pcb_properties_panel.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KICAD, a free EDA CAD application.
 *
 * Copyright (C) 2020-2023 CERN
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 * @author Maciej Suminski <[email protected]>
 *
 * 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 <https://www.gnu.org/licenses/>.
 */
 
#include "pcb_properties_panel.h"
 
#include <font/fontconfig.h>
#include <font/kicad_font_name.h>
#include <frame_type.h>
#include <pgm_base.h>
#include <pcb_base_edit_frame.h>
#include <tool/tool_manager.h>
#include <tools/pcb_actions.h>
#include <tools/pcb_selection_tool.h>
#include <tools/edit_tool.h>
#include <tools/constraint_edit_tool.h>
#include <constraints/board_constraint_adapter.h>
#include <constraints/constraint_builder.h>
#include <constraints/pcb_constraint.h>
#include <drill/drill_chart_model.h>
#include <drill/drill_enumerator.h>
#include <math/util.h>
#include <base_units.h>
#include <pcb_generated_table.h>
#include <pcb_drill_map.h>
#include <pcb_shape.h>
#include <eda_units.h>
#include <properties/property_mgr.h>
#include <properties/pg_editors.h>
#include <board_design_settings.h>
#include <board_commit.h>
#include <board_connected_item.h>
#include <board.h>
#include <properties/pg_properties.h>
#include <properties/property.h>
#include <pcb_dimension.h>
#include <pcb_shape.h>
#include <pcb_text.h>
#include <pcb_track.h>
#include <pcb_generator.h>
#include <generators/pcb_tuning_pattern.h>
#include <generators/pcb_via_stitch.h>
#include <pad.h>
#include <footprint.h>
#include <pcb_field.h>
#include <template_fieldnames.h>
#include <settings/color_settings.h>
#include <string_utils.h>
#include <widgets/net_selector.h>
#include <widgets/ui_common.h>
#include <widgets/unit_binder.h>
 
#include <memory>
#include <vector>
#include <wx/combobox.h>
 
#include <wx/msgdlg.h>
 
#include <cmath>
 
 
class PG_NET_SELECTOR_EDITOR : public wxPGEditor
{
public:
    static const wxString EDITOR_NAME;
 
    PG_NET_SELECTOR_EDITOR() = default;
 
    wxString GetName() const override { return EDITOR_NAME; }
 
    wxPGWindowList CreateControls( wxPropertyGrid* aGrid, wxPGProperty* aProperty, const wxPoint& aPos,
                                   const wxSize& aSize ) const override
    {
        NET_SELECTOR* editor = new NET_SELECTOR( aGrid->GetPanel(), wxID_ANY, aPos, aSize, 0 );
 
        // wxPropertyGrid registers editors globally and the same PG_NET_SELECTOR_EDITOR
        // instance is reused by every PCB_PROPERTIES_PANEL (board editor, footprint editor).
        // Resolve the owning panel -- and therefore the live frame and board -- from the
        // grid at use time instead of caching frame state on the editor.  This avoids
        // cross-frame state corruption and nullptr derefs when one panel is destroyed while
        // another is still live.
        if( PCB_PROPERTIES_PANEL* panel = dynamic_cast<PCB_PROPERTIES_PANEL*>( aGrid->GetParent() ) )
        {
            if( PCB_BASE_EDIT_FRAME* frame = panel->GetFrame() )
            {
                if( BOARD* board = frame->GetBoard() )
                    editor->SetNetInfo( &board->GetNetInfo() );
            }
        }
 
        editor->SetIndeterminateString( INDETERMINATE_STATE );
        UpdateControl( aProperty, editor );
 
        editor->Bind( FILTERED_ITEM_SELECTED,
                      [=]( wxCommandEvent& aEvt )
                      {
                          auto& choices = const_cast<wxPGChoices&>( aProperty->GetChoices() );
                          wxString netname = editor->GetSelectedNetname();
 
                          if( choices.Index( netname ) == wxNOT_FOUND )
                              choices.Add( netname, editor->GetSelectedNetcode() );
 
                          wxVariant val( editor->GetSelectedNetcode() );
                          aGrid->ChangePropertyValue( aProperty, val );
                      } );
 
        return editor;
    }
 
    void UpdateControl( wxPGProperty* aProperty, wxWindow* aCtrl ) const override
    {
        if( NET_SELECTOR* editor = dynamic_cast<NET_SELECTOR*>( aCtrl ) )
        {
            if( aProperty->IsValueUnspecified() )
                editor->SetIndeterminate();
            else
                editor->SetSelectedNetcode( (int) aProperty->GetValue().GetLong() );
        }
    }
 
    bool GetValueFromControl( wxVariant& aVariant, wxPGProperty* aProperty, wxWindow* aCtrl ) const override
    {
        NET_SELECTOR* editor = dynamic_cast<NET_SELECTOR*>( aCtrl );
 
        if( !editor )
            return false;
 
        aVariant = static_cast<long>( editor->GetSelectedNetcode() );
        return true;
    }
 
    bool OnEvent( wxPropertyGrid* aGrid, wxPGProperty* aProperty, wxWindow* aWindow, wxEvent& aEvent ) const override
    {
        return false;
    }
};
 
 
const wxString PG_NET_SELECTOR_EDITOR::EDITOR_NAME = wxS( "PG_NET_SELECTOR_EDITOR" );
 
class PG_TRACK_WIDTH_EDITOR : public wxPGEditor
{
public:
    static const wxString EDITOR_NAME;
 
    PG_TRACK_WIDTH_EDITOR( PCB_BASE_EDIT_FRAME* aFrame ) :
            m_frame( aFrame )
    {
        if( m_frame )
        {
            m_unitBinder = std::make_unique<PROPERTY_EDITOR_UNIT_BINDER>( m_frame );
            m_unitBinder->SetUnits( m_frame->GetUserUnits() );
        }
 
        m_editorName = BuildEditorName( m_frame );
    }
 
    wxString GetName() const override { return m_editorName; }
 
    static wxString BuildEditorName( PCB_BASE_EDIT_FRAME* aFrame )
    {
        if( !aFrame )
            return EDITOR_NAME + "NoFrame";
 
        return EDITOR_NAME + aFrame->GetName();
    }
 
    void UpdateFrame( PCB_BASE_EDIT_FRAME* aFrame )
    {
        m_frame = aFrame;
 
        if( m_frame )
        {
            m_unitBinder = std::make_unique<PROPERTY_EDITOR_UNIT_BINDER>( m_frame );
            m_unitBinder->SetUnits( m_frame->GetUserUnits() );
        }
        else
        {
            m_unitBinder = nullptr;
        }
    }
 
    wxPGWindowList CreateControls( wxPropertyGrid* aGrid, wxPGProperty* aProperty, const wxPoint& aPos,
                                   const wxSize& aSize ) const override
    {
        wxASSERT( m_unitBinder );
 
        wxComboBox* editor = new wxComboBox( aGrid->GetPanel(), wxID_ANY, wxEmptyString, aPos, aSize, 0, nullptr,
                                             wxCB_DROPDOWN | wxTE_PROCESS_ENTER );
 
        m_unitBinder->SetControl( editor );
        m_unitBinder->RequireEval();
        m_unitBinder->SetUnits( m_frame->GetUserUnits() );
 
        setTrackWidthOptions( editor );
        UpdateControl( aProperty, editor );
 
        std::shared_ptr<bool> popupShown = std::make_shared<bool>( false );
        auto commitValue =
                [this, aGrid, aProperty, editor]()
                {
                    if( !m_unitBinder || editor->GetValue() == INDETERMINATE_STATE )
                        return;
 
                    wxVariant val( static_cast<long>( m_unitBinder->GetValue() ) );
                    aGrid->ChangePropertyValue( aProperty, val );
                };
 
        editor->Bind( wxEVT_COMBOBOX_DROPDOWN,
                      [popupShown]( wxCommandEvent& aEvent )
                      {
                          *popupShown = true;
                          aEvent.Skip();
                      } );
 
        editor->Bind( wxEVT_COMBOBOX,
                      [commitValue, popupShown]( wxCommandEvent& aEvent )
                      {
                          // Choosing a preset from the dropdown should apply that preset immediately.
                          if( *popupShown )
                              commitValue();
 
                          aEvent.Skip();
                      } );
 
        editor->Bind( wxEVT_COMBOBOX_CLOSEUP,
                      [aGrid, popupShown]( wxCommandEvent& aEvent )
                      {
                          aGrid->CallAfter( [popupShown]()
                                            {
                                                *popupShown = false;
                                            } );
 
                          aEvent.Skip();
                      } );
 
        editor->Bind( wxEVT_CHAR_HOOK,
                      [commitValue, editor, popupShown]( wxKeyEvent& aEvent )
                      {
                          // Pressing Enter after typing a custom value should apply the typed value,
                          // not the first preset in the dropdown.
                          if( ( aEvent.GetKeyCode() == WXK_RETURN
                                || aEvent.GetKeyCode() == WXK_NUMPAD_ENTER )
                              && !*popupShown )
                          {
                              if( editor->GetValue() != INDETERMINATE_STATE )
                              {
                                  commitValue();
                                  return;
                              }
 
                              // Let the property grid accept an unchanged mixed value.
                          }
 
                          aEvent.Skip();
                      } );
 
        editor->Bind( wxEVT_KILL_FOCUS,
                      [commitValue, popupShown]( wxFocusEvent& aEvent )
                      {
                          // Clicking into another property cell should keep any typed custom value.
                          if( !*popupShown )
                              commitValue();
 
                          aEvent.Skip();
                      } );
 
        return wxPGWindowList( editor, nullptr );
    }
 
    void UpdateControl( wxPGProperty* aProperty, wxWindow* aCtrl ) const override
    {
        if( !m_unitBinder )
            return;
 
        wxComboBox* editor = dynamic_cast<wxComboBox*>( aCtrl );
        wxCHECK( editor, /* void */ );
 
        if( aProperty->IsValueUnspecified() )
            editor->ChangeValue( INDETERMINATE_STATE );
        else
            m_unitBinder->ChangeValue( aProperty->GetValue().GetLong() );
    }
 
    bool GetValueFromControl( wxVariant& aVariant, wxPGProperty* aProperty, wxWindow* aCtrl ) const override
    {
        if( !m_unitBinder )
            return false;
 
        wxComboBox* editor = dynamic_cast<wxComboBox*>( aCtrl );
        wxCHECK_MSG( editor, false, "PG_TRACK_WIDTH_EDITOR requires a combo box!" );
 
        if( editor->GetValue() == INDETERMINATE_STATE )
        {
            aVariant.MakeNull();
            return true;
        }
 
        long result = static_cast<long>( m_unitBinder->GetValue() );
        bool changed = aVariant.IsNull() || result != aVariant.GetLong();
 
        if( changed )
            aVariant = result;
 
        return changed;
    }
 
    bool OnEvent( wxPropertyGrid* aGrid, wxPGProperty* aProperty, wxWindow* aWindow, wxEvent& aEvent ) const override
    {
        return false;
    }
 
private:
    void setTrackWidthOptions( wxComboBox* aEditor ) const
    {
        std::vector<long long int> trackWidths;
 
        // 0 is the netclass place-holder.
        for( unsigned ii = 1; ii < m_frame->GetDesignSettings().m_TrackWidthList.size(); ++ii )
            trackWidths.push_back( m_frame->GetDesignSettings().m_TrackWidthList[ii] );
 
        m_unitBinder->SetOptionsList( trackWidths );
 
        wxString unitLabel = EDA_UNIT_UTILS::GetLabel( m_frame->GetUserUnits() );
 
        for( unsigned ii = 0; ii < aEditor->GetCount(); ++ii )
            aEditor->SetString( ii, aEditor->GetString( ii ) + wxS( " " ) + unitLabel );
    }
 
    PCB_BASE_EDIT_FRAME*                         m_frame;
    std::unique_ptr<PROPERTY_EDITOR_UNIT_BINDER> m_unitBinder;
    wxString                                     m_editorName;
};
 
 
const wxString PG_TRACK_WIDTH_EDITOR::EDITOR_NAME = wxS( "PG_TRACK_WIDTH_EDITOR" );
 
PCB_PROPERTIES_PANEL::PCB_PROPERTIES_PANEL( wxWindow* aParent, PCB_BASE_EDIT_FRAME* aFrame ) :
        PROPERTIES_PANEL( aParent, aFrame ),
        m_frame( aFrame ),
        m_propMgr( PROPERTY_MANAGER::Instance() ),
        m_scaleConfirmPending( false )
{
    addCategoryButton( _HKI( "Custom Properties" ), _( "Add Custom Property" ), BITMAPS::small_plus,
                       [this]()
                       {
                           addBlankCustomProperty();
                       } );
 
    addCategoryButton( _HKI( "Fields" ), _( "Add Field" ), BITMAPS::small_plus,
                       [this]()
                       {
                           addBlankField();
                       } );
 
    m_propMgr.Rebuild();
    bool found = false;
 
    wxASSERT( wxPGGlobalVars );
 
    wxString editorKey = PG_UNIT_EDITOR::BuildEditorName( m_frame );
 
    auto it = wxPGGlobalVars->m_mapEditorClasses.find( editorKey );
 
    if( it != wxPGGlobalVars->m_mapEditorClasses.end() )
    {
        m_unitEditorInstance = static_cast<PG_UNIT_EDITOR*>( it->second );
        m_unitEditorInstance->UpdateFrame( m_frame );
        found = true;
    }
 
    if( !found )
    {
        PG_UNIT_EDITOR* new_editor = new PG_UNIT_EDITOR( m_frame );
        m_unitEditorInstance = static_cast<PG_UNIT_EDITOR*>( wxPropertyGrid::RegisterEditorClass( new_editor ) );
    }
 
    it = wxPGGlobalVars->m_mapEditorClasses.find( PG_TRACK_WIDTH_EDITOR::BuildEditorName( m_frame ) );
 
    if( it != wxPGGlobalVars->m_mapEditorClasses.end() )
    {
        m_trackWidthEditorInstance = static_cast<PG_TRACK_WIDTH_EDITOR*>( it->second );
        m_trackWidthEditorInstance->UpdateFrame( m_frame );
    }
    else
    {
        PG_TRACK_WIDTH_EDITOR* trackWidthEditor = new PG_TRACK_WIDTH_EDITOR( m_frame );
        m_trackWidthEditorInstance =
                static_cast<PG_TRACK_WIDTH_EDITOR*>( wxPropertyGrid::RegisterEditorClass( trackWidthEditor ) );
    }
 
    it = wxPGGlobalVars->m_mapEditorClasses.find( PG_CHECKBOX_EDITOR::EDITOR_NAME );
 
    if( it == wxPGGlobalVars->m_mapEditorClasses.end() )
    {
        PG_CHECKBOX_EDITOR* cbEditor = new PG_CHECKBOX_EDITOR();
        m_checkboxEditorInstance = static_cast<PG_CHECKBOX_EDITOR*>( wxPropertyGrid::RegisterEditorClass( cbEditor ) );
    }
    else
    {
        m_checkboxEditorInstance = static_cast<PG_CHECKBOX_EDITOR*>( it->second );
    }
 
    it = wxPGGlobalVars->m_mapEditorClasses.find( PG_RATIO_EDITOR::EDITOR_NAME );
 
    if( it == wxPGGlobalVars->m_mapEditorClasses.end() )
    {
        PG_RATIO_EDITOR* ratioEditor = new PG_RATIO_EDITOR();
        m_ratioEditorInstance = static_cast<PG_RATIO_EDITOR*>( wxPropertyGrid::RegisterEditorClass( ratioEditor ) );
    }
    else
    {
        m_ratioEditorInstance = static_cast<PG_RATIO_EDITOR*>( it->second );
    }
 
    it = wxPGGlobalVars->m_mapEditorClasses.find( PG_NET_SELECTOR_EDITOR::EDITOR_NAME );
 
    if( it == wxPGGlobalVars->m_mapEditorClasses.end() )
    {
        PG_NET_SELECTOR_EDITOR* netEditor = new PG_NET_SELECTOR_EDITOR();
        m_netSelectorEditorInstance = static_cast<PG_NET_SELECTOR_EDITOR*>( wxPropertyGrid::RegisterEditorClass( netEditor ) );
    }
    else
    {
        m_netSelectorEditorInstance = static_cast<PG_NET_SELECTOR_EDITOR*>( it->second );
    }
 
    it = wxPGGlobalVars->m_mapEditorClasses.find( PG_FPID_EDITOR::BuildEditorName( m_frame ) );
 
    if( it != wxPGGlobalVars->m_mapEditorClasses.end() )
    {
        m_fpEditorInstance = static_cast<PG_FPID_EDITOR*>( it->second );
        m_fpEditorInstance->UpdateFrame( m_frame );
    }
    else
    {
        PG_FPID_EDITOR* fpEditor = new PG_FPID_EDITOR( m_frame,
                                                       []()
                                                       {
                                                           return "";
                                                       });
        m_fpEditorInstance = static_cast<PG_FPID_EDITOR*>( wxPropertyGrid::RegisterEditorClass( fpEditor ) );
    }
 
    it = wxPGGlobalVars->m_mapEditorClasses.find( PG_URL_EDITOR::BuildEditorName( m_frame ) );
 
    if( it != wxPGGlobalVars->m_mapEditorClasses.end() )
    {
        m_urlEditorInstance = static_cast<PG_URL_EDITOR*>( it->second );
        m_urlEditorInstance->UpdateFrame( m_frame );
    }
    else
    {
        PG_URL_EDITOR* urlEditor = new PG_URL_EDITOR( m_frame );
        m_urlEditorInstance = static_cast<PG_URL_EDITOR*>( wxPropertyGrid::RegisterEditorClass( urlEditor ) );
    }
 
    Bind( wxEVT_MENU, &PCB_PROPERTIES_PANEL::onContextMenu, this, ID_CTX_ADD_FIELD );
    Bind( wxEVT_MENU, &PCB_PROPERTIES_PANEL::onContextMenu, this, ID_CTX_ADD_CUSTOM_PROPERTY );
    Bind( wxEVT_MENU, &PCB_PROPERTIES_PANEL::onContextMenu, this, ID_CTX_REMOVE_FIELD );
    Bind( wxEVT_MENU, &PCB_PROPERTIES_PANEL::onContextMenu, this, ID_CTX_REMOVE_CUSTOM_PROPERTY );
}
 
 
PCB_PROPERTIES_PANEL::~PCB_PROPERTIES_PANEL()
{
    m_unitEditorInstance->UpdateFrame( nullptr );
    m_fpEditorInstance->UpdateFrame( nullptr );
    m_urlEditorInstance->UpdateFrame( nullptr );
    m_trackWidthEditorInstance->UpdateFrame( nullptr );
 
    // Note: the shared PG_NET_SELECTOR_EDITOR does not cache frame state; it resolves the
    // owning panel from the property grid on each CreateControls call, so no teardown is
    // needed here.
}
 
 
const SELECTION& PCB_PROPERTIES_PANEL::getSelection( SELECTION& aFallbackSelection )
{
    PCB_SELECTION_TOOL* selectionTool = m_frame->GetToolManager()->GetTool<PCB_SELECTION_TOOL>();
    const SELECTION& selection = selectionTool->GetSelection();
 
    if( selection.Empty() && m_frame->IsType( FRAME_FOOTPRINT_EDITOR ) )
    {
        if( BOARD* board = m_frame->GetBoard() )
        {
            if( FOOTPRINT* footprint = board->GetFirstFootprint() )
            {
                aFallbackSelection.Clear();
                aFallbackSelection.Add( footprint );
                return aFallbackSelection;
            }
        }
    }
 
    return selection;
}
 
 
EDA_ITEM* PCB_PROPERTIES_PANEL::getFrontItem()
{
    SELECTION fallbackSelection;
    const SELECTION& selection = getSelection( fallbackSelection );
 
    return selection.Empty() ? nullptr : selection.Front();
}
 
 
void PCB_PROPERTIES_PANEL::UpdateData()
{
    BOARD* board = m_frame->GetBoard();
 
    if( !board )
        return;
 
    SELECTION fallbackSelection;
    const SELECTION& selection = getSelection( fallbackSelection );
 
    // TODO perhaps it could be called less often? use PROPERTIES_TOOL and catch MODEL_RELOAD?
    updateLists( board );
 
    // Will actually just be updatePropertyValues() if selection hasn't changed
    rebuildProperties( selection );
}
 
 
void PCB_PROPERTIES_PANEL::AfterCommit()
{
    if( !m_frame->GetBoard() )
        return;
 
    SELECTION fallbackSelection;
    const SELECTION& selection = getSelection( fallbackSelection );
 
    rebuildProperties( selection );
}
 
 
bool PCB_PROPERTIES_PANEL::isKeyEditable( const wxPGProperty* aPGProp ) const
{
    PROPERTY_BASE* prop = static_cast<PROPERTY_BASE*>( aPGProp->GetClientData() );
 
    if( !prop )
        return false;
 
    EDA_ITEM* item = const_cast<PCB_PROPERTIES_PANEL*>( this )->getFrontItem();
 
    if( !item )
        return false;
 
    if( prop->Group() == _HKI( "Custom Properties" ) )
        return true;
 
    if( item->Type() != PCB_FOOTPRINT_T )
        return false;
 
    PCB_FIELD* field = static_cast<FOOTPRINT*>( item )->GetField( prop->Name() );
 
    return field && !field->IsMandatory() && !field->IsPrivate();
}
 
 
bool PCB_PROPERTIES_PANEL::isKeyNameInUse( const wxString& aName ) const
{
    EDA_ITEM* item = const_cast<PCB_PROPERTIES_PANEL*>( this )->getFrontItem();
 
    if( !item )
        return false;
 
    return m_propMgr.GetProperty( item, aName ) != nullptr;
}
 
 
void PCB_PROPERTIES_PANEL::onKeyRenamed( const wxString& aOldName, const wxString& aNewName )
{
    SELECTION fallbackSelection;
    const SELECTION& selection = getSelection( fallbackSelection );
 
    BOARD_COMMIT changes( m_frame );
    PROPERTY_COMMIT_HANDLER handler( &changes );
 
    for( EDA_ITEM* item : selection )
    {
        if( !item->IsBOARD_ITEM() )
            continue;
 
        BOARD_ITEM* boardItem = static_cast<BOARD_ITEM*>( item );
 
        if( boardItem->Type() == PCB_FOOTPRINT_T )
        {
            FOOTPRINT* footprint = static_cast<FOOTPRINT*>( boardItem );
            PCB_FIELD* field     = footprint->GetField( aOldName );
 
            if( field && !field->IsMandatory() )
            {
                changes.Modify( footprint, nullptr, RECURSE_MODE::NO_RECURSE );
                field->SetName( aNewName );
                continue;
            }
        }
 
        wxString value;
 
        if( boardItem->GetCustomProperty( aOldName, value ) )
        {
            changes.Modify( boardItem, nullptr, RECURSE_MODE::NO_RECURSE );
            boardItem->RemoveCustomProperty( aOldName );
            boardItem->SetCustomProperty( aNewName, value );
        }
    }
 
    changes.Push( _( "Rename Property" ) );
 
    AfterCommit();
}
 
 
bool PCB_PROPERTIES_PANEL::buildContextMenu( wxMenu& aMenu, wxPGProperty* aPGProp )
{
    if( aPGProp->IsCategory() )
    {
        if( aPGProp->GetLabel() == wxGetTranslation( _HKI( "Fields" ) ) )
            aMenu.Append( ID_CTX_ADD_FIELD, _( "Add Field" ) );
        else if( aPGProp->GetLabel() == wxGetTranslation( _HKI( "Custom Properties" ) ) )
            aMenu.Append( ID_CTX_ADD_CUSTOM_PROPERTY, _( "Add Custom Property" ) );
    }
    else
    {
        PROPERTY_BASE* prop = static_cast<PROPERTY_BASE*>( aPGProp->GetClientData() );
 
        if( !prop )
            return false;
 
        if( prop->Group() == _HKI( "Fields" ) )
        {
            if( isKeyEditable( aPGProp ) )
                aMenu.Append( ID_CTX_REMOVE_FIELD, _( "Remove Field" ) );
 
            aMenu.Append( ID_CTX_ADD_FIELD, _( "Add Field" ) );
        }
        else if( prop->Group() == _HKI( "Custom Properties" ) )
        {
            aMenu.Append( ID_CTX_REMOVE_CUSTOM_PROPERTY, _( "Remove Custom Property" ) );
            aMenu.Append( ID_CTX_ADD_CUSTOM_PROPERTY, _( "Add Custom Property" ) );
        }
    }
 
    return aMenu.GetMenuItemCount() > 0;
}
 
 
void PCB_PROPERTIES_PANEL::onContextMenu( wxCommandEvent& aEvent )
{
    switch( aEvent.GetId() )
    {
    case ID_CTX_ADD_FIELD:              addBlankField();                                    break;
    case ID_CTX_ADD_CUSTOM_PROPERTY:    addBlankCustomProperty();                           break;
    case ID_CTX_REMOVE_FIELD:           removeField( m_contextMenuPropertyName );           break;
    case ID_CTX_REMOVE_CUSTOM_PROPERTY: removeCustomProperty( m_contextMenuPropertyName );  break;
    default:
        break;
    }
}
 
 
void PCB_PROPERTIES_PANEL::addBlankField()
{
    SELECTION fallbackSelection;
    const SELECTION& selection = getSelection( fallbackSelection );
 
    settlePendingLabelEdit();
 
    if( selection.Empty() )
        return;
 
    // Pick a unique untranslated placeholder name that doesn't collide with an existing field.
    wxString name;
 
    for( int n = 0; ; ++n )
    {
        name   = GetUserFieldName( n, UNTRANSLATED );
        bool used = false;
 
        for( EDA_ITEM* item : selection )
        {
            if( item->Type() == PCB_FOOTPRINT_T && static_cast<FOOTPRINT*>( item )->HasField( name ) )
            {
                used = true;
                break;
            }
        }
 
        if( !used )
            break;
    }
 
    BOARD_COMMIT changes( m_frame );
    PROPERTY_COMMIT_HANDLER handler( &changes );
 
    for( EDA_ITEM* item : selection )
    {
        if( item->Type() != PCB_FOOTPRINT_T )
            continue;
 
        FOOTPRINT* footprint = static_cast<FOOTPRINT*>( item );
        PCB_FIELD* field     = new PCB_FIELD( footprint, FIELD_T::USER, name );
 
        field->SetText( wxEmptyString );
        field->SetVisible( false );
        changes.Modify( footprint, nullptr, RECURSE_MODE::NO_RECURSE );
        footprint->Add( field );
    }
 
    changes.Push( _( "Add Field" ) );
    AfterCommit();
 
    m_pendingNewKey = name;
 
    beginLabelEdit( name, true );
}
 
 
void PCB_PROPERTIES_PANEL::addBlankCustomProperty()
{
    SELECTION fallbackSelection;
    const SELECTION& selection = getSelection( fallbackSelection );
 
    settlePendingLabelEdit();
 
    if( selection.Empty() )
        return;
 
    wxString name;
 
    for( int n = 0; ; ++n )
    {
        name   = wxString::Format( wxS( "Property%d" ), n );
        bool used = false;
 
        for( EDA_ITEM* item : selection )
        {
            wxString dummy;
 
            if( item->GetCustomProperty( name, dummy ) )
            {
                used = true;
                break;
            }
        }
 
        if( !used )
            break;
    }
 
    BOARD_COMMIT changes( m_frame );
    PROPERTY_COMMIT_HANDLER handler( &changes );
 
    for( EDA_ITEM* item : selection )
    {
        if( item->IsBOARD_ITEM() )
        {
            changes.Modify( item, nullptr, RECURSE_MODE::NO_RECURSE );
            item->SetCustomProperty( name, wxEmptyString );
        }
    }
 
    changes.Push( _( "Add Custom Property" ) );
    AfterCommit();
 
    m_pendingNewKey = name;
 
    beginLabelEdit( name, true );
}
 
 
void PCB_PROPERTIES_PANEL::removeField( const wxString& aName )
{
    SELECTION fallbackSelection;
    const SELECTION& selection = getSelection( fallbackSelection );
 
    BOARD_COMMIT changes( m_frame );
    PROPERTY_COMMIT_HANDLER handler( &changes );
 
    for( EDA_ITEM* item : selection )
    {
        if( item->Type() != PCB_FOOTPRINT_T )
            continue;
 
        FOOTPRINT* footprint = static_cast<FOOTPRINT*>( item );
        PCB_FIELD* field     = footprint->GetField( aName );
 
        if( field && !field->IsMandatory() )
        {
            // BOARD_COMMIT's own field removal path only hides the field (e.g. when a user presses the delete key),
            // we want to actually delete a custom field from this explicit menu action
            changes.Modify( footprint, nullptr, RECURSE_MODE::NO_RECURSE );
            footprint->Remove( field );
        }
    }
 
    changes.Push( _( "Remove Field" ) );
    AfterCommit();
}
 
 
void PCB_PROPERTIES_PANEL::removeCustomProperty( const wxString& aName )
{
    SELECTION fallbackSelection;
    const SELECTION& selection = getSelection( fallbackSelection );
 
    BOARD_COMMIT changes( m_frame );
    PROPERTY_COMMIT_HANDLER handler( &changes );
 
    for( EDA_ITEM* item : selection )
    {
        if( item->IsBOARD_ITEM() )
        {
            changes.Modify( item, nullptr, RECURSE_MODE::NO_RECURSE );
            item->RemoveCustomProperty( aName );
        }
    }
 
    changes.Push( _( "Remove Custom Property" ) );
    AfterCommit();
}
 
 
void PCB_PROPERTIES_PANEL::onNewItemLeftBlank( const wxString& aKey )
{
    // Note: currently assuming that any newly-created item from the panel is either a field or
    // a custom property because those are the types we currently support.
    if( EDA_ITEM* item = getFrontItem();
        item && item->Type() == PCB_FOOTPRINT_T && static_cast<FOOTPRINT*>( item )->HasField( aKey ) )
    {
        removeField( aKey );
    }
    else
    {
        removeCustomProperty( aKey );
    }
}
 
 
SELECTION PCB_PROPERTIES_PANEL::filterOutReadOnlyGenChildren( const SELECTION& aSelection )
{
    SELECTION filtered;
    filtered.SetIsHover( aSelection.IsHover() );
 
    for( EDA_ITEM* item : aSelection )
    {
        if( item->IsBOARD_ITEM() )
        {
            EDA_GROUP* parent = static_cast<BOARD_ITEM*>( item )->GetParentGroup();
 
            if( parent && parent->AsEdaItem()->Type() == PCB_GENERATOR_T
                && static_cast<PCB_GENERATOR*>( parent->AsEdaItem() )->ChildrenAreReadOnly() )
            {
                continue;
            }
        }
 
        filtered.Add( item );
    }
 
    return filtered;
}
 
 
void PCB_PROPERTIES_PANEL::rebuildProperties( const SELECTION& aRawSelection )
{
    // Strip read-only generator children (like stitch vias)
    SELECTION        editableSelection = filterOutReadOnlyGenChildren( aRawSelection );
    const SELECTION& aSelection = editableSelection;
 
    PROPERTIES_PANEL::rebuildProperties( aSelection );
 
}
 
 
wxPGProperty* PCB_PROPERTIES_PANEL::createPGProperty( const PROPERTY_BASE* aProperty ) const
{
    if( aProperty->TypeHash() == TYPE_HASH( PCB_LAYER_ID ) )
    {
        wxASSERT( aProperty->HasChoices() );
 
        const wxPGChoices& canonicalLayers = aProperty->Choices();
        wxArrayString      boardLayerNames;
        wxArrayInt         boardLayerIDs;
 
        for( int ii = 0; ii < (int) aProperty->Choices().GetCount(); ++ii )
        {
            int layer = canonicalLayers.GetValue( ii );
 
            boardLayerNames.push_back( m_frame->GetBoard()->GetLayerName( ToLAYER_ID( layer ) ) );
            boardLayerIDs.push_back( canonicalLayers.GetValue( ii ) );
        }
 
        auto ret = new PGPROPERTY_COLORENUM( new wxPGChoices( boardLayerNames, boardLayerIDs ) );
 
        ret->SetColorFunc(
                [&]( int aValue ) -> wxColour
                {
                    return m_frame->GetColorSettings()->GetColor( ToLAYER_ID( aValue ) ).ToColour();
                } );
 
        ret->SetLabel( wxGetTranslation( aProperty->Name() ) );
        ret->SetName( aProperty->Name() );
        ret->SetHelpString( wxGetTranslation( aProperty->Name() ) );
        ret->SetClientData( const_cast<PROPERTY_BASE*>( aProperty ) );
 
        return ret;
    }
 
    wxPGProperty* prop = PGPropertyFactory( aProperty, m_frame );
 
    if( aProperty->Name() == GetDefaultFieldName( FIELD_T::FOOTPRINT, UNTRANSLATED ) )
        prop->SetEditor( PG_FPID_EDITOR::BuildEditorName( m_frame ) );
    else if( aProperty->Name() == GetDefaultFieldName( FIELD_T::DATASHEET, UNTRANSLATED ) )
        prop->SetEditor( PG_URL_EDITOR::BuildEditorName( m_frame ) );
    // OwnerHash is the class that registered the property.  Routed PCB_ARC items inherit
    // PCB_TRACK::Width, so this catches track arcs without changing unrelated "Width" properties.
    else if( aProperty->OwnerHash() == TYPE_HASH( PCB_TRACK ) && aProperty->Name() == _HKI( "Width" ) )
        prop->SetEditor( PG_TRACK_WIDTH_EDITOR::BuildEditorName( m_frame ) );
 
    return prop;
}
 
 
PROPERTY_BASE* PCB_PROPERTIES_PANEL::getPropertyFromEvent( const wxPropertyGridEvent& aEvent ) const
{
    EDA_ITEM* item = const_cast<PCB_PROPERTIES_PANEL*>( this )->getFrontItem();
 
    if( !item || !item->IsBOARD_ITEM() )
        return nullptr;
 
    BOARD_ITEM* firstItem = static_cast<BOARD_ITEM*>( item );
 
    wxCHECK_MSG( firstItem, nullptr, wxT( "getPropertyFromEvent for a property with nothing selected!") );
 
    PROPERTY_BASE* property = m_propMgr.GetProperty( firstItem, aEvent.GetPropertyName() );
    wxCHECK_MSG( property, nullptr, wxT( "getPropertyFromEvent for a property not found on the selected item!" ) );
 
    return property;
}
 
 
void PCB_PROPERTIES_PANEL::valueChanging( wxPropertyGridEvent& aEvent )
{
    if( m_SuppressGridChangeEvents > 0 )
        return;
 
    EDA_ITEM* item = getFrontItem();
 
    PROPERTY_BASE* property = getPropertyFromEvent( aEvent );
    wxCHECK( property, /* void */ );
    wxCHECK( item, /* void */ );
 
    wxVariant newValue = aEvent.GetPropertyValue();
 
    if( VALIDATOR_RESULT validationFailure = property->Validate( newValue.GetAny(), item ) )
    {
        wxString errorMsg = wxString::Format( wxS( "%s: %s" ), wxGetTranslation( property->Name() ),
                                              validationFailure->get()->Format( m_frame ) );
        m_frame->ShowInfoBarError( errorMsg );
        aEvent.Veto();
        return;
    }
 
    // Scaling a footprint that has pads is dangerous (the physical
    // part keeps its original size), so confirm before applying.
    const wxString propName = aEvent.GetPropertyName();
 
    if( propName == _HKI( "Scale X" ) || propName == _HKI( "Scale Y" ) )
    {
        const double newScale = newValue.GetDouble();
 
        // Zero, negative, and non-finite scales make the footprint transform degenerate.
        if( !std::isfinite( newScale ) || newScale <= 0.0 )
        {
            m_frame->ShowInfoBarError( _( "Scale must be a positive number." ) );
            aEvent.Veto();
            return;
        }
 
        if( newScale != 1.0 )
        {
            SELECTION        fallbackSelection;
            const SELECTION& selection = getSelection( fallbackSelection );
            int              fpWithPads = 0;
 
            for( EDA_ITEM* edaItem : selection )
            {
                if( edaItem->IsBOARD_ITEM() && static_cast<BOARD_ITEM*>( edaItem )->Type() == PCB_FOOTPRINT_T
                    && !static_cast<FOOTPRINT*>( edaItem )->Pads().empty() )
                {
                    fpWithPads++;
                }
            }
 
            if( fpWithPads > 0 )
            {
                // A modal dialog must not be shown from this synchronous grid handler.
                // Veto the edit and re-drive it from the main loop once confirmed.
                aEvent.Veto();
 
                if( m_scaleConfirmPending )
                    return;
 
                m_scaleConfirmPending = true;
 
                wxString msg = wxString::Format( _( "%d footprint(s) in the selection have pads. Scaling changes "
                                                    "the drawn pad positions but not the physical part. Continue?" ),
                                                 fpWithPads );
 
                CallAfter(
                        [this, msg, propName, newValue]()
                        {
                            if( wxMessageBox( msg, _( "Scale footprint with pads?" ), wxYES_NO | wxICON_WARNING, this )
                                == wxYES )
                            {
                                applyConfirmedScale( propName, newValue );
                            }
 
                            m_scaleConfirmPending = false;
                        } );
 
                return;
            }
        }
    }
 
    aEvent.Skip();
}
 
 
void PCB_PROPERTIES_PANEL::applyConfirmedScale( const wxString& aPropName, const wxVariant& aValue )
{
    wxPGProperty* pgProp = m_grid->GetPropertyByName( aPropName );
 
    if( !pgProp )
        return;
 
    // Re-drive the normal changed path now that we are back in the main loop.
    wxPropertyGridEvent evt( wxEVT_PG_CHANGED );
    evt.SetEventObject( m_grid );
    evt.SetProperty( pgProp );
    evt.SetPropertyValue( aValue );
 
    valueChanged( evt );
}
 
 
void PCB_PROPERTIES_PANEL::valueChanged( wxPropertyGridEvent& aEvent )
{
    if( m_SuppressGridChangeEvents > 0 )
        return;
 
    SELECTION fallbackSelection;
    SELECTION rawSelection = getSelection( fallbackSelection );
 
    // Strip read-only generator children, last ditch sanity check
    SELECTION filtered = filterOutReadOnlyGenChildren( rawSelection );
 
    if( filtered.Empty() )
    {
        aEvent.Veto();
        return;
    }
 
    const SELECTION& selection = filtered;
 
    wxCHECK( getPropertyFromEvent( aEvent ), /* void */ );
 
    wxVariant newValue = aEvent.GetPropertyValue();
    BOARD_COMMIT changes( m_frame );
 
    PROPERTY_COMMIT_HANDLER handler( &changes );
 
    // Multi-footprint scale: rescale each footprint around the selection's
    // geometric (bbox) center instead of around its own anchor. Single-fp
    // edits go through the regular setter path (anchored at the fp itself).
    const wxString propName = aEvent.GetPropertyName();
    const bool     isScaleX = ( propName == _HKI( "Scale X" ) );
    const bool     isScaleY = ( propName == _HKI( "Scale Y" ) );
    int            fpInSelection = 0;
    BOX2I          selectionBBox;
 
    if( isScaleX || isScaleY )
    {
        for( EDA_ITEM* edaItem : selection )
        {
            if( edaItem->IsBOARD_ITEM() && static_cast<BOARD_ITEM*>( edaItem )->Type() == PCB_FOOTPRINT_T )
            {
                fpInSelection++;
                selectionBBox.Merge( static_cast<FOOTPRINT*>( edaItem )->GetBoundingBox() );
            }
        }
    }
 
    const bool     useSelectionCenter = fpInSelection > 1;
    const VECTOR2I selectionCenter = useSelectionCenter ? selectionBBox.GetCenter() : VECTOR2I( 0, 0 );
 
    // Driving length constraints touched by this edit solved again after commit lands
    std::vector<PCB_CONSTRAINT*> drivingConstraints;
 
    for( EDA_ITEM* edaItem : selection )
    {
        if( !edaItem->IsBOARD_ITEM() )
            continue;
 
        BOARD_ITEM* item = static_cast<BOARD_ITEM*>( edaItem );
        PROPERTY_BASE* property = m_propMgr.GetProperty( item, aEvent.GetPropertyName() );
        wxCHECK( property, /* void */ );
 
        if( item->Type() == PCB_TABLECELL_T )
            changes.Modify( item->GetParent(), nullptr, RECURSE_MODE::NO_RECURSE );
        else if( item->Type() == PCB_GENERATOR_T )
            changes.Modify( item, nullptr, RECURSE_MODE::RECURSE );
        else
            changes.Modify( item, nullptr, RECURSE_MODE::NO_RECURSE );
 
        // In the PCB Editor, we generally restrict pad movement to the footprint (like dragging)
        if( item->Type() == PCB_PAD_T && m_frame
                && m_frame->IsType( FRAME_PCB_EDITOR )
                && !m_frame->GetPcbNewSettings()->m_AllowFreePads
                && ( aEvent.GetPropertyName() == _HKI( "Position X" )
                     || aEvent.GetPropertyName() == _HKI( "Position Y" ) ) )
        {
            PAD* pad = static_cast<PAD*>( item );
            FOOTPRINT* fp = pad->GetParentFootprint();
 
            if( fp )
            {
                VECTOR2I oldPos = pad->GetPosition();
                VECTOR2I newPos = oldPos;
 
                if( aEvent.GetPropertyName() == _HKI( "Position X" ) )
                    newPos.x = (int) newValue.GetLong();
                else
                    newPos.y = (int) newValue.GetLong();
 
                VECTOR2I delta = newPos - oldPos;
 
                if( delta.x != 0 || delta.y != 0 )
                {
                    changes.Modify( fp );
                    fp->Move( delta );
                }
            }
 
            continue;
        }
 
        // Handle variant-aware boolean properties for footprints
        if( item->Type() == PCB_FOOTPRINT_T )
        {
            FOOTPRINT* footprint = static_cast<FOOTPRINT*>( item );
            wxString   variantName;
 
            if( footprint->GetBoard() )
                variantName = footprint->GetBoard()->GetCurrentVariant();
 
            if( !variantName.IsEmpty() )
            {
                if( propName == _HKI( "Do not Populate" )
                    || propName == _HKI( "Exclude From Bill of Materials" )
                    || propName == _HKI( "Exclude From Simulation" )
                    || propName == _HKI( "Exclude From Position Files" ) )
                {
                    FOOTPRINT_VARIANT* variant = footprint->GetVariant( variantName );
 
                    if( !variant )
                        variant = footprint->AddVariant( variantName );
 
                    if( variant )
                    {
                        bool boolValue = newValue.GetBool();
 
                        if( propName == _HKI( "Do not Populate" ) )
                            variant->SetDNP( boolValue );
                        else if( propName == _HKI( "Exclude From Bill of Materials" ) )
                            variant->SetExcludedFromBOM( boolValue );
                        else if( propName == _HKI( "Exclude From Simulation" ) )
                            variant->SetExcludedFromSim( boolValue );
                        else if( propName == _HKI( "Exclude From Position Files" ) )
                            variant->SetExcludedFromPosFiles( boolValue );
 
                        continue;
                    }
                }
            }
        }
 
        if( useSelectionCenter && item->Type() == PCB_FOOTPRINT_T )
        {
            FOOTPRINT* fp = static_cast<FOOTPRINT*>( item );
            double     newScale = newValue.GetDouble();
            double     relSx = isScaleX ? newScale / fp->GetScaleX() : 1.0;
            double     relSy = isScaleY ? newScale / fp->GetScaleY() : 1.0;
 
            fp->RescaleAroundPoint( selectionCenter, relSx, relSy );
            continue;
        }
 
        // Value mode and Driving value live partly in a board level constraint not item scoped
        // so route them through this commit for a shared undo step
        if( BaseType( item->Type() ) == PCB_DIMENSION_T )
        {
            PCB_DIMENSION_BASE* dim = static_cast<PCB_DIMENSION_BASE*>( item );
            BOARD*              board = m_frame->GetBoard();
 
            if( propName == _HKI( "Value Mode" ) )
            {
                DIM_VALUE_MODE mode = static_cast<DIM_VALUE_MODE>( newValue.GetLong() );
 
                // Seed from current display value so a mode switch alone does not move geometry
                std::optional<int> length;
 
                if( mode == DIM_VALUE_MODE::DRIVING )
                {
                    PCB_CONSTRAINT* existing = FindDimensionLengthConstraint( board, dim );
 
                    if( existing && existing->GetValue() )
                        length = KiROUND( *existing->GetValue() );
                    else
                        length = dim->GetMeasuredValue();
                }
 
                // Arbitrary keeps measured text until edited
                std::optional<wxString> overrideText;
 
                if( mode == DIM_VALUE_MODE::ARBITRARY && !dim->GetOverrideTextEnabled() )
                    overrideText = dim->GetValueText();
 
                PCB_CONSTRAINT* driving = SetDimensionValueMode(
                        board, dim, mode, length, overrideText,
                        [&]( BOARD_ITEM* aItem ) { changes.Modify( aItem ); },
                        [&]( BOARD_ITEM* aItem ) { changes.Add( aItem ); },
                        [&]( BOARD_ITEM* aItem ) { changes.Remove( aItem ); } );
 
                if( driving )
                    drivingConstraints.push_back( driving );
 
                continue;
            }
 
            if( propName == _HKI( "Value" ) && dim->GetValueMode() == DIM_VALUE_MODE::DRIVING )
            {
                // Parsed in dimension own units to match display validator already blocked
                // non positive entries other selected dims failing parse left unchanged
                double iu = EDA_UNIT_UTILS::UI::DoubleValueFromString( pcbIUScale, dim->GetUnits(),
                                                                       newValue.GetString() );
 
                if( iu > 0.0 )
                {
                    if( PCB_CONSTRAINT* driving = FindDimensionLengthConstraint( board, dim ) )
                    {
                        changes.Modify( driving );
                        driving->SetValue( KiROUND( iu ) );
                        drivingConstraints.push_back( driving );
                    }
                }
 
                continue;
            }
        }
 
        item->Set( property, newValue );
 
        // A generated table's cells come from the settings just changed, so they say nothing
        // about the edit until the table has been laid out again
        if( IsGeneratedTableType( item->Type() ) && item->GetBoard() )
            static_cast<PCB_GENERATED_TABLE*>( item )->RebuildCells( *item->GetBoard() );
    }
 
    changes.Push( _( "Edit Properties" ) );
 
    // Edit is authoritative so hold shapes fixed while solving neighbors and fold into this
    // undo with a no op if nothing was touched
    if( CONSTRAINT_EDIT_TOOL* constraintTool = m_frame->GetToolManager()->GetTool<CONSTRAINT_EDIT_TOOL>() )
    {
        std::vector<PCB_SHAPE*> shapes;
        EDIT_TOOL::collectConstraintShapes( selection, shapes );
        constraintTool->SolveAfterEdit( shapes );
    }
 
    // Driving length now on board so solve bound geometry to it and APPEND_UNDO folds follow
    // up moves into one undo
    if( !drivingConstraints.empty() )
    {
        BOARD_COMMIT solveCommit( m_frame );
 
        for( PCB_CONSTRAINT* constraint : drivingConstraints )
        {
            ApplyConstraintImmediately( m_frame->GetBoard(), constraint, nullptr,
                                        [&]( BOARD_ITEM* aItem )
                                        {
                                            solveCommit.Modify( aItem );
                                        } );
        }
 
        if( !solveCommit.Empty() )
            solveCommit.Push( _( "Apply Dimension Length" ), APPEND_UNDO );
    }
 
    m_frame->Refresh();
 
    // Perform grid updates as necessary based on value change
    AfterCommit();
 
    // PointEditor may need to update if locked/unlocked
    if( aEvent.GetPropertyName() == _HKI( "Locked" ) )
        m_frame->GetToolManager()->ProcessEvent( EVENTS::SelectedEvent );
 
    aEvent.Skip();
}
 
 
void PCB_PROPERTIES_PANEL::updateLists( const BOARD* aBoard )
{
    wxPGChoices layersAll;
    wxPGChoices layersCu;
    wxPGChoices nets;
    wxPGChoices fonts;
 
    // Regenerate all layers
    for( PCB_LAYER_ID layer : aBoard->GetEnabledLayers().UIOrder() )
        layersAll.Add( LSET::Name( layer ), layer );
 
    for( PCB_LAYER_ID layer : LSET( aBoard->GetEnabledLayers() & LSET::AllCuMask() ).UIOrder() )
        layersCu.Add( LSET::Name( layer ), layer );
 
    m_propMgr.GetProperty( TYPE_HASH( BOARD_ITEM ), _HKI( "Layer" ) )->SetChoices( layersAll );
    m_propMgr.GetProperty( TYPE_HASH( PCB_SHAPE ), _HKI( "Layer" ) )->SetChoices( layersAll );
 
    // Copper only properties
    m_propMgr.GetProperty( TYPE_HASH( BOARD_CONNECTED_ITEM ), _HKI( "Layer" ) )->SetChoices( layersCu );
    m_propMgr.GetProperty( TYPE_HASH( PAD ), _HKI( "Bottom Backdrill Must-Cut" ) )->SetChoices( layersCu );
    m_propMgr.GetProperty( TYPE_HASH( PAD ), _HKI( "Top Backdrill Must-Cut" ) )->SetChoices( layersCu );
    m_propMgr.GetProperty( TYPE_HASH( PCB_VIA ), _HKI( "Layer Top" ) )->SetChoices( layersCu );
    m_propMgr.GetProperty( TYPE_HASH( PCB_VIA ), _HKI( "Layer Bottom" ) )->SetChoices( layersCu );
    m_propMgr.GetProperty( TYPE_HASH( PCB_VIA ), _HKI( "Bottom Backdrill Must-Cut" ) )->SetChoices( layersCu );
    m_propMgr.GetProperty( TYPE_HASH( PCB_VIA ), _HKI( "Top Backdrill Must-Cut" ) )->SetChoices( layersCu );
    m_propMgr.GetProperty( TYPE_HASH( PCB_TUNING_PATTERN ), _HKI( "Layer" ) )->SetChoices( layersCu );
 
    // Regenerate nets
 
    std::vector<std::pair<wxString, int>> netNames;
    netNames.reserve( aBoard->GetNetInfo().NetsByNetcode().size() );
 
    for( const auto& [ netCode, netInfo ] : aBoard->GetNetInfo().NetsByNetcode() )
        netNames.emplace_back( UnescapeString( netInfo->GetNetname() ), netCode );
 
    std::sort( netNames.begin(), netNames.end(),
               []( const auto& a, const auto& b )
               {
                   return a.first.CmpNoCase( b.first ) < 0;
               } );
 
    for( const auto& [ netName, netCode ] : netNames )
        nets.Add( netName, netCode );
 
    auto netProperty = m_propMgr.GetProperty( TYPE_HASH( BOARD_CONNECTED_ITEM ), _HKI( "Net" ) );
    netProperty->SetChoices( nets );
 
    auto tuningNet = m_propMgr.GetProperty( TYPE_HASH( PCB_TUNING_PATTERN ), _HKI( "Net" ) );
    tuningNet->SetChoices( nets );
 
    auto stitchNet = m_propMgr.GetProperty( TYPE_HASH( PCB_VIA_STITCH ), _HKI( "Net" ) );
    stitchNet->SetChoices( nets );
 
    auto stitchGuardedNet = m_propMgr.GetProperty( TYPE_HASH( PCB_VIA_STITCH ), _HKI( "Guarded Net" ) );
    stitchGuardedNet->SetChoices( nets );
 
    // Drill spans come from the stackup rather than from an enum, and enumerating them costs a
    // walk of the board, so only a board that actually has a map pays for it
    if( aBoard->DrillSymbolLayers().any() )
    {
        wxPGChoices spans;
        spans.Add( _( "All spans" ), -1 );
 
        int index = 0;
 
        for( const DRILL_SPAN& span : EnumerateDrillSpans( *aBoard ) )
        {
            spans.Add( wxString::Format( wxT( "%s - %s%s" ),
                                         aBoard->GetLayerName( span.TopLayer() ),
                                         aBoard->GetLayerName( span.BottomLayer() ),
                                         span.m_IsBackdrill ? _( " (backdrill)" )
                                                            : wxString( wxEmptyString ) ),
                       index++ );
        }
 
        m_propMgr.GetProperty( TYPE_HASH( PCB_DRILL_MAP ), _HKI( "Hole Span" ) )
                ->SetChoices( spans );
    }
}
 
 
bool PCB_PROPERTIES_PANEL::getItemValue( EDA_ITEM* aItem, PROPERTY_BASE* aProperty, wxVariant& aValue )
{
    // For FOOTPRINT variant-aware boolean properties, return variant-specific values
    if( aItem->Type() == PCB_FOOTPRINT_T )
    {
        FOOTPRINT*      footprint = static_cast<FOOTPRINT*>( aItem );
        const wxString& propName = aProperty->Name();
        wxString        variantName;
 
        if( footprint->GetBoard() )
            variantName = footprint->GetBoard()->GetCurrentVariant();
 
        if( propName == _HKI( "Do not Populate" ) )
        {
            aValue = wxVariant( footprint->GetDNPForVariant( variantName ) );
            return true;
        }
        else if( propName == _HKI( "Exclude From Bill of Materials" ) )
        {
            aValue = wxVariant( footprint->GetExcludedFromBOMForVariant( variantName ) );
            return true;
        }
        else if( propName == _HKI( "Exclude From Simulation" ) )
        {
            aValue = wxVariant( footprint->GetExcludedFromSimForVariant( variantName ) );
            return true;
        }
        else if( propName == _HKI( "Exclude From Position Files" ) )
        {
            aValue = wxVariant( footprint->GetExcludedFromPosFilesForVariant( variantName ) );
            return true;
        }
    }
 
    return PROPERTIES_PANEL::getItemValue( aItem, aProperty, aValue );
}