#include <cadstar_pcb_archive_loader.h>

Inheritance diagram for CADSTAR_PCB_ARCHIVE_LOADER:

Public Types
enum	MATERIAL_LAYER_TYPE { MATERIAL_LAYER_TYPE::CONSTRUCTION, MATERIAL_LAYER_TYPE::ELECTRICAL, MATERIAL_LAYER_TYPE::NON_ELECTRICAL }
	Type of layer appropriate for the material being set up. More...

enum	LAYER_TYPE { LAYER_TYPE::UNDEFINED, LAYER_TYPE::ALLLAYER, LAYER_TYPE::ALLELEC, LAYER_TYPE::ALLDOC, LAYER_TYPE::NOLAYER, LAYER_TYPE::ASSCOMPCOPP, LAYER_TYPE::JUMPERLAYER, LAYER_TYPE::ELEC, LAYER_TYPE::POWER, LAYER_TYPE::NONELEC, LAYER_TYPE::CONSTRUCTION, LAYER_TYPE::DOC }

enum	LAYER_SUBTYPE { LAYER_SUBTYPE::LAYERSUBTYPE_NONE, LAYER_SUBTYPE::LAYERSUBTYPE_SILKSCREEN, LAYER_SUBTYPE::LAYERSUBTYPE_PLACEMENT, LAYER_SUBTYPE::LAYERSUBTYPE_ASSEMBLY, LAYER_SUBTYPE::LAYERSUBTYPE_SOLDERRESIST, LAYER_SUBTYPE::LAYERSUBTYPE_PASTE, LAYER_SUBTYPE::LAYERSUBTYPE_CLEARANCE, LAYER_SUBTYPE::LAYERSUBTYPE_ROUT }

enum	ROUTING_BIAS { ROUTING_BIAS::UNBIASED, ROUTING_BIAS::X, ROUTING_BIAS::Y, ROUTING_BIAS::ANTI_ROUTE, ROUTING_BIAS::OBSTACLE }

enum	EMBEDDING { EMBEDDING::NONE, EMBEDDING::ABOVE, EMBEDDING::BELOW }

enum	PAD_SHAPE_TYPE { PAD_SHAPE_TYPE::ANNULUS, PAD_SHAPE_TYPE::BULLET, PAD_SHAPE_TYPE::CIRCLE, PAD_SHAPE_TYPE::DIAMOND, PAD_SHAPE_TYPE::FINGER, PAD_SHAPE_TYPE::OCTAGON, PAD_SHAPE_TYPE::RECTANGLE, PAD_SHAPE_TYPE::ROUNDED_RECT, PAD_SHAPE_TYPE::SQUARE }

enum	PAD_SIDE { PAD_SIDE::MINIMUM, PAD_SIDE::MAXIMUM, PAD_SIDE::THROUGH_HOLE }
	From CADSTAR Help: "This parameter indicates the physical layers on which the selected pad is placed. More...

enum	SYMDEF_TYPE { SYMDEF_TYPE::COMPONENT, SYMDEF_TYPE::JUMPER, SYMDEF_TYPE::STARPOINT, SYMDEF_TYPE::TESTPOINT }
	A symbol definition can represent a number of different objects in CADSTAR. More...

enum	TESTLAND_SIDE { TESTLAND_SIDE::NONE, TESTLAND_SIDE::MAX, TESTLAND_SIDE::MIN, TESTLAND_SIDE::BOTH }

enum	NETSYNCH { NETSYNCH::UNDEFINED, NETSYNCH::WARNING, NETSYNCH::FULL }

typedef wxString	MATERIAL_ID

typedef long	PHYSICAL_LAYER_ID

typedef wxString	COPPERCODE_ID

typedef wxString	PADCODE_ID

typedef wxString	VIACODE_ID

typedef wxString	SPACINGCODE_ID

typedef wxString	LAYERPAIR_ID

typedef wxString	RULESET_ID

typedef wxString	COMP_AREA_ID

typedef long	PAD_ID
	Pad identifier (pin) in the PCB. More...

typedef wxString	DIMENSION_ID

typedef wxString	BOARD_ID

typedef wxString	AREA_ID

typedef wxString	COMPONENT_ID

typedef wxString	TEMPLATE_ID

typedef long	COPPER_TERM_ID

typedef wxString	COPPER_ID

typedef wxString	DRILL_TABLE_ID

typedef wxString	TRUNK_ID

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

enum	RESOLUTION { RESOLUTION::HUNDREDTH_MICRON }

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

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

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

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

enum	ANGUNITS { ANGUNITS::DEGREES, ANGUNITS::RADIANS }

enum	GRID_TYPE { GRID_TYPE::FRACTIONALGRID, GRID_TYPE::STEPGRID }

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

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

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

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

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

enum	SWAP_RULE { SWAP_RULE::NO_SWAP, SWAP_RULE::USE_SWAP_LAYER, SWAP_RULE::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_PCB_ARCHIVE_LOADER (wxString aFilename, LAYER_MAPPING_HANDLER aLayerMappingHandler, bool aLogLayerWarnings, PROGRESS_REPORTER *aProgressReporter)

	~CADSTAR_PCB_ARCHIVE_LOADER ()

void	Load (BOARD aBoard, PROJECT aProject)
	Loads a CADSTAR PCB Archive file into the KiCad BOARD object given. More...

std::vector< FOOTPRINT * >	GetLoadedLibraryFootpints () const
	Return a copy of the loaded library footprints (caller owns the objects) More...

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

Static Public Member Functions
static PAD_SIDE	GetPadSide (const wxString &aPadSideString)

static TESTLAND_SIDE	ParseTestlandSide (XNODE *aNode)

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
wxString	Filename

HEADER	Header

ASSIGNMENTS	Assignments

LIBRARY	Library

PARTS	Parts

LAYOUT	Layout

int	KiCadUnitMultiplier
	Use this value to convert units in this CPA 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
using	ASSOCIATED_COPPER_PADS = std::map< PAD_ID, std::vector< PAD_ID > >
	Map of pad anchor points (first) to copper pads (second). More...

Private Member Functions
void	loadBoardStackup ()

void	remapUnsureLayers ()
	Callback m_layerMappingHandler for layers we aren't sure of. More...

void	loadDesignRules ()

void	loadComponentLibrary ()

void	loadGroups ()

void	loadBoards ()

void	loadFigures ()

void	loadTexts ()

void	loadDimensions ()

void	loadAreas ()

void	loadComponents ()

void	loadDocumentationSymbols ()

void	loadTemplates ()

void	loadCoppers ()

void	loadNets ()

void	loadTextVariables ()

void	logBoardStackupWarning (const wxString &aCadstarLayerName, const PCB_LAYER_ID &aKiCadLayer)

void	logBoardStackupMessage (const wxString &aCadstarLayerName, const PCB_LAYER_ID &aKiCadLayer)

void	initStackupItem (const LAYER &aCadstarLayer, BOARD_STACKUP_ITEM *aKiCadItem, int aDielectricSublayer)

void	loadLibraryFigures (const SYMDEF_PCB &aComponent, FOOTPRINT *aFootprint)

void	loadLibraryCoppers (const SYMDEF_PCB &aComponent, FOOTPRINT *aFootprint)

void	loadLibraryAreas (const SYMDEF_PCB &aComponent, FOOTPRINT *aFootprint)

void	loadLibraryPads (const SYMDEF_PCB &aComponent, FOOTPRINT *aFootprint)

void	loadComponentAttributes (const COMPONENT &aComponent, FOOTPRINT *aFootprint)

void	loadNetTracks (const NET_ID &aCadstarNetID, const NET_PCB::ROUTE &aCadstarRoute, long aStartWidth=std::numeric_limits< long >::max(), long aEndWidth=std::numeric_limits< long >::max())

int	loadNetVia (const NET_ID &aCadstarNetID, const NET_PCB::VIA &aCadstarVia)
	Load via and return via size. More...

void	checkAndLogHatchCode (const HATCHCODE_ID &aCadstarHatchcodeID)

void	applyDimensionSettings (const DIMENSION &aCadstarDim, PCB_DIMENSION_BASE *aKiCadDim)

bool	calculateZonePriorities (PCB_LAYER_ID &aLayer)
	Tries to make a best guess as to the zone priorities based on the pour status. More...

void	drawCadstarText (const TEXT &aCadstarText, BOARD_ITEM_CONTAINER *aContainer, const GROUP_ID &aCadstarGroupID=wxEmptyString, const LAYER_ID &aCadstarLayerOverride=wxEmptyString, const wxPoint &aMoveVector={ 0, 0 }, const double &aRotationAngle=0.0, const double &aScalingFactor=1.0, const wxPoint &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)

void	drawCadstarShape (const SHAPE &aCadstarShape, const PCB_LAYER_ID &aKiCadLayer, const int &aLineThickness, const wxString &aShapeName, BOARD_ITEM_CONTAINER *aContainer, const GROUP_ID &aCadstarGroupID=wxEmptyString, const wxPoint &aMoveVector={ 0, 0 }, const double &aRotationAngle=0.0, const double &aScalingFactor=1.0, const wxPoint &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)

void	drawCadstarCutoutsAsShapes (const std::vector< CUTOUT > &aCutouts, const PCB_LAYER_ID &aKiCadLayer, const int &aLineThickness, BOARD_ITEM_CONTAINER *aContainer, const GROUP_ID &aCadstarGroupID=wxEmptyString, const wxPoint &aMoveVector={ 0, 0 }, const double &aRotationAngle=0.0, const double &aScalingFactor=1.0, const wxPoint &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)
	Uses PCB_SHAPEs to draw the cutouts on m_board object. More...

void	drawCadstarVerticesAsShapes (const std::vector< VERTEX > &aCadstarVertices, const PCB_LAYER_ID &aKiCadLayer, const int &aLineThickness, BOARD_ITEM_CONTAINER *aContainer, const GROUP_ID &aCadstarGroupID=wxEmptyString, const wxPoint &aMoveVector={ 0, 0 }, const double &aRotationAngle=0.0, const double &aScalingFactor=1.0, const wxPoint &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)
	Uses PCB_SHAPE to draw the vertices on m_board object. More...

std::vector< PCB_SHAPE * >	getShapesFromVertices (const std::vector< VERTEX > &aCadstarVertices, BOARD_ITEM_CONTAINER *aContainer=nullptr, const GROUP_ID &aCadstarGroupID=wxEmptyString, const wxPoint &aMoveVector={ 0, 0 }, const double &aRotationAngle=0.0, const double &aScalingFactor=1.0, const wxPoint &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)
	Returns a vector of pointers to PCB_SHAPE objects. More...

PCB_SHAPE *	getShapeFromVertex (const POINT &aCadstarStartPoint, const VERTEX &aCadstarVertex, BOARD_ITEM_CONTAINER *aContainer=nullptr, const GROUP_ID &aCadstarGroupID=wxEmptyString, const wxPoint &aMoveVector={ 0, 0 }, const double &aRotationAngle=0.0, const double &aScalingFactor=1.0, const wxPoint &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)
	Returns a pointer to a PCB_SHAPE object. More...

ZONE *	getZoneFromCadstarShape (const SHAPE &aCadstarShape, const int &aLineThickness, BOARD_ITEM_CONTAINER *aParentContainer)

SHAPE_POLY_SET	getPolySetFromCadstarShape (const SHAPE &aCadstarShape, const int &aLineThickness=-1, BOARD_ITEM_CONTAINER *aContainer=nullptr, const wxPoint &aMoveVector={ 0, 0 }, const double &aRotationAngle=0.0, const double &aScalingFactor=1.0, const wxPoint &aTransformCentre={ 0, 0 }, const bool &aMirrorInvert=false)
	Returns a SHAPE_POLY_SET object from a Cadstar SHAPE. More...

SHAPE_LINE_CHAIN	getLineChainFromShapes (const std::vector< PCB_SHAPE * > aShapes)
	Returns a SHAPE_LINE_CHAIN object from a series of PCB_SHAPE objects. More...

std::vector< PCB_TRACK * >	makeTracksFromShapes (const std::vector< PCB_SHAPE * > aShapes, BOARD_ITEM_CONTAINER aParentContainer, NETINFO_ITEM aNet=nullptr, PCB_LAYER_ID aLayerOverride=UNDEFINED_LAYER, int aWidthOverride=-1)
	Returns a vector of pointers to TRACK/ARC objects. More...

void	addAttribute (const ATTRIBUTE_LOCATION &aCadstarAttrLoc, const ATTRIBUTE_ID &aCadstarAttributeID, FOOTPRINT *aFootprint, const wxString &aAttributeValue)
	Adds a CADSTAR Attribute to a KiCad footprint. More...

void	applyRouteOffset (wxPoint *aPointToOffset, const wxPoint &aRefPoint, const long &aOffsetAmount)
	CADSTAR's Post Processor does an action called "Route Offset" which is applied when a route is wider than the pad on which it is terminating or when there are different widths of route, in order to reduce overlap. More...

int	getLineThickness (const LINECODE_ID &aCadstarLineCodeID)

COPPERCODE	getCopperCode (const COPPERCODE_ID &aCadstaCopperCodeID)

HATCHCODE	getHatchCode (const HATCHCODE_ID &aCadstarHatchcodeID)

LAYERPAIR	getLayerPair (const LAYERPAIR_ID &aCadstarLayerPairID)

PADCODE	getPadCode (const PADCODE_ID &aCadstarPadCodeID)

PART	getPart (const PART_ID &aCadstarPartID)

ROUTECODE	getRouteCode (const ROUTECODE_ID &aCadstarRouteCodeID)

TEXTCODE	getTextCode (const TEXTCODE_ID &aCadstarTextCodeID)

VIACODE	getViaCode (const VIACODE_ID &aCadstarViaCodeID)

wxString	getAttributeName (const ATTRIBUTE_ID &aCadstarAttributeID)

wxString	getAttributeValue (const ATTRIBUTE_ID &aCadstarAttributeID, const std::map< ATTRIBUTE_ID, ATTRIBUTE_VALUE > &aCadstarAttributeMap)

LAYER_TYPE	getLayerType (const LAYER_ID aCadstarLayerID)

double	getHatchCodeAngleDegrees (const HATCHCODE_ID &aCadstarHatchcodeID)

PAD *	getKiCadPad (const COMPONENT_PAD &aCadstarPad, FOOTPRINT *aParent)

PAD *&	getPadReference (FOOTPRINT *aFootprint, const PAD_ID aCadstarPadID)

FOOTPRINT *	getFootprintFromCadstarID (const COMPONENT_ID &aCadstarComponentID)

int	getKiCadHatchCodeThickness (const HATCHCODE_ID &aCadstarHatchcodeID)

int	getKiCadHatchCodeGap (const HATCHCODE_ID &aCadstarHatchcodeID)

PCB_GROUP *	getKiCadGroup (const GROUP_ID &aCadstarGroupID)

wxPoint	getKiCadPoint (const wxPoint &aCadstarPoint)
	Scales, offsets and inverts y axis to make the point usable directly in KiCad. More...

int	getKiCadLength (long long aCadstarLength)

double	getAngleTenthDegree (const long long &aCadstarAngle)

double	getAngleDegrees (const long long &aCadstarAngle)

double	getPolarAngle (const wxPoint &aPoint)

NETINFO_ITEM *	getKiCadNet (const NET_ID &aCadstarNetID)
	Searches m_netMap and returns the NETINFO_ITEM pointer if exists. More...

PCB_LAYER_ID	getKiCadCopperLayerID (unsigned int aLayerNum, bool aDetectMaxLayer=true)

bool	isLayerSet (const LAYER_ID &aCadstarLayerID)

PCB_LAYER_ID	getKiCadLayer (const LAYER_ID &aCadstarLayerID)

LSET	getKiCadLayerSet (const LAYER_ID &aCadstarLayerID)

bool	isFootprint (BOARD_ITEM_CONTAINER *aContainer)

void	addToGroup (const GROUP_ID &aCadstarGroupID, BOARD_ITEM *aKiCadItem)

GROUP_ID	createUniqueGroupID (const wxString &aName)
	Adds a new PCB_GROUP* to m_groupMap. More...

Private Attributes
LAYER_MAPPING_HANDLER	m_layerMappingHandler
	Callback to get layer mapping. More...

bool	m_logLayerWarnings
	Used in loadBoardStackup() More...

BOARD *	m_board

PROJECT *	m_project

std::map< LAYER_ID, PCB_LAYER_ID >	m_layermap
	Map between Cadstar and KiCad Layers. More...

std::map< SYMDEF_ID, FOOTPRINT * >	m_libraryMap
	Map between Cadstar and KiCad components in the library. More...

std::map< GROUP_ID, PCB_GROUP * >	m_groupMap
	Map between Cadstar and KiCad groups. More...

std::map< COMPONENT_ID, FOOTPRINT * >	m_componentMap
	Map between Cadstar and KiCad components on the board. More...

std::map< SYMDEF_ID, ASSOCIATED_COPPER_PADS >	m_librarycopperpads
	Associated copper pads (if any) for each component library definition. More...

std::map< NET_ID, NETINFO_ITEM * >	m_netMap
	Map between Cadstar and KiCad Nets. More...

std::map< std::tuple< ROUTECODE_ID, NETCLASS_ID, SPACING_CLASS_ID >, NETCLASSPTR >	m_netClassMap
	Map between Cadstar and KiCad classes. More...

std::map< TEMPLATE_ID, ZONE * >	m_zonesMap
	Map between Cadstar and KiCad zones. More...

std::vector< LAYER_ID >	m_powerPlaneLayers
	List of layers that are marked as power plane in CADSTAR. More...

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

std::set< HATCHCODE_ID >	m_hatchcodesTested
	Used by checkAndLogHatchCode() to avoid multiple duplicate warnings. More...

std::set< PADCODE_ID >	m_padcodesTested
	Used by getKiCadPad() to avoid multiple duplicate warnings. More...

bool	m_doneCopperWarning
	Used by loadCoppers() to avoid multiple duplicate warnings. More...

bool	m_doneSpacingClassWarning
	Used by getKiCadNet() to avoid multiple duplicate warnings. More...

bool	m_doneNetClassWarning
	Used by getKiCadNet() to avoid multiple duplicate warnings. More...

int	m_numNets
	Number of nets loaded so far. More...

int	m_numCopperLayers
	Number of layers in the design. More...

Detailed Description

Definition at line 39 of file cadstar_pcb_archive_loader.h.

Member Typedef Documentation

◆ AREA_ID

typedef wxString CADSTAR_PCB_ARCHIVE_PARSER::AREA_ID

inherited

Definition at line 70 of file cadstar_pcb_archive_parser.h.

◆ ASSOCIATED_COPPER_PADS

using CADSTAR_PCB_ARCHIVE_LOADER::ASSOCIATED_COPPER_PADS = std::map<PAD_ID, std::vector<PAD_ID> >

private

Map of pad anchor points (first) to copper pads (second).

In the vast majority of designs there is only one copper pad, but just in case, making it a vector

Definition at line 110 of file cadstar_pcb_archive_loader.h.

◆ ATTRIBUTE_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::ATTRIBUTE_ID

inherited

Definition at line 100 of file cadstar_archive_parser.h.

◆ BOARD_ID

typedef wxString CADSTAR_PCB_ARCHIVE_PARSER::BOARD_ID

inherited

Definition at line 69 of file cadstar_pcb_archive_parser.h.

◆ COLOR_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::COLOR_ID

inherited

Definition at line 114 of file cadstar_archive_parser.h.

◆ COMP_AREA_ID

typedef wxString CADSTAR_PCB_ARCHIVE_PARSER::COMP_AREA_ID

inherited

Definition at line 66 of file cadstar_pcb_archive_parser.h.

◆ COMPONENT_ID

typedef wxString CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_ID

inherited

Definition at line 71 of file cadstar_pcb_archive_parser.h.

◆ COPPER_ID

typedef wxString CADSTAR_PCB_ARCHIVE_PARSER::COPPER_ID

inherited

Definition at line 74 of file cadstar_pcb_archive_parser.h.

◆ COPPER_TERM_ID

typedef long CADSTAR_PCB_ARCHIVE_PARSER::COPPER_TERM_ID

inherited

Definition at line 73 of file cadstar_pcb_archive_parser.h.

◆ COPPERCODE_ID

typedef wxString CADSTAR_PCB_ARCHIVE_PARSER::COPPERCODE_ID

inherited

Definition at line 60 of file cadstar_pcb_archive_parser.h.

◆ DIMENSION_ID

typedef wxString CADSTAR_PCB_ARCHIVE_PARSER::DIMENSION_ID

inherited

Definition at line 68 of file cadstar_pcb_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.

◆ DRILL_TABLE_ID

typedef wxString CADSTAR_PCB_ARCHIVE_PARSER::DRILL_TABLE_ID

inherited

Definition at line 75 of file cadstar_pcb_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.

◆ LAYERPAIR_ID

typedef wxString CADSTAR_PCB_ARCHIVE_PARSER::LAYERPAIR_ID

inherited

Definition at line 64 of file cadstar_pcb_archive_parser.h.

◆ LINECODE_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::LINECODE_ID

inherited

Definition at line 92 of file cadstar_archive_parser.h.

◆ MATERIAL_ID

typedef wxString CADSTAR_PCB_ARCHIVE_PARSER::MATERIAL_ID

inherited

Definition at line 58 of file cadstar_pcb_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.

◆ PAD_ID

typedef long CADSTAR_PCB_ARCHIVE_PARSER::PAD_ID

inherited

Pad identifier (pin) in the PCB.

Definition at line 67 of file cadstar_pcb_archive_parser.h.

◆ PADCODE_ID

typedef wxString CADSTAR_PCB_ARCHIVE_PARSER::PADCODE_ID

inherited

Definition at line 61 of file cadstar_pcb_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_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.

◆ PHYSICAL_LAYER_ID

typedef long CADSTAR_PCB_ARCHIVE_PARSER::PHYSICAL_LAYER_ID

inherited

Definition at line 59 of file cadstar_pcb_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.

◆ RULESET_ID

typedef wxString CADSTAR_PCB_ARCHIVE_PARSER::RULESET_ID

inherited

Definition at line 65 of file cadstar_pcb_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.

◆ SPACINGCODE_ID

typedef wxString CADSTAR_PCB_ARCHIVE_PARSER::SPACINGCODE_ID

inherited

Definition at line 63 of file cadstar_pcb_archive_parser.h.

◆ SYMDEF_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::SYMDEF_ID

inherited

Definition at line 101 of file cadstar_archive_parser.h.

◆ TEMPLATE_ID

typedef wxString CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE_ID

inherited

Definition at line 72 of file cadstar_pcb_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.

◆ 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.

◆ TRUNK_ID

typedef wxString CADSTAR_PCB_ARCHIVE_PARSER::TRUNK_ID

inherited

Definition at line 76 of file cadstar_pcb_archive_parser.h.

◆ VARIANT_ID

typedef wxString CADSTAR_ARCHIVE_PARSER::VARIANT_ID

inherited

Definition at line 99 of file cadstar_archive_parser.h.

◆ VIACODE_ID

typedef wxString CADSTAR_PCB_ARCHIVE_PARSER::VIACODE_ID

inherited

Definition at line 62 of file cadstar_pcb_archive_parser.h.

Member Enumeration Documentation

◆ ALIGNMENT

enum 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 CADSTAR_ARCHIVE_PARSER::ANGUNITS

stronginherited

Enumerator
DEGREES
RADIANS

Definition at line 486 of file cadstar_archive_parser.h.

  {
  DEGREES,
  RADIANS
  };

◆ ATTROWNER

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

◆ EMBEDDING

enum CADSTAR_PCB_ARCHIVE_PARSER::EMBEDDING

stronginherited

Enumerator
NONE
ABOVE
BELOW

Definition at line 142 of file cadstar_pcb_archive_parser.h.

  {
  NONE,
  ABOVE,
  BELOW
  };

◆ GRID_TYPE

enum 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 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

◆ LAYER_SUBTYPE

enum CADSTAR_PCB_ARCHIVE_PARSER::LAYER_SUBTYPE

stronginherited

Enumerator
LAYERSUBTYPE_NONE
LAYERSUBTYPE_SILKSCREEN
LAYERSUBTYPE_PLACEMENT
LAYERSUBTYPE_ASSEMBLY
LAYERSUBTYPE_SOLDERRESIST
LAYERSUBTYPE_PASTE
LAYERSUBTYPE_CLEARANCE
LAYERSUBTYPE_ROUT

Definition at line 119 of file cadstar_pcb_archive_parser.h.

  {
  LAYERSUBTYPE_NONE,
  LAYERSUBTYPE_SILKSCREEN,
  LAYERSUBTYPE_PLACEMENT,
  LAYERSUBTYPE_ASSEMBLY,
  LAYERSUBTYPE_SOLDERRESIST,
  LAYERSUBTYPE_PASTE,
  LAYERSUBTYPE_CLEARANCE,
  LAYERSUBTYPE_ROUT,
  };

◆ LAYER_TYPE

enum CADSTAR_PCB_ARCHIVE_PARSER::LAYER_TYPE

stronginherited

Enumerator
UNDEFINED	Only used for error detection.
ALLLAYER	Inbuilt layer type (cannot be assigned to user layers)
ALLELEC	Inbuilt layer type (cannot be assigned to user layers)
ALLDOC	Inbuilt layer type (cannot be assigned to user layers)
NOLAYER	Inbuilt layer type (cannot be assigned to user layers)
ASSCOMPCOPP	Inbuilt layer type (cannot be assigned to user layers)
JUMPERLAYER	Inbuilt layer type (cannot be assigned to user layers)
ELEC
POWER
NONELEC	This type has subtypes.
CONSTRUCTION
DOC

Definition at line 102 of file cadstar_pcb_archive_parser.h.

  {
  UNDEFINED, 
  ALLLAYER, 
  ALLELEC, 
  ALLDOC, 
  NOLAYER, 
  ASSCOMPCOPP, 
  JUMPERLAYER, 
  ELEC,
  POWER,
  NONELEC, 
  CONSTRUCTION,
  DOC
  };

◆ LINESTYLE

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

◆ MATERIAL_LAYER_TYPE

enum CADSTAR_PCB_ARCHIVE_PARSER::MATERIAL_LAYER_TYPE

stronginherited

Type of layer appropriate for the material being set up.

Enumerator

CONSTRUCTION

ELECTRICAL

Either.

See also: LAYER_TYPE::ELEC or; LAYER_TYPE::POWER

NON_ELECTRICAL

Definition at line 81 of file cadstar_pcb_archive_parser.h.

  {
  CONSTRUCTION,
  ELECTRICAL, 
  NON_ELECTRICAL
  };

◆ NETSYNCH

enum CADSTAR_PCB_ARCHIVE_PARSER::NETSYNCH

stronginherited

Enumerator
UNDEFINED
WARNING
FULL

Definition at line 1153 of file cadstar_pcb_archive_parser.h.

  {
  UNDEFINED,
  WARNING,
  FULL
  };

◆ PAD_SHAPE_TYPE

enum CADSTAR_PCB_ARCHIVE_PARSER::PAD_SHAPE_TYPE

stronginherited

Enumerator
ANNULUS
BULLET
CIRCLE	Keyword "ROUND".
DIAMOND
FINGER
OCTAGON
RECTANGLE
ROUNDED_RECT	Keyword "ROUNDED".
SQUARE

Definition at line 259 of file cadstar_pcb_archive_parser.h.

  {
  ANNULUS,
  BULLET,
  CIRCLE, 
  DIAMOND,
  FINGER,
  OCTAGON,
  RECTANGLE,
  ROUNDED_RECT, 
  SQUARE
  };

◆ PAD_SIDE

enum CADSTAR_PCB_ARCHIVE_PARSER::PAD_SIDE

stronginherited

From CADSTAR Help: "This parameter indicates the physical layers on which the selected pad is placed.

Note: When you change the Side parameter in PCB Design, the Side assigned to the pad in the library is not overwritten."

Enumerator

MINIMUM

PHYSICAL_LAYER_ID 1 (i.e.

front / top side). Normally used for surface mount devices.

MAXIMUM

The highest PHYSICAL_LAYER_ID currently defined (i.e.

back / bottom side). Normally used for surface mount devices.

THROUGH_HOLE

All physical layers currently defined.

Definition at line 480 of file cadstar_pcb_archive_parser.h.

  {
  MINIMUM, 
  MAXIMUM, 
  THROUGH_HOLE 
  };

◆ READABILITY

enum 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 CADSTAR_ARCHIVE_PARSER::RESOLUTION

stronginherited

Enumerator
HUNDREDTH_MICRON

Definition at line 242 of file cadstar_archive_parser.h.

  {
  HUNDREDTH_MICRON
  };

◆ ROUTING_BIAS

enum CADSTAR_PCB_ARCHIVE_PARSER::ROUTING_BIAS

stronginherited

Enumerator
UNBIASED	Keyword "UNBIASED" (default)
X	Keyword "X_BIASED".
Y	Keyword "Y_BIASED".
ANTI_ROUTE	Keyword "ANTITRACK".
OBSTACLE	Keyword "OBSTACLE".

Definition at line 132 of file cadstar_pcb_archive_parser.h.

  {
  UNBIASED, 
  X, 
  Y, 
  ANTI_ROUTE, 
  OBSTACLE 
  };

◆ SHAPE_TYPE

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

◆ SYMDEF_TYPE

enum CADSTAR_PCB_ARCHIVE_PARSER::SYMDEF_TYPE

stronginherited

A symbol definition can represent a number of different objects in CADSTAR.

SYMDEF_TYPE is used in cadstar2kicadplugin to simplify identification of each type.

Enumerator
COMPONENT	Standard PCB Component definition.
JUMPER	From CADSTAR Help: "Jumpers are components used primarily for the purpose of routing. A jumper's two pins are connected with a wire, joining together the nets on either side. Typically, a jumper is used to bridge across other routes where a routing problem is particularly difficult or to make a small modification to a design when most of the routing has been finalised. In CADSTAR, components are designated as jumpers in the component footprint. If the footprint has two pins and the first eight letters of the reference name spell "JUMPERNF" then the component will be treated as a jumper. From CADSTAR 8.0 archive format onwards, jumpers are saved as jumpers. For older archive formats and for most other export formats and post processing, jumpers are treated just as components. When CADSTAR saves a PCB design in an old archive format, the implied connection between the jumper's pins is added as an actual connection. When an old archive or binary PCB design is opened in the latest CADSTAR, any component footprint with two pins and whose first eight letters spell "JUMPERNF" will be treated as a jumper footprint automatically. If there is an actual connection between the pins, it will be removed and one implied from then on. If there isn't an actual connection, the nets connected to the pins will be merged. If a merge is needed and if each net has a user-supplied name (not $...), you will be asked to choose which name to use."
STARPOINT	From CADSTAR Help: "Starpoints are special symbols/components that can be used to electrically connect different nets together, whilst avoiding any of the standard design rule error codes that would normally occur. If the first eleven letters of the reference name spell "STARPOINTNF" then the component will be treated as a starpoint. For a starpoint component to be valid: There must be at least two pads All pads must have the same position All pads must have the same orientation All pads must be on the same side All pad codes must be the same All pads must have the same exit direction All pads must have the same PCB Only Pad setting If a starpoint component is not valid you will get an error message when trying to add it to the PCB component library."
TESTPOINT	From CADSTAR Help: "A testpoint is an area of copper connected to a net. It allows a test probe to investigate the electrical properties of that net. The Testpoint Symbols provided in the CADSTAR libraries are the Alternates for a pre-defined symbol called TESTPOINT." If the ReferenceName equals "TESTPOINT", then the component is treated as such. Note that the library manager does not permit adding a component with the name "TESTPOINT" if it has more than one pad defined.

Definition at line 720 of file cadstar_pcb_archive_parser.h.

  {
  COMPONENT, 
  JUMPER, 
  STARPOINT, 
  TESTPOINT 
  };

◆ TESTLAND_SIDE

enum CADSTAR_PCB_ARCHIVE_PARSER::TESTLAND_SIDE

stronginherited

Enumerator
NONE
MAX	The highest PHYSICAL_LAYER_ID currently defined (i.e. back / bottom side).
MIN	The lowest PHYSICAL_LAYER_ID currently defined (i.e. front / top side).
BOTH

Definition at line 858 of file cadstar_pcb_archive_parser.h.

  {
  NONE,
  MAX, 
  MIN, 
  BOTH
  };

◆ TEXT_FIELD_NAME

enum 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 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 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_PCB_ARCHIVE_LOADER()

CADSTAR_PCB_ARCHIVE_LOADER::CADSTAR_PCB_ARCHIVE_LOADER	(	wxString	aFilename,
		LAYER_MAPPING_HANDLER	aLayerMappingHandler,
		bool	aLogLayerWarnings,
		PROGRESS_REPORTER *	aProgressReporter
	)

inlineexplicit

Definition at line 42 of file cadstar_pcb_archive_loader.h.

  : CADSTAR_PCB_ARCHIVE_PARSER( aFilename )
  {
  m_layerMappingHandler = aLayerMappingHandler;
  m_logLayerWarnings = aLogLayerWarnings;
  m_board = nullptr;
  m_project = nullptr;
  m_designCenter.x = 0;
  m_designCenter.y = 0;
  m_doneCopperWarning = false;
  m_doneSpacingClassWarning = false;
  m_doneNetClassWarning = false;
  m_numNets = 0;
  m_numCopperLayers = 0 ;
  m_progressReporter = aProgressReporter;
  }

References m_board, m_designCenter, m_doneCopperWarning, m_doneNetClassWarning, m_doneSpacingClassWarning, m_layerMappingHandler, m_logLayerWarnings, m_numCopperLayers, m_numNets, CADSTAR_ARCHIVE_PARSER::m_progressReporter, and m_project.

◆ ~CADSTAR_PCB_ARCHIVE_LOADER()

CADSTAR_PCB_ARCHIVE_LOADER::~CADSTAR_PCB_ARCHIVE_LOADER ( )

inline

Definition at line 63 of file cadstar_pcb_archive_loader.h.

  {
  for( std::pair<SYMDEF_ID, FOOTPRINT*> libItem : m_libraryMap )
  {
  FOOTPRINT* footprint = libItem.second;
 
  if( footprint )
  delete footprint;
  }
  }

References m_libraryMap.

Member Function Documentation

◆ addAttribute()

void CADSTAR_PCB_ARCHIVE_LOADER::addAttribute	(	const ATTRIBUTE_LOCATION &	aCadstarAttrLoc,
		const ATTRIBUTE_ID &	aCadstarAttributeID,
		FOOTPRINT *	aFootprint,
		const wxString &	aAttributeValue
	)

private

Adds a CADSTAR Attribute to a KiCad footprint.

Parameters

aCadstarAttrLoc
aCadstarAttributeID
aFootprint
aAttributeValue

Definition at line 3198 of file cadstar_pcb_archive_loader.cpp.

 {
  FP_TEXT* txt;
 
  if( aCadstarAttributeID == COMPONENT_NAME_ATTRID )
  {
  txt = &aFootprint->Reference(); //text should be set outside this function
  }
  else if( aCadstarAttributeID == PART_NAME_ATTRID )
  {
  if( aFootprint->Value().GetText().IsEmpty() )
  {
  // Use PART_NAME_ATTRID as the value is value field is blank
  aFootprint->SetValue( aAttributeValue );
  txt = &aFootprint->Value();
  }
  else
  {
  txt = new FP_TEXT( aFootprint );
  aFootprint->Add( txt );
  txt->SetText( aAttributeValue );
  }
  txt->SetVisible( false ); //make invisible to avoid clutter.
  }
  else if( aCadstarAttributeID != COMPONENT_NAME_2_ATTRID
  && getAttributeName( aCadstarAttributeID ) == wxT( "Value" ) )
  {
  if( !aFootprint->Value().GetText().IsEmpty() )
  {
  //copy the object
  aFootprint->Add( aFootprint->Value().Duplicate() );
  }
 
  aFootprint->SetValue( aAttributeValue );
  txt = &aFootprint->Value();
  txt->SetVisible( false ); //make invisible to avoid clutter.
  }
  else
  {
  txt = new FP_TEXT( aFootprint );
  aFootprint->Add( txt );
  txt->SetText( aAttributeValue );
  txt->SetVisible( false ); //make all user attributes invisible to avoid clutter.
  //TODO: Future improvement - allow user to decide what to do with attributes
  }
 
  wxPoint rotatedTextPos = getKiCadPoint( aCadstarAttrLoc.Position ) - aFootprint->GetPosition();
  RotatePoint( &rotatedTextPos, -aFootprint->GetOrientation() );
 
  txt->SetTextPos( getKiCadPoint( aCadstarAttrLoc.Position ) );
  txt->SetPos0( rotatedTextPos );
  txt->SetLayer( getKiCadLayer( aCadstarAttrLoc.LayerID ) );
  txt->SetMirrored( aCadstarAttrLoc.Mirror );
  txt->SetTextAngle(
  getAngleTenthDegree( aCadstarAttrLoc.OrientAngle ) - aFootprint->GetOrientation() );
 
  if( aCadstarAttrLoc.Mirror ) // If mirroring, invert angle to match CADSTAR
  txt->SetTextAngle( -txt->GetTextAngle() );
 
  TEXTCODE tc = getTextCode( aCadstarAttrLoc.TextCodeID );
 
  txt->SetTextThickness( getKiCadLength( tc.LineWidth ) );
 
  wxSize txtSize;
  txtSize.x = getKiCadLength( tc.Width );
 
  // The width is zero for all non-cadstar fonts. Using a width equal to the height seems
  // to work well for most fonts.
  if( txtSize.x == 0 )
  txtSize.x = getKiCadLength( tc.Height );
 
  txtSize.y = KiROUND( TXT_HEIGHT_RATIO * (double) getKiCadLength( tc.Height ) );
  txt->SetTextSize( txtSize );
  txt->SetKeepUpright( false ); //Keeping it upright seems to result in incorrect orientation
 
  switch( aCadstarAttrLoc.Alignment )
  {
  case ALIGNMENT::NO_ALIGNMENT: // Default for Single line text is Bottom Left
  FixTextPositionNoAlignment( txt );
  KI_FALLTHROUGH;
  case ALIGNMENT::BOTTOMLEFT:
  txt->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
  break;
 
  case ALIGNMENT::BOTTOMCENTER:
  txt->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
  break;
 
  case ALIGNMENT::BOTTOMRIGHT:
  txt->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
  break;
 
  case ALIGNMENT::CENTERLEFT:
  txt->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER );
  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
  break;
 
  case ALIGNMENT::CENTERCENTER:
  txt->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER );
  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
  break;
 
  case ALIGNMENT::CENTERRIGHT:
  txt->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER );
  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
  break;
 
  case ALIGNMENT::TOPLEFT:
  txt->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
  break;
 
  case ALIGNMENT::TOPCENTER:
  txt->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
  break;
 
  case ALIGNMENT::TOPRIGHT:
  txt->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
  break;
 
  default:
  wxFAIL_MSG( wxT( "Unknown Alignment - needs review!" ) );
  }
 
  //TODO Handle different font types when KiCad can support it.
 }

Referenced by loadComponentAttributes().

◆ addToGroup()

void CADSTAR_PCB_ARCHIVE_LOADER::addToGroup	(	const GROUP_ID &	aCadstarGroupID,
		BOARD_ITEM *	aKiCadItem
	)

private

Definition at line 4116 of file cadstar_pcb_archive_loader.cpp.

 {
  wxCHECK( m_groupMap.find( aCadstarGroupID ) != m_groupMap.end(), );
 
  PCB_GROUP* parentGroup = m_groupMap.at( aCadstarGroupID );
  parentGroup->AddItem( aKiCadItem );
 }

References m_groupMap.

Referenced by drawCadstarShape(), drawCadstarText(), getShapeFromVertex(), and loadBoards().

◆ applyDimensionSettings()

void CADSTAR_PCB_ARCHIVE_LOADER::applyDimensionSettings	(	const DIMENSION &	aCadstarDim,
		PCB_DIMENSION_BASE *	aKiCadDim
	)

private

Definition at line 3593 of file cadstar_pcb_archive_loader.cpp.

 {
  UNITS dimensionUnits = aCadstarDim.LinearUnits;
  TEXTCODE txtCode = getTextCode( aCadstarDim.Text.TextCodeID );
  int correctedHeight = KiROUND( TXT_HEIGHT_RATIO * (double) getKiCadLength( txtCode.Height ) );
  wxSize txtSize( getKiCadLength( txtCode.Width ), correctedHeight );
  LINECODE linecode = Assignments.Codedefs.LineCodes.at( aCadstarDim.Line.LineCodeID );
 
  aKiCadDim->SetLayer( getKiCadLayer( aCadstarDim.LayerID ) );
  aKiCadDim->SetPrecision( aCadstarDim.Precision );
  aKiCadDim->SetStart( getKiCadPoint( aCadstarDim.ExtensionLineParams.Start ) );
  aKiCadDim->SetEnd( getKiCadPoint( aCadstarDim.ExtensionLineParams.End ) );
  aKiCadDim->SetExtensionOffset( getKiCadLength( aCadstarDim.ExtensionLineParams.Offset ) );
  aKiCadDim->SetLineThickness( getKiCadLength( linecode.Width ) );
  aKiCadDim->Text().SetTextThickness( getKiCadLength( txtCode.LineWidth ) );
  aKiCadDim->Text().SetTextSize( txtSize );
 
  // Find prefix and suffix:
  wxString prefix = wxEmptyString;
  wxString suffix = wxEmptyString;
  size_t startpos = aCadstarDim.Text.Text.Find( wxT( "<@DISTANCE" ) );
 
  if( startpos != wxNOT_FOUND )
  {
  prefix = ParseTextFields( aCadstarDim.Text.Text.SubString( 0, startpos - 1 ), &m_context );
  wxString remainingStr = aCadstarDim.Text.Text.Mid( startpos );
  size_t endpos = remainingStr.Find( "@>" );
  suffix = ParseTextFields( remainingStr.Mid( endpos + 2 ), &m_context );
  }
 
  if( suffix.StartsWith( wxT( "mm" ) ) )
  {
  aKiCadDim->SetUnitsFormat( DIM_UNITS_FORMAT::BARE_SUFFIX );
  suffix = suffix.Mid( 2 );
  }
  else
  {
  aKiCadDim->SetUnitsFormat( DIM_UNITS_FORMAT::NO_SUFFIX );
  }
 
  aKiCadDim->SetPrefix( prefix );
  aKiCadDim->SetSuffix( suffix );
 
  if( aCadstarDim.LinearUnits == UNITS::DESIGN )
  {
  // For now we will hardcode the units as per the original CADSTAR design.
  // TODO: update this when KiCad supports design units
  aKiCadDim->SetPrecision( Assignments.Technology.UnitDisplPrecision );
  dimensionUnits = Assignments.Technology.Units;
  }
 
  switch( dimensionUnits )
  {
  case UNITS::METER:
  case UNITS::CENTIMETER:
  case UNITS::MICROMETRE:
  wxLogWarning( wxString::Format( _( "Dimension ID %s uses a type of unit that "
  "is not supported in KiCad. Millimeters were "
  "applied instead." ),
  aCadstarDim.ID ) );
  KI_FALLTHROUGH;
  case UNITS::MM:
  aKiCadDim->SetUnitsMode( DIM_UNITS_MODE::MILLIMETRES );
  break;
 
  case UNITS::INCH:
  aKiCadDim->SetUnitsMode( DIM_UNITS_MODE::INCHES );
  break;
 
  case UNITS::THOU:
  aKiCadDim->SetUnitsMode( DIM_UNITS_MODE::MILS );
  break;
 
  case UNITS::DESIGN:
  wxFAIL_MSG( wxT( "We should have handled design units before coming here!" ) );
  break;
  }
 }

Referenced by loadDimensions().

◆ applyRouteOffset()

void CADSTAR_PCB_ARCHIVE_LOADER::applyRouteOffset	(	wxPoint *	aPointToOffset,
		const wxPoint &	aRefPoint,
		const long &	aOffsetAmount
	)

private

CADSTAR's Post Processor does an action called "Route Offset" which is applied when a route is wider than the pad on which it is terminating or when there are different widths of route, in order to reduce overlap.

Parameters

aPointToOffset	Point that we want to offset by aOffsetAmount
aRefPoint	Reference point to use for determine the angle of the offset
aOffsetAmount

Definition at line 3334 of file cadstar_pcb_archive_loader.cpp.

 {
  VECTOR2I v( *aPointToOffset - aRefPoint );
  int newLength = v.EuclideanNorm() - aOffsetAmount;
 
  if( newLength > 0 )
  {
  VECTOR2I offsetted = v.Resize( newLength ) + VECTOR2I( aRefPoint );
  aPointToOffset->x = offsetted.x;
  aPointToOffset->y = offsetted.y;
  }
  else
  {
  *aPointToOffset = aRefPoint; // zero length track. Needs to be removed to mimmick
  // cadstar behaviour
  }
 }

References VECTOR2< T >::EuclideanNorm(), VECTOR2< T >::Resize(), VECTOR2< T >::x, and VECTOR2< T >::y.

Referenced by makeTracksFromShapes().

◆ calculateZonePriorities()

bool CADSTAR_PCB_ARCHIVE_LOADER::calculateZonePriorities ( PCB_LAYER_ID & aLayer )

private

Tries to make a best guess as to the zone priorities based on the pour status.

Definition at line 3673 of file cadstar_pcb_archive_loader.cpp.

 {
  std::map<TEMPLATE_ID, std::set<TEMPLATE_ID>> winningOverlaps;
 
  auto inflateValue =
  [&]( ZONE* aZoneA, ZONE* aZoneB )
  {
  int extra = getKiCadLength( Assignments.Codedefs.SpacingCodes.at( wxT( "C_C" ) ).Spacing )
  - m_board->GetDesignSettings().m_MinClearance;
 
  int retval = std::max( aZoneA->GetLocalClearance(), aZoneB->GetLocalClearance() );
 
  retval += extra;
 
  return retval;
  };
 
  // Find the error in fill area when guessing that aHigherZone gets filled before aLowerZone
  auto errorArea =
  [&]( ZONE* aLowerZone, ZONE* aHigherZone ) -> double
  {
  SHAPE_POLY_SET intersectShape( *aHigherZone->Outline() );
  intersectShape.Inflate( inflateValue( aLowerZone, aHigherZone ) , 32 );
 
  SHAPE_POLY_SET lowerZoneFill( aLowerZone->GetFilledPolysList( aLayer ) );
 
  SHAPE_POLY_SET lowerZoneOutline( *aLowerZone->Outline() );
 
  lowerZoneOutline.BooleanSubtract( intersectShape,
  SHAPE_POLY_SET::PM_FAST );
 
  lowerZoneFill.BooleanSubtract( lowerZoneOutline,
  SHAPE_POLY_SET::PM_FAST );
 
  double leftOverArea = lowerZoneFill.Area();
 
  return leftOverArea;
  };
 
  auto intersectionAreaOfZoneOutlines =
  [&]( ZONE* aZoneA, ZONE* aZoneB ) -> double
  {
  SHAPE_POLY_SET outLineA( *aZoneA->Outline() );
  outLineA.Inflate( inflateValue( aZoneA, aZoneB ), 32 );
 
  SHAPE_POLY_SET outLineB( *aZoneA->Outline() );
  outLineB.Inflate( inflateValue( aZoneA, aZoneB ), 32 );
 
  outLineA.BooleanIntersection( outLineB, SHAPE_POLY_SET::PM_FAST );
 
  return outLineA.Area();
  };
 
  // Lambda to determine if the zone with template ID 'a' is lower priority than 'b'
  auto isLowerPriority =
  [&]( const TEMPLATE_ID& a, const TEMPLATE_ID& b ) -> bool
  {
  return winningOverlaps[b].count( a ) > 0;
  };
 
  for( std::map<TEMPLATE_ID, ZONE*>::iterator it1 = m_zonesMap.begin();
  it1 != m_zonesMap.end(); ++it1 )
  {
  TEMPLATE& thisTemplate = Layout.Templates.at( it1->first );
  ZONE* thisZone = it1->second;
 
  if( !thisZone->GetLayerSet().Contains( aLayer ) )
  continue;
 
  for( std::map<TEMPLATE_ID, ZONE*>::iterator it2 = it1;
  it2 != m_zonesMap.end(); ++it2 )
  {
  TEMPLATE& otherTemplate = Layout.Templates.at( it2->first );
  ZONE* otherZone = it2->second;
 
  if( thisTemplate.ID == otherTemplate.ID )
  continue;
 
  if( !otherZone->GetLayerSet().Contains( aLayer ) )
  {
  checkPoint();
  continue;
   }
 
  if( intersectionAreaOfZoneOutlines( thisZone, otherZone ) == 0 )
  {
  checkPoint();
  continue; // The zones do not interact in any way
  }
 
  SHAPE_POLY_SET thisZonePolyFill = thisZone->GetFilledPolysList( aLayer );
  SHAPE_POLY_SET otherZonePolyFill = otherZone->GetFilledPolysList( aLayer );
 
  if( thisZonePolyFill.Area() > 0.0 && otherZonePolyFill.Area() > 0.0 )
  {
  // Test if this zone were lower priority than other zone, what is the error?
  double areaThis = errorArea( thisZone, otherZone );
  // Viceversa
  double areaOther = errorArea( otherZone, thisZone );
 
  if( areaThis > areaOther )
  {
  // thisTemplate is filled before otherTemplate
  winningOverlaps[thisTemplate.ID].insert( otherTemplate.ID );
  }
  else
  {
  // thisTemplate is filled AFTER otherTemplate
  winningOverlaps[otherTemplate.ID].insert( thisTemplate.ID );
  }
  }
  else if( thisZonePolyFill.Area() > 0.0 )
  {
  // The other template is not filled, this one wins
  winningOverlaps[thisTemplate.ID].insert( otherTemplate.ID );
  }
  else if( otherZonePolyFill.Area() > 0.0 )
  {
  // This template is not filled, the other one wins
  winningOverlaps[otherTemplate.ID].insert( thisTemplate.ID );
  }
  else
  {
  // Neither of the templates is poured - use zone outlines instead (bigger outlines
  // get a lower priority)
  if( intersectionAreaOfZoneOutlines( thisZone, otherZone ) != 0 )
  {
  if( thisZone->Outline()->Area() > otherZone->Outline()->Area() )
  winningOverlaps[otherTemplate.ID].insert( thisTemplate.ID );
  else
  winningOverlaps[thisTemplate.ID].insert( otherTemplate.ID );
  }
  }
 
  checkPoint();
  }
  }
 
  // Build a set of unique TEMPLATE_IDs of all the zones that intersect with another one
  std::set<TEMPLATE_ID> intersectingIDs;
 
  for( const std::pair<TEMPLATE_ID, std::set<TEMPLATE_ID>>& idPair : winningOverlaps )
  {
  intersectingIDs.insert( idPair.first );
  intersectingIDs.insert( idPair.second.begin(), idPair.second.end() );
  }
 
  // Now store them in a vector
  std::vector<TEMPLATE_ID> sortedIDs;
 
  for( const TEMPLATE_ID& id : intersectingIDs )
  {
  sortedIDs.push_back( id );
  }
 
  // sort by priority
  std::sort( sortedIDs.begin(), sortedIDs.end(), isLowerPriority );
 
  TEMPLATE_ID prevID = wxEmptyString;
 
  for( const TEMPLATE_ID& id : sortedIDs )
   {
  if( prevID.IsEmpty() )
  {
  prevID = id;
  continue;
  }
 
  wxASSERT( !isLowerPriority( id, prevID ) );
 
  int newPriority = m_zonesMap.at( prevID )->GetPriority();
 
  // Only increase priority of the current zone
  if( isLowerPriority( prevID, id ) )
  newPriority++;
 
  m_zonesMap.at( id )->SetPriority( newPriority );
  prevID = id;
  }
 
  // Verify
  for( const std::pair<TEMPLATE_ID, std::set<TEMPLATE_ID>>& idPair : winningOverlaps )
  {
  const TEMPLATE_ID& winningID = idPair.first;
 
  for( const TEMPLATE_ID& losingID : idPair.second )
  {
  if( m_zonesMap.at( losingID )->GetPriority()
  > m_zonesMap.at( winningID )->GetPriority() )
  {
  return false;
  }
  }
  }
 
  return true;
 }

References SHAPE_POLY_SET::Area(), CADSTAR_PCB_ARCHIVE_PARSER::Assignments, SHAPE_POLY_SET::BooleanSubtract(), CADSTAR_ARCHIVE_PARSER::checkPoint(), CADSTAR_PCB_ARCHIVE_PARSER::ASSIGNMENTS::Codedefs, LSET::Contains(), BOARD::GetDesignSettings(), ZONE::GetFilledPolysList(), getKiCadLength(), ZONE::GetLayerSet(), ZONE::GetLocalClearance(), CADSTAR_PCB_ARCHIVE_PARSER::TEMPLATE::ID, SHAPE_POLY_SET::Inflate(), CADSTAR_PCB_ARCHIVE_PARSER::Layout, m_board, BOARD_DESIGN_SETTINGS::m_MinClearance, m_zonesMap, ZONE::Outline(), SHAPE_POLY_SET::PM_FAST, CADSTAR_PCB_ARCHIVE_PARSER::CODEDEFS_PCB::SpacingCodes, and CADSTAR_PCB_ARCHIVE_PARSER::LAYOUT::Templates.

Referenced by Load().

◆ checkAndLogHatchCode()

void CADSTAR_PCB_ARCHIVE_LOADER::checkAndLogHatchCode ( const HATCHCODE_ID & aCadstarHatchcodeID )

private

Definition at line 3529 of file cadstar_pcb_archive_loader.cpp.

 {
  if( m_hatchcodesTested.find( aCadstarHatchcodeID ) != m_hatchcodesTested.end() )
  {
  return; //already checked
  }
  else
  {
  HATCHCODE hcode = getHatchCode( aCadstarHatchcodeID );
 
  if( hcode.Hatches.size() != 2 )
  {
  wxLogWarning( wxString::Format(
  _( "The CADSTAR Hatching code '%s' has %d hatches defined. "
  "KiCad only supports 2 hatches (crosshatching) 90 degrees apart. "
  "The imported hatching is crosshatched." ),
  hcode.Name, (int) hcode.Hatches.size() ) );
  }
  else
  {
  if( hcode.Hatches.at( 0 ).LineWidth != hcode.Hatches.at( 1 ).LineWidth )
  {
  wxLogWarning( wxString::Format(
  _( "The CADSTAR Hatching code '%s' has different line widths for each "
  "hatch. KiCad only supports one width for the hatching. The imported "
  "hatching uses the width defined in the first hatch definition, i.e. "
  "%.2f mm." ),
  hcode.Name,
  (double) ( (double) getKiCadLength( hcode.Hatches.at( 0 ).LineWidth ) )
  / 1E6 ) );
  }
 
  if( hcode.Hatches.at( 0 ).Step != hcode.Hatches.at( 1 ).Step )
  {
  wxLogWarning( wxString::Format(
  _( "The CADSTAR Hatching code '%s' has different step sizes for each "
  "hatch. KiCad only supports one step size for the hatching. The imported "
  "hatching uses the step size defined in the first hatching definition, "
  "i.e. %.2f mm." ),
  hcode.Name,
  (double) ( (double) getKiCadLength( hcode.Hatches.at( 0 ).Step ) )
  / 1E6 ) );
  }
 
  if( abs( hcode.Hatches.at( 0 ).OrientAngle - hcode.Hatches.at( 1 ).OrientAngle )
  != 90000 )
  {
  wxLogWarning( wxString::Format(
  _( "The hatches in CADSTAR Hatching code '%s' have an angle "
  "difference of %.1f degrees. KiCad only supports hatching 90 "
  "degrees apart. The imported hatching has two hatches 90 "
  "degrees apart, oriented %.1f degrees from horizontal." ),
  hcode.Name,
  getAngleDegrees( abs( hcode.Hatches.at( 0 ).OrientAngle
  - hcode.Hatches.at( 1 ).OrientAngle ) ),
  getAngleDegrees( hcode.Hatches.at( 0 ).OrientAngle ) ) );
  }
  }
 
  m_hatchcodesTested.insert( aCadstarHatchcodeID );
  }
 }

References _, E6, Format(), getAngleDegrees(), getHatchCode(), getKiCadLength(), CADSTAR_ARCHIVE_PARSER::HATCHCODE::Hatches, m_hatchcodesTested, and CADSTAR_ARCHIVE_PARSER::HATCHCODE::Name.

Referenced by getHatchCodeAngleDegrees(), getKiCadHatchCodeGap(), and getKiCadHatchCodeThickness().

◆ CheckNoChildNodes()

void CADSTAR_ARCHIVE_PARSER::CheckNoChildNodes ( XNODE * aNode )

staticinherited

Parameters

aNode

Exceptions

IO_ERROR if a child node was found

Definition at line 2465 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_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_ARCHIVE_PARSER::ATTRNAME::COLUMNORDER::Parse(), CADSTAR_ARCHIVE_PARSER::ATTRNAME::COLUMNWIDTH::Parse(), CADSTAR_ARCHIVE_PARSER::REUSEBLOCKREF::Parse(), CADSTAR_PCB_ARCHIVE_PARSER::AREA::Parse(), CADSTAR_PCB_ARCHIVE_PARSER::NET_PCB::PIN::Parse(), CADSTAR_ARCHIVE_PARSER::PART::DEFINITION::GATE::Parse(), CADSTAR_ARCHIVE_PARSER::PART::DEFINITION::PIN_EQUIVALENCE::Parse(), and CADSTAR_ARCHIVE_PARSER::PART::DEFINITION::SWAP_GATE::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 2472 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 2645 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 calculateZonePriorities(), CADSTAR_SCH_ARCHIVE_LOADER::Load(), loadCoppers(), CADSTAR_SCH_ARCHIVE_LOADER::loadPartsLibrary(), CADSTAR_SCH_ARCHIVE_PARSER::Parse(), and CADSTAR_PCB_ARCHIVE_PARSER::Parse().

◆ createUniqueGroupID()

CADSTAR_PCB_ARCHIVE_LOADER::GROUP_ID CADSTAR_PCB_ARCHIVE_LOADER::createUniqueGroupID ( const wxString & aName )

private

Adds a new PCB_GROUP* to m_groupMap.

Parameters

aName Name to give the group. If name already exists, append "_1", "_2", etc. to the end to ensure it is unique

Returns

Definition at line 4126 of file cadstar_pcb_archive_loader.cpp.

 {
  wxString groupName = aName;
  int num = 0;
 
  while( m_groupMap.find( groupName ) != m_groupMap.end() )
  {
  groupName = aName + wxT( "_" ) + wxString::Format( wxT( "%i" ), ++num );
  }
 
  PCB_GROUP* docSymGroup = new PCB_GROUP( m_board );
  m_board->Add( docSymGroup );
  docSymGroup->SetName( groupName );
  GROUP_ID groupID( groupName );
  m_groupMap.insert( { groupID, docSymGroup } );
 
  return groupID;
 }

References BOARD::Add(), Format(), m_board, m_groupMap, and PCB_GROUP::SetName().

Referenced by loadBoards(), and loadDocumentationSymbols().

◆ drawCadstarCutoutsAsShapes()

void CADSTAR_PCB_ARCHIVE_LOADER::drawCadstarCutoutsAsShapes	(	const std::vector< CUTOUT > &	aCutouts,
		const PCB_LAYER_ID &	aKiCadLayer,
		const int &	aLineThickness,
		BOARD_ITEM_CONTAINER *	aContainer,
		const GROUP_ID &	aCadstarGroupID = `wxEmptyString`,
		const wxPoint &	aMoveVector = `{ 0, 0 }`,
		const double &	aRotationAngle = `0.0`,
		const double &	aScalingFactor = `1.0`,
		const wxPoint &	aTransformCentre = `{ 0, 0 }`,
		const bool &	aMirrorInvert = `false`
	)

private

Uses PCB_SHAPEs to draw the cutouts on m_board object.

Parameters

aVertices
aKiCadLayer	KiCad layer to draw on
aLineThickness	Thickness of line to draw with
aContainer	to draw on (e.g. m_board)
aCadstarGroupID	to add the shapes to
aMoveVector	move shapes by this amount (in KiCad coordinates)
aRotationAngle	rotate shapes by this amount (in tenth degrees)
aScalingFactor	scale shapes by this amount
aTransformCentre	around which all transforms are applied (KiCad coordinates)
aMirrorInvert	if true, mirrors the shapes

Definition at line 2727 of file cadstar_pcb_archive_loader.cpp.

 {
  for( CUTOUT cutout : aCutouts )
  {
  drawCadstarVerticesAsShapes( cutout.Vertices, aKiCadLayer, aLineThickness, aContainer,
  aCadstarGroupID, aMoveVector, aRotationAngle, aScalingFactor,
  aTransformCentre, aMirrorInvert );
  }
 }

References drawCadstarVerticesAsShapes().

Referenced by drawCadstarShape().

◆ drawCadstarShape()

void CADSTAR_PCB_ARCHIVE_LOADER::drawCadstarShape	(	const SHAPE &	aCadstarShape,
		const PCB_LAYER_ID &	aKiCadLayer,
		const int &	aLineThickness,
		const wxString &	aShapeName,
		BOARD_ITEM_CONTAINER *	aContainer,
		const GROUP_ID &	aCadstarGroupID = `wxEmptyString`,
		const wxPoint &	aMoveVector = `{ 0, 0 }`,
		const double &	aRotationAngle = `0.0`,
		const double &	aScalingFactor = `1.0`,
		const wxPoint &	aTransformCentre = `{ 0, 0 }`,
		const bool &	aMirrorInvert = `false`
	)

private

Parameters

aCadstarShape
aCadstarLayerID	KiCad layer to draw on
aLineThickness	Thickness of line to draw with
aShapeName	for reporting warnings/errors to the user
aContainer	to draw on (e.g. m_board)
aCadstarGroupID	to add the shape to
aMoveVector	move shapes by this amount (in KiCad coordinates)
aRotationAngle	rotate shapes by this amount (in tenth degrees)
aScalingFactor	scale shapes by this amount
aTransformCentre	around which all transforms are applied (KiCad coordinates)
aMirrorInvert	if true, mirrors the shapes

TODO update this when Polygons in KiCad can be defined with no fill

TODO update this when Polygons in KiCad can be defined with hatch fill

Definition at line 2665 of file cadstar_pcb_archive_loader.cpp.

 {
  switch( aCadstarShape.Type )
  {
  case SHAPE_TYPE::OPENSHAPE:
  case SHAPE_TYPE::OUTLINE:
  drawCadstarVerticesAsShapes( aCadstarShape.Vertices, aKiCadLayer, aLineThickness,
  aContainer, aCadstarGroupID, aMoveVector, aRotationAngle,
  aScalingFactor, aTransformCentre, aMirrorInvert );
  drawCadstarCutoutsAsShapes( aCadstarShape.Cutouts, aKiCadLayer, aLineThickness,
  aContainer, aCadstarGroupID, aMoveVector, aRotationAngle,
  aScalingFactor, aTransformCentre, aMirrorInvert );
  break;
 
  case SHAPE_TYPE::HATCHED:
  wxLogWarning( wxString::Format(
  _( "The shape for '%s' is Hatch filled in CADSTAR, which has no KiCad equivalent. "
  "Using solid fill instead." ),
  aShapeName ) );
 
  case SHAPE_TYPE::SOLID:
  {
  PCB_SHAPE* shape;
 
  if( isFootprint( aContainer ) )
  shape = new FP_SHAPE( (FOOTPRINT*) aContainer, SHAPE_T::POLY );
  else
  shape = new PCB_SHAPE( aContainer, SHAPE_T::POLY );
 
  shape->SetFilled( true );
 
  SHAPE_POLY_SET shapePolys = getPolySetFromCadstarShape(
  aCadstarShape, -1, aContainer, aMoveVector, aRotationAngle, aScalingFactor,
  aTransformCentre, aMirrorInvert );
 
  shapePolys.Fracture( SHAPE_POLY_SET::POLYGON_MODE::PM_STRICTLY_SIMPLE );
 
  shape->SetPolyShape( shapePolys );
  shape->SetWidth( aLineThickness );
  shape->SetLayer( aKiCadLayer );
  aContainer->Add( shape, ADD_MODE::APPEND );
 
  if( !aCadstarGroupID.IsEmpty() )
  addToGroup( aCadstarGroupID, shape );
  }
  break;
  }
 }

References _, FOOTPRINT::Add(), addToGroup(), APPEND, CADSTAR_ARCHIVE_PARSER::SHAPE::Cutouts, drawCadstarCutoutsAsShapes(), drawCadstarVerticesAsShapes(), Format(), SHAPE_POLY_SET::Fracture(), getPolySetFromCadstarShape(), CADSTAR_ARCHIVE_PARSER::HATCHED, isFootprint(), CADSTAR_ARCHIVE_PARSER::OPENSHAPE, CADSTAR_ARCHIVE_PARSER::OUTLINE, POLY, EDA_SHAPE::SetFilled(), BOARD_ITEM::SetLayer(), EDA_SHAPE::SetPolyShape(), EDA_SHAPE::SetWidth(), CADSTAR_ARCHIVE_PARSER::SOLID, CADSTAR_ARCHIVE_PARSER::SHAPE::Type, and CADSTAR_ARCHIVE_PARSER::SHAPE::Vertices.

Referenced by loadBoards(), loadDocumentationSymbols(), loadFigures(), loadLibraryCoppers(), and loadLibraryFigures().

◆ drawCadstarText()

void CADSTAR_PCB_ARCHIVE_LOADER::drawCadstarText	(	const TEXT &	aCadstarText,
		BOARD_ITEM_CONTAINER *	aContainer,
		const GROUP_ID &	aCadstarGroupID = `wxEmptyString`,
		const LAYER_ID &	aCadstarLayerOverride = `wxEmptyString`,
		const wxPoint &	aMoveVector = `{ 0, 0 }`,
		const double &	aRotationAngle = `0.0`,
		const double &	aScalingFactor = `1.0`,
		const wxPoint &	aTransformCentre = `{ 0, 0 }`,
		const bool &	aMirrorInvert = `false`
	)

private

Parameters

aCadstarText
aContainer	to draw on (e.g. m_board)
aCadstarGroupID	to add the text to
aCadstarLayerOverride	if not empty, overrides the LayerID in aCadstarText
aMoveVector	move text by this amount (in KiCad coordinates)
aRotationAngle	rotate text by this amount (in tenth degrees)
aScalingFactor	scale text by this amount
aTransformCentre	around which all transforms are applied (KiCad coordinates)
aMirrorInvert	if true, it inverts the Mirror status of aCadstarText

Definition at line 2517 of file cadstar_pcb_archive_loader.cpp.

 {
  PCB_TEXT* txt = new PCB_TEXT( aContainer );
  aContainer->Add( txt );
  txt->SetText( aCadstarText.Text );
 
  wxPoint rotatedTextPos = getKiCadPoint( aCadstarText.Position );
  RotatePoint( &rotatedTextPos, aTransformCentre, aRotationAngle );
  rotatedTextPos.x =
  KiROUND( (double) ( rotatedTextPos.x - aTransformCentre.x ) * aScalingFactor );
  rotatedTextPos.y =
  KiROUND( (double) ( rotatedTextPos.y - aTransformCentre.y ) * aScalingFactor );
  rotatedTextPos += aTransformCentre;
  txt->SetTextPos( rotatedTextPos );
  txt->SetPosition( rotatedTextPos );
 
  txt->SetTextAngle( getAngleTenthDegree( aCadstarText.OrientAngle ) + aRotationAngle );
 
  txt->SetMirrored( aCadstarText.Mirror );
 
  TEXTCODE tc = getTextCode( aCadstarText.TextCodeID );
 
  txt->SetTextThickness( getKiCadLength( tc.LineWidth ) );
 
  wxSize unscaledTextSize;
  unscaledTextSize.x = getKiCadLength( tc.Width );
 
  // The width is zero for all non-cadstar fonts. Using a width equal to the height seems
  // to work well for most fonts.
  if( unscaledTextSize.x == 0 )
  unscaledTextSize.x = getKiCadLength( tc.Height );
 
  unscaledTextSize.y = KiROUND( TXT_HEIGHT_RATIO * (double) getKiCadLength( tc.Height ) );
  txt->SetTextSize( unscaledTextSize );
 
  switch( aCadstarText.Alignment )
  {
  case ALIGNMENT::NO_ALIGNMENT: // Default for Single line text is Bottom Left
  case ALIGNMENT::BOTTOMLEFT:
  txt->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
  break;
 
  case ALIGNMENT::BOTTOMCENTER:
  txt->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
  break;
 
  case ALIGNMENT::BOTTOMRIGHT:
  txt->SetVertJustify( GR_TEXT_VJUSTIFY_BOTTOM );
  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
  break;
 
  case ALIGNMENT::CENTERLEFT:
  txt->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER );
  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
  break;
 
  case ALIGNMENT::CENTERCENTER:
  txt->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER );
  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
  break;
 
  case ALIGNMENT::CENTERRIGHT:
  txt->SetVertJustify( GR_TEXT_VJUSTIFY_CENTER );
  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
  break;
 
  case ALIGNMENT::TOPLEFT:
  txt->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_LEFT );
  break;
 
  case ALIGNMENT::TOPCENTER:
  txt->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_CENTER );
  break;
 
  case ALIGNMENT::TOPRIGHT:
  txt->SetVertJustify( GR_TEXT_VJUSTIFY_TOP );
  txt->SetHorizJustify( GR_TEXT_HJUSTIFY_RIGHT );
  break;
 
  default:
  wxFAIL_MSG( wxT( "Unknown Alignment - needs review!" ) );
  }
 
  if( aMirrorInvert )
  {
  txt->Flip( aTransformCentre, true );
  }
 
  //scale it after flipping:
  if( aScalingFactor != 1.0 )
  {
  wxSize scaledTextSize;
  scaledTextSize.x = KiROUND( (double) unscaledTextSize.x * aScalingFactor );
  scaledTextSize.y = KiROUND( (double) unscaledTextSize.y * aScalingFactor );
  txt->SetTextSize( scaledTextSize );
  txt->SetTextThickness(
  KiROUND( (double) getKiCadLength( tc.LineWidth ) * aScalingFactor ) );
  }
 
  txt->Move( aMoveVector );
 
  if( aCadstarText.Alignment == ALIGNMENT::NO_ALIGNMENT )
  FixTextPositionNoAlignment( txt );
 
  LAYER_ID layersToDrawOn = aCadstarLayerOverride;
 
  if( layersToDrawOn.IsEmpty() )
  layersToDrawOn = aCadstarText.LayerID;
 
  if( isLayerSet( layersToDrawOn ) )
  {
  //Make a copy on each layer
 
  LSEQ layers = getKiCadLayerSet( layersToDrawOn ).Seq();
  PCB_TEXT* newtxt;
 
  for( PCB_LAYER_ID layer : layers )
  {
  txt->SetLayer( layer );
  newtxt = static_cast<PCB_TEXT*>( txt->Duplicate() );
  m_board->Add( newtxt, ADD_MODE::APPEND );
 
  if( !aCadstarGroupID.IsEmpty() )
  addToGroup( aCadstarGroupID, newtxt );
  }
 
  m_board->Remove( txt );
  delete txt;
  }
  else
  {
  txt->SetLayer( getKiCadLayer( layersToDrawOn ) );
 
  if( !aCadstarGroupID.IsEmpty() )
  addToGroup( aCadstarGroupID, txt );
  }
  //TODO Handle different font types when KiCad can support it.
 }

Referenced by loadDocumentationSymbols(), and loadTexts().

◆ drawCadstarVerticesAsShapes()

void CADSTAR_PCB_ARCHIVE_LOADER::drawCadstarVerticesAsShapes	(	const std::vector< VERTEX > &	aCadstarVertices,
		const PCB_LAYER_ID &	aKiCadLayer,
		const int &	aLineThickness,
		BOARD_ITEM_CONTAINER *	aContainer,
		const GROUP_ID &	aCadstarGroupID = `wxEmptyString`,
		const wxPoint &	aMoveVector = `{ 0, 0 }`,
		const double &	aRotationAngle = `0.0`,
		const double &	aScalingFactor = `1.0`,
		const wxPoint &	aTransformCentre = `{ 0, 0 }`,
		const bool &	aMirrorInvert = `false`
	)

private

Uses PCB_SHAPE to draw the vertices on m_board object.

Parameters

aCadstarVertices
aKiCadLayer	KiCad layer to draw on
aLineThickness	Thickness of line to draw with
aContainer	to draw on (e.g. m_board)
aCadstarGroupID	to add the shape to
aMoveVector	move shape by this amount (in KiCad coordinates)
aRotationAngle	rotate shape by this amount (in tenth degrees)
aScalingFactor	scale shape by this amount
aTransformCentre	around which all transforms are applied (KiCad coordinates)
aMirrorInvert	if true, mirrors the shape
aCadstarGroupID	to add the shape to

Definition at line 2747 of file cadstar_pcb_archive_loader.cpp.

 {
  std::vector<PCB_SHAPE*> shapes = getShapesFromVertices( aCadstarVertices, aContainer,
  aCadstarGroupID, aMoveVector,
  aRotationAngle, aScalingFactor,
  aTransformCentre, aMirrorInvert );
 
  for( PCB_SHAPE* shape : shapes )
  {
  shape->SetWidth( aLineThickness );
  shape->SetLayer( aKiCadLayer );
  shape->SetParent( aContainer );
  aContainer->Add( shape, ADD_MODE::APPEND );
  }
 }

References BOARD_ITEM_CONTAINER::Add(), APPEND, and getShapesFromVertices().

Referenced by drawCadstarCutoutsAsShapes(), and drawCadstarShape().

◆ 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 2617 of file cadstar_archive_parser.cpp.

 {
  if( !aKiCadTextItem->GetText().IsEmpty() )
  {
  int txtAngleDecideg = aKiCadTextItem->GetTextAngleDegrees() * 10.0;
  wxPoint positionOffset( 0, aKiCadTextItem->GetInterline() );
  RotatePoint( &positionOffset, txtAngleDecideg );
 
  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( wxT( "\n" ), wxT( "\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::GetTextAngleDegrees(), LIB_FIELD_T, LIB_TEXT_T, EDA_TEXT::Offset(), RotatePoint(), text, and EDA_ITEM::Type().

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

◆ generateLibName()

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

inlinestaticinherited

Definition at line 1402 of file cadstar_archive_parser.h.

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

Referenced by CADSTAR_SCH_ARCHIVE_LOADER::loadSymDefIntoLibrary().

◆ getAngleDegrees()

double CADSTAR_PCB_ARCHIVE_LOADER::getAngleDegrees ( const long long & aCadstarAngle )

inlineprivate

Parameters

aCadstarAngle

Returns

Definition at line 467 of file cadstar_pcb_archive_loader.h.

  {
  return getAngleTenthDegree( aCadstarAngle ) / 10.0;
  }

References getAngleTenthDegree().

Referenced by checkAndLogHatchCode(), getHatchCodeAngleDegrees(), and loadDimensions().

◆ getAngleTenthDegree()

double CADSTAR_PCB_ARCHIVE_LOADER::getAngleTenthDegree ( const long long & aCadstarAngle )

inlineprivate

Parameters

aCadstarAngle

Returns

Definition at line 447 of file cadstar_pcb_archive_loader.h.

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

References CADSTAR_ARCHIVE_PARSER::HEADER::Format, CADSTAR_PCB_ARCHIVE_PARSER::Header, and CADSTAR_ARCHIVE_PARSER::FORMAT::Version.

Referenced by addAttribute(), drawCadstarText(), getAngleDegrees(), getKiCadPad(), loadComponents(), and loadDocumentationSymbols().

◆ getAttributeName()

wxString CADSTAR_PCB_ARCHIVE_LOADER::getAttributeName ( const ATTRIBUTE_ID & aCadstarAttributeID )

private

Definition at line 3420 of file cadstar_pcb_archive_loader.cpp.

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

References CADSTAR_PCB_ARCHIVE_PARSER::Assignments, CADSTAR_ARCHIVE_PARSER::CODEDEFS::AttributeNames, and CADSTAR_PCB_ARCHIVE_PARSER::ASSIGNMENTS::Codedefs.

Referenced by addAttribute().

◆ getAttributeValue()

wxString CADSTAR_PCB_ARCHIVE_LOADER::getAttributeValue	(	const ATTRIBUTE_ID &	aCadstarAttributeID,
		const std::map< ATTRIBUTE_ID, ATTRIBUTE_VALUE > &	aCadstarAttributeMap
	)

private

Definition at line 3430 of file cadstar_pcb_archive_loader.cpp.

 {
  wxCHECK( aCadstarAttributeMap.find( aCadstarAttributeID ) != aCadstarAttributeMap.end(),
  wxEmptyString );
 
  return aCadstarAttributeMap.at( aCadstarAttributeID ).Value;
 }

Referenced by loadComponentAttributes().

◆ getCopperCode()

CADSTAR_PCB_ARCHIVE_LOADER::COPPERCODE CADSTAR_PCB_ARCHIVE_LOADER::getCopperCode ( const COPPERCODE_ID & aCadstaCopperCodeID )

private

Definition at line 3365 of file cadstar_pcb_archive_loader.cpp.

 {
  wxCHECK( Assignments.Codedefs.CopperCodes.find( aCadstaCopperCodeID )
  != Assignments.Codedefs.CopperCodes.end(),
  COPPERCODE() );
 
  return Assignments.Codedefs.CopperCodes.at( aCadstaCopperCodeID );
 }

References CADSTAR_PCB_ARCHIVE_PARSER::Assignments, CADSTAR_PCB_ARCHIVE_PARSER::ASSIGNMENTS::Codedefs, and CADSTAR_PCB_ARCHIVE_PARSER::CODEDEFS_PCB::CopperCodes.

Referenced by loadCoppers(), loadLibraryCoppers(), and loadTemplates().

◆ getFootprintFromCadstarID()

FOOTPRINT * CADSTAR_PCB_ARCHIVE_LOADER::getFootprintFromCadstarID ( const COMPONENT_ID & aCadstarComponentID )

private

Definition at line 3872 of file cadstar_pcb_archive_loader.cpp.

 {
  if( m_componentMap.find( aCadstarComponentID ) == m_componentMap.end() )
  return nullptr;
  else
  return m_componentMap.at( aCadstarComponentID );
 }

References m_componentMap.

Referenced by getKiCadNet(), and loadNets().

◆ getHatchCode()

CADSTAR_PCB_ARCHIVE_LOADER::HATCHCODE CADSTAR_PCB_ARCHIVE_LOADER::getHatchCode ( const HATCHCODE_ID & aCadstarHatchcodeID )

private

Definition at line 3472 of file cadstar_pcb_archive_loader.cpp.

 {
  wxCHECK( Assignments.Codedefs.HatchCodes.find( aCadstarHatchcodeID )
  != Assignments.Codedefs.HatchCodes.end(),
  HATCHCODE() );
 
  return Assignments.Codedefs.HatchCodes.at( aCadstarHatchcodeID );
 }

References CADSTAR_PCB_ARCHIVE_PARSER::Assignments, CADSTAR_PCB_ARCHIVE_PARSER::ASSIGNMENTS::Codedefs, and CADSTAR_ARCHIVE_PARSER::CODEDEFS::HatchCodes.

Referenced by checkAndLogHatchCode(), getHatchCodeAngleDegrees(), getKiCadHatchCodeGap(), and getKiCadHatchCodeThickness().

◆ getHatchCodeAngleDegrees()

double CADSTAR_PCB_ARCHIVE_LOADER::getHatchCodeAngleDegrees ( const HATCHCODE_ID & aCadstarHatchcodeID )

private

Definition at line 3483 of file cadstar_pcb_archive_loader.cpp.

 {
  checkAndLogHatchCode( aCadstarHatchcodeID );
  HATCHCODE hcode = getHatchCode( aCadstarHatchcodeID );
 
  if( hcode.Hatches.size() < 1 )
  return m_board->GetDesignSettings().GetDefaultZoneSettings().m_HatchOrientation;
  else
  return getAngleDegrees( hcode.Hatches.at( 0 ).OrientAngle );
 }

References checkAndLogHatchCode(), getAngleDegrees(), BOARD_DESIGN_SETTINGS::GetDefaultZoneSettings(), BOARD::GetDesignSettings(), getHatchCode(), CADSTAR_ARCHIVE_PARSER::HATCHCODE::Hatches, m_board, and ZONE_SETTINGS::m_HatchOrientation.

Referenced by loadCoppers(), and loadTemplates().

◆ getKiCadCopperLayerID()

PCB_LAYER_ID CADSTAR_PCB_ARCHIVE_LOADER::getKiCadCopperLayerID	(	unsigned int	aLayerNum,
		bool	aDetectMaxLayer = `true`
	)

private

Parameters

aLayerNum	Physical / logical layer number (starts at 1)
aDetectMaxLayer	If true, returns B.Cu if the requested layer is the maximum layer

Returns: PCB_LAYER_ID

Definition at line 4007 of file cadstar_pcb_archive_loader.cpp.

 {
  if( aDetectMaxLayer && aLayerNum == m_numCopperLayers )
  return PCB_LAYER_ID::B_Cu;
 
  switch( aLayerNum )
  {
  case 1: return PCB_LAYER_ID::F_Cu;
  case 2: return PCB_LAYER_ID::In1_Cu;
  case 3: return PCB_LAYER_ID::In2_Cu;
  case 4: return PCB_LAYER_ID::In3_Cu;
  case 5: return PCB_LAYER_ID::In4_Cu;
  case 6: return PCB_LAYER_ID::In5_Cu;
  case 7: return PCB_LAYER_ID::In6_Cu;
  case 8: return PCB_LAYER_ID::In7_Cu;
  case 9: return PCB_LAYER_ID::In8_Cu;
  case 10: return PCB_LAYER_ID::In9_Cu;
  case 11: return PCB_LAYER_ID::In10_Cu;
  case 12: return PCB_LAYER_ID::In11_Cu;
  case 13: return PCB_LAYER_ID::In12_Cu;
  case 14: return PCB_LAYER_ID::In13_Cu;
  case 15: return PCB_LAYER_ID::In14_Cu;
  case 16: return PCB_LAYER_ID::In15_Cu;
  case 17: return PCB_LAYER_ID::In16_Cu;
  case 18: return PCB_LAYER_ID::In17_Cu;
  case 19: return PCB_LAYER_ID::In18_Cu;
  case 20: return PCB_LAYER_ID::In19_Cu;
  case 21: return PCB_LAYER_ID::In20_Cu;
  case 22: return PCB_LAYER_ID::In21_Cu;
  case 23: return PCB_LAYER_ID::In22_Cu;
  case 24: return PCB_LAYER_ID::In23_Cu;
  case 25: return PCB_LAYER_ID::In24_Cu;
  case 26: return PCB_LAYER_ID::In25_Cu;
  case 27: return PCB_LAYER_ID::In26_Cu;
  case 28: return PCB_LAYER_ID::In27_Cu;
  case 29: return PCB_LAYER_ID::In28_Cu;
  case 30: return PCB_LAYER_ID::In29_Cu;
  case 31: return PCB_LAYER_ID::In30_Cu;
  case 32: return PCB_LAYER_ID::B_Cu;
  }
 
  return PCB_LAYER_ID::UNDEFINED_LAYER;
 }

References B_Cu, F_Cu, In10_Cu, In11_Cu, In12_Cu, In13_Cu, In14_Cu, In15_Cu, In16_Cu, In17_Cu, In18_Cu, In19_Cu, In1_Cu, In20_Cu, In21_Cu, In22_Cu, In23_Cu, In24_Cu, In25_Cu, In26_Cu, In27_Cu, In28_Cu, In29_Cu, In2_Cu, In30_Cu, In3_Cu, In4_Cu, In5_Cu, In6_Cu, In7_Cu, In8_Cu, In9_Cu, m_numCopperLayers, and UNDEFINED_LAYER.

Referenced by loadNetVia().

◆ getKiCadGroup()

PCB_GROUP * CADSTAR_PCB_ARCHIVE_LOADER::getKiCadGroup ( const GROUP_ID & aCadstarGroupID )

private

Definition at line 3521 of file cadstar_pcb_archive_loader.cpp.

 {
  wxCHECK( m_groupMap.find( aCadstarGroupID ) != m_groupMap.end(), nullptr );
 
  return m_groupMap.at( aCadstarGroupID );
 }

References m_groupMap.

Referenced by loadBoards().

◆ getKiCadHatchCodeGap()

int CADSTAR_PCB_ARCHIVE_LOADER::getKiCadHatchCodeGap ( const HATCHCODE_ID & aCadstarHatchcodeID )

private

Definition at line 3509 of file cadstar_pcb_archive_loader.cpp.

 {
  checkAndLogHatchCode( aCadstarHatchcodeID );
  HATCHCODE hcode = getHatchCode( aCadstarHatchcodeID );
 
  if( hcode.Hatches.size() < 1 )
  return m_board->GetDesignSettings().GetDefaultZoneSettings().m_HatchGap;
  else
  return getKiCadLength( hcode.Hatches.at( 0 ).Step );
 }

References checkAndLogHatchCode(), BOARD_DESIGN_SETTINGS::GetDefaultZoneSettings(), BOARD::GetDesignSettings(), getHatchCode(), getKiCadLength(), CADSTAR_ARCHIVE_PARSER::HATCHCODE::Hatches, m_board, and ZONE_SETTINGS::m_HatchGap.

Referenced by loadCoppers(), and loadTemplates().

◆ getKiCadHatchCodeThickness()

int CADSTAR_PCB_ARCHIVE_LOADER::getKiCadHatchCodeThickness ( const HATCHCODE_ID & aCadstarHatchcodeID )

private

Definition at line 3496 of file cadstar_pcb_archive_loader.cpp.

 {
  checkAndLogHatchCode( aCadstarHatchcodeID );
  HATCHCODE hcode = getHatchCode( aCadstarHatchcodeID );
 
  if( hcode.Hatches.size() < 1 )
  return m_board->GetDesignSettings().GetDefaultZoneSettings().m_HatchThickness;
  else
  return getKiCadLength( hcode.Hatches.at( 0 ).LineWidth );
 }

References checkAndLogHatchCode(), BOARD_DESIGN_SETTINGS::GetDefaultZoneSettings(), BOARD::GetDesignSettings(), getHatchCode(), getKiCadLength(), CADSTAR_ARCHIVE_PARSER::HATCHCODE::Hatches, m_board, and ZONE_SETTINGS::m_HatchThickness.

Referenced by loadCoppers(), and loadTemplates().

◆ getKiCadLayer()

PCB_LAYER_ID CADSTAR_PCB_ARCHIVE_LOADER::getKiCadLayer ( const LAYER_ID & aCadstarLayerID )

private

Parameters

aCadstarLayerID

Returns: PCB_LAYER_ID

Definition at line 4076 of file cadstar_pcb_archive_loader.cpp.

 {
  if( getLayerType( aCadstarLayerID ) == LAYER_TYPE::NOLAYER )
  {
  //The "no layer" is common for CADSTAR documentation symbols
  //map it to undefined layer for later processing
  return PCB_LAYER_ID::UNDEFINED_LAYER;
  }
 
  wxCHECK( m_layermap.find( aCadstarLayerID ) != m_layermap.end(),
  PCB_LAYER_ID::UNDEFINED_LAYER );
 
  return m_layermap.at( aCadstarLayerID );
 }

References getLayerType(), m_layermap, CADSTAR_PCB_ARCHIVE_PARSER::NOLAYER, and UNDEFINED_LAYER.

Referenced by addAttribute(), applyDimensionSettings(), drawCadstarText(), getKiCadLayerSet(), getKiCadPad(), loadAreas(), loadCoppers(), loadFigures(), loadLibraryAreas(), loadLibraryCoppers(), loadLibraryFigures(), loadNetTracks(), and loadTemplates().

◆ getKiCadLayerSet()

LSET CADSTAR_PCB_ARCHIVE_LOADER::getKiCadLayerSet ( const LAYER_ID & aCadstarLayerID )

private

Parameters

aCadstarLayerID

Returns: LSET

Definition at line 4092 of file cadstar_pcb_archive_loader.cpp.

 {
  LAYER_TYPE layerType = getLayerType( aCadstarLayerID );
 
  switch( layerType )
  {
  case LAYER_TYPE::ALLDOC:
  return LSET( 4, PCB_LAYER_ID::Dwgs_User, PCB_LAYER_ID::Cmts_User, PCB_LAYER_ID::Eco1_User,
  PCB_LAYER_ID::Eco2_User );
 
  case LAYER_TYPE::ALLELEC:
  return LSET::AllCuMask( m_numCopperLayers );
 
  case LAYER_TYPE::ALLLAYER:
  return LSET::AllLayersMask()
  ^ ( LSET::AllCuMask( m_numCopperLayers ) ^ LSET::AllCuMask( MAX_CU_LAYERS ) )
  ^ ( LSET( PCB_LAYER_ID::Rescue ) );
 
  default:
  return LSET( getKiCadLayer( aCadstarLayerID ) );
  }
 }

References LSET::AllCuMask(), CADSTAR_PCB_ARCHIVE_PARSER::ALLDOC, CADSTAR_PCB_ARCHIVE_PARSER::ALLELEC, CADSTAR_PCB_ARCHIVE_PARSER::ALLLAYER, LSET::AllLayersMask(), Cmts_User, Dwgs_User, Eco1_User, Eco2_User, getKiCadLayer(), getLayerType(), m_numCopperLayers, MAX_CU_LAYERS, and Rescue.

Referenced by drawCadstarText(), loadAreas(), loadDocumentationSymbols(), and loadLibraryAreas().

◆ getKiCadLength()

int CADSTAR_PCB_ARCHIVE_LOADER::getKiCadLength ( long long aCadstarLength )

inlineprivate

Parameters

aCadstarLength

Returns

Definition at line 437 of file cadstar_pcb_archive_loader.h.

  {
  return aCadstarLength * KiCadUnitMultiplier;
  }

References CADSTAR_PCB_ARCHIVE_PARSER::KiCadUnitMultiplier.

Referenced by addAttribute(), applyDimensionSettings(), calculateZonePriorities(), checkAndLogHatchCode(), drawCadstarText(), getKiCadHatchCodeGap(), getKiCadHatchCodeThickness(), getKiCadNet(), getKiCadPad(), getLineThickness(), initStackupItem(), loadCoppers(), loadDesignRules(), loadDimensions(), loadLibraryCoppers(), loadNets(), loadNetTracks(), loadNetVia(), and loadTemplates().

◆ getKiCadNet()

NETINFO_ITEM * CADSTAR_PCB_ARCHIVE_LOADER::getKiCadNet ( const NET_ID & aCadstarNetID )

private

Searches m_netMap and returns the NETINFO_ITEM pointer if exists.

Otherwise creates a new one and adds it to m_board.

Parameters

aCadstarNetID

Returns

Definition at line 3899 of file cadstar_pcb_archive_loader.cpp.

 {
  if( aCadstarNetID.IsEmpty() )
  {
  return nullptr;
  }
  else if( m_netMap.find( aCadstarNetID ) != m_netMap.end() )
  {
  return m_netMap.at( aCadstarNetID );
  }
  else
  {
  wxCHECK( Layout.Nets.find( aCadstarNetID ) != Layout.Nets.end(), nullptr );
 
  NET_PCB csNet = Layout.Nets.at( aCadstarNetID );
  wxString newName = csNet.Name;
 
  if( csNet.Name.IsEmpty() )
  {
  if( csNet.Pins.size() > 0 )
  {
  // Create default KiCad net naming:
 
  NET_PCB::PIN firstPin = ( *csNet.Pins.begin() ).second;
  //we should have already loaded the component with loadComponents() :
  FOOTPRINT* m = getFootprintFromCadstarID( firstPin.ComponentID );
  newName = wxT( "Net-(" );
  newName << m->Reference().GetText();
  newName << wxT( "-Pad" ) << wxString::Format( wxT( "%ld" ), firstPin.PadID );
  newName << wxT( ")" );
  }
  else
  {
  wxFAIL_MSG( wxT( "A net with no pins associated?" ) );
  newName = wxT( "csNet-" );
  newName << wxString::Format( wxT( "%i" ), csNet.SignalNum );
  }
  }
 
  if( !m_doneNetClassWarning && !csNet.NetClassID.IsEmpty()
  && csNet.NetClassID != wxT( "NONE" ) )
  {
  wxLogMessage( _( "The CADSTAR design contains nets with a 'Net Class' assigned. KiCad "
  "does not have an equivalent to CADSTAR's Net Class so these elements "
  "were not imported. Note: KiCad's version of 'Net Class' is closer to "
  "CADSTAR's 'Net Route Code' (which has been imported for all nets)." ) );
  m_doneNetClassWarning = true;
  }
 
  if( !m_doneSpacingClassWarning && !csNet.SpacingClassID.IsEmpty()
  && csNet.SpacingClassID != wxT( "NONE" ) )
  {
  wxLogWarning( _( "The CADSTAR design contains nets with a 'Spacing Class' assigned. "
  "KiCad does not have an equivalent to CADSTAR's Spacing Class so "
  "these elements were not imported. Please review the design rules as "
  "copper pours will affected by this." ) );
  m_doneSpacingClassWarning = true;
  }
 
  NETINFO_ITEM* netInfo = new NETINFO_ITEM( m_board, newName, ++m_numNets );
  NETCLASSPTR netclass;
 
  std::tuple<ROUTECODE_ID, NETCLASS_ID, SPACING_CLASS_ID> key = { csNet.RouteCodeID,
  csNet.NetClassID,
  csNet.SpacingClassID };
 
  if( m_netClassMap.find( key ) != m_netClassMap.end() )
  {
  netclass = m_netClassMap.at( key );
  }
  else
  {
  wxString netClassName;
 
 
  ROUTECODE rc = getRouteCode( csNet.RouteCodeID );
  netClassName += wxT( "Route code: " ) + rc.Name;
 
  if( !csNet.NetClassID.IsEmpty() )
  {
  CADSTAR_NETCLASS nc = Assignments.Codedefs.NetClasses.at( csNet.NetClassID );
  netClassName += wxT( " | Net class: " ) + nc.Name;
  }
 
  if( !csNet.SpacingClassID.IsEmpty() )
  {
  SPCCLASSNAME sp = Assignments.Codedefs.SpacingClassNames.at( csNet.SpacingClassID );
  netClassName += wxT( " | Spacing class: " ) + sp.Name;
  }
 
  netclass.reset( new NETCLASS( *m_board->GetDesignSettings().GetDefault() ) );
  netclass->SetName( netClassName );
  m_board->GetDesignSettings().GetNetClasses().Add( netclass );
  netclass->SetTrackWidth( getKiCadLength( rc.OptimalWidth ) );
  m_netClassMap.insert( { key, netclass } );
  }
 
  netclass->Add( newName );
  netInfo->SetNetClass( netclass );
  m_board->Add( netInfo, ADD_MODE::APPEND );
  m_netMap.insert( { aCadstarNetID, netInfo } );
  return netInfo;
  }
 
  return nullptr;
 }

References _, NETCLASSES::Add(), BOARD::Add(), APPEND, CADSTAR_PCB_ARCHIVE_PARSER::Assignments, CADSTAR_PCB_ARCHIVE_PARSER::ASSIGNMENTS::Codedefs, Format(), BOARD_DESIGN_SETTINGS::GetDefault(), BOARD::GetDesignSettings(), getFootprintFromCadstarID(), getKiCadLength(), BOARD_DESIGN_SETTINGS::GetNetClasses(), getRouteCode(), EDA_TEXT::GetText(), CADSTAR_PCB_ARCHIVE_PARSER::Layout, m_board, m_doneNetClassWarning, m_doneSpacingClassWarning, m_netClassMap, m_netMap, m_numNets, CADSTAR_ARCHIVE_PARSER::ROUTECODE::Name, CADSTAR_ARCHIVE_PARSER::CADSTAR_NETCLASS::Name, CADSTAR_ARCHIVE_PARSER::SPCCLASSNAME::Name, CADSTAR_ARCHIVE_PARSER::CODEDEFS::NetClasses, CADSTAR_PCB_ARCHIVE_PARSER::LAYOUT::Nets, CADSTAR_ARCHIVE_PARSER::ROUTECODE::OptimalWidth, FOOTPRINT::Reference(), NETINFO_ITEM::SetNetClass(), and CADSTAR_ARCHIVE_PARSER::CODEDEFS::SpacingClassNames.

Referenced by loadCoppers(), loadNets(), loadNetTracks(), loadNetVia(), and loadTemplates().

◆ getKiCadPad()

PAD * CADSTAR_PCB_ARCHIVE_LOADER::getKiCadPad	(	const COMPONENT_PAD &	aCadstarPad,
		FOOTPRINT *	aParent
	)

private

Definition at line 921 of file cadstar_pcb_archive_loader.cpp.

 {
  PADCODE csPadcode = getPadCode( aCadstarPad.PadCodeID );
  wxString errorMSG;
 
  PAD* pad = new PAD( aParent );
  LSET padLayerSet;
 
  switch( aCadstarPad.Side )
  {
  case PAD_SIDE::MAXIMUM: //Bottom side
  padLayerSet |= LSET( 3, B_Cu, B_Paste, B_Mask );
  break;
 
  case PAD_SIDE::MINIMUM: //TOP side
  padLayerSet |= LSET( 3, F_Cu, F_Paste, F_Mask );
  break;
 
  case PAD_SIDE::THROUGH_HOLE:
  padLayerSet = LSET::AllCuMask() | LSET( 4, F_Mask, B_Mask, F_Paste, B_Paste );
  break;
 
  default:
  wxFAIL_MSG( wxT( "Unknown Pad type" ) );
  }
 
  pad->SetAttribute( PAD_ATTRIB::SMD ); // assume SMD pad for now
  pad->SetLocalSolderMaskMargin( 0 );
  pad->SetLocalSolderPasteMargin( 0 );
  pad->SetLocalSolderPasteMarginRatio( 0.0 );
  bool complexPadErrorLogged = false;
 
  for( auto& reassign : csPadcode.Reassigns )
  {
  PCB_LAYER_ID kiLayer = getKiCadLayer( reassign.first );
  CADSTAR_PAD_SHAPE shape = reassign.second;
 
  if( shape.Size == 0 )
  {
  padLayerSet.reset( kiLayer );
  }
  else
  {
  int newMargin = getKiCadLength( shape.Size - csPadcode.Shape.Size ) / 2;
 
  if( kiLayer == F_Mask || kiLayer == B_Mask )
  {
  if( std::abs( pad->GetLocalSolderMaskMargin() ) < std::abs( newMargin ) )
  pad->SetLocalSolderMaskMargin( newMargin );
  }
  else if( kiLayer == F_Paste || kiLayer == B_Paste )
  {
  if( std::abs( pad->GetLocalSolderPasteMargin() ) < std::abs( newMargin ) )
  pad->SetLocalSolderPasteMargin( newMargin );
  }
  else
  {
  //TODO fix properly when KiCad supports full padstacks
 
  if( !complexPadErrorLogged )
  {
  complexPadErrorLogged = true;
  errorMSG +=
  wxT( "\n - " )
  + wxString::Format(
  _( "The CADSTAR pad definition '%s' is a complex pad stack, "
  "which is not supported in KiCad. Please review the "
  "imported pads as they may require manual correction." ),
  csPadcode.Name );
  }
  }
  }
  }
 
  pad->SetLayerSet( padLayerSet );
 
  if( aCadstarPad.PCBonlyPad )
  {
  // PCB Only pads in CADSTAR do not have a representation in the schematic - they are
  // purely mechanical pads that have no net associated with them. Make the pad name
  // empty to avoid warnings when importing from the schematic
  pad->SetNumber( wxEmptyString );
  }
  else
  {
  pad->SetNumber( aCadstarPad.Identifier.IsEmpty()
  ? wxString::Format( wxT( "%ld" ), aCadstarPad.ID )
  : aCadstarPad.Identifier );
  }
 
  if( csPadcode.Shape.Size == 0 )
  {
  if( csPadcode.DrillDiameter == UNDEFINED_VALUE
  && aCadstarPad.Side == PAD_SIDE::THROUGH_HOLE )
  {
  // Through-hole, zero sized pad?. Lets load this just on the F_Mask for now to
  // prevent DRC errors.
  // TODO: This could be a custom padstack, update when KiCad supports padstacks
  pad->SetAttribute( PAD_ATTRIB::SMD );
  pad->SetLayerSet( LSET( 1, F_Mask ) );
  }
 
  // zero sized pads seems to break KiCad so lets make it very small instead
  csPadcode.Shape.Size = 1;
  }
 
  wxPoint padOffset = { 0, 0 }; // offset of the pad origin (before rotating)
  wxPoint drillOffset = { 0, 0 }; // offset of the drill origin w.r.t. the pad (before rotating)
 
  switch( csPadcode.Shape.ShapeType )
  {
  case PAD_SHAPE_TYPE::ANNULUS:
  //todo fix: use custom shape instead (Donught shape, i.e. a circle with a hole)
  pad->SetShape( PAD_SHAPE::CIRCLE );
  pad->SetSize( { getKiCadLength( csPadcode.Shape.Size ),
  getKiCadLength( csPadcode.Shape.Size ) } );
  break;
 
  case PAD_SHAPE_TYPE::BULLET:
  pad->SetShape( PAD_SHAPE::CHAMFERED_RECT );
  pad->SetSize( { getKiCadLength( (long long) csPadcode.Shape.Size
  + (long long) csPadcode.Shape.LeftLength
  + (long long) csPadcode.Shape.RightLength ),
  getKiCadLength( csPadcode.Shape.Size ) } );
  pad->SetChamferPositions( RECT_CHAMFER_POSITIONS::RECT_CHAMFER_BOTTOM_LEFT
  | RECT_CHAMFER_POSITIONS::RECT_CHAMFER_TOP_LEFT );
  pad->SetRoundRectRadiusRatio( 0.5 );
  pad->SetChamferRectRatio( 0.0 );
 
  padOffset.x = getKiCadLength( ( (long long) csPadcode.Shape.LeftLength / 2 ) -
  ( (long long) csPadcode.Shape.RightLength / 2 ) );
  break;
 
  case PAD_SHAPE_TYPE::CIRCLE:
  pad->SetShape( PAD_SHAPE::CIRCLE );
  pad->SetSize( { getKiCadLength( csPadcode.Shape.Size ),
  getKiCadLength( csPadcode.Shape.Size ) } );
  break;
 
  case PAD_SHAPE_TYPE::DIAMOND:
  {
  // Cadstar diamond shape is a square rotated 45 degrees
  // We convert it in KiCad to a square with chamfered edges
  int sizeOfSquare = (double) getKiCadLength( csPadcode.Shape.Size ) * sqrt(2.0);
  pad->SetShape( PAD_SHAPE::RECT );
  pad->SetChamferRectRatio( 0.5 );
  pad->SetSize( { sizeOfSquare, sizeOfSquare } );
 
  padOffset.x = getKiCadLength( ( (long long) csPadcode.Shape.LeftLength / 2 ) -
  ( (long long) csPadcode.Shape.RightLength / 2 ) );
  }
  break;
 
  case PAD_SHAPE_TYPE::FINGER:
  pad->SetShape( PAD_SHAPE::OVAL );
  pad->SetSize( { getKiCadLength( (long long) csPadcode.Shape.Size
  + (long long) csPadcode.Shape.LeftLength
  + (long long) csPadcode.Shape.RightLength ),
  getKiCadLength( csPadcode.Shape.Size ) } );
 
  padOffset.x = getKiCadLength( ( (long long) csPadcode.Shape.LeftLength / 2 ) -
  ( (long long) csPadcode.Shape.RightLength / 2 ) );
  break;
 
  case PAD_SHAPE_TYPE::OCTAGON:
  pad->SetShape( PAD_SHAPE::CHAMFERED_RECT );
  pad->SetChamferPositions( RECT_CHAMFER_POSITIONS::RECT_CHAMFER_ALL );
  pad->SetChamferRectRatio( 0.25 );
  pad->SetSize( { getKiCadLength( csPadcode.Shape.Size ),
  getKiCadLength( csPadcode.Shape.Size ) } );
  break;
 
  case PAD_SHAPE_TYPE::RECTANGLE:
  pad->SetShape( PAD_SHAPE::RECT );
  pad->SetSize( { getKiCadLength( (long long) csPadcode.Shape.Size
  + (long long) csPadcode.Shape.LeftLength
  + (long long) csPadcode.Shape.RightLength ),
  getKiCadLength( csPadcode.Shape.Size ) } );
 
  padOffset.x = getKiCadLength( ( (long long) csPadcode.Shape.LeftLength / 2 ) -
  ( (long long) csPadcode.Shape.RightLength / 2 ) );
  break;
 
  case PAD_SHAPE_TYPE::ROUNDED_RECT:
  pad->SetShape( PAD_SHAPE::RECT );
  pad->SetRoundRectCornerRadius( getKiCadLength( csPadcode.Shape.InternalFeature ) );
  pad->SetSize( { getKiCadLength( (long long) csPadcode.Shape.Size
  + (long long) csPadcode.Shape.LeftLength
  + (long long) csPadcode.Shape.RightLength ),
  getKiCadLength( csPadcode.Shape.Size ) } );
 
  padOffset.x = getKiCadLength( ( (long long) csPadcode.Shape.LeftLength / 2 ) -
  ( (long long) csPadcode.Shape.RightLength / 2 ) );
  break;
 
 
  case PAD_SHAPE_TYPE::SQUARE:
  pad->SetShape( PAD_SHAPE::RECT );
  pad->SetSize( { getKiCadLength( csPadcode.Shape.Size ),
  getKiCadLength( csPadcode.Shape.Size ) } );
  break;
 
  default:
  wxFAIL_MSG( wxT( "Unknown Pad Shape" ) );
  }
 
  if( csPadcode.ReliefClearance != UNDEFINED_VALUE )
  pad->SetThermalGap( getKiCadLength( csPadcode.ReliefClearance ) );
 
  if( csPadcode.ReliefWidth != UNDEFINED_VALUE )
  pad->SetThermalSpokeWidth( getKiCadLength( csPadcode.ReliefWidth ) );
 
  if( csPadcode.DrillDiameter != UNDEFINED_VALUE )
  {
  if( csPadcode.SlotLength != UNDEFINED_VALUE )
  {
  pad->SetDrillShape( PAD_DRILL_SHAPE_T::PAD_DRILL_SHAPE_OBLONG );
  pad->SetDrillSize( { getKiCadLength( (long long) csPadcode.SlotLength +
  (long long) csPadcode.DrillDiameter ),
  getKiCadLength( csPadcode.DrillDiameter ) } );
  }
  else
  {
  pad->SetDrillShape( PAD_DRILL_SHAPE_T::PAD_DRILL_SHAPE_CIRCLE );
  pad->SetDrillSize( { getKiCadLength( csPadcode.DrillDiameter ),
  getKiCadLength( csPadcode.DrillDiameter ) } );
  }
 
  drillOffset.x = -getKiCadLength( csPadcode.DrillXoffset );
  drillOffset.y = getKiCadLength( csPadcode.DrillYoffset );
 
  if( csPadcode.Plated )
  pad->SetAttribute( PAD_ATTRIB::PTH );
  else
  pad->SetAttribute( PAD_ATTRIB::NPTH );
  }
  else
  {
  pad->SetDrillSize( { 0, 0 } );
  }
 
  if( csPadcode.SlotOrientation != 0 )
  {
  LSET lset = pad->GetLayerSet();
  lset &= LSET::AllCuMask();
 
  if( lset.size() > 0 )
  {
  SHAPE_POLY_SET padOutline;
  PCB_LAYER_ID layer = lset.Seq().at( 0 );
  int maxError = m_board->GetDesignSettings().m_MaxError;
 
  pad->SetPosition( { 0, 0 } );
  pad->SetPos0( { 0, 0 } );
  pad->TransformShapeWithClearanceToPolygon( padOutline, layer, 0, maxError,
  ERROR_LOC::ERROR_INSIDE );
 
  PCB_SHAPE* padShape = new PCB_SHAPE;
  padShape->SetShape( SHAPE_T::POLY );
  padShape->SetFilled( true );
  padShape->SetPolyShape( padOutline );
  padShape->SetWidth( 0 );
  padShape->Move( padOffset - drillOffset );
  padShape->Rotate( wxPoint( 0, 0 ),
  1800.0 - getAngleTenthDegree( csPadcode.SlotOrientation ) );
 
  SHAPE_POLY_SET editedPadOutline = padShape->GetPolyShape();
 
  if( editedPadOutline.Contains( { 0, 0 } ) )
  {
  pad->SetAnchorPadShape( PAD_SHAPE::RECT );
  pad->SetSize( wxSize( { 4, 4 } ) );
  pad->SetShape( PAD_SHAPE::CUSTOM );
  pad->AddPrimitive( padShape );
  padOffset = { 0, 0 };
  }
  else
  {
  // The CADSTAR pad has the hole shape outside the pad shape
  // Lets just put the hole in the center of the pad instead
  csPadcode.SlotOrientation = 0;
  drillOffset = { 0, 0 };
 
  errorMSG +=
  wxT( "\n - " )
  + wxString::Format(
  _( "The CADSTAR pad definition '%s' has the hole shape outside the "
  "pad shape. The hole has been moved to the center of the pad." ),
  csPadcode.Name );
  }
  }
  else
  {
  wxFAIL_MSG( wxT( "No copper layers defined in the pad?" ) );
  csPadcode.SlotOrientation = 0;
  pad->SetOffset( drillOffset );
  }
  }
  else
  {
  pad->SetOffset( drillOffset );
  }
 
  double padOrientation = getAngleTenthDegree( aCadstarPad.OrientAngle )
  + getAngleTenthDegree( csPadcode.Shape.OrientAngle );
 
  RotatePoint( &padOffset, padOrientation );
  RotatePoint( &drillOffset, padOrientation );
  pad->SetPos0( getKiCadPoint( aCadstarPad.Position ) - aParent->GetPosition() - padOffset
  - drillOffset );
  pad->SetOrientation( padOrientation + getAngleTenthDegree( csPadcode.SlotOrientation ) );
 
  //TODO handle csPadcode.Reassigns when KiCad supports full padstacks
 
  pad->SetLocked( true ); // Cadstar pads are always locked with respect to the footprint
 
  //log warnings:
  if( m_padcodesTested.find( csPadcode.ID ) == m_padcodesTested.end() && !errorMSG.IsEmpty() )
  {
  wxLogError( _( "The CADSTAR pad definition '%s' has import errors: %s" ),
  csPadcode.Name,
  errorMSG );
 
  m_padcodesTested.insert( csPadcode.ID );
  }
 
  return pad;
 }

Referenced by loadComponents(), and loadLibraryPads().

◆ getKiCadPoint()

wxPoint CADSTAR_PCB_ARCHIVE_LOADER::getKiCadPoint ( const wxPoint & aCadstarPoint )

private

Scales, offsets and inverts y axis to make the point usable directly in KiCad.

Parameters

aCadstarPoint

Returns

Definition at line 3882 of file cadstar_pcb_archive_loader.cpp.

 {
  wxPoint retval;
 
  retval.x = ( aCadstarPoint.x - m_designCenter.x ) * KiCadUnitMultiplier;
  retval.y = -( aCadstarPoint.y - m_designCenter.y ) * KiCadUnitMultiplier;
 
  return retval;
 }

References CADSTAR_PCB_ARCHIVE_PARSER::KiCadUnitMultiplier, and m_designCenter.

Referenced by addAttribute(), applyDimensionSettings(), drawCadstarText(), getKiCadPad(), getShapeFromVertex(), loadComponentLibrary(), loadComponents(), loadDimensions(), loadDocumentationSymbols(), loadLibraryCoppers(), and loadNetVia().

◆ getLayerPair()

CADSTAR_PCB_ARCHIVE_LOADER::LAYERPAIR CADSTAR_PCB_ARCHIVE_LOADER::getLayerPair ( const LAYERPAIR_ID & aCadstarLayerPairID )

private

Definition at line 3409 of file cadstar_pcb_archive_loader.cpp.

 {
  wxCHECK( Assignments.Codedefs.LayerPairs.find( aCadstarLayerPairID )
  != Assignments.Codedefs.LayerPairs.end(),
  LAYERPAIR() );
 
  return Assignments.Codedefs.LayerPairs.at( aCadstarLayerPairID );
 }

References CADSTAR_PCB_ARCHIVE_PARSER::Assignments, CADSTAR_PCB_ARCHIVE_PARSER::ASSIGNMENTS::Codedefs, and CADSTAR_PCB_ARCHIVE_PARSER::CODEDEFS_PCB::LayerPairs.

Referenced by loadNetVia().

◆ getLayerType()

CADSTAR_PCB_ARCHIVE_LOADER::LAYER_TYPE CADSTAR_PCB_ARCHIVE_LOADER::getLayerType ( const LAYER_ID aCadstarLayerID )

private

Definition at line 3441 of file cadstar_pcb_archive_loader.cpp.

 {
  if( Assignments.Layerdefs.Layers.find( aCadstarLayerID ) != Assignments.Layerdefs.Layers.end() )
  {
  return Assignments.Layerdefs.Layers.at( aCadstarLayerID ).Type;
  }
 
  return LAYER_TYPE::UNDEFINED;
 }

References CADSTAR_PCB_ARCHIVE_PARSER::Assignments, CADSTAR_PCB_ARCHIVE_PARSER::ASSIGNMENTS::Layerdefs, CADSTAR_PCB_ARCHIVE_PARSER::LAYERDEFS::Layers, and CADSTAR_PCB_ARCHIVE_PARSER::UNDEFINED.

Referenced by getKiCadLayer(), getKiCadLayerSet(), and loadComponentLibrary().

◆ getLineChainFromShapes()

SHAPE_LINE_CHAIN CADSTAR_PCB_ARCHIVE_LOADER::getLineChainFromShapes ( const std::vector< PCB_SHAPE * > aShapes )

private

Returns a SHAPE_LINE_CHAIN object from a series of PCB_SHAPE objects.

Parameters

aShapes

Returns

Definition at line 2991 of file cadstar_pcb_archive_loader.cpp.

 {
  SHAPE_LINE_CHAIN lineChain;
 
  for( PCB_SHAPE* shape : aShapes )
  {
  switch( shape->GetShape() )
  {
  case SHAPE_T::ARC:
  {
  if( shape->GetClass() == wxT( "MGRAPHIC" ) )
  {
  FP_SHAPE* fp_shape = (FP_SHAPE*) shape;
  SHAPE_ARC arc( fp_shape->GetCenter0(), fp_shape->GetStart0(), fp_shape->GetArcAngle() / 10.0 );
 
  if( shape->EndsSwapped() )
  arc.Reverse();
 
  lineChain.Append( arc );
  }
  else
  {
  SHAPE_ARC arc( shape->GetCenter(), shape->GetStart(), shape->GetArcAngle() / 10.0 );
 
  if( shape->EndsSwapped() )
  arc.Reverse();
 
  lineChain.Append( arc );
  }
  }
  break;
  case SHAPE_T::SEGMENT:
  if( shape->GetClass() == wxT( "MGRAPHIC" ) )
  {
  FP_SHAPE* fp_shape = (FP_SHAPE*) shape;
  lineChain.Append( fp_shape->GetStart0().x, fp_shape->GetStart0().y );
  lineChain.Append( fp_shape->GetEnd0().x, fp_shape->GetEnd0().y );
  }
  else
  {
  lineChain.Append( shape->GetStartX(), shape->GetStartY() );
  lineChain.Append( shape->GetEndX(), shape->GetEndY() );
  }
  break;
 
  default:
  wxFAIL_MSG( wxT( "Drawsegment type is unexpected. Ignored." ) );
  }
  }
 
  // Shouldn't have less than 3 points to make a closed shape!
  wxASSERT( lineChain.PointCount() > 2 );
 
  // Check if it is closed
  if( lineChain.GetPoint( 0 ) != lineChain.GetPoint( lineChain.PointCount() - 1 ) )
  {
  lineChain.Append( lineChain.GetPoint( 0 ) );
  }
 
  lineChain.SetClosed( true );
 
  return lineChain;
 }

References SHAPE_LINE_CHAIN::Append(), ARC, EDA_SHAPE::GetArcAngle(), FP_SHAPE::GetCenter0(), FP_SHAPE::GetEnd0(), SHAPE_LINE_CHAIN::GetPoint(), FP_SHAPE::GetStart0(), SHAPE_LINE_CHAIN::PointCount(), SHAPE_ARC::Reverse(), SEGMENT, and SHAPE_LINE_CHAIN::SetClosed().

Referenced by getPolySetFromCadstarShape().

◆ getLineThickness()

int CADSTAR_PCB_ARCHIVE_LOADER::getLineThickness ( const LINECODE_ID & aCadstarLineCodeID )

private

Definition at line 3355 of file cadstar_pcb_archive_loader.cpp.

 {
  wxCHECK( Assignments.Codedefs.LineCodes.find( aCadstarLineCodeID )
  != Assignments.Codedefs.LineCodes.end(),
  m_board->GetDesignSettings().GetLineThickness( PCB_LAYER_ID::Edge_Cuts ) );
 
  return getKiCadLength( Assignments.Codedefs.LineCodes.at( aCadstarLineCodeID ).Width );
 }

References CADSTAR_PCB_ARCHIVE_PARSER::Assignments, CADSTAR_PCB_ARCHIVE_PARSER::ASSIGNMENTS::Codedefs, Edge_Cuts, BOARD::GetDesignSettings(), getKiCadLength(), BOARD_DESIGN_SETTINGS::GetLineThickness(), CADSTAR_ARCHIVE_PARSER::CODEDEFS::LineCodes, and m_board.

Referenced by loadBoards(), loadDocumentationSymbols(), loadFigures(), and loadLibraryFigures().

◆ GetLoadedLibraryFootpints()

std::vector< FOOTPRINT * > CADSTAR_PCB_ARCHIVE_LOADER::GetLoadedLibraryFootpints ( ) const

Return a copy of the loaded library footprints (caller owns the objects)

Returns: Container with all the footprint definitions that were loaded

Definition at line 169 of file cadstar_pcb_archive_loader.cpp.

 {
  std::vector<FOOTPRINT*> retval;
 
  for( std::pair<SYMDEF_ID, FOOTPRINT*> fpPair : m_libraryMap )
  {
  retval.push_back( static_cast<FOOTPRINT*>( fpPair.second->Clone() ) );
  }
 
  return retval;
 }

References m_libraryMap.

Referenced by CADSTAR_PCB_ARCHIVE_PLUGIN::Load().

◆ GetNumberOfChildNodes()

long CADSTAR_ARCHIVE_PARSER::GetNumberOfChildNodes ( XNODE * aNode )

staticinherited

Definition at line 2575 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 2587 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().

◆ getPadCode()

CADSTAR_PCB_ARCHIVE_LOADER::PADCODE CADSTAR_PCB_ARCHIVE_LOADER::getPadCode ( const PADCODE_ID & aCadstarPadCodeID )

private

Definition at line 3387 of file cadstar_pcb_archive_loader.cpp.

 {
  wxCHECK( Assignments.Codedefs.PadCodes.find( aCadstarPadCodeID )
  != Assignments.Codedefs.PadCodes.end(),
  PADCODE() );
 
  return Assignments.Codedefs.PadCodes.at( aCadstarPadCodeID );
 }

References CADSTAR_PCB_ARCHIVE_PARSER::Assignments, CADSTAR_PCB_ARCHIVE_PARSER::ASSIGNMENTS::Codedefs, and CADSTAR_PCB_ARCHIVE_PARSER::CODEDEFS_PCB::PadCodes.

Referenced by getKiCadPad(), and loadLibraryCoppers().

◆ getPadReference()

PAD *& CADSTAR_PCB_ARCHIVE_LOADER::getPadReference	(	FOOTPRINT *	aFootprint,
		const PAD_ID	aCadstarPadID
	)

private

Definition at line 1251 of file cadstar_pcb_archive_loader.cpp.

 {
  size_t index = aCadstarPadID - (long) 1;
 
  if( !( index < aFootprint->Pads().size() ) )
  {
  THROW_IO_ERROR( wxString::Format( _( "Unable to find pad index '%d' in footprint '%s'." ),
  (long) aCadstarPadID,
  aFootprint->GetReference() ) );
  }
 
  return aFootprint->Pads().at( index );
 }

References _, Format(), FOOTPRINT::GetReference(), FOOTPRINT::Pads(), and THROW_IO_ERROR.

Referenced by loadComponents(), loadLibraryCoppers(), and loadNets().

◆ GetPadSide()

CADSTAR_PCB_ARCHIVE_PARSER::PAD_SIDE CADSTAR_PCB_ARCHIVE_PARSER::GetPadSide ( const wxString & aPadSideString )

staticinherited

Definition at line 1004 of file cadstar_pcb_archive_parser.cpp.

 {
  if( aPadSideString == wxT( "THRU" ) )
  return PAD_SIDE::THROUGH_HOLE;
  else if( aPadSideString == wxT( "BOTTOM" ) )
  return PAD_SIDE::MAXIMUM;
  else if( aPadSideString == wxT( "TOP" ) )
  return PAD_SIDE::MINIMUM;
  else
  return PAD_SIDE::THROUGH_HOLE; // Assume through hole as default
 }

References CADSTAR_PCB_ARCHIVE_PARSER::MAXIMUM, CADSTAR_PCB_ARCHIVE_PARSER::MINIMUM, and CADSTAR_PCB_ARCHIVE_PARSER::THROUGH_HOLE.

Referenced by CADSTAR_PCB_ARCHIVE_PARSER::COMPONENT_PAD::Parse(), and CADSTAR_PCB_ARCHIVE_PARSER::PADEXCEPTION::Parse().

◆ getPart()

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

private

Definition at line 3452 of file cadstar_pcb_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_PCB_ARCHIVE_PARSER::Parts.

Referenced by loadComponentAttributes(), and loadComponents().

◆ getPolarAngle()

double CADSTAR_PCB_ARCHIVE_LOADER::getPolarAngle ( const wxPoint & aPoint )

private

Parameters

aPoint

Returns: Angle in decidegrees of the polar representation of the point, scaled 0..360

Definition at line 3893 of file cadstar_pcb_archive_loader.cpp.

 {
  return NormalizeAnglePos( ArcTangente( aPoint.y, aPoint.x ) );
 }

References ArcTangente(), and NormalizeAnglePos().

Referenced by getShapeFromVertex().

◆ getPolySetFromCadstarShape()

SHAPE_POLY_SET CADSTAR_PCB_ARCHIVE_LOADER::getPolySetFromCadstarShape	(	const SHAPE &	aCadstarShape,
		const int &	aLineThickness = `-1`,
		BOARD_ITEM_CONTAINER *	aContainer = `nullptr`,
		const wxPoint &	aMoveVector = `{ 0, 0 }`,
		const double &	aRotationAngle = `0.0`,
		const double &	aScalingFactor = `1.0`,
		const wxPoint &	aTransformCentre = `{ 0, 0 }`,
		const bool &	aMirrorInvert = `false`
	)

private

Returns a SHAPE_POLY_SET object from a Cadstar SHAPE.

Parameters

aCadstarShape
aLineThickness	Thickness of line is used for expanding the polygon by half.
aContainer	to draw on (e.g. m_board). Can be nullptr.
aMoveVector	move poly by this amount (in KiCad coordinates)
aRotationAngle	rotate poly by this amount (in tenth degrees)
aScalingFactor	scale poly by this amount
aTransformCentre	around which all transforms are applied (KiCad coordinates)
aMirrorInvert	if true, mirrors the poly

Returns

Definition at line 2931 of file cadstar_pcb_archive_loader.cpp.

 {
  GROUP_ID noGroup = wxEmptyString;
 
  std::vector<PCB_SHAPE*> outlineShapes = getShapesFromVertices( aCadstarShape.Vertices,
  aContainer, noGroup, aMoveVector,
  aRotationAngle, aScalingFactor,
  aTransformCentre, aMirrorInvert );
 
  SHAPE_POLY_SET polySet( getLineChainFromShapes( outlineShapes ) );
 
  //cleanup
  for( PCB_SHAPE* shape : outlineShapes )
  delete shape;
 
  for( CUTOUT cutout : aCadstarShape.Cutouts )
  {
  std::vector<PCB_SHAPE*> cutoutShapes = getShapesFromVertices( cutout.Vertices, aContainer,
  noGroup, aMoveVector,
  aRotationAngle, aScalingFactor,
  aTransformCentre, aMirrorInvert );
 
  polySet.AddHole( getLineChainFromShapes( cutoutShapes ) );
 
  //cleanup
  for( PCB_SHAPE* shape : cutoutShapes )
  delete shape;
  }
 
  polySet.ClearArcs();
 
  if( aLineThickness > 0 )
  {
  polySet.Inflate( aLineThickness / 2, 32,
  SHAPE_POLY_SET::CORNER_STRATEGY::ROUND_ALL_CORNERS );
  }
 
 #ifdef DEBUG
  for( int i = 0; i < polySet.OutlineCount(); ++i )
  {
  wxASSERT( polySet.Outline( i ).PointCount() > 2 );
 
  for( int j = 0; j < polySet.HoleCount( i ); ++j )
  {
  wxASSERT( polySet.Hole( i, j ).PointCount() > 2 );
  }
  }
 #endif
 
  return polySet;
 }

References SHAPE_POLY_SET::AddHole(), SHAPE_POLY_SET::ClearArcs(), CADSTAR_ARCHIVE_PARSER::SHAPE::Cutouts, getLineChainFromShapes(), getShapesFromVertices(), SHAPE_POLY_SET::Hole(), SHAPE_POLY_SET::HoleCount(), SHAPE_POLY_SET::Inflate(), SHAPE_POLY_SET::Outline(), SHAPE_POLY_SET::OutlineCount(), SHAPE_LINE_CHAIN::PointCount(), CADSTAR_ARCHIVE_PARSER::CUTOUT::Vertices, and CADSTAR_ARCHIVE_PARSER::SHAPE::Vertices.

Referenced by drawCadstarShape(), getZoneFromCadstarShape(), loadCoppers(), and loadLibraryCoppers().

◆ getRouteCode()

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

private

Definition at line 3461 of file cadstar_pcb_archive_loader.cpp.

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

References CADSTAR_PCB_ARCHIVE_PARSER::Assignments, CADSTAR_PCB_ARCHIVE_PARSER::ASSIGNMENTS::Codedefs, and CADSTAR_ARCHIVE_PARSER::CODEDEFS::RouteCodes.

Referenced by getKiCadNet().

◆ getShapeFromVertex()

PCB_SHAPE * CADSTAR_PCB_ARCHIVE_LOADER::getShapeFromVertex	(	const POINT &	aCadstarStartPoint,
		const VERTEX &	aCadstarVertex,
		BOARD_ITEM_CONTAINER *	aContainer = `nullptr`,
		const GROUP_ID &	aCadstarGroupID = `wxEmptyString`,
		const wxPoint &	aMoveVector = `{ 0, 0 }`,
		const double &	aRotationAngle = `0.0`,
		const double &	aScalingFactor = `1.0`,
		const wxPoint &	aTransformCentre = `{ 0, 0 }`,
		const bool &	aMirrorInvert = `false`
	)

private

Returns a pointer to a PCB_SHAPE object.

Caller owns the object.

Parameters

aCadstarStartPoint
aCadstarVertex
aContainer	to draw on (e.g. m_board). Can be nullptr.
aCadstarGroupID	to add the shape to
aMoveVector	move shapes by this amount (in KiCad coordinates)
aRotationAngle	rotate shapes by this amount (in tenth degrees)
aScalingFactor	scale shapes by this amount
aTransformCentre	around which all transforms are applied (KiCad coordinates)
aMirrorInvert	if true, mirrors the shapes

Returns

Definition at line 2805 of file cadstar_pcb_archive_loader.cpp.

 {
  PCB_SHAPE* shape = nullptr;
  bool cw = false;
  double arcStartAngle, arcEndAngle, arcAngle;
 
  wxPoint startPoint = getKiCadPoint( aCadstarStartPoint );
  wxPoint endPoint = getKiCadPoint( aCadstarVertex.End );
  wxPoint centerPoint;
 
  if( aCadstarVertex.Type == VERTEX_TYPE::ANTICLOCKWISE_SEMICIRCLE
  || aCadstarVertex.Type == VERTEX_TYPE::CLOCKWISE_SEMICIRCLE )
  {
  centerPoint = ( startPoint + endPoint ) / 2;
  }
  else
  {
  centerPoint = getKiCadPoint( aCadstarVertex.Center );
  }
 
  switch( aCadstarVertex.Type )
  {
 
  case VERTEX_TYPE::POINT:
 
  if( isFootprint( aContainer ) )
  shape = new FP_SHAPE( static_cast<FOOTPRINT*>( aContainer ), SHAPE_T::SEGMENT );
  else
  shape = new PCB_SHAPE( aContainer, SHAPE_T::SEGMENT );
 
  shape->SetStart( startPoint );
  shape->SetEnd( 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:
 
  if( isFootprint( aContainer ) )
  shape = new FP_SHAPE((FOOTPRINT*) aContainer, SHAPE_T::ARC );
  else
  shape = new PCB_SHAPE( aContainer, SHAPE_T::ARC );
 
  shape->SetCenter( centerPoint );
  shape->SetStart( startPoint );
 
  arcStartAngle = getPolarAngle( startPoint - centerPoint );
  arcEndAngle = getPolarAngle( endPoint - centerPoint );
  arcAngle = arcEndAngle - arcStartAngle;
  //TODO: detect if we are supposed to draw a circle instead (i.e. two SEMICIRCLEs
  // with opposite start/end points and same centre point)
 
  if( cw )
  shape->SetArcAngleAndEnd( NormalizeAnglePos( arcAngle ) );
  else
  shape->SetArcAngleAndEnd( NormalizeAngleNeg( arcAngle ), true );
 
   break;
  }
 
  //Apply transforms
  if( aMirrorInvert )
  shape->Flip( aTransformCentre, true );
 
  if( aScalingFactor != 1.0 )
  {
  shape->Move( -aTransformCentre );
  shape->Scale( aScalingFactor );
  shape->Move( aTransformCentre );
  }
 
  if( aRotationAngle != 0.0 )
  shape->Rotate( aTransformCentre, aRotationAngle );
 
  if( aMoveVector != wxPoint{ 0, 0 } )
  shape->Move( aMoveVector );
 
  if( isFootprint( aContainer ) && shape != nullptr )
  static_cast<FP_SHAPE*>( shape )->SetLocalCoord();
 
  if( !aCadstarGroupID.IsEmpty() )
  addToGroup( aCadstarGroupID, shape );
 
  return shape;
 }

Referenced by getShapesFromVertices(), and loadNetTracks().

◆ getShapesFromVertices()

std::vector< PCB_SHAPE * > CADSTAR_PCB_ARCHIVE_LOADER::getShapesFromVertices	(	const std::vector< VERTEX > &	aCadstarVertices,
		BOARD_ITEM_CONTAINER *	aContainer = `nullptr`,
		const GROUP_ID &	aCadstarGroupID = `wxEmptyString`,
		const wxPoint &	aMoveVector = `{ 0, 0 }`,
		const double &	aRotationAngle = `0.0`,
		const double &	aScalingFactor = `1.0`,
		const wxPoint &	aTransformCentre = `{ 0, 0 }`,
		const bool &	aMirrorInvert = `false`
	)

private

Returns a vector of pointers to PCB_SHAPE objects.

Caller owns the objects.

Parameters

aCadstarVertices
aContainer	to draw on (e.g. m_board). Can be nullptr.
aCadstarGroupID	to add the shape to
aMoveVector	move shapes by this amount (in KiCad coordinates)
aRotationAngle	rotate shapes by this amount (in tenth degrees)
aScalingFactor	scale shapes by this amount
aTransformCentre	around which all transforms are applied (KiCad coordinates)
aMirrorInvert	if true, mirrors the shapes

Returns

Definition at line 2773 of file cadstar_pcb_archive_loader.cpp.

 {
  std::vector<PCB_SHAPE*> drawSegments;
 
  if( aCadstarVertices.size() < 2 )
  //need at least two points to draw a segment! (unlikely but possible to have only one)
  return drawSegments;
 
  const VERTEX* prev = &aCadstarVertices.at( 0 ); // first one should always be a point vertex
  const VERTEX* cur;
 
  for( size_t i = 1; i < aCadstarVertices.size(); i++ )
  {
  cur = &aCadstarVertices.at( i );
  drawSegments.push_back( getShapeFromVertex( prev->End, *cur, aContainer, aCadstarGroupID,
  aMoveVector, aRotationAngle, aScalingFactor,
  aTransformCentre, aMirrorInvert ) );
  prev = cur;
  }
 
  return drawSegments;
 }

References CADSTAR_ARCHIVE_PARSER::VERTEX::End, and getShapeFromVertex().

Referenced by drawCadstarVerticesAsShapes(), getPolySetFromCadstarShape(), and loadCoppers().

◆ getTextCode()

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

private

Definition at line 3376 of file cadstar_pcb_archive_loader.cpp.

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

References CADSTAR_PCB_ARCHIVE_PARSER::Assignments, CADSTAR_PCB_ARCHIVE_PARSER::ASSIGNMENTS::Codedefs, and CADSTAR_ARCHIVE_PARSER::CODEDEFS::TextCodes.

Referenced by addAttribute(), applyDimensionSettings(), and drawCadstarText().

◆ getViaCode()

CADSTAR_PCB_ARCHIVE_LOADER::VIACODE CADSTAR_PCB_ARCHIVE_LOADER::getViaCode ( const VIACODE_ID & aCadstarViaCodeID )

private

Definition at line 3398 of file cadstar_pcb_archive_loader.cpp.

 {
  wxCHECK( Assignments.Codedefs.ViaCodes.find( aCadstarViaCodeID )
  != Assignments.Codedefs.ViaCodes.end(),
  VIACODE() );
 
  return Assignments.Codedefs.ViaCodes.at( aCadstarViaCodeID );
 }

References CADSTAR_PCB_ARCHIVE_PARSER::Assignments, CADSTAR_PCB_ARCHIVE_PARSER::ASSIGNMENTS::Codedefs, and CADSTAR_PCB_ARCHIVE_PARSER::CODEDEFS_PCB::ViaCodes.

Referenced by loadNetVia().

◆ 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 2447 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 2428 of file cadstar_archive_parser.cpp.

 {
  wxString attrName, retVal;
  attrName = wxT( "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.

◆ getZoneFromCadstarShape()

ZONE * CADSTAR_PCB_ARCHIVE_LOADER::getZoneFromCadstarShape	(	const SHAPE &	aCadstarShape,
		const int &	aLineThickness,
		BOARD_ITEM_CONTAINER *	aParentContainer
	)

private

Parameters

aCadstarShape
aLineThickness	Thickness of line to draw with
aParentContainer	Parent object (e.g. BOARD or FOOTPRINT pointer)

Returns: Pointer to ZONE. Caller owns the object.

Definition at line 2904 of file cadstar_pcb_archive_loader.cpp.

 {
  ZONE* zone = new ZONE( aParentContainer, isFootprint( aParentContainer ) );
 
  if( aCadstarShape.Type == SHAPE_TYPE::HATCHED )
  {
  zone->SetFillMode( ZONE_FILL_MODE::HATCH_PATTERN );
  zone->SetHatchStyle( ZONE_BORDER_DISPLAY_STYLE::DIAGONAL_FULL );
  }
  else
  {
  zone->SetHatchStyle( ZONE_BORDER_DISPLAY_STYLE::NO_HATCH );
  }
 
  SHAPE_POLY_SET polygon = getPolySetFromCadstarShape( aCadstarShape, aLineThickness );
 
  zone->AddPolygon( polygon.COutline( 0 ) );
 
  for( int i = 0; i < polygon.HoleCount( 0 ); i++ )
  zone->AddPolygon( polygon.CHole( 0, i ) );
 
  return zone;
 }

References ZONE::AddPolygon(), SHAPE_POLY_SET::CHole(), SHAPE_POLY_SET::COutline(), DIAGONAL_FULL, getPolySetFromCadstarShape(), HATCH_PATTERN, CADSTAR_ARCHIVE_PARSER::HATCHED, SHAPE_POLY_SET::HoleCount(), isFootprint(), NO_HATCH, ZONE::SetFillMode(), ZONE::SetHatchStyle(), and CADSTAR_ARCHIVE_PARSER::SHAPE::Type.

Referenced by loadAreas(), loadCoppers(), loadLibraryAreas(), and loadTemplates().

◆ 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 2607 of file cadstar_archive_parser.cpp.

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

References ConvertToNewOverbarNotation().

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

◆ initStackupItem()

void CADSTAR_PCB_ARCHIVE_LOADER::initStackupItem	(	const LAYER &	aCadstarLayer,
		BOARD_STACKUP_ITEM *	aKiCadItem,
		int	aDielectricSublayer
	)

private

Definition at line 209 of file cadstar_pcb_archive_loader.cpp.

 {
  if( !aCadstarLayer.MaterialId.IsEmpty() )
  {
  MATERIAL material = Assignments.Layerdefs.Materials.at( aCadstarLayer.MaterialId );
 
  aKiCadItem->SetMaterial( material.Name, aDielectricSublayer );
  aKiCadItem->SetEpsilonR( material.Permittivity.GetDouble(), aDielectricSublayer );
  aKiCadItem->SetLossTangent( material.LossTangent.GetDouble(), aDielectricSublayer );
  //TODO add Resistivity when KiCad supports it
  }
 
  if( !aCadstarLayer.Name.IsEmpty() )
   aKiCadItem->SetLayerName( aCadstarLayer.Name );
 
  if( aCadstarLayer.Thickness != 0 )
  aKiCadItem->SetThickness( getKiCadLength( aCadstarLayer.Thickness ), aDielectricSublayer );
 }

Referenced by loadBoardStackup().

◆ InsertAttributeAtEnd()

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

staticinherited

Definition at line 2297 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().

◆ isFootprint()

bool CADSTAR_PCB_ARCHIVE_LOADER::isFootprint ( BOARD_ITEM_CONTAINER * aContainer )

inlineprivate

Definition at line 517 of file cadstar_pcb_archive_loader.h.

  {
  return aContainer && aContainer->Type() == PCB_FOOTPRINT_T;
  }

References PCB_FOOTPRINT_T, and EDA_ITEM::Type().

Referenced by drawCadstarShape(), getShapeFromVertex(), and getZoneFromCadstarShape().

◆ isLayerSet()

bool CADSTAR_PCB_ARCHIVE_LOADER::isLayerSet ( const LAYER_ID & aCadstarLayerID )

private

Parameters

aCadstarLayerID

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

◆ AREA_ID

◆ ASSOCIATED_COPPER_PADS

◆ ATTRIBUTE_ID

◆ BOARD_ID

◆ COLOR_ID

◆ COMP_AREA_ID

◆ COMPONENT_ID

◆ COPPER_ID

◆ COPPER_TERM_ID

◆ COPPERCODE_ID

◆ DIMENSION_ID

◆ DOCUMENTATION_SYMBOL_ID

◆ DRILL_TABLE_ID

◆ FIGURE_ID

◆ GATE_ID

◆ GROUP_ID

◆ HATCHCODE_ID

◆ LAYER_ID

◆ LAYERPAIR_ID

◆ LINECODE_ID

◆ MATERIAL_ID

◆ NET_ID

◆ NETCLASS_ID

◆ NETELEMENT_ID

◆ PAD_ID

◆ PADCODE_ID

◆ PART_DEFINITION_PIN_ID

◆ PART_ID

◆ PART_PIN_ID

◆ PHYSICAL_LAYER_ID

◆ REUSEBLOCK_ID

◆ ROUTECODE_ID

◆ RULESET_ID

◆ SPACING_CLASS_ID

◆ SPACINGCODE_ID

◆ SYMDEF_ID

◆ TEMPLATE_ID

◆ TERMINAL_ID

◆ TEXT_ID

◆ TEXTCODE_ID

◆ TRUNK_ID

◆ VARIANT_ID

◆ VIACODE_ID

Member Enumeration Documentation

◆ ALIGNMENT

◆ ANGUNITS

◆ ATTROWNER

◆ ATTRUSAGE

◆ EMBEDDING

◆ GRID_TYPE

◆ JUSTIFICATION

◆ LAYER_SUBTYPE

◆ LAYER_TYPE

◆ LINESTYLE

◆ MATERIAL_LAYER_TYPE

◆ NETSYNCH

◆ PAD_SHAPE_TYPE

◆ PAD_SIDE

◆ READABILITY

◆ RESOLUTION

◆ ROUTING_BIAS

◆ SHAPE_TYPE

◆ SWAP_RULE

◆ SYMDEF_TYPE

◆ TESTLAND_SIDE

◆ TEXT_FIELD_NAME

◆ UNITS

◆ VERTEX_TYPE