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 The 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 <singleton.h>
#include <exception>
#include <map>
#include <future>
#include <mutex>
#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 KISTATUSBAR;
struct LOAD_MESSAGE;
struct BACKGROUND_JOB;
class BACKGROUND_JOBS_MONITOR;
class NOTIFICATIONS_MANAGER;
class COMMON_SETTINGS;
class SETTINGS_MANAGER;
class LIBRARY_MANAGER;
 
#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();

    void BuildArgvUtf8();
 
    BS::priority_thread_pool& GetThreadPool();
 
    GL_CONTEXT_MANAGER* GetGLContextManager() { return m_singleton.m_GLContextManager; }

    virtual void MacOpenFile( const wxString& aFileName ) = 0;
 
    virtual SETTINGS_MANAGER& GetSettingsManager() const { return *m_settings_manager; }
 
    virtual LIBRARY_MANAGER& GetLibraryManager() const { return *m_library_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; }
 
    KICAD_API_SERVER* ApiServerOrNull() const { return m_api_server.get(); }
#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 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();

    void HandleException( std::exception_ptr aPtr, bool aUnhandled = false );

    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;
    }

    void PreloadDesignBlockLibraries( KIWAY* aKiway );

    void RegisterLibraryLoadStatusBar( KISTATUSBAR* aStatusBar );

    void UnregisterLibraryLoadStatusBar( KISTATUSBAR* aStatusBar );

    void AddLibraryLoadMessages( const std::vector<LOAD_MESSAGE>& aMessages );

    void ClearLibraryLoadMessages();

    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();
    wxString sentryCreateUid();
#endif
 
protected:
    std::unique_ptr<SETTINGS_MANAGER> m_settings_manager;
    std::unique_ptr<LIBRARY_MANAGER> m_library_manager;
    std::unique_ptr<BACKGROUND_JOBS_MONITOR> m_background_jobs_monitor;
    std::unique_ptr<NOTIFICATIONS_MANAGER> m_notifications_manager;

    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;
 
    KICAD_SINGLETON m_singleton;
 
#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;
 
    std::shared_ptr<BACKGROUND_JOB> m_libraryPreloadBackgroundJob;
    std::future<void>               m_libraryPreloadReturn;
    std::atomic_bool                m_libraryPreloadInProgress;
    std::atomic_bool                m_libraryPreloadAbort;
 
    std::vector<KISTATUSBAR*>       m_libraryLoadStatusBars;
    mutable std::mutex              m_libraryLoadStatusBarsMutex;
};
 

KICOMMON_API extern PGM_BASE& Pgm();

KICOMMON_API extern PGM_BASE* PgmOrNull();
 
KICOMMON_API extern void SetPgm( PGM_BASE* pgm );
 
 
#endif  // PGM_BASE_H_