4794 lines
151 KiB
C++
4794 lines
151 KiB
C++
|
|
/*
|
|
* This program source code file is part of KiCad, a free EDA CAD application.
|
|
*
|
|
* Copyright (C) 2007-2012 SoftPLC Corporation, Dick Hollenbeck <dick@softplc.com>
|
|
* Copyright (C) 2004 Jean-Pierre Charras, jp.charras@wanadoo.fr
|
|
* Copyright (C) 1992-2016 KiCad Developers, see AUTHORS.txt for contributors.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, you may find one here:
|
|
* http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
|
|
* or you may search the http://www.gnu.org website for the version 2 license,
|
|
* or you may write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
/*
|
|
This implements loading and saving a BOARD, behind the PLUGIN interface.
|
|
|
|
The definitions:
|
|
|
|
*) a Board Internal Unit (BIU) is a unit of length that is used only internally
|
|
to PCBNEW, and is nanometers when this work is done, but deci-mils until done.
|
|
|
|
The philosophies:
|
|
|
|
*) BIUs should be typed as such to distinguish them from ints. This is mostly
|
|
for human readability, and having the type nearby in the source supports this readability.
|
|
*) Do not assume that BIUs will always be int, doing a sscanf() into a BIU
|
|
does not make sense in case the size of the BIU changes.
|
|
*) variables are put onto the stack in an automatic, even when it might look
|
|
more efficient to do otherwise. This is so we can seem them with a debugger.
|
|
*) Global variables should not be touched from within a PLUGIN, since it will eventually
|
|
be in a DLL/DSO. This includes window information too. The PLUGIN API knows
|
|
nothing of wxFrame or globals and all error reporting must be done by throwing
|
|
an exception.
|
|
*) No wxWindowing calls are made in here, since the UI resides higher up than in here,
|
|
and is going to process a bucket of detailed information thrown from down here
|
|
in the form of an exception if an error happens.
|
|
*) Much of what we do in this source file is for human readability, not performance.
|
|
Simply avoiding strtok() more often than the old code washes out performance losses.
|
|
Remember strncmp() will bail as soon as a mismatch happens, not going all the way
|
|
to end of string unless a full match.
|
|
*) angles are in the process of migrating to doubles, and 'int' if used, is
|
|
only shortterm, and along with this a change, and transition from from
|
|
"tenths of degrees" to simply "degrees" in the double (which has no problem
|
|
representing any portion of a degree).
|
|
*/
|
|
|
|
|
|
#include <cmath>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <wx/ffile.h>
|
|
|
|
#include <legacy_plugin.h> // implement this here
|
|
|
|
#include <kicad_string.h>
|
|
#include <macros.h>
|
|
#include <zones.h>
|
|
|
|
#include <class_board.h>
|
|
#include <class_module.h>
|
|
#include <class_track.h>
|
|
#include <class_pcb_text.h>
|
|
#include <class_zone.h>
|
|
#include <class_dimension.h>
|
|
#include <class_drawsegment.h>
|
|
#include <class_mire.h>
|
|
#include <class_edge_mod.h>
|
|
#include <3d_struct.h>
|
|
#include <pcb_plot_params.h>
|
|
#include <pcb_plot_params_parser.h>
|
|
#include <drawtxt.h>
|
|
#include <convert_to_biu.h>
|
|
#include <trigo.h>
|
|
#include <build_version.h>
|
|
|
|
#include <boost/make_shared.hpp>
|
|
|
|
|
|
typedef LEGACY_PLUGIN::BIU BIU;
|
|
|
|
|
|
#define VERSION_ERROR_FORMAT _( "File '%s' is format version: %d.\nI only support format version <= %d.\nPlease upgrade Pcbnew to load this file." )
|
|
#define UNKNOWN_GRAPHIC_FORMAT _( "unknown graphic type: %d")
|
|
#define UNKNOWN_PAD_FORMAT _( "unknown pad type: %d")
|
|
#define UNKNOWN_PAD_ATTRIBUTE _( "unknown pad attribute: %d" )
|
|
|
|
|
|
typedef unsigned LEG_MASK;
|
|
|
|
#define FIRST_LAYER 0
|
|
#define FIRST_COPPER_LAYER 0
|
|
#define LAYER_N_BACK 0
|
|
#define LAYER_N_2 1
|
|
#define LAYER_N_3 2
|
|
#define LAYER_N_4 3
|
|
#define LAYER_N_5 4
|
|
#define LAYER_N_6 5
|
|
#define LAYER_N_7 6
|
|
#define LAYER_N_8 7
|
|
#define LAYER_N_9 8
|
|
#define LAYER_N_10 9
|
|
#define LAYER_N_11 10
|
|
#define LAYER_N_12 11
|
|
#define LAYER_N_13 12
|
|
#define LAYER_N_14 13
|
|
#define LAYER_N_15 14
|
|
#define LAYER_N_FRONT 15
|
|
#define LAST_COPPER_LAYER LAYER_N_FRONT
|
|
|
|
#define FIRST_NON_COPPER_LAYER 16
|
|
#define ADHESIVE_N_BACK 16
|
|
#define ADHESIVE_N_FRONT 17
|
|
#define SOLDERPASTE_N_BACK 18
|
|
#define SOLDERPASTE_N_FRONT 19
|
|
#define SILKSCREEN_N_BACK 20
|
|
#define SILKSCREEN_N_FRONT 21
|
|
#define SOLDERMASK_N_BACK 22
|
|
#define SOLDERMASK_N_FRONT 23
|
|
#define DRAW_N 24
|
|
#define COMMENT_N 25
|
|
#define ECO1_N 26
|
|
#define ECO2_N 27
|
|
#define EDGE_N 28
|
|
#define LAST_NON_COPPER_LAYER 28
|
|
|
|
// Masks to identify a layer by a bit map
|
|
typedef unsigned LAYER_MSK;
|
|
#define LAYER_BACK (1 << LAYER_N_BACK) ///< bit mask for copper layer
|
|
#define LAYER_2 (1 << LAYER_N_2) ///< bit mask for layer 2
|
|
#define LAYER_3 (1 << LAYER_N_3) ///< bit mask for layer 3
|
|
#define LAYER_4 (1 << LAYER_N_4) ///< bit mask for layer 4
|
|
#define LAYER_5 (1 << LAYER_N_5) ///< bit mask for layer 5
|
|
#define LAYER_6 (1 << LAYER_N_6) ///< bit mask for layer 6
|
|
#define LAYER_7 (1 << LAYER_N_7) ///< bit mask for layer 7
|
|
#define LAYER_8 (1 << LAYER_N_8) ///< bit mask for layer 8
|
|
#define LAYER_9 (1 << LAYER_N_9) ///< bit mask for layer 9
|
|
#define LAYER_10 (1 << LAYER_N_10) ///< bit mask for layer 10
|
|
#define LAYER_11 (1 << LAYER_N_11) ///< bit mask for layer 11
|
|
#define LAYER_12 (1 << LAYER_N_12) ///< bit mask for layer 12
|
|
#define LAYER_13 (1 << LAYER_N_13) ///< bit mask for layer 13
|
|
#define LAYER_14 (1 << LAYER_N_14) ///< bit mask for layer 14
|
|
#define LAYER_15 (1 << LAYER_N_15) ///< bit mask for layer 15
|
|
#define LAYER_FRONT (1 << LAYER_N_FRONT) ///< bit mask for component layer
|
|
#define ADHESIVE_LAYER_BACK (1 << ADHESIVE_N_BACK)
|
|
#define ADHESIVE_LAYER_FRONT (1 << ADHESIVE_N_FRONT)
|
|
#define SOLDERPASTE_LAYER_BACK (1 << SOLDERPASTE_N_BACK)
|
|
#define SOLDERPASTE_LAYER_FRONT (1 << SOLDERPASTE_N_FRONT)
|
|
#define SILKSCREEN_LAYER_BACK (1 << SILKSCREEN_N_BACK)
|
|
#define SILKSCREEN_LAYER_FRONT (1 << SILKSCREEN_N_FRONT)
|
|
#define SOLDERMASK_LAYER_BACK (1 << SOLDERMASK_N_BACK)
|
|
#define SOLDERMASK_LAYER_FRONT (1 << SOLDERMASK_N_FRONT)
|
|
#define DRAW_LAYER (1 << DRAW_N)
|
|
#define COMMENT_LAYER (1 << COMMENT_N)
|
|
#define ECO1_LAYER (1 << ECO1_N)
|
|
#define ECO2_LAYER (1 << ECO2_N)
|
|
#define EDGE_LAYER (1 << EDGE_N)
|
|
|
|
// Helpful global layer masks:
|
|
// ALL_AUX_LAYERS layers are technical layers, ALL_NO_CU_LAYERS has user
|
|
// and edge layers too!
|
|
#define ALL_NO_CU_LAYERS 0x1FFF0000
|
|
#define ALL_CU_LAYERS 0x0000FFFF
|
|
#define FRONT_TECH_LAYERS (SILKSCREEN_LAYER_FRONT | SOLDERMASK_LAYER_FRONT \
|
|
| ADHESIVE_LAYER_FRONT | SOLDERPASTE_LAYER_FRONT)
|
|
#define BACK_TECH_LAYERS (SILKSCREEN_LAYER_BACK | SOLDERMASK_LAYER_BACK \
|
|
| ADHESIVE_LAYER_BACK | SOLDERPASTE_LAYER_BACK)
|
|
#define ALL_TECH_LAYERS (FRONT_TECH_LAYERS | BACK_TECH_LAYERS)
|
|
#define BACK_LAYERS (LAYER_BACK | BACK_TECH_LAYERS)
|
|
#define FRONT_LAYERS (LAYER_FRONT | FRONT_TECH_LAYERS)
|
|
|
|
#define ALL_USER_LAYERS (DRAW_LAYER | COMMENT_LAYER | ECO1_LAYER | ECO2_LAYER )
|
|
|
|
#define NO_LAYERS 0x00000000
|
|
|
|
|
|
// Old internal units definition (UI = decimil)
|
|
#define PCB_LEGACY_INTERNAL_UNIT 10000
|
|
|
|
/// Get the length of a string constant, at compile time
|
|
#define SZ( x ) (sizeof(x)-1)
|
|
|
|
|
|
static const char delims[] = " \t\r\n";
|
|
|
|
|
|
static bool inline isSpace( int c ) { return strchr( delims, c ) != 0; }
|
|
|
|
#define MASK(x) (1<<(x))
|
|
|
|
//-----<BOARD Load Functions>---------------------------------------------------
|
|
|
|
/// C string compare test for a specific length of characters.
|
|
#define TESTLINE( x ) ( !strnicmp( line, x, SZ( x ) ) && isSpace( line[SZ( x )] ) )
|
|
|
|
/// C sub-string compare test for a specific length of characters.
|
|
#define TESTSUBSTR( x ) ( !strnicmp( line, x, SZ( x ) ) )
|
|
|
|
|
|
#if 1
|
|
#define READLINE( rdr ) rdr->ReadLine()
|
|
|
|
#else
|
|
/// The function and macro which follow comprise a shim which can be a
|
|
/// monitor on lines of text read in from the input file.
|
|
/// And it can be used as a trap.
|
|
static inline char* ReadLine( LINE_READER* rdr, const char* caller )
|
|
{
|
|
char* ret = rdr->ReadLine();
|
|
|
|
const char* line = rdr->Line();
|
|
printf( "%-6u %s: %s", rdr->LineNumber(), caller, line );
|
|
|
|
#if 0 // trap
|
|
if( !strcmp( "loadSETUP", caller ) && !strcmp( "$EndSETUP\n", line ) )
|
|
{
|
|
int breakhere = 1;
|
|
}
|
|
#endif
|
|
|
|
return ret;
|
|
}
|
|
#define READLINE( rdr ) ReadLine( rdr, __FUNCTION__ )
|
|
#endif
|
|
|
|
|
|
|
|
using namespace std; // auto_ptr
|
|
|
|
|
|
static inline const char* ShowVertJustify( EDA_TEXT_VJUSTIFY_T vertical )
|
|
{
|
|
const char* rs;
|
|
switch( vertical )
|
|
{
|
|
case GR_TEXT_VJUSTIFY_TOP: rs = "T"; break;
|
|
case GR_TEXT_VJUSTIFY_CENTER: rs = "C"; break;
|
|
case GR_TEXT_VJUSTIFY_BOTTOM: rs = "B"; break;
|
|
default: rs = "?"; break;
|
|
}
|
|
return rs;
|
|
}
|
|
|
|
static inline const char* ShowHorizJustify( EDA_TEXT_HJUSTIFY_T horizontal )
|
|
{
|
|
const char* rs;
|
|
switch( horizontal )
|
|
{
|
|
case GR_TEXT_HJUSTIFY_LEFT: rs = "L"; break;
|
|
case GR_TEXT_HJUSTIFY_CENTER: rs = "C"; break;
|
|
case GR_TEXT_HJUSTIFY_RIGHT: rs = "R"; break;
|
|
default: rs = "?"; break;
|
|
}
|
|
return rs;
|
|
}
|
|
|
|
static EDA_TEXT_HJUSTIFY_T horizJustify( const char* horizontal )
|
|
{
|
|
if( !strcmp( "L", horizontal ) )
|
|
return GR_TEXT_HJUSTIFY_LEFT;
|
|
if( !strcmp( "R", horizontal ) )
|
|
return GR_TEXT_HJUSTIFY_RIGHT;
|
|
return GR_TEXT_HJUSTIFY_CENTER;
|
|
}
|
|
|
|
static EDA_TEXT_VJUSTIFY_T vertJustify( const char* vertical )
|
|
{
|
|
if( !strcmp( "T", vertical ) )
|
|
return GR_TEXT_VJUSTIFY_TOP;
|
|
if( !strcmp( "B", vertical ) )
|
|
return GR_TEXT_VJUSTIFY_BOTTOM;
|
|
return GR_TEXT_VJUSTIFY_CENTER;
|
|
}
|
|
|
|
|
|
/// Count the number of set layers in the mask
|
|
inline int layerMaskCountSet( LEG_MASK aMask )
|
|
{
|
|
int count = 0;
|
|
|
|
for( int i = 0; aMask; ++i, aMask >>= 1 )
|
|
{
|
|
if( aMask & 1 )
|
|
++count;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
|
|
// return true if aLegacyLayerNum is a valid copper layer legacy id, therefore
|
|
// top, bottom or inner activated layer
|
|
inline bool is_leg_copperlayer_valid( int aCu_Count, LAYER_NUM aLegacyLayerNum )
|
|
{
|
|
return ( aLegacyLayerNum == LAYER_N_FRONT ) || ( aLegacyLayerNum < aCu_Count );
|
|
}
|
|
|
|
|
|
LAYER_ID LEGACY_PLUGIN::leg_layer2new( int cu_count, LAYER_NUM aLayerNum )
|
|
{
|
|
int newid;
|
|
unsigned old = aLayerNum;
|
|
|
|
// this is a speed critical function, be careful.
|
|
|
|
if( unsigned( old ) <= unsigned( LAYER_N_FRONT ) )
|
|
{
|
|
if( old == LAYER_N_FRONT )
|
|
newid = F_Cu;
|
|
else if( old == LAYER_N_BACK )
|
|
newid = B_Cu;
|
|
else
|
|
{
|
|
newid = cu_count - 1 - old;
|
|
wxASSERT( newid >= 0 );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch( old )
|
|
{
|
|
case ADHESIVE_N_BACK: newid = B_Adhes; break;
|
|
case ADHESIVE_N_FRONT: newid = F_Adhes; break;
|
|
case SOLDERPASTE_N_BACK: newid = B_Paste; break;
|
|
case SOLDERPASTE_N_FRONT: newid = F_Paste; break;
|
|
case SILKSCREEN_N_BACK: newid = B_SilkS; break;
|
|
case SILKSCREEN_N_FRONT: newid = F_SilkS; break;
|
|
case SOLDERMASK_N_BACK: newid = B_Mask; break;
|
|
case SOLDERMASK_N_FRONT: newid = F_Mask; break;
|
|
case DRAW_N: newid = Dwgs_User; break;
|
|
case COMMENT_N: newid = Cmts_User; break;
|
|
case ECO1_N: newid = Eco1_User; break;
|
|
case ECO2_N: newid = Eco2_User; break;
|
|
case EDGE_N: newid = Edge_Cuts; break;
|
|
default:
|
|
// wxASSERT( 0 );
|
|
// Remap all illegal non copper layers to comment layer
|
|
newid = Cmts_User;
|
|
}
|
|
}
|
|
|
|
return LAYER_ID( newid );
|
|
}
|
|
|
|
|
|
LSET LEGACY_PLUGIN::leg_mask2new( int cu_count, unsigned aMask )
|
|
{
|
|
LSET ret;
|
|
|
|
if( ( aMask & ALL_CU_LAYERS ) == ALL_CU_LAYERS )
|
|
{
|
|
ret = LSET::AllCuMask();
|
|
|
|
aMask &= ~ALL_CU_LAYERS;
|
|
}
|
|
|
|
for( int i=0; aMask; ++i, aMask >>= 1 )
|
|
{
|
|
if( aMask & 1 )
|
|
ret.set( leg_layer2new( cu_count, i ) );
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
/**
|
|
* Function intParse
|
|
* parses an ASCII integer string with possible leading whitespace into
|
|
* an integer and updates the pointer at \a out if it is not NULL, just
|
|
* like "man strtol()". I can use this without casting, and its name says
|
|
* what I am doing.
|
|
*/
|
|
static inline int intParse( const char* next, const char** out = NULL )
|
|
{
|
|
// please just compile this and be quiet, hide casting ugliness:
|
|
return (int) strtol( next, (char**) out, 10 );
|
|
}
|
|
|
|
/**
|
|
* Function layerParse
|
|
* Like intParse but returns a LAYER_NUM
|
|
*/
|
|
static inline LAYER_NUM layerParse( const char* next, const char** out = NULL )
|
|
{
|
|
return intParse( next, out );
|
|
}
|
|
|
|
/**
|
|
* Function hexParse
|
|
* parses an ASCII hex integer string with possible leading whitespace into
|
|
* a long integer and updates the pointer at \a out if it is not NULL, just
|
|
* like "man strtol". I can use this without casting, and its name says
|
|
* what I am doing.
|
|
*/
|
|
static inline long hexParse( const char* next, const char** out = NULL )
|
|
{
|
|
// please just compile this and be quiet, hide casting ugliness:
|
|
return strtol( next, (char**) out, 16 );
|
|
}
|
|
|
|
|
|
BOARD* LEGACY_PLUGIN::Load( const wxString& aFileName, BOARD* aAppendToMe,
|
|
const PROPERTIES* aProperties )
|
|
{
|
|
LOCALE_IO toggle; // toggles on, then off, the C locale.
|
|
|
|
init( aProperties );
|
|
|
|
m_board = aAppendToMe ? aAppendToMe : new BOARD();
|
|
|
|
// Give the filename to the board if it's new
|
|
if( !aAppendToMe )
|
|
m_board->SetFileName( aFileName );
|
|
|
|
// delete on exception, iff I own m_board, according to aAppendToMe
|
|
auto_ptr<BOARD> deleter( aAppendToMe ? NULL : m_board );
|
|
|
|
FILE_LINE_READER reader( aFileName );
|
|
|
|
m_reader = &reader; // member function accessibility
|
|
|
|
checkVersion();
|
|
|
|
loadAllSections( bool( aAppendToMe ) );
|
|
|
|
deleter.release();
|
|
return m_board;
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::loadAllSections( bool doAppend )
|
|
{
|
|
// $GENERAL section is first
|
|
|
|
// $SHEETDESCR section is next
|
|
|
|
// $SETUP section is next
|
|
|
|
// Then follows $EQUIPOT and all the rest
|
|
char* line;
|
|
|
|
while( ( line = READLINE( m_reader ) ) != NULL )
|
|
{
|
|
// put the more frequent ones at the top, but realize TRACKs are loaded as a group
|
|
|
|
if( TESTLINE( "$MODULE" ) )
|
|
{
|
|
auto_ptr<MODULE> module( new MODULE( m_board ) );
|
|
|
|
FPID fpid;
|
|
std::string fpName = StrPurge( line + SZ( "$MODULE" ) );
|
|
|
|
// The footprint names in legacy libraries can contain the '/' and ':'
|
|
// characters which will cause the FPID parser to choke.
|
|
ReplaceIllegalFileNameChars( &fpName );
|
|
|
|
if( !fpName.empty() )
|
|
fpid = FPID( fpName );
|
|
|
|
module->SetFPID( fpid );
|
|
|
|
loadMODULE( module.get() );
|
|
m_board->Add( module.release(), ADD_APPEND );
|
|
}
|
|
|
|
else if( TESTLINE( "$DRAWSEGMENT" ) )
|
|
{
|
|
loadPCB_LINE();
|
|
}
|
|
|
|
else if( TESTLINE( "$EQUIPOT" ) )
|
|
{
|
|
loadNETINFO_ITEM();
|
|
}
|
|
|
|
else if( TESTLINE( "$TEXTPCB" ) )
|
|
{
|
|
loadPCB_TEXT();
|
|
}
|
|
|
|
else if( TESTLINE( "$TRACK" ) )
|
|
{
|
|
loadTrackList( PCB_TRACE_T );
|
|
}
|
|
|
|
else if( TESTLINE( "$NCLASS" ) )
|
|
{
|
|
loadNETCLASS();
|
|
}
|
|
|
|
else if( TESTLINE( "$CZONE_OUTLINE" ) )
|
|
{
|
|
loadZONE_CONTAINER();
|
|
}
|
|
|
|
else if( TESTLINE( "$COTATION" ) )
|
|
{
|
|
loadDIMENSION();
|
|
}
|
|
|
|
else if( TESTLINE( "$PCB_TARGET" ) || TESTLINE( "$MIREPCB" ) )
|
|
{
|
|
loadPCB_TARGET();
|
|
}
|
|
|
|
else if( TESTLINE( "$ZONE" ) )
|
|
{
|
|
loadTrackList( PCB_ZONE_T );
|
|
}
|
|
|
|
else if( TESTLINE( "$GENERAL" ) )
|
|
{
|
|
loadGENERAL();
|
|
}
|
|
|
|
else if( TESTLINE( "$SHEETDESCR" ) )
|
|
{
|
|
loadSHEET();
|
|
}
|
|
|
|
else if( TESTLINE( "$SETUP" ) )
|
|
{
|
|
if( !doAppend )
|
|
{
|
|
loadSETUP();
|
|
}
|
|
else
|
|
{
|
|
while( ( line = READLINE( m_reader ) ) != NULL )
|
|
{
|
|
// gobble until $EndSetup
|
|
if( TESTLINE( "$EndSETUP" ) )
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
else if( TESTLINE( "$EndBOARD" ) )
|
|
return; // preferred exit
|
|
}
|
|
|
|
THROW_IO_ERROR( "Missing '$EndBOARD'" );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::checkVersion()
|
|
{
|
|
// Read first line and TEST if it is a PCB file format header like this:
|
|
// "PCBNEW-BOARD Version 1 ...."
|
|
|
|
m_reader->ReadLine();
|
|
|
|
char* line = m_reader->Line();
|
|
|
|
if( !TESTLINE( "PCBNEW-BOARD" ) )
|
|
{
|
|
THROW_IO_ERROR( "Unknown file type" );
|
|
}
|
|
|
|
int ver = 1; // if sccanf fails
|
|
sscanf( line, "PCBNEW-BOARD Version %d", &ver );
|
|
|
|
#if !defined(DEBUG)
|
|
if( ver > LEGACY_BOARD_FILE_VERSION )
|
|
{
|
|
// "File '%s' is format version: %d.\nI only support format version <= %d.\nPlease upgrade Pcbnew to load this file."
|
|
m_error.Printf( VERSION_ERROR_FORMAT,
|
|
m_reader->GetSource().GetData(), ver, LEGACY_BOARD_FILE_VERSION );
|
|
THROW_IO_ERROR( m_error );
|
|
}
|
|
#endif
|
|
|
|
m_loading_format_version = ver;
|
|
m_board->SetFileFormatVersionAtLoad( m_loading_format_version );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::loadGENERAL()
|
|
{
|
|
char* line;
|
|
char* saveptr;
|
|
bool saw_LayerCount = false;
|
|
|
|
while( ( line = READLINE( m_reader ) ) != NULL )
|
|
{
|
|
const char* data;
|
|
|
|
if( TESTLINE( "Units" ) )
|
|
{
|
|
// what are the engineering units of the lengths in the BOARD?
|
|
data = strtok_r( line + SZ("Units"), delims, &saveptr );
|
|
|
|
if( !strcmp( data, "mm" ) )
|
|
{
|
|
diskToBiu = IU_PER_MM;
|
|
}
|
|
}
|
|
|
|
else if( TESTLINE( "LayerCount" ) )
|
|
{
|
|
int tmp = intParse( line + SZ( "LayerCount" ) );
|
|
m_board->SetCopperLayerCount( tmp );
|
|
|
|
// This has to be set early so that leg_layer2new() works OK, and
|
|
// that means before parsing "EnabledLayers" and "VisibleLayers".
|
|
m_cu_count = tmp;
|
|
|
|
saw_LayerCount = true;
|
|
}
|
|
|
|
else if( TESTLINE( "EnabledLayers" ) )
|
|
{
|
|
if( !saw_LayerCount )
|
|
THROW_IO_ERROR( "Missing '$GENERAL's LayerCount" );
|
|
|
|
LEG_MASK enabledLayers = hexParse( line + SZ( "EnabledLayers" ) );
|
|
|
|
LSET new_mask = leg_mask2new( m_cu_count, enabledLayers );
|
|
|
|
//DBG( printf( "EnabledLayers: %s\n", new_mask.FmtHex().c_str() );)
|
|
|
|
m_board->SetEnabledLayers( new_mask );
|
|
|
|
// layer visibility equals layer usage, unless overridden later via "VisibleLayers"
|
|
// Must call SetEnabledLayers() before calling SetVisibleLayers().
|
|
m_board->SetVisibleLayers( new_mask );
|
|
}
|
|
|
|
else if( TESTLINE( "VisibleLayers" ) )
|
|
{
|
|
if( !saw_LayerCount )
|
|
THROW_IO_ERROR( "Missing '$GENERAL's LayerCount" );
|
|
|
|
LEG_MASK visibleLayers = hexParse( line + SZ( "VisibleLayers" ) );
|
|
|
|
LSET new_mask = leg_mask2new( m_cu_count, visibleLayers );
|
|
|
|
m_board->SetVisibleLayers( new_mask );
|
|
}
|
|
|
|
else if( TESTLINE( "Ly" ) ) // Old format for Layer count
|
|
{
|
|
if( !saw_LayerCount )
|
|
{
|
|
LEG_MASK layer_mask = hexParse( line + SZ( "Ly" ) );
|
|
|
|
m_cu_count = layerMaskCountSet( layer_mask & ALL_CU_LAYERS );
|
|
|
|
m_board->SetCopperLayerCount( m_cu_count );
|
|
|
|
saw_LayerCount = true;
|
|
}
|
|
}
|
|
|
|
else if( TESTLINE( "BoardThickness" ) )
|
|
{
|
|
BIU thickn = biuParse( line + SZ( "BoardThickness" ) );
|
|
m_board->GetDesignSettings().SetBoardThickness( thickn );
|
|
}
|
|
|
|
/*
|
|
else if( TESTLINE( "Links" ) )
|
|
{
|
|
// Info only, do nothing, but only for a short while.
|
|
}
|
|
*/
|
|
|
|
else if( TESTLINE( "NoConn" ) )
|
|
{
|
|
int tmp = intParse( line + SZ( "NoConn" ) );
|
|
m_board->SetUnconnectedNetCount( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( "Di" ) )
|
|
{
|
|
BIU x1 = biuParse( line + SZ( "Di" ), &data );
|
|
BIU y1 = biuParse( data, &data );
|
|
BIU x2 = biuParse( data, &data );
|
|
BIU y2 = biuParse( data );
|
|
|
|
EDA_RECT bbbox( wxPoint( x1, y1 ), wxSize( x2-x1, y2-y1 ) );
|
|
|
|
m_board->SetBoundingBox( bbbox );
|
|
}
|
|
|
|
/* This is no more usefull, so this info is no more parsed
|
|
// Read the number of segments of type DRAW, TRACK, ZONE
|
|
else if( TESTLINE( "Ndraw" ) )
|
|
{
|
|
NbDraw = intParse( line + SZ( "Ndraw" ) );
|
|
}
|
|
|
|
else if( TESTLINE( "Ntrack" ) )
|
|
{
|
|
NbTrack = intParse( line + SZ( "Ntrack" ) );
|
|
}
|
|
|
|
else if( TESTLINE( "Nzone" ) )
|
|
{
|
|
NbZone = intParse( line + SZ( "Nzone" ) );
|
|
}
|
|
|
|
else if( TESTLINE( "Nmodule" ) )
|
|
{
|
|
NbMod = intParse( line + SZ( "Nmodule" ) );
|
|
}*/
|
|
|
|
else if( TESTLINE( "Nnets" ) )
|
|
{
|
|
m_netCodes.resize( intParse( line + SZ( "Nnets" ) ) );
|
|
}
|
|
|
|
else if( TESTLINE( "Nn" ) ) // id "Nnets" for old .brd files
|
|
{
|
|
m_netCodes.resize( intParse( line + SZ( "Nn" ) ) );
|
|
}
|
|
|
|
else if( TESTLINE( "$EndGENERAL" ) )
|
|
return; // preferred exit
|
|
}
|
|
|
|
THROW_IO_ERROR( "Missing '$EndGENERAL'" );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::loadSHEET()
|
|
{
|
|
char buf[260];
|
|
TITLE_BLOCK tb;
|
|
char* line;
|
|
char* saveptr;
|
|
|
|
while( ( line = READLINE( m_reader ) ) != NULL )
|
|
{
|
|
if( TESTLINE( "Sheet" ) )
|
|
{
|
|
// e.g. "Sheet A3 16535 11700"
|
|
// width and height are in 1/1000th of an inch, always
|
|
|
|
PAGE_INFO page;
|
|
char* sname = strtok_r( line + SZ( "Sheet" ), delims, &saveptr );
|
|
|
|
if( sname )
|
|
{
|
|
wxString wname = FROM_UTF8( sname );
|
|
if( !page.SetType( wname ) )
|
|
{
|
|
m_error.Printf( _( "Unknown sheet type '%s' on line:%d" ),
|
|
wname.GetData(), m_reader->LineNumber() );
|
|
THROW_IO_ERROR( m_error );
|
|
}
|
|
|
|
char* width = strtok_r( NULL, delims, &saveptr );
|
|
char* height = strtok_r( NULL, delims, &saveptr );
|
|
char* orient = strtok_r( NULL, delims, &saveptr );
|
|
|
|
// only parse the width and height if page size is custom ("User")
|
|
if( wname == PAGE_INFO::Custom )
|
|
{
|
|
if( width && height )
|
|
{
|
|
// legacy disk file describes paper in mils
|
|
// (1/1000th of an inch)
|
|
int w = intParse( width );
|
|
int h = intParse( height );
|
|
|
|
page.SetWidthMils( w );
|
|
page.SetHeightMils( h );
|
|
}
|
|
}
|
|
|
|
if( orient && !strcmp( orient, "portrait" ) )
|
|
{
|
|
page.SetPortrait( true );
|
|
}
|
|
|
|
m_board->SetPageSettings( page );
|
|
}
|
|
}
|
|
|
|
else if( TESTLINE( "Title" ) )
|
|
{
|
|
ReadDelimitedText( buf, line, sizeof(buf) );
|
|
tb.SetTitle( FROM_UTF8( buf ) );
|
|
}
|
|
|
|
else if( TESTLINE( "Date" ) )
|
|
{
|
|
ReadDelimitedText( buf, line, sizeof(buf) );
|
|
tb.SetDate( FROM_UTF8( buf ) );
|
|
}
|
|
|
|
else if( TESTLINE( "Rev" ) )
|
|
{
|
|
ReadDelimitedText( buf, line, sizeof(buf) );
|
|
tb.SetRevision( FROM_UTF8( buf ) );
|
|
}
|
|
|
|
else if( TESTLINE( "Comp" ) )
|
|
{
|
|
ReadDelimitedText( buf, line, sizeof(buf) );
|
|
tb.SetCompany( FROM_UTF8( buf ) );
|
|
}
|
|
|
|
else if( TESTLINE( "Comment1" ) )
|
|
{
|
|
ReadDelimitedText( buf, line, sizeof(buf) );
|
|
tb.SetComment1( FROM_UTF8( buf ) );
|
|
}
|
|
|
|
else if( TESTLINE( "Comment2" ) )
|
|
{
|
|
ReadDelimitedText( buf, line, sizeof(buf) );
|
|
tb.SetComment2( FROM_UTF8( buf ) );
|
|
}
|
|
|
|
else if( TESTLINE( "Comment3" ) )
|
|
{
|
|
ReadDelimitedText( buf, line, sizeof(buf) );
|
|
tb.SetComment3( FROM_UTF8( buf ) );
|
|
}
|
|
|
|
else if( TESTLINE( "Comment4" ) )
|
|
{
|
|
ReadDelimitedText( buf, line, sizeof(buf) );
|
|
tb.SetComment4( FROM_UTF8( buf ) );
|
|
}
|
|
|
|
else if( TESTLINE( "$EndSHEETDESCR" ) )
|
|
{
|
|
m_board->SetTitleBlock( tb );
|
|
return; // preferred exit
|
|
}
|
|
}
|
|
|
|
THROW_IO_ERROR( "Missing '$EndSHEETDESCR'" );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::loadSETUP()
|
|
{
|
|
NETCLASSPTR netclass_default = m_board->GetDesignSettings().GetDefault();
|
|
// TODO Orson: is it really necessary to first operate on a copy and then apply it?
|
|
// would not it be better to use reference here and apply all the changes instantly?
|
|
BOARD_DESIGN_SETTINGS bds = m_board->GetDesignSettings();
|
|
ZONE_SETTINGS zs = m_board->GetZoneSettings();
|
|
char* line;
|
|
char* saveptr;
|
|
|
|
while( ( line = READLINE( m_reader ) ) != NULL )
|
|
{
|
|
const char* data;
|
|
|
|
if( TESTLINE( "PcbPlotParams" ) )
|
|
{
|
|
PCB_PLOT_PARAMS plot_opts;
|
|
|
|
PCB_PLOT_PARAMS_PARSER parser( line + SZ( "PcbPlotParams" ), m_reader->GetSource() );
|
|
|
|
plot_opts.Parse( &parser );
|
|
|
|
m_board->SetPlotOptions( plot_opts );
|
|
}
|
|
|
|
else if( TESTLINE( "AuxiliaryAxisOrg" ) )
|
|
{
|
|
BIU gx = biuParse( line + SZ( "AuxiliaryAxisOrg" ), &data );
|
|
BIU gy = biuParse( data );
|
|
|
|
// m_board->SetAuxOrigin( wxPoint( gx, gy ) ); gets overwritten by SetDesignSettings() below
|
|
bds.m_AuxOrigin = wxPoint( gx, gy );
|
|
}
|
|
|
|
/* Done from $General above's "LayerCount"
|
|
else if( TESTLINE( "Layers" ) )
|
|
{
|
|
int tmp = intParse( line + SZ( "Layers" ) );
|
|
m_board->SetCopperLayerCount( tmp );
|
|
|
|
m_cu_count = tmp;
|
|
}
|
|
*/
|
|
|
|
else if( TESTSUBSTR( "Layer[" ) )
|
|
{
|
|
// eg: "Layer[n] <a_Layer_name_with_no_spaces> <LAYER_T>"
|
|
|
|
LAYER_NUM layer_num = layerParse( line + SZ( "Layer[" ), &data );
|
|
LAYER_ID layer_id = leg_layer2new( m_cu_count, layer_num );
|
|
|
|
/*
|
|
switch( layer_num )
|
|
{
|
|
case LAYER_N_BACK:
|
|
layer_id = B_Cu;
|
|
break;
|
|
|
|
case LAYER_N_FRONT:
|
|
layer_id = F_Cu;
|
|
break;
|
|
|
|
default:
|
|
layer_id = LAYER_ID( layer_num );
|
|
}
|
|
*/
|
|
|
|
data = strtok_r( (char*) data+1, delims, &saveptr ); // +1 for ']'
|
|
if( data )
|
|
{
|
|
wxString layerName = FROM_UTF8( data );
|
|
m_board->SetLayerName( layer_id, layerName );
|
|
|
|
data = strtok_r( NULL, delims, &saveptr );
|
|
if( data ) // optional in old board files
|
|
{
|
|
LAYER_T type = LAYER::ParseType( data );
|
|
m_board->SetLayerType( layer_id, type );
|
|
}
|
|
}
|
|
}
|
|
|
|
else if( TESTLINE( "TrackWidth" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "TrackWidth" ) );
|
|
netclass_default->SetTrackWidth( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( "TrackWidthList" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "TrackWidthList" ) );
|
|
bds.m_TrackWidthList.push_back( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( "TrackClearence" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "TrackClearence" ) );
|
|
netclass_default->SetClearance( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( "TrackMinWidth" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "TrackMinWidth" ) );
|
|
bds.m_TrackMinWidth = tmp;
|
|
}
|
|
|
|
else if( TESTLINE( "ZoneClearence" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "ZoneClearence" ) );
|
|
zs.m_ZoneClearance = tmp;
|
|
}
|
|
|
|
else if( TESTLINE( "Zone_45_Only" ) )
|
|
{
|
|
bool tmp = (bool) intParse( line + SZ( "Zone_45_Only" ) );
|
|
zs.m_Zone_45_Only = tmp;
|
|
}
|
|
|
|
else if( TESTLINE( "DrawSegmWidth" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "DrawSegmWidth" ) );
|
|
bds.m_DrawSegmentWidth = tmp;
|
|
}
|
|
|
|
else if( TESTLINE( "EdgeSegmWidth" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "EdgeSegmWidth" ) );
|
|
bds.m_EdgeSegmentWidth = tmp;
|
|
}
|
|
|
|
else if( TESTLINE( "ViaMinSize" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "ViaMinSize" ) );
|
|
bds.m_ViasMinSize = tmp;
|
|
}
|
|
|
|
else if( TESTLINE( "MicroViaMinSize" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "MicroViaMinSize" ) );
|
|
bds.m_MicroViasMinSize = tmp;
|
|
}
|
|
|
|
else if( TESTLINE( "ViaSizeList" ) )
|
|
{
|
|
// e.g. "ViaSizeList DIAMETER [DRILL]"
|
|
|
|
BIU drill = 0;
|
|
BIU diameter = biuParse( line + SZ( "ViaSizeList" ), &data );
|
|
|
|
data = strtok_r( (char*) data, delims, &saveptr );
|
|
if( data ) // DRILL may not be present ?
|
|
drill = biuParse( data );
|
|
|
|
bds.m_ViasDimensionsList.push_back( VIA_DIMENSION( diameter,
|
|
drill ) );
|
|
}
|
|
|
|
else if( TESTLINE( "ViaSize" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "ViaSize" ) );
|
|
netclass_default->SetViaDiameter( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( "ViaDrill" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "ViaDrill" ) );
|
|
netclass_default->SetViaDrill( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( "ViaMinDrill" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "ViaMinDrill" ) );
|
|
bds.m_ViasMinDrill = tmp;
|
|
}
|
|
|
|
else if( TESTLINE( "MicroViaSize" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "MicroViaSize" ) );
|
|
netclass_default->SetuViaDiameter( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( "MicroViaDrill" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "MicroViaDrill" ) );
|
|
netclass_default->SetuViaDrill( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( "MicroViaMinDrill" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "MicroViaMinDrill" ) );
|
|
bds.m_MicroViasMinDrill = tmp;
|
|
}
|
|
|
|
else if( TESTLINE( "MicroViasAllowed" ) )
|
|
{
|
|
int tmp = intParse( line + SZ( "MicroViasAllowed" ) );
|
|
bds.m_MicroViasAllowed = tmp;
|
|
}
|
|
|
|
else if( TESTLINE( "TextPcbWidth" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "TextPcbWidth" ) );
|
|
bds.m_PcbTextWidth = tmp;
|
|
}
|
|
|
|
else if( TESTLINE( "TextPcbSize" ) )
|
|
{
|
|
BIU x = biuParse( line + SZ( "TextPcbSize" ), &data );
|
|
BIU y = biuParse( data );
|
|
|
|
bds.m_PcbTextSize = wxSize( x, y );
|
|
}
|
|
|
|
else if( TESTLINE( "EdgeModWidth" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "EdgeModWidth" ) );
|
|
bds.m_ModuleSegmentWidth = tmp;
|
|
}
|
|
|
|
else if( TESTLINE( "TextModWidth" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "TextModWidth" ) );
|
|
bds.m_ModuleTextWidth = tmp;
|
|
}
|
|
|
|
else if( TESTLINE( "TextModSize" ) )
|
|
{
|
|
BIU x = biuParse( line + SZ( "TextModSize" ), &data );
|
|
BIU y = biuParse( data );
|
|
|
|
bds.m_ModuleTextSize = wxSize( x, y );
|
|
}
|
|
|
|
else if( TESTLINE( "PadSize" ) )
|
|
{
|
|
BIU x = biuParse( line + SZ( "PadSize" ), &data );
|
|
BIU y = biuParse( data );
|
|
|
|
bds.m_Pad_Master.SetSize( wxSize( x, y ) );
|
|
}
|
|
|
|
else if( TESTLINE( "PadDrill" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "PadDrill" ) );
|
|
bds.m_Pad_Master.SetDrillSize( wxSize( tmp, tmp ) );
|
|
}
|
|
|
|
else if( TESTLINE( "Pad2MaskClearance" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "Pad2MaskClearance" ) );
|
|
bds.m_SolderMaskMargin = tmp;
|
|
}
|
|
|
|
else if( TESTLINE( "SolderMaskMinWidth" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "SolderMaskMinWidth" ) );
|
|
bds.m_SolderMaskMinWidth = tmp;
|
|
}
|
|
|
|
else if( TESTLINE( "Pad2PasteClearance" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "Pad2PasteClearance" ) );
|
|
bds.m_SolderPasteMargin = tmp;
|
|
}
|
|
|
|
else if( TESTLINE( "Pad2PasteClearanceRatio" ) )
|
|
{
|
|
double ratio = atof( line + SZ( "Pad2PasteClearanceRatio" ) );
|
|
bds.m_SolderPasteMarginRatio = ratio;
|
|
}
|
|
|
|
else if( TESTLINE( "GridOrigin" ) )
|
|
{
|
|
BIU x = biuParse( line + SZ( "GridOrigin" ), &data );
|
|
BIU y = biuParse( data );
|
|
|
|
// m_board->SetGridOrigin( wxPoint( x, y ) ); gets overwritten by SetDesignSettings() below
|
|
bds.m_GridOrigin = wxPoint( x, y );
|
|
}
|
|
|
|
else if( TESTLINE( "VisibleElements" ) )
|
|
{
|
|
int visibleElements = hexParse( line + SZ( "VisibleElements" ) );
|
|
bds.SetVisibleElements( visibleElements );
|
|
}
|
|
|
|
else if( TESTLINE( "$EndSETUP" ) )
|
|
{
|
|
m_board->SetDesignSettings( bds );
|
|
m_board->SetZoneSettings( zs );
|
|
|
|
// Very old *.brd file does not have NETCLASSes
|
|
// "TrackWidth", "ViaSize", "ViaDrill", "ViaMinSize",
|
|
// and "TrackClearence", were defined in SETUP
|
|
// these values are put into the default NETCLASS until later board load
|
|
// code should override them. *.brd files which have been
|
|
// saved with knowledge of NETCLASSes will override these
|
|
// defaults, very old boards (before 2009) will not and use the setup values.
|
|
// However these values should be the same as default NETCLASS.
|
|
|
|
return; // preferred exit
|
|
}
|
|
}
|
|
|
|
// @todo: this code is currently unreachable, would need a goto, to get here.
|
|
// that may be better handled with an #ifdef
|
|
|
|
/* Ensure tracks and vias sizes lists are ok:
|
|
* Sort lists by by increasing value and remove duplicates
|
|
* (the first value is not tested, because it is the netclass value
|
|
*/
|
|
BOARD_DESIGN_SETTINGS& designSettings = m_board->GetDesignSettings();
|
|
sort( designSettings.m_ViasDimensionsList.begin() + 1, designSettings.m_ViasDimensionsList.end() );
|
|
sort( designSettings.m_TrackWidthList.begin() + 1, designSettings.m_TrackWidthList.end() );
|
|
|
|
for( unsigned ii = 1; ii < designSettings.m_ViasDimensionsList.size() - 1; ii++ )
|
|
{
|
|
if( designSettings.m_ViasDimensionsList[ii] == designSettings.m_ViasDimensionsList[ii + 1] )
|
|
{
|
|
designSettings.m_ViasDimensionsList.erase( designSettings.m_ViasDimensionsList.begin() + ii );
|
|
ii--;
|
|
}
|
|
}
|
|
|
|
for( unsigned ii = 1; ii < designSettings.m_TrackWidthList.size() - 1; ii++ )
|
|
{
|
|
if( designSettings.m_TrackWidthList[ii] == designSettings.m_TrackWidthList[ii + 1] )
|
|
{
|
|
designSettings.m_TrackWidthList.erase( designSettings.m_TrackWidthList.begin() + ii );
|
|
ii--;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::loadMODULE( MODULE* aModule )
|
|
{
|
|
char* line;
|
|
char* saveptr;
|
|
|
|
while( ( line = READLINE( m_reader ) ) != NULL )
|
|
{
|
|
const char* data;
|
|
|
|
// most frequently encountered ones at the top
|
|
|
|
if( TESTSUBSTR( "D" ) && strchr( "SCAP", line[1] ) ) // read a drawing item, e.g. "DS"
|
|
{
|
|
loadMODULE_EDGE( aModule );
|
|
}
|
|
|
|
else if( TESTLINE( "$PAD" ) )
|
|
{
|
|
loadPAD( aModule );
|
|
}
|
|
|
|
// Read a footprint text description (ref, value, or drawing)
|
|
else if( TESTSUBSTR( "T" ) )
|
|
{
|
|
// e.g. "T1 6940 -16220 350 300 900 60 M I 20 N "CFCARD"\r\n"
|
|
|
|
int tnum = intParse( line + SZ( "T" ) );
|
|
|
|
TEXTE_MODULE* textm = 0;
|
|
|
|
switch( tnum )
|
|
{
|
|
case TEXTE_MODULE::TEXT_is_REFERENCE:
|
|
textm = &aModule->Reference();
|
|
break;
|
|
|
|
case TEXTE_MODULE::TEXT_is_VALUE:
|
|
textm = &aModule->Value();
|
|
break;
|
|
|
|
// All other fields greater than 1.
|
|
default:
|
|
textm = new TEXTE_MODULE( aModule );
|
|
aModule->GraphicalItems().PushBack( textm );
|
|
}
|
|
|
|
loadMODULE_TEXT( textm );
|
|
}
|
|
|
|
else if( TESTLINE( "Po" ) )
|
|
{
|
|
// e.g. "Po 19120 39260 900 0 4E823D06 46EAAFA5 ~~\r\n"
|
|
|
|
// 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 );
|
|
|
|
BIU pos_x = biuParse( line + SZ( "Po" ), &data );
|
|
BIU pos_y = biuParse( data, &data );
|
|
int orient = intParse( data, &data );
|
|
|
|
LAYER_NUM layer_num = layerParse( data, &data );
|
|
LAYER_ID layer_id = leg_layer2new( m_cu_count, layer_num );
|
|
|
|
long edittime = hexParse( data, &data );
|
|
time_t timestamp = hexParse( data, &data );
|
|
|
|
data = strtok_r( (char*) data+1, delims, &saveptr );
|
|
|
|
// data is now a two character long string
|
|
// Note: some old files do not have this field
|
|
if( data && data[0] == 'F' )
|
|
aModule->SetLocked( true );
|
|
|
|
if( data && data[1] == 'P' )
|
|
aModule->SetIsPlaced( true );
|
|
|
|
aModule->SetPosition( wxPoint( pos_x, pos_y ) );
|
|
aModule->SetLayer( layer_id );
|
|
aModule->SetOrientation( orient );
|
|
aModule->SetTimeStamp( timestamp );
|
|
aModule->SetLastEditTime( edittime );
|
|
}
|
|
|
|
/* footprint name set earlier, immediately after MODULE construction
|
|
else if( TESTLINE( "Li" ) ) // Library name of footprint
|
|
{
|
|
// There can be whitespace in the footprint name on some old libraries.
|
|
// Grab everything after "Li" up to end of line:
|
|
//aModule->SetFPID( FROM_UTF8( StrPurge( line + SZ( "Li" ) ) ) );
|
|
}
|
|
*/
|
|
|
|
else if( TESTLINE( "Sc" ) ) // timestamp
|
|
{
|
|
time_t timestamp = hexParse( line + SZ( "Sc" ) );
|
|
aModule->SetTimeStamp( timestamp );
|
|
}
|
|
|
|
else if( TESTLINE( "Op" ) ) // (Op)tions for auto placement
|
|
{
|
|
int itmp1 = hexParse( line + SZ( "Op" ), &data );
|
|
int itmp2 = hexParse( data );
|
|
|
|
int cntRot180 = itmp2 & 0x0F;
|
|
if( cntRot180 > 10 )
|
|
cntRot180 = 10;
|
|
|
|
aModule->SetPlacementCost180( cntRot180 );
|
|
|
|
int cntRot90 = itmp1 & 0x0F;
|
|
if( cntRot90 > 10 )
|
|
cntRot90 = 0;
|
|
|
|
itmp1 = (itmp1 >> 4) & 0x0F;
|
|
if( itmp1 > 10 )
|
|
itmp1 = 0;
|
|
|
|
aModule->SetPlacementCost90( (itmp1 << 4) | cntRot90 );
|
|
}
|
|
|
|
else if( TESTLINE( "At" ) ) // (At)tributes of module
|
|
{
|
|
int attrs = MOD_DEFAULT;
|
|
|
|
data = line + SZ( "At" );
|
|
|
|
if( strstr( data, "SMD" ) )
|
|
attrs |= MOD_CMS;
|
|
|
|
if( strstr( data, "VIRTUAL" ) )
|
|
attrs |= MOD_VIRTUAL;
|
|
|
|
aModule->SetAttributes( attrs );
|
|
}
|
|
|
|
else if( TESTLINE( "AR" ) ) // Alternate Reference
|
|
{
|
|
// e.g. "AR /47BA2624/45525076"
|
|
data = strtok_r( line + SZ( "AR" ), delims, &saveptr );
|
|
if( data )
|
|
aModule->SetPath( FROM_UTF8( data ) );
|
|
}
|
|
|
|
else if( TESTLINE( "$SHAPE3D" ) )
|
|
{
|
|
load3D( aModule );
|
|
}
|
|
|
|
else if( TESTLINE( "Cd" ) )
|
|
{
|
|
// e.g. "Cd Double rangee de contacts 2 x 4 pins\r\n"
|
|
aModule->SetDescription( FROM_UTF8( StrPurge( line + SZ( "Cd" ) ) ) );
|
|
}
|
|
|
|
else if( TESTLINE( "Kw" ) ) // Key words
|
|
{
|
|
aModule->SetKeywords( FROM_UTF8( StrPurge( line + SZ( "Kw" ) ) ) );
|
|
}
|
|
|
|
else if( TESTLINE( ".SolderPasteRatio" ) )
|
|
{
|
|
double tmp = atof( line + SZ( ".SolderPasteRatio" ) );
|
|
// Due to a bug in dialog editor in Modedit, fixed in BZR version 3565
|
|
// this parameter can be broken.
|
|
// It should be >= -50% (no solder paste) and <= 0% (full area of the pad)
|
|
|
|
if( tmp < -0.50 )
|
|
tmp = -0.50;
|
|
if( tmp > 0.0 )
|
|
tmp = 0.0;
|
|
aModule->SetLocalSolderPasteMarginRatio( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( ".SolderPaste" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( ".SolderPaste" ) );
|
|
aModule->SetLocalSolderPasteMargin( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( ".SolderMask" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( ".SolderMask" ) );
|
|
aModule->SetLocalSolderMaskMargin( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( ".LocalClearance" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( ".LocalClearance" ) );
|
|
aModule->SetLocalClearance( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( ".ZoneConnection" ) )
|
|
{
|
|
int tmp = intParse( line + SZ( ".ZoneConnection" ) );
|
|
aModule->SetZoneConnection( (ZoneConnection)tmp );
|
|
}
|
|
|
|
else if( TESTLINE( ".ThermalWidth" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( ".ThermalWidth" ) );
|
|
aModule->SetThermalWidth( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( ".ThermalGap" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( ".ThermalGap" ) );
|
|
aModule->SetThermalGap( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( "$EndMODULE" ) )
|
|
{
|
|
aModule->CalculateBoundingBox();
|
|
|
|
return; // preferred exit
|
|
}
|
|
}
|
|
|
|
wxString msg = wxString::Format(
|
|
wxT( "Missing '$EndMODULE' for MODULE '%s'" ),
|
|
GetChars( aModule->GetFPID().GetFootprintName() ) );
|
|
|
|
THROW_IO_ERROR( msg );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::loadPAD( MODULE* aModule )
|
|
{
|
|
auto_ptr<D_PAD> pad( new D_PAD( aModule ) );
|
|
char* line;
|
|
char* saveptr;
|
|
|
|
while( ( line = READLINE( m_reader ) ) != NULL )
|
|
{
|
|
const char* data;
|
|
|
|
if( TESTLINE( "Sh" ) ) // (Sh)ape and padname
|
|
{
|
|
// e.g. "Sh "A2" C 520 520 0 0 900"
|
|
// or "Sh "1" R 157 1378 0 0 900"
|
|
|
|
// mypadname is LATIN1/CRYLIC for BOARD_FORMAT_VERSION 1,
|
|
// but for BOARD_FORMAT_VERSION 2, it is UTF8 from disk.
|
|
// So we have to go through two code paths. Moving forward
|
|
// padnames will be in UTF8 on disk, as are all KiCad strings on disk.
|
|
char mypadname[50];
|
|
|
|
data = line + SZ( "Sh" ) + 1; // +1 skips trailing whitespace
|
|
|
|
data = data + ReadDelimitedText( mypadname, data, sizeof(mypadname) ) + 1; // +1 trailing whitespace
|
|
|
|
// sscanf( PtLine, " %s %d %d %d %d %d", BufCar, &m_Size.x, &m_Size.y, &m_DeltaSize.x, &m_DeltaSize.y, &m_Orient );
|
|
while( isSpace( *data ) )
|
|
++data;
|
|
|
|
unsigned char padchar = (unsigned char) *data++;
|
|
int padshape;
|
|
|
|
BIU size_x = biuParse( data, &data );
|
|
BIU size_y = biuParse( data, &data );
|
|
BIU delta_x = biuParse( data, &data );
|
|
BIU delta_y = biuParse( data, &data );
|
|
double orient = degParse( data );
|
|
|
|
switch( padchar )
|
|
{
|
|
case 'C': padshape = PAD_SHAPE_CIRCLE; break;
|
|
case 'R': padshape = PAD_SHAPE_RECT; break;
|
|
case 'O': padshape = PAD_SHAPE_OVAL; break;
|
|
case 'T': padshape = PAD_SHAPE_TRAPEZOID; break;
|
|
default:
|
|
m_error.Printf( _( "Unknown padshape '%c=0x%02x' on line: %d of footprint: '%s'" ),
|
|
padchar,
|
|
padchar,
|
|
m_reader->LineNumber(),
|
|
GetChars( aModule->GetFPID().GetFootprintName() )
|
|
);
|
|
THROW_IO_ERROR( m_error );
|
|
}
|
|
|
|
// go through a wxString to establish a universal character set properly
|
|
wxString padname;
|
|
|
|
if( m_loading_format_version == 1 )
|
|
{
|
|
// add 8 bit bytes, file format 1 was KiCad font type byte,
|
|
// simply promote those 8 bit bytes up into UNICODE. (subset of LATIN1)
|
|
const unsigned char* cp = (unsigned char*) mypadname;
|
|
while( *cp )
|
|
{
|
|
padname += *cp++; // unsigned, ls 8 bits only
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// version 2, which is UTF8.
|
|
padname = FROM_UTF8( mypadname );
|
|
}
|
|
// chances are both were ASCII, but why take chances?
|
|
|
|
pad->SetPadName( padname );
|
|
pad->SetShape( PAD_SHAPE_T( padshape ) );
|
|
pad->SetSize( wxSize( size_x, size_y ) );
|
|
pad->SetDelta( wxSize( delta_x, delta_y ) );
|
|
pad->SetOrientation( orient );
|
|
}
|
|
|
|
else if( TESTLINE( "Dr" ) ) // (Dr)ill
|
|
{
|
|
// e.g. "Dr 350 0 0" or "Dr 0 0 0 O 0 0"
|
|
// sscanf( PtLine, "%d %d %d %s %d %d", &m_Drill.x, &m_Offset.x, &m_Offset.y, BufCar, &dx, &dy );
|
|
|
|
BIU drill_x = biuParse( line + SZ( "Dr" ), &data );
|
|
BIU drill_y = drill_x;
|
|
BIU offs_x = biuParse( data, &data );
|
|
BIU offs_y = biuParse( data, &data );
|
|
|
|
PAD_DRILL_SHAPE_T drShape = PAD_DRILL_SHAPE_CIRCLE;
|
|
|
|
data = strtok_r( (char*) data, delims, &saveptr );
|
|
if( data ) // optional shape
|
|
{
|
|
if( data[0] == 'O' )
|
|
{
|
|
drShape = PAD_DRILL_SHAPE_OBLONG;
|
|
|
|
data = strtok_r( NULL, delims, &saveptr );
|
|
drill_x = biuParse( data );
|
|
|
|
data = strtok_r( NULL, delims, &saveptr );
|
|
drill_y = biuParse( data );
|
|
}
|
|
}
|
|
|
|
pad->SetDrillShape( drShape );
|
|
pad->SetOffset( wxPoint( offs_x, offs_y ) );
|
|
pad->SetDrillSize( wxSize( drill_x, drill_y ) );
|
|
}
|
|
|
|
else if( TESTLINE( "At" ) ) // (At)tribute
|
|
{
|
|
// e.g. "At SMD N 00888000"
|
|
// sscanf( PtLine, "%s %s %X", BufLine, BufCar, &m_layerMask );
|
|
|
|
PAD_ATTR_T attribute;
|
|
|
|
data = strtok_r( line + SZ( "At" ), delims, &saveptr );
|
|
|
|
if( !strcmp( data, "SMD" ) )
|
|
attribute = PAD_ATTRIB_SMD;
|
|
else if( !strcmp( data, "CONN" ) )
|
|
attribute = PAD_ATTRIB_CONN;
|
|
else if( !strcmp( data, "HOLE" ) )
|
|
attribute = PAD_ATTRIB_HOLE_NOT_PLATED;
|
|
else
|
|
attribute = PAD_ATTRIB_STANDARD;
|
|
|
|
strtok_r( NULL, delims, &saveptr ); // skip BufCar
|
|
data = strtok_r( NULL, delims, &saveptr );
|
|
|
|
LEG_MASK layer_mask = hexParse( data );
|
|
|
|
pad->SetLayerSet( leg_mask2new( m_cu_count, layer_mask ) );
|
|
pad->SetAttribute( attribute );
|
|
}
|
|
|
|
else if( TESTLINE( "Ne" ) ) // (Ne)tname
|
|
{
|
|
// e.g. "Ne 461 "V5.0"
|
|
|
|
char buf[1024]; // can be fairly long
|
|
int netcode = intParse( line + SZ( "Ne" ), &data );
|
|
|
|
// Store the new code mapping
|
|
pad->SetNetCode( getNetCode( netcode ) );
|
|
|
|
// read Netname
|
|
ReadDelimitedText( buf, data, sizeof(buf) );
|
|
#ifndef NDEBUG
|
|
if( m_board )
|
|
assert( m_board->FindNet( getNetCode( netcode ) )->GetNetname() ==
|
|
FROM_UTF8( StrPurge( buf ) ) );
|
|
#endif /* NDEBUG */
|
|
}
|
|
|
|
else if( TESTLINE( "Po" ) ) // (Po)sition
|
|
{
|
|
// e.g. "Po 500 -500"
|
|
wxPoint pos;
|
|
|
|
pos.x = biuParse( line + SZ( "Po" ), &data );
|
|
pos.y = biuParse( data );
|
|
|
|
pad->SetPos0( pos );
|
|
// pad->SetPosition( pos ); set at function return
|
|
}
|
|
|
|
else if( TESTLINE( "Le" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "Le" ) );
|
|
pad->SetPadToDieLength( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( ".SolderMask" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( ".SolderMask" ) );
|
|
pad->SetLocalSolderMaskMargin( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( ".SolderPasteRatio" ) )
|
|
{
|
|
double tmp = atof( line + SZ( ".SolderPasteRatio" ) );
|
|
pad->SetLocalSolderPasteMarginRatio( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( ".SolderPaste" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( ".SolderPaste" ) );
|
|
pad->SetLocalSolderPasteMargin( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( ".LocalClearance" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( ".LocalClearance" ) );
|
|
pad->SetLocalClearance( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( ".ZoneConnection" ) )
|
|
{
|
|
int tmp = intParse( line + SZ( ".ZoneConnection" ) );
|
|
pad->SetZoneConnection( (ZoneConnection)tmp );
|
|
}
|
|
|
|
else if( TESTLINE( ".ThermalWidth" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( ".ThermalWidth" ) );
|
|
pad->SetThermalWidth( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( ".ThermalGap" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( ".ThermalGap" ) );
|
|
pad->SetThermalGap( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( "$EndPAD" ) )
|
|
{
|
|
// pad's "Position" is not relative to the module's,
|
|
// whereas Pos0 is relative to the module's but is the unrotated coordinate.
|
|
|
|
wxPoint padpos = pad->GetPos0();
|
|
|
|
RotatePoint( &padpos, aModule->GetOrientation() );
|
|
|
|
pad->SetPosition( padpos + aModule->GetPosition() );
|
|
|
|
aModule->Pads().PushBack( pad.release() );
|
|
return; // preferred exit
|
|
}
|
|
}
|
|
|
|
THROW_IO_ERROR( "Missing '$EndPAD'" );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::loadMODULE_EDGE( MODULE* aModule )
|
|
{
|
|
STROKE_T shape;
|
|
char* line = m_reader->Line(); // obtain current (old) line
|
|
|
|
switch( line[1] )
|
|
{
|
|
case 'S': shape = S_SEGMENT; break;
|
|
case 'C': shape = S_CIRCLE; break;
|
|
case 'A': shape = S_ARC; break;
|
|
case 'P': shape = S_POLYGON; break;
|
|
default:
|
|
m_error.Printf( wxT( "Unknown EDGE_MODULE type:'%c=0x%02x' on line:%d of module:'%s'" ),
|
|
(unsigned char) line[1],
|
|
(unsigned char) line[1],
|
|
m_reader->LineNumber(),
|
|
GetChars( aModule->GetFPID().GetFootprintName() )
|
|
);
|
|
THROW_IO_ERROR( m_error );
|
|
}
|
|
|
|
auto_ptr<EDGE_MODULE> dwg( new EDGE_MODULE( aModule, shape ) ); // a drawing
|
|
|
|
const char* data;
|
|
|
|
// common to all cases, and we have to check their values uniformly at end
|
|
BIU width = 1;
|
|
LAYER_NUM layer = FIRST_NON_COPPER_LAYER;
|
|
|
|
switch( shape )
|
|
{
|
|
case S_ARC:
|
|
{
|
|
// 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 );
|
|
BIU start0_x = biuParse( line + SZ( "DA" ), &data );
|
|
BIU start0_y = biuParse( data, &data );
|
|
BIU end0_x = biuParse( data, &data );
|
|
BIU end0_y = biuParse( data, &data );
|
|
double angle = degParse( data, &data );
|
|
|
|
width = biuParse( data, &data );
|
|
layer = layerParse( data );
|
|
|
|
dwg->SetAngle( angle );
|
|
dwg->m_Start0 = wxPoint( start0_x, start0_y );
|
|
dwg->m_End0 = wxPoint( end0_x, end0_y );
|
|
}
|
|
break;
|
|
|
|
case S_SEGMENT:
|
|
case S_CIRCLE:
|
|
{
|
|
// e.g. "DS -7874 -10630 7874 -10630 50 20\r\n"
|
|
// 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 );
|
|
|
|
BIU start0_x = biuParse( line + SZ( "DS" ), &data );
|
|
BIU start0_y = biuParse( data, &data );
|
|
BIU end0_x = biuParse( data, &data );
|
|
BIU end0_y = biuParse( data, &data );
|
|
|
|
width = biuParse( data, &data );
|
|
layer = layerParse( data );
|
|
|
|
dwg->m_Start0 = wxPoint( start0_x, start0_y );
|
|
dwg->m_End0 = wxPoint( end0_x, end0_y );
|
|
}
|
|
break;
|
|
|
|
case S_POLYGON:
|
|
{
|
|
// e.g. "DP %d %d %d %d %d %d %d\n"
|
|
// 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 );
|
|
|
|
BIU start0_x = biuParse( line + SZ( "DP" ), &data );
|
|
BIU start0_y = biuParse( data, &data );
|
|
BIU end0_x = biuParse( data, &data );
|
|
BIU end0_y = biuParse( data, &data );
|
|
int ptCount = intParse( data, &data );
|
|
|
|
width = biuParse( data, &data );
|
|
layer = layerParse( data );
|
|
|
|
dwg->m_Start0 = wxPoint( start0_x, start0_y );
|
|
dwg->m_End0 = wxPoint( end0_x, end0_y );
|
|
|
|
std::vector<wxPoint> pts;
|
|
pts.reserve( ptCount );
|
|
|
|
for( int ii = 0; ii<ptCount; ++ii )
|
|
{
|
|
if( ( line = READLINE( m_reader ) ) == NULL )
|
|
{
|
|
THROW_IO_ERROR( "S_POLGON point count mismatch." );
|
|
}
|
|
|
|
// e.g. "Dl 23 44\n"
|
|
|
|
if( !TESTLINE( "Dl" ) )
|
|
{
|
|
THROW_IO_ERROR( "Missing Dl point def" );
|
|
}
|
|
|
|
BIU x = biuParse( line + SZ( "Dl" ), &data );
|
|
BIU y = biuParse( data );
|
|
|
|
pts.push_back( wxPoint( x, y ) );
|
|
}
|
|
|
|
dwg->SetPolyPoints( pts );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
// first switch code above prevents us from getting here.
|
|
break;
|
|
}
|
|
|
|
// Check for a reasonable width:
|
|
|
|
/* @todo no MAX_WIDTH in out of reach header.
|
|
if( width <= 1 )
|
|
width = 1;
|
|
else if( width > MAX_WIDTH )
|
|
width = MAX_WIDTH;
|
|
*/
|
|
|
|
// Check for a reasonable layer:
|
|
// m_Layer must be >= FIRST_NON_COPPER_LAYER, but because microwave footprints
|
|
// can use the copper layers m_Layer < FIRST_NON_COPPER_LAYER is allowed.
|
|
// @todo: changes use of EDGE_MODULE these footprints and allows only
|
|
// m_Layer >= FIRST_NON_COPPER_LAYER
|
|
if( layer < FIRST_LAYER || layer > LAST_NON_COPPER_LAYER )
|
|
layer = SILKSCREEN_N_FRONT;
|
|
|
|
dwg->SetWidth( width );
|
|
dwg->SetLayer( leg_layer2new( m_cu_count, layer ) );
|
|
|
|
EDGE_MODULE* em = dwg.release();
|
|
|
|
aModule->GraphicalItems().PushBack( em );
|
|
|
|
// this had been done at the MODULE level before, presumably because the
|
|
// EDGE_MODULE needs to be already added to a module before this function will work.
|
|
em->SetDrawCoord();
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::loadMODULE_TEXT( TEXTE_MODULE* aText )
|
|
{
|
|
const char* data;
|
|
const char* txt_end;
|
|
const char* line = m_reader->Line(); // current (old) line
|
|
char* saveptr;
|
|
|
|
// sscanf( line + 1, "%d %d %d %d %d %d %d %s %s %d %s",
|
|
// &type, &m_Pos0.x, &m_Pos0.y, &m_Size.y, &m_Size.x,
|
|
// &m_Orient, &m_Thickness, BufCar1, BufCar2, &layer, BufCar3 ) >= 10 )
|
|
|
|
// e.g. "T1 6940 -16220 350 300 900 60 M I 20 N "CFCARD"\r\n"
|
|
// or T1 0 500 600 400 900 80 M V 20 N"74LS245"
|
|
// ouch, the last example has no space between N and "74LS245" !
|
|
// that is an older version.
|
|
|
|
int type = intParse( line+1, &data );
|
|
BIU pos0_x = biuParse( data, &data );
|
|
BIU pos0_y = biuParse( data, &data );
|
|
BIU size0_y = biuParse( data, &data );
|
|
BIU size0_x = biuParse( data, &data );
|
|
double orient = degParse( data, &data );
|
|
BIU thickn = biuParse( data, &data );
|
|
|
|
// read the quoted text before the first call to strtok() which introduces
|
|
// NULs into the string and chops it into mutliple C strings, something
|
|
// ReadDelimitedText() cannot traverse.
|
|
|
|
// convert the "quoted, escaped, UTF8, text" to a wxString, find it by skipping
|
|
// as far forward as needed until the first double quote.
|
|
txt_end = data + ReadDelimitedText( &m_field, data );
|
|
|
|
#if 1 && defined(DEBUG)
|
|
if( m_field == wxT( "ARM_C8" ) )
|
|
{
|
|
int breakhere = 1;
|
|
(void) breakhere;
|
|
}
|
|
#endif
|
|
|
|
aText->SetText( m_field );
|
|
|
|
// after switching to strtok, there's no easy coming back because of the
|
|
// embedded nul(s?) placed to the right of the current field.
|
|
// (that's the reason why strtok was deprecated...)
|
|
char* mirror = strtok_r( (char*) data, delims, &saveptr );
|
|
char* hide = strtok_r( NULL, delims, &saveptr );
|
|
char* tmp = strtok_r( NULL, delims, &saveptr );
|
|
|
|
LAYER_NUM layer_num = tmp ? layerParse( tmp ) : SILKSCREEN_N_FRONT;
|
|
|
|
char* italic = strtok_r( NULL, delims, &saveptr );
|
|
|
|
char* hjust = strtok_r( (char*) txt_end, delims, &saveptr );
|
|
char* vjust = strtok_r( NULL, delims, &saveptr );
|
|
|
|
if( type != TEXTE_MODULE::TEXT_is_REFERENCE
|
|
&& type != TEXTE_MODULE::TEXT_is_VALUE )
|
|
type = TEXTE_MODULE::TEXT_is_DIVERS;
|
|
|
|
aText->SetType( static_cast<TEXTE_MODULE::TEXT_TYPE>( type ) );
|
|
|
|
aText->SetPos0( wxPoint( pos0_x, pos0_y ) );
|
|
aText->SetSize( wxSize( size0_x, size0_y ) );
|
|
|
|
orient -= ( static_cast<MODULE*>( aText->GetParent() ) )->GetOrientation();
|
|
|
|
aText->SetOrientation( orient );
|
|
|
|
// @todo put in accessors?
|
|
// Set a reasonable width:
|
|
if( thickn < 1 )
|
|
thickn = 1;
|
|
|
|
/* this is better left to the dialogs UIs
|
|
aText->SetThickness( Clamp_Text_PenSize( thickn, aText->GetSize() ) );
|
|
*/
|
|
|
|
aText->SetThickness( thickn );
|
|
|
|
aText->SetMirrored( mirror && *mirror == 'M' );
|
|
|
|
aText->SetVisible( !(hide && *hide == 'I') );
|
|
|
|
aText->SetItalic( italic && *italic == 'I' );
|
|
|
|
if( hjust )
|
|
aText->SetHorizJustify( horizJustify( hjust ) );
|
|
|
|
if( vjust )
|
|
aText->SetVertJustify( vertJustify( vjust ) );
|
|
|
|
if( layer_num < FIRST_LAYER )
|
|
layer_num = FIRST_LAYER;
|
|
else if( layer_num > LAST_NON_COPPER_LAYER )
|
|
layer_num = LAST_NON_COPPER_LAYER;
|
|
else if( layer_num == LAYER_N_BACK )
|
|
layer_num = SILKSCREEN_N_BACK;
|
|
else if( layer_num == LAYER_N_FRONT )
|
|
layer_num = SILKSCREEN_N_FRONT;
|
|
|
|
aText->SetLayer( leg_layer2new( m_cu_count, layer_num ) );
|
|
|
|
// Calculate the actual position.
|
|
aText->SetDrawCoord();
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::load3D( MODULE* aModule )
|
|
{
|
|
S3D_MASTER* t3D = aModule->Models();
|
|
|
|
if( !t3D->GetShape3DName().IsEmpty() )
|
|
{
|
|
S3D_MASTER* n3D = new S3D_MASTER( aModule );
|
|
|
|
aModule->Models().PushBack( n3D );
|
|
|
|
t3D = n3D;
|
|
}
|
|
|
|
char* line;
|
|
while( ( line = READLINE( m_reader ) ) != NULL )
|
|
{
|
|
if( TESTLINE( "Na" ) ) // Shape File Name
|
|
{
|
|
char buf[512];
|
|
ReadDelimitedText( buf, line + SZ( "Na" ), sizeof(buf) );
|
|
t3D->SetShape3DName( FROM_UTF8( buf ) );
|
|
}
|
|
|
|
else if( TESTLINE( "Sc" ) ) // Scale
|
|
{
|
|
sscanf( line + SZ( "Sc" ), "%lf %lf %lf\n",
|
|
&t3D->m_MatScale.x,
|
|
&t3D->m_MatScale.y,
|
|
&t3D->m_MatScale.z );
|
|
}
|
|
|
|
else if( TESTLINE( "Of" ) ) // Offset
|
|
{
|
|
sscanf( line + SZ( "Of" ), "%lf %lf %lf\n",
|
|
&t3D->m_MatPosition.x,
|
|
&t3D->m_MatPosition.y,
|
|
&t3D->m_MatPosition.z );
|
|
}
|
|
|
|
else if( TESTLINE( "Ro" ) ) // Rotation
|
|
{
|
|
sscanf( line + SZ( "Ro" ), "%lf %lf %lf\n",
|
|
&t3D->m_MatRotation.x,
|
|
&t3D->m_MatRotation.y,
|
|
&t3D->m_MatRotation.z );
|
|
}
|
|
|
|
else if( TESTLINE( "$EndSHAPE3D" ) )
|
|
return; // preferred exit
|
|
}
|
|
|
|
THROW_IO_ERROR( "Missing '$EndSHAPE3D'" );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::loadPCB_LINE()
|
|
{
|
|
/* example:
|
|
$DRAWSEGMENT
|
|
Po 0 57500 -1000 57500 0 150
|
|
De 24 0 900 0 0
|
|
$EndDRAWSEGMENT
|
|
*/
|
|
|
|
auto_ptr<DRAWSEGMENT> dseg( new DRAWSEGMENT( m_board ) );
|
|
|
|
char* line;
|
|
char* saveptr;
|
|
|
|
while( ( line = READLINE( m_reader ) ) != NULL )
|
|
{
|
|
const char* data;
|
|
|
|
if( TESTLINE( "Po" ) )
|
|
{
|
|
// 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 );
|
|
int shape = intParse( line + SZ( "Po" ), &data );
|
|
BIU start_x = biuParse( data, &data );
|
|
BIU start_y = biuParse( data, &data );
|
|
BIU end_x = biuParse( data, &data );
|
|
BIU end_y = biuParse( data, &data );
|
|
BIU width = biuParse( data );
|
|
|
|
if( width < 0 )
|
|
width = 0;
|
|
|
|
dseg->SetShape( STROKE_T( shape ) );
|
|
dseg->SetWidth( width );
|
|
dseg->SetStart( wxPoint( start_x, start_y ) );
|
|
dseg->SetEnd( wxPoint( end_x, end_y ) );
|
|
}
|
|
|
|
else if( TESTLINE( "De" ) )
|
|
{
|
|
BIU x = 0;
|
|
BIU y;
|
|
|
|
data = strtok_r( line + SZ( "De" ), delims, &saveptr );
|
|
for( int i = 0; data; ++i, data = strtok_r( NULL, delims, &saveptr ) )
|
|
{
|
|
switch( i )
|
|
{
|
|
case 0:
|
|
LAYER_NUM layer;
|
|
layer = layerParse( data );
|
|
|
|
if( layer < FIRST_NON_COPPER_LAYER )
|
|
layer = FIRST_NON_COPPER_LAYER;
|
|
|
|
else if( layer > LAST_NON_COPPER_LAYER )
|
|
layer = LAST_NON_COPPER_LAYER;
|
|
|
|
dseg->SetLayer( leg_layer2new( m_cu_count, layer ) );
|
|
break;
|
|
case 1:
|
|
int mtype;
|
|
mtype = intParse( data );
|
|
dseg->SetType( mtype ); // m_Type
|
|
break;
|
|
case 2:
|
|
double angle;
|
|
angle = degParse( data );
|
|
dseg->SetAngle( angle ); // m_Angle
|
|
break;
|
|
case 3:
|
|
time_t timestamp;
|
|
timestamp = hexParse( data );
|
|
dseg->SetTimeStamp( timestamp );
|
|
break;
|
|
case 4:
|
|
STATUS_FLAGS state;
|
|
state = static_cast<STATUS_FLAGS>( hexParse( data ) );
|
|
dseg->SetState( state, true );
|
|
break;
|
|
|
|
// Bezier Control Points
|
|
case 5:
|
|
x = biuParse( data );
|
|
break;
|
|
case 6:
|
|
y = biuParse( data );
|
|
dseg->SetBezControl1( wxPoint( x, y ) );
|
|
break;
|
|
|
|
case 7:
|
|
x = biuParse( data );
|
|
break;
|
|
case 8:
|
|
y = biuParse( data );
|
|
dseg->SetBezControl2( wxPoint( x, y ) );
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
else if( TESTLINE( "$EndDRAWSEGMENT" ) )
|
|
{
|
|
m_board->Add( dseg.release(), ADD_APPEND );
|
|
return; // preferred exit
|
|
}
|
|
}
|
|
|
|
THROW_IO_ERROR( "Missing '$EndDRAWSEGMENT'" );
|
|
}
|
|
|
|
void LEGACY_PLUGIN::loadNETINFO_ITEM()
|
|
{
|
|
/* a net description is something like
|
|
* $EQUIPOT
|
|
* Na 5 "/BIT1"
|
|
* St ~
|
|
* $EndEQUIPOT
|
|
*/
|
|
|
|
char buf[1024];
|
|
|
|
NETINFO_ITEM* net = NULL;
|
|
char* line;
|
|
int netCode = 0;
|
|
|
|
while( ( line = READLINE( m_reader ) ) != NULL )
|
|
{
|
|
const char* data;
|
|
|
|
if( TESTLINE( "Na" ) )
|
|
{
|
|
// e.g. "Na 58 "/cpu.sch/PAD7"\r\n"
|
|
|
|
netCode = intParse( line + SZ( "Na" ), &data );
|
|
|
|
ReadDelimitedText( buf, data, sizeof(buf) );
|
|
|
|
if( net == NULL )
|
|
net = new NETINFO_ITEM( m_board, FROM_UTF8( buf ), netCode );
|
|
else
|
|
{
|
|
THROW_IO_ERROR( "Two net definitions in '$EQUIPOT' block" );
|
|
}
|
|
}
|
|
|
|
else if( TESTLINE( "$EndEQUIPOT" ) )
|
|
{
|
|
// net 0 should be already in list, so store this net
|
|
// if it is not the net 0, or if the net 0 does not exists.
|
|
if( net && ( net->GetNet() > 0 || m_board->FindNet( 0 ) == NULL ) )
|
|
{
|
|
m_board->AppendNet( net );
|
|
|
|
// Be sure we have room to store the net in m_netCodes
|
|
if( (int)m_netCodes.size() <= netCode )
|
|
m_netCodes.resize( netCode+1 );
|
|
|
|
m_netCodes[netCode] = net->GetNet();
|
|
net = NULL;
|
|
}
|
|
else
|
|
{
|
|
delete net;
|
|
net = NULL; // Avoid double deletion.
|
|
}
|
|
|
|
return; // preferred exit
|
|
}
|
|
}
|
|
|
|
// If we are here, there is an error.
|
|
delete net;
|
|
THROW_IO_ERROR( "Missing '$EndEQUIPOT'" );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::loadPCB_TEXT()
|
|
{
|
|
/* examples:
|
|
For a single line text:
|
|
----------------------
|
|
$TEXTPCB
|
|
Te "Text example"
|
|
Po 66750 53450 600 800 150 0
|
|
De 24 1 0 Italic
|
|
$EndTEXTPCB
|
|
|
|
For a multi line text:
|
|
---------------------
|
|
$TEXTPCB
|
|
Te "Text example"
|
|
Nl "Line 2"
|
|
Po 66750 53450 600 800 150 0
|
|
De 24 1 0 Italic
|
|
$EndTEXTPCB
|
|
Nl "line nn" is a line added to the current text
|
|
*/
|
|
|
|
char text[1024];
|
|
|
|
// maybe someday a constructor that takes all this data in one call?
|
|
TEXTE_PCB* pcbtxt = new TEXTE_PCB( m_board );
|
|
m_board->Add( pcbtxt, ADD_APPEND );
|
|
|
|
char* line;
|
|
char* saveptr;
|
|
|
|
while( ( line = READLINE( m_reader ) ) != NULL )
|
|
{
|
|
const char* data;
|
|
|
|
if( TESTLINE( "Te" ) ) // Text line (or first line for multi line texts)
|
|
{
|
|
ReadDelimitedText( text, line + SZ( "Te" ), sizeof(text) );
|
|
pcbtxt->SetText( FROM_UTF8( text ) );
|
|
}
|
|
|
|
else if( TESTLINE( "nl" ) ) // next line of the current text
|
|
{
|
|
ReadDelimitedText( text, line + SZ( "nl" ), sizeof(text) );
|
|
pcbtxt->SetText( pcbtxt->GetText() + wxChar( '\n' ) + FROM_UTF8( text ) );
|
|
}
|
|
|
|
else if( TESTLINE( "Po" ) )
|
|
{
|
|
// 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 );
|
|
wxSize size;
|
|
|
|
BIU pos_x = biuParse( line + SZ( "Po" ), &data );
|
|
BIU pos_y = biuParse( data, &data );
|
|
size.x = biuParse( data, &data );
|
|
size.y = biuParse( data, &data );
|
|
BIU thickn = biuParse( data, &data );
|
|
double angle = degParse( data );
|
|
|
|
// Ensure the text has minimal size to see this text on screen:
|
|
|
|
/* @todo wait until we are firmly in the nanometer world
|
|
if( sz.x < 5 )
|
|
sz.x = 5;
|
|
|
|
if( sz.y < 5 )
|
|
sz.y = 5;
|
|
*/
|
|
|
|
pcbtxt->SetSize( size );
|
|
|
|
/* @todo move into an accessor
|
|
// Set a reasonable width:
|
|
if( thickn < 1 )
|
|
thickn = 1;
|
|
|
|
thickn = Clamp_Text_PenSize( thickn, size );
|
|
*/
|
|
|
|
pcbtxt->SetThickness( thickn );
|
|
pcbtxt->SetOrientation( angle );
|
|
|
|
pcbtxt->SetTextPosition( wxPoint( pos_x, pos_y ) );
|
|
}
|
|
|
|
else if( TESTLINE( "De" ) )
|
|
{
|
|
// e.g. "De 21 1 0 Normal C\r\n"
|
|
// sscanf( line + 2, " %d %d %lX %s %c\n", &m_Layer, &normal_display, &m_TimeStamp, style, &hJustify );
|
|
|
|
LAYER_NUM layer_num = layerParse( line + SZ( "De" ), &data );
|
|
int notMirrored = intParse( data, &data );
|
|
time_t timestamp = hexParse( data, &data );
|
|
char* style = strtok_r( (char*) data, delims, &saveptr );
|
|
char* hJustify = strtok_r( NULL, delims, &saveptr );
|
|
char* vJustify = strtok_r( NULL, delims, &saveptr );
|
|
|
|
pcbtxt->SetMirrored( !notMirrored );
|
|
pcbtxt->SetTimeStamp( timestamp );
|
|
pcbtxt->SetItalic( !strcmp( style, "Italic" ) );
|
|
|
|
if( hJustify )
|
|
pcbtxt->SetHorizJustify( horizJustify( hJustify ) );
|
|
else
|
|
{
|
|
// boom, somebody changed a constructor, I was relying on this:
|
|
wxASSERT( pcbtxt->GetHorizJustify() == GR_TEXT_HJUSTIFY_CENTER );
|
|
}
|
|
|
|
if( vJustify )
|
|
pcbtxt->SetVertJustify( vertJustify( vJustify ) );
|
|
|
|
if( layer_num < FIRST_COPPER_LAYER )
|
|
layer_num = FIRST_COPPER_LAYER;
|
|
else if( layer_num > LAST_NON_COPPER_LAYER )
|
|
layer_num = LAST_NON_COPPER_LAYER;
|
|
|
|
if( layer_num >= FIRST_NON_COPPER_LAYER ||
|
|
is_leg_copperlayer_valid( m_cu_count, layer_num ) )
|
|
pcbtxt->SetLayer( leg_layer2new( m_cu_count, layer_num ) );
|
|
else // not perfect, but putting this text on front layer is a workaround
|
|
pcbtxt->SetLayer( F_Cu );
|
|
}
|
|
|
|
else if( TESTLINE( "$EndTEXTPCB" ) )
|
|
{
|
|
return; // preferred exit
|
|
}
|
|
}
|
|
|
|
THROW_IO_ERROR( "Missing '$EndTEXTPCB'" );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::loadTrackList( int aStructType )
|
|
{
|
|
char* line;
|
|
char* saveptr;
|
|
|
|
while( ( line = READLINE( m_reader ) ) != NULL )
|
|
{
|
|
// read two lines per loop iteration, each loop is one TRACK or VIA
|
|
// example first line:
|
|
// e.g. "Po 0 23994 28800 24400 28800 150 -1" for a track
|
|
// e.g. "Po 3 21086 17586 21086 17586 180 -1" for a via (uses sames start and end)
|
|
|
|
const char* data;
|
|
|
|
if( line[0] == '$' ) // $EndTRACK
|
|
return; // preferred exit
|
|
|
|
// int arg_count = sscanf( line + 2, " %d %d %d %d %d %d %d", &shape, &tempStartX, &tempStartY, &tempEndX, &tempEndY, &width, &drill );
|
|
|
|
assert( TESTLINE( "Po" ) );
|
|
|
|
VIATYPE_T viatype = static_cast<VIATYPE_T>( intParse( line + SZ( "Po" ), &data ));
|
|
BIU start_x = biuParse( data, &data );
|
|
BIU start_y = biuParse( data, &data );
|
|
BIU end_x = biuParse( data, &data );
|
|
BIU end_y = biuParse( data, &data );
|
|
BIU width = biuParse( data, &data );
|
|
|
|
// optional 7th drill parameter (must be optional in an old format?)
|
|
data = strtok_r( (char*) data, delims, &saveptr );
|
|
|
|
BIU drill = data ? biuParse( data ) : -1; // SetDefault() if < 0
|
|
|
|
// Read the 2nd line to determine the exact type, one of:
|
|
// PCB_TRACE_T, PCB_VIA_T, or PCB_ZONE_T. The type field in 2nd line
|
|
// differentiates between PCB_TRACE_T and PCB_VIA_T. With virtual
|
|
// functions in use, it is critical to instantiate the PCB_VIA_T
|
|
// exactly.
|
|
READLINE( m_reader );
|
|
|
|
line = m_reader->Line();
|
|
|
|
// example second line:
|
|
// "De 0 0 463 0 800000\r\n"
|
|
|
|
#if 1
|
|
assert( TESTLINE( "De" ) );
|
|
#else
|
|
if( !TESTLINE( "De" ) )
|
|
{
|
|
// mandatory 2nd line is missing
|
|
THROW_IO_ERROR( "Missing 2nd line of a TRACK def" );
|
|
}
|
|
#endif
|
|
|
|
int makeType;
|
|
time_t timeStamp;
|
|
LAYER_NUM layer_num;
|
|
int type, net_code, flags_int;
|
|
|
|
// parse the 2nd line to determine the type of object
|
|
// e.g. "De 15 1 7 0 0" for a via
|
|
sscanf( line + SZ( "De" ), " %d %d %d %lX %X", &layer_num, &type, &net_code,
|
|
&timeStamp, &flags_int );
|
|
|
|
STATUS_FLAGS flags;
|
|
|
|
flags = static_cast<STATUS_FLAGS>( flags_int );
|
|
|
|
if( aStructType==PCB_TRACE_T && type==1 )
|
|
makeType = PCB_VIA_T;
|
|
else
|
|
makeType = aStructType;
|
|
|
|
TRACK* newTrack;
|
|
|
|
switch( makeType )
|
|
{
|
|
default:
|
|
case PCB_TRACE_T:
|
|
newTrack = new TRACK( m_board );
|
|
break;
|
|
|
|
case PCB_VIA_T:
|
|
newTrack = new VIA( m_board );
|
|
break;
|
|
|
|
case PCB_ZONE_T: // this is now deprecated, but exist in old boards
|
|
newTrack = new SEGZONE( m_board );
|
|
break;
|
|
}
|
|
|
|
newTrack->SetTimeStamp( timeStamp );
|
|
|
|
newTrack->SetPosition( wxPoint( start_x, start_y ) );
|
|
newTrack->SetEnd( wxPoint( end_x, end_y ) );
|
|
|
|
newTrack->SetWidth( width );
|
|
|
|
if( makeType == PCB_VIA_T ) // Ensure layers are OK when possible:
|
|
{
|
|
VIA *via = static_cast<VIA*>( newTrack );
|
|
via->SetViaType( viatype );
|
|
|
|
if( drill < 0 )
|
|
via->SetDrillDefault();
|
|
else
|
|
via->SetDrill( drill );
|
|
|
|
if( via->GetViaType() == VIA_THROUGH )
|
|
via->SetLayerPair( F_Cu, B_Cu );
|
|
else
|
|
{
|
|
LAYER_ID back = leg_layer2new( m_cu_count, (layer_num >> 4) & 0xf );
|
|
LAYER_ID front = leg_layer2new( m_cu_count, layer_num & 0xf );
|
|
|
|
if( is_leg_copperlayer_valid( m_cu_count, back ) &&
|
|
is_leg_copperlayer_valid( m_cu_count, front ) )
|
|
via->SetLayerPair( front, back );
|
|
else
|
|
{
|
|
delete via;
|
|
newTrack = NULL;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// A few legacy boards can have tracks on non existent layers, because
|
|
// reducing the number of layers does not remove tracks on removed layers
|
|
// If happens, skip them
|
|
if( is_leg_copperlayer_valid( m_cu_count, layer_num ) )
|
|
newTrack->SetLayer( leg_layer2new( m_cu_count, layer_num ) );
|
|
else
|
|
{
|
|
delete newTrack;
|
|
newTrack = NULL;
|
|
}
|
|
}
|
|
|
|
if( newTrack )
|
|
{
|
|
newTrack->SetNetCode( getNetCode( net_code ) );
|
|
newTrack->SetState( flags, true );
|
|
|
|
m_board->Add( newTrack );
|
|
}
|
|
}
|
|
|
|
THROW_IO_ERROR( "Missing '$EndTRACK'" );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::loadNETCLASS()
|
|
{
|
|
char buf[1024];
|
|
wxString netname;
|
|
char* line;
|
|
|
|
// create an empty NETCLASS without a name, but do not add it to the BOARD
|
|
// yet since that would bypass duplicate netclass name checking within the BOARD.
|
|
// store it temporarily in an auto_ptr until successfully inserted into the BOARD
|
|
// just before returning.
|
|
NETCLASSPTR nc = boost::make_shared<NETCLASS>( wxEmptyString );
|
|
|
|
while( ( line = READLINE( m_reader ) ) != NULL )
|
|
{
|
|
if( TESTLINE( "AddNet" ) ) // most frequent type of line
|
|
{
|
|
// e.g. "AddNet "V3.3D"\n"
|
|
ReadDelimitedText( buf, line + SZ( "AddNet" ), sizeof(buf) );
|
|
netname = FROM_UTF8( buf );
|
|
nc->Add( netname );
|
|
}
|
|
|
|
else if( TESTLINE( "Clearance" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "Clearance" ) );
|
|
nc->SetClearance( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( "TrackWidth" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "TrackWidth" ) );
|
|
nc->SetTrackWidth( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( "ViaDia" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "ViaDia" ) );
|
|
nc->SetViaDiameter( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( "ViaDrill" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "ViaDrill" ) );
|
|
nc->SetViaDrill( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( "uViaDia" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "uViaDia" ) );
|
|
nc->SetuViaDiameter( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( "uViaDrill" ) )
|
|
{
|
|
BIU tmp = biuParse( line + SZ( "uViaDrill" ) );
|
|
nc->SetuViaDrill( tmp );
|
|
}
|
|
|
|
else if( TESTLINE( "Name" ) )
|
|
{
|
|
ReadDelimitedText( buf, line + SZ( "Name" ), sizeof(buf) );
|
|
nc->SetName( FROM_UTF8( buf ) );
|
|
}
|
|
|
|
else if( TESTLINE( "Desc" ) )
|
|
{
|
|
ReadDelimitedText( buf, line + SZ( "Desc" ), sizeof(buf) );
|
|
nc->SetDescription( FROM_UTF8( buf ) );
|
|
}
|
|
|
|
else if( TESTLINE( "$EndNCLASS" ) )
|
|
{
|
|
if( !m_board->GetDesignSettings().m_NetClasses.Add( nc ) )
|
|
{
|
|
// Must have been a name conflict, this is a bad board file.
|
|
// User may have done a hand edit to the file.
|
|
|
|
// auto_ptr will delete nc on this code path
|
|
|
|
m_error.Printf( _( "duplicate NETCLASS name '%s'" ), nc->GetName().GetData() );
|
|
THROW_IO_ERROR( m_error );
|
|
}
|
|
|
|
return; // preferred exit
|
|
}
|
|
}
|
|
|
|
THROW_IO_ERROR( "Missing '$EndNCLASS'" );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::loadZONE_CONTAINER()
|
|
{
|
|
auto_ptr<ZONE_CONTAINER> zc( new ZONE_CONTAINER( m_board ) );
|
|
|
|
CPolyLine::HATCH_STYLE outline_hatch = CPolyLine::NO_HATCH;
|
|
bool sawCorner = false;
|
|
char buf[1024];
|
|
char* line;
|
|
char* saveptr;
|
|
|
|
while( ( line = READLINE( m_reader ) ) != NULL )
|
|
{
|
|
const char* data;
|
|
|
|
if( TESTLINE( "ZCorner" ) ) // new corner found
|
|
{
|
|
// e.g. "ZCorner 25650 49500 0"
|
|
BIU x = biuParse( line + SZ( "ZCorner" ), &data );
|
|
BIU y = biuParse( data, &data );
|
|
int flag = intParse( data );
|
|
|
|
if( !sawCorner )
|
|
zc->Outline()->Start( zc->GetLayer(), x, y, outline_hatch );
|
|
else
|
|
zc->AppendCorner( wxPoint( x, y ) );
|
|
|
|
sawCorner = true;
|
|
|
|
if( flag )
|
|
zc->Outline()->CloseLastContour();
|
|
}
|
|
|
|
else if( TESTLINE( "ZInfo" ) ) // general info found
|
|
{
|
|
// e.g. 'ZInfo 479194B1 310 "COMMON"'
|
|
time_t timestamp = hexParse( line + SZ( "ZInfo" ), &data );
|
|
int netcode = intParse( data, &data );
|
|
|
|
if( ReadDelimitedText( buf, data, sizeof(buf) ) > (int) sizeof(buf) )
|
|
{
|
|
THROW_IO_ERROR( "ZInfo netname too long" );
|
|
}
|
|
|
|
zc->SetTimeStamp( timestamp );
|
|
// Init the net code only, not the netname, to be sure
|
|
// the zone net name is the name read in file.
|
|
// (When mismatch, the user will be prompted in DRC, to fix the actual name)
|
|
zc->BOARD_CONNECTED_ITEM::SetNetCode( getNetCode( netcode ) );
|
|
}
|
|
|
|
else if( TESTLINE( "ZLayer" ) ) // layer found
|
|
{
|
|
LAYER_NUM layer_num = layerParse( line + SZ( "ZLayer" ) );
|
|
zc->SetLayer( leg_layer2new( m_cu_count, layer_num ) );
|
|
}
|
|
|
|
else if( TESTLINE( "ZAux" ) ) // aux info found
|
|
{
|
|
// e.g. "ZAux 7 E"
|
|
int ignore = intParse( line + SZ( "ZAux" ), &data );
|
|
char* hopt = strtok_r( (char*) data, delims, &saveptr );
|
|
|
|
if( !hopt )
|
|
{
|
|
m_error.Printf( wxT( "Bad ZAux for CZONE_CONTAINER '%s'" ), zc->GetNetname().GetData() );
|
|
THROW_IO_ERROR( m_error );
|
|
}
|
|
|
|
switch( *hopt ) // upper case required
|
|
{
|
|
case 'N': outline_hatch = CPolyLine::NO_HATCH; break;
|
|
case 'E': outline_hatch = CPolyLine::DIAGONAL_EDGE; break;
|
|
case 'F': outline_hatch = CPolyLine::DIAGONAL_FULL; break;
|
|
|
|
default:
|
|
m_error.Printf( wxT( "Bad ZAux for CZONE_CONTAINER '%s'" ), zc->GetNetname().GetData() );
|
|
THROW_IO_ERROR( m_error );
|
|
}
|
|
|
|
(void) ignore;
|
|
|
|
// Set hatch mode later, after reading corner outline data
|
|
}
|
|
|
|
else if( TESTLINE( "ZSmoothing" ) )
|
|
{
|
|
// e.g. "ZSmoothing 0 0"
|
|
int smoothing = intParse( line + SZ( "ZSmoothing" ), &data );
|
|
BIU cornerRadius = biuParse( data );
|
|
|
|
if( smoothing >= ZONE_SETTINGS::SMOOTHING_LAST || smoothing < 0 )
|
|
{
|
|
m_error.Printf( wxT( "Bad ZSmoothing for CZONE_CONTAINER '%s'" ), zc->GetNetname().GetData() );
|
|
THROW_IO_ERROR( m_error );
|
|
}
|
|
|
|
zc->SetCornerSmoothingType( smoothing );
|
|
zc->SetCornerRadius( cornerRadius );
|
|
}
|
|
|
|
else if( TESTLINE( "ZKeepout" ) )
|
|
{
|
|
zc->SetIsKeepout( true );
|
|
// e.g. "ZKeepout tracks N vias N pads Y"
|
|
data = strtok_r( line + SZ( "ZKeepout" ), delims, &saveptr );
|
|
|
|
while( data )
|
|
{
|
|
if( !strcmp( data, "tracks" ) )
|
|
{
|
|
data = strtok_r( NULL, delims, &saveptr );
|
|
zc->SetDoNotAllowTracks( data && *data == 'N' );
|
|
}
|
|
else if( !strcmp( data, "vias" ) )
|
|
{
|
|
data = strtok_r( NULL, delims, &saveptr );
|
|
zc->SetDoNotAllowVias( data && *data == 'N' );
|
|
}
|
|
else if( !strcmp( data, "copperpour" ) )
|
|
{
|
|
data = strtok_r( NULL, delims, &saveptr );
|
|
zc->SetDoNotAllowCopperPour( data && *data == 'N' );
|
|
}
|
|
|
|
data = strtok_r( NULL, delims, &saveptr );
|
|
}
|
|
}
|
|
|
|
else if( TESTLINE( "ZOptions" ) )
|
|
{
|
|
// e.g. "ZOptions 0 32 F 200 200"
|
|
int fillmode = intParse( line + SZ( "ZOptions" ), &data );
|
|
int arcsegcount = intParse( data, &data );
|
|
char fillstate = data[1]; // here e.g. " F"
|
|
BIU thermalReliefGap = biuParse( data += 2 , &data ); // +=2 for " F"
|
|
BIU thermalReliefCopperBridge = biuParse( data );
|
|
|
|
zc->SetFillMode( fillmode ? 1 : 0 );
|
|
|
|
// @todo ARC_APPROX_SEGMENTS_COUNT_HIGHT_DEF: don't really want pcbnew.h
|
|
// in here, after all, its a PLUGIN and global data is evil.
|
|
// put in accessor
|
|
if( arcsegcount >= 32 )
|
|
arcsegcount = 32;
|
|
|
|
zc->SetArcSegmentCount( arcsegcount );
|
|
zc->SetIsFilled( fillstate == 'S' );
|
|
zc->SetThermalReliefGap( thermalReliefGap );
|
|
zc->SetThermalReliefCopperBridge( thermalReliefCopperBridge );
|
|
}
|
|
|
|
else if( TESTLINE( "ZClearance" ) ) // Clearance and pad options info found
|
|
{
|
|
// e.g. "ZClearance 40 I"
|
|
BIU clearance = biuParse( line + SZ( "ZClearance" ), &data );
|
|
char* padoption = strtok_r( (char*) data, delims, &saveptr ); // data: " I"
|
|
|
|
ZoneConnection popt;
|
|
switch( *padoption )
|
|
{
|
|
case 'I': popt = PAD_ZONE_CONN_FULL; break;
|
|
case 'T': popt = PAD_ZONE_CONN_THERMAL; break;
|
|
case 'H': popt = PAD_ZONE_CONN_THT_THERMAL; break;
|
|
case 'X': popt = PAD_ZONE_CONN_NONE; break;
|
|
|
|
default:
|
|
m_error.Printf( wxT( "Bad ZClearance padoption for CZONE_CONTAINER '%s'" ),
|
|
zc->GetNetname().GetData() );
|
|
THROW_IO_ERROR( m_error );
|
|
}
|
|
|
|
zc->SetZoneClearance( clearance );
|
|
zc->SetPadConnection( popt );
|
|
}
|
|
|
|
else if( TESTLINE( "ZMinThickness" ) )
|
|
{
|
|
BIU thickness = biuParse( line + SZ( "ZMinThickness" ) );
|
|
zc->SetMinThickness( thickness );
|
|
}
|
|
|
|
else if( TESTLINE( "ZPriority" ) )
|
|
{
|
|
int priority = intParse( line + SZ( "ZPriority" ) );
|
|
zc->SetPriority( priority );
|
|
}
|
|
|
|
else if( TESTLINE( "$POLYSCORNERS" ) )
|
|
{
|
|
// Read the PolysList (polygons used for fill areas in the zone)
|
|
SHAPE_POLY_SET polysList;
|
|
|
|
bool makeNewOutline = true;
|
|
|
|
while( ( line = READLINE( m_reader ) ) != NULL )
|
|
{
|
|
if( TESTLINE( "$endPOLYSCORNERS" ) )
|
|
break;
|
|
|
|
// e.g. "39610 43440 0 0"
|
|
BIU x = biuParse( line, &data );
|
|
BIU y = biuParse( data, &data );
|
|
|
|
if( makeNewOutline )
|
|
polysList.NewOutline();
|
|
|
|
polysList.Append( x, y );
|
|
|
|
bool end_contour = intParse( data, &data ); // end_countour was a bool when file saved, so '0' or '1' here
|
|
intParse( data ); // skip corner utility flag
|
|
|
|
makeNewOutline = end_contour;
|
|
}
|
|
|
|
zc->AddFilledPolysList( polysList );
|
|
}
|
|
|
|
else if( TESTLINE( "$FILLSEGMENTS" ) )
|
|
{
|
|
while( ( line = READLINE( m_reader ) ) != NULL )
|
|
{
|
|
if( TESTLINE( "$endFILLSEGMENTS" ) )
|
|
break;
|
|
|
|
// e.g. ""%d %d %d %d\n"
|
|
BIU sx = biuParse( line, &data );
|
|
BIU sy = biuParse( data, &data );
|
|
BIU ex = biuParse( data, &data );
|
|
BIU ey = biuParse( data );
|
|
|
|
zc->FillSegments().push_back( SEGMENT( wxPoint( sx, sy ), wxPoint( ex, ey ) ) );
|
|
}
|
|
}
|
|
|
|
else if( TESTLINE( "$endCZONE_OUTLINE" ) )
|
|
{
|
|
// Ensure keepout does not have a net
|
|
// (which have no sense for a keepout zone)
|
|
if( zc->GetIsKeepout() )
|
|
zc->SetNetCode( NETINFO_LIST::UNCONNECTED );
|
|
|
|
// should always occur, but who knows, a zone without two corners
|
|
// is no zone at all, it's a spot?
|
|
|
|
if( zc->GetNumCorners() > 2 )
|
|
{
|
|
if( !zc->IsOnCopperLayer() )
|
|
{
|
|
zc->SetFillMode( 0 );
|
|
zc->SetNetCode( NETINFO_LIST::UNCONNECTED );
|
|
}
|
|
|
|
// Hatch here, after outlines corners are read
|
|
// Set hatch here, after outlines corners are read
|
|
zc->Outline()->SetHatch( outline_hatch,
|
|
Mils2iu( CPolyLine::GetDefaultHatchPitchMils() ),
|
|
true );
|
|
|
|
m_board->Add( zc.release() );
|
|
}
|
|
|
|
return; // preferred exit
|
|
}
|
|
}
|
|
|
|
THROW_IO_ERROR( "Missing '$endCZONE_OUTLINE'" );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::loadDIMENSION()
|
|
{
|
|
auto_ptr<DIMENSION> dim( new DIMENSION( m_board ) );
|
|
|
|
char* line;
|
|
char* saveptr;
|
|
|
|
while( ( line = READLINE( m_reader ) ) != NULL )
|
|
{
|
|
const char* data;
|
|
|
|
if( TESTLINE( "$endCOTATION" ) )
|
|
{
|
|
m_board->Add( dim.release(), ADD_APPEND );
|
|
return; // preferred exit
|
|
}
|
|
|
|
else if( TESTLINE( "Va" ) )
|
|
{
|
|
BIU value = biuParse( line + SZ( "Va" ) );
|
|
dim->SetValue( value );
|
|
}
|
|
|
|
else if( TESTLINE( "Ge" ) )
|
|
{
|
|
LAYER_NUM layer_num;
|
|
time_t timestamp;
|
|
int shape;
|
|
int ilayer;
|
|
|
|
sscanf( line + SZ( "Ge" ), " %d %d %lX", &shape, &ilayer, ×tamp );
|
|
|
|
if( ilayer < FIRST_NON_COPPER_LAYER )
|
|
layer_num = FIRST_NON_COPPER_LAYER;
|
|
else if( ilayer > LAST_NON_COPPER_LAYER )
|
|
layer_num = LAST_NON_COPPER_LAYER;
|
|
else
|
|
layer_num = ilayer;
|
|
|
|
dim->SetLayer( leg_layer2new( m_cu_count, layer_num ) );
|
|
dim->SetTimeStamp( timestamp );
|
|
dim->SetShape( shape );
|
|
}
|
|
|
|
else if( TESTLINE( "Te" ) )
|
|
{
|
|
char buf[2048];
|
|
|
|
ReadDelimitedText( buf, line + SZ( "Te" ), sizeof(buf) );
|
|
dim->SetText( FROM_UTF8( buf ) );
|
|
}
|
|
|
|
else if( TESTLINE( "Po" ) )
|
|
{
|
|
// sscanf( Line + 2, " %d %d %d %d %d %d %d", &m_Text->m_Pos.x, &m_Text->m_Pos.y,
|
|
// &m_Text->m_Size.x, &m_Text->m_Size.y, &thickness, &orientation, &normal_display );
|
|
|
|
BIU pos_x = biuParse( line + SZ( "Po" ), &data );
|
|
BIU pos_y = biuParse( data, &data );
|
|
BIU width = biuParse( data, &data );
|
|
BIU height = biuParse( data, &data );
|
|
BIU thickn = biuParse( data, &data );
|
|
double orient = degParse( data, &data );
|
|
char* mirror = strtok_r( (char*) data, delims, &saveptr );
|
|
|
|
// This sets both DIMENSION's position and internal m_Text's.
|
|
// @todo: But why do we even know about internal m_Text?
|
|
dim->SetPosition( wxPoint( pos_x, pos_y ) );
|
|
dim->SetTextSize( wxSize( width, height ) );
|
|
|
|
dim->Text().SetMirrored( mirror && *mirror == '0' );
|
|
dim->Text().SetThickness( thickn );
|
|
dim->Text().SetOrientation( orient );
|
|
}
|
|
|
|
else if( TESTLINE( "Sb" ) )
|
|
{
|
|
// sscanf( Line + 2, " %d %d %d %d %d %d", &Dummy, &m_crossBarOx, &m_crossBarOy, &m_crossBarFx, &m_crossBarFy, &m_Width );
|
|
|
|
int ignore = biuParse( line + SZ( "Sb" ), &data );
|
|
BIU crossBarOx = biuParse( data, &data );
|
|
BIU crossBarOy = biuParse( data, &data );
|
|
BIU crossBarFx = biuParse( data, &data );
|
|
BIU crossBarFy = biuParse( data, &data );
|
|
BIU width = biuParse( data );
|
|
|
|
dim->m_crossBarO.x = crossBarOx;
|
|
dim->m_crossBarO.y = crossBarOy;
|
|
dim->m_crossBarF.x = crossBarFx;
|
|
dim->m_crossBarF.y = crossBarFy;
|
|
dim->SetWidth( width );
|
|
(void) ignore;
|
|
}
|
|
|
|
else if( TESTLINE( "Sd" ) )
|
|
{
|
|
// sscanf( Line + 2, " %d %d %d %d %d %d", &Dummy, &m_featureLineDOx, &m_featureLineDOy, &m_featureLineDFx, &m_featureLineDFy, &Dummy );
|
|
|
|
int ignore = intParse( line + SZ( "Sd" ), &data );
|
|
BIU featureLineDOx = biuParse( data, &data );
|
|
BIU featureLineDOy = biuParse( data, &data );
|
|
BIU featureLineDFx = biuParse( data, &data );
|
|
BIU featureLineDFy = biuParse( data );
|
|
|
|
dim->m_featureLineDO.x = featureLineDOx;
|
|
dim->m_featureLineDO.y = featureLineDOy;
|
|
dim->m_featureLineDF.x = featureLineDFx;
|
|
dim->m_featureLineDF.y = featureLineDFy;
|
|
(void) ignore;
|
|
}
|
|
|
|
else if( TESTLINE( "Sg" ) )
|
|
{
|
|
// sscanf( Line + 2, " %d %d %d %d %d %d", &Dummy, &m_featureLineGOx, &m_featureLineGOy, &m_featureLineGFx, &m_featureLineGFy, &Dummy );
|
|
|
|
int ignore = intParse( line + SZ( "Sg" ), &data );
|
|
BIU featureLineGOx = biuParse( data, &data );
|
|
BIU featureLineGOy = biuParse( data, &data );
|
|
BIU featureLineGFx = biuParse( data, &data );
|
|
BIU featureLineGFy = biuParse( data );
|
|
|
|
dim->m_featureLineGO.x = featureLineGOx;
|
|
dim->m_featureLineGO.y = featureLineGOy;
|
|
dim->m_featureLineGF.x = featureLineGFx;
|
|
dim->m_featureLineGF.y = featureLineGFy;
|
|
(void) ignore;
|
|
}
|
|
|
|
else if( TESTLINE( "S1" ) )
|
|
{
|
|
// sscanf( Line + 2, " %d %d %d %d %d %d", &Dummy, &m_arrowD1Ox, &m_arrowD1Oy, &m_arrowD1Fx, &m_arrowD1Fy, &Dummy );
|
|
|
|
int ignore = intParse( line + SZ( "S1" ), &data );
|
|
biuParse( data, &data ); // skipping excessive data
|
|
biuParse( data, &data ); // skipping excessive data
|
|
BIU arrowD1Fx = biuParse( data, &data );
|
|
BIU arrowD1Fy = biuParse( data );
|
|
|
|
dim->m_arrowD1F.x = arrowD1Fx;
|
|
dim->m_arrowD1F.y = arrowD1Fy;
|
|
(void) ignore;
|
|
}
|
|
|
|
else if( TESTLINE( "S2" ) )
|
|
{
|
|
// sscanf( Line + 2, " %d %d %d %d %d %d", &Dummy, &m_arrowD2Ox, &m_arrowD2Oy, &m_arrowD2Fx, &m_arrowD2Fy, &Dummy );
|
|
|
|
int ignore = intParse( line + SZ( "S2" ), &data );
|
|
biuParse( data, &data ); // skipping excessive data
|
|
biuParse( data, &data ); // skipping excessive data
|
|
BIU arrowD2Fx = biuParse( data, &data );
|
|
BIU arrowD2Fy = biuParse( data, &data );
|
|
|
|
dim->m_arrowD2F.x = arrowD2Fx;
|
|
dim->m_arrowD2F.y = arrowD2Fy;
|
|
(void) ignore;
|
|
}
|
|
|
|
else if( TESTLINE( "S3" ) )
|
|
{
|
|
// sscanf( Line + 2, " %d %d %d %d %d %d\n", &Dummy, &m_arrowG1Ox, &m_arrowG1Oy, &m_arrowG1Fx, &m_arrowG1Fy, &Dummy );
|
|
int ignore = intParse( line + SZ( "S3" ), &data );
|
|
biuParse( data, &data ); // skipping excessive data
|
|
biuParse( data, &data ); // skipping excessive data
|
|
BIU arrowG1Fx = biuParse( data, &data );
|
|
BIU arrowG1Fy = biuParse( data, &data );
|
|
|
|
dim->m_arrowG1F.x = arrowG1Fx;
|
|
dim->m_arrowG1F.y = arrowG1Fy;
|
|
(void) ignore;
|
|
}
|
|
|
|
else if( TESTLINE( "S4" ) )
|
|
{
|
|
// sscanf( Line + 2, " %d %d %d %d %d %d", &Dummy, &m_arrowG2Ox, &m_arrowG2Oy, &m_arrowG2Fx, &m_arrowG2Fy, &Dummy );
|
|
int ignore = intParse( line + SZ( "S4" ), &data );
|
|
biuParse( data, &data ); // skipping excessive data
|
|
biuParse( data, &data ); // skipping excessive data
|
|
BIU arrowG2Fx = biuParse( data, &data );
|
|
BIU arrowG2Fy = biuParse( data, &data );
|
|
|
|
dim->m_arrowG2F.x = arrowG2Fx;
|
|
dim->m_arrowG2F.y = arrowG2Fy;
|
|
(void) ignore;
|
|
}
|
|
}
|
|
|
|
THROW_IO_ERROR( "Missing '$endCOTATION'" );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::loadPCB_TARGET()
|
|
{
|
|
char* line;
|
|
|
|
while( ( line = READLINE( m_reader ) ) != NULL )
|
|
{
|
|
const char* data;
|
|
|
|
if( TESTLINE( "$EndPCB_TARGET" ) || TESTLINE( "$EndMIREPCB" ) )
|
|
{
|
|
return; // preferred exit
|
|
}
|
|
|
|
else if( TESTLINE( "Po" ) )
|
|
{
|
|
// 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 );
|
|
|
|
int shape = intParse( line + SZ( "Po" ), &data );
|
|
|
|
LAYER_NUM layer_num = layerParse( data, &data );
|
|
|
|
BIU pos_x = biuParse( data, &data );
|
|
BIU pos_y = biuParse( data, &data );
|
|
BIU size = biuParse( data, &data );
|
|
BIU width = biuParse( data, &data );
|
|
time_t timestamp = hexParse( data );
|
|
|
|
if( layer_num < FIRST_NON_COPPER_LAYER )
|
|
layer_num = FIRST_NON_COPPER_LAYER;
|
|
|
|
else if( layer_num > LAST_NON_COPPER_LAYER )
|
|
layer_num = LAST_NON_COPPER_LAYER;
|
|
|
|
PCB_TARGET* t = new PCB_TARGET( m_board, shape, leg_layer2new( m_cu_count, layer_num ),
|
|
wxPoint( pos_x, pos_y ), size, width );
|
|
m_board->Add( t, ADD_APPEND );
|
|
|
|
t->SetTimeStamp( timestamp );
|
|
}
|
|
}
|
|
|
|
THROW_IO_ERROR( "Missing '$EndDIMENSION'" );
|
|
}
|
|
|
|
|
|
BIU LEGACY_PLUGIN::biuParse( const char* aValue, const char** nptrptr )
|
|
{
|
|
char* nptr;
|
|
|
|
errno = 0;
|
|
|
|
double fval = strtod( aValue, &nptr );
|
|
|
|
if( errno )
|
|
{
|
|
m_error.Printf( _( "invalid float number in file: '%s'\nline: %d, offset: %d" ),
|
|
m_reader->GetSource().GetData(),
|
|
m_reader->LineNumber(), aValue - m_reader->Line() + 1 );
|
|
|
|
THROW_IO_ERROR( m_error );
|
|
}
|
|
|
|
if( aValue == nptr )
|
|
{
|
|
m_error.Printf( _( "missing float number in file: '%s'\nline: %d, offset: %d" ),
|
|
m_reader->GetSource().GetData(),
|
|
m_reader->LineNumber(), aValue - m_reader->Line() + 1 );
|
|
|
|
THROW_IO_ERROR( m_error );
|
|
}
|
|
|
|
if( nptrptr )
|
|
*nptrptr = nptr;
|
|
|
|
fval *= diskToBiu;
|
|
|
|
// fval is up into the whole number realm here, and should be bounded
|
|
// within INT_MIN to INT_MAX since BIU's are nanometers.
|
|
return KiROUND( fval );
|
|
}
|
|
|
|
|
|
double LEGACY_PLUGIN::degParse( const char* aValue, const char** nptrptr )
|
|
{
|
|
char* nptr;
|
|
|
|
errno = 0;
|
|
|
|
double fval = strtod( aValue, &nptr );
|
|
|
|
if( errno )
|
|
{
|
|
m_error.Printf( _( "invalid float number in file: '%s'\nline: %d, offset: %d" ),
|
|
m_reader->GetSource().GetData(), m_reader->LineNumber(), aValue - m_reader->Line() + 1 );
|
|
|
|
THROW_IO_ERROR( m_error );
|
|
}
|
|
|
|
if( aValue == nptr )
|
|
{
|
|
m_error.Printf( _( "missing float number in file: '%s'\nline: %d, offset: %d" ),
|
|
m_reader->GetSource().GetData(), m_reader->LineNumber(), aValue - m_reader->Line() + 1 );
|
|
|
|
THROW_IO_ERROR( m_error );
|
|
}
|
|
|
|
if( nptrptr )
|
|
*nptrptr = nptr;
|
|
|
|
return fval;
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::init( const PROPERTIES* aProperties )
|
|
{
|
|
m_loading_format_version = 0;
|
|
m_cu_count = 16;
|
|
m_board = NULL;
|
|
m_props = aProperties;
|
|
|
|
// conversion factor for saving RAM BIUs to KICAD legacy file format.
|
|
biuToDisk = 1.0/IU_PER_MM; // BIUs are nanometers & file is mm
|
|
|
|
// Conversion factor for loading KICAD legacy file format into BIUs in RAM
|
|
// Start by assuming the *.brd file is in deci-mils.
|
|
// If we see "Units mm" in the $GENERAL section, set diskToBiu to 1000000.0
|
|
// then, during the file loading process, to start a conversion from
|
|
// mm to nanometers. The deci-mil legacy files have no such "Units" marker
|
|
// so we must assume the file is in deci-mils until told otherwise.
|
|
|
|
diskToBiu = IU_PER_DECIMILS; // BIUs are nanometers
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::SaveModule3D( const MODULE* me ) const
|
|
{
|
|
for( S3D_MASTER* t3D = me->Models(); t3D; t3D = t3D->Next() )
|
|
{
|
|
if( !t3D->GetShape3DName().IsEmpty() )
|
|
{
|
|
fprintf( m_fp, "$SHAPE3D\n" );
|
|
|
|
fprintf( m_fp, "Na %s\n", EscapedUTF8( t3D->GetShape3DName() ).c_str() );
|
|
|
|
fprintf(m_fp,
|
|
#if defined(DEBUG)
|
|
// use old formats for testing, just to verify compatibility
|
|
// using "diff", then switch to more concise form for release builds.
|
|
"Sc %lf %lf %lf\n",
|
|
#else
|
|
"Sc %.10g %.10g %.10g\n",
|
|
#endif
|
|
t3D->m_MatScale.x,
|
|
t3D->m_MatScale.y,
|
|
t3D->m_MatScale.z );
|
|
|
|
fprintf(m_fp,
|
|
#if defined(DEBUG)
|
|
"Of %lf %lf %lf\n",
|
|
#else
|
|
"Of %.10g %.10g %.10g\n",
|
|
#endif
|
|
t3D->m_MatPosition.x,
|
|
t3D->m_MatPosition.y,
|
|
t3D->m_MatPosition.z );
|
|
|
|
fprintf(m_fp,
|
|
#if defined(DEBUG)
|
|
"Ro %lf %lf %lf\n",
|
|
#else
|
|
"Ro %.10g %.10g %.10g\n",
|
|
#endif
|
|
t3D->m_MatRotation.x,
|
|
t3D->m_MatRotation.y,
|
|
t3D->m_MatRotation.z );
|
|
|
|
fprintf( m_fp, "$EndSHAPE3D\n" );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#if 0
|
|
|
|
//-----<BOARD Save Functions>---------------------------------------------------
|
|
|
|
#define SPBUFZ 50 // wire all usages of this together.
|
|
|
|
int LEGACY_PLUGIN::biuSprintf( char* buf, BIU aValue ) const
|
|
{
|
|
double engUnits = biuToDisk * aValue;
|
|
int len;
|
|
|
|
if( engUnits != 0.0 && fabsl( engUnits ) <= 0.0001 )
|
|
{
|
|
len = snprintf( buf, SPBUFZ, "%.10f", engUnits );
|
|
|
|
while( --len > 0 && buf[len] == '0' )
|
|
buf[len] = '\0';
|
|
|
|
++len;
|
|
}
|
|
else
|
|
{
|
|
// The %.10g is about optimal since we are dealing with a bounded
|
|
// range on aValue, and we can be sure that there will never
|
|
// be a reason to have more than 6 digits to the right of the
|
|
// decimal point because we are converting from integer
|
|
// (signed whole numbers) nanometers to mm. A value of
|
|
// 0.000001 is one nanometer, the smallest positive nonzero value
|
|
// that we can ever have here. If you ever see a board file with
|
|
// more digits to the right of the decimal point than 6, this is a
|
|
// possibly a bug in a formatting string nearby.
|
|
len = snprintf( buf, SPBUFZ, "%.10g", engUnits );
|
|
}
|
|
return len;
|
|
}
|
|
|
|
|
|
std::string LEGACY_PLUGIN::fmtBIU( BIU aValue ) const
|
|
{
|
|
char temp[SPBUFZ];
|
|
|
|
int len = biuSprintf( temp, aValue );
|
|
|
|
return std::string( temp, len );
|
|
}
|
|
|
|
|
|
std::string LEGACY_PLUGIN::fmtDEG( double aAngle ) const
|
|
{
|
|
char temp[50];
|
|
|
|
// @todo a hook site to convert from tenths degrees to degrees for BOARD_FORMAT_VERSION 2.
|
|
|
|
// MINGW: snprintf() comes from gcc folks, sprintf() comes from Microsoft.
|
|
int len = snprintf( temp, sizeof( temp ), "%.10g", aAngle );
|
|
|
|
return std::string( temp, len );
|
|
}
|
|
|
|
|
|
std::string LEGACY_PLUGIN::fmtBIUPair( BIU first, BIU second ) const
|
|
{
|
|
char temp[2*SPBUFZ+2];
|
|
char* cp = temp;
|
|
|
|
cp += biuSprintf( cp, first );
|
|
|
|
*cp++ = ' ';
|
|
|
|
cp += biuSprintf( cp, second );
|
|
|
|
return std::string( temp, cp - temp );
|
|
}
|
|
|
|
void LEGACY_PLUGIN::Save( const wxString& aFileName, BOARD* aBoard, const PROPERTIES* aProperties )
|
|
{
|
|
LOCALE_IO toggle; // toggles on, then off, the C locale.
|
|
|
|
init( aProperties );
|
|
|
|
FILE* fp = wxFopen( aFileName, wxT( "w" ) );
|
|
if( !fp )
|
|
{
|
|
m_error.Printf( _( "Unable to open file '%s'" ), aFileName.GetData() );
|
|
THROW_IO_ERROR( m_error );
|
|
}
|
|
|
|
m_filename = aFileName;
|
|
|
|
// wxf now owns fp, will close on exception or return
|
|
wxFFile wxf( fp );
|
|
|
|
m_fp = fp; // member function accessibility
|
|
|
|
wxString header = wxString::Format(
|
|
wxT( "PCBNEW-BOARD Version %d date %s\n\n# Created by Pcbnew%s\n\n" ),
|
|
LEGACY_BOARD_FILE_VERSION, DateAndTime().GetData(),
|
|
GetBuildVersion().GetData() );
|
|
|
|
// save a file header, if caller provided one (with trailing \n hopefully).
|
|
fprintf( m_fp, "%s", TO_UTF8( header ) );
|
|
|
|
SaveBOARD( aBoard );
|
|
}
|
|
|
|
|
|
wxString LEGACY_PLUGIN::writeError() const
|
|
{
|
|
return wxString::Format( _( "error writing to file '%s'" ), m_filename.GetData() );
|
|
}
|
|
|
|
#define CHECK_WRITE_ERROR() \
|
|
do { \
|
|
if( ferror( m_fp ) ) \
|
|
{ \
|
|
THROW_IO_ERROR( writeError() ); \
|
|
} \
|
|
} while(0)
|
|
|
|
|
|
// With the advent of the LSET expansion it was agreed to abort the legacy save since
|
|
// we'd have to expand the old format in order to suppor the new LAYER_IDs.
|
|
|
|
void LEGACY_PLUGIN::SaveBOARD( const BOARD* aBoard ) const
|
|
{
|
|
m_mapping->SetBoard( aBoard );
|
|
|
|
saveGENERAL( aBoard );
|
|
|
|
saveSHEET( aBoard );
|
|
|
|
saveSETUP( aBoard );
|
|
|
|
saveBOARD_ITEMS( aBoard );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::saveGENERAL( const BOARD* aBoard ) const
|
|
{
|
|
fprintf( m_fp, "$GENERAL\n" );
|
|
fprintf( m_fp, "encoding utf-8\n" );
|
|
|
|
// tell folks the units used within the file, as early as possible here.
|
|
fprintf( m_fp, "Units mm\n" );
|
|
|
|
// Write copper layer count
|
|
fprintf( m_fp, "LayerCount %d\n", aBoard->GetCopperLayerCount() );
|
|
|
|
/* No, EnabledLayers has this information, plus g_TabAllCopperLayerMask is
|
|
global and globals are not allowed in a plugin.
|
|
fprintf( m_fp,
|
|
"Ly %8X\n",
|
|
g_TabAllCopperLayerMask[NbLayers - 1] | ALL_NO_CU_LAYERS );
|
|
*/
|
|
|
|
fprintf( m_fp, "EnabledLayers %08X\n", aBoard->GetEnabledLayers() );
|
|
|
|
if( aBoard->GetEnabledLayers() != aBoard->GetVisibleLayers() )
|
|
fprintf( m_fp, "VisibleLayers %08X\n", aBoard->GetVisibleLayers() );
|
|
|
|
fprintf( m_fp, "Links %d\n", aBoard->GetRatsnestsCount() );
|
|
fprintf( m_fp, "NoConn %d\n", aBoard->GetUnconnectedNetCount() );
|
|
|
|
// Write Bounding box info
|
|
EDA_RECT bbbox = ((BOARD*)aBoard)->ComputeBoundingBox();
|
|
|
|
fprintf( m_fp, "Di %s %s\n",
|
|
fmtBIUPair( bbbox.GetX(), bbbox.GetY() ).c_str(),
|
|
fmtBIUPair( bbbox.GetRight(), bbbox.GetBottom() ).c_str() );
|
|
|
|
fprintf( m_fp, "Ndraw %d\n", aBoard->m_Drawings.GetCount() );
|
|
fprintf( m_fp, "Ntrack %d\n", aBoard->GetNumSegmTrack() );
|
|
fprintf( m_fp, "Nzone %d\n", aBoard->GetNumSegmZone() );
|
|
fprintf( m_fp, "BoardThickness %s\n", fmtBIU( aBoard->GetDesignSettings().GetBoardThickness() ).c_str() );
|
|
fprintf( m_fp, "Nmodule %d\n", aBoard->m_Modules.GetCount() );
|
|
fprintf( m_fp, "Nnets %d\n", m_mapping->GetSize() );
|
|
fprintf( m_fp, "$EndGENERAL\n\n" );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::saveSHEET( const BOARD* aBoard ) const
|
|
{
|
|
const PAGE_INFO& pageInfo = aBoard->GetPageSettings();
|
|
const TITLE_BLOCK& tb = ((BOARD*)aBoard)->GetTitleBlock();
|
|
|
|
fprintf( m_fp, "$SHEETDESCR\n" );
|
|
|
|
// paper is described in mils
|
|
fprintf( m_fp, "Sheet %s %d %d%s\n",
|
|
TO_UTF8( pageInfo.GetType() ),
|
|
pageInfo.GetWidthMils(),
|
|
pageInfo.GetHeightMils(),
|
|
!pageInfo.IsCustom() && pageInfo.IsPortrait() ?
|
|
" portrait" : ""
|
|
);
|
|
|
|
fprintf( m_fp, "Title %s\n", EscapedUTF8( tb.GetTitle() ).c_str() );
|
|
fprintf( m_fp, "Date %s\n", EscapedUTF8( tb.GetDate() ).c_str() );
|
|
fprintf( m_fp, "Rev %s\n", EscapedUTF8( tb.GetRevision() ).c_str() );
|
|
fprintf( m_fp, "Comp %s\n", EscapedUTF8( tb.GetCompany() ).c_str() );
|
|
fprintf( m_fp, "Comment1 %s\n", EscapedUTF8( tb.GetComment1() ).c_str() );
|
|
fprintf( m_fp, "Comment2 %s\n", EscapedUTF8( tb.GetComment2() ).c_str() );
|
|
fprintf( m_fp, "Comment3 %s\n", EscapedUTF8( tb.GetComment3() ).c_str() );
|
|
fprintf( m_fp, "Comment4 %s\n", EscapedUTF8( tb.GetComment4() ).c_str() );
|
|
fprintf( m_fp, "$EndSHEETDESCR\n\n" );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::saveSETUP( const BOARD* aBoard ) const
|
|
{
|
|
const BOARD_DESIGN_SETTINGS& bds = aBoard->GetDesignSettings();
|
|
NETCLASSPTR netclass_default = bds.GetDefault();
|
|
|
|
fprintf( m_fp, "$SETUP\n" );
|
|
|
|
/* Internal units are nobody's business, they are internal.
|
|
Units used in the file are now in the "Units" attribute of $GENERAL.
|
|
fprintf( m_fp,, "InternalUnit %f INCH\n", 1.0 / PCB_LEGACY_INTERNAL_UNIT );
|
|
*/
|
|
|
|
fprintf( m_fp, "Layers %d\n", aBoard->GetCopperLayerCount() );
|
|
|
|
unsigned layerMask = ALL_CU_LAYERS & aBoard->GetEnabledLayers();
|
|
|
|
for( LAYER_NUM layer = FIRST_LAYER; layer <= LAST_COPPER_LAYER; ++layer )
|
|
{
|
|
if( layerMask & MASK( layer ) )
|
|
{
|
|
fprintf( m_fp, "Layer[%d] %s %s\n", layer,
|
|
TO_UTF8( aBoard->GetLayerName( layer ) ),
|
|
LAYER::ShowType( aBoard->GetLayerType( layer ) ) );
|
|
}
|
|
}
|
|
|
|
// Save current default track width, for compatibility with older Pcbnew version;
|
|
fprintf( m_fp, "TrackWidth %s\n",
|
|
fmtBIU( aBoard->GetDesignSettings().GetCurrentTrackWidth() ).c_str() );
|
|
|
|
// Save custom tracks width list (the first is not saved here: this is the netclass value
|
|
for( unsigned ii = 1; ii < aBoard->GetDesignSettings().m_TrackWidthList.size(); ii++ )
|
|
fprintf( m_fp, "TrackWidthList %s\n", fmtBIU( aBoard->GetDesignSettings().m_TrackWidthList[ii] ).c_str() );
|
|
|
|
fprintf( m_fp, "TrackClearence %s\n", fmtBIU( netclass_default->GetClearance() ).c_str() );
|
|
|
|
// ZONE_SETTINGS
|
|
fprintf( m_fp, "ZoneClearence %s\n", fmtBIU( aBoard->GetZoneSettings().m_ZoneClearance ).c_str() );
|
|
fprintf( m_fp, "Zone_45_Only %d\n", aBoard->GetZoneSettings().m_Zone_45_Only );
|
|
|
|
fprintf( m_fp, "TrackMinWidth %s\n", fmtBIU( bds.m_TrackMinWidth ).c_str() );
|
|
|
|
fprintf( m_fp, "DrawSegmWidth %s\n", fmtBIU( bds.m_DrawSegmentWidth ).c_str() );
|
|
fprintf( m_fp, "EdgeSegmWidth %s\n", fmtBIU( bds.m_EdgeSegmentWidth ).c_str() );
|
|
|
|
// Save current default via size, for compatibility with older Pcbnew version;
|
|
fprintf( m_fp, "ViaSize %s\n", fmtBIU( netclass_default->GetViaDiameter() ).c_str() );
|
|
fprintf( m_fp, "ViaDrill %s\n", fmtBIU( netclass_default->GetViaDrill() ).c_str() );
|
|
fprintf( m_fp, "ViaMinSize %s\n", fmtBIU( bds.m_ViasMinSize ).c_str() );
|
|
fprintf( m_fp, "ViaMinDrill %s\n", fmtBIU( bds.m_ViasMinDrill ).c_str() );
|
|
|
|
// Save custom vias diameters list (the first is not saved here: this is
|
|
// the netclass value
|
|
for( unsigned ii = 1; ii < aBoard->GetDesignSettings().m_ViasDimensionsList.size(); ii++ )
|
|
fprintf( m_fp, "ViaSizeList %s %s\n",
|
|
fmtBIU( aBoard->GetDesignSettings().m_ViasDimensionsList[ii].m_Diameter ).c_str(),
|
|
fmtBIU( aBoard->GetDesignSettings().m_ViasDimensionsList[ii].m_Drill ).c_str() );
|
|
|
|
// for old versions compatibility:
|
|
fprintf( m_fp, "MicroViaSize %s\n", fmtBIU( netclass_default->GetuViaDiameter() ).c_str() );
|
|
fprintf( m_fp, "MicroViaDrill %s\n", fmtBIU( netclass_default->GetuViaDrill() ).c_str() );
|
|
fprintf( m_fp, "MicroViasAllowed %s\n", fmtBIU( bds.m_MicroViasAllowed ).c_str() );
|
|
fprintf( m_fp, "MicroViaMinSize %s\n", fmtBIU( bds.m_MicroViasMinSize ).c_str() );
|
|
fprintf( m_fp, "MicroViaMinDrill %s\n", fmtBIU( bds.m_MicroViasMinDrill ).c_str() );
|
|
|
|
fprintf( m_fp, "TextPcbWidth %s\n", fmtBIU( bds.m_PcbTextWidth ).c_str() );
|
|
fprintf( m_fp, "TextPcbSize %s\n", fmtBIUSize( bds.m_PcbTextSize ).c_str() );
|
|
|
|
fprintf( m_fp, "EdgeModWidth %s\n", fmtBIU( bds.m_ModuleSegmentWidth ).c_str() );
|
|
fprintf( m_fp, "TextModSize %s\n", fmtBIUSize( bds.m_ModuleTextSize ).c_str() );
|
|
fprintf( m_fp, "TextModWidth %s\n", fmtBIU( bds.m_ModuleTextWidth ).c_str() );
|
|
|
|
fprintf( m_fp, "PadSize %s\n", fmtBIUSize( bds.m_Pad_Master.GetSize() ).c_str() );
|
|
fprintf( m_fp, "PadDrill %s\n", fmtBIU( bds.m_Pad_Master.GetDrillSize().x ).c_str() );
|
|
|
|
fprintf( m_fp, "Pad2MaskClearance %s\n", fmtBIU( bds.m_SolderMaskMargin ).c_str() );
|
|
fprintf( m_fp, "SolderMaskMinWidth %s\n", fmtBIU( bds.m_SolderMaskMinWidth ).c_str() );
|
|
|
|
if( bds.m_SolderPasteMargin != 0 )
|
|
fprintf( m_fp, "Pad2PasteClearance %s\n", fmtBIU( bds.m_SolderPasteMargin ).c_str() );
|
|
|
|
if( bds.m_SolderPasteMarginRatio != 0 )
|
|
fprintf( m_fp, "Pad2PasteClearanceRatio %g\n", bds.m_SolderPasteMarginRatio );
|
|
|
|
fprintf( m_fp, "GridOrigin %s\n", fmtBIUPoint( aBoard->GetGridOrigin() ).c_str() );
|
|
fprintf( m_fp, "AuxiliaryAxisOrg %s\n", fmtBIUPoint( aBoard->GetAuxOrigin() ).c_str() );
|
|
|
|
fprintf( m_fp, "VisibleElements %X\n", bds.GetVisibleElements() );
|
|
|
|
{
|
|
STRING_FORMATTER sf;
|
|
|
|
aBoard->GetPlotOptions().Format( &sf, 0 );
|
|
|
|
wxString record = FROM_UTF8( sf.GetString().c_str() );
|
|
|
|
record.Replace( wxT("\n"), wxT(""), true );
|
|
record.Replace( wxT(" "), wxT(" "), true);
|
|
|
|
fprintf( m_fp, "PcbPlotParams %s\n", TO_UTF8( record ) );
|
|
}
|
|
|
|
fprintf( m_fp, "$EndSETUP\n\n" );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::saveBOARD_ITEMS( const BOARD* aBoard ) const
|
|
{
|
|
// save the nets
|
|
for( NETINFO_MAPPING::iterator net = m_mapping->begin(), netEnd = m_mapping->end();
|
|
net != netEnd; ++net )
|
|
{
|
|
saveNETINFO_ITEM( *net );
|
|
}
|
|
|
|
// Saved nets do not include netclass names, so save netclasses after nets.
|
|
saveNETCLASSES( &aBoard->GetDesignSettings().m_NetClasses );
|
|
|
|
// save the modules
|
|
for( MODULE* m = aBoard->m_Modules; m; m = (MODULE*) m->Next() )
|
|
saveMODULE( m );
|
|
|
|
// save the graphics owned by the board (not owned by a module)
|
|
for( BOARD_ITEM* gr = aBoard->m_Drawings; gr; gr = gr->Next() )
|
|
{
|
|
switch( gr->Type() )
|
|
{
|
|
case PCB_TEXT_T:
|
|
savePCB_TEXT( (TEXTE_PCB*) gr );
|
|
break;
|
|
case PCB_LINE_T:
|
|
savePCB_LINE( (DRAWSEGMENT*) gr );
|
|
break;
|
|
case PCB_TARGET_T:
|
|
savePCB_TARGET( (PCB_TARGET*) gr );
|
|
break;
|
|
case PCB_DIMENSION_T:
|
|
saveDIMENSION( (DIMENSION*) gr );
|
|
break;
|
|
default:
|
|
THROW_IO_ERROR( wxString::Format( UNKNOWN_GRAPHIC_FORMAT, gr->Type() ) );
|
|
}
|
|
}
|
|
|
|
// do not save MARKER_PCBs, they can be regenerated easily
|
|
|
|
// save the tracks & vias
|
|
fprintf( m_fp, "$TRACK\n" );
|
|
for( TRACK* track = aBoard->m_Track; track; track = track->Next() )
|
|
saveTRACK( track );
|
|
fprintf( m_fp, "$EndTRACK\n" );
|
|
|
|
// save the old obsolete zones which were done by segments (tracks)
|
|
fprintf( m_fp, "$ZONE\n" );
|
|
for( SEGZONE* zone = aBoard->m_Zone; zone; zone = zone->Next() )
|
|
saveTRACK( zone );
|
|
fprintf( m_fp, "$EndZONE\n" );
|
|
|
|
// save the polygon (which are the newer technology) zones
|
|
for( int i=0; i < aBoard->GetAreaCount(); ++i )
|
|
saveZONE_CONTAINER( aBoard->GetArea( i ) );
|
|
|
|
fprintf( m_fp, "$EndBOARD\n" );
|
|
|
|
CHECK_WRITE_ERROR();
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::saveNETINFO_ITEM( const NETINFO_ITEM* aNet ) const
|
|
{
|
|
fprintf( m_fp, "$EQUIPOT\n" );
|
|
fprintf( m_fp, "Na %d %s\n", m_mapping->Translate( aNet->GetNet() ),
|
|
EscapedUTF8( aNet->GetNetname() ).c_str() );
|
|
fprintf( m_fp, "St %s\n", "~" );
|
|
fprintf( m_fp, "$EndEQUIPOT\n" );
|
|
|
|
CHECK_WRITE_ERROR();
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::saveNETCLASSES( const NETCLASSES* aNetClasses ) const
|
|
{
|
|
// save the default first.
|
|
saveNETCLASS( aNetClasses->GetDefault() );
|
|
|
|
// the rest will be alphabetical in the *.brd file.
|
|
for( NETCLASSES::const_iterator it = aNetClasses->begin(); it != aNetClasses->end(); ++it )
|
|
{
|
|
NETCLASSPTR netclass = it->second;
|
|
saveNETCLASS( netclass );
|
|
}
|
|
|
|
CHECK_WRITE_ERROR();
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::saveNETCLASS( const NETCLASSPTR nc ) const
|
|
{
|
|
fprintf( m_fp, "$NCLASS\n" );
|
|
fprintf( m_fp, "Name %s\n", EscapedUTF8( nc->GetName() ).c_str() );
|
|
fprintf( m_fp, "Desc %s\n", EscapedUTF8( nc->GetDescription() ).c_str() );
|
|
|
|
fprintf( m_fp, "Clearance %s\n", fmtBIU( nc->GetClearance() ).c_str() );
|
|
fprintf( m_fp, "TrackWidth %s\n", fmtBIU( nc->GetTrackWidth() ).c_str() );
|
|
|
|
fprintf( m_fp, "ViaDia %s\n", fmtBIU( nc->GetViaDiameter() ).c_str() );
|
|
fprintf( m_fp, "ViaDrill %s\n", fmtBIU( nc->GetViaDrill() ).c_str() );
|
|
|
|
fprintf( m_fp, "uViaDia %s\n", fmtBIU( nc->GetuViaDiameter() ).c_str() );
|
|
fprintf( m_fp, "uViaDrill %s\n", fmtBIU( nc->GetuViaDrill() ).c_str() );
|
|
|
|
for( NETCLASS::const_iterator it = nc->begin(); it!=nc->end(); ++it )
|
|
fprintf( m_fp, "AddNet %s\n", EscapedUTF8( *it ).c_str() );
|
|
|
|
fprintf( m_fp, "$EndNCLASS\n" );
|
|
|
|
CHECK_WRITE_ERROR();
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::saveMODULE_TEXT( const TEXTE_MODULE* me ) const
|
|
{
|
|
MODULE* parent = (MODULE*) me->GetParent();
|
|
double orient = me->GetOrientation();
|
|
|
|
// Due to the Pcbnew history, m_Orient is saved in screen value
|
|
// but it is handled as relative to its parent footprint
|
|
if( parent )
|
|
orient += parent->GetOrientation();
|
|
|
|
wxString txt = me->GetText();
|
|
|
|
fprintf( m_fp, "T%d %s %s %s %s %c %c %d %c %s",
|
|
me->GetType(),
|
|
fmtBIUPoint( me->GetPos0() ).c_str(), // m_Pos0.x, m_Pos0.y,
|
|
|
|
// legacy has goofed reversed order: ( y, x )
|
|
fmtBIUPair( me->GetSize().y, me->GetSize().x ).c_str(),
|
|
|
|
fmtDEG( orient ).c_str(),
|
|
fmtBIU( me->GetThickness() ).c_str(), // m_Thickness,
|
|
me->IsMirrored() ? 'M' : 'N',
|
|
me->IsVisible() ? 'V' : 'I',
|
|
me->GetLayer(),
|
|
me->IsItalic() ? 'I' : 'N',
|
|
EscapedUTF8( txt ).c_str()
|
|
);
|
|
|
|
if( me->GetHorizJustify() != GR_TEXT_HJUSTIFY_CENTER ||
|
|
me->GetVertJustify() != GR_TEXT_VJUSTIFY_CENTER )
|
|
{
|
|
fprintf( m_fp, " %s %s\n",
|
|
ShowHorizJustify( me->GetHorizJustify() ),
|
|
ShowVertJustify( me->GetVertJustify() )
|
|
);
|
|
}
|
|
else
|
|
fprintf( m_fp, "\n" );
|
|
|
|
CHECK_WRITE_ERROR();
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::saveMODULE_EDGE( const EDGE_MODULE* me ) const
|
|
{
|
|
switch( me->GetShape() )
|
|
{
|
|
case S_SEGMENT:
|
|
fprintf( m_fp, "DS %s %s %s %d\n",
|
|
fmtBIUPoint( me->m_Start0 ).c_str(),
|
|
fmtBIUPoint( me->m_End0 ).c_str(),
|
|
fmtBIU( me->GetWidth() ).c_str(),
|
|
me->GetLayer() );
|
|
break;
|
|
|
|
case S_CIRCLE:
|
|
fprintf( m_fp, "DC %s %s %s %d\n",
|
|
fmtBIUPoint( me->m_Start0 ).c_str(),
|
|
fmtBIUPoint( me->m_End0 ).c_str(),
|
|
fmtBIU( me->GetWidth() ).c_str(),
|
|
me->GetLayer() );
|
|
break;
|
|
|
|
case S_ARC:
|
|
fprintf( m_fp, "DA %s %s %s %s %d\n",
|
|
fmtBIUPoint( me->m_Start0 ).c_str(),
|
|
fmtBIUPoint( me->m_End0 ).c_str(),
|
|
fmtDEG( me->GetAngle() ).c_str(),
|
|
fmtBIU( me->GetWidth() ).c_str(),
|
|
me->GetLayer() );
|
|
break;
|
|
|
|
case S_POLYGON:
|
|
{
|
|
const std::vector<wxPoint>& polyPoints = me->GetPolyPoints();
|
|
|
|
fprintf( m_fp, "DP %s %s %d %s %d\n",
|
|
fmtBIUPoint( me->m_Start0 ).c_str(),
|
|
fmtBIUPoint( me->m_End0 ).c_str(),
|
|
(int) polyPoints.size(),
|
|
fmtBIU( me->GetWidth() ).c_str(),
|
|
me->GetLayer() );
|
|
|
|
for( unsigned i = 0; i<polyPoints.size(); ++i )
|
|
fprintf( m_fp, "Dl %s\n", fmtBIUPoint( polyPoints[i] ).c_str() );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
THROW_IO_ERROR( wxString::Format( UNKNOWN_GRAPHIC_FORMAT, me->GetShape() ) );
|
|
}
|
|
|
|
CHECK_WRITE_ERROR();
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::savePAD( const D_PAD* me ) const
|
|
{
|
|
fprintf( m_fp, "$PAD\n" );
|
|
|
|
int cshape;
|
|
|
|
switch( me->GetShape() )
|
|
{
|
|
case PAD_SHAPE_CIRCLE: cshape = 'C'; break;
|
|
case PAD_SHAPE_RECT: cshape = 'R'; break;
|
|
case PAD_SHAPE_OVAL: cshape = 'O'; break;
|
|
case PAD_SHAPE_TRAPEZOID: cshape = 'T'; break;
|
|
|
|
default:
|
|
THROW_IO_ERROR( wxString::Format( UNKNOWN_PAD_FORMAT, me->GetShape() ) );
|
|
}
|
|
|
|
#if BOARD_FORMAT_VERSION == 1 // saving mode is a compile time option
|
|
|
|
wxString wpadname = me->GetPadName(); // universal character set padname
|
|
std::string spadname;
|
|
|
|
for( unsigned i = 0; wpadname.size(); ++i )
|
|
{
|
|
// truncate from universal character down to 8 bit foreign jibber
|
|
// jabber byte. This basically duplicates what was done in the old
|
|
// BOARD_FORMAT_VERSION 1 code. Any characters that were in the 8 bit
|
|
// character space were OK.
|
|
spadname += (char) wpadname[i];
|
|
}
|
|
|
|
fprintf( m_fp, "Sh \"%s\" %c %s %s %s\n",
|
|
spadname.c_str(), // probably ASCII, but possibly jibber jabber
|
|
#else
|
|
|
|
fprintf( m_fp, "Sh %s %c %s %s %s\n",
|
|
// legacy VERSION 2 simply uses UTF8, wrapped in quotes,
|
|
// and 99.99 % of the time there is no difference between 1 & 2,
|
|
// since ASCII is a subset of UTF8. But if they were not using
|
|
// ASCII pad names, then there is a difference in the file.
|
|
EscapedUTF8( me->GetPadName() ).c_str(),
|
|
#endif
|
|
cshape,
|
|
fmtBIUSize( me->GetSize() ).c_str(),
|
|
fmtBIUSize( me->GetDelta() ).c_str(),
|
|
fmtDEG( me->GetOrientation() ).c_str() );
|
|
|
|
fprintf( m_fp, "Dr %s %s",
|
|
fmtBIU( me->GetDrillSize().x ).c_str(),
|
|
fmtBIUPoint( me->GetOffset() ).c_str() );
|
|
|
|
if( me->GetDrillShape() == PAD_DRILL_SHAPE_OBLONG )
|
|
{
|
|
fprintf( m_fp, " %c %s", 'O', fmtBIUSize( me->GetDrillSize() ).c_str() );
|
|
}
|
|
|
|
fprintf( m_fp, "\n" );
|
|
|
|
const char* texttype;
|
|
|
|
switch( me->GetAttribute() )
|
|
{
|
|
case PAD_ATTRIB_STANDARD: texttype = "STD"; break;
|
|
case PAD_ATTRIB_SMD: texttype = "SMD"; break;
|
|
case PAD_ATTRIB_CONN: texttype = "CONN"; break;
|
|
case PAD_ATTRIB_HOLE_NOT_PLATED: texttype = "HOLE"; break;
|
|
|
|
default:
|
|
THROW_IO_ERROR( wxString::Format( UNKNOWN_PAD_ATTRIBUTE, me->GetAttribute() ) );
|
|
}
|
|
|
|
fprintf( m_fp, "At %s N %08X\n", texttype, me->GetLayerSet() );
|
|
|
|
fprintf( m_fp, "Ne %d %s\n", m_mapping->Translate( me->GetNetCode() ),
|
|
EscapedUTF8( me->GetNetname() ).c_str() );
|
|
|
|
fprintf( m_fp, "Po %s\n", fmtBIUPoint( me->GetPos0() ).c_str() );
|
|
|
|
if( me->GetPadToDieLength() != 0 )
|
|
fprintf( m_fp, "Le %s\n", fmtBIU( me->GetPadToDieLength() ).c_str() );
|
|
|
|
if( me->GetLocalSolderMaskMargin() != 0 )
|
|
fprintf( m_fp, ".SolderMask %s\n", fmtBIU( me->GetLocalSolderMaskMargin() ).c_str() );
|
|
|
|
if( me->GetLocalSolderPasteMargin() != 0 )
|
|
fprintf( m_fp, ".SolderPaste %s\n", fmtBIU( me->GetLocalSolderPasteMargin() ).c_str() );
|
|
|
|
double ratio = me->GetLocalSolderPasteMarginRatio();
|
|
if( ratio != 0.0 )
|
|
fprintf( m_fp, ".SolderPasteRatio %g\n", ratio );
|
|
|
|
if( me->GetLocalClearance() != 0 )
|
|
fprintf( m_fp, ".LocalClearance %s\n", fmtBIU( me->GetLocalClearance( ) ).c_str() );
|
|
|
|
if( me->GetZoneConnection() != PAD_ZONE_CONN_INHERITED )
|
|
fprintf( m_fp, ".ZoneConnection %d\n", me->GetZoneConnection() );
|
|
|
|
if( me->GetThermalWidth() != 0 )
|
|
fprintf( m_fp, ".ThermalWidth %s\n", fmtBIU( me->GetThermalWidth() ).c_str() );
|
|
|
|
if( me->GetThermalGap() != 0 )
|
|
fprintf( m_fp, ".ThermalGap %s\n", fmtBIU( me->GetThermalGap() ).c_str() );
|
|
|
|
fprintf( m_fp, "$EndPAD\n" );
|
|
|
|
CHECK_WRITE_ERROR();
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::saveMODULE( const MODULE* me ) const
|
|
{
|
|
char statusTxt[3];
|
|
double orient = me->GetOrientation();
|
|
|
|
// Do not save full FPID. Only the footprint name. The legacy file format should
|
|
// never support FPIDs.
|
|
fprintf( m_fp, "$MODULE %s\n", me->GetFPID().GetFootprintName().c_str() );
|
|
|
|
statusTxt[0] = me->IsLocked() ? 'F' : '~';
|
|
statusTxt[1] = me->IsPlaced() ? 'P' : '~';
|
|
statusTxt[2] = '\0';
|
|
|
|
fprintf( m_fp, "Po %s %s %d %08lX %08lX %s\n",
|
|
fmtBIUPoint( me->GetPosition() ).c_str(), // m_Pos.x, m_Pos.y,
|
|
fmtDEG( orient ).c_str(),
|
|
me->GetLayer(),
|
|
me->GetLastEditTime(),
|
|
me->GetTimeStamp(),
|
|
statusTxt );
|
|
|
|
fprintf( m_fp, "Li %s\n", me->GetFPID().GetFootprintName().c_str() );
|
|
|
|
if( !me->GetDescription().IsEmpty() )
|
|
{
|
|
fprintf( m_fp, "Cd %s\n", TO_UTF8( me->GetDescription() ) );
|
|
}
|
|
|
|
if( !me->GetKeywords().IsEmpty() )
|
|
{
|
|
fprintf( m_fp, "Kw %s\n", TO_UTF8( me->GetKeywords() ) );
|
|
}
|
|
|
|
fprintf( m_fp, "Sc %lX\n", me->GetTimeStamp() );
|
|
fprintf( m_fp, "AR %s\n", TO_UTF8( me->GetPath() ) );
|
|
fprintf( m_fp, "Op %X %X 0\n", me->GetPlacementCost90(), me->GetPlacementCost180() );
|
|
|
|
if( me->GetLocalSolderMaskMargin() != 0 )
|
|
fprintf( m_fp, ".SolderMask %s\n", fmtBIU( me->GetLocalSolderMaskMargin() ).c_str() );
|
|
|
|
if( me->GetLocalSolderPasteMargin() != 0 )
|
|
fprintf( m_fp, ".SolderPaste %s\n", fmtBIU( me->GetLocalSolderPasteMargin() ).c_str() );
|
|
|
|
double ratio = me->GetLocalSolderPasteMarginRatio();
|
|
if( ratio != 0.0 )
|
|
fprintf( m_fp, ".SolderPasteRatio %g\n", ratio );
|
|
|
|
if( me->GetLocalClearance() != 0 )
|
|
fprintf( m_fp, ".LocalClearance %s\n", fmtBIU( me->GetLocalClearance( ) ).c_str() );
|
|
|
|
if( me->GetZoneConnection() != PAD_ZONE_CONN_INHERITED )
|
|
fprintf( m_fp, ".ZoneConnection %d\n", me->GetZoneConnection() );
|
|
|
|
if( me->GetThermalWidth() != 0 )
|
|
fprintf( m_fp, ".ThermalWidth %s\n", fmtBIU( me->GetThermalWidth() ).c_str() );
|
|
|
|
if( me->GetThermalGap() != 0 )
|
|
fprintf( m_fp, ".ThermalGap %s\n", fmtBIU( me->GetThermalGap() ).c_str() );
|
|
|
|
// attributes
|
|
if( me->GetAttributes() != MOD_DEFAULT )
|
|
{
|
|
fprintf( m_fp, "At" );
|
|
|
|
if( me->GetAttributes() & MOD_CMS )
|
|
fprintf( m_fp, " SMD" );
|
|
|
|
if( me->GetAttributes() & MOD_VIRTUAL )
|
|
fprintf( m_fp, " VIRTUAL" );
|
|
|
|
fprintf( m_fp, "\n" );
|
|
}
|
|
|
|
saveMODULE_TEXT( &me->Reference() );
|
|
|
|
saveMODULE_TEXT( &me->Value() );
|
|
|
|
// save drawing elements
|
|
for( BOARD_ITEM* gr = me->GraphicalItems(); gr; gr = gr->Next() )
|
|
{
|
|
switch( gr->Type() )
|
|
{
|
|
case PCB_MODULE_TEXT_T:
|
|
saveMODULE_TEXT( static_cast<TEXTE_MODULE*>( gr ));
|
|
break;
|
|
case PCB_MODULE_EDGE_T:
|
|
saveMODULE_EDGE( static_cast<EDGE_MODULE*>( gr ));
|
|
break;
|
|
default:
|
|
THROW_IO_ERROR( wxString::Format( UNKNOWN_GRAPHIC_FORMAT, gr->Type() ) );
|
|
}
|
|
}
|
|
|
|
for( D_PAD* pad = me->Pads(); pad; pad = pad->Next() )
|
|
savePAD( pad );
|
|
|
|
SaveModule3D( me );
|
|
|
|
fprintf( m_fp, "$EndMODULE %s\n", me->GetFPID().GetFootprintName().c_str() );
|
|
|
|
CHECK_WRITE_ERROR();
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::savePCB_TARGET( const PCB_TARGET* me ) const
|
|
{
|
|
fprintf( m_fp, "$PCB_TARGET\n" );
|
|
|
|
fprintf( m_fp, "Po %X %d %s %s %s %lX\n",
|
|
me->GetShape(),
|
|
me->GetLayer(),
|
|
fmtBIUPoint( me->GetPosition() ).c_str(),
|
|
fmtBIU( me->GetSize() ).c_str(),
|
|
fmtBIU( me->GetWidth() ).c_str(),
|
|
me->GetTimeStamp()
|
|
);
|
|
|
|
fprintf( m_fp, "$EndPCB_TARGET\n" );
|
|
|
|
CHECK_WRITE_ERROR();
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::savePCB_LINE( const DRAWSEGMENT* me ) const
|
|
{
|
|
fprintf( m_fp, "$DRAWSEGMENT\n" );
|
|
|
|
fprintf( m_fp, "Po %d %s %s %s\n",
|
|
me->GetShape(),
|
|
fmtBIUPoint( me->GetStart() ).c_str(),
|
|
fmtBIUPoint( me->GetEnd() ).c_str(),
|
|
fmtBIU( me->GetWidth() ).c_str()
|
|
);
|
|
|
|
if( me->GetType() != S_CURVE )
|
|
{
|
|
fprintf( m_fp, "De %d %d %s %lX %X\n",
|
|
me->GetLayer(),
|
|
me->GetType(),
|
|
fmtDEG( me->GetAngle() ).c_str(),
|
|
me->GetTimeStamp(),
|
|
me->GetStatus()
|
|
);
|
|
}
|
|
else
|
|
{
|
|
fprintf( m_fp, "De %d %d %s %lX %X %s %s\n",
|
|
me->GetLayer(),
|
|
me->GetType(),
|
|
fmtDEG( me->GetAngle() ).c_str(),
|
|
me->GetTimeStamp(),
|
|
me->GetStatus(),
|
|
fmtBIUPoint( me->GetBezControl1() ).c_str(),
|
|
fmtBIUPoint( me->GetBezControl2() ).c_str()
|
|
);
|
|
}
|
|
|
|
fprintf( m_fp, "$EndDRAWSEGMENT\n" );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::saveTRACK( const TRACK* me ) const
|
|
{
|
|
int type = 0;
|
|
VIATYPE_T viatype = VIA_NOT_DEFINED;
|
|
int drill = UNDEFINED_DRILL_DIAMETER;
|
|
|
|
if( me->Type() == PCB_VIA_T )
|
|
{
|
|
const VIA *via = static_cast<const VIA *>(me);
|
|
type = 1;
|
|
viatype = via->GetViaType();
|
|
drill = via->GetDrill();
|
|
}
|
|
|
|
fprintf(m_fp, "Po %d %s %s %s %s\n",
|
|
viatype,
|
|
fmtBIUPoint( me->GetStart() ).c_str(),
|
|
fmtBIUPoint( me->GetEnd() ).c_str(),
|
|
fmtBIU( me->GetWidth() ).c_str(),
|
|
drill == UNDEFINED_DRILL_DIAMETER ?
|
|
"-1" : fmtBIU( drill ).c_str() );
|
|
|
|
fprintf(m_fp, "De %d %d %d %lX %X\n",
|
|
me->GetLayer(), type, m_mapping->Translate( me->GetNetCode() ),
|
|
me->GetTimeStamp(), me->GetStatus() );
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::saveZONE_CONTAINER( const ZONE_CONTAINER* me ) const
|
|
{
|
|
fprintf( m_fp, "$CZONE_OUTLINE\n" );
|
|
|
|
// Save the outline main info
|
|
// For keepout zones, net code and net name are irrelevant, so we store a dummy value
|
|
// just for ZONE_CONTAINER compatibility
|
|
fprintf( m_fp, "ZInfo %lX %d %s\n",
|
|
me->GetTimeStamp(),
|
|
me->GetIsKeepout() ? 0 : m_mapping->Translate( me->GetNetCode() ),
|
|
EscapedUTF8( me->GetIsKeepout() ? wxT("") : me->GetNetname() ).c_str() );
|
|
|
|
// Save the outline layer info
|
|
fprintf( m_fp, "ZLayer %d\n", me->GetLayer() );
|
|
|
|
// Save the outline aux info
|
|
int outline_hatch;
|
|
|
|
switch( me->GetHatchStyle() )
|
|
{
|
|
default:
|
|
case CPolyLine::NO_HATCH: outline_hatch = 'N'; break;
|
|
case CPolyLine::DIAGONAL_EDGE: outline_hatch = 'E'; break;
|
|
case CPolyLine::DIAGONAL_FULL: outline_hatch = 'F'; break;
|
|
}
|
|
|
|
fprintf( m_fp, "ZAux %d %c\n", me->GetNumCorners(), outline_hatch );
|
|
|
|
if( me->GetPriority() > 0 )
|
|
fprintf( m_fp, "ZPriority %d\n", me->GetPriority() );
|
|
|
|
// Save pad option and clearance
|
|
char padoption;
|
|
|
|
switch( me->GetPadConnection() )
|
|
{
|
|
default:
|
|
case PAD_ZONE_CONN_FULL: padoption = 'I'; break;
|
|
case PAD_ZONE_CONN_THERMAL: padoption = 'T'; break;
|
|
case PAD_ZONE_CONN_THT_THERMAL: padoption = 'H'; break; // H is for 'hole' since it reliefs holes only
|
|
case PAD_ZONE_CONN_NONE: padoption = 'X'; break;
|
|
}
|
|
|
|
fprintf( m_fp, "ZClearance %s %c\n",
|
|
fmtBIU( me->GetZoneClearance() ).c_str(),
|
|
padoption );
|
|
|
|
fprintf( m_fp, "ZMinThickness %s\n", fmtBIU( me->GetMinThickness() ).c_str() );
|
|
|
|
fprintf( m_fp, "ZOptions %d %d %c %s %s\n",
|
|
me->GetFillMode(),
|
|
me->GetArcSegmentCount(),
|
|
me->IsFilled() ? 'S' : 'F',
|
|
fmtBIU( me->GetThermalReliefGap() ).c_str(),
|
|
fmtBIU( me->GetThermalReliefCopperBridge() ).c_str() );
|
|
|
|
if( me->GetIsKeepout() )
|
|
{
|
|
fprintf( m_fp, "ZKeepout tracks %c vias %c copperpour %c\n",
|
|
me->GetDoNotAllowTracks() ? 'N' : 'Y',
|
|
me->GetDoNotAllowVias() ? 'N' : 'Y',
|
|
me->GetDoNotAllowCopperPour() ? 'N' : 'Y' );
|
|
}
|
|
|
|
fprintf( m_fp, "ZSmoothing %d %s\n",
|
|
me->GetCornerSmoothingType(),
|
|
fmtBIU( me->GetCornerRadius() ).c_str() );
|
|
|
|
// Save the corner list
|
|
const CPOLYGONS_LIST& cv = me->Outline()->m_CornersList;
|
|
|
|
for( unsigned it = 0; it < cv.GetCornersCount(); ++it )
|
|
{
|
|
fprintf( m_fp, "ZCorner %s %d\n",
|
|
fmtBIUPair( cv.GetX( it ), cv.GetY( it ) ).c_str(),
|
|
cv.IsEndContour( it ) );
|
|
}
|
|
|
|
// Save the PolysList
|
|
const CPOLYGONS_LIST& fv = me->GetFilledPolysList();
|
|
if( fv.GetCornersCount() )
|
|
{
|
|
fprintf( m_fp, "$POLYSCORNERS\n" );
|
|
|
|
for( unsigned it = 0; it < fv.GetCornersCount(); ++it )
|
|
{
|
|
fprintf( m_fp, "%s %d %d\n",
|
|
fmtBIUPair( fv.GetX( it ), fv.GetY( it ) ).c_str(),
|
|
fv.IsEndContour( it ),
|
|
fv.GetUtility( it ) );
|
|
}
|
|
|
|
fprintf( m_fp, "$endPOLYSCORNERS\n" );
|
|
}
|
|
|
|
typedef std::vector< SEGMENT > SEGMENTS;
|
|
|
|
// Save the filling segments list
|
|
const SEGMENTS& segs = me->FillSegments();
|
|
|
|
if( segs.size() )
|
|
{
|
|
fprintf( m_fp, "$FILLSEGMENTS\n" );
|
|
|
|
for( SEGMENTS::const_iterator it = segs.begin(); it != segs.end(); ++it )
|
|
{
|
|
fprintf( m_fp, "%s %s\n",
|
|
fmtBIUPoint( it->m_Start ).c_str(),
|
|
fmtBIUPoint( it->m_End ).c_str() );
|
|
}
|
|
|
|
fprintf( m_fp, "$endFILLSEGMENTS\n" );
|
|
}
|
|
|
|
fprintf( m_fp, "$endCZONE_OUTLINE\n" );
|
|
|
|
CHECK_WRITE_ERROR();
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::saveDIMENSION( const DIMENSION* me ) const
|
|
{
|
|
// note: COTATION was the previous name of DIMENSION
|
|
// this old keyword is used here for compatibility
|
|
fprintf( m_fp, "$COTATION\n" );
|
|
|
|
fprintf( m_fp, "Ge %d %d %lX\n", me->GetShape(), me->GetLayer(), me->GetTimeStamp() );
|
|
|
|
fprintf( m_fp, "Va %s\n", fmtBIU( me->GetValue() ).c_str() );
|
|
|
|
if( !me->GetText().IsEmpty() )
|
|
fprintf( m_fp, "Te %s\n", EscapedUTF8( me->GetText() ).c_str() );
|
|
else
|
|
fprintf( m_fp, "Te \"?\"\n" );
|
|
|
|
fprintf( m_fp, "Po %s %s %s %s %d\n",
|
|
fmtBIUPoint( me->Text().GetTextPosition() ).c_str(),
|
|
fmtBIUSize( me->Text().GetSize() ).c_str(),
|
|
fmtBIU( me->Text().GetThickness() ).c_str(),
|
|
fmtDEG( me->Text().GetOrientation() ).c_str(),
|
|
me->Text().IsMirrored() ? 0 : 1 // strange but true
|
|
);
|
|
|
|
fprintf( m_fp, "Sb %d %s %s %s\n", S_SEGMENT,
|
|
fmtBIUPair( me->m_crossBarO.x, me->m_crossBarO.y ).c_str(),
|
|
fmtBIUPair( me->m_crossBarF.x, me->m_crossBarF.y ).c_str(),
|
|
fmtBIU( me->GetWidth() ).c_str() );
|
|
|
|
fprintf( m_fp, "Sd %d %s %s %s\n", S_SEGMENT,
|
|
fmtBIUPair( me->m_featureLineDO.x, me->m_featureLineDO.y ).c_str(),
|
|
fmtBIUPair( me->m_featureLineDF.x, me->m_featureLineDF.y ).c_str(),
|
|
fmtBIU( me->GetWidth() ).c_str() );
|
|
|
|
fprintf( m_fp, "Sg %d %s %s %s\n", S_SEGMENT,
|
|
fmtBIUPair( me->m_featureLineGO.x, me->m_featureLineGO.y ).c_str(),
|
|
fmtBIUPair( me->m_featureLineGF.x, me->m_featureLineGF.y ).c_str(),
|
|
fmtBIU( me->GetWidth() ).c_str() );
|
|
|
|
fprintf( m_fp, "S1 %d %s %s %s\n", S_SEGMENT,
|
|
fmtBIUPair( me->m_crossBarF.x, me->m_crossBarF.y ).c_str(),
|
|
fmtBIUPair( me->m_arrowD1F.x, me->m_arrowD1F.y ).c_str(),
|
|
fmtBIU( me->GetWidth() ).c_str() );
|
|
|
|
fprintf( m_fp, "S2 %d %s %s %s\n", S_SEGMENT,
|
|
fmtBIUPair( me->m_crossBarF.x, me->m_crossBarF.y ).c_str(),
|
|
fmtBIUPair( me->m_arrowD2F.x, me->m_arrowD2F.y ).c_str(),
|
|
fmtBIU( me->GetWidth() ).c_str() );
|
|
|
|
fprintf( m_fp, "S3 %d %s %s %s\n", S_SEGMENT,
|
|
fmtBIUPair( me->m_crossBarO.x, me->m_crossBarO.y ).c_str(),
|
|
fmtBIUPair( me->m_arrowG1F.x, me->m_arrowG1F.y ).c_str(),
|
|
fmtBIU( me->GetWidth() ).c_str() );
|
|
|
|
fprintf( m_fp, "S4 %d %s %s %s\n", S_SEGMENT,
|
|
fmtBIUPair( me->m_crossBarO.x, me->m_crossBarO.y ).c_str(),
|
|
fmtBIUPair( me->m_arrowG2F.x, me->m_arrowG2F.y ).c_str(),
|
|
fmtBIU( me->GetWidth() ).c_str() );
|
|
|
|
fprintf( m_fp, "$endCOTATION\n" );
|
|
|
|
CHECK_WRITE_ERROR();
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::savePCB_TEXT( const TEXTE_PCB* me ) const
|
|
{
|
|
if( me->GetText().IsEmpty() )
|
|
return;
|
|
|
|
fprintf( m_fp, "$TEXTPCB\n" );
|
|
|
|
wxArrayString* list = wxStringSplit( me->GetText(), '\n' );
|
|
|
|
for( unsigned ii = 0; ii < list->Count(); ii++ )
|
|
{
|
|
wxString txt = list->Item( ii );
|
|
|
|
if ( ii == 0 )
|
|
fprintf( m_fp, "Te %s\n", EscapedUTF8( txt ).c_str() );
|
|
else
|
|
fprintf( m_fp, "nl %s\n", EscapedUTF8( txt ).c_str() );
|
|
}
|
|
|
|
delete list;
|
|
|
|
fprintf( m_fp, "Po %s %s %s %s\n",
|
|
fmtBIUPoint( me->GetTextPosition() ).c_str(),
|
|
fmtBIUSize( me->GetSize() ).c_str(),
|
|
fmtBIU( me->GetThickness() ).c_str(),
|
|
fmtDEG( me->GetOrientation() ).c_str() );
|
|
|
|
fprintf( m_fp, "De %d %d %lX %s",
|
|
me->GetLayer(),
|
|
!me->IsMirrored(),
|
|
me->GetTimeStamp(),
|
|
me->IsItalic() ? "Italic" : "Normal" );
|
|
|
|
if( me->GetHorizJustify() != GR_TEXT_HJUSTIFY_CENTER ||
|
|
me->GetVertJustify() != GR_TEXT_VJUSTIFY_CENTER )
|
|
{
|
|
fprintf( m_fp, " %s %s\n",
|
|
ShowHorizJustify( me->GetHorizJustify() ),
|
|
ShowVertJustify( me->GetVertJustify() )
|
|
);
|
|
}
|
|
else
|
|
fprintf( m_fp, "\n" );
|
|
|
|
fprintf( m_fp, "$EndTEXTPCB\n" );
|
|
}
|
|
|
|
#endif // NO LEGACY_PLUGIN::Save()
|
|
|
|
|
|
//-----<FOOTPRINT LIBRARY FUNCTIONS>--------------------------------------------
|
|
|
|
/*
|
|
|
|
The legacy file format is being obsoleted and this code will have a short
|
|
lifetime, so it only needs to be good enough for a short duration of time.
|
|
Caching all the MODULEs is a bit memory intensive, but it is a considerably
|
|
faster way of fulfilling the API contract. Otherwise, without the cache, you
|
|
would have to re-read the file when searching for any MODULE, and this would
|
|
be very problematic filling a FOOTPRINT_LIST via this PLUGIN API. If memory
|
|
becomes a concern, consider the cache lifetime policy, which determines the
|
|
time that a LP_CACHE is in RAM. Note PLUGIN lifetime also plays a role in
|
|
cache lifetime.
|
|
|
|
*/
|
|
|
|
|
|
#include <boost/ptr_container/ptr_map.hpp>
|
|
#include <wx/filename.h>
|
|
|
|
typedef boost::ptr_map< std::string, MODULE > MODULE_MAP;
|
|
typedef MODULE_MAP::iterator MODULE_ITER;
|
|
typedef MODULE_MAP::const_iterator MODULE_CITER;
|
|
|
|
|
|
/**
|
|
* Class LP_CACHE
|
|
* assists only for the footprint portion of the PLUGIN API, and only for the
|
|
* LEGACY_PLUGIN, so therefore is private to this implementation file, i.e. not placed
|
|
* into a header.
|
|
*/
|
|
struct LP_CACHE
|
|
{
|
|
LEGACY_PLUGIN* m_owner; // my owner, I need its LEGACY_PLUGIN::loadMODULE()
|
|
wxString m_lib_path;
|
|
wxDateTime m_mod_time;
|
|
MODULE_MAP m_modules; // map or tuple of footprint_name vs. MODULE*
|
|
bool m_writable;
|
|
|
|
LP_CACHE( LEGACY_PLUGIN* aOwner, const wxString& aLibraryPath );
|
|
|
|
// Most all functions in this class throw IO_ERROR exceptions. There are no
|
|
// error codes nor user interface calls from here, nor in any PLUGIN.
|
|
// Catch these exceptions higher up please.
|
|
|
|
/// save the entire legacy library to m_lib_path;
|
|
void Save();
|
|
|
|
void SaveHeader( FILE* aFile );
|
|
|
|
void SaveIndex( FILE* aFile );
|
|
|
|
void SaveModules( FILE* aFile );
|
|
|
|
void SaveEndOfFile( FILE* aFile )
|
|
{
|
|
fprintf( aFile, "$EndLIBRARY\n" );
|
|
}
|
|
|
|
void Load();
|
|
|
|
void ReadAndVerifyHeader( LINE_READER* aReader );
|
|
|
|
void SkipIndex( LINE_READER* aReader );
|
|
|
|
void LoadModules( LINE_READER* aReader );
|
|
|
|
wxDateTime GetLibModificationTime();
|
|
};
|
|
|
|
|
|
LP_CACHE::LP_CACHE( LEGACY_PLUGIN* aOwner, const wxString& aLibraryPath ) :
|
|
m_owner( aOwner ),
|
|
m_lib_path( aLibraryPath ),
|
|
m_writable( true )
|
|
{
|
|
}
|
|
|
|
|
|
wxDateTime LP_CACHE::GetLibModificationTime()
|
|
{
|
|
wxFileName fn( m_lib_path );
|
|
|
|
// update the writable flag while we have a wxFileName, in a network this
|
|
// is possibly quite dynamic anyway.
|
|
m_writable = fn.IsFileWritable();
|
|
|
|
return fn.GetModificationTime();
|
|
}
|
|
|
|
|
|
void LP_CACHE::Load()
|
|
{
|
|
FILE_LINE_READER reader( m_lib_path );
|
|
|
|
ReadAndVerifyHeader( &reader );
|
|
SkipIndex( &reader );
|
|
LoadModules( &reader );
|
|
|
|
// Remember the file modification time of library file when the
|
|
// cache snapshot was made, so that in a networked environment we will
|
|
// reload the cache as needed.
|
|
m_mod_time = GetLibModificationTime();
|
|
}
|
|
|
|
|
|
void LP_CACHE::ReadAndVerifyHeader( LINE_READER* aReader )
|
|
{
|
|
char* line = aReader->ReadLine();
|
|
char* saveptr;
|
|
|
|
if( !line )
|
|
goto L_bad_library;
|
|
|
|
if( !TESTLINE( "PCBNEW-LibModule-V1" ) )
|
|
goto L_bad_library;
|
|
|
|
while( ( line = aReader->ReadLine() ) != NULL )
|
|
{
|
|
if( TESTLINE( "Units" ) )
|
|
{
|
|
const char* units = strtok_r( line + SZ( "Units" ), delims, &saveptr );
|
|
|
|
if( !strcmp( units, "mm" ) )
|
|
{
|
|
m_owner->diskToBiu = IU_PER_MM;
|
|
}
|
|
|
|
}
|
|
else if( TESTLINE( "$INDEX" ) )
|
|
return;
|
|
}
|
|
|
|
L_bad_library:
|
|
THROW_IO_ERROR( wxString::Format( _( "File '%s' is empty or is not a legacy library" ),
|
|
m_lib_path.GetData() ) );
|
|
}
|
|
|
|
|
|
void LP_CACHE::SkipIndex( LINE_READER* aReader )
|
|
{
|
|
// Some broken INDEX sections have more than one section, due to prior bugs.
|
|
// So we must read the next line after $EndINDEX tag,
|
|
// to see if this is not a new $INDEX tag.
|
|
bool exit = false;
|
|
char* line = aReader->Line();
|
|
|
|
do
|
|
{
|
|
if( TESTLINE( "$INDEX" ) )
|
|
{
|
|
exit = false;
|
|
|
|
while( ( line = aReader->ReadLine() ) != NULL )
|
|
{
|
|
if( TESTLINE( "$EndINDEX" ) )
|
|
{
|
|
exit = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else if( exit )
|
|
break;
|
|
} while( ( line = aReader->ReadLine() ) != NULL );
|
|
}
|
|
|
|
|
|
void LP_CACHE::LoadModules( LINE_READER* aReader )
|
|
{
|
|
m_owner->SetReader( aReader );
|
|
|
|
char* line = aReader->Line();
|
|
|
|
do
|
|
{
|
|
// test first for the $MODULE, even before reading because of INDEX bug.
|
|
if( TESTLINE( "$MODULE" ) )
|
|
{
|
|
auto_ptr<MODULE> module( new MODULE( m_owner->m_board ) );
|
|
|
|
std::string footprintName = StrPurge( line + SZ( "$MODULE" ) );
|
|
|
|
// The footprint names in legacy libraries can contain the '/' and ':'
|
|
// characters which will cause the FPID parser to choke.
|
|
ReplaceIllegalFileNameChars( &footprintName );
|
|
|
|
// set the footprint name first thing, so exceptions can use name.
|
|
module->SetFPID( FPID( footprintName ) );
|
|
|
|
#if 0 && defined( DEBUG )
|
|
printf( "%s\n", footprintName.c_str() );
|
|
if( footprintName == "QFN40" )
|
|
{
|
|
int breakhere = 1;
|
|
(void) breakhere;
|
|
}
|
|
#endif
|
|
|
|
m_owner->loadMODULE( module.get() );
|
|
|
|
MODULE* m = module.release(); // exceptions after this are not expected.
|
|
|
|
// Not sure why this is asserting on debug builds. The debugger shows the
|
|
// strings are the same. If it's not really needed maybe it can be removed.
|
|
// wxASSERT( footprintName == m->GetFPID().GetFootprintName() );
|
|
|
|
/*
|
|
|
|
There was a bug in old legacy library management code
|
|
(pre-LEGACY_PLUGIN) which was introducing duplicate footprint names
|
|
in legacy libraries without notification. To best recover from such
|
|
bad libraries, and use them to their fullest, there are a few
|
|
strategies that could be used. (Note: footprints must have unique
|
|
names to be accepted into this cache.) The strategy used here is to
|
|
append a differentiating version counter to the end of the name as:
|
|
_v2, _v3, etc.
|
|
|
|
*/
|
|
|
|
MODULE_CITER it = m_modules.find( footprintName );
|
|
|
|
if( it == m_modules.end() ) // footprintName is not present in cache yet.
|
|
{
|
|
std::pair<MODULE_ITER, bool> r = m_modules.insert( footprintName, m );
|
|
|
|
wxASSERT_MSG( r.second, wxT( "error doing cache insert using guaranteed unique name" ) );
|
|
(void) r;
|
|
}
|
|
|
|
// Bad library has a duplicate of this footprintName, generate a
|
|
// unique footprint name and load it anyway.
|
|
else
|
|
{
|
|
bool nameOK = false;
|
|
int version = 2;
|
|
char buf[48];
|
|
|
|
while( !nameOK )
|
|
{
|
|
std::string newName = footprintName;
|
|
|
|
newName += "_v";
|
|
sprintf( buf, "%d", version++ );
|
|
newName += buf;
|
|
|
|
it = m_modules.find( newName );
|
|
|
|
if( it == m_modules.end() )
|
|
{
|
|
nameOK = true;
|
|
|
|
m->SetFPID( FPID( newName ) );
|
|
std::pair<MODULE_ITER, bool> r = m_modules.insert( newName, m );
|
|
|
|
wxASSERT_MSG( r.second, wxT( "error doing cache insert using guaranteed unique name" ) );
|
|
(void) r;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
} while( ( line = aReader->ReadLine() ) != NULL );
|
|
}
|
|
|
|
|
|
#if 0
|
|
void LP_CACHE::Save()
|
|
{
|
|
if( !m_writable )
|
|
{
|
|
THROW_IO_ERROR( wxString::Format(
|
|
_( "Legacy library file '%s' is read only" ), m_lib_path.GetData() ) );
|
|
}
|
|
|
|
wxString tempFileName;
|
|
|
|
// a block {} scope to fire wxFFile wxf()'s destructor
|
|
{
|
|
// CreateTempFileName works better with an absolute path
|
|
wxFileName abs_lib_name( m_lib_path );
|
|
|
|
abs_lib_name.MakeAbsolute();
|
|
tempFileName = wxFileName::CreateTempFileName( abs_lib_name.GetFullPath() );
|
|
|
|
//wxLogDebug( wxT( "tempFileName:'%s' m_lib_path:'%s'\n" ), TO_UTF8( tempFileName ), TO_UTF8( m_lib_path ) );
|
|
|
|
FILE* fp = wxFopen( tempFileName, wxT( "w" ) );
|
|
if( !fp )
|
|
{
|
|
THROW_IO_ERROR( wxString::Format(
|
|
_( "Unable to open or create legacy library file '%s'" ),
|
|
m_lib_path.GetData() ) );
|
|
}
|
|
|
|
// wxf now owns fp, will close on exception or exit from
|
|
// this block {} scope
|
|
wxFFile wxf( fp );
|
|
|
|
SaveHeader( fp );
|
|
SaveIndex( fp );
|
|
SaveModules( fp );
|
|
SaveEndOfFile( fp );
|
|
}
|
|
|
|
// fp is now closed here, and that seems proper before trying to rename
|
|
// the temporary file to m_lib_path.
|
|
|
|
wxRemove( m_lib_path ); // it is not an error if this does not exist
|
|
|
|
// Even on linux you can see an _intermittent_ error when calling wxRename(),
|
|
// and it is fully inexplicable. See if this dodges the error.
|
|
wxMilliSleep( 250L );
|
|
|
|
if( !wxRenameFile( tempFileName, m_lib_path ) )
|
|
{
|
|
THROW_IO_ERROR( wxString::Format(
|
|
_( "Unable to rename tempfile '%s' to library file '%s'" ),
|
|
tempFileName.GetData(),
|
|
m_lib_path.GetData() ) );
|
|
}
|
|
}
|
|
|
|
|
|
void LP_CACHE::SaveHeader( FILE* aFile )
|
|
{
|
|
fprintf( aFile, "%s %s\n", FOOTPRINT_LIBRARY_HEADER, TO_UTF8( DateAndTime() ) );
|
|
fprintf( aFile, "# encoding utf-8\n" );
|
|
fprintf( aFile, "Units mm\n" );
|
|
}
|
|
|
|
|
|
void LP_CACHE::SaveIndex( FILE* aFile )
|
|
{
|
|
fprintf( aFile, "$INDEX\n" );
|
|
|
|
for( MODULE_CITER it = m_modules.begin(); it != m_modules.end(); ++it )
|
|
{
|
|
fprintf( aFile, "%s\n", it->first.c_str() );
|
|
}
|
|
|
|
fprintf( aFile, "$EndINDEX\n" );
|
|
}
|
|
|
|
|
|
void LP_CACHE::SaveModules( FILE* aFile )
|
|
{
|
|
m_owner->SetFilePtr( aFile );
|
|
|
|
for( MODULE_CITER it = m_modules.begin(); it != m_modules.end(); ++it )
|
|
{
|
|
m_owner->saveMODULE( it->second );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void LEGACY_PLUGIN::cacheLib( const wxString& aLibraryPath )
|
|
{
|
|
if( !m_cache || m_cache->m_lib_path != aLibraryPath ||
|
|
// somebody else on a network touched the library:
|
|
m_cache->m_mod_time != m_cache->GetLibModificationTime() )
|
|
{
|
|
// a spectacular episode in memory management:
|
|
delete m_cache;
|
|
m_cache = new LP_CACHE( this, aLibraryPath );
|
|
m_cache->Load();
|
|
}
|
|
}
|
|
|
|
|
|
wxArrayString LEGACY_PLUGIN::FootprintEnumerate( const wxString& aLibraryPath, const PROPERTIES* aProperties )
|
|
{
|
|
LOCALE_IO toggle; // toggles on, then off, the C locale.
|
|
|
|
init( aProperties );
|
|
|
|
cacheLib( aLibraryPath );
|
|
|
|
const MODULE_MAP& mods = m_cache->m_modules;
|
|
|
|
wxArrayString ret;
|
|
|
|
for( MODULE_CITER it = mods.begin(); it != mods.end(); ++it )
|
|
{
|
|
ret.Add( FROM_UTF8( it->first.c_str() ) );
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
MODULE* LEGACY_PLUGIN::FootprintLoad( const wxString& aLibraryPath,
|
|
const wxString& aFootprintName, const PROPERTIES* aProperties )
|
|
{
|
|
LOCALE_IO toggle; // toggles on, then off, the C locale.
|
|
|
|
init( aProperties );
|
|
|
|
cacheLib( aLibraryPath );
|
|
|
|
const MODULE_MAP& mods = m_cache->m_modules;
|
|
|
|
MODULE_CITER it = mods.find( TO_UTF8( aFootprintName ) );
|
|
|
|
if( it == mods.end() )
|
|
{
|
|
/*
|
|
THROW_IO_ERROR( wxString::Format( _( "No '%s' footprint in library '%s'" ),
|
|
aFootprintName.GetData(), aLibraryPath.GetData() ) );
|
|
*/
|
|
|
|
return NULL;
|
|
}
|
|
|
|
// copy constructor to clone the already loaded MODULE
|
|
return new MODULE( *it->second );
|
|
}
|
|
|
|
|
|
#if 0 // omit FootprintSave()
|
|
|
|
void LEGACY_PLUGIN::FootprintSave( const wxString& aLibraryPath,
|
|
const MODULE* aFootprint, const PROPERTIES* aProperties )
|
|
{
|
|
LOCALE_IO toggle; // toggles on, then off, the C locale.
|
|
|
|
init( aProperties );
|
|
|
|
cacheLib( aLibraryPath );
|
|
|
|
if( !m_cache->m_writable )
|
|
{
|
|
THROW_IO_ERROR( wxString::Format( _( "Library '%s' is read only" ), aLibraryPath.GetData() ) );
|
|
}
|
|
|
|
std::string footprintName = aFootprint->GetFPID().GetFootprintName();
|
|
|
|
MODULE_MAP& mods = m_cache->m_modules;
|
|
|
|
// quietly overwrite any by same name.
|
|
MODULE_CITER it = mods.find( footprintName );
|
|
if( it != mods.end() )
|
|
{
|
|
mods.erase( footprintName );
|
|
}
|
|
|
|
// I need my own copy for the cache
|
|
MODULE* my_module = new MODULE( *aFootprint );
|
|
|
|
// and it's time stamp must be 0, it should have no parent, orientation should
|
|
// be zero, and it should be on the front layer.
|
|
|
|
my_module->SetTimeStamp( 0 );
|
|
my_module->SetParent( 0 );
|
|
|
|
my_module->SetOrientation( 0 );
|
|
|
|
if( my_module->GetLayer() != F_Cu )
|
|
my_module->Flip( my_module->GetPosition() );
|
|
|
|
mods.insert( footprintName, my_module );
|
|
|
|
m_cache->Save();
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::FootprintDelete( const wxString& aLibraryPath,
|
|
const wxString& aFootprintName, const PROPERTIES* aProperties )
|
|
{
|
|
LOCALE_IO toggle; // toggles on, then off, the C locale.
|
|
|
|
init( NULL );
|
|
|
|
cacheLib( aLibraryPath );
|
|
|
|
if( !m_cache->m_writable )
|
|
{
|
|
THROW_IO_ERROR( wxString::Format( _( "Library '%s' is read only" ), aLibraryPath.GetData() ) );
|
|
}
|
|
|
|
std::string footprintName = TO_UTF8( aFootprintName );
|
|
|
|
size_t erasedCount = m_cache->m_modules.erase( footprintName );
|
|
|
|
if( erasedCount != 1 )
|
|
{
|
|
THROW_IO_ERROR( wxString::Format(
|
|
_( "library '%s' has no footprint '%s' to delete" ),
|
|
aLibraryPath.GetData(), aFootprintName.GetData() ) );
|
|
}
|
|
|
|
m_cache->Save();
|
|
}
|
|
|
|
|
|
void LEGACY_PLUGIN::FootprintLibCreate( const wxString& aLibraryPath, const PROPERTIES* aProperties )
|
|
{
|
|
if( wxFileExists( aLibraryPath ) )
|
|
{
|
|
THROW_IO_ERROR( wxString::Format(
|
|
_( "library '%s' already exists, will not create a new" ),
|
|
aLibraryPath.GetData() ) );
|
|
}
|
|
|
|
LOCALE_IO toggle;
|
|
|
|
init( NULL );
|
|
|
|
delete m_cache;
|
|
m_cache = new LP_CACHE( this, aLibraryPath );
|
|
m_cache->Save();
|
|
m_cache->Load(); // update m_writable and m_mod_time
|
|
}
|
|
|
|
#endif // omit FootprintSave()
|
|
|
|
|
|
bool LEGACY_PLUGIN::FootprintLibDelete( const wxString& aLibraryPath, const PROPERTIES* aProperties )
|
|
{
|
|
wxFileName fn = aLibraryPath;
|
|
|
|
if( !fn.FileExists() )
|
|
return false;
|
|
|
|
// Some of the more elaborate wxRemoveFile() crap puts up its own wxLog dialog
|
|
// we don't want that. we want bare metal portability with no UI here.
|
|
if( wxRemove( aLibraryPath ) )
|
|
{
|
|
THROW_IO_ERROR( wxString::Format(
|
|
_( "library '%s' cannot be deleted" ),
|
|
aLibraryPath.GetData() ) );
|
|
}
|
|
|
|
if( m_cache && m_cache->m_lib_path == aLibraryPath )
|
|
{
|
|
delete m_cache;
|
|
m_cache = 0;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool LEGACY_PLUGIN::IsFootprintLibWritable( const wxString& aLibraryPath )
|
|
{
|
|
#if 0 // no support for 32 Cu layers in legacy format
|
|
return false;
|
|
#else
|
|
LOCALE_IO toggle;
|
|
|
|
init( NULL );
|
|
|
|
cacheLib( aLibraryPath );
|
|
|
|
return m_cache->m_writable;
|
|
#endif
|
|
}
|
|
|
|
|
|
LEGACY_PLUGIN::LEGACY_PLUGIN() :
|
|
m_cu_count( 16 ), // for FootprintLoad()
|
|
m_board( 0 ),
|
|
m_props( 0 ),
|
|
m_reader( 0 ),
|
|
m_fp( 0 ),
|
|
m_cache( 0 ),
|
|
m_mapping( new NETINFO_MAPPING() )
|
|
{
|
|
init( NULL );
|
|
}
|
|
|
|
|
|
LEGACY_PLUGIN::~LEGACY_PLUGIN()
|
|
{
|
|
delete m_cache;
|
|
delete m_mapping;
|
|
}
|