mirror of
https://github.com/MultiMC/MultiMC5.git
synced 2024-09-02 13:09:22 +00:00
GH-366: Plain and simple modpack export/import/download
Also removed the in-source QuaZIP in favour of upstream version
This commit is contained in:
parent
f9a17eb9de
commit
a53f8d506e
@ -210,10 +210,23 @@ set(DIRS "${QT_LIBS_DIR}")
|
||||
|
||||
################################ Included Libs ################################
|
||||
|
||||
include(ExternalProject)
|
||||
set_directory_properties(PROPERTIES EP_BASE External)
|
||||
|
||||
# Add quazip
|
||||
add_definitions(-DQUAZIP_STATIC)
|
||||
add_subdirectory(depends/quazip)
|
||||
include_directories(depends/quazip)
|
||||
set(QUAZIP_VERSION "0.7.1")
|
||||
if(NOT EXISTS ${CMAKE_BINARY_DIR}/quazip-${QUAZIP_VERSION}.tar.gz)
|
||||
file(DOWNLOAD http://downloads.sourceforge.net/project/quazip/quazip/${QUAZIP_VERSION}/quazip-${QUAZIP_VERSION}.tar.gz ${CMAKE_BINARY_DIR}/quazip-${QUAZIP_VERSION}.tar.gz)
|
||||
endif()
|
||||
ExternalProject_Add(QuaZIP
|
||||
SOURCE_DIR <BINARY_DIR>/../Source/quazip-${QUAZIP_VERSION}
|
||||
DOWNLOAD_COMMAND ${CMAKE_COMMAND} -E chdir <SOURCE_DIR>/.. ${CMAKE_COMMAND} -E tar xzf ${CMAKE_BINARY_DIR}/quazip-${QUAZIP_VERSION}.tar.gz
|
||||
PATCH_COMMAND patch -p0 -i ${CMAKE_SOURCE_DIR}/quazip.patch
|
||||
CMAKE_ARGS -DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER} -DCMAKE_C_COMPILER=${CMAKE_C_COMPILER} -DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS} -DCMAKE_CXX_FLAGS_DEBUG=${CMAKE_CXX_FLAGS_DEBUG} -DCMAKE_PREFIX_PATH=${CMAKE_PREFIX_PATH} -DCMAKE_INSTALL_PREFIX=<INSTALL_DIR>
|
||||
)
|
||||
include_directories("${CMAKE_BINARY_DIR}/External/Install/QuaZIP/include/quazip")
|
||||
set(QUAZIP_LIBRARIES -L"${CMAKE_BINARY_DIR}/External/Install/QuaZIP/lib" quazip)
|
||||
|
||||
# Add the java launcher and checker
|
||||
add_subdirectory(depends/launcher)
|
||||
@ -728,10 +741,12 @@ add_executable(MultiMC MACOSX_BUNDLE WIN32 main.cpp ${MULTIMC_RCS})
|
||||
|
||||
# Link
|
||||
target_link_libraries(MultiMC MultiMC_common)
|
||||
target_link_libraries(MultiMC_common xz-embedded unpack200 quazip libUtil LogicalGui ${MultiMC_LINK_ADDITIONAL_LIBS})
|
||||
target_link_libraries(MultiMC_common xz-embedded unpack200 libUtil LogicalGui ${QUAZIP_LIBRARIES} ${MultiMC_LINK_ADDITIONAL_LIBS})
|
||||
qt5_use_modules(MultiMC Core Widgets Network Xml Concurrent WebKitWidgets ${MultiMC_QT_ADDITIONAL_MODULES})
|
||||
qt5_use_modules(MultiMC_common Core Widgets Network Xml Concurrent WebKitWidgets ${MultiMC_QT_ADDITIONAL_MODULES})
|
||||
|
||||
add_dependencies(MultiMC_common QuaZip)
|
||||
|
||||
################################ INSTALLATION AND PACKAGING ################################
|
||||
|
||||
######## Install ########
|
||||
|
@ -551,6 +551,7 @@ void MultiMC::initHttpMetaCache()
|
||||
m_metacache->addBase("minecraftforge", QDir("mods/minecraftforge").absolutePath());
|
||||
m_metacache->addBase("fmllibs", QDir("mods/minecraftforge/libs").absolutePath());
|
||||
m_metacache->addBase("liteloader", QDir("mods/liteloader").absolutePath());
|
||||
m_metacache->addBase("general", QDir("cache").absolutePath());
|
||||
m_metacache->addBase("skins", QDir("accounts/skins").absolutePath());
|
||||
m_metacache->addBase("root", QDir(root()).absolutePath());
|
||||
m_metacache->addBase("translations", QDir(staticData() + "/translations").absolutePath());
|
||||
|
@ -1,31 +0,0 @@
|
||||
project(quazip)
|
||||
|
||||
# Find ZLIB for quazip
|
||||
# Use system zlib on unix and Qt ZLIB on Windows
|
||||
if(UNIX)
|
||||
find_package(ZLIB REQUIRED)
|
||||
else(UNIX)
|
||||
get_filename_component(ZLIB_FOUND_DIR "${Qt5Core_DIR}/../../../include/QtZlib" ABSOLUTE)
|
||||
set(ZLIB_INCLUDE_DIRS ${ZLIB_FOUND_DIR} CACHE PATH "Path to ZLIB headers of Qt")
|
||||
set(ZLIB_LIBRARIES "")
|
||||
if(NOT EXISTS "${ZLIB_INCLUDE_DIRS}/zlib.h")
|
||||
message("Please specify a valid zlib include dir")
|
||||
endif(NOT EXISTS "${ZLIB_INCLUDE_DIRS}/zlib.h")
|
||||
endif(UNIX)
|
||||
|
||||
# set all include directories for in and out of source builds
|
||||
include_directories(
|
||||
${CMAKE_CURRENT_SOURCE_DIR}
|
||||
${CMAKE_CURRENT_BINARY_DIR}
|
||||
${ZLIB_INCLUDE_DIRS}
|
||||
)
|
||||
|
||||
file(GLOB SRCS "*.c" "*.cpp")
|
||||
file(GLOB PUBLIC_HEADERS "*.h")
|
||||
|
||||
# Static link!
|
||||
add_definitions(-DQUAZIP_STATIC)
|
||||
|
||||
add_library(quazip STATIC ${SRCS})
|
||||
qt5_use_modules(quazip Core)
|
||||
target_link_libraries(quazip ${ZLIB_LIBRARIES})
|
@ -1,522 +0,0 @@
|
||||
#include "JlCompress.h"
|
||||
#include <QDebug>
|
||||
|
||||
bool JlCompress::copyData(QIODevice &inFile, QIODevice &outFile)
|
||||
{
|
||||
while (!inFile.atEnd()) {
|
||||
char buf[4096];
|
||||
qint64 readLen = inFile.read(buf, 4096);
|
||||
if (readLen <= 0)
|
||||
return false;
|
||||
if (outFile.write(buf, readLen) != readLen)
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**OK
|
||||
* Comprime il file fileName, nell'oggetto zip, con il nome fileDest.
|
||||
*
|
||||
* La funzione fallisce se:
|
||||
* * zip==NULL;
|
||||
* * l'oggetto zip e stato aperto in una modalita non compatibile con l'aggiunta di file;
|
||||
* * non e possibile aprire il file d'origine;
|
||||
* * non e possibile creare il file all'interno dell'oggetto zip;
|
||||
* * si e rilevato un errore nella copia dei dati;
|
||||
* * non e stato possibile chiudere il file all'interno dell'oggetto zip;
|
||||
*/
|
||||
bool JlCompress::compressFile(QuaZip* zip, QString fileName, QString fileDest) {
|
||||
// zip: oggetto dove aggiungere il file
|
||||
// fileName: nome del file reale
|
||||
// fileDest: nome del file all'interno del file compresso
|
||||
|
||||
// Controllo l'apertura dello zip
|
||||
if (!zip) return false;
|
||||
if (zip->getMode()!=QuaZip::mdCreate &&
|
||||
zip->getMode()!=QuaZip::mdAppend &&
|
||||
zip->getMode()!=QuaZip::mdAdd) return false;
|
||||
|
||||
// Apro il file originale
|
||||
QFile inFile;
|
||||
inFile.setFileName(fileName);
|
||||
if(!inFile.open(QIODevice::ReadOnly)) return false;
|
||||
|
||||
// Apro il file risulato
|
||||
QuaZipFile outFile(zip);
|
||||
if(!outFile.open(QIODevice::WriteOnly, QuaZipNewInfo(fileDest, inFile.fileName()))) return false;
|
||||
|
||||
// Copio i dati
|
||||
if (!copyData(inFile, outFile) || outFile.getZipError()!=UNZ_OK) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Chiudo i file
|
||||
outFile.close();
|
||||
if (outFile.getZipError()!=UNZ_OK) return false;
|
||||
inFile.close();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**OK
|
||||
* Comprime la cartella dir nel file fileCompressed, se recursive e true allora
|
||||
* comprime anche le sotto cartelle. I nomi dei file preceduti dal path creato
|
||||
* togliendo il pat della cartella origDir al path della cartella dir.
|
||||
* Se la funzione fallisce restituisce false e cancella il file che si e tentato
|
||||
* di creare.
|
||||
*
|
||||
* La funzione fallisce se:
|
||||
* * zip==NULL;
|
||||
* * l'oggetto zip e stato aperto in una modalita non compatibile con l'aggiunta di file;
|
||||
* * la cartella dir non esiste;
|
||||
* * la compressione di una sotto cartella fallisce (1);
|
||||
* * la compressione di un file fallisce;
|
||||
* (1) La funzione si richiama in maniera ricorsiva per comprimere le sotto cartelle
|
||||
* dunque gli errori di compressione di una sotto cartella sono gli stessi di questa
|
||||
* funzione.
|
||||
*/
|
||||
bool JlCompress::compressSubDir( QuaZip* parentZip, QString dir, QString parentDir, bool recursive, QSet<QString>& added )
|
||||
{
|
||||
// zip: oggetto dove aggiungere il file
|
||||
// dir: cartella reale corrente
|
||||
// origDir: cartella reale originale
|
||||
// (path(dir)-path(origDir)) = path interno all'oggetto zip
|
||||
|
||||
// Controllo l'apertura dello zip
|
||||
if (!parentZip ) return false;
|
||||
if ( parentZip->getMode()!=QuaZip::mdCreate &&
|
||||
parentZip->getMode()!=QuaZip::mdAppend &&
|
||||
parentZip->getMode()!=QuaZip::mdAdd) return false;
|
||||
|
||||
// Controllo la cartella
|
||||
QDir directory(dir);
|
||||
if (!directory.exists()) return false;
|
||||
|
||||
// Se comprimo anche le sotto cartelle
|
||||
if (recursive) {
|
||||
// Per ogni sotto cartella
|
||||
QFileInfoList files = directory.entryInfoList(QDir::AllDirs|QDir::NoDotAndDotDot);
|
||||
Q_FOREACH (QFileInfo file, files)
|
||||
{
|
||||
// Comprimo la sotto cartella
|
||||
if(!compressSubDir( parentZip,file.absoluteFilePath(),parentDir,recursive,added)) return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Per ogni file nella cartella
|
||||
QFileInfoList files = directory.entryInfoList(QDir::Files);
|
||||
QDir origDirectory( parentDir );
|
||||
Q_FOREACH (QFileInfo file, files)
|
||||
{
|
||||
// Se non e un file o e il file compresso che sto creando
|
||||
if(!file.isFile()||file.absoluteFilePath()==parentZip->getZipName()) continue;
|
||||
|
||||
// Creo il nome relativo da usare all'interno del file compresso
|
||||
QString filename = origDirectory.relativeFilePath(file.absoluteFilePath());
|
||||
|
||||
// Comprimo il file
|
||||
if (!compressFile( parentZip,file.absoluteFilePath(),filename))
|
||||
return false;
|
||||
added.insert(filename);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**OK
|
||||
* Estrae il file fileName, contenuto nell'oggetto zip, con il nome fileDest.
|
||||
* Se la funzione fallisce restituisce false e cancella il file che si e tentato di estrarre.
|
||||
*
|
||||
* La funzione fallisce se:
|
||||
* * zip==NULL;
|
||||
* * l'oggetto zip e stato aperto in una modalita non compatibile con l'estrazione di file;
|
||||
* * non e possibile aprire il file all'interno dell'oggetto zip;
|
||||
* * non e possibile creare il file estratto;
|
||||
* * si e rilevato un errore nella copia dei dati (1);
|
||||
* * non e stato possibile chiudere il file all'interno dell'oggetto zip (1);
|
||||
*
|
||||
* (1): prima di uscire dalla funzione cancella il file estratto.
|
||||
*/
|
||||
bool JlCompress::extractFile(QuaZip* zip, QString fileName, QString fileDest) {
|
||||
// zip: oggetto dove aggiungere il file
|
||||
// filename: nome del file reale
|
||||
// fileincompress: nome del file all'interno del file compresso
|
||||
|
||||
// Controllo l'apertura dello zip
|
||||
if (!zip) return false;
|
||||
if (zip->getMode()!=QuaZip::mdUnzip) return false;
|
||||
|
||||
// Apro il file compresso
|
||||
if (!fileName.isEmpty())
|
||||
zip->setCurrentFile(fileName);
|
||||
QuaZipFile inFile(zip);
|
||||
if(!inFile.open(QIODevice::ReadOnly) || inFile.getZipError()!=UNZ_OK) return false;
|
||||
|
||||
// Controllo esistenza cartella file risultato
|
||||
QDir curDir;
|
||||
if (!curDir.mkpath(QFileInfo(fileDest).absolutePath())) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (QFileInfo(fileDest).isDir())
|
||||
return true;
|
||||
|
||||
// Apro il file risultato
|
||||
QFile outFile;
|
||||
outFile.setFileName(fileDest);
|
||||
if(!outFile.open(QIODevice::WriteOnly)) return false;
|
||||
|
||||
// Copio i dati
|
||||
if (!copyData(inFile, outFile) || inFile.getZipError()!=UNZ_OK) {
|
||||
outFile.close();
|
||||
removeFile(QStringList(fileDest));
|
||||
return false;
|
||||
}
|
||||
outFile.close();
|
||||
|
||||
// Chiudo i file
|
||||
inFile.close();
|
||||
if (inFile.getZipError()!=UNZ_OK) {
|
||||
removeFile(QStringList(fileDest));
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Rimuove i file il cui nome e specificato all'interno di listFile.
|
||||
* Restituisce true se tutti i file sono stati cancellati correttamente, attenzione
|
||||
* perche puo restituire false anche se alcuni file non esistevano e si e tentato
|
||||
* di cancellarli.
|
||||
*/
|
||||
bool JlCompress::removeFile(QStringList listFile) {
|
||||
bool ret = true;
|
||||
// Per ogni file
|
||||
for (int i=0; i<listFile.count(); i++) {
|
||||
// Lo elimino
|
||||
ret = ret && QFile::remove(listFile.at(i));
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/**OK
|
||||
* Comprime il file fileName nel file fileCompressed.
|
||||
* Se la funzione fallisce restituisce false e cancella il file che si e tentato
|
||||
* di creare.
|
||||
*
|
||||
* La funzione fallisce se:
|
||||
* * non si riesce ad aprire l'oggetto zip;
|
||||
* * la compressione del file fallisce;
|
||||
* * non si riesce a chiudere l'oggetto zip;
|
||||
*/
|
||||
bool JlCompress::compressFile(QString fileCompressed, QString file) {
|
||||
// Creo lo zip
|
||||
QuaZip zip(fileCompressed);
|
||||
QDir().mkpath(QFileInfo(fileCompressed).absolutePath());
|
||||
if(!zip.open(QuaZip::mdCreate)) {
|
||||
QFile::remove(fileCompressed);
|
||||
return false;
|
||||
}
|
||||
|
||||
// Aggiungo il file
|
||||
if (!compressFile(&zip,file,QFileInfo(file).fileName())) {
|
||||
QFile::remove(fileCompressed);
|
||||
return false;
|
||||
}
|
||||
|
||||
// Chiudo il file zip
|
||||
zip.close();
|
||||
if(zip.getZipError()!=0) {
|
||||
QFile::remove(fileCompressed);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**OK
|
||||
* Comprime i file specificati in files nel file fileCompressed.
|
||||
* Se la funzione fallisce restituisce false e cancella il file che si e tentato
|
||||
* di creare.
|
||||
*
|
||||
* La funzione fallisce se:
|
||||
* * non si riesce ad aprire l'oggetto zip;
|
||||
* * la compressione di un file fallisce;
|
||||
* * non si riesce a chiudere l'oggetto zip;
|
||||
*/
|
||||
bool JlCompress::compressFiles(QString fileCompressed, QStringList files) {
|
||||
// Creo lo zip
|
||||
QuaZip zip(fileCompressed);
|
||||
QDir().mkpath(QFileInfo(fileCompressed).absolutePath());
|
||||
if(!zip.open(QuaZip::mdCreate)) {
|
||||
QFile::remove(fileCompressed);
|
||||
return false;
|
||||
}
|
||||
|
||||
// Comprimo i file
|
||||
QFileInfo info;
|
||||
Q_FOREACH (QString file, files) {
|
||||
info.setFile(file);
|
||||
if (!info.exists() || !compressFile(&zip,file,info.fileName())) {
|
||||
QFile::remove(fileCompressed);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Chiudo il file zip
|
||||
zip.close();
|
||||
if(zip.getZipError()!=0) {
|
||||
QFile::remove(fileCompressed);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**OK
|
||||
* Comprime la cartella dir nel file fileCompressed, se recursive e true allora
|
||||
* comprime anche le sotto cartelle.
|
||||
* Se la funzione fallisce restituisce false e cancella il file che si e tentato
|
||||
* di creare.
|
||||
*
|
||||
* La funzione fallisce se:
|
||||
* * non si riesce ad aprire l'oggetto zip;
|
||||
* * la compressione di un file fallisce;
|
||||
* * non si riesce a chiudere l'oggetto zip;
|
||||
*/
|
||||
bool JlCompress::compressDir(QString fileCompressed, QString dir, bool recursive) {
|
||||
// Creo lo zip
|
||||
QuaZip zip(fileCompressed);
|
||||
QDir().mkpath(QFileInfo(fileCompressed).absolutePath());
|
||||
if(!zip.open(QuaZip::mdCreate)) {
|
||||
QFile::remove(fileCompressed);
|
||||
return false;
|
||||
}
|
||||
QSet<QString> added;
|
||||
// Aggiungo i file e le sotto cartelle
|
||||
if (!compressSubDir(&zip,dir,dir,recursive, added))
|
||||
{
|
||||
QFile::remove(fileCompressed);
|
||||
return false;
|
||||
}
|
||||
|
||||
// Chiudo il file zip
|
||||
zip.close();
|
||||
if(zip.getZipError()!=0) {
|
||||
QFile::remove(fileCompressed);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
/**OK
|
||||
* Estrae il file fileName, contenuto nel file fileCompressed, con il nome fileDest.
|
||||
* Se fileDest = "" allora il file viene estratto con lo stesso nome con cui e
|
||||
* stato compresso.
|
||||
* Se la funzione fallisce cancella il file che si e tentato di estrarre.
|
||||
* Restituisce il nome assoluto del file estratto.
|
||||
*
|
||||
* La funzione fallisce se:
|
||||
* * non si riesce ad aprire l'oggetto zip;
|
||||
* * l'estrazione del file fallisce;
|
||||
* * non si riesce a chiudere l'oggetto zip;
|
||||
*/
|
||||
QString JlCompress::extractFile(QString fileCompressed, QString fileName, QString fileDest) {
|
||||
// Apro lo zip
|
||||
QuaZip zip(fileCompressed);
|
||||
if(!zip.open(QuaZip::mdUnzip)) {
|
||||
return QString();
|
||||
}
|
||||
|
||||
// Estraggo il file
|
||||
if (fileDest.isEmpty())
|
||||
fileDest = fileName;
|
||||
if (!extractFile(&zip,fileName,fileDest)) {
|
||||
return QString();
|
||||
}
|
||||
|
||||
// Chiudo il file zip
|
||||
zip.close();
|
||||
if(zip.getZipError()!=0) {
|
||||
removeFile(QStringList(fileDest));
|
||||
return QString();
|
||||
}
|
||||
return QFileInfo(fileDest).absoluteFilePath();
|
||||
}
|
||||
|
||||
/**OK
|
||||
* Estrae i file specificati in files, contenuti nel file fileCompressed, nella
|
||||
* cartella dir. La struttura a cartelle del file compresso viene rispettata.
|
||||
* Se dir = "" allora il file viene estratto nella cartella corrente.
|
||||
* Se la funzione fallisce cancella i file che si e tentato di estrarre.
|
||||
* Restituisce i nomi assoluti dei file estratti.
|
||||
*
|
||||
* La funzione fallisce se:
|
||||
* * non si riesce ad aprire l'oggetto zip;
|
||||
* * l'estrazione di un file fallisce;
|
||||
* * non si riesce a chiudere l'oggetto zip;
|
||||
*/
|
||||
QStringList JlCompress::extractFiles(QString fileCompressed, QStringList files, QString dir) {
|
||||
// Creo lo zip
|
||||
QuaZip zip(fileCompressed);
|
||||
if(!zip.open(QuaZip::mdUnzip)) {
|
||||
return QStringList();
|
||||
}
|
||||
|
||||
// Estraggo i file
|
||||
QStringList extracted;
|
||||
for (int i=0; i<files.count(); i++) {
|
||||
QString absPath = QDir(dir).absoluteFilePath(files.at(i));
|
||||
if (!extractFile(&zip, files.at(i), absPath)) {
|
||||
removeFile(extracted);
|
||||
return QStringList();
|
||||
}
|
||||
extracted.append(absPath);
|
||||
}
|
||||
|
||||
// Chiudo il file zip
|
||||
zip.close();
|
||||
if(zip.getZipError()!=0) {
|
||||
removeFile(extracted);
|
||||
return QStringList();
|
||||
}
|
||||
|
||||
return extracted;
|
||||
}
|
||||
|
||||
QStringList JlCompress::extractWithExceptions(QString fileCompressed, QString dir, QStringList exceptions)
|
||||
{
|
||||
QuaZip zip(fileCompressed);
|
||||
if(!zip.open(QuaZip::mdUnzip))
|
||||
{
|
||||
return QStringList();
|
||||
}
|
||||
|
||||
QDir directory(dir);
|
||||
QStringList extracted;
|
||||
if (!zip.goToFirstFile())
|
||||
{
|
||||
return QStringList();
|
||||
}
|
||||
do
|
||||
{
|
||||
QString name = zip.getCurrentFileName();
|
||||
bool ok = true;
|
||||
for(auto str: exceptions)
|
||||
{
|
||||
if(name.startsWith(str))
|
||||
{
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if(!ok)
|
||||
continue;
|
||||
QString absFilePath = directory.absoluteFilePath(name);
|
||||
if (!JlCompress::extractFile(&zip, "", absFilePath))
|
||||
{
|
||||
JlCompress::removeFile(extracted);
|
||||
return QStringList();
|
||||
}
|
||||
extracted.append(absFilePath);
|
||||
} while (zip.goToNextFile());
|
||||
|
||||
zip.close();
|
||||
if(zip.getZipError()!=0)
|
||||
{
|
||||
JlCompress::removeFile(extracted);
|
||||
return QStringList();
|
||||
}
|
||||
|
||||
return extracted;
|
||||
}
|
||||
|
||||
/**OK
|
||||
* Estrae il file fileCompressed nella cartella dir.
|
||||
* Se dir = "" allora il file viene estratto nella cartella corrente.
|
||||
* Se la funzione fallisce cancella i file che si e tentato di estrarre.
|
||||
* Restituisce i nomi assoluti dei file estratti.
|
||||
*
|
||||
* La funzione fallisce se:
|
||||
* * non si riesce ad aprire l'oggetto zip;
|
||||
* * la compressione di un file fallisce;
|
||||
* * non si riesce a chiudere l'oggetto zip;
|
||||
*/
|
||||
QStringList JlCompress::extractDir(QString fileCompressed, QString dir) {
|
||||
// Apro lo zip
|
||||
QuaZip zip(fileCompressed);
|
||||
if(!zip.open(QuaZip::mdUnzip)) {
|
||||
return QStringList();
|
||||
}
|
||||
|
||||
QDir directory(dir);
|
||||
QStringList extracted;
|
||||
if (!zip.goToFirstFile()) {
|
||||
return QStringList();
|
||||
}
|
||||
do {
|
||||
QString name = zip.getCurrentFileName();
|
||||
QString absFilePath = directory.absoluteFilePath(name);
|
||||
if (!extractFile(&zip, "", absFilePath)) {
|
||||
removeFile(extracted);
|
||||
return QStringList();
|
||||
}
|
||||
extracted.append(absFilePath);
|
||||
} while (zip.goToNextFile());
|
||||
|
||||
// Chiudo il file zip
|
||||
zip.close();
|
||||
if(zip.getZipError()!=0) {
|
||||
removeFile(extracted);
|
||||
return QStringList();
|
||||
}
|
||||
|
||||
return extracted;
|
||||
}
|
||||
|
||||
/**OK
|
||||
* Restituisce la lista dei file resenti nel file compresso fileCompressed.
|
||||
* Se la funzione fallisce, restituisce un elenco vuoto.
|
||||
*
|
||||
* La funzione fallisce se:
|
||||
* * non si riesce ad aprire l'oggetto zip;
|
||||
* * la richiesta di informazioni di un file fallisce;
|
||||
* * non si riesce a chiudere l'oggetto zip;
|
||||
*/
|
||||
QStringList JlCompress::getFileList(QString fileCompressed) {
|
||||
// Apro lo zip
|
||||
QuaZip* zip = new QuaZip(QFileInfo(fileCompressed).absoluteFilePath());
|
||||
if(!zip->open(QuaZip::mdUnzip)) {
|
||||
delete zip;
|
||||
return QStringList();
|
||||
}
|
||||
|
||||
// Estraggo i nomi dei file
|
||||
QStringList lst;
|
||||
QuaZipFileInfo info;
|
||||
for(bool more=zip->goToFirstFile(); more; more=zip->goToNextFile()) {
|
||||
if(!zip->getCurrentFileInfo(&info)) {
|
||||
delete zip;
|
||||
return QStringList();
|
||||
}
|
||||
lst << info.name;
|
||||
//info.name.toLocal8Bit().constData()
|
||||
}
|
||||
|
||||
// Chiudo il file zip
|
||||
zip->close();
|
||||
if(zip->getZipError()!=0) {
|
||||
delete zip;
|
||||
return QStringList();
|
||||
}
|
||||
delete zip;
|
||||
|
||||
return lst;
|
||||
}
|
||||
|
@ -1,125 +0,0 @@
|
||||
#ifndef JLCOMPRESSFOLDER_H_
|
||||
#define JLCOMPRESSFOLDER_H_
|
||||
|
||||
#include "quazip.h"
|
||||
#include "quazipfile.h"
|
||||
#include "quazipfileinfo.h"
|
||||
#include <QString>
|
||||
#include <QDir>
|
||||
#include <QFileInfo>
|
||||
#include <QFile>
|
||||
|
||||
/// Utility class for typical operations.
|
||||
/**
|
||||
This class contains a number of useful static functions to perform
|
||||
simple operations, such as mass ZIP packing or extraction.
|
||||
*/
|
||||
class QUAZIP_EXPORT JlCompress {
|
||||
private:
|
||||
/// Remove some files.
|
||||
/**
|
||||
\param listFile The list of files to remove.
|
||||
\return true if success, false otherwise.
|
||||
*/
|
||||
static bool removeFile(QStringList listFile);
|
||||
public:
|
||||
/// Compress a single file.
|
||||
/**
|
||||
\param zip Opened zip to compress the file to.
|
||||
\param fileName The full path to the source file.
|
||||
\param fileDest The full name of the file inside the archive.
|
||||
\return true if success, false otherwise.
|
||||
*/
|
||||
static bool compressFile(QuaZip* zip, QString fileName, QString fileDest);
|
||||
/// Compress a subdirectory.
|
||||
/**
|
||||
\param parentZip Opened zip containing the parent directory.
|
||||
\param dir The full path to the directory to pack.
|
||||
\param parentDir The full path to the directory corresponding to
|
||||
the root of the ZIP.
|
||||
\param recursive Whether to pack sub-directories as well or only
|
||||
files.
|
||||
\return true if success, false otherwise.
|
||||
*/
|
||||
static bool compressSubDir( QuaZip* parentZip, QString dir, QString parentDir, bool recursive, QSet< QString >& added );
|
||||
/// Extract a single file.
|
||||
/**
|
||||
\param zip The opened zip archive to extract from.
|
||||
\param fileName The full name of the file to extract.
|
||||
\param fileDest The full path to the destination file.
|
||||
\return true if success, false otherwise.
|
||||
*/
|
||||
static bool extractFile(QuaZip* zip, QString fileName, QString fileDest);
|
||||
|
||||
/// copy data from inFile to outFile
|
||||
static bool copyData(QIODevice &inFile, QIODevice &outFile);
|
||||
/// Compress a single file.
|
||||
/**
|
||||
\param fileCompressed The name of the archive.
|
||||
\param file The file to compress.
|
||||
\return true if success, false otherwise.
|
||||
*/
|
||||
static bool compressFile(QString fileCompressed, QString file);
|
||||
/// Compress a list of files.
|
||||
/**
|
||||
\param fileCompressed The name of the archive.
|
||||
\param files The file list to compress.
|
||||
\return true if success, false otherwise.
|
||||
*/
|
||||
static bool compressFiles(QString fileCompressed, QStringList files);
|
||||
/// Compress a whole directory.
|
||||
/**
|
||||
\param fileCompressed The name of the archive.
|
||||
\param dir The directory to compress.
|
||||
\param recursive Whether to pack the subdirectories as well, or
|
||||
just regular files.
|
||||
\return true if success, false otherwise.
|
||||
*/
|
||||
static bool compressDir(QString fileCompressed, QString dir = QString(), bool recursive = true);
|
||||
|
||||
public:
|
||||
/// Extract a single file.
|
||||
/**
|
||||
\param fileCompressed The name of the archive.
|
||||
\param fileName The file to extract.
|
||||
\param fileDest The destination file, assumed to be identical to
|
||||
\a file if left empty.
|
||||
\return The list of the full paths of the files extracted, empty on failure.
|
||||
*/
|
||||
static QString extractFile(QString fileCompressed, QString fileName, QString fileDest = QString());
|
||||
/// Extract a list of files.
|
||||
/**
|
||||
\param fileCompressed The name of the archive.
|
||||
\param files The file list to extract.
|
||||
\param dir The directory to put the files to, the current
|
||||
directory if left empty.
|
||||
\return The list of the full paths of the files extracted, empty on failure.
|
||||
*/
|
||||
static QStringList extractFiles(QString fileCompressed, QStringList files, QString dir = QString());
|
||||
/// Extract a whole archive.
|
||||
/**
|
||||
\param fileCompressed The name of the archive.
|
||||
\param dir The directory to extract to, the current directory if
|
||||
left empty.
|
||||
\return The list of the full paths of the files extracted, empty on failure.
|
||||
*/
|
||||
static QStringList extractDir(QString fileCompressed, QString dir = QString());
|
||||
/// Extract a whole archive, with a list of exceptions (prefixes to ignore).
|
||||
/**
|
||||
\param fileCompressed The name of the archive.
|
||||
\param dir The directory to extract to, the current directory if
|
||||
left empty.
|
||||
\param exceptions The list of exception prefixes
|
||||
\return The list of the full paths of the files extracted, empty on failure.
|
||||
*/
|
||||
static QStringList extractWithExceptions(QString fileCompressed, QString dir, QStringList exceptions);
|
||||
/// Get the file list.
|
||||
/**
|
||||
\return The list of the files in the archive, or, more precisely, the
|
||||
list of the entries, including both files and directories if they
|
||||
are present separately.
|
||||
*/
|
||||
static QStringList getFileList(QString fileCompressed);
|
||||
};
|
||||
|
||||
#endif /* JLCOMPRESSFOLDER_H_ */
|
@ -1,135 +0,0 @@
|
||||
/* crypt.h -- base code for crypt/uncrypt ZIPfile
|
||||
|
||||
|
||||
Version 1.01e, February 12th, 2005
|
||||
|
||||
Copyright (C) 1998-2005 Gilles Vollant
|
||||
|
||||
This code is a modified version of crypting code in Infozip distribution
|
||||
|
||||
The encryption/decryption parts of this source code (as opposed to the
|
||||
non-echoing password parts) were originally written in Europe. The
|
||||
whole source package can be freely distributed, including from the USA.
|
||||
(Prior to January 2000, re-export from the US was a violation of US law.)
|
||||
|
||||
This encryption code is a direct transcription of the algorithm from
|
||||
Roger Schlafly, described by Phil Katz in the file appnote.txt. This
|
||||
file (appnote.txt) is distributed with the PKZIP program (even in the
|
||||
version without encryption capabilities).
|
||||
|
||||
If you don't need crypting in your application, just define symbols
|
||||
NOCRYPT and NOUNCRYPT.
|
||||
|
||||
This code support the "Traditional PKWARE Encryption".
|
||||
|
||||
The new AES encryption added on Zip format by Winzip (see the page
|
||||
http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong
|
||||
Encryption is not supported.
|
||||
*/
|
||||
|
||||
#include "quazip_global.h"
|
||||
|
||||
#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
|
||||
|
||||
/***********************************************************************
|
||||
* Return the next byte in the pseudo-random sequence
|
||||
*/
|
||||
static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab UNUSED)
|
||||
{
|
||||
//(void) pcrc_32_tab; /* avoid "unused parameter" warning */
|
||||
unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an
|
||||
* unpredictable manner on 16-bit systems; not a problem
|
||||
* with any known compiler so far, though */
|
||||
|
||||
temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
|
||||
return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
* Update the encryption keys with the next byte of plain text
|
||||
*/
|
||||
static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c)
|
||||
{
|
||||
(*(pkeys+0)) = CRC32((*(pkeys+0)), c);
|
||||
(*(pkeys+1)) += (*(pkeys+0)) & 0xff;
|
||||
(*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
|
||||
{
|
||||
register int keyshift = (int)((*(pkeys+1)) >> 24);
|
||||
(*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
* Initialize the encryption keys and the random header according to
|
||||
* the given password.
|
||||
*/
|
||||
static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab)
|
||||
{
|
||||
*(pkeys+0) = 305419896L;
|
||||
*(pkeys+1) = 591751049L;
|
||||
*(pkeys+2) = 878082192L;
|
||||
while (*passwd != '\0') {
|
||||
update_keys(pkeys,pcrc_32_tab,(int)*passwd);
|
||||
passwd++;
|
||||
}
|
||||
}
|
||||
|
||||
#define zdecode(pkeys,pcrc_32_tab,c) \
|
||||
(update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
|
||||
|
||||
#define zencode(pkeys,pcrc_32_tab,c,t) \
|
||||
(t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))
|
||||
|
||||
#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
|
||||
|
||||
#define RAND_HEAD_LEN 12
|
||||
/* "last resort" source for second part of crypt seed pattern */
|
||||
# ifndef ZCR_SEED2
|
||||
# define ZCR_SEED2 3141592654UL /* use PI as default pattern */
|
||||
# endif
|
||||
|
||||
static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting)
|
||||
const char *passwd; /* password string */
|
||||
unsigned char *buf; /* where to write header */
|
||||
int bufSize;
|
||||
unsigned long* pkeys;
|
||||
const unsigned long* pcrc_32_tab;
|
||||
unsigned long crcForCrypting;
|
||||
{
|
||||
int n; /* index in random header */
|
||||
int t; /* temporary */
|
||||
int c; /* random byte */
|
||||
unsigned char header[RAND_HEAD_LEN-2]; /* random header */
|
||||
static unsigned calls = 0; /* ensure different random header each time */
|
||||
|
||||
if (bufSize<RAND_HEAD_LEN)
|
||||
return 0;
|
||||
|
||||
/* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
|
||||
* output of rand() to get less predictability, since rand() is
|
||||
* often poorly implemented.
|
||||
*/
|
||||
if (++calls == 1)
|
||||
{
|
||||
srand((unsigned)(time(NULL) ^ ZCR_SEED2));
|
||||
}
|
||||
init_keys(passwd, pkeys, pcrc_32_tab);
|
||||
for (n = 0; n < RAND_HEAD_LEN-2; n++)
|
||||
{
|
||||
c = (rand() >> 7) & 0xff;
|
||||
header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
|
||||
}
|
||||
/* Encrypt random header (last two bytes is high word of crc) */
|
||||
init_keys(passwd, pkeys, pcrc_32_tab);
|
||||
for (n = 0; n < RAND_HEAD_LEN-2; n++)
|
||||
{
|
||||
buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
|
||||
}
|
||||
buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
|
||||
buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
|
||||
return n;
|
||||
}
|
||||
|
||||
#endif
|
@ -1,77 +0,0 @@
|
||||
/* ioapi.h -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API
|
||||
|
||||
Version 1.01e, February 12th, 2005
|
||||
|
||||
Copyright (C) 1998-2005 Gilles Vollant
|
||||
|
||||
Modified by Sergey A. Tachenov to integrate with Qt.
|
||||
*/
|
||||
|
||||
#ifndef _ZLIBIOAPI_H
|
||||
#define _ZLIBIOAPI_H
|
||||
|
||||
|
||||
#define ZLIB_FILEFUNC_SEEK_CUR (1)
|
||||
#define ZLIB_FILEFUNC_SEEK_END (2)
|
||||
#define ZLIB_FILEFUNC_SEEK_SET (0)
|
||||
|
||||
#define ZLIB_FILEFUNC_MODE_READ (1)
|
||||
#define ZLIB_FILEFUNC_MODE_WRITE (2)
|
||||
#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
|
||||
|
||||
#define ZLIB_FILEFUNC_MODE_EXISTING (4)
|
||||
#define ZLIB_FILEFUNC_MODE_CREATE (8)
|
||||
|
||||
|
||||
#ifndef ZCALLBACK
|
||||
|
||||
#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
|
||||
#define ZCALLBACK CALLBACK
|
||||
#else
|
||||
#define ZCALLBACK
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, voidpf file, int mode));
|
||||
typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size));
|
||||
typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
|
||||
typedef uLong (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
|
||||
typedef int (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));
|
||||
typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));
|
||||
typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
|
||||
|
||||
typedef struct zlib_filefunc_def_s
|
||||
{
|
||||
open_file_func zopen_file;
|
||||
read_file_func zread_file;
|
||||
write_file_func zwrite_file;
|
||||
tell_file_func ztell_file;
|
||||
seek_file_func zseek_file;
|
||||
close_file_func zclose_file;
|
||||
testerror_file_func zerror_file;
|
||||
voidpf opaque;
|
||||
} zlib_filefunc_def;
|
||||
|
||||
|
||||
|
||||
void fill_qiodevice_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
|
||||
|
||||
#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size))
|
||||
#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size))
|
||||
#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream))
|
||||
#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode))
|
||||
#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream))
|
||||
#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream))
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
@ -1,146 +0,0 @@
|
||||
/* ioapi.c -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API
|
||||
|
||||
Version 1.01e, February 12th, 2005
|
||||
|
||||
Copyright (C) 1998-2005 Gilles Vollant
|
||||
|
||||
Modified by Sergey A. Tachenov to integrate with Qt.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "zlib.h"
|
||||
#include "ioapi.h"
|
||||
#include "quazip_global.h"
|
||||
#include <QIODevice>
|
||||
|
||||
|
||||
/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
|
||||
|
||||
#ifndef SEEK_CUR
|
||||
#define SEEK_CUR 1
|
||||
#endif
|
||||
|
||||
#ifndef SEEK_END
|
||||
#define SEEK_END 2
|
||||
#endif
|
||||
|
||||
#ifndef SEEK_SET
|
||||
#define SEEK_SET 0
|
||||
#endif
|
||||
|
||||
voidpf ZCALLBACK qiodevice_open_file_func (
|
||||
voidpf opaque UNUSED,
|
||||
voidpf file,
|
||||
int mode)
|
||||
{
|
||||
QIODevice *iodevice = reinterpret_cast<QIODevice*>(file);
|
||||
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
|
||||
iodevice->open(QIODevice::ReadOnly);
|
||||
else
|
||||
if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
|
||||
iodevice->open(QIODevice::ReadWrite);
|
||||
else
|
||||
if (mode & ZLIB_FILEFUNC_MODE_CREATE)
|
||||
iodevice->open(QIODevice::WriteOnly);
|
||||
|
||||
if (iodevice->isOpen()) {
|
||||
if (iodevice->isSequential()) {
|
||||
iodevice->close();
|
||||
return NULL;
|
||||
} else {
|
||||
return iodevice;
|
||||
}
|
||||
} else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
uLong ZCALLBACK qiodevice_read_file_func (
|
||||
voidpf opaque UNUSED,
|
||||
voidpf stream,
|
||||
void* buf,
|
||||
uLong size)
|
||||
{
|
||||
uLong ret;
|
||||
ret = (uLong)((QIODevice*)stream)->read((char*)buf,size);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
uLong ZCALLBACK qiodevice_write_file_func (
|
||||
voidpf opaque UNUSED,
|
||||
voidpf stream,
|
||||
const void* buf,
|
||||
uLong size)
|
||||
{
|
||||
uLong ret;
|
||||
ret = (uLong)((QIODevice*)stream)->write((char*)buf,size);
|
||||
return ret;
|
||||
}
|
||||
|
||||
uLong ZCALLBACK qiodevice_tell_file_func (
|
||||
voidpf opaque UNUSED,
|
||||
voidpf stream)
|
||||
{
|
||||
uLong ret;
|
||||
ret = ((QIODevice*)stream)->pos();
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ZCALLBACK qiodevice_seek_file_func (
|
||||
voidpf opaque UNUSED,
|
||||
voidpf stream,
|
||||
uLong offset,
|
||||
int origin)
|
||||
{
|
||||
uLong qiodevice_seek_result=0;
|
||||
int ret;
|
||||
switch (origin)
|
||||
{
|
||||
case ZLIB_FILEFUNC_SEEK_CUR :
|
||||
qiodevice_seek_result = ((QIODevice*)stream)->pos() + offset;
|
||||
break;
|
||||
case ZLIB_FILEFUNC_SEEK_END :
|
||||
qiodevice_seek_result = ((QIODevice*)stream)->size() - offset;
|
||||
break;
|
||||
case ZLIB_FILEFUNC_SEEK_SET :
|
||||
qiodevice_seek_result = offset;
|
||||
break;
|
||||
default: return -1;
|
||||
}
|
||||
ret = !((QIODevice*)stream)->seek(qiodevice_seek_result);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ZCALLBACK qiodevice_close_file_func (
|
||||
voidpf opaque UNUSED,
|
||||
voidpf stream)
|
||||
{
|
||||
((QIODevice*)stream)->close();
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ZCALLBACK qiodevice_error_file_func (
|
||||
voidpf opaque UNUSED,
|
||||
voidpf stream)
|
||||
{
|
||||
// can't check for error due to the QIODevice API limitation
|
||||
return 0;
|
||||
}
|
||||
|
||||
void fill_qiodevice_filefunc (
|
||||
zlib_filefunc_def* pzlib_filefunc_def)
|
||||
{
|
||||
pzlib_filefunc_def->zopen_file = qiodevice_open_file_func;
|
||||
pzlib_filefunc_def->zread_file = qiodevice_read_file_func;
|
||||
pzlib_filefunc_def->zwrite_file = qiodevice_write_file_func;
|
||||
pzlib_filefunc_def->ztell_file = qiodevice_tell_file_func;
|
||||
pzlib_filefunc_def->zseek_file = qiodevice_seek_file_func;
|
||||
pzlib_filefunc_def->zclose_file = qiodevice_close_file_func;
|
||||
pzlib_filefunc_def->zerror_file = qiodevice_error_file_func;
|
||||
pzlib_filefunc_def->opaque = NULL;
|
||||
}
|
@ -1,28 +0,0 @@
|
||||
#include "quaadler32.h"
|
||||
|
||||
#include "zlib.h"
|
||||
|
||||
QuaAdler32::QuaAdler32()
|
||||
{
|
||||
reset();
|
||||
}
|
||||
|
||||
quint32 QuaAdler32::calculate(const QByteArray &data)
|
||||
{
|
||||
return adler32( adler32(0L, Z_NULL, 0), (const Bytef*)data.data(), data.size() );
|
||||
}
|
||||
|
||||
void QuaAdler32::reset()
|
||||
{
|
||||
checksum = adler32(0L, Z_NULL, 0);
|
||||
}
|
||||
|
||||
void QuaAdler32::update(const QByteArray &buf)
|
||||
{
|
||||
checksum = adler32( checksum, (const Bytef*)buf.data(), buf.size() );
|
||||
}
|
||||
|
||||
quint32 QuaAdler32::value()
|
||||
{
|
||||
return checksum;
|
||||
}
|
@ -1,29 +0,0 @@
|
||||
#ifndef QUAADLER32_H
|
||||
#define QUAADLER32_H
|
||||
|
||||
#include <QtCore/QByteArray>
|
||||
|
||||
#include "quachecksum32.h"
|
||||
|
||||
/// Adler32 checksum
|
||||
/** \class QuaAdler32 quaadler32.h <quazip/quaadler32.h>
|
||||
* This class wrappers the adler32 function with the QuaChecksum32 interface.
|
||||
* See QuaChecksum32 for more info.
|
||||
*/
|
||||
class QUAZIP_EXPORT QuaAdler32 : public QuaChecksum32
|
||||
{
|
||||
|
||||
public:
|
||||
QuaAdler32();
|
||||
|
||||
quint32 calculate(const QByteArray &data);
|
||||
|
||||
void reset();
|
||||
void update(const QByteArray &buf);
|
||||
quint32 value();
|
||||
|
||||
private:
|
||||
quint32 checksum;
|
||||
};
|
||||
|
||||
#endif //QUAADLER32_H
|
@ -1,54 +0,0 @@
|
||||
#ifndef QUACHECKSUM32_H
|
||||
#define QUACHECKSUM32_H
|
||||
|
||||
#include <QtCore/QByteArray>
|
||||
#include "quazip_global.h"
|
||||
|
||||
/// Checksum interface.
|
||||
/** \class QuaChecksum32 quachecksum32.h <quazip/quachecksum32.h>
|
||||
* This is an interface for 32 bit checksums.
|
||||
* Classes implementing this interface can calcunate a certin
|
||||
* checksum in a single step:
|
||||
* \code
|
||||
* QChecksum32 *crc32 = new QuaCrc32();
|
||||
* rasoult = crc32->calculate(data);
|
||||
* \endcode
|
||||
* or by streaming the data:
|
||||
* \code
|
||||
* QChecksum32 *crc32 = new QuaCrc32();
|
||||
* while(!fileA.atEnd())
|
||||
* crc32->update(fileA.read(bufSize));
|
||||
* resoultA = crc32->value();
|
||||
* crc32->reset();
|
||||
* while(!fileB.atEnd())
|
||||
* crc32->update(fileB.read(bufSize));
|
||||
* resoultB = crc32->value();
|
||||
* \endcode
|
||||
*/
|
||||
class QUAZIP_EXPORT QuaChecksum32
|
||||
{
|
||||
|
||||
public:
|
||||
///Calculates the checksum for data.
|
||||
/** \a data source data
|
||||
* \return data checksum
|
||||
*
|
||||
* This function has no efect on the value returned by value().
|
||||
*/
|
||||
virtual quint32 calculate(const QByteArray &data) = 0;
|
||||
|
||||
///Resets the calculation on a checksun for a stream.
|
||||
virtual void reset() = 0;
|
||||
|
||||
///Updates the calculated checksum for the stream
|
||||
/** \a buf next portion of data from the stream
|
||||
*/
|
||||
virtual void update(const QByteArray &buf) = 0;
|
||||
|
||||
///Value of the checksum calculated for the stream passed throw update().
|
||||
/** \return checksum
|
||||
*/
|
||||
virtual quint32 value() = 0;
|
||||
};
|
||||
|
||||
#endif //QUACHECKSUM32_H
|
@ -1,28 +0,0 @@
|
||||
#include "quacrc32.h"
|
||||
|
||||
#include "zlib.h"
|
||||
|
||||
QuaCrc32::QuaCrc32()
|
||||
{
|
||||
reset();
|
||||
}
|
||||
|
||||
quint32 QuaCrc32::calculate(const QByteArray &data)
|
||||
{
|
||||
return crc32( crc32(0L, Z_NULL, 0), (const Bytef*)data.data(), data.size() );
|
||||
}
|
||||
|
||||
void QuaCrc32::reset()
|
||||
{
|
||||
checksum = crc32(0L, Z_NULL, 0);
|
||||
}
|
||||
|
||||
void QuaCrc32::update(const QByteArray &buf)
|
||||
{
|
||||
checksum = crc32( checksum, (const Bytef*)buf.data(), buf.size() );
|
||||
}
|
||||
|
||||
quint32 QuaCrc32::value()
|
||||
{
|
||||
return checksum;
|
||||
}
|
@ -1,26 +0,0 @@
|
||||
#ifndef QUACRC32_H
|
||||
#define QUACRC32_H
|
||||
|
||||
#include "quachecksum32.h"
|
||||
|
||||
///CRC32 checksum
|
||||
/** \class QuaCrc32 quacrc32.h <quazip/quacrc32.h>
|
||||
* This class wrappers the crc32 function with the QuaChecksum32 interface.
|
||||
* See QuaChecksum32 for more info.
|
||||
*/
|
||||
class QUAZIP_EXPORT QuaCrc32 : public QuaChecksum32 {
|
||||
|
||||
public:
|
||||
QuaCrc32();
|
||||
|
||||
quint32 calculate(const QByteArray &data);
|
||||
|
||||
void reset();
|
||||
void update(const QByteArray &buf);
|
||||
quint32 value();
|
||||
|
||||
private:
|
||||
quint32 checksum;
|
||||
};
|
||||
|
||||
#endif //QUACRC32_H
|
@ -1,141 +0,0 @@
|
||||
#include <QFile>
|
||||
|
||||
#include "quagzipfile.h"
|
||||
|
||||
class QuaGzipFilePrivate {
|
||||
friend class QuaGzipFile;
|
||||
QString fileName;
|
||||
gzFile gzd;
|
||||
inline QuaGzipFilePrivate(): gzd(NULL) {}
|
||||
inline QuaGzipFilePrivate(const QString &fileName):
|
||||
fileName(fileName), gzd(NULL) {}
|
||||
template<typename FileId> bool open(FileId id,
|
||||
QIODevice::OpenMode mode, QString &error);
|
||||
gzFile open(int fd, const char *modeString);
|
||||
gzFile open(const QString &name, const char *modeString);
|
||||
};
|
||||
|
||||
gzFile QuaGzipFilePrivate::open(const QString &name, const char *modeString)
|
||||
{
|
||||
return gzopen(QFile::encodeName(name).constData(), modeString);
|
||||
}
|
||||
|
||||
gzFile QuaGzipFilePrivate::open(int fd, const char *modeString)
|
||||
{
|
||||
return gzdopen(fd, modeString);
|
||||
}
|
||||
|
||||
template<typename FileId>
|
||||
bool QuaGzipFilePrivate::open(FileId id, QIODevice::OpenMode mode,
|
||||
QString &error)
|
||||
{
|
||||
char modeString[2];
|
||||
modeString[0] = modeString[1] = '\0';
|
||||
if ((mode & QIODevice::ReadOnly) != 0
|
||||
&& (mode & QIODevice::WriteOnly) != 0) {
|
||||
error = QuaGzipFile::trUtf8("Opening gzip for both reading"
|
||||
" and writing is not supported");
|
||||
return false;
|
||||
} else if ((mode & QIODevice::ReadOnly) != 0) {
|
||||
modeString[0] = 'r';
|
||||
} else if ((mode & QIODevice::WriteOnly) != 0) {
|
||||
modeString[0] = 'w';
|
||||
} else {
|
||||
error = QuaGzipFile::trUtf8("You can open a gzip either for reading"
|
||||
" or for writing. Which is it?");
|
||||
return false;
|
||||
}
|
||||
gzd = open(id, modeString);
|
||||
if (gzd == NULL) {
|
||||
error = QuaGzipFile::trUtf8("Could not gzopen() file");
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
QuaGzipFile::QuaGzipFile():
|
||||
d(new QuaGzipFilePrivate())
|
||||
{
|
||||
}
|
||||
|
||||
QuaGzipFile::QuaGzipFile(QObject *parent):
|
||||
QIODevice(parent),
|
||||
d(new QuaGzipFilePrivate())
|
||||
{
|
||||
}
|
||||
|
||||
QuaGzipFile::QuaGzipFile(const QString &fileName, QObject *parent):
|
||||
QIODevice(parent),
|
||||
d(new QuaGzipFilePrivate(fileName))
|
||||
{
|
||||
}
|
||||
|
||||
QuaGzipFile::~QuaGzipFile()
|
||||
{
|
||||
if (isOpen()) {
|
||||
close();
|
||||
}
|
||||
delete d;
|
||||
}
|
||||
|
||||
void QuaGzipFile::setFileName(const QString& fileName)
|
||||
{
|
||||
d->fileName = fileName;
|
||||
}
|
||||
|
||||
QString QuaGzipFile::getFileName() const
|
||||
{
|
||||
return d->fileName;
|
||||
}
|
||||
|
||||
bool QuaGzipFile::isSequential() const
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
bool QuaGzipFile::open(QIODevice::OpenMode mode)
|
||||
{
|
||||
QString error;
|
||||
if (!d->open(d->fileName, mode, error)) {
|
||||
setErrorString(error);
|
||||
return false;
|
||||
}
|
||||
return QIODevice::open(mode);
|
||||
}
|
||||
|
||||
bool QuaGzipFile::open(int fd, QIODevice::OpenMode mode)
|
||||
{
|
||||
QString error;
|
||||
if (!d->open(fd, mode, error)) {
|
||||
setErrorString(error);
|
||||
return false;
|
||||
}
|
||||
return QIODevice::open(mode);
|
||||
}
|
||||
|
||||
bool QuaGzipFile::flush()
|
||||
{
|
||||
return gzflush(d->gzd, Z_SYNC_FLUSH) == Z_OK;
|
||||
}
|
||||
|
||||
void QuaGzipFile::close()
|
||||
{
|
||||
QIODevice::close();
|
||||
gzclose(d->gzd);
|
||||
}
|
||||
|
||||
qint64 QuaGzipFile::readData(char *data, qint64 maxSize)
|
||||
{
|
||||
return gzread(d->gzd, (voidp)data, (unsigned)maxSize);
|
||||
}
|
||||
|
||||
qint64 QuaGzipFile::writeData(const char *data, qint64 maxSize)
|
||||
{
|
||||
if (maxSize == 0)
|
||||
return 0;
|
||||
int written = gzwrite(d->gzd, (voidp)data, (unsigned)maxSize);
|
||||
if (written == 0)
|
||||
return -1;
|
||||
else
|
||||
return written;
|
||||
}
|
@ -1,35 +0,0 @@
|
||||
#ifndef QUAZIP_QUAGZIPFILE_H
|
||||
#define QUAZIP_QUAGZIPFILE_H
|
||||
|
||||
#include <QIODevice>
|
||||
#include "quazip_global.h"
|
||||
|
||||
#include <zlib.h>
|
||||
|
||||
class QuaGzipFilePrivate;
|
||||
|
||||
class QUAZIP_EXPORT QuaGzipFile: public QIODevice {
|
||||
Q_OBJECT
|
||||
public:
|
||||
QuaGzipFile();
|
||||
QuaGzipFile(QObject *parent);
|
||||
QuaGzipFile(const QString &fileName, QObject *parent = NULL);
|
||||
virtual ~QuaGzipFile();
|
||||
void setFileName(const QString& fileName);
|
||||
QString getFileName() const;
|
||||
virtual bool isSequential() const;
|
||||
virtual bool open(QIODevice::OpenMode mode);
|
||||
virtual bool open(int fd, QIODevice::OpenMode mode);
|
||||
virtual bool flush();
|
||||
virtual void close();
|
||||
protected:
|
||||
virtual qint64 readData(char *data, qint64 maxSize);
|
||||
virtual qint64 writeData(const char *data, qint64 maxSize);
|
||||
private:
|
||||
// not implemented by design to disable copy
|
||||
QuaGzipFile(const QuaGzipFile &that);
|
||||
QuaGzipFile& operator=(const QuaGzipFile &that);
|
||||
QuaGzipFilePrivate *d;
|
||||
};
|
||||
|
||||
#endif // QUAZIP_QUAGZIPFILE_H
|
@ -1,283 +0,0 @@
|
||||
#include "quaziodevice.h"
|
||||
|
||||
#define QUAZIO_INBUFSIZE 4096
|
||||
#define QUAZIO_OUTBUFSIZE 4096
|
||||
|
||||
class QuaZIODevicePrivate {
|
||||
friend class QuaZIODevice;
|
||||
QuaZIODevicePrivate(QIODevice *io);
|
||||
~QuaZIODevicePrivate();
|
||||
QIODevice *io;
|
||||
z_stream zins;
|
||||
z_stream zouts;
|
||||
char *inBuf;
|
||||
int inBufPos;
|
||||
int inBufSize;
|
||||
char *outBuf;
|
||||
int outBufPos;
|
||||
int outBufSize;
|
||||
bool zBufError;
|
||||
int doFlush(QString &error);
|
||||
};
|
||||
|
||||
QuaZIODevicePrivate::QuaZIODevicePrivate(QIODevice *io):
|
||||
io(io),
|
||||
inBuf(NULL),
|
||||
inBufPos(0),
|
||||
inBufSize(0),
|
||||
outBuf(NULL),
|
||||
outBufPos(0),
|
||||
outBufSize(0),
|
||||
zBufError(false)
|
||||
{
|
||||
zins.zalloc = (alloc_func) NULL;
|
||||
zins.zfree = (free_func) NULL;
|
||||
zins.opaque = NULL;
|
||||
zouts.zalloc = (alloc_func) NULL;
|
||||
zouts.zfree = (free_func) NULL;
|
||||
zouts.opaque = NULL;
|
||||
inBuf = new char[QUAZIO_INBUFSIZE];
|
||||
outBuf = new char[QUAZIO_OUTBUFSIZE];
|
||||
#ifdef QUAZIP_ZIODEVICE_DEBUG_OUTPUT
|
||||
debug.setFileName("debug.out");
|
||||
debug.open(QIODevice::WriteOnly);
|
||||
#endif
|
||||
#ifdef QUAZIP_ZIODEVICE_DEBUG_INPUT
|
||||
indebug.setFileName("debug.in");
|
||||
indebug.open(QIODevice::WriteOnly);
|
||||
#endif
|
||||
}
|
||||
|
||||
QuaZIODevicePrivate::~QuaZIODevicePrivate()
|
||||
{
|
||||
#ifdef QUAZIP_ZIODEVICE_DEBUG_OUTPUT
|
||||
debug.close();
|
||||
#endif
|
||||
#ifdef QUAZIP_ZIODEVICE_DEBUG_INPUT
|
||||
indebug.close();
|
||||
#endif
|
||||
if (inBuf != NULL)
|
||||
delete[] inBuf;
|
||||
if (outBuf != NULL)
|
||||
delete[] outBuf;
|
||||
}
|
||||
|
||||
int QuaZIODevicePrivate::doFlush(QString &error)
|
||||
{
|
||||
int flushed = 0;
|
||||
while (outBufPos < outBufSize) {
|
||||
int more = io->write(outBuf + outBufPos, outBufSize - outBufPos);
|
||||
if (more == -1) {
|
||||
error = io->errorString();
|
||||
return -1;
|
||||
}
|
||||
if (more == 0)
|
||||
break;
|
||||
outBufPos += more;
|
||||
flushed += more;
|
||||
}
|
||||
if (outBufPos == outBufSize) {
|
||||
outBufPos = outBufSize = 0;
|
||||
}
|
||||
return flushed;
|
||||
}
|
||||
|
||||
// #define QUAZIP_ZIODEVICE_DEBUG_OUTPUT
|
||||
// #define QUAZIP_ZIODEVICE_DEBUG_INPUT
|
||||
#ifdef QUAZIP_ZIODEVICE_DEBUG_OUTPUT
|
||||
#include <QFile>
|
||||
static QFile debug;
|
||||
#endif
|
||||
#ifdef QUAZIP_ZIODEVICE_DEBUG_INPUT
|
||||
#include <QFile>
|
||||
static QFile indebug;
|
||||
#endif
|
||||
|
||||
QuaZIODevice::QuaZIODevice(QIODevice *io, QObject *parent):
|
||||
QIODevice(parent),
|
||||
d(new QuaZIODevicePrivate(io))
|
||||
{
|
||||
connect(io, SIGNAL(readyRead()), SIGNAL(readyRead()));
|
||||
}
|
||||
|
||||
QuaZIODevice::~QuaZIODevice()
|
||||
{
|
||||
if (isOpen())
|
||||
close();
|
||||
delete d;
|
||||
}
|
||||
|
||||
QIODevice *QuaZIODevice::getIoDevice() const
|
||||
{
|
||||
return d->io;
|
||||
}
|
||||
|
||||
bool QuaZIODevice::open(QIODevice::OpenMode mode)
|
||||
{
|
||||
if ((mode & QIODevice::ReadOnly) != 0) {
|
||||
if (inflateInit(&d->zins) != Z_OK) {
|
||||
setErrorString(d->zins.msg);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
if ((mode & QIODevice::WriteOnly) != 0) {
|
||||
if (deflateInit(&d->zouts, Z_DEFAULT_COMPRESSION) != Z_OK) {
|
||||
setErrorString(d->zouts.msg);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return QIODevice::open(mode);
|
||||
}
|
||||
|
||||
void QuaZIODevice::close()
|
||||
{
|
||||
if ((openMode() & QIODevice::ReadOnly) != 0) {
|
||||
if (inflateEnd(&d->zins) != Z_OK) {
|
||||
setErrorString(d->zins.msg);
|
||||
}
|
||||
}
|
||||
if ((openMode() & QIODevice::WriteOnly) != 0) {
|
||||
flush();
|
||||
if (deflateEnd(&d->zouts) != Z_OK) {
|
||||
setErrorString(d->zouts.msg);
|
||||
}
|
||||
}
|
||||
QIODevice::close();
|
||||
}
|
||||
|
||||
qint64 QuaZIODevice::readData(char *data, qint64 maxSize)
|
||||
{
|
||||
int read = 0;
|
||||
while (read < maxSize) {
|
||||
if (d->inBufPos == d->inBufSize) {
|
||||
d->inBufPos = 0;
|
||||
d->inBufSize = d->io->read(d->inBuf, QUAZIO_INBUFSIZE);
|
||||
if (d->inBufSize == -1) {
|
||||
d->inBufSize = 0;
|
||||
setErrorString(d->io->errorString());
|
||||
return -1;
|
||||
}
|
||||
if (d->inBufSize == 0)
|
||||
break;
|
||||
}
|
||||
while (read < maxSize && d->inBufPos < d->inBufSize) {
|
||||
d->zins.next_in = (Bytef *) (d->inBuf + d->inBufPos);
|
||||
d->zins.avail_in = d->inBufSize - d->inBufPos;
|
||||
d->zins.next_out = (Bytef *) (data + read);
|
||||
d->zins.avail_out = (uInt) (maxSize - read); // hope it's less than 2GB
|
||||
int more = 0;
|
||||
switch (inflate(&d->zins, Z_SYNC_FLUSH)) {
|
||||
case Z_OK:
|
||||
read = (char *) d->zins.next_out - data;
|
||||
d->inBufPos = (char *) d->zins.next_in - d->inBuf;
|
||||
break;
|
||||
case Z_STREAM_END:
|
||||
read = (char *) d->zins.next_out - data;
|
||||
d->inBufPos = (char *) d->zins.next_in - d->inBuf;
|
||||
return read;
|
||||
case Z_BUF_ERROR: // this should never happen, but just in case
|
||||
if (!d->zBufError) {
|
||||
qWarning("Z_BUF_ERROR detected with %d/%d in/out, weird",
|
||||
d->zins.avail_in, d->zins.avail_out);
|
||||
d->zBufError = true;
|
||||
}
|
||||
memmove(d->inBuf, d->inBuf + d->inBufPos, d->inBufSize - d->inBufPos);
|
||||
d->inBufSize -= d->inBufPos;
|
||||
d->inBufPos = 0;
|
||||
more = d->io->read(d->inBuf + d->inBufSize, QUAZIO_INBUFSIZE - d->inBufSize);
|
||||
if (more == -1) {
|
||||
setErrorString(d->io->errorString());
|
||||
return -1;
|
||||
}
|
||||
if (more == 0)
|
||||
return read;
|
||||
d->inBufSize += more;
|
||||
break;
|
||||
default:
|
||||
setErrorString(QString::fromLocal8Bit(d->zins.msg));
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
#ifdef QUAZIP_ZIODEVICE_DEBUG_INPUT
|
||||
indebug.write(data, read);
|
||||
#endif
|
||||
return read;
|
||||
}
|
||||
|
||||
qint64 QuaZIODevice::writeData(const char *data, qint64 maxSize)
|
||||
{
|
||||
int written = 0;
|
||||
QString error;
|
||||
if (d->doFlush(error) == -1) {
|
||||
setErrorString(error);
|
||||
return -1;
|
||||
}
|
||||
while (written < maxSize) {
|
||||
// there is some data waiting in the output buffer
|
||||
if (d->outBufPos < d->outBufSize)
|
||||
return written;
|
||||
d->zouts.next_in = (Bytef *) (data + written);
|
||||
d->zouts.avail_in = (uInt) (maxSize - written); // hope it's less than 2GB
|
||||
d->zouts.next_out = (Bytef *) d->outBuf;
|
||||
d->zouts.avail_out = QUAZIO_OUTBUFSIZE;
|
||||
switch (deflate(&d->zouts, Z_NO_FLUSH)) {
|
||||
case Z_OK:
|
||||
written = (char *) d->zouts.next_in - data;
|
||||
d->outBufSize = (char *) d->zouts.next_out - d->outBuf;
|
||||
break;
|
||||
default:
|
||||
setErrorString(QString::fromLocal8Bit(d->zouts.msg));
|
||||
return -1;
|
||||
}
|
||||
if (d->doFlush(error) == -1) {
|
||||
setErrorString(error);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
#ifdef QUAZIP_ZIODEVICE_DEBUG_OUTPUT
|
||||
debug.write(data, written);
|
||||
#endif
|
||||
return written;
|
||||
}
|
||||
|
||||
bool QuaZIODevice::flush()
|
||||
{
|
||||
QString error;
|
||||
if (d->doFlush(error) < 0) {
|
||||
setErrorString(error);
|
||||
return false;
|
||||
}
|
||||
// can't flush buffer, some data is still waiting
|
||||
if (d->outBufPos < d->outBufSize)
|
||||
return true;
|
||||
Bytef c = 0;
|
||||
d->zouts.next_in = &c; // fake input buffer
|
||||
d->zouts.avail_in = 0; // of zero size
|
||||
do {
|
||||
d->zouts.next_out = (Bytef *) d->outBuf;
|
||||
d->zouts.avail_out = QUAZIO_OUTBUFSIZE;
|
||||
switch (deflate(&d->zouts, Z_SYNC_FLUSH)) {
|
||||
case Z_OK:
|
||||
d->outBufSize = (char *) d->zouts.next_out - d->outBuf;
|
||||
if (d->doFlush(error) < 0) {
|
||||
setErrorString(error);
|
||||
return false;
|
||||
}
|
||||
if (d->outBufPos < d->outBufSize)
|
||||
return true;
|
||||
break;
|
||||
case Z_BUF_ERROR: // nothing to write?
|
||||
return true;
|
||||
default:
|
||||
setErrorString(QString::fromLocal8Bit(d->zouts.msg));
|
||||
return false;
|
||||
}
|
||||
} while (d->zouts.avail_out == 0);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool QuaZIODevice::isSequential() const
|
||||
{
|
||||
return true;
|
||||
}
|
@ -1,27 +0,0 @@
|
||||
#ifndef QUAZIP_QUAZIODEVICE_H
|
||||
#define QUAZIP_QUAZIODEVICE_H
|
||||
|
||||
#include <QIODevice>
|
||||
#include "quazip_global.h"
|
||||
|
||||
#include <zlib.h>
|
||||
|
||||
class QuaZIODevicePrivate;
|
||||
|
||||
class QUAZIP_EXPORT QuaZIODevice: public QIODevice {
|
||||
Q_OBJECT
|
||||
public:
|
||||
QuaZIODevice(QIODevice *io, QObject *parent = NULL);
|
||||
~QuaZIODevice();
|
||||
virtual bool flush();
|
||||
virtual bool open(QIODevice::OpenMode);
|
||||
virtual void close();
|
||||
QIODevice *getIoDevice() const;
|
||||
virtual bool isSequential() const;
|
||||
protected:
|
||||
virtual qint64 readData(char *data, qint64 maxSize);
|
||||
virtual qint64 writeData(const char *data, qint64 maxSize);
|
||||
private:
|
||||
QuaZIODevicePrivate *d;
|
||||
};
|
||||
#endif // QUAZIP_QUAZIODEVICE_H
|
@ -1,554 +0,0 @@
|
||||
/*
|
||||
Copyright (C) 2005-2011 Sergey A. Tachenov
|
||||
|
||||
This program is free software; you can redistribute it and/or modify it
|
||||
under the terms of the GNU Lesser 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 Lesser
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with this program; if not, write to the Free Software Foundation,
|
||||
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
See COPYING file for the full LGPL text.
|
||||
|
||||
Original ZIP package is copyrighted by Gilles Vollant, see
|
||||
quazip/(un)zip.h files for details, basically it's zlib license.
|
||||
**/
|
||||
|
||||
#include <QtCore/QFile>
|
||||
#include <QtCore/QFlags>
|
||||
|
||||
#include "quazip.h"
|
||||
|
||||
/// All the internal stuff for the QuaZip class.
|
||||
/**
|
||||
\internal
|
||||
|
||||
This class keeps all the private stuff for the QuaZip class so it can
|
||||
be changed without breaking binary compatibility, according to the
|
||||
Pimpl idiom.
|
||||
*/
|
||||
class QuaZipPrivate {
|
||||
friend class QuaZip;
|
||||
private:
|
||||
/// The pointer to the corresponding QuaZip instance.
|
||||
QuaZip *q;
|
||||
/// The codec for file names.
|
||||
QTextCodec *fileNameCodec;
|
||||
/// The codec for comments.
|
||||
QTextCodec *commentCodec;
|
||||
/// The archive file name.
|
||||
QString zipName;
|
||||
/// The device to access the archive.
|
||||
QIODevice *ioDevice;
|
||||
/// The global comment.
|
||||
QString comment;
|
||||
/// The open mode.
|
||||
QuaZip::Mode mode;
|
||||
union {
|
||||
/// The internal handle for UNZIP modes.
|
||||
unzFile unzFile_f;
|
||||
/// The internal handle for ZIP modes.
|
||||
zipFile zipFile_f;
|
||||
};
|
||||
/// Whether a current file is set.
|
||||
bool hasCurrentFile_f;
|
||||
/// The last error.
|
||||
int zipError;
|
||||
/// Whether \ref QuaZip::setDataDescriptorWritingEnabled() "the data descriptor writing mode" is enabled.
|
||||
bool dataDescriptorWritingEnabled;
|
||||
/// The constructor for the corresponding QuaZip constructor.
|
||||
inline QuaZipPrivate(QuaZip *q):
|
||||
q(q),
|
||||
fileNameCodec(QTextCodec::codecForLocale()),
|
||||
commentCodec(QTextCodec::codecForLocale()),
|
||||
ioDevice(NULL),
|
||||
mode(QuaZip::mdNotOpen),
|
||||
hasCurrentFile_f(false),
|
||||
zipError(UNZ_OK),
|
||||
dataDescriptorWritingEnabled(true) {}
|
||||
/// The constructor for the corresponding QuaZip constructor.
|
||||
inline QuaZipPrivate(QuaZip *q, const QString &zipName):
|
||||
q(q),
|
||||
fileNameCodec(QTextCodec::codecForLocale()),
|
||||
commentCodec(QTextCodec::codecForLocale()),
|
||||
zipName(zipName),
|
||||
ioDevice(NULL),
|
||||
mode(QuaZip::mdNotOpen),
|
||||
hasCurrentFile_f(false),
|
||||
zipError(UNZ_OK),
|
||||
dataDescriptorWritingEnabled(true) {}
|
||||
/// The constructor for the corresponding QuaZip constructor.
|
||||
inline QuaZipPrivate(QuaZip *q, QIODevice *ioDevice):
|
||||
q(q),
|
||||
fileNameCodec(QTextCodec::codecForLocale()),
|
||||
commentCodec(QTextCodec::codecForLocale()),
|
||||
ioDevice(ioDevice),
|
||||
mode(QuaZip::mdNotOpen),
|
||||
hasCurrentFile_f(false),
|
||||
zipError(UNZ_OK),
|
||||
dataDescriptorWritingEnabled(true) {}
|
||||
/// Returns either a list of file names or a list of QuaZipFileInfo.
|
||||
template<typename TFileInfo>
|
||||
bool getFileInfoList(QList<TFileInfo> *result) const;
|
||||
};
|
||||
|
||||
QuaZip::QuaZip():
|
||||
p(new QuaZipPrivate(this))
|
||||
{
|
||||
}
|
||||
|
||||
QuaZip::QuaZip(const QString& zipName):
|
||||
p(new QuaZipPrivate(this, zipName))
|
||||
{
|
||||
}
|
||||
|
||||
QuaZip::QuaZip(QIODevice *ioDevice):
|
||||
p(new QuaZipPrivate(this, ioDevice))
|
||||
{
|
||||
}
|
||||
|
||||
QuaZip::~QuaZip()
|
||||
{
|
||||
if(isOpen())
|
||||
close();
|
||||
delete p;
|
||||
}
|
||||
|
||||
bool QuaZip::open(Mode mode, zlib_filefunc_def* ioApi)
|
||||
{
|
||||
p->zipError=UNZ_OK;
|
||||
if(isOpen()) {
|
||||
qWarning("QuaZip::open(): ZIP already opened");
|
||||
return false;
|
||||
}
|
||||
QIODevice *ioDevice = p->ioDevice;
|
||||
if (ioDevice == NULL) {
|
||||
if (p->zipName.isEmpty()) {
|
||||
qWarning("QuaZip::open(): set either ZIP file name or IO device first");
|
||||
return false;
|
||||
} else {
|
||||
ioDevice = new QFile(p->zipName);
|
||||
}
|
||||
}
|
||||
switch(mode) {
|
||||
case mdUnzip:
|
||||
p->unzFile_f=unzOpen2(ioDevice, ioApi);
|
||||
if(p->unzFile_f!=NULL) {
|
||||
p->mode=mode;
|
||||
p->ioDevice = ioDevice;
|
||||
return true;
|
||||
} else {
|
||||
p->zipError=UNZ_OPENERROR;
|
||||
if (!p->zipName.isEmpty())
|
||||
delete ioDevice;
|
||||
return false;
|
||||
}
|
||||
case mdCreate:
|
||||
case mdAppend:
|
||||
case mdAdd:
|
||||
p->zipFile_f=zipOpen2(ioDevice,
|
||||
mode==mdCreate?APPEND_STATUS_CREATE:
|
||||
mode==mdAppend?APPEND_STATUS_CREATEAFTER:
|
||||
APPEND_STATUS_ADDINZIP,
|
||||
NULL,
|
||||
ioApi);
|
||||
if(p->zipFile_f!=NULL) {
|
||||
p->mode=mode;
|
||||
p->ioDevice = ioDevice;
|
||||
return true;
|
||||
} else {
|
||||
p->zipError=UNZ_OPENERROR;
|
||||
if (!p->zipName.isEmpty())
|
||||
delete ioDevice;
|
||||
return false;
|
||||
}
|
||||
default:
|
||||
qWarning("QuaZip::open(): unknown mode: %d", (int)mode);
|
||||
if (!p->zipName.isEmpty())
|
||||
delete ioDevice;
|
||||
return false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void QuaZip::close()
|
||||
{
|
||||
p->zipError=UNZ_OK;
|
||||
switch(p->mode) {
|
||||
case mdNotOpen:
|
||||
qWarning("QuaZip::close(): ZIP is not open");
|
||||
return;
|
||||
case mdUnzip:
|
||||
p->zipError=unzClose(p->unzFile_f);
|
||||
break;
|
||||
case mdCreate:
|
||||
case mdAppend:
|
||||
case mdAdd:
|
||||
p->zipError=zipClose(p->zipFile_f,
|
||||
p->comment.isNull() ? NULL
|
||||
: p->commentCodec->fromUnicode(p->comment).constData());
|
||||
break;
|
||||
default:
|
||||
qWarning("QuaZip::close(): unknown mode: %d", (int)p->mode);
|
||||
return;
|
||||
}
|
||||
// opened by name, need to delete the internal IO device
|
||||
if (!p->zipName.isEmpty()) {
|
||||
delete p->ioDevice;
|
||||
p->ioDevice = NULL;
|
||||
}
|
||||
if(p->zipError==UNZ_OK)
|
||||
p->mode=mdNotOpen;
|
||||
}
|
||||
|
||||
void QuaZip::setZipName(const QString& zipName)
|
||||
{
|
||||
if(isOpen()) {
|
||||
qWarning("QuaZip::setZipName(): ZIP is already open!");
|
||||
return;
|
||||
}
|
||||
p->zipName=zipName;
|
||||
p->ioDevice = NULL;
|
||||
}
|
||||
|
||||
void QuaZip::setIoDevice(QIODevice *ioDevice)
|
||||
{
|
||||
if(isOpen()) {
|
||||
qWarning("QuaZip::setIoDevice(): ZIP is already open!");
|
||||
return;
|
||||
}
|
||||
p->ioDevice = ioDevice;
|
||||
p->zipName = QString();
|
||||
}
|
||||
|
||||
int QuaZip::getEntriesCount()const
|
||||
{
|
||||
QuaZip *fakeThis=(QuaZip*)this; // non-const
|
||||
fakeThis->p->zipError=UNZ_OK;
|
||||
if(p->mode!=mdUnzip) {
|
||||
qWarning("QuaZip::getEntriesCount(): ZIP is not open in mdUnzip mode");
|
||||
return -1;
|
||||
}
|
||||
unz_global_info globalInfo;
|
||||
if((fakeThis->p->zipError=unzGetGlobalInfo(p->unzFile_f, &globalInfo))!=UNZ_OK)
|
||||
return p->zipError;
|
||||
return (int)globalInfo.number_entry;
|
||||
}
|
||||
|
||||
QString QuaZip::getComment()const
|
||||
{
|
||||
QuaZip *fakeThis=(QuaZip*)this; // non-const
|
||||
fakeThis->p->zipError=UNZ_OK;
|
||||
if(p->mode!=mdUnzip) {
|
||||
qWarning("QuaZip::getComment(): ZIP is not open in mdUnzip mode");
|
||||
return QString();
|
||||
}
|
||||
unz_global_info globalInfo;
|
||||
QByteArray comment;
|
||||
if((fakeThis->p->zipError=unzGetGlobalInfo(p->unzFile_f, &globalInfo))!=UNZ_OK)
|
||||
return QString();
|
||||
comment.resize(globalInfo.size_comment);
|
||||
if((fakeThis->p->zipError=unzGetGlobalComment(p->unzFile_f, comment.data(), comment.size())) < 0)
|
||||
return QString();
|
||||
fakeThis->p->zipError = UNZ_OK;
|
||||
return p->commentCodec->toUnicode(comment);
|
||||
}
|
||||
|
||||
bool QuaZip::setCurrentFile(const QString& fileName, CaseSensitivity cs)
|
||||
{
|
||||
p->zipError=UNZ_OK;
|
||||
if(p->mode!=mdUnzip) {
|
||||
qWarning("QuaZip::setCurrentFile(): ZIP is not open in mdUnzip mode");
|
||||
return false;
|
||||
}
|
||||
if(fileName.isEmpty()) {
|
||||
p->hasCurrentFile_f=false;
|
||||
return true;
|
||||
}
|
||||
// Unicode-aware reimplementation of the unzLocateFile function
|
||||
if(p->unzFile_f==NULL) {
|
||||
p->zipError=UNZ_PARAMERROR;
|
||||
return false;
|
||||
}
|
||||
if(fileName.length()>MAX_FILE_NAME_LENGTH) {
|
||||
p->zipError=UNZ_PARAMERROR;
|
||||
return false;
|
||||
}
|
||||
bool sens = convertCaseSensitivity(cs) == Qt::CaseSensitive;
|
||||
QString lower, current;
|
||||
if(!sens) lower=fileName.toLower();
|
||||
p->hasCurrentFile_f=false;
|
||||
for(bool more=goToFirstFile(); more; more=goToNextFile()) {
|
||||
current=getCurrentFileName();
|
||||
if(current.isEmpty()) return false;
|
||||
if(sens) {
|
||||
if(current==fileName) break;
|
||||
} else {
|
||||
if(current.toLower()==lower) break;
|
||||
}
|
||||
}
|
||||
return p->hasCurrentFile_f;
|
||||
}
|
||||
|
||||
bool QuaZip::goToFirstFile()
|
||||
{
|
||||
p->zipError=UNZ_OK;
|
||||
if(p->mode!=mdUnzip) {
|
||||
qWarning("QuaZip::goToFirstFile(): ZIP is not open in mdUnzip mode");
|
||||
return false;
|
||||
}
|
||||
p->zipError=unzGoToFirstFile(p->unzFile_f);
|
||||
p->hasCurrentFile_f=p->zipError==UNZ_OK;
|
||||
return p->hasCurrentFile_f;
|
||||
}
|
||||
|
||||
bool QuaZip::goToNextFile()
|
||||
{
|
||||
p->zipError=UNZ_OK;
|
||||
if(p->mode!=mdUnzip) {
|
||||
qWarning("QuaZip::goToFirstFile(): ZIP is not open in mdUnzip mode");
|
||||
return false;
|
||||
}
|
||||
p->zipError=unzGoToNextFile(p->unzFile_f);
|
||||
p->hasCurrentFile_f=p->zipError==UNZ_OK;
|
||||
if(p->zipError==UNZ_END_OF_LIST_OF_FILE)
|
||||
p->zipError=UNZ_OK;
|
||||
return p->hasCurrentFile_f;
|
||||
}
|
||||
|
||||
bool QuaZip::getCurrentFileInfo(QuaZipFileInfo *info)const
|
||||
{
|
||||
QuaZip *fakeThis=(QuaZip*)this; // non-const
|
||||
fakeThis->p->zipError=UNZ_OK;
|
||||
if(p->mode!=mdUnzip) {
|
||||
qWarning("QuaZip::getCurrentFileInfo(): ZIP is not open in mdUnzip mode");
|
||||
return false;
|
||||
}
|
||||
unz_file_info info_z;
|
||||
QByteArray fileName;
|
||||
QByteArray extra;
|
||||
QByteArray comment;
|
||||
if(info==NULL) return false;
|
||||
if(!isOpen()||!hasCurrentFile()) return false;
|
||||
if((fakeThis->p->zipError=unzGetCurrentFileInfo(p->unzFile_f, &info_z, NULL, 0, NULL, 0, NULL, 0))!=UNZ_OK)
|
||||
return false;
|
||||
fileName.resize(info_z.size_filename);
|
||||
extra.resize(info_z.size_file_extra);
|
||||
comment.resize(info_z.size_file_comment);
|
||||
if((fakeThis->p->zipError=unzGetCurrentFileInfo(p->unzFile_f, NULL,
|
||||
fileName.data(), fileName.size(),
|
||||
extra.data(), extra.size(),
|
||||
comment.data(), comment.size()))!=UNZ_OK)
|
||||
return false;
|
||||
info->versionCreated=info_z.version;
|
||||
info->versionNeeded=info_z.version_needed;
|
||||
info->flags=info_z.flag;
|
||||
info->method=info_z.compression_method;
|
||||
info->crc=info_z.crc;
|
||||
info->compressedSize=info_z.compressed_size;
|
||||
info->uncompressedSize=info_z.uncompressed_size;
|
||||
info->diskNumberStart=info_z.disk_num_start;
|
||||
info->internalAttr=info_z.internal_fa;
|
||||
info->externalAttr=info_z.external_fa;
|
||||
info->name=p->fileNameCodec->toUnicode(fileName);
|
||||
info->comment=p->commentCodec->toUnicode(comment);
|
||||
info->extra=extra;
|
||||
info->dateTime=QDateTime(
|
||||
QDate(info_z.tmu_date.tm_year, info_z.tmu_date.tm_mon+1, info_z.tmu_date.tm_mday),
|
||||
QTime(info_z.tmu_date.tm_hour, info_z.tmu_date.tm_min, info_z.tmu_date.tm_sec));
|
||||
return true;
|
||||
}
|
||||
|
||||
QString QuaZip::getCurrentFileName()const
|
||||
{
|
||||
QuaZip *fakeThis=(QuaZip*)this; // non-const
|
||||
fakeThis->p->zipError=UNZ_OK;
|
||||
if(p->mode!=mdUnzip) {
|
||||
qWarning("QuaZip::getCurrentFileName(): ZIP is not open in mdUnzip mode");
|
||||
return QString();
|
||||
}
|
||||
if(!isOpen()||!hasCurrentFile()) return QString();
|
||||
QByteArray fileName(MAX_FILE_NAME_LENGTH, 0);
|
||||
if((fakeThis->p->zipError=unzGetCurrentFileInfo(p->unzFile_f, NULL, fileName.data(), fileName.size(),
|
||||
NULL, 0, NULL, 0))!=UNZ_OK)
|
||||
return QString();
|
||||
return p->fileNameCodec->toUnicode(fileName.constData());
|
||||
}
|
||||
|
||||
void QuaZip::setFileNameCodec(QTextCodec *fileNameCodec)
|
||||
{
|
||||
p->fileNameCodec=fileNameCodec;
|
||||
}
|
||||
|
||||
void QuaZip::setFileNameCodec(const char *fileNameCodecName)
|
||||
{
|
||||
p->fileNameCodec=QTextCodec::codecForName(fileNameCodecName);
|
||||
}
|
||||
|
||||
QTextCodec *QuaZip::getFileNameCodec()const
|
||||
{
|
||||
return p->fileNameCodec;
|
||||
}
|
||||
|
||||
void QuaZip::setCommentCodec(QTextCodec *commentCodec)
|
||||
{
|
||||
p->commentCodec=commentCodec;
|
||||
}
|
||||
|
||||
void QuaZip::setCommentCodec(const char *commentCodecName)
|
||||
{
|
||||
p->commentCodec=QTextCodec::codecForName(commentCodecName);
|
||||
}
|
||||
|
||||
QTextCodec *QuaZip::getCommentCodec()const
|
||||
{
|
||||
return p->commentCodec;
|
||||
}
|
||||
|
||||
QString QuaZip::getZipName() const
|
||||
{
|
||||
return p->zipName;
|
||||
}
|
||||
|
||||
QIODevice *QuaZip::getIoDevice() const
|
||||
{
|
||||
if (!p->zipName.isEmpty()) // opened by name, using an internal QIODevice
|
||||
return NULL;
|
||||
return p->ioDevice;
|
||||
}
|
||||
|
||||
QuaZip::Mode QuaZip::getMode()const
|
||||
{
|
||||
return p->mode;
|
||||
}
|
||||
|
||||
bool QuaZip::isOpen()const
|
||||
{
|
||||
return p->mode!=mdNotOpen;
|
||||
}
|
||||
|
||||
int QuaZip::getZipError() const
|
||||
{
|
||||
return p->zipError;
|
||||
}
|
||||
|
||||
void QuaZip::setComment(const QString& comment)
|
||||
{
|
||||
p->comment=comment;
|
||||
}
|
||||
|
||||
bool QuaZip::hasCurrentFile()const
|
||||
{
|
||||
return p->hasCurrentFile_f;
|
||||
}
|
||||
|
||||
unzFile QuaZip::getUnzFile()
|
||||
{
|
||||
return p->unzFile_f;
|
||||
}
|
||||
|
||||
zipFile QuaZip::getZipFile()
|
||||
{
|
||||
return p->zipFile_f;
|
||||
}
|
||||
|
||||
void QuaZip::setDataDescriptorWritingEnabled(bool enabled)
|
||||
{
|
||||
p->dataDescriptorWritingEnabled = enabled;
|
||||
}
|
||||
|
||||
bool QuaZip::isDataDescriptorWritingEnabled() const
|
||||
{
|
||||
return p->dataDescriptorWritingEnabled;
|
||||
}
|
||||
|
||||
template<typename TFileInfo>
|
||||
TFileInfo QuaZip_getFileInfo(QuaZip *zip, bool *ok);
|
||||
|
||||
template<>
|
||||
QuaZipFileInfo QuaZip_getFileInfo(QuaZip *zip, bool *ok)
|
||||
{
|
||||
QuaZipFileInfo info;
|
||||
*ok = zip->getCurrentFileInfo(&info);
|
||||
return info;
|
||||
}
|
||||
|
||||
template<>
|
||||
QString QuaZip_getFileInfo(QuaZip *zip, bool *ok)
|
||||
{
|
||||
QString name = zip->getCurrentFileName();
|
||||
*ok = !name.isEmpty();
|
||||
return name;
|
||||
}
|
||||
|
||||
template<typename TFileInfo>
|
||||
bool QuaZipPrivate::getFileInfoList(QList<TFileInfo> *result) const
|
||||
{
|
||||
QuaZipPrivate *fakeThis=const_cast<QuaZipPrivate*>(this);
|
||||
fakeThis->zipError=UNZ_OK;
|
||||
if (mode!=QuaZip::mdUnzip) {
|
||||
qWarning("QuaZip::getFileNameList/getFileInfoList(): "
|
||||
"ZIP is not open in mdUnzip mode");
|
||||
return false;
|
||||
}
|
||||
QString currentFile;
|
||||
if (q->hasCurrentFile()) {
|
||||
currentFile = q->getCurrentFileName();
|
||||
}
|
||||
if (q->goToFirstFile()) {
|
||||
do {
|
||||
bool ok;
|
||||
result->append(QuaZip_getFileInfo<TFileInfo>(q, &ok));
|
||||
if (!ok)
|
||||
return false;
|
||||
} while (q->goToNextFile());
|
||||
}
|
||||
if (zipError != UNZ_OK)
|
||||
return false;
|
||||
if (currentFile.isEmpty()) {
|
||||
if (!q->goToFirstFile())
|
||||
return false;
|
||||
} else {
|
||||
if (!q->setCurrentFile(currentFile))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
QStringList QuaZip::getFileNameList() const
|
||||
{
|
||||
QStringList list;
|
||||
if (p->getFileInfoList(&list))
|
||||
return list;
|
||||
else
|
||||
return QStringList();
|
||||
}
|
||||
|
||||
QList<QuaZipFileInfo> QuaZip::getFileInfoList() const
|
||||
{
|
||||
QList<QuaZipFileInfo> list;
|
||||
if (p->getFileInfoList(&list))
|
||||
return list;
|
||||
else
|
||||
return QList<QuaZipFileInfo>();
|
||||
}
|
||||
|
||||
Qt::CaseSensitivity QuaZip::convertCaseSensitivity(QuaZip::CaseSensitivity cs)
|
||||
{
|
||||
if (cs == csDefault) {
|
||||
#ifdef Q_WS_WIN
|
||||
return Qt::CaseInsensitive;
|
||||
#else
|
||||
return Qt::CaseSensitive;
|
||||
#endif
|
||||
} else {
|
||||
return cs == csSensitive ? Qt::CaseSensitive : Qt::CaseInsensitive;
|
||||
}
|
||||
}
|
@ -1,411 +0,0 @@
|
||||
#ifndef QUA_ZIP_H
|
||||
#define QUA_ZIP_H
|
||||
|
||||
/*
|
||||
Copyright (C) 2005-2011 Sergey A. Tachenov
|
||||
|
||||
This program is free software; you can redistribute it and/or modify it
|
||||
under the terms of the GNU Lesser 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 Lesser
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with this program; if not, write to the Free Software Foundation,
|
||||
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
See COPYING file for the full LGPL text.
|
||||
|
||||
Original ZIP package is copyrighted by Gilles Vollant, see
|
||||
quazip/(un)zip.h files for details, basically it's zlib license.
|
||||
**/
|
||||
|
||||
#include <QString>
|
||||
#include <QStringList>
|
||||
#include <QTextCodec>
|
||||
|
||||
#include "zip.h"
|
||||
#include "unzip.h"
|
||||
|
||||
#include "quazip_global.h"
|
||||
#include "quazipfileinfo.h"
|
||||
|
||||
// just in case it will be defined in the later versions of the ZIP/UNZIP
|
||||
#ifndef UNZ_OPENERROR
|
||||
// define additional error code
|
||||
#define UNZ_OPENERROR -1000
|
||||
#endif
|
||||
|
||||
class QuaZipPrivate;
|
||||
|
||||
/// ZIP archive.
|
||||
/** \class QuaZip quazip.h <quazip/quazip.h>
|
||||
* This class implements basic interface to the ZIP archive. It can be
|
||||
* used to read table contents of the ZIP archive and retreiving
|
||||
* information about the files inside it.
|
||||
*
|
||||
* You can also use this class to open files inside archive by passing
|
||||
* pointer to the instance of this class to the constructor of the
|
||||
* QuaZipFile class. But see QuaZipFile::QuaZipFile(QuaZip*, QObject*)
|
||||
* for the possible pitfalls.
|
||||
*
|
||||
* This class is indended to provide interface to the ZIP subpackage of
|
||||
* the ZIP/UNZIP package as well as to the UNZIP subpackage. But
|
||||
* currently it supports only UNZIP.
|
||||
*
|
||||
* The use of this class is simple - just create instance using
|
||||
* constructor, then set ZIP archive file name using setFile() function
|
||||
* (if you did not passed the name to the constructor), then open() and
|
||||
* then use different functions to work with it! Well, if you are
|
||||
* paranoid, you may also wish to call close before destructing the
|
||||
* instance, to check for errors on close.
|
||||
*
|
||||
* You may also use getUnzFile() and getZipFile() functions to get the
|
||||
* ZIP archive handle and use it with ZIP/UNZIP package API directly.
|
||||
*
|
||||
* This class supports localized file names inside ZIP archive, but you
|
||||
* have to set up proper codec with setCodec() function. By default,
|
||||
* locale codec will be used, which is probably ok for UNIX systems, but
|
||||
* will almost certainly fail with ZIP archives created in Windows. This
|
||||
* is because Windows ZIP programs have strange habit of using DOS
|
||||
* encoding for file names in ZIP archives. For example, ZIP archive
|
||||
* with cyrillic names created in Windows will have file names in \c
|
||||
* IBM866 encoding instead of \c WINDOWS-1251. I think that calling one
|
||||
* function is not much trouble, but for true platform independency it
|
||||
* would be nice to have some mechanism for file name encoding auto
|
||||
* detection using locale information. Does anyone know a good way to do
|
||||
* it?
|
||||
**/
|
||||
class QUAZIP_EXPORT QuaZip {
|
||||
friend class QuaZipPrivate;
|
||||
public:
|
||||
/// Useful constants.
|
||||
enum Constants {
|
||||
MAX_FILE_NAME_LENGTH=256 /**< Maximum file name length. Taken from
|
||||
\c UNZ_MAXFILENAMEINZIP constant in
|
||||
unzip.c. */
|
||||
};
|
||||
/// Open mode of the ZIP file.
|
||||
enum Mode {
|
||||
mdNotOpen, ///< ZIP file is not open. This is the initial mode.
|
||||
mdUnzip, ///< ZIP file is open for reading files inside it.
|
||||
mdCreate, ///< ZIP file was created with open() call.
|
||||
mdAppend, /**< ZIP file was opened in append mode. This refers to
|
||||
* \c APPEND_STATUS_CREATEAFTER mode in ZIP/UNZIP package
|
||||
* and means that zip is appended to some existing file
|
||||
* what is useful when that file contains
|
||||
* self-extractor code. This is obviously \em not what
|
||||
* you whant to use to add files to the existing ZIP
|
||||
* archive.
|
||||
**/
|
||||
mdAdd ///< ZIP file was opened for adding files in the archive.
|
||||
};
|
||||
/// Case sensitivity for the file names.
|
||||
/** This is what you specify when accessing files in the archive.
|
||||
* Works perfectly fine with any characters thanks to Qt's great
|
||||
* unicode support. This is different from ZIP/UNZIP API, where
|
||||
* only US-ASCII characters was supported.
|
||||
**/
|
||||
enum CaseSensitivity {
|
||||
csDefault=0, ///< Default for platform. Case sensitive for UNIX, not for Windows.
|
||||
csSensitive=1, ///< Case sensitive.
|
||||
csInsensitive=2 ///< Case insensitive.
|
||||
};
|
||||
static Qt::CaseSensitivity convertCaseSensitivity(CaseSensitivity);
|
||||
private:
|
||||
QuaZipPrivate *p;
|
||||
// not (and will not be) implemented
|
||||
QuaZip(const QuaZip& that);
|
||||
// not (and will not be) implemented
|
||||
QuaZip& operator=(const QuaZip& that);
|
||||
public:
|
||||
/// Constructs QuaZip object.
|
||||
/** Call setName() before opening constructed object. */
|
||||
QuaZip();
|
||||
/// Constructs QuaZip object associated with ZIP file \a zipName.
|
||||
QuaZip(const QString& zipName);
|
||||
/// Constructs QuaZip object associated with ZIP file represented by \a ioDevice.
|
||||
/** The IO device must be seekable, otherwise an error will occur when opening. */
|
||||
QuaZip(QIODevice *ioDevice);
|
||||
/// Destroys QuaZip object.
|
||||
/** Calls close() if necessary. */
|
||||
~QuaZip();
|
||||
/// Opens ZIP file.
|
||||
/**
|
||||
* Argument \a mode specifies open mode of the ZIP archive. See Mode
|
||||
* for details. Note that there is zipOpen2() function in the
|
||||
* ZIP/UNZIP API which accepts \a globalcomment argument, but it
|
||||
* does not use it anywhere, so this open() function does not have this
|
||||
* argument. See setComment() if you need to set global comment.
|
||||
*
|
||||
* If the ZIP file is accessed via explicitly set QIODevice, then
|
||||
* this device is opened in the necessary mode. If the device was
|
||||
* already opened by some other means, then the behaviour is defined by
|
||||
* the device implementation, but generally it is not a very good
|
||||
* idea. For example, QFile will at least issue a warning.
|
||||
*
|
||||
* \return \c true if successful, \c false otherwise.
|
||||
*
|
||||
* \note ZIP/UNZIP API open calls do not return error code - they
|
||||
* just return \c NULL indicating an error. But to make things
|
||||
* easier, quazip.h header defines additional error code \c
|
||||
* UNZ_ERROROPEN and getZipError() will return it if the open call
|
||||
* of the ZIP/UNZIP API returns \c NULL.
|
||||
*
|
||||
* Argument \a ioApi specifies IO function set for ZIP/UNZIP
|
||||
* package to use. See unzip.h, zip.h and ioapi.h for details. Note
|
||||
* that IO API for QuaZip is different from the original package.
|
||||
* The file path argument was changed to be of type \c voidpf, and
|
||||
* QuaZip passes a QIODevice pointer there. This QIODevice is either
|
||||
* set explicitly via setIoDevice() or the QuaZip(QIODevice*)
|
||||
* constructor, or it is created internally when opening the archive
|
||||
* by its file name. The default API (qioapi.cpp) just delegates
|
||||
* everything to the QIODevice API. Not only this allows to use a
|
||||
* QIODevice instead of file name, but also has a nice side effect
|
||||
* of raising the file size limit from 2G to 4G.
|
||||
*
|
||||
* In short: just forget about the \a ioApi argument and you'll be
|
||||
* fine.
|
||||
**/
|
||||
bool open(Mode mode, zlib_filefunc_def *ioApi =NULL);
|
||||
/// Closes ZIP file.
|
||||
/** Call getZipError() to determine if the close was successful. The
|
||||
* underlying QIODevice is also closed, regardless of whether it was
|
||||
* set explicitly or not. */
|
||||
void close();
|
||||
/// Sets the codec used to encode/decode file names inside archive.
|
||||
/** This is necessary to access files in the ZIP archive created
|
||||
* under Windows with non-latin characters in file names. For
|
||||
* example, file names with cyrillic letters will be in \c IBM866
|
||||
* encoding.
|
||||
**/
|
||||
void setFileNameCodec(QTextCodec *fileNameCodec);
|
||||
/// Sets the codec used to encode/decode file names inside archive.
|
||||
/** \overload
|
||||
* Equivalent to calling setFileNameCodec(QTextCodec::codecForName(codecName));
|
||||
**/
|
||||
void setFileNameCodec(const char *fileNameCodecName);
|
||||
/// Returns the codec used to encode/decode comments inside archive.
|
||||
QTextCodec* getFileNameCodec() const;
|
||||
/// Sets the codec used to encode/decode comments inside archive.
|
||||
/** This codec defaults to locale codec, which is probably ok.
|
||||
**/
|
||||
void setCommentCodec(QTextCodec *commentCodec);
|
||||
/// Sets the codec used to encode/decode comments inside archive.
|
||||
/** \overload
|
||||
* Equivalent to calling setCommentCodec(QTextCodec::codecForName(codecName));
|
||||
**/
|
||||
void setCommentCodec(const char *commentCodecName);
|
||||
/// Returns the codec used to encode/decode comments inside archive.
|
||||
QTextCodec* getCommentCodec() const;
|
||||
/// Returns the name of the ZIP file.
|
||||
/** Returns null string if no ZIP file name has been set, for
|
||||
* example when the QuaZip instance is set up to use a QIODevice
|
||||
* instead.
|
||||
* \sa setZipName(), setIoDevice(), getIoDevice()
|
||||
**/
|
||||
QString getZipName() const;
|
||||
/// Sets the name of the ZIP file.
|
||||
/** Does nothing if the ZIP file is open.
|
||||
*
|
||||
* Does not reset error code returned by getZipError().
|
||||
* \sa setIoDevice(), getIoDevice(), getZipName()
|
||||
**/
|
||||
void setZipName(const QString& zipName);
|
||||
/// Returns the device representing this ZIP file.
|
||||
/** Returns null string if no device has been set explicitly, for
|
||||
* example when opening a ZIP file by name.
|
||||
* \sa setIoDevice(), getZipName(), setZipName()
|
||||
**/
|
||||
QIODevice *getIoDevice() const;
|
||||
/// Sets the device representing the ZIP file.
|
||||
/** Does nothing if the ZIP file is open.
|
||||
*
|
||||
* Does not reset error code returned by getZipError().
|
||||
* \sa getIoDevice(), getZipName(), setZipName()
|
||||
**/
|
||||
void setIoDevice(QIODevice *ioDevice);
|
||||
/// Returns the mode in which ZIP file was opened.
|
||||
Mode getMode() const;
|
||||
/// Returns \c true if ZIP file is open, \c false otherwise.
|
||||
bool isOpen() const;
|
||||
/// Returns the error code of the last operation.
|
||||
/** Returns \c UNZ_OK if the last operation was successful.
|
||||
*
|
||||
* Error code resets to \c UNZ_OK every time you call any function
|
||||
* that accesses something inside ZIP archive, even if it is \c
|
||||
* const (like getEntriesCount()). open() and close() calls reset
|
||||
* error code too. See documentation for the specific functions for
|
||||
* details on error detection.
|
||||
**/
|
||||
int getZipError() const;
|
||||
/// Returns number of the entries in the ZIP central directory.
|
||||
/** Returns negative error code in the case of error. The same error
|
||||
* code will be returned by subsequent getZipError() call.
|
||||
**/
|
||||
int getEntriesCount() const;
|
||||
/// Returns global comment in the ZIP file.
|
||||
QString getComment() const;
|
||||
/// Sets the global comment in the ZIP file.
|
||||
/** The comment will be written to the archive on close operation.
|
||||
* QuaZip makes a distinction between a null QByteArray() comment
|
||||
* and an empty "" comment in the QuaZip::mdAdd mode.
|
||||
* A null comment is the default and it means "don't change
|
||||
* the comment". An empty comment removes the original comment.
|
||||
*
|
||||
* \sa open()
|
||||
**/
|
||||
void setComment(const QString& comment);
|
||||
/// Sets the current file to the first file in the archive.
|
||||
/** Returns \c true on success, \c false otherwise. Call
|
||||
* getZipError() to get the error code.
|
||||
**/
|
||||
bool goToFirstFile();
|
||||
/// Sets the current file to the next file in the archive.
|
||||
/** Returns \c true on success, \c false otherwise. Call
|
||||
* getZipError() to determine if there was an error.
|
||||
*
|
||||
* Should be used only in QuaZip::mdUnzip mode.
|
||||
*
|
||||
* \note If the end of file was reached, getZipError() will return
|
||||
* \c UNZ_OK instead of \c UNZ_END_OF_LIST_OF_FILE. This is to make
|
||||
* things like this easier:
|
||||
* \code
|
||||
* for(bool more=zip.goToFirstFile(); more; more=zip.goToNextFile()) {
|
||||
* // do something
|
||||
* }
|
||||
* if(zip.getZipError()==UNZ_OK) {
|
||||
* // ok, there was no error
|
||||
* }
|
||||
* \endcode
|
||||
**/
|
||||
bool goToNextFile();
|
||||
/// Sets current file by its name.
|
||||
/** Returns \c true if successful, \c false otherwise. Argument \a
|
||||
* cs specifies case sensitivity of the file name. Call
|
||||
* getZipError() in the case of a failure to get error code.
|
||||
*
|
||||
* This is not a wrapper to unzLocateFile() function. That is
|
||||
* because I had to implement locale-specific case-insensitive
|
||||
* comparison.
|
||||
*
|
||||
* Here are the differences from the original implementation:
|
||||
*
|
||||
* - If the file was not found, error code is \c UNZ_OK, not \c
|
||||
* UNZ_END_OF_LIST_OF_FILE (see also goToNextFile()).
|
||||
* - If this function fails, it unsets the current file rather than
|
||||
* resetting it back to what it was before the call.
|
||||
*
|
||||
* If \a fileName is null string then this function unsets the
|
||||
* current file and return \c true. Note that you should close the
|
||||
* file first if it is open! See
|
||||
* QuaZipFile::QuaZipFile(QuaZip*,QObject*) for the details.
|
||||
*
|
||||
* Should be used only in QuaZip::mdUnzip mode.
|
||||
*
|
||||
* \sa setFileNameCodec(), CaseSensitivity
|
||||
**/
|
||||
bool setCurrentFile(const QString& fileName, CaseSensitivity cs =csDefault);
|
||||
/// Returns \c true if the current file has been set.
|
||||
bool hasCurrentFile() const;
|
||||
/// Retrieves information about the current file.
|
||||
/** Fills the structure pointed by \a info. Returns \c true on
|
||||
* success, \c false otherwise. In the latter case structure pointed
|
||||
* by \a info remains untouched. If there was an error,
|
||||
* getZipError() returns error code.
|
||||
*
|
||||
* Should be used only in QuaZip::mdUnzip mode.
|
||||
*
|
||||
* Does nothing and returns \c false in any of the following cases.
|
||||
* - ZIP is not open;
|
||||
* - ZIP does not have current file;
|
||||
* - \a info is \c NULL;
|
||||
*
|
||||
* In all these cases getZipError() returns \c UNZ_OK since there
|
||||
* is no ZIP/UNZIP API call.
|
||||
**/
|
||||
bool getCurrentFileInfo(QuaZipFileInfo* info)const;
|
||||
/// Returns the current file name.
|
||||
/** Equivalent to calling getCurrentFileInfo() and then getting \c
|
||||
* name field of the QuaZipFileInfo structure, but faster and more
|
||||
* convenient.
|
||||
*
|
||||
* Should be used only in QuaZip::mdUnzip mode.
|
||||
**/
|
||||
QString getCurrentFileName()const;
|
||||
/// Returns \c unzFile handle.
|
||||
/** You can use this handle to directly call UNZIP part of the
|
||||
* ZIP/UNZIP package functions (see unzip.h).
|
||||
*
|
||||
* \warning When using the handle returned by this function, please
|
||||
* keep in mind that QuaZip class is unable to detect any changes
|
||||
* you make in the ZIP file state (e. g. changing current file, or
|
||||
* closing the handle). So please do not do anything with this
|
||||
* handle that is possible to do with the functions of this class.
|
||||
* Or at least return the handle in the original state before
|
||||
* calling some another function of this class (including implicit
|
||||
* destructor calls and calls from the QuaZipFile objects that refer
|
||||
* to this QuaZip instance!). So if you have changed the current
|
||||
* file in the ZIP archive - then change it back or you may
|
||||
* experience some strange behavior or even crashes.
|
||||
**/
|
||||
unzFile getUnzFile();
|
||||
/// Returns \c zipFile handle.
|
||||
/** You can use this handle to directly call ZIP part of the
|
||||
* ZIP/UNZIP package functions (see zip.h). Warnings about the
|
||||
* getUnzFile() function also apply to this function.
|
||||
**/
|
||||
zipFile getZipFile();
|
||||
/// Changes the data descriptor writing mode.
|
||||
/**
|
||||
According to the ZIP format specification, a file inside archive
|
||||
may have a data descriptor immediately following the file
|
||||
data. This is reflected by a special flag in the local file header
|
||||
and in the central directory. By default, QuaZIP sets this flag
|
||||
and writes the data descriptor unless both method and level were
|
||||
set to 0, in which case it operates in 1.0-compatible mode and
|
||||
never writes data descriptors.
|
||||
|
||||
By setting this flag to false, it is possible to disable data
|
||||
descriptor writing, thus increasing compatibility with archive
|
||||
readers that don't understand this feature of the ZIP file format.
|
||||
|
||||
Setting this flag affects all the QuaZipFile instances that are
|
||||
opened after this flag is set.
|
||||
|
||||
The data descriptor writing mode is enabled by default.
|
||||
|
||||
\param enabled If \c true, enable local descriptor writing,
|
||||
disable it otherwise.
|
||||
|
||||
\sa QuaZipFile::setDataDescriptorWritingEnabled()
|
||||
*/
|
||||
void setDataDescriptorWritingEnabled(bool enabled);
|
||||
/// Returns the data descriptor default writing mode.
|
||||
/**
|
||||
\sa setDataDescriptorWritingEnabled()
|
||||
*/
|
||||
bool isDataDescriptorWritingEnabled() const;
|
||||
/// Returns a list of files inside the archive.
|
||||
/**
|
||||
\return A list of file names or an empty list if there
|
||||
was an error or if the archive is empty (call getZipError() to
|
||||
figure out which).
|
||||
\sa getFileInfoList()
|
||||
*/
|
||||
QStringList getFileNameList() const;
|
||||
/// Returns information list about all files inside the archive.
|
||||
/**
|
||||
\return A list of QuaZipFileInfo objects or an empty list if there
|
||||
was an error or if the archive is empty (call getZipError() to
|
||||
figure out which).
|
||||
\sa getFileNameList()
|
||||
*/
|
||||
QList<QuaZipFileInfo> getFileInfoList() const;
|
||||
};
|
||||
|
||||
#endif
|
@ -1,55 +0,0 @@
|
||||
/**
|
||||
Copyright (C) 2005-2011 Sergey A. Tachenov
|
||||
|
||||
This program is free software; you can redistribute it and/or modify it
|
||||
under the terms of the GNU Lesser 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 Lesser
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with this program; if not, write to the Free Software Foundation,
|
||||
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
See COPYING file for the full LGPL text.
|
||||
|
||||
Original ZIP package is copyrighted by Gilles Vollant, see
|
||||
quazip/(un)zip.h files for details, basically it's zlib license.
|
||||
*/
|
||||
|
||||
#ifndef QUAZIP_GLOBAL_H
|
||||
#define QUAZIP_GLOBAL_H
|
||||
|
||||
#include <QtCore/qglobal.h>
|
||||
|
||||
/**
|
||||
This is automatically defined when building a static library, but when
|
||||
including QuaZip sources directly into a project, QUAZIP_STATIC should
|
||||
be defined explicitly to avoid possible troubles with unnecessary
|
||||
importing/exporting.
|
||||
*/
|
||||
#ifdef QUAZIP_STATIC
|
||||
#define QUAZIP_EXPORT
|
||||
#else
|
||||
/**
|
||||
* When building a DLL with MSVC, QUAZIP_BUILD must be defined.
|
||||
* qglobal.h takes care of defining Q_DECL_* correctly for msvc/gcc.
|
||||
*/
|
||||
#if defined(QUAZIP_BUILD)
|
||||
#define QUAZIP_EXPORT Q_DECL_EXPORT
|
||||
#else
|
||||
#define QUAZIP_EXPORT Q_DECL_IMPORT
|
||||
#endif
|
||||
#endif // QUAZIP_STATIC
|
||||
|
||||
#ifdef __GNUC__
|
||||
#define UNUSED __attribute__((__unused__))
|
||||
#else
|
||||
#define UNUSED
|
||||
#endif
|
||||
|
||||
#endif // QUAZIP_GLOBAL_H
|
@ -1,507 +0,0 @@
|
||||
#include "quazipdir.h"
|
||||
|
||||
#include <QSet>
|
||||
#include <QSharedData>
|
||||
|
||||
class QuaZipDirPrivate: public QSharedData {
|
||||
friend class QuaZipDir;
|
||||
private:
|
||||
QuaZipDirPrivate(QuaZip *zip, const QString &dir = QString()):
|
||||
zip(zip), dir(dir), caseSensitivity(QuaZip::csDefault),
|
||||
filter(QDir::NoFilter), sorting(QDir::NoSort) {}
|
||||
QuaZip *zip;
|
||||
QString dir;
|
||||
QuaZip::CaseSensitivity caseSensitivity;
|
||||
QDir::Filters filter;
|
||||
QStringList nameFilters;
|
||||
QDir::SortFlags sorting;
|
||||
template<typename TFileInfoList>
|
||||
bool entryInfoList(QStringList nameFilters, QDir::Filters filter,
|
||||
QDir::SortFlags sort, TFileInfoList &result) const;
|
||||
inline QString simplePath() const {return QDir::cleanPath(dir);}
|
||||
};
|
||||
|
||||
QuaZipDir::QuaZipDir(const QuaZipDir &that):
|
||||
d(that.d)
|
||||
{
|
||||
}
|
||||
|
||||
QuaZipDir::QuaZipDir(QuaZip *zip, const QString &dir):
|
||||
d(new QuaZipDirPrivate(zip, dir))
|
||||
{
|
||||
if (d->dir.startsWith('/'))
|
||||
d->dir = d->dir.mid(1);
|
||||
}
|
||||
|
||||
QuaZipDir::~QuaZipDir()
|
||||
{
|
||||
}
|
||||
|
||||
bool QuaZipDir::operator==(const QuaZipDir &that)
|
||||
{
|
||||
return d->zip == that.d->zip && d->dir == that.d->dir;
|
||||
}
|
||||
|
||||
QuaZipDir& QuaZipDir::operator=(const QuaZipDir &that)
|
||||
{
|
||||
this->d = that.d;
|
||||
return *this;
|
||||
}
|
||||
|
||||
QString QuaZipDir::operator[](int pos) const
|
||||
{
|
||||
return entryList().at(pos);
|
||||
}
|
||||
|
||||
QuaZip::CaseSensitivity QuaZipDir::caseSensitivity() const
|
||||
{
|
||||
return d->caseSensitivity;
|
||||
}
|
||||
|
||||
bool QuaZipDir::cd(const QString &directoryName)
|
||||
{
|
||||
if (directoryName == "/") {
|
||||
d->dir = "";
|
||||
return true;
|
||||
}
|
||||
QString dirName = directoryName;
|
||||
if (dirName.endsWith('/'))
|
||||
dirName.chop(1);
|
||||
if (dirName.contains('/')) {
|
||||
QuaZipDir dir(*this);
|
||||
if (dirName.startsWith('/')) {
|
||||
#ifdef QUAZIP_QUAZIPDIR_DEBUG
|
||||
qDebug("QuaZipDir::cd(%s): going to /",
|
||||
dirName.toUtf8().constData());
|
||||
#endif
|
||||
if (!dir.cd("/"))
|
||||
return false;
|
||||
}
|
||||
QStringList path = dirName.split('/', QString::SkipEmptyParts);
|
||||
for (QStringList::const_iterator i = path.constBegin();
|
||||
i != path.end();
|
||||
++i) {
|
||||
const QString &step = *i;
|
||||
#ifdef QUAZIP_QUAZIPDIR_DEBUG
|
||||
qDebug("QuaZipDir::cd(%s): going to %s",
|
||||
dirName.toUtf8().constData(),
|
||||
step.toUtf8().constData());
|
||||
#endif
|
||||
if (!dir.cd(step))
|
||||
return false;
|
||||
}
|
||||
d->dir = dir.path();
|
||||
return true;
|
||||
} else { // no '/'
|
||||
if (dirName == ".") {
|
||||
return true;
|
||||
} else if (dirName == "..") {
|
||||
if (isRoot()) {
|
||||
return false;
|
||||
} else {
|
||||
int slashPos = d->dir.lastIndexOf('/');
|
||||
if (slashPos == -1) {
|
||||
d->dir = "";
|
||||
} else {
|
||||
d->dir = d->dir.left(slashPos);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
} else { // a simple subdirectory
|
||||
if (exists(dirName)) {
|
||||
if (isRoot())
|
||||
d->dir = dirName;
|
||||
else
|
||||
d->dir += "/" + dirName;
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool QuaZipDir::cdUp()
|
||||
{
|
||||
return cd("..");
|
||||
}
|
||||
|
||||
uint QuaZipDir::count() const
|
||||
{
|
||||
return entryList().count();
|
||||
}
|
||||
|
||||
QString QuaZipDir::dirName() const
|
||||
{
|
||||
return QDir(d->dir).dirName();
|
||||
}
|
||||
|
||||
QuaZipFileInfo QuaZipDir_getFileInfo(QuaZip *zip, bool *ok,
|
||||
const QString &relativeName,
|
||||
bool isReal)
|
||||
{
|
||||
QuaZipFileInfo info;
|
||||
if (isReal) {
|
||||
*ok = zip->getCurrentFileInfo(&info);
|
||||
} else {
|
||||
*ok = true;
|
||||
info.compressedSize = 0;
|
||||
info.crc = 0;
|
||||
info.diskNumberStart = 0;
|
||||
info.externalAttr = 0;
|
||||
info.flags = 0;
|
||||
info.internalAttr = 0;
|
||||
info.method = 0;
|
||||
info.uncompressedSize = 0;
|
||||
info.versionCreated = info.versionNeeded = 0;
|
||||
}
|
||||
info.name = relativeName;
|
||||
return info;
|
||||
}
|
||||
|
||||
template<typename TFileInfoList>
|
||||
void QuaZipDir_convertInfoList(const QList<QuaZipFileInfo> &from, TFileInfoList &to);
|
||||
|
||||
template<>
|
||||
void QuaZipDir_convertInfoList(const QList<QuaZipFileInfo> &from, QList<QuaZipFileInfo> &to)
|
||||
{
|
||||
to = from;
|
||||
}
|
||||
|
||||
template<>
|
||||
void QuaZipDir_convertInfoList(const QList<QuaZipFileInfo> &from, QStringList &to)
|
||||
{
|
||||
to.clear();
|
||||
for (QList<QuaZipFileInfo>::const_iterator i = from.constBegin();
|
||||
i != from.constEnd();
|
||||
++i) {
|
||||
to.append(i->name);
|
||||
}
|
||||
}
|
||||
|
||||
// utility class to restore the current file
|
||||
class QuaZipDirRestoreCurrent {
|
||||
public:
|
||||
inline QuaZipDirRestoreCurrent(QuaZip *zip):
|
||||
zip(zip), currentFile(zip->getCurrentFileName()) {}
|
||||
inline ~QuaZipDirRestoreCurrent()
|
||||
{
|
||||
zip->setCurrentFile(currentFile);
|
||||
}
|
||||
private:
|
||||
QuaZip *zip;
|
||||
QString currentFile;
|
||||
};
|
||||
|
||||
class QuaZipDirComparator
|
||||
{
|
||||
private:
|
||||
QDir::SortFlags sort;
|
||||
static QString getExtension(const QString &name);
|
||||
int compareStrings(const QString &string1, const QString &string2);
|
||||
public:
|
||||
inline QuaZipDirComparator(QDir::SortFlags sort): sort(sort) {}
|
||||
bool operator()(const QuaZipFileInfo &info1, const QuaZipFileInfo &info2);
|
||||
};
|
||||
|
||||
QString QuaZipDirComparator::getExtension(const QString &name)
|
||||
{
|
||||
if (name.endsWith('.') || name.indexOf('.', 1) == -1) {
|
||||
return "";
|
||||
} else {
|
||||
return name.mid(name.lastIndexOf('.') + 1);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
int QuaZipDirComparator::compareStrings(const QString &string1,
|
||||
const QString &string2)
|
||||
{
|
||||
if (sort & QDir::LocaleAware) {
|
||||
if (sort & QDir::IgnoreCase) {
|
||||
return string1.toLower().localeAwareCompare(string2.toLower());
|
||||
} else {
|
||||
return string1.localeAwareCompare(string2);
|
||||
}
|
||||
} else {
|
||||
return string1.compare(string2, (sort & QDir::IgnoreCase)
|
||||
? Qt::CaseInsensitive : Qt::CaseSensitive);
|
||||
}
|
||||
}
|
||||
|
||||
bool QuaZipDirComparator::operator()(const QuaZipFileInfo &info1,
|
||||
const QuaZipFileInfo &info2)
|
||||
{
|
||||
QDir::SortFlags order = sort
|
||||
& (QDir::Name | QDir::Time | QDir::Size | QDir::Type);
|
||||
if ((sort & QDir::DirsFirst) == QDir::DirsFirst
|
||||
|| (sort & QDir::DirsLast) == QDir::DirsLast) {
|
||||
if (info1.name.endsWith('/') && !info2.name.endsWith('/'))
|
||||
return (sort & QDir::DirsFirst) == QDir::DirsFirst;
|
||||
else if (!info1.name.endsWith('/') && info2.name.endsWith('/'))
|
||||
return (sort & QDir::DirsLast) == QDir::DirsLast;
|
||||
}
|
||||
bool result;
|
||||
int extDiff;
|
||||
switch (order) {
|
||||
case QDir::Name:
|
||||
result = compareStrings(info1.name, info2.name) < 0;
|
||||
break;
|
||||
case QDir::Type:
|
||||
extDiff = compareStrings(getExtension(info1.name),
|
||||
getExtension(info2.name));
|
||||
if (extDiff == 0) {
|
||||
result = compareStrings(info1.name, info2.name) < 0;
|
||||
} else {
|
||||
result = extDiff < 0;
|
||||
}
|
||||
break;
|
||||
case QDir::Size:
|
||||
if (info1.uncompressedSize == info2.uncompressedSize) {
|
||||
result = compareStrings(info1.name, info2.name) < 0;
|
||||
} else {
|
||||
result = info1.uncompressedSize < info2.uncompressedSize;
|
||||
}
|
||||
break;
|
||||
case QDir::Time:
|
||||
if (info1.dateTime == info2.dateTime) {
|
||||
result = compareStrings(info1.name, info2.name) < 0;
|
||||
} else {
|
||||
result = info1.dateTime < info2.dateTime;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
qWarning("QuaZipDirComparator(): Invalid sort mode 0x%2X",
|
||||
static_cast<unsigned>(sort));
|
||||
return false;
|
||||
}
|
||||
return (sort & QDir::Reversed) ? !result : result;
|
||||
}
|
||||
|
||||
template<typename TFileInfoList>
|
||||
bool QuaZipDirPrivate::entryInfoList(QStringList nameFilters,
|
||||
QDir::Filters filter, QDir::SortFlags sort, TFileInfoList &result) const
|
||||
{
|
||||
QString basePath = simplePath();
|
||||
if (!basePath.isEmpty())
|
||||
basePath += "/";
|
||||
int baseLength = basePath.length();
|
||||
result.clear();
|
||||
QuaZipDirRestoreCurrent saveCurrent(zip);
|
||||
if (!zip->goToFirstFile()) {
|
||||
return zip->getZipError() == UNZ_OK;
|
||||
}
|
||||
QDir::Filters fltr = filter;
|
||||
if (fltr == QDir::NoFilter)
|
||||
fltr = this->filter;
|
||||
if (fltr == QDir::NoFilter)
|
||||
fltr = QDir::AllEntries;
|
||||
QStringList nmfltr = nameFilters;
|
||||
if (nmfltr.isEmpty())
|
||||
nmfltr = this->nameFilters;
|
||||
QSet<QString> dirsFound;
|
||||
QList<QuaZipFileInfo> list;
|
||||
do {
|
||||
QString name = zip->getCurrentFileName();
|
||||
if (!name.startsWith(basePath))
|
||||
continue;
|
||||
QString relativeName = name.mid(baseLength);
|
||||
bool isDir = false;
|
||||
bool isReal = true;
|
||||
if (relativeName.contains('/')) {
|
||||
int indexOfSlash = relativeName.indexOf('/');
|
||||
// something like "subdir/"
|
||||
isReal = indexOfSlash == relativeName.length() - 1;
|
||||
relativeName = relativeName.left(indexOfSlash + 1);
|
||||
if (dirsFound.contains(relativeName))
|
||||
continue;
|
||||
isDir = true;
|
||||
}
|
||||
dirsFound.insert(relativeName);
|
||||
if ((fltr & QDir::Dirs) == 0 && isDir)
|
||||
continue;
|
||||
if ((fltr & QDir::Files) == 0 && !isDir)
|
||||
continue;
|
||||
if (!nmfltr.isEmpty() && QDir::match(nmfltr, relativeName))
|
||||
continue;
|
||||
bool ok;
|
||||
QuaZipFileInfo info = QuaZipDir_getFileInfo(zip, &ok, relativeName,
|
||||
isReal);
|
||||
if (!ok) {
|
||||
return false;
|
||||
}
|
||||
list.append(info);
|
||||
} while (zip->goToNextFile());
|
||||
QDir::SortFlags srt = sort;
|
||||
if (srt == QDir::NoSort)
|
||||
srt = sorting;
|
||||
#ifdef QUAZIP_QUAZIPDIR_DEBUG
|
||||
qDebug("QuaZipDirPrivate::entryInfoList(): before sort:");
|
||||
foreach (QuaZipFileInfo info, list) {
|
||||
qDebug("%s\t%s", info.name.toUtf8().constData(),
|
||||
info.dateTime.toString(Qt::ISODate).toUtf8().constData());
|
||||
}
|
||||
#endif
|
||||
if (srt != QDir::NoSort && (srt & QDir::Unsorted) != QDir::Unsorted) {
|
||||
if (QuaZip::convertCaseSensitivity(caseSensitivity)
|
||||
== Qt::CaseInsensitive)
|
||||
srt |= QDir::IgnoreCase;
|
||||
QuaZipDirComparator lessThan(srt);
|
||||
qSort(list.begin(), list.end(), lessThan);
|
||||
}
|
||||
QuaZipDir_convertInfoList(list, result);
|
||||
return true;
|
||||
}
|
||||
|
||||
QList<QuaZipFileInfo> QuaZipDir::entryInfoList(const QStringList &nameFilters,
|
||||
QDir::Filters filters, QDir::SortFlags sort) const
|
||||
{
|
||||
QList<QuaZipFileInfo> result;
|
||||
if (d->entryInfoList(nameFilters, filters, sort, result))
|
||||
return result;
|
||||
else
|
||||
return QList<QuaZipFileInfo>();
|
||||
}
|
||||
|
||||
QList<QuaZipFileInfo> QuaZipDir::entryInfoList(QDir::Filters filters,
|
||||
QDir::SortFlags sort) const
|
||||
{
|
||||
return entryInfoList(QStringList(), filters, sort);
|
||||
}
|
||||
|
||||
QStringList QuaZipDir::entryList(const QStringList &nameFilters,
|
||||
QDir::Filters filters, QDir::SortFlags sort) const
|
||||
{
|
||||
QStringList result;
|
||||
if (d->entryInfoList(nameFilters, filters, sort, result))
|
||||
return result;
|
||||
else
|
||||
return QStringList();
|
||||
}
|
||||
|
||||
QStringList QuaZipDir::entryList(QDir::Filters filters,
|
||||
QDir::SortFlags sort) const
|
||||
{
|
||||
return entryList(QStringList(), filters, sort);
|
||||
}
|
||||
|
||||
bool QuaZipDir::exists(const QString &filePath) const
|
||||
{
|
||||
if (filePath == "/")
|
||||
return true;
|
||||
QString fileName = filePath;
|
||||
if (fileName.endsWith('/'))
|
||||
fileName.chop(1);
|
||||
if (fileName.contains('/')) {
|
||||
QFileInfo fileInfo(fileName);
|
||||
#ifdef QUAZIP_QUAZIPDIR_DEBUG
|
||||
qDebug("QuaZipDir::exists(): fileName=%s, fileInfo.fileName()=%s, "
|
||||
"fileInfo.path()=%s", fileName.toUtf8().constData(),
|
||||
fileInfo.fileName().toUtf8().constData(),
|
||||
fileInfo.path().toUtf8().constData());
|
||||
#endif
|
||||
QuaZipDir dir(*this);
|
||||
return dir.cd(fileInfo.path()) && dir.exists(fileInfo.fileName());
|
||||
} else {
|
||||
if (fileName == "..") {
|
||||
return !isRoot();
|
||||
} else if (fileName == ".") {
|
||||
return true;
|
||||
} else {
|
||||
QStringList entries = entryList(QDir::AllEntries, QDir::NoSort);
|
||||
#ifdef QUAZIP_QUAZIPDIR_DEBUG
|
||||
qDebug("QuaZipDir::exists(): looking for %s",
|
||||
fileName.toUtf8().constData());
|
||||
for (QStringList::const_iterator i = entries.constBegin();
|
||||
i != entries.constEnd();
|
||||
++i) {
|
||||
qDebug("QuaZipDir::exists(): entry: %s",
|
||||
i->toUtf8().constData());
|
||||
}
|
||||
#endif
|
||||
Qt::CaseSensitivity cs = QuaZip::convertCaseSensitivity(
|
||||
d->caseSensitivity);
|
||||
if (filePath.endsWith('/')) {
|
||||
return entries.contains(filePath, cs);
|
||||
} else {
|
||||
return entries.contains(fileName, cs)
|
||||
|| entries.contains(fileName + "/", cs);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool QuaZipDir::exists() const
|
||||
{
|
||||
QDir thisDir(d->dir);
|
||||
return QuaZipDir(d->zip, thisDir.filePath("..")).exists(thisDir.dirName());
|
||||
}
|
||||
|
||||
QString QuaZipDir::filePath(const QString &fileName) const
|
||||
{
|
||||
return QDir(d->dir).filePath(fileName);
|
||||
}
|
||||
|
||||
QDir::Filters QuaZipDir::filter()
|
||||
{
|
||||
return d->filter;
|
||||
}
|
||||
|
||||
bool QuaZipDir::isRoot() const
|
||||
{
|
||||
return d->simplePath().isEmpty();
|
||||
}
|
||||
|
||||
QStringList QuaZipDir::nameFilters() const
|
||||
{
|
||||
return d->nameFilters;
|
||||
}
|
||||
|
||||
QString QuaZipDir::path() const
|
||||
{
|
||||
return d->dir;
|
||||
}
|
||||
|
||||
QString QuaZipDir::relativeFilePath(const QString &fileName) const
|
||||
{
|
||||
return QDir(d->dir).relativeFilePath(fileName);
|
||||
}
|
||||
|
||||
void QuaZipDir::setCaseSensitivity(QuaZip::CaseSensitivity caseSensitivity)
|
||||
{
|
||||
d->caseSensitivity = caseSensitivity;
|
||||
}
|
||||
|
||||
void QuaZipDir::setFilter(QDir::Filters filters)
|
||||
{
|
||||
d->filter = filters;
|
||||
}
|
||||
|
||||
void QuaZipDir::setNameFilters(const QStringList &nameFilters)
|
||||
{
|
||||
d->nameFilters = nameFilters;
|
||||
}
|
||||
|
||||
void QuaZipDir::setPath(const QString &path)
|
||||
{
|
||||
QString newDir = path;
|
||||
if (newDir == "/") {
|
||||
d->dir = "";
|
||||
} else {
|
||||
if (newDir.endsWith('/'))
|
||||
newDir.chop(1);
|
||||
if (newDir.startsWith('/'))
|
||||
newDir = newDir.mid(1);
|
||||
d->dir = newDir;
|
||||
}
|
||||
}
|
||||
|
||||
void QuaZipDir::setSorting(QDir::SortFlags sort)
|
||||
{
|
||||
d->sorting = sort;
|
||||
}
|
||||
|
||||
QDir::SortFlags QuaZipDir::sorting() const
|
||||
{
|
||||
return d->sorting;
|
||||
}
|
@ -1,171 +0,0 @@
|
||||
#ifndef QUAZIP_QUAZIPDIR_H
|
||||
#define QUAZIP_QUAZIPDIR_H
|
||||
|
||||
class QuaZipDirPrivate;
|
||||
|
||||
#include "quazip.h"
|
||||
#include "quazipfileinfo.h"
|
||||
#include <QDir>
|
||||
#include <QList>
|
||||
#include <QSharedDataPointer>
|
||||
|
||||
/// Provides ZIP archive navigation.
|
||||
/**
|
||||
* This class is modelled after QDir, and is designed to provide similar
|
||||
* features for ZIP archives.
|
||||
*
|
||||
* The only significant difference from QDir is that the root path is not
|
||||
* '/', but an empty string since that's how the file paths are stored in
|
||||
* the archive. However, QuaZipDir understands the paths starting with
|
||||
* '/'. It is important in a few places:
|
||||
*
|
||||
* - In the cd() function.
|
||||
* - In the constructor.
|
||||
* - In the exists() function.
|
||||
*
|
||||
* Note that since ZIP uses '/' on all platforms, the '\' separator is
|
||||
* not supported.
|
||||
*/
|
||||
class QUAZIP_EXPORT QuaZipDir {
|
||||
private:
|
||||
QSharedDataPointer<QuaZipDirPrivate> d;
|
||||
public:
|
||||
/// The copy constructor.
|
||||
QuaZipDir(const QuaZipDir &that);
|
||||
/// Constructs a QuaZipDir instance pointing to the specified directory.
|
||||
/**
|
||||
If \a dir is not specified, points to the root of the archive.
|
||||
The same happens if the \a dir is "/".
|
||||
*/
|
||||
QuaZipDir(QuaZip *zip, const QString &dir = QString());
|
||||
/// Destructor.
|
||||
~QuaZipDir();
|
||||
/// The assignment operator.
|
||||
bool operator==(const QuaZipDir &that);
|
||||
/// operator!=
|
||||
/**
|
||||
\return \c true if either this and \a that use different QuaZip
|
||||
instances or if they point to different directories.
|
||||
*/
|
||||
inline bool operator!=(const QuaZipDir &that) {return !operator==(that);}
|
||||
/// operator==
|
||||
/**
|
||||
\return \c true if both this and \a that use the same QuaZip
|
||||
instance and point to the same directory.
|
||||
*/
|
||||
QuaZipDir& operator=(const QuaZipDir &that);
|
||||
/// Returns the name of the entry at the specified position.
|
||||
QString operator[](int pos) const;
|
||||
/// Returns the current case sensitivity mode.
|
||||
QuaZip::CaseSensitivity caseSensitivity() const;
|
||||
/// Changes the 'current' directory.
|
||||
/**
|
||||
* If the path starts with '/', it is interpreted as an absolute
|
||||
* path from the root of the archive. Otherwise, it is interpreted
|
||||
* as a path relative to the current directory as was set by the
|
||||
* previous cd() or the constructor.
|
||||
*
|
||||
* Note that the subsequent path() call will not return a path
|
||||
* starting with '/' in all cases.
|
||||
*/
|
||||
bool cd(const QString &dirName);
|
||||
/// Goes up.
|
||||
bool cdUp();
|
||||
/// Returns the number of entries in the directory.
|
||||
uint count() const;
|
||||
/// Returns the current directory name.
|
||||
/**
|
||||
The name doesn't include the path.
|
||||
*/
|
||||
QString dirName() const;
|
||||
/// Returns the list of the entries in the directory.
|
||||
/**
|
||||
\param nameFilters The list of file patterns to list, uses the same
|
||||
syntax as QDir.
|
||||
\param filters The entry type filters, only Files and Dirs are
|
||||
accepted.
|
||||
\param sort Sorting mode (not supported yet).
|
||||
*/
|
||||
QList<QuaZipFileInfo> entryInfoList(const QStringList &nameFilters,
|
||||
QDir::Filters filters = QDir::NoFilter,
|
||||
QDir::SortFlags sort = QDir::NoSort) const;
|
||||
/// Returns the list of the entries in the directory.
|
||||
/**
|
||||
\overload
|
||||
|
||||
The same as entryInfoList(QStringList(), filters, sort).
|
||||
*/
|
||||
QList<QuaZipFileInfo> entryInfoList(QDir::Filters filters = QDir::NoFilter,
|
||||
QDir::SortFlags sort = QDir::NoSort) const;
|
||||
/// Returns the list of the entry names in the directory.
|
||||
/**
|
||||
The same as entryInfoList(nameFilters, filters, sort), but only
|
||||
returns entry names.
|
||||
*/
|
||||
QStringList entryList(const QStringList &nameFilters,
|
||||
QDir::Filters filters = QDir::NoFilter,
|
||||
QDir::SortFlags sort = QDir::NoSort) const;
|
||||
/// Returns the list of the entry names in the directory.
|
||||
/**
|
||||
\overload
|
||||
|
||||
The same as entryList(QStringList(), filters, sort).
|
||||
*/
|
||||
QStringList entryList(QDir::Filters filters = QDir::NoFilter,
|
||||
QDir::SortFlags sort = QDir::NoSort) const;
|
||||
/// Returns \c true if the entry with the specified name exists.
|
||||
/**
|
||||
The ".." is considered to exist if the current directory
|
||||
is not root. The "." and "/" are considered to
|
||||
always exist. Paths starting with "/" are relative to
|
||||
the archive root, other paths are relative to the current dir.
|
||||
*/
|
||||
bool exists(const QString &fileName) const;
|
||||
/// Return \c true if the directory pointed by this QuaZipDir exists.
|
||||
bool exists() const;
|
||||
/// Returns the full path to the specified file.
|
||||
/**
|
||||
Doesn't check if the file actually exists.
|
||||
*/
|
||||
QString filePath(const QString &fileName) const;
|
||||
/// Returns the default filter.
|
||||
QDir::Filters filter();
|
||||
/// Returns if the QuaZipDir points to the root of the archive.
|
||||
/**
|
||||
Not that the root path is the empty string, not '/'.
|
||||
*/
|
||||
bool isRoot() const;
|
||||
/// Return the default name filter.
|
||||
QStringList nameFilters() const;
|
||||
/// Returns the path to the current dir.
|
||||
/**
|
||||
The path never starts with '/', and the root path is an empty
|
||||
string.
|
||||
*/
|
||||
QString path() const;
|
||||
/// Returns the path to the specified file relative to the current dir.
|
||||
QString relativeFilePath(const QString &fileName) const;
|
||||
/// Sets the default case sensitivity mode.
|
||||
void setCaseSensitivity(QuaZip::CaseSensitivity caseSensitivity);
|
||||
/// Sets the default filter.
|
||||
void setFilter(QDir::Filters filters);
|
||||
/// Sets the default name filter.
|
||||
void setNameFilters(const QStringList &nameFilters);
|
||||
/// Goes to the specified path.
|
||||
/**
|
||||
The difference from cd() is that this function never checks if the
|
||||
path actually exists and doesn't use relative paths, so it's
|
||||
possible to go to the root directory with setPath("").
|
||||
|
||||
Note that this function still chops the trailing and/or leading
|
||||
'/' and treats a single '/' as the root path (path() will still
|
||||
return an empty string).
|
||||
*/
|
||||
void setPath(const QString &path);
|
||||
/// Sets the default sorting mode.
|
||||
void setSorting(QDir::SortFlags sort);
|
||||
/// Returns the default sorting mode.
|
||||
QDir::SortFlags sorting() const;
|
||||
};
|
||||
|
||||
#endif // QUAZIP_QUAZIPDIR_H
|
@ -1,488 +0,0 @@
|
||||
/*
|
||||
Copyright (C) 2005-2011 Sergey A. Tachenov
|
||||
|
||||
This program is free software; you can redistribute it and/or modify it
|
||||
under the terms of the GNU Lesser 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 Lesser
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with this program; if not, write to the Free Software Foundation,
|
||||
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
See COPYING file for the full LGPL text.
|
||||
|
||||
Original ZIP package is copyrighted by Gilles Vollant, see
|
||||
quazip/(un)zip.h files for details, basically it's zlib license.
|
||||
**/
|
||||
|
||||
#include "quazipfile.h"
|
||||
|
||||
using namespace std;
|
||||
|
||||
/// The implementation class for QuaZip.
|
||||
/**
|
||||
\internal
|
||||
|
||||
This class contains all the private stuff for the QuaZipFile class, thus
|
||||
allowing to preserve binary compatibility between releases, the
|
||||
technique known as the Pimpl (private implementation) idiom.
|
||||
*/
|
||||
class QuaZipFilePrivate {
|
||||
friend class QuaZipFile;
|
||||
private:
|
||||
/// The pointer to the associated QuaZipFile instance.
|
||||
QuaZipFile *q;
|
||||
/// The QuaZip object to work with.
|
||||
QuaZip *zip;
|
||||
/// The file name.
|
||||
QString fileName;
|
||||
/// Case sensitivity mode.
|
||||
QuaZip::CaseSensitivity caseSensitivity;
|
||||
/// Whether this file is opened in the raw mode.
|
||||
bool raw;
|
||||
/// Write position to keep track of.
|
||||
/**
|
||||
QIODevice::pos() is broken for non-seekable devices, so we need
|
||||
our own position.
|
||||
*/
|
||||
qint64 writePos;
|
||||
/// Uncompressed size to write along with a raw file.
|
||||
ulong uncompressedSize;
|
||||
/// CRC to write along with a raw file.
|
||||
quint32 crc;
|
||||
/// Whether \ref zip points to an internal QuaZip instance.
|
||||
/**
|
||||
This is true if the archive was opened by name, rather than by
|
||||
supplying an existing QuaZip instance.
|
||||
*/
|
||||
bool internal;
|
||||
/// The last error.
|
||||
int zipError;
|
||||
/// Resets \ref zipError.
|
||||
inline void resetZipError() const {setZipError(UNZ_OK);}
|
||||
/// Sets the zip error.
|
||||
/**
|
||||
This function is marked as const although it changes one field.
|
||||
This allows to call it from const functions that don't change
|
||||
anything by themselves.
|
||||
*/
|
||||
void setZipError(int zipError) const;
|
||||
/// The constructor for the corresponding QuaZipFile constructor.
|
||||
inline QuaZipFilePrivate(QuaZipFile *q):
|
||||
q(q), zip(NULL), internal(true), zipError(UNZ_OK) {}
|
||||
/// The constructor for the corresponding QuaZipFile constructor.
|
||||
inline QuaZipFilePrivate(QuaZipFile *q, const QString &zipName):
|
||||
q(q), internal(true), zipError(UNZ_OK)
|
||||
{
|
||||
zip=new QuaZip(zipName);
|
||||
}
|
||||
/// The constructor for the corresponding QuaZipFile constructor.
|
||||
inline QuaZipFilePrivate(QuaZipFile *q, const QString &zipName, const QString &fileName,
|
||||
QuaZip::CaseSensitivity cs):
|
||||
q(q), internal(true), zipError(UNZ_OK)
|
||||
{
|
||||
zip=new QuaZip(zipName);
|
||||
this->fileName=fileName;
|
||||
if (this->fileName.startsWith('/'))
|
||||
this->fileName = this->fileName.mid(1);
|
||||
this->caseSensitivity=cs;
|
||||
}
|
||||
/// The constructor for the QuaZipFile constructor accepting a file name.
|
||||
inline QuaZipFilePrivate(QuaZipFile *q, QuaZip *zip):
|
||||
q(q), zip(zip), internal(false), zipError(UNZ_OK) {}
|
||||
/// The destructor.
|
||||
inline ~QuaZipFilePrivate()
|
||||
{
|
||||
if (internal)
|
||||
delete zip;
|
||||
}
|
||||
};
|
||||
|
||||
QuaZipFile::QuaZipFile():
|
||||
p(new QuaZipFilePrivate(this))
|
||||
{
|
||||
}
|
||||
|
||||
QuaZipFile::QuaZipFile(QObject *parent):
|
||||
QIODevice(parent),
|
||||
p(new QuaZipFilePrivate(this))
|
||||
{
|
||||
}
|
||||
|
||||
QuaZipFile::QuaZipFile(const QString& zipName, QObject *parent):
|
||||
QIODevice(parent),
|
||||
p(new QuaZipFilePrivate(this, zipName))
|
||||
{
|
||||
}
|
||||
|
||||
QuaZipFile::QuaZipFile(const QString& zipName, const QString& fileName,
|
||||
QuaZip::CaseSensitivity cs, QObject *parent):
|
||||
QIODevice(parent),
|
||||
p(new QuaZipFilePrivate(this, zipName, fileName, cs))
|
||||
{
|
||||
}
|
||||
|
||||
QuaZipFile::QuaZipFile(QuaZip *zip, QObject *parent):
|
||||
QIODevice(parent),
|
||||
p(new QuaZipFilePrivate(this, zip))
|
||||
{
|
||||
}
|
||||
|
||||
QuaZipFile::~QuaZipFile()
|
||||
{
|
||||
if (isOpen())
|
||||
close();
|
||||
delete p;
|
||||
}
|
||||
|
||||
QString QuaZipFile::getZipName() const
|
||||
{
|
||||
return p->zip==NULL ? QString() : p->zip->getZipName();
|
||||
}
|
||||
|
||||
QuaZip *QuaZipFile::getZip() const
|
||||
{
|
||||
return p->internal ? NULL : p->zip;
|
||||
}
|
||||
|
||||
QString QuaZipFile::getActualFileName()const
|
||||
{
|
||||
p->setZipError(UNZ_OK);
|
||||
if (p->zip == NULL || (openMode() & WriteOnly))
|
||||
return QString();
|
||||
QString name=p->zip->getCurrentFileName();
|
||||
if(name.isNull())
|
||||
p->setZipError(p->zip->getZipError());
|
||||
return name;
|
||||
}
|
||||
|
||||
void QuaZipFile::setZipName(const QString& zipName)
|
||||
{
|
||||
if(isOpen()) {
|
||||
qWarning("QuaZipFile::setZipName(): file is already open - can not set ZIP name");
|
||||
return;
|
||||
}
|
||||
if(p->zip!=NULL && p->internal)
|
||||
delete p->zip;
|
||||
p->zip=new QuaZip(zipName);
|
||||
p->internal=true;
|
||||
}
|
||||
|
||||
void QuaZipFile::setZip(QuaZip *zip)
|
||||
{
|
||||
if(isOpen()) {
|
||||
qWarning("QuaZipFile::setZip(): file is already open - can not set ZIP");
|
||||
return;
|
||||
}
|
||||
if(p->zip!=NULL && p->internal)
|
||||
delete p->zip;
|
||||
p->zip=zip;
|
||||
p->fileName=QString();
|
||||
p->internal=false;
|
||||
}
|
||||
|
||||
void QuaZipFile::setFileName(const QString& fileName, QuaZip::CaseSensitivity cs)
|
||||
{
|
||||
if(p->zip==NULL) {
|
||||
qWarning("QuaZipFile::setFileName(): call setZipName() first");
|
||||
return;
|
||||
}
|
||||
if(!p->internal) {
|
||||
qWarning("QuaZipFile::setFileName(): should not be used when not using internal QuaZip");
|
||||
return;
|
||||
}
|
||||
if(isOpen()) {
|
||||
qWarning("QuaZipFile::setFileName(): can not set file name for already opened file");
|
||||
return;
|
||||
}
|
||||
p->fileName=fileName;
|
||||
if (p->fileName.startsWith('/'))
|
||||
p->fileName = p->fileName.mid(1);
|
||||
p->caseSensitivity=cs;
|
||||
}
|
||||
|
||||
void QuaZipFilePrivate::setZipError(int zipError) const
|
||||
{
|
||||
QuaZipFilePrivate *fakeThis = const_cast<QuaZipFilePrivate*>(this); // non-const
|
||||
fakeThis->zipError=zipError;
|
||||
if(zipError==UNZ_OK)
|
||||
q->setErrorString(QString());
|
||||
else
|
||||
q->setErrorString(q->tr("ZIP/UNZIP API error %1").arg(zipError));
|
||||
}
|
||||
|
||||
bool QuaZipFile::open(OpenMode mode)
|
||||
{
|
||||
return open(mode, NULL);
|
||||
}
|
||||
|
||||
bool QuaZipFile::open(OpenMode mode, int *method, int *level, bool raw, const char *password)
|
||||
{
|
||||
p->resetZipError();
|
||||
if(isOpen()) {
|
||||
qWarning("QuaZipFile::open(): already opened");
|
||||
return false;
|
||||
}
|
||||
if(mode&Unbuffered) {
|
||||
qWarning("QuaZipFile::open(): Unbuffered mode is not supported");
|
||||
return false;
|
||||
}
|
||||
if((mode&ReadOnly)&&!(mode&WriteOnly)) {
|
||||
if(p->internal) {
|
||||
if(!p->zip->open(QuaZip::mdUnzip)) {
|
||||
p->setZipError(p->zip->getZipError());
|
||||
return false;
|
||||
}
|
||||
if(!p->zip->setCurrentFile(p->fileName, p->caseSensitivity)) {
|
||||
p->setZipError(p->zip->getZipError());
|
||||
p->zip->close();
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
if(p->zip==NULL) {
|
||||
qWarning("QuaZipFile::open(): zip is NULL");
|
||||
return false;
|
||||
}
|
||||
if(p->zip->getMode()!=QuaZip::mdUnzip) {
|
||||
qWarning("QuaZipFile::open(): file open mode %d incompatible with ZIP open mode %d",
|
||||
(int)mode, (int)p->zip->getMode());
|
||||
return false;
|
||||
}
|
||||
if(!p->zip->hasCurrentFile()) {
|
||||
qWarning("QuaZipFile::open(): zip does not have current file");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
p->setZipError(unzOpenCurrentFile3(p->zip->getUnzFile(), method, level, (int)raw, password));
|
||||
if(p->zipError==UNZ_OK) {
|
||||
setOpenMode(mode);
|
||||
p->raw=raw;
|
||||
return true;
|
||||
} else
|
||||
return false;
|
||||
}
|
||||
qWarning("QuaZipFile::open(): open mode %d not supported by this function", (int)mode);
|
||||
return false;
|
||||
}
|
||||
|
||||
bool QuaZipFile::open(OpenMode mode, const QuaZipNewInfo& info,
|
||||
const char *password, quint32 crc,
|
||||
int method, int level, bool raw,
|
||||
int windowBits, int memLevel, int strategy)
|
||||
{
|
||||
zip_fileinfo info_z;
|
||||
p->resetZipError();
|
||||
if(isOpen()) {
|
||||
qWarning("QuaZipFile::open(): already opened");
|
||||
return false;
|
||||
}
|
||||
if((mode&WriteOnly)&&!(mode&ReadOnly)) {
|
||||
if(p->internal) {
|
||||
qWarning("QuaZipFile::open(): write mode is incompatible with internal QuaZip approach");
|
||||
return false;
|
||||
}
|
||||
if(p->zip==NULL) {
|
||||
qWarning("QuaZipFile::open(): zip is NULL");
|
||||
return false;
|
||||
}
|
||||
if(p->zip->getMode()!=QuaZip::mdCreate&&p->zip->getMode()!=QuaZip::mdAppend&&p->zip->getMode()!=QuaZip::mdAdd) {
|
||||
qWarning("QuaZipFile::open(): file open mode %d incompatible with ZIP open mode %d",
|
||||
(int)mode, (int)p->zip->getMode());
|
||||
return false;
|
||||
}
|
||||
info_z.tmz_date.tm_year=info.dateTime.date().year();
|
||||
info_z.tmz_date.tm_mon=info.dateTime.date().month() - 1;
|
||||
info_z.tmz_date.tm_mday=info.dateTime.date().day();
|
||||
info_z.tmz_date.tm_hour=info.dateTime.time().hour();
|
||||
info_z.tmz_date.tm_min=info.dateTime.time().minute();
|
||||
info_z.tmz_date.tm_sec=info.dateTime.time().second();
|
||||
info_z.dosDate = 0;
|
||||
info_z.internal_fa=(uLong)info.internalAttr;
|
||||
info_z.external_fa=(uLong)info.externalAttr;
|
||||
if (!p->zip->isDataDescriptorWritingEnabled())
|
||||
zipClearFlags(p->zip->getZipFile(), ZIP_WRITE_DATA_DESCRIPTOR);
|
||||
p->setZipError(zipOpenNewFileInZip3(p->zip->getZipFile(),
|
||||
p->zip->getFileNameCodec()->fromUnicode(info.name).constData(), &info_z,
|
||||
info.extraLocal.constData(), info.extraLocal.length(),
|
||||
info.extraGlobal.constData(), info.extraGlobal.length(),
|
||||
p->zip->getCommentCodec()->fromUnicode(info.comment).constData(),
|
||||
method, level, (int)raw,
|
||||
windowBits, memLevel, strategy,
|
||||
password, (uLong)crc));
|
||||
if(p->zipError==UNZ_OK) {
|
||||
p->writePos=0;
|
||||
setOpenMode(mode);
|
||||
p->raw=raw;
|
||||
if(raw) {
|
||||
p->crc=crc;
|
||||
p->uncompressedSize=info.uncompressedSize;
|
||||
}
|
||||
return true;
|
||||
} else
|
||||
return false;
|
||||
}
|
||||
qWarning("QuaZipFile::open(): open mode %d not supported by this function", (int)mode);
|
||||
return false;
|
||||
}
|
||||
|
||||
bool QuaZipFile::isSequential()const
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
qint64 QuaZipFile::pos()const
|
||||
{
|
||||
if(p->zip==NULL) {
|
||||
qWarning("QuaZipFile::pos(): call setZipName() or setZip() first");
|
||||
return -1;
|
||||
}
|
||||
if(!isOpen()) {
|
||||
qWarning("QuaZipFile::pos(): file is not open");
|
||||
return -1;
|
||||
}
|
||||
if(openMode()&ReadOnly)
|
||||
// QIODevice::pos() is broken for sequential devices,
|
||||
// but thankfully bytesAvailable() returns the number of
|
||||
// bytes buffered, so we know how far ahead we are.
|
||||
return unztell(p->zip->getUnzFile()) - QIODevice::bytesAvailable();
|
||||
else
|
||||
return p->writePos;
|
||||
}
|
||||
|
||||
bool QuaZipFile::atEnd()const
|
||||
{
|
||||
if(p->zip==NULL) {
|
||||
qWarning("QuaZipFile::atEnd(): call setZipName() or setZip() first");
|
||||
return false;
|
||||
}
|
||||
if(!isOpen()) {
|
||||
qWarning("QuaZipFile::atEnd(): file is not open");
|
||||
return false;
|
||||
}
|
||||
if(openMode()&ReadOnly)
|
||||
// the same problem as with pos()
|
||||
return QIODevice::bytesAvailable() == 0
|
||||
&& unzeof(p->zip->getUnzFile())==1;
|
||||
else
|
||||
return true;
|
||||
}
|
||||
|
||||
qint64 QuaZipFile::size()const
|
||||
{
|
||||
if(!isOpen()) {
|
||||
qWarning("QuaZipFile::atEnd(): file is not open");
|
||||
return -1;
|
||||
}
|
||||
if(openMode()&ReadOnly)
|
||||
return p->raw?csize():usize();
|
||||
else
|
||||
return p->writePos;
|
||||
}
|
||||
|
||||
qint64 QuaZipFile::csize()const
|
||||
{
|
||||
unz_file_info info_z;
|
||||
p->setZipError(UNZ_OK);
|
||||
if(p->zip==NULL||p->zip->getMode()!=QuaZip::mdUnzip) return -1;
|
||||
p->setZipError(unzGetCurrentFileInfo(p->zip->getUnzFile(), &info_z, NULL, 0, NULL, 0, NULL, 0));
|
||||
if(p->zipError!=UNZ_OK)
|
||||
return -1;
|
||||
return info_z.compressed_size;
|
||||
}
|
||||
|
||||
qint64 QuaZipFile::usize()const
|
||||
{
|
||||
unz_file_info info_z;
|
||||
p->setZipError(UNZ_OK);
|
||||
if(p->zip==NULL||p->zip->getMode()!=QuaZip::mdUnzip) return -1;
|
||||
p->setZipError(unzGetCurrentFileInfo(p->zip->getUnzFile(), &info_z, NULL, 0, NULL, 0, NULL, 0));
|
||||
if(p->zipError!=UNZ_OK)
|
||||
return -1;
|
||||
return info_z.uncompressed_size;
|
||||
}
|
||||
|
||||
bool QuaZipFile::getFileInfo(QuaZipFileInfo *info)
|
||||
{
|
||||
if(p->zip==NULL||p->zip->getMode()!=QuaZip::mdUnzip) return false;
|
||||
p->zip->getCurrentFileInfo(info);
|
||||
p->setZipError(p->zip->getZipError());
|
||||
return p->zipError==UNZ_OK;
|
||||
}
|
||||
|
||||
void QuaZipFile::close()
|
||||
{
|
||||
p->resetZipError();
|
||||
if(p->zip==NULL||!p->zip->isOpen()) return;
|
||||
if(!isOpen()) {
|
||||
qWarning("QuaZipFile::close(): file isn't open");
|
||||
return;
|
||||
}
|
||||
if(openMode()&ReadOnly)
|
||||
p->setZipError(unzCloseCurrentFile(p->zip->getUnzFile()));
|
||||
else if(openMode()&WriteOnly)
|
||||
if(isRaw()) p->setZipError(zipCloseFileInZipRaw(p->zip->getZipFile(), p->uncompressedSize, p->crc));
|
||||
else p->setZipError(zipCloseFileInZip(p->zip->getZipFile()));
|
||||
else {
|
||||
qWarning("Wrong open mode: %d", (int)openMode());
|
||||
return;
|
||||
}
|
||||
if(p->zipError==UNZ_OK) setOpenMode(QIODevice::NotOpen);
|
||||
else return;
|
||||
if(p->internal) {
|
||||
p->zip->close();
|
||||
p->setZipError(p->zip->getZipError());
|
||||
}
|
||||
}
|
||||
|
||||
qint64 QuaZipFile::readData(char *data, qint64 maxSize)
|
||||
{
|
||||
p->setZipError(UNZ_OK);
|
||||
qint64 bytesRead=unzReadCurrentFile(p->zip->getUnzFile(), data, (unsigned)maxSize);
|
||||
if (bytesRead < 0) {
|
||||
p->setZipError((int) bytesRead);
|
||||
return -1;
|
||||
}
|
||||
return bytesRead;
|
||||
}
|
||||
|
||||
qint64 QuaZipFile::writeData(const char* data, qint64 maxSize)
|
||||
{
|
||||
p->setZipError(ZIP_OK);
|
||||
p->setZipError(zipWriteInFileInZip(p->zip->getZipFile(), data, (uint)maxSize));
|
||||
if(p->zipError!=ZIP_OK) return -1;
|
||||
else {
|
||||
p->writePos+=maxSize;
|
||||
return maxSize;
|
||||
}
|
||||
}
|
||||
|
||||
QString QuaZipFile::getFileName() const
|
||||
{
|
||||
return p->fileName;
|
||||
}
|
||||
|
||||
QuaZip::CaseSensitivity QuaZipFile::getCaseSensitivity() const
|
||||
{
|
||||
return p->caseSensitivity;
|
||||
}
|
||||
|
||||
bool QuaZipFile::isRaw() const
|
||||
{
|
||||
return p->raw;
|
||||
}
|
||||
|
||||
int QuaZipFile::getZipError() const
|
||||
{
|
||||
return p->zipError;
|
||||
}
|
||||
|
||||
qint64 QuaZipFile::bytesAvailable() const
|
||||
{
|
||||
return size() - pos();
|
||||
}
|
@ -1,442 +0,0 @@
|
||||
#ifndef QUA_ZIPFILE_H
|
||||
#define QUA_ZIPFILE_H
|
||||
|
||||
/*
|
||||
Copyright (C) 2005-2011 Sergey A. Tachenov
|
||||
|
||||
This program is free software; you can redistribute it and/or modify it
|
||||
under the terms of the GNU Lesser 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 Lesser
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with this program; if not, write to the Free Software Foundation,
|
||||
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
See COPYING file for the full LGPL text.
|
||||
|
||||
Original ZIP package is copyrighted by Gilles Vollant, see
|
||||
quazip/(un)zip.h files for details, basically it's zlib license.
|
||||
**/
|
||||
|
||||
#include <QIODevice>
|
||||
|
||||
#include "quazip_global.h"
|
||||
#include "quazip.h"
|
||||
#include "quazipnewinfo.h"
|
||||
|
||||
class QuaZipFilePrivate;
|
||||
|
||||
/// A file inside ZIP archive.
|
||||
/** \class QuaZipFile quazipfile.h <quazip/quazipfile.h>
|
||||
* This is the most interesting class. Not only it provides C++
|
||||
* interface to the ZIP/UNZIP package, but also integrates it with Qt by
|
||||
* subclassing QIODevice. This makes possible to access files inside ZIP
|
||||
* archive using QTextStream or QDataStream, for example. Actually, this
|
||||
* is the main purpose of the whole QuaZIP library.
|
||||
*
|
||||
* You can either use existing QuaZip instance to create instance of
|
||||
* this class or pass ZIP archive file name to this class, in which case
|
||||
* it will create internal QuaZip object. See constructors' descriptions
|
||||
* for details. Writing is only possible with the existing instance.
|
||||
*
|
||||
* Note that due to the underlying library's limitation it is not
|
||||
* possible to use multiple QuaZipFile instances to open several files
|
||||
* in the same archive at the same time. If you need to write to
|
||||
* multiple files in parallel, then you should write to temporary files
|
||||
* first, then pack them all at once when you have finished writing. If
|
||||
* you need to read multiple files inside the same archive in parallel,
|
||||
* you should extract them all into a temporary directory first.
|
||||
*
|
||||
* \section quazipfile-sequential Sequential or random-access?
|
||||
*
|
||||
* At the first thought, QuaZipFile has fixed size, the start and the
|
||||
* end and should be therefore considered random-access device. But
|
||||
* there is one major obstacle to making it random-access: ZIP/UNZIP API
|
||||
* does not support seek() operation and the only way to implement it is
|
||||
* through reopening the file and re-reading to the required position,
|
||||
* but this is prohibitively slow.
|
||||
*
|
||||
* Therefore, QuaZipFile is considered to be a sequential device. This
|
||||
* has advantage of availability of the ungetChar() operation (QIODevice
|
||||
* does not implement it properly for non-sequential devices unless they
|
||||
* support seek()). Disadvantage is a somewhat strange behaviour of the
|
||||
* size() and pos() functions. This should be kept in mind while using
|
||||
* this class.
|
||||
*
|
||||
**/
|
||||
class QUAZIP_EXPORT QuaZipFile: public QIODevice {
|
||||
friend class QuaZipFilePrivate;
|
||||
Q_OBJECT
|
||||
private:
|
||||
QuaZipFilePrivate *p;
|
||||
// these are not supported nor implemented
|
||||
QuaZipFile(const QuaZipFile& that);
|
||||
QuaZipFile& operator=(const QuaZipFile& that);
|
||||
protected:
|
||||
/// Implementation of the QIODevice::readData().
|
||||
qint64 readData(char *data, qint64 maxSize);
|
||||
/// Implementation of the QIODevice::writeData().
|
||||
qint64 writeData(const char *data, qint64 maxSize);
|
||||
public:
|
||||
/// Constructs a QuaZipFile instance.
|
||||
/** You should use setZipName() and setFileName() or setZip() before
|
||||
* trying to call open() on the constructed object.
|
||||
**/
|
||||
QuaZipFile();
|
||||
/// Constructs a QuaZipFile instance.
|
||||
/** \a parent argument specifies this object's parent object.
|
||||
*
|
||||
* You should use setZipName() and setFileName() or setZip() before
|
||||
* trying to call open() on the constructed object.
|
||||
**/
|
||||
QuaZipFile(QObject *parent);
|
||||
/// Constructs a QuaZipFile instance.
|
||||
/** \a parent argument specifies this object's parent object and \a
|
||||
* zipName specifies ZIP archive file name.
|
||||
*
|
||||
* You should use setFileName() before trying to call open() on the
|
||||
* constructed object.
|
||||
*
|
||||
* QuaZipFile constructed by this constructor can be used for read
|
||||
* only access. Use QuaZipFile(QuaZip*,QObject*) for writing.
|
||||
**/
|
||||
QuaZipFile(const QString& zipName, QObject *parent =NULL);
|
||||
/// Constructs a QuaZipFile instance.
|
||||
/** \a parent argument specifies this object's parent object, \a
|
||||
* zipName specifies ZIP archive file name and \a fileName and \a cs
|
||||
* specify a name of the file to open inside archive.
|
||||
*
|
||||
* QuaZipFile constructed by this constructor can be used for read
|
||||
* only access. Use QuaZipFile(QuaZip*,QObject*) for writing.
|
||||
*
|
||||
* \sa QuaZip::setCurrentFile()
|
||||
**/
|
||||
QuaZipFile(const QString& zipName, const QString& fileName,
|
||||
QuaZip::CaseSensitivity cs =QuaZip::csDefault, QObject *parent =NULL);
|
||||
/// Constructs a QuaZipFile instance.
|
||||
/** \a parent argument specifies this object's parent object.
|
||||
*
|
||||
* \a zip is the pointer to the existing QuaZip object. This
|
||||
* QuaZipFile object then can be used to read current file in the
|
||||
* \a zip or to write to the file inside it.
|
||||
*
|
||||
* \warning Using this constructor for reading current file can be
|
||||
* tricky. Let's take the following example:
|
||||
* \code
|
||||
* QuaZip zip("archive.zip");
|
||||
* zip.open(QuaZip::mdUnzip);
|
||||
* zip.setCurrentFile("file-in-archive");
|
||||
* QuaZipFile file(&zip);
|
||||
* file.open(QIODevice::ReadOnly);
|
||||
* // ok, now we can read from the file
|
||||
* file.read(somewhere, some);
|
||||
* zip.setCurrentFile("another-file-in-archive"); // oops...
|
||||
* QuaZipFile anotherFile(&zip);
|
||||
* anotherFile.open(QIODevice::ReadOnly);
|
||||
* anotherFile.read(somewhere, some); // this is still ok...
|
||||
* file.read(somewhere, some); // and this is NOT
|
||||
* \endcode
|
||||
* So, what exactly happens here? When we change current file in the
|
||||
* \c zip archive, \c file that references it becomes invalid
|
||||
* (actually, as far as I understand ZIP/UNZIP sources, it becomes
|
||||
* closed, but QuaZipFile has no means to detect it).
|
||||
*
|
||||
* Summary: do not close \c zip object or change its current file as
|
||||
* long as QuaZipFile is open. Even better - use another constructors
|
||||
* which create internal QuaZip instances, one per object, and
|
||||
* therefore do not cause unnecessary trouble. This constructor may
|
||||
* be useful, though, if you already have a QuaZip instance and do
|
||||
* not want to access several files at once. Good example:
|
||||
* \code
|
||||
* QuaZip zip("archive.zip");
|
||||
* zip.open(QuaZip::mdUnzip);
|
||||
* // first, we need some information about archive itself
|
||||
* QByteArray comment=zip.getComment();
|
||||
* // and now we are going to access files inside it
|
||||
* QuaZipFile file(&zip);
|
||||
* for(bool more=zip.goToFirstFile(); more; more=zip.goToNextFile()) {
|
||||
* file.open(QIODevice::ReadOnly);
|
||||
* // do something cool with file here
|
||||
* file.close(); // do not forget to close!
|
||||
* }
|
||||
* zip.close();
|
||||
* \endcode
|
||||
**/
|
||||
QuaZipFile(QuaZip *zip, QObject *parent =NULL);
|
||||
/// Destroys a QuaZipFile instance.
|
||||
/** Closes file if open, destructs internal QuaZip object (if it
|
||||
* exists and \em is internal, of course).
|
||||
**/
|
||||
virtual ~QuaZipFile();
|
||||
/// Returns the ZIP archive file name.
|
||||
/** If this object was created by passing QuaZip pointer to the
|
||||
* constructor, this function will return that QuaZip's file name
|
||||
* (or null string if that object does not have file name yet).
|
||||
*
|
||||
* Otherwise, returns associated ZIP archive file name or null
|
||||
* string if there are no name set yet.
|
||||
*
|
||||
* \sa setZipName() getFileName()
|
||||
**/
|
||||
QString getZipName()const;
|
||||
/// Returns a pointer to the associated QuaZip object.
|
||||
/** Returns \c NULL if there is no associated QuaZip or it is
|
||||
* internal (so you will not mess with it).
|
||||
**/
|
||||
QuaZip* getZip()const;
|
||||
/// Returns file name.
|
||||
/** This function returns file name you passed to this object either
|
||||
* by using
|
||||
* QuaZipFile(const QString&,const QString&,QuaZip::CaseSensitivity,QObject*)
|
||||
* or by calling setFileName(). Real name of the file may differ in
|
||||
* case if you used case-insensitivity.
|
||||
*
|
||||
* Returns null string if there is no file name set yet. This is the
|
||||
* case when this QuaZipFile operates on the existing QuaZip object
|
||||
* (constructor QuaZipFile(QuaZip*,QObject*) or setZip() was used).
|
||||
*
|
||||
* \sa getActualFileName
|
||||
**/
|
||||
QString getFileName() const;
|
||||
/// Returns case sensitivity of the file name.
|
||||
/** This function returns case sensitivity argument you passed to
|
||||
* this object either by using
|
||||
* QuaZipFile(const QString&,const QString&,QuaZip::CaseSensitivity,QObject*)
|
||||
* or by calling setFileName().
|
||||
*
|
||||
* Returns unpredictable value if getFileName() returns null string
|
||||
* (this is the case when you did not used setFileName() or
|
||||
* constructor above).
|
||||
*
|
||||
* \sa getFileName
|
||||
**/
|
||||
QuaZip::CaseSensitivity getCaseSensitivity() const;
|
||||
/// Returns the actual file name in the archive.
|
||||
/** This is \em not a ZIP archive file name, but a name of file inside
|
||||
* archive. It is not necessary the same name that you have passed
|
||||
* to the
|
||||
* QuaZipFile(const QString&,const QString&,QuaZip::CaseSensitivity,QObject*),
|
||||
* setFileName() or QuaZip::setCurrentFile() - this is the real file
|
||||
* name inside archive, so it may differ in case if the file name
|
||||
* search was case-insensitive.
|
||||
*
|
||||
* Equivalent to calling getCurrentFileName() on the associated
|
||||
* QuaZip object. Returns null string if there is no associated
|
||||
* QuaZip object or if it does not have a current file yet. And this
|
||||
* is the case if you called setFileName() but did not open the
|
||||
* file yet. So this is perfectly fine:
|
||||
* \code
|
||||
* QuaZipFile file("somezip.zip");
|
||||
* file.setFileName("somefile");
|
||||
* QString name=file.getName(); // name=="somefile"
|
||||
* QString actual=file.getActualFileName(); // actual is null string
|
||||
* file.open(QIODevice::ReadOnly);
|
||||
* QString actual=file.getActualFileName(); // actual can be "SoMeFiLe" on Windows
|
||||
* \endcode
|
||||
*
|
||||
* \sa getZipName(), getFileName(), QuaZip::CaseSensitivity
|
||||
**/
|
||||
QString getActualFileName()const;
|
||||
/// Sets the ZIP archive file name.
|
||||
/** Automatically creates internal QuaZip object and destroys
|
||||
* previously created internal QuaZip object, if any.
|
||||
*
|
||||
* Will do nothing if this file is already open. You must close() it
|
||||
* first.
|
||||
**/
|
||||
void setZipName(const QString& zipName);
|
||||
/// Returns \c true if the file was opened in raw mode.
|
||||
/** If the file is not open, the returned value is undefined.
|
||||
*
|
||||
* \sa open(OpenMode,int*,int*,bool,const char*)
|
||||
**/
|
||||
bool isRaw() const;
|
||||
/// Binds to the existing QuaZip instance.
|
||||
/** This function destroys internal QuaZip object, if any, and makes
|
||||
* this QuaZipFile to use current file in the \a zip object for any
|
||||
* further operations. See QuaZipFile(QuaZip*,QObject*) for the
|
||||
* possible pitfalls.
|
||||
*
|
||||
* Will do nothing if the file is currently open. You must close()
|
||||
* it first.
|
||||
**/
|
||||
void setZip(QuaZip *zip);
|
||||
/// Sets the file name.
|
||||
/** Will do nothing if at least one of the following conditions is
|
||||
* met:
|
||||
* - ZIP name has not been set yet (getZipName() returns null
|
||||
* string).
|
||||
* - This QuaZipFile is associated with external QuaZip. In this
|
||||
* case you should call that QuaZip's setCurrentFile() function
|
||||
* instead!
|
||||
* - File is already open so setting the name is meaningless.
|
||||
*
|
||||
* \sa QuaZip::setCurrentFile
|
||||
**/
|
||||
void setFileName(const QString& fileName, QuaZip::CaseSensitivity cs =QuaZip::csDefault);
|
||||
/// Opens a file for reading.
|
||||
/** Returns \c true on success, \c false otherwise.
|
||||
* Call getZipError() to get error code.
|
||||
*
|
||||
* \note Since ZIP/UNZIP API provides buffered reading only,
|
||||
* QuaZipFile does not support unbuffered reading. So do not pass
|
||||
* QIODevice::Unbuffered flag in \a mode, or open will fail.
|
||||
**/
|
||||
virtual bool open(OpenMode mode);
|
||||
/// Opens a file for reading.
|
||||
/** \overload
|
||||
* Argument \a password specifies a password to decrypt the file. If
|
||||
* it is NULL then this function behaves just like open(OpenMode).
|
||||
**/
|
||||
inline bool open(OpenMode mode, const char *password)
|
||||
{return open(mode, NULL, NULL, false, password);}
|
||||
/// Opens a file for reading.
|
||||
/** \overload
|
||||
* Argument \a password specifies a password to decrypt the file.
|
||||
*
|
||||
* An integers pointed by \a method and \a level will receive codes
|
||||
* of the compression method and level used. See unzip.h.
|
||||
*
|
||||
* If raw is \c true then no decompression is performed.
|
||||
*
|
||||
* \a method should not be \c NULL. \a level can be \c NULL if you
|
||||
* don't want to know the compression level.
|
||||
**/
|
||||
bool open(OpenMode mode, int *method, int *level, bool raw, const char *password =NULL);
|
||||
/// Opens a file for writing.
|
||||
/** \a info argument specifies information about file. It should at
|
||||
* least specify a correct file name. Also, it is a good idea to
|
||||
* specify correct timestamp (by default, current time will be
|
||||
* used). See QuaZipNewInfo.
|
||||
*
|
||||
* The \a password argument specifies the password for crypting. Pass NULL
|
||||
* if you don't need any crypting. The \a crc argument was supposed
|
||||
* to be used for crypting too, but then it turned out that it's
|
||||
* false information, so you need to set it to 0 unless you want to
|
||||
* use the raw mode (see below).
|
||||
*
|
||||
* Arguments \a method and \a level specify compression method and
|
||||
* level. The only method supported is Z_DEFLATED, but you may also
|
||||
* specify 0 for no compression. If all of the files in the archive
|
||||
* use both method 0 and either level 0 is explicitly specified or
|
||||
* data descriptor writing is disabled with
|
||||
* QuaZip::setDataDescriptorWritingEnabled(), then the
|
||||
* resulting archive is supposed to be compatible with the 1.0 ZIP
|
||||
* format version, should you need that. Except for this, \a level
|
||||
* has no other effects with method 0.
|
||||
*
|
||||
* If \a raw is \c true, no compression is performed. In this case,
|
||||
* \a crc and uncompressedSize field of the \a info are required.
|
||||
*
|
||||
* Arguments \a windowBits, \a memLevel, \a strategy provide zlib
|
||||
* algorithms tuning. See deflateInit2() in zlib.
|
||||
**/
|
||||
bool open(OpenMode mode, const QuaZipNewInfo& info,
|
||||
const char *password =NULL, quint32 crc =0,
|
||||
int method =Z_DEFLATED, int level =Z_DEFAULT_COMPRESSION, bool raw =false,
|
||||
int windowBits =-MAX_WBITS, int memLevel =DEF_MEM_LEVEL, int strategy =Z_DEFAULT_STRATEGY);
|
||||
/// Returns \c true, but \ref quazipfile-sequential "beware"!
|
||||
virtual bool isSequential()const;
|
||||
/// Returns current position in the file.
|
||||
/** Implementation of the QIODevice::pos(). When reading, this
|
||||
* function is a wrapper to the ZIP/UNZIP unztell(), therefore it is
|
||||
* unable to keep track of the ungetChar() calls (which is
|
||||
* non-virtual and therefore is dangerous to reimplement). So if you
|
||||
* are using ungetChar() feature of the QIODevice, this function
|
||||
* reports incorrect value until you get back characters which you
|
||||
* ungot.
|
||||
*
|
||||
* When writing, pos() returns number of bytes already written
|
||||
* (uncompressed unless you use raw mode).
|
||||
*
|
||||
* \note Although
|
||||
* \ref quazipfile-sequential "QuaZipFile is a sequential device"
|
||||
* and therefore pos() should always return zero, it does not,
|
||||
* because it would be misguiding. Keep this in mind.
|
||||
*
|
||||
* This function returns -1 if the file or archive is not open.
|
||||
*
|
||||
* Error code returned by getZipError() is not affected by this
|
||||
* function call.
|
||||
**/
|
||||
virtual qint64 pos()const;
|
||||
/// Returns \c true if the end of file was reached.
|
||||
/** This function returns \c false in the case of error. This means
|
||||
* that you called this function on either not open file, or a file
|
||||
* in the not open archive or even on a QuaZipFile instance that
|
||||
* does not even have QuaZip instance associated. Do not do that
|
||||
* because there is no means to determine whether \c false is
|
||||
* returned because of error or because end of file was reached.
|
||||
* Well, on the other side you may interpret \c false return value
|
||||
* as "there is no file open to check for end of file and there is
|
||||
* no end of file therefore".
|
||||
*
|
||||
* When writing, this function always returns \c true (because you
|
||||
* are always writing to the end of file).
|
||||
*
|
||||
* Error code returned by getZipError() is not affected by this
|
||||
* function call.
|
||||
**/
|
||||
virtual bool atEnd()const;
|
||||
/// Returns file size.
|
||||
/** This function returns csize() if the file is open for reading in
|
||||
* raw mode, usize() if it is open for reading in normal mode and
|
||||
* pos() if it is open for writing.
|
||||
*
|
||||
* Returns -1 on error, call getZipError() to get error code.
|
||||
*
|
||||
* \note This function returns file size despite that
|
||||
* \ref quazipfile-sequential "QuaZipFile is considered to be sequential device",
|
||||
* for which size() should return bytesAvailable() instead. But its
|
||||
* name would be very misguiding otherwise, so just keep in mind
|
||||
* this inconsistence.
|
||||
**/
|
||||
virtual qint64 size()const;
|
||||
/// Returns compressed file size.
|
||||
/** Equivalent to calling getFileInfo() and then getting
|
||||
* compressedSize field, but more convenient and faster.
|
||||
*
|
||||
* File must be open for reading before calling this function.
|
||||
*
|
||||
* Returns -1 on error, call getZipError() to get error code.
|
||||
**/
|
||||
qint64 csize()const;
|
||||
/// Returns uncompressed file size.
|
||||
/** Equivalent to calling getFileInfo() and then getting
|
||||
* uncompressedSize field, but more convenient and faster. See
|
||||
* getFileInfo() for a warning.
|
||||
*
|
||||
* File must be open for reading before calling this function.
|
||||
*
|
||||
* Returns -1 on error, call getZipError() to get error code.
|
||||
**/
|
||||
qint64 usize()const;
|
||||
/// Gets information about current file.
|
||||
/** This function does the same thing as calling
|
||||
* QuaZip::getCurrentFileInfo() on the associated QuaZip object,
|
||||
* but you can not call getCurrentFileInfo() if the associated
|
||||
* QuaZip is internal (because you do not have access to it), while
|
||||
* you still can call this function in that case.
|
||||
*
|
||||
* File must be open for reading before calling this function.
|
||||
*
|
||||
* Returns \c false in the case of an error.
|
||||
**/
|
||||
bool getFileInfo(QuaZipFileInfo *info);
|
||||
/// Closes the file.
|
||||
/** Call getZipError() to determine if the close was successful.
|
||||
**/
|
||||
virtual void close();
|
||||
/// Returns the error code returned by the last ZIP/UNZIP API call.
|
||||
int getZipError() const;
|
||||
/// Returns the number of bytes available for reading.
|
||||
virtual qint64 bytesAvailable() const;
|
||||
};
|
||||
|
||||
#endif
|
@ -1,66 +0,0 @@
|
||||
#ifndef QUA_ZIPFILEINFO_H
|
||||
#define QUA_ZIPFILEINFO_H
|
||||
|
||||
/*
|
||||
Copyright (C) 2005-2011 Sergey A. Tachenov
|
||||
|
||||
This program is free software; you can redistribute it and/or modify it
|
||||
under the terms of the GNU Lesser 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 Lesser
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with this program; if not, write to the Free Software Foundation,
|
||||
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
See COPYING file for the full LGPL text.
|
||||
|
||||
Original ZIP package is copyrighted by Gilles Vollant, see
|
||||
quazip/(un)zip.h files for details, basically it's zlib license.
|
||||
**/
|
||||
|
||||
#include <QByteArray>
|
||||
#include <QDateTime>
|
||||
|
||||
#include "quazip_global.h"
|
||||
|
||||
/// Information about a file inside archive.
|
||||
/** Call QuaZip::getCurrentFileInfo() or QuaZipFile::getFileInfo() to
|
||||
* fill this structure. */
|
||||
struct QUAZIP_EXPORT QuaZipFileInfo {
|
||||
/// File name.
|
||||
QString name;
|
||||
/// Version created by.
|
||||
quint16 versionCreated;
|
||||
/// Version needed to extract.
|
||||
quint16 versionNeeded;
|
||||
/// General purpose flags.
|
||||
quint16 flags;
|
||||
/// Compression method.
|
||||
quint16 method;
|
||||
/// Last modification date and time.
|
||||
QDateTime dateTime;
|
||||
/// CRC.
|
||||
quint32 crc;
|
||||
/// Compressed file size.
|
||||
quint32 compressedSize;
|
||||
/// Uncompressed file size.
|
||||
quint32 uncompressedSize;
|
||||
/// Disk number start.
|
||||
quint16 diskNumberStart;
|
||||
/// Internal file attributes.
|
||||
quint16 internalAttr;
|
||||
/// External file attributes.
|
||||
quint32 externalAttr;
|
||||
/// Comment.
|
||||
QString comment;
|
||||
/// Extra field.
|
||||
QByteArray extra;
|
||||
};
|
||||
|
||||
#endif
|
@ -1,51 +0,0 @@
|
||||
/*
|
||||
Copyright (C) 2005-2011 Sergey A. Tachenov
|
||||
|
||||
This program is free software; you can redistribute it and/or modify it
|
||||
under the terms of the GNU Lesser 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 Lesser
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with this program; if not, write to the Free Software Foundation,
|
||||
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
See COPYING file for the full LGPL text.
|
||||
|
||||
Original ZIP package is copyrighted by Gilles Vollant, see
|
||||
quazip/(un)zip.h files for details, basically it's zlib license.
|
||||
*/
|
||||
|
||||
#include <QFileInfo>
|
||||
|
||||
#include "quazipnewinfo.h"
|
||||
|
||||
|
||||
QuaZipNewInfo::QuaZipNewInfo(const QString& name):
|
||||
name(name), dateTime(QDateTime::currentDateTime()), internalAttr(0), externalAttr(0)
|
||||
{
|
||||
}
|
||||
|
||||
QuaZipNewInfo::QuaZipNewInfo(const QString& name, const QString& file):
|
||||
name(name), internalAttr(0), externalAttr(0)
|
||||
{
|
||||
QFileInfo info(file);
|
||||
QDateTime lm = info.lastModified();
|
||||
if (!info.exists())
|
||||
dateTime = QDateTime::currentDateTime();
|
||||
else
|
||||
dateTime = lm;
|
||||
}
|
||||
|
||||
void QuaZipNewInfo::setFileDateTime(const QString& file)
|
||||
{
|
||||
QFileInfo info(file);
|
||||
QDateTime lm = info.lastModified();
|
||||
if (info.exists())
|
||||
dateTime = lm;
|
||||
}
|
@ -1,102 +0,0 @@
|
||||
#ifndef QUA_ZIPNEWINFO_H
|
||||
#define QUA_ZIPNEWINFO_H
|
||||
|
||||
/*
|
||||
Copyright (C) 2005-2011 Sergey A. Tachenov
|
||||
|
||||
This program is free software; you can redistribute it and/or modify it
|
||||
under the terms of the GNU Lesser 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 Lesser
|
||||
General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Lesser General Public License
|
||||
along with this program; if not, write to the Free Software Foundation,
|
||||
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
|
||||
See COPYING file for the full LGPL text.
|
||||
|
||||
Original ZIP package is copyrighted by Gilles Vollant, see
|
||||
quazip/(un)zip.h files for details, basically it's zlib license.
|
||||
**/
|
||||
|
||||
#include <QDateTime>
|
||||
#include <QString>
|
||||
|
||||
#include "quazip_global.h"
|
||||
|
||||
/// Information about a file to be created.
|
||||
/** This structure holds information about a file to be created inside
|
||||
* ZIP archive. At least name should be set to something correct before
|
||||
* passing this structure to
|
||||
* QuaZipFile::open(OpenMode,const QuaZipNewInfo&,int,int,bool).
|
||||
**/
|
||||
struct QUAZIP_EXPORT QuaZipNewInfo {
|
||||
/// File name.
|
||||
/** This field holds file name inside archive, including path relative
|
||||
* to archive root.
|
||||
**/
|
||||
QString name;
|
||||
/// File timestamp.
|
||||
/** This is the last file modification date and time. Will be stored
|
||||
* in the archive central directory. It is a good practice to set it
|
||||
* to the source file timestamp instead of archive creating time. Use
|
||||
* setFileDateTime() or QuaZipNewInfo(const QString&, const QString&).
|
||||
**/
|
||||
QDateTime dateTime;
|
||||
/// File internal attributes.
|
||||
quint16 internalAttr;
|
||||
/// File external attributes.
|
||||
quint32 externalAttr;
|
||||
/// File comment.
|
||||
/** Will be encoded using QuaZip::getCommentCodec().
|
||||
**/
|
||||
QString comment;
|
||||
/// File local extra field.
|
||||
QByteArray extraLocal;
|
||||
/// File global extra field.
|
||||
QByteArray extraGlobal;
|
||||
/// Uncompressed file size.
|
||||
/** This is only needed if you are using raw file zipping mode, i. e.
|
||||
* adding precompressed file in the zip archive.
|
||||
**/
|
||||
ulong uncompressedSize;
|
||||
/// Constructs QuaZipNewInfo instance.
|
||||
/** Initializes name with \a name, dateTime with current date and
|
||||
* time. Attributes are initialized with zeros, comment and extra
|
||||
* field with null values.
|
||||
**/
|
||||
QuaZipNewInfo(const QString& name);
|
||||
/// Constructs QuaZipNewInfo instance.
|
||||
/** Initializes name with \a name and dateTime with timestamp of the
|
||||
* file named \a file. If the \a file does not exists or its timestamp
|
||||
* is inaccessible (e. g. you do not have read permission for the
|
||||
* directory file in), uses current date and time. Attributes are
|
||||
* initialized with zeros, comment and extra field with null values.
|
||||
*
|
||||
* \sa setFileDateTime()
|
||||
**/
|
||||
QuaZipNewInfo(const QString& name, const QString& file);
|
||||
/// Sets the file timestamp from the existing file.
|
||||
/** Use this function to set the file timestamp from the existing
|
||||
* file. Use it like this:
|
||||
* \code
|
||||
* QuaZipFile zipFile(&zip);
|
||||
* QFile file("file-to-add");
|
||||
* file.open(QIODevice::ReadOnly);
|
||||
* QuaZipNewInfo info("file-name-in-archive");
|
||||
* info.setFileDateTime("file-to-add"); // take the timestamp from file
|
||||
* zipFile.open(QIODevice::WriteOnly, info);
|
||||
* \endcode
|
||||
*
|
||||
* This function does not change dateTime if some error occured (e. g.
|
||||
* file is inaccessible).
|
||||
**/
|
||||
void setFileDateTime(const QString& file);
|
||||
};
|
||||
|
||||
#endif
|
File diff suppressed because it is too large
Load Diff
@ -1,356 +0,0 @@
|
||||
/* unzip.h -- IO for uncompress .zip files using zlib
|
||||
Version 1.01e, February 12th, 2005
|
||||
|
||||
Copyright (C) 1998-2005 Gilles Vollant
|
||||
|
||||
This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
|
||||
WinZip, InfoZip tools and compatible.
|
||||
|
||||
Multi volume ZipFile (span) are not supported.
|
||||
Encryption compatible with pkzip 2.04g only supported
|
||||
Old compressions used by old PKZip 1.x are not supported
|
||||
|
||||
|
||||
I WAIT FEEDBACK at mail info@winimage.com
|
||||
Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
|
||||
|
||||
Condition of use and distribution are the same than zlib :
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
|
||||
Modified by Sergey A. Tachenov to integrate with Qt.
|
||||
|
||||
|
||||
*/
|
||||
|
||||
/* for more info about .ZIP format, see
|
||||
http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
|
||||
http://www.info-zip.org/pub/infozip/doc/
|
||||
PkWare has also a specification at :
|
||||
ftp://ftp.pkware.com/probdesc.zip
|
||||
*/
|
||||
|
||||
#ifndef _unz_H
|
||||
#define _unz_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef _ZLIB_H
|
||||
#include "zlib.h"
|
||||
#endif
|
||||
|
||||
#ifndef _ZLIBIOAPI_H
|
||||
#include "ioapi.h"
|
||||
#endif
|
||||
|
||||
#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
|
||||
/* like the STRICT of WIN32, we define a pointer that cannot be converted
|
||||
from (void*) without cast */
|
||||
typedef struct TagunzFile__ { int unused; } unzFile__;
|
||||
typedef unzFile__ *unzFile;
|
||||
#else
|
||||
typedef voidp unzFile;
|
||||
#endif
|
||||
|
||||
|
||||
#define UNZ_OK (0)
|
||||
#define UNZ_END_OF_LIST_OF_FILE (-100)
|
||||
#define UNZ_ERRNO (Z_ERRNO)
|
||||
#define UNZ_EOF (0)
|
||||
#define UNZ_PARAMERROR (-102)
|
||||
#define UNZ_BADZIPFILE (-103)
|
||||
#define UNZ_INTERNALERROR (-104)
|
||||
#define UNZ_CRCERROR (-105)
|
||||
|
||||
/* tm_unz contain date/time info */
|
||||
typedef struct tm_unz_s
|
||||
{
|
||||
uInt tm_sec; /* seconds after the minute - [0,59] */
|
||||
uInt tm_min; /* minutes after the hour - [0,59] */
|
||||
uInt tm_hour; /* hours since midnight - [0,23] */
|
||||
uInt tm_mday; /* day of the month - [1,31] */
|
||||
uInt tm_mon; /* months since January - [0,11] */
|
||||
uInt tm_year; /* years - [1980..2044] */
|
||||
} tm_unz;
|
||||
|
||||
/* unz_global_info structure contain global data about the ZIPfile
|
||||
These data comes from the end of central dir */
|
||||
typedef struct unz_global_info_s
|
||||
{
|
||||
uLong number_entry; /* total number of entries in
|
||||
the central dir on this disk */
|
||||
uLong size_comment; /* size of the global comment of the zipfile */
|
||||
} unz_global_info;
|
||||
|
||||
|
||||
/* unz_file_info contain information about a file in the zipfile */
|
||||
typedef struct unz_file_info_s
|
||||
{
|
||||
uLong version; /* version made by 2 bytes */
|
||||
uLong version_needed; /* version needed to extract 2 bytes */
|
||||
uLong flag; /* general purpose bit flag 2 bytes */
|
||||
uLong compression_method; /* compression method 2 bytes */
|
||||
uLong dosDate; /* last mod file date in Dos fmt 4 bytes */
|
||||
uLong crc; /* crc-32 4 bytes */
|
||||
uLong compressed_size; /* compressed size 4 bytes */
|
||||
uLong uncompressed_size; /* uncompressed size 4 bytes */
|
||||
uLong size_filename; /* filename length 2 bytes */
|
||||
uLong size_file_extra; /* extra field length 2 bytes */
|
||||
uLong size_file_comment; /* file comment length 2 bytes */
|
||||
|
||||
uLong disk_num_start; /* disk number start 2 bytes */
|
||||
uLong internal_fa; /* internal file attributes 2 bytes */
|
||||
uLong external_fa; /* external file attributes 4 bytes */
|
||||
|
||||
tm_unz tmu_date;
|
||||
} unz_file_info;
|
||||
|
||||
extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
|
||||
const char* fileName2,
|
||||
int iCaseSensitivity));
|
||||
/*
|
||||
Compare two filename (fileName1,fileName2).
|
||||
If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
|
||||
If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
|
||||
or strcasecmp)
|
||||
If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
|
||||
(like 1 on Unix, 2 on Windows)
|
||||
*/
|
||||
|
||||
|
||||
extern unzFile ZEXPORT unzOpen OF((voidpf file));
|
||||
/*
|
||||
Open a Zip file. path contain whatever zopen_file from the IO API
|
||||
accepts. For Qt implementation it is a pointer to QIODevice, for
|
||||
fopen() implementation it's a file name.
|
||||
If the zipfile cannot be opened (file don't exist or in not valid), the
|
||||
return value is NULL.
|
||||
Else, the return value is a unzFile Handle, usable with other function
|
||||
of this unzip package.
|
||||
*/
|
||||
|
||||
extern unzFile ZEXPORT unzOpen2 OF((voidpf file,
|
||||
zlib_filefunc_def* pzlib_filefunc_def));
|
||||
/*
|
||||
Open a Zip file, like unzOpen, but provide a set of file low level API
|
||||
for read/write the zip file (see ioapi.h)
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzClose OF((unzFile file));
|
||||
/*
|
||||
Close a ZipFile opened with unzipOpen.
|
||||
If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
|
||||
these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
|
||||
return UNZ_OK if there is no problem. */
|
||||
|
||||
extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
|
||||
unz_global_info *pglobal_info));
|
||||
/*
|
||||
Write info about the ZipFile in the *pglobal_info structure.
|
||||
No preparation of the structure is needed
|
||||
return UNZ_OK if there is no problem. */
|
||||
|
||||
|
||||
extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
|
||||
char *szComment,
|
||||
uLong uSizeBuf));
|
||||
/*
|
||||
Get the global comment string of the ZipFile, in the szComment buffer.
|
||||
uSizeBuf is the size of the szComment buffer.
|
||||
return the number of byte copied or an error code <0
|
||||
*/
|
||||
|
||||
|
||||
/***************************************************************************/
|
||||
/* Unzip package allow you browse the directory of the zipfile */
|
||||
|
||||
extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
|
||||
/*
|
||||
Set the current file of the zipfile to the first file.
|
||||
return UNZ_OK if there is no problem
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzGoToNextFile OF((unzFile file));
|
||||
/*
|
||||
Set the current file of the zipfile to the next file.
|
||||
return UNZ_OK if there is no problem
|
||||
return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzLocateFile OF((unzFile file,
|
||||
const char *szFileName,
|
||||
int iCaseSensitivity));
|
||||
/*
|
||||
Try locate the file szFileName in the zipfile.
|
||||
For the iCaseSensitivity signification, see unzStringFileNameCompare
|
||||
|
||||
return value :
|
||||
UNZ_OK if the file is found. It becomes the current file.
|
||||
UNZ_END_OF_LIST_OF_FILE if the file is not found
|
||||
*/
|
||||
|
||||
|
||||
/* ****************************************** */
|
||||
/* Ryan supplied functions */
|
||||
/* unz_file_info contain information about a file in the zipfile */
|
||||
typedef struct unz_file_pos_s
|
||||
{
|
||||
uLong pos_in_zip_directory; /* offset in zip file directory */
|
||||
uLong num_of_file; /* # of file */
|
||||
} unz_file_pos;
|
||||
|
||||
extern int ZEXPORT unzGetFilePos(
|
||||
unzFile file,
|
||||
unz_file_pos* file_pos);
|
||||
|
||||
extern int ZEXPORT unzGoToFilePos(
|
||||
unzFile file,
|
||||
unz_file_pos* file_pos);
|
||||
|
||||
/* ****************************************** */
|
||||
|
||||
extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
|
||||
unz_file_info *pfile_info,
|
||||
char *szFileName,
|
||||
uLong fileNameBufferSize,
|
||||
void *extraField,
|
||||
uLong extraFieldBufferSize,
|
||||
char *szComment,
|
||||
uLong commentBufferSize));
|
||||
/*
|
||||
Get Info about the current file
|
||||
if pfile_info!=NULL, the *pfile_info structure will contain somes info about
|
||||
the current file
|
||||
if szFileName!=NULL, the filemane string will be copied in szFileName
|
||||
(fileNameBufferSize is the size of the buffer)
|
||||
if extraField!=NULL, the extra field information will be copied in extraField
|
||||
(extraFieldBufferSize is the size of the buffer).
|
||||
This is the Central-header version of the extra field
|
||||
if szComment!=NULL, the comment string of the file will be copied in szComment
|
||||
(commentBufferSize is the size of the buffer)
|
||||
*/
|
||||
|
||||
/***************************************************************************/
|
||||
/* for reading the content of the current zipfile, you can open it, read data
|
||||
from it, and close it (you can close it before reading all the file)
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
|
||||
/*
|
||||
Open for reading data the current file in the zipfile.
|
||||
If there is no error, the return value is UNZ_OK.
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
|
||||
const char* password));
|
||||
/*
|
||||
Open for reading data the current file in the zipfile.
|
||||
password is a crypting password
|
||||
If there is no error, the return value is UNZ_OK.
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
|
||||
int* method,
|
||||
int* level,
|
||||
int raw));
|
||||
/*
|
||||
Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
|
||||
if raw==1
|
||||
*method will receive method of compression, *level will receive level of
|
||||
compression
|
||||
note : you can set level parameter as NULL (if you did not want known level,
|
||||
but you CANNOT set method parameter as NULL
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file,
|
||||
int* method,
|
||||
int* level,
|
||||
int raw,
|
||||
const char* password));
|
||||
/*
|
||||
Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
|
||||
if raw==1
|
||||
*method will receive method of compression, *level will receive level of
|
||||
compression
|
||||
note : you can set level parameter as NULL (if you did not want known level,
|
||||
but you CANNOT set method parameter as NULL
|
||||
*/
|
||||
|
||||
|
||||
extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
|
||||
/*
|
||||
Close the file in zip opened with unzOpenCurrentFile
|
||||
Return UNZ_CRCERROR if all the file was read but the CRC is not good
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
|
||||
voidp buf,
|
||||
unsigned len));
|
||||
/*
|
||||
Read bytes from the current file (opened by unzOpenCurrentFile)
|
||||
buf contain buffer where data must be copied
|
||||
len the size of buf.
|
||||
|
||||
return the number of byte copied if somes bytes are copied
|
||||
return 0 if the end of file was reached
|
||||
return <0 with error code if there is an error
|
||||
(UNZ_ERRNO for IO error, or zLib error for uncompress error)
|
||||
*/
|
||||
|
||||
extern z_off_t ZEXPORT unztell OF((unzFile file));
|
||||
/*
|
||||
Give the current position in uncompressed data
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzeof OF((unzFile file));
|
||||
/*
|
||||
return 1 if the end of file was reached, 0 elsewhere
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
|
||||
voidp buf,
|
||||
unsigned len));
|
||||
/*
|
||||
Read extra field from the current file (opened by unzOpenCurrentFile)
|
||||
This is the local-header version of the extra field (sometimes, there is
|
||||
more info in the local-header version than in the central-header)
|
||||
|
||||
if buf==NULL, it return the size of the local extra field
|
||||
|
||||
if buf!=NULL, len is the size of the buffer, the extra header is copied in
|
||||
buf.
|
||||
the return value is the number of bytes copied in buf, or (if <0)
|
||||
the error code
|
||||
*/
|
||||
|
||||
/***************************************************************************/
|
||||
|
||||
/* Get the current file offset */
|
||||
extern uLong ZEXPORT unzGetOffset (unzFile file);
|
||||
|
||||
/* Set the current file offset */
|
||||
extern int ZEXPORT unzSetOffset (unzFile file, uLong pos);
|
||||
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _unz_H */
|
1281
depends/quazip/zip.c
1281
depends/quazip/zip.c
File diff suppressed because it is too large
Load Diff
@ -1,245 +0,0 @@
|
||||
/* zip.h -- IO for compress .zip files using zlib
|
||||
Version 1.01e, February 12th, 2005
|
||||
|
||||
Copyright (C) 1998-2005 Gilles Vollant
|
||||
|
||||
This unzip package allow creates .ZIP file, compatible with PKZip 2.04g
|
||||
WinZip, InfoZip tools and compatible.
|
||||
Multi volume ZipFile (span) are not supported.
|
||||
Encryption compatible with pkzip 2.04g only supported
|
||||
Old compressions used by old PKZip 1.x are not supported
|
||||
|
||||
For uncompress .zip file, look at unzip.h
|
||||
|
||||
|
||||
I WAIT FEEDBACK at mail info@winimage.com
|
||||
Visit also http://www.winimage.com/zLibDll/unzip.html for evolution
|
||||
|
||||
Condition of use and distribution are the same than zlib :
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
|
||||
Modified by Sergey A. Tachenov to integrate with Qt.
|
||||
|
||||
|
||||
*/
|
||||
|
||||
/* for more info about .ZIP format, see
|
||||
http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
|
||||
http://www.info-zip.org/pub/infozip/doc/
|
||||
PkWare has also a specification at :
|
||||
ftp://ftp.pkware.com/probdesc.zip
|
||||
*/
|
||||
|
||||
#ifndef _zip_H
|
||||
#define _zip_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef _ZLIB_H
|
||||
#include "zlib.h"
|
||||
#endif
|
||||
|
||||
#ifndef _ZLIBIOAPI_H
|
||||
#include "ioapi.h"
|
||||
#endif
|
||||
|
||||
#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
|
||||
/* like the STRICT of WIN32, we define a pointer that cannot be converted
|
||||
from (void*) without cast */
|
||||
typedef struct TagzipFile__ { int unused; } zipFile__;
|
||||
typedef zipFile__ *zipFile;
|
||||
#else
|
||||
typedef voidp zipFile;
|
||||
#endif
|
||||
|
||||
#define ZIP_OK (0)
|
||||
#define ZIP_EOF (0)
|
||||
#define ZIP_ERRNO (Z_ERRNO)
|
||||
#define ZIP_PARAMERROR (-102)
|
||||
#define ZIP_BADZIPFILE (-103)
|
||||
#define ZIP_INTERNALERROR (-104)
|
||||
|
||||
#define ZIP_WRITE_DATA_DESCRIPTOR 0x8u
|
||||
|
||||
#ifndef DEF_MEM_LEVEL
|
||||
# if MAX_MEM_LEVEL >= 8
|
||||
# define DEF_MEM_LEVEL 8
|
||||
# else
|
||||
# define DEF_MEM_LEVEL MAX_MEM_LEVEL
|
||||
# endif
|
||||
#endif
|
||||
/* default memLevel */
|
||||
|
||||
/* tm_zip contain date/time info */
|
||||
typedef struct tm_zip_s
|
||||
{
|
||||
uInt tm_sec; /* seconds after the minute - [0,59] */
|
||||
uInt tm_min; /* minutes after the hour - [0,59] */
|
||||
uInt tm_hour; /* hours since midnight - [0,23] */
|
||||
uInt tm_mday; /* day of the month - [1,31] */
|
||||
uInt tm_mon; /* months since January - [0,11] */
|
||||
uInt tm_year; /* years - [1980..2044] */
|
||||
} tm_zip;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
tm_zip tmz_date; /* date in understandable format */
|
||||
uLong dosDate; /* if dos_date == 0, tmu_date is used */
|
||||
/* uLong flag; */ /* general purpose bit flag 2 bytes */
|
||||
|
||||
uLong internal_fa; /* internal file attributes 2 bytes */
|
||||
uLong external_fa; /* external file attributes 4 bytes */
|
||||
} zip_fileinfo;
|
||||
|
||||
typedef const char* zipcharpc;
|
||||
|
||||
|
||||
#define APPEND_STATUS_CREATE (0)
|
||||
#define APPEND_STATUS_CREATEAFTER (1)
|
||||
#define APPEND_STATUS_ADDINZIP (2)
|
||||
|
||||
extern zipFile ZEXPORT zipOpen OF((voidpf file, int append));
|
||||
/*
|
||||
Create a zipfile.
|
||||
file is whatever the IO API accepts. For Qt IO API it's a pointer to
|
||||
QIODevice. For fopen() IO API it's a file name (const char*).
|
||||
if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip
|
||||
will be created at the end of the file.
|
||||
(useful if the file contain a self extractor code)
|
||||
if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will
|
||||
add files in existing zip (be sure you don't add file that doesn't exist)
|
||||
If the zipfile cannot be opened, the return value is NULL.
|
||||
Else, the return value is a zipFile Handle, usable with other function
|
||||
of this zip package.
|
||||
*/
|
||||
|
||||
/* Note : there is no delete function into a zipfile.
|
||||
If you want delete file into a zipfile, you must open a zipfile, and create another
|
||||
Of couse, you can use RAW reading and writing to copy the file you did not want delte
|
||||
*/
|
||||
|
||||
extern zipFile ZEXPORT zipOpen2 OF((voidpf file,
|
||||
int append,
|
||||
zipcharpc* globalcomment,
|
||||
zlib_filefunc_def* pzlib_filefunc_def));
|
||||
|
||||
extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
|
||||
const char* filename,
|
||||
const zip_fileinfo* zipfi,
|
||||
const void* extrafield_local,
|
||||
uInt size_extrafield_local,
|
||||
const void* extrafield_global,
|
||||
uInt size_extrafield_global,
|
||||
const char* comment,
|
||||
int method,
|
||||
int level));
|
||||
/*
|
||||
Open a file in the ZIP for writing.
|
||||
filename : the filename in zip (if NULL, '-' without quote will be used
|
||||
*zipfi contain supplemental information
|
||||
if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
|
||||
contains the extrafield data the the local header
|
||||
if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
|
||||
contains the extrafield data the the local header
|
||||
if comment != NULL, comment contain the comment string
|
||||
method contain the compression method (0 for store, Z_DEFLATED for deflate)
|
||||
level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
|
||||
*/
|
||||
|
||||
|
||||
extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
|
||||
const char* filename,
|
||||
const zip_fileinfo* zipfi,
|
||||
const void* extrafield_local,
|
||||
uInt size_extrafield_local,
|
||||
const void* extrafield_global,
|
||||
uInt size_extrafield_global,
|
||||
const char* comment,
|
||||
int method,
|
||||
int level,
|
||||
int raw));
|
||||
|
||||
/*
|
||||
Same than zipOpenNewFileInZip, except if raw=1, we write raw file
|
||||
*/
|
||||
|
||||
extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
|
||||
const char* filename,
|
||||
const zip_fileinfo* zipfi,
|
||||
const void* extrafield_local,
|
||||
uInt size_extrafield_local,
|
||||
const void* extrafield_global,
|
||||
uInt size_extrafield_global,
|
||||
const char* comment,
|
||||
int method,
|
||||
int level,
|
||||
int raw,
|
||||
int windowBits,
|
||||
int memLevel,
|
||||
int strategy,
|
||||
const char* password,
|
||||
uLong crcForCtypting));
|
||||
|
||||
/*
|
||||
Same than zipOpenNewFileInZip2, except
|
||||
windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
|
||||
password : crypting password (NULL for no crypting)
|
||||
crcForCtypting : crc of file to compress (needed for crypting)
|
||||
*/
|
||||
|
||||
|
||||
extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
|
||||
const void* buf,
|
||||
unsigned len));
|
||||
/*
|
||||
Write data in the zipfile
|
||||
*/
|
||||
|
||||
extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
|
||||
/*
|
||||
Close the current file in the zipfile
|
||||
*/
|
||||
|
||||
extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
|
||||
uLong uncompressed_size,
|
||||
uLong crc32));
|
||||
/*
|
||||
Close the current file in the zipfile, for fiel opened with
|
||||
parameter raw=1 in zipOpenNewFileInZip2
|
||||
uncompressed_size and crc32 are value for the uncompressed size
|
||||
*/
|
||||
|
||||
extern int ZEXPORT zipClose OF((zipFile file,
|
||||
const char* global_comment));
|
||||
/*
|
||||
Close the zipfile
|
||||
*/
|
||||
|
||||
/*
|
||||
Added by Sergey A. Tachenov to tweak zipping behaviour.
|
||||
*/
|
||||
extern int ZEXPORT zipSetFlags(zipFile file, unsigned flags);
|
||||
extern int ZEXPORT zipClearFlags(zipFile file, unsigned flags);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _zip_H */
|
@ -36,6 +36,9 @@
|
||||
#include <QWidgetAction>
|
||||
#include <QProgressDialog>
|
||||
#include <QShortcut>
|
||||
#include <QFileDialog>
|
||||
|
||||
#include <JlCompress.h>
|
||||
|
||||
#include "osutils.h"
|
||||
#include "userutils.h"
|
||||
@ -106,6 +109,7 @@
|
||||
#include <logic/updater/UpdateChecker.h>
|
||||
#include <logic/updater/NotificationChecker.h>
|
||||
#include <logic/tasks/ThreadTask.h>
|
||||
#include "logic/net/CacheDownload.h"
|
||||
|
||||
#include "logic/tools/BaseProfiler.h"
|
||||
|
||||
@ -733,6 +737,25 @@ void MainWindow::setCatBackground(bool enabled)
|
||||
}
|
||||
}
|
||||
|
||||
static QFileInfo findRecursive(const QString &dir, const QString &name)
|
||||
{
|
||||
for (const auto info : QDir(dir).entryInfoList(QDir::NoDotAndDotDot | QDir::Dirs | QDir::Files, QDir::DirsLast))
|
||||
{
|
||||
if (info.isFile() && info.fileName() == name)
|
||||
{
|
||||
return info;
|
||||
}
|
||||
else if (info.isDir())
|
||||
{
|
||||
const QFileInfo res = findRecursive(info.absoluteFilePath(), name);
|
||||
if (res.isFile() && res.exists())
|
||||
{
|
||||
return res;
|
||||
}
|
||||
}
|
||||
}
|
||||
return QFileInfo();
|
||||
}
|
||||
void MainWindow::on_actionAddInstance_triggered()
|
||||
{
|
||||
if (!MMC->minecraftlist()->isLoaded() && m_versionLoadTask &&
|
||||
@ -755,44 +778,103 @@ void MainWindow::on_actionAddInstance_triggered()
|
||||
QString instancesDir = MMC->settings()->get("InstanceDir").toString();
|
||||
QString instDirName = DirNameFromString(newInstDlg.instName(), instancesDir);
|
||||
QString instDir = PathCombine(instancesDir, instDirName);
|
||||
|
||||
auto &loader = InstanceFactory::get();
|
||||
|
||||
auto error = loader.createInstance(newInstance, newInstDlg.selectedVersion(), instDir);
|
||||
QString errorMsg = tr("Failed to create instance %1: ").arg(instDirName);
|
||||
switch (error)
|
||||
const QUrl modpackUrl = newInstDlg.modpackUrl();
|
||||
if (modpackUrl.isValid())
|
||||
{
|
||||
case InstanceFactory::NoCreateError:
|
||||
QString archivePath;
|
||||
if (modpackUrl.isLocalFile())
|
||||
{
|
||||
archivePath = modpackUrl.toLocalFile();
|
||||
}
|
||||
else
|
||||
{
|
||||
const QString path = modpackUrl.host() + '/' + QString::fromUtf8(modpackUrl.toEncoded());
|
||||
auto entry = MMC->metacache()->resolveEntry("general", path);
|
||||
CacheDownloadPtr dl = CacheDownload::make(modpackUrl, entry);
|
||||
NetJob job(tr("Modpack download"));
|
||||
job.addNetAction(dl);
|
||||
|
||||
ProgressDialog dlDialog(this);
|
||||
if (dlDialog.exec(&job) != QDialog::Accepted)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
archivePath = entry->getFullPath();
|
||||
}
|
||||
|
||||
|
||||
QTemporaryDir extractTmpDir;
|
||||
QDir extractDir(extractTmpDir.path());
|
||||
QLOG_INFO() << "Attempting to create instance from" << archivePath;
|
||||
if (JlCompress::extractDir(archivePath, extractDir.absolutePath()).isEmpty())
|
||||
{
|
||||
CustomMessageBox::selectable(this, tr("Error"),
|
||||
tr("Failed to extract modpack"), QMessageBox::Warning)->show();
|
||||
return;
|
||||
}
|
||||
const QFileInfo instanceCfgFile = findRecursive(extractDir.absolutePath(), "instance.cfg");
|
||||
if (!instanceCfgFile.isFile() || !instanceCfgFile.exists())
|
||||
{
|
||||
CustomMessageBox::selectable(this, tr("Error"), tr("Archive does not contain instance.cfg"))->show();
|
||||
return;
|
||||
}
|
||||
if (!copyPath(instanceCfgFile.absoluteDir().absolutePath(), instDir))
|
||||
{
|
||||
CustomMessageBox::selectable(this, tr("Error"), tr("Unable to copy instance"))->show();
|
||||
return;
|
||||
}
|
||||
|
||||
auto error = loader.loadInstance(newInstance, instDir);
|
||||
QString errorMsg = tr("Failed to load instance %1: ").arg(instDirName);
|
||||
switch (error)
|
||||
{
|
||||
case InstanceFactory::UnknownLoadError:
|
||||
errorMsg += tr("Unkown error");
|
||||
CustomMessageBox::selectable(this, tr("Error"), errorMsg, QMessageBox::Warning)->show();
|
||||
return;
|
||||
case InstanceFactory::NotAnInstance:
|
||||
errorMsg += tr("Not an instance");
|
||||
CustomMessageBox::selectable(this, tr("Error"), errorMsg, QMessageBox::Warning)->show();
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
newInstance->setName(newInstDlg.instName());
|
||||
newInstance->setIconKey(newInstDlg.iconKey());
|
||||
newInstance->setGroupInitial(newInstDlg.instGroup());
|
||||
MMC->instances()->add(InstancePtr(newInstance));
|
||||
stringToIntList(MMC->settings()->get("ShownNotifications").toString());
|
||||
break;
|
||||
auto error = loader.createInstance(newInstance, newInstDlg.selectedVersion(), instDir);
|
||||
QString errorMsg = tr("Failed to create instance %1: ").arg(instDirName);
|
||||
switch (error)
|
||||
{
|
||||
case InstanceFactory::NoCreateError: break;
|
||||
case InstanceFactory::InstExists:
|
||||
{
|
||||
errorMsg += tr("An instance with the given directory name already exists.");
|
||||
CustomMessageBox::selectable(this, tr("Error"), errorMsg, QMessageBox::Warning)->show();
|
||||
return;
|
||||
}
|
||||
|
||||
case InstanceFactory::CantCreateDir:
|
||||
{
|
||||
errorMsg += tr("Failed to create the instance directory.");
|
||||
CustomMessageBox::selectable(this, tr("Error"), errorMsg, QMessageBox::Warning)->show();
|
||||
return;
|
||||
}
|
||||
|
||||
default:
|
||||
{
|
||||
errorMsg += tr("Unknown instance loader error %1").arg(error);
|
||||
CustomMessageBox::selectable(this, tr("Error"), errorMsg, QMessageBox::Warning)->show();
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
case InstanceFactory::InstExists:
|
||||
{
|
||||
errorMsg += tr("An instance with the given directory name already exists.");
|
||||
CustomMessageBox::selectable(this, tr("Error"), errorMsg, QMessageBox::Warning)->show();
|
||||
return;
|
||||
}
|
||||
|
||||
case InstanceFactory::CantCreateDir:
|
||||
{
|
||||
errorMsg += tr("Failed to create the instance directory.");
|
||||
CustomMessageBox::selectable(this, tr("Error"), errorMsg, QMessageBox::Warning)->show();
|
||||
return;
|
||||
}
|
||||
|
||||
default:
|
||||
{
|
||||
errorMsg += tr("Unknown instance loader error %1").arg(error);
|
||||
CustomMessageBox::selectable(this, tr("Error"), errorMsg, QMessageBox::Warning)->show();
|
||||
return;
|
||||
}
|
||||
}
|
||||
newInstance->setName(newInstDlg.instName());
|
||||
newInstance->setIconKey(newInstDlg.iconKey());
|
||||
newInstance->setGroupInitial(newInstDlg.instGroup());
|
||||
MMC->instances()->add(InstancePtr(newInstance));
|
||||
|
||||
if (MMC->accounts()->anyAccountIsValid())
|
||||
{
|
||||
@ -1056,6 +1138,33 @@ void MainWindow::on_actionDeleteInstance_triggered()
|
||||
}
|
||||
}
|
||||
|
||||
void MainWindow::on_actionExportInstance_triggered()
|
||||
{
|
||||
if (m_selectedInstance)
|
||||
{
|
||||
const QString output = QFileDialog::getSaveFileName(this, tr("Export %1")
|
||||
.arg(m_selectedInstance->name()),
|
||||
QDir::homePath(), "Zip (*.zip)");
|
||||
if (output.isNull())
|
||||
{
|
||||
return;
|
||||
}
|
||||
if (QFile::exists(output))
|
||||
{
|
||||
int ret = QMessageBox::question(this, tr("Overwrite?"), tr("This file already exists. Do you want to overwrite it?"),
|
||||
QMessageBox::No, QMessageBox::Yes);
|
||||
if (ret == QMessageBox::No)
|
||||
{
|
||||
return;
|
||||
}
|
||||
}
|
||||
if (!JlCompress::compressDir(output, m_selectedInstance->instanceRoot()))
|
||||
{
|
||||
QMessageBox::warning(this, tr("Error"), tr("Unable to export instance"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MainWindow::on_actionRenameInstance_triggered()
|
||||
{
|
||||
if (m_selectedInstance)
|
||||
|
@ -104,6 +104,8 @@ slots:
|
||||
|
||||
void on_actionDeleteInstance_triggered();
|
||||
|
||||
void on_actionExportInstance_triggered();
|
||||
|
||||
void on_actionRenameInstance_triggered();
|
||||
|
||||
void on_actionEditInstance_triggered();
|
||||
|
@ -118,6 +118,7 @@
|
||||
<addaction name="actionViewSelectedInstFolder"/>
|
||||
<addaction name="actionConfig_Folder"/>
|
||||
<addaction name="separator"/>
|
||||
<addaction name="actionExportInstance"/>
|
||||
<addaction name="actionDeleteInstance"/>
|
||||
</widget>
|
||||
<widget class="QToolBar" name="newsToolBar">
|
||||
@ -495,6 +496,11 @@
|
||||
<string>Change the settings specific to the instance</string>
|
||||
</property>
|
||||
</action>
|
||||
<action name="actionExportInstance">
|
||||
<property name="text">
|
||||
<string>Export Instance</string>
|
||||
</property>
|
||||
</action>
|
||||
</widget>
|
||||
<layoutdefault spacing="6" margin="11"/>
|
||||
<resources>
|
||||
|
@ -22,7 +22,7 @@
|
||||
#include "logic/icons/IconList.h"
|
||||
#include "logic/minecraft/MinecraftVersionList.h"
|
||||
#include "logic/tasks/Task.h"
|
||||
#include <logic/InstanceList.h>
|
||||
#include "logic/InstanceList.h"
|
||||
|
||||
#include "gui/Platform.h"
|
||||
#include "VersionSelectDialog.h"
|
||||
@ -31,6 +31,31 @@
|
||||
|
||||
#include <QLayout>
|
||||
#include <QPushButton>
|
||||
#include <QFileDialog>
|
||||
#include <QValidator>
|
||||
|
||||
class UrlValidator : public QValidator
|
||||
{
|
||||
public:
|
||||
using QValidator::QValidator;
|
||||
|
||||
State validate(QString &in, int &pos) const
|
||||
{
|
||||
const QUrl url(in);
|
||||
if (url.isValid() && !url.isRelative() && !url.isEmpty())
|
||||
{
|
||||
return Acceptable;
|
||||
}
|
||||
else if (QFile::exists(in))
|
||||
{
|
||||
return Acceptable;
|
||||
}
|
||||
else
|
||||
{
|
||||
return Intermediate;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
NewInstanceDialog::NewInstanceDialog(QWidget *parent)
|
||||
: QDialog(parent), ui(new Ui::NewInstanceDialog)
|
||||
@ -39,9 +64,16 @@ NewInstanceDialog::NewInstanceDialog(QWidget *parent)
|
||||
ui->setupUi(this);
|
||||
resize(minimumSizeHint());
|
||||
layout()->setSizeConstraint(QLayout::SetFixedSize);
|
||||
|
||||
setSelectedVersion(MMC->minecraftlist()->getLatestStable(), true);
|
||||
InstIconKey = "infinity";
|
||||
ui->iconButton->setIcon(MMC->icons()->getIcon(InstIconKey));
|
||||
|
||||
ui->modpackEdit->setValidator(new UrlValidator(ui->modpackEdit));
|
||||
connect(ui->modpackEdit, &QLineEdit::textChanged, this, &NewInstanceDialog::updateDialogState);
|
||||
connect(ui->modpackBox, &QRadioButton::clicked, this, &NewInstanceDialog::updateDialogState);
|
||||
connect(ui->versionBox, &QRadioButton::clicked, this, &NewInstanceDialog::updateDialogState);
|
||||
|
||||
auto groups = MMC->instances()->getGroups().toSet();
|
||||
auto groupList = QStringList(groups.toList());
|
||||
groupList.sort(Qt::CaseInsensitive);
|
||||
@ -67,7 +99,10 @@ NewInstanceDialog::~NewInstanceDialog()
|
||||
void NewInstanceDialog::updateDialogState()
|
||||
{
|
||||
ui->buttonBox->button(QDialogButtonBox::Ok)
|
||||
->setEnabled(!instName().isEmpty() && m_selectedVersion);
|
||||
->setEnabled(!instName().isEmpty()
|
||||
&& m_selectedVersion
|
||||
&& (!ui->modpackBox->isChecked()
|
||||
|| ui->modpackEdit->hasAcceptableInput()));
|
||||
}
|
||||
|
||||
void NewInstanceDialog::setSelectedVersion(BaseVersionPtr version, bool initial)
|
||||
@ -94,16 +129,33 @@ QString NewInstanceDialog::instName() const
|
||||
{
|
||||
return ui->instNameTextBox->text();
|
||||
}
|
||||
|
||||
QString NewInstanceDialog::instGroup() const
|
||||
{
|
||||
return ui->groupBox->currentText();
|
||||
}
|
||||
|
||||
QString NewInstanceDialog::iconKey() const
|
||||
{
|
||||
return InstIconKey;
|
||||
}
|
||||
QUrl NewInstanceDialog::modpackUrl() const
|
||||
{
|
||||
if (ui->modpackBox->isChecked())
|
||||
{
|
||||
const QUrl url(ui->modpackEdit->text());
|
||||
if (url.isValid() && !url.isRelative() && !url.host().isEmpty())
|
||||
{
|
||||
return url;
|
||||
}
|
||||
else
|
||||
{
|
||||
return QUrl::fromLocalFile(ui->modpackEdit->text());
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
return QUrl();
|
||||
}
|
||||
}
|
||||
|
||||
BaseVersionPtr NewInstanceDialog::selectedVersion() const
|
||||
{
|
||||
@ -140,3 +192,18 @@ void NewInstanceDialog::on_instNameTextBox_textChanged(const QString &arg1)
|
||||
updateDialogState();
|
||||
}
|
||||
|
||||
void NewInstanceDialog::on_modpackBtn_clicked()
|
||||
{
|
||||
const QUrl url = QFileDialog::getOpenFileUrl(this, tr("Choose modpack"), modpackUrl(), tr("Zip (*.zip)"));
|
||||
if (url.isValid())
|
||||
{
|
||||
if (url.isLocalFile())
|
||||
{
|
||||
ui->modpackEdit->setText(url.toLocalFile());
|
||||
}
|
||||
else
|
||||
{
|
||||
ui->modpackEdit->setText(url.toString());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -41,12 +41,14 @@ public:
|
||||
QString instName() const;
|
||||
QString instGroup() const;
|
||||
QString iconKey() const;
|
||||
QUrl modpackUrl() const;
|
||||
BaseVersionPtr selectedVersion() const;
|
||||
|
||||
private
|
||||
slots:
|
||||
void on_btnChangeVersion_clicked();
|
||||
void on_iconButton_clicked();
|
||||
void on_modpackBtn_clicked();
|
||||
void on_instNameTextBox_textChanged(const QString &arg1);
|
||||
|
||||
private:
|
||||
|
@ -10,7 +10,7 @@
|
||||
<x>0</x>
|
||||
<y>0</y>
|
||||
<width>345</width>
|
||||
<height>261</height>
|
||||
<height>343</height>
|
||||
</rect>
|
||||
</property>
|
||||
<property name="windowTitle">
|
||||
@ -84,41 +84,24 @@
|
||||
</item>
|
||||
<item>
|
||||
<layout class="QGridLayout" name="gridLayout">
|
||||
<item row="0" column="2">
|
||||
<item row="1" column="2">
|
||||
<widget class="QToolButton" name="btnChangeVersion">
|
||||
<property name="text">
|
||||
<string>...</string>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item row="0" column="1">
|
||||
<widget class="QLineEdit" name="versionTextBox">
|
||||
<property name="readOnly">
|
||||
<bool>true</bool>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item row="0" column="0">
|
||||
<widget class="QLabel" name="labelVersion">
|
||||
<property name="text">
|
||||
<string>Version:</string>
|
||||
</property>
|
||||
<property name="buddy">
|
||||
<cstring>versionTextBox</cstring>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item row="1" column="0">
|
||||
<widget class="QLabel" name="labelVersion_3">
|
||||
<property name="text">
|
||||
<string>Group:</string>
|
||||
<string>&Group:</string>
|
||||
</property>
|
||||
<property name="buddy">
|
||||
<cstring>groupBox</cstring>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item row="1" column="1" colspan="2">
|
||||
<item row="0" column="1" colspan="2">
|
||||
<widget class="QComboBox" name="groupBox">
|
||||
<property name="sizePolicy">
|
||||
<sizepolicy hsizetype="Expanding" vsizetype="Fixed">
|
||||
@ -131,6 +114,50 @@
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item row="2" column="1">
|
||||
<widget class="QLineEdit" name="modpackEdit">
|
||||
<property name="enabled">
|
||||
<bool>false</bool>
|
||||
</property>
|
||||
<property name="text">
|
||||
<string>http://</string>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item row="2" column="2">
|
||||
<widget class="QToolButton" name="modpackBtn">
|
||||
<property name="enabled">
|
||||
<bool>false</bool>
|
||||
</property>
|
||||
<property name="text">
|
||||
<string>...</string>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item row="1" column="0">
|
||||
<widget class="QRadioButton" name="versionBox">
|
||||
<property name="text">
|
||||
<string>&Version:</string>
|
||||
</property>
|
||||
<property name="checked">
|
||||
<bool>true</bool>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item row="2" column="0">
|
||||
<widget class="QRadioButton" name="modpackBox">
|
||||
<property name="text">
|
||||
<string>Import &Modpack:</string>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
<item row="1" column="1">
|
||||
<widget class="QLineEdit" name="versionTextBox">
|
||||
<property name="readOnly">
|
||||
<bool>true</bool>
|
||||
</property>
|
||||
</widget>
|
||||
</item>
|
||||
</layout>
|
||||
</item>
|
||||
<item>
|
||||
@ -176,8 +203,8 @@
|
||||
<slot>accept()</slot>
|
||||
<hints>
|
||||
<hint type="sourcelabel">
|
||||
<x>248</x>
|
||||
<y>254</y>
|
||||
<x>257</x>
|
||||
<y>333</y>
|
||||
</hint>
|
||||
<hint type="destinationlabel">
|
||||
<x>157</x>
|
||||
@ -192,8 +219,8 @@
|
||||
<slot>reject()</slot>
|
||||
<hints>
|
||||
<hint type="sourcelabel">
|
||||
<x>316</x>
|
||||
<y>260</y>
|
||||
<x>325</x>
|
||||
<y>333</y>
|
||||
</hint>
|
||||
<hint type="destinationlabel">
|
||||
<x>286</x>
|
||||
@ -201,5 +228,69 @@
|
||||
</hint>
|
||||
</hints>
|
||||
</connection>
|
||||
<connection>
|
||||
<sender>modpackBox</sender>
|
||||
<signal>toggled(bool)</signal>
|
||||
<receiver>modpackEdit</receiver>
|
||||
<slot>setEnabled(bool)</slot>
|
||||
<hints>
|
||||
<hint type="sourcelabel">
|
||||
<x>81</x>
|
||||
<y>229</y>
|
||||
</hint>
|
||||
<hint type="destinationlabel">
|
||||
<x>236</x>
|
||||
<y>221</y>
|
||||
</hint>
|
||||
</hints>
|
||||
</connection>
|
||||
<connection>
|
||||
<sender>modpackBox</sender>
|
||||
<signal>toggled(bool)</signal>
|
||||
<receiver>modpackBtn</receiver>
|
||||
<slot>setEnabled(bool)</slot>
|
||||
<hints>
|
||||
<hint type="sourcelabel">
|
||||
<x>129</x>
|
||||
<y>225</y>
|
||||
</hint>
|
||||
<hint type="destinationlabel">
|
||||
<x>328</x>
|
||||
<y>229</y>
|
||||
</hint>
|
||||
</hints>
|
||||
</connection>
|
||||
<connection>
|
||||
<sender>versionBox</sender>
|
||||
<signal>toggled(bool)</signal>
|
||||
<receiver>versionTextBox</receiver>
|
||||
<slot>setEnabled(bool)</slot>
|
||||
<hints>
|
||||
<hint type="sourcelabel">
|
||||
<x>93</x>
|
||||
<y>195</y>
|
||||
</hint>
|
||||
<hint type="destinationlabel">
|
||||
<x>213</x>
|
||||
<y>191</y>
|
||||
</hint>
|
||||
</hints>
|
||||
</connection>
|
||||
<connection>
|
||||
<sender>versionBox</sender>
|
||||
<signal>toggled(bool)</signal>
|
||||
<receiver>btnChangeVersion</receiver>
|
||||
<slot>setEnabled(bool)</slot>
|
||||
<hints>
|
||||
<hint type="sourcelabel">
|
||||
<x>104</x>
|
||||
<y>198</y>
|
||||
</hint>
|
||||
<hint type="destinationlabel">
|
||||
<x>322</x>
|
||||
<y>192</y>
|
||||
</hint>
|
||||
</hints>
|
||||
</connection>
|
||||
</connections>
|
||||
</ui>
|
||||
|
188
quazip.patch
Normal file
188
quazip.patch
Normal file
@ -0,0 +1,188 @@
|
||||
Index: CMakeLists.txt
|
||||
===================================================================
|
||||
--- CMakeLists.txt (revision 250)
|
||||
+++ CMakeLists.txt (working copy)
|
||||
@@ -51,4 +51,4 @@
|
||||
|
||||
add_subdirectory(quazip)
|
||||
|
||||
-install(FILES FindQuaZip.cmake DESTINATION ${CMAKE_ROOT}/Modules)
|
||||
+#install(FILES FindQuaZip.cmake DESTINATION ${CMAKE_ROOT}/Modules)
|
||||
Index: quazip/CMakeLists.txt
|
||||
===================================================================
|
||||
--- quazip/CMakeLists.txt (revision 250)
|
||||
+++ quazip/CMakeLists.txt (working copy)
|
||||
@@ -14,10 +14,11 @@
|
||||
qt_wrap_cpp(MOC_SRCS ${PUBLIC_HEADERS})
|
||||
set(SRCS ${SRCS} ${MOC_SRCS})
|
||||
|
||||
-add_library(quazip SHARED ${SRCS})
|
||||
-set_target_properties(quazip PROPERTIES VERSION 1.0.0 SOVERSION 1)
|
||||
+add_library(quazip STATIC ${SRCS})
|
||||
+#set_target_properties(quazip PROPERTIES VERSION 1.0.0 SOVERSION 1)
|
||||
# Link against ZLIB_LIBRARIES if needed (on Windows this variable is empty)
|
||||
-target_link_libraries(quazip ${QT_QTMAIN_LIBRARY} ${QT_QTCORE_LIBRARY} ${ZLIB_LIBRARIES})
|
||||
+target_link_libraries(quazip ${ZLIB_LIBRARIES})
|
||||
+qt5_use_modules(quazip Core)
|
||||
|
||||
install(FILES ${PUBLIC_HEADERS} DESTINATION include/quazip)
|
||||
install(TARGETS quazip LIBRARY DESTINATION ${LIB_DESTINATION} ARCHIVE DESTINATION ${LIB_DESTINATION} RUNTIME DESTINATION ${LIB_DESTINATION})
|
||||
Index: quazip/JlCompress.cpp
|
||||
===================================================================
|
||||
--- quazip/JlCompress.cpp (revision 250)
|
||||
+++ quazip/JlCompress.cpp (working copy)
|
||||
@@ -26,7 +26,7 @@
|
||||
#include "JlCompress.h"
|
||||
#include <QDebug>
|
||||
|
||||
-static bool copyData(QIODevice &inFile, QIODevice &outFile)
|
||||
+bool JlCompress::copyData(QIODevice &inFile, QIODevice &outFile)
|
||||
{
|
||||
while (!inFile.atEnd()) {
|
||||
char buf[4096];
|
||||
@@ -100,7 +100,7 @@
|
||||
* dunque gli errori di compressione di una sotto cartella sono gli stessi di questa
|
||||
* funzione.
|
||||
*/
|
||||
-bool JlCompress::compressSubDir(QuaZip* zip, QString dir, QString origDir, bool recursive) {
|
||||
+bool JlCompress::compressSubDir(QuaZip* zip, QString dir, QString origDir, bool recursive, QSet<QString>& added) {
|
||||
// zip: oggetto dove aggiungere il file
|
||||
// dir: cartella reale corrente
|
||||
// origDir: cartella reale originale
|
||||
@@ -133,7 +133,7 @@
|
||||
QFileInfoList files = directory.entryInfoList(QDir::AllDirs|QDir::NoDotAndDotDot);
|
||||
Q_FOREACH (QFileInfo file, files) {
|
||||
// Comprimo la sotto cartella
|
||||
- if(!compressSubDir(zip,file.absoluteFilePath(),origDir,recursive)) return false;
|
||||
+ if(!compressSubDir(zip,file.absoluteFilePath(),origDir,recursive,added)) return false;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -148,6 +148,7 @@
|
||||
|
||||
// Comprimo il file
|
||||
if (!compressFile(zip,file.absoluteFilePath(),filename)) return false;
|
||||
+ added.insert(filename);
|
||||
}
|
||||
|
||||
return true;
|
||||
@@ -344,8 +345,9 @@
|
||||
return false;
|
||||
}
|
||||
|
||||
+ QSet<QString> added;
|
||||
// Aggiungo i file e le sotto cartelle
|
||||
- if (!compressSubDir(&zip,dir,dir,recursive)) {
|
||||
+ if (!compressSubDir(&zip,dir,dir,recursive,added)) {
|
||||
QFile::remove(fileCompressed);
|
||||
return false;
|
||||
}
|
||||
@@ -437,6 +439,53 @@
|
||||
return extracted;
|
||||
}
|
||||
|
||||
+QStringList JlCompress::extractWithExceptions(QString fileCompressed, QString dir, QStringList exceptions)
|
||||
+{
|
||||
+ QuaZip zip(fileCompressed);
|
||||
+ if(!zip.open(QuaZip::mdUnzip))
|
||||
+ {
|
||||
+ return QStringList();
|
||||
+ }
|
||||
+
|
||||
+ QDir directory(dir);
|
||||
+ QStringList extracted;
|
||||
+ if (!zip.goToFirstFile())
|
||||
+ {
|
||||
+ return QStringList();
|
||||
+ }
|
||||
+ do
|
||||
+ {
|
||||
+ QString name = zip.getCurrentFileName();
|
||||
+ bool ok = true;
|
||||
+ for(auto str: exceptions)
|
||||
+ {
|
||||
+ if(name.startsWith(str))
|
||||
+ {
|
||||
+ ok = false;
|
||||
+ break;
|
||||
+ }
|
||||
+ }
|
||||
+ if(!ok)
|
||||
+ continue;
|
||||
+ QString absFilePath = directory.absoluteFilePath(name);
|
||||
+ if (!JlCompress::extractFile(&zip, "", absFilePath))
|
||||
+ {
|
||||
+ JlCompress::removeFile(extracted);
|
||||
+ return QStringList();
|
||||
+ }
|
||||
+ extracted.append(absFilePath);
|
||||
+ } while (zip.goToNextFile());
|
||||
+
|
||||
+ zip.close();
|
||||
+ if(zip.getZipError()!=0)
|
||||
+ {
|
||||
+ JlCompress::removeFile(extracted);
|
||||
+ return QStringList();
|
||||
+ }
|
||||
+
|
||||
+ return extracted;
|
||||
+}
|
||||
+
|
||||
/**OK
|
||||
* Estrae il file fileCompressed nella cartella dir.
|
||||
* Se dir = "" allora il file viene estratto nella cartella corrente.
|
||||
Index: quazip/JlCompress.h
|
||||
===================================================================
|
||||
--- quazip/JlCompress.h (revision 250)
|
||||
+++ quazip/JlCompress.h (working copy)
|
||||
@@ -40,7 +40,7 @@
|
||||
simple operations, such as mass ZIP packing or extraction.
|
||||
*/
|
||||
class QUAZIP_EXPORT JlCompress {
|
||||
-private:
|
||||
+public:
|
||||
/// Compress a single file.
|
||||
/**
|
||||
\param zip Opened zip to compress the file to.
|
||||
@@ -59,7 +59,7 @@
|
||||
files.
|
||||
\return true if success, false otherwise.
|
||||
*/
|
||||
- static bool compressSubDir(QuaZip* parentZip, QString dir, QString parentDir, bool recursive = true);
|
||||
+ static bool compressSubDir(QuaZip* parentZip, QString dir, QString parentDir, bool recursive, QSet<QString>& added);
|
||||
/// Extract a single file.
|
||||
/**
|
||||
\param zip The opened zip archive to extract from.
|
||||
@@ -68,6 +68,7 @@
|
||||
\return true if success, false otherwise.
|
||||
*/
|
||||
static bool extractFile(QuaZip* zip, QString fileName, QString fileDest);
|
||||
+private:
|
||||
/// Remove some files.
|
||||
/**
|
||||
\param listFile The list of files to remove.
|
||||
@@ -76,6 +77,8 @@
|
||||
static bool removeFile(QStringList listFile);
|
||||
|
||||
public:
|
||||
+ /// copy data from inFile to outFile
|
||||
+ static bool copyData(QIODevice &inFile, QIODevice &outFile);
|
||||
/// Compress a single file.
|
||||
/**
|
||||
\param fileCompressed The name of the archive.
|
||||
@@ -127,6 +130,15 @@
|
||||
\return The list of the full paths of the files extracted, empty on failure.
|
||||
*/
|
||||
static QStringList extractDir(QString fileCompressed, QString dir = QString());
|
||||
+ /// Extract a whole archive, with a list of exceptions (prefixes to ignore).
|
||||
+ /**
|
||||
+ \param fileCompressed The name of the archive.
|
||||
+ \param dir The directory to extract to, the current directory if
|
||||
+ left empty.
|
||||
+ \param exceptions The list of exception prefixes
|
||||
+ \return The list of the full paths of the files extracted, empty on failure.
|
||||
+ */
|
||||
+ static QStringList extractWithExceptions(QString fileCompressed, QString dir, QStringList exceptions);
|
||||
/// Get the file list.
|
||||
/**
|
||||
\return The list of the files in the archive, or, more precisely, the
|
Loading…
Reference in New Issue
Block a user