dialog_fp_edit_pad_table.cpp

Go to the documentation of this file.

/*
 * 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 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
#include "dialog_fp_edit_pad_table.h"
 
#include <wx/button.h>
#include <wx/sizer.h>
#include <wx/dcclient.h>
#include <pcb_shape.h>
#include <widgets/wx_grid.h>
#include <widgets/grid_text_helpers.h>
#include <widgets/grid_combobox.h>
#include <base_units.h>
#include <units_provider.h>
#include <board.h>
#include <footprint.h>
#include <footprint_edit_frame.h>
 
 
// Helper to map shape string to PAD_SHAPE
static PAD_SHAPE ShapeFromString( const wxString& shape )
{
    if( shape == _( "Oval" ) ) return PAD_SHAPE::OVAL;
    if( shape == _( "Rectangle" ) ) return PAD_SHAPE::RECTANGLE;
    if( shape == _( "Trapezoid" ) ) return PAD_SHAPE::TRAPEZOID;
    if( shape == _( "Rounded rectangle" ) ) return PAD_SHAPE::ROUNDRECT;
    if( shape == _( "Chamfered rectangle" ) ) return PAD_SHAPE::CHAMFERED_RECT;
    if( shape == _( "Custom shape" ) ) return PAD_SHAPE::CUSTOM;
    return PAD_SHAPE::CIRCLE;
}
 
 
DIALOG_FP_EDIT_PAD_TABLE::DIALOG_FP_EDIT_PAD_TABLE( PCB_BASE_FRAME* aParent, FOOTPRINT* aFootprint ) :
        DIALOG_SHIM( (wxWindow*)aParent, wxID_ANY, _( "Pad Table" ), wxDefaultPosition, wxDefaultSize,
                     wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER ),
        m_grid( nullptr ),
        m_footprint( aFootprint ),
        m_unitsProvider( std::make_unique<UNITS_PROVIDER>( pcbIUScale, GetUserUnits() ) )
{
    wxBoxSizer* topSizer = new wxBoxSizer( wxVERTICAL );
 
    m_grid = new WX_GRID( this, wxID_ANY );
    m_grid->CreateGrid( 0, 11 );
    m_grid->SetColLabelValue( COL_NUMBER, _( "Number" ) );
    m_grid->SetColLabelValue( COL_TYPE,   _( "Type" ) );
    m_grid->SetColLabelValue( COL_SHAPE,  _( "Shape" ) );
    m_grid->SetColLabelValue( COL_POS_X,  _( "X Position" ) );
    m_grid->SetColLabelValue( COL_POS_Y,  _( "Y Position" ) );
    m_grid->SetColLabelValue( COL_SIZE_X, _( "Size X" ) );
    m_grid->SetColLabelValue( COL_SIZE_Y, _( "Size Y" ) );
    m_grid->SetColLabelValue( COL_DRILL_X, _( "Drill X" ) );
    m_grid->SetColLabelValue( COL_DRILL_Y, _( "Drill Y" ) );
    m_grid->SetColLabelValue( COL_P2D_LENGTH, _( "Pad->Die Length" ) );
    m_grid->SetColLabelValue( COL_P2D_DELAY, _( "Pad->Die Delay" ) );
    m_grid->EnableEditing( true );
 
    wxGridCellAttr* attr;
 
    // Type column editor (attribute)
    attr = new wxGridCellAttr;
    {
        wxArrayString typeNames;
        typeNames.push_back( _( "Through-hole" ) ); // PTH
        typeNames.push_back( _( "SMD" ) );          // SMD
        typeNames.push_back( _( "Connector" ) );    // CONN SMD? (use CONN?)
        typeNames.push_back( _( "NPTH" ) );         // NPTH
        typeNames.push_back( _( "Aperture" ) );     // inferred copper-less
        attr->SetEditor( new GRID_CELL_COMBOBOX( typeNames ) );
    }
    m_grid->SetColAttr( COL_TYPE, attr );
 
    attr = new wxGridCellAttr;
    wxArrayString shapeNames;
    shapeNames.push_back( _( "Circle" ) );
    shapeNames.push_back( _( "Oval" ) );
    shapeNames.push_back( _( "Rectangle" ) );
    shapeNames.push_back( _( "Trapezoid" ) );
    shapeNames.push_back( _( "Rounded rectangle" ) );
    shapeNames.push_back( _( "Chamfered rectangle" ) );
    shapeNames.push_back( _( "Custom shape" ) );
    attr->SetEditor( new GRID_CELL_COMBOBOX( shapeNames ) );
    m_grid->SetColAttr( COL_SHAPE, attr );
 
    attr = new wxGridCellAttr;
    attr->SetEditor( new GRID_CELL_TEXT_EDITOR() );
    m_grid->SetColAttr( COL_POS_X, attr );
 
    attr = new wxGridCellAttr;
    attr->SetEditor( new GRID_CELL_TEXT_EDITOR() );
    m_grid->SetColAttr( COL_POS_Y, attr );
 
    attr = new wxGridCellAttr;
    attr->SetEditor( new GRID_CELL_TEXT_EDITOR() );
    m_grid->SetColAttr( COL_SIZE_X, attr );
 
    attr = new wxGridCellAttr;
    attr->SetEditor( new GRID_CELL_TEXT_EDITOR() );
    m_grid->SetColAttr( COL_SIZE_Y, attr );
 
    // Drill X
    attr = new wxGridCellAttr;
    attr->SetEditor( new GRID_CELL_TEXT_EDITOR() );
    m_grid->SetColAttr( COL_DRILL_X, attr );
 
    // Drill Y
    attr = new wxGridCellAttr;
    attr->SetEditor( new GRID_CELL_TEXT_EDITOR() );
    m_grid->SetColAttr( COL_DRILL_Y, attr );
 
    // Pad->Die Length
    attr = new wxGridCellAttr;
    attr->SetEditor( new GRID_CELL_TEXT_EDITOR() );
    m_grid->SetColAttr( COL_P2D_LENGTH, attr );
 
    // Pad->Die Delay
    attr = new wxGridCellAttr;
    attr->SetEditor( new GRID_CELL_TEXT_EDITOR() );
    m_grid->SetColAttr( COL_P2D_DELAY, attr );
 
    m_grid->SetUnitsProvider( m_unitsProvider.get(), COL_POS_X );
    m_grid->SetUnitsProvider( m_unitsProvider.get(), COL_POS_Y );
    m_grid->SetUnitsProvider( m_unitsProvider.get(), COL_SIZE_X );
    m_grid->SetUnitsProvider( m_unitsProvider.get(), COL_SIZE_Y );
    m_grid->SetUnitsProvider( m_unitsProvider.get(), COL_DRILL_X );
    m_grid->SetUnitsProvider( m_unitsProvider.get(), COL_DRILL_Y );
    m_grid->SetAutoEvalCols( { COL_POS_X, COL_POS_Y, COL_SIZE_X, COL_SIZE_Y, COL_DRILL_X, COL_DRILL_Y } );
 
    topSizer->Add( m_grid, 1, wxEXPAND | wxALL, 5 );
 
    wxStdDialogButtonSizer* buttons = new wxStdDialogButtonSizer();
    buttons->AddButton( new wxButton( this, wxID_OK ) );
    buttons->AddButton( new wxButton( this, wxID_CANCEL ) );
    buttons->Realize();
    topSizer->Add( buttons, 0, wxALIGN_RIGHT | wxALL, 5 );
 
    SetSizerAndFit( topSizer );
 
    CaptureOriginalPadState();
    Populate();
 
    // Bind cell change handlers for real-time updates
    m_grid->Bind( wxEVT_GRID_CELL_CHANGED, &DIALOG_FP_EDIT_PAD_TABLE::OnCellChanged, this );
    m_grid->Bind( wxEVT_GRID_SELECT_CELL, &DIALOG_FP_EDIT_PAD_TABLE::OnSelectCell, this );
 
    // Listen for cancel
    Bind( wxEVT_BUTTON,
          [this]( wxCommandEvent& aEvt )
          {
              m_cancelled = true;
              aEvt.Skip();
          },
          wxID_CANCEL );
 
    finishDialogSettings();
}
 
 
DIALOG_FP_EDIT_PAD_TABLE::~DIALOG_FP_EDIT_PAD_TABLE()
{
    if( m_cancelled )
        RestoreOriginalPadState();
}
 
 
void DIALOG_FP_EDIT_PAD_TABLE::Populate()
{
    if( !m_footprint )
        return;
 
    int row = 0;
 
    for( PAD* pad : m_footprint->Pads() )
    {
        m_grid->AppendRows( 1 );
        m_grid->SetCellValue( row, COL_NUMBER, pad->GetNumber() );
 
        // Pad attribute to string
        wxString attrStr;
 
        switch( pad->GetAttribute() )
        {
        case PAD_ATTRIB::PTH:  attrStr = _( "Through-hole" ); break;
        case PAD_ATTRIB::SMD:  attrStr = _( "SMD" ); break;
        case PAD_ATTRIB::CONN: attrStr = _( "Connector" ); break;
        case PAD_ATTRIB::NPTH: attrStr = _( "NPTH" ); break;
        default: attrStr = _( "Through-hole" ); break;
        }
 
        VECTOR2I size = pad->GetSize( PADSTACK::ALL_LAYERS );
 
        if( pad->IsAperturePad() )
            attrStr = _( "Aperture" );
 
        m_grid->SetCellValue( row, COL_TYPE, attrStr );
        m_grid->SetCellValue( row, COL_SHAPE, pad->ShowPadShape( PADSTACK::ALL_LAYERS ) );
        m_grid->SetCellValue( row, COL_POS_X, m_unitsProvider->StringFromValue( pad->GetPosition().x, true ) );
        m_grid->SetCellValue( row, COL_POS_Y, m_unitsProvider->StringFromValue( pad->GetPosition().y, true ) );
        m_grid->SetCellValue( row, COL_SIZE_X, m_unitsProvider->StringFromValue( size.x, true ) );
        m_grid->SetCellValue( row, COL_SIZE_Y, m_unitsProvider->StringFromValue( size.y, true ) );
 
        // Drill values (only meaningful for PTH or NPTH). Leave empty otherwise.
        if( pad->GetAttribute() == PAD_ATTRIB::PTH || pad->GetAttribute() == PAD_ATTRIB::NPTH )
        {
            VECTOR2I drill = pad->GetDrillSize();
 
            if( drill.x > 0 )
                m_grid->SetCellValue( row, COL_DRILL_X, m_unitsProvider->StringFromValue( drill.x, true ) );
 
            if( drill.y > 0 )
                m_grid->SetCellValue( row, COL_DRILL_Y, m_unitsProvider->StringFromValue( drill.y, true ) );
        }
        else
        {
            // For non-PTH pads, drill columns are not applicable.
            m_grid->SetReadOnly( row, COL_DRILL_X, true );
            m_grid->SetReadOnly( row, COL_DRILL_Y, true );
        }
 
        // Pad to die metrics
        if( pad->GetPadToDieLength() )
            m_grid->SetCellValue( row, COL_P2D_LENGTH, m_unitsProvider->StringFromValue( pad->GetPadToDieLength(), true ) );
 
        if( pad->GetPadToDieDelay() )
            m_grid->SetCellValue( row, COL_P2D_DELAY, wxString::Format( "%d", pad->GetPadToDieDelay() ) );
 
        row++;
    }
 
    // Hide row labels per requirements
    m_grid->HideRowLabels();
 
    // Auto size the data columns first to get reasonable initial widths
    m_grid->AutoSizeColumns();
 
    // Ensure the Shape column (index 1) is wide enough for the longest translated
    // shape text plus the dropdown arrow / padding. We compute a max text width
    // using a device context and add a platform neutral padding.
    {
        wxClientDC dc( m_grid );
        dc.SetFont( m_grid->GetFont() );
 
        wxArrayString shapeNames;
        shapeNames.push_back( _( "Circle" ) );
        shapeNames.push_back( _( "Oval" ) );
        shapeNames.push_back( _( "Rectangle" ) );
        shapeNames.push_back( _( "Trapezoid" ) );
        shapeNames.push_back( _( "Rounded rectangle" ) );
        shapeNames.push_back( _( "Chamfered rectangle" ) );
        shapeNames.push_back( _( "Custom shape" ) );
 
        int maxWidth = 0;
 
        for( const wxString& str : shapeNames )
        {
            int w, h;
            dc.GetTextExtent( str, &w, &h );
            maxWidth = std::max( maxWidth, w );
        }
 
        // Add padding for internal cell margins + dropdown control.
        int padding = FromDIP( 30 ); // heuristic: 2*margin + arrow button
        m_grid->SetColSize( COL_SHAPE, maxWidth + padding );
    }
 
    // Record initial proportions for proportional resizing later.
    InitColumnProportions();
    Bind( wxEVT_SIZE, &DIALOG_FP_EDIT_PAD_TABLE::OnSize, this );
 
    // Run an initial proportional resize using current client size so columns
    // respect proportions immediately.
    wxSizeEvent sizeEvt( GetSize(), GetId() );
    CallAfter(
            [this, sizeEvt]
            {
                wxSizeEvent evt( sizeEvt );
                this->OnSize( evt );
            } );
 
    // If pads exist, select the first row to show initial highlight
    if( m_grid->GetNumberRows() > 0 )
    {
        m_grid->SetGridCursor( 0, 0 );
        // Construct event with required parameters (id, type, obj, row, col,...)
        wxGridEvent ev( m_grid->GetId(), wxEVT_GRID_SELECT_CELL, m_grid, 0, 0, -1, -1, true );
        OnSelectCell( ev );
    }
}
 
 
void DIALOG_FP_EDIT_PAD_TABLE::CaptureOriginalPadState()
{
    m_originalPads.clear();
    if( !m_footprint )
        return;
 
    for( PAD* pad : m_footprint->Pads() )
    {
        PAD_SNAPSHOT snap;
        snap.number        = pad->GetNumber();
        snap.shape         = pad->GetShape( PADSTACK::ALL_LAYERS );
        snap.position      = pad->GetPosition();
        snap.size          = pad->GetSize( PADSTACK::ALL_LAYERS );
        snap.attribute     = pad->GetAttribute();
        snap.drillSize     = pad->GetDrillSize();
        snap.padToDieLength= pad->GetPadToDieLength();
        snap.padToDieDelay = pad->GetPadToDieDelay();
        m_originalPads.push_back( snap );
    }
}
 
 
void DIALOG_FP_EDIT_PAD_TABLE::RestoreOriginalPadState()
{
    if( !m_footprint )
        return;
 
    size_t idx = 0;
    PCB_BASE_FRAME* base = dynamic_cast<PCB_BASE_FRAME*>( GetParent() );
    PCB_DRAW_PANEL_GAL* canvas = base ? base->GetCanvas() : nullptr;
 
    for( PAD* pad : m_footprint->Pads() )
    {
        if( idx >= m_originalPads.size() )
            break;
 
        const PAD_SNAPSHOT& snap = m_originalPads[idx++];
        pad->SetNumber( snap.number );
        pad->SetShape( PADSTACK::ALL_LAYERS, snap.shape );
        pad->SetAttribute( snap.attribute );
        pad->SetPosition( snap.position );
        pad->SetSize( PADSTACK::ALL_LAYERS, snap.size );
        pad->SetDrillSize( snap.drillSize );
        pad->SetPadToDieLength( snap.padToDieLength );
        pad->SetPadToDieDelay( snap.padToDieDelay );
        pad->ClearBrightened();
 
        if( canvas )
            canvas->GetView()->Update( pad, KIGFX::REPAINT );
    }
 
    if( canvas )
    {
        canvas->GetView()->MarkTargetDirty( KIGFX::TARGET_OVERLAY );
        canvas->ForceRefresh();
    }
}
 
 
bool DIALOG_FP_EDIT_PAD_TABLE::TransferDataFromWindow()
{
    if( !m_grid->CommitPendingChanges() )
        return false;
 
    if( !m_footprint )
        return true;
 
    int row = 0;
 
    for( PAD* pad : m_footprint->Pads() )
    {
    pad->SetNumber( m_grid->GetCellValue( row, COL_NUMBER ) );
 
        wxString typeStr = m_grid->GetCellValue( row, COL_TYPE );
 
        if( typeStr == _( "Through-hole" ) )
            pad->SetAttribute( PAD_ATTRIB::PTH );
        else if( typeStr == _( "SMD" ) )
            pad->SetAttribute( PAD_ATTRIB::SMD );
        else if( typeStr == _( "Connector" ) )
            pad->SetAttribute( PAD_ATTRIB::CONN );
        else if( typeStr == _( "NPTH" ) )
            pad->SetAttribute( PAD_ATTRIB::NPTH );
        // Aperture derived by copper-less layers; do not overwrite attribute here.
 
        wxString  shape = m_grid->GetCellValue( row, COL_SHAPE );
        PAD_SHAPE newShape = ShapeFromString( shape );
 
        pad->SetShape( PADSTACK::ALL_LAYERS, newShape );
 
        VECTOR2I pos;
        pos.x = m_grid->GetUnitValue( row, COL_POS_X );
        pos.y = m_grid->GetUnitValue( row, COL_POS_Y );
        pad->SetPosition( pos );
 
        VECTOR2I size;
        size.x = m_grid->GetUnitValue( row, COL_SIZE_X );
        size.y = m_grid->GetUnitValue( row, COL_SIZE_Y );
        pad->SetSize( PADSTACK::ALL_LAYERS, size );
 
        // Drill sizes (only if attribute allows)
        if( pad->GetAttribute() == PAD_ATTRIB::PTH || pad->GetAttribute() == PAD_ATTRIB::NPTH )
        {
            int dx = m_grid->GetUnitValue( row, COL_DRILL_X );
            int dy = m_grid->GetUnitValue( row, COL_DRILL_Y );
            if( dx > 0 || dy > 0 )
            {
                if( dx <= 0 ) dx = dy;
                if( dy <= 0 ) dy = dx;
                pad->SetDrillSize( { dx, dy } );
            }
        }
 
        // Pad->Die
        wxString delayStr = m_grid->GetCellValue( row, COL_P2D_DELAY );
        wxString lenStr = m_grid->GetCellValue( row, COL_P2D_LENGTH );
 
        if( !lenStr.IsEmpty() )
            pad->SetPadToDieLength( m_grid->GetUnitValue( row, COL_P2D_LENGTH ) );
        else
            pad->SetPadToDieLength( 0 );
 
        if( !delayStr.IsEmpty() )
        {
            long delayVal;
 
            if( delayStr.ToLong( &delayVal ) )
                pad->SetPadToDieDelay( (int) delayVal );
            else
                pad->SetPadToDieDelay( 0 );
        }
        else
            pad->SetPadToDieDelay( 0 );
 
        row++;
    }
 
    return true;
}
 
 
void DIALOG_FP_EDIT_PAD_TABLE::InitColumnProportions()
{
    m_colProportions.clear();
    m_minColWidths.clear();
 
    if( !m_grid )
        return;
 
    // Only consider the actual data columns (all of them since row labels are hidden)
    int cols = m_grid->GetNumberCols();
    int total = 0;
    std::vector<int> widths;
    widths.reserve( cols );
 
    for( int c = 0; c < cols; ++c )
    {
        int w = m_grid->GetColSize( c );
        widths.push_back( w );
        total += w;
    }
 
    if( total <= 0 )
        return;
 
    for( int w : widths )
    {
        m_colProportions.push_back( (double) w / (double) total );
        m_minColWidths.push_back( w );
    }
}
 
 
void DIALOG_FP_EDIT_PAD_TABLE::OnSize( wxSizeEvent& aEvent )
{
    if( m_colProportions.empty() )
    {
        aEvent.Skip();
        return;
    }
 
    // Compute available total width for columns and resize keeping proportions.
    int cols = m_grid->GetNumberCols();
    int available = 0;
 
    for( int c = 0; c < cols; ++c )
        available += m_grid->GetColSize( c );
 
    // Use client size of grid minus scrollbar estimate to better distribute.
    int clientW = m_grid->GetClientSize().x;
 
    if( clientW > 0 )
        available = clientW; // prefer actual client width
 
    int used = 0;
 
    for( int c = 0; c < cols; ++c )
    {
        int target = (int) std::round( m_colProportions[c] * available );
        target = std::max( target, m_minColWidths[c] );
 
        // Defer last column to absorb rounding diff.
        if( c == cols - 1 )
            target = std::max( available - used, m_minColWidths[c] );
 
        m_grid->SetColSize( c, target );
        used += target;
    }
 
    aEvent.Skip();
}
 
 
void DIALOG_FP_EDIT_PAD_TABLE::OnCellChanged( wxGridEvent& aEvent )
{
    int row = aEvent.GetRow();
    int col = aEvent.GetCol();
 
    if( !m_footprint )
        return;
 
    // row -> pad mapping is current order of Pads() iteration; rebuild each time (pads count small)
    int idx = 0;
    PAD* target = nullptr;
 
    for( PAD* pad : m_footprint->Pads() )
    {
        if( idx == row ) { target = pad; break; }
        ++idx;
    }
 
    if( !target )
        return;
    bool needCanvasRefresh = false;
 
    switch( col )
    {
    case COL_NUMBER:
        target->SetNumber( m_grid->GetCellValue( row, col ) );
        break;
 
    case COL_TYPE:
    {
        wxString typeStr = m_grid->GetCellValue( row, col );
        PAD_ATTRIB newAttr = target->GetAttribute();
 
        if( typeStr == _( "Through-hole" ) )
            newAttr = PAD_ATTRIB::PTH;
        else if( typeStr == _( "SMD" ) )
            newAttr = PAD_ATTRIB::SMD;
        else if( typeStr == _( "Connector" ) )
            newAttr = PAD_ATTRIB::CONN;
        else if( typeStr == _( "NPTH" ) )
            newAttr = PAD_ATTRIB::NPTH;
 
        if( newAttr != target->GetAttribute() )
        {
            target->SetAttribute( newAttr );
 
            // Toggle drill columns read-only state dynamically.
            bool drillsEditable = ( newAttr == PAD_ATTRIB::PTH || newAttr == PAD_ATTRIB::NPTH );
            m_grid->SetReadOnly( row, COL_DRILL_X, !drillsEditable );
            m_grid->SetReadOnly( row, COL_DRILL_Y, !drillsEditable );
            needCanvasRefresh = true;
        }
        break;
    }
 
    case COL_SHAPE:
        target->SetShape( PADSTACK::ALL_LAYERS, ShapeFromString( m_grid->GetCellValue( row, col ) ) );
        needCanvasRefresh = true;
        break;
 
    case COL_POS_X:
    case COL_POS_Y:
    {
        VECTOR2I pos = target->GetPosition();
 
        if( col == COL_POS_X )
            pos.x = m_grid->GetUnitValue( row, col );
        else
            pos.y = m_grid->GetUnitValue( row, col );
 
        target->SetPosition( pos );
        needCanvasRefresh = true;
        break;
    }
 
    case COL_SIZE_X:
    case COL_SIZE_Y:
    {
        VECTOR2I size = target->GetSize( PADSTACK::ALL_LAYERS );
 
        if( col == COL_SIZE_X )
            size.x = m_grid->GetUnitValue( row, col );
        else
            size.y = m_grid->GetUnitValue( row, col );
 
        target->SetSize( PADSTACK::ALL_LAYERS, size );
        needCanvasRefresh = true;
        break;
    }
 
    case COL_DRILL_X:
    case COL_DRILL_Y:
    {
        if( target->GetAttribute() == PAD_ATTRIB::PTH || target->GetAttribute() == PAD_ATTRIB::NPTH )
        {
            int dx = m_grid->GetUnitValue( row, COL_DRILL_X );
            int dy = m_grid->GetUnitValue( row, COL_DRILL_Y );
            if( dx > 0 || dy > 0 )
            {
                if( dx <= 0 ) dx = dy;
                if( dy <= 0 ) dy = dx;
                target->SetDrillSize( { dx, dy } );
                needCanvasRefresh = true;
            }
        }
        break;
    }
 
    case COL_P2D_LENGTH:
        if( !m_grid->GetCellValue( row, col ).IsEmpty() )
            target->SetPadToDieLength( m_grid->GetUnitValue( row, col ) );
        break;
 
    case COL_P2D_DELAY:
    {
        wxString d = m_grid->GetCellValue( row, col );
        long val;
 
        if( d.ToLong( &val ) )
            target->SetPadToDieDelay( (int) val );
        break;
    }
 
    default:
        break;
    }
 
    // Request redraw (simple approach)
    target->SetDirty();
 
    if( needCanvasRefresh )
    {
        if( PCB_BASE_FRAME* base = dynamic_cast<PCB_BASE_FRAME*>( GetParent() ) )
            base->GetCanvas()->ForceRefresh();
    }
}
 
 
void DIALOG_FP_EDIT_PAD_TABLE::OnSelectCell( wxGridEvent& aEvent )
{
    int row = aEvent.GetRow();
 
    if( !m_footprint )
        return;
 
    PCB_BASE_FRAME* base = dynamic_cast<PCB_BASE_FRAME*>( GetParent() );
    PCB_DRAW_PANEL_GAL* canvas = base ? base->GetCanvas() : nullptr;
 
    // Clear existing pad selections
    for( PAD* pad : m_footprint->Pads() )
    {
        if( pad->IsBrightened() )
        {
            pad->ClearBrightened();
 
            if( canvas )
                canvas->GetView()->Update( pad, KIGFX::REPAINT );
        }
    }
 
    int idx = 0;
 
    for( PAD* pad : m_footprint->Pads() )
    {
        if( idx == row )
        {
            pad->SetBrightened();
 
            if( canvas )
            {
                canvas->GetView()->Update( pad, KIGFX::REPAINT );
                canvas->ForceRefresh();
            }
 
            break;
        }
 
        ++idx;
    }
 
}