advanced_config.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2019-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
 */

#include <advanced_config.h>

#include <config_params.h>
#include <settings/settings_manager.h>

#include <wx/app.h>
#include <wx/config.h>
#include <wx/filename.h>
#include <wx/log.h>
#include <wx/tokenzr.h>

/*
 * Flag to enable advanced config debugging
 *
 * Use "KICAD_ADVANCED_CONFIG" to enable.
 *
 * @ingroup trace_env_vars
 */
static const wxChar AdvancedConfigMask[] = wxT( "KICAD_ADVANCED_CONFIG" );

namespace AC_STACK
{
 static constexpr int min_stack = 32 * 4096;
 static constexpr int default_stack = 256 * 4096;
 static constexpr int max_stack = 4096 * 4096;
}

namespace AC_KEYS
{

static const wxChar ExtraFillMargin[] = wxT( "ExtraFillMargin" );

static const wxChar DRCEpsilon[] = wxT( "DRCEpsilon" );

static const wxChar HoleWallThickness[] = wxT( "HoleWallPlatingThickness" );

static const wxChar RealtimeConnectivity[] = wxT( "RealtimeConnectivity" );

static const wxChar CoroutineStackSize[] = wxT( "CoroutineStackSize" );

static const wxChar ShowRouterDebugGraphics[] = wxT( "ShowRouterDebugGraphics" );

static const wxChar CompactFileSave[] = wxT( "CompactSave" );

static const wxChar DrawArcAccuracy[] = wxT( "DrawArcAccuracy" );

static const wxChar DrawArcCenterStartEndMaxAngle[] = wxT( "DrawArcCenterStartEndMaxAngle" );

static const wxChar MaxTangentTrackAngleDeviation[] = wxT( "MaxTangentTrackAngleDeviation" );

static const wxChar MaxTrackLengthToKeep[] = wxT( "MaxTrackLengthToKeep" );

static const wxChar StrokeTriangulation[] = wxT( "StrokeTriangulation" );

static const wxChar ExtraZoneDisplayModes[] = wxT( "ExtraZoneDisplayModes" );

static const wxChar MinPlotPenWidth[] = wxT( "MinPlotPenWidth" );

static const wxChar DebugZoneFiller[] = wxT( "DebugZoneFiller" );

static const wxChar DebugPDFWriter[] = wxT( "DebugPDFWriter" );

static const wxChar SmallDrillMarkSize[] = wxT( "SmallDrillMarkSize" );

static const wxChar HotkeysDumper[] = wxT( "HotkeysDumper" );

static const wxChar DrawBoundingBoxes[] = wxT( "DrawBoundingBoxes" );

static const wxChar ShowPcbnewExportNetlist[] = wxT( "ShowPcbnewExportNetlist" );

static const wxChar Skip3DModelFileCache[] = wxT( "Skip3DModelFileCache" );

static const wxChar Skip3DModelMemoryCache[] = wxT( "Skip3DModelMemoryCache" );

static const wxChar HideVersionFromTitle[] = wxT( "HideVersionFromTitle" );

static const wxChar TraceMasks[] = wxT( "TraceMasks" );

static const wxChar ShowRepairSchematic[] = wxT( "ShowRepairSchematic" );

static const wxChar ShowEventCounters[] = wxT( "ShowEventCounters" );

static const wxChar AllowManualCanvasScale[] = wxT( "AllowManualCanvasScale" );

} // namespace KEYS


/*
 * Get a simple string for common parameters.
 *
 * This isn't exhaustive, but it covers most common types that might be
 * used in the advance config
 */
wxString dumpParamCfg( const PARAM_CFG& aParam )
{
 wxString s = aParam.m_Ident + wxT( ": " );

 /*
 * This implementation is rather simplistic, but it is
 * effective enough for simple uses. A better implementation would be
 * some kind of visitor, but that's somewhat more work.
 */
 switch( aParam.m_Type )
 {
 case paramcfg_id::PARAM_INT:
 case paramcfg_id::PARAM_INT_WITH_SCALE:
 s << *static_cast<const PARAM_CFG_INT&>( aParam ).m_Pt_param;
 break;
 case paramcfg_id::PARAM_DOUBLE:
 s << *static_cast<const PARAM_CFG_DOUBLE&>( aParam ).m_Pt_param;
 break;
 case paramcfg_id::PARAM_WXSTRING:
 s << *static_cast<const PARAM_CFG_WXSTRING&>( aParam ).m_Pt_param;
 break;
 case paramcfg_id::PARAM_FILENAME:
 s << *static_cast<const PARAM_CFG_FILENAME&>( aParam ).m_Pt_param;
 break;
 case paramcfg_id::PARAM_BOOL:
 s << ( *static_cast<const PARAM_CFG_BOOL&>( aParam ).m_Pt_param ? wxT( "true" ) : wxT( "false" ) );
 break;
 default: s << wxT( "Unsupported PARAM_CFG variant: " ) << aParam.m_Type;
 }

 return s;
}


static void dumpCfg( const std::vector<PARAM_CFG*>& aArray )
{
 // only dump if we need to
 if( !wxLog::IsAllowedTraceMask( AdvancedConfigMask ) )
 return;

 for( const PARAM_CFG* param : aArray )
 {
 wxLogTrace( AdvancedConfigMask, dumpParamCfg( *param ) );
 }
}


static wxFileName getAdvancedCfgFilename()
{
 const static wxString cfg_filename{ wxT( "kicad_advanced" ) };
 return wxFileName( SETTINGS_MANAGER::GetUserSettingsPath(), cfg_filename );
}


ADVANCED_CFG::ADVANCED_CFG()
{
 wxLogTrace( AdvancedConfigMask, wxT( "Init advanced config" ) );

 // Init defaults - this is done in case the config doesn't exist,
 // then the values will remain as set here.
 m_RealTimeConnectivity = true;
 m_CoroutineStackSize = AC_STACK::default_stack;
 m_ShowRouterDebugGraphics = false;
 m_DrawArcAccuracy = 10.0;
 m_DrawArcCenterMaxAngle = 50.0;
 m_MaxTangentAngleDeviation = 1.0;
 m_MaxTrackLengthToKeep = 0.0005;
 m_ExtraZoneDisplayModes = false;
 m_DrawTriangulationOutlines = false;

 m_ExtraClearance = 0.0005;
 m_DRCEpsilon = 0.0005; // 0.5um is small enough not to materially violate
 // any constraints.

 m_HoleWallThickness = 0.020; // IPC-6012 says 15-18um; Cadence says at least
 // 0.020 for a Class 2 board and at least 0.025
 // for Class 3.

 m_MinPlotPenWidth = 0.0212; // 1 pixel at 1200dpi.

 m_DebugZoneFiller = false;
 m_DebugPDFWriter = false;
 m_SmallDrillMarkSize = 0.35;
 m_HotkeysDumper = false;
 m_DrawBoundingBoxes = false;
 m_ShowPcbnewExportNetlist = false;
 m_Skip3DModelFileCache = false;
 m_Skip3DModelMemoryCache = false;
 m_HideVersionFromTitle = false;
 m_ShowEventCounters = false;
 m_AllowManualCanvasScale = false;

 loadFromConfigFile();
}


const ADVANCED_CFG& ADVANCED_CFG::GetCfg()
{
 static ADVANCED_CFG instance;
 return instance;
}


void ADVANCED_CFG::loadFromConfigFile()
{
 const wxFileName k_advanced = getAdvancedCfgFilename();

 // If we are running headless, use the class defaults because we cannot instantiate wxConfig
 if( !wxTheApp )
 return;

 if( !k_advanced.FileExists() )
 {
 wxLogTrace( AdvancedConfigMask, wxT( "File does not exist %s" ), k_advanced.GetFullPath() );

 // load the defaults
 wxConfig emptyConfig;
 loadSettings( emptyConfig );

 return;
 }

 wxLogTrace( AdvancedConfigMask, wxT( "Loading advanced config from: %s" ), k_advanced.GetFullPath() );

 wxFileConfig file_cfg( wxEmptyString, wxEmptyString, k_advanced.GetFullPath() );
 loadSettings( file_cfg );
}


void ADVANCED_CFG::loadSettings( wxConfigBase& aCfg )
{
 std::vector<PARAM_CFG*> configParams;

 configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::RealtimeConnectivity,
 &m_RealTimeConnectivity, m_RealTimeConnectivity ) );

 configParams.push_back( new PARAM_CFG_DOUBLE( true, AC_KEYS::ExtraFillMargin,
 &m_ExtraClearance, m_ExtraClearance, 0.0, 1.0 ) );

 configParams.push_back( new PARAM_CFG_DOUBLE( true, AC_KEYS::DRCEpsilon,
 &m_DRCEpsilon, m_DRCEpsilon, 0.0, 1.0 ) );

 configParams.push_back( new PARAM_CFG_DOUBLE( true, AC_KEYS::HoleWallThickness,
 &m_HoleWallThickness, m_HoleWallThickness, 0.0, 1.0 ) );

 configParams.push_back( new PARAM_CFG_INT( true, AC_KEYS::CoroutineStackSize,
 &m_CoroutineStackSize, AC_STACK::default_stack,
 AC_STACK::min_stack, AC_STACK::max_stack ) );

 configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::ShowRouterDebugGraphics,
 &m_ShowRouterDebugGraphics, m_ShowRouterDebugGraphics ) );

 configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::CompactFileSave,
  &m_CompactSave, m_CompactSave ) );

 configParams.push_back( new PARAM_CFG_DOUBLE( true, AC_KEYS::DrawArcAccuracy,
 &m_DrawArcAccuracy, m_DrawArcAccuracy, 0.0, 100000.0 ) );

 configParams.push_back( new PARAM_CFG_DOUBLE( true, AC_KEYS::DrawArcCenterStartEndMaxAngle,
 &m_DrawArcCenterMaxAngle, m_DrawArcCenterMaxAngle, 0.0, 100000.0 ) );

 configParams.push_back( new PARAM_CFG_DOUBLE( true, AC_KEYS::MaxTangentTrackAngleDeviation,
 &m_MaxTangentAngleDeviation, m_MaxTangentAngleDeviation, 0.0, 90.0 ) );

 configParams.push_back( new PARAM_CFG_DOUBLE( true, AC_KEYS::MaxTrackLengthToKeep,
 &m_MaxTrackLengthToKeep, m_MaxTrackLengthToKeep, 0.0, 1.0 ) );

 configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::ExtraZoneDisplayModes,
  &m_ExtraZoneDisplayModes, m_ExtraZoneDisplayModes ) );

 configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::StrokeTriangulation,
 &m_DrawTriangulationOutlines, m_DrawTriangulationOutlines ) );

 configParams.push_back( new PARAM_CFG_DOUBLE( true, AC_KEYS::MinPlotPenWidth,
 &m_MinPlotPenWidth, m_MinPlotPenWidth, 0.0, 1.0 ) );

 configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::DebugZoneFiller,
 &m_DebugZoneFiller, m_DebugZoneFiller ) );

 configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::DebugPDFWriter,
 &m_DebugPDFWriter, m_DebugPDFWriter ) );

 configParams.push_back( new PARAM_CFG_DOUBLE( true, AC_KEYS::SmallDrillMarkSize,
 &m_SmallDrillMarkSize, m_SmallDrillMarkSize, 0.0, 3.0 ) );

 configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::HotkeysDumper,
 &m_HotkeysDumper, m_HotkeysDumper ) );

 configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::DrawBoundingBoxes,
 &m_DrawBoundingBoxes, m_DrawBoundingBoxes ) );

 configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::ShowPcbnewExportNetlist,
 &m_ShowPcbnewExportNetlist, m_ShowPcbnewExportNetlist ) );

 configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::Skip3DModelFileCache,
 &m_Skip3DModelFileCache, m_Skip3DModelFileCache ) );

 configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::Skip3DModelMemoryCache,
 &m_Skip3DModelMemoryCache, m_Skip3DModelMemoryCache ) );

 configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::HideVersionFromTitle,
 &m_HideVersionFromTitle, m_HideVersionFromTitle ) );

 configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::ShowRepairSchematic,
 &m_ShowRepairSchematic, m_ShowRepairSchematic ) );

 configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::ShowEventCounters,
 &m_ShowEventCounters, m_ShowEventCounters ) );

 configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::AllowManualCanvasScale,
 &m_AllowManualCanvasScale, m_AllowManualCanvasScale ) );

 // Special case for trace mask setting...we just grab them and set them immediately
 // Because we even use wxLogTrace inside of advanced config
 wxString traceMasks = wxEmptyString;
 configParams.push_back( new PARAM_CFG_WXSTRING( true, AC_KEYS::TraceMasks, &traceMasks, wxEmptyString ) );

 // Load the config from file
 wxConfigLoadSetups( &aCfg, configParams );

 // Now actually set the trace masks
 wxStringTokenizer traceMaskTokenizer( traceMasks, wxT( "," ) );

 while( traceMaskTokenizer.HasMoreTokens() )
 {
 wxString mask = traceMaskTokenizer.GetNextToken();
 wxLog::AddTraceMask( mask );
 }

 dumpCfg( configParams );

 for( PARAM_CFG* param : configParams )
 delete param;
}