Class KICAD_MANAGER_FRAME is 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
	Function OnChangeIconsOptions Selects 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)
	Function OnLoadProject loads an exiting or creates a new project (.pro) file. More...

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

void	OnSaveProject (wxCommandEvent &event)
	Function OnSaveProject is the command event hendler to 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)
	Function PrintMsg displays aText in the text panel. More...

void	PrintPrjInfo ()
	a minor helper function: Prints the Current Working Dir name and the projet name on the text panel. More...

void	ClearMsg ()
	a minor helper function: 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 wxString &aPrjFullFileName, bool aTemplateSelector)

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)
	Function Execute opens 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

Class KICAD_MANAGER_FRAME is the main KiCad project manager frame.

It is not a KIWAY_PLAYER.

Definition at line 137 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 49 of file mainframe.cpp.

References config(), 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();
 }

KICAD_MANAGER_FRAME::~KICAD_MANAGER_FRAME ( )

Definition at line 118 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 671 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 576 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 ( )

a minor helper function: Erase the text panel.

Definition at line 526 of file mainframe.cpp.

References m_MessagesBox.

Referenced by CreateNewProject(), and OnLoadProject().

 {
     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 124 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 256 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 wxString &	aPrjFullFileName,
		bool	aTemplateSelector = `false`
	)

Definition at line 59 of file prjconfig.cpp.

References DIALOG_TEMPLATE_SELECTOR::AddTemplatesPage(), ClearMsg(), PROJECT::ConfigSave(), PROJECT_TEMPLATE::CreateProject(), GeneralGroupName, DIALOG_TEMPLATE_SELECTOR::GetSelectedTemplate(), KiCadPcbFileExtension, LegacyPcbFileExtension, m_active_project, m_MessagesBox, PgmTop(), Prj(), SchematicFileExtension, SEP, and SetProjectFileName().

Referenced by OnCreateProjectFromTemplate(), and OnLoadProject().

 {
     wxFileName  newProjectName = aPrjFullFileName;
     wxChar      sep[2] = { SEP(), 0 };  // nul terminated separator wxChar string.
 
     ClearMsg();
 
     // If we are creating a project from a template, make sure the template directory is sane
     if( aTemplateSelector )
     {
         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
         int result = ps->ShowModal();
 
         if( ( result != wxID_OK ) || ( ps->GetSelectedTemplate() == NULL ) )
         {
             if( ps->GetSelectedTemplate() == NULL )
             {
                 wxMessageBox( _( "No project template was selected.  Cannot generate new "
                                  "project." ),
                               _( "Error" ),
                               wxOK | wxICON_ERROR,
                               this );
             }
         }
         else
         {
             // The selected template widget contains the template we're attempting to use to
             // create a project
             if( !ps->GetSelectedTemplate()->CreateProject( newProjectName ) )
             {
                 wxMessageBox( _( "Problem whilst creating new project from template!" ),
                               _( "Template Error" ),
                               wxOK | wxICON_ERROR,
                               this );
             }
         }
     }
 
     // Init project filename
     SetProjectFileName( newProjectName.GetFullPath() );
 
     // Write settings to project file
     // was: wxGetApp().WriteProjectConfig( aPrjFullFileName, GeneralGroupName, s_KicadManagerParams );
     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( newProjectName.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
     }
 
     // Enable the toolbar and menubar buttons and clear the help text.
     m_active_project = true;
     m_MessagesBox->Clear();
 }

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`
	)

Function Execute opens 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 268 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 215 of file wxstruct.h.

References EDA_BASE_FRAME::m_autoSaveInterval.

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

215 { return m_autoSaveInterval; }

EDA_BASE_FRAME::m_autoSaveInterval

int m_autoSaveInterval

The auto save interval time in seconds.

Definition: wxstruct.h:149

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(), 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 525 of file basicframe.cpp.

References ShowAboutDialog().

 {
     bool ShowAboutDialog(wxWindow * parent);
     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 = _( "Could not launch the default browser. For information on how to help the KiCad project, visit " );
         msg.Append( 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 359 of file wxstruct.h.

References EDA_BASE_FRAME::m_mruPath.

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

359 { return m_mruPath; }

EDA_BASE_FRAME::m_mruPath

wxString m_mruPath

Most recently used path.

Definition: wxstruct.h:156

const wxString KICAD_MANAGER_FRAME::GetProjectFileName ( )

Definition at line 144 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(), OnLoadProject(), 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 192 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 169 of file wxstruct.h.

Referenced by EDA_BASE_FRAME::ProcessEvent().

169 { return false; }

bool EDA_BASE_FRAME::IsType ( FRAME_T aType ) const

inlineinherited

Definition at line 217 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().

217 { return m_Ident == aType; }

EDA_BASE_FRAME::m_Ident

FRAME_T m_Ident

Id Type (pcb, schematic, library..)

Definition: wxstruct.h:129

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 532 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 519 of file mainframe.cpp.

References Kiway, and KIWAY::SetLanguage().

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

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 532 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 141 of file kicad/files-io.cpp.

References DIM, 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() )
         return;
 
     wxSetWorkingDirectory( currdirname );
 
     // Prepare the zip file
     wxString zipfilename = zip.GetFullPath();
 
     wxFFileOutputStream ostream( zipfilename );
     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

Function OnChangeIconsOptions Selects 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 444 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 1089 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 213 of file mainframe.cpp.

References 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;
 
         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 590 of file mainframe.cpp.

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

 {
     Pgm().ConfigurePaths( this );
 }

void KICAD_MANAGER_FRAME::OnCreateProjectFromTemplate ( wxCommandEvent & event )

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

and open this new projrct as working project

Definition at line 359 of file prjconfig.cpp.

References CreateNewProject(), OnLoadProject(), 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" ) );
 
     // Launch the template selector dialog, and copy files
     CreateNewProject( fn.GetFullPath(), true );
 
     // Initialize the project
     event.SetId( wxID_ANY );
     OnLoadProject( event );
 }

void KICAD_MANAGER_FRAME::OnExit ( wxCommandEvent & event )

Definition at line 241 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(), Kiway, OnLoadProject(), PgmTop(), KIWAY::PlayersClose(), and SetProjectFileName().

Referenced by PGM_KICAD::OnPgmInit().

 {
     wxString fn = GetFileFromHistory( event.GetId(),
                     _( "KiCad project file" ), &PgmTop().GetFileHistory() );
 
     if( fn.size() )
     {
         // Any open KIFACE's must be closed before changing the project.
         // We never want a KIWAY_PLAYER open on a KIWAY that isn't in the same project,
         // and then break one project.
         // Remember when saving files, the full path is build from the current project path
         // User is prompted here to close those KIWAY_PLAYERs:
         if( !Kiway.PlayersClose( false ) )
             return;
 
         // We can now set the new project filename and load this project
         SetProjectFileName( fn );
         wxCommandEvent cmd( 0, wxID_ANY );
         OnLoadProject( cmd );
     }
 }

void KICAD_MANAGER_FRAME::OnLoadProject ( wxCommandEvent & event )

Function OnLoadProject loads an exiting or creates a new project (.pro) file.

Definition at line 207 of file prjconfig.cpp.

References ClearMsg(), PROJECT::ConfigLoad(), CreateNewProject(), DisplayError(), Format(), GeneralGroupName, GetChars(), PGM_KICAD::GetFileHistory(), EDA_BASE_FRAME::GetMruPath(), GetProjectFileName(), ID_INIT_WATCHED_PATHS, ID_NEW_PROJECT, ID_NEW_PROJECT_FROM_TEMPLATE, IsOK(), Kiway, m_active_project, m_LeftWin, m_MessagesBox, NAMELESS_PROJECT, PgmTop(), KIWAY::PlayersClose(), PrintPrjInfo(), Prj(), ProjectFileExtension, ProjectFileWildcard, TREE_PROJECT_FRAME::ReCreateTreePrj(), EDA_BASE_FRAME::SetMruPath(), SetProjectFileName(), and EDA_BASE_FRAME::UpdateFileHistory().

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

 {
     // 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;
 
     // evt_id can be one of:
     //   ID_NEW_PROJECT, ID_NEW_PROJECT_FROM_TEMPLATE, ID_LOAD_PROJECT, and
     //   wxID_ANY from 3 different places.
     int evt_id = event.GetId();
 
     wxString    title;
 
     ClearMsg();
 
     bool newProject = ( evt_id == ID_NEW_PROJECT ) ||
                         ( evt_id == ID_NEW_PROJECT_FROM_TEMPLATE );
 
     if( evt_id != wxID_ANY )
     {
         int  style;
 
         if( newProject )
         {
             title = _( "Create New Project" );
             style = wxFD_SAVE | wxFD_OVERWRITE_PROMPT;
         }
         else
         {
             title = _( "Open Existing Project" );
             style = wxFD_OPEN | wxFD_FILE_MUST_EXIST;
         }
 
         wxString        default_dir = GetMruPath();
         wxFileDialog    dlg( this, title, default_dir, wxEmptyString,
                              ProjectFileWildcard, style );
 
         if( dlg.ShowModal() == wxID_CANCEL )
             return;
 
         //DBG( printf( "%s: wxFileDialog::GetPath=%s\n", __func__, TO_UTF8( dlg.GetPath() ) );)
 
         wxFileName pro( dlg.GetPath() );
         pro.SetExt( ProjectFileExtension );     // enforce extension
 
         if( !pro.IsAbsolute() )
             pro.MakeAbsolute();
 
         if( newProject )
         {
             // Check if the project directory is empty
             wxDir directory( pro.GetPath() );
 
             if( directory.HasFiles() )
             {
                 wxString msg = _( "The selected directory is not empty.  We recommend you "
                                   "create projects in their own clean directory.\n\nDo you "
                                   "want to create a new empty directory for the project?" );
 
                 if( IsOK( this, msg ) )
                 {
                     // Append a new directory with the same name of the project file
                     // and try to create it
                     pro.AppendDir( pro.GetName() );
 
                     if( !wxMkdir( pro.GetPath() ) )
                         // There was a problem, undo
                         pro.RemoveLastDir();
                 }
             }
 
             if( evt_id == ID_NEW_PROJECT )
             {
                 CreateNewProject( pro.GetFullPath() );
             }
             else if( evt_id == ID_NEW_PROJECT_FROM_TEMPLATE )
             {
                 // Launch the template selector dialog
                 CreateNewProject( pro.GetFullPath(), true );
             }
         }
 
         SetProjectFileName( pro.GetFullPath() );
     }
 
     wxString prj_filename = GetProjectFileName();
 
     wxString nameless_prj = NAMELESS_PROJECT  wxT( ".pro" );
 
     wxLogDebug( wxT( "%s: %s" ),
                 GetChars( wxFileName( prj_filename ).GetFullName() ),
                 GetChars( nameless_prj ) );
 
     // Check if project file exists and if it is not noname.pro
     if( !wxFileExists( prj_filename )
       && !wxFileName( prj_filename ).GetFullName().IsSameAs( nameless_prj ) )
     {
         wxString msg = wxString::Format( _(
                 "KiCad project file '%s' not found" ),
                 GetChars( prj_filename ) );
 
         DisplayError( this, msg );
         return;
     }
 
     // Either this is the first time kicad has been run or one of the projects in the
     // history list is no longer valid.  This prevents kicad from automatically creating
     // a noname.pro file in the same folder as the kicad binary.
     if( wxFileName( prj_filename ).GetFullName().IsSameAs( nameless_prj ) && !newProject )
     {
         m_active_project = false;
         m_MessagesBox->SetValue( _( "To proceed, you can use the File menu to start a new project." ) );
         return;
     }
     else
     {
         m_active_project = true;
         m_MessagesBox->Clear();
     }
 
     Prj().ConfigLoad( PgmTop().SysSearch(), GeneralGroupName, s_KicadManagerParams );
 
     title = L"KiCad \u2014 " + prj_filename;
 
     if( !wxFileName( prj_filename ).IsDirWritable() )
         title += _( " [Read Only]" );
     else
         SetMruPath( Prj().GetProjectPath() );    // Only set MRU path if we have write access.
 
     SetTitle( title );
 
     if( !prj_filename.IsSameAs( nameless_prj ) )
         UpdateFileHistory( prj_filename, &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::OnOpenFileInEditor ( wxCommandEvent & event )

void KICAD_MANAGER_FRAME::OnOpenFileInTextEditor ( wxCommandEvent & event )

Definition at line 488 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 479 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 513 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 451 of file mainframe.cpp.

References BITMAPCONVERTER_EXE, and Execute().

 {
     Execute( this, BITMAPCONVERTER_EXE );
 }

void KICAD_MANAGER_FRAME::OnRunEeschema ( wxCommandEvent & event )

Definition at line 334 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 470 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 463 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 457 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 415 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->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();
 }

void KICAD_MANAGER_FRAME::OnRunPcbNew ( wxCommandEvent & event )

Definition at line 403 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 342 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->OpenProjectFiles( std::vector<wxString>( 1, aProjectSchematicFileName ) );
         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 )

Function OnSaveProject is the command event hendler to Save the project (.pro) file containing the top level configuration parameters.

Definition at line 383 of file prjconfig.cpp.

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

 {
     if( !wxIsWritable( GetProjectFileName() ) )
         return;
 
     // was: wxGetApp().WriteProjectConfig( m_ProjectFileName.GetFullPath(),
     //          GeneralGroupName, s_KicadManagerParams );
     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 204 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 70 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 394 of file prjconfig.cpp.

References m_active_project.

 {
     event.Enable( m_active_project );
 }

const wxString KICAD_MANAGER_FRAME::PcbFileName ( )

Definition at line 160 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 170 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 645 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 )

Function PrintMsg displays aText in the text panel.

Parameters

aText The text to display.

Definition at line 198 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 ( )

a minor helper function: Prints the Current Working Dir name and the projet name on the text panel.

a minor helper function: Prints the Current Project full name on the text panel.

Definition at line 550 of file mainframe.cpp.

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

Referenced by OnLoadProject().

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

void KICAD_MANAGER_FRAME::Process_Config ( wxCommandEvent & event )

Definition at line 558 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 &&
         (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 476 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_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" ) );
 
     // Save
     m_mainToolBar->AddTool( ID_SAVE_PROJECT, wxEmptyString,
                             KiBitmap( save_project_xpm ),
                             _( "Save current project" ) );
 
     // Separator
     m_mainToolBar->AddSeparator();
 
     // Archive
     m_mainToolBar->AddTool( ID_SAVE_AND_ZIP_FILES, wxEmptyString,
                             KiBitmap( zip_xpm ),
                             _( "Archive all project files" ) );
 
     // 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 187 of file kicad/menubar.cpp.

References AddHotkeyConfigMenu(), AddHotkeyName(), EDA_BASE_FRAME::AddMenuIconsOptions(), AddMenuItem(), PGM_BASE::AddMenuLanguageList(), PGM_KICAD::GetFileHistory(), HK_HELP, 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_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;
 
     // Open
     msg = AddHotkeyName( _( "&Open Project" ), kicad_Manager_Hokeys_Descr, HK_LOAD_PROJECT );
     AddMenuItem( fileMenu, ID_LOAD_PROJECT, msg,
                  _( "Open 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 recent schematic project" ),
                  KiBitmap( recent_xpm ) );
 
     // New project creation
     wxMenu* newprjSubMenu = new wxMenu();
 
     msg = AddHotkeyName( _( "&New Project" ), kicad_Manager_Hokeys_Descr, HK_NEW_PRJ );
     AddMenuItem( newprjSubMenu, ID_NEW_PROJECT, msg,
                  _( "Create new blank project" ),
                  KiBitmap( new_project_xpm ) );
 
     msg = AddHotkeyName( _( "New 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 Project" ),
                  _( "Create new project" ),
                  KiBitmap( new_project_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_PROJECT );
     AddMenuItem( fileMenu, ID_SAVE_PROJECT, msg,
                  _( "Save current project" ),
                  KiBitmap( save_project_xpm ) );
 #endif
 
     // Archive
     fileMenu->AppendSeparator();
     AddMenuItem( fileMenu,
                  ID_SAVE_AND_ZIP_FILES,
                  _( "&Archive Current 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 ) );
 
     // 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( _( "Run Eeschema" ), kicad_Manager_Hokeys_Descr, HK_RUN_EESCHEMA );
     AddMenuItem( toolsMenu, ID_TO_SCH, msg, KiBitmap( eeschema_xpm ) );
 
     msg = AddHotkeyName( _( "Run Library Editor" ),
                          kicad_Manager_Hokeys_Descr, HK_RUN_LIBEDIT );
     AddMenuItem( toolsMenu, ID_TO_SCH_LIB_EDITOR, msg, KiBitmap( libedit_xpm ) );
 
     msg = AddHotkeyName( _( "Run Pcbnew" ),
                          kicad_Manager_Hokeys_Descr, HK_RUN_PCBNEW );
     AddMenuItem( toolsMenu, ID_TO_PCB, msg, KiBitmap( pcbnew_xpm ) );
 
     msg = AddHotkeyName( _( "Run Footprint Editor" ),
                          kicad_Manager_Hokeys_Descr, HK_RUN_FPEDITOR );
     AddMenuItem( toolsMenu, ID_TO_PCB_FP_EDITOR, msg, KiBitmap( module_editor_xpm ) );
 
     msg = AddHotkeyName( _( "Run Gerbview" ),
                          kicad_Manager_Hokeys_Descr, HK_RUN_GERBVIEW );
     AddMenuItem( toolsMenu, ID_TO_GERBVIEW, msg, KiBitmap( icon_gerbview_small_xpm ) );
 
     msg = AddHotkeyName( _( "Run Bitmap2Component" ),
                          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( _( "Run Page Layout Editor" ), 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( browseMenu, _( "&Browse" ) );
     menuBar->Append( preferencesMenu, _( "&Preferences" ) );
     menuBar->Append( toolsMenu, _( "&Tools" ) );
     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 180 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 292 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 371 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 270 of file wxstruct.h.

Referenced by DIALOG_PAGES_SETTINGS::OnOkClick().

270 {};

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 539 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 150 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 357 of file wxstruct.h.

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

357 { m_mruPath = aPath; }

EDA_BASE_FRAME::m_mruPath

wxString m_mruPath

Most recently used path.

Definition: wxstruct.h:156

void KICAD_MANAGER_FRAME::SetProjectFileName ( const wxString & aFullProjectProFileName )

Definition at line 132 of file mainframe.cpp.

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

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

 {
     // 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 186 of file mainframe.cpp.

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

 {
     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(), PL_EDITOR_FRAME::LoadPageLayoutDescrFile(), OnCloseWindow(), OnLoadProject(), 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;
 }