Thread Rating:
  • 0 Vote(s) - 0 Average
  • 1
  • 2
  • 3
  • 4
  • 5
How to get file's length and date from zip
#1
I want to know the file's length and date before unzip it from zip file,because some big file need long time,the scripts looks like no respond.so
I did this,but not work...

dll qmzip.dll #OpenZip hFile
dll qmzip.dll #GetZipItem hZip index *zipEntry
dll qmzip.dll #CloseZip hZip

str s="C:\111.zip"

int ii=OpenZip(s)
out ii

0

but return ii=0,where is the problem? Many thanks for your help!
#2
Macro
Code:
Copy      Help
out

ref qmzip qmzip_def

str zf.searchpath("$desktop$\test.zip")
if(!zf) end "zip file not found"

int hzip=qmzip.OpenZip(zf.unicode 0 ZIP_FILENAME)
if(!hzip) end "failed"
;note: in QM 2.3.0 and later, with OpenZip and CreateZip, file name must be Unicode UTF-16

ZIPENTRY z
int i n
int zr=qmzip.GetZipItem(hzip -1 &z); if(zr) goto g1 ;;call with index -1 to get info about the zip file, particularly number of items
n=z.index

for i 0 n
,zr=qmzip.GetZipItem(hzip i &z); if(zr) goto g1
,lpstr name=&z.name
,DATE d1.fromfiletime(z.mtime); str sd1.time(d1 "%x %H:%M")
,out "name=''%s'',  size=%i,  compressed size=%i,  date modified=%s" name z.unc_size z.comp_size sd1

;g1
qmzip.CloseZip(hzip)
if(zr) end "failed"

Function qmzip_def
Code:
Copy      Help
;zip

dll qmzip #CloseZip hz
dll qmzip #CreateZip !*z len flags
dll qmzip #FormatZipMessage code $buf len
type HZIP = #
def IMPORT
def XZIP_H
def ZIP_FILENAME 2
def ZIP_FOLDER 4
def ZIP_HANDLE 1
def ZIP_MEMORY 3
type ZRESULT = #
def ZR_ARGS 0x00010000
def ZR_BUGMASK 0xFF000000
def ZR_CALLERMASK 0x00FF0000
def ZR_CORRUPT 0x00000700
def ZR_ENDED 0x00050000
def ZR_FAILED 0x00040000
def ZR_FLATE 0x05000000
def ZR_GENMASK 0x0000FF00
def ZR_MEMSIZE 0x00030000
def ZR_MISSIZE 0x00060000
def ZR_MORE 0x00000600
def ZR_NOALLOC 0x00000300
def ZR_NOCHANGE 0x04000000
def ZR_NODUPH 0x00000100
def ZR_NOFILE 0x00000200
def ZR_NOTFOUND 0x00000500
def ZR_NOTINITED 0x01000000
def ZR_NOTMMAP 0x00020000
def ZR_OK 0x00000000
def ZR_PARTIALUNZ 0x00070000
def ZR_READ 0x00000800
def ZR_RECENT 0x00000001
def ZR_SEEK 0x02000000
def ZR_WRITE 0x00000400
def ZR_ZMODE 0x00080000
dll qmzip #ZipAdd hz $dstzn !*src len flags level

;unzip

dll qmzip #GetZipItem hz index ZIPENTRY*ze
type HZIP = #
def IMPORT
dll qmzip #OpenZip !*z len flags
dll qmzip #UnzipItem hz index !*dst len flags
def XUNZIP_H
type ZIPENTRY index !name[260] attr FILETIME'atime FILETIME'ctime FILETIME'mtime comp_size unc_size
def ZIP_FILENAME 2
def ZIP_HANDLE 1
def ZIP_MEMORY 3
type ZRESULT = #
def ZR_ARGS 0x00010000
def ZR_BUGMASK 0xFF000000
def ZR_CALLERMASK 0x00FF0000
def ZR_CORRUPT 0x00000700
def ZR_ENDED 0x00050000
def ZR_FAILED 0x00040000
def ZR_FLATE 0x05000000
def ZR_GENMASK 0x0000FF00
def ZR_MEMSIZE 0x00030000
def ZR_MISSIZE 0x00060000
def ZR_MORE 0x00000600
def ZR_NOALLOC 0x00000300
def ZR_NOCHANGE 0x04000000
def ZR_NODUPH 0x00000100
def ZR_NOFILE 0x00000200
def ZR_NOTFOUND 0x00000500
def ZR_NOTINITED 0x01000000
def ZR_NOTMMAP 0x00020000
def ZR_OK 0x00000000
def ZR_PARTIALUNZ 0x00070000
def ZR_READ 0x00000800
def ZR_RECENT 0x00000001
def ZR_SEEK 0x02000000
def ZR_WRITE 0x00000400
def ZR_ZMODE 0x00080000

Macro qmzip zip doc
Code:
Copy      Help
DECLARE_HANDLE(HZIP);        // An HZIP identifies a zip file that is being created
typedef DWORD ZRESULT;        // result codes from any of the zip functions. Listed later.

// flag values passed to some functions
#define ZIP_HANDLE   1
#define ZIP_FILENAME 2
#define ZIP_MEMORY   3
#define ZIP_FOLDER   4


///////////////////////////////////////////////////////////////////////////////
//
// CreateZip()
//
// Purpose:     Create a zip archive file
//
// Parameters:  z      - archive file name if flags is ZIP_FILENAME;  for other
//                       uses see below
//              len    - for memory (ZIP_MEMORY) should be the buffer size;
//                       for other uses, should be 0
//              flags  - indicates usage, see below;  for files, this will be
//                       ZIP_FILENAME
//
// Returns:     HZIP   - non-zero if zip archive created ok, otherwise 0
//
//QM: z file name must be UTF-16

IMPORT HZIP CreateZip(void *z, unsigned int len, DWORD flags);
// CreateZip - call this to start the creation of a zip file.
// As the zip is being created, it will be stored somewhere:
// to a pipe:              CreateZip(hpipe_write, 0,ZIP_HANDLE);
// in a file (by handle):  CreateZip(hfile, 0,ZIP_HANDLE);
// in a file (by name):    CreateZip("c:\\test.zip", 0,ZIP_FILENAME);
// in memory:              CreateZip(buf, len,ZIP_MEMORY);
// or in pagefile memory:  CreateZip(0, len,ZIP_MEMORY);
// The final case stores it in memory backed by the system paging file,
// where the zip may not exceed len bytes. This is a bit friendlier than
// allocating memory with new[]: it won't lead to fragmentation, and the
// memory won't be touched unless needed.
// Note: because pipes don't allow random access, the structure of a zipfile
// created into a pipe is slightly different from that created into a file
// or memory. In particular, the compressed-size of the item cannot be
// stored in the zipfile until after the item itself. (Also, for an item added
// itself via a pipe, the uncompressed-size might not either be known until
// after.) This is not normally a problem. But if you try to unzip via a pipe
// as well, then the unzipper will not know these things about the item until
// after it has been unzipped. Therefore: for unzippers which don't just write
// each item to disk or to a pipe, but instead pre-allocate memory space into
// which to unzip them, then either you have to create the zip not to a pipe,
// or you have to add items not from a pipe, or at least when adding items
// from a pipe you have to specify the length.


///////////////////////////////////////////////////////////////////////////////
//
// ZipAdd()
//
// Purpose:     Add a file to a zip archive
//
// Parameters:  hz      - handle to an open zip archive
//              dstzn   - name used inside the zip archive to identify the file
//              src     - for a file (ZIP_FILENAME) this specifies the filename
//                        to be added to the archive;  for other uses, see below
//              len     - for memory (ZIP_MEMORY) this specifies the buffer
//                        length;  for other uses, this should be 0
//              flags   - indicates usage, see below;  for files, this will be
//                        ZIP_FILENAME
//
// Returns:     ZRESULT - ZR_OK if success, otherwise some other value
//

IMPORT ZRESULT ZipAdd(HZIP hz, const char *dstzn, void *src, unsigned int len, DWORD flags, int level);

// ZipAdd - call this for each file to be added to the zip.
// dstzn is the name that the file will be stored as in the zip file.
// The file to be added to the zip can come
// from a pipe:  ZipAdd(hz,"file.dat", hpipe_read,0,ZIP_HANDLE);
// from a file:  ZipAdd(hz,"file.dat", hfile,0,ZIP_HANDLE);
// from a fname: ZipAdd(hz,"file.dat", "c:\\docs\\origfile.dat",0,ZIP_FILENAME);
// from memory:  ZipAdd(hz,"subdir\\file.dat", buf,len,ZIP_MEMORY);
// (folder):     ZipAdd(hz,"subdir",   0,0,ZIP_FOLDER);
// Note: if adding an item from a pipe, and if also creating the zip file itself
// to a pipe, then you might wish to pass a non-zero length to the ZipAdd
// function. This will let the zipfile store the items size ahead of the
// compressed item itself, which in turn makes it easier when unzipping the
// zipfile into a pipe.


///////////////////////////////////////////////////////////////////////////////
//
// CloseZip()
//
// Purpose:     Close an open zip archive
//
// Parameters:  hz      - handle to an open zip archive
//
// Returns:     ZRESULT - ZR_OK if success, otherwise some other value
//
IMPORT ZRESULT CloseZip(HZIP hz);
// CloseZip - the zip handle must be closed with this function.


IMPORT unsigned int FormatZipMessage(ZRESULT code, char *buf,unsigned int len);
// FormatZipMessage - given an error code, formats it as a string.
// It returns the length of the error message. If buf/len points
// to a real buffer, then it also writes as much as possible into there.



// These are the result codes:
#define ZR_OK         0x00000000     // nb. the pseudo-code zr-recent is never returned,
#define ZR_RECENT     0x00000001     // but can be passed to FormatZipMessage.
// The following come from general system stuff (e.g. files not openable)
#define ZR_GENMASK    0x0000FF00
#define ZR_NODUPH     0x00000100     // couldn't duplicate the handle
#define ZR_NOFILE     0x00000200     // couldn't create/open the file
#define ZR_NOALLOC    0x00000300     // failed to allocate some resource
#define ZR_WRITE      0x00000400     // a general error writing to the file
#define ZR_NOTFOUND   0x00000500     // couldn't find that file in the zip
#define ZR_MORE       0x00000600     // there's still more data to be unzipped
#define ZR_CORRUPT    0x00000700     // the zipfile is corrupt or not a zipfile
#define ZR_READ       0x00000800     // a general error reading the file
// The following come from mistakes on the part of the caller
#define ZR_CALLERMASK 0x00FF0000
#define ZR_ARGS       0x00010000     // general mistake with the arguments
#define ZR_NOTMMAP    0x00020000     // tried to ZipGetMemory, but that only works on mmap zipfiles, which yours wasn't
#define ZR_MEMSIZE    0x00030000     // the memory size is too small
#define ZR_FAILED     0x00040000     // the thing was already failed when you called this function
#define ZR_ENDED      0x00050000     // the zip creation has already been closed
#define ZR_MISSIZE    0x00060000     // the indicated input file size turned out mistaken
#define ZR_PARTIALUNZ 0x00070000     // the file had already been partially unzipped
#define ZR_ZMODE      0x00080000     // tried to mix creating/opening a zip
// The following come from bugs within the zip library itself
#define ZR_BUGMASK    0xFF000000
#define ZR_NOTINITED  0x01000000     // initialisation didn't work
#define ZR_SEEK       0x02000000     // trying to seek in an unseekable file
#define ZR_NOCHANGE   0x04000000     // changed its mind on storage, but not allowed
#define ZR_FLATE      0x05000000     // an internal error in the de/inflation code



// e.g.
//
// (1) Traditional use, creating a zipfile from existing files
//     HZIP hz = CreateZip("c:\\temp.zip",0,ZIP_FILENAME);
//     ZipAdd(hz,"src1.txt",  "c:\\src1.txt",0,ZIP_FILENAME);
//     ZipAdd(hz,"src2.bmp",  "c:\\src2_origfn.bmp",0,ZIP_FILENAME);
//     CloseZip(hz);
//
// (2) Memory use, creating an auto-allocated mem-based zip file from various sources
//     HZIP hz = CreateZip(0,100000,ZIP_MEMORY);
//     // adding a conventional file...
//     ZipAdd(hz,"src1.txt",  "c:\\src1.txt",0,ZIP_FILENAME);
//     // adding something from memory...
//     char buf[1000]; for (int i=0; i<1000; i++) buf[i]=(char)(i&0x7F);
//     ZipAdd(hz,"file.dat",  buf,1000,ZIP_MEMORY);
//     // adding something from a pipe...
//     HANDLE hread,hwrite; CreatePipe(&hread,&write,NULL,0);
//     HANDLE hthread = CreateThread(ThreadFunc,(void*)hwrite);
//     ZipAdd(hz,"unz3.dat",  hread,0,ZIP_HANDLE);
//     WaitForSingleObject(hthread,INFINITE);
//     CloseHandle(hthread); CloseHandle(hread);
//     ... meanwhile DWORD CALLBACK ThreadFunc(void *dat)
//                   { HANDLE hwrite = (HANDLE)dat;
//                     char buf[1000]={17};
//                     DWORD writ; WriteFile(hwrite,buf,1000,&writ,NULL);
//                     CloseHandle(hwrite);
//                     return 0;
//                   }
//     // and now that the zip is created, let's do something with it:
//     void *zbuf; unsigned long zlen; ZipGetMemory(hz,&zbuf,&zlen);
//     HANDLE hfz = CreateFile("test2.zip",GENERIC_WRITE,CREATE_ALWAYS);
//     DWORD writ; WriteFile(hfz,zbuf,zlen,&writ,NULL);
//     CloseHandle(hfz);
//     CloseZip(hz);
//
// (3) Handle use, for file handles and pipes
//     HANDLE hzread,hzwrite; CreatePipe(&hzread,&hzwrite);
//     HANDLE hthread = CreateThread(ZipReceiverThread,(void*)hread);
//     HZIP hz = ZipCreate(hzwrite,ZIP_HANDLE);
//     // ... add to it
//     CloseZip(hz);
//     CloseHandle(hzwrite);
//     WaitForSingleObject(hthread,INFINITE);
//     CloseHandle(hthread);
//     ... meanwhile DWORD CALLBACK ThreadFunc(void *dat)
//                   { HANDLE hread = (HANDLE)dat;
//                     char buf[1000];
//                     while (true)
//                     { DWORD red; ReadFile(hread,buf,1000,&red,NULL);
//                       // ... and do something with this zip data we're receiving
//                       if (red==0) break;
//                     }
//                     CloseHandle(hread);
//                     return 0;
//                   }
//

Macro qmzip unzip doc
Code:
Copy      Help
DECLARE_HANDLE(HZIP);    // An HZIP identifies a zip file that has been opened
typedef DWORD ZRESULT; // return codes from any of the zip functions. Listed later.

#define ZIP_HANDLE   1
#define ZIP_FILENAME 2
#define ZIP_MEMORY   3

typedef struct
{ int index;                 // index of this file within the zip
;;char name[MAX_PATH];       // filename within the zip
;;DWORD attr;                // attributes, as in GetFileAttributes.
;;FILETIME atime,ctime,mtime;// access, create, modify filetimes
;;long comp_size;            // sizes of item, compressed and uncompressed. These
;;long unc_size;             // may be -1 if not yet known (e.g. being streamed in)
} ZIPENTRY;


///////////////////////////////////////////////////////////////////////////////
//
// OpenZip()
//
// Purpose:     Open an existing zip archive file
//
// Parameters:  z      - archive file name if flags is ZIP_FILENAME;  for other
//                       uses see below
//              len    - for memory (ZIP_MEMORY) should be the buffer size;
//                       for other uses, should be 0
//              flags  - indicates usage, see below;  for files, this will be
//                       ZIP_FILENAME
//
// Returns:     HZIP   - non-zero if zip archive opened ok, otherwise 0
//
//QM: z file name must be UTF-16

IMPORT HZIP OpenZip(void *z, unsigned int len, DWORD flags);
// OpenZip - opens a zip file and returns a handle with which you can
// subsequently examine its contents. You can open a zip file from:
// from a pipe:             OpenZip(hpipe_read,0, ZIP_HANDLE);
// from a file (by handle): OpenZip(hfile,0,      ZIP_HANDLE);
// from a file (by name):   OpenZip("c:\\test.zip",0, ZIP_FILENAME);
// from a memory block:     OpenZip(bufstart, buflen, ZIP_MEMORY);
// If the file is opened through a pipe, then items may only be
// accessed in increasing order, and an item may only be unzipped once,
// although GetZipItem can be called immediately before and after unzipping
// it. If it's opened i    n any other way, then full random access is possible.
// Note: pipe input is not yet implemented.


///////////////////////////////////////////////////////////////////////////////
//
// GetZipItem()
//
// Purpose:     Get information about an item in an open zip archive
//
// Parameters:  hz      - handle of open zip archive
//              index   - index number (0 based) of item in zip
//              ze      - pointer to a ZIPENTRY (if ANSI) or ZIPENTRYW struct
//                        (if Unicode)
//
// Returns:     ZRESULT - ZR_OK if success, otherwise some other value
//

IMPORT ZRESULT GetZipItem(HZIP hz, int index, ZIPENTRY *ze);

// GetZipItem - call this to get information about an item in the zip.
// If index is -1 and the file wasn't opened through a pipe,
// then it returns information about the whole zipfile
// (and in particular ze.index returns the number of index items).
// Note: the item might be a directory (ze.attr & FILE_ATTRIBUTE_DIRECTORY)
// See below for notes on what happens when you unzip such an item.
// Note: if you are opening the zip through a pipe, then random access
// is not possible and GetZipItem(-1) fails and you can't discover the number
// of items except by calling GetZipItem on each one of them in turn,
// starting at 0, until eventually the call fails. Also, in the event that
// you are opening through a pipe and the zip was itself created into a pipe,
// then then comp_size and sometimes unc_size as well may not be known until
// after the item has been unzipped.


///////////////////////////////////////////////////////////////////////////////
//
// FindZipItem()
//
// Purpose:     Find item by name and return information about it
//
// Parameters:  hz      - handle of open zip archive
//              name    - name of file to look for inside zip archive
//              ic      - TRUE = case insensitive
//              index   - pointer to index number returned, or -1
//              ze      - pointer to a ZIPENTRY (if ANSI) or ZIPENTRYW struct
//                        (if Unicode)
//
// Returns:     ZRESULT - ZR_OK if success, otherwise some other value
//

//QM: commented because not used by QM
//
//IMPORT ZRESULT FindZipItem(HZIP hz, const CHAR *name, bool ic, int *index, ZIPENTRY *ze);
// FindZipItem - finds an item by name. ic means 'insensitive to case'.
// It returns the index of the item, and returns information about it.
// If nothing was found, then index is set to -1 and the function returns
// an error code.


///////////////////////////////////////////////////////////////////////////////
//
// UnzipItem()
//
// Purpose:     Find item by index and unzip it
//
// Parameters:  hz      - handle of open zip archive
//              index   - index number of file to unzip
//              dst     - target file name of unzipped file
//              len     - for memory (ZIP_MEMORY. length of buffer;
//                        otherwise 0
//              flags   - indicates usage, see below;  for files, this will be
//                        ZIP_FILENAME
//
// Returns:     ZRESULT - ZR_OK if success, otherwise some other value
//

IMPORT ZRESULT UnzipItem(HZIP hz, int index, void *dst, unsigned int len, DWORD flags);
// UnzipItem - given an index to an item, unzips it. You can unzip to:
// to a pipe:             UnzipItem(hz,i, hpipe_write,0,ZIP_HANDLE);
// to a file (by handle): UnzipItem(hz,i, hfile,0,ZIP_HANDLE);
// to a file (by name):   UnzipItem(hz,i, ze.name,0,ZIP_FILENAME);
// to a memory block:     UnzipItem(hz,i, buf,buflen,ZIP_MEMORY);
// In the final case, if the buffer isn't large enough to hold it all,
// then the return code indicates that more is yet to come. If it was
// large enough, and you want to know precisely how big, GetZipItem.
// Note: zip files are normally stored with relative pathnames. If you
// unzip with ZIP_FILENAME a relative pathname then the item gets created
// relative to the current directory - it first ensures that all necessary
// subdirectories have been created. Also, the item may itself be a directory.
// If you unzip a directory with ZIP_FILENAME, then the directory gets created.
// If you unzip it to a handle or a memory block, then nothing gets created
// and it emits 0 bytes.


///////////////////////////////////////////////////////////////////////////////


// These are the result codes:
#define ZR_OK         0x00000000     // nb. the pseudo-code zr-recent is never returned,
#define ZR_RECENT     0x00000001     // but can be passed to FormatZipMessage.
// The following come from general system stuff (e.g. files not openable)
#define ZR_GENMASK    0x0000FF00
#define ZR_NODUPH     0x00000100     // couldn't duplicate the handle
#define ZR_NOFILE     0x00000200     // couldn't create/open the file
#define ZR_NOALLOC    0x00000300     // failed to allocate some resource
#define ZR_WRITE      0x00000400     // a general error writing to the file
#define ZR_NOTFOUND   0x00000500     // couldn't find that file in the zip
#define ZR_MORE       0x00000600     // there's still more data to be unzipped
#define ZR_CORRUPT    0x00000700     // the zipfile is corrupt or not a zipfile
#define ZR_READ       0x00000800     // a general error reading the file
// The following come from mistakes on the part of the caller
#define ZR_CALLERMASK 0x00FF0000
#define ZR_ARGS       0x00010000     // general mistake with the arguments
#define ZR_NOTMMAP    0x00020000     // tried to ZipGetMemory, but that only works on mmap zipfiles, which yours wasn't
#define ZR_MEMSIZE    0x00030000     // the memory size is too small
#define ZR_FAILED     0x00040000     // the thing was already failed when you called this function
#define ZR_ENDED      0x00050000     // the zip creation has already been closed
#define ZR_MISSIZE    0x00060000     // the indicated input file size turned out mistaken
#define ZR_PARTIALUNZ 0x00070000     // the file had already been partially unzipped
#define ZR_ZMODE      0x00080000     // tried to mix creating/opening a zip
// The following come from bugs within the zip library itself
#define ZR_BUGMASK    0xFF000000
#define ZR_NOTINITED  0x01000000     // initialisation didn't work
#define ZR_SEEK       0x02000000     // trying to seek in an unseekable file
#define ZR_NOCHANGE   0x04000000     // changed its mind on storage, but not allowed
#define ZR_FLATE      0x05000000     // an internal error in the de/inflation code





// e.g.
//
// SetCurrentDirectory("c:\\docs\\stuff");
// HZIP hz = OpenZip("c:\\stuff.zip",0,ZIP_FILENAME);
// ZIPENTRY ze; GetZipItem(hz,-1,&ze); int numitems=ze.index;
// for (int i=0; i<numitems; i++)
// { GetZipItem(hz,i,&ze);
//   UnzipItem(hz,i,ze.name,0,ZIP_FILENAME);
// }
// CloseZip(hz);
//
//
// HRSRC hrsrc = FindResource(hInstance,MAKEINTRESOURCE(1),RT_RCDATA);
// HANDLE hglob = LoadResource(hInstance,hrsrc);
// void *zipbuf=LockResource(hglob);
// unsigned int ziplen=SizeofResource(hInstance,hrsrc);
// HZIP hz = OpenZip(zipbuf, ziplen, ZIP_MEMORY);
//   - unzip to a membuffer -
// ZIPENTRY ze; int i; FindZipItem(hz,"file.dat",&i,&ze);
// char *ibuf = new char[ze.unc_size];
// UnzipItem(hz,i, ibuf, ze.unc_size,ZIP_MEMORY);
// delete[] buf;
//   - unzip to a fixed membuff -
// ZIPENTRY ze; int i; FindZipItem(hz,"file.dat",&i,&ze);
// char ibuf[1024]; ZIPRESULT zr=ZR_MORE; unsigned long totsize=0;
// while (zr==ZR_MORE)
// { zr = UnzipItem(hz,i, ibuf,1024,ZIP_MEMORY);
//   unsigned long bufsize=1024; if (zr==ZR_OK) bufsize=ze.unc_size-totsize;
//   totsize+=bufsize;
// }
//   - unzip to a pipe -
// HANDLE hthread=CreateWavReaderThread(&hread,&hwrite);
// FindZipItem(hz,"sound.wav",&i,&ze);
// UnzipItem(hz,i, hwrite,0,ZIP_HANDLE);
// CloseHandle(hwrite);
// WaitForSingleObject(hthread,INFINITE);
// CloseHandle(hread); CloseHandle(hthread);
//   - finished -
// CloseZip(hz);
// // note: no need to free resources obtained through Find/Load/LockResource
//
//
// SetCurrentDirectory("c:\\docs\\pipedzipstuff");
// HANDLE hread,hwrite; CreatePipe(&hread,&hwrite);
// CreateZipWriterThread(hwrite);
// HZIP hz = OpenZip(hread,0,ZIP_HANDLE);
// for (int i=0; ; i++)
// { ZIPENTRY ze; ZRESULT res = GetZipItem(hz,i,&ze);
//   if (res!=ZE_OK) break; // no more
//   UnzipItem(hz,i, ze.name,0,ZIP_FILENAME);
// }
// CloseZip(hz);
//
#3
oh...so many doc,thanks a lot!
#4
it works,thanks very much!

(copy second to a function and rewrite first script,the doc...maybe study it later if have more time, Big Grin :wink: )
#5
Dear Gintaras,

I have a short question : I downloaded and run this "Macro". Everything was OK. I was not asked for a qmzip.dll file as advised and in consequence in this thread. I did not download it at all. I am using QM 2.4.0.3. Could you please advise?

Best regards and many thanks!
#6
That statement "in QM 2.3.4 qmzip.dll not installed" now is incorrect. Now I don't remember, it was not installed maybe only in 2.3.4 beta. Now QM installs and uses the dll.
#7
Sorry to kick this up.
Regarding the code in the second post
Code:
Copy      Help
out
ref qmzip qmzip_def
...
...

1)
Can it be used in a compiled .exe? (question might be answered, see below edit)

2)
And must the code contain something like below in order to be used in compiled .exe? (question might be answered, see below edit)

 
Code:
Copy      Help
#compile " qmzip.dll "
ExeQmzip
...?


EDIT: I found the below quote at: http://www.quickmacros.com/forum/showthr...2#pid26642

Quote:Most of QM zip/unzip code is in file qmzip.dll. It is in QM folder. Problem in exe: QM is not installed on most computers where exe runs.
To solve this, QM adds qmzip.dll to exe resources. Problem 2: dlls cannot be loaded directly from resources or memory.
To solve this, when exe runs and executes zip, it extracts the dll from exe resources, saves in the temp folder and loads the temporary dll file.
#8
The macro above works in QM (2.4.6.1)
But when I compile to .exe and then move exe to other location, I get the error:
Dll not found: qmzip

Within QM I created a folder and placed the macro and other component 'qmzip_def'.
Running macro from QM works but compiling macro to .exe and placing .exe at other location I get: Dll not found: qmzip

I slightly modified macro:

Macro qmzip_test
Code:
Copy      Help
out
str zip_path="E:\__qm_testdirs\_rotation_scripts\test_contents.zip" ;; ===> SLIGHT modification, added path to zip here...


ref qmzip qmzip_def

str zf.searchpath(zip_path)
if(!zf) end "zip file not found"

int hzip=qmzip.OpenZip(zf.unicode 0 ZIP_FILENAME)
if(!hzip) end "failed"
;note: in QM 2.3.0 and later, with OpenZip and CreateZip, file name must be Unicode UTF-16

ZIPENTRY z
int i n
int zr=qmzip.GetZipItem(hzip -1 &z); if(zr) goto g1 ;;call with index -1 to get info about the zip file, particularly number of items
n=z.index

for i 0 n
,zr=qmzip.GetZipItem(hzip i &z); if(zr) goto g1
,lpstr name=&z.name
,DATE d1.fromfiletime(z.mtime); str sd1.time(d1 "%x %H:%M")
,out "name=''%s'', size=%i, compressed size=%i, date modified=%s" name z.unc_size z.comp_size sd1

;g1
qmzip.CloseZip(hzip)
if(zr) end "failed"


Forum Jump:


Users browsing this thread: 1 Guest(s)