KiCad PCB EDA Suite
Loading...
Searching...
No Matches
sch_io_easyedapro.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2023 Alex Shvartzkop <[email protected]>
5 * Copyright (C) 2023-2024 KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version 2
10 * of the License, or (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, you may find one here:
19 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
20 * or you may search the http://www.gnu.org website for the version 2 license,
21 * or you may write to the Free Software Foundation, Inc.,
22 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
26#include "sch_io_easyedapro.h"
27
28#include <schematic.h>
29#include <sch_sheet.h>
30#include <sch_screen.h>
32
33#include <fstream>
34#include <wx/txtstrm.h>
35#include <wx/wfstream.h>
36#include <wx/mstream.h>
37#include <wx/zipstrm.h>
38#include <wx/fs_zip.h>
39#include <wx/log.h>
40
41#include <nlohmann/json.hpp>
42#include <string_utils.h>
46#include <core/map_helpers.h>
47#include <project_sch.h>
48
49
51{
52 std::map<wxString, EASYEDAPRO::SYM_INFO> m_Symbols;
53 std::map<wxString, EASYEDAPRO::BLOB> m_Blobs;
54};
55
56
57SCH_IO_EASYEDAPRO::SCH_IO_EASYEDAPRO() : SCH_IO( wxS( "EasyEDA Pro (JLCEDA) Schematic" ) )
58{
60}
61
62
64{
65 if( m_projectData )
66 delete m_projectData;
67}
68
69
70bool SCH_IO_EASYEDAPRO::CanReadSchematicFile( const wxString& aFileName ) const
71{
72 if( aFileName.Lower().EndsWith( wxS( ".epro" ) ) )
73 {
74 return true;
75 }
76 else if( aFileName.Lower().EndsWith( wxS( ".zip" ) ) )
77 {
78 std::shared_ptr<wxZipEntry> entry;
79 wxFFileInputStream in( aFileName );
80 wxZipInputStream zip( in );
81
82 if( !zip.IsOk() )
83 return false;
84
85 while( entry.reset( zip.GetNextEntry() ), entry.get() != NULL )
86 {
87 wxString name = entry->GetName();
88
89 if( name == wxS( "project.json" ) )
90 return true;
91 }
92
93 return false;
94 }
95
96 return false;
97}
98
99
101{
102 return 0;
103}
104
105
106static LIB_SYMBOL* loadSymbol( nlohmann::json project, const wxString& aLibraryPath,
107 const wxString& aAliasName, const STRING_UTF8_MAP* aProperties )
108{
109 SCH_EASYEDAPRO_PARSER parser( nullptr, nullptr );
110 LIB_SYMBOL* symbol = nullptr;
111 wxFileName libFname( aLibraryPath );
112 wxString symLibName = LIB_ID::FixIllegalChars( libFname.GetName(), true );
113
114 /*if( libFname.GetExt() == wxS( "esym" ) )
115 {
116 wxFFileInputStream ffis( aLibraryPath );
117 wxTextInputStream txt( ffis, wxS( " " ), wxConvUTF8 );
118
119 bool loadThis = false;
120 std::vector<nlohmann::json> lines;
121 while( ffis.CanRead() )
122 {
123 nlohmann::json js = nlohmann::json::parse( txt.ReadLine() );
124 lines.emplace_back( js );
125
126 if( js.at( 0 ) == "ATTR" && js.at( 3 ) == "Symbol" )
127 {
128 if( js.at( 4 ).get<wxString>() == aAliasName )
129 {
130 loadThis = true;
131 }
132 }
133 }
134
135 if( loadThis )
136 {
137 EASYEDAPRO::SYM_INFO symInfo = parser.ParseSymbol( lines );
138 return symInfo.libSymbol.release();
139 }
140 }
141 else */
142 if( libFname.GetExt() == wxS( "elibz" ) || libFname.GetExt() == wxS( "epro" )
143 || libFname.GetExt() == wxS( "zip" ) )
144 {
145 std::map<wxString, EASYEDAPRO::PRJ_SYMBOL> prjSymbols = project.at( "symbols" );
146 std::map<wxString, EASYEDAPRO::PRJ_FOOTPRINT> prjFootprints = project.at( "footprints" );
147 std::map<wxString, EASYEDAPRO::PRJ_DEVICE> prjDevices = project.at( "devices" );
148
149 auto prjSymIt = std::find_if( prjSymbols.begin(), prjSymbols.end(),
150 [&]( const auto& pair )
151 {
152 return pair.second.title == aAliasName;
153 } );
154
155 if( prjSymIt == prjSymbols.end() )
156 return nullptr;
157
158 wxString prjSymUuid = prjSymIt->first;
159 wxString fpTitle;
160
161 for( auto& [key, device] : prjDevices )
162 {
163 auto val = get_opt( device.attributes, "Symbol" );
164
165 if( val && *val == prjSymUuid )
166 {
167 if( auto fpUuid = get_opt( device.attributes, "Footprint" ) )
168 {
169 if( auto prjFp = get_opt( prjFootprints, *fpUuid ) )
170 {
171 fpTitle = prjFp->title;
172 break;
173 }
174 }
175 }
176 }
177
178 auto cb = [&]( const wxString& name, const wxString& symUuid, wxInputStream& zip ) -> bool
179 {
180 if( !name.EndsWith( wxS( ".esym" ) ) )
182
183 if( symUuid != prjSymUuid )
185
186 wxTextInputStream txt( zip, wxS( " " ), wxConvUTF8 );
187
188 std::vector<nlohmann::json> lines;
189 while( zip.CanRead() )
190 {
191 nlohmann::json js = nlohmann::json::parse( txt.ReadLine() );
192 lines.emplace_back( js );
193 }
194
195 EASYEDAPRO::SYM_INFO symInfo = parser.ParseSymbol( lines );
196
197 if( !symInfo.libSymbol )
199
200 LIB_ID libID = EASYEDAPRO::ToKiCadLibID( symLibName, aAliasName );
201 symInfo.libSymbol->SetLibId( libID );
202 symInfo.libSymbol->SetName( aAliasName );
203 symInfo.libSymbol->GetFootprintField().SetText( symLibName + wxS( ":" ) + fpTitle );
204
205 symbol = symInfo.libSymbol.release();
206
208 };
209 EASYEDAPRO::IterateZipFiles( aLibraryPath, cb );
210 }
211
212 return symbol;
213}
214
215
216void SCH_IO_EASYEDAPRO::EnumerateSymbolLib( wxArrayString& aSymbolNameList,
217 const wxString& aLibraryPath,
218 const STRING_UTF8_MAP* aProperties )
219{
220 wxFileName fname( aLibraryPath );
221
222 if( fname.GetExt() == wxS( "esym" ) )
223 {
224 wxFFileInputStream ffis( aLibraryPath );
225 wxTextInputStream txt( ffis, wxS( " " ), wxConvUTF8 );
226
227 while( ffis.CanRead() )
228 {
229 wxString line = txt.ReadLine();
230
231 if( !line.Contains( wxS( "ATTR" ) ) )
232 continue; // Don't bother parsing
233
234 nlohmann::json js = nlohmann::json::parse( line );
235 if( js.at( 0 ) == "ATTR" && js.at( 3 ) == "Symbol" )
236 {
237 aSymbolNameList.Add( js.at( 4 ).get<wxString>() );
238 }
239 }
240 }
241 else if( fname.GetExt() == wxS( "elibz" ) || fname.GetExt() == wxS( "epro" )
242 || fname.GetExt() == wxS( "zip" ) )
243 {
244 nlohmann::json project = EASYEDAPRO::ReadProjectOrDeviceFile( aLibraryPath );
245 std::map<wxString, nlohmann::json> symbolMap = project.at( "symbols" );
246
247 for( auto& [key, value] : symbolMap )
248 {
249 wxString title;
250
251 if( value.contains( "display_title" ) )
252 title = value.at( "display_title" ).get<wxString>();
253 else
254 title = value.at( "title" ).get<wxString>();
255
256 aSymbolNameList.Add( title );
257 }
258 }
259}
260
261
262void SCH_IO_EASYEDAPRO::EnumerateSymbolLib( std::vector<LIB_SYMBOL*>& aSymbolList,
263 const wxString& aLibraryPath,
264 const STRING_UTF8_MAP* aProperties )
265{
266 wxFileName libFname( aLibraryPath );
267 wxArrayString symbolNameList;
268 nlohmann::json project;
269
270 EnumerateSymbolLib( symbolNameList, aLibraryPath, aProperties );
271
272 if( libFname.GetExt() == wxS( "elibz" ) || libFname.GetExt() == wxS( "epro" )
273 || libFname.GetExt() == wxS( "zip" ) )
274 {
276 }
277
278 for( const wxString& symbolName : symbolNameList )
279 {
280 LIB_SYMBOL* sym = loadSymbol( project, aLibraryPath, symbolName, aProperties );
281
282 if( sym )
283 aSymbolList.push_back( sym );
284 }
285}
286
287
288void SCH_IO_EASYEDAPRO::LoadAllDataFromProject( const wxString& aProjectPath )
289{
290 if( m_projectData )
291 delete m_projectData;
292
294
295 SCH_EASYEDAPRO_PARSER parser( nullptr, nullptr );
296 wxFileName fname( aProjectPath );
297 wxString symLibName = EASYEDAPRO::ShortenLibName( fname.GetName() );
298
299 if( fname.GetExt() != wxS( "epro" ) && fname.GetExt() != wxS( "zip" ) )
300 return;
301
302 nlohmann::json project = EASYEDAPRO::ReadProjectOrDeviceFile( aProjectPath );
303
304 std::map<wxString, EASYEDAPRO::PRJ_SYMBOL> prjSymbols = project.at( "symbols" );
305 std::map<wxString, EASYEDAPRO::PRJ_FOOTPRINT> prjFootprints = project.at( "footprints" );
306 std::map<wxString, EASYEDAPRO::PRJ_DEVICE> prjDevices = project.at( "devices" );
307
308 auto cb = [&]( const wxString& name, const wxString& baseName, wxInputStream& zip ) -> bool
309 {
310 if( !name.EndsWith( wxS( ".esym" ) ) && !name.EndsWith( wxS( ".eblob" ) ) )
312
313 std::vector<nlohmann::json> lines = EASYEDAPRO::ParseJsonLines( zip, name );
314
315 if( name.EndsWith( wxS( ".esym" ) ) )
316 {
317 EASYEDAPRO::PRJ_SYMBOL symData = prjSymbols.at( baseName );
318 EASYEDAPRO::SYM_INFO symInfo = parser.ParseSymbol( lines );
319
320 if( !symInfo.libSymbol )
322
323 wxString fpTitle;
324
325 for( auto& [key, device] : prjDevices )
326 {
327 auto val = get_opt( device.attributes, "Symbol" );
328
329 if( val && *val == baseName )
330 {
331 if( auto fpUuid = get_opt( device.attributes, "Footprint" ) )
332 {
333 if( auto prjFp = get_opt( prjFootprints, *fpUuid ) )
334 {
335 fpTitle = prjFp->title;
336 break;
337 }
338 }
339 }
340 }
341
342 LIB_ID libID = EASYEDAPRO::ToKiCadLibID( symLibName, symData.title );
343 symInfo.libSymbol->SetLibId( libID );
344 symInfo.libSymbol->SetName( symData.title );
345 symInfo.libSymbol->GetFootprintField().SetText( symLibName + wxS( ":" ) + fpTitle );
346
347 m_projectData->m_Symbols.emplace( baseName, std::move( symInfo ) );
348 }
349 else if( name.EndsWith( wxS( ".eblob" ) ) )
350 {
351 for( const nlohmann::json& line : lines )
352 {
353 if( line.at( 0 ) == "BLOB" )
354 {
355 EASYEDAPRO::BLOB blob = line;
356 m_projectData->m_Blobs[blob.objectId] = blob;
357 }
358 }
359 }
360
362 };
363 EASYEDAPRO::IterateZipFiles( aProjectPath, cb );
364}
365
366
367LIB_SYMBOL* SCH_IO_EASYEDAPRO::LoadSymbol( const wxString& aLibraryPath, const wxString& aAliasName,
368 const STRING_UTF8_MAP* aProperties )
369{
370 wxFileName libFname( aLibraryPath );
371 nlohmann::json project;
372
373 if( libFname.GetExt() == wxS( "elibz" ) || libFname.GetExt() == wxS( "epro" )
374 || libFname.GetExt() == wxS( "zip" ) )
375 {
377 }
378
379 return loadSymbol( project, aLibraryPath, aAliasName, aProperties );
380}
381
382
384 SCHEMATIC* aSchematic, SCH_SHEET* aAppendToMe,
385 const STRING_UTF8_MAP* aProperties )
386{
387 wxCHECK( !aFileName.IsEmpty() && aSchematic, nullptr );
388
389 SCH_SHEET* rootSheet = nullptr;
390
391 if( aAppendToMe )
392 {
393 wxCHECK_MSG( aSchematic->IsValid(), nullptr,
394 wxS( "Can't append to a schematic with no root!" ) );
395
396 rootSheet = &aSchematic->Root();
397 }
398 else
399 {
400 rootSheet = new SCH_SHEET( aSchematic );
401 rootSheet->SetFileName( aFileName );
402 aSchematic->SetRoot( rootSheet );
403 }
404
405 if( !rootSheet->GetScreen() )
406 {
407 SCH_SCREEN* screen = new SCH_SCREEN( aSchematic );
408
409 screen->SetFileName( aFileName );
410 rootSheet->SetScreen( screen );
411 }
412
413 SYMBOL_LIB_TABLE* libTable = PROJECT_SCH::SchSymbolLibTable( &aSchematic->Prj() );
414 wxCHECK_MSG( libTable, nullptr, wxS( "Could not load symbol lib table." ) );
415
416 SCH_EASYEDAPRO_PARSER parser( nullptr, nullptr );
417 wxFileName fname( aFileName );
418 wxString libName = EASYEDAPRO::ShortenLibName( fname.GetName() );
419
420 wxFileName libFileName( fname.GetPath(), libName, FILEEXT::KiCadSymbolLibFileExtension );
421
422 if( fname.GetExt() != wxS( "epro" ) && fname.GetExt() != wxS( "zip" ) )
423 return rootSheet;
424
425 nlohmann::json project = EASYEDAPRO::ReadProjectOrDeviceFile( aFileName );
426
427 std::map<wxString, EASYEDAPRO::PRJ_SCHEMATIC> prjSchematics = project.at( "schematics" );
428
429 wxString schematicToLoad;
430
431 if( aProperties && aProperties->Exists( "sch_id" ) )
432 {
433 schematicToLoad = wxString::FromUTF8( aProperties->at( "sch_id" ) );
434 }
435 else
436 {
437 if( prjSchematics.size() == 1 )
438 {
439 schematicToLoad = prjSchematics.begin()->first;
440 }
441 else
442 {
443 std::vector<IMPORT_PROJECT_DESC> chosen = m_choose_project_handler(
445
446 if( chosen.size() > 0 )
447 schematicToLoad = chosen[0].SchematicId;
448 }
449 }
450
451 if( schematicToLoad.empty() )
452 return nullptr;
453
454 wxString rootBaseName = EscapeString( prjSchematics[schematicToLoad].name, CTX_FILENAME );
455
456 wxFileName rootFname( aFileName );
457 rootFname.SetFullName( rootBaseName + wxS( "." )
458 + wxString::FromUTF8( FILEEXT::KiCadSchematicFileExtension ) );
459
460 rootSheet->SetName( prjSchematics[schematicToLoad].name );
461 rootSheet->SetFileName( rootFname.GetFullPath() );
462 rootSheet->GetScreen()->SetFileName( rootFname.GetFullPath() );
463
464 const std::vector<EASYEDAPRO::PRJ_SHEET>& prjSchematicSheets =
465 prjSchematics[schematicToLoad].sheets;
466
467 LoadAllDataFromProject( aFileName );
468
469 if( !m_projectData )
470 return nullptr;
471
472 const int schSheetsCount = prjSchematicSheets.size();
473
474 auto cbs = [&]( const wxString& name, const wxString& baseName, wxInputStream& zip ) -> bool
475 {
476 if( !name.EndsWith( wxS( ".esch" ) ) )
478
479 wxArrayString nameParts = wxSplit( name, '\\', '\0' );
480
481 if( nameParts.size() == 1 )
482 nameParts = wxSplit( name, '/', '\0' );
483
484 if( nameParts.size() < 3 )
486
487 wxString schematicUuid = nameParts[1];
488 wxString sheetFileName = nameParts[2];
489 wxString sheetId = sheetFileName.BeforeLast( '.' );
490 int sheetId_i;
491 sheetId.ToInt( &sheetId_i );
492
493 if( schematicUuid != schematicToLoad )
495
496 auto prjSheetIt = std::find_if( prjSchematicSheets.begin(), prjSchematicSheets.end(),
497 [&]( const EASYEDAPRO::PRJ_SHEET& s )
498 {
499 return s.id == sheetId_i;
500 } );
501
502 if( prjSheetIt == prjSchematicSheets.end() )
504
505 std::vector<nlohmann::json> lines = EASYEDAPRO::ParseJsonLines( zip, name );
506
507 if( schSheetsCount > 1 )
508 {
509 wxString sheetBaseName =
510 sheetId + wxS( "_" ) + EscapeString( prjSheetIt->name, CTX_FILENAME );
511
512 wxFileName sheetFname( aFileName );
513 sheetFname.SetFullName( sheetBaseName + wxS( "." )
514 + wxString::FromUTF8( FILEEXT::KiCadSchematicFileExtension ) );
515
516 wxFileName relSheetPath( sheetFname );
517 relSheetPath.MakeRelativeTo( rootFname.GetPath() );
518
519 std::unique_ptr<SCH_SHEET> subSheet = std::make_unique<SCH_SHEET>( aSchematic );
520 subSheet->SetFileName( relSheetPath.GetFullPath() );
521 subSheet->SetName( prjSheetIt->name );
522
523 SCH_SCREEN* screen = new SCH_SCREEN( aSchematic );
524 screen->SetFileName( sheetFname.GetFullPath() );
525 screen->SetPageNumber( sheetId );
526 subSheet->SetScreen( screen );
527
528 VECTOR2I pos;
529 pos.x = schIUScale.MilsToIU( 200 );
530 pos.y = schIUScale.MilsToIU( 200 )
531 + ( subSheet->GetSize().y + schIUScale.MilsToIU( 200 ) ) * ( sheetId_i - 1 );
532
533 subSheet->SetPosition( pos );
534
535 SCH_SHEET_PATH sheetPath;
536 sheetPath.push_back( rootSheet );
537 sheetPath.push_back( subSheet.get() );
538 sheetPath.SetPageNumber( sheetId );
539 aSchematic->SetCurrentSheet( sheetPath );
540
541 parser.ParseSchematic( aSchematic, subSheet.get(), project, m_projectData->m_Symbols,
542 m_projectData->m_Blobs, lines, libName );
543
544 rootSheet->GetScreen()->Append( subSheet.release() );
545 }
546 else
547 {
548 parser.ParseSchematic( aSchematic, rootSheet, project, m_projectData->m_Symbols,
549 m_projectData->m_Blobs, lines, libName );
550 }
551
553 };
554 EASYEDAPRO::IterateZipFiles( aFileName, cbs );
555
556 IO_RELEASER<SCH_IO> sch_plugin( SCH_IO_MGR::FindPlugin( SCH_IO_MGR::SCH_KICAD ) );
557
558 if( !libTable->HasLibrary( libName ) )
559 {
560 // Create a new empty symbol library.
561 sch_plugin->CreateLibrary( libFileName.GetFullPath() );
562 wxString libTableUri = wxS( "${KIPRJMOD}/" ) + libFileName.GetFullName();
563
564 // Add the new library to the project symbol library table.
565 libTable->InsertRow( new SYMBOL_LIB_TABLE_ROW( libName, libTableUri, wxS( "KiCad" ) ) );
566
567 // Save project symbol library table.
568 wxFileName fn( aSchematic->Prj().GetProjectPath(),
570
571 // So output formatter goes out of scope and closes the file before reloading.
572 {
573 FILE_OUTPUTFORMATTER formatter( fn.GetFullPath() );
574 libTable->Format( &formatter, 0 );
575 }
576
577 // Relaod the symbol library table.
578 aSchematic->Prj().SetElem( PROJECT::ELEM_SYMBOL_LIB_TABLE, NULL );
579 PROJECT_SCH::SchSymbolLibTable( &aSchematic->Prj() );
580 }
581
582 // set properties to prevent save file on every symbol save
583 STRING_UTF8_MAP properties;
584 properties.emplace( SCH_IO_KICAD_SEXPR::PropBuffering, wxEmptyString );
585
586 for( auto& [symbolUuid, symInfo] : m_projectData->m_Symbols )
587 sch_plugin->SaveSymbol( libFileName.GetFullPath(), symInfo.libSymbol.release(),
588 &properties );
589
590 sch_plugin->SaveLibrary( libFileName.GetFullPath() );
591
593 aSchematic->FixupJunctions();
594
595 return rootSheet;
596}
const char * name
Definition: DXF_plotter.cpp:57
constexpr EDA_IU_SCALE schIUScale
Definition: base_units.h:110
void SetPageNumber(const wxString &aPageNumber)
Definition: base_screen.h:79
Used for text file output.
Definition: richio.h:475
REPORTER * m_reporter
Reporter to log errors/warnings to, may be nullptr.
Definition: io_base.h:207
A logical library item identifier and consists of various portions much like a URI.
Definition: lib_id.h:49
static UTF8 FixIllegalChars(const UTF8 &aLibItemName, bool aLib)
Replace illegal LIB_ID item name characters with underscores '_'.
Definition: lib_id.cpp:191
Define a library symbol object.
Definition: lib_symbol.h:79
bool HasLibrary(const wxString &aNickname, bool aCheckEnabled=false) const
Test for the existence of aNickname in the library table.
bool InsertRow(LIB_TABLE_ROW *aRow, bool doReplace=false)
Adds aRow if it does not already exist or if doReplace is true.
CHOOSE_PROJECT_HANDLER m_choose_project_handler
Callback to choose projects to import.
static SYMBOL_LIB_TABLE * SchSymbolLibTable(PROJECT *aProject)
Accessor for project symbol library table.
virtual const wxString GetProjectPath() const
Return the full path of the project.
Definition: project.cpp:135
virtual void SetElem(ELEM_T aIndex, _ELEM *aElem)
Definition: project.cpp:309
@ ELEM_SYMBOL_LIB_TABLE
Definition: project.h:228
Holds all the data relating to one schematic.
Definition: schematic.h:75
SCH_SHEET_PATH & CurrentSheet() const override
Definition: schematic.h:136
void SetCurrentSheet(const SCH_SHEET_PATH &aPath) override
Definition: schematic.h:141
void FixupJunctions()
Add junctions to this schematic where required.
Definition: schematic.cpp:721
void SetRoot(SCH_SHEET *aRootSheet)
Initialize the schematic with a new root sheet.
Definition: schematic.cpp:184
bool IsValid() const
A simple test if the schematic is loaded, not a complete one.
Definition: schematic.h:121
SCH_SHEET & Root() const
Definition: schematic.h:105
PROJECT & Prj() const override
Return a reference to the project this schematic is part of.
Definition: schematic.h:90
EASYEDAPRO::SYM_INFO ParseSymbol(const std::vector< nlohmann::json > &aLines)
void ParseSchematic(SCHEMATIC *aSchematic, SCH_SHEET *aRootSheet, const nlohmann::json &aProject, std::map< wxString, EASYEDAPRO::SYM_INFO > &aSymbolMap, const std::map< wxString, EASYEDAPRO::BLOB > &aBlobMap, const std::vector< nlohmann::json > &aLines, const wxString &aLibName)
SCH_SHEET * LoadSchematicFile(const wxString &aFileName, SCHEMATIC *aSchematic, SCH_SHEET *aAppendToMe=nullptr, const STRING_UTF8_MAP *aProperties=nullptr) override
Load information from some input file format that this SCH_IO implementation knows about,...
void EnumerateSymbolLib(wxArrayString &aSymbolNameList, const wxString &aLibraryPath, const STRING_UTF8_MAP *aProperties=nullptr) override
Populate a list of LIB_SYMBOL alias names contained within the library aLibraryPath.
PRJ_DATA * m_projectData
void LoadAllDataFromProject(const wxString &aLibraryPath)
int GetModifyHash() const override
Return the modification hash from the library cache.
bool CanReadSchematicFile(const wxString &aFileName) const override
Checks if this SCH_IO can read the specified schematic file.
LIB_SYMBOL * LoadSymbol(const wxString &aLibraryPath, const wxString &aAliasName, const STRING_UTF8_MAP *aProperties=nullptr) override
Load a LIB_SYMBOL object having aPartName from the aLibraryPath containing a library format that this...
static const char * PropBuffering
The property used internally by the plugin to enable cache buffering which prevents the library file ...
Base class that schematic file and library loading and saving plugins should derive from.
Definition: sch_io.h:57
void Append(SCH_ITEM *aItem, bool aUpdateLibSymbol=true)
Definition: sch_screen.cpp:150
void SetFileName(const wxString &aFileName)
Set the file name for this screen to aFileName.
Definition: sch_screen.cpp:115
Handle access to a stack of flattened SCH_SHEET objects by way of a path for creating a flattened sch...
void UpdateAllScreenReferences() const
Update all the symbol references for this sheet path.
void SetPageNumber(const wxString &aPageNumber)
Set the sheet instance user definable page number.
void push_back(SCH_SHEET *aSheet)
Forwarded method from std::vector.
Sheet symbol placed in a schematic, and is the entry point for a sub schematic.
Definition: sch_sheet.h:57
void SetFileName(const wxString &aFilename)
Definition: sch_sheet.h:312
void SetName(const wxString &aName)
Definition: sch_sheet.h:108
SCH_SCREEN * GetScreen() const
Definition: sch_sheet.h:110
void SetScreen(SCH_SCREEN *aScreen)
Set the SCH_SCREEN associated with this sheet to aScreen.
Definition: sch_sheet.cpp:162
A name/value tuple with unique names and optional values.
bool Exists(const std::string &aProperty) const
Hold a record identifying a symbol library accessed by the appropriate symbol library SCH_IO object i...
static const wxString & GetSymbolLibTableFileName()
virtual void Format(OUTPUTFORMATTER *aOutput, int aIndentLevel) const override
Generate the table in s-expression format to aOutput with an indentation level of aIndentLevel.
static REPORTER & GetInstance()
Definition: reporter.cpp:203
#define EASY_IT_BREAK
#define EASY_IT_CONTINUE
static const std::string KiCadSchematicFileExtension
static const std::string KiCadSymbolLibFileExtension
std::unique_ptr< T > IO_RELEASER
Helper to hold and release an IO_BASE object when exceptions are thrown.
Definition: io_mgr.h:33
std::optional< V > get_opt(const std::map< wxString, V > &aMap, const wxString &aKey)
Definition: map_helpers.h:34
LIB_ID ToKiCadLibID(const wxString &aLibName, const wxString &aLibReference)
void IterateZipFiles(const wxString &aFileName, std::function< bool(const wxString &, const wxString &, wxInputStream &)> aCallback)
std::vector< nlohmann::json > ParseJsonLines(wxInputStream &aInput, const wxString &aSource)
std::vector< IMPORT_PROJECT_DESC > ProjectToSelectorDialog(const nlohmann::json &aProject, bool aPcbOnly=false, bool aSchOnly=false)
nlohmann::json ReadProjectOrDeviceFile(const wxString &aZipFileName)
wxString ShortenLibName(wxString aProjectName)
LIB_SYMBOL * loadSymbol(const wxString &aLibraryPath, nlohmann::json aFileData, const wxString &aAliasName, const STRING_UTF8_MAP *aProperties)
static LIB_SYMBOL * loadSymbol(nlohmann::json project, const wxString &aLibraryPath, const wxString &aAliasName, const STRING_UTF8_MAP *aProperties)
wxString EscapeString(const wxString &aSource, ESCAPE_CONTEXT aContext)
The Escape/Unescape routines use HTML-entity-reference-style encoding to handle characters which are:...
@ CTX_FILENAME
Definition: string_utils.h:61
std::unique_ptr< LIB_SYMBOL > libSymbol
constexpr int MilsToIU(int mils) const
Definition: base_units.h:93
std::map< wxString, EASYEDAPRO::BLOB > m_Blobs
std::map< wxString, EASYEDAPRO::SYM_INFO > m_Symbols
Definition of file extensions used in Kicad.