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 2307 of file eagle_plugin.cpp.

2308 {
2309  try
2310  {
2311  wxDateTime modtime = getModificationTime( aLibPath );
2312 
2313  // Fixes assertions in wxWidgets debug builds for the wxDateTime object. Refresh the
2314  // cache if either of the wxDateTime objects are invalid or the last file modification
2315  // time differs from the current file modification time.
2316  bool load = !m_mod_time.IsValid() || !modtime.IsValid() || m_mod_time != modtime;
2317 
2318  if( aLibPath != m_lib_path || load )
2319  {
2320  wxXmlNode* doc;
2321  LOCALE_IO toggle; // toggles on, then off, the C locale.
2322 
2323  deleteTemplates();
2324 
2325  // Set this before completion of loading, since we rely on it for
2326  // text of an exception. Delay setting m_mod_time until after successful load
2327  // however.
2328  m_lib_path = aLibPath;
2329 
2330  // 8 bit "filename" should be encoded according to disk filename encoding,
2331  // (maybe this is current locale, maybe not, its a filesystem issue),
2332  // and is not necessarily utf8.
2333  string filename = (const char*) aLibPath.char_str( wxConvFile );
2334 
2335  // Load the document
2336  wxXmlDocument xmlDocument;
2337  wxFileName fn( filename );
2338 
2339  if( !xmlDocument.Load( fn.GetFullPath() ) )
2340  THROW_IO_ERROR( wxString::Format( _( "Unable to read file \"%s\"" ),
2341  fn.GetFullPath() ) );
2342 
2343  doc = xmlDocument.GetRoot();
2344 
2345  wxXmlNode* drawing = MapChildren( doc )["drawing"];
2346  NODE_MAP drawingChildren = MapChildren( drawing );
2347 
2348  // clear the cu map and then rebuild it.
2349  clear_cu_map();
2350 
2351  m_xpath->push( "eagle.drawing.layers" );
2352  wxXmlNode* layers = drawingChildren["layers"];
2353  loadLayerDefs( layers );
2354  m_xpath->pop();
2355 
2356  m_xpath->push( "eagle.drawing.library" );
2357  wxXmlNode* library = drawingChildren["library"];
2358  loadLibrary( library, NULL );
2359  m_xpath->pop();
2360 
2361  m_mod_time = modtime;
2362  }
2363  }
2364  catch(...){}
2365  // TODO: Handle exceptions
2366  // catch( file_parser_error fpe )
2367  // {
2368  // // for xml_parser_error, what() has the line number in it,
2369  // // but no byte offset. That should be an adequate error message.
2370  // THROW_IO_ERROR( fpe.what() );
2371  // }
2372  //
2373  // // Class ptree_error is a base class for xml_parser_error & file_parser_error,
2374  // // so one catch should be OK for all errors.
2375  // catch( ptree_error pte )
2376  // {
2377  // string errmsg = pte.what();
2378  //
2379  // errmsg += " @\n";
2380  // errmsg += m_xpath->Contents();
2381  //
2382  // THROW_IO_ERROR( errmsg );
2383  // }
2384 }
void clear_cu_map()
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: common.h:177
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 2265 of file eagle_plugin.cpp.

2266 {
2267  if( m_props )
2268  {
2269  UTF8 page_width;
2270  UTF8 page_height;
2271 
2272  if( m_props->Value( "page_width", &page_width ) &&
2273  m_props->Value( "page_height", &page_height ) )
2274  {
2276 
2277  int w = atoi( page_width.c_str() );
2278  int h = atoi( page_height.c_str() );
2279 
2280  int desired_x = ( w - bbbox.GetWidth() ) / 2;
2281  int desired_y = ( h - bbbox.GetHeight() ) / 2;
2282 
2283  DBG(printf( "bbox.width:%d bbox.height:%d w:%d h:%d desired_x:%d desired_y:%d\n",
2284  bbbox.GetWidth(), bbbox.GetHeight(), w, h, desired_x, desired_y );)
2285 
2286  m_board->Move( wxPoint( desired_x - bbbox.GetX(), desired_y - bbbox.GetY() ) );
2287  }
2288  }
2289 }
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:802
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:107
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 1942 of file eagle_plugin.cpp.

1943 {
1944  for( auto& t : m_templates )
1945  delete t.second;
1946 
1947  m_templates.clear();
1948 }
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 2257 of file eagle_plugin.cpp.

2258 {
2259  static const wxString unknown( "unknown" );
2260  auto it = m_eagleLayers.find( aLayer );
2261  return it == m_eagleLayers.end() ? unknown : it->second.name;
2262 }
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 2387 of file eagle_plugin.cpp.

2389 {
2390  init( aProperties );
2391 
2392  cacheLib( aLibraryPath );
2393 
2394  for( MODULE_CITER it = m_templates.begin(); it != m_templates.end(); ++it )
2395  aFootprintNames.Add( FROM_UTF8( it->first.c_str() ) );
2396 }
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:61
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 2416 of file eagle_plugin.cpp.

2417 {
2418  PLUGIN::FootprintLibOptions( aListToAppendTo );
2419 
2420  /*
2421  (*aListToAppendTo)["ignore_duplicates"] = UTF8( _(
2422  "Ignore duplicately named footprints within the same Eagle library. "
2423  "Only the first similarly named footprint will be loaded."
2424  ));
2425  */
2426 }
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 2399 of file eagle_plugin.cpp.

2401 {
2402  init( aProperties );
2403  cacheLib( aLibraryPath );
2404  MODULE_CITER mi = m_templates.find( aFootprintName );
2405 
2406  if( mi == m_templates.end() )
2407  return NULL;
2408 
2409  // copy constructor to clone the template
2410  MODULE* ret = new MODULE( *mi->second );
2411 
2412  return ret;
2413 }
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 2292 of file eagle_plugin.cpp.

2293 {
2294  // File hasn't been loaded yet.
2295  if( aPath.IsEmpty() )
2296  return wxDateTime::Now();
2297 
2298  wxFileName fn( aPath );
2299 
2300  if( fn.IsFileReadable() )
2301  return fn.GetModificationTime();
2302  else
2303  return wxDateTime( 0.0 );
2304 }

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 2188 of file eagle_plugin.cpp.

2189 {
2190  int kiLayer;
2191 
2192  // eagle copper layer:
2193  if( aEagleLayer >= 1 && aEagleLayer < int( arrayDim( m_cu_map ) ) )
2194  {
2195  kiLayer = m_cu_map[aEagleLayer];
2196  }
2197 
2198  else
2199  {
2200  // translate non-copper eagle layer to pcbnew layer
2201  switch( aEagleLayer )
2202  {
2203  // Eagle says "Dimension" layer, but it's for board perimeter
2204  case EAGLE_LAYER::MILLING: kiLayer = Edge_Cuts; break;
2205  case EAGLE_LAYER::DIMENSION: kiLayer = Edge_Cuts; break;
2206 
2207  case EAGLE_LAYER::TPLACE: kiLayer = F_SilkS; break;
2208  case EAGLE_LAYER::BPLACE: kiLayer = B_SilkS; break;
2209  case EAGLE_LAYER::TNAMES: kiLayer = F_SilkS; break;
2210  case EAGLE_LAYER::BNAMES: kiLayer = B_SilkS; break;
2211  case EAGLE_LAYER::TVALUES: kiLayer = F_Fab; break;
2212  case EAGLE_LAYER::BVALUES: kiLayer = B_Fab; break;
2213  case EAGLE_LAYER::TSTOP: kiLayer = F_Mask; break;
2214  case EAGLE_LAYER::BSTOP: kiLayer = B_Mask; break;
2215  case EAGLE_LAYER::TCREAM: kiLayer = F_Paste; break;
2216  case EAGLE_LAYER::BCREAM: kiLayer = B_Paste; break;
2217  case EAGLE_LAYER::TFINISH: kiLayer = F_Mask; break;
2218  case EAGLE_LAYER::BFINISH: kiLayer = B_Mask; break;
2219  case EAGLE_LAYER::TGLUE: kiLayer = F_Adhes; break;
2220  case EAGLE_LAYER::BGLUE: kiLayer = B_Adhes; break;
2221  case EAGLE_LAYER::DOCUMENT: kiLayer = Cmts_User; break;
2222  case EAGLE_LAYER::REFERENCELC: kiLayer = Cmts_User; break;
2223  case EAGLE_LAYER::REFERENCELS: kiLayer = Cmts_User; break;
2224 
2225  // Packages show the future chip pins on SMD parts using layer 51.
2226  // This is an area slightly smaller than the PAD/SMD copper area.
2227  // Carry those visual aids into the MODULE on the fabrication layer,
2228  // not silkscreen. This is perhaps not perfect, but there is not a lot
2229  // of other suitable paired layers
2230  case EAGLE_LAYER::TDOCU: kiLayer = F_Fab; break;
2231  case EAGLE_LAYER::BDOCU: kiLayer = B_Fab; break;
2232 
2233  // thes layers are defined as user layers. put them on ECO layers
2234  case EAGLE_LAYER::USERLAYER1: kiLayer = Eco1_User; break;
2235  case EAGLE_LAYER::USERLAYER2: kiLayer = Eco2_User; break;
2236 
2237  case EAGLE_LAYER::UNROUTED:
2238  case EAGLE_LAYER::TKEEPOUT:
2239  case EAGLE_LAYER::BKEEPOUT:
2240  case EAGLE_LAYER::TTEST:
2241  case EAGLE_LAYER::BTEST:
2242  case EAGLE_LAYER::HOLES:
2243  default:
2244  // some layers do not map to KiCad
2245  wxLogMessage( wxString::Format( _( "Unsupported Eagle layer '%s' (%d), converted to Dwgs.User layer" ),
2246  eagle_layer_name( aEagleLayer ), aEagleLayer ) );
2247 
2248  kiLayer = Dwgs_User;
2249  break;
2250  }
2251  }
2252 
2253  return PCB_LAYER_ID( kiLayer );
2254 }
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:107
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:118
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: common.h:177
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:534
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:235
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:170
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:61
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:192
const wxString GetValue() const
Function GetValue.
Definition: class_module.h:487
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
const wxString GetReference() const
Function GetReference.
Definition: class_module.h:462
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.
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:100
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
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:61
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:107
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:668
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:100
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:195
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:61
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:240
void SetVisible(bool aVisible)
Definition: eda_text.h:192
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:534
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:231
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:179
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.
virtual void SetText(const wxString &aText)
Definition: eda_text.cpp:64
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:211
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:212
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:210
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:465
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:165
void SetTimeStamp(timestamp_t aNewTimeStamp)
Definition: base_struct.h:209
Class BOARD_DESIGN_SETTINGS contains design settings for a BOARD object.
int sign(T val)
Definition: math_util.h:44
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:659
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:118
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:184
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:658
void SetPriority(unsigned aPriority)
Function SetPriority.
Definition: class_zone.h:90
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:212
void SetZoneClearance(int aZoneClearance)
Definition: class_zone.h:194
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:175
void SetDoNotAllowCopperPour(bool aEnable)
Definition: class_zone.h:657
#define ZONE_THICKNESS_MIN_VALUE_MIL
Definition: zones.h:41
ECOORD x
Definition: eagle_parser.h:749
double DEG2RAD(double deg)
Definition: trigo.h:208
#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:552
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:656
void SetPadConnection(ZoneConnection aPadConnection)
Definition: class_zone.h:197
void SetMinThickness(int aMinThickness)
Definition: class_zone.h:200
#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:172
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:209
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 1951 of file eagle_plugin.cpp.

1952 {
1953  ZONES zones; // per net
1954 
1955  m_xpath->push( "signals.signal", "name" );
1956 
1957  int netCode = 1;
1958 
1959  // Get the first signal and iterate
1960  wxXmlNode* net = aSignals->GetChildren();
1961 
1962  while( net )
1963  {
1964  bool sawPad = false;
1965 
1966  zones.clear();
1967 
1968  const wxString& netName = escapeName( net->GetAttribute( "name" ) );
1969  m_board->Add( new NETINFO_ITEM( m_board, netName, netCode ) );
1970 
1971  m_xpath->Value( netName.c_str() );
1972 
1973  // Get the first net item and iterate
1974  wxXmlNode* netItem = net->GetChildren();
1975 
1976  // (contactref | polygon | wire | via)*
1977  while( netItem )
1978  {
1979  const wxString& itemName = netItem->GetName();
1980 
1981  if( itemName == "wire" )
1982  {
1983  m_xpath->push( "wire" );
1984 
1985  EWIRE w( netItem );
1986  PCB_LAYER_ID layer = kicad_layer( w.layer );
1987 
1988  if( IsCopperLayer( layer ) )
1989  {
1990  wxPoint start( kicad_x( w.x1 ), kicad_y( w.y1 ) );
1991  double angle = 0.0;
1992  double end_angle = 0.0;
1993  double radius = 0.0;
1994  double delta_angle = 0.0;
1995  wxPoint center;
1996 
1997  int width = w.width.ToPcbUnits();
1998  if( width < m_min_trace )
1999  m_min_trace = width;
2000 
2001  if( w.curve )
2002  {
2003  center = ConvertArcCenter(
2004  wxPoint( kicad_x( w.x1 ), kicad_y( w.y1 ) ),
2005  wxPoint( kicad_x( w.x2 ), kicad_y( w.y2 ) ),
2006  *w.curve );
2007 
2008  angle = DEG2RAD( *w.curve );
2009 
2010  end_angle = atan2( kicad_y( w.y2 ) - center.y,
2011  kicad_x( w.x2 ) - center.x );
2012 
2013  radius = sqrt( pow( center.x - kicad_x( w.x1 ), 2 ) +
2014  pow( center.y - kicad_y( w.y1 ), 2 ) );
2015 
2016  // If we are curving, we need at least 2 segments otherwise
2017  // delta_angle == angle
2018  int segments = std::max( 2, GetArcToSegmentCount( KiROUND( radius ),
2019  ARC_HIGH_DEF, *w.curve ) - 1 );
2020  delta_angle = angle / segments;
2021  }
2022 
2023  while( fabs( angle ) > fabs( delta_angle ) )
2024  {
2025  wxASSERT( radius > 0.0 );
2026  wxPoint end( KiROUND( radius * cos( end_angle + angle ) + center.x ),
2027  KiROUND( radius * sin( end_angle + angle ) + center.y ) );
2028 
2029  TRACK* t = new TRACK( m_board );
2030 
2031  t->SetTimeStamp( EagleTimeStamp( netItem ) + int( RAD2DEG( angle ) ) );
2032  t->SetPosition( start );
2033  t->SetEnd( end );
2034  t->SetWidth( width );
2035  t->SetLayer( layer );
2036  t->SetNetCode( netCode );
2037 
2038  m_board->m_Track.PushBack( t );
2039 
2040  start = end;
2041  angle -= delta_angle;
2042  }
2043 
2044  TRACK* t = new TRACK( m_board );
2045 
2046  t->SetTimeStamp( EagleTimeStamp( netItem ) );
2047  t->SetPosition( start );
2048  t->SetEnd( wxPoint( kicad_x( w.x2 ), kicad_y( w.y2 ) ) );
2049  t->SetWidth( width );
2050  t->SetLayer( layer );
2051  t->SetNetCode( netCode );
2052 
2053  m_board->m_Track.PushBack( t );
2054  }
2055  else
2056  {
2057  // put non copper wires where the sun don't shine.
2058  }
2059 
2060  m_xpath->pop();
2061  }
2062 
2063  else if( itemName == "via" )
2064  {
2065  m_xpath->push( "via" );
2066  EVIA v( netItem );
2067 
2068  PCB_LAYER_ID layer_front_most = kicad_layer( v.layer_front_most );
2069  PCB_LAYER_ID layer_back_most = kicad_layer( v.layer_back_most );
2070 
2071  if( IsCopperLayer( layer_front_most ) &&
2072  IsCopperLayer( layer_back_most ) )
2073  {
2074  int kidiam;
2075  int drillz = v.drill.ToPcbUnits();
2076  VIA* via = new VIA( m_board );
2077  m_board->m_Track.PushBack( via );
2078 
2079  via->SetLayerPair( layer_front_most, layer_back_most );
2080 
2081  if( v.diam )
2082  {
2083  kidiam = v.diam->ToPcbUnits();
2084  via->SetWidth( kidiam );
2085  }
2086  else
2087  {
2088  double annulus = drillz * m_rules->rvViaOuter; // eagle "restring"
2089  annulus = eagleClamp( m_rules->rlMinViaOuter, annulus, m_rules->rlMaxViaOuter );
2090  kidiam = KiROUND( drillz + 2 * annulus );
2091  via->SetWidth( kidiam );
2092  }
2093 
2094  via->SetDrill( drillz );
2095 
2096  // make sure the via diameter respects the restring rules
2097 
2098  if( !v.diam || via->GetWidth() <= via->GetDrill() )
2099  {
2100  double annulus = eagleClamp( m_rules->rlMinViaOuter,
2101  (double)( via->GetWidth() / 2 - via->GetDrill() ), m_rules->rlMaxViaOuter );
2102  via->SetWidth( drillz + 2 * annulus );
2103  }
2104 
2105  if( kidiam < m_min_via )
2106  m_min_via = kidiam;
2107 
2108  if( drillz < m_min_via_hole )
2109  m_min_via_hole = drillz;
2110 
2111  if( layer_front_most == F_Cu && layer_back_most == B_Cu )
2112  via->SetViaType( VIA_THROUGH );
2113  else if( layer_front_most == F_Cu || layer_back_most == B_Cu )
2114  via->SetViaType( VIA_MICROVIA );
2115  else
2116  via->SetViaType( VIA_BLIND_BURIED );
2117 
2118  via->SetTimeStamp( EagleTimeStamp( netItem ) );
2119 
2120  wxPoint pos( kicad_x( v.x ), kicad_y( v.y ) );
2121 
2122  via->SetPosition( pos );
2123  via->SetEnd( pos );
2124 
2125  via->SetNetCode( netCode );
2126  }
2127 
2128  m_xpath->pop();
2129  }
2130 
2131  else if( itemName == "contactref" )
2132  {
2133  m_xpath->push( "contactref" );
2134  // <contactref element="RN1" pad="7"/>
2135 
2136  const wxString& reference = netItem->GetAttribute( "element" );
2137  const wxString& pad = netItem->GetAttribute( "pad" );
2138  wxString key = makeKey( reference, pad ) ;
2139 
2140  // D(printf( "adding refname:'%s' pad:'%s' netcode:%d netname:'%s'\n", reference.c_str(), pad.c_str(), netCode, netName.c_str() );)
2141 
2142  m_pads_to_nets[ key ] = ENET( netCode, netName );
2143 
2144  m_xpath->pop();
2145 
2146  sawPad = true;
2147  }
2148 
2149  else if( itemName == "polygon" )
2150  {
2151  m_xpath->push( "polygon" );
2152  auto* zone = loadPolygon( netItem );
2153 
2154  if( zone )
2155  {
2156  zones.push_back( zone );
2157 
2158  if( !zone->GetIsKeepout() )
2159  zone->SetNetCode( netCode );
2160  }
2161 
2162  m_xpath->pop(); // "polygon"
2163  }
2164 
2165  netItem = netItem->GetNext();
2166  }
2167 
2168  if( zones.size() && !sawPad )
2169  {
2170  // KiCad does not support an unconnected zone with its own non-zero netcode,
2171  // but only when assigned netcode = 0 w/o a name...
2172  for( ZONES::iterator it = zones.begin(); it != zones.end(); ++it )
2173  (*it)->SetNetCode( NETINFO_LIST::UNCONNECTED );
2174 
2175  // therefore omit this signal/net.
2176  }
2177  else
2178  netCode++;
2179 
2180  // Get next signal
2181  net = net->GetNext();
2182  }
2183 
2184  m_xpath->pop(); // "signals.signal"
2185 }
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:438
static int KiROUND(double v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: common.h:118
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:411
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:129
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:209
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:126
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:452
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:65
int GetWidth() const
Definition: class_track.h:127
double DEG2RAD(double deg)
Definition: trigo.h:208
#define max(a, b)
Definition: auxiliary.h:86
void SetPosition(const wxPoint &aPos) override
Definition: class_track.h:123
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:445
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:249
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:465
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:209
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:61
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:195
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:196
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:61
void SetTextPos(const wxPoint &aPoint)
Definition: eda_text.h:240
double GetTextAngle() const
Definition: eda_text.h:181
double degrees
Definition: eagle_parser.h:483
void SetTextSize(const wxSize &aNewSize)
Definition: eda_text.h:231
#define abs(a)
Definition: auxiliary.h:84
opt_erot rot
Definition: eagle_parser.h:612
virtual void SetText(const wxString &aText)
Definition: eda_text.cpp:64
opt_ecoord y
Definition: eagle_parser.h:608
const wxSize & GetTextSize() const
Definition: eda_text.h:232
void SetVertJustify(EDA_TEXT_VJUSTIFY_T aType)
Definition: eda_text.h:211
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:210
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:165
opt_ecoord size
Definition: eagle_parser.h:609
int sign(T val)
Definition: math_util.h:44

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 1748 of file eagle_plugin.cpp.

1749 {
1750  ECIRCLE e( aTree );
1751  PCB_LAYER_ID layer = kicad_layer( e.layer );
1752  EDGE_MODULE* gr = new EDGE_MODULE( aModule, S_CIRCLE );
1753  int width = e.width.ToPcbUnits();
1754  int radius = e.radius.ToPcbUnits();
1755 
1756  // with == 0 means filled circle
1757  if( width <= 0 )
1758  {
1759  width = radius;
1760  radius = radius / 2;
1761  }
1762 
1763  aModule->GraphicalItemsList().PushBack( gr );
1764  gr->SetWidth( width );
1765 
1766  switch ( (int) layer )
1767  {
1768  case UNDEFINED_LAYER:
1769  layer = Cmts_User;
1770  break;
1771  default:
1772  break;
1773  }
1774 
1775  gr->SetLayer( layer );
1776  gr->SetTimeStamp( EagleTimeStamp( aTree ) );
1777  gr->SetStart0( wxPoint( kicad_x( e.x ), kicad_y( e.y ) ) );
1778  gr->SetEnd0( wxPoint( kicad_x( e.x ) + radius, kicad_y( e.y ) ) );
1779  gr->SetDrawCoord();
1780 }
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:209
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 1783 of file eagle_plugin.cpp.

1784 {
1785  EHOLE e( aTree );
1786 
1787  // we add a PAD_ATTRIB_HOLE_NOT_PLATED pad to this module.
1788  D_PAD* pad = new D_PAD( aModule );
1789  aModule->PadsList().PushBack( pad );
1790 
1791  pad->SetShape( PAD_SHAPE_CIRCLE );
1793 
1794  // Mechanical purpose only:
1795  // no offset, no net name, no pad name allowed
1796  // pad->SetOffset( wxPoint( 0, 0 ) );
1797  // pad->SetName( wxEmptyString );
1798 
1799  wxPoint padpos( kicad_x( e.x ), kicad_y( e.y ) );
1800 
1801  if( aCenter )
1802  {
1803  pad->SetPos0( wxPoint( 0, 0 ) );
1804  aModule->SetPosition( padpos );
1805  pad->SetPosition( padpos );
1806  }
1807  else
1808  {
1809  pad->SetPos0( padpos );
1810  pad->SetPosition( padpos + aModule->GetPosition() );
1811  }
1812 
1813  wxSize sz( e.drill.ToPcbUnits(), e.drill.ToPcbUnits() );
1814 
1815  pad->SetDrillSize( sz );
1816  pad->SetSize( sz );
1817 
1818  pad->SetLayerSet( LSET::AllCuMask().set( B_Mask ).set( F_Mask ) );
1819 }
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:221
void SetDrillSize(const wxSize &aSize)
Definition: class_pad.h:276
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:264
void SetSize(const wxSize &aSize)
Definition: class_pad.h:270
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:413
void SetShape(PAD_SHAPE_T aShape)
Definition: class_pad.h:219
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 || shape == EPAD::OCTAGON )
1458  e.shape = shape;
1459 
1460  if( e.shape )
1461  {
1462  switch( *e.shape )
1463  {
1464  case EPAD::ROUND:
1465  pad->SetShape( PAD_SHAPE_CIRCLE );
1466  break;
1467 
1468  case EPAD::OCTAGON:
1469  // no KiCad octagonal pad shape, use PAD_CIRCLE for now.
1470  // pad->SetShape( PAD_OCTAGON );
1471  wxASSERT( pad->GetShape() == PAD_SHAPE_CIRCLE ); // verify set in D_PAD constructor
1474  pad->SetChamferRectRatio( 0.25 );
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  pad->SetShape( PAD_SHAPE_OVAL );
1487  break;
1488  }
1489  }
1490  else
1491  {
1492  // if shape is not present, our default is circle and that matches their default "round"
1493  }
1494 
1495  if( e.diameter )
1496  {
1497  int diameter = e.diameter->ToPcbUnits();
1498  pad->SetSize( wxSize( diameter, diameter ) );
1499  }
1500  else
1501  {
1502  double drillz = pad->GetDrillSize().x;
1503  double annulus = drillz * m_rules->rvPadTop; // copper annulus, eagle "restring"
1504  annulus = eagleClamp( m_rules->rlMinPadTop, annulus, m_rules->rlMaxPadTop );
1505  int diameter = KiROUND( drillz + 2 * annulus );
1506  pad->SetSize( wxSize( KiROUND( diameter ), KiROUND( diameter ) ) );
1507  }
1508 
1509  if( pad->GetShape() == PAD_SHAPE_OVAL )
1510  {
1511  // The Eagle "long" pad is wider than it is tall,
1512  // m_elongation is percent elongation
1513  wxSize sz = pad->GetSize();
1514  sz.x = ( sz.x * ( 100 + m_rules->psElongationLong ) ) / 100;
1515  pad->SetSize( sz );
1516 
1517  if( e.shape && *e.shape == EPAD::OFFSET )
1518  {
1519  int offset = KiROUND( ( sz.x - sz.y ) / 2.0 );
1520  pad->SetOffset( wxPoint( offset, 0 ) );
1521  }
1522  }
1523 
1524  if( e.rot )
1525  {
1526  pad->SetOrientation( e.rot->degrees * 10 );
1527  }
1528 }
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:118
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:276
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:192
void SetSize(const wxSize &aSize)
Definition: class_pad.h:270
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:413
const wxSize & GetDrillSize() const
Definition: class_pad.h:277
void transferPad(const EPAD_COMMON &aEaglePad, D_PAD *aPad) const
Handles common pad properties
void SetShape(PAD_SHAPE_T aShape)
Definition: class_pad.h:219
void SetOrientation(double aAngle)
Function SetOrientation sets the rotation angle of the pad.
Definition: class_pad.cpp:429
void SetChamferRectRatio(double aChamferScale)
has meaning only for chamfered rect pads Set the ratio between the smaller Y or Y size and the radius...
Definition: class_pad.h:683
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:218
const wxSize & GetSize() const
Definition: class_pad.h:271
void SetOffset(const wxPoint &aOffset)
Definition: class_pad.h:279
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.
void SetChamferPositions(int aChamferPositions)
has meaning only for chamfered rect pads set the position of the chamfer for a 0 orientation,...
Definition: class_pad.h:703

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_CHAMFERED_RECT, PAD_SHAPE_CIRCLE, PAD_SHAPE_OVAL, PAD_SHAPE_RECT, MODULE::PadsList(), ERULES::psBottom, ERULES::psElongationLong, ERULES::psFirst, ERULES::psTop, DLIST< T >::PushBack(), RECT_CHAMFER_ALL, ERULES::rlMaxPadTop, ERULES::rlMinPadTop, EPAD_COMMON::rot, EPAD::ROUND, ERULES::rvPadTop, D_PAD::SetChamferPositions(), D_PAD::SetChamferRectRatio(), D_PAD::SetDrillSize(), D_PAD::SetLayerSet(), D_PAD::SetOffset(), 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 1672 of file eagle_plugin.cpp.

1673 {
1674  EPOLYGON p( aTree );
1675  PCB_LAYER_ID layer = kicad_layer( p.layer );
1676  EDGE_MODULE* dwg = new EDGE_MODULE( aModule, S_POLYGON );
1677 
1678  aModule->GraphicalItemsList().PushBack( dwg );
1679 
1680  dwg->SetWidth( 0 ); // it's filled, no need for boundary width
1681  dwg->SetLayer( layer );
1682  dwg->SetTimeStamp( EagleTimeStamp( aTree ) );
1683 
1684  std::vector<wxPoint> pts;
1685  // TODO: I think there's no way to know a priori the number of children in wxXmlNode :()
1686  // pts.reserve( aTree.size() );
1687 
1688  // Get the first vertex and iterate
1689  wxXmlNode* vertex = aTree->GetChildren();
1690  std::vector<EVERTEX> vertices;
1691 
1692  // Create a circular vector of vertices
1693  // The "curve" parameter indicates a curve from the current
1694  // to the next vertex, so we keep the first at the end as well
1695  // to allow the curve to link back
1696  while( vertex )
1697  {
1698  if( vertex->GetName() == "vertex" )
1699  vertices.push_back( EVERTEX( vertex ) );
1700 
1701  vertex = vertex->GetNext();
1702  }
1703 
1704  vertices.push_back( vertices[0] );
1705 
1706  for( size_t i = 0; i < vertices.size() - 1; i++ )
1707  {
1708  EVERTEX v1 = vertices[i];
1709 
1710  // Append the corner
1711  pts.push_back( wxPoint( kicad_x( v1.x ), kicad_y( v1.y ) ) );
1712 
1713  if( v1.curve )
1714  {
1715  EVERTEX v2 = vertices[i + 1];
1716  wxPoint center = ConvertArcCenter(
1717  wxPoint( kicad_x( v1.x ), kicad_y( v1.y ) ),
1718  wxPoint( kicad_x( v2.x ), kicad_y( v2.y ) ), *v1.curve );
1719  double angle = DEG2RAD( *v1.curve );
1720  double end_angle = atan2( kicad_y( v2.y ) - center.y,
1721  kicad_x( v2.x ) - center.x );
1722  double radius = sqrt( pow( center.x - kicad_x( v1.x ), 2 )
1723  + pow( center.y - kicad_y( v1.y ), 2 ) );
1724 
1725  // If we are curving, we need at least 2 segments otherwise
1726  // delta_angle == angle
1727  double delta_angle = angle / std::max(
1728  2, GetArcToSegmentCount( KiROUND( radius ),
1729  ARC_HIGH_DEF, *v1.curve ) - 1 );
1730 
1731  for( double a = end_angle + angle;
1732  fabs( a - end_angle ) > fabs( delta_angle );
1733  a -= delta_angle )
1734  {
1735  pts.push_back(
1736  wxPoint( KiROUND( radius * cos( a ) ),
1737  KiROUND( radius * sin( a ) ) ) + center );
1738  }
1739  }
1740  }
1741 
1742  dwg->SetPolyPoints( pts );
1743  dwg->SetStart0( *pts.begin() );
1744  dwg->SetEnd0( pts.back() );
1745  dwg->SetDrawCoord();
1746 }
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:118
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:208
#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:209
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 1637 of file eagle_plugin.cpp.

1638 {
1639  ERECT r( aTree );
1640  PCB_LAYER_ID layer = kicad_layer( r.layer );
1641  EDGE_MODULE* dwg = new EDGE_MODULE( aModule, S_POLYGON );
1642 
1643  aModule->GraphicalItemsList().PushBack( dwg );
1644 
1645  dwg->SetLayer( layer );
1646  dwg->SetWidth( 0 );
1647 
1648  dwg->SetTimeStamp( EagleTimeStamp( aTree ) );
1649 
1650  std::vector<wxPoint> pts;
1651 
1652  wxPoint start( wxPoint( kicad_x( r.x1 ), kicad_y( r.y1 ) ) );
1653  wxPoint end( wxPoint( kicad_x( r.x1 ), kicad_y( r.y2 ) ) );
1654 
1655  pts.push_back( start );
1656  pts.push_back( wxPoint( kicad_x( r.x2 ), kicad_y( r.y1 ) ) );
1657  pts.push_back( wxPoint( kicad_x( r.x2 ), kicad_y( r.y2 ) ) );
1658  pts.push_back( end );
1659 
1660  dwg->SetPolyPoints( pts );
1661 
1662  dwg->SetStart0( start );
1663  dwg->SetEnd0( end );
1664 
1665  if( r.rot )
1666  {
1667  dwg->Rotate( dwg->GetCenter(), r.rot->degrees * 10 );
1668  }
1669 }
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:209
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 1822 of file eagle_plugin.cpp.

1823 {
1824  ESMD e( aTree );
1825  PCB_LAYER_ID layer = kicad_layer( e.layer );
1826 
1827  if( !IsCopperLayer( layer ) )
1828  return;
1829 
1830  bool shape_set = false;
1831  int shape = EPAD::UNDEF;
1832  D_PAD* pad = new D_PAD( aModule );
1833  aModule->PadsList().PushBack( pad );
1834  transferPad( e, pad );
1835 
1836  if( pad->GetName() == wxT( "1" ) && m_rules->psFirst != EPAD::UNDEF )
1837  shape = m_rules->psFirst;
1838  else if( layer == F_Cu && m_rules->psTop != EPAD::UNDEF )
1839  shape = m_rules->psTop;
1840  else if( layer == B_Cu && m_rules->psBottom != EPAD::UNDEF )
1841  shape = m_rules->psBottom;
1842 
1843  switch( shape )
1844  {
1845  case EPAD::ROUND:
1846  case EPAD::OCTAGON:
1847  shape_set = true;
1848  pad->SetShape( PAD_SHAPE_CIRCLE );
1849  break;
1850 
1851  case EPAD::SQUARE:
1852  shape_set = true;
1853  pad->SetShape( PAD_SHAPE_RECT );
1854  break;
1855 
1856  default:
1857  pad->SetShape( PAD_SHAPE_RECT );
1858  }
1859 
1860  pad->SetAttribute( PAD_ATTRIB_SMD );
1861 
1862  wxSize padSize( e.dx.ToPcbUnits(), e.dy.ToPcbUnits() );
1863  pad->SetSize( padSize );
1864  pad->SetLayer( layer );
1865 
1866  const LSET front( 3, F_Cu, F_Paste, F_Mask );
1867  const LSET back( 3, B_Cu, B_Paste, B_Mask );
1868 
1869  if( layer == F_Cu )
1870  pad->SetLayerSet( front );
1871  else if( layer == B_Cu )
1872  pad->SetLayerSet( back );
1873 
1874  int minPadSize = std::min( padSize.x, padSize.y );
1875 
1876  // Rounded rectangle pads
1877  int roundRadius = eagleClamp( m_rules->srMinRoundness * 2,
1878  (int)( minPadSize * m_rules->srRoundness ), m_rules->srMaxRoundness * 2 );
1879 
1880  if( !shape_set && ( e.roundness || roundRadius > 0 ) )
1881  {
1882  double roundRatio = (double) roundRadius / minPadSize / 2.0;
1883 
1884  // Eagle uses a different definition of roundness, hence division by 200
1885  if( e.roundness )
1886  roundRatio = std::fmax( *e.roundness / 200.0, roundRatio );
1887 
1888  pad->SetShape( PAD_SHAPE_ROUNDRECT );
1889  pad->SetRoundRectRadiusRatio( roundRatio );
1890  }
1891 
1892  if( e.rot )
1893  {
1894  pad->SetOrientation( e.rot->degrees * 10 );
1895  }
1896 
1898  (int) ( m_rules->mvCreamFrame * minPadSize ),
1899  m_rules->mlMaxCreamFrame ) );
1900 
1901  // Solder paste (only for SMD pads)
1902  if( e.cream && *e.cream == false ) // enabled by default
1903  {
1904  if( layer == F_Cu )
1905  pad->SetLayerSet( pad->GetLayerSet().set( F_Paste, false ) );
1906  else if( layer == B_Cu )
1907  pad->SetLayerSet( pad->GetLayerSet().set( B_Paste, false ) );
1908  }
1909 }
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:658
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:414
const wxString & GetName() const
Definition: class_pad.h:192
void SetSize(const wxSize &aSize)
Definition: class_pad.h:270
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:413
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:219
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:433
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 1531 of file eagle_plugin.cpp.

1532 {
1533  ETEXT t( aTree );
1534  PCB_LAYER_ID layer = kicad_layer( t.layer );
1535 
1536  if( layer == UNDEFINED_LAYER )
1537  {
1538  layer = Cmts_User;
1539  }
1540 
1541  TEXTE_MODULE* txt;
1542 
1543  if( t.text == ">NAME" || t.text == ">name" )
1544  txt = &aModule->Reference();
1545  else if( t.text == ">VALUE" || t.text == ">value" )
1546  txt = &aModule->Value();
1547  else
1548  {
1549  // FIXME: graphical text items are rotated for some reason.
1550  txt = new TEXTE_MODULE( aModule );
1551  aModule->GraphicalItemsList().PushBack( txt );
1552  }
1553 
1554  txt->SetTimeStamp( EagleTimeStamp( aTree ) );
1555  txt->SetText( FROM_UTF8( t.text.c_str() ) );
1556 
1557  wxPoint pos( kicad_x( t.x ), kicad_y( t.y ) );
1558 
1559  txt->SetTextPos( pos );
1560  txt->SetPos0( pos - aModule->GetPosition() );
1561 
1562  txt->SetLayer( layer );
1563  txt->SetTextSize( kicad_fontz( t.size ) );
1564 
1565  double ratio = t.ratio ? *t.ratio : 8; // DTD says 8 is default
1566 
1567  txt->SetThickness( t.size.ToPcbUnits() * ratio / 100 );
1568 
1569  int align = t.align ? *t.align : ETEXT::BOTTOM_LEFT; // bottom-left is eagle default
1570 
1571  // An eagle package is never rotated, the DTD does not allow it.
1572  // angle -= aModule->GetOrienation();
1573 
1574  if( t.rot )
1575  {
1576  int sign = t.rot->mirror ? -1 : 1;
1577  txt->SetMirrored( t.rot->mirror );
1578 
1579  double degrees = t.rot->degrees;
1580 
1581  if( degrees == 90 || t.rot->spin )
1582  txt->SetTextAngle( sign * degrees * 10 );
1583  else if( degrees == 180 )
1584  align = ETEXT::TOP_RIGHT;
1585  else if( degrees == 270 )
1586  {
1587  align = ETEXT::TOP_RIGHT;
1588  txt->SetTextAngle( sign * 90 * 10 );
1589  }
1590  }
1591 
1592  switch( align )
1593  {
1594  case ETEXT::CENTER:
1595  // this was the default in pcbtxt's constructor
1596  break;
1597 
1598  case ETEXT::CENTER_LEFT:
1600  break;
1601 
1602  case ETEXT::CENTER_RIGHT:
1604  break;
1605 
1606  case ETEXT::TOP_CENTER:
1608  break;
1609 
1610  case ETEXT::TOP_LEFT:
1613  break;
1614 
1615  case ETEXT::TOP_RIGHT:
1618  break;
1619 
1620  case ETEXT::BOTTOM_CENTER:
1622  break;
1623 
1624  case ETEXT::BOTTOM_LEFT:
1627  break;
1628 
1629  case ETEXT::BOTTOM_RIGHT:
1632  break;
1633  }
1634 }
void SetMirrored(bool isMirrored)
Definition: eda_text.h:195
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:61
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:240
void SetTextSize(const wxSize &aNewSize)
Definition: eda_text.h:231
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:
virtual void SetText(const wxString &aText)
Definition: eda_text.cpp:64
TEXTE_MODULE & Value()
read/write accessors:
Definition: class_module.h:502
void SetVertJustify(EDA_TEXT_VJUSTIFY_T aType)
Definition: eda_text.h:211
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:210
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:165
void SetTimeStamp(timestamp_t aNewTimeStamp)
Definition: base_struct.h:209
int sign(T val)
Definition: math_util.h:44

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:534
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 1912 of file eagle_plugin.cpp.

1913 {
1914  aPad->SetName( FROM_UTF8( aEaglePad.name.c_str() ) );
1915 
1916  // pad's "Position" is not relative to the module's,
1917  // whereas Pos0 is relative to the module's but is the unrotated coordinate.
1918  wxPoint padPos( kicad_x( aEaglePad.x ), kicad_y( aEaglePad.y ) );
1919  aPad->SetPos0( padPos );
1920 
1921  // Solder mask
1922  const wxSize& padSize( aPad->GetSize() );
1923 
1924  if( !aEaglePad.stop || !*aEaglePad.stop ) // enabled by default
1925  {
1927  (int)( m_rules->mvStopFrame * std::min( padSize.x, padSize.y ) ),
1928  m_rules->mlMaxStopFrame ) );
1929  }
1930 
1931  // Solid connection to copper zones
1932  if( aEaglePad.thermals && !*aEaglePad.thermals )
1934 
1935  MODULE* module = aPad->GetParent();
1936  wxCHECK( module, /* void */ );
1937  RotatePoint( &padPos, module->GetOrientation() );
1938  aPad->SetPosition( padPos + module->GetPosition() );
1939 }
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:61
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:221
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:501
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:184
void SetPos0(const wxPoint &aPos)
Definition: class_pad.h:264
MODULE * GetParent() const
Definition: class_pad.h:164
void SetLocalSolderMaskMargin(int aMargin)
Definition: class_pad.h:427
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:271
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: