diff options
Diffstat (limited to 'utils/themeeditor')
29 files changed, 7841 insertions, 24 deletions
diff --git a/utils/themeeditor/gui/fontdownloader.cpp b/utils/themeeditor/gui/fontdownloader.cpp new file mode 100644 index 0000000000..7aa4cd8d57 --- /dev/null +++ b/utils/themeeditor/gui/fontdownloader.cpp | |||
@@ -0,0 +1,158 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2010 Robert Bieber | ||
11 | * | ||
12 | * This program is free software; you can redistribute it and/or | ||
13 | * modify it under the terms of the GNU General Public License | ||
14 | * as published by the Free Software Foundation; either version 2 | ||
15 | * of the License, or (at your option) any later version. | ||
16 | * | ||
17 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
18 | * KIND, either express or implied. | ||
19 | * | ||
20 | ****************************************************************************/ | ||
21 | |||
22 | #include "fontdownloader.h" | ||
23 | #include "ui_fontdownloader.h" | ||
24 | |||
25 | #include "quazip.h" | ||
26 | #include "quazipfile.h" | ||
27 | #include "quazipfileinfo.h" | ||
28 | |||
29 | #include <QNetworkRequest> | ||
30 | #include <QNetworkReply> | ||
31 | #include <QCloseEvent> | ||
32 | |||
33 | #include <QDebug> | ||
34 | |||
35 | FontDownloader::FontDownloader(QWidget *parent, QString path) : | ||
36 | QDialog(parent), | ||
37 | ui(new Ui::FontDownloader), dir(path), reply(0) | ||
38 | { | ||
39 | ui->setupUi(this); | ||
40 | |||
41 | manager = new QNetworkAccessManager(); | ||
42 | |||
43 | if(dir.isReadable()) | ||
44 | { | ||
45 | fout.setFileName(dir.absolutePath() + "/fonts.zip"); | ||
46 | if(fout.open(QFile::WriteOnly)) | ||
47 | { | ||
48 | ui->label->setText(tr("Downloading font pack")); | ||
49 | |||
50 | QNetworkRequest request; | ||
51 | request.setUrl(QUrl("http://download.rockbox.org" | ||
52 | "/daily/fonts/rockbox-fonts.zip")); | ||
53 | request.setRawHeader("User-Agent", "Rockbox Theme Editor"); | ||
54 | |||
55 | reply = manager->get(request); | ||
56 | |||
57 | QObject::connect(reply, SIGNAL(readyRead()), | ||
58 | this, SLOT(dataReceived())); | ||
59 | QObject::connect(reply, SIGNAL(finished()), | ||
60 | this, SLOT(finished())); | ||
61 | QObject::connect(reply, SIGNAL(downloadProgress(qint64,qint64)), | ||
62 | this, SLOT(progress(qint64,qint64))); | ||
63 | } | ||
64 | else | ||
65 | { | ||
66 | ui->label->setText(tr("Error: Couldn't open archive file")); | ||
67 | } | ||
68 | } | ||
69 | else | ||
70 | { | ||
71 | ui->label->setText(tr("Error: Fonts directory not readable")); | ||
72 | } | ||
73 | |||
74 | } | ||
75 | |||
76 | FontDownloader::~FontDownloader() | ||
77 | { | ||
78 | delete ui; | ||
79 | fout.close(); | ||
80 | manager->deleteLater(); | ||
81 | |||
82 | if(reply) | ||
83 | { | ||
84 | reply->abort(); | ||
85 | reply->deleteLater(); | ||
86 | } | ||
87 | } | ||
88 | |||
89 | void FontDownloader::cancel() | ||
90 | { | ||
91 | if(reply) | ||
92 | { | ||
93 | reply->abort(); | ||
94 | reply->deleteLater(); | ||
95 | reply = 0; | ||
96 | } | ||
97 | } | ||
98 | |||
99 | void FontDownloader::dataReceived() | ||
100 | { | ||
101 | fout.write(reply->readAll()); | ||
102 | } | ||
103 | |||
104 | void FontDownloader::progress(qint64 bytes, qint64 available) | ||
105 | { | ||
106 | if(available > 0) | ||
107 | { | ||
108 | ui->progressBar->setMaximum(available); | ||
109 | ui->progressBar->setValue(bytes); | ||
110 | } | ||
111 | } | ||
112 | |||
113 | void FontDownloader::finished() | ||
114 | { | ||
115 | fout.close(); | ||
116 | reply->deleteLater(); | ||
117 | reply = 0; | ||
118 | ui->label->setText(tr("Download complete")); | ||
119 | |||
120 | /* Extracting the ZIP archive */ | ||
121 | QuaZip archive(fout.fileName()); | ||
122 | QuaZipFile zipFile(&archive); | ||
123 | archive.open(QuaZip::mdUnzip); | ||
124 | |||
125 | bool more; | ||
126 | for(more = archive.goToFirstFile(); more; more = archive.goToNextFile()) | ||
127 | { | ||
128 | if(archive.getCurrentFileName().split("/").last() == "") | ||
129 | continue; | ||
130 | |||
131 | QFile fontFile(dir.absolutePath() + "/" + | ||
132 | archive.getCurrentFileName().split("/").last()); | ||
133 | fontFile.open(QFile::WriteOnly); | ||
134 | |||
135 | zipFile.open(QIODevice::ReadOnly); | ||
136 | fontFile.write(zipFile.readAll()); | ||
137 | zipFile.close(); | ||
138 | |||
139 | fontFile.close(); | ||
140 | } | ||
141 | |||
142 | archive.close(); | ||
143 | QFile::remove(dir.absolutePath() + "/fonts.zip"); | ||
144 | |||
145 | hide(); | ||
146 | this->deleteLater(); | ||
147 | } | ||
148 | |||
149 | void FontDownloader::netError(QNetworkReply::NetworkError code) | ||
150 | { | ||
151 | ui->label->setText(tr("Network error: ") + reply->errorString()); | ||
152 | } | ||
153 | |||
154 | void FontDownloader::closeEvent(QCloseEvent *event) | ||
155 | { | ||
156 | cancel(); | ||
157 | event->accept(); | ||
158 | } | ||
diff --git a/utils/themeeditor/gui/fontdownloader.h b/utils/themeeditor/gui/fontdownloader.h new file mode 100644 index 0000000000..acd8ea54b3 --- /dev/null +++ b/utils/themeeditor/gui/fontdownloader.h | |||
@@ -0,0 +1,59 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2010 Robert Bieber | ||
11 | * | ||
12 | * This program is free software; you can redistribute it and/or | ||
13 | * modify it under the terms of the GNU General Public License | ||
14 | * as published by the Free Software Foundation; either version 2 | ||
15 | * of the License, or (at your option) any later version. | ||
16 | * | ||
17 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
18 | * KIND, either express or implied. | ||
19 | * | ||
20 | ****************************************************************************/ | ||
21 | |||
22 | #ifndef FONTDOWNLOADER_H | ||
23 | #define FONTDOWNLOADER_H | ||
24 | |||
25 | #include <QDialog> | ||
26 | #include <QDir> | ||
27 | #include <QNetworkAccessManager> | ||
28 | #include <QNetworkReply> | ||
29 | |||
30 | namespace Ui { | ||
31 | class FontDownloader; | ||
32 | } | ||
33 | |||
34 | class FontDownloader : public QDialog { | ||
35 | Q_OBJECT | ||
36 | public: | ||
37 | FontDownloader(QWidget *parent, QString dir); | ||
38 | virtual ~FontDownloader(); | ||
39 | |||
40 | private slots: | ||
41 | void cancel(); | ||
42 | |||
43 | void dataReceived(); | ||
44 | void progress(qint64 bytes, qint64 available); | ||
45 | void finished(); | ||
46 | void netError(QNetworkReply::NetworkError code); | ||
47 | |||
48 | private: | ||
49 | void closeEvent(QCloseEvent *event); | ||
50 | |||
51 | Ui::FontDownloader *ui; | ||
52 | |||
53 | QNetworkAccessManager* manager; | ||
54 | QDir dir; | ||
55 | QFile fout; | ||
56 | QNetworkReply* reply; | ||
57 | }; | ||
58 | |||
59 | #endif // FONTDOWNLOADER_H | ||
diff --git a/utils/themeeditor/gui/fontdownloader.ui b/utils/themeeditor/gui/fontdownloader.ui new file mode 100644 index 0000000000..53b69a8be7 --- /dev/null +++ b/utils/themeeditor/gui/fontdownloader.ui | |||
@@ -0,0 +1,87 @@ | |||
1 | <?xml version="1.0" encoding="UTF-8"?> | ||
2 | <ui version="4.0"> | ||
3 | <class>FontDownloader</class> | ||
4 | <widget class="QDialog" name="FontDownloader"> | ||
5 | <property name="windowModality"> | ||
6 | <enum>Qt::WindowModal</enum> | ||
7 | </property> | ||
8 | <property name="geometry"> | ||
9 | <rect> | ||
10 | <x>0</x> | ||
11 | <y>0</y> | ||
12 | <width>400</width> | ||
13 | <height>107</height> | ||
14 | </rect> | ||
15 | </property> | ||
16 | <property name="windowTitle"> | ||
17 | <string>Downloading Font Pack</string> | ||
18 | </property> | ||
19 | <property name="windowIcon"> | ||
20 | <iconset resource="../resources.qrc"> | ||
21 | <normaloff>:/resources/windowicon.png</normaloff>:/resources/windowicon.png</iconset> | ||
22 | </property> | ||
23 | <property name="sizeGripEnabled"> | ||
24 | <bool>true</bool> | ||
25 | </property> | ||
26 | <property name="modal"> | ||
27 | <bool>true</bool> | ||
28 | </property> | ||
29 | <layout class="QVBoxLayout" name="verticalLayout"> | ||
30 | <item> | ||
31 | <widget class="QProgressBar" name="progressBar"> | ||
32 | <property name="value"> | ||
33 | <number>0</number> | ||
34 | </property> | ||
35 | </widget> | ||
36 | </item> | ||
37 | <item> | ||
38 | <widget class="QLabel" name="label"> | ||
39 | <property name="text"> | ||
40 | <string>Checking Directory</string> | ||
41 | </property> | ||
42 | </widget> | ||
43 | </item> | ||
44 | <item> | ||
45 | <spacer name="verticalSpacer"> | ||
46 | <property name="orientation"> | ||
47 | <enum>Qt::Vertical</enum> | ||
48 | </property> | ||
49 | <property name="sizeHint" stdset="0"> | ||
50 | <size> | ||
51 | <width>20</width> | ||
52 | <height>40</height> | ||
53 | </size> | ||
54 | </property> | ||
55 | </spacer> | ||
56 | </item> | ||
57 | <item> | ||
58 | <layout class="QHBoxLayout" name="horizontalLayout"> | ||
59 | <item> | ||
60 | <spacer name="horizontalSpacer"> | ||
61 | <property name="orientation"> | ||
62 | <enum>Qt::Horizontal</enum> | ||
63 | </property> | ||
64 | <property name="sizeHint" stdset="0"> | ||
65 | <size> | ||
66 | <width>40</width> | ||
67 | <height>20</height> | ||
68 | </size> | ||
69 | </property> | ||
70 | </spacer> | ||
71 | </item> | ||
72 | <item> | ||
73 | <widget class="QPushButton" name="cancelButton"> | ||
74 | <property name="text"> | ||
75 | <string>Cancel</string> | ||
76 | </property> | ||
77 | </widget> | ||
78 | </item> | ||
79 | </layout> | ||
80 | </item> | ||
81 | </layout> | ||
82 | </widget> | ||
83 | <resources> | ||
84 | <include location="../resources.qrc"/> | ||
85 | </resources> | ||
86 | <connections/> | ||
87 | </ui> | ||
diff --git a/utils/themeeditor/gui/preferencesdialog.cpp b/utils/themeeditor/gui/preferencesdialog.cpp index dbb3249e9f..b8d0a0a6d6 100644 --- a/utils/themeeditor/gui/preferencesdialog.cpp +++ b/utils/themeeditor/gui/preferencesdialog.cpp | |||
@@ -21,6 +21,7 @@ | |||
21 | 21 | ||
22 | #include "preferencesdialog.h" | 22 | #include "preferencesdialog.h" |
23 | #include "ui_preferencesdialog.h" | 23 | #include "ui_preferencesdialog.h" |
24 | #include "fontdownloader.h" | ||
24 | 25 | ||
25 | #include <QSettings> | 26 | #include <QSettings> |
26 | #include <QColorDialog> | 27 | #include <QColorDialog> |
@@ -124,6 +125,14 @@ void PreferencesDialog::loadRender() | |||
124 | false).toBool()); | 125 | false).toBool()); |
125 | 126 | ||
126 | settings.endGroup(); | 127 | settings.endGroup(); |
128 | |||
129 | settings.beginGroup("TargetData"); | ||
130 | |||
131 | ui->dbBox->setText(settings.value("targetDbPath", | ||
132 | QDir::homePath() + "/.targetdb") | ||
133 | .toString()); | ||
134 | |||
135 | settings.endGroup(); | ||
127 | } | 136 | } |
128 | 137 | ||
129 | void PreferencesDialog::saveSettings() | 138 | void PreferencesDialog::saveSettings() |
@@ -183,6 +192,10 @@ void PreferencesDialog::saveRender() | |||
183 | settings.setValue("autoHighlightTree", ui->autoHighlightBox->isChecked()); | 192 | settings.setValue("autoHighlightTree", ui->autoHighlightBox->isChecked()); |
184 | 193 | ||
185 | settings.endGroup(); | 194 | settings.endGroup(); |
195 | |||
196 | settings.beginGroup("TargetData"); | ||
197 | settings.setValue("targetDbPath", ui->dbBox->text()); | ||
198 | settings.endGroup(); | ||
186 | } | 199 | } |
187 | 200 | ||
188 | void PreferencesDialog::setupUI() | 201 | void PreferencesDialog::setupUI() |
@@ -203,6 +216,10 @@ void PreferencesDialog::setupUI() | |||
203 | 216 | ||
204 | QObject::connect(ui->fontBrowseButton, SIGNAL(clicked()), | 217 | QObject::connect(ui->fontBrowseButton, SIGNAL(clicked()), |
205 | this, SLOT(browseFont())); | 218 | this, SLOT(browseFont())); |
219 | QObject::connect(ui->browseDB, SIGNAL(clicked()), | ||
220 | this, SLOT(browseDB())); | ||
221 | QObject::connect(ui->dlFontsButton, SIGNAL(clicked()), | ||
222 | this, SLOT(dlFonts())); | ||
206 | } | 223 | } |
207 | 224 | ||
208 | void PreferencesDialog::colorClicked() | 225 | void PreferencesDialog::colorClicked() |
@@ -243,6 +260,21 @@ void PreferencesDialog::browseFont() | |||
243 | ui->fontBox->setText(path); | 260 | ui->fontBox->setText(path); |
244 | } | 261 | } |
245 | 262 | ||
263 | void PreferencesDialog::browseDB() | ||
264 | { | ||
265 | QString path = QFileDialog::getOpenFileName(this, tr("Target DB"), | ||
266 | QDir(ui->dbBox->text()). | ||
267 | absolutePath(), | ||
268 | "All Files (*)"); | ||
269 | ui->dbBox->setText(path); | ||
270 | } | ||
271 | |||
272 | void PreferencesDialog::dlFonts() | ||
273 | { | ||
274 | FontDownloader* dl = new FontDownloader(this, ui->fontBox->text()); | ||
275 | dl->show(); | ||
276 | } | ||
277 | |||
246 | void PreferencesDialog::accept() | 278 | void PreferencesDialog::accept() |
247 | { | 279 | { |
248 | saveSettings(); | 280 | saveSettings(); |
diff --git a/utils/themeeditor/gui/preferencesdialog.h b/utils/themeeditor/gui/preferencesdialog.h index cc1d7c75e3..16d239c18f 100644 --- a/utils/themeeditor/gui/preferencesdialog.h +++ b/utils/themeeditor/gui/preferencesdialog.h | |||
@@ -48,6 +48,8 @@ public slots: | |||
48 | private slots: | 48 | private slots: |
49 | void colorClicked(); | 49 | void colorClicked(); |
50 | void browseFont(); | 50 | void browseFont(); |
51 | void browseDB(); | ||
52 | void dlFonts(); | ||
51 | 53 | ||
52 | private: | 54 | private: |
53 | Ui::PreferencesDialog *ui; | 55 | Ui::PreferencesDialog *ui; |
diff --git a/utils/themeeditor/gui/preferencesdialog.ui b/utils/themeeditor/gui/preferencesdialog.ui index c455ed0786..824862e025 100644 --- a/utils/themeeditor/gui/preferencesdialog.ui +++ b/utils/themeeditor/gui/preferencesdialog.ui | |||
@@ -7,7 +7,7 @@ | |||
7 | <x>0</x> | 7 | <x>0</x> |
8 | <y>0</y> | 8 | <y>0</y> |
9 | <width>370</width> | 9 | <width>370</width> |
10 | <height>370</height> | 10 | <height>295</height> |
11 | </rect> | 11 | </rect> |
12 | </property> | 12 | </property> |
13 | <property name="windowTitle"> | 13 | <property name="windowTitle"> |
@@ -24,7 +24,7 @@ | |||
24 | <enum>QTabWidget::North</enum> | 24 | <enum>QTabWidget::North</enum> |
25 | </property> | 25 | </property> |
26 | <property name="currentIndex"> | 26 | <property name="currentIndex"> |
27 | <number>0</number> | 27 | <number>2</number> |
28 | </property> | 28 | </property> |
29 | <widget class="QWidget" name="tab_2"> | 29 | <widget class="QWidget" name="tab_2"> |
30 | <attribute name="title"> | 30 | <attribute name="title"> |
@@ -32,29 +32,31 @@ | |||
32 | </attribute> | 32 | </attribute> |
33 | <layout class="QVBoxLayout" name="verticalLayout_2"> | 33 | <layout class="QVBoxLayout" name="verticalLayout_2"> |
34 | <item> | 34 | <item> |
35 | <layout class="QHBoxLayout" name="horizontalLayout_7"> | 35 | <layout class="QFormLayout" name="formLayout"> |
36 | <item> | 36 | <item row="0" column="0"> |
37 | <widget class="QLabel" name="label_7"> | 37 | <widget class="QLabel" name="label_7"> |
38 | <property name="text"> | 38 | <property name="text"> |
39 | <string>Font</string> | 39 | <string>Font</string> |
40 | </property> | 40 | </property> |
41 | <property name="buddy"> | ||
42 | <cstring>fontSelect</cstring> | ||
43 | </property> | ||
41 | </widget> | 44 | </widget> |
42 | </item> | 45 | </item> |
43 | <item> | 46 | <item row="0" column="1"> |
44 | <widget class="QFontComboBox" name="fontSelect"/> | 47 | <widget class="QFontComboBox" name="fontSelect"/> |
45 | </item> | 48 | </item> |
46 | </layout> | 49 | <item row="1" column="0"> |
47 | </item> | ||
48 | <item> | ||
49 | <layout class="QHBoxLayout" name="horizontalLayout_8"> | ||
50 | <item> | ||
51 | <widget class="QLabel" name="label_8"> | 50 | <widget class="QLabel" name="label_8"> |
52 | <property name="text"> | 51 | <property name="text"> |
53 | <string>Size</string> | 52 | <string>Size</string> |
54 | </property> | 53 | </property> |
54 | <property name="buddy"> | ||
55 | <cstring>fontSize</cstring> | ||
56 | </property> | ||
55 | </widget> | 57 | </widget> |
56 | </item> | 58 | </item> |
57 | <item> | 59 | <item row="1" column="1"> |
58 | <widget class="QSpinBox" name="fontSize"> | 60 | <widget class="QSpinBox" name="fontSize"> |
59 | <property name="value"> | 61 | <property name="value"> |
60 | <number>12</number> | 62 | <number>12</number> |
@@ -118,7 +120,7 @@ | |||
118 | </layout> | 120 | </layout> |
119 | </item> | 121 | </item> |
120 | <item> | 122 | <item> |
121 | <layout class="QHBoxLayout" name="horizontalLayout_9"> | 123 | <layout class="QHBoxLayout" name="horizontalLayout_7"> |
122 | <item> | 124 | <item> |
123 | <widget class="QLabel" name="label_9"> | 125 | <widget class="QLabel" name="label_9"> |
124 | <property name="text"> | 126 | <property name="text"> |
@@ -138,6 +140,19 @@ | |||
138 | </item> | 140 | </item> |
139 | </layout> | 141 | </layout> |
140 | </item> | 142 | </item> |
143 | <item> | ||
144 | <spacer name="verticalSpacer_3"> | ||
145 | <property name="orientation"> | ||
146 | <enum>Qt::Vertical</enum> | ||
147 | </property> | ||
148 | <property name="sizeHint" stdset="0"> | ||
149 | <size> | ||
150 | <width>20</width> | ||
151 | <height>40</height> | ||
152 | </size> | ||
153 | </property> | ||
154 | </spacer> | ||
155 | </item> | ||
141 | </layout> | 156 | </layout> |
142 | </widget> | 157 | </widget> |
143 | <widget class="QWidget" name="prefsGroupsPage1"> | 158 | <widget class="QWidget" name="prefsGroupsPage1"> |
@@ -256,6 +271,19 @@ | |||
256 | </item> | 271 | </item> |
257 | </layout> | 272 | </layout> |
258 | </item> | 273 | </item> |
274 | <item> | ||
275 | <spacer name="verticalSpacer_2"> | ||
276 | <property name="orientation"> | ||
277 | <enum>Qt::Vertical</enum> | ||
278 | </property> | ||
279 | <property name="sizeHint" stdset="0"> | ||
280 | <size> | ||
281 | <width>20</width> | ||
282 | <height>40</height> | ||
283 | </size> | ||
284 | </property> | ||
285 | </spacer> | ||
286 | </item> | ||
259 | </layout> | 287 | </layout> |
260 | </widget> | 288 | </widget> |
261 | <widget class="QWidget" name="tab"> | 289 | <widget class="QWidget" name="tab"> |
@@ -301,6 +329,54 @@ | |||
301 | </item> | 329 | </item> |
302 | </layout> | 330 | </layout> |
303 | </item> | 331 | </item> |
332 | <item> | ||
333 | <widget class="QPushButton" name="dlFontsButton"> | ||
334 | <property name="text"> | ||
335 | <string>Download Fontpack</string> | ||
336 | </property> | ||
337 | </widget> | ||
338 | </item> | ||
339 | <item> | ||
340 | <layout class="QHBoxLayout" name="horizontalLayout_11"> | ||
341 | <item> | ||
342 | <widget class="QLabel" name="label_11"> | ||
343 | <property name="text"> | ||
344 | <string>Target DB</string> | ||
345 | </property> | ||
346 | </widget> | ||
347 | </item> | ||
348 | <item> | ||
349 | <widget class="QLineEdit" name="dbBox"/> | ||
350 | </item> | ||
351 | <item> | ||
352 | <widget class="QPushButton" name="browseDB"> | ||
353 | <property name="text"> | ||
354 | <string>Browse...</string> | ||
355 | </property> | ||
356 | </widget> | ||
357 | </item> | ||
358 | </layout> | ||
359 | </item> | ||
360 | <item> | ||
361 | <widget class="QPushButton" name="pushButton_2"> | ||
362 | <property name="text"> | ||
363 | <string>Update Target DB</string> | ||
364 | </property> | ||
365 | </widget> | ||
366 | </item> | ||
367 | <item> | ||
368 | <spacer name="verticalSpacer"> | ||
369 | <property name="orientation"> | ||
370 | <enum>Qt::Vertical</enum> | ||
371 | </property> | ||
372 | <property name="sizeHint" stdset="0"> | ||
373 | <size> | ||
374 | <width>20</width> | ||
375 | <height>40</height> | ||
376 | </size> | ||
377 | </property> | ||
378 | </spacer> | ||
379 | </item> | ||
304 | </layout> | 380 | </layout> |
305 | </widget> | 381 | </widget> |
306 | </widget> | 382 | </widget> |
diff --git a/utils/themeeditor/gui/skindocument.h b/utils/themeeditor/gui/skindocument.h index f7ac2bbc2c..927a5cf9fc 100644 --- a/utils/themeeditor/gui/skindocument.h +++ b/utils/themeeditor/gui/skindocument.h | |||
@@ -50,7 +50,7 @@ public: | |||
50 | "FMS Files (*.fms *.rfms);;" | 50 | "FMS Files (*.fms *.rfms);;" |
51 | "All Skin Files (*.wps *.rwps *.sbs " | 51 | "All Skin Files (*.wps *.rwps *.sbs " |
52 | "*.rsbs *.fms *.rfms);;" | 52 | "*.rsbs *.fms *.rfms);;" |
53 | "All Files (*.*)"); | 53 | "All Files (*)"); |
54 | } | 54 | } |
55 | 55 | ||
56 | SkinDocument(QLabel* statusLabel, ProjectModel* project = 0, | 56 | SkinDocument(QLabel* statusLabel, ProjectModel* project = 0, |
diff --git a/utils/themeeditor/models/projectmodel.h b/utils/themeeditor/models/projectmodel.h index 4cc531b88f..4afca2837e 100644 --- a/utils/themeeditor/models/projectmodel.h +++ b/utils/themeeditor/models/projectmodel.h | |||
@@ -35,7 +35,7 @@ public: | |||
35 | 35 | ||
36 | static QString fileFilter() | 36 | static QString fileFilter() |
37 | { | 37 | { |
38 | return QObject::tr("Project Files (*.cfg);;All Files (*.*)"); | 38 | return QObject::tr("Project Files (*.cfg);;All Files (*)"); |
39 | } | 39 | } |
40 | 40 | ||
41 | ProjectModel(QString config, EditorWindow* mainWindow, QObject *parent = 0); | 41 | ProjectModel(QString config, EditorWindow* mainWindow, QObject *parent = 0); |
diff --git a/utils/themeeditor/models/targetdata.cpp b/utils/themeeditor/models/targetdata.cpp index 70d231988b..b44f1e67b3 100644 --- a/utils/themeeditor/models/targetdata.cpp +++ b/utils/themeeditor/models/targetdata.cpp | |||
@@ -22,11 +22,17 @@ | |||
22 | #include "targetdata.h" | 22 | #include "targetdata.h" |
23 | 23 | ||
24 | #include <QStringList> | 24 | #include <QStringList> |
25 | #include <QSettings> | ||
25 | 26 | ||
26 | const QString TargetData::reserved = "{}:#\n"; | 27 | const QString TargetData::reserved = "{}:#\n"; |
27 | 28 | ||
28 | TargetData::TargetData(QString file) | 29 | TargetData::TargetData() |
29 | { | 30 | { |
31 | QSettings settings; | ||
32 | settings.beginGroup("TargetData"); | ||
33 | QString file = settings.value("targetDbPath", "").toString(); | ||
34 | settings.endGroup(); | ||
35 | |||
30 | if(!QFile::exists(file)) | 36 | if(!QFile::exists(file)) |
31 | file = ":/targets/targetdb"; | 37 | file = ":/targets/targetdb"; |
32 | 38 | ||
@@ -132,7 +138,8 @@ TargetData::TargetData(QString file) | |||
132 | /* Checking for the closing '}' and adding the entry */ | 138 | /* Checking for the closing '}' and adding the entry */ |
133 | if(require('}', data, cursor)) | 139 | if(require('}', data, cursor)) |
134 | { | 140 | { |
135 | entries.append(Entry(name, size, depth, rSize, rDepth, fm, record)); | 141 | entries.append(Entry(id, name, size, depth, rSize, rDepth, |
142 | fm, record)); | ||
136 | indices.insert(id, index); | 143 | indices.insert(id, index); |
137 | index++; | 144 | index++; |
138 | } | 145 | } |
diff --git a/utils/themeeditor/models/targetdata.h b/utils/themeeditor/models/targetdata.h index 09276c5966..89bb78bdc3 100644 --- a/utils/themeeditor/models/targetdata.h +++ b/utils/themeeditor/models/targetdata.h | |||
@@ -39,7 +39,7 @@ public: | |||
39 | None | 39 | None |
40 | }; | 40 | }; |
41 | 41 | ||
42 | TargetData(QString file = ""); | 42 | TargetData(); |
43 | virtual ~TargetData(); | 43 | virtual ~TargetData(); |
44 | 44 | ||
45 | int count(){ return indices.count(); } | 45 | int count(){ return indices.count(); } |
@@ -57,11 +57,12 @@ public: | |||
57 | private: | 57 | private: |
58 | struct Entry | 58 | struct Entry |
59 | { | 59 | { |
60 | Entry(QString name, QRect size, ScreenDepth depth, QRect rSize, | 60 | Entry(QString id, QString name, QRect size, ScreenDepth depth, |
61 | ScreenDepth rDepth, bool fm, bool record) | 61 | QRect rSize, ScreenDepth rDepth, bool fm, bool record) |
62 | : name(name), size(size), depth(depth), rSize(rSize), | 62 | : id(id), name(name), size(size), depth(depth), rSize(rSize), |
63 | rDepth(rDepth), fm(fm), record(record){ } | 63 | rDepth(rDepth), fm(fm), record(record){ } |
64 | 64 | ||
65 | QString id; | ||
65 | QString name; | 66 | QString name; |
66 | QRect size; | 67 | QRect size; |
67 | ScreenDepth depth; | 68 | ScreenDepth depth; |
diff --git a/utils/themeeditor/quazip/LICENSE.GPL b/utils/themeeditor/quazip/LICENSE.GPL new file mode 100644 index 0000000000..04a7580109 --- /dev/null +++ b/utils/themeeditor/quazip/LICENSE.GPL | |||
@@ -0,0 +1,341 @@ | |||
1 | GNU GENERAL PUBLIC LICENSE | ||
2 | Version 2, June 1991 | ||
3 | |||
4 | Copyright (C) 1989, 1991 Free Software Foundation, Inc. | ||
5 | 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
6 | Everyone is permitted to copy and distribute verbatim copies | ||
7 | of this license document, but changing it is not allowed. | ||
8 | |||
9 | Preamble | ||
10 | |||
11 | The licenses for most software are designed to take away your | ||
12 | freedom to share and change it. By contrast, the GNU General Public | ||
13 | License is intended to guarantee your freedom to share and change free | ||
14 | software--to make sure the software is free for all its users. This | ||
15 | General Public License applies to most of the Free Software | ||
16 | Foundation's software and to any other program whose authors commit to | ||
17 | using it. (Some other Free Software Foundation software is covered by | ||
18 | the GNU Library General Public License instead.) You can apply it to | ||
19 | your programs, too. | ||
20 | |||
21 | When we speak of free software, we are referring to freedom, not | ||
22 | price. Our General Public Licenses are designed to make sure that you | ||
23 | have the freedom to distribute copies of free software (and charge for | ||
24 | this service if you wish), that you receive source code or can get it | ||
25 | if you want it, that you can change the software or use pieces of it | ||
26 | in new free programs; and that you know you can do these things. | ||
27 | |||
28 | To protect your rights, we need to make restrictions that forbid | ||
29 | anyone to deny you these rights or to ask you to surrender the rights. | ||
30 | These restrictions translate to certain responsibilities for you if you | ||
31 | distribute copies of the software, or if you modify it. | ||
32 | |||
33 | For example, if you distribute copies of such a program, whether | ||
34 | gratis or for a fee, you must give the recipients all the rights that | ||
35 | you have. You must make sure that they, too, receive or can get the | ||
36 | source code. And you must show them these terms so they know their | ||
37 | rights. | ||
38 | |||
39 | We protect your rights with two steps: (1) copyright the software, and | ||
40 | (2) offer you this license which gives you legal permission to copy, | ||
41 | distribute and/or modify the software. | ||
42 | |||
43 | Also, for each author's protection and ours, we want to make certain | ||
44 | that everyone understands that there is no warranty for this free | ||
45 | software. If the software is modified by someone else and passed on, we | ||
46 | want its recipients to know that what they have is not the original, so | ||
47 | that any problems introduced by others will not reflect on the original | ||
48 | authors' reputations. | ||
49 | |||
50 | Finally, any free program is threatened constantly by software | ||
51 | patents. We wish to avoid the danger that redistributors of a free | ||
52 | program will individually obtain patent licenses, in effect making the | ||
53 | program proprietary. To prevent this, we have made it clear that any | ||
54 | patent must be licensed for everyone's free use or not licensed at all. | ||
55 | |||
56 | The precise terms and conditions for copying, distribution and | ||
57 | modification follow. | ||
58 | |||
59 | GNU GENERAL PUBLIC LICENSE | ||
60 | TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION | ||
61 | |||
62 | 0. This License applies to any program or other work which contains | ||
63 | a notice placed by the copyright holder saying it may be distributed | ||
64 | under the terms of this General Public License. The "Program", below, | ||
65 | refers to any such program or work, and a "work based on the Program" | ||
66 | means either the Program or any derivative work under copyright law: | ||
67 | that is to say, a work containing the Program or a portion of it, | ||
68 | either verbatim or with modifications and/or translated into another | ||
69 | language. (Hereinafter, translation is included without limitation in | ||
70 | the term "modification".) Each licensee is addressed as "you". | ||
71 | |||
72 | Activities other than copying, distribution and modification are not | ||
73 | covered by this License; they are outside its scope. The act of | ||
74 | running the Program is not restricted, and the output from the Program | ||
75 | is covered only if its contents constitute a work based on the | ||
76 | Program (independent of having been made by running the Program). | ||
77 | Whether that is true depends on what the Program does. | ||
78 | |||
79 | 1. You may copy and distribute verbatim copies of the Program's | ||
80 | source code as you receive it, in any medium, provided that you | ||
81 | conspicuously and appropriately publish on each copy an appropriate | ||
82 | copyright notice and disclaimer of warranty; keep intact all the | ||
83 | notices that refer to this License and to the absence of any warranty; | ||
84 | and give any other recipients of the Program a copy of this License | ||
85 | along with the Program. | ||
86 | |||
87 | You may charge a fee for the physical act of transferring a copy, and | ||
88 | you may at your option offer warranty protection in exchange for a fee. | ||
89 | |||
90 | 2. You may modify your copy or copies of the Program or any portion | ||
91 | of it, thus forming a work based on the Program, and copy and | ||
92 | distribute such modifications or work under the terms of Section 1 | ||
93 | above, provided that you also meet all of these conditions: | ||
94 | |||
95 | a) You must cause the modified files to carry prominent notices | ||
96 | stating that you changed the files and the date of any change. | ||
97 | |||
98 | b) You must cause any work that you distribute or publish, that in | ||
99 | whole or in part contains or is derived from the Program or any | ||
100 | part thereof, to be licensed as a whole at no charge to all third | ||
101 | parties under the terms of this License. | ||
102 | |||
103 | c) If the modified program normally reads commands interactively | ||
104 | when run, you must cause it, when started running for such | ||
105 | interactive use in the most ordinary way, to print or display an | ||
106 | announcement including an appropriate copyright notice and a | ||
107 | notice that there is no warranty (or else, saying that you provide | ||
108 | a warranty) and that users may redistribute the program under | ||
109 | these conditions, and telling the user how to view a copy of this | ||
110 | License. (Exception: if the Program itself is interactive but | ||
111 | does not normally print such an announcement, your work based on | ||
112 | the Program is not required to print an announcement.) | ||
113 | |||
114 | These requirements apply to the modified work as a whole. If | ||
115 | identifiable sections of that work are not derived from the Program, | ||
116 | and can be reasonably considered independent and separate works in | ||
117 | themselves, then this License, and its terms, do not apply to those | ||
118 | sections when you distribute them as separate works. But when you | ||
119 | distribute the same sections as part of a whole which is a work based | ||
120 | on the Program, the distribution of the whole must be on the terms of | ||
121 | this License, whose permissions for other licensees extend to the | ||
122 | entire whole, and thus to each and every part regardless of who wrote it. | ||
123 | |||
124 | Thus, it is not the intent of this section to claim rights or contest | ||
125 | your rights to work written entirely by you; rather, the intent is to | ||
126 | exercise the right to control the distribution of derivative or | ||
127 | collective works based on the Program. | ||
128 | |||
129 | In addition, mere aggregation of another work not based on the Program | ||
130 | with the Program (or with a work based on the Program) on a volume of | ||
131 | a storage or distribution medium does not bring the other work under | ||
132 | the scope of this License. | ||
133 | |||
134 | 3. You may copy and distribute the Program (or a work based on it, | ||
135 | under Section 2) in object code or executable form under the terms of | ||
136 | Sections 1 and 2 above provided that you also do one of the following: | ||
137 | |||
138 | a) Accompany it with the complete corresponding machine-readable | ||
139 | source code, which must be distributed under the terms of Sections | ||
140 | 1 and 2 above on a medium customarily used for software interchange; or, | ||
141 | |||
142 | b) Accompany it with a written offer, valid for at least three | ||
143 | years, to give any third party, for a charge no more than your | ||
144 | cost of physically performing source distribution, a complete | ||
145 | machine-readable copy of the corresponding source code, to be | ||
146 | distributed under the terms of Sections 1 and 2 above on a medium | ||
147 | customarily used for software interchange; or, | ||
148 | |||
149 | c) Accompany it with the information you received as to the offer | ||
150 | to distribute corresponding source code. (This alternative is | ||
151 | allowed only for noncommercial distribution and only if you | ||
152 | received the program in object code or executable form with such | ||
153 | an offer, in accord with Subsection b above.) | ||
154 | |||
155 | The source code for a work means the preferred form of the work for | ||
156 | making modifications to it. For an executable work, complete source | ||
157 | code means all the source code for all modules it contains, plus any | ||
158 | associated interface definition files, plus the scripts used to | ||
159 | control compilation and installation of the executable. However, as a | ||
160 | special exception, the source code distributed need not include | ||
161 | anything that is normally distributed (in either source or binary | ||
162 | form) with the major components (compiler, kernel, and so on) of the | ||
163 | operating system on which the executable runs, unless that component | ||
164 | itself accompanies the executable. | ||
165 | |||
166 | If distribution of executable or object code is made by offering | ||
167 | access to copy from a designated place, then offering equivalent | ||
168 | access to copy the source code from the same place counts as | ||
169 | distribution of the source code, even though third parties are not | ||
170 | compelled to copy the source along with the object code. | ||
171 | |||
172 | 4. You may not copy, modify, sublicense, or distribute the Program | ||
173 | except as expressly provided under this License. Any attempt | ||
174 | otherwise to copy, modify, sublicense or distribute the Program is | ||
175 | void, and will automatically terminate your rights under this License. | ||
176 | However, parties who have received copies, or rights, from you under | ||
177 | this License will not have their licenses terminated so long as such | ||
178 | parties remain in full compliance. | ||
179 | |||
180 | 5. You are not required to accept this License, since you have not | ||
181 | signed it. However, nothing else grants you permission to modify or | ||
182 | distribute the Program or its derivative works. These actions are | ||
183 | prohibited by law if you do not accept this License. Therefore, by | ||
184 | modifying or distributing the Program (or any work based on the | ||
185 | Program), you indicate your acceptance of this License to do so, and | ||
186 | all its terms and conditions for copying, distributing or modifying | ||
187 | the Program or works based on it. | ||
188 | |||
189 | 6. Each time you redistribute the Program (or any work based on the | ||
190 | Program), the recipient automatically receives a license from the | ||
191 | original licensor to copy, distribute or modify the Program subject to | ||
192 | these terms and conditions. You may not impose any further | ||
193 | restrictions on the recipients' exercise of the rights granted herein. | ||
194 | You are not responsible for enforcing compliance by third parties to | ||
195 | this License. | ||
196 | |||
197 | 7. If, as a consequence of a court judgment or allegation of patent | ||
198 | infringement or for any other reason (not limited to patent issues), | ||
199 | conditions are imposed on you (whether by court order, agreement or | ||
200 | otherwise) that contradict the conditions of this License, they do not | ||
201 | excuse you from the conditions of this License. If you cannot | ||
202 | distribute so as to satisfy simultaneously your obligations under this | ||
203 | License and any other pertinent obligations, then as a consequence you | ||
204 | may not distribute the Program at all. For example, if a patent | ||
205 | license would not permit royalty-free redistribution of the Program by | ||
206 | all those who receive copies directly or indirectly through you, then | ||
207 | the only way you could satisfy both it and this License would be to | ||
208 | refrain entirely from distribution of the Program. | ||
209 | |||
210 | If any portion of this section is held invalid or unenforceable under | ||
211 | any particular circumstance, the balance of the section is intended to | ||
212 | apply and the section as a whole is intended to apply in other | ||
213 | circumstances. | ||
214 | |||
215 | It is not the purpose of this section to induce you to infringe any | ||
216 | patents or other property right claims or to contest validity of any | ||
217 | such claims; this section has the sole purpose of protecting the | ||
218 | integrity of the free software distribution system, which is | ||
219 | implemented by public license practices. Many people have made | ||
220 | generous contributions to the wide range of software distributed | ||
221 | through that system in reliance on consistent application of that | ||
222 | system; it is up to the author/donor to decide if he or she is willing | ||
223 | to distribute software through any other system and a licensee cannot | ||
224 | impose that choice. | ||
225 | |||
226 | This section is intended to make thoroughly clear what is believed to | ||
227 | be a consequence of the rest of this License. | ||
228 | |||
229 | 8. If the distribution and/or use of the Program is restricted in | ||
230 | certain countries either by patents or by copyrighted interfaces, the | ||
231 | original copyright holder who places the Program under this License | ||
232 | may add an explicit geographical distribution limitation excluding | ||
233 | those countries, so that distribution is permitted only in or among | ||
234 | countries not thus excluded. In such case, this License incorporates | ||
235 | the limitation as if written in the body of this License. | ||
236 | |||
237 | 9. The Free Software Foundation may publish revised and/or new versions | ||
238 | of the General Public License from time to time. Such new versions will | ||
239 | be similar in spirit to the present version, but may differ in detail to | ||
240 | address new problems or concerns. | ||
241 | |||
242 | Each version is given a distinguishing version number. If the Program | ||
243 | specifies a version number of this License which applies to it and "any | ||
244 | later version", you have the option of following the terms and conditions | ||
245 | either of that version or of any later version published by the Free | ||
246 | Software Foundation. If the Program does not specify a version number of | ||
247 | this License, you may choose any version ever published by the Free Software | ||
248 | Foundation. | ||
249 | |||
250 | 10. If you wish to incorporate parts of the Program into other free | ||
251 | programs whose distribution conditions are different, write to the author | ||
252 | to ask for permission. For software which is copyrighted by the Free | ||
253 | Software Foundation, write to the Free Software Foundation; we sometimes | ||
254 | make exceptions for this. Our decision will be guided by the two goals | ||
255 | of preserving the free status of all derivatives of our free software and | ||
256 | of promoting the sharing and reuse of software generally. | ||
257 | |||
258 | NO WARRANTY | ||
259 | |||
260 | 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY | ||
261 | FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN | ||
262 | OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES | ||
263 | PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED | ||
264 | OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF | ||
265 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS | ||
266 | TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE | ||
267 | PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, | ||
268 | REPAIR OR CORRECTION. | ||
269 | |||
270 | 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING | ||
271 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR | ||
272 | REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, | ||
273 | INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING | ||
274 | OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED | ||
275 | TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY | ||
276 | YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER | ||
277 | PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE | ||
278 | POSSIBILITY OF SUCH DAMAGES. | ||
279 | |||
280 | END OF TERMS AND CONDITIONS | ||
281 | |||
282 | How to Apply These Terms to Your New Programs | ||
283 | |||
284 | If you develop a new program, and you want it to be of the greatest | ||
285 | possible use to the public, the best way to achieve this is to make it | ||
286 | free software which everyone can redistribute and change under these terms. | ||
287 | |||
288 | To do so, attach the following notices to the program. It is safest | ||
289 | to attach them to the start of each source file to most effectively | ||
290 | convey the exclusion of warranty; and each file should have at least | ||
291 | the "copyright" line and a pointer to where the full notice is found. | ||
292 | |||
293 | <one line to give the program's name and a brief idea of what it does.> | ||
294 | Copyright (C) <year> <name of author> | ||
295 | |||
296 | This program is free software; you can redistribute it and/or modify | ||
297 | it under the terms of the GNU General Public License as published by | ||
298 | the Free Software Foundation; either version 2 of the License, or | ||
299 | (at your option) any later version. | ||
300 | |||
301 | This program is distributed in the hope that it will be useful, | ||
302 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
303 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
304 | GNU General Public License for more details. | ||
305 | |||
306 | You should have received a copy of the GNU General Public License | ||
307 | along with this program; if not, write to the Free Software | ||
308 | Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA Â 02111-1307, USA. | ||
309 | |||
310 | Also add information on how to contact you by electronic and paper mail. | ||
311 | |||
312 | If the program is interactive, make it output a short notice like this | ||
313 | when it starts in an interactive mode: | ||
314 | |||
315 | Gnomovision version 69, Copyright (C) year name of author | ||
316 | Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. | ||
317 | This is free software, and you are welcome to redistribute it | ||
318 | under certain conditions; type `show c' for details. | ||
319 | |||
320 | The hypothetical commands `show w' and `show c' should show the appropriate | ||
321 | parts of the General Public License. Of course, the commands you use may | ||
322 | be called something other than `show w' and `show c'; they could even be | ||
323 | mouse-clicks or menu items--whatever suits your program. | ||
324 | |||
325 | You should also get your employer (if you work as a programmer) or your | ||
326 | school, if any, to sign a "copyright disclaimer" for the program, if | ||
327 | necessary. Here is a sample; alter the names: | ||
328 | |||
329 | Yoyodyne, Inc., hereby disclaims all copyright interest in the program | ||
330 | `Gnomovision' (which makes passes at compilers) written by James Hacker. | ||
331 | |||
332 | <signature of Ty Coon>, 1 April 1989 | ||
333 | Ty Coon, President of Vice | ||
334 | |||
335 | This General Public License does not permit incorporating your program into | ||
336 | proprietary programs. If your program is a subroutine library, you may | ||
337 | consider it more useful to permit linking proprietary applications with the | ||
338 | library. If this is what you want to do, use the GNU Library General | ||
339 | Public License instead of this License. | ||
340 | |||
341 | ------------------------------------------------------------------------- | ||
diff --git a/utils/themeeditor/quazip/README.ROCKBOX b/utils/themeeditor/quazip/README.ROCKBOX new file mode 100644 index 0000000000..b95f80caee --- /dev/null +++ b/utils/themeeditor/quazip/README.ROCKBOX | |||
@@ -0,0 +1,6 @@ | |||
1 | This folder contains the quazip project for ZIP file compression/decompression. | ||
2 | These files are distributed under the GPL v2 or later. | ||
3 | The source files have been last synced with the projects release at | ||
4 | http://sourceforge.net/projects/quazip/ on July 20, 2010 | ||
5 | |||
6 | |||
diff --git a/utils/themeeditor/quazip/crypt.h b/utils/themeeditor/quazip/crypt.h new file mode 100644 index 0000000000..82748c5715 --- /dev/null +++ b/utils/themeeditor/quazip/crypt.h | |||
@@ -0,0 +1,133 @@ | |||
1 | /* crypt.h -- base code for crypt/uncrypt ZIPfile | ||
2 | |||
3 | |||
4 | Version 1.01e, February 12th, 2005 | ||
5 | |||
6 | Copyright (C) 1998-2005 Gilles Vollant | ||
7 | |||
8 | This code is a modified version of crypting code in Infozip distribution | ||
9 | |||
10 | The encryption/decryption parts of this source code (as opposed to the | ||
11 | non-echoing password parts) were originally written in Europe. The | ||
12 | whole source package can be freely distributed, including from the USA. | ||
13 | (Prior to January 2000, re-export from the US was a violation of US law.) | ||
14 | |||
15 | This encryption code is a direct transcription of the algorithm from | ||
16 | Roger Schlafly, described by Phil Katz in the file appnote.txt. This | ||
17 | file (appnote.txt) is distributed with the PKZIP program (even in the | ||
18 | version without encryption capabilities). | ||
19 | |||
20 | If you don't need crypting in your application, just define symbols | ||
21 | NOCRYPT and NOUNCRYPT. | ||
22 | |||
23 | This code support the "Traditional PKWARE Encryption". | ||
24 | |||
25 | The new AES encryption added on Zip format by Winzip (see the page | ||
26 | http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong | ||
27 | Encryption is not supported. | ||
28 | */ | ||
29 | |||
30 | #define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8)) | ||
31 | |||
32 | /*********************************************************************** | ||
33 | * Return the next byte in the pseudo-random sequence | ||
34 | */ | ||
35 | static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab) | ||
36 | { | ||
37 | (void) pcrc_32_tab; /* avoid "unused parameter" warning */ | ||
38 | unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an | ||
39 | * unpredictable manner on 16-bit systems; not a problem | ||
40 | * with any known compiler so far, though */ | ||
41 | |||
42 | temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2; | ||
43 | return (int)(((temp * (temp ^ 1)) >> 8) & 0xff); | ||
44 | } | ||
45 | |||
46 | /*********************************************************************** | ||
47 | * Update the encryption keys with the next byte of plain text | ||
48 | */ | ||
49 | static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c) | ||
50 | { | ||
51 | (*(pkeys+0)) = CRC32((*(pkeys+0)), c); | ||
52 | (*(pkeys+1)) += (*(pkeys+0)) & 0xff; | ||
53 | (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1; | ||
54 | { | ||
55 | register int keyshift = (int)((*(pkeys+1)) >> 24); | ||
56 | (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift); | ||
57 | } | ||
58 | return c; | ||
59 | } | ||
60 | |||
61 | |||
62 | /*********************************************************************** | ||
63 | * Initialize the encryption keys and the random header according to | ||
64 | * the given password. | ||
65 | */ | ||
66 | static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab) | ||
67 | { | ||
68 | *(pkeys+0) = 305419896L; | ||
69 | *(pkeys+1) = 591751049L; | ||
70 | *(pkeys+2) = 878082192L; | ||
71 | while (*passwd != '\0') { | ||
72 | update_keys(pkeys,pcrc_32_tab,(int)*passwd); | ||
73 | passwd++; | ||
74 | } | ||
75 | } | ||
76 | |||
77 | #define zdecode(pkeys,pcrc_32_tab,c) \ | ||
78 | (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab))) | ||
79 | |||
80 | #define zencode(pkeys,pcrc_32_tab,c,t) \ | ||
81 | (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c)) | ||
82 | |||
83 | #ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED | ||
84 | |||
85 | #define RAND_HEAD_LEN 12 | ||
86 | /* "last resort" source for second part of crypt seed pattern */ | ||
87 | # ifndef ZCR_SEED2 | ||
88 | # define ZCR_SEED2 3141592654UL /* use PI as default pattern */ | ||
89 | # endif | ||
90 | |||
91 | static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting) | ||
92 | const char *passwd; /* password string */ | ||
93 | unsigned char *buf; /* where to write header */ | ||
94 | int bufSize; | ||
95 | unsigned long* pkeys; | ||
96 | const unsigned long* pcrc_32_tab; | ||
97 | unsigned long crcForCrypting; | ||
98 | { | ||
99 | int n; /* index in random header */ | ||
100 | int t; /* temporary */ | ||
101 | int c; /* random byte */ | ||
102 | unsigned char header[RAND_HEAD_LEN-2]; /* random header */ | ||
103 | static unsigned calls = 0; /* ensure different random header each time */ | ||
104 | |||
105 | if (bufSize<RAND_HEAD_LEN) | ||
106 | return 0; | ||
107 | |||
108 | /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the | ||
109 | * output of rand() to get less predictability, since rand() is | ||
110 | * often poorly implemented. | ||
111 | */ | ||
112 | if (++calls == 1) | ||
113 | { | ||
114 | srand((unsigned)(time(NULL) ^ ZCR_SEED2)); | ||
115 | } | ||
116 | init_keys(passwd, pkeys, pcrc_32_tab); | ||
117 | for (n = 0; n < RAND_HEAD_LEN-2; n++) | ||
118 | { | ||
119 | c = (rand() >> 7) & 0xff; | ||
120 | header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t); | ||
121 | } | ||
122 | /* Encrypt random header (last two bytes is high word of crc) */ | ||
123 | init_keys(passwd, pkeys, pcrc_32_tab); | ||
124 | for (n = 0; n < RAND_HEAD_LEN-2; n++) | ||
125 | { | ||
126 | buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t); | ||
127 | } | ||
128 | buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t); | ||
129 | buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t); | ||
130 | return n; | ||
131 | } | ||
132 | |||
133 | #endif | ||
diff --git a/utils/themeeditor/quazip/ioapi.c b/utils/themeeditor/quazip/ioapi.c new file mode 100644 index 0000000000..cf29a317fd --- /dev/null +++ b/utils/themeeditor/quazip/ioapi.c | |||
@@ -0,0 +1,184 @@ | |||
1 | /* ioapi.c -- IO base function header for compress/uncompress .zip | ||
2 | files using zlib + zip or unzip API | ||
3 | |||
4 | Version 1.01e, February 12th, 2005 | ||
5 | |||
6 | Copyright (C) 1998-2005 Gilles Vollant | ||
7 | */ | ||
8 | |||
9 | #include <stdio.h> | ||
10 | #include <stdlib.h> | ||
11 | #include <string.h> | ||
12 | |||
13 | #include "zlib.h" | ||
14 | #include "ioapi.h" | ||
15 | |||
16 | |||
17 | |||
18 | /* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ | ||
19 | |||
20 | #ifndef SEEK_CUR | ||
21 | #define SEEK_CUR 1 | ||
22 | #endif | ||
23 | |||
24 | #ifndef SEEK_END | ||
25 | #define SEEK_END 2 | ||
26 | #endif | ||
27 | |||
28 | #ifndef SEEK_SET | ||
29 | #define SEEK_SET 0 | ||
30 | #endif | ||
31 | |||
32 | voidpf ZCALLBACK fopen_file_func OF(( | ||
33 | voidpf opaque, | ||
34 | const char* filename, | ||
35 | int mode)); | ||
36 | |||
37 | uLong ZCALLBACK fread_file_func OF(( | ||
38 | voidpf opaque, | ||
39 | voidpf stream, | ||
40 | void* buf, | ||
41 | uLong size)); | ||
42 | |||
43 | uLong ZCALLBACK fwrite_file_func OF(( | ||
44 | voidpf opaque, | ||
45 | voidpf stream, | ||
46 | const void* buf, | ||
47 | uLong size)); | ||
48 | |||
49 | long ZCALLBACK ftell_file_func OF(( | ||
50 | voidpf opaque, | ||
51 | voidpf stream)); | ||
52 | |||
53 | long ZCALLBACK fseek_file_func OF(( | ||
54 | voidpf opaque, | ||
55 | voidpf stream, | ||
56 | uLong offset, | ||
57 | int origin)); | ||
58 | |||
59 | int ZCALLBACK fclose_file_func OF(( | ||
60 | voidpf opaque, | ||
61 | voidpf stream)); | ||
62 | |||
63 | int ZCALLBACK ferror_file_func OF(( | ||
64 | voidpf opaque, | ||
65 | voidpf stream)); | ||
66 | |||
67 | |||
68 | voidpf ZCALLBACK fopen_file_func (opaque, filename, mode) | ||
69 | voidpf opaque; | ||
70 | const char* filename; | ||
71 | int mode; | ||
72 | { | ||
73 | (void) opaque; /* avoid "unused parameter" warning */ | ||
74 | FILE* file = NULL; | ||
75 | const char* mode_fopen = NULL; | ||
76 | if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) | ||
77 | mode_fopen = "rb"; | ||
78 | else | ||
79 | if (mode & ZLIB_FILEFUNC_MODE_EXISTING) | ||
80 | mode_fopen = "r+b"; | ||
81 | else | ||
82 | if (mode & ZLIB_FILEFUNC_MODE_CREATE) | ||
83 | mode_fopen = "wb"; | ||
84 | |||
85 | if ((filename!=NULL) && (mode_fopen != NULL)) | ||
86 | file = fopen(filename, mode_fopen); | ||
87 | return file; | ||
88 | } | ||
89 | |||
90 | |||
91 | uLong ZCALLBACK fread_file_func (opaque, stream, buf, size) | ||
92 | voidpf opaque; | ||
93 | voidpf stream; | ||
94 | void* buf; | ||
95 | uLong size; | ||
96 | { | ||
97 | (void) opaque; /* avoid "unused parameter" warning */ | ||
98 | uLong ret; | ||
99 | ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream); | ||
100 | return ret; | ||
101 | } | ||
102 | |||
103 | |||
104 | uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size) | ||
105 | voidpf opaque; | ||
106 | voidpf stream; | ||
107 | const void* buf; | ||
108 | uLong size; | ||
109 | { | ||
110 | (void) opaque; /* avoid "unused parameter" warning */ | ||
111 | uLong ret; | ||
112 | ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream); | ||
113 | return ret; | ||
114 | } | ||
115 | |||
116 | long ZCALLBACK ftell_file_func (opaque, stream) | ||
117 | voidpf opaque; | ||
118 | voidpf stream; | ||
119 | { | ||
120 | (void) opaque; /* avoid "unused parameter" warning */ | ||
121 | long ret; | ||
122 | ret = ftell((FILE *)stream); | ||
123 | return ret; | ||
124 | } | ||
125 | |||
126 | long ZCALLBACK fseek_file_func (opaque, stream, offset, origin) | ||
127 | voidpf opaque; | ||
128 | voidpf stream; | ||
129 | uLong offset; | ||
130 | int origin; | ||
131 | { | ||
132 | (void) opaque; /* avoid "unused parameter" warning */ | ||
133 | int fseek_origin=0; | ||
134 | long ret; | ||
135 | switch (origin) | ||
136 | { | ||
137 | case ZLIB_FILEFUNC_SEEK_CUR : | ||
138 | fseek_origin = SEEK_CUR; | ||
139 | break; | ||
140 | case ZLIB_FILEFUNC_SEEK_END : | ||
141 | fseek_origin = SEEK_END; | ||
142 | break; | ||
143 | case ZLIB_FILEFUNC_SEEK_SET : | ||
144 | fseek_origin = SEEK_SET; | ||
145 | break; | ||
146 | default: return -1; | ||
147 | } | ||
148 | ret = 0; | ||
149 | fseek((FILE *)stream, offset, fseek_origin); | ||
150 | return ret; | ||
151 | } | ||
152 | |||
153 | int ZCALLBACK fclose_file_func (opaque, stream) | ||
154 | voidpf opaque; | ||
155 | voidpf stream; | ||
156 | { | ||
157 | (void) opaque; /* avoid "unused parameter" warning */ | ||
158 | int ret; | ||
159 | ret = fclose((FILE *)stream); | ||
160 | return ret; | ||
161 | } | ||
162 | |||
163 | int ZCALLBACK ferror_file_func (opaque, stream) | ||
164 | voidpf opaque; | ||
165 | voidpf stream; | ||
166 | { | ||
167 | (void) opaque; /* avoid "unused parameter" warning */ | ||
168 | int ret; | ||
169 | ret = ferror((FILE *)stream); | ||
170 | return ret; | ||
171 | } | ||
172 | |||
173 | void fill_fopen_filefunc (pzlib_filefunc_def) | ||
174 | zlib_filefunc_def* pzlib_filefunc_def; | ||
175 | { | ||
176 | pzlib_filefunc_def->zopen_file = fopen_file_func; | ||
177 | pzlib_filefunc_def->zread_file = fread_file_func; | ||
178 | pzlib_filefunc_def->zwrite_file = fwrite_file_func; | ||
179 | pzlib_filefunc_def->ztell_file = ftell_file_func; | ||
180 | pzlib_filefunc_def->zseek_file = fseek_file_func; | ||
181 | pzlib_filefunc_def->zclose_file = fclose_file_func; | ||
182 | pzlib_filefunc_def->zerror_file = ferror_file_func; | ||
183 | pzlib_filefunc_def->opaque = NULL; | ||
184 | } | ||
diff --git a/utils/themeeditor/quazip/ioapi.h b/utils/themeeditor/quazip/ioapi.h new file mode 100644 index 0000000000..7d457baab3 --- /dev/null +++ b/utils/themeeditor/quazip/ioapi.h | |||
@@ -0,0 +1,75 @@ | |||
1 | /* ioapi.h -- IO base function header for compress/uncompress .zip | ||
2 | files using zlib + zip or unzip API | ||
3 | |||
4 | Version 1.01e, February 12th, 2005 | ||
5 | |||
6 | Copyright (C) 1998-2005 Gilles Vollant | ||
7 | */ | ||
8 | |||
9 | #ifndef _ZLIBIOAPI_H | ||
10 | #define _ZLIBIOAPI_H | ||
11 | |||
12 | |||
13 | #define ZLIB_FILEFUNC_SEEK_CUR (1) | ||
14 | #define ZLIB_FILEFUNC_SEEK_END (2) | ||
15 | #define ZLIB_FILEFUNC_SEEK_SET (0) | ||
16 | |||
17 | #define ZLIB_FILEFUNC_MODE_READ (1) | ||
18 | #define ZLIB_FILEFUNC_MODE_WRITE (2) | ||
19 | #define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3) | ||
20 | |||
21 | #define ZLIB_FILEFUNC_MODE_EXISTING (4) | ||
22 | #define ZLIB_FILEFUNC_MODE_CREATE (8) | ||
23 | |||
24 | |||
25 | #ifndef ZCALLBACK | ||
26 | |||
27 | #if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK) | ||
28 | #define ZCALLBACK CALLBACK | ||
29 | #else | ||
30 | #define ZCALLBACK | ||
31 | #endif | ||
32 | #endif | ||
33 | |||
34 | #ifdef __cplusplus | ||
35 | extern "C" { | ||
36 | #endif | ||
37 | |||
38 | typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode)); | ||
39 | typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size)); | ||
40 | typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size)); | ||
41 | typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream)); | ||
42 | typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin)); | ||
43 | typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream)); | ||
44 | typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream)); | ||
45 | |||
46 | typedef struct zlib_filefunc_def_s | ||
47 | { | ||
48 | open_file_func zopen_file; | ||
49 | read_file_func zread_file; | ||
50 | write_file_func zwrite_file; | ||
51 | tell_file_func ztell_file; | ||
52 | seek_file_func zseek_file; | ||
53 | close_file_func zclose_file; | ||
54 | testerror_file_func zerror_file; | ||
55 | voidpf opaque; | ||
56 | } zlib_filefunc_def; | ||
57 | |||
58 | |||
59 | |||
60 | void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def)); | ||
61 | |||
62 | #define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size)) | ||
63 | #define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size)) | ||
64 | #define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream)) | ||
65 | #define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode)) | ||
66 | #define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream)) | ||
67 | #define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream)) | ||
68 | |||
69 | |||
70 | #ifdef __cplusplus | ||
71 | } | ||
72 | #endif | ||
73 | |||
74 | #endif | ||
75 | |||
diff --git a/utils/themeeditor/quazip/quazip.cpp b/utils/themeeditor/quazip/quazip.cpp new file mode 100644 index 0000000000..3f7314a433 --- /dev/null +++ b/utils/themeeditor/quazip/quazip.cpp | |||
@@ -0,0 +1,285 @@ | |||
1 | /* | ||
2 | -- A kind of "standard" GPL license statement -- | ||
3 | QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package | ||
4 | Copyright (C) 2005-2007 Sergey A. Tachenov | ||
5 | |||
6 | This program is free software; you can redistribute it and/or modify it | ||
7 | under the terms of the GNU General Public License as published by the | ||
8 | Free Software Foundation; either version 2 of the License, or (at your | ||
9 | option) any later version. | ||
10 | |||
11 | This program is distributed in the hope that it will be useful, but | ||
12 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General | ||
14 | Public License for more details. | ||
15 | |||
16 | You should have received a copy of the GNU General Public License along | ||
17 | with this program; if not, write to the Free Software Foundation, Inc., | ||
18 | 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
19 | |||
20 | -- A kind of "standard" GPL license statement ends here -- | ||
21 | |||
22 | See COPYING file for GPL. | ||
23 | |||
24 | You are also permitted to use QuaZIP under the terms of LGPL (see | ||
25 | COPYING.LGPL). You are free to choose either license, but please note | ||
26 | that QuaZIP makes use of Qt, which is not licensed under LGPL. So if | ||
27 | you are using Open Source edition of Qt, you therefore MUST use GPL for | ||
28 | your code based on QuaZIP, since it would be also based on Qt in this | ||
29 | case. If you are Qt commercial license owner, then you are free to use | ||
30 | QuaZIP as long as you respect either GPL or LGPL for QuaZIP code. | ||
31 | **/ | ||
32 | |||
33 | #include <QFile> | ||
34 | |||
35 | #include "quazip.h" | ||
36 | |||
37 | QuaZip::QuaZip(): | ||
38 | fileNameCodec(QTextCodec::codecForLocale()), | ||
39 | commentCodec(QTextCodec::codecForLocale()), | ||
40 | mode(mdNotOpen), hasCurrentFile_f(false), zipError(UNZ_OK) | ||
41 | { | ||
42 | } | ||
43 | |||
44 | QuaZip::QuaZip(const QString& zipName): | ||
45 | fileNameCodec(QTextCodec::codecForLocale()), | ||
46 | commentCodec(QTextCodec::codecForLocale()), | ||
47 | zipName(zipName), | ||
48 | mode(mdNotOpen), hasCurrentFile_f(false), zipError(UNZ_OK) | ||
49 | { | ||
50 | } | ||
51 | |||
52 | QuaZip::~QuaZip() | ||
53 | { | ||
54 | if(isOpen()) close(); | ||
55 | } | ||
56 | |||
57 | bool QuaZip::open(Mode mode, zlib_filefunc_def* ioApi) | ||
58 | { | ||
59 | zipError=UNZ_OK; | ||
60 | if(isOpen()) { | ||
61 | qWarning("QuaZip::open(): ZIP already opened"); | ||
62 | return false; | ||
63 | } | ||
64 | switch(mode) { | ||
65 | case mdUnzip: | ||
66 | unzFile_f=unzOpen2(QFile::encodeName(zipName).constData(), ioApi); | ||
67 | if(unzFile_f!=NULL) { | ||
68 | this->mode=mode; | ||
69 | return true; | ||
70 | } else { | ||
71 | zipError=UNZ_OPENERROR; | ||
72 | return false; | ||
73 | } | ||
74 | case mdCreate: | ||
75 | case mdAppend: | ||
76 | case mdAdd: | ||
77 | zipFile_f=zipOpen2(QFile::encodeName(zipName).constData(), | ||
78 | mode==mdCreate?APPEND_STATUS_CREATE: | ||
79 | mode==mdAppend?APPEND_STATUS_CREATEAFTER: | ||
80 | APPEND_STATUS_ADDINZIP, | ||
81 | NULL, | ||
82 | ioApi); | ||
83 | if(zipFile_f!=NULL) { | ||
84 | this->mode=mode; | ||
85 | return true; | ||
86 | } else { | ||
87 | zipError=UNZ_OPENERROR; | ||
88 | return false; | ||
89 | } | ||
90 | default: | ||
91 | qWarning("QuaZip::open(): unknown mode: %d", (int)mode); | ||
92 | return false; | ||
93 | break; | ||
94 | } | ||
95 | } | ||
96 | |||
97 | void QuaZip::close() | ||
98 | { | ||
99 | zipError=UNZ_OK; | ||
100 | switch(mode) { | ||
101 | case mdNotOpen: | ||
102 | qWarning("QuaZip::close(): ZIP is not open"); | ||
103 | return; | ||
104 | case mdUnzip: | ||
105 | zipError=unzClose(unzFile_f); | ||
106 | break; | ||
107 | case mdCreate: | ||
108 | case mdAppend: | ||
109 | case mdAdd: | ||
110 | zipError=zipClose(zipFile_f, commentCodec->fromUnicode(comment).constData()); | ||
111 | break; | ||
112 | default: | ||
113 | qWarning("QuaZip::close(): unknown mode: %d", (int)mode); | ||
114 | return; | ||
115 | } | ||
116 | if(zipError==UNZ_OK) mode=mdNotOpen; | ||
117 | } | ||
118 | |||
119 | void QuaZip::setZipName(const QString& zipName) | ||
120 | { | ||
121 | if(isOpen()) { | ||
122 | qWarning("QuaZip::setZipName(): ZIP is already open!"); | ||
123 | return; | ||
124 | } | ||
125 | this->zipName=zipName; | ||
126 | } | ||
127 | |||
128 | int QuaZip::getEntriesCount()const | ||
129 | { | ||
130 | QuaZip *fakeThis=(QuaZip*)this; // non-const | ||
131 | fakeThis->zipError=UNZ_OK; | ||
132 | if(mode!=mdUnzip) { | ||
133 | qWarning("QuaZip::getEntriesCount(): ZIP is not open in mdUnzip mode"); | ||
134 | return -1; | ||
135 | } | ||
136 | unz_global_info globalInfo; | ||
137 | if((fakeThis->zipError=unzGetGlobalInfo(unzFile_f, &globalInfo))!=UNZ_OK) | ||
138 | return zipError; | ||
139 | return (int)globalInfo.number_entry; | ||
140 | } | ||
141 | |||
142 | QString QuaZip::getComment()const | ||
143 | { | ||
144 | QuaZip *fakeThis=(QuaZip*)this; // non-const | ||
145 | fakeThis->zipError=UNZ_OK; | ||
146 | if(mode!=mdUnzip) { | ||
147 | qWarning("QuaZip::getComment(): ZIP is not open in mdUnzip mode"); | ||
148 | return QString(); | ||
149 | } | ||
150 | unz_global_info globalInfo; | ||
151 | QByteArray comment; | ||
152 | if((fakeThis->zipError=unzGetGlobalInfo(unzFile_f, &globalInfo))!=UNZ_OK) | ||
153 | return QString(); | ||
154 | comment.resize(globalInfo.size_comment); | ||
155 | if((fakeThis->zipError=unzGetGlobalComment(unzFile_f, comment.data(), comment.size()))!=UNZ_OK) | ||
156 | return QString(); | ||
157 | return commentCodec->toUnicode(comment); | ||
158 | } | ||
159 | |||
160 | bool QuaZip::setCurrentFile(const QString& fileName, CaseSensitivity cs) | ||
161 | { | ||
162 | zipError=UNZ_OK; | ||
163 | if(mode!=mdUnzip) { | ||
164 | qWarning("QuaZip::setCurrentFile(): ZIP is not open in mdUnzip mode"); | ||
165 | return false; | ||
166 | } | ||
167 | if(fileName.isNull()) { | ||
168 | hasCurrentFile_f=false; | ||
169 | return true; | ||
170 | } | ||
171 | // Unicode-aware reimplementation of the unzLocateFile function | ||
172 | if(unzFile_f==NULL) { | ||
173 | zipError=UNZ_PARAMERROR; | ||
174 | return false; | ||
175 | } | ||
176 | if(fileName.length()>MAX_FILE_NAME_LENGTH) { | ||
177 | zipError=UNZ_PARAMERROR; | ||
178 | return false; | ||
179 | } | ||
180 | bool sens; | ||
181 | if(cs==csDefault) { | ||
182 | #ifdef Q_WS_WIN | ||
183 | sens=false; | ||
184 | #else | ||
185 | sens=true; | ||
186 | #endif | ||
187 | } else sens=cs==csSensitive; | ||
188 | QString lower, current; | ||
189 | if(!sens) lower=fileName.toLower(); | ||
190 | hasCurrentFile_f=false; | ||
191 | for(bool more=goToFirstFile(); more; more=goToNextFile()) { | ||
192 | current=getCurrentFileName(); | ||
193 | if(current.isNull()) return false; | ||
194 | if(sens) { | ||
195 | if(current==fileName) break; | ||
196 | } else { | ||
197 | if(current.toLower()==lower) break; | ||
198 | } | ||
199 | } | ||
200 | return hasCurrentFile_f; | ||
201 | } | ||
202 | |||
203 | bool QuaZip::goToFirstFile() | ||
204 | { | ||
205 | zipError=UNZ_OK; | ||
206 | if(mode!=mdUnzip) { | ||
207 | qWarning("QuaZip::goToFirstFile(): ZIP is not open in mdUnzip mode"); | ||
208 | return false; | ||
209 | } | ||
210 | zipError=unzGoToFirstFile(unzFile_f); | ||
211 | hasCurrentFile_f=zipError==UNZ_OK; | ||
212 | return hasCurrentFile_f; | ||
213 | } | ||
214 | |||
215 | bool QuaZip::goToNextFile() | ||
216 | { | ||
217 | zipError=UNZ_OK; | ||
218 | if(mode!=mdUnzip) { | ||
219 | qWarning("QuaZip::goToFirstFile(): ZIP is not open in mdUnzip mode"); | ||
220 | return false; | ||
221 | } | ||
222 | zipError=unzGoToNextFile(unzFile_f); | ||
223 | hasCurrentFile_f=zipError==UNZ_OK; | ||
224 | if(zipError==UNZ_END_OF_LIST_OF_FILE) zipError=UNZ_OK; | ||
225 | return hasCurrentFile_f; | ||
226 | } | ||
227 | |||
228 | bool QuaZip::getCurrentFileInfo(QuaZipFileInfo *info)const | ||
229 | { | ||
230 | QuaZip *fakeThis=(QuaZip*)this; // non-const | ||
231 | fakeThis->zipError=UNZ_OK; | ||
232 | if(mode!=mdUnzip) { | ||
233 | qWarning("QuaZip::getCurrentFileInfo(): ZIP is not open in mdUnzip mode"); | ||
234 | return false; | ||
235 | } | ||
236 | unz_file_info info_z; | ||
237 | QByteArray fileName; | ||
238 | QByteArray extra; | ||
239 | QByteArray comment; | ||
240 | if(info==NULL) return false; | ||
241 | if(!isOpen()||!hasCurrentFile()) return false; | ||
242 | if((fakeThis->zipError=unzGetCurrentFileInfo(unzFile_f, &info_z, NULL, 0, NULL, 0, NULL, 0))!=UNZ_OK) | ||
243 | return false; | ||
244 | fileName.resize(info_z.size_filename); | ||
245 | extra.resize(info_z.size_file_extra); | ||
246 | comment.resize(info_z.size_file_comment); | ||
247 | if((fakeThis->zipError=unzGetCurrentFileInfo(unzFile_f, NULL, | ||
248 | fileName.data(), fileName.size(), | ||
249 | extra.data(), extra.size(), | ||
250 | comment.data(), comment.size()))!=UNZ_OK) | ||
251 | return false; | ||
252 | info->versionCreated=info_z.version; | ||
253 | info->versionNeeded=info_z.version_needed; | ||
254 | info->flags=info_z.flag; | ||
255 | info->method=info_z.compression_method; | ||
256 | info->crc=info_z.crc; | ||
257 | info->compressedSize=info_z.compressed_size; | ||
258 | info->uncompressedSize=info_z.uncompressed_size; | ||
259 | info->diskNumberStart=info_z.disk_num_start; | ||
260 | info->internalAttr=info_z.internal_fa; | ||
261 | info->externalAttr=info_z.external_fa; | ||
262 | info->name=fileNameCodec->toUnicode(fileName); | ||
263 | info->comment=commentCodec->toUnicode(comment); | ||
264 | info->extra=extra; | ||
265 | info->dateTime=QDateTime( | ||
266 | QDate(info_z.tmu_date.tm_year, info_z.tmu_date.tm_mon+1, info_z.tmu_date.tm_mday), | ||
267 | QTime(info_z.tmu_date.tm_hour, info_z.tmu_date.tm_min, info_z.tmu_date.tm_sec)); | ||
268 | return true; | ||
269 | } | ||
270 | |||
271 | QString QuaZip::getCurrentFileName()const | ||
272 | { | ||
273 | QuaZip *fakeThis=(QuaZip*)this; // non-const | ||
274 | fakeThis->zipError=UNZ_OK; | ||
275 | if(mode!=mdUnzip) { | ||
276 | qWarning("QuaZip::getCurrentFileName(): ZIP is not open in mdUnzip mode"); | ||
277 | return QString(); | ||
278 | } | ||
279 | if(!isOpen()||!hasCurrentFile()) return QString(); | ||
280 | QByteArray fileName(MAX_FILE_NAME_LENGTH, 0); | ||
281 | if((fakeThis->zipError=unzGetCurrentFileInfo(unzFile_f, NULL, fileName.data(), fileName.size(), | ||
282 | NULL, 0, NULL, 0))!=UNZ_OK) | ||
283 | return QString(); | ||
284 | return fileNameCodec->toUnicode(fileName.constData()); | ||
285 | } | ||
diff --git a/utils/themeeditor/quazip/quazip.h b/utils/themeeditor/quazip/quazip.h new file mode 100644 index 0000000000..ced1ea0f1a --- /dev/null +++ b/utils/themeeditor/quazip/quazip.h | |||
@@ -0,0 +1,346 @@ | |||
1 | #ifndef QUA_ZIP_H | ||
2 | #define QUA_ZIP_H | ||
3 | |||
4 | /* | ||
5 | -- A kind of "standard" GPL license statement -- | ||
6 | QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package | ||
7 | Copyright (C) 2005-2007 Sergey A. Tachenov | ||
8 | |||
9 | This program is free software; you can redistribute it and/or modify it | ||
10 | under the terms of the GNU General Public License as published by the | ||
11 | Free Software Foundation; either version 2 of the License, or (at your | ||
12 | option) any later version. | ||
13 | |||
14 | This program is distributed in the hope that it will be useful, but | ||
15 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General | ||
17 | Public License for more details. | ||
18 | |||
19 | You should have received a copy of the GNU General Public License along | ||
20 | with this program; if not, write to the Free Software Foundation, Inc., | ||
21 | 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
22 | |||
23 | -- A kind of "standard" GPL license statement ends here -- | ||
24 | |||
25 | See COPYING file for GPL. | ||
26 | |||
27 | You are also permitted to use QuaZIP under the terms of LGPL (see | ||
28 | COPYING.LGPL). You are free to choose either license, but please note | ||
29 | that QuaZIP makes use of Qt, which is not licensed under LGPL. So if | ||
30 | you are using Open Source edition of Qt, you therefore MUST use GPL for | ||
31 | your code based on QuaZIP, since it would be also based on Qt in this | ||
32 | case. If you are Qt commercial license owner, then you are free to use | ||
33 | QuaZIP as long as you respect either GPL or LGPL for QuaZIP code. | ||
34 | **/ | ||
35 | |||
36 | #include <QString> | ||
37 | #include <QTextCodec> | ||
38 | |||
39 | #include "zip.h" | ||
40 | #include "unzip.h" | ||
41 | |||
42 | #include "quazipfileinfo.h" | ||
43 | |||
44 | // just in case it will be defined in the later versions of the ZIP/UNZIP | ||
45 | #ifndef UNZ_OPENERROR | ||
46 | // define additional error code | ||
47 | #define UNZ_OPENERROR -1000 | ||
48 | #endif | ||
49 | |||
50 | /// ZIP archive. | ||
51 | /** \class QuaZip quazip.h <quazip/quazip.h> | ||
52 | * This class implements basic interface to the ZIP archive. It can be | ||
53 | * used to read table contents of the ZIP archive and retreiving | ||
54 | * information about the files inside it. | ||
55 | * | ||
56 | * You can also use this class to open files inside archive by passing | ||
57 | * pointer to the instance of this class to the constructor of the | ||
58 | * QuaZipFile class. But see QuaZipFile::QuaZipFile(QuaZip*, QObject*) | ||
59 | * for the possible pitfalls. | ||
60 | * | ||
61 | * This class is indended to provide interface to the ZIP subpackage of | ||
62 | * the ZIP/UNZIP package as well as to the UNZIP subpackage. But | ||
63 | * currently it supports only UNZIP. | ||
64 | * | ||
65 | * The use of this class is simple - just create instance using | ||
66 | * constructor, then set ZIP archive file name using setFile() function | ||
67 | * (if you did not passed the name to the constructor), then open() and | ||
68 | * then use different functions to work with it! Well, if you are | ||
69 | * paranoid, you may also wish to call close before destructing the | ||
70 | * instance, to check for errors on close. | ||
71 | * | ||
72 | * You may also use getUnzFile() and getZipFile() functions to get the | ||
73 | * ZIP archive handle and use it with ZIP/UNZIP package API directly. | ||
74 | * | ||
75 | * This class supports localized file names inside ZIP archive, but you | ||
76 | * have to set up proper codec with setCodec() function. By default, | ||
77 | * locale codec will be used, which is probably ok for UNIX systems, but | ||
78 | * will almost certainly fail with ZIP archives created in Windows. This | ||
79 | * is because Windows ZIP programs have strange habit of using DOS | ||
80 | * encoding for file names in ZIP archives. For example, ZIP archive | ||
81 | * with cyrillic names created in Windows will have file names in \c | ||
82 | * IBM866 encoding instead of \c WINDOWS-1251. I think that calling one | ||
83 | * function is not much trouble, but for true platform independency it | ||
84 | * would be nice to have some mechanism for file name encoding auto | ||
85 | * detection using locale information. Does anyone know a good way to do | ||
86 | * it? | ||
87 | **/ | ||
88 | class QuaZip { | ||
89 | public: | ||
90 | /// Useful constants. | ||
91 | enum Constants { | ||
92 | MAX_FILE_NAME_LENGTH=256 /**< Maximum file name length. Taken from | ||
93 | \c UNZ_MAXFILENAMEINZIP constant in | ||
94 | unzip.c. */ | ||
95 | }; | ||
96 | /// Open mode of the ZIP file. | ||
97 | enum Mode { | ||
98 | mdNotOpen, ///< ZIP file is not open. This is the initial mode. | ||
99 | mdUnzip, ///< ZIP file is open for reading files inside it. | ||
100 | mdCreate, ///< ZIP file was created with open() call. | ||
101 | mdAppend, /**< ZIP file was opened in append mode. This refers to | ||
102 | * \c APPEND_STATUS_CREATEAFTER mode in ZIP/UNZIP package | ||
103 | * and means that zip is appended to some existing file | ||
104 | * what is useful when that file contains | ||
105 | * self-extractor code. This is obviously \em not what | ||
106 | * you whant to use to add files to the existing ZIP | ||
107 | * archive. | ||
108 | **/ | ||
109 | mdAdd ///< ZIP file was opened for adding files in the archive. | ||
110 | }; | ||
111 | /// Case sensitivity for the file names. | ||
112 | /** This is what you specify when accessing files in the archive. | ||
113 | * Works perfectly fine with any characters thanks to Qt's great | ||
114 | * unicode support. This is different from ZIP/UNZIP API, where | ||
115 | * only US-ASCII characters was supported. | ||
116 | **/ | ||
117 | enum CaseSensitivity { | ||
118 | csDefault=0, ///< Default for platform. Case sensitive for UNIX, not for Windows. | ||
119 | csSensitive=1, ///< Case sensitive. | ||
120 | csInsensitive=2 ///< Case insensitive. | ||
121 | }; | ||
122 | private: | ||
123 | QTextCodec *fileNameCodec, *commentCodec; | ||
124 | QString zipName; | ||
125 | QString comment; | ||
126 | Mode mode; | ||
127 | union { | ||
128 | unzFile unzFile_f; | ||
129 | zipFile zipFile_f; | ||
130 | }; | ||
131 | bool hasCurrentFile_f; | ||
132 | int zipError; | ||
133 | // not (and will not be) implemented | ||
134 | QuaZip(const QuaZip& that); | ||
135 | // not (and will not be) implemented | ||
136 | QuaZip& operator=(const QuaZip& that); | ||
137 | public: | ||
138 | /// Constructs QuaZip object. | ||
139 | /** Call setName() before opening constructed object. */ | ||
140 | QuaZip(); | ||
141 | /// Constructs QuaZip object associated with ZIP file \a zipName. | ||
142 | QuaZip(const QString& zipName); | ||
143 | /// Destroys QuaZip object. | ||
144 | /** Calls close() if necessary. */ | ||
145 | ~QuaZip(); | ||
146 | /// Opens ZIP file. | ||
147 | /** Argument \a ioApi specifies IO function set for ZIP/UNZIP | ||
148 | * package to use. See unzip.h, zip.h and ioapi.h for details. By | ||
149 | * passing NULL (the default) you just tell package to use the | ||
150 | * default API which works just fine on UNIX platforms. I have tried | ||
151 | * it on win32-g++ platform too and it seems it works fine there | ||
152 | * too, so I see no reason to use win32 IO API included in original | ||
153 | * ZIP/UNZIP package. | ||
154 | * | ||
155 | * ZIP archive file name will be converted to 8-bit encoding using | ||
156 | * Qt's QFile::encodeName() function before passing it to the | ||
157 | * ZIP/UNZIP package API. | ||
158 | * | ||
159 | * Returns \c true if successful, \c false otherwise. | ||
160 | * | ||
161 | * Argument \a mode specifies open mode of the ZIP archive. See Mode | ||
162 | * for details. Note that there is zipOpen2() function in the | ||
163 | * ZIP/UNZIP API which accepts \a globalcomment argument, but it | ||
164 | * does not use it anywhere, so this open() function does not have this | ||
165 | * argument. See setComment() if you need to set global comment. | ||
166 | * | ||
167 | * \note ZIP/UNZIP API open calls do not return error code - they | ||
168 | * just return \c NULL indicating an error. But to make things | ||
169 | * easier, quazip.h header defines additional error code \c | ||
170 | * UNZ_ERROROPEN and getZipError() will return it if the open call | ||
171 | * of the ZIP/UNZIP API returns \c NULL. | ||
172 | **/ | ||
173 | bool open(Mode mode, zlib_filefunc_def *ioApi =NULL); | ||
174 | /// Closes ZIP file. | ||
175 | /** Call getZipError() to determine if the close was successful. */ | ||
176 | void close(); | ||
177 | /// Sets the codec used to encode/decode file names inside archive. | ||
178 | /** This is necessary to access files in the ZIP archive created | ||
179 | * under Windows with non-latin characters in file names. For | ||
180 | * example, file names with cyrillic letters will be in \c IBM866 | ||
181 | * encoding. | ||
182 | **/ | ||
183 | void setFileNameCodec(QTextCodec *fileNameCodec) | ||
184 | {this->fileNameCodec=fileNameCodec;} | ||
185 | /// Sets the codec used to encode/decode file names inside archive. | ||
186 | /** \overload | ||
187 | * Equivalent to calling setFileNameCodec(QTextCodec::codecForName(codecName)); | ||
188 | **/ | ||
189 | void setFileNameCodec(const char *fileNameCodecName) | ||
190 | {fileNameCodec=QTextCodec::codecForName(fileNameCodecName);} | ||
191 | /// Returns the codec used to encode/decode comments inside archive. | ||
192 | QTextCodec* getFileNameCodec()const {return fileNameCodec;} | ||
193 | /// Sets the codec used to encode/decode comments inside archive. | ||
194 | /** This codec defaults to locale codec, which is probably ok. | ||
195 | **/ | ||
196 | void setCommentCodec(QTextCodec *commentCodec) | ||
197 | {this->commentCodec=commentCodec;} | ||
198 | /// Sets the codec used to encode/decode comments inside archive. | ||
199 | /** \overload | ||
200 | * Equivalent to calling setCommentCodec(QTextCodec::codecForName(codecName)); | ||
201 | **/ | ||
202 | void setCommentCodec(const char *commentCodecName) | ||
203 | {commentCodec=QTextCodec::codecForName(commentCodecName);} | ||
204 | /// Returns the codec used to encode/decode comments inside archive. | ||
205 | QTextCodec* getCommentCodec()const {return commentCodec;} | ||
206 | /// Returns the name of the ZIP file. | ||
207 | /** Returns null string if no ZIP file name has been set. | ||
208 | * \sa setZipName() | ||
209 | **/ | ||
210 | QString getZipName()const {return zipName;} | ||
211 | /// Sets the name of the ZIP file. | ||
212 | /** Does nothing if the ZIP file is open. | ||
213 | * | ||
214 | * Does not reset error code returned by getZipError(). | ||
215 | **/ | ||
216 | void setZipName(const QString& zipName); | ||
217 | /// Returns the mode in which ZIP file was opened. | ||
218 | Mode getMode()const {return mode;} | ||
219 | /// Returns \c true if ZIP file is open, \c false otherwise. | ||
220 | bool isOpen()const {return mode!=mdNotOpen;} | ||
221 | /// Returns the error code of the last operation. | ||
222 | /** Returns \c UNZ_OK if the last operation was successful. | ||
223 | * | ||
224 | * Error code resets to \c UNZ_OK every time you call any function | ||
225 | * that accesses something inside ZIP archive, even if it is \c | ||
226 | * const (like getEntriesCount()). open() and close() calls reset | ||
227 | * error code too. See documentation for the specific functions for | ||
228 | * details on error detection. | ||
229 | **/ | ||
230 | int getZipError()const {return zipError;} | ||
231 | /// Returns number of the entries in the ZIP central directory. | ||
232 | /** Returns negative error code in the case of error. The same error | ||
233 | * code will be returned by subsequent getZipError() call. | ||
234 | **/ | ||
235 | int getEntriesCount()const; | ||
236 | /// Returns global comment in the ZIP file. | ||
237 | QString getComment()const; | ||
238 | /// Sets global comment in the ZIP file. | ||
239 | /** Comment will be written to the archive on close operation. | ||
240 | * | ||
241 | * \sa open() | ||
242 | **/ | ||
243 | void setComment(const QString& comment) {this->comment=comment;} | ||
244 | /// Sets the current file to the first file in the archive. | ||
245 | /** Returns \c true on success, \c false otherwise. Call | ||
246 | * getZipError() to get the error code. | ||
247 | **/ | ||
248 | bool goToFirstFile(); | ||
249 | /// Sets the current file to the next file in the archive. | ||
250 | /** Returns \c true on success, \c false otherwise. Call | ||
251 | * getZipError() to determine if there was an error. | ||
252 | * | ||
253 | * Should be used only in QuaZip::mdUnzip mode. | ||
254 | * | ||
255 | * \note If the end of file was reached, getZipError() will return | ||
256 | * \c UNZ_OK instead of \c UNZ_END_OF_LIST_OF_FILE. This is to make | ||
257 | * things like this easier: | ||
258 | * \code | ||
259 | * for(bool more=zip.goToFirstFile(); more; more=zip.goToNextFile()) { | ||
260 | * // do something | ||
261 | * } | ||
262 | * if(zip.getZipError()==UNZ_OK) { | ||
263 | * // ok, there was no error | ||
264 | * } | ||
265 | * \endcode | ||
266 | **/ | ||
267 | bool goToNextFile(); | ||
268 | /// Sets current file by its name. | ||
269 | /** Returns \c true if successful, \c false otherwise. Argument \a | ||
270 | * cs specifies case sensitivity of the file name. Call | ||
271 | * getZipError() in the case of a failure to get error code. | ||
272 | * | ||
273 | * This is not a wrapper to unzLocateFile() function. That is | ||
274 | * because I had to implement locale-specific case-insensitive | ||
275 | * comparison. | ||
276 | * | ||
277 | * Here are the differences from the original implementation: | ||
278 | * | ||
279 | * - If the file was not found, error code is \c UNZ_OK, not \c | ||
280 | * UNZ_END_OF_LIST_OF_FILE (see also goToNextFile()). | ||
281 | * - If this function fails, it unsets the current file rather than | ||
282 | * resetting it back to what it was before the call. | ||
283 | * | ||
284 | * If \a fileName is null string then this function unsets the | ||
285 | * current file and return \c true. Note that you should close the | ||
286 | * file first if it is open! See | ||
287 | * QuaZipFile::QuaZipFile(QuaZip*,QObject*) for the details. | ||
288 | * | ||
289 | * Should be used only in QuaZip::mdUnzip mode. | ||
290 | * | ||
291 | * \sa setFileNameCodec(), CaseSensitivity | ||
292 | **/ | ||
293 | bool setCurrentFile(const QString& fileName, CaseSensitivity cs =csDefault); | ||
294 | /// Returns \c true if the current file has been set. | ||
295 | bool hasCurrentFile()const {return hasCurrentFile_f;} | ||
296 | /// Retrieves information about the current file. | ||
297 | /** Fills the structure pointed by \a info. Returns \c true on | ||
298 | * success, \c false otherwise. In the latter case structure pointed | ||
299 | * by \a info remains untouched. If there was an error, | ||
300 | * getZipError() returns error code. | ||
301 | * | ||
302 | * Should be used only in QuaZip::mdUnzip mode. | ||
303 | * | ||
304 | * Does nothing and returns \c false in any of the following cases. | ||
305 | * - ZIP is not open; | ||
306 | * - ZIP does not have current file; | ||
307 | * - \a info is \c NULL; | ||
308 | * | ||
309 | * In all these cases getZipError() returns \c UNZ_OK since there | ||
310 | * is no ZIP/UNZIP API call. | ||
311 | **/ | ||
312 | bool getCurrentFileInfo(QuaZipFileInfo* info)const; | ||
313 | /// Returns the current file name. | ||
314 | /** Equivalent to calling getCurrentFileInfo() and then getting \c | ||
315 | * name field of the QuaZipFileInfo structure, but faster and more | ||
316 | * convenient. | ||
317 | * | ||
318 | * Should be used only in QuaZip::mdUnzip mode. | ||
319 | **/ | ||
320 | QString getCurrentFileName()const; | ||
321 | /// Returns \c unzFile handle. | ||
322 | /** You can use this handle to directly call UNZIP part of the | ||
323 | * ZIP/UNZIP package functions (see unzip.h). | ||
324 | * | ||
325 | * \warning When using the handle returned by this function, please | ||
326 | * keep in mind that QuaZip class is unable to detect any changes | ||
327 | * you make in the ZIP file state (e. g. changing current file, or | ||
328 | * closing the handle). So please do not do anything with this | ||
329 | * handle that is possible to do with the functions of this class. | ||
330 | * Or at least return the handle in the original state before | ||
331 | * calling some another function of this class (including implicit | ||
332 | * destructor calls and calls from the QuaZipFile objects that refer | ||
333 | * to this QuaZip instance!). So if you have changed the current | ||
334 | * file in the ZIP archive - then change it back or you may | ||
335 | * experience some strange behavior or even crashes. | ||
336 | **/ | ||
337 | unzFile getUnzFile() {return unzFile_f;} | ||
338 | /// Returns \c zipFile handle. | ||
339 | /** You can use this handle to directly call ZIP part of the | ||
340 | * ZIP/UNZIP package functions (see zip.h). Warnings about the | ||
341 | * getUnzFile() function also apply to this function. | ||
342 | **/ | ||
343 | zipFile getZipFile() {return zipFile_f;} | ||
344 | }; | ||
345 | |||
346 | #endif | ||
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 @@ | |||
1 | /* | ||
2 | -- A kind of "standard" GPL license statement -- | ||
3 | QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package | ||
4 | Copyright (C) 2005-2007 Sergey A. Tachenov | ||
5 | |||
6 | This program is free software; you can redistribute it and/or modify it | ||
7 | under the terms of the GNU General Public License as published by the | ||
8 | Free Software Foundation; either version 2 of the License, or (at your | ||
9 | option) any later version. | ||
10 | |||
11 | This program is distributed in the hope that it will be useful, but | ||
12 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General | ||
14 | Public License for more details. | ||
15 | |||
16 | You should have received a copy of the GNU General Public License along | ||
17 | with this program; if not, write to the Free Software Foundation, Inc., | ||
18 | 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
19 | |||
20 | -- A kind of "standard" GPL license statement ends here -- | ||
21 | |||
22 | See COPYING file for GPL. | ||
23 | |||
24 | You are also permitted to use QuaZIP under the terms of LGPL (see | ||
25 | COPYING.LGPL). You are free to choose either license, but please note | ||
26 | that QuaZIP makes use of Qt, which is not licensed under LGPL. So if | ||
27 | you are using Open Source edition of Qt, you therefore MUST use GPL for | ||
28 | your code based on QuaZIP, since it would be also based on Qt in this | ||
29 | case. If you are Qt commercial license owner, then you are free to use | ||
30 | QuaZIP as long as you respect either GPL or LGPL for QuaZIP code. | ||
31 | **/ | ||
32 | |||
33 | #include "quazipfile.h" | ||
34 | |||
35 | using namespace std; | ||
36 | |||
37 | QuaZipFile::QuaZipFile(): | ||
38 | zip(NULL), internal(true), zipError(UNZ_OK) | ||
39 | { | ||
40 | } | ||
41 | |||
42 | QuaZipFile::QuaZipFile(QObject *parent): | ||
43 | QIODevice(parent), zip(NULL), internal(true), zipError(UNZ_OK) | ||
44 | { | ||
45 | } | ||
46 | |||
47 | QuaZipFile::QuaZipFile(const QString& zipName, QObject *parent): | ||
48 | QIODevice(parent), internal(true), zipError(UNZ_OK) | ||
49 | { | ||
50 | zip=new QuaZip(zipName); | ||
51 | Q_CHECK_PTR(zip); | ||
52 | } | ||
53 | |||
54 | QuaZipFile::QuaZipFile(const QString& zipName, const QString& fileName, | ||
55 | QuaZip::CaseSensitivity cs, QObject *parent): | ||
56 | QIODevice(parent), internal(true), zipError(UNZ_OK) | ||
57 | { | ||
58 | zip=new QuaZip(zipName); | ||
59 | Q_CHECK_PTR(zip); | ||
60 | this->fileName=fileName; | ||
61 | this->caseSensitivity=cs; | ||
62 | } | ||
63 | |||
64 | QuaZipFile::QuaZipFile(QuaZip *zip, QObject *parent): | ||
65 | QIODevice(parent), | ||
66 | zip(zip), internal(false), | ||
67 | zipError(UNZ_OK) | ||
68 | { | ||
69 | } | ||
70 | |||
71 | QuaZipFile::~QuaZipFile() | ||
72 | { | ||
73 | if(isOpen()) close(); | ||
74 | if(internal) delete zip; | ||
75 | } | ||
76 | |||
77 | QString QuaZipFile::getZipName()const | ||
78 | { | ||
79 | return zip==NULL?QString():zip->getZipName(); | ||
80 | } | ||
81 | |||
82 | QString QuaZipFile::getActualFileName()const | ||
83 | { | ||
84 | setZipError(UNZ_OK); | ||
85 | if(zip==NULL||(openMode()&WriteOnly)) return QString(); | ||
86 | QString name=zip->getCurrentFileName(); | ||
87 | if(name.isNull()) | ||
88 | setZipError(zip->getZipError()); | ||
89 | return name; | ||
90 | } | ||
91 | |||
92 | void QuaZipFile::setZipName(const QString& zipName) | ||
93 | { | ||
94 | if(isOpen()) { | ||
95 | qWarning("QuaZipFile::setZipName(): file is already open - can not set ZIP name"); | ||
96 | return; | ||
97 | } | ||
98 | if(zip!=NULL&&internal) delete zip; | ||
99 | zip=new QuaZip(zipName); | ||
100 | Q_CHECK_PTR(zip); | ||
101 | internal=true; | ||
102 | } | ||
103 | |||
104 | void QuaZipFile::setZip(QuaZip *zip) | ||
105 | { | ||
106 | if(isOpen()) { | ||
107 | qWarning("QuaZipFile::setZip(): file is already open - can not set ZIP"); | ||
108 | return; | ||
109 | } | ||
110 | if(this->zip!=NULL&&internal) delete this->zip; | ||
111 | this->zip=zip; | ||
112 | this->fileName=QString(); | ||
113 | internal=false; | ||
114 | } | ||
115 | |||
116 | void QuaZipFile::setFileName(const QString& fileName, QuaZip::CaseSensitivity cs) | ||
117 | { | ||
118 | if(zip==NULL) { | ||
119 | qWarning("QuaZipFile::setFileName(): call setZipName() first"); | ||
120 | return; | ||
121 | } | ||
122 | if(!internal) { | ||
123 | qWarning("QuaZipFile::setFileName(): should not be used when not using internal QuaZip"); | ||
124 | return; | ||
125 | } | ||
126 | if(isOpen()) { | ||
127 | qWarning("QuaZipFile::setFileName(): can not set file name for already opened file"); | ||
128 | return; | ||
129 | } | ||
130 | this->fileName=fileName; | ||
131 | this->caseSensitivity=cs; | ||
132 | } | ||
133 | |||
134 | void QuaZipFile::setZipError(int zipError)const | ||
135 | { | ||
136 | QuaZipFile *fakeThis=(QuaZipFile*)this; // non-const | ||
137 | fakeThis->zipError=zipError; | ||
138 | if(zipError==UNZ_OK) | ||
139 | fakeThis->setErrorString(QString()); | ||
140 | else | ||
141 | fakeThis->setErrorString(tr("ZIP/UNZIP API error %1").arg(zipError)); | ||
142 | } | ||
143 | |||
144 | bool QuaZipFile::open(OpenMode mode) | ||
145 | { | ||
146 | return open(mode, NULL); | ||
147 | } | ||
148 | |||
149 | bool QuaZipFile::open(OpenMode mode, int *method, int *level, bool raw, const char *password) | ||
150 | { | ||
151 | resetZipError(); | ||
152 | if(isOpen()) { | ||
153 | qWarning("QuaZipFile::open(): already opened"); | ||
154 | return false; | ||
155 | } | ||
156 | if(mode&Unbuffered) { | ||
157 | qWarning("QuaZipFile::open(): Unbuffered mode is not supported"); | ||
158 | return false; | ||
159 | } | ||
160 | if((mode&ReadOnly)&&!(mode&WriteOnly)) { | ||
161 | if(internal) { | ||
162 | if(!zip->open(QuaZip::mdUnzip)) { | ||
163 | setZipError(zip->getZipError()); | ||
164 | return false; | ||
165 | } | ||
166 | if(!zip->setCurrentFile(fileName, caseSensitivity)) { | ||
167 | setZipError(zip->getZipError()); | ||
168 | zip->close(); | ||
169 | return false; | ||
170 | } | ||
171 | } else { | ||
172 | if(zip==NULL) { | ||
173 | qWarning("QuaZipFile::open(): zip is NULL"); | ||
174 | return false; | ||
175 | } | ||
176 | if(zip->getMode()!=QuaZip::mdUnzip) { | ||
177 | qWarning("QuaZipFile::open(): file open mode %d incompatible with ZIP open mode %d", | ||
178 | (int)mode, (int)zip->getMode()); | ||
179 | return false; | ||
180 | } | ||
181 | if(!zip->hasCurrentFile()) { | ||
182 | qWarning("QuaZipFile::open(): zip does not have current file"); | ||
183 | return false; | ||
184 | } | ||
185 | } | ||
186 | setZipError(unzOpenCurrentFile3(zip->getUnzFile(), method, level, (int)raw, password)); | ||
187 | if(zipError==UNZ_OK) { | ||
188 | setOpenMode(mode); | ||
189 | this->raw=raw; | ||
190 | return true; | ||
191 | } else | ||
192 | return false; | ||
193 | } | ||
194 | qWarning("QuaZipFile::open(): open mode %d not supported by this function", (int)mode); | ||
195 | return false; | ||
196 | } | ||
197 | |||
198 | bool QuaZipFile::open(OpenMode mode, const QuaZipNewInfo& info, | ||
199 | const char *password, quint32 crc, | ||
200 | int method, int level, bool raw, | ||
201 | int windowBits, int memLevel, int strategy) | ||
202 | { | ||
203 | zip_fileinfo info_z; | ||
204 | resetZipError(); | ||
205 | if(isOpen()) { | ||
206 | qWarning("QuaZipFile::open(): already opened"); | ||
207 | return false; | ||
208 | } | ||
209 | if((mode&WriteOnly)&&!(mode&ReadOnly)) { | ||
210 | if(internal) { | ||
211 | qWarning("QuaZipFile::open(): write mode is incompatible with internal QuaZip approach"); | ||
212 | return false; | ||
213 | } | ||
214 | if(zip==NULL) { | ||
215 | qWarning("QuaZipFile::open(): zip is NULL"); | ||
216 | return false; | ||
217 | } | ||
218 | if(zip->getMode()!=QuaZip::mdCreate&&zip->getMode()!=QuaZip::mdAppend&&zip->getMode()!=QuaZip::mdAdd) { | ||
219 | qWarning("QuaZipFile::open(): file open mode %d incompatible with ZIP open mode %d", | ||
220 | (int)mode, (int)zip->getMode()); | ||
221 | return false; | ||
222 | } | ||
223 | info_z.tmz_date.tm_year=info.dateTime.date().year(); | ||
224 | info_z.tmz_date.tm_mon=info.dateTime.date().month() - 1; | ||
225 | info_z.tmz_date.tm_mday=info.dateTime.date().day(); | ||
226 | info_z.tmz_date.tm_hour=info.dateTime.time().hour(); | ||
227 | info_z.tmz_date.tm_min=info.dateTime.time().minute(); | ||
228 | info_z.tmz_date.tm_sec=info.dateTime.time().second(); | ||
229 | info_z.dosDate = 0; | ||
230 | info_z.internal_fa=(uLong)info.internalAttr; | ||
231 | info_z.external_fa=(uLong)info.externalAttr; | ||
232 | setZipError(zipOpenNewFileInZip3(zip->getZipFile(), | ||
233 | zip->getFileNameCodec()->fromUnicode(info.name).constData(), &info_z, | ||
234 | info.extraLocal.constData(), info.extraLocal.length(), | ||
235 | info.extraGlobal.constData(), info.extraGlobal.length(), | ||
236 | zip->getCommentCodec()->fromUnicode(info.comment).constData(), | ||
237 | method, level, (int)raw, | ||
238 | windowBits, memLevel, strategy, | ||
239 | password, (uLong)crc)); | ||
240 | if(zipError==UNZ_OK) { | ||
241 | writePos=0; | ||
242 | setOpenMode(mode); | ||
243 | this->raw=raw; | ||
244 | if(raw) { | ||
245 | this->crc=crc; | ||
246 | this->uncompressedSize=info.uncompressedSize; | ||
247 | } | ||
248 | return true; | ||
249 | } else | ||
250 | return false; | ||
251 | } | ||
252 | qWarning("QuaZipFile::open(): open mode %d not supported by this function", (int)mode); | ||
253 | return false; | ||
254 | } | ||
255 | |||
256 | bool QuaZipFile::isSequential()const | ||
257 | { | ||
258 | return true; | ||
259 | } | ||
260 | |||
261 | qint64 QuaZipFile::pos()const | ||
262 | { | ||
263 | if(zip==NULL) { | ||
264 | qWarning("QuaZipFile::pos(): call setZipName() or setZip() first"); | ||
265 | return -1; | ||
266 | } | ||
267 | if(!isOpen()) { | ||
268 | qWarning("QuaZipFile::pos(): file is not open"); | ||
269 | return -1; | ||
270 | } | ||
271 | if(openMode()&ReadOnly) | ||
272 | return unztell(zip->getUnzFile()); | ||
273 | else | ||
274 | return writePos; | ||
275 | } | ||
276 | |||
277 | bool QuaZipFile::atEnd()const | ||
278 | { | ||
279 | if(zip==NULL) { | ||
280 | qWarning("QuaZipFile::atEnd(): call setZipName() or setZip() first"); | ||
281 | return false; | ||
282 | } | ||
283 | if(!isOpen()) { | ||
284 | qWarning("QuaZipFile::atEnd(): file is not open"); | ||
285 | return false; | ||
286 | } | ||
287 | if(openMode()&ReadOnly) | ||
288 | return unzeof(zip->getUnzFile())==1; | ||
289 | else | ||
290 | return true; | ||
291 | } | ||
292 | |||
293 | qint64 QuaZipFile::size()const | ||
294 | { | ||
295 | if(!isOpen()) { | ||
296 | qWarning("QuaZipFile::atEnd(): file is not open"); | ||
297 | return -1; | ||
298 | } | ||
299 | if(openMode()&ReadOnly) | ||
300 | return raw?csize():usize(); | ||
301 | else | ||
302 | return writePos; | ||
303 | } | ||
304 | |||
305 | qint64 QuaZipFile::csize()const | ||
306 | { | ||
307 | unz_file_info info_z; | ||
308 | setZipError(UNZ_OK); | ||
309 | if(zip==NULL||zip->getMode()!=QuaZip::mdUnzip) return -1; | ||
310 | setZipError(unzGetCurrentFileInfo(zip->getUnzFile(), &info_z, NULL, 0, NULL, 0, NULL, 0)); | ||
311 | if(zipError!=UNZ_OK) | ||
312 | return -1; | ||
313 | return info_z.compressed_size; | ||
314 | } | ||
315 | |||
316 | qint64 QuaZipFile::usize()const | ||
317 | { | ||
318 | unz_file_info info_z; | ||
319 | setZipError(UNZ_OK); | ||
320 | if(zip==NULL||zip->getMode()!=QuaZip::mdUnzip) return -1; | ||
321 | setZipError(unzGetCurrentFileInfo(zip->getUnzFile(), &info_z, NULL, 0, NULL, 0, NULL, 0)); | ||
322 | if(zipError!=UNZ_OK) | ||
323 | return -1; | ||
324 | return info_z.uncompressed_size; | ||
325 | } | ||
326 | |||
327 | bool QuaZipFile::getFileInfo(QuaZipFileInfo *info) | ||
328 | { | ||
329 | if(zip==NULL||zip->getMode()!=QuaZip::mdUnzip) return false; | ||
330 | zip->getCurrentFileInfo(info); | ||
331 | setZipError(zip->getZipError()); | ||
332 | return zipError==UNZ_OK; | ||
333 | } | ||
334 | |||
335 | void QuaZipFile::close() | ||
336 | { | ||
337 | resetZipError(); | ||
338 | if(zip==NULL||!zip->isOpen()) return; | ||
339 | if(!isOpen()) { | ||
340 | qWarning("QuaZipFile::close(): file isn't open"); | ||
341 | return; | ||
342 | } | ||
343 | if(openMode()&ReadOnly) | ||
344 | setZipError(unzCloseCurrentFile(zip->getUnzFile())); | ||
345 | else if(openMode()&WriteOnly) | ||
346 | if(isRaw()) setZipError(zipCloseFileInZipRaw(zip->getZipFile(), uncompressedSize, crc)); | ||
347 | else setZipError(zipCloseFileInZip(zip->getZipFile())); | ||
348 | else { | ||
349 | qWarning("Wrong open mode: %d", (int)openMode()); | ||
350 | return; | ||
351 | } | ||
352 | if(zipError==UNZ_OK) setOpenMode(QIODevice::NotOpen); | ||
353 | else return; | ||
354 | if(internal) { | ||
355 | zip->close(); | ||
356 | setZipError(zip->getZipError()); | ||
357 | } | ||
358 | } | ||
359 | |||
360 | qint64 QuaZipFile::readData(char *data, qint64 maxSize) | ||
361 | { | ||
362 | setZipError(UNZ_OK); | ||
363 | qint64 bytesRead=unzReadCurrentFile(zip->getUnzFile(), data, (unsigned)maxSize); | ||
364 | if(bytesRead<0) setZipError((int)bytesRead); | ||
365 | return bytesRead; | ||
366 | } | ||
367 | |||
368 | qint64 QuaZipFile::writeData(const char* data, qint64 maxSize) | ||
369 | { | ||
370 | setZipError(ZIP_OK); | ||
371 | setZipError(zipWriteInFileInZip(zip->getZipFile(), data, (uint)maxSize)); | ||
372 | if(zipError!=ZIP_OK) return -1; | ||
373 | else { | ||
374 | writePos+=maxSize; | ||
375 | return maxSize; | ||
376 | } | ||
377 | } | ||
diff --git a/utils/themeeditor/quazip/quazipfile.h b/utils/themeeditor/quazip/quazipfile.h new file mode 100644 index 0000000000..09af5bceca --- /dev/null +++ b/utils/themeeditor/quazip/quazipfile.h | |||
@@ -0,0 +1,442 @@ | |||
1 | #ifndef QUA_ZIPFILE_H | ||
2 | #define QUA_ZIPFILE_H | ||
3 | |||
4 | /* | ||
5 | -- A kind of "standard" GPL license statement -- | ||
6 | QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package | ||
7 | Copyright (C) 2005-2008 Sergey A. Tachenov | ||
8 | |||
9 | This program is free software; you can redistribute it and/or modify it | ||
10 | under the terms of the GNU General Public License as published by the | ||
11 | Free Software Foundation; either version 2 of the License, or (at your | ||
12 | option) any later version. | ||
13 | |||
14 | This program is distributed in the hope that it will be useful, but | ||
15 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General | ||
17 | Public License for more details. | ||
18 | |||
19 | You should have received a copy of the GNU General Public License along | ||
20 | with this program; if not, write to the Free Software Foundation, Inc., | ||
21 | 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
22 | |||
23 | -- A kind of "standard" GPL license statement ends here -- | ||
24 | |||
25 | See COPYING file for GPL. | ||
26 | |||
27 | You are also permitted to use QuaZIP under the terms of LGPL (see | ||
28 | COPYING.LGPL). You are free to choose either license, but please note | ||
29 | that QuaZIP makes use of Qt, which is not licensed under LGPL. So if | ||
30 | you are using Open Source edition of Qt, you therefore MUST use GPL for | ||
31 | your code based on QuaZIP, since it would be also based on Qt in this | ||
32 | case. If you are Qt commercial license owner, then you are free to use | ||
33 | QuaZIP as long as you respect either GPL or LGPL for QuaZIP code. | ||
34 | **/ | ||
35 | |||
36 | #include <QIODevice> | ||
37 | |||
38 | #include "quazip.h" | ||
39 | #include "quazipnewinfo.h" | ||
40 | |||
41 | /// A file inside ZIP archive. | ||
42 | /** \class QuaZipFile quazipfile.h <quazip/quazipfile.h> | ||
43 | * This is the most interesting class. Not only it provides C++ | ||
44 | * interface to the ZIP/UNZIP package, but also integrates it with Qt by | ||
45 | * subclassing QIODevice. This makes possible to access files inside ZIP | ||
46 | * archive using QTextStream or QDataStream, for example. Actually, this | ||
47 | * is the main purpose of the whole QuaZIP library. | ||
48 | * | ||
49 | * You can either use existing QuaZip instance to create instance of | ||
50 | * this class or pass ZIP archive file name to this class, in which case | ||
51 | * it will create internal QuaZip object. See constructors' descriptions | ||
52 | * for details. Writing is only possible with the existing instance. | ||
53 | * | ||
54 | * \section quazipfile-sequential Sequential or random-access? | ||
55 | * | ||
56 | * At the first thought, QuaZipFile has fixed size, the start and the | ||
57 | * end and should be therefore considered random-access device. But | ||
58 | * there is one major obstacle to making it random-access: ZIP/UNZIP API | ||
59 | * does not support seek() operation and the only way to implement it is | ||
60 | * through reopening the file and re-reading to the required position, | ||
61 | * but this is prohibitely slow. | ||
62 | * | ||
63 | * Therefore, QuaZipFile is considered to be a sequential device. This | ||
64 | * has advantage of availability of the ungetChar() operation (QIODevice | ||
65 | * does not implement it properly for non-sequential devices unless they | ||
66 | * support seek()). Disadvantage is a somewhat strange behaviour of the | ||
67 | * size() and pos() functions. This should be kept in mind while using | ||
68 | * this class. | ||
69 | * | ||
70 | **/ | ||
71 | class QuaZipFile: public QIODevice { | ||
72 | Q_OBJECT | ||
73 | private: | ||
74 | QuaZip *zip; | ||
75 | QString fileName; | ||
76 | QuaZip::CaseSensitivity caseSensitivity; | ||
77 | bool raw; | ||
78 | qint64 writePos; | ||
79 | // these two are for writing raw files | ||
80 | ulong uncompressedSize; | ||
81 | quint32 crc; | ||
82 | bool internal; | ||
83 | int zipError; | ||
84 | // these are not supported nor implemented | ||
85 | QuaZipFile(const QuaZipFile& that); | ||
86 | QuaZipFile& operator=(const QuaZipFile& that); | ||
87 | void resetZipError()const {setZipError(UNZ_OK);} | ||
88 | // const, but sets zipError! | ||
89 | void setZipError(int zipError)const; | ||
90 | protected: | ||
91 | /// Implementation of the QIODevice::readData(). | ||
92 | qint64 readData(char *data, qint64 maxSize); | ||
93 | /// Implementation of the QIODevice::writeData(). | ||
94 | qint64 writeData(const char *data, qint64 maxSize); | ||
95 | public: | ||
96 | /// Constructs a QuaZipFile instance. | ||
97 | /** You should use setZipName() and setFileName() or setZip() before | ||
98 | * trying to call open() on the constructed object. | ||
99 | **/ | ||
100 | QuaZipFile(); | ||
101 | /// Constructs a QuaZipFile instance. | ||
102 | /** \a parent argument specifies this object's parent object. | ||
103 | * | ||
104 | * You should use setZipName() and setFileName() or setZip() before | ||
105 | * trying to call open() on the constructed object. | ||
106 | **/ | ||
107 | QuaZipFile(QObject *parent); | ||
108 | /// Constructs a QuaZipFile instance. | ||
109 | /** \a parent argument specifies this object's parent object and \a | ||
110 | * zipName specifies ZIP archive file name. | ||
111 | * | ||
112 | * You should use setFileName() before trying to call open() on the | ||
113 | * constructed object. | ||
114 | * | ||
115 | * QuaZipFile constructed by this constructor can be used for read | ||
116 | * only access. Use QuaZipFile(QuaZip*,QObject*) for writing. | ||
117 | **/ | ||
118 | QuaZipFile(const QString& zipName, QObject *parent =NULL); | ||
119 | /// Constructs a QuaZipFile instance. | ||
120 | /** \a parent argument specifies this object's parent object, \a | ||
121 | * zipName specifies ZIP archive file name and \a fileName and \a cs | ||
122 | * specify a name of the file to open inside archive. | ||
123 | * | ||
124 | * QuaZipFile constructed by this constructor can be used for read | ||
125 | * only access. Use QuaZipFile(QuaZip*,QObject*) for writing. | ||
126 | * | ||
127 | * \sa QuaZip::setCurrentFile() | ||
128 | **/ | ||
129 | QuaZipFile(const QString& zipName, const QString& fileName, | ||
130 | QuaZip::CaseSensitivity cs =QuaZip::csDefault, QObject *parent =NULL); | ||
131 | /// Constructs a QuaZipFile instance. | ||
132 | /** \a parent argument specifies this object's parent object. | ||
133 | * | ||
134 | * \a zip is the pointer to the existing QuaZip object. This | ||
135 | * QuaZipFile object then can be used to read current file in the | ||
136 | * \a zip or to write to the file inside it. | ||
137 | * | ||
138 | * \warning Using this constructor for reading current file can be | ||
139 | * tricky. Let's take the following example: | ||
140 | * \code | ||
141 | * QuaZip zip("archive.zip"); | ||
142 | * zip.open(QuaZip::mdUnzip); | ||
143 | * zip.setCurrentFile("file-in-archive"); | ||
144 | * QuaZipFile file(&zip); | ||
145 | * file.open(QIODevice::ReadOnly); | ||
146 | * // ok, now we can read from the file | ||
147 | * file.read(somewhere, some); | ||
148 | * zip.setCurrentFile("another-file-in-archive"); // oops... | ||
149 | * QuaZipFile anotherFile(&zip); | ||
150 | * anotherFile.open(QIODevice::ReadOnly); | ||
151 | * anotherFile.read(somewhere, some); // this is still ok... | ||
152 | * file.read(somewhere, some); // and this is NOT | ||
153 | * \endcode | ||
154 | * So, what exactly happens here? When we change current file in the | ||
155 | * \c zip archive, \c file that references it becomes invalid | ||
156 | * (actually, as far as I understand ZIP/UNZIP sources, it becomes | ||
157 | * closed, but QuaZipFile has no means to detect it). | ||
158 | * | ||
159 | * Summary: do not close \c zip object or change its current file as | ||
160 | * long as QuaZipFile is open. Even better - use another constructors | ||
161 | * which create internal QuaZip instances, one per object, and | ||
162 | * therefore do not cause unnecessary trouble. This constructor may | ||
163 | * be useful, though, if you already have a QuaZip instance and do | ||
164 | * not want to access several files at once. Good example: | ||
165 | * \code | ||
166 | * QuaZip zip("archive.zip"); | ||
167 | * zip.open(QuaZip::mdUnzip); | ||
168 | * // first, we need some information about archive itself | ||
169 | * QByteArray comment=zip.getComment(); | ||
170 | * // and now we are going to access files inside it | ||
171 | * QuaZipFile file(&zip); | ||
172 | * for(bool more=zip.goToFirstFile(); more; more=zip.goToNextFile()) { | ||
173 | * file.open(QIODevice::ReadOnly); | ||
174 | * // do something cool with file here | ||
175 | * file.close(); // do not forget to close! | ||
176 | * } | ||
177 | * zip.close(); | ||
178 | * \endcode | ||
179 | **/ | ||
180 | QuaZipFile(QuaZip *zip, QObject *parent =NULL); | ||
181 | /// Destroys a QuaZipFile instance. | ||
182 | /** Closes file if open, destructs internal QuaZip object (if it | ||
183 | * exists and \em is internal, of course). | ||
184 | **/ | ||
185 | virtual ~QuaZipFile(); | ||
186 | /// Returns the ZIP archive file name. | ||
187 | /** If this object was created by passing QuaZip pointer to the | ||
188 | * constructor, this function will return that QuaZip's file name | ||
189 | * (or null string if that object does not have file name yet). | ||
190 | * | ||
191 | * Otherwise, returns associated ZIP archive file name or null | ||
192 | * string if there are no name set yet. | ||
193 | * | ||
194 | * \sa setZipName() getFileName() | ||
195 | **/ | ||
196 | QString getZipName()const; | ||
197 | /// Returns a pointer to the associated QuaZip object. | ||
198 | /** Returns \c NULL if there is no associated QuaZip or it is | ||
199 | * internal (so you will not mess with it). | ||
200 | **/ | ||
201 | QuaZip* getZip()const; | ||
202 | /// Returns file name. | ||
203 | /** This function returns file name you passed to this object either | ||
204 | * by using | ||
205 | * QuaZipFile(const QString&,const QString&,QuaZip::CaseSensitivity,QObject*) | ||
206 | * or by calling setFileName(). Real name of the file may differ in | ||
207 | * case if you used case-insensitivity. | ||
208 | * | ||
209 | * Returns null string if there is no file name set yet. This is the | ||
210 | * case when this QuaZipFile operates on the existing QuaZip object | ||
211 | * (constructor QuaZipFile(QuaZip*,QObject*) or setZip() was used). | ||
212 | * | ||
213 | * \sa getActualFileName | ||
214 | **/ | ||
215 | QString getFileName()const {return fileName;} | ||
216 | /// Returns case sensitivity of the file name. | ||
217 | /** This function returns case sensitivity argument you passed to | ||
218 | * this object either by using | ||
219 | * QuaZipFile(const QString&,const QString&,QuaZip::CaseSensitivity,QObject*) | ||
220 | * or by calling setFileName(). | ||
221 | * | ||
222 | * Returns unpredictable value if getFileName() returns null string | ||
223 | * (this is the case when you did not used setFileName() or | ||
224 | * constructor above). | ||
225 | * | ||
226 | * \sa getFileName | ||
227 | **/ | ||
228 | QuaZip::CaseSensitivity getCaseSensitivity()const {return caseSensitivity;} | ||
229 | /// Returns the actual file name in the archive. | ||
230 | /** This is \em not a ZIP archive file name, but a name of file inside | ||
231 | * archive. It is not necessary the same name that you have passed | ||
232 | * to the | ||
233 | * QuaZipFile(const QString&,const QString&,QuaZip::CaseSensitivity,QObject*), | ||
234 | * setFileName() or QuaZip::setCurrentFile() - this is the real file | ||
235 | * name inside archive, so it may differ in case if the file name | ||
236 | * search was case-insensitive. | ||
237 | * | ||
238 | * Equivalent to calling getCurrentFileName() on the associated | ||
239 | * QuaZip object. Returns null string if there is no associated | ||
240 | * QuaZip object or if it does not have a current file yet. And this | ||
241 | * is the case if you called setFileName() but did not open the | ||
242 | * file yet. So this is perfectly fine: | ||
243 | * \code | ||
244 | * QuaZipFile file("somezip.zip"); | ||
245 | * file.setFileName("somefile"); | ||
246 | * QString name=file.getName(); // name=="somefile" | ||
247 | * QString actual=file.getActualFileName(); // actual is null string | ||
248 | * file.open(QIODevice::ReadOnly); | ||
249 | * QString actual=file.getActualFileName(); // actual can be "SoMeFiLe" on Windows | ||
250 | * \endcode | ||
251 | * | ||
252 | * \sa getZipName(), getFileName(), QuaZip::CaseSensitivity | ||
253 | **/ | ||
254 | QString getActualFileName()const; | ||
255 | /// Sets the ZIP archive file name. | ||
256 | /** Automatically creates internal QuaZip object and destroys | ||
257 | * previously created internal QuaZip object, if any. | ||
258 | * | ||
259 | * Will do nothing if this file is already open. You must close() it | ||
260 | * first. | ||
261 | **/ | ||
262 | void setZipName(const QString& zipName); | ||
263 | /// Returns \c true if the file was opened in raw mode. | ||
264 | /** If the file is not open, the returned value is undefined. | ||
265 | * | ||
266 | * \sa open(OpenMode,int*,int*,bool,const char*) | ||
267 | **/ | ||
268 | bool isRaw()const {return raw;} | ||
269 | /// Binds to the existing QuaZip instance. | ||
270 | /** This function destroys internal QuaZip object, if any, and makes | ||
271 | * this QuaZipFile to use current file in the \a zip object for any | ||
272 | * further operations. See QuaZipFile(QuaZip*,QObject*) for the | ||
273 | * possible pitfalls. | ||
274 | * | ||
275 | * Will do nothing if the file is currently open. You must close() | ||
276 | * it first. | ||
277 | **/ | ||
278 | void setZip(QuaZip *zip); | ||
279 | /// Sets the file name. | ||
280 | /** Will do nothing if at least one of the following conditions is | ||
281 | * met: | ||
282 | * - ZIP name has not been set yet (getZipName() returns null | ||
283 | * string). | ||
284 | * - This QuaZipFile is associated with external QuaZip. In this | ||
285 | * case you should call that QuaZip's setCurrentFile() function | ||
286 | * instead! | ||
287 | * - File is already open so setting the name is meaningless. | ||
288 | * | ||
289 | * \sa QuaZip::setCurrentFile | ||
290 | **/ | ||
291 | void setFileName(const QString& fileName, QuaZip::CaseSensitivity cs =QuaZip::csDefault); | ||
292 | /// Opens a file for reading. | ||
293 | /** Returns \c true on success, \c false otherwise. | ||
294 | * Call getZipError() to get error code. | ||
295 | * | ||
296 | * \note Since ZIP/UNZIP API provides buffered reading only, | ||
297 | * QuaZipFile does not support unbuffered reading. So do not pass | ||
298 | * QIODevice::Unbuffered flag in \a mode, or open will fail. | ||
299 | **/ | ||
300 | virtual bool open(OpenMode mode); | ||
301 | /// Opens a file for reading. | ||
302 | /** \overload | ||
303 | * Argument \a password specifies a password to decrypt the file. If | ||
304 | * it is NULL then this function behaves just like open(OpenMode). | ||
305 | **/ | ||
306 | bool open(OpenMode mode, const char *password) | ||
307 | {return open(mode, NULL, NULL, false, password);} | ||
308 | /// Opens a file for reading. | ||
309 | /** \overload | ||
310 | * Argument \a password specifies a password to decrypt the file. | ||
311 | * | ||
312 | * An integers pointed by \a method and \a level will receive codes | ||
313 | * of the compression method and level used. See unzip.h. | ||
314 | * | ||
315 | * If raw is \c true then no decompression is performed. | ||
316 | * | ||
317 | * \a method should not be \c NULL. \a level can be \c NULL if you | ||
318 | * don't want to know the compression level. | ||
319 | **/ | ||
320 | bool open(OpenMode mode, int *method, int *level, bool raw, const char *password =NULL); | ||
321 | /// Opens a file for writing. | ||
322 | /** \a info argument specifies information about file. It should at | ||
323 | * least specify a correct file name. Also, it is a good idea to | ||
324 | * specify correct timestamp (by default, current time will be | ||
325 | * used). See QuaZipNewInfo. | ||
326 | * | ||
327 | * Arguments \a password and \a crc provide necessary information | ||
328 | * for crypting. Note that you should specify both of them if you | ||
329 | * need crypting. If you do not, pass \c NULL as password, but you | ||
330 | * still need to specify \a crc if you are going to use raw mode | ||
331 | * (see below). | ||
332 | * | ||
333 | * Arguments \a method and \a level specify compression method and | ||
334 | * level. | ||
335 | * | ||
336 | * If \a raw is \c true, no compression is performed. In this case, | ||
337 | * \a crc and uncompressedSize field of the \a info are required. | ||
338 | * | ||
339 | * Arguments \a windowBits, \a memLevel, \a strategy provide zlib | ||
340 | * algorithms tuning. See deflateInit2() in zlib. | ||
341 | **/ | ||
342 | bool open(OpenMode mode, const QuaZipNewInfo& info, | ||
343 | const char *password =NULL, quint32 crc =0, | ||
344 | int method =Z_DEFLATED, int level =Z_DEFAULT_COMPRESSION, bool raw =false, | ||
345 | int windowBits =-MAX_WBITS, int memLevel =DEF_MEM_LEVEL, int strategy =Z_DEFAULT_STRATEGY); | ||
346 | /// Returns \c true, but \ref quazipfile-sequential "beware"! | ||
347 | virtual bool isSequential()const; | ||
348 | /// Returns current position in the file. | ||
349 | /** Implementation of the QIODevice::pos(). When reading, this | ||
350 | * function is a wrapper to the ZIP/UNZIP unztell(), therefore it is | ||
351 | * unable to keep track of the ungetChar() calls (which is | ||
352 | * non-virtual and therefore is dangerous to reimplement). So if you | ||
353 | * are using ungetChar() feature of the QIODevice, this function | ||
354 | * reports incorrect value until you get back characters which you | ||
355 | * ungot. | ||
356 | * | ||
357 | * When writing, pos() returns number of bytes already written | ||
358 | * (uncompressed unless you use raw mode). | ||
359 | * | ||
360 | * \note Although | ||
361 | * \ref quazipfile-sequential "QuaZipFile is a sequential device" | ||
362 | * and therefore pos() should always return zero, it does not, | ||
363 | * because it would be misguiding. Keep this in mind. | ||
364 | * | ||
365 | * This function returns -1 if the file or archive is not open. | ||
366 | * | ||
367 | * Error code returned by getZipError() is not affected by this | ||
368 | * function call. | ||
369 | **/ | ||
370 | virtual qint64 pos()const; | ||
371 | /// Returns \c true if the end of file was reached. | ||
372 | /** This function returns \c false in the case of error. This means | ||
373 | * that you called this function on either not open file, or a file | ||
374 | * in the not open archive or even on a QuaZipFile instance that | ||
375 | * does not even have QuaZip instance associated. Do not do that | ||
376 | * because there is no means to determine whether \c false is | ||
377 | * returned because of error or because end of file was reached. | ||
378 | * Well, on the other side you may interpret \c false return value | ||
379 | * as "there is no file open to check for end of file and there is | ||
380 | * no end of file therefore". | ||
381 | * | ||
382 | * When writing, this function always returns \c true (because you | ||
383 | * are always writing to the end of file). | ||
384 | * | ||
385 | * Error code returned by getZipError() is not affected by this | ||
386 | * function call. | ||
387 | **/ | ||
388 | virtual bool atEnd()const; | ||
389 | /// Returns file size. | ||
390 | /** This function returns csize() if the file is open for reading in | ||
391 | * raw mode, usize() if it is open for reading in normal mode and | ||
392 | * pos() if it is open for writing. | ||
393 | * | ||
394 | * Returns -1 on error, call getZipError() to get error code. | ||
395 | * | ||
396 | * \note This function returns file size despite that | ||
397 | * \ref quazipfile-sequential "QuaZipFile is considered to be sequential device", | ||
398 | * for which size() should return bytesAvailable() instead. But its | ||
399 | * name would be very misguiding otherwise, so just keep in mind | ||
400 | * this inconsistence. | ||
401 | **/ | ||
402 | virtual qint64 size()const; | ||
403 | /// Returns compressed file size. | ||
404 | /** Equivalent to calling getFileInfo() and then getting | ||
405 | * compressedSize field, but more convenient and faster. | ||
406 | * | ||
407 | * File must be open for reading before calling this function. | ||
408 | * | ||
409 | * Returns -1 on error, call getZipError() to get error code. | ||
410 | **/ | ||
411 | qint64 csize()const; | ||
412 | /// Returns uncompressed file size. | ||
413 | /** Equivalent to calling getFileInfo() and then getting | ||
414 | * uncompressedSize field, but more convenient and faster. See | ||
415 | * getFileInfo() for a warning. | ||
416 | * | ||
417 | * File must be open for reading before calling this function. | ||
418 | * | ||
419 | * Returns -1 on error, call getZipError() to get error code. | ||
420 | **/ | ||
421 | qint64 usize()const; | ||
422 | /// Gets information about current file. | ||
423 | /** This function does the same thing as calling | ||
424 | * QuaZip::getCurrentFileInfo() on the associated QuaZip object, | ||
425 | * but you can not call getCurrentFileInfo() if the associated | ||
426 | * QuaZip is internal (because you do not have access to it), while | ||
427 | * you still can call this function in that case. | ||
428 | * | ||
429 | * File must be open for reading before calling this function. | ||
430 | * | ||
431 | * Returns \c false in the case of an error. | ||
432 | **/ | ||
433 | bool getFileInfo(QuaZipFileInfo *info); | ||
434 | /// Closes the file. | ||
435 | /** Call getZipError() to determine if the close was successful. | ||
436 | **/ | ||
437 | virtual void close(); | ||
438 | /// Returns the error code returned by the last ZIP/UNZIP API call. | ||
439 | int getZipError()const {return zipError;} | ||
440 | }; | ||
441 | |||
442 | #endif | ||
diff --git a/utils/themeeditor/quazip/quazipfileinfo.h b/utils/themeeditor/quazip/quazipfileinfo.h new file mode 100644 index 0000000000..3216d776d5 --- /dev/null +++ b/utils/themeeditor/quazip/quazipfileinfo.h | |||
@@ -0,0 +1,73 @@ | |||
1 | #ifndef QUA_ZIPFILEINFO_H | ||
2 | #define QUA_ZIPFILEINFO_H | ||
3 | |||
4 | /* | ||
5 | -- A kind of "standard" GPL license statement -- | ||
6 | QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package | ||
7 | Copyright (C) 2005-2007 Sergey A. Tachenov | ||
8 | |||
9 | This program is free software; you can redistribute it and/or modify it | ||
10 | under the terms of the GNU General Public License as published by the | ||
11 | Free Software Foundation; either version 2 of the License, or (at your | ||
12 | option) any later version. | ||
13 | |||
14 | This program is distributed in the hope that it will be useful, but | ||
15 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General | ||
17 | Public License for more details. | ||
18 | |||
19 | You should have received a copy of the GNU General Public License along | ||
20 | with this program; if not, write to the Free Software Foundation, Inc., | ||
21 | 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
22 | |||
23 | -- A kind of "standard" GPL license statement ends here -- | ||
24 | |||
25 | See COPYING file for GPL. | ||
26 | |||
27 | You are also permitted to use QuaZIP under the terms of LGPL (see | ||
28 | COPYING.LGPL). You are free to choose either license, but please note | ||
29 | that QuaZIP makes use of Qt, which is not licensed under LGPL. So if | ||
30 | you are using Open Source edition of Qt, you therefore MUST use GPL for | ||
31 | your code based on QuaZIP, since it would be also based on Qt in this | ||
32 | case. If you are Qt commercial license owner, then you are free to use | ||
33 | QuaZIP as long as you respect either GPL or LGPL for QuaZIP code. | ||
34 | **/ | ||
35 | |||
36 | #include <QByteArray> | ||
37 | #include <QDateTime> | ||
38 | |||
39 | /// Information about a file inside archive. | ||
40 | /** Call QuaZip::getCurrentFileInfo() or QuaZipFile::getFileInfo() to | ||
41 | * fill this structure. */ | ||
42 | struct QuaZipFileInfo { | ||
43 | /// File name. | ||
44 | QString name; | ||
45 | /// Version created by. | ||
46 | quint16 versionCreated; | ||
47 | /// Version needed to extract. | ||
48 | quint16 versionNeeded; | ||
49 | /// General purpose flags. | ||
50 | quint16 flags; | ||
51 | /// Compression method. | ||
52 | quint16 method; | ||
53 | /// Last modification date and time. | ||
54 | QDateTime dateTime; | ||
55 | /// CRC. | ||
56 | quint32 crc; | ||
57 | /// Compressed file size. | ||
58 | quint32 compressedSize; | ||
59 | /// Uncompressed file size. | ||
60 | quint32 uncompressedSize; | ||
61 | /// Disk number start. | ||
62 | quint16 diskNumberStart; | ||
63 | /// Internal file attributes. | ||
64 | quint16 internalAttr; | ||
65 | /// External file attributes. | ||
66 | quint32 externalAttr; | ||
67 | /// Comment. | ||
68 | QString comment; | ||
69 | /// Extra field. | ||
70 | QByteArray extra; | ||
71 | }; | ||
72 | |||
73 | #endif | ||
diff --git a/utils/themeeditor/quazip/quazipnewinfo.cpp b/utils/themeeditor/quazip/quazipnewinfo.cpp new file mode 100644 index 0000000000..17571f2fc8 --- /dev/null +++ b/utils/themeeditor/quazip/quazipnewinfo.cpp | |||
@@ -0,0 +1,59 @@ | |||
1 | /* -- A kind of "standard" GPL license statement -- | ||
2 | QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package | ||
3 | Copyright (C) 2005-2007 Sergey A. Tachenov | ||
4 | |||
5 | This program is free software; you can redistribute it and/or modify it | ||
6 | under the terms of the GNU General Public License as published by the | ||
7 | Free Software Foundation; either version 2 of the License, or (at your | ||
8 | option) any later version. | ||
9 | |||
10 | This program is distributed in the hope that it will be useful, but | ||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General | ||
13 | Public License for more details. | ||
14 | |||
15 | You should have received a copy of the GNU General Public License along | ||
16 | with this program; if not, write to the Free Software Foundation, Inc., | ||
17 | 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
18 | |||
19 | -- A kind of "standard" GPL license statement ends here -- | ||
20 | |||
21 | See COPYING file for GPL. | ||
22 | |||
23 | You are also permitted to use QuaZIP under the terms of LGPL (see | ||
24 | COPYING.LGPL). You are free to choose either license, but please note | ||
25 | that QuaZIP makes use of Qt, which is not licensed under LGPL. So if | ||
26 | you are using Open Source edition of Qt, you therefore MUST use GPL for | ||
27 | your code based on QuaZIP, since it would be also based on Qt in this | ||
28 | case. If you are Qt commercial license owner, then you are free to use | ||
29 | QuaZIP as long as you respect either GPL or LGPL for QuaZIP code. | ||
30 | */ | ||
31 | |||
32 | #include <QFileInfo> | ||
33 | |||
34 | #include "quazipnewinfo.h" | ||
35 | |||
36 | |||
37 | QuaZipNewInfo::QuaZipNewInfo(const QString& name): | ||
38 | name(name), dateTime(QDateTime::currentDateTime()), internalAttr(0), externalAttr(0) | ||
39 | { | ||
40 | } | ||
41 | |||
42 | QuaZipNewInfo::QuaZipNewInfo(const QString& name, const QString& file): | ||
43 | name(name), internalAttr(0), externalAttr(0) | ||
44 | { | ||
45 | QFileInfo info(file); | ||
46 | QDateTime lm = info.lastModified(); | ||
47 | if (!info.exists()) | ||
48 | dateTime = QDateTime::currentDateTime(); | ||
49 | else | ||
50 | dateTime = lm; | ||
51 | } | ||
52 | |||
53 | void QuaZipNewInfo::setFileDateTime(const QString& file) | ||
54 | { | ||
55 | QFileInfo info(file); | ||
56 | QDateTime lm = info.lastModified(); | ||
57 | if (info.exists()) | ||
58 | dateTime = lm; | ||
59 | } | ||
diff --git a/utils/themeeditor/quazip/quazipnewinfo.h b/utils/themeeditor/quazip/quazipnewinfo.h new file mode 100644 index 0000000000..93ff1a2fc0 --- /dev/null +++ b/utils/themeeditor/quazip/quazipnewinfo.h | |||
@@ -0,0 +1,109 @@ | |||
1 | #ifndef QUA_ZIPNEWINFO_H | ||
2 | #define QUA_ZIPNEWINFO_H | ||
3 | |||
4 | /* | ||
5 | -- A kind of "standard" GPL license statement -- | ||
6 | QuaZIP - a Qt/C++ wrapper for the ZIP/UNZIP package | ||
7 | Copyright (C) 2005-2007 Sergey A. Tachenov | ||
8 | |||
9 | This program is free software; you can redistribute it and/or modify it | ||
10 | under the terms of the GNU General Public License as published by the | ||
11 | Free Software Foundation; either version 2 of the License, or (at your | ||
12 | option) any later version. | ||
13 | |||
14 | This program is distributed in the hope that it will be useful, but | ||
15 | WITHOUT ANY WARRANTY; without even the implied warranty of | ||
16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General | ||
17 | Public License for more details. | ||
18 | |||
19 | You should have received a copy of the GNU General Public License along | ||
20 | with this program; if not, write to the Free Software Foundation, Inc., | ||
21 | 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
22 | |||
23 | -- A kind of "standard" GPL license statement ends here -- | ||
24 | |||
25 | See COPYING file for GPL. | ||
26 | |||
27 | You are also permitted to use QuaZIP under the terms of LGPL (see | ||
28 | COPYING.LGPL). You are free to choose either license, but please note | ||
29 | that QuaZIP makes use of Qt, which is not licensed under LGPL. So if | ||
30 | you are using Open Source edition of Qt, you therefore MUST use GPL for | ||
31 | your code based on QuaZIP, since it would be also based on Qt in this | ||
32 | case. If you are Qt commercial license owner, then you are free to use | ||
33 | QuaZIP as long as you respect either GPL or LGPL for QuaZIP code. | ||
34 | **/ | ||
35 | |||
36 | #include <QDateTime> | ||
37 | #include <QString> | ||
38 | |||
39 | /// Information about a file to be created. | ||
40 | /** This structure holds information about a file to be created inside | ||
41 | * ZIP archive. At least name should be set to something correct before | ||
42 | * passing this structure to | ||
43 | * QuaZipFile::open(OpenMode,const QuaZipNewInfo&,int,int,bool). | ||
44 | **/ | ||
45 | struct QuaZipNewInfo { | ||
46 | /// File name. | ||
47 | /** This field holds file name inside archive, including path relative | ||
48 | * to archive root. | ||
49 | **/ | ||
50 | QString name; | ||
51 | /// File timestamp. | ||
52 | /** This is the last file modification date and time. Will be stored | ||
53 | * in the archive central directory. It is a good practice to set it | ||
54 | * to the source file timestamp instead of archive creating time. Use | ||
55 | * setFileDateTime() or QuaZipNewInfo(const QString&, const QString&). | ||
56 | **/ | ||
57 | QDateTime dateTime; | ||
58 | /// File internal attributes. | ||
59 | quint16 internalAttr; | ||
60 | /// File external attributes. | ||
61 | quint32 externalAttr; | ||
62 | /// File comment. | ||
63 | /** Will be encoded using QuaZip::getCommentCodec(). | ||
64 | **/ | ||
65 | QString comment; | ||
66 | /// File local extra field. | ||
67 | QByteArray extraLocal; | ||
68 | /// File global extra field. | ||
69 | QByteArray extraGlobal; | ||
70 | /// Uncompressed file size. | ||
71 | /** This is only needed if you are using raw file zipping mode, i. e. | ||
72 | * adding precompressed file in the zip archive. | ||
73 | **/ | ||
74 | ulong uncompressedSize; | ||
75 | /// Constructs QuaZipNewInfo instance. | ||
76 | /** Initializes name with \a name, dateTime with current date and | ||
77 | * time. Attributes are initialized with zeros, comment and extra | ||
78 | * field with null values. | ||
79 | **/ | ||
80 | QuaZipNewInfo(const QString& name); | ||
81 | /// Constructs QuaZipNewInfo instance. | ||
82 | /** Initializes name with \a name and dateTime with timestamp of the | ||
83 | * file named \a file. If the \a file does not exists or its timestamp | ||
84 | * is inaccessible (e. g. you do not have read permission for the | ||
85 | * directory file in), uses current date and time. Attributes are | ||
86 | * initialized with zeros, comment and extra field with null values. | ||
87 | * | ||
88 | * \sa setFileDateTime() | ||
89 | **/ | ||
90 | QuaZipNewInfo(const QString& name, const QString& file); | ||
91 | /// Sets the file timestamp from the existing file. | ||
92 | /** Use this function to set the file timestamp from the existing | ||
93 | * file. Use it like this: | ||
94 | * \code | ||
95 | * QuaZipFile zipFile(&zip); | ||
96 | * QFile file("file-to-add"); | ||
97 | * file.open(QIODevice::ReadOnly); | ||
98 | * QuaZipNewInfo info("file-name-in-archive"); | ||
99 | * info.setFileDateTime("file-to-add"); // take the timestamp from file | ||
100 | * zipFile.open(QIODevice::WriteOnly, info); | ||
101 | * \endcode | ||
102 | * | ||
103 | * This function does not change dateTime if some error occured (e. g. | ||
104 | * file is inaccessible). | ||
105 | **/ | ||
106 | void setFileDateTime(const QString& file); | ||
107 | }; | ||
108 | |||
109 | #endif | ||
diff --git a/utils/themeeditor/quazip/unzip.c b/utils/themeeditor/quazip/unzip.c new file mode 100644 index 0000000000..ace7a08837 --- /dev/null +++ b/utils/themeeditor/quazip/unzip.c | |||
@@ -0,0 +1,1601 @@ | |||
1 | /* unzip.c -- IO for uncompress .zip files using zlib | ||
2 | Version 1.01e, February 12th, 2005 | ||
3 | |||
4 | Copyright (C) 1998-2005 Gilles Vollant | ||
5 | |||
6 | Read unzip.h for more info | ||
7 | */ | ||
8 | |||
9 | /* Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of | ||
10 | compatibility with older software. The following is from the original crypt.c. Code | ||
11 | woven in by Terry Thorsen 1/2003. | ||
12 | */ | ||
13 | /* | ||
14 | Copyright (c) 1990-2000 Info-ZIP. All rights reserved. | ||
15 | |||
16 | See the accompanying file LICENSE, version 2000-Apr-09 or later | ||
17 | (the contents of which are also included in zip.h) for terms of use. | ||
18 | If, for some reason, all these files are missing, the Info-ZIP license | ||
19 | also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html | ||
20 | */ | ||
21 | /* | ||
22 | crypt.c (full version) by Info-ZIP. Last revised: [see crypt.h] | ||
23 | |||
24 | The encryption/decryption parts of this source code (as opposed to the | ||
25 | non-echoing password parts) were originally written in Europe. The | ||
26 | whole source package can be freely distributed, including from the USA. | ||
27 | (Prior to January 2000, re-export from the US was a violation of US law.) | ||
28 | */ | ||
29 | |||
30 | /* | ||
31 | This encryption code is a direct transcription of the algorithm from | ||
32 | Roger Schlafly, described by Phil Katz in the file appnote.txt. This | ||
33 | file (appnote.txt) is distributed with the PKZIP program (even in the | ||
34 | version without encryption capabilities). | ||
35 | */ | ||
36 | |||
37 | |||
38 | #include <stdio.h> | ||
39 | #include <stdlib.h> | ||
40 | #include <string.h> | ||
41 | #include "zlib.h" | ||
42 | #include "unzip.h" | ||
43 | |||
44 | #ifdef STDC | ||
45 | # include <stddef.h> | ||
46 | # include <string.h> | ||
47 | # include <stdlib.h> | ||
48 | #endif | ||
49 | #ifdef NO_ERRNO_H | ||
50 | extern int errno; | ||
51 | #else | ||
52 | # include <errno.h> | ||
53 | #endif | ||
54 | |||
55 | |||
56 | #ifndef local | ||
57 | # define local static | ||
58 | #endif | ||
59 | /* compile with -Dlocal if your debugger can't find static symbols */ | ||
60 | |||
61 | |||
62 | #ifndef CASESENSITIVITYDEFAULT_NO | ||
63 | # if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES) | ||
64 | # define CASESENSITIVITYDEFAULT_NO | ||
65 | # endif | ||
66 | #endif | ||
67 | |||
68 | |||
69 | #ifndef UNZ_BUFSIZE | ||
70 | #define UNZ_BUFSIZE (16384) | ||
71 | #endif | ||
72 | |||
73 | #ifndef UNZ_MAXFILENAMEINZIP | ||
74 | #define UNZ_MAXFILENAMEINZIP (256) | ||
75 | #endif | ||
76 | |||
77 | #ifndef ALLOC | ||
78 | # define ALLOC(size) (malloc(size)) | ||
79 | #endif | ||
80 | #ifndef TRYFREE | ||
81 | # define TRYFREE(p) {if (p) free(p);} | ||
82 | #endif | ||
83 | |||
84 | #define SIZECENTRALDIRITEM (0x2e) | ||
85 | #define SIZEZIPLOCALHEADER (0x1e) | ||
86 | |||
87 | |||
88 | |||
89 | |||
90 | const char unz_copyright[] = | ||
91 | " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll"; | ||
92 | |||
93 | /* unz_file_info_interntal contain internal info about a file in zipfile*/ | ||
94 | typedef struct unz_file_info_internal_s | ||
95 | { | ||
96 | uLong offset_curfile;/* relative offset of local header 4 bytes */ | ||
97 | } unz_file_info_internal; | ||
98 | |||
99 | |||
100 | /* file_in_zip_read_info_s contain internal information about a file in zipfile, | ||
101 | when reading and decompress it */ | ||
102 | typedef struct | ||
103 | { | ||
104 | char *read_buffer; /* internal buffer for compressed data */ | ||
105 | z_stream stream; /* zLib stream structure for inflate */ | ||
106 | |||
107 | uLong pos_in_zipfile; /* position in byte on the zipfile, for fseek*/ | ||
108 | uLong stream_initialised; /* flag set if stream structure is initialised*/ | ||
109 | |||
110 | uLong offset_local_extrafield;/* offset of the local extra field */ | ||
111 | uInt size_local_extrafield;/* size of the local extra field */ | ||
112 | uLong pos_local_extrafield; /* position in the local extra field in read*/ | ||
113 | |||
114 | uLong crc32; /* crc32 of all data uncompressed */ | ||
115 | uLong crc32_wait; /* crc32 we must obtain after decompress all */ | ||
116 | uLong rest_read_compressed; /* number of byte to be decompressed */ | ||
117 | uLong rest_read_uncompressed;/*number of byte to be obtained after decomp*/ | ||
118 | zlib_filefunc_def z_filefunc; | ||
119 | voidpf filestream; /* io structore of the zipfile */ | ||
120 | uLong compression_method; /* compression method (0==store) */ | ||
121 | uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ | ||
122 | int raw; | ||
123 | } file_in_zip_read_info_s; | ||
124 | |||
125 | |||
126 | /* unz_s contain internal information about the zipfile | ||
127 | */ | ||
128 | typedef struct | ||
129 | { | ||
130 | zlib_filefunc_def z_filefunc; | ||
131 | voidpf filestream; /* io structore of the zipfile */ | ||
132 | unz_global_info gi; /* public global information */ | ||
133 | uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ | ||
134 | uLong num_file; /* number of the current file in the zipfile*/ | ||
135 | uLong pos_in_central_dir; /* pos of the current file in the central dir*/ | ||
136 | uLong current_file_ok; /* flag about the usability of the current file*/ | ||
137 | uLong central_pos; /* position of the beginning of the central dir*/ | ||
138 | |||
139 | uLong size_central_dir; /* size of the central directory */ | ||
140 | uLong offset_central_dir; /* offset of start of central directory with | ||
141 | respect to the starting disk number */ | ||
142 | |||
143 | unz_file_info cur_file_info; /* public info about the current file in zip*/ | ||
144 | unz_file_info_internal cur_file_info_internal; /* private info about it*/ | ||
145 | file_in_zip_read_info_s* pfile_in_zip_read; /* structure about the current | ||
146 | file if we are decompressing it */ | ||
147 | int encrypted; | ||
148 | # ifndef NOUNCRYPT | ||
149 | unsigned long keys[3]; /* keys defining the pseudo-random sequence */ | ||
150 | const unsigned long* pcrc_32_tab; | ||
151 | # endif | ||
152 | } unz_s; | ||
153 | |||
154 | |||
155 | #ifndef NOUNCRYPT | ||
156 | #include "crypt.h" | ||
157 | #endif | ||
158 | |||
159 | /* =========================================================================== | ||
160 | Read a byte from a gz_stream; update next_in and avail_in. Return EOF | ||
161 | for end of file. | ||
162 | IN assertion: the stream s has been sucessfully opened for reading. | ||
163 | */ | ||
164 | |||
165 | |||
166 | local int unzlocal_getByte OF(( | ||
167 | const zlib_filefunc_def* pzlib_filefunc_def, | ||
168 | voidpf filestream, | ||
169 | int *pi)); | ||
170 | |||
171 | local int unzlocal_getByte(pzlib_filefunc_def,filestream,pi) | ||
172 | const zlib_filefunc_def* pzlib_filefunc_def; | ||
173 | voidpf filestream; | ||
174 | int *pi; | ||
175 | { | ||
176 | unsigned char c; | ||
177 | int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1); | ||
178 | if (err==1) | ||
179 | { | ||
180 | *pi = (int)c; | ||
181 | return UNZ_OK; | ||
182 | } | ||
183 | else | ||
184 | { | ||
185 | if (ZERROR(*pzlib_filefunc_def,filestream)) | ||
186 | return UNZ_ERRNO; | ||
187 | else | ||
188 | return UNZ_EOF; | ||
189 | } | ||
190 | } | ||
191 | |||
192 | |||
193 | /* =========================================================================== | ||
194 | Reads a long in LSB order from the given gz_stream. Sets | ||
195 | */ | ||
196 | local int unzlocal_getShort OF(( | ||
197 | const zlib_filefunc_def* pzlib_filefunc_def, | ||
198 | voidpf filestream, | ||
199 | uLong *pX)); | ||
200 | |||
201 | local int unzlocal_getShort (pzlib_filefunc_def,filestream,pX) | ||
202 | const zlib_filefunc_def* pzlib_filefunc_def; | ||
203 | voidpf filestream; | ||
204 | uLong *pX; | ||
205 | { | ||
206 | uLong x ; | ||
207 | int i; | ||
208 | int err; | ||
209 | |||
210 | err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); | ||
211 | x = (uLong)i; | ||
212 | |||
213 | if (err==UNZ_OK) | ||
214 | err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); | ||
215 | x += ((uLong)i)<<8; | ||
216 | |||
217 | if (err==UNZ_OK) | ||
218 | *pX = x; | ||
219 | else | ||
220 | *pX = 0; | ||
221 | return err; | ||
222 | } | ||
223 | |||
224 | local int unzlocal_getLong OF(( | ||
225 | const zlib_filefunc_def* pzlib_filefunc_def, | ||
226 | voidpf filestream, | ||
227 | uLong *pX)); | ||
228 | |||
229 | local int unzlocal_getLong (pzlib_filefunc_def,filestream,pX) | ||
230 | const zlib_filefunc_def* pzlib_filefunc_def; | ||
231 | voidpf filestream; | ||
232 | uLong *pX; | ||
233 | { | ||
234 | uLong x ; | ||
235 | int i; | ||
236 | int err; | ||
237 | |||
238 | err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); | ||
239 | x = (uLong)i; | ||
240 | |||
241 | if (err==UNZ_OK) | ||
242 | err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); | ||
243 | x += ((uLong)i)<<8; | ||
244 | |||
245 | if (err==UNZ_OK) | ||
246 | err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); | ||
247 | x += ((uLong)i)<<16; | ||
248 | |||
249 | if (err==UNZ_OK) | ||
250 | err = unzlocal_getByte(pzlib_filefunc_def,filestream,&i); | ||
251 | x += ((uLong)i)<<24; | ||
252 | |||
253 | if (err==UNZ_OK) | ||
254 | *pX = x; | ||
255 | else | ||
256 | *pX = 0; | ||
257 | return err; | ||
258 | } | ||
259 | |||
260 | |||
261 | /* My own strcmpi / strcasecmp */ | ||
262 | local int strcmpcasenosensitive_internal (fileName1,fileName2) | ||
263 | const char* fileName1; | ||
264 | const char* fileName2; | ||
265 | { | ||
266 | for (;;) | ||
267 | { | ||
268 | char c1=*(fileName1++); | ||
269 | char c2=*(fileName2++); | ||
270 | if ((c1>='a') && (c1<='z')) | ||
271 | c1 -= 0x20; | ||
272 | if ((c2>='a') && (c2<='z')) | ||
273 | c2 -= 0x20; | ||
274 | if (c1=='\0') | ||
275 | return ((c2=='\0') ? 0 : -1); | ||
276 | if (c2=='\0') | ||
277 | return 1; | ||
278 | if (c1<c2) | ||
279 | return -1; | ||
280 | if (c1>c2) | ||
281 | return 1; | ||
282 | } | ||
283 | } | ||
284 | |||
285 | |||
286 | #ifdef CASESENSITIVITYDEFAULT_NO | ||
287 | #define CASESENSITIVITYDEFAULTVALUE 2 | ||
288 | #else | ||
289 | #define CASESENSITIVITYDEFAULTVALUE 1 | ||
290 | #endif | ||
291 | |||
292 | #ifndef STRCMPCASENOSENTIVEFUNCTION | ||
293 | #define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal | ||
294 | #endif | ||
295 | |||
296 | /* | ||
297 | Compare two filename (fileName1,fileName2). | ||
298 | If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp) | ||
299 | If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi | ||
300 | or strcasecmp) | ||
301 | If iCaseSenisivity = 0, case sensitivity is defaut of your operating system | ||
302 | (like 1 on Unix, 2 on Windows) | ||
303 | |||
304 | */ | ||
305 | extern int ZEXPORT unzStringFileNameCompare (fileName1,fileName2,iCaseSensitivity) | ||
306 | const char* fileName1; | ||
307 | const char* fileName2; | ||
308 | int iCaseSensitivity; | ||
309 | { | ||
310 | if (iCaseSensitivity==0) | ||
311 | iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE; | ||
312 | |||
313 | if (iCaseSensitivity==1) | ||
314 | return strcmp(fileName1,fileName2); | ||
315 | |||
316 | return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2); | ||
317 | } | ||
318 | |||
319 | #ifndef BUFREADCOMMENT | ||
320 | #define BUFREADCOMMENT (0x400) | ||
321 | #endif | ||
322 | |||
323 | /* | ||
324 | Locate the Central directory of a zipfile (at the end, just before | ||
325 | the global comment) | ||
326 | */ | ||
327 | local uLong unzlocal_SearchCentralDir OF(( | ||
328 | const zlib_filefunc_def* pzlib_filefunc_def, | ||
329 | voidpf filestream)); | ||
330 | |||
331 | local uLong unzlocal_SearchCentralDir(pzlib_filefunc_def,filestream) | ||
332 | const zlib_filefunc_def* pzlib_filefunc_def; | ||
333 | voidpf filestream; | ||
334 | { | ||
335 | unsigned char* buf; | ||
336 | uLong uSizeFile; | ||
337 | uLong uBackRead; | ||
338 | uLong uMaxBack=0xffff; /* maximum size of global comment */ | ||
339 | uLong uPosFound=0; | ||
340 | |||
341 | if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0) | ||
342 | return 0; | ||
343 | |||
344 | |||
345 | uSizeFile = ZTELL(*pzlib_filefunc_def,filestream); | ||
346 | |||
347 | if (uMaxBack>uSizeFile) | ||
348 | uMaxBack = uSizeFile; | ||
349 | |||
350 | buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); | ||
351 | if (buf==NULL) | ||
352 | return 0; | ||
353 | |||
354 | uBackRead = 4; | ||
355 | while (uBackRead<uMaxBack) | ||
356 | { | ||
357 | uLong uReadSize,uReadPos ; | ||
358 | int i; | ||
359 | if (uBackRead+BUFREADCOMMENT>uMaxBack) | ||
360 | uBackRead = uMaxBack; | ||
361 | else | ||
362 | uBackRead+=BUFREADCOMMENT; | ||
363 | uReadPos = uSizeFile-uBackRead ; | ||
364 | |||
365 | uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? | ||
366 | (BUFREADCOMMENT+4) : (uSizeFile-uReadPos); | ||
367 | if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0) | ||
368 | break; | ||
369 | |||
370 | if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize) | ||
371 | break; | ||
372 | |||
373 | for (i=(int)uReadSize-3; (i--)>0;) | ||
374 | if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && | ||
375 | ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) | ||
376 | { | ||
377 | uPosFound = uReadPos+i; | ||
378 | break; | ||
379 | } | ||
380 | |||
381 | if (uPosFound!=0) | ||
382 | break; | ||
383 | } | ||
384 | TRYFREE(buf); | ||
385 | return uPosFound; | ||
386 | } | ||
387 | |||
388 | /* | ||
389 | Open a Zip file. path contain the full pathname (by example, | ||
390 | on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer | ||
391 | "zlib/zlib114.zip". | ||
392 | If the zipfile cannot be opened (file doesn't exist or in not valid), the | ||
393 | return value is NULL. | ||
394 | Else, the return value is a unzFile Handle, usable with other function | ||
395 | of this unzip package. | ||
396 | */ | ||
397 | extern unzFile ZEXPORT unzOpen2 (path, pzlib_filefunc_def) | ||
398 | const char *path; | ||
399 | zlib_filefunc_def* pzlib_filefunc_def; | ||
400 | { | ||
401 | unz_s us; | ||
402 | unz_s *s; | ||
403 | uLong central_pos,uL; | ||
404 | |||
405 | uLong number_disk; /* number of the current dist, used for | ||
406 | spaning ZIP, unsupported, always 0*/ | ||
407 | uLong number_disk_with_CD; /* number the the disk with central dir, used | ||
408 | for spaning ZIP, unsupported, always 0*/ | ||
409 | uLong number_entry_CD; /* total number of entries in | ||
410 | the central dir | ||
411 | (same than number_entry on nospan) */ | ||
412 | |||
413 | int err=UNZ_OK; | ||
414 | |||
415 | if (unz_copyright[0]!=' ') | ||
416 | return NULL; | ||
417 | |||
418 | if (pzlib_filefunc_def==NULL) | ||
419 | fill_fopen_filefunc(&us.z_filefunc); | ||
420 | else | ||
421 | us.z_filefunc = *pzlib_filefunc_def; | ||
422 | |||
423 | us.filestream= (*(us.z_filefunc.zopen_file))(us.z_filefunc.opaque, | ||
424 | path, | ||
425 | ZLIB_FILEFUNC_MODE_READ | | ||
426 | ZLIB_FILEFUNC_MODE_EXISTING); | ||
427 | if (us.filestream==NULL) | ||
428 | return NULL; | ||
429 | |||
430 | central_pos = unzlocal_SearchCentralDir(&us.z_filefunc,us.filestream); | ||
431 | if (central_pos==0) | ||
432 | err=UNZ_ERRNO; | ||
433 | |||
434 | if (ZSEEK(us.z_filefunc, us.filestream, | ||
435 | central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0) | ||
436 | err=UNZ_ERRNO; | ||
437 | |||
438 | /* the signature, already checked */ | ||
439 | if (unzlocal_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK) | ||
440 | err=UNZ_ERRNO; | ||
441 | |||
442 | /* number of this disk */ | ||
443 | if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK) | ||
444 | err=UNZ_ERRNO; | ||
445 | |||
446 | /* number of the disk with the start of the central directory */ | ||
447 | if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK) | ||
448 | err=UNZ_ERRNO; | ||
449 | |||
450 | /* total number of entries in the central dir on this disk */ | ||
451 | if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK) | ||
452 | err=UNZ_ERRNO; | ||
453 | |||
454 | /* total number of entries in the central dir */ | ||
455 | if (unzlocal_getShort(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK) | ||
456 | err=UNZ_ERRNO; | ||
457 | |||
458 | if ((number_entry_CD!=us.gi.number_entry) || | ||
459 | (number_disk_with_CD!=0) || | ||
460 | (number_disk!=0)) | ||
461 | err=UNZ_BADZIPFILE; | ||
462 | |||
463 | /* size of the central directory */ | ||
464 | if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK) | ||
465 | err=UNZ_ERRNO; | ||
466 | |||
467 | /* offset of start of central directory with respect to the | ||
468 | starting disk number */ | ||
469 | if (unzlocal_getLong(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK) | ||
470 | err=UNZ_ERRNO; | ||
471 | |||
472 | /* zipfile comment length */ | ||
473 | if (unzlocal_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK) | ||
474 | err=UNZ_ERRNO; | ||
475 | |||
476 | if ((central_pos<us.offset_central_dir+us.size_central_dir) && | ||
477 | (err==UNZ_OK)) | ||
478 | err=UNZ_BADZIPFILE; | ||
479 | |||
480 | if (err!=UNZ_OK) | ||
481 | { | ||
482 | ZCLOSE(us.z_filefunc, us.filestream); | ||
483 | return NULL; | ||
484 | } | ||
485 | |||
486 | us.byte_before_the_zipfile = central_pos - | ||
487 | (us.offset_central_dir+us.size_central_dir); | ||
488 | us.central_pos = central_pos; | ||
489 | us.pfile_in_zip_read = NULL; | ||
490 | us.encrypted = 0; | ||
491 | |||
492 | |||
493 | s=(unz_s*)ALLOC(sizeof(unz_s)); | ||
494 | *s=us; | ||
495 | unzGoToFirstFile((unzFile)s); | ||
496 | return (unzFile)s; | ||
497 | } | ||
498 | |||
499 | |||
500 | extern unzFile ZEXPORT unzOpen (path) | ||
501 | const char *path; | ||
502 | { | ||
503 | return unzOpen2(path, NULL); | ||
504 | } | ||
505 | |||
506 | /* | ||
507 | Close a ZipFile opened with unzipOpen. | ||
508 | If there is files inside the .Zip opened with unzipOpenCurrentFile (see later), | ||
509 | these files MUST be closed with unzipCloseCurrentFile before call unzipClose. | ||
510 | return UNZ_OK if there is no problem. */ | ||
511 | extern int ZEXPORT unzClose (file) | ||
512 | unzFile file; | ||
513 | { | ||
514 | unz_s* s; | ||
515 | if (file==NULL) | ||
516 | return UNZ_PARAMERROR; | ||
517 | s=(unz_s*)file; | ||
518 | |||
519 | if (s->pfile_in_zip_read!=NULL) | ||
520 | unzCloseCurrentFile(file); | ||
521 | |||
522 | ZCLOSE(s->z_filefunc, s->filestream); | ||
523 | TRYFREE(s); | ||
524 | return UNZ_OK; | ||
525 | } | ||
526 | |||
527 | |||
528 | /* | ||
529 | Write info about the ZipFile in the *pglobal_info structure. | ||
530 | No preparation of the structure is needed | ||
531 | return UNZ_OK if there is no problem. */ | ||
532 | extern int ZEXPORT unzGetGlobalInfo (file,pglobal_info) | ||
533 | unzFile file; | ||
534 | unz_global_info *pglobal_info; | ||
535 | { | ||
536 | unz_s* s; | ||
537 | if (file==NULL) | ||
538 | return UNZ_PARAMERROR; | ||
539 | s=(unz_s*)file; | ||
540 | *pglobal_info=s->gi; | ||
541 | return UNZ_OK; | ||
542 | } | ||
543 | |||
544 | |||
545 | /* | ||
546 | Translate date/time from Dos format to tm_unz (readable more easilty) | ||
547 | */ | ||
548 | local void unzlocal_DosDateToTmuDate (ulDosDate, ptm) | ||
549 | uLong ulDosDate; | ||
550 | tm_unz* ptm; | ||
551 | { | ||
552 | uLong uDate; | ||
553 | uDate = (uLong)(ulDosDate>>16); | ||
554 | ptm->tm_mday = (uInt)(uDate&0x1f) ; | ||
555 | ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1) ; | ||
556 | ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ; | ||
557 | |||
558 | ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800); | ||
559 | ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ; | ||
560 | ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ; | ||
561 | } | ||
562 | |||
563 | /* | ||
564 | Get Info about the current file in the zipfile, with internal only info | ||
565 | */ | ||
566 | local int unzlocal_GetCurrentFileInfoInternal OF((unzFile file, | ||
567 | unz_file_info *pfile_info, | ||
568 | unz_file_info_internal | ||
569 | *pfile_info_internal, | ||
570 | char *szFileName, | ||
571 | uLong fileNameBufferSize, | ||
572 | void *extraField, | ||
573 | uLong extraFieldBufferSize, | ||
574 | char *szComment, | ||
575 | uLong commentBufferSize)); | ||
576 | |||
577 | local int unzlocal_GetCurrentFileInfoInternal (file, | ||
578 | pfile_info, | ||
579 | pfile_info_internal, | ||
580 | szFileName, fileNameBufferSize, | ||
581 | extraField, extraFieldBufferSize, | ||
582 | szComment, commentBufferSize) | ||
583 | unzFile file; | ||
584 | unz_file_info *pfile_info; | ||
585 | unz_file_info_internal *pfile_info_internal; | ||
586 | char *szFileName; | ||
587 | uLong fileNameBufferSize; | ||
588 | void *extraField; | ||
589 | uLong extraFieldBufferSize; | ||
590 | char *szComment; | ||
591 | uLong commentBufferSize; | ||
592 | { | ||
593 | unz_s* s; | ||
594 | unz_file_info file_info; | ||
595 | unz_file_info_internal file_info_internal; | ||
596 | int err=UNZ_OK; | ||
597 | uLong uMagic; | ||
598 | long lSeek=0; | ||
599 | |||
600 | if (file==NULL) | ||
601 | return UNZ_PARAMERROR; | ||
602 | s=(unz_s*)file; | ||
603 | if (ZSEEK(s->z_filefunc, s->filestream, | ||
604 | s->pos_in_central_dir+s->byte_before_the_zipfile, | ||
605 | ZLIB_FILEFUNC_SEEK_SET)!=0) | ||
606 | err=UNZ_ERRNO; | ||
607 | |||
608 | |||
609 | /* we check the magic */ | ||
610 | if (err==UNZ_OK) { | ||
611 | if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK) | ||
612 | err=UNZ_ERRNO; | ||
613 | else if (uMagic!=0x02014b50) | ||
614 | err=UNZ_BADZIPFILE; | ||
615 | } | ||
616 | |||
617 | if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK) | ||
618 | err=UNZ_ERRNO; | ||
619 | |||
620 | if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK) | ||
621 | err=UNZ_ERRNO; | ||
622 | |||
623 | if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK) | ||
624 | err=UNZ_ERRNO; | ||
625 | |||
626 | if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK) | ||
627 | err=UNZ_ERRNO; | ||
628 | |||
629 | if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK) | ||
630 | err=UNZ_ERRNO; | ||
631 | |||
632 | unzlocal_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date); | ||
633 | |||
634 | if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK) | ||
635 | err=UNZ_ERRNO; | ||
636 | |||
637 | if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK) | ||
638 | err=UNZ_ERRNO; | ||
639 | |||
640 | if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK) | ||
641 | err=UNZ_ERRNO; | ||
642 | |||
643 | if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK) | ||
644 | err=UNZ_ERRNO; | ||
645 | |||
646 | if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK) | ||
647 | err=UNZ_ERRNO; | ||
648 | |||
649 | if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK) | ||
650 | err=UNZ_ERRNO; | ||
651 | |||
652 | if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK) | ||
653 | err=UNZ_ERRNO; | ||
654 | |||
655 | if (unzlocal_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK) | ||
656 | err=UNZ_ERRNO; | ||
657 | |||
658 | if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK) | ||
659 | err=UNZ_ERRNO; | ||
660 | |||
661 | if (unzlocal_getLong(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK) | ||
662 | err=UNZ_ERRNO; | ||
663 | |||
664 | lSeek+=file_info.size_filename; | ||
665 | if ((err==UNZ_OK) && (szFileName!=NULL)) | ||
666 | { | ||
667 | uLong uSizeRead ; | ||
668 | if (file_info.size_filename<fileNameBufferSize) | ||
669 | { | ||
670 | *(szFileName+file_info.size_filename)='\0'; | ||
671 | uSizeRead = file_info.size_filename; | ||
672 | } | ||
673 | else | ||
674 | uSizeRead = fileNameBufferSize; | ||
675 | |||
676 | if ((file_info.size_filename>0) && (fileNameBufferSize>0)) | ||
677 | if (ZREAD(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead) | ||
678 | err=UNZ_ERRNO; | ||
679 | lSeek -= uSizeRead; | ||
680 | } | ||
681 | |||
682 | |||
683 | if ((err==UNZ_OK) && (extraField!=NULL)) | ||
684 | { | ||
685 | uLong uSizeRead ; | ||
686 | if (file_info.size_file_extra<extraFieldBufferSize) | ||
687 | uSizeRead = file_info.size_file_extra; | ||
688 | else | ||
689 | uSizeRead = extraFieldBufferSize; | ||
690 | |||
691 | if (lSeek!=0) { | ||
692 | if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0) | ||
693 | lSeek=0; | ||
694 | else | ||
695 | err=UNZ_ERRNO; | ||
696 | } | ||
697 | if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0)) | ||
698 | if (ZREAD(s->z_filefunc, s->filestream,extraField,uSizeRead)!=uSizeRead) | ||
699 | err=UNZ_ERRNO; | ||
700 | lSeek += file_info.size_file_extra - uSizeRead; | ||
701 | } | ||
702 | else | ||
703 | lSeek+=file_info.size_file_extra; | ||
704 | |||
705 | |||
706 | if ((err==UNZ_OK) && (szComment!=NULL)) | ||
707 | { | ||
708 | uLong uSizeRead ; | ||
709 | if (file_info.size_file_comment<commentBufferSize) | ||
710 | { | ||
711 | *(szComment+file_info.size_file_comment)='\0'; | ||
712 | uSizeRead = file_info.size_file_comment; | ||
713 | } | ||
714 | else | ||
715 | uSizeRead = commentBufferSize; | ||
716 | |||
717 | if (lSeek!=0) { | ||
718 | if (ZSEEK(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0) | ||
719 | lSeek=0; | ||
720 | else | ||
721 | err=UNZ_ERRNO; | ||
722 | } | ||
723 | if ((file_info.size_file_comment>0) && (commentBufferSize>0)) | ||
724 | if (ZREAD(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead) | ||
725 | err=UNZ_ERRNO; | ||
726 | lSeek+=file_info.size_file_comment - uSizeRead; | ||
727 | } | ||
728 | else | ||
729 | lSeek+=file_info.size_file_comment; | ||
730 | |||
731 | if ((err==UNZ_OK) && (pfile_info!=NULL)) | ||
732 | *pfile_info=file_info; | ||
733 | |||
734 | if ((err==UNZ_OK) && (pfile_info_internal!=NULL)) | ||
735 | *pfile_info_internal=file_info_internal; | ||
736 | |||
737 | return err; | ||
738 | } | ||
739 | |||
740 | |||
741 | |||
742 | /* | ||
743 | Write info about the ZipFile in the *pglobal_info structure. | ||
744 | No preparation of the structure is needed | ||
745 | return UNZ_OK if there is no problem. | ||
746 | */ | ||
747 | extern int ZEXPORT unzGetCurrentFileInfo (file, | ||
748 | pfile_info, | ||
749 | szFileName, fileNameBufferSize, | ||
750 | extraField, extraFieldBufferSize, | ||
751 | szComment, commentBufferSize) | ||
752 | unzFile file; | ||
753 | unz_file_info *pfile_info; | ||
754 | char *szFileName; | ||
755 | uLong fileNameBufferSize; | ||
756 | void *extraField; | ||
757 | uLong extraFieldBufferSize; | ||
758 | char *szComment; | ||
759 | uLong commentBufferSize; | ||
760 | { | ||
761 | return unzlocal_GetCurrentFileInfoInternal(file,pfile_info,NULL, | ||
762 | szFileName,fileNameBufferSize, | ||
763 | extraField,extraFieldBufferSize, | ||
764 | szComment,commentBufferSize); | ||
765 | } | ||
766 | |||
767 | /* | ||
768 | Set the current file of the zipfile to the first file. | ||
769 | return UNZ_OK if there is no problem | ||
770 | */ | ||
771 | extern int ZEXPORT unzGoToFirstFile (file) | ||
772 | unzFile file; | ||
773 | { | ||
774 | int err=UNZ_OK; | ||
775 | unz_s* s; | ||
776 | if (file==NULL) | ||
777 | return UNZ_PARAMERROR; | ||
778 | s=(unz_s*)file; | ||
779 | s->pos_in_central_dir=s->offset_central_dir; | ||
780 | s->num_file=0; | ||
781 | err=unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info, | ||
782 | &s->cur_file_info_internal, | ||
783 | NULL,0,NULL,0,NULL,0); | ||
784 | s->current_file_ok = (err == UNZ_OK); | ||
785 | return err; | ||
786 | } | ||
787 | |||
788 | /* | ||
789 | Set the current file of the zipfile to the next file. | ||
790 | return UNZ_OK if there is no problem | ||
791 | return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest. | ||
792 | */ | ||
793 | extern int ZEXPORT unzGoToNextFile (file) | ||
794 | unzFile file; | ||
795 | { | ||
796 | unz_s* s; | ||
797 | int err; | ||
798 | |||
799 | if (file==NULL) | ||
800 | return UNZ_PARAMERROR; | ||
801 | s=(unz_s*)file; | ||
802 | if (!s->current_file_ok) | ||
803 | return UNZ_END_OF_LIST_OF_FILE; | ||
804 | if (s->gi.number_entry != 0xffff) /* 2^16 files overflow hack */ | ||
805 | if (s->num_file+1==s->gi.number_entry) | ||
806 | return UNZ_END_OF_LIST_OF_FILE; | ||
807 | |||
808 | s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename + | ||
809 | s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ; | ||
810 | s->num_file++; | ||
811 | err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info, | ||
812 | &s->cur_file_info_internal, | ||
813 | NULL,0,NULL,0,NULL,0); | ||
814 | s->current_file_ok = (err == UNZ_OK); | ||
815 | return err; | ||
816 | } | ||
817 | |||
818 | |||
819 | /* | ||
820 | Try locate the file szFileName in the zipfile. | ||
821 | For the iCaseSensitivity signification, see unzipStringFileNameCompare | ||
822 | |||
823 | return value : | ||
824 | UNZ_OK if the file is found. It becomes the current file. | ||
825 | UNZ_END_OF_LIST_OF_FILE if the file is not found | ||
826 | */ | ||
827 | extern int ZEXPORT unzLocateFile (file, szFileName, iCaseSensitivity) | ||
828 | unzFile file; | ||
829 | const char *szFileName; | ||
830 | int iCaseSensitivity; | ||
831 | { | ||
832 | unz_s* s; | ||
833 | int err; | ||
834 | |||
835 | /* We remember the 'current' position in the file so that we can jump | ||
836 | * back there if we fail. | ||
837 | */ | ||
838 | unz_file_info cur_file_infoSaved; | ||
839 | unz_file_info_internal cur_file_info_internalSaved; | ||
840 | uLong num_fileSaved; | ||
841 | uLong pos_in_central_dirSaved; | ||
842 | |||
843 | |||
844 | if (file==NULL) | ||
845 | return UNZ_PARAMERROR; | ||
846 | |||
847 | if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP) | ||
848 | return UNZ_PARAMERROR; | ||
849 | |||
850 | s=(unz_s*)file; | ||
851 | if (!s->current_file_ok) | ||
852 | return UNZ_END_OF_LIST_OF_FILE; | ||
853 | |||
854 | /* Save the current state */ | ||
855 | num_fileSaved = s->num_file; | ||
856 | pos_in_central_dirSaved = s->pos_in_central_dir; | ||
857 | cur_file_infoSaved = s->cur_file_info; | ||
858 | cur_file_info_internalSaved = s->cur_file_info_internal; | ||
859 | |||
860 | err = unzGoToFirstFile(file); | ||
861 | |||
862 | while (err == UNZ_OK) | ||
863 | { | ||
864 | char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1]; | ||
865 | err = unzGetCurrentFileInfo(file,NULL, | ||
866 | szCurrentFileName,sizeof(szCurrentFileName)-1, | ||
867 | NULL,0,NULL,0); | ||
868 | if (err == UNZ_OK) | ||
869 | { | ||
870 | if (unzStringFileNameCompare(szCurrentFileName, | ||
871 | szFileName,iCaseSensitivity)==0) | ||
872 | return UNZ_OK; | ||
873 | err = unzGoToNextFile(file); | ||
874 | } | ||
875 | } | ||
876 | |||
877 | /* We failed, so restore the state of the 'current file' to where we | ||
878 | * were. | ||
879 | */ | ||
880 | s->num_file = num_fileSaved ; | ||
881 | s->pos_in_central_dir = pos_in_central_dirSaved ; | ||
882 | s->cur_file_info = cur_file_infoSaved; | ||
883 | s->cur_file_info_internal = cur_file_info_internalSaved; | ||
884 | return err; | ||
885 | } | ||
886 | |||
887 | |||
888 | /* | ||
889 | /////////////////////////////////////////// | ||
890 | // Contributed by Ryan Haksi (mailto://cryogen@infoserve.net) | ||
891 | // I need random access | ||
892 | // | ||
893 | // Further optimization could be realized by adding an ability | ||
894 | // to cache the directory in memory. The goal being a single | ||
895 | // comprehensive file read to put the file I need in a memory. | ||
896 | */ | ||
897 | |||
898 | /* | ||
899 | typedef struct unz_file_pos_s | ||
900 | { | ||
901 | uLong pos_in_zip_directory; // offset in file | ||
902 | uLong num_of_file; // # of file | ||
903 | } unz_file_pos; | ||
904 | */ | ||
905 | |||
906 | extern int ZEXPORT unzGetFilePos(file, file_pos) | ||
907 | unzFile file; | ||
908 | unz_file_pos* file_pos; | ||
909 | { | ||
910 | unz_s* s; | ||
911 | |||
912 | if (file==NULL || file_pos==NULL) | ||
913 | return UNZ_PARAMERROR; | ||
914 | s=(unz_s*)file; | ||
915 | if (!s->current_file_ok) | ||
916 | return UNZ_END_OF_LIST_OF_FILE; | ||
917 | |||
918 | file_pos->pos_in_zip_directory = s->pos_in_central_dir; | ||
919 | file_pos->num_of_file = s->num_file; | ||
920 | |||
921 | return UNZ_OK; | ||
922 | } | ||
923 | |||
924 | extern int ZEXPORT unzGoToFilePos(file, file_pos) | ||
925 | unzFile file; | ||
926 | unz_file_pos* file_pos; | ||
927 | { | ||
928 | unz_s* s; | ||
929 | int err; | ||
930 | |||
931 | if (file==NULL || file_pos==NULL) | ||
932 | return UNZ_PARAMERROR; | ||
933 | s=(unz_s*)file; | ||
934 | |||
935 | /* jump to the right spot */ | ||
936 | s->pos_in_central_dir = file_pos->pos_in_zip_directory; | ||
937 | s->num_file = file_pos->num_of_file; | ||
938 | |||
939 | /* set the current file */ | ||
940 | err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info, | ||
941 | &s->cur_file_info_internal, | ||
942 | NULL,0,NULL,0,NULL,0); | ||
943 | /* return results */ | ||
944 | s->current_file_ok = (err == UNZ_OK); | ||
945 | return err; | ||
946 | } | ||
947 | |||
948 | /* | ||
949 | // Unzip Helper Functions - should be here? | ||
950 | /////////////////////////////////////////// | ||
951 | */ | ||
952 | |||
953 | /* | ||
954 | Read the local header of the current zipfile | ||
955 | Check the coherency of the local header and info in the end of central | ||
956 | directory about this file | ||
957 | store in *piSizeVar the size of extra info in local header | ||
958 | (filename and size of extra field data) | ||
959 | */ | ||
960 | local int unzlocal_CheckCurrentFileCoherencyHeader (s,piSizeVar, | ||
961 | poffset_local_extrafield, | ||
962 | psize_local_extrafield) | ||
963 | unz_s* s; | ||
964 | uInt* piSizeVar; | ||
965 | uLong *poffset_local_extrafield; | ||
966 | uInt *psize_local_extrafield; | ||
967 | { | ||
968 | uLong uMagic,uData,uFlags; | ||
969 | uLong size_filename; | ||
970 | uLong size_extra_field; | ||
971 | int err=UNZ_OK; | ||
972 | |||
973 | *piSizeVar = 0; | ||
974 | *poffset_local_extrafield = 0; | ||
975 | *psize_local_extrafield = 0; | ||
976 | |||
977 | if (ZSEEK(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile + | ||
978 | s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0) | ||
979 | return UNZ_ERRNO; | ||
980 | |||
981 | |||
982 | if (err==UNZ_OK) { | ||
983 | if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK) | ||
984 | err=UNZ_ERRNO; | ||
985 | else if (uMagic!=0x04034b50) | ||
986 | err=UNZ_BADZIPFILE; | ||
987 | } | ||
988 | |||
989 | if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) | ||
990 | err=UNZ_ERRNO; | ||
991 | /* | ||
992 | else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion)) | ||
993 | err=UNZ_BADZIPFILE; | ||
994 | */ | ||
995 | if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK) | ||
996 | err=UNZ_ERRNO; | ||
997 | |||
998 | if (unzlocal_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) | ||
999 | err=UNZ_ERRNO; | ||
1000 | else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method)) | ||
1001 | err=UNZ_BADZIPFILE; | ||
1002 | |||
1003 | if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) && | ||
1004 | (s->cur_file_info.compression_method!=Z_DEFLATED)) | ||
1005 | err=UNZ_BADZIPFILE; | ||
1006 | |||
1007 | if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */ | ||
1008 | err=UNZ_ERRNO; | ||
1009 | |||
1010 | if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */ | ||
1011 | err=UNZ_ERRNO; | ||
1012 | else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) && | ||
1013 | ((uFlags & 8)==0)) | ||
1014 | err=UNZ_BADZIPFILE; | ||
1015 | |||
1016 | if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */ | ||
1017 | err=UNZ_ERRNO; | ||
1018 | else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) && | ||
1019 | ((uFlags & 8)==0)) | ||
1020 | err=UNZ_BADZIPFILE; | ||
1021 | |||
1022 | if (unzlocal_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */ | ||
1023 | err=UNZ_ERRNO; | ||
1024 | else if ((err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && | ||
1025 | ((uFlags & 8)==0)) | ||
1026 | err=UNZ_BADZIPFILE; | ||
1027 | |||
1028 | |||
1029 | if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK) | ||
1030 | err=UNZ_ERRNO; | ||
1031 | else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename)) | ||
1032 | err=UNZ_BADZIPFILE; | ||
1033 | |||
1034 | *piSizeVar += (uInt)size_filename; | ||
1035 | |||
1036 | if (unzlocal_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK) | ||
1037 | err=UNZ_ERRNO; | ||
1038 | *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile + | ||
1039 | SIZEZIPLOCALHEADER + size_filename; | ||
1040 | *psize_local_extrafield = (uInt)size_extra_field; | ||
1041 | |||
1042 | *piSizeVar += (uInt)size_extra_field; | ||
1043 | |||
1044 | return err; | ||
1045 | } | ||
1046 | |||
1047 | /* | ||
1048 | Open for reading data the current file in the zipfile. | ||
1049 | If there is no error and the file is opened, the return value is UNZ_OK. | ||
1050 | */ | ||
1051 | extern int ZEXPORT unzOpenCurrentFile3 (file, method, level, raw, password) | ||
1052 | unzFile file; | ||
1053 | int* method; | ||
1054 | int* level; | ||
1055 | int raw; | ||
1056 | const char* password; | ||
1057 | { | ||
1058 | int err=UNZ_OK; | ||
1059 | uInt iSizeVar; | ||
1060 | unz_s* s; | ||
1061 | file_in_zip_read_info_s* pfile_in_zip_read_info; | ||
1062 | uLong offset_local_extrafield; /* offset of the local extra field */ | ||
1063 | uInt size_local_extrafield; /* size of the local extra field */ | ||
1064 | # ifndef NOUNCRYPT | ||
1065 | char source[12]; | ||
1066 | # else | ||
1067 | if (password != NULL) | ||
1068 | return UNZ_PARAMERROR; | ||
1069 | # endif | ||
1070 | |||
1071 | if (file==NULL) | ||
1072 | return UNZ_PARAMERROR; | ||
1073 | s=(unz_s*)file; | ||
1074 | if (!s->current_file_ok) | ||
1075 | return UNZ_PARAMERROR; | ||
1076 | |||
1077 | if (s->pfile_in_zip_read != NULL) | ||
1078 | unzCloseCurrentFile(file); | ||
1079 | |||
1080 | if (unzlocal_CheckCurrentFileCoherencyHeader(s,&iSizeVar, | ||
1081 | &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK) | ||
1082 | return UNZ_BADZIPFILE; | ||
1083 | |||
1084 | pfile_in_zip_read_info = (file_in_zip_read_info_s*) | ||
1085 | ALLOC(sizeof(file_in_zip_read_info_s)); | ||
1086 | if (pfile_in_zip_read_info==NULL) | ||
1087 | return UNZ_INTERNALERROR; | ||
1088 | |||
1089 | pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE); | ||
1090 | pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield; | ||
1091 | pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield; | ||
1092 | pfile_in_zip_read_info->pos_local_extrafield=0; | ||
1093 | pfile_in_zip_read_info->raw=raw; | ||
1094 | |||
1095 | if (pfile_in_zip_read_info->read_buffer==NULL) | ||
1096 | { | ||
1097 | TRYFREE(pfile_in_zip_read_info); | ||
1098 | return UNZ_INTERNALERROR; | ||
1099 | } | ||
1100 | |||
1101 | pfile_in_zip_read_info->stream_initialised=0; | ||
1102 | |||
1103 | if (method!=NULL) | ||
1104 | *method = (int)s->cur_file_info.compression_method; | ||
1105 | |||
1106 | if (level!=NULL) | ||
1107 | { | ||
1108 | *level = 6; | ||
1109 | switch (s->cur_file_info.flag & 0x06) | ||
1110 | { | ||
1111 | case 6 : *level = 1; break; | ||
1112 | case 4 : *level = 2; break; | ||
1113 | case 2 : *level = 9; break; | ||
1114 | } | ||
1115 | } | ||
1116 | |||
1117 | if ((s->cur_file_info.compression_method!=0) && | ||
1118 | (s->cur_file_info.compression_method!=Z_DEFLATED)) | ||
1119 | err=UNZ_BADZIPFILE; | ||
1120 | |||
1121 | pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc; | ||
1122 | pfile_in_zip_read_info->crc32=0; | ||
1123 | pfile_in_zip_read_info->compression_method = | ||
1124 | s->cur_file_info.compression_method; | ||
1125 | pfile_in_zip_read_info->filestream=s->filestream; | ||
1126 | pfile_in_zip_read_info->z_filefunc=s->z_filefunc; | ||
1127 | pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile; | ||
1128 | |||
1129 | pfile_in_zip_read_info->stream.total_out = 0; | ||
1130 | |||
1131 | if ((s->cur_file_info.compression_method==Z_DEFLATED) && | ||
1132 | (!raw)) | ||
1133 | { | ||
1134 | pfile_in_zip_read_info->stream.zalloc = (alloc_func)0; | ||
1135 | pfile_in_zip_read_info->stream.zfree = (free_func)0; | ||
1136 | pfile_in_zip_read_info->stream.opaque = (voidpf)0; | ||
1137 | pfile_in_zip_read_info->stream.next_in = (voidpf)0; | ||
1138 | pfile_in_zip_read_info->stream.avail_in = 0; | ||
1139 | |||
1140 | err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS); | ||
1141 | if (err == Z_OK) | ||
1142 | pfile_in_zip_read_info->stream_initialised=1; | ||
1143 | else | ||
1144 | { | ||
1145 | TRYFREE(pfile_in_zip_read_info); | ||
1146 | return err; | ||
1147 | } | ||
1148 | /* windowBits is passed < 0 to tell that there is no zlib header. | ||
1149 | * Note that in this case inflate *requires* an extra "dummy" byte | ||
1150 | * after the compressed stream in order to complete decompression and | ||
1151 | * return Z_STREAM_END. | ||
1152 | * In unzip, i don't wait absolutely Z_STREAM_END because I known the | ||
1153 | * size of both compressed and uncompressed data | ||
1154 | */ | ||
1155 | } | ||
1156 | pfile_in_zip_read_info->rest_read_compressed = | ||
1157 | s->cur_file_info.compressed_size ; | ||
1158 | pfile_in_zip_read_info->rest_read_uncompressed = | ||
1159 | s->cur_file_info.uncompressed_size ; | ||
1160 | |||
1161 | |||
1162 | pfile_in_zip_read_info->pos_in_zipfile = | ||
1163 | s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER + | ||
1164 | iSizeVar; | ||
1165 | |||
1166 | pfile_in_zip_read_info->stream.avail_in = (uInt)0; | ||
1167 | |||
1168 | s->pfile_in_zip_read = pfile_in_zip_read_info; | ||
1169 | |||
1170 | # ifndef NOUNCRYPT | ||
1171 | if (password != NULL) | ||
1172 | { | ||
1173 | int i; | ||
1174 | s->pcrc_32_tab = get_crc_table(); | ||
1175 | init_keys(password,s->keys,s->pcrc_32_tab); | ||
1176 | if (ZSEEK(s->z_filefunc, s->filestream, | ||
1177 | s->pfile_in_zip_read->pos_in_zipfile + | ||
1178 | s->pfile_in_zip_read->byte_before_the_zipfile, | ||
1179 | SEEK_SET)!=0) | ||
1180 | return UNZ_INTERNALERROR; | ||
1181 | if(ZREAD(s->z_filefunc, s->filestream,source, 12)<12) | ||
1182 | return UNZ_INTERNALERROR; | ||
1183 | |||
1184 | for (i = 0; i<12; i++) | ||
1185 | zdecode(s->keys,s->pcrc_32_tab,source[i]); | ||
1186 | |||
1187 | s->pfile_in_zip_read->pos_in_zipfile+=12; | ||
1188 | s->encrypted=1; | ||
1189 | } | ||
1190 | # endif | ||
1191 | |||
1192 | |||
1193 | return UNZ_OK; | ||
1194 | } | ||
1195 | |||
1196 | extern int ZEXPORT unzOpenCurrentFile (file) | ||
1197 | unzFile file; | ||
1198 | { | ||
1199 | return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL); | ||
1200 | } | ||
1201 | |||
1202 | extern int ZEXPORT unzOpenCurrentFilePassword (file, password) | ||
1203 | unzFile file; | ||
1204 | const char* password; | ||
1205 | { | ||
1206 | return unzOpenCurrentFile3(file, NULL, NULL, 0, password); | ||
1207 | } | ||
1208 | |||
1209 | extern int ZEXPORT unzOpenCurrentFile2 (file,method,level,raw) | ||
1210 | unzFile file; | ||
1211 | int* method; | ||
1212 | int* level; | ||
1213 | int raw; | ||
1214 | { | ||
1215 | return unzOpenCurrentFile3(file, method, level, raw, NULL); | ||
1216 | } | ||
1217 | |||
1218 | /* | ||
1219 | Read bytes from the current file. | ||
1220 | buf contain buffer where data must be copied | ||
1221 | len the size of buf. | ||
1222 | |||
1223 | return the number of byte copied if somes bytes are copied | ||
1224 | return 0 if the end of file was reached | ||
1225 | return <0 with error code if there is an error | ||
1226 | (UNZ_ERRNO for IO error, or zLib error for uncompress error) | ||
1227 | */ | ||
1228 | extern int ZEXPORT unzReadCurrentFile (file, buf, len) | ||
1229 | unzFile file; | ||
1230 | voidp buf; | ||
1231 | unsigned len; | ||
1232 | { | ||
1233 | int err=UNZ_OK; | ||
1234 | uInt iRead = 0; | ||
1235 | unz_s* s; | ||
1236 | file_in_zip_read_info_s* pfile_in_zip_read_info; | ||
1237 | if (file==NULL) | ||
1238 | return UNZ_PARAMERROR; | ||
1239 | s=(unz_s*)file; | ||
1240 | pfile_in_zip_read_info=s->pfile_in_zip_read; | ||
1241 | |||
1242 | if (pfile_in_zip_read_info==NULL) | ||
1243 | return UNZ_PARAMERROR; | ||
1244 | |||
1245 | |||
1246 | if ((pfile_in_zip_read_info->read_buffer == NULL)) | ||
1247 | return UNZ_END_OF_LIST_OF_FILE; | ||
1248 | if (len==0) | ||
1249 | return 0; | ||
1250 | |||
1251 | pfile_in_zip_read_info->stream.next_out = (Bytef*)buf; | ||
1252 | |||
1253 | pfile_in_zip_read_info->stream.avail_out = (uInt)len; | ||
1254 | |||
1255 | if ((len>pfile_in_zip_read_info->rest_read_uncompressed) && | ||
1256 | (!(pfile_in_zip_read_info->raw))) | ||
1257 | pfile_in_zip_read_info->stream.avail_out = | ||
1258 | (uInt)pfile_in_zip_read_info->rest_read_uncompressed; | ||
1259 | |||
1260 | if ((len>pfile_in_zip_read_info->rest_read_compressed+ | ||
1261 | pfile_in_zip_read_info->stream.avail_in) && | ||
1262 | (pfile_in_zip_read_info->raw)) | ||
1263 | pfile_in_zip_read_info->stream.avail_out = | ||
1264 | (uInt)pfile_in_zip_read_info->rest_read_compressed+ | ||
1265 | pfile_in_zip_read_info->stream.avail_in; | ||
1266 | |||
1267 | while (pfile_in_zip_read_info->stream.avail_out>0) | ||
1268 | { | ||
1269 | if ((pfile_in_zip_read_info->stream.avail_in==0) && | ||
1270 | (pfile_in_zip_read_info->rest_read_compressed>0)) | ||
1271 | { | ||
1272 | uInt uReadThis = UNZ_BUFSIZE; | ||
1273 | if (pfile_in_zip_read_info->rest_read_compressed<uReadThis) | ||
1274 | uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed; | ||
1275 | if (uReadThis == 0) | ||
1276 | return UNZ_EOF; | ||
1277 | if (ZSEEK(pfile_in_zip_read_info->z_filefunc, | ||
1278 | pfile_in_zip_read_info->filestream, | ||
1279 | pfile_in_zip_read_info->pos_in_zipfile + | ||
1280 | pfile_in_zip_read_info->byte_before_the_zipfile, | ||
1281 | ZLIB_FILEFUNC_SEEK_SET)!=0) | ||
1282 | return UNZ_ERRNO; | ||
1283 | if (ZREAD(pfile_in_zip_read_info->z_filefunc, | ||
1284 | pfile_in_zip_read_info->filestream, | ||
1285 | pfile_in_zip_read_info->read_buffer, | ||
1286 | uReadThis)!=uReadThis) | ||
1287 | return UNZ_ERRNO; | ||
1288 | |||
1289 | |||
1290 | # ifndef NOUNCRYPT | ||
1291 | if(s->encrypted) | ||
1292 | { | ||
1293 | uInt i; | ||
1294 | for(i=0;i<uReadThis;i++) | ||
1295 | pfile_in_zip_read_info->read_buffer[i] = | ||
1296 | zdecode(s->keys,s->pcrc_32_tab, | ||
1297 | pfile_in_zip_read_info->read_buffer[i]); | ||
1298 | } | ||
1299 | # endif | ||
1300 | |||
1301 | |||
1302 | pfile_in_zip_read_info->pos_in_zipfile += uReadThis; | ||
1303 | |||
1304 | pfile_in_zip_read_info->rest_read_compressed-=uReadThis; | ||
1305 | |||
1306 | pfile_in_zip_read_info->stream.next_in = | ||
1307 | (Bytef*)pfile_in_zip_read_info->read_buffer; | ||
1308 | pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis; | ||
1309 | } | ||
1310 | |||
1311 | if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw)) | ||
1312 | { | ||
1313 | uInt uDoCopy,i ; | ||
1314 | |||
1315 | if ((pfile_in_zip_read_info->stream.avail_in == 0) && | ||
1316 | (pfile_in_zip_read_info->rest_read_compressed == 0)) | ||
1317 | return (iRead==0) ? UNZ_EOF : iRead; | ||
1318 | |||
1319 | if (pfile_in_zip_read_info->stream.avail_out < | ||
1320 | pfile_in_zip_read_info->stream.avail_in) | ||
1321 | uDoCopy = pfile_in_zip_read_info->stream.avail_out ; | ||
1322 | else | ||
1323 | uDoCopy = pfile_in_zip_read_info->stream.avail_in ; | ||
1324 | |||
1325 | for (i=0;i<uDoCopy;i++) | ||
1326 | *(pfile_in_zip_read_info->stream.next_out+i) = | ||
1327 | *(pfile_in_zip_read_info->stream.next_in+i); | ||
1328 | |||
1329 | pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32, | ||
1330 | pfile_in_zip_read_info->stream.next_out, | ||
1331 | uDoCopy); | ||
1332 | pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy; | ||
1333 | pfile_in_zip_read_info->stream.avail_in -= uDoCopy; | ||
1334 | pfile_in_zip_read_info->stream.avail_out -= uDoCopy; | ||
1335 | pfile_in_zip_read_info->stream.next_out += uDoCopy; | ||
1336 | pfile_in_zip_read_info->stream.next_in += uDoCopy; | ||
1337 | pfile_in_zip_read_info->stream.total_out += uDoCopy; | ||
1338 | iRead += uDoCopy; | ||
1339 | } | ||
1340 | else | ||
1341 | { | ||
1342 | uLong uTotalOutBefore,uTotalOutAfter; | ||
1343 | const Bytef *bufBefore; | ||
1344 | uLong uOutThis; | ||
1345 | int flush=Z_SYNC_FLUSH; | ||
1346 | |||
1347 | uTotalOutBefore = pfile_in_zip_read_info->stream.total_out; | ||
1348 | bufBefore = pfile_in_zip_read_info->stream.next_out; | ||
1349 | |||
1350 | /* | ||
1351 | if ((pfile_in_zip_read_info->rest_read_uncompressed == | ||
1352 | pfile_in_zip_read_info->stream.avail_out) && | ||
1353 | (pfile_in_zip_read_info->rest_read_compressed == 0)) | ||
1354 | flush = Z_FINISH; | ||
1355 | */ | ||
1356 | err=inflate(&pfile_in_zip_read_info->stream,flush); | ||
1357 | |||
1358 | if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL)) | ||
1359 | err = Z_DATA_ERROR; | ||
1360 | |||
1361 | uTotalOutAfter = pfile_in_zip_read_info->stream.total_out; | ||
1362 | uOutThis = uTotalOutAfter-uTotalOutBefore; | ||
1363 | |||
1364 | pfile_in_zip_read_info->crc32 = | ||
1365 | crc32(pfile_in_zip_read_info->crc32,bufBefore, | ||
1366 | (uInt)(uOutThis)); | ||
1367 | |||
1368 | pfile_in_zip_read_info->rest_read_uncompressed -= | ||
1369 | uOutThis; | ||
1370 | |||
1371 | iRead += (uInt)(uTotalOutAfter - uTotalOutBefore); | ||
1372 | |||
1373 | if (err==Z_STREAM_END) | ||
1374 | return (iRead==0) ? UNZ_EOF : iRead; | ||
1375 | if (err!=Z_OK) | ||
1376 | break; | ||
1377 | } | ||
1378 | } | ||
1379 | |||
1380 | if (err==Z_OK) | ||
1381 | return iRead; | ||
1382 | return err; | ||
1383 | } | ||
1384 | |||
1385 | |||
1386 | /* | ||
1387 | Give the current position in uncompressed data | ||
1388 | */ | ||
1389 | extern z_off_t ZEXPORT unztell (file) | ||
1390 | unzFile file; | ||
1391 | { | ||
1392 | unz_s* s; | ||
1393 | file_in_zip_read_info_s* pfile_in_zip_read_info; | ||
1394 | if (file==NULL) | ||
1395 | return UNZ_PARAMERROR; | ||
1396 | s=(unz_s*)file; | ||
1397 | pfile_in_zip_read_info=s->pfile_in_zip_read; | ||
1398 | |||
1399 | if (pfile_in_zip_read_info==NULL) | ||
1400 | return UNZ_PARAMERROR; | ||
1401 | |||
1402 | return (z_off_t)pfile_in_zip_read_info->stream.total_out; | ||
1403 | } | ||
1404 | |||
1405 | |||
1406 | /* | ||
1407 | return 1 if the end of file was reached, 0 elsewhere | ||
1408 | */ | ||
1409 | extern int ZEXPORT unzeof (file) | ||
1410 | unzFile file; | ||
1411 | { | ||
1412 | unz_s* s; | ||
1413 | file_in_zip_read_info_s* pfile_in_zip_read_info; | ||
1414 | if (file==NULL) | ||
1415 | return UNZ_PARAMERROR; | ||
1416 | s=(unz_s*)file; | ||
1417 | pfile_in_zip_read_info=s->pfile_in_zip_read; | ||
1418 | |||
1419 | if (pfile_in_zip_read_info==NULL) | ||
1420 | return UNZ_PARAMERROR; | ||
1421 | |||
1422 | if (pfile_in_zip_read_info->rest_read_uncompressed == 0) | ||
1423 | return 1; | ||
1424 | else | ||
1425 | return 0; | ||
1426 | } | ||
1427 | |||
1428 | |||
1429 | |||
1430 | /* | ||
1431 | Read extra field from the current file (opened by unzOpenCurrentFile) | ||
1432 | This is the local-header version of the extra field (sometimes, there is | ||
1433 | more info in the local-header version than in the central-header) | ||
1434 | |||
1435 | if buf==NULL, it return the size of the local extra field that can be read | ||
1436 | |||
1437 | if buf!=NULL, len is the size of the buffer, the extra header is copied in | ||
1438 | buf. | ||
1439 | the return value is the number of bytes copied in buf, or (if <0) | ||
1440 | the error code | ||
1441 | */ | ||
1442 | extern int ZEXPORT unzGetLocalExtrafield (file,buf,len) | ||
1443 | unzFile file; | ||
1444 | voidp buf; | ||
1445 | unsigned len; | ||
1446 | { | ||
1447 | unz_s* s; | ||
1448 | file_in_zip_read_info_s* pfile_in_zip_read_info; | ||
1449 | uInt read_now; | ||
1450 | uLong size_to_read; | ||
1451 | |||
1452 | if (file==NULL) | ||
1453 | return UNZ_PARAMERROR; | ||
1454 | s=(unz_s*)file; | ||
1455 | pfile_in_zip_read_info=s->pfile_in_zip_read; | ||
1456 | |||
1457 | if (pfile_in_zip_read_info==NULL) | ||
1458 | return UNZ_PARAMERROR; | ||
1459 | |||
1460 | size_to_read = (pfile_in_zip_read_info->size_local_extrafield - | ||
1461 | pfile_in_zip_read_info->pos_local_extrafield); | ||
1462 | |||
1463 | if (buf==NULL) | ||
1464 | return (int)size_to_read; | ||
1465 | |||
1466 | if (len>size_to_read) | ||
1467 | read_now = (uInt)size_to_read; | ||
1468 | else | ||
1469 | read_now = (uInt)len ; | ||
1470 | |||
1471 | if (read_now==0) | ||
1472 | return 0; | ||
1473 | |||
1474 | if (ZSEEK(pfile_in_zip_read_info->z_filefunc, | ||
1475 | pfile_in_zip_read_info->filestream, | ||
1476 | pfile_in_zip_read_info->offset_local_extrafield + | ||
1477 | pfile_in_zip_read_info->pos_local_extrafield, | ||
1478 | ZLIB_FILEFUNC_SEEK_SET)!=0) | ||
1479 | return UNZ_ERRNO; | ||
1480 | |||
1481 | if (ZREAD(pfile_in_zip_read_info->z_filefunc, | ||
1482 | pfile_in_zip_read_info->filestream, | ||
1483 | buf,read_now)!=read_now) | ||
1484 | return UNZ_ERRNO; | ||
1485 | |||
1486 | return (int)read_now; | ||
1487 | } | ||
1488 | |||
1489 | /* | ||
1490 | Close the file in zip opened with unzipOpenCurrentFile | ||
1491 | Return UNZ_CRCERROR if all the file was read but the CRC is not good | ||
1492 | */ | ||
1493 | extern int ZEXPORT unzCloseCurrentFile (file) | ||
1494 | unzFile file; | ||
1495 | { | ||
1496 | int err=UNZ_OK; | ||
1497 | |||
1498 | unz_s* s; | ||
1499 | file_in_zip_read_info_s* pfile_in_zip_read_info; | ||
1500 | if (file==NULL) | ||
1501 | return UNZ_PARAMERROR; | ||
1502 | s=(unz_s*)file; | ||
1503 | pfile_in_zip_read_info=s->pfile_in_zip_read; | ||
1504 | |||
1505 | if (pfile_in_zip_read_info==NULL) | ||
1506 | return UNZ_PARAMERROR; | ||
1507 | |||
1508 | |||
1509 | if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) && | ||
1510 | (!pfile_in_zip_read_info->raw)) | ||
1511 | { | ||
1512 | if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait) | ||
1513 | err=UNZ_CRCERROR; | ||
1514 | } | ||
1515 | |||
1516 | |||
1517 | TRYFREE(pfile_in_zip_read_info->read_buffer); | ||
1518 | pfile_in_zip_read_info->read_buffer = NULL; | ||
1519 | if (pfile_in_zip_read_info->stream_initialised) | ||
1520 | inflateEnd(&pfile_in_zip_read_info->stream); | ||
1521 | |||
1522 | pfile_in_zip_read_info->stream_initialised = 0; | ||
1523 | TRYFREE(pfile_in_zip_read_info); | ||
1524 | |||
1525 | s->pfile_in_zip_read=NULL; | ||
1526 | |||
1527 | return err; | ||
1528 | } | ||
1529 | |||
1530 | |||
1531 | /* | ||
1532 | Get the global comment string of the ZipFile, in the szComment buffer. | ||
1533 | uSizeBuf is the size of the szComment buffer. | ||
1534 | return the number of byte copied or an error code <0 | ||
1535 | */ | ||
1536 | extern int ZEXPORT unzGetGlobalComment (file, szComment, uSizeBuf) | ||
1537 | unzFile file; | ||
1538 | char *szComment; | ||
1539 | uLong uSizeBuf; | ||
1540 | { | ||
1541 | unz_s* s; | ||
1542 | uLong uReadThis ; | ||
1543 | if (file==NULL) | ||
1544 | return UNZ_PARAMERROR; | ||
1545 | s=(unz_s*)file; | ||
1546 | |||
1547 | uReadThis = uSizeBuf; | ||
1548 | if (uReadThis>s->gi.size_comment) | ||
1549 | uReadThis = s->gi.size_comment; | ||
1550 | |||
1551 | if (ZSEEK(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0) | ||
1552 | return UNZ_ERRNO; | ||
1553 | |||
1554 | if (uReadThis>0) | ||
1555 | { | ||
1556 | *szComment='\0'; | ||
1557 | if (ZREAD(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis) | ||
1558 | return UNZ_ERRNO; | ||
1559 | } | ||
1560 | |||
1561 | if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment)) | ||
1562 | *(szComment+s->gi.size_comment)='\0'; | ||
1563 | return (int)uReadThis; | ||
1564 | } | ||
1565 | |||
1566 | /* Additions by RX '2004 */ | ||
1567 | extern uLong ZEXPORT unzGetOffset (file) | ||
1568 | unzFile file; | ||
1569 | { | ||
1570 | unz_s* s; | ||
1571 | |||
1572 | if (file==NULL) | ||
1573 | return UNZ_PARAMERROR; | ||
1574 | s=(unz_s*)file; | ||
1575 | if (!s->current_file_ok) | ||
1576 | return 0; | ||
1577 | if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff) | ||
1578 | if (s->num_file==s->gi.number_entry) | ||
1579 | return 0; | ||
1580 | return s->pos_in_central_dir; | ||
1581 | } | ||
1582 | |||
1583 | extern int ZEXPORT unzSetOffset (file, pos) | ||
1584 | unzFile file; | ||
1585 | uLong pos; | ||
1586 | { | ||
1587 | unz_s* s; | ||
1588 | int err; | ||
1589 | |||
1590 | if (file==NULL) | ||
1591 | return UNZ_PARAMERROR; | ||
1592 | s=(unz_s*)file; | ||
1593 | |||
1594 | s->pos_in_central_dir = pos; | ||
1595 | s->num_file = s->gi.number_entry; /* hack */ | ||
1596 | err = unzlocal_GetCurrentFileInfoInternal(file,&s->cur_file_info, | ||
1597 | &s->cur_file_info_internal, | ||
1598 | NULL,0,NULL,0,NULL,0); | ||
1599 | s->current_file_ok = (err == UNZ_OK); | ||
1600 | return err; | ||
1601 | } | ||
diff --git a/utils/themeeditor/quazip/unzip.h b/utils/themeeditor/quazip/unzip.h new file mode 100644 index 0000000000..b247937c80 --- /dev/null +++ b/utils/themeeditor/quazip/unzip.h | |||
@@ -0,0 +1,354 @@ | |||
1 | /* unzip.h -- IO for uncompress .zip files using zlib | ||
2 | Version 1.01e, February 12th, 2005 | ||
3 | |||
4 | Copyright (C) 1998-2005 Gilles Vollant | ||
5 | |||
6 | This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g | ||
7 | WinZip, InfoZip tools and compatible. | ||
8 | |||
9 | Multi volume ZipFile (span) are not supported. | ||
10 | Encryption compatible with pkzip 2.04g only supported | ||
11 | Old compressions used by old PKZip 1.x are not supported | ||
12 | |||
13 | |||
14 | I WAIT FEEDBACK at mail info@winimage.com | ||
15 | Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution | ||
16 | |||
17 | Condition of use and distribution are the same than zlib : | ||
18 | |||
19 | This software is provided 'as-is', without any express or implied | ||
20 | warranty. In no event will the authors be held liable for any damages | ||
21 | arising from the use of this software. | ||
22 | |||
23 | Permission is granted to anyone to use this software for any purpose, | ||
24 | including commercial applications, and to alter it and redistribute it | ||
25 | freely, subject to the following restrictions: | ||
26 | |||
27 | 1. The origin of this software must not be misrepresented; you must not | ||
28 | claim that you wrote the original software. If you use this software | ||
29 | in a product, an acknowledgment in the product documentation would be | ||
30 | appreciated but is not required. | ||
31 | 2. Altered source versions must be plainly marked as such, and must not be | ||
32 | misrepresented as being the original software. | ||
33 | 3. This notice may not be removed or altered from any source distribution. | ||
34 | |||
35 | |||
36 | */ | ||
37 | |||
38 | /* for more info about .ZIP format, see | ||
39 | http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip | ||
40 | http://www.info-zip.org/pub/infozip/doc/ | ||
41 | PkWare has also a specification at : | ||
42 | ftp://ftp.pkware.com/probdesc.zip | ||
43 | */ | ||
44 | |||
45 | #ifndef _unz_H | ||
46 | #define _unz_H | ||
47 | |||
48 | #ifdef __cplusplus | ||
49 | extern "C" { | ||
50 | #endif | ||
51 | |||
52 | #ifndef _ZLIB_H | ||
53 | #include "zlib.h" | ||
54 | #endif | ||
55 | |||
56 | #ifndef _ZLIBIOAPI_H | ||
57 | #include "ioapi.h" | ||
58 | #endif | ||
59 | |||
60 | #if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP) | ||
61 | /* like the STRICT of WIN32, we define a pointer that cannot be converted | ||
62 | from (void*) without cast */ | ||
63 | typedef struct TagunzFile__ { int unused; } unzFile__; | ||
64 | typedef unzFile__ *unzFile; | ||
65 | #else | ||
66 | typedef voidp unzFile; | ||
67 | #endif | ||
68 | |||
69 | |||
70 | #define UNZ_OK (0) | ||
71 | #define UNZ_END_OF_LIST_OF_FILE (-100) | ||
72 | #define UNZ_ERRNO (Z_ERRNO) | ||
73 | #define UNZ_EOF (0) | ||
74 | #define UNZ_PARAMERROR (-102) | ||
75 | #define UNZ_BADZIPFILE (-103) | ||
76 | #define UNZ_INTERNALERROR (-104) | ||
77 | #define UNZ_CRCERROR (-105) | ||
78 | |||
79 | /* tm_unz contain date/time info */ | ||
80 | typedef struct tm_unz_s | ||
81 | { | ||
82 | uInt tm_sec; /* seconds after the minute - [0,59] */ | ||
83 | uInt tm_min; /* minutes after the hour - [0,59] */ | ||
84 | uInt tm_hour; /* hours since midnight - [0,23] */ | ||
85 | uInt tm_mday; /* day of the month - [1,31] */ | ||
86 | uInt tm_mon; /* months since January - [0,11] */ | ||
87 | uInt tm_year; /* years - [1980..2044] */ | ||
88 | } tm_unz; | ||
89 | |||
90 | /* unz_global_info structure contain global data about the ZIPfile | ||
91 | These data comes from the end of central dir */ | ||
92 | typedef struct unz_global_info_s | ||
93 | { | ||
94 | uLong number_entry; /* total number of entries in | ||
95 | the central dir on this disk */ | ||
96 | uLong size_comment; /* size of the global comment of the zipfile */ | ||
97 | } unz_global_info; | ||
98 | |||
99 | |||
100 | /* unz_file_info contain information about a file in the zipfile */ | ||
101 | typedef struct unz_file_info_s | ||
102 | { | ||
103 | uLong version; /* version made by 2 bytes */ | ||
104 | uLong version_needed; /* version needed to extract 2 bytes */ | ||
105 | uLong flag; /* general purpose bit flag 2 bytes */ | ||
106 | uLong compression_method; /* compression method 2 bytes */ | ||
107 | uLong dosDate; /* last mod file date in Dos fmt 4 bytes */ | ||
108 | uLong crc; /* crc-32 4 bytes */ | ||
109 | uLong compressed_size; /* compressed size 4 bytes */ | ||
110 | uLong uncompressed_size; /* uncompressed size 4 bytes */ | ||
111 | uLong size_filename; /* filename length 2 bytes */ | ||
112 | uLong size_file_extra; /* extra field length 2 bytes */ | ||
113 | uLong size_file_comment; /* file comment length 2 bytes */ | ||
114 | |||
115 | uLong disk_num_start; /* disk number start 2 bytes */ | ||
116 | uLong internal_fa; /* internal file attributes 2 bytes */ | ||
117 | uLong external_fa; /* external file attributes 4 bytes */ | ||
118 | |||
119 | tm_unz tmu_date; | ||
120 | } unz_file_info; | ||
121 | |||
122 | extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1, | ||
123 | const char* fileName2, | ||
124 | int iCaseSensitivity)); | ||
125 | /* | ||
126 | Compare two filename (fileName1,fileName2). | ||
127 | If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp) | ||
128 | If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi | ||
129 | or strcasecmp) | ||
130 | If iCaseSenisivity = 0, case sensitivity is defaut of your operating system | ||
131 | (like 1 on Unix, 2 on Windows) | ||
132 | */ | ||
133 | |||
134 | |||
135 | extern unzFile ZEXPORT unzOpen OF((const char *path)); | ||
136 | /* | ||
137 | Open a Zip file. path contain the full pathname (by example, | ||
138 | on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer | ||
139 | "zlib/zlib113.zip". | ||
140 | If the zipfile cannot be opened (file don't exist or in not valid), the | ||
141 | return value is NULL. | ||
142 | Else, the return value is a unzFile Handle, usable with other function | ||
143 | of this unzip package. | ||
144 | */ | ||
145 | |||
146 | extern unzFile ZEXPORT unzOpen2 OF((const char *path, | ||
147 | zlib_filefunc_def* pzlib_filefunc_def)); | ||
148 | /* | ||
149 | Open a Zip file, like unzOpen, but provide a set of file low level API | ||
150 | for read/write the zip file (see ioapi.h) | ||
151 | */ | ||
152 | |||
153 | extern int ZEXPORT unzClose OF((unzFile file)); | ||
154 | /* | ||
155 | Close a ZipFile opened with unzipOpen. | ||
156 | If there is files inside the .Zip opened with unzOpenCurrentFile (see later), | ||
157 | these files MUST be closed with unzipCloseCurrentFile before call unzipClose. | ||
158 | return UNZ_OK if there is no problem. */ | ||
159 | |||
160 | extern int ZEXPORT unzGetGlobalInfo OF((unzFile file, | ||
161 | unz_global_info *pglobal_info)); | ||
162 | /* | ||
163 | Write info about the ZipFile in the *pglobal_info structure. | ||
164 | No preparation of the structure is needed | ||
165 | return UNZ_OK if there is no problem. */ | ||
166 | |||
167 | |||
168 | extern int ZEXPORT unzGetGlobalComment OF((unzFile file, | ||
169 | char *szComment, | ||
170 | uLong uSizeBuf)); | ||
171 | /* | ||
172 | Get the global comment string of the ZipFile, in the szComment buffer. | ||
173 | uSizeBuf is the size of the szComment buffer. | ||
174 | return the number of byte copied or an error code <0 | ||
175 | */ | ||
176 | |||
177 | |||
178 | /***************************************************************************/ | ||
179 | /* Unzip package allow you browse the directory of the zipfile */ | ||
180 | |||
181 | extern int ZEXPORT unzGoToFirstFile OF((unzFile file)); | ||
182 | /* | ||
183 | Set the current file of the zipfile to the first file. | ||
184 | return UNZ_OK if there is no problem | ||
185 | */ | ||
186 | |||
187 | extern int ZEXPORT unzGoToNextFile OF((unzFile file)); | ||
188 | /* | ||
189 | Set the current file of the zipfile to the next file. | ||
190 | return UNZ_OK if there is no problem | ||
191 | return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest. | ||
192 | */ | ||
193 | |||
194 | extern int ZEXPORT unzLocateFile OF((unzFile file, | ||
195 | const char *szFileName, | ||
196 | int iCaseSensitivity)); | ||
197 | /* | ||
198 | Try locate the file szFileName in the zipfile. | ||
199 | For the iCaseSensitivity signification, see unzStringFileNameCompare | ||
200 | |||
201 | return value : | ||
202 | UNZ_OK if the file is found. It becomes the current file. | ||
203 | UNZ_END_OF_LIST_OF_FILE if the file is not found | ||
204 | */ | ||
205 | |||
206 | |||
207 | /* ****************************************** */ | ||
208 | /* Ryan supplied functions */ | ||
209 | /* unz_file_info contain information about a file in the zipfile */ | ||
210 | typedef struct unz_file_pos_s | ||
211 | { | ||
212 | uLong pos_in_zip_directory; /* offset in zip file directory */ | ||
213 | uLong num_of_file; /* # of file */ | ||
214 | } unz_file_pos; | ||
215 | |||
216 | extern int ZEXPORT unzGetFilePos( | ||
217 | unzFile file, | ||
218 | unz_file_pos* file_pos); | ||
219 | |||
220 | extern int ZEXPORT unzGoToFilePos( | ||
221 | unzFile file, | ||
222 | unz_file_pos* file_pos); | ||
223 | |||
224 | /* ****************************************** */ | ||
225 | |||
226 | extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file, | ||
227 | unz_file_info *pfile_info, | ||
228 | char *szFileName, | ||
229 | uLong fileNameBufferSize, | ||
230 | void *extraField, | ||
231 | uLong extraFieldBufferSize, | ||
232 | char *szComment, | ||
233 | uLong commentBufferSize)); | ||
234 | /* | ||
235 | Get Info about the current file | ||
236 | if pfile_info!=NULL, the *pfile_info structure will contain somes info about | ||
237 | the current file | ||
238 | if szFileName!=NULL, the filemane string will be copied in szFileName | ||
239 | (fileNameBufferSize is the size of the buffer) | ||
240 | if extraField!=NULL, the extra field information will be copied in extraField | ||
241 | (extraFieldBufferSize is the size of the buffer). | ||
242 | This is the Central-header version of the extra field | ||
243 | if szComment!=NULL, the comment string of the file will be copied in szComment | ||
244 | (commentBufferSize is the size of the buffer) | ||
245 | */ | ||
246 | |||
247 | /***************************************************************************/ | ||
248 | /* for reading the content of the current zipfile, you can open it, read data | ||
249 | from it, and close it (you can close it before reading all the file) | ||
250 | */ | ||
251 | |||
252 | extern int ZEXPORT unzOpenCurrentFile OF((unzFile file)); | ||
253 | /* | ||
254 | Open for reading data the current file in the zipfile. | ||
255 | If there is no error, the return value is UNZ_OK. | ||
256 | */ | ||
257 | |||
258 | extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file, | ||
259 | const char* password)); | ||
260 | /* | ||
261 | Open for reading data the current file in the zipfile. | ||
262 | password is a crypting password | ||
263 | If there is no error, the return value is UNZ_OK. | ||
264 | */ | ||
265 | |||
266 | extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file, | ||
267 | int* method, | ||
268 | int* level, | ||
269 | int raw)); | ||
270 | /* | ||
271 | Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) | ||
272 | if raw==1 | ||
273 | *method will receive method of compression, *level will receive level of | ||
274 | compression | ||
275 | note : you can set level parameter as NULL (if you did not want known level, | ||
276 | but you CANNOT set method parameter as NULL | ||
277 | */ | ||
278 | |||
279 | extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file, | ||
280 | int* method, | ||
281 | int* level, | ||
282 | int raw, | ||
283 | const char* password)); | ||
284 | /* | ||
285 | Same than unzOpenCurrentFile, but open for read raw the file (not uncompress) | ||
286 | if raw==1 | ||
287 | *method will receive method of compression, *level will receive level of | ||
288 | compression | ||
289 | note : you can set level parameter as NULL (if you did not want known level, | ||
290 | but you CANNOT set method parameter as NULL | ||
291 | */ | ||
292 | |||
293 | |||
294 | extern int ZEXPORT unzCloseCurrentFile OF((unzFile file)); | ||
295 | /* | ||
296 | Close the file in zip opened with unzOpenCurrentFile | ||
297 | Return UNZ_CRCERROR if all the file was read but the CRC is not good | ||
298 | */ | ||
299 | |||
300 | extern int ZEXPORT unzReadCurrentFile OF((unzFile file, | ||
301 | voidp buf, | ||
302 | unsigned len)); | ||
303 | /* | ||
304 | Read bytes from the current file (opened by unzOpenCurrentFile) | ||
305 | buf contain buffer where data must be copied | ||
306 | len the size of buf. | ||
307 | |||
308 | return the number of byte copied if somes bytes are copied | ||
309 | return 0 if the end of file was reached | ||
310 | return <0 with error code if there is an error | ||
311 | (UNZ_ERRNO for IO error, or zLib error for uncompress error) | ||
312 | */ | ||
313 | |||
314 | extern z_off_t ZEXPORT unztell OF((unzFile file)); | ||
315 | /* | ||
316 | Give the current position in uncompressed data | ||
317 | */ | ||
318 | |||
319 | extern int ZEXPORT unzeof OF((unzFile file)); | ||
320 | /* | ||
321 | return 1 if the end of file was reached, 0 elsewhere | ||
322 | */ | ||
323 | |||
324 | extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file, | ||
325 | voidp buf, | ||
326 | unsigned len)); | ||
327 | /* | ||
328 | Read extra field from the current file (opened by unzOpenCurrentFile) | ||
329 | This is the local-header version of the extra field (sometimes, there is | ||
330 | more info in the local-header version than in the central-header) | ||
331 | |||
332 | if buf==NULL, it return the size of the local extra field | ||
333 | |||
334 | if buf!=NULL, len is the size of the buffer, the extra header is copied in | ||
335 | buf. | ||
336 | the return value is the number of bytes copied in buf, or (if <0) | ||
337 | the error code | ||
338 | */ | ||
339 | |||
340 | /***************************************************************************/ | ||
341 | |||
342 | /* Get the current file offset */ | ||
343 | extern uLong ZEXPORT unzGetOffset (unzFile file); | ||
344 | |||
345 | /* Set the current file offset */ | ||
346 | extern int ZEXPORT unzSetOffset (unzFile file, uLong pos); | ||
347 | |||
348 | |||
349 | |||
350 | #ifdef __cplusplus | ||
351 | } | ||
352 | #endif | ||
353 | |||
354 | #endif /* _unz_H */ | ||
diff --git a/utils/themeeditor/quazip/zip.c b/utils/themeeditor/quazip/zip.c new file mode 100644 index 0000000000..13463fe336 --- /dev/null +++ b/utils/themeeditor/quazip/zip.c | |||
@@ -0,0 +1,1221 @@ | |||
1 | /* zip.c -- IO on .zip files using zlib | ||
2 | Version 1.01e, February 12th, 2005 | ||
3 | |||
4 | 27 Dec 2004 Rolf Kalbermatter | ||
5 | Modification to zipOpen2 to support globalComment retrieval. | ||
6 | |||
7 | Copyright (C) 1998-2005 Gilles Vollant | ||
8 | |||
9 | Read zip.h for more info | ||
10 | */ | ||
11 | |||
12 | |||
13 | #include <stdio.h> | ||
14 | #include <stdlib.h> | ||
15 | #include <string.h> | ||
16 | #include <time.h> | ||
17 | #include "zlib.h" | ||
18 | #include "zip.h" | ||
19 | |||
20 | #ifdef STDC | ||
21 | # include <stddef.h> | ||
22 | # include <string.h> | ||
23 | # include <stdlib.h> | ||
24 | #endif | ||
25 | #ifdef NO_ERRNO_H | ||
26 | extern int errno; | ||
27 | #else | ||
28 | # include <errno.h> | ||
29 | #endif | ||
30 | |||
31 | |||
32 | #ifndef local | ||
33 | # define local static | ||
34 | #endif | ||
35 | /* compile with -Dlocal if your debugger can't find static symbols */ | ||
36 | |||
37 | #ifndef VERSIONMADEBY | ||
38 | # define VERSIONMADEBY (0x0) /* platform depedent */ | ||
39 | #endif | ||
40 | |||
41 | #ifndef Z_BUFSIZE | ||
42 | #define Z_BUFSIZE (16384) | ||
43 | #endif | ||
44 | |||
45 | #ifndef Z_MAXFILENAMEINZIP | ||
46 | #define Z_MAXFILENAMEINZIP (256) | ||
47 | #endif | ||
48 | |||
49 | #ifndef ALLOC | ||
50 | # define ALLOC(size) (malloc(size)) | ||
51 | #endif | ||
52 | #ifndef TRYFREE | ||
53 | # define TRYFREE(p) {if (p) free(p);} | ||
54 | #endif | ||
55 | |||
56 | /* | ||
57 | #define SIZECENTRALDIRITEM (0x2e) | ||
58 | #define SIZEZIPLOCALHEADER (0x1e) | ||
59 | */ | ||
60 | |||
61 | /* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */ | ||
62 | |||
63 | #ifndef SEEK_CUR | ||
64 | #define SEEK_CUR 1 | ||
65 | #endif | ||
66 | |||
67 | #ifndef SEEK_END | ||
68 | #define SEEK_END 2 | ||
69 | #endif | ||
70 | |||
71 | #ifndef SEEK_SET | ||
72 | #define SEEK_SET 0 | ||
73 | #endif | ||
74 | |||
75 | #ifndef DEF_MEM_LEVEL | ||
76 | #if MAX_MEM_LEVEL >= 8 | ||
77 | # define DEF_MEM_LEVEL 8 | ||
78 | #else | ||
79 | # define DEF_MEM_LEVEL MAX_MEM_LEVEL | ||
80 | #endif | ||
81 | #endif | ||
82 | const char zip_copyright[] = | ||
83 | " zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll"; | ||
84 | |||
85 | |||
86 | #define SIZEDATA_INDATABLOCK (4096-(4*4)) | ||
87 | |||
88 | #define LOCALHEADERMAGIC (0x04034b50) | ||
89 | #define CENTRALHEADERMAGIC (0x02014b50) | ||
90 | #define ENDHEADERMAGIC (0x06054b50) | ||
91 | |||
92 | #define FLAG_LOCALHEADER_OFFSET (0x06) | ||
93 | #define CRC_LOCALHEADER_OFFSET (0x0e) | ||
94 | |||
95 | #define SIZECENTRALHEADER (0x2e) /* 46 */ | ||
96 | |||
97 | typedef struct linkedlist_datablock_internal_s | ||
98 | { | ||
99 | struct linkedlist_datablock_internal_s* next_datablock; | ||
100 | uLong avail_in_this_block; | ||
101 | uLong filled_in_this_block; | ||
102 | uLong unused; /* for future use and alignement */ | ||
103 | unsigned char data[SIZEDATA_INDATABLOCK]; | ||
104 | } linkedlist_datablock_internal; | ||
105 | |||
106 | typedef struct linkedlist_data_s | ||
107 | { | ||
108 | linkedlist_datablock_internal* first_block; | ||
109 | linkedlist_datablock_internal* last_block; | ||
110 | } linkedlist_data; | ||
111 | |||
112 | |||
113 | typedef struct | ||
114 | { | ||
115 | z_stream stream; /* zLib stream structure for inflate */ | ||
116 | int stream_initialised; /* 1 is stream is initialised */ | ||
117 | uInt pos_in_buffered_data; /* last written byte in buffered_data */ | ||
118 | |||
119 | uLong pos_local_header; /* offset of the local header of the file | ||
120 | currenty writing */ | ||
121 | char* central_header; /* central header data for the current file */ | ||
122 | uLong size_centralheader; /* size of the central header for cur file */ | ||
123 | uLong flag; /* flag of the file currently writing */ | ||
124 | |||
125 | int method; /* compression method of file currenty wr.*/ | ||
126 | int raw; /* 1 for directly writing raw data */ | ||
127 | Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/ | ||
128 | uLong dosDate; | ||
129 | uLong crc32; | ||
130 | int encrypt; | ||
131 | #ifndef NOCRYPT | ||
132 | unsigned long keys[3]; /* keys defining the pseudo-random sequence */ | ||
133 | const unsigned long* pcrc_32_tab; | ||
134 | int crypt_header_size; | ||
135 | #endif | ||
136 | } curfile_info; | ||
137 | |||
138 | typedef struct | ||
139 | { | ||
140 | zlib_filefunc_def z_filefunc; | ||
141 | voidpf filestream; /* io structore of the zipfile */ | ||
142 | linkedlist_data central_dir;/* datablock with central dir in construction*/ | ||
143 | int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/ | ||
144 | curfile_info ci; /* info on the file curretly writing */ | ||
145 | |||
146 | uLong begin_pos; /* position of the beginning of the zipfile */ | ||
147 | uLong add_position_when_writting_offset; | ||
148 | uLong number_entry; | ||
149 | #ifndef NO_ADDFILEINEXISTINGZIP | ||
150 | char *globalcomment; | ||
151 | #endif | ||
152 | } zip_internal; | ||
153 | |||
154 | |||
155 | |||
156 | #ifndef NOCRYPT | ||
157 | #define INCLUDECRYPTINGCODE_IFCRYPTALLOWED | ||
158 | #include "crypt.h" | ||
159 | #endif | ||
160 | |||
161 | local linkedlist_datablock_internal* allocate_new_datablock() | ||
162 | { | ||
163 | linkedlist_datablock_internal* ldi; | ||
164 | ldi = (linkedlist_datablock_internal*) | ||
165 | ALLOC(sizeof(linkedlist_datablock_internal)); | ||
166 | if (ldi!=NULL) | ||
167 | { | ||
168 | ldi->next_datablock = NULL ; | ||
169 | ldi->filled_in_this_block = 0 ; | ||
170 | ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ; | ||
171 | } | ||
172 | return ldi; | ||
173 | } | ||
174 | |||
175 | local void free_datablock(ldi) | ||
176 | linkedlist_datablock_internal* ldi; | ||
177 | { | ||
178 | while (ldi!=NULL) | ||
179 | { | ||
180 | linkedlist_datablock_internal* ldinext = ldi->next_datablock; | ||
181 | TRYFREE(ldi); | ||
182 | ldi = ldinext; | ||
183 | } | ||
184 | } | ||
185 | |||
186 | local void init_linkedlist(ll) | ||
187 | linkedlist_data* ll; | ||
188 | { | ||
189 | ll->first_block = ll->last_block = NULL; | ||
190 | } | ||
191 | |||
192 | #if 0 // unused | ||
193 | local void free_linkedlist(ll) | ||
194 | linkedlist_data* ll; | ||
195 | { | ||
196 | free_datablock(ll->first_block); | ||
197 | ll->first_block = ll->last_block = NULL; | ||
198 | } | ||
199 | #endif | ||
200 | |||
201 | local int add_data_in_datablock(ll,buf,len) | ||
202 | linkedlist_data* ll; | ||
203 | const void* buf; | ||
204 | uLong len; | ||
205 | { | ||
206 | linkedlist_datablock_internal* ldi; | ||
207 | const unsigned char* from_copy; | ||
208 | |||
209 | if (ll==NULL) | ||
210 | return ZIP_INTERNALERROR; | ||
211 | |||
212 | if (ll->last_block == NULL) | ||
213 | { | ||
214 | ll->first_block = ll->last_block = allocate_new_datablock(); | ||
215 | if (ll->first_block == NULL) | ||
216 | return ZIP_INTERNALERROR; | ||
217 | } | ||
218 | |||
219 | ldi = ll->last_block; | ||
220 | from_copy = (unsigned char*)buf; | ||
221 | |||
222 | while (len>0) | ||
223 | { | ||
224 | uInt copy_this; | ||
225 | uInt i; | ||
226 | unsigned char* to_copy; | ||
227 | |||
228 | if (ldi->avail_in_this_block==0) | ||
229 | { | ||
230 | ldi->next_datablock = allocate_new_datablock(); | ||
231 | if (ldi->next_datablock == NULL) | ||
232 | return ZIP_INTERNALERROR; | ||
233 | ldi = ldi->next_datablock ; | ||
234 | ll->last_block = ldi; | ||
235 | } | ||
236 | |||
237 | if (ldi->avail_in_this_block < len) | ||
238 | copy_this = (uInt)ldi->avail_in_this_block; | ||
239 | else | ||
240 | copy_this = (uInt)len; | ||
241 | |||
242 | to_copy = &(ldi->data[ldi->filled_in_this_block]); | ||
243 | |||
244 | for (i=0;i<copy_this;i++) | ||
245 | *(to_copy+i)=*(from_copy+i); | ||
246 | |||
247 | ldi->filled_in_this_block += copy_this; | ||
248 | ldi->avail_in_this_block -= copy_this; | ||
249 | from_copy += copy_this ; | ||
250 | len -= copy_this; | ||
251 | } | ||
252 | return ZIP_OK; | ||
253 | } | ||
254 | |||
255 | |||
256 | |||
257 | /****************************************************************************/ | ||
258 | |||
259 | #ifndef NO_ADDFILEINEXISTINGZIP | ||
260 | /* =========================================================================== | ||
261 | Inputs a long in LSB order to the given file | ||
262 | nbByte == 1, 2 or 4 (byte, short or long) | ||
263 | */ | ||
264 | |||
265 | local int ziplocal_putValue OF((const zlib_filefunc_def* pzlib_filefunc_def, | ||
266 | voidpf filestream, uLong x, int nbByte)); | ||
267 | local int ziplocal_putValue (pzlib_filefunc_def, filestream, x, nbByte) | ||
268 | const zlib_filefunc_def* pzlib_filefunc_def; | ||
269 | voidpf filestream; | ||
270 | uLong x; | ||
271 | int nbByte; | ||
272 | { | ||
273 | unsigned char buf[4]; | ||
274 | int n; | ||
275 | for (n = 0; n < nbByte; n++) | ||
276 | { | ||
277 | buf[n] = (unsigned char)(x & 0xff); | ||
278 | x >>= 8; | ||
279 | } | ||
280 | if (x != 0) | ||
281 | { /* data overflow - hack for ZIP64 (X Roche) */ | ||
282 | for (n = 0; n < nbByte; n++) | ||
283 | { | ||
284 | buf[n] = 0xff; | ||
285 | } | ||
286 | } | ||
287 | |||
288 | if (ZWRITE(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte) | ||
289 | return ZIP_ERRNO; | ||
290 | else | ||
291 | return ZIP_OK; | ||
292 | } | ||
293 | |||
294 | local void ziplocal_putValue_inmemory OF((void* dest, uLong x, int nbByte)); | ||
295 | local void ziplocal_putValue_inmemory (dest, x, nbByte) | ||
296 | void* dest; | ||
297 | uLong x; | ||
298 | int nbByte; | ||
299 | { | ||
300 | unsigned char* buf=(unsigned char*)dest; | ||
301 | int n; | ||
302 | for (n = 0; n < nbByte; n++) { | ||
303 | buf[n] = (unsigned char)(x & 0xff); | ||
304 | x >>= 8; | ||
305 | } | ||
306 | |||
307 | if (x != 0) | ||
308 | { /* data overflow - hack for ZIP64 */ | ||
309 | for (n = 0; n < nbByte; n++) | ||
310 | { | ||
311 | buf[n] = 0xff; | ||
312 | } | ||
313 | } | ||
314 | } | ||
315 | |||
316 | /****************************************************************************/ | ||
317 | |||
318 | |||
319 | local uLong ziplocal_TmzDateToDosDate(ptm,dosDate) | ||
320 | const tm_zip* ptm; | ||
321 | uLong dosDate; | ||
322 | { | ||
323 | (void) dosDate; /* avoid "unused parameter" warning */ | ||
324 | uLong year = (uLong)ptm->tm_year; | ||
325 | if (year>1980) | ||
326 | year-=1980; | ||
327 | else if (year>80) | ||
328 | year-=80; | ||
329 | return | ||
330 | (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) | | ||
331 | ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour)); | ||
332 | } | ||
333 | |||
334 | |||
335 | /****************************************************************************/ | ||
336 | |||
337 | local int ziplocal_getByte OF(( | ||
338 | const zlib_filefunc_def* pzlib_filefunc_def, | ||
339 | voidpf filestream, | ||
340 | int *pi)); | ||
341 | |||
342 | local int ziplocal_getByte(pzlib_filefunc_def,filestream,pi) | ||
343 | const zlib_filefunc_def* pzlib_filefunc_def; | ||
344 | voidpf filestream; | ||
345 | int *pi; | ||
346 | { | ||
347 | unsigned char c; | ||
348 | int err = (int)ZREAD(*pzlib_filefunc_def,filestream,&c,1); | ||
349 | if (err==1) | ||
350 | { | ||
351 | *pi = (int)c; | ||
352 | return ZIP_OK; | ||
353 | } | ||
354 | else | ||
355 | { | ||
356 | if (ZERROR(*pzlib_filefunc_def,filestream)) | ||
357 | return ZIP_ERRNO; | ||
358 | else | ||
359 | return ZIP_EOF; | ||
360 | } | ||
361 | } | ||
362 | |||
363 | |||
364 | /* =========================================================================== | ||
365 | Reads a long in LSB order from the given gz_stream. Sets | ||
366 | */ | ||
367 | local int ziplocal_getShort OF(( | ||
368 | const zlib_filefunc_def* pzlib_filefunc_def, | ||
369 | voidpf filestream, | ||
370 | uLong *pX)); | ||
371 | |||
372 | local int ziplocal_getShort (pzlib_filefunc_def,filestream,pX) | ||
373 | const zlib_filefunc_def* pzlib_filefunc_def; | ||
374 | voidpf filestream; | ||
375 | uLong *pX; | ||
376 | { | ||
377 | uLong x ; | ||
378 | int i; | ||
379 | int err; | ||
380 | |||
381 | err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); | ||
382 | x = (uLong)i; | ||
383 | |||
384 | if (err==ZIP_OK) | ||
385 | err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); | ||
386 | x += ((uLong)i)<<8; | ||
387 | |||
388 | if (err==ZIP_OK) | ||
389 | *pX = x; | ||
390 | else | ||
391 | *pX = 0; | ||
392 | return err; | ||
393 | } | ||
394 | |||
395 | local int ziplocal_getLong OF(( | ||
396 | const zlib_filefunc_def* pzlib_filefunc_def, | ||
397 | voidpf filestream, | ||
398 | uLong *pX)); | ||
399 | |||
400 | local int ziplocal_getLong (pzlib_filefunc_def,filestream,pX) | ||
401 | const zlib_filefunc_def* pzlib_filefunc_def; | ||
402 | voidpf filestream; | ||
403 | uLong *pX; | ||
404 | { | ||
405 | uLong x ; | ||
406 | int i; | ||
407 | int err; | ||
408 | |||
409 | err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); | ||
410 | x = (uLong)i; | ||
411 | |||
412 | if (err==ZIP_OK) | ||
413 | err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); | ||
414 | x += ((uLong)i)<<8; | ||
415 | |||
416 | if (err==ZIP_OK) | ||
417 | err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); | ||
418 | x += ((uLong)i)<<16; | ||
419 | |||
420 | if (err==ZIP_OK) | ||
421 | err = ziplocal_getByte(pzlib_filefunc_def,filestream,&i); | ||
422 | x += ((uLong)i)<<24; | ||
423 | |||
424 | if (err==ZIP_OK) | ||
425 | *pX = x; | ||
426 | else | ||
427 | *pX = 0; | ||
428 | return err; | ||
429 | } | ||
430 | |||
431 | #ifndef BUFREADCOMMENT | ||
432 | #define BUFREADCOMMENT (0x400) | ||
433 | #endif | ||
434 | /* | ||
435 | Locate the Central directory of a zipfile (at the end, just before | ||
436 | the global comment) | ||
437 | */ | ||
438 | local uLong ziplocal_SearchCentralDir OF(( | ||
439 | const zlib_filefunc_def* pzlib_filefunc_def, | ||
440 | voidpf filestream)); | ||
441 | |||
442 | local uLong ziplocal_SearchCentralDir(pzlib_filefunc_def,filestream) | ||
443 | const zlib_filefunc_def* pzlib_filefunc_def; | ||
444 | voidpf filestream; | ||
445 | { | ||
446 | unsigned char* buf; | ||
447 | uLong uSizeFile; | ||
448 | uLong uBackRead; | ||
449 | uLong uMaxBack=0xffff; /* maximum size of global comment */ | ||
450 | uLong uPosFound=0; | ||
451 | |||
452 | if (ZSEEK(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0) | ||
453 | return 0; | ||
454 | |||
455 | |||
456 | uSizeFile = ZTELL(*pzlib_filefunc_def,filestream); | ||
457 | |||
458 | if (uMaxBack>uSizeFile) | ||
459 | uMaxBack = uSizeFile; | ||
460 | |||
461 | buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4); | ||
462 | if (buf==NULL) | ||
463 | return 0; | ||
464 | |||
465 | uBackRead = 4; | ||
466 | while (uBackRead<uMaxBack) | ||
467 | { | ||
468 | uLong uReadSize,uReadPos ; | ||
469 | int i; | ||
470 | if (uBackRead+BUFREADCOMMENT>uMaxBack) | ||
471 | uBackRead = uMaxBack; | ||
472 | else | ||
473 | uBackRead+=BUFREADCOMMENT; | ||
474 | uReadPos = uSizeFile-uBackRead ; | ||
475 | |||
476 | uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ? | ||
477 | (BUFREADCOMMENT+4) : (uSizeFile-uReadPos); | ||
478 | if (ZSEEK(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0) | ||
479 | break; | ||
480 | |||
481 | if (ZREAD(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize) | ||
482 | break; | ||
483 | |||
484 | for (i=(int)uReadSize-3; (i--)>0;) | ||
485 | if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && | ||
486 | ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06)) | ||
487 | { | ||
488 | uPosFound = uReadPos+i; | ||
489 | break; | ||
490 | } | ||
491 | |||
492 | if (uPosFound!=0) | ||
493 | break; | ||
494 | } | ||
495 | TRYFREE(buf); | ||
496 | return uPosFound; | ||
497 | } | ||
498 | #endif /* !NO_ADDFILEINEXISTINGZIP*/ | ||
499 | |||
500 | /************************************************************/ | ||
501 | extern zipFile ZEXPORT zipOpen2 (pathname, append, globalcomment, pzlib_filefunc_def) | ||
502 | const char *pathname; | ||
503 | int append; | ||
504 | zipcharpc* globalcomment; | ||
505 | zlib_filefunc_def* pzlib_filefunc_def; | ||
506 | { | ||
507 | zip_internal ziinit; | ||
508 | zip_internal* zi; | ||
509 | int err=ZIP_OK; | ||
510 | |||
511 | |||
512 | if (pzlib_filefunc_def==NULL) | ||
513 | fill_fopen_filefunc(&ziinit.z_filefunc); | ||
514 | else | ||
515 | ziinit.z_filefunc = *pzlib_filefunc_def; | ||
516 | |||
517 | ziinit.filestream = (*(ziinit.z_filefunc.zopen_file)) | ||
518 | (ziinit.z_filefunc.opaque, | ||
519 | pathname, | ||
520 | (append == APPEND_STATUS_CREATE) ? | ||
521 | (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) : | ||
522 | (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING)); | ||
523 | |||
524 | if (ziinit.filestream == NULL) | ||
525 | return NULL; | ||
526 | ziinit.begin_pos = ZTELL(ziinit.z_filefunc,ziinit.filestream); | ||
527 | ziinit.in_opened_file_inzip = 0; | ||
528 | ziinit.ci.stream_initialised = 0; | ||
529 | ziinit.number_entry = 0; | ||
530 | ziinit.add_position_when_writting_offset = 0; | ||
531 | init_linkedlist(&(ziinit.central_dir)); | ||
532 | |||
533 | |||
534 | zi = (zip_internal*)ALLOC(sizeof(zip_internal)); | ||
535 | if (zi==NULL) | ||
536 | { | ||
537 | ZCLOSE(ziinit.z_filefunc,ziinit.filestream); | ||
538 | return NULL; | ||
539 | } | ||
540 | |||
541 | /* now we add file in a zipfile */ | ||
542 | # ifndef NO_ADDFILEINEXISTINGZIP | ||
543 | ziinit.globalcomment = NULL; | ||
544 | if (append == APPEND_STATUS_ADDINZIP) | ||
545 | { | ||
546 | uLong byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/ | ||
547 | |||
548 | uLong size_central_dir; /* size of the central directory */ | ||
549 | uLong offset_central_dir; /* offset of start of central directory */ | ||
550 | uLong central_pos,uL; | ||
551 | |||
552 | uLong number_disk; /* number of the current dist, used for | ||
553 | spaning ZIP, unsupported, always 0*/ | ||
554 | uLong number_disk_with_CD; /* number the the disk with central dir, used | ||
555 | for spaning ZIP, unsupported, always 0*/ | ||
556 | uLong number_entry; | ||
557 | uLong number_entry_CD; /* total number of entries in | ||
558 | the central dir | ||
559 | (same than number_entry on nospan) */ | ||
560 | uLong size_comment; | ||
561 | |||
562 | central_pos = ziplocal_SearchCentralDir(&ziinit.z_filefunc,ziinit.filestream); | ||
563 | if (central_pos==0) | ||
564 | err=ZIP_ERRNO; | ||
565 | |||
566 | if (ZSEEK(ziinit.z_filefunc, ziinit.filestream, | ||
567 | central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0) | ||
568 | err=ZIP_ERRNO; | ||
569 | |||
570 | /* the signature, already checked */ | ||
571 | if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&uL)!=ZIP_OK) | ||
572 | err=ZIP_ERRNO; | ||
573 | |||
574 | /* number of this disk */ | ||
575 | if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk)!=ZIP_OK) | ||
576 | err=ZIP_ERRNO; | ||
577 | |||
578 | /* number of the disk with the start of the central directory */ | ||
579 | if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_disk_with_CD)!=ZIP_OK) | ||
580 | err=ZIP_ERRNO; | ||
581 | |||
582 | /* total number of entries in the central dir on this disk */ | ||
583 | if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry)!=ZIP_OK) | ||
584 | err=ZIP_ERRNO; | ||
585 | |||
586 | /* total number of entries in the central dir */ | ||
587 | if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&number_entry_CD)!=ZIP_OK) | ||
588 | err=ZIP_ERRNO; | ||
589 | |||
590 | if ((number_entry_CD!=number_entry) || | ||
591 | (number_disk_with_CD!=0) || | ||
592 | (number_disk!=0)) | ||
593 | err=ZIP_BADZIPFILE; | ||
594 | |||
595 | /* size of the central directory */ | ||
596 | if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&size_central_dir)!=ZIP_OK) | ||
597 | err=ZIP_ERRNO; | ||
598 | |||
599 | /* offset of start of central directory with respect to the | ||
600 | starting disk number */ | ||
601 | if (ziplocal_getLong(&ziinit.z_filefunc, ziinit.filestream,&offset_central_dir)!=ZIP_OK) | ||
602 | err=ZIP_ERRNO; | ||
603 | |||
604 | /* zipfile global comment length */ | ||
605 | if (ziplocal_getShort(&ziinit.z_filefunc, ziinit.filestream,&size_comment)!=ZIP_OK) | ||
606 | err=ZIP_ERRNO; | ||
607 | |||
608 | if ((central_pos<offset_central_dir+size_central_dir) && | ||
609 | (err==ZIP_OK)) | ||
610 | err=ZIP_BADZIPFILE; | ||
611 | |||
612 | if (err!=ZIP_OK) | ||
613 | { | ||
614 | ZCLOSE(ziinit.z_filefunc, ziinit.filestream); | ||
615 | return NULL; | ||
616 | } | ||
617 | |||
618 | if (size_comment>0) | ||
619 | { | ||
620 | ziinit.globalcomment = ALLOC(size_comment+1); | ||
621 | if (ziinit.globalcomment) | ||
622 | { | ||
623 | size_comment = ZREAD(ziinit.z_filefunc, ziinit.filestream,ziinit.globalcomment,size_comment); | ||
624 | ziinit.globalcomment[size_comment]=0; | ||
625 | } | ||
626 | } | ||
627 | |||
628 | byte_before_the_zipfile = central_pos - | ||
629 | (offset_central_dir+size_central_dir); | ||
630 | ziinit.add_position_when_writting_offset = byte_before_the_zipfile; | ||
631 | |||
632 | { | ||
633 | uLong size_central_dir_to_read = size_central_dir; | ||
634 | size_t buf_size = SIZEDATA_INDATABLOCK; | ||
635 | void* buf_read = (void*)ALLOC(buf_size); | ||
636 | if (ZSEEK(ziinit.z_filefunc, ziinit.filestream, | ||
637 | offset_central_dir + byte_before_the_zipfile, | ||
638 | ZLIB_FILEFUNC_SEEK_SET) != 0) | ||
639 | err=ZIP_ERRNO; | ||
640 | |||
641 | while ((size_central_dir_to_read>0) && (err==ZIP_OK)) | ||
642 | { | ||
643 | uLong read_this = SIZEDATA_INDATABLOCK; | ||
644 | if (read_this > size_central_dir_to_read) | ||
645 | read_this = size_central_dir_to_read; | ||
646 | if (ZREAD(ziinit.z_filefunc, ziinit.filestream,buf_read,read_this) != read_this) | ||
647 | err=ZIP_ERRNO; | ||
648 | |||
649 | if (err==ZIP_OK) | ||
650 | err = add_data_in_datablock(&ziinit.central_dir,buf_read, | ||
651 | (uLong)read_this); | ||
652 | size_central_dir_to_read-=read_this; | ||
653 | } | ||
654 | TRYFREE(buf_read); | ||
655 | } | ||
656 | ziinit.begin_pos = byte_before_the_zipfile; | ||
657 | ziinit.number_entry = number_entry_CD; | ||
658 | |||
659 | if (ZSEEK(ziinit.z_filefunc, ziinit.filestream, | ||
660 | offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0) | ||
661 | err=ZIP_ERRNO; | ||
662 | } | ||
663 | |||
664 | if (globalcomment) | ||
665 | { | ||
666 | *globalcomment = ziinit.globalcomment; | ||
667 | } | ||
668 | # endif /* !NO_ADDFILEINEXISTINGZIP*/ | ||
669 | |||
670 | if (err != ZIP_OK) | ||
671 | { | ||
672 | # ifndef NO_ADDFILEINEXISTINGZIP | ||
673 | TRYFREE(ziinit.globalcomment); | ||
674 | # endif /* !NO_ADDFILEINEXISTINGZIP*/ | ||
675 | TRYFREE(zi); | ||
676 | return NULL; | ||
677 | } | ||
678 | else | ||
679 | { | ||
680 | *zi = ziinit; | ||
681 | return (zipFile)zi; | ||
682 | } | ||
683 | } | ||
684 | |||
685 | extern zipFile ZEXPORT zipOpen (pathname, append) | ||
686 | const char *pathname; | ||
687 | int append; | ||
688 | { | ||
689 | return zipOpen2(pathname,append,NULL,NULL); | ||
690 | } | ||
691 | |||
692 | extern int ZEXPORT zipOpenNewFileInZip3 (file, filename, zipfi, | ||
693 | extrafield_local, size_extrafield_local, | ||
694 | extrafield_global, size_extrafield_global, | ||
695 | comment, method, level, raw, | ||
696 | windowBits, memLevel, strategy, | ||
697 | password, crcForCrypting) | ||
698 | zipFile file; | ||
699 | const char* filename; | ||
700 | const zip_fileinfo* zipfi; | ||
701 | const void* extrafield_local; | ||
702 | uInt size_extrafield_local; | ||
703 | const void* extrafield_global; | ||
704 | uInt size_extrafield_global; | ||
705 | const char* comment; | ||
706 | int method; | ||
707 | int level; | ||
708 | int raw; | ||
709 | int windowBits; | ||
710 | int memLevel; | ||
711 | int strategy; | ||
712 | const char* password; | ||
713 | uLong crcForCrypting; | ||
714 | { | ||
715 | zip_internal* zi; | ||
716 | uInt size_filename; | ||
717 | uInt size_comment; | ||
718 | uInt i; | ||
719 | int err = ZIP_OK; | ||
720 | |||
721 | # ifdef NOCRYPT | ||
722 | if (password != NULL) | ||
723 | return ZIP_PARAMERROR; | ||
724 | # endif | ||
725 | |||
726 | if (file == NULL) | ||
727 | return ZIP_PARAMERROR; | ||
728 | if ((method!=0) && (method!=Z_DEFLATED)) | ||
729 | return ZIP_PARAMERROR; | ||
730 | |||
731 | zi = (zip_internal*)file; | ||
732 | |||
733 | if (zi->in_opened_file_inzip == 1) | ||
734 | { | ||
735 | err = zipCloseFileInZip (file); | ||
736 | if (err != ZIP_OK) | ||
737 | return err; | ||
738 | } | ||
739 | |||
740 | |||
741 | if (filename==NULL) | ||
742 | filename="-"; | ||
743 | |||
744 | if (comment==NULL) | ||
745 | size_comment = 0; | ||
746 | else | ||
747 | size_comment = (uInt)strlen(comment); | ||
748 | |||
749 | size_filename = (uInt)strlen(filename); | ||
750 | |||
751 | if (zipfi == NULL) | ||
752 | zi->ci.dosDate = 0; | ||
753 | else | ||
754 | { | ||
755 | if (zipfi->dosDate != 0) | ||
756 | zi->ci.dosDate = zipfi->dosDate; | ||
757 | else zi->ci.dosDate = ziplocal_TmzDateToDosDate(&zipfi->tmz_date,zipfi->dosDate); | ||
758 | } | ||
759 | |||
760 | zi->ci.flag = 0; | ||
761 | if ((level==8) || (level==9)) | ||
762 | zi->ci.flag |= 2; | ||
763 | if ((level==2)) | ||
764 | zi->ci.flag |= 4; | ||
765 | if ((level==1)) | ||
766 | zi->ci.flag |= 6; | ||
767 | if (password != NULL) | ||
768 | zi->ci.flag |= 1; | ||
769 | |||
770 | zi->ci.crc32 = 0; | ||
771 | zi->ci.method = method; | ||
772 | zi->ci.encrypt = 0; | ||
773 | zi->ci.stream_initialised = 0; | ||
774 | zi->ci.pos_in_buffered_data = 0; | ||
775 | zi->ci.raw = raw; | ||
776 | zi->ci.pos_local_header = ZTELL(zi->z_filefunc,zi->filestream) ; | ||
777 | zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + | ||
778 | size_extrafield_global + size_comment; | ||
779 | zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader); | ||
780 | |||
781 | ziplocal_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4); | ||
782 | /* version info */ | ||
783 | ziplocal_putValue_inmemory(zi->ci.central_header+4,(uLong)VERSIONMADEBY,2); | ||
784 | ziplocal_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2); | ||
785 | ziplocal_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2); | ||
786 | ziplocal_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2); | ||
787 | ziplocal_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4); | ||
788 | ziplocal_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/ | ||
789 | ziplocal_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/ | ||
790 | ziplocal_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/ | ||
791 | ziplocal_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2); | ||
792 | ziplocal_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2); | ||
793 | ziplocal_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2); | ||
794 | ziplocal_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/ | ||
795 | |||
796 | if (zipfi==NULL) | ||
797 | ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2); | ||
798 | else | ||
799 | ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2); | ||
800 | |||
801 | if (zipfi==NULL) | ||
802 | ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4); | ||
803 | else | ||
804 | ziplocal_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4); | ||
805 | |||
806 | ziplocal_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header- zi->add_position_when_writting_offset,4); | ||
807 | |||
808 | for (i=0;i<size_filename;i++) | ||
809 | *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i); | ||
810 | |||
811 | for (i=0;i<size_extrafield_global;i++) | ||
812 | *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) = | ||
813 | *(((const char*)extrafield_global)+i); | ||
814 | |||
815 | for (i=0;i<size_comment;i++) | ||
816 | *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+ | ||
817 | size_extrafield_global+i) = *(comment+i); | ||
818 | if (zi->ci.central_header == NULL) | ||
819 | return ZIP_INTERNALERROR; | ||
820 | |||
821 | /* write the local header */ | ||
822 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC,4); | ||
823 | |||
824 | if (err==ZIP_OK) | ||
825 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */ | ||
826 | if (err==ZIP_OK) | ||
827 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2); | ||
828 | |||
829 | if (err==ZIP_OK) | ||
830 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2); | ||
831 | |||
832 | if (err==ZIP_OK) | ||
833 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4); | ||
834 | |||
835 | if (err==ZIP_OK) | ||
836 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */ | ||
837 | if (err==ZIP_OK) | ||
838 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */ | ||
839 | if (err==ZIP_OK) | ||
840 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */ | ||
841 | |||
842 | if (err==ZIP_OK) | ||
843 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2); | ||
844 | |||
845 | if (err==ZIP_OK) | ||
846 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield_local,2); | ||
847 | |||
848 | if ((err==ZIP_OK) && (size_filename>0)) | ||
849 | if (ZWRITE(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename) | ||
850 | err = ZIP_ERRNO; | ||
851 | |||
852 | if ((err==ZIP_OK) && (size_extrafield_local>0)) | ||
853 | if (ZWRITE(zi->z_filefunc,zi->filestream,extrafield_local,size_extrafield_local) | ||
854 | !=size_extrafield_local) | ||
855 | err = ZIP_ERRNO; | ||
856 | |||
857 | zi->ci.stream.avail_in = (uInt)0; | ||
858 | zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; | ||
859 | zi->ci.stream.next_out = zi->ci.buffered_data; | ||
860 | zi->ci.stream.total_in = 0; | ||
861 | zi->ci.stream.total_out = 0; | ||
862 | |||
863 | if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) | ||
864 | { | ||
865 | zi->ci.stream.zalloc = (alloc_func)0; | ||
866 | zi->ci.stream.zfree = (free_func)0; | ||
867 | zi->ci.stream.opaque = (voidpf)0; | ||
868 | |||
869 | if (windowBits>0) | ||
870 | windowBits = -windowBits; | ||
871 | |||
872 | err = deflateInit2(&zi->ci.stream, level, | ||
873 | Z_DEFLATED, windowBits, memLevel, strategy); | ||
874 | |||
875 | if (err==Z_OK) | ||
876 | zi->ci.stream_initialised = 1; | ||
877 | } | ||
878 | # ifndef NOCRYPT | ||
879 | zi->ci.crypt_header_size = 0; | ||
880 | if ((err==Z_OK) && (password != NULL)) | ||
881 | { | ||
882 | unsigned char bufHead[RAND_HEAD_LEN]; | ||
883 | unsigned int sizeHead; | ||
884 | zi->ci.encrypt = 1; | ||
885 | zi->ci.pcrc_32_tab = get_crc_table(); | ||
886 | /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/ | ||
887 | |||
888 | sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting); | ||
889 | zi->ci.crypt_header_size = sizeHead; | ||
890 | |||
891 | if (ZWRITE(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead) | ||
892 | err = ZIP_ERRNO; | ||
893 | } | ||
894 | # endif | ||
895 | |||
896 | if (err==Z_OK) | ||
897 | zi->in_opened_file_inzip = 1; | ||
898 | return err; | ||
899 | } | ||
900 | |||
901 | extern int ZEXPORT zipOpenNewFileInZip2(file, filename, zipfi, | ||
902 | extrafield_local, size_extrafield_local, | ||
903 | extrafield_global, size_extrafield_global, | ||
904 | comment, method, level, raw) | ||
905 | zipFile file; | ||
906 | const char* filename; | ||
907 | const zip_fileinfo* zipfi; | ||
908 | const void* extrafield_local; | ||
909 | uInt size_extrafield_local; | ||
910 | const void* extrafield_global; | ||
911 | uInt size_extrafield_global; | ||
912 | const char* comment; | ||
913 | int method; | ||
914 | int level; | ||
915 | int raw; | ||
916 | { | ||
917 | return zipOpenNewFileInZip3 (file, filename, zipfi, | ||
918 | extrafield_local, size_extrafield_local, | ||
919 | extrafield_global, size_extrafield_global, | ||
920 | comment, method, level, raw, | ||
921 | -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, | ||
922 | NULL, 0); | ||
923 | } | ||
924 | |||
925 | extern int ZEXPORT zipOpenNewFileInZip (file, filename, zipfi, | ||
926 | extrafield_local, size_extrafield_local, | ||
927 | extrafield_global, size_extrafield_global, | ||
928 | comment, method, level) | ||
929 | zipFile file; | ||
930 | const char* filename; | ||
931 | const zip_fileinfo* zipfi; | ||
932 | const void* extrafield_local; | ||
933 | uInt size_extrafield_local; | ||
934 | const void* extrafield_global; | ||
935 | uInt size_extrafield_global; | ||
936 | const char* comment; | ||
937 | int method; | ||
938 | int level; | ||
939 | { | ||
940 | return zipOpenNewFileInZip2 (file, filename, zipfi, | ||
941 | extrafield_local, size_extrafield_local, | ||
942 | extrafield_global, size_extrafield_global, | ||
943 | comment, method, level, 0); | ||
944 | } | ||
945 | |||
946 | local int zipFlushWriteBuffer(zi) | ||
947 | zip_internal* zi; | ||
948 | { | ||
949 | int err=ZIP_OK; | ||
950 | |||
951 | if (zi->ci.encrypt != 0) | ||
952 | { | ||
953 | #ifndef NOCRYPT | ||
954 | uInt i; | ||
955 | int t; | ||
956 | for (i=0;i<zi->ci.pos_in_buffered_data;i++) | ||
957 | zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, | ||
958 | zi->ci.buffered_data[i],t); | ||
959 | #endif | ||
960 | } | ||
961 | if (ZWRITE(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data) | ||
962 | !=zi->ci.pos_in_buffered_data) | ||
963 | err = ZIP_ERRNO; | ||
964 | zi->ci.pos_in_buffered_data = 0; | ||
965 | return err; | ||
966 | } | ||
967 | |||
968 | extern int ZEXPORT zipWriteInFileInZip (file, buf, len) | ||
969 | zipFile file; | ||
970 | const void* buf; | ||
971 | unsigned len; | ||
972 | { | ||
973 | zip_internal* zi; | ||
974 | int err=ZIP_OK; | ||
975 | |||
976 | if (file == NULL) | ||
977 | return ZIP_PARAMERROR; | ||
978 | zi = (zip_internal*)file; | ||
979 | |||
980 | if (zi->in_opened_file_inzip == 0) | ||
981 | return ZIP_PARAMERROR; | ||
982 | |||
983 | zi->ci.stream.next_in = (void*)buf; | ||
984 | zi->ci.stream.avail_in = len; | ||
985 | zi->ci.crc32 = crc32(zi->ci.crc32,buf,len); | ||
986 | |||
987 | while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0)) | ||
988 | { | ||
989 | if (zi->ci.stream.avail_out == 0) | ||
990 | { | ||
991 | if (zipFlushWriteBuffer(zi) == ZIP_ERRNO) | ||
992 | err = ZIP_ERRNO; | ||
993 | zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; | ||
994 | zi->ci.stream.next_out = zi->ci.buffered_data; | ||
995 | } | ||
996 | |||
997 | |||
998 | if(err != ZIP_OK) | ||
999 | break; | ||
1000 | |||
1001 | if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) | ||
1002 | { | ||
1003 | uLong uTotalOutBefore = zi->ci.stream.total_out; | ||
1004 | err=deflate(&zi->ci.stream, Z_NO_FLUSH); | ||
1005 | zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; | ||
1006 | |||
1007 | } | ||
1008 | else | ||
1009 | { | ||
1010 | uInt copy_this,i; | ||
1011 | if (zi->ci.stream.avail_in < zi->ci.stream.avail_out) | ||
1012 | copy_this = zi->ci.stream.avail_in; | ||
1013 | else | ||
1014 | copy_this = zi->ci.stream.avail_out; | ||
1015 | for (i=0;i<copy_this;i++) | ||
1016 | *(((char*)zi->ci.stream.next_out)+i) = | ||
1017 | *(((const char*)zi->ci.stream.next_in)+i); | ||
1018 | { | ||
1019 | zi->ci.stream.avail_in -= copy_this; | ||
1020 | zi->ci.stream.avail_out-= copy_this; | ||
1021 | zi->ci.stream.next_in+= copy_this; | ||
1022 | zi->ci.stream.next_out+= copy_this; | ||
1023 | zi->ci.stream.total_in+= copy_this; | ||
1024 | zi->ci.stream.total_out+= copy_this; | ||
1025 | zi->ci.pos_in_buffered_data += copy_this; | ||
1026 | } | ||
1027 | } | ||
1028 | } | ||
1029 | |||
1030 | return err; | ||
1031 | } | ||
1032 | |||
1033 | extern int ZEXPORT zipCloseFileInZipRaw (file, uncompressed_size, crc32) | ||
1034 | zipFile file; | ||
1035 | uLong uncompressed_size; | ||
1036 | uLong crc32; | ||
1037 | { | ||
1038 | zip_internal* zi; | ||
1039 | uLong compressed_size; | ||
1040 | int err=ZIP_OK; | ||
1041 | |||
1042 | if (file == NULL) | ||
1043 | return ZIP_PARAMERROR; | ||
1044 | zi = (zip_internal*)file; | ||
1045 | |||
1046 | if (zi->in_opened_file_inzip == 0) | ||
1047 | return ZIP_PARAMERROR; | ||
1048 | zi->ci.stream.avail_in = 0; | ||
1049 | |||
1050 | if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) | ||
1051 | while (err==ZIP_OK) | ||
1052 | { | ||
1053 | uLong uTotalOutBefore; | ||
1054 | if (zi->ci.stream.avail_out == 0) | ||
1055 | { | ||
1056 | if (zipFlushWriteBuffer(zi) == ZIP_ERRNO) | ||
1057 | err = ZIP_ERRNO; | ||
1058 | zi->ci.stream.avail_out = (uInt)Z_BUFSIZE; | ||
1059 | zi->ci.stream.next_out = zi->ci.buffered_data; | ||
1060 | } | ||
1061 | uTotalOutBefore = zi->ci.stream.total_out; | ||
1062 | err=deflate(&zi->ci.stream, Z_FINISH); | ||
1063 | zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ; | ||
1064 | } | ||
1065 | |||
1066 | if (err==Z_STREAM_END) | ||
1067 | err=ZIP_OK; /* this is normal */ | ||
1068 | |||
1069 | if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK)) | ||
1070 | if (zipFlushWriteBuffer(zi)==ZIP_ERRNO) | ||
1071 | err = ZIP_ERRNO; | ||
1072 | |||
1073 | if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw)) | ||
1074 | { | ||
1075 | err=deflateEnd(&zi->ci.stream); | ||
1076 | zi->ci.stream_initialised = 0; | ||
1077 | } | ||
1078 | |||
1079 | if (!zi->ci.raw) | ||
1080 | { | ||
1081 | crc32 = (uLong)zi->ci.crc32; | ||
1082 | uncompressed_size = (uLong)zi->ci.stream.total_in; | ||
1083 | } | ||
1084 | compressed_size = (uLong)zi->ci.stream.total_out; | ||
1085 | # ifndef NOCRYPT | ||
1086 | compressed_size += zi->ci.crypt_header_size; | ||
1087 | # endif | ||
1088 | |||
1089 | ziplocal_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/ | ||
1090 | ziplocal_putValue_inmemory(zi->ci.central_header+20, | ||
1091 | compressed_size,4); /*compr size*/ | ||
1092 | if (zi->ci.stream.data_type == Z_ASCII) | ||
1093 | ziplocal_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2); | ||
1094 | ziplocal_putValue_inmemory(zi->ci.central_header+24, | ||
1095 | uncompressed_size,4); /*uncompr size*/ | ||
1096 | |||
1097 | if (err==ZIP_OK) | ||
1098 | err = add_data_in_datablock(&zi->central_dir,zi->ci.central_header, | ||
1099 | (uLong)zi->ci.size_centralheader); | ||
1100 | free(zi->ci.central_header); | ||
1101 | |||
1102 | if (err==ZIP_OK) | ||
1103 | { | ||
1104 | long cur_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream); | ||
1105 | if (ZSEEK(zi->z_filefunc,zi->filestream, | ||
1106 | zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0) | ||
1107 | err = ZIP_ERRNO; | ||
1108 | |||
1109 | if (err==ZIP_OK) | ||
1110 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */ | ||
1111 | |||
1112 | if (err==ZIP_OK) /* compressed size, unknown */ | ||
1113 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4); | ||
1114 | |||
1115 | if (err==ZIP_OK) /* uncompressed size, unknown */ | ||
1116 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4); | ||
1117 | |||
1118 | if (ZSEEK(zi->z_filefunc,zi->filestream, | ||
1119 | cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0) | ||
1120 | err = ZIP_ERRNO; | ||
1121 | } | ||
1122 | |||
1123 | zi->number_entry ++; | ||
1124 | zi->in_opened_file_inzip = 0; | ||
1125 | |||
1126 | return err; | ||
1127 | } | ||
1128 | |||
1129 | extern int ZEXPORT zipCloseFileInZip (file) | ||
1130 | zipFile file; | ||
1131 | { | ||
1132 | return zipCloseFileInZipRaw (file,0,0); | ||
1133 | } | ||
1134 | |||
1135 | extern int ZEXPORT zipClose (file, global_comment) | ||
1136 | zipFile file; | ||
1137 | const char* global_comment; | ||
1138 | { | ||
1139 | zip_internal* zi; | ||
1140 | int err = 0; | ||
1141 | uLong size_centraldir = 0; | ||
1142 | uLong centraldir_pos_inzip; | ||
1143 | uInt size_global_comment; | ||
1144 | if (file == NULL) | ||
1145 | return ZIP_PARAMERROR; | ||
1146 | zi = (zip_internal*)file; | ||
1147 | |||
1148 | if (zi->in_opened_file_inzip == 1) | ||
1149 | { | ||
1150 | err = zipCloseFileInZip (file); | ||
1151 | } | ||
1152 | |||
1153 | #ifndef NO_ADDFILEINEXISTINGZIP | ||
1154 | if (global_comment==NULL) | ||
1155 | global_comment = zi->globalcomment; | ||
1156 | #endif | ||
1157 | if (global_comment==NULL) | ||
1158 | size_global_comment = 0; | ||
1159 | else | ||
1160 | size_global_comment = (uInt)strlen(global_comment); | ||
1161 | |||
1162 | centraldir_pos_inzip = ZTELL(zi->z_filefunc,zi->filestream); | ||
1163 | if (err==ZIP_OK) | ||
1164 | { | ||
1165 | linkedlist_datablock_internal* ldi = zi->central_dir.first_block ; | ||
1166 | while (ldi!=NULL) | ||
1167 | { | ||
1168 | if ((err==ZIP_OK) && (ldi->filled_in_this_block>0)) | ||
1169 | if (ZWRITE(zi->z_filefunc,zi->filestream, | ||
1170 | ldi->data,ldi->filled_in_this_block) | ||
1171 | !=ldi->filled_in_this_block ) | ||
1172 | err = ZIP_ERRNO; | ||
1173 | |||
1174 | size_centraldir += ldi->filled_in_this_block; | ||
1175 | ldi = ldi->next_datablock; | ||
1176 | } | ||
1177 | } | ||
1178 | free_datablock(zi->central_dir.first_block); | ||
1179 | |||
1180 | if (err==ZIP_OK) /* Magic End */ | ||
1181 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4); | ||
1182 | |||
1183 | if (err==ZIP_OK) /* number of this disk */ | ||
1184 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); | ||
1185 | |||
1186 | if (err==ZIP_OK) /* number of the disk with the start of the central directory */ | ||
1187 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2); | ||
1188 | |||
1189 | if (err==ZIP_OK) /* total number of entries in the central dir on this disk */ | ||
1190 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); | ||
1191 | |||
1192 | if (err==ZIP_OK) /* total number of entries in the central dir */ | ||
1193 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2); | ||
1194 | |||
1195 | if (err==ZIP_OK) /* size of the central directory */ | ||
1196 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4); | ||
1197 | |||
1198 | if (err==ZIP_OK) /* offset of start of central directory with respect to the | ||
1199 | starting disk number */ | ||
1200 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream, | ||
1201 | (uLong)(centraldir_pos_inzip - zi->add_position_when_writting_offset),4); | ||
1202 | |||
1203 | if (err==ZIP_OK) /* zipfile comment length */ | ||
1204 | err = ziplocal_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2); | ||
1205 | |||
1206 | if ((err==ZIP_OK) && (size_global_comment>0)) | ||
1207 | if (ZWRITE(zi->z_filefunc,zi->filestream, | ||
1208 | global_comment,size_global_comment) != size_global_comment) | ||
1209 | err = ZIP_ERRNO; | ||
1210 | |||
1211 | if (ZCLOSE(zi->z_filefunc,zi->filestream) != 0) | ||
1212 | if (err == ZIP_OK) | ||
1213 | err = ZIP_ERRNO; | ||
1214 | |||
1215 | #ifndef NO_ADDFILEINEXISTINGZIP | ||
1216 | TRYFREE(zi->globalcomment); | ||
1217 | #endif | ||
1218 | TRYFREE(zi); | ||
1219 | |||
1220 | return err; | ||
1221 | } | ||
diff --git a/utils/themeeditor/quazip/zip.h b/utils/themeeditor/quazip/zip.h new file mode 100644 index 0000000000..acacce83b9 --- /dev/null +++ b/utils/themeeditor/quazip/zip.h | |||
@@ -0,0 +1,235 @@ | |||
1 | /* zip.h -- IO for compress .zip files using zlib | ||
2 | Version 1.01e, February 12th, 2005 | ||
3 | |||
4 | Copyright (C) 1998-2005 Gilles Vollant | ||
5 | |||
6 | This unzip package allow creates .ZIP file, compatible with PKZip 2.04g | ||
7 | WinZip, InfoZip tools and compatible. | ||
8 | Multi volume ZipFile (span) are not supported. | ||
9 | Encryption compatible with pkzip 2.04g only supported | ||
10 | Old compressions used by old PKZip 1.x are not supported | ||
11 | |||
12 | For uncompress .zip file, look at unzip.h | ||
13 | |||
14 | |||
15 | I WAIT FEEDBACK at mail info@winimage.com | ||
16 | Visit also http://www.winimage.com/zLibDll/unzip.html for evolution | ||
17 | |||
18 | Condition of use and distribution are the same than zlib : | ||
19 | |||
20 | This software is provided 'as-is', without any express or implied | ||
21 | warranty. In no event will the authors be held liable for any damages | ||
22 | arising from the use of this software. | ||
23 | |||
24 | Permission is granted to anyone to use this software for any purpose, | ||
25 | including commercial applications, and to alter it and redistribute it | ||
26 | freely, subject to the following restrictions: | ||
27 | |||
28 | 1. The origin of this software must not be misrepresented; you must not | ||
29 | claim that you wrote the original software. If you use this software | ||
30 | in a product, an acknowledgment in the product documentation would be | ||
31 | appreciated but is not required. | ||
32 | 2. Altered source versions must be plainly marked as such, and must not be | ||
33 | misrepresented as being the original software. | ||
34 | 3. This notice may not be removed or altered from any source distribution. | ||
35 | |||
36 | |||
37 | */ | ||
38 | |||
39 | /* for more info about .ZIP format, see | ||
40 | http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip | ||
41 | http://www.info-zip.org/pub/infozip/doc/ | ||
42 | PkWare has also a specification at : | ||
43 | ftp://ftp.pkware.com/probdesc.zip | ||
44 | */ | ||
45 | |||
46 | #ifndef _zip_H | ||
47 | #define _zip_H | ||
48 | |||
49 | #ifdef __cplusplus | ||
50 | extern "C" { | ||
51 | #endif | ||
52 | |||
53 | #ifndef _ZLIB_H | ||
54 | #include "zlib.h" | ||
55 | #endif | ||
56 | |||
57 | #ifndef _ZLIBIOAPI_H | ||
58 | #include "ioapi.h" | ||
59 | #endif | ||
60 | |||
61 | #if defined(STRICTZIP) || defined(STRICTZIPUNZIP) | ||
62 | /* like the STRICT of WIN32, we define a pointer that cannot be converted | ||
63 | from (void*) without cast */ | ||
64 | typedef struct TagzipFile__ { int unused; } zipFile__; | ||
65 | typedef zipFile__ *zipFile; | ||
66 | #else | ||
67 | typedef voidp zipFile; | ||
68 | #endif | ||
69 | |||
70 | #define ZIP_OK (0) | ||
71 | #define ZIP_EOF (0) | ||
72 | #define ZIP_ERRNO (Z_ERRNO) | ||
73 | #define ZIP_PARAMERROR (-102) | ||
74 | #define ZIP_BADZIPFILE (-103) | ||
75 | #define ZIP_INTERNALERROR (-104) | ||
76 | |||
77 | #ifndef DEF_MEM_LEVEL | ||
78 | # if MAX_MEM_LEVEL >= 8 | ||
79 | # define DEF_MEM_LEVEL 8 | ||
80 | # else | ||
81 | # define DEF_MEM_LEVEL MAX_MEM_LEVEL | ||
82 | # endif | ||
83 | #endif | ||
84 | /* default memLevel */ | ||
85 | |||
86 | /* tm_zip contain date/time info */ | ||
87 | typedef struct tm_zip_s | ||
88 | { | ||
89 | uInt tm_sec; /* seconds after the minute - [0,59] */ | ||
90 | uInt tm_min; /* minutes after the hour - [0,59] */ | ||
91 | uInt tm_hour; /* hours since midnight - [0,23] */ | ||
92 | uInt tm_mday; /* day of the month - [1,31] */ | ||
93 | uInt tm_mon; /* months since January - [0,11] */ | ||
94 | uInt tm_year; /* years - [1980..2044] */ | ||
95 | } tm_zip; | ||
96 | |||
97 | typedef struct | ||
98 | { | ||
99 | tm_zip tmz_date; /* date in understandable format */ | ||
100 | uLong dosDate; /* if dos_date == 0, tmu_date is used */ | ||
101 | /* uLong flag; */ /* general purpose bit flag 2 bytes */ | ||
102 | |||
103 | uLong internal_fa; /* internal file attributes 2 bytes */ | ||
104 | uLong external_fa; /* external file attributes 4 bytes */ | ||
105 | } zip_fileinfo; | ||
106 | |||
107 | typedef const char* zipcharpc; | ||
108 | |||
109 | |||
110 | #define APPEND_STATUS_CREATE (0) | ||
111 | #define APPEND_STATUS_CREATEAFTER (1) | ||
112 | #define APPEND_STATUS_ADDINZIP (2) | ||
113 | |||
114 | extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append)); | ||
115 | /* | ||
116 | Create a zipfile. | ||
117 | pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on | ||
118 | an Unix computer "zlib/zlib113.zip". | ||
119 | if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip | ||
120 | will be created at the end of the file. | ||
121 | (useful if the file contain a self extractor code) | ||
122 | if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will | ||
123 | add files in existing zip (be sure you don't add file that doesn't exist) | ||
124 | If the zipfile cannot be opened, the return value is NULL. | ||
125 | Else, the return value is a zipFile Handle, usable with other function | ||
126 | of this zip package. | ||
127 | */ | ||
128 | |||
129 | /* Note : there is no delete function into a zipfile. | ||
130 | If you want delete file into a zipfile, you must open a zipfile, and create another | ||
131 | Of couse, you can use RAW reading and writing to copy the file you did not want delte | ||
132 | */ | ||
133 | |||
134 | extern zipFile ZEXPORT zipOpen2 OF((const char *pathname, | ||
135 | int append, | ||
136 | zipcharpc* globalcomment, | ||
137 | zlib_filefunc_def* pzlib_filefunc_def)); | ||
138 | |||
139 | extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file, | ||
140 | const char* filename, | ||
141 | const zip_fileinfo* zipfi, | ||
142 | const void* extrafield_local, | ||
143 | uInt size_extrafield_local, | ||
144 | const void* extrafield_global, | ||
145 | uInt size_extrafield_global, | ||
146 | const char* comment, | ||
147 | int method, | ||
148 | int level)); | ||
149 | /* | ||
150 | Open a file in the ZIP for writing. | ||
151 | filename : the filename in zip (if NULL, '-' without quote will be used | ||
152 | *zipfi contain supplemental information | ||
153 | if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local | ||
154 | contains the extrafield data the the local header | ||
155 | if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global | ||
156 | contains the extrafield data the the local header | ||
157 | if comment != NULL, comment contain the comment string | ||
158 | method contain the compression method (0 for store, Z_DEFLATED for deflate) | ||
159 | level contain the level of compression (can be Z_DEFAULT_COMPRESSION) | ||
160 | */ | ||
161 | |||
162 | |||
163 | extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file, | ||
164 | const char* filename, | ||
165 | const zip_fileinfo* zipfi, | ||
166 | const void* extrafield_local, | ||
167 | uInt size_extrafield_local, | ||
168 | const void* extrafield_global, | ||
169 | uInt size_extrafield_global, | ||
170 | const char* comment, | ||
171 | int method, | ||
172 | int level, | ||
173 | int raw)); | ||
174 | |||
175 | /* | ||
176 | Same than zipOpenNewFileInZip, except if raw=1, we write raw file | ||
177 | */ | ||
178 | |||
179 | extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file, | ||
180 | const char* filename, | ||
181 | const zip_fileinfo* zipfi, | ||
182 | const void* extrafield_local, | ||
183 | uInt size_extrafield_local, | ||
184 | const void* extrafield_global, | ||
185 | uInt size_extrafield_global, | ||
186 | const char* comment, | ||
187 | int method, | ||
188 | int level, | ||
189 | int raw, | ||
190 | int windowBits, | ||
191 | int memLevel, | ||
192 | int strategy, | ||
193 | const char* password, | ||
194 | uLong crcForCtypting)); | ||
195 | |||
196 | /* | ||
197 | Same than zipOpenNewFileInZip2, except | ||
198 | windowBits,memLevel,,strategy : see parameter strategy in deflateInit2 | ||
199 | password : crypting password (NULL for no crypting) | ||
200 | crcForCtypting : crc of file to compress (needed for crypting) | ||
201 | */ | ||
202 | |||
203 | |||
204 | extern int ZEXPORT zipWriteInFileInZip OF((zipFile file, | ||
205 | const void* buf, | ||
206 | unsigned len)); | ||
207 | /* | ||
208 | Write data in the zipfile | ||
209 | */ | ||
210 | |||
211 | extern int ZEXPORT zipCloseFileInZip OF((zipFile file)); | ||
212 | /* | ||
213 | Close the current file in the zipfile | ||
214 | */ | ||
215 | |||
216 | extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file, | ||
217 | uLong uncompressed_size, | ||
218 | uLong crc32)); | ||
219 | /* | ||
220 | Close the current file in the zipfile, for fiel opened with | ||
221 | parameter raw=1 in zipOpenNewFileInZip2 | ||
222 | uncompressed_size and crc32 are value for the uncompressed size | ||
223 | */ | ||
224 | |||
225 | extern int ZEXPORT zipClose OF((zipFile file, | ||
226 | const char* global_comment)); | ||
227 | /* | ||
228 | Close the zipfile | ||
229 | */ | ||
230 | |||
231 | #ifdef __cplusplus | ||
232 | } | ||
233 | #endif | ||
234 | |||
235 | #endif /* _zip_H */ | ||
diff --git a/utils/themeeditor/themeeditor.pro b/utils/themeeditor/themeeditor.pro index 48c9f8c24d..42031ff9fa 100644 --- a/utils/themeeditor/themeeditor.pro +++ b/utils/themeeditor/themeeditor.pro | |||
@@ -1,7 +1,13 @@ | |||
1 | QT += network | ||
2 | |||
1 | # Enabling profiling | 3 | # Enabling profiling |
2 | QMAKE_CXXFLAGS_DEBUG += -pg | 4 | QMAKE_CXXFLAGS_DEBUG += -pg |
3 | QMAKE_LFLAGS_DEBUG += -pg | 5 | QMAKE_LFLAGS_DEBUG += -pg |
4 | 6 | ||
7 | # Adding zlib dependency for QuaZip | ||
8 | LIBS += -lz | ||
9 | INCLUDEPATH += zlib | ||
10 | |||
5 | # build in a separate folder. | 11 | # build in a separate folder. |
6 | MYBUILDDIR = $$OUT_PWD/build/ | 12 | MYBUILDDIR = $$OUT_PWD/build/ |
7 | OBJECTS_DIR = $$MYBUILDDIR/o | 13 | OBJECTS_DIR = $$MYBUILDDIR/o |
@@ -15,6 +21,7 @@ RBBASE_DIR = $$replace(RBBASE_DIR,/utils/themeeditor,) | |||
15 | INCLUDEPATH += gui | 21 | INCLUDEPATH += gui |
16 | INCLUDEPATH += models | 22 | INCLUDEPATH += models |
17 | INCLUDEPATH += graphics | 23 | INCLUDEPATH += graphics |
24 | INCLUDEPATH += quazip | ||
18 | 25 | ||
19 | # Stuff for the parse lib | 26 | # Stuff for the parse lib |
20 | libskin_parser.commands = @$(MAKE) \ | 27 | libskin_parser.commands = @$(MAKE) \ |
@@ -56,7 +63,18 @@ HEADERS += models/parsetreemodel.h \ | |||
56 | gui/skintimer.h \ | 63 | gui/skintimer.h \ |
57 | graphics/rbtoucharea.h \ | 64 | graphics/rbtoucharea.h \ |
58 | gui/newprojectdialog.h \ | 65 | gui/newprojectdialog.h \ |
59 | models/targetdata.h | 66 | models/targetdata.h \ |
67 | quazip/zip.h \ | ||
68 | quazip/unzip.h \ | ||
69 | quazip/quazipnewinfo.h \ | ||
70 | quazip/quazipfileinfo.h \ | ||
71 | quazip/quazipfile.h \ | ||
72 | quazip/quazip.h \ | ||
73 | quazip/ioapi.h \ | ||
74 | quazip/crypt.h \ | ||
75 | zlib/zlib.h \ | ||
76 | zlib/zconf.h \ | ||
77 | gui/fontdownloader.h | ||
60 | SOURCES += main.cpp \ | 78 | SOURCES += main.cpp \ |
61 | models/parsetreemodel.cpp \ | 79 | models/parsetreemodel.cpp \ |
62 | models/parsetreenode.cpp \ | 80 | models/parsetreenode.cpp \ |
@@ -83,7 +101,14 @@ SOURCES += main.cpp \ | |||
83 | gui/skintimer.cpp \ | 101 | gui/skintimer.cpp \ |
84 | graphics/rbtoucharea.cpp \ | 102 | graphics/rbtoucharea.cpp \ |
85 | gui/newprojectdialog.cpp \ | 103 | gui/newprojectdialog.cpp \ |
86 | models/targetdata.cpp | 104 | models/targetdata.cpp \ |
105 | quazip/zip.c \ | ||
106 | quazip/unzip.c \ | ||
107 | quazip/quazipnewinfo.cpp \ | ||
108 | quazip/quazipfile.cpp \ | ||
109 | quazip/quazip.cpp \ | ||
110 | quazip/ioapi.c \ | ||
111 | gui/fontdownloader.cpp | ||
87 | OTHER_FILES += README \ | 112 | OTHER_FILES += README \ |
88 | resources/windowicon.png \ | 113 | resources/windowicon.png \ |
89 | resources/appicon.xcf \ | 114 | resources/appicon.xcf \ |
@@ -105,14 +130,17 @@ OTHER_FILES += README \ | |||
105 | resources/lines.png \ | 130 | resources/lines.png \ |
106 | resources/cursor.xcf \ | 131 | resources/cursor.xcf \ |
107 | resources/cursor.png \ | 132 | resources/cursor.png \ |
108 | resources/targetdb | 133 | resources/targetdb \ |
134 | quazip/README.ROCKBOX \ | ||
135 | quazip/LICENSE.GPL | ||
109 | FORMS += gui/editorwindow.ui \ | 136 | FORMS += gui/editorwindow.ui \ |
110 | gui/preferencesdialog.ui \ | 137 | gui/preferencesdialog.ui \ |
111 | gui/configdocument.ui \ | 138 | gui/configdocument.ui \ |
112 | gui/skinviewer.ui \ | 139 | gui/skinviewer.ui \ |
113 | gui/findreplacedialog.ui \ | 140 | gui/findreplacedialog.ui \ |
114 | gui/skintimer.ui \ | 141 | gui/skintimer.ui \ |
115 | gui/newprojectdialog.ui | 142 | gui/newprojectdialog.ui \ |
143 | gui/fontdownloader.ui | ||
116 | RESOURCES += resources.qrc | 144 | RESOURCES += resources.qrc |
117 | win32:RC_FILE = themeeditor.rc | 145 | win32:RC_FILE = themeeditor.rc |
118 | macx { | 146 | macx { |
diff --git a/utils/themeeditor/zlib/zconf.h b/utils/themeeditor/zlib/zconf.h new file mode 100644 index 0000000000..3c21403fce --- /dev/null +++ b/utils/themeeditor/zlib/zconf.h | |||
@@ -0,0 +1,326 @@ | |||
1 | /* zconf.h -- configuration of the zlib compression library | ||
2 | * Copyright (C) 1995-2004 Jean-loup Gailly. | ||
3 | * For conditions of distribution and use, see copyright notice in zlib.h | ||
4 | */ | ||
5 | |||
6 | /* @(#) $Id$ */ | ||
7 | |||
8 | #ifndef ZCONF_H | ||
9 | #define ZCONF_H | ||
10 | |||
11 | /* | ||
12 | * If you *really* need a unique prefix for all types and library functions, | ||
13 | * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. | ||
14 | */ | ||
15 | #ifdef Z_PREFIX | ||
16 | # define deflateInit_ z_deflateInit_ | ||
17 | # define deflate z_deflate | ||
18 | # define deflateEnd z_deflateEnd | ||
19 | # define inflateInit_ z_inflateInit_ | ||
20 | # define inflate z_inflate | ||
21 | # define inflateEnd z_inflateEnd | ||
22 | # define deflateInit2_ z_deflateInit2_ | ||
23 | # define deflateSetDictionary z_deflateSetDictionary | ||
24 | # define deflateCopy z_deflateCopy | ||
25 | # define deflateReset z_deflateReset | ||
26 | # define deflateParams z_deflateParams | ||
27 | # define deflateBound z_deflateBound | ||
28 | # define deflatePrime z_deflatePrime | ||
29 | # define inflateInit2_ z_inflateInit2_ | ||
30 | # define inflateSetDictionary z_inflateSetDictionary | ||
31 | # define inflateSync z_inflateSync | ||
32 | # define inflateSyncPoint z_inflateSyncPoint | ||
33 | # define inflateCopy z_inflateCopy | ||
34 | # define inflateReset z_inflateReset | ||
35 | # define inflateBack z_inflateBack | ||
36 | # define inflateBackEnd z_inflateBackEnd | ||
37 | # define compress z_compress | ||
38 | # define compress2 z_compress2 | ||
39 | # define compressBound z_compressBound | ||
40 | # define uncompress z_uncompress | ||
41 | # define adler32 z_adler32 | ||
42 | # define crc32 z_crc32 | ||
43 | # define get_crc_table z_get_crc_table | ||
44 | # define zError z_zError | ||
45 | |||
46 | # define Byte z_Byte | ||
47 | # define uInt z_uInt | ||
48 | # define uLong z_uLong | ||
49 | # define Bytef z_Bytef | ||
50 | # define charf z_charf | ||
51 | # define intf z_intf | ||
52 | # define uIntf z_uIntf | ||
53 | # define uLongf z_uLongf | ||
54 | # define voidpf z_voidpf | ||
55 | # define voidp z_voidp | ||
56 | #endif | ||
57 | |||
58 | #if defined(__MSDOS__) && !defined(MSDOS) | ||
59 | # define MSDOS | ||
60 | #endif | ||
61 | #if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) | ||
62 | # define OS2 | ||
63 | #endif | ||
64 | #if defined(_WINDOWS) && !defined(WINDOWS) | ||
65 | # define WINDOWS | ||
66 | #endif | ||
67 | #if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32) | ||
68 | # define WIN32 | ||
69 | #endif | ||
70 | #if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) | ||
71 | # if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) | ||
72 | # ifndef SYS16BIT | ||
73 | # define SYS16BIT | ||
74 | # endif | ||
75 | # endif | ||
76 | #endif | ||
77 | |||
78 | /* | ||
79 | * Compile with -DMAXSEG_64K if the alloc function cannot allocate more | ||
80 | * than 64k bytes at a time (needed on systems with 16-bit int). | ||
81 | */ | ||
82 | #ifdef SYS16BIT | ||
83 | # define MAXSEG_64K | ||
84 | #endif | ||
85 | #ifdef MSDOS | ||
86 | # define UNALIGNED_OK | ||
87 | #endif | ||
88 | |||
89 | #ifdef __STDC_VERSION__ | ||
90 | # ifndef STDC | ||
91 | # define STDC | ||
92 | # endif | ||
93 | # if __STDC_VERSION__ >= 199901L | ||
94 | # ifndef STDC99 | ||
95 | # define STDC99 | ||
96 | # endif | ||
97 | # endif | ||
98 | #endif | ||
99 | #if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) | ||
100 | # define STDC | ||
101 | #endif | ||
102 | #if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) | ||
103 | # define STDC | ||
104 | #endif | ||
105 | #if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) | ||
106 | # define STDC | ||
107 | #endif | ||
108 | #if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) | ||
109 | # define STDC | ||
110 | #endif | ||
111 | |||
112 | #if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ | ||
113 | # define STDC | ||
114 | #endif | ||
115 | |||
116 | #ifndef STDC | ||
117 | # ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ | ||
118 | # define const /* note: need a more gentle solution here */ | ||
119 | # endif | ||
120 | #endif | ||
121 | |||
122 | /* Some Mac compilers merge all .h files incorrectly: */ | ||
123 | #if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) | ||
124 | # define NO_DUMMY_DECL | ||
125 | #endif | ||
126 | |||
127 | /* Maximum value for memLevel in deflateInit2 */ | ||
128 | #ifndef MAX_MEM_LEVEL | ||
129 | # ifdef MAXSEG_64K | ||
130 | # define MAX_MEM_LEVEL 8 | ||
131 | # else | ||
132 | # define MAX_MEM_LEVEL 9 | ||
133 | # endif | ||
134 | #endif | ||
135 | |||
136 | /* Maximum value for windowBits in deflateInit2 and inflateInit2. | ||
137 | * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files | ||
138 | * created by gzip. (Files created by minigzip can still be extracted by | ||
139 | * gzip.) | ||
140 | */ | ||
141 | #ifndef MAX_WBITS | ||
142 | # define MAX_WBITS 15 /* 32K LZ77 window */ | ||
143 | #endif | ||
144 | |||
145 | /* The memory requirements for deflate are (in bytes): | ||
146 | (1 << (windowBits+2)) + (1 << (memLevel+9)) | ||
147 | that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) | ||
148 | plus a few kilobytes for small objects. For example, if you want to reduce | ||
149 | the default memory requirements from 256K to 128K, compile with | ||
150 | make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" | ||
151 | Of course this will generally degrade compression (there's no free lunch). | ||
152 | |||
153 | The memory requirements for inflate are (in bytes) 1 << windowBits | ||
154 | that is, 32K for windowBits=15 (default value) plus a few kilobytes | ||
155 | for small objects. | ||
156 | */ | ||
157 | |||
158 | /* Type declarations */ | ||
159 | |||
160 | #ifndef OF /* function prototypes */ | ||
161 | # ifdef STDC | ||
162 | # define OF(args) args | ||
163 | # else | ||
164 | # define OF(args) () | ||
165 | # endif | ||
166 | #endif | ||
167 | |||
168 | /* The following definitions for FAR are needed only for MSDOS mixed | ||
169 | * model programming (small or medium model with some far allocations). | ||
170 | * This was tested only with MSC; for other MSDOS compilers you may have | ||
171 | * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, | ||
172 | * just define FAR to be empty. | ||
173 | */ | ||
174 | #ifdef SYS16BIT | ||
175 | # if defined(M_I86SM) || defined(M_I86MM) | ||
176 | /* MSC small or medium model */ | ||
177 | # define SMALL_MEDIUM | ||
178 | # ifdef _MSC_VER | ||
179 | # define FAR _far | ||
180 | # else | ||
181 | # define FAR far | ||
182 | # endif | ||
183 | # endif | ||
184 | # if (defined(__SMALL__) || defined(__MEDIUM__)) | ||
185 | /* Turbo C small or medium model */ | ||
186 | # define SMALL_MEDIUM | ||
187 | # ifdef __BORLANDC__ | ||
188 | # define FAR _far | ||
189 | # else | ||
190 | # define FAR far | ||
191 | # endif | ||
192 | # endif | ||
193 | #endif | ||
194 | |||
195 | #if defined(WINDOWS) || defined(WIN32) | ||
196 | /* If building or using zlib as a DLL, define ZLIB_DLL. | ||
197 | * This is not mandatory, but it offers a little performance increase. | ||
198 | */ | ||
199 | # ifdef ZLIB_DLL | ||
200 | # if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) | ||
201 | # ifdef ZLIB_INTERNAL | ||
202 | # define ZEXTERN extern __declspec(dllexport) | ||
203 | # else | ||
204 | # define ZEXTERN extern __declspec(dllimport) | ||
205 | # endif | ||
206 | # endif | ||
207 | # endif /* ZLIB_DLL */ | ||
208 | /* If building or using zlib with the WINAPI/WINAPIV calling convention, | ||
209 | * define ZLIB_WINAPI. | ||
210 | * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. | ||
211 | */ | ||
212 | # ifdef ZLIB_WINAPI | ||
213 | # ifdef FAR | ||
214 | # undef FAR | ||
215 | # endif | ||
216 | # include <windows.h> | ||
217 | /* No need for _export, use ZLIB.DEF instead. */ | ||
218 | /* For complete Windows compatibility, use WINAPI, not __stdcall. */ | ||
219 | # define ZEXPORT WINAPI | ||
220 | # ifdef WIN32 | ||
221 | # define ZEXPORTVA WINAPIV | ||
222 | # else | ||
223 | # define ZEXPORTVA FAR CDECL | ||
224 | # endif | ||
225 | # endif | ||
226 | #endif | ||
227 | |||
228 | #if defined (__BEOS__) | ||
229 | # ifdef ZLIB_DLL | ||
230 | # ifdef ZLIB_INTERNAL | ||
231 | # define ZEXPORT __declspec(dllexport) | ||
232 | # define ZEXPORTVA __declspec(dllexport) | ||
233 | # else | ||
234 | # define ZEXPORT __declspec(dllimport) | ||
235 | # define ZEXPORTVA __declspec(dllimport) | ||
236 | # endif | ||
237 | # endif | ||
238 | #endif | ||
239 | |||
240 | #ifndef ZEXTERN | ||
241 | # define ZEXTERN extern | ||
242 | #endif | ||
243 | #ifndef ZEXPORT | ||
244 | # define ZEXPORT | ||
245 | #endif | ||
246 | #ifndef ZEXPORTVA | ||
247 | # define ZEXPORTVA | ||
248 | #endif | ||
249 | |||
250 | #ifndef FAR | ||
251 | # define FAR | ||
252 | #endif | ||
253 | |||
254 | #if !defined(__MACTYPES__) | ||
255 | typedef unsigned char Byte; /* 8 bits */ | ||
256 | #endif | ||
257 | typedef unsigned int uInt; /* 16 bits or more */ | ||
258 | typedef unsigned long uLong; /* 32 bits or more */ | ||
259 | |||
260 | #ifdef SMALL_MEDIUM | ||
261 | /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ | ||
262 | # define Bytef Byte FAR | ||
263 | #else | ||
264 | typedef Byte FAR Bytef; | ||
265 | #endif | ||
266 | typedef char FAR charf; | ||
267 | typedef int FAR intf; | ||
268 | typedef uInt FAR uIntf; | ||
269 | typedef uLong FAR uLongf; | ||
270 | |||
271 | #ifdef STDC | ||
272 | typedef void const *voidpc; | ||
273 | typedef void FAR *voidpf; | ||
274 | typedef void *voidp; | ||
275 | #else | ||
276 | typedef Byte const *voidpc; | ||
277 | typedef Byte FAR *voidpf; | ||
278 | typedef Byte *voidp; | ||
279 | #endif | ||
280 | |||
281 | #if 0 /* HAVE_UNISTD_H -- this line is updated by ./configure */ | ||
282 | # include <sys/types.h> /* for off_t */ | ||
283 | # include <unistd.h> /* for SEEK_* and off_t */ | ||
284 | # ifdef VMS | ||
285 | # include <unixio.h> /* for off_t */ | ||
286 | # endif | ||
287 | # define z_off_t off_t | ||
288 | #endif | ||
289 | #ifndef SEEK_SET | ||
290 | # define SEEK_SET 0 /* Seek from beginning of file. */ | ||
291 | # define SEEK_CUR 1 /* Seek from current position. */ | ||
292 | # define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ | ||
293 | #endif | ||
294 | #ifndef z_off_t | ||
295 | # define z_off_t long | ||
296 | #endif | ||
297 | |||
298 | #if defined(__OS400__) | ||
299 | # define NO_vsnprintf | ||
300 | #endif | ||
301 | |||
302 | #if defined(__MVS__) | ||
303 | # define NO_vsnprintf | ||
304 | # ifdef FAR | ||
305 | # undef FAR | ||
306 | # endif | ||
307 | #endif | ||
308 | |||
309 | /* MVS linker does not support external names larger than 8 bytes */ | ||
310 | #if defined(__MVS__) | ||
311 | # pragma map(deflateInit_,"DEIN") | ||
312 | # pragma map(deflateInit2_,"DEIN2") | ||
313 | # pragma map(deflateEnd,"DEEND") | ||
314 | # pragma map(deflateBound,"DEBND") | ||
315 | # pragma map(inflateInit_,"ININ") | ||
316 | # pragma map(inflateInit2_,"ININ2") | ||
317 | # pragma map(inflateEnd,"INEND") | ||
318 | # pragma map(inflateSync,"INSY") | ||
319 | # pragma map(inflateSetDictionary,"INSEDI") | ||
320 | # pragma map(compressBound,"CMBND") | ||
321 | # pragma map(inflate_table,"INTABL") | ||
322 | # pragma map(inflate_fast,"INFA") | ||
323 | # pragma map(inflate_copyright,"INCOPY") | ||
324 | #endif | ||
325 | |||
326 | #endif /* ZCONF_H */ | ||
diff --git a/utils/themeeditor/zlib/zlib.h b/utils/themeeditor/zlib/zlib.h new file mode 100644 index 0000000000..b4ddd34395 --- /dev/null +++ b/utils/themeeditor/zlib/zlib.h | |||
@@ -0,0 +1,1200 @@ | |||
1 | /* zlib.h -- interface of the 'zlib' general purpose compression library | ||
2 | version 1.2.2, October 3rd, 2004 | ||
3 | |||
4 | Copyright (C) 1995-2004 Jean-loup Gailly and Mark Adler | ||
5 | |||
6 | This software is provided 'as-is', without any express or implied | ||
7 | warranty. In no event will the authors be held liable for any damages | ||
8 | arising from the use of this software. | ||
9 | |||
10 | Permission is granted to anyone to use this software for any purpose, | ||
11 | including commercial applications, and to alter it and redistribute it | ||
12 | freely, subject to the following restrictions: | ||
13 | |||
14 | 1. The origin of this software must not be misrepresented; you must not | ||
15 | claim that you wrote the original software. If you use this software | ||
16 | in a product, an acknowledgment in the product documentation would be | ||
17 | appreciated but is not required. | ||
18 | 2. Altered source versions must be plainly marked as such, and must not be | ||
19 | misrepresented as being the original software. | ||
20 | 3. This notice may not be removed or altered from any source distribution. | ||
21 | |||
22 | Jean-loup Gailly Mark Adler | ||
23 | jloup@gzip.org madler@alumni.caltech.edu | ||
24 | |||
25 | |||
26 | The data format used by the zlib library is described by RFCs (Request for | ||
27 | Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt | ||
28 | (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). | ||
29 | */ | ||
30 | |||
31 | #ifndef ZLIB_H | ||
32 | #define ZLIB_H | ||
33 | |||
34 | #include "zconf.h" | ||
35 | |||
36 | #ifdef __cplusplus | ||
37 | extern "C" { | ||
38 | #endif | ||
39 | |||
40 | #define ZLIB_VERSION "1.2.2" | ||
41 | #define ZLIB_VERNUM 0x1220 | ||
42 | |||
43 | /* | ||
44 | The 'zlib' compression library provides in-memory compression and | ||
45 | decompression functions, including integrity checks of the uncompressed | ||
46 | data. This version of the library supports only one compression method | ||
47 | (deflation) but other algorithms will be added later and will have the same | ||
48 | stream interface. | ||
49 | |||
50 | Compression can be done in a single step if the buffers are large | ||
51 | enough (for example if an input file is mmap'ed), or can be done by | ||
52 | repeated calls of the compression function. In the latter case, the | ||
53 | application must provide more input and/or consume the output | ||
54 | (providing more output space) before each call. | ||
55 | |||
56 | The compressed data format used by default by the in-memory functions is | ||
57 | the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped | ||
58 | around a deflate stream, which is itself documented in RFC 1951. | ||
59 | |||
60 | The library also supports reading and writing files in gzip (.gz) format | ||
61 | with an interface similar to that of stdio using the functions that start | ||
62 | with "gz". The gzip format is different from the zlib format. gzip is a | ||
63 | gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. | ||
64 | |||
65 | This library can optionally read and write gzip streams in memory as well. | ||
66 | |||
67 | The zlib format was designed to be compact and fast for use in memory | ||
68 | and on communications channels. The gzip format was designed for single- | ||
69 | file compression on file systems, has a larger header than zlib to maintain | ||
70 | directory information, and uses a different, slower check method than zlib. | ||
71 | |||
72 | The library does not install any signal handler. The decoder checks | ||
73 | the consistency of the compressed data, so the library should never | ||
74 | crash even in case of corrupted input. | ||
75 | */ | ||
76 | |||
77 | typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); | ||
78 | typedef void (*free_func) OF((voidpf opaque, voidpf address)); | ||
79 | |||
80 | struct internal_state; | ||
81 | |||
82 | typedef struct z_stream_s { | ||
83 | Bytef *next_in; /* next input byte */ | ||
84 | uInt avail_in; /* number of bytes available at next_in */ | ||
85 | uLong total_in; /* total nb of input bytes read so far */ | ||
86 | |||
87 | Bytef *next_out; /* next output byte should be put there */ | ||
88 | uInt avail_out; /* remaining free space at next_out */ | ||
89 | uLong total_out; /* total nb of bytes output so far */ | ||
90 | |||
91 | char *msg; /* last error message, NULL if no error */ | ||
92 | struct internal_state FAR *state; /* not visible by applications */ | ||
93 | |||
94 | alloc_func zalloc; /* used to allocate the internal state */ | ||
95 | free_func zfree; /* used to free the internal state */ | ||
96 | voidpf opaque; /* private data object passed to zalloc and zfree */ | ||
97 | |||
98 | int data_type; /* best guess about the data type: ascii or binary */ | ||
99 | uLong adler; /* adler32 value of the uncompressed data */ | ||
100 | uLong reserved; /* reserved for future use */ | ||
101 | } z_stream; | ||
102 | |||
103 | typedef z_stream FAR *z_streamp; | ||
104 | |||
105 | /* | ||
106 | The application must update next_in and avail_in when avail_in has | ||
107 | dropped to zero. It must update next_out and avail_out when avail_out | ||
108 | has dropped to zero. The application must initialize zalloc, zfree and | ||
109 | opaque before calling the init function. All other fields are set by the | ||
110 | compression library and must not be updated by the application. | ||
111 | |||
112 | The opaque value provided by the application will be passed as the first | ||
113 | parameter for calls of zalloc and zfree. This can be useful for custom | ||
114 | memory management. The compression library attaches no meaning to the | ||
115 | opaque value. | ||
116 | |||
117 | zalloc must return Z_NULL if there is not enough memory for the object. | ||
118 | If zlib is used in a multi-threaded application, zalloc and zfree must be | ||
119 | thread safe. | ||
120 | |||
121 | On 16-bit systems, the functions zalloc and zfree must be able to allocate | ||
122 | exactly 65536 bytes, but will not be required to allocate more than this | ||
123 | if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, | ||
124 | pointers returned by zalloc for objects of exactly 65536 bytes *must* | ||
125 | have their offset normalized to zero. The default allocation function | ||
126 | provided by this library ensures this (see zutil.c). To reduce memory | ||
127 | requirements and avoid any allocation of 64K objects, at the expense of | ||
128 | compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). | ||
129 | |||
130 | The fields total_in and total_out can be used for statistics or | ||
131 | progress reports. After compression, total_in holds the total size of | ||
132 | the uncompressed data and may be saved for use in the decompressor | ||
133 | (particularly if the decompressor wants to decompress everything in | ||
134 | a single step). | ||
135 | */ | ||
136 | |||
137 | /* constants */ | ||
138 | |||
139 | #define Z_NO_FLUSH 0 | ||
140 | #define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ | ||
141 | #define Z_SYNC_FLUSH 2 | ||
142 | #define Z_FULL_FLUSH 3 | ||
143 | #define Z_FINISH 4 | ||
144 | #define Z_BLOCK 5 | ||
145 | /* Allowed flush values; see deflate() and inflate() below for details */ | ||
146 | |||
147 | #define Z_OK 0 | ||
148 | #define Z_STREAM_END 1 | ||
149 | #define Z_NEED_DICT 2 | ||
150 | #define Z_ERRNO (-1) | ||
151 | #define Z_STREAM_ERROR (-2) | ||
152 | #define Z_DATA_ERROR (-3) | ||
153 | #define Z_MEM_ERROR (-4) | ||
154 | #define Z_BUF_ERROR (-5) | ||
155 | #define Z_VERSION_ERROR (-6) | ||
156 | /* Return codes for the compression/decompression functions. Negative | ||
157 | * values are errors, positive values are used for special but normal events. | ||
158 | */ | ||
159 | |||
160 | #define Z_NO_COMPRESSION 0 | ||
161 | #define Z_BEST_SPEED 1 | ||
162 | #define Z_BEST_COMPRESSION 9 | ||
163 | #define Z_DEFAULT_COMPRESSION (-1) | ||
164 | /* compression levels */ | ||
165 | |||
166 | #define Z_FILTERED 1 | ||
167 | #define Z_HUFFMAN_ONLY 2 | ||
168 | #define Z_RLE 3 | ||
169 | #define Z_DEFAULT_STRATEGY 0 | ||
170 | /* compression strategy; see deflateInit2() below for details */ | ||
171 | |||
172 | #define Z_BINARY 0 | ||
173 | #define Z_ASCII 1 | ||
174 | #define Z_UNKNOWN 2 | ||
175 | /* Possible values of the data_type field (though see inflate()) */ | ||
176 | |||
177 | #define Z_DEFLATED 8 | ||
178 | /* The deflate compression method (the only one supported in this version) */ | ||
179 | |||
180 | #define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ | ||
181 | |||
182 | #define zlib_version zlibVersion() | ||
183 | /* for compatibility with versions < 1.0.2 */ | ||
184 | |||
185 | /* basic functions */ | ||
186 | |||
187 | ZEXTERN const char * ZEXPORT zlibVersion OF((void)); | ||
188 | /* The application can compare zlibVersion and ZLIB_VERSION for consistency. | ||
189 | If the first character differs, the library code actually used is | ||
190 | not compatible with the zlib.h header file used by the application. | ||
191 | This check is automatically made by deflateInit and inflateInit. | ||
192 | */ | ||
193 | |||
194 | /* | ||
195 | ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); | ||
196 | |||
197 | Initializes the internal stream state for compression. The fields | ||
198 | zalloc, zfree and opaque must be initialized before by the caller. | ||
199 | If zalloc and zfree are set to Z_NULL, deflateInit updates them to | ||
200 | use default allocation functions. | ||
201 | |||
202 | The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: | ||
203 | 1 gives best speed, 9 gives best compression, 0 gives no compression at | ||
204 | all (the input data is simply copied a block at a time). | ||
205 | Z_DEFAULT_COMPRESSION requests a default compromise between speed and | ||
206 | compression (currently equivalent to level 6). | ||
207 | |||
208 | deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not | ||
209 | enough memory, Z_STREAM_ERROR if level is not a valid compression level, | ||
210 | Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible | ||
211 | with the version assumed by the caller (ZLIB_VERSION). | ||
212 | msg is set to null if there is no error message. deflateInit does not | ||
213 | perform any compression: this will be done by deflate(). | ||
214 | */ | ||
215 | |||
216 | |||
217 | ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); | ||
218 | /* | ||
219 | deflate compresses as much data as possible, and stops when the input | ||
220 | buffer becomes empty or the output buffer becomes full. It may introduce some | ||
221 | output latency (reading input without producing any output) except when | ||
222 | forced to flush. | ||
223 | |||
224 | The detailed semantics are as follows. deflate performs one or both of the | ||
225 | following actions: | ||
226 | |||
227 | - Compress more input starting at next_in and update next_in and avail_in | ||
228 | accordingly. If not all input can be processed (because there is not | ||
229 | enough room in the output buffer), next_in and avail_in are updated and | ||
230 | processing will resume at this point for the next call of deflate(). | ||
231 | |||
232 | - Provide more output starting at next_out and update next_out and avail_out | ||
233 | accordingly. This action is forced if the parameter flush is non zero. | ||
234 | Forcing flush frequently degrades the compression ratio, so this parameter | ||
235 | should be set only when necessary (in interactive applications). | ||
236 | Some output may be provided even if flush is not set. | ||
237 | |||
238 | Before the call of deflate(), the application should ensure that at least | ||
239 | one of the actions is possible, by providing more input and/or consuming | ||
240 | more output, and updating avail_in or avail_out accordingly; avail_out | ||
241 | should never be zero before the call. The application can consume the | ||
242 | compressed output when it wants, for example when the output buffer is full | ||
243 | (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK | ||
244 | and with zero avail_out, it must be called again after making room in the | ||
245 | output buffer because there might be more output pending. | ||
246 | |||
247 | If the parameter flush is set to Z_SYNC_FLUSH, all pending output is | ||
248 | flushed to the output buffer and the output is aligned on a byte boundary, so | ||
249 | that the decompressor can get all input data available so far. (In particular | ||
250 | avail_in is zero after the call if enough output space has been provided | ||
251 | before the call.) Flushing may degrade compression for some compression | ||
252 | algorithms and so it should be used only when necessary. | ||
253 | |||
254 | If flush is set to Z_FULL_FLUSH, all output is flushed as with | ||
255 | Z_SYNC_FLUSH, and the compression state is reset so that decompression can | ||
256 | restart from this point if previous compressed data has been damaged or if | ||
257 | random access is desired. Using Z_FULL_FLUSH too often can seriously degrade | ||
258 | the compression. | ||
259 | |||
260 | If deflate returns with avail_out == 0, this function must be called again | ||
261 | with the same value of the flush parameter and more output space (updated | ||
262 | avail_out), until the flush is complete (deflate returns with non-zero | ||
263 | avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that | ||
264 | avail_out is greater than six to avoid repeated flush markers due to | ||
265 | avail_out == 0 on return. | ||
266 | |||
267 | If the parameter flush is set to Z_FINISH, pending input is processed, | ||
268 | pending output is flushed and deflate returns with Z_STREAM_END if there | ||
269 | was enough output space; if deflate returns with Z_OK, this function must be | ||
270 | called again with Z_FINISH and more output space (updated avail_out) but no | ||
271 | more input data, until it returns with Z_STREAM_END or an error. After | ||
272 | deflate has returned Z_STREAM_END, the only possible operations on the | ||
273 | stream are deflateReset or deflateEnd. | ||
274 | |||
275 | Z_FINISH can be used immediately after deflateInit if all the compression | ||
276 | is to be done in a single step. In this case, avail_out must be at least | ||
277 | the value returned by deflateBound (see below). If deflate does not return | ||
278 | Z_STREAM_END, then it must be called again as described above. | ||
279 | |||
280 | deflate() sets strm->adler to the adler32 checksum of all input read | ||
281 | so far (that is, total_in bytes). | ||
282 | |||
283 | deflate() may update data_type if it can make a good guess about | ||
284 | the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered | ||
285 | binary. This field is only for information purposes and does not affect | ||
286 | the compression algorithm in any manner. | ||
287 | |||
288 | deflate() returns Z_OK if some progress has been made (more input | ||
289 | processed or more output produced), Z_STREAM_END if all input has been | ||
290 | consumed and all output has been produced (only when flush is set to | ||
291 | Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example | ||
292 | if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible | ||
293 | (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not | ||
294 | fatal, and deflate() can be called again with more input and more output | ||
295 | space to continue compressing. | ||
296 | */ | ||
297 | |||
298 | |||
299 | ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); | ||
300 | /* | ||
301 | All dynamically allocated data structures for this stream are freed. | ||
302 | This function discards any unprocessed input and does not flush any | ||
303 | pending output. | ||
304 | |||
305 | deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the | ||
306 | stream state was inconsistent, Z_DATA_ERROR if the stream was freed | ||
307 | prematurely (some input or output was discarded). In the error case, | ||
308 | msg may be set but then points to a static string (which must not be | ||
309 | deallocated). | ||
310 | */ | ||
311 | |||
312 | |||
313 | /* | ||
314 | ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); | ||
315 | |||
316 | Initializes the internal stream state for decompression. The fields | ||
317 | next_in, avail_in, zalloc, zfree and opaque must be initialized before by | ||
318 | the caller. If next_in is not Z_NULL and avail_in is large enough (the exact | ||
319 | value depends on the compression method), inflateInit determines the | ||
320 | compression method from the zlib header and allocates all data structures | ||
321 | accordingly; otherwise the allocation will be deferred to the first call of | ||
322 | inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to | ||
323 | use default allocation functions. | ||
324 | |||
325 | inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough | ||
326 | memory, Z_VERSION_ERROR if the zlib library version is incompatible with the | ||
327 | version assumed by the caller. msg is set to null if there is no error | ||
328 | message. inflateInit does not perform any decompression apart from reading | ||
329 | the zlib header if present: this will be done by inflate(). (So next_in and | ||
330 | avail_in may be modified, but next_out and avail_out are unchanged.) | ||
331 | */ | ||
332 | |||
333 | |||
334 | ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); | ||
335 | /* | ||
336 | inflate decompresses as much data as possible, and stops when the input | ||
337 | buffer becomes empty or the output buffer becomes full. It may introduce | ||
338 | some output latency (reading input without producing any output) except when | ||
339 | forced to flush. | ||
340 | |||
341 | The detailed semantics are as follows. inflate performs one or both of the | ||
342 | following actions: | ||
343 | |||
344 | - Decompress more input starting at next_in and update next_in and avail_in | ||
345 | accordingly. If not all input can be processed (because there is not | ||
346 | enough room in the output buffer), next_in is updated and processing | ||
347 | will resume at this point for the next call of inflate(). | ||
348 | |||
349 | - Provide more output starting at next_out and update next_out and avail_out | ||
350 | accordingly. inflate() provides as much output as possible, until there | ||
351 | is no more input data or no more space in the output buffer (see below | ||
352 | about the flush parameter). | ||
353 | |||
354 | Before the call of inflate(), the application should ensure that at least | ||
355 | one of the actions is possible, by providing more input and/or consuming | ||
356 | more output, and updating the next_* and avail_* values accordingly. | ||
357 | The application can consume the uncompressed output when it wants, for | ||
358 | example when the output buffer is full (avail_out == 0), or after each | ||
359 | call of inflate(). If inflate returns Z_OK and with zero avail_out, it | ||
360 | must be called again after making room in the output buffer because there | ||
361 | might be more output pending. | ||
362 | |||
363 | The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, | ||
364 | Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much | ||
365 | output as possible to the output buffer. Z_BLOCK requests that inflate() stop | ||
366 | if and when it get to the next deflate block boundary. When decoding the zlib | ||
367 | or gzip format, this will cause inflate() to return immediately after the | ||
368 | header and before the first block. When doing a raw inflate, inflate() will | ||
369 | go ahead and process the first block, and will return when it gets to the end | ||
370 | of that block, or when it runs out of data. | ||
371 | |||
372 | The Z_BLOCK option assists in appending to or combining deflate streams. | ||
373 | Also to assist in this, on return inflate() will set strm->data_type to the | ||
374 | number of unused bits in the last byte taken from strm->next_in, plus 64 | ||
375 | if inflate() is currently decoding the last block in the deflate stream, | ||
376 | plus 128 if inflate() returned immediately after decoding an end-of-block | ||
377 | code or decoding the complete header up to just before the first byte of the | ||
378 | deflate stream. The end-of-block will not be indicated until all of the | ||
379 | uncompressed data from that block has been written to strm->next_out. The | ||
380 | number of unused bits may in general be greater than seven, except when | ||
381 | bit 7 of data_type is set, in which case the number of unused bits will be | ||
382 | less than eight. | ||
383 | |||
384 | inflate() should normally be called until it returns Z_STREAM_END or an | ||
385 | error. However if all decompression is to be performed in a single step | ||
386 | (a single call of inflate), the parameter flush should be set to | ||
387 | Z_FINISH. In this case all pending input is processed and all pending | ||
388 | output is flushed; avail_out must be large enough to hold all the | ||
389 | uncompressed data. (The size of the uncompressed data may have been saved | ||
390 | by the compressor for this purpose.) The next operation on this stream must | ||
391 | be inflateEnd to deallocate the decompression state. The use of Z_FINISH | ||
392 | is never required, but can be used to inform inflate that a faster approach | ||
393 | may be used for the single inflate() call. | ||
394 | |||
395 | In this implementation, inflate() always flushes as much output as | ||
396 | possible to the output buffer, and always uses the faster approach on the | ||
397 | first call. So the only effect of the flush parameter in this implementation | ||
398 | is on the return value of inflate(), as noted below, or when it returns early | ||
399 | because Z_BLOCK is used. | ||
400 | |||
401 | If a preset dictionary is needed after this call (see inflateSetDictionary | ||
402 | below), inflate sets strm->adler to the adler32 checksum of the dictionary | ||
403 | chosen by the compressor and returns Z_NEED_DICT; otherwise it sets | ||
404 | strm->adler to the adler32 checksum of all output produced so far (that is, | ||
405 | total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described | ||
406 | below. At the end of the stream, inflate() checks that its computed adler32 | ||
407 | checksum is equal to that saved by the compressor and returns Z_STREAM_END | ||
408 | only if the checksum is correct. | ||
409 | |||
410 | inflate() will decompress and check either zlib-wrapped or gzip-wrapped | ||
411 | deflate data. The header type is detected automatically. Any information | ||
412 | contained in the gzip header is not retained, so applications that need that | ||
413 | information should instead use raw inflate, see inflateInit2() below, or | ||
414 | inflateBack() and perform their own processing of the gzip header and | ||
415 | trailer. | ||
416 | |||
417 | inflate() returns Z_OK if some progress has been made (more input processed | ||
418 | or more output produced), Z_STREAM_END if the end of the compressed data has | ||
419 | been reached and all uncompressed output has been produced, Z_NEED_DICT if a | ||
420 | preset dictionary is needed at this point, Z_DATA_ERROR if the input data was | ||
421 | corrupted (input stream not conforming to the zlib format or incorrect check | ||
422 | value), Z_STREAM_ERROR if the stream structure was inconsistent (for example | ||
423 | if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory, | ||
424 | Z_BUF_ERROR if no progress is possible or if there was not enough room in the | ||
425 | output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and | ||
426 | inflate() can be called again with more input and more output space to | ||
427 | continue decompressing. If Z_DATA_ERROR is returned, the application may then | ||
428 | call inflateSync() to look for a good compression block if a partial recovery | ||
429 | of the data is desired. | ||
430 | */ | ||
431 | |||
432 | |||
433 | ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); | ||
434 | /* | ||
435 | All dynamically allocated data structures for this stream are freed. | ||
436 | This function discards any unprocessed input and does not flush any | ||
437 | pending output. | ||
438 | |||
439 | inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state | ||
440 | was inconsistent. In the error case, msg may be set but then points to a | ||
441 | static string (which must not be deallocated). | ||
442 | */ | ||
443 | |||
444 | /* Advanced functions */ | ||
445 | |||
446 | /* | ||
447 | The following functions are needed only in some special applications. | ||
448 | */ | ||
449 | |||
450 | /* | ||
451 | ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, | ||
452 | int level, | ||
453 | int method, | ||
454 | int windowBits, | ||
455 | int memLevel, | ||
456 | int strategy)); | ||
457 | |||
458 | This is another version of deflateInit with more compression options. The | ||
459 | fields next_in, zalloc, zfree and opaque must be initialized before by | ||
460 | the caller. | ||
461 | |||
462 | The method parameter is the compression method. It must be Z_DEFLATED in | ||
463 | this version of the library. | ||
464 | |||
465 | The windowBits parameter is the base two logarithm of the window size | ||
466 | (the size of the history buffer). It should be in the range 8..15 for this | ||
467 | version of the library. Larger values of this parameter result in better | ||
468 | compression at the expense of memory usage. The default value is 15 if | ||
469 | deflateInit is used instead. | ||
470 | |||
471 | windowBits can also be -8..-15 for raw deflate. In this case, -windowBits | ||
472 | determines the window size. deflate() will then generate raw deflate data | ||
473 | with no zlib header or trailer, and will not compute an adler32 check value. | ||
474 | |||
475 | windowBits can also be greater than 15 for optional gzip encoding. Add | ||
476 | 16 to windowBits to write a simple gzip header and trailer around the | ||
477 | compressed data instead of a zlib wrapper. The gzip header will have no | ||
478 | file name, no extra data, no comment, no modification time (set to zero), | ||
479 | no header crc, and the operating system will be set to 255 (unknown). If a | ||
480 | gzip stream is being written, strm->adler is a crc32 instead of an adler32. | ||
481 | |||
482 | The memLevel parameter specifies how much memory should be allocated | ||
483 | for the internal compression state. memLevel=1 uses minimum memory but | ||
484 | is slow and reduces compression ratio; memLevel=9 uses maximum memory | ||
485 | for optimal speed. The default value is 8. See zconf.h for total memory | ||
486 | usage as a function of windowBits and memLevel. | ||
487 | |||
488 | The strategy parameter is used to tune the compression algorithm. Use the | ||
489 | value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a | ||
490 | filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no | ||
491 | string match), or Z_RLE to limit match distances to one (run-length | ||
492 | encoding). Filtered data consists mostly of small values with a somewhat | ||
493 | random distribution. In this case, the compression algorithm is tuned to | ||
494 | compress them better. The effect of Z_FILTERED is to force more Huffman | ||
495 | coding and less string matching; it is somewhat intermediate between | ||
496 | Z_DEFAULT and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as fast as | ||
497 | Z_HUFFMAN_ONLY, but give better compression for PNG image data. The strategy | ||
498 | parameter only affects the compression ratio but not the correctness of the | ||
499 | compressed output even if it is not set appropriately. | ||
500 | |||
501 | deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough | ||
502 | memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid | ||
503 | method). msg is set to null if there is no error message. deflateInit2 does | ||
504 | not perform any compression: this will be done by deflate(). | ||
505 | */ | ||
506 | |||
507 | ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, | ||
508 | const Bytef *dictionary, | ||
509 | uInt dictLength)); | ||
510 | /* | ||
511 | Initializes the compression dictionary from the given byte sequence | ||
512 | without producing any compressed output. This function must be called | ||
513 | immediately after deflateInit, deflateInit2 or deflateReset, before any | ||
514 | call of deflate. The compressor and decompressor must use exactly the same | ||
515 | dictionary (see inflateSetDictionary). | ||
516 | |||
517 | The dictionary should consist of strings (byte sequences) that are likely | ||
518 | to be encountered later in the data to be compressed, with the most commonly | ||
519 | used strings preferably put towards the end of the dictionary. Using a | ||
520 | dictionary is most useful when the data to be compressed is short and can be | ||
521 | predicted with good accuracy; the data can then be compressed better than | ||
522 | with the default empty dictionary. | ||
523 | |||
524 | Depending on the size of the compression data structures selected by | ||
525 | deflateInit or deflateInit2, a part of the dictionary may in effect be | ||
526 | discarded, for example if the dictionary is larger than the window size in | ||
527 | deflate or deflate2. Thus the strings most likely to be useful should be | ||
528 | put at the end of the dictionary, not at the front. | ||
529 | |||
530 | Upon return of this function, strm->adler is set to the adler32 value | ||
531 | of the dictionary; the decompressor may later use this value to determine | ||
532 | which dictionary has been used by the compressor. (The adler32 value | ||
533 | applies to the whole dictionary even if only a subset of the dictionary is | ||
534 | actually used by the compressor.) If a raw deflate was requested, then the | ||
535 | adler32 value is not computed and strm->adler is not set. | ||
536 | |||
537 | deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a | ||
538 | parameter is invalid (such as NULL dictionary) or the stream state is | ||
539 | inconsistent (for example if deflate has already been called for this stream | ||
540 | or if the compression method is bsort). deflateSetDictionary does not | ||
541 | perform any compression: this will be done by deflate(). | ||
542 | */ | ||
543 | |||
544 | ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, | ||
545 | z_streamp source)); | ||
546 | /* | ||
547 | Sets the destination stream as a complete copy of the source stream. | ||
548 | |||
549 | This function can be useful when several compression strategies will be | ||
550 | tried, for example when there are several ways of pre-processing the input | ||
551 | data with a filter. The streams that will be discarded should then be freed | ||
552 | by calling deflateEnd. Note that deflateCopy duplicates the internal | ||
553 | compression state which can be quite large, so this strategy is slow and | ||
554 | can consume lots of memory. | ||
555 | |||
556 | deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not | ||
557 | enough memory, Z_STREAM_ERROR if the source stream state was inconsistent | ||
558 | (such as zalloc being NULL). msg is left unchanged in both source and | ||
559 | destination. | ||
560 | */ | ||
561 | |||
562 | ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); | ||
563 | /* | ||
564 | This function is equivalent to deflateEnd followed by deflateInit, | ||
565 | but does not free and reallocate all the internal compression state. | ||
566 | The stream will keep the same compression level and any other attributes | ||
567 | that may have been set by deflateInit2. | ||
568 | |||
569 | deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source | ||
570 | stream state was inconsistent (such as zalloc or state being NULL). | ||
571 | */ | ||
572 | |||
573 | ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, | ||
574 | int level, | ||
575 | int strategy)); | ||
576 | /* | ||
577 | Dynamically update the compression level and compression strategy. The | ||
578 | interpretation of level and strategy is as in deflateInit2. This can be | ||
579 | used to switch between compression and straight copy of the input data, or | ||
580 | to switch to a different kind of input data requiring a different | ||
581 | strategy. If the compression level is changed, the input available so far | ||
582 | is compressed with the old level (and may be flushed); the new level will | ||
583 | take effect only at the next call of deflate(). | ||
584 | |||
585 | Before the call of deflateParams, the stream state must be set as for | ||
586 | a call of deflate(), since the currently available input may have to | ||
587 | be compressed and flushed. In particular, strm->avail_out must be non-zero. | ||
588 | |||
589 | deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source | ||
590 | stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR | ||
591 | if strm->avail_out was zero. | ||
592 | */ | ||
593 | |||
594 | ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, | ||
595 | uLong sourceLen)); | ||
596 | /* | ||
597 | deflateBound() returns an upper bound on the compressed size after | ||
598 | deflation of sourceLen bytes. It must be called after deflateInit() | ||
599 | or deflateInit2(). This would be used to allocate an output buffer | ||
600 | for deflation in a single pass, and so would be called before deflate(). | ||
601 | */ | ||
602 | |||
603 | ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, | ||
604 | int bits, | ||
605 | int value)); | ||
606 | /* | ||
607 | deflatePrime() inserts bits in the deflate output stream. The intent | ||
608 | is that this function is used to start off the deflate output with the | ||
609 | bits leftover from a previous deflate stream when appending to it. As such, | ||
610 | this function can only be used for raw deflate, and must be used before the | ||
611 | first deflate() call after a deflateInit2() or deflateReset(). bits must be | ||
612 | less than or equal to 16, and that many of the least significant bits of | ||
613 | value will be inserted in the output. | ||
614 | |||
615 | deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source | ||
616 | stream state was inconsistent. | ||
617 | */ | ||
618 | |||
619 | /* | ||
620 | ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, | ||
621 | int windowBits)); | ||
622 | |||
623 | This is another version of inflateInit with an extra parameter. The | ||
624 | fields next_in, avail_in, zalloc, zfree and opaque must be initialized | ||
625 | before by the caller. | ||
626 | |||
627 | The windowBits parameter is the base two logarithm of the maximum window | ||
628 | size (the size of the history buffer). It should be in the range 8..15 for | ||
629 | this version of the library. The default value is 15 if inflateInit is used | ||
630 | instead. windowBits must be greater than or equal to the windowBits value | ||
631 | provided to deflateInit2() while compressing, or it must be equal to 15 if | ||
632 | deflateInit2() was not used. If a compressed stream with a larger window | ||
633 | size is given as input, inflate() will return with the error code | ||
634 | Z_DATA_ERROR instead of trying to allocate a larger window. | ||
635 | |||
636 | windowBits can also be -8..-15 for raw inflate. In this case, -windowBits | ||
637 | determines the window size. inflate() will then process raw deflate data, | ||
638 | not looking for a zlib or gzip header, not generating a check value, and not | ||
639 | looking for any check values for comparison at the end of the stream. This | ||
640 | is for use with other formats that use the deflate compressed data format | ||
641 | such as zip. Those formats provide their own check values. If a custom | ||
642 | format is developed using the raw deflate format for compressed data, it is | ||
643 | recommended that a check value such as an adler32 or a crc32 be applied to | ||
644 | the uncompressed data as is done in the zlib, gzip, and zip formats. For | ||
645 | most applications, the zlib format should be used as is. Note that comments | ||
646 | above on the use in deflateInit2() applies to the magnitude of windowBits. | ||
647 | |||
648 | windowBits can also be greater than 15 for optional gzip decoding. Add | ||
649 | 32 to windowBits to enable zlib and gzip decoding with automatic header | ||
650 | detection, or add 16 to decode only the gzip format (the zlib format will | ||
651 | return a Z_DATA_ERROR. If a gzip stream is being decoded, strm->adler is | ||
652 | a crc32 instead of an adler32. | ||
653 | |||
654 | inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough | ||
655 | memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative | ||
656 | memLevel). msg is set to null if there is no error message. inflateInit2 | ||
657 | does not perform any decompression apart from reading the zlib header if | ||
658 | present: this will be done by inflate(). (So next_in and avail_in may be | ||
659 | modified, but next_out and avail_out are unchanged.) | ||
660 | */ | ||
661 | |||
662 | ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, | ||
663 | const Bytef *dictionary, | ||
664 | uInt dictLength)); | ||
665 | /* | ||
666 | Initializes the decompression dictionary from the given uncompressed byte | ||
667 | sequence. This function must be called immediately after a call of inflate | ||
668 | if this call returned Z_NEED_DICT. The dictionary chosen by the compressor | ||
669 | can be determined from the adler32 value returned by this call of | ||
670 | inflate. The compressor and decompressor must use exactly the same | ||
671 | dictionary (see deflateSetDictionary). | ||
672 | |||
673 | inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a | ||
674 | parameter is invalid (such as NULL dictionary) or the stream state is | ||
675 | inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the | ||
676 | expected one (incorrect adler32 value). inflateSetDictionary does not | ||
677 | perform any decompression: this will be done by subsequent calls of | ||
678 | inflate(). | ||
679 | */ | ||
680 | |||
681 | ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); | ||
682 | /* | ||
683 | Skips invalid compressed data until a full flush point (see above the | ||
684 | description of deflate with Z_FULL_FLUSH) can be found, or until all | ||
685 | available input is skipped. No output is provided. | ||
686 | |||
687 | inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR | ||
688 | if no more input was provided, Z_DATA_ERROR if no flush point has been found, | ||
689 | or Z_STREAM_ERROR if the stream structure was inconsistent. In the success | ||
690 | case, the application may save the current current value of total_in which | ||
691 | indicates where valid compressed data was found. In the error case, the | ||
692 | application may repeatedly call inflateSync, providing more input each time, | ||
693 | until success or end of the input data. | ||
694 | */ | ||
695 | |||
696 | ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, | ||
697 | z_streamp source)); | ||
698 | /* | ||
699 | Sets the destination stream as a complete copy of the source stream. | ||
700 | |||
701 | This function can be useful when randomly accessing a large stream. The | ||
702 | first pass through the stream can periodically record the inflate state, | ||
703 | allowing restarting inflate at those points when randomly accessing the | ||
704 | stream. | ||
705 | |||
706 | inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not | ||
707 | enough memory, Z_STREAM_ERROR if the source stream state was inconsistent | ||
708 | (such as zalloc being NULL). msg is left unchanged in both source and | ||
709 | destination. | ||
710 | */ | ||
711 | |||
712 | ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); | ||
713 | /* | ||
714 | This function is equivalent to inflateEnd followed by inflateInit, | ||
715 | but does not free and reallocate all the internal decompression state. | ||
716 | The stream will keep attributes that may have been set by inflateInit2. | ||
717 | |||
718 | inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source | ||
719 | stream state was inconsistent (such as zalloc or state being NULL). | ||
720 | */ | ||
721 | |||
722 | /* | ||
723 | ZEXTERN int ZEXPORT inflateBackInit OF((z_stream FAR *strm, int windowBits, | ||
724 | unsigned char FAR *window)); | ||
725 | |||
726 | Initialize the internal stream state for decompression using inflateBack() | ||
727 | calls. The fields zalloc, zfree and opaque in strm must be initialized | ||
728 | before the call. If zalloc and zfree are Z_NULL, then the default library- | ||
729 | derived memory allocation routines are used. windowBits is the base two | ||
730 | logarithm of the window size, in the range 8..15. window is a caller | ||
731 | supplied buffer of that size. Except for special applications where it is | ||
732 | assured that deflate was used with small window sizes, windowBits must be 15 | ||
733 | and a 32K byte window must be supplied to be able to decompress general | ||
734 | deflate streams. | ||
735 | |||
736 | See inflateBack() for the usage of these routines. | ||
737 | |||
738 | inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of | ||
739 | the paramaters are invalid, Z_MEM_ERROR if the internal state could not | ||
740 | be allocated, or Z_VERSION_ERROR if the version of the library does not | ||
741 | match the version of the header file. | ||
742 | */ | ||
743 | |||
744 | typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *)); | ||
745 | typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); | ||
746 | |||
747 | ZEXTERN int ZEXPORT inflateBack OF((z_stream FAR *strm, | ||
748 | in_func in, void FAR *in_desc, | ||
749 | out_func out, void FAR *out_desc)); | ||
750 | /* | ||
751 | inflateBack() does a raw inflate with a single call using a call-back | ||
752 | interface for input and output. This is more efficient than inflate() for | ||
753 | file i/o applications in that it avoids copying between the output and the | ||
754 | sliding window by simply making the window itself the output buffer. This | ||
755 | function trusts the application to not change the output buffer passed by | ||
756 | the output function, at least until inflateBack() returns. | ||
757 | |||
758 | inflateBackInit() must be called first to allocate the internal state | ||
759 | and to initialize the state with the user-provided window buffer. | ||
760 | inflateBack() may then be used multiple times to inflate a complete, raw | ||
761 | deflate stream with each call. inflateBackEnd() is then called to free | ||
762 | the allocated state. | ||
763 | |||
764 | A raw deflate stream is one with no zlib or gzip header or trailer. | ||
765 | This routine would normally be used in a utility that reads zip or gzip | ||
766 | files and writes out uncompressed files. The utility would decode the | ||
767 | header and process the trailer on its own, hence this routine expects | ||
768 | only the raw deflate stream to decompress. This is different from the | ||
769 | normal behavior of inflate(), which expects either a zlib or gzip header and | ||
770 | trailer around the deflate stream. | ||
771 | |||
772 | inflateBack() uses two subroutines supplied by the caller that are then | ||
773 | called by inflateBack() for input and output. inflateBack() calls those | ||
774 | routines until it reads a complete deflate stream and writes out all of the | ||
775 | uncompressed data, or until it encounters an error. The function's | ||
776 | parameters and return types are defined above in the in_func and out_func | ||
777 | typedefs. inflateBack() will call in(in_desc, &buf) which should return the | ||
778 | number of bytes of provided input, and a pointer to that input in buf. If | ||
779 | there is no input available, in() must return zero--buf is ignored in that | ||
780 | case--and inflateBack() will return a buffer error. inflateBack() will call | ||
781 | out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out() | ||
782 | should return zero on success, or non-zero on failure. If out() returns | ||
783 | non-zero, inflateBack() will return with an error. Neither in() nor out() | ||
784 | are permitted to change the contents of the window provided to | ||
785 | inflateBackInit(), which is also the buffer that out() uses to write from. | ||
786 | The length written by out() will be at most the window size. Any non-zero | ||
787 | amount of input may be provided by in(). | ||
788 | |||
789 | For convenience, inflateBack() can be provided input on the first call by | ||
790 | setting strm->next_in and strm->avail_in. If that input is exhausted, then | ||
791 | in() will be called. Therefore strm->next_in must be initialized before | ||
792 | calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called | ||
793 | immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in | ||
794 | must also be initialized, and then if strm->avail_in is not zero, input will | ||
795 | initially be taken from strm->next_in[0 .. strm->avail_in - 1]. | ||
796 | |||
797 | The in_desc and out_desc parameters of inflateBack() is passed as the | ||
798 | first parameter of in() and out() respectively when they are called. These | ||
799 | descriptors can be optionally used to pass any information that the caller- | ||
800 | supplied in() and out() functions need to do their job. | ||
801 | |||
802 | On return, inflateBack() will set strm->next_in and strm->avail_in to | ||
803 | pass back any unused input that was provided by the last in() call. The | ||
804 | return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR | ||
805 | if in() or out() returned an error, Z_DATA_ERROR if there was a format | ||
806 | error in the deflate stream (in which case strm->msg is set to indicate the | ||
807 | nature of the error), or Z_STREAM_ERROR if the stream was not properly | ||
808 | initialized. In the case of Z_BUF_ERROR, an input or output error can be | ||
809 | distinguished using strm->next_in which will be Z_NULL only if in() returned | ||
810 | an error. If strm->next is not Z_NULL, then the Z_BUF_ERROR was due to | ||
811 | out() returning non-zero. (in() will always be called before out(), so | ||
812 | strm->next_in is assured to be defined if out() returns non-zero.) Note | ||
813 | that inflateBack() cannot return Z_OK. | ||
814 | */ | ||
815 | |||
816 | ZEXTERN int ZEXPORT inflateBackEnd OF((z_stream FAR *strm)); | ||
817 | /* | ||
818 | All memory allocated by inflateBackInit() is freed. | ||
819 | |||
820 | inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream | ||
821 | state was inconsistent. | ||
822 | */ | ||
823 | |||
824 | ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); | ||
825 | /* Return flags indicating compile-time options. | ||
826 | |||
827 | Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: | ||
828 | 1.0: size of uInt | ||
829 | 3.2: size of uLong | ||
830 | 5.4: size of voidpf (pointer) | ||
831 | 7.6: size of z_off_t | ||
832 | |||
833 | Compiler, assembler, and debug options: | ||
834 | 8: DEBUG | ||
835 | 9: ASMV or ASMINF -- use ASM code | ||
836 | 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention | ||
837 | 11: 0 (reserved) | ||
838 | |||
839 | One-time table building (smaller code, but not thread-safe if true): | ||
840 | 12: BUILDFIXED -- build static block decoding tables when needed | ||
841 | 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed | ||
842 | 14,15: 0 (reserved) | ||
843 | |||
844 | Library content (indicates missing functionality): | ||
845 | 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking | ||
846 | deflate code when not needed) | ||
847 | 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect | ||
848 | and decode gzip streams (to avoid linking crc code) | ||
849 | 18-19: 0 (reserved) | ||
850 | |||
851 | Operation variations (changes in library functionality): | ||
852 | 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate | ||
853 | 21: FASTEST -- deflate algorithm with only one, lowest compression level | ||
854 | 22,23: 0 (reserved) | ||
855 | |||
856 | The sprintf variant used by gzprintf (zero is best): | ||
857 | 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format | ||
858 | 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure! | ||
859 | 26: 0 = returns value, 1 = void -- 1 means inferred string length returned | ||
860 | |||
861 | Remainder: | ||
862 | 27-31: 0 (reserved) | ||
863 | */ | ||
864 | |||
865 | |||
866 | /* utility functions */ | ||
867 | |||
868 | /* | ||
869 | The following utility functions are implemented on top of the | ||
870 | basic stream-oriented functions. To simplify the interface, some | ||
871 | default options are assumed (compression level and memory usage, | ||
872 | standard memory allocation functions). The source code of these | ||
873 | utility functions can easily be modified if you need special options. | ||
874 | */ | ||
875 | |||
876 | ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, | ||
877 | const Bytef *source, uLong sourceLen)); | ||
878 | /* | ||
879 | Compresses the source buffer into the destination buffer. sourceLen is | ||
880 | the byte length of the source buffer. Upon entry, destLen is the total | ||
881 | size of the destination buffer, which must be at least the value returned | ||
882 | by compressBound(sourceLen). Upon exit, destLen is the actual size of the | ||
883 | compressed buffer. | ||
884 | This function can be used to compress a whole file at once if the | ||
885 | input file is mmap'ed. | ||
886 | compress returns Z_OK if success, Z_MEM_ERROR if there was not | ||
887 | enough memory, Z_BUF_ERROR if there was not enough room in the output | ||
888 | buffer. | ||
889 | */ | ||
890 | |||
891 | ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, | ||
892 | const Bytef *source, uLong sourceLen, | ||
893 | int level)); | ||
894 | /* | ||
895 | Compresses the source buffer into the destination buffer. The level | ||
896 | parameter has the same meaning as in deflateInit. sourceLen is the byte | ||
897 | length of the source buffer. Upon entry, destLen is the total size of the | ||
898 | destination buffer, which must be at least the value returned by | ||
899 | compressBound(sourceLen). Upon exit, destLen is the actual size of the | ||
900 | compressed buffer. | ||
901 | |||
902 | compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough | ||
903 | memory, Z_BUF_ERROR if there was not enough room in the output buffer, | ||
904 | Z_STREAM_ERROR if the level parameter is invalid. | ||
905 | */ | ||
906 | |||
907 | ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); | ||
908 | /* | ||
909 | compressBound() returns an upper bound on the compressed size after | ||
910 | compress() or compress2() on sourceLen bytes. It would be used before | ||
911 | a compress() or compress2() call to allocate the destination buffer. | ||
912 | */ | ||
913 | |||
914 | ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, | ||
915 | const Bytef *source, uLong sourceLen)); | ||
916 | /* | ||
917 | Decompresses the source buffer into the destination buffer. sourceLen is | ||
918 | the byte length of the source buffer. Upon entry, destLen is the total | ||
919 | size of the destination buffer, which must be large enough to hold the | ||
920 | entire uncompressed data. (The size of the uncompressed data must have | ||
921 | been saved previously by the compressor and transmitted to the decompressor | ||
922 | by some mechanism outside the scope of this compression library.) | ||
923 | Upon exit, destLen is the actual size of the compressed buffer. | ||
924 | This function can be used to decompress a whole file at once if the | ||
925 | input file is mmap'ed. | ||
926 | |||
927 | uncompress returns Z_OK if success, Z_MEM_ERROR if there was not | ||
928 | enough memory, Z_BUF_ERROR if there was not enough room in the output | ||
929 | buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. | ||
930 | */ | ||
931 | |||
932 | |||
933 | typedef voidp gzFile; | ||
934 | |||
935 | ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); | ||
936 | /* | ||
937 | Opens a gzip (.gz) file for reading or writing. The mode parameter | ||
938 | is as in fopen ("rb" or "wb") but can also include a compression level | ||
939 | ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for | ||
940 | Huffman only compression as in "wb1h", or 'R' for run-length encoding | ||
941 | as in "wb1R". (See the description of deflateInit2 for more information | ||
942 | about the strategy parameter.) | ||
943 | |||
944 | gzopen can be used to read a file which is not in gzip format; in this | ||
945 | case gzread will directly read from the file without decompression. | ||
946 | |||
947 | gzopen returns NULL if the file could not be opened or if there was | ||
948 | insufficient memory to allocate the (de)compression state; errno | ||
949 | can be checked to distinguish the two cases (if errno is zero, the | ||
950 | zlib error is Z_MEM_ERROR). */ | ||
951 | |||
952 | ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); | ||
953 | /* | ||
954 | gzdopen() associates a gzFile with the file descriptor fd. File | ||
955 | descriptors are obtained from calls like open, dup, creat, pipe or | ||
956 | fileno (in the file has been previously opened with fopen). | ||
957 | The mode parameter is as in gzopen. | ||
958 | The next call of gzclose on the returned gzFile will also close the | ||
959 | file descriptor fd, just like fclose(fdopen(fd), mode) closes the file | ||
960 | descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode). | ||
961 | gzdopen returns NULL if there was insufficient memory to allocate | ||
962 | the (de)compression state. | ||
963 | */ | ||
964 | |||
965 | ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); | ||
966 | /* | ||
967 | Dynamically update the compression level or strategy. See the description | ||
968 | of deflateInit2 for the meaning of these parameters. | ||
969 | gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not | ||
970 | opened for writing. | ||
971 | */ | ||
972 | |||
973 | ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); | ||
974 | /* | ||
975 | Reads the given number of uncompressed bytes from the compressed file. | ||
976 | If the input file was not in gzip format, gzread copies the given number | ||
977 | of bytes into the buffer. | ||
978 | gzread returns the number of uncompressed bytes actually read (0 for | ||
979 | end of file, -1 for error). */ | ||
980 | |||
981 | ZEXTERN int ZEXPORT gzwrite OF((gzFile file, | ||
982 | voidpc buf, unsigned len)); | ||
983 | /* | ||
984 | Writes the given number of uncompressed bytes into the compressed file. | ||
985 | gzwrite returns the number of uncompressed bytes actually written | ||
986 | (0 in case of error). | ||
987 | */ | ||
988 | |||
989 | ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); | ||
990 | /* | ||
991 | Converts, formats, and writes the args to the compressed file under | ||
992 | control of the format string, as in fprintf. gzprintf returns the number of | ||
993 | uncompressed bytes actually written (0 in case of error). The number of | ||
994 | uncompressed bytes written is limited to 4095. The caller should assure that | ||
995 | this limit is not exceeded. If it is exceeded, then gzprintf() will return | ||
996 | return an error (0) with nothing written. In this case, there may also be a | ||
997 | buffer overflow with unpredictable consequences, which is possible only if | ||
998 | zlib was compiled with the insecure functions sprintf() or vsprintf() | ||
999 | because the secure snprintf() or vsnprintf() functions were not available. | ||
1000 | */ | ||
1001 | |||
1002 | ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); | ||
1003 | /* | ||
1004 | Writes the given null-terminated string to the compressed file, excluding | ||
1005 | the terminating null character. | ||
1006 | gzputs returns the number of characters written, or -1 in case of error. | ||
1007 | */ | ||
1008 | |||
1009 | ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); | ||
1010 | /* | ||
1011 | Reads bytes from the compressed file until len-1 characters are read, or | ||
1012 | a newline character is read and transferred to buf, or an end-of-file | ||
1013 | condition is encountered. The string is then terminated with a null | ||
1014 | character. | ||
1015 | gzgets returns buf, or Z_NULL in case of error. | ||
1016 | */ | ||
1017 | |||
1018 | ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); | ||
1019 | /* | ||
1020 | Writes c, converted to an unsigned char, into the compressed file. | ||
1021 | gzputc returns the value that was written, or -1 in case of error. | ||
1022 | */ | ||
1023 | |||
1024 | ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); | ||
1025 | /* | ||
1026 | Reads one byte from the compressed file. gzgetc returns this byte | ||
1027 | or -1 in case of end of file or error. | ||
1028 | */ | ||
1029 | |||
1030 | ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); | ||
1031 | /* | ||
1032 | Push one character back onto the stream to be read again later. | ||
1033 | Only one character of push-back is allowed. gzungetc() returns the | ||
1034 | character pushed, or -1 on failure. gzungetc() will fail if a | ||
1035 | character has been pushed but not read yet, or if c is -1. The pushed | ||
1036 | character will be discarded if the stream is repositioned with gzseek() | ||
1037 | or gzrewind(). | ||
1038 | */ | ||
1039 | |||
1040 | ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); | ||
1041 | /* | ||
1042 | Flushes all pending output into the compressed file. The parameter | ||
1043 | flush is as in the deflate() function. The return value is the zlib | ||
1044 | error number (see function gzerror below). gzflush returns Z_OK if | ||
1045 | the flush parameter is Z_FINISH and all output could be flushed. | ||
1046 | gzflush should be called only when strictly necessary because it can | ||
1047 | degrade compression. | ||
1048 | */ | ||
1049 | |||
1050 | ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, | ||
1051 | z_off_t offset, int whence)); | ||
1052 | /* | ||
1053 | Sets the starting position for the next gzread or gzwrite on the | ||
1054 | given compressed file. The offset represents a number of bytes in the | ||
1055 | uncompressed data stream. The whence parameter is defined as in lseek(2); | ||
1056 | the value SEEK_END is not supported. | ||
1057 | If the file is opened for reading, this function is emulated but can be | ||
1058 | extremely slow. If the file is opened for writing, only forward seeks are | ||
1059 | supported; gzseek then compresses a sequence of zeroes up to the new | ||
1060 | starting position. | ||
1061 | |||
1062 | gzseek returns the resulting offset location as measured in bytes from | ||
1063 | the beginning of the uncompressed stream, or -1 in case of error, in | ||
1064 | particular if the file is opened for writing and the new starting position | ||
1065 | would be before the current position. | ||
1066 | */ | ||
1067 | |||
1068 | ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); | ||
1069 | /* | ||
1070 | Rewinds the given file. This function is supported only for reading. | ||
1071 | |||
1072 | gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) | ||
1073 | */ | ||
1074 | |||
1075 | ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); | ||
1076 | /* | ||
1077 | Returns the starting position for the next gzread or gzwrite on the | ||
1078 | given compressed file. This position represents a number of bytes in the | ||
1079 | uncompressed data stream. | ||
1080 | |||
1081 | gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) | ||
1082 | */ | ||
1083 | |||
1084 | ZEXTERN int ZEXPORT gzeof OF((gzFile file)); | ||
1085 | /* | ||
1086 | Returns 1 when EOF has previously been detected reading the given | ||
1087 | input stream, otherwise zero. | ||
1088 | */ | ||
1089 | |||
1090 | ZEXTERN int ZEXPORT gzclose OF((gzFile file)); | ||
1091 | /* | ||
1092 | Flushes all pending output if necessary, closes the compressed file | ||
1093 | and deallocates all the (de)compression state. The return value is the zlib | ||
1094 | error number (see function gzerror below). | ||
1095 | */ | ||
1096 | |||
1097 | ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); | ||
1098 | /* | ||
1099 | Returns the error message for the last error which occurred on the | ||
1100 | given compressed file. errnum is set to zlib error number. If an | ||
1101 | error occurred in the file system and not in the compression library, | ||
1102 | errnum is set to Z_ERRNO and the application may consult errno | ||
1103 | to get the exact error code. | ||
1104 | */ | ||
1105 | |||
1106 | ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); | ||
1107 | /* | ||
1108 | Clears the error and end-of-file flags for file. This is analogous to the | ||
1109 | clearerr() function in stdio. This is useful for continuing to read a gzip | ||
1110 | file that is being written concurrently. | ||
1111 | */ | ||
1112 | |||
1113 | /* checksum functions */ | ||
1114 | |||
1115 | /* | ||
1116 | These functions are not related to compression but are exported | ||
1117 | anyway because they might be useful in applications using the | ||
1118 | compression library. | ||
1119 | */ | ||
1120 | |||
1121 | ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); | ||
1122 | |||
1123 | /* | ||
1124 | Update a running Adler-32 checksum with the bytes buf[0..len-1] and | ||
1125 | return the updated checksum. If buf is NULL, this function returns | ||
1126 | the required initial value for the checksum. | ||
1127 | An Adler-32 checksum is almost as reliable as a CRC32 but can be computed | ||
1128 | much faster. Usage example: | ||
1129 | |||
1130 | uLong adler = adler32(0L, Z_NULL, 0); | ||
1131 | |||
1132 | while (read_buffer(buffer, length) != EOF) { | ||
1133 | adler = adler32(adler, buffer, length); | ||
1134 | } | ||
1135 | if (adler != original_adler) error(); | ||
1136 | */ | ||
1137 | |||
1138 | ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); | ||
1139 | /* | ||
1140 | Update a running crc with the bytes buf[0..len-1] and return the updated | ||
1141 | crc. If buf is NULL, this function returns the required initial value | ||
1142 | for the crc. Pre- and post-conditioning (one's complement) is performed | ||
1143 | within this function so it shouldn't be done by the application. | ||
1144 | Usage example: | ||
1145 | |||
1146 | uLong crc = crc32(0L, Z_NULL, 0); | ||
1147 | |||
1148 | while (read_buffer(buffer, length) != EOF) { | ||
1149 | crc = crc32(crc, buffer, length); | ||
1150 | } | ||
1151 | if (crc != original_crc) error(); | ||
1152 | */ | ||
1153 | |||
1154 | |||
1155 | /* various hacks, don't look :) */ | ||
1156 | |||
1157 | /* deflateInit and inflateInit are macros to allow checking the zlib version | ||
1158 | * and the compiler's view of z_stream: | ||
1159 | */ | ||
1160 | ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, | ||
1161 | const char *version, int stream_size)); | ||
1162 | ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, | ||
1163 | const char *version, int stream_size)); | ||
1164 | ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, | ||
1165 | int windowBits, int memLevel, | ||
1166 | int strategy, const char *version, | ||
1167 | int stream_size)); | ||
1168 | ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, | ||
1169 | const char *version, int stream_size)); | ||
1170 | ZEXTERN int ZEXPORT inflateBackInit_ OF((z_stream FAR *strm, int windowBits, | ||
1171 | unsigned char FAR *window, | ||
1172 | const char *version, | ||
1173 | int stream_size)); | ||
1174 | #define deflateInit(strm, level) \ | ||
1175 | deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) | ||
1176 | #define inflateInit(strm) \ | ||
1177 | inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) | ||
1178 | #define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ | ||
1179 | deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ | ||
1180 | (strategy), ZLIB_VERSION, sizeof(z_stream)) | ||
1181 | #define inflateInit2(strm, windowBits) \ | ||
1182 | inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) | ||
1183 | #define inflateBackInit(strm, windowBits, window) \ | ||
1184 | inflateBackInit_((strm), (windowBits), (window), \ | ||
1185 | ZLIB_VERSION, sizeof(z_stream)) | ||
1186 | |||
1187 | |||
1188 | #if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) | ||
1189 | struct internal_state {int dummy;}; /* hack for buggy compilers */ | ||
1190 | #endif | ||
1191 | |||
1192 | ZEXTERN const char * ZEXPORT zError OF((int)); | ||
1193 | ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)); | ||
1194 | ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); | ||
1195 | |||
1196 | #ifdef __cplusplus | ||
1197 | } | ||
1198 | #endif | ||
1199 | |||
1200 | #endif /* ZLIB_H */ | ||