KiCad PCB EDA Suite
EAGLE_PLUGIN Class Reference

Class EAGLE_PLUGIN works with Eagle 6.x XML board files and footprints to implement the Pcbnew PLUGIN API, or a portion of it. More...

#include <eagle_plugin.h>

Inheritance diagram for EAGLE_PLUGIN:
PLUGIN

Public Types

typedef int BIU
 

Public Member Functions

const wxString PluginName () const override
 Function PluginName returns a brief hard coded name for this PLUGIN. More...
 
BOARDLoad (const wxString &aFileName, BOARD *aAppendToMe, const PROPERTIES *aProperties=NULL) override
 Function Load loads information from some input file format that this PLUGIN implementation knows about, into either a new BOARD or an existing one. More...
 
const wxString GetFileExtension () const override
 Function GetFileExtension returns the file extension for the PLUGIN. More...
 
void FootprintEnumerate (wxArrayString &aFootprintNames, const wxString &aLibraryPath, const PROPERTIES *aProperties=NULL) override
 Return a list of footprint names contained within the library at aLibraryPath. More...
 
MODULEFootprintLoad (const wxString &aLibraryPath, const wxString &aFootprintName, const PROPERTIES *aProperties=NULL) override
 Function FootprintLoad loads a footprint having aFootprintName from the aLibraryPath containing a library format that this PLUGIN knows about. More...
 
long long GetLibraryTimestamp (const wxString &aLibraryPath) const override
 Generate a timestamp representing all the files in the library (including the library directory). More...
 
bool IsFootprintLibWritable (const wxString &aLibraryPath) override
 Function IsFootprintLibWritable returns true iff the library at aLibraryPath is writable. More...
 
void FootprintLibOptions (PROPERTIES *aProperties) const override
 Function FootprintLibOptions appends supported PLUGIN options to aListToAppenTo along with internationalized descriptions. More...
 
 EAGLE_PLUGIN ()
 
 ~EAGLE_PLUGIN ()
 
virtual void Save (const wxString &aFileName, BOARD *aBoard, const PROPERTIES *aProperties=NULL)
 Function Save will write aBoard to a storage file in a format that this PLUGIN implementation knows about, or it can be used to write a portion of aBoard to a special kind of export file. More...
 
virtual void PrefetchLib (const wxString &aLibraryPath, const PROPERTIES *aProperties=NULL)
 Function PrefetchLib If possible, prefetches the specified library (e.g. More...
 
virtual const MODULEGetEnumeratedFootprint (const wxString &aLibraryPath, const wxString &aFootprintName, const PROPERTIES *aProperties=NULL)
 Function GetEnumeratedFootprint a version of FootprintLoad() for use after FootprintEnumerate() for more efficient cache management. More...
 
virtual void FootprintSave (const wxString &aLibraryPath, const MODULE *aFootprint, const PROPERTIES *aProperties=NULL)
 Function FootprintSave will write aModule to an existing library located at aLibraryPath. More...
 
virtual void FootprintDelete (const wxString &aLibraryPath, const wxString &aFootprintName, const PROPERTIES *aProperties=NULL)
 Function FootprintDelete deletes aFootprintName from the library at aLibraryPath. More...
 
virtual void FootprintLibCreate (const wxString &aLibraryPath, const PROPERTIES *aProperties=NULL)
 Function FootprintLibCreate creates a new empty footprint library at aLibraryPath empty. More...
 
virtual bool FootprintLibDelete (const wxString &aLibraryPath, const PROPERTIES *aProperties=NULL)
 Function FootprintLibDelete deletes an existing footprint library and returns true, or if library does not exist returns false, or throws an exception if library exists but is read only or cannot be deleted for some other reason. More...
 

Private Types

typedef std::vector< ELAYERELAYERS
 
typedef ELAYERS::const_iterator EITER
 

Private Member Functions

void init (const PROPERTIES *aProperties)
 initialize PLUGIN like a constructor would, and futz with fresh BOARD if needed. More...
 
void clear_cu_map ()
 
int kicad_y (const ECOORD &y) const
 Convert an Eagle distance to a KiCad distance. More...
 
int kicad_x (const ECOORD &x) const
 
wxSize kicad_fontz (const ECOORD &d) const
 create a font size (fontz) from an eagle font size scalar More...
 
PCB_LAYER_ID kicad_layer (int aLayer) const
 Convert an Eagle layer to a KiCad layer. More...
 
const wxString & eagle_layer_name (int aLayer) const
 Get Eagle layer name by its number. More...
 
void cacheLib (const wxString &aLibraryPath)
 This PLUGIN only caches one footprint library, this determines which one. More...
 
void loadAllSections (wxXmlNode *aDocument)
 
void loadDesignRules (wxXmlNode *aDesignRules)
 
void loadLayerDefs (wxXmlNode *aLayers)
 
void loadPlain (wxXmlNode *aPlain)
 
void loadSignals (wxXmlNode *aSignals)
 
void loadLibrary (wxXmlNode *aLib, const wxString *aLibName)
 Function loadLibrary loads the Eagle "library" XML element, which can occur either under a "libraries" element (if a *.brd file) or under a "drawing" element if a *.lbr file. More...
 
void loadLibraries (wxXmlNode *aLibs)
 
void loadElements (wxXmlNode *aElements)
 
ZONE_CONTAINERloadPolygon (wxXmlNode *aPolyNode)
 Loads a copper or keepout polygon and adds it to the board. More...
 
void orientModuleAndText (MODULE *m, const EELEMENT &e, const EATTR *nameAttr, const EATTR *valueAttr)
 
void orientModuleText (MODULE *m, const EELEMENT &e, TEXTE_MODULE *txt, const EATTR *a)
 
void centerBoard ()
 move the BOARD into the center of the page More...
 
wxString fmtDEG (double aAngle) const
 Function fmtDEG formats an angle in a way particular to a board file format. More...
 
MODULEmakeModule (wxXmlNode *aPackage, const wxString &aPkgName) const
 Function makeModule creates a MODULE from an Eagle package. More...
 
void packageWire (MODULE *aModule, wxXmlNode *aTree) const
 
void packagePad (MODULE *aModule, wxXmlNode *aTree) const
 
void packageText (MODULE *aModule, wxXmlNode *aTree) const
 
void packageRectangle (MODULE *aModule, wxXmlNode *aTree) const
 
void packagePolygon (MODULE *aModule, wxXmlNode *aTree) const
 
void packageCircle (MODULE *aModule, wxXmlNode *aTree) const
 
void packageHole (MODULE *aModule, wxXmlNode *aTree, bool aCenter) const
 Function packageHole @parameter aModule - The KiCad module to which to assign the hole @parameter aTree - The Eagle XML node that is of type "hole" @parameter aCenter - If true, center the hole in the module and offset the module position. More...
 
void packageSMD (MODULE *aModule, wxXmlNode *aTree) const
 
void transferPad (const EPAD_COMMON &aEaglePad, D_PAD *aPad) const
 

Handles common pad properties

More...
 
void deleteTemplates ()
 

Deletes the footprint templates list

More...
 

Static Private Member Functions

static wxDateTime getModificationTime (const wxString &aPath)
 get a file's or dir's modification time. More...
 

Private Attributes

int m_cu_map [17]
 map eagle to kicad, cu layers only. More...
 
std::map< int, ELAYERm_eagleLayers
 Eagle layers data stored by the layer number. More...
 
ERULESm_rules
 Eagle design rules. More...
 
XPATHm_xpath
 keeps track of what we are working on within XML document during a Load(). More...
 
int m_hole_count
 generates unique module names from eagle "hole"s. More...
 
NET_MAP m_pads_to_nets
 net list More...
 
MODULE_MAP m_templates
 is part of a MODULE factory that operates using copy construction. More...
 
const PROPERTIESm_props
 passed via Save() or Load(), no ownership, may be NULL. More...
 
BOARDm_board
 which BOARD is being worked on, no ownership here More...
 
int m_min_trace
 smallest trace we find on Load(), in BIU. More...
 
int m_min_via
 smallest via we find on Load(), in BIU. More...
 
int m_min_via_hole
 smallest via diameter hole we find on Load(), in BIU. More...
 
wxString m_lib_path
 
wxDateTime m_mod_time
 

Detailed Description

Class EAGLE_PLUGIN works with Eagle 6.x XML board files and footprints to implement the Pcbnew PLUGIN API, or a portion of it.

Definition at line 117 of file eagle_plugin.h.

Member Typedef Documentation

◆ BIU

typedef int EAGLE_PLUGIN::BIU

Definition at line 161 of file eagle_plugin.h.

◆ EITER

typedef ELAYERS::const_iterator EAGLE_PLUGIN::EITER
private

Definition at line 168 of file eagle_plugin.h.

◆ ELAYERS

typedef std::vector<ELAYER> EAGLE_PLUGIN::ELAYERS
private

Definition at line 167 of file eagle_plugin.h.

Constructor & Destructor Documentation

◆ EAGLE_PLUGIN()

EAGLE_PLUGIN::EAGLE_PLUGIN ( )

Definition at line 182 of file eagle_plugin.cpp.

182  :
183  m_rules( new ERULES() ),
184  m_xpath( new XPATH() ),
185  m_mod_time( wxDateTime::Now() )
186 {
187  init( NULL );
188  clear_cu_map();
189 }
void clear_cu_map()
ERULES * m_rules
Eagle design rules.
Definition: eagle_plugin.h:173
Class XPATH keeps track of what we are working on within a PTREE.
Definition: eagle_parser.h:112
void init(const PROPERTIES *aProperties)
initialize PLUGIN like a constructor would, and futz with fresh BOARD if needed.
XPATH * m_xpath
keeps track of what we are working on within XML document during a Load().
Definition: eagle_plugin.h:174
subset of eagle.drawing.board.designrules in the XML document
Definition: eagle_plugin.h:45
wxDateTime m_mod_time
Definition: eagle_plugin.h:194

References clear_cu_map(), and init().

◆ ~EAGLE_PLUGIN()

EAGLE_PLUGIN::~EAGLE_PLUGIN ( )

Definition at line 192 of file eagle_plugin.cpp.

193 {
194  deleteTemplates();
195  delete m_rules;
196  delete m_xpath;
197 }
ERULES * m_rules
Eagle design rules.
Definition: eagle_plugin.h:173
XPATH * m_xpath
keeps track of what we are working on within XML document during a Load().
Definition: eagle_plugin.h:174
void deleteTemplates()
Deletes the footprint templates list

References deleteTemplates(), m_rules, and m_xpath.

Member Function Documentation

◆ cacheLib()

void EAGLE_PLUGIN::cacheLib ( const wxString &  aLibraryPath)
private

This PLUGIN only caches one footprint library, this determines which one.

Definition at line 2300 of file eagle_plugin.cpp.

2301 {
2302  try
2303  {
2304  wxDateTime modtime = getModificationTime( aLibPath );
2305 
2306  // Fixes assertions in wxWidgets debug builds for the wxDateTime object. Refresh the
2307  // cache if either of the wxDateTime objects are invalid or the last file modification
2308  // time differs from the current file modification time.
2309  bool load = !m_mod_time.IsValid() || !modtime.IsValid() || m_mod_time != modtime;
2310 
2311  if( aLibPath != m_lib_path || load )
2312  {
2313  wxXmlNode* doc;
2314  LOCALE_IO toggle; // toggles on, then off, the C locale.
2315 
2316  deleteTemplates();
2317 
2318  // Set this before completion of loading, since we rely on it for
2319  // text of an exception. Delay setting m_mod_time until after successful load
2320  // however.
2321  m_lib_path = aLibPath;
2322 
2323  // 8 bit "filename" should be encoded according to disk filename encoding,
2324  // (maybe this is current locale, maybe not, its a filesystem issue),
2325  // and is not necessarily utf8.
2326  string filename = (const char*) aLibPath.char_str( wxConvFile );
2327 
2328  // Load the document
2329  wxXmlDocument xmlDocument;
2330  wxFileName fn( filename );
2331 
2332  if( !xmlDocument.Load( fn.GetFullPath() ) )
2333  THROW_IO_ERROR( wxString::Format( _( "Unable to read file \"%s\"" ),
2334  fn.GetFullPath() ) );
2335 
2336  doc = xmlDocument.GetRoot();
2337 
2338  wxXmlNode* drawing = MapChildren( doc )["drawing"];
2339  NODE_MAP drawingChildren = MapChildren( drawing );
2340 
2341  // clear the cu map and then rebuild it.
2342  clear_cu_map();
2343 
2344  m_xpath->push( "eagle.drawing.layers" );
2345  wxXmlNode* layers = drawingChildren["layers"];
2346  loadLayerDefs( layers );
2347  m_xpath->pop();
2348 
2349  m_xpath->push( "eagle.drawing.library" );
2350  wxXmlNode* library = drawingChildren["library"];
2351  loadLibrary( library, NULL );
2352  m_xpath->pop();
2353 
2354  m_mod_time = modtime;
2355  }
2356  }
2357  catch(...){}
2358  // TODO: Handle exceptions
2359  // catch( file_parser_error fpe )
2360  // {
2361  // // for xml_parser_error, what() has the line number in it,
2362  // // but no byte offset. That should be an adequate error message.
2363  // THROW_IO_ERROR( fpe.what() );
2364  // }
2365  //
2366  // // Class ptree_error is a base class for xml_parser_error & file_parser_error,
2367  // // so one catch should be OK for all errors.
2368  // catch( ptree_error pte )
2369  // {
2370  // string errmsg = pte.what();
2371  //
2372  // errmsg += " @\n";
2373  // errmsg += m_xpath->Contents();
2374  //
2375  // THROW_IO_ERROR( errmsg );
2376  // }
2377 }
void clear_cu_map()
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: common.h:180
void push(const char *aPathSegment, const char *aAttribute="")
Definition: eagle_parser.h:117
void loadLayerDefs(wxXmlNode *aLayers)
NODE_MAP MapChildren(wxXmlNode *aCurrentNode)
Function MapChildren provides an easy access to the children of an XML node via their names.
XPATH * m_xpath
keeps track of what we are working on within XML document during a Load().
Definition: eagle_plugin.h:174
wxString m_lib_path
Definition: eagle_plugin.h:193
#define THROW_IO_ERROR(msg)
static wxDateTime getModificationTime(const wxString &aPath)
get a file's or dir's modification time.
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
wxDateTime m_mod_time
Definition: eagle_plugin.h:194
void loadLibrary(wxXmlNode *aLib, const wxString *aLibName)
Function loadLibrary loads the Eagle "library" XML element, which can occur either under a "libraries...
void deleteTemplates()
Deletes the footprint templates list
void pop()
Definition: eagle_parser.h:124
std::unordered_map< wxString, wxXmlNode * > NODE_MAP
Definition: eagle_parser.h:48

References clear_cu_map(), deleteTemplates(), Format(), getModificationTime(), loadLayerDefs(), loadLibrary(), m_lib_path, m_mod_time, m_xpath, MapChildren(), XPATH::pop(), XPATH::push(), and THROW_IO_ERROR.

Referenced by FootprintEnumerate(), and FootprintLoad().

◆ centerBoard()

void EAGLE_PLUGIN::centerBoard ( )
private

move the BOARD into the center of the page

Definition at line 2258 of file eagle_plugin.cpp.

2259 {
2260  if( m_props )
2261  {
2262  UTF8 page_width;
2263  UTF8 page_height;
2264 
2265  if( m_props->Value( "page_width", &page_width ) &&
2266  m_props->Value( "page_height", &page_height ) )
2267  {
2269 
2270  int w = atoi( page_width.c_str() );
2271  int h = atoi( page_height.c_str() );
2272 
2273  int desired_x = ( w - bbbox.GetWidth() ) / 2;
2274  int desired_y = ( h - bbbox.GetHeight() ) / 2;
2275 
2276  DBG(printf( "bbox.width:%d bbox.height:%d w:%d h:%d desired_x:%d desired_y:%d\n",
2277  bbbox.GetWidth(), bbbox.GetHeight(), w, h, desired_x, desired_y );)
2278 
2279  m_board->Move( wxPoint( desired_x - bbbox.GetX(), desired_y - bbbox.GetY() ) );
2280  }
2281  }
2282 }
Class UTF8 is an 8 bit string that is assuredly encoded in UTF8, and supplies special conversion supp...
Definition: utf8.h:73
BOARD * m_board
which BOARD is being worked on, no ownership here
Definition: eagle_plugin.h:187
int GetX() const
Definition: eda_rect.h:109
const EDA_RECT GetBoardEdgesBoundingBox() const
Function GetBoardEdgesBoundingBox Returns the board bounding box calculated using exclusively the boa...
Definition: class_board.h:810
int GetWidth() const
Definition: eda_rect.h:117
const char * c_str() const
Definition: utf8.h:107
const PROPERTIES * m_props
passed via Save() or Load(), no ownership, may be NULL.
Definition: eagle_plugin.h:186
int GetHeight() const
Definition: eda_rect.h:118
void Move(const wxPoint &aMoveVector) override
Function Move move this object.
Class EDA_RECT handles the component boundary box.
Definition: eda_rect.h:44
int GetY() const
Definition: eda_rect.h:110
#define DBG(x)
Definition: fctsys.h:33
bool Value(const char *aName, UTF8 *aFetchedValue=NULL) const
Function Value fetches a property by aName and returns true if that property was found,...
Definition: properties.cpp:24

References UTF8::c_str(), DBG, BOARD::GetBoardEdgesBoundingBox(), EDA_RECT::GetHeight(), EDA_RECT::GetWidth(), EDA_RECT::GetX(), EDA_RECT::GetY(), m_board, m_props, BOARD::Move(), and PROPERTIES::Value().

Referenced by Load().

◆ clear_cu_map()

void EAGLE_PLUGIN::clear_cu_map ( )
private

Definition at line 326 of file eagle_plugin.cpp.

327 {
328  // All cu layers are invalid until we see them in the <layers> section while
329  // loading either a board or library. See loadLayerDefs().
330  for( unsigned i = 0; i < arrayDim(m_cu_map); ++i )
331  m_cu_map[i] = -1;
332 }
int m_cu_map[17]
map eagle to kicad, cu layers only.
Definition: eagle_plugin.h:170
constexpr std::size_t arrayDim(T const (&)[N]) noexcept
Definition: macros.h:99
size_t i
Definition: json11.cpp:597

References arrayDim(), i, and m_cu_map.

Referenced by cacheLib(), and EAGLE_PLUGIN().

◆ deleteTemplates()

void EAGLE_PLUGIN::deleteTemplates ( )
private

Deletes the footprint templates list

Definition at line 1935 of file eagle_plugin.cpp.

1936 {
1937  for( auto& t : m_templates )
1938  delete t.second;
1939 
1940  m_templates.clear();
1941 }
MODULE_MAP m_templates
is part of a MODULE factory that operates using copy construction.
Definition: eagle_plugin.h:181

References m_templates.

Referenced by cacheLib(), and ~EAGLE_PLUGIN().

◆ eagle_layer_name()

const wxString & EAGLE_PLUGIN::eagle_layer_name ( int  aLayer) const
private

Get Eagle layer name by its number.

Definition at line 2250 of file eagle_plugin.cpp.

2251 {
2252  static const wxString unknown( "unknown" );
2253  auto it = m_eagleLayers.find( aLayer );
2254  return it == m_eagleLayers.end() ? unknown : it->second.name;
2255 }
std::map< int, ELAYER > m_eagleLayers
Eagle layers data stored by the layer number.
Definition: eagle_plugin.h:171

References m_eagleLayers.

Referenced by kicad_layer().

◆ fmtDEG()

wxString EAGLE_PLUGIN::fmtDEG ( double  aAngle) const
private

Function fmtDEG formats an angle in a way particular to a board file format.

This function is the opposite or complement of degParse(). One has to know what the other is doing.

◆ FootprintDelete()

void PLUGIN::FootprintDelete ( const wxString &  aLibraryPath,
const wxString &  aFootprintName,
const PROPERTIES aProperties = NULL 
)
virtualinherited

Function FootprintDelete deletes aFootprintName from the library at aLibraryPath.

Parameters
aLibraryPathis a locator for the "library", usually a directory, file, or URL containing several footprints.
aFootprintNameis the name of a footprint to delete from the specified library.
aPropertiesis an associative array that can be used to tell the library delete function anything special, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.
Exceptions
IO_ERRORif there is a problem finding the footprint or the library, or deleting it.

Reimplemented in GITHUB_PLUGIN, PCB_IO, and GPCB_PLUGIN.

Definition at line 101 of file plugin.cpp.

103 {
104  // not pure virtual so that plugins only have to implement subset of the PLUGIN interface.
105  not_implemented( this, __FUNCTION__ );
106 }
static void not_implemented(PLUGIN *aPlugin, const char *aCaller)
Function not_implemented throws an IO_ERROR and complains of an API function not being implemented.
Definition: plugin.cpp:38

References not_implemented().

◆ FootprintEnumerate()

void EAGLE_PLUGIN::FootprintEnumerate ( wxArrayString &  aFootprintNames,
const wxString &  aLibraryPath,
const PROPERTIES aProperties = NULL 
)
overridevirtual

Return a list of footprint names contained within the library at aLibraryPath.

Parameters
aLibraryPathis a locator for the "library", usually a directory, file, or URL containing several footprints.
aPropertiesis an associative array that can be used to tell the plugin anything needed about how to perform with respect to aLibraryPath. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.
aFootprintNamesis the array of available footprint names inside a library.
Exceptions
IO_ERRORif the library cannot be found, or footprint cannot be loaded.

Reimplemented from PLUGIN.

Definition at line 2380 of file eagle_plugin.cpp.

2382 {
2383  init( aProperties );
2384 
2385  cacheLib( aLibraryPath );
2386 
2387  for( MODULE_CITER it = m_templates.begin(); it != m_templates.end(); ++it )
2388  aFootprintNames.Add( FROM_UTF8( it->first.c_str() ) );
2389 }
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes.
Definition: macros.h:53
void init(const PROPERTIES *aProperties)
initialize PLUGIN like a constructor would, and futz with fresh BOARD if needed.
void cacheLib(const wxString &aLibraryPath)
This PLUGIN only caches one footprint library, this determines which one.
MODULE_MAP::const_iterator MODULE_CITER
MODULE_MAP m_templates
is part of a MODULE factory that operates using copy construction.
Definition: eagle_plugin.h:181

References cacheLib(), FROM_UTF8(), init(), and m_templates.

◆ FootprintLibCreate()

void PLUGIN::FootprintLibCreate ( const wxString &  aLibraryPath,
const PROPERTIES aProperties = NULL 
)
virtualinherited

Function FootprintLibCreate creates a new empty footprint library at aLibraryPath empty.

It is an error to attempt to create an existing library or to attempt to create on a "read only" location.

Parameters
aLibraryPathis a locator for the "library", usually a directory, file, or URL containing several footprints.
aPropertiesis an associative array that can be used to tell the library create function anything special, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.
Exceptions
IO_ERRORif there is a problem finding the library, or creating it.

Reimplemented in GITHUB_PLUGIN, and PCB_IO.

Definition at line 109 of file plugin.cpp.

110 {
111  // not pure virtual so that plugins only have to implement subset of the PLUGIN interface.
112  not_implemented( this, __FUNCTION__ );
113 }
static void not_implemented(PLUGIN *aPlugin, const char *aCaller)
Function not_implemented throws an IO_ERROR and complains of an API function not being implemented.
Definition: plugin.cpp:38

References not_implemented().

◆ FootprintLibDelete()

bool PLUGIN::FootprintLibDelete ( const wxString &  aLibraryPath,
const PROPERTIES aProperties = NULL 
)
virtualinherited

Function FootprintLibDelete deletes an existing footprint library and returns true, or if library does not exist returns false, or throws an exception if library exists but is read only or cannot be deleted for some other reason.

Parameters
aLibraryPathis a locator for the "library", usually a directory or file which will contain footprints.
aPropertiesis an associative array that can be used to tell the library delete implementation function anything special, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.
Returns
bool - true if library deleted, false if library did not exist.
Exceptions
IO_ERRORif there is a problem deleting an existing library.

Reimplemented in GITHUB_PLUGIN, PCB_IO, LEGACY_PLUGIN, and GPCB_PLUGIN.

Definition at line 116 of file plugin.cpp.

117 {
118  // not pure virtual so that plugins only have to implement subset of the PLUGIN interface.
119  not_implemented( this, __FUNCTION__ );
120  return false;
121 }
static void not_implemented(PLUGIN *aPlugin, const char *aCaller)
Function not_implemented throws an IO_ERROR and complains of an API function not being implemented.
Definition: plugin.cpp:38

References not_implemented().

◆ FootprintLibOptions()

void EAGLE_PLUGIN::FootprintLibOptions ( PROPERTIES aListToAppendTo) const
overridevirtual

Function FootprintLibOptions appends supported PLUGIN options to aListToAppenTo along with internationalized descriptions.

Options are typically appended so that a derived PLUGIN can call its base class function by the same name first, thus inheriting options declared there. (Some base class options could pertain to all Footprint*() functions in all derived PLUGINs.) Note that since aListToAppendTo is a PROPERTIES object, all options will be unique and last guy wins.

Parameters
aListToAppendToholds a tuple of
option
This eventually is what shows up into the fp-lib-table "options" field, possibly combined with others.
internationalized description
The internationalized description is displayed in DIALOG_FP_PLUGIN_OPTIONS. It may be multi-line and be quite explanatory of the option.

In the future perhaps aListToAppendTo evolves to something capable of also holding a wxValidator for the cells in said dialog: http://forums.wxwidgets.org/viewtopic.php?t=23277&p=104180. This would require a 3 column list, and introducing wx GUI knowledge to PLUGIN, which has been avoided to date.

Reimplemented from PLUGIN.

Definition at line 2409 of file eagle_plugin.cpp.

2410 {
2411  PLUGIN::FootprintLibOptions( aListToAppendTo );
2412 
2413  /*
2414  (*aListToAppendTo)["ignore_duplicates"] = UTF8( _(
2415  "Ignore duplicately named footprints within the same Eagle library. "
2416  "Only the first similarly named footprint will be loaded."
2417  ));
2418  */
2419 }
virtual void FootprintLibOptions(PROPERTIES *aListToAppendTo) const
Function FootprintLibOptions appends supported PLUGIN options to aListToAppenTo along with internatio...
Definition: plugin.cpp:132

References PLUGIN::FootprintLibOptions().

◆ FootprintLoad()

MODULE * EAGLE_PLUGIN::FootprintLoad ( const wxString &  aLibraryPath,
const wxString &  aFootprintName,
const PROPERTIES aProperties = NULL 
)
overridevirtual

Function FootprintLoad loads a footprint having aFootprintName from the aLibraryPath containing a library format that this PLUGIN knows about.

Parameters
aLibraryPathis a locator for the "library", usually a directory, file, or URL containing several footprints.
aFootprintNameis the name of the footprint to load.
aPropertiesis an associative array that can be used to tell the loader implementation to do something special, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.
Returns
MODULE* - if found caller owns it, else NULL if not found.
Exceptions
IO_ERRORif the library cannot be found or read. No exception is thrown in the case where aFootprintName cannot be found.

Reimplemented from PLUGIN.

Definition at line 2392 of file eagle_plugin.cpp.

2394 {
2395  init( aProperties );
2396  cacheLib( aLibraryPath );
2397  MODULE_CITER mi = m_templates.find( aFootprintName );
2398 
2399  if( mi == m_templates.end() )
2400  return NULL;
2401 
2402  // copy constructor to clone the template
2403  MODULE* ret = new MODULE( *mi->second );
2404 
2405  return ret;
2406 }
void init(const PROPERTIES *aProperties)
initialize PLUGIN like a constructor would, and futz with fresh BOARD if needed.
void cacheLib(const wxString &aLibraryPath)
This PLUGIN only caches one footprint library, this determines which one.
MODULE_MAP::const_iterator MODULE_CITER
MODULE_MAP m_templates
is part of a MODULE factory that operates using copy construction.
Definition: eagle_plugin.h:181

References cacheLib(), init(), and m_templates.

◆ FootprintSave()

void PLUGIN::FootprintSave ( const wxString &  aLibraryPath,
const MODULE aFootprint,
const PROPERTIES aProperties = NULL 
)
virtualinherited

Function FootprintSave will write aModule to an existing library located at aLibraryPath.

If a footprint by the same name already exists, it is replaced.

Parameters
aLibraryPathis a locator for the "library", usually a directory, file, or URL containing several footprints.
aFootprintis what to store in the library. The caller continues to own the footprint after this call.
aPropertiesis an associative array that can be used to tell the saver how to save the footprint, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.
Exceptions
IO_ERRORif there is a problem saving.

Reimplemented in GITHUB_PLUGIN, and PCB_IO.

Definition at line 93 of file plugin.cpp.

95 {
96  // not pure virtual so that plugins only have to implement subset of the PLUGIN interface.
97  not_implemented( this, __FUNCTION__ );
98 }
static void not_implemented(PLUGIN *aPlugin, const char *aCaller)
Function not_implemented throws an IO_ERROR and complains of an API function not being implemented.
Definition: plugin.cpp:38

References not_implemented().

◆ GetEnumeratedFootprint()

const MODULE * PLUGIN::GetEnumeratedFootprint ( const wxString &  aLibraryPath,
const wxString &  aFootprintName,
const PROPERTIES aProperties = NULL 
)
virtualinherited

Function GetEnumeratedFootprint a version of FootprintLoad() for use after FootprintEnumerate() for more efficient cache management.

Reimplemented in PCB_IO, and GPCB_PLUGIN.

Definition at line 75 of file plugin.cpp.

78 {
79  // default implementation
80  return FootprintLoad( aLibraryPath, aFootprintName, aProperties );
81 }
virtual MODULE * FootprintLoad(const wxString &aLibraryPath, const wxString &aFootprintName, const PROPERTIES *aProperties=NULL)
Function FootprintLoad loads a footprint having aFootprintName from the aLibraryPath containing a lib...
Definition: plugin.cpp:84

References PLUGIN::FootprintLoad().

◆ GetFileExtension()

const wxString EAGLE_PLUGIN::GetFileExtension ( ) const
overridevirtual

Function GetFileExtension returns the file extension for the PLUGIN.

Implements PLUGIN.

Definition at line 206 of file eagle_plugin.cpp.

207 {
208  return wxT( "brd" );
209 }

◆ GetLibraryTimestamp()

long long EAGLE_PLUGIN::GetLibraryTimestamp ( const wxString &  aLibraryPath) const
inlineoverridevirtual

Generate a timestamp representing all the files in the library (including the library directory).

Timestamps should not be considered ordered; they either match or they don't.

Implements PLUGIN.

Definition at line 135 of file eagle_plugin.h.

136  {
137  return getModificationTime( aLibraryPath ).GetValue().GetValue();
138  }
static wxDateTime getModificationTime(const wxString &aPath)
get a file's or dir's modification time.

References getModificationTime().

◆ getModificationTime()

wxDateTime EAGLE_PLUGIN::getModificationTime ( const wxString &  aPath)
staticprivate

get a file's or dir's modification time.

Definition at line 2285 of file eagle_plugin.cpp.

2286 {
2287  // File hasn't been loaded yet.
2288  if( aPath.IsEmpty() )
2289  return wxDateTime::Now();
2290 
2291  wxFileName fn( aPath );
2292 
2293  if( fn.IsFileReadable() )
2294  return fn.GetModificationTime();
2295  else
2296  return wxDateTime( 0.0 );
2297 }

Referenced by cacheLib(), and GetLibraryTimestamp().

◆ init()

void EAGLE_PLUGIN::init ( const PROPERTIES aProperties)
private

initialize PLUGIN like a constructor would, and futz with fresh BOARD if needed.

Definition at line 308 of file eagle_plugin.cpp.

309 {
310  m_hole_count = 0;
311  m_min_trace = 0;
312  m_min_via = 0;
313  m_min_via_hole = 0;
314  m_xpath->clear();
315  m_pads_to_nets.clear();
316 
317  m_board = NULL;
318  m_props = aProperties;
319 
320 
321  delete m_rules;
322  m_rules = new ERULES();
323 }
BOARD * m_board
which BOARD is being worked on, no ownership here
Definition: eagle_plugin.h:187
void clear()
Definition: eagle_parser.h:122
ERULES * m_rules
Eagle design rules.
Definition: eagle_plugin.h:173
int m_min_via
smallest via we find on Load(), in BIU.
Definition: eagle_plugin.h:190
XPATH * m_xpath
keeps track of what we are working on within XML document during a Load().
Definition: eagle_plugin.h:174
int m_min_via_hole
smallest via diameter hole we find on Load(), in BIU.
Definition: eagle_plugin.h:191
const PROPERTIES * m_props
passed via Save() or Load(), no ownership, may be NULL.
Definition: eagle_plugin.h:186
subset of eagle.drawing.board.designrules in the XML document
Definition: eagle_plugin.h:45
int m_min_trace
smallest trace we find on Load(), in BIU.
Definition: eagle_plugin.h:189
int m_hole_count
generates unique module names from eagle "hole"s.
Definition: eagle_plugin.h:177
NET_MAP m_pads_to_nets
net list
Definition: eagle_plugin.h:179

References XPATH::clear(), m_board, m_hole_count, m_min_trace, m_min_via, m_min_via_hole, m_pads_to_nets, m_props, m_rules, and m_xpath.

Referenced by EAGLE_PLUGIN(), FootprintEnumerate(), FootprintLoad(), and Load().

◆ IsFootprintLibWritable()

bool EAGLE_PLUGIN::IsFootprintLibWritable ( const wxString &  aLibraryPath)
inlineoverridevirtual

Function IsFootprintLibWritable returns true iff the library at aLibraryPath is writable.

(Often system libraries are read only because of where they are installed.)

Parameters
aLibraryPathis a locator for the "library", usually a directory, file, or URL containing several footprints.
Exceptions
IO_ERRORif no library at aLibraryPath exists.

Reimplemented from PLUGIN.

Definition at line 140 of file eagle_plugin.h.

141  {
142  return false; // until someone writes others like FootprintSave(), etc.
143  }

◆ kicad_fontz()

wxSize EAGLE_PLUGIN::kicad_fontz ( const ECOORD d) const
inlineprivate

create a font size (fontz) from an eagle font size scalar

Definition at line 212 of file eagle_plugin.cpp.

213 {
214  // texts seem to better match eagle when scaled down by 0.95
215  int kz = d.ToPcbUnits() * 95 / 100;
216  return wxSize( kz, kz );
217 }
int ToPcbUnits() const
Definition: eagle_parser.h:439

References ECOORD::ToPcbUnits().

Referenced by loadPlain(), orientModuleText(), and packageText().

◆ kicad_layer()

PCB_LAYER_ID EAGLE_PLUGIN::kicad_layer ( int  aLayer) const
private

Convert an Eagle layer to a KiCad layer.

Definition at line 2181 of file eagle_plugin.cpp.

2182 {
2183  int kiLayer;
2184 
2185  // eagle copper layer:
2186  if( aEagleLayer >= 1 && aEagleLayer < int( arrayDim( m_cu_map ) ) )
2187  {
2188  kiLayer = m_cu_map[aEagleLayer];
2189  }
2190 
2191  else
2192  {
2193  // translate non-copper eagle layer to pcbnew layer
2194  switch( aEagleLayer )
2195  {
2196  // Eagle says "Dimension" layer, but it's for board perimeter
2197  case EAGLE_LAYER::MILLING: kiLayer = Edge_Cuts; break;
2198  case EAGLE_LAYER::DIMENSION: kiLayer = Edge_Cuts; break;
2199 
2200  case EAGLE_LAYER::TPLACE: kiLayer = F_SilkS; break;
2201  case EAGLE_LAYER::BPLACE: kiLayer = B_SilkS; break;
2202  case EAGLE_LAYER::TNAMES: kiLayer = F_SilkS; break;
2203  case EAGLE_LAYER::BNAMES: kiLayer = B_SilkS; break;
2204  case EAGLE_LAYER::TVALUES: kiLayer = F_Fab; break;
2205  case EAGLE_LAYER::BVALUES: kiLayer = B_Fab; break;
2206  case EAGLE_LAYER::TSTOP: kiLayer = F_Mask; break;
2207  case EAGLE_LAYER::BSTOP: kiLayer = B_Mask; break;
2208  case EAGLE_LAYER::TCREAM: kiLayer = F_Paste; break;
2209  case EAGLE_LAYER::BCREAM: kiLayer = B_Paste; break;
2210  case EAGLE_LAYER::TFINISH: kiLayer = F_Mask; break;
2211  case EAGLE_LAYER::BFINISH: kiLayer = B_Mask; break;
2212  case EAGLE_LAYER::TGLUE: kiLayer = F_Adhes; break;
2213  case EAGLE_LAYER::BGLUE: kiLayer = B_Adhes; break;
2214  case EAGLE_LAYER::DOCUMENT: kiLayer = Cmts_User; break;
2215  case EAGLE_LAYER::REFERENCELC: kiLayer = Cmts_User; break;
2216  case EAGLE_LAYER::REFERENCELS: kiLayer = Cmts_User; break;
2217 
2218  // Packages show the future chip pins on SMD parts using layer 51.
2219  // This is an area slightly smaller than the PAD/SMD copper area.
2220  // Carry those visual aids into the MODULE on the fabrication layer,
2221  // not silkscreen. This is perhaps not perfect, but there is not a lot
2222  // of other suitable paired layers
2223  case EAGLE_LAYER::TDOCU: kiLayer = F_Fab; break;
2224  case EAGLE_LAYER::BDOCU: kiLayer = B_Fab; break;
2225 
2226  // thes layers are defined as user layers. put them on ECO layers
2227  case EAGLE_LAYER::USERLAYER1: kiLayer = Eco1_User; break;
2228  case EAGLE_LAYER::USERLAYER2: kiLayer = Eco2_User; break;
2229 
2230  case EAGLE_LAYER::UNROUTED:
2231  case EAGLE_LAYER::TKEEPOUT:
2232  case EAGLE_LAYER::BKEEPOUT:
2233  case EAGLE_LAYER::TTEST:
2234  case EAGLE_LAYER::BTEST:
2235  case EAGLE_LAYER::HOLES:
2236  default:
2237  // some layers do not map to KiCad
2238  wxLogMessage( wxString::Format( _( "Unsupported Eagle layer '%s' (%d), converted to Dwgs.User layer" ),
2239  eagle_layer_name( aEagleLayer ), aEagleLayer ) );
2240 
2241  kiLayer = Dwgs_User;
2242  break;
2243  }
2244  }
2245 
2246  return PCB_LAYER_ID( kiLayer );
2247 }
const wxString & eagle_layer_name(int aLayer) const
Get Eagle layer name by its number.
int m_cu_map[17]
map eagle to kicad, cu layers only.
Definition: eagle_plugin.h:170
PCB_LAYER_ID
A quick note on layer IDs:
constexpr std::size_t arrayDim(T const (&)[N]) noexcept
Definition: macros.h:99
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205

References arrayDim(), B_Adhes, B_Fab, B_Mask, B_Paste, B_SilkS, EAGLE_LAYER::BCREAM, EAGLE_LAYER::BDOCU, EAGLE_LAYER::BFINISH, EAGLE_LAYER::BGLUE, EAGLE_LAYER::BKEEPOUT, EAGLE_LAYER::BNAMES, EAGLE_LAYER::BPLACE, EAGLE_LAYER::BSTOP, EAGLE_LAYER::BTEST, EAGLE_LAYER::BVALUES, Cmts_User, EAGLE_LAYER::DIMENSION, EAGLE_LAYER::DOCUMENT, Dwgs_User, eagle_layer_name(), Eco1_User, Eco2_User, Edge_Cuts, F_Adhes, F_Fab, F_Mask, F_Paste, F_SilkS, Format(), EAGLE_LAYER::HOLES, m_cu_map, EAGLE_LAYER::MILLING, EAGLE_LAYER::REFERENCELC, EAGLE_LAYER::REFERENCELS, EAGLE_LAYER::TCREAM, EAGLE_LAYER::TDOCU, EAGLE_LAYER::TFINISH, EAGLE_LAYER::TGLUE, EAGLE_LAYER::TKEEPOUT, EAGLE_LAYER::TNAMES, EAGLE_LAYER::TPLACE, EAGLE_LAYER::TSTOP, EAGLE_LAYER::TTEST, EAGLE_LAYER::TVALUES, EAGLE_LAYER::UNROUTED, EAGLE_LAYER::USERLAYER1, and EAGLE_LAYER::USERLAYER2.

Referenced by loadLayerDefs(), loadPlain(), loadPolygon(), loadSignals(), packageCircle(), packagePolygon(), packageRectangle(), packageSMD(), packageText(), and packageWire().

◆ kicad_x()

int EAGLE_PLUGIN::kicad_x ( const ECOORD x) const
inlineprivate

◆ kicad_y()

int EAGLE_PLUGIN::kicad_y ( const ECOORD y) const
inlineprivate

Convert an Eagle distance to a KiCad distance.

Definition at line 202 of file eagle_plugin.h.

202 { return -y.ToPcbUnits(); }
int ToPcbUnits() const
Definition: eagle_parser.h:439

References ECOORD::ToPcbUnits().

Referenced by loadElements(), loadPlain(), loadPolygon(), loadSignals(), orientModuleText(), packageCircle(), packageHole(), packagePolygon(), packageRectangle(), packageText(), packageWire(), and transferPad().

◆ Load()

BOARD * EAGLE_PLUGIN::Load ( const wxString &  aFileName,
BOARD aAppendToMe,
const PROPERTIES aProperties = NULL 
)
overridevirtual

Function Load loads information from some input file format that this PLUGIN implementation knows about, into either a new BOARD or an existing one.

This may be used to load an entire new BOARD, or to augment an existing one if aAppendToMe is not NULL.

Parameters
aFileNameis the name of the file to use as input and may be foreign in nature or native in nature.
aAppendToMeis an existing BOARD to append to, but if NULL then this means "do not append, rather load anew".
aPropertiesis an associative array that can be used to tell the loader how to load the file, because it can take any number of additional named arguments that the plugin is known to support. These are tuning parameters for the import or load. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.
Returns
BOARD* - the successfully loaded board, or the same one as aAppendToMe if aAppendToMe was not NULL, and caller owns it.
Exceptions
IO_ERRORif there is a problem loading, and its contents should say what went wrong, using line number and character offsets of the input file if possible.

Reimplemented from PLUGIN.

Definition at line 220 of file eagle_plugin.cpp.

221 {
222  LOCALE_IO toggle; // toggles on, then off, the C locale.
223  wxXmlNode* doc;
224 
225  init( aProperties );
226 
227  m_board = aAppendToMe ? aAppendToMe : new BOARD();
228 
229  // Give the filename to the board if it's new
230  if( !aAppendToMe )
231  m_board->SetFileName( aFileName );
232 
233  // delete on exception, if I own m_board, according to aAppendToMe
234  unique_ptr<BOARD> deleter( aAppendToMe ? NULL : m_board );
235 
236  try
237  {
238  // Load the document
239  wxXmlDocument xmlDocument;
240  wxFileName fn = aFileName;
241 
242  if( !xmlDocument.Load( fn.GetFullPath() ) )
243  THROW_IO_ERROR( wxString::Format( _( "Unable to read file \"%s\"" ),
244  fn.GetFullPath() ) );
245 
246  doc = xmlDocument.GetRoot();
247 
248  m_min_trace = INT_MAX;
249  m_min_via = INT_MAX;
250  m_min_via_hole = INT_MAX;
251 
252  loadAllSections( doc );
253 
254  BOARD_DESIGN_SETTINGS& designSettings = m_board->GetDesignSettings();
255 
256  if( m_min_trace < designSettings.m_TrackMinWidth )
257  designSettings.m_TrackMinWidth = m_min_trace;
258 
259  if( m_min_via < designSettings.m_ViasMinSize )
260  designSettings.m_ViasMinSize = m_min_via;
261 
262  if( m_min_via_hole < designSettings.m_ViasMinDrill )
263  designSettings.m_ViasMinDrill = m_min_via_hole;
264 
265  if( m_rules->mdWireWire )
266  {
267  NETCLASSPTR defaultNetclass = designSettings.GetDefault();
268  int clearance = KiROUND( m_rules->mdWireWire );
269 
270  if( clearance < defaultNetclass->GetClearance() )
271  defaultNetclass->SetClearance( clearance );
272  }
273 
274  // should be empty, else missing m_xpath->pop()
275  wxASSERT( m_xpath->Contents().size() == 0 );
276  }
277  // Catch all exceptions thrown from the parser.
278  catch( const XML_PARSER_ERROR &exc )
279  {
280  wxString errmsg = exc.what();
281 
282  errmsg += "\n@ ";
283  errmsg += m_xpath->Contents();
284 
285  THROW_IO_ERROR( errmsg );
286  }
287 
288  // IO_ERROR exceptions are left uncaught, they pass upwards from here.
289 
290  // Ensure the copper layers count is a multiple of 2
291  // Pcbnew does not like boards with odd layers count
292  // (these boards cannot exist. they actually have a even layers count)
293  int lyrcnt = m_board->GetCopperLayerCount();
294 
295  if( (lyrcnt % 2) != 0 )
296  {
297  lyrcnt++;
298  m_board->SetCopperLayerCount( lyrcnt );
299  }
300 
301  centerBoard();
302 
303  deleter.release();
304  return m_board;
305 }
wxString Contents()
return the contents of the XPATH as a single string
Definition: eagle_parser.h:139
void loadAllSections(wxXmlNode *aDocument)
void centerBoard()
move the BOARD into the center of the page
BOARD * m_board
which BOARD is being worked on, no ownership here
Definition: eagle_plugin.h:187
static int KiROUND(double v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: common.h:121
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: common.h:180
ERULES * m_rules
Eagle design rules.
Definition: eagle_plugin.h:173
void SetCopperLayerCount(int aCount)
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:539
void init(const PROPERTIES *aProperties)
initialize PLUGIN like a constructor would, and futz with fresh BOARD if needed.
int m_min_via
smallest via we find on Load(), in BIU.
Definition: eagle_plugin.h:190
Class XML_PARSER_ERROR implements a simple wrapper around runtime_error to isolate the errors thrown ...
Definition: eagle_parser.h:70
XPATH * m_xpath
keeps track of what we are working on within XML document during a Load().
Definition: eagle_plugin.h:174
int m_min_via_hole
smallest via diameter hole we find on Load(), in BIU.
Definition: eagle_plugin.h:191
int m_TrackMinWidth
track min value for width ((min copper size value
int m_ViasMinSize
vias (not micro vias) min diameter
int m_ViasMinDrill
vias (not micro vias) min drill diameter
#define THROW_IO_ERROR(msg)
void SetFileName(const wxString &aFileName)
Definition: class_board.h:236
double mdWireWire
wire to wire spacing I presume.
Definition: eagle_plugin.h:76
int m_min_trace
smallest trace we find on Load(), in BIU.
Definition: eagle_plugin.h:189
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
NETCLASSPTR GetDefault() const
Function GetDefault.
Class BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:171
int GetCopperLayerCount() const
Function GetCopperLayerCount.
Class BOARD_DESIGN_SETTINGS contains design settings for a BOARD object.

References centerBoard(), XPATH::Contents(), Format(), BOARD::GetCopperLayerCount(), BOARD_DESIGN_SETTINGS::GetDefault(), BOARD::GetDesignSettings(), init(), KiROUND(), loadAllSections(), m_board, m_min_trace, m_min_via, m_min_via_hole, m_rules, BOARD_DESIGN_SETTINGS::m_TrackMinWidth, BOARD_DESIGN_SETTINGS::m_ViasMinDrill, BOARD_DESIGN_SETTINGS::m_ViasMinSize, m_xpath, ERULES::mdWireWire, BOARD::SetCopperLayerCount(), BOARD::SetFileName(), and THROW_IO_ERROR.

◆ loadAllSections()

void EAGLE_PLUGIN::loadAllSections ( wxXmlNode *  aDocument)
private

Definition at line 335 of file eagle_plugin.cpp.

336 {
337  wxXmlNode* drawing = MapChildren( aDoc )["drawing"];
338  NODE_MAP drawingChildren = MapChildren( drawing );
339 
340  wxXmlNode* board = drawingChildren["board"];
341  NODE_MAP boardChildren = MapChildren( board );
342 
343  m_xpath->push( "eagle.drawing" );
344 
345  {
346  m_xpath->push( "board" );
347 
348  wxXmlNode* designrules = boardChildren["designrules"];
349  loadDesignRules( designrules );
350 
351  m_xpath->pop();
352  }
353 
354  {
355  m_xpath->push( "layers" );
356 
357  wxXmlNode* layers = drawingChildren["layers"];
358  loadLayerDefs( layers );
359 
360  m_xpath->pop();
361  }
362 
363  {
364  m_xpath->push( "board" );
365 
366  wxXmlNode* plain = boardChildren["plain"];
367  loadPlain( plain );
368 
369  wxXmlNode* signals = boardChildren["signals"];
370  loadSignals( signals );
371 
372  wxXmlNode* libs = boardChildren["libraries"];
373  loadLibraries( libs );
374 
375  wxXmlNode* elems = boardChildren["elements"];
376  loadElements( elems );
377 
378  m_xpath->pop(); // "board"
379  }
380 
381  m_xpath->pop(); // "eagle.drawing"
382 }
void push(const char *aPathSegment, const char *aAttribute="")
Definition: eagle_parser.h:117
void loadLayerDefs(wxXmlNode *aLayers)
NODE_MAP MapChildren(wxXmlNode *aCurrentNode)
Function MapChildren provides an easy access to the children of an XML node via their names.
XPATH * m_xpath
keeps track of what we are working on within XML document during a Load().
Definition: eagle_plugin.h:174
void loadLibraries(wxXmlNode *aLibs)
void loadPlain(wxXmlNode *aPlain)
void loadElements(wxXmlNode *aElements)
void pop()
Definition: eagle_parser.h:124
void loadDesignRules(wxXmlNode *aDesignRules)
void loadSignals(wxXmlNode *aSignals)
std::unordered_map< wxString, wxXmlNode * > NODE_MAP
Definition: eagle_parser.h:48

References loadDesignRules(), loadElements(), loadLayerDefs(), loadLibraries(), loadPlain(), loadSignals(), m_xpath, MapChildren(), XPATH::pop(), and XPATH::push().

Referenced by Load().

◆ loadDesignRules()

void EAGLE_PLUGIN::loadDesignRules ( wxXmlNode *  aDesignRules)
private

Definition at line 385 of file eagle_plugin.cpp.

386 {
387  if( aDesignRules )
388  {
389  m_xpath->push( "designrules" );
390  m_rules->parse( aDesignRules );
391  m_xpath->pop(); // "designrules"
392  }
393 }
ERULES * m_rules
Eagle design rules.
Definition: eagle_plugin.h:173
void push(const char *aPathSegment, const char *aAttribute="")
Definition: eagle_parser.h:117
void parse(wxXmlNode *aRules)
XPATH * m_xpath
keeps track of what we are working on within XML document during a Load().
Definition: eagle_plugin.h:174
void pop()
Definition: eagle_parser.h:124

References m_rules, m_xpath, ERULES::parse(), XPATH::pop(), and XPATH::push().

Referenced by loadAllSections().

◆ loadElements()

void EAGLE_PLUGIN::loadElements ( wxXmlNode *  aElements)
private

Definition at line 854 of file eagle_plugin.cpp.

855 {
856  if( !aElements )
857  return;
858 
859  m_xpath->push( "elements.element", "name" );
860 
861  EATTR name;
862  EATTR value;
863  bool refanceNamePresetInPackageLayout;
864  bool valueNamePresetInPackageLayout;
865 
866  // Get the first element and iterate
867  wxXmlNode* element = aElements->GetChildren();
868 
869  while( element )
870  {
871  if( element->GetName() != "element" )
872  {
873  wxLogDebug( "expected: <element> read <%s>. Skip it", element->GetName() );
874  // Get next item
875  element = element->GetNext();
876  continue;
877  }
878 
879  EELEMENT e( element );
880 
881  // use "NULL-ness" as an indication of presence of the attribute:
882  EATTR* nameAttr = 0;
883  EATTR* valueAttr = 0;
884 
885  m_xpath->Value( e.name.c_str() );
886 
887  wxString pkg_key = makeKey( e.library, e.package );
888 
889  MODULE_CITER mi = m_templates.find( pkg_key );
890 
891  if( mi == m_templates.end() )
892  {
893  wxString emsg = wxString::Format( _( "No \"%s\" package in library \"%s\"" ),
894  GetChars( FROM_UTF8( e.package.c_str() ) ),
895  GetChars( FROM_UTF8( e.library.c_str() ) ) );
896  THROW_IO_ERROR( emsg );
897  }
898 
899  // copy constructor to clone the template
900  MODULE* m = new MODULE( *mi->second );
901  m_board->Add( m, ADD_APPEND );
902 
903  // update the nets within the pads of the clone
904  for( D_PAD* pad = m->PadsList(); pad; pad = pad->Next() )
905  {
906  wxString pn_key = makeKey( e.name, pad->GetName() );
907 
908  NET_MAP_CITER ni = m_pads_to_nets.find( pn_key );
909  if( ni != m_pads_to_nets.end() )
910  {
911  const ENET* enet = &ni->second;
912  pad->SetNetCode( enet->netcode );
913  }
914  }
915 
916  refanceNamePresetInPackageLayout = true;
917  valueNamePresetInPackageLayout = true;
918  m->SetPosition( wxPoint( kicad_x( e.x ), kicad_y( e.y ) ) );
919 
920  // Is >NAME field set in package layout ?
921  if( m->GetReference().size() == 0 )
922  {
923  m->Reference().SetVisible( false ); // No so no show
924  refanceNamePresetInPackageLayout = false;
925  }
926 
927  // Is >VALUE field set in package layout
928  if( m->GetValue().size() == 0 )
929  {
930  m->Value().SetVisible( false ); // No so no show
931  valueNamePresetInPackageLayout = false;
932  }
933 
934  m->SetReference( FROM_UTF8( e.name.c_str() ) );
935  m->SetValue( FROM_UTF8( e.value.c_str() ) );
936 
937  if( !e.smashed )
938  { // Not smashed so show NAME & VALUE
939  if( valueNamePresetInPackageLayout )
940  m->Value().SetVisible( true ); // Only if place holder in package layout
941 
942  if( refanceNamePresetInPackageLayout )
943  m->Reference().SetVisible( true ); // Only if place holder in package layout
944  }
945  else if( *e.smashed == true )
946  { // Smasted so set default to no show for NAME and VALUE
947  m->Value().SetVisible( false );
948  m->Reference().SetVisible( false );
949 
950  // initalize these to default values incase the <attribute> elements are not present.
951  m_xpath->push( "attribute", "name" );
952 
953  // VALUE and NAME can have something like our text "effects" overrides
954  // in SWEET and new schematic. Eagle calls these XML elements "attribute".
955  // There can be one for NAME and/or VALUE both. Features present in the
956  // EATTR override the ones established in the package only if they are
957  // present here (except for rot, which if not present means angle zero).
958  // So the logic is a bit different than in packageText() and in plain text.
959 
960  // Get the first attribute and iterate
961  wxXmlNode* attribute = element->GetChildren();
962 
963  while( attribute )
964  {
965  if( attribute->GetName() != "attribute" )
966  {
967  wxLogDebug( "expected: <attribute> read <%s>. Skip it", attribute->GetName() );
968  attribute = attribute->GetNext();
969  continue;
970  }
971 
972  EATTR a( attribute );
973 
974  if( a.name == "NAME" )
975  {
976  name = a;
977  nameAttr = &name;
978 
979  // do we have a display attribute ?
980  if( a.display )
981  {
982  // Yes!
983  switch( *a.display )
984  {
985  case EATTR::VALUE :
986  nameAttr->name = e.name;
987  m->SetReference( e.name );
988  if( refanceNamePresetInPackageLayout )
989  m->Reference().SetVisible( true );
990  break;
991 
992  case EATTR::NAME :
993  if( refanceNamePresetInPackageLayout )
994  {
995  m->SetReference( "NAME" );
996  m->Reference().SetVisible( true );
997  }
998  break;
999 
1000  case EATTR::BOTH :
1001  if( refanceNamePresetInPackageLayout )
1002  m->Reference().SetVisible( true );
1003  nameAttr->name = nameAttr->name + " = " + e.name;
1004  m->SetReference( "NAME = " + e.name );
1005  break;
1006 
1007  case EATTR::Off :
1008  m->Reference().SetVisible( false );
1009  break;
1010 
1011  default:
1012  nameAttr->name = e.name;
1013  if( refanceNamePresetInPackageLayout )
1014  m->Reference().SetVisible( true );
1015  }
1016  }
1017  else
1018  // No display, so default is visable, and show value of NAME
1019  m->Reference().SetVisible( true );
1020  }
1021  else if( a.name == "VALUE" )
1022  {
1023  value = a;
1024  valueAttr = &value;
1025 
1026  if( a.display )
1027  {
1028  // Yes!
1029  switch( *a.display )
1030  {
1031  case EATTR::VALUE :
1032  valueAttr->value = opt_wxString( e.value );
1033  m->SetValue( e.value );
1034  if( valueNamePresetInPackageLayout )
1035  m->Value().SetVisible( true );
1036  break;
1037 
1038  case EATTR::NAME :
1039  if( valueNamePresetInPackageLayout )
1040  m->Value().SetVisible( true );
1041  m->SetValue( "VALUE" );
1042  break;
1043 
1044  case EATTR::BOTH :
1045  if( valueNamePresetInPackageLayout )
1046  m->Value().SetVisible( true );
1047  valueAttr->value = opt_wxString( "VALUE = " + e.value );
1048  m->SetValue( "VALUE = " + e.value );
1049  break;
1050 
1051  case EATTR::Off :
1052  m->Value().SetVisible( false );
1053  break;
1054 
1055  default:
1056  valueAttr->value = opt_wxString( e.value );
1057  if( valueNamePresetInPackageLayout )
1058  m->Value().SetVisible( true );
1059  }
1060  }
1061  else
1062  // No display, so default is visible, and show value of NAME
1063  m->Value().SetVisible( true );
1064 
1065  }
1066 
1067  attribute = attribute->GetNext();
1068  }
1069 
1070  m_xpath->pop(); // "attribute"
1071  }
1072 
1073  orientModuleAndText( m, e, nameAttr, valueAttr );
1074 
1075  // Get next element
1076  element = element->GetNext();
1077  }
1078 
1079  m_xpath->pop(); // "elements.element"
1080 }
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:203
TEXTE_MODULE & Reference()
Definition: class_module.h:503
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes.
Definition: macros.h:53
BOARD * m_board
which BOARD is being worked on, no ownership here
Definition: eagle_plugin.h:187
void push(const char *aPathSegment, const char *aAttribute="")
Definition: eagle_parser.h:117
Eagle element element.
Definition: eagle_parser.h:798
void SetVisible(bool aVisible)
Definition: eda_text.h:188
NET_MAP::const_iterator NET_MAP_CITER
Definition: eagle_plugin.h:41
XPATH * m_xpath
keeps track of what we are working on within XML document during a Load().
Definition: eagle_plugin.h:174
OPTIONAL_XML_ATTRIBUTE< wxString > opt_wxString
Definition: eagle_parser.h:379
wxString name
Definition: eagle_parser.h:605
static wxString makeKey(const wxString &aFirst, const wxString &aSecond)
Assemble a two part key as a simple concatenation of aFirst and aSecond parts, using a separator.
TEXTE_MODULE & Value()
read/write accessors:
Definition: class_module.h:502
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_INSERT) override
Adds an item to the container.
const wxString & GetReference() const
Function GetReference.
Definition: class_module.h:462
void SetReference(const wxString &aReference)
Function SetReference.
Definition: class_module.h:472
#define THROW_IO_ERROR(msg)
void SetPosition(const wxPoint &aPos) override
opt_wxString value
Definition: eagle_parser.h:606
Eagle net.
Definition: eagle_parser.h:462
void orientModuleAndText(MODULE *m, const EELEMENT &e, const EATTR *nameAttr, const EATTR *valueAttr)
Class EATTR parses an Eagle "attribute" XML element.
Definition: eagle_parser.h:603
MODULE_MAP::const_iterator MODULE_CITER
int netcode
Definition: eagle_parser.h:464
static const wxChar * GetChars(const wxString &s)
Function GetChars returns a wxChar* to the actual wxChar* data within a wxString, and is helpful for ...
Definition: macros.h:92
const char * name
Definition: DXF_plotter.cpp:61
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
MODULE_MAP m_templates
is part of a MODULE factory that operates using copy construction.
Definition: eagle_plugin.h:181
void SetValue(const wxString &aValue)
Function SetValue.
Definition: class_module.h:496
NET_MAP m_pads_to_nets
net list
Definition: eagle_plugin.h:179
const wxString & GetValue() const
Function GetValue.
Definition: class_module.h:487
DLIST< D_PAD > & PadsList()
Definition: class_module.h:162
void pop()
Definition: eagle_parser.h:124
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:202
void Value(const char *aValue)
modify the last path node's value
Definition: eagle_parser.h:127

References BOARD::Add(), ADD_APPEND, EATTR::BOTH, EATTR::display, Format(), FROM_UTF8(), GetChars(), MODULE::GetReference(), MODULE::GetValue(), kicad_x(), kicad_y(), EELEMENT::library, m_board, m_pads_to_nets, m_templates, m_xpath, makeKey(), name, EATTR::name, EATTR::NAME, EELEMENT::name, ENET::netcode, EATTR::Off, orientModuleAndText(), EELEMENT::package, MODULE::PadsList(), XPATH::pop(), XPATH::push(), MODULE::Reference(), MODULE::SetPosition(), MODULE::SetReference(), MODULE::SetValue(), EDA_TEXT::SetVisible(), EELEMENT::smashed, THROW_IO_ERROR, XPATH::Value(), MODULE::Value(), EATTR::value, EATTR::VALUE, EELEMENT::value, EELEMENT::x, and EELEMENT::y.

Referenced by loadAllSections().

◆ loadLayerDefs()

void EAGLE_PLUGIN::loadLayerDefs ( wxXmlNode *  aLayers)
private

Definition at line 396 of file eagle_plugin.cpp.

397 {
398  if( !aLayers )
399  return;
400 
401  ELAYERS cu; // copper layers
402 
403  // Get the first layer and iterate
404  wxXmlNode* layerNode = aLayers->GetChildren();
405 
406  m_eagleLayers.clear();
407 
408  while( layerNode )
409  {
410  ELAYER elayer( layerNode );
411  m_eagleLayers.insert( std::make_pair( elayer.number, elayer ) );
412 
413  // find the subset of layers that are copper and active
414  if( elayer.number >= 1 && elayer.number <= 16 && ( !elayer.active || *elayer.active ) )
415  {
416  cu.push_back( elayer );
417  }
418 
419  layerNode = layerNode->GetNext();
420  }
421 
422  // establish cu layer map:
423  int ki_layer_count = 0;
424 
425  for( EITER it = cu.begin(); it != cu.end(); ++it, ++ki_layer_count )
426  {
427  if( ki_layer_count == 0 )
428  m_cu_map[it->number] = F_Cu;
429  else if( ki_layer_count == int( cu.size()-1 ) )
430  m_cu_map[it->number] = B_Cu;
431  else
432  {
433  // some eagle boards do not have contiguous layer number sequences.
434 
435 #if 0 // pre PCB_LAYER_ID & LSET:
436  m_cu_map[it->number] = cu.size() - 1 - ki_layer_count;
437 #else
438  m_cu_map[it->number] = ki_layer_count;
439 #endif
440  }
441  }
442 
443 #if 0 && defined(DEBUG)
444  printf( "m_cu_map:\n" );
445  for( unsigned i=0; i<arrayDim(m_cu_map); ++i )
446  {
447  printf( "\t[%d]:%d\n", i, m_cu_map[i] );
448  }
449 #endif
450 
451  // Set the layer names and cu count iff we're loading a board.
452  if( m_board )
453  {
454  m_board->SetCopperLayerCount( cu.size() );
455 
456  for( EITER it = cu.begin(); it != cu.end(); ++it )
457  {
458  PCB_LAYER_ID layer = kicad_layer( it->number );
459 
460  // these function provide their own protection against UNDEFINED_LAYER:
461  m_board->SetLayerName( layer, FROM_UTF8( it->name.c_str() ) );
462  m_board->SetLayerType( layer, LT_SIGNAL );
463 
464  // could map the colors here
465  }
466  }
467 }
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes.
Definition: macros.h:53
BOARD * m_board
which BOARD is being worked on, no ownership here
Definition: eagle_plugin.h:187
PCB_LAYER_ID kicad_layer(int aLayer) const
Convert an Eagle layer to a KiCad layer.
void SetCopperLayerCount(int aCount)
bool SetLayerType(PCB_LAYER_ID aLayer, LAYER_T aLayerType)
Function SetLayerType changes the type of the layer given by aLayer.
#define cu(a)
Definition: auxiliary.h:88
int m_cu_map[17]
map eagle to kicad, cu layers only.
Definition: eagle_plugin.h:170
PCB_LAYER_ID
A quick note on layer IDs:
std::map< int, ELAYER > m_eagleLayers
Eagle layers data stored by the layer number.
Definition: eagle_plugin.h:171
bool SetLayerName(PCB_LAYER_ID aLayer, const wxString &aLayerName)
Function SetLayerName changes the name of the layer given by aLayer.
constexpr std::size_t arrayDim(T const (&)[N]) noexcept
Definition: macros.h:99
std::vector< ELAYER > ELAYERS
Definition: eagle_plugin.h:167
size_t i
Definition: json11.cpp:597
ELAYERS::const_iterator EITER
Definition: eagle_plugin.h:168

References ELAYER::active, arrayDim(), B_Cu, cu, F_Cu, FROM_UTF8(), i, kicad_layer(), LT_SIGNAL, m_board, m_cu_map, m_eagleLayers, ELAYER::number, BOARD::SetCopperLayerCount(), BOARD::SetLayerName(), and BOARD::SetLayerType().

Referenced by cacheLib(), and loadAllSections().

◆ loadLibraries()

void EAGLE_PLUGIN::loadLibraries ( wxXmlNode *  aLibs)
private

Definition at line 831 of file eagle_plugin.cpp.

832 {
833  if( !aLibs )
834  return;
835 
836  m_xpath->push( "libraries.library", "name" );
837 
838  // Get the first library and iterate
839  wxXmlNode* library = aLibs->GetChildren();
840 
841  while( library )
842  {
843  const wxString& lib_name = library->GetAttribute( "name" );
844 
845  m_xpath->Value( lib_name.c_str() );
846  loadLibrary( library, &lib_name );
847  library = library->GetNext();
848  }
849 
850  m_xpath->pop();
851 }
void push(const char *aPathSegment, const char *aAttribute="")
Definition: eagle_parser.h:117
XPATH * m_xpath
keeps track of what we are working on within XML document during a Load().
Definition: eagle_plugin.h:174
void loadLibrary(wxXmlNode *aLib, const wxString *aLibName)
Function loadLibrary loads the Eagle "library" XML element, which can occur either under a "libraries...
void pop()
Definition: eagle_parser.h:124
void Value(const char *aValue)
modify the last path node's value
Definition: eagle_parser.h:127

References loadLibrary(), m_xpath, XPATH::pop(), XPATH::push(), and XPATH::Value().

Referenced by loadAllSections().

◆ loadLibrary()

void EAGLE_PLUGIN::loadLibrary ( wxXmlNode *  aLib,
const wxString *  aLibName 
)
private

Function loadLibrary loads the Eagle "library" XML element, which can occur either under a "libraries" element (if a *.brd file) or under a "drawing" element if a *.lbr file.

Parameters
aLibis the portion of the loaded XML document tree that is the "library" element.
aLibNameis a pointer to the library name or NULL. If NULL this means we are loading a *.lbr not a *.brd file and the key used in m_templates is to exclude the library name.

Definition at line 771 of file eagle_plugin.cpp.

772 {
773  if( !aLib )
774  return;
775 
776  // library will have <xmlattr> node, skip that and get the single packages node
777  wxXmlNode* packages = MapChildren( aLib )["packages"];
778 
779  if( !packages )
780  return;
781 
782  m_xpath->push( "packages" );
783 
784  // Create a MODULE for all the eagle packages, for use later via a copy constructor
785  // to instantiate needed MODULES in our BOARD. Save the MODULE templates in
786  // a MODULE_MAP using a single lookup key consisting of libname+pkgname.
787 
788  // Get the first package and iterate
789  wxXmlNode* package = packages->GetChildren();
790 
791  while( package )
792  {
793  m_xpath->push( "package", "name" );
794 
795  wxString pack_ref = package->GetAttribute( "name" );
796  ReplaceIllegalFileNameChars( pack_ref, '_' );
797 
798  m_xpath->Value( pack_ref.ToUTF8() );
799 
800  wxString key = aLibName ? makeKey( *aLibName, pack_ref ) : pack_ref;
801 
802  MODULE* m = makeModule( package, pack_ref );
803 
804  // add the templating MODULE to the MODULE template factory "m_templates"
805  std::pair<MODULE_ITER, bool> r = m_templates.insert( {key, m} );
806 
807  if( !r.second
808  // && !( m_props && m_props->Value( "ignore_duplicates" ) )
809  )
810  {
811  wxString lib = aLibName ? *aLibName : m_lib_path;
812  wxString pkg = pack_ref;
813 
814  wxString emsg = wxString::Format(
815  _( "<package> name: \"%s\" duplicated in eagle <library>: \"%s\"" ),
816  GetChars( pkg ),
817  GetChars( lib )
818  );
819  THROW_IO_ERROR( emsg );
820  }
821 
822  m_xpath->pop();
823 
824  package = package->GetNext();
825  }
826 
827  m_xpath->pop(); // "packages"
828 }
void push(const char *aPathSegment, const char *aAttribute="")
Definition: eagle_parser.h:117
bool ReplaceIllegalFileNameChars(std::string *aName, int aReplaceChar)
Checks aName for illegal file name characters.
Definition: string.cpp:639
NODE_MAP MapChildren(wxXmlNode *aCurrentNode)
Function MapChildren provides an easy access to the children of an XML node via their names.
XPATH * m_xpath
keeps track of what we are working on within XML document during a Load().
Definition: eagle_plugin.h:174
static wxString makeKey(const wxString &aFirst, const wxString &aSecond)
Assemble a two part key as a simple concatenation of aFirst and aSecond parts, using a separator.
wxString m_lib_path
Definition: eagle_plugin.h:193
#define THROW_IO_ERROR(msg)
static const wxChar * GetChars(const wxString &s)
Function GetChars returns a wxChar* to the actual wxChar* data within a wxString, and is helpful for ...
Definition: macros.h:92
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
MODULE_MAP m_templates
is part of a MODULE factory that operates using copy construction.
Definition: eagle_plugin.h:181
void pop()
Definition: eagle_parser.h:124
MODULE * makeModule(wxXmlNode *aPackage, const wxString &aPkgName) const
Function makeModule creates a MODULE from an Eagle package.
void Value(const char *aValue)
modify the last path node's value
Definition: eagle_parser.h:127

References Format(), GetChars(), m_lib_path, m_templates, m_xpath, makeKey(), makeModule(), MapChildren(), XPATH::pop(), XPATH::push(), ReplaceIllegalFileNameChars(), THROW_IO_ERROR, and XPATH::Value().

Referenced by cacheLib(), and loadLibraries().

◆ loadPlain()

void EAGLE_PLUGIN::loadPlain ( wxXmlNode *  aPlain)
private

Definition at line 470 of file eagle_plugin.cpp.

471 {
472  if( !aGraphics )
473  return;
474 
475  m_xpath->push( "plain" );
476 
477  // Get the first graphic and iterate
478  wxXmlNode* gr = aGraphics->GetChildren();
479 
480  // (polygon | wire | text | circle | rectangle | frame | hole)*
481  while( gr )
482  {
483  wxString grName = gr->GetName();
484 
485  if( grName == "wire" )
486  {
487  m_xpath->push( "wire" );
488 
489  EWIRE w( gr );
490  PCB_LAYER_ID layer = kicad_layer( w.layer );
491 
492  wxPoint start( kicad_x( w.x1 ), kicad_y( w.y1 ) );
493  wxPoint end( kicad_x( w.x2 ), kicad_y( w.y2 ) );
494 
495  if( layer != UNDEFINED_LAYER )
496  {
497  DRAWSEGMENT* dseg = new DRAWSEGMENT( m_board );
498  m_board->Add( dseg, ADD_APPEND );
499 
500  if( !w.curve )
501  {
502  dseg->SetStart( start );
503  dseg->SetEnd( end );
504  }
505  else
506  {
507  wxPoint center = ConvertArcCenter( start, end, *w.curve );
508 
509  dseg->SetShape( S_ARC );
510  dseg->SetStart( center );
511  dseg->SetEnd( start );
512  dseg->SetAngle( *w.curve * -10.0 ); // KiCad rotates the other way
513  }
514 
515  dseg->SetTimeStamp( EagleTimeStamp( gr ) );
516  dseg->SetLayer( layer );
517  dseg->SetWidth( Millimeter2iu( DEFAULT_PCB_EDGE_THICKNESS ) );
518  }
519  m_xpath->pop();
520  }
521  else if( grName == "text" )
522  {
523  m_xpath->push( "text" );
524 
525  ETEXT t( gr );
526  PCB_LAYER_ID layer = kicad_layer( t.layer );
527 
528  if( layer != UNDEFINED_LAYER )
529  {
530  TEXTE_PCB* pcbtxt = new TEXTE_PCB( m_board );
531  m_board->Add( pcbtxt, ADD_APPEND );
532 
533  pcbtxt->SetLayer( layer );
534  pcbtxt->SetTimeStamp( EagleTimeStamp( gr ) );
535  pcbtxt->SetText( FROM_UTF8( t.text.c_str() ) );
536  pcbtxt->SetTextPos( wxPoint( kicad_x( t.x ), kicad_y( t.y ) ) );
537 
538  pcbtxt->SetTextSize( kicad_fontz( t.size ) );
539 
540  double ratio = t.ratio ? *t.ratio : 8; // DTD says 8 is default
541 
542  pcbtxt->SetThickness( t.size.ToPcbUnits() * ratio / 100 );
543 
544  int align = t.align ? *t.align : ETEXT::BOTTOM_LEFT;
545 
546  if( t.rot )
547  {
548  int sign = t.rot->mirror ? -1 : 1;
549  pcbtxt->SetMirrored( t.rot->mirror );
550 
551  double degrees = t.rot->degrees;
552 
553  if( degrees == 90 || t.rot->spin )
554  pcbtxt->SetTextAngle( sign * t.rot->degrees * 10 );
555  else if( degrees == 180 )
556  align = ETEXT::TOP_RIGHT;
557  else if( degrees == 270 )
558  {
559  pcbtxt->SetTextAngle( sign * 90 * 10 );
560  align = ETEXT::TOP_RIGHT;
561  }
562  else // Ok so text is not at 90,180 or 270 so do some funny stuf to get placement right
563  {
564  if( ( degrees > 0 ) && ( degrees < 90 ) )
565  pcbtxt->SetTextAngle( sign * t.rot->degrees * 10 );
566  else if( ( degrees > 90 ) && ( degrees < 180 ) )
567  {
568  pcbtxt->SetTextAngle( sign * ( t.rot->degrees + 180 ) * 10 );
569  align = ETEXT::TOP_RIGHT;
570  }
571  else if( ( degrees > 180 ) && ( degrees < 270 ) )
572  {
573  pcbtxt->SetTextAngle( sign * ( t.rot->degrees - 180 ) * 10 );
574  align = ETEXT::TOP_RIGHT;
575  }
576  else if( ( degrees > 270 ) && ( degrees < 360 ) )
577  {
578  pcbtxt->SetTextAngle( sign * t.rot->degrees * 10 );
579  align = ETEXT::BOTTOM_LEFT;
580  }
581  }
582  }
583 
584  switch( align )
585  {
586  case ETEXT::CENTER:
587  // this was the default in pcbtxt's constructor
588  break;
589 
590  case ETEXT::CENTER_LEFT:
592  break;
593 
594  case ETEXT::CENTER_RIGHT:
596  break;
597 
598  case ETEXT::TOP_CENTER:
600  break;
601 
602  case ETEXT::TOP_LEFT:
605  break;
606 
607  case ETEXT::TOP_RIGHT:
610  break;
611 
614  break;
615 
616  case ETEXT::BOTTOM_LEFT:
619  break;
620 
621  case ETEXT::BOTTOM_RIGHT:
624  break;
625  }
626  }
627  m_xpath->pop();
628  }
629  else if( grName == "circle" )
630  {
631  m_xpath->push( "circle" );
632 
633  ECIRCLE c( gr );
634  PCB_LAYER_ID layer = kicad_layer( c.layer );
635 
636  if( layer != UNDEFINED_LAYER ) // unsupported layer
637  {
638  DRAWSEGMENT* dseg = new DRAWSEGMENT( m_board );
639  m_board->Add( dseg, ADD_APPEND );
640 
641  dseg->SetShape( S_CIRCLE );
642  dseg->SetTimeStamp( EagleTimeStamp( gr ) );
643  dseg->SetLayer( layer );
644  dseg->SetStart( wxPoint( kicad_x( c.x ), kicad_y( c.y ) ) );
645  dseg->SetEnd( wxPoint( kicad_x( c.x + c.radius ), kicad_y( c.y ) ) );
646  dseg->SetWidth( c.width.ToPcbUnits() );
647  }
648  m_xpath->pop();
649  }
650  else if( grName == "rectangle" )
651  {
652  // This seems to be a simplified rectangular [copper] zone, cannot find any
653  // net related info on it from the DTD.
654  m_xpath->push( "rectangle" );
655 
656  ERECT r( gr );
657  PCB_LAYER_ID layer = kicad_layer( r.layer );
658 
659  if( IsCopperLayer( layer ) )
660  {
661  // use a "netcode = 0" type ZONE:
662  ZONE_CONTAINER* zone = new ZONE_CONTAINER( m_board );
663  m_board->Add( zone, ADD_APPEND );
664 
665  zone->SetTimeStamp( EagleTimeStamp( gr ) );
666  zone->SetLayer( layer );
668 
670 
671  const int outlineIdx = -1; // this is the id of the copper zone main outline
672  zone->AppendCorner( wxPoint( kicad_x( r.x1 ), kicad_y( r.y1 ) ), outlineIdx );
673  zone->AppendCorner( wxPoint( kicad_x( r.x2 ), kicad_y( r.y1 ) ), outlineIdx );
674  zone->AppendCorner( wxPoint( kicad_x( r.x2 ), kicad_y( r.y2 ) ), outlineIdx );
675  zone->AppendCorner( wxPoint( kicad_x( r.x1 ), kicad_y( r.y2 ) ), outlineIdx );
676 
677  if( r.rot )
678  {
679  zone->Rotate( zone->GetPosition(), r.rot->degrees * 10 );
680  }
681  // this is not my fault:
682  zone->SetHatch( outline_hatch, zone->GetDefaultHatchPitch(), true );
683  }
684 
685  m_xpath->pop();
686  }
687  else if( grName == "hole" )
688  {
689  m_xpath->push( "hole" );
690 
691  // Fabricate a MODULE with a single PAD_ATTRIB_HOLE_NOT_PLATED pad.
692  // Use m_hole_count to gen up a unique name.
693 
694  MODULE* module = new MODULE( m_board );
695  m_board->Add( module, ADD_APPEND );
696  module->SetReference( wxString::Format( "@HOLE%d", m_hole_count++ ) );
697  module->Reference().SetVisible( false );
698 
699  packageHole( module, gr, true );
700 
701  m_xpath->pop();
702  }
703  else if( grName == "frame" )
704  {
705  // picture this
706  }
707  else if( grName == "polygon" )
708  {
709  m_xpath->push( "polygon" );
710  loadPolygon( gr );
711  m_xpath->pop(); // "polygon"
712  }
713  else if( grName == "dimension" )
714  {
715  EDIMENSION d( gr );
716  PCB_LAYER_ID layer = kicad_layer( d.layer );
717 
718  if( layer != UNDEFINED_LAYER )
719  {
720  const BOARD_DESIGN_SETTINGS& designSettings = m_board->GetDesignSettings();
721  DIMENSION* dimension = new DIMENSION( m_board );
722  m_board->Add( dimension, ADD_APPEND );
723 
724  if( d.dimensionType )
725  {
726  // Eagle dimension graphic arms may have different lengths, but they look
727  // incorrect in KiCad (the graphic is tilted). Make them even lenght in such case.
728  if( *d.dimensionType == "horizontal" )
729  {
730  int newY = ( d.y1.ToPcbUnits() + d.y2.ToPcbUnits() ) / 2;
731  d.y1 = ECOORD( newY, ECOORD::EAGLE_UNIT::EU_NM );
732  d.y2 = ECOORD( newY, ECOORD::EAGLE_UNIT::EU_NM );
733  }
734  else if( *d.dimensionType == "vertical" )
735  {
736  int newX = ( d.x1.ToPcbUnits() + d.x2.ToPcbUnits() ) / 2;
737  d.x1 = ECOORD( newX, ECOORD::EAGLE_UNIT::EU_NM );
738  d.x2 = ECOORD( newX, ECOORD::EAGLE_UNIT::EU_NM );
739  }
740  }
741 
742  dimension->SetLayer( layer );
743  // The origin and end are assumed to always be in this order from eagle
744  dimension->SetOrigin( wxPoint( kicad_x( d.x1 ), kicad_y( d.y1 ) ) );
745  dimension->SetEnd( wxPoint( kicad_x( d.x2 ), kicad_y( d.y2 ) ) );
746  dimension->Text().SetTextSize( designSettings.GetTextSize( layer ) );
747  dimension->Text().SetThickness( designSettings.GetTextThickness( layer ) );
748  dimension->SetWidth( designSettings.GetLineThickness( layer ) );
749  dimension->SetUnits( MILLIMETRES, false );
750 
751  // check which axis the dimension runs in
752  // because the "height" of the dimension is perpendicular to that axis
753  // Note the check is just if two axes are close enough to each other
754  // Eagle appears to have some rounding errors
755  if( abs( ( d.x1 - d.x2 ).ToPcbUnits() ) < 50000 ) // 50000 nm = 0.05 mm
756  dimension->SetHeight( kicad_x( d.x3 - d.x1 ) );
757  else
758  dimension->SetHeight( kicad_y( d.y3 - d.y1 ) );
759 
760  dimension->AdjustDimensionDetails();
761  }
762  }
763 
764  // Get next graphic
765  gr = gr->GetNext();
766  }
767  m_xpath->pop();
768 }
void SetMirrored(bool isMirrored)
Definition: eda_text.h:191
Class ZONE_CONTAINER handles a list of polygons defining a copper zone.
Definition: class_zone.h:59
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:203
void SetTextAngle(double aAngle)
TEXTE_MODULE & Reference()
Definition: class_module.h:503
void SetShape(STROKE_T aShape)
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes.
Definition: macros.h:53
BOARD * m_board
which BOARD is being worked on, no ownership here
Definition: eagle_plugin.h:187
PCB_LAYER_ID kicad_layer(int aLayer) const
Convert an Eagle layer to a KiCad layer.
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
void push(const char *aPathSegment, const char *aAttribute="")
Definition: eagle_parser.h:117
void SetTextPos(const wxPoint &aPoint)
Definition: eda_text.h:236
void SetVisible(bool aVisible)
Definition: eda_text.h:188
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:539
void SetHatch(int aHatchStyle, int aHatchPitch, bool aRebuildHatch)
Function SetHatch sets all hatch parameters for the zone.
void SetTextSize(const wxSize &aNewSize)
Definition: eda_text.h:227
int GetTextThickness(PCB_LAYER_ID aLayer) const
Function GetTextThickness Returns the default text thickness from the layer class for the given layer...
const wxPoint GetPosition() const override
Definition: class_zone.cpp:173
Eagle text element.
Definition: eagle_parser.h:646
#define abs(a)
Definition: auxiliary.h:84
static int GetDefaultHatchPitch()
Function GetDefaultHatchPitchMils.
void SetLayer(PCB_LAYER_ID aLayer) override
Function SetLayer sets the layer this item is on.
XPATH * m_xpath
keeps track of what we are working on within XML document during a Load().
Definition: eagle_plugin.h:174
void packageHole(MODULE *aModule, wxXmlNode *aTree, bool aCenter) const
Function packageHole @parameter aModule - The KiCad module to which to assign the hole @parameter aTr...
int GetLineThickness(PCB_LAYER_ID aLayer) const
Function GetLineThickness Returns the default graphic segment thickness from the layer class for the ...
PCB_LAYER_ID
A quick note on layer IDs:
void SetOrigin(const wxPoint &aOrigin)
Function SetOrigin Sets a new origin of the crossbar line.
void SetEnd(const wxPoint &aEnd)
Function SetEnd Sets a new end of the crossbar line.
void SetVertJustify(EDA_TEXT_VJUSTIFY_T aType)
Definition: eda_text.h:207
Arcs (with rounded ends)
Eagle circle.
Definition: eagle_parser.h:571
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_INSERT) override
Adds an item to the container.
void Rotate(const wxPoint &centre, double angle) override
Function Rotate Move the outlines.
Definition: class_zone.cpp:929
virtual void SetLayer(PCB_LAYER_ID aLayer) override
Function SetLayer sets the layer this item is on.
Definition: class_zone.cpp:206
bool SetNetCode(int aNetCode, bool aNoAssert=false)
Function SetNetCode sets net using a net code.
void AdjustDimensionDetails()
Function AdjustDimensionDetails Calculate coordinates of segments used to draw the dimension.
void SetReference(const wxString &aReference)
Function SetReference.
Definition: class_module.h:472
HATCH_STYLE
Zone hatch styles.
Definition: class_zone.h:66
void SetUnits(EDA_UNITS_T aUnits, bool aUseMils)
timestamp_t EagleTimeStamp(wxXmlNode *aTree)
Make a unique time stamp
int m_hole_count
generates unique module names from eagle "hole"s.
Definition: eagle_plugin.h:177
Eagle XML rectangle in binary.
Definition: eagle_parser.h:584
#define DEFAULT_PCB_EDGE_THICKNESS
void SetStart(const wxPoint &aStart)
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
void SetHorizJustify(EDA_TEXT_HJUSTIFY_T aType)
Definition: eda_text.h:206
void SetHeight(int aHeight)
Function SetHeight Sets the length of feature lines.
wxPoint ConvertArcCenter(const wxPoint &aStart, const wxPoint &aEnd, double aAngle)
Convert an Eagle curve end to a KiCad center for S_ARC
TEXTE_PCB & Text()
void SetEnd(const wxPoint &aEnd)
Eagle wire.
Definition: eagle_parser.h:500
void SetAngle(double aAngle)
Function SetAngle sets the angle for arcs, and normalizes it within the range 0 - 360 degrees.
bool IsCopperLayer(LAYER_NUM aLayerId)
Function IsCopperLayer tests whether a layer is a copper layer.
bool AppendCorner(wxPoint aPosition, int aHoleIdx, bool aAllowDuplication=false)
Add a new corner to the zone outline (to the main outline or a hole)
wxSize kicad_fontz(const ECOORD &d) const
create a font size (fontz) from an eagle font size scalar
Eagle dimension element.
Definition: eagle_parser.h:629
void pop()
Definition: eagle_parser.h:124
void SetWidth(int aWidth)
ZONE_CONTAINER * loadPolygon(wxXmlNode *aPolyNode)
Loads a copper or keepout polygon and adds it to the board.
static const int UNCONNECTED
Constant that holds the "unconnected net" number (typically 0) all items "connected" to this net are ...
Definition: netinfo.h:469
wxSize GetTextSize(PCB_LAYER_ID aLayer) const
Function GetTextSize Returns the default text size from the layer class for the given layer.
Class DIMENSION.
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:202
void SetThickness(int aNewThickness)
Function SetThickness sets pen width.
Definition: eda_text.h:161
void SetTimeStamp(timestamp_t aNewTimeStamp)
Definition: base_struct.h:206
Class BOARD_DESIGN_SETTINGS contains design settings for a BOARD object.
int sign(T val)
Definition: math_util.h:44
virtual void SetText(const wxString &aText)
Definition: eda_text.h:154
void SetWidth(int aWidth)

References abs, BOARD::Add(), ADD_APPEND, DIMENSION::AdjustDimensionDetails(), ETEXT::align, ZONE_CONTAINER::AppendCorner(), ETEXT::BOTTOM_CENTER, ETEXT::BOTTOM_LEFT, ETEXT::BOTTOM_RIGHT, ETEXT::CENTER, ETEXT::CENTER_LEFT, ETEXT::CENTER_RIGHT, ConvertArcCenter(), EWIRE::curve, DEFAULT_PCB_EDGE_THICKNESS, EROT::degrees, ZONE_CONTAINER::DIAGONAL_EDGE, EDIMENSION::dimensionType, EagleTimeStamp(), Format(), FROM_UTF8(), ZONE_CONTAINER::GetDefaultHatchPitch(), BOARD::GetDesignSettings(), BOARD_DESIGN_SETTINGS::GetLineThickness(), ZONE_CONTAINER::GetPosition(), BOARD_DESIGN_SETTINGS::GetTextSize(), BOARD_DESIGN_SETTINGS::GetTextThickness(), GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_BOTTOM, GR_TEXT_VJUSTIFY_TOP, IsCopperLayer(), kicad_fontz(), kicad_layer(), kicad_x(), kicad_y(), EWIRE::layer, ECIRCLE::layer, ERECT::layer, EDIMENSION::layer, ETEXT::layer, loadPolygon(), m_board, m_hole_count, m_xpath, MILLIMETRES, EROT::mirror, packageHole(), XPATH::pop(), XPATH::push(), ECIRCLE::radius, ETEXT::ratio, MODULE::Reference(), ERECT::rot, ETEXT::rot, ZONE_CONTAINER::Rotate(), S_ARC, S_CIRCLE, DRAWSEGMENT::SetAngle(), DRAWSEGMENT::SetEnd(), DIMENSION::SetEnd(), ZONE_CONTAINER::SetHatch(), DIMENSION::SetHeight(), EDA_TEXT::SetHorizJustify(), DIMENSION::SetLayer(), BOARD_ITEM::SetLayer(), ZONE_CONTAINER::SetLayer(), EDA_TEXT::SetMirrored(), BOARD_CONNECTED_ITEM::SetNetCode(), DIMENSION::SetOrigin(), MODULE::SetReference(), DRAWSEGMENT::SetShape(), DRAWSEGMENT::SetStart(), EDA_TEXT::SetText(), TEXTE_PCB::SetTextAngle(), EDA_TEXT::SetTextPos(), EDA_TEXT::SetTextSize(), EDA_TEXT::SetThickness(), EDA_ITEM::SetTimeStamp(), DIMENSION::SetUnits(), EDA_TEXT::SetVertJustify(), EDA_TEXT::SetVisible(), DRAWSEGMENT::SetWidth(), DIMENSION::SetWidth(), sign(), ETEXT::size, EROT::spin, DIMENSION::Text(), ETEXT::text, ETEXT::TOP_CENTER, ETEXT::TOP_LEFT, ETEXT::TOP_RIGHT, ECOORD::ToPcbUnits(), NETINFO_LIST::UNCONNECTED, UNDEFINED_LAYER, ECIRCLE::width, ECIRCLE::x, ETEXT::x, EWIRE::x1, ERECT::x1, EDIMENSION::x1, EWIRE::x2, ERECT::x2, EDIMENSION::x2, EDIMENSION::x3, ECIRCLE::y, ETEXT::y, EWIRE::y1, ERECT::y1, EDIMENSION::y1, EWIRE::y2, ERECT::y2, EDIMENSION::y2, and EDIMENSION::y3.

Referenced by loadAllSections().

◆ loadPolygon()

ZONE_CONTAINER * EAGLE_PLUGIN::loadPolygon ( wxXmlNode *  aPolyNode)
private

Loads a copper or keepout polygon and adds it to the board.

Returns
The loaded zone or nullptr if was not processed.

Definition at line 1083 of file eagle_plugin.cpp.

1084 {
1085  EPOLYGON p( aPolyNode );
1086  PCB_LAYER_ID layer = kicad_layer( p.layer );
1087  ZONE_CONTAINER* zone = nullptr;
1088  bool keepout = ( p.layer == EAGLE_LAYER::TRESTRICT || p.layer == EAGLE_LAYER::BRESTRICT );
1089 
1090  if( !IsCopperLayer( layer ) && !keepout )
1091  return nullptr;
1092 
1093  // use a "netcode = 0" type ZONE:
1094  zone = new ZONE_CONTAINER( m_board );
1095  zone->SetTimeStamp( EagleTimeStamp( aPolyNode ) );
1096  m_board->Add( zone, ADD_APPEND );
1097 
1098  if( p.layer == EAGLE_LAYER::TRESTRICT ) // front layer keepout
1099  zone->SetLayer( F_Cu );
1100  else if( p.layer == EAGLE_LAYER::BRESTRICT ) // bottom layer keepout
1101  zone->SetLayer( B_Cu );
1102  else
1103  zone->SetLayer( layer );
1104 
1105  if( keepout )
1106  {
1107  zone->SetIsKeepout( true );
1108  zone->SetDoNotAllowVias( true );
1109  zone->SetDoNotAllowTracks( true );
1110  zone->SetDoNotAllowCopperPour( true );
1111  }
1112 
1113  // Get the first vertex and iterate
1114  wxXmlNode* vertex = aPolyNode->GetChildren();
1115  std::vector<EVERTEX> vertices;
1116 
1117  // Create a circular vector of vertices
1118  // The "curve" parameter indicates a curve from the current
1119  // to the next vertex, so we keep the first at the end as well
1120  // to allow the curve to link back
1121  while( vertex )
1122  {
1123  if( vertex->GetName() == "vertex" )
1124  vertices.push_back( EVERTEX( vertex ) );
1125 
1126  vertex = vertex->GetNext();
1127  }
1128 
1129  vertices.push_back( vertices[0] );
1130 
1131  for( size_t i = 0; i < vertices.size() - 1; i++ )
1132  {
1133  EVERTEX v1 = vertices[i];
1134 
1135  // Append the corner
1136  zone->AppendCorner( wxPoint( kicad_x( v1.x ), kicad_y( v1.y ) ), -1 );
1137 
1138  if( v1.curve )
1139  {
1140  EVERTEX v2 = vertices[i + 1];
1141  wxPoint center = ConvertArcCenter(
1142  wxPoint( kicad_x( v1.x ), kicad_y( v1.y ) ),
1143  wxPoint( kicad_x( v2.x ), kicad_y( v2.y ) ), *v1.curve );
1144  double angle = DEG2RAD( *v1.curve );
1145  double end_angle = atan2( kicad_y( v2.y ) - center.y,
1146  kicad_x( v2.x ) - center.x );
1147  double radius = sqrt( pow( center.x - kicad_x( v1.x ), 2 )
1148  + pow( center.y - kicad_y( v1.y ), 2 ) );
1149 
1150  // If we are curving, we need at least 2 segments otherwise
1151  // delta_angle == angle
1152  double delta_angle = angle / std::max(
1153  2, GetArcToSegmentCount( KiROUND( radius ),
1154  ARC_HIGH_DEF, *v1.curve ) - 1 );
1155 
1156  for( double a = end_angle + angle;
1157  fabs( a - end_angle ) > fabs( delta_angle );
1158  a -= delta_angle )
1159  {
1160  zone->AppendCorner(
1161  wxPoint( KiROUND( radius * cos( a ) ),
1162  KiROUND( radius * sin( a ) ) ) + center,
1163  -1 );
1164  }
1165  }
1166  }
1167 
1168  // If the pour is a cutout it needs to be set to a keepout
1169  if( p.pour == EPOLYGON::CUTOUT )
1170  {
1171  zone->SetIsKeepout( true );
1172  zone->SetDoNotAllowCopperPour( true );
1174  }
1175 
1176  // if spacing is set the zone should be hatched
1177  // However, use the default hatch step, p.spacing value has no meaning for Kicad
1178  // TODO: see if this parameter is related to a grid fill option.
1179  if( p.spacing )
1181 
1182  // clearances, etc.
1183  zone->SetArcSegmentCount( ARC_APPROX_SEGMENTS_COUNT_HIGH_DEF ); // @todo: should be a constructor default?
1184  zone->SetMinThickness( std::max<int>(
1185  ZONE_THICKNESS_MIN_VALUE_MIL*IU_PER_MILS, p.width.ToPcbUnits() ) );
1186 
1187  // FIXME: KiCad zones have very rounded corners compared to eagle.
1188  // This means that isolation amounts that work well in eagle
1189  // tend to make copper intrude in soldermask free areas around pads.
1190  if( p.isolate )
1191  zone->SetZoneClearance( p.isolate->ToPcbUnits() );
1192  else
1193  zone->SetZoneClearance( 1 ); // @todo: set minimum clearance value based on board settings
1194 
1195  // missing == yes per DTD.
1196  bool thermals = !p.thermals || *p.thermals;
1198 
1199  if( thermals )
1200  {
1201  // FIXME: eagle calculates dimensions for thermal spokes
1202  // based on what the zone is connecting to.
1203  // (i.e. width of spoke is half of the smaller side of an smd pad)
1204  // This is a basic workaround
1205  zone->SetThermalReliefGap( p.width.ToPcbUnits() + 50000 ); // 50000nm == 0.05mm
1206  zone->SetThermalReliefCopperBridge( p.width.ToPcbUnits() + 50000 );
1207  }
1208 
1209  int rank = p.rank ? (p.max_priority - *p.rank) : p.max_priority;
1210  zone->SetPriority( rank );
1211 
1212  return zone;
1213 }
void SetDoNotAllowTracks(bool aEnable)
Definition: class_zone.h:645
Eagle vertex.
Definition: eagle_parser.h:747
Class ZONE_CONTAINER handles a list of polygons defining a copper zone.
Definition: class_zone.h:59
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:203
BOARD * m_board
which BOARD is being worked on, no ownership here
Definition: eagle_plugin.h:187
int GetArcToSegmentCount(int aRadius, int aErrorMax, double aArcAngleDegree)
static int KiROUND(double v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: common.h:121
PCB_LAYER_ID kicad_layer(int aLayer) const
Convert an Eagle layer to a KiCad layer.
ECOORD y
Definition: eagle_parser.h:750
void SetArcSegmentCount(int aArcSegCount)
Definition: class_zone.h:185
void SetHatch(int aHatchStyle, int aHatchPitch, bool aRebuildHatch)
Function SetHatch sets all hatch parameters for the zone.
static int GetDefaultHatchPitch()
Function GetDefaultHatchPitchMils.
void SetDoNotAllowVias(bool aEnable)
Definition: class_zone.h:644
void SetPriority(unsigned aPriority)
Function SetPriority.
Definition: class_zone.h:91
PCB_LAYER_ID
A quick note on layer IDs:
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_INSERT) override
Adds an item to the container.
virtual void SetLayer(PCB_LAYER_ID aLayer) override
Function SetLayer sets the layer this item is on.
Definition: class_zone.cpp:206
void SetZoneClearance(int aZoneClearance)
Definition: class_zone.h:195
timestamp_t EagleTimeStamp(wxXmlNode *aTree)
Make a unique time stamp
opt_double curve
range is -359.9..359.9
Definition: eagle_parser.h:751
void SetThermalReliefCopperBridge(int aThermalReliefCopperBridge)
Definition: class_zone.h:176
void SetDoNotAllowCopperPour(bool aEnable)
Definition: class_zone.h:643
#define ZONE_THICKNESS_MIN_VALUE_MIL
Definition: zones.h:41
ECOORD x
Definition: eagle_parser.h:749
double DEG2RAD(double deg)
Definition: trigo.h:199
#define max(a, b)
Definition: auxiliary.h:86
wxPoint ConvertArcCenter(const wxPoint &aStart, const wxPoint &aEnd, double aAngle)
Convert an Eagle curve end to a KiCad center for S_ARC
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
size_t i
Definition: json11.cpp:597
#define IU_PER_MILS
Definition: plotter.cpp:134
void SetHatchStyle(HATCH_STYLE aStyle)
Definition: class_zone.h:538
bool IsCopperLayer(LAYER_NUM aLayerId)
Function IsCopperLayer tests whether a layer is a copper layer.
bool AppendCorner(wxPoint aPosition, int aHoleIdx, bool aAllowDuplication=false)
Add a new corner to the zone outline (to the main outline or a hole)
Eagle polygon, without vertices which are parsed as needed.
Definition: eagle_parser.h:758
void SetIsKeepout(bool aEnable)
Definition: class_zone.h:642
void SetPadConnection(ZoneConnection aPadConnection)
Definition: class_zone.h:198
void SetMinThickness(int aMinThickness)
Definition: class_zone.h:201
#define ARC_APPROX_SEGMENTS_COUNT_HIGH_DEF
Definition: pcbnew.h:42
Use thermal relief for pads.
Definition: zones.h:53
void SetThermalReliefGap(int aThermalReliefGap)
Definition: class_zone.h:173
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:202
void SetTimeStamp(timestamp_t aNewTimeStamp)
Definition: base_struct.h:206
pads are covered by copper
Definition: zones.h:54

References BOARD::Add(), ADD_APPEND, PNS::angle(), ZONE_CONTAINER::AppendCorner(), ARC_APPROX_SEGMENTS_COUNT_HIGH_DEF, B_Cu, EAGLE_LAYER::BRESTRICT, ConvertArcCenter(), EVERTEX::curve, EPOLYGON::CUTOUT, DEG2RAD(), ZONE_CONTAINER::DIAGONAL_EDGE, EagleTimeStamp(), F_Cu, GetArcToSegmentCount(), ZONE_CONTAINER::GetDefaultHatchPitch(), i, IsCopperLayer(), EPOLYGON::isolate, IU_PER_MILS, kicad_layer(), kicad_x(), kicad_y(), KiROUND(), EPOLYGON::layer, m_board, max, EPOLYGON::max_priority, ZONE_CONTAINER::NO_HATCH, PAD_ZONE_CONN_FULL, PAD_ZONE_CONN_THERMAL, EPOLYGON::pour, EPOLYGON::rank, ZONE_CONTAINER::SetArcSegmentCount(), ZONE_CONTAINER::SetDoNotAllowCopperPour(), ZONE_CONTAINER::SetDoNotAllowTracks(), ZONE_CONTAINER::SetDoNotAllowVias(), ZONE_CONTAINER::SetHatch(), ZONE_CONTAINER::SetHatchStyle(), ZONE_CONTAINER::SetIsKeepout(), ZONE_CONTAINER::SetLayer(), ZONE_CONTAINER::SetMinThickness(), ZONE_CONTAINER::SetPadConnection(), ZONE_CONTAINER::SetPriority(), ZONE_CONTAINER::SetThermalReliefCopperBridge(), ZONE_CONTAINER::SetThermalReliefGap(), EDA_ITEM::SetTimeStamp(), ZONE_CONTAINER::SetZoneClearance(), EPOLYGON::spacing, EPOLYGON::thermals, ECOORD::ToPcbUnits(), EAGLE_LAYER::TRESTRICT, EPOLYGON::width, EVERTEX::x, EVERTEX::y, and ZONE_THICKNESS_MIN_VALUE_MIL.

Referenced by loadPlain(), and loadSignals().

◆ loadSignals()

void EAGLE_PLUGIN::loadSignals ( wxXmlNode *  aSignals)
private

Definition at line 1944 of file eagle_plugin.cpp.

1945 {
1946  ZONES zones; // per net
1947 
1948  m_xpath->push( "signals.signal", "name" );
1949 
1950  int netCode = 1;
1951 
1952  // Get the first signal and iterate
1953  wxXmlNode* net = aSignals->GetChildren();
1954 
1955  while( net )
1956  {
1957  bool sawPad = false;
1958 
1959  zones.clear();
1960 
1961  const wxString& netName = escapeName( net->GetAttribute( "name" ) );
1962  m_board->Add( new NETINFO_ITEM( m_board, netName, netCode ) );
1963 
1964  m_xpath->Value( netName.c_str() );
1965 
1966  // Get the first net item and iterate
1967  wxXmlNode* netItem = net->GetChildren();
1968 
1969  // (contactref | polygon | wire | via)*
1970  while( netItem )
1971  {
1972  const wxString& itemName = netItem->GetName();
1973 
1974  if( itemName == "wire" )
1975  {
1976  m_xpath->push( "wire" );
1977 
1978  EWIRE w( netItem );
1979  PCB_LAYER_ID layer = kicad_layer( w.layer );
1980 
1981  if( IsCopperLayer( layer ) )
1982  {
1983  wxPoint start( kicad_x( w.x1 ), kicad_y( w.y1 ) );
1984  double angle = 0.0;
1985  double end_angle = 0.0;
1986  double radius = 0.0;
1987  double delta_angle = 0.0;
1988  wxPoint center;
1989 
1990  int width = w.width.ToPcbUnits();
1991  if( width < m_min_trace )
1992  m_min_trace = width;
1993 
1994  if( w.curve )
1995  {
1996  center = ConvertArcCenter(
1997  wxPoint( kicad_x( w.x1 ), kicad_y( w.y1 ) ),
1998  wxPoint( kicad_x( w.x2 ), kicad_y( w.y2 ) ),
1999  *w.curve );
2000 
2001  angle = DEG2RAD( *w.curve );
2002 
2003  end_angle = atan2( kicad_y( w.y2 ) - center.y,
2004  kicad_x( w.x2 ) - center.x );
2005 
2006  radius = sqrt( pow( center.x - kicad_x( w.x1 ), 2 ) +
2007  pow( center.y - kicad_y( w.y1 ), 2 ) );
2008 
2009  // If we are curving, we need at least 2 segments otherwise
2010  // delta_angle == angle
2011  int segments = std::max( 2, GetArcToSegmentCount( KiROUND( radius ),
2012  ARC_HIGH_DEF, *w.curve ) - 1 );
2013  delta_angle = angle / segments;
2014  }
2015 
2016  while( fabs( angle ) > fabs( delta_angle ) )
2017  {
2018  wxASSERT( radius > 0.0 );
2019  wxPoint end( KiROUND( radius * cos( end_angle + angle ) + center.x ),
2020  KiROUND( radius * sin( end_angle + angle ) + center.y ) );
2021 
2022  TRACK* t = new TRACK( m_board );
2023 
2024  t->SetTimeStamp( EagleTimeStamp( netItem ) + int( RAD2DEG( angle ) ) );
2025  t->SetPosition( start );
2026  t->SetEnd( end );
2027  t->SetWidth( width );
2028  t->SetLayer( layer );
2029  t->SetNetCode( netCode );
2030 
2031  m_board->m_Track.PushBack( t );
2032 
2033  start = end;
2034  angle -= delta_angle;
2035  }
2036 
2037  TRACK* t = new TRACK( m_board );
2038 
2039  t->SetTimeStamp( EagleTimeStamp( netItem ) );
2040  t->SetPosition( start );
2041  t->SetEnd( wxPoint( kicad_x( w.x2 ), kicad_y( w.y2 ) ) );
2042  t->SetWidth( width );
2043  t->SetLayer( layer );
2044  t->SetNetCode( netCode );
2045 
2046  m_board->m_Track.PushBack( t );
2047  }
2048  else
2049  {
2050  // put non copper wires where the sun don't shine.
2051  }
2052 
2053  m_xpath->pop();
2054  }
2055 
2056  else if( itemName == "via" )
2057  {
2058  m_xpath->push( "via" );
2059  EVIA v( netItem );
2060 
2061  PCB_LAYER_ID layer_front_most = kicad_layer( v.layer_front_most );
2062  PCB_LAYER_ID layer_back_most = kicad_layer( v.layer_back_most );
2063 
2064  if( IsCopperLayer( layer_front_most ) &&
2065  IsCopperLayer( layer_back_most ) )
2066  {
2067  int kidiam;
2068  int drillz = v.drill.ToPcbUnits();
2069  VIA* via = new VIA( m_board );
2070  m_board->m_Track.PushBack( via );
2071 
2072  via->SetLayerPair( layer_front_most, layer_back_most );
2073 
2074  if( v.diam )
2075  {
2076  kidiam = v.diam->ToPcbUnits();
2077  via->SetWidth( kidiam );
2078  }
2079  else
2080  {
2081  double annulus = drillz * m_rules->rvViaOuter; // eagle "restring"
2082  annulus = eagleClamp( m_rules->rlMinViaOuter, annulus, m_rules->rlMaxViaOuter );
2083  kidiam = KiROUND( drillz + 2 * annulus );
2084  via->SetWidth( kidiam );
2085  }
2086 
2087  via->SetDrill( drillz );
2088 
2089  // make sure the via diameter respects the restring rules
2090 
2091  if( !v.diam || via->GetWidth() <= via->GetDrill() )
2092  {
2093  double annulus = eagleClamp( m_rules->rlMinViaOuter,
2094  (double)( via->GetWidth() / 2 - via->GetDrill() ), m_rules->rlMaxViaOuter );
2095  via->SetWidth( drillz + 2 * annulus );
2096  }
2097 
2098  if( kidiam < m_min_via )
2099  m_min_via = kidiam;
2100 
2101  if( drillz < m_min_via_hole )
2102  m_min_via_hole = drillz;
2103 
2104  if( layer_front_most == F_Cu && layer_back_most == B_Cu )
2105  via->SetViaType( VIA_THROUGH );
2106  else if( layer_front_most == F_Cu || layer_back_most == B_Cu )
2107  via->SetViaType( VIA_MICROVIA );
2108  else
2109  via->SetViaType( VIA_BLIND_BURIED );
2110 
2111  via->SetTimeStamp( EagleTimeStamp( netItem ) );
2112 
2113  wxPoint pos( kicad_x( v.x ), kicad_y( v.y ) );
2114 
2115  via->SetPosition( pos );
2116  via->SetEnd( pos );
2117 
2118  via->SetNetCode( netCode );
2119  }
2120 
2121  m_xpath->pop();
2122  }
2123 
2124  else if( itemName == "contactref" )
2125  {
2126  m_xpath->push( "contactref" );
2127  // <contactref element="RN1" pad="7"/>
2128 
2129  const wxString& reference = netItem->GetAttribute( "element" );
2130  const wxString& pad = netItem->GetAttribute( "pad" );
2131  wxString key = makeKey( reference, pad ) ;
2132 
2133  // D(printf( "adding refname:'%s' pad:'%s' netcode:%d netname:'%s'\n", reference.c_str(), pad.c_str(), netCode, netName.c_str() );)
2134 
2135  m_pads_to_nets[ key ] = ENET( netCode, netName );
2136 
2137  m_xpath->pop();
2138 
2139  sawPad = true;
2140  }
2141 
2142  else if( itemName == "polygon" )
2143  {
2144  m_xpath->push( "polygon" );
2145  auto* zone = loadPolygon( netItem );
2146 
2147  if( zone )
2148  {
2149  zones.push_back( zone );
2150 
2151  if( !zone->GetIsKeepout() )
2152  zone->SetNetCode( netCode );
2153  }
2154 
2155  m_xpath->pop(); // "polygon"
2156  }
2157 
2158  netItem = netItem->GetNext();
2159  }
2160 
2161  if( zones.size() && !sawPad )
2162  {
2163  // KiCad does not support an unconnected zone with its own non-zero netcode,
2164  // but only when assigned netcode = 0 w/o a name...
2165  for( ZONES::iterator it = zones.begin(); it != zones.end(); ++it )
2166  (*it)->SetNetCode( NETINFO_LIST::UNCONNECTED );
2167 
2168  // therefore omit this signal/net.
2169  }
2170  else
2171  netCode++;
2172 
2173  // Get next signal
2174  net = net->GetNext();
2175  }
2176 
2177  m_xpath->pop(); // "signals.signal"
2178 }
double rlMaxViaOuter
maximum copper annulus on via
Definition: eagle_plugin.h:75
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:203
static T eagleClamp(T aMin, T aValue, T aMax)
BOARD * m_board
which BOARD is being worked on, no ownership here
Definition: eagle_plugin.h:187
int GetArcToSegmentCount(int aRadius, int aErrorMax, double aArcAngleDegree)
void SetViaType(VIATYPE_T aViaType)
Definition: class_track.h:462
static int KiROUND(double v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: common.h:121
PCB_LAYER_ID kicad_layer(int aLayer) const
Convert an Eagle layer to a KiCad layer.
void SetPosition(const wxPoint &aPoint) override
Definition: class_track.h:434
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
void SetEnd(const wxPoint &aEnd)
Definition: class_track.h:122
ERULES * m_rules
Eagle design rules.
Definition: eagle_plugin.h:173
void push(const char *aPathSegment, const char *aAttribute="")
Definition: eagle_parser.h:117
double RAD2DEG(double rad)
Definition: trigo.h:200
int m_min_via
smallest via we find on Load(), in BIU.
Definition: eagle_plugin.h:190
double rvViaOuter
copper annulus is this percent of via hole
Definition: eagle_plugin.h:73
XPATH * m_xpath
keeps track of what we are working on within XML document during a Load().
Definition: eagle_plugin.h:174
void SetWidth(int aWidth)
Definition: class_track.h:119
void PushBack(T *aNewElement)
Function PushBack puts aNewElement at the end of the list sequence.
Definition: dlist.h:250
PCB_LAYER_ID
A quick note on layer IDs:
int m_min_via_hole
smallest via diameter hole we find on Load(), in BIU.
Definition: eagle_plugin.h:191
static wxString makeKey(const wxString &aFirst, const wxString &aSecond)
Assemble a two part key as a simple concatenation of aFirst and aSecond parts, using a separator.
wxString escapeName(const wxString &aNetName)
Translates Eagle special characters to their counterparts in KiCad.
int GetDrill() const
Function GetDrill returns the local drill setting for this VIA.
Definition: class_track.h:476
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_INSERT) override
Adds an item to the container.
bool SetNetCode(int aNetCode, bool aNoAssert=false)
Function SetNetCode sets net using a net code.
void SetLayerPair(PCB_LAYER_ID aTopLayer, PCB_LAYER_ID aBottomLayer)
Function SetLayerPair For a via m_Layer contains the top layer, the other layer is in m_BottomLayer.
timestamp_t EagleTimeStamp(wxXmlNode *aTree)
Make a unique time stamp
int m_min_trace
smallest trace we find on Load(), in BIU.
Definition: eagle_plugin.h:189
Eagle net.
Definition: eagle_parser.h:462
Eagle via.
Definition: eagle_parser.h:556
Class NETINFO_ITEM handles the data for a net.
Definition: netinfo.h:69
int GetWidth() const
Definition: class_track.h:120
double DEG2RAD(double deg)
Definition: trigo.h:199
#define max(a, b)
Definition: auxiliary.h:86
void SetPosition(const wxPoint &aPos) override
Definition: class_track.h:116
wxPoint ConvertArcCenter(const wxPoint &aStart, const wxPoint &aEnd, double aAngle)
Convert an Eagle curve end to a KiCad center for S_ARC
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
void SetDrill(int aDrill)
Function SetDrill sets the drill value for vias.
Definition: class_track.h:469
NET_MAP m_pads_to_nets
net list
Definition: eagle_plugin.h:179
Eagle wire.
Definition: eagle_parser.h:500
bool IsCopperLayer(LAYER_NUM aLayerId)
Function IsCopperLayer tests whether a layer is a copper layer.
DLIST< TRACK > m_Track
Definition: class_board.h:250
void pop()
Definition: eagle_parser.h:124
std::vector< ZONE_CONTAINER * > ZONES
Definition: eagle_plugin.h:39
ZONE_CONTAINER * loadPolygon(wxXmlNode *aPolyNode)
Loads a copper or keepout polygon and adds it to the board.
double rlMinViaOuter
minimum copper annulus on via
Definition: eagle_plugin.h:74
static const int UNCONNECTED
Constant that holds the "unconnected net" number (typically 0) all items "connected" to this net are ...
Definition: netinfo.h:469
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:202
void SetTimeStamp(timestamp_t aNewTimeStamp)
Definition: base_struct.h:206
void Value(const char *aValue)
modify the last path node's value
Definition: eagle_parser.h:127

References BOARD::Add(), PNS::angle(), B_Cu, ConvertArcCenter(), EWIRE::curve, DEG2RAD(), EVIA::diam, EVIA::drill, eagleClamp(), EagleTimeStamp(), escapeName(), F_Cu, GetArcToSegmentCount(), VIA::GetDrill(), TRACK::GetWidth(), IsCopperLayer(), kicad_layer(), kicad_x(), kicad_y(), KiROUND(), EWIRE::layer, EVIA::layer_back_most, EVIA::layer_front_most, loadPolygon(), m_board, m_min_trace, m_min_via, m_min_via_hole, m_pads_to_nets, m_rules, BOARD::m_Track, m_xpath, makeKey(), max, XPATH::pop(), XPATH::push(), DLIST< T >::PushBack(), RAD2DEG(), ERULES::rlMaxViaOuter, ERULES::rlMinViaOuter, ERULES::rvViaOuter, VIA::SetDrill(), TRACK::SetEnd(), BOARD_ITEM::SetLayer(), VIA::SetLayerPair(), BOARD_CONNECTED_ITEM::SetNetCode(), TRACK::SetPosition(), VIA::SetPosition(), EDA_ITEM::SetTimeStamp(), VIA::SetViaType(), TRACK::SetWidth(), ECOORD::ToPcbUnits(), NETINFO_LIST::UNCONNECTED, XPATH::Value(), VIA, VIA_BLIND_BURIED, VIA_MICROVIA, VIA_THROUGH, EWIRE::width, EVIA::x, EWIRE::x1, EWIRE::x2, EVIA::y, EWIRE::y1, and EWIRE::y2.

Referenced by loadAllSections().

◆ makeModule()

MODULE * EAGLE_PLUGIN::makeModule ( wxXmlNode *  aPackage,
const wxString &  aPkgName 
) const
private

Function makeModule creates a MODULE from an Eagle package.

Definition at line 1346 of file eagle_plugin.cpp.

1347 {
1348  std::unique_ptr<MODULE> m( new MODULE( m_board ) );
1349 
1350  LIB_ID fpID;
1351  fpID.Parse( aPkgName, LIB_ID::ID_PCB, true );
1352  m->SetFPID( fpID );
1353 
1354  // Get the first package item and iterate
1355  wxXmlNode* packageItem = aPackage->GetChildren();
1356 
1357  while( packageItem )
1358  {
1359  const wxString& itemName = packageItem->GetName();
1360 
1361  if( itemName == "description" )
1362  m->SetDescription( FROM_UTF8( packageItem->GetNodeContent().c_str() ) );
1363 
1364  else if( itemName == "wire" )
1365  packageWire( m.get(), packageItem );
1366 
1367  else if( itemName == "pad" )
1368  packagePad( m.get(), packageItem );
1369 
1370  else if( itemName == "text" )
1371  packageText( m.get(), packageItem );
1372 
1373  else if( itemName == "rectangle" )
1374  packageRectangle( m.get(), packageItem );
1375 
1376  else if( itemName == "polygon" )
1377  packagePolygon( m.get(), packageItem );
1378 
1379  else if( itemName == "circle" )
1380  packageCircle( m.get(), packageItem );
1381 
1382  else if( itemName == "hole" )
1383  packageHole( m.get(), packageItem, false );
1384 
1385  else if( itemName == "smd" )
1386  packageSMD( m.get(), packageItem );
1387 
1388  packageItem = packageItem->GetNext();
1389  }
1390 
1391  return m.release();
1392 }
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes.
Definition: macros.h:53
BOARD * m_board
which BOARD is being worked on, no ownership here
Definition: eagle_plugin.h:187
void packageText(MODULE *aModule, wxXmlNode *aTree) const
A logical library item identifier and consists of various portions much like a URI.
Definition: lib_id.h:51
void packageHole(MODULE *aModule, wxXmlNode *aTree, bool aCenter) const
Function packageHole @parameter aModule - The KiCad module to which to assign the hole @parameter aTr...
void packagePad(MODULE *aModule, wxXmlNode *aTree) const
void packagePolygon(MODULE *aModule, wxXmlNode *aTree) const
void packageWire(MODULE *aModule, wxXmlNode *aTree) const
void packageRectangle(MODULE *aModule, wxXmlNode *aTree) const
void packageSMD(MODULE *aModule, wxXmlNode *aTree) const
int Parse(const UTF8 &aId, LIB_ID_TYPE aType, bool aFix=false)
Parse LIB_ID with the information from aId.
Definition: lib_id.cpp:122
void packageCircle(MODULE *aModule, wxXmlNode *aTree) const

References FROM_UTF8(), LIB_ID::ID_PCB, m_board, packageCircle(), packageHole(), packagePad(), packagePolygon(), packageRectangle(), packageSMD(), packageText(), packageWire(), and LIB_ID::Parse().

Referenced by loadLibrary().

◆ orientModuleAndText()

void EAGLE_PLUGIN::orientModuleAndText ( MODULE m,
const EELEMENT e,
const EATTR nameAttr,
const EATTR valueAttr 
)
private

Definition at line 1216 of file eagle_plugin.cpp.

1218 {
1219  if( e.rot )
1220  {
1221  if( e.rot->mirror )
1222  {
1223  double orientation = e.rot->degrees + 180.0;
1224  m->SetOrientation( orientation * 10 );
1225  m->Flip( m->GetPosition() );
1226  }
1227  else
1228  m->SetOrientation( e.rot->degrees * 10 );
1229  }
1230 
1231  orientModuleText( m, e, &m->Reference(), nameAttr );
1232  orientModuleText( m, e, &m->Value(), valueAttr );
1233 }
bool mirror
Definition: eagle_parser.h:481
TEXTE_MODULE & Reference()
Definition: class_module.h:503
void Flip(const wxPoint &aCentre) override
Function Flip Flip this object, i.e.
opt_erot rot
Definition: eagle_parser.h:808
double degrees
Definition: eagle_parser.h:483
TEXTE_MODULE & Value()
read/write accessors:
Definition: class_module.h:502
void SetOrientation(double newangle)
const wxPoint GetPosition() const override
Definition: class_module.h:183
void orientModuleText(MODULE *m, const EELEMENT &e, TEXTE_MODULE *txt, const EATTR *a)

References EROT::degrees, MODULE::Flip(), MODULE::GetPosition(), EROT::mirror, orientModuleText(), MODULE::Reference(), EELEMENT::rot, MODULE::SetOrientation(), and MODULE::Value().

Referenced by loadElements().

◆ orientModuleText()

void EAGLE_PLUGIN::orientModuleText ( MODULE m,
const EELEMENT e,
TEXTE_MODULE txt,
const EATTR a 
)
private

Definition at line 1236 of file eagle_plugin.cpp.

1238 {
1239  // Smashed part ?
1240  if( aAttr )
1241  { // Yes
1242  const EATTR& a = *aAttr;
1243 
1244  if( a.value )
1245  {
1246  txt->SetText( FROM_UTF8( a.value->c_str() ) );
1247  }
1248 
1249  if( a.x && a.y ) // OPT
1250  {
1251  wxPoint pos( kicad_x( *a.x ), kicad_y( *a.y ) );
1252  txt->SetTextPos( pos );
1253  }
1254 
1255  // Even though size and ratio are both optional, I am not seeing
1256  // a case where ratio is present but size is not.
1257  double ratio = 8;
1258  wxSize fontz = txt->GetTextSize();
1259 
1260  if( a.size )
1261  {
1262  fontz = kicad_fontz( *a.size );
1263  txt->SetTextSize( fontz );
1264 
1265  if( a.ratio )
1266  ratio = *a.ratio;
1267  }
1268 
1269  int lw = int( fontz.y * ratio / 100 );
1270  txt->SetThickness( lw );
1271 
1272  int align = ETEXT::BOTTOM_LEFT; // bottom-left is eagle default
1273 
1274  // The "rot" in a EATTR seems to be assumed to be zero if it is not
1275  // present, and this zero rotation becomes an override to the
1276  // package's text field. If they did not want zero, they specify
1277  // what they want explicitly.
1278  double degrees = a.rot ? a.rot->degrees : 0;
1279  double orient; // relative to parent
1280 
1281  int sign = 1;
1282  bool spin = false;
1283 
1284  if( a.rot )
1285  {
1286  spin = a.rot->spin;
1287  sign = a.rot->mirror ? -1 : 1;
1288  txt->SetMirrored( a.rot->mirror );
1289  }
1290 
1291  if( degrees == 90 || degrees == 0 || spin )
1292  {
1293  orient = degrees - m->GetOrientation() / 10;
1294  txt->SetTextAngle( sign * orient * 10 );
1295  }
1296  else if( degrees == 180 )
1297  {
1298  orient = 0 - m->GetOrientation() / 10;
1299  txt->SetTextAngle( sign * orient * 10 );
1300  align = ETEXT::TOP_RIGHT;
1301  }
1302  else if( degrees == 270 )
1303  {
1304  orient = 90 - m->GetOrientation() / 10;
1305  align = ETEXT::TOP_RIGHT;
1306  txt->SetTextAngle( sign * orient * 10 );
1307  }
1308  else
1309  {
1310  orient = 90 - degrees - m->GetOrientation() / 10;
1311  txt->SetTextAngle( sign * orient * 10 );
1312  }
1313 
1314  switch( align )
1315  {
1316  case ETEXT::TOP_RIGHT:
1319  break;
1320 
1321  case ETEXT::BOTTOM_LEFT:
1324  break;
1325 
1326  default:
1327  ;
1328  }
1329  }
1330  else // Part is not smash so use Lib default for NAME/VALUE // the text is per the original package, sans <attribute>
1331  {
1332  double degrees = ( txt->GetTextAngle() + m->GetOrientation() ) / 10;
1333 
1334  // @todo there are a few more cases than these to contend with:
1335  if( (!txt->IsMirrored() && ( abs( degrees ) == 180 || abs( degrees ) == 270 ))
1336  || ( txt->IsMirrored() && ( degrees == 360 ) ) )
1337  {
1338  // ETEXT::TOP_RIGHT:
1341  }
1342  }
1343 }
void SetMirrored(bool isMirrored)
Definition: eda_text.h:191
bool mirror
Definition: eagle_parser.h:481
double GetOrientation() const
Definition: class_module.h:188
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:203
bool IsMirrored() const
Definition: eda_text.h:192
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes.
Definition: macros.h:53
void SetTextPos(const wxPoint &aPoint)
Definition: eda_text.h:236
double GetTextAngle() const
Definition: eda_text.h:177
double degrees
Definition: eagle_parser.h:483
void SetTextSize(const wxSize &aNewSize)
Definition: eda_text.h:227
#define abs(a)
Definition: auxiliary.h:84
opt_erot rot
Definition: eagle_parser.h:612
opt_ecoord y
Definition: eagle_parser.h:608
const wxSize & GetTextSize() const
Definition: eda_text.h:228
void SetVertJustify(EDA_TEXT_VJUSTIFY_T aType)
Definition: eda_text.h:207
opt_wxString value
Definition: eagle_parser.h:606
Class EATTR parses an Eagle "attribute" XML element.
Definition: eagle_parser.h:603
opt_ecoord x
Definition: eagle_parser.h:607
void SetHorizJustify(EDA_TEXT_HJUSTIFY_T aType)
Definition: eda_text.h:206
opt_double ratio
Definition: eagle_parser.h:611
wxSize kicad_fontz(const ECOORD &d) const
create a font size (fontz) from an eagle font size scalar
void SetTextAngle(double aAngle)
bool spin
Definition: eagle_parser.h:482
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:202
void SetThickness(int aNewThickness)
Function SetThickness sets pen width.
Definition: eda_text.h:161
opt_ecoord size
Definition: eagle_parser.h:609
int sign(T val)
Definition: math_util.h:44
virtual void SetText(const wxString &aText)
Definition: eda_text.h:154

References abs, ETEXT::BOTTOM_LEFT, EROT::degrees, FROM_UTF8(), MODULE::GetOrientation(), EDA_TEXT::GetTextAngle(), EDA_TEXT::GetTextSize(), GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_BOTTOM, GR_TEXT_VJUSTIFY_TOP, EDA_TEXT::IsMirrored(), kicad_fontz(), kicad_x(), kicad_y(), EROT::mirror, EATTR::ratio, EATTR::rot, EDA_TEXT::SetHorizJustify(), EDA_TEXT::SetMirrored(), EDA_TEXT::SetText(), TEXTE_MODULE::SetTextAngle(), EDA_TEXT::SetTextPos(), EDA_TEXT::SetTextSize(), EDA_TEXT::SetThickness(), EDA_TEXT::SetVertJustify(), sign(), EATTR::size, EROT::spin, ETEXT::TOP_RIGHT, EATTR::value, EATTR::x, and EATTR::y.

Referenced by orientModuleAndText().

◆ packageCircle()

void EAGLE_PLUGIN::packageCircle ( MODULE aModule,
wxXmlNode *  aTree 
) const
private

Definition at line 1741 of file eagle_plugin.cpp.

1742 {
1743  ECIRCLE e( aTree );
1744  PCB_LAYER_ID layer = kicad_layer( e.layer );
1745  EDGE_MODULE* gr = new EDGE_MODULE( aModule, S_CIRCLE );
1746  int width = e.width.ToPcbUnits();
1747  int radius = e.radius.ToPcbUnits();
1748 
1749  // with == 0 means filled circle
1750  if( width <= 0 )
1751  {
1752  width = radius;
1753  radius = radius / 2;
1754  }
1755 
1756  aModule->GraphicalItemsList().PushBack( gr );
1757  gr->SetWidth( width );
1758 
1759  switch ( (int) layer )
1760  {
1761  case UNDEFINED_LAYER:
1762  layer = Cmts_User;
1763  break;
1764  default:
1765  break;
1766  }
1767 
1768  gr->SetLayer( layer );
1769  gr->SetTimeStamp( EagleTimeStamp( aTree ) );
1770  gr->SetStart0( wxPoint( kicad_x( e.x ), kicad_y( e.y ) ) );
1771  gr->SetEnd0( wxPoint( kicad_x( e.x ) + radius, kicad_y( e.y ) ) );
1772  gr->SetDrawCoord();
1773 }
void SetEnd0(const wxPoint &aPoint)
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:203
PCB_LAYER_ID kicad_layer(int aLayer) const
Convert an Eagle layer to a KiCad layer.
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
void PushBack(T *aNewElement)
Function PushBack puts aNewElement at the end of the list sequence.
Definition: dlist.h:250
PCB_LAYER_ID
A quick note on layer IDs:
Eagle circle.
Definition: eagle_parser.h:571
timestamp_t EagleTimeStamp(wxXmlNode *aTree)
Make a unique time stamp
void SetDrawCoord()
Set draw coordinates (absolute values ) from relative coordinates.
void SetStart0(const wxPoint &aPoint)
DLIST< BOARD_ITEM > & GraphicalItemsList()
Definition: class_module.h:165
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:202
void SetTimeStamp(timestamp_t aNewTimeStamp)
Definition: base_struct.h:206
void SetWidth(int aWidth)

References Cmts_User, EagleTimeStamp(), MODULE::GraphicalItemsList(), kicad_layer(), kicad_x(), kicad_y(), ECIRCLE::layer, DLIST< T >::PushBack(), ECIRCLE::radius, S_CIRCLE, EDGE_MODULE::SetDrawCoord(), EDGE_MODULE::SetEnd0(), BOARD_ITEM::SetLayer(), EDGE_MODULE::SetStart0(), EDA_ITEM::SetTimeStamp(), DRAWSEGMENT::SetWidth(), ECOORD::ToPcbUnits(), UNDEFINED_LAYER, ECIRCLE::width, ECIRCLE::x, and ECIRCLE::y.

Referenced by makeModule().

◆ packageHole()

void EAGLE_PLUGIN::packageHole ( MODULE aModule,
wxXmlNode *  aTree,
bool  aCenter 
) const
private

Function packageHole @parameter aModule - The KiCad module to which to assign the hole @parameter aTree - The Eagle XML node that is of type "hole" @parameter aCenter - If true, center the hole in the module and offset the module position.

Definition at line 1776 of file eagle_plugin.cpp.

1777 {
1778  EHOLE e( aTree );
1779 
1780  // we add a PAD_ATTRIB_HOLE_NOT_PLATED pad to this module.
1781  D_PAD* pad = new D_PAD( aModule );
1782  aModule->PadsList().PushBack( pad );
1783 
1784  pad->SetShape( PAD_SHAPE_CIRCLE );
1786 
1787  // Mechanical purpose only:
1788  // no offset, no net name, no pad name allowed
1789  // pad->SetOffset( wxPoint( 0, 0 ) );
1790  // pad->SetName( wxEmptyString );
1791 
1792  wxPoint padpos( kicad_x( e.x ), kicad_y( e.y ) );
1793 
1794  if( aCenter )
1795  {
1796  pad->SetPos0( wxPoint( 0, 0 ) );
1797  aModule->SetPosition( padpos );
1798  pad->SetPosition( padpos );
1799  }
1800  else
1801  {
1802  pad->SetPos0( padpos );
1803  pad->SetPosition( padpos + aModule->GetPosition() );
1804  }
1805 
1806  wxSize sz( e.drill.ToPcbUnits(), e.drill.ToPcbUnits() );
1807 
1808  pad->SetDrillSize( sz );
1809  pad->SetSize( sz );
1810 
1811  pad->SetLayerSet( LSET::AllCuMask().set( B_Mask ).set( F_Mask ) );
1812 }
static LSET AllCuMask(int aCuLayerCount=MAX_CU_LAYERS)
Function AllCuMask returns a mask holding the requested number of Cu PCB_LAYER_IDs.
Definition: lset.cpp:676
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:203
like PAD_STANDARD, but not plated mechanical use only, no connection allowed
Definition: pad_shapes.h:66
void SetPosition(const wxPoint &aPos) override
Definition: class_pad.h:219
void SetDrillSize(const wxSize &aSize)
Definition: class_pad.h:274
Eagle hole element.
Definition: eagle_parser.h:787
void PushBack(T *aNewElement)
Function PushBack puts aNewElement at the end of the list sequence.
Definition: dlist.h:250
void SetPos0(const wxPoint &aPos)
Definition: class_pad.h:262
void SetSize(const wxSize &aSize)
Definition: class_pad.h:268
void SetPosition(const wxPoint &aPos) override
void SetAttribute(PAD_ATTR_T aAttribute)
Definition: class_pad.cpp:420
void SetLayerSet(LSET aLayerMask)
Definition: class_pad.h:408
void SetShape(PAD_SHAPE_T aShape)
Definition: class_pad.h:217
DLIST< D_PAD > & PadsList()
Definition: class_module.h:162
const wxPoint GetPosition() const override
Definition: class_module.h:183
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:202

References LSET::AllCuMask(), B_Mask, EHOLE::drill, F_Mask, MODULE::GetPosition(), kicad_x(), kicad_y(), PAD_ATTRIB_HOLE_NOT_PLATED, PAD_SHAPE_CIRCLE, MODULE::PadsList(), DLIST< T >::PushBack(), D_PAD::SetAttribute(), D_PAD::SetDrillSize(), D_PAD::SetLayerSet(), D_PAD::SetPos0(), MODULE::SetPosition(), D_PAD::SetPosition(), D_PAD::SetShape(), D_PAD::SetSize(), ECOORD::ToPcbUnits(), EHOLE::x, and EHOLE::y.

Referenced by loadPlain(), and makeModule().

◆ packagePad()

void EAGLE_PLUGIN::packagePad ( MODULE aModule,
wxXmlNode *  aTree 
) const
private

Definition at line 1437 of file eagle_plugin.cpp.

1438 {
1439  // this is thru hole technology here, no SMDs
1440  EPAD e( aTree );
1441  int shape = EPAD::UNDEF;
1442 
1443  D_PAD* pad = new D_PAD( aModule );
1444  aModule->PadsList().PushBack( pad );
1445  transferPad( e, pad );
1446 
1447  if( pad->GetName() == wxT( "1" ) && m_rules->psFirst != EPAD::UNDEF )
1448  shape = m_rules->psFirst;
1449  else if( aModule->GetLayer() == F_Cu && m_rules->psTop != EPAD::UNDEF )
1450  shape = m_rules->psTop;
1451  else if( aModule->GetLayer() == B_Cu && m_rules->psBottom != EPAD::UNDEF )
1452  shape = m_rules->psBottom;
1453 
1454  pad->SetDrillSize( wxSize( e.drill.ToPcbUnits(), e.drill.ToPcbUnits() ) );
1455  pad->SetLayerSet( LSET::AllCuMask().set( B_Mask ).set( F_Mask ) );
1456 
1457  if( shape == EPAD::ROUND || shape == EPAD::SQUARE )
1458  e.shape = shape;
1459 
1460  if( shape == EPAD::OCTAGON )
1461  e.shape = EPAD::ROUND;
1462 
1463  if( e.shape )
1464  {
1465  switch( *e.shape )
1466  {
1467  case EPAD::ROUND:
1468  wxASSERT( pad->GetShape() == PAD_SHAPE_CIRCLE ); // verify set in D_PAD constructor
1469  break;
1470 
1471  case EPAD::OCTAGON:
1472  // no KiCad octagonal pad shape, use PAD_CIRCLE for now.
1473  // pad->SetShape( PAD_OCTAGON );
1474  wxASSERT( pad->GetShape() == PAD_SHAPE_CIRCLE ); // verify set in D_PAD constructor
1475  break;
1476 
1477  case EPAD::LONG:
1478  pad->SetShape( PAD_SHAPE_OVAL );
1479  break;
1480 
1481  case EPAD::SQUARE:
1482  pad->SetShape( PAD_SHAPE_RECT );
1483  break;
1484 
1485  case EPAD::OFFSET:
1486  ; // don't know what to do here.
1487  }
1488  }
1489  else
1490  {
1491  // if shape is not present, our default is circle and that matches their default "round"
1492  }
1493 
1494  if( e.diameter )
1495  {
1496  int diameter = e.diameter->ToPcbUnits();
1497  pad->SetSize( wxSize( diameter, diameter ) );
1498  }
1499  else
1500  {
1501  double drillz = pad->GetDrillSize().x;
1502  double annulus = drillz * m_rules->rvPadTop; // copper annulus, eagle "restring"
1503  annulus = eagleClamp( m_rules->rlMinPadTop, annulus, m_rules->rlMaxPadTop );
1504  int diameter = KiROUND( drillz + 2 * annulus );
1505  pad->SetSize( wxSize( KiROUND( diameter ), KiROUND( diameter ) ) );
1506  }
1507 
1508  if( pad->GetShape() == PAD_SHAPE_OVAL )
1509  {
1510  // The Eagle "long" pad is wider than it is tall,
1511  // m_elongation is percent elongation
1512  wxSize sz = pad->GetSize();
1513  sz.x = ( sz.x * ( 100 + m_rules->psElongationLong ) ) / 100;
1514  pad->SetSize( sz );
1515  }
1516 
1517  if( e.rot )
1518  {
1519  pad->SetOrientation( e.rot->degrees * 10 );
1520  }
1521 }
static LSET AllCuMask(int aCuLayerCount=MAX_CU_LAYERS)
Function AllCuMask returns a mask holding the requested number of Cu PCB_LAYER_IDs.
Definition: lset.cpp:676
static T eagleClamp(T aMin, T aValue, T aMax)
static int KiROUND(double v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: common.h:121
int psTop
Shape of the top pads.
Definition: eagle_plugin.h:59
ERULES * m_rules
Eagle design rules.
Definition: eagle_plugin.h:173
double rlMaxPadTop
maximum copper annulus on through hole pads
Definition: eagle_plugin.h:71
void SetDrillSize(const wxSize &aSize)
Definition: class_pad.h:274
void PushBack(T *aNewElement)
Function PushBack puts aNewElement at the end of the list sequence.
Definition: dlist.h:250
Eagle thru hole pad.
Definition: eagle_parser.h:694
const wxString & GetName() const
Definition: class_pad.h:190
void SetSize(const wxSize &aSize)
Definition: class_pad.h:268
int psElongationLong
percent over 100%.
Definition: eagle_plugin.h:47
int psFirst
Shape of the first pads.
Definition: eagle_plugin.h:61
void SetLayerSet(LSET aLayerMask)
Definition: class_pad.h:408
const wxSize & GetDrillSize() const
Definition: class_pad.h:275
void transferPad(const EPAD_COMMON &aEaglePad, D_PAD *aPad) const
Handles common pad properties
void SetShape(PAD_SHAPE_T aShape)
Definition: class_pad.h:217
void SetOrientation(double aAngle)
Function SetOrientation sets the rotation angle of the pad.
Definition: class_pad.cpp:429
double rvPadTop
top pad size as percent of drill size
Definition: eagle_plugin.h:67
DLIST< D_PAD > & PadsList()
Definition: class_module.h:162
PAD_SHAPE_T GetShape() const
Function GetShape.
Definition: class_pad.h:216
const wxSize & GetSize() const
Definition: class_pad.h:269
int psBottom
Shape of the bottom pads.
Definition: eagle_plugin.h:60
double rlMinPadTop
minimum copper annulus on through hole pads
Definition: eagle_plugin.h:70
virtual PCB_LAYER_ID GetLayer() const
Function GetLayer returns the primary layer this item is on.

References LSET::AllCuMask(), B_Cu, B_Mask, EROT::degrees, EPAD::diameter, EPAD::drill, eagleClamp(), F_Cu, F_Mask, D_PAD::GetDrillSize(), BOARD_ITEM::GetLayer(), D_PAD::GetName(), D_PAD::GetShape(), D_PAD::GetSize(), KiROUND(), EPAD::LONG, m_rules, EPAD::OCTAGON, EPAD::OFFSET, PAD_SHAPE_CIRCLE, PAD_SHAPE_OVAL, PAD_SHAPE_RECT, MODULE::PadsList(), ERULES::psBottom, ERULES::psElongationLong, ERULES::psFirst, ERULES::psTop, DLIST< T >::PushBack(), ERULES::rlMaxPadTop, ERULES::rlMinPadTop, EPAD_COMMON::rot, EPAD::ROUND, ERULES::rvPadTop, D_PAD::SetDrillSize(), D_PAD::SetLayerSet(), D_PAD::SetOrientation(), D_PAD::SetShape(), D_PAD::SetSize(), EPAD::shape, EPAD::SQUARE, ECOORD::ToPcbUnits(), transferPad(), and EPAD::UNDEF.

Referenced by makeModule().

◆ packagePolygon()

void EAGLE_PLUGIN::packagePolygon ( MODULE aModule,
wxXmlNode *  aTree 
) const
private

Definition at line 1665 of file eagle_plugin.cpp.

1666 {
1667  EPOLYGON p( aTree );
1668  PCB_LAYER_ID layer = kicad_layer( p.layer );
1669  EDGE_MODULE* dwg = new EDGE_MODULE( aModule, S_POLYGON );
1670 
1671  aModule->GraphicalItemsList().PushBack( dwg );
1672 
1673  dwg->SetWidth( 0 ); // it's filled, no need for boundary width
1674  dwg->SetLayer( layer );
1675  dwg->SetTimeStamp( EagleTimeStamp( aTree ) );
1676 
1677  std::vector<wxPoint> pts;
1678  // TODO: I think there's no way to know a priori the number of children in wxXmlNode :()
1679  // pts.reserve( aTree.size() );
1680 
1681  // Get the first vertex and iterate
1682  wxXmlNode* vertex = aTree->GetChildren();
1683  std::vector<EVERTEX> vertices;
1684 
1685  // Create a circular vector of vertices
1686  // The "curve" parameter indicates a curve from the current
1687  // to the next vertex, so we keep the first at the end as well
1688  // to allow the curve to link back
1689  while( vertex )
1690  {
1691  if( vertex->GetName() == "vertex" )
1692  vertices.push_back( EVERTEX( vertex ) );
1693 
1694  vertex = vertex->GetNext();
1695  }
1696 
1697  vertices.push_back( vertices[0] );
1698 
1699  for( size_t i = 0; i < vertices.size() - 1; i++ )
1700  {
1701  EVERTEX v1 = vertices[i];
1702 
1703  // Append the corner
1704  pts.push_back( wxPoint( kicad_x( v1.x ), kicad_y( v1.y ) ) );
1705 
1706  if( v1.curve )
1707  {
1708  EVERTEX v2 = vertices[i + 1];
1709  wxPoint center = ConvertArcCenter(
1710  wxPoint( kicad_x( v1.x ), kicad_y( v1.y ) ),
1711  wxPoint( kicad_x( v2.x ), kicad_y( v2.y ) ), *v1.curve );
1712  double angle = DEG2RAD( *v1.curve );
1713  double end_angle = atan2( kicad_y( v2.y ) - center.y,
1714  kicad_x( v2.x ) - center.x );
1715  double radius = sqrt( pow( center.x - kicad_x( v1.x ), 2 )
1716  + pow( center.y - kicad_y( v1.y ), 2 ) );
1717 
1718  // If we are curving, we need at least 2 segments otherwise
1719  // delta_angle == angle
1720  double delta_angle = angle / std::max(
1721  2, GetArcToSegmentCount( KiROUND( radius ),
1722  ARC_HIGH_DEF, *v1.curve ) - 1 );
1723 
1724  for( double a = end_angle + angle;
1725  fabs( a - end_angle ) > fabs( delta_angle );
1726  a -= delta_angle )
1727  {
1728  pts.push_back(
1729  wxPoint( KiROUND( radius * cos( a ) ),
1730  KiROUND( radius * sin( a ) ) ) + center );
1731  }
1732  }
1733  }
1734 
1735  dwg->SetPolyPoints( pts );
1736  dwg->SetStart0( *pts.begin() );
1737  dwg->SetEnd0( pts.back() );
1738  dwg->SetDrawCoord();
1739 }
Eagle vertex.
Definition: eagle_parser.h:747
void SetEnd0(const wxPoint &aPoint)
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:203
int GetArcToSegmentCount(int aRadius, int aErrorMax, double aArcAngleDegree)
static int KiROUND(double v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: common.h:121
PCB_LAYER_ID kicad_layer(int aLayer) const
Convert an Eagle layer to a KiCad layer.
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
ECOORD y
Definition: eagle_parser.h:750
polygon (not yet used for tracks, but could be in microwave apps)
void PushBack(T *aNewElement)
Function PushBack puts aNewElement at the end of the list sequence.
Definition: dlist.h:250
PCB_LAYER_ID
A quick note on layer IDs:
timestamp_t EagleTimeStamp(wxXmlNode *aTree)
Make a unique time stamp
opt_double curve
range is -359.9..359.9
Definition: eagle_parser.h:751
void SetPolyPoints(const std::vector< wxPoint > &aPoints)
ECOORD x
Definition: eagle_parser.h:749
double DEG2RAD(double deg)
Definition: trigo.h:199
#define max(a, b)
Definition: auxiliary.h:86
wxPoint ConvertArcCenter(const wxPoint &aStart, const wxPoint &aEnd, double aAngle)
Convert an Eagle curve end to a KiCad center for S_ARC
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
size_t i
Definition: json11.cpp:597
void SetDrawCoord()
Set draw coordinates (absolute values ) from relative coordinates.
void SetStart0(const wxPoint &aPoint)
DLIST< BOARD_ITEM > & GraphicalItemsList()
Definition: class_module.h:165
Eagle polygon, without vertices which are parsed as needed.
Definition: eagle_parser.h:758
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:202
void SetTimeStamp(timestamp_t aNewTimeStamp)
Definition: base_struct.h:206
void SetWidth(int aWidth)

References PNS::angle(), ConvertArcCenter(), EVERTEX::curve, DEG2RAD(), EagleTimeStamp(), GetArcToSegmentCount(), MODULE::GraphicalItemsList(), i, kicad_layer(), kicad_x(), kicad_y(), KiROUND(), EPOLYGON::layer, max, DLIST< T >::PushBack(), S_POLYGON, EDGE_MODULE::SetDrawCoord(), EDGE_MODULE::SetEnd0(), BOARD_ITEM::SetLayer(), DRAWSEGMENT::SetPolyPoints(), EDGE_MODULE::SetStart0(), EDA_ITEM::SetTimeStamp(), DRAWSEGMENT::SetWidth(), EVERTEX::x, and EVERTEX::y.

Referenced by makeModule().

◆ packageRectangle()

void EAGLE_PLUGIN::packageRectangle ( MODULE aModule,
wxXmlNode *  aTree 
) const
private

Definition at line 1630 of file eagle_plugin.cpp.

1631 {
1632  ERECT r( aTree );
1633  PCB_LAYER_ID layer = kicad_layer( r.layer );
1634  EDGE_MODULE* dwg = new EDGE_MODULE( aModule, S_POLYGON );
1635 
1636  aModule->GraphicalItemsList().PushBack( dwg );
1637 
1638  dwg->SetLayer( layer );
1639  dwg->SetWidth( 0 );
1640 
1641  dwg->SetTimeStamp( EagleTimeStamp( aTree ) );
1642 
1643  std::vector<wxPoint> pts;
1644 
1645  wxPoint start( wxPoint( kicad_x( r.x1 ), kicad_y( r.y1 ) ) );
1646  wxPoint end( wxPoint( kicad_x( r.x1 ), kicad_y( r.y2 ) ) );
1647 
1648  pts.push_back( start );
1649  pts.push_back( wxPoint( kicad_x( r.x2 ), kicad_y( r.y1 ) ) );
1650  pts.push_back( wxPoint( kicad_x( r.x2 ), kicad_y( r.y2 ) ) );
1651  pts.push_back( end );
1652 
1653  dwg->SetPolyPoints( pts );
1654 
1655  dwg->SetStart0( start );
1656  dwg->SetEnd0( end );
1657 
1658  if( r.rot )
1659  {
1660  dwg->Rotate( dwg->GetCenter(), r.rot->degrees * 10 );
1661  }
1662 }
void SetEnd0(const wxPoint &aPoint)
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:203
PCB_LAYER_ID kicad_layer(int aLayer) const
Convert an Eagle layer to a KiCad layer.
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
const wxPoint GetCenter() const override
Function GetCenter()
polygon (not yet used for tracks, but could be in microwave apps)
void PushBack(T *aNewElement)
Function PushBack puts aNewElement at the end of the list sequence.
Definition: dlist.h:250
void Rotate(const wxPoint &aRotCentre, double aAngle) override
Rotate an edge of the footprint.
PCB_LAYER_ID
A quick note on layer IDs:
timestamp_t EagleTimeStamp(wxXmlNode *aTree)
Make a unique time stamp
Eagle XML rectangle in binary.
Definition: eagle_parser.h:584
void SetPolyPoints(const std::vector< wxPoint > &aPoints)
void SetStart0(const wxPoint &aPoint)
DLIST< BOARD_ITEM > & GraphicalItemsList()
Definition: class_module.h:165
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:202
void SetTimeStamp(timestamp_t aNewTimeStamp)
Definition: base_struct.h:206
void SetWidth(int aWidth)

References EROT::degrees, EagleTimeStamp(), DRAWSEGMENT::GetCenter(), MODULE::GraphicalItemsList(), kicad_layer(), kicad_x(), kicad_y(), ERECT::layer, DLIST< T >::PushBack(), ERECT::rot, EDGE_MODULE::Rotate(), S_POLYGON, EDGE_MODULE::SetEnd0(), BOARD_ITEM::SetLayer(), DRAWSEGMENT::SetPolyPoints(), EDGE_MODULE::SetStart0(), EDA_ITEM::SetTimeStamp(), DRAWSEGMENT::SetWidth(), ERECT::x1, ERECT::x2, ERECT::y1, and ERECT::y2.

Referenced by makeModule().

◆ packageSMD()

void EAGLE_PLUGIN::packageSMD ( MODULE aModule,
wxXmlNode *  aTree 
) const
private

Definition at line 1815 of file eagle_plugin.cpp.

1816 {
1817  ESMD e( aTree );
1818  PCB_LAYER_ID layer = kicad_layer( e.layer );
1819 
1820  if( !IsCopperLayer( layer ) )
1821  return;
1822 
1823  bool shape_set = false;
1824  int shape = EPAD::UNDEF;
1825  D_PAD* pad = new D_PAD( aModule );
1826  aModule->PadsList().PushBack( pad );
1827  transferPad( e, pad );
1828 
1829  if( pad->GetName() == wxT( "1" ) && m_rules->psFirst != EPAD::UNDEF )
1830  shape = m_rules->psFirst;
1831  else if( layer == F_Cu && m_rules->psTop != EPAD::UNDEF )
1832  shape = m_rules->psTop;
1833  else if( layer == B_Cu && m_rules->psBottom != EPAD::UNDEF )
1834  shape = m_rules->psBottom;
1835 
1836  switch( shape )
1837  {
1838  case EPAD::ROUND:
1839  case EPAD::OCTAGON:
1840  shape_set = true;
1841  pad->SetShape( PAD_SHAPE_CIRCLE );
1842  break;
1843 
1844  case EPAD::SQUARE:
1845  shape_set = true;
1846  pad->SetShape( PAD_SHAPE_RECT );
1847  break;
1848 
1849  default:
1850  pad->SetShape( PAD_SHAPE_RECT );
1851  }
1852 
1853  pad->SetAttribute( PAD_ATTRIB_SMD );
1854 
1855  wxSize padSize( e.dx.ToPcbUnits(), e.dy.ToPcbUnits() );
1856  pad->SetSize( padSize );
1857  pad->SetLayer( layer );
1858 
1859  const LSET front( 3, F_Cu, F_Paste, F_Mask );
1860  const LSET back( 3, B_Cu, B_Paste, B_Mask );
1861 
1862  if( layer == F_Cu )
1863  pad->SetLayerSet( front );
1864  else if( layer == B_Cu )
1865  pad->SetLayerSet( back );
1866 
1867  int minPadSize = std::min( padSize.x, padSize.y );
1868 
1869  // Rounded rectangle pads
1870  int roundRadius = eagleClamp( m_rules->srMinRoundness * 2,
1871  (int)( minPadSize * m_rules->srRoundness ), m_rules->srMaxRoundness * 2 );
1872 
1873  if( !shape_set && ( e.roundness || roundRadius > 0 ) )
1874  {
1875  double roundRatio = (double) roundRadius / minPadSize / 2.0;
1876 
1877  // Eagle uses a different definition of roundness, hence division by 200
1878  if( e.roundness )
1879  roundRatio = std::fmax( *e.roundness / 200.0, roundRatio );
1880 
1881  pad->SetShape( PAD_SHAPE_ROUNDRECT );
1882  pad->SetRoundRectRadiusRatio( roundRatio );
1883  }
1884 
1885  if( e.rot )
1886  {
1887  pad->SetOrientation( e.rot->degrees * 10 );
1888  }
1889 
1891  (int) ( m_rules->mvCreamFrame * minPadSize ),
1892  m_rules->mlMaxCreamFrame ) );
1893 
1894  // Solder paste (only for SMD pads)
1895  if( e.cream && *e.cream == false ) // enabled by default
1896  {
1897  if( layer == F_Cu )
1898  pad->SetLayerSet( pad->GetLayerSet().set( F_Paste, false ) );
1899  else if( layer == B_Cu )
1900  pad->SetLayerSet( pad->GetLayerSet().set( B_Paste, false ) );
1901  }
1902 }
static T eagleClamp(T aMin, T aValue, T aMax)
PCB_LAYER_ID kicad_layer(int aLayer) const
Convert an Eagle layer to a KiCad layer.
int psTop
Shape of the top pads.
Definition: eagle_plugin.h:59
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
ERULES * m_rules
Eagle design rules.
Definition: eagle_plugin.h:173
Smd pad, appears on the solder paste layer (default)
Definition: pad_shapes.h:62
int srMinRoundness
corner rounding radius, minimum size (Eagle mils, here nanometers)
Definition: eagle_plugin.h:64
Eagle SMD pad.
Definition: eagle_parser.h:716
void SetRoundRectRadiusRatio(double aRadiusScale)
has meaning only for rounded rect pads Set the scaling factor between the smaller Y or Y size and the...
Definition: class_pad.h:653
void PushBack(T *aNewElement)
Function PushBack puts aNewElement at the end of the list sequence.
Definition: dlist.h:250
PCB_LAYER_ID
A quick note on layer IDs:
Class LSET is a set of PCB_LAYER_IDs.
LSET GetLayerSet() const override
Function GetLayerSet returns a "layer mask", which is a bitmap of all layers on which the TRACK segme...
Definition: class_pad.h:409
const wxString & GetName() const
Definition: class_pad.h:190
void SetSize(const wxSize &aSize)
Definition: class_pad.h:268
double srRoundness
corner rounding ratio for SMD pads (percentage)
Definition: eagle_plugin.h:63
void SetAttribute(PAD_ATTR_T aAttribute)
Definition: class_pad.cpp:420
int psFirst
Shape of the first pads.
Definition: eagle_plugin.h:61
void SetLayerSet(LSET aLayerMask)
Definition: class_pad.h:408
int mlMinCreamFrame
solder paste mask, minimum size (Eagle mils, here nanometers)
Definition: eagle_plugin.h:56
void transferPad(const EPAD_COMMON &aEaglePad, D_PAD *aPad) const
Handles common pad properties
void SetShape(PAD_SHAPE_T aShape)
Definition: class_pad.h:217
void SetOrientation(double aAngle)
Function SetOrientation sets the rotation angle of the pad.
Definition: class_pad.cpp:429
bool IsCopperLayer(LAYER_NUM aLayerId)
Function IsCopperLayer tests whether a layer is a copper layer.
void SetLocalSolderPasteMargin(int aMargin)
Definition: class_pad.h:428
DLIST< D_PAD > & PadsList()
Definition: class_module.h:162
int psBottom
Shape of the bottom pads.
Definition: eagle_plugin.h:60
int mlMaxCreamFrame
solder paste mask, maximum size (Eagle mils, here nanometers)
Definition: eagle_plugin.h:57
int srMaxRoundness
corner rounding radius, maximum size (Eagle mils, here nanometers)
Definition: eagle_plugin.h:65
#define min(a, b)
Definition: auxiliary.h:85
double mvCreamFrame
solderpaste mask, expressed as percentage of the smaller pad/via dimension
Definition: eagle_plugin.h:53

References B_Cu, B_Mask, B_Paste, ESMD::cream, EROT::degrees, ESMD::dx, ESMD::dy, eagleClamp(), F_Cu, F_Mask, F_Paste, D_PAD::GetLayerSet(), D_PAD::GetName(), IsCopperLayer(), kicad_layer(), ESMD::layer, m_rules, min, ERULES::mlMaxCreamFrame, ERULES::mlMinCreamFrame, ERULES::mvCreamFrame, EPAD::OCTAGON, PAD_ATTRIB_SMD, PAD_SHAPE_CIRCLE, PAD_SHAPE_RECT, PAD_SHAPE_ROUNDRECT, MODULE::PadsList(), ERULES::psBottom, ERULES::psFirst, ERULES::psTop, DLIST< T >::PushBack(), EPAD_COMMON::rot, EPAD::ROUND, ESMD::roundness, D_PAD::SetAttribute(), BOARD_ITEM::SetLayer(), D_PAD::SetLayerSet(), D_PAD::SetLocalSolderPasteMargin(), D_PAD::SetOrientation(), D_PAD::SetRoundRectRadiusRatio(), D_PAD::SetShape(), D_PAD::SetSize(), EPAD::SQUARE, ERULES::srMaxRoundness, ERULES::srMinRoundness, ERULES::srRoundness, ECOORD::ToPcbUnits(), transferPad(), and EPAD::UNDEF.

Referenced by makeModule().

◆ packageText()

void EAGLE_PLUGIN::packageText ( MODULE aModule,
wxXmlNode *  aTree 
) const
private

Definition at line 1524 of file eagle_plugin.cpp.

1525 {
1526  ETEXT t( aTree );
1527  PCB_LAYER_ID layer = kicad_layer( t.layer );
1528 
1529  if( layer == UNDEFINED_LAYER )
1530  {
1531  layer = Cmts_User;
1532  }
1533 
1534  TEXTE_MODULE* txt;
1535 
1536  if( t.text == ">NAME" || t.text == ">name" )
1537  txt = &aModule->Reference();
1538  else if( t.text == ">VALUE" || t.text == ">value" )
1539  txt = &aModule->Value();
1540  else
1541  {
1542  // FIXME: graphical text items are rotated for some reason.
1543  txt = new TEXTE_MODULE( aModule );
1544  aModule->GraphicalItemsList().PushBack( txt );
1545  }
1546 
1547  txt->SetTimeStamp( EagleTimeStamp( aTree ) );
1548  txt->SetText( FROM_UTF8( t.text.c_str() ) );
1549 
1550  wxPoint pos( kicad_x( t.x ), kicad_y( t.y ) );
1551 
1552  txt->SetTextPos( pos );
1553  txt->SetPos0( pos - aModule->GetPosition() );
1554 
1555  txt->SetLayer( layer );
1556  txt->SetTextSize( kicad_fontz( t.size ) );
1557 
1558  double ratio = t.ratio ? *t.ratio : 8; // DTD says 8 is default
1559 
1560  txt->SetThickness( t.size.ToPcbUnits() * ratio / 100 );
1561 
1562  int align = t.align ? *t.align : ETEXT::BOTTOM_LEFT; // bottom-left is eagle default
1563 
1564  // An eagle package is never rotated, the DTD does not allow it.
1565  // angle -= aModule->GetOrienation();
1566 
1567  if( t.rot )
1568  {
1569  int sign = t.rot->mirror ? -1 : 1;
1570  txt->SetMirrored( t.rot->mirror );
1571 
1572  double degrees = t.rot->degrees;
1573 
1574  if( degrees == 90 || t.rot->spin )
1575  txt->SetTextAngle( sign * degrees * 10 );
1576  else if( degrees == 180 )
1577  align = ETEXT::TOP_RIGHT;
1578  else if( degrees == 270 )
1579  {
1580  align = ETEXT::TOP_RIGHT;
1581  txt->SetTextAngle( sign * 90 * 10 );
1582  }
1583  }
1584 
1585  switch( align )
1586  {
1587  case ETEXT::CENTER:
1588  // this was the default in pcbtxt's constructor
1589  break;
1590 
1591  case ETEXT::CENTER_LEFT:
1593  break;
1594 
1595  case ETEXT::CENTER_RIGHT:
1597  break;
1598 
1599  case ETEXT::TOP_CENTER:
1601  break;
1602 
1603  case ETEXT::TOP_LEFT:
1606  break;
1607 
1608  case ETEXT::TOP_RIGHT:
1611  break;
1612 
1613  case ETEXT::BOTTOM_CENTER:
1615  break;
1616 
1617  case ETEXT::BOTTOM_LEFT:
1620  break;
1621 
1622  case ETEXT::BOTTOM_RIGHT:
1625  break;
1626  }
1627 }
void SetMirrored(bool isMirrored)
Definition: eda_text.h:191
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:203
TEXTE_MODULE & Reference()
Definition: class_module.h:503
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes.
Definition: macros.h:53
PCB_LAYER_ID kicad_layer(int aLayer) const
Convert an Eagle layer to a KiCad layer.
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
void SetTextPos(const wxPoint &aPoint)
Definition: eda_text.h:236
void SetTextSize(const wxSize &aNewSize)
Definition: eda_text.h:227
Eagle text element.
Definition: eagle_parser.h:646
void PushBack(T *aNewElement)
Function PushBack puts aNewElement at the end of the list sequence.
Definition: dlist.h:250
PCB_LAYER_ID
A quick note on layer IDs:
TEXTE_MODULE & Value()
read/write accessors:
Definition: class_module.h:502
void SetVertJustify(EDA_TEXT_VJUSTIFY_T aType)
Definition: eda_text.h:207
timestamp_t EagleTimeStamp(wxXmlNode *aTree)
Make a unique time stamp
void SetPos0(const wxPoint &aPos)
void SetHorizJustify(EDA_TEXT_HJUSTIFY_T aType)
Definition: eda_text.h:206
DLIST< BOARD_ITEM > & GraphicalItemsList()
Definition: class_module.h:165
wxSize kicad_fontz(const ECOORD &d) const
create a font size (fontz) from an eagle font size scalar
void SetTextAngle(double aAngle)
const wxPoint GetPosition() const override
Definition: class_module.h:183
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:202
void SetThickness(int aNewThickness)
Function SetThickness sets pen width.
Definition: eda_text.h:161
void SetTimeStamp(timestamp_t aNewTimeStamp)
Definition: base_struct.h:206
int sign(T val)
Definition: math_util.h:44
virtual void SetText(const wxString &aText)
Definition: eda_text.h:154

References ETEXT::align, ETEXT::BOTTOM_CENTER, ETEXT::BOTTOM_LEFT, ETEXT::BOTTOM_RIGHT, ETEXT::CENTER, ETEXT::CENTER_LEFT, ETEXT::CENTER_RIGHT, Cmts_User, EROT::degrees, EagleTimeStamp(), FROM_UTF8(), MODULE::GetPosition(), GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_BOTTOM, GR_TEXT_VJUSTIFY_TOP, MODULE::GraphicalItemsList(), kicad_fontz(), kicad_layer(), kicad_x(), kicad_y(), ETEXT::layer, EROT::mirror, DLIST< T >::PushBack(), ETEXT::ratio, MODULE::Reference(), ETEXT::rot, EDA_TEXT::SetHorizJustify(), BOARD_ITEM::SetLayer(), EDA_TEXT::SetMirrored(), TEXTE_MODULE::SetPos0(), EDA_TEXT::SetText(), TEXTE_MODULE::SetTextAngle(), EDA_TEXT::SetTextPos(), EDA_TEXT::SetTextSize(), EDA_TEXT::SetThickness(), EDA_ITEM::SetTimeStamp(), EDA_TEXT::SetVertJustify(), sign(), ETEXT::size, EROT::spin, ETEXT::text, ETEXT::TOP_CENTER, ETEXT::TOP_LEFT, ETEXT::TOP_RIGHT, ECOORD::ToPcbUnits(), UNDEFINED_LAYER, MODULE::Value(), ETEXT::x, and ETEXT::y.

Referenced by makeModule().

◆ packageWire()

void EAGLE_PLUGIN::packageWire ( MODULE aModule,
wxXmlNode *  aTree 
) const
private

Definition at line 1395 of file eagle_plugin.cpp.

1396 {
1397  EWIRE w( aTree );
1398  PCB_LAYER_ID layer = kicad_layer( w.layer );
1399  wxPoint start( kicad_x( w.x1 ), kicad_y( w.y1 ) );
1400  wxPoint end( kicad_x( w.x2 ), kicad_y( w.y2 ) );
1401  int width = w.width.ToPcbUnits();
1402 
1403  if( width <= 0 )
1404  {
1405  width = aModule->GetBoard()->GetDesignSettings().GetLineThickness( layer );
1406  }
1407 
1408  // FIXME: the cap attribute is ignored because kicad can't create lines
1409  // with flat ends.
1410  EDGE_MODULE* dwg;
1411 
1412  if( !w.curve )
1413  {
1414  dwg = new EDGE_MODULE( aModule, S_SEGMENT );
1415 
1416  dwg->SetStart0( start );
1417  dwg->SetEnd0( end );
1418  }
1419  else
1420  {
1421  dwg = new EDGE_MODULE( aModule, S_ARC );
1422  wxPoint center = ConvertArcCenter( start, end, *w.curve );
1423 
1424  dwg->SetStart0( center );
1425  dwg->SetEnd0( start );
1426  dwg->SetAngle( *w.curve * -10.0 ); // KiCad rotates the other way
1427  }
1428 
1429  dwg->SetLayer( layer );
1430  dwg->SetWidth( width );
1431  dwg->SetDrawCoord();
1432 
1433  aModule->GraphicalItemsList().PushBack( dwg );
1434 }
void SetEnd0(const wxPoint &aPoint)
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:203
PCB_LAYER_ID kicad_layer(int aLayer) const
Convert an Eagle layer to a KiCad layer.
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:539
usual segment : line with rounded ends
void PushBack(T *aNewElement)
Function PushBack puts aNewElement at the end of the list sequence.
Definition: dlist.h:250
int GetLineThickness(PCB_LAYER_ID aLayer) const
Function GetLineThickness Returns the default graphic segment thickness from the layer class for the ...
PCB_LAYER_ID
A quick note on layer IDs:
Arcs (with rounded ends)
virtual BOARD * GetBoard() const
Function GetBoard returns the BOARD in which this BOARD_ITEM resides, or NULL if none.
wxPoint ConvertArcCenter(const wxPoint &aStart, const wxPoint &aEnd, double aAngle)
Convert an Eagle curve end to a KiCad center for S_ARC
void SetDrawCoord()
Set draw coordinates (absolute values ) from relative coordinates.
void SetStart0(const wxPoint &aPoint)
Eagle wire.
Definition: eagle_parser.h:500
void SetAngle(double aAngle)
Function SetAngle sets the angle for arcs, and normalizes it within the range 0 - 360 degrees.
DLIST< BOARD_ITEM > & GraphicalItemsList()
Definition: class_module.h:165
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:202
void SetWidth(int aWidth)

References ConvertArcCenter(), EWIRE::curve, BOARD_ITEM::GetBoard(), BOARD::GetDesignSettings(), BOARD_DESIGN_SETTINGS::GetLineThickness(), MODULE::GraphicalItemsList(), kicad_layer(), kicad_x(), kicad_y(), EWIRE::layer, DLIST< T >::PushBack(), S_ARC, S_SEGMENT, DRAWSEGMENT::SetAngle(), EDGE_MODULE::SetDrawCoord(), EDGE_MODULE::SetEnd0(), BOARD_ITEM::SetLayer(), EDGE_MODULE::SetStart0(), DRAWSEGMENT::SetWidth(), ECOORD::ToPcbUnits(), EWIRE::width, EWIRE::x1, EWIRE::x2, EWIRE::y1, and EWIRE::y2.

Referenced by makeModule().

◆ PluginName()

const wxString EAGLE_PLUGIN::PluginName ( ) const
overridevirtual

Function PluginName returns a brief hard coded name for this PLUGIN.

Implements PLUGIN.

Definition at line 200 of file eagle_plugin.cpp.

201 {
202  return wxT( "Eagle" );
203 }

◆ PrefetchLib()

void PLUGIN::PrefetchLib ( const wxString &  aLibraryPath,
const PROPERTIES aProperties = NULL 
)
virtualinherited

Function PrefetchLib If possible, prefetches the specified library (e.g.

performing downloads). Does not parse. Threadsafe.

This is a no-op for libraries that cannot be prefetched.

Plugins that cannot prefetch need not override this; a default no-op is provided.

Parameters
aLibraryPathis a locator for the "library", usually a directory, file, or URL containing several footprints.
aPropertiesis an associative array that can be used to tell the plugin anything needed about how to perform with respect to aLibraryPath. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.
Exceptions
IO_ERRORif there is an error prefetching the library.

Reimplemented in GITHUB_PLUGIN.

Definition at line 68 of file plugin.cpp.

69 {
70  (void) aLibraryPath;
71  (void) aProperties;
72 }

◆ Save()

void PLUGIN::Save ( const wxString &  aFileName,
BOARD aBoard,
const PROPERTIES aProperties = NULL 
)
virtualinherited

Function Save will write aBoard to a storage file in a format that this PLUGIN implementation knows about, or it can be used to write a portion of aBoard to a special kind of export file.

Parameters
aFileNameis the name of a file to save to on disk.
aBoardis the class BOARD in memory document tree from which to extract information when writing to aFileName. The caller continues to own the BOARD, and the plugin should refrain from modifying the BOARD if possible.
aPropertiesis an associative array that can be used to tell the saver how to save the file, because it can take any number of additional named tuning arguments that the plugin is known to support. The caller continues to own this object (plugin may not delete it), and plugins should expect it to be optionally NULL.
Exceptions
IO_ERRORif there is a problem saving or exporting.

Reimplemented in PCB_IO, and CLIPBOARD_IO.

Definition at line 53 of file plugin.cpp.

54 {
55  // not pure virtual so that plugins only have to implement subset of the PLUGIN interface.
56  not_implemented( this, __FUNCTION__ );
57 }
static void not_implemented(PLUGIN *aPlugin, const char *aCaller)
Function not_implemented throws an IO_ERROR and complains of an API function not being implemented.
Definition: plugin.cpp:38

References not_implemented().

Referenced by IO_MGR::Save().

◆ transferPad()

void EAGLE_PLUGIN::transferPad ( const EPAD_COMMON aEaglePad,
D_PAD aPad 
) const
private

Handles common pad properties

Definition at line 1905 of file eagle_plugin.cpp.

1906 {
1907  aPad->SetName( FROM_UTF8( aEaglePad.name.c_str() ) );
1908 
1909  // pad's "Position" is not relative to the module's,
1910  // whereas Pos0 is relative to the module's but is the unrotated coordinate.
1911  wxPoint padPos( kicad_x( aEaglePad.x ), kicad_y( aEaglePad.y ) );
1912  aPad->SetPos0( padPos );
1913 
1914  // Solder mask
1915  const wxSize& padSize( aPad->GetSize() );
1916 
1917  if( !aEaglePad.stop || !*aEaglePad.stop ) // enabled by default
1918  {
1920  (int)( m_rules->mvStopFrame * std::min( padSize.x, padSize.y ) ),
1921  m_rules->mlMaxStopFrame ) );
1922  }
1923 
1924  // Solid connection to copper zones
1925  if( aEaglePad.thermals && !*aEaglePad.thermals )
1927 
1928  MODULE* module = aPad->GetParent();
1929  wxCHECK( module, /* void */ );
1930  RotatePoint( &padPos, module->GetOrientation() );
1931  aPad->SetPosition( padPos + module->GetPosition() );
1932 }
double GetOrientation() const
Definition: class_module.h:188
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:203
static T eagleClamp(T aMin, T aValue, T aMax)
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes.
Definition: macros.h:53
ERULES * m_rules
Eagle design rules.
Definition: eagle_plugin.h:173
int mlMinStopFrame
solder mask, minimum size (Eagle mils, here nanometers)
Definition: eagle_plugin.h:54
void SetPosition(const wxPoint &aPos) override
Definition: class_pad.h:219
wxString name
Definition: eagle_parser.h:683
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:216
opt_bool thermals
Definition: eagle_parser.h:687
void SetZoneConnection(ZoneConnection aType)
Definition: class_pad.h:496
void SetName(const wxString &aName)
Set the pad name (sometimes called pad number, although it can be an array reference like AA12).
Definition: class_pad.h:182
void SetPos0(const wxPoint &aPos)
Definition: class_pad.h:262
MODULE * GetParent() const
Definition: class_pad.h:162
void SetLocalSolderMaskMargin(int aMargin)
Definition: class_pad.h:422
double mvStopFrame
solder mask, expressed as percentage of the smaller pad/via dimension
Definition: eagle_plugin.h:52
const wxSize & GetSize() const
Definition: class_pad.h:269
opt_bool stop
Definition: eagle_parser.h:686
const wxPoint GetPosition() const override
Definition: class_module.h:183
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:202
#define min(a, b)
Definition: auxiliary.h:85
pads are covered by copper
Definition: zones.h:54
int mlMaxStopFrame
solder mask, maximum size (Eagle mils, here nanometers)
Definition: eagle_plugin.h:55

References eagleClamp(), FROM_UTF8(), MODULE::GetOrientation(), D_PAD::GetParent(), MODULE::GetPosition(), D_PAD::GetSize(), kicad_x(), kicad_y(), m_rules, min, ERULES::mlMaxStopFrame, ERULES::mlMinStopFrame, ERULES::mvStopFrame, EPAD_COMMON::name, PAD_ZONE_CONN_FULL, RotatePoint(), D_PAD::SetLocalSolderMaskMargin(), D_PAD::SetName(), D_PAD::SetPos0(), D_PAD::SetPosition(), D_PAD::SetZoneConnection(), EPAD_COMMON::stop, EPAD_COMMON::thermals, EPAD_COMMON::x, and EPAD_COMMON::y.

Referenced by packagePad(), and packageSMD().

Member Data Documentation

◆ m_board

BOARD* EAGLE_PLUGIN::m_board
private

which BOARD is being worked on, no ownership here

Definition at line 187 of file eagle_plugin.h.

Referenced by centerBoard(), init(), Load(), loadElements(), loadLayerDefs(), loadPlain(), loadPolygon(), loadSignals(), and makeModule().

◆ m_cu_map

int EAGLE_PLUGIN::m_cu_map[17]
private

map eagle to kicad, cu layers only.

Definition at line 170 of file eagle_plugin.h.

Referenced by clear_cu_map(), kicad_layer(), and loadLayerDefs().

◆ m_eagleLayers

std::map<int, ELAYER> EAGLE_PLUGIN::m_eagleLayers
private

Eagle layers data stored by the layer number.

Definition at line 171 of file eagle_plugin.h.

Referenced by eagle_layer_name(), and loadLayerDefs().

◆ m_hole_count

int EAGLE_PLUGIN::m_hole_count
private

generates unique module names from eagle "hole"s.

Definition at line 177 of file eagle_plugin.h.

Referenced by init(), and loadPlain().

◆ m_lib_path

wxString EAGLE_PLUGIN::m_lib_path
private

Definition at line 193 of file eagle_plugin.h.

Referenced by cacheLib(), and loadLibrary().

◆ m_min_trace

int EAGLE_PLUGIN::m_min_trace
private

smallest trace we find on Load(), in BIU.

Definition at line 189 of file eagle_plugin.h.

Referenced by init(), Load(), and loadSignals().

◆ m_min_via

int EAGLE_PLUGIN::m_min_via
private

smallest via we find on Load(), in BIU.

Definition at line 190 of file eagle_plugin.h.

Referenced by init(), Load(), and loadSignals().

◆ m_min_via_hole

int EAGLE_PLUGIN::m_min_via_hole
private

smallest via diameter hole we find on Load(), in BIU.

Definition at line 191 of file eagle_plugin.h.

Referenced by init(), Load(), and loadSignals().

◆ m_mod_time

wxDateTime EAGLE_PLUGIN::m_mod_time
private

Definition at line 194 of file eagle_plugin.h.

Referenced by cacheLib().

◆ m_pads_to_nets

NET_MAP EAGLE_PLUGIN::m_pads_to_nets
private

net list

Definition at line 179 of file eagle_plugin.h.

Referenced by init(), loadElements(), and loadSignals().

◆ m_props

const PROPERTIES* EAGLE_PLUGIN::m_props
private

passed via Save() or Load(), no ownership, may be NULL.

Definition at line 186 of file eagle_plugin.h.

Referenced by centerBoard(), and init().

◆ m_rules

ERULES* EAGLE_PLUGIN::m_rules
private

Eagle design rules.

Definition at line 173 of file eagle_plugin.h.

Referenced by init(), Load(), loadDesignRules(), loadSignals(), packagePad(), packageSMD(), transferPad(), and ~EAGLE_PLUGIN().

◆ m_templates

MODULE_MAP EAGLE_PLUGIN::m_templates
private

is part of a MODULE factory that operates using copy construction.

lookup key is either libname.packagename or simply packagename if FootprintLoad() or FootprintEnumberate()

Definition at line 181 of file eagle_plugin.h.

Referenced by deleteTemplates(), FootprintEnumerate(), FootprintLoad(), loadElements(), and loadLibrary().

◆ m_xpath

XPATH* EAGLE_PLUGIN::m_xpath
private

keeps track of what we are working on within XML document during a Load().

Definition at line 174 of file eagle_plugin.h.

Referenced by cacheLib(), init(), Load(), loadAllSections(), loadDesignRules(), loadElements(), loadLibraries(), loadLibrary(), loadPlain(), loadSignals(), and ~EAGLE_PLUGIN().


The documentation for this class was generated from the following files: