git.saurik.com Git - wxWidgets.git/blame_incremental

... / ...

Commit	Line	Data
	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	DECLARE_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	DECLARE_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__