KiCad PCB EDA Suite
Loading...
Searching...
No Matches
pcbnew/files.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) 2004-2015 Jean-Pierre Charras, jp.charras at wanadoo.fr
5 * Copyright (C) 2011 Wayne Stambaugh <[email protected]>
6 * Copyright (C) 2023 CERN (www.cern.ch)
7 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version 2
12 * of the License, or (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, you may find one here:
21 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
22 * or you may search the http://www.gnu.org website for the version 2 license,
23 * or you may write to the Free Software Foundation, Inc.,
24 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
25 */
26
27#include <string>
28
29#include <confirm.h>
30#include <kidialog.h>
31#include <core/arraydim.h>
32#include <thread_pool.h>
34#include <gestfich.h>
35#include <pcb_edit_frame.h>
38#include <fp_lib_table.h>
39#include <kiface_base.h>
40#include <macros.h>
41#include <trace_helpers.h>
43#include <lockfile.h>
44#include <wx/snglinst.h>
46#include <pcbnew_id.h>
48#include <tool/tool_manager.h>
49#include <board.h>
50#include <kiplatform/app.h>
52#include <widgets/wx_infobar.h>
55#include <paths.h>
56#include <pgm_base.h>
58#include <project_pcb.h>
62#include <pcb_io/pcb_io_mgr.h>
70#include <tools/pcb_actions.h>
72#include "footprint_info_impl.h"
73#include <board_commit.h>
74#include <zone_filler.h>
77#include <wx_filename.h> // For ::ResolvePossibleSymlinks()
78#include <kiplatform/io.h>
79
80#include <wx/stdpaths.h>
81#include <wx/ffile.h>
82#include <wx/filedlg.h>
83#include <wx/txtstrm.h>
84#include <wx/wfstream.h>
85#include <wx/zipstrm.h>
86#include <wx/dir.h>
87
89
90//#define USE_INSTRUMENTATION 1
91#define USE_INSTRUMENTATION 0
92
93
103bool AskLoadBoardFileName( PCB_EDIT_FRAME* aParent, wxString* aFileName, int aCtl = 0 )
104{
105 std::vector<IO_BASE::IO_FILE_DESC> descriptions;
106
107 for( const auto& plugin : PCB_IO_MGR::PLUGIN_REGISTRY::Instance()->AllPlugins() )
108 {
109 bool isKiCad = plugin.m_type == PCB_IO_MGR::KICAD_SEXP || plugin.m_type == PCB_IO_MGR::LEGACY;
110
111 if( ( aCtl & KICTL_KICAD_ONLY ) && !isKiCad )
112 continue;
113
114 if( ( aCtl & KICTL_NONKICAD_ONLY ) && isKiCad )
115 continue;
116
117 IO_RELEASER<PCB_IO> pi( plugin.m_createFunc() );
118 wxCHECK( pi, false );
119
120 const IO_BASE::IO_FILE_DESC& desc = pi->GetBoardFileDesc();
121
122 if( desc.m_FileExtensions.empty() || !desc.m_CanRead )
123 continue;
124
125 descriptions.emplace_back( desc );
126 }
127
128 wxString fileFiltersStr;
129 std::vector<std::string> allExtensions;
130 std::set<wxString> allWildcardsSet;
131
132 for( const IO_BASE::IO_FILE_DESC& desc : descriptions )
133 {
134 if( !fileFiltersStr.IsEmpty() )
135 fileFiltersStr += wxChar( '|' );
136
137 fileFiltersStr += desc.FileFilter();
138
139 for( const std::string& ext : desc.m_FileExtensions )
140 {
141 allExtensions.emplace_back( ext );
142 allWildcardsSet.insert( wxT( "*." ) + formatWildcardExt( ext ) + wxT( ";" ) );
143 }
144 }
145
146 wxString allWildcardsStr;
147
148 for( const wxString& wildcard : allWildcardsSet )
149 allWildcardsStr << wildcard;
150
151 if( aCtl & KICTL_KICAD_ONLY )
152 {
153 fileFiltersStr = _( "All KiCad Board Files" ) + AddFileExtListToFilter( allExtensions );
154 }
155 else
156 {
157 fileFiltersStr = _( "All supported formats" ) + wxT( "|" ) + allWildcardsStr + wxT( "|" )
158 + fileFiltersStr;
159 }
160
161 wxFileName fileName( *aFileName );
162 wxString path;
163 wxString name;
164
165 if( fileName.FileExists() )
166 {
167 path = fileName.GetPath();
168 name = fileName.GetFullName();
169 }
170 else
171 {
172 path = aParent->GetMruPath();
173
174 if( path.IsEmpty() )
176 // leave name empty
177 }
178
179 bool kicadFormat = ( aCtl & KICTL_KICAD_ONLY );
180
181 wxFileDialog dlg( aParent, kicadFormat ? _( "Open Board File" ) : _( "Import Non KiCad Board File" ),
182 path, name, fileFiltersStr, wxFD_OPEN | wxFD_FILE_MUST_EXIST );
183
184 FILEDLG_IMPORT_NON_KICAD importOptions( aParent->config()->m_System.show_import_issues );
185
186 if( !kicadFormat )
187 dlg.SetCustomizeHook( importOptions );
188
189 if( dlg.ShowModal() == wxID_OK )
190 {
191 *aFileName = dlg.GetPath();
192 aParent->SetMruPath( wxFileName( dlg.GetPath() ).GetPath() );
193
194 if( !kicadFormat )
195 aParent->config()->m_System.show_import_issues = importOptions.GetShowIssues();
196
197 return true;
198 }
199 else
200 {
201 return false;
202 }
203}
204
205
215bool AskSaveBoardFileName( PCB_EDIT_FRAME* aParent, wxString* aFileName, bool* aCreateProject )
216{
217 wxString wildcard = FILEEXT::PcbFileWildcard();
218 wxFileName fn = *aFileName;
219
221
222 wxFileDialog dlg( aParent, _( "Save Board File As" ), fn.GetPath(), fn.GetFullName(), wildcard,
223 wxFD_SAVE | wxFD_OVERWRITE_PROMPT );
224
225// Add a "Create a project" checkbox in standalone mode and one isn't loaded
226 FILEDLG_HOOK_SAVE_PROJECT newProjectHook;
227
228 if( Kiface().IsSingle() && aParent->Prj().IsNullProject() )
229 dlg.SetCustomizeHook( newProjectHook );
230
231 if( dlg.ShowModal() != wxID_OK )
232 return false;
233
234 *aFileName = dlg.GetPath();
235 *aFileName = EnsureFileExtension( *aFileName, FILEEXT::KiCadPcbFileExtension );
236
237 if( newProjectHook.IsAttachedToDialog() )
238 *aCreateProject = newProjectHook.GetCreateNewProject();
239 else if( !aParent->Prj().IsNullProject() )
240 *aCreateProject = true;
241
242 return true;
243}
244
245
246void PCB_EDIT_FRAME::OnFileHistory( wxCommandEvent& event )
247{
248 wxString fn = GetFileFromHistory( event.GetId(), _( "Printed circuit board" ) );
249
250 if( !!fn )
251 {
252 if( !wxFileName::IsFileReadable( fn ) )
253 {
254 if( !AskLoadBoardFileName( this, &fn, KICTL_KICAD_ONLY ) )
255 return;
256 }
257
258 OpenProjectFiles( std::vector<wxString>( 1, fn ), KICTL_KICAD_ONLY );
259 }
260}
261
262
263void PCB_EDIT_FRAME::OnClearFileHistory( wxCommandEvent& aEvent )
264{
266}
267
268
270{
271 // Only standalone mode can directly load a new document
272 if( !Kiface().IsSingle() )
273 return false;
274
275 int open_ctl = KICTL_KICAD_ONLY;
276 wxString fileName = m_frame->Prj().AbsolutePath( m_frame->GetBoard()->GetFileName() );
277
278 if( AskLoadBoardFileName( m_frame, &fileName, open_ctl ) )
279 m_frame->OpenProjectFiles( std::vector<wxString>( 1, fileName ), open_ctl );
280
281 return 0;
282}
283
284
286{
287 // Note: we explicitly allow this even if not in standalone mode for now, even though it is dangerous.
288 int open_ctl = KICTL_NONKICAD_ONLY;
289 wxString fileName; // = Prj().AbsolutePath( GetBoard()->GetFileName() );
290
291 if( AskLoadBoardFileName( m_frame, &fileName, open_ctl ) )
292 m_frame->OpenProjectFiles( std::vector<wxString>( 1, fileName ), open_ctl );
293
294 return 0;
295}
296
297
299{
300 wxFileName currfn = m_frame->Prj().AbsolutePath( m_frame->GetBoard()->GetFileName() );
301 wxFileName fn = currfn;
302
303 wxString rec_name = FILEEXT::AutoSaveFilePrefix + fn.GetName();
304 fn.SetName( rec_name );
305
306 if( !fn.FileExists() )
307 {
308 DisplayError( m_frame, wxString::Format( _( "Recovery file '%s' not found." ), fn.GetFullPath() ) );
309 return 0;
310 }
311
312 if( !IsOK( m_frame, wxString::Format( _( "OK to load recovery file '%s'?" ), fn.GetFullPath() ) ) )
313 return false;
314
315 m_frame->GetScreen()->SetContentModified( false ); // do not prompt the user for changes
316
317 if( m_frame->OpenProjectFiles( std::vector<wxString>( 1, fn.GetFullPath() ) ) )
318 {
319 // Re-set the name since name or extension was changed
320 m_frame->GetBoard()->SetFileName( currfn.GetFullPath() );
321 m_frame->UpdateTitle();
322 }
323
324 return 0;
325}
326
327
329{
330 wxFileName fn = m_frame->Prj().AbsolutePath( m_frame->GetBoard()->GetFileName() );
331
332 if( !IsOK( m_frame, wxString::Format( _( "Revert '%s' to last version saved?" ), fn.GetFullPath() ) ) )
333 return false;
334
335 m_frame->GetScreen()->SetContentModified( false ); // do not prompt the user for changes
336
337 m_frame->ReleaseFile();
338
339 m_frame->OpenProjectFiles( std::vector<wxString>( 1, fn.GetFullPath() ), KICTL_REVERT );
340
341 return 0;
342}
343
344
346{
347 // Only standalone mode can directly load a new document
348 if( !Kiface().IsSingle() )
349 return false;
350
351 if( m_frame->IsContentModified() )
352 {
353 wxFileName fileName = m_frame->GetBoard()->GetFileName();
354 wxString saveMsg = _( "Current board will be closed, save changes to '%s' before "
355 "continuing?" );
356
357 if( !HandleUnsavedChanges( m_frame, wxString::Format( saveMsg, fileName.GetFullName() ),
358 [&]()->bool
359 {
360 return m_frame->SaveBoard();
361 } ) )
362 {
363 return false;
364 }
365 }
366 else if( !m_frame->GetBoard()->IsEmpty() )
367 {
368 if( !IsOK( m_frame, _( "Current Board will be closed. Continue?" ) ) )
369 return false;
370 }
371
372 m_frame->SaveProjectLocalSettings();
373
374 m_frame->GetBoard()->ClearProject();
375 m_frame->GetSettingsManager()->UnloadProject( &m_frame->Prj() );
376
377 if( !m_frame->Clear_Pcb( false ) )
378 return false;
379
380 m_frame->LoadProjectSettings();
381 m_frame->LoadDrawingSheet();
382
383 m_frame->OnBoardLoaded();
384 m_frame->OnModify();
385
386 return 0;
387}
388
389
390bool PCB_EDIT_FRAME::SaveBoard( bool aSaveAs, bool aSaveCopy )
391{
392 if( !aSaveAs )
393 {
394 if( !GetBoard()->GetFileName().IsEmpty() )
395 {
396 if( SavePcbFile( Prj().AbsolutePath( GetBoard()->GetFileName() ) ) )
397 {
398 m_autoSaveRequired = false;
399 return true;
400 }
401
402 return false;
403 }
404 }
405
406 wxString orig_name;
407
408 wxFileName::SplitPath( GetBoard()->GetFileName(), nullptr, nullptr, &orig_name, nullptr );
409
410 if( orig_name.IsEmpty() )
411 orig_name = NAMELESS_PROJECT;
412
413 wxFileName savePath( Prj().GetProjectFullName() );
414
415 if( !savePath.IsOk() || !savePath.IsDirWritable() )
416 {
417 savePath = GetMruPath();
418
419 if( !savePath.IsOk() || !savePath.IsDirWritable() )
421 }
422
423 wxFileName fn( savePath.GetPath(), orig_name, FILEEXT::KiCadPcbFileExtension );
424 wxString filename = fn.GetFullPath();
425 bool createProject = false;
426 bool success = false;
427
428 if( AskSaveBoardFileName( this, &filename, &createProject ) )
429 {
430 if( aSaveCopy )
431 {
432 success = SavePcbCopy( EnsureFileExtension( filename, FILEEXT::KiCadPcbFileExtension ), createProject );
433 }
434 else
435 {
436 success = SavePcbFile( filename, aSaveAs, createProject );
437
438 if( success )
439 m_autoSaveRequired = false;
440 }
441 }
442
443 return success;
444}
445
446
447int PCB_EDIT_FRAME::inferLegacyEdgeClearance( BOARD* aBoard, bool aShowUserMsg )
448{
449 PCB_LAYER_COLLECTOR collector;
450
451 collector.SetLayerId( Edge_Cuts );
452 collector.Collect( aBoard, GENERAL_COLLECTOR::AllBoardItems );
453
454 int edgeWidth = -1;
455 bool mixed = false;
456
457 for( int i = 0; i < collector.GetCount(); i++ )
458 {
459 if( collector[i]->Type() == PCB_SHAPE_T )
460 {
461 int itemWidth = static_cast<PCB_SHAPE*>( collector[i] )->GetWidth();
462
463 if( edgeWidth != -1 && edgeWidth != itemWidth )
464 {
465 mixed = true;
466 edgeWidth = std::max( edgeWidth, itemWidth );
467 }
468 else
469 {
470 edgeWidth = itemWidth;
471 }
472 }
473 }
474
475 if( mixed && aShowUserMsg )
476 {
477 // If they had different widths then we can't ensure that fills will be the same.
478 DisplayInfoMessage( this,
479 _( "If the zones on this board are refilled the Copper Edge "
480 "Clearance setting will be used (see Board Setup > Design "
481 "Rules > Constraints).\n This may result in different fills "
482 "from previous KiCad versions which used the line thicknesses "
483 "of the board boundary on the Edge Cuts layer." ) );
484 }
485
486 return std::max( 0, edgeWidth / 2 );
487}
488
489
490bool PCB_EDIT_FRAME::OpenProjectFiles( const std::vector<wxString>& aFileSet, int aCtl )
491{
492 // This is for python:
493 if( aFileSet.size() != 1 )
494 {
495 UTF8 msg = StrPrintf( "Pcbnew:%s() takes a single filename", __func__ );
496 DisplayError( this, msg );
497 return false;
498 }
499
500 wxString fullFileName( aFileSet[0] );
501 wxFileName wx_filename( fullFileName );
502 wxString msg;
503
504 if( Kiface().IsSingle() )
506
507 // We insist on caller sending us an absolute path, if it does not, we say it's a bug.
508 wxASSERT_MSG( wx_filename.IsAbsolute(), wxT( "Path is not absolute!" ) );
509
510 std::unique_ptr<LOCKFILE> lock = std::make_unique<LOCKFILE>( fullFileName );
511
512 if( !lock->Valid() && lock->IsLockedByMe() )
513 {
514 // If we cannot acquire the lock but we appear to be the one who locked it, check to
515 // see if there is another KiCad instance running. If not, then we can override the
516 // lock. This could happen if KiCad crashed or was interrupted.
517
518 if( !Pgm().SingleInstance()->IsAnotherRunning() )
519 lock->OverrideLock();
520 }
521
522 if( !lock->Valid() )
523 {
524 msg.Printf( _( "PCB '%s' is already open by '%s' at '%s'." ),
525 wx_filename.GetFullName(),
526 lock->GetUsername(),
527 lock->GetHostname() );
528
529 if( !AskOverrideLock( this, msg ) )
530 return false;
531
532 lock->OverrideLock();
533 }
534
535 if( IsContentModified() )
536 {
537 if( !HandleUnsavedChanges( this, _( "The current PCB has been modified. Save changes?" ),
538 [&]() -> bool
539 {
540 return SavePcbFile( GetBoard()->GetFileName() );
541 } ) )
542 {
543 return false;
544 }
545 }
546
547 wxFileName pro = fullFileName;
548 pro.SetExt( FILEEXT::ProjectFileExtension );
549
550 bool is_new = !wxFileName::IsFileReadable( fullFileName );
551
552 // If its a non-existent PCB and caller thinks it exists
553 if( is_new && !( aCtl & KICTL_CREATE ) )
554 {
555 // notify user that fullFileName does not exist, ask if user wants to create it.
556 msg.Printf( _( "PCB '%s' does not exist. Do you wish to create it?" ), fullFileName );
557
558 if( !IsOK( this, msg ) )
559 return false;
560 }
561
562 // Get rid of any existing warnings about the old board
563 GetInfoBar()->Dismiss();
564
565 WX_PROGRESS_REPORTER progressReporter( this, is_new ? _( "Create PCB" ) : _( "Load PCB" ), 1,
566 PR_CAN_ABORT );
567
568 // No save prompt (we already prompted above), and only reset to a new blank board if new
569 Clear_Pcb( false, !is_new );
570
572
573 if( !is_new )
574 pluginType = PCB_IO_MGR::FindPluginTypeFromBoardPath( fullFileName, aCtl );
575
576 if( pluginType == PCB_IO_MGR::FILE_TYPE_NONE )
577 {
578 progressReporter.Hide();
579 DisplayErrorMessage( this, _( "File format is not supported" ), wxEmptyString );
580 return false;
581 }
582
583 bool converted = pluginType != PCB_IO_MGR::LEGACY && pluginType != PCB_IO_MGR::KICAD_SEXP;
584
585 // Loading a project should only be done under carefully considered circumstances.
586
587 // The calling code should know not to ask me here to change projects unless
588 // it knows what consequences that will have on other KIFACEs running and using
589 // this same PROJECT. It can be very harmful if that calling code is stupid.
591 bool setProject;
592
593 if( Kiface().IsSingle() || !( aCtl & KICTL_NONKICAD_ONLY ) )
594 setProject = pro.GetFullPath() != mgr->Prj().GetProjectFullName();
595 else
596 setProject = Prj().GetProjectFullName().IsEmpty();
597
598 if( setProject )
599 {
600 // calls SaveProject
602
604 mgr->UnloadProject( &mgr->Prj() );
605
606 mgr->LoadProject( pro.GetFullPath() );
607
608 // Do not allow saving a project if one doesn't exist. This normally happens if we are
609 // opening a board that has been moved from its project folder.
610 // For converted projects, we don't want to set the read-only flag because we want a
611 // project to be saved for the new file in case things like netclasses got migrated.
612 Prj().SetReadOnly( !pro.Exists() && !converted );
613 }
614
615 // Clear the cache footprint list which may be project specific
616 GFootprintList.Clear();
617
618 if( is_new )
619 {
620 // Link the existing blank board to the new project
621 GetBoard()->SetProject( &Prj() );
622
623 GetBoard()->SetFileName( fullFileName );
624
625 OnModify();
626 }
627 else
628 {
629 BOARD* loadedBoard = nullptr; // it will be set to non-NULL if loaded OK
631
632 if( LAYER_MAPPABLE_PLUGIN* mappable_pi = dynamic_cast<LAYER_MAPPABLE_PLUGIN*>( pi.get() ) )
633 {
634 mappable_pi->RegisterCallback( std::bind( DIALOG_MAP_LAYERS::RunModal,
635 this, std::placeholders::_1 ) );
636 }
637
638 if( PROJECT_CHOOSER_PLUGIN* chooser_pi = dynamic_cast<PROJECT_CHOOSER_PLUGIN*>( pi.get() ) )
639 {
640 chooser_pi->RegisterCallback( std::bind( DIALOG_IMPORT_CHOOSE_PROJECT::RunModal,
641 this,
642 std::placeholders::_1 ) );
643 }
644
645 if( ( aCtl & KICTL_REVERT ) )
646 {
647 DeleteAutoSaveFile( fullFileName );
648 }
649 else
650 {
651 // This will rename the file if there is an autosave and the user wants to recover
652 CheckForAutoSaveFile( fullFileName );
653 }
654
655 DIALOG_HTML_REPORTER errorReporter( this );
656 bool failedLoad = false;
657
658 try
659 {
660 if( pi == nullptr )
661 {
662 // There was no plugin found, e.g. due to invalid file extension, file header,...
663 THROW_IO_ERROR( _( "File format is not supported" ) );
664 }
665
666 std::map<std::string, UTF8> props;
667
669 props.insert( m_importProperties->begin(), m_importProperties->end() );
670
671 // PCB_IO_EAGLE can use this info to center the BOARD, but it does not yet.
672 props["page_width"] = std::to_string( GetPageSizeIU().x );
673 props["page_height"] = std::to_string( GetPageSizeIU().y );
674
675 pi->SetQueryUserCallback(
676 [&]( wxString aTitle, int aIcon, wxString aMessage, wxString aAction ) -> bool
677 {
678 KIDIALOG dlg( nullptr, aMessage, aTitle, wxOK | wxCANCEL | aIcon );
679
680 if( !aAction.IsEmpty() )
681 dlg.SetOKLabel( aAction );
682
683 dlg.DoNotShowCheckbox( aMessage, 0 );
684
685 return dlg.ShowModal() == wxID_OK;
686 } );
687
688#if USE_INSTRUMENTATION
689 // measure the time to load a BOARD.
690 int64_t startTime = GetRunningMicroSecs();
691#endif
692 if( config()->m_System.show_import_issues )
693 pi->SetReporter( errorReporter.m_Reporter );
694 else
695 pi->SetReporter( &NULL_REPORTER::GetInstance() );
696
697 pi->SetProgressReporter( &progressReporter );
698 loadedBoard = pi->LoadBoard( fullFileName, nullptr, &props, &Prj() );
699
700#if USE_INSTRUMENTATION
701 int64_t stopTime = GetRunningMicroSecs();
702 printf( "PCB_IO::Load(): %u usecs\n", stopTime - startTime );
703#endif
704 }
705 catch( const FUTURE_FORMAT_ERROR& ffe )
706 {
707 msg.Printf( _( "Error loading PCB '%s'." ), fullFileName );
708 progressReporter.Hide();
709 DisplayErrorMessage( this, msg, ffe.Problem() );
710
711 failedLoad = true;
712 }
713 catch( const IO_ERROR& ioe )
714 {
715 if( ioe.Problem() != wxT( "CANCEL" ) )
716 {
717 msg.Printf( _( "Error loading PCB '%s'." ), fullFileName );
718 progressReporter.Hide();
719 DisplayErrorMessage( this, msg, ioe.What() );
720 }
721
722 failedLoad = true;
723 }
724 catch( const std::bad_alloc& )
725 {
726 msg.Printf( _( "Memory exhausted loading PCB '%s'" ), fullFileName );
727 progressReporter.Hide();
728 DisplayErrorMessage( this, msg, wxEmptyString );
729
730 failedLoad = true;
731 }
732
733 if( failedLoad || !loadedBoard )
734 {
735 // We didn't create a new blank board above, so do that now
736 Clear_Pcb( false );
737
738 return false;
739 }
740
741 // This fixes a focus issue after the progress reporter is done on GTK. It shouldn't
742 // cause any issues on macOS and Windows. If it does, it will have to be conditionally
743 // compiled.
744 Raise();
745
746 if( errorReporter.m_Reporter->HasMessage() )
747 {
748 errorReporter.m_Reporter->Flush(); // Build HTML messages
749 errorReporter.ShowModal();
750 }
751
752 // Skip (possibly expensive) connectivity build here; we build it below after load
753 SetBoard( loadedBoard, false, &progressReporter );
754
755 if( GFootprintList.GetCount() == 0 )
756 GFootprintList.ReadCacheFromFile( Prj().GetProjectPath() + wxT( "fp-info-cache" ) );
757
758 if( loadedBoard->m_LegacyDesignSettingsLoaded )
759 {
760 Prj().SetReadOnly( false );
761
762 // Before we had a copper edge clearance setting, the edge line widths could be used
763 // as a kludge to control them. So if there's no setting then infer it from the
764 // edge widths.
765 if( !loadedBoard->m_LegacyCopperEdgeClearanceLoaded )
766 {
767 // Do not show the inferred edge clearance warning dialog when loading third
768 // party boards. For some reason the dialog completely hangs all of KiCad and
769 // the imported board cannot be saved.
770 int edgeClearance = inferLegacyEdgeClearance( loadedBoard, !converted );
771 loadedBoard->GetDesignSettings().m_CopperEdgeClearance = edgeClearance;
772 }
773
774 // On save; design settings will be removed from the board
775 loadedBoard->SetModified();
776 }
777
778 // Move legacy view settings to local project settings
779 if( !loadedBoard->m_LegacyVisibleLayers.test( Rescue ) )
780 {
782 loadedBoard->SetModified();
783 }
784
786 {
788 loadedBoard->SetModified();
789 }
790
791 if( !loadedBoard->SynchronizeComponentClasses( std::unordered_set<wxString>() ) )
792 {
793 m_infoBar->RemoveAllButtons();
794 m_infoBar->AddCloseButton();
795 m_infoBar->ShowMessage( _( "Could not load component class assignment rules" ),
796 wxICON_WARNING, WX_INFOBAR::MESSAGE_TYPE::GENERIC );
797 }
798
799 // we should not ask PCB_IOs to do these items:
800 loadedBoard->BuildListOfNets();
801 m_toolManager->RunAction( PCB_ACTIONS::repairBoard, true);
803
804 if( loadedBoard->IsModified() )
805 OnModify();
806 else
807 GetScreen()->SetContentModified( false );
808
809 if( ( pluginType == PCB_IO_MGR::LEGACY )
810 || ( pluginType == PCB_IO_MGR::KICAD_SEXP
812 && loadedBoard->GetGenerator().Lower() != wxT( "gerbview" ) ) )
813 {
814 m_infoBar->RemoveAllButtons();
815 m_infoBar->AddCloseButton();
816 m_infoBar->ShowMessage( _( "This file was created by an older version of KiCad. "
817 "It will be converted to the new format when saved." ),
819 }
820
821 // Import footprints into a project-specific library
822 //==================================================
823 // TODO: This should be refactored out of here into somewhere specific to the Project Import
824 // E.g. KICAD_MANAGER_FRAME::ImportNonKiCadProject
825 if( aCtl & KICTL_IMPORT_LIB )
826 {
827 wxFileName loadedBoardFn( fullFileName );
828 wxString libNickName = loadedBoardFn.GetName();
829
830 // Extract a footprint library from the design and add it to the fp-lib-table
831 // The footprints are saved in a new .pretty library.
832 // If this library already exists, all previous footprints will be deleted
833 std::vector<FOOTPRINT*> loadedFootprints = pi->GetImportedCachedLibraryFootprints();
834 wxString newLibPath = CreateNewProjectLibrary( _( "New Footprint Library" ),
835 libNickName );
836
837 // Only create the new library if CreateNewLibrary succeeded (note that this fails if
838 // the library already exists and the user aborts after seeing the warning message
839 // which prompts the user to continue with overwrite or abort)
840 if( newLibPath.Length() > 0 )
841 {
843
844 for( FOOTPRINT* footprint : loadedFootprints )
845 {
846 try
847 {
848 if( !footprint->GetFPID().GetLibItemName().empty() ) // Handle old boards.
849 {
850 footprint->SetReference( "REF**" );
851 piSexpr->FootprintSave( newLibPath, footprint );
852 delete footprint;
853 }
854 }
855 catch( const IO_ERROR& ioe )
856 {
857 wxLogError( _( "Error saving footprint %s to project specific library." )
858 + wxS( "\n%s" ),
859 footprint->GetFPID().GetUniStringLibItemName(),
860 ioe.What() );
861 }
862 }
863
865 const wxString& project_env = PROJECT_VAR_NAME;
866 wxString rel_path, env_path;
867
868 wxASSERT_MSG( wxGetEnv( project_env, &env_path ),
869 wxT( "There is no project variable?" ) );
870
871 wxString result( newLibPath );
872
873 if( result.Replace( env_path, wxT( "$(" ) + project_env + wxT( ")" ) ) )
874 rel_path = result;
875
876 FP_LIB_TABLE_ROW* row = new FP_LIB_TABLE_ROW( libNickName, rel_path,
877 wxT( "KiCad" ), wxEmptyString );
878 prjlibtable->InsertRow( row );
879
880 wxString tblName = Prj().FootprintLibTblName();
881
882 try
883 {
884 PROJECT_PCB::PcbFootprintLibs( &Prj() )->Save( tblName );
885 }
886 catch( const IO_ERROR& ioe )
887 {
888 wxLogError( _( "Error saving project specific footprint library table." )
889 + wxS( "\n%s" ),
890 ioe.What() );
891 }
892
893 // Update footprint LIB_IDs to point to the just imported library
894 for( FOOTPRINT* footprint : GetBoard()->Footprints() )
895 {
896 LIB_ID libId = footprint->GetFPID();
897
898 if( libId.GetLibItemName().empty() )
899 continue;
900
901 libId.SetLibNickname( libNickName );
902 footprint->SetFPID( libId );
903 }
904 }
905 }
906 }
907
908 {
909 wxFileName fn;
910
911 fn.SetPath( Prj().GetProjectPath() );
912 fn.SetName( Prj().GetProjectName() );
914
915 wxString fname = fn.GetFullPath();
916
917 fname.Replace( WIN_STRING_DIR_SEP, UNIX_STRING_DIR_SEP );
918
919 GetBoard()->SetFileName( fname );
920 }
921
922 // Lock the file newly opened:
923 m_file_checker.reset( lock.release() );
924
925 if( !converted )
926 UpdateFileHistory( GetBoard()->GetFileName() );
927
928 std::vector<ZONE*> toFill;
929
930 // Rebuild list of nets (full ratsnest rebuild)
931 GetBoard()->BuildConnectivity( &progressReporter );
932
933 // Load project settings after setting up board; some of them depend on the nets list
936
937 // Resolve DRC exclusions after project settings are loaded
938 ResolveDRCExclusions( true );
939
940 // Initialise caches used by component classes
942
943 // Initialise time domain tuning caches
945
946 // Syncs the UI (appearance panel, etc) with the loaded board and project
948
949 // Refresh the 3D view, if any
950 EDA_3D_VIEWER_FRAME* draw3DFrame = Get3DViewerFrame();
951
952 if( draw3DFrame )
953 draw3DFrame->NewDisplay();
954#if 0 && defined(DEBUG)
955 // Output the board object tree to stdout, but please run from command prompt:
956 GetBoard()->Show( 0, std::cout );
957#endif
958
959 // from EDA_APPL which was first loaded BOARD only:
960 {
961 /* For an obscure reason the focus is lost after loading a board file
962 * when starting up the process.
963 * (seems due to the recreation of the layer manager after loading the file)
964 * Give focus to main window and Drawpanel
965 * must be done for these 2 windows (for an obscure reason ...)
966 * Linux specific
967 * This is more a workaround than a fix.
968 */
969 SetFocus();
970 GetCanvas()->SetFocus();
971 }
972
973 return true;
974}
975
976
977bool PCB_EDIT_FRAME::SavePcbFile( const wxString& aFileName, bool addToHistory,
978 bool aChangeProject )
979{
980 // please, keep it simple. prompting goes elsewhere.
981 wxFileName pcbFileName = aFileName;
982
983 if( pcbFileName.GetExt() == FILEEXT::LegacyPcbFileExtension )
984 pcbFileName.SetExt( FILEEXT::KiCadPcbFileExtension );
985
986 // Write through symlinks, don't replace them
988
989 if( !IsWritable( pcbFileName ) )
990 {
991 wxString msg = wxString::Format( _( "Insufficient permissions to write file '%s'." ),
992 pcbFileName.GetFullPath() );
993
994 DisplayError( this, msg );
995 return false;
996 }
997
998 // TODO: these will break if we ever go multi-board
999 wxFileName projectFile( pcbFileName );
1000 wxFileName rulesFile( pcbFileName );
1001 wxString msg;
1002
1003 projectFile.SetExt( FILEEXT::ProjectFileExtension );
1004 rulesFile.SetExt( FILEEXT::DesignRulesFileExtension );
1005
1006 if( projectFile.FileExists() )
1007 {
1009 }
1010 else if( aChangeProject )
1011 {
1012 Prj().SetReadOnly( false );
1013 GetSettingsManager()->SaveProjectAs( projectFile.GetFullPath() );
1014 }
1015
1016 wxFileName currentRules( GetDesignRulesPath() );
1017
1018 if( currentRules.FileExists() && !rulesFile.FileExists() && aChangeProject )
1019 KiCopyFile( currentRules.GetFullPath(), rulesFile.GetFullPath(), msg );
1020
1021 if( !msg.IsEmpty() )
1022 {
1023 DisplayError( this, wxString::Format( _( "Error saving custom rules file '%s'." ),
1024 rulesFile.GetFullPath() ) );
1025 }
1026
1027 if( projectFile.FileExists() )
1028 {
1029 // Save various DRC parameters, such as violation severities (which may have been
1030 // edited via the DRC dialog as well as the Board Setup dialog), DRC exclusions, etc.
1032
1035 }
1036
1037 wxString upperTxt;
1038 wxString lowerTxt;
1039
1040 try
1041 {
1043
1044 pi->SaveBoard( pcbFileName.GetFullPath(), GetBoard(), nullptr );
1045 }
1046 catch( const IO_ERROR& ioe )
1047 {
1048 DisplayError( this, wxString::Format( _( "Error saving board file '%s'.\n%s" ),
1049 pcbFileName.GetFullPath(),
1050 ioe.What() ) );
1051 return false;
1052 }
1053
1054 if( !Kiface().IsSingle() )
1055 {
1056 WX_STRING_REPORTER backupReporter;
1057
1058 if( !GetSettingsManager()->TriggerBackupIfNeeded( backupReporter ) )
1059 {
1060 upperTxt = backupReporter.GetMessages();
1061 SetStatusText( upperTxt, 1 );
1062 }
1063 }
1064
1065 GetBoard()->SetFileName( pcbFileName.GetFullPath() );
1066
1067 // Update the lock in case it was a Save As
1068 LockFile( pcbFileName.GetFullPath() );
1069
1070 // Put the saved file in File History if requested
1071 if( addToHistory )
1072 UpdateFileHistory( GetBoard()->GetFileName() );
1073
1074 // Delete auto save file on successful save.
1075 wxFileName autoSaveFileName = pcbFileName;
1076
1077 autoSaveFileName.SetName( FILEEXT::AutoSaveFilePrefix + pcbFileName.GetName() );
1078
1079 if( autoSaveFileName.FileExists() )
1080 wxRemoveFile( autoSaveFileName.GetFullPath() );
1081
1082 lowerTxt.Printf( _( "File '%s' saved." ), pcbFileName.GetFullPath() );
1083
1084 SetStatusText( lowerTxt, 0 );
1085
1086 // Get rid of the old version conversion warning, or any other dismissable warning :)
1087 if( m_infoBar->GetMessageType() == WX_INFOBAR::MESSAGE_TYPE::OUTDATED_SAVE )
1088 m_infoBar->Dismiss();
1089
1090 if( m_infoBar->IsShownOnScreen() && m_infoBar->HasCloseButton() )
1091 m_infoBar->Dismiss();
1092
1093 GetScreen()->SetContentModified( false );
1094 UpdateTitle();
1096 return true;
1097}
1098
1099
1100bool PCB_EDIT_FRAME::SavePcbCopy( const wxString& aFileName, bool aCreateProject, bool aHeadless )
1101{
1102 wxFileName pcbFileName( aFileName );
1103
1104 if( !IsWritable( pcbFileName ) )
1105 {
1106 if( !aHeadless )
1107 {
1108 DisplayError( this, wxString::Format( _( "Insufficient permissions to write file '%s'." ),
1109 pcbFileName.GetFullPath() ) );
1110 }
1111 return false;
1112 }
1113
1114 // Save various DRC parameters, such as violation severities (which may have been
1115 // edited via the DRC dialog as well as the Board Setup dialog), DRC exclusions, etc.
1117
1119
1120 try
1121 {
1123
1124 wxASSERT( pcbFileName.IsAbsolute() );
1125
1126 pi->SaveBoard( pcbFileName.GetFullPath(), GetBoard(), nullptr );
1127 }
1128 catch( const IO_ERROR& ioe )
1129 {
1130 if( !aHeadless )
1131 {
1132 DisplayError( this, wxString::Format( _( "Error saving board file '%s'.\n%s" ),
1133 pcbFileName.GetFullPath(),
1134 ioe.What() ) );
1135 }
1136
1137 return false;
1138 }
1139
1140 wxFileName projectFile( pcbFileName );
1141 wxFileName rulesFile( pcbFileName );
1142 wxString msg;
1143
1144 projectFile.SetExt( FILEEXT::ProjectFileExtension );
1145 rulesFile.SetExt( FILEEXT::DesignRulesFileExtension );
1146
1147 if( aCreateProject && !projectFile.FileExists() )
1148 GetSettingsManager()->SaveProjectCopy( projectFile.GetFullPath() );
1149
1150 wxFileName currentRules( GetDesignRulesPath() );
1151
1152 if( aCreateProject && currentRules.FileExists() && !rulesFile.FileExists() )
1153 KiCopyFile( currentRules.GetFullPath(), rulesFile.GetFullPath(), msg );
1154
1155 if( !msg.IsEmpty() && !aHeadless )
1156 {
1157 DisplayError( this, wxString::Format( _( "Error saving custom rules file '%s'." ),
1158 rulesFile.GetFullPath() ) );
1159 }
1160
1161 return true;
1162}
1163
1164
1166{
1167 wxFileName tmpFileName;
1168
1169 // Don't run autosave if content has not been modified
1170 if( !IsContentModified() )
1171 return true;
1172
1173 wxString title = GetTitle(); // Save frame title, that can be modified by the save process
1174
1175 if( GetBoard()->GetFileName().IsEmpty() )
1176 {
1177 tmpFileName = wxFileName( PATHS::GetDefaultUserProjectsPath(), NAMELESS_PROJECT,
1179 GetBoard()->SetFileName( tmpFileName.GetFullPath() );
1180 }
1181 else
1182 {
1183 tmpFileName = Prj().AbsolutePath( GetBoard()->GetFileName() );
1184 }
1185
1186 wxFileName autoSaveFileName = tmpFileName;
1187
1188 // Auto save file name is the board file name prepended with autosaveFilePrefix string.
1189 autoSaveFileName.SetName( FILEEXT::AutoSaveFilePrefix + autoSaveFileName.GetName() );
1190
1191 if( !autoSaveFileName.IsOk() )
1192 return false;
1193
1194 // If the board file path is not writable, try writing to a platform specific temp file
1195 // path. If that path isn't writable, give up.
1196 if( !autoSaveFileName.IsDirWritable() )
1197 {
1199 {
1200 DisplayError( this, wxString::Format(
1201 _( "Could not autosave files to read-only folder: '%s'" ),
1202 autoSaveFileName.GetPath() ) );
1204 }
1205
1206 autoSaveFileName.SetPath( wxFileName::GetTempDir() );
1207
1208 if( !autoSaveFileName.IsOk() || !autoSaveFileName.IsDirWritable() )
1209 return false;
1210 }
1211
1212 if( !IsWritable( autoSaveFileName, false ) )
1213 {
1215 {
1216 DisplayError( this, wxString::Format(
1217 _( "Could not autosave files to read-only folder: '%s'" ),
1218 autoSaveFileName.GetPath() ) );
1220 }
1221
1222 return false;
1223 }
1224
1225 wxLogTrace( traceAutoSave,
1226 wxT( "Creating auto save file <" ) + autoSaveFileName.GetFullPath() + wxT( ">" ) );
1227
1228 if( SavePcbFile( autoSaveFileName.GetFullPath(), false, false ) )
1229 {
1231 GetBoard()->SetFileName( tmpFileName.GetFullPath() );
1232 UpdateTitle();
1233 m_autoSaveRequired = false;
1234 m_autoSavePending = false;
1235
1236 if( !Kiface().IsSingle() &&
1237 GetSettingsManager()->GetCommonSettings()->m_Backup.backup_on_autosave )
1238 {
1240 }
1241
1242 SetTitle( title ); // Restore initial frame title
1243
1244 return true;
1245 }
1246
1247 GetBoard()->SetFileName( tmpFileName.GetFullPath() );
1248
1249 SetTitle( title ); // Restore initial frame title
1250
1251 return false;
1252}
1253
1254
1255bool PCB_EDIT_FRAME::importFile( const wxString& aFileName, int aFileType,
1256 const std::map<std::string, UTF8>* aProperties )
1257{
1258 NULLER raiiNuller( (void*&) m_importProperties );
1259
1260 m_importProperties = aProperties;
1261
1262 switch( (PCB_IO_MGR::PCB_FILE_T) aFileType )
1263 {
1265 case PCB_IO_MGR::EAGLE:
1268 return OpenProjectFiles( std::vector<wxString>( 1, aFileName ), KICTL_NONKICAD_ONLY | KICTL_IMPORT_LIB );
1269
1274 return OpenProjectFiles( std::vector<wxString>( 1, aFileName ), KICTL_NONKICAD_ONLY );
1275
1276 default:
1277 return false;
1278 }
1279}
1280
1281
1283{
1285
1286 dlg.ShowModal();
1287
1288 return 0;
1289}
1290
1291
1293{
1295
1296 if( dlg.ShowModal() != wxID_OK )
1297 return 0;
1298
1300
1302 job.m_filename = m_frame->GetBoard()->GetFileName();
1304
1305 job.m_precision = dlg.GetPrecision();
1308
1309 WX_PROGRESS_REPORTER progressReporter( m_frame, _( "Generate ODB++ Files" ), 3, PR_CAN_ABORT );
1310 WX_STRING_REPORTER reporter;
1311
1312 DIALOG_EXPORT_ODBPP::GenerateODBPPFiles( job, m_frame->GetBoard(), m_frame, &progressReporter, &reporter );
1313
1314 if( reporter.HasMessage() )
1315 DisplayError( m_frame, reporter.GetMessages() );
1316
1317 return 0;
1318}
const char * name
KIFACE_BASE & Kiface()
Global KIFACE_BASE "get" accessor.
void SetContentModified(bool aModified=true)
Definition base_screen.h:59
int RescueAutosave(const TOOL_EVENT &aEvent)
int GenerateODBPPFiles(const TOOL_EVENT &aEvent)
int New(const TOOL_EVENT &aEvent)
int Revert(const TOOL_EVENT &aEvent)
int GenIPC2581File(const TOOL_EVENT &aEvent)
int Open(const TOOL_EVENT &aEvent)
int OpenNonKicadBoard(const TOOL_EVENT &aEvent)
Information pertinent to a Pcbnew printed circuit board.
Definition board.h:317
bool m_LegacyDesignSettingsLoaded
True if the legacy board design settings were loaded from a file.
Definition board.h:406
GAL_SET m_LegacyVisibleItems
Definition board.h:403
LENGTH_DELAY_CALCULATION * GetLengthCalculation() const
Returns the track length calculator.
Definition board.h:1339
void BuildListOfNets()
Definition board.h:896
void SetFileName(const wxString &aFileName)
Definition board.h:352
bool BuildConnectivity(PROGRESS_REPORTER *aReporter=nullptr)
Build or rebuild the board connectivity database for the board, especially the list of connected item...
Definition board.cpp:188
void SynchronizeNetsAndNetClasses(bool aResetTrackAndViaSizes)
Copy NETCLASS info to each NET, based on NET membership in a NETCLASS.
Definition board.cpp:2287
LSET m_LegacyVisibleLayers
Visibility settings stored in board prior to 6.0, only used for loading legacy files.
Definition board.h:402
void SetProject(PROJECT *aProject, bool aReferenceOnly=false)
Link a board to a given project.
Definition board.cpp:198
int GetFileFormatVersionAtLoad() const
Definition board.h:426
const wxString & GetGenerator() const
Adds an item to the container.
Definition board.h:429
void ClearProject()
Definition board.cpp:236
BOARD_DESIGN_SETTINGS & GetDesignSettings() const
Definition board.cpp:1040
void SynchronizeProperties()
Copy the current project's text variables into the boards property cache.
Definition board.cpp:2274
COMPONENT_CLASS_MANAGER & GetComponentClassManager()
Gets the component class manager.
Definition board.h:1344
bool SynchronizeComponentClasses(const std::unordered_set< wxString > &aNewSheetPaths) const
Copy component class / component class generator information from the project settings.
Definition board.cpp:2317
bool m_LegacyCopperEdgeClearanceLoaded
Definition board.h:407
int GetCount() const
Return the number of objects in the list.
Definition collector.h:83
void RebuildRequiredCaches(FOOTPRINT *aFootprint=nullptr) const
Rebuilds any caches that may be required by custom assignment rules.
static void GenerateODBPPFiles(const JOB_EXPORT_PCB_ODB &aJob, BOARD *aBoard, PCB_EDIT_FRAME *aParentFrame=nullptr, PROGRESS_REPORTER *aProgressReporter=nullptr, REPORTER *aErrorReporter=nullptr)
wxString GetOutputPath() const
wxString GetUnitsString() const
Class DIALOG_HTML_REPORTER.
WX_HTML_REPORT_BOX * m_Reporter
static std::vector< IMPORT_PROJECT_DESC > RunModal(wxWindow *aParent, const std::vector< IMPORT_PROJECT_DESC > &aProjectDesc)
Create and show a dialog (modal) and returns the data from it after completion.
static std::map< wxString, PCB_LAYER_ID > RunModal(wxWindow *aParent, const std::vector< INPUT_LAYER_DESC > &aLayerDesc)
Create and show a dialog (modal) and returns the data from it after completion.
int ShowModal() override
Create and handle a window for the 3d viewer connected to a Kiway and a pcbboard.
void NewDisplay(bool aForceImmediateRedraw=false)
Reload and refresh (rebuild) the 3D scene.
virtual APP_SETTINGS_BASE * config() const
Return the settings object used in SaveSettings(), and is overloaded in KICAD_MANAGER_FRAME.
virtual void CheckForAutoSaveFile(const wxFileName &aFileName)
Check if an auto save file exists for aFileName and takes the appropriate action depending on the use...
bool m_autoSavePermissionError
WX_INFOBAR * m_infoBar
void UpdateFileHistory(const wxString &FullFileName, FILE_HISTORY *aFileHistory=nullptr)
Update the list of recently opened files.
wxString GetMruPath() const
virtual void DeleteAutoSaveFile(const wxFileName &aFileName)
bool IsWritable(const wxFileName &aFileName, bool aVerbose=true)
Check if aFileName can be written.
virtual void ClearFileHistory()
Remove all files from the file history.
wxString GetFileFromHistory(int cmdId, const wxString &type, FILE_HISTORY *aFileHistory=nullptr)
Fetch the file name from the file history list.
void SetMruPath(const wxString &aPath)
WX_INFOBAR * GetInfoBar()
std::unique_ptr< LOCKFILE > m_file_checker
bool LockFile(const wxString &aFileName)
Mark a schematic file as being in use.
void SetFocus() override
void SetModified()
Definition eda_item.cpp:100
bool IsModified() const
Definition eda_item.h:123
bool GetCreateNewProject() const
Gets the selected state of the copy subsheets option.
Hold a record identifying a library accessed by the appropriate footprint library #PLUGIN object in t...
static const std::vector< KICAD_T > AllBoardItems
A scan list for all editable board items.
Definition collectors.h:41
Hold an error message and may be used when throwing exceptions containing meaningful error messages.
virtual const wxString What() const
A composite of Problem() and Where()
virtual const wxString Problem() const
what was the problem?
ODB_COMPRESSION m_compressionMode
void SetConfiguredOutputPath(const wxString &aPath)
Sets the configured output path for the job, this path is always saved to file.
Definition job.cpp:153
Helper class to create more flexible dialogs, including 'do not show again' checkbox handling.
Definition kidialog.h:42
void DoNotShowCheckbox(wxString file, int line)
Shows the 'do not show again' checkbox.
Definition kidialog.cpp:55
int ShowModal() override
Definition kidialog.cpp:93
PROJECT & Prj() const
Return a reference to the PROJECT associated with this KIWAY.
Plugin class for import plugins that support remappable layers.
void SynchronizeTimeDomainProperties() const
Ensure time domain properties provider is synced with board / project settings if required.
A logical library item identifier and consists of various portions much like a URI.
Definition lib_id.h:49
int SetLibNickname(const UTF8 &aLibNickname)
Override the logical library name portion of the LIB_ID to aLibNickname.
Definition lib_id.cpp:100
const UTF8 & GetLibItemName() const
Definition lib_id.h:102
bool InsertRow(LIB_TABLE_ROW *aRow, bool doReplace=false)
Adds aRow if it does not already exist or if doReplace is true.
void Save(const wxString &aFileName) const
Write this library table to aFileName in s-expression form.
Definition raii.h:38
static REPORTER & GetInstance()
Definition reporter.cpp:96
static wxString GetDefaultUserProjectsPath()
Gets the default path we point users to create projects.
Definition paths.cpp:136
static TOOL_ACTION repairBoard
static TOOL_ACTION rehatchShapes
wxString GetDesignRulesPath()
Return the absolute path to the design rules file for the currently-loaded board.
wxString CreateNewProjectLibrary(const wxString &aDialogTitle, const wxString &aLibName)
const VECTOR2I GetPageSizeIU() const override
Works off of GetPageSettings() to return the size of the paper page in the internal units of this par...
PCB_DRAW_PANEL_GAL * GetCanvas() const override
Return a pointer to GAL-based canvas of given EDA draw frame.
PCB_SCREEN * GetScreen() const override
Return a pointer to a BASE_SCREEN or one of its derivatives.
BOARD * GetBoard() const
EDA_3D_VIEWER_FRAME * Get3DViewerFrame()
virtual void UpdateStatusBar() override
Update the status bar information.
The main frame for Pcbnew.
void LoadDrawingSheet()
Load the drawing sheet file.
void ResolveDRCExclusions(bool aCreateMarkers)
If aCreateMarkers then create DRC exclusion markers from the serialized data.
void SetBoard(BOARD *aBoard, PROGRESS_REPORTER *aReporter=nullptr) override
Set the #m_Pcb member in such as way as to ensure deleting any previous BOARD.
void OnModify() override
Must be called after a board change to set the modified flag.
bool DoAutoSave()
Perform auto save when the board has been modified and not saved within the auto save interval.
void OnClearFileHistory(wxCommandEvent &aEvent)
bool SaveBoard(bool aSaveAs=false, bool aSaveCopy=false)
bool OpenProjectFiles(const std::vector< wxString > &aFileSet, int aCtl=0) override
Load a KiCad board (.kicad_pcb) from aFileName.
void SaveProjectLocalSettings() override
Save changes to the project local settings.
bool SavePcbCopy(const wxString &aFileName, bool aCreateProject=false, bool aHeadless=false)
Write the board data structures to aFileName.
bool IsContentModified() const override
Get if the current board has been modified but not saved.
bool LoadProjectSettings()
Load the current project's file configuration settings which are pertinent to this PCB_EDIT_FRAME ins...
bool Clear_Pcb(bool doAskAboutUnsavedChanges, bool aFinal=false)
Delete all and reinitialize the current board.
Definition initpcb.cpp:42
void OnBoardLoaded()
Update the state of the GUI after a new board is loaded or created.
void UpdateTitle()
Set the main window title bar text.
int inferLegacyEdgeClearance(BOARD *aBoard, bool aShowUserMsg=true)
const std::map< std::string, UTF8 > * m_importProperties
bool SavePcbFile(const wxString &aFileName, bool addToHistory=true, bool aChangeProject=true)
Write the board data structures to a aFileName.
bool importFile(const wxString &aFileName, int aFileType, const std::map< std::string, UTF8 > *aProperties=nullptr)
Load the given filename but sets the path to the current project path.
void saveProjectSettings() override
Save any design-related project settings associated with this frame.
void OnFileHistory(wxCommandEvent &event)
static PLUGIN_REGISTRY * Instance()
Definition pcb_io_mgr.h:94
static PCB_IO * PluginFind(PCB_FILE_T aFileType)
Return a #PLUGIN which the caller can use to import, export, save, or load design documents.
PCB_FILE_T
The set of file types that the PCB_IO_MGR knows about, and for which there has been a plugin written,...
Definition pcb_io_mgr.h:56
@ KICAD_SEXP
S-expression Pcbnew file format.
Definition pcb_io_mgr.h:58
@ ALTIUM_DESIGNER
Definition pcb_io_mgr.h:62
@ LEGACY
Legacy Pcbnew file formats prior to s-expression.
Definition pcb_io_mgr.h:59
@ ALTIUM_CIRCUIT_MAKER
Definition pcb_io_mgr.h:60
@ ALTIUM_CIRCUIT_STUDIO
Definition pcb_io_mgr.h:61
@ CADSTAR_PCB_ARCHIVE
Definition pcb_io_mgr.h:63
static PCB_FILE_T FindPluginTypeFromBoardPath(const wxString &aFileName, int aCtl=0)
Return a plugin type given a path for a board file.
Collect all BOARD_ITEM objects on a given layer.
Definition collectors.h:549
void Collect(BOARD_ITEM *aBoard, const std::vector< KICAD_T > &aTypes)
Test a BOARD_ITEM using this class's Inspector method, which does the collection.
void SetLayerId(PCB_LAYER_ID aLayerId)
Definition collectors.h:555
Plugin class for import plugins that support choosing a project.
LSET m_VisibleLayers
Board settings.
GAL_SET m_VisibleItems
The GAL layers (aka items) that are turned on for viewing (.
static FP_LIB_TABLE * PcbFootprintLibs(PROJECT *aProject)
Return the table of footprint libraries without Kiway.
virtual void SetReadOnly(bool aReadOnly=true)
Definition project.h:168
virtual const wxString GetProjectFullName() const
Return the full path and name of the project.
Definition project.cpp:156
virtual PROJECT_LOCAL_SETTINGS & GetLocalSettings() const
Definition project.h:210
virtual const wxString FootprintLibTblName() const
Returns the path and filename of this project's footprint library table.
Definition project.cpp:192
virtual const wxString AbsolutePath(const wxString &aFileName) const
Fix up aFileName if it is relative to the project's directory to be an absolute path and filename.
Definition project.cpp:386
virtual bool IsNullProject() const
Check if this project is a null project (i.e.
Definition project.cpp:180
virtual bool HasMessage() const
Returns true if any messages were reported.
Definition reporter.h:134
void SaveProjectAs(const wxString &aFullPath, PROJECT *aProject=nullptr)
Set the currently loaded project path and saves it (pointers remain valid).
void SaveProjectCopy(const wxString &aFullPath, PROJECT *aProject=nullptr)
Save a copy of the current project under the given path.
bool SaveProject(const wxString &aFullPath=wxEmptyString, PROJECT *aProject=nullptr)
Save a loaded project.
bool LoadProject(const wxString &aFullPath, bool aSetActive=true)
Load a project or sets up a new project with a specified path.
bool UnloadProject(PROJECT *aProject, bool aSave=true)
Save, unload and unregister the given PROJECT.
bool TriggerBackupIfNeeded(REPORTER &aReporter) const
Call BackupProject() if a new backup is needed according to the current backup policy.
PROJECT & Prj() const
A helper while we are not MDI-capable – return the one and only project.
TOOL_MANAGER * m_toolManager
Generic, UI-independent tool event.
Definition tool_event.h:171
An 8 bit string that is assuredly encoded in UTF8, and supplies special conversion support to and fro...
Definition utf8.h:72
bool empty() const
Definition utf8.h:110
static void ResolvePossibleSymlinks(wxFileName &aFilename)
void Flush()
Build the HTML messages page.
bool HasMessage() const override
Returns true if any messages were reported.
@ OUTDATED_SAVE
OUTDATED_SAVE Messages that should be cleared on save.
Definition wx_infobar.h:96
@ GENERIC
GENERIC Are messages that do not have special handling.
Definition wx_infobar.h:95
void Dismiss() override
Dismisses the infobar and updates the containing layout and AUI manager (if one is provided).
Multi-thread safe progress reporter dialog, intended for use of tasks that parallel reporting back of...
A wrapper for reporting to a wxString object.
Definition reporter.h:191
const wxString & GetMessages() const
Definition reporter.cpp:77
wxString EnsureFileExtension(const wxString &aFilename, const wxString &aExtension)
It's annoying to throw up nag dialogs when the extension isn't right.
Definition common.cpp:429
bool AskOverrideLock(wxWindow *aParent, const wxString &aMessage)
Display a dialog indicating the file is already open, with an option to reset the lock.
Definition confirm.cpp:42
bool IsOK(wxWindow *aParent, const wxString &aMessage)
Display a yes/no dialog with aMessage and returns the user response.
Definition confirm.cpp:251
void DisplayInfoMessage(wxWindow *aParent, const wxString &aMessage, const wxString &aExtraInfo)
Display an informational message box with aMessage.
Definition confirm.cpp:222
bool HandleUnsavedChanges(wxWindow *aParent, const wxString &aMessage, const std::function< bool()> &aSaveFunction)
Display a dialog with Save, Cancel and Discard Changes buttons.
Definition confirm.cpp:129
void DisplayErrorMessage(wxWindow *aParent, const wxString &aText, const wxString &aExtraInfo)
Display an error message with aMessage.
Definition confirm.cpp:194
void DisplayError(wxWindow *aParent, const wxString &aText)
Display an error or warning message box with aMessage.
Definition confirm.cpp:169
This file is part of the common library.
#define _(s)
Declaration of the eda_3d_viewer class.
FOOTPRINT_LIST_IMPL GFootprintList
The global footprint info table.
Definition cvpcb.cpp:156
void KiCopyFile(const wxString &aSrcPath, const wxString &aDestPath, wxString &aErrors)
Definition gestfich.cpp:290
#define WIN_STRING_DIR_SEP
Definition gestfich.h:38
#define UNIX_STRING_DIR_SEP
Definition gestfich.h:37
static const std::string ProjectFileExtension
static const std::string LegacyPcbFileExtension
static const std::string AutoSaveFilePrefix
static const std::string DesignRulesFileExtension
static const std::string KiCadPcbFileExtension
static wxString PcbFileWildcard()
const wxChar *const traceAutoSave
Flag to enable auto save feature debug tracing.
std::unique_ptr< T > IO_RELEASER
Helper to hold and release an IO_BASE object when exceptions are thrown.
Definition io_mgr.h:33
#define THROW_IO_ERROR(msg)
macro which captures the "call site" values of FILE_, __FUNCTION & LINE
PROJECT & Prj()
Definition kicad.cpp:612
#define KICTL_CREATE
caller thinks requested project files may not exist.
#define KICTL_REVERT
reverting to a previously-saved (KiCad) file.
#define KICTL_IMPORT_LIB
import all footprints into a project library.
#define KICTL_KICAD_ONLY
chosen file is from KiCad according to user
#define KICTL_NONKICAD_ONLY
chosen file is non-KiCad according to user
@ GAL_LAYER_ID_BITMASK_END
This is the end of the layers used for visibility bit masks in legacy board files.
Definition layer_ids.h:286
@ Edge_Cuts
Definition layer_ids.h:112
@ Rescue
Definition layer_ids.h:121
#define GAL_LAYER_INDEX(x)
Use this macro to convert a GAL layer to a 0-indexed offset from LAYER_VIAS.
Definition layer_ids.h:363
File locking utilities.
This file contains miscellaneous commonly used macros and functions.
bool RegisterApplicationRestart(const wxString &aCommandLine)
Registers the application for restart with the OS with the given command line string to pass as args.
Definition unix/app.cpp:65
#define SEXPR_BOARD_FILE_VERSION
Current s-expression file format version. 2 was the last legacy format version.
bool AskLoadBoardFileName(PCB_EDIT_FRAME *aParent, wxString *aFileName, int aCtl=0)
Show a wxFileDialog asking for a BOARD filename to open.
bool AskSaveBoardFileName(PCB_EDIT_FRAME *aParent, wxString *aFileName, bool *aCreateProject)
Put up a wxFileDialog asking for a BOARD filename to save.
SETTINGS_MANAGER * GetSettingsManager()
PGM_BASE & Pgm()
The global program "get" accessor.
Definition pgm_base.cpp:913
see class PGM_BASE
int64_t GetRunningMicroSecs()
An alternate way to calculate an elapsed time (in microsecondes) to class PROF_COUNTER.
#define PROJECT_VAR_NAME
A variable name whose value holds the current project directory.
Definition project.h:40
#define NAMELESS_PROJECT
default name for nameless projects
Definition project.h:43
int StrPrintf(std::string *result, const char *format,...)
This is like sprintf() but the output is appended to a std::string instead of to a character array.
Definition richio.cpp:71
bool show_import_issues
Stored value for "show import issues" when importing non-KiCad designs to this application.
Variant of PARSE_ERROR indicating that a syntax or related error was likely caused by a file generate...
Container that describes file type info.
Definition io_base.h:43
std::vector< std::string > m_FileExtensions
Filter used for file pickers if m_IsFile is true.
Definition io_base.h:47
bool m_CanRead
Whether the IO can read this file type.
Definition io_base.h:52
wxString result
Test unit parsing edge cases and error handling.
wxLogTrace helper definitions.
@ PCB_SHAPE_T
class PCB_SHAPE, a segment not on copper layers
Definition typeinfo.h:88
wxString AddFileExtListToFilter(const std::vector< std::string > &aExts)
Build the wildcard extension file dialog wildcard filter to add to the base message dialog.
wxString formatWildcardExt(const wxString &aWildcard)
Format wildcard extension to support case sensitive file dialogs.
Definition of file extensions used in Kicad.
#define PR_CAN_ABORT