]> git.saurik.com Git - wxWidgets.git/blob - include/wx/zipstrm.h
Document that wxDC::FloodFill() is not implemented under wxOSX.
[wxWidgets.git] / include / wx / zipstrm.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/zipstrm.h
3 // Purpose: Streams for Zip files
4 // Author: Mike Wetherell
5 // RCS-ID: $Id$
6 // Copyright: (c) Mike Wetherell
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 #ifndef _WX_WXZIPSTREAM_H__
11 #define _WX_WXZIPSTREAM_H__
12
13 #include "wx/defs.h"
14
15 #if wxUSE_ZIPSTREAM
16
17 #include "wx/archive.h"
18 #include "wx/filename.h"
19
20 // some methods from wxZipInputStream and wxZipOutputStream stream do not get
21 // exported/imported when compiled with Mingw versions before 3.4.2. So they
22 // are imported/exported individually as a workaround
23 #if (defined(__GNUWIN32__) || defined(__MINGW32__)) \
24 && (!defined __GNUC__ \
25 || !defined __GNUC_MINOR__ \
26 || !defined __GNUC_PATCHLEVEL__ \
27 || __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ < 30402)
28 #define WXZIPFIX WXDLLIMPEXP_BASE
29 #else
30 #define WXZIPFIX
31 #endif
32
33 /////////////////////////////////////////////////////////////////////////////
34 // constants
35
36 // Compression Method, only 0 (store) and 8 (deflate) are supported here
37 //
38 enum wxZipMethod
39 {
40 wxZIP_METHOD_STORE,
41 wxZIP_METHOD_SHRINK,
42 wxZIP_METHOD_REDUCE1,
43 wxZIP_METHOD_REDUCE2,
44 wxZIP_METHOD_REDUCE3,
45 wxZIP_METHOD_REDUCE4,
46 wxZIP_METHOD_IMPLODE,
47 wxZIP_METHOD_TOKENIZE,
48 wxZIP_METHOD_DEFLATE,
49 wxZIP_METHOD_DEFLATE64,
50 wxZIP_METHOD_BZIP2 = 12,
51 wxZIP_METHOD_DEFAULT = 0xffff
52 };
53
54 // Originating File-System.
55 //
56 // These are Pkware's values. Note that Info-zip disagree on some of them,
57 // most notably NTFS.
58 //
59 enum wxZipSystem
60 {
61 wxZIP_SYSTEM_MSDOS,
62 wxZIP_SYSTEM_AMIGA,
63 wxZIP_SYSTEM_OPENVMS,
64 wxZIP_SYSTEM_UNIX,
65 wxZIP_SYSTEM_VM_CMS,
66 wxZIP_SYSTEM_ATARI_ST,
67 wxZIP_SYSTEM_OS2_HPFS,
68 wxZIP_SYSTEM_MACINTOSH,
69 wxZIP_SYSTEM_Z_SYSTEM,
70 wxZIP_SYSTEM_CPM,
71 wxZIP_SYSTEM_WINDOWS_NTFS,
72 wxZIP_SYSTEM_MVS,
73 wxZIP_SYSTEM_VSE,
74 wxZIP_SYSTEM_ACORN_RISC,
75 wxZIP_SYSTEM_VFAT,
76 wxZIP_SYSTEM_ALTERNATE_MVS,
77 wxZIP_SYSTEM_BEOS,
78 wxZIP_SYSTEM_TANDEM,
79 wxZIP_SYSTEM_OS_400
80 };
81
82 // Dos/Win file attributes
83 //
84 enum wxZipAttributes
85 {
86 wxZIP_A_RDONLY = 0x01,
87 wxZIP_A_HIDDEN = 0x02,
88 wxZIP_A_SYSTEM = 0x04,
89 wxZIP_A_SUBDIR = 0x10,
90 wxZIP_A_ARCH = 0x20,
91
92 wxZIP_A_MASK = 0x37
93 };
94
95 // Values for the flags field in the zip headers
96 //
97 enum wxZipFlags
98 {
99 wxZIP_ENCRYPTED = 0x0001,
100 wxZIP_DEFLATE_NORMAL = 0x0000, // normal compression
101 wxZIP_DEFLATE_EXTRA = 0x0002, // extra compression
102 wxZIP_DEFLATE_FAST = 0x0004, // fast compression
103 wxZIP_DEFLATE_SUPERFAST = 0x0006, // superfast compression
104 wxZIP_DEFLATE_MASK = 0x0006,
105 wxZIP_SUMS_FOLLOW = 0x0008, // crc and sizes come after the data
106 wxZIP_ENHANCED = 0x0010,
107 wxZIP_PATCH = 0x0020,
108 wxZIP_STRONG_ENC = 0x0040,
109 wxZIP_UNUSED = 0x0F80,
110 wxZIP_RESERVED = 0xF000
111 };
112
113 // Forward decls
114 //
115 class WXDLLIMPEXP_FWD_BASE wxZipEntry;
116 class WXDLLIMPEXP_FWD_BASE wxZipInputStream;
117
118
119 /////////////////////////////////////////////////////////////////////////////
120 // wxZipNotifier
121
122 class WXDLLIMPEXP_BASE wxZipNotifier
123 {
124 public:
125 virtual ~wxZipNotifier() { }
126
127 virtual void OnEntryUpdated(wxZipEntry& entry) = 0;
128 };
129
130
131 /////////////////////////////////////////////////////////////////////////////
132 // Zip Entry - holds the meta data for a file in the zip
133
134 class WXDLLIMPEXP_BASE wxZipEntry : public wxArchiveEntry
135 {
136 public:
137 wxZipEntry(const wxString& name = wxEmptyString,
138 const wxDateTime& dt = wxDateTime::Now(),
139 wxFileOffset size = wxInvalidOffset);
140 virtual ~wxZipEntry();
141
142 wxZipEntry(const wxZipEntry& entry);
143 wxZipEntry& operator=(const wxZipEntry& entry);
144
145 // Get accessors
146 wxDateTime GetDateTime() const { return m_DateTime; }
147 wxFileOffset GetSize() const { return m_Size; }
148 wxFileOffset GetOffset() const { return m_Offset; }
149 wxString GetInternalName() const { return m_Name; }
150 int GetMethod() const { return m_Method; }
151 int GetFlags() const { return m_Flags; }
152 wxUint32 GetCrc() const { return m_Crc; }
153 wxFileOffset GetCompressedSize() const { return m_CompressedSize; }
154 int GetSystemMadeBy() const { return m_SystemMadeBy; }
155 wxString GetComment() const { return m_Comment; }
156 wxUint32 GetExternalAttributes() const { return m_ExternalAttributes; }
157 wxPathFormat GetInternalFormat() const { return wxPATH_UNIX; }
158 int GetMode() const;
159 const char *GetLocalExtra() const;
160 size_t GetLocalExtraLen() const;
161 const char *GetExtra() const;
162 size_t GetExtraLen() const;
163 wxString GetName(wxPathFormat format = wxPATH_NATIVE) const;
164
165 // is accessors
166 inline bool IsDir() const;
167 inline bool IsText() const;
168 inline bool IsReadOnly() const;
169 inline bool IsMadeByUnix() const;
170
171 // set accessors
172 void SetDateTime(const wxDateTime& dt) { m_DateTime = dt; }
173 void SetSize(wxFileOffset size) { m_Size = size; }
174 void SetMethod(int method) { m_Method = (wxUint16)method; }
175 void SetComment(const wxString& comment) { m_Comment = comment; }
176 void SetExternalAttributes(wxUint32 attr ) { m_ExternalAttributes = attr; }
177 void SetSystemMadeBy(int system);
178 void SetMode(int mode);
179 void SetExtra(const char *extra, size_t len);
180 void SetLocalExtra(const char *extra, size_t len);
181
182 inline void SetName(const wxString& name,
183 wxPathFormat format = wxPATH_NATIVE);
184
185 static wxString GetInternalName(const wxString& name,
186 wxPathFormat format = wxPATH_NATIVE,
187 bool *pIsDir = NULL);
188
189 // set is accessors
190 void SetIsDir(bool isDir = true);
191 inline void SetIsReadOnly(bool isReadOnly = true);
192 inline void SetIsText(bool isText = true);
193
194 wxZipEntry *Clone() const { return ZipClone(); }
195
196 void SetNotifier(wxZipNotifier& notifier);
197 void UnsetNotifier();
198
199 protected:
200 // Internal attributes
201 enum { TEXT_ATTR = 1 };
202
203 // protected Get accessors
204 int GetVersionNeeded() const { return m_VersionNeeded; }
205 wxFileOffset GetKey() const { return m_Key; }
206 int GetVersionMadeBy() const { return m_VersionMadeBy; }
207 int GetDiskStart() const { return m_DiskStart; }
208 int GetInternalAttributes() const { return m_InternalAttributes; }
209
210 void SetVersionNeeded(int version) { m_VersionNeeded = (wxUint16)version; }
211 void SetOffset(wxFileOffset offset) { m_Offset = offset; }
212 void SetFlags(int flags) { m_Flags = (wxUint16)flags; }
213 void SetVersionMadeBy(int version) { m_VersionMadeBy = (wxUint8)version; }
214 void SetCrc(wxUint32 crc) { m_Crc = crc; }
215 void SetCompressedSize(wxFileOffset size) { m_CompressedSize = size; }
216 void SetKey(wxFileOffset offset) { m_Key = offset; }
217 void SetDiskStart(int start) { m_DiskStart = (wxUint16)start; }
218 void SetInternalAttributes(int attr) { m_InternalAttributes = (wxUint16)attr; }
219
220 virtual wxZipEntry *ZipClone() const { return new wxZipEntry(*this); }
221
222 void Notify();
223
224 private:
225 wxArchiveEntry* DoClone() const { return ZipClone(); }
226
227 size_t ReadLocal(wxInputStream& stream, wxMBConv& conv);
228 size_t WriteLocal(wxOutputStream& stream, wxMBConv& conv) const;
229
230 size_t ReadCentral(wxInputStream& stream, wxMBConv& conv);
231 size_t WriteCentral(wxOutputStream& stream, wxMBConv& conv) const;
232
233 size_t ReadDescriptor(wxInputStream& stream);
234 size_t WriteDescriptor(wxOutputStream& stream, wxUint32 crc,
235 wxFileOffset compressedSize, wxFileOffset size);
236
237 wxUint8 m_SystemMadeBy; // one of enum wxZipSystem
238 wxUint8 m_VersionMadeBy; // major * 10 + minor
239
240 wxUint16 m_VersionNeeded; // ver needed to extract (20 i.e. v2.0)
241 wxUint16 m_Flags;
242 wxUint16 m_Method; // compression method (one of wxZipMethod)
243 wxDateTime m_DateTime;
244 wxUint32 m_Crc;
245 wxFileOffset m_CompressedSize;
246 wxFileOffset m_Size;
247 wxString m_Name; // in internal format
248 wxFileOffset m_Key; // the original offset for copied entries
249 wxFileOffset m_Offset; // file offset of the entry
250
251 wxString m_Comment;
252 wxUint16 m_DiskStart; // for multidisk archives, not unsupported
253 wxUint16 m_InternalAttributes; // bit 0 set for text files
254 wxUint32 m_ExternalAttributes; // system specific depends on SystemMadeBy
255
256 class wxZipMemory *m_Extra;
257 class wxZipMemory *m_LocalExtra;
258
259 wxZipNotifier *m_zipnotifier;
260 class wxZipWeakLinks *m_backlink;
261
262 friend class wxZipInputStream;
263 friend class wxZipOutputStream;
264
265 DECLARE_DYNAMIC_CLASS(wxZipEntry)
266 };
267
268
269 /////////////////////////////////////////////////////////////////////////////
270 // wxZipOutputStream
271
272 WX_DECLARE_LIST_WITH_DECL(wxZipEntry, wxZipEntryList_, class WXDLLIMPEXP_BASE);
273
274 class WXDLLIMPEXP_BASE wxZipOutputStream : public wxArchiveOutputStream
275 {
276 public:
277 wxZipOutputStream(wxOutputStream& stream,
278 int level = -1,
279 wxMBConv& conv = wxConvLocal);
280 wxZipOutputStream(wxOutputStream *stream,
281 int level = -1,
282 wxMBConv& conv = wxConvLocal);
283 virtual WXZIPFIX ~wxZipOutputStream();
284
285 bool PutNextEntry(wxZipEntry *entry) { return DoCreate(entry); }
286
287 bool WXZIPFIX PutNextEntry(const wxString& name,
288 const wxDateTime& dt = wxDateTime::Now(),
289 wxFileOffset size = wxInvalidOffset);
290
291 bool WXZIPFIX PutNextDirEntry(const wxString& name,
292 const wxDateTime& dt = wxDateTime::Now());
293
294 bool WXZIPFIX CopyEntry(wxZipEntry *entry, wxZipInputStream& inputStream);
295 bool WXZIPFIX CopyArchiveMetaData(wxZipInputStream& inputStream);
296
297 void WXZIPFIX Sync();
298 bool WXZIPFIX CloseEntry();
299 bool WXZIPFIX Close();
300
301 void SetComment(const wxString& comment) { m_Comment = comment; }
302
303 int GetLevel() const { return m_level; }
304 void WXZIPFIX SetLevel(int level);
305
306 protected:
307 virtual size_t WXZIPFIX OnSysWrite(const void *buffer, size_t size);
308 virtual wxFileOffset OnSysTell() const { return m_entrySize; }
309
310 // this protected interface isn't yet finalised
311 struct Buffer { const char *m_data; size_t m_size; };
312 virtual wxOutputStream* WXZIPFIX OpenCompressor(wxOutputStream& stream,
313 wxZipEntry& entry,
314 const Buffer bufs[]);
315 virtual bool WXZIPFIX CloseCompressor(wxOutputStream *comp);
316
317 bool IsParentSeekable() const
318 { return m_offsetAdjustment != wxInvalidOffset; }
319
320 private:
321 void Init(int level);
322
323 bool WXZIPFIX PutNextEntry(wxArchiveEntry *entry);
324 bool WXZIPFIX CopyEntry(wxArchiveEntry *entry, wxArchiveInputStream& stream);
325 bool WXZIPFIX CopyArchiveMetaData(wxArchiveInputStream& stream);
326
327 bool IsOpened() const { return m_comp || m_pending; }
328
329 bool DoCreate(wxZipEntry *entry, bool raw = false);
330 void CreatePendingEntry(const void *buffer, size_t size);
331 void CreatePendingEntry();
332
333 class wxStoredOutputStream *m_store;
334 class wxZlibOutputStream2 *m_deflate;
335 class wxZipStreamLink *m_backlink;
336 wxZipEntryList_ m_entries;
337 char *m_initialData;
338 size_t m_initialSize;
339 wxZipEntry *m_pending;
340 bool m_raw;
341 wxFileOffset m_headerOffset;
342 size_t m_headerSize;
343 wxFileOffset m_entrySize;
344 wxUint32 m_crcAccumulator;
345 wxOutputStream *m_comp;
346 int m_level;
347 wxFileOffset m_offsetAdjustment;
348 wxString m_Comment;
349 bool m_endrecWritten;
350
351 wxDECLARE_NO_COPY_CLASS(wxZipOutputStream);
352 };
353
354
355 /////////////////////////////////////////////////////////////////////////////
356 // wxZipInputStream
357
358 class WXDLLIMPEXP_BASE wxZipInputStream : public wxArchiveInputStream
359 {
360 public:
361 typedef wxZipEntry entry_type;
362
363 wxZipInputStream(wxInputStream& stream, wxMBConv& conv = wxConvLocal);
364 wxZipInputStream(wxInputStream *stream, wxMBConv& conv = wxConvLocal);
365
366 #if WXWIN_COMPATIBILITY_2_6 && wxUSE_FFILE
367 wxZipInputStream(const wxString& archive, const wxString& file)
368 : wxArchiveInputStream(OpenFile(archive), wxConvLocal) { Init(file); }
369 #endif
370
371 virtual WXZIPFIX ~wxZipInputStream();
372
373 bool OpenEntry(wxZipEntry& entry) { return DoOpen(&entry); }
374 bool WXZIPFIX CloseEntry();
375
376 wxZipEntry *GetNextEntry();
377
378 wxString WXZIPFIX GetComment();
379 int WXZIPFIX GetTotalEntries();
380
381 virtual wxFileOffset GetLength() const { return m_entry.GetSize(); }
382
383 protected:
384 size_t WXZIPFIX OnSysRead(void *buffer, size_t size);
385 wxFileOffset OnSysTell() const { return m_decomp ? m_decomp->TellI() : 0; }
386
387 #if WXWIN_COMPATIBILITY_2_6
388 wxFileOffset WXZIPFIX OnSysSeek(wxFileOffset seek, wxSeekMode mode);
389 #endif
390
391 // this protected interface isn't yet finalised
392 virtual wxInputStream* WXZIPFIX OpenDecompressor(wxInputStream& stream);
393 virtual bool WXZIPFIX CloseDecompressor(wxInputStream *decomp);
394
395 private:
396 void Init();
397 void Init(const wxString& file);
398 #if WXWIN_COMPATIBILITY_2_6 && wxUSE_FFILE
399 static wxInputStream *OpenFile(const wxString& archive);
400 #endif
401
402 wxArchiveEntry *DoGetNextEntry() { return GetNextEntry(); }
403
404 bool WXZIPFIX OpenEntry(wxArchiveEntry& entry);
405
406 wxStreamError ReadLocal(bool readEndRec = false);
407 wxStreamError ReadCentral();
408
409 wxUint32 ReadSignature();
410 bool FindEndRecord();
411 bool LoadEndRecord();
412
413 bool AtHeader() const { return m_headerSize == 0; }
414 bool AfterHeader() const { return m_headerSize > 0 && !m_decomp; }
415 bool IsOpened() const { return m_decomp != NULL; }
416
417 wxZipStreamLink *MakeLink(wxZipOutputStream *out);
418
419 bool DoOpen(wxZipEntry *entry = NULL, bool raw = false);
420 bool OpenDecompressor(bool raw = false);
421
422 class wxStoredInputStream *m_store;
423 class wxZlibInputStream2 *m_inflate;
424 class wxRawInputStream *m_rawin;
425 wxZipEntry m_entry;
426 bool m_raw;
427 size_t m_headerSize;
428 wxUint32 m_crcAccumulator;
429 wxInputStream *m_decomp;
430 bool m_parentSeekable;
431 class wxZipWeakLinks *m_weaklinks;
432 class wxZipStreamLink *m_streamlink;
433 wxFileOffset m_offsetAdjustment;
434 wxFileOffset m_position;
435 wxUint32 m_signature;
436 size_t m_TotalEntries;
437 wxString m_Comment;
438
439 friend bool wxZipOutputStream::CopyEntry(
440 wxZipEntry *entry, wxZipInputStream& inputStream);
441 friend bool wxZipOutputStream::CopyArchiveMetaData(
442 wxZipInputStream& inputStream);
443
444 #if WXWIN_COMPATIBILITY_2_6
445 bool m_allowSeeking;
446 friend class wxArchiveFSHandler;
447 #endif
448
449 wxDECLARE_NO_COPY_CLASS(wxZipInputStream);
450 };
451
452
453 /////////////////////////////////////////////////////////////////////////////
454 // Iterators
455
456 #if wxUSE_STL || defined WX_TEST_ARCHIVE_ITERATOR
457 typedef wxArchiveIterator<wxZipInputStream> wxZipIter;
458 typedef wxArchiveIterator<wxZipInputStream,
459 std::pair<wxString, wxZipEntry*> > wxZipPairIter;
460 #endif
461
462
463 /////////////////////////////////////////////////////////////////////////////
464 // wxZipClassFactory
465
466 class WXDLLIMPEXP_BASE wxZipClassFactory : public wxArchiveClassFactory
467 {
468 public:
469 typedef wxZipEntry entry_type;
470 typedef wxZipInputStream instream_type;
471 typedef wxZipOutputStream outstream_type;
472 typedef wxZipNotifier notifier_type;
473 #if wxUSE_STL || defined WX_TEST_ARCHIVE_ITERATOR
474 typedef wxZipIter iter_type;
475 typedef wxZipPairIter pairiter_type;
476 #endif
477
478 wxZipClassFactory();
479
480 wxZipEntry *NewEntry() const
481 { return new wxZipEntry; }
482 wxZipInputStream *NewStream(wxInputStream& stream) const
483 { return new wxZipInputStream(stream, GetConv()); }
484 wxZipOutputStream *NewStream(wxOutputStream& stream) const
485 { return new wxZipOutputStream(stream, -1, GetConv()); }
486 wxZipInputStream *NewStream(wxInputStream *stream) const
487 { return new wxZipInputStream(stream, GetConv()); }
488 wxZipOutputStream *NewStream(wxOutputStream *stream) const
489 { return new wxZipOutputStream(stream, -1, GetConv()); }
490
491 wxString GetInternalName(const wxString& name,
492 wxPathFormat format = wxPATH_NATIVE) const
493 { return wxZipEntry::GetInternalName(name, format); }
494
495 const wxChar * const *GetProtocols(wxStreamProtocolType type
496 = wxSTREAM_PROTOCOL) const;
497
498 protected:
499 wxArchiveEntry *DoNewEntry() const
500 { return NewEntry(); }
501 wxArchiveInputStream *DoNewStream(wxInputStream& stream) const
502 { return NewStream(stream); }
503 wxArchiveOutputStream *DoNewStream(wxOutputStream& stream) const
504 { return NewStream(stream); }
505 wxArchiveInputStream *DoNewStream(wxInputStream *stream) const
506 { return NewStream(stream); }
507 wxArchiveOutputStream *DoNewStream(wxOutputStream *stream) const
508 { return NewStream(stream); }
509
510 private:
511 DECLARE_DYNAMIC_CLASS(wxZipClassFactory)
512 };
513
514
515 /////////////////////////////////////////////////////////////////////////////
516 // wxZipEntry inlines
517
518 inline bool wxZipEntry::IsText() const
519 {
520 return (m_InternalAttributes & TEXT_ATTR) != 0;
521 }
522
523 inline bool wxZipEntry::IsDir() const
524 {
525 return (m_ExternalAttributes & wxZIP_A_SUBDIR) != 0;
526 }
527
528 inline bool wxZipEntry::IsReadOnly() const
529 {
530 return (m_ExternalAttributes & wxZIP_A_RDONLY) != 0;
531 }
532
533 inline bool wxZipEntry::IsMadeByUnix() const
534 {
535 const int pattern =
536 (1 << wxZIP_SYSTEM_OPENVMS) |
537 (1 << wxZIP_SYSTEM_UNIX) |
538 (1 << wxZIP_SYSTEM_ATARI_ST) |
539 (1 << wxZIP_SYSTEM_ACORN_RISC) |
540 (1 << wxZIP_SYSTEM_BEOS) | (1 << wxZIP_SYSTEM_TANDEM);
541
542 // note: some unix zippers put madeby = dos
543 return (m_SystemMadeBy == wxZIP_SYSTEM_MSDOS
544 && (m_ExternalAttributes & ~0xFFFF))
545 || ((pattern >> m_SystemMadeBy) & 1);
546 }
547
548 inline void wxZipEntry::SetIsText(bool isText)
549 {
550 if (isText)
551 m_InternalAttributes |= TEXT_ATTR;
552 else
553 m_InternalAttributes &= ~TEXT_ATTR;
554 }
555
556 inline void wxZipEntry::SetIsReadOnly(bool isReadOnly)
557 {
558 if (isReadOnly)
559 SetMode(GetMode() & ~0222);
560 else
561 SetMode(GetMode() | 0200);
562 }
563
564 inline void wxZipEntry::SetName(const wxString& name,
565 wxPathFormat format /*=wxPATH_NATIVE*/)
566 {
567 bool isDir;
568 m_Name = GetInternalName(name, format, &isDir);
569 SetIsDir(isDir);
570 }
571
572
573 #endif // wxUSE_ZIPSTREAM
574
575 #endif // _WX_WXZIPSTREAM_H__