generic: port to the new KCompressor and KDecompressor classes

Signed-off-by: Ivailo Monev <xakepa10@gmail.com>

diff --git a/ark/plugins/libsinglefileplugin/singlefileplugin.cpp b/ark/plugins/libsinglefileplugin/singlefileplugin.cpp
index 64f4b93..dabdab2 100644 (file)
--- a/ark/plugins/libsinglefileplugin/singlefileplugin.cpp
+++ b/ark/plugins/libsinglefileplugin/singlefileplugin.cpp
@@ -33,7 +33,8 @@
 #include <QString>
 
 #include <KDebug>
-#include <KFilterDev>
+#include <KCompressor>
+#include <KDecompressor>
 #include <KLocale>
 
 LibSingleFileInterface::LibSingleFileInterface(QObject *parent, const QVariantList & args)
@@ -45,11 +46,12 @@ LibSingleFileInterface::~LibSingleFileInterface()
 {
 }
 
-bool LibSingleFileInterface::copyFiles(const QList<QVariant> & files, const QString & destinationDirectory, Kerfuffle::ExtractionOptions options)
+bool LibSingleFileInterface::copyFiles(const QList<QVariant> &files, const QString &destinationDirectory, Kerfuffle::ExtractionOptions options)
 {
     Q_UNUSED(files)
     Q_UNUSED(options)
 
+    const QString inputfile = filename();
     QString outputFileName = destinationDirectory;
     if (!destinationDirectory.endsWith(QLatin1Char('/'))) {
         outputFileName += QLatin1Char('/');
@@ -63,41 +65,43 @@ bool LibSingleFileInterface::copyFiles(const QList<QVariant> & files, const QStr
 
     kDebug() << "Extracting to" << outputFileName;
 
-    QFile outputFile(outputFileName);
-    if (!outputFile.open(QIODevice::WriteOnly)) {
-        kDebug() << "Failed to open output file" << outputFile.errorString();
-        emit error(i18nc("@info", "Ark could not extract <filename>%1</filename>.", outputFile.fileName()));
+    KDecompressor kdecompressor;
+    if (!kdecompressor.setType(KDecompressor::typeForMime(m_mimeType))
+        && !kdecompressor.setType(KDecompressor::typeForFile(filename()))) {
+        kDebug() << "Could not set KDecompressor type";
+        emit error(i18nc("@info", "Ark could not open <filename>%1</filename> for extraction.", filename()));
 
         return false;
     }
 
-    QIODevice *device = KFilterDev::deviceForFile(filename(), m_mimeType, false);
-    if (!device) {
-        kDebug() << "Could not create KFilterDev";
-        emit error(i18nc("@info", "Ark could not open <filename>%1</filename> for extraction.", filename()));
-
+    QFile inputdevice(inputfile);
+    if (!inputdevice.open(QFile::ReadOnly)) {
+        kDebug() << "Could not open input file";
+        emit error(i18n("Ark could not open <filename>%1</filename> for reading.", inputfile));
         return false;
     }
 
-    device->open(QIODevice::ReadOnly);
-
-    qint64 bytesRead;
-    QByteArray dataChunk(1024*16, '\0');   // 16Kb
+    if (!kdecompressor.process(inputdevice.readAll())) {
+        kDebug() << "Could not process input";
+        emit error(i18n("Ark could not process <filename>%1</filename>.", inputfile));
+        return false;
+    }
 
-    while (true) {
-        bytesRead = device->read(dataChunk.data(), dataChunk.size());
+    QFile outputdevice(outputFileName);
+    if (!outputdevice.open(QIODevice::WriteOnly)) {
+        kDebug() << "Failed to open output file" << outputdevice.errorString();
+        emit error(i18nc("@info", "Ark could not open <filename>%1</filename> for writing.", outputFileName));
 
-        if (bytesRead == -1) {
-            emit error(i18nc("@info", "There was an error while reading <filename>%1</filename> during extraction.", filename()));
-            break;
-        } else if (bytesRead == 0) {
-            break;
-        }
-
-        outputFile.write(dataChunk.data(), bytesRead);
+        return false;
     }
 
-    delete device;
+    const QByteArray decompressed = kdecompressor.result();
+    if (outputdevice.write(decompressed.constData(), decompressed.size()) != decompressed.size()) {
+        kDebug() << "Could not write output file";
+        emit error(i18n("Ark could not write <filename>%1</filename>.", outputFileName));
+        QFile::remove(outputFileName); // in case of partial write
+        return false;
+    }
 
     return true;
 }
@@ -172,34 +176,40 @@ bool LibSingleFileInterface::addFiles(const QStringList & files, const Kerfuffle
     const QString inputfile = files.first();
     const QString outputfile = filename();
 
+    KCompressor kcompressor;
+    if (!kcompressor.setType(KCompressor::typeForFile(outputfile))) {
+        kDebug() << "Could not set KCompressor type";
+        emit error(i18n("Ark could not create filter."));
+        return false;
+    }
+
     QFile inputdevice(inputfile);
     if (!inputdevice.open(QFile::ReadOnly)) {
-        kDebug() << "Could not create QFile";
+        kDebug() << "Could not open input file";
         emit error(i18n("Ark could not open <filename>%1</filename> for reading.", inputfile));
         return false;
     }
 
-    QIODevice *device = KFilterDev::deviceForFile(outputfile);
-    if (!device) {
-        kDebug() << "Could not create KFilterDev";
-        emit error(i18n("Ark could not create filter."));
+    if (!kcompressor.process(inputdevice.readAll())) {
+        kDebug() << "Could not process input";
+        emit error(i18n("Ark could not process <filename>%1</filename>.", inputfile));
         return false;
     }
 
-    if (!device->open(QIODevice::WriteOnly)) {
-        kDebug() << "Could not open KFilterDev";
+    QFile outputdevice(outputfile);
+    if (!outputdevice.open(QFile::WriteOnly)) {
+        kDebug() << "Could not open output file";
         emit error(i18n("Ark could not open <filename>%1</filename> for writing.", outputfile));
         return false;
     }
 
-    const QByteArray inputdata = inputdevice.readAll();
-    if (device->write(inputdata) != inputdata.size()) {
-        kDebug() << "Could not write output";
+    const QByteArray compressed = kcompressor.result();
+    if (outputdevice.write(compressed.constData(), compressed.size()) != compressed.size()) {
+        kDebug() << "Could not write output file";
         emit error(i18n("Ark could not write <filename>%1</filename>.", outputfile));
         QFile::remove(outputfile); // in case of partial write
         return false;
     }
-    device->close();
 
     return true;
 }

diff --git a/kdeplasma-addons/applets/weatherstation/lcd.cpp b/kdeplasma-addons/applets/weatherstation/lcd.cpp
index 7d4743e..89655f1 100644 (file)
--- a/kdeplasma-addons/applets/weatherstation/lcd.cpp
+++ b/kdeplasma-addons/applets/weatherstation/lcd.cpp
@@ -26,7 +26,7 @@
 #include <QtXml/qdom.h>
 #include <QCursor>
 #include <KDebug>
-#include <KFilterDev>
+#include <KDecompressor>
 #include <Plasma/Theme>
 #include <Plasma/Svg>
 
@@ -178,9 +178,14 @@ class LCD::Private
 
         void parseXml()
         {
-            QIODevice *device = KFilterDev::deviceForFile(content, "application/x-gzip");
+            KDecompressor kdecompressor;
+            if (!kdecompressor.setType(KDecompressor::TypeGZip)
+                || !kdecompressor.process(content.toAscii())) {
+                kWarning() << "Could not decompress content" << kdecompressor.errorString();
+                return;
+            }
 
-            doc.setContent(device);
+            doc.setContent(kdecompressor.result());
             QList<QDomNodeList> lists;
             int pos;
             lists << doc.elementsByTagName("g");
@@ -209,7 +214,6 @@ class LCD::Private
             }
 
             //kDebug() << groups;
-            delete device;
         }
 };
 

diff --git a/ksystemlog/src/lib/localLogFileReader.cpp b/ksystemlog/src/lib/localLogFileReader.cpp
index 8a65cc1..bbf6946 100644 (file)
--- a/ksystemlog/src/lib/localLogFileReader.cpp
+++ b/ksystemlog/src/lib/localLogFileReader.cpp
@@ -22,11 +22,12 @@
 #include "localLogFileReader.h"
 
 #include <QMutex>
+#include <QBuffer>
 #include <QFile>
 
 #include <kdirwatch.h>
 #include <klocale.h>
-#include <kfilterdev.h>
+#include <kdecompressor.h>
 #include <kmimetype.h>
 #include <kurl.h>
 
@@ -143,14 +144,33 @@ QIODevice* LocalLogFileReader::open() {
        else {
                logDebug() << "Using KFilterDev input device" << endl;
 
-               inputDevice = KFilterDev::deviceForFile(d->logFile.url().path(), mimeType);
+               const QString logFilePath = d->logFile.url().path();
+               KDecompressor kdecompressor;
+               if (!kdecompressor.setType(KDecompressor::typeForMime(mimeType))
+                   && !kdecompressor.setType(KDecompressor::typeForFile(logFilePath))) {
+                       QString message(i18n("Compressed file format is not supported '%1'.", logFilePath));
+                       emit errorOccured(i18n("Unable to open Compressed File"), message);
+                       emit statusBarChanged(message);
+                       return NULL;
+               }
+
+               QFile logFileDevice(logFilePath);
+               if (!logFileDevice.open(QFile::ReadOnly)) {
+                       QString message(i18n("Unable to open compressed file '%1': %2.", logFilePath, logFileDevice.errorString()));
+                       emit errorOccured(i18n("Unable to open Compressed File"), message);
+                       emit statusBarChanged(message);
+                       return NULL;
+               }
 
-               if (inputDevice == NULL) {
-                       QString message(i18n("Unable to uncompress the '%2' format of '%1'.", d->logFile.url().path(), mimeType));
+               if (kdecompressor.process(logFileDevice.readAll())) {
+                       QString message(i18n("Unable to uncompress '%1': '%2'.", logFilePath, kdecompressor.errorString()));
                        emit errorOccured(i18n("Unable to Uncompress File"), message);
                        emit statusBarChanged(message);
                        return NULL;
                }
+
+               inputDevice = new QBuffer();
+               qobject_cast<QBuffer*>(inputDevice)->setData(kdecompressor.result());
        }
 
        if ( ! inputDevice->open( QIODevice::ReadOnly ) ) {

diff --git a/ksystemlog/src/lib/logViewExport.cpp b/ksystemlog/src/lib/logViewExport.cpp
index 1dbd204..f437ab0 100644 (file)
--- a/ksystemlog/src/lib/logViewExport.cpp
+++ b/ksystemlog/src/lib/logViewExport.cpp
@@ -26,13 +26,13 @@
 #include <QPrinter>
 #include <QPrintDialog>
 #include <QPen>
+#include <QFile>
 
 #include <kapplication.h>
 #include <klocale.h>
 #include <ktoolinvocation.h>
 #include <kmessagebox.h>
 #include <kfiledialog.h>
-#include <kfilterdev.h>
 #include <kdeprintdialog.h>
 
 #include "logging.h"
@@ -238,7 +238,7 @@ void LogViewExport::fileSave() {
                return;
        }
 
-       QIODevice* ioDev = KFilterDev::deviceForFile(filename);
+       QFile* ioDev = new QFile(filename);
        if (ioDev->open(QIODevice::WriteOnly)) {
                QTextStream stream(ioDev);
 

diff --git a/okular/generators/ooo/manifest.cpp b/okular/generators/ooo/manifest.cpp
index 9ccb674..4f858ca 100644 (file)
--- a/okular/generators/ooo/manifest.cpp
+++ b/okular/generators/ooo/manifest.cpp
@@ -14,7 +14,7 @@
 #include <QCryptographicHash>
 #include <qxmlstream.h>
 
-#include <KFilterDev>
+#include <KDecompressor>
 #include <KLocale>
 #include <KMessageBox>
 
@@ -472,18 +472,15 @@ QByteArray Manifest::decryptFile( const QString &filename, const QByteArray &fil
     return QByteArray();
   }
 
-  QIODevice *decompresserDevice = KFilterDev::device( new QBuffer( &decryptedData, 0 ), "application/x-gzip", true );
-  if( !decompresserDevice ) {
-    kDebug(OooDebug) << "Couldn't create decompressor";
+  KDecompressor kdecompressor;
+  kdecompressor.setType(KDecompressor::TypeDeflate);
+  if( !kdecompressor.process(decryptedData) ) {
+    kDebug(OooDebug) << kdecompressor.errorString();
     // hopefully it isn't compressed then!
     return fileData;
   }
 
-  static_cast<KFilterDev*>( decompresserDevice )->setSkipHeaders( );
-
-  decompresserDevice->open( QIODevice::ReadOnly );
-
-  return decompresserDevice->readAll();
+  return kdecompressor.result();
 
 #else
   // TODO: This should have a proper parent

diff --git a/okular/part.cpp b/okular/part.cpp
index f7f0bac..58aaad7 100644 (file)
--- a/okular/part.cpp
+++ b/okular/part.cpp
@@ -57,8 +57,7 @@
 #include <ktogglefullscreenaction.h>
 #include <kio/job.h>
 #include <kicon.h>
-#include <kfilterdev.h>
-#include <kfilterbase.h>
+#include <kdecompressor.h>
 #include <kdeprintdialog.h>
 #include <kbookmarkmenu.h>
 #include <kpassworddialog.h>
@@ -195,11 +194,10 @@ static QString compressedMimeFor( const QString& mime_to_check )
     const QString app_xz( QString::fromLatin1( "application/x-xz" ) );
     if ( compressedMimeMap.isEmpty() )
     {
-        std::unique_ptr< KFilterBase > f;
+        KDecompressor f;
         compressedMimeMap[ QString::fromLatin1( "image/x-gzeps" ) ] = app_gzip;
         // check we can read bzip2-compressed files
-        f.reset( KFilterBase::findFilterByMimeType( app_bzip ) );
-        if ( f.get() )
+        if ( f.setType( KDecompressor::typeForMime( app_bzip ) ) )
         {
             supportBzip = true;
             compressedMimeMap[ QString::fromLatin1( "application/x-bzpdf" ) ] = app_bzip;
@@ -208,8 +206,7 @@ static QString compressedMimeFor( const QString& mime_to_check )
             compressedMimeMap[ QString::fromLatin1( "image/x-bzeps" ) ] = app_bzip;
         }
         // check we can read XZ-compressed files
-        f.reset( KFilterBase::findFilterByMimeType( app_xz ) );
-        if ( f.get() )
+        if ( f.setType( KDecompressor::typeForMime( app_xz ) ) )
         {
             supportXz = true;
         }
@@ -2810,15 +2807,10 @@ bool Part::handleCompressed( QString &destpath, const QString &path, const QStri
         return false;
     }
 
-    // decompression filer
-    QIODevice* filterDev = KFilterDev::deviceForFile( path, compressedMimetype );
-    if (!filterDev)
-    {
-        delete newtempfile;
-        return false;
-    }
-
-    if ( !filterDev->open(QIODevice::ReadOnly) )
+    // decompression file
+    QFile pathfile(path);
+    KDecompressor kdecompressor;
+    if ( !pathfile.open(QFile::ReadOnly) || !kdecompressor.setType(KDecompressor::typeForMime(compressedMimetype)) )
     {
         KMessageBox::detailedError( widget(),
             i18n("<qt><strong>File Error!</strong> Could not open the file "
@@ -2830,25 +2822,28 @@ bool Part::handleCompressed( QString &destpath, const QString &path, const QStri
             "right-click on the file in the Dolphin "
             "file manager and then choose the 'Properties' tab.</qt>"));
 
-        delete filterDev;
         delete newtempfile;
         return false;
     }
 
-    char buf[65536];
-    int read = 0, wrtn = 0;
-
-    while ((read = filterDev->read(buf, sizeof(buf))) > 0)
+    if (!kdecompressor.process(pathfile.readAll()))
     {
-        wrtn = newtempfile->write(buf, read);
-        if ( read != wrtn )
-            break;
+        KMessageBox::detailedError(widget(),
+            i18n("<qt><strong>File Error!</strong> Could not uncompress "
+            "the file <nobr><strong>%1</strong></nobr>. "
+            "The file will not be loaded.</qt>", path ),
+            i18n("<qt>This error typically occurs if the file is corrupt. "
+            "If you want to be sure, try to decompress the file manually "
+            "using command-line tools.</qt>"));
+        delete newtempfile;
+        return false;
     }
-    delete filterDev;
-    if ((read != 0) || (newtempfile->size() == 0))
+
+    const QByteArray uncompressed = kdecompressor.result();
+    if (newtempfile->write(uncompressed.constData(), uncompressed.size()) != uncompressed.size())
     {
         KMessageBox::detailedError(widget(),
-            i18n("<qt><strong>File Error!</strong> Could not uncompress "
+            i18n("<qt><strong>File Error!</strong> Could not write uncompressed data "
             "the file <nobr><strong>%1</strong></nobr>. "
             "The file will not be loaded.</qt>", path ),
             i18n("<qt>This error typically occurs if the file is corrupt. "
@@ -2857,6 +2852,7 @@ bool Part::handleCompressed( QString &destpath, const QString &path, const QStri
         delete newtempfile;
         return false;
     }
+
     m_tempfile = newtempfile;
     destpath = m_tempfile->fileName();
     return true;