pgm_base.cpp

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 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, see <https://www.gnu.org/licenses/>.
 */

 
#include <wx/html/htmlwin.h>
#include <wx/fs_zip.h>
#include <wx/dir.h>
#include <wx/filename.h>
#include <wx/msgdlg.h>
#include <wx/propgrid/propgrid.h>
#include <wx/stdpaths.h>
#include <wx/sysopt.h>
#include <wx/filedlg.h>
#include <wx/ffile.h>
#include <wx/tooltip.h>
 
#include <advanced_config.h>
#include <api/api_plugin_manager.h>
#include <api/api_server.h>
#include <api/python_manager.h>
#include <app_monitor.h>
#include <background_jobs_monitor.h>
#include <bitmaps.h>
#include <build_version.h>
#include <common.h>
#include <confirm.h>
#include <core/arraydim.h>
#include <id.h>
#include <kicad_curl/kicad_curl.h>
#include <kiplatform/policy.h>
#include <libraries/library_manager.h>
#include <macros.h>
#include <notifications_manager.h>
#include <paths.h>
#include <pgm_base.h>
#include <design_block_library_adapter.h>
#include <policy_keys.h>
#include <settings/common_settings.h>
#include <settings/settings_manager.h>
#include <string_utils.h>
#include <systemdirsappend.h>
#include <thread_pool.h>
#include <trace_helpers.h>
 
#include <widgets/kistatusbar.h>
#include <widgets/wx_splash.h>
 
#ifdef _MSC_VER
#include <winrt/base.h>
#endif
#undef _
#define _(s) s
LANGUAGE_DESCR LanguagesList[] =
{
    { wxLANGUAGE_DEFAULT,    ID_LANGUAGE_DEFAULT,    _( "Default" ),    false },
    { wxLANGUAGE_ARABIC,     ID_LANGUAGE_ARABIC,     wxT( "العربية" ), true },
    { wxLANGUAGE_FARSI,      ID_LANGUAGE_FARSI,      wxT( "فارسی" ), true },
    { wxLANGUAGE_INDONESIAN, ID_LANGUAGE_INDONESIAN, wxT( "Bahasa Indonesia" ), true },
    { wxLANGUAGE_BULGARIAN,  ID_LANGUAGE_BULGARIAN,  wxT( "Български" ), true },
    { wxLANGUAGE_CATALAN,    ID_LANGUAGE_CATALAN,    wxT( "Català" ), true },
    { wxLANGUAGE_CZECH,      ID_LANGUAGE_CZECH,      wxT( "Čeština" ),  true },
    { wxLANGUAGE_DANISH,     ID_LANGUAGE_DANISH,     wxT( "Dansk" ),    true },
    { wxLANGUAGE_GERMAN,     ID_LANGUAGE_GERMAN,     wxT( "Deutsch" ),  true },
    { wxLANGUAGE_GREEK,      ID_LANGUAGE_GREEK,      wxT( "Ελληνικά" ), true },
    { wxLANGUAGE_ESTONIAN,   ID_LANGUAGE_ESTONIAN,   wxT( "Eesti" ),    true },
    { wxLANGUAGE_ENGLISH,    ID_LANGUAGE_ENGLISH,    wxT( "English" ),  true },
    { wxLANGUAGE_SPANISH,    ID_LANGUAGE_SPANISH,    wxT( "Español" ),  true },
    { wxLANGUAGE_SPANISH_MEXICAN, ID_LANGUAGE_SPANISH_MEXICAN,
      wxT( "Español (Latinoamericano)" ),  true },
    { wxLANGUAGE_FRENCH,     ID_LANGUAGE_FRENCH,     wxT( "Français" ), true },
    { wxLANGUAGE_HEBREW,     ID_LANGUAGE_HEBREW,     wxT( "עברית" ), true },
    { wxLANGUAGE_HINDI,      ID_LANGUAGE_HINDI,      wxT( "हिन्दी" ), true },
    { wxLANGUAGE_CROATIAN,   ID_LANGUAGE_CROATIAN,   wxT( "Hrvatski" ), true },
    { wxLANGUAGE_KOREAN,     ID_LANGUAGE_KOREAN,     wxT( "한국어"),       true },
    { wxLANGUAGE_ITALIAN,    ID_LANGUAGE_ITALIAN,    wxT( "Italiano" ), true },
    { wxLANGUAGE_LAOTHIAN,   ID_LANGUAGE_LAOTHIAN,   wxT( "ພາສາລາວ" ), true  },
    { wxLANGUAGE_LATVIAN,    ID_LANGUAGE_LATVIAN,    wxT( "Latviešu" ), true },
    { wxLANGUAGE_LITHUANIAN, ID_LANGUAGE_LITHUANIAN, wxT( "Lietuvių" ), true },
    { wxLANGUAGE_HUNGARIAN,  ID_LANGUAGE_HUNGARIAN,  wxT( "Magyar" ),   true },
    { wxLANGUAGE_DUTCH,      ID_LANGUAGE_DUTCH,      wxT( "Nederlands" ), true },
    { wxLANGUAGE_NORWEGIAN_BOKMAL, ID_LANGUAGE_NORWEGIAN_BOKMAL, wxT( "Norsk Bokmål" ), true },
    { wxLANGUAGE_JAPANESE,   ID_LANGUAGE_JAPANESE,   wxT( "日本語" ),    true },
    { wxLANGUAGE_GEORGIAN,   ID_LANGUAGE_GEORGIAN,   wxT( "ქართული" ), true },
    { wxLANGUAGE_THAI,       ID_LANGUAGE_THAI,       wxT( "ภาษาไทย" ),    true },
    { wxLANGUAGE_POLISH,     ID_LANGUAGE_POLISH,     wxT( "Polski" ),   true },
    { wxLANGUAGE_PORTUGUESE, ID_LANGUAGE_PORTUGUESE, wxT( "Português" ),true },
    { wxLANGUAGE_PORTUGUESE_BRAZILIAN, ID_LANGUAGE_PORTUGUESE_BRAZILIAN,
      wxT( "Português (Brasil)" ), true },
    { wxLANGUAGE_ROMANIAN,   ID_LANGUAGE_ROMANIAN,   wxT( "Română" ), true },
    { wxLANGUAGE_RUSSIAN,    ID_LANGUAGE_RUSSIAN,    wxT( "Русский" ),  true },
    { wxLANGUAGE_SERBIAN,    ID_LANGUAGE_SERBIAN,    wxT( "Српски" ),   true },
    { wxLANGUAGE_SLOVAK,     ID_LANGUAGE_SLOVAK,     wxT( "Slovenčina" ), true },
    { wxLANGUAGE_SLOVENIAN,  ID_LANGUAGE_SLOVENIAN,  wxT( "Slovenščina" ), true },
    { wxLANGUAGE_FINNISH,    ID_LANGUAGE_FINNISH,    wxT( "Suomi" ),    true },
    { wxLANGUAGE_SWEDISH,    ID_LANGUAGE_SWEDISH,    wxT( "Svenska" ),  true },
    { wxLANGUAGE_VIETNAMESE, ID_LANGUAGE_VIETNAMESE, wxT( "Tiếng Việt" ), true },
    { wxLANGUAGE_TAMIL,      ID_LANGUAGE_TAMIL,      wxT( "தமிழ்" ), true },
    { wxLANGUAGE_TELUGU,     ID_LANGUAGE_TELUGU,     wxT( "తెలుగు" ), true },
    { wxLANGUAGE_TURKISH,    ID_LANGUAGE_TURKISH,    wxT( "Türkçe" ),   true },
    { wxLANGUAGE_UKRAINIAN,  ID_LANGUAGE_UKRAINIAN,   wxT( "Українська" ),   true },
    { wxLANGUAGE_CHINESE_SIMPLIFIED, ID_LANGUAGE_CHINESE_SIMPLIFIED,
            wxT( "简体中文" ), true },
    { wxLANGUAGE_CHINESE_TRADITIONAL, ID_LANGUAGE_CHINESE_TRADITIONAL,
            wxT( "繁體中文" ), true },
    { 0, 0, "", false }         // Sentinel
};
#undef _
#define _(s) wxGetTranslation((s))
 
 
BS::priority_thread_pool& PGM_BASE::GetThreadPool()
{
    return *m_singleton.m_ThreadPool;
}
 
 
PGM_BASE::PGM_BASE()
{
    m_locale = nullptr;
    m_Printing = false;
    m_Quitting = false;
    m_argcUtf8 = 0;
    m_argvUtf8 = nullptr;
    m_splash = nullptr;
    m_PropertyGridInitialized = false;
 
    setLanguageId( wxLANGUAGE_DEFAULT );
 
    ForceSystemPdfBrowser( false );
}
 
 
PGM_BASE::~PGM_BASE()
{
    HideSplash();
    Destroy();
 
    for( int n = 0; n < m_argcUtf8; n++ )
    {
        free( m_argvUtf8[n] );
    }
 
    delete[] m_argvUtf8;
 
    delete m_locale;
    m_locale = nullptr;
}
 
 
void PGM_BASE::Destroy()
{
    // The preload reads the design block libraries, so it has to stop before they go
    if( m_libraryPreloadReturn.valid() )
    {
        if( m_libraryPreloadInProgress.load() )
            m_libraryPreloadAbort.store( true );
 
        m_libraryPreloadReturn.wait();
    }
 
    // Clean up library IO plugins before static destruction
    m_library_manager.reset();
 
    KICAD_CURL::Cleanup();
 
    APP_MONITOR::SENTRY::Instance()->Cleanup();
 
#ifdef _MSC_VER
    winrt::uninit_apartment();
#endif
 
    // A project that failed to unload still holds its lock, and removing the lock file during
    // static destruction would run after wxWidgets has torn down its filename conversion.
    if( m_settings_manager )
        m_settings_manager->ReleaseProjectLocks();
 
    // Shut down the thread pool explicitly here, before static destruction begins.
    // On macOS, if the thread pool destructor runs during static destruction
    // (via __cxa_finalize_ranges), the condition variables may be in an invalid state,
    // causing a crash. By destroying the thread pool here, we ensure it's cleaned up
    // while the C++ runtime is still in a valid state.
    m_singleton.Shutdown();
}
 
 
wxApp& PGM_BASE::App()
{
    wxASSERT( wxTheApp );
    return *wxTheApp;
}
 
 
void PGM_BASE::SetTextEditor( const wxString& aFileName )
{
    m_text_editor = aFileName;
    GetCommonSettings()->m_System.text_editor = aFileName;
}
 
 
const wxString& PGM_BASE::GetTextEditor( bool aCanShowFileChooser )
{
    wxString editorname = m_text_editor;
 
    if( !editorname )
    {
        if( !wxGetEnv(  wxT( "EDITOR" ), &editorname ) )
        {
            // If there is no EDITOR variable set, try the desktop default
#ifdef __WXMAC__
            editorname = wxT( "/usr/bin/open -e" );
#elif __WXX11__
            editorname =  wxT( "/usr/bin/xdg-open" );
#endif
        }
    }
 
    // If we still don't have an editor name show a dialog asking the user to select one
    if( !editorname && aCanShowFileChooser )
    {
        DisplayInfoMessage( nullptr, _( "No default editor found, you must choose one." ) );
 
        editorname = AskUserForPreferredEditor();
    }
 
    // If we finally have a new editor name request it to be copied to m_text_editor and
    // saved to the preferences file.
    if( !editorname.IsEmpty() )
        SetTextEditor( editorname );
 
    // m_text_editor already has the same value that editorname, or empty if no editor was
    // found/chosen.
    return m_text_editor;
}
 
 
const wxString PGM_BASE::AskUserForPreferredEditor( const wxString& aDefaultEditor )
{
    // Create a mask representing the executable files in the current platform
#ifdef __WINDOWS__
    wxString mask( _( "Executable file" ) + wxT( " (*.exe)|*.exe" ) );
#else
    wxString mask( _( "Executable file" ) + wxT( " (*)|*" ) );
#endif
 
    // Extract the path, name and extension from the default editor (even if the editor's
    // name was empty, this method will succeed and return empty strings).
    wxString path, name, ext;
    wxFileName::SplitPath( aDefaultEditor, &path, &name, &ext );
 
    // Show the modal editor and return the file chosen (may be empty if the user cancels
    // the dialog).
    return wxFileSelector( _( "Select Preferred Editor" ), path, name, wxT( "." ) + ext,
                           mask, wxFD_OPEN | wxFD_FILE_MUST_EXIST, nullptr );
}
 
 
void PGM_BASE::BuildArgvUtf8()
{
    const wxArrayString& argArray = App().argv.GetArguments();
    m_argcUtf8 = argArray.size();
 
    m_argvUtf8 = new char*[m_argcUtf8 + 1];
    for( int n = 0; n < m_argcUtf8; n++ )
    {
        m_argvUtf8[n] = wxStrdup( argArray[n].ToUTF8() );
    }
 
    m_argvUtf8[m_argcUtf8] = NULL;  // null terminator at end of argv
}
 
 
void PGM_BASE::ShowSplash()
{
    // Disabling until we change to load each DSO at startup rather than lazy-load when needed.
    // Note that once the splash screen is re-enabled, there are some remaining bugs to fix:
    // Any wxWidgets error dialogs that appear during startup are hidden by the splash screen,
    // so we either need to prevent these from happening (probably not feasible) or else change
    // the error-handling path to make sure errors go on top of the splash.
#if 0
    if( m_splash )
        return;
 
    m_splash = new WX_SPLASH( KiBitmap( BITMAPS::splash ), wxSPLASH_CENTRE_ON_SCREEN, 0,
                              NULL, -1, wxDefaultPosition, wxDefaultSize,
                              wxBORDER_NONE | wxSTAY_ON_TOP );
    wxYield();
#endif
}
 
 
void PGM_BASE::HideSplash()
{
    if( !m_splash )
        return;
 
    m_splash->Close( true );
    m_splash->Destroy();
    m_splash = nullptr;
}
 
 
wxString PGM_BASE::DesktopAppIdForProgram( const wxString& aPgmName )
{
#if defined( __WXGTK__ ) && defined( KICAD_DESKTOP_APP_NAME )
    // The prefix varies by build (regular, Flatpak, Nightly) and is supplied by CMake. The main
    // manager keeps the bare app name; the other GUI apps are prefixed.
    if( aPgmName == wxT( "kicad" ) )
        return wxT( KICAD_DESKTOP_APP_NAME );
 
    if( aPgmName == wxT( "eeschema" ) || aPgmName == wxT( "pcbnew" ) || aPgmName == wxT( "gerbview" )
        || aPgmName == wxT( "pcb_calculator" ) )
    {
        // pcb_calculator installs as pcbcalculator to satisfy freedesktop naming rules.
        wxString appName = aPgmName == wxT( "pcb_calculator" ) ? wxT( "pcbcalculator" ) : aPgmName;
        return wxString( wxT( KICAD_DESKTOP_APP_PREFIX ) ) + wxT( "." ) + appName;
    }
#endif
 
    return wxEmptyString;
}
 
 
bool PGM_BASE::InitPgm( bool aHeadless, bool aIsUnitTest )
{
#if defined( __WXMAC__ )
    // Set the application locale to the system default
    wxLogNull noLog;
    wxLocale loc;
    loc.Init();
#endif
 
    // Just make sure we init precreate any folders early for later code
    // In particular, the user cache path is the most likely to be hit by startup code
    PATHS::EnsureUserPathsExist();
 
    KICAD_CURL::Init();
 
    APP_MONITOR::SENTRY::Instance()->Init();
 
    // Initialize the singleton instance
    m_singleton.Init();
 
    wxString pgm_name;

    if( App().argc == 0 )
        pgm_name = wxT( "kicad" );
    else
        pgm_name = wxFileName( App().argv[0] ).GetName().Lower();
 
    APP_MONITOR::SENTRY::Instance()->AddTag( "kicad.app", pgm_name );
 
    wxInitAllImageHandlers();
 
    // libpng warnings such as "iCCP: known incorrect sRGB profile" otherwise pop up for
    // benign plugin and user images; load failures are still reported by the callers
    wxImage::SetDefaultLoadFlags( wxImage::GetDefaultLoadFlags() & ~wxImage::Load_Verbose );
 
#if !wxCHECK_VERSION( 3, 3, 0 )
    // Without this the wxPropertyGridManager segfaults on Windows.
    if( !wxPGGlobalVars )
        wxPGInitResourceModule();
#endif
 
#ifndef __WINDOWS__
    if( wxString( wxGetenv( "HOME" ) ).IsEmpty() )
    {
        DisplayErrorMessage( nullptr, _( "Environment variable HOME is empty.  "
                                         "Unable to continue." ) );
        return false;
    }
#endif
 
    // Init KiCad environment
    // the environment variable KICAD (if exists) gives the kicad path:
    // something like set KICAD=d:\kicad
    bool isDefined = wxGetEnv( wxT( "KICAD" ), &m_kicad_env );
 
    if( isDefined )    // ensure m_kicad_env ends by "/"
    {
        m_kicad_env.Replace( WIN_STRING_DIR_SEP, UNIX_STRING_DIR_SEP );
 
        if( !m_kicad_env.IsEmpty() && m_kicad_env.Last() != '/' )
            m_kicad_env += UNIX_STRING_DIR_SEP;
    }
 
    // Init parameters for configuration
    App().SetVendorName(  wxT( "KiCad" ) );
    App().SetAppName( pgm_name );
 
    m_desktopAppId = DesktopAppIdForProgram( pgm_name );
 
#if defined( __WXGTK__ ) && defined( KICAD_DESKTOP_APP_NAME )
    // On wx >= 3.3.1 wxGTK feeds the class name to gdk_wayland_window_set_application_id(),
    // which lets Wayland compositors resolve the correct window icon and launch feedback. The
    // X11 WM_CLASS is applied per window in EDA_BASE_FRAME instead, because wxGTK derives it
    // from the (human-facing) app display name and would otherwise not match the launcher.
    if( !m_desktopAppId.IsEmpty() )
        App().SetClassName( m_desktopAppId );
#endif
 
    // Analyze the command line & initialize the binary path
    wxString tmp;
    SetLanguagePath();
    SetDefaultLanguage( tmp );
 
#ifdef _MSC_VER
    if( !wxGetEnv( "FONTCONFIG_PATH", NULL ) )
    {
        // We need to set this because the internal fontconfig logic
        // seems to search relative to the dll rather the other logic it
        // has to look for the /etc folder above the dll
        // Also don't set it because we need it in QA cli tests to be set by ctest
        wxSetEnv( "FONTCONFIG_PATH", PATHS::GetWindowsFontConfigDir() );
    }
#endif
 
#ifdef _MSC_VER
    winrt::init_apartment(winrt::apartment_type::single_threaded);
#endif
 
    m_settings_manager = std::make_unique<SETTINGS_MANAGER>();
    m_library_manager = std::make_unique<LIBRARY_MANAGER>();
    m_background_jobs_monitor = std::make_unique<BACKGROUND_JOBS_MONITOR>();
    m_notifications_manager = std::make_unique<NOTIFICATIONS_MANAGER>();
 
    m_plugin_manager = std::make_unique<API_PLUGIN_MANAGER>( &App() );
 
    // Our unit test mocks break if we continue
    // A bug caused InitPgm to terminate early in unit tests and the mocks are...simplistic
    // TODO fix the unit tests so this can be removed
    if( aIsUnitTest )
        return false;
 
    // Something got in the way of settings load: can't continue
    if( !m_settings_manager->IsOK() )
        return false;
 
    // Set up built-in environment variables (and override them from the system environment if set)
    COMMON_SETTINGS* commonSettings = GetCommonSettings();
    commonSettings->InitializeEnvironment();
 
    // Load color settings after env is initialized
    m_settings_manager->ReloadColorSettings();
 
    // Load common settings from disk after setting up env vars
    GetSettingsManager().Load( commonSettings );
 
    // If user doesn't have a saved Python interpreter, try (potentially again) to find one
    if( commonSettings->m_Api.python_interpreter.IsEmpty() )
        commonSettings->m_Api.python_interpreter = PYTHON_MANAGER::FindPythonInterpreter();
 
    // Init user language *before* calling loadSettings, because
    // env vars could be incorrectly initialized on Linux
    // (if the value contains some non ASCII7 chars, the env var is not initialized)
    SetLanguage( tmp, true );
 
    // Now that translations are available, inform the user if the OS is unsupported
    WarnUserIfOperatingSystemUnsupported();
 
    loadCommonSettings();
 
    ReadPdfBrowserInfos();      // needs GetCommonSettings()
 
    GetNotificationsManager().Load();
 
    // TODO(JE): Remove this if apps are refactored to not assume Prj() always works
    // Need to create a project early for now (it can have an empty path for the moment)
    GetSettingsManager().LoadProject( "" );
 
    if( commonSettings->m_Api.enable_server )
        m_plugin_manager->ReloadPlugins();
 
    // This sets the maximum tooltip display duration to 10s (up from 5) but only affects
    // Windows as other platforms display tooltips while the mouse is not moving
    if( !aHeadless )
    {
        wxToolTip::Enable( true );
        wxToolTip::SetAutoPop( 10000 );
    }
 
    if( ADVANCED_CFG::GetCfg().m_UpdateUIEventInterval != 0 )
        wxUpdateUIEvent::SetUpdateInterval( ADVANCED_CFG::GetCfg().m_UpdateUIEventInterval );
 
    // Now the application can safely start, show the splash screen
    if( !aHeadless )
        ShowSplash();
 
    return true;
}
 
 
void PGM_BASE::loadCommonSettings()
{
    m_text_editor = GetCommonSettings()->m_System.text_editor;
 
    for( const std::pair<wxString, ENV_VAR_ITEM> it : GetCommonSettings()->m_Env.vars )
    {
        wxLogTrace( traceEnvVars, wxT( "PGM_BASE::loadSettings: Found entry %s = %s" ),
                    it.first, it.second.GetValue() );
 
        // Do not store the env var PROJECT_VAR_NAME ("KIPRJMOD") definition if for some reason
        // it is found in config. (It is reserved and defined as project path)
        if( it.first == PROJECT_VAR_NAME )
            continue;
 
        // Don't set bogus empty entries in the environment
        if( it.first.IsEmpty() )
            continue;
 
        // Do not overwrite vars set by the system environment with values from the settings file
        if( it.second.GetDefinedExternally() )
            continue;
 
        SetLocalEnvVariable( it.first, it.second.GetValue() );
    }
}
 
 
void PGM_BASE::SaveCommonSettings()
{
    // GetCommonSettings() is not initialized until fairly late in the
    // process startup: InitPgm(), so test before using:
    if( GetCommonSettings() && IsGUI() )
        GetCommonSettings()->m_System.working_dir = wxGetCwd();
}
 
 
COMMON_SETTINGS* PGM_BASE::GetCommonSettings() const
{
    return m_settings_manager ? m_settings_manager->GetCommonSettings() : nullptr;
}
 
 
bool PGM_BASE::SetLanguage( wxString& aErrMsg, bool first_time )
{
    // Suppress wxWidgets error popups if locale is not found
    wxLogNull doNotLog;
 
    if( first_time )
    {
        setLanguageId( wxLANGUAGE_DEFAULT );
 
        // First time SetLanguage is called, the user selected language id is set
        // from common user config settings
        wxString languageSel = GetCommonSettings()->m_System.language;
 
        // Search for the current selection
        for( unsigned ii = 0; LanguagesList[ii].m_KI_Lang_Identifier != 0; ii++ )
        {
            if( LanguagesList[ii].m_Lang_Label == languageSel )
            {
                setLanguageId( LanguagesList[ii].m_WX_Lang_Identifier );
                break;
            }
        }
    }
 
    // dictionary file name without extend (full name is kicad.mo)
    wxString dictionaryName( wxT( "kicad" ) );
 
    delete m_locale;
    m_locale = new wxLocale;
 
    // don't use wxLOCALE_LOAD_DEFAULT flag so that Init() doesn't return
    // false just because it failed to load wxstd catalog
    if( !m_locale->Init( m_language_id ) )
    {
        wxLogTrace( traceLocale, wxT( "This language is not supported by the system." ) );
 
        setLanguageId( wxLANGUAGE_DEFAULT );
        delete m_locale;
 
        m_locale = new wxLocale;
        m_locale->Init( wxLANGUAGE_DEFAULT );
 
        aErrMsg = _( "This language is not supported by the operating system." );
        return false;
    }
    else if( !first_time )
    {
        wxLogTrace( traceLocale, wxT( "Search for dictionary %s.mo in %s" ) ,
                    dictionaryName, m_locale->GetName() );
    }
 
    if( !first_time )
    {
        // If we are here, the user has selected another language.
        // Therefore the new preferred language name is stored in common config.
        // Do NOT store the wxWidgets language Id, it can change between wxWidgets
        // versions, for a given language
        wxString languageSel;
 
        // Search for the current selection language name
        for( unsigned ii = 0;  LanguagesList[ii].m_KI_Lang_Identifier != 0; ii++ )
        {
            if( LanguagesList[ii].m_WX_Lang_Identifier == m_language_id )
            {
                languageSel = LanguagesList[ii].m_Lang_Label;
                break;
            }
        }
 
        COMMON_SETTINGS* cfg = GetCommonSettings();
        cfg->m_System.language = languageSel;
        cfg->SaveToFile( GetSettingsManager().GetPathForSettingsFile( cfg ) );
    }
 
    // Try adding the dictionary if it is not currently loaded
    if( !m_locale->IsLoaded( dictionaryName ) )
        m_locale->AddCatalog( dictionaryName );
 
    // Verify the Kicad dictionary was loaded properly
    // However, for the English language, the dictionary is not mandatory, as
    // all messages are already in English, just restricted to ASCII7 chars,
    // the verification is skipped.
    if( !m_locale->IsLoaded( dictionaryName ) && m_language_id != wxLANGUAGE_ENGLISH )
    {
        wxLogTrace( traceLocale, wxT( "Unable to load dictionary %s.mo in %s" ),
                    dictionaryName, m_locale->GetName() );
 
        setLanguageId( wxLANGUAGE_DEFAULT );
        delete m_locale;
 
        m_locale = new wxLocale;
        m_locale->Init( wxLANGUAGE_DEFAULT );
 
        aErrMsg = _( "The KiCad language file for this language is not installed." );
        return false;
    }
 
    return true;
}
 
 
bool PGM_BASE::SetDefaultLanguage( wxString& aErrMsg )
{
    // Suppress error popups from wxLocale
    wxLogNull doNotLog;
 
    setLanguageId( wxLANGUAGE_DEFAULT );
 
    // dictionary file name without extend (full name is kicad.mo)
    wxString dictionaryName( wxT( "kicad" ) );
 
    delete m_locale;
    m_locale = new wxLocale;
    m_locale->Init();
 
    // Try adding the dictionary if it is not currently loaded
    if( !m_locale->IsLoaded( dictionaryName ) )
        m_locale->AddCatalog( dictionaryName );
 
    // Verify the Kicad dictionary was loaded properly
    // However, for the English language, the dictionary is not mandatory, as
    // all messages are already in English, just restricted to ASCII7 chars,
    // the verification is skipped.
    if( !m_locale->IsLoaded( dictionaryName ) && m_language_id != wxLANGUAGE_ENGLISH )
    {
        wxLogTrace( traceLocale, wxT( "Unable to load dictionary %s.mo in %s" ),
                    dictionaryName, m_locale->GetName() );
 
        setLanguageId( wxLANGUAGE_DEFAULT );
        delete m_locale;
 
        m_locale = new wxLocale;
        m_locale->Init();
 
        aErrMsg = _( "The KiCad language file for this language is not installed." );
        return false;
    }
 
    return true;
}
 
 
void PGM_BASE::SetLanguageIdentifier( int menu_id )
{
    wxLogTrace( traceLocale, wxT( "Select language ID %d from %d possible languages." ),
                menu_id, (int)arrayDim( LanguagesList )-1 );
 
    for( unsigned ii = 0;  LanguagesList[ii].m_KI_Lang_Identifier != 0; ii++ )
    {
        if( menu_id == LanguagesList[ii].m_KI_Lang_Identifier )
        {
            setLanguageId( LanguagesList[ii].m_WX_Lang_Identifier );
            break;
        }
    }
}
 
 
wxString PGM_BASE::GetLanguageTag()
{
    const wxLanguageInfo* langInfo = wxLocale::GetLanguageInfo( m_language_id );
 
    if( !langInfo )
    {
        return "";
    }
    else
    {
        wxString str = langInfo->GetCanonicalWithRegion();
        str.Replace( "_", "-" );
 
        return str;
    }
}
 
 
void PGM_BASE::SetLanguagePath()
{
#ifdef _MSC_VER
    wxLocale::AddCatalogLookupPathPrefix( PATHS::GetWindowsBaseSharePath() + wxT( "locale" ) );
#endif
    wxLocale::AddCatalogLookupPathPrefix( PATHS::GetLocaleDataPath() );
 
    if( PATHS::RunningFromBuildDir() )
    {
        wxFileName fn( Pgm().GetExecutablePath() );
        fn.RemoveLastDir();
        fn.AppendDir( wxT( "translation" ) );
        wxLocale::AddCatalogLookupPathPrefix( fn.GetPath() );
    }
}
 
 
bool PGM_BASE::SetLocalEnvVariable( const wxString& aName, const wxString& aValue )
{
    wxString env;
 
    if( aName.IsEmpty() )
    {
        wxLogTrace( traceEnvVars,
                    wxT( "PGM_BASE::SetLocalEnvVariable: Attempt to set empty variable to "
                         "value %s" ),
                    aValue );
        return false;
    }
 
    // Check to see if the environment variable is already set.
    if( wxGetEnv( aName, &env ) )
    {
        wxLogTrace( traceEnvVars,
                    wxT( "PGM_BASE::SetLocalEnvVariable: Environment variable %s already set "
                         "to %s" ),
                    aName, env );
        return env == aValue;
    }
 
    wxLogTrace( traceEnvVars,
                wxT( "PGM_BASE::SetLocalEnvVariable: Setting local environment variable %s to %s" ),
                aName, aValue );
 
    return wxSetEnv( aName, aValue );
}
 
 
void PGM_BASE::SetLocalEnvVariables()
{
    // Overwrites externally defined environment variable until the next time the application
    // is run.
    for( const std::pair<wxString, ENV_VAR_ITEM> m_local_env_var : GetCommonSettings()->m_Env.vars )
    {
        wxLogTrace( traceEnvVars,
                    wxT( "PGM_BASE::SetLocalEnvVariables: Setting local environment variable %s "
                         "to %s" ),
                    m_local_env_var.first,
                    m_local_env_var.second.GetValue() );
        wxSetEnv( m_local_env_var.first, m_local_env_var.second.GetValue() );
    }
}
 
 
ENV_VAR_MAP& PGM_BASE::GetLocalEnvVariables() const
{
    return GetCommonSettings()->m_Env.vars;
}
 
 
bool PGM_BASE::IsGUI()
{
    if( !wxTheApp )
        return false;
 
    return wxTheApp->IsGUI();
}
 
 
void PGM_BASE::HandleException( std::exception_ptr aPtr, bool aUnhandled )
{
    try
    {
        if( aPtr )
            std::rethrow_exception( aPtr );
    }
    catch( const IO_ERROR& ioe )
    {
        wxLogError( ioe.What() );
 
        if( aUnhandled )
        {
            // Log this IO_ERROR escaped our usual uses (bad)
            APP_MONITOR::SENTRY::Instance()->LogException( ioe.What(), aUnhandled );
        }
    }
    catch( const std::exception& e )
    {
        APP_MONITOR::SENTRY::Instance()->LogException( e.what(), aUnhandled );
 
        wxLogError( wxT( "Unhandled exception class: %s  what: %s" ),
                    From_UTF8( typeid( e ).name() ), From_UTF8( e.what() ) );
    }
    catch( ... )
    {
        // We really shouldn't have these but just in case...
        wxLogError( wxT( "Unhandled exception of unknown type" ) );
 
        if( aUnhandled )
        {
            APP_MONITOR::SENTRY::Instance()->LogException( "Unhandled exception of unknown type", aUnhandled );
        }
    }
}
 
 
void PGM_BASE::HandleAssert( const wxString& aFile, int aLine, const wxString& aFunc,
                             const wxString& aCond, const wxString& aMsg )
{
    wxString assertStr;
 
    // Log the assertion details to standard log
    if( !aMsg.empty() )
    {
        assertStr = wxString::Format( "Assertion failed at %s:%d in %s: %s - %s", aFile, aLine,
                                      aFunc, aCond, aMsg );
    }
    else
    {
        assertStr = wxString::Format( "Assertion failed at %s:%d in %s: %s", aFile, aLine, aFunc,
                                      aCond );
    }
 
#ifndef NDEBUG
    wxLogError( assertStr );
#endif
 
#ifdef KICAD_USE_SENTRY
    APP_MONITOR::ASSERT_CACHE_KEY key = { aFile, aLine, aFunc, aCond };
    APP_MONITOR::SENTRY::Instance()->LogAssert( key, assertStr );
#endif
}
 
 
const wxString& PGM_BASE::GetExecutablePath() const
{
    return PATHS::GetExecutablePath();
}
 
 
void PGM_BASE::ReadPdfBrowserInfos()
{
    SetPdfBrowserName( GetCommonSettings()->m_System.pdf_viewer_name );
    m_use_system_pdf_browser = GetCommonSettings()->m_System.use_system_pdf_viewer;
}
 
 
void PGM_BASE::WritePdfBrowserInfos()
{
    GetCommonSettings()->m_System.pdf_viewer_name = GetPdfBrowserName();
    GetCommonSettings()->m_System.use_system_pdf_viewer = m_use_system_pdf_browser;
}
 
 
void PGM_BASE::PreloadDesignBlockLibraries( KIWAY* aKiway )
{
    // TODO(JE) much of this code can be shared across the 3 preloads
    constexpr static int interval = 150;
    constexpr static int timeLimit = 120000;
 
    if( m_libraryPreloadInProgress.load() )
        return;
 
    m_libraryPreloadBackgroundJob =
            Pgm().GetBackgroundJobMonitor().Create( _( "Loading Design Block Libraries" ) );
 
    auto preload =
        [this, aKiway]() -> void
        {
            std::shared_ptr<BACKGROUND_JOB_REPORTER> reporter =
                    m_libraryPreloadBackgroundJob->m_reporter;
 
            DESIGN_BLOCK_LIBRARY_ADAPTER* adapter = aKiway->Prj().DesignBlockLibs();
 
            int elapsed = 0;
            bool aborted = false;
 
            reporter->Report( _( "Loading Design Block Libraries" ) );
            adapter->AsyncLoad();
 
            while( true )
            {
                if( m_libraryPreloadAbort.load() )
                {
                    m_libraryPreloadAbort.store( false );
                    aborted = true;
                    break;
                }
 
                std::this_thread::sleep_for( std::chrono::milliseconds( interval ) );
 
                if( std::optional<float> loadStatus = adapter->AsyncLoadProgress() )
                {
                    float progress = *loadStatus;
                    reporter->SetCurrentProgress( progress );
 
                    if( progress >= 1 )
                        break;
                }
                else
                {
                    reporter->SetCurrentProgress( 1 );
                    break;
                }
 
                elapsed += interval;
 
                if( elapsed > timeLimit )
                    break;
            }
 
            // AbortAsyncLoad() sets the adapter's worker abort flag and then blocks,
            // so workers exit at their next checkpoint. BlockUntilLoaded() alone just
            // waits for each future to complete naturally, which can hang indefinitely
            // if a worker is stuck on a stalled network or filesystem operation.
            if( aborted )
                adapter->AbortAsyncLoad();
            else
                adapter->BlockUntilLoaded();
 
            Pgm().GetBackgroundJobMonitor().Remove( m_libraryPreloadBackgroundJob );
            m_libraryPreloadBackgroundJob.reset();
            m_libraryPreloadInProgress.store( false );
 
            std::string payload = "";
            aKiway->ExpressMail( FRAME_SCH, MAIL_RELOAD_LIB, payload, nullptr, true );
            aKiway->ExpressMail( FRAME_PCB_EDITOR, MAIL_RELOAD_LIB, payload, nullptr, true );
        };
 
    // The preload waits on loads it queues on the pool, so it must not hold a pool thread itself
    m_libraryPreloadInProgress.store( true );
    m_libraryPreloadReturn = std::async( std::launch::async, preload );
}
 
 
void PGM_BASE::RegisterLibraryLoadStatusBar( KISTATUSBAR* aStatusBar )
{
    std::lock_guard<std::mutex> lock( m_libraryLoadStatusBarsMutex );
 
    wxLogTrace( traceLibraries, "RegisterLibraryLoadStatusBar: statusBar=%p", aStatusBar );
 
    if( std::find( m_libraryLoadStatusBars.begin(), m_libraryLoadStatusBars.end(), aStatusBar )
        == m_libraryLoadStatusBars.end() )
    {
        m_libraryLoadStatusBars.push_back( aStatusBar );
        wxLogTrace( traceLibraries, "  -> registered, total count=%zu",
                    m_libraryLoadStatusBars.size() );
    }
    else
    {
        wxLogTrace( traceLibraries, "  -> already registered" );
    }
}
 
 
void PGM_BASE::UnregisterLibraryLoadStatusBar( KISTATUSBAR* aStatusBar )
{
    std::lock_guard<std::mutex> lock( m_libraryLoadStatusBarsMutex );
 
    wxLogTrace( traceLibraries, "UnregisterLibraryLoadStatusBar: statusBar=%p", aStatusBar );
 
    m_libraryLoadStatusBars.erase(
            std::remove( m_libraryLoadStatusBars.begin(), m_libraryLoadStatusBars.end(),
                         aStatusBar ),
            m_libraryLoadStatusBars.end() );
 
    wxLogTrace( traceLibraries, "  -> remaining count=%zu", m_libraryLoadStatusBars.size() );
}
 
 
void PGM_BASE::AddLibraryLoadMessages( const std::vector<KI_ERROR>& aMessages )
{
    wxLogTrace( traceLibraries, "AddLibraryLoadMessages: message_count=%zu", aMessages.size() );
 
    if( aMessages.empty() )
        return;
 
    std::lock_guard<std::mutex> lock( m_libraryLoadStatusBarsMutex );
 
    wxLogTrace( traceLibraries, "  -> registered status bars=%zu",
                m_libraryLoadStatusBars.size() );
 
    for( KISTATUSBAR* statusBar : m_libraryLoadStatusBars )
    {
        if( statusBar )
        {
            wxLogTrace( traceLibraries, "  -> forwarding to statusBar=%p", statusBar );
            statusBar->AddWarningMessages( "load", aMessages );
        }
    }
}
 
 
void PGM_BASE::ClearLibraryLoadMessages()
{
    std::lock_guard<std::mutex> lock( m_libraryLoadStatusBarsMutex );
 
    wxLogTrace( traceLibraries, "ClearLibraryLoadMessages: status bars=%zu",
                m_libraryLoadStatusBars.size() );
 
    for( KISTATUSBAR* statusBar : m_libraryLoadStatusBars )
    {
        if( statusBar )
            statusBar->ClearWarningMessages( "load" );
    }
}
 
 
static PGM_BASE* process;
 
 
PGM_BASE& Pgm()
{
    wxASSERT( process ); // KIFACE_GETTER has already been called.
    return *process;
}
 
 
// Similar to PGM_BASE& Pgm(), but return nullptr when a *.ki_face is run from a python script.
PGM_BASE* PgmOrNull()
{
    return process;
}
 
 
void SetPgm( PGM_BASE* pgm )
{
    process = pgm;
}