The main KiCad project manager frame. More...

#include <kicad.h>

Inheritance diagram for KICAD_MANAGER_FRAME:

Classes
class	TERMINATE_HANDLER

Public Member Functions
	KICAD_MANAGER_FRAME (wxWindow *parent, const wxString &title, const wxPoint &pos, const wxSize &size)

	~KICAD_MANAGER_FRAME ()

void	OnCloseWindow (wxCloseEvent &Event)

void	OnSize (wxSizeEvent &event)

void	OnChangeIconsOptions (wxCommandEvent &event) override
	Select the current icons options in menus (or toolbars) in Kicad (the default for toolbars/menus is 26x26 pixels, and shows icons in menus). More...

void	OnLoadProject (wxCommandEvent &event)
	Load an exiting project (.pro) file. More...

void	OnCreateProjectFromTemplate (wxCommandEvent &event)
	Creates a new project folder, copy a template into this new folder. More...

void	OnNewProject (wxCommandEvent &aEvent)

void	OnSaveProject (wxCommandEvent &event)
	Save the project (.pro) file containing the top level configuration parameters. More...

void	OnArchiveFiles (wxCommandEvent &event)

void	OnUnarchiveFiles (wxCommandEvent &event)

void	OnRunEeschema (wxCommandEvent &event)

void	OnRunSchLibEditor (wxCommandEvent &event)

void	OnRunPcbNew (wxCommandEvent &event)

void	OnRunPcbFpEditor (wxCommandEvent &event)

void	OnRunGerbview (wxCommandEvent &event)

void	OnRunBitmapConverter (wxCommandEvent &event)

void	OnRunPcbCalculator (wxCommandEvent &event)

void	OnRunPageLayoutEditor (wxCommandEvent &event)

void	OnConfigurePaths (wxCommandEvent &aEvent)

void	OnOpenTextEditor (wxCommandEvent &event)

void	OnOpenFileInTextEditor (wxCommandEvent &event)

void	OnOpenFileInEditor (wxCommandEvent &event)

void	OnFileHistory (wxCommandEvent &event)

void	OnExit (wxCommandEvent &event)

void	Process_Preferences (wxCommandEvent &event)

void	Process_Config (wxCommandEvent &event)

void	ReCreateMenuBar () override
	(Re)Create the menubar More...

void	RecreateBaseHToolbar ()
	(Re)Create the horizontal toolbar More...

void	PrintMsg (const wxString &aText)
	Displays aText in the text panel. More...

void	PrintPrjInfo ()
	Prints the current working directory name and the projet name on the text panel. More...

void	ClearMsg ()
	Erase the text panel. More...

void	OnRefresh (wxCommandEvent &event)

void	OnSelectDefaultPdfBrowser (wxCommandEvent &event)

void	OnSelectPreferredPdfBrowser (wxCommandEvent &event)

void	OnUpdateDefaultPdfBrowser (wxUpdateUIEvent &event)

void	OnUpdatePreferredPdfBrowser (wxUpdateUIEvent &event)

void	OnUpdateRequiresProject (wxUpdateUIEvent &event)

void	CreateNewProject (const wxFileName &aProjectFileName)
	Creates a new project by setting up and initial project, schematic, and board files. More...

void	LoadProject (const wxFileName &aProjectFileName)

void	LoadSettings (wxConfigBase *aCfg) override
	Function LoadSettings loads common frame parameters from a configuration file. More...

void	SaveSettings (wxConfigBase *aCfg) override
	Function SaveSettings saves common frame parameters to a configuration data file. More...

void	Execute (wxWindow *frame, const wxString &execFile, wxString param=wxEmptyString)
	Open another KiCad application and logs a message. More...

void	OnChangeWatchedPaths (wxCommandEvent &aEvent)
	Called by sending a event with id = ID_INIT_WATCHED_PATHS rebuild the list of wahtched paths. More...

void	SetProjectFileName (const wxString &aFullProjectProFileName)

const wxString	GetProjectFileName ()

const wxString	SchFileName ()

const wxString	PcbFileName ()

const wxString	PcbLegacyFileName ()

void	ReCreateTreePrj ()

void	RunPcbNew (const wxString &aProjectBoardFileName)
	Call this only for a PCB associated with the current project. More...

void	RunEeschema (const wxString &aProjectSchematicFileName)
	Call this only for a SCH associated with the current project. More...

bool	ProcessEvent (wxEvent &aEvent) override
	Function ProcessEvent overrides the default process event handler to implement the auto save feature. More...

bool	Enable (bool enable) override

void	SetAutoSaveInterval (int aInterval)

int	GetAutoSaveInterval () const

bool	IsType (FRAME_T aType) const

void	GetKicadHelp (wxCommandEvent &event)

void	GetKicadContribute (wxCommandEvent &event)

void	GetKicadAbout (wxCommandEvent &event)

wxString	ConfigBaseName ()
	Function ConfigBaseName. More...

virtual void	SaveProjectSettings (bool aAskForSave)
	Function SaveProjectSettings saves changes to the project settings to the project (.pro) file. More...

virtual void	OnSelectPreferredEditor (wxCommandEvent &event)
	Function OnSelectPreferredEditor Open a dialog to select the editor that will used in KiCad to edit or display files (reports ... More...

int	ReadHotkeyConfig (struct EDA_HOTKEY_CONFIG *aDescList)
	Function ReadHotkeyConfig Read configuration data and fill the current hotkey list with hotkeys. More...

virtual int	WriteHotkeyConfig (struct EDA_HOTKEY_CONFIG aDescList, wxString aFullFileName=NULL)
	Function WriteHotkeyConfig Store the current hotkey list It is stored using the standard wxConfig mechanism or a file. More...

int	ReadHotkeyConfigFile (const wxString &aFilename, struct EDA_HOTKEY_CONFIG *aDescList)
	Function ReadHotkeyConfigFile Read an old configuration file (&ltfile&gt.key) and fill the current hotkey list with hotkeys. More...

void	ImportHotkeyConfigFromFile (EDA_HOTKEY_CONFIG *aDescList, const wxString &aDefaultShortname)
	Function ImportHotkeyConfigFromFile Prompt the user for an old hotkey file to read, and read it. More...

void	ExportHotkeyConfigToFile (EDA_HOTKEY_CONFIG *aDescList, const wxString &aDefaultShortname)
	Function ExportHotkeyConfigToFile Prompt the user for an old hotkey file to read, and read it. More...

wxString	GetFileFromHistory (int cmdId, const wxString &type, wxFileHistory *aFileHistory=NULL)
	Function GetFileFromHistory fetches the file name from the file history list. More...

void	UpdateFileHistory (const wxString &FullFileName, wxFileHistory *aFileHistory=NULL)
	Function UpdateFileHistory Updates the list of recently opened files. More...

void	SetMruPath (const wxString &aPath)

wxString	GetMruPath () const

bool	IsWritable (const wxFileName &aFileName)
	Function IsWritable checks if aFileName can be written. More...

void	CheckForAutoSaveFile (const wxFileName &aFileName, const wxString &aBackupFileExtension)
	Function CheckForAutoSaveFile checks if an auto save file exists for aFileName and takes the appropriate action depending on the user input. More...

virtual void	ShowChangedLanguage ()
	Function ShowChangedLanguage redraws the menus and what not in current language. More...

virtual void	ShowChangedIcons ()
	Function ShowChangedIcons redraws items menus after a icon was changed option. More...

void	AddMenuIconsOptions (wxMenu *MasterMenu)
	Function AddMenuIconsOptions creates a menu list for icons in menu and icon sizes choice, and add it as submenu to MasterMenu. More...

bool	PostCommandMenuEvent (int evt_type)
	Function PostCommandMenuEvent. More...

Protected Member Functions
void	onAutoSaveTimer (wxTimerEvent &aEvent)
	Function onAutoSaveTimer handles the auto save timer event. More...

virtual bool	isAutoSaveRequired () const
	Function autoSaveRequired returns the auto save status of the application. More...

virtual bool	doAutoSave ()
	Function doAutoSave should be overridden by the derived class to handle the auto save feature. More...

Protected Attributes
FRAME_T	m_Ident
	Id Type (pcb, schematic, library..) More...

wxPoint	m_FramePos

wxSize	m_FrameSize

wxString	m_configFrameName
	prefix used in config to identify some params (frame size...) if empty, the frame name defined in CTOR is used More...

wxAuiToolBar *	m_mainToolBar
	Standard horizontal Toolbar. More...

wxString	m_AboutTitle
	Name of program displayed in About. More...

wxAuiManager	m_auimgr

bool	m_hasAutoSave
	Flag to indicate if this frame supports auto save. More...

bool	m_autoSaveState
	Flag to indicate the last auto save state. More...

int	m_autoSaveInterval
	The auto save interval time in seconds. More...

wxTimer *	m_autoSaveTimer
	The timer used to implement the auto save feature;. More...

wxString	m_perspective
	wxAuiManager perspective. More...

wxString	m_mruPath
	Most recently used path. More...

Private Member Functions
wxConfigBase *	config () override
	Function config returns the wxConfigBase used in SaveSettings(), and is overloaded in KICAD_MANAGER_FRAME. More...

const SEARCH_STACK &	sys_search () override
	Function sys_search returns a SEARCH_STACK pertaining to entire program, and is overloaded in KICAD_MANAGER_FRAME. More...

wxString	help_name () override

void	language_change (wxCommandEvent &event)

Private Attributes
TREE_PROJECT_FRAME *	m_LeftWin

LAUNCHER_PANEL *	m_Launcher

wxTextCtrl *	m_MessagesBox

wxAuiToolBar *	m_VToolBar

int	m_leftWinWidth

EDA_HOTKEY_CONFIG *	m_manager_Hokeys_Descr

bool	m_active_project

Detailed Description

The main KiCad project manager frame.

It is not a KIWAY_PLAYER.

Definition at line 136 of file kicad.h.

Constructor & Destructor Documentation

KICAD_MANAGER_FRAME::KICAD_MANAGER_FRAME	(	wxWindow *	parent,
		const wxString &	title,
		const wxPoint &	pos,
		const wxSize &	size
	)

Definition at line 50 of file mainframe.cpp.

References config(), GetBuildVersion(), LAUNCHER_PANEL::GetPanelHeight(), LAUNCHER_PANEL::GetPanelWidth(), EDA_PANEINFO::HorizontalToolbarPane(), EDA_PANEINFO::InfoToolbarPane(), KiBitmap(), PCAD2KICAD::Left, LoadSettings(), m_active_project, EDA_BASE_FRAME::m_auimgr, EDA_BASE_FRAME::m_FramePos, EDA_BASE_FRAME::m_FrameSize, m_Launcher, m_LeftWin, m_leftWinWidth, EDA_BASE_FRAME::m_mainToolBar, m_manager_Hokeys_Descr, m_MessagesBox, RecreateBaseHToolbar(), ReCreateMenuBar(), wxPoint::x, and wxPoint::y.

                                                                            :
     EDA_BASE_FRAME( parent, KICAD_MAIN_FRAME_T, title, pos, size,
                     KICAD_DEFAULT_DRAWFRAME_STYLE, KICAD_MANAGER_FRAME_NAME )
 {
     m_active_project = false;
     m_leftWinWidth = 60;
     m_manager_Hokeys_Descr = NULL;
 
     // Create the status line (bottom of the frame)
     static const int dims[3] = { -1, -1, 100 };
 
     CreateStatusBar( 3 );
     SetStatusWidths( 3, dims );
 
     // Give an icon
     wxIcon icon;
     icon.CopyFromBitmap( KiBitmap( icon_kicad_xpm ) );
     SetIcon( icon );
 
     // Give the last sise and pos to main window
     LoadSettings( config() );
     SetSize( m_FramePos.x, m_FramePos.y, m_FrameSize.x, m_FrameSize.y );
 
     // Left window: is the box which display tree project
     m_LeftWin = new TREE_PROJECT_FRAME( this );
 
     // Right top Window: buttons to launch applications
     m_Launcher = new LAUNCHER_PANEL( this );
 
     // Add the wxTextCtrl showing all messages from KiCad:
     m_MessagesBox = new wxTextCtrl( this, wxID_ANY, wxEmptyString,
                                     wxDefaultPosition, wxDefaultSize,
                                     wxTE_MULTILINE | wxSUNKEN_BORDER | wxTE_READONLY );
 
     RecreateBaseHToolbar();
     ReCreateMenuBar();
 
     m_auimgr.SetManagedWindow( this );
 
     EDA_PANEINFO horiztb;
     horiztb.HorizontalToolbarPane();
 
     EDA_PANEINFO info;
     info.InfoToolbarPane();
 
     m_auimgr.AddPane( m_mainToolBar,
                       wxAuiPaneInfo( horiztb ).Name( wxT( "m_mainToolBar" ) ).Top() );
 
     m_auimgr.AddPane( m_LeftWin,
                       wxAuiPaneInfo(info).Name( wxT( "m_LeftWin" ) ).Left().
                       BestSize( m_leftWinWidth, -1 ).
                       Layer( 1 ) );
 
     m_auimgr.AddPane( m_Launcher, wxTOP );
     m_auimgr.GetPane( m_Launcher).CaptionVisible( false ).PaneBorder(false)
             .MinSize( wxSize( m_Launcher->GetPanelWidth(), m_Launcher->GetPanelHeight() ) )
             .Resizable( false );
 
     m_auimgr.AddPane( m_MessagesBox,
                       wxAuiPaneInfo().Name( wxT( "m_MessagesBox" ) ).CentrePane().Layer( 2 ) );
 
     m_auimgr.GetPane( m_LeftWin ).MinSize( wxSize( 150, -1) );
     m_auimgr.GetPane( m_LeftWin ).BestSize(wxSize(m_leftWinWidth, -1) );
 
     m_auimgr.Update();
 
     SetTitle( wxString( "KiCad " ) + GetBuildVersion() );
 }

KICAD_MANAGER_FRAME::~KICAD_MANAGER_FRAME ( )

Definition at line 121 of file mainframe.cpp.

References EDA_BASE_FRAME::m_auimgr.

 {
     m_auimgr.UnInit();
 }

Member Function Documentation

void EDA_BASE_FRAME::AddMenuIconsOptions ( wxMenu * MasterMenu )

inherited

Function AddMenuIconsOptions creates a menu list for icons in menu and icon sizes choice, and add it as submenu to MasterMenu.

Parameters

MasterMenu The main menu. The sub menu list will be accessible from the menu item with id ID_KICAD_SELECT_ICONS_OPTIONS

Definition at line 673 of file basicframe.cpp.

References AddMenuItem(), ID_KICAD_SELECT_ICONS_IN_MENUS, ID_KICAD_SELECT_ICONS_OPTIONS, KiBitmap(), and Pgm().

Referenced by preparePreferencesMenu(), PL_EDITOR_FRAME::ReCreateMenuBar(), ReCreateMenuBar(), and GERBVIEW_FRAME::ReCreateMenuBar().

 {
     wxMenu*      menu = NULL;
     wxMenuItem*  item = MasterMenu->FindItem( ID_KICAD_SELECT_ICONS_OPTIONS );
 
     if( item )     // This menu exists, do nothing
         return;
 
     menu = new wxMenu;
 
     menu->Append( new wxMenuItem( menu, ID_KICAD_SELECT_ICONS_IN_MENUS,
                   _( "Icons in Menus" ), wxEmptyString,
                   wxITEM_CHECK ) );
     menu->Check( ID_KICAD_SELECT_ICONS_IN_MENUS, Pgm().GetUseIconsInMenus() );
 
     AddMenuItem( MasterMenu, menu,
                  ID_KICAD_SELECT_ICONS_OPTIONS,
                  _( "Icons Options" ),
                  _( "Select show icons in menus and icons sizes" ),
                  KiBitmap( icon_xpm ) );
 }

void EDA_BASE_FRAME::CheckForAutoSaveFile	(	const wxFileName &	aFileName,
		const wxString &	aBackupFileExtension
	)

inherited

Function CheckForAutoSaveFile checks if an auto save file exists for aFileName and takes the appropriate action depending on the user input.

If an auto save file exists for aFileName, the user is prompted if they wish to replace file aFileName with the auto saved file. If the user chooses to replace the file, the backup file of aFileName is removed, aFileName is renamed to the backup file name, and the auto save file is renamed to aFileName. If user chooses to keep the existing version of aFileName, the auto save file is removed.

Parameters

aFileName	A wxFileName object containing the file name to check.
aBackupFileExtension	A wxString object containing the backup file extension used to create the backup file name.

Definition at line 578 of file basicframe.cpp.

References AUTOSAVE_PREFIX_FILENAME, Format(), GetChars(), Pgm(), and traceAutoSave.

Referenced by SCH_EDIT_FRAME::LoadOneEEFile(), and PCB_EDIT_FRAME::OpenProjectFiles().

 {
     wxCHECK_RET( aFileName.IsOk(), wxT( "Invalid file name!" ) );
     wxCHECK_RET( !aBackupFileExtension.IsEmpty(), wxT( "Invalid backup file extension!" ) );
 
     wxFileName autoSaveFileName = aFileName;
 
     // Check for auto save file.
     autoSaveFileName.SetName( AUTOSAVE_PREFIX_FILENAME + aFileName.GetName() );
 
     wxLogTrace( traceAutoSave,
                 wxT( "Checking for auto save file " ) + autoSaveFileName.GetFullPath() );
 
     if( !autoSaveFileName.FileExists() )
         return;
 
     wxString msg = wxString::Format( _(
             "Well this is potentially embarrassing!\n"
             "It appears that the last time you were editing the file\n"
             "'%s'\n"
             "it was not saved properly.  Do you wish to restore the last saved edits you made?" ),
             GetChars( aFileName.GetFullName() )
         );
 
     int response = wxMessageBox( msg, Pgm().App().GetAppName(), wxYES_NO | wxICON_QUESTION, this );
 
     // Make a backup of the current file, delete the file, and rename the auto save file to
     // the file name.
     if( response == wxYES )
     {
         // Get the backup file name.
         wxFileName backupFileName = aFileName;
         backupFileName.SetExt( aBackupFileExtension );
 
         // If an old backup file exists, delete it.  If an old copy of the file exists, rename
         // it to the backup file name
         if( aFileName.FileExists() )
         {
             // Remove the old file backup file.
             if( backupFileName.FileExists() )
                 wxRemoveFile( backupFileName.GetFullPath() );
 
             // Rename the old file to the backup file name.
             if( !wxRenameFile( aFileName.GetFullPath(), backupFileName.GetFullPath() ) )
             {
                 msg.Printf( _( "Could not create backup file <%s>" ),
                             GetChars( backupFileName.GetFullPath() ) );
                 wxMessageBox( msg );
             }
         }
 
         if( !wxRenameFile( autoSaveFileName.GetFullPath(), aFileName.GetFullPath() ) )
         {
             wxMessageBox( _( "The auto save file could not be renamed to the board file name." ),
                           Pgm().App().GetAppName(), wxOK | wxICON_EXCLAMATION, this );
         }
     }
     else
     {
         wxLogTrace( traceAutoSave,
                     wxT( "Removing auto save file " ) + autoSaveFileName.GetFullPath() );
 
         // Remove the auto save file when using the previous file as is.
         wxRemoveFile( autoSaveFileName.GetFullPath() );
     }
 }

void KICAD_MANAGER_FRAME::ClearMsg ( )

Erase the text panel.

Definition at line 528 of file mainframe.cpp.

References m_MessagesBox.

Referenced by LoadProject(), and OnCreateProjectFromTemplate().

 {
     m_MessagesBox->Clear();
 }

wxConfigBase * KICAD_MANAGER_FRAME::config ( )

overrideprivatevirtual

Function config returns the wxConfigBase used in SaveSettings(), and is overloaded in KICAD_MANAGER_FRAME.

Reimplemented from EDA_BASE_FRAME.

Definition at line 127 of file mainframe.cpp.

References PGM_KICAD::PgmSettings(), and PgmTop().

Referenced by KICAD_MANAGER_FRAME().

 {
     wxConfigBase* ret = PgmTop().PgmSettings();
     wxASSERT( ret );
     return ret;
 }

wxString EDA_BASE_FRAME::ConfigBaseName ( )

inlineinherited

Function ConfigBaseName.

Returns: a base name prefix used in Load/Save settings to build the full name of keys used in config. This is usually the name of the frame set by CTOR, unless m_configFrameName contains a base name. this is the case of frames which can be shown in normal or modal mode. This is needed because we want only one base name prefix, regardless the mode used.

Definition at line 260 of file wxstruct.h.

References EDA_BASE_FRAME::m_configFrameName.

Referenced by EDA_BASE_FRAME::LoadSettings(), EDA_DRAW_FRAME::LoadSettings(), EDA_BASE_FRAME::SaveSettings(), and EDA_DRAW_FRAME::SaveSettings().

     {
         wxString baseCfgName = m_configFrameName.IsEmpty() ? GetName() : m_configFrameName;
         return baseCfgName;
     }

void KICAD_MANAGER_FRAME::CreateNewProject ( const wxFileName & aProjectFileName )

Creates a new project by setting up and initial project, schematic, and board files.

The project file is copied from the kicad.pro template file if possible. Otherwise, a minimal project file is created from an empty project. A minimal schematic and board file are created to prevent the schematic and board editors from complaining. If any of these files already exist, they are not overwritten.

Parameters

aProjectFileName is the absolute path of the project file name.

Definition at line 108 of file prjconfig.cpp.

References PROJECT::ConfigSave(), SEARCH_STACK::FindValidPath(), GeneralGroupName, KiCadPcbFileExtension, LegacyPcbFileExtension, PgmTop(), Prj(), SchematicFileExtension, SetProjectFileName(), and sys_search().

Referenced by OnCreateProjectFromTemplate(), and OnNewProject().

 {
     wxCHECK_RET( aProjectFileName.DirExists() && aProjectFileName.IsDirWritable(),
                  "Project folder must exist and be writable to create a new project." );
 
     // Init project filename.  This clears all elements from the project object.
     SetProjectFileName( aProjectFileName.GetFullPath() );
 
     // Copy kicad.pro file from template folder.
     if( !aProjectFileName.FileExists() )
     {
         wxString srcFileName = sys_search().FindValidPath( "kicad.pro" );
 
         // Create a minimal project (.pro) file if the template project file could not be copied.
         if( !wxFileName::FileExists( srcFileName )
           || !wxCopyFile( srcFileName, aProjectFileName.GetFullPath() ) )
         {
             Prj().ConfigSave( PgmTop().SysSearch(), GeneralGroupName, s_KicadManagerParams );
         }
     }
 
     // Ensure a "stub" for a schematic root sheet and a board exist.
     // It will avoid messages from the schematic editor or the board editor to create a new file
     // And forces the user to create main files under the right name for the project manager
     wxFileName fn( aProjectFileName.GetFullPath() );
     fn.SetExt( SchematicFileExtension );
 
     // If a <project>.sch file does not exist, create a "stub" file ( minimal schematic file )
     if( !fn.FileExists() )
     {
         wxFile file( fn.GetFullPath(), wxFile::write );
 
         if( file.IsOpened() )
             file.Write( wxT( "EESchema Schematic File Version 2\n"
                              "EELAYER 25 0\nEELAYER END\n$EndSCHEMATC\n" ) );
 
         // wxFile dtor will close the file
     }
 
     // If a <project>.kicad_pcb or <project>.brd file does not exist,
     // create a .kicad_pcb "stub" file
     fn.SetExt( KiCadPcbFileExtension );
     wxFileName leg_fn( fn );
     leg_fn.SetExt( LegacyPcbFileExtension );
 
     if( !fn.FileExists() && !leg_fn.FileExists() )
     {
         wxFile file( fn.GetFullPath(), wxFile::write );
 
         if( file.IsOpened() )
             file.Write( wxT( "(kicad_pcb (version 4) (host kicad \"dummy file\") )\n" ) );
 
         // wxFile dtor will close the file
     }
 }

bool EDA_BASE_FRAME::doAutoSave ( )

protectedvirtualinherited

Function doAutoSave should be overridden by the derived class to handle the auto save feature.

Returns: true if the auto save was successful otherwise false.

Reimplemented in PCB_EDIT_FRAME, and SCH_EDIT_FRAME.

Definition at line 231 of file basicframe.cpp.

Referenced by EDA_BASE_FRAME::onAutoSaveTimer().

 {
     wxCHECK_MSG( false, true, wxT( "Auto save timer function not overridden.  Bad programmer!" ) );
 }

bool EDA_BASE_FRAME::Enable ( bool enable )

overrideinherited

Definition at line 192 of file basicframe.cpp.

Referenced by FOOTPRINT_EDIT_FRAME::OnUpdateLoadModuleFromBoard(), and KIWAY_PLAYER::ShowModal().

 {
     // so we can do logging of this state change:
 
 #if defined(DEBUG)
     const char* type_id = typeid( *this ).name();
     printf( "wxFrame %-28s: %s\n", type_id, enable ? "enabled" : "disabled" );
 #endif
 
     return wxFrame::Enable( enable );
 }

void KICAD_MANAGER_FRAME::Execute	(	wxWindow *	frame,
		const wxString &	execFile,
		wxString	param = `wxEmptyString`
	)

Open another KiCad application and logs a message.

Parameters

frame	= owner frame.
execFile	= name of the executable file.
param	= parameters to be passed to the executable.

Definition at line 272 of file mainframe.cpp.

References AddDelimiterString(), ExecuteFile(), Format(), GetChars(), and PrintMsg().

Referenced by TREEPROJECT_ITEM::Activate(), OnOpenFileInTextEditor(), OnOpenTextEditor(), OnRunBitmapConverter(), OnRunGerbview(), OnRunPageLayoutEditor(), and OnRunPcbCalculator().

 {
     if( params.size() )
         AddDelimiterString( params );
 
     TERMINATE_HANDLER* callback = new TERMINATE_HANDLER( execFile );
 
     long pid = ExecuteFile( frame, execFile, params, callback );
 
     if( pid > 0 )
     {
         wxString msg = wxString::Format( _( "%s %s opened [pid=%ld]\n" ),
                                          GetChars( execFile ), GetChars( params ), pid );
 
         PrintMsg( msg );
     }
     else
     {
         delete callback;
     }
 }

void EDA_BASE_FRAME::ExportHotkeyConfigToFile	(	EDA_HOTKEY_CONFIG *	aDescList,
		const wxString &	aDefaultShortname
	)

inherited

Function ExportHotkeyConfigToFile Prompt the user for an old hotkey file to read, and read it.

Parameters

aDescList	= current hotkey list descr. to initialize.
aDefaultShortname	= a default short name (extention not needed) like eechema, kicad...

Definition at line 768 of file hotkeys_basic.cpp.

References DEFAULT_HOTKEY_FILENAME_EXT, EDA_FILE_SELECTOR(), EDA_BASE_FRAME::GetMruPath(), Prj(), EDA_BASE_FRAME::SetMruPath(), and EDA_BASE_FRAME::WriteHotkeyConfig().

Referenced by Process_Config(), LIB_EDIT_FRAME::Process_Config(), SCH_EDIT_FRAME::Process_Config(), PL_EDITOR_FRAME::Process_Config(), PCB_EDIT_FRAME::Process_Config(), GERBVIEW_FRAME::Process_Config(), and FOOTPRINT_EDIT_FRAME::ProcessPreferences().

 {
     wxString ext  = DEFAULT_HOTKEY_FILENAME_EXT;
     wxString mask = wxT( "*." ) + ext;
 
 #if 0
     wxString path = wxPathOnly( Prj().GetProjectFullName() );
 #else
     wxString path = GetMruPath();
 #endif
     wxFileName fn( aDefaultShortname );
     fn.SetExt( DEFAULT_HOTKEY_FILENAME_EXT );
 
     wxString filename = EDA_FILE_SELECTOR( _( "Write Hotkey Configuration File:" ),
                                            path,
                                            fn.GetFullPath(),
                                            ext,
                                            mask,
                                            this,
                                            wxFD_SAVE,
                                            true );
 
     if( filename.IsEmpty() )
         return;
 
     WriteHotkeyConfig( aDescList, &filename );
     SetMruPath( wxFileName( filename ).GetPath() );
 }

int EDA_BASE_FRAME::GetAutoSaveInterval ( ) const

inlineinherited

Definition at line 219 of file wxstruct.h.

References EDA_BASE_FRAME::m_autoSaveInterval.

Referenced by DIALOG_GENERALOPTIONS::init(), and SCH_EDIT_FRAME::OnPreferencesOptions().

219 { return m_autoSaveInterval; }

EDA_BASE_FRAME::m_autoSaveInterval

int m_autoSaveInterval

The auto save interval time in seconds.

Definition: wxstruct.h:153

wxString EDA_BASE_FRAME::GetFileFromHistory	(	int	cmdId,
		const wxString &	type,
		wxFileHistory *	aFileHistory = `NULL`
	)

inherited

Function GetFileFromHistory fetches the file name from the file history list.

and removes the selected file, if this file does not exists Note also the menu is updated, if wxFileHistory::UseMenu was called at init time

Parameters

cmdId	The command ID associated with the aFileHistory object.
type	Please document me!
aFileHistory	The wxFileHistory in use. If null, the main application file history is used

Returns: a wxString containing the selected filename

Definition at line 400 of file basicframe.cpp.

References Format(), GetChars(), KIFACE_I::GetFileHistory(), and Kiface().

Referenced by GERBVIEW_FRAME::OnDrlFileHistory(), OnFileHistory(), PL_EDITOR_FRAME::OnFileHistory(), PCB_EDIT_FRAME::OnFileHistory(), GERBVIEW_FRAME::OnGbrFileHistory(), GERBVIEW_FRAME::OnJobFileHistory(), and GERBVIEW_FRAME::OnZipFileHistory().

 {
     wxFileHistory* fileHistory = aFileHistory;
 
     if( !fileHistory )
         fileHistory = &Kiface().GetFileHistory();
 
     int baseId = fileHistory->GetBaseId();
 
     wxASSERT( cmdId >= baseId && cmdId < baseId + (int) fileHistory->GetCount() );
 
     unsigned i = cmdId - baseId;
 
     if( i < fileHistory->GetCount() )
     {
         wxString fn = fileHistory->GetHistoryFile( i );
 
         if( wxFileName::FileExists( fn ) )
             return fn;
         else
         {
             wxString msg = wxString::Format(
                         wxT( "file '%s' was not found." ),
                         GetChars( fn ) );
 
             wxMessageBox( msg );
 
             fileHistory->RemoveFileFromHistory( i );
         }
     }
 
     return wxEmptyString;
 }

void EDA_BASE_FRAME::GetKicadAbout ( wxCommandEvent & event )

inherited

Definition at line 527 of file basicframe.cpp.

References ShowAboutDialog().

 {
     void ShowAboutDialog(EDA_BASE_FRAME * aParent); // See AboutDialog_main.cpp
     ShowAboutDialog( this );
 }

void EDA_BASE_FRAME::GetKicadContribute ( wxCommandEvent & event )

inherited

Definition at line 514 of file basicframe.cpp.

References URL_GET_INVOLVED.

 {
     if( !wxLaunchDefaultBrowser( URL_GET_INVOLVED ) )
     {
         wxString msg;
         msg.Printf( _( "Could not launch the default browser.\n"
                        "For information on how to help the KiCad project, visit %s" ),
                     URL_GET_INVOLVED );
         wxMessageBox( msg, _( "Get involved with KiCad" ), wxOK, this );
     }
 }

void EDA_BASE_FRAME::GetKicadHelp ( wxCommandEvent & event )

inherited

Definition at line 436 of file basicframe.cpp.

References DIM, Format(), GetAssociatedDocument(), GetChars(), EDA_BASE_FRAME::help_name(), SearchHelpFileFullPath(), and EDA_BASE_FRAME::sys_search().

 {
     const SEARCH_STACK& search = sys_search();
 
     /* We have to get document for beginners,
      * or the full specific doc
      * if event id is wxID_INDEX, we want the document for beginners.
      * else the specific doc file (its name is in Kiface().GetHelpFileName())
      * The document for beginners is the same for all KiCad utilities
      */
     if( event.GetId() == wxID_INDEX )
     {
         // List of possible names for Getting Started in KiCad
         const wxChar* names[2] = {
             wxT( "getting_started_in_kicad" ),
             wxT( "Getting_Started_in_KiCad" )
             };
 
         wxString helpFile;
         // Search for "getting_started_in_kicad.html" or "getting_started_in_kicad.pdf"
         // or "Getting_Started_in_KiCad.html" or "Getting_Started_in_KiCad.pdf"
         for( unsigned ii = 0; ii < DIM( names ); ii++ )
         {
             helpFile = SearchHelpFileFullPath( search, names[ii] );
 
             if( !helpFile.IsEmpty() )
                break;
         }
 
         if( !helpFile )
         {
             wxString msg = wxString::Format( _(
                 "Html or pdf help file \n'%s'\n or\n'%s' could not be found." ), names[0], names[1] );
             wxMessageBox( msg );
         }
         else
         {
             GetAssociatedDocument( this, helpFile );
         }
 
         return;
     }
 
     wxString base_name = help_name();
     wxString helpFile = SearchHelpFileFullPath( search, base_name );
 
     if( !helpFile )
     {
         wxString msg = wxString::Format( _(
             "Help file '%s' could not be found." ),
             GetChars( base_name )
             );
         wxMessageBox( msg );
     }
     else
     {
         GetAssociatedDocument( this, helpFile );
     }
 }

wxString EDA_BASE_FRAME::GetMruPath ( ) const

inlineinherited

Definition at line 363 of file wxstruct.h.

References EDA_BASE_FRAME::m_mruPath.

Referenced by EDA_BASE_FRAME::ExportHotkeyConfigToFile(), EDA_BASE_FRAME::ImportHotkeyConfigFromFile(), OnLoadProject(), and OnNewProject().

363 { return m_mruPath; }

EDA_BASE_FRAME::m_mruPath

wxString m_mruPath

Most recently used path.

Definition: wxstruct.h:160

const wxString KICAD_MANAGER_FRAME::GetProjectFileName ( )

Definition at line 147 of file mainframe.cpp.

References PROJECT::GetProjectFullName(), and Prj().

Referenced by TREE_PROJECT_FRAME::AddItemToTreeProject(), TREE_PROJECT_FRAME::FileWatcherReset(), TREE_PROJECT_FRAME::findSubdirTreeItem(), OnArchiveFiles(), OnCloseWindow(), TREE_PROJECT_FRAME::OnCreateNewDirectory(), OnRunEeschema(), OnSaveProject(), OnUnarchiveFiles(), PcbFileName(), PcbLegacyFileName(), PrintPrjInfo(), TREE_PROJECT_FRAME::ReCreateTreePrj(), and SchFileName().

 {
     return  Prj().GetProjectFullName();
 }

wxString KICAD_MANAGER_FRAME::help_name ( )

overrideprivatevirtual

Reimplemented from EDA_BASE_FRAME.

Definition at line 195 of file mainframe.cpp.

References PGM_KICAD::GetHelpFileName(), and PgmTop().

 {
     return PgmTop().GetHelpFileName();
 }

void EDA_BASE_FRAME::ImportHotkeyConfigFromFile	(	EDA_HOTKEY_CONFIG *	aDescList,
		const wxString &	aDefaultShortname
	)

inherited

Function ImportHotkeyConfigFromFile Prompt the user for an old hotkey file to read, and read it.

Parameters

aDescList	= current hotkey list descr. to initialize.
aDefaultShortname	= a default short name (extention not needed) like eechema, kicad...

Definition at line 737 of file hotkeys_basic.cpp.

References DEFAULT_HOTKEY_FILENAME_EXT, EDA_FILE_SELECTOR(), EDA_BASE_FRAME::GetMruPath(), Prj(), EDA_BASE_FRAME::ReadHotkeyConfigFile(), and EDA_BASE_FRAME::SetMruPath().

Referenced by Process_Config(), LIB_EDIT_FRAME::Process_Config(), SCH_EDIT_FRAME::Process_Config(), PL_EDITOR_FRAME::Process_Config(), PCB_EDIT_FRAME::Process_Config(), GERBVIEW_FRAME::Process_Config(), and FOOTPRINT_EDIT_FRAME::ProcessPreferences().

 {
     wxString ext  = DEFAULT_HOTKEY_FILENAME_EXT;
     wxString mask = wxT( "*." ) + ext;
 
 #if 0   // pass in the project dir as an argument
     wxString path = wxPathOnly( Prj().GetProjectFullName() );
 #else
     wxString path = GetMruPath();
 #endif
     wxFileName fn( aDefaultShortname );
     fn.SetExt( DEFAULT_HOTKEY_FILENAME_EXT );
 
     wxString  filename = EDA_FILE_SELECTOR( _( "Read Hotkey Configuration File:" ),
                                            path,
                                            fn.GetFullPath(),
                                            ext,
                                            mask,
                                            this,
                                            wxFD_OPEN,
                                            true );
 
     if( filename.IsEmpty() )
         return;
 
     ReadHotkeyConfigFile( filename, aDescList );
     SetMruPath( wxFileName( filename ).GetPath() );
 }

virtual bool EDA_BASE_FRAME::isAutoSaveRequired ( ) const

inlineprotectedvirtualinherited

Function autoSaveRequired returns the auto save status of the application.

Override this function if your derived frame supports automatic file saving.

Reimplemented in PCB_EDIT_FRAME, and SCH_EDIT_FRAME.

Definition at line 173 of file wxstruct.h.

Referenced by EDA_BASE_FRAME::ProcessEvent().

173 { return false; }

bool EDA_BASE_FRAME::IsType ( FRAME_T aType ) const

inlineinherited

Definition at line 221 of file wxstruct.h.

Referenced by BOARD_COMMIT::BOARD_COMMIT(), LIB_PIN::drawGraphic(), BOARD_PRINTOUT_CONTROLLER::DrawPage(), DIALOG_EDIT_ONE_FIELD::init(), DIALOG_PAD_PROPERTIES::initValues(), PCB_BASE_FRAME::PlaceTexteModule(), and PCB_BASE_FRAME::RotateTextModule().

221 { return m_Ident == aType; }

EDA_BASE_FRAME::m_Ident

FRAME_T m_Ident

Id Type (pcb, schematic, library..)

Definition: wxstruct.h:133

bool EDA_BASE_FRAME::IsWritable ( const wxFileName & aFileName )

inherited

Function IsWritable checks if aFileName can be written.

The function performs a number of tests on aFileName to verify that it can be saved. If aFileName defines a path with no file name, them the path is tested for user write permission. If aFileName defines a file name that does not exist in the path, the path is tested for user write permission. If aFileName defines a file that already exits, the file name is tested for user write permissions.

Note: The file name path must be set or an assertion will be raised on debug builds and return false on release builds.

Parameters

aFileName The full path and/or file name of the file to test.

Returns: False if aFileName cannot be written.

Definition at line 534 of file basicframe.cpp.

References GetChars().

Referenced by SCH_EDIT_FRAME::doAutoSave(), LIB_EDIT_FRAME::SaveActiveLibrary(), SCH_EDIT_FRAME::SaveEEFile(), PCB_EDIT_FRAME::SavePcbCopy(), PCB_EDIT_FRAME::SavePcbFile(), CVPCB_MAINFRAME::SaveProjectFile(), and SCH_EDIT_FRAME::SaveProjectSettings().

 {
     wxString msg;
     wxFileName fn = aFileName;
 
     // Check for absence of a file path with a file name.  Unfortunately KiCad
     // uses paths relative to the current project path without the ./ part which
     // confuses wxFileName. Making the file name path absolute may be less than
     // elegant but it solves the problem.
     if( fn.GetPath().IsEmpty() && fn.HasName() )
         fn.MakeAbsolute();
 
     wxCHECK_MSG( fn.IsOk(), false,
                  wxT( "File name object is invalid.  Bad programmer!" ) );
     wxCHECK_MSG( !fn.GetPath().IsEmpty(), false,
                  wxT( "File name object path <" ) + fn.GetFullPath() +
                  wxT( "> is not set.  Bad programmer!" ) );
 
     if( fn.IsDir() && !fn.IsDirWritable() )
     {
         msg.Printf( _( "You do not have write permissions to folder <%s>." ),
                     GetChars( fn.GetPath() ) );
     }
     else if( !fn.FileExists() && !fn.IsDirWritable() )
     {
         msg.Printf( _( "You do not have write permissions to save file <%s> to folder <%s>." ),
                     GetChars( fn.GetFullName() ), GetChars( fn.GetPath() ) );
     }
     else if( fn.FileExists() && !fn.IsFileWritable() )
     {
         msg.Printf( _( "You do not have write permissions to save file <%s>." ),
                     GetChars( fn.GetFullPath() ) );
     }
 
     if( !msg.IsEmpty() )
     {
         wxMessageBox( msg );
         return false;
     }
 
     return true;
 }

void KICAD_MANAGER_FRAME::language_change ( wxCommandEvent & event )

private

Definition at line 521 of file mainframe.cpp.

References Kiway, and KIWAY::SetLanguage().

 {
     int id = event.GetId();
     Kiway.SetLanguage( id );
 }

void KICAD_MANAGER_FRAME::LoadProject ( const wxFileName & aProjectFileName )

Definition at line 61 of file prjconfig.cpp.

References ClearMsg(), PROJECT::ConfigLoad(), GeneralGroupName, GetBuildVersion(), PGM_KICAD::GetFileHistory(), ID_INIT_WATCHED_PATHS, Kiway, m_active_project, m_LeftWin, PgmTop(), KIWAY::PlayersClose(), PrintPrjInfo(), Prj(), TREE_PROJECT_FRAME::ReCreateTreePrj(), EDA_BASE_FRAME::SetMruPath(), SetProjectFileName(), and EDA_BASE_FRAME::UpdateFileHistory().

Referenced by PGM_KICAD::MacOpenFile(), OnCreateProjectFromTemplate(), OnFileHistory(), OnLoadProject(), OnNewProject(), and PGM_KICAD::OnPgmInit().

 {
     // The project file should be valid by the time we get here or something has gone wrong.
     if( !aProjectFileName.Exists() )
         return;
 
     // Any open KIFACE's must be closed if they are not part of the new project.
     // (We never want a KIWAY_PLAYER open on a KIWAY that isn't in the same project.)
     // User is prompted here to close those KIWAY_PLAYERs:
     if( !Kiway.PlayersClose( false ) )
         return;
 
     SetTitle( wxString( "KiCad " ) + GetBuildVersion() );
 
     // Save the project file for the currently loaded project.
     if( m_active_project )
         Prj().ConfigLoad( PgmTop().SysSearch(), GeneralGroupName, s_KicadManagerParams );
 
     m_active_project = true;
     ClearMsg();
     SetProjectFileName( aProjectFileName.GetFullPath() );
     Prj().ConfigLoad( PgmTop().SysSearch(), GeneralGroupName, s_KicadManagerParams );
 
     wxString title = GetTitle() + " " + aProjectFileName.GetFullPath();
 
     if( !aProjectFileName.IsDirWritable() )
         title += _( " [Read Only]" );
     else
         SetMruPath( Prj().GetProjectPath() ); // Only set MRU path if we have write access. Why?
 
     SetTitle( title );
 
     UpdateFileHistory( aProjectFileName.GetFullPath(), &PgmTop().GetFileHistory() );
 
     m_LeftWin->ReCreateTreePrj();
 
     // Rebuild the list of watched paths.
     // however this is possible only when the main loop event handler is running,
     // so we use it to run the rebuild function.
     wxCommandEvent cmd( wxEVT_COMMAND_MENU_SELECTED, ID_INIT_WATCHED_PATHS );
 
     wxPostEvent( this, cmd );
 
     PrintPrjInfo();
 }

void KICAD_MANAGER_FRAME::LoadSettings ( wxConfigBase * aCfg )

overridevirtual

Function LoadSettings loads common frame parameters from a configuration file.

Don't forget to call the base method or your frames won't remember their positions and sizes.

Reimplemented from EDA_BASE_FRAME.

Definition at line 534 of file mainframe.cpp.

References EDA_BASE_FRAME::LoadSettings(), m_leftWinWidth, and TREE_FRAME_WIDTH_ENTRY.

Referenced by KICAD_MANAGER_FRAME().

 {
     EDA_BASE_FRAME::LoadSettings( aCfg );
     aCfg->Read( TREE_FRAME_WIDTH_ENTRY, &m_leftWinWidth );
 }

void KICAD_MANAGER_FRAME::OnArchiveFiles ( wxCommandEvent & event )

Definition at line 129 of file kicad/files-io.cpp.

References DIM, Format(), GetChars(), GetProjectFileName(), PrintMsg(), and ZipFileWildcard.

 {
     // List of file extensions to save.
     static const wxChar* extentionList[] = {
         wxT( "*.sch" ), wxT( "*.lib" ), wxT( "*.mod" ), wxT( "*.cmp" ),
         wxT( "*.brd" ), wxT( "*.kicad_pcb" ), wxT( "*.gbr" ), wxT( "*.pos" ),
         wxT( "*.net" ), wxT( "*.pro" ), wxT( "*.drl" ), wxT( "*.py" ),
         wxT( "*.pdf" ), wxT( "*.txt" ), wxT( "*.dcm" ), wxT( "*.kicad_wks" ),
     };
 
     wxString    msg;
     wxFileName  fileName = GetProjectFileName();
     wxString    oldCwd = wxGetCwd();
 
     fileName.SetExt( wxT( "zip" ) );
 
     wxFileDialog dlg( this, _( "Archive Project Files" ),
                       fileName.GetPath(), fileName.GetFullName(),
                       ZipFileWildcard, wxFD_SAVE | wxFD_OVERWRITE_PROMPT );
 
     if( dlg.ShowModal() == wxID_CANCEL )
         return;
 
     wxFileName zip = dlg.GetPath();
 
     wxString currdirname = fileName.GetPathWithSep();
     wxDir dir( currdirname );
 
     if( !dir.IsOpened() )   // wxWidgets display a error message on issue.
         return;
 
     wxSetWorkingDirectory( currdirname );
 
     // Prepare the zip file
     wxString zipfilename = zip.GetFullPath();
 
     wxFFileOutputStream ostream( zipfilename );
 
     if( !ostream.IsOk() )   // issue to create the file. Perhaps not writable dir
     {
         wxMessageBox( wxString::Format( _( "Unable to create zip archive file '%s'" ),
                                         zipfilename ) );
         return;
     }
 
     wxZipOutputStream zipstream( ostream );
 
     // Build list of filenames to put in zip archive
     wxString currFilename;
 
     wxArrayString files;
 
     for( unsigned ii = 0; ii < DIM( extentionList ); ii++ )
         wxDir::GetAllFiles( currdirname, &files, extentionList[ii] );
 
     files.Sort();
 
     int zipBytesCnt = 0;
 
     for( unsigned ii = 0; ii < files.GetCount(); ii++ )
     {
         wxFileSystem fsfile;
 
         wxFileName curr_fn( files[ii] );
         curr_fn.MakeRelativeTo( currdirname );
         currFilename = curr_fn.GetFullPath();
 
         msg.Printf( _( "Archive file <%s>" ), GetChars( currFilename ) );
         PrintMsg( msg );
 
         // Read input file and add it to the zip file:
         wxFSFile* infile = fsfile.OpenFile( currFilename );
 
         if( infile )
         {
             zipstream.PutNextEntry( currFilename, infile->GetModificationTime() );
             infile->GetStream()->Read( zipstream );
             zipstream.CloseEntry();
             int zippedsize = zipstream.GetSize() - zipBytesCnt;
             zipBytesCnt = zipstream.GetSize();
             PrintMsg( wxT("  ") );
             msg.Printf( _( "(%lu bytes, compressed %d bytes)\n" ),
                         (unsigned long)infile->GetStream()->GetSize(), zippedsize );
             PrintMsg( msg );
             delete infile;
         }
         else
             PrintMsg( _( " >>Error\n" ) );
     }
 
     zipBytesCnt = ostream.GetSize();
 
     if( zipstream.Close() )
     {
         msg.Printf( _( "\nZip archive <%s> created (%d bytes)" ),
                     GetChars( zipfilename ), zipBytesCnt );
         PrintMsg( msg );
         PrintMsg( wxT( "\n** end **\n" ) );
     }
     else
     {
         msg.Printf( wxT( "Unable to create archive <%s>, abort\n" ),
                     GetChars( zipfilename ) );
         PrintMsg( msg );
     }
 
     wxSetWorkingDirectory( oldCwd );
 }

void EDA_BASE_FRAME::onAutoSaveTimer ( wxTimerEvent & aEvent )

protectedinherited

Function onAutoSaveTimer handles the auto save timer event.

Definition at line 224 of file basicframe.cpp.

References EDA_BASE_FRAME::doAutoSave(), EDA_BASE_FRAME::m_autoSaveInterval, and EDA_BASE_FRAME::m_autoSaveTimer.

Referenced by EDA_BASE_FRAME::EDA_BASE_FRAME().

 {
     if( !doAutoSave() )
         m_autoSaveTimer->Start( m_autoSaveInterval * 1000, wxTIMER_ONE_SHOT );
 }

void KICAD_MANAGER_FRAME::OnChangeIconsOptions ( wxCommandEvent & event )

overridevirtual

Select the current icons options in menus (or toolbars) in Kicad (the default for toolbars/menus is 26x26 pixels, and shows icons in menus).

Reimplemented from EDA_BASE_FRAME.

Definition at line 446 of file mainframe.cpp.

References Kiway, EDA_BASE_FRAME::OnChangeIconsOptions(), and KIWAY::ShowChangedIcons().

 {
     EDA_BASE_FRAME::OnChangeIconsOptions( event );
     Kiway.ShowChangedIcons();
 }

void KICAD_MANAGER_FRAME::OnChangeWatchedPaths ( wxCommandEvent & aEvent )

Called by sending a event with id = ID_INIT_WATCHED_PATHS rebuild the list of wahtched paths.

Definition at line 1093 of file tree_project_frame.cpp.

References TREE_PROJECT_FRAME::FileWatcherReset(), and m_LeftWin.

 {
     m_LeftWin->FileWatcherReset();
 }

void KICAD_MANAGER_FRAME::OnCloseWindow ( wxCloseEvent & Event )

Definition at line 216 of file mainframe.cpp.

References PGM_KICAD::GetFileHistory(), GetProjectFileName(), Kiway, EDA_BASE_FRAME::m_FramePos, EDA_BASE_FRAME::m_FrameSize, m_LeftWin, PgmTop(), KIWAY::PlayersClose(), EDA_BASE_FRAME::UpdateFileHistory(), wxPoint::x, and wxPoint::y.

 {
     if( Kiway.PlayersClose( false ) )
     {
         int px, py;
 
         if( !GetProjectFileName().empty() )
             UpdateFileHistory( GetProjectFileName(), &PgmTop().GetFileHistory() );
 
         if( !IsIconized() )   // save main frame position and size
         {
             GetPosition( &px, &py );
             m_FramePos.x = px;
             m_FramePos.y = py;
 
             GetSize( &px, &py );
             m_FrameSize.x = px;
             m_FrameSize.y = py;
         }
 
         Event.SetCanVeto( true );
 
         m_LeftWin->Show( false );
 
         Destroy();
     }
 }

void KICAD_MANAGER_FRAME::OnConfigurePaths ( wxCommandEvent & aEvent )

Definition at line 588 of file mainframe.cpp.

References PGM_BASE::ConfigurePaths(), and Pgm().

 {
     Pgm().ConfigurePaths( this );
 }

void KICAD_MANAGER_FRAME::OnCreateProjectFromTemplate ( wxCommandEvent & event )

Creates a new project folder, copy a template into this new folder.

and open this new projrct as working project

Definition at line 235 of file prjconfig.cpp.

References DIALOG_TEMPLATE_SELECTOR::AddTemplatesPage(), ClearMsg(), CreateNewProject(), PROJECT_TEMPLATE::CreateProject(), PROJECT_TEMPLATE::GetDestinationFiles(), DIALOG_TEMPLATE_SELECTOR::GetSelectedTemplate(), LoadProject(), Prj(), and SEP.

 {
     wxString    default_dir = wxFileName( Prj().GetProjectFullName() ).GetPathWithSep();
     wxString    title = _( "New Project Folder" );
     wxDirDialog dlg( this, title, default_dir );
 
     if( dlg.ShowModal() == wxID_CANCEL )
         return;
 
     // Builds the project .pro filename, from the new project folder name
     wxFileName fn;
     fn.AssignDir( dlg.GetPath() );
     fn.SetName( dlg.GetPath().AfterLast( SEP() ) );
     fn.SetExt( wxT( "pro" ) );
 
     wxChar      sep[2] = { SEP(), 0 };  // nul terminated separator wxChar string.
 
     ClearMsg();
 
     DIALOG_TEMPLATE_SELECTOR* ps = new DIALOG_TEMPLATE_SELECTOR( this );
 
     wxFileName  templatePath;
     wxString    envStr;
 
 #ifndef __WXMAC__
     wxGetEnv( wxT( "KICAD" ), &envStr );
 
     // Add a new tab for system templates
     if( !envStr.empty() )
     {
         // user may or may not have including terminating separator.
         if( !envStr.EndsWith( sep ) )
             envStr += sep;
 
         templatePath = envStr + wxT( "template" ) + sep;
     }
     else
     {
         // The standard path should be in the share directory for kicad. As
         // it is normal on Windows to only have the share directory and not
         // the kicad sub-directory we fall back to that if the directory
         // doesn't exist
         templatePath = wxPathOnly( wxStandardPaths::Get().GetExecutablePath() ) +
                        sep + wxT( ".." ) + sep + wxT( "share" ) + sep + wxT( "kicad" ) +
                        sep + wxT( "template" ) + sep;
 
         if( !wxDirExists( templatePath.GetFullPath() ) )
         {
             templatePath = wxPathOnly( wxStandardPaths::Get().GetExecutablePath() ) + sep +
                            wxT( ".." ) + sep + wxT( "share" ) + sep + wxT( "template" ) + sep;
         }
     }
 #else
         // Use what is provided in the bundle data dir
     templatePath = GetOSXKicadDataDir() + sep + wxT( "template" );
 #endif
 
     ps->AddTemplatesPage( _( "System Templates" ), templatePath );
 
     // Add a new tab for user templates
     wxFileName userPath = wxStandardPaths::Get().GetDocumentsDir() + sep + wxT( "kicad" ) +
                           sep + wxT( "template" ) + sep;
 
     ps->AddTemplatesPage( _( "User Templates" ), userPath );
 
     // Check to see if a custom template location is available and setup a
     // new selection tab if there is.
     envStr.clear();
     wxGetEnv( wxT( "KICAD_PTEMPLATES" ), &envStr );
 
     if( !envStr.empty() )
     {
         if( !envStr.EndsWith( sep ) )
             envStr += sep;
 
         wxFileName envPath = envStr;
 
         ps->AddTemplatesPage( _( "Portable Templates" ), envPath );
     }
 
     // Show the project template selector dialog
     if( ps->ShowModal() != wxID_OK )
         return;
 
     if( ps->GetSelectedTemplate() == NULL )
     {
         wxMessageBox( _( "No project template was selected.  Cannot generate new project." ),
                       _( "Error" ),
                       wxOK | wxICON_ERROR,
                       this );
 
         return;
     }
 
     // Make sure the user has write permissions to the base path.
     wxFileName prjPath = fn;
 
     while( !prjPath.DirExists() )
         prjPath.RemoveLastDir();
 
     if( !prjPath.IsDirWritable() )
     {
         wxString msg;
 
         msg.Printf( _( "Cannot write to folder '%s'." ), prjPath.GetPath() );
         wxMessageDialog msgDlg( this, msg, _( "Error!" ), wxICON_ERROR | wxOK | wxCENTER );
         msgDlg.SetExtendedMessage( _( "Plese check your access permissions to this folder "
                                       "and try again." ) );
         msgDlg.ShowModal();
         return;
     }
 
     // Make sure we are not overwriting anything in the destination folder.
     std::vector< wxFileName > destFiles;
 
     if( ps->GetSelectedTemplate()->GetDestinationFiles( fn, destFiles ) )
     {
         std::vector< wxFileName > overwrittenFiles;
 
         for( auto file : destFiles )
         {
             if( file.FileExists() )
                 overwrittenFiles.push_back( file );
         }
 
         if( !overwrittenFiles.empty() )
         {
             wxString extendedMsg = _( "Overwriting files:" ) + "\n";
 
             for( auto file : overwrittenFiles )
             {
                 extendedMsg += "\n" + file.GetFullName();
             }
 
             wxMessageDialog owDlg( this,
                                    _( "Are you sure you want to overwrite files in "
                                       "the destination folder?" ),
                                    _( "Warning!" ),
                                    wxYES_NO | wxICON_QUESTION | wxCENTER );
             owDlg.SetExtendedMessage( extendedMsg );
             owDlg.SetYesNoLabels( _( "Overwrite" ), _( "Do Not Overwrite" ) );
 
             if( owDlg.ShowModal() == wxID_NO )
                 return;
         }
     }
 
     wxString errorMsg;
 
     // The selected template widget contains the template we're attempting to use to
     // create a project
     if( !ps->GetSelectedTemplate()->CreateProject( fn, &errorMsg ) )
     {
         wxMessageDialog createDlg( this,
                                    _( "A problem occurred creating new project from template!" ),
                                    _( "Template Error" ),
                                    wxOK | wxICON_ERROR );
 
         if( !errorMsg.empty() )
             createDlg.SetExtendedMessage( errorMsg );
 
         createDlg.ShowModal();
         return;
     }
 
     CreateNewProject( fn.GetFullPath() );
     LoadProject( fn );
 }

void KICAD_MANAGER_FRAME::OnExit ( wxCommandEvent & event )

Definition at line 245 of file mainframe.cpp.

 {
     Close( true );
 }

void KICAD_MANAGER_FRAME::OnFileHistory ( wxCommandEvent & event )

Definition at line 47 of file kicad/files-io.cpp.

References EDA_BASE_FRAME::GetFileFromHistory(), PGM_KICAD::GetFileHistory(), LoadProject(), and PgmTop().

 {
     wxFileName projFileName = GetFileFromHistory( event.GetId(), _( "KiCad project file" ),
                                                   &PgmTop().GetFileHistory() );
     if( !projFileName.FileExists() )
         return;
 
     LoadProject( projFileName );
 }

void KICAD_MANAGER_FRAME::OnLoadProject ( wxCommandEvent & event )

Load an exiting project (.pro) file.

Definition at line 165 of file prjconfig.cpp.

References EDA_BASE_FRAME::GetMruPath(), LoadProject(), ProjectFileExtension, and ProjectFileWildcard.

 {
     wxString     default_dir = GetMruPath();
     wxFileDialog dlg( this, _( "Open Existing Project" ), default_dir, wxEmptyString,
                       ProjectFileWildcard, wxFD_OPEN | wxFD_FILE_MUST_EXIST );
 
     if( dlg.ShowModal() == wxID_CANCEL )
         return;
 
     wxFileName pro( dlg.GetPath() );
     pro.SetExt( ProjectFileExtension );     // enforce extension
 
     if( !pro.IsAbsolute() )
         pro.MakeAbsolute();
 
     if( !pro.FileExists() )
         return;
 
     LoadProject( pro );
 }

void KICAD_MANAGER_FRAME::OnNewProject ( wxCommandEvent & aEvent )

Definition at line 187 of file prjconfig.cpp.

References CreateNewProject(), DisplayErrorMessage(), EDA_BASE_FRAME::GetMruPath(), IsOK(), LoadProject(), ProjectFileExtension, and ProjectFileWildcard.

 {
     wxString        default_dir = GetMruPath();
     wxFileDialog    dlg( this, _( "Create New Project" ), default_dir, wxEmptyString,
                          ProjectFileWildcard, wxFD_SAVE | wxFD_OVERWRITE_PROMPT );
 
     if( dlg.ShowModal() == wxID_CANCEL )
         return;
 
     wxFileName pro( dlg.GetPath() );
     pro.SetExt( ProjectFileExtension );     // enforce extension
 
     if( !pro.IsAbsolute() )
         pro.MakeAbsolute();
 
     // Append a new directory with the same name of the project file.
     pro.AppendDir( pro.GetName() );
 
     // Check if the project directory is empty if it already exists.
     wxDir directory( pro.GetPath() );
 
     if( !pro.DirExists() )
     {
         if( !pro.Mkdir() )
         {
             wxString msg;
             msg.Printf( _( "Directory '%s' could not be created.\n\n"
                            "Please make sure you have write permissions and try again." ),
                         pro.GetPath() );
             DisplayErrorMessage( this, msg );
             return;
         }
     }
     else if( directory.HasFiles() )
     {
         wxString msg = _( "The selected directory is not empty.  It is recommended that you "
                           "create projects in their own empty directory.\n\nDo you "
                           "want to continue?" );
 
         if( !IsOK( this, msg ) )
             return;
     }
 
     CreateNewProject( pro );
     LoadProject( pro );
 }

void KICAD_MANAGER_FRAME::OnOpenFileInEditor ( wxCommandEvent & event )

void KICAD_MANAGER_FRAME::OnOpenFileInTextEditor ( wxCommandEvent & event )

Definition at line 490 of file mainframe.cpp.

References Execute(), PGM_BASE::GetEditorName(), PROJECT::GetProjectPath(), Pgm(), and Prj().

 {
     wxString mask( wxT( "*" ) );
 
 #ifdef __WINDOWS__
     mask += wxT( ".*" );
 #endif
 
     mask = _( "Text file (" ) + mask + wxT( ")|" ) + mask;
     wxString default_dir = Prj().GetProjectPath();
 
     wxFileDialog dlg( this, _( "Load File to Edit" ), default_dir,
                       wxEmptyString, mask, wxFD_OPEN );
 
     if( dlg.ShowModal() == wxID_CANCEL )
         return;
 
     wxString filename = wxT( "\"" );
     filename += dlg.GetPath() + wxT( "\"" );
 
     if( !dlg.GetPath().IsEmpty() &&  !Pgm().GetEditorName().IsEmpty() )
         Execute( this, Pgm().GetEditorName(), filename );
 }

void KICAD_MANAGER_FRAME::OnOpenTextEditor ( wxCommandEvent & event )

Definition at line 481 of file mainframe.cpp.

References Execute(), PGM_BASE::GetEditorName(), and Pgm().

 {
     wxString editorname = Pgm().GetEditorName();
 
     if( !editorname.IsEmpty() )
         Execute( this, editorname, wxEmptyString );
 }

void KICAD_MANAGER_FRAME::OnRefresh ( wxCommandEvent & event )

Definition at line 515 of file mainframe.cpp.

References m_LeftWin, and TREE_PROJECT_FRAME::ReCreateTreePrj().

 {
     m_LeftWin->ReCreateTreePrj();
 }

void KICAD_MANAGER_FRAME::OnRunBitmapConverter ( wxCommandEvent & event )

Definition at line 453 of file mainframe.cpp.

References BITMAPCONVERTER_EXE, and Execute().

 {
     Execute( this, BITMAPCONVERTER_EXE );
 }

void KICAD_MANAGER_FRAME::OnRunEeschema ( wxCommandEvent & event )

Definition at line 338 of file mainframe.cpp.

References GetProjectFileName(), RunEeschema(), and SchematicFileExtension.

 {
     wxFileName fn( GetProjectFileName() );
     fn.SetExt( SchematicFileExtension );
     RunEeschema( fn.GetFullPath() );
 }

void KICAD_MANAGER_FRAME::OnRunGerbview ( wxCommandEvent & event )

Definition at line 472 of file mainframe.cpp.

References Execute(), GERBVIEW_EXE, and Prj().

 {
     // Gerbview is called without any file to open, because we do not know
     // the list and the name of files to open (if any...).
     // however we run it in the path of the project
     Execute( this, GERBVIEW_EXE, Prj().GetProjectPath() );
 }

void KICAD_MANAGER_FRAME::OnRunPageLayoutEditor ( wxCommandEvent & event )

Definition at line 465 of file mainframe.cpp.

References Execute(), and PL_EDITOR_EXE.

 {
     Execute( this, PL_EDITOR_EXE );
 }

void KICAD_MANAGER_FRAME::OnRunPcbCalculator ( wxCommandEvent & event )

Definition at line 459 of file mainframe.cpp.

References Execute(), and PCB_CALCULATOR_EXE.

 {
     Execute( this, PCB_CALCULATOR_EXE );
 }

void KICAD_MANAGER_FRAME::OnRunPcbFpEditor ( wxCommandEvent & event )

Definition at line 418 of file mainframe.cpp.

References FRAME_PCB_MODULE_EDITOR, Kiway, KIWAY::Player(), and IO_ERROR::What().

 {
     KIWAY_PLAYER* frame = Kiway.Player( FRAME_PCB_MODULE_EDITOR, false );
 
     if( !frame )
     {
         try
         {
             frame = Kiway.Player( FRAME_PCB_MODULE_EDITOR, true );
         }
         catch( IO_ERROR err )
         {
             wxMessageBox( _( "Footprint library editor failed to load:\n" ) + err.What(),
                           _( "KiCad Error" ), wxOK | wxICON_ERROR, this );
             return;
         }
 
         frame->Show( true );
     }
 
     // On Windows, Raise() does not bring the window on screen, when iconized
     if( frame->IsIconized() )
         frame->Iconize( false );
 
     frame->Raise();
 }

void KICAD_MANAGER_FRAME::OnRunPcbNew ( wxCommandEvent & event )

Definition at line 406 of file mainframe.cpp.

References PcbFileName(), PcbLegacyFileName(), and RunPcbNew().

 {
     wxFileName  kicad_board( PcbFileName() );
     wxFileName  legacy_board( PcbLegacyFileName() );
 
     wxFileName& board = ( !legacy_board.FileExists() || kicad_board.FileExists() ) ?
                             kicad_board : legacy_board;
 
     RunPcbNew( board.GetFullPath() );
 }

void KICAD_MANAGER_FRAME::OnRunSchLibEditor ( wxCommandEvent & event )

Definition at line 346 of file mainframe.cpp.

References FRAME_SCH_LIB_EDITOR, Kiway, KIWAY::Player(), and IO_ERROR::What().

 {
     KIWAY_PLAYER* frame = Kiway.Player( FRAME_SCH_LIB_EDITOR, false );
 
     if( !frame )
     {
         try
         {
             frame = Kiway.Player( FRAME_SCH_LIB_EDITOR, true );
         }
         catch( IO_ERROR err )
         {
             wxMessageBox( _( "Component library editor failed to load:\n" ) + err.What(),
                           _( "KiCad Error" ), wxOK | wxICON_ERROR, this );
             return;
         }
 
         frame->Show( true );
     }
 
     // On Windows, Raise() does not bring the window on screen, when iconized
     if( frame->IsIconized() )
         frame->Iconize( false );
 
     frame->Raise();
 }

void KICAD_MANAGER_FRAME::OnSaveProject ( wxCommandEvent & event )

Save the project (.pro) file containing the top level configuration parameters.

Definition at line 405 of file prjconfig.cpp.

References PROJECT::ConfigSave(), GeneralGroupName, GetProjectFileName(), PgmTop(), and Prj().

 {
     if( !wxIsWritable( GetProjectFileName() ) )
         return;
 
     Prj().ConfigSave( PgmTop().SysSearch(), GeneralGroupName, s_KicadManagerParams );
 }

void KICAD_MANAGER_FRAME::OnSelectDefaultPdfBrowser ( wxCommandEvent & event )

Definition at line 43 of file preferences.cpp.

References PGM_BASE::ForceSystemPdfBrowser(), Pgm(), and PGM_BASE::WritePdfBrowserInfos().

 {
     Pgm().ForceSystemPdfBrowser( true );
     Pgm().WritePdfBrowserInfos();
 }

void EDA_BASE_FRAME::OnSelectPreferredEditor ( wxCommandEvent & event )

virtualinherited

Function OnSelectPreferredEditor Open a dialog to select the editor that will used in KiCad to edit or display files (reports ...

) The full filename editor is saved in configuration (global params)

Definition at line 497 of file basicframe.cpp.

References PGM_BASE::AskUserForPreferredEditor(), PGM_BASE::GetEditorName(), Pgm(), and PGM_BASE::SetEditorName().

 {
     // Ask for the current editor and instruct GetEditorName() to not show
     // unless we pass false as argument.
     wxString editorname = Pgm().GetEditorName( false );
 
     // Ask the user to select a new editor, but suggest the current one as the default.
     editorname = Pgm().AskUserForPreferredEditor( editorname );
 
     // If we have a new editor name request it to be copied to m_editor_name and saved
     // to the preferences file. If the user cancelled the dialog then the previous
     // value will be retained.
     if( !editorname.IsEmpty() )
         Pgm().SetEditorName( editorname );
 }

void KICAD_MANAGER_FRAME::OnSelectPreferredPdfBrowser ( wxCommandEvent & event )

Definition at line 56 of file preferences.cpp.

References DisplayError(), PGM_BASE::ForceSystemPdfBrowser(), PGM_BASE::GetPdfBrowserName(), ID_SELECT_PREFERED_PDF_BROWSER_NAME, Pgm(), PGM_BASE::ReadPdfBrowserInfos(), PGM_BASE::SetPdfBrowserName(), and PGM_BASE::WritePdfBrowserInfos().

 {
     bool setPdfBrowserName = event.GetId() == ID_SELECT_PREFERED_PDF_BROWSER_NAME;
 
     if( !Pgm().GetPdfBrowserName() && !setPdfBrowserName )
     {
         DisplayError( this,
                       _( "You must choose a PDF viewer before using this option." ) );
         setPdfBrowserName = true;
     }
 
     if( setPdfBrowserName )
     {
         wxString mask( wxT( "*" ) );
 
     #ifdef __WINDOWS__
         mask += wxT( ".exe" );
     #endif
 
         wxString wildcard = _( "Executable files (" ) + mask + wxT( ")|" ) + mask;
 
         Pgm().ReadPdfBrowserInfos();
         wxFileName fn = Pgm().GetPdfBrowserName();
 
         wxFileDialog dlg( this, _( "Select Preferred PDF Browser" ), fn.GetPath(),
                           fn.GetFullPath(), wildcard,
                           wxFD_OPEN | wxFD_FILE_MUST_EXIST );
 
         if( dlg.ShowModal() == wxID_CANCEL )
             return;
 
         Pgm().SetPdfBrowserName( dlg.GetPath() );
     }
 
     Pgm().ForceSystemPdfBrowser( false );
     Pgm().WritePdfBrowserInfos();
 }

void KICAD_MANAGER_FRAME::OnSize ( wxSizeEvent & event )

Definition at line 207 of file mainframe.cpp.

References EDA_BASE_FRAME::m_auimgr.

 {
     if( m_auimgr.GetManagedWindow() )
         m_auimgr.Update();
 
     event.Skip();
 }

void KICAD_MANAGER_FRAME::OnUnarchiveFiles ( wxCommandEvent & event )

Definition at line 58 of file kicad/files-io.cpp.

References DisplayError(), Format(), GetChars(), GetProjectFileName(), PrintMsg(), ZipFileExtension, and ZipFileWildcard.

 {
     wxFileName fn = GetProjectFileName();
 
     fn.SetExt( ZipFileExtension );
 
     wxFileDialog zipfiledlg( this, _( "Unzip Project" ), fn.GetPath(),
                              fn.GetFullName(), ZipFileWildcard,
                              wxFD_OPEN | wxFD_FILE_MUST_EXIST );
 
     if( zipfiledlg.ShowModal() == wxID_CANCEL )
         return;
 
     wxString msg = wxString::Format( _( "\nOpen '%s'\n" ), GetChars( zipfiledlg.GetPath() ) );
     PrintMsg( msg );
 
     wxDirDialog dirDlg( this, _( "Target Directory" ), fn.GetPath(),
                         wxDD_DEFAULT_STYLE | wxDD_DIR_MUST_EXIST );
 
     if( dirDlg.ShowModal() == wxID_CANCEL )
         return;
 
     wxString unzipDir = dirDlg.GetPath() + wxT( "/" );
     msg.Printf( _( "Unzipping project in '%s'\n" ), GetChars( unzipDir ) );
     PrintMsg( msg );
 
     wxFileSystem zipfilesys;
 
     zipfilesys.AddHandler( new wxZipFSHandler );
     zipfilesys.ChangePathTo( zipfiledlg.GetPath() + wxT( "#zip:" ), true );
 
     wxFSFile* zipfile = NULL;
     wxString  localfilename = zipfilesys.FindFirst( wxT( "*.*" ) );
 
     while( !localfilename.IsEmpty() )
     {
         zipfile = zipfilesys.OpenFile( localfilename );
         if( !zipfile )
         {
             DisplayError( this, wxT( "Zip file read error" ) );
             break;
         }
 
         wxFileName uzfn = localfilename.AfterLast( ':' );
         uzfn.MakeAbsolute( unzipDir );
         wxString unzipfilename = uzfn.GetFullPath();
 
         msg.Printf( _( "Extract file '%s'" ), GetChars( unzipfilename ) );
         PrintMsg( msg );
 
         wxInputStream* stream = zipfile->GetStream();
         wxFFileOutputStream* ofile = new wxFFileOutputStream( unzipfilename );
 
         if( ofile->Ok() )
         {
             ofile->Write( *stream );
             PrintMsg( _( " OK\n" ) );
         }
         else
             PrintMsg( _( " *ERROR*\n" ) );
 
         delete ofile;
         delete zipfile;
 
         localfilename = zipfilesys.FindNext();
     }
 
     PrintMsg( wxT( "** end **\n" ) );
 }

void KICAD_MANAGER_FRAME::OnUpdateDefaultPdfBrowser ( wxUpdateUIEvent & event )

Definition at line 37 of file preferences.cpp.

References Pgm().

 {
     event.Check( Pgm().UseSystemPdfBrowser() );
 }

void KICAD_MANAGER_FRAME::OnUpdatePreferredPdfBrowser ( wxUpdateUIEvent & event )

Definition at line 50 of file preferences.cpp.

References Pgm().

 {
     event.Check( !Pgm().UseSystemPdfBrowser() );
 }

void KICAD_MANAGER_FRAME::OnUpdateRequiresProject ( wxUpdateUIEvent & event )

Definition at line 414 of file prjconfig.cpp.

References m_active_project.

 {
     event.Enable( m_active_project );
 }

const wxString KICAD_MANAGER_FRAME::PcbFileName ( )

Definition at line 163 of file mainframe.cpp.

References GetProjectFileName(), and PcbFileExtension.

Referenced by TREEPROJECT_ITEM::Activate(), and OnRunPcbNew().

 {
    wxFileName   fn( GetProjectFileName() );
 
    fn.SetExt( PcbFileExtension );
 
    return fn.GetFullPath();
 }

const wxString KICAD_MANAGER_FRAME::PcbLegacyFileName ( )

Definition at line 173 of file mainframe.cpp.

References GetProjectFileName(), and LegacyPcbFileExtension.

Referenced by TREEPROJECT_ITEM::Activate(), and OnRunPcbNew().

 {
    wxFileName   fn( GetProjectFileName() );
 
    fn.SetExt( LegacyPcbFileExtension );
 
    return fn.GetFullPath();
 }

bool EDA_BASE_FRAME::PostCommandMenuEvent ( int evt_type )

inherited

Function PostCommandMenuEvent.

Post a menu event to the frame, which can be used to trigger actions bound to menu items.

Definition at line 647 of file basicframe.cpp.

Referenced by FOOTPRINT_EDIT_FRAME::OnHotKey(), FOOTPRINT_EDIT_FRAME::OnHotkeyDeleteItem(), FOOTPRINT_EDIT_FRAME::OnHotkeyDuplicateItem(), PCB_EDIT_FRAME::OnHotkeyDuplicateOrArrayItem(), FOOTPRINT_EDIT_FRAME::OnHotkeyEditItem(), FOOTPRINT_EDIT_FRAME::OnHotkeyMoveItem(), FOOTPRINT_EDIT_FRAME::OnHotkeyMoveItemExact(), and FOOTPRINT_EDIT_FRAME::OnHotkeyRotateItem().

 {
     if( evt_type != 0 )
     {
         wxCommandEvent evt( wxEVT_COMMAND_MENU_SELECTED );
         evt.SetEventObject( this );
         evt.SetId( evt_type );
         wxPostEvent( this, evt );
         return true;
     }
 
     return false;
 }

void KICAD_MANAGER_FRAME::PrintMsg ( const wxString & aText )

Displays aText in the text panel.

Parameters

aText The text to display.

Definition at line 201 of file mainframe.cpp.

References m_MessagesBox.

Referenced by Execute(), OnArchiveFiles(), KICAD_MANAGER_FRAME::TERMINATE_HANDLER::OnTerminate(), OnUnarchiveFiles(), and PrintPrjInfo().

 {
     m_MessagesBox->AppendText( aText );
 }

void KICAD_MANAGER_FRAME::PrintPrjInfo ( )

Prints the current working directory name and the projet name on the text panel.

Definition at line 548 of file mainframe.cpp.

References Format(), GetChars(), GetProjectFileName(), and PrintMsg().

Referenced by LoadProject().

 {
     wxString msg = wxString::Format( _( "Project name:\n%s\n" ),
                         GetChars( GetProjectFileName() ) );
     PrintMsg( msg );
 }

void KICAD_MANAGER_FRAME::Process_Config ( wxCommandEvent & event )

Definition at line 556 of file mainframe.cpp.

References DisplayHotkeyList(), EDA_BASE_FRAME::ExportHotkeyConfigToFile(), ID_PREFERENCES_HOTKEY_EXPORT_CONFIG, ID_PREFERENCES_HOTKEY_IMPORT_CONFIG, ID_PREFERENCES_HOTKEY_SHOW_CURRENT_LIST, ID_PREFERENCES_HOTKEY_SHOW_EDITOR, EDA_BASE_FRAME::ImportHotkeyConfigFromFile(), InstallHotkeyFrame(), and m_manager_Hokeys_Descr.

 {
     int        id = event.GetId();
     wxFileName fn;
 
     switch( id )
     {
     // Hotkey IDs
     case ID_PREFERENCES_HOTKEY_SHOW_EDITOR:
         InstallHotkeyFrame( this, m_manager_Hokeys_Descr );
         break;
 
     case ID_PREFERENCES_HOTKEY_EXPORT_CONFIG:
         ExportHotkeyConfigToFile( m_manager_Hokeys_Descr, wxT( "kicad" ) );
         break;
 
     case ID_PREFERENCES_HOTKEY_IMPORT_CONFIG:
         ImportHotkeyConfigFromFile( m_manager_Hokeys_Descr, wxT( "kicad" ) );
         break;
 
     case ID_PREFERENCES_HOTKEY_SHOW_CURRENT_LIST:
         // Display current hotkey list for LibEdit.
         DisplayHotkeyList( this, m_manager_Hokeys_Descr );
         break;
 
     default:
         wxFAIL_MSG( wxT( "KICAD_MANAGER_FRAME::Process_Config error" ) );
         break;
     }
 }

void KICAD_MANAGER_FRAME::Process_Preferences ( wxCommandEvent & event )

bool EDA_BASE_FRAME::ProcessEvent ( wxEvent & aEvent )

overrideinherited

Function ProcessEvent overrides the default process event handler to implement the auto save feature.

Warning: If you override this function in a derived class, make sure you call down to this or the auto save feature will be disabled.

Definition at line 166 of file basicframe.cpp.

References EDA_BASE_FRAME::isAutoSaveRequired(), EDA_BASE_FRAME::m_autoSaveInterval, EDA_BASE_FRAME::m_autoSaveState, EDA_BASE_FRAME::m_autoSaveTimer, EDA_BASE_FRAME::m_hasAutoSave, and traceAutoSave.

Referenced by LIB_VIEW_FRAME::onSelectNextSymbol(), LIB_VIEW_FRAME::onSelectPreviousSymbol(), KIWAY::ProcessEvent(), LIB_VIEW_FRAME::ReCreateListCmp(), and PCBNEW_CONTROL::SwitchUnits().

 {
     if( !wxFrame::ProcessEvent( aEvent ) )
         return false;
 
     if( IsShown() && m_hasAutoSave && IsActive() &&
         (m_autoSaveState != isAutoSaveRequired()) && (m_autoSaveInterval > 0) )
     {
         if( !m_autoSaveState )
         {
             wxLogTrace( traceAutoSave, wxT( "Starting auto save timer." ) );
             m_autoSaveTimer->Start( m_autoSaveInterval * 1000, wxTIMER_ONE_SHOT );
             m_autoSaveState = true;
         }
         else if( m_autoSaveTimer->IsRunning() )
         {
             wxLogTrace( traceAutoSave, wxT( "Stopping auto save timer." ) );
             m_autoSaveTimer->Stop();
             m_autoSaveState = false;
         }
     }
 
     return true;
 }

int EDA_BASE_FRAME::ReadHotkeyConfig ( struct EDA_HOTKEY_CONFIG * aDescList )

inherited

Function ReadHotkeyConfig Read configuration data and fill the current hotkey list with hotkeys.

Parameters

aDescList = current hotkey list descr. to initialize.

Definition at line 658 of file hotkeys_basic.cpp.

 {
     ::ReadHotkeyConfig( GetName(), aDescList );
     return 1;
 }

int EDA_BASE_FRAME::ReadHotkeyConfigFile	(	const wxString &	aFilename,
		struct EDA_HOTKEY_CONFIG *	aDescList
	)

inherited

Function ReadHotkeyConfigFile Read an old configuration file (&ltfile&gt.key) and fill the current hotkey list with hotkeys.

Parameters

aFilename	= file name to read.
aDescList	= current hotkey list descr. to initialize.

Definition at line 601 of file hotkeys_basic.cpp.

References DEFAULT_HOTKEY_FILENAME_EXT, and ParseHotkeyConfig().

Referenced by EDA_BASE_FRAME::ImportHotkeyConfigFromFile().

 {
     wxFileName fn( aFilename );
     fn.SetExt( DEFAULT_HOTKEY_FILENAME_EXT );
 
     wxFile cfgfile( fn.GetFullPath() );
 
     if( !cfgfile.IsOpened() )       // There is a problem to open file
         return 0;
 
     // get length
     cfgfile.SeekEnd();
     wxFileOffset size = cfgfile.Tell();
     cfgfile.Seek( 0 );
 
     // read data
     char*    buffer = new char[size];
     cfgfile.Read( buffer, size );
 
     wxString data( buffer, wxConvUTF8 );
 
     // parse
     ParseHotkeyConfig( data, aDescList );
 
     // cleanup
     delete[] buffer;
     cfgfile.Close();
     return 1;
 }

void KICAD_MANAGER_FRAME::RecreateBaseHToolbar ( )

(Re)Create the horizontal toolbar

Definition at line 491 of file kicad/menubar.cpp.

References ID_H_TOOLBAR, ID_LOAD_PROJECT, ID_NEW_PROJECT, ID_NEW_PROJECT_FROM_TEMPLATE, ID_PROJECT_TREE_REFRESH, ID_READ_ZIP_ARCHIVE, ID_SAVE_AND_ZIP_FILES, ID_SAVE_PROJECT, KiBitmap(), and EDA_BASE_FRAME::m_mainToolBar.

Referenced by KICAD_MANAGER_FRAME().

 {
     // Check if toolbar is not already created
     if( m_mainToolBar != NULL )
         return;
 
     // Allocate memory for m_mainToolBar
     m_mainToolBar = new wxAuiToolBar( this, ID_H_TOOLBAR, wxDefaultPosition, wxDefaultSize,
                                       wxAUI_TB_DEFAULT_STYLE | wxAUI_TB_HORZ_LAYOUT );
 
     // New
     m_mainToolBar->AddTool( ID_NEW_PROJECT, wxEmptyString,
                             KiBitmap( new_project_xpm ),
                             _( "Create new project" ) );
 
     m_mainToolBar->AddTool( ID_NEW_PROJECT_FROM_TEMPLATE, wxEmptyString,
                             KiBitmap( new_project_with_template_xpm ),
                             _( "Create new project from template" ) );
 
     // Load
     m_mainToolBar->AddTool( ID_LOAD_PROJECT, wxEmptyString,
                             KiBitmap( open_project_xpm ),
                             _( "Open existing project" ) );
 
     // Currently there is nothing to save
     // (Kicad manager does not save any info in .pro file)
 #if 0
     // Save
     m_mainToolBar->AddTool( ID_SAVE_PROJECT, wxEmptyString,
                             KiBitmap( save_project_xpm ),
                             _( "Save current project" ) );
 #endif
 
     // Separator
     m_mainToolBar->AddSeparator();
 
     // Archive
     m_mainToolBar->AddTool( ID_SAVE_AND_ZIP_FILES, wxEmptyString,
                             KiBitmap( zip_xpm ),
                             _( "Archive all project files" ) );
 
     // Unarchive
     m_mainToolBar->AddTool( ID_READ_ZIP_ARCHIVE, wxEmptyString,
                             KiBitmap( unzip_xpm ),
                             _( "Unarchive project files from zip archive" ) );
 
     // Separator
     m_mainToolBar->AddSeparator();
 
     // Refresh project tree
     m_mainToolBar->AddTool( ID_PROJECT_TREE_REFRESH, wxEmptyString,
                             KiBitmap( reload_xpm ),
                             _( "Refresh project tree" ) );
 
     // Create m_mainToolBar
     m_mainToolBar->Realize();
 }

void KICAD_MANAGER_FRAME::ReCreateMenuBar ( void )

overridevirtual

(Re)Create the menubar

Reimplemented from EDA_BASE_FRAME.

Definition at line 193 of file kicad/menubar.cpp.

References AddHotkeyConfigMenu(), AddHotkeyName(), EDA_BASE_FRAME::AddMenuIconsOptions(), AddMenuItem(), PGM_BASE::AddMenuLanguageList(), PGM_KICAD::GetFileHistory(), HK_HELP, HK_NEW, HK_NEW_PRJ_TEMPLATE, HK_OPEN, HK_REFRESH, HK_RUN_BM2COMPONENT, HK_RUN_EESCHEMA, HK_RUN_FPEDITOR, HK_RUN_GERBVIEW, HK_RUN_LIBEDIT, HK_RUN_PCBCALCULATOR, HK_RUN_PCBNEW, HK_RUN_PLEDITOR, HK_SAVE, ID_BROWSE_AN_SELECT_FILE, ID_HELP_GET_INVOLVED, ID_LOAD_PROJECT, ID_NEW_PROJECT, ID_NEW_PROJECT_FROM_TEMPLATE, ID_PREFERENCES_CONFIGURE_PATHS, ID_PREFERENCES_HOTKEY_SHOW_CURRENT_LIST, ID_PROJECT_TREE_REFRESH, ID_READ_ZIP_ARCHIVE, ID_SAVE_AND_ZIP_FILES, ID_SAVE_PROJECT, ID_SELECT_DEFAULT_PDF_BROWSER, ID_SELECT_PREFERED_EDITOR, ID_SELECT_PREFERED_PDF_BROWSER, ID_SELECT_PREFERED_PDF_BROWSER_NAME, ID_TO_BITMAP_CONVERTER, ID_TO_GERBVIEW, ID_TO_PCB, ID_TO_PCB_CALCULATOR, ID_TO_PCB_FP_EDITOR, ID_TO_PL_EDITOR, ID_TO_SCH, ID_TO_SCH_LIB_EDITOR, ID_TO_TEXT_EDITOR, KiBitmap(), kicad_Manager_Hokeys_Descr, m_manager_Hokeys_Descr, Pgm(), and PgmTop().

Referenced by KICAD_MANAGER_FRAME().

 {
     wxString msg;
     static wxMenu* openRecentMenu;  // Open Recent submenu,
                                     // static to remember this menu
 
     m_manager_Hokeys_Descr = kicad_Manager_Hokeys_Descr;
 
     // Create and try to get the current  menubar
     wxMenuBar*  menuBar = GetMenuBar();
 
     if( !menuBar )
         menuBar = new wxMenuBar();
 
     // Delete all existing menus so they can be rebuilt.
     // This allows language changes of the menu text on the fly.
     menuBar->Freeze();
 
     // Before deleting, remove the menus managed by m_fileHistory
     // (the file history will be updated when adding/removing files in history)
     if( openRecentMenu )
         PgmTop().GetFileHistory().RemoveMenu( openRecentMenu );
 
     // Delete all existing menus
     while( menuBar->GetMenuCount() )
         delete menuBar->Remove( 0 );
 
     // Recreate all menus:
 
     // Menu File:
     wxMenu* fileMenu = new wxMenu;
 
     // New project creation
     wxMenu* newprjSubMenu = new wxMenu();
     msg = AddHotkeyName( _( "&Project..." ), kicad_Manager_Hokeys_Descr, HK_NEW );
     AddMenuItem( newprjSubMenu, ID_NEW_PROJECT, msg,
                  _( "Create new blank project" ),
                  KiBitmap( new_project_xpm ) );
     msg = AddHotkeyName( _( "Project from &Template..." ),
                          kicad_Manager_Hokeys_Descr, HK_NEW_PRJ_TEMPLATE );
     AddMenuItem( newprjSubMenu, ID_NEW_PROJECT_FROM_TEMPLATE, msg,
                  _( "Create new project from template" ),
                  KiBitmap( new_project_with_template_xpm ) );
     AddMenuItem( fileMenu, newprjSubMenu,
                  wxID_ANY,
                  _( "&New" ),
                  _( "Create new project" ),
                  KiBitmap( new_project_xpm ) );
 
     // Open
     msg = AddHotkeyName( _( "&Open Project..." ), kicad_Manager_Hokeys_Descr, HK_OPEN );
     AddMenuItem( fileMenu, ID_LOAD_PROJECT, msg,
                  _( "Open an existing project" ),
                  KiBitmap( open_project_xpm ) );
 
     // File history
     openRecentMenu = new wxMenu();
     PgmTop().GetFileHistory().UseMenu( openRecentMenu );
     PgmTop().GetFileHistory().AddFilesToMenu( );
     AddMenuItem( fileMenu, openRecentMenu,
                  wxID_ANY,
                  _( "Open &Recent" ),
                  _( "Open a recent project" ),
                  KiBitmap( recent_xpm ) );
 
     // Currently there is nothing to save
     // (Kicad manager does not save any info in .pro file)
 #if 0
     // Save
     msg = AddHotkeyName( _( "&Save" ), kicad_Manager_Hokeys_Descr, HK_SAVE );
     AddMenuItem( fileMenu, ID_SAVE_PROJECT, msg,
                  _( "Save current project" ),
                  KiBitmap( save_project_xpm ) );
 #endif
 
     // Separator
     fileMenu->AppendSeparator();
 
     // Archive
     AddMenuItem( fileMenu,
                  ID_SAVE_AND_ZIP_FILES,
                  _( "&Archive Project..." ),
                  _( "Archive all needed project files into zip archive" ),
                  KiBitmap( zip_xpm ) );
 
     // Unarchive
     AddMenuItem( fileMenu,
                  ID_READ_ZIP_ARCHIVE,
                  _( "&Unarchive Project..." ),
                  _( "Unarchive project files from zip archive" ),
                  KiBitmap( unzip_xpm ) );
 
     // Separator
     fileMenu->AppendSeparator();
 
     // Quit
     AddMenuItem( fileMenu,
                  wxID_EXIT,
                  _( "&Close" ),
                  _( "Close KiCad" ),
                  KiBitmap( exit_xpm ) );
 
      // View Menu:
      wxMenu* viewMenu = new wxMenu();
 
      // Refresh project tree
      msg = AddHotkeyName( _( "&Refresh" ), kicad_Manager_Hokeys_Descr, HK_REFRESH );
      AddMenuItem( viewMenu, ID_PROJECT_TREE_REFRESH, msg,
                   _( "Refresh project tree" ),
                   KiBitmap( reload_xpm ) );
 
     // Menu Browse:
     wxMenu* browseMenu = new wxMenu();
 
     // Text editor
     AddMenuItem( browseMenu,
                  ID_TO_TEXT_EDITOR,
                  _( "Open Text E&ditor" ),
                  _( "Launch preferred text editor" ),
                  KiBitmap( editor_xpm ) );
 
     // View file
     AddMenuItem( browseMenu,
                  ID_BROWSE_AN_SELECT_FILE,
                  _( "&Open Local File" ),
                  _( "Edit local file" ),
                  KiBitmap( browse_files_xpm ) );
 
     // Menu Preferences:
     wxMenu* preferencesMenu = new wxMenu;
 
     // Path configuration edit dialog.
     AddMenuItem( preferencesMenu,
                  ID_PREFERENCES_CONFIGURE_PATHS,
                  _( "Configure Pa&ths" ),
                  _( "Edit path configuration environment variables" ),
                  KiBitmap( path_xpm ) );
 
     // Text editor
     AddMenuItem( preferencesMenu,
                  ID_SELECT_PREFERED_EDITOR,
                  _( "&Set Text Editor" ),
                  _( "Set your preferred text editor" ),
                  KiBitmap( editor_xpm ) );
 
     // PDF Viewer submenu:System browser or user defined checkbox
     wxMenu* SubMenuPdfBrowserChoice = new wxMenu;
 
     // Default
     AddMenuItem( SubMenuPdfBrowserChoice, ID_SELECT_DEFAULT_PDF_BROWSER,
                   _( "System &Default PDF Viewer" ),
                   _( "Use system default PDF viewer" ),
                    KiBitmap( datasheet_xpm ),
                   wxITEM_CHECK );
     SubMenuPdfBrowserChoice->Check( ID_SELECT_DEFAULT_PDF_BROWSER,
                                     Pgm().UseSystemPdfBrowser() );
 
     // Favourite
     AddMenuItem( SubMenuPdfBrowserChoice, ID_SELECT_PREFERED_PDF_BROWSER,
                   _( "&Favourite PDF Viewer" ),
                   _( "Use favourite PDF viewer" ),
                    KiBitmap( datasheet_xpm ),
                   wxITEM_CHECK );
     SubMenuPdfBrowserChoice->Check( ID_SELECT_PREFERED_PDF_BROWSER,
                                     !Pgm().UseSystemPdfBrowser() );
 
     SubMenuPdfBrowserChoice->AppendSeparator();
     // Append PDF Viewer submenu to preferences
     AddMenuItem( SubMenuPdfBrowserChoice,
                  ID_SELECT_PREFERED_PDF_BROWSER_NAME,
                  _( "Set &PDF Viewer" ),
                  _( "Set favourite PDF viewer" ),
                  KiBitmap( datasheet_xpm ) );
 
     // PDF viewer submenu
     AddMenuItem( preferencesMenu, SubMenuPdfBrowserChoice, -1,
                  _( "&PDF Viewer" ),
                  _( "PDF viewer preferences" ),
                  KiBitmap( datasheet_xpm ) );
 
     // Hotkey submenu
     preferencesMenu->AppendSeparator();
     AddHotkeyConfigMenu( preferencesMenu );
 
     // Language submenu
     preferencesMenu->AppendSeparator();
     Pgm().AddMenuLanguageList( preferencesMenu );
 
     // Icons options submenu
     preferencesMenu->AppendSeparator();
     AddMenuIconsOptions( preferencesMenu );
 
     // Menu Tools:
     wxMenu* toolsMenu = new wxMenu;
 
     msg = AddHotkeyName( _( "Edit Schematic" ), kicad_Manager_Hokeys_Descr, HK_RUN_EESCHEMA );
     AddMenuItem( toolsMenu, ID_TO_SCH, msg, KiBitmap( eeschema_xpm ) );
 
     msg = AddHotkeyName( _( "Manage Symbol Libraries" ),
                          kicad_Manager_Hokeys_Descr, HK_RUN_LIBEDIT );
     AddMenuItem( toolsMenu, ID_TO_SCH_LIB_EDITOR, msg, KiBitmap( libedit_xpm ) );
 
     msg = AddHotkeyName( _( "Edit PCB Layout" ),
                          kicad_Manager_Hokeys_Descr, HK_RUN_PCBNEW );
     AddMenuItem( toolsMenu, ID_TO_PCB, msg, KiBitmap( pcbnew_xpm ) );
 
     msg = AddHotkeyName( _( "Edit PCB Footprint" ),
                          kicad_Manager_Hokeys_Descr, HK_RUN_FPEDITOR );
     AddMenuItem( toolsMenu, ID_TO_PCB_FP_EDITOR, msg, KiBitmap( module_editor_xpm ) );
 
     msg = AddHotkeyName( _( "View Gerber Files" ),
                          kicad_Manager_Hokeys_Descr, HK_RUN_GERBVIEW );
     AddMenuItem( toolsMenu, ID_TO_GERBVIEW, msg, KiBitmap( icon_gerbview_small_xpm ) );
 
     msg = AddHotkeyName( _( "Convert Image" ),
                          kicad_Manager_Hokeys_Descr, HK_RUN_BM2COMPONENT );
     AddMenuItem( toolsMenu, ID_TO_BITMAP_CONVERTER, msg,
                  _( "Bitmap2Component - Convert bitmap images to Eeschema\n"
                     "or Pcbnew elements" ),
                  KiBitmap( image_xpm ) );
 
     msg = AddHotkeyName( _( "Run PCB Calculator" ), kicad_Manager_Hokeys_Descr, HK_RUN_PCBCALCULATOR );
     AddMenuItem( toolsMenu, ID_TO_PCB_CALCULATOR, msg,
                  _( "Pcb calculator - Calculator for components, track width, etc." ),
                  KiBitmap( pcbcalculator_xpm ) );
 
     msg = AddHotkeyName( _( "Edit Page Layout" ), kicad_Manager_Hokeys_Descr, HK_RUN_PLEDITOR );
     AddMenuItem( toolsMenu, ID_TO_PL_EDITOR, msg,
                  _( "Pl editor - Worksheet layout editor" ),
                  KiBitmap( pagelayout_load_xpm ) );
 
     // Menu Help:
     wxMenu* helpMenu = new wxMenu;
 
     // Contents
     AddMenuItem( helpMenu, wxID_HELP,
                  _( "KiCad &Manual" ),
                  _( "Open KiCad user manual" ),
                  KiBitmap( online_help_xpm ) );
 
     AddMenuItem( helpMenu, wxID_INDEX,
                  _( "&Getting Started in KiCad" ),
                  _( "Open \"Getting Started in KiCad\" guide for beginners" ),
                  KiBitmap( help_xpm ) );
 
     AddMenuItem( helpMenu,
                  ID_PREFERENCES_HOTKEY_SHOW_CURRENT_LIST,
                  _( "&List Hotkeys" ),
                  _( "Displays the current hotkeys list and corresponding commands" ),
                  KiBitmap( hotkeys_xpm ) );
 
     // Separator
     helpMenu->AppendSeparator();
 
     // Get involved with KiCad
     AddMenuItem( helpMenu, ID_HELP_GET_INVOLVED,
                  _( "Get &Involved" ),
                  _( "Contribute to KiCad (opens a web browser)" ),
                  KiBitmap( info_xpm ) );
 
     helpMenu->AppendSeparator();
 
     // About
     AddMenuItem( helpMenu, wxID_ABOUT,
                  _( "&About KiCad" ),
                  _( "About KiCad" ),
                  KiBitmap( about_xpm ) );
 
     // Create the menubar and append all submenus
     menuBar->Append( fileMenu, _( "&File" ) );
     menuBar->Append( viewMenu, _( "&View" ) );
     menuBar->Append( toolsMenu, _( "&Tools" ) );
     menuBar->Append( browseMenu, _( "&Browse" ) );
     menuBar->Append( preferencesMenu, _( "&Preferences" ) );
     menuBar->Append( helpMenu, _( "&Help" ) );
 
     menuBar->Thaw();
 
     // Associate the menu bar with the frame, if no previous menubar
     if( GetMenuBar() == NULL )
         SetMenuBar( menuBar );
     else
         menuBar->Refresh();
 
     // Add the hotkey to the "show hotkey list" menu, because we do not have
     // a management of the keyboard keys in Kicad.
     // So all hotheys should be added to the menubar
     // Note Use wxMenuBar::SetLabel only after the menubar
     // has been associated with a frame. (see wxWidgets doc)
     msg = AddHotkeyName( menuBar->GetLabel( ID_PREFERENCES_HOTKEY_SHOW_CURRENT_LIST ),
                          kicad_Manager_Hokeys_Descr, HK_HELP );
     menuBar->SetLabel( ID_PREFERENCES_HOTKEY_SHOW_CURRENT_LIST, msg );
 }

void KICAD_MANAGER_FRAME::ReCreateTreePrj ( )

Definition at line 183 of file mainframe.cpp.

References m_LeftWin, and TREE_PROJECT_FRAME::ReCreateTreePrj().

 {
     m_LeftWin->ReCreateTreePrj();
 }

void KICAD_MANAGER_FRAME::RunEeschema ( const wxString & aProjectSchematicFileName )

Call this only for a SCH associated with the current project.

That is, it must have the same path and name as the project *.pro file.

Definition at line 296 of file mainframe.cpp.

References FRAME_SCH, Kiway, KIWAY_PLAYER::OpenProjectFiles(), KIWAY::Player(), and IO_ERROR::What().

Referenced by OnRunEeschema().

 {
     KIWAY_PLAYER* frame = Kiway.Player( FRAME_SCH, false );
 
     // Please: note: DIALOG_EDIT_LIBENTRY_FIELDS_IN_LIB::initBuffers() calls
     // Kiway.Player( FRAME_SCH, true )
     // therefore, the schematic editor is sometimes running, but the schematic project
     // is not loaded, if the library editor was called, and the dialog field editor was used.
     // On linux, it happens the first time the schematic editor is launched, if
     // library editor was running, and the dialog field editor was open
     // On Windows, it happens always after the library editor was called,
     // and the dialog field editor was used
     if( !frame )
     {
         try
         {
             frame = Kiway.Player( FRAME_SCH, true );
         }
         catch( IO_ERROR err )
         {
             wxMessageBox( _( "Eeschema failed to load:\n" ) + err.What(),
                           _( "KiCad Error" ), wxOK | wxICON_ERROR, this );
             return;
         }
     }
 
     if( !frame->IsShown() ) // the frame exists, (created by the dialog field editor)
                             // but no project loaded.
     {
         frame->OpenProjectFiles( std::vector<wxString>( 1, aProjectSchematicFileName ) );
         frame->Show( true );
     }
 
     // On Windows, Raise() does not bring the window on screen, when iconized or not shown
     // On linux, Raise() brings the window on screen, but this code works fine
     if( frame->IsIconized() )
         frame->Iconize( false );
 
     frame->Raise();
 }

void KICAD_MANAGER_FRAME::RunPcbNew ( const wxString & aProjectBoardFileName )

Call this only for a PCB associated with the current project.

That is, it must have the same path and name as the project *.pro file.

Definition at line 374 of file mainframe.cpp.

References FRAME_PCB, Kiway, KIWAY_PLAYER::OpenProjectFiles(), KIWAY::Player(), and IO_ERROR::What().

Referenced by OnRunPcbNew().

 {
     KIWAY_PLAYER* frame;
 
     try
     {
         frame = Kiway.Player( FRAME_PCB, true );
     }
     catch( IO_ERROR err )
     {
         wxMessageBox( _( "Pcbnew failed to load:\n" ) + err.What(), _( "KiCad Error" ),
                       wxOK | wxICON_ERROR, this );
         return;
     }
 
     // a pcb frame can be already existing, but not yet used.
     // this is the case when running the footprint editor, or the footprint viewer first
     // if the frame is not visible, the board is not yet loaded
     if( !frame->IsVisible() )
     {
         frame->OpenProjectFiles( std::vector<wxString>( 1, aProjectBoardFileName ) );
         frame->Show( true );
     }
 
     // On Windows, Raise() does not bring the window on screen, when iconized
     if( frame->IsIconized() )
         frame->Iconize( false );
 
     frame->Raise();
 }

virtual void EDA_BASE_FRAME::SaveProjectSettings ( bool aAskForSave )

inlinevirtualinherited

Function SaveProjectSettings saves changes to the project settings to the project (.pro) file.

The method is virtual so you can override it to call the suitable save method. The base method do nothing

Parameters

aAskForSave = true to open a dialog before saving the settings

Reimplemented in PCB_EDIT_FRAME, and SCH_EDIT_FRAME.

Definition at line 274 of file wxstruct.h.

Referenced by DIALOG_PAGES_SETTINGS::OnOkClick().

274 {};

void KICAD_MANAGER_FRAME::SaveSettings ( wxConfigBase * aCfg )

overridevirtual

Function SaveSettings saves common frame parameters to a configuration data file.

Don't forget to call the base class's SaveSettings() from your derived SaveSettings() otherwise the frames won't remember their positions and sizes.

Reimplemented from EDA_BASE_FRAME.

Definition at line 541 of file mainframe.cpp.

References m_LeftWin, EDA_BASE_FRAME::SaveSettings(), and TREE_FRAME_WIDTH_ENTRY.

 {
     EDA_BASE_FRAME::SaveSettings( aCfg );
     aCfg->Write( TREE_FRAME_WIDTH_ENTRY, m_LeftWin->GetSize().x );
 }

const wxString KICAD_MANAGER_FRAME::SchFileName ( )

Definition at line 153 of file mainframe.cpp.

References GetProjectFileName(), and SchematicFileExtension.

Referenced by TREEPROJECT_ITEM::Activate().

 {
    wxFileName   fn( GetProjectFileName() );
 
    fn.SetExt( SchematicFileExtension );
 
    return fn.GetFullPath();
 }

void EDA_BASE_FRAME::SetAutoSaveInterval ( int aInterval )

inherited

Definition at line 205 of file basicframe.cpp.

References EDA_BASE_FRAME::m_autoSaveInterval, EDA_BASE_FRAME::m_autoSaveState, and EDA_BASE_FRAME::m_autoSaveTimer.

Referenced by DIALOG_GENERALOPTIONS::OnOkClick(), and SCH_EDIT_FRAME::OnPreferencesOptions().

 {
     m_autoSaveInterval = aInterval;
 
     if( m_autoSaveTimer->IsRunning() )
     {
         if( m_autoSaveInterval > 0 )
         {
             m_autoSaveTimer->Start( m_autoSaveInterval * 1000, wxTIMER_ONE_SHOT );
         }
         else
         {
             m_autoSaveTimer->Stop();
             m_autoSaveState = false;
         }
     }
 }

void EDA_BASE_FRAME::SetMruPath ( const wxString & aPath )

inlineinherited

Definition at line 361 of file wxstruct.h.

Referenced by EDA_BASE_FRAME::ExportHotkeyConfigToFile(), EDA_BASE_FRAME::ImportHotkeyConfigFromFile(), and LoadProject().

361 { m_mruPath = aPath; }

EDA_BASE_FRAME::m_mruPath

wxString m_mruPath

Most recently used path.

Definition: wxstruct.h:160

void KICAD_MANAGER_FRAME::SetProjectFileName ( const wxString & aFullProjectProFileName )

Definition at line 135 of file mainframe.cpp.

References Prj(), and PROJECT::SetProjectFullName().

Referenced by CreateNewProject(), and LoadProject().

 {
     // ensure file name is absolute:
     wxFileName fn( aFullProjectProFileName );
 
     if( !fn.IsAbsolute() )
         fn.MakeAbsolute();
 
     Prj().SetProjectFullName( fn.GetFullPath() );
 }

void EDA_BASE_FRAME::ShowChangedIcons ( )

virtualinherited

Function ShowChangedIcons redraws items menus after a icon was changed option.

Definition at line 249 of file basicframe.cpp.

References EDA_BASE_FRAME::ReCreateMenuBar().

Referenced by KIWAY::ShowChangedIcons().

 {
     ReCreateMenuBar();
     GetMenuBar()->Refresh();
 }

void EDA_BASE_FRAME::ShowChangedLanguage ( )

virtualinherited

Function ShowChangedLanguage redraws the menus and what not in current language.

Reimplemented in PCB_EDIT_FRAME, and GERBVIEW_FRAME.

Definition at line 242 of file basicframe.cpp.

References EDA_BASE_FRAME::ReCreateMenuBar().

Referenced by KIWAY::SetLanguage(), GERBVIEW_FRAME::ShowChangedLanguage(), and PCB_EDIT_FRAME::ShowChangedLanguage().

 {
     ReCreateMenuBar();
     GetMenuBar()->Refresh();
 }

const SEARCH_STACK & KICAD_MANAGER_FRAME::sys_search ( )

overrideprivatevirtual

Function sys_search returns a SEARCH_STACK pertaining to entire program, and is overloaded in KICAD_MANAGER_FRAME.

Reimplemented from EDA_BASE_FRAME.

Definition at line 189 of file mainframe.cpp.

References PgmTop(), and PGM_KICAD::SysSearch().

Referenced by CreateNewProject().

 {
     return PgmTop().SysSearch();
 }

void EDA_BASE_FRAME::UpdateFileHistory	(	const wxString &	FullFileName,
		wxFileHistory *	aFileHistory = `NULL`
	)

inherited

Function UpdateFileHistory Updates the list of recently opened files.

Note also the menu is updated, if wxFileHistory::UseMenu was called at init time

Parameters

FullFileName	The full file name including the path.
aFileHistory	The wxFileHistory in use. If NULL, the main application file history is used.

Definition at line 388 of file basicframe.cpp.

References KIFACE_I::GetFileHistory(), and Kiface().

Referenced by GERBVIEW_FRAME::LoadExcellonFiles(), GERBVIEW_FRAME::LoadGerberFiles(), GERBVIEW_FRAME::LoadGerberJobFile(), PL_EDITOR_FRAME::LoadPageLayoutDescrFile(), LoadProject(), OnCloseWindow(), SCH_EDIT_FRAME::OpenProjectFiles(), PCB_EDIT_FRAME::OpenProjectFiles(), PCB_EDIT_FRAME::SavePcbFile(), and GERBVIEW_FRAME::unarchiveFiles().

 {
     wxFileHistory* fileHistory = aFileHistory;
 
     if( !fileHistory )
         fileHistory = &Kiface().GetFileHistory();
 
     fileHistory->AddFileToHistory( FullFileName );
 }

int EDA_BASE_FRAME::WriteHotkeyConfig	(	struct EDA_HOTKEY_CONFIG *	aDescList,
		wxString *	aFullFileName = `NULL`
	)

virtualinherited

Function WriteHotkeyConfig Store the current hotkey list It is stored using the standard wxConfig mechanism or a file.

Parameters

aDescList	= pointer to the current hotkey list.
aFullFileName	= a wxString pointer to a full file name. if NULL, use the standard wxConfig mechanism (default) the output format is: shortcut "key" "function" lines starting with # are comments

Reimplemented in EDA_DRAW_FRAME.

Definition at line 534 of file hotkeys_basic.cpp.

References AddDelimiterString(), EDA_BASE_FRAME::config(), DEFAULT_HOTKEY_FILENAME_EXT, GetChars(), GetNewConfig(), HOTKEYS_CONFIG_KEY, KeyNameFromKeyCode(), EDA_HOTKEY_CONFIG::m_HK_InfoList, EDA_HOTKEY::m_InfoMsg, EDA_HOTKEY::m_KeyCode, EDA_HOTKEY_CONFIG::m_SectionTag, EDA_HOTKEY_CONFIG::m_Title, and TO_UTF8.

Referenced by EDA_BASE_FRAME::ExportHotkeyConfigToFile(), HOTKEYS_EDITOR_DIALOG::TransferDataFromWindow(), and EDA_DRAW_FRAME::WriteHotkeyConfig().

 {
     wxString msg;
     wxString keyname, infokey;
 
     msg = wxT( "$hotkey list\n" );
 
     // Print the current hotkey list
     EDA_HOTKEY** list;
 
     for( ; aDescList->m_HK_InfoList != NULL; aDescList++ )
     {
         if( aDescList->m_Title )
         {
             msg += wxT( "# " );
             msg += *aDescList->m_Title;
             msg += wxT( "\n" );
         }
 
         msg += *aDescList->m_SectionTag;
         msg += wxT( "\n" );
 
         list = aDescList->m_HK_InfoList;
 
         for( ; *list != NULL; list++ )
         {
             EDA_HOTKEY* hk_decr = *list;
             msg    += wxT( "shortcut   " );
             keyname = KeyNameFromKeyCode( hk_decr->m_KeyCode );
             AddDelimiterString( keyname );
             infokey = hk_decr->m_InfoMsg;
             AddDelimiterString( infokey );
             msg += keyname + wxT( ":    " ) + infokey + wxT( "\n" );
         }
     }
 
     msg += wxT( "$Endlist\n" );
 
     if( aFullFileName )
     {
         FILE* file = wxFopen( *aFullFileName, wxT( "wt" ) );
 
         if( file )
         {
             fputs( TO_UTF8( msg ), file );
             fclose( file );
         }
         else
         {
             msg.Printf( wxT( "Unable to write file %s" ), GetChars( *aFullFileName ) );
             return 0;
         }
     }
     else
     {
         wxFileName fn( GetName() );
         fn.SetExt( DEFAULT_HOTKEY_FILENAME_EXT );
         wxConfigBase* config = GetNewConfig( fn.GetFullPath() );
         config->Write( HOTKEYS_CONFIG_KEY, msg );
         delete config;
     }
 
     return 1;
 }