#include <cadstar_sch_archive_loader.h>

Inheritance diagram for CADSTAR_SCH_ARCHIVE_LOADER:

Public Types
enum class	TERMINAL_SHAPE_TYPE { ANNULUS , BOX , BULLET , CIRCLE , CROSS , DIAMOND , FINGER , OCTAGON , PLUS , POINTER , RECTANGLE , ROUNDED_RECT , SQUARE , STAR , TRIANGLE , UNDEFINED }

typedef wxString	TERMINALCODE_ID

typedef wxString	SYMBOL_ID

typedef wxString	BUS_ID

typedef wxString	BLOCK_ID

typedef wxString	SHEET_NAME

enum class	TEXT_FIELD_NAME { DESIGN_TITLE , SHORT_JOBNAME , LONG_JOBNAME , NUM_OF_SHEETS , SHEET_NUMBER , SHEET_NAME , VARIANT_NAME , VARIANT_DESCRIPTION , REG_USER , COMPANY_NAME , CURRENT_USER , DATE , TIME , MACHINE_NAME , FROM_FILE , DISTANCE , UNITS_SHORT , UNITS_ABBREV , UNITS_FULL , HYPERLINK , NONE }
	These are special fields in text objects enclosed between the tokens '<@' and '>' such as <@[FIELD_NAME][FIELD_VALUE]>. More...

enum class	RESOLUTION { HUNDREDTH_MICRON }

enum class	LINESTYLE { SOLID , DASH , DASHDOT , DASHDOTDOT , DOT }

enum class	VERTEX_TYPE { POINT , CLOCKWISE_ARC , CLOCKWISE_SEMICIRCLE , ANTICLOCKWISE_ARC , ANTICLOCKWISE_SEMICIRCLE }

enum class	SHAPE_TYPE { OPENSHAPE , OUTLINE , SOLID , HATCHED }

enum class	UNITS { DESIGN , THOU , INCH , MICROMETRE , MM , CENTIMETER , METER }

enum class	ANGUNITS { DEGREES , RADIANS }

enum class	GRID_TYPE { FRACTIONALGRID , STEPGRID }

enum class	ALIGNMENT { NO_ALIGNMENT , TOPLEFT , TOPCENTER , TOPRIGHT , CENTERLEFT , CENTERCENTER , CENTERRIGHT , BOTTOMLEFT , BOTTOMCENTER , BOTTOMRIGHT }
	From CADSTAR Help: "Text Alignment enables you to define the position of an alignment origin for all text items in CADSTAR. More...

enum class	JUSTIFICATION { LEFT , CENTER , RIGHT }
	From CADSTAR Help: "Multi Line Text can also be justified as Left, Centre or Right. More...

enum class	READABILITY { BOTTOM_TO_TOP , TOP_TO_BOTTOM }
	Sets the readability direction of text. More...

enum class	ATTROWNER { ALL_ITEMS , AREA , BOARD , COMPONENT , CONNECTION , COPPER , DOCSYMBOL , FIGURE , NET , NETCLASS , PART , PART_DEFINITION , PIN , SIGNALREF , SYMBOL , SYMDEF , TEMPLATE , TESTPOINT }

enum class	ATTRUSAGE { BOTH , COMPONENT , PART_DEFINITION , PART_LIBRARY , SYMBOL , UNDEFINED }

enum class	SWAP_RULE { NO_SWAP , USE_SWAP_LAYER , BOTH }
	Corresponds to "Display when" Item property. More...

typedef wxString	LINECODE_ID

typedef wxString	HATCHCODE_ID

typedef wxString	ROUTECODE_ID

typedef wxString	NETCLASS_ID

typedef wxString	SPACING_CLASS_ID

typedef wxString	TEXTCODE_ID

typedef wxString	LAYER_ID
	ID of a Sheet (if schematic) or board Layer (if PCB) More...

typedef wxString	VARIANT_ID

typedef wxString	ATTRIBUTE_ID

typedef wxString	SYMDEF_ID

typedef wxString	PART_ID

typedef wxString	GATE_ID

typedef long	TERMINAL_ID
	Terminal is the pin identifier in the schematic. More...

typedef long	PART_DEFINITION_PIN_ID
	Pin identifier in the part definition. More...

typedef long	PART_PIN_ID
	Pin identifier in the part. More...

typedef wxString	TEXT_ID

typedef wxString	FIGURE_ID

typedef wxString	GROUP_ID

typedef wxString	REUSEBLOCK_ID

typedef wxString	NET_ID

typedef wxString	NETELEMENT_ID

typedef wxString	DOCUMENTATION_SYMBOL_ID

typedef wxString	COLOR_ID

Public Member Functions
	CADSTAR_SCH_ARCHIVE_LOADER (wxString aFilename, REPORTER aReporter, PROGRESS_REPORTER aProgressReporter)

	~CADSTAR_SCH_ARCHIVE_LOADER ()

void	Load (SCHEMATIC aSchematic, SCH_SHEET aRootSheet, SCH_PLUGIN::SCH_PLUGIN_RELEASER *aSchPlugin, const wxFileName &aLibraryFileName)
	Loads a CADSTAR PCB Archive file into the KiCad BOARD object given. More...

void	Parse ()
	Parses the file. More...

Static Public Member Functions
static TERMINAL_SHAPE_TYPE	ParseTermShapeType (const wxString &aShapeStr)

static wxString	ParseTextFields (const wxString &aTextString, PARSER_CONTEXT *aParserContext)
	Replaces CADSTAR fields for the equivalent in KiCad and stores the field values in aParserContext. More...

static UNITS	ParseUnits (XNODE *aNode)

static ANGUNITS	ParseAngunits (XNODE *aNode)

static ALIGNMENT	ParseAlignment (XNODE *aNode)

static JUSTIFICATION	ParseJustification (XNODE *aNode)

static READABILITY	ParseReadability (XNODE *aNode)

static SWAP_RULE	ParseSwapRule (XNODE *aNode)

static void	InsertAttributeAtEnd (XNODE *aNode, wxString aValue)

static XNODE *	LoadArchiveFile (const wxString &aFileName, const wxString &aFileTypeIdentifier, PROGRESS_REPORTER *aProgressReporter=nullptr)
	Reads a CADSTAR Archive file (S-parameter format) More...

static bool	IsValidAttribute (wxXmlAttribute *aAttribute)

static wxString	GetXmlAttributeIDString (XNODE *aNode, unsigned int aID, bool aIsRequired=true)

static long	GetXmlAttributeIDLong (XNODE *aNode, unsigned int aID, bool aIsRequired=true)

static void	CheckNoChildNodes (XNODE *aNode)

static void	CheckNoNextNodes (XNODE *aNode)

static void	ParseChildEValue (XNODE aNode, PARSER_CONTEXT aContext, EVALUE &aValueToParse)

static std::vector< POINT >	ParseAllChildPoints (XNODE aNode, PARSER_CONTEXT aContext, bool aTestAllChildNodes=false, int aExpectedNumPoints=UNDEFINED_VALUE)
	if no children are present, it just returns an empty vector (without throwing an exception) More...

static std::vector< VERTEX >	ParseAllChildVertices (XNODE aNode, PARSER_CONTEXT aContext, bool aTestAllChildNodes=false)
	if no children are present, it just returns an empty vector (without throwing an exception) More...

static std::vector< CUTOUT >	ParseAllChildCutouts (XNODE aNode, PARSER_CONTEXT aContext, bool aTestAllChildNodes=false)
	if no children are present, it just returns an empty vector (without throwing an exception) More...

static long	GetNumberOfChildNodes (XNODE *aNode)

static long	GetNumberOfStepsForReporting (XNODE *aRootNode, std::vector< wxString > aSubNodeChildrenToCount)

static wxString	HandleTextOverbar (wxString aCadstarString)
	Convert a string with CADSTAR overbar characters to equivalent in KiCad. More...

static void	FixTextPositionNoAlignment (EDA_TEXT *aKiCadTextItem)
	Corrects the position of a text element that had NO_ALIGNMENT in CADSTAR. More...

static wxString	generateLibName (const wxString &aRefName, const wxString &aAlternateName)

Public Attributes
const int	SMALL_LABEL_SIZE = KiROUND( (double) SCH_IU_PER_MM * 0.4 )

wxString	Filename

HEADER	Header

ASSIGNMENTS_SCM	Assignments

LIBRARY_SCM	Library

PARTS	Parts

SHEETS	Sheets

CADSTAR_SCHEMATIC	Schematic

ATTRCOLORS	AttrColors

PARTNAMECOL	SymbolPartNameColor

int	KiCadUnitDivider
	Use this value to convert units in this CSA file to KiCad units. More...

Static Public Attributes
static const long	UNDEFINED_VALUE = -1

static const double	TXT_HEIGHT_RATIO = ( 24.0 - 5.0 ) / 24.0
	CADSTAR fonts are drawn on a 24x24 integer matrix, where the each axis goes from 0 to 24. More...

static const std::map< TEXT_FIELD_NAME, wxString >	CADSTAR_TO_KICAD_FIELDS
	Map between CADSTAR fields and KiCad text variables. More...

static const long	FONT_NORMAL = 400

static const long	FONT_BOLD = 700

Protected Member Functions
void	checkPoint ()
	Updates m_progressReporter or throws if user cancelled. More...

Protected Attributes
PARSER_CONTEXT	m_context

PROGRESS_REPORTER *	m_progressReporter

Private Types
typedef std::pair< BLOCK_ID, TERMINAL_ID >	BLOCK_PIN_ID

typedef std::pair< PART_ID, GATE_ID >	PART_GATE_ID

typedef std::map< TERMINAL_ID, wxString >	TERMINAL_TO_PINNUM_MAP
	Map between a terminal ID in a symbol definition to the pin number that should be imported into KiCad. More...

Private Member Functions
void	loadSheets ()

void	loadHierarchicalSheetPins ()

void	loadPartsLibrary ()

void	loadSchematicSymbolInstances ()

void	loadBusses ()

void	loadNets ()

void	loadFigures ()

void	loadTexts ()

void	loadDocumentationSymbols ()

void	loadTextVariables ()

void	loadSheetAndChildSheets (LAYER_ID aCadstarSheetID, const VECTOR2I &aPosition, VECTOR2I aSheetSize, const SCH_SHEET_PATH &aParentSheet)

void	loadChildSheets (LAYER_ID aCadstarSheetID, const SCH_SHEET_PATH &aSheet)

std::vector< LAYER_ID >	findOrphanSheets ()

int	getSheetNumber (LAYER_ID aCadstarSheetID)

void	loadItemOntoKiCadSheet (LAYER_ID aCadstarSheetID, SCH_ITEM *aItem)

void	loadSymDefIntoLibrary (const SYMDEF_ID &aSymdefID, const PART aCadstarPart, const GATE_ID &aGateID, LIB_SYMBOL aSymbol)

void	loadLibrarySymbolShapeVertices (const std::vector< VERTEX > &aCadstarVertices, wxPoint aSymbolOrigin, LIB_SYMBOL *aSymbol, int aGateNumber, int aLineThickness)

void	applyToLibraryFieldAttribute (const ATTRIBUTE_LOCATION &aCadstarAttrLoc, wxPoint aSymbolOrigin, LIB_FIELD *aKiCadField)

SCH_SYMBOL *	loadSchematicSymbol (const SYMBOL &aCadstarSymbol, const LIB_SYMBOL &aKiCadPart, EDA_ANGLE &aComponentOrientation)

void	loadSymbolFieldAttribute (const ATTRIBUTE_LOCATION &aCadstarAttrLoc, const EDA_ANGLE &aComponentOrientation, bool aIsMirrored, SCH_FIELD *aKiCadField)

int	getComponentOrientation (const EDA_ANGLE &aOrientAngle, EDA_ANGLE &aReturnedOrientation)

POINT	getLocationOfNetElement (const NET_SCH &aNet, const NETELEMENT_ID &aNetElementID)

wxString	getNetName (const NET_SCH &aNet)

void	loadGraphicStaightSegment (const VECTOR2I &aStartPoint, const VECTOR2I &aEndPoint, const LINECODE_ID &aCadstarLineCodeID, const LAYER_ID &aCadstarSheetID, const SCH_LAYER_ID &aKiCadSchLayerID, const VECTOR2I &aMoveVector={ 0, 0 }, const EDA_ANGLE &aRotation=ANGLE_0, const double &aScalingFactor=1.0, const VECTOR2I &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)

void	loadShapeVertices (const std::vector< VERTEX > &aCadstarVertices, LINECODE_ID aCadstarLineCodeID, LAYER_ID aCadstarSheetID, SCH_LAYER_ID aKiCadSchLayerID, const VECTOR2I &aMoveVector={ 0, 0 }, const EDA_ANGLE &aRotation=ANGLE_0, const double &aScalingFactor=1.0, const VECTOR2I &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)

void	loadFigure (const FIGURE &aCadstarFigure, const LAYER_ID &aCadstarSheetIDOverride, SCH_LAYER_ID aKiCadSchLayerID, const VECTOR2I &aMoveVector={ 0, 0 }, const EDA_ANGLE &aRotation=ANGLE_0, const double &aScalingFactor=1.0, const VECTOR2I &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)

void	applyTextSettings (EDA_TEXT *aKiCadTextItem, const TEXTCODE_ID &aCadstarTextCodeID, const ALIGNMENT &aCadstarAlignment, const JUSTIFICATION &aCadstarJustification, const long long aCadstarOrientAngle=0, bool aMirrored=false)

SCH_TEXT *	getKiCadSchText (const TEXT &aCadstarTextElement)

SYMDEF_ID	getSymDefFromName (const wxString &aSymdefName, const wxString &aSymDefAlternate)

bool	isAttributeVisible (const ATTRIBUTE_ID &aCadstarAttributeID)

int	getLineThickness (const LINECODE_ID &aCadstarLineCodeID)

PLOT_DASH_TYPE	getLineStyle (const LINECODE_ID &aCadstarLineCodeID)

PART	getPart (const PART_ID &aCadstarPartID)

ROUTECODE	getRouteCode (const ROUTECODE_ID &aCadstarRouteCodeID)

TEXTCODE	getTextCode (const TEXTCODE_ID &aCadstarTextCodeID)

int	getTextHeightFromTextCode (const TEXTCODE_ID &aCadstarTextCodeID)

wxString	getAttributeName (const ATTRIBUTE_ID &aCadstarAttributeID)

PART::DEFINITION::PIN	getPartDefinitionPin (const PART &aCadstarPart, const GATE_ID &aGateID, const TERMINAL_ID &aTerminalID)

ELECTRICAL_PINTYPE	getKiCadPinType (const PART::PIN_TYPE &aPinType)

int	getKiCadUnitNumberFromGate (const GATE_ID &aCadstarGateID)

TEXT_SPIN_STYLE	getSpinStyle (const long long &aCadstarOrientation, bool aMirror)

TEXT_SPIN_STYLE	getSpinStyle (const EDA_ANGLE &aOrientation)

ALIGNMENT	mirrorX (const ALIGNMENT &aCadstarAlignment)

ALIGNMENT	rotate180 (const ALIGNMENT &aCadstarAlignment)

LIB_SYMBOL *	getScaledLibPart (const LIB_SYMBOL *aSymbol, long long aScalingFactorNumerator, long long aScalingFactorDenominator)

void	fixUpLibraryPins (LIB_SYMBOL *aSymbolToFix, int aGateNumber)

std::pair< VECTOR2I, wxSize >	getFigureExtentsKiCad (const FIGURE &aCadstarFigure)

VECTOR2I	getKiCadPoint (const VECTOR2I &aCadstarPoint)

wxPoint	getKiCadLibraryPoint (const wxPoint &aCadstarPoint, const wxPoint &aCadstarCentre)

VECTOR2I	applyTransform (const VECTOR2I &aPoint, const VECTOR2I &aMoveVector={ 0, 0 }, const EDA_ANGLE &aRotation=ANGLE_0, const double &aScalingFactor=1.0, const VECTOR2I &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)

int	getKiCadLength (long long aCadstarLength)

EDA_ANGLE	getAngle (const long long &aCadstarAngle)

long long	getCadstarAngle (const EDA_ANGLE &aAngle)

double	getPolarRadius (const VECTOR2I &aPoint)

Private Attributes
REPORTER *	m_reporter

SCHEMATIC *	m_schematic

SCH_SHEET *	m_rootSheet

SCH_PLUGIN::SCH_PLUGIN_RELEASER *	m_plugin

wxFileName	m_libraryFileName

wxPoint	m_designCenter
	Used for calculating the required offset to apply to the Cadstar design so that it fits in KiCad canvas. More...

std::map< LAYER_ID, SCH_SHEET * >	m_sheetMap
	Map between Cadstar and KiCad Sheets. More...

std::map< BLOCK_PIN_ID, SCH_HIERLABEL * >	m_sheetPinMap
	Map between Cadstar and KiCad Sheets Pins. More...

std::map< PART_ID, LIB_SYMBOL * >	m_partMap
	Map between Cadstar and KiCad Parts. More...

std::map< PART_GATE_ID, SYMDEF_ID >	m_partSymbolsMap
	Map holding the symbols loaded so far for a particular PART_ID and GATE_ID. More...

std::map< PART_ID, TERMINAL_TO_PINNUM_MAP >	m_pinNumsMap
	Map of pin numbers in CADSTAR parts. More...

std::map< wxString, LIB_SYMBOL * >	m_powerSymLibMap
	Map of KiCad Power Symbol Library items. More...

std::map< SYMBOL_ID, SCH_SYMBOL * >	m_powerSymMap
	Map between Cadstar and KiCad Power Symbols. More...

std::map< SYMBOL_ID, SCH_GLOBALLABEL * >	m_globalLabelsMap
	Map between Cadstar and KiCad Global Labels. More...

std::map< BUS_ID, std::shared_ptr< BUS_ALIAS > >	m_busesMap
	Map of Cadstar and KiCad Buses. More...

Detailed Description

Definition at line 52 of file cadstar_sch_archive_loader.h.

Member Typedef Documentation

◆ ATTRIBUTE_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_ID

inherited

Definition at line 100 of file cadstar_archive_parser.h.

◆ BLOCK_ID

typedef wxString CADSTAR_SCH_ARCHIVE_PARSER::BLOCK_ID

inherited

Definition at line 54 of file cadstar_sch_archive_parser.h.

◆ BLOCK_PIN_ID

typedef std::pair<BLOCK_ID, TERMINAL_ID> CADSTAR_SCH_ARCHIVE_LOADER::BLOCK_PIN_ID

private

Definition at line 86 of file cadstar_sch_archive_loader.h.

◆ BUS_ID

typedef wxString CADSTAR_SCH_ARCHIVE_PARSER::BUS_ID

inherited

Definition at line 53 of file cadstar_sch_archive_parser.h.

◆ COLOR_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::COLOR_ID

inherited

Definition at line 114 of file cadstar_archive_parser.h.

◆ DOCUMENTATION_SYMBOL_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::DOCUMENTATION_SYMBOL_ID

inherited

Definition at line 113 of file cadstar_archive_parser.h.

◆ FIGURE_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::FIGURE_ID

inherited

Definition at line 108 of file cadstar_archive_parser.h.

◆ GATE_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::GATE_ID

inherited

Definition at line 103 of file cadstar_archive_parser.h.

◆ GROUP_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::GROUP_ID

inherited

Definition at line 109 of file cadstar_archive_parser.h.

◆ HATCHCODE_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::HATCHCODE_ID

inherited

Definition at line 93 of file cadstar_archive_parser.h.

◆ LAYER_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::LAYER_ID

inherited

ID of a Sheet (if schematic) or board Layer (if PCB)

Definition at line 98 of file cadstar_archive_parser.h.

◆ LINECODE_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::LINECODE_ID

inherited

Definition at line 92 of file cadstar_archive_parser.h.

◆ NET_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::NET_ID

inherited

Definition at line 111 of file cadstar_archive_parser.h.

◆ NETCLASS_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::NETCLASS_ID

inherited

Definition at line 95 of file cadstar_archive_parser.h.

◆ NETELEMENT_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::NETELEMENT_ID

inherited

Definition at line 112 of file cadstar_archive_parser.h.

◆ PART_DEFINITION_PIN_ID

typedef long CADSTAR_ARCHIVE_PARSER::PART_DEFINITION_PIN_ID

inherited

Pin identifier in the part definition.

Definition at line 105 of file cadstar_archive_parser.h.

◆ PART_GATE_ID

typedef std::pair<PART_ID, GATE_ID> CADSTAR_SCH_ARCHIVE_LOADER::PART_GATE_ID

private

Definition at line 87 of file cadstar_sch_archive_loader.h.

◆ PART_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::PART_ID

inherited

Definition at line 102 of file cadstar_archive_parser.h.

◆ PART_PIN_ID

typedef long CADSTAR_ARCHIVE_PARSER::PART_PIN_ID

inherited

Pin identifier in the part.

Definition at line 106 of file cadstar_archive_parser.h.

◆ REUSEBLOCK_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::REUSEBLOCK_ID

inherited

Definition at line 110 of file cadstar_archive_parser.h.

◆ ROUTECODE_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::ROUTECODE_ID

inherited

Definition at line 94 of file cadstar_archive_parser.h.

◆ SHEET_NAME

typedef wxString CADSTAR_SCH_ARCHIVE_PARSER::SHEET_NAME

inherited

Definition at line 55 of file cadstar_sch_archive_parser.h.

◆ SPACING_CLASS_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::SPACING_CLASS_ID

inherited

Definition at line 96 of file cadstar_archive_parser.h.

◆ SYMBOL_ID

typedef wxString CADSTAR_SCH_ARCHIVE_PARSER::SYMBOL_ID

inherited

Definition at line 52 of file cadstar_sch_archive_parser.h.

◆ SYMDEF_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::SYMDEF_ID

inherited

Definition at line 101 of file cadstar_archive_parser.h.

◆ TERMINAL_ID

typedef long CADSTAR_ARCHIVE_PARSER::TERMINAL_ID

inherited

Terminal is the pin identifier in the schematic.

Definition at line 104 of file cadstar_archive_parser.h.

◆ TERMINAL_TO_PINNUM_MAP

typedef std::map<TERMINAL_ID, wxString> CADSTAR_SCH_ARCHIVE_LOADER::TERMINAL_TO_PINNUM_MAP

private

Map between a terminal ID in a symbol definition to the pin number that should be imported into KiCad.

Definition at line 93 of file cadstar_sch_archive_loader.h.

◆ TERMINALCODE_ID

typedef wxString CADSTAR_SCH_ARCHIVE_PARSER::TERMINALCODE_ID

inherited

Definition at line 51 of file cadstar_sch_archive_parser.h.

◆ TEXT_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::TEXT_ID

inherited

Definition at line 107 of file cadstar_archive_parser.h.

◆ TEXTCODE_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::TEXTCODE_ID

inherited

Definition at line 97 of file cadstar_archive_parser.h.

◆ VARIANT_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::VARIANT_ID

inherited

Definition at line 99 of file cadstar_archive_parser.h.

Member Enumeration Documentation

◆ ALIGNMENT

enum class CADSTAR_ARCHIVE_PARSER::ALIGNMENT

stronginherited

From CADSTAR Help: "Text Alignment enables you to define the position of an alignment origin for all text items in CADSTAR.

The alignment origin is a point on or within the text boundary and defines how the text is displayed.

For example, with an alignment of bottom-right the origin will be positioned at the bottom right of the text boundary. This makes it easier to right-align several text items regardless of the length of text displayed.

Text Alignment applies to all CADSTAR text. [...]

Note: Unaligned text operates in the way CADSTAR text always has. In most cases this behaves as Bottom Left alignment, but there are a few exceptions, e.g. pin names. Also unaligned multiline text has an origin Bottom Left of the first line."

◆ ANGUNITS

enum class CADSTAR_ARCHIVE_PARSER::ANGUNITS

stronginherited

Enumerator
DEGREES
RADIANS

Definition at line 486 of file cadstar_archive_parser.h.

 {
 DEGREES,
 RADIANS
 };

◆ ATTROWNER

enum class CADSTAR_ARCHIVE_PARSER::ATTROWNER

stronginherited

Enumerator
ALL_ITEMS
AREA
BOARD
COMPONENT
CONNECTION
COPPER
DOCSYMBOL
FIGURE
NET
NETCLASS
PART	Only library Attributes.
PART_DEFINITION	Only library Attributes.
PIN
SIGNALREF
SYMBOL
SYMDEF
TEMPLATE
TESTPOINT

Definition at line 630 of file cadstar_archive_parser.h.

 {
 ALL_ITEMS,
 AREA,
 BOARD,
 COMPONENT,
 CONNECTION,
 COPPER,
 DOCSYMBOL,
 FIGURE,
 NET,
 NETCLASS,
 PART, 
 PART_DEFINITION, 
 PIN,
 SIGNALREF,
 SYMBOL,
 SYMDEF,
 TEMPLATE,
 TESTPOINT
 };

◆ ATTRUSAGE

enum class CADSTAR_ARCHIVE_PARSER::ATTRUSAGE

stronginherited

Enumerator
BOTH	From CADSTAR Help: Assigned to both Schematic symbols and PCB components, and displayed on Schematic and PCB designs.
COMPONENT	From CADSTAR Help: Assigned to PCB components and displayed on PCB designs.
PART_DEFINITION	From CADSTAR Help: Assigned to Parts library Definitions and displayed by the Library searcher.
PART_LIBRARY	From CADSTAR Help: Only used by non-Cadstar applications.
SYMBOL	From CADSTAR Help: Assigned to Schematic Symbols and displayed on Schematic Designs.
UNDEFINED	Note: It seems that some attribute have no "ATTRUSAGE" defined. It appears that the attributes that fall under this category are the ones associated with the design itself (i.e. not inherited from the library)

Definition at line 653 of file cadstar_archive_parser.h.

 {
 BOTH, 
 COMPONENT, 
 PART_DEFINITION, 
 PART_LIBRARY, 
 SYMBOL, 
 UNDEFINED 
 };

◆ GRID_TYPE

enum class CADSTAR_ARCHIVE_PARSER::GRID_TYPE

stronginherited

Enumerator

FRACTIONALGRID

Param1 = Units, Param2 = Divisor.

The grid is equal in X and Y dimensions with a step size equal to Param1/Param2

STEPGRID

Param1 = X Step, Param2 = Y Step. A standard x,y grid.

Definition at line 496 of file cadstar_archive_parser.h.

 {
 FRACTIONALGRID, 
 STEPGRID 
 };

◆ JUSTIFICATION

enum class CADSTAR_ARCHIVE_PARSER::JUSTIFICATION

stronginherited

From CADSTAR Help: "Multi Line Text can also be justified as Left, Centre or Right.

This does not affect the text alignment. Note: Justification of single line text has no effect."

This only affects multiline text

◆ LINESTYLE

enum class CADSTAR_ARCHIVE_PARSER::LINESTYLE

stronginherited

Enumerator
SOLID
DASH
DASHDOT
DASHDOTDOT
DOT

Definition at line 280 of file cadstar_archive_parser.h.

 {
 SOLID,
 DASH,
 DASHDOT,
 DASHDOTDOT,
 DOT
 };

◆ READABILITY

enum class CADSTAR_ARCHIVE_PARSER::READABILITY

stronginherited

Sets the readability direction of text.

From CADSTAR Help: "Horizontal text will always be displayed from left to right (i.e. never upside down). Vertical text can be set as readable from either the left or right edge of the design."

I.e. Vertical text can either be rotated 90 degrees clockwise or 90 degrees anticlockwise from horizontal. This does not impact vertical text

Enumerator
BOTTOM_TO_TOP	When text is vertical, show it rotated 90 degrees anticlockwise.
TOP_TO_BOTTOM	When text is vertical, show it rotated 90 degrees clockwise.

Definition at line 620 of file cadstar_archive_parser.h.

 {
 BOTTOM_TO_TOP, 
 TOP_TO_BOTTOM 
 };

◆ RESOLUTION

enum class CADSTAR_ARCHIVE_PARSER::RESOLUTION

stronginherited

Enumerator
HUNDREDTH_MICRON

Definition at line 242 of file cadstar_archive_parser.h.

 {
 HUNDREDTH_MICRON
 };

◆ SHAPE_TYPE

enum class CADSTAR_ARCHIVE_PARSER::SHAPE_TYPE

stronginherited

Enumerator
OPENSHAPE	Unfilled open shape. Cannot have cutouts.
OUTLINE	Unfilled closed shape.
SOLID	Filled closed shape (solid fill).
HATCHED	Filled closed shape (hatch fill).

Definition at line 450 of file cadstar_archive_parser.h.

 {
 OPENSHAPE, 
 OUTLINE, 
 SOLID, 
 HATCHED 
 };

◆ SWAP_RULE

enum class CADSTAR_ARCHIVE_PARSER::SWAP_RULE

stronginherited

Corresponds to "Display when" Item property.

From CADSTAR Help: "This parameter enables you to make the visibility of a component outline/area (or an area of component copper, or a string of component text) dependent on the current mirror status of the component. For example, you may require a string of component text to be displayed only when the component is mirrored."

Enumerator
NO_SWAP	Display when Unmirrored.
USE_SWAP_LAYER	Display when Mirrored.
BOTH	Always display (Mirrored and Unmirrored)

Definition at line 810 of file cadstar_archive_parser.h.

 {
 NO_SWAP, 
 USE_SWAP_LAYER, 
 BOTH 
 };

◆ TERMINAL_SHAPE_TYPE

enum class CADSTAR_SCH_ARCHIVE_PARSER::TERMINAL_SHAPE_TYPE

stronginherited

Enumerator
ANNULUS
BOX
BULLET
CIRCLE	Keyword "ROUND".
CROSS
DIAMOND
FINGER
OCTAGON
PLUS
POINTER
RECTANGLE
ROUNDED_RECT	Keyword "ROUNDED".
SQUARE
STAR
TRIANGLE
UNDEFINED	Only used for error checking (not a real shape)

Definition at line 58 of file cadstar_sch_archive_parser.h.

 {
 ANNULUS,
 BOX,
 BULLET,
 CIRCLE, 
 CROSS,
 DIAMOND,
 FINGER,
 OCTAGON,
 PLUS,
 POINTER,
 RECTANGLE,
 ROUNDED_RECT, 
 SQUARE,
 STAR,
 TRIANGLE,
 UNDEFINED 
 };

◆ TEXT_FIELD_NAME

enum class CADSTAR_ARCHIVE_PARSER::TEXT_FIELD_NAME

stronginherited

These are special fields in text objects enclosed between the tokens '<@' and '>' such as <@[FIELD_NAME][FIELD_VALUE]>.

For example: "<@DESIGN TITLEProject [email protected]>"

Enumerator
DESIGN_TITLE
SHORT_JOBNAME
LONG_JOBNAME
NUM_OF_SHEETS
SHEET_NUMBER
SHEET_NAME
VARIANT_NAME
VARIANT_DESCRIPTION
REG_USER
COMPANY_NAME
CURRENT_USER
DATE
TIME
MACHINE_NAME
FROM_FILE
DISTANCE
UNITS_SHORT
UNITS_ABBREV
UNITS_FULL
HYPERLINK
NONE	Synthetic for flagging.

Definition at line 135 of file cadstar_archive_parser.h.

 {
 DESIGN_TITLE,
 SHORT_JOBNAME,
 LONG_JOBNAME,
 NUM_OF_SHEETS,
 SHEET_NUMBER,
 SHEET_NAME,
 VARIANT_NAME,
 VARIANT_DESCRIPTION,
 REG_USER,
 COMPANY_NAME,
 CURRENT_USER,
 DATE,
 TIME,
 MACHINE_NAME,
 FROM_FILE,
 DISTANCE,
 UNITS_SHORT,
 UNITS_ABBREV,
 UNITS_FULL,
 HYPERLINK,
 NONE 
 };

◆ UNITS

enum class CADSTAR_ARCHIVE_PARSER::UNITS

stronginherited

Enumerator
DESIGN	Inherits from design units (assumed Assignments->Technology->Units)
THOU
INCH
MICROMETRE
MM
CENTIMETER
METER

Definition at line 471 of file cadstar_archive_parser.h.

 {
 DESIGN, 
 THOU,
 INCH,
 MICROMETRE,
 MM,
 CENTIMETER,
 METER
 };

◆ VERTEX_TYPE

enum class CADSTAR_ARCHIVE_PARSER::VERTEX_TYPE

stronginherited

Enumerator
POINT
CLOCKWISE_ARC
CLOCKWISE_SEMICIRCLE
ANTICLOCKWISE_ARC
ANTICLOCKWISE_SEMICIRCLE

Definition at line 416 of file cadstar_archive_parser.h.

 {
 POINT,
 CLOCKWISE_ARC,
 CLOCKWISE_SEMICIRCLE,
 ANTICLOCKWISE_ARC,
 ANTICLOCKWISE_SEMICIRCLE
 };

Constructor & Destructor Documentation

◆ CADSTAR_SCH_ARCHIVE_LOADER()

CADSTAR_SCH_ARCHIVE_LOADER::CADSTAR_SCH_ARCHIVE_LOADER	(	wxString	aFilename,
		REPORTER *	aReporter,
		PROGRESS_REPORTER *	aProgressReporter
	)

inlineexplicit

Definition at line 58 of file cadstar_sch_archive_loader.h.

  :
 CADSTAR_SCH_ARCHIVE_PARSER( aFilename )
 {
 m_schematic = nullptr;
 m_rootSheet = nullptr;
 m_plugin = nullptr;
 m_designCenter.x = 0;
 m_designCenter.y = 0;
 m_reporter = aReporter;
 m_progressReporter = aProgressReporter;
 }

References m_designCenter, m_plugin, CADSTAR_ARCHIVE_PARSER::m_progressReporter, m_reporter, m_rootSheet, and m_schematic.

◆ ~CADSTAR_SCH_ARCHIVE_LOADER()

CADSTAR_SCH_ARCHIVE_LOADER::~CADSTAR_SCH_ARCHIVE_LOADER ( )

inline

Definition at line 72 of file cadstar_sch_archive_loader.h.

73 {

74 }

Member Function Documentation

◆ applyTextSettings()

void CADSTAR_SCH_ARCHIVE_LOADER::applyTextSettings	(	EDA_TEXT *	aKiCadTextItem,
		const TEXTCODE_ID &	aCadstarTextCodeID,
		const ALIGNMENT &	aCadstarAlignment,
		const JUSTIFICATION &	aCadstarJustification,
		const long long	aCadstarOrientAngle = `0`,
		bool	aMirrored = `false`
	)

private

Definition at line 2621 of file cadstar_sch_archive_loader.cpp.

{
 // Justification ignored for now as not supported in Eeschema, but leaving this code in
 // place for future upgrades.
 // TODO update this when Eeschema supports justification independent of anchor position.
 
 TEXTCODE textCode = getTextCode( aCadstarTextCodeID );
 int textHeight = KiROUND( (double) getKiCadLength( textCode.Height ) * TXT_HEIGHT_RATIO );
 int textWidth = getKiCadLength( textCode.Width );
 
 // Ensure we have no Cadstar overbar characters
 wxString escapedText = HandleTextOverbar( aKiCadTextItem->GetText() );
 aKiCadTextItem->SetText( escapedText );
 
 // The width is zero for all non-cadstar fonts. Using a width equal to 2/3 the height seems
 // to work well for most fonts.
 if( textWidth == 0 )
 textWidth = getKiCadLength( 2 * textCode.Height / 3 );
 
 aKiCadTextItem->SetTextWidth( textWidth );
 aKiCadTextItem->SetTextHeight( textHeight );
 aKiCadTextItem->SetTextThickness( getKiCadLength( textCode.LineWidth ) );
 aKiCadTextItem->SetTextAngle( getAngle( aCadstarOrientAngle ) );
 aKiCadTextItem->SetBold( textCode.Font.Modifier1 == FONT_BOLD );
 aKiCadTextItem->SetItalic( textCode.Font.Italic );
 
 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_V_ALIGN_BOTTOM );
 aText->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
 break;
 
 case ALIGNMENT::BOTTOMCENTER:
 aText->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
 aText->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
 break;
 
 case ALIGNMENT::BOTTOMRIGHT:
 aText->SetVertJustify( GR_TEXT_V_ALIGN_BOTTOM );
 aText->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
 break;
 
 case ALIGNMENT::CENTERLEFT:
 aText->SetVertJustify( GR_TEXT_V_ALIGN_CENTER );
 aText->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
 break;
 
 case ALIGNMENT::CENTERCENTER:
 aText->SetVertJustify( GR_TEXT_V_ALIGN_CENTER );
 aText->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
 break;
 
 case ALIGNMENT::CENTERRIGHT:
 aText->SetVertJustify( GR_TEXT_V_ALIGN_CENTER );
 aText->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
 break;
 
 case ALIGNMENT::TOPLEFT:
 aText->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
 aText->SetHorizJustify( GR_TEXT_H_ALIGN_LEFT );
 break;
 
 case ALIGNMENT::TOPCENTER:
 aText->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
 aText->SetHorizJustify( GR_TEXT_H_ALIGN_CENTER );
 break;
 
 case ALIGNMENT::TOPRIGHT:
 aText->SetVertJustify( GR_TEXT_V_ALIGN_TOP );
 aText->SetHorizJustify( GR_TEXT_H_ALIGN_RIGHT );
 break;
 }
 };
 
 TEXT_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
 case LIB_TEXT_T:
 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
 EDA_ANGLE angle = aKiCadTextItem->GetTextAngle();
 angle.Normalize();
 
 int quadrant = KiROUND( angle.AsDegrees() / 90.0 );
 quadrant %= 4;
 
 switch( quadrant )
 {
 case 0:
 angle = ANGLE_HORIZONTAL;
 break;
 case 1:
 angle = ANGLE_VERTICAL;
 break;
 case 2:
 angle = ANGLE_HORIZONTAL;
 textAlignment = rotate180( textAlignment );
 break;
 case 3:
 angle = ANGLE_VERTICAL;
 textAlignment = rotate180( textAlignment );
 break;
 default: wxFAIL_MSG( "Unknown Quadrant" );
 }
 
 aKiCadTextItem->SetTextAngle( angle );
 setAlignment( aKiCadTextItem, textAlignment );
 return;
 }
 
 case SCH_TEXT_T:
 {
 // Note spin style in a SCH_TEXT results in a vertical alignment GR_TEXT_V_ALIGN_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;
 
 // Change the anchor point of the text item to make it match the same bounding box
 // And correct the error introduced by the text offsetting in KiCad
 switch( spin )
 {
 case TEXT_SPIN_STYLE::BOTTOM: pos = { bb.GetRight() - off, bb.GetTop() }; break;
 case TEXT_SPIN_STYLE::UP: pos = { bb.GetRight() - off, bb.GetBottom() }; break;
 case TEXT_SPIN_STYLE::LEFT: pos = { bb.GetRight() , bb.GetBottom() + off }; break;
 case TEXT_SPIN_STYLE::RIGHT: pos = { bb.GetLeft() , bb.GetBottom() + off }; break;
 }
 
 aKiCadTextItem->SetTextPos( pos );
 }
 KI_FALLTHROUGH;
 
 // 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 )->SetTextSpinStyle( spin );
 return;
 
 default:
 wxFAIL_MSG( "Unexpected item type" );
 return;
 }
}

Referenced by applyToLibraryFieldAttribute(), getKiCadSchText(), loadBusses(), loadChildSheets(), loadNets(), loadSchematicSymbolInstances(), loadSymbolFieldAttribute(), and loadSymDefIntoLibrary().

◆ applyToLibraryFieldAttribute()

void CADSTAR_SCH_ARCHIVE_LOADER::applyToLibraryFieldAttribute	(	const ATTRIBUTE_LOCATION &	aCadstarAttrLoc,
		wxPoint	aSymbolOrigin,
		LIB_FIELD *	aKiCadField
	)

private

Definition at line 1702 of file cadstar_sch_archive_loader.cpp.

{
 aKiCadField->SetTextPos( getKiCadLibraryPoint( aCadstarAttrLoc.Position, aSymbolOrigin ) );
 
 applyTextSettings( aKiCadField,
 aCadstarAttrLoc.TextCodeID,
 aCadstarAttrLoc.Alignment,
 aCadstarAttrLoc.Justification,
 aCadstarAttrLoc.OrientAngle,
 aCadstarAttrLoc.Mirror );
}

References CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_LOCATION::Alignment, applyTextSettings(), getKiCadLibraryPoint(), CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_LOCATION::Justification, CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_LOCATION::Mirror, CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_LOCATION::OrientAngle, CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_LOCATION::Position, EDA_TEXT::SetTextPos(), and CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_LOCATION::TextCodeID.

Referenced by loadSymDefIntoLibrary().

◆ applyTransform()

VECTOR2I CADSTAR_SCH_ARCHIVE_LOADER::applyTransform	(	const VECTOR2I &	aPoint,
		const VECTOR2I &	aMoveVector = `{ 0, 0 }`,
		const EDA_ANGLE &	aRotation = `ANGLE_0`,
		const double &	aScalingFactor = `1.0`,
		const VECTOR2I &	aTransformCentre = `{ 0, 0 }`,
		const bool &	aMirrorInvert = `false`
	)

private

Definition at line 3051 of file cadstar_sch_archive_loader.cpp.

{
 VECTOR2I 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( !aRotation.IsZero() )
 RotatePoint( retVal, aTransformCentre, aRotation );
 
 if( aMoveVector != wxPoint{ 0, 0 } )
 retVal += aMoveVector;
 
 return retVal;
}

References EDA_ANGLE::IsZero(), KiROUND(), MIRROR(), RotatePoint(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by loadDocumentationSymbols(), and loadGraphicStaightSegment().

◆ CheckNoChildNodes()

void CADSTAR_ARCHIVE_PARSER::CheckNoChildNodes ( XNODE * aNode )

staticinherited

Parameters

aNode

Exceptions

IO_ERROR if a child node was found

Definition at line 2469 of file cadstar_archive_parser.cpp.

{
 if( aNode && aNode->GetChildren() )
 THROW_UNKNOWN_NODE_IO_ERROR( aNode->GetChildren()->GetName(), aNode->GetName() );
}

References XNODE::GetChildren(), and THROW_UNKNOWN_NODE_IO_ERROR.

Referenced by CADSTAR_ARCHIVE_PARSER::ATTRNAME::COLUMNORDER::Parse(), CADSTAR_ARCHIVE_PARSER::ATTRNAME::COLUMNWIDTH::Parse(), CADSTAR_ARCHIVE_PARSER::REUSEBLOCKREF::Parse(), CADSTAR_ARCHIVE_PARSER::PART::DEFINITION::GATE::Parse(), CADSTAR_ARCHIVE_PARSER::PART::DEFINITION::PIN_EQUIVALENCE::Parse(), CADSTAR_ARCHIVE_PARSER::PART::DEFINITION::SWAP_GATE::Parse(), CADSTAR_PCB_ARCHIVE_PARSER::LAYERDEFS::Parse(), CADSTAR_PCB_ARCHIVE_PARSER::SPACINGCODE::REASSIGN::Parse(), CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_COPPER::Parse(), CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_AREA::Parse(), CADSTAR_PCB_ARCHIVE_PARSER::PAD_EXITS::Parse(), CADSTAR_PCB_ARCHIVE_PARSER::AREA::Parse(), and CADSTAR_PCB_ARCHIVE_PARSER::NET_PCB::PIN::Parse().

◆ CheckNoNextNodes()

void CADSTAR_ARCHIVE_PARSER::CheckNoNextNodes ( XNODE * aNode )

staticinherited

Parameters

aNode

Exceptions

IO_ERROR if a node adjacent to aNode was found

Definition at line 2476 of file cadstar_archive_parser.cpp.

{
 if( aNode && aNode->GetNext() )
 THROW_UNKNOWN_NODE_IO_ERROR( aNode->GetNext()->GetName(), aNode->GetParent()->GetName() );
}

References XNODE::GetNext(), XNODE::GetParent(), and THROW_UNKNOWN_NODE_IO_ERROR.

Referenced by CADSTAR_SCH_ARCHIVE_PARSER::TERMINAL_SHAPE::Parse(), CADSTAR_SCH_ARCHIVE_PARSER::SYMBOLVARIANT::Parse(), CADSTAR_PCB_ARCHIVE_PARSER::CADSTAR_PAD_SHAPE::Parse(), CADSTAR_PCB_ARCHIVE_PARSER::PADREASSIGN::Parse(), CADSTAR_PCB_ARCHIVE_PARSER::VIAREASSIGN::Parse(), CADSTAR_PCB_ARCHIVE_PARSER::LAYERPAIR::Parse(), and CADSTAR_PCB_ARCHIVE_PARSER::DIMENSION::TEXTFORMAT::Parse().

◆ checkPoint()

void CADSTAR_ARCHIVE_PARSER::checkPoint ( )

protectedinherited

Updates m_progressReporter or throws if user cancelled.

Definition at line 2648 of file cadstar_archive_parser.cpp.

{
 if( m_progressReporter )
 {
 m_progressReporter->AdvanceProgress();
 
 if( !m_progressReporter->KeepRefreshing() )
 THROW_IO_ERROR( _( "File import cancelled by user." ) );
 }
}

References _, PROGRESS_REPORTER::AdvanceProgress(), PROGRESS_REPORTER::KeepRefreshing(), CADSTAR_ARCHIVE_PARSER::m_progressReporter, and THROW_IO_ERROR.

Referenced by CADSTAR_PCB_ARCHIVE_LOADER::calculateZonePriorities(), Load(), CADSTAR_PCB_ARCHIVE_LOADER::loadCoppers(), loadPartsLibrary(), CADSTAR_SCH_ARCHIVE_PARSER::Parse(), and CADSTAR_PCB_ARCHIVE_PARSER::Parse().

◆ findOrphanSheets()

std::vector< CADSTAR_SCH_ARCHIVE_LOADER::LAYER_ID > CADSTAR_SCH_ARCHIVE_LOADER::findOrphanSheets ( )

private

Definition at line 2297 of file cadstar_sch_archive_loader.cpp.

{
 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;
}

References CADSTAR_SCH_ARCHIVE_PARSER::BLOCK::AssocLayerID, CADSTAR_SCH_ARCHIVE_PARSER::CADSTAR_SCHEMATIC::Blocks, CADSTAR_SCH_ARCHIVE_PARSER::Schematic, CADSTAR_SCH_ARCHIVE_PARSER::SHEETS::SheetOrder, CADSTAR_SCH_ARCHIVE_PARSER::Sheets, and CADSTAR_SCH_ARCHIVE_PARSER::BLOCK::Type.

Referenced by loadSheets().

◆ FixTextPositionNoAlignment()

void CADSTAR_ARCHIVE_PARSER::FixTextPositionNoAlignment ( EDA_TEXT * aKiCadTextItem )

staticinherited

Corrects the position of a text element that had NO_ALIGNMENT in CADSTAR.

Assumes that the provided text element has been initialised with a position and orientation.

Parameters

aKiCadTextItem a Kicad item to correct

Definition at line 2621 of file cadstar_archive_parser.cpp.

{
 if( !aKiCadTextItem->GetText().IsEmpty() )
 {
 VECTOR2I positionOffset( 0, aKiCadTextItem->GetInterline() );
 RotatePoint( positionOffset, aKiCadTextItem->GetTextAngle() );
 
 EDA_ITEM* textEdaItem = dynamic_cast<EDA_ITEM*>( aKiCadTextItem );
 
 if( textEdaItem &&
 ( textEdaItem->Type() == LIB_TEXT_T || textEdaItem->Type() == LIB_FIELD_T ) )
 {
 // Y coordinate increases upwards in the symbol editor
 positionOffset.y = -positionOffset.y;
  }
 
 //Count num of additional lines
 wxString text = aKiCadTextItem->GetText();
 int numExtraLines = text.Replace( "\n", "\n" );
 numExtraLines -= text.at( text.size() - 1 ) == '\n'; // Ignore new line character at end
 positionOffset.x *= numExtraLines;
 positionOffset.y *= numExtraLines;
 
 aKiCadTextItem->Offset( positionOffset );
 }
}

References EDA_TEXT::GetInterline(), EDA_TEXT::GetText(), EDA_TEXT::GetTextAngle(), LIB_FIELD_T, LIB_TEXT_T, EDA_TEXT::Offset(), RotatePoint(), text, EDA_ITEM::Type(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by CADSTAR_PCB_ARCHIVE_LOADER::addAttribute(), applyTextSettings(), and CADSTAR_PCB_ARCHIVE_LOADER::drawCadstarText().

◆ fixUpLibraryPins()

void CADSTAR_SCH_ARCHIVE_LOADER::fixUpLibraryPins	(	LIB_SYMBOL *	aSymbolToFix,
		int	aGateNumber
	)

private

Definition at line 2899 of file cadstar_sch_archive_loader.cpp.

{
 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 );
 
 LIB_ITEMS_CONTAINER::ITERATOR shapeIt = aSymbolToFix->GetDrawItems().begin( LIB_SHAPE_T );
 
 for( ; shapeIt != aSymbolToFix->GetDrawItems().end( LIB_SHAPE_T ); ++shapeIt )
 {
 LIB_SHAPE& shape = static_cast<LIB_SHAPE&>( *shapeIt );
 
 if( aGateNumber > 0 && shape.GetUnit() != aGateNumber )
 continue;
 
 if( shape.GetShape() != SHAPE_T::POLY )
 continue;
 
 SHAPE_LINE_CHAIN poly = shape.GetPolyShape().Outline( 0 );
 
 if( poly.GetPointCount() == 2 )
 {
 VECTOR2I pt0 = poly.CPoint( 0 );
 VECTOR2I pt1 = poly.CPoint( 1 );
 
 if( pt0 != pt1 && uniqueSegments.count( pt0 ) == 0 && uniqueSegments.count( pt1 ) == 0 )
 {
 // we are only interested in vertical or horizontal segments
 if( pt0.x == pt1.x || pt0.y == pt1.y )
 {
 uniqueSegments.insert( { pt0, poly } );
 uniqueSegments.insert( { pt1, poly } );
 }
 }
 }
 }
 
 LIB_PINS pins;
 aSymbolToFix->GetPins( pins, aGateNumber );
 
 for( auto& pin : pins )
 {
 auto setPinOrientation =
 [&]( const EDA_ANGLE& aAngle )
 {
 EDA_ANGLE angle( aAngle );
 angle.Normalize180();
 
 if( angle >= -ANGLE_45 && angle <= ANGLE_45 )
 pin->SetOrientation( 'R' ); // 0 degrees
 else if( angle >= ANGLE_45 && angle <= ANGLE_135 )
 pin->SetOrientation( 'U' ); // 90 degrees
 else if( angle >= ANGLE_135 || angle <= -ANGLE_135 )
 pin->SetOrientation( 'L' ); // 180 degrees
 else
 pin->SetOrientation( 'D' ); // -90 degrees
 };
 
 if( uniqueSegments.count( pin->GetPosition() ) )
 {
 SHAPE_LINE_CHAIN& poly = uniqueSegments.at( pin->GetPosition() );
 
 VECTOR2I otherPt = poly.CPoint( 0 );
 
 if( otherPt == pin->GetPosition() )
 otherPt = poly.CPoint( 1 );
 
 VECTOR2I vec( otherPt - pin->GetPosition() );
 
 pin->SetLength( vec.EuclideanNorm() );
 setPinOrientation( EDA_ANGLE( vec ) );
 }
 }
}

References PNS::angle(), ANGLE_135, ANGLE_45, MULTIVECTOR< T, FIRST_TYPE_VAL, LAST_TYPE_VAL >::begin(), SHAPE_LINE_CHAIN::CPoint(), MULTIVECTOR< T, FIRST_TYPE_VAL, LAST_TYPE_VAL >::end(), VECTOR2< T >::EuclideanNorm(), LIB_SYMBOL::GetDrawItems(), LIB_SYMBOL::GetPins(), SHAPE_LINE_CHAIN::GetPointCount(), EDA_SHAPE::GetPolyShape(), EDA_SHAPE::GetShape(), LIB_ITEM::GetUnit(), LexicographicalCompare(), LIB_SHAPE_T, SHAPE_POLY_SET::Outline(), pin, POLY, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by loadSymDefIntoLibrary().

◆ generateLibName()

static wxString CADSTAR_ARCHIVE_PARSER::generateLibName	(	const wxString &	aRefName,
		const wxString &	aAlternateName
	)

inlinestaticinherited

Definition at line 1404 of file cadstar_archive_parser.h.

 {
 return aRefName
 + ( ( aAlternateName.size() > 0 ) ? ( wxT( " (" ) + aAlternateName + wxT( ")" ) )
 : wxT( "" ) );
 }

Referenced by loadSymDefIntoLibrary().

◆ getAngle()

EDA_ANGLE CADSTAR_SCH_ARCHIVE_LOADER::getAngle ( const long long & aCadstarAngle )

inlineprivate

Definition at line 258 of file cadstar_sch_archive_loader.h.

 {
 // CADSTAR v6 (which outputted Schematic Format Version 8) and earlier used 1/10 degree
 // as the unit for angles/orientations. It is assumed that CADSTAR version 7 (i.e. Schematic
 // Format Version 9 and later) is the version that introduced 1/1000 degree for angles.
 if( Header.Format.Version > 8 )
 {
 return EDA_ANGLE( (double) aCadstarAngle / 1000.0, DEGREES_T );
 }
 else
 {
 return EDA_ANGLE( (double) aCadstarAngle, TENTHS_OF_A_DEGREE_T );
 }
 }

References DEGREES_T, CADSTAR_ARCHIVE_PARSER::HEADER::Format, CADSTAR_SCH_ARCHIVE_PARSER::Header, TENTHS_OF_A_DEGREE_T, and CADSTAR_ARCHIVE_PARSER::FORMAT::Version.

Referenced by applyTextSettings(), getLocationOfNetElement(), getSpinStyle(), loadDocumentationSymbols(), loadNets(), loadSchematicSymbol(), loadSchematicSymbolInstances(), and loadSymbolFieldAttribute().

◆ getAttributeName()

wxString CADSTAR_SCH_ARCHIVE_LOADER::getAttributeName ( const ATTRIBUTE_ID & aCadstarAttributeID )

private

Definition at line 2461 of file cadstar_sch_archive_loader.cpp.

{
 wxCHECK( Assignments.Codedefs.AttributeNames.find( aCadstarAttributeID )
 != Assignments.Codedefs.AttributeNames.end(),
 wxEmptyString );
 
 return Assignments.Codedefs.AttributeNames.at( aCadstarAttributeID ).Name;
}

References CADSTAR_SCH_ARCHIVE_PARSER::Assignments, CADSTAR_ARCHIVE_PARSER::CODEDEFS::AttributeNames, and CADSTAR_SCH_ARCHIVE_PARSER::ASSIGNMENTS_SCM::Codedefs.

Referenced by loadSchematicSymbolInstances(), and loadSymDefIntoLibrary().

◆ getCadstarAngle()

long long CADSTAR_SCH_ARCHIVE_LOADER::getCadstarAngle ( const EDA_ANGLE & aAngle )

inlineprivate

Definition at line 273 of file cadstar_sch_archive_loader.h.

 {
 // CADSTAR v6 (which outputted Schematic Format Version 8) and earlier used 1/10 degree
 // as the unit for angles/orientations. It is assumed that CADSTAR version 7 (i.e. Schematic
 // Format Version 9 and later) is the version that introduced 1/1000 degree for angles.
 if( Header.Format.Version > 8 )
 {
 return KiROUND( aAngle.AsDegrees() * 1000.0 );
 }
 else
 {
 return aAngle.AsTenthsOfADegree();
 }
 }

References EDA_ANGLE::AsDegrees(), EDA_ANGLE::AsTenthsOfADegree(), CADSTAR_ARCHIVE_PARSER::HEADER::Format, CADSTAR_SCH_ARCHIVE_PARSER::Header, KiROUND(), and CADSTAR_ARCHIVE_PARSER::FORMAT::Version.

Referenced by loadSymbolFieldAttribute().

◆ getComponentOrientation()

int CADSTAR_SCH_ARCHIVE_LOADER::getComponentOrientation	(	const EDA_ANGLE &	aOrientAngle,
		EDA_ANGLE &	aReturnedOrientation
	)

private

Definition at line 1861 of file cadstar_sch_archive_loader.cpp.

{
 int compOrientation = SYMBOL_ORIENTATION_T::SYM_ORIENT_0;
 
 EDA_ANGLE oDeg = aOrientAngle;
 oDeg.Normalize180();
 
 if( oDeg >= -ANGLE_45 && oDeg <= ANGLE_45 )
 {
 compOrientation = SYMBOL_ORIENTATION_T::SYM_ORIENT_0;
 aReturnedOrientation = ANGLE_0;
 }
 else if( oDeg >= ANGLE_45 && oDeg <= ANGLE_135 )
 {
 compOrientation = SYMBOL_ORIENTATION_T::SYM_ORIENT_90;
 aReturnedOrientation = ANGLE_90;
 }
 else if( oDeg >= ANGLE_135 || oDeg <= -ANGLE_135 )
 {
 compOrientation = SYMBOL_ORIENTATION_T::SYM_ORIENT_180;
 aReturnedOrientation = ANGLE_180;
 }
 else
 {
 compOrientation = SYMBOL_ORIENTATION_T::SYM_ORIENT_270;
 aReturnedOrientation = ANGLE_270;
 }
 
 return compOrientation;
}

References ANGLE_0, ANGLE_135, ANGLE_180, ANGLE_270, ANGLE_45, ANGLE_90, EDA_ANGLE::Normalize180(), SYM_ORIENT_0, SYM_ORIENT_180, SYM_ORIENT_270, and SYM_ORIENT_90.

Referenced by getLocationOfNetElement(), and loadSchematicSymbol().

◆ getFigureExtentsKiCad()

std::pair< VECTOR2I, wxSize > CADSTAR_SCH_ARCHIVE_LOADER::getFigureExtentsKiCad ( const FIGURE & aCadstarFigure )

private

Definition at line 2981 of file cadstar_sch_archive_loader.cpp.

{
 VECTOR2I upperLeft( Assignments.Settings.DesignLimit.x, 0 );
 VECTOR2I 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;
 }
 }
 
 VECTOR2I upperLeftKiCad = getKiCadPoint( upperLeft );
 VECTOR2I lowerRightKiCad = getKiCadPoint( lowerRight );
 
 VECTOR2I size = lowerRightKiCad - upperLeftKiCad;
 
 return { upperLeftKiCad, wxSize( abs( size.x ), abs( size.y ) ) };
}

References std::abs(), CADSTAR_SCH_ARCHIVE_PARSER::Assignments, CADSTAR_ARCHIVE_PARSER::SHAPE::Cutouts, CADSTAR_ARCHIVE_PARSER::SETTINGS::DesignLimit, CADSTAR_ARCHIVE_PARSER::VERTEX::End, getKiCadPoint(), CADSTAR_SCH_ARCHIVE_PARSER::ASSIGNMENTS_SCM::Settings, CADSTAR_ARCHIVE_PARSER::FIGURE::Shape, CADSTAR_ARCHIVE_PARSER::SHAPE::Vertices, CADSTAR_ARCHIVE_PARSER::LONGPOINT::x, VECTOR2< T >::x, CADSTAR_ARCHIVE_PARSER::LONGPOINT::y, and VECTOR2< T >::y.

Referenced by loadChildSheets().

◆ getKiCadLength()

int CADSTAR_SCH_ARCHIVE_LOADER::getKiCadLength ( long long aCadstarLength )

inlineprivate

Definition at line 245 of file cadstar_sch_archive_loader.h.

 {
 int mod = aCadstarLength % KiCadUnitDivider;
 int absmod = sign( mod ) * mod;
 int offset = 0;
 
 // Round half-way cases away from zero
 if( absmod >= KiCadUnitDivider / 2 )
 offset = sign( aCadstarLength );
 
 return ( aCadstarLength / KiCadUnitDivider ) + offset;
 }

References CADSTAR_SCH_ARCHIVE_PARSER::KiCadUnitDivider, and sign().

Referenced by applyTextSettings(), getKiCadLibraryPoint(), getKiCadPoint(), getLineThickness(), getTextHeightFromTextCode(), and Load().

◆ getKiCadLibraryPoint()

wxPoint CADSTAR_SCH_ARCHIVE_LOADER::getKiCadLibraryPoint	(	const wxPoint &	aCadstarPoint,
		const wxPoint &	aCadstarCentre
	)

private

Definition at line 3039 of file cadstar_sch_archive_loader.cpp.

{
 wxPoint retval;
 
 retval.x = getKiCadLength( aCadstarPoint.x - aCadstarCentre.x );
 retval.y = getKiCadLength( aCadstarPoint.y - aCadstarCentre.y );
 
 return retval;
}

References getKiCadLength().

Referenced by applyToLibraryFieldAttribute(), loadLibrarySymbolShapeVertices(), loadSchematicSymbolInstances(), and loadSymDefIntoLibrary().

◆ getKiCadPinType()

ELECTRICAL_PINTYPE CADSTAR_SCH_ARCHIVE_LOADER::getKiCadPinType ( const PART::PIN_TYPE & aPinType )

private

Definition at line 2508 of file cadstar_sch_archive_loader.cpp.

{
 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;
}

References PT_BIDI, PT_INPUT, PT_OPENCOLLECTOR, PT_OUTPUT, PT_PASSIVE, PT_POWER_IN, and PT_UNSPECIFIED.

Referenced by loadSymDefIntoLibrary().

◆ getKiCadPoint()

VECTOR2I CADSTAR_SCH_ARCHIVE_LOADER::getKiCadPoint ( const VECTOR2I & aCadstarPoint )

private

Definition at line 3028 of file cadstar_sch_archive_loader.cpp.

{
 VECTOR2I retval;
 
 retval.x = getKiCadLength( aCadstarPoint.x - m_designCenter.x );
 retval.y = -getKiCadLength( aCadstarPoint.y - m_designCenter.y );
 
 return retval;
}

References getKiCadLength(), m_designCenter, VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by getFigureExtentsKiCad(), getKiCadSchText(), loadBusses(), loadChildSheets(), loadDocumentationSymbols(), loadHierarchicalSheetPins(), loadNets(), loadSchematicSymbol(), loadSchematicSymbolInstances(), loadShapeVertices(), and loadSymbolFieldAttribute().

◆ getKiCadSchText()

SCH_TEXT * CADSTAR_SCH_ARCHIVE_LOADER::getKiCadSchText ( const TEXT & aCadstarTextElement )

private

Definition at line 2799 of file cadstar_sch_archive_loader.cpp.

{
 SCH_TEXT* kiTxt = new SCH_TEXT();
 
 kiTxt->SetParent( m_schematic ); // set to the schematic for now to avoid asserts
 kiTxt->SetPosition( getKiCadPoint( aCadstarTextElement.Position ) );
 kiTxt->SetText( aCadstarTextElement.Text );
 
 applyTextSettings( kiTxt,
 aCadstarTextElement.TextCodeID,
 aCadstarTextElement.Alignment,
 aCadstarTextElement.Justification,
 aCadstarTextElement.OrientAngle,
 aCadstarTextElement.Mirror );
 
 return kiTxt;
}

References CADSTAR_ARCHIVE_PARSER::TEXT::Alignment, applyTextSettings(), getKiCadPoint(), CADSTAR_ARCHIVE_PARSER::TEXT::Justification, m_schematic, CADSTAR_ARCHIVE_PARSER::TEXT::Mirror, CADSTAR_ARCHIVE_PARSER::TEXT::OrientAngle, CADSTAR_ARCHIVE_PARSER::TEXT::Position, EDA_ITEM::SetParent(), SCH_TEXT::SetPosition(), EDA_TEXT::SetText(), CADSTAR_ARCHIVE_PARSER::TEXT::Text, and CADSTAR_ARCHIVE_PARSER::TEXT::TextCodeID.

Referenced by loadDocumentationSymbols(), and loadTexts().

◆ getKiCadUnitNumberFromGate()

int CADSTAR_SCH_ARCHIVE_LOADER::getKiCadUnitNumberFromGate ( const GATE_ID & aCadstarGateID )

private

Definition at line 2527 of file cadstar_sch_archive_loader.cpp.

{
 if( aCadstarGateID.IsEmpty() )
 return 1;
 
 return (int) aCadstarGateID.Upper().GetChar( 0 ) - (int) wxUniChar( 'A' ) + 1;
}

Referenced by loadSchematicSymbol(), and loadSymDefIntoLibrary().

◆ getLineStyle()

PLOT_DASH_TYPE CADSTAR_SCH_ARCHIVE_LOADER::getLineStyle ( const LINECODE_ID & aCadstarLineCodeID )

private

Definition at line 2420 of file cadstar_sch_archive_loader.cpp.

{
 wxCHECK( Assignments.Codedefs.LineCodes.find( aCadstarLineCodeID )
 != Assignments.Codedefs.LineCodes.end(),
 PLOT_DASH_TYPE::SOLID );
 
 // 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();
}

References CADSTAR_SCH_ARCHIVE_PARSER::Assignments, CADSTAR_SCH_ARCHIVE_PARSER::ASSIGNMENTS_SCM::Codedefs, CADSTAR_ARCHIVE_PARSER::DASH, DASH, CADSTAR_ARCHIVE_PARSER::DASHDOT, DASHDOT, CADSTAR_ARCHIVE_PARSER::DASHDOTDOT, DEFAULT, CADSTAR_ARCHIVE_PARSER::DOT, DOT, CADSTAR_ARCHIVE_PARSER::CODEDEFS::LineCodes, CADSTAR_ARCHIVE_PARSER::SOLID, and SOLID.

Referenced by loadGraphicStaightSegment().

◆ getLineThickness()

int CADSTAR_SCH_ARCHIVE_LOADER::getLineThickness ( const LINECODE_ID & aCadstarLineCodeID )

private

Definition at line 2410 of file cadstar_sch_archive_loader.cpp.

{
 wxCHECK( Assignments.Codedefs.LineCodes.find( aCadstarLineCodeID )
 != Assignments.Codedefs.LineCodes.end(),
 Mils2iu( DEFAULT_WIRE_WIDTH_MILS ) );
 
 return getKiCadLength( Assignments.Codedefs.LineCodes.at( aCadstarLineCodeID ).Width );
}

References CADSTAR_SCH_ARCHIVE_PARSER::Assignments, CADSTAR_SCH_ARCHIVE_PARSER::ASSIGNMENTS_SCM::Codedefs, DEFAULT_WIRE_WIDTH_MILS, getKiCadLength(), and CADSTAR_ARCHIVE_PARSER::CODEDEFS::LineCodes.

Referenced by loadBusses(), loadGraphicStaightSegment(), loadNets(), and loadSymDefIntoLibrary().

◆ getLocationOfNetElement()

CADSTAR_SCH_ARCHIVE_LOADER::POINT CADSTAR_SCH_ARCHIVE_LOADER::getLocationOfNetElement	(	const NET_SCH &	aNet,
		const NETELEMENT_ID &	aNetElementID
	)

private

Definition at line 1895 of file cadstar_sch_archive_loader.cpp.

{
 // clang-format off
 auto logUnknownNetElementError =
 [&]()
 {
 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 );
 
 return POINT();
 };
 // clang-format on
 
 if( aNetElementID.Contains( "J" ) ) // Junction
 {
 if( aNet.Junctions.find( aNetElementID ) == aNet.Junctions.end() )
 return logUnknownNetElementError();
 
 return aNet.Junctions.at( aNetElementID ).Location;
 }
 else if( aNetElementID.Contains( "P" ) ) // Terminal/Pin of a symbol
 {
 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;
 VECTOR2I symbolOrigin = sym.Origin;
 
 if( Library.SymbolDefinitions.find( symdefid ) == Library.SymbolDefinitions.end() )
 return logUnknownNetElementError();
 
 VECTOR2I libpinPosition =
 Library.SymbolDefinitions.at( symdefid ).Terminals.at( termid ).Position;
 VECTOR2I libOrigin = Library.SymbolDefinitions.at( symdefid ).Origin;
 
 VECTOR2I pinOffset = libpinPosition - libOrigin;
 pinOffset.x = ( pinOffset.x * sym.ScaleRatioNumerator ) / sym.ScaleRatioDenominator;
 pinOffset.y = ( pinOffset.y * sym.ScaleRatioNumerator ) / sym.ScaleRatioDenominator;
 
 VECTOR2I pinPosition = symbolOrigin + pinOffset;
 EDA_ANGLE compAngle = getAngle( sym.OrientAngle );
 
 if( sym.Mirror )
 pinPosition.x = ( 2 * symbolOrigin.x ) - pinPosition.x;
 
 EDA_ANGLE adjustedOrientation;
 getComponentOrientation( compAngle, adjustedOrientation );
 
 RotatePoint( pinPosition, symbolOrigin, -adjustedOrientation );
 
 POINT retval;
 retval.x = pinPosition.x;
 retval.y = pinPosition.y;
 
 return retval;
 }
 else if( aNetElementID.Contains( "BT" ) ) // Bus Terminal
 {
 if( aNet.BusTerminals.find( aNetElementID ) == aNet.BusTerminals.end() )
 return logUnknownNetElementError();
 
 return aNet.BusTerminals.at( aNetElementID ).SecondPoint;
 }
 else if( aNetElementID.Contains( "BLKT" ) ) // Block Terminal (sheet hierarchy connection)
 {
 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;
 }
 else if( aNetElementID.Contains( "D" ) ) // Dangler
 {
 if( aNet.Danglers.find( aNetElementID ) == aNet.Danglers.end() )
 return logUnknownNetElementError();
 
 return aNet.Danglers.at( aNetElementID ).Position;
 }
 else
 {
 return logUnknownNetElementError();
 }
 
 return POINT();
}

Referenced by loadNets().

◆ getNetName()

wxString CADSTAR_SCH_ARCHIVE_LOADER::getNetName ( const NET_SCH & aNet )

private

Definition at line 1999 of file cadstar_sch_archive_loader.cpp.

{
 wxString netname = aNet.Name;
 
 if( netname.IsEmpty() )
 netname = wxString::Format( "$%ld", aNet.SignalNum );
 
 return netname;
}

References Format(), CADSTAR_ARCHIVE_PARSER::NET::Name, and CADSTAR_ARCHIVE_PARSER::NET::SignalNum.

Referenced by getLocationOfNetElement().

◆ GetNumberOfChildNodes()

long CADSTAR_ARCHIVE_PARSER::GetNumberOfChildNodes ( XNODE * aNode )

staticinherited

Definition at line 2579 of file cadstar_archive_parser.cpp.

{
 XNODE* childNodes = aNode->GetChildren();
 long retval = 0;
 
 for( ; childNodes; childNodes = childNodes->GetNext() )
 retval++;
 
 return retval;
}

References XNODE::GetChildren(), and XNODE::GetNext().

Referenced by CADSTAR_ARCHIVE_PARSER::GetNumberOfStepsForReporting().

◆ GetNumberOfStepsForReporting()

long CADSTAR_ARCHIVE_PARSER::GetNumberOfStepsForReporting	(	XNODE *	aRootNode,
		std::vector< wxString >	aSubNodeChildrenToCount
	)

staticinherited

Definition at line 2591 of file cadstar_archive_parser.cpp.

{
 XNODE* level1Node = aRootNode->GetChildren();
 long retval = 0;
 
 for( ; level1Node; level1Node = level1Node->GetNext() )
 {
 for( wxString childNodeName : aSubNodeChildrenToCount )
 {
 if( level1Node->GetName() == childNodeName )
 retval += GetNumberOfChildNodes( level1Node );
 }
 
 retval++;
 }
 
 return retval;
}

References XNODE::GetChildren(), XNODE::GetNext(), and CADSTAR_ARCHIVE_PARSER::GetNumberOfChildNodes().

Referenced by CADSTAR_SCH_ARCHIVE_PARSER::Parse(), and CADSTAR_PCB_ARCHIVE_PARSER::Parse().

◆ getPart()

CADSTAR_SCH_ARCHIVE_LOADER::PART CADSTAR_SCH_ARCHIVE_LOADER::getPart ( const PART_ID & aCadstarPartID )

private

Definition at line 2472 of file cadstar_sch_archive_loader.cpp.

{
 wxCHECK( Parts.PartDefinitions.find( aCadstarPartID ) != Parts.PartDefinitions.end(), PART() );
 
 return Parts.PartDefinitions.at( aCadstarPartID );
}

References CADSTAR_ARCHIVE_PARSER::PARTS::PartDefinitions, and CADSTAR_SCH_ARCHIVE_PARSER::Parts.

Referenced by loadSchematicSymbolInstances().

◆ getPartDefinitionPin()

CADSTAR_SCH_ARCHIVE_LOADER::PART::DEFINITION::PIN CADSTAR_SCH_ARCHIVE_LOADER::getPartDefinitionPin	(	const PART &	aCadstarPart,
		const GATE_ID &	aGateID,
		const TERMINAL_ID &	aTerminalID
	)

private

Definition at line 2492 of file cadstar_sch_archive_loader.cpp.

{
 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();
}

References CADSTAR_ARCHIVE_PARSER::PART::Definition, and CADSTAR_ARCHIVE_PARSER::PART::DEFINITION::Pins.

Referenced by loadSymDefIntoLibrary().

◆ getPolarRadius()

double CADSTAR_SCH_ARCHIVE_LOADER::getPolarRadius ( const VECTOR2I & aPoint )

private

Parameters

aPoint

Returns: Radius of polar representation of the point

Definition at line 3082 of file cadstar_sch_archive_loader.cpp.

{
 return sqrt( ( (double) aPoint.x * (double) aPoint.x )
 + ( (double) aPoint.y * (double) aPoint.y ) );
}

References VECTOR2< T >::x, and VECTOR2< T >::y.

◆ getRouteCode()

CADSTAR_SCH_ARCHIVE_LOADER::ROUTECODE CADSTAR_SCH_ARCHIVE_LOADER::getRouteCode ( const ROUTECODE_ID & aCadstarRouteCodeID )

private

Definition at line 2481 of file cadstar_sch_archive_loader.cpp.

{
 wxCHECK( Assignments.Codedefs.RouteCodes.find( aCadstarRouteCodeID )
 != Assignments.Codedefs.RouteCodes.end(),
 ROUTECODE() );
 
 return Assignments.Codedefs.RouteCodes.at( aCadstarRouteCodeID );
}

References CADSTAR_SCH_ARCHIVE_PARSER::Assignments, CADSTAR_SCH_ARCHIVE_PARSER::ASSIGNMENTS_SCM::Codedefs, and CADSTAR_ARCHIVE_PARSER::CODEDEFS::RouteCodes.

◆ getScaledLibPart()

LIB_SYMBOL * CADSTAR_SCH_ARCHIVE_LOADER::getScaledLibPart	(	const LIB_SYMBOL *	aSymbol,
		long long	aScalingFactorNumerator,
		long long	aScalingFactorDenominator
	)

private

Definition at line 2818 of file cadstar_sch_archive_loader.cpp.

{
 LIB_SYMBOL* retval = new LIB_SYMBOL( *aSymbol );
 
 if( aScalingFactorNumerator == aScalingFactorDenominator )
 return retval; // 1:1 scale, nothing to do
 
 auto scaleLen =
 [&]( int aLength ) -> int
 {
 return( aLength * aScalingFactorNumerator ) / aScalingFactorDenominator;
 };
 
 auto scalePt =
 [&]( VECTOR2I aCoord ) -> VECTOR2I
 {
 return VECTOR2I( scaleLen( aCoord.x ), scaleLen( aCoord.y ) );
 };
 
 auto scaleSize =
 [&]( VECTOR2I aSize ) -> VECTOR2I
 {
 return VECTOR2I( scaleLen( aSize.x ), scaleLen( aSize.y ) );
 };
 
 LIB_ITEMS_CONTAINER& items = retval->GetDrawItems();
 
 for( LIB_ITEM& item : items )
 {
 switch( item.Type() )
 {
 case KICAD_T::LIB_SHAPE_T:
 {
 LIB_SHAPE& shape = static_cast<LIB_SHAPE&>( item );
 
 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 );
 
 for( size_t ii = 0; ii < poly.GetPointCount(); ++ii )
 poly.SetPoint( ii, scalePt( (wxPoint) poly.CPoint( ii ) ) );
 }
 break;
 }
 
 case KICAD_T::LIB_PIN_T:
 {
 LIB_PIN& pin = static_cast<LIB_PIN&>( item );
 
 pin.SetPosition( scalePt( pin.GetPosition() ) );
 pin.SetLength( scaleLen( pin.GetLength() ) );
 break;
 }
 
 case KICAD_T::LIB_TEXT_T:
 {
 LIB_TEXT& txt = static_cast<LIB_TEXT&>( item );
 
 txt.SetPosition( scalePt( txt.GetPosition() ) );
 txt.SetTextSize( scaleSize( txt.GetTextSize() ) );
 break;
 }
 
 default:
 break;
 }
 
 }
 
 return retval;
}

References ARC, SHAPE_LINE_CHAIN::CPoint(), LIB_SYMBOL::GetDrawItems(), EDA_SHAPE::GetEnd(), SHAPE_LINE_CHAIN::GetPointCount(), EDA_SHAPE::GetPolyShape(), LIB_SHAPE::GetPosition(), LIB_TEXT::GetPosition(), EDA_SHAPE::GetShape(), EDA_SHAPE::GetStart(), EDA_TEXT::GetTextSize(), LIB_PIN_T, LIB_SHAPE_T, LIB_TEXT_T, SHAPE_POLY_SET::Outline(), pin, POLY, EDA_SHAPE::SetEnd(), SHAPE_LINE_CHAIN::SetPoint(), LIB_ITEM::SetPosition(), LIB_SHAPE::SetPosition(), EDA_SHAPE::SetStart(), and EDA_TEXT::SetTextSize().

Referenced by loadSchematicSymbolInstances().

◆ getSheetNumber()

int CADSTAR_SCH_ARCHIVE_LOADER::getSheetNumber ( LAYER_ID aCadstarSheetID )

private

Definition at line 2322 of file cadstar_sch_archive_loader.cpp.

{
 int i = 1;
 
 for( LAYER_ID sheetID : Sheets.SheetOrder )
 {
 if( sheetID == aCadstarSheetID )
 return i;
 
 ++i;
 }
 
 return -1;
}

References CADSTAR_SCH_ARCHIVE_PARSER::SHEETS::SheetOrder, and CADSTAR_SCH_ARCHIVE_PARSER::Sheets.

Referenced by loadSheetAndChildSheets(), and loadSheets().

◆ getSpinStyle() [1/2]

TEXT_SPIN_STYLE CADSTAR_SCH_ARCHIVE_LOADER::getSpinStyle ( const EDA_ANGLE & aOrientation )

private

Definition at line 2552 of file cadstar_sch_archive_loader.cpp.

{
 TEXT_SPIN_STYLE spinStyle = TEXT_SPIN_STYLE::LEFT;
 
 EDA_ANGLE oDeg = aOrientation;
 oDeg.Normalize180();
 
 if( oDeg >= -ANGLE_45 && oDeg <= ANGLE_45 )
 spinStyle = TEXT_SPIN_STYLE::RIGHT; // 0deg
 else if( oDeg >= ANGLE_45 && oDeg <= ANGLE_135 )
 spinStyle = TEXT_SPIN_STYLE::UP; // 90deg
 else if( oDeg >= ANGLE_135 || oDeg <= -ANGLE_135 )
 spinStyle = TEXT_SPIN_STYLE::LEFT; // 180deg
 else
 spinStyle = TEXT_SPIN_STYLE::BOTTOM; // 270deg
 
 return spinStyle;
}

References ANGLE_135, ANGLE_45, TEXT_SPIN_STYLE::BOTTOM, TEXT_SPIN_STYLE::LEFT, EDA_ANGLE::Normalize180(), TEXT_SPIN_STYLE::RIGHT, and TEXT_SPIN_STYLE::UP.

◆ getSpinStyle() [2/2]

TEXT_SPIN_STYLE CADSTAR_SCH_ARCHIVE_LOADER::getSpinStyle	(	const long long &	aCadstarOrientation,
		bool	aMirror
	)

private

Definition at line 2536 of file cadstar_sch_archive_loader.cpp.

{
 EDA_ANGLE orientation = getAngle( aCadstarOrientation );
 TEXT_SPIN_STYLE spinStyle = getSpinStyle( orientation );
 
 if( aMirror )
 {
 spinStyle = spinStyle.RotateCCW();
 spinStyle = spinStyle.RotateCCW();
 }
 
 return spinStyle;
}

References getAngle(), getSpinStyle(), and TEXT_SPIN_STYLE::RotateCCW().

Referenced by applyTextSettings(), getSpinStyle(), loadHierarchicalSheetPins(), loadNets(), and loadSchematicSymbolInstances().

◆ getSymDefFromName()

CADSTAR_SCH_ARCHIVE_LOADER::SYMDEF_ID CADSTAR_SCH_ARCHIVE_LOADER::getSymDefFromName	(	const wxString &	aSymdefName,
		const wxString &	aSymDefAlternate
	)

private

Definition at line 2378 of file cadstar_sch_archive_loader.cpp.

{
 // Do a case-insensitive comparison
 for( std::pair<SYMDEF_ID, SYMDEF_SCM> symPair : Library.SymbolDefinitions )
 {
 SYMDEF_ID id = symPair.first;
 SYMDEF_SCM symdef = symPair.second;
 
 if( symdef.ReferenceName.Lower() == aSymdefName.Lower()
 && symdef.Alternate.Lower() == aSymDefAlternate.Lower() )
 {
 return id;
 }
 }
 
 return SYMDEF_ID();
}

References CADSTAR_ARCHIVE_PARSER::SYMDEF::Alternate, CADSTAR_SCH_ARCHIVE_PARSER::Library, CADSTAR_ARCHIVE_PARSER::SYMDEF::ReferenceName, and CADSTAR_SCH_ARCHIVE_PARSER::LIBRARY_SCM::SymbolDefinitions.

Referenced by loadPartsLibrary().

◆ getTextCode()

CADSTAR_SCH_ARCHIVE_LOADER::TEXTCODE CADSTAR_SCH_ARCHIVE_LOADER::getTextCode ( const TEXTCODE_ID & aCadstarTextCodeID )

private

Definition at line 2443 of file cadstar_sch_archive_loader.cpp.

{
 wxCHECK( Assignments.Codedefs.TextCodes.find( aCadstarTextCodeID )
 != Assignments.Codedefs.TextCodes.end(),
 TEXTCODE() );
 
 return Assignments.Codedefs.TextCodes.at( aCadstarTextCodeID );
}

References CADSTAR_SCH_ARCHIVE_PARSER::Assignments, CADSTAR_SCH_ARCHIVE_PARSER::ASSIGNMENTS_SCM::Codedefs, and CADSTAR_ARCHIVE_PARSER::CODEDEFS::TextCodes.

Referenced by applyTextSettings(), and getTextHeightFromTextCode().

◆ getTextHeightFromTextCode()

int CADSTAR_SCH_ARCHIVE_LOADER::getTextHeightFromTextCode ( const TEXTCODE_ID & aCadstarTextCodeID )

private

Definition at line 2453 of file cadstar_sch_archive_loader.cpp.

{
 TEXTCODE txtCode = getTextCode( aCadstarTextCodeID );
 
 return KiROUND( (double) getKiCadLength( txtCode.Height ) * TXT_HEIGHT_RATIO );
}

References getKiCadLength(), getTextCode(), CADSTAR_ARCHIVE_PARSER::TEXTCODE::Height, KiROUND(), and CADSTAR_ARCHIVE_PARSER::TXT_HEIGHT_RATIO.

Referenced by loadSymDefIntoLibrary().

◆ GetXmlAttributeIDLong()

long CADSTAR_ARCHIVE_PARSER::GetXmlAttributeIDLong	(	XNODE *	aNode,
		unsigned int	aID,
		bool	aIsRequired = `true`
	)

staticinherited

Parameters

aNode
aID
aIsRequired	Prevents exception throwing if false.

Returns: returns the value (long) of attribute "attrX" in aNode where 'X' is aID

Exceptions

IO_ERROR if attribute does not exist

Definition at line 2451 of file cadstar_archive_parser.cpp.

{
 long retVal;
 bool success = GetXmlAttributeIDString( aNode, aID, aIsRequired ).ToLong( &retVal );
 
 if( !success )
 {
 if( aIsRequired )
 THROW_PARSING_IO_ERROR( std::to_string( aID ), aNode->GetName() );
 else
 return UNDEFINED_VALUE;
 }
 
 return retVal;
}

References CADSTAR_ARCHIVE_PARSER::GetXmlAttributeIDString(), THROW_PARSING_IO_ERROR, and CADSTAR_ARCHIVE_PARSER::UNDEFINED_VALUE.

◆ GetXmlAttributeIDString()

wxString CADSTAR_ARCHIVE_PARSER::GetXmlAttributeIDString	(	XNODE *	aNode,
		unsigned int	aID,
		bool	aIsRequired = `true`
	)

staticinherited

Parameters

aNode
aID
aIsRequired	Prevents exception throwing if false.

Returns: returns the value (wxString) of attribute "attrX" in aNode where 'X' is aID

Exceptions

IO_ERROR if attribute does not exist

Definition at line 2432 of file cadstar_archive_parser.cpp.

{
 wxString attrName, retVal;
 attrName = "attr";
 attrName << aID;
 
 if( !aNode->GetAttribute( attrName, &retVal ) )
 {
 if( aIsRequired )
 THROW_MISSING_PARAMETER_IO_ERROR( std::to_string( aID ), aNode->GetName() );
 else
 return wxEmptyString;
 }
 
 return retVal;
}

References THROW_MISSING_PARAMETER_IO_ERROR.

◆ HandleTextOverbar()

wxString CADSTAR_ARCHIVE_PARSER::HandleTextOverbar ( wxString aCadstarString )

staticinherited

Convert a string with CADSTAR overbar characters to equivalent in KiCad.

Parameters

aCadstarString Input string

Returns: KiCad string with overbar characters

Definition at line 2611 of file cadstar_archive_parser.cpp.

{
 wxString escapedText = aCadstarString;
 
 escapedText.Replace( wxT( "'" ), wxT( "~" ) );
 
 return ConvertToNewOverbarNotation( escapedText );
}

References ConvertToNewOverbarNotation().

Referenced by applyTextSettings(), loadBusses(), loadNets(), loadSchematicSymbol(), and loadSymDefIntoLibrary().

◆ InsertAttributeAtEnd()

void CADSTAR_ARCHIVE_PARSER::InsertAttributeAtEnd	(	XNODE *	aNode,
		wxString	aValue
	)

staticinherited

Definition at line 2301 of file cadstar_archive_parser.cpp.

{
 wxString result;
 int numAttributes = 0;
 
 if( aNode->GetAttribute( wxT( "numAttributes" ), &result ) )
 {
 numAttributes = wxAtoi( result );
 aNode->DeleteAttribute( wxT( "numAttributes" ) );
 ++numAttributes;
 }
 
 aNode->AddAttribute( wxT( "numAttributes" ), wxString::Format( wxT( "%i" ), numAttributes ) );
 
 wxString paramName = wxT( "attr" );
 paramName << numAttributes;
 
 aNode->AddAttribute( paramName, aValue );
}

References Format().

Referenced by CADSTAR_ARCHIVE_PARSER::LoadArchiveFile().

◆ isAttributeVisible()

bool CADSTAR_SCH_ARCHIVE_LOADER::isAttributeVisible ( const ATTRIBUTE_ID & aCadstarAttributeID )

private

Definition at line 2398 of file cadstar_sch_archive_loader.cpp.

{
 // 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;
 }
 
 return false; // If there is no visibility setting, assume not displayed
}

References CADSTAR_SCH_ARCHIVE_PARSER::AttrColors, and CADSTAR_ARCHIVE_PARSER::ATTRCOLORS::AttributeColors.

Referenced by loadSchematicSymbolInstances(), and loadSymDefIntoLibrary().

◆ IsValidAttribute()

bool CADSTAR_ARCHIVE_PARSER::IsValidAttribute ( wxXmlAttribute * aAttribute )

staticinherited

Parameters

aAttribute

Returns

Definition at line 2426 of file cadstar_archive_parser.cpp.

{
 return aAttribute->GetName() != wxT( "numAttributes" );
}

Referenced by CADSTAR_ARCHIVE_PARSER::PART::DEFINITION::PIN_EQUIVALENCE::Parse(), CADSTAR_ARCHIVE_PARSER::PART::DEFINITION::SWAP_GATE::Parse(), CADSTAR_PCB_ARCHIVE_PARSER::LAYERDEFS::Parse(), CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_COPPER::Parse(), CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_AREA::Parse(), CADSTAR_PCB_ARCHIVE_PARSER::PAD_EXITS::Parse(), and CADSTAR_PCB_ARCHIVE_PARSER::AREA::Parse().

◆ Load()

void CADSTAR_SCH_ARCHIVE_LOADER::Load	(	SCHEMATIC *	aSchematic,
		SCH_SHEET *	aRootSheet,
		SCH_PLUGIN::SCH_PLUGIN_RELEASER *	aSchPlugin,
		const wxFileName &	aLibraryFileName
	)

Loads a CADSTAR PCB Archive file into the KiCad BOARD object given.

Parameters

aSchematic	Schematic to add the design onto
aRootSheet	Root sheet to add the design onto

Definition at line 54 of file cadstar_sch_archive_loader.cpp.

{
 if( m_progressReporter )
 m_progressReporter->SetNumPhases( 3 ); // (0) Read file, (1) Parse file, (2) Load file
 
 Parse();
 
 LONGPOINT designLimit = Assignments.Settings.DesignLimit;
 
 //Note: can't use getKiCadPoint() due VECTOR2I being int - need long long to make the check
 long long designSizeXkicad = (long long) designLimit.x / KiCadUnitDivider;
 long long designSizeYkicad = (long long) designLimit.y / KiCadUnitDivider;
 
 // Max size limited by the positive dimension of VECTOR2I (which is an int)
 constexpr long long maxDesignSizekicad = std::numeric_limits<int>::max();
 
 if( designSizeXkicad > maxDesignSizekicad || designSizeYkicad > maxDesignSizekicad )
 {
 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 ) );
 }
 
 // Assume the center at 0,0 since we are going to be translating the design afterwards anyway
 m_designCenter = { 0, 0 };
 
 m_schematic = aSchematic;
 m_rootSheet = aRootSheet;
 m_plugin = aSchPlugin;
 m_libraryFileName = aLibraryFileName;
 
 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 );
 }
 
 loadTextVariables(); // Load text variables right at the start to ensure bounding box
 // calculations work correctly for text items
 checkPoint(); // Step 1
 loadSheets();
 checkPoint(); // Step 2
 loadHierarchicalSheetPins();
 checkPoint(); // Step 3
 loadPartsLibrary();
 checkPoint(); // Step 4, Subdivided into extra steps
 loadSchematicSymbolInstances();
 checkPoint(); // Step 5
 loadBusses();
 checkPoint(); // Step 6
 loadNets();
 checkPoint(); // Step 7
 loadFigures();
 checkPoint(); // Step 8
 loadTexts();
 checkPoint(); // Step 9
 loadDocumentationSymbols();
 checkPoint(); // Step 10
 
 if( Schematic.VariantHierarchy.Variants.size() > 0 )
 {
 m_reporter->Report( wxString::Format( _( "The CADSTAR design contains variants which has "
 "no KiCad equivalent. Only the master variant "
 "('%s') was loaded." ),
 Schematic.VariantHierarchy.Variants.at( "V0" ).Name ),
  RPT_SEVERITY_WARNING );
 }
 
 if( Schematic.Groups.size() > 0 )
 {
 m_reporter->Report( _( "The CADSTAR design contains grouped items which has no KiCad "
 "equivalent. Any grouped items have been ungrouped." ),
 RPT_SEVERITY_WARNING );
 }
 
 if( Schematic.ReuseBlocks.size() > 0 )
 {
 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 );
 }
 
 
 // For all sheets, center all elements and re calculate the page size:
 for( std::pair<LAYER_ID, SCH_SHEET*> sheetPair : m_sheetMap )
 {
 SCH_SHEET* sheet = sheetPair.second;
 
 // Calculate the new sheet size.
 EDA_RECT sheetBoundingBox;
 
 for( auto item : sheet->GetScreen()->Items() )
 {
 EDA_RECT bbox;
 
 // Only use the visible fields of the symbols to calculate their bounding box
 // (hidden fields could be very long and artificially enlarge the sheet bounding box)
 if( item->Type() == SCH_SYMBOL_T )
 {
 SCH_SYMBOL* comp = static_cast<SCH_SYMBOL*>( item );
 bbox = comp->GetBodyAndPinsBoundingBox();
 
 for( const SCH_FIELD& field : comp->GetFields() )
 {
 if( field.IsVisible() )
 bbox.Merge( field.GetBoundingBox() );
 }
 }
 else if( item->Type() == SCH_TEXT_T )
 {
 SCH_TEXT* txtItem = static_cast<SCH_TEXT*>( item );
 wxString txt = txtItem->GetText();
 
 if( txt.Contains( "${" ) )
 continue; // We can't calculate bounding box of text items with variables
 else
 bbox = txtItem->GetBoundingBox();
 }
 else
 {
 bbox = item->GetBoundingBox();
 }
 
 sheetBoundingBox.Merge( bbox );
 }
 
 // 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
 {
 int error = aNumber % grid;
 int absError = sign( error ) * error;
 
 if( absError > ( grid / 2 ) )
 return aNumber + ( sign( error ) * grid ) - error;
 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
 // the margin to the nearest grid, ensuring all items remain on the grid.
 wxSize targetSheetSize = (wxSize)sheetBoundingBox.GetSize();
 int longestSide = std::max( targetSheetSize.x, targetSheetSize.y );
 int margin = ( (double) longestSide * 0.03 );
 margin = roundToNearestGrid( margin );
 targetSheetSize.IncBy( margin * 2, margin * 2 );
 
 // Update page size always
 PAGE_INFO pageInfo = sheet->GetScreen()->GetPageSettings();
 pageInfo.SetWidthMils( Iu2Mils( targetSheetSize.x ) );
 pageInfo.SetHeightMils( Iu2Mils( targetSheetSize.y ) );
 
 // Set the new sheet size.
 sheet->GetScreen()->SetPageSettings( pageInfo );
 
 wxSize pageSizeIU = sheet->GetScreen()->GetPageSettings().GetSizeIU();
 VECTOR2I sheetcentre( pageSizeIU.x / 2, pageSizeIU.y / 2 );
 VECTOR2I itemsCentre = sheetBoundingBox.Centre();
 
 // round the translation to nearest point on the grid
 VECTOR2I translation = sheetcentre - itemsCentre;
 translation.x = roundToNearestGrid( translation.x );
 translation.y = roundToNearestGrid( translation.y );
 
 // 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 )
 {
 item->Move( translation );
 item->ClearFlags();
 sheet->GetScreen()->Update( item );
 }
 }
 
 checkPoint();
 
 m_reporter->Report( _( "The CADSTAR design has been imported successfully.\n"
 "Please review the import errors and warnings (if any)." ) );
}

Referenced by CADSTAR_SCH_ARCHIVE_PLUGIN::Load().

◆ LoadArchiveFile()

XNODE * CADSTAR_ARCHIVE_PARSER::LoadArchiveFile	(	const wxString &	aFileName,
		const wxString &	aFileTypeIdentifier,
		PROGRESS_REPORTER *	aProgressReporter = `nullptr`
	)

staticinherited

Reads a CADSTAR Archive file (S-parameter format)

Parameters

aFileName
aFileTypeIdentifier	Identifier of the first node in the file to check against. E.g. "CADSTARPCB"
aProgressReporter	Pointer to a Progress Reporter to report progress to.

Returns: XNODE pointing to the top of the tree for further parsing. Each node has the first element as the node's name and subsequent elements as node attributes ("attr0", "attr1", "attr2", etc.). Caller is responsible for deleting to avoid memory leaks.

Exceptions

IO_ERROR

Definition at line 2322 of file cadstar_archive_parser.cpp.

{
 KEYWORD emptyKeywords[1] = {};
 XNODE * iNode = nullptr, *cNode = nullptr;
 int tok;
 bool cadstarFileCheckDone = false;
 wxString str;
 wxCSConv win1252( wxT( "windows-1252" ) );
 wxMBConv* conv = &win1252; // Initial testing suggests file encoding to be Windows-1252
 // More samples required.
 
 // Open the file and get the file size
 FILE* fp = wxFopen( aFileName, wxT( "rt" ) );
 
 if( !fp )
 THROW_IO_ERROR( wxString::Format( _( "Cannot open file '%s'" ), aFileName ) );
 
 fseek( fp, 0L, SEEK_END );
 long fileSize = ftell( fp );
 rewind( fp );
 
 DSNLEXER lexer( emptyKeywords, 0, nullptr, fp, aFileName );
 
 auto currentProgress = [&]() -> double
 {
 return static_cast<double>( ftell( fp ) ) / fileSize;
 };
 
 double previousReportedProgress = -1.0;
 
 while( ( tok = lexer.NextTok() ) != DSN_EOF )
 {
 if( aProgressReporter && ( currentProgress() - previousReportedProgress ) > 0.01 )
 {
 if( !aProgressReporter->KeepRefreshing() )
 THROW_IO_ERROR( _( "File import cancelled by user." ) );
 
 aProgressReporter->SetCurrentProgress( currentProgress() );
 previousReportedProgress = currentProgress();
 }
 
 if( tok == DSN_RIGHT )
 {
 cNode = iNode;
 if( cNode )
 {
 iNode = cNode->GetParent();
 }
 else
 {
 //too many closing brackets
 THROW_IO_ERROR( _( "The selected file is not valid or might be corrupt!" ) );
 }
 }
 else if( tok == DSN_LEFT )
 {
 tok = lexer.NextTok();
 str = wxString( lexer.CurText(), *conv );
 cNode = new XNODE( wxXML_ELEMENT_NODE, str );
 
 if( iNode )
 {
 //we will add it as attribute as well as child node
 InsertAttributeAtEnd( iNode, str );
 iNode->AddChild( cNode );
 }
 else if( !cadstarFileCheckDone )
 {
 if( cNode->GetName() != aFileTypeIdentifier )
 THROW_IO_ERROR( _( "The selected file is not valid or might be corrupt!" ) );
 
 cadstarFileCheckDone = true;
 }
 
 iNode = cNode;
 }
 else if( iNode )
 {
 str = wxString( lexer.CurText(), *conv );
 //Insert even if string is empty
 InsertAttributeAtEnd( iNode, str );
 }
 else
 {
 //not enough closing brackets
 THROW_IO_ERROR( _( "The selected file is not valid or might be corrupt!" ) );
 }
 }
 
 // Not enough closing brackets
 if( iNode != nullptr )
 THROW_IO_ERROR( _( "The selected file is not valid or might be corrupt!" ) );
 
 // Throw if no data was parsed
 if( cNode )
 return cNode;
 else
 THROW_IO_ERROR( _( "The selected file is not valid or might be corrupt!" ) );
 
 return nullptr;
}

References _, DSNLEXER::CurText(), DSN_EOF, DSN_LEFT, DSN_RIGHT, Format(), XNODE::GetParent(), CADSTAR_ARCHIVE_PARSER::InsertAttributeAtEnd(), PROGRESS_REPORTER::KeepRefreshing(), DSNLEXER::NextTok(), PROGRESS_REPORTER::SetCurrentProgress(), and THROW_IO_ERROR.

Referenced by CADSTAR_SCH_ARCHIVE_PARSER::Parse(), and CADSTAR_PCB_ARCHIVE_PARSER::Parse().

◆ loadBusses()

void CADSTAR_SCH_ARCHIVE_LOADER::loadBusses ( )

private

Definition at line 727 of file cadstar_sch_archive_loader.cpp.

{
 for( std::pair<BUS_ID, BUS> busPair : Schematic.Buses )
 {
 BUS bus = busPair.second;
 bool firstPt = true;
 VERTEX last;
 
 if( bus.LayerID != wxT( "NO_SHEET" ) )
 {
 SCH_SCREEN* screen = m_sheetMap.at( bus.LayerID )->GetScreen();
 std::shared_ptr<BUS_ALIAS> kiBusAlias = std::make_shared<BUS_ALIAS>();
 
 kiBusAlias->SetName( bus.Name );
 kiBusAlias->SetParent( screen );
 screen->AddBusAlias( kiBusAlias );
 m_busesMap.insert( { bus.ID, kiBusAlias } );
 
 SCH_LABEL* label = new SCH_LABEL();
 
 wxString busname = HandleTextOverbar( bus.Name );
 
 label->SetText( wxT( "{" ) + busname + wxT( "}" ) );
 label->SetVisible( true );
 screen->Append( label );
 
 SHAPE_LINE_CHAIN busLineChain; // to compute nearest segment to bus label
 
 for( const VERTEX& cur : bus.Shape.Vertices )
 {
 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;
 }
 
 
 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 ) );
 screen->Append( kiBus );
 
 last = cur;
 }
 
 if( bus.HasBusLabel )
 {
 //lets find the closest point in the busline to the label
 VECTOR2I busLabelLoc = getKiCadPoint( bus.BusLabel.Position );
 VECTOR2I nearestPt = busLineChain.NearestPoint( busLabelLoc );
 
 label->SetPosition( nearestPt );
 
 applyTextSettings( label,
 bus.BusLabel.TextCodeID,
 bus.BusLabel.Alignment,
 bus.BusLabel.Justification );
 
 // Re-set bus name as it might have been "double-escaped" after applyTextSettings
 label->SetText( wxT( "{" ) + busname + wxT( "}" ) );
 
 // 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)
 }
 }
 }
}

Referenced by Load().

◆ loadChildSheets()

void CADSTAR_SCH_ARCHIVE_LOADER::loadChildSheets	(	LAYER_ID	aCadstarSheetID,
		const SCH_SHEET_PATH &	aSheet
	)

private

Definition at line 2196 of file cadstar_sch_archive_loader.cpp.

{
 wxCHECK_MSG( m_sheetMap.find( aCadstarSheetID ) != m_sheetMap.end(), ,
 "FIXME! Parent sheet should be loaded before attempting to load subsheets" );
 
 for( std::pair<BLOCK_ID, BLOCK> blockPair : Schematic.Blocks )
 {
 BLOCK& block = blockPair.second;
 
 if( block.LayerID == aCadstarSheetID && block.Type == BLOCK::TYPE::CHILD )
 {
 if( block.AssocLayerID == wxT( "NO_LINK" ) )
 {
 if( block.Figures.size() > 0 )
 {
 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 );
 }
 
 continue;
 }
 
 // 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<VECTOR2I, wxSize> blockExtents;
 
 if( block.Figures.size() > 0 )
 {
 blockExtents = getFigureExtentsKiCad( block.Figures.begin()->second );
 }
 else
 {
 THROW_IO_ERROR( wxString::Format( _( "The CADSTAR schematic might be corrupt: "
 "Block %s references a child sheet but has no "
 "Figure defined." ),
 block.ID ) );
 }
 
 loadSheetAndChildSheets( block.AssocLayerID, blockExtents.first, blockExtents.second,
 aSheet );
 
 // 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 );
 }
 
 if( block.HasBlockLabel )
 {
 //@todo use below code when KiCad supports multi-line fields
 /*
 // Add the block label as a separate field
 SCH_FIELD blockNameField( getKiCadPoint( block.BlockLabel.Position ), 2,
 loadedSheet, wxString( "Block name" ) );
 blockNameField.SetText( block.Name );
 blockNameField.SetVisible( true );
 
 applyTextSettings( &blockNameField,
 block.BlockLabel.TextCodeID,
 block.BlockLabel.Alignment,
 block.BlockLabel.Justification,
 block.BlockLabel.OrientAngle,
 block.BlockLabel.Mirror );
 
 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 );
 }
 
 loadedSheet->SetFields( fields );
 }
 }
}

Referenced by loadSheetAndChildSheets(), and loadSheets().

◆ loadDocumentationSymbols()

void CADSTAR_SCH_ARCHIVE_LOADER::loadDocumentationSymbols ( )

private

Definition at line 1179 of file cadstar_sch_archive_loader.cpp.

{
 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() )
 {
 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 );
 continue;
 }
 
 SYMDEF_SCM docSymDef = Library.SymbolDefinitions.at( docSym.SymdefID );
 VECTOR2I moveVector = getKiCadPoint( docSym.Origin ) - getKiCadPoint( docSymDef.Origin );
 EDA_ANGLE rotationAngle = getAngle( docSym.OrientAngle );
 double scalingFactor = (double) docSym.ScaleRatioNumerator
 / (double) docSym.ScaleRatioDenominator;
 VECTOR2I 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,
 centreOfTransform, mirrorInvert );
 }
 
 for( std::pair<TEXT_ID, TEXT> textPair : docSymDef.Texts )
 {
 TEXT txt = textPair.second;
 
 txt.Mirror = ( txt.Mirror ) ? !mirrorInvert : mirrorInvert;
 txt.OrientAngle = docSym.OrientAngle - txt.OrientAngle;
 
 SCH_TEXT* kiTxt = getKiCadSchText( txt );
 
 VECTOR2I newPosition = applyTransform( kiTxt->GetPosition(), moveVector, rotationAngle,
 scalingFactor, centreOfTransform, mirrorInvert );
 
 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 );
 }
 }
}

Referenced by Load().

◆ loadFigure()

void CADSTAR_SCH_ARCHIVE_LOADER::loadFigure	(	const FIGURE &	aCadstarFigure,
		const LAYER_ID &	aCadstarSheetIDOverride,
		SCH_LAYER_ID	aKiCadSchLayerID,
		const VECTOR2I &	aMoveVector = `{ 0, 0 }`,
		const EDA_ANGLE &	aRotation = `ANGLE_0`,
		const double &	aScalingFactor = `1.0`,
		const VECTOR2I &	aTransformCentre = `{ 0, 0 }`,
		const bool &	aMirrorInvert = `false`
	)

private

Definition at line 2124 of file cadstar_sch_archive_loader.cpp.

{
 loadShapeVertices( aCadstarFigure.Shape.Vertices, aCadstarFigure.LineCodeID,
 aCadstarSheetIDOverride, aKiCadSchLayerID, aMoveVector, aRotation,
 aScalingFactor, aTransformCentre, aMirrorInvert );
 
 for( CUTOUT cutout : aCadstarFigure.Shape.Cutouts )
 {
 loadShapeVertices( cutout.Vertices, aCadstarFigure.LineCodeID, aCadstarSheetIDOverride,
 aKiCadSchLayerID, aMoveVector, aRotation, aScalingFactor,
 aTransformCentre, aMirrorInvert );
 }
}

References CADSTAR_ARCHIVE_PARSER::SHAPE::Cutouts, CADSTAR_ARCHIVE_PARSER::FIGURE::LineCodeID, loadShapeVertices(), CADSTAR_ARCHIVE_PARSER::FIGURE::Shape, CADSTAR_ARCHIVE_PARSER::CUTOUT::Vertices, and CADSTAR_ARCHIVE_PARSER::SHAPE::Vertices.

Referenced by loadDocumentationSymbols(), and loadFigures().

◆ loadFigures()

void CADSTAR_SCH_ARCHIVE_LOADER::loadFigures ( )

private

Definition at line 1156 of file cadstar_sch_archive_loader.cpp.

{
 for( std::pair<FIGURE_ID, FIGURE> figPair : Schematic.Figures )
 {
 FIGURE fig = figPair.second;
 
 loadFigure( fig, fig.LayerID, LAYER_NOTES );
 }
}

References CADSTAR_SCH_ARCHIVE_PARSER::CADSTAR_SCHEMATIC::Figures, LAYER_NOTES, CADSTAR_ARCHIVE_PARSER::FIGURE::LayerID, loadFigure(), and CADSTAR_SCH_ARCHIVE_PARSER::Schematic.

Referenced by Load().

◆ loadGraphicStaightSegment()

void CADSTAR_SCH_ARCHIVE_LOADER::loadGraphicStaightSegment	(	const VECTOR2I &	aStartPoint,
		const VECTOR2I &	aEndPoint,
		const LINECODE_ID &	aCadstarLineCodeID,
		const LAYER_ID &	aCadstarSheetID,
		const SCH_LAYER_ID &	aKiCadSchLayerID,
		const VECTOR2I &	aMoveVector = `{ 0, 0 }`,
		const EDA_ANGLE &	aRotation = `ANGLE_0`,
		const double &	aScalingFactor = `1.0`,
		const VECTOR2I &	aTransformCentre = `{ 0, 0 }`,
		const bool &	aMirrorInvert = `false`
	)

private

Definition at line 2010 of file cadstar_sch_archive_loader.cpp.

{
 SCH_LINE* segment = new SCH_LINE();
 
 segment->SetLayer( aKiCadSchLayerID );
 segment->SetLineWidth( KiROUND( getLineThickness( aCadstarLineCodeID ) * aScalingFactor ) );
 segment->SetLineStyle( getLineStyle( aCadstarLineCodeID ) );
 
 //Apply transforms
 VECTOR2I startPoint = applyTransform( aStartPoint, aMoveVector, aRotation, aScalingFactor,
 aTransformCentre, aMirrorInvert );
 VECTOR2I endPoint = applyTransform( aEndPoint, aMoveVector, aRotation, aScalingFactor,
 aTransformCentre, aMirrorInvert );
 
 segment->SetStartPoint( startPoint );
 segment->SetEndPoint( endPoint );
 
 loadItemOntoKiCadSheet( aCadstarSheetID, segment );
}

References applyTransform(), getLineStyle(), getLineThickness(), KiROUND(), loadItemOntoKiCadSheet(), SCH_LINE::SetEndPoint(), SCH_ITEM::SetLayer(), SCH_LINE::SetLineStyle(), SCH_LINE::SetLineWidth(), and SCH_LINE::SetStartPoint().

Referenced by loadShapeVertices().

◆ loadHierarchicalSheetPins()

void CADSTAR_SCH_ARCHIVE_LOADER::loadHierarchicalSheetPins ( )

private

Definition at line 318 of file cadstar_sch_archive_loader.cpp.

{
 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;
 
 if( m_sheetMap.find( sheetID ) != m_sheetMap.end() )
 {
 SCH_SHEET* sheet = m_sheetMap.at( sheetID );
 
 for( std::pair<TERMINAL_ID, TERMINAL> termPair : block.Terminals )
 {
 TERMINAL term = termPair.second;
 wxString name = "YOU SHOULDN'T SEE THIS TEXT. THIS IS A BUG.";
 
 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( LABEL_FLAG_SHAPE::L_UNSPECIFIED );
 sheetPin->SetTextSpinStyle( 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 );
 m_sheetPinMap.insert( { blockPinID, sheetPin } );
 }
 }
 }
}

Referenced by Load().

◆ loadItemOntoKiCadSheet()

void CADSTAR_SCH_ARCHIVE_LOADER::loadItemOntoKiCadSheet	(	LAYER_ID	aCadstarSheetID,
		SCH_ITEM *	aItem
	)

private

Definition at line 2338 of file cadstar_sch_archive_loader.cpp.

{
 wxCHECK_MSG( aItem, /*void*/, "aItem is null" );
 
 if( aCadstarSheetID == "ALL_SHEETS" )
 {
 SCH_ITEM* duplicateItem;
 
 for( std::pair<LAYER_ID, SHEET_NAME> sheetPair : Sheets.SheetNames )
 {
 LAYER_ID sheetID = sheetPair.first;
 duplicateItem = aItem->Duplicate();
 m_sheetMap.at( sheetID )->GetScreen()->Append( aItem->Duplicate() );
 }
 
 //Get rid of the extra copy:
 delete aItem;
 aItem = duplicateItem;
 }
 else if( aCadstarSheetID == "NO_SHEET" )
 {
 wxASSERT_MSG( false,
 "Trying to add an item to NO_SHEET? This might be a documentation symbol." );
 }
 else
 {
 if( m_sheetMap.find( aCadstarSheetID ) != m_sheetMap.end() )
 {
 m_sheetMap.at( aCadstarSheetID )->GetScreen()->Append( aItem );
 }
 else
 {
 delete aItem;
 wxASSERT_MSG( false, "Unknown Sheet ID." );
 }
 }
}

References SCH_ITEM::Duplicate(), m_sheetMap, CADSTAR_SCH_ARCHIVE_PARSER::SHEETS::SheetNames, and CADSTAR_SCH_ARCHIVE_PARSER::Sheets.

Referenced by loadChildSheets(), loadDocumentationSymbols(), loadGraphicStaightSegment(), and loadTexts().

◆ loadLibrarySymbolShapeVertices()

void CADSTAR_SCH_ARCHIVE_LOADER::loadLibrarySymbolShapeVertices	(	const std::vector< VERTEX > &	aCadstarVertices,
		wxPoint	aSymbolOrigin,
		LIB_SYMBOL *	aSymbol,
		int	aGateNumber,
		int	aLineThickness
	)

private

Definition at line 1628 of file cadstar_sch_archive_loader.cpp.

{
 const VERTEX* prev = &aCadstarVertices.at( 0 );
 const VERTEX* cur;
 
 wxASSERT_MSG( prev->Type == VERTEX_TYPE::POINT, "First vertex should always be a point." );
 
 for( size_t i = 1; i < aCadstarVertices.size(); i++ )
 {
 cur = &aCadstarVertices.at( i );
 
 LIB_SHAPE* shape = nullptr;
 bool cw = false;
 wxPoint startPoint = getKiCadLibraryPoint( prev->End, aSymbolOrigin );
 wxPoint endPoint = getKiCadLibraryPoint( cur->End, aSymbolOrigin );
 wxPoint centerPoint;
 
 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:
 shape = new LIB_SHAPE( aSymbol, SHAPE_T::POLY );
 shape->AddPoint( startPoint );
 shape->AddPoint( endPoint );
 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:
 shape = new LIB_SHAPE( aSymbol, SHAPE_T::ARC );
 
 shape->SetPosition( centerPoint );
 
 if( cw )
 {
 shape->SetStart( endPoint );
 shape->SetEnd( startPoint );
 }
 else
 {
 shape->SetStart( startPoint );
 shape->SetEnd( endPoint );
 }
 
 break;
 }
 
 shape->SetUnit( aGateNumber );
 shape->SetStroke( STROKE_PARAMS( aLineThickness, PLOT_DASH_TYPE::SOLID ) );
 aSymbol->AddDrawItem( shape );
 
 prev = cur;
 }
}

Referenced by loadSymDefIntoLibrary().

◆ loadNets()

void CADSTAR_SCH_ARCHIVE_LOADER::loadNets ( )

private

Definition at line 810 of file cadstar_sch_archive_loader.cpp.

{
 for( std::pair<NET_ID, NET_SCH> netPair : Schematic.Nets )
 {
 NET_SCH net = netPair.second;
 wxString netName = net.Name;
 std::map<NETELEMENT_ID, SCH_LABEL*> netlabels;
 
 if( netName.IsEmpty() )
 netName = wxString::Format( "$%ld", net.SignalNum );
 
 netName = HandleTextOverbar( netName );
 
 for( std::pair<NETELEMENT_ID, NET_SCH::SYM_TERM> terminalPair : net.Terminals )
 {
 NET_SCH::SYM_TERM netTerm = terminalPair.second;
 
 if( m_powerSymMap.find( netTerm.SymbolID ) != m_powerSymMap.end() )
 {
 SCH_FIELD* val = m_powerSymMap.at( netTerm.SymbolID )->GetField( VALUE_FIELD );
 val->SetText( netName );
 val->SetBold( false );
 val->SetVisible( false );
 
 if( netTerm.HasNetLabel )
 {
 val->SetVisible( true );
 val->SetPosition( getKiCadPoint( netTerm.NetLabel.Position ) );
 
 applyTextSettings( val,
 netTerm.NetLabel.TextCodeID,
 netTerm.NetLabel.Alignment,
 netTerm.NetLabel.Justification,
 netTerm.NetLabel.OrientAngle,
 netTerm.NetLabel.Mirror );
 }
 }
 else if( m_globalLabelsMap.find( netTerm.SymbolID ) != m_globalLabelsMap.end() )
 {
 m_globalLabelsMap.at( netTerm.SymbolID )->SetText( netName );
 
 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 );
 }
 }
 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 );
 }
 }
 
 auto getHierarchicalLabel =
 [&]( NETELEMENT_ID aNode ) -> SCH_HIERLABEL*
 {
 if( aNode.Contains( "BLKT" ) )
 {
 NET_SCH::BLOCK_TERM blockTerm = net.BlockTerminals.at( aNode );
 BLOCK_PIN_ID blockPinID = std::make_pair( blockTerm.BlockID,
 blockTerm.TerminalID );
 
 if( m_sheetPinMap.find( blockPinID ) != m_sheetPinMap.end() )
 return m_sheetPinMap.at( blockPinID );
 }
 
 return nullptr;
 };
 
 //Add net name to all hierarchical pins (block terminals in CADSTAR)
 for( std::pair<NETELEMENT_ID, NET_SCH::BLOCK_TERM> blockPair : net.BlockTerminals )
 {
 SCH_HIERLABEL* label = getHierarchicalLabel( blockPair.first );
 
 if( label )
 label->SetText( netName );
 }
 
 // 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 );
 
 if( !m_busesMap.at( bus.ID )->Contains( netName ) )
 m_busesMap.at( bus.ID )->AddMember( netName );
 
 SCH_BUS_WIRE_ENTRY* busEntry =
 new SCH_BUS_WIRE_ENTRY( getKiCadPoint( busTerm.FirstPoint ), false );
 
 VECTOR2I size =
 getKiCadPoint( busTerm.SecondPoint ) - getKiCadPoint( busTerm.FirstPoint );
 busEntry->SetSize( wxSize( size.x, size.y ) );
 
 m_sheetMap.at( bus.LayerID )->GetScreen()->Append( busEntry );
 
 // 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 );
 
 if( busTerm.HasNetLabel )
 {
 applyTextSettings( label,
 busTerm.NetLabel.TextCodeID,
 busTerm.NetLabel.Alignment,
 busTerm.NetLabel.Justification );
 }
 else
 {
 label->SetTextSize( wxSize( SMALL_LABEL_SIZE, SMALL_LABEL_SIZE ) );
 }
 
 netlabels.insert( { busTerm.ID, label } );
 m_sheetMap.at( bus.LayerID )->GetScreen()->Append( label );
 }
 
 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 );
 
 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
 netlabels.insert( { dangler.ID, label } );
 
 m_sheetMap.at( dangler.LayerID )->GetScreen()->Append( label );
 }
 
 for( NET_SCH::CONNECTION_SCH conn : net.Connections )
 {
 if( conn.LayerID == wxT( "NO_SHEET" ) )
 continue; // No point loading virtual connections. KiCad handles that internally
 
 POINT start = getLocationOfNetElement( net, conn.StartNode );
 POINT end = getLocationOfNetElement( net, conn.EndNode );
 
 if( start.x == UNDEFINED_VALUE || end.x == UNDEFINED_VALUE )
 continue;
 
 // Connections in CADSTAR are always implied between symbols even if the route
 // 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 )
 conn.Path.push_back( end );
 
 bool firstPt = true;
 bool secondPt = false;
 VECTOR2I last;
 SCH_LINE* wire = nullptr;
 
 SHAPE_LINE_CHAIN wireChain; // Create a temp. line chain representing the connection
 
 for( POINT pt : conn.Path )
 {
 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();
 VECTOR2I 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 ) )
 {
 // The block terminal is outside the block shape in the original
 // 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() );
 
 if( node == conn.StartNode )
 wireChain = wireChain.Reverse();
 }
 else
 {
 // The block terminal is either inside or on the shape edge. Lets use
 // the first intersection point.
 VECTOR2I intsctPt = wireToSheetIntersects.at( 0 ).p;
 int  intsctIndx = wireChain.FindSegment( intsctPt );
 wxASSERT_MSG( intsctIndx != -1, "Can't find intersecting segment" );
 
 if( node == conn.StartNode )
 wireChain.Replace( 0, intsctIndx, intsctPt );
 else
 wireChain.Replace( intsctIndx + 1, /*end index*/ -1, intsctPt );
 
 sheetPin->SetPosition( intsctPt );
 }
 }
 }
 }
 
 auto fixNetLabelsAndSheetPins =
 [&]( const EDA_ANGLE& aWireAngle, NETELEMENT_ID& aNetEleID )
 {
 TEXT_SPIN_STYLE spin = getSpinStyle( aWireAngle );
 
 if( netlabels.find( aNetEleID ) != netlabels.end() )
 netlabels.at( aNetEleID )->SetTextSpinStyle( spin.MirrorY() );
 
 SCH_HIERLABEL* sheetPin = getHierarchicalLabel( aNetEleID );
 
 if( sheetPin )
 sheetPin->SetTextSpinStyle( spin.MirrorX() );
 };
 
 // Now we can load the wires and fix the label orientations
 for( const VECTOR2I& pt : wireChain.CPoints() )
 {
 if( firstPt )
 {
 last = pt;
 firstPt = false;
 secondPt = true;
 continue;
 }
 
 if( secondPt )
 {
 secondPt = false;
 
 EDA_ANGLE wireAngle( last - pt );
 fixNetLabelsAndSheetPins( wireAngle, conn.StartNode );
 }
 
 wire = new SCH_LINE();
 
 wire->SetStartPoint( last );
 wire->SetEndPoint( pt );
 wire->SetLayer( LAYER_WIRE );
 
 if( !conn.ConnectionLineCode.IsEmpty() )
 wire->SetLineWidth( getLineThickness( conn.ConnectionLineCode ) );
 
 last = pt;
 
 m_sheetMap.at( conn.LayerID )->GetScreen()->Append( wire );
 }
 
 //Fix labels on the end wire
 if( wire )
 {
 EDA_ANGLE wireAngle( wire->GetEndPoint() - wire->GetStartPoint() );
 fixNetLabelsAndSheetPins( wireAngle, conn.EndNode );
 }
 }
 
 for( std::pair<NETELEMENT_ID, NET_SCH::JUNCTION_SCH> juncPair : net.Junctions )
 {
 NET_SCH::JUNCTION_SCH junc = juncPair.second;
 
 SCH_JUNCTION* kiJunc = new SCH_JUNCTION();
 
 kiJunc->SetPosition( getKiCadPoint( junc.Location ) );
 m_sheetMap.at( junc.LayerID )->GetScreen()->Append( kiJunc );
 
 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 );
 
 EDA_ANGLE labelAngle = getAngle( junc.NetLabel.OrientAngle );
 TEXT_SPIN_STYLE spin = getSpinStyle( labelAngle );
 label->SetTextSpinStyle( spin );
 
 m_sheetMap.at( junc.LayerID )->GetScreen()->Append( label );
 }
 }
 }
}

Referenced by Load().

◆ loadPartsLibrary()

void CADSTAR_SCH_ARCHIVE_LOADER::loadPartsLibrary ( )

private

Definition at line 366 of file cadstar_sch_archive_loader.cpp.

{
 for( std::pair<PART_ID, PART> partPair : Parts.PartDefinitions )
 {
 PART_ID partID = partPair.first;
 PART part = partPair.second;
 
 wxString escapedPartName = EscapeString( part.Name, CTX_LIBID );
 LIB_SYMBOL* kiPart = new LIB_SYMBOL( escapedPartName );
 
 kiPart->SetUnitCount( part.Definition.GateSymbols.size() );
 bool ok = true;
 
 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 );
 
 if( symbolID.IsEmpty() )
 {
 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);
 
 ok = false;
 break;
 }
 
 m_partSymbolsMap.insert( { { partID, gateID }, symbolID } );
 loadSymDefIntoLibrary( symbolID, &part, gateID, kiPart );
 }
 
 if( ok && part.Definition.GateSymbols.size() != 0 )
 {
 ( *m_plugin )->SaveSymbol( m_libraryFileName.GetFullPath(), kiPart );
 
 LIB_SYMBOL* loadedPart =
 ( *m_plugin )->LoadSymbol( m_libraryFileName.GetFullPath(), kiPart->GetName() );
 
 m_partMap.insert( { partID, loadedPart } );
 }
 else
 {
 if( part.Definition.GateSymbols.size() == 0 )
 {
 m_reporter->Report(
 wxString::Format( _( "Part definition '%s' has an incomplete definition (no"
 " symbol definitions are associated with it). The part"
 " has not been loaded into the KiCad library." ),
 part.Name ),
 RPT_SEVERITY_WARNING );
 }
 
 // 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), plus the part definition contains
 // the part name, which is important to load
 m_partMap.insert( { partID, kiPart } );
 }
 
 checkPoint();
 }
}

References _, CADSTAR_ARCHIVE_PARSER::checkPoint(), CTX_LIBID, CADSTAR_ARCHIVE_PARSER::PART::Definition, EscapeString(), Format(), CADSTAR_ARCHIVE_PARSER::PART::DEFINITION::GateSymbols, LIB_SYMBOL::GetName(), getSymDefFromName(), loadSymDefIntoLibrary(), m_libraryFileName, m_partMap, m_partSymbolsMap, m_reporter, CADSTAR_ARCHIVE_PARSER::PART::Name, CADSTAR_ARCHIVE_PARSER::PARTS::PartDefinitions, CADSTAR_SCH_ARCHIVE_PARSER::Parts, REPORTER::Report(), RPT_SEVERITY_WARNING, and LIB_SYMBOL::SetUnitCount().

Referenced by Load().

◆ loadSchematicSymbol()

SCH_SYMBOL * CADSTAR_SCH_ARCHIVE_LOADER::loadSchematicSymbol	(	const SYMBOL &	aCadstarSymbol,
		const LIB_SYMBOL &	aKiCadPart,
		EDA_ANGLE &	aComponentOrientation
	)

private

Definition at line 1716 of file cadstar_sch_archive_loader.cpp.

{
 LIB_ID libId( m_libraryFileName.GetName(), aKiCadPart.GetName() );
 int unit = getKiCadUnitNumberFromGate( aCadstarSymbol.GateID );
 
 SCH_SHEET_PATH sheetpath;
 SCH_SHEET* kiSheet = m_sheetMap.at( aCadstarSymbol.LayerID );
 m_rootSheet->LocatePathOfScreen( kiSheet->GetScreen(), &sheetpath );
 
 SCH_SYMBOL* symbol = new SCH_SYMBOL( aKiCadPart, libId, &sheetpath, unit );
 
 if( aCadstarSymbol.IsComponent )
 {
 symbol->SetRef( &sheetpath, aCadstarSymbol.ComponentRef.Designator );
 }
 
 symbol->SetPosition( getKiCadPoint( aCadstarSymbol.Origin ) );
 
 EDA_ANGLE compAngle = getAngle( aCadstarSymbol.OrientAngle );
 int compOrientation = 0;
 
 if( aCadstarSymbol.Mirror )
 {
 compAngle = -compAngle;
 compOrientation += SYMBOL_ORIENTATION_T::SYM_MIRROR_Y;
 }
 
 compOrientation += getComponentOrientation( compAngle, aComponentOrientation );
 EDA_ANGLE test1( compAngle );
 EDA_ANGLE test2( aComponentOrientation );
 
 if( test1.Normalize180() != test2.Normalize180() )
 {
 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,
 compAngle.AsDegrees() ),
 RPT_SEVERITY_ERROR );
 }
 
 symbol->SetOrientation( compOrientation );
 
 if( m_sheetMap.find( aCadstarSymbol.LayerID ) == m_sheetMap.end() )
 {
 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 );
 
 delete symbol;
 return nullptr;
 }
 
 wxString gate = ( aCadstarSymbol.GateID.IsEmpty() ) ? wxT( "A" ) : aCadstarSymbol.GateID;
 wxString partGateIndex = aCadstarSymbol.PartRef.RefID + gate;
 
 //Handle pin swaps
 if( m_pinNumsMap.find( partGateIndex ) != m_pinNumsMap.end() )
 {
 TERMINAL_TO_PINNUM_MAP termNumMap = m_pinNumsMap.at( partGateIndex );
 
 std::map<wxString, LIB_PIN*> pinNumToLibPinMap;
 
 for( auto& term : termNumMap )
 {
 wxString pinNum = term.second;
 pinNumToLibPinMap.insert( { pinNum,
 symbol->GetLibSymbolRef()->GetPin( term.second ) } );
 }
 
 auto replacePinNumber =
 [&]( wxString aOldPinNum, wxString aNewPinNum )
 {
 if( aOldPinNum == aNewPinNum )
 return;
 
 LIB_PIN* libpin = pinNumToLibPinMap.at( aOldPinNum );
 libpin->SetNumber( HandleTextOverbar( aNewPinNum ) );
 };
 
 //Older versions of Cadstar used pin numbers
 for( auto& pinPair : aCadstarSymbol.PinNumbers )
 {
 SYMBOL::PIN_NUM pin = pinPair.second;
 
 replacePinNumber( termNumMap.at( pin.TerminalID ),
 wxString::Format( "%ld", pin.PinNum ) );
 }
 
 //Newer versions of Cadstar use pin names
 for( auto& pinPair : aCadstarSymbol.PinNames )
 {
 SYMPINNAME_LABEL pin = pinPair.second;
 replacePinNumber( termNumMap.at( pin.TerminalID ), pin.NameOrLabel );
 }
 
 symbol->UpdatePins();
 }
 
 kiSheet->GetScreen()->Append( symbol );
 
 return symbol;
}

Referenced by loadSchematicSymbolInstances().

◆ loadSchematicSymbolInstances()

void CADSTAR_SCH_ARCHIVE_LOADER::loadSchematicSymbolInstances ( )

private

Definition at line 436 of file cadstar_sch_archive_loader.cpp.

{
 for( std::pair<SYMBOL_ID, SYMBOL> symPair : Schematic.Symbols )
 {
 SYMBOL sym = symPair.second;
 
 if( !sym.VariantID.empty() && sym.VariantParentSymbolID != sym.ID )
 continue; // Only load master Variant
 
 if( sym.IsComponent )
 {
 if( m_partMap.find( sym.PartRef.RefID ) == m_partMap.end() )
 {
 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 );
 
 continue;
 }
 
 if( sym.GateID.IsEmpty() )
 sym.GateID = wxT( "A" ); // Assume Gate "A" if unspecified
 
 PART_GATE_ID partSymbolID = { sym.PartRef.RefID, sym.GateID };
 LIB_SYMBOL* kiPart = m_partMap.at( sym.PartRef.RefID );
 bool copy = false;
 
 // 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 )
 {
 kiPart = new LIB_SYMBOL( *kiPart ); // Make a copy
 copy = true;
 const PART& part = Parts.PartDefinitions.at( sym.PartRef.RefID );
 loadSymDefIntoLibrary( sym.SymdefID, &part, sym.GateID, kiPart );
 }
 
 LIB_SYMBOL* scaledPart = getScaledLibPart( kiPart, sym.ScaleRatioNumerator,
 sym.ScaleRatioDenominator );
 
 EDA_ANGLE symOrient = ANGLE_0;
 SCH_SYMBOL* symbol = loadSchematicSymbol( sym, *scaledPart, symOrient );
 
 delete scaledPart;
 
 if( copy )
 delete kiPart;
 
 SCH_FIELD* refField = symbol->GetField( REFERENCE_FIELD );
 
 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( "_" ) );
 
 refField->SetText( sym.ComponentRef.Designator );
 loadSymbolFieldAttribute( sym.ComponentRef.AttrLoc, symOrient, sym.Mirror, refField );
 
 if( sym.HasPartRef )
 {
 SCH_FIELD* partField = symbol->FindField( PartNameFieldName );
 
 if( !partField )
 {
 int fieldID = symbol->GetFieldCount();
 partField = symbol->AddField( SCH_FIELD( VECTOR2I(), fieldID, symbol,
 PartNameFieldName ) );
 }
 
 wxASSERT( partField->GetName() == PartNameFieldName );
 
 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, symOrient, sym.Mirror, partField );
 
 partField->SetVisible( SymbolPartNameColor.IsVisible );
 }
 
 for( auto attr : sym.AttributeValues )
 {
 ATTRIBUTE_VALUE attrVal = attr.second;
 
 if( attrVal.HasLocation )
 {
 wxString attrName = getAttributeName( attrVal.AttributeID );
 SCH_FIELD* attrField = symbol->FindField( attrName );
 
 if( !attrField )
 {
 int fieldID = symbol->GetFieldCount();
 attrField = symbol->AddField(
 SCH_FIELD( VECTOR2I(), fieldID, symbol, attrName ) );
 }
 
 wxASSERT( attrField->GetName() == attrName );
 
 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, symOrient, sym.Mirror,
 attrField );
 attrField->SetVisible( isAttributeVisible( attrVal.AttributeID ) );
 }
 }
 }
 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 )
 {
 SYMDEF_ID symID = sym.SymdefID;
 LIB_SYMBOL* kiPart = nullptr;
 
 // In CADSTAR "GlobalSignal" is a special type of symbol which defines
 // a Power Symbol. The "Alternate" name defines the default net name of
 // the power symbol but this can be overridden in the design itself.
 wxString libraryNetName = Library.SymbolDefinitions.at( symID ).Alternate;
 
 // Name of the net that the symbol instance in CADSTAR refers to:
 wxString symbolInstanceNetName = sym.SymbolVariant.Reference;
 symbolInstanceNetName = EscapeString( symbolInstanceNetName, CTX_LIBID );
 
 // 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( ")" );
 }
 
 if( m_powerSymLibMap.find( libPartName ) == m_powerSymLibMap.end() )
 {
 SYMDEF_SCM symbolDef = Library.SymbolDefinitions.at( symID );
 
 kiPart = new LIB_SYMBOL( libPartName );
 kiPart->SetPower();
 loadSymDefIntoLibrary( symID, nullptr, "A", kiPart );
 
 kiPart->GetValueField().SetText( symbolInstanceNetName );
 
 if( symbolDef.TextLocations.find( SIGNALNAME_ORIGIN_ATTRID )
 != symbolDef.TextLocations.end() )
 {
 TEXT_LOCATION txtLoc =
 symbolDef.TextLocations.at( SIGNALNAME_ORIGIN_ATTRID );
 
 VECTOR2I valPos = getKiCadLibraryPoint( txtLoc.Position, symbolDef.Origin );
 
 kiPart->GetValueField().SetPosition( valPos );
 kiPart->GetValueField().SetVisible( true );
 }
 else
 {
 kiPart->GetValueField().SetVisible( false );
 }
 
 kiPart->GetReferenceField().SetText( "#PWR" );
 kiPart->GetReferenceField().SetVisible( false );
 ( *m_plugin )->SaveSymbol( m_libraryFileName.GetFullPath(), kiPart );
 m_powerSymLibMap.insert( { libPartName, kiPart } );
 }
 else
 {
 kiPart = m_powerSymLibMap.at( libPartName );
 wxASSERT( kiPart->GetValueField().GetText() == symbolInstanceNetName );
 }
 
 LIB_SYMBOL* scaledPart = getScaledLibPart( kiPart, sym.ScaleRatioNumerator,
 sym.ScaleRatioDenominator );
 
 EDA_ANGLE returnedOrient = ANGLE_0;
 SCH_SYMBOL* symbol = loadSchematicSymbol( sym, *scaledPart, returnedOrient );
 m_powerSymMap.insert( { sym.ID, symbol } );
 
 delete scaledPart;
 }
 else if( sym.SymbolVariant.Type == SYMBOLVARIANT::TYPE::SIGNALREF )
 {
 // There should only be one pin and we'll use that to set the position
 TERMINAL& symbolTerminal = libSymDef.Terminals.begin()->second;
 VECTOR2I terminalPosOffset = symbolTerminal.Position - libSymDef.Origin;
 EDA_ANGLE rotate = getAngle( sym.OrientAngle );
 
 if( sym.Mirror )
 rotate += ANGLE_180;
 
 RotatePoint( terminalPosOffset, -rotate );
 
 SCH_GLOBALLABEL* netLabel = new SCH_GLOBALLABEL;
 netLabel->SetPosition( getKiCadPoint( (VECTOR2I)sym.Origin + terminalPosOffset ) );
 netLabel->SetText( "***UNKNOWN NET****" ); // This should be later updated when we load the netlist
 netLabel->SetTextSize( wxSize( Mils2iu( 50 ), Mils2iu( 50 ) ) );
 
 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 );
 }
 
 netLabel->SetTextSpinStyle( getSpinStyle( sym.OrientAngle, sym.Mirror ) );
 
  if( libSymDef.Alternate.Lower().Contains( "in" ) )
 netLabel->SetShape( LABEL_FLAG_SHAPE::L_INPUT );
 else if( libSymDef.Alternate.Lower().Contains( "bi" ) )
 netLabel->SetShape( LABEL_FLAG_SHAPE::L_BIDI );
 else if( libSymDef.Alternate.Lower().Contains( "out" ) )
 netLabel->SetShape( LABEL_FLAG_SHAPE::L_OUTPUT );
 else
 netLabel->SetShape( LABEL_FLAG_SHAPE::L_UNSPECIFIED );
 
 SCH_SCREEN* screen = m_sheetMap.at( sym.LayerID )->GetScreen();
 
 // autoplace intersheet refs
 netLabel->AutoplaceFields( screen, false );
 
 screen->Append( netLabel );
 m_globalLabelsMap.insert( { sym.ID, netLabel } );
 }
 else
 {
 wxASSERT_MSG( false, "Unknown Symbol Variant." );
 }
 }
 else
 {
 m_reporter->Report( wxString::Format( _( "Symbol ID '%s' is of an unknown type. It is "
 "neither a symbol or a net power / symbol. "
 "The symbol was not loaded." ),
 sym.ID ),
 RPT_SEVERITY_ERROR );
 }
 
 if( sym.ScaleRatioDenominator != 1 || sym.ScaleRatioNumerator != 1 )
 {
 wxString symbolName = sym.ComponentRef.Designator;
 
 if( symbolName.empty() )
 symbolName = wxString::Format( "ID: %s", sym.ID );
 else
 symbolName += sym.GateID;
 
 m_reporter->Report( wxString::Format( _( "Symbol '%s' is scaled in the original "
 "CADSTAR schematic but this is not supported "
 "in KiCad. When the symbol is reloaded from "
 "the library, it will revert to the original "
 "1:1 scale." ),
  symbolName,
 sym.PartRef.RefID ),
 RPT_SEVERITY_ERROR );
 }
 }
}

Referenced by Load().

◆ loadShapeVertices()

void CADSTAR_SCH_ARCHIVE_LOADER::loadShapeVertices	(	const std::vector< VERTEX > &	aCadstarVertices,
		LINECODE_ID	aCadstarLineCodeID,
		LAYER_ID	aCadstarSheetID,
		SCH_LAYER_ID	aKiCadSchLayerID,
		const VECTOR2I &	aMoveVector = `{ 0, 0 }`,
		const EDA_ANGLE &	aRotation = `ANGLE_0`,
		const double &	aScalingFactor = `1.0`,
		const VECTOR2I &	aTransformCentre = `{ 0, 0 }`,
		const bool &	aMirrorInvert = `false`
	)

private

Definition at line 2040 of file cadstar_sch_archive_loader.cpp.

{
 const VERTEX* prev = &aCadstarVertices.at( 0 );
 const VERTEX* cur;
 
 wxASSERT_MSG( prev->Type == VERTEX_TYPE::POINT,
 "First vertex should always be a point vertex" );
 
 for( size_t ii = 1; ii < aCadstarVertices.size(); ii++ )
 {
 cur = &aCadstarVertices.at( ii );
 
 VECTOR2I startPoint = getKiCadPoint( prev->End );
 VECTOR2I endPoint = getKiCadPoint( cur->End );
 VECTOR2I centerPoint = getKiCadPoint( cur->Center );
 bool cw = false;
 
 if( cur->Type == VERTEX_TYPE::ANTICLOCKWISE_SEMICIRCLE
 || cur->Type == VERTEX_TYPE::CLOCKWISE_SEMICIRCLE )
 {
 centerPoint = ( startPoint + endPoint ) / 2;
 }
 
 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:
 {
 EDA_ANGLE arcStartAngle( startPoint - centerPoint );
 EDA_ANGLE arcEndAngle( endPoint - centerPoint );
 EDA_ANGLE arcAngle = arcEndAngle - arcStartAngle;
 
 if( cw )
 arcAngle = arcAngle.Normalize();
 else
 arcAngle = -arcAngle.Normalize();
 
 // TODO: Load as arc...
 
 SHAPE_ARC tempArc( centerPoint, startPoint, arcAngle );
 SHAPE_LINE_CHAIN arcSegments = tempArc.ConvertToPolyline( Millimeter2iu( 0.1 ) );
 
 // Load the arc as a series of piece-wise segments
 
 for( int jj = 0; jj < arcSegments.SegmentCount(); jj++ )
 {
 VECTOR2I segStart = (wxPoint) arcSegments.Segment( jj ).A;
 VECTOR2I segEnd = (wxPoint) arcSegments.Segment( jj ).B;
 
 loadGraphicStaightSegment( segStart, segEnd, aCadstarLineCodeID, aCadstarSheetID,
 aKiCadSchLayerID, aMoveVector, aRotation, aScalingFactor,
 aTransformCentre, aMirrorInvert );
 }
 }
 break;
 
 case VERTEX_TYPE::POINT:
 loadGraphicStaightSegment( startPoint, endPoint, aCadstarLineCodeID, aCadstarSheetID,
 aKiCadSchLayerID, aMoveVector, aRotation, aScalingFactor,
 aTransformCentre, aMirrorInvert );
 break;
 
 default:
 wxFAIL_MSG( "Unknown CADSTAR Vertex type" );
 }
 
 
 prev = cur;
 }
}

References SEG::A, CADSTAR_ARCHIVE_PARSER::ANTICLOCKWISE_ARC, CADSTAR_ARCHIVE_PARSER::ANTICLOCKWISE_SEMICIRCLE, SEG::B, CADSTAR_ARCHIVE_PARSER::VERTEX::Center, CADSTAR_ARCHIVE_PARSER::CLOCKWISE_ARC, CADSTAR_ARCHIVE_PARSER::CLOCKWISE_SEMICIRCLE, SHAPE_ARC::ConvertToPolyline(), CADSTAR_ARCHIVE_PARSER::VERTEX::End, getKiCadPoint(), KI_FALLTHROUGH, loadGraphicStaightSegment(), Millimeter2iu(), EDA_ANGLE::Normalize(), CADSTAR_ARCHIVE_PARSER::POINT, SHAPE_LINE_CHAIN::Segment(), SHAPE_LINE_CHAIN::SegmentCount(), and CADSTAR_ARCHIVE_PARSER::VERTEX::Type.

Referenced by loadFigure().

◆ loadSheetAndChildSheets()

void CADSTAR_SCH_ARCHIVE_LOADER::loadSheetAndChildSheets	(	LAYER_ID	aCadstarSheetID,
		const VECTOR2I &	aPosition,
		VECTOR2I	aSheetSize,
		const SCH_SHEET_PATH &	aParentSheet
	)

private

Definition at line 2146 of file cadstar_sch_archive_loader.cpp.

{
 wxCHECK_MSG( m_sheetMap.find( aCadstarSheetID ) == m_sheetMap.end(), ,
 "Sheet already loaded!" );
 
 SCH_SHEET* sheet = new SCH_SHEET(
 /* aParent */ aParentSheet.Last(),
 /* aPosition */ aPosition,
 /* aSize */ wxSize( aSheetSize ) );
 SCH_SCREEN* screen = new SCH_SCREEN( m_schematic );
 SCH_SHEET_PATH instance( aParentSheet );
 
 sheet->SetScreen( screen );
 
 wxString name = Sheets.SheetNames.at( aCadstarSheetID );
 
 SCH_FIELD& sheetNameField = sheet->GetFields()[SHEETNAME];
 SCH_FIELD& filenameField = sheet->GetFields()[SHEETFILENAME];
 
 sheetNameField.SetText( name );
 
 int sheetNum = getSheetNumber( aCadstarSheetID );
 wxString loadedFilename = wxFileName( Filename ).GetName();
 std::string filename = wxString::Format( "%s_%02d", loadedFilename, sheetNum ).ToStdString();
 
 ReplaceIllegalFileNameChars( &filename );
 filename += wxT( "." ) + KiCadSchematicFileExtension;
 
 filenameField.SetText( filename );
 
 wxFileName fn( m_schematic->Prj().GetProjectPath() + filename );
 sheet->GetScreen()->SetFileName( fn.GetFullPath() );
 aParentSheet.Last()->GetScreen()->Append( sheet );
 instance.push_back( sheet );
 sheet->AddInstance( instance );
 
 wxString pageNumStr = wxString::Format( "%d", getSheetNumber( aCadstarSheetID ) );
 sheet->SetPageNumber( instance, pageNumStr );
 
 sheet->AutoplaceFields( /* aScreen */ nullptr, /* aManual */ false );
 
 m_sheetMap.insert( { aCadstarSheetID, sheet } );
 
 loadChildSheets( aCadstarSheetID, instance );
}

References SCH_SHEET::AddInstance(), SCH_SCREEN::Append(), SCH_SHEET::AutoplaceFields(), CADSTAR_SCH_ARCHIVE_PARSER::Filename, Format(), SCH_SHEET::GetFields(), PROJECT::GetProjectPath(), SCH_SHEET::GetScreen(), getSheetNumber(), KiCadSchematicFileExtension, SCH_SHEET_PATH::Last(), loadChildSheets(), m_schematic, m_sheetMap, name, SCHEMATIC::Prj(), SCH_SHEET_PATH::push_back(), ReplaceIllegalFileNameChars(), SCH_SCREEN::SetFileName(), SCH_SHEET::SetPageNumber(), SCH_SHEET::SetScreen(), EDA_TEXT::SetText(), SHEETFILENAME, SHEETNAME, CADSTAR_SCH_ARCHIVE_PARSER::SHEETS::SheetNames, and CADSTAR_SCH_ARCHIVE_PARSER::Sheets.

Referenced by loadChildSheets(), and loadSheets().

◆ loadSheets()

void CADSTAR_SCH_ARCHIVE_LOADER::loadSheets ( )

private

Definition at line 264 of file cadstar_sch_archive_loader.cpp.

{
 const std::vector<LAYER_ID>& orphanSheets = findOrphanSheets();
 SCH_SHEET_PATH rootPath;
 rootPath.push_back( m_rootSheet );
 m_rootSheet->AddInstance( rootPath );
 m_rootSheet->SetPageNumber( rootPath, wxT( "1" ) );
 
 if( orphanSheets.size() > 1 )
 {
 int x = 1;
 int y = 1;
 
 for( LAYER_ID sheetID : orphanSheets )
 {
 VECTOR2I pos( x * Mils2iu( 1000 ), y * Mils2iu( 1000 ) );
 wxSize siz( Mils2iu( 1000 ), Mils2iu( 1000 ) );
 
 loadSheetAndChildSheets( sheetID, pos, siz, rootPath );
 
 x += 2;
 
 if( x > 10 ) // start next row
 {
 x = 1;
 y += 2;
 }
 }
 }
 else if( orphanSheets.size() > 0 )
 {
 LAYER_ID rootSheetID = orphanSheets.at( 0 );
 
 wxFileName loadedFilePath = wxFileName( Filename );
 
 std::string filename = wxString::Format( "%s_%02d",
 loadedFilePath.GetName(),
 getSheetNumber( rootSheetID ) ).ToStdString();
 ReplaceIllegalFileNameChars( &filename );
 filename += wxT( "." ) + KiCadSchematicFileExtension;
 
 wxFileName fn( m_schematic->Prj().GetProjectPath() + filename );
 m_rootSheet->GetScreen()->SetFileName( fn.GetFullPath() );
 
 m_sheetMap.insert( { rootSheetID, m_rootSheet } );
 loadChildSheets( rootSheetID, rootPath );
 }
 else
 {
 THROW_IO_ERROR( _( "The CADSTAR schematic might be corrupt: there is no root sheet." ) );
 }
}

References _, SCH_SHEET::AddInstance(), CADSTAR_SCH_ARCHIVE_PARSER::Filename, findOrphanSheets(), Format(), PROJECT::GetProjectPath(), SCH_SHEET::GetScreen(), getSheetNumber(), KiCadSchematicFileExtension, loadChildSheets(), loadSheetAndChildSheets(), m_rootSheet, m_schematic, m_sheetMap, SCHEMATIC::Prj(), SCH_SHEET_PATH::push_back(), ReplaceIllegalFileNameChars(), SCH_SCREEN::SetFileName(), SCH_SHEET::SetPageNumber(), and THROW_IO_ERROR.

Referenced by Load().

◆ loadSymbolFieldAttribute()

void CADSTAR_SCH_ARCHIVE_LOADER::loadSymbolFieldAttribute	(	const ATTRIBUTE_LOCATION &	aCadstarAttrLoc,
		const EDA_ANGLE &	aComponentOrientation,
		bool	aIsMirrored,
		SCH_FIELD *	aKiCadField
	)

private

Definition at line 1828 of file cadstar_sch_archive_loader.cpp.

{
 aKiCadField->SetPosition( getKiCadPoint( aCadstarAttrLoc.Position ) );
 aKiCadField->SetVisible( true );
 
 ALIGNMENT alignment = aCadstarAttrLoc.Alignment;
 EDA_ANGLE textAngle = getAngle( aCadstarAttrLoc.OrientAngle );
 
 if( aIsMirrored )
 {
 // 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.
 
 int textIsVertical = KiROUND( textAngle.AsDegrees() / 90.0 ) % 2;
 
 if( textIsVertical )
 alignment = rotate180( alignment );
 
 alignment = mirrorX( alignment );
 }
 
 applyTextSettings( aKiCadField,
 aCadstarAttrLoc.TextCodeID,
 alignment,
 aCadstarAttrLoc.Justification,
 getCadstarAngle( textAngle - aComponentOrientation ),
 aCadstarAttrLoc.Mirror );
}

References CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_LOCATION::Alignment, applyTextSettings(), EDA_ANGLE::AsDegrees(), getAngle(), getCadstarAngle(), getKiCadPoint(), CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_LOCATION::Justification, KiROUND(), CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_LOCATION::Mirror, mirrorX(), CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_LOCATION::OrientAngle, CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_LOCATION::Position, rotate180(), SCH_FIELD::SetPosition(), EDA_TEXT::SetVisible(), and CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_LOCATION::TextCodeID.

Referenced by loadSchematicSymbolInstances().

◆ loadSymDefIntoLibrary()

void CADSTAR_SCH_ARCHIVE_LOADER::loadSymDefIntoLibrary	(	const SYMDEF_ID &	aSymdefID,
		const PART *	aCadstarPart,
		const GATE_ID &	aGateID,
		LIB_SYMBOL *	aSymbol
	)

private

Definition at line 1303 of file cadstar_sch_archive_loader.cpp.

{
 wxCHECK( Library.SymbolDefinitions.find( aSymdefID ) != Library.SymbolDefinitions.end(), );
 
 SYMDEF_SCM symbol = Library.SymbolDefinitions.at( aSymdefID );
 int gateNumber = getKiCadUnitNumberFromGate( aGateID );
 
 // 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 );
 
 for( std::pair<FIGURE_ID, FIGURE> figPair : symbol.Figures )
 {
 FIGURE fig = figPair.second;
 int lineThickness = getLineThickness( fig.LineCodeID );
 
 loadLibrarySymbolShapeVertices( fig.Shape.Vertices, symbol.Origin, aSymbol, gateNumber,
 lineThickness );
 
 for( CUTOUT c : fig.Shape.Cutouts )
 {
 loadLibrarySymbolShapeVertices( c.Vertices, symbol.Origin, aSymbol, gateNumber,
 lineThickness );
 }
 }
 
 TERMINAL_TO_PINNUM_MAP pinNumMap;
 
 for( std::pair<TERMINAL_ID, TERMINAL> termPair : symbol.Terminals )
 {
 TERMINAL term = termPair.second;
 wxString pinNum = wxString::Format( "%ld", term.ID );
 wxString pinName = wxEmptyString;
 LIB_PIN* pin = new LIB_PIN( aSymbol );
 
 if( aCadstarPart )
 {
 PART::DEFINITION::PIN csPin = getPartDefinitionPin( *aCadstarPart, aGateID, term.ID );
 
 pinName = HandleTextOverbar( csPin.Label );
 pinNum = HandleTextOverbar( csPin.Name );
 
 if( pinNum.IsEmpty() )
 {
 if( !csPin.Identifier.IsEmpty() )
 pinNum = csPin.Identifier;
 else if( csPin.ID == UNDEFINED_VALUE )
 pinNum = wxString::Format( "%ld", term.ID );
 else
 pinNum = wxString::Format( "%ld", csPin.ID );
 }
 
 pin->SetType( getKiCadPinType( csPin.Type ) );
 
 pinNumMap.insert( { term.ID, pinNum } );
 }
 else
 {
 // If no part is defined, we don't know the pin type. Assume passive pin
 pin->SetType( ELECTRICAL_PINTYPE::PT_PASSIVE );
 }
 
 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 );
 pin->SetName( pinName );
 
 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 );
 
 if( aSymbol->IsPower() )
 {
 pin->SetVisible( false );
 pin->SetType( ELECTRICAL_PINTYPE::PT_POWER_IN );
 pin->SetName( aSymbol->GetName() );
 }
 
 aSymbol->AddDrawItem( pin );
 }
 
 fixUpLibraryPins( aSymbol, gateNumber );
 
 if(aCadstarPart)
 m_pinNumsMap.insert( { aCadstarPart->ID + aGateID, pinNumMap } );
 
 for( std::pair<TEXT_ID, TEXT> textPair : symbol.Texts )
 {
 TEXT csText = textPair.second;
 
 LIB_TEXT* libtext = new LIB_TEXT( aSymbol );
 libtext->SetText( csText.Text );
 libtext->SetUnit( gateNumber );
 libtext->SetPosition( getKiCadLibraryPoint( csText.Position, symbol.Origin ) );
 libtext->SetMultilineAllowed( true ); // temporarily so that we calculate bbox correctly
 
 applyTextSettings( libtext,
 csText.TextCodeID,
 csText.Alignment,
 csText.Justification,
 csText.OrientAngle,
 csText.Mirror );
 
 // Split out multi line text items into individual text elements
 if( csText.Text.Contains( "\n" ) )
 {
 wxArrayStri

Enumerator
NO_ALIGNMENT	NO_ALIGNMENT has different meaning depending on the object type.
TOPLEFT
TOPCENTER
TOPRIGHT
CENTERLEFT
CENTERCENTER
CENTERRIGHT
BOTTOMLEFT
BOTTOMCENTER
BOTTOMRIGHT

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ATTRIBUTE_ID

◆ BLOCK_ID

◆ BLOCK_PIN_ID

◆ BUS_ID

◆ COLOR_ID

◆ DOCUMENTATION_SYMBOL_ID

◆ FIGURE_ID

◆ GATE_ID

◆ GROUP_ID

◆ HATCHCODE_ID

◆ LAYER_ID

◆ LINECODE_ID

◆ NET_ID

◆ NETCLASS_ID

◆ NETELEMENT_ID

◆ PART_DEFINITION_PIN_ID

◆ PART_GATE_ID

◆ PART_ID

◆ PART_PIN_ID

◆ REUSEBLOCK_ID

◆ ROUTECODE_ID

◆ SHEET_NAME

◆ SPACING_CLASS_ID

◆ SYMBOL_ID

◆ SYMDEF_ID

◆ TERMINAL_ID

◆ TERMINAL_TO_PINNUM_MAP

◆ TERMINALCODE_ID

◆ TEXT_ID

◆ TEXTCODE_ID

◆ VARIANT_ID

Member Enumeration Documentation

◆ ALIGNMENT

◆ ANGUNITS

◆ ATTROWNER

◆ ATTRUSAGE

◆ GRID_TYPE

◆ JUSTIFICATION

◆ LINESTYLE

◆ READABILITY

◆ RESOLUTION

◆ SHAPE_TYPE

◆ SWAP_RULE

◆ TERMINAL_SHAPE_TYPE

◆ TEXT_FIELD_NAME

◆ UNITS

◆ VERTEX_TYPE

Constructor & Destructor Documentation

◆ CADSTAR_SCH_ARCHIVE_LOADER()

◆ ~CADSTAR_SCH_ARCHIVE_LOADER()

Member Function Documentation

◆ applyTextSettings()

◆ applyToLibraryFieldAttribute()

◆ applyTransform()

◆ CheckNoChildNodes()

◆ CheckNoNextNodes()

◆ checkPoint()

◆ findOrphanSheets()

◆ FixTextPositionNoAlignment()

◆ fixUpLibraryPins()

◆ generateLibName()

◆ getAngle()

◆ getAttributeName()

◆ getCadstarAngle()

◆ getComponentOrientation()

◆ getFigureExtentsKiCad()

◆ getKiCadLength()

◆ getKiCadLibraryPoint()