640 lines
17 KiB
C++
640 lines
17 KiB
C++
/**********************************************************/
|
|
/* libclass.cpp */
|
|
/**********************************************************/
|
|
|
|
#include "fctsys.h"
|
|
#include "gr_basic.h"
|
|
#include "common.h"
|
|
#include "kicad_string.h"
|
|
#include "confirm.h"
|
|
#include "gestfich.h"
|
|
#include "eda_doc.h"
|
|
|
|
#include "program.h"
|
|
#include "libcmp.h"
|
|
#include "general.h"
|
|
#include "protos.h"
|
|
#include "class_library.h"
|
|
|
|
#include <boost/foreach.hpp>
|
|
|
|
|
|
bool operator==( const LibraryStruct& lib, const wxChar* name )
|
|
{
|
|
return lib.m_Name.CmpNoCase( name ) == 0;
|
|
}
|
|
|
|
|
|
bool operator!=( const LibraryStruct& lib, const wxChar* name )
|
|
{
|
|
return !( lib == name );
|
|
}
|
|
|
|
|
|
LibraryStruct::LibraryStruct( int type, const wxString& name,
|
|
const wxString& fullname )
|
|
{
|
|
m_Type = type; /* type indicator */
|
|
m_Name = name; /* Name of library loaded. */
|
|
m_FullFileName = fullname; /* File name (with path) of library loaded. */
|
|
m_Pnext = NULL; /* Point to next library in chain. */
|
|
m_IsModified = false; /* flag indicateur d'edition */
|
|
m_TimeStamp = 0;
|
|
m_Flags = 0;
|
|
m_IsLibCache = false;
|
|
m_DateTime = wxDateTime::Now();
|
|
}
|
|
|
|
|
|
LibraryStruct::LibraryStruct( const wxChar* fileName )
|
|
{
|
|
if( fileName == NULL )
|
|
m_fileName = wxT( "unnamed.lib" );
|
|
else
|
|
m_fileName = fileName;
|
|
}
|
|
|
|
|
|
LibraryStruct::~LibraryStruct()
|
|
{
|
|
}
|
|
|
|
|
|
void LibraryStruct::GetEntryNames( wxArrayString& names, bool sort,
|
|
bool makeUpperCase )
|
|
{
|
|
BOOST_FOREACH( LibCmpEntry& entry, m_Entries )
|
|
{
|
|
if( makeUpperCase )
|
|
names.Add( entry.m_Name.m_Text.MakeUpper() );
|
|
else
|
|
names.Add( entry.m_Name.m_Text );
|
|
}
|
|
|
|
if( sort )
|
|
names.Sort();
|
|
}
|
|
|
|
|
|
void LibraryStruct::SearchEntryNames( wxArrayString& names,
|
|
const wxString& nameSearch,
|
|
const wxString& keySearch,
|
|
bool sort )
|
|
{
|
|
BOOST_FOREACH( LibCmpEntry& entry, m_Entries )
|
|
{
|
|
if( !keySearch.IsEmpty() && KeyWordOk( keySearch, entry.m_KeyWord ) )
|
|
names.Add( entry.m_Name.m_Text );
|
|
if( !nameSearch.IsEmpty() && WildCompareString( nameSearch,
|
|
entry.m_Name.m_Text,
|
|
false ) )
|
|
names.Add( entry.m_Name.m_Text );
|
|
}
|
|
|
|
if( sort )
|
|
names.Sort();
|
|
}
|
|
|
|
|
|
LibCmpEntry* LibraryStruct::FindEntry( const wxChar* name )
|
|
{
|
|
BOOST_FOREACH( LibCmpEntry& entry, m_Entries )
|
|
{
|
|
if( entry.m_Name.m_Text.CmpNoCase( name ) == 0 )
|
|
return &entry;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
LibCmpEntry* LibraryStruct::FindEntry( const wxChar* name, LibrEntryType type )
|
|
{
|
|
LibCmpEntry* entry = FindEntry( name );
|
|
|
|
if( entry && entry->Type != ROOT && type == ROOT )
|
|
{
|
|
EDA_LibCmpAliasStruct* alias = ( EDA_LibCmpAliasStruct* ) entry;
|
|
|
|
entry = FindEntry( alias->m_RootName );
|
|
|
|
if( entry && entry->Type != ROOT )
|
|
return NULL;
|
|
}
|
|
|
|
return entry;
|
|
}
|
|
|
|
|
|
EDA_LibComponentStruct* LibraryStruct::AddComponent( EDA_LibComponentStruct* cmp )
|
|
{
|
|
wxASSERT( cmp != NULL );
|
|
|
|
EDA_LibCmpAliasStruct* Alias;
|
|
EDA_LibComponentStruct* newCmp = CopyLibEntryStruct( cmp );
|
|
|
|
if( newCmp == NULL )
|
|
return NULL;
|
|
|
|
newCmp->m_AliasList.Clear();
|
|
m_Entries.push_back( (LibCmpEntry*) newCmp );
|
|
m_IsModified = true;
|
|
|
|
for( unsigned ii = 0; ii < cmp->m_AliasList.GetCount(); ii += ALIAS_NEXT )
|
|
{
|
|
wxString aliasname = cmp->m_AliasList[ii + ALIAS_NAME];
|
|
newCmp->m_AliasList.Add( aliasname );
|
|
Alias = new EDA_LibCmpAliasStruct( aliasname, newCmp->m_Name.m_Text );
|
|
Alias->m_Doc = cmp->m_AliasList[ii + ALIAS_DOC];
|
|
Alias->m_KeyWord = cmp->m_AliasList[ii + ALIAS_KEYWORD];
|
|
Alias->m_DocFile = cmp->m_AliasList[ii + ALIAS_DOC_FILENAME];
|
|
m_Entries.push_back( (LibCmpEntry *) Alias );
|
|
}
|
|
|
|
m_Entries.sort();
|
|
|
|
return newCmp;
|
|
}
|
|
|
|
|
|
void LibraryStruct::RemoveEntry( const wxString& name )
|
|
{
|
|
LIB_ENTRY_LIST::iterator i;
|
|
|
|
for( i = m_Entries.begin(); i < m_Entries.end(); i++ )
|
|
{
|
|
if( i->m_Name.m_Text.CmpNoCase( name ) == 0 )
|
|
{
|
|
m_Entries.erase( i );
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void LibraryStruct::RemoveEntry( LibCmpEntry* entry )
|
|
{
|
|
wxASSERT( entry != NULL );
|
|
|
|
EDA_LibComponentStruct* Root;
|
|
EDA_LibCmpAliasStruct* Alias;
|
|
|
|
m_IsModified = true;
|
|
|
|
if( entry->Type == ALIAS )
|
|
{
|
|
Alias = (EDA_LibCmpAliasStruct*) entry;
|
|
Root = ( EDA_LibComponentStruct* ) FindEntry( Alias->m_RootName, ROOT );
|
|
|
|
/* Remove alias name from the root component alias list */
|
|
if( Root == NULL )
|
|
{
|
|
wxLogWarning( wxT( "No root component found for alias <%s> in \
|
|
library <%s>." ),
|
|
( const wxChar* ) entry->m_Name.m_Text,
|
|
( const wxChar* ) m_Name );
|
|
}
|
|
else
|
|
{
|
|
int index = Root->m_AliasList.Index( entry->m_Name.m_Text, false );
|
|
|
|
if( index == wxNOT_FOUND )
|
|
wxLogWarning( wxT( "Alias <%s> not found in component <%s> \
|
|
alias list in library <%s>" ),
|
|
( const wxChar* ) entry->m_Name.m_Text,
|
|
( const wxChar* ) Root->m_Name.m_Text,
|
|
( const wxChar* ) m_Name );
|
|
else
|
|
Root->m_AliasList.RemoveAt( index );
|
|
}
|
|
|
|
RemoveEntry( Alias->m_Name.m_Text );
|
|
|
|
return;
|
|
}
|
|
|
|
Root = ( EDA_LibComponentStruct* ) entry;
|
|
|
|
/* Entry is a component with no aliases so removal is simple. */
|
|
if( Root->m_AliasList.GetCount() == 0 )
|
|
{
|
|
RemoveEntry( Root->m_Name.m_Text );
|
|
return;
|
|
}
|
|
|
|
/* Entry is a component with one or more alias. */
|
|
wxString AliasName = Root->m_AliasList[0];
|
|
|
|
/* The root component is not really deleted, it is renamed with the first
|
|
* alias name. */
|
|
Alias = (EDA_LibCmpAliasStruct*) FindEntry( AliasName, ALIAS );
|
|
|
|
if( Alias == NULL || Alias->Type == ROOT )
|
|
{
|
|
wxLogWarning( wxT( "Alias <%s> for component <%s> not found in \
|
|
library <%s>" ),
|
|
( const wxChar* ) AliasName,
|
|
( const wxChar* ) Root->m_Name.m_Text,
|
|
( const wxChar* ) m_Name );
|
|
return;
|
|
}
|
|
|
|
/* Remove the first alias name from the component alias list. */
|
|
Root->m_AliasList.RemoveAt( 0 );
|
|
|
|
/* Rename the component to the name of the first alias. */
|
|
Root->m_Doc = Alias->m_Doc;
|
|
Root->m_KeyWord = Alias->m_KeyWord;
|
|
|
|
/* Remove the first alias from library. */
|
|
RemoveEntry( AliasName );
|
|
|
|
Root->m_Name.m_Text = AliasName;
|
|
|
|
/* Change the "RootName" for all other aliases */
|
|
for( size_t ii = 0; ii < Root->m_AliasList.GetCount(); ii++ )
|
|
{
|
|
Alias = (EDA_LibCmpAliasStruct*) FindEntry( Root->m_AliasList[ii],
|
|
ALIAS );
|
|
|
|
/* Should not occur if library was saved by the library editor.
|
|
* However, it is possible if the library was edited by hand or
|
|
* some other program or a there is a bug in the library editor. */
|
|
if( Alias == NULL || Alias->Type != ALIAS )
|
|
{
|
|
wxLogWarning( wxT( "Alias <%s> for component <%s> not found in \
|
|
library <%s>." ),
|
|
( const wxChar* ) AliasName,
|
|
( const wxChar* ) Root->m_Name.m_Text,
|
|
( const wxChar* ) m_Name );
|
|
continue;
|
|
}
|
|
|
|
Alias->m_RootName = Root->m_Name.m_Text;
|
|
}
|
|
}
|
|
|
|
|
|
LibCmpEntry* LibraryStruct::GetNextEntry( const wxChar* name )
|
|
{
|
|
size_t i;
|
|
LibCmpEntry* entry = NULL;
|
|
|
|
for( i = 0; i < m_Entries.size(); i++ )
|
|
{
|
|
if( m_Entries[i].m_Name.m_Text.CmpNoCase( name ) == 0 )
|
|
{
|
|
if( i < m_Entries.size() - 1 )
|
|
{
|
|
entry = &m_Entries[ i + 1 ];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( entry == NULL )
|
|
entry = &m_Entries.front();
|
|
|
|
return entry;
|
|
}
|
|
|
|
|
|
LibCmpEntry* LibraryStruct::GetPreviousEntry( const wxChar* name )
|
|
{
|
|
size_t i;
|
|
LibCmpEntry* entry = NULL;
|
|
|
|
for( i = 0; i < m_Entries.size(); i++ )
|
|
{
|
|
if( m_Entries[i].m_Name.m_Text.CmpNoCase( name ) == 0 && entry )
|
|
break;
|
|
|
|
entry = &m_Entries[i];
|
|
}
|
|
|
|
return entry;
|
|
}
|
|
|
|
|
|
bool LibraryStruct::Load( wxString& errMsg )
|
|
{
|
|
FILE* f;
|
|
int LineNum = 0;
|
|
char Line[1024];
|
|
EDA_LibComponentStruct* LibEntry;
|
|
wxString msg;
|
|
|
|
if( m_FullFileName.IsEmpty() )
|
|
{
|
|
errMsg = _( "library file name not set" );
|
|
return false;
|
|
}
|
|
|
|
f = wxFopen( m_FullFileName, wxT( "rt" ) );
|
|
|
|
if( f == NULL )
|
|
{
|
|
errMsg = _( "could not open file" );
|
|
return false;
|
|
}
|
|
|
|
if( GetLine( f, Line, &LineNum, sizeof( Line ) ) == NULL )
|
|
{
|
|
errMsg = _( "file is empty!" );
|
|
return false;
|
|
}
|
|
|
|
if( strnicmp( Line, LIBFILE_IDENT, 10 ) != 0 )
|
|
{
|
|
errMsg = _( "file is NOT an EESCHEMA library!" );
|
|
return false;
|
|
}
|
|
|
|
/* There is no header if this is a symbol library. */
|
|
if( m_Type == LIBRARY_TYPE_EESCHEMA )
|
|
m_Header = CONV_FROM_UTF8( Line );
|
|
|
|
while( GetLine( f, Line, &LineNum, sizeof( Line ) ) )
|
|
{
|
|
if( m_Type == LIBRARY_TYPE_EESCHEMA
|
|
&& strnicmp( Line, "$HEADER", 7 ) == 0 )
|
|
{
|
|
if( !LoadHeader( f, &LineNum ) )
|
|
{
|
|
errMsg = _( "header read error" );
|
|
return false;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if( strnicmp( Line, "DEF", 3 ) == 0 )
|
|
{
|
|
/* Read one DEF/ENDDEF part entry from library: */
|
|
LibEntry = new EDA_LibComponentStruct( NULL );
|
|
|
|
if( LibEntry->Load( f, Line, &LineNum, msg ) )
|
|
{
|
|
/* If we are here, this part is O.k. - put it in: */
|
|
m_Entries.push_back( LibEntry );
|
|
LoadAliases( LibEntry );
|
|
}
|
|
else
|
|
{
|
|
wxLogWarning( wxT( "Library <%s> component load error %s." ),
|
|
(const wxChar*) m_Name,
|
|
(const wxChar*) msg );
|
|
msg.Clear();
|
|
delete LibEntry;
|
|
}
|
|
}
|
|
}
|
|
|
|
m_Entries.sort();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void LibraryStruct::LoadAliases( EDA_LibComponentStruct* component )
|
|
{
|
|
wxASSERT( component != NULL );
|
|
|
|
EDA_LibCmpAliasStruct* AliasEntry;
|
|
unsigned ii;
|
|
|
|
for( ii = 0; ii < component->m_AliasList.GetCount(); ii++ )
|
|
{
|
|
AliasEntry =
|
|
new EDA_LibCmpAliasStruct( component->m_AliasList[ii],
|
|
component->m_Name.m_Text );
|
|
m_Entries.push_back( AliasEntry );
|
|
}
|
|
}
|
|
|
|
|
|
bool LibraryStruct::LoadHeader( FILE* libfile, int* LineNum )
|
|
{
|
|
char Line[1024], * text, * data;
|
|
|
|
while( GetLine( libfile, Line, LineNum, sizeof(Line) ) )
|
|
{
|
|
text = strtok( Line, " \t\r\n" );
|
|
data = strtok( NULL, " \t\r\n" );
|
|
if( stricmp( text, "TimeStamp" ) == 0 )
|
|
m_TimeStamp = atol( data );
|
|
if( stricmp( text, "$ENDHEADER" ) == 0 )
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
bool LibraryStruct::LoadDocs( wxString& errMsg )
|
|
{
|
|
int LineNum = 0;
|
|
char Line[1024], * Name, * Text;
|
|
LibCmpEntry* Entry;
|
|
FILE* f;
|
|
wxString msg;
|
|
wxFileName fn;
|
|
|
|
fn = m_FullFileName;
|
|
fn.SetExt( DOC_EXT );
|
|
|
|
f = wxFopen( fn.GetFullPath(), wxT( "rt" ) );
|
|
|
|
if( f == NULL )
|
|
{
|
|
errMsg.Printf( _( "Could not open component document libray file\n<%s>." ),
|
|
(const wxChar*) fn.GetFullPath() );
|
|
return false;
|
|
}
|
|
|
|
if( GetLine( f, Line, &LineNum, sizeof(Line) ) == NULL )
|
|
{
|
|
errMsg.Printf( _( "Component document libray file <%s> is empty." ),
|
|
(const wxChar*) fn.GetFullPath() );
|
|
fclose( f );
|
|
return false;
|
|
}
|
|
|
|
if( strnicmp( Line, DOCFILE_IDENT, 10 ) != 0 )
|
|
{
|
|
errMsg.Printf( _( "File <%s> is not a valid component library \
|
|
document file." ),
|
|
(const wxChar*) fn.GetFullPath() );
|
|
fclose( f );
|
|
return false;
|
|
}
|
|
|
|
while( GetLine( f, Line, &LineNum, sizeof(Line) ) )
|
|
{
|
|
if( strncmp( Line, "$CMP", 4 ) != 0 )
|
|
{
|
|
errMsg.Printf( wxT( "$CMP command expected in line %d, aborted." ),
|
|
LineNum );
|
|
fclose( f );
|
|
return false;
|
|
}
|
|
|
|
/* Read one $CMP/$ENDCMP part entry from library: */
|
|
Name = strtok( Line + 5, "\n\r" );
|
|
|
|
wxString cmpname = CONV_FROM_UTF8( Name );
|
|
|
|
Entry = FindEntry( cmpname, ALIAS );
|
|
|
|
while( GetLine( f, Line, &LineNum, sizeof(Line) ) )
|
|
{
|
|
if( strncmp( Line, "$ENDCMP", 7 ) == 0 )
|
|
break;
|
|
Text = strtok( Line + 2, "\n\r" );
|
|
|
|
switch( Line[0] )
|
|
{
|
|
case 'D':
|
|
if( Entry )
|
|
Entry->m_Doc = CONV_FROM_UTF8( Text );
|
|
break;
|
|
|
|
case 'K':
|
|
if( Entry )
|
|
Entry->m_KeyWord = CONV_FROM_UTF8( Text );
|
|
break;
|
|
|
|
case 'F':
|
|
if( Entry )
|
|
Entry->m_DocFile = CONV_FROM_UTF8( Text );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
fclose( f );
|
|
return true;
|
|
}
|
|
|
|
|
|
bool LibraryStruct::Save( const wxString& FullFileName )
|
|
{
|
|
FILE* libfile, *docfile;
|
|
wxString msg;
|
|
wxFileName libFileName = FullFileName;
|
|
wxFileName backupFileName = FullFileName;
|
|
wxFileName docFileName = FullFileName;
|
|
|
|
/* the old .lib file is renamed .bak */
|
|
if( libFileName.FileExists() )
|
|
{
|
|
backupFileName.SetExt( wxT( "bak" ) );
|
|
wxRemoveFile( backupFileName.GetFullPath() );
|
|
|
|
if( !wxRenameFile( libFileName.GetFullPath(),
|
|
backupFileName.GetFullPath() ) )
|
|
{
|
|
msg = wxT( "Failed to rename old lib file " ) +
|
|
backupFileName.GetFullPath();
|
|
DisplayError( NULL, msg );
|
|
}
|
|
}
|
|
|
|
docFileName.SetExt( DOC_EXT );
|
|
/* L'ancien fichier doc lib est renomme en .bck */
|
|
if( wxFileExists( docFileName.GetFullPath() ) )
|
|
{
|
|
backupFileName = docFileName;
|
|
backupFileName.SetExt( wxT( "bck" ) );
|
|
wxRemoveFile( backupFileName.GetFullPath() );
|
|
|
|
if( !wxRenameFile( docFileName.GetFullPath(),
|
|
backupFileName.GetFullPath() ) )
|
|
{
|
|
msg = wxT( "Failed to save old doc lib file " ) +
|
|
backupFileName.GetFullPath();
|
|
DisplayError( NULL, msg );
|
|
}
|
|
}
|
|
|
|
libfile = wxFopen( libFileName.GetFullPath(), wxT( "wt" ) );
|
|
|
|
if( libfile == NULL )
|
|
{
|
|
msg = wxT( "Failed to create Lib File " ) + libFileName.GetFullPath();
|
|
DisplayError( NULL, msg );
|
|
return false;
|
|
}
|
|
|
|
docfile = wxFopen( docFileName.GetFullPath(), wxT( "wt" ) );
|
|
|
|
if( docfile == NULL )
|
|
{
|
|
msg = wxT( "Failed to create DocLib File " ) +
|
|
docFileName.GetFullPath();
|
|
DisplayError( NULL, msg );
|
|
}
|
|
|
|
m_IsModified = false;
|
|
|
|
/* Creation de l'entete de la librairie */
|
|
m_TimeStamp = GetTimeStamp();
|
|
SaveHeader( libfile );
|
|
|
|
/* Sauvegarde des composant: */
|
|
char Line[256];
|
|
fprintf( docfile, "%s Date: %s\n", DOCFILE_IDENT,
|
|
DateAndTime( Line ) );
|
|
|
|
bool success = true;
|
|
|
|
BOOST_FOREACH( LibCmpEntry& entry, m_Entries )
|
|
{
|
|
if ( entry.Type == ROOT )
|
|
{
|
|
EDA_LibComponentStruct* component =
|
|
( EDA_LibComponentStruct* ) &entry;
|
|
if ( ! component->Save( libfile ) )
|
|
success = false;
|
|
}
|
|
if ( docfile )
|
|
{
|
|
if ( ! entry.SaveDoc( docfile ) )
|
|
success = false;
|
|
}
|
|
}
|
|
|
|
fprintf( libfile, "#\n#End Library\n" );
|
|
if ( docfile )
|
|
fprintf( docfile, "#\n#End Doc Library\n" );
|
|
fclose( libfile );
|
|
fclose( docfile );
|
|
return success;
|
|
}
|
|
|
|
|
|
bool LibraryStruct::SaveHeader( FILE* file )
|
|
{
|
|
char BufLine[1024];
|
|
bool succes = false;
|
|
|
|
DateAndTime( BufLine );
|
|
if( fprintf( file, "%s %d.%d Date: %s\n", LIBFILE_IDENT,
|
|
LIB_VERSION_MAJOR, LIB_VERSION_MINOR, BufLine ) < 0 )
|
|
succes = false;
|
|
#if 0
|
|
if( ( fprintf( file, "$HEADER\n" ) < 0 )
|
|
|| ( fprintf( file, "TimeStamp %8.8lX\n", m_TimeStamp ) < 0 )
|
|
|| ( fprintf( file, "Parts %d\n", m_Entries.size() ) != 2 )
|
|
|| ( fprintf( file, "$ENDHEADER\n" ) != 1 ) )
|
|
succes = false;
|
|
#endif
|
|
return succes;
|
|
}
|
|
|
|
|
|
wxString LibraryStruct::GetName()
|
|
{
|
|
return m_Name;
|
|
}
|