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_