KiCad PCB EDA Suite
LEGACY_PLUGIN Class Reference

Class LEGACY_PLUGIN is a PLUGIN derivation which could possibly be put into a DLL/DSO. More...

#include <legacy_plugin.h>

Inheritance diagram for LEGACY_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...
 
const wxString GetFileExtension () const override
 Function GetFileExtension returns the file extension for the 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...
 
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 FootprintLibDelete (const wxString &aLibraryPath, const PROPERTIES *aProperties=NULL) override
 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...
 
long long GetLibraryTimestamp (const wxString &aLibraryPath) const override
 Generate a timestamp representing all the files in the library (including the library directory). More...
 
bool IsFootprintLibWritable (const wxString &aLibraryPath) override
 Function IsFootprintLibWritable returns true iff the library at aLibraryPath is writable. More...
 
 LEGACY_PLUGIN ()
 
 ~LEGACY_PLUGIN ()
 
void SetReader (LINE_READER *aReader)
 
void SetFilePtr (FILE *aFile)
 
void SaveModule3D (const MODULE *aModule) const
 
virtual void Save (const wxString &aFileName, BOARD *aBoard, const PROPERTIES *aProperties=NULL)
 Function Save will write aBoard to a storage file in a format that this PLUGIN implementation knows about, or it can be used to write a portion of aBoard to a special kind of export file. More...
 
virtual void PrefetchLib (const wxString &aLibraryPath, const PROPERTIES *aProperties=NULL)
 Function PrefetchLib If possible, prefetches the specified library (e.g. More...
 
virtual const MODULEGetEnumeratedFootprint (const wxString &aLibraryPath, const wxString &aFootprintName, const PROPERTIES *aProperties=NULL)
 Function GetEnumeratedFootprint a version of FootprintLoad() for use after FootprintEnumerate() for more efficient cache management. More...
 
virtual bool FootprintExists (const wxString &aLibraryPath, const wxString &aFootprintName, const PROPERTIES *aProperties=NULL)
 Function FootprintExists check for the existence of a footprint. 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 void FootprintLibOptions (PROPERTIES *aListToAppendTo) const
 Function FootprintLibOptions appends supported PLUGIN options to aListToAppenTo along with internationalized descriptions. More...
 

Static Public Member Functions

static PCB_LAYER_ID leg_layer2new (int cu_count, LAYER_NUM aLayerNum)
 
static LSET leg_mask2new (int cu_count, unsigned aMask)
 

Protected Member Functions

void init (const PROPERTIES *aProperties)
 initialize PLUGIN like a constructor would, and futz with fresh BOARD if needed. More...
 
int getNetCode (int aNetCode)
 

Converts net code using the mapping table if available, otherwise returns unchanged net code

More...
 
BIU biuParse (const char *aValue, const char **nptrptr=NULL)
 Function biuParse parses an ASCII decimal floating point value and scales it into a BIU according to the current value of diskToBui. More...
 
double degParse (const char *aValue, const char **nptrptr=NULL)
 Function degParse parses an ASCII decimal floating point value which is certainly an angle. More...
 
void checkVersion ()
 
void loadAllSections (bool doAppend)
 
void loadGENERAL ()
 
void loadSETUP ()
 
void loadSHEET ()
 
void load3D (MODULE *aModule)
 
void loadPAD (MODULE *aModule)
 
void loadMODULE_TEXT (TEXTE_MODULE *aText)
 
void loadMODULE_EDGE (MODULE *aModule)
 
void loadPCB_LINE ()
 
void loadNETINFO_ITEM ()
 
void loadPCB_TEXT ()
 
void loadNETCLASS ()
 
void loadMODULE (MODULE *aModule)
 
void loadTrackList (int aStructType)
 Function loadTrackList reads a list of segments (Tracks and Vias, or Segzones) More...
 
void loadZONE_CONTAINER ()
 
void loadDIMENSION ()
 
void loadPCB_TARGET ()
 
void cacheLib (const wxString &aLibraryPath)
 we only cache one footprint library for now, this determines which one. More...
 

Protected Attributes

int m_cu_count
 
wxString m_error
 for throwing exceptions More...
 
BOARDm_board
 which BOARD, no ownership here More...
 
const PROPERTIESm_props
 passed via Save() or Load(), no ownership, may be NULL. More...
 
LINE_READERm_reader
 no ownership here. More...
 
FILE * m_fp
 no ownership here. More...
 
wxString m_field
 reused to stuff MODULE fields. More...
 
int m_loading_format_version
 which BOARD_FORMAT_VERSION am I Load()ing? More...
 
LP_CACHEm_cache
 
bool m_showLegacyZoneWarning
 
NETINFO_MAPPINGm_mapping
 mapping for net codes, so only not empty nets are stored with consecutive integers as net codes More...
 
std::vector< int > m_netCodes
 net codes mapping for boards being loaded More...
 
double biuToDisk
 convert from BIUs to disk engineering units with this scale factor More...
 
double diskToBiu
 convert from disk engineering units to BIUs with this scale factor More...
 

Friends

struct LP_CACHE
 

Detailed Description

Class LEGACY_PLUGIN is a PLUGIN derivation which could possibly be put into a DLL/DSO.

As with any PLUGIN, there is no UI, i.e. windowing calls allowed.

Definition at line 65 of file legacy_plugin.h.

Member Typedef Documentation

◆ BIU

typedef int LEGACY_PLUGIN::BIU

Definition at line 101 of file legacy_plugin.h.

Constructor & Destructor Documentation

◆ LEGACY_PLUGIN()

LEGACY_PLUGIN::LEGACY_PLUGIN ( )

Definition at line 3494 of file legacy_plugin.cpp.

3494  :
3495  m_cu_count( 16 ), // for FootprintLoad()
3496  m_board( 0 ),
3497  m_props( 0 ),
3498  m_reader( 0 ),
3499  m_fp( 0 ),
3500  m_cache( 0 ),
3501  m_mapping( new NETINFO_MAPPING() )
3502 {
3503  init( NULL );
3504 }
FILE * m_fp
no ownership here.
LINE_READER * m_reader
no ownership here.
void init(const PROPERTIES *aProperties)
initialize PLUGIN like a constructor would, and futz with fresh BOARD if needed.
BOARD * m_board
which BOARD, no ownership here
NETINFO_MAPPING * m_mapping
mapping for net codes, so only not empty nets are stored with consecutive integers as net codes
LP_CACHE * m_cache
const PROPERTIES * m_props
passed via Save() or Load(), no ownership, may be NULL.

References init().

◆ ~LEGACY_PLUGIN()

LEGACY_PLUGIN::~LEGACY_PLUGIN ( )

Definition at line 3507 of file legacy_plugin.cpp.

3508 {
3509  delete m_cache;
3510  delete m_mapping;
3511 }
NETINFO_MAPPING * m_mapping
mapping for net codes, so only not empty nets are stored with consecutive integers as net codes
LP_CACHE * m_cache

References m_cache, and m_mapping.

Member Function Documentation

◆ biuParse()

BIU LEGACY_PLUGIN::biuParse ( const char *  aValue,
const char **  nptrptr = NULL 
)
protected

Function biuParse parses an ASCII decimal floating point value and scales it into a BIU according to the current value of diskToBui.

This fuction is the complement of fmtBIU(). One has to know what the other is doing.

Parameters
aValueis the ASCII value in C locale form with possible leading whitespace
nptrptrmay be NULL, but if not, then it tells where to put a pointer to the next unconsumed input text. See "man strtod" for more information.
Returns
BIU - the converted Board Internal Unit.

Definition at line 2985 of file legacy_plugin.cpp.

2986 {
2987  char* nptr;
2988 
2989  errno = 0;
2990 
2991  double fval = strtod( aValue, &nptr );
2992 
2993  if( errno )
2994  {
2995  m_error.Printf( _( "invalid float number in file: \"%s\"\nline: %d, offset: %d" ),
2996  m_reader->GetSource().GetData(),
2997  m_reader->LineNumber(), aValue - m_reader->Line() + 1 );
2998 
3000  }
3001 
3002  if( aValue == nptr )
3003  {
3004  m_error.Printf( _( "missing float number in file: \"%s\"\nline: %d, offset: %d" ),
3005  m_reader->GetSource().GetData(),
3006  m_reader->LineNumber(), aValue - m_reader->Line() + 1 );
3007 
3009  }
3010 
3011  if( nptrptr )
3012  *nptrptr = nptr;
3013 
3014  fval *= diskToBiu;
3015 
3016  // fval is up into the whole number realm here, and should be bounded
3017  // within INT_MIN to INT_MAX since BIU's are nanometers.
3018  return KiROUND( fval );
3019 }
char * Line() const
Function Line returns a pointer to the last line that was read in.
Definition: richio.h:139
virtual const wxString & GetSource() const
Function GetSource returns the name of the source of the lines in an abstract sense.
Definition: richio.h:130
static int KiROUND(double v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: common.h:115
LINE_READER * m_reader
no ownership here.
virtual unsigned LineNumber() const
Function Line Number returns the line number of the last line read from this LINE_READER.
Definition: richio.h:159
#define THROW_IO_ERROR(msg)
double diskToBiu
convert from disk engineering units to BIUs with this scale factor
#define _(s)
wxString m_error
for throwing exceptions

References _, diskToBiu, LINE_READER::GetSource(), KiROUND(), LINE_READER::Line(), LINE_READER::LineNumber(), m_error, m_reader, and THROW_IO_ERROR.

Referenced by loadDIMENSION(), loadGENERAL(), loadMODULE(), loadMODULE_EDGE(), loadMODULE_TEXT(), loadNETCLASS(), loadPAD(), loadPCB_LINE(), loadPCB_TARGET(), loadPCB_TEXT(), loadSETUP(), loadTrackList(), and loadZONE_CONTAINER().

◆ cacheLib()

void LEGACY_PLUGIN::cacheLib ( const wxString &  aLibraryPath)
protected

we only cache one footprint library for now, this determines which one.

Definition at line 3393 of file legacy_plugin.cpp.

3394 {
3395  if( !m_cache || m_cache->m_lib_path != aLibraryPath || m_cache->IsModified() )
3396  {
3397  // a spectacular episode in memory management:
3398  delete m_cache;
3399  m_cache = new LP_CACHE( this, aLibraryPath );
3400  m_cache->Load();
3401  }
3402 }
friend struct LP_CACHE
Definition: legacy_plugin.h:67
bool IsModified()
wxString m_lib_path
LP_CACHE * m_cache

References LP_CACHE::IsModified(), LP_CACHE::Load(), LP_CACHE, m_cache, and LP_CACHE::m_lib_path.

Referenced by FootprintEnumerate(), FootprintLoad(), and IsFootprintLibWritable().

◆ checkVersion()

void LEGACY_PLUGIN::checkVersion ( )
protected

Definition at line 538 of file legacy_plugin.cpp.

539 {
540  // Read first line and TEST if it is a PCB file format header like this:
541  // "PCBNEW-BOARD Version 1 ...."
542 
543  m_reader->ReadLine();
544 
545  char* line = m_reader->Line();
546 
547  if( !TESTLINE( "PCBNEW-BOARD" ) )
548  {
549  THROW_IO_ERROR( "Unknown file type" );
550  }
551 
552  int ver = 1; // if sccanf fails
553  sscanf( line, "PCBNEW-BOARD Version %d", &ver );
554 
555 #if !defined(DEBUG)
556  if( ver > LEGACY_BOARD_FILE_VERSION )
557  {
558  // "File \"%s\" is format version: %d.\nI only support format version <= %d.\nPlease upgrade Pcbnew to load this file."
560  m_reader->GetSource().GetData(), ver, LEGACY_BOARD_FILE_VERSION );
562  }
563 #endif
564 
567 }
void SetFileFormatVersionAtLoad(int aVersion)
Definition: class_board.h:274
char * Line() const
Function Line returns a pointer to the last line that was read in.
Definition: richio.h:139
virtual const wxString & GetSource() const
Function GetSource returns the name of the source of the lines in an abstract sense.
Definition: richio.h:130
int m_loading_format_version
which BOARD_FORMAT_VERSION am I Load()ing?
LINE_READER * m_reader
no ownership here.
#define THROW_IO_ERROR(msg)
BOARD * m_board
which BOARD, no ownership here
virtual char * ReadLine()=0
Function ReadLine reads a line of text into the buffer and increments the line number counter.
#define VERSION_ERROR_FORMAT
wxString m_error
for throwing exceptions
#define TESTLINE(x)
C string compare test for a specific length of characters.

References LINE_READER::GetSource(), LINE_READER::Line(), m_board, m_error, m_loading_format_version, m_reader, LINE_READER::ReadLine(), BOARD::SetFileFormatVersionAtLoad(), TESTLINE, THROW_IO_ERROR, and VERSION_ERROR_FORMAT.

Referenced by Load().

◆ degParse()

double LEGACY_PLUGIN::degParse ( const char *  aValue,
const char **  nptrptr = NULL 
)
protected

Function degParse parses an ASCII decimal floating point value which is certainly an angle.

This is a dedicated function for encapsulating support for the migration from tenths of degrees to degrees in floating point. This function is the complement of fmtDEG(). One has to know what the other is doing.

Parameters
aValueis the ASCII value in C locale form with possible leading whitespace
nptrptrmay be NULL, but if not, then it tells where to put a pointer to the next unconsumed input text. See "man strtod" for more information.
Returns
double - the string converted to a primitive double type

Definition at line 3022 of file legacy_plugin.cpp.

3023 {
3024  char* nptr;
3025 
3026  errno = 0;
3027 
3028  double fval = strtod( aValue, &nptr );
3029 
3030  if( errno )
3031  {
3032  m_error.Printf( _( "invalid float number in file: \"%s\"\nline: %d, offset: %d" ),
3033  m_reader->GetSource().GetData(), m_reader->LineNumber(), aValue - m_reader->Line() + 1 );
3034 
3036  }
3037 
3038  if( aValue == nptr )
3039  {
3040  m_error.Printf( _( "missing float number in file: \"%s\"\nline: %d, offset: %d" ),
3041  m_reader->GetSource().GetData(), m_reader->LineNumber(), aValue - m_reader->Line() + 1 );
3042 
3044  }
3045 
3046  if( nptrptr )
3047  *nptrptr = nptr;
3048 
3049  return fval;
3050 }
char * Line() const
Function Line returns a pointer to the last line that was read in.
Definition: richio.h:139
virtual const wxString & GetSource() const
Function GetSource returns the name of the source of the lines in an abstract sense.
Definition: richio.h:130
LINE_READER * m_reader
no ownership here.
virtual unsigned LineNumber() const
Function Line Number returns the line number of the last line read from this LINE_READER.
Definition: richio.h:159
#define THROW_IO_ERROR(msg)
#define _(s)
wxString m_error
for throwing exceptions

References _, LINE_READER::GetSource(), LINE_READER::Line(), LINE_READER::LineNumber(), m_error, m_reader, and THROW_IO_ERROR.

Referenced by loadDIMENSION(), loadMODULE_EDGE(), loadMODULE_TEXT(), loadPAD(), loadPCB_LINE(), and loadPCB_TEXT().

◆ FootprintDelete()

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

Function FootprintDelete deletes aFootprintName from the library at aLibraryPath.

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

Reimplemented in GITHUB_PLUGIN, PCB_IO, and GPCB_PLUGIN.

Definition at line 109 of file plugin.cpp.

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

References not_implemented().

◆ FootprintEnumerate()

void LEGACY_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 3405 of file legacy_plugin.cpp.

3408 {
3409  LOCALE_IO toggle; // toggles on, then off, the C locale.
3410 
3411  init( aProperties );
3412 
3413  cacheLib( aLibraryPath );
3414 
3415  const MODULE_MAP& mods = m_cache->m_modules;
3416 
3417  for( MODULE_CITER it = mods.begin(); it != mods.end(); ++it )
3418  {
3419  aFootprintNames.Add( FROM_UTF8( it->first.c_str() ) );
3420  }
3421 }
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:62
void cacheLib(const wxString &aLibraryPath)
we only cache one footprint library for now, this determines which one.
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: common.h:175
void init(const PROPERTIES *aProperties)
initialize PLUGIN like a constructor would, and futz with fresh BOARD if needed.
std::map< wxString, MODULE * > MODULE_MAP
Definition: eagle_plugin.h:36
MODULE_MAP::const_iterator MODULE_CITER
MODULE_MAP m_modules
LP_CACHE * m_cache

References cacheLib(), FROM_UTF8(), init(), m_cache, and LP_CACHE::m_modules.

◆ FootprintExists()

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

Function FootprintExists check for the existence of a footprint.

Reimplemented in PCB_IO.

Definition at line 84 of file plugin.cpp.

86 {
87  // default implementation
88  return FootprintLoad( aLibraryPath, aFootprintName, aProperties ) != nullptr;
89 }
virtual MODULE * FootprintLoad(const wxString &aLibraryPath, const wxString &aFootprintName, const PROPERTIES *aProperties=NULL)
Function FootprintLoad loads a footprint having aFootprintName from the aLibraryPath containing a lib...
Definition: plugin.cpp:92

References PLUGIN::FootprintLoad().

◆ FootprintLibCreate()

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

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

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

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

Reimplemented in GITHUB_PLUGIN, and PCB_IO.

Definition at line 117 of file plugin.cpp.

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

References not_implemented().

◆ FootprintLibDelete()

bool LEGACY_PLUGIN::FootprintLibDelete ( const wxString &  aLibraryPath,
const PROPERTIES aProperties = NULL 
)
overridevirtual

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 from PLUGIN.

Definition at line 3452 of file legacy_plugin.cpp.

3453 {
3454  wxFileName fn = aLibraryPath;
3455 
3456  if( !fn.FileExists() )
3457  return false;
3458 
3459  // Some of the more elaborate wxRemoveFile() crap puts up its own wxLog dialog
3460  // we don't want that. we want bare metal portability with no UI here.
3461  if( wxRemove( aLibraryPath ) )
3462  {
3464  _( "library \"%s\" cannot be deleted" ),
3465  aLibraryPath.GetData() ) );
3466  }
3467 
3468  if( m_cache && m_cache->m_lib_path == aLibraryPath )
3469  {
3470  delete m_cache;
3471  m_cache = 0;
3472  }
3473 
3474  return true;
3475 }
#define THROW_IO_ERROR(msg)
#define _(s)
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
wxString m_lib_path
LP_CACHE * m_cache

References _, Format(), m_cache, LP_CACHE::m_lib_path, and THROW_IO_ERROR.

◆ FootprintLibOptions()

void PLUGIN::FootprintLibOptions ( PROPERTIES aListToAppendTo) const
virtualinherited

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 in GITHUB_PLUGIN, and EAGLE_PLUGIN.

Definition at line 140 of file plugin.cpp.

141 {
142  // disable all these in another couple of months, after everyone has seen them:
143 #if 1
144  (*aListToAppendTo)["debug_level"] = UTF8( _(
145  "Enable <b>debug</b> logging for Footprint*() functions in this PLUGIN."
146  ));
147 
148  (*aListToAppendTo)["read_filter_regex"] = UTF8( _(
149  "Regular expression <b>footprint name</b> filter."
150  ));
151 
152  (*aListToAppendTo)["enable_transaction_logging"] = UTF8( _(
153  "Enable transaction logging. The mere presence of this option turns on the "
154  "logging, no need to set a Value."
155  ));
156 
157  (*aListToAppendTo)["username"] = UTF8( _(
158  "User name for <b>login</b> to some special library server."
159  ));
160 
161  (*aListToAppendTo)["password"] = UTF8( _(
162  "Password for <b>login</b> to some special library server."
163  ));
164 #endif
165 
166 #if 1
167  // Suitable for a C++ to python PLUGIN::Footprint*() adapter, move it to the adapter
168  // if and when implemented.
169  (*aListToAppendTo)["python_footprint_plugin"] = UTF8( _(
170  "Enter the python module which implements the PLUGIN::Footprint*() functions."
171  ));
172 #endif
173 }
Class UTF8 is an 8 bit string that is assuredly encoded in UTF8, and supplies special conversion supp...
Definition: utf8.h:73
#define _(s)

References _.

Referenced by EAGLE_PLUGIN::FootprintLibOptions(), and GITHUB_PLUGIN::FootprintLibOptions().

◆ FootprintLoad()

MODULE * LEGACY_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 3424 of file legacy_plugin.cpp.

3426 {
3427  LOCALE_IO toggle; // toggles on, then off, the C locale.
3428 
3429  init( aProperties );
3430 
3431  cacheLib( aLibraryPath );
3432 
3433  const MODULE_MAP& mods = m_cache->m_modules;
3434 
3435  MODULE_CITER it = mods.find( TO_UTF8( aFootprintName ) );
3436 
3437  if( it == mods.end() )
3438  {
3439  /*
3440  THROW_IO_ERROR( wxString::Format( _( "No \"%s\" footprint in library \"%s\"" ),
3441  aFootprintName.GetData(), aLibraryPath.GetData() ) );
3442  */
3443 
3444  return NULL;
3445  }
3446 
3447  // copy constructor to clone the already loaded MODULE
3448  return new MODULE( *it->second );
3449 }
void cacheLib(const wxString &aLibraryPath)
we only cache one footprint library for now, this determines which one.
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: common.h:175
#define TO_UTF8(wxstring)
Macro TO_UTF8 converts a wxString to a UTF8 encoded C string for all wxWidgets build modes.
Definition: macros.h:48
void init(const PROPERTIES *aProperties)
initialize PLUGIN like a constructor would, and futz with fresh BOARD if needed.
std::map< wxString, MODULE * > MODULE_MAP
Definition: eagle_plugin.h:36
MODULE_MAP::const_iterator MODULE_CITER
MODULE_MAP m_modules
LP_CACHE * m_cache

References cacheLib(), init(), m_cache, LP_CACHE::m_modules, and TO_UTF8.

◆ FootprintSave()

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

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

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

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

Reimplemented in GITHUB_PLUGIN, and PCB_IO.

Definition at line 101 of file plugin.cpp.

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

References not_implemented().

◆ GetEnumeratedFootprint()

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

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

Reimplemented in PCB_IO, and GPCB_PLUGIN.

Definition at line 75 of file plugin.cpp.

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

References PLUGIN::FootprintLoad().

◆ GetFileExtension()

const wxString LEGACY_PLUGIN::GetFileExtension ( ) const
inlineoverridevirtual

Function GetFileExtension returns the file extension for the PLUGIN.

Implements PLUGIN.

Definition at line 78 of file legacy_plugin.h.

79  {
80  return wxT( "brd" );
81  }

◆ GetLibraryTimestamp()

long long LEGACY_PLUGIN::GetLibraryTimestamp ( const wxString &  aLibraryPath) const
overridevirtual

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

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

Implements PLUGIN.

Definition at line 3387 of file legacy_plugin.cpp.

3388 {
3389  return LP_CACHE::GetTimestamp( aLibraryPath );
3390 }
static long long GetTimestamp(const wxString &aLibPath)

References LP_CACHE::GetTimestamp().

◆ getNetCode()

int LEGACY_PLUGIN::getNetCode ( int  aNetCode)
inlineprotected

Converts net code using the mapping table if available, otherwise returns unchanged net code

Definition at line 147 of file legacy_plugin.h.

148  {
149  if( (unsigned int) aNetCode < m_netCodes.size() )
150  return m_netCodes[aNetCode];
151 
152  return aNetCode;
153  }
std::vector< int > m_netCodes
net codes mapping for boards being loaded

References m_netCodes.

Referenced by loadPAD(), loadTrackList(), and loadZONE_CONTAINER().

◆ init()

void LEGACY_PLUGIN::init ( const PROPERTIES aProperties)
protected

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

Definition at line 3053 of file legacy_plugin.cpp.

3054 {
3056  m_cu_count = 16;
3057  m_board = NULL;
3058  m_showLegacyZoneWarning = true;
3059  m_props = aProperties;
3060 
3061  // conversion factor for saving RAM BIUs to KICAD legacy file format.
3062  biuToDisk = 1.0/IU_PER_MM; // BIUs are nanometers & file is mm
3063 
3064  // Conversion factor for loading KICAD legacy file format into BIUs in RAM
3065  // Start by assuming the *.brd file is in deci-mils.
3066  // If we see "Units mm" in the $GENERAL section, set diskToBiu to 1000000.0
3067  // then, during the file loading process, to start a conversion from
3068  // mm to nanometers. The deci-mil legacy files have no such "Units" marker
3069  // so we must assume the file is in deci-mils until told otherwise.
3070 
3071  diskToBiu = IU_PER_MILS / 10; // BIUs are nanometers
3072 }
bool m_showLegacyZoneWarning
int m_loading_format_version
which BOARD_FORMAT_VERSION am I Load()ing?
double biuToDisk
convert from BIUs to disk engineering units with this scale factor
double diskToBiu
convert from disk engineering units to BIUs with this scale factor
BOARD * m_board
which BOARD, no ownership here
#define IU_PER_MILS
Definition: plotter.cpp:134
const PROPERTIES * m_props
passed via Save() or Load(), no ownership, may be NULL.

References biuToDisk, diskToBiu, IU_PER_MILS, m_board, m_cu_count, m_loading_format_version, m_props, and m_showLegacyZoneWarning.

Referenced by FootprintEnumerate(), FootprintLoad(), IsFootprintLibWritable(), LEGACY_PLUGIN(), and Load().

◆ IsFootprintLibWritable()

bool LEGACY_PLUGIN::IsFootprintLibWritable ( const wxString &  aLibraryPath)
overridevirtual

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 3478 of file legacy_plugin.cpp.

3479 {
3480 #if 0 // no support for 32 Cu layers in legacy format
3481  return false;
3482 #else
3483  LOCALE_IO toggle;
3484 
3485  init( NULL );
3486 
3487  cacheLib( aLibraryPath );
3488 
3489  return m_cache->m_writable;
3490 #endif
3491 }
void cacheLib(const wxString &aLibraryPath)
we only cache one footprint library for now, this determines which one.
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: common.h:175
void init(const PROPERTIES *aProperties)
initialize PLUGIN like a constructor would, and futz with fresh BOARD if needed.
LP_CACHE * m_cache

References cacheLib(), init(), m_cache, and LP_CACHE::m_writable.

◆ leg_layer2new()

PCB_LAYER_ID LEGACY_PLUGIN::leg_layer2new ( int  cu_count,
LAYER_NUM  aLayerNum 
)
static

Definition at line 284 of file legacy_plugin.cpp.

285 {
286  int newid;
287  unsigned old = aLayerNum;
288 
289  // this is a speed critical function, be careful.
290 
291  if( unsigned( old ) <= unsigned( LAYER_N_FRONT ) )
292  {
293  // In .brd files, the layers are numbered from back to front
294  // (the opposite of the .kicad_pcb files)
295  if( old == LAYER_N_FRONT )
296  newid = F_Cu;
297  else if( old == LAYER_N_BACK )
298  newid = B_Cu;
299  else
300  {
301  newid = cu_count - 1 - old;
302  wxASSERT( newid >= 0 );
303  // This is of course incorrect, but at least it avoid crashing pcbnew:
304  if( newid < 0 )
305  newid = 0;
306  }
307  }
308  else
309  {
310  switch( old )
311  {
312  case ADHESIVE_N_BACK: newid = B_Adhes; break;
313  case ADHESIVE_N_FRONT: newid = F_Adhes; break;
314  case SOLDERPASTE_N_BACK: newid = B_Paste; break;
315  case SOLDERPASTE_N_FRONT: newid = F_Paste; break;
316  case SILKSCREEN_N_BACK: newid = B_SilkS; break;
317  case SILKSCREEN_N_FRONT: newid = F_SilkS; break;
318  case SOLDERMASK_N_BACK: newid = B_Mask; break;
319  case SOLDERMASK_N_FRONT: newid = F_Mask; break;
320  case DRAW_N: newid = Dwgs_User; break;
321  case COMMENT_N: newid = Cmts_User; break;
322  case ECO1_N: newid = Eco1_User; break;
323  case ECO2_N: newid = Eco2_User; break;
324  case EDGE_N: newid = Edge_Cuts; break;
325  default:
326 // wxASSERT( 0 );
327  // Remap all illegal non copper layers to comment layer
328  newid = Cmts_User;
329  }
330  }
331 
332  return PCB_LAYER_ID( newid );
333 }
#define SILKSCREEN_N_BACK
#define LAYER_N_BACK
#define COMMENT_N
#define EDGE_N
#define ADHESIVE_N_FRONT
#define SOLDERMASK_N_FRONT
#define ECO2_N
#define SOLDERMASK_N_BACK
#define ADHESIVE_N_BACK
#define SILKSCREEN_N_FRONT
PCB_LAYER_ID
A quick note on layer IDs:
#define ECO1_N
#define LAYER_N_FRONT
#define SOLDERPASTE_N_FRONT
#define DRAW_N
#define SOLDERPASTE_N_BACK

References ADHESIVE_N_BACK, ADHESIVE_N_FRONT, B_Adhes, B_Cu, B_Mask, B_Paste, B_SilkS, Cmts_User, COMMENT_N, DRAW_N, Dwgs_User, ECO1_N, Eco1_User, ECO2_N, Eco2_User, Edge_Cuts, EDGE_N, F_Adhes, F_Cu, F_Mask, F_Paste, F_SilkS, LAYER_N_BACK, LAYER_N_FRONT, SILKSCREEN_N_BACK, SILKSCREEN_N_FRONT, SOLDERMASK_N_BACK, SOLDERMASK_N_FRONT, SOLDERPASTE_N_BACK, and SOLDERPASTE_N_FRONT.

Referenced by leg_mask2new(), loadDIMENSION(), loadMODULE(), loadMODULE_EDGE(), loadMODULE_TEXT(), loadPCB_LINE(), loadPCB_TARGET(), loadPCB_TEXT(), loadSETUP(), loadTrackList(), and loadZONE_CONTAINER().

◆ leg_mask2new()

LSET LEGACY_PLUGIN::leg_mask2new ( int  cu_count,
unsigned  aMask 
)
static

Definition at line 336 of file legacy_plugin.cpp.

337 {
338  LSET ret;
339 
340  if( ( aMask & ALL_CU_LAYERS ) == ALL_CU_LAYERS )
341  {
342  ret = LSET::AllCuMask();
343 
344  aMask &= ~ALL_CU_LAYERS;
345  }
346 
347  for( int i=0; aMask; ++i, aMask >>= 1 )
348  {
349  if( aMask & 1 )
350  ret.set( leg_layer2new( cu_count, i ) );
351  }
352 
353  return ret;
354 }
static LSET AllCuMask(int aCuLayerCount=MAX_CU_LAYERS)
Function AllCuMask returns a mask holding the requested number of Cu PCB_LAYER_IDs.
Definition: lset.cpp:676
static PCB_LAYER_ID leg_layer2new(int cu_count, LAYER_NUM aLayerNum)
Class LSET is a set of PCB_LAYER_IDs.
#define ALL_CU_LAYERS
size_t i
Definition: json11.cpp:597

References ALL_CU_LAYERS, LSET::AllCuMask(), i, and leg_layer2new().

Referenced by loadGENERAL(), and loadPAD().

◆ Load()

BOARD * LEGACY_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 393 of file legacy_plugin.cpp.

395 {
396  LOCALE_IO toggle; // toggles on, then off, the C locale.
397 
398  init( aProperties );
399 
400  m_board = aAppendToMe ? aAppendToMe : new BOARD();
401 
402  // Give the filename to the board if it's new
403  if( !aAppendToMe )
404  m_board->SetFileName( aFileName );
405 
406  // delete on exception, iff I own m_board, according to aAppendToMe
407  unique_ptr<BOARD> deleter( aAppendToMe ? NULL : m_board );
408 
409  FILE_LINE_READER reader( aFileName );
410 
411  m_reader = &reader; // member function accessibility
412 
413  checkVersion();
414 
415  loadAllSections( bool( aAppendToMe ) );
416 
417  deleter.release();
418  return m_board;
419 }
Instantiate the current locale within a scope in which you are expecting exceptions to be thrown.
Definition: common.h:175
LINE_READER * m_reader
no ownership here.
Class FILE_LINE_READER is a LINE_READER that reads from an open file.
Definition: richio.h:180
void init(const PROPERTIES *aProperties)
initialize PLUGIN like a constructor would, and futz with fresh BOARD if needed.
void SetFileName(const wxString &aFileName)
Definition: class_board.h:223
BOARD * m_board
which BOARD, no ownership here
void loadAllSections(bool doAppend)
Class BOARD holds information pertinent to a Pcbnew printed circuit board.
Definition: class_board.h:161

References checkVersion(), init(), loadAllSections(), m_board, m_reader, and BOARD::SetFileName().

◆ load3D()

void LEGACY_PLUGIN::load3D ( MODULE aModule)
protected

Definition at line 1866 of file legacy_plugin.cpp.

1867 {
1868  MODULE_3D_SETTINGS t3D;
1869 
1870  char* line;
1871  while( ( line = READLINE( m_reader ) ) != NULL )
1872  {
1873  if( TESTLINE( "Na" ) ) // Shape File Name
1874  {
1875  char buf[512];
1876  ReadDelimitedText( buf, line + SZ( "Na" ), sizeof(buf) );
1877  t3D.m_Filename = buf;
1878  }
1879 
1880  else if( TESTLINE( "Sc" ) ) // Scale
1881  {
1882  sscanf( line + SZ( "Sc" ), "%lf %lf %lf\n",
1883  &t3D.m_Scale.x,
1884  &t3D.m_Scale.y,
1885  &t3D.m_Scale.z );
1886  }
1887 
1888  else if( TESTLINE( "Of" ) ) // Offset
1889  {
1890  sscanf( line + SZ( "Of" ), "%lf %lf %lf\n",
1891  &t3D.m_Offset.x,
1892  &t3D.m_Offset.y,
1893  &t3D.m_Offset.z );
1894  }
1895 
1896  else if( TESTLINE( "Ro" ) ) // Rotation
1897  {
1898  sscanf( line + SZ( "Ro" ), "%lf %lf %lf\n",
1899  &t3D.m_Rotation.x,
1900  &t3D.m_Rotation.y,
1901  &t3D.m_Rotation.z );
1902  }
1903 
1904  else if( TESTLINE( "$EndSHAPE3D" ) )
1905  {
1906  aModule->Models().push_back( t3D );
1907  return; // preferred exit
1908  }
1909  }
1910 
1911  THROW_IO_ERROR( "Missing '$EndSHAPE3D'" );
1912 }
#define READLINE(rdr)
VECTOR3D m_Offset
3D model offset (mm)
Definition: class_module.h:101
LINE_READER * m_reader
no ownership here.
#define THROW_IO_ERROR(msg)
wxString m_Filename
The 3D shape filename in 3D library.
Definition: class_module.h:102
std::list< MODULE_3D_SETTINGS > & Models()
Definition: class_module.h:183
VECTOR3D m_Rotation
3D model rotation (degrees)
Definition: class_module.h:100
VECTOR3D m_Scale
3D model scaling factor (dimensionless)
Definition: class_module.h:99
int ReadDelimitedText(wxString *aDest, const char *aSource)
Copy bytes from aSource delimited string segment to aDest wxString.
Definition: string.cpp:147
#define SZ(x)
Get the length of a string constant, at compile time.
#define TESTLINE(x)
C string compare test for a specific length of characters.

References MODULE_3D_SETTINGS::m_Filename, MODULE_3D_SETTINGS::m_Offset, m_reader, MODULE_3D_SETTINGS::m_Rotation, MODULE_3D_SETTINGS::m_Scale, MODULE::Models(), ReadDelimitedText(), READLINE, SZ, TESTLINE, THROW_IO_ERROR, MODULE_3D_SETTINGS::VECTOR3D::x, MODULE_3D_SETTINGS::VECTOR3D::y, and MODULE_3D_SETTINGS::VECTOR3D::z.

Referenced by loadMODULE().

◆ loadAllSections()

void LEGACY_PLUGIN::loadAllSections ( bool  doAppend)
protected

Definition at line 422 of file legacy_plugin.cpp.

423 {
424  // $GENERAL section is first
425 
426  // $SHEETDESCR section is next
427 
428  // $SETUP section is next
429 
430  // Then follows $EQUIPOT and all the rest
431  char* line;
432 
433  while( ( line = READLINE( m_reader ) ) != NULL )
434  {
435  // put the more frequent ones at the top, but realize TRACKs are loaded as a group
436 
437  if( TESTLINE( "$MODULE" ) )
438  {
439  unique_ptr<MODULE> module( new MODULE( m_board ) );
440 
441  LIB_ID fpid;
442  std::string fpName = StrPurge( line + SZ( "$MODULE" ) );
443 
444  // The footprint names in legacy libraries can contain the '/' and ':'
445  // characters which will cause the FPID parser to choke.
446  ReplaceIllegalFileNameChars( &fpName );
447 
448  if( !fpName.empty() )
449  fpid.Parse( fpName, LIB_ID::ID_PCB, true );
450 
451  module->SetFPID( fpid );
452 
453  loadMODULE( module.get() );
454  m_board->Add( module.release(), ADD_APPEND );
455  }
456 
457  else if( TESTLINE( "$DRAWSEGMENT" ) )
458  {
459  loadPCB_LINE();
460  }
461 
462  else if( TESTLINE( "$EQUIPOT" ) )
463  {
465  }
466 
467  else if( TESTLINE( "$TEXTPCB" ) )
468  {
469  loadPCB_TEXT();
470  }
471 
472  else if( TESTLINE( "$TRACK" ) )
473  {
475  }
476 
477  else if( TESTLINE( "$NCLASS" ) )
478  {
479  loadNETCLASS();
480  }
481 
482  else if( TESTLINE( "$CZONE_OUTLINE" ) )
483  {
485  }
486 
487  else if( TESTLINE( "$COTATION" ) )
488  {
489  loadDIMENSION();
490  }
491 
492  else if( TESTLINE( "$PCB_TARGET" ) || TESTLINE( "$MIREPCB" ) )
493  {
494  loadPCB_TARGET();
495  }
496 
497  else if( TESTLINE( "$ZONE" ) )
498  {
499  // No longer supported; discard segment fills
501  }
502 
503  else if( TESTLINE( "$GENERAL" ) )
504  {
505  loadGENERAL();
506  }
507 
508  else if( TESTLINE( "$SHEETDESCR" ) )
509  {
510  loadSHEET();
511  }
512 
513  else if( TESTLINE( "$SETUP" ) )
514  {
515  if( !doAppend )
516  {
517  loadSETUP();
518  }
519  else
520  {
521  while( ( line = READLINE( m_reader ) ) != NULL )
522  {
523  // gobble until $EndSetup
524  if( TESTLINE( "$EndSETUP" ) )
525  break;
526  }
527  }
528  }
529 
530  else if( TESTLINE( "$EndBOARD" ) )
531  return; // preferred exit
532  }
533 
534  THROW_IO_ERROR( "Missing '$EndBOARD'" );
535 }
char * StrPurge(char *text)
Remove leading and training spaces, tabs and end of line chars in text.
Definition: string.cpp:298
the 3d code uses this value
Definition: typeinfo.h:80
void loadMODULE(MODULE *aModule)
bool ReplaceIllegalFileNameChars(std::string *aName, int aReplaceChar)
Checks aName for illegal file name characters.
Definition: string.cpp:668
#define READLINE(rdr)
A logical library item identifier and consists of various portions much like a URI.
Definition: lib_id.h:51
class TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:95
LINE_READER * m_reader
no ownership here.
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_INSERT) override
Adds an item to the container.
#define THROW_IO_ERROR(msg)
BOARD * m_board
which BOARD, no ownership here
void loadZONE_CONTAINER()
int Parse(const UTF8 &aId, LIB_ID_TYPE aType, bool aFix=false)
Parse LIB_ID with the information from aId.
Definition: lib_id.cpp:122
#define SZ(x)
Get the length of a string constant, at compile time.
#define TESTLINE(x)
C string compare test for a specific length of characters.
void loadTrackList(int aStructType)
Function loadTrackList reads a list of segments (Tracks and Vias, or Segzones)

References BOARD::Add(), ADD_APPEND, LIB_ID::ID_PCB, loadDIMENSION(), loadGENERAL(), loadMODULE(), loadNETCLASS(), loadNETINFO_ITEM(), loadPCB_LINE(), loadPCB_TARGET(), loadPCB_TEXT(), loadSETUP(), loadSHEET(), loadTrackList(), loadZONE_CONTAINER(), m_board, m_reader, NOT_USED, LIB_ID::Parse(), PCB_TRACE_T, READLINE, ReplaceIllegalFileNameChars(), StrPurge(), SZ, TESTLINE, and THROW_IO_ERROR.

Referenced by Load().

◆ loadDIMENSION()

void LEGACY_PLUGIN::loadDIMENSION ( )
protected

Definition at line 2749 of file legacy_plugin.cpp.

2750 {
2751  unique_ptr<DIMENSION> dim( new DIMENSION( m_board ) );
2752 
2753  char* line;
2754  char* saveptr;
2755 
2756  while( ( line = READLINE( m_reader ) ) != NULL )
2757  {
2758  const char* data;
2759 
2760  if( TESTLINE( "$endCOTATION" ) )
2761  {
2762  m_board->Add( dim.release(), ADD_APPEND );
2763  return; // preferred exit
2764  }
2765 
2766  else if( TESTLINE( "Va" ) )
2767  {
2768  BIU value = biuParse( line + SZ( "Va" ) );
2769  dim->SetValue( value );
2770  }
2771 
2772  else if( TESTLINE( "Ge" ) )
2773  {
2774  LAYER_NUM layer_num;
2775  unsigned long timestamp;
2776  int shape;
2777  int ilayer;
2778 
2779  sscanf( line + SZ( "Ge" ), " %d %d %lX", &shape, &ilayer, &timestamp );
2780 
2781  if( ilayer < FIRST_NON_COPPER_LAYER )
2782  layer_num = FIRST_NON_COPPER_LAYER;
2783  else if( ilayer > LAST_NON_COPPER_LAYER )
2784  layer_num = LAST_NON_COPPER_LAYER;
2785  else
2786  layer_num = ilayer;
2787 
2788  dim->SetLayer( leg_layer2new( m_cu_count, layer_num ) );
2789  dim->SetTimeStamp( (timestamp_t) timestamp );
2790  dim->SetShape( shape );
2791  }
2792 
2793  else if( TESTLINE( "Te" ) )
2794  {
2795  char buf[2048];
2796 
2797  ReadDelimitedText( buf, line + SZ( "Te" ), sizeof(buf) );
2798  dim->SetText( FROM_UTF8( buf ) );
2799  }
2800 
2801  else if( TESTLINE( "Po" ) )
2802  {
2803  // sscanf( Line + 2, " %d %d %d %d %d %d %d", &m_Text->m_Pos.x, &m_Text->m_Pos.y,
2804  // &m_Text->m_Size.x, &m_Text->m_Size.y, &thickness, &orientation, &normal_display );
2805 
2806  BIU pos_x = biuParse( line + SZ( "Po" ), &data );
2807  BIU pos_y = biuParse( data, &data );
2808  BIU width = biuParse( data, &data );
2809  BIU height = biuParse( data, &data );
2810  BIU thickn = biuParse( data, &data );
2811  double orient = degParse( data, &data );
2812  char* mirror = strtok_r( (char*) data, delims, &saveptr );
2813 
2814  // This sets both DIMENSION's position and internal m_Text's.
2815  // @todo: But why do we even know about internal m_Text?
2816  dim->SetPosition( wxPoint( pos_x, pos_y ) );
2817  dim->SetTextSize( wxSize( width, height ) );
2818 
2819  dim->Text().SetMirrored( mirror && *mirror == '0' );
2820  dim->Text().SetThickness( thickn );
2821  dim->Text().SetTextAngle( orient );
2822  }
2823 
2824  else if( TESTLINE( "Sb" ) )
2825  {
2826  // sscanf( Line + 2, " %d %d %d %d %d %d", &Dummy, &m_crossBarOx, &m_crossBarOy, &m_crossBarFx, &m_crossBarFy, &m_Width );
2827 
2828  int ignore = biuParse( line + SZ( "Sb" ), &data );
2829  BIU crossBarOx = biuParse( data, &data );
2830  BIU crossBarOy = biuParse( data, &data );
2831  BIU crossBarFx = biuParse( data, &data );
2832  BIU crossBarFy = biuParse( data, &data );
2833  BIU width = biuParse( data );
2834 
2835  dim->m_crossBarO.x = crossBarOx;
2836  dim->m_crossBarO.y = crossBarOy;
2837  dim->m_crossBarF.x = crossBarFx;
2838  dim->m_crossBarF.y = crossBarFy;
2839  dim->SetWidth( width );
2840  (void) ignore;
2841  }
2842 
2843  else if( TESTLINE( "Sd" ) )
2844  {
2845  // sscanf( Line + 2, " %d %d %d %d %d %d", &Dummy, &m_featureLineDOx, &m_featureLineDOy, &m_featureLineDFx, &m_featureLineDFy, &Dummy );
2846 
2847  int ignore = intParse( line + SZ( "Sd" ), &data );
2848  BIU featureLineDOx = biuParse( data, &data );
2849  BIU featureLineDOy = biuParse( data, &data );
2850  BIU featureLineDFx = biuParse( data, &data );
2851  BIU featureLineDFy = biuParse( data );
2852 
2853  dim->m_featureLineDO.x = featureLineDOx;
2854  dim->m_featureLineDO.y = featureLineDOy;
2855  dim->m_featureLineDF.x = featureLineDFx;
2856  dim->m_featureLineDF.y = featureLineDFy;
2857  (void) ignore;
2858  }
2859 
2860  else if( TESTLINE( "Sg" ) )
2861  {
2862  // sscanf( Line + 2, " %d %d %d %d %d %d", &Dummy, &m_featureLineGOx, &m_featureLineGOy, &m_featureLineGFx, &m_featureLineGFy, &Dummy );
2863 
2864  int ignore = intParse( line + SZ( "Sg" ), &data );
2865  BIU featureLineGOx = biuParse( data, &data );
2866  BIU featureLineGOy = biuParse( data, &data );
2867  BIU featureLineGFx = biuParse( data, &data );
2868  BIU featureLineGFy = biuParse( data );
2869 
2870  dim->m_featureLineGO.x = featureLineGOx;
2871  dim->m_featureLineGO.y = featureLineGOy;
2872  dim->m_featureLineGF.x = featureLineGFx;
2873  dim->m_featureLineGF.y = featureLineGFy;
2874  (void) ignore;
2875  }
2876 
2877  else if( TESTLINE( "S1" ) )
2878  {
2879  // sscanf( Line + 2, " %d %d %d %d %d %d", &Dummy, &m_arrowD1Ox, &m_arrowD1Oy, &m_arrowD1Fx, &m_arrowD1Fy, &Dummy );
2880 
2881  int ignore = intParse( line + SZ( "S1" ), &data );
2882  biuParse( data, &data ); // skipping excessive data
2883  biuParse( data, &data ); // skipping excessive data
2884  BIU arrowD1Fx = biuParse( data, &data );
2885  BIU arrowD1Fy = biuParse( data );
2886 
2887  dim->m_arrowD1F.x = arrowD1Fx;
2888  dim->m_arrowD1F.y = arrowD1Fy;
2889  (void) ignore;
2890  }
2891 
2892  else if( TESTLINE( "S2" ) )
2893  {
2894  // sscanf( Line + 2, " %d %d %d %d %d %d", &Dummy, &m_arrowD2Ox, &m_arrowD2Oy, &m_arrowD2Fx, &m_arrowD2Fy, &Dummy );
2895 
2896  int ignore = intParse( line + SZ( "S2" ), &data );
2897  biuParse( data, &data ); // skipping excessive data
2898  biuParse( data, &data ); // skipping excessive data
2899  BIU arrowD2Fx = biuParse( data, &data );
2900  BIU arrowD2Fy = biuParse( data, &data );
2901 
2902  dim->m_arrowD2F.x = arrowD2Fx;
2903  dim->m_arrowD2F.y = arrowD2Fy;
2904  (void) ignore;
2905  }
2906 
2907  else if( TESTLINE( "S3" ) )
2908  {
2909  // sscanf( Line + 2, " %d %d %d %d %d %d\n", &Dummy, &m_arrowG1Ox, &m_arrowG1Oy, &m_arrowG1Fx, &m_arrowG1Fy, &Dummy );
2910  int ignore = intParse( line + SZ( "S3" ), &data );
2911  biuParse( data, &data ); // skipping excessive data
2912  biuParse( data, &data ); // skipping excessive data
2913  BIU arrowG1Fx = biuParse( data, &data );
2914  BIU arrowG1Fy = biuParse( data, &data );
2915 
2916  dim->m_arrowG1F.x = arrowG1Fx;
2917  dim->m_arrowG1F.y = arrowG1Fy;
2918  (void) ignore;
2919  }
2920 
2921  else if( TESTLINE( "S4" ) )
2922  {
2923  // sscanf( Line + 2, " %d %d %d %d %d %d", &Dummy, &m_arrowG2Ox, &m_arrowG2Oy, &m_arrowG2Fx, &m_arrowG2Fy, &Dummy );
2924  int ignore = intParse( line + SZ( "S4" ), &data );
2925  biuParse( data, &data ); // skipping excessive data
2926  biuParse( data, &data ); // skipping excessive data
2927  BIU arrowG2Fx = biuParse( data, &data );
2928  BIU arrowG2Fy = biuParse( data, &data );
2929 
2930  dim->m_arrowG2F.x = arrowG2Fx;
2931  dim->m_arrowG2F.y = arrowG2Fy;
2932  (void) ignore;
2933  }
2934  }
2935 
2936  THROW_IO_ERROR( "Missing '$endCOTATION'" );
2937 }
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:62
static int intParse(const char *next, const char **out=NULL)
Function intParse parses an ASCII integer string with possible leading whitespace into an integer and...
static const char delims[]
#define READLINE(rdr)
static PCB_LAYER_ID leg_layer2new(int cu_count, LAYER_NUM aLayerNum)
BIU biuParse(const char *aValue, const char **nptrptr=NULL)
Function biuParse parses an ASCII decimal floating point value and scales it into a BIU according to ...
LINE_READER * m_reader
no ownership here.
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_INSERT) override
Adds an item to the container.
#define THROW_IO_ERROR(msg)
LEGACY_PLUGIN::BIU BIU
BOARD * m_board
which BOARD, no ownership here
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
double degParse(const char *aValue, const char **nptrptr=NULL)
Function degParse parses an ASCII decimal floating point value which is certainly an angle.
#define LAST_NON_COPPER_LAYER
char * strtok_r(char *str, const char *delim, char **nextp)
uint32_t timestamp_t
timestamp_t is our type to represent unique IDs for all kinds of elements; historically simply the ti...
Definition: common.h:50
int ReadDelimitedText(wxString *aDest, const char *aSource)
Copy bytes from aSource delimited string segment to aDest wxString.
Definition: string.cpp:147
#define SZ(x)
Get the length of a string constant, at compile time.
#define TESTLINE(x)
C string compare test for a specific length of characters.
Class DIMENSION.
#define FIRST_NON_COPPER_LAYER

References BOARD::Add(), ADD_APPEND, biuParse(), degParse(), delims, FIRST_NON_COPPER_LAYER, FROM_UTF8(), intParse(), LAST_NON_COPPER_LAYER, leg_layer2new(), m_board, m_cu_count, m_reader, ReadDelimitedText(), READLINE, strtok_r(), SZ, TESTLINE, and THROW_IO_ERROR.

Referenced by loadAllSections().

◆ loadGENERAL()

void LEGACY_PLUGIN::loadGENERAL ( )
protected

Definition at line 570 of file legacy_plugin.cpp.

571 {
572  char* line;
573  char* saveptr;
574  bool saw_LayerCount = false;
575 
576  while( ( line = READLINE( m_reader ) ) != NULL )
577  {
578  const char* data;
579 
580  if( TESTLINE( "Units" ) )
581  {
582  // what are the engineering units of the lengths in the BOARD?
583  data = strtok_r( line + SZ("Units"), delims, &saveptr );
584 
585  if( !strcmp( data, "mm" ) )
586  {
587  diskToBiu = IU_PER_MM;
588  }
589  }
590 
591  else if( TESTLINE( "LayerCount" ) )
592  {
593  int tmp = intParse( line + SZ( "LayerCount" ) );
595 
596  // This has to be set early so that leg_layer2new() works OK, and
597  // that means before parsing "EnabledLayers" and "VisibleLayers".
598  m_cu_count = tmp;
599 
600  saw_LayerCount = true;
601  }
602 
603  else if( TESTLINE( "EnabledLayers" ) )
604  {
605  if( !saw_LayerCount )
606  THROW_IO_ERROR( "Missing '$GENERAL's LayerCount" );
607 
608  LEG_MASK enabledLayers = hexParse( line + SZ( "EnabledLayers" ) );
609 
610  LSET new_mask = leg_mask2new( m_cu_count, enabledLayers );
611 
612  //DBG( printf( "EnabledLayers: %s\n", new_mask.FmtHex().c_str() );)
613 
614  m_board->SetEnabledLayers( new_mask );
615 
616  // layer visibility equals layer usage, unless overridden later via "VisibleLayers"
617  // Must call SetEnabledLayers() before calling SetVisibleLayers().
618  m_board->SetVisibleLayers( new_mask );
619  }
620 
621  else if( TESTLINE( "VisibleLayers" ) )
622  {
623  if( !saw_LayerCount )
624  THROW_IO_ERROR( "Missing '$GENERAL's LayerCount" );
625 
626  LEG_MASK visibleLayers = hexParse( line + SZ( "VisibleLayers" ) );
627 
628  LSET new_mask = leg_mask2new( m_cu_count, visibleLayers );
629 
630  m_board->SetVisibleLayers( new_mask );
631  }
632 
633  else if( TESTLINE( "Ly" ) ) // Old format for Layer count
634  {
635  if( !saw_LayerCount )
636  {
637  LEG_MASK layer_mask = hexParse( line + SZ( "Ly" ) );
638 
639  m_cu_count = layerMaskCountSet( layer_mask & ALL_CU_LAYERS );
640 
642 
643  saw_LayerCount = true;
644  }
645  }
646 
647  else if( TESTLINE( "BoardThickness" ) )
648  {
649  BIU thickn = biuParse( line + SZ( "BoardThickness" ) );
651  }
652 
653  /*
654  else if( TESTLINE( "Links" ) )
655  {
656  // Info only, do nothing, but only for a short while.
657  }
658  */
659 
660  else if( TESTLINE( "NoConn" ) )
661  {
662  // ignore
663  intParse( line + SZ( "NoConn" ) );
664  }
665 
666  else if( TESTLINE( "Di" ) )
667  {
668  biuParse( line + SZ( "Di" ), &data );
669  biuParse( data, &data );
670  biuParse( data, &data );
671  biuParse( data );
672  }
673 
674  /* This is no more usefull, so this info is no more parsed
675  // Read the number of segments of type DRAW, TRACK, ZONE
676  else if( TESTLINE( "Ndraw" ) )
677  {
678  NbDraw = intParse( line + SZ( "Ndraw" ) );
679  }
680 
681  else if( TESTLINE( "Ntrack" ) )
682  {
683  NbTrack = intParse( line + SZ( "Ntrack" ) );
684  }
685 
686  else if( TESTLINE( "Nzone" ) )
687  {
688  NbZone = intParse( line + SZ( "Nzone" ) );
689  }
690 
691  else if( TESTLINE( "Nmodule" ) )
692  {
693  NbMod = intParse( line + SZ( "Nmodule" ) );
694  }*/
695 
696  else if( TESTLINE( "Nnets" ) )
697  {
698  m_netCodes.resize( intParse( line + SZ( "Nnets" ) ) );
699  }
700 
701  else if( TESTLINE( "Nn" ) ) // id "Nnets" for old .brd files
702  {
703  m_netCodes.resize( intParse( line + SZ( "Nn" ) ) );
704  }
705 
706  else if( TESTLINE( "$EndGENERAL" ) )
707  return; // preferred exit
708  }
709 
710  THROW_IO_ERROR( "Missing '$EndGENERAL'" );
711 }
static int intParse(const char *next, const char **out=NULL)
Function intParse parses an ASCII integer string with possible leading whitespace into an integer and...
static const char delims[]
void SetCopperLayerCount(int aCount)
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:540
#define READLINE(rdr)
void SetBoardThickness(int aThickness)
BIU biuParse(const char *aValue, const char **nptrptr=NULL)
Function biuParse parses an ASCII decimal floating point value and scales it into a BIU according to ...
std::vector< int > m_netCodes
net codes mapping for boards being loaded
LINE_READER * m_reader
no ownership here.
Class LSET is a set of PCB_LAYER_IDs.
void SetVisibleLayers(LSET aLayerMask)
Function SetVisibleLayers is a proxy function that calls the correspondent function in m_BoardSetting...
#define ALL_CU_LAYERS
#define THROW_IO_ERROR(msg)
unsigned LEG_MASK
LEGACY_PLUGIN::BIU BIU
double diskToBiu
convert from disk engineering units to BIUs with this scale factor
BOARD * m_board
which BOARD, no ownership here
static LSET leg_mask2new(int cu_count, unsigned aMask)
int layerMaskCountSet(LEG_MASK aMask)
Count the number of set layers in the mask.
static long hexParse(const char *next, const char **out=NULL)
Function hexParse parses an ASCII hex integer string with possible leading whitespace into a long int...
char * strtok_r(char *str, const char *delim, char **nextp)
#define SZ(x)
Get the length of a string constant, at compile time.
#define TESTLINE(x)
C string compare test for a specific length of characters.
void SetEnabledLayers(LSET aLayerMask)
Function SetEnabledLayers is a proxy function that calls the correspondent function in m_BoardSetting...

References ALL_CU_LAYERS, biuParse(), delims, diskToBiu, BOARD::GetDesignSettings(), hexParse(), intParse(), layerMaskCountSet(), leg_mask2new(), m_board, m_cu_count, m_netCodes, m_reader, READLINE, BOARD_DESIGN_SETTINGS::SetBoardThickness(), BOARD::SetCopperLayerCount(), BOARD::SetEnabledLayers(), BOARD::SetVisibleLayers(), strtok_r(), SZ, TESTLINE, and THROW_IO_ERROR.

Referenced by loadAllSections().

◆ loadMODULE()

void LEGACY_PLUGIN::loadMODULE ( MODULE aModule)
protected

Definition at line 1163 of file legacy_plugin.cpp.

1164 {
1165  char* line;
1166  char* saveptr;
1167 
1168  while( ( line = READLINE( m_reader ) ) != NULL )
1169  {
1170  const char* data;
1171 
1172  // most frequently encountered ones at the top
1173 
1174  if( TESTSUBSTR( "D" ) && strchr( "SCAP", line[1] ) ) // read a drawing item, e.g. "DS"
1175  {
1176  loadMODULE_EDGE( aModule );
1177  }
1178 
1179  else if( TESTLINE( "$PAD" ) )
1180  {
1181  loadPAD( aModule );
1182  }
1183 
1184  // Read a footprint text description (ref, value, or drawing)
1185  else if( TESTSUBSTR( "T" ) )
1186  {
1187  // e.g. "T1 6940 -16220 350 300 900 60 M I 20 N "CFCARD"\r\n"
1188 
1189  int tnum = intParse( line + SZ( "T" ) );
1190 
1191  TEXTE_MODULE* textm = 0;
1192 
1193  switch( tnum )
1194  {
1196  textm = &aModule->Reference();
1197  break;
1198 
1200  textm = &aModule->Value();
1201  break;
1202 
1203  // All other fields greater than 1.
1204  default:
1205  textm = new TEXTE_MODULE( aModule );
1206  aModule->Add( textm );
1207  }
1208 
1209  loadMODULE_TEXT( textm );
1210  }
1211 
1212  else if( TESTLINE( "Po" ) )
1213  {
1214  // e.g. "Po 19120 39260 900 0 4E823D06 46EAAFA5 ~~\r\n"
1215 
1216  // sscanf( PtLine, "%d %d %d %d %lX %lX %s", &m_Pos.x, &m_Pos.y, &m_Orient, &m_Layer, &m_LastEdit_Time, &m_TimeStamp, BufCar1 );
1217 
1218  BIU pos_x = biuParse( line + SZ( "Po" ), &data );
1219  BIU pos_y = biuParse( data, &data );
1220  int orient = intParse( data, &data );
1221 
1222  LAYER_NUM layer_num = layerParse( data, &data );
1223  PCB_LAYER_ID layer_id = leg_layer2new( m_cu_count, layer_num );
1224 
1225  long edittime = hexParse( data, &data );
1226  timestamp_t timestamp = hexParse( data, &data );
1227 
1228  data = strtok_r( (char*) data+1, delims, &saveptr );
1229 
1230  // data is now a two character long string
1231  // Note: some old files do not have this field
1232  if( data && data[0] == 'F' )
1233  aModule->SetLocked( true );
1234 
1235  if( data && data[1] == 'P' )
1236  aModule->SetIsPlaced( true );
1237 
1238  aModule->SetPosition( wxPoint( pos_x, pos_y ) );
1239  aModule->SetLayer( layer_id );
1240  aModule->SetOrientation( orient );
1241  aModule->SetTimeStamp( timestamp );
1242  aModule->SetLastEditTime( edittime );
1243  }
1244 
1245  /* footprint name set earlier, immediately after MODULE construction
1246  else if( TESTLINE( "Li" ) ) // Library name of footprint
1247  {
1248  // There can be whitespace in the footprint name on some old libraries.
1249  // Grab everything after "Li" up to end of line:
1250  //aModule->SetFPID( FROM_UTF8( StrPurge( line + SZ( "Li" ) ) ) );
1251  }
1252  */
1253 
1254  else if( TESTLINE( "Sc" ) ) // timestamp
1255  {
1256  timestamp_t timestamp = hexParse( line + SZ( "Sc" ) );
1257  aModule->SetTimeStamp( timestamp );
1258  }
1259 
1260  else if( TESTLINE( "Op" ) ) // (Op)tions for auto placement
1261  {
1262  int itmp1 = hexParse( line + SZ( "Op" ), &data );
1263  int itmp2 = hexParse( data );
1264 
1265  int cntRot180 = itmp2 & 0x0F;
1266  if( cntRot180 > 10 )
1267  cntRot180 = 10;
1268 
1269  aModule->SetPlacementCost180( cntRot180 );
1270 
1271  int cntRot90 = itmp1 & 0x0F;
1272  if( cntRot90 > 10 )
1273  cntRot90 = 0;
1274 
1275  itmp1 = (itmp1 >> 4) & 0x0F;
1276  if( itmp1 > 10 )
1277  itmp1 = 0;
1278 
1279  aModule->SetPlacementCost90( (itmp1 << 4) | cntRot90 );
1280  }
1281 
1282  else if( TESTLINE( "At" ) ) // (At)tributes of module
1283  {
1284  int attrs = MOD_DEFAULT;
1285 
1286  data = line + SZ( "At" );
1287 
1288  if( strstr( data, "SMD" ) )
1289  attrs |= MOD_CMS;
1290 
1291  if( strstr( data, "VIRTUAL" ) )
1292  attrs |= MOD_VIRTUAL;
1293 
1294  aModule->SetAttributes( attrs );
1295  }
1296 
1297  else if( TESTLINE( "AR" ) ) // Alternate Reference
1298  {
1299  // e.g. "AR /47BA2624/45525076"
1300  data = strtok_r( line + SZ( "AR" ), delims, &saveptr );
1301  if( data )
1302  aModule->SetPath( FROM_UTF8( data ) );
1303  }
1304 
1305  else if( TESTLINE( "$SHAPE3D" ) )
1306  {
1307  load3D( aModule );
1308  }
1309 
1310  else if( TESTLINE( "Cd" ) )
1311  {
1312  // e.g. "Cd Double rangee de contacts 2 x 4 pins\r\n"
1313  aModule->SetDescription( FROM_UTF8( StrPurge( line + SZ( "Cd" ) ) ) );
1314  }
1315 
1316  else if( TESTLINE( "Kw" ) ) // Key words
1317  {
1318  aModule->SetKeywords( FROM_UTF8( StrPurge( line + SZ( "Kw" ) ) ) );
1319  }
1320 
1321  else if( TESTLINE( ".SolderPasteRatio" ) )
1322  {
1323  double tmp = atof( line + SZ( ".SolderPasteRatio" ) );
1324  // Due to a bug in dialog editor in Modedit, fixed in BZR version 3565
1325  // this parameter can be broken.
1326  // It should be >= -50% (no solder paste) and <= 0% (full area of the pad)
1327 
1328  if( tmp < -0.50 )
1329  tmp = -0.50;
1330  if( tmp > 0.0 )
1331  tmp = 0.0;
1332  aModule->SetLocalSolderPasteMarginRatio( tmp );
1333  }
1334 
1335  else if( TESTLINE( ".SolderPaste" ) )
1336  {
1337  BIU tmp = biuParse( line + SZ( ".SolderPaste" ) );
1338  aModule->SetLocalSolderPasteMargin( tmp );
1339  }
1340 
1341  else if( TESTLINE( ".SolderMask" ) )
1342  {
1343  BIU tmp = biuParse( line + SZ( ".SolderMask" ) );
1344  aModule->SetLocalSolderMaskMargin( tmp );
1345  }
1346 
1347  else if( TESTLINE( ".LocalClearance" ) )
1348  {
1349  BIU tmp = biuParse( line + SZ( ".LocalClearance" ) );
1350  aModule->SetLocalClearance( tmp );
1351  }
1352 
1353  else if( TESTLINE( ".ZoneConnection" ) )
1354  {
1355  int tmp = intParse( line + SZ( ".ZoneConnection" ) );
1356  aModule->SetZoneConnection( (ZoneConnection)tmp );
1357  }
1358 
1359  else if( TESTLINE( ".ThermalWidth" ) )
1360  {
1361  BIU tmp = biuParse( line + SZ( ".ThermalWidth" ) );
1362  aModule->SetThermalWidth( tmp );
1363  }
1364 
1365  else if( TESTLINE( ".ThermalGap" ) )
1366  {
1367  BIU tmp = biuParse( line + SZ( ".ThermalGap" ) );
1368  aModule->SetThermalGap( tmp );
1369  }
1370 
1371  else if( TESTLINE( "$EndMODULE" ) )
1372  {
1373  aModule->CalculateBoundingBox();
1374 
1375  return; // preferred exit
1376  }
1377  }
1378 
1379  wxString msg = wxString::Format(
1380  _( "Missing '$EndMODULE' for MODULE \"%s\"" ),
1381  GetChars( aModule->GetFPID().GetLibItemName() ) );
1382 
1383  THROW_IO_ERROR( msg );
1384 }
void SetPlacementCost90(int aCost)
Definition: class_module.h:527
const UTF8 & GetLibItemName() const
Definition: lib_id.h:114
TEXTE_MODULE & Reference()
Definition: class_module.h:448
void SetThermalGap(int aGap)
Definition: class_module.h:227
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:62
char * StrPurge(char *text)
Remove leading and training spaces, tabs and end of line chars in text.
Definition: string.cpp:298
void SetLocalClearance(int aClearance)
Definition: class_module.h:213
void loadMODULE_TEXT(TEXTE_MODULE *aText)
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
void SetPlacementCost180(int aCost)
Definition: class_module.h:524
static int intParse(const char *next, const char **out=NULL)
Function intParse parses an ASCII integer string with possible leading whitespace into an integer and...
void CalculateBoundingBox()
Function CalculateBoundingBox calculates the bounding box in board coordinates.
ZoneConnection
How pads are covered by copper in zone.
Definition: zones.h:50
static const char delims[]
Set for modules listed in the automatic insertion list (usually SMD footprints)
Definition: class_module.h:76
static LAYER_NUM layerParse(const char *next, const char **out=NULL)
Function layerParse Like intParse but returns a LAYER_NUM.
void SetZoneConnection(ZoneConnection aType)
Definition: class_module.h:221
const LIB_ID & GetFPID() const
Definition: class_module.h:197
#define READLINE(rdr)
static PCB_LAYER_ID leg_layer2new(int cu_count, LAYER_NUM aLayerNum)
void SetLocalSolderPasteMarginRatio(double aRatio)
Definition: class_module.h:219
void load3D(MODULE *aModule)
BIU biuParse(const char *aValue, const char **nptrptr=NULL)
Function biuParse parses an ASCII decimal floating point value and scales it into a BIU according to ...
PCB_LAYER_ID
A quick note on layer IDs:
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_INSERT) override
LINE_READER * m_reader
no ownership here.
TEXTE_MODULE & Value()
read/write accessors:
Definition: class_module.h:447
void loadMODULE_EDGE(MODULE *aModule)
void SetLastEditTime(timestamp_t aTime)
Definition: class_module.h:318
void SetThermalWidth(int aWidth)
Definition: class_module.h:224
#define THROW_IO_ERROR(msg)
void SetIsPlaced(bool isPlaced)
Definition: class_module.h:291
LEGACY_PLUGIN::BIU BIU
void SetPosition(const wxPoint &aPos) override
#define _(s)
#define TESTSUBSTR(x)
C sub-string compare test for a specific length of characters.
void SetLocalSolderMaskMargin(int aMargin)
Definition: class_module.h:210
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
default
Definition: class_module.h:75
void SetLocalSolderPasteMargin(int aMargin)
Definition: class_module.h:216
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:101
void SetLocked(bool isLocked) override
Function SetLocked sets the MODULE_is_LOCKED bit in the m_ModuleStatus.
Definition: class_module.h:282
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 SetOrientation(double newangle)
Virtual component: when created by copper shapes on board (Like edge card connectors,...
Definition: class_module.h:78
static long hexParse(const char *next, const char **out=NULL)
Function hexParse parses an ASCII hex integer string with possible leading whitespace into a long int...
char * strtok_r(char *str, const char *delim, char **nextp)
void SetKeywords(const wxString &aKeywords)
Definition: class_module.h:204
uint32_t timestamp_t
timestamp_t is our type to represent unique IDs for all kinds of elements; historically simply the ti...
Definition: common.h:50
void loadPAD(MODULE *aModule)
#define SZ(x)
Get the length of a string constant, at compile time.
#define TESTLINE(x)
C string compare test for a specific length of characters.
void SetPath(const wxString &aPath)
Definition: class_module.h:207
void SetAttributes(int aAttributes)
Definition: class_module.h:231
void SetTimeStamp(timestamp_t aNewTimeStamp)
Definition: base_struct.h:215
void SetDescription(const wxString &aDoc)
Definition: class_module.h:201

References _, MODULE::Add(), biuParse(), MODULE::CalculateBoundingBox(), delims, Format(), FROM_UTF8(), GetChars(), MODULE::GetFPID(), LIB_ID::GetLibItemName(), hexParse(), intParse(), layerParse(), leg_layer2new(), load3D(), loadMODULE_EDGE(), loadMODULE_TEXT(), loadPAD(), m_cu_count, m_reader, MOD_CMS, MOD_DEFAULT, MOD_VIRTUAL, READLINE, MODULE::Reference(), MODULE::SetAttributes(), MODULE::SetDescription(), MODULE::SetIsPlaced(), MODULE::SetKeywords(), MODULE::SetLastEditTime(), BOARD_ITEM::SetLayer(), MODULE::SetLocalClearance(), MODULE::SetLocalSolderMaskMargin(), MODULE::SetLocalSolderPasteMargin(), MODULE::SetLocalSolderPasteMarginRatio(), MODULE::SetLocked(), MODULE::SetOrientation(), MODULE::SetPath(), MODULE::SetPlacementCost180(), MODULE::SetPlacementCost90(), MODULE::SetPosition(), MODULE::SetThermalGap(), MODULE::SetThermalWidth(), EDA_ITEM::SetTimeStamp(), MODULE::SetZoneConnection(), StrPurge(), strtok_r(), SZ, TESTLINE, TESTSUBSTR, TEXTE_MODULE::TEXT_is_REFERENCE, TEXTE_MODULE::TEXT_is_VALUE, THROW_IO_ERROR, and MODULE::Value().

Referenced by loadAllSections(), and LP_CACHE::LoadModules().

◆ loadMODULE_EDGE()

void LEGACY_PLUGIN::loadMODULE_EDGE ( MODULE aModule)
protected

Definition at line 1626 of file legacy_plugin.cpp.

1627 {
1628  STROKE_T shape;
1629  char* line = m_reader->Line(); // obtain current (old) line
1630 
1631  switch( line[1] )
1632  {
1633  case 'S': shape = S_SEGMENT; break;
1634  case 'C': shape = S_CIRCLE; break;
1635  case 'A': shape = S_ARC; break;
1636  case 'P': shape = S_POLYGON; break;
1637  default:
1638  m_error.Printf( _( "Unknown EDGE_MODULE type:'%c=0x%02x' on line:%d of footprint:\"%s\"" ),
1639  (unsigned char) line[1],
1640  (unsigned char) line[1],
1641  m_reader->LineNumber(),
1642  GetChars( aModule->GetFPID().GetLibItemName() )
1643  );
1645  }
1646 
1647  unique_ptr<EDGE_MODULE> dwg( new EDGE_MODULE( aModule, shape ) ); // a drawing
1648 
1649  const char* data;
1650 
1651  // common to all cases, and we have to check their values uniformly at end
1652  BIU width = 1;
1654 
1655  switch( shape )
1656  {
1657  case S_ARC:
1658  {
1659  // sscanf( Line + 3, "%d %d %d %d %d %d %d", &m_Start0.x, &m_Start0.y, &m_End0.x, &m_End0.y, &m_Angle, &m_Width, &m_Layer );
1660  BIU start0_x = biuParse( line + SZ( "DA" ), &data );
1661  BIU start0_y = biuParse( data, &data );
1662  BIU end0_x = biuParse( data, &data );
1663  BIU end0_y = biuParse( data, &data );
1664  double angle = degParse( data, &data );
1665 
1666  width = biuParse( data, &data );
1667  layer = layerParse( data );
1668 
1669  dwg->SetAngle( angle );
1670  dwg->m_Start0 = wxPoint( start0_x, start0_y );
1671  dwg->m_End0 = wxPoint( end0_x, end0_y );
1672  }
1673  break;
1674 
1675  case S_SEGMENT:
1676  case S_CIRCLE:
1677  {
1678  // e.g. "DS -7874 -10630 7874 -10630 50 20\r\n"
1679  // sscanf( Line + 3, "%d %d %d %d %d %d", &m_Start0.x, &m_Start0.y, &m_End0.x, &m_End0.y, &m_Width, &m_Layer );
1680 
1681  BIU start0_x = biuParse( line + SZ( "DS" ), &data );
1682  BIU start0_y = biuParse( data, &data );
1683  BIU end0_x = biuParse( data, &data );
1684  BIU end0_y = biuParse( data, &data );
1685 
1686  width = biuParse( data, &data );
1687  layer = layerParse( data );
1688 
1689  dwg->m_Start0 = wxPoint( start0_x, start0_y );
1690  dwg->m_End0 = wxPoint( end0_x, end0_y );
1691  }
1692  break;
1693 
1694  case S_POLYGON:
1695  {
1696  // e.g. "DP %d %d %d %d %d %d %d\n"
1697  // sscanf( Line + 3, "%d %d %d %d %d %d %d", &m_Start0.x, &m_Start0.y, &m_End0.x, &m_End0.y, &pointCount, &m_Width, &m_Layer );
1698 
1699  BIU start0_x = biuParse( line + SZ( "DP" ), &data );
1700  BIU start0_y = biuParse( data, &data );
1701  BIU end0_x = biuParse( data, &data );
1702  BIU end0_y = biuParse( data, &data );
1703  int ptCount = intParse( data, &data );
1704 
1705  width = biuParse( data, &data );
1706  layer = layerParse( data );
1707 
1708  dwg->m_Start0 = wxPoint( start0_x, start0_y );
1709  dwg->m_End0 = wxPoint( end0_x, end0_y );
1710 
1711  std::vector<wxPoint> pts;
1712  pts.reserve( ptCount );
1713 
1714  for( int ii = 0; ii<ptCount; ++ii )
1715  {
1716  if( ( line = READLINE( m_reader ) ) == NULL )
1717  {
1718  THROW_IO_ERROR( "S_POLGON point count mismatch." );
1719  }
1720 
1721  // e.g. "Dl 23 44\n"
1722 
1723  if( !TESTLINE( "Dl" ) )
1724  {
1725  THROW_IO_ERROR( "Missing Dl point def" );
1726  }
1727 
1728  BIU x = biuParse( line + SZ( "Dl" ), &data );
1729  BIU y = biuParse( data );
1730 
1731  pts.push_back( wxPoint( x, y ) );
1732  }
1733 
1734  dwg->SetPolyPoints( pts );
1735  }
1736  break;
1737 
1738  default:
1739  // first switch code above prevents us from getting here.
1740  break;
1741  }
1742 
1743  // Check for a reasonable layer:
1744  // m_Layer must be >= FIRST_NON_COPPER_LAYER, but because microwave footprints
1745  // can use the copper layers m_Layer < FIRST_NON_COPPER_LAYER is allowed.
1746  // @todo: changes use of EDGE_MODULE these footprints and allows only
1747  // m_Layer >= FIRST_NON_COPPER_LAYER
1748  if( layer < FIRST_LAYER || layer > LAST_NON_COPPER_LAYER )
1749  layer = SILKSCREEN_N_FRONT;
1750 
1751  dwg->SetWidth( width );
1752  dwg->SetLayer( leg_layer2new( m_cu_count, layer ) );
1753 
1754  EDGE_MODULE* em = dwg.release();
1755 
1756  aModule->Add( em );
1757 
1758  // this had been done at the MODULE level before, presumably because the
1759  // EDGE_MODULE needs to be already added to a module before this function will work.
1760  em->SetDrawCoord();
1761 }
const UTF8 & GetLibItemName() const
Definition: lib_id.h:114
char * Line() const
Function Line returns a pointer to the last line that was read in.
Definition: richio.h:139
static int intParse(const char *next, const char **out=NULL)
Function intParse parses an ASCII integer string with possible leading whitespace into an integer and...
polygon (not yet used for tracks, but could be in microwave apps)
static LAYER_NUM layerParse(const char *next, const char **out=NULL)
Function layerParse Like intParse but returns a LAYER_NUM.
usual segment : line with rounded ends
const LIB_ID & GetFPID() const
Definition: class_module.h:197
#define READLINE(rdr)
static PCB_LAYER_ID leg_layer2new(int cu_count, LAYER_NUM aLayerNum)
#define SILKSCREEN_N_FRONT
BIU biuParse(const char *aValue, const char **nptrptr=NULL)
Function biuParse parses an ASCII decimal floating point value and scales it into a BIU according to ...
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_INSERT) override
LINE_READER * m_reader
no ownership here.
virtual unsigned LineNumber() const
Function Line Number returns the line number of the last line read from this LINE_READER.
Definition: richio.h:159
Arcs (with rounded ends)
STROKE_T
Enum STROKE_T is the set of shapes for segments (graphic segments and tracks) which are often in the ...
#define THROW_IO_ERROR(msg)
LEGACY_PLUGIN::BIU BIU
#define _(s)
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
double degParse(const char *aValue, const char **nptrptr=NULL)
Function degParse parses an ASCII decimal floating point value which is certainly an angle.
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:101
wxString m_error
for throwing exceptions
#define LAST_NON_COPPER_LAYER
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
void SetDrawCoord()
Set draw coordinates (absolute values ) from relative coordinates.
#define SZ(x)
Get the length of a string constant, at compile time.
#define TESTLINE(x)
C string compare test for a specific length of characters.
#define FIRST_NON_COPPER_LAYER

References _, MODULE::Add(), PNS::angle(), biuParse(), degParse(), FIRST_NON_COPPER_LAYER, GetChars(), MODULE::GetFPID(), LIB_ID::GetLibItemName(), intParse(), LAST_NON_COPPER_LAYER, layerParse(), leg_layer2new(), LINE_READER::Line(), LINE_READER::LineNumber(), m_cu_count, m_error, m_reader, READLINE, S_ARC, S_CIRCLE, S_POLYGON, S_SEGMENT, EDGE_MODULE::SetDrawCoord(), SILKSCREEN_N_FRONT, SZ, TESTLINE, and THROW_IO_ERROR.

Referenced by loadMODULE().

◆ loadMODULE_TEXT()

void LEGACY_PLUGIN::loadMODULE_TEXT ( TEXTE_MODULE aText)
protected

Definition at line 1764 of file legacy_plugin.cpp.

1765 {
1766  const char* data;
1767  const char* txt_end;
1768  const char* line = m_reader->Line(); // current (old) line
1769  char* saveptr;
1770 
1771  // sscanf( line + 1, "%d %d %d %d %d %d %d %s %s %d %s",
1772  // &type, &m_Pos0.x, &m_Pos0.y, &m_Size.y, &m_Size.x,
1773  // &m_Orient, &m_Thickness, BufCar1, BufCar2, &layer, BufCar3 ) >= 10 )
1774 
1775  // e.g. "T1 6940 -16220 350 300 900 60 M I 20 N "CFCARD"\r\n"
1776  // or T1 0 500 600 400 900 80 M V 20 N"74LS245"
1777  // ouch, the last example has no space between N and "74LS245" !
1778  // that is an older version.
1779 
1780  int type = intParse( line+1, &data );
1781  BIU pos0_x = biuParse( data, &data );
1782  BIU pos0_y = biuParse( data, &data );
1783  BIU size0_y = biuParse( data, &data );
1784  BIU size0_x = biuParse( data, &data );
1785  double orient = degParse( data, &data );
1786  BIU thickn = biuParse( data, &data );
1787 
1788  // read the quoted text before the first call to strtok() which introduces
1789  // NULs into the string and chops it into mutliple C strings, something
1790  // ReadDelimitedText() cannot traverse.
1791 
1792  // convert the "quoted, escaped, UTF8, text" to a wxString, find it by skipping
1793  // as far forward as needed until the first double quote.
1794  txt_end = data + ReadDelimitedText( &m_field, data );
1795 
1796  aText->SetText( m_field );
1797 
1798  // after switching to strtok, there's no easy coming back because of the
1799  // embedded nul(s?) placed to the right of the current field.
1800  // (that's the reason why strtok was deprecated...)
1801  char* mirror = strtok_r( (char*) data, delims, &saveptr );
1802  char* hide = strtok_r( NULL, delims, &saveptr );
1803  char* tmp = strtok_r( NULL, delims, &saveptr );
1804 
1805  LAYER_NUM layer_num = tmp ? layerParse( tmp ) : SILKSCREEN_N_FRONT;
1806 
1807  char* italic = strtok_r( NULL, delims, &saveptr );
1808 
1809  char* hjust = strtok_r( (char*) txt_end, delims, &saveptr );
1810  char* vjust = strtok_r( NULL, delims, &saveptr );
1811 
1813  && type != TEXTE_MODULE::TEXT_is_VALUE )
1815 
1816  aText->SetType( static_cast<TEXTE_MODULE::TEXT_TYPE>( type ) );
1817 
1818  aText->SetPos0( wxPoint( pos0_x, pos0_y ) );
1819  aText->SetTextSize( wxSize( size0_x, size0_y ) );
1820 
1821  orient -= ( static_cast<MODULE*>( aText->GetParent() ) )->GetOrientation();
1822 
1823  aText->SetTextAngle( orient );
1824 
1825  // Set a reasonable width:
1826  if( thickn < 1 )
1827  thickn = 1;
1828 
1829  /* this is better left to the dialogs UIs
1830  aText->SetThickness( Clamp_Text_PenSize( thickn, aText->GetSize() ) );
1831  */
1832 
1833  aText->SetThickness( thickn );
1834 
1835  aText->SetMirrored( mirror && *mirror == 'M' );
1836 
1837  aText->SetVisible( !(hide && *hide == 'I') );
1838 
1839  aText->SetItalic( italic && *italic == 'I' );
1840 
1841  if( hjust )
1842  aText->SetHorizJustify( horizJustify( hjust ) );
1843 
1844  if( vjust )
1845  aText->SetVertJustify( vertJustify( vjust ) );
1846 
1847  // A protection against mal formed (or edited by hand) files:
1848  if( layer_num < FIRST_LAYER )
1849  layer_num = FIRST_LAYER;
1850  else if( layer_num > LAST_NON_COPPER_LAYER )
1851  layer_num = LAST_NON_COPPER_LAYER;
1852  else if( layer_num == LAYER_N_BACK )
1853  layer_num = SILKSCREEN_N_BACK;
1854  else if( layer_num == LAYER_N_FRONT )
1855  layer_num = SILKSCREEN_N_FRONT;
1856  else if( layer_num < LAYER_N_FRONT ) // this case is a internal layer
1857  layer_num = SILKSCREEN_N_FRONT;
1858 
1859  aText->SetLayer( leg_layer2new( m_cu_count, layer_num ) );
1860 
1861  // Calculate the actual position.
1862  aText->SetDrawCoord();
1863 }
void SetMirrored(bool isMirrored)
Definition: eda_text.h:172
#define SILKSCREEN_N_BACK
char * Line() const
Function Line returns a pointer to the last line that was read in.
Definition: richio.h:139
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
static int intParse(const char *next, const char **out=NULL)
Function intParse parses an ASCII integer string with possible leading whitespace into an integer and...
#define LAYER_N_BACK
void SetItalic(bool isItalic)
Definition: eda_text.h:163
static const char delims[]
void SetVisible(bool aVisible)
Definition: eda_text.h:169
static LAYER_NUM layerParse(const char *next, const char **out=NULL)
Function layerParse Like intParse but returns a LAYER_NUM.
void SetTextSize(const wxSize &aNewSize)
Definition: eda_text.h:220
static PCB_LAYER_ID leg_layer2new(int cu_count, LAYER_NUM aLayerNum)
wxString m_field
reused to stuff MODULE fields.
#define SILKSCREEN_N_FRONT
BIU biuParse(const char *aValue, const char **nptrptr=NULL)
Function biuParse parses an ASCII decimal floating point value and scales it into a BIU according to ...
LINE_READER * m_reader
no ownership here.
static EDA_TEXT_HJUSTIFY_T horizJustify(const char *horizontal)
virtual void SetText(const wxString &aText)
Definition: eda_text.cpp:112
void SetVertJustify(EDA_TEXT_VJUSTIFY_T aType)
Definition: eda_text.h:188
LEGACY_PLUGIN::BIU BIU
void SetType(TEXT_TYPE aType)
void SetPos0(const wxPoint &aPos)
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
double degParse(const char *aValue, const char **nptrptr=NULL)
Function degParse parses an ASCII decimal floating point value which is certainly an angle.
#define LAYER_N_FRONT
#define FIRST_LAYER
static EDA_TEXT_VJUSTIFY_T vertJustify(const char *vertical)
void SetHorizJustify(EDA_TEXT_HJUSTIFY_T aType)
Definition: eda_text.h:187
#define LAST_NON_COPPER_LAYER
void SetDrawCoord()
Set absolute coordinates.
char * strtok_r(char *str, const char *delim, char **nextp)
void SetTextAngle(double aAngle)
int ReadDelimitedText(wxString *aDest, const char *aSource)
Copy bytes from aSource delimited string segment to aDest wxString.
Definition: string.cpp:147
BOARD_ITEM_CONTAINER * GetParent() const
void SetThickness(int aNewThickness)
Function SetThickness sets pen width.
Definition: eda_text.h:142

References biuParse(), degParse(), delims, FIRST_LAYER, BOARD_ITEM::GetParent(), horizJustify(), intParse(), LAST_NON_COPPER_LAYER, LAYER_N_BACK, LAYER_N_FRONT, layerParse(), leg_layer2new(), LINE_READER::Line(), m_cu_count, m_field, m_reader, ReadDelimitedText(), TEXTE_MODULE::SetDrawCoord(), EDA_TEXT::SetHorizJustify(), EDA_TEXT::SetItalic(), BOARD_ITEM::SetLayer(), EDA_TEXT::SetMirrored(), TEXTE_MODULE::SetPos0(), EDA_TEXT::SetText(), TEXTE_MODULE::SetTextAngle(), EDA_TEXT::SetTextSize(), EDA_TEXT::SetThickness(), TEXTE_MODULE::SetType(), EDA_TEXT::SetVertJustify(), EDA_TEXT::SetVisible(), SILKSCREEN_N_BACK, SILKSCREEN_N_FRONT, strtok_r(), TEXTE_MODULE::TEXT_is_DIVERS, TEXTE_MODULE::TEXT_is_REFERENCE, TEXTE_MODULE::TEXT_is_VALUE, and vertJustify().

Referenced by loadMODULE().

◆ loadNETCLASS()

void LEGACY_PLUGIN::loadNETCLASS ( )
protected

Definition at line 2367 of file legacy_plugin.cpp.

2368 {
2369  char buf[1024];
2370  wxString netname;
2371  char* line;
2372 
2373  // create an empty NETCLASS without a name, but do not add it to the BOARD
2374  // yet since that would bypass duplicate netclass name checking within the BOARD.
2375  // store it temporarily in an unique_ptr until successfully inserted into the BOARD
2376  // just before returning.
2377  NETCLASSPTR nc = std::make_shared<NETCLASS>( wxEmptyString );
2378 
2379  while( ( line = READLINE( m_reader ) ) != NULL )
2380  {
2381  if( TESTLINE( "AddNet" ) ) // most frequent type of line
2382  {
2383  // e.g. "AddNet "V3.3D"\n"
2384  ReadDelimitedText( buf, line + SZ( "AddNet" ), sizeof(buf) );
2385  netname = FROM_UTF8( buf );
2386  nc->Add( netname );
2387  }
2388 
2389  else if( TESTLINE( "Clearance" ) )
2390  {
2391  BIU tmp = biuParse( line + SZ( "Clearance" ) );
2392  nc->SetClearance( tmp );
2393  }
2394 
2395  else if( TESTLINE( "TrackWidth" ) )
2396  {
2397  BIU tmp = biuParse( line + SZ( "TrackWidth" ) );
2398  nc->SetTrackWidth( tmp );
2399  }
2400 
2401  else if( TESTLINE( "ViaDia" ) )
2402  {
2403  BIU tmp = biuParse( line + SZ( "ViaDia" ) );
2404  nc->SetViaDiameter( tmp );
2405  }
2406 
2407  else if( TESTLINE( "ViaDrill" ) )
2408  {
2409  BIU tmp = biuParse( line + SZ( "ViaDrill" ) );
2410  nc->SetViaDrill( tmp );
2411  }
2412 
2413  else if( TESTLINE( "uViaDia" ) )
2414  {
2415  BIU tmp = biuParse( line + SZ( "uViaDia" ) );
2416  nc->SetuViaDiameter( tmp );
2417  }
2418 
2419  else if( TESTLINE( "uViaDrill" ) )
2420  {
2421  BIU tmp = biuParse( line + SZ( "uViaDrill" ) );
2422  nc->SetuViaDrill( tmp );
2423  }
2424 
2425  else if( TESTLINE( "Name" ) )
2426  {
2427  ReadDelimitedText( buf, line + SZ( "Name" ), sizeof(buf) );
2428  nc->SetName( FROM_UTF8( buf ) );
2429  }
2430 
2431  else if( TESTLINE( "Desc" ) )
2432  {
2433  ReadDelimitedText( buf, line + SZ( "Desc" ), sizeof(buf) );
2434  nc->SetDescription( FROM_UTF8( buf ) );
2435  }
2436 
2437  else if( TESTLINE( "$EndNCLASS" ) )
2438  {
2439  if( !m_board->GetDesignSettings().m_NetClasses.Add( nc ) )
2440  {
2441  // Must have been a name conflict, this is a bad board file.
2442  // User may have done a hand edit to the file.
2443 
2444  // unique_ptr will delete nc on this code path
2445 
2446  m_error.Printf( _( "duplicate NETCLASS name \"%s\"" ), nc->GetName().GetData() );
2448  }
2449 
2450  return; // preferred exit
2451  }
2452  }
2453 
2454  THROW_IO_ERROR( "Missing '$EndNCLASS'" );
2455 }
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:62
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:540
#define READLINE(rdr)
BIU biuParse(const char *aValue, const char **nptrptr=NULL)
Function biuParse parses an ASCII decimal floating point value and scales it into a BIU according to ...
LINE_READER * m_reader
no ownership here.
#define THROW_IO_ERROR(msg)
LEGACY_PLUGIN::BIU BIU
#define _(s)
BOARD * m_board
which BOARD, no ownership here
bool Add(const NETCLASSPTR &aNetclass)
Function Add takes aNetclass and puts it into this NETCLASSES container.
Definition: netclass.cpp:99
wxString m_error
for throwing exceptions
int ReadDelimitedText(wxString *aDest, const char *aSource)
Copy bytes from aSource delimited string segment to aDest wxString.
Definition: string.cpp:147
#define SZ(x)
Get the length of a string constant, at compile time.
#define TESTLINE(x)
C string compare test for a specific length of characters.

References _, NETCLASSES::Add(), biuParse(), FROM_UTF8(), BOARD::GetDesignSettings(), m_board, m_error, BOARD_DESIGN_SETTINGS::m_NetClasses, m_reader, ReadDelimitedText(), READLINE, SZ, TESTLINE, and THROW_IO_ERROR.

Referenced by loadAllSections().

◆ loadNETINFO_ITEM()

void LEGACY_PLUGIN::loadNETINFO_ITEM ( )
protected

Definition at line 2028 of file legacy_plugin.cpp.

2029 {
2030  /* a net description is something like
2031  * $EQUIPOT
2032  * Na 5 "/BIT1"
2033  * St ~
2034  * $EndEQUIPOT
2035  */
2036 
2037  char buf[1024];
2038 
2039  NETINFO_ITEM* net = NULL;
2040  char* line;
2041  int netCode = 0;
2042 
2043  while( ( line = READLINE( m_reader ) ) != NULL )
2044  {
2045  const char* data;
2046 
2047  if( TESTLINE( "Na" ) )
2048  {
2049  // e.g. "Na 58 "/cpu.sch/PAD7"\r\n"
2050 
2051  netCode = intParse( line + SZ( "Na" ), &data );
2052 
2053  ReadDelimitedText( buf, data, sizeof(buf) );
2054 
2055  if( net == NULL )
2056  net = new NETINFO_ITEM( m_board, FROM_UTF8( buf ), netCode );
2057  else
2058  {
2059  THROW_IO_ERROR( "Two net definitions in '$EQUIPOT' block" );
2060  }
2061  }
2062 
2063  else if( TESTLINE( "$EndEQUIPOT" ) )
2064  {
2065  // net 0 should be already in list, so store this net
2066  // if it is not the net 0, or if the net 0 does not exists.
2067  if( net && ( net->GetNet() > 0 || m_board->FindNet( 0 ) == NULL ) )
2068  {
2069  m_board->Add( net );
2070 
2071  // Be sure we have room to store the net in m_netCodes
2072  if( (int)m_netCodes.size() <= netCode )
2073  m_netCodes.resize( netCode+1 );
2074 
2075  m_netCodes[netCode] = net->GetNet();
2076  net = NULL;
2077  }
2078  else
2079  {
2080  delete net;
2081  net = NULL; // Avoid double deletion.
2082  }
2083 
2084  return; // preferred exit
2085  }
2086  }
2087 
2088  // If we are here, there is an error.
2089  delete net;
2090  THROW_IO_ERROR( "Missing '$EndEQUIPOT'" );
2091 }
NETINFO_ITEM * FindNet(int aNetcode) const
Function FindNet searches for a net with the given netcode.
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:62
static int intParse(const char *next, const char **out=NULL)
Function intParse parses an ASCII integer string with possible leading whitespace into an integer and...
#define READLINE(rdr)
std::vector< int > m_netCodes
net codes mapping for boards being loaded
LINE_READER * m_reader
no ownership here.
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_INSERT) override
Adds an item to the container.
#define THROW_IO_ERROR(msg)
BOARD * m_board
which BOARD, no ownership here
Class NETINFO_ITEM handles the data for a net.
Definition: netinfo.h:65
int GetNet() const
Function GetNet.
Definition: netinfo.h:225
int ReadDelimitedText(wxString *aDest, const char *aSource)
Copy bytes from aSource delimited string segment to aDest wxString.
Definition: string.cpp:147
#define SZ(x)
Get the length of a string constant, at compile time.
#define TESTLINE(x)
C string compare test for a specific length of characters.

References BOARD::Add(), BOARD::FindNet(), FROM_UTF8(), NETINFO_ITEM::GetNet(), intParse(), m_board, m_netCodes, m_reader, ReadDelimitedText(), READLINE, SZ, TESTLINE, and THROW_IO_ERROR.

Referenced by loadAllSections().

◆ loadPAD()

void LEGACY_PLUGIN::loadPAD ( MODULE aModule)
protected

Definition at line 1387 of file legacy_plugin.cpp.

1388 {
1389  unique_ptr<D_PAD> pad( new D_PAD( aModule ) );
1390  char* line;
1391  char* saveptr;
1392 
1393  while( ( line = READLINE( m_reader ) ) != NULL )
1394  {
1395  const char* data;
1396 
1397  if( TESTLINE( "Sh" ) ) // (Sh)ape and padname
1398  {
1399  // e.g. "Sh "A2" C 520 520 0 0 900"
1400  // or "Sh "1" R 157 1378 0 0 900"
1401 
1402  // mypadname is LATIN1/CRYLIC for BOARD_FORMAT_VERSION 1,
1403  // but for BOARD_FORMAT_VERSION 2, it is UTF8 from disk.
1404  // So we have to go through two code paths. Moving forward
1405  // padnames will be in UTF8 on disk, as are all KiCad strings on disk.
1406  char mypadname[50];
1407 
1408  data = line + SZ( "Sh" ) + 1; // +1 skips trailing whitespace
1409 
1410  data = data + ReadDelimitedText( mypadname, data, sizeof(mypadname) ) + 1; // +1 trailing whitespace
1411 
1412  // sscanf( PtLine, " %s %d %d %d %d %d", BufCar, &m_Size.x, &m_Size.y, &m_DeltaSize.x, &m_DeltaSize.y, &m_Orient );
1413  while( isSpace( *data ) )
1414  ++data;
1415 
1416  unsigned char padchar = (unsigned char) *data++;
1417  int padshape;
1418 
1419  BIU size_x = biuParse( data, &data );
1420  BIU size_y = biuParse( data, &data );
1421  BIU delta_x = biuParse( data, &data );
1422  BIU delta_y = biuParse( data, &data );
1423  double orient = degParse( data );
1424 
1425  switch( padchar )
1426  {
1427  case 'C': padshape = PAD_SHAPE_CIRCLE; break;
1428  case 'R': padshape = PAD_SHAPE_RECT; break;
1429  case 'O': padshape = PAD_SHAPE_OVAL; break;
1430  case 'T': padshape = PAD_SHAPE_TRAPEZOID; break;
1431  default:
1432  m_error.Printf( _( "Unknown padshape '%c=0x%02x' on line: %d of footprint: \"%s\"" ),
1433  padchar,
1434  padchar,
1435  m_reader->LineNumber(),
1436  GetChars( aModule->GetFPID().GetLibItemName() )
1437  );
1439  }
1440 
1441  // go through a wxString to establish a universal character set properly
1442  wxString padname;
1443 
1444  if( m_loading_format_version == 1 )
1445  {
1446  // add 8 bit bytes, file format 1 was KiCad font type byte,
1447  // simply promote those 8 bit bytes up into UNICODE. (subset of LATIN1)
1448  const unsigned char* cp = (unsigned char*) mypadname;
1449  while( *cp )
1450  {
1451  padname += *cp++; // unsigned, ls 8 bits only
1452  }
1453  }
1454  else
1455  {
1456  // version 2, which is UTF8.
1457  padname = FROM_UTF8( mypadname );
1458  }
1459  // chances are both were ASCII, but why take chances?
1460 
1461  pad->SetName( padname );
1462  pad->SetShape( PAD_SHAPE_T( padshape ) );
1463  pad->SetSize( wxSize( size_x, size_y ) );
1464  pad->SetDelta( wxSize( delta_x, delta_y ) );
1465  pad->SetOrientation( orient );
1466  }
1467 
1468  else if( TESTLINE( "Dr" ) ) // (Dr)ill
1469  {
1470  // e.g. "Dr 350 0 0" or "Dr 0 0 0 O 0 0"
1471  // sscanf( PtLine, "%d %d %d %s %d %d", &m_Drill.x, &m_Offset.x, &m_Offset.y, BufCar, &dx, &dy );
1472 
1473  BIU drill_x = biuParse( line + SZ( "Dr" ), &data );
1474  BIU drill_y = drill_x;
1475  BIU offs_x = biuParse( data, &data );
1476  BIU offs_y = biuParse( data, &data );
1477 
1479 
1480  data = strtok_r( (char*) data, delims, &saveptr );
1481  if( data ) // optional shape
1482  {
1483  if( data[0] == 'O' )
1484  {
1485  drShape = PAD_DRILL_SHAPE_OBLONG;
1486 
1487  data = strtok_r( NULL, delims, &saveptr );
1488  drill_x = biuParse( data );
1489 
1490  data = strtok_r( NULL, delims, &saveptr );
1491  drill_y = biuParse( data );
1492  }
1493  }
1494 
1495  pad->SetDrillShape( drShape );
1496  pad->SetOffset( wxPoint( offs_x, offs_y ) );
1497  pad->SetDrillSize( wxSize( drill_x, drill_y ) );
1498  }
1499 
1500  else if( TESTLINE( "At" ) ) // (At)tribute
1501  {
1502  // e.g. "At SMD N 00888000"
1503  // sscanf( PtLine, "%s %s %X", BufLine, BufCar, &m_layerMask );
1504 
1505  PAD_ATTR_T attribute;
1506 
1507  data = strtok_r( line + SZ( "At" ), delims, &saveptr );
1508 
1509  if( !strcmp( data, "SMD" ) )
1510  attribute = PAD_ATTRIB_SMD;
1511  else if( !strcmp( data, "CONN" ) )
1512  attribute = PAD_ATTRIB_CONN;
1513  else if( !strcmp( data, "HOLE" ) )
1514  attribute = PAD_ATTRIB_HOLE_NOT_PLATED;
1515  else
1516  attribute = PAD_ATTRIB_STANDARD;
1517 
1518  strtok_r( NULL, delims, &saveptr ); // skip BufCar
1519  data = strtok_r( NULL, delims, &saveptr );
1520 
1521  LEG_MASK layer_mask = hexParse( data );
1522 
1523  pad->SetLayerSet( leg_mask2new( m_cu_count, layer_mask ) );
1524  pad->SetAttribute( attribute );
1525  }
1526 
1527  else if( TESTLINE( "Ne" ) ) // (Ne)tname
1528  {
1529  // e.g. "Ne 461 "V5.0"
1530 
1531  char buf[1024]; // can be fairly long
1532  int netcode = intParse( line + SZ( "Ne" ), &data );
1533 
1534  // Store the new code mapping
1535  pad->SetNetCode( getNetCode( netcode ) );
1536 
1537  // read Netname
1538  ReadDelimitedText( buf, data, sizeof(buf) );
1539 #ifndef NDEBUG
1540  if( m_board )
1541  assert( m_board->FindNet( getNetCode( netcode ) )->GetNetname() ==
1542  FROM_UTF8( StrPurge( buf ) ) );
1543 #endif /* NDEBUG */
1544  }
1545 
1546  else if( TESTLINE( "Po" ) ) // (Po)sition
1547  {
1548  // e.g. "Po 500 -500"
1549  wxPoint pos;
1550 
1551  pos.x = biuParse( line + SZ( "Po" ), &data );
1552  pos.y = biuParse( data );
1553 
1554  pad->SetPos0( pos );
1555  // pad->SetPosition( pos ); set at function return
1556  }
1557 
1558  else if( TESTLINE( "Le" ) )
1559  {
1560  BIU tmp = biuParse( line + SZ( "Le" ) );
1561  pad->SetPadToDieLength( tmp );
1562  }
1563 
1564  else if( TESTLINE( ".SolderMask" ) )
1565  {
1566  BIU tmp = biuParse( line + SZ( ".SolderMask" ) );
1567  pad->SetLocalSolderMaskMargin( tmp );
1568  }
1569 
1570  else if( TESTLINE( ".SolderPasteRatio" ) )
1571  {
1572  double tmp = atof( line + SZ( ".SolderPasteRatio" ) );
1573  pad->SetLocalSolderPasteMarginRatio( tmp );
1574  }
1575 
1576  else if( TESTLINE( ".SolderPaste" ) )
1577  {
1578  BIU tmp = biuParse( line + SZ( ".SolderPaste" ) );
1579  pad->SetLocalSolderPasteMargin( tmp );
1580  }
1581 
1582  else if( TESTLINE( ".LocalClearance" ) )
1583  {
1584  BIU tmp = biuParse( line + SZ( ".LocalClearance" ) );
1585  pad->SetLocalClearance( tmp );
1586  }
1587 
1588  else if( TESTLINE( ".ZoneConnection" ) )
1589  {
1590  int tmp = intParse( line + SZ( ".ZoneConnection" ) );
1591  pad->SetZoneConnection( (ZoneConnection)tmp );
1592  }
1593 
1594  else if( TESTLINE( ".ThermalWidth" ) )
1595  {
1596  BIU tmp = biuParse( line + SZ( ".ThermalWidth" ) );
1597  pad->SetThermalWidth( tmp );
1598  }
1599 
1600  else if( TESTLINE( ".ThermalGap" ) )
1601  {
1602  BIU tmp = biuParse( line + SZ( ".ThermalGap" ) );
1603  pad->SetThermalGap( tmp );
1604  }
1605 
1606  else if( TESTLINE( "$EndPAD" ) )
1607  {
1608  // pad's "Position" is not relative to the module's,
1609  // whereas Pos0 is relative to the module's but is the unrotated coordinate.
1610 
1611  wxPoint padpos = pad->GetPos0();
1612 
1613  RotatePoint( &padpos, aModule->GetOrientation() );
1614 
1615  pad->SetPosition( padpos + aModule->GetPosition() );
1616 
1617  aModule->Add( pad.release() );
1618  return; // preferred exit
1619  }
1620  }
1621 
1622  THROW_IO_ERROR( "Missing '$EndPAD'" );
1623 }
NETINFO_ITEM * FindNet(int aNetcode) const
Function FindNet searches for a net with the given netcode.
double GetOrientation() const
Definition: class_module.h:193
const UTF8 & GetLibItemName() const
Definition: lib_id.h:114
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:62
char * StrPurge(char *text)
Remove leading and training spaces, tabs and end of line chars in text.
Definition: string.cpp:298
like PAD_STANDARD, but not plated mechanical use only, no connection allowed
Definition: pad_shapes.h:66
PAD_ATTR_T
Enum PAD_ATTR_T is the set of pad shapes, used with D_PAD::{Set,Get}Attribute() The double name is fo...
Definition: pad_shapes.h:59
static int intParse(const char *next, const char **out=NULL)
Function intParse parses an ASCII integer string with possible leading whitespace into an integer and...
ZoneConnection
How pads are covered by copper in zone.
Definition: zones.h:50
Smd pad, appears on the solder paste layer (default)
Definition: pad_shapes.h:62
static const char delims[]
const LIB_ID & GetFPID() const
Definition: class_module.h:197
#define READLINE(rdr)
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:229
PAD_DRILL_SHAPE_T
Enum PAD_DRILL_SHAPE_T is the set of pad drill shapes, used with D_PAD::{Set,Get}DrillShape()
Definition: pad_shapes.h:47
int m_loading_format_version
which BOARD_FORMAT_VERSION am I Load()ing?
PAD_SHAPE_T
Enum PAD_SHAPE_T is the set of pad shapes, used with D_PAD::{Set,Get}Shape()
Definition: pad_shapes.h:31
BIU biuParse(const char *aValue, const char **nptrptr=NULL)
Function biuParse parses an ASCII decimal floating point value and scales it into a BIU according to ...
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_INSERT) override
LINE_READER * m_reader
no ownership here.
virtual unsigned LineNumber() const
Function Line Number returns the line number of the last line read from this LINE_READER.
Definition: richio.h:159
const wxString & GetNetname() const
Function GetNetname.
Definition: netinfo.h:233
#define THROW_IO_ERROR(msg)
unsigned LEG_MASK
LEGACY_PLUGIN::BIU BIU
Like smd, does not appear on the solder paste layer (default) note also has a special attribute in Ge...
Definition: pad_shapes.h:63
#define _(s)
BOARD * m_board
which BOARD, no ownership here
static bool isSpace(int c)
double degParse(const char *aValue, const char **nptrptr=NULL)
Function degParse parses an ASCII decimal floating point value which is certainly an angle.
static LSET leg_mask2new(int cu_count, unsigned aMask)
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:101
wxString m_error
for throwing exceptions
static long hexParse(const char *next, const char **out=NULL)
Function hexParse parses an ASCII hex integer string with possible leading whitespace into a long int...
char * strtok_r(char *str, const char *delim, char **nextp)
int ReadDelimitedText(wxString *aDest, const char *aSource)
Copy bytes from aSource delimited string segment to aDest wxString.
Definition: string.cpp:147
#define SZ(x)
Get the length of a string constant, at compile time.
int getNetCode(int aNetCode)
Converts net code using the mapping table if available, otherwise returns unchanged net code
const wxPoint GetPosition() const override
Definition: class_module.h:188
#define TESTLINE(x)
C string compare test for a specific length of characters.

References _, MODULE::Add(), biuParse(), degParse(), delims, BOARD::FindNet(), FROM_UTF8(), GetChars(), MODULE::GetFPID(), LIB_ID::GetLibItemName(), getNetCode(), NETINFO_ITEM::GetNetname(), MODULE::GetOrientation(), MODULE::GetPosition(), hexParse(), intParse(), isSpace(), leg_mask2new(), LINE_READER::LineNumber(), m_board, m_cu_count, m_error, m_loading_format_version, m_reader, PAD_ATTRIB_CONN, PAD_ATTRIB_HOLE_NOT_PLATED, PAD_ATTRIB_SMD, PAD_ATTRIB_STANDARD, PAD_DRILL_SHAPE_CIRCLE, PAD_DRILL_SHAPE_OBLONG, PAD_SHAPE_CIRCLE, PAD_SHAPE_OVAL, PAD_SHAPE_RECT, PAD_SHAPE_TRAPEZOID, ReadDelimitedText(), READLINE, RotatePoint(), StrPurge(), strtok_r(), SZ, TESTLINE, and THROW_IO_ERROR.

Referenced by loadMODULE().

◆ loadPCB_LINE()

void LEGACY_PLUGIN::loadPCB_LINE ( )
protected

Definition at line 1915 of file legacy_plugin.cpp.

1916 {
1917  /* example:
1918  $DRAWSEGMENT
1919  Po 0 57500 -1000 57500 0 150
1920  De 24 0 900 0 0
1921  $EndDRAWSEGMENT
1922  */
1923 
1924  unique_ptr<DRAWSEGMENT> dseg( new DRAWSEGMENT( m_board ) );
1925 
1926  char* line;
1927  char* saveptr;
1928 
1929  while( ( line = READLINE( m_reader ) ) != NULL )
1930  {
1931  const char* data;
1932 
1933  if( TESTLINE( "Po" ) )
1934  {
1935  // sscanf( line + 2, " %d %d %d %d %d %d", &m_Shape, &m_Start.x, &m_Start.y, &m_End.x, &m_End.y, &m_Width );
1936  int shape = intParse( line + SZ( "Po" ), &data );
1937  BIU start_x = biuParse( data, &data );
1938  BIU start_y = biuParse( data, &data );
1939  BIU end_x = biuParse( data, &data );
1940  BIU end_y = biuParse( data, &data );
1941  BIU width = biuParse( data );
1942 
1943  if( width < 0 )
1944  width = 0;
1945 
1946  dseg->SetShape( STROKE_T( shape ) );
1947  dseg->SetWidth( width );
1948  dseg->SetStart( wxPoint( start_x, start_y ) );
1949  dseg->SetEnd( wxPoint( end_x, end_y ) );
1950  }
1951 
1952  else if( TESTLINE( "De" ) )
1953  {
1954  BIU x = 0;
1955  BIU y;
1956 
1957  data = strtok_r( line + SZ( "De" ), delims, &saveptr );
1958  for( int i = 0; data; ++i, data = strtok_r( NULL, delims, &saveptr ) )
1959  {
1960  switch( i )
1961  {
1962  case 0:
1963  LAYER_NUM layer;
1964  layer = layerParse( data );
1965 
1966  if( layer < FIRST_NON_COPPER_LAYER )
1967  layer = FIRST_NON_COPPER_LAYER;
1968 
1969  else if( layer > LAST_NON_COPPER_LAYER )
1970  layer = LAST_NON_COPPER_LAYER;
1971 
1972  dseg->SetLayer( leg_layer2new( m_cu_count, layer ) );
1973  break;
1974  case 1:
1975  int mtype;
1976  mtype = intParse( data );
1977  dseg->SetType( mtype ); // m_Type
1978  break;
1979  case 2:
1980  double angle;
1981  angle = degParse( data );
1982  dseg->SetAngle( angle ); // m_Angle
1983  break;
1984  case 3:
1985  timestamp_t timestamp;
1986  timestamp = hexParse( data );
1987  dseg->SetTimeStamp( timestamp );
1988  break;
1989  case 4:
1990  STATUS_FLAGS state;
1991  state = static_cast<STATUS_FLAGS>( hexParse( data ) );
1992  dseg->SetState( state, true );
1993  break;
1994 
1995  // Bezier Control Points
1996  case 5:
1997  x = biuParse( data );
1998  break;
1999  case 6:
2000  y = biuParse( data );
2001  dseg->SetBezControl1( wxPoint( x, y ) );
2002  break;
2003 
2004  case 7:
2005  x = biuParse( data );
2006  break;
2007  case 8:
2008  y = biuParse( data );
2009  dseg->SetBezControl2( wxPoint( x, y ) );
2010  break;
2011 
2012  default:
2013  break;
2014  }
2015  }
2016  }
2017 
2018  else if( TESTLINE( "$EndDRAWSEGMENT" ) )
2019  {
2020  m_board->Add( dseg.release(), ADD_APPEND );
2021  return; // preferred exit
2022  }
2023  }
2024 
2025  THROW_IO_ERROR( "Missing '$EndDRAWSEGMENT'" );
2026 }
static int intParse(const char *next, const char **out=NULL)
Function intParse parses an ASCII integer string with possible leading whitespace into an integer and...
static const char delims[]
static LAYER_NUM layerParse(const char *next, const char **out=NULL)
Function layerParse Like intParse but returns a LAYER_NUM.
#define READLINE(rdr)
static PCB_LAYER_ID leg_layer2new(int cu_count, LAYER_NUM aLayerNum)
BIU biuParse(const char *aValue, const char **nptrptr=NULL)
Function biuParse parses an ASCII decimal floating point value and scales it into a BIU according to ...
LINE_READER * m_reader
no ownership here.
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_INSERT) override
Adds an item to the container.
unsigned STATUS_FLAGS
Definition: base_struct.h:156
STROKE_T
Enum STROKE_T is the set of shapes for segments (graphic segments and tracks) which are often in the ...
#define THROW_IO_ERROR(msg)
LEGACY_PLUGIN::BIU BIU
BOARD * m_board
which BOARD, no ownership here
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
double degParse(const char *aValue, const char **nptrptr=NULL)
Function degParse parses an ASCII decimal floating point value which is certainly an angle.
#define LAST_NON_COPPER_LAYER
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
static long hexParse(const char *next, const char **out=NULL)
Function hexParse parses an ASCII hex integer string with possible leading whitespace into a long int...
size_t i
Definition: json11.cpp:597
char * strtok_r(char *str, const char *delim, char **nextp)
uint32_t timestamp_t
timestamp_t is our type to represent unique IDs for all kinds of elements; historically simply the ti...
Definition: common.h:50
#define SZ(x)
Get the length of a string constant, at compile time.
#define TESTLINE(x)
C string compare test for a specific length of characters.
#define FIRST_NON_COPPER_LAYER

References BOARD::Add(), ADD_APPEND, PNS::angle(), biuParse(), degParse(), delims, FIRST_NON_COPPER_LAYER, hexParse(), i, intParse(), LAST_NON_COPPER_LAYER, layerParse(), leg_layer2new(), m_board, m_cu_count, m_reader, READLINE, strtok_r(), SZ, TESTLINE, and THROW_IO_ERROR.

Referenced by loadAllSections().

◆ loadPCB_TARGET()

void LEGACY_PLUGIN::loadPCB_TARGET ( )
protected

Definition at line 2940 of file legacy_plugin.cpp.

2941 {
2942  char* line;
2943 
2944  while( ( line = READLINE( m_reader ) ) != NULL )
2945  {
2946  const char* data;
2947 
2948  if( TESTLINE( "$EndPCB_TARGET" ) || TESTLINE( "$EndMIREPCB" ) )
2949  {
2950  return; // preferred exit
2951  }
2952 
2953  else if( TESTLINE( "Po" ) )
2954  {
2955  // sscanf( Line + 2, " %X %d %d %d %d %d %lX", &m_Shape, &m_Layer, &m_Pos.x, &m_Pos.y, &m_Size, &m_Width, &m_TimeStamp );
2956 
2957  int shape = intParse( line + SZ( "Po" ), &data );
2958 
2959  LAYER_NUM layer_num = layerParse( data, &data );
2960 
2961  BIU pos_x = biuParse( data, &data );
2962  BIU pos_y = biuParse( data, &data );
2963  BIU size = biuParse( data, &data );
2964  BIU width = biuParse( data, &data );
2965  timestamp_t timestamp = hexParse( data );
2966 
2967  if( layer_num < FIRST_NON_COPPER_LAYER )
2968  layer_num = FIRST_NON_COPPER_LAYER;
2969 
2970  else if( layer_num > LAST_NON_COPPER_LAYER )
2971  layer_num = LAST_NON_COPPER_LAYER;
2972 
2973  PCB_TARGET* t = new PCB_TARGET( m_board, shape, leg_layer2new( m_cu_count, layer_num ),
2974  wxPoint( pos_x, pos_y ), size, width );
2975  m_board->Add( t, ADD_APPEND );
2976 
2977  t->SetTimeStamp( timestamp );
2978  }
2979  }
2980 
2981  THROW_IO_ERROR( "Missing '$EndDIMENSION'" );
2982 }
static int intParse(const char *next, const char **out=NULL)
Function intParse parses an ASCII integer string with possible leading whitespace into an integer and...
static LAYER_NUM layerParse(const char *next, const char **out=NULL)
Function layerParse Like intParse but returns a LAYER_NUM.
#define READLINE(rdr)
static PCB_LAYER_ID leg_layer2new(int cu_count, LAYER_NUM aLayerNum)
BIU biuParse(const char *aValue, const char **nptrptr=NULL)
Function biuParse parses an ASCII decimal floating point value and scales it into a BIU according to ...
LINE_READER * m_reader
no ownership here.
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_INSERT) override
Adds an item to the container.
#define THROW_IO_ERROR(msg)
LEGACY_PLUGIN::BIU BIU
BOARD * m_board
which BOARD, no ownership here
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
#define LAST_NON_COPPER_LAYER
static long hexParse(const char *next, const char **out=NULL)
Function hexParse parses an ASCII hex integer string with possible leading whitespace into a long int...
uint32_t timestamp_t
timestamp_t is our type to represent unique IDs for all kinds of elements; historically simply the ti...
Definition: common.h:50
#define SZ(x)
Get the length of a string constant, at compile time.
#define TESTLINE(x)
C string compare test for a specific length of characters.
#define FIRST_NON_COPPER_LAYER
void SetTimeStamp(timestamp_t aNewTimeStamp)
Definition: base_struct.h:215

References BOARD::Add(), ADD_APPEND, biuParse(), FIRST_NON_COPPER_LAYER, hexParse(), intParse(), LAST_NON_COPPER_LAYER, layerParse(), leg_layer2new(), m_board, m_cu_count, m_reader, READLINE, EDA_ITEM::SetTimeStamp(), SZ, TESTLINE, and THROW_IO_ERROR.

Referenced by loadAllSections().

◆ loadPCB_TEXT()

void LEGACY_PLUGIN::loadPCB_TEXT ( )
protected

Definition at line 2094 of file legacy_plugin.cpp.

2095 {
2096  /* examples:
2097  For a single line text:
2098  ----------------------
2099  $TEXTPCB
2100  Te "Text example"
2101  Po 66750 53450 600 800 150 0
2102  De 24 1 0 Italic
2103  $EndTEXTPCB
2104 
2105  For a multi line text:
2106  ---------------------
2107  $TEXTPCB
2108  Te "Text example"
2109  Nl "Line 2"
2110  Po 66750 53450 600 800 150 0
2111  De 24 1 0 Italic
2112  $EndTEXTPCB
2113  Nl "line nn" is a line added to the current text
2114  */
2115 
2116  char text[1024];
2117 
2118  // maybe someday a constructor that takes all this data in one call?
2119  TEXTE_PCB* pcbtxt = new TEXTE_PCB( m_board );
2120  m_board->Add( pcbtxt, ADD_APPEND );
2121 
2122  char* line;
2123  char* saveptr;
2124 
2125  while( ( line = READLINE( m_reader ) ) != NULL )
2126  {
2127  const char* data;
2128 
2129  if( TESTLINE( "Te" ) ) // Text line (or first line for multi line texts)
2130  {
2131  ReadDelimitedText( text, line + SZ( "Te" ), sizeof(text) );
2132  pcbtxt->SetText( FROM_UTF8( text ) );
2133  }
2134 
2135  else if( TESTLINE( "nl" ) ) // next line of the current text
2136  {
2137  ReadDelimitedText( text, line + SZ( "nl" ), sizeof(text) );
2138  pcbtxt->SetText( pcbtxt->GetText() + wxChar( '\n' ) + FROM_UTF8( text ) );
2139  }
2140 
2141  else if( TESTLINE( "Po" ) )
2142  {
2143  // sscanf( line + 2, " %d %d %d %d %d %d", &m_Pos.x, &m_Pos.y, &m_Size.x, &m_Size.y, &m_Thickness, &m_Orient );
2144  wxSize size;
2145 
2146  BIU pos_x = biuParse( line + SZ( "Po" ), &data );
2147  BIU pos_y = biuParse( data, &data );
2148  size.x = biuParse( data, &data );
2149  size.y = biuParse( data, &data );
2150  BIU thickn = biuParse( data, &data );
2151  double angle = degParse( data );
2152 
2153  pcbtxt->SetTextSize( size );
2154 
2155  pcbtxt->SetThickness( thickn );
2156  pcbtxt->SetTextAngle( angle );
2157 
2158  pcbtxt->SetTextPos( wxPoint( pos_x, pos_y ) );
2159  }
2160 
2161  else if( TESTLINE( "De" ) )
2162  {
2163  // e.g. "De 21 1 0 Normal C\r\n"
2164  // sscanf( line + 2, " %d %d %lX %s %c\n", &m_Layer, &normal_display, &m_TimeStamp, style, &hJustify );
2165 
2166  LAYER_NUM layer_num = layerParse( line + SZ( "De" ), &data );
2167  int notMirrored = intParse( data, &data );
2168  timestamp_t timestamp = hexParse( data, &data );
2169  char* style = strtok_r( (char*) data, delims, &saveptr );
2170  char* hJustify = strtok_r( NULL, delims, &saveptr );
2171  char* vJustify = strtok_r( NULL, delims, &saveptr );
2172 
2173  pcbtxt->SetMirrored( !notMirrored );
2174  pcbtxt->SetTimeStamp( timestamp );
2175  pcbtxt->SetItalic( !strcmp( style, "Italic" ) );
2176 
2177  if( hJustify )
2178  pcbtxt->SetHorizJustify( horizJustify( hJustify ) );
2179  else
2180  {
2181  // boom, somebody changed a constructor, I was relying on this:
2182  wxASSERT( pcbtxt->GetHorizJustify() == GR_TEXT_HJUSTIFY_CENTER );
2183  }
2184 
2185  if( vJustify )
2186  pcbtxt->SetVertJustify( vertJustify( vJustify ) );
2187 
2188  if( layer_num < FIRST_COPPER_LAYER )
2189  layer_num = FIRST_COPPER_LAYER;
2190  else if( layer_num > LAST_NON_COPPER_LAYER )
2191  layer_num = LAST_NON_COPPER_LAYER;
2192 
2193  if( layer_num >= FIRST_NON_COPPER_LAYER ||
2194  is_leg_copperlayer_valid( m_cu_count, layer_num ) )
2195  pcbtxt->SetLayer( leg_layer2new( m_cu_count, layer_num ) );
2196  else // not perfect, but putting this text on front layer is a workaround
2197  pcbtxt->SetLayer( F_Cu );
2198  }
2199 
2200  else if( TESTLINE( "$EndTEXTPCB" ) )
2201  {
2202  return; // preferred exit
2203  }
2204  }
2205 
2206  THROW_IO_ERROR( "Missing '$EndTEXTPCB'" );
2207 }
void SetMirrored(bool isMirrored)
Definition: eda_text.h:172
void SetTextAngle(double aAngle)
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:62
virtual void SetLayer(PCB_LAYER_ID aLayer)
Function SetLayer sets the layer this item is on.
static int intParse(const char *next, const char **out=NULL)
Function intParse parses an ASCII integer string with possible leading whitespace into an integer and...
void SetItalic(bool isItalic)
Definition: eda_text.h:163
void SetTextPos(const wxPoint &aPoint)
Definition: eda_text.h:229
static const char delims[]
static LAYER_NUM layerParse(const char *next, const char **out=NULL)
Function layerParse Like intParse but returns a LAYER_NUM.
#define READLINE(rdr)
void SetTextSize(const wxSize &aNewSize)
Definition: eda_text.h:220
static PCB_LAYER_ID leg_layer2new(int cu_count, LAYER_NUM aLayerNum)
BIU biuParse(const char *aValue, const char **nptrptr=NULL)
Function biuParse parses an ASCII decimal floating point value and scales it into a BIU according to ...
LINE_READER * m_reader
no ownership here.
static EDA_TEXT_HJUSTIFY_T horizJustify(const char *horizontal)
bool is_leg_copperlayer_valid(int aCu_Count, LAYER_NUM aLegacyLayerNum)
EDA_TEXT_HJUSTIFY_T GetHorizJustify() const
Definition: eda_text.h:184
virtual void SetText(const wxString &aText)
Definition: eda_text.cpp:112
void SetVertJustify(EDA_TEXT_VJUSTIFY_T aType)
Definition: eda_text.h:188
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_INSERT) override
Adds an item to the container.
#define THROW_IO_ERROR(msg)
LEGACY_PLUGIN::BIU BIU
BOARD * m_board
which BOARD, no ownership here
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
double degParse(const char *aValue, const char **nptrptr=NULL)
Function degParse parses an ASCII decimal floating point value which is certainly an angle.
static EDA_TEXT_VJUSTIFY_T vertJustify(const char *vertical)
void SetHorizJustify(EDA_TEXT_HJUSTIFY_T aType)
Definition: eda_text.h:187
#define LAST_NON_COPPER_LAYER
static DIRECTION_45::AngleType angle(const VECTOR2I &a, const VECTOR2I &b)
static long hexParse(const char *next, const char **out=NULL)
Function hexParse parses an ASCII hex integer string with possible leading whitespace into a long int...
char * strtok_r(char *str, const char *delim, char **nextp)
#define FIRST_COPPER_LAYER
uint32_t timestamp_t
timestamp_t is our type to represent unique IDs for all kinds of elements; historically simply the ti...
Definition: common.h:50
int ReadDelimitedText(wxString *aDest, const char *aSource)
Copy bytes from aSource delimited string segment to aDest wxString.
Definition: string.cpp:147
#define SZ(x)
Get the length of a string constant, at compile time.
virtual const wxString & GetText() const
Function GetText returns the string associated with the text object.
Definition: eda_text.h:124
#define TESTLINE(x)
C string compare test for a specific length of characters.
#define FIRST_NON_COPPER_LAYER
void SetThickness(int aNewThickness)
Function SetThickness sets pen width.
Definition: eda_text.h:142
void SetTimeStamp(timestamp_t aNewTimeStamp)
Definition: base_struct.h:215

References BOARD::Add(), ADD_APPEND, PNS::angle(), biuParse(), degParse(), delims, F_Cu, FIRST_COPPER_LAYER, FIRST_NON_COPPER_LAYER, FROM_UTF8(), EDA_TEXT::GetHorizJustify(), EDA_TEXT::GetText(), GR_TEXT_HJUSTIFY_CENTER, hexParse(), horizJustify(), intParse(), is_leg_copperlayer_valid(), LAST_NON_COPPER_LAYER, layerParse(), leg_layer2new(), m_board, m_cu_count, m_reader, ReadDelimitedText(), READLINE, EDA_TEXT::SetHorizJustify(), EDA_TEXT::SetItalic(), BOARD_ITEM::SetLayer(), EDA_TEXT::SetMirrored(), EDA_TEXT::SetText(), TEXTE_PCB::SetTextAngle(), EDA_TEXT::SetTextPos(), EDA_TEXT::SetTextSize(), EDA_TEXT::SetThickness(), EDA_ITEM::SetTimeStamp(), EDA_TEXT::SetVertJustify(), strtok_r(), SZ, TESTLINE, THROW_IO_ERROR, and vertJustify().

Referenced by loadAllSections().

◆ loadSETUP()

void LEGACY_PLUGIN::loadSETUP ( )
protected

Definition at line 828 of file legacy_plugin.cpp.

829 {
830  NETCLASSPTR netclass_default = m_board->GetDesignSettings().GetDefault();
831  // TODO Orson: is it really necessary to first operate on a copy and then apply it?
832  // would not it be better to use reference here and apply all the changes instantly?
835  char* line;
836  char* saveptr;
837 
838  while( ( line = READLINE( m_reader ) ) != NULL )
839  {
840  const char* data;
841 
842  if( TESTLINE( "PcbPlotParams" ) )
843  {
844  PCB_PLOT_PARAMS plot_opts;
845 
846  PCB_PLOT_PARAMS_PARSER parser( line + SZ( "PcbPlotParams" ), m_reader->GetSource() );
847 
848  plot_opts.Parse( &parser );
849 
850  m_board->SetPlotOptions( plot_opts );
851  }
852 
853  else if( TESTLINE( "AuxiliaryAxisOrg" ) )
854  {
855  BIU gx = biuParse( line + SZ( "AuxiliaryAxisOrg" ), &data );
856  BIU gy = biuParse( data );
857 
858  // m_board->SetAuxOrigin( wxPoint( gx, gy ) ); gets overwritten by SetDesignSettings() below
859  bds.m_AuxOrigin = wxPoint( gx, gy );
860  }
861 
862  /* Done from $General above's "LayerCount"
863  else if( TESTLINE( "Layers" ) )
864  {
865  int tmp = intParse( line + SZ( "Layers" ) );
866  m_board->SetCopperLayerCount( tmp );
867 
868  m_cu_count = tmp;
869  }
870  */
871 
872  else if( TESTSUBSTR( "Layer[" ) )
873  {
874  // eg: "Layer[n] <a_Layer_name_with_no_spaces> <LAYER_T>"
875 
876  LAYER_NUM layer_num = layerParse( line + SZ( "Layer[" ), &data );
877  PCB_LAYER_ID layer_id = leg_layer2new( m_cu_count, layer_num );
878 
879  /*
880  switch( layer_num )
881  {
882  case LAYER_N_BACK:
883  layer_id = B_Cu;
884  break;
885 
886  case LAYER_N_FRONT:
887  layer_id = F_Cu;
888  break;
889 
890  default:
891  layer_id = PCB_LAYER_ID( layer_num );
892  }
893  */
894 
895  data = strtok_r( (char*) data+1, delims, &saveptr ); // +1 for ']'
896  if( data )
897  {
898  wxString layerName = FROM_UTF8( data );
899  m_board->SetLayerName( layer_id, layerName );
900 
901  data = strtok_r( NULL, delims, &saveptr );
902  if( data ) // optional in old board files
903  {
904  LAYER_T type = LAYER::ParseType( data );
905  m_board->SetLayerType( layer_id, type );
906  }
907  }
908  }
909 
910  else if( TESTLINE( "TrackWidth" ) )
911  {
912  BIU tmp = biuParse( line + SZ( "TrackWidth" ) );
913  netclass_default->SetTrackWidth( tmp );
914  }
915 
916  else if( TESTLINE( "TrackWidthList" ) )
917  {
918  BIU tmp = biuParse( line + SZ( "TrackWidthList" ) );
919  bds.m_TrackWidthList.push_back( tmp );
920  }
921 
922  else if( TESTLINE( "TrackClearence" ) )
923  {
924  BIU tmp = biuParse( line + SZ( "TrackClearence" ) );
925  netclass_default->SetClearance( tmp );
926  }
927 
928  else if( TESTLINE( "TrackMinWidth" ) )
929  {
930  BIU tmp = biuParse( line + SZ( "TrackMinWidth" ) );
931  bds.m_TrackMinWidth = tmp;
932  }
933 
934  else if( TESTLINE( "ZoneClearence" ) )
935  {
936  BIU tmp = biuParse( line + SZ( "ZoneClearence" ) );
937  zs.m_ZoneClearance = tmp;
938  }
939 
940  else if( TESTLINE( "Zone_45_Only" ) )
941  {
942  bool tmp = (bool) intParse( line + SZ( "Zone_45_Only" ) );
943  zs.m_Zone_45_Only = tmp;
944  }
945 
946  else if( TESTLINE( "DrawSegmWidth" ) )
947  {
948  BIU tmp = biuParse( line + SZ( "DrawSegmWidth" ) );
949  bds.m_LineThickness[ LAYER_CLASS_COPPER ] = tmp;
950  }
951 
952  else if( TESTLINE( "EdgeSegmWidth" ) )
953  {
954  BIU tmp = biuParse( line + SZ( "EdgeSegmWidth" ) );
955  bds.m_LineThickness[ LAYER_CLASS_EDGES ] = tmp;
956  }
957 
958  else if( TESTLINE( "ViaMinSize" ) )
959  {
960  BIU tmp = biuParse( line + SZ( "ViaMinSize" ) );
961  bds.m_ViasMinSize = tmp;
962  }
963 
964  else if( TESTLINE( "MicroViaMinSize" ) )
965  {
966  BIU tmp = biuParse( line + SZ( "MicroViaMinSize" ) );
967  bds.m_MicroViasMinSize = tmp;
968  }
969 
970  else if( TESTLINE( "ViaSizeList" ) )
971  {
972  // e.g. "ViaSizeList DIAMETER [DRILL]"
973 
974  BIU drill = 0;
975  BIU diameter = biuParse( line + SZ( "ViaSizeList" ), &data );
976 
977  data = strtok_r( (char*) data, delims, &saveptr );
978  if( data ) // DRILL may not be present ?
979  drill = biuParse( data );
980 
981  bds.m_ViasDimensionsList.push_back( VIA_DIMENSION( diameter,
982  drill ) );
983  }
984 
985  else if( TESTLINE( "ViaSize" ) )
986  {
987  BIU tmp = biuParse( line + SZ( "ViaSize" ) );
988  netclass_default->SetViaDiameter( tmp );
989  }
990 
991  else if( TESTLINE( "ViaDrill" ) )
992  {
993  BIU tmp = biuParse( line + SZ( "ViaDrill" ) );
994  netclass_default->SetViaDrill( tmp );
995  }
996 
997  else if( TESTLINE( "ViaMinDrill" ) )
998  {
999  BIU tmp = biuParse( line + SZ( "ViaMinDrill" ) );
1000  bds.m_ViasMinDrill = tmp;
1001  }
1002 
1003  else if( TESTLINE( "MicroViaSize" ) )
1004  {
1005  BIU tmp = biuParse( line + SZ( "MicroViaSize" ) );
1006  netclass_default->SetuViaDiameter( tmp );
1007  }
1008 
1009  else if( TESTLINE( "MicroViaDrill" ) )
1010  {
1011  BIU tmp = biuParse( line + SZ( "MicroViaDrill" ) );
1012  netclass_default->SetuViaDrill( tmp );
1013  }
1014 
1015  else if( TESTLINE( "MicroViaMinDrill" ) )
1016  {
1017  BIU tmp = biuParse( line + SZ( "MicroViaMinDrill" ) );
1018  bds.m_MicroViasMinDrill = tmp;
1019  }
1020 
1021  else if( TESTLINE( "MicroViasAllowed" ) )
1022  {
1023  int tmp = intParse( line + SZ( "MicroViasAllowed" ) );
1024  bds.m_MicroViasAllowed = tmp;
1025  }
1026 
1027  else if( TESTLINE( "TextPcbWidth" ) )
1028  {
1029  BIU tmp = biuParse( line + SZ( "TextPcbWidth" ) );
1030  bds.m_TextThickness[ LAYER_CLASS_COPPER ] = tmp;
1031  }
1032 
1033  else if( TESTLINE( "TextPcbSize" ) )
1034  {
1035  BIU x = biuParse( line + SZ( "TextPcbSize" ), &data );
1036  BIU y = biuParse( data );
1037 
1038  bds.m_TextSize[ LAYER_CLASS_COPPER ] = wxSize( x, y );
1039  }
1040 
1041  else if( TESTLINE( "EdgeModWidth" ) )
1042  {
1043  BIU tmp = biuParse( line + SZ( "EdgeModWidth" ) );
1044  bds.m_LineThickness[ LAYER_CLASS_SILK ] = tmp;
1045  bds.m_LineThickness[ LAYER_CLASS_OTHERS ] = tmp;
1046  }
1047 
1048  else if( TESTLINE( "TextModWidth" ) )
1049  {
1050  BIU tmp = biuParse( line + SZ( "TextModWidth" ) );
1051  bds.m_TextThickness[ LAYER_CLASS_SILK ] = tmp;
1052  bds.m_TextThickness[ LAYER_CLASS_OTHERS ] = tmp;
1053  }
1054 
1055  else if( TESTLINE( "TextModSize" ) )
1056  {
1057  BIU x = biuParse( line + SZ( "TextModSize" ), &data );
1058  BIU y = biuParse( data );
1059 
1060  bds.m_TextSize[ LAYER_CLASS_SILK ] = wxSize( x, y );
1061  bds.m_TextSize[ LAYER_CLASS_OTHERS ] = wxSize( x, y );
1062  }
1063 
1064  else if( TESTLINE( "PadSize" ) )
1065  {
1066  BIU x = biuParse( line + SZ( "PadSize" ), &data );
1067  BIU y = biuParse( data );
1068 
1069  bds.m_Pad_Master.SetSize( wxSize( x, y ) );
1070  }
1071 
1072  else if( TESTLINE( "PadDrill" ) )
1073  {
1074  BIU tmp = biuParse( line + SZ( "PadDrill" ) );
1075  bds.m_Pad_Master.SetDrillSize( wxSize( tmp, tmp ) );
1076  }
1077 
1078  else if( TESTLINE( "Pad2MaskClearance" ) )
1079  {
1080  BIU tmp = biuParse( line + SZ( "Pad2MaskClearance" ) );
1081  bds.m_SolderMaskMargin = tmp;
1082  }
1083 
1084  else if( TESTLINE( "SolderMaskMinWidth" ) )
1085  {
1086  BIU tmp = biuParse( line + SZ( "SolderMaskMinWidth" ) );
1087  bds.m_SolderMaskMinWidth = tmp;
1088  }
1089 
1090  else if( TESTLINE( "Pad2PasteClearance" ) )
1091  {
1092  BIU tmp = biuParse( line + SZ( "Pad2PasteClearance" ) );
1093  bds.m_SolderPasteMargin = tmp;
1094  }
1095 
1096  else if( TESTLINE( "Pad2PasteClearanceRatio" ) )
1097  {
1098  double ratio = atof( line + SZ( "Pad2PasteClearanceRatio" ) );
1099  bds.m_SolderPasteMarginRatio = ratio;
1100  }
1101 
1102  else if( TESTLINE( "GridOrigin" ) )
1103  {
1104  BIU x = biuParse( line + SZ( "GridOrigin" ), &data );
1105  BIU y = biuParse( data );
1106 
1107  // m_board->SetGridOrigin( wxPoint( x, y ) ); gets overwritten by SetDesignSettings() below
1108  bds.m_GridOrigin = wxPoint( x, y );
1109  }
1110 
1111  else if( TESTLINE( "VisibleElements" ) )
1112  {
1113  int visibleElements = hexParse( line + SZ( "VisibleElements" ) );
1114  bds.SetVisibleElements( visibleElements );
1115  }
1116 
1117  else if( TESTLINE( "$EndSETUP" ) )
1118  {
1119  m_board->SetDesignSettings( bds );
1120  m_board->SetZoneSettings( zs );
1121 
1122  // Very old *.brd file does not have NETCLASSes
1123  // "TrackWidth", "ViaSize", "ViaDrill", "ViaMinSize", and "TrackClearence" were
1124  // defined in SETUP; these values are put into the default NETCLASS until later board
1125  // load code should override them. *.brd files which have been saved with knowledge
1126  // of NETCLASSes will override these defaults, very old boards (before 2009) will not
1127  // and use the setup values.
1128  // However these values should be the same as default NETCLASS.
1129 
1130  return; // preferred exit
1131  }
1132  }
1133 
1134  /*
1135  * Ensure tracks and vias sizes lists are ok:
1136  * Sort lists by by increasing value and remove duplicates
1137  * (the first value is not tested, because it is the netclass value)
1138  */
1139  BOARD_DESIGN_SETTINGS& designSettings = m_board->GetDesignSettings();
1140  sort( designSettings.m_ViasDimensionsList.begin() + 1, designSettings.m_ViasDimensionsList.end() );
1141  sort( designSettings.m_TrackWidthList.begin() + 1, designSettings.m_TrackWidthList.end() );
1142 
1143  for( unsigned ii = 1; ii < designSettings.m_ViasDimensionsList.size() - 1; ii++ )
1144  {
1145  if( designSettings.m_ViasDimensionsList[ii] == designSettings.m_ViasDimensionsList[ii + 1] )
1146  {
1147  designSettings.m_ViasDimensionsList.erase( designSettings.m_ViasDimensionsList.begin() + ii );
1148  ii--;
1149  }
1150  }
1151 
1152  for( unsigned ii = 1; ii < designSettings.m_TrackWidthList.size() - 1; ii++ )
1153  {
1154  if( designSettings.m_TrackWidthList[ii] == designSettings.m_TrackWidthList[ii + 1] )
1155  {
1156  designSettings.m_TrackWidthList.erase( designSettings.m_TrackWidthList.begin() + ii );
1157  ii--;
1158  }
1159  }
1160 }
int m_SolderMaskMargin
Solder mask margin.
Struct VIA_DIMENSION is a small helper container to handle a stock of specific vias each with unique ...
void SetZoneSettings(const ZONE_SETTINGS &aSettings)
Definition: class_board.h:565
wxPoint m_GridOrigin
origin for grid offsets
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:62
virtual const wxString & GetSource() const
Function GetSource returns the name of the source of the lines in an abstract sense.
Definition: richio.h:130
int m_SolderPasteMargin
Solder paste margin absolute value.
Class PCB_PLOT_PARAMS_PARSER is the parser class for PCB_PLOT_PARAMS.
std::vector< int > m_TrackWidthList
static int intParse(const char *next, const char **out=NULL)
Function intParse parses an ASCII integer string with possible leading whitespace into an integer and...
static const char delims[]
static LAYER_NUM layerParse(const char *next, const char **out=NULL)
Function layerParse Like intParse but returns a LAYER_NUM.
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Function GetDesignSettings.
Definition: class_board.h:540
#define READLINE(rdr)
void SetDrillSize(const wxSize &aSize)
Definition: class_pad.h:289
static PCB_LAYER_ID leg_layer2new(int cu_count, LAYER_NUM aLayerNum)
bool SetLayerType(PCB_LAYER_ID aLayer, LAYER_T aLayerType)
Function SetLayerType changes the type of the layer given by aLayer.
wxSize m_TextSize[LAYER_CLASS_COUNT]
BIU biuParse(const char *aValue, const char **nptrptr=NULL)
Function biuParse parses an ASCII decimal floating point value and scales it into a BIU according to ...
PCB_LAYER_ID
A quick note on layer IDs:
LINE_READER * m_reader
no ownership here.
int m_TextThickness[LAYER_CLASS_COUNT]
int m_TrackMinWidth
track min value for width ((min copper size value
int m_ViasMinSize
vias (not micro vias) min diameter
LAYER_T
Enum LAYER_T gives the allowed types of layers, same as Specctra DSN spec.
Definition: class_board.h:66
bool SetLayerName(PCB_LAYER_ID aLayer, const wxString &aLayerName)
Function SetLayerName changes the name of the layer given by aLayer.
int m_ViasMinDrill
vias (not micro vias) min drill diameter
void SetSize(const wxSize &aSize)
Definition: class_pad.h:283
int m_ZoneClearance
Clearance value.
Definition: zone_settings.h:64
void SetDesignSettings(const BOARD_DESIGN_SETTINGS &aDesignSettings)
Function SetDesignSettings.
Definition: class_board.h:550
LEGACY_PLUGIN::BIU BIU
void SetPlotOptions(const PCB_PLOT_PARAMS &aOptions)
Definition: class_board.h:559
static LAYER_T ParseType(const char *aType)
Function ParseType converts a string to a LAYER_T.
int m_MicroViasMinSize
micro vias (not vias) min diameter
Class PCB_PLOT_PARAMS handles plot parameters and options when plotting/printing a board.
BOARD * m_board
which BOARD, no ownership here
int m_LineThickness[LAYER_CLASS_COUNT]
#define TESTSUBSTR(x)
C sub-string compare test for a specific length of characters.
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
Class ZONE_SETTINGS handles zones parameters.
Definition: zone_settings.h:49
NETCLASSPTR GetDefault() const
Function GetDefault.
static long hexParse(const char *next, const char **out=NULL)
Function hexParse parses an ASCII hex integer string with possible leading whitespace into a long int...
D_PAD m_Pad_Master
A dummy pad to store all default parameters.
char * strtok_r(char *str, const char *delim, char **nextp)
void SetVisibleElements(int aMask)
Function SetVisibleElements changes the bit-mask of visible element categories.
const ZONE_SETTINGS & GetZoneSettings() const
Definition: class_board.h:564
std::vector< VIA_DIMENSION > m_ViasDimensionsList
bool m_MicroViasAllowed
true to allow micro vias
int m_MicroViasMinDrill
micro vias (not vias) min drill diameter
double m_SolderPasteMarginRatio
Solder pask margin ratio value of pad size The final margin is the sum of these 2 values.
void Parse(PCB_PLOT_PARAMS_PARSER *aParser)
#define SZ(x)
Get the length of a string constant, at compile time.
#define TESTLINE(x)
C string compare test for a specific length of characters.
wxPoint m_AuxOrigin
origin for plot exports
int m_SolderMaskMinWidth
Solder mask min width.
Class BOARD_DESIGN_SETTINGS contains design settings for a BOARD object.

References biuParse(), delims, FROM_UTF8(), BOARD_DESIGN_SETTINGS::GetDefault(), BOARD::GetDesignSettings(), LINE_READER::GetSource(), BOARD::GetZoneSettings(), hexParse(), intParse(), LAYER_CLASS_COPPER, LAYER_CLASS_EDGES, LAYER_CLASS_OTHERS, LAYER_CLASS_SILK, layerParse(), leg_layer2new(), BOARD_DESIGN_SETTINGS::m_AuxOrigin, m_board, m_cu_count, BOARD_DESIGN_SETTINGS::m_GridOrigin, BOARD_DESIGN_SETTINGS::m_LineThickness, BOARD_DESIGN_SETTINGS::m_MicroViasAllowed, BOARD_DESIGN_SETTINGS::m_MicroViasMinDrill, BOARD_DESIGN_SETTINGS::m_MicroViasMinSize, BOARD_DESIGN_SETTINGS::m_Pad_Master, m_reader, BOARD_DESIGN_SETTINGS::m_SolderMaskMargin, BOARD_DESIGN_SETTINGS::m_SolderMaskMinWidth, BOARD_DESIGN_SETTINGS::m_SolderPasteMargin, BOARD_DESIGN_SETTINGS::m_SolderPasteMarginRatio, BOARD_DESIGN_SETTINGS::m_TextSize, BOARD_DESIGN_SETTINGS::m_TextThickness, BOARD_DESIGN_SETTINGS::m_TrackMinWidth, BOARD_DESIGN_SETTINGS::m_TrackWidthList, BOARD_DESIGN_SETTINGS::m_ViasDimensionsList, BOARD_DESIGN_SETTINGS::m_ViasMinDrill, BOARD_DESIGN_SETTINGS::m_ViasMinSize, ZONE_SETTINGS::m_Zone_45_Only, ZONE_SETTINGS::m_ZoneClearance, PCB_PLOT_PARAMS::Parse(), LAYER::ParseType(), READLINE, BOARD::SetDesignSettings(), D_PAD::SetDrillSize(), BOARD::SetLayerName(), BOARD::SetLayerType(), BOARD::SetPlotOptions(), D_PAD::SetSize(), BOARD_DESIGN_SETTINGS::SetVisibleElements(), BOARD::SetZoneSettings(), strtok_r(), SZ, TESTLINE, and TESTSUBSTR.

Referenced by loadAllSections().

◆ loadSHEET()

void LEGACY_PLUGIN::loadSHEET ( )
protected

Definition at line 714 of file legacy_plugin.cpp.

715 {
716  char buf[260];
717  TITLE_BLOCK tb;
718  char* line;
719  char* saveptr;
720 
721  while( ( line = READLINE( m_reader ) ) != NULL )
722  {
723  if( TESTLINE( "Sheet" ) )
724  {
725  // e.g. "Sheet A3 16535 11700"
726  // width and height are in 1/1000th of an inch, always
727 
728  PAGE_INFO page;
729  char* sname = strtok_r( line + SZ( "Sheet" ), delims, &saveptr );
730 
731  if( sname )
732  {
733  wxString wname = FROM_UTF8( sname );
734  if( !page.SetType( wname ) )
735  {
736  m_error.Printf( _( "Unknown sheet type \"%s\" on line:%d" ),
737  wname.GetData(), m_reader->LineNumber() );
739  }
740 
741  char* width = strtok_r( NULL, delims, &saveptr );
742  char* height = strtok_r( NULL, delims, &saveptr );
743  char* orient = strtok_r( NULL, delims, &saveptr );
744 
745  // only parse the width and height if page size is custom ("User")
746  if( wname == PAGE_INFO::Custom )
747  {
748  if( width && height )
749  {
750  // legacy disk file describes paper in mils
751  // (1/1000th of an inch)
752  int w = intParse( width );
753  int h = intParse( height );
754 
755  page.SetWidthMils( w );
756  page.SetHeightMils( h );
757  }
758  }
759 
760  if( orient && !strcmp( orient, "portrait" ) )
761  {
762  page.SetPortrait( true );
763  }
764 
765  m_board->SetPageSettings( page );
766  }
767  }
768 
769  else if( TESTLINE( "Title" ) )
770  {
771  ReadDelimitedText( buf, line, sizeof(buf) );
772  tb.SetTitle( FROM_UTF8( buf ) );
773  }
774 
775  else if( TESTLINE( "Date" ) )
776  {
777  ReadDelimitedText( buf, line, sizeof(buf) );
778  tb.SetDate( FROM_UTF8( buf ) );
779  }
780 
781  else if( TESTLINE( "Rev" ) )
782  {
783  ReadDelimitedText( buf, line, sizeof(buf) );
784  tb.SetRevision( FROM_UTF8( buf ) );
785  }
786 
787  else if( TESTLINE( "Comp" ) )
788  {
789  ReadDelimitedText( buf, line, sizeof(buf) );
790  tb.SetCompany( FROM_UTF8( buf ) );
791  }
792 
793  else if( TESTLINE( "Comment1" ) )
794  {
795  ReadDelimitedText( buf, line, sizeof(buf) );
796  tb.SetComment1( FROM_UTF8( buf ) );
797  }
798 
799  else if( TESTLINE( "Comment2" ) )
800  {
801  ReadDelimitedText( buf, line, sizeof(buf) );
802  tb.SetComment2( FROM_UTF8( buf ) );
803  }
804 
805  else if( TESTLINE( "Comment3" ) )
806  {
807  ReadDelimitedText( buf, line, sizeof(buf) );
808  tb.SetComment3( FROM_UTF8( buf ) );
809  }
810 
811  else if( TESTLINE( "Comment4" ) )
812  {
813  ReadDelimitedText( buf, line, sizeof(buf) );
814  tb.SetComment4( FROM_UTF8( buf ) );
815  }
816 
817  else if( TESTLINE( "$EndSHEETDESCR" ) )
818  {
819  m_board->SetTitleBlock( tb );
820  return; // preferred exit
821  }
822  }
823 
824  THROW_IO_ERROR( "Missing '$EndSHEETDESCR'" );
825 }
void SetComment1(const wxString &aComment)
Definition: title_block.h:117
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:62
static int intParse(const char *next, const char **out=NULL)
Function intParse parses an ASCII integer string with possible leading whitespace into an integer and...
void SetRevision(const wxString &aRevision)
Definition: title_block.h:84
void SetTitleBlock(const TITLE_BLOCK &aTitleBlock)
Definition: class_board.h:562
void SetPageSettings(const PAGE_INFO &aPageSettings)
Definition: class_board.h:556
static const char delims[]
bool SetType(const wxString &aStandardPageDescriptionName, bool aIsPortrait=false)
Function SetType sets the name of the page type and also the sizes and margins commonly associated wi...
Definition: page_info.cpp:117
void SetDate(const wxString &aDate)
Function SetDate sets the date field, and defaults to the current time and date.
Definition: title_block.h:74
static const wxChar Custom[]
"User" defined page type
Definition: page_info.h:78
#define READLINE(rdr)
Class TITLE_BLOCK holds the information shown in the lower right corner of a plot,...
Definition: title_block.h:40
void SetComment4(const wxString &aComment)
Definition: title_block.h:120
LINE_READER * m_reader
no ownership here.
virtual unsigned LineNumber() const
Function Line Number returns the line number of the last line read from this LINE_READER.
Definition: richio.h:159
Class PAGE_INFO describes the page size and margins of a paper page on which to eventually print or p...
Definition: page_info.h:54
void SetCompany(const wxString &aCompany)
Definition: title_block.h:94
#define THROW_IO_ERROR(msg)
void SetTitle(const wxString &aTitle)
Definition: title_block.h:60
#define _(s)
BOARD * m_board
which BOARD, no ownership here
void SetHeightMils(int aHeightInMils)
Definition: page_info.cpp:253
void SetComment2(const wxString &aComment)
Definition: title_block.h:118
wxString m_error
for throwing exceptions
void SetWidthMils(int aWidthInMils)
Definition: page_info.cpp:239
char * strtok_r(char *str, const char *delim, char **nextp)
void SetComment3(const wxString &aComment)
Definition: title_block.h:119
int ReadDelimitedText(wxString *aDest, const char *aSource)
Copy bytes from aSource delimited string segment to aDest wxString.
Definition: string.cpp:147
#define SZ(x)
Get the length of a string constant, at compile time.
void SetPortrait(bool aIsPortrait)
Function SetPortrait will rotate the paper page 90 degrees.
Definition: page_info.cpp:182
#define TESTLINE(x)
C string compare test for a specific length of characters.

References _, PAGE_INFO::Custom, delims, FROM_UTF8(), intParse(), LINE_READER::LineNumber(), m_board, m_error, m_reader, ReadDelimitedText(), READLINE, TITLE_BLOCK::SetComment1(), TITLE_BLOCK::SetComment2(), TITLE_BLOCK::SetComment3(), TITLE_BLOCK::SetComment4(), TITLE_BLOCK::SetCompany(), TITLE_BLOCK::SetDate(), PAGE_INFO::SetHeightMils(), BOARD::SetPageSettings(), PAGE_INFO::SetPortrait(), TITLE_BLOCK::SetRevision(), TITLE_BLOCK::SetTitle(), BOARD::SetTitleBlock(), PAGE_INFO::SetType(), PAGE_INFO::SetWidthMils(), strtok_r(), SZ, TESTLINE, and THROW_IO_ERROR.

Referenced by loadAllSections().

◆ loadTrackList()

void LEGACY_PLUGIN::loadTrackList ( int  aStructType)
protected

Function loadTrackList reads a list of segments (Tracks and Vias, or Segzones)

Parameters
aStructTypeis either PCB_TRACE_T to indicate tracks and vias, or NOT_USED to indicate oldschool zone segments (which are discarded).

Definition at line 2210 of file legacy_plugin.cpp.

2211 {
2212  char* line;
2213  char* saveptr;
2214 
2215  while( ( line = READLINE( m_reader ) ) != NULL )
2216  {
2217  // read two lines per loop iteration, each loop is one TRACK or VIA
2218  // example first line:
2219  // e.g. "Po 0 23994 28800 24400 28800 150 -1" for a track
2220  // e.g. "Po 3 21086 17586 21086 17586 180 -1" for a via (uses sames start and end)
2221 
2222  const char* data;
2223 
2224  if( line[0] == '$' ) // $EndTRACK
2225  return; // preferred exit
2226 
2227  // int arg_count = sscanf( line + 2, " %d %d %d %d %d %d %d", &shape, &tempStartX, &tempStartY, &tempEndX, &tempEndY, &width, &drill );
2228 
2229  assert( TESTLINE( "Po" ) );
2230 
2231  VIATYPE_T viatype = static_cast<VIATYPE_T>( intParse( line + SZ( "Po" ), &data ));
2232  BIU start_x = biuParse( data, &data );
2233  BIU start_y = biuParse( data, &data );
2234  BIU end_x = biuParse( data, &data );
2235  BIU end_y = biuParse( data, &data );
2236  BIU width = biuParse( data, &data );
2237 
2238  // optional 7th drill parameter (must be optional in an old format?)
2239  data = strtok_r( (char*) data, delims, &saveptr );
2240 
2241  BIU drill = data ? biuParse( data ) : -1; // SetDefault() if < 0
2242 
2243  // Read the 2nd line to determine the exact type, one of:
2244  // PCB_TRACE_T, PCB_VIA_T, or PCB_SEGZONE_T. The type field in 2nd line
2245  // differentiates between PCB_TRACE_T and PCB_VIA_T. With virtual
2246  // functions in use, it is critical to instantiate the PCB_VIA_T
2247  // exactly.
2248  READLINE( m_reader );
2249 
2250  line = m_reader->Line();
2251 
2252  // example second line:
2253  // "De 0 0 463 0 800000\r\n"
2254 
2255 #if 1
2256  assert( TESTLINE( "De" ) );
2257 #else
2258  if( !TESTLINE( "De" ) )
2259  {
2260  // mandatory 2nd line is missing
2261  THROW_IO_ERROR( "Missing 2nd line of a TRACK def" );
2262  }
2263 #endif
2264 
2265  int makeType;
2266  unsigned long timeStamp;
2267  LAYER_NUM layer_num;
2268  int type, net_code, flags_int;
2269 
2270  // parse the 2nd line to determine the type of object
2271  // e.g. "De 15 1 7 0 0" for a via
2272  sscanf( line + SZ( "De" ), " %d %d %d %lX %X", &layer_num, &type, &net_code,
2273  &timeStamp, &flags_int );
2274 
2275  STATUS_FLAGS flags;
2276 
2277  flags = static_cast<STATUS_FLAGS>( flags_int );
2278 
2279  if( aStructType == PCB_TRACE_T )
2280  {
2281  makeType = ( type == 1 ) ? PCB_VIA_T : PCB_TRACE_T;
2282  }
2283  else if (aStructType == NOT_USED )
2284  {
2285  continue;
2286  }
2287  else
2288  {
2289  wxFAIL_MSG( "Segment type unknown" );
2290  continue;
2291  }
2292 
2293  TRACK* newTrack;
2294 
2295  switch( makeType )
2296  {
2297  default:
2298  case PCB_TRACE_T:
2299  newTrack = new TRACK( m_board );
2300  break;
2301 
2302  case PCB_VIA_T:
2303  newTrack = new VIA( m_board );
2304  break;
2305  }
2306 
2307  newTrack->SetTimeStamp( (timestamp_t)timeStamp );
2308  newTrack->SetPosition( wxPoint( start_x, start_y ) );
2309  newTrack->SetEnd( wxPoint( end_x, end_y ) );
2310 
2311  newTrack->SetWidth( width );
2312 
2313  if( makeType == PCB_VIA_T ) // Ensure layers are OK when possible:
2314  {
2315  VIA *via = static_cast<VIA*>( newTrack );
2316  via->SetViaType( viatype );
2317 
2318  if( drill < 0 )
2319  via->SetDrillDefault();
2320  else
2321  via->SetDrill( drill );
2322 
2323  if( via->GetViaType() == VIA_THROUGH )
2324  via->SetLayerPair( F_Cu, B_Cu );
2325  else
2326  {
2327  PCB_LAYER_ID back = leg_layer2new( m_cu_count, (layer_num >> 4) & 0xf );
2328  PCB_LAYER_ID front = leg_layer2new( m_cu_count, layer_num & 0xf );
2329 
2330  if( is_leg_copperlayer_valid( m_cu_count, back ) &&
2332  via->SetLayerPair( front, back );
2333  else
2334  {
2335  delete via;
2336  newTrack = NULL;
2337  }
2338  }
2339  }
2340  else
2341  {
2342  // A few legacy boards can have tracks on non existent layers, because
2343  // reducing the number of layers does not remove tracks on removed layers
2344  // If happens, skip them
2345  if( is_leg_copperlayer_valid( m_cu_count, layer_num ) )
2346  newTrack->SetLayer( leg_layer2new( m_cu_count, layer_num ) );
2347  else
2348  {
2349  delete newTrack;
2350  newTrack = NULL;
2351  }
2352  }
2353 
2354  if( newTrack )
2355  {
2356  newTrack->SetNetCode( getNetCode( net_code ) );
2357  newTrack->SetState( flags, true );
2358 
2359  m_board->Add( newTrack );
2360  }
2361  }
2362 
2363  THROW_IO_ERROR( "Missing '$EndTRACK'" );
2364 }
char * Line() const
Function Line returns a pointer to the last line that was read in.
Definition: richio.h:139
void SetViaType(VIATYPE_T aViaType)
Definition: class_track.h:347
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:105
static int intParse(const char *next, const char **out=NULL)
Function intParse parses an ASCII integer string with possible leading whitespace into an integer and...
the 3d code uses this value
Definition: typeinfo.h:80
static const char delims[]
#define READLINE(rdr)
static PCB_LAYER_ID leg_layer2new(int cu_count, LAYER_NUM aLayerNum)
VIATYPE_T
Definition: class_track.h:60
class TRACK, a track segment (segment on a copper layer)
Definition: typeinfo.h:95
void SetWidth(int aWidth)
Definition: class_track.h:102
BIU biuParse(const char *aValue, const char **nptrptr=NULL)
Function biuParse parses an ASCII decimal floating point value and scales it into a BIU according to ...
PCB_LAYER_ID
A quick note on layer IDs:
LINE_READER * m_reader
no ownership here.
bool is_leg_copperlayer_valid(int aCu_Count, LAYER_NUM aLegacyLayerNum)
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_INSERT) override
Adds an item to the container.
VIATYPE_T GetViaType() const
Definition: class_track.h:346
unsigned STATUS_FLAGS
Definition: base_struct.h:156
bool SetNetCode(int aNetCode, bool aNoAssert=false)
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.
#define THROW_IO_ERROR(msg)
LEGACY_PLUGIN::BIU BIU
BOARD * m_board
which BOARD, no ownership here
void SetDrillDefault()
Function SetDrillDefault sets the drill value for vias to the default value UNDEFINED_DRILL_DIAMETER.
Definition: class_track.h:375
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
void SetState(int type, int state)
Definition: base_struct.h:254
void SetPosition(const wxPoint &aPos) override
Definition: class_track.h:99
char * strtok_r(char *str, const char *delim, char **nextp)
void SetDrill(int aDrill)
Function SetDrill sets the drill value for vias.
Definition: class_track.h:354
class VIA, a via (like a track segment on a copper layer)
Definition: typeinfo.h:96
uint32_t timestamp_t
timestamp_t is our type to represent unique IDs for all kinds of elements; historically simply the ti...
Definition: common.h:50
#define SZ(x)
Get the length of a string constant, at compile time.
int getNetCode(int aNetCode)
Converts net code using the mapping table if available, otherwise returns unchanged net code
#define TESTLINE(x)
C string compare test for a specific length of characters.
void SetTimeStamp(timestamp_t aNewTimeStamp)
Definition: base_struct.h:215

References BOARD::Add(), B_Cu, biuParse(), delims, F_Cu, getNetCode(), VIA::GetViaType(), intParse(), is_leg_copperlayer_valid(), leg_layer2new(), LINE_READER::Line(), m_board, m_cu_count, m_reader, NOT_USED, PCB_TRACE_T, PCB_VIA_T, READLINE, VIA::SetDrill(), VIA::SetDrillDefault(), TRACK::SetEnd(), BOARD_ITEM::SetLayer(), VIA::SetLayerPair(), BOARD_CONNECTED_ITEM::SetNetCode(), TRACK::SetPosition(), EDA_ITEM::SetState(), EDA_ITEM::SetTimeStamp(), VIA::SetViaType(), TRACK::SetWidth(), strtok_r(), SZ, TESTLINE, THROW_IO_ERROR, VIA, and VIA_THROUGH.

Referenced by loadAllSections().

◆ loadZONE_CONTAINER()

void LEGACY_PLUGIN::loadZONE_CONTAINER ( )
protected

Definition at line 2458 of file legacy_plugin.cpp.

2459 {
2460  unique_ptr<ZONE_CONTAINER> zc( new ZONE_CONTAINER( m_board ) );
2461 
2463  bool endContour = false;
2464  int holeIndex = -1; // -1 is the main outline; holeIndex >= 0 = hole index
2465  char buf[1024];
2466  char* line;
2467  char* saveptr;
2468 
2469  while( ( line = READLINE( m_reader ) ) != NULL )
2470  {
2471  const char* data;
2472 
2473  if( TESTLINE( "ZCorner" ) ) // new corner of the zone outlines found
2474  {
2475  // e.g. "ZCorner 25650 49500 0"
2476  BIU x = biuParse( line + SZ( "ZCorner" ), &data );
2477  BIU y = biuParse( data, &data );
2478 
2479  if( endContour )
2480  {
2481  // the previous corner was the last corner of a contour.
2482  // so this corner is the first of a new hole
2483  endContour = false;
2484  zc->NewHole();
2485  holeIndex++;
2486  }
2487 
2488  zc->AppendCorner( wxPoint( x, y ), holeIndex );
2489 
2490  // Is this corner the end of current contour?
2491  // the next corner (if any) will be stored in a new contour (a hole)
2492  // intParse( data )returns 0 = usual corner, 1 = last corner of the current contour:
2493  endContour = intParse( data );
2494  }
2495 
2496  else if( TESTLINE( "ZInfo" ) ) // general info found
2497  {
2498  // e.g. 'ZInfo 479194B1 310 "COMMON"'
2499  timestamp_t timestamp = hexParse( line + SZ( "ZInfo" ), &data );
2500  int netcode = intParse( data, &data );
2501 
2502  if( ReadDelimitedText( buf, data, sizeof(buf) ) > (int) sizeof(buf) )
2503  {
2504  THROW_IO_ERROR( "ZInfo netname too long" );
2505  }
2506 
2507  zc->SetTimeStamp( timestamp );
2508  // Init the net code only, not the netname, to be sure
2509  // the zone net name is the name read in file.
2510  // (When mismatch, the user will be prompted in DRC, to fix the actual name)
2511  zc->BOARD_CONNECTED_ITEM::SetNetCode( getNetCode( netcode ) );
2512  }
2513 
2514  else if( TESTLINE( "ZLayer" ) ) // layer found
2515  {
2516  LAYER_NUM layer_num = layerParse( line + SZ( "ZLayer" ) );
2517  zc->SetLayer( leg_layer2new( m_cu_count, layer_num ) );
2518  }
2519 
2520  else if( TESTLINE( "ZAux" ) ) // aux info found
2521  {
2522  // e.g. "ZAux 7 E"
2523  int ignore = intParse( line + SZ( "ZAux" ), &data );
2524  char* hopt = strtok_r( (char*) data, delims, &saveptr );
2525 
2526  if( !hopt )
2527  {
2528  m_error.Printf( _( "Bad ZAux for CZONE_CONTAINER \"%s\"" ), zc->GetNetname().GetData() );
2530  }
2531 
2532  switch( *hopt ) // upper case required
2533  {
2534  case 'N': outline_hatch = ZONE_CONTAINER::NO_HATCH; break;
2535  case 'E': outline_hatch = ZONE_CONTAINER::DIAGONAL_EDGE; break;
2536  case 'F': outline_hatch = ZONE_CONTAINER::DIAGONAL_FULL; break;
2537 
2538  default:
2539  m_error.Printf( _( "Bad ZAux for CZONE_CONTAINER \"%s\"" ), zc->GetNetname().GetData() );
2541  }
2542 
2543  (void) ignore;
2544 
2545  // Set hatch mode later, after reading corner outline data
2546  }
2547 
2548  else if( TESTLINE( "ZSmoothing" ) )
2549  {
2550  // e.g. "ZSmoothing 0 0"
2551  int smoothing = intParse( line + SZ( "ZSmoothing" ), &data );
2552  BIU cornerRadius = biuParse( data );
2553 
2554  if( smoothing >= ZONE_SETTINGS::SMOOTHING_LAST || smoothing < 0 )
2555  {
2556  m_error.Printf( _( "Bad ZSmoothing for CZONE_CONTAINER \"%s\"" ), zc->GetNetname().GetData() );
2558  }
2559 
2560  zc->SetCornerSmoothingType( smoothing );
2561  zc->SetCornerRadius( cornerRadius );
2562  }
2563 
2564  else if( TESTLINE( "ZKeepout" ) )
2565  {
2566  zc->SetIsKeepout( true );
2567  // e.g. "ZKeepout tracks N vias N pads Y"
2568  data = strtok_r( line + SZ( "ZKeepout" ), delims, &saveptr );
2569 
2570  while( data )
2571  {
2572  if( !strcmp( data, "tracks" ) )
2573  {
2574  data = strtok_r( NULL, delims, &saveptr );
2575  zc->SetDoNotAllowTracks( data && *data == 'N' );
2576  }
2577  else if( !strcmp( data, "vias" ) )
2578  {
2579  data = strtok_r( NULL, delims, &saveptr );
2580  zc->SetDoNotAllowVias( data && *data == 'N' );
2581  }
2582  else if( !strcmp( data, "copperpour" ) )
2583  {
2584  data = strtok_r( NULL, delims, &saveptr );
2585  zc->SetDoNotAllowCopperPour( data && *data == 'N' );
2586  }
2587 
2588  data = strtok_r( NULL, delims, &saveptr );
2589  }
2590  }
2591 
2592  else if( TESTLINE( "ZOptions" ) )
2593  {
2594  // e.g. "ZOptions 0 32 F 200 200"
2595  int fillmode = intParse( line + SZ( "ZOptions" ), &data );
2596  static_cast<void>( intParse( data, &data ) ); // Ignored
2597  char fillstate = data[1]; // here e.g. " F"
2598  BIU thermalReliefGap = biuParse( data += 2 , &data ); // +=2 for " F"
2599  BIU thermalReliefCopperBridge = biuParse( data );
2600 
2601  if( fillmode)
2602  {
2603  // SEGMENT fill mode no longer supported. Make sure user is OK with converting them.
2605  {
2606  KIDIALOG dlg( nullptr,
2607  _( "The legacy segment fill mode is no longer supported.\n"
2608  "Convert zones to polygon fills?"),
2609  _( "Legacy Zone Warning" ),
2610  wxYES_NO | wxICON_WARNING );
2611 
2612  dlg.DoNotShowCheckbox( __FILE__, __LINE__ );
2613 
2614  if( dlg.ShowModal() == wxID_NO )
2615  THROW_IO_ERROR( wxT( "CANCEL" ) );
2616 
2617  m_showLegacyZoneWarning = false;
2618  }
2619 
2620  // User OK'd; switch to polygon mode
2621  zc->SetFillMode( ZFM_POLYGONS );
2622  m_board->SetModified();
2623  }
2624  else
2625  zc->SetFillMode( ZFM_POLYGONS );
2626 
2627  zc->SetIsFilled( fillstate == 'S' );
2628  zc->SetThermalReliefGap( thermalReliefGap );
2629  zc->SetThermalReliefCopperBridge( thermalReliefCopperBridge );
2630  }
2631 
2632  else if( TESTLINE( "ZClearance" ) ) // Clearance and pad options info found
2633  {
2634  // e.g. "ZClearance 40 I"
2635  BIU clearance = biuParse( line + SZ( "ZClearance" ), &data );
2636  char* padoption = strtok_r( (char*) data, delims, &saveptr ); // data: " I"
2637 
2638  ZoneConnection popt;
2639  switch( *padoption )
2640  {
2641  case 'I': popt = PAD_ZONE_CONN_FULL; break;
2642  case 'T': popt = PAD_ZONE_CONN_THERMAL; break;
2643  case 'H': popt = PAD_ZONE_CONN_THT_THERMAL; break;
2644  case 'X': popt = PAD_ZONE_CONN_NONE; break;
2645 
2646  default:
2647  m_error.Printf( _( "Bad ZClearance padoption for CZONE_CONTAINER \"%s\"" ),
2648  zc->GetNetname().GetData() );
2650  }
2651 
2652  zc->SetZoneClearance( clearance );
2653  zc->SetPadConnection( popt );
2654  }
2655 
2656  else if( TESTLINE( "ZMinThickness" ) )
2657  {
2658  BIU thickness = biuParse( line + SZ( "ZMinThickness" ) );
2659  zc->SetMinThickness( thickness );
2660  }
2661 
2662  else if( TESTLINE( "ZPriority" ) )
2663  {
2664  int priority = intParse( line + SZ( "ZPriority" ) );
2665  zc->SetPriority( priority );
2666  }
2667 
2668  else if( TESTLINE( "$POLYSCORNERS" ) )
2669  {
2670  // Read the PolysList (polygons that are the solid areas in the filled zone)
2671  SHAPE_POLY_SET polysList;
2672 
2673  bool makeNewOutline = true;
2674 
2675  while( ( line = READLINE( m_reader ) ) != NULL )
2676  {
2677  if( TESTLINE( "$endPOLYSCORNERS" ) )
2678  break;
2679 
2680  // e.g. "39610 43440 0 0"
2681  BIU x = biuParse( line, &data );
2682  BIU y = biuParse( data, &data );
2683 
2684  if( makeNewOutline )
2685  polysList.NewOutline();
2686 
2687  polysList.Append( x, y );
2688 
2689  bool end_contour = intParse( data, &data ); // end_countour was a bool when file saved, so '0' or '1' here
2690  intParse( data ); // skip corner utility flag
2691 
2692  makeNewOutline = end_contour;
2693  }
2694 
2695  zc->SetFilledPolysList( polysList );
2696  }
2697 
2698  else if( TESTLINE( "$FILLSEGMENTS" ) )
2699  {
2700  while( ( line = READLINE( m_reader ) ) != NULL )
2701  {
2702  if( TESTLINE( "$endFILLSEGMENTS" ) )
2703  break;
2704 
2705  // e.g. ""%d %d %d %d\n"
2706  BIU sx = biuParse( line, &data );
2707  BIU sy = biuParse( data, &data );
2708  BIU ex = biuParse( data, &data );
2709  BIU ey = biuParse( data );
2710 
2711  zc->FillSegments().push_back( SEG( VECTOR2I( sx, sy ), VECTOR2I( ex, ey ) ) );
2712  }
2713  }
2714 
2715  else if( TESTLINE( "$endCZONE_OUTLINE" ) )
2716  {
2717  // Ensure keepout does not have a net
2718  // (which have no sense for a keepout zone)
2719  if( zc->GetIsKeepout() )
2720  zc->SetNetCode( NETINFO_LIST::UNCONNECTED );
2721 
2722  // should always occur, but who knows, a zone without two corners
2723  // is no zone at all, it's a spot?
2724 
2725  if( zc->GetNumCorners() > 2 )
2726  {
2727  if( !zc->IsOnCopperLayer() )
2728  {
2729  zc->SetFillMode( ZFM_POLYGONS );
2730  zc->SetNetCode( NETINFO_LIST::UNCONNECTED );
2731  }
2732 
2733  // Hatch here, after outlines corners are read
2734  // Set hatch here, after outlines corners are read
2735  zc->SetHatch( outline_hatch, ZONE_CONTAINER::GetDefaultHatchPitch(),
2736  true );
2737 
2738  m_board->Add( zc.release() );
2739  }
2740 
2741  return; // preferred exit
2742  }
2743  }
2744 
2745  THROW_IO_ERROR( "Missing '$endCZONE_OUTLINE'" );
2746 }
void SetModified()
Definition: base_struct.cpp:98
Class ZONE_CONTAINER handles a list of polygons defining a copper zone.
Definition: class_zone.h:57
Helper class to create more flexible dialogs, including 'do not show again' checkbox handling.
Definition: confirm.h:44
bool m_showLegacyZoneWarning
static int intParse(const char *next, const char **out=NULL)
Function intParse parses an ASCII integer string with possible leading whitespace into an integer and...
ZoneConnection
How pads are covered by copper in zone.
Definition: zones.h:50
static const char delims[]
static LAYER_NUM layerParse(const char *next, const char **out=NULL)
Function layerParse Like intParse but returns a LAYER_NUM.
#define READLINE(rdr)
static PCB_LAYER_ID leg_layer2new(int cu_count, LAYER_NUM aLayerNum)
VECTOR2< int > VECTOR2I
Definition: vector2d.h:587
static int GetDefaultHatchPitch()
Function GetDefaultHatchPitchMils.
Pads are not covered.
Definition: zones.h:52
BIU biuParse(const char *aValue, const char **nptrptr=NULL)
Function biuParse parses an ASCII decimal floating point value and scales it into a BIU according to ...
LINE_READER * m_reader
no ownership here.
Class SHAPE_POLY_SET.
void Add(BOARD_ITEM *aItem, ADD_MODE aMode=ADD_INSERT) override
Adds an item to the container.
#define THROW_IO_ERROR(msg)
LEGACY_PLUGIN::BIU BIU
HATCH_STYLE
Zone hatch styles.
Definition: class_zone.h:64
int NewOutline()
Creates a new empty polygon in the set and returns its index
#define _(s)
BOARD * m_board
which BOARD, no ownership here
Thermal relief only for THT pads.
Definition: zones.h:55
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
Definition: seg.h:36
wxString m_error
for throwing exceptions
static long hexParse(const char *next, const char **out=NULL)
Function hexParse parses an ASCII hex integer string with possible leading whitespace into a long int...
char * strtok_r(char *str, const char *delim, char **nextp)
uint32_t timestamp_t
timestamp_t is our type to represent unique IDs for all kinds of elements; historically simply the ti...
Definition: common.h:50
int ReadDelimitedText(wxString *aDest, const char *aSource)
Copy bytes from aSource delimited string segment to aDest wxString.
Definition: string.cpp:147
#define SZ(x)
Get the length of a string constant, at compile time.
int getNetCode(int aNetCode)
Converts net code using the mapping table if available, otherwise returns unchanged net code
static const int UNCONNECTED
Constant that holds the "unconnected net" number (typically 0) all items "connected" to this net are ...
Definition: netinfo.h:463
#define TESTLINE(x)
C string compare test for a specific length of characters.
Use thermal relief for pads.
Definition: zones.h:53
pads are covered by copper
Definition: zones.h:54
int Append(int x, int y, int aOutline=-1, int aHole=-1, bool aAllowDuplication=false)
Appends a vertex at the end of the given outline/hole (default: the last outline)

References _, BOARD::Add(), SHAPE_POLY_SET::Append(), biuParse(), delims, ZONE_CONTAINER::DIAGONAL_EDGE, ZONE_CONTAINER::DIAGONAL_FULL, KIDIALOG::DoNotShowCheckbox(), ZONE_CONTAINER::GetDefaultHatchPitch(), getNetCode(), hexParse(), intParse(), layerParse(), leg_layer2new(), m_board, m_cu_count, m_error, m_reader, m_showLegacyZoneWarning, SHAPE_POLY_SET::NewOutline(), ZONE_CONTAINER::NO_HATCH, PAD_ZONE_CONN_FULL, PAD_ZONE_CONN_NONE, PAD_ZONE_CONN_THERMAL, PAD_ZONE_CONN_THT_THERMAL, ReadDelimitedText(), READLINE, EDA_ITEM::SetModified(), KIDIALOG::ShowModal(), ZONE_SETTINGS::SMOOTHING_LAST, strtok_r(), SZ, TESTLINE, THROW_IO_ERROR, NETINFO_LIST::UNCONNECTED, and ZFM_POLYGONS.

Referenced by loadAllSections().

◆ PluginName()

const wxString LEGACY_PLUGIN::PluginName ( ) const
inlineoverridevirtual

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

Implements PLUGIN.

Definition at line 73 of file legacy_plugin.h.

74  {
75  return wxT( "KiCad-Legacy" );
76  }

◆ PrefetchLib()

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

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

performing downloads). Does not parse. Threadsafe.

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

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

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

Reimplemented in GITHUB_PLUGIN.

Definition at line 68 of file plugin.cpp.

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

◆ Save()

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

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

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

Reimplemented in PCB_IO, and CLIPBOARD_IO.

Definition at line 53 of file plugin.cpp.

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

References not_implemented().

Referenced by IO_MGR::Save().

◆ SaveModule3D()

void LEGACY_PLUGIN::SaveModule3D ( const MODULE aModule) const

Definition at line 3075 of file legacy_plugin.cpp.

3076 {
3077  auto sM = me->Models().begin();
3078  auto eM = me->Models().end();
3079 
3080  while( sM != eM )
3081  {
3082  if( sM->m_Filename.empty() )
3083  {
3084  ++sM;
3085  continue;
3086  }
3087 
3088  fprintf( m_fp, "$SHAPE3D\n" );
3089 
3090  fprintf( m_fp, "Na %s\n", EscapedUTF8( sM->m_Filename ).c_str() );
3091 
3092  fprintf(m_fp,
3093 #if defined(DEBUG)
3094  // use old formats for testing, just to verify compatibility
3095  // using "diff", then switch to more concise form for release builds.
3096  "Sc %lf %lf %lf\n",
3097 #else
3098  "Sc %.10g %.10g %.10g\n",
3099 #endif
3100  sM->m_Scale.x,
3101  sM->m_Scale.y,
3102  sM->m_Scale.z );
3103 
3104  fprintf(m_fp,
3105 #if defined(DEBUG)
3106  "Of %lf %lf %lf\n",
3107 #else
3108  "Of %.10g %.10g %.10g\n",
3109 #endif
3110  sM->m_Offset.x,
3111  sM->m_Offset.y,
3112  sM->m_Offset.z );
3113 
3114  fprintf(m_fp,
3115 #if defined(DEBUG)
3116  "Ro %lf %lf %lf\n",
3117 #else
3118  "Ro %.10g %.10g %.10g\n",
3119 #endif
3120  sM->m_Rotation.x,
3121  sM->m_Rotation.y,
3122  sM->m_Rotation.z );
3123 
3124  fprintf( m_fp, "$EndSHAPE3D\n" );
3125 
3126  ++sM;
3127  }
3128 
3129  return;
3130 }
FILE * m_fp
no ownership here.
std::string EscapedUTF8(const wxString &aString)
Function EscapedUTF8 returns an 8 bit UTF8 string given aString in unicode form.
Definition: string.cpp:241

References EscapedUTF8(), m_fp, and MODULE::Models().

◆ SetFilePtr()

void LEGACY_PLUGIN::SetFilePtr ( FILE *  aFile)
inline

Definition at line 107 of file legacy_plugin.h.

107 { m_fp = aFile; }
FILE * m_fp
no ownership here.

References m_fp.

◆ SetReader()

void LEGACY_PLUGIN::SetReader ( LINE_READER aReader)
inline

Definition at line 106 of file legacy_plugin.h.

106 { m_reader = aReader; }
LINE_READER * m_reader
no ownership here.

References m_reader.

Referenced by LP_CACHE::LoadModules().

Friends And Related Function Documentation

◆ LP_CACHE

friend struct LP_CACHE
friend

Definition at line 67 of file legacy_plugin.h.

Referenced by cacheLib().

Member Data Documentation

◆ biuToDisk

double LEGACY_PLUGIN::biuToDisk
protected

convert from BIUs to disk engineering units with this scale factor

Definition at line 139 of file legacy_plugin.h.

Referenced by init().

◆ diskToBiu

double LEGACY_PLUGIN::diskToBiu
protected

convert from disk engineering units to BIUs with this scale factor

Definition at line 142 of file legacy_plugin.h.

Referenced by biuParse(), init(), loadGENERAL(), and LP_CACHE::ReadAndVerifyHeader().

◆ m_board

◆ m_cache

LP_CACHE* LEGACY_PLUGIN::m_cache
protected

◆ m_cu_count

◆ m_error

wxString LEGACY_PLUGIN::m_error
protected

for throwing exceptions

Definition at line 120 of file legacy_plugin.h.

Referenced by biuParse(), checkVersion(), degParse(), loadMODULE_EDGE(), loadNETCLASS(), loadPAD(), loadSHEET(), and loadZONE_CONTAINER().

◆ m_field

wxString LEGACY_PLUGIN::m_field
protected

reused to stuff MODULE fields.

Definition at line 127 of file legacy_plugin.h.

Referenced by loadMODULE_TEXT().

◆ m_fp

FILE* LEGACY_PLUGIN::m_fp
protected

no ownership here.

Definition at line 125 of file legacy_plugin.h.

Referenced by SaveModule3D(), and SetFilePtr().

◆ m_loading_format_version

int LEGACY_PLUGIN::m_loading_format_version
protected

which BOARD_FORMAT_VERSION am I Load()ing?

Definition at line 128 of file legacy_plugin.h.

Referenced by checkVersion(), init(), and loadPAD().

◆ m_mapping

NETINFO_MAPPING* LEGACY_PLUGIN::m_mapping
protected

mapping for net codes, so only not empty nets are stored with consecutive integers as net codes

Definition at line 132 of file legacy_plugin.h.

Referenced by ~LEGACY_PLUGIN().

◆ m_netCodes

std::vector<int> LEGACY_PLUGIN::m_netCodes
protected

net codes mapping for boards being loaded

Definition at line 134 of file legacy_plugin.h.

Referenced by getNetCode(), loadGENERAL(), and loadNETINFO_ITEM().

◆ m_props

const PROPERTIES* LEGACY_PLUGIN::m_props
protected

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

Definition at line 122 of file legacy_plugin.h.

Referenced by init().

◆ m_reader

◆ m_showLegacyZoneWarning

bool LEGACY_PLUGIN::m_showLegacyZoneWarning
protected

Definition at line 130 of file legacy_plugin.h.

Referenced by init(), and loadZONE_CONTAINER().


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