KiCad PCB EDA Suite
Loading...
Searching...
No Matches
panel_packages_view.cpp
Go to the documentation of this file.
1/*
2 * This program source code file is part of KiCad, a free EDA CAD application.
3 *
4 * Copyright (C) 2021 Andrew Lutsenko, anlutsenko at gmail dot com
5 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
6 *
7 * This program is free software: you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation, either version 3 of the License, or (at your
10 * option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful, but
13 * WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program. If not, see <http://www.gnu.org/licenses/>.
19 */
20
21#include "panel_packages_view.h"
22#include <grid_tricks.h>
23#include <widgets/html_window.h>
24#include <pgm_base.h>
25#include <kiplatform/ui.h>
29#include <string_utils.h>
30#include <widgets/wx_panel.h>
32
33#include <cmath>
34#include <fstream>
35#include <wx/filedlg.h>
36#include <wx/font.h>
37#include <wx/tokenzr.h>
38
39
40#define GRID_CELL_MARGIN 4
41
42
43std::unordered_map<PCM_PACKAGE_VERSION_STATUS, wxString> PANEL_PACKAGES_VIEW::STATUS_ENUM_TO_STR = {
44 { PVS_INVALID, wxS( "invalid" ) },
45 { PVS_STABLE, wxS( "stable" ) },
46 { PVS_TESTING, wxS( "testing" ) },
47 { PVS_DEVELOPMENT, wxS( "development" ) },
48 { PVS_DEPRECATED, wxS( "deprecated" ) }
49};
50
51
53 std::shared_ptr<PLUGIN_CONTENT_MANAGER> aPcm,
54 const ActionCallback& aActionCallback,
55 const PinCallback& aPinCallback ) :
57 m_actionCallback( aActionCallback ),
58 m_pinCallback( aPinCallback ),
59 m_pcm( aPcm )
60{
61 // Replace wxFormBuilder's sash initializer with one which will respect m_initialSashPos.
62 m_splitter1->Disconnect( wxEVT_IDLE,
64 NULL, this );
65 m_splitter1->Connect( wxEVT_IDLE, wxIdleEventHandler( PANEL_PACKAGES_VIEW::SetSashOnIdle ),
66 NULL, this );
67
68 m_splitter1->SetPaneMinimums( FromDIP( 350 ), FromDIP( 450 ) );
69
70#ifdef __WXGTK__
71 // wxSearchCtrl vertical height is not calculated correctly on some GTK setups
72 // See https://gitlab.com/kicad/code/kicad/-/issues/9019
73 m_searchCtrl->SetMinSize( wxSize( -1, GetTextExtent( wxT( "qb" ) ).y + 10 ) );
74#endif
75
77 m_searchCtrl->SetDescriptiveText( _( "Filter" ) );
78
79 m_panelList->SetBorders( false, true, false, false );
80
81 m_gridVersions->PushEventHandler( new GRID_TRICKS( m_gridVersions ) );
82
83 for( int col = 0; col < m_gridVersions->GetNumberCols(); col++ )
84 {
85 const wxString& heading = m_gridVersions->GetColLabelValue( col );
86 int headingWidth = GetTextExtent( heading ).x + 2 * GRID_CELL_MARGIN;
87
88 // Set the minimal width to the column label size.
89 m_gridVersions->SetColMinimalWidth( col, headingWidth );
90 m_gridVersions->SetColSize( col, m_gridVersions->GetVisibleWidth( col ) );
91 }
92
93 // Most likely should be changed to wxGridSelectNone once WxWidgets>=3.1.5 is mandatory.
94 m_gridVersions->SetSelectionMode( WX_GRID::wxGridSelectRows );
95
96 wxColor background = wxStaticText::GetClassDefaultAttributes().colBg;
97 m_panelList->SetBackgroundColour( background );
98 m_packageListWindow->SetBackgroundColour( background );
99 m_infoScrollWindow->SetBackgroundColour( background );
100 m_infoScrollWindow->EnableScrolling( false, true );
101
102 ClearData();
103}
104
105
107{
108 m_splitter1->Disconnect( wxEVT_IDLE, wxIdleEventHandler( PANEL_PACKAGES_VIEW::SetSashOnIdle ),
109 NULL, this );
110
112 cfg->m_PackageManager.sash_pos = m_splitter1->GetSashPosition();
113
114 m_gridVersions->PopEventHandler( true );
115}
116
117
119{
121
122 m_currentSelected = nullptr;
123 m_updateablePackages.clear();
124 m_packagePanels.clear();
125 m_packageInitialOrder.clear();
126 m_packageListWindow->GetSizer()->Clear( true ); // Delete panels
127 m_packageListWindow->GetSizer()->FitInside( m_packageListWindow );
128 m_packageListWindow->Layout();
129}
130
131
132void PANEL_PACKAGES_VIEW::SetData( const std::vector<PACKAGE_VIEW_DATA>& aPackageData )
133{
134 ClearData();
135
136 for( const PACKAGE_VIEW_DATA& data : aPackageData )
137 {
139 m_pinCallback, data );
140
141 package_panel->SetSelectCallback(
142 [package_panel, this] ()
143 {
144 if( m_currentSelected && m_currentSelected != package_panel )
146
147 package_panel->SetSelected( true );
148 m_currentSelected = package_panel;
149 setPackageDetails( package_panel->GetPackageData() );
150
151 Layout();
152 } );
153
154 m_packagePanels.insert( { data.package.identifier, package_panel } );
155 m_packageInitialOrder.push_back( data.package.identifier );
156
157 if( data.state == PPS_UPDATE_AVAILABLE && !data.pinned )
158 m_updateablePackages.insert( data.package.identifier );
159 }
160
163}
164
165
167{
168 const PCM_PACKAGE& package = aPackageData.package;
169
170 // Details
171 wxString details;
172
173 details << wxT( "<h5>" ) + package.name + wxT( "</h5>" );
174
175 auto format_desc =
176 []( const wxString& text ) -> wxString
177 {
178 wxString result;
179 bool inURL = false;
180 wxString url;
181
182 for( unsigned i = 0; i < text.length(); ++i )
183 {
184 wxUniChar c = text[i];
185
186 if( inURL )
187 {
188 if( c == ' ' || c == '\n')
189 {
190 result += wxString::Format( wxT( "<a href='%s'>%s</a>" ), url, url );
191 inURL = false;
192
193 if( c == '\n' )
194 result += wxT( "</p><p>" );
195 else
196 result += c;
197 }
198 else
199 {
200 url += c;
201 }
202 }
203 else if( text.Mid( i, 5 ) == wxT( "http:" )
204 || text.Mid( i, 6 ) == wxT( "https:" ) )
205 {
206 url = c;
207 inURL = true;
208 }
209 else if( c == '\n' )
210 {
211 result += wxT( "</p><p>" );
212 }
213 else
214 {
215 result += c;
216 }
217 }
218
219 if( inURL )
220 result += wxString::Format( wxT( "<a href='%s'>%s</a>" ), url, url );
221
222 return result;
223 };
224
225 wxString desc = package.description_full;
226 details << wxT( "<p>" ) + format_desc( desc ) + wxT( "</p>" );
227
228 details << wxT( "<p><b>" ) + _( "Metadata" ) + wxT( "</b></p>" );
229 details << wxT( "<ul>" );
230 details << wxT( "<li>" ) + _( "Package identifier: " ) + package.identifier + wxT( "</li>" );
231 details << wxT( "<li>" ) + _( "License: " ) + package.license + wxT( "</li>" );
232
233 if( package.tags.size() > 0 )
234 {
235 wxString tags_str;
236
237 for( const std::string& tag : package.tags )
238 {
239 if( !tags_str.IsEmpty() )
240 tags_str += ", ";
241
242 tags_str += tag;
243 }
244
245 details << wxT( "<li>" ) + _( "Tags: " ) + tags_str + wxT( "</li>" );
246 }
247
248 auto format_entry =
249 []( const std::pair<const std::string, wxString>& entry ) -> wxString
250 {
251 wxString name = entry.first;
252 wxString url = EscapeHTML( entry.second );
253
254 if( name == wxT( "email" ) )
255 return wxString::Format( wxT( "<a href='mailto:%s'>%s</a>" ), url, url );
256 else if( url.StartsWith( wxT( "http:" ) ) || url.StartsWith( wxT( "https:" ) ) )
257 return wxString::Format( wxT( "<a href='%s'>%s</a>" ), url, url );
258 else
259 return entry.second;
260 };
261
262 auto write_contact =
263 [&]( const wxString& type, const PCM_CONTACT& contact )
264 {
265 details << wxT( "<li>" ) + type + wxT( ": " ) + contact.name + wxT( "<ul>" );
266
267 for( const std::pair<const std::string, wxString>& entry : contact.contact )
268 {
269 details << wxT( "<li>" );
270 details << entry.first << wxT( ": " ) + format_entry( entry );
271 details << wxT( "</li>" );
272 }
273
274 details << wxT( "</ul>" );
275 };
276
277 write_contact( _( "Author" ), package.author );
278
279 if( package.maintainer )
280 write_contact( _( "Maintainer" ), *package.maintainer );
281
282 if( package.resources.size() > 0 )
283 {
284 details << wxT( "<li>" ) + _( "Resources" ) + wxT( "<ul>" );
285
286 for( const std::pair<const std::string, wxString>& entry : package.resources )
287 {
288 details << wxT( "<li>" );
289 details << entry.first << wxT( ": " );
290 details << format_entry( entry ) + wxT( "</li>" );
291 }
292
293 details << wxT( "</ul>" );
294 }
295
296 details << wxT( "</ul>" );
297
298 m_infoText->SetPage( details );
299
300 wxSizeEvent dummy;
301 OnSizeInfoBox( dummy );
302
303 // Versions table
304 m_gridVersions->Freeze();
305
306 if( m_gridVersions->GetNumberRows() != 0 )
307 m_gridVersions->DeleteRows( 0, m_gridVersions->GetNumberRows() );
308
309 int row = 0;
310 wxString current_version;
311
312 if( aPackageData.state == PPS_INSTALLED || aPackageData.state == PPS_UPDATE_AVAILABLE )
313 current_version = m_pcm->GetInstalledPackageVersion( package.identifier );
314
315 wxFont bold_font = m_gridVersions->GetDefaultCellFont().Bold();
316
317 for( const PACKAGE_VERSION& version : package.versions )
318 {
319 if( !version.compatible && !m_showAllVersions->IsChecked() )
320 continue;
321
322 m_gridVersions->InsertRows( row );
323
324 m_gridVersions->SetCellValue( row, COL_VERSION, version.version );
325 m_gridVersions->SetCellValue( row, COL_DOWNLOAD_SIZE, toHumanReadableSize( version.download_size ) );
326 m_gridVersions->SetCellValue( row, COL_INSTALL_SIZE, toHumanReadableSize( version.install_size ) );
327 m_gridVersions->SetCellValue( row, COL_COMPATIBILITY, version.compatible ? wxT( "\u2714" ) : wxEmptyString );
328 m_gridVersions->SetCellValue( row, COL_STATUS, STATUS_ENUM_TO_STR.at( version.status ) );
329
330 m_gridVersions->SetCellAlignment( row, COL_COMPATIBILITY, wxALIGN_CENTER, wxALIGN_CENTER );
331
332 if( current_version == version.version )
333 {
334 for( int col = 0; col < m_gridVersions->GetNumberCols(); col++ )
335 m_gridVersions->SetCellFont( row, col, bold_font );
336 }
337
338 row++;
339 }
340
341 for( int col = 0; col < m_gridVersions->GetNumberCols(); col++ )
342 {
343 // Set the width to see the full contents
344 m_gridVersions->SetColSize( col, m_gridVersions->GetVisibleWidth( col ) );
345 }
346
347 // Autoselect preferred or installed version
348 if( m_gridVersions->GetNumberRows() >= 1 )
349 {
350 wxString version = m_currentSelected->GetPackageData().current_version;
351
352 if( version.IsEmpty() )
353 version = m_currentSelected->GetPreferredVersion();
354
355 if( !version.IsEmpty() )
356 {
357 for( int i = 0; i < m_gridVersions->GetNumberRows(); i++ )
358 {
359 if( m_gridVersions->GetCellValue( i, COL_VERSION ) == version )
360 {
361 m_gridVersions->SelectRow( i );
362 m_gridVersions->SetGridCursor( i, COL_VERSION );
363 break;
364 }
365 }
366 }
367 else
368 {
369 // Fall back to first row.
370 m_gridVersions->SelectRow( 0 );
371 }
372 }
373
374 m_gridVersions->Thaw();
375
376 updateDetailsButtons();
377
378 m_infoText->Show( true );
379 m_sizerVersions->Show( true );
380 m_sizerVersions->Layout();
381
382 wxSize size = m_infoScrollWindow->GetTargetWindow()->GetBestVirtualSize();
383 m_infoScrollWindow->SetVirtualSize( size );
384}
385
386
388{
389 m_infoText->SetPage( wxEmptyString );
390 m_infoText->Show( false );
391 m_sizerVersions->Show( false );
392
393 wxSize size = m_infoScrollWindow->GetTargetWindow()->GetBestVirtualSize();
394 m_infoScrollWindow->SetVirtualSize( size );
395
396 // Clean up grid just so we don't keep stale info around (it's already been hidden).
397 m_gridVersions->Freeze();
398
399 if( m_gridVersions->GetNumberRows() > 0 )
400 m_gridVersions->DeleteRows( 0, m_gridVersions->GetNumberRows() );
401
402 m_gridVersions->Thaw();
403}
404
405
406wxString PANEL_PACKAGES_VIEW::toHumanReadableSize( const std::optional<uint64_t> size ) const
407{
408 if( !size )
409 return wxT( "-" );
410
411 uint64_t b = *size;
412
413 if( b >= 1024 * 1024 )
414 return wxString::Format( wxT( "%.1f MB" ), b / 1000.0 / 1000.0 );
415
416 if( b >= 1024 )
417 return wxString::Format( wxT( "%lld kB" ), b / 1000 );
418
419 return wxString::Format( wxT( "%lld B" ), b );
420}
421
422
424{
425 if( !m_currentSelected )
426 return false;
427
428 return m_gridVersions->GetNumberRows() == 1 || m_gridVersions->GetSelectedRows().size() == 1;
429}
430
431
433{
434 if( !m_currentSelected )
435 return false;
436
437 const PACKAGE_VIEW_DATA& packageData = m_currentSelected->GetPackageData();
438
439 switch( packageData.state )
440 {
443 case PPS_PENDING_UPDATE: return false;
444 default: break;
445 }
446
447 return m_gridVersions->GetNumberRows() == 1 || m_gridVersions->GetSelectedRows().size() == 1;
448}
449
450
451void PANEL_PACKAGES_VIEW::SetPackageState( const wxString& aPackageId, const PCM_PACKAGE_STATE aState,
452 const bool aPinned )
453{
454 auto it = m_packagePanels.find( aPackageId );
455
456 if( it != m_packagePanels.end() )
457 {
458 it->second->SetState( aState, aPinned );
459
460 if( m_currentSelected && m_currentSelected == it->second )
461 {
462 wxMouseEvent dummy;
464 }
465
466 if( aState == PPS_UPDATE_AVAILABLE && !aPinned )
467 m_updateablePackages.insert( aPackageId );
468 else
469 m_updateablePackages.erase( aPackageId );
470
472 }
473}
474
475
477{
478 m_gridVersions->ClearSelection();
479 m_gridVersions->SelectRow( event.GetRow() );
480
482}
483
484
486{
487 if( !canDownload() )
488 {
489 wxBell();
490 return;
491 }
492
493 if( m_gridVersions->GetNumberRows() == 1 )
494 m_gridVersions->SelectRow( 0 );
495
496 const wxArrayInt selectedRows = m_gridVersions->GetSelectedRows();
497
498 wxString version = m_gridVersions->GetCellValue( selectedRows[0], COL_VERSION );
499 const PCM_PACKAGE& package = m_currentSelected->GetPackageData().package;
500
501 auto ver_it = std::find_if( package.versions.begin(), package.versions.end(),
502 [&]( const PACKAGE_VERSION& ver )
503 {
504 return ver.version == version;
505 } );
506
507 wxASSERT_MSG( ver_it != package.versions.end(), "Could not find package version" );
508
509 if( !ver_it->download_url )
510 {
511 wxMessageBox( _( "Package download url is not specified" ), _( "Error downloading package" ),
512 wxICON_INFORMATION | wxOK, wxGetTopLevelParent( this ) );
513 return;
514 }
515
516 const wxString& url = *ver_it->download_url;
517 KICAD_SETTINGS* cfg = GetAppSettings<KICAD_SETTINGS>( "kicad" );
518
519 wxWindow* topLevelParent = wxGetTopLevelParent( this );
520 wxFileDialog dialog( topLevelParent, _( "Save Package" ), cfg->m_PcmLastDownloadDir,
521 wxString::Format( wxT( "%s_v%s.zip" ), package.identifier, version ),
522 wxT( "ZIP files (*.zip)|*.zip" ), wxFD_SAVE | wxFD_OVERWRITE_PROMPT );
523
524 if( dialog.ShowModal() == wxID_CANCEL )
525 return;
526
527 wxString path = dialog.GetPath();
528 cfg->m_PcmLastDownloadDir = wxPathOnly( path );
529
530 std::ofstream output( path.ToUTF8(), std::ios_base::binary );
531
532 WX_PROGRESS_REPORTER reporter( this, _( "Download Package" ), 1, PR_CAN_ABORT );
533
534 bool success = m_pcm->DownloadToStream( url, &output, &reporter, 0 );
535
536 output.close();
537
538 if( success )
539 {
540 if( ver_it->download_sha256 )
541 {
542 std::ifstream stream( path.ToUTF8(), std::ios_base::binary );
543
544 bool matches = m_pcm->VerifyHash( stream, *ver_it->download_sha256 );
545
546 stream.close();
547
548 if( !matches && wxMessageBox( _( "Integrity of the downloaded package could not be verified, hash "
549 "does not match. Are you sure you want to keep this file?" ),
550 _( "Keep downloaded file" ), wxICON_EXCLAMATION | wxYES_NO,
551 wxGetTopLevelParent( this ) )
552 == wxNO )
553 {
554 wxRemoveFile( path );
555 }
556 }
557 }
558 else
559 {
560 if( wxFileExists( path ) )
561 wxRemoveFile( path );
562 }
563}
564
565
567{
568 if( !canRunAction() )
569 {
570 wxBell();
571 return;
572 }
573
574 PCM_PACKAGE_ACTION action = getAction();
575
576 if( action == PPA_UNINSTALL )
577 {
580 return;
581 }
582
583 if( m_gridVersions->GetNumberRows() == 1 )
584 m_gridVersions->SelectRow( 0 );
585
586 const wxArrayInt selectedRows = m_gridVersions->GetSelectedRows();
587
588 wxString version = m_gridVersions->GetCellValue( selectedRows[0], COL_VERSION );
589 const PCM_PACKAGE& package = m_currentSelected->GetPackageData().package;
590
591 auto ver_it = std::find_if( package.versions.begin(), package.versions.end(),
592 [&]( const PACKAGE_VERSION& ver )
593 {
594 return ver.version == version;
595 } );
596
597 wxCHECK_RET( ver_it != package.versions.end(), "Could not find package version" );
598
599 if( !ver_it->compatible && wxMessageBox( _( "This package version is incompatible with your KiCad version or "
600 "platform. Are you sure you want to install it anyway?" ),
601 _( "Install package" ), wxICON_EXCLAMATION | wxYES_NO,
602 wxGetTopLevelParent( this ) )
603 == wxNO )
604 {
605 return;
606 }
607
608 m_actionCallback( m_currentSelected->GetPackageData(), action, version );
609}
610
611
613{
615 {
616 wxMouseEvent dummy;
618 }
619
621}
622
623
624void PANEL_PACKAGES_VIEW::OnSearchTextChanged( wxCommandEvent& event )
625{
627
630
631 m_currentSelected = nullptr;
632
634}
635
636
638{
639 // Sort by descending rank, ascending index
640 std::vector<std::pair<int, int>> package_ranks;
641
642 const wxString search_term = m_searchCtrl->GetValue().Trim();
643
644 for( size_t index = 0; index < m_packageInitialOrder.size(); index++ )
645 {
646 int rank = 1;
647 const PCM_PACKAGE& pkg = m_packagePanels[m_packageInitialOrder[index]]->GetPackageData().package;
648
649 if( search_term.size() > 2 )
650 rank = m_pcm->GetPackageSearchRank( pkg, search_term );
651
652 // Packages with no versions are delisted and should not be shown
653 if( pkg.versions.size() == 0 )
654 rank = 0;
655
656 package_ranks.emplace_back( rank, index );
657 }
658
659 std::sort( package_ranks.begin(), package_ranks.end(),
660 []( const std::pair<int, int>& a, const std::pair<int, int>& b )
661 {
662 return a.first > b.first || ( a.first == b.first && a.second < b.second );
663 } );
664
665 // Rearrange panels, hide ones with 0 rank
666 wxSizer* sizer = m_packageListWindow->GetSizer();
667 sizer->Clear( false ); // Don't delete panels
668
669 for( const std::pair<int, int>& pair : package_ranks )
670 {
672
673 if( pair.first > 0 )
674 {
675 sizer->Add( panel, 0, wxEXPAND );
676 panel->Show();
677
678 if( !m_currentSelected )
679 {
680 wxMouseEvent dummy;
681 panel->OnClick( dummy );
682 }
683 }
684 else
685 {
686 panel->Hide();
687 }
688 }
689
690 m_packageListWindow->FitInside();
691 m_packageListWindow->SetScrollRate( 0, 15 );
692 m_packageListWindow->SendSizeEvent( wxSEND_EVENT_POST );
693}
694
695
697{
698 m_buttonDownload->Enable( canDownload() );
699
700 if( canRunAction() )
701 {
702 m_buttonAction->Enable();
703
704 PCM_PACKAGE_ACTION action = getAction();
705
706 switch( action )
707 {
708 case PPA_INSTALL: m_buttonAction->SetLabel( _( "Install" ) ); break;
709 case PPA_UNINSTALL: m_buttonAction->SetLabel( _( "Uninstall" ) ); break;
710 case PPA_UPDATE: m_buttonAction->SetLabel( _( "Update" ) ); break;
711 }
712 }
713 else
714 {
715 m_buttonAction->Disable();
716 m_buttonAction->SetLabel( _( "Pending" ) );
717 }
718}
719
720
722{
723 wxASSERT_MSG( m_gridVersions->GetNumberRows() == 1 || m_gridVersions->GetSelectedRows().size() == 1,
724 wxT( "getAction() called with ambiguous version selection" ) );
725
726 int selected_row = 0;
727
728 if( m_gridVersions->GetSelectedRows().size() == 1 )
729 selected_row = m_gridVersions->GetSelectedRows()[0];
730
731 wxString version = m_gridVersions->GetCellValue( selected_row, COL_VERSION );
732 const PACKAGE_VIEW_DATA& package = m_currentSelected->GetPackageData();
733
734 switch( package.state )
735 {
736 case PPS_AVAILABLE:
737 case PPS_UNAVAILABLE:
738 return PPA_INSTALL; // Only action for not installed package is to install it
739 case PPS_INSTALLED:
741 if( version == package.current_version )
742 return PPA_UNINSTALL;
743 else
744 return PPA_UPDATE;
745 default:
746 return PPA_INSTALL; // For pending states return value does not matter as button will be disabled
747 }
748}
749
750
751void PANEL_PACKAGES_VIEW::OnSizeInfoBox( wxSizeEvent& aEvent )
752{
753 wxSize infoSize = KIPLATFORM::UI::GetUnobscuredSize( m_infoText->GetParent() );
754 infoSize.x -= 10;
755 m_infoText->SetMinSize( infoSize );
756 m_infoText->SetMaxSize( infoSize );
757 m_infoText->SetSize( infoSize );
758 m_infoText->Layout();
759
760 infoSize.y = m_infoText->GetInternalRepresentation()->GetHeight() + 12;
761 m_infoText->SetMinSize( infoSize );
762 m_infoText->SetMaxSize( infoSize );
763 m_infoText->SetSize( infoSize );
764 m_infoText->Layout();
765
766 Refresh();
767}
768
769
770void PANEL_PACKAGES_VIEW::OnURLClicked( wxHtmlLinkEvent& aEvent )
771{
772 const wxHtmlLinkInfo& info = aEvent.GetLinkInfo();
773 ::wxLaunchDefaultBrowser( info.GetHref() );
774}
775
776
777void PANEL_PACKAGES_VIEW::OnInfoMouseWheel( wxMouseEvent& event )
778{
779 // Transfer scrolling from the info window to its parent scroll window
780 m_infoScrollWindow->HandleOnMouseWheel( event );
781}
782
783
784void PANEL_PACKAGES_VIEW::SetSashOnIdle( wxIdleEvent& aEvent )
785{
787 m_splitter1->SetSashPosition( cfg->m_PackageManager.sash_pos );
788
789 m_packageListWindow->FitInside();
790
791 m_splitter1->Disconnect( wxEVT_IDLE, wxIdleEventHandler( PANEL_PACKAGES_VIEW::SetSashOnIdle ), nullptr, this );
792}
793
794
796{
797 m_buttonUpdateAll->Enable( m_updateablePackages.size() > 0 );
798}
799
800
801void PANEL_PACKAGES_VIEW::OnUpdateAllClicked( wxCommandEvent& event )
802{
803 // The map will be modified by the callback so we copy the list here
804 std::vector<wxString> packages;
805
806 std::copy( m_updateablePackages.begin(), m_updateablePackages.end(), std::back_inserter( packages ) );
807
808 for( const wxString& pkg_id : packages )
809 {
810 auto it = m_packagePanels.find( pkg_id );
811
812 if( it != m_packagePanels.end() )
813 {
814 const PACKAGE_VIEW_DATA& data = it->second->GetPackageData();
815
817 }
818 }
819}
const char * name
Definition: DXF_plotter.cpp:62
PACKAGE_MANAGER m_PackageManager
Add mouse and command handling (such as cut, copy, and paste) to a WX_GRID instance.
Definition: grid_tricks.h:61
bool SetPage(const wxString &aSource) override
Definition: html_window.cpp:50
wxString m_PcmLastDownloadDir
Class PANEL_PACKAGES_VIEW_BASE.
WX_SPLITTER_WINDOW * m_splitter1
wxScrolledWindow * m_packageListWindow
void m_splitter1OnIdle(wxIdleEvent &)
wxScrolledWindow * m_infoScrollWindow
void OnInfoMouseWheel(wxMouseEvent &event) override
Replacement of wxFormBuilder's ill-advised m_splitter1OnIdle.
std::unordered_set< wxString > m_updateablePackages
void OnUpdateAllClicked(wxCommandEvent &event) override
void ClearData()
Selects full row of the clicked cell.
void updateDetailsButtons()
Called when package state changes, currently used to calculate Update All button state.
void OnVersionActionClicked(wxCommandEvent &event) override
Shows all versions including incompatible ones.
void OnSizeInfoBox(wxSizeEvent &aEvent) override
Respond to a URL in the info window.
bool canDownload() const
Returns true if the package action can be performed.
void OnDownloadVersionClicked(wxCommandEvent &event) override
Schedules relevant action for selected package version.
wxString toHumanReadableSize(const std::optional< uint64_t > size) const
Returns true if it the download operation can be performed.
void OnSearchTextChanged(wxCommandEvent &event)
void updateCommonState()
Updates details panel.
void updatePackageList()
< Updates package listing according to search term
const ActionCallback & m_actionCallback
std::unordered_map< wxString, PANEL_PACKAGE * > m_packagePanels
void setPackageDetails(const PACKAGE_VIEW_DATA &aPackageData)
Clears details panel.
const PinCallback & m_pinCallback
std::shared_ptr< PLUGIN_CONTENT_MANAGER > m_pcm
PCM_PACKAGE_ACTION getAction() const
bool canRunAction() const
Returns implied action for the action button.
PANEL_PACKAGE * m_currentSelected
void unsetPackageDetails()
Bytes to Kb/Mb/Gb string or "-" if absent.
void SetData(const std::vector< PACKAGE_VIEW_DATA > &aPackageData)
Recreates package panels and displays data.
void OnVersionsCellClicked(wxGridEvent &event) override
Opens file chooser dialog and downloads selected package version archive.
void OnURLClicked(wxHtmlLinkEvent &event) override
Respond to scrolling over the window.
void SetSashOnIdle(wxIdleEvent &)
Enqueues all available package updates.
static std::unordered_map< PCM_PACKAGE_VERSION_STATUS, wxString > STATUS_ENUM_TO_STR
void SetPackageState(const wxString &aPackageId, const PCM_PACKAGE_STATE aState, const bool aPinned)
Set the state of package.
std::vector< wxString > m_packageInitialOrder
PANEL_PACKAGES_VIEW(wxWindow *parent, std::shared_ptr< PLUGIN_CONTENT_MANAGER > aPcm, const ActionCallback &aCallback, const PinCallback &aPinCallback)
void OnShowAllVersionsClicked(wxCommandEvent &event) override
Ranks packages for entered search term and rearranges/hides panels according to their rank.
void OnClick(wxMouseEvent &event) override
const PACKAGE_VIEW_DATA & GetPackageData() const
Definition: panel_package.h:92
void SetSelected(bool aSelected)
void SetSelectCallback(const std::function< void()> &aCallback)
Marks panel as selected.
virtual COMMON_SETTINGS * GetCommonSettings() const
Definition: pgm_base.cpp:565
int GetVisibleWidth(int aCol, bool aHeader=true, bool aContents=true, bool aKeep=false)
Calculate the specified column based on the actual size of the text on screen.
Definition: wx_grid.cpp:916
void SetBorders(bool aLeft, bool aRight, bool aTop, bool aBottom)
Definition: wx_panel.h:39
Multi-thread safe progress reporter dialog, intended for use of tasks that parallel reporting back of...
void SetPaneMinimums(int aFirst, int aSecond)
#define GRID_CELL_MARGIN
#define _(s)
wxSize GetUnobscuredSize(const wxWindow *aWindow)
Tries to determine the size of the viewport of a scrollable widget (wxDataViewCtrl,...
Definition: wxgtk/ui.cpp:258
std::function< void(const wxString &aPackageId, const PCM_PACKAGE_STATE aState, const bool aPinned)> PinCallback
Definition: panel_package.h:60
std::function< void(const PACKAGE_VIEW_DATA &aData, PCM_PACKAGE_ACTION aAction, const wxString &aVersion)> ActionCallback
Definition: panel_package.h:57
void Refresh()
Update the board display after modifying it by a python script (note: it is automatically called by a...
PCM_PACKAGE_STATE
Definition: pcm.h:58
@ PPS_INSTALLED
Definition: pcm.h:61
@ PPS_PENDING_UPDATE
Definition: pcm.h:65
@ PPS_UNAVAILABLE
Definition: pcm.h:60
@ PPS_UPDATE_AVAILABLE
Definition: pcm.h:64
@ PPS_PENDING_UNINSTALL
Definition: pcm.h:63
@ PPS_PENDING_INSTALL
Definition: pcm.h:62
@ PPS_AVAILABLE
Definition: pcm.h:59
PCM_PACKAGE_ACTION
Definition: pcm.h:71
@ PPA_UNINSTALL
Definition: pcm.h:73
@ PPA_UPDATE
Definition: pcm.h:74
@ PPA_INSTALL
Definition: pcm.h:72
@ PVS_INVALID
Definition: pcm_data.h:62
@ PVS_DEVELOPMENT
Definition: pcm_data.h:65
@ PVS_STABLE
Definition: pcm_data.h:63
@ PVS_TESTING
Definition: pcm_data.h:64
@ PVS_DEPRECATED
Definition: pcm_data.h:66
PGM_BASE & Pgm()
The global program "get" accessor.
Definition: pgm_base.cpp:902
see class PGM_BASE
std::vector< FAB_LAYER_COLOR > dummy
wxString EscapeHTML(const wxString &aString)
Return a new wxString escaped for embedding in HTML.
< Package version metadata Package metadata
Definition: pcm_data.h:91
std::optional< uint64_t > download_size
Definition: pcm_data.h:96
std::optional< uint64_t > install_size
Definition: pcm_data.h:97
wxString version
Definition: pcm_data.h:92
PCM_PACKAGE_VERSION_STATUS status
Definition: pcm_data.h:98
< Collection of data relevant to the package display panel Callback for (un)install button
Definition: panel_package.h:31
wxString update_version
Definition: panel_package.h:39
wxString current_version
Definition: panel_package.h:38
PCM_PACKAGE_STATE state
Definition: panel_package.h:34
Repository reference to a resource.
Definition: pcm_data.h:113
wxString name
Definition: pcm_data.h:114
std::vector< PACKAGE_VERSION > versions
Definition: pcm_data.h:126
#define PR_CAN_ABORT