From 7c52284b294cb33bc2e5d747e2e3c14d8ab937ae Mon Sep 17 00:00:00 2001 From: Robert Bieber Date: Wed, 21 Jul 2010 07:45:29 +0000 Subject: Theme Editor: Implemented download and decompression of font pack in the preferences dialog. Dialog will also allow the user to set a directory for a custom target database, but the update button doesn't work yet. Also fixed the file filters for open file/open project actions and resized the preferences dialog git-svn-id: svn://svn.rockbox.org/rockbox/trunk@27509 a1c6a512-1295-4272-9138-f99709370657 --- utils/themeeditor/quazip/quazipfile.cpp | 377 ++++++++++++++++++++++++++++++++ 1 file changed, 377 insertions(+) create mode 100644 utils/themeeditor/quazip/quazipfile.cpp (limited to 'utils/themeeditor/quazip/quazipfile.cpp') diff --git a/utils/themeeditor/quazip/quazipfile.cpp b/utils/themeeditor/quazip/quazipfile.cpp new file mode 100644 index 0000000000..0399d1dbd0 --- /dev/null +++ b/utils/themeeditor/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; + } +} -- cgit v1.2.3