| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,66 +1,66 @@ | ||
| QuaZIP is the C++ wrapper for the Gilles Vollant's ZIP/UNZIP package | ||
| using Trolltech's Qt library. | ||
|
|
||
| It contains original ZIP/UNZIP package C code and therefore depends on | ||
| zlib library. | ||
|
|
||
| Also, it depends on Qt 4. | ||
|
|
||
| To comile it on UNIX dialect: | ||
|
|
||
| $ cd quazip | ||
| $ qmake | ||
| $ make | ||
|
|
||
| You must make sure that: | ||
| * You have Qt 4 properly and fully installed (including tools and | ||
| headers, not just library) | ||
| * "qmake" command runs Qt 4's qmake, not some other version (you'll have | ||
| to type full path to qmake otherwise). | ||
|
|
||
| To install compiled shared library, just type: | ||
|
|
||
| $ make install | ||
|
|
||
| By default, it installs in /usr/local, but you may change it using | ||
|
|
||
| $ qmake PREFIX=/wherever/you/whant/to/install | ||
|
|
||
| You do not have to compile and install QuaZIP to use it. You can just | ||
| (and sometimes it may be the best way) add QuaZIP's source files to your | ||
| project and use them. | ||
|
|
||
| See doc/html or, if you do not have a browser, quazip/*.h and | ||
| quazip/doc/* files for the more detailed documentation. | ||
|
|
||
| For Windows, it's essentially the same, but you may have to adjust | ||
| settings for different environments. | ||
|
|
||
| If you want to include QuaZIP sources directly into your project or if | ||
| you want to use QuaZIP compiled as a static library using | ||
| "qmake CONFIG+=statliclib", you have to define the QUAZIP_STATIC macro, | ||
| otherwise you're likely to run into problems as QuaZIP symbols will be | ||
| marked as dllimported. | ||
|
|
||
| Copyright notice: | ||
|
|
||
| Copyright (C) 2005-2011 Sergey A. Tachenov | ||
|
|
||
| This program is free software; you can redistribute it and/or modify it | ||
| under the terms of the GNU Lesser General Public License as published by | ||
| the Free Software Foundation; either version 2 of the License, or (at | ||
| your option) any later version. | ||
|
|
||
| This program is distributed in the hope that it will be useful, but | ||
| WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser | ||
| General Public License for more details. | ||
|
|
||
| You should have received a copy of the GNU Lesser General Public License | ||
| along with this program; if not, write to the Free Software Foundation, | ||
| Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
|
|
||
| See COPYING file for the full LGPL text. | ||
|
|
||
| Original ZIP package is copyrighted by Gilles Vollant, see | ||
| quazip/(un)zip.h files for details, basically it's zlib license. |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,135 +1,136 @@ | ||
| /* crypt.h -- base code for crypt/uncrypt ZIPfile | ||
| Version 1.01e, February 12th, 2005 | ||
| Copyright (C) 1998-2005 Gilles Vollant | ||
| This code is a modified version of crypting code in Infozip distribution | ||
| The encryption/decryption parts of this source code (as opposed to the | ||
| non-echoing password parts) were originally written in Europe. The | ||
| whole source package can be freely distributed, including from the USA. | ||
| (Prior to January 2000, re-export from the US was a violation of US law.) | ||
| This encryption code is a direct transcription of the algorithm from | ||
| Roger Schlafly, described by Phil Katz in the file appnote.txt. This | ||
| file (appnote.txt) is distributed with the PKZIP program (even in the | ||
| version without encryption capabilities). | ||
| If you don't need crypting in your application, just define symbols | ||
| NOCRYPT and NOUNCRYPT. | ||
| This code support the "Traditional PKWARE Encryption". | ||
| The new AES encryption added on Zip format by Winzip (see the page | ||
| http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong | ||
| Encryption is not supported. | ||
| */ | ||
|
|
||
| #include "quazip_global.h" | ||
|
|
||
| #define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8)) | ||
|
|
||
| /*********************************************************************** | ||
| * Return the next byte in the pseudo-random sequence | ||
| */ | ||
| static int decrypt_byte( unsigned long* pkeys, const unsigned long* pcrc_32_tab UNUSED ) | ||
| { | ||
| //(void) pcrc_32_tab; /* avoid "unused parameter" warning */ | ||
| unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an | ||
| * unpredictable manner on 16-bit systems; not a problem | ||
| * with any known compiler so far, though */ | ||
|
|
||
| temp = (( unsigned )( *( pkeys + 2 ) ) & 0xffff ) | 2; | ||
| return ( int )((( temp * ( temp ^ 1 ) ) >> 8 ) & 0xff ); | ||
| } | ||
|
|
||
| /*********************************************************************** | ||
| * Update the encryption keys with the next byte of plain text | ||
| */ | ||
| static int update_keys( unsigned long* pkeys, const unsigned long* pcrc_32_tab, int c ) | ||
| { | ||
| ( *( pkeys + 0 ) ) = CRC32(( *( pkeys + 0 ) ), c ); | ||
| ( *( pkeys + 1 ) ) += ( *( pkeys + 0 ) ) & 0xff; | ||
| ( *( pkeys + 1 ) ) = ( *( pkeys + 1 ) ) * 134775813L + 1; | ||
| { | ||
| register int keyshift = ( int )(( *( pkeys + 1 ) ) >> 24 ); | ||
| ( *( pkeys + 2 ) ) = CRC32(( *( pkeys + 2 ) ), keyshift ); | ||
| } | ||
| return c; | ||
| } | ||
|
|
||
|
|
||
| /*********************************************************************** | ||
| * Initialize the encryption keys and the random header according to | ||
| * the given password. | ||
| */ | ||
| static void init_keys( const char* passwd, unsigned long* pkeys, const unsigned long* pcrc_32_tab ) | ||
| { | ||
| *( pkeys + 0 ) = 305419896L; | ||
| *( pkeys + 1 ) = 591751049L; | ||
| *( pkeys + 2 ) = 878082192L; | ||
| while ( *passwd != '\0' ) | ||
| { | ||
| update_keys( pkeys, pcrc_32_tab, ( int )*passwd ); | ||
| passwd++; | ||
| } | ||
| } | ||
|
|
||
| #define zdecode(pkeys,pcrc_32_tab,c) \ | ||
| (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab))) | ||
|
|
||
| #define zencode(pkeys,pcrc_32_tab,c,t) \ | ||
| (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c)) | ||
|
|
||
| #ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED | ||
|
|
||
| #define RAND_HEAD_LEN 12 | ||
| /* "last resort" source for second part of crypt seed pattern */ | ||
| # ifndef ZCR_SEED2 | ||
| # define ZCR_SEED2 3141592654UL /* use PI as default pattern */ | ||
| # endif | ||
|
|
||
| static int crypthead( passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting ) | ||
| const char *passwd; /* password string */ | ||
| unsigned char *buf; /* where to write header */ | ||
| int bufSize; | ||
| unsigned long* pkeys; | ||
| const unsigned long* pcrc_32_tab; | ||
| unsigned long crcForCrypting; | ||
| { | ||
| int n; /* index in random header */ | ||
| int t; /* temporary */ | ||
| int c; /* random byte */ | ||
| unsigned char header[RAND_HEAD_LEN-2]; /* random header */ | ||
| static unsigned calls = 0; /* ensure different random header each time */ | ||
|
|
||
| if ( bufSize < RAND_HEAD_LEN ) | ||
| return 0; | ||
|
|
||
| /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the | ||
| * output of rand() to get less predictability, since rand() is | ||
| * often poorly implemented. | ||
| */ | ||
| if ( ++calls == 1 ) | ||
| { | ||
| srand(( unsigned )( time( NULL ) ^ ZCR_SEED2 ) ); | ||
| } | ||
| init_keys( passwd, pkeys, pcrc_32_tab ); | ||
| for ( n = 0; n < RAND_HEAD_LEN - 2; n++ ) | ||
| { | ||
| c = ( rand() >> 7 ) & 0xff; | ||
| header[n] = ( unsigned char )zencode( pkeys, pcrc_32_tab, c, t ); | ||
| } | ||
| /* Encrypt random header (last two bytes is high word of crc) */ | ||
| init_keys( passwd, pkeys, pcrc_32_tab ); | ||
| for ( n = 0; n < RAND_HEAD_LEN - 2; n++ ) | ||
| { | ||
| buf[n] = ( unsigned char )zencode( pkeys, pcrc_32_tab, header[n], t ); | ||
| } | ||
| buf[n++] = zencode( pkeys, pcrc_32_tab, ( int )( crcForCrypting >> 16 ) & 0xff, t ); | ||
| buf[n++] = zencode( pkeys, pcrc_32_tab, ( int )( crcForCrypting >> 24 ) & 0xff, t ); | ||
| return n; | ||
| } | ||
|
|
||
| #endif |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,77 +1,78 @@ | ||
| /* ioapi.h -- IO base function header for compress/uncompress .zip | ||
| files using zlib + zip or unzip API | ||
| Version 1.01e, February 12th, 2005 | ||
| Copyright (C) 1998-2005 Gilles Vollant | ||
| Modified by Sergey A. Tachenov to integrate with Qt. | ||
| */ | ||
|
|
||
| #ifndef _ZLIBIOAPI_H | ||
| #define _ZLIBIOAPI_H | ||
|
|
||
|
|
||
| #define ZLIB_FILEFUNC_SEEK_CUR (1) | ||
| #define ZLIB_FILEFUNC_SEEK_END (2) | ||
| #define ZLIB_FILEFUNC_SEEK_SET (0) | ||
|
|
||
| #define ZLIB_FILEFUNC_MODE_READ (1) | ||
| #define ZLIB_FILEFUNC_MODE_WRITE (2) | ||
| #define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3) | ||
|
|
||
| #define ZLIB_FILEFUNC_MODE_EXISTING (4) | ||
| #define ZLIB_FILEFUNC_MODE_CREATE (8) | ||
|
|
||
|
|
||
| #ifndef ZCALLBACK | ||
|
|
||
| #if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK) | ||
| #define ZCALLBACK CALLBACK | ||
| #else | ||
| #define ZCALLBACK | ||
| #endif | ||
| #endif | ||
|
|
||
| #ifdef __cplusplus | ||
| extern "C" | ||
| { | ||
| #endif | ||
|
|
||
| typedef voidpf( ZCALLBACK *open_file_func ) OF(( voidpf opaque, voidpf file, int mode ) ); | ||
| typedef uLong( ZCALLBACK *read_file_func ) OF(( voidpf opaque, voidpf stream, void* buf, uLong size ) ); | ||
| typedef uLong( ZCALLBACK *write_file_func ) OF(( voidpf opaque, voidpf stream, const void* buf, uLong size ) ); | ||
| typedef uLong( ZCALLBACK *tell_file_func ) OF(( voidpf opaque, voidpf stream ) ); | ||
| typedef int ( ZCALLBACK *seek_file_func ) OF(( voidpf opaque, voidpf stream, uLong offset, int origin ) ); | ||
| typedef int ( ZCALLBACK *close_file_func ) OF(( voidpf opaque, voidpf stream ) ); | ||
| typedef int ( ZCALLBACK *testerror_file_func ) OF(( voidpf opaque, voidpf stream ) ); | ||
|
|
||
| typedef struct zlib_filefunc_def_s | ||
| { | ||
| open_file_func zopen_file; | ||
| read_file_func zread_file; | ||
| write_file_func zwrite_file; | ||
| tell_file_func ztell_file; | ||
| seek_file_func zseek_file; | ||
| close_file_func zclose_file; | ||
| testerror_file_func zerror_file; | ||
| voidpf opaque; | ||
| } zlib_filefunc_def; | ||
|
|
||
|
|
||
|
|
||
| void fill_qiodevice_filefunc OF(( zlib_filefunc_def* pzlib_filefunc_def ) ); | ||
|
|
||
| #define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size)) | ||
| #define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size)) | ||
| #define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream)) | ||
| #define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode)) | ||
| #define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream)) | ||
| #define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream)) | ||
|
|
||
|
|
||
| #ifdef __cplusplus | ||
| } | ||
| #endif | ||
|
|
||
| #endif | ||
|
|
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,145 +1,150 @@ | ||
| /* ioapi.c -- IO base function header for compress/uncompress .zip | ||
| files using zlib + zip or unzip API | ||
| Version 1.01e, February 12th, 2005 | ||
| Copyright (C) 1998-2005 Gilles Vollant | ||
| Modified by Sergey A. Tachenov to integrate with Qt. | ||
| */ | ||
|
|
||
| #include <stdio.h> | ||
| #include <stdlib.h> | ||
| #include <string.h> | ||
|
|
||
| #include "zlib.h" | ||
| #include "ioapi.h" | ||
| #include "quazip_global.h" | ||
| #include <QIODevice> | ||
|
|
||
|
|
||
| /* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ | ||
|
|
||
| #ifndef SEEK_CUR | ||
| #define SEEK_CUR 1 | ||
| #endif | ||
|
|
||
| #ifndef SEEK_END | ||
| #define SEEK_END 2 | ||
| #endif | ||
|
|
||
| #ifndef SEEK_SET | ||
| #define SEEK_SET 0 | ||
| #endif | ||
|
|
||
| voidpf ZCALLBACK qiodevice_open_file_func( | ||
| voidpf opaque UNUSED, | ||
| voidpf file, | ||
| int mode ) | ||
| { | ||
| QIODevice *iodevice = reinterpret_cast<QIODevice*>( file ); | ||
| if (( mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER ) == ZLIB_FILEFUNC_MODE_READ ) | ||
| iodevice->open( QIODevice::ReadOnly ); | ||
| else | ||
| if ( mode & ZLIB_FILEFUNC_MODE_EXISTING ) | ||
| iodevice->open( QIODevice::ReadWrite ); | ||
| else | ||
| if ( mode & ZLIB_FILEFUNC_MODE_CREATE ) | ||
| iodevice->open( QIODevice::WriteOnly ); | ||
|
|
||
| if ( iodevice->isOpen() ) | ||
| { | ||
| if ( iodevice->isSequential() ) | ||
| { | ||
| iodevice->close(); | ||
| return NULL; | ||
| } | ||
| else | ||
| { | ||
| return iodevice; | ||
| } | ||
| } | ||
| else | ||
| return NULL; | ||
| } | ||
|
|
||
|
|
||
| uLong ZCALLBACK qiodevice_read_file_func( | ||
| voidpf opaque UNUSED, | ||
| voidpf stream, | ||
| void* buf, | ||
| uLong size ) | ||
| { | ||
| uLong ret; | ||
| ret = ( uLong )(( QIODevice* )stream )->read(( char* )buf, size ); | ||
| return ret; | ||
| } | ||
|
|
||
|
|
||
| uLong ZCALLBACK qiodevice_write_file_func( | ||
| voidpf opaque UNUSED, | ||
| voidpf stream, | ||
| const void* buf, | ||
| uLong size ) | ||
| { | ||
| uLong ret; | ||
| ret = ( uLong )(( QIODevice* )stream )->write(( char* )buf, size ); | ||
| return ret; | ||
| } | ||
|
|
||
| uLong ZCALLBACK qiodevice_tell_file_func( | ||
| voidpf opaque UNUSED, | ||
| voidpf stream ) | ||
| { | ||
| uLong ret; | ||
| ret = (( QIODevice* )stream )->pos(); | ||
| return ret; | ||
| } | ||
|
|
||
| int ZCALLBACK qiodevice_seek_file_func( | ||
| voidpf opaque UNUSED, | ||
| voidpf stream, | ||
| uLong offset, | ||
| int origin ) | ||
| { | ||
| uLong qiodevice_seek_result = 0; | ||
| int ret; | ||
| switch ( origin ) | ||
| { | ||
| case ZLIB_FILEFUNC_SEEK_CUR : | ||
| qiodevice_seek_result = (( QIODevice* )stream )->pos() + offset; | ||
| break; | ||
| case ZLIB_FILEFUNC_SEEK_END : | ||
| qiodevice_seek_result = (( QIODevice* )stream )->size() - offset; | ||
| break; | ||
| case ZLIB_FILEFUNC_SEEK_SET : | ||
| qiodevice_seek_result = offset; | ||
| break; | ||
| default: return -1; | ||
| } | ||
| ret = !(( QIODevice* )stream )->seek( qiodevice_seek_result ); | ||
| return ret; | ||
| } | ||
|
|
||
| int ZCALLBACK qiodevice_close_file_func( | ||
| voidpf opaque UNUSED, | ||
| voidpf stream ) | ||
| { | ||
| (( QIODevice* )stream )->close(); | ||
| return 0; | ||
| } | ||
|
|
||
| int ZCALLBACK qiodevice_error_file_func( | ||
| voidpf opaque UNUSED, | ||
| voidpf stream ) | ||
| { | ||
| return !(( QIODevice* )stream )->errorString().isEmpty(); | ||
| } | ||
|
|
||
| void fill_qiodevice_filefunc( | ||
| zlib_filefunc_def* pzlib_filefunc_def ) | ||
| { | ||
| pzlib_filefunc_def->zopen_file = qiodevice_open_file_func; | ||
| pzlib_filefunc_def->zread_file = qiodevice_read_file_func; | ||
| pzlib_filefunc_def->zwrite_file = qiodevice_write_file_func; | ||
| pzlib_filefunc_def->ztell_file = qiodevice_tell_file_func; | ||
| pzlib_filefunc_def->zseek_file = qiodevice_seek_file_func; | ||
| pzlib_filefunc_def->zclose_file = qiodevice_close_file_func; | ||
| pzlib_filefunc_def->zerror_file = qiodevice_error_file_func; | ||
| pzlib_filefunc_def->opaque = NULL; | ||
| } |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,66 +1,67 @@ | ||
| #ifndef QUA_ZIPFILEINFO_H | ||
| #define QUA_ZIPFILEINFO_H | ||
|
|
||
| /* | ||
| Copyright (C) 2005-2011 Sergey A. Tachenov | ||
| This program is free software; you can redistribute it and/or modify it | ||
| under the terms of the GNU Lesser General Public License as published by | ||
| the Free Software Foundation; either version 2 of the License, or (at | ||
| your option) any later version. | ||
| This program is distributed in the hope that it will be useful, but | ||
| WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser | ||
| General Public License for more details. | ||
| You should have received a copy of the GNU Lesser General Public License | ||
| along with this program; if not, write to the Free Software Foundation, | ||
| Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
| See COPYING file for the full LGPL text. | ||
| Original ZIP package is copyrighted by Gilles Vollant, see | ||
| quazip/(un)zip.h files for details, basically it's zlib license. | ||
| **/ | ||
|
|
||
| #include <QByteArray> | ||
| #include <QDateTime> | ||
|
|
||
| #include "quazip_global.h" | ||
|
|
||
| /// Information about a file inside archive. | ||
| /** Call QuaZip::getCurrentFileInfo() or QuaZipFile::getFileInfo() to | ||
| * fill this structure. */ | ||
| struct QUAZIP_EXPORT QuaZipFileInfo | ||
| { | ||
| /// File name. | ||
| QString name; | ||
| /// Version created by. | ||
| quint16 versionCreated; | ||
| /// Version needed to extract. | ||
| quint16 versionNeeded; | ||
| /// General purpose flags. | ||
| quint16 flags; | ||
| /// Compression method. | ||
| quint16 method; | ||
| /// Last modification date and time. | ||
| QDateTime dateTime; | ||
| /// CRC. | ||
| quint32 crc; | ||
| /// Compressed file size. | ||
| quint32 compressedSize; | ||
| /// Uncompressed file size. | ||
| quint32 uncompressedSize; | ||
| /// Disk number start. | ||
| quint16 diskNumberStart; | ||
| /// Internal file attributes. | ||
| quint16 internalAttr; | ||
| /// External file attributes. | ||
| quint32 externalAttr; | ||
| /// Comment. | ||
| QString comment; | ||
| /// Extra field. | ||
| QByteArray extra; | ||
| }; | ||
|
|
||
| #endif |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,51 +1,51 @@ | ||
| /* | ||
| Copyright (C) 2005-2011 Sergey A. Tachenov | ||
| This program is free software; you can redistribute it and/or modify it | ||
| under the terms of the GNU Lesser General Public License as published by | ||
| the Free Software Foundation; either version 2 of the License, or (at | ||
| your option) any later version. | ||
| This program is distributed in the hope that it will be useful, but | ||
| WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser | ||
| General Public License for more details. | ||
| You should have received a copy of the GNU Lesser General Public License | ||
| along with this program; if not, write to the Free Software Foundation, | ||
| Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
| See COPYING file for the full LGPL text. | ||
| Original ZIP package is copyrighted by Gilles Vollant, see | ||
| quazip/(un)zip.h files for details, basically it's zlib license. | ||
| */ | ||
|
|
||
| #include <QFileInfo> | ||
|
|
||
| #include "quazipnewinfo.h" | ||
|
|
||
|
|
||
| QuaZipNewInfo::QuaZipNewInfo( const QString& name ): | ||
| name( name ), dateTime( QDateTime::currentDateTime() ), internalAttr( 0 ), externalAttr( 0 ) | ||
| { | ||
| } | ||
|
|
||
| QuaZipNewInfo::QuaZipNewInfo( const QString& name, const QString& file ): | ||
| name( name ), internalAttr( 0 ), externalAttr( 0 ) | ||
| { | ||
| QFileInfo info( file ); | ||
| QDateTime lm = info.lastModified(); | ||
| if ( !info.exists() ) | ||
| dateTime = QDateTime::currentDateTime(); | ||
| else | ||
| dateTime = lm; | ||
| } | ||
|
|
||
| void QuaZipNewInfo::setFileDateTime( const QString& file ) | ||
| { | ||
| QFileInfo info( file ); | ||
| QDateTime lm = info.lastModified(); | ||
| if ( info.exists() ) | ||
| dateTime = lm; | ||
| } |
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -1,102 +1,103 @@ | ||
| #ifndef QUA_ZIPNEWINFO_H | ||
| #define QUA_ZIPNEWINFO_H | ||
|
|
||
| /* | ||
| Copyright (C) 2005-2011 Sergey A. Tachenov | ||
| This program is free software; you can redistribute it and/or modify it | ||
| under the terms of the GNU Lesser General Public License as published by | ||
| the Free Software Foundation; either version 2 of the License, or (at | ||
| your option) any later version. | ||
| This program is distributed in the hope that it will be useful, but | ||
| WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser | ||
| General Public License for more details. | ||
| You should have received a copy of the GNU Lesser General Public License | ||
| along with this program; if not, write to the Free Software Foundation, | ||
| Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
| See COPYING file for the full LGPL text. | ||
| Original ZIP package is copyrighted by Gilles Vollant, see | ||
| quazip/(un)zip.h files for details, basically it's zlib license. | ||
| **/ | ||
|
|
||
| #include <QDateTime> | ||
| #include <QString> | ||
|
|
||
| #include "quazip_global.h" | ||
|
|
||
| /// Information about a file to be created. | ||
| /** This structure holds information about a file to be created inside | ||
| * ZIP archive. At least name should be set to something correct before | ||
| * passing this structure to | ||
| * QuaZipFile::open(OpenMode,const QuaZipNewInfo&,int,int,bool). | ||
| **/ | ||
| struct QUAZIP_EXPORT QuaZipNewInfo | ||
| { | ||
| /// File name. | ||
| /** This field holds file name inside archive, including path relative | ||
| * to archive root. | ||
| **/ | ||
| QString name; | ||
| /// File timestamp. | ||
| /** This is the last file modification date and time. Will be stored | ||
| * in the archive central directory. It is a good practice to set it | ||
| * to the source file timestamp instead of archive creating time. Use | ||
| * setFileDateTime() or QuaZipNewInfo(const QString&, const QString&). | ||
| **/ | ||
| QDateTime dateTime; | ||
| /// File internal attributes. | ||
| quint16 internalAttr; | ||
| /// File external attributes. | ||
| quint32 externalAttr; | ||
| /// File comment. | ||
| /** Will be encoded using QuaZip::getCommentCodec(). | ||
| **/ | ||
| QString comment; | ||
| /// File local extra field. | ||
| QByteArray extraLocal; | ||
| /// File global extra field. | ||
| QByteArray extraGlobal; | ||
| /// Uncompressed file size. | ||
| /** This is only needed if you are using raw file zipping mode, i. e. | ||
| * adding precompressed file in the zip archive. | ||
| **/ | ||
| ulong uncompressedSize; | ||
| /// Constructs QuaZipNewInfo instance. | ||
| /** Initializes name with \a name, dateTime with current date and | ||
| * time. Attributes are initialized with zeros, comment and extra | ||
| * field with null values. | ||
| **/ | ||
| QuaZipNewInfo( const QString& name ); | ||
| /// Constructs QuaZipNewInfo instance. | ||
| /** Initializes name with \a name and dateTime with timestamp of the | ||
| * file named \a file. If the \a file does not exists or its timestamp | ||
| * is inaccessible (e. g. you do not have read permission for the | ||
| * directory file in), uses current date and time. Attributes are | ||
| * initialized with zeros, comment and extra field with null values. | ||
| * | ||
| * \sa setFileDateTime() | ||
| **/ | ||
| QuaZipNewInfo( const QString& name, const QString& file ); | ||
| /// Sets the file timestamp from the existing file. | ||
| /** Use this function to set the file timestamp from the existing | ||
| * file. Use it like this: | ||
| * \code | ||
| * QuaZipFile zipFile(&zip); | ||
| * QFile file("file-to-add"); | ||
| * file.open(QIODevice::ReadOnly); | ||
| * QuaZipNewInfo info("file-name-in-archive"); | ||
| * info.setFileDateTime("file-to-add"); // take the timestamp from file | ||
| * zipFile.open(QIODevice::WriteOnly, info); | ||
| * \endcode | ||
| * | ||
| * This function does not change dateTime if some error occured (e. g. | ||
| * file is inaccessible). | ||
| **/ | ||
| void setFileDateTime( const QString& file ); | ||
| }; | ||
|
|
||
| #endif |