haskal
/
kicad
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
kicad/eeschema/sch_plugins/cadstar/cadstar_sch_archive_loader.cpp

3071 lines
116 KiB
C++
Raw Normal View History

ADDED: CADSTAR Schematic Archive Importer Initial commit to trigger the importer
2020-09-08 19:51:22 +00:00
/*
* This program source code file is part of KiCad, a free EDA CAD application.
*
CADSTAR Importer: Update copyright years and remove white spaces
2021-01-31 20:47:36 +00:00
* Copyright (C) 2020-2021 Roberto Fernandez Bautista <roberto.fer.bau@gmail.com>
* Copyright (C) 2020-2021 KiCad Developers, see AUTHORS.txt for contributors.
ADDED: CADSTAR Schematic Archive Importer Initial commit to trigger the importer
2020-09-08 19:51:22 +00:00
*
* This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @file cadstar_sch_archive_loader.cpp
* @brief Loads a csa file into a KiCad SCHEMATIC object
*/
#include <sch_plugins/cadstar/cadstar_sch_archive_loader.h>
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR Schematic Importer: Fix loading of buses Place bus labels and correctly group nets for the bus in a BUS_ALIAS
2020-11-26 18:11:06 +00:00
#include <bus_alias.h>
Split out arrayDim and MIRROR templates from macros.h These were not macros
2020-11-18 01:21:04 +00:00
#include <core/mirror.h>
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
#include <eda_text.h>
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
#include <lib_shape.h>
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
#include <lib_text.h>
Include optimization: move some things from common.h to point-of-use
2021-03-20 15:35:37 +00:00
#include <macros.h>
Add progress reporting to CADSTAR Schematic & PCB importers Fixes https://gitlab.com/kicad/code/kicad/-/issues/8685
2021-09-09 21:15:38 +00:00
#include <progress_reporter.h>
Fix kicad_string.h / string.cpp mismatch. They don't define a KiCad string class, so the header file name was somewhat misleading. But the fact that they didn't match definitely made coding more difficult.
2021-07-29 09:56:22 +00:00
#include <string_utils.h>
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
#include <sch_bus_entry.h>
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
#include <sch_edit_frame.h> //SYMBOL_ORIENTATION_T
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
#include <sch_io_mgr.h>
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
#include <sch_junction.h>
#include <sch_line.h>
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
#include <sch_screen.h>
#include <sch_sheet.h>
CADSTAR Schematic Archive Importer: Fix Loading of page numbers Need to keep track of the hierarchy path in order to assign the page number
2020-11-22 19:55:21 +00:00
#include <sch_sheet_path.h>
Eeschema: split out SCH_SHEET_PIN declarations into separate header.
2021-04-06 21:15:49 +00:00
#include <sch_sheet_pin.h>
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
#include <sch_text.h>
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
#include <schematic.h>
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
#include <trigo.h>
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
#include <wildcards_and_files_ext.h>
ADDED: CADSTAR Schematic Archive Importer Initial commit to trigger the importer
2020-09-08 19:51:22 +00:00
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
const wxString PartNameFieldName = wxT( "Part Name" );
SCH_COMPONENT::GetField() expects a vector index, not a field id. Check this at compile time. Callers wanting to use an index now must use SCH_COMPONENT::GetFields()[i] instead. Fixes https://gitlab.com/kicad/code/kicad/issues/7757
2021-02-28 13:28:23 +00:00
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::Load( SCHEMATIC* aSchematic, SCH_SHEET* aRootSheet,
Various Coverity fixes
2020-10-27 00:25:08 +00:00
SCH_PLUGIN::SCH_PLUGIN_RELEASER* aSchPlugin, const wxFileName& aLibraryFileName )
ADDED: CADSTAR Schematic Archive Importer Initial commit to trigger the importer
2020-09-08 19:51:22 +00:00
{
Add progress reporting to CADSTAR Schematic & PCB importers Fixes https://gitlab.com/kicad/code/kicad/-/issues/8685
2021-09-09 21:15:38 +00:00
if( m_progressReporter )
m_progressReporter->SetNumPhases( 3 ); // (0) Read file, (1) Parse file, (2) Load file
ADDED: CADSTAR Schematic Archive Importer Initial commit to trigger the importer
2020-09-08 19:51:22 +00:00
Parse();
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
LONGPOINT designLimit = Assignments.Settings.DesignLimit;
//Note: can't use getKiCadPoint() due wxPoint being int - need long long to make the check
CADSTAR Schematic Archive Importer: Fix Coordinate Rounding error Rewrite of the calculation to convert CADSTAR to KiCad coordinates, rounding half way cases away from zero. Use integer division instead of double, to ensure precision.
2021-02-18 18:02:49 +00:00
long long designSizeXkicad = (long long) designLimit.x / KiCadUnitDivider;
long long designSizeYkicad = (long long) designLimit.y / KiCadUnitDivider;
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
// Max size limited by the positive dimension of wxPoint (which is an int)
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
constexpr long long maxDesignSizekicad = std::numeric_limits<int>::max();
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
if( designSizeXkicad > maxDesignSizekicad || designSizeYkicad > maxDesignSizekicad )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
{
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
THROW_IO_ERROR( wxString::Format(
_( "The design is too large and cannot be imported into KiCad. \n"
"Please reduce the maximum design size in CADSTAR by navigating to: \n"
"Design Tab -> Properties -> Design Options -> Maximum Design Size. \n"
"Current Design size: %.2f, %.2f millimeters. \n"
"Maximum permitted design size: %.2f, %.2f millimeters.\n" ),
(double) designSizeXkicad / SCH_IU_PER_MM,
(double) designSizeYkicad / SCH_IU_PER_MM,
(double) maxDesignSizekicad / SCH_IU_PER_MM,
(double) maxDesignSizekicad / SCH_IU_PER_MM ) );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
More NULL expunging.
2021-07-16 20:13:26 +00:00
// Assume the center at 0,0 since we are going to be translating the design afterwards anyway
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_designCenter = { 0, 0 };
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_schematic = aSchematic;
m_rootSheet = aRootSheet;
m_plugin = aSchPlugin;
m_libraryFileName = aLibraryFileName;
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
Add progress reporting to CADSTAR Schematic & PCB importers Fixes https://gitlab.com/kicad/code/kicad/-/issues/8685
2021-09-09 21:15:38 +00:00
if( m_progressReporter )
{
m_progressReporter->BeginPhase( 2 );
long numSteps = 11; // one step for each of below functions + one at the end of import
// Step 4 is by far the longest - add granularity in reporting
numSteps += Parts.PartDefinitions.size();
m_progressReporter->SetMaxProgress( numSteps );
}
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
loadTextVariables(); // Load text variables right at the start to ensure bounding box
// calculations work correctly for text items
Fix debug assertion in Altium and CADSTAR schematic importers.
2021-12-09 00:14:04 +00:00
checkPoint(); // Step 1
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
loadSheets();
Fix debug assertion in Altium and CADSTAR schematic importers.
2021-12-09 00:14:04 +00:00
checkPoint(); // Step 2
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
loadHierarchicalSheetPins();
Fix debug assertion in Altium and CADSTAR schematic importers.
2021-12-09 00:14:04 +00:00
checkPoint(); // Step 3
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
loadPartsLibrary();
Fix debug assertion in Altium and CADSTAR schematic importers.
2021-12-09 00:14:04 +00:00
checkPoint(); // Step 4, Subdivided into extra steps
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
loadSchematicSymbolInstances();
Fix debug assertion in Altium and CADSTAR schematic importers.
2021-12-09 00:14:04 +00:00
checkPoint(); // Step 5
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
loadBusses();
Fix debug assertion in Altium and CADSTAR schematic importers.
2021-12-09 00:14:04 +00:00
checkPoint(); // Step 6
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
loadNets();
Fix debug assertion in Altium and CADSTAR schematic importers.
2021-12-09 00:14:04 +00:00
checkPoint(); // Step 7
CADSTAR Schematic Archive Importer: Load Figures
2020-09-26 18:23:13 +00:00
loadFigures();
Fix debug assertion in Altium and CADSTAR schematic importers.
2021-12-09 00:14:04 +00:00
checkPoint(); // Step 8
CADSTAR Schematic Archive Importer: Load Texts
2020-09-27 02:35:24 +00:00
loadTexts();
Fix debug assertion in Altium and CADSTAR schematic importers.
2021-12-09 00:14:04 +00:00
checkPoint(); // Step 9
CADSTAR Schematic Archive Importer: Load Documentation Symbols
2020-09-27 12:19:51 +00:00
loadDocumentationSymbols();
Fix debug assertion in Altium and CADSTAR schematic importers.
2021-12-09 00:14:04 +00:00
checkPoint(); // Step 10
Remove kicad_string.h from eda_text.h
2020-10-14 11:03:58 +00:00
CADSTAR Schematic / PCB Archive Importers: Add missing import warnings and fix code formatting
2020-09-27 13:10:59 +00:00
if( Schematic.VariantHierarchy.Variants.size() > 0 )
{
Move importers from wxLog to REPORTER. Fixes https://gitlab.com/kicad/code/kicad/issues/6389
2021-03-31 21:33:30 +00:00
m_reporter->Report( wxString::Format( _( "The CADSTAR design contains variants which has "
"no KiCad equivalent. Only the master variant "
"('%s') was loaded." ),
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
Schematic.VariantHierarchy.Variants.at( wxT( "V0" ) ).Name ),
Move importers from wxLog to REPORTER. Fixes https://gitlab.com/kicad/code/kicad/issues/6389
2021-03-31 21:33:30 +00:00
RPT_SEVERITY_WARNING );
CADSTAR Schematic / PCB Archive Importers: Add missing import warnings and fix code formatting
2020-09-27 13:10:59 +00:00
}
Remove kicad_string.h from eda_text.h
2020-10-14 11:03:58 +00:00
CADSTAR Schematic / PCB Archive Importers: Add missing import warnings and fix code formatting
2020-09-27 13:10:59 +00:00
if( Schematic.Groups.size() > 0 )
{
Move importers from wxLog to REPORTER. Fixes https://gitlab.com/kicad/code/kicad/issues/6389
2021-03-31 21:33:30 +00:00
m_reporter->Report( _( "The CADSTAR design contains grouped items which has no KiCad "
"equivalent. Any grouped items have been ungrouped." ),
RPT_SEVERITY_WARNING );
CADSTAR Schematic / PCB Archive Importers: Add missing import warnings and fix code formatting
2020-09-27 13:10:59 +00:00
}
if( Schematic.ReuseBlocks.size() > 0 )
{
Move importers from wxLog to REPORTER. Fixes https://gitlab.com/kicad/code/kicad/issues/6389
2021-03-31 21:33:30 +00:00
m_reporter->Report( _( "The CADSTAR design contains re-use blocks which has no KiCad "
"equivalent. The re-use block information has been discarded during "
"the import." ),
RPT_SEVERITY_WARNING );
CADSTAR Schematic / PCB Archive Importers: Add missing import warnings and fix code formatting
2020-09-27 13:10:59 +00:00
}
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
More NULL expunging.
2021-07-16 20:13:26 +00:00
// For all sheets, center all elements and re calculate the page size:
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
for( std::pair<LAYER_ID, SCH_SHEET*> sheetPair : m_sheetMap )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
{
SCH_SHEET* sheet = sheetPair.second;
// Calculate the new sheet size.
EDA_RECT sheetBoundingBox;
for( auto item : sheet->GetScreen()->Items() )
CADSTAR Schematic Archive Importer: Fix positioning and margins Fix calculation of sheet bounding box and sheet margins with the aim of matching CADSTAR pdf output as closely as possible.
2021-02-04 17:48:07 +00:00
{
EDA_RECT bbox;
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
// Only use the visible fields of the symbols to calculate their bounding box
CADSTAR Schematic Archive Importer: Fix positioning and margins Fix calculation of sheet bounding box and sheet margins with the aim of matching CADSTAR pdf output as closely as possible.
2021-02-04 17:48:07 +00:00
// (hidden fields could be very long and artificially enlarge the sheet bounding box)
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
if( item->Type() == SCH_SYMBOL_T )
CADSTAR Schematic Archive Importer: Visible fields to calculate BBOX - Ensures page size is calculated correctly
2021-02-17 17:04:19 +00:00
{
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
SCH_SYMBOL* comp = static_cast<SCH_SYMBOL*>( item );
Remove pins from symbol hit-testing. Fixes https://gitlab.com/kicad/code/kicad/issues/8508
2021-09-23 21:07:19 +00:00
bbox = comp->GetBodyAndPinsBoundingBox();
CADSTAR Schematic Archive Importer: Visible fields to calculate BBOX - Ensures page size is calculated correctly
2021-02-17 17:04:19 +00:00
for( const SCH_FIELD& field : comp->GetFields() )
{
if( field.IsVisible() )
bbox.Merge( field.GetBoundingBox() );
}
}
CADSTAR Sch: Fix calculation of page size Don't attempt to calculate bounding box of text variables. We do not know the resolution of the text variable inside the importer. The resolved text could be shorter than the text variable (e.g. ${#} page number)
2021-10-30 20:46:32 +00:00
else if( item->Type() == SCH_TEXT_T )
{
SCH_TEXT* txtItem = static_cast<SCH_TEXT*>( item );
wxString txt = txtItem->GetText();
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
if( txt.Contains( wxT( "${" ) ) )
CADSTAR Sch: Fix calculation of page size Don't attempt to calculate bounding box of text variables. We do not know the resolution of the text variable inside the importer. The resolved text could be shorter than the text variable (e.g. ${#} page number)
2021-10-30 20:46:32 +00:00
continue; // We can't calculate bounding box of text items with variables
else
bbox = txtItem->GetBoundingBox();
}
CADSTAR Schematic Archive Importer: Fix positioning and margins Fix calculation of sheet bounding box and sheet margins with the aim of matching CADSTAR pdf output as closely as possible.
2021-02-04 17:48:07 +00:00
else
CADSTAR Schematic Archive Importer: Visible fields to calculate BBOX - Ensures page size is calculated correctly
2021-02-17 17:04:19 +00:00
{
CADSTAR Schematic Archive Importer: Fix positioning and margins Fix calculation of sheet bounding box and sheet margins with the aim of matching CADSTAR pdf output as closely as possible.
2021-02-04 17:48:07 +00:00
bbox = item->GetBoundingBox();
CADSTAR Schematic Archive Importer: Visible fields to calculate BBOX - Ensures page size is calculated correctly
2021-02-17 17:04:19 +00:00
}
CADSTAR Schematic Archive Importer: Fix positioning and margins Fix calculation of sheet bounding box and sheet margins with the aim of matching CADSTAR pdf output as closely as possible.
2021-02-04 17:48:07 +00:00
sheetBoundingBox.Merge( bbox );
}
CADSTAR Schematic Archive Importer: Align to original grid Previous assumption of 100mil grid in CADSTAR schematic designs has been proven to be incorrect. Let's use the "working grid" in the original design instead.
2021-02-17 17:02:57 +00:00
// Find the working grid of the original CADSTAR design
int grid = Assignments.Grids.WorkingGrid.Param1;
if( Assignments.Grids.WorkingGrid.Type == GRID_TYPE::FRACTIONALGRID )
grid = grid / Assignments.Grids.WorkingGrid.Param2;
else if( Assignments.Grids.WorkingGrid.Param2 > grid )
grid = Assignments.Grids.WorkingGrid.Param2;
grid = getKiCadLength( grid );
auto roundToNearestGrid =
[&]( int aNumber ) -> int
CADSTAR Schematic Archive Importer: Fix positioning and margins Fix calculation of sheet bounding box and sheet margins with the aim of matching CADSTAR pdf output as closely as possible.
2021-02-04 17:48:07 +00:00
{
CADSTAR Schematic Archive Importer: Align to original grid Previous assumption of 100mil grid in CADSTAR schematic designs has been proven to be incorrect. Let's use the "working grid" in the original design instead.
2021-02-17 17:02:57 +00:00
int error = aNumber % grid;
int absError = sign( error ) * error;
CADSTAR Schematic Archive Importer: Fix positioning and margins Fix calculation of sheet bounding box and sheet margins with the aim of matching CADSTAR pdf output as closely as possible.
2021-02-04 17:48:07 +00:00
CADSTAR Schematic Archive Importer: Align to original grid Previous assumption of 100mil grid in CADSTAR schematic designs has been proven to be incorrect. Let's use the "working grid" in the original design instead.
2021-02-17 17:02:57 +00:00
if( absError > ( grid / 2 ) )
return aNumber + ( sign( error ) * grid ) - error;
CADSTAR Schematic Archive Importer: Fix positioning and margins Fix calculation of sheet bounding box and sheet margins with the aim of matching CADSTAR pdf output as closely as possible.
2021-02-04 17:48:07 +00:00
else
return aNumber - error;
};
// When exporting to pdf, CADSTAR applies a margin of 3% of the longest dimension (height
// or width) to all 4 sides (top, bottom, left right). For the import, we are also rounding
CADSTAR Schematic Archive Importer: Align to original grid Previous assumption of 100mil grid in CADSTAR schematic designs has been proven to be incorrect. Let's use the "working grid" in the original design instead.
2021-02-17 17:02:57 +00:00
// the margin to the nearest grid, ensuring all items remain on the grid.
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
wxSize targetSheetSize = sheetBoundingBox.GetSize();
CADSTAR Schematic Archive Importer: Fix positioning and margins Fix calculation of sheet bounding box and sheet margins with the aim of matching CADSTAR pdf output as closely as possible.
2021-02-04 17:48:07 +00:00
int longestSide = std::max( targetSheetSize.x, targetSheetSize.y );
int margin = ( (double) longestSide * 0.03);
CADSTAR Schematic Archive Importer: Align to original grid Previous assumption of 100mil grid in CADSTAR schematic designs has been proven to be incorrect. Let's use the "working grid" in the original design instead.
2021-02-17 17:02:57 +00:00
margin = roundToNearestGrid( margin );
CADSTAR Schematic Archive Importer: Fix positioning and margins Fix calculation of sheet bounding box and sheet margins with the aim of matching CADSTAR pdf output as closely as possible.
2021-02-04 17:48:07 +00:00
targetSheetSize.IncBy( margin * 2, margin * 2 );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR Schematic Archive Importer: Fix positioning and margins Fix calculation of sheet bounding box and sheet margins with the aim of matching CADSTAR pdf output as closely as possible.
2021-02-04 17:48:07 +00:00
// Update page size always
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
PAGE_INFO pageInfo = sheet->GetScreen()->GetPageSettings();
CADSTAR Schematic Archive Importer: Fix positioning and margins Fix calculation of sheet bounding box and sheet margins with the aim of matching CADSTAR pdf output as closely as possible.
2021-02-04 17:48:07 +00:00
pageInfo.SetWidthMils( Iu2Mils( targetSheetSize.x ) );
pageInfo.SetHeightMils( Iu2Mils( targetSheetSize.y ) );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
// Set the new sheet size.
sheet->GetScreen()->SetPageSettings( pageInfo );
CADSTAR Schematic Archive Importer: Fix positioning and margins Fix calculation of sheet bounding box and sheet margins with the aim of matching CADSTAR pdf output as closely as possible.
2021-02-04 17:48:07 +00:00
wxSize pageSizeIU = sheet->GetScreen()->GetPageSettings().GetSizeIU();
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
wxPoint sheetcentre( pageSizeIU.x / 2, pageSizeIU.y / 2 );
wxPoint itemsCentre = sheetBoundingBox.Centre();
CADSTAR Schematic Archive Importer: Align to original grid Previous assumption of 100mil grid in CADSTAR schematic designs has been proven to be incorrect. Let's use the "working grid" in the original design instead.
2021-02-17 17:02:57 +00:00
// round the translation to nearest point on the grid
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
wxPoint translation = sheetcentre - itemsCentre;
CADSTAR Schematic Archive Importer: Align to original grid Previous assumption of 100mil grid in CADSTAR schematic designs has been proven to be incorrect. Let's use the "working grid" in the original design instead.
2021-02-17 17:02:57 +00:00
translation.x = roundToNearestGrid( translation.x );
translation.y = roundToNearestGrid( translation.y );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
// Translate the items.
std::vector<SCH_ITEM*> allItems;
std::copy( sheet->GetScreen()->Items().begin(), sheet->GetScreen()->Items().end(),
std::back_inserter( allItems ) );
for( SCH_ITEM* item : allItems )
{
CADSTAR Sch: Autoplace intersheet references (instead of 0,0)
2021-10-30 19:12:28 +00:00
item->Move( translation );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
item->ClearFlags();
sheet->GetScreen()->Update( item );
}
}
Add progress reporting to CADSTAR Schematic & PCB importers Fixes https://gitlab.com/kicad/code/kicad/-/issues/8685
2021-09-09 21:15:38 +00:00
checkPoint();
cadstar: Report warning that imported text may be different Fixes https://gitlab.com/kicad/code/kicad/-/issues/12195 (cherry picked from commit 69d696660b05e7d77adf085e2dbf045c7542e65c)
2022-08-14 20:13:27 +00:00
m_reporter->Report( _( "CADSTAR fonts are different to the ones in KiCad. This will likely "
"result in alignment issues. Please review the imported text elements "
"carefully and correct manually if required." ),
RPT_SEVERITY_WARNING );
Move importers from wxLog to REPORTER. Fixes https://gitlab.com/kicad/code/kicad/issues/6389
2021-03-31 21:33:30 +00:00
m_reporter->Report( _( "The CADSTAR design has been imported successfully.\n"
"Please review the import errors and warnings (if any)." ) );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
}
void CADSTAR_SCH_ARCHIVE_LOADER::loadSheets()
{
const std::vector<LAYER_ID>& orphanSheets = findOrphanSheets();
CADSTAR Schematic Archive Importer: Fix Loading of page numbers Need to keep track of the hierarchy path in order to assign the page number
2020-11-22 19:55:21 +00:00
SCH_SHEET_PATH rootPath;
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
rootPath.push_back( m_rootSheet );
Eeschema: fix broken page numbers when renaming a sheet file name. Always use full sheet paths when storing sheet instances. Partial sheet paths cannot be full resolved resulting in lost page numbers when renaming sheet file name. Fixes #9782
2021-12-08 18:36:23 +00:00
m_rootSheet->AddInstance( rootPath );
Revert "Eeschema: fix broken page numbers when renaming a sheet file name." This reverts commit a468a79948a544aa3313b20a101b7c92dcfe3375.
2021-12-06 12:47:18 +00:00
m_rootSheet->SetPageNumber( rootPath, wxT( "1" ) );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
if( orphanSheets.size() > 1 )
{
int x = 1;
int y = 1;
for( LAYER_ID sheetID : orphanSheets )
{
wxPoint pos( x * Mils2iu( 1000 ), y * Mils2iu( 1000 ) );
wxSize siz( Mils2iu( 1000 ), Mils2iu( 1000 ) );
CADSTAR Schematic Archive Importer: Fix Loading of page numbers Need to keep track of the hierarchy path in order to assign the page number
2020-11-22 19:55:21 +00:00
loadSheetAndChildSheets( sheetID, pos, siz, rootPath );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
x += 2;
if( x > 10 ) // start next row
{
x = 1;
y += 2;
}
}
}
else if( orphanSheets.size() > 0 )
{
LAYER_ID rootSheetID = orphanSheets.at( 0 );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
wxFileName loadedFilePath = wxFileName( Filename );
std::string filename = wxString::Format(
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
wxT( "%s_%02d" ), loadedFilePath.GetName(), getSheetNumber( rootSheetID ) )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
.ToStdString();
ReplaceIllegalFileNameChars( &filename );
filename += wxT( "." ) + KiCadSchematicFileExtension;
CADSTAR Schematic: Fix assert regarding sheet absolute path
2021-05-28 16:06:22 +00:00
wxFileName fn( m_schematic->Prj().GetProjectPath() + filename );
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_rootSheet->GetScreen()->SetFileName( fn.GetFullPath() );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_sheetMap.insert( { rootSheetID, m_rootSheet } );
CADSTAR Schematic Archive Importer: Fix Loading of page numbers Need to keep track of the hierarchy path in order to assign the page number
2020-11-22 19:55:21 +00:00
loadChildSheets( rootSheetID, rootPath );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
}
else
{
THROW_IO_ERROR( _( "The CADSTAR schematic might be corrupt: there is no root sheet." ) );
}
}
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::loadHierarchicalSheetPins()
{
for( std::pair<BLOCK_ID, BLOCK> blockPair : Schematic.Blocks )
{
BLOCK& block = blockPair.second;
LAYER_ID sheetID = "";
if( block.Type == BLOCK::TYPE::PARENT )
sheetID = block.LayerID;
else if( block.Type == BLOCK::TYPE::CHILD )
sheetID = block.AssocLayerID;
else
continue;
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
if( m_sheetMap.find( sheetID ) != m_sheetMap.end() )
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
{
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
SCH_SHEET* sheet = m_sheetMap.at( sheetID );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
for( std::pair<TERMINAL_ID, TERMINAL> termPair : block.Terminals )
{
TERMINAL term = termPair.second;
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
wxString name = wxT( "YOU SHOULDN'T SEE THIS TEXT. THIS IS A BUG." );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
SCH_HIERLABEL* sheetPin = nullptr;
if( block.Type == BLOCK::TYPE::PARENT )
sheetPin = new SCH_HIERLABEL();
else if( block.Type == BLOCK::TYPE::CHILD )
sheetPin = new SCH_SHEET_PIN( sheet );
sheetPin->SetText( name );
sheetPin->SetShape( PINSHEETLABEL_SHAPE::PS_UNSPECIFIED );
sheetPin->SetLabelSpinStyle( getSpinStyle( term.OrientAngle, false ) );
sheetPin->SetPosition( getKiCadPoint( term.Position ) );
if( sheetPin->Type() == SCH_SHEET_PIN_T )
sheet->AddPin( (SCH_SHEET_PIN*) sheetPin );
else
sheet->GetScreen()->Append( sheetPin );
BLOCK_PIN_ID blockPinID = std::make_pair( block.ID, term.ID );
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_sheetPinMap.insert( { blockPinID, sheetPin } );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
}
}
}
}
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::loadPartsLibrary()
{
for( std::pair<PART_ID, PART> partPair : Parts.PartDefinitions )
{
CADSTAR Schematic: Fix loading of symbol instances differing from part The previous assumption was that a part definition would always hold the information about the symbol. However some designs have symbol instances that refer to a different symbol definition than that specified in the part. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7808
2021-03-28 18:47:48 +00:00
PART_ID partID = partPair.first;
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
PART part = partPair.second;
if( part.Definition.GateSymbols.size() == 0 )
continue;
CADSTAR Schematic: Ensure library ID is valid Previously the library created was invalid - opening it resulted in a parsing error due to invalid characters in the name.
2021-09-01 19:24:59 +00:00
wxString escapedPartName = EscapeString( part.Name, CTX_LIBID );
LIB_SYMBOL* kiPart = new LIB_SYMBOL( escapedPartName );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
kiPart->SetUnitCount( part.Definition.GateSymbols.size() );
CADSTAR Schematic: Fix loading of symbol instances differing from part The previous assumption was that a part definition would always hold the information about the symbol. However some designs have symbol instances that refer to a different symbol definition than that specified in the part. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7808
2021-03-28 18:47:48 +00:00
bool ok = true;
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
for( std::pair<GATE_ID, PART::DEFINITION::GATE> gatePair : part.Definition.GateSymbols )
{
GATE_ID gateID = gatePair.first;
PART::DEFINITION::GATE gate = gatePair.second;
SYMDEF_ID symbolID = getSymDefFromName( gate.Name, gate.Alternate );
CADSTAR Schematic: Fix loading of symbol instances differing from part The previous assumption was that a part definition would always hold the information about the symbol. However some designs have symbol instances that refer to a different symbol definition than that specified in the part. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7808
2021-03-28 18:47:48 +00:00
m_partSymbolsMap.insert( { { partID, gateID }, symbolID } );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
if( symbolID.IsEmpty() )
{
Move importers from wxLog to REPORTER. Fixes https://gitlab.com/kicad/code/kicad/issues/6389
2021-03-31 21:33:30 +00:00
m_reporter->Report( wxString::Format( _( "Part definition '%s' references symbol "
"'%s' (alternate '%s') which could not be "
"found in the symbol library. The part has "
"not been loaded into the KiCad library." ),
part.Name,
gate.Name,
gate.Alternate ),
RPT_SEVERITY_WARNING);
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR Schematic: Fix loading of symbol instances differing from part The previous assumption was that a part definition would always hold the information about the symbol. However some designs have symbol instances that refer to a different symbol definition than that specified in the part. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7808
2021-03-28 18:47:48 +00:00
ok = false;
break;
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
loadSymDefIntoLibrary( symbolID, &part, gateID, kiPart );
}
CADSTAR Schematic: Fix loading of symbol instances differing from part The previous assumption was that a part definition would always hold the information about the symbol. However some designs have symbol instances that refer to a different symbol definition than that specified in the part. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7808
2021-03-28 18:47:48 +00:00
if( ok )
{
( *m_plugin )->SaveSymbol( m_libraryFileName.GetFullPath(), kiPart );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
LIB_SYMBOL* loadedPart =
CADSTAR Schematic: Fix loading of symbol instances differing from part The previous assumption was that a part definition would always hold the information about the symbol. However some designs have symbol instances that refer to a different symbol definition than that specified in the part. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7808
2021-03-28 18:47:48 +00:00
( *m_plugin )->LoadSymbol( m_libraryFileName.GetFullPath(), kiPart->GetName() );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR Schematic: Fix loading of symbol instances differing from part The previous assumption was that a part definition would always hold the information about the symbol. However some designs have symbol instances that refer to a different symbol definition than that specified in the part. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7808
2021-03-28 18:47:48 +00:00
m_partMap.insert( { partID, loadedPart } );
}
else
{
// Don't save in the library, but still keep it cached as some of the units might have
// been loaded correctly (saving us time later on)
m_partMap.insert( { partID, kiPart } );
}
Add progress reporting to CADSTAR Schematic & PCB importers Fixes https://gitlab.com/kicad/code/kicad/-/issues/8685
2021-09-09 21:15:38 +00:00
checkPoint();
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
}
void CADSTAR_SCH_ARCHIVE_LOADER::loadSchematicSymbolInstances()
{
for( std::pair<SYMBOL_ID, SYMBOL> symPair : Schematic.Symbols )
{
SYMBOL sym = symPair.second;
CADSTAR Archive Importer: Only load the Master variant
2020-11-21 12:55:58 +00:00
if( !sym.VariantID.empty() && sym.VariantParentSymbolID != sym.ID )
continue; // Only load master Variant
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
if( sym.IsComponent )
{
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
if( m_partMap.find( sym.PartRef.RefID ) == m_partMap.end() )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
{
Move importers from wxLog to REPORTER. Fixes https://gitlab.com/kicad/code/kicad/issues/6389
2021-03-31 21:33:30 +00:00
m_reporter->Report( wxString::Format( _( "Symbol '%s' references part '%s' which "
"could not be found in the library. The "
"symbol was not loaded" ),
sym.ComponentRef.Designator,
sym.PartRef.RefID ),
RPT_SEVERITY_ERROR);
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
continue;
}
CADSTAR Schematic: Fix duplicate pins Fixes a bug that was causing duplicate pins to be loaded (one on top of the other) for all symbols.
2021-03-29 15:00:28 +00:00
if( sym.GateID.IsEmpty() )
sym.GateID = wxT( "A" ); // Assume Gate "A" if unspecified
CADSTAR Schematic: Fix loading of symbol instances differing from part The previous assumption was that a part definition would always hold the information about the symbol. However some designs have symbol instances that refer to a different symbol definition than that specified in the part. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7808
2021-03-28 18:47:48 +00:00
PART_GATE_ID partSymbolID = { sym.PartRef.RefID, sym.GateID };
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
LIB_SYMBOL* kiPart = m_partMap.at( sym.PartRef.RefID );
CADSTAR Schematic: Fix loading of symbol instances differing from part The previous assumption was that a part definition would always hold the information about the symbol. However some designs have symbol instances that refer to a different symbol definition than that specified in the part. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7808
2021-03-28 18:47:48 +00:00
bool copy = false;
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR Schematic: Fix loading of symbol instances differing from part The previous assumption was that a part definition would always hold the information about the symbol. However some designs have symbol instances that refer to a different symbol definition than that specified in the part. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7808
2021-03-28 18:47:48 +00:00
// The symbol definition in the part either does not exist for this gate number
// or is different to the symbol instance. We need to load a new symbol
if( m_partSymbolsMap.find( partSymbolID ) == m_partSymbolsMap.end()
|| m_partSymbolsMap.at( partSymbolID ) != sym.SymdefID )
{
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
kiPart = new LIB_SYMBOL( *kiPart ); // Make a copy
CADSTAR Schematic: Fix loading of symbol instances differing from part The previous assumption was that a part definition would always hold the information about the symbol. However some designs have symbol instances that refer to a different symbol definition than that specified in the part. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7808
2021-03-28 18:47:48 +00:00
copy = true;
const PART& part = Parts.PartDefinitions.at( sym.PartRef.RefID );
loadSymDefIntoLibrary( sym.SymdefID, &part, sym.GateID, kiPart );
}
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
LIB_SYMBOL* scaledPart = getScaledLibPart( kiPart, sym.ScaleRatioNumerator,
More NULL expunging.
2021-07-16 20:13:26 +00:00
sym.ScaleRatioDenominator );
CADSTAR Schematic: Handle scaled symbols Create a new LIB_PART for scaled symbols. These will be then embedded into the schematic file. However when "update from library" is done, it will revert to the unscaled symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/8494
2021-05-28 15:19:04 +00:00
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
double symOrientDeciDeg = 0.0;
SCH_SYMBOL* symbol = loadSchematicSymbol( sym, *scaledPart, symOrientDeciDeg );
CADSTAR Schematic: Handle scaled symbols Create a new LIB_PART for scaled symbols. These will be then embedded into the schematic file. However when "update from library" is done, it will revert to the unscaled symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/8494
2021-05-28 15:19:04 +00:00
delete scaledPart;
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR Schematic: Fix loading of symbol instances differing from part The previous assumption was that a part definition would always hold the information about the symbol. However some designs have symbol instances that refer to a different symbol definition than that specified in the part. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7808
2021-03-28 18:47:48 +00:00
if( copy )
delete kiPart;
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
SCH_FIELD* refField = symbol->GetField( REFERENCE_FIELD );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
sym.ComponentRef.Designator.Replace( wxT( "\n" ), wxT( "\\n" ) );
sym.ComponentRef.Designator.Replace( wxT( "\r" ), wxT( "\\r" ) );
sym.ComponentRef.Designator.Replace( wxT( "\t" ), wxT( "\\t" ) );
sym.ComponentRef.Designator.Replace( wxT( " " ), wxT( "_" ) );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
refField->SetText( sym.ComponentRef.Designator );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
loadSymbolFieldAttribute( sym.ComponentRef.AttrLoc, symOrientDeciDeg,
sym.Mirror, refField );
if( sym.HasPartRef )
{
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
SCH_FIELD* partField = symbol->FindField( PartNameFieldName );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
if( !partField )
{
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
int fieldID = symbol->GetFieldCount();
partField = symbol->AddField( SCH_FIELD( wxPoint(), fieldID, symbol,
PartNameFieldName ) );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
}
CADSTAR Schematic: Fix loading of symbol attributes Fixes an issue that resulted in incorrect field values being loaded
2021-03-28 18:03:11 +00:00
wxASSERT( partField->GetName() == PartNameFieldName );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
wxString partname = getPart( sym.PartRef.RefID ).Name;
partname.Replace( wxT( "\n" ), wxT( "\\n" ) );
partname.Replace( wxT( "\r" ), wxT( "\\r" ) );
partname.Replace( wxT( "\t" ), wxT( "\\t" ) );
partField->SetText( partname );
loadSymbolFieldAttribute( sym.PartRef.AttrLoc, symOrientDeciDeg,
sym.Mirror, partField );
CADSTAR Schematic Archive Importer: Import common fields visibilities Import field visibilities for Ref, Value and Part Name Also fix incorrect loading of designator from previous commit
2021-02-02 13:39:40 +00:00
partField->SetVisible( SymbolPartNameColor.IsVisible );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
}
for( auto attr : sym.AttributeValues )
{
ATTRIBUTE_VALUE attrVal = attr.second;
if( attrVal.HasLocation )
{
wxString attrName = getAttributeName( attrVal.AttributeID );
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
SCH_FIELD* attrField = symbol->FindField( attrName );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
if( !attrField )
{
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
int fieldID = symbol->GetFieldCount();
attrField = symbol->AddField( SCH_FIELD( wxPoint(), fieldID,
symbol, attrName ) );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
}
CADSTAR Schematic: Fix loading of symbol attributes Fixes an issue that resulted in incorrect field values being loaded
2021-03-28 18:03:11 +00:00
wxASSERT( attrField->GetName() == attrName );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
attrVal.Value.Replace( wxT( "\n" ), wxT( "\\n" ) );
attrVal.Value.Replace( wxT( "\r" ), wxT( "\\r" ) );
attrVal.Value.Replace( wxT( "\t" ), wxT( "\\t" ) );
attrField->SetText( attrVal.Value );
loadSymbolFieldAttribute( attrVal.AttributeLocation, symOrientDeciDeg,
sym.Mirror, attrField );
attrField->SetVisible( isAttributeVisible( attrVal.AttributeID ) );
}
}
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
else if( sym.IsSymbolVariant )
{
if( Library.SymbolDefinitions.find( sym.SymdefID ) == Library.SymbolDefinitions.end() )
{
THROW_IO_ERROR( wxString::Format(
_( "Symbol ID '%s' references library symbol '%s' which could not be "
"found in the library. Did you export all items of the design?" ),
sym.ID, sym.PartRef.RefID ) );
}
SYMDEF_SCM libSymDef = Library.SymbolDefinitions.at( sym.SymdefID );
if( libSymDef.Terminals.size() != 1 )
{
THROW_IO_ERROR( wxString::Format(
_( "Symbol ID '%s' is a signal reference or global signal but it has too "
"many pins. The expected number of pins is 1 but %d were found." ),
sym.ID, libSymDef.Terminals.size() ) );
}
if( sym.SymbolVariant.Type == SYMBOLVARIANT::TYPE::GLOBALSIGNAL )
{
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
SYMDEF_ID symID = sym.SymdefID;
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
LIB_SYMBOL* kiPart = nullptr;
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR PCB Archive Importer: Re-write loading of power symbols Ensure all each power symbol is unique for each net name even if it uses the same graphical symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7722
2021-02-26 18:37:59 +00:00
// In CADSTAR "GlobalSignal" is a special type of symbol which defines
// a Power Symbol. The "Alternate" name defines the default net name of
Fix source comment / documentation typos
2021-06-09 19:32:58 +00:00
// the power symbol but this can be overridden in the design itself.
CADSTAR PCB Archive Importer: Re-write loading of power symbols Ensure all each power symbol is unique for each net name even if it uses the same graphical symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7722
2021-02-26 18:37:59 +00:00
wxString libraryNetName = Library.SymbolDefinitions.at( symID ).Alternate;
// Name of the net that the symbol instance in CADSTAR refers to:
wxString symbolInstanceNetName = sym.SymbolVariant.Reference;
Escape "naughty" characters in symbol names. It's tempting to say that we don't need to exclude filename chars from symbols, but we might regret that decision down the road. Better to just escape them. Fixes https://gitlab.com/kicad/code/kicad/issues/8694
2021-06-30 10:53:04 +00:00
symbolInstanceNetName = EscapeString( symbolInstanceNetName, CTX_LIBID );
CADSTAR PCB Archive Importer: Re-write loading of power symbols Ensure all each power symbol is unique for each net name even if it uses the same graphical symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7722
2021-02-26 18:37:59 +00:00
// Name of the symbol we will use for saving the part in KiCad
// Note: In CADSTAR all power symbols will start have the reference name be
// "GLOBALSIGNAL" followed by the default net name, so it makes sense to save
// the symbol in KiCad as the default net name as well.
wxString libPartName = libraryNetName;
// In CADSTAR power symbol instances can refer to a different net to that defined
// in the library. This causes problems in KiCad v6 as it breaks connectivity when
// the user decides to update all symbols from library. We handle this by creating
// individual versions of the power symbol for each net name.
if( libPartName != symbolInstanceNetName )
{
libPartName += wxT( " (" ) + symbolInstanceNetName + wxT( ")" );
}
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR PCB Archive Importer: Re-write loading of power symbols Ensure all each power symbol is unique for each net name even if it uses the same graphical symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7722
2021-02-26 18:37:59 +00:00
if( m_powerSymLibMap.find( libPartName ) == m_powerSymLibMap.end() )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
{
CADSTAR PCB Archive Importer: Re-write loading of power symbols Ensure all each power symbol is unique for each net name even if it uses the same graphical symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7722
2021-02-26 18:37:59 +00:00
SYMDEF_SCM symbolDef = Library.SymbolDefinitions.at( symID );
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
kiPart = new LIB_SYMBOL( libPartName );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
kiPart->SetPower();
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
loadSymDefIntoLibrary( symID, nullptr, wxT( "A" ), kiPart );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
CADSTAR PCB Archive Importer: Re-write loading of power symbols Ensure all each power symbol is unique for each net name even if it uses the same graphical symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7722
2021-02-26 18:37:59 +00:00
kiPart->GetValueField().SetText( symbolInstanceNetName );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
if( symbolDef.TextLocations.find( SIGNALNAME_ORIGIN_ATTRID )
!= symbolDef.TextLocations.end() )
{
CADSTAR PCB Archive Importer: Re-write loading of power symbols Ensure all each power symbol is unique for each net name even if it uses the same graphical symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7722
2021-02-26 18:37:59 +00:00
TEXT_LOCATION txtLoc =
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
symbolDef.TextLocations.at( SIGNALNAME_ORIGIN_ATTRID );
CADSTAR PCB Archive Importer: Re-write loading of power symbols Ensure all each power symbol is unique for each net name even if it uses the same graphical symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7722
2021-02-26 18:37:59 +00:00
wxPoint valPos = getKiCadLibraryPoint( txtLoc.Position, symbolDef.Origin );
kiPart->GetValueField().SetPosition( valPos );
CADSTAR Schematic Archive Importer: Import common fields visibilities Import field visibilities for Ref, Value and Part Name Also fix incorrect loading of designator from previous commit
2021-02-02 13:39:40 +00:00
kiPart->GetValueField().SetVisible( true );
}
else
{
kiPart->GetValueField().SetVisible( false );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
}
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
kiPart->GetReferenceField().SetText( wxT( "#PWR" ) );
CADSTAR Schematic Archive Importer: Import common fields visibilities Import field visibilities for Ref, Value and Part Name Also fix incorrect loading of designator from previous commit
2021-02-02 13:39:40 +00:00
kiPart->GetReferenceField().SetVisible( false );
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
( *m_plugin )->SaveSymbol( m_libraryFileName.GetFullPath(), kiPart );
CADSTAR PCB Archive Importer: Re-write loading of power symbols Ensure all each power symbol is unique for each net name even if it uses the same graphical symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7722
2021-02-26 18:37:59 +00:00
m_powerSymLibMap.insert( { libPartName, kiPart } );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
else
{
CADSTAR PCB Archive Importer: Re-write loading of power symbols Ensure all each power symbol is unique for each net name even if it uses the same graphical symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/7722
2021-02-26 18:37:59 +00:00
kiPart = m_powerSymLibMap.at( libPartName );
wxASSERT( kiPart->GetValueField().GetText() == symbolInstanceNetName );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
LIB_SYMBOL* scaledPart = getScaledLibPart( kiPart, sym.ScaleRatioNumerator,
sym.ScaleRatioDenominator );
CADSTAR Schematic: Handle scaled symbols Create a new LIB_PART for scaled symbols. These will be then embedded into the schematic file. However when "update from library" is done, it will revert to the unscaled symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/8494
2021-05-28 15:19:04 +00:00
double returnedOrient = 0.0;
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
SCH_SYMBOL* symbol = loadSchematicSymbol( sym, *scaledPart, returnedOrient );
m_powerSymMap.insert( { sym.ID, symbol } );
CADSTAR Schematic: Handle scaled symbols Create a new LIB_PART for scaled symbols. These will be then embedded into the schematic file. However when "update from library" is done, it will revert to the unscaled symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/8494
2021-05-28 15:19:04 +00:00
delete scaledPart;
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
else if( sym.SymbolVariant.Type == SYMBOLVARIANT::TYPE::SIGNALREF )
{
// There should only be one pin and we'll use that to set the position
CADSTAR Schematic Archive Importer: Fix positioning of global labels Previous calculation did not take into account rotation of the labels when calculating the final position.
2021-02-04 17:51:27 +00:00
TERMINAL& symbolTerminal = libSymDef.Terminals.begin()->second;
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
wxPoint terminalPosOffset = symbolTerminal.Position - libSymDef.Origin;
CADSTAR Schematic Archive Importer: Fix positioning of global labels Previous calculation did not take into account rotation of the labels when calculating the final position.
2021-02-04 17:51:27 +00:00
double rotateDeciDegree = getAngleTenthDegree( sym.OrientAngle );
if( sym.Mirror )
rotateDeciDegree += 1800.0;
RotatePoint( &terminalPosOffset, -rotateDeciDegree );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
SCH_GLOBALLABEL* netLabel = new SCH_GLOBALLABEL;
netLabel->SetPosition( getKiCadPoint( sym.Origin + terminalPosOffset ) );
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
netLabel->SetText( wxT( "***UNKNOWN NET****" ) ); // This should be later updated when we load the netlist
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
netLabel->SetTextSize( wxSize( Mils2iu( 50 ), Mils2iu( 50 ) ) );
CADSTAR Schematic: Load text sizes for pin names/numbers and net labels
2021-09-01 19:12:56 +00:00
SYMDEF_SCM symbolDef = Library.SymbolDefinitions.at( sym.SymdefID );
if( symbolDef.TextLocations.count( LINK_ORIGIN_ATTRID ) )
{
TEXT_LOCATION linkOrigin = symbolDef.TextLocations.at( LINK_ORIGIN_ATTRID );
applyTextSettings( netLabel, linkOrigin.TextCodeID, linkOrigin.Alignment,
linkOrigin.Justification );
}
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
netLabel->SetLabelSpinStyle( getSpinStyle( sym.OrientAngle, sym.Mirror ) );
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
if( libSymDef.Alternate.Lower().Contains( wxT( "in" ) ) )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
netLabel->SetShape( PINSHEETLABEL_SHAPE::PS_INPUT );
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
else if( libSymDef.Alternate.Lower().Contains( wxT( "bi" ) ) )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
netLabel->SetShape( PINSHEETLABEL_SHAPE::PS_BIDI );
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
else if( libSymDef.Alternate.Lower().Contains( wxT( "out" ) ) )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
netLabel->SetShape( PINSHEETLABEL_SHAPE::PS_OUTPUT );
else
netLabel->SetShape( PINSHEETLABEL_SHAPE::PS_UNSPECIFIED );
CADSTAR Sch: Autoplace intersheet references (instead of 0,0)
2021-10-30 19:12:28 +00:00
SCH_SCREEN* screen = m_sheetMap.at( sym.LayerID )->GetScreen();
// autoplace intersheet refs
netLabel->AutoplaceFields( screen, false );
screen->Append( netLabel );
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_globalLabelsMap.insert( { sym.ID, netLabel } );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
else
{
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
wxASSERT_MSG( false, wxT( "Unknown Symbol Variant." ) );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
}
else
{
Move importers from wxLog to REPORTER. Fixes https://gitlab.com/kicad/code/kicad/issues/6389
2021-03-31 21:33:30 +00:00
m_reporter->Report( wxString::Format( _( "Symbol ID '%s' is of an unknown type. It is "
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
"neither a symbol or a net power / symbol. "
Move importers from wxLog to REPORTER. Fixes https://gitlab.com/kicad/code/kicad/issues/6389
2021-03-31 21:33:30 +00:00
"The symbol was not loaded." ),
sym.ID ),
RPT_SEVERITY_ERROR );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
CADSTAR Schematic Archive Importer: Parse SCALE token in Symbol and warn user this is not supported Fixes https://gitlab.com/kicad/code/kicad/-/issues/6463
2020-11-23 20:54:34 +00:00
if( sym.ScaleRatioDenominator != 1 || sym.ScaleRatioNumerator != 1 )
{
wxString symbolName = sym.ComponentRef.Designator;
if( symbolName.empty() )
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
symbolName = wxString::Format( wxT( "ID: %s" ), sym.ID );
CADSTAR sch: Include gate in error message when symbols are scaled
2021-10-30 19:11:49 +00:00
else
symbolName += sym.GateID;
CADSTAR Schematic Archive Importer: Parse SCALE token in Symbol and warn user this is not supported Fixes https://gitlab.com/kicad/code/kicad/-/issues/6463
2020-11-23 20:54:34 +00:00
Move importers from wxLog to REPORTER. Fixes https://gitlab.com/kicad/code/kicad/issues/6389
2021-03-31 21:33:30 +00:00
m_reporter->Report( wxString::Format( _( "Symbol '%s' is scaled in the original "
"CADSTAR schematic but this is not supported "
CADSTAR Schematic: Handle scaled symbols Create a new LIB_PART for scaled symbols. These will be then embedded into the schematic file. However when "update from library" is done, it will revert to the unscaled symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/8494
2021-05-28 15:19:04 +00:00
"in KiCad. When the symbol is reloaded from "
"the library, it will revert to the original "
"1:1 scale." ),
Move importers from wxLog to REPORTER. Fixes https://gitlab.com/kicad/code/kicad/issues/6389
2021-03-31 21:33:30 +00:00
symbolName,
sym.PartRef.RefID ),
RPT_SEVERITY_ERROR );
CADSTAR Schematic Archive Importer: Parse SCALE token in Symbol and warn user this is not supported Fixes https://gitlab.com/kicad/code/kicad/-/issues/6463
2020-11-23 20:54:34 +00:00
}
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
}
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::loadBusses()
{
for( std::pair<BUS_ID, BUS> busPair : Schematic.Buses )
{
BUS bus = busPair.second;
bool firstPt = true;
VERTEX last;
CADSTAR Schematic Importer: Fix loading of buses Place bus labels and correctly group nets for the bus in a BUS_ALIAS
2020-11-26 18:11:06 +00:00
if( bus.LayerID != wxT( "NO_SHEET" ) )
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
{
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
SCH_SCREEN* screen = m_sheetMap.at( bus.LayerID )->GetScreen();
CADSTAR Schematic Importer: Fix loading of buses Place bus labels and correctly group nets for the bus in a BUS_ALIAS
2020-11-26 18:11:06 +00:00
std::shared_ptr<BUS_ALIAS> kiBusAlias = std::make_shared<BUS_ALIAS>();
kiBusAlias->SetName( bus.Name );
kiBusAlias->SetParent( screen );
screen->AddBusAlias( kiBusAlias );
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_busesMap.insert( { bus.ID, kiBusAlias } );
CADSTAR Schematic Importer: Fix loading of buses Place bus labels and correctly group nets for the bus in a BUS_ALIAS
2020-11-26 18:11:06 +00:00
SCH_LABEL* label = new SCH_LABEL();
Fix issues with new overbar syntax - Update sch text help (~~ no longer gets converted to single ~) - Update Eagle importer to correctly handle new overbar syntax - Update CADSTAR importer to correctly handle new overbar syntax
2021-09-01 18:24:42 +00:00
wxString busname = HandleTextOverbar( bus.Name );
label->SetText( wxT( "{" ) + busname + wxT( "}" ) );
CADSTAR Schematic Importer: Fix loading of buses Place bus labels and correctly group nets for the bus in a BUS_ALIAS
2020-11-26 18:11:06 +00:00
label->SetVisible( true );
screen->Append( label );
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
CADSTAR Schematic Importer: Fix loading of buses Place bus labels and correctly group nets for the bus in a BUS_ALIAS
2020-11-26 18:11:06 +00:00
SHAPE_LINE_CHAIN busLineChain; // to compute nearest segment to bus label
for( const VERTEX& cur : bus.Shape.Vertices )
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
{
CADSTAR Schematic Importer: Fix loading of buses Place bus labels and correctly group nets for the bus in a BUS_ALIAS
2020-11-26 18:11:06 +00:00
busLineChain.Append( getKiCadPoint( cur.End ) );
if( firstPt )
{
last = cur;
firstPt = false;
if( !bus.HasBusLabel )
{
// Add a bus label on the starting point if the original CADSTAR design
// does not have an explicit label
label->SetPosition( getKiCadPoint( last.End ) );
}
continue;
}
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
SCH_LINE* kiBus = new SCH_LINE();
kiBus->SetStartPoint( getKiCadPoint( last.End ) );
kiBus->SetEndPoint( getKiCadPoint( cur.End ) );
kiBus->SetLayer( LAYER_BUS );
kiBus->SetLineWidth( getLineThickness( bus.LineCodeID ) );
CADSTAR Schematic Importer: Fix loading of buses Place bus labels and correctly group nets for the bus in a BUS_ALIAS
2020-11-26 18:11:06 +00:00
screen->Append( kiBus );
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
last = cur;
CADSTAR Schematic Importer: Fix loading of buses Place bus labels and correctly group nets for the bus in a BUS_ALIAS
2020-11-26 18:11:06 +00:00
}
if( bus.HasBusLabel )
{
//lets find the closest point in the busline to the label
VECTOR2I busLabelLoc = getKiCadPoint( bus.BusLabel.Position );
wxPoint nearestPt = (wxPoint) busLineChain.NearestPoint( busLabelLoc );
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
CADSTAR Schematic Importer: Fix loading of buses Place bus labels and correctly group nets for the bus in a BUS_ALIAS
2020-11-26 18:11:06 +00:00
label->SetPosition( nearestPt );
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
applyTextSettings( label,
bus.BusLabel.TextCodeID,
bus.BusLabel.Alignment,
bus.BusLabel.Justification );
Fix issues with new overbar syntax - Update sch text help (~~ no longer gets converted to single ~) - Update Eagle importer to correctly handle new overbar syntax - Update CADSTAR importer to correctly handle new overbar syntax
2021-09-01 18:24:42 +00:00
// Re-set bus name as it might have been "double-escaped" after applyTextSettings
label->SetText( wxT( "{" ) + busname + wxT( "}" ) );
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
// Note orientation of the bus label will be determined in loadNets
// (the position of the wire will determine how best to place the bus label)
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
}
}
CADSTAR Schematic Importer: Fix loading of buses Place bus labels and correctly group nets for the bus in a BUS_ALIAS
2020-11-26 18:11:06 +00:00
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
}
}
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::loadNets()
{
for( std::pair<NET_ID, NET_SCH> netPair : Schematic.Nets )
{
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
NET_SCH net = netPair.second;
wxString netName = net.Name;
std::map<NETELEMENT_ID, SCH_LABEL*> netlabels;
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
if( netName.IsEmpty() )
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
netName = wxString::Format( wxT( "$%ld" ), net.SignalNum );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
Fix issues with new overbar syntax - Update sch text help (~~ no longer gets converted to single ~) - Update Eagle importer to correctly handle new overbar syntax - Update CADSTAR importer to correctly handle new overbar syntax
2021-09-01 18:24:42 +00:00
netName = HandleTextOverbar( netName );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
for( std::pair<NETELEMENT_ID, NET_SCH::SYM_TERM> terminalPair : net.Terminals )
{
NET_SCH::SYM_TERM netTerm = terminalPair.second;
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
if( m_powerSymMap.find( netTerm.SymbolID ) != m_powerSymMap.end() )
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
{
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
SCH_FIELD* val = m_powerSymMap.at( netTerm.SymbolID )->GetField( VALUE_FIELD );
CADSTAR Schematic Archive Importer: Load signal name even if no net label (global labels and power symbols) Fixes error that prevented global net names from being loaded properly
2020-12-29 23:38:51 +00:00
val->SetText( netName );
val->SetBold( false );
val->SetVisible( false );
if( netTerm.HasNetLabel )
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
{
CADSTAR Schematic Archive Importer: Load signal name even if no net label (global labels and power symbols) Fixes error that prevented global net names from being loaded properly
2020-12-29 23:38:51 +00:00
val->SetVisible( true );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
val->SetPosition( getKiCadPoint( netTerm.NetLabel.Position ) );
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
applyTextSettings( val,
netTerm.NetLabel.TextCodeID,
netTerm.NetLabel.Alignment,
netTerm.NetLabel.Justification,
netTerm.NetLabel.OrientAngle,
netTerm.NetLabel.Mirror );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
}
}
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
else if( m_globalLabelsMap.find( netTerm.SymbolID ) != m_globalLabelsMap.end() )
CADSTAR Schematic Archive Importer: Load signal name even if no net label (global labels and power symbols) Fixes error that prevented global net names from being loaded properly
2020-12-29 23:38:51 +00:00
{
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_globalLabelsMap.at( netTerm.SymbolID )->SetText( netName );
CADSTAR Sch: Autoplace intersheet references (instead of 0,0)
2021-10-30 19:12:28 +00:00
LAYER_ID sheet = Schematic.Symbols.at( netTerm.SymbolID ).LayerID;
if( m_sheetMap.count( sheet ) )
{
SCH_SCREEN* screen = m_sheetMap.at( sheet )->GetScreen();
// autoplace intersheet refs again since we've changed the name
m_globalLabelsMap.at( netTerm.SymbolID )->AutoplaceFields( screen, false );
}
CADSTAR Schematic Archive Importer: Load signal name even if no net label (global labels and power symbols) Fixes error that prevented global net names from being loaded properly
2020-12-29 23:38:51 +00:00
}
CADSTAR Schematic: Add net labels for named nets on symbol pins Fixes https://gitlab.com/kicad/code/kicad/-/issues/9371
2021-10-11 17:29:17 +00:00
else if( !net.Name.IsEmpty() && Schematic.Symbols.count( netTerm.SymbolID )
&& netTerm.HasNetLabel )
{
// This is a named net that connects to a schematic symbol pin - we need to put a label
SCH_LABEL* label = new SCH_LABEL();
label->SetText( netName );
POINT pinLocation = getLocationOfNetElement( net, netTerm.ID );
label->SetPosition( getKiCadPoint( pinLocation ) );
label->SetVisible( true );
applyTextSettings( label, netTerm.NetLabel.TextCodeID, netTerm.NetLabel.Alignment,
netTerm.NetLabel.Justification );
netlabels.insert( { netTerm.ID, label } );
LAYER_ID sheet = Schematic.Symbols.at( netTerm.SymbolID ).LayerID;
m_sheetMap.at( sheet )->GetScreen()->Append( label );
}
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
}
CADSTAR Schematic: Fix orientation of net labels and sheet pins
2021-03-24 12:04:26 +00:00
auto getHierarchicalLabel =
[&]( NETELEMENT_ID aNode ) -> SCH_HIERLABEL*
{
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
if( aNode.Contains( wxT( "BLKT" ) ) )
CADSTAR Schematic: Fix orientation of net labels and sheet pins
2021-03-24 12:04:26 +00:00
{
NET_SCH::BLOCK_TERM blockTerm = net.BlockTerminals.at( aNode );
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
BLOCK_PIN_ID blockPinID = std::make_pair( blockTerm.BlockID,
blockTerm.TerminalID );
CADSTAR Schematic: Fix orientation of net labels and sheet pins
2021-03-24 12:04:26 +00:00
if( m_sheetPinMap.find( blockPinID )
!= m_sheetPinMap.end() )
{
return m_sheetPinMap.at( blockPinID );
}
}
return nullptr;
};
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
//Add net name to all hierarchical pins (block terminals in CADSTAR)
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
for( std::pair<NETELEMENT_ID, NET_SCH::BLOCK_TERM> blockPair : net.BlockTerminals )
{
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
SCH_HIERLABEL* label = getHierarchicalLabel( blockPair.first );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
Fix issues with new overbar syntax - Update sch text help (~~ no longer gets converted to single ~) - Update Eagle importer to correctly handle new overbar syntax - Update CADSTAR importer to correctly handle new overbar syntax
2021-09-01 18:24:42 +00:00
if( label )
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
label->SetText( netName );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
}
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
// Load all bus entries and add net label if required
for( std::pair<NETELEMENT_ID, NET_SCH::BUS_TERM> busPair : net.BusTerminals )
{
NET_SCH::BUS_TERM busTerm = busPair.second;
BUS bus = Schematic.Buses.at( busTerm.BusID );
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
if( !m_busesMap.at( bus.ID )->Contains( netName ) )
m_busesMap.at( bus.ID )->AddMember( netName );
CADSTAR Schematic Importer: Fix loading of buses Place bus labels and correctly group nets for the bus in a BUS_ALIAS
2020-11-26 18:11:06 +00:00
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
SCH_BUS_WIRE_ENTRY* busEntry =
new SCH_BUS_WIRE_ENTRY( getKiCadPoint( busTerm.FirstPoint ), false );
wxPoint size =
getKiCadPoint( busTerm.SecondPoint ) - getKiCadPoint( busTerm.FirstPoint );
busEntry->SetSize( wxSize( size.x, size.y ) );
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_sheetMap.at( bus.LayerID )->GetScreen()->Append( busEntry );
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
CADSTAR Schematic: Ensure connectivity with tiny labels at Bus Entries Always add a label at bus terminals to ensure connectivity. The original design might already have a bus terminal with a given location. If the original design does not have a label, just make it very small to keep connectivity but make the design look visually similar to the original.
2021-02-19 12:38:47 +00:00
// Always add a label at bus terminals to ensure connectivity.
// If the original design does not have a label, just make it very small
// to keep connectivity but make the design look visually similar to
// the original.
SCH_LABEL* label = new SCH_LABEL();
label->SetText( netName );
label->SetPosition( getKiCadPoint( busTerm.SecondPoint ) );
label->SetVisible( true );
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
if( busTerm.HasNetLabel )
{
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
applyTextSettings( label,
busTerm.NetLabel.TextCodeID,
busTerm.NetLabel.Alignment,
busTerm.NetLabel.Justification );
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
}
CADSTAR Schematic: Ensure connectivity with tiny labels at Bus Entries Always add a label at bus terminals to ensure connectivity. The original design might already have a bus terminal with a given location. If the original design does not have a label, just make it very small to keep connectivity but make the design look visually similar to the original.
2021-02-19 12:38:47 +00:00
else
{
CADSTAR Schematic: Load text sizes for pin names/numbers and net labels
2021-09-01 19:12:56 +00:00
label->SetTextSize( wxSize( SMALL_LABEL_SIZE, SMALL_LABEL_SIZE ) );
CADSTAR Schematic: Ensure connectivity with tiny labels at Bus Entries Always add a label at bus terminals to ensure connectivity. The original design might already have a bus terminal with a given location. If the original design does not have a label, just make it very small to keep connectivity but make the design look visually similar to the original.
2021-02-19 12:38:47 +00:00
}
netlabels.insert( { busTerm.ID, label } );
m_sheetMap.at( bus.LayerID )->GetScreen()->Append( label );
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
}
for( std::pair<NETELEMENT_ID, NET_SCH::DANGLER> danglerPair : net.Danglers )
{
NET_SCH::DANGLER dangler = danglerPair.second;
SCH_LABEL* label = new SCH_LABEL();
label->SetPosition( getKiCadPoint( dangler.Position ) );
label->SetVisible( true );
CADSTAR Schematic: Load text sizes for pin names/numbers and net labels
2021-09-01 19:12:56 +00:00
if( dangler.HasNetLabel )
{
applyTextSettings( label,
dangler.NetLabel.TextCodeID,
dangler.NetLabel.Alignment,
dangler.NetLabel.Justification );
}
label->SetText( netName ); // set text after applying settings to avoid double-escaping
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
netlabels.insert( { dangler.ID, label } );
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_sheetMap.at( dangler.LayerID )->GetScreen()->Append( label );
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
}
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
for( NET_SCH::CONNECTION_SCH conn : net.Connections )
{
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
if( conn.LayerID == wxT( "NO_SHEET" ) )
continue; // No point loading virtual connections. KiCad handles that internally
CADSTAR Schematic Archive Importer: Fix wires (Implied connections) There is an implied connection between elements in a net even though there might not be a graphical connection in the file.
2021-02-04 17:50:21 +00:00
POINT start = getLocationOfNetElement( net, conn.StartNode );
POINT end = getLocationOfNetElement( net, conn.EndNode );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
CADSTAR Schematic Archive Importer: Fix wires (Implied connections) There is an implied connection between elements in a net even though there might not be a graphical connection in the file.
2021-02-04 17:50:21 +00:00
if( start.x == UNDEFINED_VALUE || end.x == UNDEFINED_VALUE )
continue;
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
// Connections in CADSTAR are always implied between symbols even if the route
CADSTAR Schematic Archive Importer: Fix wires (Implied connections) There is an implied connection between elements in a net even though there might not be a graphical connection in the file.
2021-02-04 17:50:21 +00:00
// doesn't start and end exactly at the connection points
if( conn.Path.size() < 1 || conn.Path.front() != start )
conn.Path.insert( conn.Path.begin(), start );
if( conn.Path.size() < 2 || conn.Path.back() != end )
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
conn.Path.push_back( end );
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
bool firstPt = true;
bool secondPt = false;
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
wxPoint last;
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
SCH_LINE* wire = nullptr;
Fix a minor compil warning
2020-11-29 11:57:29 +00:00
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
SHAPE_LINE_CHAIN wireChain; // Create a temp. line chain representing the connection
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
for( POINT pt : conn.Path )
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
{
wireChain.Append( getKiCadPoint( pt ) );
}
// AUTO-FIX SHEET PINS
//--------------------
// KiCad constrains the sheet pin on the edge of the sheet object whereas in
// CADSTAR it can be anywhere. Let's find the intersection of the wires with the sheet
// and place the hierarchical
std::vector<NETELEMENT_ID> nodes;
nodes.push_back( conn.StartNode );
nodes.push_back( conn.EndNode );
for( NETELEMENT_ID node : nodes )
{
SCH_HIERLABEL* sheetPin = getHierarchicalLabel( node );
if( sheetPin )
{
if( sheetPin->Type() == SCH_SHEET_PIN_T
&& SCH_SHEET::ClassOf( sheetPin->GetParent() ) )
{
SCH_SHEET* parentSheet = static_cast<SCH_SHEET*>( sheetPin->GetParent() );
wxSize sheetSize = parentSheet->GetSize();
wxPoint sheetPosition = parentSheet->GetPosition();
int leftSide = sheetPosition.x;
int rightSide = sheetPosition.x + sheetSize.x;
int topSide = sheetPosition.y;
int botSide = sheetPosition.y + sheetSize.y;
SHAPE_LINE_CHAIN sheetEdge;
sheetEdge.Append( leftSide, topSide );
sheetEdge.Append( rightSide, topSide );
sheetEdge.Append( rightSide, botSide );
sheetEdge.Append( leftSide, botSide );
sheetEdge.Append( leftSide, topSide );
SHAPE_LINE_CHAIN::INTERSECTIONS wireToSheetIntersects;
if( !wireChain.Intersect( sheetEdge, wireToSheetIntersects ) )
{
Fix a minor compil warning
2020-11-29 11:57:29 +00:00
// The block terminal is outside the block shape in the original
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
// CADSTAR design. Since KiCad's Sheet Pin will already be constrained
// on the edge, we will simply join to it with a straight line.
if( node == conn.StartNode )
wireChain = wireChain.Reverse();
wireChain.Append( sheetPin->GetPosition() );
Fix a minor compil warning
2020-11-29 11:57:29 +00:00
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
if( node == conn.StartNode )
wireChain = wireChain.Reverse();
}
else
{
More NULL expunging.
2021-07-16 20:13:26 +00:00
// The block terminal is either inside or on the shape edge. Lets use
// the first intersection point.
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
VECTOR2I intsctPt = wireToSheetIntersects.at( 0 ).p;
int intsctIndx = wireChain.FindSegment( intsctPt );
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
wxASSERT_MSG( intsctIndx != -1, wxT( "Can't find intersecting segment" ) );
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
if( node == conn.StartNode )
wireChain.Replace( 0, intsctIndx, intsctPt );
else
wireChain.Replace( intsctIndx + 1, /*end index*/ -1, intsctPt );
sheetPin->SetPosition( (wxPoint) intsctPt );
}
}
}
}
CADSTAR Schematic: Fix orientation of net labels and sheet pins
2021-03-24 12:04:26 +00:00
auto fixNetLabelsAndSheetPins =
[&]( double aWireAngleDeciDeg, NETELEMENT_ID& aNetEleID )
{
LABEL_SPIN_STYLE spin = getSpinStyleDeciDeg( aWireAngleDeciDeg );
if( netlabels.find( aNetEleID ) != netlabels.end() )
CADSTAR Schematic: Increase "tiny" bus labels to 0.4mm text size Also fix incorrect label orientation
2021-03-25 19:10:49 +00:00
netlabels.at( aNetEleID )->SetLabelSpinStyle( spin.MirrorY() );
CADSTAR Schematic: Fix orientation of net labels and sheet pins
2021-03-24 12:04:26 +00:00
SCH_HIERLABEL* sheetPin = getHierarchicalLabel( aNetEleID );
if( sheetPin )
sheetPin->SetLabelSpinStyle( spin.MirrorX() );
};
// Now we can load the wires and fix the label orientations
Fixup memory lifespan of GAL options for the settings preview canvas The canvas keeps a reference to the settings object, so we can't pass one from the stack because it runs into lifetime issues. Also cleanup some loop-iterator problems. Fixes https://gitlab.com/kicad/code/kicad/issues/6338
2020-12-01 01:10:58 +00:00
for( const VECTOR2I& pt : wireChain.CPoints() )
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
{
if( firstPt )
{
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
last = (wxPoint) pt;
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
firstPt = false;
secondPt = true;
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
continue;
}
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
if( secondPt )
{
secondPt = false;
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
CADSTAR Schematic: Fix orientation of net labels and sheet pins
2021-03-24 12:04:26 +00:00
wxPoint kiLast = last;
wxPoint kiCurrent = (wxPoint) pt;
double wireangleDeciDeg = getPolarAngle( kiLast - kiCurrent );
fixNetLabelsAndSheetPins( wireangleDeciDeg, conn.StartNode );
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
}
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
wire = new SCH_LINE();
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
wire->SetStartPoint( last );
wire->SetEndPoint( (wxPoint) pt );
wire->SetLayer( LAYER_WIRE );
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
if( !conn.ConnectionLineCode.IsEmpty() )
wire->SetLineWidth( getLineThickness( conn.ConnectionLineCode ) );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
last = (wxPoint) pt;
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_sheetMap.at( conn.LayerID )->GetScreen()->Append( wire );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
}
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
CADSTAR Schematic Archive Importer: Fix loading of Schematic Sheet Pins and Orientation of Labels - Find the intersection between the wire and the sheet and place the sheet pin there - Fix orientation of hierarchical labels and global labels by applying opposite orientation to the connecting wire
2020-11-27 18:05:57 +00:00
//Fix labels on the end wire
if( wire )
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
{
CADSTAR Schematic: Fix orientation of net labels and sheet pins
2021-03-24 12:04:26 +00:00
wxPoint kiLast = wire->GetEndPoint();
wxPoint kiCurrent = wire->GetStartPoint();
double wireangleDeciDeg = getPolarAngle( kiLast - kiCurrent );
fixNetLabelsAndSheetPins( wireangleDeciDeg, conn.EndNode );
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
}
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
}
CADSTAR Schematic Archive Importer: Fix SIGLOC in JPT (Load labels in junctions) Fixes but that refused to open file with a SIGLOC node in JPT
2020-12-29 19:38:16 +00:00
for( std::pair<NETELEMENT_ID, NET_SCH::JUNCTION_SCH> juncPair : net.Junctions )
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
{
CADSTAR Schematic Archive Importer: Fix SIGLOC in JPT (Load labels in junctions) Fixes but that refused to open file with a SIGLOC node in JPT
2020-12-29 19:38:16 +00:00
NET_SCH::JUNCTION_SCH junc = juncPair.second;
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
SCH_JUNCTION* kiJunc = new SCH_JUNCTION();
kiJunc->SetPosition( getKiCadPoint( junc.Location ) );
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_sheetMap.at( junc.LayerID )->GetScreen()->Append( kiJunc );
CADSTAR Schematic Archive Importer: Fix SIGLOC in JPT (Load labels in junctions) Fixes but that refused to open file with a SIGLOC node in JPT
2020-12-29 19:38:16 +00:00
if( junc.HasNetLabel )
{
// In CADSTAR the label can be placed anywhere, but in KiCad it has to be placed
// in the same location as the junction for it to be connected to it.
SCH_LABEL* label = new SCH_LABEL();
label->SetText( netName );
label->SetPosition( getKiCadPoint( junc.Location ) );
label->SetVisible( true );
double labelAngleDeciDeg = getAngleTenthDegree( junc.NetLabel.OrientAngle );
LABEL_SPIN_STYLE spin = getSpinStyleDeciDeg( labelAngleDeciDeg );
label->SetLabelSpinStyle( spin );
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_sheetMap.at( junc.LayerID )->GetScreen()->Append( label );
CADSTAR Schematic Archive Importer: Fix SIGLOC in JPT (Load labels in junctions) Fixes but that refused to open file with a SIGLOC node in JPT
2020-12-29 19:38:16 +00:00
}
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
}
}
}
CADSTAR Schematic Archive Importer: Load Figures
2020-09-26 18:23:13 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::loadFigures()
{
for( std::pair<FIGURE_ID, FIGURE> figPair : Schematic.Figures )
{
FIGURE fig = figPair.second;
CADSTAR Schematic Archive Importer: Load Texts
2020-09-27 02:35:24 +00:00
loadFigure( fig, fig.LayerID, LAYER_NOTES );
}
}
CADSTAR Schematic Archive Importer: Load Figures
2020-09-26 18:23:13 +00:00
CADSTAR Schematic Archive Importer: Load Texts
2020-09-27 02:35:24 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::loadTexts()
{
for( std::pair<TEXT_ID, TEXT> textPair : Schematic.Texts )
{
TEXT txt = textPair.second;
SCH_TEXT* kiTxt = getKiCadSchText( txt );
loadItemOntoKiCadSheet( txt.LayerID, kiTxt );
CADSTAR Schematic Archive Importer: Load Figures
2020-09-26 18:23:13 +00:00
}
}
CADSTAR Schematic Archive Importer: Load Documentation Symbols
2020-09-27 12:19:51 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::loadDocumentationSymbols()
{
for( std::pair<DOCUMENTATION_SYMBOL_ID, DOCUMENTATION_SYMBOL> docSymPair :
Schematic.DocumentationSymbols )
{
DOCUMENTATION_SYMBOL docSym = docSymPair.second;
if( Library.SymbolDefinitions.find( docSym.SymdefID ) == Library.SymbolDefinitions.end() )
{
Move importers from wxLog to REPORTER. Fixes https://gitlab.com/kicad/code/kicad/issues/6389
2021-03-31 21:33:30 +00:00
m_reporter->Report( wxString::Format( _( "Documentation Symbol '%s' refers to symbol "
"definition ID '%s' which does not exist in "
"the library. The symbol was not loaded." ),
docSym.ID,
docSym.SymdefID ),
RPT_SEVERITY_ERROR );
CADSTAR Schematic Archive Importer: Load Documentation Symbols
2020-09-27 12:19:51 +00:00
continue;
}
SYMDEF_SCM docSymDef = Library.SymbolDefinitions.at( docSym.SymdefID );
wxPoint moveVector = getKiCadPoint( docSym.Origin ) - getKiCadPoint( docSymDef.Origin );
double rotationAngle = getAngleTenthDegree( docSym.OrientAngle );
double scalingFactor =
(double) docSym.ScaleRatioNumerator / (double) docSym.ScaleRatioDenominator;
wxPoint centreOfTransform = getKiCadPoint( docSymDef.Origin );
bool mirrorInvert = docSym.Mirror;
for( std::pair<FIGURE_ID, FIGURE> figPair : docSymDef.Figures )
{
FIGURE fig = figPair.second;
loadFigure( fig, docSym.LayerID, LAYER_NOTES, moveVector, rotationAngle, scalingFactor,
More NULL expunging.
2021-07-16 20:13:26 +00:00
centreOfTransform, mirrorInvert );
CADSTAR Schematic Archive Importer: Load Documentation Symbols
2020-09-27 12:19:51 +00:00
}
for( std::pair<TEXT_ID, TEXT> textPair : docSymDef.Texts )
{
TEXT txt = textPair.second;
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
txt.Mirror = ( txt.Mirror ) ? !mirrorInvert : mirrorInvert;
txt.OrientAngle = docSym.OrientAngle - txt.OrientAngle;
CADSTAR Schematic Archive Importer: Load Documentation Symbols
2020-09-27 12:19:51 +00:00
SCH_TEXT* kiTxt = getKiCadSchText( txt );
wxPoint newPosition = applyTransform( kiTxt->GetPosition(), moveVector, rotationAngle,
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
scalingFactor, centreOfTransform, mirrorInvert );
CADSTAR Schematic Archive Importer: Load Documentation Symbols
2020-09-27 12:19:51 +00:00
int newTxtWidth = KiROUND( kiTxt->GetTextWidth() * scalingFactor );
int newTxtHeight = KiROUND( kiTxt->GetTextHeight() * scalingFactor );
int newTxtThickness = KiROUND( kiTxt->GetTextThickness() * scalingFactor );
kiTxt->SetPosition( newPosition );
kiTxt->SetTextWidth( newTxtWidth );
kiTxt->SetTextHeight( newTxtHeight );
kiTxt->SetTextThickness( newTxtThickness );
loadItemOntoKiCadSheet( docSym.LayerID, kiTxt );
}
}
}
CADSTAR Schematic Archive Importer: Load Schematic Text Variables to KiCad project
2020-12-13 17:28:00 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::loadTextVariables()
{
auto findAndReplaceTextField = [&]( TEXT_FIELD_NAME aField, wxString aValue ) {
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
if( m_context.TextFieldToValuesMap.find( aField ) != m_context.TextFieldToValuesMap.end() )
CADSTAR Schematic Archive Importer: Load Schematic Text Variables to KiCad project
2020-12-13 17:28:00 +00:00
{
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
if( m_context.TextFieldToValuesMap.at( aField ) != aValue )
CADSTAR Schematic Archive Importer: Load Schematic Text Variables to KiCad project
2020-12-13 17:28:00 +00:00
{
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_context.TextFieldToValuesMap.at( aField ) = aValue;
m_context.InconsistentTextFields.insert( aField );
CADSTAR Schematic Archive Importer: Load Schematic Text Variables to KiCad project
2020-12-13 17:28:00 +00:00
return false;
}
}
else
{
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_context.TextFieldToValuesMap.insert( { aField, aValue } );
CADSTAR Schematic Archive Importer: Load Schematic Text Variables to KiCad project
2020-12-13 17:28:00 +00:00
}
return true;
};
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
PROJECT* pj = &m_schematic->Prj();
CADSTAR Schematic Archive Importer: Load Schematic Text Variables to KiCad project
2020-12-13 17:28:00 +00:00
if( pj )
{
std::map<wxString, wxString>& txtVars = pj->GetTextVars();
// Most of the design text fields can be derived from other elements
if( Schematic.VariantHierarchy.Variants.size() > 0 )
{
VARIANT loadedVar = Schematic.VariantHierarchy.Variants.begin()->second;
findAndReplaceTextField( TEXT_FIELD_NAME::VARIANT_NAME, loadedVar.Name );
findAndReplaceTextField( TEXT_FIELD_NAME::VARIANT_DESCRIPTION, loadedVar.Description );
}
findAndReplaceTextField( TEXT_FIELD_NAME::DESIGN_TITLE, Header.JobTitle );
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
for( std::pair<TEXT_FIELD_NAME, wxString> txtvalue : m_context.TextFieldToValuesMap )
CADSTAR Schematic Archive Importer: Load Schematic Text Variables to KiCad project
2020-12-13 17:28:00 +00:00
{
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
wxString varName = CADSTAR_TO_KICAD_FIELDS.at( txtvalue.first );
CADSTAR Schematic Archive Importer: Load Schematic Text Variables to KiCad project
2020-12-13 17:28:00 +00:00
wxString varValue = txtvalue.second;
txtVars.insert( { varName, varValue } );
}
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
for( std::pair<wxString, wxString> txtvalue : m_context.FilenamesToTextMap )
CADSTAR Schematic Archive Importer: Load Schematic Text Variables to KiCad project
2020-12-13 17:28:00 +00:00
{
wxString varName = txtvalue.first;
wxString varValue = txtvalue.second;
txtVars.insert( { varName, varValue } );
}
}
else
{
Move importers from wxLog to REPORTER. Fixes https://gitlab.com/kicad/code/kicad/issues/6389
2021-03-31 21:33:30 +00:00
m_reporter->Report( _( "Text Variables could not be set as there is no project attached." ),
RPT_SEVERITY_ERROR );
CADSTAR Schematic Archive Importer: Load Schematic Text Variables to KiCad project
2020-12-13 17:28:00 +00:00
}
}
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::loadSymDefIntoLibrary( const SYMDEF_ID& aSymdefID,
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
const PART* aCadstarPart, const GATE_ID& aGateID, LIB_SYMBOL* aSymbol )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
{
wxCHECK( Library.SymbolDefinitions.find( aSymdefID ) != Library.SymbolDefinitions.end(), );
SYMDEF_SCM symbol = Library.SymbolDefinitions.at( aSymdefID );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
int gateNumber = getKiCadUnitNumberFromGate( aGateID );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR Sch: Clear symbol of all elements before overwriting with new one Fixes https://gitlab.com/kicad/code/kicad/-/issues/11378 (cherry picked from commit 85f6ff48e75f38f957542c719f5384522670f1e5)
2022-04-12 20:33:52 +00:00
// Ensure there are no items on this unit (e.g. if we already previously loaded the symbol from
// the part definition)
std::vector<LIB_ITEM*> drawItems = aSymbol->GetUnitDrawItems( gateNumber, 0 );
for( LIB_ITEM* item : drawItems )
aSymbol->RemoveDrawItem( item );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
for( std::pair<FIGURE_ID, FIGURE> figPair : symbol.Figures )
{
FIGURE fig = figPair.second;
CADSTAR Schematic: Load line thickness in symbols
2021-08-29 18:55:47 +00:00
int lineThickness = getLineThickness( fig.LineCodeID );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR Schematic: Load line thickness in symbols
2021-08-29 18:55:47 +00:00
loadLibrarySymbolShapeVertices( fig.Shape.Vertices, symbol.Origin, aSymbol, gateNumber,
lineThickness );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
for( CUTOUT c : fig.Shape.Cutouts )
{
CADSTAR Schematic: Load line thickness in symbols
2021-08-29 18:55:47 +00:00
loadLibrarySymbolShapeVertices( c.Vertices, symbol.Origin, aSymbol, gateNumber,
lineThickness );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
}
CADSTAR Schematic Archive Importer: Handle Pin Swaps Each schematic symbol instance can have pin numbers that diverge from the pin number definitions in the library
2021-02-03 20:06:41 +00:00
TERMINAL_TO_PINNUM_MAP pinNumMap;
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
for( std::pair<TERMINAL_ID, TERMINAL> termPair : symbol.Terminals )
{
TERMINAL term = termPair.second;
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
wxString pinNum = wxString::Format( wxT( "%ld" ), term.ID );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
wxString pinName = wxEmptyString;
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
LIB_PIN* pin = new LIB_PIN( aSymbol );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
if( aCadstarPart )
{
PART::DEFINITION::PIN csPin = getPartDefinitionPin( *aCadstarPart, aGateID, term.ID );
Fix issues with new overbar syntax - Update sch text help (~~ no longer gets converted to single ~) - Update Eagle importer to correctly handle new overbar syntax - Update CADSTAR importer to correctly handle new overbar syntax
2021-09-01 18:24:42 +00:00
pinName = HandleTextOverbar( csPin.Label );
pinNum = HandleTextOverbar( csPin.Name );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR PCB Archive Importer: Correctly load the pad numbers as per the original design To load the pad numbers correctly we need to also check the PART DEFINITION for each component
2020-11-18 23:26:27 +00:00
if( pinNum.IsEmpty() )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
{
if( !csPin.Identifier.IsEmpty() )
CADSTAR PCB Archive Importer: Correctly load the pad numbers as per the original design To load the pad numbers correctly we need to also check the PART DEFINITION for each component
2020-11-18 23:26:27 +00:00
pinNum = csPin.Identifier;
CADSTAR Schematic Archive Importer: Handle undefined pin number in part Use terminal pin number (i.e. from the symbol definition) when the pin number is undefined in the part. This fixes a bug that resulted in symbols with "0" as the pin numbers.
2021-02-02 15:35:45 +00:00
else if( csPin.ID == UNDEFINED_VALUE )
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
pinNum = wxString::Format( wxT( "%ld" ), term.ID );
CADSTAR PCB Archive Importer: Correctly load the pad numbers as per the original design To load the pad numbers correctly we need to also check the PART DEFINITION for each component
2020-11-18 23:26:27 +00:00
else
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
pinNum = wxString::Format( wxT( "%ld" ), csPin.ID );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
CADSTAR Schematic Archive Importer: Load pin types Default to passive if undefined
2021-02-02 15:37:10 +00:00
pin->SetType( getKiCadPinType( csPin.Type ) );
CADSTAR Schematic Archive Importer: Handle Pin Swaps Each schematic symbol instance can have pin numbers that diverge from the pin number definitions in the library
2021-02-03 20:06:41 +00:00
pinNumMap.insert( { term.ID, pinNum } );
CADSTAR Schematic Archive Importer: Load pin types Default to passive if undefined
2021-02-02 15:37:10 +00:00
}
else
{
// If no part is defined, we don't know the pin type. Assume passive pin
pin->SetType( ELECTRICAL_PINTYPE::PT_PASSIVE );
}
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
pin->SetPosition( getKiCadLibraryPoint( term.Position, symbol.Origin ) );
pin->SetLength( 0 ); //CADSTAR Pins are just a point (have no length)
pin->SetShape( GRAPHIC_PINSHAPE::LINE );
pin->SetUnit( gateNumber );
pin->SetNumber( pinNum );
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
pin->SetName( pinName );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR Schematic: Load text sizes for pin names/numbers and net labels
2021-09-01 19:12:56 +00:00
int pinNumberHeight = getTextHeightFromTextCode( wxT( "TC0" ) ); // TC0 is the default CADSTAR text size for name/number
int pinNameHeight = getTextHeightFromTextCode( wxT( "TC0" ) );
if( symbol.PinNumberLocations.count( term.ID ) )
{
PIN_NUM_LABEL_LOC pinNumLocation = symbol.PinNumberLocations.at( term.ID );
pinNumberHeight = getTextHeightFromTextCode( pinNumLocation.TextCodeID );
}
if( symbol.PinLabelLocations.count( term.ID ) )
{
PIN_NUM_LABEL_LOC pinNameLocation = symbol.PinLabelLocations.at( term.ID );
pinNameHeight = getTextHeightFromTextCode( pinNameLocation.TextCodeID );
}
pin->SetNumberTextSize( pinNumberHeight );
pin->SetNameTextSize( pinNameHeight );
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
if( aSymbol->IsPower() )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
{
pin->SetVisible( false );
pin->SetType( ELECTRICAL_PINTYPE::PT_POWER_IN );
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
pin->SetName( aSymbol->GetName() );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
aSymbol->AddDrawItem( pin );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
fixUpLibraryPins( aSymbol, gateNumber );
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
CADSTAR Schematic Archive Importer: Handle Pin Swaps Each schematic symbol instance can have pin numbers that diverge from the pin number definitions in the library
2021-02-03 20:06:41 +00:00
if(aCadstarPart)
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_pinNumsMap.insert( { aCadstarPart->ID + aGateID, pinNumMap } );
CADSTAR Schematic Archive Importer: Handle Pin Swaps Each schematic symbol instance can have pin numbers that diverge from the pin number definitions in the library
2021-02-03 20:06:41 +00:00
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
for( std::pair<TEXT_ID, TEXT> textPair : symbol.Texts )
{
CADSTAR Schematic: Fix Text Positioning within Symbols
2021-04-09 19:11:12 +00:00
TEXT csText = textPair.second;
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
LIB_TEXT* libtext = new LIB_TEXT( aSymbol );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
libtext->SetText( csText.Text );
libtext->SetUnit( gateNumber );
libtext->SetPosition( getKiCadLibraryPoint( csText.Position, symbol.Origin ) );
CADSTAR Schematic: Fix Text Positioning within Symbols
2021-04-09 19:11:12 +00:00
libtext->SetMultilineAllowed( true ); // temporarily so that we calculate bbox correctly
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
applyTextSettings( libtext,
csText.TextCodeID,
csText.Alignment,
csText.Justification,
csText.OrientAngle,
csText.Mirror );
CADSTAR Schematic: Fix Text Positioning within Symbols
2021-04-09 19:11:12 +00:00
// Split out multi line text items into individual text elements
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
if( csText.Text.Contains( wxT( "\n" ) ) )
CADSTAR Schematic: Fix Text Positioning within Symbols
2021-04-09 19:11:12 +00:00
{
wxArrayString strings;
wxStringSplit( csText.Text, strings, '\n' );
wxPoint firstLinePos;
Fix a minor compil warning
2021-04-15 17:47:06 +00:00
for( size_t ii = 0; ii < strings.size(); ++ii )
CADSTAR Schematic: Fix Text Positioning within Symbols
2021-04-09 19:11:12 +00:00
{
EDA_RECT bbox = libtext->GetTextBox( ii, true );
wxPoint linePos = { bbox.GetLeft(), -bbox.GetBottom() };
RotatePoint( &linePos, libtext->GetTextPos(), -libtext->GetTextAngle() );
LIB_TEXT* line = static_cast<LIB_TEXT*>( libtext->Clone() );
line->SetText( strings[ii] );
line->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
line->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
line->SetTextPos( linePos );
// Multiline text not allowed in LIB_TEXT
line->SetMultilineAllowed( false );
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
aSymbol->AddDrawItem( line );
CADSTAR Schematic: Fix Text Positioning within Symbols
2021-04-09 19:11:12 +00:00
}
delete libtext;
}
else
{
// Multiline text not allowed in LIB_TEXT
libtext->SetMultilineAllowed( false );
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
aSymbol->AddDrawItem( libtext );
CADSTAR Schematic: Fix Text Positioning within Symbols
2021-04-09 19:11:12 +00:00
}
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
if( symbol.TextLocations.find( SYMBOL_NAME_ATTRID ) != symbol.TextLocations.end() )
{
TEXT_LOCATION textLoc = symbol.TextLocations.at( SYMBOL_NAME_ATTRID );
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
LIB_FIELD* field = &aSymbol->GetReferenceField();
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
applyToLibraryFieldAttribute( textLoc, symbol.Origin, field );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
field->SetUnit( gateNumber );
}
CADSTAR Schematic Archive Importer: Import common fields visibilities Import field visibilities for Ref, Value and Part Name Also fix incorrect loading of designator from previous commit
2021-02-02 13:39:40 +00:00
// Hide the value field for now (it might get unhidden if an attribute exists in the cadstar
// design with the text "Value"
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
aSymbol->GetValueField().SetVisible( false );
CADSTAR Schematic Archive Importer: Import common fields visibilities Import field visibilities for Ref, Value and Part Name Also fix incorrect loading of designator from previous commit
2021-02-02 13:39:40 +00:00
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
if( symbol.TextLocations.find( PART_NAME_ATTRID ) != symbol.TextLocations.end() )
{
TEXT_LOCATION textLoc = symbol.TextLocations.at( PART_NAME_ATTRID );
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
LIB_FIELD* field = aSymbol->FindField( PartNameFieldName );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
if( !field )
{
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
int fieldID = aSymbol->GetFieldCount();
field = new LIB_FIELD( aSymbol, fieldID );
CADSTAR Schematic: Fix loading of symbol attributes Fixes an issue that resulted in incorrect field values being loaded
2021-03-28 18:03:11 +00:00
field->SetName( PartNameFieldName );
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
aSymbol->AddField( field );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
CADSTAR Schematic: Fix loading of symbol attributes Fixes an issue that resulted in incorrect field values being loaded
2021-03-28 18:03:11 +00:00
wxASSERT( field->GetName() == PartNameFieldName );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
applyToLibraryFieldAttribute( textLoc, symbol.Origin, field );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
if( aCadstarPart )
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
{
wxString partName = aCadstarPart->Name;
partName.Replace( wxT( "\n" ), wxT( "\\n" ) );
partName.Replace( wxT( "\r" ), wxT( "\\r" ) );
partName.Replace( wxT( "\t" ), wxT( "\\t" ) );
field->SetText( partName );
}
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
field->SetUnit( gateNumber );
CADSTAR Schematic Archive Importer: Import common fields visibilities Import field visibilities for Ref, Value and Part Name Also fix incorrect loading of designator from previous commit
2021-02-02 13:39:40 +00:00
field->SetVisible( SymbolPartNameColor.IsVisible );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
if( aCadstarPart )
{
wxString footprintRefName = wxEmptyString;
wxString footprintAlternateName = wxEmptyString;
auto loadLibraryField =
[&]( ATTRIBUTE_VALUE& aAttributeVal )
{
CADSTAR Schematic: Fix loading of symbol attributes Fixes an issue that resulted in incorrect field values being loaded
2021-03-28 18:03:11 +00:00
wxString attrName = getAttributeName( aAttributeVal.AttributeID );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
// Remove invalid field characters
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
aAttributeVal.Value.Replace( wxT( "\n" ), wxT( "\\n" ) );
aAttributeVal.Value.Replace( wxT( "\r" ), wxT( "\\r" ) );
aAttributeVal.Value.Replace( wxT( "\t" ), wxT( "\\t" ) );
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
//TODO: Handle "links": In cadstar a field can be a "link" if its name starts
// with the characters "Link ". Need to figure out how to convert them to
// equivalent in KiCad.
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
if( attrName == wxT( "(PartDefinitionNameStem)" ) )
{
//Space not allowed in Reference field
aAttributeVal.Value.Replace( wxT( " " ), "_" );
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
aSymbol->GetReferenceField().SetText( aAttributeVal.Value );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
return;
}
else if( attrName == wxT( "(PartDescription)" ) )
{
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
aSymbol->SetDescription( aAttributeVal.Value );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
return;
}
else if( attrName == wxT( "(PartDefinitionReferenceName)" ) )
{
footprintRefName = aAttributeVal.Value;
return;
}
else if( attrName == wxT( "(PartDefinitionAlternateName)" ) )
{
footprintAlternateName = aAttributeVal.Value;
return;
}
CADSTAR Schematic: Fix loading of symbol attributes Fixes an issue that resulted in incorrect field values being loaded
2021-03-28 18:03:11 +00:00
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
LIB_FIELD* attrField = aSymbol->FindField( attrName );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
if( !attrField )
{
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
int fieldID = aSymbol->GetFieldCount();
attrField = new LIB_FIELD( aSymbol, fieldID );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
attrField->SetName( attrName );
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
aSymbol->AddField( attrField );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
}
CADSTAR Schematic: Fix loading of symbol attributes Fixes an issue that resulted in incorrect field values being loaded
2021-03-28 18:03:11 +00:00
wxASSERT( attrField->GetName() == attrName );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
attrField->SetText( aAttributeVal.Value );
attrField->SetUnit( gateNumber );
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
ATTRIBUTE_ID& attrid = aAttributeVal.AttributeID;
attrField->SetVisible( isAttributeVisible( attrid ) );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
if( aAttributeVal.HasLocation )
{
// #1 Check if the part itself defined a location for the field
applyToLibraryFieldAttribute( aAttributeVal.AttributeLocation, symbol.Origin,
attrField );
}
else if( symbol.TextLocations.find( aAttributeVal.AttributeID )
!= symbol.TextLocations.end() )
{
// #2 Look in the symbol definition: Text locations
TEXT_LOCATION symTxtLoc = symbol.TextLocations.at( aAttributeVal.AttributeID );
applyToLibraryFieldAttribute( symTxtLoc, symbol.Origin, attrField );
}
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
else if( symbol.AttributeValues.find( attrid ) != symbol.AttributeValues.end()
&& symbol.AttributeValues.at( attrid ).HasLocation )
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
{
// #3 Look in the symbol definition: Attribute values
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
ATTRIBUTE_VALUE symAttrVal = symbol.AttributeValues.at( attrid );
applyToLibraryFieldAttribute( symAttrVal.AttributeLocation, symbol.Origin,
attrField );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
}
else
{
attrField->SetVisible( false );
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
applyTextSettings( attrField, wxT( "TC1" ), ALIGNMENT::NO_ALIGNMENT,
JUSTIFICATION::LEFT );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
}
};
// Load all attributes in the Part Definition
More NULL expunging.
2021-07-16 20:13:26 +00:00
for( std::pair<ATTRIBUTE_ID,
ATTRIBUTE_VALUE> attr : aCadstarPart->Definition.AttributeValues )
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
{
ATTRIBUTE_VALUE attrVal = attr.second;
loadLibraryField( attrVal );
}
// Load all attributes in the Part itself.
for( std::pair<ATTRIBUTE_ID, ATTRIBUTE_VALUE> attr : aCadstarPart->AttributeValues )
{
ATTRIBUTE_VALUE attrVal = attr.second;
loadLibraryField( attrVal );
}
wxString fpNameInLibrary = generateLibName( footprintRefName, footprintAlternateName );
wxArrayString fpFilters;
fpFilters.Add( fpNameInLibrary );
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
aSymbol->SetFPFilters( fpFilters );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
// Assume that the PCB footprint library name will be the same as the schematic filename
wxFileName schFilename( Filename );
wxString libName = schFilename.GetName();
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
aSymbol->GetFootprintField().SetText( libName + wxT( ":" ) + fpNameInLibrary );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
}
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
if( aCadstarPart && aCadstarPart->Definition.HidePinNames )
{
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
aSymbol->SetShowPinNames( false );
aSymbol->SetShowPinNumbers( false );
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
}
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
Overhaul arc internal model to not over-specify information.
2021-07-17 19:56:18 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::loadLibrarySymbolShapeVertices( const std::vector<VERTEX>& aCadstarVertices,
wxPoint aSymbolOrigin,
LIB_SYMBOL* aSymbol,
int aGateNumber,
int aLineThickness )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
{
const VERTEX* prev = &aCadstarVertices.at( 0 );
const VERTEX* cur;
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
wxASSERT_MSG( prev->Type == VERTEX_TYPE::POINT, wxT( "First vertex should always be a point." ) );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
for( size_t i = 1; i < aCadstarVertices.size(); i++ )
{
cur = &aCadstarVertices.at( i );
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
LIB_SHAPE* shape = nullptr;
bool cw = false;
wxPoint startPoint = getKiCadLibraryPoint( prev->End, aSymbolOrigin );
wxPoint endPoint = getKiCadLibraryPoint( cur->End, aSymbolOrigin );
wxPoint centerPoint;
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
if( cur->Type == VERTEX_TYPE::ANTICLOCKWISE_SEMICIRCLE
|| cur->Type == VERTEX_TYPE::CLOCKWISE_SEMICIRCLE )
{
centerPoint = ( startPoint + endPoint ) / 2;
}
else
{
centerPoint = getKiCadLibraryPoint( cur->Center, aSymbolOrigin );
}
switch( cur->Type )
{
case VERTEX_TYPE::POINT:
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
shape = new LIB_SHAPE( aSymbol, SHAPE_T::POLY );
shape->AddPoint( startPoint );
shape->AddPoint( endPoint );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
break;
case VERTEX_TYPE::CLOCKWISE_SEMICIRCLE:
case VERTEX_TYPE::CLOCKWISE_ARC:
cw = true;
KI_FALLTHROUGH;
case VERTEX_TYPE::ANTICLOCKWISE_SEMICIRCLE:
case VERTEX_TYPE::ANTICLOCKWISE_ARC:
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
shape = new LIB_SHAPE( aSymbol, SHAPE_T::ARC );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
shape->SetPosition( centerPoint );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
if( cw )
{
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
shape->SetStart( endPoint );
shape->SetEnd( startPoint );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
else
{
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
shape->SetStart( startPoint );
shape->SetEnd( endPoint );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
break;
}
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
shape->SetUnit( aGateNumber );
shape->SetWidth( aLineThickness );
aSymbol->AddDrawItem( shape );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
prev = cur;
}
}
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::applyToLibraryFieldAttribute(
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
const ATTRIBUTE_LOCATION& aCadstarAttrLoc, wxPoint aSymbolOrigin, LIB_FIELD* aKiCadField )
{
aKiCadField->SetTextPos( getKiCadLibraryPoint( aCadstarAttrLoc.Position, aSymbolOrigin ) );
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
applyTextSettings( aKiCadField,
aCadstarAttrLoc.TextCodeID,
aCadstarAttrLoc.Alignment,
aCadstarAttrLoc.Justification,
aCadstarAttrLoc.OrientAngle,
aCadstarAttrLoc.Mirror );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
SCH_SYMBOL* CADSTAR_SCH_ARCHIVE_LOADER::loadSchematicSymbol( const SYMBOL& aCadstarSymbol,
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
const LIB_SYMBOL& aKiCadPart,
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
double& aComponentOrientationDeciDeg )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
{
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
LIB_ID libId( m_libraryFileName.GetName(), aKiCadPart.GetName() );
CADSTAR Schematic Archive Importer: Correctly load symbol instances Previous implementation was not loading all fields defined in the library.
2021-01-31 19:32:39 +00:00
int unit = getKiCadUnitNumberFromGate( aCadstarSymbol.GateID );
SCH_SHEET_PATH sheetpath;
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
SCH_SHEET* kiSheet = m_sheetMap.at( aCadstarSymbol.LayerID );
m_rootSheet->LocatePathOfScreen( kiSheet->GetScreen(), &sheetpath );
CADSTAR Schematic Archive Importer: Correctly load symbol instances Previous implementation was not loading all fields defined in the library.
2021-01-31 19:32:39 +00:00
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
SCH_SYMBOL* symbol = new SCH_SYMBOL( aKiCadPart, libId, &sheetpath, unit );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR Schematic Archive Importer: Import common fields visibilities Import field visibilities for Ref, Value and Part Name Also fix incorrect loading of designator from previous commit
2021-02-02 13:39:40 +00:00
if( aCadstarSymbol.IsComponent )
{
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
symbol->SetRef( &sheetpath, aCadstarSymbol.ComponentRef.Designator );
CADSTAR Schematic Archive Importer: Import common fields visibilities Import field visibilities for Ref, Value and Part Name Also fix incorrect loading of designator from previous commit
2021-02-02 13:39:40 +00:00
}
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
symbol->SetPosition( getKiCadPoint( aCadstarSymbol.Origin ) );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR Schematic Archive Importer: Fix orientation of components - Fix the logic for the orientation of mirrored components - Fix loading of angles/orientations from earlier versions of CADSTAR
2020-11-22 01:50:04 +00:00
double compAngleDeciDeg = getAngleTenthDegree( aCadstarSymbol.OrientAngle );
int compOrientation = 0;
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
if( aCadstarSymbol.Mirror )
CADSTAR Schematic Archive Importer: Fix orientation of components - Fix the logic for the orientation of mirrored components - Fix loading of angles/orientations from earlier versions of CADSTAR
2020-11-22 01:50:04 +00:00
{
compAngleDeciDeg = -compAngleDeciDeg;
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
compOrientation += SYMBOL_ORIENTATION_T::SYM_MIRROR_Y;
CADSTAR Schematic Archive Importer: Fix orientation of components - Fix the logic for the orientation of mirrored components - Fix loading of angles/orientations from earlier versions of CADSTAR
2020-11-22 01:50:04 +00:00
}
compOrientation += getComponentOrientation( compAngleDeciDeg, aComponentOrientationDeciDeg );
if( NormalizeAngle180( compAngleDeciDeg ) != NormalizeAngle180( aComponentOrientationDeciDeg ) )
{
Move importers from wxLog to REPORTER. Fixes https://gitlab.com/kicad/code/kicad/issues/6389
2021-03-31 21:33:30 +00:00
m_reporter->Report( wxString::Format( _( "Symbol '%s' is rotated by an angle of %.1f "
"degrees in the original CADSTAR design but "
"KiCad only supports rotation angles multiples "
"of 90 degrees. The connecting wires will need "
"manual fixing." ),
aCadstarSymbol.ComponentRef.Designator,
compAngleDeciDeg / 10.0 ),
RPT_SEVERITY_ERROR);
CADSTAR Schematic Archive Importer: Fix orientation of components - Fix the logic for the orientation of mirrored components - Fix loading of angles/orientations from earlier versions of CADSTAR
2020-11-22 01:50:04 +00:00
}
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
symbol->SetOrientation( compOrientation );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
if( m_sheetMap.find( aCadstarSymbol.LayerID ) == m_sheetMap.end() )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
{
Move importers from wxLog to REPORTER. Fixes https://gitlab.com/kicad/code/kicad/issues/6389
2021-03-31 21:33:30 +00:00
m_reporter->Report( wxString::Format( _( "Symbol '%s' references sheet ID '%s' which does "
"not exist in the design. The symbol was not "
"loaded." ),
aCadstarSymbol.ComponentRef.Designator,
aCadstarSymbol.LayerID ),
RPT_SEVERITY_ERROR );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
delete symbol;
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
return nullptr;
}
CADSTAR Schematic Archive Importer: Handle Pin Swaps Each schematic symbol instance can have pin numbers that diverge from the pin number definitions in the library
2021-02-03 20:06:41 +00:00
wxString gate = ( aCadstarSymbol.GateID.IsEmpty() ) ? wxT( "A" ) : aCadstarSymbol.GateID;
wxString partGateIndex = aCadstarSymbol.PartRef.RefID + gate;
//Handle pin swaps
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
if( m_pinNumsMap.find( partGateIndex ) != m_pinNumsMap.end() )
CADSTAR Schematic Archive Importer: Handle Pin Swaps Each schematic symbol instance can have pin numbers that diverge from the pin number definitions in the library
2021-02-03 20:06:41 +00:00
{
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
TERMINAL_TO_PINNUM_MAP termNumMap = m_pinNumsMap.at( partGateIndex );
CADSTAR Schematic Archive Importer: Handle Pin Swaps Each schematic symbol instance can have pin numbers that diverge from the pin number definitions in the library
2021-02-03 20:06:41 +00:00
std::map<wxString, LIB_PIN*> pinNumToLibPinMap;
for( auto& term : termNumMap )
{
wxString pinNum = term.second;
Expunge the use of the word part from Eeschema code.
2021-06-15 12:31:28 +00:00
pinNumToLibPinMap.insert( { pinNum,
symbol->GetLibSymbolRef()->GetPin( term.second ) } );
CADSTAR Schematic Archive Importer: Handle Pin Swaps Each schematic symbol instance can have pin numbers that diverge from the pin number definitions in the library
2021-02-03 20:06:41 +00:00
}
auto replacePinNumber = [&]( wxString aOldPinNum, wxString aNewPinNum )
{
if( aOldPinNum == aNewPinNum )
return;
LIB_PIN* libpin = pinNumToLibPinMap.at( aOldPinNum );
Fix issues with new overbar syntax - Update sch text help (~~ no longer gets converted to single ~) - Update Eagle importer to correctly handle new overbar syntax - Update CADSTAR importer to correctly handle new overbar syntax
2021-09-01 18:24:42 +00:00
libpin->SetNumber( HandleTextOverbar( aNewPinNum ) );
CADSTAR Schematic Archive Importer: Handle Pin Swaps Each schematic symbol instance can have pin numbers that diverge from the pin number definitions in the library
2021-02-03 20:06:41 +00:00
};
//Older versions of Cadstar used pin numbers
for( auto& pinPair : aCadstarSymbol.PinNumbers )
{
SYMBOL::PIN_NUM pin = pinPair.second;
replacePinNumber( termNumMap.at( pin.TerminalID ),
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
wxString::Format( wxT( "%ld" ), pin.PinNum ) );
CADSTAR Schematic Archive Importer: Handle Pin Swaps Each schematic symbol instance can have pin numbers that diverge from the pin number definitions in the library
2021-02-03 20:06:41 +00:00
}
//Newer versions of Cadstar use pin names
for( auto& pinPair : aCadstarSymbol.PinNames )
{
SYMPINNAME_LABEL pin = pinPair.second;
replacePinNumber( termNumMap.at( pin.TerminalID ), pin.NameOrLabel );
}
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
symbol->UpdatePins();
CADSTAR Schematic Archive Importer: Handle Pin Swaps Each schematic symbol instance can have pin numbers that diverge from the pin number definitions in the library
2021-02-03 20:06:41 +00:00
}
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
kiSheet->GetScreen()->Append( symbol );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
return symbol;
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::loadSymbolFieldAttribute(
const ATTRIBUTE_LOCATION& aCadstarAttrLoc, const double& aComponentOrientationDeciDeg,
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
bool aIsMirrored, SCH_FIELD* aKiCadField )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
{
aKiCadField->SetPosition( getKiCadPoint( aCadstarAttrLoc.Position ) );
aKiCadField->SetVisible( true );
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
ALIGNMENT alignment = aCadstarAttrLoc.Alignment;
CADSTAR Schematic: Fix positioning of symbol attributes Symbol attributes were being placed at the wrong location due to incorrect relative angle calculation
2021-05-28 16:25:37 +00:00
double textAngle = getAngleTenthDegree( aCadstarAttrLoc.OrientAngle );
long long cadstarAngle = getCadstarAngle( textAngle - aComponentOrientationDeciDeg );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
if( aIsMirrored )
{
CADSTAR Sch: Fix positioning of symbol fields when the symbol is mirrored The text aligment needs to be rotated and/or mirrored depending on whether the text field is vertical or horizontal.
2021-10-31 16:12:08 +00:00
// We need to change the aligment when the symbol is mirrored based on the text orientation
// To ensure the anchor point is the same in KiCad.
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
CADSTAR Sch: Fix positioning of symbol fields when the symbol is mirrored The text aligment needs to be rotated and/or mirrored depending on whether the text field is vertical or horizontal.
2021-10-31 16:12:08 +00:00
int textIsVertical = KiROUND( textAngle / 900.0 ) % 2;
if( textIsVertical )
alignment = rotate180( alignment );
alignment = mirrorX( alignment );
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
}
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
applyTextSettings( aKiCadField,
aCadstarAttrLoc.TextCodeID,
alignment,
aCadstarAttrLoc.Justification,
cadstarAngle,
aCadstarAttrLoc.Mirror );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
int CADSTAR_SCH_ARCHIVE_LOADER::getComponentOrientation(
CADSTAR Schematic Archive Importer: Fix orientation of components - Fix the logic for the orientation of mirrored components - Fix loading of angles/orientations from earlier versions of CADSTAR
2020-11-22 01:50:04 +00:00
double aOrientAngleDeciDeg, double& aReturnedOrientationDeciDeg )
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
{
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
int compOrientation = SYMBOL_ORIENTATION_T::SYM_ORIENT_0;
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
CADSTAR Schematic Archive Importer: Fix orientation of components - Fix the logic for the orientation of mirrored components - Fix loading of angles/orientations from earlier versions of CADSTAR
2020-11-22 01:50:04 +00:00
int oDeg = (int) NormalizeAngle180( aOrientAngleDeciDeg );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
if( oDeg >= -450 && oDeg <= 450 )
{
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
compOrientation = SYMBOL_ORIENTATION_T::SYM_ORIENT_0;
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
aReturnedOrientationDeciDeg = 0.0;
}
else if( oDeg >= 450 && oDeg <= 1350 )
{
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
compOrientation = SYMBOL_ORIENTATION_T::SYM_ORIENT_90;
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
aReturnedOrientationDeciDeg = 900.0;
}
else if( oDeg >= 1350 || oDeg <= -1350 )
{
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
compOrientation = SYMBOL_ORIENTATION_T::SYM_ORIENT_180;
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
aReturnedOrientationDeciDeg = 1800.0;
}
else
{
Rename SCH_COMPONENT to SCH_SYMBOL.
2021-06-10 14:10:55 +00:00
compOrientation = SYMBOL_ORIENTATION_T::SYM_ORIENT_270;
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
aReturnedOrientationDeciDeg = 2700.0;
}
return compOrientation;
}
CADSTAR_SCH_ARCHIVE_LOADER::POINT CADSTAR_SCH_ARCHIVE_LOADER::getLocationOfNetElement(
const NET_SCH& aNet, const NETELEMENT_ID& aNetElementID )
{
// clang-format off
Remove kicad_string.h from eda_text.h
2020-10-14 11:03:58 +00:00
auto logUnknownNetElementError =
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
[&]()
{
Move importers from wxLog to REPORTER. Fixes https://gitlab.com/kicad/code/kicad/issues/6389
2021-03-31 21:33:30 +00:00
m_reporter->Report( wxString::Format( _( "Net %s references unknown net element %s. "
"The net was not properly loaded and may "
"require manual fixing." ),
getNetName( aNet ),
aNetElementID ),
RPT_SEVERITY_ERROR );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
return POINT();
};
// clang-format on
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
if( aNetElementID.Contains( wxT( "J" ) ) ) // Junction
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
{
if( aNet.Junctions.find( aNetElementID ) == aNet.Junctions.end() )
return logUnknownNetElementError();
return aNet.Junctions.at( aNetElementID ).Location;
}
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
else if( aNetElementID.Contains( wxT( "P" ) ) ) // Terminal/Pin of a symbol
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
{
if( aNet.Terminals.find( aNetElementID ) == aNet.Terminals.end() )
return logUnknownNetElementError();
SYMBOL_ID symid = aNet.Terminals.at( aNetElementID ).SymbolID;
TERMINAL_ID termid = aNet.Terminals.at( aNetElementID ).TerminalID;
if( Schematic.Symbols.find( symid ) == Schematic.Symbols.end() )
return logUnknownNetElementError();
SYMBOL sym = Schematic.Symbols.at( symid );
SYMDEF_ID symdefid = sym.SymdefID;
wxPoint symbolOrigin = sym.Origin;
if( Library.SymbolDefinitions.find( symdefid ) == Library.SymbolDefinitions.end() )
return logUnknownNetElementError();
wxPoint libpinPosition =
Library.SymbolDefinitions.at( symdefid ).Terminals.at( termid ).Position;
wxPoint libOrigin = Library.SymbolDefinitions.at( symdefid ).Origin;
CADSTAR Schematic: Handle scaled symbols Create a new LIB_PART for scaled symbols. These will be then embedded into the schematic file. However when "update from library" is done, it will revert to the unscaled symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/8494
2021-05-28 15:19:04 +00:00
wxPoint pinOffset = libpinPosition - libOrigin;
pinOffset.x = ( pinOffset.x * sym.ScaleRatioNumerator ) / sym.ScaleRatioDenominator;
pinOffset.y = ( pinOffset.y * sym.ScaleRatioNumerator ) / sym.ScaleRatioDenominator;
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
wxPoint pinPosition = symbolOrigin + pinOffset;
CADSTAR Schematic Archive Importer: Fix orientation of components - Fix the logic for the orientation of mirrored components - Fix loading of angles/orientations from earlier versions of CADSTAR
2020-11-22 01:50:04 +00:00
double compAngleDeciDeg = getAngleTenthDegree( sym.OrientAngle );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
if( sym.Mirror )
pinPosition.x = ( 2 * symbolOrigin.x ) - pinPosition.x;
double adjustedOrientationDecideg;
CADSTAR Schematic Archive Importer: Fix orientation of components - Fix the logic for the orientation of mirrored components - Fix loading of angles/orientations from earlier versions of CADSTAR
2020-11-22 01:50:04 +00:00
getComponentOrientation( compAngleDeciDeg, adjustedOrientationDecideg );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
RotatePoint( &pinPosition, symbolOrigin, -adjustedOrientationDecideg );
POINT retval;
retval.x = pinPosition.x;
retval.y = pinPosition.y;
return retval;
}
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
else if( aNetElementID.Contains( wxT( "BT" ) ) ) // Bus Terminal
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
{
if( aNet.BusTerminals.find( aNetElementID ) == aNet.BusTerminals.end() )
return logUnknownNetElementError();
return aNet.BusTerminals.at( aNetElementID ).SecondPoint;
}
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
else if( aNetElementID.Contains( wxT( "BLKT" ) ) ) // Block Terminal (sheet hierarchy connection)
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
{
if( aNet.BlockTerminals.find( aNetElementID ) == aNet.BlockTerminals.end() )
return logUnknownNetElementError();
BLOCK_ID blockid = aNet.BlockTerminals.at( aNetElementID ).BlockID;
TERMINAL_ID termid = aNet.BlockTerminals.at( aNetElementID ).TerminalID;
if( Schematic.Blocks.find( blockid ) == Schematic.Blocks.end() )
return logUnknownNetElementError();
return Schematic.Blocks.at( blockid ).Terminals.at( termid ).Position;
}
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
else if( aNetElementID.Contains( wxT( "D" ) ) ) // Dangler
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
{
if( aNet.Danglers.find( aNetElementID ) == aNet.Danglers.end() )
return logUnknownNetElementError();
return aNet.Danglers.at( aNetElementID ).Position;
}
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
else
{
return logUnknownNetElementError();
}
return POINT();
}
wxString CADSTAR_SCH_ARCHIVE_LOADER::getNetName( const NET_SCH& aNet )
{
wxString netname = aNet.Name;
if( netname.IsEmpty() )
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
netname = wxString::Format( wxT( "$%ld" ), aNet.SignalNum );
CADSTAR Schematic Archive Importer: Load Nets, Wires, Junctions and Hierarchical Pins
2020-09-23 20:39:11 +00:00
return netname;
}
CADSTAR Schematic Archive Importer: Fix loading of graphical arc segments Load the arc segments as piece-wise straight segments
2020-11-21 22:56:56 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::loadGraphicStaightSegment( const wxPoint& aStartPoint,
const wxPoint& aEndPoint, const LINECODE_ID& aCadstarLineCodeID,
const LAYER_ID& aCadstarSheetID, const SCH_LAYER_ID& aKiCadSchLayerID,
const wxPoint& aMoveVector, const double& aRotationAngleDeciDeg,
const double& aScalingFactor, const wxPoint& aTransformCentre, const bool& aMirrorInvert )
{
SCH_LINE* segment = new SCH_LINE();
segment->SetLayer( aKiCadSchLayerID );
segment->SetLineWidth( KiROUND( getLineThickness( aCadstarLineCodeID ) * aScalingFactor ) );
segment->SetLineStyle( getLineStyle( aCadstarLineCodeID ) );
//Apply transforms
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
wxPoint startPoint = applyTransform( aStartPoint, aMoveVector, aRotationAngleDeciDeg,
aScalingFactor, aTransformCentre, aMirrorInvert );
wxPoint endPoint = applyTransform( aEndPoint, aMoveVector, aRotationAngleDeciDeg,
aScalingFactor, aTransformCentre, aMirrorInvert );
CADSTAR Schematic Archive Importer: Fix loading of graphical arc segments Load the arc segments as piece-wise straight segments
2020-11-21 22:56:56 +00:00
segment->SetStartPoint( startPoint );
segment->SetEndPoint( endPoint );
loadItemOntoKiCadSheet( aCadstarSheetID, segment );
}
CADSTAR Schematic Archive Importer: Load Figures
2020-09-26 18:23:13 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::loadShapeVertices( const std::vector<VERTEX>& aCadstarVertices,
CADSTAR Schematic Archive Importer: Load Documentation Symbols
2020-09-27 12:19:51 +00:00
LINECODE_ID aCadstarLineCodeID, LAYER_ID aCadstarSheetID, SCH_LAYER_ID aKiCadSchLayerID,
const wxPoint& aMoveVector, const double& aRotationAngleDeciDeg,
const double& aScalingFactor, const wxPoint& aTransformCentre, const bool& aMirrorInvert )
CADSTAR Schematic Archive Importer: Load Figures
2020-09-26 18:23:13 +00:00
{
const VERTEX* prev = &aCadstarVertices.at( 0 );
const VERTEX* cur;
wxASSERT_MSG(
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
prev->Type == VERTEX_TYPE::POINT, wxT( "First vertex should always be a point vertex" ) );
CADSTAR Schematic Archive Importer: Load Figures
2020-09-26 18:23:13 +00:00
Fix a minor compil warning
2020-11-29 11:57:29 +00:00
for( size_t ii = 1; ii < aCadstarVertices.size(); ii++ )
CADSTAR Schematic Archive Importer: Load Figures
2020-09-26 18:23:13 +00:00
{
Fix a minor compil warning
2020-11-29 11:57:29 +00:00
cur = &aCadstarVertices.at( ii );
CADSTAR Schematic Archive Importer: Load Figures
2020-09-26 18:23:13 +00:00
CADSTAR Schematic Archive Importer: Fix loading of graphical arc segments Load the arc segments as piece-wise straight segments
2020-11-21 22:56:56 +00:00
wxPoint startPoint = getKiCadPoint( prev->End );
wxPoint endPoint = getKiCadPoint( cur->End );
wxPoint centerPoint = getKiCadPoint( cur->Center );
bool cw = false;
CADSTAR Schematic Archive Importer: Load Figures
2020-09-26 18:23:13 +00:00
CADSTAR Schematic Archive Importer: Fix loading of graphical arc segments Load the arc segments as piece-wise straight segments
2020-11-21 22:56:56 +00:00
if( cur->Type == VERTEX_TYPE::ANTICLOCKWISE_SEMICIRCLE
|| cur->Type == VERTEX_TYPE::CLOCKWISE_SEMICIRCLE )
{
centerPoint = ( startPoint + endPoint ) / 2;
}
CADSTAR Schematic Archive Importer: Load Figures
2020-09-26 18:23:13 +00:00
CADSTAR Schematic Archive Importer: Fix loading of graphical arc segments Load the arc segments as piece-wise straight segments
2020-11-21 22:56:56 +00:00
switch( cur->Type )
{
case VERTEX_TYPE::CLOCKWISE_SEMICIRCLE:
case VERTEX_TYPE::CLOCKWISE_ARC:
cw = true;
KI_FALLTHROUGH;
case VERTEX_TYPE::ANTICLOCKWISE_SEMICIRCLE:
case VERTEX_TYPE::ANTICLOCKWISE_ARC:
{
double arcStartAngle = getPolarAngle( startPoint - centerPoint );
double arcEndAngle = getPolarAngle( endPoint - centerPoint );
double arcAngleDeciDeg = arcEndAngle - arcStartAngle;
CADSTAR Schematic Archive Importer: Load Documentation Symbols
2020-09-27 12:19:51 +00:00
CADSTAR Schematic Archive Importer: Fix loading of graphical arc segments Load the arc segments as piece-wise straight segments
2020-11-21 22:56:56 +00:00
if( cw )
arcAngleDeciDeg = NormalizeAnglePos( arcAngleDeciDeg );
else
arcAngleDeciDeg = NormalizeAngleNeg( arcAngleDeciDeg );
CADSTAR Schematic Archive Importer: Load Documentation Symbols
2020-09-27 12:19:51 +00:00
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
SHAPE_ARC tempArc( centerPoint, startPoint, arcAngleDeciDeg / 10.0 );
CADSTAR Schematic Archive Importer: Fix loading of graphical arc segments Load the arc segments as piece-wise straight segments
2020-11-21 22:56:56 +00:00
SHAPE_LINE_CHAIN arcSegments = tempArc.ConvertToPolyline( Millimeter2iu( 0.1 ) );
// Load the arc as a series of piece-wise segments
CADSTAR Schematic Archive Importer: Load Figures
2020-09-26 18:23:13 +00:00
Fix a minor compil warning
2020-11-29 11:57:29 +00:00
for( int jj = 0; jj < arcSegments.SegmentCount(); jj++ )
CADSTAR Schematic Archive Importer: Fix loading of graphical arc segments Load the arc segments as piece-wise straight segments
2020-11-21 22:56:56 +00:00
{
Fix a minor compil warning
2020-11-29 11:57:29 +00:00
wxPoint segStart = (wxPoint) arcSegments.Segment( jj ).A;
wxPoint segEnd = (wxPoint) arcSegments.Segment( jj ).B;
CADSTAR Schematic Archive Importer: Fix loading of graphical arc segments Load the arc segments as piece-wise straight segments
2020-11-21 22:56:56 +00:00
More NULL expunging.
2021-07-16 20:13:26 +00:00
loadGraphicStaightSegment( segStart, segEnd, aCadstarLineCodeID, aCadstarSheetID,
aKiCadSchLayerID, aMoveVector, aRotationAngleDeciDeg,
aScalingFactor, aTransformCentre, aMirrorInvert );
CADSTAR Schematic Archive Importer: Fix loading of graphical arc segments Load the arc segments as piece-wise straight segments
2020-11-21 22:56:56 +00:00
}
}
break;
case VERTEX_TYPE::POINT:
loadGraphicStaightSegment( startPoint, endPoint, aCadstarLineCodeID, aCadstarSheetID,
More NULL expunging.
2021-07-16 20:13:26 +00:00
aKiCadSchLayerID, aMoveVector, aRotationAngleDeciDeg,
aScalingFactor, aTransformCentre, aMirrorInvert );
CADSTAR Schematic Archive Importer: Fix loading of graphical arc segments Load the arc segments as piece-wise straight segments
2020-11-21 22:56:56 +00:00
break;
default:
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
wxFAIL_MSG( wxT( "Unknown CADSTAR Vertex type" ) );
CADSTAR Schematic Archive Importer: Fix loading of graphical arc segments Load the arc segments as piece-wise straight segments
2020-11-21 22:56:56 +00:00
}
prev = cur;
CADSTAR Schematic Archive Importer: Load Texts
2020-09-27 02:35:24 +00:00
}
}
void CADSTAR_SCH_ARCHIVE_LOADER::loadFigure( const FIGURE& aCadstarFigure,
CADSTAR Schematic Archive Importer: Load Documentation Symbols
2020-09-27 12:19:51 +00:00
const LAYER_ID& aCadstarSheetIDOverride, SCH_LAYER_ID aKiCadSchLayerID,
const wxPoint& aMoveVector, const double& aRotationAngleDeciDeg,
const double& aScalingFactor, const wxPoint& aTransformCentre, const bool& aMirrorInvert )
CADSTAR Schematic Archive Importer: Load Texts
2020-09-27 02:35:24 +00:00
{
loadShapeVertices( aCadstarFigure.Shape.Vertices, aCadstarFigure.LineCodeID,
More NULL expunging.
2021-07-16 20:13:26 +00:00
aCadstarSheetIDOverride, aKiCadSchLayerID, aMoveVector,
aRotationAngleDeciDeg, aScalingFactor, aTransformCentre, aMirrorInvert );
CADSTAR Schematic Archive Importer: Load Texts
2020-09-27 02:35:24 +00:00
for( CUTOUT cutout : aCadstarFigure.Shape.Cutouts )
{
CADSTAR Schematic Archive Importer: Load Documentation Symbols
2020-09-27 12:19:51 +00:00
loadShapeVertices( cutout.Vertices, aCadstarFigure.LineCodeID, aCadstarSheetIDOverride,
More NULL expunging.
2021-07-16 20:13:26 +00:00
aKiCadSchLayerID, aMoveVector, aRotationAngleDeciDeg, aScalingFactor,
aTransformCentre, aMirrorInvert );
CADSTAR Schematic Archive Importer: Load Figures
2020-09-26 18:23:13 +00:00
}
}
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::loadSheetAndChildSheets(
Pass wxPoint objects by reference instead of on the stack.
2021-07-26 19:35:12 +00:00
LAYER_ID aCadstarSheetID, const wxPoint& aPosition, wxSize aSheetSize,
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
const SCH_SHEET_PATH& aParentSheet )
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
{
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
wxCHECK_MSG( m_sheetMap.find( aCadstarSheetID ) == m_sheetMap.end(), ,
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
wxT( "Sheet already loaded!" ) );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
CADSTAR Schematic Archive Importer: Fix Loading of page numbers Need to keep track of the hierarchy path in order to assign the page number
2020-11-22 19:55:21 +00:00
SCH_SHEET* sheet = new SCH_SHEET( aParentSheet.Last(), aPosition );
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
SCH_SCREEN* screen = new SCH_SCREEN( m_schematic );
CADSTAR Schematic Archive Importer: Fix Loading of page numbers Need to keep track of the hierarchy path in order to assign the page number
2020-11-22 19:55:21 +00:00
SCH_SHEET_PATH instance( aParentSheet );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
sheet->SetSize( aSheetSize );
sheet->SetScreen( screen );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
wxString name = Sheets.SheetNames.at( aCadstarSheetID );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
SCH_FIELD& sheetNameField = sheet->GetFields()[SHEETNAME];
SCH_FIELD& filenameField = sheet->GetFields()[SHEETFILENAME];
sheetNameField.SetText( name );
CADSTAR Schematic Archive Importer: Fix Loading of page numbers Need to keep track of the hierarchy path in order to assign the page number
2020-11-22 19:55:21 +00:00
int sheetNum = getSheetNumber( aCadstarSheetID );
wxString loadedFilename = wxFileName( Filename ).GetName();
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
std::string filename = wxString::Format( wxT( "%s_%02d" ), loadedFilename, sheetNum ).ToStdString();
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
ReplaceIllegalFileNameChars( &filename );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
filename += wxT( "." ) + KiCadSchematicFileExtension;
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
filenameField.SetText( filename );
CADSTAR Schematic Archive Importer: Autoplace fields when adding sheet Makes the sheets look a little bit better when there is no block name in the original CADSTAR design.
2021-02-17 19:12:47 +00:00
CADSTAR Schematic: Fix assert regarding sheet absolute path
2021-05-28 16:06:22 +00:00
wxFileName fn( m_schematic->Prj().GetProjectPath() + filename );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
sheet->GetScreen()->SetFileName( fn.GetFullPath() );
CADSTAR Schematic Archive Importer: Fix Loading of page numbers Need to keep track of the hierarchy path in order to assign the page number
2020-11-22 19:55:21 +00:00
aParentSheet.Last()->GetScreen()->Append( sheet );
instance.push_back( sheet );
Eeschema: fix broken page numbers when renaming a sheet file name. Always use full sheet paths when storing sheet instances. Partial sheet paths cannot be full resolved resulting in lost page numbers when renaming sheet file name. Fixes #9782
2021-12-08 18:36:23 +00:00
sheet->AddInstance( instance );
CADSTAR Schematic Archive Importer: Fix Loading of page numbers Need to keep track of the hierarchy path in order to assign the page number
2020-11-22 19:55:21 +00:00
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
wxString pageNumStr = wxString::Format( wxT( "%d" ), getSheetNumber( aCadstarSheetID ) );
Revert "Eeschema: fix broken page numbers when renaming a sheet file name." This reverts commit a468a79948a544aa3313b20a101b7c92dcfe3375.
2021-12-06 12:47:18 +00:00
sheet->SetPageNumber( instance, pageNumStr );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
More NULL expunging.
2021-07-16 20:13:26 +00:00
sheet->AutoplaceFields( /* aScreen */ nullptr, /* aManual */ false );
CADSTAR Schematic Archive Importer: Autoplace fields when adding sheet Makes the sheets look a little bit better when there is no block name in the original CADSTAR design.
2021-02-17 19:12:47 +00:00
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_sheetMap.insert( { aCadstarSheetID, sheet } );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
CADSTAR Schematic Archive Importer: Fix Loading of page numbers Need to keep track of the hierarchy path in order to assign the page number
2020-11-22 19:55:21 +00:00
loadChildSheets( aCadstarSheetID, instance );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
}
More NULL expunging.
2021-07-16 20:13:26 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::loadChildSheets( LAYER_ID aCadstarSheetID,
const SCH_SHEET_PATH& aSheet )
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
{
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
wxCHECK_MSG( m_sheetMap.find( aCadstarSheetID ) != m_sheetMap.end(), ,
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
wxT( "FIXME! Parent sheet should be loaded before attempting to load subsheets" ) );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
for( std::pair<BLOCK_ID, BLOCK> blockPair : Schematic.Blocks )
{
BLOCK& block = blockPair.second;
if( block.LayerID == aCadstarSheetID && block.Type == BLOCK::TYPE::CHILD )
{
CADSTAR Schematic Archive Importer: Do not load blocks without a linked sheet Fixes std::out_of_range error
2020-12-29 23:35:57 +00:00
if( block.AssocLayerID == wxT( "NO_LINK" ) )
{
if( block.Figures.size() > 0 )
{
Move importers from wxLog to REPORTER. Fixes https://gitlab.com/kicad/code/kicad/issues/6389
2021-03-31 21:33:30 +00:00
m_reporter->Report( wxString::Format( _( "The block ID %s (Block name: '%s') "
"is drawn on sheet '%s' but is not "
"linked to another sheet in the "
"design. KiCad requires all sheet "
"symbols to be associated to a sheet, "
"so the block was not loaded." ),
block.ID, block.Name,
Sheets.SheetNames.at( aCadstarSheetID ) ),
RPT_SEVERITY_ERROR );
CADSTAR Schematic Archive Importer: Do not load blocks without a linked sheet Fixes std::out_of_range error
2020-12-29 23:35:57 +00:00
}
continue;
}
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
// In KiCad you can only draw rectangular shapes whereas in Cadstar arbitrary shapes
// are allowed. We will calculate the extents of the Cadstar shape and draw a rectangle
std::pair<wxPoint, wxSize> blockExtents;
if( block.Figures.size() > 0 )
{
blockExtents = getFigureExtentsKiCad( block.Figures.begin()->second );
}
else
{
Move importers from wxLog to REPORTER. Fixes https://gitlab.com/kicad/code/kicad/issues/6389
2021-03-31 21:33:30 +00:00
THROW_IO_ERROR( wxString::Format( _( "The CADSTAR schematic might be corrupt: "
"Block %s references a child sheet but has no "
"Figure defined." ),
block.ID ) );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
}
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
loadSheetAndChildSheets( block.AssocLayerID, blockExtents.first, blockExtents.second,
aSheet );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
CADSTAR Schematic: Hide all KiCad sheet properties Sheet name/filename not applicable in CADSTAR so displaying it just makes the import look messy.
2021-10-17 17:31:42 +00:00
// Hide all KiCad sheet properties (sheet name/filename is not applicable in CADSTAR)
SCH_SHEET* loadedSheet = m_sheetMap.at( block.AssocLayerID );
SCH_FIELDS fields = loadedSheet->GetFields();
for( SCH_FIELD& field : fields )
{
field.SetVisible( false );
}
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
if( block.HasBlockLabel )
{
CADSTAR Sch: Fix block names - load as stand-alone text items instead KiCad doesn't support multi-line text in fields, so we can't load it as a text field (even if that would be the closest thing). We should update this when KiCad supports multi-line text in fields.
2021-10-29 17:59:07 +00:00
//@todo use below code when KiCad supports multi-line fields
/*
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
// Add the block label as a separate field
SCH_FIELD blockNameField( getKiCadPoint( block.BlockLabel.Position ), 2,
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
loadedSheet, wxString( wxT( "Block name" ) ) );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
blockNameField.SetText( block.Name );
blockNameField.SetVisible( true );
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
applyTextSettings( &blockNameField,
block.BlockLabel.TextCodeID,
block.BlockLabel.Alignment,
block.BlockLabel.Justification,
block.BlockLabel.OrientAngle,
block.BlockLabel.Mirror );
CADSTAR Sch: Fix block names - load as stand-alone text items instead KiCad doesn't support multi-line text in fields, so we can't load it as a text field (even if that would be the closest thing). We should update this when KiCad supports multi-line text in fields.
2021-10-29 17:59:07 +00:00
fields.push_back( blockNameField );*/
// For now as as a text item (supports multi-line properly)
SCH_TEXT* kiTxt = new SCH_TEXT();
kiTxt->SetParent( m_schematic );
kiTxt->SetPosition( getKiCadPoint( block.BlockLabel.Position ) );
kiTxt->SetText( block.Name );
applyTextSettings( kiTxt,
block.BlockLabel.TextCodeID,
block.BlockLabel.Alignment,
block.BlockLabel.Justification,
block.BlockLabel.OrientAngle,
block.BlockLabel.Mirror );
loadItemOntoKiCadSheet( aCadstarSheetID, kiTxt );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
}
CADSTAR Schematic: Hide all KiCad sheet properties Sheet name/filename not applicable in CADSTAR so displaying it just makes the import look messy.
2021-10-17 17:31:42 +00:00
loadedSheet->SetFields( fields );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
}
}
}
std::vector<CADSTAR_SCH_ARCHIVE_LOADER::LAYER_ID> CADSTAR_SCH_ARCHIVE_LOADER::findOrphanSheets()
{
std::vector<LAYER_ID> childSheets, orphanSheets;
//Find all sheets that are child of another
for( std::pair<BLOCK_ID, BLOCK> blockPair : Schematic.Blocks )
{
BLOCK& block = blockPair.second;
LAYER_ID& assocSheetID = block.AssocLayerID;
if( block.Type == BLOCK::TYPE::CHILD )
childSheets.push_back( assocSheetID );
}
//Add sheets that do not have a parent
for( LAYER_ID sheetID : Sheets.SheetOrder )
{
if( std::find( childSheets.begin(), childSheets.end(), sheetID ) == childSheets.end() )
orphanSheets.push_back( sheetID );
}
return orphanSheets;
}
int CADSTAR_SCH_ARCHIVE_LOADER::getSheetNumber( LAYER_ID aCadstarSheetID )
{
int i = 1;
for( LAYER_ID sheetID : Sheets.SheetOrder )
{
if( sheetID == aCadstarSheetID )
return i;
++i;
}
return -1;
}
CADSTAR Schematic Archive Importer: Load Texts
2020-09-27 02:35:24 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::loadItemOntoKiCadSheet( LAYER_ID aCadstarSheetID, SCH_ITEM* aItem )
{
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
wxCHECK_MSG( aItem, /*void*/, wxT( "aItem is null" ) );
CADSTAR Schematic Archive Importer: Load Texts
2020-09-27 02:35:24 +00:00
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
if( aCadstarSheetID == wxT( "ALL_SHEETS" ) )
CADSTAR Schematic Archive Importer: Load Texts
2020-09-27 02:35:24 +00:00
{
SCH_ITEM* duplicateItem;
for( std::pair<LAYER_ID, SHEET_NAME> sheetPair : Sheets.SheetNames )
{
LAYER_ID sheetID = sheetPair.first;
duplicateItem = aItem->Duplicate();
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_sheetMap.at( sheetID )->GetScreen()->Append( aItem->Duplicate() );
CADSTAR Schematic Archive Importer: Load Texts
2020-09-27 02:35:24 +00:00
}
//Get rid of the extra copy:
delete aItem;
aItem = duplicateItem;
}
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
else if( aCadstarSheetID == wxT( "NO_SHEET" ) )
CADSTAR Schematic Archive Importer: Load Texts
2020-09-27 02:35:24 +00:00
{
wxASSERT_MSG(
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
false, wxT( "Trying to add an item to NO_SHEET? This might be a documentation symbol." ) );
CADSTAR Schematic Archive Importer: Load Texts
2020-09-27 02:35:24 +00:00
}
else
{
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
if( m_sheetMap.find( aCadstarSheetID ) != m_sheetMap.end() )
CADSTAR Schematic Archive Importer: Load Texts
2020-09-27 02:35:24 +00:00
{
CADSTAR Importer: Fix Code Style - Rename member variable names to use the 'm_' prefix - Rename a few object types that clashed with KiCad object names, such as BOARD and SCHEMATIC, to avoid the use of '::' to access the KiCad objects. - Remove some unused code.
2021-02-13 20:00:17 +00:00
m_sheetMap.at( aCadstarSheetID )->GetScreen()->Append( aItem );
CADSTAR Schematic Archive Importer: Load Texts
2020-09-27 02:35:24 +00:00
}
else
{
delete aItem;
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
wxASSERT_MSG( false, wxT( "Unknown Sheet ID." ) );
CADSTAR Schematic Archive Importer: Load Texts
2020-09-27 02:35:24 +00:00
}
}
}
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR_SCH_ARCHIVE_LOADER::SYMDEF_ID CADSTAR_SCH_ARCHIVE_LOADER::getSymDefFromName(
const wxString& aSymdefName, const wxString& aSymDefAlternate )
{
CADSTAR Schematic Archive Importer: Symbol name is case insensitive Fixes an issue on some designs that would not be able to find the symbol definition referenced by the part due to different capitalisation of the symbol name in the part definition and the symbol definition.
2021-02-02 15:38:46 +00:00
// Do a case-insensitive comparison
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
for( std::pair<SYMDEF_ID, SYMDEF_SCM> symPair : Library.SymbolDefinitions )
{
SYMDEF_ID id = symPair.first;
SYMDEF_SCM symdef = symPair.second;
CADSTAR Schematic Archive Importer: Symbol name is case insensitive Fixes an issue on some designs that would not be able to find the symbol definition referenced by the part due to different capitalisation of the symbol name in the part definition and the symbol definition.
2021-02-02 15:38:46 +00:00
if( symdef.ReferenceName.Lower() == aSymdefName.Lower()
&& symdef.Alternate.Lower() == aSymDefAlternate.Lower() )
{
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
return id;
CADSTAR Schematic Archive Importer: Symbol name is case insensitive Fixes an issue on some designs that would not be able to find the symbol definition referenced by the part due to different capitalisation of the symbol name in the part definition and the symbol definition.
2021-02-02 15:38:46 +00:00
}
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
return SYMDEF_ID();
}
More NULL expunging.
2021-07-16 20:13:26 +00:00
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
bool CADSTAR_SCH_ARCHIVE_LOADER::isAttributeVisible( const ATTRIBUTE_ID& aCadstarAttributeID )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
{
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
// Use CADSTAR visibility settings to determine if an attribute is visible
if( AttrColors.AttributeColors.find( aCadstarAttributeID ) != AttrColors.AttributeColors.end() )
{
return AttrColors.AttributeColors.at( aCadstarAttributeID ).IsVisible;
}
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR Schematic Archive Importer: Load all fields in symbols - Load Fields in the library items as well as schematic instances - Remove invalid characters (e.g. '\n', '\t', '\r') in fields - Load footprint field (assume that the footprint library name is the same as the filename of the schematic)
2021-01-27 00:09:58 +00:00
return false; // If there is no visibility setting, assume not displayed
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
}
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
int CADSTAR_SCH_ARCHIVE_LOADER::getLineThickness( const LINECODE_ID& aCadstarLineCodeID )
{
wxCHECK( Assignments.Codedefs.LineCodes.find( aCadstarLineCodeID )
!= Assignments.Codedefs.LineCodes.end(),
Remove atrophied schematic default wire and bus widths. (They're now in the netclasses, and specifically the default netclass if no other netclass is assigned.) Fixes https://gitlab.com/kicad/code/kicad/issues/9628
2021-11-13 22:55:46 +00:00
Mils2iu( DEFAULT_WIRE_WIDTH_MILS ) );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
return getKiCadLength( Assignments.Codedefs.LineCodes.at( aCadstarLineCodeID ).Width );
}
CADSTAR Schematic Archive Importer: Load Figures
2020-09-26 18:23:13 +00:00
PLOT_DASH_TYPE CADSTAR_SCH_ARCHIVE_LOADER::getLineStyle( const LINECODE_ID& aCadstarLineCodeID )
{
wxCHECK( Assignments.Codedefs.LineCodes.find( aCadstarLineCodeID )
!= Assignments.Codedefs.LineCodes.end(),
More NULL expunging.
2021-07-16 20:13:26 +00:00
PLOT_DASH_TYPE::SOLID );
CADSTAR Schematic Archive Importer: Load Figures
2020-09-26 18:23:13 +00:00
// clang-format off
switch( Assignments.Codedefs.LineCodes.at( aCadstarLineCodeID ).Style )
{
case LINESTYLE::DASH: return PLOT_DASH_TYPE::DASH;
case LINESTYLE::DASHDOT: return PLOT_DASH_TYPE::DASHDOT;
case LINESTYLE::DASHDOTDOT: return PLOT_DASH_TYPE::DASHDOT; //TODO: update in future
case LINESTYLE::DOT: return PLOT_DASH_TYPE::DOT;
case LINESTYLE::SOLID: return PLOT_DASH_TYPE::SOLID;
default: return PLOT_DASH_TYPE::DEFAULT;
}
// clang-format on
return PLOT_DASH_TYPE();
}
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
CADSTAR_SCH_ARCHIVE_LOADER::TEXTCODE CADSTAR_SCH_ARCHIVE_LOADER::getTextCode(
const TEXTCODE_ID& aCadstarTextCodeID )
{
wxCHECK( Assignments.Codedefs.TextCodes.find( aCadstarTextCodeID )
!= Assignments.Codedefs.TextCodes.end(),
More NULL expunging.
2021-07-16 20:13:26 +00:00
TEXTCODE() );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
return Assignments.Codedefs.TextCodes.at( aCadstarTextCodeID );
}
CADSTAR Schematic: Load text sizes for pin names/numbers and net labels
2021-09-01 19:12:56 +00:00
int CADSTAR_SCH_ARCHIVE_LOADER::getTextHeightFromTextCode( const TEXTCODE_ID& aCadstarTextCodeID )
{
TEXTCODE txtCode = getTextCode( aCadstarTextCodeID );
return KiROUND( (double) getKiCadLength( txtCode.Height ) * TXT_HEIGHT_RATIO );
}
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
wxString CADSTAR_SCH_ARCHIVE_LOADER::getAttributeName( const ATTRIBUTE_ID& aCadstarAttributeID )
{
wxCHECK( Assignments.Codedefs.AttributeNames.find( aCadstarAttributeID )
!= Assignments.Codedefs.AttributeNames.end(),
More NULL expunging.
2021-07-16 20:13:26 +00:00
wxEmptyString );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
return Assignments.Codedefs.AttributeNames.at( aCadstarAttributeID ).Name;
}
CADSTAR_SCH_ARCHIVE_LOADER::PART CADSTAR_SCH_ARCHIVE_LOADER::getPart(
const PART_ID& aCadstarPartID )
{
wxCHECK( Parts.PartDefinitions.find( aCadstarPartID ) != Parts.PartDefinitions.end(), PART() );
return Parts.PartDefinitions.at( aCadstarPartID );
}
CADSTAR_SCH_ARCHIVE_LOADER::ROUTECODE CADSTAR_SCH_ARCHIVE_LOADER::getRouteCode(
const ROUTECODE_ID& aCadstarRouteCodeID )
{
wxCHECK( Assignments.Codedefs.RouteCodes.find( aCadstarRouteCodeID )
!= Assignments.Codedefs.RouteCodes.end(),
More NULL expunging.
2021-07-16 20:13:26 +00:00
ROUTECODE() );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
return Assignments.Codedefs.RouteCodes.at( aCadstarRouteCodeID );
}
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR_SCH_ARCHIVE_LOADER::PART::DEFINITION::PIN CADSTAR_SCH_ARCHIVE_LOADER::getPartDefinitionPin(
const PART& aCadstarPart, const GATE_ID& aGateID, const TERMINAL_ID& aTerminalID )
{
for( std::pair<PART_DEFINITION_PIN_ID, PART::DEFINITION::PIN> pinPair :
aCadstarPart.Definition.Pins )
{
PART::DEFINITION::PIN partPin = pinPair.second;
if( partPin.TerminalGate == aGateID && partPin.TerminalPin == aTerminalID )
return partPin;
}
return PART::DEFINITION::PIN();
}
CADSTAR Schematic Archive Importer: Load pin types Default to passive if undefined
2021-02-02 15:37:10 +00:00
ELECTRICAL_PINTYPE CADSTAR_SCH_ARCHIVE_LOADER::getKiCadPinType( const PART::PIN_TYPE& aPinType )
{
switch( aPinType )
{
case PART::PIN_TYPE::UNCOMMITTED: return ELECTRICAL_PINTYPE::PT_PASSIVE;
case PART::PIN_TYPE::INPUT: return ELECTRICAL_PINTYPE::PT_INPUT;
case PART::PIN_TYPE::OUTPUT_OR: return ELECTRICAL_PINTYPE::PT_OPENCOLLECTOR;
case PART::PIN_TYPE::OUTPUT_NOT_OR: return ELECTRICAL_PINTYPE::PT_OUTPUT;
case PART::PIN_TYPE::OUTPUT_NOT_NORM_OR: return ELECTRICAL_PINTYPE::PT_OUTPUT;
case PART::PIN_TYPE::POWER: return ELECTRICAL_PINTYPE::PT_POWER_IN;
case PART::PIN_TYPE::GROUND: return ELECTRICAL_PINTYPE::PT_POWER_IN;
case PART::PIN_TYPE::TRISTATE_BIDIR: return ELECTRICAL_PINTYPE::PT_BIDI;
case PART::PIN_TYPE::TRISTATE_INPUT: return ELECTRICAL_PINTYPE::PT_INPUT;
case PART::PIN_TYPE::TRISTATE_DRIVER: return ELECTRICAL_PINTYPE::PT_OUTPUT;
}
return ELECTRICAL_PINTYPE::PT_UNSPECIFIED;
}
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
int CADSTAR_SCH_ARCHIVE_LOADER::getKiCadUnitNumberFromGate( const GATE_ID& aCadstarGateID )
{
if( aCadstarGateID.IsEmpty() )
return 1;
return (int) aCadstarGateID.Upper().GetChar( 0 ) - (int) wxUniChar( 'A' ) + 1;
}
More NULL expunging.
2021-07-16 20:13:26 +00:00
LABEL_SPIN_STYLE CADSTAR_SCH_ARCHIVE_LOADER::getSpinStyle( const long long& aCadstarOrientation,
bool aMirror )
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
{
double orientationDeciDegree = getAngleTenthDegree( aCadstarOrientation );
LABEL_SPIN_STYLE spinStyle = getSpinStyleDeciDeg( orientationDeciDegree );
if( aMirror )
{
spinStyle = spinStyle.RotateCCW();
spinStyle = spinStyle.RotateCCW();
}
return spinStyle;
}
LABEL_SPIN_STYLE CADSTAR_SCH_ARCHIVE_LOADER::getSpinStyleDeciDeg(
const double& aOrientationDeciDeg )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
{
LABEL_SPIN_STYLE spinStyle = LABEL_SPIN_STYLE::LEFT;
CADSTAR Schematic Archive Importer: Load Busses and fix minor import bugs Fixed missing tokens that weren't parsed before: - Danglers (in NET_SCH) - Pin numbers (in SYMBOL) - HidePinNames in both PART and PART::DEFINITION, defaulting it to false
2020-09-26 13:27:03 +00:00
int oDeg = (int) NormalizeAngle180( aOrientationDeciDeg );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
if( oDeg >= -450 && oDeg <= 450 )
spinStyle = LABEL_SPIN_STYLE::RIGHT; // 0deg
else if( oDeg >= 450 && oDeg <= 1350 )
CADSTAR Schematic Archive Importer: Fix positioning of global labels Previous calculation did not take into account rotation of the labels when calculating the final position.
2021-02-04 17:51:27 +00:00
spinStyle = LABEL_SPIN_STYLE::UP; // 90deg
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
else if( oDeg >= 1350 || oDeg <= -1350 )
spinStyle = LABEL_SPIN_STYLE::LEFT; // 180deg
else
CADSTAR Schematic Archive Importer: Fix positioning of global labels Previous calculation did not take into account rotation of the labels when calculating the final position.
2021-02-04 17:51:27 +00:00
spinStyle = LABEL_SPIN_STYLE::BOTTOM; // 270deg
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
return spinStyle;
}
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
CADSTAR_SCH_ARCHIVE_LOADER::ALIGNMENT
CADSTAR_SCH_ARCHIVE_LOADER::mirrorX( const ALIGNMENT& aCadstarAlignment )
{
switch( aCadstarAlignment )
{
// Change left to right:
case ALIGNMENT::NO_ALIGNMENT:
case ALIGNMENT::BOTTOMLEFT: return ALIGNMENT::BOTTOMRIGHT;
case ALIGNMENT::CENTERLEFT: return ALIGNMENT::CENTERRIGHT;
case ALIGNMENT::TOPLEFT: return ALIGNMENT::TOPRIGHT;
More NULL expunging.
2021-07-16 20:13:26 +00:00
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
//Change right to left:
case ALIGNMENT::BOTTOMRIGHT: return ALIGNMENT::BOTTOMLEFT;
case ALIGNMENT::CENTERRIGHT: return ALIGNMENT::CENTERLEFT;
case ALIGNMENT::TOPRIGHT: return ALIGNMENT::TOPLEFT;
More NULL expunging.
2021-07-16 20:13:26 +00:00
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
// Center alignment does not mirror:
case ALIGNMENT::BOTTOMCENTER:
case ALIGNMENT::CENTERCENTER:
case ALIGNMENT::TOPCENTER: return aCadstarAlignment;
More NULL expunging.
2021-07-16 20:13:26 +00:00
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
// Shouldn't be here
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
default: wxFAIL_MSG( wxT( "Unknown Cadstar Alignment" ) ); return aCadstarAlignment;
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
}
}
CADSTAR_SCH_ARCHIVE_LOADER::ALIGNMENT
CADSTAR_SCH_ARCHIVE_LOADER::rotate180( const ALIGNMENT& aCadstarAlignment )
{
switch( aCadstarAlignment )
{
case ALIGNMENT::NO_ALIGNMENT:
case ALIGNMENT::BOTTOMLEFT: return ALIGNMENT::TOPRIGHT;
case ALIGNMENT::BOTTOMCENTER: return ALIGNMENT::TOPCENTER;
case ALIGNMENT::BOTTOMRIGHT: return ALIGNMENT::TOPLEFT;
case ALIGNMENT::TOPLEFT: return ALIGNMENT::BOTTOMRIGHT;
case ALIGNMENT::TOPCENTER: return ALIGNMENT::BOTTOMCENTER;
case ALIGNMENT::TOPRIGHT: return ALIGNMENT::BOTTOMLEFT;
case ALIGNMENT::CENTERLEFT: return ALIGNMENT::CENTERRIGHT;
case ALIGNMENT::CENTERCENTER: return ALIGNMENT::CENTERCENTER;
case ALIGNMENT::CENTERRIGHT: return ALIGNMENT::CENTERLEFT;
More NULL expunging.
2021-07-16 20:13:26 +00:00
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
// Shouldn't be here
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
default: wxFAIL_MSG( wxT( "Unknown Cadstar Alignment" ) ); return aCadstarAlignment;
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
}
}
void CADSTAR_SCH_ARCHIVE_LOADER::applyTextSettings( EDA_TEXT* aKiCadTextItem,
const TEXTCODE_ID& aCadstarTextCodeID,
const ALIGNMENT& aCadstarAlignment,
const JUSTIFICATION& aCadstarJustification,
const long long aCadstarOrientAngle,
bool aMirrored )
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
{
More NULL expunging.
2021-07-16 20:13:26 +00:00
// Justification ignored for now as not supported in Eeschema, but leaving this code in
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
// place for future upgrades.
More NULL expunging.
2021-07-16 20:13:26 +00:00
// TODO update this when Eeschema supports justification independent of anchor position.
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
TEXTCODE textCode = getTextCode( aCadstarTextCodeID );
CADSTAR Archive Importer: Fix position of multiline text with NO_ALIGNMENT in CADSTAR
2020-12-30 02:04:19 +00:00
int textHeight = KiROUND( (double) getKiCadLength( textCode.Height ) * TXT_HEIGHT_RATIO );
CADSTAR Archive Importer: Fix loading of non-cadstar font text sizes Non-cadstar fonts use a width of 0.
2021-02-04 18:57:09 +00:00
int textWidth = getKiCadLength( textCode.Width );
Fix issues with new overbar syntax - Update sch text help (~~ no longer gets converted to single ~) - Update Eagle importer to correctly handle new overbar syntax - Update CADSTAR importer to correctly handle new overbar syntax
2021-09-01 18:24:42 +00:00
// Ensure we have no Cadstar overbar characters
wxString escapedText = HandleTextOverbar( aKiCadTextItem->GetText() );
CADSTAR Schematic: Text Loading improvements
2021-03-28 15:45:26 +00:00
aKiCadTextItem->SetText( escapedText );
// The width is zero for all non-cadstar fonts. Using a width equal to 2/3 the height seems
CADSTAR Archive Importer: Fix loading of non-cadstar font text sizes Non-cadstar fonts use a width of 0.
2021-02-04 18:57:09 +00:00
// to work well for most fonts.
if( textWidth == 0 )
CADSTAR Schematic: Text Loading improvements
2021-03-28 15:45:26 +00:00
textWidth = getKiCadLength( 2 * textCode.Height / 3 );
CADSTAR Archive Importer: Fix loading of non-cadstar font text sizes Non-cadstar fonts use a width of 0.
2021-02-04 18:57:09 +00:00
aKiCadTextItem->SetTextWidth( textWidth );
CADSTAR Archive Importer: Fix position of multiline text with NO_ALIGNMENT in CADSTAR
2020-12-30 02:04:19 +00:00
aKiCadTextItem->SetTextHeight( textHeight );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
aKiCadTextItem->SetTextThickness( getKiCadLength( textCode.LineWidth ) );
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
aKiCadTextItem->SetTextAngle( getAngleTenthDegree( aCadstarOrientAngle ) );
aKiCadTextItem->SetBold( textCode.Font.Modifier1 == FONT_BOLD );
aKiCadTextItem->SetItalic( textCode.Font.Italic );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
ALIGNMENT textAlignment = aCadstarAlignment;
// KiCad mirrors the justification and alignment when the symbol is mirrored but CADSTAR
// specifies it post-mirroring. In contrast, if the text item itself is mirrored (not
// supported in KiCad), CADSTAR specifies the alignment and justification pre-mirroring
if( aMirrored )
textAlignment = mirrorX( aCadstarAlignment );
auto setAlignment = [&]( EDA_TEXT* aText, ALIGNMENT aAlignment )
{
switch( aAlignment )
{
case ALIGNMENT::NO_ALIGNMENT: // Bottom left of the first line
//No exact KiCad equivalent, so lets move the position of the text
FixTextPositionNoAlignment( aText );
KI_FALLTHROUGH;
case ALIGNMENT::BOTTOMLEFT:
aText->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
aText->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
break;
case ALIGNMENT::BOTTOMCENTER:
aText->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
aText->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
break;
case ALIGNMENT::BOTTOMRIGHT:
aText->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
aText->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
break;
case ALIGNMENT::CENTERLEFT:
aText->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER );
aText->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
break;
case ALIGNMENT::CENTERCENTER:
aText->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER );
aText->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
break;
case ALIGNMENT::CENTERRIGHT:
aText->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER );
aText->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
break;
case ALIGNMENT::TOPLEFT:
aText->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
aText->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
break;
case ALIGNMENT::TOPCENTER:
aText->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
aText->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
break;
case ALIGNMENT::TOPRIGHT:
aText->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
aText->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
break;
}
};
LABEL_SPIN_STYLE spin = getSpinStyle( aCadstarOrientAngle, aMirrored );
EDA_ITEM* textEdaItem = dynamic_cast<EDA_ITEM*>( aKiCadTextItem );
wxCHECK( textEdaItem, /* void */ ); // ensure this is a EDA_ITEM
switch( textEdaItem->Type() )
{
// Some KiCad schematic text items only permit a limited amount of angles
// and text justifications
CADSTAR Schematic: Fix Text Positioning within Symbols
2021-04-09 19:11:12 +00:00
case LIB_TEXT_T:
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
case SCH_FIELD_T:
case LIB_FIELD_T:
{
// Spin style not used. All text justifications are permitted. However, only orientations
// of 0 deg or 90 deg are supported
double angleDeciDeg = NormalizeAnglePos( aKiCadTextItem->GetTextAngle() );
int quadrant = KiROUND( angleDeciDeg / 900.0 );
quadrant %= 4;
switch( quadrant )
{
case 0:
angleDeciDeg = 0;
break;
case 1:
angleDeciDeg = 900;
break;
case 2:
angleDeciDeg = 0;
textAlignment = rotate180( textAlignment );
break;
case 3:
angleDeciDeg = 900;
textAlignment = rotate180( textAlignment );
break;
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
default: wxFAIL_MSG( wxT( "Unknown Quadrant" ) );
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
}
aKiCadTextItem->SetTextAngle( angleDeciDeg );
setAlignment( aKiCadTextItem, textAlignment );
}
return;
case SCH_TEXT_T:
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
{
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
// Note spin style in a SCH_TEXT results in a vertical alignment GR_TEXT_VJUSTIFY_BOTTOM
// so need to adjust the location of the text element based on Cadstar's original text
// alignment (anchor position).
setAlignment( aKiCadTextItem, textAlignment );
EDA_RECT bb = textEdaItem->GetBoundingBox();
int off = static_cast<SCH_TEXT*>( aKiCadTextItem )->GetTextOffset();
wxPoint pos;
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
// Change the anchor point of the text item to make it match the same bounding box
Fix source comment / documentation typos
2021-06-09 19:32:58 +00:00
// And correct the error introduced by the text offsetting in KiCad
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
switch( spin )
{
case LABEL_SPIN_STYLE::BOTTOM: pos = { bb.GetRight() - off, bb.GetTop() }; break;
case LABEL_SPIN_STYLE::UP: pos = { bb.GetRight() - off, bb.GetBottom() }; break;
case LABEL_SPIN_STYLE::LEFT: pos = { bb.GetRight() , bb.GetBottom() + off }; break;
case LABEL_SPIN_STYLE::RIGHT: pos = { bb.GetLeft() , bb.GetBottom() + off }; break;
}
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
aKiCadTextItem->SetTextPos( pos );
}
KI_FALLTHROUGH;
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
// We don't want to change position of net labels as that would break connectivity
case SCH_LABEL_T:
case SCH_GLOBAL_LABEL_T:
case SCH_HIER_LABEL_T:
case SCH_SHEET_PIN_T:
static_cast<SCH_TEXT*>( aKiCadTextItem )->SetLabelSpinStyle( spin );
return;
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
default:
Default eeschema strings to wide Prevents stack bug on MacOS
2022-02-08 23:14:18 +00:00
wxFAIL_MSG( wxT( "Unexpected item type" ) );
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
return;
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
}
}
More NULL expunging.
2021-07-16 20:13:26 +00:00
CADSTAR Schematic Archive Importer: Load Texts
2020-09-27 02:35:24 +00:00
SCH_TEXT* CADSTAR_SCH_ARCHIVE_LOADER::getKiCadSchText( const TEXT& aCadstarTextElement )
{
SCH_TEXT* kiTxt = new SCH_TEXT();
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
kiTxt->SetParent( m_schematic ); // set to the schematic for now to avoid asserts
CADSTAR Schematic Archive Importer: Load Texts
2020-09-27 02:35:24 +00:00
kiTxt->SetPosition( getKiCadPoint( aCadstarTextElement.Position ) );
kiTxt->SetText( aCadstarTextElement.Text );
CADSTAR Schematic: Fix import of text alignment Ensure that the text alignment applied to text objects corresponds to valid text alignments that can be set within eeschema Fixes https://gitlab.com/kicad/code/kicad/-/issues/8090
2021-04-02 18:50:30 +00:00
applyTextSettings( kiTxt,
aCadstarTextElement.TextCodeID,
aCadstarTextElement.Alignment,
aCadstarTextElement.Justification,
aCadstarTextElement.OrientAngle,
aCadstarTextElement.Mirror );
CADSTAR Schematic Archive Importer: Load Texts
2020-09-27 02:35:24 +00:00
return kiTxt;
}
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
LIB_SYMBOL* CADSTAR_SCH_ARCHIVE_LOADER::getScaledLibPart( const LIB_SYMBOL* aSymbol,
long long aScalingFactorNumerator,
long long aScalingFactorDenominator )
CADSTAR Schematic: Handle scaled symbols Create a new LIB_PART for scaled symbols. These will be then embedded into the schematic file. However when "update from library" is done, it will revert to the unscaled symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/8494
2021-05-28 15:19:04 +00:00
{
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
LIB_SYMBOL* retval = new LIB_SYMBOL( *aSymbol );
CADSTAR Schematic: Handle scaled symbols Create a new LIB_PART for scaled symbols. These will be then embedded into the schematic file. However when "update from library" is done, it will revert to the unscaled symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/8494
2021-05-28 15:19:04 +00:00
if( aScalingFactorNumerator == aScalingFactorDenominator )
return retval; // 1:1 scale, nothing to do
auto scaleLen =
[&]( int aLength ) -> int
{
return( aLength * aScalingFactorNumerator ) / aScalingFactorDenominator;
};
auto scalePt =
[&]( wxPoint aCoord ) -> wxPoint
{
return wxPoint( scaleLen( aCoord.x ), scaleLen( aCoord.y ) );
};
auto scaleSize =
[&]( wxSize aSize ) -> wxSize
{
return wxSize( scaleLen( aSize.x ), scaleLen( aSize.y ) );
};
LIB_ITEMS_CONTAINER& items = retval->GetDrawItems();
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
for( LIB_ITEM& item : items )
CADSTAR Schematic: Handle scaled symbols Create a new LIB_PART for scaled symbols. These will be then embedded into the schematic file. However when "update from library" is done, it will revert to the unscaled symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/8494
2021-05-28 15:19:04 +00:00
{
switch( item.Type() )
{
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
case KICAD_T::LIB_SHAPE_T:
CADSTAR Schematic: Handle scaled symbols Create a new LIB_PART for scaled symbols. These will be then embedded into the schematic file. However when "update from library" is done, it will revert to the unscaled symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/8494
2021-05-28 15:19:04 +00:00
{
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
LIB_SHAPE& shape = static_cast<LIB_SHAPE&>( item );
CADSTAR Schematic: Handle scaled symbols Create a new LIB_PART for scaled symbols. These will be then embedded into the schematic file. However when "update from library" is done, it will revert to the unscaled symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/8494
2021-05-28 15:19:04 +00:00
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
if( shape.GetShape() == SHAPE_T::ARC )
{
shape.SetPosition( scalePt( shape.GetPosition() ) );
shape.SetStart( scalePt( shape.GetStart() ) );
shape.SetEnd( scalePt( shape.GetEnd() ) );
}
else if( shape.GetShape() == SHAPE_T::POLY )
{
SHAPE_LINE_CHAIN& poly = shape.GetPolyShape().Outline( 0 );
CADSTAR Schematic: Handle scaled symbols Create a new LIB_PART for scaled symbols. These will be then embedded into the schematic file. However when "update from library" is done, it will revert to the unscaled symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/8494
2021-05-28 15:19:04 +00:00
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
for( size_t ii = 0; ii < poly.GetPointCount(); ++ii )
poly.SetPoint( ii, scalePt( (wxPoint) poly.CPoint( ii ) ) );
}
CADSTAR Schematic: Handle scaled symbols Create a new LIB_PART for scaled symbols. These will be then embedded into the schematic file. However when "update from library" is done, it will revert to the unscaled symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/8494
2021-05-28 15:19:04 +00:00
}
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
break;
CADSTAR Schematic: Handle scaled symbols Create a new LIB_PART for scaled symbols. These will be then embedded into the schematic file. However when "update from library" is done, it will revert to the unscaled symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/8494
2021-05-28 15:19:04 +00:00
case KICAD_T::LIB_PIN_T:
{
LIB_PIN& pin = static_cast<LIB_PIN&>( item );
pin.SetPosition( scalePt( pin.GetPosition() ) );
pin.SetLength( scaleLen( pin.GetLength() ) );
}
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
break;
CADSTAR Schematic: Handle scaled symbols Create a new LIB_PART for scaled symbols. These will be then embedded into the schematic file. However when "update from library" is done, it will revert to the unscaled symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/8494
2021-05-28 15:19:04 +00:00
case KICAD_T::LIB_TEXT_T:
{
LIB_TEXT& txt = static_cast<LIB_TEXT&>( item );
txt.SetPosition( scalePt( txt.GetPosition() ) );
txt.SetTextSize( scaleSize( txt.GetTextSize() ) );
}
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
break;
CADSTAR Schematic: Handle scaled symbols Create a new LIB_PART for scaled symbols. These will be then embedded into the schematic file. However when "update from library" is done, it will revert to the unscaled symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/8494
2021-05-28 15:19:04 +00:00
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
default:
break;
CADSTAR Schematic: Handle scaled symbols Create a new LIB_PART for scaled symbols. These will be then embedded into the schematic file. However when "update from library" is done, it will revert to the unscaled symbol. Fixes https://gitlab.com/kicad/code/kicad/-/issues/8494
2021-05-28 15:19:04 +00:00
}
}
return retval;
}
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
void CADSTAR_SCH_ARCHIVE_LOADER::fixUpLibraryPins( LIB_SYMBOL* aSymbolToFix, int aGateNumber )
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
{
CADSTAR Sch: Fix spurious pin length and orientation of some symbols Ensure deterministic sorting of std::map in fixUpLibraryPins
2021-10-30 18:20:52 +00:00
auto compLambda = []( const VECTOR2I& aA, const VECTOR2I& aB )
{
return LexicographicalCompare( aA, aB ) < 0;
};
// Store a list of vertical or horizontal segments in the symbol
// Note: Need the custom comparison function to ensure the map is sorted correctly
std::map<VECTOR2I, SHAPE_LINE_CHAIN, decltype( compLambda )> uniqueSegments( compLambda );
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
LIB_ITEMS_CONTAINER::ITERATOR shapeIt = aSymbolToFix->GetDrawItems().begin( LIB_SHAPE_T );
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
for( ; shapeIt != aSymbolToFix->GetDrawItems().end( LIB_SHAPE_T ); ++shapeIt )
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
{
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
LIB_SHAPE& shape = static_cast<LIB_SHAPE&>( *shapeIt );
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
if( aGateNumber > 0 && shape.GetUnit() != aGateNumber )
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
continue;
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
if( shape.GetShape() != SHAPE_T::POLY )
continue;
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
CADSTAR Sch: Fix spurious pin length and orientation of some symbols Ensure deterministic sorting of std::map in fixUpLibraryPins
2021-10-30 18:20:52 +00:00
SHAPE_LINE_CHAIN poly = shape.GetPolyShape().Outline( 0 );
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
if( poly.GetPointCount() == 2 )
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
{
CADSTAR Sch: Fix spurious pin length and orientation of some symbols Ensure deterministic sorting of std::map in fixUpLibraryPins
2021-10-30 18:20:52 +00:00
VECTOR2I pt0 = poly.CPoint( 0 );
VECTOR2I pt1 = poly.CPoint( 1 );
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
CADSTAR Sch: Fix spurious pin length and orientation of some symbols Ensure deterministic sorting of std::map in fixUpLibraryPins
2021-10-30 18:20:52 +00:00
if( pt0 != pt1 && uniqueSegments.count( pt0 ) == 0 && uniqueSegments.count( pt1 ) == 0 )
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
{
CADSTAR Schematic: Fix crash when trying to fix library pins Need to copy the chain as we might have deleted it.
2021-10-17 12:43:01 +00:00
// we are only interested in vertical or horizontal segments
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
if( pt0.x == pt1.x || pt0.y == pt1.y )
{
CADSTAR Sch: Fix spurious pin length and orientation of some symbols Ensure deterministic sorting of std::map in fixUpLibraryPins
2021-10-30 18:20:52 +00:00
uniqueSegments.insert( { pt0, poly } );
uniqueSegments.insert( { pt1, poly } );
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
}
}
}
}
LIB_PINS pins;
Rename LIB_PART to LIB_SYMBOL.
2021-06-10 18:51:46 +00:00
aSymbolToFix->GetPins( pins, aGateNumber );
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
for( auto& pin : pins )
{
auto setPinOrientation =
[&]( double aAngleRad )
{
Cleanup RAD2DEG and unused vars
2021-05-28 19:37:57 +00:00
int oDeg = (int) NormalizeAngle180( RAD2DEG( aAngleRad ) );
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
if( oDeg >= -45 && oDeg <= 45 )
pin->SetOrientation( 'R' ); // 0 degrees
else if( oDeg >= 45 && oDeg <= 135 )
pin->SetOrientation( 'U' ); // 90 degrees
else if( oDeg >= 135 || oDeg <= -135 )
pin->SetOrientation( 'L' ); // 180 degrees
else
pin->SetOrientation( 'D' ); // -90 degrees
};
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
if( uniqueSegments.count( pin->GetPosition() ) )
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
{
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
SHAPE_LINE_CHAIN& poly = uniqueSegments.at( pin->GetPosition() );
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
VECTOR2I otherPt = poly.CPoint( 0 );
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
if( otherPt == pin->GetPosition() )
Replace individual LIB_* shapes with LIB_SHAPE (based on EDA_SHAPE). Also moves to more capable FILL_T model that can be shared.
2021-07-18 23:08:54 +00:00
otherPt = poly.CPoint( 1 );
CADSTAR Schematic: Cleanup pins in symbols In CADSTAR pins are single points. We can replicate the original look of the schematic in most cases by searching the symbol for straight segments that are coincident with the pin and use those to calculate a suitable pin length and angle.
2021-05-28 18:39:08 +00:00
VECTOR2I vec( otherPt - pin->GetPosition() );
pin->SetLength( vec.EuclideanNorm() );
setPinOrientation( vec.Angle() );
}
}
}
More NULL expunging.
2021-07-16 20:13:26 +00:00
std::pair<wxPoint, wxSize> CADSTAR_SCH_ARCHIVE_LOADER::getFigureExtentsKiCad(
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
const FIGURE& aCadstarFigure )
{
wxPoint upperLeft( Assignments.Settings.DesignLimit.x, 0 );
wxPoint lowerRight( 0, Assignments.Settings.DesignLimit.y );
for( const VERTEX& v : aCadstarFigure.Shape.Vertices )
{
if( upperLeft.x > v.End.x )
upperLeft.x = v.End.x;
if( upperLeft.y < v.End.y )
upperLeft.y = v.End.y;
if( lowerRight.x < v.End.x )
lowerRight.x = v.End.x;
if( lowerRight.y > v.End.y )
lowerRight.y = v.End.y;
}
for( CUTOUT cutout : aCadstarFigure.Shape.Cutouts )
{
for( const VERTEX& v : aCadstarFigure.Shape.Vertices )
{
if( upperLeft.x > v.End.x )
upperLeft.x = v.End.x;
if( upperLeft.y < v.End.y )
upperLeft.y = v.End.y;
if( lowerRight.x < v.End.x )
lowerRight.x = v.End.x;
if( lowerRight.y > v.End.y )
lowerRight.y = v.End.y;
}
}
wxPoint upperLeftKiCad = getKiCadPoint( upperLeft );
wxPoint lowerRightKiCad = getKiCadPoint( lowerRight );
wxPoint size = lowerRightKiCad - upperLeftKiCad;
return { upperLeftKiCad, wxSize( abs( size.x ), abs( size.y ) ) };
}
Pass wxPoint objects by reference instead of on the stack.
2021-07-26 19:35:12 +00:00
wxPoint CADSTAR_SCH_ARCHIVE_LOADER::getKiCadPoint( const wxPoint& aCadstarPoint )
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
{
wxPoint retval;
CADSTAR Schematic Archive Importer: Fix Coordinate Rounding error Rewrite of the calculation to convert CADSTAR to KiCad coordinates, rounding half way cases away from zero. Use integer division instead of double, to ensure precision.
2021-02-18 18:02:49 +00:00
retval.x = getKiCadLength( aCadstarPoint.x - m_designCenter.x );
retval.y = -getKiCadLength( aCadstarPoint.y - m_designCenter.y );
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
return retval;
}
Pass wxPoint objects by reference instead of on the stack.
2021-07-26 19:35:12 +00:00
wxPoint CADSTAR_SCH_ARCHIVE_LOADER::getKiCadLibraryPoint( const wxPoint& aCadstarPoint,
const wxPoint& aCadstarCentre )
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
{
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
wxPoint retval;
CADSTAR Schematic Archive Importer: Fix Coordinate Rounding error Rewrite of the calculation to convert CADSTAR to KiCad coordinates, rounding half way cases away from zero. Use integer division instead of double, to ensure precision.
2021-02-18 18:02:49 +00:00
retval.x = getKiCadLength( aCadstarPoint.x - aCadstarCentre.x );
retval.y = getKiCadLength( aCadstarPoint.y - aCadstarCentre.y );
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
return retval;
}
ADDED: CADSTAR Schematic Archive Importer Initial commit to trigger the importer
2020-09-08 19:51:22 +00:00
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
CADSTAR Schematic Archive Importer: Load Documentation Symbols
2020-09-27 12:19:51 +00:00
wxPoint CADSTAR_SCH_ARCHIVE_LOADER::applyTransform( const wxPoint& aPoint,
const wxPoint& aMoveVector, const double& aRotationAngleDeciDeg,
const double& aScalingFactor, const wxPoint& aTransformCentre, const bool& aMirrorInvert )
{
wxPoint retVal = aPoint;
if( aScalingFactor != 1.0 )
{
//scale point
retVal -= aTransformCentre;
retVal.x = KiROUND( retVal.x * aScalingFactor );
retVal.y = KiROUND( retVal.y * aScalingFactor );
retVal += aTransformCentre;
}
if( aMirrorInvert )
{
MIRROR( retVal.x, aTransformCentre.x );
}
if( aRotationAngleDeciDeg != 0.0 )
{
RotatePoint( &retVal, aTransformCentre, aRotationAngleDeciDeg );
}
if( aMoveVector != wxPoint{ 0, 0 } )
{
retVal += aMoveVector;
}
return retVal;
}
Pass wxPoint objects by reference instead of on the stack.
2021-07-26 19:35:12 +00:00
double CADSTAR_SCH_ARCHIVE_LOADER::getPolarAngle( const wxPoint& aPoint )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
{
CADSTAR Schematic Archive Importer: Load all Sheets and Hierarchical Blocks
2020-09-19 22:05:02 +00:00
return NormalizeAnglePos( ArcTangente( aPoint.y, aPoint.x ) );
ADDED: CADSTAR Schematic Archive Importer Initial commit to trigger the importer
2020-09-08 19:51:22 +00:00
}
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
Pass wxPoint objects by reference instead of on the stack.
2021-07-26 19:35:12 +00:00
double CADSTAR_SCH_ARCHIVE_LOADER::getPolarRadius( const wxPoint& aPoint )
CADSTAR Schematic Archive Importer: Load symbol library and schematic symbol instances
2020-09-20 21:08:46 +00:00
{
return sqrt(
( (double) aPoint.x * (double) aPoint.x ) + ( (double) aPoint.y * (double) aPoint.y ) );
}