panel_packages_view.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2021 Andrew Lutsenko, anlutsenko at gmail dot com
 * Copyright (C) 1992-2024 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 "panel_packages_view.h"
#include <grid_tricks.h>
#include <widgets/html_window.h>
#include <pgm_base.h>
#include <kiplatform/ui.h>
#include <settings/common_settings.h>
#include <settings/kicad_settings.h>
#include <settings/settings_manager.h>
#include <string_utils.h>
#include <widgets/wx_panel.h>
#include <widgets/wx_splitter_window.h>
 
#include <cmath>
#include <fstream>
#include <wx/filedlg.h>
#include <wx/font.h>
#include <wx/tokenzr.h>
 
 
#define GRID_CELL_MARGIN 4
 
 
std::unordered_map<PCM_PACKAGE_VERSION_STATUS, wxString> PANEL_PACKAGES_VIEW::STATUS_ENUM_TO_STR = {
    { PVS_INVALID, wxS( "invalid" ) },
    { PVS_STABLE, wxS( "stable" ) },
    { PVS_TESTING, wxS( "testing" ) },
    { PVS_DEVELOPMENT, wxS( "development" ) },
    { PVS_DEPRECATED, wxS( "deprecated" ) }
};
 
 
PANEL_PACKAGES_VIEW::PANEL_PACKAGES_VIEW( wxWindow*                               parent,
                                          std::shared_ptr<PLUGIN_CONTENT_MANAGER> aPcm,
                                          const ActionCallback&                   aActionCallback,
                                          const PinCallback&                      aPinCallback ) :
        PANEL_PACKAGES_VIEW_BASE( parent ),
        m_actionCallback( aActionCallback ),
        m_pinCallback( aPinCallback ),
        m_pcm( aPcm )
{
    // Replace wxFormBuilder's sash initializer with one which will respect m_initialSashPos.
    m_splitter1->Disconnect( wxEVT_IDLE,
                             wxIdleEventHandler( PANEL_PACKAGES_VIEW_BASE::m_splitter1OnIdle ),
                             NULL, this );
    m_splitter1->Connect( wxEVT_IDLE, wxIdleEventHandler( PANEL_PACKAGES_VIEW::SetSashOnIdle ),
                          NULL, this );
 
    m_splitter1->SetPaneMinimums( FromDIP( 350 ), FromDIP( 450 ) );
 
#ifdef __WXGTK__
    // wxSearchCtrl vertical height is not calculated correctly on some GTK setups
    // See https://gitlab.com/kicad/code/kicad/-/issues/9019
    m_searchCtrl->SetMinSize( wxSize( -1, GetTextExtent( wxT( "qb" ) ).y + 10 ) );
#endif
 
    m_searchCtrl->Bind( wxEVT_TEXT, &PANEL_PACKAGES_VIEW::OnSearchTextChanged, this );
    m_searchCtrl->SetDescriptiveText( _( "Filter" ) );
 
    m_panelList->SetBorders( false, true, false, false );
 
    m_gridVersions->PushEventHandler( new GRID_TRICKS( m_gridVersions ) );
 
    for( int col = 0; col < m_gridVersions->GetNumberCols(); col++ )
    {
        const wxString& heading = m_gridVersions->GetColLabelValue( col );
        int             headingWidth = GetTextExtent( heading ).x + 2 * GRID_CELL_MARGIN;
 
        // Set the minimal width to the column label size.
        m_gridVersions->SetColMinimalWidth( col, headingWidth );
        m_gridVersions->SetColSize( col, m_gridVersions->GetVisibleWidth( col ) );
    }
 
    // Most likely should be changed to wxGridSelectNone once WxWidgets>=3.1.5 is mandatory.
    m_gridVersions->SetSelectionMode( WX_GRID::wxGridSelectRows );
 
    wxColor background = wxStaticText::GetClassDefaultAttributes().colBg;
    m_panelList->SetBackgroundColour( background );
    m_packageListWindow->SetBackgroundColour( background );
    m_infoScrollWindow->SetBackgroundColour( background );
    m_infoScrollWindow->EnableScrolling( false, true );
 
    ClearData();
}
 
 
PANEL_PACKAGES_VIEW::~PANEL_PACKAGES_VIEW()
{
    m_splitter1->Disconnect( wxEVT_IDLE, wxIdleEventHandler( PANEL_PACKAGES_VIEW::SetSashOnIdle ),
                             NULL, this );
 
    COMMON_SETTINGS* cfg = Pgm().GetCommonSettings();
    cfg->m_PackageManager.sash_pos = m_splitter1->GetSashPosition();
 
    m_gridVersions->PopEventHandler( true );
}
 
 
void PANEL_PACKAGES_VIEW::ClearData()
{
    unsetPackageDetails();
 
    m_currentSelected = nullptr;
    m_updateablePackages.clear();
    m_packagePanels.clear();
    m_packageInitialOrder.clear();
    m_packageListWindow->GetSizer()->Clear( true ); // Delete panels
    m_packageListWindow->GetSizer()->FitInside( m_packageListWindow );
    m_packageListWindow->Layout();
}
 
 
void PANEL_PACKAGES_VIEW::SetData( const std::vector<PACKAGE_VIEW_DATA>& aPackageData )
{
    ClearData();
 
    for( const PACKAGE_VIEW_DATA& data : aPackageData )
    {
        PANEL_PACKAGE* package_panel = new PANEL_PACKAGE( m_packageListWindow, m_actionCallback,
                                                          m_pinCallback, data );
 
        package_panel->SetSelectCallback(
                [package_panel, this] ()
                {
                    if( m_currentSelected && m_currentSelected != package_panel )
                        m_currentSelected->SetSelected( false );
 
                    package_panel->SetSelected( true );
                    m_currentSelected = package_panel;
                    setPackageDetails( package_panel->GetPackageData() );
 
                    Layout();
                } );
 
        m_packagePanels.insert( { data.package.identifier, package_panel } );
        m_packageInitialOrder.push_back( data.package.identifier );
 
        if( data.state == PPS_UPDATE_AVAILABLE && !data.pinned )
            m_updateablePackages.insert( data.package.identifier );
    }
 
    updatePackageList();
    updateCommonState();
}
 
 
void PANEL_PACKAGES_VIEW::setPackageDetails( const PACKAGE_VIEW_DATA& aPackageData )
{
    const PCM_PACKAGE& package = aPackageData.package;
 
    // Details
    wxString details;
 
    details << wxT( "<h5>" ) + package.name + wxT( "</h5>" );
 
    auto format_desc =
            []( const wxString& text ) -> wxString
            {
                wxString result;
                bool     inURL = false;
                wxString url;
 
                for( unsigned i = 0; i < text.length(); ++i )
                {
                    wxUniChar c = text[i];
 
                    if( inURL )
                    {
                        if( c == ' ' || c == '\n')
                        {
                            result += wxString::Format( wxT( "<a href='%s'>%s</a>" ), url, url );
                            inURL = false;
 
                            if( c == '\n' )
                                result += wxT( "</p><p>" );
                            else
                                result += c;
                        }
                        else
                        {
                            url += c;
                        }
                    }
                    else if( text.Mid( i, 5 ) == wxT( "http:" )
                                || text.Mid( i, 6 ) == wxT( "https:" ) )
                    {
                        url = c;
                        inURL = true;
                    }
                    else if( c == '\n' )
                    {
                        result += wxT( "</p><p>" );
                    }
                    else
                    {
                        result += c;
                    }
                }
 
                if( inURL )
                    result += wxString::Format( wxT( "<a href='%s'>%s</a>" ), url, url );
 
                return result;
            };
 
    wxString desc = package.description_full;
    details << wxT( "<p>" ) + format_desc( desc ) + wxT( "</p>" );
 
    details << wxT( "<p><b>" ) + _( "Metadata" ) + wxT( "</b></p>" );
    details << wxT( "<ul>" );
    details << wxT( "<li>" ) + _( "Package identifier: " ) + package.identifier + wxT( "</li>" );
    details << wxT( "<li>" ) + _( "License: " ) + package.license + wxT( "</li>" );
 
    if( package.tags.size() > 0 )
    {
        wxString tags_str;
 
        for( const std::string& tag : package.tags )
        {
            if( !tags_str.IsEmpty() )
                tags_str += ", ";
 
            tags_str += tag;
        }
 
        details << wxT( "<li>" ) + _( "Tags: " ) + tags_str + wxT( "</li>" );
    }
 
    auto format_entry =
            []( const std::pair<const std::string, wxString>& entry ) -> wxString
            {
                wxString name = entry.first;
                wxString url = EscapeHTML( entry.second );
 
                if( name == wxT( "email" ) )
                    return wxString::Format( wxT( "<a href='mailto:%s'>%s</a>" ), url, url );
                else if( url.StartsWith( wxT( "http:" ) ) || url.StartsWith( wxT( "https:" ) ) )
                    return wxString::Format( wxT( "<a href='%s'>%s</a>" ), url, url );
                else
                    return entry.second;
            };
 
    auto write_contact =
            [&]( const wxString& type, const PCM_CONTACT& contact )
            {
                details << wxT( "<li>" ) + type + wxT( ": " ) + contact.name + wxT( "<ul>" );
 
                for( const std::pair<const std::string, wxString>& entry : contact.contact )
                {
                    details << wxT( "<li>" );
                    details << entry.first << wxT( ": " ) + format_entry( entry );
                    details << wxT( "</li>" );
                }
 
                details << wxT( "</ul>" );
            };
 
    write_contact( _( "Author" ), package.author );
 
    if( package.maintainer )
        write_contact( _( "Maintainer" ), *package.maintainer );
 
    if( package.resources.size() > 0 )
    {
        details << wxT( "<li>" ) + _( "Resources" ) + wxT( "<ul>" );
 
        for( const std::pair<const std::string, wxString>& entry : package.resources )
        {
            details << wxT( "<li>" );
            details << entry.first << wxT( ": " );
            details << format_entry( entry ) + wxT( "</li>" );
        }
 
        details << wxT( "</ul>" );
    }
 
    details << wxT( "</ul>" );
 
    m_infoText->SetPage( details );
 
    wxSizeEvent dummy;
    OnSizeInfoBox( dummy );
 
    // Versions table
    m_gridVersions->Freeze();
 
    if( m_gridVersions->GetNumberRows() != 0 )
        m_gridVersions->DeleteRows( 0, m_gridVersions->GetNumberRows() );
 
    int      row = 0;
    wxString current_version;
 
    if( aPackageData.state == PPS_INSTALLED || aPackageData.state == PPS_UPDATE_AVAILABLE )
        current_version = m_pcm->GetInstalledPackageVersion( package.identifier );
 
    wxFont bold_font = m_gridVersions->GetDefaultCellFont().Bold();
 
    for( const PACKAGE_VERSION& version : package.versions )
    {
        if( !version.compatible && !m_showAllVersions->IsChecked() )
            continue;
 
        m_gridVersions->InsertRows( row );
 
        m_gridVersions->SetCellValue( row, COL_VERSION, version.version );
        m_gridVersions->SetCellValue( row, COL_DOWNLOAD_SIZE,
                                      toHumanReadableSize( version.download_size ) );
        m_gridVersions->SetCellValue( row, COL_INSTALL_SIZE,
                                      toHumanReadableSize( version.install_size ) );
        m_gridVersions->SetCellValue( row, COL_COMPATIBILITY,
                                      version.compatible ? wxT( "\u2714" ) : wxEmptyString );
        m_gridVersions->SetCellValue( row, COL_STATUS, STATUS_ENUM_TO_STR.at( version.status ) );
 
        m_gridVersions->SetCellAlignment( row, COL_COMPATIBILITY, wxALIGN_CENTER, wxALIGN_CENTER );
 
        if( current_version == version.version )
        {
            for( int col = 0; col < m_gridVersions->GetNumberCols(); col++ )
                m_gridVersions->SetCellFont( row, col, bold_font );
        }
 
        row++;
    }
 
    for( int col = 0; col < m_gridVersions->GetNumberCols(); col++ )
    {
        // Set the width to see the full contents
        m_gridVersions->SetColSize( col, m_gridVersions->GetVisibleWidth( col ) );
    }
 
    // Autoselect preferred or installed version
    if( m_gridVersions->GetNumberRows() >= 1 )
    {
        wxString version = m_currentSelected->GetPackageData().current_version;
 
        if( version.IsEmpty() )
            version = m_currentSelected->GetPreferredVersion();
 
        if( !version.IsEmpty() )
        {
            for( int i = 0; i < m_gridVersions->GetNumberRows(); i++ )
            {
                if( m_gridVersions->GetCellValue( i, COL_VERSION ) == version )
                {
                    m_gridVersions->SelectRow( i );
                    m_gridVersions->SetGridCursor( i, COL_VERSION );
                    break;
                }
            }
        }
        else
        {
            // Fall back to first row.
            m_gridVersions->SelectRow( 0 );
        }
    }
 
    m_gridVersions->Thaw();
 
    updateDetailsButtons();
 
    m_infoText->Show( true );
    m_sizerVersions->Show( true );
    m_sizerVersions->Layout();
 
    wxSize size = m_infoScrollWindow->GetTargetWindow()->GetBestVirtualSize();
    m_infoScrollWindow->SetVirtualSize( size );
}
 
 
void PANEL_PACKAGES_VIEW::unsetPackageDetails()
{
    m_infoText->SetPage( wxEmptyString );
    m_infoText->Show( false );
    m_sizerVersions->Show( false );
 
    wxSize size = m_infoScrollWindow->GetTargetWindow()->GetBestVirtualSize();
    m_infoScrollWindow->SetVirtualSize( size );
 
    // Clean up grid just so we don't keep stale info around (it's already been hidden).
    m_gridVersions->Freeze();
 
    if( m_gridVersions->GetNumberRows() > 0 )
        m_gridVersions->DeleteRows( 0, m_gridVersions->GetNumberRows() );
 
    m_gridVersions->Thaw();
}
 
 
wxString PANEL_PACKAGES_VIEW::toHumanReadableSize( const std::optional<uint64_t> size ) const
{
    if( !size )
        return wxT( "-" );
 
    uint64_t b = *size;
 
    if( b >= 1024 * 1024 )
        return wxString::Format( wxT( "%.1f MB" ), b / 1000.0 / 1000.0 );
 
    if( b >= 1024 )
        return wxString::Format( wxT( "%lld kB" ), b / 1000 );
 
    return wxString::Format( wxT( "%lld B" ), b );
}
 
 
bool PANEL_PACKAGES_VIEW::canDownload() const
{
    if( !m_currentSelected )
        return false;
 
    return m_gridVersions->GetNumberRows() == 1 || m_gridVersions->GetSelectedRows().size() == 1;
}
 
 
bool PANEL_PACKAGES_VIEW::canRunAction() const
{
    if( !m_currentSelected )
        return false;
 
    const PACKAGE_VIEW_DATA& packageData = m_currentSelected->GetPackageData();
 
    switch( packageData.state )
    {
    case PPS_PENDING_INSTALL:
    case PPS_PENDING_UNINSTALL:
    case PPS_PENDING_UPDATE: return false;
    default: break;
    }
 
    return m_gridVersions->GetNumberRows() == 1 || m_gridVersions->GetSelectedRows().size() == 1;
}
 
 
void PANEL_PACKAGES_VIEW::SetPackageState( const wxString&         aPackageId,
                                           const PCM_PACKAGE_STATE aState, const bool aPinned )
{
    auto it = m_packagePanels.find( aPackageId );
 
    if( it != m_packagePanels.end() )
    {
        it->second->SetState( aState, aPinned );
 
        if( m_currentSelected && m_currentSelected == it->second )
        {
            wxMouseEvent dummy;
            m_currentSelected->OnClick( dummy );
        }
 
        if( aState == PPS_UPDATE_AVAILABLE && !aPinned )
        {
            m_updateablePackages.insert( aPackageId );
        }
        else
        {
            m_updateablePackages.erase( aPackageId );
        }
 
        updateCommonState();
    }
}
 
 
void PANEL_PACKAGES_VIEW::OnVersionsCellClicked( wxGridEvent& event )
{
    m_gridVersions->ClearSelection();
    m_gridVersions->SelectRow( event.GetRow() );
 
    updateDetailsButtons();
}
 
 
void PANEL_PACKAGES_VIEW::OnDownloadVersionClicked( wxCommandEvent& event )
{
    if( !canDownload() )
    {
        wxBell();
        return;
    }
 
    if( m_gridVersions->GetNumberRows() == 1 )
        m_gridVersions->SelectRow( 0 );
 
    const wxArrayInt selectedRows = m_gridVersions->GetSelectedRows();
 
    wxString           version = m_gridVersions->GetCellValue( selectedRows[0], COL_VERSION );
    const PCM_PACKAGE& package = m_currentSelected->GetPackageData().package;
 
    auto ver_it = std::find_if( package.versions.begin(), package.versions.end(),
                                [&]( const PACKAGE_VERSION& ver )
                                {
                                    return ver.version == version;
                                } );
 
    wxASSERT_MSG( ver_it != package.versions.end(), "Could not find package version" );
 
    if( !ver_it->download_url )
    {
        wxMessageBox( _( "Package download url is not specified" ),
                      _( "Error downloading package" ), wxICON_INFORMATION | wxOK,
                      wxGetTopLevelParent( this ) );
        return;
    }
 
    const wxString& url = *ver_it->download_url;
 
    SETTINGS_MANAGER& mgr = Pgm().GetSettingsManager();
    KICAD_SETTINGS*   cfg = mgr.GetAppSettings<KICAD_SETTINGS>( "kicad" );
 
    wxWindow* topLevelParent = wxGetTopLevelParent( this );
    wxFileDialog dialog( topLevelParent, _( "Save Package" ), cfg->m_PcmLastDownloadDir,
                         wxString::Format( wxT( "%s_v%s.zip" ), package.identifier, version ),
                         wxT( "ZIP files (*.zip)|*.zip" ), wxFD_SAVE | wxFD_OVERWRITE_PROMPT );
 
    if( dialog.ShowModal() == wxID_CANCEL )
        return;
 
    wxString path = dialog.GetPath();
    cfg->m_PcmLastDownloadDir = wxPathOnly( path );
 
    std::ofstream output( path.ToUTF8(), std::ios_base::binary );
 
    std::unique_ptr<WX_PROGRESS_REPORTER> reporter =
            std::make_unique<WX_PROGRESS_REPORTER>( this, _( "Downloading package" ), 1 );
 
    bool success = m_pcm->DownloadToStream( url, &output, reporter.get(), 0 );
 
    output.close();
 
    if( success )
    {
        if( ver_it->download_sha256 )
        {
            std::ifstream stream( path.ToUTF8(), std::ios_base::binary );
 
            bool matches = m_pcm->VerifyHash( stream, *ver_it->download_sha256 );
 
            stream.close();
 
            if( !matches
                && wxMessageBox(
                           _( "Integrity of the downloaded package could not be verified, hash "
                              "does not match. Are you sure you want to keep this file?" ),
                           _( "Keep downloaded file" ), wxICON_EXCLAMATION | wxYES_NO,
                           wxGetTopLevelParent( this ) )
                           == wxNO )
            {
                wxRemoveFile( path );
            }
        }
    }
    else
    {
        if( wxFileExists( path ) )
            wxRemoveFile( path );
    }
}
 
 
void PANEL_PACKAGES_VIEW::OnVersionActionClicked( wxCommandEvent& event )
{
    if( !canRunAction() )
    {
        wxBell();
        return;
    }
 
    PCM_PACKAGE_ACTION action = getAction();
 
    if( action == PPA_UNINSTALL )
    {
        m_actionCallback( m_currentSelected->GetPackageData(), PPA_UNINSTALL,
                          m_currentSelected->GetPackageData().current_version );
        return;
    }
 
    if( m_gridVersions->GetNumberRows() == 1 )
        m_gridVersions->SelectRow( 0 );
 
    const wxArrayInt selectedRows = m_gridVersions->GetSelectedRows();
 
    wxString           version = m_gridVersions->GetCellValue( selectedRows[0], COL_VERSION );
    const PCM_PACKAGE& package = m_currentSelected->GetPackageData().package;
 
    auto ver_it = std::find_if( package.versions.begin(), package.versions.end(),
                                [&]( const PACKAGE_VERSION& ver )
                                {
                                    return ver.version == version;
                                } );
 
    wxCHECK_RET( ver_it != package.versions.end(), "Could not find package version" );
 
    if( !ver_it->compatible
        && wxMessageBox( _( "This package version is incompatible with your KiCad version or "
                            "platform. Are you sure you want to install it anyway?" ),
                         _( "Install package" ), wxICON_EXCLAMATION | wxYES_NO,
                         wxGetTopLevelParent( this ) )
                   == wxNO )
    {
        return;
    }
 
    m_actionCallback( m_currentSelected->GetPackageData(), action, version );
}
 
 
void PANEL_PACKAGES_VIEW::OnShowAllVersionsClicked( wxCommandEvent& event )
{
    if( m_currentSelected )
    {
        wxMouseEvent dummy;
        m_currentSelected->OnClick( dummy );
    }
 
    updateDetailsButtons();
}
 
 
void PANEL_PACKAGES_VIEW::OnSearchTextChanged( wxCommandEvent& event )
{
    unsetPackageDetails();
 
    if( m_currentSelected )
        m_currentSelected->SetSelected( false );
 
    m_currentSelected = nullptr;
 
    updatePackageList();
}
 
 
void PANEL_PACKAGES_VIEW::updatePackageList()
{
    // Sort by descending rank, ascending index
    std::vector<std::pair<int, int>> package_ranks;
 
    const wxString search_term = m_searchCtrl->GetValue().Trim();
 
    for( size_t index = 0; index < m_packageInitialOrder.size(); index++ )
    {
        int                rank = 1;
        const PCM_PACKAGE& pkg =
                m_packagePanels[m_packageInitialOrder[index]]->GetPackageData().package;
 
        if( search_term.size() > 2 )
            rank = m_pcm->GetPackageSearchRank( pkg, search_term );
 
        // Packages with no versions are delisted and should not be shown
        if( pkg.versions.size() == 0 )
            rank = 0;
 
        package_ranks.emplace_back( rank, index );
    }
 
    std::sort( package_ranks.begin(), package_ranks.end(),
               []( const std::pair<int, int>& a, const std::pair<int, int>& b )
               {
                   return a.first > b.first || ( a.first == b.first && a.second < b.second );
               } );
 
    // Rearrange panels, hide ones with 0 rank
    wxSizer* sizer = m_packageListWindow->GetSizer();
    sizer->Clear( false ); // Don't delete panels
 
    for( const std::pair<int, int>& pair : package_ranks )
    {
        PANEL_PACKAGE* panel = m_packagePanels[m_packageInitialOrder[pair.second]];
 
        if( pair.first > 0 )
        {
            sizer->Add( panel, 0, wxEXPAND );
            panel->Show();
        }
        else
        {
            panel->Hide();
        }
    }
 
    m_packageListWindow->FitInside();
    m_packageListWindow->SetScrollRate( 0, 15 );
    m_packageListWindow->SendSizeEvent( wxSEND_EVENT_POST );
}
 
 
void PANEL_PACKAGES_VIEW::updateDetailsButtons()
{
    m_buttonDownload->Enable( canDownload() );
 
    if( canRunAction() )
    {
        m_buttonAction->Enable();
 
        PCM_PACKAGE_ACTION action = getAction();
 
        switch( action )
        {
        case PPA_INSTALL: m_buttonAction->SetLabel( _( "Install" ) ); break;
        case PPA_UNINSTALL: m_buttonAction->SetLabel( _( "Uninstall" ) ); break;
        case PPA_UPDATE: m_buttonAction->SetLabel( _( "Update" ) ); break;
        }
    }
    else
    {
        m_buttonAction->Disable();
        m_buttonAction->SetLabel( _( "Pending" ) );
    }
}
 
 
PCM_PACKAGE_ACTION PANEL_PACKAGES_VIEW::getAction() const
{
    wxASSERT_MSG( m_gridVersions->GetNumberRows() == 1
                          || m_gridVersions->GetSelectedRows().size() == 1,
                  wxT( "getAction() called with ambiguous version selection" ) );
 
    int selected_row = 0;
 
    if( m_gridVersions->GetSelectedRows().size() == 1 )
        selected_row = m_gridVersions->GetSelectedRows()[0];
 
    wxString                 version = m_gridVersions->GetCellValue( selected_row, COL_VERSION );
    const PACKAGE_VIEW_DATA& package = m_currentSelected->GetPackageData();
 
    switch( package.state )
    {
    case PPS_AVAILABLE:
    case PPS_UNAVAILABLE:
        return PPA_INSTALL; // Only action for not installed package is to install it
    case PPS_INSTALLED:
    case PPS_UPDATE_AVAILABLE:
        if( version == package.current_version )
            return PPA_UNINSTALL;
        else
            return PPA_UPDATE;
    default:
        return PPA_INSTALL; // For pending states return value does not matter as button will be disabled
    }
}
 
 
void PANEL_PACKAGES_VIEW::OnSizeInfoBox( wxSizeEvent& aEvent )
{
    wxSize infoSize = KIPLATFORM::UI::GetUnobscuredSize( m_infoText->GetParent() );
    infoSize.x -= 10;
    m_infoText->SetMinSize( infoSize );
    m_infoText->SetMaxSize( infoSize );
    m_infoText->SetSize( infoSize );
    m_infoText->Layout();
 
    infoSize.y = m_infoText->GetInternalRepresentation()->GetHeight() + 12;
    m_infoText->SetMinSize( infoSize );
    m_infoText->SetMaxSize( infoSize );
    m_infoText->SetSize( infoSize );
    m_infoText->Layout();
 
    Refresh();
}
 
 
void PANEL_PACKAGES_VIEW::OnURLClicked( wxHtmlLinkEvent& aEvent )
{
    const wxHtmlLinkInfo& info = aEvent.GetLinkInfo();
    ::wxLaunchDefaultBrowser( info.GetHref() );
}
 
 
void PANEL_PACKAGES_VIEW::OnInfoMouseWheel( wxMouseEvent& event )
{
    // Transfer scrolling from the info window to its parent scroll window
    m_infoScrollWindow->HandleOnMouseWheel( event );
}
 
 
void PANEL_PACKAGES_VIEW::SetSashOnIdle( wxIdleEvent& aEvent )
{
    COMMON_SETTINGS* cfg = Pgm().GetCommonSettings();
    m_splitter1->SetSashPosition( cfg->m_PackageManager.sash_pos );
 
    m_packageListWindow->FitInside();
 
    m_splitter1->Disconnect( wxEVT_IDLE, wxIdleEventHandler( PANEL_PACKAGES_VIEW::SetSashOnIdle ),
                             NULL, this );
}
 
 
void PANEL_PACKAGES_VIEW::updateCommonState()
{
    m_buttonUpdateAll->Enable( m_updateablePackages.size() > 0 );
}
 
 
void PANEL_PACKAGES_VIEW::OnUpdateAllClicked( wxCommandEvent& event )
{
    // The map will be modified by the callback so we copy the list here
    std::vector<wxString> packages;
 
    std::copy( m_updateablePackages.begin(), m_updateablePackages.end(),
               std::back_inserter( packages ) );
 
    for( const wxString& pkg_id : packages )
    {
        auto it = m_packagePanels.find( pkg_id );
 
        if( it != m_packagePanels.end() )
        {
            const PACKAGE_VIEW_DATA& data = it->second->GetPackageData();
 
            m_actionCallback( data, PPA_UPDATE, data.update_version );
        }
    }
}