Rockbox Utility: Replace OSDaB Zip with QuaZip.

This change fixes problems with zip files created with newer zip utilities (a
known issue is the iLike theme). QuaZip also allows better feedback during
operations without changing the imported code. Additionally Rockbox Utility and
the Theme Editor are now both using QuaZip; currently Rockbox Utility uses a
copy of the sources, merging them later is planned.

git-svn-id: svn://svn.rockbox.org/rockbox/trunk@29645 a1c6a512-1295-4272-9138-f99709370657

36 files changed, 5880 insertions, 3485 deletions

diff --git a/rbutil/rbutilqt/base/rbunzip.cpp b/rbutil/rbutilqt/base/rbunzip.cpp
deleted file mode 100644
index f71db5377e..0000000000
--- a/rbutil/rbutilqt/base/rbunzip.cpp
+++ /dev/null
@@ -1,66 +0,0 @@
-/***************************************************************************
- *             __________               __   ___.
- *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
- *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
- *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
- *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
- *                     \/            \/     \/    \/            \/
- *
- *   Copyright (C) 2008 by Dominik Riebeling
- *   $Id$
- *
- * All files in this archive are subject to the GNU General Public License.
- * See the file COPYING in the source tree root for full license agreement.
- *
- * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
- * KIND, either express or implied.
- *
- ****************************************************************************/
-
-#include "rbunzip.h"
-#include <QtCore>
-
-
-//! @brief extract archive to destination
-UnZip::ErrorCode RbUnZip::extractArchive(const QString& dest)
-{
-    qDebug() << "[UNZIP] extracting archive to" << dest;
-    QStringList files = this->fileList();
-    UnZip::ErrorCode error = Ok;
-    m_abortunzip = false;
-
-    int total = files.size();
-    for(int i = 0; i < total; i++) {
-        error = this->extractFile(files.at(i), dest, UnZip::ExtractPaths);
-        emit unzipProgress(i + 1, total);
-        QCoreApplication::processEvents(); // update UI
-        if(m_abortunzip)
-            error = SkipAll;
-        if(error != Ok)
-            break;
-    }
-    return error;
-}
-
-
-//! @brief abort an extractArchive() operation.
-void RbUnZip::abortUnzip(void)
-{
-    m_abortunzip = true;
-}
-
-
-//! @brief return total size of extracted files in archive.
-qulonglong RbUnZip::totalSize(void)
-{
-    QList<ZipEntry> l = this->entryList();
-    qulonglong total = 0;
-
-    int i = l.size();
-    while(i--)
-        total += l.at(i).uncompressedSize;
-
-    return total;
-
-}
-
diff --git a/rbutil/rbutilqt/base/rbunzip.h b/rbutil/rbutilqt/base/rbunzip.h
deleted file mode 100644
index c0b7215b6a..0000000000
--- a/rbutil/rbutilqt/base/rbunzip.h
+++ /dev/null
@@ -1,47 +0,0 @@
-/***************************************************************************
- *             __________               __   ___.
- *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
- *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
- *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
- *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
- *                     \/            \/     \/    \/            \/
- *
- *   Copyright (C) 2008 by Dominik Riebeling
- *   $Id$
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
- * KIND, either express or implied.
- *
- ****************************************************************************/
-
-#ifndef RBUNZIP_H
-#define RBUNZIP_H
-
-#include <QtCore>
-#include "zip/unzip.h"
-#include "zip/zip.h"
-
-class RbUnZip : public QObject, public UnZip
-{
-    Q_OBJECT
-    public:
-        UnZip::ErrorCode extractArchive(const QString&);
-        qulonglong totalSize(void);
-
-    signals:
-        void unzipProgress(int, int);
-
-    public slots:
-        void abortUnzip(void);
-
-    private:
-        bool m_abortunzip;
-};
-
-#endif
-
diff --git a/rbutil/rbutilqt/base/rbzip.cpp b/rbutil/rbutilqt/base/rbzip.cpp
deleted file mode 100644
index c011c0ccbc..0000000000
--- a/rbutil/rbutilqt/base/rbzip.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-/***************************************************************************
- *             __________               __   ___.
- *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
- *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
- *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
- *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
- *                     \/            \/     \/    \/            \/
- *
- *   Copyright (C) 2008 by Dominik Wenger
- *   $Id$
- *
- * All files in this archive are subject to the GNU General Public License.
- * See the file COPYING in the source tree root for full license agreement.
- *
- * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
- * KIND, either express or implied.
- *
- ****************************************************************************/
-
-#include "rbzip.h"
-#include <QtCore>
-
-
-Zip::ErrorCode RbZip::createZip(QString zip,QString dir)
-{
-    Zip::ErrorCode error = Ok;
-    m_curEntry = 1;
-    m_numEntrys=0;
-
-    QCoreApplication::processEvents();
-
-    // get number of entrys in dir
-    QDirIterator it(dir, QDirIterator::Subdirectories);
-    while (it.hasNext())
-    {
-        it.next();
-        m_numEntrys++;
-        QCoreApplication::processEvents();
-    }
-
-
-    //! create zip
-    error = Zip::createArchive(zip);
-    if(error != Ok)
-        return error;
-
-    //! add the content
-    error = Zip::addDirectory(dir);
-    if(error != Ok)
-        return error;
-
-    //! close zip
-    error = Zip::closeArchive();
-
-    return error;
-}
-
-void RbZip::progress()
-{
-    m_curEntry++;
-    emit zipProgress(m_curEntry,m_numEntrys);
-    QCoreApplication::processEvents(); // update UI
-}
-
-
diff --git a/rbutil/rbutilqt/base/rbzip.h b/rbutil/rbutilqt/base/rbzip.h
deleted file mode 100644
index d2681ec097..0000000000
--- a/rbutil/rbutilqt/base/rbzip.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/***************************************************************************
- *             __________               __   ___.
- *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
- *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
- *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
- *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
- *                     \/            \/     \/    \/            \/
- *
- *   Copyright (C) 2008 by Dominik Wenger
- *   $Id$
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
- * KIND, either express or implied.
- *
- ****************************************************************************/
-
-#ifndef RBZIP_H
-#define RBZIP_H
-
-#include <QtCore>
-#include "zip/zip.h"
-
-class RbZip : public QObject, public Zip
-{
-    Q_OBJECT
-    public:
-        Zip::ErrorCode createZip(QString zip,QString dir);
-
-        virtual void progress();
-
-    signals:
-        void zipProgress(int, int);
-
-    private:
-        int m_curEntry;
-        int m_numEntrys;
-};
-
-#endif
-
diff --git a/rbutil/rbutilqt/base/zipinstaller.cpp b/rbutil/rbutilqt/base/zipinstaller.cpp
index 1822d3c9ed..07a901ddf4 100644
--- a/rbutil/rbutilqt/base/zipinstaller.cpp
+++ b/rbutil/rbutilqt/base/zipinstaller.cpp
@@ -19,8 +19,8 @@
 
 #include <QtCore>
 #include "zipinstaller.h"
-#include "rbunzip.h"
 #include "utils.h"
+#include "ziputil.h"
 
 ZipInstaller::ZipInstaller(QObject* parent): QObject(parent)
 {
@@ -132,39 +132,28 @@ void ZipInstaller::downloadDone(bool error)
         emit logItem(tr("Extracting file."), LOGINFO);
         QCoreApplication::processEvents();
 
-        UnZip::ErrorCode ec;
-        RbUnZip uz;
-        connect(&uz, SIGNAL(unzipProgress(int, int)), this, SIGNAL(logProgress(int, int)));
-        connect(this, SIGNAL(internalAborted()), &uz, SLOT(abortUnzip()));
-        ec = uz.openArchive(m_file);
-        if(ec != UnZip::Ok) {
-            emit logItem(tr("Opening archive failed: %1.")
-                .arg(uz.formatError(ec)),LOGERROR);
-            emit logProgress(1, 1);
-            emit done(true);
-            return;
-        }
-
+        ZipUtil zip(this);
+        connect(&zip, SIGNAL(logProgress(int, int)), this, SIGNAL(logProgress(int, int)));
+        connect(&zip, SIGNAL(logItem(QString, int)), this, SIGNAL(logItem(QString, int)));
+        zip.open(m_file, QuaZip::mdUnzip);
         // check for free space. Make sure after installation will still be
         // some room for operating (also includes calculation mistakes due to
         // cluster sizes on the player).
-        if(Utils::filesystemFree(m_mountpoint) < (uz.totalSize() + 1000000)) {
+        if(Utils::filesystemFree(m_mountpoint)
+                < (zip.totalUncompressedSize() + 1000000)) {
             emit logItem(tr("Not enough disk space! Aborting."), LOGERROR);
             emit logProgress(1, 1);
             emit done(true);
             return;
         }
-        ec = uz.extractArchive(m_mountpoint);
-        // TODO: better handling of aborted unzip operation.
-        if(ec != UnZip::Ok) {
-            emit logItem(tr("Extracting failed: %1.")
-                .arg(uz.formatError(ec)),LOGERROR);
+        zipContents = zip.files();
+        if(!zip.extractArchive(m_mountpoint)) {
+            emit logItem(tr("Extraction failed!"), LOGERROR);
             emit logProgress(1, 1);
             emit done(true);
             return;
         }
-        // prepare file list for log
-        zipContents = uz.fileList();
+        zip.close();
     }
     else {
         // only copy the downloaded file to the output location / name
@@ -185,7 +174,7 @@ void ZipInstaller::downloadDone(bool error)
         }
 
         // add file to log
-        zipContents.append( m_target);
+        zipContents.append(m_target);
     }
 
     emit logItem(tr("Creating installation log"),LOGINFO);
diff --git a/rbutil/rbutilqt/base/ziputil.cpp b/rbutil/rbutilqt/base/ziputil.cpp
new file mode 100644
index 0000000000..ed8f17eefe
--- /dev/null
+++ b/rbutil/rbutilqt/base/ziputil.cpp
@@ -0,0 +1,261 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ *
+ *   Copyright (C) 2011 Dominik Riebeling
+ *   $Id$
+ *
+ * All files in this archive are subject to the GNU General Public License.
+ * See the file COPYING in the source tree root for full license agreement.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include <QtCore>
+#include <QDebug>
+#include "ziputil.h"
+#include "progressloggerinterface.h"
+
+#include "quazip.h"
+#include "quazipfile.h"
+#include "quazipfileinfo.h"
+
+
+ZipUtil::ZipUtil(QObject* parent) : QObject(parent)
+{
+    m_zip = NULL;
+}
+
+
+ZipUtil::~ZipUtil()
+{
+    if(m_zip) {
+        delete m_zip;
+    }
+}
+
+//! @brief open zip file.
+//! @param zipfile path to zip file
+//! @param mode open mode (see QuaZip::Mode)
+//! @return true on success, false otherwise
+bool ZipUtil::open(QString& zipfile, QuaZip::Mode mode)
+{
+    m_zip = new QuaZip(zipfile);
+    return m_zip->open(mode);
+}
+
+
+//! @brief close zip file.
+//! @return true on success, false otherwise
+bool ZipUtil::close(void)
+{
+    if(!m_zip) {
+        return false;
+    }
+
+    int error = UNZ_OK;
+    if(m_zip->isOpen()) {
+        m_zip->close();
+        error = m_zip->getZipError();
+    }
+    delete m_zip;
+    m_zip = NULL;
+    return (error == UNZ_OK) ? true : false;
+}
+
+
+//! @brief extract currently opened archive
+//! @brief dest path to extract archive to
+//! @return true on success, false otherwise
+bool ZipUtil::extractArchive(QString& dest)
+{
+    bool result = true;
+    if(!m_zip) {
+        return false;
+    }
+    QuaZipFile *currentFile = new QuaZipFile(m_zip);
+    int entries = m_zip->getEntriesCount();
+    int current = 0;
+    for(bool more = m_zip->goToFirstFile(); more; more = m_zip->goToNextFile())
+    {
+        ++current;
+        // if the entry is a path ignore it. Path existence is ensured separately.
+        if(m_zip->getCurrentFileName().split("/").last() == "")
+            continue;
+
+        QString outfilename = dest + "/" + m_zip->getCurrentFileName();
+        QFile outputFile(outfilename);
+        // make sure the output path exists
+        if(!QDir().mkpath(QFileInfo(outfilename).absolutePath())) {
+            result = false;
+            emit logItem(tr("Creating output path failed"), LOGERROR);
+            qDebug() << "[ZipUtil] creating output path failed for:"
+                     << outfilename;
+            break;
+        }
+        if(!outputFile.open(QFile::WriteOnly)) {
+            result = false;
+            emit logItem(tr("Creating output file failed"), LOGERROR);
+            qDebug() << "[ZipUtil] creating output file failed:"
+                     << outfilename;
+            break;
+        }
+        currentFile->open(QIODevice::ReadOnly);
+        outputFile.write(currentFile->readAll());
+        if(currentFile->getZipError() != UNZ_OK) {
+            result = false;
+            emit logItem(tr("Error during Zip operation"), LOGERROR);
+            qDebug() << "[ZipUtil] QuaZip error:" << currentFile->getZipError()
+                     << "on file" << currentFile->getFileName();
+            break;
+        }
+        currentFile->close();
+        outputFile.close();
+
+        emit logProgress(current, entries);
+    }
+    delete currentFile;
+    emit logProgress(1, 1);
+
+    return result;
+}
+
+
+//! @brief append a folder to current archive
+//! @param source source folder
+//! @param basedir base folder for archive. Will get stripped from zip paths.
+//! @return true on success, false otherwise
+bool ZipUtil::appendDirToArchive(QString& source, QString& basedir)
+{
+    bool result = true;
+    if(!m_zip || !m_zip->isOpen()) {
+        qDebug() << "[ZipUtil] Zip file not open!";
+        return false;
+    }
+    // get a list of all files and folders. Needed for progress info and avoids
+    // recursive calls.
+    QDirIterator iterator(source, QDirIterator::Subdirectories);
+    QStringList fileList;
+    while(iterator.hasNext()) {
+        iterator.next();
+        // skip folders, we can't add them.
+        if(!QFileInfo(iterator.filePath()).isDir()) {
+            fileList.append(iterator.filePath());
+        }
+    }
+    qDebug() << "[ZipUtil] Adding" << fileList.size() << "files to archive";
+
+    int max = fileList.size();
+    for(int i = 0; i < max; i++) {
+        QString current = fileList.at(i);
+        if(!appendFileToArchive(current, basedir)) {
+            qDebug() << "[ZipUtil] Error appending file" << current
+                     << "to archive" << m_zip->getZipName();
+            result = false;
+            break;
+        }
+        emit logProgress(i, max);
+    }
+    return result;
+}
+
+
+//! @brief append a single file to current archive
+//!
+bool ZipUtil::appendFileToArchive(QString& file, QString& basedir)
+{
+    bool result = true;
+    if(!m_zip || !m_zip->isOpen()) {
+        qDebug() << "[ZipUtil] Zip file not open!";
+        return false;
+    }
+    // skip folders, we can't add them.
+    QFileInfo fileinfo(file);
+    if(fileinfo.isDir()) {
+        return false;
+    }
+    QString infile = fileinfo.canonicalFilePath();
+    QString newfile = infile;
+    newfile.remove(QDir(basedir).canonicalPath() + "/");
+
+    QuaZipFile fout(m_zip);
+    QFile fin(file);
+
+    if(!fin.open(QFile::ReadOnly)) {
+        qDebug() << "[ZipUtil] Could not open file for reading:" << file;
+        return false;
+    }
+    if(!fout.open(QIODevice::WriteOnly, QuaZipNewInfo(newfile, infile))) {
+        fin.close();
+        qDebug() << "[ZipUtil] Could not open file for writing:" << newfile;
+        return false;
+    }
+
+    result = (fout.write(fin.readAll()) < 0) ? false : true;
+    fin.close();
+    fout.close();
+    return result;
+}
+
+
+//! @brief calculate total size of extracted files
+qint64 ZipUtil::totalUncompressedSize(void)
+{
+    qint64 uncompressed = 0;
+
+    QList<QuaZipFileInfo> items = contentProperties();
+    if(items.size() == 0) {
+        return -1;
+    }
+    int max = items.size();
+    for(int i = 0; i < max; ++i) {
+        uncompressed += items.at(i).uncompressedSize;
+    }
+    qDebug() << "[ZipUtil] size of archive files uncompressed:" << uncompressed;
+    return uncompressed;
+}
+
+
+QStringList ZipUtil::files(void)
+{
+    QList<QuaZipFileInfo> items = contentProperties();
+    QStringList fileList;
+    if(items.size() == 0) {
+        return fileList;
+    }
+    int max = items.size();
+    for(int i = 0; i < max; ++i) {
+        fileList.append(items.at(i).name);
+    }
+    return fileList;
+}
+
+
+QList<QuaZipFileInfo> ZipUtil::contentProperties()
+{
+    QList<QuaZipFileInfo> items;
+    if(!m_zip || !m_zip->isOpen()) {
+        qDebug() << "[ZipUtil] Zip file not open!";
+        return items;
+    }
+    QuaZipFileInfo info;
+    QuaZipFile currentFile(m_zip);
+    for(bool more = m_zip->goToFirstFile(); more; more = m_zip->goToNextFile())
+    {
+        currentFile.getFileInfo(&info);
+        if(currentFile.getZipError() != UNZ_OK) {
+            qDebug() << "[ZipUtil] QuaZip error:" << currentFile.getZipError()
+                     << "on file" << currentFile.getFileName();
+            return QList<QuaZipFileInfo>();
+        }
+        items.append(info);
+    }
+    return items;
+}
+
diff --git a/rbutil/rbutilqt/base/ziputil.h b/rbutil/rbutilqt/base/ziputil.h
new file mode 100644
index 0000000000..cfafb96566
--- /dev/null
+++ b/rbutil/rbutilqt/base/ziputil.h
@@ -0,0 +1,54 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ *
+ *   Copyright (C) 2011 Dominik Riebeling
+ *   $Id$
+ *
+ * All files in this archive are subject to the GNU General Public License.
+ * See the file COPYING in the source tree root for full license agreement.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#ifndef ZIPUTIL_H
+#define ZIPUTIL_H
+
+#include <QtCore>
+#include "quazip.h"
+#include "quazipfile.h"
+#include "quazipfileinfo.h"
+
+class ZipUtil : public QObject
+{
+    Q_OBJECT
+
+    public:
+        ZipUtil(QObject* parent);
+        ~ZipUtil();
+        bool open(QString& zipfile, QuaZip::Mode mode);
+        bool close(void);
+        bool extractArchive(QString& dest);
+        bool appendDirToArchive(QString& source, QString& basedir);
+        bool appendFileToArchive(QString& file, QString& basedir);
+        qint64 totalUncompressedSize(void);
+        QStringList files(void);
+
+    signals:
+       void logProgress(int, int);
+       void logItem(QString, int);
+
+    private:
+        QList<QuaZipFileInfo> contentProperties();
+        QuaZip* m_zip;
+        QuaZipFile* m_file;
+
+};
+#endif
+
diff --git a/rbutil/rbutilqt/installwindow.cpp b/rbutil/rbutilqt/installwindow.cpp
index 7b12303b96..c619bb5208 100644
--- a/rbutil/rbutilqt/installwindow.cpp
+++ b/rbutil/rbutilqt/installwindow.cpp
@@ -19,13 +19,13 @@
 
 #include "installwindow.h"
 #include "ui_installwindowfrm.h"
-#include "rbzip.h"
 #include "system.h"
 #include "rbsettings.h"
 #include "serverinfo.h"
 #include "systeminfo.h"
 #include "utils.h"
 #include "rockboxinfo.h"
+#include "ziputil.h"
 
 InstallWindow::InstallWindow(QWidget *parent) : QDialog(parent)
 {
@@ -55,8 +55,8 @@ InstallWindow::InstallWindow(QWidget *parent) : QDialog(parent)
         ui.Backupgroup->hide();
     }
     backupCheckboxChanged(Qt::Unchecked);
-    
-    
+
+
     if(ServerInfo::value(ServerInfo::DailyRevision).toString().isEmpty()) {
         ui.radioArchived->setEnabled(false);
         qDebug() << "[Install] no information about archived version available!";
@@ -89,7 +89,7 @@ InstallWindow::InstallWindow(QWidget *parent) : QDialog(parent)
         font.setBold(true);
         ui.radioCurrent->setFont(font);
     }
-    
+
 }
 
 
@@ -186,6 +186,7 @@ void InstallWindow::accept()
     if(ui.backup->isChecked())
     {
         logger->addItem(tr("Beginning Backup..."),LOGINFO);
+        QCoreApplication::processEvents();
 
         //! create dir, if it doesnt exist
         QFileInfo backupFile(m_backupName);
@@ -196,16 +197,20 @@ void InstallWindow::accept()
         }
 
         //! create backup
-        RbZip backup;
-        connect(&backup,SIGNAL(zipProgress(int,int)),logger,SLOT(setProgress(int,int)));
-        if(backup.createZip(m_backupName,
-            RbSettings::value(RbSettings::Mountpoint).toString() + "/.rockbox") == Zip::Ok)
-        {
-            logger->addItem(tr("Backup successful"),LOGOK);
+        bool result = true;
+        ZipUtil zip(this);
+        connect(&zip, SIGNAL(logProgress(int, int)), logger, SLOT(setProgress(int, int)));
+        connect(&zip, SIGNAL(logItem(QString, int)), logger, SLOT(addItem(QString, int)));
+        zip.open(m_backupName, QuaZip::mdCreate);
+        QString mp = RbSettings::value(RbSettings::Mountpoint).toString();
+        QString folder = mp + "/.rockbox";
+        result = zip.appendDirToArchive(folder, mp);
+        zip.close();
+        if(result) {
+            logger->addItem(tr("Backup finished."), LOGINFO);
         }
-        else
-        {
-            logger->addItem(tr("Backup failed!"),LOGERROR);
+        else {
+            logger->addItem(tr("Backup failed!"), LOGERROR);
             logger->setFinished();
             return;
         }
diff --git a/rbutil/rbutilqt/zip/LICENSE.GPL b/rbutil/rbutilqt/quazip/LICENSE.GPL
index 04a7580109..04a7580109 100644
--- a/rbutil/rbutilqt/zip/LICENSE.GPL
+++ b/rbutil/rbutilqt/quazip/LICENSE.GPL
diff --git a/rbutil/rbutilqt/quazip/README.ROCKBOX b/rbutil/rbutilqt/quazip/README.ROCKBOX
new file mode 100644
index 0000000000..b95f80caee
--- /dev/null
+++ b/rbutil/rbutilqt/quazip/README.ROCKBOX
@@ -0,0 +1,6 @@
+This folder contains the quazip project for ZIP file compression/decompression.
+These files are distributed under the GPL v2 or later.
+The source files have been last synced with the projects release at
+http://sourceforge.net/projects/quazip/ on July 20, 2010
+
+
diff --git a/rbutil/rbutilqt/quazip/crypt.h b/rbutil/rbutilqt/quazip/crypt.h
new file mode 100644
index 0000000000..82748c5715
--- /dev/null
+++ b/rbutil/rbutilqt/quazip/crypt.h
@@ -0,0 +1,133 @@
+/* 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.
+*/
+
+#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)
+{
+    (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
diff --git a/rbutil/rbutilqt/quazip/ioapi.c b/rbutil/rbutilqt/quazip/ioapi.c
new file mode 100644
index 0000000000..cf29a317fd
--- /dev/null
+++ b/rbutil/rbutilqt/quazip/ioapi.c
@@ -0,0 +1,184 @@
+/* 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
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "zlib.h"
+#include "ioapi.h"
+
+
+
+/* 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 fopen_file_func OF((
+   voidpf opaque,
+   const char* filename,
+   int mode));
+
+uLong ZCALLBACK fread_file_func OF((
+   voidpf opaque,
+   voidpf stream,
+   void* buf,
+   uLong size));
+
+uLong ZCALLBACK fwrite_file_func OF((
+   voidpf opaque,
+   voidpf stream,
+   const void* buf,
+   uLong size));
+
+long ZCALLBACK ftell_file_func OF((
+   voidpf opaque,
+   voidpf stream));
+
+long ZCALLBACK fseek_file_func OF((
+   voidpf opaque,
+   voidpf stream,
+   uLong offset,
+   int origin));
+
+int ZCALLBACK fclose_file_func OF((
+   voidpf opaque,
+   voidpf stream));
+
+int ZCALLBACK ferror_file_func OF((
+   voidpf opaque,
+   voidpf stream));
+
+
+voidpf ZCALLBACK fopen_file_func (opaque, filename, mode)
+   voidpf opaque;
+   const char* filename;
+   int mode;
+{
+    (void) opaque; /* avoid "unused parameter" warning */
+    FILE* file = NULL;
+    const char* mode_fopen = NULL;
+    if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
+        mode_fopen = "rb";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+        mode_fopen = "r+b";
+    else
+    if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+        mode_fopen = "wb";
+
+    if ((filename!=NULL) && (mode_fopen != NULL))
+        file = fopen(filename, mode_fopen);
+    return file;
+}
+
+
+uLong ZCALLBACK fread_file_func (opaque, stream, buf, size)
+   voidpf opaque;
+   voidpf stream;
+   void* buf;
+   uLong size;
+{
+    (void) opaque; /* avoid "unused parameter" warning */
+    uLong ret;
+    ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
+    return ret;
+}
+
+
+uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size)
+   voidpf opaque;
+   voidpf stream;
+   const void* buf;
+   uLong size;
+{
+    (void) opaque; /* avoid "unused parameter" warning */
+    uLong ret;
+    ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
+    return ret;
+}
+
+long ZCALLBACK ftell_file_func (opaque, stream)
+   voidpf opaque;
+   voidpf stream;
+{
+    (void) opaque; /* avoid "unused parameter" warning */
+    long ret;
+    ret = ftell((FILE *)stream);
+    return ret;
+}
+
+long ZCALLBACK fseek_file_func (opaque, stream, offset, origin)
+   voidpf opaque;
+   voidpf stream;
+   uLong offset;
+   int origin;
+{
+    (void) opaque; /* avoid "unused parameter" warning */
+    int fseek_origin=0;
+    long ret;
+    switch (origin)
+    {
+    case ZLIB_FILEFUNC_SEEK_CUR :
+        fseek_origin = SEEK_CUR;
+        break;
+    case ZLIB_FILEFUNC_SEEK_END :
+        fseek_origin = SEEK_END;
+        break;
+    case ZLIB_FILEFUNC_SEEK_SET :
+        fseek_origin = SEEK_SET;
+        break;
+    default: return -1;
+    }
+    ret = 0;
+    fseek((FILE *)stream, offset, fseek_origin);
+    return ret;
+}
+
+int ZCALLBACK fclose_file_func (opaque, stream)
+   voidpf opaque;
+   voidpf stream;
+{
+    (void) opaque; /* avoid "unused parameter" warning */
+    int ret;
+    ret = fclose((FILE *)stream);
+    return ret;
+}
+
+int ZCALLBACK ferror_file_func (opaque, stream)
+   voidpf opaque;
+   voidpf stream;
+{
+    (void) opaque; /* avoid "unused parameter" warning */
+    int ret;
+    ret = ferror((FILE *)stream);
+    return ret;
+}
+
+void fill_fopen_filefunc (pzlib_filefunc_def)
+  zlib_filefunc_def* pzlib_filefunc_def;
+{
+    pzlib_filefunc_def->zopen_file = fopen_file_func;
+    pzlib_filefunc_def->zread_file = fread_file_func;
+    pzlib_filefunc_def->zwrite_file = fwrite_file_func;
+    pzlib_filefunc_def->ztell_file = ftell_file_func;
+    pzlib_filefunc_def->zseek_file = fseek_file_func;
+    pzlib_filefunc_def->zclose_file = fclose_file_func;
+    pzlib_filefunc_def->zerror_file = ferror_file_func;
+    pzlib_filefunc_def->opaque = NULL;
+}
diff --git a/rbutil/rbutilqt/quazip/ioapi.h b/rbutil/rbutilqt/quazip/ioapi.h
new file mode 100644
index 0000000000..7d457baab3
--- /dev/null
+++ b/rbutil/rbutilqt/quazip/ioapi.h
@@ -0,0 +1,75 @@
+/* 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
+*/
+
+#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, const char* filename, 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 long   (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
+typedef long   (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_fopen_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
+
diff --git a/rbutil/rbutilqt/quazip/quazip.cpp b/rbutil/rbutilqt/quazip/quazip.cpp
new file mode 100644
index 0000000000..3f7314a433
--- /dev/null
+++ b/rbutil/rbutilqt/quazip/quazip.cpp
@@ -0,0 +1,285 @@
+/*
+-- A kind of "standard" GPL license statement --
+QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package
+Copyright (C) 2005-2007 Sergey A. Tachenov
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+-- A kind of "standard" GPL license statement ends here --
+
+See COPYING file for GPL.
+
+You are also permitted to use QuaZIP under the terms of LGPL (see
+COPYING.LGPL). You are free to choose either license, but please note
+that QuaZIP makes use of Qt, which is not licensed under LGPL. So if
+you are using Open Source edition of Qt, you therefore MUST use GPL for
+your code based on QuaZIP, since it would be also based on Qt in this
+case. If you are Qt commercial license owner, then you are free to use
+QuaZIP as long as you respect either GPL or LGPL for QuaZIP code.
+ **/
+
+#include <QFile>
+
+#include "quazip.h"
+
+QuaZip::QuaZip():
+  fileNameCodec(QTextCodec::codecForLocale()),
+  commentCodec(QTextCodec::codecForLocale()),
+  mode(mdNotOpen), hasCurrentFile_f(false), zipError(UNZ_OK)
+{
+}
+
+QuaZip::QuaZip(const QString& zipName):
+  fileNameCodec(QTextCodec::codecForLocale()),
+  commentCodec(QTextCodec::codecForLocale()),
+  zipName(zipName),
+  mode(mdNotOpen), hasCurrentFile_f(false), zipError(UNZ_OK)
+{
+}
+
+QuaZip::~QuaZip()
+{
+  if(isOpen()) close();
+}
+
+bool QuaZip::open(Mode mode, zlib_filefunc_def* ioApi)
+{
+  zipError=UNZ_OK;
+  if(isOpen()) {
+    qWarning("QuaZip::open(): ZIP already opened");
+    return false;
+  }
+  switch(mode) {
+    case mdUnzip:
+      unzFile_f=unzOpen2(QFile::encodeName(zipName).constData(), ioApi);
+      if(unzFile_f!=NULL) {
+        this->mode=mode;
+        return true;
+      } else {
+        zipError=UNZ_OPENERROR;
+        return false;
+      }
+    case mdCreate:
+    case mdAppend:
+    case mdAdd:
+      zipFile_f=zipOpen2(QFile::encodeName(zipName).constData(),
+          mode==mdCreate?APPEND_STATUS_CREATE:
+          mode==mdAppend?APPEND_STATUS_CREATEAFTER:
+          APPEND_STATUS_ADDINZIP,
+          NULL,
+          ioApi);
+      if(zipFile_f!=NULL) {
+        this->mode=mode;
+        return true;
+      } else {
+        zipError=UNZ_OPENERROR;
+        return false;
+      }
+    default:
+      qWarning("QuaZip::open(): unknown mode: %d", (int)mode);
+      return false;
+      break;
+  }
+}
+
+void QuaZip::close()
+{
+  zipError=UNZ_OK;
+  switch(mode) {
+    case mdNotOpen:
+      qWarning("QuaZip::close(): ZIP is not open");
+      return;
+    case mdUnzip:
+      zipError=unzClose(unzFile_f);
+      break;
+    case mdCreate:
+    case mdAppend:
+    case mdAdd:
+      zipError=zipClose(zipFile_f, commentCodec->fromUnicode(comment).constData());
+      break;
+    default:
+      qWarning("QuaZip::close(): unknown mode: %d", (int)mode);
+      return;
+  }
+  if(zipError==UNZ_OK) mode=mdNotOpen;
+}
+
+void QuaZip::setZipName(const QString& zipName)
+{
+  if(isOpen()) {
+    qWarning("QuaZip::setZipName(): ZIP is already open!");
+    return;
+  }
+  this->zipName=zipName;
+}
+
+int QuaZip::getEntriesCount()const
+{
+  QuaZip *fakeThis=(QuaZip*)this; // non-const
+  fakeThis->zipError=UNZ_OK;
+  if(mode!=mdUnzip) {
+    qWarning("QuaZip::getEntriesCount(): ZIP is not open in mdUnzip mode");
+    return -1;
+  }
+  unz_global_info globalInfo;
+  if((fakeThis->zipError=unzGetGlobalInfo(unzFile_f, &globalInfo))!=UNZ_OK)
+    return zipError;
+  return (int)globalInfo.number_entry;
+}
+
+QString QuaZip::getComment()const
+{
+  QuaZip *fakeThis=(QuaZip*)this; // non-const
+  fakeThis->zipError=UNZ_OK;
+  if(mode!=mdUnzip) {
+    qWarning("QuaZip::getComment(): ZIP is not open in mdUnzip mode");
+    return QString();
+  }
+  unz_global_info globalInfo;
+  QByteArray comment;
+  if((fakeThis->zipError=unzGetGlobalInfo(unzFile_f, &globalInfo))!=UNZ_OK)
+    return QString();
+  comment.resize(globalInfo.size_comment);
+  if((fakeThis->zipError=unzGetGlobalComment(unzFile_f, comment.data(), comment.size()))!=UNZ_OK)
+    return QString();
+  return commentCodec->toUnicode(comment);
+}
+
+bool QuaZip::setCurrentFile(const QString& fileName, CaseSensitivity cs)
+{
+  zipError=UNZ_OK;
+  if(mode!=mdUnzip) {
+    qWarning("QuaZip::setCurrentFile(): ZIP is not open in mdUnzip mode");
+    return false;
+  }
+  if(fileName.isNull()) {
+    hasCurrentFile_f=false;
+    return true;
+  }
+  // Unicode-aware reimplementation of the unzLocateFile function
+  if(unzFile_f==NULL) {
+    zipError=UNZ_PARAMERROR;
+    return false;
+  }
+  if(fileName.length()>MAX_FILE_NAME_LENGTH) {
+    zipError=UNZ_PARAMERROR;
+    return false;
+  }
+  bool sens;
+  if(cs==csDefault) {
+#ifdef Q_WS_WIN
+    sens=false;
+#else
+    sens=true;
+#endif
+  } else sens=cs==csSensitive;
+  QString lower, current;
+  if(!sens) lower=fileName.toLower();
+  hasCurrentFile_f=false;
+  for(bool more=goToFirstFile(); more; more=goToNextFile()) {
+    current=getCurrentFileName();
+    if(current.isNull()) return false;
+    if(sens) {
+      if(current==fileName) break;
+    } else {
+      if(current.toLower()==lower) break;
+    }
+  }
+  return hasCurrentFile_f;
+}
+
+bool QuaZip::goToFirstFile()
+{
+  zipError=UNZ_OK;
+  if(mode!=mdUnzip) {
+    qWarning("QuaZip::goToFirstFile(): ZIP is not open in mdUnzip mode");
+    return false;
+  }
+  zipError=unzGoToFirstFile(unzFile_f);
+  hasCurrentFile_f=zipError==UNZ_OK;
+  return hasCurrentFile_f;
+}
+
+bool QuaZip::goToNextFile()
+{
+  zipError=UNZ_OK;
+  if(mode!=mdUnzip) {
+    qWarning("QuaZip::goToFirstFile(): ZIP is not open in mdUnzip mode");
+    return false;
+  }
+  zipError=unzGoToNextFile(unzFile_f);
+  hasCurrentFile_f=zipError==UNZ_OK;
+  if(zipError==UNZ_END_OF_LIST_OF_FILE) zipError=UNZ_OK;
+  return hasCurrentFile_f;
+}
+
+bool QuaZip::getCurrentFileInfo(QuaZipFileInfo *info)const
+{
+  QuaZip *fakeThis=(QuaZip*)this; // non-const
+  fakeThis->zipError=UNZ_OK;
+  if(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->zipError=unzGetCurrentFileInfo(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->zipError=unzGetCurrentFileInfo(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=fileNameCodec->toUnicode(fileName);
+  info->comment=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->zipError=UNZ_OK;
+  if(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->zipError=unzGetCurrentFileInfo(unzFile_f, NULL, fileName.data(), fileName.size(),
+      NULL, 0, NULL, 0))!=UNZ_OK)
+    return QString();
+  return fileNameCodec->toUnicode(fileName.constData());
+}
diff --git a/rbutil/rbutilqt/quazip/quazip.h b/rbutil/rbutilqt/quazip/quazip.h
new file mode 100644
index 0000000000..ced1ea0f1a
--- /dev/null
+++ b/rbutil/rbutilqt/quazip/quazip.h
@@ -0,0 +1,346 @@
+#ifndef QUA_ZIP_H
+#define QUA_ZIP_H
+
+/*
+-- A kind of "standard" GPL license statement --
+QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package
+Copyright (C) 2005-2007 Sergey A. Tachenov
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+-- A kind of "standard" GPL license statement ends here --
+
+See COPYING file for GPL.
+
+You are also permitted to use QuaZIP under the terms of LGPL (see
+COPYING.LGPL). You are free to choose either license, but please note
+that QuaZIP makes use of Qt, which is not licensed under LGPL. So if
+you are using Open Source edition of Qt, you therefore MUST use GPL for
+your code based on QuaZIP, since it would be also based on Qt in this
+case. If you are Qt commercial license owner, then you are free to use
+QuaZIP as long as you respect either GPL or LGPL for QuaZIP code.
+ **/
+
+#include <QString>
+#include <QTextCodec>
+
+#include "zip.h"
+#include "unzip.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
+
+/// 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 {
+  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.
+    };
+  private:
+    QTextCodec *fileNameCodec, *commentCodec;
+    QString zipName;
+    QString comment;
+    Mode mode;
+    union {
+      unzFile unzFile_f;
+      zipFile zipFile_f;
+    };
+    bool hasCurrentFile_f;
+    int zipError;
+    // 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);
+    /// Destroys QuaZip object.
+    /** Calls close() if necessary. */
+    ~QuaZip();
+    /// Opens ZIP file.
+    /** Argument \a ioApi specifies IO function set for ZIP/UNZIP
+     * package to use. See unzip.h, zip.h and ioapi.h for details. By
+     * passing NULL (the default) you just tell package to use the
+     * default API which works just fine on UNIX platforms. I have tried
+     * it on win32-g++ platform too and it seems it works fine there
+     * too, so I see no reason to use win32 IO API included in original
+     * ZIP/UNZIP package.
+     *
+     * ZIP archive file name will be converted to 8-bit encoding using
+     * Qt's QFile::encodeName() function before passing it to the
+     * ZIP/UNZIP package API.
+     *
+     * Returns \c true if successful, \c false otherwise.
+     *
+     * 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.
+     *
+     * \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.
+     **/
+    bool open(Mode mode, zlib_filefunc_def *ioApi =NULL);
+    /// Closes ZIP file.
+    /** Call getZipError() to determine if the close was successful. */
+    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)
+    {this->fileNameCodec=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)
+    {fileNameCodec=QTextCodec::codecForName(fileNameCodecName);}
+    /// Returns the codec used to encode/decode comments inside archive.
+    QTextCodec* getFileNameCodec()const {return fileNameCodec;}
+    /// Sets the codec used to encode/decode comments inside archive.
+    /** This codec defaults to locale codec, which is probably ok.
+     **/
+    void setCommentCodec(QTextCodec *commentCodec)
+    {this->commentCodec=commentCodec;}
+    /// Sets the codec used to encode/decode comments inside archive.
+    /** \overload
+     * Equivalent to calling setCommentCodec(QTextCodec::codecForName(codecName));
+     **/
+    void setCommentCodec(const char *commentCodecName)
+    {commentCodec=QTextCodec::codecForName(commentCodecName);}
+    /// Returns the codec used to encode/decode comments inside archive.
+    QTextCodec* getCommentCodec()const {return commentCodec;}
+    /// Returns the name of the ZIP file.
+    /** Returns null string if no ZIP file name has been set.
+     * \sa setZipName()
+     **/
+    QString getZipName()const {return zipName;}
+    /// Sets the name of the ZIP file.
+    /** Does nothing if the ZIP file is open.
+     *
+     * Does not reset error code returned by getZipError().
+     **/
+    void setZipName(const QString& zipName);
+    /// Returns the mode in which ZIP file was opened.
+    Mode getMode()const {return mode;}
+    /// Returns \c true if ZIP file is open, \c false otherwise.
+    bool isOpen()const {return mode!=mdNotOpen;}
+    /// 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 {return zipError;}
+    /// 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 global comment in the ZIP file.
+    /** Comment will be written to the archive on close operation.
+     *
+     * \sa open()
+     **/
+    void setComment(const QString& comment) {this->comment=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 {return hasCurrentFile_f;}
+    /// 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() {return unzFile_f;}
+    /// 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() {return zipFile_f;}
+};
+
+#endif
diff --git a/rbutil/rbutilqt/quazip/quazipfile.cpp b/rbutil/rbutilqt/quazip/quazipfile.cpp
new file mode 100644
index 0000000000..0399d1dbd0
--- /dev/null
+++ b/rbutil/rbutilqt/quazip/quazipfile.cpp
@@ -0,0 +1,377 @@
+/*
+-- A kind of "standard" GPL license statement --
+QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package
+Copyright (C) 2005-2007 Sergey A. Tachenov
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+-- A kind of "standard" GPL license statement ends here --
+
+See COPYING file for GPL.
+
+You are also permitted to use QuaZIP under the terms of LGPL (see
+COPYING.LGPL). You are free to choose either license, but please note
+that QuaZIP makes use of Qt, which is not licensed under LGPL. So if
+you are using Open Source edition of Qt, you therefore MUST use GPL for
+your code based on QuaZIP, since it would be also based on Qt in this
+case. If you are Qt commercial license owner, then you are free to use
+QuaZIP as long as you respect either GPL or LGPL for QuaZIP code.
+ **/
+
+#include "quazipfile.h"
+
+using namespace std;
+
+QuaZipFile::QuaZipFile():
+  zip(NULL), internal(true), zipError(UNZ_OK)
+{
+}
+
+QuaZipFile::QuaZipFile(QObject *parent):
+  QIODevice(parent), zip(NULL), internal(true), zipError(UNZ_OK)
+{
+}
+
+QuaZipFile::QuaZipFile(const QString& zipName, QObject *parent):
+  QIODevice(parent), internal(true), zipError(UNZ_OK)
+{
+  zip=new QuaZip(zipName);
+  Q_CHECK_PTR(zip);
+}
+
+QuaZipFile::QuaZipFile(const QString& zipName, const QString& fileName,
+    QuaZip::CaseSensitivity cs, QObject *parent):
+  QIODevice(parent), internal(true), zipError(UNZ_OK)
+{
+  zip=new QuaZip(zipName);
+  Q_CHECK_PTR(zip);
+  this->fileName=fileName;
+  this->caseSensitivity=cs;
+}
+
+QuaZipFile::QuaZipFile(QuaZip *zip, QObject *parent):
+  QIODevice(parent),
+  zip(zip), internal(false),
+  zipError(UNZ_OK)
+{
+}
+
+QuaZipFile::~QuaZipFile()
+{
+  if(isOpen()) close();
+  if(internal) delete zip;
+}
+
+QString QuaZipFile::getZipName()const
+{
+  return zip==NULL?QString():zip->getZipName();
+}
+
+QString QuaZipFile::getActualFileName()const
+{
+  setZipError(UNZ_OK);
+  if(zip==NULL||(openMode()&WriteOnly)) return QString();
+  QString name=zip->getCurrentFileName();
+  if(name.isNull())
+    setZipError(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(zip!=NULL&&internal) delete zip;
+  zip=new QuaZip(zipName);
+  Q_CHECK_PTR(zip);
+  internal=true;
+}
+
+void QuaZipFile::setZip(QuaZip *zip)
+{
+  if(isOpen()) {
+    qWarning("QuaZipFile::setZip(): file is already open - can not set ZIP");
+    return;
+  }
+  if(this->zip!=NULL&&internal) delete this->zip;
+  this->zip=zip;
+  this->fileName=QString();
+  internal=false;
+}
+
+void QuaZipFile::setFileName(const QString& fileName, QuaZip::CaseSensitivity cs)
+{
+  if(zip==NULL) {
+    qWarning("QuaZipFile::setFileName(): call setZipName() first");
+    return;
+  }
+  if(!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;
+  }
+  this->fileName=fileName;
+  this->caseSensitivity=cs;
+}
+
+void QuaZipFile::setZipError(int zipError)const
+{
+  QuaZipFile *fakeThis=(QuaZipFile*)this; // non-const
+  fakeThis->zipError=zipError;
+  if(zipError==UNZ_OK)
+    fakeThis->setErrorString(QString());
+  else
+    fakeThis->setErrorString(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)
+{
+  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(internal) {
+      if(!zip->open(QuaZip::mdUnzip)) {
+        setZipError(zip->getZipError());
+        return false;
+      }
+      if(!zip->setCurrentFile(fileName, caseSensitivity)) {
+        setZipError(zip->getZipError());
+        zip->close();
+        return false;
+      }
+    } else {
+      if(zip==NULL) {
+        qWarning("QuaZipFile::open(): zip is NULL");
+        return false;
+      }
+      if(zip->getMode()!=QuaZip::mdUnzip) {
+        qWarning("QuaZipFile::open(): file open mode %d incompatible with ZIP open mode %d",
+            (int)mode, (int)zip->getMode());
+        return false;
+      }
+      if(!zip->hasCurrentFile()) {
+        qWarning("QuaZipFile::open(): zip does not have current file");
+        return false;
+      }
+    }
+    setZipError(unzOpenCurrentFile3(zip->getUnzFile(), method, level, (int)raw, password));
+    if(zipError==UNZ_OK) {
+      setOpenMode(mode);
+      this->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;
+  resetZipError();
+  if(isOpen()) {
+    qWarning("QuaZipFile::open(): already opened");
+    return false;
+  }
+  if((mode&WriteOnly)&&!(mode&ReadOnly)) {
+    if(internal) {
+      qWarning("QuaZipFile::open(): write mode is incompatible with internal QuaZip approach");
+      return false;
+    }
+    if(zip==NULL) {
+      qWarning("QuaZipFile::open(): zip is NULL");
+      return false;
+    }
+    if(zip->getMode()!=QuaZip::mdCreate&&zip->getMode()!=QuaZip::mdAppend&&zip->getMode()!=QuaZip::mdAdd) {
+      qWarning("QuaZipFile::open(): file open mode %d incompatible with ZIP open mode %d",
+          (int)mode, (int)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;
+    setZipError(zipOpenNewFileInZip3(zip->getZipFile(),
+          zip->getFileNameCodec()->fromUnicode(info.name).constData(), &info_z,
+          info.extraLocal.constData(), info.extraLocal.length(),
+          info.extraGlobal.constData(), info.extraGlobal.length(),
+          zip->getCommentCodec()->fromUnicode(info.comment).constData(),
+          method, level, (int)raw,
+          windowBits, memLevel, strategy,
+          password, (uLong)crc));
+    if(zipError==UNZ_OK) {
+      writePos=0;
+      setOpenMode(mode);
+      this->raw=raw;
+      if(raw) {
+        this->crc=crc;
+        this->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(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)
+    return unztell(zip->getUnzFile());
+  else
+    return writePos;
+}
+
+bool QuaZipFile::atEnd()const
+{
+  if(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)
+    return unzeof(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 raw?csize():usize();
+  else
+    return writePos;
+}
+
+qint64 QuaZipFile::csize()const
+{
+  unz_file_info info_z;
+  setZipError(UNZ_OK);
+  if(zip==NULL||zip->getMode()!=QuaZip::mdUnzip) return -1;
+  setZipError(unzGetCurrentFileInfo(zip->getUnzFile(), &info_z, NULL, 0, NULL, 0, NULL, 0));
+  if(zipError!=UNZ_OK)
+    return -1;
+  return info_z.compressed_size;
+}
+
+qint64 QuaZipFile::usize()const
+{
+  unz_file_info info_z;
+  setZipError(UNZ_OK);
+  if(zip==NULL||zip->getMode()!=QuaZip::mdUnzip) return -1;
+  setZipError(unzGetCurrentFileInfo(zip->getUnzFile(), &info_z, NULL, 0, NULL, 0, NULL, 0));
+  if(zipError!=UNZ_OK)
+    return -1;
+  return info_z.uncompressed_size;
+}
+
+bool QuaZipFile::getFileInfo(QuaZipFileInfo *info)
+{
+  if(zip==NULL||zip->getMode()!=QuaZip::mdUnzip) return false;
+  zip->getCurrentFileInfo(info);
+  setZipError(zip->getZipError());
+  return zipError==UNZ_OK;
+}
+
+void QuaZipFile::close()
+{
+  resetZipError();
+  if(zip==NULL||!zip->isOpen()) return;
+  if(!isOpen()) {
+    qWarning("QuaZipFile::close(): file isn't open");
+    return;
+  }
+  if(openMode()&ReadOnly)
+    setZipError(unzCloseCurrentFile(zip->getUnzFile()));
+  else if(openMode()&WriteOnly)
+    if(isRaw()) setZipError(zipCloseFileInZipRaw(zip->getZipFile(), uncompressedSize, crc));
+    else setZipError(zipCloseFileInZip(zip->getZipFile()));
+  else {
+    qWarning("Wrong open mode: %d", (int)openMode());
+    return;
+  }
+  if(zipError==UNZ_OK) setOpenMode(QIODevice::NotOpen);
+  else return;
+  if(internal) {
+    zip->close();
+    setZipError(zip->getZipError());
+  }
+}
+
+qint64 QuaZipFile::readData(char *data, qint64 maxSize)
+{
+  setZipError(UNZ_OK);
+  qint64 bytesRead=unzReadCurrentFile(zip->getUnzFile(), data, (unsigned)maxSize);
+  if(bytesRead<0) setZipError((int)bytesRead);
+  return bytesRead;
+}
+
+qint64 QuaZipFile::writeData(const char* data, qint64 maxSize)
+{
+  setZipError(ZIP_OK);
+  setZipError(zipWriteInFileInZip(zip->getZipFile(), data, (uint)maxSize));
+  if(zipError!=ZIP_OK) return -1;
+  else {
+    writePos+=maxSize;
+    return maxSize;
+  }
+}
diff --git a/rbutil/rbutilqt/quazip/quazipfile.h b/rbutil/rbutilqt/quazip/quazipfile.h
new file mode 100644
index 0000000000..09af5bceca
--- /dev/null
+++ b/rbutil/rbutilqt/quazip/quazipfile.h
@@ -0,0 +1,442 @@
+#ifndef QUA_ZIPFILE_H
+#define QUA_ZIPFILE_H
+
+/*
+-- A kind of "standard" GPL license statement --
+QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package
+Copyright (C) 2005-2008 Sergey A. Tachenov
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+-- A kind of "standard" GPL license statement ends here --
+
+See COPYING file for GPL.
+
+You are also permitted to use QuaZIP under the terms of LGPL (see
+COPYING.LGPL). You are free to choose either license, but please note
+that QuaZIP makes use of Qt, which is not licensed under LGPL. So if
+you are using Open Source edition of Qt, you therefore MUST use GPL for
+your code based on QuaZIP, since it would be also based on Qt in this
+case. If you are Qt commercial license owner, then you are free to use
+QuaZIP as long as you respect either GPL or LGPL for QuaZIP code.
+ **/
+
+#include <QIODevice>
+
+#include "quazip.h"
+#include "quazipnewinfo.h"
+
+/// 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.
+ *
+ * \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 prohibitely 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 QuaZipFile: public QIODevice {
+  Q_OBJECT
+  private:
+    QuaZip *zip;
+    QString fileName;
+    QuaZip::CaseSensitivity caseSensitivity;
+    bool raw;
+    qint64 writePos;
+    // these two are for writing raw files
+    ulong uncompressedSize;
+    quint32 crc;
+    bool internal;
+    int zipError;
+    // these are not supported nor implemented
+    QuaZipFile(const QuaZipFile& that);
+    QuaZipFile& operator=(const QuaZipFile& that);
+    void resetZipError()const {setZipError(UNZ_OK);}
+    // const, but sets zipError!
+    void setZipError(int zipError)const;
+  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 {return fileName;}
+    /// 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 {return caseSensitivity;}
+    /// 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 {return raw;}
+    /// 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).
+     **/
+    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.
+     *
+     * Arguments \a password and \a crc provide necessary information
+     * for crypting. Note that you should specify both of them if you
+     * need crypting. If you do not, pass \c NULL as password, but you
+     * still need to specify \a crc if you are going to use raw mode
+     * (see below).
+     *
+     * Arguments \a method and \a level specify compression method and
+     * level.
+     *
+     * 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 {return zipError;}
+};
+
+#endif
diff --git a/rbutil/rbutilqt/quazip/quazipfileinfo.h b/rbutil/rbutilqt/quazip/quazipfileinfo.h
new file mode 100644
index 0000000000..3216d776d5
--- /dev/null
+++ b/rbutil/rbutilqt/quazip/quazipfileinfo.h
@@ -0,0 +1,73 @@
+#ifndef QUA_ZIPFILEINFO_H
+#define QUA_ZIPFILEINFO_H
+
+/*
+-- A kind of "standard" GPL license statement --
+QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package
+Copyright (C) 2005-2007 Sergey A. Tachenov
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+-- A kind of "standard" GPL license statement ends here --
+
+See COPYING file for GPL.
+
+You are also permitted to use QuaZIP under the terms of LGPL (see
+COPYING.LGPL). You are free to choose either license, but please note
+that QuaZIP makes use of Qt, which is not licensed under LGPL. So if
+you are using Open Source edition of Qt, you therefore MUST use GPL for
+your code based on QuaZIP, since it would be also based on Qt in this
+case. If you are Qt commercial license owner, then you are free to use
+QuaZIP as long as you respect either GPL or LGPL for QuaZIP code.
+ **/
+
+#include <QByteArray>
+#include <QDateTime>
+
+/// Information about a file inside archive.
+/** Call QuaZip::getCurrentFileInfo() or QuaZipFile::getFileInfo() to
+ * fill this structure. */
+struct 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
diff --git a/rbutil/rbutilqt/quazip/quazipnewinfo.cpp b/rbutil/rbutilqt/quazip/quazipnewinfo.cpp
new file mode 100644
index 0000000000..17571f2fc8
--- /dev/null
+++ b/rbutil/rbutilqt/quazip/quazipnewinfo.cpp
@@ -0,0 +1,59 @@
+/* -- A kind of "standard" GPL license statement --
+QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package
+Copyright (C) 2005-2007 Sergey A. Tachenov
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+-- A kind of "standard" GPL license statement ends here --
+
+See COPYING file for GPL.
+
+You are also permitted to use QuaZIP under the terms of LGPL (see
+COPYING.LGPL). You are free to choose either license, but please note
+that QuaZIP makes use of Qt, which is not licensed under LGPL. So if
+you are using Open Source edition of Qt, you therefore MUST use GPL for
+your code based on QuaZIP, since it would be also based on Qt in this
+case. If you are Qt commercial license owner, then you are free to use
+QuaZIP as long as you respect either GPL or LGPL for QuaZIP code.
+*/
+
+#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;
+}
diff --git a/rbutil/rbutilqt/quazip/quazipnewinfo.h b/rbutil/rbutilqt/quazip/quazipnewinfo.h
new file mode 100644
index 0000000000..93ff1a2fc0
--- /dev/null
+++ b/rbutil/rbutilqt/quazip/quazipnewinfo.h
@@ -0,0 +1,109 @@
+#ifndef QUA_ZIPNEWINFO_H
+#define QUA_ZIPNEWINFO_H
+
+/*
+-- A kind of "standard" GPL license statement --
+QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package
+Copyright (C) 2005-2007 Sergey A. Tachenov
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU General Public License as published by the
+Free Software Foundation; either version 2 of the License, or (at your
+option) any later version.
+
+This program is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+-- A kind of "standard" GPL license statement ends here --
+
+See COPYING file for GPL.
+
+You are also permitted to use QuaZIP under the terms of LGPL (see
+COPYING.LGPL). You are free to choose either license, but please note
+that QuaZIP makes use of Qt, which is not licensed under LGPL. So if
+you are using Open Source edition of Qt, you therefore MUST use GPL for
+your code based on QuaZIP, since it would be also based on Qt in this
+case. If you are Qt commercial license owner, then you are free to use
+QuaZIP as long as you respect either GPL or LGPL for QuaZIP code.
+ **/
+
+#include <QDateTime>
+#include <QString>
+
+/// 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 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
diff --git a/rbutil/rbutilqt/quazip/unzip.c b/rbutil/rbutilqt/quazip/unzip.c
new file mode 100644
index 0000000000..ace7a08837
--- /dev/null
+++ b/rbutil/rbutilqt/quazip/unzip.c
@@ -0,0 +1,1601 @@
+/* unzip.c -- IO for uncompress .zip files using zlib
+   Version 1.01e, February 12th, 2005
+
+   Copyright (C) 1998-2005 Gilles Vollant
+
+   Read unzip.h for more info
+*/
+
+/* Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of
+compatibility with older software. The following is from the original crypt.c. Code
+woven in by Terry Thorsen 1/2003.
+*/
+/*
+  Copyright (c) 1990-2000 Info-ZIP.  All rights reserved.
+
+  See the accompanying file LICENSE, version 2000-Apr-09 or later
+  (the contents of which are also included in zip.h) for terms of use.
+  If, for some reason, all these files are missing, the Info-ZIP license
+  also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html
+*/
+/*
+  crypt.c (full version) by Info-ZIP.      Last revised:  [see crypt.h]
+
+  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).
+ */
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "zlib.h"
+#include "unzip.h"
+
+#ifdef STDC
+#  include <stddef.h>
+#  include <string.h>
+#  include <stdlib.h>
+#endif
+#ifdef NO_ERRNO_H
+    extern int errno;
+#else
+#   include <errno.h>
+#endif
+
+
+#ifndef local
+#  define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+
+#ifndef CASESENSITIVITYDEFAULT_NO
+#  if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES)
+#    define CASESENSITIVITYDEFAULT_NO
+#  endif
+#endif
+
+
+#ifndef UNZ_BUFSIZE
+#define UNZ_BUFSIZE (16384)
+#endif
+
+#ifndef UNZ_MAXFILENAMEINZIP
+#define UNZ_MAXFILENAMEINZIP (256)
+#endif
+
+#ifndef ALLOC
+# define ALLOC(size) (malloc(size))
+#endif
+#ifndef TRYFREE
+# define TRYFREE(p) {if (p) free(p);}
+#endif
+
+#define SIZECENTRALDIRITEM (0x2e)
+#define SIZEZIPLOCALHEADER (0x1e)
+
+
+
+
+const char unz_copyright[] =
+   " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
+
+/* unz_file_info_interntal contain internal info about a file in zipfile*/
+typedef struct unz_file_info_internal_s
+{
+    uLong offset_curfile;/* relative offset of local header 4 bytes */
+} unz_file_info_internal;
+
+
+/* file_in_zip_read_info_s contain internal information about a file in zipfile,
+    when reading and decompress it */
+typedef struct
+{
+    char  *read_buffer;         /* internal buffer for compressed data */
+    z_stream stream;            /* zLib stream structure for inflate */
+
+    uLong pos_in_zipfile;       /* position in byte on the zipfile, for fseek*/
+    uLong stream_initialised;   /* flag set if stream structure is initialised*/
+
+    uLong offset_local_extrafield;/* offset of the local extra field */
+    uInt  size_local_extrafield;/* size of the local extra field */
+    uLong pos_local_extrafield;   /* position in the local extra field in read*/
+
+    uLong crc32;                /* crc32 of all data uncompressed */
+    uLong crc32_wait;           /* crc32 we must obtain after decompress all */
+    uLong rest_read_compressed; /* number of byte to be decompressed */
+    uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/
+    zlib_filefunc_def z_filefunc;
+    voidpf filestream;        /* io structore of the zipfile */
+    uLong compression_method;   /* compression method (0==store) */
+    uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
+    int   raw;
+} file_in_zip_read_info_s;
+
+
+/* unz_s contain internal information about the zipfile
+*/
+typedef struct
+{
+    zlib_filefunc_def z_filefunc;
+    voidpf filestream;        /* io structore of the zipfile */
+    unz_global_info gi;       /* public global information */
+    uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
+    uLong num_file;             /* number of the current file in the zipfile*/
+    uLong pos_in_central_dir;   /* pos of the current file in the central dir*/
+    uLong current_file_ok;      /* flag about the usability of the current file*/
+    uLong central_pos;          /* position of the beginning of the central dir*/
+
+    uLong size_central_dir;     /* size of the central directory  */
+    uLong offset_central_dir;   /* offset of start of central directory with
+                                   respect to the starting disk number */
+
+    unz_file_info cur_file_info; /* public info about the current file in zip*/
+    unz_file_info_internal cur_file_info_internal; /* private info about it*/
+    file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current
+                                        file if we are decompressing it */
+    int encrypted;
+#    ifndef NOUNCRYPT
+    unsigned long keys[3];     /* keys defining the pseudo-random sequence */
+    const unsigned long* pcrc_32_tab;
+#    endif
+} unz_s;
+
+
+#ifndef NOUNCRYPT
+#include "crypt.h"
+#endif
+
+/* ===========================================================================
+     Read a byte from a gz_stream; update next_in and avail_in. Return EOF
+   for end of file.
+   IN assertion: the stream s has been sucessfully opened for reading.
+*/
+
+
+local int unzlocal_getByte OF((
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream,
+    int *pi));
+
+local int unzlocal_getByte(pzlib_filefunc_def,filestream,pi)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+    int *pi;
+{
+    unsigned char c;
+    int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
+    if (err==1)
+    {
+        *pi = (int)c;
+        return UNZ_OK;
+    }
+    else
+    {
+        if (ZERROR(*pzlib_filefunc_def,filestream))
+            return UNZ_ERRNO;
+        else
+            return UNZ_EOF;
+    }
+}
+
+
+/* ===========================================================================
+   Reads a long in LSB order from the given gz_stream. Sets
+*/
+local int unzlocal_getShort OF((
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream,
+    uLong *pX));
+
+local int unzlocal_getShort (pzlib_filefunc_def,filestream,pX)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+    uLong *pX;
+{
+    uLong x ;
+    int i;
+    int err;
+
+    err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x = (uLong)i;
+
+    if (err==UNZ_OK)
+        err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<8;
+
+    if (err==UNZ_OK)
+        *pX = x;
+    else
+        *pX = 0;
+    return err;
+}
+
+local int unzlocal_getLong OF((
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream,
+    uLong *pX));
+
+local int unzlocal_getLong (pzlib_filefunc_def,filestream,pX)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+    uLong *pX;
+{
+    uLong x ;
+    int i;
+    int err;
+
+    err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x = (uLong)i;
+
+    if (err==UNZ_OK)
+        err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<8;
+
+    if (err==UNZ_OK)
+        err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<16;
+
+    if (err==UNZ_OK)
+        err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<24;
+
+    if (err==UNZ_OK)
+        *pX = x;
+    else
+        *pX = 0;
+    return err;
+}
+
+
+/* My own strcmpi / strcasecmp */
+local int strcmpcasenosensitive_internal (fileName1,fileName2)
+    const char* fileName1;
+    const char* fileName2;
+{
+    for (;;)
+    {
+        char c1=*(fileName1++);
+        char c2=*(fileName2++);
+        if ((c1>='a') && (c1<='z'))
+            c1 -= 0x20;
+        if ((c2>='a') && (c2<='z'))
+            c2 -= 0x20;
+        if (c1=='\0')
+            return ((c2=='\0') ? 0 : -1);
+        if (c2=='\0')
+            return 1;
+        if (c1<c2)
+            return -1;
+        if (c1>c2)
+            return 1;
+    }
+}
+
+
+#ifdef  CASESENSITIVITYDEFAULT_NO
+#define CASESENSITIVITYDEFAULTVALUE 2
+#else
+#define CASESENSITIVITYDEFAULTVALUE 1
+#endif
+
+#ifndef STRCMPCASENOSENTIVEFUNCTION
+#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
+#endif
+
+/*
+   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 int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity)
+    const char* fileName1;
+    const char* fileName2;
+    int iCaseSensitivity;
+{
+    if (iCaseSensitivity==0)
+        iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
+
+    if (iCaseSensitivity==1)
+        return strcmp(fileName1,fileName2);
+
+    return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
+}
+
+#ifndef BUFREADCOMMENT
+#define BUFREADCOMMENT (0x400)
+#endif
+
+/*
+  Locate the Central directory of a zipfile (at the end, just before
+    the global comment)
+*/
+local uLong unzlocal_SearchCentralDir OF((
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream));
+
+local uLong unzlocal_SearchCentralDir(pzlib_filefunc_def,filestream)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+{
+    unsigned char* buf;
+    uLong uSizeFile;
+    uLong uBackRead;
+    uLong uMaxBack=0xffff; /* maximum size of global comment */
+    uLong uPosFound=0;
+
+    if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
+        return 0;
+
+
+    uSizeFile = ZTELL(*pzlib_filefunc_def,filestream);
+
+    if (uMaxBack>uSizeFile)
+        uMaxBack = uSizeFile;
+
+    buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
+    if (buf==NULL)
+        return 0;
+
+    uBackRead = 4;
+    while (uBackRead<uMaxBack)
+    {
+        uLong uReadSize,uReadPos ;
+        int i;
+        if (uBackRead+BUFREADCOMMENT>uMaxBack)
+            uBackRead = uMaxBack;
+        else
+            uBackRead+=BUFREADCOMMENT;
+        uReadPos = uSizeFile-uBackRead ;
+
+        uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
+                     (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
+        if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+            break;
+
+        if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
+            break;
+
+        for (i=(int)uReadSize-3; (i--)>0;)
+            if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
+                ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
+            {
+                uPosFound = uReadPos+i;
+                break;
+            }
+
+        if (uPosFound!=0)
+            break;
+    }
+    TRYFREE(buf);
+    return uPosFound;
+}
+
+/*
+  Open a Zip file. path contain the full pathname (by example,
+     on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer
+     "zlib/zlib114.zip".
+     If the zipfile cannot be opened (file doesn'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 (path, pzlib_filefunc_def)
+    const char *path;
+    zlib_filefunc_def* pzlib_filefunc_def;
+{
+    unz_s us;
+    unz_s *s;
+    uLong central_pos,uL;
+
+    uLong number_disk;          /* number of the current dist, used for
+                                   spaning ZIP, unsupported, always 0*/
+    uLong number_disk_with_CD;  /* number the the disk with central dir, used
+                                   for spaning ZIP, unsupported, always 0*/
+    uLong number_entry_CD;      /* total number of entries in
+                                   the central dir
+                                   (same than number_entry on nospan) */
+
+    int err=UNZ_OK;
+
+    if (unz_copyright[0]!=' ')
+        return NULL;
+
+    if (pzlib_filefunc_def==NULL)
+        fill_fopen_filefunc(&us.z_filefunc);
+    else
+        us.z_filefunc = *pzlib_filefunc_def;
+
+    us.filestream= (*(us.z_filefunc.zopen_file))(us.z_filefunc.opaque,
+                                                 path,
+                                                 ZLIB_FILEFUNC_MODE_READ |
+                                                 ZLIB_FILEFUNC_MODE_EXISTING);
+    if (us.filestream==NULL)
+        return NULL;
+
+    central_pos = unzlocal_SearchCentralDir(&us.z_filefunc,us.filestream);
+    if (central_pos==0)
+        err=UNZ_ERRNO;
+
+    if (ZSEEK(us.z_filefunc, us.filestream,
+                                      central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+        err=UNZ_ERRNO;
+
+    /* the signature, already checked */
+    if (unzlocal_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
+        err=UNZ_ERRNO;
+
+    /* number of this disk */
+    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
+        err=UNZ_ERRNO;
+
+    /* number of the disk with the start of the central directory */
+    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
+        err=UNZ_ERRNO;
+
+    /* total number of entries in the central dir on this disk */
+    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK)
+        err=UNZ_ERRNO;
+
+    /* total number of entries in the central dir */
+    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if ((number_entry_CD!=us.gi.number_entry) ||
+        (number_disk_with_CD!=0) ||
+        (number_disk!=0))
+        err=UNZ_BADZIPFILE;
+
+    /* size of the central directory */
+    if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK)
+        err=UNZ_ERRNO;
+
+    /* offset of start of central directory with respect to the
+          starting disk number */
+    if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK)
+        err=UNZ_ERRNO;
+
+    /* zipfile comment length */
+    if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
+        (err==UNZ_OK))
+        err=UNZ_BADZIPFILE;
+
+    if (err!=UNZ_OK)
+    {
+        ZCLOSE(us.z_filefunc, us.filestream);
+        return NULL;
+    }
+
+    us.byte_before_the_zipfile = central_pos -
+                            (us.offset_central_dir+us.size_central_dir);
+    us.central_pos = central_pos;
+    us.pfile_in_zip_read = NULL;
+    us.encrypted = 0;
+
+
+    s=(unz_s*)ALLOC(sizeof(unz_s));
+    *s=us;
+    unzGoToFirstFile((unzFile)s);
+    return (unzFile)s;
+}
+
+
+extern unzFile ZEXPORT unzOpen (path)
+    const char *path;
+{
+    return unzOpen2(path, NULL);
+}
+
+/*
+  Close a ZipFile opened with unzipOpen.
+  If there is files inside the .Zip opened with unzipOpenCurrentFile (see later),
+    these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
+  return UNZ_OK if there is no problem. */
+extern int ZEXPORT unzClose (file)
+    unzFile file;
+{
+    unz_s* s;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+
+    if (s->pfile_in_zip_read!=NULL)
+        unzCloseCurrentFile(file);
+
+    ZCLOSE(s->z_filefunc, s->filestream);
+    TRYFREE(s);
+    return UNZ_OK;
+}
+
+
+/*
+  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 unzGetGlobalInfo (file,pglobal_info)
+    unzFile file;
+    unz_global_info *pglobal_info;
+{
+    unz_s* s;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    *pglobal_info=s->gi;
+    return UNZ_OK;
+}
+
+
+/*
+   Translate date/time from Dos format to tm_unz (readable more easilty)
+*/
+local void unzlocal_DosDateToTmuDate (ulDosDate, ptm)
+    uLong ulDosDate;
+    tm_unz* ptm;
+{
+    uLong uDate;
+    uDate = (uLong)(ulDosDate>>16);
+    ptm->tm_mday = (uInt)(uDate&0x1f) ;
+    ptm->tm_mon =  (uInt)((((uDate)&0x1E0)/0x20)-1) ;
+    ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
+
+    ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
+    ptm->tm_min =  (uInt) ((ulDosDate&0x7E0)/0x20) ;
+    ptm->tm_sec =  (uInt) (2*(ulDosDate&0x1f)) ;
+}
+
+/*
+  Get Info about the current file in the zipfile, with internal only info
+*/
+local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file,
+                                                  unz_file_info *pfile_info,
+                                                  unz_file_info_internal
+                                                  *pfile_info_internal,
+                                                  char *szFileName,
+                                                  uLong fileNameBufferSize,
+                                                  void *extraField,
+                                                  uLong extraFieldBufferSize,
+                                                  char *szComment,
+                                                  uLong commentBufferSize));
+
+local int unzlocal_GetCurrentFileInfoInternal (file,
+                                              pfile_info,
+                                              pfile_info_internal,
+                                              szFileName, fileNameBufferSize,
+                                              extraField, extraFieldBufferSize,
+                                              szComment,  commentBufferSize)
+    unzFile file;
+    unz_file_info *pfile_info;
+    unz_file_info_internal *pfile_info_internal;
+    char *szFileName;
+    uLong fileNameBufferSize;
+    void *extraField;
+    uLong extraFieldBufferSize;
+    char *szComment;
+    uLong commentBufferSize;
+{
+    unz_s* s;
+    unz_file_info file_info;
+    unz_file_info_internal file_info_internal;
+    int err=UNZ_OK;
+    uLong uMagic;
+    long lSeek=0;
+
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    if (ZSEEK(s->z_filefunc, s->filestream,
+              s->pos_in_central_dir+s->byte_before_the_zipfile,
+              ZLIB_FILEFUNC_SEEK_SET)!=0)
+        err=UNZ_ERRNO;
+
+
+    /* we check the magic */
+    if (err==UNZ_OK) {
+        if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
+            err=UNZ_ERRNO;
+        else if (uMagic!=0x02014b50)
+            err=UNZ_BADZIPFILE;
+    }
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    lSeek+=file_info.size_filename;
+    if ((err==UNZ_OK) && (szFileName!=NULL))
+    {
+        uLong uSizeRead ;
+        if (file_info.size_filename<fileNameBufferSize)
+        {
+            *(szFileName+file_info.size_filename)='\0';
+            uSizeRead = file_info.size_filename;
+        }
+        else
+            uSizeRead = fileNameBufferSize;
+
+        if ((file_info.size_filename>0) && (fileNameBufferSize>0))
+            if (ZREAD(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead)
+                err=UNZ_ERRNO;
+        lSeek -= uSizeRead;
+    }
+
+
+    if ((err==UNZ_OK) && (extraField!=NULL))
+    {
+        uLong uSizeRead ;
+        if (file_info.size_file_extra<extraFieldBufferSize)
+            uSizeRead = file_info.size_file_extra;
+        else
+            uSizeRead = extraFieldBufferSize;
+
+        if (lSeek!=0) {
+            if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
+                lSeek=0;
+            else
+                err=UNZ_ERRNO;
+        }
+        if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
+            if (ZREAD(s->z_filefunc, s->filestream,extraField,uSizeRead)!=uSizeRead)
+                err=UNZ_ERRNO;
+        lSeek += file_info.size_file_extra - uSizeRead;
+    }
+    else
+        lSeek+=file_info.size_file_extra;
+
+
+    if ((err==UNZ_OK) && (szComment!=NULL))
+    {
+        uLong uSizeRead ;
+        if (file_info.size_file_comment<commentBufferSize)
+        {
+            *(szComment+file_info.size_file_comment)='\0';
+            uSizeRead = file_info.size_file_comment;
+        }
+        else
+            uSizeRead = commentBufferSize;
+
+        if (lSeek!=0) {
+            if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
+                lSeek=0;
+            else
+                err=UNZ_ERRNO;
+        }
+        if ((file_info.size_file_comment>0) && (commentBufferSize>0))
+            if (ZREAD(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead)
+                err=UNZ_ERRNO;
+        lSeek+=file_info.size_file_comment - uSizeRead;
+    }
+    else
+        lSeek+=file_info.size_file_comment;
+
+    if ((err==UNZ_OK) && (pfile_info!=NULL))
+        *pfile_info=file_info;
+
+    if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
+        *pfile_info_internal=file_info_internal;
+
+    return err;
+}
+
+
+
+/*
+  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 unzGetCurrentFileInfo (file,
+                                          pfile_info,
+                                          szFileName, fileNameBufferSize,
+                                          extraField, extraFieldBufferSize,
+                                          szComment,  commentBufferSize)
+    unzFile file;
+    unz_file_info *pfile_info;
+    char *szFileName;
+    uLong fileNameBufferSize;
+    void *extraField;
+    uLong extraFieldBufferSize;
+    char *szComment;
+    uLong commentBufferSize;
+{
+    return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL,
+                                                szFileName,fileNameBufferSize,
+                                                extraField,extraFieldBufferSize,
+                                                szComment,commentBufferSize);
+}
+
+/*
+  Set the current file of the zipfile to the first file.
+  return UNZ_OK if there is no problem
+*/
+extern int ZEXPORT unzGoToFirstFile (file)
+    unzFile file;
+{
+    int err=UNZ_OK;
+    unz_s* s;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    s->pos_in_central_dir=s->offset_central_dir;
+    s->num_file=0;
+    err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+                                             &s->cur_file_info_internal,
+                                             NULL,0,NULL,0,NULL,0);
+    s->current_file_ok = (err == UNZ_OK);
+    return err;
+}
+
+/*
+  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 unzGoToNextFile (file)
+    unzFile file;
+{
+    unz_s* s;
+    int err;
+
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    if (!s->current_file_ok)
+        return UNZ_END_OF_LIST_OF_FILE;
+    if (s->gi.number_entry != 0xffff)    /* 2^16 files overflow hack */
+      if (s->num_file+1==s->gi.number_entry)
+        return UNZ_END_OF_LIST_OF_FILE;
+
+    s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
+            s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
+    s->num_file++;
+    err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+                                               &s->cur_file_info_internal,
+                                               NULL,0,NULL,0,NULL,0);
+    s->current_file_ok = (err == UNZ_OK);
+    return err;
+}
+
+
+/*
+  Try locate the file szFileName in the zipfile.
+  For the iCaseSensitivity signification, see unzipStringFileNameCompare
+
+  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
+*/
+extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity)
+    unzFile file;
+    const char *szFileName;
+    int iCaseSensitivity;
+{
+    unz_s* s;
+    int err;
+
+    /* We remember the 'current' position in the file so that we can jump
+     * back there if we fail.
+     */
+    unz_file_info cur_file_infoSaved;
+    unz_file_info_internal cur_file_info_internalSaved;
+    uLong num_fileSaved;
+    uLong pos_in_central_dirSaved;
+
+
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+
+    if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
+        return UNZ_PARAMERROR;
+
+    s=(unz_s*)file;
+    if (!s->current_file_ok)
+        return UNZ_END_OF_LIST_OF_FILE;
+
+    /* Save the current state */
+    num_fileSaved = s->num_file;
+    pos_in_central_dirSaved = s->pos_in_central_dir;
+    cur_file_infoSaved = s->cur_file_info;
+    cur_file_info_internalSaved = s->cur_file_info_internal;
+
+    err = unzGoToFirstFile(file);
+
+    while (err == UNZ_OK)
+    {
+        char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
+        err = unzGetCurrentFileInfo(file,NULL,
+                                    szCurrentFileName,sizeof(szCurrentFileName)-1,
+                                    NULL,0,NULL,0);
+        if (err == UNZ_OK)
+        {
+            if (unzStringFileNameCompare(szCurrentFileName,
+                                            szFileName,iCaseSensitivity)==0)
+                return UNZ_OK;
+            err = unzGoToNextFile(file);
+        }
+    }
+
+    /* We failed, so restore the state of the 'current file' to where we
+     * were.
+     */
+    s->num_file = num_fileSaved ;
+    s->pos_in_central_dir = pos_in_central_dirSaved ;
+    s->cur_file_info = cur_file_infoSaved;
+    s->cur_file_info_internal = cur_file_info_internalSaved;
+    return err;
+}
+
+
+/*
+///////////////////////////////////////////
+// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net)
+// I need random access
+//
+// Further optimization could be realized by adding an ability
+// to cache the directory in memory. The goal being a single
+// comprehensive file read to put the file I need in a memory.
+*/
+
+/*
+typedef struct unz_file_pos_s
+{
+    uLong pos_in_zip_directory;   // offset in file
+    uLong num_of_file;            // # of file
+} unz_file_pos;
+*/
+
+extern int ZEXPORT unzGetFilePos(file, file_pos)
+    unzFile file;
+    unz_file_pos* file_pos;
+{
+    unz_s* s;
+
+    if (file==NULL || file_pos==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    if (!s->current_file_ok)
+        return UNZ_END_OF_LIST_OF_FILE;
+
+    file_pos->pos_in_zip_directory  = s->pos_in_central_dir;
+    file_pos->num_of_file           = s->num_file;
+
+    return UNZ_OK;
+}
+
+extern int ZEXPORT unzGoToFilePos(file, file_pos)
+    unzFile file;
+    unz_file_pos* file_pos;
+{
+    unz_s* s;
+    int err;
+
+    if (file==NULL || file_pos==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+
+    /* jump to the right spot */
+    s->pos_in_central_dir = file_pos->pos_in_zip_directory;
+    s->num_file           = file_pos->num_of_file;
+
+    /* set the current file */
+    err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+                                               &s->cur_file_info_internal,
+                                               NULL,0,NULL,0,NULL,0);
+    /* return results */
+    s->current_file_ok = (err == UNZ_OK);
+    return err;
+}
+
+/*
+// Unzip Helper Functions - should be here?
+///////////////////////////////////////////
+*/
+
+/*
+  Read the local header of the current zipfile
+  Check the coherency of the local header and info in the end of central
+        directory about this file
+  store in *piSizeVar the size of extra info in local header
+        (filename and size of extra field data)
+*/
+local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar,
+                                                    poffset_local_extrafield,
+                                                    psize_local_extrafield)
+    unz_s* s;
+    uInt* piSizeVar;
+    uLong *poffset_local_extrafield;
+    uInt  *psize_local_extrafield;
+{
+    uLong uMagic,uData,uFlags;
+    uLong size_filename;
+    uLong size_extra_field;
+    int err=UNZ_OK;
+
+    *piSizeVar = 0;
+    *poffset_local_extrafield = 0;
+    *psize_local_extrafield = 0;
+
+    if (ZSEEK(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile +
+                                s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
+        return UNZ_ERRNO;
+
+
+    if (err==UNZ_OK) {
+        if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
+            err=UNZ_ERRNO;
+        else if (uMagic!=0x04034b50)
+            err=UNZ_BADZIPFILE;
+    }
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
+        err=UNZ_ERRNO;
+/*
+    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
+        err=UNZ_BADZIPFILE;
+*/
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK)
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
+        err=UNZ_ERRNO;
+    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
+        err=UNZ_BADZIPFILE;
+
+    if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
+                         (s->cur_file_info.compression_method!=Z_DEFLATED))
+        err=UNZ_BADZIPFILE;
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */
+        err=UNZ_ERRNO;
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */
+        err=UNZ_ERRNO;
+    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) &&
+                              ((uFlags & 8)==0))
+        err=UNZ_BADZIPFILE;
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */
+        err=UNZ_ERRNO;
+    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) &&
+                              ((uFlags & 8)==0))
+        err=UNZ_BADZIPFILE;
+
+    if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */
+        err=UNZ_ERRNO;
+    else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) &&
+                              ((uFlags & 8)==0))
+        err=UNZ_BADZIPFILE;
+
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK)
+        err=UNZ_ERRNO;
+    else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
+        err=UNZ_BADZIPFILE;
+
+    *piSizeVar += (uInt)size_filename;
+
+    if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK)
+        err=UNZ_ERRNO;
+    *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
+                                    SIZEZIPLOCALHEADER + size_filename;
+    *psize_local_extrafield = (uInt)size_extra_field;
+
+    *piSizeVar += (uInt)size_extra_field;
+
+    return err;
+}
+
+/*
+  Open for reading data the current file in the zipfile.
+  If there is no error and the file is opened, the return value is UNZ_OK.
+*/
+extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password)
+    unzFile file;
+    int* method;
+    int* level;
+    int raw;
+    const char* password;
+{
+    int err=UNZ_OK;
+    uInt iSizeVar;
+    unz_s* s;
+    file_in_zip_read_info_s* pfile_in_zip_read_info;
+    uLong offset_local_extrafield;  /* offset of the local extra field */
+    uInt  size_local_extrafield;    /* size of the local extra field */
+#    ifndef NOUNCRYPT
+    char source[12];
+#    else
+    if (password != NULL)
+        return UNZ_PARAMERROR;
+#    endif
+
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    if (!s->current_file_ok)
+        return UNZ_PARAMERROR;
+
+    if (s->pfile_in_zip_read != NULL)
+        unzCloseCurrentFile(file);
+
+    if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar,
+                &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
+        return UNZ_BADZIPFILE;
+
+    pfile_in_zip_read_info = (file_in_zip_read_info_s*)
+                                        ALLOC(sizeof(file_in_zip_read_info_s));
+    if (pfile_in_zip_read_info==NULL)
+        return UNZ_INTERNALERROR;
+
+    pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
+    pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
+    pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
+    pfile_in_zip_read_info->pos_local_extrafield=0;
+    pfile_in_zip_read_info->raw=raw;
+
+    if (pfile_in_zip_read_info->read_buffer==NULL)
+    {
+        TRYFREE(pfile_in_zip_read_info);
+        return UNZ_INTERNALERROR;
+    }
+
+    pfile_in_zip_read_info->stream_initialised=0;
+
+    if (method!=NULL)
+        *method = (int)s->cur_file_info.compression_method;
+
+    if (level!=NULL)
+    {
+        *level = 6;
+        switch (s->cur_file_info.flag & 0x06)
+        {
+          case 6 : *level = 1; break;
+          case 4 : *level = 2; break;
+          case 2 : *level = 9; break;
+        }
+    }
+
+    if ((s->cur_file_info.compression_method!=0) &&
+        (s->cur_file_info.compression_method!=Z_DEFLATED))
+        err=UNZ_BADZIPFILE;
+
+    pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
+    pfile_in_zip_read_info->crc32=0;
+    pfile_in_zip_read_info->compression_method =
+            s->cur_file_info.compression_method;
+    pfile_in_zip_read_info->filestream=s->filestream;
+    pfile_in_zip_read_info->z_filefunc=s->z_filefunc;
+    pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
+
+    pfile_in_zip_read_info->stream.total_out = 0;
+
+    if ((s->cur_file_info.compression_method==Z_DEFLATED) &&
+        (!raw))
+    {
+      pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
+      pfile_in_zip_read_info->stream.zfree = (free_func)0;
+      pfile_in_zip_read_info->stream.opaque = (voidpf)0;
+      pfile_in_zip_read_info->stream.next_in = (voidpf)0;
+      pfile_in_zip_read_info->stream.avail_in = 0;
+
+      err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
+      if (err == Z_OK)
+        pfile_in_zip_read_info->stream_initialised=1;
+      else
+      {
+        TRYFREE(pfile_in_zip_read_info);
+        return err;
+      }
+        /* windowBits is passed < 0 to tell that there is no zlib header.
+         * Note that in this case inflate *requires* an extra "dummy" byte
+         * after the compressed stream in order to complete decompression and
+         * return Z_STREAM_END.
+         * In unzip, i don't wait absolutely Z_STREAM_END because I known the
+         * size of both compressed and uncompressed data
+         */
+    }
+    pfile_in_zip_read_info->rest_read_compressed =
+            s->cur_file_info.compressed_size ;
+    pfile_in_zip_read_info->rest_read_uncompressed =
+            s->cur_file_info.uncompressed_size ;
+
+
+    pfile_in_zip_read_info->pos_in_zipfile =
+            s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
+              iSizeVar;
+
+    pfile_in_zip_read_info->stream.avail_in = (uInt)0;
+
+    s->pfile_in_zip_read = pfile_in_zip_read_info;
+
+#    ifndef NOUNCRYPT
+    if (password != NULL)
+    {
+        int i;
+        s->pcrc_32_tab = get_crc_table();
+        init_keys(password,s->keys,s->pcrc_32_tab);
+        if (ZSEEK(s->z_filefunc, s->filestream,
+                  s->pfile_in_zip_read->pos_in_zipfile +
+                     s->pfile_in_zip_read->byte_before_the_zipfile,
+                  SEEK_SET)!=0)
+            return UNZ_INTERNALERROR;
+        if(ZREAD(s->z_filefunc, s->filestream,source, 12)<12)
+            return UNZ_INTERNALERROR;
+
+        for (i = 0; i<12; i++)
+            zdecode(s->keys,s->pcrc_32_tab,source[i]);
+
+        s->pfile_in_zip_read->pos_in_zipfile+=12;
+        s->encrypted=1;
+    }
+#    endif
+
+
+    return UNZ_OK;
+}
+
+extern int ZEXPORT unzOpenCurrentFile (file)
+    unzFile file;
+{
+    return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
+}
+
+extern int ZEXPORT unzOpenCurrentFilePassword (file, password)
+    unzFile file;
+    const char* password;
+{
+    return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
+}
+
+extern int ZEXPORT unzOpenCurrentFile2 (file,method,level,raw)
+    unzFile file;
+    int* method;
+    int* level;
+    int raw;
+{
+    return unzOpenCurrentFile3(file, method, level, raw, NULL);
+}
+
+/*
+  Read bytes from the current file.
+  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 int ZEXPORT unzReadCurrentFile  (file, buf, len)
+    unzFile file;
+    voidp buf;
+    unsigned len;
+{
+    int err=UNZ_OK;
+    uInt iRead = 0;
+    unz_s* s;
+    file_in_zip_read_info_s* pfile_in_zip_read_info;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+    if (pfile_in_zip_read_info==NULL)
+        return UNZ_PARAMERROR;
+
+
+    if ((pfile_in_zip_read_info->read_buffer == NULL))
+        return UNZ_END_OF_LIST_OF_FILE;
+    if (len==0)
+        return 0;
+
+    pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
+
+    pfile_in_zip_read_info->stream.avail_out = (uInt)len;
+
+    if ((len>pfile_in_zip_read_info->rest_read_uncompressed) &&
+        (!(pfile_in_zip_read_info->raw)))
+        pfile_in_zip_read_info->stream.avail_out =
+            (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
+
+    if ((len>pfile_in_zip_read_info->rest_read_compressed+
+           pfile_in_zip_read_info->stream.avail_in) &&
+         (pfile_in_zip_read_info->raw))
+        pfile_in_zip_read_info->stream.avail_out =
+            (uInt)pfile_in_zip_read_info->rest_read_compressed+
+            pfile_in_zip_read_info->stream.avail_in;
+
+    while (pfile_in_zip_read_info->stream.avail_out>0)
+    {
+        if ((pfile_in_zip_read_info->stream.avail_in==0) &&
+            (pfile_in_zip_read_info->rest_read_compressed>0))
+        {
+            uInt uReadThis = UNZ_BUFSIZE;
+            if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
+                uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
+            if (uReadThis == 0)
+                return UNZ_EOF;
+            if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
+                      pfile_in_zip_read_info->filestream,
+                      pfile_in_zip_read_info->pos_in_zipfile +
+                         pfile_in_zip_read_info->byte_before_the_zipfile,
+                         ZLIB_FILEFUNC_SEEK_SET)!=0)
+                return UNZ_ERRNO;
+            if (ZREAD(pfile_in_zip_read_info->z_filefunc,
+                      pfile_in_zip_read_info->filestream,
+                      pfile_in_zip_read_info->read_buffer,
+                      uReadThis)!=uReadThis)
+                return UNZ_ERRNO;
+
+
+#            ifndef NOUNCRYPT
+            if(s->encrypted)
+            {
+                uInt i;
+                for(i=0;i<uReadThis;i++)
+                  pfile_in_zip_read_info->read_buffer[i] =
+                      zdecode(s->keys,s->pcrc_32_tab,
+                              pfile_in_zip_read_info->read_buffer[i]);
+            }
+#            endif
+
+
+            pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
+
+            pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
+
+            pfile_in_zip_read_info->stream.next_in =
+                (Bytef*)pfile_in_zip_read_info->read_buffer;
+            pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
+        }
+
+        if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw))
+        {
+            uInt uDoCopy,i ;
+
+            if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
+                (pfile_in_zip_read_info->rest_read_compressed == 0))
+                return (iRead==0) ? UNZ_EOF : iRead;
+
+            if (pfile_in_zip_read_info->stream.avail_out <
+                            pfile_in_zip_read_info->stream.avail_in)
+                uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
+            else
+                uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
+
+            for (i=0;i<uDoCopy;i++)
+                *(pfile_in_zip_read_info->stream.next_out+i) =
+                        *(pfile_in_zip_read_info->stream.next_in+i);
+
+            pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
+                                pfile_in_zip_read_info->stream.next_out,
+                                uDoCopy);
+            pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
+            pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
+            pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
+            pfile_in_zip_read_info->stream.next_out += uDoCopy;
+            pfile_in_zip_read_info->stream.next_in += uDoCopy;
+            pfile_in_zip_read_info->stream.total_out += uDoCopy;
+            iRead += uDoCopy;
+        }
+        else
+        {
+            uLong uTotalOutBefore,uTotalOutAfter;
+            const Bytef *bufBefore;
+            uLong uOutThis;
+            int flush=Z_SYNC_FLUSH;
+
+            uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
+            bufBefore = pfile_in_zip_read_info->stream.next_out;
+
+            /*
+            if ((pfile_in_zip_read_info->rest_read_uncompressed ==
+                     pfile_in_zip_read_info->stream.avail_out) &&
+                (pfile_in_zip_read_info->rest_read_compressed == 0))
+                flush = Z_FINISH;
+            */
+            err=inflate(&pfile_in_zip_read_info->stream,flush);
+
+            if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL))
+              err = Z_DATA_ERROR;
+
+            uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
+            uOutThis = uTotalOutAfter-uTotalOutBefore;
+
+            pfile_in_zip_read_info->crc32 =
+                crc32(pfile_in_zip_read_info->crc32,bufBefore,
+                        (uInt)(uOutThis));
+
+            pfile_in_zip_read_info->rest_read_uncompressed -=
+                uOutThis;
+
+            iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
+
+            if (err==Z_STREAM_END)
+                return (iRead==0) ? UNZ_EOF : iRead;
+            if (err!=Z_OK)
+                break;
+        }
+    }
+
+    if (err==Z_OK)
+        return iRead;
+    return err;
+}
+
+
+/*
+  Give the current position in uncompressed data
+*/
+extern z_off_t ZEXPORT unztell (file)
+    unzFile file;
+{
+    unz_s* s;
+    file_in_zip_read_info_s* pfile_in_zip_read_info;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+    if (pfile_in_zip_read_info==NULL)
+        return UNZ_PARAMERROR;
+
+    return (z_off_t)pfile_in_zip_read_info->stream.total_out;
+}
+
+
+/*
+  return 1 if the end of file was reached, 0 elsewhere
+*/
+extern int ZEXPORT unzeof (file)
+    unzFile file;
+{
+    unz_s* s;
+    file_in_zip_read_info_s* pfile_in_zip_read_info;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+    if (pfile_in_zip_read_info==NULL)
+        return UNZ_PARAMERROR;
+
+    if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
+        return 1;
+    else
+        return 0;
+}
+
+
+
+/*
+  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 that can be read
+
+  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
+*/
+extern int ZEXPORT unzGetLocalExtrafield (file,buf,len)
+    unzFile file;
+    voidp buf;
+    unsigned len;
+{
+    unz_s* s;
+    file_in_zip_read_info_s* pfile_in_zip_read_info;
+    uInt read_now;
+    uLong size_to_read;
+
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+    if (pfile_in_zip_read_info==NULL)
+        return UNZ_PARAMERROR;
+
+    size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
+                pfile_in_zip_read_info->pos_local_extrafield);
+
+    if (buf==NULL)
+        return (int)size_to_read;
+
+    if (len>size_to_read)
+        read_now = (uInt)size_to_read;
+    else
+        read_now = (uInt)len ;
+
+    if (read_now==0)
+        return 0;
+
+    if (ZSEEK(pfile_in_zip_read_info->z_filefunc,
+              pfile_in_zip_read_info->filestream,
+              pfile_in_zip_read_info->offset_local_extrafield +
+              pfile_in_zip_read_info->pos_local_extrafield,
+              ZLIB_FILEFUNC_SEEK_SET)!=0)
+        return UNZ_ERRNO;
+
+    if (ZREAD(pfile_in_zip_read_info->z_filefunc,
+              pfile_in_zip_read_info->filestream,
+              buf,read_now)!=read_now)
+        return UNZ_ERRNO;
+
+    return (int)read_now;
+}
+
+/*
+  Close the file in zip opened with unzipOpenCurrentFile
+  Return UNZ_CRCERROR if all the file was read but the CRC is not good
+*/
+extern int ZEXPORT unzCloseCurrentFile (file)
+    unzFile file;
+{
+    int err=UNZ_OK;
+
+    unz_s* s;
+    file_in_zip_read_info_s* pfile_in_zip_read_info;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+    if (pfile_in_zip_read_info==NULL)
+        return UNZ_PARAMERROR;
+
+
+    if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&
+        (!pfile_in_zip_read_info->raw))
+    {
+        if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
+            err=UNZ_CRCERROR;
+    }
+
+
+    TRYFREE(pfile_in_zip_read_info->read_buffer);
+    pfile_in_zip_read_info->read_buffer = NULL;
+    if (pfile_in_zip_read_info->stream_initialised)
+        inflateEnd(&pfile_in_zip_read_info->stream);
+
+    pfile_in_zip_read_info->stream_initialised = 0;
+    TRYFREE(pfile_in_zip_read_info);
+
+    s->pfile_in_zip_read=NULL;
+
+    return err;
+}
+
+
+/*
+  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
+*/
+extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf)
+    unzFile file;
+    char *szComment;
+    uLong uSizeBuf;
+{
+    unz_s* s;
+    uLong uReadThis ;
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+
+    uReadThis = uSizeBuf;
+    if (uReadThis>s->gi.size_comment)
+        uReadThis = s->gi.size_comment;
+
+    if (ZSEEK(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0)
+        return UNZ_ERRNO;
+
+    if (uReadThis>0)
+    {
+      *szComment='\0';
+      if (ZREAD(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis)
+        return UNZ_ERRNO;
+    }
+
+    if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
+        *(szComment+s->gi.size_comment)='\0';
+    return (int)uReadThis;
+}
+
+/* Additions by RX '2004 */
+extern uLong ZEXPORT unzGetOffset (file)
+    unzFile file;
+{
+    unz_s* s;
+
+    if (file==NULL)
+          return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+    if (!s->current_file_ok)
+      return 0;
+    if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff)
+      if (s->num_file==s->gi.number_entry)
+         return 0;
+    return s->pos_in_central_dir;
+}
+
+extern int ZEXPORT unzSetOffset (file, pos)
+        unzFile file;
+        uLong pos;
+{
+    unz_s* s;
+    int err;
+
+    if (file==NULL)
+        return UNZ_PARAMERROR;
+    s=(unz_s*)file;
+
+    s->pos_in_central_dir = pos;
+    s->num_file = s->gi.number_entry;      /* hack */
+    err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+                                              &s->cur_file_info_internal,
+                                              NULL,0,NULL,0,NULL,0);
+    s->current_file_ok = (err == UNZ_OK);
+    return err;
+}
diff --git a/rbutil/rbutilqt/quazip/unzip.h b/rbutil/rbutilqt/quazip/unzip.h
new file mode 100644
index 0000000000..b247937c80
--- /dev/null
+++ b/rbutil/rbutilqt/quazip/unzip.h
@@ -0,0 +1,354 @@
+/* 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.
+
+
+*/
+
+/* 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((const char *path));
+/*
+  Open a Zip file. path contain the full pathname (by example,
+     on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer
+     "zlib/zlib113.zip".
+     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((const char *path,
+                                    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 */
diff --git a/rbutil/rbutilqt/quazip/zip.c b/rbutil/rbutilqt/quazip/zip.c
new file mode 100644
index 0000000000..13463fe336
--- /dev/null
+++ b/rbutil/rbutilqt/quazip/zip.c
@@ -0,0 +1,1221 @@
+/* zip.c -- IO on .zip files using zlib
+   Version 1.01e, February 12th, 2005
+
+   27 Dec 2004 Rolf Kalbermatter
+   Modification to zipOpen2 to support globalComment retrieval.
+
+   Copyright (C) 1998-2005 Gilles Vollant
+
+   Read zip.h for more info
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include "zlib.h"
+#include "zip.h"
+
+#ifdef STDC
+#  include <stddef.h>
+#  include <string.h>
+#  include <stdlib.h>
+#endif
+#ifdef NO_ERRNO_H
+    extern int errno;
+#else
+#   include <errno.h>
+#endif
+
+
+#ifndef local
+#  define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+#ifndef VERSIONMADEBY
+# define VERSIONMADEBY   (0x0) /* platform depedent */
+#endif
+
+#ifndef Z_BUFSIZE
+#define Z_BUFSIZE (16384)
+#endif
+
+#ifndef Z_MAXFILENAMEINZIP
+#define Z_MAXFILENAMEINZIP (256)
+#endif
+
+#ifndef ALLOC
+# define ALLOC(size) (malloc(size))
+#endif
+#ifndef TRYFREE
+# define TRYFREE(p) {if (p) free(p);}
+#endif
+
+/*
+#define SIZECENTRALDIRITEM (0x2e)
+#define SIZEZIPLOCALHEADER (0x1e)
+*/
+
+/* 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
+
+#ifndef DEF_MEM_LEVEL
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+#endif
+const char zip_copyright[] =
+   " zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
+
+
+#define SIZEDATA_INDATABLOCK (4096-(4*4))
+
+#define LOCALHEADERMAGIC    (0x04034b50)
+#define CENTRALHEADERMAGIC  (0x02014b50)
+#define ENDHEADERMAGIC      (0x06054b50)
+
+#define FLAG_LOCALHEADER_OFFSET (0x06)
+#define CRC_LOCALHEADER_OFFSET  (0x0e)
+
+#define SIZECENTRALHEADER (0x2e) /* 46 */
+
+typedef struct linkedlist_datablock_internal_s
+{
+  struct linkedlist_datablock_internal_s* next_datablock;
+  uLong  avail_in_this_block;
+  uLong  filled_in_this_block;
+  uLong  unused; /* for future use and alignement */
+  unsigned char data[SIZEDATA_INDATABLOCK];
+} linkedlist_datablock_internal;
+
+typedef struct linkedlist_data_s
+{
+    linkedlist_datablock_internal* first_block;
+    linkedlist_datablock_internal* last_block;
+} linkedlist_data;
+
+
+typedef struct
+{
+    z_stream stream;            /* zLib stream structure for inflate */
+    int  stream_initialised;    /* 1 is stream is initialised */
+    uInt pos_in_buffered_data;  /* last written byte in buffered_data */
+
+    uLong pos_local_header;     /* offset of the local header of the file
+                                     currenty writing */
+    char* central_header;       /* central header data for the current file */
+    uLong size_centralheader;   /* size of the central header for cur file */
+    uLong flag;                 /* flag of the file currently writing */
+
+    int  method;                /* compression method of file currenty wr.*/
+    int  raw;                   /* 1 for directly writing raw data */
+    Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/
+    uLong dosDate;
+    uLong crc32;
+    int  encrypt;
+#ifndef NOCRYPT
+    unsigned long keys[3];     /* keys defining the pseudo-random sequence */
+    const unsigned long* pcrc_32_tab;
+    int crypt_header_size;
+#endif
+} curfile_info;
+
+typedef struct
+{
+    zlib_filefunc_def z_filefunc;
+    voidpf filestream;        /* io structore of the zipfile */
+    linkedlist_data central_dir;/* datablock with central dir in construction*/
+    int  in_opened_file_inzip;  /* 1 if a file in the zip is currently writ.*/
+    curfile_info ci;            /* info on the file curretly writing */
+
+    uLong begin_pos;            /* position of the beginning of the zipfile */
+    uLong add_position_when_writting_offset;
+    uLong number_entry;
+#ifndef NO_ADDFILEINEXISTINGZIP
+    char *globalcomment;
+#endif
+} zip_internal;
+
+
+
+#ifndef NOCRYPT
+#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED
+#include "crypt.h"
+#endif
+
+local linkedlist_datablock_internal* allocate_new_datablock()
+{
+    linkedlist_datablock_internal* ldi;
+    ldi = (linkedlist_datablock_internal*)
+                 ALLOC(sizeof(linkedlist_datablock_internal));
+    if (ldi!=NULL)
+    {
+        ldi->next_datablock = NULL ;
+        ldi->filled_in_this_block = 0 ;
+        ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ;
+    }
+    return ldi;
+}
+
+local void free_datablock(ldi)
+    linkedlist_datablock_internal* ldi;
+{
+    while (ldi!=NULL)
+    {
+        linkedlist_datablock_internal* ldinext = ldi->next_datablock;
+        TRYFREE(ldi);
+        ldi = ldinext;
+    }
+}
+
+local void init_linkedlist(ll)
+    linkedlist_data* ll;
+{
+    ll->first_block = ll->last_block = NULL;
+}
+
+#if 0 // unused
+local void free_linkedlist(ll)
+    linkedlist_data* ll;
+{
+    free_datablock(ll->first_block);
+    ll->first_block = ll->last_block = NULL;
+}
+#endif
+
+local int add_data_in_datablock(ll,buf,len)
+    linkedlist_data* ll;
+    const void* buf;
+    uLong len;
+{
+    linkedlist_datablock_internal* ldi;
+    const unsigned char* from_copy;
+
+    if (ll==NULL)
+        return ZIP_INTERNALERROR;
+
+    if (ll->last_block == NULL)
+    {
+        ll->first_block = ll->last_block = allocate_new_datablock();
+        if (ll->first_block == NULL)
+            return ZIP_INTERNALERROR;
+    }
+
+    ldi = ll->last_block;
+    from_copy = (unsigned char*)buf;
+
+    while (len>0)
+    {
+        uInt copy_this;
+        uInt i;
+        unsigned char* to_copy;
+
+        if (ldi->avail_in_this_block==0)
+        {
+            ldi->next_datablock = allocate_new_datablock();
+            if (ldi->next_datablock == NULL)
+                return ZIP_INTERNALERROR;
+            ldi = ldi->next_datablock ;
+            ll->last_block = ldi;
+        }
+
+        if (ldi->avail_in_this_block < len)
+            copy_this = (uInt)ldi->avail_in_this_block;
+        else
+            copy_this = (uInt)len;
+
+        to_copy = &(ldi->data[ldi->filled_in_this_block]);
+
+        for (i=0;i<copy_this;i++)
+            *(to_copy+i)=*(from_copy+i);
+
+        ldi->filled_in_this_block += copy_this;
+        ldi->avail_in_this_block -= copy_this;
+        from_copy += copy_this ;
+        len -= copy_this;
+    }
+    return ZIP_OK;
+}
+
+
+
+/****************************************************************************/
+
+#ifndef NO_ADDFILEINEXISTINGZIP
+/* ===========================================================================
+   Inputs a long in LSB order to the given file
+   nbByte == 1, 2 or 4 (byte, short or long)
+*/
+
+local int ziplocal_putValue OF((const zlib_filefunc_def* pzlib_filefunc_def,
+                                voidpf filestream, uLong x, int nbByte));
+local int ziplocal_putValue (pzlib_filefunc_def, filestream, x, nbByte)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+    uLong x;
+    int nbByte;
+{
+    unsigned char buf[4];
+    int n;
+    for (n = 0; n < nbByte; n++)
+    {
+        buf[n] = (unsigned char)(x & 0xff);
+        x >>= 8;
+    }
+    if (x != 0)
+      {     /* data overflow - hack for ZIP64 (X Roche) */
+      for (n = 0; n < nbByte; n++)
+        {
+          buf[n] = 0xff;
+        }
+      }
+
+    if (ZWRITE(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte)
+        return ZIP_ERRNO;
+    else
+        return ZIP_OK;
+}
+
+local void ziplocal_putValue_inmemory OF((void* dest, uLong x, int nbByte));
+local void ziplocal_putValue_inmemory (dest, x, nbByte)
+    void* dest;
+    uLong x;
+    int nbByte;
+{
+    unsigned char* buf=(unsigned char*)dest;
+    int n;
+    for (n = 0; n < nbByte; n++) {
+        buf[n] = (unsigned char)(x & 0xff);
+        x >>= 8;
+    }
+
+    if (x != 0)
+    {     /* data overflow - hack for ZIP64 */
+       for (n = 0; n < nbByte; n++)
+       {
+          buf[n] = 0xff;
+       }
+    }
+}
+
+/****************************************************************************/
+
+
+local uLong ziplocal_TmzDateToDosDate(ptm,dosDate)
+    const tm_zip* ptm;
+    uLong dosDate;
+{
+    (void) dosDate; /* avoid "unused parameter" warning */
+    uLong year = (uLong)ptm->tm_year;
+    if (year>1980)
+        year-=1980;
+    else if (year>80)
+        year-=80;
+    return
+      (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) |
+        ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));
+}
+
+
+/****************************************************************************/
+
+local int ziplocal_getByte OF((
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream,
+    int *pi));
+
+local int ziplocal_getByte(pzlib_filefunc_def,filestream,pi)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+    int *pi;
+{
+    unsigned char c;
+    int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1);
+    if (err==1)
+    {
+        *pi = (int)c;
+        return ZIP_OK;
+    }
+    else
+    {
+        if (ZERROR(*pzlib_filefunc_def,filestream))
+            return ZIP_ERRNO;
+        else
+            return ZIP_EOF;
+    }
+}
+
+
+/* ===========================================================================
+   Reads a long in LSB order from the given gz_stream. Sets
+*/
+local int ziplocal_getShort OF((
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream,
+    uLong *pX));
+
+local int ziplocal_getShort (pzlib_filefunc_def,filestream,pX)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+    uLong *pX;
+{
+    uLong x ;
+    int i;
+    int err;
+
+    err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x = (uLong)i;
+
+    if (err==ZIP_OK)
+        err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<8;
+
+    if (err==ZIP_OK)
+        *pX = x;
+    else
+        *pX = 0;
+    return err;
+}
+
+local int ziplocal_getLong OF((
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream,
+    uLong *pX));
+
+local int ziplocal_getLong (pzlib_filefunc_def,filestream,pX)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+    uLong *pX;
+{
+    uLong x ;
+    int i;
+    int err;
+
+    err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x = (uLong)i;
+
+    if (err==ZIP_OK)
+        err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<8;
+
+    if (err==ZIP_OK)
+        err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<16;
+
+    if (err==ZIP_OK)
+        err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i);
+    x += ((uLong)i)<<24;
+
+    if (err==ZIP_OK)
+        *pX = x;
+    else
+        *pX = 0;
+    return err;
+}
+
+#ifndef BUFREADCOMMENT
+#define BUFREADCOMMENT (0x400)
+#endif
+/*
+  Locate the Central directory of a zipfile (at the end, just before
+    the global comment)
+*/
+local uLong ziplocal_SearchCentralDir OF((
+    const zlib_filefunc_def* pzlib_filefunc_def,
+    voidpf filestream));
+
+local uLong ziplocal_SearchCentralDir(pzlib_filefunc_def,filestream)
+    const zlib_filefunc_def* pzlib_filefunc_def;
+    voidpf filestream;
+{
+    unsigned char* buf;
+    uLong uSizeFile;
+    uLong uBackRead;
+    uLong uMaxBack=0xffff; /* maximum size of global comment */
+    uLong uPosFound=0;
+
+    if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
+        return 0;
+
+
+    uSizeFile = ZTELL(*pzlib_filefunc_def,filestream);
+
+    if (uMaxBack>uSizeFile)
+        uMaxBack = uSizeFile;
+
+    buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
+    if (buf==NULL)
+        return 0;
+
+    uBackRead = 4;
+    while (uBackRead<uMaxBack)
+    {
+        uLong uReadSize,uReadPos ;
+        int i;
+        if (uBackRead+BUFREADCOMMENT>uMaxBack)
+            uBackRead = uMaxBack;
+        else
+            uBackRead+=BUFREADCOMMENT;
+        uReadPos = uSizeFile-uBackRead ;
+
+        uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
+                     (BUFREADCOMMENT+4) : (uSizeFile-uReadPos);
+        if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+            break;
+
+        if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
+            break;
+
+        for (i=(int)uReadSize-3; (i--)>0;)
+            if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
+                ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
+            {
+                uPosFound = uReadPos+i;
+                break;
+            }
+
+        if (uPosFound!=0)
+            break;
+    }
+    TRYFREE(buf);
+    return uPosFound;
+}
+#endif /* !NO_ADDFILEINEXISTINGZIP*/
+
+/************************************************************/
+extern zipFile ZEXPORT zipOpen2 (pathname, append, globalcomment, pzlib_filefunc_def)
+    const char *pathname;
+    int append;
+    zipcharpc* globalcomment;
+    zlib_filefunc_def* pzlib_filefunc_def;
+{
+    zip_internal ziinit;
+    zip_internal* zi;
+    int err=ZIP_OK;
+
+
+    if (pzlib_filefunc_def==NULL)
+        fill_fopen_filefunc(&ziinit.z_filefunc);
+    else
+        ziinit.z_filefunc = *pzlib_filefunc_def;
+
+    ziinit.filestream = (*(ziinit.z_filefunc.zopen_file))
+                 (ziinit.z_filefunc.opaque,
+                  pathname,
+                  (append == APPEND_STATUS_CREATE) ?
+                  (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) :
+                    (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING));
+
+    if (ziinit.filestream == NULL)
+        return NULL;
+    ziinit.begin_pos = ZTELL(ziinit.z_filefunc,ziinit.filestream);
+    ziinit.in_opened_file_inzip = 0;
+    ziinit.ci.stream_initialised = 0;
+    ziinit.number_entry = 0;
+    ziinit.add_position_when_writting_offset = 0;
+    init_linkedlist(&(ziinit.central_dir));
+
+
+    zi = (zip_internal*)ALLOC(sizeof(zip_internal));
+    if (zi==NULL)
+    {
+        ZCLOSE(ziinit.z_filefunc,ziinit.filestream);
+        return NULL;
+    }
+
+    /* now we add file in a zipfile */
+#    ifndef NO_ADDFILEINEXISTINGZIP
+    ziinit.globalcomment = NULL;
+    if (append == APPEND_STATUS_ADDINZIP)
+    {
+        uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
+
+        uLong size_central_dir;     /* size of the central directory  */
+        uLong offset_central_dir;   /* offset of start of central directory */
+        uLong central_pos,uL;
+
+        uLong number_disk;          /* number of the current dist, used for
+                                    spaning ZIP, unsupported, always 0*/
+        uLong number_disk_with_CD;  /* number the the disk with central dir, used
+                                    for spaning ZIP, unsupported, always 0*/
+        uLong number_entry;
+        uLong number_entry_CD;      /* total number of entries in
+                                    the central dir
+                                    (same than number_entry on nospan) */
+        uLong size_comment;
+
+        central_pos = ziplocal_SearchCentralDir(&ziinit.z_filefunc,ziinit.filestream);
+        if (central_pos==0)
+            err=ZIP_ERRNO;
+
+        if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
+                                        central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+            err=ZIP_ERRNO;
+
+        /* the signature, already checked */
+        if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&uL)!=ZIP_OK)
+            err=ZIP_ERRNO;
+
+        /* number of this disk */
+        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk)!=ZIP_OK)
+            err=ZIP_ERRNO;
+
+        /* number of the disk with the start of the central directory */
+        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk_with_CD)!=ZIP_OK)
+            err=ZIP_ERRNO;
+
+        /* total number of entries in the central dir on this disk */
+        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry)!=ZIP_OK)
+            err=ZIP_ERRNO;
+
+        /* total number of entries in the central dir */
+        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry_CD)!=ZIP_OK)
+            err=ZIP_ERRNO;
+
+        if ((number_entry_CD!=number_entry) ||
+            (number_disk_with_CD!=0) ||
+            (number_disk!=0))
+            err=ZIP_BADZIPFILE;
+
+        /* size of the central directory */
+        if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&size_central_dir)!=ZIP_OK)
+            err=ZIP_ERRNO;
+
+        /* offset of start of central directory with respect to the
+            starting disk number */
+        if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&offset_central_dir)!=ZIP_OK)
+            err=ZIP_ERRNO;
+
+        /* zipfile global comment length */
+        if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&size_comment)!=ZIP_OK)
+            err=ZIP_ERRNO;
+
+        if ((central_pos<offset_central_dir+size_central_dir) &&
+            (err==ZIP_OK))
+            err=ZIP_BADZIPFILE;
+
+        if (err!=ZIP_OK)
+        {
+            ZCLOSE(ziinit.z_filefunc, ziinit.filestream);
+            return NULL;
+        }
+
+        if (size_comment>0)
+        {
+            ziinit.globalcomment = ALLOC(size_comment+1);
+            if (ziinit.globalcomment)
+            {
+               size_comment = ZREAD(ziinit.z_filefunc, ziinit.filestream,ziinit.globalcomment,size_comment);
+               ziinit.globalcomment[size_comment]=0;
+            }
+        }
+
+        byte_before_the_zipfile = central_pos -
+                                (offset_central_dir+size_central_dir);
+        ziinit.add_position_when_writting_offset = byte_before_the_zipfile;
+
+        {
+            uLong size_central_dir_to_read = size_central_dir;
+            size_t buf_size = SIZEDATA_INDATABLOCK;
+            void* buf_read = (void*)ALLOC(buf_size);
+            if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
+                  offset_central_dir + byte_before_the_zipfile,
+                  ZLIB_FILEFUNC_SEEK_SET) != 0)
+                  err=ZIP_ERRNO;
+
+            while ((size_central_dir_to_read>0) && (err==ZIP_OK))
+            {
+                uLong read_this = SIZEDATA_INDATABLOCK;
+                if (read_this > size_central_dir_to_read)
+                    read_this = size_central_dir_to_read;
+                if (ZREAD(ziinit.z_filefunc, ziinit.filestream,buf_read,read_this) != read_this)
+                    err=ZIP_ERRNO;
+
+                if (err==ZIP_OK)
+                    err = add_data_in_datablock(&ziinit.central_dir,buf_read,
+                                                (uLong)read_this);
+                size_central_dir_to_read-=read_this;
+            }
+            TRYFREE(buf_read);
+        }
+        ziinit.begin_pos = byte_before_the_zipfile;
+        ziinit.number_entry = number_entry_CD;
+
+        if (ZSEEK(ziinit.z_filefunc, ziinit.filestream,
+                  offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
+            err=ZIP_ERRNO;
+    }
+
+    if (globalcomment)
+    {
+      *globalcomment = ziinit.globalcomment;
+    }
+#    endif /* !NO_ADDFILEINEXISTINGZIP*/
+
+    if (err != ZIP_OK)
+    {
+#    ifndef NO_ADDFILEINEXISTINGZIP
+        TRYFREE(ziinit.globalcomment);
+#    endif /* !NO_ADDFILEINEXISTINGZIP*/
+        TRYFREE(zi);
+        return NULL;
+    }
+    else
+    {
+        *zi = ziinit;
+        return (zipFile)zi;
+    }
+}
+
+extern zipFile ZEXPORT zipOpen (pathname, append)
+    const char *pathname;
+    int append;
+{
+    return zipOpen2(pathname,append,NULL,NULL);
+}
+
+extern int ZEXPORT zipOpenNewFileInZip3 (file, filename, zipfi,
+                                         extrafield_local, size_extrafield_local,
+                                         extrafield_global, size_extrafield_global,
+                                         comment, method, level, raw,
+                                         windowBits, memLevel, strategy,
+                                         password, crcForCrypting)
+    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 crcForCrypting;
+{
+    zip_internal* zi;
+    uInt size_filename;
+    uInt size_comment;
+    uInt i;
+    int err = ZIP_OK;
+
+#    ifdef NOCRYPT
+    if (password != NULL)
+        return ZIP_PARAMERROR;
+#    endif
+
+    if (file == NULL)
+        return ZIP_PARAMERROR;
+    if ((method!=0) && (method!=Z_DEFLATED))
+        return ZIP_PARAMERROR;
+
+    zi = (zip_internal*)file;
+
+    if (zi->in_opened_file_inzip == 1)
+    {
+        err = zipCloseFileInZip (file);
+        if (err != ZIP_OK)
+            return err;
+    }
+
+
+    if (filename==NULL)
+        filename="-";
+
+    if (comment==NULL)
+        size_comment = 0;
+    else
+        size_comment = (uInt)strlen(comment);
+
+    size_filename = (uInt)strlen(filename);
+
+    if (zipfi == NULL)
+        zi->ci.dosDate = 0;
+    else
+    {
+        if (zipfi->dosDate != 0)
+            zi->ci.dosDate = zipfi->dosDate;
+        else zi->ci.dosDate = ziplocal_TmzDateToDosDate(&zipfi->tmz_date,zipfi->dosDate);
+    }
+
+    zi->ci.flag = 0;
+    if ((level==8) || (level==9))
+      zi->ci.flag |= 2;
+    if ((level==2))
+      zi->ci.flag |= 4;
+    if ((level==1))
+      zi->ci.flag |= 6;
+    if (password != NULL)
+      zi->ci.flag |= 1;
+
+    zi->ci.crc32 = 0;
+    zi->ci.method = method;
+    zi->ci.encrypt = 0;
+    zi->ci.stream_initialised = 0;
+    zi->ci.pos_in_buffered_data = 0;
+    zi->ci.raw = raw;
+    zi->ci.pos_local_header = ZTELL(zi->z_filefunc,zi->filestream) ;
+    zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename +
+                                      size_extrafield_global + size_comment;
+    zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader);
+
+    ziplocal_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4);
+    /* version info */
+    ziplocal_putValue_inmemory(zi->ci.central_header+4,(uLong)VERSIONMADEBY,2);
+    ziplocal_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2);
+    ziplocal_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2);
+    ziplocal_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2);
+    ziplocal_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4);
+    ziplocal_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/
+    ziplocal_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/
+    ziplocal_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/
+    ziplocal_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2);
+    ziplocal_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2);
+    ziplocal_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2);
+    ziplocal_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/
+
+    if (zipfi==NULL)
+        ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2);
+    else
+        ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2);
+
+    if (zipfi==NULL)
+        ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4);
+    else
+        ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4);
+
+    ziplocal_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header- zi->add_position_when_writting_offset,4);
+
+    for (i=0;i<size_filename;i++)
+        *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i);
+
+    for (i=0;i<size_extrafield_global;i++)
+        *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) =
+              *(((const char*)extrafield_global)+i);
+
+    for (i=0;i<size_comment;i++)
+        *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+
+              size_extrafield_global+i) = *(comment+i);
+    if (zi->ci.central_header == NULL)
+        return ZIP_INTERNALERROR;
+
+    /* write the local header */
+    err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC,4);
+
+    if (err==ZIP_OK)
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */
+    if (err==ZIP_OK)
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2);
+
+    if (err==ZIP_OK)
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2);
+
+    if (err==ZIP_OK)
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4);
+
+    if (err==ZIP_OK)
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */
+    if (err==ZIP_OK)
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */
+    if (err==ZIP_OK)
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */
+
+    if (err==ZIP_OK)
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2);
+
+    if (err==ZIP_OK)
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield_local,2);
+
+    if ((err==ZIP_OK) && (size_filename>0))
+        if (ZWRITE(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename)
+                err = ZIP_ERRNO;
+
+    if ((err==ZIP_OK) && (size_extrafield_local>0))
+        if (ZWRITE(zi->z_filefunc,zi->filestream,extrafield_local,size_extrafield_local)
+                                                                           !=size_extrafield_local)
+                err = ZIP_ERRNO;
+
+    zi->ci.stream.avail_in = (uInt)0;
+    zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
+    zi->ci.stream.next_out = zi->ci.buffered_data;
+    zi->ci.stream.total_in = 0;
+    zi->ci.stream.total_out = 0;
+
+    if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+    {
+        zi->ci.stream.zalloc = (alloc_func)0;
+        zi->ci.stream.zfree = (free_func)0;
+        zi->ci.stream.opaque = (voidpf)0;
+
+        if (windowBits>0)
+            windowBits = -windowBits;
+
+        err = deflateInit2(&zi->ci.stream, level,
+               Z_DEFLATED, windowBits, memLevel, strategy);
+
+        if (err==Z_OK)
+            zi->ci.stream_initialised = 1;
+    }
+#    ifndef NOCRYPT
+    zi->ci.crypt_header_size = 0;
+    if ((err==Z_OK) && (password != NULL))
+    {
+        unsigned char bufHead[RAND_HEAD_LEN];
+        unsigned int sizeHead;
+        zi->ci.encrypt = 1;
+        zi->ci.pcrc_32_tab = get_crc_table();
+        /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/
+
+        sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting);
+        zi->ci.crypt_header_size = sizeHead;
+
+        if (ZWRITE(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead)
+                err = ZIP_ERRNO;
+    }
+#    endif
+
+    if (err==Z_OK)
+        zi->in_opened_file_inzip = 1;
+    return err;
+}
+
+extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi,
+                                        extrafield_local, size_extrafield_local,
+                                        extrafield_global, size_extrafield_global,
+                                        comment, method, level, raw)
+    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;
+{
+    return zipOpenNewFileInZip3 (file, filename, zipfi,
+                                 extrafield_local, size_extrafield_local,
+                                 extrafield_global, size_extrafield_global,
+                                 comment, method, level, raw,
+                                 -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
+                                 NULL, 0);
+}
+
+extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi,
+                                        extrafield_local, size_extrafield_local,
+                                        extrafield_global, size_extrafield_global,
+                                        comment, method, level)
+    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;
+{
+    return zipOpenNewFileInZip2 (file, filename, zipfi,
+                                 extrafield_local, size_extrafield_local,
+                                 extrafield_global, size_extrafield_global,
+                                 comment, method, level, 0);
+}
+
+local int zipFlushWriteBuffer(zi)
+  zip_internal* zi;
+{
+    int err=ZIP_OK;
+
+    if (zi->ci.encrypt != 0)
+    {
+#ifndef NOCRYPT
+        uInt i;
+        int t;
+        for (i=0;i<zi->ci.pos_in_buffered_data;i++)
+            zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab,
+                                       zi->ci.buffered_data[i],t);
+#endif
+    }
+    if (ZWRITE(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data)
+                                                                    !=zi->ci.pos_in_buffered_data)
+      err = ZIP_ERRNO;
+    zi->ci.pos_in_buffered_data = 0;
+    return err;
+}
+
+extern int ZEXPORT zipWriteInFileInZip (file, buf, len)
+    zipFile file;
+    const void* buf;
+    unsigned len;
+{
+    zip_internal* zi;
+    int err=ZIP_OK;
+
+    if (file == NULL)
+        return ZIP_PARAMERROR;
+    zi = (zip_internal*)file;
+
+    if (zi->in_opened_file_inzip == 0)
+        return ZIP_PARAMERROR;
+
+    zi->ci.stream.next_in = (void*)buf;
+    zi->ci.stream.avail_in = len;
+    zi->ci.crc32 = crc32(zi->ci.crc32,buf,len);
+
+    while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))
+    {
+        if (zi->ci.stream.avail_out == 0)
+        {
+            if (zipFlushWriteBuffer(zi) == ZIP_ERRNO)
+                err = ZIP_ERRNO;
+            zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
+            zi->ci.stream.next_out = zi->ci.buffered_data;
+        }
+
+
+        if(err != ZIP_OK)
+            break;
+
+        if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+        {
+            uLong uTotalOutBefore = zi->ci.stream.total_out;
+            err=deflate(&zi->ci.stream,  Z_NO_FLUSH);
+            zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
+
+        }
+        else
+        {
+            uInt copy_this,i;
+            if (zi->ci.stream.avail_in < zi->ci.stream.avail_out)
+                copy_this = zi->ci.stream.avail_in;
+            else
+                copy_this = zi->ci.stream.avail_out;
+            for (i=0;i<copy_this;i++)
+                *(((char*)zi->ci.stream.next_out)+i) =
+                    *(((const char*)zi->ci.stream.next_in)+i);
+            {
+                zi->ci.stream.avail_in -= copy_this;
+                zi->ci.stream.avail_out-= copy_this;
+                zi->ci.stream.next_in+= copy_this;
+                zi->ci.stream.next_out+= copy_this;
+                zi->ci.stream.total_in+= copy_this;
+                zi->ci.stream.total_out+= copy_this;
+                zi->ci.pos_in_buffered_data += copy_this;
+            }
+        }
+    }
+
+    return err;
+}
+
+extern int ZEXPORT zipCloseFileInZipRaw (file, uncompressed_size, crc32)
+    zipFile file;
+    uLong uncompressed_size;
+    uLong crc32;
+{
+    zip_internal* zi;
+    uLong compressed_size;
+    int err=ZIP_OK;
+
+    if (file == NULL)
+        return ZIP_PARAMERROR;
+    zi = (zip_internal*)file;
+
+    if (zi->in_opened_file_inzip == 0)
+        return ZIP_PARAMERROR;
+    zi->ci.stream.avail_in = 0;
+
+    if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+        while (err==ZIP_OK)
+    {
+        uLong uTotalOutBefore;
+        if (zi->ci.stream.avail_out == 0)
+        {
+            if (zipFlushWriteBuffer(zi) == ZIP_ERRNO)
+                err = ZIP_ERRNO;
+            zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
+            zi->ci.stream.next_out = zi->ci.buffered_data;
+        }
+        uTotalOutBefore = zi->ci.stream.total_out;
+        err=deflate(&zi->ci.stream,  Z_FINISH);
+        zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
+    }
+
+    if (err==Z_STREAM_END)
+        err=ZIP_OK; /* this is normal */
+
+    if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK))
+        if (zipFlushWriteBuffer(zi)==ZIP_ERRNO)
+            err = ZIP_ERRNO;
+
+    if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+    {
+        err=deflateEnd(&zi->ci.stream);
+        zi->ci.stream_initialised = 0;
+    }
+
+    if (!zi->ci.raw)
+    {
+        crc32 = (uLong)zi->ci.crc32;
+        uncompressed_size = (uLong)zi->ci.stream.total_in;
+    }
+    compressed_size = (uLong)zi->ci.stream.total_out;
+#    ifndef NOCRYPT
+    compressed_size += zi->ci.crypt_header_size;
+#    endif
+
+    ziplocal_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/
+    ziplocal_putValue_inmemory(zi->ci.central_header+20,
+                                compressed_size,4); /*compr size*/
+    if (zi->ci.stream.data_type == Z_ASCII)
+        ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2);
+    ziplocal_putValue_inmemory(zi->ci.central_header+24,
+                                uncompressed_size,4); /*uncompr size*/
+
+    if (err==ZIP_OK)
+        err = add_data_in_datablock(&zi->central_dir,zi->ci.central_header,
+                                       (uLong)zi->ci.size_centralheader);
+    free(zi->ci.central_header);
+
+    if (err==ZIP_OK)
+    {
+        long cur_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
+        if (ZSEEK(zi->z_filefunc,zi->filestream,
+                  zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0)
+            err = ZIP_ERRNO;
+
+        if (err==ZIP_OK)
+            err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */
+
+        if (err==ZIP_OK) /* compressed size, unknown */
+            err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4);
+
+        if (err==ZIP_OK) /* uncompressed size, unknown */
+            err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4);
+
+        if (ZSEEK(zi->z_filefunc,zi->filestream,
+                  cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0)
+            err = ZIP_ERRNO;
+    }
+
+    zi->number_entry ++;
+    zi->in_opened_file_inzip = 0;
+
+    return err;
+}
+
+extern int ZEXPORT zipCloseFileInZip (file)
+    zipFile file;
+{
+    return zipCloseFileInZipRaw (file,0,0);
+}
+
+extern int ZEXPORT zipClose (file, global_comment)
+    zipFile file;
+    const char* global_comment;
+{
+    zip_internal* zi;
+    int err = 0;
+    uLong size_centraldir = 0;
+    uLong centraldir_pos_inzip;
+    uInt size_global_comment;
+    if (file == NULL)
+        return ZIP_PARAMERROR;
+    zi = (zip_internal*)file;
+
+    if (zi->in_opened_file_inzip == 1)
+    {
+        err = zipCloseFileInZip (file);
+    }
+
+#ifndef NO_ADDFILEINEXISTINGZIP
+    if (global_comment==NULL)
+        global_comment = zi->globalcomment;
+#endif
+    if (global_comment==NULL)
+        size_global_comment = 0;
+    else
+        size_global_comment = (uInt)strlen(global_comment);
+
+    centraldir_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream);
+    if (err==ZIP_OK)
+    {
+        linkedlist_datablock_internal* ldi = zi->central_dir.first_block ;
+        while (ldi!=NULL)
+        {
+            if ((err==ZIP_OK) && (ldi->filled_in_this_block>0))
+                if (ZWRITE(zi->z_filefunc,zi->filestream,
+                           ldi->data,ldi->filled_in_this_block)
+                              !=ldi->filled_in_this_block )
+                    err = ZIP_ERRNO;
+
+            size_centraldir += ldi->filled_in_this_block;
+            ldi = ldi->next_datablock;
+        }
+    }
+    free_datablock(zi->central_dir.first_block);
+
+    if (err==ZIP_OK) /* Magic End */
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4);
+
+    if (err==ZIP_OK) /* number of this disk */
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
+
+    if (err==ZIP_OK) /* number of the disk with the start of the central directory */
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
+
+    if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
+
+    if (err==ZIP_OK) /* total number of entries in the central dir */
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
+
+    if (err==ZIP_OK) /* size of the central directory */
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4);
+
+    if (err==ZIP_OK) /* offset of start of central directory with respect to the
+                            starting disk number */
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,
+                                (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4);
+
+    if (err==ZIP_OK) /* zipfile comment length */
+        err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2);
+
+    if ((err==ZIP_OK) && (size_global_comment>0))
+        if (ZWRITE(zi->z_filefunc,zi->filestream,
+                   global_comment,size_global_comment) != size_global_comment)
+                err = ZIP_ERRNO;
+
+    if (ZCLOSE(zi->z_filefunc,zi->filestream) != 0)
+        if (err == ZIP_OK)
+            err = ZIP_ERRNO;
+
+#ifndef NO_ADDFILEINEXISTINGZIP
+    TRYFREE(zi->globalcomment);
+#endif
+    TRYFREE(zi);
+
+    return err;
+}
diff --git a/rbutil/rbutilqt/quazip/zip.h b/rbutil/rbutilqt/quazip/zip.h
new file mode 100644
index 0000000000..acacce83b9
--- /dev/null
+++ b/rbutil/rbutilqt/quazip/zip.h
@@ -0,0 +1,235 @@
+/* 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.
+
+
+*/
+
+/* 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)
+
+#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((const char *pathname, int append));
+/*
+  Create a zipfile.
+     pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on
+       an Unix computer "zlib/zlib113.zip".
+     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((const char *pathname,
+                                   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
+*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _zip_H */
diff --git a/rbutil/rbutilqt/rbutilqt.cpp b/rbutil/rbutilqt/rbutilqt.cpp
index 328fb5d8c7..f7ae202ab0 100644
--- a/rbutil/rbutilqt/rbutilqt.cpp
+++ b/rbutil/rbutilqt/rbutilqt.cpp
@@ -32,13 +32,13 @@
 #include "uninstallwindow.h"
 #include "utils.h"
 #include "rockboxinfo.h"
-#include "rbzip.h"
 #include "sysinfo.h"
 #include "system.h"
 #include "systrace.h"
 #include "rbsettings.h"
 #include "serverinfo.h"
 #include "systeminfo.h"
+#include "ziputil.h"
 
 #include "progressloggerinterface.h"
 
@@ -578,6 +578,7 @@ bool RbUtilQt::installAuto()
            tr("Rockbox installation detected. Do you want to backup first?"),
            QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes)
         {
+            bool result;
             logger->addItem(tr("Starting backup..."),LOGINFO);
             QString backupName = RbSettings::value(RbSettings::Mountpoint).toString()
                 + "/.backup/rockbox-backup-" + rbinfo.version() + ".zip";
@@ -590,11 +591,19 @@ bool RbUtilQt::installAuto()
                 a.mkpath(backupFile.path());
             }
 
+            logger->addItem(tr("Beginning Backup..."),LOGINFO);
+            QCoreApplication::processEvents();
+
             //! create backup
-            RbZip backup;
-            connect(&backup,SIGNAL(zipProgress(int,int)),logger, SLOT(setProgress(int,int)));
-            if(backup.createZip(backupName,
-                RbSettings::value(RbSettings::Mountpoint).toString() + "/.rockbox") == Zip::Ok)
+            ZipUtil zip(this);
+            connect(&zip, SIGNAL(logProgress(int, int)), logger, SLOT(setProgress(int, int)));
+            connect(&zip, SIGNAL(logItem(QString, int)), logger, SLOT(addItem(QString, int)));
+            zip.open(backupName, QuaZip::mdCreate);
+            QString mp = RbSettings::value(RbSettings::Mountpoint).toString();
+            QString folder = mp + "/.rockbox";
+            result = zip.appendDirToArchive(folder, mp);
+            zip.close();
+            if(result)
             {
                 logger->addItem(tr("Backup successful"),LOGOK);
             }
@@ -1262,13 +1271,13 @@ void RbUtilQt::checkUpdate(void)
 #elif defined(Q_OS_MACX)
     url += "macosx/";
 #endif
-    
+
     update = new HttpGet(this);
     connect(update, SIGNAL(done(bool)), this, SLOT(downloadUpdateDone(bool)));
     connect(qApp, SIGNAL(lastWindowClosed()), update, SLOT(abort()));
     if(RbSettings::value(RbSettings::CacheOffline).toBool())
         update->setCache(true);
-   
+
     ui.statusbar->showMessage(tr("Checking for update ..."));
     update->getFile(QUrl(url));
 }
@@ -1289,7 +1298,7 @@ void RbUtilQt::downloadUpdateDone(bool error)
             rbutilList << searchString.cap(1);
             pos += searchString.matchedLength();
         }
-        qDebug() << "[Checkupdate] " << rbutilList;
+        qDebug() << "[RbUtilQt] Checking for update";
 
         QString newVersion = "";
         QString foundVersion = "";
diff --git a/rbutil/rbutilqt/rbutilqt.pri b/rbutil/rbutilqt/rbutilqt.pri
index 63d182a0ab..88977c1da3 100644
--- a/rbutil/rbutilqt/rbutilqt.pri
+++ b/rbutil/rbutilqt/rbutilqt.pri
@@ -22,8 +22,6 @@ SOURCES += \
  installwindow.cpp \
  base/httpget.cpp \
  configure.cpp \
- zip/zip.cpp \
- zip/unzip.cpp \
  base/zipinstaller.cpp \
  progressloggergui.cpp \
  installtalkwindow.cpp \
@@ -53,8 +51,6 @@ SOURCES += \
  base/rbsettings.cpp \
  base/serverinfo.cpp \
  base/systeminfo.cpp \
- base/rbunzip.cpp \
- base/rbzip.cpp \
  base/system.cpp \
  sysinfo.cpp \
  systrace.cpp \
@@ -71,6 +67,13 @@ SOURCES += \
  base/rockboxinfo.cpp \
  ../../tools/mkboot.c \
  ../../tools/iriver.c \
+ quazip/quazip.cpp \
+ quazip/quazipfile.cpp \
+ quazip/quazipnewinfo.cpp \
+ quazip/unzip.c \
+ quazip/zip.c \
+ quazip/ioapi.c \
+ base/ziputil.cpp \
 
 
 HEADERS += \
@@ -78,11 +81,6 @@ HEADERS += \
  installwindow.h \
  base/httpget.h \
  configure.h \
- zip/zip.h \
- zip/unzip.h \
- zip/zipentry_p.h \
- zip/unzip_p.h \
- zip/zip_p.h \
  version.h \
  base/zipinstaller.h \
  installtalkwindow.h \
@@ -120,8 +118,6 @@ HEADERS += \
  base/rbsettings.h \
  base/serverinfo.h \
  base/systeminfo.h \
- base/rbunzip.h \
- base/rbzip.h \
  sysinfo.h \
  base/system.h \
  systrace.h \
@@ -138,6 +134,16 @@ HEADERS += \
  base/rockboxinfo.h \
  ../../tools/mkboot.h \
  ../../tools/iriver.h \
+ quazip/crypt.h \
+ quazip/ioapi.h \
+ quazip/quazipfile.h \
+ quazip/quazipfileinfo.h \
+ quazip/quazip.h \
+ quazip/quazipnewinfo.h \
+ quazip/unzip.h \
+ quazip/zip.h \
+ base/ziputil.h \
+
 
 FORMS += \
  rbutilqtfrm.ui \
diff --git a/rbutil/rbutilqt/rbutilqt.pro b/rbutil/rbutilqt/rbutilqt.pro
index 13667dd25b..c2e3c93f13 100644
--- a/rbutil/rbutilqt/rbutilqt.pro
+++ b/rbutil/rbutilqt/rbutilqt.pro
@@ -110,7 +110,7 @@ QMAKE_EXTRA_TARGETS += lrelease
 
 # Needed by QT on Win
 INCLUDEPATH = $$_PRO_FILE_PWD_ $$_PRO_FILE_PWD_/irivertools \
-            $$_PRO_FILE_PWD_/zip $$_PRO_FILE_PWD_/zlib $$_PRO_FILE_PWD_/base
+            $$_PRO_FILE_PWD_/quazip $$_PRO_FILE_PWD_/zlib $$_PRO_FILE_PWD_/base
 INCLUDEPATH += $$RBBASE_DIR/rbutil/ipodpatcher $$RBBASE_DIR/rbutil/sansapatcher \
             $$RBBASE_DIR/tools/rbspeex $$RBBASE_DIR/tools
 
diff --git a/rbutil/rbutilqt/zip/README b/rbutil/rbutilqt/zip/README
deleted file mode 100644
index b5f88cb6ae..0000000000
--- a/rbutil/rbutilqt/zip/README
+++ /dev/null
@@ -1,69 +0,0 @@
-The *.cpp and *.h files in this archive are 
-Copyright (C) 2007-2008 Angius Fabrizio (blue_death@users.sourceforge.net)
-
-You may use, distribute and copy the files under the terms of
-GNU General Public License version 2 (see the file LICENSE.GPL for details)
-
--------------------------------------------------------------------------
-
-Website: http://osdab.sourceforge.net/
-SourceForge.net project page: https://sourceforge.net/projects/osdab/
-
-**************** ******* ******************************************************
-
-detailed description
---------------------
-Meet a couple of pure-Qt/C++ classes capable of handling PKZIP 2.0 compatible zip archives. 
-
-This is not a "port" of some other existing implementation, everything has been written from scratch (althought some code was actually inspired by existing public domain projects) and it's all pure C++/Qt. Please note that this is not a complete stand-alone library, it's just a bunch of classes. You will have to add them to your project and modify them to best fit your needs. 
-
-It supports basic features like file extraction and compression (with optional password encryption) and archive comments. There are methods to extract single files or the whole archive and methods to compress the contents of a whole directory. Nevertheless, it should be quite trivial to add other features. The public API only has a few methods because this is what I was looking for. This does not mean you can't write a few more lines of code (it really shouldn't take more than a few lines!) to add more features. 
-
-The classes are great if you only need to use the PKZIP format for loading/saving your application's data. Just remember that you will need to customize a few parts of the code, i.e. to add your own password retrieval method. 
-
-zlib is used for actual compression and decompression.
-
-Please refer to the example application's main.cpp file or to the class comments in the source files for details and more usage examples.
-
-history
--------
-2008-09-97 - Bug fix: end of central directory was sometimes not being found when the archive had a comment.
-2007-02-01 - New IgnorePaths compression option and two more "addDirectoryContents()" convenience methods to use this option.
-2007-01-28 - Major changes:
- - Bug fix: there was a big problem with directory names.
- - API changes: the Zip::addDirectory() method is now easier to use.
-   The password can now be set using a setPassword() method and a new flag allows to preserve absolute paths.
- - Added an "encrypted" flag to the Unzip::ZipEntry struct.
- - Removed QObject inheritance. Internationalization is now achieved through QCoreApplication::translate().
-2006-11-30 - A good part of the UnZip class has been rewritten. Zip entries with a Data Descriptor (like OpenOffice files) are now correctly parsed; some minor API changes and bug fixes; new features: comments, zip entry list, skip paths unzip option
-2006-11-24 - Bug fix. An additional directory was being created for some files in the root directory
-2006-10-23 - Minor API changes; QIODevice support added; better binary compatibility; "long long" issue with older compilers solved
-2006-06-09 - Minor API changes
-2005-10-03 - First public release
-
-features
---------
-Pure C++/Qt based, clean & oo implementation. 
-Retrieve archive contents information before extracting any file. 
-Fast (but less robust with corrupt archives) parsing of the ZIP file format. 
-Traditional PKWARE password encryption (strong encryption as introduced by PKZip versions 5.0 and later is NOT available). 
-Support for archive comments.
-
-missing features and restrictions
----------------------------------
-Needs to be modified to fit into an existing project (i.e.: you might need to add your own password handling routine). 
-Weak support of corrupted archives (althought some files could be extracted even if the archive is corrupted). 
-No support for filesystem specific features like unix symbolic links. 
-No support for spanned archives. 
-No support for strong encryption or features introduced after PKZIP version 2.0 (see the PKWARE specs for details).
-
-requirements
-------------
-Qt version 4.0.x or later
-zlib library
-
-
-**************** ******* ******************************************************
-BEFORE SENDING ANY EMAIL, CHECK OUT THE OSDAB WEBSITE HOSTED AT SOURCEFORGE.NET
-**************** ******* ******************************************************
-
diff --git a/rbutil/rbutilqt/zip/README.ROCKBOX b/rbutil/rbutilqt/zip/README.ROCKBOX
deleted file mode 100644
index 46bdd9a15e..0000000000
--- a/rbutil/rbutilqt/zip/README.ROCKBOX
+++ /dev/null
@@ -1,8 +0,0 @@
-This folder contains the zip extraction classes of the OSDaB project.
-These classes are distributed under the GPL license (see the file
-LICENSE.GPL in this folder).
-The source files have been last synced with the projects svn repo
-at http://osdab.googlecode.com/svn/trunk revision 7 on 2009-04-26.
-
-Details at http://code.google.com/p/osdab/
-
diff --git a/rbutil/rbutilqt/zip/unzip.cpp b/rbutil/rbutilqt/zip/unzip.cpp
deleted file mode 100644
index 8c4028b40c..0000000000
--- a/rbutil/rbutilqt/zip/unzip.cpp
+++ /dev/null
@@ -1,1366 +0,0 @@
-/****************************************************************************
-** Filename: unzip.cpp
-** Last updated [dd/mm/yyyy]: 07/09/2008
-**
-** pkzip 2.0 decompression.
-**
-** Some of the code has been inspired by other open source projects,
-** (mainly Info-Zip and Gilles Vollant's minizip).
-** Compression and decompression actually uses the zlib library.
-**
-** Copyright (C) 2007-2008 Angius Fabrizio. All rights reserved.
-**
-** This file is part of the OSDaB project (http://osdab.sourceforge.net/).
-**
-** This file may be distributed and/or modified under the terms of the
-** GNU General Public License version 2 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.
-**
-** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-**
-** See the file LICENSE.GPL that came with this software distribution or
-** visit http://www.gnu.org/copyleft/gpl.html for GPL licensing information.
-**
-**********************************************************************/
-
-#include "unzip.h"
-#include "unzip_p.h"
-#include "zipentry_p.h"
-
-#include <QString>
-#include <QStringList>
-#include <QDir>
-#include <QFile>
-#include <QCoreApplication>
-
-// You can remove this #include if you replace the qDebug() statements.
-#include <QtDebug>
-
-/*!
-        \class UnZip unzip.h
-
-        \brief PKZip 2.0 file decompression.
-        Compatibility with later versions is not ensured as they may use
-        unsupported compression algorithms.
-        Versions after 2.7 may have an incompatible header format and thus be
-        completely incompatible.
-*/
-
-/*! \enum UnZip::ErrorCode The result of a decompression operation.
-        \value UnZip::Ok No error occurred.
-        \value UnZip::ZlibInit Failed to init or load the zlib library.
-        \value UnZip::ZlibError The zlib library returned some error.
-        \value UnZip::OpenFailed Unable to create or open a device.
-        \value UnZip::PartiallyCorrupted Corrupted zip archive - some files could be extracted.
-        \value UnZip::Corrupted Corrupted or invalid zip archive.
-        \value UnZip::WrongPassword Unable to decrypt a password protected file.
-        \value UnZip::NoOpenArchive No archive has been opened yet.
-        \value UnZip::FileNotFound Unable to find the requested file in the archive.
-        \value UnZip::ReadFailed Reading of a file failed.
-        \value UnZip::WriteFailed Writing of a file failed.
-        \value UnZip::SeekFailed Seek failed.
-        \value UnZip::CreateDirFailed Could not create a directory.
-        \value UnZip::InvalidDevice A null device has been passed as parameter.
-        \value UnZip::InvalidArchive This is not a valid (or supported) ZIP archive.
-        \value UnZip::HeaderConsistencyError Local header record info does not match with the central directory record info. The archive may be corrupted.
-
-        \value UnZip::Skip Internal use only.
-        \value UnZip::SkipAll Internal use only.
-*/
-
-/*! \enum UnZip::ExtractionOptions Some options for the file extraction methods.
-        \value UnZip::ExtractPaths Default. Does not ignore the path of the zipped files.
-        \value UnZip::SkipPaths Default. Ignores the path of the zipped files and extracts them all to the same root directory.
-*/
-
-//! Local header size (excluding signature, excluding variable length fields)
-#define UNZIP_LOCAL_HEADER_SIZE 26
-//! Central Directory file entry size (excluding signature, excluding variable length fields)
-#define UNZIP_CD_ENTRY_SIZE_NS 42
-//! Data descriptor size (excluding signature)
-#define UNZIP_DD_SIZE 12
-//! End Of Central Directory size (including signature, excluding variable length fields)
-#define UNZIP_EOCD_SIZE 22
-//! Local header entry encryption header size
-#define UNZIP_LOCAL_ENC_HEADER_SIZE 12
-
-// Some offsets inside a CD record (excluding signature)
-#define UNZIP_CD_OFF_VERSION 0
-#define UNZIP_CD_OFF_GPFLAG 4
-#define UNZIP_CD_OFF_CMETHOD 6
-#define UNZIP_CD_OFF_MODT 8
-#define UNZIP_CD_OFF_MODD 10
-#define UNZIP_CD_OFF_CRC32 12
-#define UNZIP_CD_OFF_CSIZE 16
-#define UNZIP_CD_OFF_USIZE 20
-#define UNZIP_CD_OFF_NAMELEN 24
-#define UNZIP_CD_OFF_XLEN 26
-#define UNZIP_CD_OFF_COMMLEN 28
-#define UNZIP_CD_OFF_LHOFFSET 38
-
-// Some offsets inside a local header record (excluding signature)
-#define UNZIP_LH_OFF_VERSION 0
-#define UNZIP_LH_OFF_GPFLAG 2
-#define UNZIP_LH_OFF_CMETHOD 4
-#define UNZIP_LH_OFF_MODT 6
-#define UNZIP_LH_OFF_MODD 8
-#define UNZIP_LH_OFF_CRC32 10
-#define UNZIP_LH_OFF_CSIZE 14
-#define UNZIP_LH_OFF_USIZE 18
-#define UNZIP_LH_OFF_NAMELEN 22
-#define UNZIP_LH_OFF_XLEN 24
-
-// Some offsets inside a data descriptor record (excluding signature)
-#define UNZIP_DD_OFF_CRC32 0
-#define UNZIP_DD_OFF_CSIZE 4
-#define UNZIP_DD_OFF_USIZE 8
-
-// Some offsets inside a EOCD record
-#define UNZIP_EOCD_OFF_ENTRIES 6
-#define UNZIP_EOCD_OFF_CDOFF 12
-#define UNZIP_EOCD_OFF_COMMLEN 16
-
-/*!
-        Max version handled by this API.
-        0x1B = 2.7 --> full compatibility only up to version 2.0 (0x14)
-        versions from 2.1 to 2.7 may use unsupported compression methods
-        versions after 2.7 may have an incompatible header format
-*/
-/* NOTE: changed to 0x1e as info-zip 3.0 uses that header type which breaks
- *       usage. Extraction seems to work fine with the value increased.
- *       No guarantees though.
- */
-//#define UNZIP_VERSION 0x1B
-#define UNZIP_VERSION 0x1e
-//! Full compatibility granted until this version
-#define UNZIP_VERSION_STRICT 0x14
-
-//! CRC32 routine
-#define CRC32(c, b) crcTable[((int)c^b) & 0xff] ^ (c >> 8)
-
-//! Checks if some file has been already extracted.
-#define UNZIP_CHECK_FOR_VALID_DATA \
-        {\
-                if (headers != 0)\
-                {\
-                        qDebug() << "Corrupted zip archive. Some files might be extracted.";\
-                        ec = headers->size() != 0 ? UnZip::PartiallyCorrupted : UnZip::Corrupted;\
-                        break;\
-                }\
-                else\
-                {\
-                        delete device;\
-                        device = 0;\
-                        qDebug() << "Corrupted or invalid zip archive";\
-                        ec = UnZip::Corrupted;\
-                        break;\
-                }\
-        }
-
-
-/************************************************************************
- Public interface
-*************************************************************************/
-
-/*!
-        Creates a new Zip file decompressor.
-*/
-UnZip::UnZip()
-{
-        d = new UnzipPrivate;
-}
-
-/*!
-        Closes any open archive and releases used resources.
-*/
-UnZip::~UnZip()
-{
-        closeArchive();
-        delete d;
-}
-
-/*!
-        Returns true if there is an open archive.
-*/
-bool UnZip::isOpen() const
-{
-        return d->device != 0;
-}
-
-/*!
-        Opens a zip archive and reads the files list. Closes any previously opened archive.
-*/
-UnZip::ErrorCode UnZip::openArchive(const QString& filename)
-{
-        QFile* file = new QFile(filename);
-
-        if (!file->exists()) {
-                delete file;
-                return UnZip::FileNotFound;
-        }
-
-        if (!file->open(QIODevice::ReadOnly)) {
-                delete file;
-                return UnZip::OpenFailed;
-        }
-
-        return openArchive(file);
-}
-
-/*!
-        Opens a zip archive and reads the entries list.
-        Closes any previously opened archive.
-        \warning The class takes ownership of the device so don't delete it!
-*/
-UnZip::ErrorCode UnZip::openArchive(QIODevice* device)
-{
-        if (device == 0)
-        {
-                qDebug() << "Invalid device.";
-                return UnZip::InvalidDevice;
-        }
-
-        return d->openArchive(device);
-}
-
-/*!
-        Closes the archive and releases all the used resources (like cached passwords).
-*/
-void UnZip::closeArchive()
-{
-        d->closeArchive();
-}
-
-QString UnZip::archiveComment() const
-{
-        if (d->device == 0)
-                return QString();
-        return d->comment;
-}
-
-/*!
-        Returns a locale translated error string for a given error code.
-*/
-QString UnZip::formatError(UnZip::ErrorCode c) const
-{
-        switch (c)
-        {
-        case Ok: return QCoreApplication::translate("UnZip", "ZIP operation completed successfully."); break;
-        case ZlibInit: return QCoreApplication::translate("UnZip", "Failed to initialize or load zlib library."); break;
-        case ZlibError: return QCoreApplication::translate("UnZip", "zlib library error."); break;
-        case OpenFailed: return QCoreApplication::translate("UnZip", "Unable to create or open file."); break;
-        case PartiallyCorrupted: return QCoreApplication::translate("UnZip", "Partially corrupted archive. Some files might be extracted."); break;
-        case Corrupted: return QCoreApplication::translate("UnZip", "Corrupted archive."); break;
-        case WrongPassword: return QCoreApplication::translate("UnZip", "Wrong password."); break;
-        case NoOpenArchive: return QCoreApplication::translate("UnZip", "No archive has been created yet."); break;
-        case FileNotFound: return QCoreApplication::translate("UnZip", "File or directory does not exist."); break;
-        case ReadFailed: return QCoreApplication::translate("UnZip", "File read error."); break;
-        case WriteFailed: return QCoreApplication::translate("UnZip", "File write error."); break;
-        case SeekFailed: return QCoreApplication::translate("UnZip", "File seek error."); break;
-        case CreateDirFailed: return QCoreApplication::translate("UnZip", "Unable to create a directory."); break;
-        case InvalidDevice: return QCoreApplication::translate("UnZip", "Invalid device."); break;
-        case InvalidArchive: return QCoreApplication::translate("UnZip", "Invalid or incompatible zip archive."); break;
-        case HeaderConsistencyError: return QCoreApplication::translate("UnZip", "Inconsistent headers. Archive might be corrupted."); break;
-        default: ;
-        }
-
-        return QCoreApplication::translate("UnZip", "Unknown error.");
-}
-
-/*!
-        Returns true if the archive contains a file with the given path and name.
-*/
-bool UnZip::contains(const QString& file) const
-{
-        if (d->headers == 0)
-                return false;
-
-        return d->headers->contains(file);
-}
-
-/*!
-        Returns complete paths of files and directories in this archive.
-*/
-QStringList UnZip::fileList() const
-{
-        return d->headers == 0 ? QStringList() : d->headers->keys();
-}
-
-/*!
-        Returns information for each (correctly parsed) entry of this archive.
-*/
-QList<UnZip::ZipEntry> UnZip::entryList() const
-{
-        QList<UnZip::ZipEntry> list;
-
-        if (d->headers != 0)
-        {
-                for (QMap<QString,ZipEntryP*>::ConstIterator it = d->headers->constBegin(); it != d->headers->constEnd(); ++it)
-                {
-                        const ZipEntryP* entry = it.value();
-                        Q_ASSERT(entry != 0);
-
-                        ZipEntry z;
-
-                        z.filename = it.key();
-                        if (!entry->comment.isEmpty())
-                                z.comment = entry->comment;
-                        z.compressedSize = entry->szComp;
-                        z.uncompressedSize = entry->szUncomp;
-                        z.crc32 = entry->crc;
-                        z.lastModified = d->convertDateTime(entry->modDate, entry->modTime);
-
-                        z.compression = entry->compMethod == 0 ? NoCompression : entry->compMethod == 8 ? Deflated : UnknownCompression;
-                        z.type = z.filename.endsWith("/") ? Directory : File;
-
-                        z.encrypted = entry->isEncrypted();
-
-                        list.append(z);
-                }
-        }
-
-        return list;
-}
-
-/*!
-        Extracts the whole archive to a directory.
-*/
-UnZip::ErrorCode UnZip::extractAll(const QString& dirname, ExtractionOptions options)
-{
-        return extractAll(QDir(dirname), options);
-}
-
-/*!
-        Extracts the whole archive to a directory.
-*/
-UnZip::ErrorCode UnZip::extractAll(const QDir& dir, ExtractionOptions options)
-{
-        // this should only happen if we didn't call openArchive() yet
-        if (d->device == 0)
-                return NoOpenArchive;
-
-        if (d->headers == 0)
-                return Ok;
-
-        bool end = false;
-        for (QMap<QString,ZipEntryP*>::Iterator itr = d->headers->begin(); itr != d->headers->end(); ++itr)
-        {
-                ZipEntryP* entry = itr.value();
-                Q_ASSERT(entry != 0);
-
-                if ((entry->isEncrypted()) && d->skipAllEncrypted)
-                        continue;
-
-                switch (d->extractFile(itr.key(), *entry, dir, options))
-                {
-                case Corrupted:
-                        qDebug() << "Removing corrupted entry" << itr.key();
-                        d->headers->erase(itr++);
-                        if (itr == d->headers->end())
-                                end = true;
-                        break;
-                case CreateDirFailed:
-                        break;
-                case Skip:
-                        break;
-                case SkipAll:
-                        d->skipAllEncrypted = true;
-                        break;
-                default:
-                        ;
-                }
-
-                if (end)
-                        break;
-        }
-
-        return Ok;
-}
-
-/*!
-        Extracts a single file to a directory.
-*/
-UnZip::ErrorCode UnZip::extractFile(const QString& filename, const QString& dirname, ExtractionOptions options)
-{
-        return extractFile(filename, QDir(dirname), options);
-}
-
-/*!
-        Extracts a single file to a directory.
-*/
-UnZip::ErrorCode UnZip::extractFile(const QString& filename, const QDir& dir, ExtractionOptions options)
-{
-        QMap<QString,ZipEntryP*>::Iterator itr = d->headers->find(filename);
-        if (itr != d->headers->end())
-        {
-                ZipEntryP* entry = itr.value();
-                Q_ASSERT(entry != 0);
-                return d->extractFile(itr.key(), *entry, dir, options);
-        }
-
-        return FileNotFound;
-}
-
-/*!
-        Extracts a single file to a directory.
-*/
-UnZip::ErrorCode UnZip::extractFile(const QString& filename, QIODevice* dev, ExtractionOptions options)
-{
-        if (dev == 0)
-                return InvalidDevice;
-
-        QMap<QString,ZipEntryP*>::Iterator itr = d->headers->find(filename);
-        if (itr != d->headers->end()) {
-                ZipEntryP* entry = itr.value();
-                Q_ASSERT(entry != 0);
-                return d->extractFile(itr.key(), *entry, dev, options);
-        }
-
-        return FileNotFound;
-}
-
-/*!
-        Extracts a list of files.
-        Stops extraction at the first error (but continues if a file does not exist in the archive).
- */
-UnZip::ErrorCode UnZip::extractFiles(const QStringList& filenames, const QString& dirname, ExtractionOptions options)
-{
-        QDir dir(dirname);
-        ErrorCode ec;
-
-        for (QStringList::ConstIterator itr = filenames.constBegin(); itr != filenames.constEnd(); ++itr)
-        {
-                ec = extractFile(*itr, dir, options);
-                if (ec == FileNotFound)
-                        continue;
-                if (ec != Ok)
-                        return ec;
-        }
-
-        return Ok;
-}
-
-/*!
-        Extracts a list of files.
-        Stops extraction at the first error (but continues if a file does not exist in the archive).
- */
-UnZip::ErrorCode UnZip::extractFiles(const QStringList& filenames, const QDir& dir, ExtractionOptions options)
-{
-        ErrorCode ec;
-
-        for (QStringList::ConstIterator itr = filenames.constBegin(); itr != filenames.constEnd(); ++itr)
-        {
-                ec = extractFile(*itr, dir, options);
-                if (ec == FileNotFound)
-                        continue;
-                if (ec != Ok)
-                        return ec;
-        }
-
-        return Ok;
-}
-
-/*!
-        Remove/replace this method to add your own password retrieval routine.
-*/
-void UnZip::setPassword(const QString& pwd)
-{
-        d->password = pwd;
-}
-
-/*!
-        ZipEntry constructor - initialize data. Type is set to File.
-*/
-UnZip::ZipEntry::ZipEntry()
-{
-        compressedSize = uncompressedSize = crc32 = 0;
-        compression = NoCompression;
-        type = File;
-        encrypted = false;
-}
-
-
-/************************************************************************
- Private interface
-*************************************************************************/
-
-//! \internal
-UnzipPrivate::UnzipPrivate()
-{
-        skipAllEncrypted = false;
-        headers = 0;
-        device = 0;
-
-        uBuffer = (unsigned char*) buffer1;
-        crcTable = (quint32*) get_crc_table();
-
-        cdOffset = eocdOffset = 0;
-        cdEntryCount = 0;
-        unsupportedEntryCount = 0;
-}
-
-//! \internal Parses a Zip archive.
-UnZip::ErrorCode UnzipPrivate::openArchive(QIODevice* dev)
-{
-        Q_ASSERT(dev != 0);
-
-        if (device != 0)
-                closeArchive();
-
-        device = dev;
-
-        if (!(device->isOpen() || device->open(QIODevice::ReadOnly)))
-        {
-                delete device;
-                device = 0;
-
-                qDebug() << "Unable to open device for reading";
-                return UnZip::OpenFailed;
-        }
-
-        UnZip::ErrorCode ec;
-
-        ec = seekToCentralDirectory();
-        if (ec != UnZip::Ok)
-        {
-                closeArchive();
-                return ec;
-        }
-
-        //! \todo Ignore CD entry count? CD may be corrupted.
-        if (cdEntryCount == 0)
-        {
-                return UnZip::Ok;
-        }
-
-        bool continueParsing = true;
-
-        while (continueParsing)
-        {
-                if (device->read(buffer1, 4) != 4)
-                        UNZIP_CHECK_FOR_VALID_DATA
-
-                if (! (buffer1[0] == 'P' && buffer1[1] == 'K' && buffer1[2] == 0x01  && buffer1[3] == 0x02) )
-                        break;
-
-                if ( (ec = parseCentralDirectoryRecord()) != UnZip::Ok )
-                        break;
-        }
-
-        if (ec != UnZip::Ok)
-                closeArchive();
-
-        return ec;
-}
-
-/*
-        \internal Parses a local header record and makes some consistency check
-        with the information stored in the Central Directory record for this entry
-        that has been previously parsed.
-        \todo Optional consistency check (as a ExtractionOptions flag)
-
-        local file header signature     4 bytes  (0x04034b50)
-        version needed to extract       2 bytes
-        general purpose bit flag        2 bytes
-        compression method              2 bytes
-        last mod file time              2 bytes
-        last mod file date              2 bytes
-        crc-32                          4 bytes
-        compressed size                 4 bytes
-        uncompressed size               4 bytes
-        file name length                2 bytes
-        extra field length              2 bytes
-
-        file name (variable size)
-        extra field (variable size)
-*/
-UnZip::ErrorCode UnzipPrivate::parseLocalHeaderRecord(const QString& path, ZipEntryP& entry)
-{
-        if (!device->seek(entry.lhOffset))
-                return UnZip::SeekFailed;
-
-        // Test signature
-        if (device->read(buffer1, 4) != 4)
-                return UnZip::ReadFailed;
-
-        if ((buffer1[0] != 'P') || (buffer1[1] != 'K') || (buffer1[2] != 0x03) || (buffer1[3] != 0x04))
-                return UnZip::InvalidArchive;
-
-        if (device->read(buffer1, UNZIP_LOCAL_HEADER_SIZE) != UNZIP_LOCAL_HEADER_SIZE)
-                return UnZip::ReadFailed;
-
-        /*
-                Check 3rd general purpose bit flag.
-
-                "bit 3: If this bit is set, the fields crc-32, compressed size
-                and uncompressed size are set to zero in the local
-                header.  The correct values are put in the data descriptor
-                immediately following the compressed data."
-        */
-        bool hasDataDescriptor = entry.hasDataDescriptor();
-
-        bool checkFailed = false;
-
-        if (!checkFailed)
-                checkFailed = entry.compMethod != getUShort(uBuffer, UNZIP_LH_OFF_CMETHOD);
-        if (!checkFailed)
-                checkFailed = entry.gpFlag[0] != uBuffer[UNZIP_LH_OFF_GPFLAG];
-        if (!checkFailed)
-                checkFailed = entry.gpFlag[1] != uBuffer[UNZIP_LH_OFF_GPFLAG + 1];
-        if (!checkFailed)
-                checkFailed = entry.modTime[0] != uBuffer[UNZIP_LH_OFF_MODT];
-        if (!checkFailed)
-                checkFailed = entry.modTime[1] != uBuffer[UNZIP_LH_OFF_MODT + 1];
-        if (!checkFailed)
-                checkFailed = entry.modDate[0] != uBuffer[UNZIP_LH_OFF_MODD];
-        if (!checkFailed)
-                checkFailed = entry.modDate[1] != uBuffer[UNZIP_LH_OFF_MODD + 1];
-        if (!hasDataDescriptor)
-        {
-                if (!checkFailed)
-                        checkFailed = entry.crc != getULong(uBuffer, UNZIP_LH_OFF_CRC32);
-                if (!checkFailed)
-                        checkFailed = entry.szComp != getULong(uBuffer, UNZIP_LH_OFF_CSIZE);
-                if (!checkFailed)
-                        checkFailed = entry.szUncomp != getULong(uBuffer, UNZIP_LH_OFF_USIZE);
-        }
-
-        if (checkFailed)
-                return UnZip::HeaderConsistencyError;
-
-        // Check filename
-        quint16 szName = getUShort(uBuffer, UNZIP_LH_OFF_NAMELEN);
-        if (szName == 0)
-                return UnZip::HeaderConsistencyError;
-
-        if (device->read(buffer2, szName) != szName)
-                return UnZip::ReadFailed;
-
-        QString filename = QString::fromAscii(buffer2, szName);
-        if (filename != path)
-        {
-                qDebug() << "Filename in local header mismatches.";
-                return UnZip::HeaderConsistencyError;
-        }
-
-        // Skip extra field
-        quint16 szExtra = getUShort(uBuffer, UNZIP_LH_OFF_XLEN);
-        if (szExtra != 0)
-        {
-                if (!device->seek(device->pos() + szExtra))
-                        return UnZip::SeekFailed;
-        }
-
-        entry.dataOffset = device->pos();
-
-        if (hasDataDescriptor)
-        {
-                /*
-                        The data descriptor has this OPTIONAL signature: PK\7\8
-                        We try to skip the compressed data relying on the size set in the
-                        Central Directory record.
-                */
-                if (!device->seek(device->pos() + entry.szComp))
-                        return UnZip::SeekFailed;
-
-                // Read 4 bytes and check if there is a data descriptor signature
-                if (device->read(buffer2, 4) != 4)
-                        return UnZip::ReadFailed;
-
-                bool hasSignature = buffer2[0] == 'P' && buffer2[1] == 'K' && buffer2[2] == 0x07 && buffer2[3] == 0x08;
-                if (hasSignature)
-                {
-                        if (device->read(buffer2, UNZIP_DD_SIZE) != UNZIP_DD_SIZE)
-                                return UnZip::ReadFailed;
-                }
-                else
-                {
-                        if (device->read(buffer2 + 4, UNZIP_DD_SIZE - 4) != UNZIP_DD_SIZE - 4)
-                                return UnZip::ReadFailed;
-                }
-
-                // DD: crc, compressed size, uncompressed size
-                if (
-                        entry.crc != getULong((unsigned char*)buffer2, UNZIP_DD_OFF_CRC32) ||
-                        entry.szComp != getULong((unsigned char*)buffer2, UNZIP_DD_OFF_CSIZE) ||
-                        entry.szUncomp != getULong((unsigned char*)buffer2, UNZIP_DD_OFF_USIZE)
-                        )
-                        return UnZip::HeaderConsistencyError;
-        }
-
-        return UnZip::Ok;
-}
-
-/*! \internal Attempts to find the start of the central directory record.
-
-        We seek the file back until we reach the "End Of Central Directory"
-        signature PK\5\6.
-
-        end of central dir signature    4 bytes  (0x06054b50)
-        number of this disk             2 bytes
-        number of the disk with the
-        start of the central directory  2 bytes
-        total number of entries in the
-        central directory on this disk  2 bytes
-        total number of entries in
-        the central directory           2 bytes
-        size of the central directory   4 bytes
-        offset of start of central
-        directory with respect to
-        the starting disk number        4 bytes
-        .ZIP file comment length        2 bytes
-        --- SIZE UNTIL HERE: UNZIP_EOCD_SIZE ---
-        .ZIP file comment       (variable size)
-*/
-UnZip::ErrorCode UnzipPrivate::seekToCentralDirectory()
-{
-        qint64 length = device->size();
-        qint64 offset = length - UNZIP_EOCD_SIZE;
-
-        if (length < UNZIP_EOCD_SIZE)
-                return UnZip::InvalidArchive;
-
-        if (!device->seek( offset ))
-                return UnZip::SeekFailed;
-
-        if (device->read(buffer1, UNZIP_EOCD_SIZE) != UNZIP_EOCD_SIZE)
-                return UnZip::ReadFailed;
-
-        bool eocdFound = (buffer1[0] == 'P' && buffer1[1] == 'K' && buffer1[2] == 0x05 && buffer1[3] == 0x06);
-
-        if (eocdFound)
-        {
-                // Zip file has no comment (the only variable length field in the EOCD record)
-                eocdOffset = offset;
-        }
-        else
-        {
-                qint64 read;
-                char* p = 0;
-
-                offset -= UNZIP_EOCD_SIZE;
-
-                if (offset <= 0)
-                        return UnZip::InvalidArchive;
-
-                if (!device->seek( offset ))
-                        return UnZip::SeekFailed;
-
-                while ((read = device->read(buffer1, UNZIP_EOCD_SIZE)) >= 0)
-                {
-                        if ( (p = strstr(buffer1, "PK\5\6")) != 0)
-                        {
-                                // Seek to the start of the EOCD record so we can read it fully
-                                // Yes... we could simply read the missing bytes and append them to the buffer
-                                // but this is far easier so heck it!
-                                device->seek( offset + (p - buffer1) );
-                                eocdFound = true;
-                                eocdOffset = offset + (p - buffer1);
-
-                                // Read EOCD record
-                                if (device->read(buffer1, UNZIP_EOCD_SIZE) != UNZIP_EOCD_SIZE)
-                                        return UnZip::ReadFailed;
-
-                                break;
-                        }
-
-                        // TODO: This is very slow and only a temporary bug fix. Need some pattern matching algorithm here.
-                        offset -= 1 /*UNZIP_EOCD_SIZE*/;
-                        if (offset <= 0)
-                                return UnZip::InvalidArchive;
-
-                        if (!device->seek( offset ))
-                                return UnZip::SeekFailed;
-                }
-        }
-
-        if (!eocdFound)
-                return UnZip::InvalidArchive;
-
-        // Parse EOCD to locate CD offset
-        offset = getULong((const unsigned char*)buffer1, UNZIP_EOCD_OFF_CDOFF + 4);
-
-        cdOffset = offset;
-
-        cdEntryCount = getUShort((const unsigned char*)buffer1, UNZIP_EOCD_OFF_ENTRIES + 4);
-
-        quint16 commentLength = getUShort((const unsigned char*)buffer1, UNZIP_EOCD_OFF_COMMLEN + 4);
-        if (commentLength != 0)
-        {
-                QByteArray c = device->read(commentLength);
-                if (c.count() != commentLength)
-                        return UnZip::ReadFailed;
-
-                comment = c;
-        }
-
-        // Seek to the start of the CD record
-        if (!device->seek( cdOffset ))
-                return UnZip::SeekFailed;
-
-        return UnZip::Ok;
-}
-
-/*!
-        \internal Parses a central directory record.
-
-        Central Directory record structure:
-
-        [file header 1]
-        .
-        .
-        .
-        [file header n]
-        [digital signature] // PKZip 6.2 or later only
-
-        File header:
-
-        central file header signature   4 bytes  (0x02014b50)
-        version made by                 2 bytes
-        version needed to extract       2 bytes
-        general purpose bit flag        2 bytes
-        compression method              2 bytes
-        last mod file time              2 bytes
-        last mod file date              2 bytes
-        crc-32                          4 bytes
-        compressed size                 4 bytes
-        uncompressed size               4 bytes
-        file name length                2 bytes
-        extra field length              2 bytes
-        file comment length             2 bytes
-        disk number start               2 bytes
-        internal file attributes        2 bytes
-        external file attributes        4 bytes
-        relative offset of local header 4 bytes
-
-        file name (variable size)
-        extra field (variable size)
-        file comment (variable size)
-*/
-UnZip::ErrorCode UnzipPrivate::parseCentralDirectoryRecord()
-{
-        // Read CD record
-        if (device->read(buffer1, UNZIP_CD_ENTRY_SIZE_NS) != UNZIP_CD_ENTRY_SIZE_NS)
-                return UnZip::ReadFailed;
-
-        bool skipEntry = false;
-
-        // Get compression type so we can skip non compatible algorithms
-        quint16 compMethod = getUShort(uBuffer, UNZIP_CD_OFF_CMETHOD);
-
-        // Get variable size fields length so we can skip the whole record
-        // if necessary
-        quint16 szName = getUShort(uBuffer, UNZIP_CD_OFF_NAMELEN);
-        quint16 szExtra = getUShort(uBuffer, UNZIP_CD_OFF_XLEN);
-        quint16 szComment = getUShort(uBuffer, UNZIP_CD_OFF_COMMLEN);
-
-        quint32 skipLength = szName + szExtra + szComment;
-
-        UnZip::ErrorCode ec = UnZip::Ok;
-
-        if ((compMethod != 0) && (compMethod != 8))
-        {
-                qDebug() << "Unsupported compression method. Skipping file.";
-                skipEntry = true;
-        }
-
-        // Header parsing may be a problem if version is bigger than UNZIP_VERSION
-        if (!skipEntry && buffer1[UNZIP_CD_OFF_VERSION] > UNZIP_VERSION)
-        {
-                qDebug() << "Unsupported PKZip version. Skipping file.";
-                skipEntry = true;
-        }
-
-        if (!skipEntry && szName == 0)
-        {
-                qDebug() << "Skipping file with no name.";
-                skipEntry = true;
-        }
-
-        if (!skipEntry && device->read(buffer2, szName) != szName)
-        {
-                ec = UnZip::ReadFailed;
-                skipEntry = true;
-        }
-
-        if (skipEntry)
-        {
-                if (ec == UnZip::Ok)
-                {
-                        if (!device->seek( device->pos() + skipLength ))
-                                ec = UnZip::SeekFailed;
-
-                        unsupportedEntryCount++;
-                }
-
-                return ec;
-        }
-
-        QString filename = QString::fromAscii(buffer2, szName);
-
-        ZipEntryP* h = new ZipEntryP;
-        h->compMethod = compMethod;
-
-        h->gpFlag[0] = buffer1[UNZIP_CD_OFF_GPFLAG];
-        h->gpFlag[1] = buffer1[UNZIP_CD_OFF_GPFLAG + 1];
-
-        h->modTime[0] = buffer1[UNZIP_CD_OFF_MODT];
-        h->modTime[1] = buffer1[UNZIP_CD_OFF_MODT + 1];
-
-        h->modDate[0] = buffer1[UNZIP_CD_OFF_MODD];
-        h->modDate[1] = buffer1[UNZIP_CD_OFF_MODD + 1];
-
-        h->crc = getULong(uBuffer, UNZIP_CD_OFF_CRC32);
-        h->szComp = getULong(uBuffer, UNZIP_CD_OFF_CSIZE);
-        h->szUncomp = getULong(uBuffer, UNZIP_CD_OFF_USIZE);
-
-        // Skip extra field (if any)
-        if (szExtra != 0)
-        {
-                if (!device->seek( device->pos() + szExtra ))
-                {
-                        delete h;
-                        return UnZip::SeekFailed;
-                }
-        }
-
-        // Read comment field (if any)
-        if (szComment != 0)
-        {
-                if (device->read(buffer2, szComment) != szComment)
-                {
-                        delete h;
-                        return UnZip::ReadFailed;
-                }
-
-                h->comment = QString::fromAscii(buffer2, szComment);
-        }
-
-        h->lhOffset = getULong(uBuffer, UNZIP_CD_OFF_LHOFFSET);
-
-        if (headers == 0)
-                headers = new QMap<QString, ZipEntryP*>();
-        headers->insert(filename, h);
-
-        return UnZip::Ok;
-}
-
-//! \internal Closes the archive and resets the internal status.
-void UnzipPrivate::closeArchive()
-{
-        if (device == 0)
-                return;
-
-        skipAllEncrypted = false;
-
-        if (headers != 0)
-        {
-                qDeleteAll(*headers);
-                delete headers;
-                headers = 0;
-        }
-
-        delete device; device = 0;
-
-        cdOffset = eocdOffset = 0;
-        cdEntryCount = 0;
-        unsupportedEntryCount = 0;
-
-        comment.clear();
-}
-
-//! \internal
-UnZip::ErrorCode UnzipPrivate::extractFile(const QString& path, ZipEntryP& entry, const QDir& dir, UnZip::ExtractionOptions options)
-{
-        QString name(path);
-        QString dirname;
-        QString directory;
-
-        int pos = name.lastIndexOf('/');
-
-        // This entry is for a directory
-        if (pos == name.length() - 1)
-        {
-                if (options.testFlag(UnZip::SkipPaths))
-                        return UnZip::Ok;
-
-                directory = QString("%1/%2").arg(dir.absolutePath()).arg(QDir::cleanPath(name));
-                if (!createDirectory(directory))
-                {
-                        qDebug() << QString("Unable to create directory: %1").arg(directory);
-                        return UnZip::CreateDirFailed;
-                }
-
-                return UnZip::Ok;
-        }
-
-        // Extract path from entry
-        if (pos > 0)
-        {
-                // get directory part
-                dirname = name.left(pos);
-                if (options.testFlag(UnZip::SkipPaths))
-                {
-                        directory = dir.absolutePath();
-                }
-                else
-                {
-                        directory = QString("%1/%2").arg(dir.absolutePath()).arg(QDir::cleanPath(dirname));
-                        if (!createDirectory(directory))
-                        {
-                                qDebug() << QString("Unable to create directory: %1").arg(directory);
-                                return UnZip::CreateDirFailed;
-                        }
-                }
-                name = name.right(name.length() - pos - 1);
-        } else directory = dir.absolutePath();
-
-        name = QString("%1/%2").arg(directory).arg(name);
-
-        QFile outFile(name);
-
-        if (!outFile.open(QIODevice::WriteOnly))
-        {
-                qDebug() << QString("Unable to open %1 for writing").arg(name);
-                return UnZip::OpenFailed;
-        }
-
-        //! \todo Set creation/last_modified date/time
-
-        UnZip::ErrorCode ec = extractFile(path, entry, &outFile, options);
-
-        outFile.close();
-
-        if (ec != UnZip::Ok)
-        {
-                if (!outFile.remove())
-                        qDebug() << QString("Unable to remove corrupted file: %1").arg(name);
-        }
-
-        return ec;
-}
-
-//! \internal
-UnZip::ErrorCode UnzipPrivate::extractFile(const QString& path, ZipEntryP& entry, QIODevice* dev, UnZip::ExtractionOptions options)
-{
-        Q_UNUSED(options);
-        Q_ASSERT(dev != 0);
-
-        if (!entry.lhEntryChecked)
-        {
-                UnZip::ErrorCode ec = parseLocalHeaderRecord(path, entry);
-                entry.lhEntryChecked = true;
-
-                if (ec != UnZip::Ok)
-                        return ec;
-        }
-
-        if (!device->seek(entry.dataOffset))
-                return UnZip::SeekFailed;
-
-        // Encryption keys
-        quint32 keys[3];
-
-        if (entry.isEncrypted())
-        {
-                UnZip::ErrorCode e = testPassword(keys, path, entry);
-                if (e != UnZip::Ok)
-                {
-                        qDebug() << QString("Unable to decrypt %1").arg(path);
-                        return e;
-                }//! Encryption header size
-                entry.szComp -= UNZIP_LOCAL_ENC_HEADER_SIZE; // remove encryption header size
-        }
-
-        if (entry.szComp == 0)
-        {
-                if (entry.crc != 0)
-                        return UnZip::Corrupted;
-
-                return UnZip::Ok;
-        }
-
-        uInt rep = entry.szComp / UNZIP_READ_BUFFER;
-        uInt rem = entry.szComp % UNZIP_READ_BUFFER;
-        uInt cur = 0;
-
-        // extract data
-        qint64 read;
-        quint64 tot = 0;
-
-        quint32 myCRC = crc32(0L, Z_NULL, 0);
-
-        if (entry.compMethod == 0)
-        {
-                while ( (read = device->read(buffer1, cur < rep ? UNZIP_READ_BUFFER : rem)) > 0 )
-                {
-                        if (entry.isEncrypted())
-                                decryptBytes(keys, buffer1, read);
-
-                        myCRC = crc32(myCRC, uBuffer, read);
-
-                        if (dev->write(buffer1, read) != read)
-                                return UnZip::WriteFailed;
-
-                        cur++;
-                        tot += read;
-
-                        if (tot == entry.szComp)
-                                break;
-                }
-
-                if (read < 0)
-                        return UnZip::ReadFailed;
-        }
-        else if (entry.compMethod == 8)
-        {
-                /* Allocate inflate state */
-                z_stream zstr;
-                zstr.zalloc = Z_NULL;
-                zstr.zfree = Z_NULL;
-                zstr.opaque = Z_NULL;
-                zstr.next_in = Z_NULL;
-                zstr.avail_in = 0;
-
-                int zret;
-
-                // Use inflateInit2 with negative windowBits to get raw decompression
-                if ( (zret = inflateInit2_(&zstr, -MAX_WBITS, ZLIB_VERSION, sizeof(z_stream))) != Z_OK )
-                        return UnZip::ZlibError;
-
-                int szDecomp;
-
-                // Decompress until deflate stream ends or end of file
-                do
-                {
-                        read = device->read(buffer1, cur < rep ? UNZIP_READ_BUFFER : rem);
-                        if (read == 0)
-                                break;
-                        if (read < 0)
-                        {
-                                (void)inflateEnd(&zstr);
-                                return UnZip::ReadFailed;
-                        }
-
-                        if (entry.isEncrypted())
-                                decryptBytes(keys, buffer1, read);
-
-                        cur++;
-                        tot += read;
-
-                        zstr.avail_in = (uInt) read;
-                        zstr.next_in = (Bytef*) buffer1;
-
-
-                        // Run inflate() on input until output buffer not full
-                        do {
-                                zstr.avail_out = UNZIP_READ_BUFFER;
-                                zstr.next_out = (Bytef*) buffer2;;
-
-                                zret = inflate(&zstr, Z_NO_FLUSH);
-
-                                switch (zret) {
-                                        case Z_NEED_DICT:
-                                        case Z_DATA_ERROR:
-                                        case Z_MEM_ERROR:
-                                                inflateEnd(&zstr);
-                                                return UnZip::WriteFailed;
-                                        default:
-                                                ;
-                                }
-
-                                szDecomp = UNZIP_READ_BUFFER - zstr.avail_out;
-                                if (dev->write(buffer2, szDecomp) != szDecomp)
-                                {
-                                        inflateEnd(&zstr);
-                                        return UnZip::ZlibError;
-                                }
-
-                                myCRC = crc32(myCRC, (const Bytef*) buffer2, szDecomp);
-
-                        } while (zstr.avail_out == 0);
-
-                }
-                while (zret != Z_STREAM_END);
-
-                inflateEnd(&zstr);
-        }
-
-        if (myCRC != entry.crc)
-                return UnZip::Corrupted;
-
-        return UnZip::Ok;
-}
-
-//! \internal Creates a new directory and all the needed parent directories.
-bool UnzipPrivate::createDirectory(const QString& path)
-{
-        QDir d(path);
-        if (!d.exists())
-        {
-                int sep = path.lastIndexOf("/");
-                if (sep <= 0) return true;
-
-                if (!createDirectory(path.left(sep)))
-                        return false;
-
-                if (!d.mkdir(path))
-                {
-                        qDebug() << QString("Unable to create directory: %1").arg(path);
-                        return false;
-                }
-        }
-
-        return true;
-}
-
-/*!
-        \internal Reads an quint32 (4 bytes) from a byte array starting at given offset.
-*/
-quint32 UnzipPrivate::getULong(const unsigned char* data, quint32 offset) const
-{
-        quint32 res = (quint32) data[offset];
-        res |= (((quint32)data[offset+1]) << 8);
-        res |= (((quint32)data[offset+2]) << 16);
-        res |= (((quint32)data[offset+3]) << 24);
-
-        return res;
-}
-
-/*!
-        \internal Reads an quint64 (8 bytes) from a byte array starting at given offset.
-*/
-quint64 UnzipPrivate::getULLong(const unsigned char* data, quint32 offset) const
-{
-        quint64 res = (quint64) data[offset];
-        res |= (((quint64)data[offset+1]) << 8);
-        res |= (((quint64)data[offset+2]) << 16);
-        res |= (((quint64)data[offset+3]) << 24);
-        res |= (((quint64)data[offset+1]) << 32);
-        res |= (((quint64)data[offset+2]) << 40);
-        res |= (((quint64)data[offset+3]) << 48);
-        res |= (((quint64)data[offset+3]) << 56);
-
-        return res;
-}
-
-/*!
-        \internal Reads an quint16 (2 bytes) from a byte array starting at given offset.
-*/
-quint16 UnzipPrivate::getUShort(const unsigned char* data, quint32 offset) const
-{
-        return (quint16) data[offset] | (((quint16)data[offset+1]) << 8);
-}
-
-/*!
-        \internal Return the next byte in the pseudo-random sequence
- */
-int UnzipPrivate::decryptByte(quint32 key2) const
-{
-        quint16 temp = ((quint16)(key2) & 0xffff) | 2;
-        return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
-}
-
-/*!
-        \internal Update the encryption keys with the next byte of plain text
- */
-void UnzipPrivate::updateKeys(quint32* keys, int c) const
-{
-        keys[0] = CRC32(keys[0], c);
-        keys[1] += keys[0] & 0xff;
-        keys[1] = keys[1] * 134775813L + 1;
-        keys[2] = CRC32(keys[2], ((int)keys[1]) >> 24);
-}
-
-/*!
-        \internal Initialize the encryption keys and the random header according to
-        the given password.
- */
-void UnzipPrivate::initKeys(const QString& pwd, quint32* keys) const
-{
-        keys[0] = 305419896L;
-        keys[1] = 591751049L;
-        keys[2] = 878082192L;
-
-        QByteArray pwdBytes = pwd.toAscii();
-        int sz = pwdBytes.size();
-        const char* ascii = pwdBytes.data();
-
-        for (int i=0; i<sz; ++i)
-                updateKeys(keys, (int)ascii[i]);
-}
-
-/*!
-        \internal Attempts to test a password without actually extracting a file.
-        The \p file parameter can be used in the user interface or for debugging purposes
-        as it is the name of the encrypted file for wich the password is being tested.
-*/
-UnZip::ErrorCode UnzipPrivate::testPassword(quint32* keys, const QString& file, const ZipEntryP& header)
-{
-        Q_UNUSED(file);
-
-        // read encryption keys
-        if (device->read(buffer1, 12) != 12)
-                return UnZip::Corrupted;
-
-        // Replace this code if you want to i.e. call some dialog and ask the user for a password
-        initKeys(password, keys);
-        if (testKeys(header, keys))
-                return UnZip::Ok;
-
-        return UnZip::Skip;
-}
-
-/*!
-        \internal Tests a set of keys on the encryption header.
-*/
-bool UnzipPrivate::testKeys(const ZipEntryP& header, quint32* keys)
-{
-        char lastByte;
-
-        // decrypt encryption header
-        for (int i=0; i<11; ++i)
-                updateKeys(keys, lastByte = buffer1[i] ^ decryptByte(keys[2]));
-        updateKeys(keys, lastByte = buffer1[11] ^ decryptByte(keys[2]));
-
-        // if there is an extended header (bit in the gp flag) buffer[11] is a byte from the file time
-        // with no extended header we have to check the crc high-order byte
-        char c = ((header.gpFlag[0] & 0x08) == 8) ? header.modTime[1] : header.crc >> 24;
-
-        return (lastByte == c);
-}
-
-/*!
-        \internal Decrypts an array of bytes long \p read.
-*/
-void UnzipPrivate::decryptBytes(quint32* keys, char* buffer, qint64 read)
-{
-        for (int i=0; i<(int)read; ++i)
-                updateKeys(keys, buffer[i] ^= decryptByte(keys[2]));
-}
-
-/*!
-        \internal Converts date and time values from ZIP format to a QDateTime object.
-*/
-QDateTime UnzipPrivate::convertDateTime(const unsigned char date[2], const unsigned char time[2]) const
-{
-        QDateTime dt;
-
-        // Usual PKZip low-byte to high-byte order
-
-        // Date: 7 bits = years from 1980, 4 bits = month, 5 bits = day
-        quint16 year = (date[1] >> 1) & 127;
-        quint16 month = ((date[1] << 3) & 14) | ((date[0] >> 5) & 7);
-        quint16 day = date[0] & 31;
-
-        // Time: 5 bits hour, 6 bits minutes, 5 bits seconds with a 2sec precision
-        quint16 hour = (time[1] >> 3) & 31;
-        quint16 minutes = ((time[1] << 3) & 56) | ((time[0] >> 5) & 7);
-        quint16 seconds = (time[0] & 31) * 2;
-
-        dt.setDate(QDate(1980 + year, month, day));
-        dt.setTime(QTime(hour, minutes, seconds));
-        return dt;
-}
diff --git a/rbutil/rbutilqt/zip/unzip.h b/rbutil/rbutilqt/zip/unzip.h
deleted file mode 100644
index 4839e12027..0000000000
--- a/rbutil/rbutilqt/zip/unzip.h
+++ /dev/null
@@ -1,144 +0,0 @@
-/****************************************************************************
-** Filename: unzip.h
-** Last updated [dd/mm/yyyy]: 28/01/2007
-**
-** pkzip 2.0 decompression.
-**
-** Some of the code has been inspired by other open source projects,
-** (mainly Info-Zip and Gilles Vollant's minizip).
-** Compression and decompression actually uses the zlib library.
-**
-** Copyright (C) 2007-2008 Angius Fabrizio. All rights reserved.
-**
-** This file is part of the OSDaB project (http://osdab.sourceforge.net/).
-**
-** This file may be distributed and/or modified under the terms of the
-** GNU General Public License version 2 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.
-**
-** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-**
-** See the file LICENSE.GPL that came with this software distribution or
-** visit http://www.gnu.org/copyleft/gpl.html for GPL licensing information.
-**
-**********************************************************************/
-
-#ifndef OSDAB_UNZIP__H
-#define OSDAB_UNZIP__H
-
-#include <QtGlobal>
-#include <QMap>
-#include <QDateTime>
-
-#include <zlib/zlib.h>
-
-class UnzipPrivate;
-class QIODevice;
-class QFile;
-class QDir;
-class QStringList;
-class QString;
-
-
-class UnZip
-{
-public:
-        enum ErrorCode
-        {
-                Ok,
-                ZlibInit,
-                ZlibError,
-                OpenFailed,
-                PartiallyCorrupted,
-                Corrupted,
-                WrongPassword,
-                NoOpenArchive,
-                FileNotFound,
-                ReadFailed,
-                WriteFailed,
-                SeekFailed,
-                CreateDirFailed,
-                InvalidDevice,
-                InvalidArchive,
-                HeaderConsistencyError,
-
-                Skip, SkipAll // internal use only
-        };
-
-        enum ExtractionOption
-        {
-                //! Extracts paths (default)
-                ExtractPaths = 0x0001,
-                //! Ignores paths and extracts all the files to the same directory
-                SkipPaths = 0x0002
-        };
-        Q_DECLARE_FLAGS(ExtractionOptions, ExtractionOption)
-
-        enum CompressionMethod
-        {
-                NoCompression, Deflated, UnknownCompression
-        };
-
-        enum FileType
-        {
-                File, Directory
-        };
-
-        struct ZipEntry
-        {
-                ZipEntry();
-
-                QString filename;
-                QString comment;
-
-                quint32 compressedSize;
-                quint32 uncompressedSize;
-                quint32 crc32;
-
-                QDateTime lastModified;
-
-                CompressionMethod compression;
-                FileType type;
-
-                bool encrypted;
-        };
-
-        UnZip();
-        virtual ~UnZip();
-
-        bool isOpen() const;
-
-        ErrorCode openArchive(const QString& filename);
-        ErrorCode openArchive(QIODevice* device);
-        void closeArchive();
-
-        QString archiveComment() const;
-
-        QString formatError(UnZip::ErrorCode c) const;
-
-        bool contains(const QString& file) const;
-
-        QStringList fileList() const;
-        QList<ZipEntry> entryList() const;
-
-        ErrorCode extractAll(const QString& dirname, ExtractionOptions options = ExtractPaths);
-        ErrorCode extractAll(const QDir& dir, ExtractionOptions options = ExtractPaths);
-
-        ErrorCode extractFile(const QString& filename, const QString& dirname, ExtractionOptions options = ExtractPaths);
-        ErrorCode extractFile(const QString& filename, const QDir& dir, ExtractionOptions options = ExtractPaths);
-        ErrorCode extractFile(const QString& filename, QIODevice* device, ExtractionOptions options = ExtractPaths);
-
-        ErrorCode extractFiles(const QStringList& filenames, const QString& dirname, ExtractionOptions options = ExtractPaths);
-        ErrorCode extractFiles(const QStringList& filenames, const QDir& dir, ExtractionOptions options = ExtractPaths);
-
-        void setPassword(const QString& pwd);
-
-private:
-        UnzipPrivate* d;
-};
-
-Q_DECLARE_OPERATORS_FOR_FLAGS(UnZip::ExtractionOptions)
-
-#endif // OSDAB_UNZIP__H
diff --git a/rbutil/rbutilqt/zip/unzip_p.h b/rbutil/rbutilqt/zip/unzip_p.h
deleted file mode 100644
index 394c9d5346..0000000000
--- a/rbutil/rbutilqt/zip/unzip_p.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/****************************************************************************
-** Filename: unzip_p.h
-** Last updated [dd/mm/yyyy]: 28/01/2007
-**
-** pkzip 2.0 decompression.
-**
-** Some of the code has been inspired by other open source projects,
-** (mainly Info-Zip and Gilles Vollant's minizip).
-** Compression and decompression actually uses the zlib library.
-**
-** Copyright (C) 2007-2008 Angius Fabrizio. All rights reserved.
-**
-** This file is part of the OSDaB project (http://osdab.sourceforge.net/).
-**
-** This file may be distributed and/or modified under the terms of the
-** GNU General Public License version 2 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.
-**
-** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-**
-** See the file LICENSE.GPL that came with this software distribution or
-** visit http://www.gnu.org/copyleft/gpl.html for GPL licensing information.
-**
-**********************************************************************/
-
-//
-//  W A R N I N G
-//  -------------
-//
-// This file is not part of the Zip/UnZip API.  It exists purely as an
-// implementation detail. This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#ifndef OSDAB_UNZIP_P__H
-#define OSDAB_UNZIP_P__H
-
-#include "unzip.h"
-#include "zipentry_p.h"
-
-#include <QtGlobal>
-
-// zLib authors suggest using larger buffers (128K or 256K) for (de)compression (especially for inflate())
-// we use a 256K buffer here - if you want to use this code on a pre-iceage mainframe please change it ;)
-#define UNZIP_READ_BUFFER (256*1024)
-
-class UnzipPrivate
-{
-public:
-        UnzipPrivate();
-
-        // Replace this with whatever else you use to store/retrieve the password.
-        QString password;
-
-        bool skipAllEncrypted;
-
-        QMap<QString,ZipEntryP*>* headers;
-
-        QIODevice* device;
-
-        char buffer1[UNZIP_READ_BUFFER];
-        char buffer2[UNZIP_READ_BUFFER];
-
-        unsigned char* uBuffer;
-        const quint32* crcTable;
-
-        // Central Directory (CD) offset
-        quint32 cdOffset;
-        // End of Central Directory (EOCD) offset
-        quint32 eocdOffset;
-
-        // Number of entries in the Central Directory (as to the EOCD record)
-        quint16 cdEntryCount;
-
-        // The number of detected entries that have been skipped because of a non compatible format
-        quint16 unsupportedEntryCount;
-
-        QString comment;
-
-        UnZip::ErrorCode openArchive(QIODevice* device);
-
-        UnZip::ErrorCode seekToCentralDirectory();
-        UnZip::ErrorCode parseCentralDirectoryRecord();
-        UnZip::ErrorCode parseLocalHeaderRecord(const QString& path, ZipEntryP& entry);
-
-        void closeArchive();
-
-        UnZip::ErrorCode extractFile(const QString& path, ZipEntryP& entry, const QDir& dir, UnZip::ExtractionOptions options);
-        UnZip::ErrorCode extractFile(const QString& path, ZipEntryP& entry, QIODevice* device, UnZip::ExtractionOptions options);
-
-        UnZip::ErrorCode testPassword(quint32* keys, const QString& file, const ZipEntryP& header);
-        bool testKeys(const ZipEntryP& header, quint32* keys);
-
-        bool createDirectory(const QString& path);
-
-        inline void decryptBytes(quint32* keys, char* buffer, qint64 read);
-
-        inline quint32 getULong(const unsigned char* data, quint32 offset) const;
-        inline quint64 getULLong(const unsigned char* data, quint32 offset) const;
-        inline quint16 getUShort(const unsigned char* data, quint32 offset) const;
-        inline int decryptByte(quint32 key2) const;
-        inline void updateKeys(quint32* keys, int c) const;
-        inline void initKeys(const QString& pwd, quint32* keys) const;
-
-        inline QDateTime convertDateTime(const unsigned char date[2], const unsigned char time[2]) const;
-};
-
-#endif // OSDAB_UNZIP_P__H
diff --git a/rbutil/rbutilqt/zip/zip.cpp b/rbutil/rbutilqt/zip/zip.cpp
deleted file mode 100644
index 9ecd5531ef..0000000000
--- a/rbutil/rbutilqt/zip/zip.cpp
+++ /dev/null
@@ -1,1221 +0,0 @@
-/****************************************************************************
-** Filename: zip.cpp
-** Last updated [dd/mm/yyyy]: 01/02/2007
-**
-** pkzip 2.0 file compression.
-**
-** Some of the code has been inspired by other open source projects,
-** (mainly Info-Zip and Gilles Vollant's minizip).
-** Compression and decompression actually uses the zlib library.
-**
-** Copyright (C) 2007-2008 Angius Fabrizio. All rights reserved.
-**
-** This file is part of the OSDaB project (http://osdab.sourceforge.net/).
-**
-** This file may be distributed and/or modified under the terms of the
-** GNU General Public License version 2 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.
-**
-** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-**
-** See the file LICENSE.GPL that came with this software distribution or
-** visit http://www.gnu.org/copyleft/gpl.html for GPL licensing information.
-**
-**********************************************************************/
-
-#include "zip.h"
-#include "zip_p.h"
-#include "zipentry_p.h"
-
-// we only use this to seed the random number generator
-#include <time.h>
-
-#include <QMap>
-#include <QString>
-#include <QStringList>
-#include <QDir>
-#include <QFile>
-#include <QDateTime>
-#include <QCoreApplication>
-
-// You can remove this #include if you replace the qDebug() statements.
-#include <QtDebug>
-
-//! Local header size (including signature, excluding variable length fields)
-#define ZIP_LOCAL_HEADER_SIZE 30
-//! Encryption header size
-#define ZIP_LOCAL_ENC_HEADER_SIZE 12
-//! Data descriptor size (signature included)
-#define ZIP_DD_SIZE_WS 16
-//! Central Directory record size (signature included)
-#define ZIP_CD_SIZE 46
-//! End of Central Directory record size (signature included)
-#define ZIP_EOCD_SIZE 22
-
-// Some offsets inside a local header record (signature included)
-#define ZIP_LH_OFF_VERS 4
-#define ZIP_LH_OFF_GPFLAG 6
-#define ZIP_LH_OFF_CMET 8
-#define ZIP_LH_OFF_MODT 10
-#define ZIP_LH_OFF_MODD 12
-#define ZIP_LH_OFF_CRC 14
-#define ZIP_LH_OFF_CSIZE 18
-#define ZIP_LH_OFF_USIZE 22
-#define ZIP_LH_OFF_NAMELEN 26
-#define ZIP_LH_OFF_XLEN 28
-
-// Some offsets inside a data descriptor record (including signature)
-#define ZIP_DD_OFF_CRC32 4
-#define ZIP_DD_OFF_CSIZE 8
-#define ZIP_DD_OFF_USIZE 12
-
-// Some offsets inside a Central Directory record (including signature)
-#define ZIP_CD_OFF_MADEBY 4
-#define ZIP_CD_OFF_VERSION 6
-#define ZIP_CD_OFF_GPFLAG 8
-#define ZIP_CD_OFF_CMET 10
-#define ZIP_CD_OFF_MODT 12
-#define ZIP_CD_OFF_MODD 14
-#define ZIP_CD_OFF_CRC 16
-#define ZIP_CD_OFF_CSIZE 20
-#define ZIP_CD_OFF_USIZE 24
-#define ZIP_CD_OFF_NAMELEN 28
-#define ZIP_CD_OFF_XLEN 30
-#define ZIP_CD_OFF_COMMLEN 32
-#define ZIP_CD_OFF_DISKSTART 34
-#define ZIP_CD_OFF_IATTR 36
-#define ZIP_CD_OFF_EATTR 38
-#define ZIP_CD_OFF_LHOFF 42
-
-// Some offsets inside a EOCD record (including signature)
-#define ZIP_EOCD_OFF_DISKNUM 4
-#define ZIP_EOCD_OFF_CDDISKNUM 6
-#define ZIP_EOCD_OFF_ENTRIES 8
-#define ZIP_EOCD_OFF_CDENTRIES 10
-#define ZIP_EOCD_OFF_CDSIZE 12
-#define ZIP_EOCD_OFF_CDOFF 16
-#define ZIP_EOCD_OFF_COMMLEN 20
-
-//! PKZip version for archives created by this API
-#define ZIP_VERSION 0x14
-
-//! Do not store very small files as the compression headers overhead would be to big
-#define ZIP_COMPRESSION_THRESHOLD 60
-
-//! This macro updates a one-char-only CRC; it's the Info-Zip macro re-adapted
-#define CRC32(c, b) crcTable[((int)c^b) & 0xff] ^ (c >> 8)
-
-/*!
-        \class Zip zip.h
-
-        \brief Zip file compression.
-
-        Some quick usage examples.
-
-        \verbatim
-        Suppose you have this directory structure:
-
-        /root/dir1/
-        /root/dir1/file1.1
-        /root/dir1/file1.2
-        /root/dir1/dir1.1/
-        /root/dir1/dir1.2/file1.2.1
-
-        EXAMPLE 1:
-        myZipInstance.addDirectory("/root/dir1");
-
-        RESULT:
-        Beheaves like any common zip software and creates a zip file with this structure:
-
-        dir1/
-        dir1/file1.1
-        dir1/file1.2
-        dir1/dir1.1/
-        dir1/dir1.2/file1.2.1
-
-        EXAMPLE 2:
-        myZipInstance.addDirectory("/root/dir1", "myRoot/myFolder");
-
-        RESULT:
-        Adds a custom root to the paths and creates a zip file with this structure:
-
-        myRoot/myFolder/dir1/
-        myRoot/myFolder/dir1/file1.1
-        myRoot/myFolder/dir1/file1.2
-        myRoot/myFolder/dir1/dir1.1/
-        myRoot/myFolder/dir1/dir1.2/file1.2.1
-
-        EXAMPLE 3:
-        myZipInstance.addDirectory("/root/dir1", Zip::AbsolutePaths);
-
-        NOTE:
-        Same as calling addDirectory(SOME_PATH, PARENT_PATH_of_SOME_PATH).
-
-        RESULT:
-        Preserves absolute paths and creates a zip file with this structure:
-
-        /root/dir1/
-        /root/dir1/file1.1
-        /root/dir1/file1.2
-        /root/dir1/dir1.1/
-        /root/dir1/dir1.2/file1.2.1
-
-        EXAMPLE 4:
-        myZipInstance.setPassword("hellopass");
-        myZipInstance.addDirectory("/root/dir1", "/");
-
-        RESULT:
-        Adds and encrypts the files in /root/dir1, creating the following zip structure:
-
-        /dir1/
-        /dir1/file1.1
-        /dir1/file1.2
-        /dir1/dir1.1/
-        /dir1/dir1.2/file1.2.1
-
-        \endverbatim
-*/
-
-/*! \enum Zip::ErrorCode The result of a compression operation.
-        \value Zip::Ok No error occurred.
-        \value Zip::ZlibInit Failed to init or load the zlib library.
-        \value Zip::ZlibError The zlib library returned some error.
-        \value Zip::FileExists The file already exists and will not be overwritten.
-        \value Zip::OpenFailed Unable to create or open a device.
-        \value Zip::NoOpenArchive CreateArchive() has not been called yet.
-        \value Zip::FileNotFound File or directory does not exist.
-        \value Zip::ReadFailed Reading of a file failed.
-        \value Zip::WriteFailed Writing of a file failed.
-        \value Zip::SeekFailed Seek failed.
-*/
-
-/*! \enum Zip::CompressionLevel Returns the result of a decompression operation.
-        \value Zip::Store No compression.
-        \value Zip::Deflate1 Deflate compression level 1(lowest compression).
-        \value Zip::Deflate1 Deflate compression level 2.
-        \value Zip::Deflate1 Deflate compression level 3.
-        \value Zip::Deflate1 Deflate compression level 4.
-        \value Zip::Deflate1 Deflate compression level 5.
-        \value Zip::Deflate1 Deflate compression level 6.
-        \value Zip::Deflate1 Deflate compression level 7.
-        \value Zip::Deflate1 Deflate compression level 8.
-        \value Zip::Deflate1 Deflate compression level 9 (maximum compression).
-        \value Zip::AutoCPU Adapt compression level to CPU speed (faster CPU => better compression).
-        \value Zip::AutoMIME Adapt compression level to MIME type of the file being compressed.
-        \value Zip::AutoFull Use both CPU and MIME type detection.
-*/
-
-
-/************************************************************************
- Public interface
-*************************************************************************/
-
-/*!
-        Creates a new Zip file compressor.
-*/
-Zip::Zip()
-{
-        d = new ZipPrivate;
-}
-
-/*!
-        Closes any open archive and releases used resources.
-*/
-Zip::~Zip()
-{
-        closeArchive();
-        delete d;
-}
-
-/*!
-        Returns true if there is an open archive.
-*/
-bool Zip::isOpen() const
-{
-        return d->device != 0;
-}
-
-/*!
-        Sets the password to be used for the next files being added!
-        Files added before calling this method will use the previously
-        set password (if any).
-        Closing the archive won't clear the password!
-*/
-void Zip::setPassword(const QString& pwd)
-{
-        d->password = pwd;
-}
-
-//! Convenience method, clears the current password.
-void Zip::clearPassword()
-{
-        d->password.clear();
-}
-
-//! Returns the currently used password.
-QString Zip::password() const
-{
-        return d->password;
-}
-
-/*!
-        Attempts to create a new Zip archive. If \p overwrite is true and the file
-        already exist it will be overwritten.
-        Any open archive will be closed.
- */
-Zip::ErrorCode Zip::createArchive(const QString& filename, bool overwrite)
-{
-        QFile* file = new QFile(filename);
-
-        if (file->exists() && !overwrite) {
-                delete file;
-                return Zip::FileExists;
-        }
-
-        if (!file->open(QIODevice::WriteOnly)) {
-                delete file;
-                return Zip::OpenFailed;
-        }
-
-        Zip::ErrorCode ec = createArchive(file);
-        if (ec != Zip::Ok) {
-                file->remove();
-        }
-
-        return ec;
-}
-
-/*!
-        Attempts to create a new Zip archive. If there is another open archive this will be closed.
-        \warning The class takes ownership of the device!
- */
-Zip::ErrorCode Zip::createArchive(QIODevice* device)
-{
-        if (device == 0)
-        {
-                qDebug() << "Invalid device.";
-                return Zip::OpenFailed;
-        }
-
-        return d->createArchive(device);
-}
-
-/*!
-        Returns the current archive comment.
-*/
-QString Zip::archiveComment() const
-{
-        return d->comment;
-}
-
-/*!
-        Sets the comment for this archive. Note: createArchive() should have been
-        called before.
-*/
-void Zip::setArchiveComment(const QString& comment)
-{
-        if (d->device != 0)
-                d->comment = comment;
-}
-
-/*!
-        Convenience method, same as calling
-        Zip::addDirectory(const QString&,const QString&,CompressionLevel)
-        with an empty \p root parameter (or with the parent directory of \p path if the
-        AbsolutePaths options is set).
-
-        The ExtractionOptions are checked in the order they are defined in the zip.h heaser file.
-        This means that the last one overwrites the previous one (if some conflict occurs), i.e.
-        Zip::IgnorePaths | Zip::AbsolutePaths would be interpreted as Zip::IgnorePaths.
- */
-Zip::ErrorCode Zip::addDirectory(const QString& path, CompressionOptions options, CompressionLevel level)
-{
-        return addDirectory(path, QString(), options, level);
-}
-
-/*!
-        Convenience method, same as calling Zip::addDirectory(const QString&,const QString&,CompressionOptions,CompressionLevel)
-        with the Zip::RelativePaths flag as compression option.
- */
-Zip::ErrorCode Zip::addDirectory(const QString& path, const QString& root, CompressionLevel level)
-{
-        return addDirectory(path, root, Zip::RelativePaths, level);
-}
-
-/*!
-        Convenience method, same as calling Zip::addDirectory(const QString&,const QString&,CompressionOptions,CompressionLevel)
-        with the Zip::IgnorePaths flag as compression option and an empty \p root parameter.
-*/
-Zip::ErrorCode Zip::addDirectoryContents(const QString& path, CompressionLevel level)
-{
-        return addDirectory(path, QString(), IgnorePaths, level);
-}
-
-/*!
-        Convenience method, same as calling Zip::addDirectory(const QString&,const QString&,CompressionOptions,CompressionLevel)
-        with the Zip::IgnorePaths flag as compression option.
-*/
-Zip::ErrorCode Zip::addDirectoryContents(const QString& path, const QString& root, CompressionLevel level)
-{
-        return addDirectory(path, root, IgnorePaths, level);
-}
-
-/*!
-        Recursively adds files contained in \p dir to the archive, using \p root as name for the root folder.
-        Stops adding files if some error occurs.
-
-        The ExtractionOptions are checked in the order they are defined in the zip.h heaser file.
-        This means that the last one overwrites the previous one (if some conflict occurs), i.e.
-        Zip::IgnorePaths | Zip::AbsolutePaths would be interpreted as Zip::IgnorePaths.
-
-        The \p root parameter is ignored with the Zip::IgnorePaths parameter and used as path prefix (a trailing /
-        is always added as directory separator!) otherwise (even with Zip::AbsolutePaths set!).
-*/
-Zip::ErrorCode Zip::addDirectory(const QString& path, const QString& root, CompressionOptions options, CompressionLevel level)
-{
-        // qDebug() << QString("addDir(path=%1, root=%2)").arg(path, root);
-
-        // Bad boy didn't call createArchive() yet :)
-        if (d->device == 0)
-                return Zip::NoOpenArchive;
-
-        QDir dir(path);
-        if (!dir.exists())
-                return Zip::FileNotFound;
-
-        // Remove any trailing separator
-        QString actualRoot = root.trimmed();
-
-        // Preserve Unix root
-        if (actualRoot != "/")
-        {
-                while (actualRoot.endsWith("/") || actualRoot.endsWith("\\"))
-                        actualRoot.truncate(actualRoot.length() - 1);
-        }
-
-        // QDir::cleanPath() fixes some issues with QDir::dirName()
-        QFileInfo current(QDir::cleanPath(path));
-
-        if (!actualRoot.isEmpty() && actualRoot != "/")
-                actualRoot.append("/");
-
-        /* This part is quite confusing and needs some test or check */
-        /* An attempt to compress the / root directory evtl. using a root prefix should be a good test */
-        if (options.testFlag(AbsolutePaths) && !options.testFlag(IgnorePaths))
-        {
-                QString absolutePath = d->extractRoot(path);
-                if (!absolutePath.isEmpty() && absolutePath != "/")
-                        absolutePath.append("/");
-                actualRoot.append(absolutePath);
-        }
-
-        if (!options.testFlag(IgnorePaths))
-        {
-                actualRoot = actualRoot.append(QDir(current.absoluteFilePath()).dirName());
-                actualRoot.append("/");
-        }
-
-        // actualRoot now contains the path of the file relative to the zip archive
-        // with a trailing /
-
-        QFileInfoList list = dir.entryInfoList(
-                QDir::Files |
-                QDir::Dirs |
-                QDir::NoDotAndDotDot |
-                QDir::NoSymLinks);
-
-        ErrorCode ec = Zip::Ok;
-        bool filesAdded = false;
-
-        CompressionOptions recursionOptions;
-        if (options.testFlag(IgnorePaths))
-                recursionOptions |= IgnorePaths;
-        else recursionOptions |= RelativePaths;
-
-        for (int i = 0; i < list.size() && ec == Zip::Ok; ++i)
-        {
-                QFileInfo info = list.at(i);
-
-                if (info.isDir())
-                {
-                        // Recursion :)
-            progress();
-                        ec = addDirectory(info.absoluteFilePath(), actualRoot, recursionOptions, level); 
-                }
-                else
-                {
-            progress();
-                        ec = d->createEntry(info, actualRoot, level);
-                        filesAdded = true;
-        }
-        }
-
-
-        // We need an explicit record for this dir
-        // Non-empty directories don't need it because they have a path component in the filename
-        if (!filesAdded && !options.testFlag(IgnorePaths))
-                ec = d->createEntry(current, actualRoot, level);
-   
-        return ec;
-}
-
-/*!
-        Closes the archive and writes any pending data.
-*/
-Zip::ErrorCode Zip::closeArchive()
-{
-        Zip::ErrorCode ec = d->closeArchive();
-        d->reset();
-        return ec;
-}
-
-/*!
-        Returns a locale translated error string for a given error code.
-*/
-QString Zip::formatError(Zip::ErrorCode c) const
-{
-        switch (c)
-        {
-        case Ok: return QCoreApplication::translate("Zip", "ZIP operation completed successfully."); break;
-        case ZlibInit: return QCoreApplication::translate("Zip", "Failed to initialize or load zlib library."); break;
-        case ZlibError: return QCoreApplication::translate("Zip", "zlib library error."); break;
-        case OpenFailed: return QCoreApplication::translate("Zip", "Unable to create or open file."); break;
-        case NoOpenArchive: return QCoreApplication::translate("Zip", "No archive has been created yet."); break;
-        case FileNotFound: return QCoreApplication::translate("Zip", "File or directory does not exist."); break;
-        case ReadFailed: return QCoreApplication::translate("Zip", "File read error."); break;
-        case WriteFailed: return QCoreApplication::translate("Zip", "File write error."); break;
-        case SeekFailed: return QCoreApplication::translate("Zip", "File seek error."); break;
-        default: ;
-        }
-
-        return QCoreApplication::translate("Zip", "Unknown error.");
-}
-
-
-/************************************************************************
- Private interface
-*************************************************************************/
-
-//! \internal
-ZipPrivate::ZipPrivate()
-{
-        headers = 0;
-        device = 0;
-
-        // keep an unsigned pointer so we avoid to over bloat the code with casts
-        uBuffer = (unsigned char*) buffer1;
-        crcTable = (quint32*) get_crc_table();
-}
-
-//! \internal
-ZipPrivate::~ZipPrivate()
-{
-        closeArchive();
-}
-
-//! \internal
-Zip::ErrorCode ZipPrivate::createArchive(QIODevice* dev)
-{
-        Q_ASSERT(dev != 0);
-
-        if (device != 0)
-                closeArchive();
-
-        device = dev;
-
-        if (!device->isOpen())
-        {
-                if (!device->open(QIODevice::ReadOnly)) {
-                        delete device;
-                        device = 0;
-                        qDebug() << "Unable to open device for writing.";
-                        return Zip::OpenFailed;
-                }
-        }
-
-        headers = new QMap<QString,ZipEntryP*>;
-        return Zip::Ok;
-}
-
-//! \internal Writes a new entry in the zip file.
-Zip::ErrorCode ZipPrivate::createEntry(const QFileInfo& file, const QString& root, Zip::CompressionLevel level)
-{
-        //! \todo Automatic level detection (cpu, extension & file size)
-
-        // Directories and very small files are always stored
-        // (small files would get bigger due to the compression headers overhead)
-
-        // Need this for zlib
-        bool isPNGFile = false;
-        bool dirOnly = file.isDir();
-
-        QString entryName = root;
-
-        // Directory entry
-        if (dirOnly)
-                level = Zip::Store;
-        else
-        {
-                entryName.append(file.fileName());
-
-                QString ext = file.completeSuffix().toLower();
-                isPNGFile = ext == "png";
-
-                if (file.size() < ZIP_COMPRESSION_THRESHOLD)
-                        level = Zip::Store;
-                else
-                        switch (level)
-                        {
-                        case Zip::AutoCPU:
-                                level = Zip::Deflate5;
-                                break;
-                        case Zip::AutoMIME:
-                                level = detectCompressionByMime(ext);
-                                break;
-                        case Zip::AutoFull:
-                                level = detectCompressionByMime(ext);
-                                break;
-                        default:
-                                ;
-                        }
-        }
-
-        // entryName contains the path as it should be written
-        // in the zip file records
-        // qDebug() << QString("addDir(file=%1, root=%2, entry=%3)").arg(file.absoluteFilePath(), root, entryName);
-
-        // create header and store it to write a central directory later
-        ZipEntryP* h = new ZipEntryP;
-
-        h->compMethod = (level == Zip::Store) ? 0 : 0x0008;
-
-        // Set encryption bit and set the data descriptor bit
-        // so we can use mod time instead of crc for password check
-        bool encrypt = !dirOnly && !password.isEmpty();
-        if (encrypt)
-                h->gpFlag[0] |= 9;
-
-        QDateTime dt = file.lastModified();
-        QDate d = dt.date();
-        h->modDate[1] = ((d.year() - 1980) << 1) & 254;
-        h->modDate[1] |= ((d.month() >> 3) & 1);
-        h->modDate[0] = ((d.month() & 7) << 5) & 224;
-        h->modDate[0] |= d.day();
-
-        QTime t = dt.time();
-        h->modTime[1] = (t.hour() << 3) & 248;
-        h->modTime[1] |= ((t.minute() >> 3) & 7);
-        h->modTime[0] = ((t.minute() & 7) << 5) & 224;
-        h->modTime[0] |= t.second() / 2;
-
-        h->szUncomp = dirOnly ? 0 : file.size();
-
-        // **** Write local file header ****
-
-        // signature
-        buffer1[0] = 'P'; buffer1[1] = 'K';
-        buffer1[2] = 0x3; buffer1[3] = 0x4;
-
-        // version needed to extract
-        buffer1[ZIP_LH_OFF_VERS] = ZIP_VERSION;
-        buffer1[ZIP_LH_OFF_VERS + 1] = 0;
-
-        // general purpose flag
-        buffer1[ZIP_LH_OFF_GPFLAG] = h->gpFlag[0];
-        buffer1[ZIP_LH_OFF_GPFLAG + 1] = h->gpFlag[1];
-
-        // compression method
-        buffer1[ZIP_LH_OFF_CMET] = h->compMethod & 0xFF;
-        buffer1[ZIP_LH_OFF_CMET + 1] = (h->compMethod>>8) & 0xFF;
-
-        // last mod file time
-        buffer1[ZIP_LH_OFF_MODT] = h->modTime[0];
-        buffer1[ZIP_LH_OFF_MODT + 1] = h->modTime[1];
-
-        // last mod file date
-        buffer1[ZIP_LH_OFF_MODD] = h->modDate[0];
-        buffer1[ZIP_LH_OFF_MODD + 1] = h->modDate[1];
-
-        // skip crc (4bytes) [14,15,16,17]
-
-        // skip compressed size but include evtl. encryption header (4bytes: [18,19,20,21])
-        buffer1[ZIP_LH_OFF_CSIZE] =
-        buffer1[ZIP_LH_OFF_CSIZE + 1] =
-        buffer1[ZIP_LH_OFF_CSIZE + 2] =
-        buffer1[ZIP_LH_OFF_CSIZE + 3] = 0;
-
-        h->szComp = encrypt ? ZIP_LOCAL_ENC_HEADER_SIZE : 0;
-
-        // uncompressed size [22,23,24,25]
-        setULong(h->szUncomp, buffer1, ZIP_LH_OFF_USIZE);
-
-        // filename length
-        QByteArray entryNameBytes = entryName.toAscii();
-        int sz = entryNameBytes.size();
-
-        buffer1[ZIP_LH_OFF_NAMELEN] = sz & 0xFF;
-        buffer1[ZIP_LH_OFF_NAMELEN + 1] = (sz >> 8) & 0xFF;
-
-        // extra field length
-        buffer1[ZIP_LH_OFF_XLEN] = buffer1[ZIP_LH_OFF_XLEN + 1] = 0;
-
-        // Store offset to write crc and compressed size
-        h->lhOffset = device->pos();
-        quint32 crcOffset = h->lhOffset + ZIP_LH_OFF_CRC;
-
-        if (device->write(buffer1, ZIP_LOCAL_HEADER_SIZE) != ZIP_LOCAL_HEADER_SIZE)
-        {
-                delete h;
-                return Zip::WriteFailed;
-        }
-
-        // Write out filename
-        if (device->write(entryNameBytes) != sz)
-        {
-                delete h;
-                return Zip::WriteFailed;
-        }
-
-        // Encryption keys
-        quint32 keys[3] = { 0, 0, 0 };
-
-        if (encrypt)
-        {
-                // **** encryption header ****
-
-                // XOR with PI to ensure better random numbers
-                // with poorly implemented rand() as suggested by Info-Zip
-                srand(time(NULL) ^ 3141592654UL);
-                int randByte;
-
-                initKeys(keys);
-                for (int i=0; i<10; ++i)
-                {
-                        randByte = (rand() >> 7) & 0xff;
-                        buffer1[i] = decryptByte(keys[2]) ^ randByte;
-                        updateKeys(keys, randByte);
-                }
-
-                // Encrypt encryption header
-                initKeys(keys);
-                for (int i=0; i<10; ++i)
-                {
-                        randByte = decryptByte(keys[2]);
-                        updateKeys(keys, buffer1[i]);
-                        buffer1[i] ^= randByte;
-                }
-
-                // We don't know the CRC at this time, so we use the modification time
-                // as the last two bytes
-                randByte = decryptByte(keys[2]);
-                updateKeys(keys, h->modTime[0]);
-                buffer1[10] ^= randByte;
-
-                randByte = decryptByte(keys[2]);
-                updateKeys(keys, h->modTime[1]);
-                buffer1[11] ^= randByte;
-
-                // Write out encryption header
-                if (device->write(buffer1, ZIP_LOCAL_ENC_HEADER_SIZE) != ZIP_LOCAL_ENC_HEADER_SIZE)
-                {
-                        delete h;
-                        return Zip::WriteFailed;
-                }
-        }
-
-        qint64 written = 0;
-        quint32 crc = crc32(0L, Z_NULL, 0);
-
-        if (!dirOnly)
-        {
-                QFile actualFile(file.absoluteFilePath());
-                if (!actualFile.open(QIODevice::ReadOnly))
-                {
-                        qDebug() << QString("An error occurred while opening %1").arg(file.absoluteFilePath());
-                        return Zip::OpenFailed;
-                }
-
-                // Write file data
-                qint64 read = 0;
-                qint64 totRead = 0;
-                qint64 toRead = actualFile.size();
-
-                if (level == Zip::Store)
-                {
-                        while ( (read = actualFile.read(buffer1, ZIP_READ_BUFFER)) > 0 )
-                        {
-                                crc = crc32(crc, uBuffer, read);
-
-                                if (password != 0)
-                                        encryptBytes(keys, buffer1, read);
-
-                                if ( (written = device->write(buffer1, read)) != read )
-                                {
-                                        actualFile.close();
-                                        delete h;
-                                        return Zip::WriteFailed;
-                                }
-                        }
-                }
-                else
-                {
-                        z_stream zstr;
-
-                        // Initialize zalloc, zfree and opaque before calling the init function
-                        zstr.zalloc = Z_NULL;
-                        zstr.zfree = Z_NULL;
-                        zstr.opaque = Z_NULL;
-
-                        int zret;
-
-                        // Use deflateInit2 with negative windowBits to get raw compression
-                        if ((zret = deflateInit2_(
-                                        &zstr,
-                                        (int)level,
-                                        Z_DEFLATED,
-                                        -MAX_WBITS,
-                                        8,
-                                        isPNGFile ? Z_RLE : Z_DEFAULT_STRATEGY,
-                                        ZLIB_VERSION,
-                                        sizeof(z_stream)
-                                )) != Z_OK )
-                        {
-                                actualFile.close();
-                                qDebug() << "Could not initialize zlib for compression";
-                                delete h;
-                                return Zip::ZlibError;
-                        }
-
-                        qint64 compressed;
-
-                        int flush = Z_NO_FLUSH;
-
-                        do
-                        {
-                                read = actualFile.read(buffer1, ZIP_READ_BUFFER);
-                                totRead += read;
-
-                                if (read == 0)
-                                        break;
-                                if (read < 0)
-                                {
-                                        actualFile.close();
-                                        deflateEnd(&zstr);
-                                        qDebug() << QString("Error while reading %1").arg(file.absoluteFilePath());
-                                        delete h;
-                                        return Zip::ReadFailed;
-                                }
-
-                                crc = crc32(crc, uBuffer, read);
-
-                                zstr.next_in = (Bytef*) buffer1;
-                                zstr.avail_in = (uInt)read;
-
-                                // Tell zlib if this is the last chunk we want to encode
-                                // by setting the flush parameter to Z_FINISH
-                                flush = (totRead == toRead) ? Z_FINISH : Z_NO_FLUSH;
-
-                                // Run deflate() on input until output buffer not full
-                                // finish compression if all of source has been read in
-                        do
-                        {
-                                        zstr.next_out = (Bytef*) buffer2;
-                                        zstr.avail_out = ZIP_READ_BUFFER;
-
-                                        zret = deflate(&zstr, flush);
-                                        // State not clobbered
-                                        Q_ASSERT(zret != Z_STREAM_ERROR);
-
-                                        // Write compressed data to file and empty buffer
-                                        compressed = ZIP_READ_BUFFER - zstr.avail_out;
-
-                                        if (password != 0)
-                                                encryptBytes(keys, buffer2, compressed);
-
-                                        if (device->write(buffer2, compressed) != compressed)
-                                        {
-                                                deflateEnd(&zstr);
-                                                actualFile.close();
-                                                qDebug() << QString("Error while writing %1").arg(file.absoluteFilePath());
-                                                delete h;
-                                                return Zip::WriteFailed;
-                                        }
-
-                                        written += compressed;
-
-                                } while (zstr.avail_out == 0);
-
-                                // All input will be used
-                                Q_ASSERT(zstr.avail_in == 0);
-
-                        } while (flush != Z_FINISH);
-
-                        // Stream will be complete
-                        Q_ASSERT(zret == Z_STREAM_END);
-
-                        deflateEnd(&zstr);
-
-                } // if (level != STORE)
-
-                actualFile.close();
-        }
-
-        // Store end of entry offset
-        quint32 current = device->pos();
-
-        // Update crc and compressed size in local header
-        if (!device->seek(crcOffset))
-        {
-                delete h;
-                return Zip::SeekFailed;
-        }
-
-        h->crc = dirOnly ? 0 : crc;
-        h->szComp += written;
-
-        setULong(h->crc, buffer1, 0);
-        setULong(h->szComp, buffer1, 4);
-        if ( device->write(buffer1, 8) != 8)
-        {
-                delete h;
-                return Zip::WriteFailed;
-        }
-
-        // Seek to end of entry
-        if (!device->seek(current))
-        {
-                delete h;
-                return Zip::SeekFailed;
-        }
-
-        if ((h->gpFlag[0] & 8) == 8)
-        {
-                // Write data descriptor
-
-                // Signature: PK\7\8
-                buffer1[0] = 'P';
-                buffer1[1] = 'K';
-                buffer1[2] = 0x07;
-                buffer1[3] = 0x08;
-
-                // CRC
-                setULong(h->crc, buffer1, ZIP_DD_OFF_CRC32);
-
-                // Compressed size
-                setULong(h->szComp, buffer1, ZIP_DD_OFF_CSIZE);
-
-                // Uncompressed size
-                setULong(h->szUncomp, buffer1, ZIP_DD_OFF_USIZE);
-
-                if (device->write(buffer1, ZIP_DD_SIZE_WS) != ZIP_DD_SIZE_WS)
-                {
-                        delete h;
-                        return Zip::WriteFailed;
-                }
-        }
-
-        headers->insert(entryName, h);
-        return Zip::Ok;
-}
-
-//! \internal
-int ZipPrivate::decryptByte(quint32 key2) const
-{
-        quint16 temp = ((quint16)(key2) & 0xffff) | 2;
-        return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
-}
-
-//! \internal Writes an quint32 (4 bytes) to a byte array at given offset.
-void ZipPrivate::setULong(quint32 v, char* buffer, unsigned int offset)
-{
-        buffer[offset+3] = ((v >> 24) & 0xFF);
-        buffer[offset+2] = ((v >> 16) & 0xFF);
-        buffer[offset+1] = ((v >> 8) & 0xFF);
-        buffer[offset] = (v & 0xFF);
-}
-
-//! \internal Initializes decryption keys using a password.
-void ZipPrivate::initKeys(quint32* keys) const
-{
-        // Encryption keys initialization constants are taken from the
-        // PKZip file format specification docs
-        keys[0] = 305419896L;
-        keys[1] = 591751049L;
-        keys[2] = 878082192L;
-
-        QByteArray pwdBytes = password.toAscii();
-        int sz = pwdBytes.size();
-        const char* ascii = pwdBytes.data();
-
-        for (int i=0; i<sz; ++i)
-                updateKeys(keys, (int)ascii[i]);
-}
-
-//! \internal Updates encryption keys.
-void ZipPrivate::updateKeys(quint32* keys, int c) const
-{
-        keys[0] = CRC32(keys[0], c);
-        keys[1] += keys[0] & 0xff;
-        keys[1] = keys[1] * 134775813L + 1;
-        keys[2] = CRC32(keys[2], ((int)keys[1]) >> 24);
-}
-
-//! \internal Encrypts a byte array.
-void ZipPrivate::encryptBytes(quint32* keys, char* buffer, qint64 read)
-{
-        char t;
-
-        for (int i=0; i<(int)read; ++i)
-        {
-                t = buffer[i];
-                buffer[i] ^= decryptByte(keys[2]);
-                updateKeys(keys, t);
-        }
-}
-
-//! \internal Detects the best compression level for a given file extension.
-Zip::CompressionLevel ZipPrivate::detectCompressionByMime(const QString& ext)
-{
-        // files really hard to compress
-        if ((ext == "png") ||
-                (ext == "jpg") ||
-                (ext == "jpeg") ||
-                (ext == "mp3") ||
-                (ext == "ogg") ||
-                (ext == "ogm") ||
-                (ext == "avi") ||
-                (ext == "mov") ||
-                (ext == "rm") ||
-                (ext == "ra") ||
-                (ext == "zip") ||
-                (ext == "rar") ||
-                (ext == "bz2") ||
-                (ext == "gz") ||
-                (ext == "7z") ||
-                (ext == "z") ||
-                (ext == "jar")
-        ) return Zip::Store;
-
-        // files slow and hard to compress
-        if ((ext == "exe") ||
-                (ext == "bin") ||
-                (ext == "rpm") ||
-                (ext == "deb")
-        ) return Zip::Deflate2;
-
-        return Zip::Deflate9;
-}
-
-/*!
-        Closes the current archive and writes out pending data.
-*/
-Zip::ErrorCode ZipPrivate::closeArchive()
-{
-        // Close current archive by writing out central directory
-        // and free up resources
-
-        if (device == 0)
-                return Zip::Ok;
-
-        if (headers == 0)
-                return Zip::Ok;
-
-        const ZipEntryP* h;
-
-        unsigned int sz;
-        quint32 szCentralDir = 0;
-        quint32 offCentralDir = device->pos();
-
-        for (QMap<QString,ZipEntryP*>::ConstIterator itr = headers->constBegin(); itr != headers->constEnd(); ++itr)
-        {
-                h = itr.value();
-
-                // signature
-                buffer1[0] = 'P';
-                buffer1[1] = 'K';
-                buffer1[2] = 0x01;
-                buffer1[3] = 0x02;
-
-                // version made by  (currently only MS-DOS/FAT - no symlinks or other stuff supported)
-                buffer1[ZIP_CD_OFF_MADEBY] = buffer1[ZIP_CD_OFF_MADEBY + 1] = 0;
-
-                // version needed to extract
-                buffer1[ZIP_CD_OFF_VERSION] = ZIP_VERSION;
-                buffer1[ZIP_CD_OFF_VERSION + 1] = 0;
-
-                // general purpose flag
-                buffer1[ZIP_CD_OFF_GPFLAG] = h->gpFlag[0];
-                buffer1[ZIP_CD_OFF_GPFLAG + 1] = h->gpFlag[1];
-
-                // compression method
-                buffer1[ZIP_CD_OFF_CMET] = h->compMethod & 0xFF;
-                buffer1[ZIP_CD_OFF_CMET + 1] = (h->compMethod >> 8) & 0xFF;
-
-                // last mod file time
-                buffer1[ZIP_CD_OFF_MODT] = h->modTime[0];
-                buffer1[ZIP_CD_OFF_MODT + 1] = h->modTime[1];
-
-                // last mod file date
-                buffer1[ZIP_CD_OFF_MODD] = h->modDate[0];
-                buffer1[ZIP_CD_OFF_MODD + 1] = h->modDate[1];
-
-                // crc (4bytes) [16,17,18,19]
-                setULong(h->crc, buffer1, ZIP_CD_OFF_CRC);
-
-                // compressed size (4bytes: [20,21,22,23])
-                setULong(h->szComp, buffer1, ZIP_CD_OFF_CSIZE);
-
-                // uncompressed size [24,25,26,27]
-                setULong(h->szUncomp, buffer1, ZIP_CD_OFF_USIZE);
-
-                // filename
-                QByteArray fileNameBytes = itr.key().toAscii();
-                sz = fileNameBytes.size();
-                buffer1[ZIP_CD_OFF_NAMELEN] = sz & 0xFF;
-                buffer1[ZIP_CD_OFF_NAMELEN + 1] = (sz >> 8) & 0xFF;
-
-                // extra field length
-                buffer1[ZIP_CD_OFF_XLEN] = buffer1[ZIP_CD_OFF_XLEN + 1] = 0;
-
-                // file comment length
-                buffer1[ZIP_CD_OFF_COMMLEN] = buffer1[ZIP_CD_OFF_COMMLEN + 1] = 0;
-
-                // disk number start
-                buffer1[ZIP_CD_OFF_DISKSTART] = buffer1[ZIP_CD_OFF_DISKSTART + 1] = 0;
-
-                // internal file attributes
-                buffer1[ZIP_CD_OFF_IATTR] = buffer1[ZIP_CD_OFF_IATTR + 1] = 0;
-
-                // external file attributes
-                buffer1[ZIP_CD_OFF_EATTR] =
-                buffer1[ZIP_CD_OFF_EATTR + 1] =
-                buffer1[ZIP_CD_OFF_EATTR + 2] =
-                buffer1[ZIP_CD_OFF_EATTR + 3] = 0;
-
-                // relative offset of local header [42->45]
-                setULong(h->lhOffset, buffer1, ZIP_CD_OFF_LHOFF);
-
-                if (device->write(buffer1, ZIP_CD_SIZE) != ZIP_CD_SIZE)
-                {
-                        //! \todo See if we can detect QFile objects using the Qt Meta Object System
-                        /*
-                        if (!device->remove())
-                                qDebug() << tr("Unable to delete corrupted archive: %1").arg(device->fileName());
-                        */
-                        return Zip::WriteFailed;
-                }
-
-                // Write out filename
-                if ((unsigned int)device->write(fileNameBytes) != sz)
-                {
-                        //! \todo SAME AS ABOVE: See if we can detect QFile objects using the Qt Meta Object System
-                        /*
-                        if (!device->remove())
-                                qDebug() << tr("Unable to delete corrupted archive: %1").arg(device->fileName());
-                                */
-                        return Zip::WriteFailed;
-                }
-
-                szCentralDir += (ZIP_CD_SIZE + sz);
-
-        } // central dir headers loop
-
-
-        // Write end of central directory
-
-        // signature
-        buffer1[0] = 'P';
-        buffer1[1] = 'K';
-        buffer1[2] = 0x05;
-        buffer1[3] = 0x06;
-
-        // number of this disk
-        buffer1[ZIP_EOCD_OFF_DISKNUM] = buffer1[ZIP_EOCD_OFF_DISKNUM + 1] = 0;
-
-        // number of disk with central directory
-        buffer1[ZIP_EOCD_OFF_CDDISKNUM] = buffer1[ZIP_EOCD_OFF_CDDISKNUM + 1] = 0;
-
-        // number of entries in this disk
-        sz = headers->count();
-    buffer1[ZIP_EOCD_OFF_ENTRIES] = sz & 0xFF;
-        buffer1[ZIP_EOCD_OFF_ENTRIES + 1] = (sz >> 8) & 0xFF;
-
-        // total number of entries
-        buffer1[ZIP_EOCD_OFF_CDENTRIES] = buffer1[ZIP_EOCD_OFF_ENTRIES];
-        buffer1[ZIP_EOCD_OFF_CDENTRIES + 1] = buffer1[ZIP_EOCD_OFF_ENTRIES + 1];
-
-        // size of central directory [12->15]
-        setULong(szCentralDir, buffer1, ZIP_EOCD_OFF_CDSIZE);
-
-        // central dir offset [16->19]
-        setULong(offCentralDir, buffer1, ZIP_EOCD_OFF_CDOFF);
-
-        // ZIP file comment length
-        QByteArray commentBytes = comment.toAscii();
-        quint16 commentLength = commentBytes.size();
-
-        if (commentLength == 0)
-        {
-                buffer1[ZIP_EOCD_OFF_COMMLEN] = buffer1[ZIP_EOCD_OFF_COMMLEN + 1] = 0;
-        }
-        else
-        {
-                buffer1[ZIP_EOCD_OFF_COMMLEN] = commentLength & 0xFF;
-                buffer1[ZIP_EOCD_OFF_COMMLEN + 1] = (commentLength >> 8) & 0xFF;
-        }
-
-        if (device->write(buffer1, ZIP_EOCD_SIZE) != ZIP_EOCD_SIZE)
-        {
-                //! \todo SAME AS ABOVE: See if we can detect QFile objects using the Qt Meta Object System
-                /*
-                if (!device->remove())
-                        qDebug() << tr("Unable to delete corrupted archive: %1").arg(device->fileName());
-                        */
-                return Zip::WriteFailed;
-        }
-
-        if (commentLength != 0)
-        {
-                if ((unsigned int)device->write(commentBytes) != commentLength)
-                {
-                        //! \todo SAME AS ABOVE: See if we can detect QFile objects using the Qt Meta Object System
-                        /*
-                        if (!device->remove())
-                                qDebug() << tr("Unable to delete corrupted archive: %1").arg(device->fileName());
-                                */
-                        return Zip::WriteFailed;
-                }
-        }
-
-        return Zip::Ok;
-}
-
-//! \internal
-void ZipPrivate::reset()
-{
-        comment.clear();
-
-        if (headers != 0)
-        {
-                qDeleteAll(*headers);
-                delete headers;
-                headers = 0;
-        }
-
-        delete device; device = 0;
-}
-
-//! \internal Returns the path of the parent directory
-QString ZipPrivate::extractRoot(const QString& p)
-{
-        QDir d(QDir::cleanPath(p));
-        if (!d.exists())
-                return QString();
-
-        if (!d.cdUp())
-                return QString();
-
-        return d.absolutePath();
-}
diff --git a/rbutil/rbutilqt/zip/zip.h b/rbutil/rbutilqt/zip/zip.h
deleted file mode 100644
index dfe5deb064..0000000000
--- a/rbutil/rbutilqt/zip/zip.h
+++ /dev/null
@@ -1,115 +0,0 @@
-/****************************************************************************
-** Filename: zip.h
-** Last updated [dd/mm/yyyy]: 01/02/2007
-**
-** pkzip 2.0 file compression.
-**
-** Some of the code has been inspired by other open source projects,
-** (mainly Info-Zip and Gilles Vollant's minizip).
-** Compression and decompression actually uses the zlib library.
-**
-** Copyright (C) 2007-2008 Angius Fabrizio. All rights reserved.
-**
-** This file is part of the OSDaB project (http://osdab.sourceforge.net/).
-**
-** This file may be distributed and/or modified under the terms of the
-** GNU General Public License version 2 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.
-**
-** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-**
-** See the file LICENSE.GPL that came with this software distribution or
-** visit http://www.gnu.org/copyleft/gpl.html for GPL licensing information.
-**
-**********************************************************************/
-
-#ifndef OSDAB_ZIP__H
-#define OSDAB_ZIP__H
-
-#include <QtGlobal>
-#include <QMap>
-
-#include <zlib/zlib.h>
-
-class ZipPrivate;
-
-class QIODevice;
-class QFile;
-class QDir;
-class QStringList;
-class QString;
-
-
-class Zip
-{
-public:
-        enum ErrorCode
-        {
-                Ok,
-                ZlibInit,
-                ZlibError,
-                FileExists,
-                OpenFailed,
-                NoOpenArchive,
-                FileNotFound,
-                ReadFailed,
-                WriteFailed,
-                SeekFailed
-        };
-
-        enum CompressionLevel
-        {
-                Store,
-                Deflate1 = 1, Deflate2, Deflate3, Deflate4,
-                Deflate5, Deflate6, Deflate7, Deflate8, Deflate9,
-                AutoCPU, AutoMIME, AutoFull
-        };
-
-        enum CompressionOption
-        {
-                //! Does not preserve absolute paths in the zip file when adding a file/directory (default)
-                RelativePaths = 0x0001,
-                //! Preserve absolute paths
-                AbsolutePaths = 0x0002,
-                //! Do not store paths. All the files are put in the (evtl. user defined) root of the zip file
-                IgnorePaths = 0x0004
-        };
-        Q_DECLARE_FLAGS(CompressionOptions, CompressionOption)
-
-        Zip();
-        virtual ~Zip();
-
-        bool isOpen() const;
-
-        void setPassword(const QString& pwd);
-        void clearPassword();
-        QString password() const;
-
-        ErrorCode createArchive(const QString& file, bool overwrite = true);
-        ErrorCode createArchive(QIODevice* device);
-
-        QString archiveComment() const;
-        void setArchiveComment(const QString& comment);
-
-        ErrorCode addDirectoryContents(const QString& path, CompressionLevel level = AutoFull);
-        ErrorCode addDirectoryContents(const QString& path, const QString& root, CompressionLevel level = AutoFull);
-
-        ErrorCode addDirectory(const QString& path, CompressionOptions options = RelativePaths, CompressionLevel level = AutoFull);
-        ErrorCode addDirectory(const QString& path, const QString& root, CompressionLevel level = AutoFull);
-        ErrorCode addDirectory(const QString& path, const QString& root, CompressionOptions options = RelativePaths, CompressionLevel level = AutoFull);
-
-        ErrorCode closeArchive();
-
-        QString formatError(ErrorCode c) const;
-    
-    virtual void progress() {}
-    
-private:
-        ZipPrivate* d;
-};
-
-Q_DECLARE_OPERATORS_FOR_FLAGS(Zip::CompressionOptions)
-
-#endif // OSDAB_ZIP__H
diff --git a/rbutil/rbutilqt/zip/zip_p.h b/rbutil/rbutilqt/zip/zip_p.h
deleted file mode 100644
index 271cc1859f..0000000000
--- a/rbutil/rbutilqt/zip/zip_p.h
+++ /dev/null
@@ -1,93 +0,0 @@
-/****************************************************************************
-** Filename: zip_p.h
-** Last updated [dd/mm/yyyy]: 28/01/2007
-**
-** pkzip 2.0 file compression.
-**
-** Some of the code has been inspired by other open source projects,
-** (mainly Info-Zip and Gilles Vollant's minizip).
-** Compression and decompression actually uses the zlib library.
-**
-** Copyright (C) 2007-2008 Angius Fabrizio. All rights reserved.
-**
-** This file is part of the OSDaB project (http://osdab.sourceforge.net/).
-**
-** This file may be distributed and/or modified under the terms of the
-** GNU General Public License version 2 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.
-**
-** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-**
-** See the file LICENSE.GPL that came with this software distribution or
-** visit http://www.gnu.org/copyleft/gpl.html for GPL licensing information.
-**
-**********************************************************************/
-
-//
-//  W A R N I N G
-//  -------------
-//
-// This file is not part of the Zip/UnZip API.  It exists purely as an
-// implementation detail. This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#ifndef OSDAB_ZIP_P__H
-#define OSDAB_ZIP_P__H
-
-#include "zip.h"
-#include "zipentry_p.h"
-
-#include <QtGlobal>
-#include <QFileInfo>
-
-/*!
-        zLib authors suggest using larger buffers (128K or 256K) for (de)compression (especially for inflate())
-        we use a 256K buffer here - if you want to use this code on a pre-iceage mainframe please change it ;)
-*/
-#define ZIP_READ_BUFFER (256*1024)
-
-class ZipPrivate
-{
-public:
-        ZipPrivate();
-        virtual ~ZipPrivate();
-
-        QMap<QString,ZipEntryP*>* headers;
-
-        QIODevice* device;
-
-        char buffer1[ZIP_READ_BUFFER];
-        char buffer2[ZIP_READ_BUFFER];
-
-        unsigned char* uBuffer;
-
-        const quint32* crcTable;
-
-        QString comment;
-        QString password;
-
-        Zip::ErrorCode createArchive(QIODevice* device);
-        Zip::ErrorCode closeArchive();
-        void reset();
-
-        bool zLibInit();
-
-        Zip::ErrorCode createEntry(const QFileInfo& file, const QString& root, Zip::CompressionLevel level);
-        Zip::CompressionLevel detectCompressionByMime(const QString& ext);
-
-        inline void encryptBytes(quint32* keys, char* buffer, qint64 read);
-
-        inline void setULong(quint32 v, char* buffer, unsigned int offset);
-        inline void updateKeys(quint32* keys, int c) const;
-        inline void initKeys(quint32* keys) const;
-        inline int decryptByte(quint32 key2) const;
-
-        inline QString extractRoot(const QString& p);
-};
-
-#endif // OSDAB_ZIP_P__H
diff --git a/rbutil/rbutilqt/zip/zipentry_p.h b/rbutil/rbutilqt/zip/zipentry_p.h
deleted file mode 100644
index c88253ee8c..0000000000
--- a/rbutil/rbutilqt/zip/zipentry_p.h
+++ /dev/null
@@ -1,78 +0,0 @@
-/****************************************************************************
-** Filename: ZipEntryP.h
-** Last updated [dd/mm/yyyy]: 28/01/2007
-**
-** Wrapper for a ZIP local header.
-**
-** Some of the code has been inspired by other open source projects,
-** (mainly Info-Zip and Gilles Vollant's minizip).
-** Compression and decompression actually uses the zlib library.
-**
-** Copyright (C) 2007-2008 Angius Fabrizio. All rights reserved.
-**
-** This file is part of the OSDaB project (http://osdab.sourceforge.net/).
-**
-** This file may be distributed and/or modified under the terms of the
-** GNU General Public License version 2 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file.
-**
-** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
-** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-**
-** See the file LICENSE.GPL that came with this software distribution or
-** visit http://www.gnu.org/copyleft/gpl.html for GPL licensing information.
-**
-**********************************************************************/
-
-//
-//  W A R N I N G
-//  -------------
-//
-// This file is not part of the Zip/UnZip API.  It exists purely as an
-// implementation detail. This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#ifndef OSDAB_ZIPENTRY_P__H
-#define OSDAB_ZIPENTRY_P__H
-
-#include <QtGlobal>
-#include <QString>
-
-class ZipEntryP
-{
-public:
-        ZipEntryP()
-        {
-                lhOffset = 0;
-                dataOffset = 0;
-                gpFlag[0] = gpFlag[1] = 0;
-                compMethod = 0;
-                modTime[0] = modTime[1] = 0;
-                modDate[0] = modDate[1] = 0;
-                crc = 0;
-                szComp = szUncomp = 0;
-                lhEntryChecked = false;
-        }
-
-        quint32 lhOffset;                       // Offset of the local header record for this entry
-        quint32 dataOffset;                     // Offset of the file data for this entry
-        unsigned char gpFlag[2];        // General purpose flag
-        quint16 compMethod;                     // Compression method
-        unsigned char modTime[2];       // Last modified time
-        unsigned char modDate[2];       // Last modified date
-        quint32 crc;                            // CRC32
-        quint32 szComp;                         // Compressed file size
-        quint32 szUncomp;                       // Uncompressed file size
-        QString comment;                        // File comment
-
-        bool lhEntryChecked;            // Is true if the local header record for this entry has been parsed
-
-        inline bool isEncrypted() const { return gpFlag[0] & 0x01; }
-        inline bool hasDataDescriptor() const { return gpFlag[0] & 0x08; }
-};
-
-#endif // OSDAB_ZIPENTRY_P__H