pgm_base.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2004-2015 Jean-Pierre Charras, jp.charras at wanadoo.fr
 * Copyright (C) 2008-2015 Wayne Stambaugh <[email protected]>
 * Copyright (C) 1992-2021 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
#ifndef PGM_BASE_H_
#define PGM_BASE_H_
 
#include <kicommon.h>
#include <exception>
#include <map>
#include <vector>
#include <memory>
#include <search_stack.h>
#include <settings/environment.h>
#include <wx/filename.h>
 
class wxApp;
class wxMenu;
class wxWindow;
class wxSplashScreen;
class wxSingleInstanceChecker;
 
class BACKGROUND_JOBS_MONITOR;
class NOTIFICATIONS_MANAGER;
class COMMON_SETTINGS;
class SETTINGS_MANAGER;
class SCRIPTING;
 
#ifdef KICAD_IPC_API
class API_PLUGIN_MANAGER;
class KICAD_API_SERVER;
#endif
 
struct KICOMMON_API LANGUAGE_DESCR
{
 int m_WX_Lang_Identifier;
 
 int m_KI_Lang_Identifier;
 
 wxString m_Lang_Label;
 
 bool m_DoNotTranslate;
};
 
 
KICOMMON_API extern LANGUAGE_DESCR LanguagesList[];
 
class KICOMMON_API PGM_BASE
{
public:
 PGM_BASE();
 virtual ~PGM_BASE();
 
#if 0
 /*
 
 Derived classes must implement these two functions: OnPgmInit() and
 OnPgmExit(), and since they are only called from same source file as their
 implementation, these need not be virtual here. In fact, in the case of
 python project manager's class PGM_PYTHON, these functions are actually
 written in python. In total there are three implementations, corresponding
 to the three defines given by kiface.h's KFCTL_* #defines.
 
 */
 
 virtual bool OnPgmInit() = 0; // call this from wxApp::OnInit()
 
 virtual void OnPgmExit() = 0; // call this from wxApp::OnExit()
#endif
 
 void BuildArgvUtf8();
 
 virtual void MacOpenFile( const wxString& aFileName ) = 0;
 
 virtual SETTINGS_MANAGER& GetSettingsManager() const { return *m_settings_manager; }
 
 virtual COMMON_SETTINGS* GetCommonSettings() const;
 
 virtual BACKGROUND_JOBS_MONITOR& GetBackgroundJobMonitor() const { return *m_background_jobs_monitor; }
 
 virtual NOTIFICATIONS_MANAGER& GetNotificationsManager() const { return *m_notifications_manager; }
 
#ifdef KICAD_IPC_API
 virtual API_PLUGIN_MANAGER& GetPluginManager() const { return *m_plugin_manager; }
 
 KICAD_API_SERVER& GetApiServer() { return *m_api_server; }
#endif
 
 virtual void SetTextEditor( const wxString& aFileName );
 
 virtual const wxString& GetTextEditor( bool aCanShowFileChooser = true );
 
 virtual const wxString AskUserForPreferredEditor(
 const wxString& aDefaultEditor = wxEmptyString );
 
 virtual bool IsKicadEnvVariableDefined() const { return !m_kicad_env.IsEmpty(); }
 
 virtual const wxString& GetKicadEnvVariable() const { return m_kicad_env; }
 
 virtual const wxString& GetExecutablePath() const;
 
 virtual wxLocale* GetLocale() { return m_locale; }
 
 virtual const wxString& GetPdfBrowserName() const { return m_pdf_browser; }
 
 virtual void SetPdfBrowserName( const wxString& aFileName ) { m_pdf_browser = aFileName; }
 
 virtual bool UseSystemPdfBrowser() const
 {
 return m_use_system_pdf_browser || m_pdf_browser.IsEmpty();
 }
 
 virtual void ForceSystemPdfBrowser( bool aFlg ) { m_use_system_pdf_browser = aFlg; }
 
 virtual bool SetLanguage( wxString& aErrMsg, bool first_time = false );
 
 bool SetDefaultLanguage( wxString& aErrMsg );
 
 virtual void SetLanguageIdentifier( int menu_id );
 
 virtual int GetSelectedLanguageIdentifier() const { return m_language_id; }
 
 virtual wxString GetLanguageTag();
 
 virtual void SetLanguagePath();
 
 virtual void ReadPdfBrowserInfos();
 
 virtual void WritePdfBrowserInfos();
 
 virtual bool SetLocalEnvVariable( const wxString& aName, const wxString& aValue );
 
 virtual void SetLocalEnvVariables();
 
 virtual ENV_VAR_MAP& GetLocalEnvVariables() const;
 
 virtual wxApp& App();
 
 static const wxChar workingDirKey[];
 
 bool InitPgm( bool aHeadless = false, bool aSkipPyInit = false, bool aIsUnitTest = false );
 
 // The PGM_* classes can have difficulties at termination if they
 // are not destroyed soon enough. Relying on a static destructor can be
 // too late for contained objects like wxSingleInstanceChecker.
 void Destroy();
 
 void SaveCommonSettings();
 
#ifdef KICAD_USE_SENTRY
 bool IsSentryOptedIn();
 
 void SetSentryOptIn( bool aOptIn );
 
 void ResetSentryId();
 
 const wxString& GetSentryId();
#endif
 
 void HandleException( std::exception_ptr aPtr );
 
 void HandleAssert( const wxString& aFile, int aLine, const wxString& aFunc,
 const wxString& aCond, const wxString& aMsg );
 
 bool IsGUI();
 
 
 void ShowSplash();
 void HideSplash();
 
 std::unique_ptr<wxSingleInstanceChecker>& SingleInstance()
 {
 return m_pgm_checker;
 }
 
 bool m_Printing;
 
 std::vector<void*> m_ModalDialogs;
 
 bool m_Quitting;
 
 bool m_PropertyGridInitialized;
 
protected:
 void loadCommonSettings();
 
 void setLanguageId( int aId ) { m_language_id = aId; }
 
#ifdef KICAD_USE_SENTRY
 void sentryInit();
 void sentryPrompt();
 wxString sentryCreateUid();
#endif
 
protected:
 std::unique_ptr<SETTINGS_MANAGER> m_settings_manager;
 std::unique_ptr<BACKGROUND_JOBS_MONITOR> m_background_jobs_monitor;
 std::unique_ptr<NOTIFICATIONS_MANAGER> m_notifications_manager;
 
 std::unique_ptr<SCRIPTING> m_python_scripting;
 
 std::unique_ptr<wxSingleInstanceChecker> m_pgm_checker;
 
#ifdef KICAD_IPC_API
 std::unique_ptr<API_PLUGIN_MANAGER> m_plugin_manager;
 std::unique_ptr<KICAD_API_SERVER> m_api_server;
#endif
 
 wxString m_kicad_env; 
 
 wxLocale* m_locale;
 int m_language_id;
 
 bool m_use_system_pdf_browser;
 wxString m_pdf_browser; 
 
 wxString m_text_editor;
 
#ifdef KICAD_USE_SENTRY
 wxFileName m_sentry_optin_fn;
 wxFileName m_sentry_uid_fn;
 wxString m_sentryUid;
#endif
 
 char** m_argvUtf8; 
 
 int m_argcUtf8;
 
 wxSplashScreen* m_splash;
};
 
 
KICOMMON_API extern PGM_BASE& Pgm();
 
KICOMMON_API extern PGM_BASE* PgmOrNull();
 
KICOMMON_API extern void SetPgm( PGM_BASE* pgm );
 
 
#endif // PGM_BASE_H_