*zip.txt*	For Vim version 7.0d.  Last change: 2006 Apr 03

				+====================+
				| Zip File Interface |
				+====================+

Author:  Charles E. Campbell, Jr.  <NdrOchip@ScampbellPfamily.AbizM>
	  (remove NOSPAM from Campbell's email first)
Copyright: Copyright (C) 2005,2006 Charles E Campbell, Jr {{{1 *zip-copyright*
           Permission is hereby granted to use and distribute this code,
	   with or without modifications, provided that this copyright
	   notice is copied with it. Like anything else that's free,
	   zip.vim, zipPlugin.vim, and pi_zip.txt are provided *as is*
	   and it comes with no warranty of any kind, either expressed or
	   implied. By using this plugin, you agree that in no event will
	   the copyright holder be liable for any damages resulting from
	   the use of this software.

==============================================================================
1. Contents					*zip* *zip-contents*
   1. Contents..................................................|zip-contents|
   2. Usage.....................................................|zip-usage|
   3. History...................................................|zip-history|

==============================================================================
2. Usage					*zip-usage* *zip-manual*

   When one edits a *.zip file, this plugin will handle displaying a
   contents page.  Select a file to edit by moving the cursor atop
   the desired file, then hit the <return> key.  After editing, one may
   also write to the file.  Currently, one may not make a new file in
   zip archives via the plugin.

==============================================================================
3. History					*zip-history*
   v7 Mar 22, 2006 * escaped some characters that can cause filename handling
                     problems.
   v6 Dec 21, 2005 * writing to files not in directories caused problems -
                     fixed (pointed out by Christian Robinson)
   v5 Nov 22, 2005 * report option workaround installed
   v3 Oct 18, 2005 * <amatch> used instead of <afile> in autocmds
   v2 Sep 16, 2005 * silenced some commands (avoiding hit-enter prompt)
                   * began testing under Windows; works thus far
		   * filetype detection fixed
      Nov 03, 2005 * handles writing zipfiles across a network using
                     netrw#NetWrite()
   v1 Sep 15, 2005 * Initial release, had browsing, reading, and writing

==============================================================================
vim:tw=78:ts=8:ft=help
