[wxWidgets.git] / include / wx / zipstrm.h

/////////////////////////////////////////////////////////////////////////////
// Name:        zipstrm.h
// Purpose:     Streams for Zip files
// Author:      Mike Wetherell
// RCS-ID:      $Id$
// Copyright:   (c) Mike Wetherell
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifndef _WX_WXZIPSTREAM_H__
#define _WX_WXZIPSTREAM_H__

#include "wx/defs.h"

#if wxUSE_ZLIB && wxUSE_STREAMS && wxUSE_ZIPSTREAM

#include "wx/archive.h"
#include "wx/hashmap.h"
#include "wx/filename.h"

// some methods from wxZipInputStream and wxZipOutputStream stream do not get
// exported/imported when compiled with Mingw versions before 3.4.2. So they
// are imported/exported individually as a workaround
#if (defined(__GNUWIN32__) || defined(__MINGW32__)) \
    && (!defined __GNUC__ \
       || !defined __GNUC_MINOR__ \
       || !defined __GNUC_PATCHLEVEL__ \
       || __GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__ < 30402)
#define WXZIPFIX WXDLLIMPEXP_BASE 
#else
#define WXZIPFIX
#endif

/////////////////////////////////////////////////////////////////////////////
// constants

// Compression Method, only 0 (store) and 8 (deflate) are supported here
//
enum wxZipMethod
{
    wxZIP_METHOD_STORE,
    wxZIP_METHOD_SHRINK,
    wxZIP_METHOD_REDUCE1,
    wxZIP_METHOD_REDUCE2,
    wxZIP_METHOD_REDUCE3,
    wxZIP_METHOD_REDUCE4,
    wxZIP_METHOD_IMPLODE,
    wxZIP_METHOD_TOKENIZE,
    wxZIP_METHOD_DEFLATE,
    wxZIP_METHOD_DEFLATE64,
    wxZIP_METHOD_BZIP2 = 12,
    wxZIP_METHOD_DEFAULT = 0xffff
};

// Originating File-System.
// 
// These are Pkware's values. Note that Info-zip disagree on some of them,
// most notably NTFS.
//
enum wxZipSystem
{
    wxZIP_SYSTEM_MSDOS,
    wxZIP_SYSTEM_AMIGA,
    wxZIP_SYSTEM_OPENVMS,
    wxZIP_SYSTEM_UNIX,
    wxZIP_SYSTEM_VM_CMS,
    wxZIP_SYSTEM_ATARI_ST,
    wxZIP_SYSTEM_OS2_HPFS,
    wxZIP_SYSTEM_MACINTOSH,
    wxZIP_SYSTEM_Z_SYSTEM,
    wxZIP_SYSTEM_CPM,
    wxZIP_SYSTEM_WINDOWS_NTFS,
    wxZIP_SYSTEM_MVS,
    wxZIP_SYSTEM_VSE,
    wxZIP_SYSTEM_ACORN_RISC,
    wxZIP_SYSTEM_VFAT,
    wxZIP_SYSTEM_ALTERNATE_MVS,
    wxZIP_SYSTEM_BEOS,
    wxZIP_SYSTEM_TANDEM,
    wxZIP_SYSTEM_OS_400
};

// Dos/Win file attributes
//
enum wxZipAttributes
{
    wxZIP_A_RDONLY = 0x01,
    wxZIP_A_HIDDEN = 0x02,
    wxZIP_A_SYSTEM = 0x04,
    wxZIP_A_SUBDIR = 0x10,
    wxZIP_A_ARCH   = 0x20,

    wxZIP_A_MASK   = 0x37
};

// Values for the flags field in the zip headers
//
enum wxZipFlags
{
    wxZIP_ENCRYPTED         = 0x0001,
    wxZIP_DEFLATE_NORMAL    = 0x0000,   // normal compression
    wxZIP_DEFLATE_EXTRA     = 0x0002,   // extra compression
    wxZIP_DEFLATE_FAST      = 0x0004,   // fast compression
    wxZIP_DEFLATE_SUPERFAST = 0x0006,   // superfast compression
    wxZIP_DEFLATE_MASK      = 0x0006,
    wxZIP_SUMS_FOLLOW       = 0x0008,   // crc and sizes come after the data
    wxZIP_ENHANCED          = 0x0010,
    wxZIP_PATCH             = 0x0020,
    wxZIP_STRONG_ENC        = 0x0040,
    wxZIP_UNUSED            = 0x0F80,
    wxZIP_RESERVED          = 0xF000
};

// Forward decls
//
class WXDLLIMPEXP_BASE wxZipEntry;
class WXDLLIMPEXP_BASE wxZipInputStream;


/////////////////////////////////////////////////////////////////////////////
// wxZipNotifier

class WXDLLIMPEXP_BASE wxZipNotifier
{
public:
    virtual ~wxZipNotifier() { }

    virtual void OnEntryUpdated(wxZipEntry& entry) = 0;
};


/////////////////////////////////////////////////////////////////////////////
// Zip Entry - holds the meta data for a file in the zip

class WXDLLIMPEXP_BASE wxZipEntry : public wxArchiveEntry
{
public:
    wxZipEntry(const wxString& name = wxEmptyString,
               const wxDateTime& dt = wxDateTime::Now(),
               wxFileOffset size = wxInvalidOffset);
    virtual ~wxZipEntry();

    wxZipEntry(const wxZipEntry& entry);
    wxZipEntry& operator=(const wxZipEntry& entry);

    // Get accessors
    wxDateTime   GetDateTime() const            { return m_DateTime; }
    wxFileOffset GetSize() const                { return m_Size; }
    wxFileOffset GetOffset() const              { return m_Offset; }
    wxString     GetInternalName() const        { return m_Name; }
    int          GetMethod() const              { return m_Method; }
    int          GetFlags() const               { return m_Flags; }
    wxUint32     GetCrc() const                 { return m_Crc; }
    wxFileOffset GetCompressedSize() const      { return m_CompressedSize; }
    int          GetSystemMadeBy() const        { return m_SystemMadeBy; }
    wxString     GetComment() const             { return m_Comment; }
    wxUint32     GetExternalAttributes() const  { return m_ExternalAttributes; }
    wxPathFormat GetInternalFormat() const      { return wxPATH_UNIX; }
    int          GetMode() const;
    const char  *GetLocalExtra() const;
    size_t       GetLocalExtraLen() const;
    const char  *GetExtra() const;
    size_t       GetExtraLen() const;
    wxString     GetName(wxPathFormat format = wxPATH_NATIVE) const;

    // is accessors
    inline bool IsDir() const;
    inline bool IsText() const;
    inline bool IsReadOnly() const;
    inline bool IsMadeByUnix() const;

    // set accessors
    void SetDateTime(const wxDateTime& dt)      { m_DateTime = dt; }
    void SetSize(wxFileOffset size)             { m_Size = size; }
    void SetMethod(int method)                  { m_Method = (wxUint16)method; }
    void SetComment(const wxString& comment)    { m_Comment = comment; }
    void SetExternalAttributes(wxUint32 attr )  { m_ExternalAttributes = attr; }
    void SetSystemMadeBy(int system);
    void SetMode(int mode);
    void SetExtra(const char *extra, size_t len);
    void SetLocalExtra(const char *extra, size_t len);

    inline void SetName(const wxString& name,
                        wxPathFormat format = wxPATH_NATIVE);

    static wxString GetInternalName(const wxString& name,
                                    wxPathFormat format = wxPATH_NATIVE,
                                    bool *pIsDir = NULL);

    // set is accessors
    void SetIsDir(bool isDir = true);
    inline void SetIsReadOnly(bool isReadOnly = true);
    inline void SetIsText(bool isText = true);

    wxZipEntry *Clone() const                   { return ZipClone(); }

    void SetNotifier(wxZipNotifier& notifier);
    void UnsetNotifier();

protected:
    // Internal attributes
    enum { TEXT_ATTR = 1 };

    // protected Get accessors
    int GetVersionNeeded() const                { return m_VersionNeeded; }
    wxFileOffset GetKey() const                 { return m_Key; }
    int GetVersionMadeBy() const                { return m_VersionMadeBy; }
    int GetDiskStart() const                    { return m_DiskStart; }
    int GetInternalAttributes() const           { return m_InternalAttributes; }

    void SetVersionNeeded(int version)          { m_VersionNeeded = (wxUint16)version; }
    void SetOffset(wxFileOffset offset)         { m_Offset = offset; }
    void SetFlags(int flags)                    { m_Flags = (wxUint16)flags; }
    void SetVersionMadeBy(int version)          { m_VersionMadeBy = (wxUint8)version; }
    void SetCrc(wxUint32 crc)                   { m_Crc = crc; }
    void SetCompressedSize(wxFileOffset size)   { m_CompressedSize = size; }
    void SetKey(wxFileOffset offset)            { m_Key = offset; }
    void SetDiskStart(int start)                { m_DiskStart = (wxUint16)start; }
    void SetInternalAttributes(int attr)        { m_InternalAttributes = (wxUint16)attr; }

    virtual wxZipEntry *ZipClone() const        { return new wxZipEntry(*this); }

    void Notify();

private:
    wxArchiveEntry* DoClone() const             { return ZipClone(); }

    size_t ReadLocal(wxInputStream& stream, wxMBConv& conv);
    size_t WriteLocal(wxOutputStream& stream, wxMBConv& conv) const;

    size_t ReadCentral(wxInputStream& stream, wxMBConv& conv);
    size_t WriteCentral(wxOutputStream& stream, wxMBConv& conv) const;

    size_t ReadDescriptor(wxInputStream& stream);
    size_t WriteDescriptor(wxOutputStream& stream, wxUint32 crc,
                           wxFileOffset compressedSize, wxFileOffset size);

    wxUint8      m_SystemMadeBy;       // one of enum wxZipSystem
    wxUint8      m_VersionMadeBy;      // major * 10 + minor

    wxUint16     m_VersionNeeded;      // ver needed to extract (20 i.e. v2.0)
    wxUint16     m_Flags;
    wxUint16     m_Method;             // compression method (one of wxZipMethod)
    wxDateTime   m_DateTime;
    wxUint32     m_Crc;
    wxFileOffset m_CompressedSize;
    wxFileOffset m_Size;
    wxString     m_Name;               // in internal format
    wxFileOffset m_Key;                // the original offset for copied entries
    wxFileOffset m_Offset;             // file offset of the entry

    wxString     m_Comment;
    wxUint16     m_DiskStart;          // for multidisk archives, not unsupported
    wxUint16     m_InternalAttributes; // bit 0 set for text files
    wxUint32     m_ExternalAttributes; // system specific depends on SystemMadeBy

    class wxZipMemory *m_Extra;
    class wxZipMemory *m_LocalExtra;

    wxZipNotifier *m_zipnotifier;
    class wxZipWeakLinks *m_backlink;

    friend class wxZipInputStream;
    friend class wxZipOutputStream;

    DECLARE_DYNAMIC_CLASS(wxZipEntry)
};


/////////////////////////////////////////////////////////////////////////////
// wxZipOutputStream 

WX_DECLARE_LIST_WITH_DECL(wxZipEntry, wxZipEntryList_, class WXDLLIMPEXP_BASE);

class WXDLLIMPEXP_BASE wxZipOutputStream : public wxArchiveOutputStream
{
public:
    wxZipOutputStream(wxOutputStream& stream,
                      int level = -1,
                      wxMBConv& conv = wxConvLocal);
    wxZipOutputStream(wxOutputStream *stream,
                      int level = -1,
                      wxMBConv& conv = wxConvLocal);
    virtual WXZIPFIX ~wxZipOutputStream();

    bool PutNextEntry(wxZipEntry *entry)        { return DoCreate(entry); }

    bool WXZIPFIX PutNextEntry(const wxString& name,
                               const wxDateTime& dt = wxDateTime::Now(),
                               wxFileOffset size = wxInvalidOffset);

    bool WXZIPFIX PutNextDirEntry(const wxString& name,
                                  const wxDateTime& dt = wxDateTime::Now());

    bool WXZIPFIX CopyEntry(wxZipEntry *entry, wxZipInputStream& inputStream);
    bool WXZIPFIX CopyArchiveMetaData(wxZipInputStream& inputStream);

    void WXZIPFIX Sync();
    bool WXZIPFIX CloseEntry();
    bool WXZIPFIX Close();

    void SetComment(const wxString& comment)    { m_Comment = comment; }

    int  GetLevel() const                       { return m_level; }
    void WXZIPFIX SetLevel(int level);
    
protected:
    virtual size_t WXZIPFIX OnSysWrite(const void *buffer, size_t size);
    virtual wxFileOffset OnSysTell() const      { return m_entrySize; }

    // this protected interface isn't yet finalised
    struct Buffer { const char *m_data; size_t m_size; };
    virtual wxOutputStream* WXZIPFIX OpenCompressor(wxOutputStream& stream,
                                                    wxZipEntry& entry,
                                                    const Buffer bufs[]);
    virtual bool WXZIPFIX CloseCompressor(wxOutputStream *comp);

    bool IsParentSeekable() const
        { return m_offsetAdjustment != wxInvalidOffset; }

private:
    void Init(int level);

    bool WXZIPFIX PutNextEntry(wxArchiveEntry *entry);
    bool WXZIPFIX CopyEntry(wxArchiveEntry *entry, wxArchiveInputStream& stream);
    bool WXZIPFIX CopyArchiveMetaData(wxArchiveInputStream& stream);

    bool IsOpened() const { return m_comp || m_pending; }

    bool DoCreate(wxZipEntry *entry, bool raw = false);
    void CreatePendingEntry(const void *buffer, size_t size);
    void CreatePendingEntry();

    class wxStoredOutputStream *m_store;
    class wxZlibOutputStream2 *m_deflate;
    class wxZipStreamLink *m_backlink;
    wxZipEntryList_ m_entries;
    char *m_initialData;
    size_t m_initialSize;
    wxZipEntry *m_pending;
    bool m_raw;
    wxFileOffset m_headerOffset;
    size_t m_headerSize;
    wxFileOffset m_entrySize;
    wxUint32 m_crcAccumulator;
    wxOutputStream *m_comp;
    int m_level;
    wxFileOffset m_offsetAdjustment;
    wxString m_Comment;

    DECLARE_NO_COPY_CLASS(wxZipOutputStream)
};


/////////////////////////////////////////////////////////////////////////////
// wxZipInputStream 

class WXDLLIMPEXP_BASE wxZipInputStream : public wxArchiveInputStream
{
public:
    typedef wxZipEntry entry_type;

    wxZipInputStream(wxInputStream& stream, wxMBConv& conv = wxConvLocal);
    wxZipInputStream(wxInputStream *stream, wxMBConv& conv = wxConvLocal);

#if WXWIN_COMPATIBILITY_2_6 && wxUSE_FFILE
    wxZipInputStream(const wxString& archive, const wxString& file)
     : wxArchiveInputStream(OpenFile(archive), wxConvLocal) { Init(file); }
#endif

    virtual WXZIPFIX ~wxZipInputStream();

    bool OpenEntry(wxZipEntry& entry)   { return DoOpen(&entry); }
    bool WXZIPFIX CloseEntry();

    wxZipEntry *GetNextEntry();

    wxString WXZIPFIX GetComment();
    int WXZIPFIX GetTotalEntries();

    virtual wxFileOffset GetLength() const { return m_entry.GetSize(); }

protected:
    size_t WXZIPFIX OnSysRead(void *buffer, size_t size);
    wxFileOffset OnSysTell() const { return m_decomp ? m_decomp->TellI() : 0; }

#if WXWIN_COMPATIBILITY_2_6 && wxUSE_FFILE
    wxFileOffset WXZIPFIX OnSysSeek(wxFileOffset seek, wxSeekMode mode);
#endif

    // this protected interface isn't yet finalised
    virtual wxInputStream* WXZIPFIX OpenDecompressor(wxInputStream& stream);
    virtual bool WXZIPFIX CloseDecompressor(wxInputStream *decomp);

private:
    void Init();
    void Init(const wxString& file);
#if WXWIN_COMPATIBILITY_2_6 && wxUSE_FFILE
    static wxInputStream *OpenFile(const wxString& archive);
#endif

    wxArchiveEntry *DoGetNextEntry()    { return GetNextEntry(); }

    bool WXZIPFIX OpenEntry(wxArchiveEntry& entry);

    wxStreamError ReadLocal(bool readEndRec = false);
    wxStreamError ReadCentral();

    wxUint32 ReadSignature();
    bool FindEndRecord();
    bool LoadEndRecord();
    
    bool AtHeader() const       { return m_headerSize == 0; }
    bool AfterHeader() const    { return m_headerSize > 0 && !m_decomp; }
    bool IsOpened() const       { return m_decomp != NULL; }

    wxZipStreamLink *MakeLink(wxZipOutputStream *out);

    bool DoOpen(wxZipEntry *entry = NULL, bool raw = false);
    bool OpenDecompressor(bool raw = false);

    class wxStoredInputStream *m_store;
    class wxZlibInputStream2 *m_inflate;
    class wxRawInputStream *m_rawin;
    wxZipEntry m_entry;
    bool m_raw;
    size_t m_headerSize;
    wxUint32 m_crcAccumulator;
    wxInputStream *m_decomp;
    bool m_parentSeekable;
    class wxZipWeakLinks *m_weaklinks;
    class wxZipStreamLink *m_streamlink;
    wxFileOffset m_offsetAdjustment;
    wxFileOffset m_position;
    wxUint32 m_signature;
    size_t m_TotalEntries;
    wxString m_Comment;

    friend bool wxZipOutputStream::CopyEntry(
                    wxZipEntry *entry, wxZipInputStream& inputStream);
    friend bool wxZipOutputStream::CopyArchiveMetaData(
                    wxZipInputStream& inputStream);

#if WXWIN_COMPATIBILITY_2_6 && wxUSE_FFILE
    bool m_allowSeeking;
    friend class wxZipFSInputStream;
#endif

    DECLARE_NO_COPY_CLASS(wxZipInputStream)
};


/////////////////////////////////////////////////////////////////////////////
// Iterators

#if wxUSE_STL || defined WX_TEST_ARCHIVE_ITERATOR
typedef wxArchiveIterator<wxZipInputStream> wxZipIter;
typedef wxArchiveIterator<wxZipInputStream,
         std::pair<wxString, wxZipEntry*> > wxZipPairIter;
#endif


/////////////////////////////////////////////////////////////////////////////
// wxZipClassFactory

class WXDLLIMPEXP_BASE wxZipClassFactory : public wxArchiveClassFactory
{
public:
    typedef wxZipEntry        entry_type;
    typedef wxZipInputStream  instream_type;
    typedef wxZipOutputStream outstream_type;
    typedef wxZipNotifier     notifier_type;
#if wxUSE_STL || defined WX_TEST_ARCHIVE_ITERATOR
    typedef wxZipIter         iter_type;
    typedef wxZipPairIter     pairiter_type;
#endif

    wxZipClassFactory();

    wxZipEntry *NewEntry() const
        { return new wxZipEntry; }
    wxZipInputStream *NewStream(wxInputStream& stream) const
        { return new wxZipInputStream(stream, GetConv()); }
    wxZipOutputStream *NewStream(wxOutputStream& stream) const
        { return new wxZipOutputStream(stream, -1, GetConv()); }
    wxZipInputStream *NewStream(wxInputStream *stream) const
        { return new wxZipInputStream(stream, GetConv()); }
    wxZipOutputStream *NewStream(wxOutputStream *stream) const
        { return new wxZipOutputStream(stream, -1, GetConv()); }

    wxString GetInternalName(const wxString& name,
                             wxPathFormat format = wxPATH_NATIVE) const
        { return wxZipEntry::GetInternalName(name, format); }

    const wxChar * const *GetProtocols(wxStreamProtocolType type
                                       = wxSTREAM_PROTOCOL) const;

protected:
    wxArchiveEntry *DoNewEntry() const
        { return NewEntry(); }
    wxArchiveInputStream *DoNewStream(wxInputStream& stream) const
        { return NewStream(stream); }
    wxArchiveOutputStream *DoNewStream(wxOutputStream& stream) const
        { return NewStream(stream); }
    wxArchiveInputStream *DoNewStream(wxInputStream *stream) const
        { return NewStream(stream); }
    wxArchiveOutputStream *DoNewStream(wxOutputStream *stream) const
        { return NewStream(stream); }

private:
    DECLARE_DYNAMIC_CLASS(wxZipClassFactory)
};


/////////////////////////////////////////////////////////////////////////////
// wxZipEntry inlines

inline bool wxZipEntry::IsText() const
{
    return (m_InternalAttributes & TEXT_ATTR) != 0;
}

inline bool wxZipEntry::IsDir() const
{
    return (m_ExternalAttributes & wxZIP_A_SUBDIR) != 0;
}

inline bool wxZipEntry::IsReadOnly() const
{
    return (m_ExternalAttributes & wxZIP_A_RDONLY) != 0;
}

inline bool wxZipEntry::IsMadeByUnix() const
{
    const int pattern =
        (1 << wxZIP_SYSTEM_OPENVMS) |
        (1 << wxZIP_SYSTEM_UNIX) |
        (1 << wxZIP_SYSTEM_ATARI_ST) |
        (1 << wxZIP_SYSTEM_ACORN_RISC) |
        (1 << wxZIP_SYSTEM_BEOS) | (1 << wxZIP_SYSTEM_TANDEM);

    // note: some unix zippers put madeby = dos
    return (m_SystemMadeBy == wxZIP_SYSTEM_MSDOS
            && (m_ExternalAttributes & ~0xFFFF))
        || ((pattern >> m_SystemMadeBy) & 1);
}

inline void wxZipEntry::SetIsText(bool isText)
{
    if (isText)
        m_InternalAttributes |= TEXT_ATTR;
    else
        m_InternalAttributes &= ~TEXT_ATTR;
}

inline void wxZipEntry::SetIsReadOnly(bool isReadOnly)
{
    if (isReadOnly)
        SetMode(GetMode() & ~0222);
    else
        SetMode(GetMode() | 0200);
}

inline void wxZipEntry::SetName(const wxString& name,
                                wxPathFormat format /*=wxPATH_NATIVE*/)
{
    bool isDir;
    m_Name = GetInternalName(name, format, &isDir);
    SetIsDir(isDir);
}


#endif // wxUSE_ZLIB && wxUSE_STREAMS && wxUSE_ZIPSTREAM

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