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, bool aBestEfforts, 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 3527 of file legacy_plugin.cpp.

3527  :
3528  m_cu_count( 16 ), // for FootprintLoad()
3529  m_board( 0 ),
3530  m_props( 0 ),
3531  m_reader( 0 ),
3532  m_fp( 0 ),
3533  m_cache( 0 ),
3534  m_mapping( new NETINFO_MAPPING() )
3535 {
3536  init( NULL );
3537 }
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 3540 of file legacy_plugin.cpp.

3541 {
3542  delete m_cache;
3543  delete m_mapping;
3544 }
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 3015 of file legacy_plugin.cpp.

3016 {
3017  char* nptr;
3018 
3019  errno = 0;
3020 
3021  double fval = strtod( aValue, &nptr );
3022 
3023  if( errno )
3024  {
3025  m_error.Printf( _( "invalid float number in file: \"%s\"\nline: %d, offset: %d" ),
3026  m_reader->GetSource().GetData(),
3027  m_reader->LineNumber(), aValue - m_reader->Line() + 1 );
3028 
3030  }
3031 
3032  if( aValue == nptr )
3033  {
3034  m_error.Printf( _( "missing float number in file: \"%s\"\nline: %d, offset: %d" ),
3035  m_reader->GetSource().GetData(),
3036  m_reader->LineNumber(), aValue - m_reader->Line() + 1 );
3037 
3039  }
3040 
3041  if( nptrptr )
3042  *nptrptr = nptr;
3043 
3044  fval *= diskToBiu;
3045 
3046  // fval is up into the whole number realm here, and should be bounded
3047  // within INT_MIN to INT_MAX since BIU's are nanometers.
3048  return KiROUND( fval );
3049 }
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)
double diskToBiu
convert from disk engineering units to BIUs with this scale factor
#define _(s)
wxString m_error
for throwing exceptions
constexpr ret_type KiROUND(fp_type v)
Round a floating point number to an integer using "round halfway cases away from zero".
Definition: common.h:114

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

3418 {
3419  if( !m_cache || m_cache->m_lib_path != aLibraryPath || m_cache->IsModified() )
3420  {
3421  // a spectacular episode in memory management:
3422  delete m_cache;
3423  m_cache = new LP_CACHE( this, aLibraryPath );
3424  m_cache->Load();
3425  }
3426 }
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:265
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 3052 of file legacy_plugin.cpp.

3053 {
3054  char* nptr;
3055 
3056  errno = 0;
3057 
3058  double fval = strtod( aValue, &nptr );
3059 
3060  if( errno )
3061  {
3062  m_error.Printf( _( "invalid float number in file: \"%s\"\nline: %d, offset: %d" ),
3063  m_reader->GetSource().GetData(), m_reader->LineNumber(), aValue - m_reader->Line() + 1 );
3064 
3066  }
3067 
3068  if( aValue == nptr )
3069  {
3070  m_error.Printf( _( "missing float number in file: \"%s\"\nline: %d, offset: %d" ),
3071  m_reader->GetSource().GetData(), m_reader->LineNumber(), aValue - m_reader->Line() + 1 );
3072 
3074  }
3075 
3076  if( nptrptr )
3077  *nptrptr = nptr;
3078 
3079  return fval;
3080 }
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,
bool  aBestEfforts,
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.
aBestEffortsif true, don't throw on errors, just return an empty list.
Exceptions
IO_ERRORif the library cannot be found, or footprint cannot be loaded.

Reimplemented from PLUGIN.

Definition at line 3429 of file legacy_plugin.cpp.

3431 {
3432  LOCALE_IO toggle; // toggles on, then off, the C locale.
3433  wxString errorMsg;
3434 
3435  init( aProperties );
3436 
3437  try
3438  {
3439  cacheLib( aLibPath );
3440  }
3441  catch( const IO_ERROR& ioe )
3442  {
3443  errorMsg = ioe.What();
3444  }
3445 
3446  // Some of the files may have been parsed correctly so we want to add the valid files to
3447  // the library.
3448 
3449  for( MODULE_CITER it = m_cache->m_modules.begin(); it != m_cache->m_modules.end(); ++it )
3450  aFootprintNames.Add( FROM_UTF8( it->first.c_str() ) );
3451 
3452  if( !errorMsg.IsEmpty() && !aBestEfforts )
3453  THROW_IO_ERROR( errorMsg );
3454 }
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:154
virtual const wxString What() const
A composite of Problem() and Where()
Definition: exceptions.cpp:33
void init(const PROPERTIES *aProperties)
initialize PLUGIN like a constructor would, and futz with fresh BOARD if needed.
#define THROW_IO_ERROR(msg)
MODULE_MAP::const_iterator MODULE_CITER
Struct IO_ERROR is a class used to hold an error message and may be used when throwing exceptions con...
Definition: ki_exception.h:76
MODULE_MAP m_modules
LP_CACHE * m_cache

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

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

3486 {
3487  wxFileName fn = aLibraryPath;
3488 
3489  if( !fn.FileExists() )
3490  return false;
3491 
3492  // Some of the more elaborate wxRemoveFile() crap puts up its own wxLog dialog
3493  // we don't want that. we want bare metal portability with no UI here.
3494  if( wxRemove( aLibraryPath ) )
3495  {
3497  _( "library \"%s\" cannot be deleted" ),
3498  aLibraryPath.GetData() ) );
3499  }
3500 
3501  if( m_cache && m_cache->m_lib_path == aLibraryPath )
3502  {
3503  delete m_cache;
3504  m_cache = 0;
3505  }
3506 
3507  return true;
3508 }
#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 3457 of file legacy_plugin.cpp.

3459 {
3460  LOCALE_IO toggle; // toggles on, then off, the C locale.
3461 
3462  init( aProperties );
3463 
3464  cacheLib( aLibraryPath );
3465 
3466  const MODULE_MAP& mods = m_cache->m_modules;
3467 
3468  MODULE_CITER it = mods.find( TO_UTF8( aFootprintName ) );
3469 
3470  if( it == mods.end() )
3471  {
3472  /*
3473  THROW_IO_ERROR( wxString::Format( _( "No \"%s\" footprint in library \"%s\"" ),
3474  aFootprintName.GetData(), aLibraryPath.GetData() ) );
3475  */
3476 
3477  return NULL;
3478  }
3479 
3480  // copy constructor to clone the already loaded MODULE
3481  return new MODULE( *it->second );
3482 }
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:154
#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 3411 of file legacy_plugin.cpp.

3412 {
3413  return LP_CACHE::GetTimestamp( aLibraryPath );
3414 }
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 3083 of file legacy_plugin.cpp.

3084 {
3086  m_cu_count = 16;
3087  m_board = NULL;
3088  m_showLegacyZoneWarning = true;
3089  m_props = aProperties;
3090 
3091  // conversion factor for saving RAM BIUs to KICAD legacy file format.
3092  biuToDisk = 1.0/IU_PER_MM; // BIUs are nanometers & file is mm
3093 
3094  // Conversion factor for loading KICAD legacy file format into BIUs in RAM
3095  // Start by assuming the *.brd file is in deci-mils.
3096  // If we see "Units mm" in the $GENERAL section, set diskToBiu to 1000000.0
3097  // then, during the file loading process, to start a conversion from
3098  // mm to nanometers. The deci-mil legacy files have no such "Units" marker
3099  // so we must assume the file is in deci-mils until told otherwise.
3100 
3101  diskToBiu = IU_PER_MILS / 10; // BIUs are nanometers
3102 }
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:136
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 3511 of file legacy_plugin.cpp.

3512 {
3513 #if 0 // no support for 32 Cu layers in legacy format
3514  return false;
3515 #else
3516  LOCALE_IO toggle;
3517 
3518  init( NULL );
3519 
3520  cacheLib( aLibraryPath );
3521 
3522  return m_cache->m_writable;
3523 #endif
3524 }
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:154
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:649

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:154
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:214
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 1896 of file legacy_plugin.cpp.

1897 {
1898  MODULE_3D_SETTINGS t3D;
1899 
1900  char* line;
1901  while( ( line = READLINE( m_reader ) ) != NULL )
1902  {
1903  if( TESTLINE( "Na" ) ) // Shape File Name
1904  {
1905  char buf[512];
1906  ReadDelimitedText( buf, line + SZ( "Na" ), sizeof(buf) );
1907  t3D.m_Filename = buf;
1908  }
1909 
1910  else if( TESTLINE( "Sc" ) ) // Scale
1911  {
1912  sscanf( line + SZ( "Sc" ), "%lf %lf %lf\n",
1913  &t3D.m_Scale.x,
1914  &t3D.m_Scale.y,
1915  &t3D.m_Scale.z );
1916  }
1917 
1918  else if( TESTLINE( "Of" ) ) // Offset
1919  {
1920  sscanf( line + SZ( "Of" ), "%lf %lf %lf\n",
1921  &t3D.m_Offset.x,
1922  &t3D.m_Offset.y,
1923  &t3D.m_Offset.z );
1924  }
1925 
1926  else if( TESTLINE( "Ro" ) ) // Rotation
1927  {
1928  sscanf( line + SZ( "Ro" ), "%lf %lf %lf\n",
1929  &t3D.m_Rotation.x,
1930  &t3D.m_Rotation.y,
1931  &t3D.m_Rotation.z );
1932  }
1933 
1934  else if( TESTLINE( "$EndSHAPE3D" ) )
1935  {
1936  aModule->Models().push_back( t3D );
1937  return; // preferred exit
1938  }
1939  }
1940 
1941  THROW_IO_ERROR( "Missing '$EndSHAPE3D'" );
1942 }
#define READLINE(rdr)
VECTOR3D m_Offset
3D model offset (mm)
Definition: class_module.h:102
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:103
std::list< MODULE_3D_SETTINGS > & Models()
Definition: class_module.h:208
VECTOR3D m_Rotation
3D model rotation (degrees)
Definition: class_module.h:101
VECTOR3D m_Scale
3D model scaling factor (dimensionless)
Definition: class_module.h:100
int ReadDelimitedText(wxString *aDest, const char *aSource)
Copy bytes from aSource delimited string segment to aDest wxString.
Definition: string.cpp:155
#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:310
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:680
#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:96
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 2779 of file legacy_plugin.cpp.

2780 {
2781  unique_ptr<DIMENSION> dim( new DIMENSION( m_board ) );
2782 
2783  char* line;
2784  char* saveptr;
2785 
2786  while( ( line = READLINE( m_reader ) ) != NULL )
2787  {
2788  const char* data;
2789 
2790  if( TESTLINE( "$endCOTATION" ) )
2791  {
2792  m_board->Add( dim.release(), ADD_APPEND );
2793  return; // preferred exit
2794  }
2795 
2796  else if( TESTLINE( "Va" ) )
2797  {
2798  BIU value = biuParse( line + SZ( "Va" ) );
2799  dim->SetValue( value );
2800  }
2801 
2802  else if( TESTLINE( "Ge" ) )
2803  {
2804  LAYER_NUM layer_num;
2805  unsigned long timestamp;
2806  int shape;
2807  int ilayer;
2808 
2809  sscanf( line + SZ( "Ge" ), " %d %d %lX", &shape, &ilayer, &timestamp );
2810 
2811  if( ilayer < FIRST_NON_COPPER_LAYER )
2812  layer_num = FIRST_NON_COPPER_LAYER;
2813  else if( ilayer > LAST_NON_COPPER_LAYER )
2814  layer_num = LAST_NON_COPPER_LAYER;
2815  else
2816  layer_num = ilayer;
2817 
2818  dim->SetLayer( leg_layer2new( m_cu_count, layer_num ) );
2819  dim->SetTimeStamp( (timestamp_t) timestamp );
2820  dim->SetShape( shape );
2821  }
2822 
2823  else if( TESTLINE( "Te" ) )
2824  {
2825  char buf[2048];
2826 
2827  ReadDelimitedText( buf, line + SZ( "Te" ), sizeof(buf) );
2828  dim->SetText( FROM_UTF8( buf ) );
2829  }
2830 
2831  else if( TESTLINE( "Po" ) )
2832  {
2833  // sscanf( Line + 2, " %d %d %d %d %d %d %d", &m_Text->m_Pos.x, &m_Text->m_Pos.y,
2834  // &m_Text->m_Size.x, &m_Text->m_Size.y, &thickness, &orientation, &normal_display );
2835 
2836  BIU pos_x = biuParse( line + SZ( "Po" ), &data );
2837  BIU pos_y = biuParse( data, &data );
2838  BIU width = biuParse( data, &data );
2839  BIU height = biuParse( data, &data );
2840  BIU thickn = biuParse( data, &data );
2841  double orient = degParse( data, &data );
2842  char* mirror = strtok_r( (char*) data, delims, &saveptr );
2843 
2844  // This sets both DIMENSION's position and internal m_Text's.
2845  // @todo: But why do we even know about internal m_Text?
2846  dim->SetPosition( wxPoint( pos_x, pos_y ) );
2847  dim->SetTextSize( wxSize( width, height ) );
2848 
2849  dim->Text().SetMirrored( mirror && *mirror == '0' );
2850  dim->Text().SetThickness( thickn );
2851  dim->Text().SetTextAngle( orient );
2852  }
2853 
2854  else if( TESTLINE( "Sb" ) )
2855  {
2856  // sscanf( Line + 2, " %d %d %d %d %d %d", &Dummy, &m_crossBarOx, &m_crossBarOy, &m_crossBarFx, &m_crossBarFy, &m_Width );
2857 
2858  int ignore = biuParse( line + SZ( "Sb" ), &data );
2859  BIU crossBarOx = biuParse( data, &data );
2860  BIU crossBarOy = biuParse( data, &data );
2861  BIU crossBarFx = biuParse( data, &data );
2862  BIU crossBarFy = biuParse( data, &data );
2863  BIU width = biuParse( data );
2864 
2865  dim->m_crossBarO.x = crossBarOx;
2866  dim->m_crossBarO.y = crossBarOy;
2867  dim->m_crossBarF.x = crossBarFx;
2868  dim->m_crossBarF.y = crossBarFy;
2869  dim->SetWidth( width );
2870  (void) ignore;
2871  }
2872 
2873  else if( TESTLINE( "Sd" ) )
2874  {
2875  // sscanf( Line + 2, " %d %d %d %d %d %d", &Dummy, &m_featureLineDOx, &m_featureLineDOy, &m_featureLineDFx, &m_featureLineDFy, &Dummy );
2876 
2877  int ignore = intParse( line + SZ( "Sd" ), &data );
2878  BIU featureLineDOx = biuParse( data, &data );
2879  BIU featureLineDOy = biuParse( data, &data );
2880  BIU featureLineDFx = biuParse( data, &data );
2881  BIU featureLineDFy = biuParse( data );
2882 
2883  dim->m_featureLineDO.x = featureLineDOx;
2884  dim->m_featureLineDO.y = featureLineDOy;
2885  dim->m_featureLineDF.x = featureLineDFx;
2886  dim->m_featureLineDF.y = featureLineDFy;
2887  (void) ignore;
2888  }
2889 
2890  else if( TESTLINE( "Sg" ) )
2891  {
2892  // sscanf( Line + 2, " %d %d %d %d %d %d", &Dummy, &m_featureLineGOx, &m_featureLineGOy, &m_featureLineGFx, &m_featureLineGFy, &Dummy );
2893 
2894  int ignore = intParse( line + SZ( "Sg" ), &data );
2895  BIU featureLineGOx = biuParse( data, &data );
2896  BIU featureLineGOy = biuParse( data, &data );
2897  BIU featureLineGFx = biuParse( data, &data );
2898  BIU featureLineGFy = biuParse( data );
2899 
2900  dim->m_featureLineGO.x = featureLineGOx;
2901  dim->m_featureLineGO.y = featureLineGOy;
2902  dim->m_featureLineGF.x = featureLineGFx;
2903  dim->m_featureLineGF.y = featureLineGFy;
2904  (void) ignore;
2905  }
2906 
2907  else if( TESTLINE( "S1" ) )
2908  {
2909  // sscanf( Line + 2, " %d %d %d %d %d %d", &Dummy, &m_arrowD1Ox, &m_arrowD1Oy, &m_arrowD1Fx, &m_arrowD1Fy, &Dummy );
2910 
2911  int ignore = intParse( line + SZ( "S1" ), &data );
2912  biuParse( data, &data ); // skipping excessive data
2913  biuParse( data, &data ); // skipping excessive data
2914  BIU arrowD1Fx = biuParse( data, &data );
2915  BIU arrowD1Fy = biuParse( data );
2916 
2917  dim->m_arrowD1F.x = arrowD1Fx;
2918  dim->m_arrowD1F.y = arrowD1Fy;
2919  (void) ignore;
2920  }
2921 
2922  else if( TESTLINE( "S2" ) )
2923  {
2924  // sscanf( Line + 2, " %d %d %d %d %d %d", &Dummy, &m_arrowD2Ox, &m_arrowD2Oy, &m_arrowD2Fx, &m_arrowD2Fy, &Dummy );
2925 
2926  int ignore = intParse( line + SZ( "S2" ), &data );
2927  biuParse( data, &data ); // skipping excessive data
2928  biuParse( data, &data ); // skipping excessive data
2929  BIU arrowD2Fx = biuParse( data, &data );
2930  BIU arrowD2Fy = biuParse( data, &data );
2931 
2932  dim->m_arrowD2F.x = arrowD2Fx;
2933  dim->m_arrowD2F.y = arrowD2Fy;
2934  (void) ignore;
2935  }
2936 
2937  else if( TESTLINE( "S3" ) )
2938  {
2939  // sscanf( Line + 2, " %d %d %d %d %d %d\n", &Dummy, &m_arrowG1Ox, &m_arrowG1Oy, &m_arrowG1Fx, &m_arrowG1Fy, &Dummy );
2940  int ignore = intParse( line + SZ( "S3" ), &data );
2941  biuParse( data, &data ); // skipping excessive data
2942  biuParse( data, &data ); // skipping excessive data
2943  BIU arrowG1Fx = biuParse( data, &data );
2944  BIU arrowG1Fy = biuParse( data, &data );
2945 
2946  dim->m_arrowG1F.x = arrowG1Fx;
2947  dim->m_arrowG1F.y = arrowG1Fy;
2948  (void) ignore;
2949  }
2950 
2951  else if( TESTLINE( "S4" ) )
2952  {
2953  // sscanf( Line + 2, " %d %d %d %d %d %d", &Dummy, &m_arrowG2Ox, &m_arrowG2Oy, &m_arrowG2Fx, &m_arrowG2Fy, &Dummy );
2954  int ignore = intParse( line + SZ( "S4" ), &data );
2955  biuParse( data, &data ); // skipping excessive data
2956  biuParse( data, &data ); // skipping excessive data
2957  BIU arrowG2Fx = biuParse( data, &data );
2958  BIU arrowG2Fy = biuParse( data, &data );
2959 
2960  dim->m_arrowG2F.x = arrowG2Fx;
2961  dim->m_arrowG2F.y = arrowG2Fy;
2962  (void) ignore;
2963  }
2964  }
2965 
2966  THROW_IO_ERROR( "Missing '$endCOTATION'" );
2967 }
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:53
int ReadDelimitedText(wxString *aDest, const char *aSource)
Copy bytes from aSource delimited string segment to aDest wxString.
Definition: string.cpp:155
#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:531
#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 1193 of file legacy_plugin.cpp.

1194 {
1195  char* line;
1196  char* saveptr;
1197 
1198  while( ( line = READLINE( m_reader ) ) != NULL )
1199  {
1200  const char* data;
1201 
1202  // most frequently encountered ones at the top
1203 
1204  if( TESTSUBSTR( "D" ) && strchr( "SCAP", line[1] ) ) // read a drawing item, e.g. "DS"
1205  {
1206  loadMODULE_EDGE( aModule );
1207  }
1208 
1209  else if( TESTLINE( "$PAD" ) )
1210  {
1211  loadPAD( aModule );
1212  }
1213 
1214  // Read a footprint text description (ref, value, or drawing)
1215  else if( TESTSUBSTR( "T" ) )
1216  {
1217  // e.g. "T1 6940 -16220 350 300 900 60 M I 20 N "CFCARD"\r\n"
1218 
1219  int tnum = intParse( line + SZ( "T" ) );
1220 
1221  TEXTE_MODULE* textm = 0;
1222 
1223  switch( tnum )
1224  {
1226  textm = &aModule->Reference();
1227  break;
1228 
1230  textm = &aModule->Value();
1231  break;
1232 
1233  // All other fields greater than 1.
1234  default:
1235  textm = new TEXTE_MODULE( aModule );
1236  aModule->Add( textm );
1237  }
1238 
1239  loadMODULE_TEXT( textm );
1240  }
1241 
1242  else if( TESTLINE( "Po" ) )
1243  {
1244  // e.g. "Po 19120 39260 900 0 4E823D06 46EAAFA5 ~~\r\n"
1245 
1246  // 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 );
1247 
1248  BIU pos_x = biuParse( line + SZ( "Po" ), &data );
1249  BIU pos_y = biuParse( data, &data );
1250  int orient = intParse( data, &data );
1251 
1252  LAYER_NUM layer_num = layerParse( data, &data );
1253  PCB_LAYER_ID layer_id = leg_layer2new( m_cu_count, layer_num );
1254 
1255  long edittime = hexParse( data, &data );
1256  timestamp_t timestamp = hexParse( data, &data );
1257 
1258  data = strtok_r( (char*) data+1, delims, &saveptr );
1259 
1260  // data is now a two character long string
1261  // Note: some old files do not have this field
1262  if( data && data[0] == 'F' )
1263  aModule->SetLocked( true );
1264 
1265  if( data && data[1] == 'P' )
1266  aModule->SetIsPlaced( true );
1267 
1268  aModule->SetPosition( wxPoint( pos_x, pos_y ) );
1269  aModule->SetLayer( layer_id );
1270  aModule->SetOrientation( orient );
1271  aModule->SetTimeStamp( timestamp );
1272  aModule->SetLastEditTime( edittime );
1273  }
1274 
1275  /* footprint name set earlier, immediately after MODULE construction
1276  else if( TESTLINE( "Li" ) ) // Library name of footprint
1277  {
1278  // There can be whitespace in the footprint name on some old libraries.
1279  // Grab everything after "Li" up to end of line:
1280  //aModule->SetFPID( FROM_UTF8( StrPurge( line + SZ( "Li" ) ) ) );
1281  }
1282  */
1283 
1284  else if( TESTLINE( "Sc" ) ) // timestamp
1285  {
1286  timestamp_t timestamp = hexParse( line + SZ( "Sc" ) );
1287  aModule->SetTimeStamp( timestamp );
1288  }
1289 
1290  else if( TESTLINE( "Op" ) ) // (Op)tions for auto placement
1291  {
1292  int itmp1 = hexParse( line + SZ( "Op" ), &data );
1293  int itmp2 = hexParse( data );
1294 
1295  int cntRot180 = itmp2 & 0x0F;
1296  if( cntRot180 > 10 )
1297  cntRot180 = 10;
1298 
1299  aModule->SetPlacementCost180( cntRot180 );
1300 
1301  int cntRot90 = itmp1 & 0x0F;
1302  if( cntRot90 > 10 )
1303  cntRot90 = 0;
1304 
1305  itmp1 = (itmp1 >> 4) & 0x0F;
1306  if( itmp1 > 10 )
1307  itmp1 = 0;
1308 
1309  aModule->SetPlacementCost90( (itmp1 << 4) | cntRot90 );
1310  }
1311 
1312  else if( TESTLINE( "At" ) ) // (At)tributes of module
1313  {
1314  int attrs = MOD_DEFAULT;
1315 
1316  data = line + SZ( "At" );
1317 
1318  if( strstr( data, "SMD" ) )
1319  attrs |= MOD_CMS;
1320 
1321  if( strstr( data, "VIRTUAL" ) )
1322  attrs |= MOD_VIRTUAL;
1323 
1324  aModule->SetAttributes( attrs );
1325  }
1326 
1327  else if( TESTLINE( "AR" ) ) // Alternate Reference
1328  {
1329  // e.g. "AR /47BA2624/45525076"
1330  data = strtok_r( line + SZ( "AR" ), delims, &saveptr );
1331  if( data )
1332  aModule->SetPath( FROM_UTF8( data ) );
1333  }
1334 
1335  else if( TESTLINE( "$SHAPE3D" ) )
1336  {
1337  load3D( aModule );
1338  }
1339 
1340  else if( TESTLINE( "Cd" ) )
1341  {
1342  // e.g. "Cd Double rangee de contacts 2 x 4 pins\r\n"
1343  aModule->SetDescription( FROM_UTF8( StrPurge( line + SZ( "Cd" ) ) ) );
1344  }
1345 
1346  else if( TESTLINE( "Kw" ) ) // Key words
1347  {
1348  aModule->SetKeywords( FROM_UTF8( StrPurge( line + SZ( "Kw" ) ) ) );
1349  }
1350 
1351  else if( TESTLINE( ".SolderPasteRatio" ) )
1352  {
1353  double tmp = atof( line + SZ( ".SolderPasteRatio" ) );
1354  // Due to a bug in dialog editor in Modedit, fixed in BZR version 3565
1355  // this parameter can be broken.
1356  // It should be >= -50% (no solder paste) and <= 0% (full area of the pad)
1357 
1358  if( tmp < -0.50 )
1359  tmp = -0.50;
1360  if( tmp > 0.0 )
1361  tmp = 0.0;
1362  aModule->SetLocalSolderPasteMarginRatio( tmp );
1363  }
1364 
1365  else if( TESTLINE( ".SolderPaste" ) )
1366  {
1367  BIU tmp = biuParse( line + SZ( ".SolderPaste" ) );
1368  aModule->SetLocalSolderPasteMargin( tmp );
1369  }
1370 
1371  else if( TESTLINE( ".SolderMask" ) )
1372  {
1373  BIU tmp = biuParse( line + SZ( ".SolderMask" ) );
1374  aModule->SetLocalSolderMaskMargin( tmp );
1375  }
1376 
1377  else if( TESTLINE( ".LocalClearance" ) )
1378  {
1379  BIU tmp = biuParse( line + SZ( ".LocalClearance" ) );
1380  aModule->SetLocalClearance( tmp );
1381  }
1382 
1383  else if( TESTLINE( ".ZoneConnection" ) )
1384  {
1385  int tmp = intParse( line + SZ( ".ZoneConnection" ) );
1386  aModule->SetZoneConnection( (ZoneConnection)tmp );
1387  }
1388 
1389  else if( TESTLINE( ".ThermalWidth" ) )
1390  {
1391  BIU tmp = biuParse( line + SZ( ".ThermalWidth" ) );
1392  aModule->SetThermalWidth( tmp );
1393  }
1394 
1395  else if( TESTLINE( ".ThermalGap" ) )
1396  {
1397  BIU tmp = biuParse( line + SZ( ".ThermalGap" ) );
1398  aModule->SetThermalGap( tmp );
1399  }
1400 
1401  else if( TESTLINE( "$EndMODULE" ) )
1402  {
1403  aModule->CalculateBoundingBox();
1404 
1405  return; // preferred exit
1406  }
1407  }
1408 
1409  wxString msg = wxString::Format(
1410  _( "Missing '$EndMODULE' for MODULE \"%s\"" ),
1411  GetChars( aModule->GetFPID().GetLibItemName() ) );
1412 
1413  THROW_IO_ERROR( msg );
1414 }
void SetPlacementCost90(int aCost)
Definition: class_module.h:552
const UTF8 & GetLibItemName() const
Definition: lib_id.h:114
TEXTE_MODULE & Reference()
Definition: class_module.h:473
void SetThermalGap(int aGap)
Definition: class_module.h:252
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:310
void SetLocalClearance(int aClearance)
Definition: class_module.h:238
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:549
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:77
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:246
const LIB_ID & GetFPID() const
Definition: class_module.h:222
#define READLINE(rdr)
static PCB_LAYER_ID leg_layer2new(int cu_count, LAYER_NUM aLayerNum)
void SetLocalSolderPasteMarginRatio(double aRatio)
Definition: class_module.h:244
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:472
void loadMODULE_EDGE(MODULE *aModule)
void SetLastEditTime(timestamp_t aTime)
Definition: class_module.h:343
void SetThermalWidth(int aWidth)
Definition: class_module.h:249
#define THROW_IO_ERROR(msg)
void SetIsPlaced(bool isPlaced)
Definition: class_module.h:316
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:235
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
default
Definition: class_module.h:76
void SetLocalSolderPasteMargin(int aMargin)
Definition: class_module.h:241
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:307
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:79
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:229
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:53
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:232
void SetAttributes(int aAttributes)
Definition: class_module.h:256
void SetTimeStamp(timestamp_t aNewTimeStamp)
Definition: base_struct.h:215
void SetDescription(const wxString &aDoc)
Definition: class_module.h:226

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

1657 {
1658  STROKE_T shape;
1659  char* line = m_reader->Line(); // obtain current (old) line
1660 
1661  switch( line[1] )
1662  {
1663  case 'S': shape = S_SEGMENT; break;
1664  case 'C': shape = S_CIRCLE; break;
1665  case 'A': shape = S_ARC; break;
1666  case 'P': shape = S_POLYGON; break;
1667  default:
1668  m_error.Printf( _( "Unknown EDGE_MODULE type:'%c=0x%02x' on line:%d of footprint:\"%s\"" ),
1669  (unsigned char) line[1],
1670  (unsigned char) line[1],
1671  m_reader->LineNumber(),
1672  GetChars( aModule->GetFPID().GetLibItemName() )
1673  );
1675  }
1676 
1677  unique_ptr<EDGE_MODULE> dwg( new EDGE_MODULE( aModule, shape ) ); // a drawing
1678 
1679  const char* data;
1680 
1681  // common to all cases, and we have to check their values uniformly at end
1682  BIU width = 1;
1684 
1685  switch( shape )
1686  {
1687  case S_ARC:
1688  {
1689  // 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 );
1690  BIU start0_x = biuParse( line + SZ( "DA" ), &data );
1691  BIU start0_y = biuParse( data, &data );
1692  BIU end0_x = biuParse( data, &data );
1693  BIU end0_y = biuParse( data, &data );
1694  double angle = degParse( data, &data );
1695 
1696  width = biuParse( data, &data );
1697  layer = layerParse( data );
1698 
1699  dwg->SetAngle( angle );
1700  dwg->m_Start0 = wxPoint( start0_x, start0_y );
1701  dwg->m_End0 = wxPoint( end0_x, end0_y );
1702  }
1703  break;
1704 
1705  case S_SEGMENT:
1706  case S_CIRCLE:
1707  {
1708  // e.g. "DS -7874 -10630 7874 -10630 50 20\r\n"
1709  // 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 );
1710 
1711  BIU start0_x = biuParse( line + SZ( "DS" ), &data );
1712  BIU start0_y = biuParse( data, &data );
1713  BIU end0_x = biuParse( data, &data );
1714  BIU end0_y = biuParse( data, &data );
1715 
1716  width = biuParse( data, &data );
1717  layer = layerParse( data );
1718 
1719  dwg->m_Start0 = wxPoint( start0_x, start0_y );
1720  dwg->m_End0 = wxPoint( end0_x, end0_y );
1721  }
1722  break;
1723 
1724  case S_POLYGON:
1725  {
1726  // e.g. "DP %d %d %d %d %d %d %d\n"
1727  // 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 );
1728 
1729  BIU start0_x = biuParse( line + SZ( "DP" ), &data );
1730  BIU start0_y = biuParse( data, &data );
1731  BIU end0_x = biuParse( data, &data );
1732  BIU end0_y = biuParse( data, &data );
1733  int ptCount = intParse( data, &data );
1734 
1735  width = biuParse( data, &data );
1736  layer = layerParse( data );
1737 
1738  dwg->m_Start0 = wxPoint( start0_x, start0_y );
1739  dwg->m_End0 = wxPoint( end0_x, end0_y );
1740 
1741  std::vector<wxPoint> pts;
1742  pts.reserve( ptCount );
1743 
1744  for( int ii = 0; ii<ptCount; ++ii )
1745  {
1746  if( ( line = READLINE( m_reader ) ) == NULL )
1747  {
1748  THROW_IO_ERROR( "S_POLGON point count mismatch." );
1749  }
1750 
1751  // e.g. "Dl 23 44\n"
1752 
1753  if( !TESTLINE( "Dl" ) )
1754  {
1755  THROW_IO_ERROR( "Missing Dl point def" );
1756  }
1757 
1758  BIU x = biuParse( line + SZ( "Dl" ), &data );
1759  BIU y = biuParse( data );
1760 
1761  pts.emplace_back( x, y );
1762  }
1763 
1764  dwg->SetPolyPoints( pts );
1765  }
1766  break;
1767 
1768  default:
1769  // first switch code above prevents us from getting here.
1770  break;
1771  }
1772 
1773  // Check for a reasonable layer:
1774  // m_Layer must be >= FIRST_NON_COPPER_LAYER, but because microwave footprints
1775  // can use the copper layers m_Layer < FIRST_NON_COPPER_LAYER is allowed.
1776  // @todo: changes use of EDGE_MODULE these footprints and allows only
1777  // m_Layer >= FIRST_NON_COPPER_LAYER
1778  if( layer < FIRST_LAYER || layer > LAST_NON_COPPER_LAYER )
1779  layer = SILKSCREEN_N_FRONT;
1780 
1781  dwg->SetWidth( width );
1782  dwg->SetLayer( leg_layer2new( m_cu_count, layer ) );
1783 
1784  EDGE_MODULE* em = dwg.release();
1785 
1786  aModule->Add( em );
1787 
1788  // this had been done at the MODULE level before, presumably because the
1789  // EDGE_MODULE needs to be already added to a module before this function will work.
1790  em->SetDrawCoord();
1791 }
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:222
#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 1794 of file legacy_plugin.cpp.

1795 {
1796  const char* data;
1797  const char* txt_end;
1798  const char* line = m_reader->Line(); // current (old) line
1799  char* saveptr;
1800 
1801  // sscanf( line + 1, "%d %d %d %d %d %d %d %s %s %d %s",
1802  // &type, &m_Pos0.x, &m_Pos0.y, &m_Size.y, &m_Size.x,
1803  // &m_Orient, &m_Thickness, BufCar1, BufCar2, &layer, BufCar3 ) >= 10 )
1804 
1805  // e.g. "T1 6940 -16220 350 300 900 60 M I 20 N "CFCARD"\r\n"
1806  // or T1 0 500 600 400 900 80 M V 20 N"74LS245"
1807  // ouch, the last example has no space between N and "74LS245" !
1808  // that is an older version.
1809 
1810  int type = intParse( line+1, &data );
1811  BIU pos0_x = biuParse( data, &data );
1812  BIU pos0_y = biuParse( data, &data );
1813  BIU size0_y = biuParse( data, &data );
1814  BIU size0_x = biuParse( data, &data );
1815  double orient = degParse( data, &data );
1816  BIU thickn = biuParse( data, &data );
1817 
1818  // read the quoted text before the first call to strtok() which introduces
1819  // NULs into the string and chops it into mutliple C strings, something
1820  // ReadDelimitedText() cannot traverse.
1821 
1822  // convert the "quoted, escaped, UTF8, text" to a wxString, find it by skipping
1823  // as far forward as needed until the first double quote.
1824  txt_end = data + ReadDelimitedText( &m_field, data );
1825 
1826  aText->SetText( m_field );
1827 
1828  // after switching to strtok, there's no easy coming back because of the
1829  // embedded nul(s?) placed to the right of the current field.
1830  // (that's the reason why strtok was deprecated...)
1831  char* mirror = strtok_r( (char*) data, delims, &saveptr );
1832  char* hide = strtok_r( NULL, delims, &saveptr );
1833  char* tmp = strtok_r( NULL, delims, &saveptr );
1834 
1835  LAYER_NUM layer_num = tmp ? layerParse( tmp ) : SILKSCREEN_N_FRONT;
1836 
1837  char* italic = strtok_r( NULL, delims, &saveptr );
1838 
1839  char* hjust = strtok_r( (char*) txt_end, delims, &saveptr );
1840  char* vjust = strtok_r( NULL, delims, &saveptr );
1841 
1843  && type != TEXTE_MODULE::TEXT_is_VALUE )
1845 
1846  aText->SetType( static_cast<TEXTE_MODULE::TEXT_TYPE>( type ) );
1847 
1848  aText->SetPos0( wxPoint( pos0_x, pos0_y ) );
1849  aText->SetTextSize( wxSize( size0_x, size0_y ) );
1850 
1851  orient -= ( static_cast<MODULE*>( aText->GetParent() ) )->GetOrientation();
1852 
1853  aText->SetTextAngle( orient );
1854 
1855  // Set a reasonable width:
1856  if( thickn < 1 )
1857  thickn = 1;
1858 
1859  /* this is better left to the dialogs UIs
1860  aText->SetThickness( Clamp_Text_PenSize( thickn, aText->GetSize() ) );
1861  */
1862 
1863  aText->SetThickness( thickn );
1864 
1865  aText->SetMirrored( mirror && *mirror == 'M' );
1866 
1867  aText->SetVisible( !(hide && *hide == 'I') );
1868 
1869  aText->SetItalic( italic && *italic == 'I' );
1870 
1871  if( hjust )
1872  aText->SetHorizJustify( horizJustify( hjust ) );
1873 
1874  if( vjust )
1875  aText->SetVertJustify( vertJustify( vjust ) );
1876 
1877  // A protection against mal formed (or edited by hand) files:
1878  if( layer_num < FIRST_LAYER )
1879  layer_num = FIRST_LAYER;
1880  else if( layer_num > LAST_NON_COPPER_LAYER )
1881  layer_num = LAST_NON_COPPER_LAYER;
1882  else if( layer_num == LAYER_N_BACK )
1883  layer_num = SILKSCREEN_N_BACK;
1884  else if( layer_num == LAYER_N_FRONT )
1885  layer_num = SILKSCREEN_N_FRONT;
1886  else if( layer_num < LAYER_N_FRONT ) // this case is a internal layer
1887  layer_num = SILKSCREEN_N_FRONT;
1888 
1889  aText->SetLayer( leg_layer2new( m_cu_count, layer_num ) );
1890 
1891  // Calculate the actual position.
1892  aText->SetDrawCoord();
1893 }
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:222
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:126
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:155
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 2397 of file legacy_plugin.cpp.

2398 {
2399  char buf[1024];
2400  wxString netname;
2401  char* line;
2402 
2403  // create an empty NETCLASS without a name, but do not add it to the BOARD
2404  // yet since that would bypass duplicate netclass name checking within the BOARD.
2405  // store it temporarily in an unique_ptr until successfully inserted into the BOARD
2406  // just before returning.
2407  NETCLASSPTR nc = std::make_shared<NETCLASS>( wxEmptyString );
2408 
2409  while( ( line = READLINE( m_reader ) ) != NULL )
2410  {
2411  if( TESTLINE( "AddNet" ) ) // most frequent type of line
2412  {
2413  // e.g. "AddNet "V3.3D"\n"
2414  ReadDelimitedText( buf, line + SZ( "AddNet" ), sizeof(buf) );
2415  netname = FROM_UTF8( buf );
2416  nc->Add( netname );
2417  }
2418 
2419  else if( TESTLINE( "Clearance" ) )
2420  {
2421  BIU tmp = biuParse( line + SZ( "Clearance" ) );
2422  nc->SetClearance( tmp );
2423  }
2424 
2425  else if( TESTLINE( "TrackWidth" ) )
2426  {
2427  BIU tmp = biuParse( line + SZ( "TrackWidth" ) );
2428  nc->SetTrackWidth( tmp );
2429  }
2430 
2431  else if( TESTLINE( "ViaDia" ) )
2432  {
2433  BIU tmp = biuParse( line + SZ( "ViaDia" ) );
2434  nc->SetViaDiameter( tmp );
2435  }
2436 
2437  else if( TESTLINE( "ViaDrill" ) )
2438  {
2439  BIU tmp = biuParse( line + SZ( "ViaDrill" ) );
2440  nc->SetViaDrill( tmp );
2441  }
2442 
2443  else if( TESTLINE( "uViaDia" ) )
2444  {
2445  BIU tmp = biuParse( line + SZ( "uViaDia" ) );
2446  nc->SetuViaDiameter( tmp );
2447  }
2448 
2449  else if( TESTLINE( "uViaDrill" ) )
2450  {
2451  BIU tmp = biuParse( line + SZ( "uViaDrill" ) );
2452  nc->SetuViaDrill( tmp );
2453  }
2454 
2455  else if( TESTLINE( "Name" ) )
2456  {
2457  ReadDelimitedText( buf, line + SZ( "Name" ), sizeof(buf) );
2458  nc->SetName( FROM_UTF8( buf ) );
2459  }
2460 
2461  else if( TESTLINE( "Desc" ) )
2462  {
2463  ReadDelimitedText( buf, line + SZ( "Desc" ), sizeof(buf) );
2464  nc->SetDescription( FROM_UTF8( buf ) );
2465  }
2466 
2467  else if( TESTLINE( "$EndNCLASS" ) )
2468  {
2469  if( !m_board->GetDesignSettings().m_NetClasses.Add( nc ) )
2470  {
2471  // Must have been a name conflict, this is a bad board file.
2472  // User may have done a hand edit to the file.
2473 
2474  // unique_ptr will delete nc on this code path
2475 
2476  m_error.Printf( _( "duplicate NETCLASS name \"%s\"" ), nc->GetName().GetData() );
2478  }
2479 
2480  return; // preferred exit
2481  }
2482  }
2483 
2484  THROW_IO_ERROR( "Missing '$EndNCLASS'" );
2485 }
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:531
#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:155
#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 2058 of file legacy_plugin.cpp.

2059 {
2060  /* a net description is something like
2061  * $EQUIPOT
2062  * Na 5 "/BIT1"
2063  * St ~
2064  * $EndEQUIPOT
2065  */
2066 
2067  char buf[1024];
2068 
2069  NETINFO_ITEM* net = NULL;
2070  char* line;
2071  int netCode = 0;
2072 
2073  while( ( line = READLINE( m_reader ) ) != NULL )
2074  {
2075  const char* data;
2076 
2077  if( TESTLINE( "Na" ) )
2078  {
2079  // e.g. "Na 58 "/cpu.sch/PAD7"\r\n"
2080 
2081  netCode = intParse( line + SZ( "Na" ), &data );
2082 
2083  ReadDelimitedText( buf, data, sizeof(buf) );
2084 
2085  if( net == NULL )
2086  net = new NETINFO_ITEM( m_board, FROM_UTF8( buf ), netCode );
2087  else
2088  {
2089  THROW_IO_ERROR( "Two net definitions in '$EQUIPOT' block" );
2090  }
2091  }
2092 
2093  else if( TESTLINE( "$EndEQUIPOT" ) )
2094  {
2095  // net 0 should be already in list, so store this net
2096  // if it is not the net 0, or if the net 0 does not exists.
2097  if( net && ( net->GetNet() > 0 || m_board->FindNet( 0 ) == NULL ) )
2098  {
2099  m_board->Add( net );
2100 
2101  // Be sure we have room to store the net in m_netCodes
2102  if( (int)m_netCodes.size() <= netCode )
2103  m_netCodes.resize( netCode+1 );
2104 
2105  m_netCodes[netCode] = net->GetNet();
2106  net = NULL;
2107  }
2108  else
2109  {
2110  delete net;
2111  net = NULL; // Avoid double deletion.
2112  }
2113 
2114  return; // preferred exit
2115  }
2116  }
2117 
2118  // If we are here, there is an error.
2119  delete net;
2120  THROW_IO_ERROR( "Missing '$EndEQUIPOT'" );
2121 }
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:155
#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 1417 of file legacy_plugin.cpp.

1418 {
1419  unique_ptr<D_PAD> pad( new D_PAD( aModule ) );
1420  char* line;
1421  char* saveptr;
1422 
1423  while( ( line = READLINE( m_reader ) ) != NULL )
1424  {
1425  const char* data;
1426 
1427  if( TESTLINE( "Sh" ) ) // (Sh)ape and padname
1428  {
1429  // e.g. "Sh "A2" C 520 520 0 0 900"
1430  // or "Sh "1" R 157 1378 0 0 900"
1431 
1432  // mypadname is LATIN1/CRYLIC for BOARD_FORMAT_VERSION 1,
1433  // but for BOARD_FORMAT_VERSION 2, it is UTF8 from disk.
1434  // So we have to go through two code paths. Moving forward
1435  // padnames will be in UTF8 on disk, as are all KiCad strings on disk.
1436  char mypadname[50];
1437 
1438  data = line + SZ( "Sh" ) + 1; // +1 skips trailing whitespace
1439 
1440  data = data + ReadDelimitedText( mypadname, data, sizeof(mypadname) ) + 1; // +1 trailing whitespace
1441 
1442  // sscanf( PtLine, " %s %d %d %d %d %d", BufCar, &m_Size.x, &m_Size.y, &m_DeltaSize.x, &m_DeltaSize.y, &m_Orient );
1443  while( isSpace( *data ) )
1444  ++data;
1445 
1446  unsigned char padchar = (unsigned char) *data++;
1447  int padshape;
1448 
1449  BIU size_x = biuParse( data, &data );
1450  BIU size_y = biuParse( data, &data );
1451  BIU delta_x = biuParse( data, &data );
1452  BIU delta_y = biuParse( data, &data );
1453  double orient = degParse( data );
1454 
1455  switch( padchar )
1456  {
1457  case 'C': padshape = PAD_SHAPE_CIRCLE; break;
1458  case 'R': padshape = PAD_SHAPE_RECT; break;
1459  case 'O': padshape = PAD_SHAPE_OVAL; break;
1460  case 'T': padshape = PAD_SHAPE_TRAPEZOID; break;
1461  default:
1462  m_error.Printf( _( "Unknown padshape '%c=0x%02x' on line: %d of footprint: \"%s\"" ),
1463  padchar,
1464  padchar,
1465  m_reader->LineNumber(),
1466  GetChars( aModule->GetFPID().GetLibItemName() )
1467  );
1469  }
1470 
1471  // go through a wxString to establish a universal character set properly
1472  wxString padname;
1473 
1474  if( m_loading_format_version == 1 )
1475  {
1476  // add 8 bit bytes, file format 1 was KiCad font type byte,
1477  // simply promote those 8 bit bytes up into UNICODE. (subset of LATIN1)
1478  const unsigned char* cp = (unsigned char*) mypadname;
1479  while( *cp )
1480  {
1481  padname += *cp++; // unsigned, ls 8 bits only
1482  }
1483  }
1484  else
1485  {
1486  // version 2, which is UTF8.
1487  padname = FROM_UTF8( mypadname );
1488  }
1489  // chances are both were ASCII, but why take chances?
1490 
1491  pad->SetName( padname );
1492  pad->SetShape( PAD_SHAPE_T( padshape ) );
1493  pad->SetSize( wxSize( size_x, size_y ) );
1494  pad->SetDelta( wxSize( delta_x, delta_y ) );
1495  pad->SetOrientation( orient );
1496  }
1497 
1498  else if( TESTLINE( "Dr" ) ) // (Dr)ill
1499  {
1500  // e.g. "Dr 350 0 0" or "Dr 0 0 0 O 0 0"
1501  // sscanf( PtLine, "%d %d %d %s %d %d", &m_Drill.x, &m_Offset.x, &m_Offset.y, BufCar, &dx, &dy );
1502 
1503  BIU drill_x = biuParse( line + SZ( "Dr" ), &data );
1504  BIU drill_y = drill_x;
1505  BIU offs_x = biuParse( data, &data );
1506  BIU offs_y = biuParse( data, &data );
1507 
1509 
1510  data = strtok_r( (char*) data, delims, &saveptr );
1511  if( data ) // optional shape
1512  {
1513  if( data[0] == 'O' )
1514  {
1515  drShape = PAD_DRILL_SHAPE_OBLONG;
1516 
1517  data = strtok_r( NULL, delims, &saveptr );
1518  drill_x = biuParse( data );
1519 
1520  data = strtok_r( NULL, delims, &saveptr );
1521  drill_y = biuParse( data );
1522  }
1523  }
1524 
1525  pad->SetDrillShape( drShape );
1526  pad->SetOffset( wxPoint( offs_x, offs_y ) );
1527  pad->SetDrillSize( wxSize( drill_x, drill_y ) );
1528  }
1529 
1530  else if( TESTLINE( "At" ) ) // (At)tribute
1531  {
1532  // e.g. "At SMD N 00888000"
1533  // sscanf( PtLine, "%s %s %X", BufLine, BufCar, &m_layerMask );
1534 
1535  PAD_ATTR_T attribute;
1536 
1537  data = strtok_r( line + SZ( "At" ), delims, &saveptr );
1538 
1539  if( !strcmp( data, "SMD" ) )
1540  attribute = PAD_ATTRIB_SMD;
1541  else if( !strcmp( data, "CONN" ) )
1542  attribute = PAD_ATTRIB_CONN;
1543  else if( !strcmp( data, "HOLE" ) )
1544  attribute = PAD_ATTRIB_HOLE_NOT_PLATED;
1545  else
1546  attribute = PAD_ATTRIB_STANDARD;
1547 
1548  strtok_r( NULL, delims, &saveptr ); // skip BufCar
1549  data = strtok_r( NULL, delims, &saveptr );
1550 
1551  LEG_MASK layer_mask = hexParse( data );
1552 
1553  pad->SetLayerSet( leg_mask2new( m_cu_count, layer_mask ) );
1554  pad->SetAttribute( attribute );
1555  }
1556 
1557  else if( TESTLINE( "Ne" ) ) // (Ne)tname
1558  {
1559  // e.g. "Ne 461 "V5.0"
1560 
1561  char buf[1024]; // can be fairly long
1562  int netcode = intParse( line + SZ( "Ne" ), &data );
1563 
1564  // Store the new code mapping
1565  pad->SetNetCode( getNetCode( netcode ) );
1566 
1567  // read Netname
1568  ReadDelimitedText( buf, data, sizeof(buf) );
1569 #ifndef NDEBUG
1570  if( m_board )
1571  assert( m_board->FindNet( getNetCode( netcode ) )->GetNetname() ==
1572  FROM_UTF8( StrPurge( buf ) ) );
1573 #endif /* NDEBUG */
1574  }
1575 
1576  else if( TESTLINE( "Po" ) ) // (Po)sition
1577  {
1578  // e.g. "Po 500 -500"
1579  wxPoint pos;
1580 
1581  pos.x = biuParse( line + SZ( "Po" ), &data );
1582  pos.y = biuParse( data );
1583 
1584  pad->SetPos0( pos );
1585  // pad->SetPosition( pos ); set at function return
1586  }
1587 
1588  else if( TESTLINE( "Le" ) )
1589  {
1590  BIU tmp = biuParse( line + SZ( "Le" ) );
1591  pad->SetPadToDieLength( tmp );
1592  }
1593 
1594  else if( TESTLINE( ".SolderMask" ) )
1595  {
1596  BIU tmp = biuParse( line + SZ( ".SolderMask" ) );
1597  pad->SetLocalSolderMaskMargin( tmp );
1598  }
1599 
1600  else if( TESTLINE( ".SolderPasteRatio" ) )
1601  {
1602  double tmp = atof( line + SZ( ".SolderPasteRatio" ) );
1603  pad->SetLocalSolderPasteMarginRatio( tmp );
1604  }
1605 
1606  else if( TESTLINE( ".SolderPaste" ) )
1607  {
1608  BIU tmp = biuParse( line + SZ( ".SolderPaste" ) );
1609  pad->SetLocalSolderPasteMargin( tmp );
1610  }
1611 
1612  else if( TESTLINE( ".LocalClearance" ) )
1613  {
1614  BIU tmp = biuParse( line + SZ( ".LocalClearance" ) );
1615  pad->SetLocalClearance( tmp );
1616  }
1617 
1618  else if( TESTLINE( ".ZoneConnection" ) )
1619  {
1620  int tmp = intParse( line + SZ( ".ZoneConnection" ) );
1621  pad->SetZoneConnection( (ZoneConnection)tmp );
1622  }
1623 
1624  else if( TESTLINE( ".ThermalWidth" ) )
1625  {
1626  BIU tmp = biuParse( line + SZ( ".ThermalWidth" ) );
1627  pad->SetThermalWidth( tmp );
1628  }
1629 
1630  else if( TESTLINE( ".ThermalGap" ) )
1631  {
1632  BIU tmp = biuParse( line + SZ( ".ThermalGap" ) );
1633  pad->SetThermalGap( tmp );
1634  }
1635 
1636  else if( TESTLINE( "$EndPAD" ) )
1637  {
1638  // pad's "Position" is not relative to the module's,
1639  // whereas Pos0 is relative to the module's but is the unrotated coordinate.
1640 
1641  wxPoint padpos = pad->GetPos0();
1642 
1643  RotatePoint( &padpos, aModule->GetOrientation() );
1644 
1645  pad->SetPosition( padpos + aModule->GetPosition() );
1646 
1647  aModule->Add( pad.release() );
1648  return; // preferred exit
1649  }
1650  }
1651 
1652  THROW_IO_ERROR( "Missing '$EndPAD'" );
1653 }
NETINFO_ITEM * FindNet(int aNetcode) const
Function FindNet searches for a net with the given netcode.
double GetOrientation() const
Definition: class_module.h:218
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:310
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:222
#define READLINE(rdr)
void RotatePoint(int *pX, int *pY, double angle)
Definition: trigo.cpp:206
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:155
#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:213
#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 1945 of file legacy_plugin.cpp.

1946 {
1947  /* example:
1948  $DRAWSEGMENT
1949  Po 0 57500 -1000 57500 0 150
1950  De 24 0 900 0 0
1951  $EndDRAWSEGMENT
1952  */
1953 
1954  unique_ptr<DRAWSEGMENT> dseg( new DRAWSEGMENT( m_board ) );
1955 
1956  char* line;
1957  char* saveptr;
1958 
1959  while( ( line = READLINE( m_reader ) ) != NULL )
1960  {
1961  const char* data;
1962 
1963  if( TESTLINE( "Po" ) )
1964  {
1965  // 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 );
1966  int shape = intParse( line + SZ( "Po" ), &data );
1967  BIU start_x = biuParse( data, &data );
1968  BIU start_y = biuParse( data, &data );
1969  BIU end_x = biuParse( data, &data );
1970  BIU end_y = biuParse( data, &data );
1971  BIU width = biuParse( data );
1972 
1973  if( width < 0 )
1974  width = 0;
1975 
1976  dseg->SetShape( STROKE_T( shape ) );
1977  dseg->SetWidth( width );
1978  dseg->SetStart( wxPoint( start_x, start_y ) );
1979  dseg->SetEnd( wxPoint( end_x, end_y ) );
1980  }
1981 
1982  else if( TESTLINE( "De" ) )
1983  {
1984  BIU x = 0;
1985  BIU y;
1986 
1987  data = strtok_r( line + SZ( "De" ), delims, &saveptr );
1988  for( int i = 0; data; ++i, data = strtok_r( NULL, delims, &saveptr ) )
1989  {
1990  switch( i )
1991  {
1992  case 0:
1993  LAYER_NUM layer;
1994  layer = layerParse( data );
1995 
1996  if( layer < FIRST_NON_COPPER_LAYER )
1997  layer = FIRST_NON_COPPER_LAYER;
1998 
1999  else if( layer > LAST_NON_COPPER_LAYER )
2000  layer = LAST_NON_COPPER_LAYER;
2001 
2002  dseg->SetLayer( leg_layer2new( m_cu_count, layer ) );
2003  break;
2004  case 1:
2005  int mtype;
2006  mtype = intParse( data );
2007  dseg->SetType( mtype ); // m_Type
2008  break;
2009  case 2:
2010  double angle;
2011  angle = degParse( data );
2012  dseg->SetAngle( angle ); // m_Angle
2013  break;
2014  case 3:
2015  timestamp_t timestamp;
2016  timestamp = hexParse( data );
2017  dseg->SetTimeStamp( timestamp );
2018  break;
2019  case 4:
2020  STATUS_FLAGS state;
2021  state = static_cast<STATUS_FLAGS>( hexParse( data ) );
2022  dseg->SetState( state, true );
2023  break;
2024 
2025  // Bezier Control Points
2026  case 5:
2027  x = biuParse( data );
2028  break;
2029  case 6:
2030  y = biuParse( data );
2031  dseg->SetBezControl1( wxPoint( x, y ) );
2032  break;
2033 
2034  case 7:
2035  x = biuParse( data );
2036  break;
2037  case 8:
2038  y = biuParse( data );
2039  dseg->SetBezControl2( wxPoint( x, y ) );
2040  break;
2041 
2042  default:
2043  break;
2044  }
2045  }
2046  }
2047 
2048  else if( TESTLINE( "$EndDRAWSEGMENT" ) )
2049  {
2050  m_board->Add( dseg.release(), ADD_APPEND );
2051  return; // preferred exit
2052  }
2053  }
2054 
2055  THROW_IO_ERROR( "Missing '$EndDRAWSEGMENT'" );
2056 }
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:649
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:53
#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 2970 of file legacy_plugin.cpp.

2971 {
2972  char* line;
2973 
2974  while( ( line = READLINE( m_reader ) ) != NULL )
2975  {
2976  const char* data;
2977 
2978  if( TESTLINE( "$EndPCB_TARGET" ) || TESTLINE( "$EndMIREPCB" ) )
2979  {
2980  return; // preferred exit
2981  }
2982 
2983  else if( TESTLINE( "Po" ) )
2984  {
2985  // 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 );
2986 
2987  int shape = intParse( line + SZ( "Po" ), &data );
2988 
2989  LAYER_NUM layer_num = layerParse( data, &data );
2990 
2991  BIU pos_x = biuParse( data, &data );
2992  BIU pos_y = biuParse( data, &data );
2993  BIU size = biuParse( data, &data );
2994  BIU width = biuParse( data, &data );
2995  timestamp_t timestamp = hexParse( data );
2996 
2997  if( layer_num < FIRST_NON_COPPER_LAYER )
2998  layer_num = FIRST_NON_COPPER_LAYER;
2999 
3000  else if( layer_num > LAST_NON_COPPER_LAYER )
3001  layer_num = LAST_NON_COPPER_LAYER;
3002 
3003  PCB_TARGET* t = new PCB_TARGET( m_board, shape, leg_layer2new( m_cu_count, layer_num ),
3004  wxPoint( pos_x, pos_y ), size, width );
3005  m_board->Add( t, ADD_APPEND );
3006 
3007  t->SetTimeStamp( timestamp );
3008  }
3009  }
3010 
3011  THROW_IO_ERROR( "Missing '$EndDIMENSION'" );
3012 }
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:53
#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 2124 of file legacy_plugin.cpp.

2125 {
2126  /* examples:
2127  For a single line text:
2128  ----------------------
2129  $TEXTPCB
2130  Te "Text example"
2131  Po 66750 53450 600 800 150 0
2132  De 24 1 0 Italic
2133  $EndTEXTPCB
2134 
2135  For a multi line text:
2136  ---------------------
2137  $TEXTPCB
2138  Te "Text example"
2139  Nl "Line 2"
2140  Po 66750 53450 600 800 150 0
2141  De 24 1 0 Italic
2142  $EndTEXTPCB
2143  Nl "line nn" is a line added to the current text
2144  */
2145 
2146  char text[1024];
2147 
2148  // maybe someday a constructor that takes all this data in one call?
2149  TEXTE_PCB* pcbtxt = new TEXTE_PCB( m_board );
2150  m_board->Add( pcbtxt, ADD_APPEND );
2151 
2152  char* line;
2153  char* saveptr;
2154 
2155  while( ( line = READLINE( m_reader ) ) != NULL )
2156  {
2157  const char* data;
2158 
2159  if( TESTLINE( "Te" ) ) // Text line (or first line for multi line texts)
2160  {
2161  ReadDelimitedText( text, line + SZ( "Te" ), sizeof(text) );
2162  pcbtxt->SetText( FROM_UTF8( text ) );
2163  }
2164 
2165  else if( TESTLINE( "nl" ) ) // next line of the current text
2166  {
2167  ReadDelimitedText( text, line + SZ( "nl" ), sizeof(text) );
2168  pcbtxt->SetText( pcbtxt->GetText() + wxChar( '\n' ) + FROM_UTF8( text ) );
2169  }
2170 
2171  else if( TESTLINE( "Po" ) )
2172  {
2173  // 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 );
2174  wxSize size;
2175 
2176  BIU pos_x = biuParse( line + SZ( "Po" ), &data );
2177  BIU pos_y = biuParse( data, &data );
2178  size.x = biuParse( data, &data );
2179  size.y = biuParse( data, &data );
2180  BIU thickn = biuParse( data, &data );
2181  double angle = degParse( data );
2182 
2183  pcbtxt->SetTextSize( size );
2184 
2185  pcbtxt->SetThickness( thickn );
2186  pcbtxt->SetTextAngle( angle );
2187 
2188  pcbtxt->SetTextPos( wxPoint( pos_x, pos_y ) );
2189  }
2190 
2191  else if( TESTLINE( "De" ) )
2192  {
2193  // e.g. "De 21 1 0 Normal C\r\n"
2194  // sscanf( line + 2, " %d %d %lX %s %c\n", &m_Layer, &normal_display, &m_TimeStamp, style, &hJustify );
2195 
2196  LAYER_NUM layer_num = layerParse( line + SZ( "De" ), &data );
2197  int notMirrored = intParse( data, &data );
2198  timestamp_t timestamp = hexParse( data, &data );
2199  char* style = strtok_r( (char*) data, delims, &saveptr );
2200  char* hJustify = strtok_r( NULL, delims, &saveptr );
2201  char* vJustify = strtok_r( NULL, delims, &saveptr );
2202 
2203  pcbtxt->SetMirrored( !notMirrored );
2204  pcbtxt->SetTimeStamp( timestamp );
2205  pcbtxt->SetItalic( !strcmp( style, "Italic" ) );
2206 
2207  if( hJustify )
2208  pcbtxt->SetHorizJustify( horizJustify( hJustify ) );
2209  else
2210  {
2211  // boom, somebody changed a constructor, I was relying on this:
2212  wxASSERT( pcbtxt->GetHorizJustify() == GR_TEXT_HJUSTIFY_CENTER );
2213  }
2214 
2215  if( vJustify )
2216  pcbtxt->SetVertJustify( vertJustify( vJustify ) );
2217 
2218  if( layer_num < FIRST_COPPER_LAYER )
2219  layer_num = FIRST_COPPER_LAYER;
2220  else if( layer_num > LAST_NON_COPPER_LAYER )
2221  layer_num = LAST_NON_COPPER_LAYER;
2222 
2223  if( layer_num >= FIRST_NON_COPPER_LAYER ||
2224  is_leg_copperlayer_valid( m_cu_count, layer_num ) )
2225  pcbtxt->SetLayer( leg_layer2new( m_cu_count, layer_num ) );
2226  else // not perfect, but putting this text on front layer is a workaround
2227  pcbtxt->SetLayer( F_Cu );
2228  }
2229 
2230  else if( TESTLINE( "$EndTEXTPCB" ) )
2231  {
2232  return; // preferred exit
2233  }
2234  }
2235 
2236  THROW_IO_ERROR( "Missing '$EndTEXTPCB'" );
2237 }
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:231
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:222
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:126
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:53
int ReadDelimitedText(wxString *aDest, const char *aSource)
Copy bytes from aSource delimited string segment to aDest wxString.
Definition: string.cpp:155
#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 858 of file legacy_plugin.cpp.

859 {
860  NETCLASSPTR netclass_default = m_board->GetDesignSettings().GetDefault();
861  // TODO Orson: is it really necessary to first operate on a copy and then apply it?
862  // would not it be better to use reference here and apply all the changes instantly?
865  char* line;
866  char* saveptr;
867 
868  while( ( line = READLINE( m_reader ) ) != NULL )
869  {
870  const char* data;
871 
872  if( TESTLINE( "PcbPlotParams" ) )
873  {
874  PCB_PLOT_PARAMS plot_opts;
875 
876  PCB_PLOT_PARAMS_PARSER parser( line + SZ( "PcbPlotParams" ), m_reader->GetSource() );
877 
878  plot_opts.Parse( &parser );
879 
880  m_board->SetPlotOptions( plot_opts );
881  }
882 
883  else if( TESTLINE( "AuxiliaryAxisOrg" ) )
884  {
885  BIU gx = biuParse( line + SZ( "AuxiliaryAxisOrg" ), &data );
886  BIU gy = biuParse( data );
887 
888  // m_board->SetAuxOrigin( wxPoint( gx, gy ) ); gets overwritten by SetDesignSettings() below
889  bds.m_AuxOrigin = wxPoint( gx, gy );
890  }
891 
892  /* Done from $General above's "LayerCount"
893  else if( TESTLINE( "Layers" ) )
894  {
895  int tmp = intParse( line + SZ( "Layers" ) );
896  m_board->SetCopperLayerCount( tmp );
897 
898  m_cu_count = tmp;
899  }
900  */
901 
902  else if( TESTSUBSTR( "Layer[" ) )
903  {
904  // eg: "Layer[n] <a_Layer_name_with_no_spaces> <LAYER_T>"
905 
906  LAYER_NUM layer_num = layerParse( line + SZ( "Layer[" ), &data );
907  PCB_LAYER_ID layer_id = leg_layer2new( m_cu_count, layer_num );
908 
909  /*
910  switch( layer_num )
911  {
912  case LAYER_N_BACK:
913  layer_id = B_Cu;
914  break;
915 
916  case LAYER_N_FRONT:
917  layer_id = F_Cu;
918  break;
919 
920  default:
921  layer_id = PCB_LAYER_ID( layer_num );
922  }
923  */
924 
925  data = strtok_r( (char*) data+1, delims, &saveptr ); // +1 for ']'
926  if( data )
927  {
928  wxString layerName = FROM_UTF8( data );
929  m_board->SetLayerName( layer_id, layerName );
930 
931  data = strtok_r( NULL, delims, &saveptr );
932  if( data ) // optional in old board files
933  {
934  LAYER_T type = LAYER::ParseType( data );
935  m_board->SetLayerType( layer_id, type );
936  }
937  }
938  }
939 
940  else if( TESTLINE( "TrackWidth" ) )
941  {
942  BIU tmp = biuParse( line + SZ( "TrackWidth" ) );
943  netclass_default->SetTrackWidth( tmp );
944  }
945 
946  else if( TESTLINE( "TrackWidthList" ) )
947  {
948  BIU tmp = biuParse( line + SZ( "TrackWidthList" ) );
949  bds.m_TrackWidthList.push_back( tmp );
950  }
951 
952  else if( TESTLINE( "TrackClearence" ) )
953  {
954  BIU tmp = biuParse( line + SZ( "TrackClearence" ) );
955  netclass_default->SetClearance( tmp );
956  }
957 
958  else if( TESTLINE( "TrackMinWidth" ) )
959  {
960  BIU tmp = biuParse( line + SZ( "TrackMinWidth" ) );
961  bds.m_TrackMinWidth = tmp;
962  }
963 
964  else if( TESTLINE( "ZoneClearence" ) )
965  {
966  BIU tmp = biuParse( line + SZ( "ZoneClearence" ) );
967  zs.m_ZoneClearance = tmp;
968  }
969 
970  else if( TESTLINE( "Zone_45_Only" ) )
971  {
972  bool tmp = (bool) intParse( line + SZ( "Zone_45_Only" ) );
973  zs.m_Zone_45_Only = tmp;
974  }
975 
976  else if( TESTLINE( "DrawSegmWidth" ) )
977  {
978  BIU tmp = biuParse( line + SZ( "DrawSegmWidth" ) );
979  bds.m_LineThickness[ LAYER_CLASS_COPPER ] = tmp;
980  }
981 
982  else if( TESTLINE( "EdgeSegmWidth" ) )
983  {
984  BIU tmp = biuParse( line + SZ( "EdgeSegmWidth" ) );
985  bds.m_LineThickness[ LAYER_CLASS_EDGES ] = tmp;
986  }
987 
988  else if( TESTLINE( "ViaMinSize" ) )
989  {
990  BIU tmp = biuParse( line + SZ( "ViaMinSize" ) );
991  bds.m_ViasMinSize = tmp;
992  }
993 
994  else if( TESTLINE( "MicroViaMinSize" ) )
995  {
996  BIU tmp = biuParse( line + SZ( "MicroViaMinSize" ) );
997  bds.m_MicroViasMinSize = tmp;
998  }
999 
1000  else if( TESTLINE( "ViaSizeList" ) )
1001  {
1002  // e.g. "ViaSizeList DIAMETER [DRILL]"
1003 
1004  BIU drill = 0;
1005  BIU diameter = biuParse( line + SZ( "ViaSizeList" ), &data );
1006 
1007  data = strtok_r( (char*) data, delims, &saveptr );
1008  if( data ) // DRILL may not be present ?
1009  drill = biuParse( data );
1010 
1011  bds.m_ViasDimensionsList.emplace_back( diameter,
1012  drill );
1013  }
1014 
1015  else if( TESTLINE( "ViaSize" ) )
1016  {
1017  BIU tmp = biuParse( line + SZ( "ViaSize" ) );
1018  netclass_default->SetViaDiameter( tmp );
1019  }
1020 
1021  else if( TESTLINE( "ViaDrill" ) )
1022  {
1023  BIU tmp = biuParse( line + SZ( "ViaDrill" ) );
1024  netclass_default->SetViaDrill( tmp );
1025  }
1026 
1027  else if( TESTLINE( "ViaMinDrill" ) )
1028  {
1029  BIU tmp = biuParse( line + SZ( "ViaMinDrill" ) );
1030  bds.m_ViasMinDrill = tmp;
1031  }
1032 
1033  else if( TESTLINE( "MicroViaSize" ) )
1034  {
1035  BIU tmp = biuParse( line + SZ( "MicroViaSize" ) );
1036  netclass_default->SetuViaDiameter( tmp );
1037  }
1038 
1039  else if( TESTLINE( "MicroViaDrill" ) )
1040  {
1041  BIU tmp = biuParse( line + SZ( "MicroViaDrill" ) );
1042  netclass_default->SetuViaDrill( tmp );
1043  }
1044 
1045  else if( TESTLINE( "MicroViaMinDrill" ) )
1046  {
1047  BIU tmp = biuParse( line + SZ( "MicroViaMinDrill" ) );
1048  bds.m_MicroViasMinDrill = tmp;
1049  }
1050 
1051  else if( TESTLINE( "MicroViasAllowed" ) )
1052  {
1053  int tmp = intParse( line + SZ( "MicroViasAllowed" ) );
1054  bds.m_MicroViasAllowed = tmp;
1055  }
1056 
1057  else if( TESTLINE( "TextPcbWidth" ) )
1058  {
1059  BIU tmp = biuParse( line + SZ( "TextPcbWidth" ) );
1060  bds.m_TextThickness[ LAYER_CLASS_COPPER ] = tmp;
1061  }
1062 
1063  else if( TESTLINE( "TextPcbSize" ) )
1064  {
1065  BIU x = biuParse( line + SZ( "TextPcbSize" ), &data );
1066  BIU y = biuParse( data );
1067 
1068  bds.m_TextSize[ LAYER_CLASS_COPPER ] = wxSize( x, y );
1069  }
1070 
1071  else if( TESTLINE( "EdgeModWidth" ) )
1072  {
1073  BIU tmp = biuParse( line + SZ( "EdgeModWidth" ) );
1074  bds.m_LineThickness[ LAYER_CLASS_SILK ] = tmp;
1075  bds.m_LineThickness[ LAYER_CLASS_OTHERS ] = tmp;
1076  }
1077 
1078  else if( TESTLINE( "TextModWidth" ) )
1079  {
1080  BIU tmp = biuParse( line + SZ( "TextModWidth" ) );
1081  bds.m_TextThickness[ LAYER_CLASS_SILK ] = tmp;
1082  bds.m_TextThickness[ LAYER_CLASS_OTHERS ] = tmp;
1083  }
1084 
1085  else if( TESTLINE( "TextModSize" ) )
1086  {
1087  BIU x = biuParse( line + SZ( "TextModSize" ), &data );
1088  BIU y = biuParse( data );
1089 
1090  bds.m_TextSize[ LAYER_CLASS_SILK ] = wxSize( x, y );
1091  bds.m_TextSize[ LAYER_CLASS_OTHERS ] = wxSize( x, y );
1092  }
1093 
1094  else if( TESTLINE( "PadSize" ) )
1095  {
1096  BIU x = biuParse( line + SZ( "PadSize" ), &data );
1097  BIU y = biuParse( data );
1098 
1099  bds.m_Pad_Master.SetSize( wxSize( x, y ) );
1100  }
1101 
1102  else if( TESTLINE( "PadDrill" ) )
1103  {
1104  BIU tmp = biuParse( line + SZ( "PadDrill" ) );
1105  bds.m_Pad_Master.SetDrillSize( wxSize( tmp, tmp ) );
1106  }
1107 
1108  else if( TESTLINE( "Pad2MaskClearance" ) )
1109  {
1110  BIU tmp = biuParse( line + SZ( "Pad2MaskClearance" ) );
1111  bds.m_SolderMaskMargin = tmp;
1112  }
1113 
1114  else if( TESTLINE( "SolderMaskMinWidth" ) )
1115  {
1116  BIU tmp = biuParse( line + SZ( "SolderMaskMinWidth" ) );
1117  bds.m_SolderMaskMinWidth = tmp;
1118  }
1119 
1120  else if( TESTLINE( "Pad2PasteClearance" ) )
1121  {
1122  BIU tmp = biuParse( line + SZ( "Pad2PasteClearance" ) );
1123  bds.m_SolderPasteMargin = tmp;
1124  }
1125 
1126  else if( TESTLINE( "Pad2PasteClearanceRatio" ) )
1127  {
1128  double ratio = atof( line + SZ( "Pad2PasteClearanceRatio" ) );
1129  bds.m_SolderPasteMarginRatio = ratio;
1130  }
1131 
1132  else if( TESTLINE( "GridOrigin" ) )
1133  {
1134  BIU x = biuParse( line + SZ( "GridOrigin" ), &data );
1135  BIU y = biuParse( data );
1136 
1137  // m_board->SetGridOrigin( wxPoint( x, y ) ); gets overwritten by SetDesignSettings() below
1138  bds.m_GridOrigin = wxPoint( x, y );
1139  }
1140 
1141  else if( TESTLINE( "VisibleElements" ) )
1142  {
1143  int visibleElements = hexParse( line + SZ( "VisibleElements" ) );
1144  bds.SetVisibleElements( visibleElements );
1145  }
1146 
1147  else if( TESTLINE( "$EndSETUP" ) )
1148  {
1149  m_board->SetDesignSettings( bds );
1150  m_board->SetZoneSettings( zs );
1151 
1152  // Very old *.brd file does not have NETCLASSes
1153  // "TrackWidth", "ViaSize", "ViaDrill", "ViaMinSize", and "TrackClearence" were
1154  // defined in SETUP; these values are put into the default NETCLASS until later board
1155  // load code should override them. *.brd files which have been saved with knowledge
1156  // of NETCLASSes will override these defaults, very old boards (before 2009) will not
1157  // and use the setup values.
1158  // However these values should be the same as default NETCLASS.
1159 
1160  return; // preferred exit
1161  }
1162  }
1163 
1164  /*
1165  * Ensure tracks and vias sizes lists are ok:
1166  * Sort lists by by increasing value and remove duplicates
1167  * (the first value is not tested, because it is the netclass value)
1168  */
1169  BOARD_DESIGN_SETTINGS& designSettings = m_board->GetDesignSettings();
1170  sort( designSettings.m_ViasDimensionsList.begin() + 1, designSettings.m_ViasDimensionsList.end() );
1171  sort( designSettings.m_TrackWidthList.begin() + 1, designSettings.m_TrackWidthList.end() );
1172 
1173  for( unsigned ii = 1; ii < designSettings.m_ViasDimensionsList.size() - 1; ii++ )
1174  {
1175  if( designSettings.m_ViasDimensionsList[ii] == designSettings.m_ViasDimensionsList[ii + 1] )
1176  {
1177  designSettings.m_ViasDimensionsList.erase( designSettings.m_ViasDimensionsList.begin() + ii );
1178  ii--;
1179  }
1180  }
1181 
1182  for( unsigned ii = 1; ii < designSettings.m_TrackWidthList.size() - 1; ii++ )
1183  {
1184  if( designSettings.m_TrackWidthList[ii] == designSettings.m_TrackWidthList[ii + 1] )
1185  {
1186  designSettings.m_TrackWidthList.erase( designSettings.m_TrackWidthList.begin() + ii );
1187  ii--;
1188  }
1189  }
1190 }
int m_SolderMaskMargin
Solder mask margin.
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:531
#define READLINE(rdr)
void SetDrillSize(const wxSize &aSize)
Definition: class_pad.h:305
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:299
int m_ZoneClearance
Clearance value.
Definition: zone_settings.h:64
void SetDesignSettings(const BOARD_DESIGN_SETTINGS &aDesignSettings)
Function SetDesignSettings.
Definition: class_board.h:541
LEGACY_PLUGIN::BIU BIU
void SetPlotOptions(const PCB_PLOT_PARAMS &aOptions)
Definition: class_board.h:550
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.
void SetZoneSettings(const ZONE_SETTINGS &aSettings)
Set the zone settings for this container.
int LAYER_NUM
Type LAYER_NUM can be replaced with int and removed.
Class ZONE_SETTINGS handles zones parameters.
Definition: zone_settings.h:49
const ZONE_SETTINGS & GetZoneSettings() const
Fetch the zone settings for this container.
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.
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_ITEM_CONTAINER::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_ITEM_CONTAINER::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.SetComment( 0, FROM_UTF8( buf ) );
797  }
798 
799  else if( TESTLINE( "Comment2" ) )
800  {
801  ReadDelimitedText( buf, line, sizeof(buf) );
802  tb.SetComment( 1, FROM_UTF8( buf ) );
803  }
804 
805  else if( TESTLINE( "Comment3" ) )
806  {
807  ReadDelimitedText( buf, line, sizeof(buf) );
808  tb.SetComment( 2, FROM_UTF8( buf ) );
809  }
810 
811  else if( TESTLINE( "Comment4" ) )
812  {
813  ReadDelimitedText( buf, line, sizeof(buf) );
814  tb.SetComment( 3, FROM_UTF8( buf ) );
815  }
816 
817  else if( TESTLINE( "Comment5" ) )
818  {
819  ReadDelimitedText( buf, line, sizeof(buf) );
820  tb.SetComment( 4, FROM_UTF8( buf ) );
821  }
822 
823  else if( TESTLINE( "Comment6" ) )
824  {
825  ReadDelimitedText( buf, line, sizeof(buf) );
826  tb.SetComment( 5, FROM_UTF8( buf ) );
827  }
828 
829  else if( TESTLINE( "Comment7" ) )
830  {
831  ReadDelimitedText( buf, line, sizeof(buf) );
832  tb.SetComment( 6, FROM_UTF8( buf ) );
833  }
834 
835  else if( TESTLINE( "Comment8" ) )
836  {
837  ReadDelimitedText( buf, line, sizeof(buf) );
838  tb.SetComment( 7, FROM_UTF8( buf ) );
839  }
840 
841  else if( TESTLINE( "Comment9" ) )
842  {
843  ReadDelimitedText( buf, line, sizeof(buf) );
844  tb.SetComment( 8, FROM_UTF8( buf ) );
845  }
846 
847  else if( TESTLINE( "$EndSHEETDESCR" ) )
848  {
849  m_board->SetTitleBlock( tb );
850  return; // preferred exit
851  }
852  }
853 
854  THROW_IO_ERROR( "Missing '$EndSHEETDESCR'" );
855 }
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:553
void SetPageSettings(const PAGE_INFO &aPageSettings)
Definition: class_board.h:547
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
LINE_READER * m_reader
no ownership here.
void SetComment(int aIdx, const wxString &aComment)
Definition: title_block.h:104
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
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)
int ReadDelimitedText(wxString *aDest, const char *aSource)
Copy bytes from aSource delimited string segment to aDest wxString.
Definition: string.cpp:155
#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::SetComment(), 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 2240 of file legacy_plugin.cpp.

2241 {
2242  char* line;
2243  char* saveptr;
2244 
2245  while( ( line = READLINE( m_reader ) ) != NULL )
2246  {
2247  // read two lines per loop iteration, each loop is one TRACK or VIA
2248  // example first line:
2249  // e.g. "Po 0 23994 28800 24400 28800 150 -1" for a track
2250  // e.g. "Po 3 21086 17586 21086 17586 180 -1" for a via (uses sames start and end)
2251 
2252  const char* data;
2253 
2254  if( line[0] == '$' ) // $EndTRACK
2255  return; // preferred exit
2256 
2257  // int arg_count = sscanf( line + 2, " %d %d %d %d %d %d %d", &shape, &tempStartX, &tempStartY, &tempEndX, &tempEndY, &width, &drill );
2258 
2259  assert( TESTLINE( "Po" ) );
2260 
2261  VIATYPE_T viatype = static_cast<VIATYPE_T>( intParse( line + SZ( "Po" ), &data ));
2262  BIU start_x = biuParse( data, &data );
2263  BIU start_y = biuParse( data, &data );
2264  BIU end_x = biuParse( data, &data );
2265  BIU end_y = biuParse( data, &data );
2266  BIU width = biuParse( data, &data );
2267 
2268  // optional 7th drill parameter (must be optional in an old format?)
2269  data = strtok_r( (char*) data, delims, &saveptr );
2270 
2271  BIU drill = data ? biuParse( data ) : -1; // SetDefault() if < 0
2272 
2273  // Read the 2nd line to determine the exact type, one of:
2274  // PCB_TRACE_T, PCB_VIA_T, or PCB_SEGZONE_T. The type field in 2nd line
2275  // differentiates between PCB_TRACE_T and PCB_VIA_T. With virtual
2276  // functions in use, it is critical to instantiate the PCB_VIA_T
2277  // exactly.
2278  READLINE( m_reader );
2279 
2280  line = m_reader->Line();
2281 
2282  // example second line:
2283  // "De 0 0 463 0 800000\r\n"
2284 
2285 #if 1
2286  assert( TESTLINE( "De" ) );
2287 #else
2288  if( !TESTLINE( "De" ) )
2289  {
2290  // mandatory 2nd line is missing
2291  THROW_IO_ERROR( "Missing 2nd line of a TRACK def" );
2292  }
2293 #endif
2294 
2295  int makeType;
2296  unsigned long timeStamp;
2297  LAYER_NUM layer_num;
2298  int type, net_code, flags_int;
2299 
2300  // parse the 2nd line to determine the type of object
2301  // e.g. "De 15 1 7 0 0" for a via
2302  sscanf( line + SZ( "De" ), " %d %d %d %lX %X", &layer_num, &type, &net_code,
2303  &timeStamp, &flags_int );
2304 
2305  STATUS_FLAGS flags;
2306 
2307  flags = static_cast<STATUS_FLAGS>( flags_int );
2308 
2309  if( aStructType == PCB_TRACE_T )
2310  {
2311  makeType = ( type == 1 ) ? PCB_VIA_T : PCB_TRACE_T;
2312  }
2313  else if (aStructType == NOT_USED )
2314  {
2315  continue;
2316  }
2317  else
2318  {
2319  wxFAIL_MSG( "Segment type unknown" );
2320  continue;
2321  }
2322 
2323  TRACK* newTrack;
2324 
2325  switch( makeType )
2326  {
2327  default:
2328  case PCB_TRACE_T:
2329  newTrack = new TRACK( m_board );
2330  break;
2331 
2332  case PCB_VIA_T:
2333  newTrack = new VIA( m_board );
2334  break;
2335  }
2336 
2337  newTrack->SetTimeStamp( (timestamp_t)timeStamp );
2338  newTrack->SetPosition( wxPoint( start_x, start_y ) );
2339  newTrack->SetEnd( wxPoint( end_x, end_y ) );
2340 
2341  newTrack->SetWidth( width );
2342 
2343  if( makeType == PCB_VIA_T ) // Ensure layers are OK when possible:
2344  {
2345  VIA *via = static_cast<VIA*>( newTrack );
2346  via->SetViaType( viatype );
2347 
2348  if( drill < 0 )
2349  via->SetDrillDefault();
2350  else
2351  via->SetDrill( drill );
2352 
2353  if( via->GetViaType() == VIA_THROUGH )
2354  via->SetLayerPair( F_Cu, B_Cu );
2355  else
2356  {
2357  PCB_LAYER_ID back = leg_layer2new( m_cu_count, (layer_num >> 4) & 0xf );
2358  PCB_LAYER_ID front = leg_layer2new( m_cu_count, layer_num & 0xf );
2359 
2360  if( is_leg_copperlayer_valid( m_cu_count, back ) &&
2362  via->SetLayerPair( front, back );
2363  else
2364  {
2365  delete via;
2366  newTrack = NULL;
2367  }
2368  }
2369  }
2370  else
2371  {
2372  // A few legacy boards can have tracks on non existent layers, because
2373  // reducing the number of layers does not remove tracks on removed layers
2374  // If happens, skip them
2375  if( is_leg_copperlayer_valid( m_cu_count, layer_num ) )
2376  newTrack->SetLayer( leg_layer2new( m_cu_count, layer_num ) );
2377  else
2378  {
2379  delete newTrack;
2380  newTrack = NULL;
2381  }
2382  }
2383 
2384  if( newTrack )
2385  {
2386  newTrack->SetNetCode( getNetCode( net_code ) );
2387  newTrack->SetState( flags, true );
2388 
2389  m_board->Add( newTrack );
2390  }
2391  }
2392 
2393  THROW_IO_ERROR( "Missing '$EndTRACK'" );
2394 }
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:96
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:97
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:53
#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 2488 of file legacy_plugin.cpp.

2489 {
2490  unique_ptr<ZONE_CONTAINER> zc( new ZONE_CONTAINER( m_board ) );
2491 
2493  bool endContour = false;
2494  int holeIndex = -1; // -1 is the main outline; holeIndex >= 0 = hole index
2495  char buf[1024];
2496  char* line;
2497  char* saveptr;
2498 
2499  while( ( line = READLINE( m_reader ) ) != NULL )
2500  {
2501  const char* data;
2502 
2503  if( TESTLINE( "ZCorner" ) ) // new corner of the zone outlines found
2504  {
2505  // e.g. "ZCorner 25650 49500 0"
2506  BIU x = biuParse( line + SZ( "ZCorner" ), &data );
2507  BIU y = biuParse( data, &data );
2508 
2509  if( endContour )
2510  {
2511  // the previous corner was the last corner of a contour.
2512  // so this corner is the first of a new hole
2513  endContour = false;
2514  zc->NewHole();
2515  holeIndex++;
2516  }
2517 
2518  zc->AppendCorner( wxPoint( x, y ), holeIndex );
2519 
2520  // Is this corner the end of current contour?
2521  // the next corner (if any) will be stored in a new contour (a hole)
2522  // intParse( data )returns 0 = usual corner, 1 = last corner of the current contour:
2523  endContour = intParse( data );
2524  }
2525 
2526  else if( TESTLINE( "ZInfo" ) ) // general info found
2527  {
2528  // e.g. 'ZInfo 479194B1 310 "COMMON"'
2529  timestamp_t timestamp = hexParse( line + SZ( "ZInfo" ), &data );
2530  int netcode = intParse( data, &data );
2531 
2532  if( ReadDelimitedText( buf, data, sizeof(buf) ) > (int) sizeof(buf) )
2533  {
2534  THROW_IO_ERROR( "ZInfo netname too long" );
2535  }
2536 
2537  zc->SetTimeStamp( timestamp );
2538  // Init the net code only, not the netname, to be sure
2539  // the zone net name is the name read in file.
2540  // (When mismatch, the user will be prompted in DRC, to fix the actual name)
2541  zc->BOARD_CONNECTED_ITEM::SetNetCode( getNetCode( netcode ) );
2542  }
2543 
2544  else if( TESTLINE( "ZLayer" ) ) // layer found
2545  {
2546  LAYER_NUM layer_num = layerParse( line + SZ( "ZLayer" ) );
2547  zc->SetLayer( leg_layer2new( m_cu_count, layer_num ) );
2548  }
2549 
2550  else if( TESTLINE( "ZAux" ) ) // aux info found
2551  {
2552  // e.g. "ZAux 7 E"
2553  int ignore = intParse( line + SZ( "ZAux" ), &data );
2554  char* hopt = strtok_r( (char*) data, delims, &saveptr );
2555 
2556  if( !hopt )
2557  {
2558  m_error.Printf( _( "Bad ZAux for CZONE_CONTAINER \"%s\"" ), zc->GetNetname().GetData() );
2560  }
2561 
2562  switch( *hopt ) // upper case required
2563  {
2564  case 'N': outline_hatch = ZONE_CONTAINER::NO_HATCH; break;
2565  case 'E': outline_hatch = ZONE_CONTAINER::DIAGONAL_EDGE; break;
2566  case 'F': outline_hatch = ZONE_CONTAINER::DIAGONAL_FULL; break;
2567 
2568  default:
2569  m_error.Printf( _( "Bad ZAux for CZONE_CONTAINER \"%s\"" ), zc->GetNetname().GetData() );
2571  }
2572 
2573  (void) ignore;
2574 
2575  // Set hatch mode later, after reading corner outline data
2576  }
2577 
2578  else if( TESTLINE( "ZSmoothing" ) )
2579  {
2580  // e.g. "ZSmoothing 0 0"
2581  int smoothing = intParse( line + SZ( "ZSmoothing" ), &data );
2582  BIU cornerRadius = biuParse( data );
2583 
2584  if( smoothing >= ZONE_SETTINGS::SMOOTHING_LAST || smoothing < 0 )
2585  {
2586  m_error.Printf( _( "Bad ZSmoothing for CZONE_CONTAINER \"%s\"" ), zc->GetNetname().GetData() );
2588  }
2589 
2590  zc->SetCornerSmoothingType( smoothing );
2591  zc->SetCornerRadius( cornerRadius );
2592  }
2593 
2594  else if( TESTLINE( "ZKeepout" ) )
2595  {
2596  zc->SetIsKeepout( true );
2597  // e.g. "ZKeepout tracks N vias N pads Y"
2598  data = strtok_r( line + SZ( "ZKeepout" ), delims, &saveptr );
2599 
2600  while( data )
2601  {
2602  if( !strcmp( data, "tracks" ) )
2603  {
2604  data = strtok_r( NULL, delims, &saveptr );
2605  zc->SetDoNotAllowTracks( data && *data == 'N' );
2606  }
2607  else if( !strcmp( data, "vias" ) )
2608  {
2609  data = strtok_r( NULL, delims, &saveptr );
2610  zc->SetDoNotAllowVias( data && *data == 'N' );
2611  }
2612  else if( !strcmp( data, "copperpour" ) )
2613  {
2614  data = strtok_r( NULL, delims, &saveptr );
2615  zc->SetDoNotAllowCopperPour( data && *data == 'N' );
2616  }
2617 
2618  data = strtok_r( NULL, delims, &saveptr );
2619  }
2620  }
2621 
2622  else if( TESTLINE( "ZOptions" ) )
2623  {
2624  // e.g. "ZOptions 0 32 F 200 200"
2625  int fillmode = intParse( line + SZ( "ZOptions" ), &data );
2626  static_cast<void>( intParse( data, &data ) ); // Ignored
2627  char fillstate = data[1]; // here e.g. " F"
2628  BIU thermalReliefGap = biuParse( data += 2 , &data ); // +=2 for " F"
2629  BIU thermalReliefCopperBridge = biuParse( data );
2630 
2631  if( fillmode)
2632  {
2633  // SEGMENT fill mode no longer supported. Make sure user is OK with converting them.
2635  {
2636  KIDIALOG dlg( nullptr,
2637  _( "The legacy segment fill mode is no longer supported.\n"
2638  "Convert zones to polygon fills?"),
2639  _( "Legacy Zone Warning" ),
2640  wxYES_NO | wxICON_WARNING );
2641 
2642  dlg.DoNotShowCheckbox( __FILE__, __LINE__ );
2643 
2644  if( dlg.ShowModal() == wxID_NO )
2645  THROW_IO_ERROR( wxT( "CANCEL" ) );
2646 
2647  m_showLegacyZoneWarning = false;
2648  }
2649 
2650  // User OK'd; switch to polygon mode
2651  zc->SetFillMode( ZFM_POLYGONS );
2652  m_board->SetModified();
2653  }
2654  else
2655  zc->SetFillMode( ZFM_POLYGONS );
2656 
2657  zc->SetIsFilled( fillstate == 'S' );
2658  zc->SetThermalReliefGap( thermalReliefGap );
2659  zc->SetThermalReliefCopperBridge( thermalReliefCopperBridge );
2660  }
2661 
2662  else if( TESTLINE( "ZClearance" ) ) // Clearance and pad options info found
2663  {
2664  // e.g. "ZClearance 40 I"
2665  BIU clearance = biuParse( line + SZ( "ZClearance" ), &data );
2666  char* padoption = strtok_r( (char*) data, delims, &saveptr ); // data: " I"
2667 
2668  ZoneConnection popt;
2669  switch( *padoption )
2670  {
2671  case 'I': popt = PAD_ZONE_CONN_FULL; break;
2672  case 'T': popt = PAD_ZONE_CONN_THERMAL; break;
2673  case 'H': popt = PAD_ZONE_CONN_THT_THERMAL; break;
2674  case 'X': popt = PAD_ZONE_CONN_NONE; break;
2675 
2676  default:
2677  m_error.Printf( _( "Bad ZClearance padoption for CZONE_CONTAINER \"%s\"" ),
2678  zc->GetNetname().GetData() );
2680  }
2681 
2682  zc->SetZoneClearance( clearance );
2683  zc->SetPadConnection( popt );
2684  }
2685 
2686  else if( TESTLINE( "ZMinThickness" ) )
2687  {
2688  BIU thickness = biuParse( line + SZ( "ZMinThickness" ) );
2689  zc->SetMinThickness( thickness );
2690  }
2691 
2692  else if( TESTLINE( "ZPriority" ) )
2693  {
2694  int priority = intParse( line + SZ( "ZPriority" ) );
2695  zc->SetPriority( priority );
2696  }
2697 
2698  else if( TESTLINE( "$POLYSCORNERS" ) )
2699  {
2700  // Read the PolysList (polygons that are the solid areas in the filled zone)
2701  SHAPE_POLY_SET polysList;
2702 
2703  bool makeNewOutline = true;
2704 
2705  while( ( line = READLINE( m_reader ) ) != NULL )
2706  {
2707  if( TESTLINE( "$endPOLYSCORNERS" ) )
2708  break;
2709 
2710  // e.g. "39610 43440 0 0"
2711  BIU x = biuParse( line, &data );
2712  BIU y = biuParse( data, &data );
2713 
2714  if( makeNewOutline )
2715  polysList.NewOutline();
2716 
2717  polysList.Append( x, y );
2718 
2719  bool end_contour = intParse( data, &data ); // end_countour was a bool when file saved, so '0' or '1' here
2720  intParse( data ); // skip corner utility flag
2721 
2722  makeNewOutline = end_contour;
2723  }
2724 
2725  zc->SetFilledPolysList( polysList );
2726  }
2727 
2728  else if( TESTLINE( "$FILLSEGMENTS" ) )
2729  {
2730  while( ( line = READLINE( m_reader ) ) != NULL )
2731  {
2732  if( TESTLINE( "$endFILLSEGMENTS" ) )
2733  break;
2734 
2735  // e.g. ""%d %d %d %d\n"
2736  BIU sx = biuParse( line, &data );
2737  BIU sy = biuParse( data, &data );
2738  BIU ex = biuParse( data, &data );
2739  BIU ey = biuParse( data );
2740 
2741  zc->FillSegments().push_back( SEG( VECTOR2I( sx, sy ), VECTOR2I( ex, ey ) ) );
2742  }
2743  }
2744 
2745  else if( TESTLINE( "$endCZONE_OUTLINE" ) )
2746  {
2747  // Ensure keepout does not have a net
2748  // (which have no sense for a keepout zone)
2749  if( zc->GetIsKeepout() )
2750  zc->SetNetCode( NETINFO_LIST::UNCONNECTED );
2751 
2752  // should always occur, but who knows, a zone without two corners
2753  // is no zone at all, it's a spot?
2754 
2755  if( zc->GetNumCorners() > 2 )
2756  {
2757  if( !zc->IsOnCopperLayer() )
2758  {
2759  zc->SetFillMode( ZFM_POLYGONS );
2760  zc->SetNetCode( NETINFO_LIST::UNCONNECTED );
2761  }
2762 
2763  // Hatch here, after outlines corners are read
2764  // Set hatch here, after outlines corners are read
2765  zc->SetHatch( outline_hatch, ZONE_CONTAINER::GetDefaultHatchPitch(),
2766  true );
2767 
2768  m_board->Add( zc.release() );
2769  }
2770 
2771  return; // preferred exit
2772  }
2773  }
2774 
2775  THROW_IO_ERROR( "Missing '$endCZONE_OUTLINE'" );
2776 }
void SetModified()
Definition: base_struct.cpp:98
Class ZONE_CONTAINER handles a list of polygons defining a copper zone.
Definition: class_zone.h:60
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:65
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:53
int ReadDelimitedText(wxString *aDest, const char *aSource)
Copy bytes from aSource delimited string segment to aDest wxString.
Definition: string.cpp:155
#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 3105 of file legacy_plugin.cpp.

3106 {
3107  auto sM = me->Models().begin();
3108  auto eM = me->Models().end();
3109 
3110  while( sM != eM )
3111  {
3112  if( sM->m_Filename.empty() )
3113  {
3114  ++sM;
3115  continue;
3116  }
3117 
3118  fprintf( m_fp, "$SHAPE3D\n" );
3119 
3120  fprintf( m_fp, "Na %s\n", EscapedUTF8( sM->m_Filename ).c_str() );
3121 
3122  fprintf(m_fp,
3123 #if defined(DEBUG)
3124  // use old formats for testing, just to verify compatibility
3125  // using "diff", then switch to more concise form for release builds.
3126  "Sc %lf %lf %lf\n",
3127 #else
3128  "Sc %.10g %.10g %.10g\n",
3129 #endif
3130  sM->m_Scale.x,
3131  sM->m_Scale.y,
3132  sM->m_Scale.z );
3133 
3134  fprintf(m_fp,
3135 #if defined(DEBUG)
3136  "Of %lf %lf %lf\n",
3137 #else
3138  "Of %.10g %.10g %.10g\n",
3139 #endif
3140  sM->m_Offset.x,
3141  sM->m_Offset.y,
3142  sM->m_Offset.z );
3143 
3144  fprintf(m_fp,
3145 #if defined(DEBUG)
3146  "Ro %lf %lf %lf\n",
3147 #else
3148  "Ro %.10g %.10g %.10g\n",
3149 #endif
3150  sM->m_Rotation.x,
3151  sM->m_Rotation.y,
3152  sM->m_Rotation.z );
3153 
3154  fprintf( m_fp, "$EndSHAPE3D\n" );
3155 
3156  ++sM;
3157  }
3158 
3159  return;
3160 }
FILE * m_fp
no ownership here.
std::string EscapedUTF8(wxString aString)
Function EscapedUTF8 returns an 8 bit UTF8 string given aString in unicode form.
Definition: string.cpp:249

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: