diff --git a/src/basicdownloader.cpp b/src/basicdownloader.cpp index 4f91899c..1a876945 100644 --- a/src/basicdownloader.cpp +++ b/src/basicdownloader.cpp @@ -475,7 +475,7 @@ void basicdownloader::run( const basicdownloader::engine& eng, m_parent( p ),m_engine( engine ),m_id( id ),m_getList( l ) { } - void done( engines::ProcessExitState m,const QStringList& fileNames ) + void done( engines::ProcessExitState m,const std::vector< QByteArray >& fileNames ) { m_parent.m_ctx.TabManager().enableAll() ; diff --git a/src/batchdownloader.cpp b/src/batchdownloader.cpp index 2ab7f383..1ac3f49a 100644 --- a/src/batchdownloader.cpp +++ b/src/batchdownloader.cpp @@ -1177,7 +1177,10 @@ void batchdownloader::renameFile( int row ) if( !m.isEmpty() ){ - m_table.setFileNames( row,{ m } ) ; + std::vector< QByteArray > s ; + s.emplace_back( m.toUtf8() ) ; + + m_table.setFileNames( row,std::move( s ) ) ; } } } @@ -1887,7 +1890,7 @@ void batchdownloader::showThumbnail( const engines::engine& engine, { return utility::addData( e ) ; } - void done( engines::ProcessExitState e,const QStringList& ) + void done( engines::ProcessExitState e,const std::vector< QByteArray >& ) { auto& a = m_parent ; auto& b = m_engine ; @@ -2245,7 +2248,7 @@ void batchdownloader::showList( batchdownloader::listType listType, return false ; } } - void done( engines::ProcessExitState st,const QStringList& ) + void done( engines::ProcessExitState st,const std::vector< QByteArray >& ) { m_parent.m_ctx.TabManager().enableAll() ; @@ -2548,7 +2551,8 @@ void batchdownloader::download( const engines::engine& engine,int init ) this->download( engine,indexes.move() ) ; } -void batchdownloader::reportFinishedStatus( const reportFinished& f,const QStringList& fileNames ) +void batchdownloader::reportFinishedStatus( const reportFinished& f, + const std::vector< QByteArray >& fileNames ) { auto finishedStatus = f.finishedStatus() ; @@ -2628,7 +2632,7 @@ void batchdownloader::downloadEntry( const engines::engine& eng,int index ) return true ; } } - void done( engines::ProcessExitState e,QStringList s ) + void done( engines::ProcessExitState e,std::vector< QByteArray > s ) { event ev( m_parent,m_engine,std::move( s ) ) ; m_parent.m_ccmd.monitorForFinished( m_engine,m_index,e.move(),ev.move() ) ; @@ -2656,7 +2660,7 @@ void batchdownloader::downloadEntry( const engines::engine& eng,int index ) class event { public: - event( batchdownloader& p,const engines::engine& engine,QStringList f ) : + event( batchdownloader& p,const engines::engine& engine,std::vector< QByteArray > f ) : m_parent( p ),m_engine( engine ),m_fileNames( std::move( f ) ) { } @@ -2677,7 +2681,7 @@ void batchdownloader::downloadEntry( const engines::engine& eng,int index ) private: batchdownloader& m_parent ; const engines::engine& m_engine ; - QStringList m_fileNames ; + std::vector< QByteArray > m_fileNames ; } ; batchdownloader& m_parent ; @@ -2693,6 +2697,8 @@ void batchdownloader::downloadEntry( const engines::engine& eng,int index ) auto updater = [ this,index ]( const QByteArray& e ){ + qDebug() << "batch: " + e ; + emit this->addTextToUiSignal( e,index ) ; } ; diff --git a/src/batchdownloader.h b/src/batchdownloader.h index c3834e08..28bb993c 100644 --- a/src/batchdownloader.h +++ b/src/batchdownloader.h @@ -216,14 +216,14 @@ private slots: void addTextToUi( const QByteArray&,int ) ; signals: - void reportFStatus( const reportFinished&,const QStringList& ) ; + void reportFStatus( const reportFinished&,const std::vector< QByteArray >& ) ; void addItemUiSignal( ItemEntry ) ; void addTextToUiSignal( const QByteArray&,int ) ; private: void showHideControls() ; void networkData( const utility::networkReply& ) ; void addItemUiSlot( ItemEntry ) ; - void reportFinishedStatus( const reportFinished&,const QStringList& ) ; + void reportFinishedStatus( const reportFinished&,const std::vector< QByteArray >& ) ; enum class listType{ COMMENTS,SUBTITLES,MEDIA_OPTIONS } ; void setDefaultEngineAndOptions( Items::entry& ) ; void showList( batchdownloader::listType,const engines::engine&,const QString&,int ) ; @@ -383,7 +383,7 @@ private { return m_localLogger.toLine() ; } - const QStringList& fileNames() const + const std::vector< QByteArray >& fileNames() const { return m_localLogger.fileNames() ; } @@ -443,7 +443,7 @@ private return data ; } - const QStringList& fileNames() const + const std::vector< QByteArray >& fileNames() const { return m_logger->fileNames() ; } diff --git a/src/engines.cpp b/src/engines.cpp index c7295f97..311338f3 100644 --- a/src/engines.cpp +++ b/src/engines.cpp @@ -1469,7 +1469,7 @@ QString engines::engine::baseEngine::deleteEngineBinFolder( const QString& e ) } } -void engines::engine::baseEngine::runCommandOnDownloadedFile( const QStringList& fileNames ) +void engines::engine::baseEngine::runCommandOnDownloadedFile( const std::vector< QByteArray >& fileNames ) { auto df = m_settings.downloadFolder() + "/" ; @@ -1532,7 +1532,7 @@ void engines::engine::baseEngine::openLocalFile( const engines::engine::baseEngi { auto e = [ & ](){ - if( l.fileNames.isEmpty() ){ + if( l.fileNames.size() ){ auto m = util::split( l.uiText,'\n',true ) ; @@ -1543,7 +1543,7 @@ void engines::engine::baseEngine::openLocalFile( const engines::engine::baseEngi return QString() ; } }else{ - return l.fileNames.last() ; + return QString( l.fileNames.back() ) ; } }() ; diff --git a/src/engines.h b/src/engines.h index 6b11d078..30ae7c69 100644 --- a/src/engines.h +++ b/src/engines.h @@ -712,7 +712,7 @@ class engines virtual QString deleteEngineBinFolder( const QString& ) ; - virtual void runCommandOnDownloadedFile( const QStringList& ) ; + virtual void runCommandOnDownloadedFile( const std::vector< QByteArray >& ) ; virtual QString commandString( const engines::engine::exeArgs::cmd& ) ; @@ -732,7 +732,7 @@ class engines { const QString& uiText ; const QString& downloadFolder ; - const QStringList& fileNames ; + const std::vector< QByteArray >& fileNames ; }; virtual void openLocalFile( const engines::engine::baseEngine::localFile& ) ; @@ -986,7 +986,7 @@ class engines { return m_engine->commandString( cmd ) ; } - void runCommandOnDownloadedFile( const QStringList& fileNames ) const + void runCommandOnDownloadedFile( const std::vector< QByteArray >& fileNames ) const { m_engine->runCommandOnDownloadedFile( fileNames ) ; } diff --git a/src/engines.h~RF893463.TMP b/src/engines.h~RF893463.TMP new file mode 100644 index 00000000..343c7871 --- /dev/null +++ b/src/engines.h~RF893463.TMP @@ -0,0 +1,1415 @@ +/* + * + * Copyright (c) 2021 + * name : Francis Banyikwa + * email: mhogomchungu@gmail.com + * 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, see . + */ +#ifndef ENGINES_H +#define ENGINES_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include "logger.h" +#include "util.hpp" +#include "utils/threads.hpp" +#include "utils/qprocess.hpp" + +class tableWidget ; +class settings ; +class Context ; + +namespace utility { + class uiIndex ; +} + +class engines +{ +public: + static bool filePathIsValid( const QFileInfo& ) ; + + class file + { + public: + file( const QString& path,Logger& logger ) : + m_filePath( path ),m_file( m_filePath ),m_logger( logger ) + { + } + void write( const QString& ) ; + void write( const QJsonDocument&, + QJsonDocument::JsonFormat = QJsonDocument::Indented ) ; + void write( const QJsonObject&, + QJsonDocument::JsonFormat = QJsonDocument::Indented ) ; + QByteArray readAll() ; + QStringList readAllAsLines() ; + template< typename Function > + static void readAll( const QString& filePath,Logger& logger,Function function ) + { + struct result + { + bool success ; + QByteArray data ; + }; + + utils::qthread::run( [ filePath ]()->result{ + + QFile f( filePath ) ; + + if( f.open( QIODevice::ReadOnly ) ){ + + return { true,f.readAll() } ; + }else{ + return { false,{} } ; + } + + },[ &logger,filePath,function = std::move( function ) ]( result r ){ + + if( r.success ){ + + function( true,r.data ) ; + }else{ + engines::file( filePath,logger ).failToOpenForReading() ; + function( false,r.data ) ; + } + } ) ; + } + private: + void failToOpenForReading() ; + void failToOpenForWriting() ; + QString m_filePath ; + QFile m_file ; + Logger& m_logger ; + } ; + + class ProcessExitState + { + public: + enum class ExitStatus{ FailedToStart,NormalExit,Crashed } ; + + ProcessExitState() + { + } + ProcessExitState( bool c,int s,qint64 d,ProcessExitState::ExitStatus e ) : + m_cancelled( c ), + m_exitCode( s ), + m_duration( d ), + m_exitStatus( e ) + { + } + ProcessExitState( bool c,int s,qint64 d,QProcess::ExitStatus e ) : + m_cancelled( c ), + m_exitCode( s ), + m_duration( d ) + { + if( e == QProcess::ExitStatus::NormalExit ){ + + m_exitStatus = ProcessExitState::ExitStatus::NormalExit ; + + }else if( e == QProcess::ExitStatus::CrashExit ){ + + m_exitStatus = ProcessExitState::ExitStatus::Crashed ; + }else{ + m_exitStatus = ProcessExitState::ExitStatus::FailedToStart ; + } + } + int exitCode() const + { + return m_exitCode ; + } + const ProcessExitState::ExitStatus& exitStatus() const + { + return m_exitStatus ; + } + bool cancelled() const + { + return m_cancelled ; + } + bool success() const + { + return m_exitCode == 0 && m_exitStatus == ProcessExitState::ExitStatus::NormalExit ; + } + qint64 duration() const + { + return m_duration ; + } + ProcessExitState move() + { + return std::move( *this ) ; + } + private: + bool m_cancelled = false ; + int m_exitCode = 255 ; + qint64 m_duration = 0 ; + ProcessExitState::ExitStatus m_exitStatus = ProcessExitState::ExitStatus::NormalExit ; + }; + + class enginePaths + { + public: + enginePaths( settings& ) ; + + const QString& basePath() const + { + return m_basePath ; + } + const QString& binPath() const + { + return m_binPath ; + } + const QString& enginePath() const + { + return m_enginePath ; + } + const QString& dataPath() const + { + return m_dataPath ; + } + const QString& updatePath() const + { + return m_updatePath ; + } + const QString& tmp() const + { + return m_tmp ; + } + const QString updateNewPath() const + { + return m_updateNewPath ; + } + QString tmp( const QString& e ) const + { + return _add( m_tmp,e ) ; + } + QString updatePath( const QString& e ) const + { + return _add( m_updatePath,e ) ; + } + QString dataPath( const QString& e ) const + { + return _add( m_dataPath,e ) ; + } + QString subscriptionsArchiveFilePath() const + { + return _add( m_dataPath,"subscriptions_archive_file.txt" ) ; + } + QString binPath( const QString& e ) const + { + return _add( m_binPath,e ) ; + } + QString themePath() const + { + return _add( m_dataPath,"themes" ) ; + } + QString enginePath( const QString& e ) const + { + return _add( m_enginePath,e ) ; + } + QString socketPath() ; + void confirmPaths( Logger& ) const ; + private: + QString _add( const QString& basePath,const QString& toAdd ) const + { + if( basePath.endsWith( "/" ) ){ + + return basePath + toAdd ; + }else{ + return basePath + "/" + toAdd ; + } + } + QString m_binPath ; + QString m_enginePath ; + QString m_basePath ; + QString m_dataPath ; + QString m_updatePath ; + QString m_updateNewPath ; + QString m_tmp ; + } ; + + struct metadata + { + qint64 size = 0 ; + QString url ; + QString fileName ; + metadata move() + { + return std::move( *this ) ; + } + } ; + + class engine + { + public: + class exeArgs + { + public: + class cmd + { + public: + cmd() + { + } + cmd( const engines::engine::exeArgs& exeArgs, + const QStringList& args ) : + m_args( exeArgs.exe() ), + m_exe( m_args.takeAt( 0 ) ) + { + m_args.append( exeArgs.args() ) ; + m_args.append( args ) ; + } + const QString& exe() const + { + return m_exe ; + } + const QStringList& args() const + { + return m_args ; + } + bool valid() + { + QFileInfo info( m_exe ) ; + + return engines::filePathIsValid( info ) ; + } + private: + QStringList m_args ; + QString m_exe ; + } ; + + exeArgs() = default; + exeArgs( const QString& e ) : + m_exe( e ),m_realExe( e ) + { + } + exeArgs( const QString& e,const QString& r,const QStringList& s ) : + m_exe( e ),m_realExe( r ),m_options( s ) + { + } + exeArgs( const QStringList& e,const QString& r,const QStringList& s ) : + m_exe( e ),m_realExe( r ),m_options( s ) + { + } + bool isEmpty() const + { + return m_realExe.isEmpty() ; + } + const QStringList& exe() const + { + return m_exe ; + } + const QStringList& args() const + { + return m_options ; + } + const QString& realExe() const + { + return m_realExe ; + } + void updateRealExe( const QString& e ) + { + if( m_exe.at( 0 ) == m_realExe ){ + + m_exe[ 0 ] = e ; + m_realExe = e ; + }else{ + m_realExe = e ; + } + } + private: + QStringList m_exe ; + QString m_realExe ; + QStringList m_options ; + } ; + + class baseEngine + { + public: + class finishedState + { + public: + template< typename Args > + finishedState( const Args& a ) : + m_success( a.success() ), + m_cancelled( a.cancelled() ), + m_duration( a.duration() ), + m_errorCode( a.exitCode() ), + m_exitStatus( a.exitStatus() ) + { + } + bool success() const + { + return m_success ; + } + bool cancelled() const + { + return m_cancelled ; + } + qint64 duration() const + { + return m_duration ; + } + int errorCode() const + { + return m_errorCode ; + } + engines::ProcessExitState::ExitStatus exitStatus() const + { + return m_exitStatus ; + } + private: + bool m_success ; + bool m_cancelled ; + qint64 m_duration ; + int m_errorCode ; + engines::ProcessExitState::ExitStatus m_exitStatus ; + }; + + enum class errors{ unknownUrl,notSupportedUrl,noNetwork,unknownFormat,logInRequired } ; + static QString errorString( const engine::engine::baseEngine::finishedState&, + engines::engine::baseEngine::errors, + const QString& ) ; + static QString processCompleteStateText( const engine::engine::baseEngine::finishedState& ) ; + + class timer + { + public: + static bool timerText( const QString& e ) ; + static QString timerText() ; + static QString startTimerText() ; + static QString stringElapsedTime( qint64 ) ; + static QString duration( qint64 ) ; + static int toSeconds( const QString& ) ; + static qint64 currentTime() ; + qint64 elapsedTime() ; + QString stringElapsedTime() ; + void reset() ; + private: + qint64 m_startTime = engines::engine::baseEngine::timer::currentTime() ; + }; + + class preProcessing + { + public: + preProcessing() ; + preProcessing( const QByteArray&,int = 16 ) ; + + static QByteArray processingText() ; + void reset() ; + const QByteArray& text() ; + const QByteArray& text( const QByteArray& ) ; + private: + int m_maxCounter = 16 ; + int m_counter = 0 ; + QByteArray m_counterDots ; + QByteArray m_txt ; + QByteArray m_processingDefaultText ; + }; + + class postProcessing + { + public: + static QByteArray processingText() ; + postProcessing() ; + postProcessing( const QByteArray& ) ; + + const QByteArray& text( const QByteArray& ) ; + private: + int m_counter = 0 ; + QByteArray m_counterDots ; + QByteArray m_txt ; + QByteArray m_processingDefaultText ; + }; + + class filter + { + public: + filter( const engines::engine& engine,int ) ; + virtual const QByteArray& operator()( Logger::Data& e ) ; + virtual ~filter() ; + const engines::engine& engine() const ; + private: + engines::engine::baseEngine::preProcessing m_processing ; + const engines::engine& m_engine ; + QByteArray m_tmp ; + int m_processId ; + } ; + + class DataFilter + { + public: + template< typename Type,typename ... Args > + DataFilter( Type,Args&& ... args ) : + m_filter( std::make_unique< typename Type::type >( std::forward< Args >( args ) ... ) ) + { + } + const QByteArray& operator()( Logger::Data& e ) + { + return ( *m_filter )( e ) ; + } + DataFilter move() + { + return std::move( *this ) ; + } + private: + std::unique_ptr< engines::engine::baseEngine::filter > m_filter ; + }; + + class filterOutPut + { + public: + struct args + { + const Logger::locale& locale ; + Logger::Data& data ; + const QByteArray& outPut ; + } ; + class meetCondition + { + public: + meetCondition( bool( *m )( const engines::engine&,const QByteArray& ), + const engines::engine& engine ) : + m_function( m ),m_engine( engine ) + { + } + bool operator()( const QByteArray& e ) const + { + return m_function( m_engine,e ) ; + } + private: + bool( *m_function )( const engines::engine&,const QByteArray& ) ; + const engines::engine& m_engine ; + } ; + class result + { + public: + result( const QByteArray& p, + const engines::engine& e, + bool( *m )( const engines::engine&,const QByteArray& ) ) : + m_progress( p ),m_meetCondition( m,e ) + { + } + const QByteArray& progress() + { + return m_progress ; + } + const filterOutPut::meetCondition& meetCondition() + { + return m_meetCondition ; + } + private: + const QByteArray& m_progress ; + filterOutPut::meetCondition m_meetCondition ; + } ; + virtual result formatOutput( const filterOutPut::args& ) const = 0 ; + virtual bool meetCondition( const filterOutPut::args& ) const = 0 ; + virtual const engines::engine& engine() const = 0 ; + virtual ~filterOutPut() ; + } ; + + static bool meetCondition( const engines::engine&,const QByteArray& ) ; + + class FilterOutPut + { + public: + template< typename Type,typename ... Args > + FilterOutPut( Type,const engines::engine& engine,Args&& ... args ) : + m_filterOutPut( std::make_unique< typename Type::type >( engine,std::forward< Args >( args ) ... ) ) + { + } + engines::engine::baseEngine::filterOutPut::result + formatOutput( const Logger::locale& l,Logger::Data& d,const QByteArray& e ) const + { + return m_filterOutPut->formatOutput( { l,d,e } ) ; + } + bool meetCondition( const Logger::locale& l,Logger::Data& d,const QByteArray& e ) const + { + return m_filterOutPut->meetCondition( { l,d,e } ) ; + } + private: + std::unique_ptr< engines::engine::baseEngine::filterOutPut > m_filterOutPut ; + }; + + virtual FilterOutPut filterOutput() ; + + virtual ~baseEngine() ; + + virtual const QProcessEnvironment& processEnvironment() const ; + + class mediaInfo + { + public: + mediaInfo( const QStringList& u, + const QString& i, + const QString& e, + const QString& r, + const QString& f, + const QString& ff, + const QString& n, + const QString& d, + const QString& t ) : + m_url( u ), + m_id( i ), + m_extension( e ), + m_resolution( r ), + m_fileSize( f ), + m_fileSizeRaw( ff ), + m_info( n ), + m_duration( d ), + m_title( t ) + { + } + mediaInfo( const QString& i, + const QString& e, + const QString& r, + const QString& f, + const QString& ff, + const QString& n, + const QString& d, + const QString& t ) : + m_id( i ), + m_extension( e ), + m_resolution( r ), + m_fileSize( f ), + m_fileSizeRaw( ff ), + m_info( n ), + m_duration( d ), + m_title( t ) + { + } + QJsonObject toqJsonObject() const + { + QJsonObject obj ; + + QJsonArray arr ; + + for( const auto& it : m_url ){ + + arr.append( it ) ; + } + + obj.insert( "urls",arr ) ; + obj.insert( "id",m_id ) ; + obj.insert( "extension",m_extension ) ; + obj.insert( "resolution",m_resolution ) ; + obj.insert( "filesize",m_fileSize ) ; + obj.insert( "filesizeRaw",m_fileSizeRaw ) ; + obj.insert( "info",m_info ) ; + obj.insert( "duration",m_duration ) ; + obj.insert( "title",m_title ) ; + + return obj ; + } + static QString fileSizeRaw( const QJsonObject& obj ) + { + return obj.value( "filesizeRaw" ).toString() ; + } + static QString id( const QJsonObject& obj ) + { + return obj.value( "id" ).toString() ; + } + template< typename Function > + static void fromQJobject( const QJsonObject& obj,const Function& function ) + { + auto a = obj.value( "id" ).toString() ; + auto b = obj.value( "extension" ).toString() ; + auto c = obj.value( "resolution" ).toString() ; + auto d = obj.value( "filesize" ).toString() ; + auto e = obj.value( "info" ).toString() ; + + function( a,b,c,d,e ) ; + } + const QString& id() const + { + return m_id ; + } + const QString& ext() const + { + return m_extension ; + } + const QString& resolution() const + { + return m_resolution ; + } + const QString& fileSize() const + { + return m_fileSize ; + } + const QString& fileSizeRaw() const + { + return m_fileSizeRaw ; + } + const QString& info() const + { + return m_info ; + } + const QString& title() const + { + return m_title ; + } + const QString& duration() const + { + return m_duration ; + } + mediaInfo move() + { + return std::move( *this ) ; + } + private: + QStringList m_url ; + QString m_id ; + QString m_extension ; + QString m_resolution ; + QString m_fileSize ; + QString m_fileSizeRaw ; + QString m_info ; + QString m_duration ; + QString m_title ; + } ; + + virtual engines::metadata parseJsonDataFromGitHub( const QJsonDocument& ) ; + + virtual std::vector< engines::engine::baseEngine::mediaInfo > mediaProperties( Logger&,const QByteArray& ) ; + + virtual std::vector< engines::engine::baseEngine::mediaInfo > mediaProperties( Logger&,const QJsonArray& ) ; + + virtual void updateOutPutChannel( QProcess::ProcessChannel& ) const ; + + virtual bool breakShowListIfContains( const QStringList& ) ; + + virtual bool supportsShowingComments() ; + + virtual bool updateVersionInfo() ; + + virtual void setTextEncondig( const QString&,QStringList& opts ) ; + + virtual QString updateCmdPath( const QString& ) ; + + virtual engines::engine::baseEngine::DataFilter Filter( int ) ; + + virtual QString deleteEngineBinFolder( const QString& ) ; + + virtual void runCommandOnDownloadedFile( const std::vector< QByteArray >& ) ; + + virtual QString commandString( const engines::engine::exeArgs::cmd& ) ; + + virtual QStringList horizontalHeaderLabels() const ; + + virtual void updateEnginePaths( const Context&,QString& filePath,QString& exeBinPath,QString& exeFolderPath ) ; + + virtual void updateLocalOptions( QStringList& ) ; + + virtual void setProxySetting( QStringList&,const QString& ) ; + + virtual QString setCredentials( QStringList&,QStringList & ) ; + + virtual util::Json parsePlayListData( const QByteArray& ) ; + + struct localFile + { + const QString& uiText ; + const QString& downloadFolder ; + const QStringList& fileNames ; + }; + + virtual void openLocalFile( const engines::engine::baseEngine::localFile& ) ; + + struct onlineVersion + { + QString stringVersion ; + util::version version ; + onlineVersion move() + { + return std::move( *this ) ; + } + }; + + virtual engines::engine::baseEngine::onlineVersion versionInfoFromGithub( const QByteArray& ) ; + + virtual bool foundNetworkUrl( const QString& ) ; + + virtual void renameArchiveFolder( const QString&,const QString& ) ; + + QString updateTextOnCompleteDownlod( const QString& uiText, + const QString& downloadingOptions, + const engine::engine::baseEngine::finishedState& ) ; + + virtual QString updateTextOnCompleteDownlod( const QString& uiText, + const QString& bkText, + const QString& downloadingOptions, + const engine::engine::baseEngine::finishedState& ) ; + + virtual void sendCredentials( const QString&,QProcess& ) ; + + virtual void processData( Logger::Data&,const QByteArray&,int id,bool readableJson ) ; + + virtual void processData( Logger::Data&,const QString&,int id,bool readableJson ) ; + + struct updateOpts + { + template< typename Args,typename Ent > + updateOpts( const Args& args, + const Ent& ent, + const utility::uiIndex& ui, + QStringList& u, + QStringList& o ) : + uiOptions( args.uiDownloadOptions() ), + userOptions( args.otherOptions() ), + uiIndex( ui ), + credentials( args.credentials() ), + playlist( ent.playlist ), + playlist_count( ent.playlist_count ), + playlist_id( ent.playlist_id ), + playlist_title( ent.playlist_title ), + playlist_uploader( ent.playlist_uploader ), + playlist_uploader_id( ent.playlist_uploader_id ), + n_entries( ent.n_entries ), + urls( u ), + ourOptions( o ) + { + } + const QStringList& uiOptions ; + const QStringList& userOptions ; + const utility::uiIndex& uiIndex ; + const QString& credentials ; + const QString& playlist ; + const QString& playlist_count ; + const QString& playlist_id ; + const QString& playlist_title ; + const QString& playlist_uploader ; + const QString& playlist_uploader_id ; + const QString& n_entries ; + QStringList& urls ; + QStringList& ourOptions ; + }; + + virtual void updateDownLoadCmdOptions( const engines::engine::baseEngine::updateOpts&,bool ) ; + + virtual void updateGetPlaylistCmdOptions( QStringList& ) ; + + virtual void updateCmdOptions( QStringList& ) ; + + baseEngine( settings&,const engines::engine&,const QProcessEnvironment& e ) ; + settings& Settings() const ; + const engines::engine& engine() const ; + private: + settings& m_settings ; + const engines::engine& m_engine ; + const QProcessEnvironment& m_processEnvironment ; + } ; + + engine() + { + } + engine( const engines& engines, + Logger& logger, + const QString& name, + const QString& versionArgument, + int line, + int position, + int id ) ; + + engine( Logger& logger, + const enginePaths& ePaths, + const util::Json& json, + const engines& engines, + int id ) ; + + static QString mediaAlreadInArchiveText() + { + return QObject::tr( "Media Already In Archive" ) ; + } + + const QString& name() const + { + return m_name ; + } + + bool forTesting() const + { + return this->name().endsWith( "-test" ) ; + } + void updateLocalOptions( QStringList& opts ) const + { + m_engine->updateLocalOptions( opts ) ; + } + + template< typename Context,typename Function > + class uvic + { + public: + uvic( const engines::engine& engine, + const Context& ctx, + Function function ) : + m_engine( engine ), + m_ctx( ctx ), + m_function( std::move( function ) ) + { + } + void operator()( const utils::qprocess::outPut& e ) + { + if( e.success() ){ + + m_engine.setVersionString( e.stdOut ) ; + } + + m_ctx.TabManager().enableAll() ; + + m_function() ; + } + uvic< Context,Function > move() + { + return std::move( *this ) ; + } + private: + const engines::engine& m_engine ; + const Context& m_ctx ; + Function m_function ; + } ; + + template< typename Context,typename Function > + void updateVersionInfo( const Context& ctx,Function ff ) const + { + if( m_engine->updateVersionInfo() ){ + + const auto& engine = *this ; + + if( engine.versionInfo().valid() ){ + + ff() ; + }else{ + ctx.TabManager().disableAll() ; + + const auto& exe = engine.exePath() ; + QStringList args{ engine.versionArgument() } ; + + engines::engine::exeArgs::cmd cmd( exe,args ) ; + + this->setPermissions( cmd.exe() ) ; + + uvic< Context,Function > meaw( engine,ctx,std::move( ff ) ) ; + + auto m = QProcess::SeparateChannels ; + + utils::qprocess::run( cmd.exe(),cmd.args(),m,meaw.move() ) ; + } + }else{ + ff() ; + } + } + + template< typename backend,typename ... Args > + void setBackend( const engines& engines,Args&& ... args ) + { + m_engine = std::make_unique< backend >( engines, + *this, + m_jsonObject, + std::forward< Args >( args ) ... ) ; + + this->updateOptions() ; + } + + QString updateCmdPath( Logger&,const QString& e ) const ; + + const QString& commandName() const ; + + bool breakShowListIfContains( const QStringList& e ) const ; + + const QString& versionArgument() const + { + return m_versionArgument ; + } + + QString setVersionString( const QString& data ) const ; + QString versionString( const QString& data ) const ; + + const util::version& versionInfo() const + { + return m_version ; + } + const QString& optionsArgument() const + { + return m_optionsArgument ; + } + const QString& downloadUrl() const + { + return m_downloadUrl ; + } + bool validDownloadUrl() const + { + return m_downloadUrl.startsWith( "https://api.github.com" ) ; + } + void setTextEncondig( QStringList& opts ) const + { + m_engine->setTextEncondig( m_encodingArgument,opts ) ; + } + const QProcessEnvironment& processEnvironment() const + { + return m_engine->processEnvironment() ; + } + void processData( Logger::Data& outPut,const QByteArray& data,int id,bool readableJson ) const + { + m_engine->processData( outPut,data,id,readableJson ) ; + } + void processData( Logger::Data& outPut,const QString& data,int id,bool readableJson ) const + { + m_engine->processData( outPut,data,id,readableJson ) ; + } + void renameArchiveFolder( const QString& s,const QString& e ) const + { + return m_engine->renameArchiveFolder( s,e ) ; + } + QString commandString( const engines::engine::exeArgs::cmd& cmd ) const + { + return m_engine->commandString( cmd ) ; + } + void runCommandOnDownloadedFile( const QStringList& fileNames ) const + { + m_engine->runCommandOnDownloadedFile( fileNames ) ; + } + const QStringList& defaultDownLoadCmdOptions() const + { + return m_defaultDownLoadCmdOptions ; + } + QString setCredentials( QStringList& e,QStringList& s ) const + { + return m_engine->setCredentials( e,s ) ; + } + enum class tab{ basic,batch,playlist } ; + QStringList dumpJsonArguments( engines::engine::tab ) const ; + + engines::engine::baseEngine::DataFilter filter( int processId ) const + { + return m_engine->Filter( processId ) ; + } + QString updateTextOnCompleteDownlod( const QString& uiText, + const QString& bkText, + const QString& dopts, + const engine::engine::baseEngine::finishedState& f ) const + { + return m_engine->updateTextOnCompleteDownlod( uiText,bkText,dopts,f ) ; + } + void updateDownLoadCmdOptions( const engines::engine::baseEngine::updateOpts& u,bool e ) const + { + m_engine->updateDownLoadCmdOptions( u,e ) ; + } + void sendCredentials( const QString& credentials,QProcess& exe ) const + { + m_engine->sendCredentials( credentials,exe ) ; + } + std::vector< engines::engine::baseEngine::mediaInfo > mediaProperties( Logger& l,const QByteArray& e ) const + { + return m_engine->mediaProperties( l,e ) ; + } + void updateGetPlaylistCmdOptions( QStringList& e ) const + { + m_engine->updateGetPlaylistCmdOptions( e ) ; + } + void updateCmdOptions( QStringList& e ) const + { + m_engine->updateCmdOptions( e ) ; + } + util::Json parsePlayListData( const QByteArray& e ) const + { + return m_engine->parsePlayListData( e ) ; + } + bool archiveContainsFolder() const + { + return m_archiveContainsFolder ; + } + QString deleteEngineBinFolder( const QString& e ) const + { + return m_engine->deleteEngineBinFolder( e ) ; + } + engines::metadata parseJsonDataFromGitHub( const QJsonDocument& e ) const + { + return m_engine->parseJsonDataFromGitHub( e ) ; + } + engines::engine::baseEngine::FilterOutPut filterOutput() const + { + return m_engine->filterOutput() ; + } + bool foundNetworkUrl( const QString& s ) const + { + return m_engine->foundNetworkUrl( s ) ; + } + engines::engine::baseEngine::onlineVersion versionInfoFromGithub( const QByteArray& e ) const + { + return m_engine->versionInfoFromGithub( e ) ; + } + void setProxySetting( QStringList& e,const QString& s ) const + { + m_engine->setProxySetting( e,s ) ; + } + QStringList horizontalHeaderLabels() const + { + return m_engine->horizontalHeaderLabels() ; + } + void openLocalFile( const engines::engine::baseEngine::localFile& s ) const + { + m_engine->openLocalFile( s ) ; + } + void updateOutPutChannel( QProcess::ProcessChannel& s ) const + { + m_engine->updateOutPutChannel( s ) ; + } + std::vector< engines::engine::baseEngine::mediaInfo > mediaProperties( Logger& l,const QJsonArray& e ) const + { + return m_engine->mediaProperties( l,e ) ; + } + void updateEnginePaths( const Context& ctx,QString& filePath,QString& exeBinPath,QString& exeFolderPath ) const + { + m_engine->updateEnginePaths( ctx,filePath,exeBinPath,exeFolderPath ) ; + } + const QStringList& defaultListCmdOptions() const + { + return m_defaultListCmdOptions ; + } + const QStringList& defaultCommentsCmdOptions() const + { + return m_defaultCommentsCmdOptions ; + } + const QStringList& defaultSubstitlesCmdOptions() const + { + return m_defaultSubstitlesCmdOptions ; + } + const QStringList& defaultSubtitleDownloadOptions() const + { + return m_defaultSubtitleDownloadOptions ; + } + const QStringList& skiptLineWithText() const + { + return m_skiptLineWithText ; + } + const QStringList& removeText() const + { + return m_removeText ; + } + const QStringList& splitLinesBy() const + { + return m_splitLinesBy ; + } + const exeArgs& exePath() const + { + return m_exePath ; + } + const QString& batchFileArgument() const + { + return m_batchFileArgument ; + } + const QString& exeFolderPath() const + { + return m_exeFolderPath ; + } + const QString& userName() const + { + return m_userName ; + } + const QString& password() const + { + return m_password ; + } + const QString& playListUrlPrefix() const + { + return m_playListUrlPrefix ; + } + const QString& playlistItemsArgument() const + { + return m_playlistItemsArgument ; + } + const QString& cookieArgument() const + { + return m_cookieArgument ; + } + const QJsonObject& controlStructure() const + { + return m_controlStructure ; + } + bool canDownloadMediaPart() const + { + return this->likeYtDlp() ; + } + bool valid() const + { + return m_valid ; + } + bool supportShowingComments() const + { + return m_engine->supportsShowingComments() ; + } + bool canDownloadPlaylist() const + { + return m_canDownloadPlaylist ; + } + bool likeYtDlp() const + { + return m_likeYtDlp ; + } + bool backendExists() const + { + QFileInfo m( m_exePath.realExe() ) ; + return m.exists() && m.isFile() ; + } + bool autoUpdate() const + { + return m_autoUpdate ; + } + bool mainEngine() const + { + return m_mainEngine ; + } + bool replaceOutputWithProgressReport() const + { + return m_replaceOutputWithProgressReport ; + } + void setBroken() const + { + m_broken = true ; + } + bool broken() const + { + return m_broken ; + } + private: + void setPermissions( const QString& ) const ; + + void updateOptions() ; + + struct cmd + { + QString name ; + QStringList args ; + bool noCheckArgs ; + } ; + + engines::engine::cmd getCommands( const QJsonObject& ) ; + engines::engine::cmd getLegacyCommands() ; + + void parseMultipleCmdArgs( Logger& logger,const engines& engines,const enginePaths&,int ) ; + + void parseMultipleCmdArgs( QStringList&, + const QString&, + Logger& logger, + const enginePaths& ePaths, + const engines& engines, + int ) ; + + mutable util::version m_version ; + QJsonObject m_jsonObject ; + std::unique_ptr< engines::engine::baseEngine > m_engine ; + int m_line ; + int m_position ; + bool m_valid ; + bool m_autoUpdate ; + bool m_canDownloadPlaylist ; + bool m_mainEngine ; + bool m_archiveContainsFolder = false ; + bool m_replaceOutputWithProgressReport ; + mutable bool m_broken = false ; + QString m_versionArgument ; + QString m_name ; + bool m_likeYtDlp ; + QString m_commandName ; + QString m_userName ; + QString m_password ; + QString m_exeFolderPath ; + QString m_optionsArgument ; + QString m_downloadUrl ; + QString m_playListUrlPrefix ; + QString m_playlistItemsArgument ; + QString m_batchFileArgument ; + QString m_cookieArgument ; + QString m_encodingArgument ; + QStringList m_dumpJsonArguments ; + QStringList m_splitLinesBy ; + QStringList m_removeText ; + QStringList m_skiptLineWithText ; + QStringList m_defaultDownLoadCmdOptions ; + QStringList m_defaultListCmdOptions ; + QStringList m_defaultCommentsCmdOptions ; + QStringList m_defaultSubstitlesCmdOptions ; + QStringList m_defaultSubtitleDownloadOptions ; + + QJsonObject m_controlStructure ; + + mutable engines::engine::exeArgs m_exePath ; + }; + settings& Settings() const; + QString findExecutable( const QString& exeName ) const ; + const QProcessEnvironment& processEnvironment() const ; + QString addEngine( const QByteArray& data,const QString& path,int ) ; + void removeEngine( const QString& name,int ) ; + QStringList enginesList() const ; + const engine& defaultEngine( const QString&,int ) const ; + util::result_ref< const engines::engine& > getEngineByName( const QString& name ) const ; + const enginePaths& engineDirPaths() const ; + engines( Logger&,const engines::enginePaths&,settings&,int ) ; + void openUrls( tableWidget&,int row,const engines::engine& ) const ; + void openUrls( const QString& path ) const ; + const QString& defaultEngineName() const ; + class Iterator + { + public: + Iterator( const std::vector< engines::engine >& engines,int id ) : + m_maxCounter( engines.size() ), + m_engines( &engines ), + m_id( id ) + { + } + Iterator( const engines::engine& engine,int id ) : + m_maxCounter( 1 ), + m_engine( &engine ), + m_id( id ) + { + } + size_t size() const + { + return m_maxCounter ; + } + bool hasNext() const + { + return m_counter + 1 < m_maxCounter ; + } + engines::Iterator next() const + { + auto m = *this ; + m.m_counter++ ; + return m ; + } + const engines::engine& engine() const + { + if( m_engine ){ + + return *m_engine ; + }else{ + return ( *m_engines )[ m_counter ] ; + } + } + int id() const + { + return m_id ; + } + Iterator move() + { + return std::move( *this ) ; + } + private: + size_t m_counter = 0 ; + size_t m_maxCounter ; + const engines::engine * m_engine = nullptr ; + const std::vector< engines::engine > * m_engines = nullptr ; + int m_id ; + } ; + + const std::vector< engine >& getEngines() const ; + engines::Iterator getEnginesIterator() const ; + void setDefaultEngine( const QString& ) ; + void showBanner() ; + class proxySettings + { + public: + proxySettings() + { + } + proxySettings( const QByteArray& e ) : + m_networkProxyString( e ), + m_networkProxy( this->toQNetworkProxy( m_networkProxyString ) ) + { + } + proxySettings( const QString& e ) : + m_networkProxyString( e ), + m_networkProxy( this->toQNetworkProxy( m_networkProxyString ) ) + { + this->setDefaultProxy() ; + } + proxySettings( const QNetworkProxy& e ) : + m_networkProxyString( this->toString( e ) ), + m_networkProxy( e ) + { + this->setDefaultProxy() ; + } + const QString& networkProxyString() const + { + return m_networkProxyString ; + } + const QNetworkProxy& networkProxy() const + { + return m_networkProxy ; + } + bool isSet() const + { + return !m_networkProxyString.isEmpty() ; + } + proxySettings move() + { + return std::move( *this ) ; + } + bool operator!=( const proxySettings &other ) const ; + QNetworkProxy toQNetworkProxy( const QString& e ) const ; + void setApplicationProxy( const QString& ) const ; + void setDefaultProxy() const ; + private: + QString toString( const QNetworkProxy& ) const ; + QString m_networkProxyString ; + mutable QString m_currentProxyString ; + QNetworkProxy m_networkProxy ; + }; + const engines::proxySettings& networkProxy() const + { + return m_networkProxy ; + } + void setNetworkProxy( engines::proxySettings,bool ) ; +private: + void updateEngines( bool,int ) ; + Logger& m_logger ; + settings& m_settings ; + std::vector< engine > m_backends ; + const engines::enginePaths& m_enginePaths ; + QProcessEnvironment m_processEnvironment ; + engines::proxySettings m_networkProxy ; + int m_bannerId ; + class configDefaultEngine + { + public: + configDefaultEngine( Logger& logger,const enginePaths& enginePath ) ; + + const QString& name() const + { + return m_name ; + } + const QString& configFileName() const + { + return m_configFileName ; + } + private: + QString m_name ; + QString m_configFileName ; + } ; + + engines::configDefaultEngine m_defaultEngine ; +}; + +#endif diff --git a/src/engines/gallery-dl.cpp b/src/engines/gallery-dl.cpp index 6f4bb39f..6da23b2e 100644 --- a/src/engines/gallery-dl.cpp +++ b/src/engines/gallery-dl.cpp @@ -242,13 +242,13 @@ void gallery_dl::openLocalFile( const engines::engine::baseEngine::localFile& s if( s.fileNames.size() ){ const auto& e = s.downloadFolder ; - auto m = QUrl::fromLocalFile( e + "/gallery-dl/" + s.fileNames.last() ) ; + auto m = QUrl::fromLocalFile( e + "/gallery-dl/" + s.fileNames.back() ) ; QDesktopServices::openUrl( m ) ; } } -void gallery_dl::runCommandOnDownloadedFile( const QStringList& e ) +void gallery_dl::runCommandOnDownloadedFile( const std::vector< QByteArray >& e ) { auto& s = engines::engine::baseEngine::Settings() ; auto df = s.downloadFolder() + "/" + this->engine().name() + "/" ; @@ -387,7 +387,7 @@ const QByteArray& gallery_dl::gallery_dlFilter::operator()( Logger::Data& s ) if( !u.startsWith( "[media-downloader] cmd:" ) ){ - s.addFileName( ss ) ; + s.addFileName( ss.toUtf8() ) ; } }else{ n = u.indexOf( "./gallery-dl" ) ; @@ -398,7 +398,7 @@ const QByteArray& gallery_dl::gallery_dlFilter::operator()( Logger::Data& s ) if( !u.startsWith( "[media-downloader] cmd:" ) ){ - s.addFileName( ss ) ; + s.addFileName( ss.toUtf8() ) ; } } } @@ -406,14 +406,21 @@ const QByteArray& gallery_dl::gallery_dlFilter::operator()( Logger::Data& s ) const auto& m = s.fileNames() ; - if( !m.isEmpty() ){ + if( m.size() ){ if( m.size() < 4 ){ - m_tmp = m.join( "\n" ).toUtf8() ; + auto begin = m.begin() ; + + m_tmp = *begin ; + + for( auto it = begin + 1 ; begin != m.end() ; it++ ){ + + m_tmp += "\n" + *it ; + } }else{ auto a = QObject::tr( "%1 Already Downloaded" ).arg( QString::number( m.size() - 1 ) ) ; - m_tmp = a.toUtf8() + "\n" + m.last().toUtf8() ; + m_tmp = a.toUtf8() + "\n" + m.back() ; } if( s.lastLineIsProgressLine() ){ diff --git a/src/engines/gallery-dl.h b/src/engines/gallery-dl.h index 55216ea5..9a53d273 100644 --- a/src/engines/gallery-dl.h +++ b/src/engines/gallery-dl.h @@ -51,7 +51,7 @@ class gallery_dl : public engines::engine::baseEngine void openLocalFile( const engines::engine::baseEngine::localFile& ) override ; - void runCommandOnDownloadedFile( const QStringList& ) override ; + void runCommandOnDownloadedFile( const std::vector< QByteArray >& ) override ; void setProxySetting( QStringList&,const QString& ) override ; diff --git a/src/engines/yt-dlp.cpp b/src/engines/yt-dlp.cpp index b1676c0c..8f269da5 100644 --- a/src/engines/yt-dlp.cpp +++ b/src/engines/yt-dlp.cpp @@ -445,7 +445,7 @@ class parseTemplateOutPut static void setTemplate( QStringList& e ) { e.append( "--progress-template" ) ; - e.append( "download:[download] downloaded_bytes:%(progress.downloaded_bytes)s ETA:%(progress.eta)s total_bytes_estimate:%(progress.total_bytes_estimate)s total_bytes:%(progress.total_bytes)s progress.speed:%(progress.speed)s filename:%(progress.filename)s" ) ; + e.append( "download:[download] downloaded_bytes:%(progress.downloaded_bytes)s ETA:%(progress.eta)s total_bytes_estimate:%(progress.total_bytes_estimate)s total_bytes:%(progress.total_bytes)s progress.speed:%(progress.speed)s filename:%(progress.filename)r" ) ; } parseTemplateOutPut( const QByteArray& e ) : m_totalSize( this->findEntry( e,"total_bytes:" ) ), @@ -1316,7 +1316,7 @@ const QByteArray& yt_dlp::yt_dlplFilter::operator()( Logger::Data& s ) auto m = m_parent.m_settings->downloadFolder() ; - utility::deleteTmpFiles( m,std::move( m_fileNames ) ) ; + utility::deleteTmpFiles( m,m_fileNames ) ; } }else if( s.lastLineIsProgressLine() ){ @@ -1396,7 +1396,7 @@ const QByteArray& yt_dlp::yt_dlplFilter::operator()( Logger::Data& s ) } } - this->setFileName( s.ytDlpData().filePath() ) ; + //this->setFileName( s.ytDlpData().filePath() ) ; return this->parseOutput( m ) ; } @@ -1479,11 +1479,9 @@ void yt_dlp::yt_dlplFilter::setFileName( const QByteArray& fn ) auto downloadFolder = m_parent.m_settings->downloadFolder() ; - auto a = QDir::fromNativeSeparators( downloadFolder + "/" ) ; + auto a = QDir::toNativeSeparators( downloadFolder + "/" ) ; - auto b = QDir::fromNativeSeparators( fn ) ; - - auto fileName = b.replace( a,"" ).toUtf8() ; + auto fileName = fn.mid( a.size() ) ; for( const auto& it : m_fileNames ){ diff --git a/src/logger.h b/src/logger.h index c7d0ee53..da452a05 100644 --- a/src/logger.h +++ b/src/logger.h @@ -409,11 +409,11 @@ class Logger { return m_filePath ; } - void setFilePath( const QString& m ) + void setFilePath( const QByteArray& m ) { if( !m.isEmpty() && m != m_filePath ){ - m_filePath = m.toUtf8() ; + m_filePath = m ; } } private: @@ -450,11 +450,11 @@ class Logger { return m_fileName ; } - void setFileName( const QString& m ) + void setFileName( const QByteArray& m ) { if( !m.isEmpty() && m != m_fileName ){ - m_fileName = m.toUtf8() ; + m_fileName = m ; } } private: @@ -470,14 +470,19 @@ class Logger { return m_svtData ; } - void addFileName( const QString& e ) + void addFileName( const QByteArray& e ) { - if( !m_fileNames.contains( e ) ){ + for( const auto& it : m_fileNames ){ - m_fileNames.append( e ) ; + if( it == e ){ + + return ; + } } + + m_fileNames.emplace_back( e ) ; } - const QStringList& fileNames() const + const std::vector< QByteArray >& fileNames() const { return m_fileNames ; } @@ -526,7 +531,7 @@ class Logger bool m_mainLogger ; YtDlpData m_ytDlpData ; SvtData m_svtData ; - QStringList m_fileNames ; + std::vector< QByteArray > m_fileNames ; size_t m_maxLogEntries ; size_t m_longEntriesToRemove ; } ; @@ -562,7 +567,7 @@ class Logger void showLogWindow() ; void reTranslateLogWindow() ; void updateView( bool e ) ; - const QStringList& fileNames() + const std::vector< QByteArray >& fileNames() { return m_processOutPuts.fileNames() ; } @@ -618,7 +623,7 @@ class LoggerWrapper { return std::move( *this ) ; } - const QStringList& fileNames() + const std::vector< QByteArray >& fileNames() { return m_logger->fileNames() ; } @@ -681,7 +686,7 @@ class LoggerBasicDownloader { return std::move( *this ) ; } - const QStringList& fileNames() + const std::vector< QByteArray >& fileNames() { return m_localLogger.fileNames() ; } @@ -763,7 +768,7 @@ class loggerBatchDownloader m_error( data ) ; m_logger.logError( data,m_id ) ; } - const QStringList& fileNames() + const std::vector< QByteArray >& fileNames() { return m_localLogger.fileNames() ; } @@ -850,7 +855,7 @@ class loggerPlaylistDownloader m_logger.logError( data,m_id ) ; } } - const QStringList& fileNames() + const std::vector< QByteArray >& fileNames() { return m_localLogger.fileNames() ; } diff --git a/src/playlistdownloader.cpp b/src/playlistdownloader.cpp index 9c0fba30..32ae32dd 100644 --- a/src/playlistdownloader.cpp +++ b/src/playlistdownloader.cpp @@ -829,7 +829,7 @@ void playlistdownloader::download( const engines::engine& eng,int index ) return true ; } } - void done( engines::ProcessExitState e,QStringList s ) + void done( engines::ProcessExitState e,std::vector< QByteArray > s ) { event ev( m_parent,m_engine,std::move( s ) ) ; auto& h = m_parent.m_ccmd ; @@ -859,7 +859,7 @@ void playlistdownloader::download( const engines::engine& eng,int index ) class event { public: - event( playlistdownloader& p,const engines::engine& engine,QStringList s ) : + event( playlistdownloader& p,const engines::engine& engine,std::vector< QByteArray > s ) : m_parent( p ),m_engine( engine ),m_fileNames( std::move( s ) ) { } @@ -881,7 +881,7 @@ void playlistdownloader::download( const engines::engine& eng,int index ) private: playlistdownloader& m_parent ; const engines::engine& m_engine ; - QStringList m_fileNames ; + std::vector< QByteArray > m_fileNames ; } ; playlistdownloader& m_parent ; @@ -1051,7 +1051,7 @@ void playlistdownloader::getList( customOptions&& c, { return utility::addData( e ) ; } - void done( engines::ProcessExitState st,const QStringList& ) + void done( engines::ProcessExitState st,const std::vector< QByteArray >& ) { if( st.cancelled() ){ @@ -1273,7 +1273,8 @@ void playlistdownloader::addTextToUi( const QByteArray& data,int index ) } } -void playlistdownloader::reportFinishedStatus( const reportFinished& f,const QStringList& fileNames ) +void playlistdownloader::reportFinishedStatus( const reportFinished& f, + const std::vector< QByteArray >& fileNames ) { m_banner.updateTimer() ; diff --git a/src/playlistdownloader.h b/src/playlistdownloader.h index 098edc03..5c66f248 100644 --- a/src/playlistdownloader.h +++ b/src/playlistdownloader.h @@ -96,9 +96,9 @@ class playlistdownloader : public QObject private: signals: void addTextToUiSignal( const QByteArray&,int ) ; - void reportFinishedStatusSignal( const reportFinished&,const QStringList& ) ; + void reportFinishedStatusSignal( const reportFinished&,const std::vector< QByteArray >& ) ; private: - void reportFinishedStatus( const reportFinished&,const QStringList& ) ; + void reportFinishedStatus( const reportFinished&,const std::vector< QByteArray >& ) ; void networkData( const utility::networkReply& ) ; void addTextToUi( const QByteArray&,int ) ; diff --git a/src/settings.cpp b/src/settings.cpp index f40510a7..836bb2a5 100644 --- a/src/settings.cpp +++ b/src/settings.cpp @@ -1039,11 +1039,13 @@ const QString& settings::appDataPath() return m_appDataPath ; } -void settings::runCommandOnSuccessfulDownload( const QString& s,const QString& df,const QStringList& e ) +void settings::runCommandOnSuccessfulDownload( const QString& s, + const QString& df, + const std::vector< QByteArray >& e ) { auto m = this->getOption( "CommandOnSuccessfulDownload",QString() ) ; - if( !m.isEmpty() && !e.isEmpty() ){ + if( !m.isEmpty() && e.size() ){ auto args = util::splitPreserveQuotes( m ) ; diff --git a/src/settings.h b/src/settings.h index 84228111..8d1f03cf 100644 --- a/src/settings.h +++ b/src/settings.h @@ -167,7 +167,9 @@ class settings settings::mediaPlayer openWith( Logger& ) ; - void runCommandOnSuccessfulDownload( const QString&,const QString&,const QStringList& ) ; + void runCommandOnSuccessfulDownload( const QString&, + const QString&, + const std::vector< QByteArray >& ) ; QString downloadFolder() ; QString libraryDownloadFolder() ; diff --git a/src/tableWidget.h b/src/tableWidget.h index 682281ee..420dffcd 100644 --- a/src/tableWidget.h +++ b/src/tableWidget.h @@ -216,7 +216,7 @@ class tableWidget QJsonArray mediaProperties ; QJsonObject uiJson ; QPixmap thumbnail ; - QStringList fileNames ; + std::vector< QByteArray > fileNames ; bool splitByChapters = false ; bool banner = false ; bool showFirst = false ; @@ -245,7 +245,7 @@ class tableWidget { return m_items[ s ] ; } - void setFileNames( size_t m,const QStringList& s ) + void setFileNames( size_t m,const std::vector< QByteArray >& s ) { m_items[ m ].fileNames = s ; } diff --git a/src/utility.h b/src/utility.h index ea82810a..cab11cfe 100644 --- a/src/utility.h +++ b/src/utility.h @@ -1277,7 +1277,7 @@ namespace utility m_engine.processData( e,d,id,s ) ; } ) ; - m_events.done( state,QStringList() ) ; + m_events.done( state,{} ) ; } } void withData( QProcess::ProcessChannel channel,const QByteArray& data ) @@ -1692,7 +1692,7 @@ namespace utility settings& s, tableWidget& table, const FinishedState& f, - const QStringList& fileNames ) + const std::vector< QByteArray >& fileNames ) { const auto& index = f.index() ; const auto& es = f.exitState() ;