PCM_TASK_MANAGER Class Reference

Helper class that handles package (un)installation. More...

#include <pcm_task_manager.h>

Public Member Functions
	PCM_TASK_MANAGER (std::shared_ptr< PLUGIN_CONTENT_MANAGER > pcm)
void	DownloadAndInstall (const PCM_PACKAGE &aPackage, const wxString &aVersion, const wxString &aRepositoryId, const bool isUpdate)
	Enqueue package download and installation. More...
void	Uninstall (const PCM_PACKAGE &aPackage)
	Enqueue package uninstallation. More...
void	RunQueue (wxWindow *aParent)
	Run queue of pending actions. More...
void	InstallFromFile (wxWindow *aParent, const wxString &aFilePath)
	Installs package from an archive file on disk. More...
bool	ColorSettingsChanged () const

Private Member Functions
int	downloadFile (const wxString &aFilePath, const wxString &aUrl)
	Download URL to a file. More...
void	installDownloadedPackage (const PCM_PACKAGE &aPackage, const wxString &aVersion, const wxString &aRepositoryId, const wxFileName &aFilePath, const bool isUpdate)
	Installs downloaded package archive. More...
bool	extract (const wxString &aFilePath, const wxString &aPackageId, bool isMultiThreaded)
	Extract package archive. More...
void	deletePackageDirectories (const wxString &aPackageId, const std::forward_list< wxRegEx > &aKeep={})
	Delete all package files. More...

Private Attributes
std::unique_ptr< DIALOG_PCM_PROGRESS >	m_reporter
SYNC_QUEUE< PCM_TASK >	m_download_queue
SYNC_QUEUE< PCM_TASK >	m_install_queue
std::shared_ptr< PLUGIN_CONTENT_MANAGER >	m_pcm
std::atomic_bool	m_color_themes_changed

Detailed Description

Helper class that handles package (un)installation.

Package state changes are first enqueued using DownloadAndInstall/Uninstall methods and then applied using RunQueue().

RunQueue() is multithreaded for better experience.

Definition at line 50 of file pcm_task_manager.h.

Constructor & Destructor Documentation

PCM_TASK_MANAGER()

PCM_TASK_MANAGER::PCM_TASK_MANAGER ( std::shared_ptr< PLUGIN_CONTENT_MANAGER >  pcm )

inline

Definition at line 53 of file pcm_task_manager.h.

: m_pcm( pcm ){};

Member Function Documentation

ColorSettingsChanged()

bool PCM_TASK_MANAGER::ColorSettingsChanged

(

)

const

Returns

true if color settings were installed or uninstalled by the most recent action

Definition at line 655 of file pcm_task_manager.cpp.

{
 return m_color_themes_changed.load();
}

References m_color_themes_changed.

Referenced by DIALOG_PCM::OnApplyChangesClicked(), and DIALOG_PCM::OnInstallFromFileClicked().

deletePackageDirectories()

void PCM_TASK_MANAGER::deletePackageDirectories ( const wxString &  aPackageId, const std::forward_list< wxRegEx > &  aKeep = {}  )

private

Delete all package files.

Parameters

aPackageId	id of the package
aKeep	list of regex indicating which files should not be deleted

Definition at line 464 of file pcm_task_manager.cpp.

{
 // Namespace delimiter changed on disk to allow flat loading of Python modules
 wxString clean_package_id = aPackageId;
 clean_package_id.Replace( '.', '_' );
 
 int path_prefix_len = m_pcm->Get3rdPartyPath().Length();
 
 auto sort_func = []( const wxString& a, const wxString& b )
 {
 if( a.length() > b.length() )
 return true;
 if( a.length() < b.length() )
 return false;
 
 if( a != b )
 return a < b;
 
 return false;
 };
 
 for( const wxString& dir : PCM_PACKAGE_DIRECTORIES )
 {
 wxFileName d( m_pcm->Get3rdPartyPath(), "" );
 d.AppendDir( dir );
 d.AppendDir( clean_package_id );
 
 if( !d.DirExists() )
 continue;
 
 m_reporter->PCMReport( wxString::Format( _( "Removing directory %s" ), d.GetPath() ),
 RPT_SEVERITY_INFO );
 
 if( aKeep.empty() )
 {
 if( !d.Rmdir( wxPATH_RMDIR_RECURSIVE ) )
 {
 m_reporter->PCMReport(
 wxString::Format( _( "Failed to remove directory %s" ), d.GetPath() ),
 RPT_SEVERITY_ERROR );
 }
 }
 else
 {
 std::vector<wxString> files;
 std::vector<wxString> dirs;
 PATH_COLLECTOR collector( files, dirs );
 
 wxDir( d.GetFullPath() )
 .Traverse( collector, wxEmptyString, wxDIR_DEFAULT | wxDIR_NO_FOLLOW );
 
 // Do a poor mans post order traversal by sorting paths in reverse length order
 std::sort( files.begin(), files.end(), sort_func );
 std::sort( dirs.begin(), dirs.end(), sort_func );
 
 // Delete files that don't match any of the aKeep regexs
 for( const wxString& file : files )
 {
 bool del = true;
 
 for( const wxRegEx& re : aKeep )
 {
 wxString tmp = file.Mid( path_prefix_len );
 tmp.Replace( "\\", "/" );
 
 if( re.Matches( tmp ) )
 {
 // m_reporter->PCMReport( wxString::Format( _( "Keeping file '%s'." ), tmp ),
 // RPT_SEVERITY_INFO );
 
 del = false;
 break;
 }
 }
 
 if( del )
 wxRemoveFile( file );
 }
 
 // Delete any empty dirs
 for( const wxString& empty_dir : dirs )
 {
 wxFileName dname( empty_dir, "" );
 dname.Rmdir(); // not passing any flags here will only remove empty directories
 }
 }
 }
}

References _, Format(), m_pcm, m_reporter, PCM_PACKAGE_DIRECTORIES(), RPT_SEVERITY_ERROR, and RPT_SEVERITY_INFO.

Referenced by installDownloadedPackage(), InstallFromFile(), and Uninstall().

DownloadAndInstall()

void PCM_TASK_MANAGER::DownloadAndInstall	(	const PCM_PACKAGE &	aPackage,
		const wxString &	aVersion,
		const wxString &	aRepositoryId,
		const bool	isUpdate
	)

Enqueue package download and installation.

Enqueues a download task for a given package version.

Download task fetches the package archive and if successful enqueues an installation task. Installation task verifies sha256 hash if specified, extracts the package, removes the downloaded archive and marks package as installed.

Both tasks report their state independently to a progress dialog.

Parameters

aPackage	package metadata
aVersion	version to be installed
aRepositoryId	id of the source repository

Definition at line 57 of file pcm_task_manager.cpp.

{
 PCM_TASK download_task = [aPackage, aVersion, aRepositoryId, isUpdate, this]()
 {
 wxFileName file_path( PATHS::GetUserCachePath(), "" );
 file_path.AppendDir( "pcm" );
 file_path.SetFullName( wxString::Format( "%s_v%s.zip", aPackage.identifier, aVersion ) );
 
 auto find_pkgver = std::find_if( aPackage.versions.begin(), aPackage.versions.end(),
 [&aVersion]( const PACKAGE_VERSION& pv )
 {
 return pv.version == aVersion;
 } );
 
 if( find_pkgver == aPackage.versions.end() )
 {
 m_reporter->PCMReport( wxString::Format( _( "Version %s of package %s not found!" ),
 aVersion, aPackage.identifier ),
 RPT_SEVERITY_ERROR );
 return;
 }
 
 if( !wxDirExists( file_path.GetPath() )
 && !wxFileName::Mkdir( file_path.GetPath(), wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL ) )
 {
 m_reporter->PCMReport( _( "Unable to create download directory!" ),
 RPT_SEVERITY_ERROR );
 return;
 }
 
 int code = downloadFile( file_path.GetFullPath(), *find_pkgver->download_url );
 
 if( code != CURLE_OK )
 {
 // Cleanup after ourselves and exit
 wxRemoveFile( file_path.GetFullPath() );
 return;
 }
 
 PCM_TASK install_task = [aPackage, aVersion, aRepositoryId, file_path, isUpdate, this]()
 {
 installDownloadedPackage( aPackage, aVersion, aRepositoryId, file_path, isUpdate );
 };
 
 m_install_queue.push( install_task );
 };
 
 m_download_queue.push( download_task );
}

References _, downloadFile(), Format(), PATHS::GetUserCachePath(), PCM_PACKAGE::identifier, installDownloadedPackage(), m_download_queue, m_install_queue, m_reporter, SYNC_QUEUE< T >::push(), RPT_SEVERITY_ERROR, and PCM_PACKAGE::versions.

Referenced by DIALOG_PCM::OnApplyChangesClicked().

downloadFile()

int PCM_TASK_MANAGER::downloadFile ( const wxString &  aFilePath, const wxString &  aUrl  )

private

Download URL to a file.

Parameters

aFilePath	path to file
aUrl	URL to download

Returns

int CURLE error code

Definition at line 109 of file pcm_task_manager.cpp.

{
 TRANSFER_CALLBACK callback = [&]( size_t dltotal, size_t dlnow, size_t ultotal, size_t ulnow )
 {
 if( dltotal > 1024 )
 m_reporter->SetDownloadProgress( dlnow, dltotal );
 else
 m_reporter->SetDownloadProgress( 0.0, 0.0 );
 
 return m_reporter->IsCancelled();
 };
 
 std::ofstream out( aFilePath.ToUTF8(), std::ofstream::binary );
 
 KICAD_CURL_EASY curl;
 curl.SetOutputStream( &out );
 curl.SetURL( url.ToUTF8().data() );
 curl.SetFollowRedirects( true );
 curl.SetTransferCallback( callback, 250000L );
 
 m_reporter->PCMReport( wxString::Format( _( "Downloading package url: '%s'" ), url ),
 RPT_SEVERITY_INFO );
 
 int code = curl.Perform();
 
 out.close();
 
 uint64_t download_total;
 
 if( CURLE_OK == curl.GetTransferTotal( download_total ) )
 m_reporter->SetDownloadProgress( download_total, download_total );
 
 if( code != CURLE_OK && code != CURLE_ABORTED_BY_CALLBACK )
 {
 m_reporter->PCMReport( wxString::Format( _( "Failed to download url %s\n%s" ), url,
 curl.GetErrorText( code ) ),
 RPT_SEVERITY_ERROR );
 }
 
 return code;
}

References _, Format(), KICAD_CURL_EASY::GetErrorText(), KICAD_CURL_EASY::GetTransferTotal(), m_reporter, KICAD_CURL_EASY::Perform(), RPT_SEVERITY_ERROR, RPT_SEVERITY_INFO, KICAD_CURL_EASY::SetFollowRedirects(), KICAD_CURL_EASY::SetOutputStream(), KICAD_CURL_EASY::SetTransferCallback(), and KICAD_CURL_EASY::SetURL().

Referenced by DownloadAndInstall().

extract()

bool PCM_TASK_MANAGER::extract ( const wxString &  aFilePath, const wxString &  aPackageId, bool  isMultiThreaded  )

private

Extract package archive.

Parameters

aFilePath	path to the archive
aPackageId	id of the package
isMultiThreaded	MUST be set to true if the caller is not running in the main thread

Returns

true if archive was extracted successfuly

Definition at line 235 of file pcm_task_manager.cpp.

{
 wxFFileInputStream stream( aFilePath );
 wxZipInputStream zip( stream );
 
 wxLogNull no_wx_logging;
 
 int entries = zip.GetTotalEntries();
 int extracted = 0;
 
 wxArchiveEntry* entry = zip.GetNextEntry();
 
 if( !zip.IsOk() )
 {
 m_reporter->PCMReport( _( "Error extracting file!" ), RPT_SEVERITY_ERROR );
 return false;
 }
 
 // Namespace delimiter changed on disk to allow flat loading of Python modules
 wxString clean_package_id = aPackageId;
 clean_package_id.Replace( '.', '_' );
 
 for( ; entry; entry = zip.GetNextEntry() )
 {
 wxArrayString path_parts =
 wxSplit( entry->GetName(), wxFileName::GetPathSeparator(), (wxChar) 0 );
 
 if( path_parts.size() < 2
 || PCM_PACKAGE_DIRECTORIES.find( path_parts[0] ) == PCM_PACKAGE_DIRECTORIES.end()
 || path_parts[path_parts.size() - 1].IsEmpty() )
 {
 // Ignore files in the root of the archive and files outside of package dirs.
 continue;
 }
 
 // m_reporter->Report( wxString::Format( _( "Extracting file '%s'\n" ), entry->GetName() ),
 // RPT_SEVERITY_INFO );
 
 // Transform paths from
 // <PackageRoot>/$folder/$contents
 // To
 // $KICAD7_3RD_PARTY/$folder/$package_id/$contents
 path_parts.Insert( clean_package_id, 1 );
 path_parts.Insert( m_pcm->Get3rdPartyPath(), 0 );
 
 wxString fullname = wxJoin( path_parts, wxFileName::GetPathSeparator(), (wxChar) 0 );
 
 // Ensure the target directory exists and create it if not.
 wxString t_path = wxPathOnly( fullname );
 
 if( !wxDirExists( t_path ) )
 {
 wxFileName::Mkdir( t_path, wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL );
 }
 
 wxTempFileOutputStream out( fullname );
 
 if( !( CopyStreamData( zip, out, entry->GetSize() ) && out.Commit() ) )
 {
 m_reporter->PCMReport( _( "Error extracting file!" ), RPT_SEVERITY_ERROR );
 return false;
 }
 
 extracted++;
 m_reporter->SetPackageProgress( extracted, entries );
 
 if( !isMultiThreaded )
 m_reporter->KeepRefreshing( false );
 
 if( m_reporter->IsCancelled() )
 break;
 }
 
 zip.CloseEntry();
 
 if( m_reporter->IsCancelled() )
 {
 m_reporter->PCMReport( _( "Aborting package installation." ), RPT_SEVERITY_INFO );
 return false;
 }
 
 m_reporter->PCMReport( _( "Extracted package\n" ), RPT_SEVERITY_INFO );
 m_reporter->SetPackageProgress( entries, entries );
 
 return true;
}

References _, CopyStreamData(), m_pcm, m_reporter, PCM_PACKAGE_DIRECTORIES(), RPT_SEVERITY_ERROR, RPT_SEVERITY_INFO, and zip.

Referenced by installDownloadedPackage(), and InstallFromFile().

installDownloadedPackage()

void PCM_TASK_MANAGER::installDownloadedPackage ( const PCM_PACKAGE &  aPackage, const wxString &  aVersion, const wxString &  aRepositoryId, const wxFileName &  aFilePath, const bool  isUpdate  )

private

Installs downloaded package archive.

Parameters

aPackage	package metadata
aVersion	version to be installed
aRepositoryId	id of the source repository
aFilePath	path to the archive
isUpdate	true if this is an update operation

Definition at line 152 of file pcm_task_manager.cpp.

{
 auto pkgver = std::find_if( aPackage.versions.begin(), aPackage.versions.end(),
 [&aVersion]( const PACKAGE_VERSION& pv )
 {
 return pv.version == aVersion;
 } );
 
 if( pkgver == aPackage.versions.end() )
 {
 m_reporter->PCMReport( wxString::Format( _( "Version %s of package %s not found!" ),
 aVersion, aPackage.identifier ),
 RPT_SEVERITY_ERROR );
 return;
 }
 
 // wxRegEx is not CopyConstructible hence the weird choice of forward_list
 std::forward_list<wxRegEx> keep_on_update;
 
 if( isUpdate )
 compile_keep_on_update_regex( aPackage, *pkgver, keep_on_update );
 
 const std::optional<wxString>& hash = pkgver->download_sha256;
 bool hash_match = true;
 
 if( hash )
 {
 std::ifstream stream( aFilePath.GetFullPath().ToUTF8(), std::ios::binary );
 hash_match = m_pcm->VerifyHash( stream, *hash );
 }
 
 if( !hash_match )
 {
 m_reporter->PCMReport( wxString::Format( _( "Downloaded archive hash for package "
 "%s does not match repository entry. "
 "This may indicate a problem with the "
 "package, if the issue persists "
 "report this to repository maintainers." ),
 aPackage.identifier ),
 RPT_SEVERITY_ERROR );
 }
 else
 {
 if( isUpdate )
 {
 m_reporter->PCMReport(
 wxString::Format( _( "Removing previous version of package '%s'." ),
 aPackage.identifier ),
 RPT_SEVERITY_INFO );
 
 deletePackageDirectories( aPackage.identifier, keep_on_update );
 }
 
 m_reporter->PCMReport(
 wxString::Format( _( "Extracting package '%s'." ), aPackage.identifier ),
 RPT_SEVERITY_INFO );
 
 if( extract( aFilePath.GetFullPath(), aPackage.identifier, true ) )
 {
 m_pcm->MarkInstalled( aPackage, pkgver->version, aRepositoryId );
 // TODO register libraries.
 }
 else
 {
 // Cleanup possibly partially extracted package
 deletePackageDirectories( aPackage.identifier );
 }
 }
 
 if( aPackage.type == PCM_PACKAGE_TYPE::PT_COLORTHEME )
 m_color_themes_changed.store( true );
 
 m_reporter->PCMReport(
 wxString::Format( _( "Removing downloaded archive '%s'." ), aFilePath.GetFullName() ),
 RPT_SEVERITY_INFO );
 
 wxRemoveFile( aFilePath.GetFullPath() );
}

References _, compile_keep_on_update_regex(), deletePackageDirectories(), extract(), Format(), PCM_PACKAGE::identifier, m_color_themes_changed, m_pcm, m_reporter, PT_COLORTHEME, RPT_SEVERITY_ERROR, RPT_SEVERITY_INFO, PCM_PACKAGE::type, and PCM_PACKAGE::versions.

Referenced by DownloadAndInstall().

InstallFromFile()

void PCM_TASK_MANAGER::InstallFromFile	(	wxWindow *	aParent,
		const wxString &	aFilePath
	)

Installs package from an archive file on disk.

Unlike DownloadAndInstall/Uninstall methods this one immediately extracts the package and marks it as installed.

Parameters

aParent	parent dialog for progress window
aFilePath	path to the archive file

Definition at line 324 of file pcm_task_manager.cpp.

{
 wxFFileInputStream stream( aFilePath );
 
 if( !stream.IsOk() )
 {
 wxLogError( _( "Could not open archive file." ) );
 return;
 }
 
 wxZipInputStream zip( stream );
 
 if( !zip.IsOk() )
 {
 wxLogError( _( "Invalid archive file format." ) );
 return;
 }
 
 nlohmann::json metadata;
 
 for( wxArchiveEntry* entry = zip.GetNextEntry(); entry != nullptr; entry = zip.GetNextEntry() )
 {
  // Find and load metadata.json
 if( entry->GetName() != "metadata.json" )
 continue;
 
 wxStringOutputStream strStream;
 
 if( CopyStreamData( zip, strStream, entry->GetSize() ) )
 {
 try
 {
 metadata = nlohmann::json::parse( strStream.GetString().ToUTF8().data() );
 m_pcm->ValidateJson( metadata );
 }
 catch( const std::exception& e )
 {
 wxLogError( wxString::Format( _( "Unable to parse package metadata:\n\n%s" ),
 e.what() ) );
 break;
 }
 }
 }
 
 if( metadata.empty() )
 {
 wxLogError( _( "Archive does not contain a valid metadata.json file" ) );
 return;
 }
 
 PCM_PACKAGE package = metadata.get<PCM_PACKAGE>();
 
 if( package.versions.size() != 1 )
 {
 wxLogError( _( "Archive metadata must have a single version defined" ) );
 return;
 }
 
 bool isUpdate = false;
 // wxRegEx is not CopyConstructible hence the weird choice of forward_list
 std::forward_list<wxRegEx> keep_on_update;
 const std::vector<PCM_INSTALLATION_ENTRY> installed_packages = m_pcm->GetInstalledPackages();
 
 if( std::find_if( installed_packages.begin(), installed_packages.end(),
 [&]( const PCM_INSTALLATION_ENTRY& entry )
 {
 return entry.package.identifier == package.identifier;
 } )
 != installed_packages.end() )
 {
 if( wxMessageBox(
 wxString::Format(
 _( "Package with identifier %s is already installed. "
 "Would you like to update it to the version from selected file?" ),
 package.identifier ),
 _( "Update package" ), wxICON_EXCLAMATION | wxYES_NO, aParent )
 == wxNO )
 return;
 
 isUpdate = true;
 
 compile_keep_on_update_regex( package, package.versions[0], keep_on_update );
 }
 
 m_reporter = std::make_unique<DIALOG_PCM_PROGRESS>( aParent, false );
#ifdef __WXMAC__
 m_reporter->ShowWindowModal();
#else
 m_reporter->Show();
#endif
 
 if( isUpdate )
 {
 m_reporter->PCMReport( wxString::Format( _( "Removing previous version of package '%s'." ),
 package.identifier ),
 RPT_SEVERITY_INFO );
 
 deletePackageDirectories( package.identifier, keep_on_update );
 }
 
 if( extract( aFilePath, package.identifier, false ) )
 m_pcm->MarkInstalled( package, package.versions[0].version, "" );
 
 m_reporter->SetFinished();
 m_reporter->KeepRefreshing( false );
 m_reporter->Destroy();
 m_reporter.reset();
 
 aParent->Raise();
 
 m_color_themes_changed.store( package.type == PCM_PACKAGE_TYPE::PT_COLORTHEME );
}

References _, compile_keep_on_update_regex(), CopyStreamData(), deletePackageDirectories(), extract(), Format(), m_color_themes_changed, m_pcm, m_reporter, parse(), PT_COLORTHEME, RPT_SEVERITY_INFO, and zip.

Referenced by DIALOG_PCM::OnInstallFromFileClicked().

RunQueue()

void PCM_TASK_MANAGER::RunQueue

(

wxWindow *

aParent

)

Run queue of pending actions.

This method spawns 2 threads to concurrently run tasks in download and install queues until they are drained.

Download queue feeds into install queue so the install thread keeps running until download thread indicated that it's finished AND all installs are processed.

Parameters

aParent

parent dialog for progress window

Definition at line 575 of file pcm_task_manager.cpp.

{
 m_reporter = std::make_unique<DIALOG_PCM_PROGRESS>( aParent );
 
 m_reporter->SetNumPhases( m_download_queue.size() + m_install_queue.size() );
#ifdef __WXMAC__
 m_reporter->ShowWindowModal();
#else
 m_reporter->Show();
#endif
 
 wxSafeYield();
 
 std::mutex mutex;
 std::condition_variable condvar;
 bool download_complete = false;
 
 m_color_themes_changed.store( false );
 
 std::thread download_thread(
 [&]()
 {
 while( !m_download_queue.empty() && !m_reporter->IsCancelled() )
 {
 PCM_TASK task;
 m_download_queue.pop( task );
 task();
 condvar.notify_all();
 }
 
 std::unique_lock<std::mutex> lock( mutex );
 download_complete = true;
 condvar.notify_all();
 } );
 
 std::thread install_thread(
 [&]()
 {
 std::unique_lock<std::mutex> lock( mutex );
 
 do
 {
 condvar.wait( lock,
 [&]()
 {
 return download_complete || !m_install_queue.empty()
 || m_reporter->IsCancelled();
 } );
 
 lock.unlock();
 
 while( !m_install_queue.empty() && !m_reporter->IsCancelled() )
 {
 PCM_TASK task;
 m_install_queue.pop( task );
 task();
 m_reporter->AdvancePhase();
 }
 
 lock.lock();
 
 } while( ( !m_install_queue.empty() || !download_complete )
 && !m_reporter->IsCancelled() );
 
 m_reporter->PCMReport( _( "Done." ), RPT_SEVERITY_INFO );
 
 m_reporter->SetFinished();
 } );
 
 m_reporter->KeepRefreshing( true );
 m_reporter->Destroy();
 m_reporter.reset();
 
 aParent->Raise();
 
 download_thread.join();
 install_thread.join();
}

References _, SYNC_QUEUE< T >::empty(), m_color_themes_changed, m_download_queue, m_install_queue, m_reporter, SYNC_QUEUE< T >::pop(), RPT_SEVERITY_INFO, and SYNC_QUEUE< T >::size().

Referenced by DIALOG_PCM::OnApplyChangesClicked().

Uninstall()

void PCM_TASK_MANAGER::Uninstall

(

const PCM_PACKAGE &

aPackage

)

Enqueue package uninstallation.

Enqueues uninstallation task that removes all package files and marks package as uninstalled.

Parameters

aPackage

package metadata

Definition at line 555 of file pcm_task_manager.cpp.

{
 PCM_TASK task = [aPackage, this]
 {
 deletePackageDirectories( aPackage.identifier );
 
 m_pcm->MarkUninstalled( aPackage );
 
 if( aPackage.type == PCM_PACKAGE_TYPE::PT_COLORTHEME )
 m_color_themes_changed.store( true );
 
 m_reporter->PCMReport(
 wxString::Format( _( "Package %s uninstalled" ), aPackage.identifier ),
 RPT_SEVERITY_INFO );
 };
 
 m_install_queue.push( task );
}

References _, deletePackageDirectories(), Format(), PCM_PACKAGE::identifier, m_color_themes_changed, m_install_queue, m_pcm, m_reporter, PT_COLORTHEME, SYNC_QUEUE< T >::push(), RPT_SEVERITY_INFO, and PCM_PACKAGE::type.

Referenced by DIALOG_PCM::OnApplyChangesClicked().

Member Data Documentation

m_color_themes_changed

std::atomic_bool PCM_TASK_MANAGER::m_color_themes_changed

private

Definition at line 158 of file pcm_task_manager.h.

Referenced by ColorSettingsChanged(), installDownloadedPackage(), InstallFromFile(), RunQueue(), and Uninstall().

m_download_queue

SYNC_QUEUE<PCM_TASK> PCM_TASK_MANAGER::m_download_queue

private

Definition at line 155 of file pcm_task_manager.h.

Referenced by DownloadAndInstall(), and RunQueue().

m_install_queue

SYNC_QUEUE<PCM_TASK> PCM_TASK_MANAGER::m_install_queue

private

Definition at line 156 of file pcm_task_manager.h.

Referenced by DownloadAndInstall(), RunQueue(), and Uninstall().

m_pcm

std::shared_ptr<PLUGIN_CONTENT_MANAGER> PCM_TASK_MANAGER::m_pcm

private

Definition at line 157 of file pcm_task_manager.h.

Referenced by deletePackageDirectories(), extract(), installDownloadedPackage(), InstallFromFile(), and Uninstall().

m_reporter

std::unique_ptr<DIALOG_PCM_PROGRESS> PCM_TASK_MANAGER::m_reporter

private

Definition at line 154 of file pcm_task_manager.h.

Referenced by deletePackageDirectories(), DownloadAndInstall(), downloadFile(), extract(), installDownloadedPackage(), InstallFromFile(), RunQueue(), and Uninstall().

---

The documentation for this class was generated from the following files:

• pcm_task_manager.h
• pcm_task_manager.cpp