sch_io_mgr.h

Go to the documentation of this file.

#ifndef _SCH_IO_MGR_H_
#define _SCH_IO_MGR_H_
 
/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2016 CERN
 * Copyright (C) 2016-2021 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * @author Wayne Stambaugh <[email protected]>
 *
 * 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 3
 * 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, see <http://www.gnu.org/licenses/>.
 */
 
#include <richio.h>
#include <import_export.h>
#include <map>
#include <enum_vector.h>
#include <reporter.h>
 
 
class SCH_SHEET;
class SCH_SCREEN;
class SCH_PLUGIN;
class SCHEMATIC;
class SYMBOL_LIB_TABLE;
class KIWAY;
class LIB_SYMBOL;
class SYMBOL_LIB;
class STRING_UTF8_MAP;
class PROGRESS_REPORTER;
 
 
class SCH_IO_MGR
{
public:
 
 DEFINE_ENUM_VECTOR( SCH_FILE_T,
  {
 SCH_LEGACY, 
 SCH_KICAD, 
 SCH_ALTIUM, 
 SCH_CADSTAR_ARCHIVE, 
 SCH_EAGLE, 
 SCH_DATABASE, 
 
 // Add your schematic type here.
 SCH_FILE_UNKNOWN
 } )
 
 APIEXPORT
 static SCH_PLUGIN* FindPlugin( SCH_FILE_T aFileType );
 
 static void ReleasePlugin( SCH_PLUGIN* aPlugin );
 
 static const wxString ShowType( SCH_FILE_T aFileType );
 
 static SCH_FILE_T EnumFromStr( const wxString& aFileType );
 
 static const wxString GetFileExtension( SCH_FILE_T aFileType );
 
 static const wxString GetLibraryFileExtension( SCH_FILE_T aFileType );
 
 static SCH_FILE_T GuessPluginTypeFromLibPath( const wxString& aLibPath );
 
 static SCH_FILE_T GuessPluginTypeFromSchPath( const wxString& aSchematicPath );
};
 
 
class SCH_PLUGIN
{
public:
 
 //-----<PUBLIC SCH_PLUGIN API>-------------------------------------------------
 
 virtual const wxString GetName() const = 0;
 
 virtual void SetReporter( REPORTER* aReporter ) {}
 
 virtual void SetProgressReporter( PROGRESS_REPORTER* aReporter ) {}
 
 virtual const wxString GetFileExtension() const = 0;
 
 virtual const wxString GetLibraryFileExtension() const = 0;
 
 virtual int GetModifyHash() const = 0;
 
 virtual void SaveLibrary( const wxString& aFileName, const STRING_UTF8_MAP* aProperties = nullptr );
 
 virtual SCH_SHEET* Load( const wxString& aFileName, SCHEMATIC* aSchematic,
 SCH_SHEET* aAppendToMe = nullptr,
 const STRING_UTF8_MAP* aProperties = nullptr );
 
 virtual void Save( const wxString& aFileName, SCH_SHEET* aSheet, SCHEMATIC* aSchematic,
 const STRING_UTF8_MAP* aProperties = nullptr );
 
 virtual void EnumerateSymbolLib( wxArrayString& aSymbolNameList, const wxString& aLibraryPath,
 const STRING_UTF8_MAP* aProperties = nullptr );
 
 virtual void EnumerateSymbolLib( std::vector<LIB_SYMBOL*>& aSymbolList,
 const wxString& aLibraryPath,
 const STRING_UTF8_MAP* aProperties = nullptr );
 
 virtual LIB_SYMBOL* LoadSymbol( const wxString& aLibraryPath, const wxString& aPartName,
 const STRING_UTF8_MAP* aProperties = nullptr );
 
 virtual void SaveSymbol( const wxString& aLibraryPath, const LIB_SYMBOL* aSymbol,
 const STRING_UTF8_MAP* aProperties = nullptr );
 
 virtual void DeleteSymbol( const wxString& aLibraryPath, const wxString& aSymbolName,
 const STRING_UTF8_MAP* aProperties = nullptr );
 
 virtual void CreateSymbolLib( const wxString& aLibraryPath,
 const STRING_UTF8_MAP* aProperties = nullptr );
 
 virtual bool DeleteSymbolLib( const wxString& aLibraryPath,
 const STRING_UTF8_MAP* aProperties = nullptr );
 
 virtual bool IsSymbolLibWritable( const wxString& aLibraryPath );
 
 virtual void SymbolLibOptions( STRING_UTF8_MAP* aListToAppendTo ) const;
 
 virtual bool SupportsSubLibraries() const { return false; }
 
 virtual void GetSubLibraryNames( std::vector<wxString>& aNames ) {}
 
 virtual void GetAvailableSymbolFields( std::vector<wxString>& aNames ) {}
 
 virtual void GetDefaultSymbolFields( std::vector<wxString>& aNames )
 {
 return GetAvailableSymbolFields( aNames );
 }
 
 virtual bool CheckHeader( const wxString& aFileName );
 
 virtual const wxString& GetError() const;
 
 virtual void SetLibTable( SYMBOL_LIB_TABLE* aTable ) {}
 
 //-----</PUBLIC SCH_PLUGIN API>------------------------------------------------
 
 
 /* The compiler writes the "zero argument" constructor for a SCH_PLUGIN
 automatically if you do not provide one. If you decide you need to
 provide a zero argument constructor of your own design, that is allowed.
 It must be public, and it is what the SCH_IO_MGR uses. Parameters may be
 passed into a SCH_PLUGIN via the PROPERTIES variable for any of the public
 API functions which take one.
 */
 virtual ~SCH_PLUGIN() { }
 
 
 class SCH_PLUGIN_RELEASER
 {
 SCH_PLUGIN* plugin;
 
 // private assignment operator so it's illegal
 SCH_PLUGIN_RELEASER& operator=( SCH_PLUGIN_RELEASER& aOther ) { return *this; }
 
 // private copy constructor so it's illegal
 SCH_PLUGIN_RELEASER( const SCH_PLUGIN_RELEASER& aOther ) {}
 
 public:
 SCH_PLUGIN_RELEASER( SCH_PLUGIN* aPlugin = nullptr ) :
 plugin( aPlugin )
 {
 }
 
 ~SCH_PLUGIN_RELEASER()
 {
 if( plugin )
 release();
 }
 
 void release()
 {
 SCH_IO_MGR::ReleasePlugin( plugin );
 plugin = nullptr;
 }
 
 void set( SCH_PLUGIN* aPlugin )
 {
 if( plugin )
 release();
 plugin = aPlugin;
 }
 
 operator SCH_PLUGIN* () const
 {
 return plugin;
 }
 
 SCH_PLUGIN* operator -> () const
 {
 return plugin;
 }
 };
};
 
#endif // _SCH_IO_MGR_H_