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...
 
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 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 std::string & 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 std::string *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)
 
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...
 
std::string fmtDEG (double aAngle) const
 Function fmtDEG formats an angle in a way particular to a board file format. More...
 
MODULEmakeModule (wxXmlNode *aPackage, const std::string &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) const
 
void packageSMD (MODULE *aModule, wxXmlNode *aTree) const
 
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 83 of file eagle_plugin.h.

Member Typedef Documentation

typedef int EAGLE_PLUGIN::BIU

Definition at line 122 of file eagle_plugin.h.

typedef ELAYERS::const_iterator EAGLE_PLUGIN::EITER
private

Definition at line 129 of file eagle_plugin.h.

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

Definition at line 128 of file eagle_plugin.h.

Constructor & Destructor Documentation

EAGLE_PLUGIN::EAGLE_PLUGIN ( )

Definition at line 142 of file eagle_plugin.cpp.

References clear_cu_map(), and init().

142  :
143  m_rules( new ERULES() ),
144  m_xpath( new XPATH() ),
145  m_mod_time( wxDateTime::Now() )
146 {
147  init( NULL );
148  clear_cu_map();
149 }
void clear_cu_map()
ERULES * m_rules
Eagle design rules.
Definition: eagle_plugin.h:134
Class XPATH keeps track of what we are working on within a PTREE.
Definition: eagle_parser.h:110
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:135
subset of eagle.drawing.board.designrules in the XML document
Definition: eagle_plugin.h:42
wxDateTime m_mod_time
Definition: eagle_plugin.h:155
EAGLE_PLUGIN::~EAGLE_PLUGIN ( )

Definition at line 152 of file eagle_plugin.cpp.

References deleteTemplates(), m_rules, and m_xpath.

153 {
154  deleteTemplates();
155  delete m_rules;
156  delete m_xpath;
157 }
ERULES * m_rules
Eagle design rules.
Definition: eagle_plugin.h:134
XPATH * m_xpath
keeps track of what we are working on within XML document during a Load().
Definition: eagle_plugin.h:135
void deleteTemplates()
Deletes the footprint templates list

Member Function Documentation

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

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

Definition at line 2099 of file eagle_plugin.cpp.

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().

2100 {
2101  try
2102  {
2103  wxDateTime modtime = getModificationTime( aLibPath );
2104 
2105  // Fixes assertions in wxWidgets debug builds for the wxDateTime object. Refresh the
2106  // cache if either of the wxDateTime objects are invalid or the last file modification
2107  // time differs from the current file modification time.
2108  bool load = !m_mod_time.IsValid() || !modtime.IsValid() ||
2109  m_mod_time != modtime;
2110 
2111  if( aLibPath != m_lib_path || load )
2112  {
2113  wxXmlNode* doc;
2114  LOCALE_IO toggle; // toggles on, then off, the C locale.
2115 
2116  deleteTemplates();
2117 
2118  // Set this before completion of loading, since we rely on it for
2119  // text of an exception. Delay setting m_mod_time until after successful load
2120  // however.
2121  m_lib_path = aLibPath;
2122 
2123  // 8 bit "filename" should be encoded according to disk filename encoding,
2124  // (maybe this is current locale, maybe not, its a filesystem issue),
2125  // and is not necessarily utf8.
2126  string filename = (const char*) aLibPath.char_str( wxConvFile );
2127 
2128  // Load the document
2129  wxXmlDocument xmlDocument;
2130  wxFileName fn( filename );
2131 
2132  if( !xmlDocument.Load( fn.GetFullPath() ) )
2133  THROW_IO_ERROR( wxString::Format( _( "Unable to read file '%s'" ),
2134  fn.GetFullPath() ) );
2135 
2136  doc = xmlDocument.GetRoot();
2137 
2138  wxXmlNode* drawing = MapChildren( doc )["drawing"];
2139  NODE_MAP drawingChildren = MapChildren( drawing );
2140 
2141  // clear the cu map and then rebuild it.
2142  clear_cu_map();
2143 
2144  m_xpath->push( "eagle.drawing.layers" );
2145  wxXmlNode* layers = drawingChildren["layers"];
2146  loadLayerDefs( layers );
2147  m_xpath->pop();
2148 
2149  m_xpath->push( "eagle.drawing.library" );
2150  wxXmlNode* library = drawingChildren["library"];
2151  loadLibrary( library, NULL );
2152  m_xpath->pop();
2153 
2154  m_mod_time = modtime;
2155  }
2156  }
2157  catch(...){}
2158  // TODO: Handle exceptions
2159  // catch( file_parser_error fpe )
2160  // {
2161  // // for xml_parser_error, what() has the line number in it,
2162  // // but no byte offset. That should be an adequate error message.
2163  // THROW_IO_ERROR( fpe.what() );
2164  // }
2165  //
2166  // // Class ptree_error is a base class for xml_parser_error & file_parser_error,
2167  // // so one catch should be OK for all errors.
2168  // catch( ptree_error pte )
2169  // {
2170  // string errmsg = pte.what();
2171  //
2172  // errmsg += " @\n";
2173  // errmsg += m_xpath->Contents();
2174  //
2175  // THROW_IO_ERROR( errmsg );
2176  // }
2177 }
void clear_cu_map()
Class LOCALE_IO is a class that can be instantiated within a scope in which you are expecting excepti...
Definition: common.h:165
void push(const char *aPathSegment, const char *aAttribute="")
Definition: eagle_parser.h:115
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:135
wxString m_lib_path
Definition: eagle_plugin.h:154
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:155
void deleteTemplates()
Deletes the footprint templates list
void pop()
Definition: eagle_parser.h:122
std::unordered_map< string, wxXmlNode * > NODE_MAP
Definition: eagle_parser.h:49
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:38
void loadLibrary(wxXmlNode *aLib, const std::string *aLibName)
Function loadLibrary loads the Eagle "library" XML element, which can occur either under a "libraries...
void EAGLE_PLUGIN::centerBoard ( )
private

move the BOARD into the center of the page

Definition at line 2041 of file eagle_plugin.cpp.

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().

2042 {
2043  if( m_props )
2044  {
2045  UTF8 page_width;
2046  UTF8 page_height;
2047 
2048  if( m_props->Value( "page_width", &page_width ) &&
2049  m_props->Value( "page_height", &page_height ) )
2050  {
2052 
2053  int w = atoi( page_width.c_str() );
2054  int h = atoi( page_height.c_str() );
2055 
2056  int desired_x = ( w - bbbox.GetWidth() ) / 2;
2057  int desired_y = ( h - bbbox.GetHeight() ) / 2;
2058 
2059  DBG(printf( "bbox.width:%d bbox.height:%d w:%d h:%d desired_x:%d desired_y:%d\n",
2060  bbbox.GetWidth(), bbbox.GetHeight(), w, h, desired_x, desired_y );)
2061 
2062  m_board->Move( wxPoint( desired_x - bbbox.GetX(), desired_y - bbbox.GetY() ) );
2063  }
2064  }
2065 }
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:148
bool Value(const char *aName, UTF8 *aFetchedValue=NULL) const
Function Value fetches a property by aName and returns true if that property was found, else false.
Definition: properties.cpp:24
int GetHeight() const
const EDA_RECT GetBoardEdgesBoundingBox() const
Function GetBoardEdgesBoundingBox Returns the board bounding box calculated using exclusively the boa...
Definition: class_board.h:797
const PROPERTIES * m_props
passed via Save() or Load(), no ownership, may be NULL.
Definition: eagle_plugin.h:147
void Move(const wxPoint &aMoveVector) override
Function Move move this object.
const char * c_str() const
Definition: utf8.h:107
Class EDA_RECT handles the component boundary box.
int GetX() const
int GetWidth() const
int GetY() const
#define DBG(x)
Definition: fctsys.h:33
void EAGLE_PLUGIN::clear_cu_map ( )
private

Definition at line 287 of file eagle_plugin.cpp.

References DIM, and m_cu_map.

Referenced by cacheLib(), and EAGLE_PLUGIN().

288 {
289  // All cu layers are invalid until we see them in the <layers> section while
290  // loading either a board or library. See loadLayerDefs().
291  for( unsigned i = 0; i < DIM(m_cu_map); ++i )
292  m_cu_map[i] = -1;
293 }
#define DIM(x)
of elements in an array
Definition: macros.h:98
int m_cu_map[17]
map eagle to kicad, cu layers only.
Definition: eagle_plugin.h:131
void EAGLE_PLUGIN::deleteTemplates ( )
private

Deletes the footprint templates list

Definition at line 1695 of file eagle_plugin.cpp.

References m_templates.

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

1696 {
1697  for( auto& t : m_templates )
1698  delete t.second;
1699 
1700  m_templates.clear();
1701 }
MODULE_MAP m_templates
is part of a MODULE factory that operates using copy construction.
Definition: eagle_plugin.h:142
const string & EAGLE_PLUGIN::eagle_layer_name ( int  aLayer) const
private

Get Eagle layer name by its number.

Definition at line 2033 of file eagle_plugin.cpp.

References m_eagleLayers.

Referenced by kicad_layer().

2034 {
2035  static const string unknown( "unknown" );
2036  auto it = m_eagleLayers.find( aLayer );
2037  return it == m_eagleLayers.end() ? unknown : it->second.name;
2038 }
std::map< int, ELAYER > m_eagleLayers
Eagle layers data stored by the layer number.
Definition: eagle_plugin.h:132
std::string 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.

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 92 of file plugin.cpp.

References not_implemented().

Referenced by FP_LIB_TABLE::FootprintDelete().

93 {
94  // not pure virtual so that plugins only have to implement subset of the PLUGIN interface.
95  not_implemented( this, __FUNCTION__ );
96 }
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
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 2180 of file eagle_plugin.cpp.

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

2182 {
2183  init( aProperties );
2184 
2185  cacheLib( aLibraryPath );
2186 
2187  for( MODULE_CITER it = m_templates.begin(); it != m_templates.end(); ++it )
2188  aFootprintNames.Add( FROM_UTF8( it->first.c_str() ) );
2189 }
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes...
Definition: macros.h:53
void init(const PROPERTIES *aProperties)
initialize PLUGIN like a constructor would, and futz with fresh BOARD if needed.
void cacheLib(const wxString &aLibraryPath)
This PLUGIN only caches one footprint library, this determines which one.
MODULE_MAP::const_iterator MODULE_CITER
MODULE_MAP m_templates
is part of a MODULE factory that operates using copy construction.
Definition: eagle_plugin.h:142
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 99 of file plugin.cpp.

References not_implemented().

Referenced by PCB_BASE_EDIT_FRAME::CreateNewLibrary(), and FP_LIB_TABLE::FootprintLibCreate().

100 {
101  // not pure virtual so that plugins only have to implement subset of the PLUGIN interface.
102  not_implemented( this, __FUNCTION__ );
103 }
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
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 106 of file plugin.cpp.

References not_implemented().

Referenced by PCB_BASE_EDIT_FRAME::CreateNewLibrary(), and FP_LIB_TABLE::FootprintLibDelete().

107 {
108  // not pure virtual so that plugins only have to implement subset of the PLUGIN interface.
109  not_implemented( this, __FUNCTION__ );
110  return false;
111 }
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
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 2213 of file eagle_plugin.cpp.

References PLUGIN::FootprintLibOptions().

2214 {
2215  PLUGIN::FootprintLibOptions( aListToAppendTo );
2216 
2217  /*
2218  (*aListToAppendTo)["ignore_duplicates"] = UTF8( _(
2219  "Ignore duplicately named footprints within the same Eagle library. "
2220  "Only the first similarly named footprint will be loaded."
2221  ));
2222  */
2223 }
virtual void FootprintLibOptions(PROPERTIES *aListToAppendTo) const
Function FootprintLibOptions appends supported PLUGIN options to aListToAppenTo along with internatio...
Definition: plugin.cpp:122
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 2192 of file eagle_plugin.cpp.

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

2194 {
2195  init( aProperties );
2196 
2197  cacheLib( aLibraryPath );
2198 
2199  string key = TO_UTF8( aFootprintName );
2200 
2201  MODULE_CITER mi = m_templates.find( key );
2202 
2203  if( mi == m_templates.end() )
2204  return NULL;
2205 
2206  // copy constructor to clone the template
2207  MODULE* ret = new MODULE( *mi->second );
2208 
2209  return ret;
2210 }
void init(const PROPERTIES *aProperties)
initialize PLUGIN like a constructor would, and futz with fresh BOARD if needed.
#define TO_UTF8(wxstring)
Macro TO_UTF8 converts a wxString to a UTF8 encoded C string for all wxWidgets build modes...
Definition: macros.h:47
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:142
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 85 of file plugin.cpp.

References not_implemented().

Referenced by PCB_EDIT_FRAME::ArchiveModulesOnBoard(), FP_LIB_TABLE::FootprintSave(), FOOTPRINT_EDIT_FRAME::OnSaveLibraryAs(), and FOOTPRINT_EDIT_FRAME::SaveCurrentModule().

86 {
87  // not pure virtual so that plugins only have to implement subset of the PLUGIN interface.
88  not_implemented( this, __FUNCTION__ );
89 }
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
const wxString EAGLE_PLUGIN::GetFileExtension ( ) const
overridevirtual

Function GetFileExtension returns the file extension for the PLUGIN.

Implements PLUGIN.

Definition at line 166 of file eagle_plugin.cpp.

167 {
168  return wxT( "brd" );
169 }
wxDateTime EAGLE_PLUGIN::getModificationTime ( const wxString &  aPath)
staticprivate

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

Definition at line 2068 of file eagle_plugin.cpp.

References Format(), GetChars(), and THROW_IO_ERROR.

Referenced by cacheLib().

2069 {
2070  wxFileName fn( aPath );
2071 
2072  // Do not call wxFileName::GetModificationTime() on a non-existent file, because
2073  // if it fails, wx's implementation calls the crap wxLogSysError() which
2074  // eventually infects our UI with an unwanted popup window, so don't let it fail.
2075  if( !fn.IsFileReadable() )
2076  {
2077  wxString msg = wxString::Format(
2078  _( "File '%s' is not readable." ),
2079  GetChars( aPath ) );
2080 
2081  THROW_IO_ERROR( msg );
2082  }
2083 
2084  /*
2085  // update the writable flag while we have a wxFileName, in a network this
2086  // is possibly quite dynamic anyway.
2087  m_writable = fn.IsFileWritable();
2088  */
2089 
2090  wxDateTime modTime = fn.GetModificationTime();
2091 
2092  if( !modTime.IsValid() )
2093  modTime.Now();
2094 
2095  return modTime;
2096 }
static const wxChar * GetChars(const wxString &s)
Function GetChars returns a wxChar* to the actual wxChar* data within a wxString, and is helpful for ...
Definition: macros.h:92
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:38
void EAGLE_PLUGIN::init ( const PROPERTIES aProperties)
private

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

Definition at line 268 of file eagle_plugin.cpp.

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, m_templates, and m_xpath.

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

269 {
270  m_hole_count = 0;
271  m_min_trace = 0;
272  m_min_via = 0;
273  m_min_via_hole = 0;
274  m_xpath->clear();
275  m_pads_to_nets.clear();
276  m_templates.clear();
277 
278  m_board = NULL;
279  m_props = aProperties;
280 
281 
282  delete m_rules;
283  m_rules = new ERULES();
284 }
BOARD * m_board
which BOARD is being worked on, no ownership here
Definition: eagle_plugin.h:148
void clear()
Definition: eagle_parser.h:120
ERULES * m_rules
Eagle design rules.
Definition: eagle_plugin.h:134
int m_min_via
smallest via we find on Load(), in BIU.
Definition: eagle_plugin.h:151
XPATH * m_xpath
keeps track of what we are working on within XML document during a Load().
Definition: eagle_plugin.h:135
int m_min_via_hole
smallest via diameter hole we find on Load(), in BIU.
Definition: eagle_plugin.h:152
const PROPERTIES * m_props
passed via Save() or Load(), no ownership, may be NULL.
Definition: eagle_plugin.h:147
subset of eagle.drawing.board.designrules in the XML document
Definition: eagle_plugin.h:42
int m_min_trace
smallest trace we find on Load(), in BIU.
Definition: eagle_plugin.h:150
int m_hole_count
generates unique module names from eagle "hole"s.
Definition: eagle_plugin.h:138
MODULE_MAP m_templates
is part of a MODULE factory that operates using copy construction.
Definition: eagle_plugin.h:142
NET_MAP m_pads_to_nets
net list
Definition: eagle_plugin.h:140
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 101 of file eagle_plugin.h.

102  {
103  return false; // until someone writes others like FootprintSave(), etc.
104  }
wxSize EAGLE_PLUGIN::kicad_fontz ( const ECOORD d) const
inlineprivate

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

Definition at line 172 of file eagle_plugin.cpp.

References ECOORD::ToPcbUnits().

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

173 {
174  // texts seem to better match eagle when scaled down by 0.95
175  int kz = d.ToPcbUnits() * 95 / 100;
176  return wxSize( kz, kz );
177 }
int ToPcbUnits() const
Definition: eagle_parser.h:421
PCB_LAYER_ID EAGLE_PLUGIN::kicad_layer ( int  aLayer) const
private

Convert an Eagle layer to a KiCad layer.

Definition at line 1965 of file eagle_plugin.cpp.

References 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, DIM, 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(), loadSignals(), packageCircle(), packagePolygon(), packageRectangle(), packageSMD(), packageText(), and packageWire().

1966 {
1967  int kiLayer;
1968 
1969  // eagle copper layer:
1970  if( aEagleLayer >= 1 && aEagleLayer < int( DIM( m_cu_map ) ) )
1971  {
1972  kiLayer = m_cu_map[aEagleLayer];
1973  }
1974 
1975  else
1976  {
1977  // translate non-copper eagle layer to pcbnew layer
1978  switch( aEagleLayer )
1979  {
1980  // Eagle says "Dimension" layer, but it's for board perimeter
1981  case EAGLE_LAYER::DIMENSION: kiLayer = Edge_Cuts; break;
1982  case EAGLE_LAYER::TPLACE: kiLayer = F_SilkS; break;
1983  case EAGLE_LAYER::BPLACE: kiLayer = B_SilkS; break;
1984  case EAGLE_LAYER::TNAMES: kiLayer = F_SilkS; break;
1985  case EAGLE_LAYER::BNAMES: kiLayer = B_SilkS; break;
1986  case EAGLE_LAYER::TVALUES: kiLayer = F_SilkS; break;
1987  case EAGLE_LAYER::BVALUES: kiLayer = B_SilkS; break;
1988  case EAGLE_LAYER::TSTOP: kiLayer = F_Mask; break;
1989  case EAGLE_LAYER::BSTOP: kiLayer = B_Mask; break;
1990  case EAGLE_LAYER::TCREAM: kiLayer = F_Paste; break;
1991  case EAGLE_LAYER::BCREAM: kiLayer = B_Paste; break;
1992  case EAGLE_LAYER::TFINISH: kiLayer = F_Mask; break;
1993  case EAGLE_LAYER::BFINISH: kiLayer = B_Mask; break;
1994  case EAGLE_LAYER::TGLUE: kiLayer = F_Adhes; break;
1995  case EAGLE_LAYER::BGLUE: kiLayer = B_Adhes; break;
1996  case EAGLE_LAYER::DOCUMENT: kiLayer = Cmts_User; break;
1997  case EAGLE_LAYER::REFERENCELC: kiLayer = Cmts_User; break;
1998  case EAGLE_LAYER::REFERENCELS: kiLayer = Cmts_User; break;
1999 
2000  // Packages show the future chip pins on SMD parts using layer 51.
2001  // This is an area slightly smaller than the PAD/SMD copper area.
2002  // Carry those visual aids into the MODULE on the fabrication layer,
2003  // not silkscreen. This is perhaps not perfect, but there is not a lot
2004  // of other suitable paired layers
2005  case EAGLE_LAYER::TDOCU: kiLayer = F_Fab; break;
2006  case EAGLE_LAYER::BDOCU: kiLayer = B_Fab; break;
2007 
2008  // thes layers are defined as user layers. put them on ECO layers
2009  case EAGLE_LAYER::USERLAYER1: kiLayer = Eco1_User; break;
2010  case EAGLE_LAYER::USERLAYER2: kiLayer = Eco2_User; break;
2011 
2012  case EAGLE_LAYER::UNROUTED:
2013  case EAGLE_LAYER::TKEEPOUT:
2014  case EAGLE_LAYER::BKEEPOUT:
2015  case EAGLE_LAYER::TTEST:
2016  case EAGLE_LAYER::BTEST:
2017  case EAGLE_LAYER::MILLING:
2018  case EAGLE_LAYER::HOLES:
2019  default:
2020  // some layers do not map to KiCad
2021  wxLogMessage( wxString::Format( "Unsupported Eagle layer '%s' (%d), converted to Dwgs.User layer",
2022  eagle_layer_name( aEagleLayer ), aEagleLayer ) );
2023 
2024  kiLayer = Dwgs_User;
2025  break;
2026  }
2027  }
2028 
2029  return PCB_LAYER_ID( kiLayer );
2030 }
#define DIM(x)
of elements in an array
Definition: macros.h:98
int m_cu_map[17]
map eagle to kicad, cu layers only.
Definition: eagle_plugin.h:131
PCB_LAYER_ID
A quick note on layer IDs:
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
const std::string & eagle_layer_name(int aLayer) const
Get Eagle layer name by its number.
int EAGLE_PLUGIN::kicad_x ( const ECOORD x) const
inlineprivate
int EAGLE_PLUGIN::kicad_y ( const ECOORD y) const
inlineprivate

Convert an Eagle distance to a KiCad distance.

Definition at line 163 of file eagle_plugin.h.

References ECOORD::ToPcbUnits().

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

163 { return -y.ToPcbUnits(); }
int ToPcbUnits() const
Definition: eagle_parser.h:421
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 180 of file eagle_plugin.cpp.

References centerBoard(), XPATH::Contents(), Format(), BOARD_DESIGN_SETTINGS::GetDefault(), 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::SetFileName(), and THROW_IO_ERROR.

181 {
182  LOCALE_IO toggle; // toggles on, then off, the C locale.
183  wxXmlNode* doc;
184 
185  init( aProperties );
186 
187  m_board = aAppendToMe ? aAppendToMe : new BOARD();
188 
189  // Give the filename to the board if it's new
190  if( !aAppendToMe )
191  m_board->SetFileName( aFileName );
192 
193  // delete on exception, if I own m_board, according to aAppendToMe
194  unique_ptr<BOARD> deleter( aAppendToMe ? NULL : m_board );
195 
196  try
197  {
198  // Load the document
199  wxXmlDocument xmlDocument;
200  wxFileName fn = aFileName;
201 
202  if( !xmlDocument.Load( fn.GetFullPath() ) )
203  THROW_IO_ERROR( wxString::Format( _( "Unable to read file '%s'" ),
204  fn.GetFullPath() ) );
205 
206  doc = xmlDocument.GetRoot();
207 
208  m_min_trace = INT_MAX;
209  m_min_via = INT_MAX;
210  m_min_via_hole = INT_MAX;
211 
212  loadAllSections( doc );
213 
214  BOARD_DESIGN_SETTINGS& designSettings = m_board->GetDesignSettings();
215 
216  if( m_min_trace < designSettings.m_TrackMinWidth )
217  designSettings.m_TrackMinWidth = m_min_trace;
218 
219  if( m_min_via < designSettings.m_ViasMinSize )
220  designSettings.m_ViasMinSize = m_min_via;
221 
222  if( m_min_via_hole < designSettings.m_ViasMinDrill )
223  designSettings.m_ViasMinDrill = m_min_via_hole;
224 
225  if( m_rules->mdWireWire )
226  {
227  NETCLASSPTR defaultNetclass = designSettings.GetDefault();
228  int clearance = KiROUND( m_rules->mdWireWire );
229 
230  if( clearance < defaultNetclass->GetClearance() )
231  defaultNetclass->SetClearance( clearance );
232  }
233 
234  // should be empty, else missing m_xpath->pop()
235  wxASSERT( m_xpath->Contents().size() == 0 );
236  }
237  // Catch all exceptions thrown from the parser.
238  catch( const XML_PARSER_ERROR &exc )
239  {
240  string errmsg = exc.what();
241 
242  errmsg += "\n@ ";
243  errmsg += m_xpath->Contents();
244 
245  THROW_IO_ERROR( errmsg );
246  }
247 
248  // IO_ERROR exceptions are left uncaught, they pass upwards from here.
249 
250  // Ensure the copper layers count is a multiple of 2
251  // Pcbnew does not like boards with odd layers count
252  // (these boards cannot exist. they actually have a even layers count)
253  int lyrcnt = m_board->GetCopperLayerCount();
254 
255  if( (lyrcnt % 2) != 0 )
256  {
257  lyrcnt++;
258  m_board->SetCopperLayerCount( lyrcnt );
259  }
260 
261  centerBoard();
262 
263  deleter.release();
264  return m_board;
265 }
void loadAllSections(wxXmlNode *aDocument)
NETCLASSPTR GetDefault() const
Function GetDefault.
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:148
static int KiROUND(double v)
KiROUND rounds a floating point number to an int using "round halfway cases away from zero"...
Definition: common.h:106
Class LOCALE_IO is a class that can be instantiated within a scope in which you are expecting excepti...
Definition: common.h:165
ERULES * m_rules
Eagle design rules.
Definition: eagle_plugin.h:134
int GetCopperLayerCount() const
Function GetCopperLayerCount.
void SetCopperLayerCount(int aCount)
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:151
Class XML_PARSER_ERROR implements a simple wrapper around runtime_error to isolate the errors thrown ...
Definition: eagle_parser.h:68
XPATH * m_xpath
keeps track of what we are working on within XML document during a Load().
Definition: eagle_plugin.h:135
int m_min_via_hole
smallest via diameter hole we find on Load(), in BIU.
Definition: eagle_plugin.h:152
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
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:532
void SetFileName(const wxString &aFileName)
Definition: class_board.h:232
double mdWireWire
wire to wire spacing I presume.
Definition: eagle_plugin.h:58
int m_min_trace
smallest trace we find on Load(), in BIU.
Definition: eagle_plugin.h:150
string Contents()
return the contents of the XPATH as a single string
Definition: eagle_parser.h:137
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
Class BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:169
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:38
Class BOARD_DESIGN_SETTINGS contains design settings for a BOARD object.
void EAGLE_PLUGIN::loadAllSections ( wxXmlNode *  aDocument)
private

Definition at line 296 of file eagle_plugin.cpp.

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

Referenced by Load().

297 {
298  wxXmlNode* drawing = MapChildren( aDoc )["drawing"];
299  NODE_MAP drawingChildren = MapChildren( drawing );
300 
301  wxXmlNode* board = drawingChildren["board"];
302  NODE_MAP boardChildren = MapChildren( board );
303 
304  m_xpath->push( "eagle.drawing" );
305 
306  {
307  m_xpath->push( "board" );
308 
309  wxXmlNode* designrules = boardChildren["designrules"];
310  loadDesignRules( designrules );
311 
312  m_xpath->pop();
313  }
314 
315  {
316  m_xpath->push( "layers" );
317 
318  wxXmlNode* layers = drawingChildren["layers"];
319  loadLayerDefs( layers );
320 
321  m_xpath->pop();
322  }
323 
324  {
325  m_xpath->push( "board" );
326 
327  wxXmlNode* plain = boardChildren["plain"];
328  loadPlain( plain );
329 
330  wxXmlNode* signals = boardChildren["signals"];
331  loadSignals( signals );
332 
333  wxXmlNode* libs = boardChildren["libraries"];
334  loadLibraries( libs );
335 
336  wxXmlNode* elems = boardChildren["elements"];
337  loadElements( elems );
338 
339  m_xpath->pop(); // "board"
340  }
341 
342  m_xpath->pop(); // "eagle.drawing"
343 }
void push(const char *aPathSegment, const char *aAttribute="")
Definition: eagle_parser.h:115
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:135
void loadLibraries(wxXmlNode *aLibs)
void loadPlain(wxXmlNode *aPlain)
void loadElements(wxXmlNode *aElements)
void pop()
Definition: eagle_parser.h:122
void loadDesignRules(wxXmlNode *aDesignRules)
std::unordered_map< string, wxXmlNode * > NODE_MAP
Definition: eagle_parser.h:49
void loadSignals(wxXmlNode *aSignals)
void EAGLE_PLUGIN::loadDesignRules ( wxXmlNode *  aDesignRules)
private

Definition at line 346 of file eagle_plugin.cpp.

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

Referenced by loadAllSections().

347 {
348  m_xpath->push( "designrules" );
349  m_rules->parse( aDesignRules );
350  m_xpath->pop(); // "designrules"
351 }
ERULES * m_rules
Eagle design rules.
Definition: eagle_plugin.h:134
void push(const char *aPathSegment, const char *aAttribute="")
Definition: eagle_parser.h:115
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:135
void pop()
Definition: eagle_parser.h:122
void EAGLE_PLUGIN::loadElements ( wxXmlNode *  aElements)
private

Definition at line 829 of file eagle_plugin.cpp.

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, D_PAD::Next(), 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, TO_UTF8, XPATH::Value(), MODULE::Value(), EATTR::value, EATTR::VALUE, EELEMENT::value, EELEMENT::x, and EELEMENT::y.

Referenced by loadAllSections().

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

Definition at line 354 of file eagle_plugin.cpp.

References ELAYER::active, B_Cu, cu, DIM, F_Cu, FROM_UTF8(), 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().

355 {
356  ELAYERS cu; // copper layers
357 
358  // Get the first layer and iterate
359  wxXmlNode* layerNode = aLayers->GetChildren();
360 
361  m_eagleLayers.clear();
362 
363  while( layerNode )
364  {
365  ELAYER elayer( layerNode );
366  m_eagleLayers.insert( std::make_pair( elayer.number, elayer ) );
367 
368  // find the subset of layers that are copper and active
369  if( elayer.number >= 1 && elayer.number <= 16 && ( !elayer.active || *elayer.active ) )
370  {
371  cu.push_back( elayer );
372  }
373 
374  layerNode = layerNode->GetNext();
375  }
376 
377  // establish cu layer map:
378  int ki_layer_count = 0;
379 
380  for( EITER it = cu.begin(); it != cu.end(); ++it, ++ki_layer_count )
381  {
382  if( ki_layer_count == 0 )
383  m_cu_map[it->number] = F_Cu;
384  else if( ki_layer_count == int( cu.size()-1 ) )
385  m_cu_map[it->number] = B_Cu;
386  else
387  {
388  // some eagle boards do not have contiguous layer number sequences.
389 
390 #if 0 // pre PCB_LAYER_ID & LSET:
391  m_cu_map[it->number] = cu.size() - 1 - ki_layer_count;
392 #else
393  m_cu_map[it->number] = ki_layer_count;
394 #endif
395  }
396  }
397 
398 #if 0 && defined(DEBUG)
399  printf( "m_cu_map:\n" );
400  for( unsigned i=0; i<DIM(m_cu_map); ++i )
401  {
402  printf( "\t[%d]:%d\n", i, m_cu_map[i] );
403  }
404 #endif
405 
406  // Set the layer names and cu count iff we're loading a board.
407  if( m_board )
408  {
409  m_board->SetCopperLayerCount( cu.size() );
410 
411  for( EITER it = cu.begin(); it != cu.end(); ++it )
412  {
413  PCB_LAYER_ID layer = kicad_layer( it->number );
414 
415  // these function provide their own protection against UNDEFINED_LAYER:
416  m_board->SetLayerName( layer, FROM_UTF8( it->name.c_str() ) );
417  m_board->SetLayerType( layer, LT_SIGNAL );
418 
419  // could map the colors here
420  }
421  }
422 }
#define DIM(x)
of elements in an array
Definition: macros.h:98
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes...
Definition: macros.h:53
BOARD * m_board
which BOARD is being worked on, no ownership here
Definition: eagle_plugin.h:148
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:131
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:132
bool SetLayerName(PCB_LAYER_ID aLayer, const wxString &aLayerName)
Function SetLayerName changes the name of the layer given by aLayer.
std::vector< ELAYER > ELAYERS
Definition: eagle_plugin.h:128
ELAYERS::const_iterator EITER
Definition: eagle_plugin.h:129
void EAGLE_PLUGIN::loadLibraries ( wxXmlNode *  aLibs)
private

Definition at line 807 of file eagle_plugin.cpp.

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

Referenced by loadAllSections().

808 {
809  m_xpath->push( "libraries.library", "name" );
810 
811  // Get the first library and iterate
812  wxXmlNode* library = aLibs->GetChildren();
813 
814  while( library )
815  {
816  const string& lib_name = library->GetAttribute( "name" ).ToStdString();
817 
818  m_xpath->Value( lib_name.c_str() );
819 
820  loadLibrary( library, &lib_name );
821 
822  library = library->GetNext();
823  }
824 
825  m_xpath->pop();
826 }
void push(const char *aPathSegment, const char *aAttribute="")
Definition: eagle_parser.h:115
XPATH * m_xpath
keeps track of what we are working on within XML document during a Load().
Definition: eagle_plugin.h:135
void pop()
Definition: eagle_parser.h:122
void Value(const char *aValue)
modify the last path node's value
Definition: eagle_parser.h:125
void loadLibrary(wxXmlNode *aLib, const std::string *aLibName)
Function loadLibrary loads the Eagle "library" XML element, which can occur either under a "libraries...
void EAGLE_PLUGIN::loadLibrary ( wxXmlNode *  aLib,
const std::string *  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 749 of file eagle_plugin.cpp.

References Format(), FROM_UTF8(), 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().

750 {
751  m_xpath->push( "packages" );
752 
753  // library will have <xmlattr> node, skip that and get the single packages node
754  wxXmlNode* packages = MapChildren( aLib )["packages"];
755 
756 
757  // Create a MODULE for all the eagle packages, for use later via a copy constructor
758  // to instantiate needed MODULES in our BOARD. Save the MODULE templates in
759  // a MODULE_MAP using a single lookup key consisting of libname+pkgname.
760 
761  // Get the first package and iterate
762  wxXmlNode* package = packages->GetChildren();
763 
764  while( package )
765  {
766  m_xpath->push( "package", "name" );
767 
768  const wxString& pack_ref = package->GetAttribute( "name" );
769 
770  string pack_name( pack_ref.ToStdString() );
771 
772  ReplaceIllegalFileNameChars( &pack_name );
773 
774  m_xpath->Value( pack_name.c_str() );
775 
776  string key = aLibName ? makeKey( *aLibName, pack_name ) : pack_name;
777 
778  MODULE* m = makeModule( package, pack_name );
779 
780  // add the templating MODULE to the MODULE template factory "m_templates"
781  std::pair<MODULE_ITER, bool> r = m_templates.insert( {key, m} );
782 
783  if( !r.second
784  // && !( m_props && m_props->Value( "ignore_duplicates" ) )
785  )
786  {
787  wxString lib = aLibName ? FROM_UTF8( aLibName->c_str() ) : m_lib_path;
788  wxString pkg = FROM_UTF8( pack_name.c_str() );
789 
790  wxString emsg = wxString::Format(
791  _( "<package> name: '%s' duplicated in eagle <library>: '%s'" ),
792  GetChars( pkg ),
793  GetChars( lib )
794  );
795  THROW_IO_ERROR( emsg );
796  }
797 
798  m_xpath->pop();
799 
800  package = package->GetNext();
801  }
802 
803  m_xpath->pop(); // "packages"
804 }
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes...
Definition: macros.h:53
MODULE * makeModule(wxXmlNode *aPackage, const std::string &aPkgName) const
Function makeModule creates a MODULE from an Eagle package.
static string makeKey(const string &aFirst, const string &aSecond)
Assemble a two part key as a simple concatenation of aFirst and aSecond parts, using a separator...
void push(const char *aPathSegment, const char *aAttribute="")
Definition: eagle_parser.h:115
bool ReplaceIllegalFileNameChars(std::string *aName, int aReplaceChar)
Function ReplaceIllegalFileNameChars checks aName for illegal file name characters.
Definition: string.cpp:483
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:135
wxString m_lib_path
Definition: eagle_plugin.h:154
static const wxChar * GetChars(const wxString &s)
Function GetChars returns a wxChar* to the actual wxChar* data within a wxString, and is helpful for ...
Definition: macros.h:92
void Format(OUTPUTFORMATTER *out, int aNestLevel, int aCtl, CPTREE &aTree)
Function Format outputs a PTREE into s-expression format via an OUTPUTFORMATTER derivative.
Definition: ptree.cpp:205
MODULE_MAP m_templates
is part of a MODULE factory that operates using copy construction.
Definition: eagle_plugin.h:142
void pop()
Definition: eagle_parser.h:122
#define THROW_IO_ERROR(msg)
Definition: ki_exception.h:38
void Value(const char *aValue)
modify the last path node's value
Definition: eagle_parser.h:125
void EAGLE_PLUGIN::loadPlain ( wxXmlNode *  aPlain)
private

Definition at line 425 of file eagle_plugin.cpp.

References abs, BOARD::Add(), ADD_APPEND, DIMENSION::AdjustDimensionDetails(), ETEXT::align, LSET::AllCuMask(), ZONE_CONTAINER::AppendCorner(), ETEXT::BOTTOM_CENTER, ETEXT::BOTTOM_LEFT, ETEXT::BOTTOM_RIGHT, ETEXT::CENTER, ETEXT::CENTER_LEFT, ETEXT::CENTER_RIGHT, Clamp_Text_PenSize(), ConvertArcCenter(), EWIRE::curve, DEFAULT_PCB_EDGE_THICKNESS, EROT::degrees, ZONE_CONTAINER::DIAGONAL_EDGE, EDIMENSION::dimensionType, EHOLE::drill, EagleTimeStamp(), FROM_UTF8(), ZONE_CONTAINER::GetDefaultHatchPitch(), BOARD::GetDesignSettings(), EDA_TEXT::GetTextSize(), 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, m_board, m_hole_count, BOARD_DESIGN_SETTINGS::m_PcbTextSize, BOARD_DESIGN_SETTINGS::m_PcbTextWidth, m_xpath, EROT::mirror, PAD_ATTRIB_HOLE_NOT_PLATED, PAD_SHAPE_CIRCLE, MODULE::PadsList(), XPATH::pop(), XPATH::push(), DLIST< T >::PushBack(), ECIRCLE::radius, ETEXT::ratio, MODULE::Reference(), ETEXT::rot, S_ARC, S_CIRCLE, DRAWSEGMENT::SetAngle(), D_PAD::SetAttribute(), D_PAD::SetDrillSize(), DRAWSEGMENT::SetEnd(), DIMENSION::SetEnd(), ZONE_CONTAINER::SetHatch(), DIMENSION::SetHeight(), EDA_TEXT::SetHorizJustify(), DIMENSION::SetLayer(), BOARD_ITEM::SetLayer(), ZONE_CONTAINER::SetLayer(), D_PAD::SetLayerSet(), EDA_TEXT::SetMirrored(), BOARD_CONNECTED_ITEM::SetNetCode(), DIMENSION::SetOrigin(), MODULE::SetPosition(), MODULE::SetReference(), DRAWSEGMENT::SetShape(), D_PAD::SetShape(), D_PAD::SetSize(), DRAWSEGMENT::SetStart(), EDA_TEXT::SetText(), TEXTE_PCB::SetTextAngle(), EDA_TEXT::SetTextPos(), EDA_TEXT::SetTextSize(), EDA_TEXT::SetThickness(), EDA_ITEM::SetTimeStamp(), 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, EHOLE::x, EWIRE::x1, ERECT::x1, EDIMENSION::x1, EWIRE::x2, ERECT::x2, EDIMENSION::x2, EDIMENSION::x3, ECIRCLE::y, ETEXT::y, EHOLE::y, EWIRE::y1, ERECT::y1, EDIMENSION::y1, EWIRE::y2, ERECT::y2, EDIMENSION::y2, and EDIMENSION::y3.

Referenced by loadAllSections().

426 {
427  m_xpath->push( "plain" );
428 
429  // Get the first graphic and iterate
430  wxXmlNode* gr = aGraphics->GetChildren();
431 
432  // (polygon | wire | text | circle | rectangle | frame | hole)*
433  while( gr )
434  {
435  wxString grName = gr->GetName();
436 
437  if( grName == "wire" )
438  {
439  m_xpath->push( "wire" );
440 
441  EWIRE w( gr );
442  PCB_LAYER_ID layer = kicad_layer( w.layer );
443 
444  wxPoint start( kicad_x( w.x1 ), kicad_y( w.y1 ) );
445  wxPoint end( kicad_x( w.x2 ), kicad_y( w.y2 ) );
446 
447  if( layer != UNDEFINED_LAYER )
448  {
449  DRAWSEGMENT* dseg = new DRAWSEGMENT( m_board );
450  m_board->Add( dseg, ADD_APPEND );
451 
452  if( !w.curve )
453  {
454  dseg->SetStart( start );
455  dseg->SetEnd( end );
456  }
457  else
458  {
459  wxPoint center = ConvertArcCenter( start, end, *w.curve );
460 
461  dseg->SetShape( S_ARC );
462  dseg->SetStart( center );
463  dseg->SetEnd( start );
464  dseg->SetAngle( *w.curve * -10.0 ); // KiCad rotates the other way
465  }
466 
467  dseg->SetTimeStamp( EagleTimeStamp( gr ) );
468  dseg->SetLayer( layer );
469  dseg->SetWidth( Millimeter2iu( DEFAULT_PCB_EDGE_THICKNESS ) );
470  }
471  m_xpath->pop();
472  }
473  else if( grName == "text" )
474  {
475  m_xpath->push( "text" );
476 
477  ETEXT t( gr );
478  PCB_LAYER_ID layer = kicad_layer( t.layer );
479 
480  if( layer != UNDEFINED_LAYER )
481  {
482  TEXTE_PCB* pcbtxt = new TEXTE_PCB( m_board );
483  m_board->Add( pcbtxt, ADD_APPEND );
484 
485  pcbtxt->SetLayer( layer );
486  pcbtxt->SetTimeStamp( EagleTimeStamp( gr ) );
487  pcbtxt->SetText( FROM_UTF8( t.text.c_str() ) );
488  pcbtxt->SetTextPos( wxPoint( kicad_x( t.x ), kicad_y( t.y ) ) );
489 
490  pcbtxt->SetTextSize( kicad_fontz( t.size ) );
491 
492  double ratio = t.ratio ? *t.ratio : 8; // DTD says 8 is default
493 
494  pcbtxt->SetThickness( t.size.ToPcbUnits() * ratio / 100 );
495 
496  int align = t.align ? *t.align : ETEXT::BOTTOM_LEFT;
497 
498  if( t.rot )
499  {
500  int sign = t.rot->mirror ? -1 : 1;
501  pcbtxt->SetMirrored( t.rot->mirror );
502 
503  double degrees = t.rot->degrees;
504 
505  if( degrees == 90 || t.rot->spin )
506  pcbtxt->SetTextAngle( sign * t.rot->degrees * 10 );
507  else if( degrees == 180 )
508  align = ETEXT::TOP_RIGHT;
509  else if( degrees == 270 )
510  {
511  pcbtxt->SetTextAngle( sign * 90 * 10 );
512  align = ETEXT::TOP_RIGHT;
513  }
514  else // Ok so text is not at 90,180 or 270 so do some funny stuf to get placement right
515  {
516  if( ( degrees > 0 ) && ( degrees < 90 ) )
517  pcbtxt->SetTextAngle( sign * t.rot->degrees * 10 );
518  else if( ( degrees > 90 ) && ( degrees < 180 ) )
519  {
520  pcbtxt->SetTextAngle( sign * ( t.rot->degrees + 180 ) * 10 );
521  align = ETEXT::TOP_RIGHT;
522  }
523  else if( ( degrees > 180 ) && ( degrees < 270 ) )
524  {
525  pcbtxt->SetTextAngle( sign * ( t.rot->degrees - 180 ) * 10 );
526  align = ETEXT::TOP_RIGHT;
527  }
528  else if( ( degrees > 270 ) && ( degrees < 360 ) )
529  {
530  pcbtxt->SetTextAngle( sign * t.rot->degrees * 10 );
531  align = ETEXT::BOTTOM_LEFT;
532  }
533  }
534  }
535 
536  switch( align )
537  {
538  case ETEXT::CENTER:
539  // this was the default in pcbtxt's constructor
540  break;
541 
542  case ETEXT::CENTER_LEFT:
544  break;
545 
546  case ETEXT::CENTER_RIGHT:
548  break;
549 
550  case ETEXT::TOP_CENTER:
552  break;
553 
554  case ETEXT::TOP_LEFT:
557  break;
558 
559  case ETEXT::TOP_RIGHT:
562  break;
563 
566  break;
567 
568  case ETEXT::BOTTOM_LEFT:
571  break;
572 
573  case ETEXT::BOTTOM_RIGHT:
576  break;
577  }
578  }
579  m_xpath->pop();
580  }
581  else if( grName == "circle" )
582  {
583  m_xpath->push( "circle" );
584 
585  ECIRCLE c( gr );
586  PCB_LAYER_ID layer = kicad_layer( c.layer );
587 
588  if( layer != UNDEFINED_LAYER ) // unsupported layer
589  {
590  DRAWSEGMENT* dseg = new DRAWSEGMENT( m_board );
591  m_board->Add( dseg, ADD_APPEND );
592 
593  dseg->SetShape( S_CIRCLE );
594  dseg->SetTimeStamp( EagleTimeStamp( gr ) );
595  dseg->SetLayer( layer );
596  dseg->SetStart( wxPoint( kicad_x( c.x ), kicad_y( c.y ) ) );
597  dseg->SetEnd( wxPoint( kicad_x( c.x + c.radius ), kicad_y( c.y ) ) );
598  dseg->SetWidth( c.width.ToPcbUnits() );
599  }
600  m_xpath->pop();
601  }
602  else if( grName == "rectangle" )
603  {
604  // This seems to be a simplified rectangular [copper] zone, cannot find any
605  // net related info on it from the DTD.
606  m_xpath->push( "rectangle" );
607 
608  ERECT r( gr );
609  PCB_LAYER_ID layer = kicad_layer( r.layer );
610 
611  if( IsCopperLayer( layer ) )
612  {
613  // use a "netcode = 0" type ZONE:
614  ZONE_CONTAINER* zone = new ZONE_CONTAINER( m_board );
615  m_board->Add( zone, ADD_APPEND );
616 
617  zone->SetTimeStamp( EagleTimeStamp( gr ) );
618  zone->SetLayer( layer );
620 
622 
623  const int outlineIdx = -1; // this is the id of the copper zone main outline
624  zone->AppendCorner( wxPoint( kicad_x( r.x1 ), kicad_y( r.y1 ) ), outlineIdx );
625  zone->AppendCorner( wxPoint( kicad_x( r.x2 ), kicad_y( r.y1 ) ), outlineIdx );
626  zone->AppendCorner( wxPoint( kicad_x( r.x2 ), kicad_y( r.y2 ) ), outlineIdx );
627  zone->AppendCorner( wxPoint( kicad_x( r.x1 ), kicad_y( r.y2 ) ), outlineIdx );
628 
629  // this is not my fault:
630  zone->SetHatch( outline_hatch, zone->GetDefaultHatchPitch(), true );
631  }
632 
633  m_xpath->pop();
634  }
635  else if( grName == "hole" )
636  {
637  m_xpath->push( "hole" );
638  EHOLE e( gr );
639 
640  // Fabricate a MODULE with a single PAD_ATTRIB_HOLE_NOT_PLATED pad.
641  // Use m_hole_count to gen up a unique name.
642 
643  MODULE* module = new MODULE( m_board );
644  m_board->Add( module, ADD_APPEND );
645 
646  char temp[40];
647  sprintf( temp, "@HOLE%d", m_hole_count++ );
648  module->SetReference( FROM_UTF8( temp ) );
649  module->Reference().SetVisible( false );
650 
651  wxPoint pos( kicad_x( e.x ), kicad_y( e.y ) );
652 
653  module->SetPosition( pos );
654 
655  // Add a PAD_ATTRIB_HOLE_NOT_PLATED pad to this module.
656  D_PAD* pad = new D_PAD( module );
657  module->PadsList().PushBack( pad );
658 
659  pad->SetShape( PAD_SHAPE_CIRCLE );
661 
662  /* pad's position is already centered on module at relative (0, 0)
663  wxPoint padpos( kicad_x( e.x ), kicad_y( e.y ) );
664 
665  pad->SetPos0( padpos );
666  pad->SetPosition( padpos + module->GetPosition() );
667  */
668 
669  wxSize sz( e.drill.ToPcbUnits(), e.drill.ToPcbUnits() );
670 
671  pad->SetDrillSize( sz );
672  pad->SetSize( sz );
673 
674  pad->SetLayerSet( LSET::AllCuMask() );
675  m_xpath->pop();
676  }
677  else if( grName == "frame" )
678  {
679  // picture this
680  }
681  else if( grName == "polygon" )
682  {
683  // could be on a copper layer, could be on another layer.
684  // copper layer would be done using netCode=0 type of ZONE_CONTAINER.
685  }
686  else if( grName == "dimension" )
687  {
688  EDIMENSION d( gr );
689  PCB_LAYER_ID layer = kicad_layer( d.layer );
690 
691  if( layer != UNDEFINED_LAYER )
692  {
693  DIMENSION* dimension = new DIMENSION( m_board );
694  m_board->Add( dimension, ADD_APPEND );
695 
696  if( d.dimensionType )
697  {
698  // Eagle dimension graphic arms may have different lengths, but they look
699  // incorrect in KiCad (the graphic is tilted). Make them even lenght in such case.
700  if( *d.dimensionType == "horizontal" )
701  {
702  int newY = ( d.y1.ToPcbUnits() + d.y2.ToPcbUnits() ) / 2;
703  d.y1 = ECOORD( newY, ECOORD::EAGLE_UNIT::EAGLE_NM );
704  d.y2 = ECOORD( newY, ECOORD::EAGLE_UNIT::EAGLE_NM );
705  }
706  else if( *d.dimensionType == "vertical" )
707  {
708  int newX = ( d.x1.ToPcbUnits() + d.x2.ToPcbUnits() ) / 2;
709  d.x1 = ECOORD( newX, ECOORD::EAGLE_UNIT::EAGLE_NM );
710  d.x2 = ECOORD( newX, ECOORD::EAGLE_UNIT::EAGLE_NM );
711  }
712  }
713 
714  dimension->SetLayer( layer );
715  // The origin and end are assumed to always be in this order from eagle
716  dimension->SetOrigin( wxPoint( kicad_x( d.x1 ), kicad_y( d.y1 ) ) );
717  dimension->SetEnd( wxPoint( kicad_x( d.x2 ), kicad_y( d.y2 ) ) );
719 
721  int maxThickness = Clamp_Text_PenSize( width, dimension->Text().GetTextSize() );
722 
723  if( width > maxThickness )
724  width = maxThickness;
725 
726  dimension->Text().SetThickness( width );
727  dimension->SetWidth( width );
728 
729  // check which axis the dimension runs in
730  // because the "height" of the dimension is perpendicular to that axis
731  // Note the check is just if two axes are close enough to each other
732  // Eagle appears to have some rounding errors
733  if( abs( ( d.x1 - d.x2 ).ToPcbUnits() ) < 50000 ) // 50000 nm = 0.05 mm
734  dimension->SetHeight( kicad_x( d.x3 - d.x1 ) );
735  else
736  dimension->SetHeight( kicad_y( d.y3 - d.y1 ) );
737 
738  dimension->AdjustDimensionDetails();
739  }
740  }
741 
742  // Get next graphic
743  gr = gr->GetNext();
744  }
745  m_xpath->pop();
746 }
void SetMirrored(bool isMirrored)
Definition: eda_text.h:178
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:646
Class ZONE_CONTAINER handles a list of polygons defining a copper zone.
Definition: class_zone.h:78
void SetTextAngle(double aAngle)
TEXTE_MODULE & Reference()
Definition: class_module.h:483
void SetShape(STROKE_T aShape)
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes...
Definition: macros.h:53
BOARD * m_board
which BOARD is being worked on, no ownership here
Definition: eagle_plugin.h:148
like PAD_STANDARD, but not plated mechanical use only, no connection allowed
Definition: pad_shapes.h:65
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
int m_PcbTextWidth
current Pcb (not module) Text width
PCB_LAYER_ID kicad_layer(int aLayer) const
Convert an Eagle layer to a KiCad layer.
void push(const char *aPathSegment, const char *aAttribute="")
Definition: eagle_parser.h:115
void SetTextPos(const wxPoint &aPoint)
Definition: eda_text.h:223
void SetVisible(bool aVisible)
Definition: eda_text.h:175
void SetHatch(int aHatchStyle, int aHatchPitch, bool aRebuildHatch)
Function SetHatch sets all hatch parameters for the zone.
void SetDrillSize(const wxSize &aSize)
Definition: class_pad.h:274
void SetTextSize(const wxSize &aNewSize)
Definition: eda_text.h:214
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:164
Eagle hole element.
Definition: eagle_parser.h:774
Eagle text element.
Definition: eagle_parser.h:636
#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:135
void SetTimeStamp(time_t aNewTimeStamp)
Definition: base_struct.h:217
#define DEFAULT_PCB_EDGE_THICKNESS
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:
void SetOrigin(const wxPoint &aOrigin)
Function SetOrigin Sets a new origin of the crossbar line.
wxSize m_PcbTextSize
current Pcb (not module) Text size
void SetEnd(const wxPoint &aEnd)
Function SetEnd Sets a new end of the crossbar line.
int Clamp_Text_PenSize(int aPenSize, int aSize, bool aBold)
Function Clamp_Text_PenSize As a rule, pen width should not be >1/4em, otherwise the character will b...
Definition: drawtxt.cpp:67
void SetVertJustify(EDA_TEXT_VJUSTIFY_T aType)
Definition: eda_text.h:194
Arcs (with rounded ends)
Eagle circle.
Definition: eagle_parser.h:561
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:209
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:163
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:532
void SetSize(const wxSize &aSize)
Definition: class_pad.h:268
bool SetNetCode(int aNetCode, bool aNoAssert=false)
Function SetNetCode sets net using a net code.
void SetReference(const wxString &aReference)
Function SetReference.
Definition: class_module.h:449
HATCH_STYLE
Zone hatch styles.
Definition: class_zone.h:85
void SetPosition(const wxPoint &aPos) override
int m_hole_count
generates unique module names from eagle "hole"s.
Definition: eagle_plugin.h:138
Eagle XML rectangle in binary.
Definition: eagle_parser.h:574
void SetAttribute(PAD_ATTR_T aAttribute)
Definition: class_pad.cpp:392
void AdjustDimensionDetails(bool aDoNotChangeText=false)
Function AdjustDimensionDetails Calculate coordinates of segments used to draw the dimension...
void SetStart(const wxPoint &aStart)
unsigned long EagleTimeStamp(wxXmlNode *aTree)
Make a unique time stamp.
void SetLayerSet(LSET aLayerMask)
Definition: class_pad.h:394
wxSize kicad_fontz(const ECOORD &d) const
create a font size (fontz) from an eagle font size scalar
void SetHorizJustify(EDA_TEXT_HJUSTIFY_T aType)
Definition: eda_text.h:193
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 SetShape(PAD_SHAPE_T aShape)
Definition: class_pad.h:217
void SetEnd(const wxPoint &aEnd)
Eagle wire.
Definition: eagle_parser.h:490
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)
Eagle dimension element.
Definition: eagle_parser.h:619
DLIST< D_PAD > & PadsList()
Definition: class_module.h:154
const wxSize & GetTextSize() const
Definition: eda_text.h:215
void pop()
Definition: eagle_parser.h:122
void SetWidth(int aWidth)
static const int UNCONNECTED
Constant that holds the "unconnected net" number (typically 0) all items "connected" to this net are ...
Class DIMENSION.
void SetThickness(int aNewThickness)
Function SetThickness sets pen width.
Definition: eda_text.h:148
int sign(T val)
Definition: math_util.h:44
virtual void SetText(const wxString &aText)
Definition: eda_text.h:141
void SetWidth(int aWidth)
void EAGLE_PLUGIN::loadSignals ( wxXmlNode *  aSignals)
private

Definition at line 1708 of file eagle_plugin.cpp.

References BOARD::Add(), ADD_APPEND, ZONE_CONTAINER::AppendCorner(), B_Cu, Clamp(), EPOLYGON::CUTOUT, ZONE_CONTAINER::DIAGONAL_EDGE, EVIA::diam, EVIA::drill, EagleTimeStamp(), F_Cu, FROM_UTF8(), ZONE_CONTAINER::GetDefaultHatchPitch(), VIA::GetDrill(), TRACK::GetWidth(), DLIST< T >::Insert(), IsCopperLayer(), EPOLYGON::isolate, kicad_layer(), kicad_x(), kicad_y(), KiROUND(), EWIRE::layer, EPOLYGON::layer, EVIA::layer_back_most, EVIA::layer_front_most, m_board, m_min_trace, m_min_via, m_min_via_hole, m_pads_to_nets, m_rules, BOARD::m_Track, m_xpath, makeKey(), EPOLYGON::max_priority, ZONE_CONTAINER::NO_HATCH, PAD_ZONE_CONN_FULL, PAD_ZONE_CONN_THERMAL, XPATH::pop(), EPOLYGON::pour, XPATH::push(), EPOLYGON::rank, ERULES::rlMaxViaOuter, ERULES::rlMinViaOuter, ERULES::rvViaOuter, ZONE_CONTAINER::SetArcSegmentCount(), ZONE_CONTAINER::SetDoNotAllowCopperPour(), VIA::SetDrill(), TRACK::SetEnd(), ZONE_CONTAINER::SetHatch(), ZONE_CONTAINER::SetHatchStyle(), ZONE_CONTAINER::SetIsKeepout(), BOARD_ITEM::SetLayer(), ZONE_CONTAINER::SetLayer(), VIA::SetLayerPair(), ZONE_CONTAINER::SetMinThickness(), BOARD_CONNECTED_ITEM::SetNetCode(), ZONE_CONTAINER::SetPadConnection(), TRACK::SetPosition(), VIA::SetPosition(), ZONE_CONTAINER::SetPriority(), ZONE_CONTAINER::SetThermalReliefCopperBridge(), ZONE_CONTAINER::SetThermalReliefGap(), EDA_ITEM::SetTimeStamp(), VIA::SetViaType(), TRACK::SetWidth(), ZONE_CONTAINER::SetZoneClearance(), EPOLYGON::spacing, EPOLYGON::thermals, ECOORD::ToPcbUnits(), NETINFO_LIST::UNCONNECTED, XPATH::Value(), VIA, VIA_BLIND_BURIED, VIA_MICROVIA, VIA_THROUGH, EWIRE::width, EPOLYGON::width, EVIA::x, EVERTEX::x, EWIRE::x1, EWIRE::x2, EVIA::y, EVERTEX::y, EWIRE::y1, and EWIRE::y2.

Referenced by loadAllSections().

1709 {
1710  ZONES zones; // per net
1711 
1712  m_xpath->push( "signals.signal", "name" );
1713 
1714  int netCode = 1;
1715 
1716  // Get the first signal and iterate
1717  wxXmlNode* net = aSignals->GetChildren();
1718 
1719  while( net )
1720  {
1721  bool sawPad = false;
1722 
1723  zones.clear();
1724 
1725  const string& nname = net->GetAttribute( "name" ).ToStdString();
1726  wxString netName = FROM_UTF8( nname.c_str() );
1727  m_board->Add( new NETINFO_ITEM( m_board, netName, netCode ) );
1728 
1729  m_xpath->Value( nname.c_str() );
1730 
1731  // Get the first net item and iterate
1732  wxXmlNode* netItem = net->GetChildren();
1733 
1734  // (contactref | polygon | wire | via)*
1735  while( netItem )
1736  {
1737  const wxString& itemName = netItem->GetName();
1738  if( itemName == "wire" )
1739  {
1740  m_xpath->push( "wire" );
1741 
1742  EWIRE w( netItem );
1743  PCB_LAYER_ID layer = kicad_layer( w.layer );
1744 
1745  if( IsCopperLayer( layer ) )
1746  {
1747  TRACK* t = new TRACK( m_board );
1748 
1749  t->SetTimeStamp( EagleTimeStamp( netItem ) );
1750 
1751  t->SetPosition( wxPoint( kicad_x( w.x1 ), kicad_y( w.y1 ) ) );
1752  t->SetEnd( wxPoint( kicad_x( w.x2 ), kicad_y( w.y2 ) ) );
1753 
1754  int width = w.width.ToPcbUnits();
1755  if( width < m_min_trace )
1756  m_min_trace = width;
1757 
1758  t->SetWidth( width );
1759  t->SetLayer( layer );
1760  t->SetNetCode( netCode );
1761 
1762  m_board->m_Track.Insert( t, NULL );
1763  }
1764  else
1765  {
1766  // put non copper wires where the sun don't shine.
1767  }
1768 
1769  m_xpath->pop();
1770  }
1771 
1772  else if( itemName == "via" )
1773  {
1774  m_xpath->push( "via" );
1775  EVIA v( netItem );
1776 
1777  PCB_LAYER_ID layer_front_most = kicad_layer( v.layer_front_most );
1778  PCB_LAYER_ID layer_back_most = kicad_layer( v.layer_back_most );
1779 
1780  if( IsCopperLayer( layer_front_most ) &&
1781  IsCopperLayer( layer_back_most ) )
1782  {
1783  int kidiam;
1784  int drillz = v.drill.ToPcbUnits();
1785  VIA* via = new VIA( m_board );
1786  m_board->m_Track.Insert( via, NULL );
1787 
1788  via->SetLayerPair( layer_front_most, layer_back_most );
1789 
1790  if( v.diam )
1791  {
1792  kidiam = v.diam->ToPcbUnits();
1793  via->SetWidth( kidiam );
1794  }
1795  else
1796  {
1797  double annulus = drillz * m_rules->rvViaOuter; // eagle "restring"
1798  annulus = Clamp( m_rules->rlMinViaOuter, annulus, m_rules->rlMaxViaOuter );
1799  kidiam = KiROUND( drillz + 2 * annulus );
1800  via->SetWidth( kidiam );
1801  }
1802 
1803  via->SetDrill( drillz );
1804 
1805  // make sure the via diameter respects the restring rules
1806 
1807  if( !v.diam || via->GetWidth() <= via->GetDrill() )
1808  {
1809  double annulus = Clamp( m_rules->rlMinViaOuter,
1810  (double)( via->GetWidth() / 2 - via->GetDrill() ), m_rules->rlMaxViaOuter );
1811  via->SetWidth( drillz + 2 * annulus );
1812  }
1813 
1814  if( kidiam < m_min_via )
1815  m_min_via = kidiam;
1816 
1817  if( drillz < m_min_via_hole )
1818  m_min_via_hole = drillz;
1819 
1820  if( layer_front_most == F_Cu && layer_back_most == B_Cu )
1821  via->SetViaType( VIA_THROUGH );
1822  else if( layer_front_most == F_Cu || layer_back_most == B_Cu )
1823  via->SetViaType( VIA_MICROVIA );
1824  else
1825  via->SetViaType( VIA_BLIND_BURIED );
1826 
1827  via->SetTimeStamp( EagleTimeStamp( netItem ) );
1828 
1829  wxPoint pos( kicad_x( v.x ), kicad_y( v.y ) );
1830 
1831  via->SetPosition( pos );
1832  via->SetEnd( pos );
1833 
1834  via->SetNetCode( netCode );
1835  }
1836 
1837  m_xpath->pop();
1838  }
1839 
1840  else if( itemName == "contactref" )
1841  {
1842  m_xpath->push( "contactref" );
1843  // <contactref element="RN1" pad="7"/>
1844 
1845  const string& reference = netItem->GetAttribute( "element" ).ToStdString();
1846  const string& pad = netItem->GetAttribute( "pad" ).ToStdString();
1847 
1848  string key = makeKey( reference, pad ) ;
1849 
1850  // D(printf( "adding refname:'%s' pad:'%s' netcode:%d netname:'%s'\n", reference.c_str(), pad.c_str(), netCode, nname.c_str() );)
1851 
1852  m_pads_to_nets[ key ] = ENET( netCode, nname );
1853 
1854  m_xpath->pop();
1855 
1856  sawPad = true;
1857  }
1858 
1859  else if( itemName == "polygon" )
1860  {
1861  m_xpath->push( "polygon" );
1862 
1863  EPOLYGON p( netItem );
1864  PCB_LAYER_ID layer = kicad_layer( p.layer );
1865 
1866  if( IsCopperLayer( layer ) )
1867  {
1868  // use a "netcode = 0" type ZONE:
1869  ZONE_CONTAINER* zone = new ZONE_CONTAINER( m_board );
1870  m_board->Add( zone, ADD_APPEND );
1871  zones.push_back( zone );
1872 
1873  zone->SetTimeStamp( EagleTimeStamp( netItem ) );
1874  zone->SetLayer( layer );
1875  zone->SetNetCode( netCode );
1876 
1877  // Get the first vertex and iterate
1878  wxXmlNode* vertex = netItem->GetChildren();
1879 
1880  while( vertex )
1881  {
1882  if( vertex->GetName() != "vertex" ) // skip <xmlattr> node
1883  continue;
1884 
1885  EVERTEX v( vertex );
1886 
1887  // Append the corner
1888  zone->AppendCorner( wxPoint( kicad_x( v.x ), kicad_y( v.y ) ), -1 );
1889 
1890  vertex = vertex->GetNext();
1891  }
1892 
1893  // If the pour is a cutout it needs to be set to a keepout
1894  if( p.pour == EPOLYGON::CUTOUT )
1895  {
1896  zone->SetIsKeepout( true );
1897  zone->SetDoNotAllowCopperPour( true );
1899  }
1900 
1901  // if spacing is set the zone should be hatched
1902  // However, use the default hatch step, p.spacing value has no meaning for Kicad
1903  // TODO: see if this parameter is related to a grid fill option.
1904  if( p.spacing )
1906 
1907  // clearances, etc.
1908  zone->SetArcSegmentCount( 32 ); // @todo: should be a constructor default?
1909  zone->SetMinThickness( p.width.ToPcbUnits() );
1910 
1911  // FIXME: KiCad zones have very rounded corners compared to eagle.
1912  // This means that isolation amounts that work well in eagle
1913  // tend to make copper intrude in soldermask free areas around pads.
1914  if( p.isolate )
1915  {
1916  zone->SetZoneClearance( p.isolate->ToPcbUnits() );
1917  } else
1918  {
1919  zone->SetZoneClearance( 0 );
1920  }
1921 
1922  // missing == yes per DTD.
1923  bool thermals = !p.thermals || *p.thermals;
1925  if( thermals )
1926  {
1927  // FIXME: eagle calculates dimensions for thermal spokes
1928  // based on what the zone is connecting to.
1929  // (i.e. width of spoke is half of the smaller side of an smd pad)
1930  // This is a basic workaround
1931  zone->SetThermalReliefGap( p.width.ToPcbUnits() + 50000 ); // 50000nm == 0.05mm
1932  zone->SetThermalReliefCopperBridge( p.width.ToPcbUnits() + 50000 );
1933  }
1934 
1935  int rank = p.rank ? (p.max_priority - *p.rank) : p.max_priority;
1936  zone->SetPriority( rank );
1937  }
1938 
1939  m_xpath->pop(); // "polygon"
1940  }
1941 
1942  netItem = netItem->GetNext();
1943  }
1944 
1945  if( zones.size() && !sawPad )
1946  {
1947  // KiCad does not support an unconnected zone with its own non-zero netcode,
1948  // but only when assigned netcode = 0 w/o a name...
1949  for( ZONES::iterator it = zones.begin(); it != zones.end(); ++it )
1950  (*it)->SetNetCode( NETINFO_LIST::UNCONNECTED );
1951 
1952  // therefore omit this signal/net.
1953  }
1954  else
1955  netCode++;
1956 
1957  // Get next signal
1958  net = net->GetNext();
1959  }
1960 
1961  m_xpath->pop(); // "signals.signal"
1962 }
Eagle vertex.
Definition: eagle_parser.h:735
double rlMaxViaOuter
maximum copper annulus on via
Definition: eagle_plugin.h:57
Class ZONE_CONTAINER handles a list of polygons defining a copper zone.
Definition: class_zone.h:78
const T & Clamp(const T &lower, const T &value, const T &upper)
Function Clamp limits value within the range lower <= value <= upper.
Definition: macros.h:127
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes...
Definition: macros.h:53
BOARD * m_board
which BOARD is being worked on, no ownership here
Definition: eagle_plugin.h:148
void SetViaType(VIATYPE_T aViaType)
Definition: class_track.h:444
static int KiROUND(double v)
KiROUND rounds a floating point number to an int using "round halfway cases away from zero"...
Definition: common.h:106
void SetPosition(const wxPoint &aPoint) override
Definition: class_track.h:416
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:119
ERULES * m_rules
Eagle design rules.
Definition: eagle_plugin.h:134
static string makeKey(const string &aFirst, const string &aSecond)
Assemble a two part key as a simple concatenation of aFirst and aSecond parts, using a separator...
PCB_LAYER_ID kicad_layer(int aLayer) const
Convert an Eagle layer to a KiCad layer.
void push(const char *aPathSegment, const char *aAttribute="")
Definition: eagle_parser.h:115
void SetArcSegmentCount(int aArcSegCount)
Definition: class_zone.h:212
void SetHatch(int aHatchStyle, int aHatchPitch, bool aRebuildHatch)
Function SetHatch sets all hatch parameters for the zone.
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:164
int m_min_via
smallest via we find on Load(), in BIU.
Definition: eagle_plugin.h:151
double rvViaOuter
copper annulus is this percent of via hole
Definition: eagle_plugin.h:55
int GetDrill() const
Function GetDrill returns the local drill setting for this VIA.
Definition: class_track.h:458
static int GetDefaultHatchPitch()
Function GetDefaultHatchPitchMils.
XPATH * m_xpath
keeps track of what we are working on within XML document during a Load().
Definition: eagle_plugin.h:135
void SetTimeStamp(time_t aNewTimeStamp)
Definition: base_struct.h:217
void SetWidth(int aWidth)
Definition: class_track.h:116
void SetPriority(unsigned aPriority)
Function SetPriority.
Definition: class_zone.h:113
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:152
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:209
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:163
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...
void SetZoneClearance(int aZoneClearance)
Definition: class_zone.h:219
std::vector< ZONE_CONTAINER * > ZONES
non-owning container
int m_min_trace
smallest trace we find on Load(), in BIU.
Definition: eagle_plugin.h:150
Eagle net.
Definition: eagle_parser.h:452
void SetThermalReliefCopperBridge(int aThermalReliefCopperBridge)
Definition: class_zone.h:206
void SetDoNotAllowCopperPour(bool aEnable)
Definition: class_zone.h:678
Eagle via.
Definition: eagle_parser.h:546
unsigned long EagleTimeStamp(wxXmlNode *aTree)
Make a unique time stamp.
Class NETINFO_ITEM handles the data for a net.
Definition: class_netinfo.h:69
int GetWidth() const
Definition: class_track.h:117
void SetPosition(const wxPoint &aPos) override
Definition: class_track.h:113
void SetDrill(int aDrill)
Function SetDrill sets the drill value for vias.
Definition: class_track.h:451
void SetHatchStyle(HATCH_STYLE aStyle)
Definition: class_zone.h:569
NET_MAP m_pads_to_nets
net list
Definition: eagle_plugin.h:140
Eagle wire.
Definition: eagle_parser.h:490
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)
DLIST< TRACK > m_Track
Definition: class_board.h:246
Eagle polygon, without vertices which are parsed as needed.
Definition: eagle_parser.h:745
void pop()
Definition: eagle_parser.h:122
void SetIsKeepout(bool aEnable)
Definition: class_zone.h:677
void SetPadConnection(ZoneConnection aPadConnection)
Definition: class_zone.h:222
void SetMinThickness(int aMinThickness)
Definition: class_zone.h:225
double rlMinViaOuter
minimum copper annulus on via
Definition: eagle_plugin.h:56
static const int UNCONNECTED
Constant that holds the "unconnected net" number (typically 0) all items "connected" to this net are ...
Use thermal relief for pads.
Definition: zones.h:58
void SetThermalReliefGap(int aThermalReliefGap)
Definition: class_zone.h:203
void Insert(T *aNewElement, T *aElementAfterMe)
Function Insert puts aNewElement just in front of aElementAfterMe in the list sequence.
Definition: dlist.h:200
pads are covered by copper
Definition: zones.h:59
void Value(const char *aValue)
modify the last path node's value
Definition: eagle_parser.h:125
MODULE * EAGLE_PLUGIN::makeModule ( wxXmlNode *  aPackage,
const std::string &  aPkgName 
) const
private

Function makeModule creates a MODULE from an Eagle package.

Definition at line 1185 of file eagle_plugin.cpp.

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

Referenced by loadLibrary().

1186 {
1187  std::unique_ptr<MODULE> m( new MODULE( m_board ) );
1188 
1189  m->SetFPID( LIB_ID( UTF8( aPkgName ) ) );
1190 
1191  // Get the first package item and iterate
1192  wxXmlNode* packageItem = aPackage->GetChildren();
1193 
1194  while( packageItem )
1195  {
1196  const wxString& itemName = packageItem->GetName();
1197 
1198  if( itemName == "description" )
1199  m->SetDescription( FROM_UTF8( packageItem->GetNodeContent().c_str() ) );
1200 
1201  else if( itemName == "wire" )
1202  packageWire( m.get(), packageItem );
1203 
1204  else if( itemName == "pad" )
1205  packagePad( m.get(), packageItem );
1206 
1207  else if( itemName == "text" )
1208  packageText( m.get(), packageItem );
1209 
1210  else if( itemName == "rectangle" )
1211  packageRectangle( m.get(), packageItem );
1212 
1213  else if( itemName == "polygon" )
1214  packagePolygon( m.get(), packageItem );
1215 
1216  else if( itemName == "circle" )
1217  packageCircle( m.get(), packageItem );
1218 
1219  else if( itemName == "hole" )
1220  packageHole( m.get(), packageItem );
1221 
1222  else if( itemName == "smd" )
1223  packageSMD( m.get(), packageItem );
1224 
1225  packageItem = packageItem->GetNext();
1226  }
1227 
1228  return m.release();
1229 }
Class UTF8 is an 8 bit string that is assuredly encoded in UTF8, and supplies special conversion supp...
Definition: utf8.h:73
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes...
Definition: macros.h:53
BOARD * m_board
which BOARD is being worked on, no ownership here
Definition: eagle_plugin.h:148
void packageHole(MODULE *aModule, wxXmlNode *aTree) const
void packageText(MODULE *aModule, wxXmlNode *aTree) const
void packagePolygon(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 packageCircle(MODULE *aModule, wxXmlNode *aTree) const
void packageSMD(MODULE *aModule, wxXmlNode *aTree) const
void packagePad(MODULE *aModule, wxXmlNode *aTree) const
void packageWire(MODULE *aModule, wxXmlNode *aTree) const
void packageRectangle(MODULE *aModule, wxXmlNode *aTree) const
void EAGLE_PLUGIN::orientModuleAndText ( MODULE m,
const EELEMENT e,
const EATTR nameAttr,
const EATTR valueAttr 
)
private

Definition at line 1055 of file eagle_plugin.cpp.

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

Referenced by loadElements().

1057 {
1058  if( e.rot )
1059  {
1060  if( e.rot->mirror )
1061  {
1062  double orientation = e.rot->degrees + 180.0;
1063  m->SetOrientation( orientation * 10 );
1064  m->Flip( m->GetPosition() );
1065  }
1066  else
1067  m->SetOrientation( e.rot->degrees * 10 );
1068  }
1069 
1070  orientModuleText( m, e, &m->Reference(), nameAttr );
1071  orientModuleText( m, e, &m->Value(), valueAttr );
1072 }
bool mirror
Definition: eagle_parser.h:471
TEXTE_MODULE & Reference()
Definition: class_module.h:483
void Flip(const wxPoint &aCentre) override
Function Flip Flip this object, i.e.
const wxPoint & GetPosition() const override
Definition: class_module.h:175
opt_erot rot
Definition: eagle_parser.h:795
double degrees
Definition: eagle_parser.h:473
TEXTE_MODULE & Value()
read/write accessors:
Definition: class_module.h:482
void SetOrientation(double newangle)
void orientModuleText(MODULE *m, const EELEMENT &e, TEXTE_MODULE *txt, const EATTR *a)
void EAGLE_PLUGIN::orientModuleText ( MODULE m,
const EELEMENT e,
TEXTE_MODULE txt,
const EATTR a 
)
private

Definition at line 1075 of file eagle_plugin.cpp.

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().

1077 {
1078  // Smashed part ?
1079  if( aAttr )
1080  { // Yes
1081  const EATTR& a = *aAttr;
1082 
1083  if( a.value )
1084  {
1085  txt->SetText( FROM_UTF8( a.value->c_str() ) );
1086  }
1087 
1088  if( a.x && a.y ) // OPT
1089  {
1090  wxPoint pos( kicad_x( *a.x ), kicad_y( *a.y ) );
1091  txt->SetTextPos( pos );
1092  }
1093 
1094  // Even though size and ratio are both optional, I am not seeing
1095  // a case where ratio is present but size is not.
1096  double ratio = 8;
1097  wxSize fontz = txt->GetTextSize();
1098 
1099  if( a.size )
1100  {
1101  fontz = kicad_fontz( *a.size );
1102  txt->SetTextSize( fontz );
1103 
1104  if( a.ratio )
1105  ratio = *a.ratio;
1106  }
1107 
1108  int lw = int( fontz.y * ratio / 100 );
1109  txt->SetThickness( lw );
1110 
1111  int align = ETEXT::BOTTOM_LEFT; // bottom-left is eagle default
1112 
1113  // The "rot" in a EATTR seems to be assumed to be zero if it is not
1114  // present, and this zero rotation becomes an override to the
1115  // package's text field. If they did not want zero, they specify
1116  // what they want explicitly.
1117  double degrees = a.rot ? a.rot->degrees : 0;
1118  double orient; // relative to parent
1119 
1120  int sign = 1;
1121  bool spin = false;
1122 
1123  if( a.rot )
1124  {
1125  spin = a.rot->spin;
1126  sign = a.rot->mirror ? -1 : 1;
1127  txt->SetMirrored( a.rot->mirror );
1128  }
1129 
1130  if( degrees == 90 || degrees == 0 || spin )
1131  {
1132  orient = degrees - m->GetOrientation() / 10;
1133  txt->SetTextAngle( sign * orient * 10 );
1134  }
1135  else if( degrees == 180 )
1136  {
1137  orient = 0 - m->GetOrientation() / 10;
1138  txt->SetTextAngle( sign * orient * 10 );
1139  align = ETEXT::TOP_RIGHT;
1140  }
1141  else if( degrees == 270 )
1142  {
1143  orient = 90 - m->GetOrientation() / 10;
1144  align = ETEXT::TOP_RIGHT;
1145  txt->SetTextAngle( sign * orient * 10 );
1146  }
1147  else
1148  {
1149  orient = 90 - degrees - m->GetOrientation() / 10;
1150  txt->SetTextAngle( sign * orient * 10 );
1151  }
1152 
1153  switch( align )
1154  {
1155  case ETEXT::TOP_RIGHT:
1158  break;
1159 
1160  case ETEXT::BOTTOM_LEFT:
1163  break;
1164 
1165  default:
1166  ;
1167  }
1168  }
1169  else // Part is not smash so use Lib default for NAME/VALUE // the text is per the original package, sans <attribute>
1170  {
1171  double degrees = ( txt->GetTextAngle() + m->GetOrientation() ) / 10;
1172 
1173  // @todo there are a few more cases than these to contend with:
1174  if( (!txt->IsMirrored() && ( abs( degrees ) == 180 || abs( degrees ) == 270 ))
1175  || ( txt->IsMirrored() && ( degrees == 360 ) ) )
1176  {
1177  // ETEXT::TOP_RIGHT:
1180  }
1181  }
1182 }
void SetMirrored(bool isMirrored)
Definition: eda_text.h:178
bool mirror
Definition: eagle_parser.h:471
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes...
Definition: macros.h:53
void SetTextPos(const wxPoint &aPoint)
Definition: eda_text.h:223
double degrees
Definition: eagle_parser.h:473
void SetTextSize(const wxSize &aNewSize)
Definition: eda_text.h:214
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:164
#define abs(a)
Definition: auxiliary.h:84
opt_erot rot
Definition: eagle_parser.h:602
double GetTextAngle() const
Definition: eda_text.h:164
opt_ecoord y
Definition: eagle_parser.h:598
double GetOrientation() const
Definition: class_module.h:180
void SetVertJustify(EDA_TEXT_VJUSTIFY_T aType)
Definition: eda_text.h:194
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:163
opt_string value
Definition: eagle_parser.h:596
Class EATTR parses an Eagle "attribute" XML element.
Definition: eagle_parser.h:593
opt_ecoord x
Definition: eagle_parser.h:597
wxSize kicad_fontz(const ECOORD &d) const
create a font size (fontz) from an eagle font size scalar
void SetHorizJustify(EDA_TEXT_HJUSTIFY_T aType)
Definition: eda_text.h:193
bool IsMirrored() const
Definition: eda_text.h:179
opt_double ratio
Definition: eagle_parser.h:601
void SetTextAngle(double aAngle)
bool spin
Definition: eagle_parser.h:472
const wxSize & GetTextSize() const
Definition: eda_text.h:215
void SetThickness(int aNewThickness)
Function SetThickness sets pen width.
Definition: eda_text.h:148
opt_ecoord size
Definition: eagle_parser.h:599
int sign(T val)
Definition: math_util.h:44
virtual void SetText(const wxString &aText)
Definition: eda_text.h:141
void EAGLE_PLUGIN::packageCircle ( MODULE aModule,
wxXmlNode *  aTree 
) const
private

Definition at line 1566 of file eagle_plugin.cpp.

References UTF8::c_str(), Cmts_User, Dwgs_User, EagleTimeStamp(), Format(), MODULE::GetFPID(), LIB_ID::GetLibItemName(), MODULE::GraphicalItemsList(), IsCopperLayer(), 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().

1567 {
1568  ECIRCLE e( aTree );
1569  PCB_LAYER_ID layer = kicad_layer( e.layer );
1570 
1571  if( IsCopperLayer( layer ) ) // skip copper "package.circle"s
1572  {
1573  wxLogMessage( wxString::Format(
1574  "Unsupported circle on copper layer in package %s.\nMoving to Dwgs.User layer.",
1575  aModule->GetFPID().GetLibItemName().c_str() ) );
1576  layer = Dwgs_User;
1577  }
1578 
1579  EDGE_MODULE* gr = new EDGE_MODULE( aModule, S_CIRCLE );
1580 
1581  aModule->GraphicalItemsList().PushBack( gr );
1582 
1583  gr->SetWidth( e.width.ToPcbUnits() );
1584 
1585  switch( (int) layer )
1586  {
1587  case UNDEFINED_LAYER: layer = Cmts_User; break;
1588  /*
1589  case Eco1_User: layer = F_SilkS; break;
1590  case Eco2_User: layer = B_SilkS; break;
1591  */
1592  default:
1593  break;
1594  }
1595 
1596  gr->SetLayer( layer );
1597  gr->SetTimeStamp( EagleTimeStamp( aTree ) );
1598  gr->SetStart0( wxPoint( kicad_x( e.x ), kicad_y( e.y ) ) );
1599  gr->SetEnd0( wxPoint( kicad_x( e.x + e.radius ), kicad_y( e.y ) ) );
1600  gr->SetDrawCoord();
1601 }
void SetEnd0(const wxPoint &aPoint)
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
PCB_LAYER_ID kicad_layer(int aLayer) const
Convert an Eagle layer to a KiCad layer.
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:164
void SetTimeStamp(time_t aNewTimeStamp)
Definition: base_struct.h:217
void PushBack(T *aNewElement)
Function PushBack puts aNewElement at the end of the list sequence.
Definition: dlist.h:250
const LIB_ID & GetFPID() const
Definition: class_module.h:184
PCB_LAYER_ID
A quick note on layer IDs:
const UTF8 & GetLibItemName() const
Definition: lib_id.h:115
Eagle circle.
Definition: eagle_parser.h:561
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:163
unsigned long EagleTimeStamp(wxXmlNode *aTree)
Make a unique time stamp.
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
const char * c_str() const
Definition: utf8.h:107
void SetDrawCoord()
Set draw coordinates (absolute values ) from relative coordinates.
void SetStart0(const wxPoint &aPoint)
bool IsCopperLayer(LAYER_NUM aLayerId)
Function IsCopperLayer tests whether a layer is a copper layer.
DLIST< BOARD_ITEM > & GraphicalItemsList()
Definition: class_module.h:157
void SetWidth(int aWidth)
void EAGLE_PLUGIN::packageHole ( MODULE aModule,
wxXmlNode *  aTree 
) const
private

Definition at line 1604 of file eagle_plugin.cpp.

References LSET::AllCuMask(), EHOLE::drill, 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(), D_PAD::SetPosition(), D_PAD::SetShape(), D_PAD::SetSize(), ECOORD::ToPcbUnits(), EHOLE::x, and EHOLE::y.

Referenced by makeModule().

1605 {
1606  EHOLE e( aTree );
1607 
1608  // we add a PAD_ATTRIB_HOLE_NOT_PLATED pad to this module.
1609  D_PAD* pad = new D_PAD( aModule );
1610  aModule->PadsList().PushBack( pad );
1611 
1612  pad->SetShape( PAD_SHAPE_CIRCLE );
1614 
1615  // Mechanical purpose only:
1616  // no offset, no net name, no pad name allowed
1617  // pad->SetOffset( wxPoint( 0, 0 ) );
1618  // pad->SetName( wxEmptyString );
1619 
1620  wxPoint padpos( kicad_x( e.x ), kicad_y( e.y ) );
1621 
1622  pad->SetPos0( padpos );
1623  pad->SetPosition( padpos + aModule->GetPosition() );
1624 
1625  wxSize sz( e.drill.ToPcbUnits(), e.drill.ToPcbUnits() );
1626 
1627  pad->SetDrillSize( sz );
1628  pad->SetSize( sz );
1629 
1630  pad->SetLayerSet( LSET::AllCuMask() /* | SOLDERMASK_LAYER_BACK | SOLDERMASK_LAYER_FRONT */ );
1631 }
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:646
like PAD_STANDARD, but not plated mechanical use only, no connection allowed
Definition: pad_shapes.h:65
const wxPoint & GetPosition() const override
Definition: class_module.h:175
void SetPosition(const wxPoint &aPos) override
Definition: class_pad.h:219
void SetDrillSize(const wxSize &aSize)
Definition: class_pad.h:274
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:164
Eagle hole element.
Definition: eagle_parser.h:774
void PushBack(T *aNewElement)
Function PushBack puts aNewElement at the end of the list sequence.
Definition: dlist.h:250
void SetPos0(const wxPoint &aPos)
Definition: class_pad.h:262
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:163
void SetSize(const wxSize &aSize)
Definition: class_pad.h:268
void SetAttribute(PAD_ATTR_T aAttribute)
Definition: class_pad.cpp:392
void SetLayerSet(LSET aLayerMask)
Definition: class_pad.h:394
void SetShape(PAD_SHAPE_T aShape)
Definition: class_pad.h:217
DLIST< D_PAD > & PadsList()
Definition: class_module.h:154
void EAGLE_PLUGIN::packagePad ( MODULE aModule,
wxXmlNode *  aTree 
) const
private

Definition at line 1280 of file eagle_plugin.cpp.

References LSET::AllCuMask(), B_Mask, Clamp(), EROT::degrees, EPAD::diameter, EPAD::drill, F_Mask, FROM_UTF8(), D_PAD::GetDrillSize(), MODULE::GetOrientation(), MODULE::GetPosition(), D_PAD::GetShape(), D_PAD::GetSize(), kicad_x(), kicad_y(), KiROUND(), EPAD::LONG, m_rules, EPAD::name, EPAD::OCTAGON, EPAD::OFFSET, PAD_SHAPE_CIRCLE, PAD_SHAPE_OVAL, PAD_SHAPE_RECT, MODULE::PadsList(), ERULES::psElongationLong, DLIST< T >::PushBack(), ERULES::rlMaxPadTop, ERULES::rlMinPadTop, EPAD::rot, RotatePoint(), EPAD::ROUND, ERULES::rvPadTop, D_PAD::SetDrillSize(), D_PAD::SetLayerSet(), D_PAD::SetName(), D_PAD::SetOrientation(), D_PAD::SetPos0(), D_PAD::SetPosition(), D_PAD::SetShape(), D_PAD::SetSize(), EPAD::shape, EPAD::SQUARE, ECOORD::ToPcbUnits(), EPAD::x, and EPAD::y.

Referenced by makeModule().

1281 {
1282  // this is thru hole technology here, no SMDs
1283  EPAD e( aTree );
1284 
1285  D_PAD* pad = new D_PAD( aModule );
1286  aModule->PadsList().PushBack( pad );
1287 
1288  pad->SetName( FROM_UTF8( e.name.c_str() ) );
1289 
1290  // pad's "Position" is not relative to the module's,
1291  // whereas Pos0 is relative to the module's but is the unrotated coordinate.
1292 
1293  wxPoint padpos( kicad_x( e.x ), kicad_y( e.y ) );
1294 
1295  pad->SetPos0( padpos );
1296 
1297  RotatePoint( &padpos, aModule->GetOrientation() );
1298 
1299  pad->SetPosition( padpos + aModule->GetPosition() );
1300  pad->SetDrillSize( wxSize( e.drill.ToPcbUnits(), e.drill.ToPcbUnits() ) );
1301  pad->SetLayerSet( LSET::AllCuMask().set( B_Mask ).set( F_Mask ) );
1302 
1303  if( e.shape )
1304  {
1305  switch( *e.shape )
1306  {
1307  case EPAD::ROUND:
1308  wxASSERT( pad->GetShape()==PAD_SHAPE_CIRCLE ); // verify set in D_PAD constructor
1309  break;
1310 
1311  case EPAD::OCTAGON:
1312  // no KiCad octagonal pad shape, use PAD_CIRCLE for now.
1313  // pad->SetShape( PAD_OCTAGON );
1314  wxASSERT( pad->GetShape()==PAD_SHAPE_CIRCLE ); // verify set in D_PAD constructor
1315  break;
1316 
1317  case EPAD::LONG:
1318  pad->SetShape( PAD_SHAPE_OVAL );
1319  break;
1320 
1321  case EPAD::SQUARE:
1322  pad->SetShape( PAD_SHAPE_RECT );
1323  break;
1324 
1325  case EPAD::OFFSET:
1326  ; // don't know what to do here.
1327  }
1328  }
1329  else
1330  {
1331  // if shape is not present, our default is circle and that matches their default "round"
1332  }
1333 
1334  if( e.diameter )
1335  {
1336  int diameter = e.diameter->ToPcbUnits();
1337  pad->SetSize( wxSize( diameter, diameter ) );
1338  }
1339  else
1340  {
1341  double drillz = pad->GetDrillSize().x;
1342  double annulus = drillz * m_rules->rvPadTop; // copper annulus, eagle "restring"
1343  annulus = Clamp( m_rules->rlMinPadTop, annulus, m_rules->rlMaxPadTop );
1344  int diameter = KiROUND( drillz + 2 * annulus );
1345  pad->SetSize( wxSize( KiROUND( diameter ), KiROUND( diameter ) ) );
1346  }
1347 
1348  if( pad->GetShape() == PAD_SHAPE_OVAL )
1349  {
1350  // The Eagle "long" pad is wider than it is tall,
1351  // m_elongation is percent elongation
1352  wxSize sz = pad->GetSize();
1353  sz.x = ( sz.x * ( 100 + m_rules->psElongationLong ) ) / 100;
1354  pad->SetSize( sz );
1355  }
1356 
1357  if( e.rot )
1358  {
1359  pad->SetOrientation( e.rot->degrees * 10 );
1360  }
1361 
1362  // @todo: handle stop and thermal
1363 }
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:646
const T & Clamp(const T &lower, const T &value, const T &upper)
Function Clamp limits value within the range lower <= value <= upper.
Definition: macros.h:127
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes...
Definition: macros.h:53
static int KiROUND(double v)
KiROUND rounds a floating point number to an int using "round halfway cases away from zero"...
Definition: common.h:106
ERULES * m_rules
Eagle design rules.
Definition: eagle_plugin.h:134
const wxPoint & GetPosition() const override
Definition: class_module.h:175
double rlMaxPadTop
maximum copper annulus on through hole pads
Definition: eagle_plugin.h:53
void SetPosition(const wxPoint &aPos) override
Definition: class_pad.h:219
void SetDrillSize(const wxSize &aSize)
Definition: class_pad.h:274
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:164
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:317
const wxSize & GetDrillSize() const
Definition: class_pad.h:275
PAD_SHAPE_T GetShape() const
Function GetShape.
Definition: class_pad.h:216
void PushBack(T *aNewElement)
Function PushBack puts aNewElement at the end of the list sequence.
Definition: dlist.h:250
Eagle thru hol pad.
Definition: eagle_parser.h:671
void SetName(const wxString &aName)
Set the pad name (sometimes called pad number, although it can be an array reference like AA12)...
Definition: class_pad.h:182
double GetOrientation() const
Definition: class_module.h:180
void SetPos0(const wxPoint &aPos)
Definition: class_pad.h:262
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:163
const wxSize & GetSize() const
Definition: class_pad.h:269
void SetSize(const wxSize &aSize)
Definition: class_pad.h:268
int psElongationLong
percent over 100%.
Definition: eagle_plugin.h:44
void SetLayerSet(LSET aLayerMask)
Definition: class_pad.h:394
void SetShape(PAD_SHAPE_T aShape)
Definition: class_pad.h:217
void SetOrientation(double aAngle)
Function SetOrientation sets the rotation angle of the pad.
Definition: class_pad.cpp:401
double rvPadTop
top pad size as percent of drill size
Definition: eagle_plugin.h:49
DLIST< D_PAD > & PadsList()
Definition: class_module.h:154
double rlMinPadTop
minimum copper annulus on through hole pads
Definition: eagle_plugin.h:52
void EAGLE_PLUGIN::packagePolygon ( MODULE aModule,
wxXmlNode *  aTree 
) const
private

Definition at line 1518 of file eagle_plugin.cpp.

References UTF8::c_str(), Dwgs_User, EagleTimeStamp(), Format(), MODULE::GetFPID(), LIB_ID::GetLibItemName(), MODULE::GraphicalItemsList(), IsCopperLayer(), kicad_layer(), kicad_x(), kicad_y(), EPOLYGON::layer, 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().

1519 {
1520  EPOLYGON p( aTree );
1521  PCB_LAYER_ID layer = kicad_layer( p.layer );
1522 
1523  if( IsCopperLayer( layer ) ) // skip copper "package.circle"s
1524  {
1525  wxLogMessage( wxString::Format(
1526  "Unsupported polygon on copper layer in package %s.\nMoving to Dwgs.User layer.",
1527  aModule->GetFPID().GetLibItemName().c_str() ) );
1528  layer = Dwgs_User;
1529  }
1530 
1531  EDGE_MODULE* dwg = new EDGE_MODULE( aModule, S_POLYGON );
1532  aModule->GraphicalItemsList().PushBack( dwg );
1533 
1534  dwg->SetWidth( 0 ); // it's filled, no need for boundary width
1535 
1536  dwg->SetLayer( layer );
1537 
1538  dwg->SetTimeStamp( EagleTimeStamp( aTree ) );
1539 
1540  std::vector<wxPoint> pts;
1541  // TODO: I think there's no way to know a priori the number of children in wxXmlNode :()
1542  // pts.reserve( aTree.size() );
1543 
1544  // Get the first vertex and iterate
1545  wxXmlNode* vertex = aTree->GetChildren();
1546 
1547  while( vertex )
1548  {
1549  if( vertex->GetName() != "vertex" ) // skip <xmlattr> node
1550  continue;
1551 
1552  EVERTEX v( vertex );
1553 
1554  pts.push_back( wxPoint( kicad_x( v.x ), kicad_y( v.y ) ) );
1555 
1556  vertex = vertex->GetNext();
1557  }
1558 
1559  dwg->SetPolyPoints( pts );
1560  dwg->SetStart0( *pts.begin() );
1561  dwg->SetEnd0( pts.back() );
1562  dwg->SetDrawCoord();
1563 }
Eagle vertex.
Definition: eagle_parser.h:735
void SetEnd0(const wxPoint &aPoint)
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
PCB_LAYER_ID kicad_layer(int aLayer) const
Convert an Eagle layer to a KiCad layer.
polygon (not yet used for tracks, but could be in microwave apps)
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:164
void SetTimeStamp(time_t aNewTimeStamp)
Definition: base_struct.h:217
void PushBack(T *aNewElement)
Function PushBack puts aNewElement at the end of the list sequence.
Definition: dlist.h:250
const LIB_ID & GetFPID() const
Definition: class_module.h:184
PCB_LAYER_ID
A quick note on layer IDs:
const UTF8 & GetLibItemName() const
Definition: lib_id.h:115
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:163
void SetPolyPoints(const std::vector< wxPoint > &aPoints)
unsigned long EagleTimeStamp(wxXmlNode *aTree)
Make a unique time stamp.
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
const char * c_str() const
Definition: utf8.h:107
void SetDrawCoord()
Set draw coordinates (absolute values ) from relative coordinates.
void SetStart0(const wxPoint &aPoint)
bool IsCopperLayer(LAYER_NUM aLayerId)
Function IsCopperLayer tests whether a layer is a copper layer.
DLIST< BOARD_ITEM > & GraphicalItemsList()
Definition: class_module.h:157
Eagle polygon, without vertices which are parsed as needed.
Definition: eagle_parser.h:745
void SetWidth(int aWidth)
void EAGLE_PLUGIN::packageRectangle ( MODULE aModule,
wxXmlNode *  aTree 
) const
private

Definition at line 1480 of file eagle_plugin.cpp.

References UTF8::c_str(), Dwgs_User, EagleTimeStamp(), Format(), MODULE::GetFPID(), LIB_ID::GetLibItemName(), MODULE::GraphicalItemsList(), IsCopperLayer(), kicad_layer(), kicad_x(), kicad_y(), ERECT::layer, DLIST< T >::PushBack(), 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().

1481 {
1482  ERECT r( aTree );
1483  PCB_LAYER_ID layer = kicad_layer( r.layer );
1484 
1485  if( IsCopperLayer( layer ) ) // skip copper "package.circle"s
1486  {
1487  wxLogMessage( wxString::Format(
1488  "Unsupported rectangle on copper layer in package %s.\nMoving to Dwgs.User layer.",
1489  aModule->GetFPID().GetLibItemName().c_str() ) );
1490  layer = Dwgs_User;
1491  }
1492 
1493  EDGE_MODULE* dwg = new EDGE_MODULE( aModule, S_POLYGON );
1494  aModule->GraphicalItemsList().PushBack( dwg );
1495 
1496  dwg->SetLayer( layer );
1497  dwg->SetWidth( 0 );
1498 
1499  dwg->SetTimeStamp( EagleTimeStamp( aTree ) );
1500 
1501  std::vector<wxPoint> pts;
1502 
1503  wxPoint start( wxPoint( kicad_x( r.x1 ), kicad_y( r.y1 ) ) );
1504  wxPoint end( wxPoint( kicad_x( r.x1 ), kicad_y( r.y2 ) ) );
1505 
1506  pts.push_back( start );
1507  pts.push_back( wxPoint( kicad_x( r.x2 ), kicad_y( r.y1 ) ) );
1508  pts.push_back( wxPoint( kicad_x( r.x2 ), kicad_y( r.y2 ) ) );
1509  pts.push_back( end );
1510 
1511  dwg->SetPolyPoints( pts );
1512 
1513  dwg->SetStart0( start );
1514  dwg->SetEnd0( end );
1515 }
void SetEnd0(const wxPoint &aPoint)
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
PCB_LAYER_ID kicad_layer(int aLayer) const
Convert an Eagle layer to a KiCad layer.
polygon (not yet used for tracks, but could be in microwave apps)
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:164
void SetTimeStamp(time_t aNewTimeStamp)
Definition: base_struct.h:217
void PushBack(T *aNewElement)
Function PushBack puts aNewElement at the end of the list sequence.
Definition: dlist.h:250
const LIB_ID & GetFPID() const
Definition: class_module.h:184
PCB_LAYER_ID
A quick note on layer IDs:
const UTF8 & GetLibItemName() const
Definition: lib_id.h:115
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:163
Eagle XML rectangle in binary.
Definition: eagle_parser.h:574
void SetPolyPoints(const std::vector< wxPoint > &aPoints)
unsigned long EagleTimeStamp(wxXmlNode *aTree)
Make a unique time stamp.
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
const char * c_str() const
Definition: utf8.h:107
void SetStart0(const wxPoint &aPoint)
bool IsCopperLayer(LAYER_NUM aLayerId)
Function IsCopperLayer tests whether a layer is a copper layer.
DLIST< BOARD_ITEM > & GraphicalItemsList()
Definition: class_module.h:157
void SetWidth(int aWidth)
void EAGLE_PLUGIN::packageSMD ( MODULE aModule,
wxXmlNode *  aTree 
) const
private

Definition at line 1634 of file eagle_plugin.cpp.

References B_Cu, B_Mask, B_Paste, EROT::degrees, ESMD::dx, ESMD::dy, F_Cu, F_Mask, F_Paste, FROM_UTF8(), MODULE::GetOrientation(), MODULE::GetPosition(), IsCopperLayer(), kicad_layer(), kicad_x(), kicad_y(), ESMD::layer, ESMD::name, PAD_ATTRIB_SMD, PAD_SHAPE_CIRCLE, PAD_SHAPE_OVAL, PAD_SHAPE_RECT, MODULE::PadsList(), DLIST< T >::PushBack(), ESMD::rot, RotatePoint(), ESMD::roundness, D_PAD::SetAttribute(), BOARD_ITEM::SetLayer(), D_PAD::SetLayerSet(), D_PAD::SetName(), D_PAD::SetOrientation(), D_PAD::SetPos0(), D_PAD::SetPosition(), D_PAD::SetShape(), D_PAD::SetSize(), ECOORD::ToPcbUnits(), ESMD::x, and ESMD::y.

Referenced by makeModule().

1635 {
1636  ESMD e( aTree );
1637  PCB_LAYER_ID layer = kicad_layer( e.layer );
1638 
1639  if( !IsCopperLayer( layer ) )
1640  {
1641  return;
1642  }
1643 
1644  D_PAD* pad = new D_PAD( aModule );
1645  aModule->PadsList().PushBack( pad );
1646 
1647  pad->SetName( FROM_UTF8( e.name.c_str() ) );
1648  pad->SetShape( PAD_SHAPE_RECT );
1649  pad->SetAttribute( PAD_ATTRIB_SMD );
1650 
1651  // pad's "Position" is not relative to the module's,
1652  // whereas Pos0 is relative to the module's but is the unrotated coordinate.
1653 
1654  wxPoint padpos( kicad_x( e.x ), kicad_y( e.y ) );
1655 
1656  pad->SetPos0( padpos );
1657 
1658  RotatePoint( &padpos, aModule->GetOrientation() );
1659 
1660  pad->SetPosition( padpos + aModule->GetPosition() );
1661 
1662  pad->SetSize( wxSize( e.dx.ToPcbUnits(), e.dy.ToPcbUnits() ) );
1663 
1664  pad->SetLayer( layer );
1665 
1666  static const LSET front( 3, F_Cu, F_Paste, F_Mask );
1667  static const LSET back( 3, B_Cu, B_Paste, B_Mask );
1668 
1669  if( layer == F_Cu )
1670  pad->SetLayerSet( front );
1671  else if( layer == B_Cu )
1672  pad->SetLayerSet( back );
1673 
1674  // Optional according to DTD
1675  if( e.roundness ) // set set shape to PAD_SHAPE_RECT above, in case roundness is not present
1676  {
1677  if( *e.roundness >= 75 ) // roundness goes from 0-100% as integer
1678  {
1679  if( e.dy == e.dx )
1680  pad->SetShape( PAD_SHAPE_CIRCLE );
1681  else
1682  pad->SetShape( PAD_SHAPE_OVAL );
1683  }
1684  }
1685 
1686  if( e.rot )
1687  {
1688  pad->SetOrientation( e.rot->degrees * 10 );
1689  }
1690 
1691  // don't know what stop, thermals, and cream should look like now.
1692 }
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes...
Definition: macros.h:53
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
PCB_LAYER_ID kicad_layer(int aLayer) const
Convert an Eagle layer to a KiCad layer.
const wxPoint & GetPosition() const override
Definition: class_module.h:175
Smd pad, appears on the solder paste layer (default)
Definition: pad_shapes.h:61
void SetPosition(const wxPoint &aPos) override
Definition: class_pad.h:219
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:164
Eagle SMD pad.
Definition: eagle_parser.h:698
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:317
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.
void SetName(const wxString &aName)
Set the pad name (sometimes called pad number, although it can be an array reference like AA12)...
Definition: class_pad.h:182
double GetOrientation() const
Definition: class_module.h:180
void SetPos0(const wxPoint &aPos)
Definition: class_pad.h:262
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:163
void SetSize(const wxSize &aSize)
Definition: class_pad.h:268
void SetAttribute(PAD_ATTR_T aAttribute)
Definition: class_pad.cpp:392
void SetLayerSet(LSET aLayerMask)
Definition: class_pad.h:394
void SetShape(PAD_SHAPE_T aShape)
Definition: class_pad.h:217
void SetOrientation(double aAngle)
Function SetOrientation sets the rotation angle of the pad.
Definition: class_pad.cpp:401
bool IsCopperLayer(LAYER_NUM aLayerId)
Function IsCopperLayer tests whether a layer is a copper layer.
DLIST< D_PAD > & PadsList()
Definition: class_module.h:154
void EAGLE_PLUGIN::packageText ( MODULE aModule,
wxXmlNode *  aTree 
) const
private

Definition at line 1366 of file eagle_plugin.cpp.

References ETEXT::align, ETEXT::BOTTOM_CENTER, ETEXT::BOTTOM_LEFT, ETEXT::BOTTOM_RIGHT, UTF8::c_str(), ETEXT::CENTER, ETEXT::CENTER_LEFT, ETEXT::CENTER_RIGHT, Cmts_User, EROT::degrees, Dwgs_User, EagleTimeStamp(), Format(), FROM_UTF8(), MODULE::GetFPID(), LIB_ID::GetLibItemName(), MODULE::GetPosition(), GR_TEXT_HJUSTIFY_LEFT, GR_TEXT_HJUSTIFY_RIGHT, GR_TEXT_VJUSTIFY_BOTTOM, GR_TEXT_VJUSTIFY_TOP, MODULE::GraphicalItemsList(), IsCopperLayer(), 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().

1367 {
1368  ETEXT t( aTree );
1369  PCB_LAYER_ID layer = kicad_layer( t.layer );
1370 
1371  if( IsCopperLayer( layer ) ) // skip copper texts
1372  {
1373  wxLogMessage( wxString::Format(
1374  "Unsupported text on copper layer in package %s.\nMoving to Dwgs.User layer.",
1375  aModule->GetFPID().GetLibItemName().c_str() ) );
1376  layer = Dwgs_User;
1377  }
1378 
1379  if( layer == UNDEFINED_LAYER )
1380  {
1381  layer = Cmts_User;
1382  }
1383 
1384  TEXTE_MODULE* txt;
1385 
1386  if( t.text == ">NAME" || t.text == ">name" )
1387  txt = &aModule->Reference();
1388  else if( t.text == ">VALUE" || t.text == ">value" )
1389  txt = &aModule->Value();
1390  else
1391  {
1392  // FIXME: graphical text items are rotated for some reason.
1393  txt = new TEXTE_MODULE( aModule );
1394  aModule->GraphicalItemsList().PushBack( txt );
1395  }
1396 
1397  txt->SetTimeStamp( EagleTimeStamp( aTree ) );
1398  txt->SetText( FROM_UTF8( t.text.c_str() ) );
1399 
1400  wxPoint pos( kicad_x( t.x ), kicad_y( t.y ) );
1401 
1402  txt->SetTextPos( pos );
1403  txt->SetPos0( pos - aModule->GetPosition() );
1404 
1405  txt->SetLayer( layer );
1406  txt->SetTextSize( kicad_fontz( t.size ) );
1407 
1408  double ratio = t.ratio ? *t.ratio : 8; // DTD says 8 is default
1409 
1410  txt->SetThickness( t.size.ToPcbUnits() * ratio / 100 );
1411 
1412  int align = t.align ? *t.align : ETEXT::BOTTOM_LEFT; // bottom-left is eagle default
1413 
1414  // An eagle package is never rotated, the DTD does not allow it.
1415  // angle -= aModule->GetOrienation();
1416 
1417  if( t.rot )
1418  {
1419  int sign = t.rot->mirror ? -1 : 1;
1420  txt->SetMirrored( t.rot->mirror );
1421 
1422  double degrees = t.rot->degrees;
1423 
1424  if( degrees == 90 || t.rot->spin )
1425  txt->SetTextAngle( sign * degrees * 10 );
1426  else if( degrees == 180 )
1427  align = ETEXT::TOP_RIGHT;
1428  else if( degrees == 270 )
1429  {
1430  align = ETEXT::TOP_RIGHT;
1431  txt->SetTextAngle( sign * 90 * 10 );
1432  }
1433  }
1434 
1435  switch( align )
1436  {
1437  case ETEXT::CENTER:
1438  // this was the default in pcbtxt's constructor
1439  break;
1440 
1441  case ETEXT::CENTER_LEFT:
1443  break;
1444 
1445  case ETEXT::CENTER_RIGHT:
1447  break;
1448 
1449  case ETEXT::TOP_CENTER:
1451  break;
1452 
1453  case ETEXT::TOP_LEFT:
1456  break;
1457 
1458  case ETEXT::TOP_RIGHT:
1461  break;
1462 
1463  case ETEXT::BOTTOM_CENTER:
1465  break;
1466 
1467  case ETEXT::BOTTOM_LEFT:
1470  break;
1471 
1472  case ETEXT::BOTTOM_RIGHT:
1475  break;
1476  }
1477 }
void SetMirrored(bool isMirrored)
Definition: eda_text.h:178
TEXTE_MODULE & Reference()
Definition: class_module.h:483
static wxString FROM_UTF8(const char *cstring)
function FROM_UTF8 converts a UTF8 encoded C string to a wxString for all wxWidgets build modes...
Definition: macros.h:53
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
PCB_LAYER_ID kicad_layer(int aLayer) const
Convert an Eagle layer to a KiCad layer.
const wxPoint & GetPosition() const override
Definition: class_module.h:175
void SetTextPos(const wxPoint &aPoint)
Definition: eda_text.h:223
void SetTextSize(const wxSize &aNewSize)
Definition: eda_text.h:214
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:164
Eagle text element.
Definition: eagle_parser.h:636
void SetTimeStamp(time_t aNewTimeStamp)
Definition: base_struct.h:217
void PushBack(T *aNewElement)
Function PushBack puts aNewElement at the end of the list sequence.
Definition: dlist.h:250
const LIB_ID & GetFPID() const
Definition: class_module.h:184
PCB_LAYER_ID
A quick note on layer IDs:
TEXTE_MODULE & Value()
read/write accessors:
Definition: class_module.h:482
const UTF8 & GetLibItemName() const
Definition: lib_id.h:115
void SetVertJustify(EDA_TEXT_VJUSTIFY_T aType)
Definition: eda_text.h:194
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:163
void SetPos0(const wxPoint &aPos)
unsigned long EagleTimeStamp(wxXmlNode *aTree)
Make a unique time stamp.
wxSize kicad_fontz(const ECOORD &d) const
create a font size (fontz) from an eagle font size scalar
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:193
const char * c_str() const
Definition: utf8.h:107
bool IsCopperLayer(LAYER_NUM aLayerId)
Function IsCopperLayer tests whether a layer is a copper layer.
DLIST< BOARD_ITEM > & GraphicalItemsList()
Definition: class_module.h:157
void SetTextAngle(double aAngle)
void SetThickness(int aNewThickness)
Function SetThickness sets pen width.
Definition: eda_text.h:148
int sign(T val)
Definition: math_util.h:44
virtual void SetText(const wxString &aText)
Definition: eda_text.h:141
void EAGLE_PLUGIN::packageWire ( MODULE aModule,
wxXmlNode *  aTree 
) const
private

Definition at line 1232 of file eagle_plugin.cpp.

References UTF8::c_str(), ConvertArcCenter(), EWIRE::curve, Dwgs_User, Format(), MODULE::GetFPID(), LIB_ID::GetLibItemName(), MODULE::GraphicalItemsList(), IsCopperLayer(), 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::ToMm(), ECOORD::ToPcbUnits(), EWIRE::width, EWIRE::x1, EWIRE::x2, EWIRE::y1, and EWIRE::y2.

Referenced by makeModule().

1233 {
1234  EWIRE w( aTree );
1235  PCB_LAYER_ID layer = kicad_layer( w.layer );
1236 
1237  if( IsCopperLayer( layer ) ) // skip copper "package.circle"s
1238  {
1239  wxLogMessage( wxString::Format(
1240  "Line on copper layer in package %s (%f mm, %f mm) (%f mm, %f mm)."
1241  "\nMoving to Dwgs.User layer",
1242  aModule->GetFPID().GetLibItemName().c_str(), w.x1.ToMm(), w.y1.ToMm(),
1243  w.x2.ToMm(), w.y2.ToMm() ) );
1244  layer = Dwgs_User;
1245  }
1246 
1247  wxPoint start( kicad_x( w.x1 ), kicad_y( w.y1 ) );
1248  wxPoint end( kicad_x( w.x2 ), kicad_y( w.y2 ) );
1249  int width = w.width.ToPcbUnits();
1250 
1251  // FIXME: the cap attribute is ignored because kicad can't create lines
1252  // with flat ends.
1253  EDGE_MODULE* dwg;
1254 
1255  if( !w.curve )
1256  {
1257  dwg = new EDGE_MODULE( aModule, S_SEGMENT );
1258 
1259  dwg->SetStart0( start );
1260  dwg->SetEnd0( end );
1261  }
1262  else
1263  {
1264  dwg = new EDGE_MODULE( aModule, S_ARC );
1265  wxPoint center = ConvertArcCenter( start, end, *w.curve );
1266 
1267  dwg->SetStart0( center );
1268  dwg->SetEnd0( start );
1269  dwg->SetAngle( *w.curve * -10.0 ); // KiCad rotates the other way
1270  }
1271 
1272  dwg->SetLayer( layer );
1273  dwg->SetWidth( width );
1274  dwg->SetDrawCoord();
1275 
1276  aModule->GraphicalItemsList().PushBack( dwg );
1277 }
void SetEnd0(const wxPoint &aPoint)
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
PCB_LAYER_ID kicad_layer(int aLayer) const
Convert an Eagle layer to a KiCad layer.
usual segment : line with rounded ends
int kicad_x(const ECOORD &x) const
Definition: eagle_plugin.h:164
void PushBack(T *aNewElement)
Function PushBack puts aNewElement at the end of the list sequence.
Definition: dlist.h:250
const LIB_ID & GetFPID() const
Definition: class_module.h:184
PCB_LAYER_ID
A quick note on layer IDs:
const UTF8 & GetLibItemName() const
Definition: lib_id.h:115
Arcs (with rounded ends)
int kicad_y(const ECOORD &y) const
Convert an Eagle distance to a KiCad distance.
Definition: eagle_plugin.h:163
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
wxPoint ConvertArcCenter(const wxPoint &aStart, const wxPoint &aEnd, double aAngle)
Convert an Eagle curve end to a KiCad center for S_ARC.
const char * c_str() const
Definition: utf8.h:107
void SetDrawCoord()
Set draw coordinates (absolute values ) from relative coordinates.
void SetStart0(const wxPoint &aPoint)
Eagle wire.
Definition: eagle_parser.h:490
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.
DLIST< BOARD_ITEM > & GraphicalItemsList()
Definition: class_module.h:157
void SetWidth(int aWidth)
const wxString EAGLE_PLUGIN::PluginName ( ) const
overridevirtual

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

Implements PLUGIN.

Definition at line 160 of file eagle_plugin.cpp.

161 {
162  return wxT( "Eagle" );
163 }
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 69 of file plugin.cpp.

Referenced by FP_LIB_TABLE::PrefetchLib().

70 {
71  (void) aLibraryPath;
72  (void) aProperties;
73 }
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 54 of file plugin.cpp.

References not_implemented().

Referenced by IO_MGR::Save(), PCB_EDIT_FRAME::SavePcbCopy(), and PCB_EDIT_FRAME::SavePcbFile().

55 {
56  // not pure virtual so that plugins only have to implement subset of the PLUGIN interface.
57  not_implemented( this, __FUNCTION__ );
58 }
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

Member Data Documentation

BOARD* EAGLE_PLUGIN::m_board
private

which BOARD is being worked on, no ownership here

Definition at line 148 of file eagle_plugin.h.

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

int EAGLE_PLUGIN::m_cu_map[17]
private

map eagle to kicad, cu layers only.

Definition at line 131 of file eagle_plugin.h.

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

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

Eagle layers data stored by the layer number.

Definition at line 132 of file eagle_plugin.h.

Referenced by eagle_layer_name(), and loadLayerDefs().

int EAGLE_PLUGIN::m_hole_count
private

generates unique module names from eagle "hole"s.

Definition at line 138 of file eagle_plugin.h.

Referenced by init(), and loadPlain().

wxString EAGLE_PLUGIN::m_lib_path
private

Definition at line 154 of file eagle_plugin.h.

Referenced by cacheLib(), and loadLibrary().

int EAGLE_PLUGIN::m_min_trace
private

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

Definition at line 150 of file eagle_plugin.h.

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

int EAGLE_PLUGIN::m_min_via
private

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

Definition at line 151 of file eagle_plugin.h.

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

int EAGLE_PLUGIN::m_min_via_hole
private

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

Definition at line 152 of file eagle_plugin.h.

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

wxDateTime EAGLE_PLUGIN::m_mod_time
private

Definition at line 155 of file eagle_plugin.h.

Referenced by cacheLib().

NET_MAP EAGLE_PLUGIN::m_pads_to_nets
private

net list

Definition at line 140 of file eagle_plugin.h.

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

const PROPERTIES* EAGLE_PLUGIN::m_props
private

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

Definition at line 147 of file eagle_plugin.h.

Referenced by centerBoard(), and init().

ERULES* EAGLE_PLUGIN::m_rules
private

Eagle design rules.

Definition at line 134 of file eagle_plugin.h.

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

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 142 of file eagle_plugin.h.

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

XPATH* EAGLE_PLUGIN::m_xpath
private

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

Definition at line 135 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: