Translated using Weblate (Lithuanian)

Currently translated at 95.4% (9663 of 10123 strings)

Translation: KiCad EDA/v9
Translate-URL: https://hosted.weblate.org/projects/kicad/v9/lt/

.gitlab/doxygen.yml

@@ -1,7 +1,7 @@
 build_doxygen_docker:
-  image: docker:stable
+  image: docker:24.0.5-cli
   services:
-    - docker:dind
+    - docker:24.0.5-dind
   stage: build
   rules:
     - if: $CI_PIPELINE_SOURCE == "schedule" && $SCHEDULED_JOB_NAME == "doxygen"

3d-viewer/3d_viewer/eda_3d_viewer_frame.cpp

@@ -202,6 +202,10 @@ EDA_3D_VIEWER_FRAME::EDA_3D_VIEWER_FRAME( KIWAY* aKiway, PCB_BASE_FRAME* aParent
 
 EDA_3D_VIEWER_FRAME::~EDA_3D_VIEWER_FRAME()
 {
+    // Shutdown all running tools
+    if( m_toolManager )
+        m_toolManager->ShutdownAllTools();
+
     Prj().GetProjectFile().m_Viewports3D = m_appearancePanel->GetUserViewports();
 
     m_canvas->SetEventDispatcher( nullptr );

3d-viewer/dialogs/panel_preview_3d_model.cpp

@@ -185,6 +185,10 @@ PANEL_PREVIEW_3D_MODEL::PANEL_PREVIEW_3D_MODEL( wxWindow* aParent, PCB_BASE_FRAM
 
 PANEL_PREVIEW_3D_MODEL::~PANEL_PREVIEW_3D_MODEL()
 {
+    // Shutdown all running tools
+    if( m_toolManager )
+        m_toolManager->ShutdownAllTools();
+
     // Restore the 3D viewer Render settings, that can be modified by the panel tools
     if( m_boardAdapter.m_Cfg )
         m_boardAdapter.m_Cfg->m_Render = m_initialRender;

api/proto/board/board_commands.proto

@@ -115,6 +115,20 @@ message SetBoardOrigin
   kiapi.common.types.Vector2 origin = 3;
 }
 
+message GetBoardLayerName
+{
+  kiapi.common.types.DocumentSpecifier board = 1;
+
+  kiapi.board.types.BoardLayer layer = 2;
+}
+
+message BoardLayerNameResponse
+{
+  // The name of the layer shown in the KiCad GUI, which may be a default value like "F.Cu" or may
+  // have been customized by the user.
+  string name = 1;
+}
+
 /*
  * Net management
  */

api/proto/board/board_types.proto

@@ -464,6 +464,18 @@ message ThermalSpokeSettings
   kiapi.common.types.Distance gap = 3;
 }
 
+message SymbolPinInfo
+{
+  // The pin name for the associated symbol pin, if one exists
+  string name = 1;
+
+  // The electrical type of the associated symbol pin, if one exists (EPT_UNKNOWN if not)
+  kiapi.common.types.ElectricalPinType type = 2;
+
+  // True if the pin is attached to a no-connect marker in the schematic
+  bool no_connect = 3;
+}
+
 message Pad
 {
   kiapi.common.types.KIID id = 1;
@@ -481,6 +493,10 @@ message Pad
 
   // Since: 9.0.4
   kiapi.common.types.Distance pad_to_die_length = 9;
+
+  // Information about the associated symbol pin, if one exists
+  // Since: 9.0.7
+  SymbolPinInfo symbol_pin = 10;
 }
 
 enum ZoneType
@@ -830,6 +846,9 @@ message FootprintAttributes
   bool exempt_from_courtyard_requirement = 6;
   bool do_not_populate = 7;
   FootprintMountingStyle mounting_style = 8;
+
+  // Since: 9.0.7
+  bool allow_soldermask_bridges = 9;
 }
 
 message NetTieDefinition
@@ -902,4 +921,19 @@ message FootprintInstance
 
   // The sheet path to the associated symbol for this footprint instance, if one exists
   kiapi.common.types.SheetPath symbol_path = 13;
+
+  // The name of the hierarchical sheet the associated symbol for this footprint exists on,
+  // or the empty string if there is no associated symbol
+  // Since: 9.0.7
+  string symbol_sheet_name = 14;
+
+  // The filename of the hierarchical sheet the associated symbol for this footprint exists on,
+  // or the empty string if there is no associated symbol
+  // Since: 9.0.7
+  string symbol_sheet_filename = 15;
+
+  // The the footprint filters given by the symbol this footprint is associated with,
+  // or the empty string if there is no associated symbol
+  // Since: 9.0.7
+  string symbol_footprint_filters = 16;
 }

api/proto/common/types/base_types.proto

@@ -451,3 +451,25 @@ enum MapMergeMode
   // The existing map will be cleared and replaced with the incoming map
   MMM_REPLACE = 2;
 }
+
+enum ElectricalPinType
+{
+  EPT_UNKNOWN = 0;
+  EPT_INPUT = 1;
+  EPT_OUTPUT = 2;
+  EPT_BIDIRECTIONAL = 3;
+  EPT_TRISTATE = 4;
+  EPT_PASSIVE = 5;
+
+  // A free pin is not internally connected and may connect to any net (route-through)
+  EPT_FREE = 6;
+
+  EPT_UNSPECIFIED = 7;
+  EPT_POWER_INPUT = 8;
+  EPT_POWER_OUTPUT = 9;
+  EPT_OPEN_COLLECTOR = 10;
+  EPT_OPEN_EMITTER = 11;
+
+  // A no-connect pin should not be connected to any net
+  EPT_NO_CONNECT = 12;
+}

bitmap2component/bitmap2cmp_frame.cpp

@@ -205,7 +205,12 @@ BITMAP2CMP_FRAME::BITMAP2CMP_FRAME( KIWAY* aKiway, wxWindow* aParent ) :
 
 BITMAP2CMP_FRAME::~BITMAP2CMP_FRAME()
 {
+    // Shutdown all running tools
+    if( m_toolManager )
+        m_toolManager->ShutdownAllTools();
+
     SaveSettings( config() );
+
     /*
      * This needed for OSX: avoids further OnDraw processing after this
      * destructor and before the native window is destroyed

cmake/BuildSteps/CreateDocsetDoxyfile.cmake

@@ -51,5 +51,7 @@ DOCSET_BUNDLE_ID        = ${DOCSET_BUNDLE_ID}
 DISABLE_INDEX           = YES
 GENERATE_TREEVIEW       = NO
 SEARCHENGINE            = NO
-GENERATE_TAGFILE        = ${DOXY_TAG_FILE}"
+GENERATE_TAGFILE        = ${DOXY_TAG_FILE}
+# Doxygen-awesome doesn't look great without the index
+HTML_EXTRA_STYLESHEET   = "
     )

cmake/FindOCC.cmake

@@ -28,18 +28,12 @@
 
 # Set the needed libraries
 set( OCC_LIBS_COMMON
-    TKBinL
-    TKBin
-    TKBinTObj
-    TKBinXCAF
     TKBool
     TKBO
     TKBRep
     TKCAF
     TKCDF
     TKernel
-    TKFeat
-    TKFillet
     TKG2d
     TKG3d
     TKGeomAlgo
@@ -48,22 +42,13 @@ set( OCC_LIBS_COMMON
     TKLCAF
     TKMath
     TKMesh
-    TKMeshVS
-    TKOffset
-    TKOpenGl
     TKPrim
     TKRWMesh
     TKService
     TKShHealing
-    TKTObj
     TKTopAlgo
     TKV3d
     TKXCAF
-    TKXMesh
-    TKXmlL
-    TKXml
-    TKXmlTObj
-    TKXmlXCAF
     TKXSBase
 )
 
@@ -140,6 +125,7 @@ else(WIN32)
     /usr
     /usr/local
     /usr/local/opencascade
+    /usr/opencascade
     /opt/opencascade
     /opt/opencascade/lin64/gcc
     PATH_SUFFIXES lib

cmake/KiCadVersion.cmake

@@ -2,7 +2,7 @@
 #  This program source code file is part of KICAD, a free EDA CAD application.
 #
 #  Copyright (C) 2016 Wayne Stambaugh <stambaughw@gmail.com>
-#  Copyright (C) 2016-2023, 2024 KiCad Developers, see AUTHORS.txt for contributors.
+#  Copyright (C) 2016-2023, 2024, 2025 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
@@ -37,7 +37,7 @@
 # KiCad.
 #
 # Note: This version string should follow the semantic versioning system
-set( KICAD_SEMANTIC_VERSION "9.0.5-rc1" )
+set( KICAD_SEMANTIC_VERSION "9.0.8-unknown" )
 
 # Default the version to the semantic version.
 # This is overridden by the git repository tag though (if using git)

cmake/Warnings.cmake

@@ -184,6 +184,13 @@ if( CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang" )
         set( HAVE_WIMPLICIT_FLOAT_CONVERSION true )
     endif()
 
+    CHECK_CXX_COMPILER_FLAG( "-Wambiguous-conditional" COMPILER_SUPPORTS_WAMBIGUOUS_CONDITIONAL )
+
+    # Add this to match MSVC's warning about ambiguous conditionals
+    if( COMPILER_SUPPORTS_WAMBIGUOUS_CONDITIONAL )
+        set( WARN_FLAGS_CXX "${WARN_FLAGS_CXX} -Wambiguous-conditional" )
+    endif()
+
     # See if the compiler will throw warnings on these conversions
     CHECK_CXX_COMPILER_FLAG( "-Wunused-const-variable" COMPILER_SUPPORTS_WUNUSED_CONST_VARIABLE )
 

common/CMakeLists.txt

@@ -11,6 +11,7 @@ include_directories(
     ./dialogs
     ./widgets
     ./dialog_about
+    ${CMAKE_SOURCE_DIR}/libs/sexpr/include
     ${CMAKE_SOURCE_DIR}/resources/bitmaps_png
     ${CMAKE_SOURCE_DIR}/3d-viewer
     ${CMAKE_SOURCE_DIR}/pcbnew
@@ -128,6 +129,7 @@ set( KICOMMON_SRCS
     widgets/kistatusbar.cpp
     widgets/number_badge.cpp
     widgets/progress_reporter_base.cpp
+    widgets/report_severity.cpp
     widgets/std_bitmap_button.cpp
     widgets/ui_common.cpp
     widgets/wx_html_report_panel.cpp
@@ -237,6 +239,7 @@ target_link_libraries( kicommon
     fmt::fmt
     CURL::libcurl
     picosha2
+    sexpr
     ${ZSTD_LIBRARY}
     ${wxWidgets_LIBRARIES}
     ${LIBGIT2_LIBRARIES}

common/advanced_config.cpp

@@ -102,6 +102,7 @@ static const wxChar EnableDesignBlocks[] = wxT( "EnableDesignBlocks" );
 static const wxChar EnableGenerators[] = wxT( "EnableGenerators" );
 static const wxChar EnableLibWithText[] = wxT( "EnableLibWithText" );
 static const wxChar EnableLibDir[] = wxT( "EnableLibDir" );
+static const wxChar LibraryTableEditor[] = wxT( "LibraryTableEditor" );
 static const wxChar EnableEeschemaPrintCairo[] = wxT( "EnableEeschemaPrintCairo" );
 static const wxChar EnableEeschemaExportClipboardCairo[] = wxT( "EnableEeschemaExportClipboardCairo" );
 static const wxChar DisambiguationTime[] = wxT( "DisambiguationTime" );
@@ -120,6 +121,8 @@ static const wxChar EnableExtensionSnaps[] = wxT( "EnableExtensionSnaps" );
 static const wxChar ExtensionSnapTimeoutMs[] = wxT( "ExtensionSnapTimeoutMs" );
 static const wxChar ExtensionSnapActivateOnHover[] = wxT( "ExtensionSnapActivateOnHover" );
 static const wxChar EnableSnapAnchorsDebug[] = wxT( "EnableSnapAnchorsDebug" );
+static const wxChar SnapHysteresis[] = wxT( "SnapHysteresis" );
+static const wxChar SnapToAnchorMargin[] = wxT( "SnapToAnchorMargin" );
 static const wxChar MinParallelAngle[] = wxT( "MinParallelAngle" );
 static const wxChar HoleWallPaintingMultiplier[] = wxT( "HoleWallPaintingMultiplier" );
 static const wxChar MsgPanelShowUuids[] = wxT( "MsgPanelShowUuids" );
@@ -130,6 +133,7 @@ static const wxChar ExcludeFromSimulationLineWidth[] = wxT( "ExcludeFromSimulati
 static const wxChar GitIconRefreshInterval[] = wxT( "GitIconRefreshInterval" );
 static const wxChar MaxPastedTextLength[] = wxT( "MaxPastedTextLength" );
 static const wxChar PNSProcessClusterTimeout[] = wxT( "PNSProcessClusterTimeout" );
+static const wxChar FollowBranchTimeout[] = wxT( "FollowBranchTimeoutMs" );
 
 } // namespace KEYS
 
@@ -262,6 +266,7 @@ ADVANCED_CFG::ADVANCED_CFG()
     m_EnableGenerators          = false;
     m_EnableLibWithText         = false;
     m_EnableLibDir              = false;
+    m_LibraryTableEditor        = false;
 
     m_EnableEeschemaPrintCairo  = true;
     m_EnableEeschemaExportClipboardCairo = true;
@@ -299,6 +304,8 @@ ADVANCED_CFG::ADVANCED_CFG()
     m_ExtensionSnapTimeoutMs = 500;
     m_ExtensionSnapActivateOnHover = true;
     m_EnableSnapAnchorsDebug = false;
+    m_SnapHysteresis = 5;
+    m_SnapToAnchorMargin = 1.1;
 
     m_MinParallelAngle = 0.001;
     m_HoleWallPaintingMultiplier = 1.5;
@@ -316,6 +323,7 @@ ADVANCED_CFG::ADVANCED_CFG()
     m_MaxPastedTextLength = 100;
 
     m_PNSProcessClusterTimeout = 100; // Default: 100 ms
+    m_FollowBranchTimeout = 500; // Default: 500 ms
 
     loadFromConfigFile();
 }
@@ -512,6 +520,9 @@ void ADVANCED_CFG::loadSettings( wxConfigBase& aCfg )
     configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::EnableLibDir,
                                                 &m_EnableLibDir, m_EnableLibDir ) );
 
+    configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::LibraryTableEditor,
+                                                &m_LibraryTableEditor, m_LibraryTableEditor ) );
+
     configParams.push_back( new PARAM_CFG_BOOL( true, AC_KEYS::EnableEeschemaPrintCairo,
                                                 &m_EnableEeschemaPrintCairo,
                                                 m_EnableEeschemaPrintCairo ) );
@@ -577,6 +588,14 @@ void ADVANCED_CFG::loadSettings( wxConfigBase& aCfg )
                                                 &m_EnableSnapAnchorsDebug,
                                                 m_EnableSnapAnchorsDebug ) );
 
+    configParams.push_back( new PARAM_CFG_INT( true, AC_KEYS::SnapHysteresis,
+                                               &m_SnapHysteresis, m_SnapHysteresis,
+                                               0, 100 ) );
+
+    configParams.push_back( new PARAM_CFG_DOUBLE( true, AC_KEYS::SnapToAnchorMargin,
+                                                  &m_SnapToAnchorMargin, m_SnapToAnchorMargin,
+                                                  1.0, 2.0 ) );
+
     configParams.push_back( new PARAM_CFG_DOUBLE( true, AC_KEYS::MinParallelAngle,
                                                   &m_MinParallelAngle, m_MinParallelAngle,
                                                   0.0, 45.0 ) );
@@ -614,6 +633,9 @@ void ADVANCED_CFG::loadSettings( wxConfigBase& aCfg )
     configParams.push_back( new PARAM_CFG_INT( true, AC_KEYS::PNSProcessClusterTimeout,
                                                &m_PNSProcessClusterTimeout, 100, 10, 10000 ) );
 
+    configParams.push_back( new PARAM_CFG_INT( true, AC_KEYS::FollowBranchTimeout,
+                                               &m_FollowBranchTimeout, 500, 50, 5000 ) );
+
     // 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;

common/api/api_enums.cpp

@@ -26,6 +26,7 @@
 #include <core/typeinfo.h>
 #include <font/text_attributes.h>
 #include <layer_ids.h>
+#include <pin_type.h>
 #include <stroke_params.h>
 
 using namespace kiapi;
@@ -498,3 +499,54 @@ types::StrokeLineStyle ToProtoEnum( LINE_STYLE aValue )
                      "Unhandled case in ToProtoEnum<LINE_STYLE>");
     }
 }
+
+
+template<>
+ELECTRICAL_PINTYPE FromProtoEnum( types::ElectricalPinType aValue )
+{
+    switch( aValue )
+    {
+    case types::ElectricalPinType::EPT_INPUT:           return ELECTRICAL_PINTYPE::PT_INPUT;
+    case types::ElectricalPinType::EPT_OUTPUT:          return ELECTRICAL_PINTYPE::PT_OUTPUT;
+    case types::ElectricalPinType::EPT_BIDIRECTIONAL:   return ELECTRICAL_PINTYPE::PT_BIDI;
+    case types::ElectricalPinType::EPT_TRISTATE:        return ELECTRICAL_PINTYPE::PT_TRISTATE;
+    case types::ElectricalPinType::EPT_PASSIVE:         return ELECTRICAL_PINTYPE::PT_PASSIVE;
+    case types::ElectricalPinType::EPT_FREE:            return ELECTRICAL_PINTYPE::PT_NIC;
+    case types::ElectricalPinType::EPT_UNSPECIFIED:     return ELECTRICAL_PINTYPE::PT_UNSPECIFIED;
+    case types::ElectricalPinType::EPT_POWER_INPUT:     return ELECTRICAL_PINTYPE::PT_POWER_IN;
+    case types::ElectricalPinType::EPT_POWER_OUTPUT:    return ELECTRICAL_PINTYPE::PT_POWER_OUT;
+    case types::ElectricalPinType::EPT_OPEN_COLLECTOR:  return ELECTRICAL_PINTYPE::PT_OPENCOLLECTOR;
+    case types::ElectricalPinType::EPT_OPEN_EMITTER:    return ELECTRICAL_PINTYPE::PT_OPENEMITTER;
+    case types::ElectricalPinType::EPT_NO_CONNECT:      return ELECTRICAL_PINTYPE::PT_NC;
+    case types::ElectricalPinType::EPT_UNKNOWN:
+    default:
+        wxCHECK_MSG( false, ELECTRICAL_PINTYPE::PT_UNSPECIFIED,
+                     "Unhandled case in FromProtoEnum<types::ElectricalPinType>" );
+    }
+}
+
+
+template<>
+types::ElectricalPinType ToProtoEnum( ELECTRICAL_PINTYPE aValue )
+{
+    switch( aValue )
+    {
+    case ELECTRICAL_PINTYPE::PT_INPUT:         return types::ElectricalPinType::EPT_INPUT;
+    case ELECTRICAL_PINTYPE::PT_OUTPUT:        return types::ElectricalPinType::EPT_OUTPUT;
+    case ELECTRICAL_PINTYPE::PT_BIDI:          return types::ElectricalPinType::EPT_BIDIRECTIONAL;
+    case ELECTRICAL_PINTYPE::PT_TRISTATE:      return types::ElectricalPinType::EPT_TRISTATE;
+    case ELECTRICAL_PINTYPE::PT_PASSIVE:       return types::ElectricalPinType::EPT_PASSIVE;
+    case ELECTRICAL_PINTYPE::PT_NIC:           return types::ElectricalPinType::EPT_FREE;
+    case ELECTRICAL_PINTYPE::PT_UNSPECIFIED:   return types::ElectricalPinType::EPT_UNSPECIFIED;
+    case ELECTRICAL_PINTYPE::PT_POWER_IN:      return types::ElectricalPinType::EPT_POWER_INPUT;
+    case ELECTRICAL_PINTYPE::PT_POWER_OUT:     return types::ElectricalPinType::EPT_POWER_OUTPUT;
+    case ELECTRICAL_PINTYPE::PT_OPENCOLLECTOR: return types::ElectricalPinType::EPT_OPEN_COLLECTOR;
+    case ELECTRICAL_PINTYPE::PT_OPENEMITTER:   return types::ElectricalPinType::EPT_OPEN_EMITTER;
+    case ELECTRICAL_PINTYPE::PT_NC:            return types::ElectricalPinType::EPT_NO_CONNECT;
+    // Inherit shouldn't be serialized, it's an internal flag
+    case ELECTRICAL_PINTYPE::PT_INHERIT:
+    default:
+        wxCHECK_MSG( false, types::ElectricalPinType::EPT_UNKNOWN,
+                     "Unhandled case in ToProtoEnum<ELECTRICAL_PINTYPE>");
+    }
+}

common/api/api_utils.cpp

@@ -122,10 +122,9 @@ KICOMMON_API void PackPolyLine( types::PolyLine& aOutput, const SHAPE_LINE_CHAIN
         if( vertex < 0 )
             break;
 
-        types::PolyLineNode* node = aOutput.mutable_nodes()->Add();
-
-        if( aSlc.IsPtOnArc( vertex ) )
+        if( aSlc.IsArcStart( vertex ) )
         {
+            types::PolyLineNode* node = aOutput.mutable_nodes()->Add();
             const SHAPE_ARC& arc = aSlc.Arc( aSlc.ArcIndex( vertex ) );
             node->mutable_arc()->mutable_start()->set_x_nm( arc.GetP0().x );
             node->mutable_arc()->mutable_start()->set_y_nm( arc.GetP0().y );
@@ -134,8 +133,9 @@ KICOMMON_API void PackPolyLine( types::PolyLine& aOutput, const SHAPE_LINE_CHAIN
             node->mutable_arc()->mutable_end()->set_x_nm( arc.GetP1().x );
             node->mutable_arc()->mutable_end()->set_y_nm( arc.GetP1().y );
         }
-        else
+        else if( !aSlc.IsPtOnArc( vertex ) )
         {
+            types::PolyLineNode* node = aOutput.mutable_nodes()->Add();
             node->mutable_point()->set_x_nm( aSlc.CPoint( vertex ).x );
             node->mutable_point()->set_y_nm( aSlc.CPoint( vertex ).y );
         }
@@ -241,4 +241,14 @@ KICOMMON_API void PackSheetPath( types::SheetPath& aOutput, const KIID_PATH& aIn
         aOutput.add_path()->set_value( entry.AsStdString() );
 }
 
+KICOMMON_API KIID_PATH UnpackSheetPath( const types::SheetPath& aInput )
+{
+    KIID_PATH output;
+
+    for( const types::KIID& sheet : aInput.path() )
+        output.push_back( KIID( sheet.value() ) );
+
+    return output;
+}
+
 } // namespace kiapi::common

common/array_axis.cpp

@@ -37,7 +37,11 @@ static bool schemeNonUnitColsStartAt0( ARRAY_AXIS::NUMBERING_TYPE type )
 }
 
 
-ARRAY_AXIS::ARRAY_AXIS() : m_type( NUMBERING_TYPE::NUMBERING_NUMERIC ), m_offset( 0 ), m_step( 1 )
+ARRAY_AXIS::ARRAY_AXIS() :
+        m_type( NUMBERING_TYPE::NUMBERING_NUMERIC ),
+        m_offset( 0 ),
+        m_step( 1 ),
+        m_useLowercase( false )
 {
 }
 
@@ -76,7 +80,14 @@ std::optional<int> ARRAY_AXIS::getNumberingOffset( const wxString& str ) const
 
     for( unsigned i = 0; i < str.length(); i++ )
     {
-        int chIndex = alphabet.Find( str[i], false );
+        wxUniChar ch = str[i];
+
+        // For alphabetic types, convert to uppercase for lookup since our alphabets
+        // are defined with uppercase letters. This allows users to enter lowercase.
+        if( !TypeIsNumeric( m_type ) && ch >= 'a' && ch <= 'z' )
+            ch = ch - 'a' + 'A';
+
+        int chIndex = alphabet.Find( ch, false );
 
         if( chIndex == wxNOT_FOUND )
             return std::optional<int>{};
@@ -109,6 +120,18 @@ bool ARRAY_AXIS::SetOffset( const wxString& aOffsetName )
     if( !offset )
         return false;
 
+    // For alphabetic types, check if the user entered lowercase letters.
+    // If so, we'll output lowercase letters as well.
+    if( !TypeIsNumeric( m_type ) && !aOffsetName.IsEmpty() )
+    {
+        wxUniChar firstChar = aOffsetName[0];
+        m_useLowercase = ( firstChar >= 'a' && firstChar <= 'z' );
+    }
+    else
+    {
+        m_useLowercase = false;
+    }
+
     SetOffset( *offset );
     return true;
 }
@@ -140,5 +163,11 @@ wxString ARRAY_AXIS::GetItemNumber( int n ) const
 
     n = m_offset + m_step * n;
 
-    return AlphabeticFromIndex( n, alphabet, nonUnitColsStartAt0 );
+    wxString result = AlphabeticFromIndex( n, alphabet, nonUnitColsStartAt0 );
+
+    // If the user entered a lowercase starting value, output lowercase letters
+    if( m_useLowercase )
+        result = result.Lower();
+
+    return result;
 }

common/bitmap_base.cpp

@@ -450,7 +450,8 @@ void BITMAP_BASE::Rotate( bool aRotateCCW )
         int resY = m_image->GetOptionInt( wxIMAGE_OPTION_RESOLUTIONY );
         int unit = m_image->GetOptionInt( wxIMAGE_OPTION_RESOLUTIONUNIT );
 
-        *m_image = m_image->Rotate90( aRotateCCW );
+        // wxImage::Rotate90 parameter is "clockwise", so invert for CCW rotation
+        *m_image = m_image->Rotate90( !aRotateCCW );
 
         m_image->SetOption( wxIMAGE_OPTION_RESOLUTIONUNIT, unit );
         m_image->SetOption( wxIMAGE_OPTION_RESOLUTIONX, resX );

common/design_block_lib_table.cpp

@@ -631,7 +631,8 @@ bool DESIGN_BLOCK_LIB_TABLE::LoadGlobalTable( DESIGN_BLOCK_LIB_TABLE& aTable )
     {
         tableExists = false;
 
-        if( !fn.DirExists() && !fn.Mkdir( 0x777, wxPATH_MKDIR_FULL ) )
+        if( !wxFileName::DirExists( fn.GetPath() )
+            && !wxFileName::Mkdir( fn.GetPath(), 0x777, wxPATH_MKDIR_FULL ) )
         {
             THROW_IO_ERROR( wxString::Format( _( "Cannot create global library table path '%s'." ),
                                               fn.GetPath() ) );

common/dialog_about/AboutDialog_main.cpp

@@ -909,7 +909,13 @@ static void buildKicadAboutBanner( EDA_BASE_FRAME* aParent, ABOUT_APP_INFO& aInf
 #define FOOTPRINT_LIB_CONTRIBUTION _( "Footprints" )
     aInfo.AddLibrarian( new CONTRIBUTOR( wxS( "Scripts by Maui" ),
                                          MODELS_3D_CONTRIBUTION,
-                                         wxS( "https://gitlab.com/kicad/libraries/kicad-footprint-generator" ) ) );
+                                         wxS( "https://github.com/easyw" ) ) );
+    aInfo.AddLibrarian( new CONTRIBUTOR( wxS( "Hasan Yavuz Özderya" ),
+                                         MODELS_3D_CONTRIBUTION,
+                                         wxS( "https://bitbucket.org/hyOzd/freecad-macros/src/master/" ) ) );
+    aInfo.AddLibrarian( new CONTRIBUTOR( wxS( "GitHub contributors" ),
+                                         MODELS_3D_CONTRIBUTION,
+                                         wxS( "https://github.com/easyw/kicad-3d-models-in-freecad/graphs/contributors" ) ) );
     aInfo.AddLibrarian( new CONTRIBUTOR( wxS( "GitLab contributors" ),
                                          MODELS_3D_CONTRIBUTION,
                                          wxS( "https://gitlab.com/kicad/libraries/kicad-packages3D/-/graphs/master" ) ) );

common/dialog_shim.cpp

@@ -752,7 +752,10 @@ void DIALOG_SHIM::OnCharHook( wxKeyEvent& aEvt )
 
         for( size_t i = 0; i < m_tabOrder.size(); ++i )
         {
-            if( m_tabOrder[i] == currentWindow )
+            // Check for exact match or if currentWindow is a child of the control
+            // (e.g., the text entry inside a wxComboBox)
+            if( m_tabOrder[i] == currentWindow
+                || ( currentWindow && m_tabOrder[i]->IsDescendant( currentWindow ) ) )
             {
                 currentIdx = (int) i;
                 break;
@@ -763,6 +766,17 @@ void DIALOG_SHIM::OnCharHook( wxKeyEvent& aEvt )
         {
             advance( currentIdx );
 
+            // Skip hidden or disabled controls
+            int startIdx = currentIdx;
+
+            while( !m_tabOrder[currentIdx]->IsShown() || !m_tabOrder[currentIdx]->IsEnabled() )
+            {
+                advance( currentIdx );
+
+                if( currentIdx == startIdx )
+                    break;  // Avoid infinite loop if all controls are hidden
+            }
+
             //todo: We don't currently have non-textentry dialog boxes but this will break if
             // we add them.
 #ifdef __APPLE__

common/dialogs/dialog_global_design_block_lib_table_config.cpp

@@ -27,6 +27,8 @@
 
 #include "design_block_lib_table.h"
 
+#include <kiplatform/io.h>
+
 
 DIALOG_GLOBAL_DESIGN_BLOCK_LIB_TABLE_CONFIG::DIALOG_GLOBAL_DESIGN_BLOCK_LIB_TABLE_CONFIG(
         wxWindow* aParent ) :
@@ -106,8 +108,8 @@ bool DIALOG_GLOBAL_DESIGN_BLOCK_LIB_TABLE_CONFIG::TransferDataFromWindow()
         // Create the config path if it doesn't already exist.
         wxFileName designBlockTableFileName = DESIGN_BLOCK_LIB_TABLE::GetGlobalTableFileName();
 
-        if( !designBlockTableFileName.DirExists()
-            && !designBlockTableFileName.Mkdir( 0x777, wxPATH_MKDIR_FULL ) )
+        if( !wxFileName::DirExists( designBlockTableFileName.GetPath() )
+            && !wxFileName::Mkdir( designBlockTableFileName.GetPath(), 0x777, wxPATH_MKDIR_FULL ) )
         {
             DisplayError( this, wxString::Format( _( "Cannot create global library table '%s'." ),
                                                   designBlockTableFileName.GetPath() ) );
@@ -124,6 +126,9 @@ bool DIALOG_GLOBAL_DESIGN_BLOCK_LIB_TABLE_CONFIG::TransferDataFromWindow()
                                       fn.GetFullPath(), designBlockTableFileName.GetFullPath() ) );
             return false;
         }
+
+        // Ensure the copied file is writable
+        KIPLATFORM::IO::MakeWriteable( designBlockTableFileName.GetFullPath() );
     }
 
     // Load the successfully copied design block library table file.  This should not fail since the

common/dialogs/dialog_hotkey_list.cpp

@@ -39,7 +39,8 @@ DIALOG_LIST_HOTKEYS::DIALOG_LIST_HOTKEYS( EDA_BASE_FRAME* aParent ):
     wxBoxSizer* main_sizer = new wxBoxSizer( wxVERTICAL );
     KIFACE*     kiface = nullptr;
 
-    m_hk_list = new PANEL_HOTKEYS_EDITOR( aParent, this, true );
+    m_hk_list = new PANEL_HOTKEYS_EDITOR( aParent, this );
+    m_hk_list->SetIncludeGestures( true );
 
     wxWindow* kicadMgr_window = wxWindow::FindWindowByName( KICAD_MANAGER_FRAME_NAME );
 
@@ -71,6 +72,7 @@ DIALOG_LIST_HOTKEYS::DIALOG_LIST_HOTKEYS( EDA_BASE_FRAME* aParent ):
 
     wxStdDialogButtonSizer* sdb_sizer = new wxStdDialogButtonSizer;
     sdb_sizer->AddButton( new wxButton( this, wxID_OK ) );
+    sdb_sizer->AddButton( new wxButton( this, wxID_CANCEL ) );
     sdb_sizer->Realize();
 
     main_sizer->Add( sdb_sizer, 0, wxEXPAND | wxALL, margin );

common/dialogs/eda_view_switcher.cpp

@@ -36,7 +36,8 @@
 EDA_VIEW_SWITCHER::EDA_VIEW_SWITCHER( wxWindow* aParent, const wxArrayString& aItems,
                                       wxKeyCode aCtrlKey ) :
         EDA_VIEW_SWITCHER_BASE( aParent ),
-        m_tabState( true ),
+        // Start with the tab marked as "up" so the initial ctrl-tab press advances selection.
+        m_tabState( false ),
         m_receivingEvents( false ),
         m_ctrlKey( aCtrlKey )
 {

common/dialogs/panel_embedded_files.cpp

@@ -90,8 +90,12 @@ void EMBEDDED_FILES_GRID_TRICKS::doPopupSelection( wxCommandEvent& event )
 /* ---------- End of GRID_TRICKS for embedded files grid ---------- */
 
 
-PANEL_EMBEDDED_FILES::PANEL_EMBEDDED_FILES( wxWindow* parent, EMBEDDED_FILES* aFiles ) :
-        PANEL_EMBEDDED_FILES_BASE( parent ), m_files( aFiles ), m_localFiles( new EMBEDDED_FILES() )
+PANEL_EMBEDDED_FILES::PANEL_EMBEDDED_FILES( wxWindow* aParent, EMBEDDED_FILES* aFiles, int aFlags,
+                                            std::vector<const EMBEDDED_FILES*> aInheritedFiles ) :
+        PANEL_EMBEDDED_FILES_BASE( aParent ),
+        m_files( aFiles ),
+        m_localFiles( new EMBEDDED_FILES() ),
+        m_inheritedFiles( std::move( aInheritedFiles ) )
 {
     for( auto& [name, file] : m_files->EmbeddedFileMap() )
     {
@@ -99,6 +103,19 @@ PANEL_EMBEDDED_FILES::PANEL_EMBEDDED_FILES( wxWindow* parent, EMBEDDED_FILES* aF
         m_localFiles->AddFile( newFile );
     }
 
+    for( const EMBEDDED_FILES* inheritedFiles : m_inheritedFiles )
+    {
+        for( auto& [name, file] : inheritedFiles->EmbeddedFileMap() )
+        {
+            if( m_localFiles->HasFile( name ) )
+                continue;
+
+            EMBEDDED_FILES::EMBEDDED_FILE* newFile = new EMBEDDED_FILES::EMBEDDED_FILE( *file );
+            m_localFiles->AddFile( newFile );
+            m_inheritedFileNames.insert( name );
+        }
+    }
+
     // Set up the standard buttons
     m_delete_button->SetBitmap( KiBitmapBundle( BITMAPS::small_trash ) );
     m_browse_button->SetBitmap( KiBitmapBundle( BITMAPS::small_folder ) );
@@ -131,6 +148,7 @@ PANEL_EMBEDDED_FILES::~PANEL_EMBEDDED_FILES()
 {
     // Remove the GRID_TRICKS handler
     m_files_grid->PopEventHandler( true );
+    delete m_localFiles;
 }
 
 
@@ -242,6 +260,9 @@ bool PANEL_EMBEDDED_FILES::TransferDataFromWindow()
 
     for( auto& file : files )
     {
+        if( m_inheritedFileNames.count( file->name ) )
+            continue;
+
         m_files->AddFile( file );
         m_localFiles->RemoveFile( file->name, false );
     }
@@ -378,6 +399,14 @@ bool PANEL_EMBEDDED_FILES::RemoveEmbeddedFile( const wxString& aFileName )
     if( name.StartsWith( FILEEXT::KiCadUriPrefix ) )
         name = name.Mid( FILEEXT::KiCadUriPrefix.size() + 3 );
 
+    if( m_inheritedFileNames.count( name ) )
+    {
+        wxString msg = _( "Embedded files inherited from a parent symbol cannot be removed." );
+
+        DisplayErrorMessage( this, msg );
+        return false;
+    }
+
     int row = std::max( 0, m_files_grid->GetGridCursorRow() );
 
     for( int ii = 0; ii < m_files_grid->GetNumberRows(); ii++ )
@@ -409,14 +438,7 @@ void PANEL_EMBEDDED_FILES::onDeleteEmbeddedFile( wxCommandEvent& event )
 
     wxString name = m_files_grid->GetCellValue( row, 0 );
 
-    m_localFiles->RemoveFile( name );
-
-    m_files_grid->DeleteRows( row );
-
-    if( row < m_files_grid->GetNumberRows() )
-        m_files_grid->SetGridCursor( row, 0 );
-    else if( m_files_grid->GetNumberRows() > 0 )
-        m_files_grid->SetGridCursor( m_files_grid->GetNumberRows() - 1, 0 );
+    RemoveEmbeddedFile( name );
 }
 
 

common/dialogs/panel_embedded_files.h

@@ -24,6 +24,9 @@
 #ifndef PANEL_EMBEDDED_FILES_H
 #define PANEL_EMBEDDED_FILES_H
 
+#include <set>
+#include <vector>
+
 #include <embedded_files.h>
 #include "panel_embedded_files_base.h"
 
@@ -55,7 +58,8 @@ protected:
 class PANEL_EMBEDDED_FILES : public PANEL_EMBEDDED_FILES_BASE
 {
 public:
-    PANEL_EMBEDDED_FILES( wxWindow* parent, EMBEDDED_FILES* aFiles );
+    PANEL_EMBEDDED_FILES( wxWindow* aParent, EMBEDDED_FILES* aFiles, int aFlags = 0,
+                          std::vector<const EMBEDDED_FILES*> aInheritedFiles = {} );
     ~PANEL_EMBEDDED_FILES() override;
 
     bool TransferDataFromWindow() override;
@@ -79,6 +83,8 @@ private:
 
     EMBEDDED_FILES* m_files;
     EMBEDDED_FILES* m_localFiles;
+    std::vector<const EMBEDDED_FILES*> m_inheritedFiles;
+    std::set<wxString>                 m_inheritedFileNames;
 };
 
 

common/dialogs/panel_hotkeys_editor.cpp

@@ -65,11 +65,10 @@ static wxSearchCtrl* CreateTextFilterBox( wxWindow* aParent, const wxString& aDe
 }
 
 
-PANEL_HOTKEYS_EDITOR::PANEL_HOTKEYS_EDITOR( EDA_BASE_FRAME* aFrame, wxWindow* aWindow,
-                                            bool aReadOnly ) :
+PANEL_HOTKEYS_EDITOR::PANEL_HOTKEYS_EDITOR( EDA_BASE_FRAME* aFrame, wxWindow* aWindow ) :
         RESETTABLE_PANEL( aWindow, wxID_ANY, wxDefaultPosition, wxDefaultSize ),
         m_frame( aFrame ),
-        m_readOnly( aReadOnly ),
+        m_includeGestures( false ),
         m_hotkeyStore()
 {
     wxBoxSizer* mainSizer = new wxBoxSizer( wxVERTICAL );
@@ -78,11 +77,10 @@ PANEL_HOTKEYS_EDITOR::PANEL_HOTKEYS_EDITOR( EDA_BASE_FRAME* aFrame, wxWindow* aW
     m_filterSearch = CreateTextFilterBox( this, _( "Type filter text" ) );
     bMargins->Add( m_filterSearch, 0, wxEXPAND | wxTOP | wxRIGHT, 5 );
 
-    m_hotkeyListCtrl = new WIDGET_HOTKEY_LIST( this, m_hotkeyStore, m_readOnly );
+    m_hotkeyListCtrl = new WIDGET_HOTKEY_LIST( this, m_hotkeyStore );
     bMargins->Add( m_hotkeyListCtrl, 1, wxEXPAND | wxTOP | wxRIGHT, 5 );
 
-    if( !m_readOnly )
-        installButtons( bMargins );
+    installButtons( bMargins );
 
     mainSizer->Add( bMargins, 1, wxEXPAND, 0 );
 
@@ -166,7 +164,7 @@ void PANEL_HOTKEYS_EDITOR::installButtons( wxSizer* aSizer )
 
 bool PANEL_HOTKEYS_EDITOR::TransferDataToWindow()
 {
-    m_hotkeyStore.Init( m_actions, m_readOnly );
+    m_hotkeyStore.Init( m_actions, m_includeGestures );
 
     if( !m_hotkeyListCtrl->TransferDataToControl() )
         return false;
@@ -177,9 +175,6 @@ bool PANEL_HOTKEYS_EDITOR::TransferDataToWindow()
 
 bool PANEL_HOTKEYS_EDITOR::TransferDataFromWindow()
 {
-    if( m_readOnly )
-        return true;
-
     if( !m_hotkeyListCtrl->TransferDataFromControl() )
         return false;
 

common/draw_panel_gal.cpp

@@ -626,6 +626,12 @@ void EDA_DRAW_PANEL_GAL::onLostFocus( wxFocusEvent& aEvent )
 
     m_viewControls->CancelDrag();
 
+    // Reset the tool dispatcher's button state when focus is lost. This prevents
+    // the dispatcher from thinking the button is still pressed when focus returns,
+    // which can cause selection and drag operations to stop working.
+    if( m_eventDispatcher )
+        m_eventDispatcher->ResetState();
+
     aEvent.Skip();
 }
 

common/eda_base_frame.cpp

@@ -220,6 +220,12 @@ wxWindow* EDA_BASE_FRAME::findQuasiModalDialog()
 
 void EDA_BASE_FRAME::windowClosing( wxCloseEvent& event )
 {
+    // Guard against re-entrant close events. GTK can deliver a second wxEVT_CLOSE_WINDOW
+    // while we are still processing the first one (e.g. during Destroy() calls), which leads
+    // to use-after-free crashes when child objects have already been torn down.
+    if( m_isClosing )
+        return;
+
     // Don't allow closing when a quasi-modal is open.
     wxWindow* quasiModal = findQuasiModalDialog();
 
@@ -1064,7 +1070,7 @@ void EDA_BASE_FRAME::ShowPreferences( wxString aStartPage, wxString aStartParent
         WX_BUSY_INDICATOR busy_cursor;
 
         WX_TREEBOOK*            book = dlg.GetTreebook();
-        PANEL_HOTKEYS_EDITOR*   hotkeysPanel = new PANEL_HOTKEYS_EDITOR( this, book, false );
+        PANEL_HOTKEYS_EDITOR*   hotkeysPanel = new PANEL_HOTKEYS_EDITOR( this, book );
         KIFACE*                 kiface = nullptr;
         std::vector<int>        expand;
 

common/eda_draw_frame.cpp

@@ -318,7 +318,7 @@ void EDA_DRAW_FRAME::CommonSettingsChanged( int aFlags )
 
     m_galDisplayOptions.ReadCommonConfig( *settings, this );
 
-    GetToolManager()->RunAction( ACTIONS::gridPreset, config()->m_Window.grid.last_size_idx );
+    GetToolManager()->RunAction( ACTIONS::gridPreset, GetWindowSettings( config() )->grid.last_size_idx );
     UpdateGridSelectBox();
 
     if( m_lastToolbarIconSize == 0
@@ -373,7 +373,7 @@ void EDA_DRAW_FRAME::UpdateGridSelectBox()
 
     wxCHECK( config(), /* void */ );
 
-    GRID_MENU::BuildChoiceList( &gridsList, config(), this );
+    GRID_MENU::BuildChoiceList( &gridsList, GetWindowSettings( config() ), this );
 
     for( const wxString& grid : gridsList )
         m_gridSelectBox->Append( grid );
@@ -381,7 +381,7 @@ void EDA_DRAW_FRAME::UpdateGridSelectBox()
     m_gridSelectBox->Append( wxT( "---" ) );
     m_gridSelectBox->Append( _( "Edit Grids..." ) );
 
-    m_gridSelectBox->SetSelection( config()->m_Window.grid.last_size_idx );
+    m_gridSelectBox->SetSelection( GetWindowSettings( config() )->grid.last_size_idx );
 }
 
 
@@ -394,7 +394,7 @@ void EDA_DRAW_FRAME::OnUpdateSelectGrid( wxUpdateUIEvent& aEvent )
 
     wxCHECK( config(), /* void */ );
 
-    int idx = config()->m_Window.grid.last_size_idx;
+    int idx = GetWindowSettings( config() )->grid.last_size_idx;
     idx = std::clamp( idx, 0, (int) m_gridSelectBox->GetCount() - 1 );
 
     if( idx != m_gridSelectBox->GetSelection() )
@@ -414,10 +414,10 @@ void EDA_DRAW_FRAME::OnUpdateSelectZoom( wxUpdateUIEvent& aEvent )
 
     wxCHECK( config(), /* void */ );
 
-    const std::vector<double>& zoomList = config()->m_Window.zoom_factors;
-    int curr_selection = m_zoomSelectBox->GetSelection();
-    int new_selection = 0;      // select zoom auto
-    double last_approx = 1e9;   // large value to start calculation
+    const std::vector<double>& zoomList = GetWindowSettings( config() )->zoom_factors;
+    int                        curr_selection = m_zoomSelectBox->GetSelection();
+    int                        new_selection = 0;      // select zoom auto
+    double                     last_approx = 1e9;      // large value to start calculation
 
     // Search for the nearest available value to the current zoom setting, and select it
     for( size_t jj = 0; jj < zoomList.size(); ++jj )
@@ -484,11 +484,11 @@ void EDA_DRAW_FRAME::OnSelectGrid( wxCommandEvent& event )
 }
 
 
-bool EDA_DRAW_FRAME::IsGridVisible() const
+bool EDA_DRAW_FRAME::IsGridVisible()
 {
     wxCHECK( config(), true );
 
-    return config()->m_Window.grid.show;
+    return GetWindowSettings( config() )->grid.show;
 }
 
 
@@ -496,7 +496,7 @@ void EDA_DRAW_FRAME::SetGridVisibility( bool aVisible )
 {
     wxCHECK( config(), /* void */ );
 
-    config()->m_Window.grid.show = aVisible;
+    GetWindowSettings( config() )->grid.show = aVisible;
 
     // Update the display with the new grid
     if( GetCanvas() )
@@ -514,11 +514,11 @@ void EDA_DRAW_FRAME::SetGridVisibility( bool aVisible )
 }
 
 
-bool EDA_DRAW_FRAME::IsGridOverridden() const
+bool EDA_DRAW_FRAME::IsGridOverridden()
 {
     wxCHECK( config(), false );
 
-    return config()->m_Window.grid.overrides_enabled;
+    return GetWindowSettings( config() )->grid.overrides_enabled;
 }
 
 
@@ -526,7 +526,7 @@ void EDA_DRAW_FRAME::SetGridOverrides( bool aOverride )
 {
     wxCHECK( config(), /* void */ );
 
-    config()->m_Window.grid.overrides_enabled = aOverride;
+    GetWindowSettings( config() )->grid.overrides_enabled = aOverride;
 }
 
 
@@ -549,14 +549,14 @@ void EDA_DRAW_FRAME::UpdateZoomSelectBox()
 
     wxCHECK( config(), /* void */ );
 
-    for( unsigned i = 0;  i < config()->m_Window.zoom_factors.size();  ++i )
+    for( unsigned ii = 0;  ii < GetWindowSettings( config() )->zoom_factors.size();  ++ii )
     {
-        double current = config()->m_Window.zoom_factors[i];
+        double current = GetWindowSettings( config() )->zoom_factors[ii];
 
         m_zoomSelectBox->Append( wxString::Format( _( "Zoom %.2f" ), current ) );
 
         if( zoom == current )
-            m_zoomSelectBox->SetSelection( i + 1 );
+            m_zoomSelectBox->SetSelection( ii + 1 );
     }
 }
 

common/eda_shape.cpp

@@ -2339,10 +2339,10 @@ static struct EDA_SHAPE_DESC
 
         if( lineStyleEnum.Choices().GetCount() == 0 )
         {
-            lineStyleEnum.Map( LINE_STYLE::SOLID, _HKI( "Solid" ) )
-                         .Map( LINE_STYLE::DASH, _HKI( "Dashed" ) )
-                         .Map( LINE_STYLE::DOT, _HKI( "Dotted" ) )
-                         .Map( LINE_STYLE::DASHDOT, _HKI( "Dash-Dot" ) )
+            lineStyleEnum.Map( LINE_STYLE::SOLID,      _HKI( "Solid" ) )
+                         .Map( LINE_STYLE::DASH,       _HKI( "Dashed" ) )
+                         .Map( LINE_STYLE::DOT,        _HKI( "Dotted" ) )
+                         .Map( LINE_STYLE::DASHDOT,    _HKI( "Dash-Dot" ) )
                          .Map( LINE_STYLE::DASHDOTDOT, _HKI( "Dash-Dot-Dot" ) );
         }
 

common/eda_text.cpp

@@ -189,14 +189,14 @@ void EDA_TEXT::Serialize( google::protobuf::Any &aContainer ) const
     using namespace kiapi::common;
     types::Text text;
 
-    text.set_text( GetText().ToStdString() );
-    text.set_hyperlink( GetHyperlink().ToStdString() );
+    text.set_text( GetText().ToUTF8() );
+    text.set_hyperlink( GetHyperlink().ToUTF8() );
     PackVector2( *text.mutable_position(), GetTextPos() );
 
     types::TextAttributes* attrs = text.mutable_attributes();
 
     if( GetFont() )
-        attrs->set_font_name( GetFont()->GetName().ToStdString() );
+        attrs->set_font_name( GetFont()->GetName().ToUTF8() );
 
     attrs->set_horizontal_alignment(
             ToProtoEnum<GR_TEXT_H_ALIGN_T, types::HorizontalAlignment>( GetHorizJustify() ) );
@@ -1323,18 +1323,18 @@ static struct EDA_TEXT_DESC
 
         if( h_inst.Choices().GetCount() == 0)
         {
-            h_inst.Map( GR_TEXT_H_ALIGN_LEFT,   _( "Left" ) );
-            h_inst.Map( GR_TEXT_H_ALIGN_CENTER, _( "Center" ) );
-            h_inst.Map( GR_TEXT_H_ALIGN_RIGHT,  _( "Right" ) );
+            h_inst.Map( GR_TEXT_H_ALIGN_LEFT,   _HKI( "Left" ) );
+            h_inst.Map( GR_TEXT_H_ALIGN_CENTER, _HKI( "Center" ) );
+            h_inst.Map( GR_TEXT_H_ALIGN_RIGHT,  _HKI( "Right" ) );
         }
 
         auto& v_inst = ENUM_MAP<GR_TEXT_V_ALIGN_T>::Instance();
 
         if( v_inst.Choices().GetCount() == 0)
         {
-            v_inst.Map( GR_TEXT_V_ALIGN_TOP,    _( "Top" ) );
-            v_inst.Map( GR_TEXT_V_ALIGN_CENTER, _( "Center" ) );
-            v_inst.Map( GR_TEXT_V_ALIGN_BOTTOM, _( "Bottom" ) );
+            v_inst.Map( GR_TEXT_V_ALIGN_TOP,    _HKI( "Top" ) );
+            v_inst.Map( GR_TEXT_V_ALIGN_CENTER, _HKI( "Center" ) );
+            v_inst.Map( GR_TEXT_V_ALIGN_BOTTOM, _HKI( "Bottom" ) );
         }
 
         PROPERTY_MANAGER& propMgr = PROPERTY_MANAGER::Instance();

common/eda_units.cpp

@@ -599,6 +599,85 @@ double EDA_UNIT_UTILS::UI::DoubleValueFromString( const EDA_IU_SCALE& aIuScale,
 }
 
 
+bool EDA_UNIT_UTILS::UI::DoubleValueFromString( const EDA_IU_SCALE& aIuScale, const wxString& aTextValue,
+                                                double& aDoubleValue )
+{
+    double dtmp = 0;
+
+    // Acquire the 'right' decimal point separator
+    const struct lconv* lc = localeconv();
+
+    wxChar      decimal_point = lc->decimal_point[0];
+    wxString    buf( aTextValue.Strip( wxString::both ) );
+
+    // Convert any entered decimal point separators to the 'right' one
+    buf.Replace( wxT( "." ), wxString( decimal_point, 1 ) );
+    buf.Replace( wxT( "," ), wxString( decimal_point, 1 ) );
+
+    // Find the end of the numeric part
+    unsigned brk_point = 0;
+
+    while( brk_point < buf.Len() )
+    {
+        wxChar ch = buf[brk_point];
+
+        if( !( (ch >= '0' && ch <= '9') || (ch == decimal_point) || (ch == '-') || (ch == '+') ) )
+            break;
+
+        ++brk_point;
+    }
+
+    if( brk_point == 0 )
+        return false;
+
+    // Extract the numeric part
+    buf.Left( brk_point ).ToDouble( &dtmp );
+
+    // Check the unit designator
+    wxString  unit( buf.Mid( brk_point ).Strip( wxString::both ).Lower() );
+    EDA_UNITS units;
+
+    //check for um, μm (µ is MICRO SIGN) and µm (µ is GREEK SMALL LETTER MU) for micrometre
+    if( unit == wxT( "um" ) || unit == wxT( "\u00B5m" ) || unit == wxT( "\u03BCm" ) )
+    {
+        units = EDA_UNITS::UM;
+    }
+    else if( unit == wxT( "mm" ) )
+    {
+        units = EDA_UNITS::MM;
+    }
+    else if( unit == wxT( "cm" ) )
+    {
+        units = EDA_UNITS::CM;
+    }
+    else if( unit == wxT( "mil" ) || unit == wxT( "mils" ) || unit == wxT( "thou" ) )
+    {
+        units = EDA_UNITS::MILS;
+    }
+    else if( unit == wxT( "in" ) || unit == wxT( "\"" ) )
+    {
+        units = EDA_UNITS::INCH;
+    }
+    else if( unit == wxT( "oz" ) ) // 1 oz = 1.37 mils
+    {
+        units = EDA_UNITS::MILS;
+        dtmp *= 1.37;
+    }
+    else if( unit == wxT( "ra" ) ) // Radians
+    {
+        units = EDA_UNITS::DEGREES;
+        dtmp *= 180.0f / M_PI;
+    }
+    else
+    {
+        return false;
+    }
+
+    aDoubleValue = FromUserUnit( aIuScale, units, dtmp );
+    return true;
+}
+
+
 long long int EDA_UNIT_UTILS::UI::ValueFromString( const EDA_IU_SCALE& aIuScale, EDA_UNITS aUnits,
                                                    const wxString& aTextValue, EDA_DATA_TYPE aType )
 {

common/embedded_files.cpp

@@ -591,6 +591,21 @@ EMBEDDED_FILES::EMBEDDED_FILES( const EMBEDDED_FILES& other ) :
 }
 
 
+EMBEDDED_FILES::EMBEDDED_FILES( const EMBEDDED_FILES& other, bool aDeepCopy ) :
+        m_embedFonts( other.m_embedFonts )
+{
+    if( aDeepCopy )
+    {
+        for( const auto& [name, file] : other.m_files )
+            m_files[name] = new EMBEDDED_FILE( *file );
+
+        m_fontFiles = other.m_fontFiles;
+    }
+
+    m_fileAddedCallback = other.m_fileAddedCallback;
+}
+
+
 // Copy assignment operator
 EMBEDDED_FILES& EMBEDDED_FILES::operator=( const EMBEDDED_FILES& other )
 {

common/font/outline_font.cpp

@@ -355,7 +355,7 @@ VECTOR2I OUTLINE_FONT::getTextAsGlyphsUnlocked( BOX2I* aBBox,
                                                 // contents
 
     hb_font_t* referencedFont = hb_ft_font_create_referenced( face );
-    hb_ft_font_set_funcs( referencedFont );
+
     hb_shape( referencedFont, buf, nullptr, 0 );
 
     unsigned int         glyphCount;
@@ -376,10 +376,6 @@ VECTOR2I OUTLINE_FONT::getTextAsGlyphsUnlocked( BOX2I* aBBox,
 
     for( unsigned int i = 0; i < glyphCount; i++ )
     {
-        // Don't process glyphs that were already included in a previous cluster
-        if( i > 0 && glyphInfo[i].cluster == glyphInfo[i-1].cluster )
-            continue;
-
         if( aGlyphs )
         {
             GLYPH_CACHE_KEY key = { face, glyphInfo[i].codepoint, scaleFactor, m_forDrawingSheet,
@@ -557,9 +553,8 @@ void OUTLINE_FONT::RenderToOpenGLCanvas( KIGFX::OPENGL_GAL& aGal, const wxString
 
     std::lock_guard<std::mutex> guard( m_freeTypeMutex );
 
-    hb_font_t*           referencedFont = hb_ft_font_create_referenced( m_face );
+    hb_font_t* referencedFont = hb_ft_font_create_referenced( m_face );
 
-    hb_ft_font_set_funcs( referencedFont );
     hb_shape( referencedFont, buf, nullptr, 0 );
 
     const double mirror_factor = ( aIsMirrored ? 1 : -1 );

common/fp_lib_table.cpp

@@ -628,7 +628,8 @@ bool FP_LIB_TABLE::LoadGlobalTable( FP_LIB_TABLE& aTable )
     {
         tableExists = false;
 
-        if( !fn.DirExists() && !fn.Mkdir( 0x777, wxPATH_MKDIR_FULL ) )
+        if( !wxFileName::DirExists( fn.GetPath() )
+            && !wxFileName::Mkdir( fn.GetPath(), 0x777, wxPATH_MKDIR_FULL ) )
         {
             THROW_IO_ERROR( wxString::Format( _( "Cannot create global library table path '%s'." ),
                                               fn.GetPath() ) );

common/gal/cairo/cairo_gal.cpp

@@ -29,6 +29,7 @@
 
 #include <wx/image.h>
 #include <wx/log.h>
+#include <wx/dcclient.h>
 
 #include <gal/cairo/cairo_gal.h>
 #include <gal/cairo/cairo_compositor.h>
@@ -1650,6 +1651,10 @@ void CAIRO_GAL::setCompositor()
 
 void CAIRO_GAL::onPaint( wxPaintEvent& aEvent )
 {
+    // A wxPaintDC must be created in wxEVT_PAINT handlers. Without this, the system keeps
+    // sending paint events because it thinks the window still needs to be painted, causing
+    // high CPU usage in fallback mode (Cairo).
+    wxPaintDC dc( this );
     PostPaint( aEvent );
 }
 
@@ -1746,6 +1751,8 @@ void CAIRO_GAL_BASE::DrawGrid()
         return;
 
     VECTOR2D gridScreenSize( m_gridSize );
+    gridScreenSize = VECTOR2D( std::max( 1.0, gridScreenSize.x ),
+                               std::max( 1.0, gridScreenSize.y ) );
 
     double gridThreshold = KiROUND( computeMinGridSpacing() / m_worldScale );
 

common/gal/graphics_abstraction_layer.cpp

@@ -76,6 +76,8 @@ GAL::GAL( GAL_DISPLAY_OPTIONS& aDisplayOptions ) :
     SetCoarseGrid( 10 );
     m_gridLineWidth = 0.5f;
     m_gridStyle = GRID_STYLE::LINES;
+    m_gridSize = VECTOR2D( 1.0, 1.0 );
+    m_gridOffset = VECTOR2D( 0.0, 0.0 );
     m_gridMinSpacing = 10;
 
     // Initialize the cursor shape

common/gestfich.cpp

@@ -38,12 +38,15 @@
 #include <string_utils.h>
 #include <launch_ext.h>
 #include "wx/tokenzr.h"
+#include <sexpr/sexpr.h>
+#include <sexpr/sexpr_parser.h>
 
 #include <wx/wfstream.h>
 #include <wx/fs_zip.h>
 #include <wx/zipstrm.h>
 
 #include <filesystem>
+#include <core/kicad_algo.h>
 
 void QuoteString( wxString& string )
 {
@@ -302,6 +305,79 @@ void KiCopyFile( const wxString& aSrcPath, const wxString& aDestPath, wxString&
 }
 
 
+static void traverseSEXPR( SEXPR::SEXPR* aNode, const std::function<void( SEXPR::SEXPR* )>& aVisitor )
+{
+    aVisitor( aNode );
+
+    if( aNode->IsList() )
+    {
+        for( unsigned i = 0; i < aNode->GetNumberOfChildren(); i++ )
+            traverseSEXPR( aNode->GetChild( i ), aVisitor );
+    }
+}
+
+
+void CopySexprFile( const wxString& aSrcPath, const wxString& aDestPath,
+                    std::function<bool( const std::string& token, wxString& value )> aCallback,
+                    wxString& aErrors )
+{
+    bool success = false;
+
+    try
+    {
+        SEXPR::PARSER parser;
+        std::unique_ptr<SEXPR::SEXPR> sexpr( parser.ParseFromFile( TO_UTF8( aSrcPath ) ) );
+
+        traverseSEXPR( sexpr.get(),
+                [&]( SEXPR::SEXPR* node )
+                {
+                    if( node->IsList() && node->GetNumberOfChildren() > 1 && node->GetChild( 0 )->IsSymbol() )
+                    {
+                        std::string          token = node->GetChild( 0 )->GetSymbol();
+                        SEXPR::SEXPR_STRING* pathNode = dynamic_cast<SEXPR::SEXPR_STRING*>( node->GetChild( 1 ) );
+                        SEXPR::SEXPR_SYMBOL* symNode = dynamic_cast<SEXPR::SEXPR_SYMBOL*>( node->GetChild( 1 ) );
+                        wxString             path;
+
+                        if( pathNode )
+                            path = pathNode->m_value;
+                        else if( symNode )
+                            path = symNode->m_value;
+
+                        if( aCallback( token, path ) )
+                        {
+                            if( pathNode )
+                                pathNode->m_value = path;
+                            else if( symNode )
+                                symNode->m_value = path;
+                        }
+                    }
+                } );
+
+        wxFFile destFile( aDestPath, "wb" );
+
+        if( destFile.IsOpened() )
+            success = destFile.Write( sexpr->AsString( 0 ) );
+
+        // wxFFile dtor will close the file
+    }
+    catch( ... )
+    {
+        success = false;
+    }
+
+    if( !success )
+    {
+        wxString msg;
+
+        if( !aErrors.empty() )
+            aErrors += wxS( "\n" );
+
+        msg.Printf( _( "Cannot copy file '%s'." ), aDestPath );
+        aErrors += msg;
+    }
+}
+
+
 wxString QuoteFullPath( wxFileName& fn, wxPathFormat format )
 {
     return wxT( "\"" ) + fn.GetFullPath( format ) + wxT( "\"" );
@@ -347,8 +423,7 @@ bool RmDirRecursive( const wxString& aFileName, wxString* aErrors )
     catch( const fs::filesystem_error& e )
     {
         if( aErrors )
-            *aErrors = wxString::Format( _( "Error removing directory '%s': %s" ),
-                                         aFileName, e.what() );
+            *aErrors = wxString::Format( _( "Error removing directory '%s': %s" ), aFileName, e.what() );
 
         return false;
     }
@@ -357,7 +432,8 @@ bool RmDirRecursive( const wxString& aFileName, wxString* aErrors )
 }
 
 
-bool CopyDirectory( const wxString& aSourceDir, const wxString& aDestDir, wxString& aErrors )
+bool CopyDirectory( const wxString& aSourceDir, const wxString& aDestDir,
+                    const std::vector<wxString>& aPathsWithOverwriteDisallowed, wxString& aErrors )
 {
     wxDir dir( aSourceDir );
 
@@ -380,23 +456,25 @@ bool CopyDirectory( const wxString& aSourceDir, const wxString& aDestDir, wxStri
 
     while( cont )
     {
-        wxString sourcePath = aSourceDir + wxFileName::GetPathSeparator() + filename;
+        wxString sourcePath = dir.GetNameWithSep() + filename;
         wxString destPath = aDestDir + wxFileName::GetPathSeparator() + filename;
 
         if( wxFileName::DirExists( sourcePath ) )
         {
             // Recursively copy subdirectories
-            if( !CopyDirectory( sourcePath, destPath, aErrors ) )
+            if( !CopyDirectory( sourcePath, destPath, aPathsWithOverwriteDisallowed, aErrors ) )
                 return false;
         }
         else
         {
             // Copy files
-            if( !wxCopyFile( sourcePath, destPath ) )
+            if( alg::contains( aPathsWithOverwriteDisallowed, sourcePath ) && wxFileExists( destPath ) )
             {
-                aErrors += wxString::Format( _( "Could not copy file: %s to %s" ),
-                                             sourcePath,
-                                             destPath );
+                // Presumably user does not want an error on a no-overwrite condition....
+            }
+            else if( !wxCopyFile( sourcePath, destPath ) )
+            {
+                aErrors += wxString::Format( _( "Could not copy file: %s to %s" ), sourcePath, destPath );
                 return false;
             }
         }
@@ -408,8 +486,8 @@ bool CopyDirectory( const wxString& aSourceDir, const wxString& aDestDir, wxStri
 }
 
 
-bool CopyFilesOrDirectory( const wxString& aSourcePath, const wxString& aDestDir, wxString& aErrors,
-                           int& aFileCopiedCount, const std::vector<wxString>& aExclusions )
+bool CopyFilesOrDirectory( const wxString& aSourcePath, const wxString& aDestDir, bool aAllowOverwrites,
+                           wxString& aErrors, std::vector<wxString>& aPathsWritten )
 {
     // Parse source path and determine if it's a directory
     wxFileName sourceFn( aSourcePath );
@@ -417,85 +495,72 @@ bool CopyFilesOrDirectory( const wxString& aSourcePath, const wxString& aDestDir
     bool       isSourceDirectory = wxFileName::DirExists( sourcePath );
     wxString   baseDestDir = aDestDir;
 
-    auto performCopy = [&]( const wxString& src, const wxString& dest ) -> bool
-    {
-        if( wxCopyFile( src, dest ) )
-        {
-            aFileCopiedCount++;
-            return true;
-        }
-
-        aErrors += wxString::Format( _( "Could not copy file: %s to %s" ), src, dest );
-        aErrors += wxT( "\n" );
-        return false;
-    };
-
-    auto processEntries = [&]( const wxString& srcDir, const wxString& pattern,
-                               const wxString& destDir ) -> bool
-    {
-        wxDir dir( srcDir );
-
-        if( !dir.IsOpened() )
-        {
-            aErrors += wxString::Format( _( "Could not open source directory: %s" ), srcDir );
-            aErrors += wxT( "\n" );
-            return false;
-        }
-
-        wxString filename;
-        bool     success = true;
-
-        // Find all entries matching pattern (files + directories + hidden items)
-        bool cont = dir.GetFirst( &filename, pattern, wxDIR_FILES | wxDIR_DIRS | wxDIR_HIDDEN );
-
-        while( cont )
-        {
-            const wxString entrySrc = srcDir + wxFileName::GetPathSeparator() + filename;
-            const wxString entryDest = destDir + wxFileName::GetPathSeparator() + filename;
-
-            // Apply exclusion filters
-            bool exclude =
-                    filename.Matches( wxT( "~*.lck" ) ) || filename.Matches( wxT( "*.lck" ) );
-
-            for( const auto& exclusion : aExclusions )
+    auto performCopy =
+            [&]( const wxString& src, const wxString& dest ) -> bool
             {
-                if( entrySrc.Matches( exclusion ) )
+                if( wxCopyFile( src, dest, aAllowOverwrites ) )
                 {
-                    exclude = true;
-                    break;
+                    aPathsWritten.push_back( dest );
+                    return true;
                 }
-            }
 
-            if( !exclude )
+                aErrors += wxString::Format( _( "Could not copy file: %s to %s" ), src, dest );
+                aErrors += wxT( "\n" );
+                return false;
+            };
+
+    auto processEntries =
+            [&]( const wxString& srcDir, const wxString& pattern, const wxString& destDir ) -> bool
             {
-                if( wxFileName::DirExists( entrySrc ) )
+                wxDir dir( srcDir );
+
+                if( !dir.IsOpened() )
                 {
-                    // Recursively process subdirectories
-                    if( !CopyFilesOrDirectory( entrySrc, destDir, aErrors, aFileCopiedCount,
-                                               aExclusions ) )
-                    {
-                        aErrors += wxString::Format( _( "Could not copy directory: %s to %s" ),
-                                                     entrySrc, entryDest );
-                        aErrors += wxT( "\n" );
-
-                        success = false;
-                    }
+                    aErrors += wxString::Format( _( "Could not open source directory: %s" ), srcDir );
+                    aErrors += wxT( "\n" );
+                    return false;
                 }
-                else
+
+                wxString filename;
+                bool     success = true;
+
+                // Find all entries matching pattern (files + directories + hidden items)
+                bool cont = dir.GetFirst( &filename, pattern, wxDIR_FILES | wxDIR_DIRS | wxDIR_HIDDEN );
+
+                while( cont )
                 {
-                    // Copy individual files
-                    if( !performCopy( entrySrc, entryDest ) )
+                    const wxString entrySrc = srcDir + wxFileName::GetPathSeparator() + filename;
+                    const wxString entryDest = destDir + wxFileName::GetPathSeparator() + filename;
+
+                    if( !filename.Matches( wxT( "~*.lck" ) ) && !filename.Matches( wxT( "*.lck" ) ) )
                     {
-                        success = false;
+                        if( wxFileName::DirExists( entrySrc ) )
+                        {
+                            // Recursively process subdirectories
+                            if( !CopyFilesOrDirectory( entrySrc, destDir, aAllowOverwrites, aErrors, aPathsWritten ) )
+                            {
+                                aErrors += wxString::Format( _( "Could not copy directory: %s to %s" ),
+                                                             entrySrc, entryDest );
+                                aErrors += wxT( "\n" );
+
+                                success = false;
+                            }
+                        }
+                        else
+                        {
+                            // Copy individual files
+                            if( !performCopy( entrySrc, entryDest ) )
+                            {
+                                success = false;
+                            }
+                        }
                     }
+
+                    cont = dir.GetNext( &filename );
                 }
-            }
 
-            cont = dir.GetNext( &filename );
-        }
-
-        return success;
-    };
+                return success;
+            };
 
     // If copying a directory, append its name to destination path
     if( isSourceDirectory )
@@ -507,8 +572,7 @@ bool CopyFilesOrDirectory( const wxString& aSourcePath, const wxString& aDestDir
     // Create destination directory hierarchy
     if( !wxFileName::Mkdir( baseDestDir, wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL ) )
     {
-        aErrors +=
-                wxString::Format( _( "Could not create destination directory: %s" ), baseDestDir );
+        aErrors += wxString::Format( _( "Could not create destination directory: %s" ), baseDestDir );
         aErrors += wxT( "\n" );
 
         return false;
@@ -531,6 +595,7 @@ bool CopyFilesOrDirectory( const wxString& aSourcePath, const wxString& aDestDir
 
                 return false;
             }
+
             // Process all matching files in source directory
             return processEntries( dirPath, fileName, baseDestDir );
         }

common/git/git_pull_handler.cpp

@@ -378,6 +378,14 @@ PullResult GIT_PULL_HANDLER::handleFastForward()
 PullResult GIT_PULL_HANDLER::handleMerge( const git_annotated_commit** aMergeHeads,
                                           size_t                       aMergeHeadsCount )
 {
+    if( hasUnstagedChanges( GetRepo() ) )
+    {
+        AddErrorString(
+                _( "Cannot merge: you have unstaged changes. "
+                   "Please commit or stash them before pulling." ) );
+        return PullResult::DirtyWorkdir;
+    }
+
     git_merge_options merge_opts;
     git_merge_options_init( &merge_opts, GIT_MERGE_OPTIONS_VERSION );
 
@@ -481,6 +489,14 @@ PullResult GIT_PULL_HANDLER::handleMerge( const git_annotated_commit** aMergeHea
 
 PullResult GIT_PULL_HANDLER::handleRebase( const git_annotated_commit** aMergeHeads, size_t aMergeHeadsCount )
 {
+    if( hasUnstagedChanges( GetRepo() ) )
+    {
+        AddErrorString(
+                _( "Cannot rebase: you have unstaged changes. "
+                   "Please commit or stash them before pulling." ) );
+        return PullResult::DirtyWorkdir;
+    }
+
     // Get the current branch reference
     git_reference* head_ref = nullptr;
 
@@ -563,6 +579,40 @@ PullResult GIT_PULL_HANDLER::handleRebase( const git_annotated_commit** aMergeHe
 }
 
 
+bool GIT_PULL_HANDLER::hasUnstagedChanges( git_repository* aRepo )
+{
+    if( !aRepo )
+        return false;
+
+    git_status_options opts;
+    git_status_init_options( &opts, GIT_STATUS_OPTIONS_VERSION );
+
+    opts.show = GIT_STATUS_SHOW_WORKDIR_ONLY;
+    opts.flags = GIT_STATUS_OPT_INCLUDE_UNTRACKED;
+
+    git_status_list* status_list = nullptr;
+
+    if( git_status_list_new( &status_list, aRepo, &opts ) != GIT_OK )
+    {
+        wxLogTrace( traceGit, "Failed to get status list: %s", KIGIT_COMMON::GetLastGitError() );
+        return false;
+    }
+
+    KIGIT::GitStatusListPtr status_list_ptr( status_list );
+    size_t count = git_status_list_entrycount( status_list );
+
+    for( size_t ii = 0; ii < count; ++ii )
+    {
+        const git_status_entry* entry = git_status_byindex( status_list, ii );
+
+        if( entry->status & ( GIT_STATUS_WT_MODIFIED | GIT_STATUS_WT_DELETED | GIT_STATUS_WT_TYPECHANGE ) )
+            return true;
+    }
+
+    return false;
+}
+
+
 void GIT_PULL_HANDLER::UpdateProgress( int aCurrent, int aTotal, const wxString& aMessage )
 {
 

common/git/git_pull_handler.h

@@ -43,6 +43,7 @@ struct CommitDetails
 // Enum for result codes, error codes are negative, success codes are positive
 enum class PullResult : int
 {
+    DirtyWorkdir = -3,
     MergeFailed = -2,
     Error = -1,
     Success = 0,
@@ -86,6 +87,8 @@ private:
     PullResult  handleFastForward();
     PullResult  handleMerge( const git_annotated_commit** aMergeHeads, size_t aMergeHeadsCount );
     PullResult  handleRebase( const git_annotated_commit** aMergeHeads, size_t aMergeHeadsCount );
+
+    static bool hasUnstagedChanges( git_repository* aRepo );
 };
 
 #endif // _GIT_PULL_HANDLER_H_

common/git/kicad_git_common.cpp

@@ -40,7 +40,7 @@
 
 KIGIT_COMMON::KIGIT_COMMON( git_repository* aRepo ) :
         m_repo( aRepo ), m_connType( GIT_CONN_TYPE::GIT_CONN_LOCAL ), m_testedTypes( 0 ),
-        m_nextPublicKey( 0 )
+        m_nextPublicKey( 0 ), m_secretFetched( false )
 {}
 
 KIGIT_COMMON::KIGIT_COMMON( const KIGIT_COMMON& aOther ) :
@@ -55,7 +55,8 @@ KIGIT_COMMON::KIGIT_COMMON( const KIGIT_COMMON& aOther ) :
         // The mutex is default-initialized, not copied
         m_gitActionMutex(),
         m_publicKeys( aOther.m_publicKeys ),
-        m_nextPublicKey( aOther.m_nextPublicKey )
+        m_nextPublicKey( aOther.m_nextPublicKey ),
+        m_secretFetched( aOther.m_secretFetched )
 {
 }
 
@@ -100,6 +101,25 @@ wxString KIGIT_COMMON::GetCurrentBranchName() const
 }
 
 
+wxString KIGIT_COMMON::GetPassword()
+{
+    if( !m_secretFetched )
+    {
+        if( m_connType != GIT_CONN_TYPE::GIT_CONN_LOCAL && !m_remote.IsEmpty() )
+        {
+            wxString secret;
+
+            if( KIPLATFORM::SECRETS::GetSecret( m_remote, m_username, secret ) )
+                m_password = secret;
+        }
+
+        m_secretFetched = true;
+    }
+
+    return m_password;
+}
+
+
 std::vector<wxString> KIGIT_COMMON::GetBranchNames() const
 {
     if( !m_repo )
@@ -238,7 +258,7 @@ std::pair<std::set<wxString>,std::set<wxString>> KIGIT_COMMON::GetDifferentFiles
         std::set<wxString> modified_set;
         git_revwalk* walker = nullptr;
 
-        if( !m_repo || !from_oid )
+        if( !m_repo || !from_oid || IsCancelled() )
             return modified_set;
 
         if( git_revwalk_new( &walker, m_repo ) != GIT_OK )
@@ -266,6 +286,10 @@ std::pair<std::set<wxString>,std::set<wxString>> KIGIT_COMMON::GetDifferentFiles
         // iterate over all local commits not in remote
         while( git_revwalk_next( &oid, walker ) == GIT_OK )
         {
+            // Check for cancellation to allow early exit during shutdown
+            if( IsCancelled() )
+                return modified_set;
+
             if( git_commit_lookup( &commit, m_repo, &oid ) != GIT_OK )
             {
                 wxLogTrace( traceGit, "Failed to lookup commit: %s", KIGIT_COMMON::GetLastGitError() );
@@ -351,7 +375,7 @@ std::pair<std::set<wxString>,std::set<wxString>> KIGIT_COMMON::GetDifferentFiles
 
     std::pair<std::set<wxString>,std::set<wxString>> modified_files;
 
-    if( !m_repo )
+    if( !m_repo || IsCancelled() )
         return modified_files;
 
     git_reference* head = nullptr;
@@ -645,6 +669,10 @@ void KIGIT_COMMON::UpdateCurrentBranchInfo()
     wxString remote_name = GetRemotename();
     git_remote* remote = nullptr;
 
+    m_remote.clear();
+    m_password.clear();
+    m_secretFetched = false;
+
     if( git_remote_lookup( &remote, m_repo, remote_name.ToStdString().c_str() ) == GIT_OK )
     {
         const char* url = git_remote_url( remote );
@@ -655,9 +683,6 @@ void KIGIT_COMMON::UpdateCurrentBranchInfo()
         git_remote_free( remote );
     }
 
-    // Find the stored password if it exists
-    KIPLATFORM::SECRETS::GetSecret( m_remote, m_username, m_password );
-
     updateConnectionType();
     updatePublicKeys();
 }
@@ -748,6 +773,8 @@ void KIGIT_COMMON::updateConnectionType()
                 m_hostname = host;
         }
     }
+
+    m_secretFetched = !m_password.IsEmpty();
 }
 
 

common/git/kicad_git_common.h

@@ -26,6 +26,7 @@
 
 #include <git/kicad_git_errors.h>
 
+#include <atomic>
 #include <git2.h>
 #include <mutex>
 #include <set>
@@ -89,11 +90,11 @@ public:
     };
 
     wxString GetUsername() const { return m_username; }
-    wxString GetPassword() const { return m_password; }
+    wxString GetPassword();
     GIT_CONN_TYPE GetConnType() const;
 
-    void SetUsername( const wxString& aUsername ) { m_username = aUsername; }
-    void SetPassword( const wxString& aPassword ) { m_password = aPassword; }
+    void SetUsername( const wxString& aUsername ) { m_username = aUsername; m_secretFetched = false; }
+    void SetPassword( const wxString& aPassword ) { m_password = aPassword; m_secretFetched = true; }
     void SetSSHKey( const wxString& aSSHKey );
 
     // Holds a temporary variable that can be used by the authentication callback
@@ -127,6 +128,8 @@ public:
     void SetRemote( const wxString& aRemote )
     {
         m_remote = aRemote;
+        m_password.clear();
+        m_secretFetched = false;
         updateConnectionType();
     }
 
@@ -136,6 +139,12 @@ public:
 
     int HandleSSHAgentAuthentication( git_cred** aOut, const wxString& aUsername );
 
+    bool IsCancelled() const { return m_cancel.load(); }
+
+    void SetCancelled( bool aCancel ) { m_cancel.store( aCancel ); }
+
+    std::mutex& GetMutex() { return m_gitActionMutex; }
+
     static wxString GetLastGitError()
     {
         const git_error* error = git_error_last();
@@ -170,6 +179,9 @@ private:
 
     std::vector<wxString> m_publicKeys;
     int m_nextPublicKey;
+    bool m_secretFetched;
+
+    std::atomic<bool> m_cancel{ false };
 
     // Create a dummy flag to tell if we have tested ssh agent credentials separately
     // from the ssh key credentials

common/hotkeys_basic.cpp

@@ -324,7 +324,9 @@ int KeyCodeFromKeyName( const wxString& keyname )
 void DisplayHotkeyList( EDA_BASE_FRAME* aParent )
 {
     DIALOG_LIST_HOTKEYS dlg( aParent );
-    dlg.ShowModal();
+
+    if( dlg.ShowModal() == wxID_OK )
+        dlg.Kiway().CommonSettingsChanged( HOTKEYS_CHANGED );
 }
 
 

common/http_lib/http_lib_connection.cpp

@@ -323,11 +323,7 @@ bool HTTP_LIB_CONNECTION::SelectAll( const HTTP_LIB_CATEGORY& aCategory, std::ve
             part.id = item.at( "id" );
 
             if( item.contains( "description" ) )
-            {
-                // At this point we don't display anything so just set it to false
-                part.fields.push_back( std::make_pair( "description",
-                                                       std::make_tuple( item.at( "description" ), false ) ) );
-            }
+                part.desc = item.at( "description" );
 
             // API might not want to return an optional name.
             if( item.contains( "name" ) )

common/import_gfx/graphics_importer_buffer.cpp

@@ -132,10 +132,12 @@ void GRAPHICS_IMPORTER_BUFFER::ImportTo( GRAPHICS_IMPORTER& aImporter )
     // the graphics in the KiCad drawing area.
     else if( aImporter.GetImportOffsetMM() == VECTOR2D( 0, 0 ) )
     {
-        if( boundingBox.GetRight() > std::numeric_limits<int>::max()
-            || boundingBox.GetBottom() > std::numeric_limits<int>::max()
-            || boundingBox.GetLeft() < std::numeric_limits<int>::min()
-            || boundingBox.GetTop() < std::numeric_limits<int>::min() )
+        double iuFactor = aImporter.GetMillimeterToIuFactor();
+
+        if( boundingBox.GetRight() * iuFactor > std::numeric_limits<int>::max()
+            || boundingBox.GetBottom() * iuFactor > std::numeric_limits<int>::max()
+            || boundingBox.GetLeft() * iuFactor < std::numeric_limits<int>::min()
+            || boundingBox.GetTop() * iuFactor < std::numeric_limits<int>::min() )
         {
             VECTOR2D offset = boundingBox.GetOrigin();
             aImporter.SetImportOffsetMM( -offset );

common/io/altium/altium_ascii_parser.cpp

@@ -119,7 +119,10 @@ std::map<wxString, wxString> ALTIUM_ASCII_PARSER::ReadProperties()
             if( canonicalKey == wxT( "DESIGNATOR" ) || canonicalKey == wxT( "NAME" )
                 || canonicalKey == wxT( "TEXT" ) )
             {
-                if( kv[ wxT( "RECORD" ) ] != wxT( "4" ) )
+                wxString recordType = kv[ wxT( "RECORD" ) ];
+
+                // RECORD=33 (FILE_NAME) stores Windows-formatted paths; keep the backslashes intact.
+                if( recordType != wxT( "4" ) && recordType != wxT( "33" ) )
                     value = AltiumPropertyToKiCadString( value );
             }
         }

common/io/altium/altium_binary_parser.cpp

@@ -382,7 +382,7 @@ std::map<wxString, wxString> ALTIUM_BINARY_PARSER::ReadProperties(
 
     // we use std::string because std::string can handle NULL-bytes
     // wxString would end the string at the first NULL-byte
-    std::string str = std::string( m_pos, length - ( hasNullByte ? 1 : 0 ) );
+    std::string str = std::string( m_pos, length - ( ( hasNullByte && !isBinary ) ? 1 : 0 ) );
     m_pos += length;
 
     if( isBinary )

common/io/eagle/eagle_parser.cpp

@@ -327,7 +327,8 @@ bool EURN::IsValid() const
         "footprint",
         "library",
         "package",
-        "symbol"
+        "symbol",
+        "fs.file"
     };
 
     if( validAssetTypes.count( assetType ) == 0 )
@@ -407,11 +408,29 @@ EROT Convert<EROT>( const wxString& aRot )
 
     value.spin    = aRot.find( 'S' ) != aRot.npos;
     value.mirror  = aRot.find( 'M' ) != aRot.npos;
-    value.degrees = strtod( aRot.c_str()
-                            + 1                        // skip leading 'R'
-                            + int( value.spin )       // skip optional leading 'S'
-                            + int( value.mirror ),    // skip optional leading 'M'
-                            nullptr );
+
+    size_t rPos = aRot.find( 'R' );
+
+    if( rPos == wxString::npos )
+    {
+        value.degrees = 0.0;
+        return value;
+    }
+
+    // Calculate the offset after 'R', 'S', and 'M'
+    size_t offset;
+
+    for( offset = 0; offset < aRot.size(); offset++ )
+    {
+        if( wxIsdigit( aRot[offset] ) )
+            break;
+    }
+
+    wxString degreesStr = aRot.Mid( offset );
+
+    // Use locale-independent conversion
+    if( !degreesStr.ToCDouble( &value.degrees ) )
+        value.degrees = 0.0;
 
     return value;
 }

common/io/eagle/eagle_parser.h

@@ -428,6 +428,9 @@ struct EAGLE_BASE
  *   The "/<VERSION>" is omitted when referencing the asset without specifying a particular version.
  *   For example, "urn:adsk.eagle:component:60986/2" references version 2 of component 60986 and
  *   "urn:adsk.eagle:library:60968" references library 60986 without specifying a version.
+ * 
+ * Autodesk Fusion can use a different format instead, e.g.:
+ * "urn:adsk.wipprod:fs.file:vf.RSKzNVZVQPeDNm7Bnfr3WQ"
  */
 struct EURN : public EAGLE_BASE
 {

common/io/easyedapro/easyedapro_import_utils.cpp

@@ -72,7 +72,17 @@ EASYEDAPRO::ProjectToSelectorDialog( const nlohmann::json& aProject, bool aPcbOn
 
     std::map<wxString, EASYEDAPRO::PRJ_SCHEMATIC> prjSchematics = aProject.at( "schematics" );
     std::map<wxString, EASYEDAPRO::PRJ_BOARD>     prjBoards = aProject.at( "boards" );
-    std::map<wxString, wxString>                  prjPcbNames = aProject.at( "pcbs" );
+
+    std::map<wxString, wxString>       prjPcbNames;
+    std::map<wxString, nlohmann::json> prjPcbs = aProject.at( "pcbs" );
+
+    for( const auto& [pcbUuid, pcbJsonEntry] : prjPcbs )
+    {
+        if( pcbJsonEntry.is_string() )
+            prjPcbNames.emplace( pcbUuid, pcbJsonEntry );
+        else if( pcbJsonEntry.is_object() )
+            prjPcbNames.emplace( pcbUuid, pcbJsonEntry.at( "title" ) );
+    }
 
     for( const auto& [prjName, board] : prjBoards )
     {

common/io/easyedapro/easyedapro_parser.cpp

@@ -220,7 +220,7 @@ void EASYEDAPRO::from_json( const nlohmann::json& j, EASYEDAPRO::PRJ_SYMBOL& d )
     if( j.at( "type" ).is_number() )
         d.type = j.at( "type" );
 
-    if( j.at( "tags" ).is_object() )
+    if( j.find( "tags" ) != j.end() && j.at( "tags" ).is_object() )
         d.tags = j.at( "tags" );
 
     if( j.find( "custom_tags" ) != j.end() && j.at( "custom_tags" ).is_object() )
@@ -249,7 +249,7 @@ void EASYEDAPRO::from_json( const nlohmann::json& j, EASYEDAPRO::PRJ_FOOTPRINT&
     if( j.at( "type" ).is_number() )
         d.type = j.at( "type" );
 
-    if( j.at( "tags" ).is_object() )
+    if( j.find( "tags" ) != j.end() && j.at( "tags" ).is_object() )
         d.tags = j.at( "tags" );
 
     if( j.find( "custom_tags" ) != j.end() && j.at( "custom_tags" ).is_object() )
@@ -275,7 +275,7 @@ void EASYEDAPRO::from_json( const nlohmann::json& j, EASYEDAPRO::PRJ_DEVICE& d )
     if( j.at( "version" ).is_string() )
         d.version = j.at( "version" ).get<wxString>();
 
-    if( j.at( "tags" ).is_object() )
+    if( j.find( "tags" ) != j.end() && j.at( "tags" ).is_object() )
         d.tags = j.at( "tags" );
 
     if( j.find( "custom_tags" ) != j.end() && j.at( "custom_tags" ).is_object() )

common/jobs/job.cpp

@@ -97,27 +97,24 @@ void PrependDirectoryToPath( wxFileName& aFileName, const wxString aDirPath )
 }
 
 
-wxString JOB::GetFullOutputPath( PROJECT* aProject ) const
+wxString JOB::ResolveOutputPath( const wxString& aPath, bool aPathIsDirectory, PROJECT* aProject ) const
 {
     std::function<bool( wxString* )> textResolver =
             [&]( wxString* token ) -> bool
             {
                 if( m_titleBlock.TextVarResolver( token, aProject ) )
                     return true;
-
                 if( aProject )
                     return aProject->TextVarResolver( token );
-
                 return false;
             };
 
-    // use the working output path (nonsaved) over the configured path if its not empty
-    wxString outPath = m_workingOutputPath.IsEmpty() ? m_outputPath : m_workingOutputPath;
+    wxString outPath = aPath;
     outPath = ExpandTextVars( outPath, &textResolver );
 
     if( !m_tempOutputDirectory.IsEmpty() )
     {
-        if( m_outputPathIsDirectory )
+        if( aPathIsDirectory )
         {
             wxFileName fn( outPath );
 
@@ -144,12 +141,19 @@ wxString JOB::GetFullOutputPath( PROJECT* aProject ) const
 
             return fn.GetFullPath();
         }
-	}
+    }
 
     return outPath;
 }
 
 
+wxString JOB::GetFullOutputPath( PROJECT* aProject ) const
+{
+    return ResolveOutputPath( m_workingOutputPath.IsEmpty() ? m_outputPath : m_workingOutputPath,
+                              m_outputPathIsDirectory, aProject );
+}
+
+
 void JOB::SetConfiguredOutputPath( const wxString& aPath )
 {
     m_outputPath = aPath;

common/jobs/job.h

@@ -249,6 +249,8 @@ public:
      */
     wxString GetFullOutputPath( PROJECT* aProject ) const;
 
+    wxString ResolveOutputPath( const wxString& aPath, bool aPathIsDirectory, PROJECT* aProject ) const;
+
     bool GetOutputPathIsDirectory() const { return m_outputPathIsDirectory; }
 
 protected:
@@ -261,6 +263,11 @@ protected:
     wxString m_outputPath;
     bool     m_outputPathIsDirectory;
     wxString m_description;
+
+    /**
+     * The working output path is a transient path that takes priority over the configured
+     * output path when determining where to write output files.
+     */
     wxString m_workingOutputPath;
 
     std::vector<JOB_PARAM_BASE*> m_params;

common/jobs/job_export_pcb_drill.cpp

@@ -70,7 +70,8 @@ JOB_EXPORT_PCB_DRILL::JOB_EXPORT_PCB_DRILL() :
         m_zeroFormat( ZEROS_FORMAT::DECIMAL ),
         m_mapFormat( MAP_FORMAT::PDF ),
         m_gerberPrecision( 5 ),
-        m_generateMap( false )
+        m_generateMap( false ),
+        m_generateReport( false )
 {
     m_params.emplace_back( new JOB_PARAM<bool>( "excellon.mirror_y",
                                                 &m_excellonMirrorY,
@@ -115,6 +116,14 @@ JOB_EXPORT_PCB_DRILL::JOB_EXPORT_PCB_DRILL() :
     m_params.emplace_back( new JOB_PARAM<int>( "gerber_precision",
                                                &m_gerberPrecision,
                                                m_gerberPrecision ) );
+    
+    m_params.emplace_back( new JOB_PARAM<bool>( "generate_report",
+                                                &m_generateReport,
+                                                m_generateReport ) );
+
+    m_params.emplace_back( new JOB_PARAM<wxString>( "report_filename", 
+                                                        &m_reportPath, 
+                                                         m_reportPath ) );
 }
 
 

common/jobs/job_export_pcb_drill.h

@@ -85,6 +85,9 @@ public:
     MAP_FORMAT   m_mapFormat;
     int          m_gerberPrecision;
     bool         m_generateMap;
+
+    bool         m_generateReport;
+    wxString     m_reportPath;
 };
 
 #endif

common/jobs/jobs_output.h

@@ -44,6 +44,7 @@ public:
     virtual bool OutputPrecheck() { return true; }
     virtual bool HandleOutputs( const wxString&                aBaseTempPath,
                                 PROJECT*                       aProject,
+                                const std::vector<wxString>&   aPathsWithOverwriteDisallowed,
                                 const std::vector<JOB_OUTPUT>& aOutputsToHandle ) = 0;
 
     virtual void FromJson( const nlohmann::json& j ) = 0;

common/jobs/jobs_output_archive.cpp

@@ -42,7 +42,9 @@ bool JOBS_OUTPUT_ARCHIVE::OutputPrecheck()
 }
 
 
-bool JOBS_OUTPUT_ARCHIVE::HandleOutputs( const wxString& baseTempPath, PROJECT* aProject,
+bool JOBS_OUTPUT_ARCHIVE::HandleOutputs( const wxString&                baseTempPath,
+                                         PROJECT*                       aProject,
+                                         const std::vector<wxString>&   aPathsWithOverwriteDisallowed,
                                          const std::vector<JOB_OUTPUT>& aOutputsToHandle )
 {
     bool success = true;

common/jobs/jobs_output_archive.h

@@ -32,8 +32,9 @@ public:
         ZIP
     };
 
-    bool HandleOutputs( const wxString& aBaseTempPath,
-                        PROJECT* aProject,
+    bool HandleOutputs( const wxString&                aBaseTempPath,
+                        PROJECT*                       aProject,
+                        const std::vector<wxString>&   aPathsWithOverwriteDisallowed,
                         const std::vector<JOB_OUTPUT>& aOutputsToHandle ) override;
     bool OutputPrecheck() override;
 

common/jobs/jobs_output_folder.cpp

@@ -30,7 +30,9 @@ JOBS_OUTPUT_FOLDER::JOBS_OUTPUT_FOLDER() :
 }
 
 
-bool JOBS_OUTPUT_FOLDER::HandleOutputs( const wxString& baseTempPath, PROJECT* aProject,
+bool JOBS_OUTPUT_FOLDER::HandleOutputs( const wxString&                baseTempPath,
+                                        PROJECT*                       aProject,
+                                        const std::vector<wxString>&   aPathsWithOverwriteDisallowed,
                                         const std::vector<JOB_OUTPUT>& aOutputsToHandle )
 {
     wxString outputPath = ExpandTextVars( m_outputPath, aProject );
@@ -47,7 +49,7 @@ bool JOBS_OUTPUT_FOLDER::HandleOutputs( const wxString& baseTempPath, PROJECT* a
 
     wxString errors;
 
-    if( !CopyDirectory( baseTempPath, outputPath, errors ) )
+    if( !CopyDirectory( baseTempPath, outputPath, aPathsWithOverwriteDisallowed, errors ) )
         return false;
 
     return true;

common/jobs/jobs_output_folder.h

@@ -27,8 +27,9 @@ class JOBS_OUTPUT_FOLDER : public JOBS_OUTPUT_HANDLER
 public:
     JOBS_OUTPUT_FOLDER();
 
-    bool HandleOutputs( const wxString& aBaseTempPath,
-                        PROJECT* aProject,
+    bool HandleOutputs( const wxString&                aBaseTempPath,
+                        PROJECT*                       aProject,
+                        const std::vector<wxString>&   aPathsWithOverwriteDisallowed,
                         const std::vector<JOB_OUTPUT>& aOutputsToHandle ) override;
 
     bool OutputPrecheck() override;

common/kicad_curl/kicad_curl_easy.cpp

@@ -139,6 +139,12 @@ KICAD_CURL_EASY::KICAD_CURL_EASY() :
     curl_easy_setopt( m_CURL, CURLOPT_PROTOCOLS, CURLPROTO_HTTP | CURLPROTO_HTTPS );
 #endif
 
+    // Set connection timeout to prevent long freezes when network is unreachable.
+    // Without this, CURL can wait up to 5 minutes for DNS resolution or connection
+    // establishment, which causes the UI to freeze on macOS when behind a proxy with
+    // restricted internet access.
+    curl_easy_setopt( m_CURL, CURLOPT_CONNECTTIMEOUT, 30L );
+
 #ifdef _WIN32
     long sslOpts = CURLSSLOPT_NATIVE_CA;
 
@@ -345,6 +351,12 @@ bool KICAD_CURL_EASY::SetOutputStream( const std::ostream* aOutput )
 }
 
 
+bool KICAD_CURL_EASY::SetConnectTimeout( long aTimeoutSecs )
+{
+    return setOption( CURLOPT_CONNECTTIMEOUT, aTimeoutSecs ) == CURLE_OK;
+}
+
+
 int KICAD_CURL_EASY::GetTransferTotal( uint64_t& aDownloadedBytes ) const
 {
 #if LIBCURL_VERSION_NUM >= 0x073700 // 7.55.0

common/kiid.cpp

@@ -285,6 +285,17 @@ void KIID::Increment()
 }
 
 
+KIID KIID::Combine( const KIID& aFirst, const KIID& aSecond )
+{
+    KIID result( 0 );
+
+    for( int i = 0; i < 16; ++i )
+        result.m_uuid.data[i] = aFirst.m_uuid.data[i] ^ aSecond.m_uuid.data[i];
+
+    return result;
+}
+
+
 void KIID::CreateNilUuids( bool aNil )
 {
     g_createNilUuids = aNil;

common/lib_tree_model_adapter.cpp

@@ -48,7 +48,20 @@ public:
 
     wxSize GetSize() const override
     {
-        return wxSize( GetOwner()->GetWidth(), GetTextExtent( m_text ).y + 2 );
+        wxSize size( GetOwner()->GetWidth(), GetTextExtent( m_text ).y + 2 );
+
+#if defined( __WXGTK__ ) && !wxCHECK_VERSION( 3, 2, 7 )
+        // Somehow returning 0 or negative width prevents the returned height from
+        // being taken into account at all, even if we return strictly positive
+        // width from later calls to GetSize(), meaning that it's enough to return
+        // 0 from it once to completely break the layout for the entire lifetime of
+        // the control.
+        //
+        // As this is completely unexpected, forcefully prevent this from happening
+        size.IncTo( wxSize( 1, 1 ) );
+#endif
+
+        return size;
     }
 
     bool GetValue( wxVariant& aValue ) const override

common/paths.cpp

@@ -22,6 +22,7 @@
 #include <wx/stdpaths.h>
 #include <wx/string.h>
 #include <wx/utils.h>
+#include <wx/msgdlg.h>
 
 #include <kiplatform/environment.h>
 #include <paths.h>
@@ -151,6 +152,7 @@ wxString PATHS::GetDefaultUserProjectsPath()
 }
 
 
+#if !defined( __WXMAC__ ) && !defined( __WXMSW__ )
 /**
  * Get the CMake build root directory for the current executable
  * (which assumes the executable is in a build directory).
@@ -191,6 +193,48 @@ static wxString getBuildDirectoryRoot()
 
     return fn.GetPath();
 }
+#elif defined( __WXMAC__ )
+/**
+ * Get the main .app bundle root with symlinks resolved.
+ * Handles both main KiCad binaries and aux binaries inside the bundle.
+ * This is the single source of truth for bundle root resolution on macOS.
+ */
+static wxString getOSXBundleRoot()
+{
+    static wxString bundleRoot;
+
+    if( bundleRoot.empty() )
+    {
+        wxFileName fn( wxStandardPaths::Get().GetExecutablePath() );
+        WX_FILENAME::ResolvePossibleSymlinks( fn );
+        fn.SetFullName( wxEmptyString ); // Remove binary name
+
+        // Navigate from .../Contents/MacOS/ up to the .app bundle root
+        // e.g., /Applications/KiCad/KiCad.app/Contents/MacOS -> /Applications/KiCad/KiCad.app
+        if( fn.GetDirCount() >= 2 && fn.GetDirs().Last() == wxT( "MacOS" ) )
+        {
+            fn.RemoveLastDir(); // MacOS
+            fn.RemoveLastDir(); // Contents
+        }
+
+        // Handle aux binaries inside main bundle
+        // From: .../main.app/Contents/Applications/standalone.app
+        // To:   .../main.app
+        const wxArrayString dirs = fn.GetDirs();
+        if( dirs.GetCount() >= 4 && dirs[dirs.GetCount() - 2] == wxT( "Applications" )
+            && dirs[dirs.GetCount() - 4].Lower().EndsWith( wxT( "app" ) ) )
+        {
+            fn.RemoveLastDir(); // standalone.app
+            fn.RemoveLastDir(); // Applications
+            fn.RemoveLastDir(); // Contents
+        }
+
+        bundleRoot = fn.GetPath();
+    }
+
+    return bundleRoot;
+}
+#endif
 
 
 wxString PATHS::GetStockDataPath( bool aRespectRunFromBuildDir )
@@ -201,12 +245,10 @@ wxString PATHS::GetStockDataPath( bool aRespectRunFromBuildDir )
     {
         // Allow debugging from build dir by placing relevant files/folders in the build root
 #if defined( __WXMAC__ )
-        wxFileName fn = wxStandardPaths::Get().GetExecutablePath();
-
-        fn.RemoveLastDir();
-        fn.RemoveLastDir();
-        fn.RemoveLastDir();
-        fn.RemoveLastDir();
+        wxFileName fn;
+        fn.AssignDir( getOSXBundleRoot() );
+        fn.RemoveLastDir(); // Above the .app bundle
+        fn.RemoveLastDir(); // Above the target subdirectory to build root
         path = fn.GetPath();
 #elif defined( __WXMSW__ )
         path = getWindowsKiCadRoot();
@@ -361,32 +403,25 @@ wxString PATHS::GetStockPlugins3DPath()
 
     fn.AppendDir( wxT( "plugins" ) );
 #elif defined( __WXMAC__ )
-    fn.Assign( wxStandardPaths::Get().GetPluginsDir(), wxEmptyString );
-
-    // This must be mapped to main bundle for everything but kicad.app
-    const wxArrayString dirs = fn.GetDirs();
-
-    // Check if we are the main kicad binary.  in this case, the path will be
-    //     /path/to/bundlename.app/Contents/PlugIns
-    // If we are an aux binary, the path will be something like
-    //     /path/to/bundlename.app/Contents/Applications/<standalone>.app/Contents/PlugIns
-    if( dirs.GetCount() >= 6 &&
-        dirs[dirs.GetCount() - 4] == wxT( "Applications" ) &&
-        dirs[dirs.GetCount() - 6].Lower().EndsWith( wxT( "app" ) ) )
-    {
-        fn.RemoveLastDir();
-        fn.RemoveLastDir();
-        fn.RemoveLastDir();
-        fn.RemoveLastDir();
-        fn.AppendDir( wxT( "PlugIns" ) );
-    }
+    fn.AssignDir( getOSXBundleRoot() );
+    fn.AppendDir( wxT( "Contents" ) );
+    fn.AppendDir( wxT( "PlugIns" ) );
 #else
-    // KICAD_PLUGINDIR = CMAKE_INSTALL_FULL_LIBDIR path is the absolute path
-    // corresponding to the install path used for constructing KICAD_USER_PLUGIN
-    wxString tfname = wxString::FromUTF8Unchecked( KICAD_PLUGINDIR );
-    fn.Assign( tfname, "" );
-    fn.AppendDir( wxT( "kicad" ) );
-    fn.AppendDir( wxT( "plugins" ) );
+    if( wxGetEnv( wxT( "KICAD_RUN_FROM_BUILD_DIR" ), nullptr ) )
+    {
+        fn.Assign( wxStandardPaths::Get().GetExecutablePath() );
+        fn.AppendDir( wxT( ".." ) );
+        fn.AppendDir( wxT( "plugins" ) );
+    }
+    else
+    {
+        // KICAD_PLUGINDIR = CMAKE_INSTALL_FULL_LIBDIR path is the absolute path
+        // corresponding to the install path used for constructing KICAD_USER_PLUGIN
+        wxString tfname = wxString::FromUTF8Unchecked( KICAD_PLUGINDIR );
+        fn.Assign( tfname, "" );
+        fn.AppendDir( wxT( "kicad" ) );
+        fn.AppendDir( wxT( "plugins" ) );
+    }
 #endif
 
     fn.AppendDir( wxT( "3d" ) );
@@ -502,6 +537,25 @@ void PATHS::EnsureUserPathsExist()
     EnsurePathExists( GetDefaultUserFootprintsPath() );
     EnsurePathExists( GetDefaultUser3DModelsPath() );
     EnsurePathExists( GetDefault3rdPartyPath() );
+
+#ifdef _WIN32
+    // Warn about Controlled folder access
+    wxFileName tmp;
+    getUserDocumentPath( tmp );
+
+    if( !tmp.DirExists() )
+    {
+        wxString msg = wxString::Format(
+                _( "KiCad was unable to use '%s'.\n"
+                   "\n"
+                   "1. Disable 'Controlled folder access' in Windows settings or Group Policy\n"
+                   "2. Make sure no other antivirus software interferes with KiCad\n"
+                   "3. Make sure you have correct permissions set up" ),
+                tmp.GetPath() );
+
+        wxMessageBox( msg, _( "Warning" ), wxICON_WARNING );
+    }
+#endif
 }
 
 
@@ -530,28 +584,10 @@ wxString PATHS::GetOSXKicadMachineDataDir()
 
 wxString PATHS::GetOSXKicadDataDir()
 {
-    // According to wxWidgets documentation for GetDataDir:
-    // Mac: appname.app/Contents/SharedSupport bundle subdirectory
-    wxFileName ddir( wxStandardPaths::Get().GetDataDir(), wxEmptyString );
-
-    // This must be mapped to main bundle for everything but kicad.app
-    const wxArrayString dirs = ddir.GetDirs();
-
-    // Check if we are the main kicad binary.  in this case, the path will be
-    //     /path/to/bundlename.app/Contents/SharedSupport
-    // If we are an aux binary, the path will be something like
-    //     /path/to/bundlename.app/Contents/Applications/<standalone>.app/Contents/SharedSupport
-    if( dirs.GetCount() >= 6 &&
-        dirs[dirs.GetCount() - 4] == wxT( "Applications" ) &&
-        dirs[dirs.GetCount() - 6].Lower().EndsWith( wxT( "app" ) ) )
-    {
-        ddir.RemoveLastDir();
-        ddir.RemoveLastDir();
-        ddir.RemoveLastDir();
-        ddir.RemoveLastDir();
-        ddir.AppendDir( wxT( "SharedSupport" ) );
-    }
-
+    wxFileName ddir;
+    ddir.AssignDir( getOSXBundleRoot() );
+    ddir.AppendDir( wxT( "Contents" ) );
+    ddir.AppendDir( wxT( "SharedSupport" ) );
     return ddir.GetPath();
 }
 #endif
@@ -622,33 +658,12 @@ const wxString& PATHS::GetExecutablePath()
 
     if( exe_path.empty() )
     {
+#ifdef __WXMAC__
+        // Use bundle root helper which handles symlink resolution and aux binaries
+        exe_path = getOSXBundleRoot() + wxT( "/" );
+#else
         wxString bin_dir = wxStandardPaths::Get().GetExecutablePath();
 
-#ifdef __WXMAC__
-        // On OSX GetExecutablePath() will always point to main
-        // bundle directory, e.g., /Applications/kicad.app/
-
-        wxFileName fn( bin_dir );
-        WX_FILENAME::ResolvePossibleSymlinks( fn );
-
-        if( fn.GetName() == wxT( "kicad" ) || fn.GetName() == wxT( "kicad-cli" ) )
-        {
-            // kicad launcher, so just remove the Contents/MacOS part
-            fn.RemoveLastDir();
-            fn.RemoveLastDir();
-        }
-        else
-        {
-            // standalone binaries live in Contents/Applications/<standalone>.app/Contents/MacOS
-            fn.RemoveLastDir();
-            fn.RemoveLastDir();
-            fn.RemoveLastDir();
-            fn.RemoveLastDir();
-            fn.RemoveLastDir();
-        }
-
-        bin_dir = fn.GetPath() + wxT( "/" );
-#else
         // Use unix notation for paths. I am not sure this is a good idea,
         // but it simplifies compatibility between Windows and Unices.
         // However it is a potential problem in path handling under Windows.
@@ -657,8 +672,9 @@ const wxString& PATHS::GetExecutablePath()
         // Remove file name form command line:
         while( bin_dir.Last() != '/' && !bin_dir.IsEmpty() )
             bin_dir.RemoveLast();
-#endif
+
         exe_path = bin_dir;
+#endif
     }
 
     return exe_path;

common/pgm_base.cpp

@@ -176,6 +176,8 @@ void PGM_BASE::Destroy()
 #endif
 
     m_pgm_checker.reset();
+
+    m_singleton.Shutdown();
 }
 
 

common/plotters/DXF_plotter.cpp

@@ -141,12 +141,14 @@ void DXF_PLOTTER::SetUnits( DXF_UNITS aUnit )
     case DXF_UNITS::MM:
         m_unitScalingFactor = 0.00254;
         m_measurementDirective = 1;
+        m_insUnits = 4;
         break;
 
     case DXF_UNITS::INCH:
     default:
         m_unitScalingFactor = 0.0001;
         m_measurementDirective = 0;
+        m_insUnits = 1;
     }
 }
 
@@ -219,6 +221,10 @@ bool DXF_PLOTTER::StartPlot( const wxString& aPageNumber )
             "$MEASUREMENT\n"
             "  70\n"
             "%u\n"
+            "  9\n"
+            "$INSUNITS\n"
+            "  70\n"
+            "%u\n"
             "  0\n"
             "ENDSEC\n"
             "  0\n"
@@ -313,7 +319,7 @@ bool DXF_PLOTTER::StartPlot( const wxString& aPageNumber )
             "-0.2\n"
             "  0\n"
             "ENDTAB\n",
-             GetMeasurementDirective() );
+             GetMeasurementDirective(), GetInsUnits() );
 
     // Text styles table
     // Defines 4 text styles, one for each bold/italic combination

common/plotters/PDF_plotter.cpp

@@ -415,7 +415,7 @@ void PDF_PLOTTER::PlotPoly( const std::vector<VECTOR2I>& aCornerList, FILL_T aFi
     if( aFill == FILL_T::NO_FILL )
         fputs( "S\n", m_workFile );
     else if( aWidth == 0 )
-        fputs( "f\n", m_workFile );
+        fputs( "h f\n", m_workFile );
     else
         fputs( "b\n", m_workFile );
 }

common/plotters/SVG_plotter.cpp

@@ -683,10 +683,10 @@ void SVG_PLOTTER::PlotImage( const wxImage& aImage, const VECTOR2I& aPos, double
         img_stream.CopyTo( buffer.data(), buffer.size() );
         base64::encode( buffer, encoded );
 
+        VECTOR2D pos = userToDeviceCoordinates( start );
         fprintf( m_outputFile,
                  "<image x=\"%f\" y=\"%f\" xlink:href=\"data:image/png;base64,",
-                 userToDeviceSize( start.x ),
-                 userToDeviceSize( start.y ) );
+                 pos.x, pos.y );
 
         for( size_t i = 0; i < encoded.size(); i++ )
         {

common/preview_items/construction_geom.cpp

@@ -24,6 +24,7 @@
 #include "preview_items/construction_geom.h"
 
 #include <layer_ids.h>
+#include <utility>
 #include <gal/graphics_abstraction_layer.h>
 #include <geometry/shape_utils.h>
 #include <preview_items/item_drawing_utils.h>
@@ -39,9 +40,15 @@ CONSTRUCTION_GEOM::CONSTRUCTION_GEOM() :
 }
 
 
-void CONSTRUCTION_GEOM::AddDrawable( const DRAWABLE& aItem, bool aPersistent )
+void CONSTRUCTION_GEOM::AddDrawable( const DRAWABLE& aItem, bool aPersistent, int aLineWidth )
 {
-    m_drawables.push_back( { aItem, aPersistent } );
+    m_drawables.push_back( { aItem, aPersistent, aLineWidth } );
+}
+
+
+void CONSTRUCTION_GEOM::SetSnapGuides( std::vector<SNAP_GUIDE> aGuides )
+{
+    m_snapGuides = std::move( aGuides );
 }
 
 
@@ -90,6 +97,7 @@ void CONSTRUCTION_GEOM::ViewDraw( int aLayer, VIEW* aView ) const
     for( const DRAWABLE_INFO& drawable : m_drawables )
     {
         gal.SetStrokeColor( drawable.IsPersistent ? m_persistentColor : m_color );
+        gal.SetLineWidth( drawable.LineWidth );
 
         std::visit(
                 [&]( const auto& visited )
@@ -139,9 +147,17 @@ void CONSTRUCTION_GEOM::ViewDraw( int aLayer, VIEW* aView ) const
                 drawable.Item );
     }
 
+    for( const SNAP_GUIDE& guide : m_snapGuides )
+    {
+        gal.SetStrokeColor( guide.Color );
+        gal.SetLineWidth( guide.LineWidth );
+        gal.DrawLine( guide.Segment.A, guide.Segment.B );
+    }
+
     if( haveSnapLine )
     {
         gal.SetStrokeColor( m_persistentColor );
+        gal.SetLineWidth( 2 );
 
         const int dashSizeBasis = aView->ToWorld( 12 );
         const int snapOriginMarkerSize = aView->ToWorld( 16 );

common/project/net_settings.cpp

@@ -316,9 +316,12 @@ NET_SETTINGS::NET_SETTINGS( JSON_SETTINGS* aParent, const std::string& aPath ) :
                         wxString pattern = entry["pattern"].get<wxString>();
                         wxString netclass = entry["netclass"].get<wxString>();
 
-                        m_netClassPatternAssignments.push_back(
-                                { std::make_unique<EDA_COMBINED_MATCHER>( pattern, CTX_NETCLASS ),
-                                  netclass } );
+                        // Expand bus patterns so individual bus member nets can be matched
+                        ForEachBusMember( pattern,
+                                          [&]( const wxString& memberPattern )
+                                          {
+                                              addSinglePatternAssignment( memberPattern, netclass );
+                                          } );
                     }
                 }
             },
@@ -557,6 +560,21 @@ bool NET_SETTINGS::HasNetclassLabelAssignment( const wxString& netName ) const
 
 
 void NET_SETTINGS::SetNetclassPatternAssignment( const wxString& pattern, const wxString& netclass )
+{
+    // Expand bus patterns (vector buses and bus groups) to individual member patterns.
+    // This is necessary because the regex/wildcard matchers interpret brackets and braces
+    // as special characters, not as bus notation.
+    ForEachBusMember( pattern,
+                      [&]( const wxString& memberPattern )
+                      {
+                          addSinglePatternAssignment( memberPattern, netclass );
+                      } );
+
+    ClearAllCaches();
+}
+
+
+void NET_SETTINGS::addSinglePatternAssignment( const wxString& pattern, const wxString& netclass )
 {
     // Avoid exact duplicates - these shouldn't cause problems, due to later de-duplication
     // but they are unnecessary.
@@ -569,8 +587,6 @@ void NET_SETTINGS::SetNetclassPatternAssignment( const wxString& pattern, const
     // No assignment, add a new one
     m_netClassPatternAssignments.push_back(
             { std::make_unique<EDA_COMBINED_MATCHER>( pattern, CTX_NETCLASS ), netclass } );
-
-    ClearAllCaches();
 }
 
 
@@ -733,6 +749,44 @@ std::shared_ptr<NETCLASS> NET_SETTINGS::GetEffectiveNetClass( const wxString& aN
     // Handle zero resolved netclasses
     if( resolvedNetclasses.size() == 0 )
     {
+        // For bus patterns, check if all members share the same netclass.
+        // If they do, the bus inherits that netclass for coloring purposes.
+        std::shared_ptr<NETCLASS> sharedNetclass;
+        bool                      allSameNetclass = true;
+        bool                      isBusPattern = false;
+
+        ForEachBusMember( aNetName,
+                          [&]( const wxString& member )
+                          {
+                              // If ForEachBusMember gives us back the same name, it's not a bus.
+                              // Skip to avoid infinite recursion.
+                              if( member == aNetName )
+                                  return;
+
+                              isBusPattern = true;
+
+                              if( !allSameNetclass )
+                                  return;
+
+                              std::shared_ptr<NETCLASS> memberNc = GetEffectiveNetClass( member );
+
+                              if( !sharedNetclass )
+                              {
+                                  sharedNetclass = memberNc;
+                              }
+                              else if( memberNc->GetName() != sharedNetclass->GetName() )
+                              {
+                                  allSameNetclass = false;
+                              }
+                          } );
+
+        if( isBusPattern && allSameNetclass && sharedNetclass
+            && sharedNetclass->GetName() != NETCLASS::Default )
+        {
+            m_effectiveNetclassCache[aNetName] = sharedNetclass;
+            return sharedNetclass;
+        }
+
         m_effectiveNetclassCache[aNetName] = m_defaultNetClass;
 
         return m_defaultNetClass;
@@ -1015,6 +1069,33 @@ static bool isSuperSubOverbar( wxChar c )
 }
 
 
+/**
+ * Check if a character at the given position is escaped by a backslash.
+ *
+ * @param aStr The string to check
+ * @param aPos Position of the character to check
+ * @return true if the character is preceded by a backslash escape
+ */
+static bool isEscaped( const wxString& aStr, size_t aPos )
+{
+    if( aPos == 0 )
+        return false;
+
+    // Count consecutive backslashes before this position
+    int backslashCount = 0;
+    size_t pos = aPos;
+
+    while( pos > 0 && aStr[pos - 1] == '\\' )
+    {
+        backslashCount++;
+        pos--;
+    }
+
+    // If odd number of backslashes, the character is escaped
+    return ( backslashCount % 2 ) == 1;
+}
+
+
 bool NET_SETTINGS::ParseBusVector( const wxString& aBus, wxString* aName,
                                    std::vector<wxString>* aMemberList )
 {
@@ -1032,6 +1113,7 @@ bool NET_SETTINGS::ParseBusVector( const wxString& aBus, wxString* aName,
     long     begin = 0;
     long     end = 0;
     int      braceNesting = 0;
+    bool     inQuotes = false;
 
     prefix.reserve( busLen );
 
@@ -1039,18 +1121,57 @@ bool NET_SETTINGS::ParseBusVector( const wxString& aBus, wxString* aName,
     //
     for( ; i < busLen; ++i )
     {
+        // Handle quoted strings (allows spaces inside)
+        if( aBus[i] == '"' && !isEscaped( aBus, i ) )
+        {
+            inQuotes = !inQuotes;
+            continue;
+        }
+
+        if( inQuotes )
+        {
+            // Inside quotes, add characters directly (including spaces)
+            if( aBus[i] == '\\' && i + 1 < busLen )
+            {
+                // Handle escaped characters inside quotes
+                prefix += aBus[++i];
+            }
+            else
+            {
+                prefix += aBus[i];
+            }
+
+            continue;
+        }
+
         if( aBus[i] == '{' )
         {
             if( i > 0 && isSuperSubOverbar( aBus[i-1] ) )
+            {
                 braceNesting++;
+
+                if( !prefix.IsEmpty() )
+                    prefix.RemoveLast();
+
+                continue;
+            }
             else
                 return false;
         }
         else if( aBus[i] == '}' )
         {
             braceNesting--;
+            continue;
         }
 
+        // Handle backslash-escaped spaces
+        if( aBus[i] == '\\' && i + 1 < busLen && aBus[i + 1] == ' ' )
+        {
+            prefix += aBus[++i];
+            continue;
+        }
+
+        // Unescaped space or ] in bus vector prefix is not allowed
         if( aBus[i] == ' ' || aBus[i] == ']' )
             return false;
 
@@ -1111,6 +1232,9 @@ bool NET_SETTINGS::ParseBusVector( const wxString& aBus, wxString* aName,
         if( aBus[i] == '}' )
         {
             braceNesting--;
+        }
+        else if( aBus[i] == '+' || aBus[i] == '-' || aBus[i] == 'P' || aBus[i] == 'N' )
+        {
             suffix += aBus[i];
         }
         else
@@ -1154,17 +1278,68 @@ bool NET_SETTINGS::ParseBusGroup( const wxString& aGroup, wxString* aName,
     wxString prefix;
     wxString tmp;
     int      braceNesting = 0;
+    bool     inQuotes = false;
 
     prefix.reserve( groupLen );
 
+    // Escape spaces in member names so recursive parsing by ForEachBusMember works correctly.
+    // Both quoted strings and backslash-escaped spaces collapse to bare spaces during parsing,
+    // so we must re-escape them for subsequent ParseBusVector/ParseBusGroup calls.
+    auto escapeSpacesForBus =
+            []( const wxString& aMember ) -> wxString
+            {
+                wxString escaped;
+                escaped.reserve( aMember.length() * 2 );
+
+                for( wxUniChar c : aMember )
+                {
+                    if( c == ' ' )
+                        escaped += wxT( "\\ " );
+                    else
+                        escaped += c;
+                }
+
+                return escaped;
+            };
+
     // Parse prefix
     //
     for( ; i < groupLen; ++i )
     {
+        // Handle quoted strings (allows spaces inside)
+        if( aGroup[i] == '"' && !isEscaped( aGroup, i ) )
+        {
+            inQuotes = !inQuotes;
+            continue;
+        }
+
+        if( inQuotes )
+        {
+            // Inside quotes, add characters directly (including spaces)
+            if( aGroup[i] == '\\' && i + 1 < groupLen )
+            {
+                // Handle escaped characters inside quotes
+                prefix += aGroup[++i];
+            }
+            else
+            {
+                prefix += aGroup[i];
+            }
+
+            continue;
+        }
+
         if( aGroup[i] == '{' )
         {
             if( i > 0 && isSuperSubOverbar( aGroup[i-1] ) )
+            {
                 braceNesting++;
+
+                if( !prefix.IsEmpty() )
+                    prefix.RemoveLast();
+
+                continue;
+            }
             else
                 break;
         }
@@ -1173,6 +1348,14 @@ bool NET_SETTINGS::ParseBusGroup( const wxString& aGroup, wxString* aName,
             braceNesting--;
         }
 
+        // Handle backslash-escaped spaces
+        if( aGroup[i] == '\\' && i + 1 < groupLen && aGroup[i + 1] == ' ' )
+        {
+            prefix += aGroup[++i];
+            continue;
+        }
+
+        // Unescaped space, [, or ] in bus group prefix is not allowed
         if( aGroup[i] == ' ' || aGroup[i] == '[' || aGroup[i] == ']' )
             return false;
 
@@ -1192,12 +1375,44 @@ bool NET_SETTINGS::ParseBusGroup( const wxString& aGroup, wxString* aName,
     if( i >= groupLen )
         return false;
 
+    inQuotes = false;
+
     for( ; i < groupLen; ++i )
     {
+        // Handle quoted strings (allows spaces inside member names)
+        if( aGroup[i] == '"' && !isEscaped( aGroup, i ) )
+        {
+            inQuotes = !inQuotes;
+            continue;
+        }
+
+        if( inQuotes )
+        {
+            // Inside quotes, add characters directly (including spaces)
+            if( aGroup[i] == '\\' && i + 1 < groupLen )
+            {
+                // Handle escaped characters inside quotes
+                tmp += aGroup[++i];
+            }
+            else
+            {
+                tmp += aGroup[i];
+            }
+
+            continue;
+        }
+
         if( aGroup[i] == '{' )
         {
             if( i > 0 && isSuperSubOverbar( aGroup[i-1] ) )
+            {
                 braceNesting++;
+
+                if( !tmp.IsEmpty() )
+                    tmp.RemoveLast();
+
+                continue;
+            }
             else
                 return false;
         }
@@ -1206,21 +1421,29 @@ bool NET_SETTINGS::ParseBusGroup( const wxString& aGroup, wxString* aName,
             if( braceNesting )
             {
                 braceNesting--;
+                continue;
             }
             else
             {
                 if( aMemberList && !tmp.IsEmpty() )
-                    aMemberList->push_back( EscapeString( tmp, CTX_NETNAME ) );
+                    aMemberList->push_back( EscapeString( escapeSpacesForBus( tmp ), CTX_NETNAME ) );
 
                 return true;
             }
         }
 
-        // Commas aren't strictly legal, but we can be pretty sure what the author had in mind.
+        // Handle backslash-escaped spaces in member names
+        if( aGroup[i] == '\\' && i + 1 < groupLen && aGroup[i + 1] == ' ' )
+        {
+            tmp += aGroup[++i];
+            continue;
+        }
+
+        // Unescaped space or comma separates members
         if( aGroup[i] == ' ' || aGroup[i] == ',' )
         {
             if( aMemberList && !tmp.IsEmpty() )
-                aMemberList->push_back( EscapeString( tmp, CTX_NETNAME ) );
+                aMemberList->push_back( EscapeString( escapeSpacesForBus( tmp ), CTX_NETNAME ) );
 
             tmp.Clear();
             continue;
@@ -1231,3 +1454,28 @@ bool NET_SETTINGS::ParseBusGroup( const wxString& aGroup, wxString* aName,
 
     return false;
 }
+
+
+void NET_SETTINGS::ForEachBusMember( const wxString&                              aBusPattern,
+                                     const std::function<void( const wxString& )>& aFunction )
+{
+    std::vector<wxString> members;
+
+    if( ParseBusVector( aBusPattern, nullptr, &members ) )
+    {
+        // Vector bus: call function for each expanded member
+        for( const wxString& member : members )
+            aFunction( member );
+    }
+    else if( ParseBusGroup( aBusPattern, nullptr, &members ) )
+    {
+        // Bus group: recursively expand each member (which may itself be a vector or group)
+        for( const wxString& member : members )
+            ForEachBusMember( member, aFunction );
+    }
+    else
+    {
+        // Not a bus pattern: call function with the original pattern
+        aFunction( aBusPattern );
+    }
+}

common/project/project_file.cpp

@@ -117,6 +117,8 @@ PROJECT_FILE::PROJECT_FILE( const wxString& aFullPath ) :
                     m_LegacyLibNames.push_back( entry.get<wxString>() );
             }, {} ) );
 
+
+
     m_NetSettings = std::make_shared<NET_SETTINGS>( this, "net_settings" );
 
     m_params.emplace_back( new PARAM_LAYER_PRESET( "board.layer_presets", &m_LayerPresets ) );

common/project/project_local_settings.cpp

@@ -45,6 +45,7 @@ PROJECT_LOCAL_SETTINGS::PROJECT_LOCAL_SETTINGS( PROJECT* aProject, const wxStrin
         m_ShapeOpacity( 1.0 ),
         m_ImageOpacity( 0.6 ),
         m_PcbSelectionFilter(),
+        m_GitIntegrationDisabled( false ),
         m_project( aProject ),
         m_wasMigrated( false )
 {
@@ -207,6 +208,8 @@ PROJECT_LOCAL_SETTINGS::PROJECT_LOCAL_SETTINGS( PROJECT* aProject, const wxStrin
 
     m_params.emplace_back( new PARAM<wxString>( "git.ssh_key", &m_GitSSHKey, "" ) );
 
+    m_params.emplace_back( new PARAM<bool>( "git.integration_disabled", &m_GitIntegrationDisabled, false ) );
+
     m_params.emplace_back( new PARAM<wxString>( "net_inspector_panel.filter_text",
                                                 &m_NetInspectorPanel.filter_text, "" ) );
     m_params.emplace_back( new PARAM<bool>( "net_inspector_panel.filter_by_net_name",

common/properties/pg_editors.cpp

@@ -311,13 +311,21 @@ wxPGWindowList PG_COLOR_EDITOR::CreateControls( wxPropertyGrid* aGrid, wxPGPrope
     editor->SetPosition( aPos );
     editor->SetSize( aSize );
 
+    // Capture property name instead of pointer to avoid dangling pointer if grid is rebuilt
+    wxString propName = colorProp->GetName();
+
     editor->Bind( COLOR_SWATCH_CHANGED,
                   [=]( wxCommandEvent& aEvt )
                   {
-                      wxVariant val;
-                      auto data = new COLOR4D_VARIANT_DATA( editor->GetSwatchColor() );
-                      val.SetData( data );
-                      aGrid->ChangePropertyValue( colorProp, val );
+                      wxPGProperty* prop = aGrid->GetPropertyByName( propName );
+
+                      if( prop )
+                      {
+                          wxVariant val;
+                          auto data = new COLOR4D_VARIANT_DATA( editor->GetSwatchColor() );
+                          val.SetData( data );
+                          aGrid->ChangePropertyValue( prop, val );
+                      }
                   } );
 
 #if wxCHECK_VERSION( 3, 3, 0 )
@@ -330,6 +338,11 @@ wxPGWindowList PG_COLOR_EDITOR::CreateControls( wxPropertyGrid* aGrid, wxPGPrope
                 [=]()
                 {
                     editor->GetNewSwatchColor();
+
+                    wxPGProperty* prop = aGrid->GetPropertyByName( propName );
+
+                    if( prop )
+                        aGrid->DrawItem( prop );
                 } );
     }
 

common/properties/pg_properties.cpp

@@ -254,9 +254,11 @@ wxPGProperty* PGPropertyFactory( const PROPERTY_BASE* aProperty, EDA_DRAW_FRAME*
         // Enum property
         if( aProperty->HasChoices() )
         {
+            const_cast<PROPERTY_BASE*>( aProperty )->TranslateChoices();
+
             // I do not know why enum property takes a non-const reference to wxPGChoices..
             ret = new wxEnumProperty( wxPG_LABEL, wxPG_LABEL,
-                    const_cast<wxPGChoices&>( aProperty->Choices() ) );
+                                      const_cast<wxPGChoices&>( aProperty->Choices() ) );
         }
         else if( typeId == TYPE_HASH( int ) || typeId == TYPE_HASH( long ) )
         {

common/rc_item.cpp

@@ -174,6 +174,9 @@ void RC_ITEM::GetJsonViolation( RC_JSON::VIOLATION& aViolation, UNITS_PROVIDER*
     aViolation.type = GetSettingsKey();
     aViolation.excluded = ( m_parent && m_parent->IsExcluded() );
 
+    if( m_parent && m_parent->IsExcluded() && !m_parent->GetComment().IsEmpty() )
+        aViolation.comment = m_parent->GetComment();
+
     EDA_ITEM* mainItem = nullptr;
     EDA_ITEM* auxItem = nullptr;
 

common/scintilla_tricks.cpp

@@ -206,10 +206,12 @@ void SCINTILLA_TRICKS::onModified( wxStyledTextEvent& aEvent )
     {
         // If the font is larger than the height of a single-line text box we can get issues
         // with the text disappearing every other character due to dodgy scrolling behaviour.
-        CallAfter( [this]()
-                   {
-                       m_te->ScrollToStart();
-                   } );
+        CallAfter(
+                [this]()
+                {
+                    if( !m_te->AutoCompActive() )
+                        m_te->ScrollToStart();
+                } );
     }
 }
 

common/singleton.cpp

@@ -20,18 +20,37 @@
 #include <singleton.h>
 #include <bs_thread_pool.hpp>
 #include <gal/opengl/gl_context_mgr.h>
+#include <thread_pool.h>
 
 
 KICAD_SINGLETON::~KICAD_SINGLETON()
 {
-    // This will wait for all threads to finish and then join them to the main thread
-    delete m_ThreadPool;
+    // Shutdown() should have been called before static destruction.
+    // If not, we still try to clean up, but this may crash on macOS
+    // during static destruction due to condition variable issues.
+    Shutdown();
+}
 
-    m_ThreadPool = nullptr;
 
-    m_GLContextManager->DeleteAll();
-    delete m_GLContextManager;
-    m_GLContextManager = nullptr;
+void KICAD_SINGLETON::Shutdown()
+{
+    // This will wait for all threads to finish and then join them to the main thread.
+    // Must be called before static destruction begins to avoid crashes on macOS.
+    if( m_ThreadPool )
+    {
+        delete m_ThreadPool;
+        m_ThreadPool = nullptr;
+
+        // Clear the cached thread pool pointer to prevent dangling reference
+        InvalidateKiCadThreadPool();
+    }
+
+    if( m_GLContextManager )
+    {
+        m_GLContextManager->DeleteAll();
+        delete m_GLContextManager;
+        m_GLContextManager = nullptr;
+    }
 }
 
 

common/string_utils.cpp

@@ -155,7 +155,7 @@ bool ConvertSmartQuotesAndDashes( wxString* aString )
 
     for( wxString::iterator ii = aString->begin(); ii != aString->end(); ++ii )
     {
-        if( *ii == L'\u00B4' || *ii == L'\u2018' || *ii == L'\u2019' )
+        if( *ii == L'\u2018' || *ii == L'\u2019' )
         {
             *ii = '\'';
             retVal = true;

common/thread_pool.cpp

@@ -26,6 +26,7 @@
 #include <thread_pool.h>
 
 static thread_pool* tp = nullptr;
+static bool         tp_owned = false;  // True if we created the thread pool ourselves
 
 thread_pool& GetKiCadThreadPool()
 {
@@ -36,6 +37,7 @@ thread_pool& GetKiCadThreadPool()
     if( PGM_BASE* pgm = PgmOrNull() )
     {
         tp = &pgm->GetThreadPool();
+        tp_owned = false;
         return *tp;
     }
 
@@ -43,6 +45,20 @@ thread_pool& GetKiCadThreadPool()
     // so we need to create our own thread pool
     int num_threads = std::max( 0, ADVANCED_CFG::GetCfg().m_MaximumThreads );
     tp = new thread_pool( num_threads );
+    tp_owned = true;
 
     return *tp;
 }
+
+
+void InvalidateKiCadThreadPool()
+{
+    // If we own the thread pool (scripting context), delete it
+    if( tp && tp_owned )
+    {
+        delete tp;
+    }
+
+    tp = nullptr;
+    tp_owned = false;
+}

common/tool/action_toolbar.cpp

@@ -477,13 +477,17 @@ void ACTION_TOOLBAR::onToolEvent( wxAuiToolBarEvent& aEvent )
 
     bool handled = false;
 
-    if( m_toolManager && type == wxEVT_COMMAND_TOOL_CLICKED  && id >= TOOL_ACTION::GetBaseUIId() )
+    if( m_toolManager && type == wxEVT_COMMAND_TOOL_CLICKED )
     {
         const auto actionIt = m_toolActions.find( id );
+        const auto cancelIt = m_toolCancellable.find( id );
+
+        // Determine if the tool is actually cancellable
+        bool isCancellable = ( cancelIt != m_toolCancellable.end() ) ? cancelIt->second : false;
 
         // The toolbar item is toggled before the event is sent, so we check for it not being
         // toggled to see if it was toggled originally
-        if( m_toolCancellable[id] && !GetToolToggled( id ) )
+        if( isCancellable && !GetToolToggled( id ) )
         {
             // Send a cancel event
             m_toolManager->CancelTool();

common/tool/actions.cpp

@@ -799,6 +799,12 @@ TOOL_ACTION ACTIONS::unpinLibrary( TOOL_ACTION_ARGS()
         .FriendlyName( _( "Unpin Library" ) )
         .Tooltip( _( "No longer keep the library at the top of the list" ) ) );
 
+TOOL_ACTION ACTIONS::showLibraryTable( TOOL_ACTION_ARGS()
+        .Name( "common.Control.showLibraryTable" )
+        .Scope( AS_GLOBAL )
+        .FriendlyName( _( "Library Table" ) )
+        .Icon( BITMAPS::table ) );
+
 TOOL_ACTION ACTIONS::showLibraryTree( TOOL_ACTION_ARGS()
         .Name( "common.Control.showLibraryTree" )
         .Scope( AS_GLOBAL )

common/tool/common_tools.cpp

@@ -612,6 +612,7 @@ int COMMON_TOOLS::GridProperties( const TOOL_EVENT& aEvent )
     case FRAME_SCH_SYMBOL_EDITOR: showGridPrefs( _( "Symbol Editor" ) );        break;
     case FRAME_PCB_EDITOR:        showGridPrefs( _( "PCB Editor" ) );           break;
     case FRAME_FOOTPRINT_EDITOR:  showGridPrefs( _( "Footprint Editor" ) );     break;
+    case FRAME_FOOTPRINT_VIEWER:  showGridPrefs( _( "Footprint Browser" ) );    break;
     case FRAME_PL_EDITOR:         showGridPrefs( _( "Drawing Sheet Editor" ) ); break;
     case FRAME_GERBER:            showGridPrefs( _( "Gerber Viewer" ) );        break;
     default:                      wxFAIL_MSG( "Unknown frame: " + GetName() );  break;

common/tool/construction_manager.cpp

@@ -23,12 +23,21 @@
 
 #include "tool/construction_manager.h"
 
+#include <algorithm>
 #include <chrono>
+#include <cmath>
+#include <limits>
+#include <numeric>
+#include <utility>
 
 #include <wx/timer.h>
+#include <wx/debug.h>
+#include <wx/log.h>
 
 #include <advanced_config.h>
+#include <math/util.h>
 #include <hash.h>
+#include <trace_helpers.h>
 
 
 /**
@@ -329,9 +338,9 @@ void CONSTRUCTION_MANAGER::acceptConstructionItems( std::unique_ptr<PENDING_BATC
         {
             for( const CONSTRUCTION_ITEM& item : batch )
             {
-                for( const KIGFX::CONSTRUCTION_GEOM::DRAWABLE& drawable : item.Constructions )
+                for( const CONSTRUCTION_ITEM::DRAWABLE_ENTRY& drawable : item.Constructions )
                 {
-                    geom.AddDrawable( drawable, aIsPersistent );
+                    geom.AddDrawable( drawable.Drawable, aIsPersistent, drawable.LineWidth );
                 }
             }
         }
@@ -383,16 +392,111 @@ bool CONSTRUCTION_MANAGER::HasActiveConstruction() const
 
 
 SNAP_LINE_MANAGER::SNAP_LINE_MANAGER( CONSTRUCTION_VIEW_HANDLER& aViewHandler ) :
-        m_viewHandler( aViewHandler )
+        m_viewHandler( aViewHandler ), m_snapManager( static_cast<SNAP_MANAGER*>( &aViewHandler ) )
 {
+    wxASSERT( m_snapManager );
+    SetDirections( { VECTOR2I( 1, 0 ), VECTOR2I( 0, 1 ) } );
+}
+
+
+static VECTOR2I normalizeDirection( const VECTOR2I& aDir )
+{
+    if( aDir.x == 0 && aDir.y == 0 )
+        return VECTOR2I( 0, 0 );
+
+    int dx = aDir.x;
+    int dy = aDir.y;
+
+    int gcd = std::gcd( std::abs( dx ), std::abs( dy ) );
+
+    if( gcd > 0 )
+    {
+        dx /= gcd;
+        dy /= gcd;
+    }
+
+    if( dx < 0 || ( dx == 0 && dy < 0 ) )
+    {
+        dx = -dx;
+        dy = -dy;
+    }
+
+    return VECTOR2I( dx, dy );
+}
+
+
+static std::optional<int> findDirectionIndex( const std::vector<VECTOR2I>& aDirections,
+                                              const VECTOR2I&               aDelta )
+{
+    VECTOR2I normalized = normalizeDirection( aDelta );
+
+    if( normalized.x == 0 && normalized.y == 0 )
+        return std::nullopt;
+
+    for( size_t i = 0; i < aDirections.size(); ++i )
+    {
+        if( aDirections[i] == normalized )
+            return static_cast<int>( i );
+    }
+
+    return std::nullopt;
+}
+
+
+void SNAP_LINE_MANAGER::SetDirections( const std::vector<VECTOR2I>& aDirections )
+{
+    std::vector<VECTOR2I> uniqueDirections;
+    uniqueDirections.reserve( aDirections.size() );
+
+    for( const VECTOR2I& direction : aDirections )
+    {
+        VECTOR2I normalized = normalizeDirection( direction );
+
+        if( normalized.x == 0 && normalized.y == 0 )
+            continue;
+
+        if( std::find( uniqueDirections.begin(), uniqueDirections.end(), normalized )
+                == uniqueDirections.end() )
+        {
+            uniqueDirections.push_back( normalized );
+        }
+    }
+
+    if( uniqueDirections != m_directions )
+    {
+        m_directions = std::move( uniqueDirections );
+        m_activeDirection.reset();
+
+        if( m_snapLineOrigin && m_snapLineEnd )
+        {
+            if( !findDirectionIndex( m_directions, *m_snapLineEnd - *m_snapLineOrigin ) )
+                m_snapLineEnd.reset();
+        }
+
+        if( m_directions.empty() )
+        {
+            ClearSnapLine();
+            return;
+        }
+
+        notifyGuideChange();
+    }
 }
 
 
 void SNAP_LINE_MANAGER::SetSnapLineOrigin( const VECTOR2I& aOrigin )
 {
-    // Setting the origin clears the snap line as the end point is no longer valid
-    ClearSnapLine();
+    if( m_snapLineOrigin && *m_snapLineOrigin == aOrigin && !m_snapLineEnd )
+    {
+        notifyGuideChange();
+        return;
+    }
+
     m_snapLineOrigin = aOrigin;
+    m_snapLineEnd.reset();
+    m_activeDirection.reset();
+    m_viewHandler.GetViewItem().ClearSnapLine();
+    notifyGuideChange();
 }
 
 
@@ -402,12 +506,17 @@ void SNAP_LINE_MANAGER::SetSnapLineEnd( const OPT_VECTOR2I& aSnapEnd )
     {
         m_snapLineEnd = aSnapEnd;
 
+        if( m_snapLineEnd )
+            m_activeDirection = findDirectionIndex( m_directions, *m_snapLineEnd - *m_snapLineOrigin );
+        else
+            m_activeDirection.reset();
+
         if( m_snapLineEnd )
             m_viewHandler.GetViewItem().SetSnapLine( SEG{ *m_snapLineOrigin, *m_snapLineEnd } );
         else
             m_viewHandler.GetViewItem().ClearSnapLine();
 
-        m_viewHandler.updateView();
+        notifyGuideChange();
     }
 }
 
@@ -416,8 +525,9 @@ void SNAP_LINE_MANAGER::ClearSnapLine()
 {
     m_snapLineOrigin.reset();
     m_snapLineEnd.reset();
+    m_activeDirection.reset();
     m_viewHandler.GetViewItem().ClearSnapLine();
-    m_viewHandler.updateView();
+    notifyGuideChange();
 }
 
 
@@ -425,7 +535,7 @@ void SNAP_LINE_MANAGER::SetSnappedAnchor( const VECTOR2I& aAnchorPos )
 {
     if( m_snapLineOrigin.has_value() )
     {
-        if( aAnchorPos.x == m_snapLineOrigin->x || aAnchorPos.y == m_snapLineOrigin->y )
+        if( findDirectionIndex( m_directions, aAnchorPos - *m_snapLineOrigin ) )
         {
             SetSnapLineEnd( aAnchorPos );
         }
@@ -444,93 +554,206 @@ void SNAP_LINE_MANAGER::SetSnappedAnchor( const VECTOR2I& aAnchorPos )
 }
 
 
-/**
- * Check if the cursor has moved far enough away from the snap line origin to escape snapping
- * in the X direction.
- *
- * This is defined as within aEscapeRange of the snap line origin, and within aLongRangeEscapeAngle
- * of the vertical line passing through the snap line origin.
- */
-static bool pointHasEscapedSnapLineX( const VECTOR2I& aCursor, const VECTOR2I& aSnapLineOrigin,
-                                      int aEscapeRange, EDA_ANGLE aLongRangeEscapeAngle )
-{
-    if( std::abs( aCursor.x - aSnapLineOrigin.x ) < aEscapeRange )
-    {
-        return false;
-    }
-    EDA_ANGLE angle = EDA_ANGLE( aCursor - aSnapLineOrigin ) + EDA_ANGLE( 90, DEGREES_T );
-    return std::abs( angle.Normalize90() ) > aLongRangeEscapeAngle;
-}
-
-
-/**
- * As above, but for the Y direction.
- */
-static bool pointHasEscapedSnapLineY( const VECTOR2I& aCursor, const VECTOR2I& aSnapLineOrigin,
-                                      int aEscapeRange, EDA_ANGLE aLongRangeEscapeAngle )
-{
-    if( std::abs( aCursor.y - aSnapLineOrigin.y ) < aEscapeRange )
-    {
-        return false;
-    }
-    EDA_ANGLE angle = EDA_ANGLE( aCursor - aSnapLineOrigin );
-    return std::abs( angle.Normalize90() ) > aLongRangeEscapeAngle;
-}
-
-
 OPT_VECTOR2I SNAP_LINE_MANAGER::GetNearestSnapLinePoint( const VECTOR2I&    aCursor,
                                                          const VECTOR2I&    aNearestGrid,
                                                          std::optional<int> aDistToNearest,
-                                                         int                aSnapRange ) const
+                                                         int                aSnapRange,
+                                                         const VECTOR2D&    aGridSize,
+                                                         const VECTOR2I&    aGridOrigin ) const
 {
-    // return std::nullopt;
-    if( m_snapLineOrigin )
+    wxLogTrace( traceSnap, "GetNearestSnapLinePoint: cursor=(%d, %d), nearestGrid=(%d, %d), distToNearest=%s, snapRange=%d",
+                aCursor.x, aCursor.y, aNearestGrid.x, aNearestGrid.y,
+                aDistToNearest ? wxString::Format( "%d", *aDistToNearest ) : wxString( "none" ), aSnapRange );
+
+    if( !m_snapLineOrigin || m_directions.empty() )
     {
-        bool     snapLine = false;
-        VECTOR2I bestSnapPoint = aNearestGrid;
+        wxLogTrace( traceSnap, "  No snap line origin or no directions, returning nullopt" );
+        return std::nullopt;
+    }
 
-        // If there's no snap anchor, or it's too far away, prefer the grid
-        const bool gridBetterThanNearest = !aDistToNearest || *aDistToNearest > aSnapRange;
+    const bool gridBetterThanNearest = !aDistToNearest || *aDistToNearest > aSnapRange;
+    const bool gridActive = aGridSize.x > 0 && aGridSize.y > 0;
 
-        // The escape range is how far you go before the snap line is de-activated.
-        // Make this a bit more forgiving than the snap range, as you can easily cancel
-        // deliberately with a mouse move.
-        // These are both a bit arbitrary, and can be adjusted as preferred
-        const int       escapeRange = 2 * aSnapRange;
-        const EDA_ANGLE longRangeEscapeAngle( 4, DEGREES_T );
+    wxLogTrace( traceSnap, "  snapLineOrigin=(%d, %d), directions count=%zu, gridBetterThanNearest=%d, gridActive=%d",
+                m_snapLineOrigin->x, m_snapLineOrigin->y, m_directions.size(), gridBetterThanNearest, gridActive );
 
-        const bool escapedX = pointHasEscapedSnapLineX( aCursor, *m_snapLineOrigin, escapeRange,
-                                                        longRangeEscapeAngle );
-        const bool escapedY = pointHasEscapedSnapLineY( aCursor, *m_snapLineOrigin, escapeRange,
-                                                        longRangeEscapeAngle );
+    if( !gridBetterThanNearest )
+    {
+        wxLogTrace( traceSnap, "  Grid not better than nearest, returning nullopt" );
+        return std::nullopt;
+    }
 
-        /// Allows de-snapping from the line if you are closer to another snap point
-        /// Or if you have moved far enough away from the line
-        if( !escapedX && gridBetterThanNearest )
+    const int       escapeRange = 2 * aSnapRange;
+    const EDA_ANGLE longRangeEscapeAngle( 4, DEGREES_T );
+
+    wxLogTrace( traceSnap, "  escapeRange=%d, longRangeEscapeAngle=%.1f deg",
+                escapeRange, longRangeEscapeAngle.AsDegrees() );
+
+    const VECTOR2D origin( *m_snapLineOrigin );
+    const VECTOR2D cursor( aCursor );
+    const VECTOR2D delta = cursor - origin;
+
+    double                        bestPerpDistance = std::numeric_limits<double>::max();
+    std::optional<VECTOR2I>       bestSnapPoint;
+
+    for( size_t ii = 0; ii < m_directions.size(); ++ii )
+    {
+        const VECTOR2I& direction = m_directions[ii];
+        VECTOR2D dirVector( direction );
+        double   dirLength = dirVector.EuclideanNorm();
+
+        if( dirLength == 0.0 )
         {
-            bestSnapPoint.x = m_snapLineOrigin->x;
-            snapLine = true;
+            wxLogTrace( traceSnap, "    Direction %zu: zero length, skipping", ii );
+            continue;
         }
 
-        if( !escapedY && gridBetterThanNearest )
+        VECTOR2D dirUnit = dirVector / dirLength;
+
+        double    distanceAlong = delta.Dot( dirUnit );
+        VECTOR2D  projection = origin + dirUnit * distanceAlong;
+        VECTOR2D  offset = delta - dirUnit * distanceAlong;
+        double    perpDistance = offset.EuclideanNorm();
+
+        wxLogTrace( traceSnap, "    Direction %zu: dir=(%d, %d), perpDist=%.1f, distAlong=%.1f",
+                    ii, direction.x, direction.y, perpDistance, distanceAlong );
+
+        if( perpDistance > aSnapRange )
         {
-            bestSnapPoint.y = m_snapLineOrigin->y;
-            snapLine = true;
+            wxLogTrace( traceSnap, "      perpDistance > snapRange, skipping" );
+            continue;
         }
 
-        if( snapLine )
+        bool escaped = false;
+
+        if( perpDistance >= escapeRange )
         {
-            return bestSnapPoint;
+            EDA_ANGLE deltaAngle( delta );
+            EDA_ANGLE directionAngle( dirVector );
+            double    angleDiff = ( deltaAngle - directionAngle ).Normalize180().AsDegrees();
+
+            wxLogTrace( traceSnap, "      In escape range: deltaAngle=%.1f, dirAngle=%.1f, angleDiff=%.1f",
+                        deltaAngle.AsDegrees(), directionAngle.AsDegrees(), angleDiff );
+
+            if( std::abs( angleDiff ) > longRangeEscapeAngle.AsDegrees() )
+            {
+                escaped = true;
+                wxLogTrace( traceSnap, "      ESCAPED (angle diff too large)" );
+            }
+        }
+
+        if( escaped )
+        {
+            wxLogTrace( traceSnap, "      Not updating (escaped)" );
+            continue;
+        }
+
+        // Now snap the projection to the grid if the grid is active
+        VECTOR2D snapPoint = projection;
+
+        if( gridActive )
+        {
+            // For horizontal/vertical lines, snap to grid intersections
+            if( direction.x == 0 && direction.y != 0 )
+            {
+                // Vertical line: keep origin X, snap Y to grid
+                snapPoint.x = origin.x;
+                snapPoint.y = aNearestGrid.y;
+                wxLogTrace( traceSnap, "      Vertical line: snapping to grid Y, snapPoint=(%.1f, %.1f)",
+                            snapPoint.x, snapPoint.y );
+            }
+            else if( direction.y == 0 && direction.x != 0 )
+            {
+                // Horizontal line: snap X to grid, keep origin Y
+                snapPoint.x = aNearestGrid.x;
+                snapPoint.y = origin.y;
+                wxLogTrace( traceSnap, "      Horizontal line: snapping to grid X, snapPoint=(%.1f, %.1f)",
+                            snapPoint.x, snapPoint.y );
+            }
+            else
+            {
+                // Diagonal line: find nearest grid intersection along the line
+                VECTOR2D gridOriginD( aGridOrigin );
+                VECTOR2D relProjection = projection - gridOriginD;
+
+                // Find nearby grid points (check 3x3 grid around projection)
+                double   bestGridScore = std::numeric_limits<double>::max();
+                VECTOR2D bestGridPoint = projection;
+
+                for( int dx = -1; dx <= 1; ++dx )
+                {
+                    for( int dy = -1; dy <= 1; ++dy )
+                    {
+                        double gridX = std::round( relProjection.x / aGridSize.x ) * aGridSize.x + dx * aGridSize.x;
+                        double gridY = std::round( relProjection.y / aGridSize.y ) * aGridSize.y + dy * aGridSize.y;
+                        VECTOR2D gridPt( gridX + gridOriginD.x, gridY + gridOriginD.y );
+
+                        // Calculate perpendicular distance from grid point to construction line
+                        VECTOR2D gridDelta = gridPt - origin;
+                        double   gridDistAlong = gridDelta.Dot( dirUnit );
+                        VECTOR2D gridProjection = origin + dirUnit * gridDistAlong;
+                        double   gridPerpDist = ( gridPt - gridProjection ).EuclideanNorm();
+
+                        // Also consider distance from cursor
+                        double distFromCursor = ( gridPt - cursor ).EuclideanNorm();
+
+                        // Prefer grid points that are close to the line and close to cursor
+                        double score = gridPerpDist + distFromCursor * 0.1;
+
+                        if( score < bestGridScore )
+                        {
+                        bestGridScore = score;
+                            bestGridPoint = gridPt;
+                        }
+                    }
+                }
+
+                snapPoint = bestGridPoint;
+                wxLogTrace( traceSnap, "      Diagonal line: snapping to grid intersection, snapPoint=(%.1f, %.1f)",
+                            snapPoint.x, snapPoint.y );
+            }
+        }
+        else
+        {
+            wxLogTrace( traceSnap, "      Grid not active, using projection" );
+        }
+
+        if( perpDistance < bestPerpDistance )
+        {
+            bestPerpDistance = perpDistance;
+            bestSnapPoint = VECTOR2I( KiROUND( snapPoint.x ), KiROUND( snapPoint.y ) );
+            wxLogTrace( traceSnap, "      NEW BEST: perpDist=%.1f, snapPoint=(%d, %d)",
+                        bestPerpDistance, bestSnapPoint->x, bestSnapPoint->y );
+        }
+        else
+        {
+            wxLogTrace( traceSnap, "      Not updating (perpDist=%.1f >= bestPerp=%.1f)",
+                        perpDistance, bestPerpDistance );
         }
     }
 
+    if( bestSnapPoint )
+    {
+        wxLogTrace( traceSnap, "  RETURNING bestSnapPoint=(%d, %d)", bestSnapPoint->x, bestSnapPoint->y );
+        return *bestSnapPoint;
+    }
+
+    wxLogTrace( traceSnap, "  RETURNING nullopt (no valid snap found)" );
     return std::nullopt;
 }
 
 
+void SNAP_LINE_MANAGER::notifyGuideChange()
+{
+    if( m_snapManager )
+        m_snapManager->UpdateSnapGuides();
+}
+
+
 SNAP_MANAGER::SNAP_MANAGER( KIGFX::CONSTRUCTION_GEOM& aHelper ) :
         CONSTRUCTION_VIEW_HANDLER( aHelper ), m_snapLineManager( *this ),
-        m_constructionManager( *this )
+        m_constructionManager( *this ), m_snapGuideColor( KIGFX::COLOR4D::WHITE ),
+        m_snapGuideHighlightColor( KIGFX::COLOR4D::WHITE )
 {
 }
 
@@ -540,13 +763,67 @@ void SNAP_MANAGER::updateView()
     if( m_updateCallback )
     {
         bool showAnything = m_constructionManager.HasActiveConstruction()
-                            || m_snapLineManager.HasCompleteSnapLine();
+                            || m_snapLineManager.HasCompleteSnapLine()
+                            || ( m_snapLineManager.GetSnapLineOrigin()
+                                 && !m_snapLineManager.GetDirections().empty() );
 
         m_updateCallback( showAnything );
     }
 }
 
 
+void SNAP_MANAGER::SetSnapGuideColors( const KIGFX::COLOR4D& aBase, const KIGFX::COLOR4D& aHighlight )
+{
+    m_snapGuideColor = aBase;
+    m_snapGuideHighlightColor = aHighlight;
+    UpdateSnapGuides();
+}
+
+
+void SNAP_MANAGER::UpdateSnapGuides()
+{
+    std::vector<KIGFX::CONSTRUCTION_GEOM::SNAP_GUIDE> guides;
+
+    const OPT_VECTOR2I& origin = m_snapLineManager.GetSnapLineOrigin();
+    const std::vector<VECTOR2I>& directions = m_snapLineManager.GetDirections();
+
+    if( origin && !directions.empty() )
+    {
+        const std::optional<int> activeDirection = m_snapLineManager.GetActiveDirection();
+        const int                guideLength = 500000;
+
+        for( size_t ii = 0; ii < directions.size(); ++ii )
+        {
+            const VECTOR2I& direction = directions[ii];
+
+            if( direction.x == 0 && direction.y == 0 )
+                continue;
+
+            VECTOR2I scaled = direction * guideLength;
+
+            KIGFX::CONSTRUCTION_GEOM::SNAP_GUIDE guide;
+            guide.Segment = SEG( *origin - scaled, *origin + scaled );
+
+            if( activeDirection && *activeDirection == static_cast<int>( ii ) )
+            {
+                guide.LineWidth = 2;
+                guide.Color = m_snapGuideHighlightColor;
+            }
+            else
+            {
+                guide.LineWidth = 1;
+                guide.Color = m_snapGuideColor;
+            }
+
+            guides.push_back( guide );
+        }
+    }
+
+    GetViewItem().SetSnapGuides( std::move( guides ) );
+    updateView();
+}
+
+
 std::vector<CONSTRUCTION_MANAGER::CONSTRUCTION_ITEM_BATCH>
 SNAP_MANAGER::GetConstructionItems() const
 {
@@ -566,14 +843,44 @@ SNAP_MANAGER::GetConstructionItems() const
                         {},
                 } );
 
-        // One horizontal and one vertical infinite line from the snap point
-        snapPointItem.Constructions.push_back(
-                LINE{ *snapLineOrigin, *snapLineOrigin + VECTOR2I( 100000, 0 ) } );
-        snapPointItem.Constructions.push_back(
-                LINE{ *snapLineOrigin, *snapLineOrigin + VECTOR2I( 0, 100000 ) } );
+        const std::vector<VECTOR2I>& directions = m_snapLineManager.GetDirections();
+        const std::optional<int>     activeDirection = m_snapLineManager.GetActiveDirection();
 
-        batches.push_back( std::move( batch ) );
+        for( size_t ii = 0; ii < directions.size(); ++ii )
+        {
+            const VECTOR2I& direction = directions[ii];
+
+            VECTOR2I scaledDirection = direction * 100000;
+
+            CONSTRUCTION_MANAGER::CONSTRUCTION_ITEM::DRAWABLE_ENTRY entry;
+            entry.Drawable = LINE{ *snapLineOrigin, *snapLineOrigin + scaledDirection };
+            entry.LineWidth = ( activeDirection && *activeDirection == static_cast<int>( ii ) ) ? 2 : 1;
+
+            snapPointItem.Constructions.push_back( entry );
+        }
+
+        if( !snapPointItem.Constructions.empty() )
+            batches.push_back( std::move( batch ) );
     }
 
     return batches;
 }
+
+
+void CONSTRUCTION_MANAGER::Clear()
+{
+    std::lock_guard<std::mutex> lock( m_batchesMutex );
+
+    m_persistentConstructionBatch.reset();
+    m_temporaryConstructionBatches.clear();
+    m_involvedItems.clear();
+    CancelProposal();
+}
+
+
+void SNAP_MANAGER::Clear()
+{
+    m_snapLineManager.ClearSnapLine();
+    m_constructionManager.Clear();
+    UpdateSnapGuides();
+}

common/tool/edit_constraints.cpp

@@ -61,7 +61,7 @@ void EC_45DEGREE::Apply( EDIT_POINT& aHandle, const GRID_HELPER& aGrid )
     VECTOR2I lineVector( aHandle.GetPosition() - m_constrainer.GetPosition() );
     VECTOR2I newLineVector = GetVectorSnapped45( lineVector );
 
-    if( aHandle.GetGridConstraint() == SNAP_TO_GRID
+    if( aHandle.GetGridConstraint() == SNAP_TO_GRID && !aGrid.GetSnappedPoint()
             && ( newLineVector.x == 0 || newLineVector.y == 0 ) )
     {
         VECTOR2I snap = aGrid.AlignGrid( m_constrainer.GetPosition() + newLineVector );

common/tool/grid_helper.cpp

@@ -24,21 +24,23 @@
 #include "tool/grid_helper.h"
 
 #include <functional>
+#include <cmath>
+#include <limits>
 
 #include <advanced_config.h>
+#include <trace_helpers.h>
+#include <wx/log.h>
 #include <gal/graphics_abstraction_layer.h>
-#include <gal/painter.h>
 #include <math/util.h>      // for KiROUND
 #include <math/vector2d.h>
-#include <render_settings.h>
 #include <tool/tool_manager.h>
 #include <tool/tools_holder.h>
 #include <view/view.h>
 #include <settings/app_settings.h>
 
 
-GRID_HELPER::GRID_HELPER( TOOL_MANAGER* aToolMgr, int aConstructionLayer ) :
-        m_toolMgr( aToolMgr ), m_snapManager( m_constructionGeomPreview )
+GRID_HELPER::GRID_HELPER() :
+        m_toolMgr( nullptr ), m_snapManager( m_constructionGeomPreview )
 {
     m_maskTypes = ALL;
     m_enableSnap = true;
@@ -46,12 +48,23 @@ GRID_HELPER::GRID_HELPER( TOOL_MANAGER* aToolMgr, int aConstructionLayer ) :
     m_enableGrid = true;
     m_snapItem = std::nullopt;
 
-    KIGFX::VIEW*            view = m_toolMgr->GetView();
-    KIGFX::RENDER_SETTINGS* settings = view->GetPainter()->GetSettings();
+    m_manualGrid = VECTOR2D( 1, 1 );
+    m_manualVisibleGrid = VECTOR2D( 1, 1 );
+    m_manualOrigin = VECTOR2I( 0, 0 );
+    m_manualGridSnapping = true;
+}
 
-    const KIGFX::COLOR4D constructionColour = settings->GetLayerColor( aConstructionLayer );
-    m_constructionGeomPreview.SetPersistentColor( constructionColour );
-    m_constructionGeomPreview.SetColor( constructionColour.WithAlpha( 0.7 ) );
+
+GRID_HELPER::GRID_HELPER( TOOL_MANAGER* aToolMgr, int aConstructionLayer ) :
+        GRID_HELPER()
+{
+    m_toolMgr = aToolMgr;
+
+    if( !m_toolMgr )
+        return;
+
+    KIGFX::VIEW* view = m_toolMgr->GetView();
+    wxUnusedVar( aConstructionLayer );
 
     view->Add( &m_constructionGeomPreview );
     view->SetVisible( &m_constructionGeomPreview, false );
@@ -72,11 +85,20 @@ GRID_HELPER::GRID_HELPER( TOOL_MANAGER* aToolMgr, int aConstructionLayer ) :
 
                 m_toolMgr->GetToolHolder()->RefreshCanvas();
             } );
+
+    // Initialise manual values from view for compatibility
+    m_manualGrid = view->GetGAL()->GetGridSize();
+    m_manualVisibleGrid = view->GetGAL()->GetVisibleGridSize();
+    m_manualOrigin = VECTOR2I( view->GetGAL()->GetGridOrigin() );
+    m_manualGridSnapping = view->GetGAL()->GetGridSnapping();
 }
 
 
 GRID_HELPER::~GRID_HELPER()
 {
+    if( !m_toolMgr )
+        return;
+
     KIGFX::VIEW& view = *m_toolMgr->GetView();
     view.Remove( &m_constructionGeomPreview );
 
@@ -89,6 +111,9 @@ KIGFX::ANCHOR_DEBUG* GRID_HELPER::enableAndGetAnchorDebug()
 {
     static bool permitted = ADVANCED_CFG::GetCfg().m_EnableSnapAnchorsDebug;
 
+    if( !m_toolMgr )
+        return nullptr;
+
     if( permitted && !m_anchorDebug )
     {
         KIGFX::VIEW& view = *m_toolMgr->GetView();
@@ -103,12 +128,223 @@ KIGFX::ANCHOR_DEBUG* GRID_HELPER::enableAndGetAnchorDebug()
 
 void GRID_HELPER::showConstructionGeometry( bool aShow )
 {
-    m_toolMgr->GetView()->SetVisible( &m_constructionGeomPreview, aShow );
+    if( m_toolMgr )
+        m_toolMgr->GetView()->SetVisible( &m_constructionGeomPreview, aShow );
+}
+
+
+void GRID_HELPER::SetSnapLineDirections( const std::vector<VECTOR2I>& aDirections )
+{
+    m_snapManager.GetSnapLineManager().SetDirections( aDirections );
+}
+
+
+void GRID_HELPER::SetSnapLineOrigin( const VECTOR2I& aOrigin )
+{
+    m_snapManager.GetSnapLineManager().SetSnapLineOrigin( aOrigin );
+}
+
+
+void GRID_HELPER::ClearSnapLine()
+{
+    m_snapManager.GetSnapLineManager().ClearSnapLine();
+}
+
+
+std::optional<VECTOR2I> GRID_HELPER::SnapToConstructionLines( const VECTOR2I& aPoint,
+                                                              const VECTOR2I& aNearestGrid,
+                                                              const VECTOR2D& aGrid,
+                                                              double aSnapRange ) const
+{
+    const SNAP_LINE_MANAGER& snapLineManager = m_snapManager.GetSnapLineManager();
+    const OPT_VECTOR2I&      snapOrigin = snapLineManager.GetSnapLineOrigin();
+
+    wxLogTrace( traceSnap, "SnapToConstructionLines: aPoint=(%d, %d), nearestGrid=(%d, %d), snapRange=%.1f",
+                aPoint.x, aPoint.y, aNearestGrid.x, aNearestGrid.y, aSnapRange );
+
+    if( !snapOrigin || snapLineManager.GetDirections().empty() )
+    {
+        wxLogTrace( traceSnap, "  No snap origin or no directions, returning nullopt" );
+        return std::nullopt;
+    }
+
+    const VECTOR2I& origin = *snapOrigin;
+
+    wxLogTrace( traceSnap, "  snapOrigin=(%d, %d), directions count=%zu",
+                origin.x, origin.y, snapLineManager.GetDirections().size() );
+
+    const std::vector<VECTOR2I>& directions = snapLineManager.GetDirections();
+    const std::optional<int>     activeDirection = snapLineManager.GetActiveDirection();
+
+    if( activeDirection )
+        wxLogTrace( traceSnap, "  activeDirection=%d", *activeDirection );
+
+    const VECTOR2D originVec( origin );
+    const VECTOR2D cursorVec( aPoint );
+    const VECTOR2D delta = cursorVec - originVec;
+
+    std::optional<VECTOR2I> bestPoint;
+    double                  bestPerp = std::numeric_limits<double>::max();
+    double                  bestDistance = std::numeric_limits<double>::max();
+
+    for( size_t ii = 0; ii < directions.size(); ++ii )
+    {
+        const VECTOR2I& dir = directions[ii];
+        VECTOR2D        dirVector( dir );
+        double          dirLength = dirVector.EuclideanNorm();
+
+        if( dirLength == 0.0 )
+        {
+            wxLogTrace( traceSnap, "    Direction %zu: zero length, skipping", ii );
+            continue;
+        }
+
+        VECTOR2D dirUnit = dirVector / dirLength;
+
+        double    distanceAlong = delta.Dot( dirUnit );
+        VECTOR2D  projection = originVec + dirUnit * distanceAlong;
+        VECTOR2D  offset = delta - dirUnit * distanceAlong;
+        double    perpDistance = offset.EuclideanNorm();
+
+        double snapThreshold = aSnapRange;
+
+        if( activeDirection && *activeDirection == static_cast<int>( ii ) )
+        {
+            snapThreshold *= 1.5;
+            wxLogTrace( traceSnap, "    Direction %zu: ACTIVE, increased snapThreshold=%.1f", ii, snapThreshold );
+        }
+
+        wxLogTrace( traceSnap, "    Direction %zu: dir=(%d, %d), perpDist=%.1f, threshold=%.1f",
+                    ii, dir.x, dir.y, perpDistance, snapThreshold );
+
+        if( perpDistance > snapThreshold )
+        {
+            wxLogTrace( traceSnap, "      perpDistance > threshold, skipping" );
+            continue;
+        }
+
+        VECTOR2D candidate = projection;
+
+        if( canUseGrid() )
+        {
+            if( dir.x == 0 && dir.y != 0 )
+            {
+                // Vertical construction line: snap to grid intersection
+                candidate.x = origin.x;
+                candidate.y = aNearestGrid.y;
+                wxLogTrace( traceSnap, "      Vertical snap: candidate=(%d, %d)",
+                            (int)candidate.x, (int)candidate.y );
+            }
+            else if( dir.y == 0 && dir.x != 0 )
+            {
+                // Horizontal construction line: snap to grid intersection
+                candidate.x = aNearestGrid.x;
+                candidate.y = origin.y;
+                wxLogTrace( traceSnap, "      Horizontal snap: candidate=(%d, %d)",
+                            (int)candidate.x, (int)candidate.y );
+            }
+            else
+            {
+                // Diagonal construction line: find nearest grid intersection along the line
+                // We need to find grid points near the projection point and pick the closest
+                // one that lies on the construction line
+
+                // Get the grid origin for proper alignment
+                VECTOR2D gridOrigin( GetOrigin() );
+
+                // Calculate the projection point relative to grid
+                VECTOR2D relProjection = projection - gridOrigin;
+
+                // Find nearby grid points (check 9 points in a 3x3 grid around the projection)
+                std::vector<VECTOR2D> gridPoints;
+                for( int dx = -1; dx <= 1; ++dx )
+                {
+                    for( int dy = -1; dy <= 1; ++dy )
+                    {
+                        double gridX = std::round( relProjection.x / aGrid.x ) * aGrid.x + dx * aGrid.x;
+                        double gridY = std::round( relProjection.y / aGrid.y ) * aGrid.y + dy * aGrid.y;
+                        gridPoints.push_back( VECTOR2D( gridX + gridOrigin.x, gridY + gridOrigin.y ) );
+                    }
+                }
+
+                // Find the grid point closest to the construction line
+                double   bestGridDist = std::numeric_limits<double>::max();
+                VECTOR2D bestGridPt = projection;
+
+                for( const VECTOR2D& gridPt : gridPoints )
+                {
+                    // Calculate perpendicular distance from grid point to construction line
+                    VECTOR2D gridDelta = gridPt - originVec;
+                    double   gridDistAlong = gridDelta.Dot( dirUnit );
+                    VECTOR2D gridProjection = originVec + dirUnit * gridDistAlong;
+                    double   gridPerpDist = ( gridPt - gridProjection ).EuclideanNorm();
+
+                    // Also consider distance from cursor
+                    double distFromCursor = ( gridPt - cursorVec ).EuclideanNorm();
+
+                    // Prefer grid points that are close to the line and close to cursor
+                    double score = gridPerpDist + distFromCursor * 0.1;
+
+                    if( score < bestGridDist )
+                    {
+                        bestGridDist = score;
+                        bestGridPt = gridPt;
+                    }
+                }
+
+                candidate = bestGridPt;
+                wxLogTrace( traceSnap, "      Diagonal snap: candidate=(%.1f, %.1f), perpDist=%.1f",
+                            candidate.x, candidate.y, bestGridDist );
+            }
+        }
+        else
+        {
+            wxLogTrace( traceSnap, "      Grid disabled, using projection candidate=(%.1f, %.1f)",
+                        candidate.x, candidate.y );
+        }
+
+        VECTOR2I candidateInt( KiROUND( candidate.x ), KiROUND( candidate.y ) );
+
+        if( candidateInt == m_skipPoint )
+        {
+            wxLogTrace( traceSnap, "      candidateInt matches m_skipPoint, skipping" );
+            continue;
+        }
+
+        VECTOR2D candidateDelta( candidateInt.x - aPoint.x, candidateInt.y - aPoint.y );
+        double    candidateDistance = candidateDelta.EuclideanNorm();
+
+        wxLogTrace( traceSnap, "      candidateInt=(%d, %d), candidateDist=%.1f",
+                    candidateInt.x, candidateInt.y, candidateDistance );
+
+        if( perpDistance < bestPerp
+                || ( std::abs( perpDistance - bestPerp ) < 1e-9 && candidateDistance < bestDistance ) )
+        {
+            wxLogTrace( traceSnap, "      NEW BEST: perpDist=%.1f, candDist=%.1f", perpDistance, candidateDistance );
+            bestPerp = perpDistance;
+            bestDistance = candidateDistance;
+            bestPoint = candidateInt;
+        }
+    }
+
+    if( bestPoint )
+    {
+        wxLogTrace( traceSnap, "  RETURNING bestPoint=(%d, %d)", bestPoint->x, bestPoint->y );
+    }
+    else
+    {
+        wxLogTrace( traceSnap, "  RETURNING nullopt (no valid snap found)" );
+    }
+
+    return bestPoint;
 }
 
 
 void GRID_HELPER::updateSnapPoint( const TYPED_POINT2I& aPoint )
 {
+    if( !m_toolMgr )
+        return;
+
     m_viewSnapPoint.SetPosition( aPoint.m_point );
     m_viewSnapPoint.SetSnapTypes( aPoint.m_types );
 
@@ -121,23 +357,26 @@ void GRID_HELPER::updateSnapPoint( const TYPED_POINT2I& aPoint )
 
 VECTOR2I GRID_HELPER::GetGrid() const
 {
-    VECTOR2D size = m_toolMgr->GetView()->GetGAL()->GetGridSize();
-
+    VECTOR2D size = m_toolMgr ? m_toolMgr->GetView()->GetGAL()->GetGridSize() : m_manualGrid;
     return VECTOR2I( KiROUND( size.x ), KiROUND( size.y ) );
 }
 
 
 VECTOR2D GRID_HELPER::GetVisibleGrid() const
 {
-    return m_toolMgr->GetView()->GetGAL()->GetVisibleGridSize();
+    return m_toolMgr ? m_toolMgr->GetView()->GetGAL()->GetVisibleGridSize() : m_manualVisibleGrid;
 }
 
 
 VECTOR2I GRID_HELPER::GetOrigin() const
 {
-    VECTOR2D origin = m_toolMgr->GetView()->GetGAL()->GetGridOrigin();
+    if( m_toolMgr )
+    {
+        VECTOR2D origin = m_toolMgr->GetView()->GetGAL()->GetGridOrigin();
+        return VECTOR2I( origin );
+    }
 
-    return VECTOR2I( origin );
+    return m_manualOrigin;
 }
 
 
@@ -160,7 +399,7 @@ GRID_HELPER_GRIDS GRID_HELPER::GetSelectionGrid( const SELECTION& aSelection ) c
 
 VECTOR2D GRID_HELPER::GetGridSize( GRID_HELPER_GRIDS aGrid ) const
 {
-    return m_toolMgr->GetView()->GetGAL()->GetGridSize();
+    return m_toolMgr ? m_toolMgr->GetView()->GetGAL()->GetGridSize() : m_manualGrid;
 }
 
 
@@ -170,12 +409,14 @@ void GRID_HELPER::SetAuxAxes( bool aEnable, const VECTOR2I& aOrigin )
     {
         m_auxAxis = aOrigin;
         m_viewAxis.SetPosition( aOrigin );
-        m_toolMgr->GetView()->SetVisible( &m_viewAxis, true );
+        if( m_toolMgr )
+            m_toolMgr->GetView()->SetVisible( &m_viewAxis, true );
     }
     else
     {
         m_auxAxis = std::optional<VECTOR2I>();
-        m_toolMgr->GetView()->SetVisible( &m_viewAxis, false );
+        if( m_toolMgr )
+            m_toolMgr->GetView()->SetVisible( &m_viewAxis, false );
     }
 }
 
@@ -230,7 +471,8 @@ VECTOR2I GRID_HELPER::Align( const VECTOR2I& aPoint, const VECTOR2D& aGrid,
 
 bool GRID_HELPER::canUseGrid() const
 {
-    return m_enableGrid && m_toolMgr->GetView()->GetGAL()->GetGridSnapping();
+    return m_enableGrid && ( m_toolMgr ? m_toolMgr->GetView()->GetGAL()->GetGridSnapping()
+                                       : m_manualGridSnapping );
 }
 
 

common/tool/grid_menu.cpp

@@ -59,12 +59,12 @@ void GRID_MENU::UpdateTitle()
 
 void GRID_MENU::update()
 {
-    APP_SETTINGS_BASE* settings = m_parent->config();
-    unsigned int       current = settings->m_Window.grid.last_size_idx + ID_POPUP_GRID_START;
-    wxArrayString      gridsList;
-    int                i = ID_POPUP_GRID_START;
+    WINDOW_SETTINGS* cfg = m_parent->GetWindowSettings( m_parent->config() );
+    unsigned int     current = cfg->grid.last_size_idx + ID_POPUP_GRID_START;
+    wxArrayString    gridsList;
+    int              i = ID_POPUP_GRID_START;
 
-    GRID_MENU::BuildChoiceList( &gridsList, settings, m_parent );
+    GRID_MENU::BuildChoiceList( &gridsList, cfg, m_parent );
 
     while( GetMenuItemCount() > 0 )
         Delete( FindItemByPosition( 0 ) );
@@ -80,8 +80,7 @@ void GRID_MENU::update()
 }
 
 
-void GRID_MENU::BuildChoiceList( wxArrayString* aGridsList, APP_SETTINGS_BASE* aCfg,
-                                 EDA_DRAW_FRAME* aParent )
+void GRID_MENU::BuildChoiceList( wxArrayString* aGridsList, WINDOW_SETTINGS* aCfg, EDA_DRAW_FRAME* aParent )
 {
     wxString     msg;
     EDA_IU_SCALE scale = aParent->GetIuScale();
@@ -90,7 +89,7 @@ void GRID_MENU::BuildChoiceList( wxArrayString* aGridsList, APP_SETTINGS_BASE* a
 
     aParent->GetUnitPair( primaryUnit, secondaryUnit );
 
-    for( GRID& gridSize : aCfg->m_Window.grid.grids )
+    for( GRID& gridSize : aCfg->grid.grids )
     {
         wxString name;
 

common/tool/point_editor_behavior.cpp

@@ -31,6 +31,9 @@ void POLYGON_POINT_EDIT_BEHAVIOR::BuildForPolyOutline( EDIT_POINTS&          aPo
 {
     const int cornersCount = aOutline.TotalVertices();
 
+    if( cornersCount == 0 )
+        return;
+
     for( auto iterator = aOutline.CIterateWithHoles(); iterator; iterator++ )
     {
         aPoints.AddPoint( *iterator );

common/tool/tool_dispatcher.cpp

@@ -425,6 +425,28 @@ std::optional<TOOL_EVENT> TOOL_DISPATCHER::GetToolEvent( wxKeyEvent* aKeyEvent,
 }
 
 
+void TOOL_DISPATCHER::flushPendingClicks()
+{
+    // When an escape key event arrives, keyboard events can be processed before mouse button
+    // events due to wxWidgets event queue ordering. If a mouse button was pressed and has since
+    // been released (detected via polling), we need to process that click before handling the
+    // escape to maintain proper event ordering.
+    for( BUTTON_STATE* st : m_buttons )
+    {
+        if( st->pressed && !st->GetState() )
+        {
+            st->pressed = false;
+
+            TOOL_EVENT clickEvt( TC_MOUSE, TA_MOUSE_CLICK, st->button );
+            clickEvt.SetMousePosition( st->downPosition );
+            m_toolMgr->ProcessEvent( clickEvt );
+
+            st->dragging = false;
+        }
+    }
+}
+
+
 void TOOL_DISPATCHER::DispatchWxEvent( wxEvent& aEvent )
 {
     bool            motion = false;
@@ -543,6 +565,12 @@ void TOOL_DISPATCHER::DispatchWxEvent( wxEvent& aEvent )
 
         keyIsEscape = ( ke->GetKeyCode() == WXK_ESCAPE );
 
+        // When escape is pressed shortly after a mouse click, the keyboard event can be
+        // processed before the mouse button release event. Flush any pending clicks first
+        // to ensure proper event ordering.
+        if( keyIsEscape )
+            flushPendingClicks();
+
         if( KIUI::IsInputControlFocused( focus ) )
         {
             bool enabled = KIUI::IsInputControlEditable( focus );

common/trace_helpers.cpp

@@ -59,6 +59,8 @@ const wxChar* const traceUiProfile = wxT( "KICAD_UI_PROFILE" );
 const wxChar* const traceGit = wxT( "KICAD_GIT" );
 const wxChar* const traceEagleIo = wxT( "KICAD_EAGLE_IO" );
 const wxChar* const traceDesignBlocks = wxT( "KICAD_DESIGN_BLOCK" );
+const wxChar* const traceLibFieldTable = wxT( "KICAD_LIB_FIELD_TABLE" );
+const wxChar* const traceSnap = wxT( "KICAD_SNAP" );
 
 
 wxString dump( const wxArrayString& aArray )

common/view/wx_view_controls.cpp

@@ -214,6 +214,22 @@ void WX_VIEW_CONTROLS::onMotion( wxMouseEvent& aEvent )
     int      y = mouseRel.y;
     VECTOR2D mousePos( x, y );
 
+    // Clear keyboard cursor position flag when actual mouse motion is detected
+    // (i.e., not from cursor warping and position has changed)
+    if( !m_cursorWarped && m_settings.m_lastKeyboardCursorPositionValid )
+    {
+        VECTOR2I screenPos( x, y );
+        VECTOR2I keyboardScreenPos = m_view->ToScreen( m_settings.m_lastKeyboardCursorPosition );
+
+        // If mouse has moved to a different position than the keyboard cursor position,
+        // clear the keyboard position flag to allow mouse control
+        if( screenPos != keyboardScreenPos )
+        {
+            m_settings.m_lastKeyboardCursorPositionValid = false;
+            m_settings.m_lastKeyboardCursorPosition = { 0.0, 0.0 };
+        }
+    }
+
     // Automatic focus switching between SCH and PCB windows on canvas mouse motion
     if( m_settings.m_focusFollowSchPcb )
     {

common/widgets/app_progress_dialog.cpp

@@ -22,9 +22,9 @@
  */
 
 #include <wx/version.h>
+#include <wx/sizer.h>
 #include <widgets/app_progress_dialog.h>
 
-
 APP_PROGRESS_DIALOG::APP_PROGRESS_DIALOG( const wxString& aTitle, const wxString& aMessage,
                                           int aMaximum, wxWindow* aParent,
                                           bool aIndeterminateTaskBarStatus, int aStyle )
@@ -39,6 +39,11 @@ APP_PROGRESS_DIALOG::APP_PROGRESS_DIALOG( const wxString& aTitle, const wxString
     {
         m_appProgressIndicator.Pulse();
     }
+
+    Layout();
+
+    if( GetSizer() )
+        GetSizer()->Fit( this );
 }
 
 

common/widgets/color_swatch.cpp

@@ -208,11 +208,7 @@ void COLOR_SWATCH::setupEvents( bool aTriggerWithSingleClick )
 {
     if( dynamic_cast<DIALOG_SHIM*>( wxGetTopLevelParent( this ) ) )
     {
-        m_swatch->Bind( wxEVT_LEFT_DOWN,
-                        [this] ( wxMouseEvent& aEvt )
-                        {
-                            GetNewSwatchColor();
-                        } );
+        m_swatch->Bind( wxEVT_LEFT_DOWN, &COLOR_SWATCH::onMouseEvent, this );
     }
     else
     {
@@ -220,27 +216,15 @@ void COLOR_SWATCH::setupEvents( bool aTriggerWithSingleClick )
         m_swatch->Bind( wxEVT_LEFT_DOWN, &COLOR_SWATCH::rePostEvent, this );
 
         // bind the events that trigger the dialog
-        m_swatch->Bind( wxEVT_LEFT_DCLICK,
-                        [this] ( wxMouseEvent& aEvt )
-                        {
-                            GetNewSwatchColor();
-                        } );
+        m_swatch->Bind( wxEVT_LEFT_DCLICK, &COLOR_SWATCH::onMouseEvent, this );
 
         if( aTriggerWithSingleClick )
         {
-            m_swatch->Bind( wxEVT_LEFT_UP,
-                        [this] ( wxMouseEvent& aEvt )
-                        {
-                            GetNewSwatchColor();
-                        } );
+            m_swatch->Bind( wxEVT_LEFT_UP, &COLOR_SWATCH::onMouseEvent, this );
         }
     }
 
-    m_swatch->Bind( wxEVT_MIDDLE_DOWN,
-                    [this] ( wxMouseEvent& aEvt )
-                    {
-                        GetNewSwatchColor();
-                    } );
+    m_swatch->Bind( wxEVT_MIDDLE_DOWN, &COLOR_SWATCH::onMouseEvent, this );
 
     m_swatch->Bind( wxEVT_RIGHT_DOWN, &COLOR_SWATCH::rePostEvent, this );
 }
@@ -252,6 +236,12 @@ void COLOR_SWATCH::rePostEvent( wxEvent& aEvent )
 }
 
 
+void COLOR_SWATCH::onMouseEvent( wxEvent& )
+{
+    GetNewSwatchColor();
+}
+
+
 static void sendSwatchChangeEvent( COLOR_SWATCH& aSender )
 {
     wxCommandEvent changeEvt( COLOR_SWATCH_CHANGED, aSender.GetId() );

common/widgets/grid_striped_renderer.cpp

@@ -0,0 +1,47 @@
+
+#include <widgets/grid_striped_renderer.h>
+
+void STRIPED_CELL_RENDERER::Draw(wxGrid& grid, wxGridCellAttr& attr, wxDC& dc,
+                                  const wxRect& rect, int row, int col, bool isSelected)
+{
+    // First draw the striped background for empty cells
+    wxString cellValue = grid.GetCellValue(row, col);
+    if (cellValue.IsEmpty())
+    {
+        DrawStripedBackground(dc, rect, isSelected);
+    }
+
+    // Then draw the text content using the parent class
+    wxGridCellStringRenderer::Draw(grid, attr, dc, rect, row, col, isSelected);
+}
+
+void STRIPED_CELL_RENDERER::drawStripedBackground(wxDC& dc, const wxRect& rect, bool isSelected) const
+{
+    if (isSelected)
+    {
+        // For selected cells, use the selection color
+        dc.SetBrush(wxBrush(wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHT)));
+        dc.SetPen(*wxTRANSPARENT_PEN);
+        dc.DrawRectangle(rect);
+        return;
+    }
+
+    // Draw horizontal stripes
+    const int stripeHeight = 3;
+    wxColour color1 = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
+    wxColour color2(240, 240, 240); // Light gray
+
+    dc.SetPen(*wxTRANSPARENT_PEN);
+
+    bool useColor1 = true;
+    for (int y = rect.GetTop(); y < rect.GetBottom(); y += stripeHeight)
+    {
+        wxColour currentColor = useColor1 ? color1 : color2;
+        dc.SetBrush(wxBrush(currentColor));
+
+        int stripeBottom = wxMin(y + stripeHeight, rect.GetBottom());
+        dc.DrawRectangle(rect.GetLeft(), y, rect.GetWidth(), stripeBottom - y);
+
+        useColor1 = !useColor1;
+    }
+}

common/widgets/kistatusbar.cpp

@@ -193,7 +193,12 @@ void KISTATUSBAR::HideBackgroundProgressBar()
 
 void KISTATUSBAR::SetBackgroundProgress( int aAmount )
 {
-    m_backgroundProgressBar->SetValue( aAmount );
+    int value = m_backgroundProgressBar->GetRange();
+
+    if( value <= aAmount )
+        value = aAmount;
+
+    m_backgroundProgressBar->SetValue( value );
 }
 
 

common/widgets/mathplot.cpp

@@ -624,7 +624,11 @@ void mpFXY::Plot( wxDC& dc, mpWindow& w )
 #else
             int chunkSize = 100000;
 #endif
-            if( dc.GetPen().GetStyle() == wxPENSTYLE_DOT )
+            wxPenStyle penStyle = dc.GetPen().GetStyle();
+            bool isSolidPen = ( penStyle == wxPENSTYLE_SOLID
+                                || penStyle == wxPENSTYLE_TRANSPARENT );
+
+            if( !isSolidPen )
                 chunkSize /= 500;
 
             drawPoints.push_back( pointList[0] );   // push the first point in list
@@ -632,9 +636,11 @@ void mpFXY::Plot( wxDC& dc, mpWindow& w )
             for( size_t ii = 1; ii < pointList.size()-1; ii++ )
             {
                 // Skip intermediate points between the first point and the last point of the
-                // segment candidate
-                if( drawPoints.back().y == pointList[ii].y &&
-                    drawPoints.back().y == pointList[ii+1].y )
+                // segment candidate. This optimization merges horizontal line segments, which
+                // breaks non-solid pen styles by altering segment lengths.
+                if( isSolidPen
+                    && drawPoints.back().y == pointList[ii].y
+                    && drawPoints.back().y == pointList[ii+1].y )
                 {
                     continue;
                 }

common/widgets/properties_panel.cpp

@@ -300,6 +300,10 @@ void PROPERTIES_PANEL::rebuildProperties( const SELECTION& aSelection )
         wxPGChoices choices;
 
         extractValueAndWritability( aSelection, property, commonVal, writeable, choices );
+
+        if( choices.GetCount() > 0 )
+            pgProp->SetChoices( choices );
+
         pgProp->SetValue( commonVal );
         pgProp->Enable( writeable );
 

common/widgets/report_severity.cpp

@@ -0,0 +1,53 @@
+/*
+ * This program source code file is part of KiCad, a free EDA CAD application.
+ *
+ * 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 3 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 <http://www.gnu.org/licenses/>.
+ */
+
+#include <widgets/report_severity.h>
+#include <wx/intl.h>
+#include <i18n_utility.h>
+#include <vector>
+
+
+wxString formatSeverities( int aSeverities )
+{
+    wxString result;
+    std::vector<wxString> items;
+
+    if( aSeverities & RPT_SEVERITY_ERROR )
+        items.push_back( _( "Errors" ) );
+
+    if( aSeverities & RPT_SEVERITY_WARNING )
+        items.push_back( _( "Warnings" ) );
+
+    if( aSeverities & RPT_SEVERITY_EXCLUSION )
+        items.push_back( _( "Exclusions" ) );
+
+    if( items.empty() )
+        return _( "None" );
+
+    for( size_t i = 0; i < items.size(); i++ )
+    {
+        result += items[i];
+
+        if( i < items.size() - 1 )
+            result += wxS( ", " );
+    }
+
+    return result;
+}
+

common/widgets/widget_hotkey_list.cpp

@@ -513,16 +513,11 @@ bool WIDGET_HOTKEY_LIST::resolveKeyConflicts( TOOL_ACTION* aAction, long aKey )
 }
 
 
-WIDGET_HOTKEY_LIST::WIDGET_HOTKEY_LIST( wxWindow* aParent, HOTKEY_STORE& aHotkeyStore,
-                                        bool aReadOnly ) :
+WIDGET_HOTKEY_LIST::WIDGET_HOTKEY_LIST( wxWindow* aParent, HOTKEY_STORE& aHotkeyStore ) :
         wxTreeListCtrl( aParent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTL_SINGLE ),
-        m_hk_store( aHotkeyStore ),
-        m_readOnly( aReadOnly )
+        m_hk_store( aHotkeyStore )
 {
-    wxString command_header = _( "Command" );
-
-    if( !m_readOnly )
-        command_header << wxS( " " ) << _( "(double-click to edit)" );
+    wxString command_header = _( "Command (double-click to edit)" );
 
     AppendColumn( command_header, 450, wxALIGN_LEFT, wxCOL_RESIZABLE | wxCOL_SORTABLE );
     AppendColumn( _( "Hotkey" ), 120, wxALIGN_LEFT, wxCOL_RESIZABLE | wxCOL_SORTABLE );
@@ -568,13 +563,9 @@ WIDGET_HOTKEY_LIST::WIDGET_HOTKEY_LIST( wxWindow* aParent, HOTKEY_STORE& aHotkey
 
     GetDataView()->SetIndent( 10 );
 
-    if( !m_readOnly )
-    {
-        // The event only apply if the widget is in editable mode
-        Bind( wxEVT_TREELIST_ITEM_ACTIVATED, &WIDGET_HOTKEY_LIST::onActivated, this );
-        Bind( wxEVT_TREELIST_ITEM_CONTEXT_MENU, &WIDGET_HOTKEY_LIST::onContextMenu, this );
-        Bind( wxEVT_MENU, &WIDGET_HOTKEY_LIST::onMenu, this );
-    }
+    Bind( wxEVT_TREELIST_ITEM_ACTIVATED, &WIDGET_HOTKEY_LIST::onActivated, this );
+    Bind( wxEVT_TREELIST_ITEM_CONTEXT_MENU, &WIDGET_HOTKEY_LIST::onContextMenu, this );
+    Bind( wxEVT_MENU, &WIDGET_HOTKEY_LIST::onMenu, this );
 }
 
 

common/widgets/wx_infobar.cpp

@@ -30,6 +30,7 @@
 #include <wx/sizer.h>
 #include <wx/stattext.h>
 #include <wx/timer.h>
+#include <wx/dcclient.h>
 #include <eda_base_frame.h>
 
 #ifdef __WXMSW__
@@ -236,11 +237,28 @@ void WX_INFOBAR::onSize( wxSizeEvent& aEvent )
     if( !sizer )
         return;
 
-    wxSizerItem* text = sizer->GetItem( 1 );
+    // wx3.3 moved the sizer we previously wanted deeper into sizers...
+    // do we actually still need this for wx3.3?
+    #if wxCHECK_VERSION( 3, 3, 0 )
+    wxSizerItem* outerSizer = sizer->GetItem( (size_t) 0 );
+    wxSizerItem* textSizer = nullptr;
 
-    if( text )
+    if (outerSizer->IsSizer())
     {
-        if( auto textCtrl = dynamic_cast<wxStaticText*>( text->GetWindow() ) )
+        wxBoxSizer* innerSizer1 = dynamic_cast<wxBoxSizer*>( outerSizer->GetSizer() );
+        wxBoxSizer* innerSizer2 =
+                dynamic_cast<wxBoxSizer*>( innerSizer1->GetItem((size_t)0)->GetSizer() );
+
+        if( innerSizer2 )
+            textSizer = innerSizer2->GetItem( 1 );
+    }
+    #else
+    wxSizerItem* textSizer = sizer->GetItem( 1 );
+    #endif
+
+    if( textSizer )
+    {
+        if( wxStaticText* textCtrl = dynamic_cast<wxStaticText*>( textSizer->GetWindow() ) )
             textCtrl->SetLabelText( m_message );
     }
 
@@ -257,9 +275,9 @@ void WX_INFOBAR::onSize( wxSizeEvent& aEvent )
     if( barWidth != parentWidth )
         SetSize( parentWidth, GetSize().GetHeight() );
 
-    if( text )
+    if( textSizer )
     {
-        if( auto textCtrl = dynamic_cast<wxStaticText*>( text->GetWindow() ) )
+        if( wxStaticText* textCtrl = dynamic_cast<wxStaticText*>( textSizer->GetWindow() ) )
         {
             // Re-wrap the text (this is done automatically later but we need it now)
             // And count how many lines we need.  If we have embedded newlines, then
@@ -267,10 +285,18 @@ void WX_INFOBAR::onSize( wxSizeEvent& aEvent )
             // min height for the control.  The min height of the text control will be the size
             // of a single line of text.  This assumes that two lines of text are larger
             // than the height of the icon for the bar.
-            textCtrl->Wrap( text->GetSize().GetWidth() );
-            wxString new_text = textCtrl->GetLabel();
-            int      height = ( new_text.Freq( '\n' ) + 1 ) * text->GetMinSize().GetHeight();
-            SetMinSize( wxSize( GetSize().GetWidth(), height ) );
+            textCtrl->Wrap( -1 );
+            wxString wrapped_text = textCtrl->GetLabel();
+            int line_count = wrapped_text.Freq( '\n' ) + 1;
+            int txt_h, txt_v;
+            wxWindowDC dc( textCtrl );
+            dc.GetTextExtent( wxT( "Xp" ), &txt_h, &txt_v );
+
+            int      height = txt_v * line_count;
+            int      margins = txt_v - 1;
+            SetMinSize( wxSize( GetSize().GetWidth(), height + margins ) );
+
+            textCtrl->Wrap( -1 );
         }
     }
 
@@ -323,7 +349,10 @@ void WX_INFOBAR::AddButton( wxButton* aButton )
     element->SetFlag( wxSTRETCH_MASK );
 
     if( IsShownOnScreen() )
-        sizer->Layout();
+    {
+        Layout();
+        sizer->Fit( this );
+    }
 }
 
 
@@ -336,7 +365,10 @@ void WX_INFOBAR::AddButton( wxHyperlinkCtrl* aHypertextButton )
     sizer->Add( aHypertextButton, wxSizerFlags().Centre().Border( wxRIGHT ).Shaped() );
 
     if( IsShownOnScreen() )
-        sizer->Layout();
+    {
+        Layout();
+        sizer->Fit( this );
+    }
 }
 
 
@@ -498,13 +530,13 @@ void INFOBAR_REPORTER::Finalize()
     switch( m_severity )
     {
     case RPT_SEVERITY_UNDEFINED: icon = wxICON_INFORMATION; break;
-    case RPT_SEVERITY_INFO: icon = wxICON_INFORMATION; break;
-    case RPT_SEVERITY_EXCLUSION: icon = wxICON_WARNING; break;
-    case RPT_SEVERITY_ACTION: icon = wxICON_WARNING; break;
-    case RPT_SEVERITY_WARNING: icon = wxICON_WARNING; break;
-    case RPT_SEVERITY_ERROR: icon = wxICON_ERROR; break;
-    case RPT_SEVERITY_IGNORE: icon = wxICON_INFORMATION; break;
-    case RPT_SEVERITY_DEBUG: icon = wxICON_INFORMATION; break;
+    case RPT_SEVERITY_INFO:      icon = wxICON_INFORMATION; break;
+    case RPT_SEVERITY_EXCLUSION: icon = wxICON_WARNING;     break;
+    case RPT_SEVERITY_ACTION:    icon = wxICON_WARNING;     break;
+    case RPT_SEVERITY_WARNING:   icon = wxICON_WARNING;     break;
+    case RPT_SEVERITY_ERROR:     icon = wxICON_ERROR;       break;
+    case RPT_SEVERITY_IGNORE:    icon = wxICON_INFORMATION; break;
+    case RPT_SEVERITY_DEBUG:     icon = wxICON_INFORMATION; break;
     }
 
     if( m_message->EndsWith( wxS( "\n" ) ) )

eeschema/CMakeLists.txt

@@ -32,7 +32,6 @@ include_directories( BEFORE ${INC_BEFORE} )
 include_directories(
     ${CMAKE_SOURCE_DIR}/common
     ${CMAKE_SOURCE_DIR}/common/dialogs
-    ${CMAKE_SOURCE_DIR}/libs/sexpr/include
     ${INC_AFTER}
     ./dialogs
     ./libview
@@ -124,6 +123,8 @@ set( EESCHEMA_DLGS
     dialogs/dialog_label_properties_base.cpp
     dialogs/dialog_lib_edit_pin_table.cpp
     dialogs/dialog_lib_edit_pin_table_base.cpp
+    dialogs/dialog_lib_fields_base.cpp
+    dialogs/dialog_lib_fields.cpp
     dialogs/dialog_lib_new_symbol.cpp
     dialogs/dialog_lib_new_symbol_base.cpp
     dialogs/dialog_lib_symbol_properties.cpp
@@ -369,6 +370,7 @@ set( EESCHEMA_SRCS
     generate_alias_info.cpp
     gfx_import_utils.cpp
     junction_helpers.cpp
+    lib_fields_data_model.cpp
     lib_symbol.cpp
     libarch.cpp
     menubar.cpp
@@ -606,7 +608,6 @@ target_link_libraries( eeschema_kiface
         eeschema_kiface_objects
         markdown_lib
         scripting
-        sexpr
         core
         Boost::headers
         ${wxWidgets_LIBRARIES}