Chip 2002 September/Chip_2002-09_cd1.bin/zkuste/vbasic/Data/Utils/XZipComp.exe/XceedZip.Cab/F112557_xceedzip.cpp

C/C++ Source or Header | 1999-11-17 | 30.0 KB | 1,087 lines

// Machine generated IDispatch wrapper class(es) created with ClassWizard
//
// MFC sample using The Xceed Zip Compression Library 4
// Copyright (c) 1999 Xceed Software Inc.
//
// This sample illustrate how to use the XceedZip control in MFC
// without having to drop the control on a form.
//

#include "stdafx.h"
#include "xceedzip.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif



/////////////////////////////////////////////////////////////////////////////
// IXceedZip properties

/////////////////////////////////////////////////////////////////////////////
// IXceedZip operations

BOOL IXceedZip::GetAbort()
{
    BOOL result;
    InvokeHelper(0xb54, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetAbort(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xb54, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

CString IXceedZip::GetBasePath()
{
    CString result;
    InvokeHelper(0xc8, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetBasePath(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0xc8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

long IXceedZip::GetCompressionLevel()
{
    long result;
    InvokeHelper(0x190, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetCompressionLevel(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x190, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

CString IXceedZip::GetEncryptionPassword()
{
    CString result;
    InvokeHelper(0x192, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetEncryptionPassword(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x192, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

long IXceedZip::GetRequiredFileAttributes()
{
    long result;
    InvokeHelper(0x132, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetRequiredFileAttributes(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x132, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IXceedZip::GetExcludedFileAttributes()
{
    long result;
    InvokeHelper(0x133, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetExcludedFileAttributes(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x133, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

CString IXceedZip::GetFilesToProcess()
{
    CString result;
    InvokeHelper(0x12c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetFilesToProcess(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x12c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString IXceedZip::GetFilesToExclude()
{
    CString result;
    InvokeHelper(0x12d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetFilesToExclude(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x12d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

DATE IXceedZip::GetMinDateToProcess()
{
    DATE result;
    InvokeHelper(0x12e, DISPATCH_PROPERTYGET, VT_DATE, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetMinDateToProcess(DATE newValue)
{
    static BYTE parms[] =
        VTS_DATE;
    InvokeHelper(0x12e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

DATE IXceedZip::GetMaxDateToProcess()
{
    DATE result;
    InvokeHelper(0x12f, DISPATCH_PROPERTYGET, VT_DATE, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetMaxDateToProcess(DATE newValue)
{
    static BYTE parms[] =
        VTS_DATE;
    InvokeHelper(0x12f, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

long IXceedZip::GetMinSizeToProcess()
{
    long result;
    InvokeHelper(0x130, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetMinSizeToProcess(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x130, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IXceedZip::GetMaxSizeToProcess()
{
    long result;
    InvokeHelper(0x131, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetMaxSizeToProcess(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x131, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IXceedZip::GetSplitSize()
{
    long result;
    InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetSplitSize(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

BOOL IXceedZip::GetPreservePaths()
{
    BOOL result;
    InvokeHelper(0xc9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetPreservePaths(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xc9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IXceedZip::GetProcessSubfolders()
{
    BOOL result;
    InvokeHelper(0xca, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetProcessSubfolders(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xca, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IXceedZip::GetSkipIfExisting()
{
    BOOL result;
    InvokeHelper(0x134, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetSkipIfExisting(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x134, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IXceedZip::GetSkipIfNotExisting()
{
    BOOL result;
    InvokeHelper(0x135, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetSkipIfNotExisting(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x135, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IXceedZip::GetSkipIfOlderDate()
{
    BOOL result;
    InvokeHelper(0x136, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetSkipIfOlderDate(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x136, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IXceedZip::GetSkipIfOlderVersion()
{
    BOOL result;
    InvokeHelper(0x137, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetSkipIfOlderVersion(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x137, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

CString IXceedZip::GetTempFolder()
{
    CString result;
    InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetTempFolder(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

BOOL IXceedZip::GetUseTempFile()
{
    BOOL result;
    InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetUseTempFile(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

CString IXceedZip::GetUnzipToFolder()
{
    CString result;
    InvokeHelper(0xcb, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetUnzipToFolder(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0xcb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString IXceedZip::GetZipFilename()
{
    CString result;
    InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetZipFilename(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

long IXceedZip::GetCurrentOperation()
{
    long result;
    InvokeHelper(0xb55, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

long IXceedZip::GetSpanMultipleDisks()
{
    long result;
    InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetSpanMultipleDisks(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

long IXceedZip::GetExtraHeaders()
{
    long result;
    InvokeHelper(0x191, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetExtraHeaders(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x191, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

BOOL IXceedZip::GetZipOpenedFiles()
{
    BOOL result;
    InvokeHelper(0x193, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetZipOpenedFiles(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x193, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

BOOL IXceedZip::GetBackgroundProcessing()
{
    BOOL result;
    InvokeHelper(0x194, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetBackgroundProcessing(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x194, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

CString IXceedZip::GetSfxBinaryModule()
{
    CString result;
    InvokeHelper(0x1f5, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetSfxBinaryModule(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x1f5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString IXceedZip::GetSfxButtons(long xIndex)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x1f6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
        xIndex);
    return result;
}

void IXceedZip::SetSfxButtons(long xIndex, LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_I4 VTS_BSTR;
    InvokeHelper(0x1f6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         xIndex, lpszNewValue);
}

CString IXceedZip::GetSfxMessages(long xIndex)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x1f7, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
        xIndex);
    return result;
}

void IXceedZip::SetSfxMessages(long xIndex, LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_I4 VTS_BSTR;
    InvokeHelper(0x1f7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         xIndex, lpszNewValue);
}

CString IXceedZip::GetSfxStrings(long xIndex)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x1f8, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
        xIndex);
    return result;
}

void IXceedZip::SetSfxStrings(long xIndex, LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_I4 VTS_BSTR;
    InvokeHelper(0x1f8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         xIndex, lpszNewValue);
}

CString IXceedZip::GetSfxDefaultPassword()
{
    CString result;
    InvokeHelper(0x1f9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetSfxDefaultPassword(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x1f9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString IXceedZip::GetSfxDefaultUnzipToFolder()
{
    CString result;
    InvokeHelper(0x1fa, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetSfxDefaultUnzipToFolder(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x1fa, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

long IXceedZip::GetSfxExistingFileBehavior()
{
    long result;
    InvokeHelper(0x1fb, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetSfxExistingFileBehavior(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x1fb, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

CString IXceedZip::GetSfxReadmeFile()
{
    CString result;
    InvokeHelper(0x1fc, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetSfxReadmeFile(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x1fc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString IXceedZip::GetSfxExecuteAfter()
{
    CString result;
    InvokeHelper(0x1fd, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetSfxExecuteAfter(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x1fd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

BOOL IXceedZip::GetSfxInstallMode()
{
    BOOL result;
    InvokeHelper(0x1fe, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetSfxInstallMode(BOOL bNewValue)
{
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0x1fe, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         bNewValue);
}

CString IXceedZip::GetSfxProgramGroup()
{
    CString result;
    InvokeHelper(0x1ff, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetSfxProgramGroup(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x1ff, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString IXceedZip::GetSfxProgramGroupItems()
{
    CString result;
    InvokeHelper(0x200, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetSfxProgramGroupItems(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x200, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString IXceedZip::GetSfxExtensionsToAssociate()
{
    CString result;
    InvokeHelper(0x201, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetSfxExtensionsToAssociate(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x201, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

CString IXceedZip::GetSfxIconFilename()
{
    CString result;
    InvokeHelper(0x202, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IXceedZip::SetSfxIconFilename(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x202, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

void IXceedZip::AddFilesToProcess(LPCTSTR sFileMask)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0xbb8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sFileMask);
}

void IXceedZip::AddFilesToExclude(LPCTSTR sFileMask)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0xbb9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sFileMask);
}

long IXceedZip::PreviewFiles(BOOL bCalcCompSize)
{
    long result;
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xc1c, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        bCalcCompSize);
    return result;
}

long IXceedZip::ListZipContents()
{
    long result;
    InvokeHelper(0xc1d, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
    return result;
}

long IXceedZip::Zip()
{
    long result;
    InvokeHelper(0xc1f, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
    return result;
}

long IXceedZip::Unzip()
{
    long result;
    InvokeHelper(0xc20, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
    return result;
}

long IXceedZip::RemoveFiles()
{
    long result;
    InvokeHelper(0xc21, DISPATCH_METHOD, VT_I4, (void*)&result, NULL);
    return result;
}

long IXceedZip::TestZipFile(BOOL bCheckCompressedData)
{
    long result;
    static BYTE parms[] =
        VTS_BOOL;
    InvokeHelper(0xc22, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        bCheckCompressedData);
    return result;
}

long IXceedZip::GetZipFileInformation(long* lNbFiles, long* lCompressedSize, long* lUncompressedSize, short* nCompressionRatio, BOOL* bSpanned)
{
    long result;
    static BYTE parms[] =
        VTS_PI4 VTS_PI4 VTS_PI4 VTS_PI2 VTS_PBOOL;
    InvokeHelper(0xc1e, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        lNbFiles, lCompressedSize, lUncompressedSize, nCompressionRatio, bSpanned);
    return result;
}

void IXceedZip::SfxAddProgramGroupItem(LPCTSTR sApplication, LPCTSTR sDescription)
{
    static BYTE parms[] =
        VTS_BSTR VTS_BSTR;
    InvokeHelper(0xc80, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sApplication, sDescription);
}

void IXceedZip::SfxAddExtensionToAssociate(LPCTSTR sDescription, LPCTSTR sExtension, LPCTSTR sApplication)
{
    static BYTE parms[] =
        VTS_BSTR VTS_BSTR VTS_BSTR;
    InvokeHelper(0xc81, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sDescription, sExtension, sApplication);
}

void IXceedZip::SfxResetButtons()
{
    InvokeHelper(0xc82, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IXceedZip::SfxResetMessages()
{
    InvokeHelper(0xc83, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IXceedZip::SfxResetStrings()
{
    InvokeHelper(0xc84, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IXceedZip::SfxClearButtons()
{
    InvokeHelper(0xc85, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IXceedZip::SfxClearMessages()
{
    InvokeHelper(0xc86, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

void IXceedZip::SfxClearStrings()
{
    InvokeHelper(0xc87, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

long IXceedZip::Convert(LPCTSTR sDestFilename)
{
    long result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0xc88, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        sDestFilename);
    return result;
}

BOOL IXceedZip::License(LPCTSTR sLicense)
{
    BOOL result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x176f, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        sLicense);
    return result;
}

BOOL IXceedZip::SfxLoadConfig(LPCTSTR sConfigFilename)
{
    BOOL result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x203, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        sConfigFilename);
    return result;
}

BOOL IXceedZip::SfxSaveConfig(LPCTSTR sConfigFilename)
{
    BOOL result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x204, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        sConfigFilename);
    return result;
}

CString IXceedZip::GetErrorDescription(long xType, long lValue)
{
    CString result;
    static BYTE parms[] =
        VTS_I4 VTS_I4;
    InvokeHelper(0x1388, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        xType, lValue);
    return result;
}


/////////////////////////////////////////////////////////////////////////////
// _IXceedZipEvents properties

/////////////////////////////////////////////////////////////////////////////
// _IXceedZipEvents operations

void _IXceedZipEvents::ListingFile(LPCTSTR sFilename, LPCTSTR sComment, long lSize, long lCompressedSize, short nCompressionRatio, long xAttributes, long lCRC, DATE dtLastModified, DATE dtLastAccessed, DATE dtCreated, long xMethod, BOOL bEncrypted,
        long lDiskNumber, BOOL bExcluded, long xReason)
{
    static BYTE parms[] =
        VTS_BSTR VTS_BSTR VTS_I4 VTS_I4 VTS_I2 VTS_I4 VTS_I4 VTS_DATE VTS_DATE VTS_DATE VTS_I4 VTS_BOOL VTS_I4 VTS_BOOL VTS_I4;
    InvokeHelper(0x1771, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sFilename, sComment, lSize, lCompressedSize, nCompressionRatio, xAttributes, lCRC, dtLastModified, dtLastAccessed, dtCreated, xMethod, bEncrypted, lDiskNumber, bExcluded, xReason);
}

void _IXceedZipEvents::PreviewingFile(LPCTSTR sFilename, LPCTSTR sSourceFilename, long lSize, long xAttributes, DATE dtLastModified, DATE dtLastAccessed, DATE dtCreated, BOOL bExcluded, long xReason)
{
    static BYTE parms[] =
        VTS_BSTR VTS_BSTR VTS_I4 VTS_I4 VTS_DATE VTS_DATE VTS_DATE VTS_BOOL VTS_I4;
    InvokeHelper(0x1770, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sFilename, sSourceFilename, lSize, xAttributes, dtLastModified, dtLastAccessed, dtCreated, bExcluded, xReason);
}

void _IXceedZipEvents::InsertDisk(long lDiskNumber, BOOL* bDiskInserted)
{
    static BYTE parms[] =
        VTS_I4 VTS_PBOOL;
    InvokeHelper(0x1838, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         lDiskNumber, bDiskInserted);
}

void _IXceedZipEvents::ZipPreprocessingFile(BSTR* sFilename, BSTR* sComment, LPCTSTR sSourceFilename, long lSize, long* xAttributes, DATE* dtLastModified, DATE* dtLastAccessed, DATE* dtCreated, long* xMethod, BOOL* bEncrypted, BSTR* sPassword, BOOL* bExcluded,
        long xReason, BOOL bExisting)
{
    static BYTE parms[] =
        VTS_PBSTR VTS_PBSTR VTS_BSTR VTS_I4 VTS_PI4 VTS_PDATE VTS_PDATE VTS_PDATE VTS_PI4 VTS_PBOOL VTS_PBSTR VTS_PBOOL VTS_I4 VTS_BOOL;
    InvokeHelper(0x1774, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sFilename, sComment, sSourceFilename, lSize, xAttributes, dtLastModified, dtLastAccessed, dtCreated, xMethod, bEncrypted, sPassword, bExcluded, xReason, bExisting);
}

void _IXceedZipEvents::UnzipPreprocessingFile(LPCTSTR sFilename, LPCTSTR sComment, BSTR* sDestFilename, long lSize, long lCompressedSize, long* xAttributes, long lCRC, DATE* dtLastModified, DATE* dtLastAccessed, DATE* dtCreated, long xMethod, BOOL bEncrypted,
        BSTR* sPassword, long lDiskNumber, BOOL* bExcluded, long xReason, BOOL bExisting, long* xDestination)
{
    static BYTE parms[] =
        VTS_BSTR VTS_BSTR VTS_PBSTR VTS_I4 VTS_I4 VTS_PI4 VTS_I4 VTS_PDATE VTS_PDATE VTS_PDATE VTS_I4 VTS_BOOL VTS_PBSTR VTS_I4 VTS_PBOOL VTS_I4 VTS_BOOL VTS_PI4;
    InvokeHelper(0x1775, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sFilename, sComment, sDestFilename, lSize, lCompressedSize, xAttributes, lCRC, dtLastModified, dtLastAccessed, dtCreated, xMethod, bEncrypted, sPassword, lDiskNumber, bExcluded, xReason, bExisting, xDestination);
}

void _IXceedZipEvents::SkippingFile(LPCTSTR sFilename, LPCTSTR sComment, LPCTSTR sFilenameOnDisk, long lSize, long lCompressedSize, long xAttributes, long lCRC, DATE dtLastModified, DATE dtLastAccessed, DATE dtCreated, long xMethod, BOOL bEncrypted,
        long xReason)
{
    static BYTE parms[] =
        VTS_BSTR VTS_BSTR VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_DATE VTS_DATE VTS_DATE VTS_I4 VTS_BOOL VTS_I4;
    InvokeHelper(0x17d6, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sFilename, sComment, sFilenameOnDisk, lSize, lCompressedSize, xAttributes, lCRC, dtLastModified, dtLastAccessed, dtCreated, xMethod, bEncrypted, xReason);
}

void _IXceedZipEvents::RemovingFile(LPCTSTR sFilename, LPCTSTR sComment, long lSize, long lCompressedSize, long xAttributes, long lCRC, DATE dtLastModified, DATE dtLastAccessed, DATE dtCreated, long xMethod, BOOL bEncrypted)
{
    static BYTE parms[] =
        VTS_BSTR VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_DATE VTS_DATE VTS_DATE VTS_I4 VTS_BOOL;
    InvokeHelper(0x1777, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sFilename, sComment, lSize, lCompressedSize, xAttributes, lCRC, dtLastModified, dtLastAccessed, dtCreated, xMethod, bEncrypted);
}

void _IXceedZipEvents::TestingFile(LPCTSTR sFilename, LPCTSTR sComment, long lSize, long lCompressedSize, short nCompressionRatio, long xAttributes, long lCRC, DATE dtLastModified, DATE dtLastAccessed, DATE dtCreated, long xMethod, BOOL bEncrypted,
        long lDiskNumber)
{
    static BYTE parms[] =
        VTS_BSTR VTS_BSTR VTS_I4 VTS_I4 VTS_I2 VTS_I4 VTS_I4 VTS_DATE VTS_DATE VTS_DATE VTS_I4 VTS_BOOL VTS_I4;
    InvokeHelper(0x1778, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sFilename, sComment, lSize, lCompressedSize, nCompressionRatio, xAttributes, lCRC, dtLastModified, dtLastAccessed, dtCreated, xMethod, bEncrypted, lDiskNumber);
}

void _IXceedZipEvents::FileStatus(LPCTSTR sFilename, long lSize, long lCompressedSize, long lBytesProcessed, short nBytesPercent, short nCompressionRatio, BOOL bFileCompleted)
{
    static BYTE parms[] =
        VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_I2 VTS_I2 VTS_BOOL;
    InvokeHelper(0x17d4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sFilename, lSize, lCompressedSize, lBytesProcessed, nBytesPercent, nCompressionRatio, bFileCompleted);
}

void _IXceedZipEvents::GlobalStatus(long lFilesTotal, long lFilesProcessed, long lFilesSkipped, short nFilesPercent, long lBytesTotal, long lBytesProcessed, long lBytesSkipped, short nBytesPercent, long lBytesOutput, short nCompressionRatio)
{
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_I4 VTS_I2 VTS_I4 VTS_I4 VTS_I4 VTS_I2 VTS_I4 VTS_I2;
    InvokeHelper(0x17d5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         lFilesTotal, lFilesProcessed, lFilesSkipped, nFilesPercent, lBytesTotal, lBytesProcessed, lBytesSkipped, nBytesPercent, lBytesOutput, nCompressionRatio);
}

void _IXceedZipEvents::DiskNotEmpty(long* xAction)
{
    static BYTE parms[] =
        VTS_PI4;
    InvokeHelper(0x1839, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         xAction);
}

void _IXceedZipEvents::ProcessCompleted(long lFilesTotal, long lFilesProcessed, long lFilesSkipped, long lBytesTotal, long lBytesProcessed, long lBytesSkipped, long lBytesOutput, short nCompressionRatio, long xResult)
{
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I4 VTS_I2 VTS_I4;
    InvokeHelper(0x22c4, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         lFilesTotal, lFilesProcessed, lFilesSkipped, lBytesTotal, lBytesProcessed, lBytesSkipped, lBytesOutput, nCompressionRatio, xResult);
}

void _IXceedZipEvents::ZipComment(BSTR* sComment)
{
    static BYTE parms[] =
        VTS_PBSTR;
    InvokeHelper(0x22c5, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sComment);
}

void _IXceedZipEvents::QueryMemoryFile(long* lUserTag, BSTR* sFilename, BSTR* sComment, long* xAttributes, DATE* dtLastModified, DATE* dtLastAccessed, DATE* dtCreated, BOOL* bEncrypted, BSTR* sPassword, BOOL* bFileProvided)
{
    static BYTE parms[] =
        VTS_PI4 VTS_PBSTR VTS_PBSTR VTS_PI4 VTS_PDATE VTS_PDATE VTS_PDATE VTS_PBOOL VTS_PBSTR VTS_PBOOL;
    InvokeHelper(0x1772, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         lUserTag, sFilename, sComment, xAttributes, dtLastModified, dtLastAccessed, dtCreated, bEncrypted, sPassword, bFileProvided);
}

void _IXceedZipEvents::ZippingMemoryFile(long lUserTag, LPCTSTR sFilename, VARIANT* vaDataToCompress, BOOL* bEndOfData)
{
    static BYTE parms[] =
        VTS_I4 VTS_BSTR VTS_PVARIANT VTS_PBOOL;
    InvokeHelper(0x1773, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         lUserTag, sFilename, vaDataToCompress, bEndOfData);
}

void _IXceedZipEvents::UnzippingMemoryFile(LPCTSTR sFilename, VARIANT* vaUncompressedData, BOOL bEndOfData)
{
    static BYTE parms[] =
        VTS_BSTR VTS_PVARIANT VTS_BOOL;
    InvokeHelper(0x1776, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sFilename, vaUncompressedData, bEndOfData);
}

void _IXceedZipEvents::Warning(LPCTSTR sFilename, long xWarning)
{
    static BYTE parms[] =
        VTS_BSTR VTS_I4;
    InvokeHelper(0x17d7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sFilename, xWarning);
}

void _IXceedZipEvents::InvalidPassword(LPCTSTR sFilename, BSTR* sNewPassword, BOOL* bRetry)
{
    static BYTE parms[] =
        VTS_BSTR VTS_PBSTR VTS_PBOOL;
    InvokeHelper(0x183a, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sFilename, sNewPassword, bRetry);
}

void _IXceedZipEvents::ReplacingFile(LPCTSTR sFilename, LPCTSTR sComment, long lSize, long xAttributes, DATE dtLastModified, DATE dtLastAccessed, DATE dtCreated, LPCTSTR sOrigFilename, long lOrigSize, long xOrigAttributes, DATE dtOrigLastModified,
        DATE dtOrigLastAccessed, DATE dtOrigCreated, BOOL* bReplaceFile)
{
    static BYTE parms[] =
        VTS_BSTR VTS_BSTR VTS_I4 VTS_I4 VTS_DATE VTS_DATE VTS_DATE VTS_BSTR VTS_I4 VTS_I4 VTS_DATE VTS_DATE VTS_DATE VTS_PBOOL;
    InvokeHelper(0x183b, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sFilename, sComment, lSize, xAttributes, dtLastModified, dtLastAccessed, dtCreated, sOrigFilename, lOrigSize, xOrigAttributes, dtOrigLastModified, dtOrigLastAccessed, dtOrigCreated, bReplaceFile);
}

void _IXceedZipEvents::ZipContentsStatus(long lFilesRead, long lFilesTotal, short nFilesPercent)
{
    static BYTE parms[] =
        VTS_I4 VTS_I4 VTS_I2;
    InvokeHelper(0x17d8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         lFilesRead, lFilesTotal, nFilesPercent);
}


/////////////////////////////////////////////////////////////////////////////
// IXceedCompression properties

/////////////////////////////////////////////////////////////////////////////
// IXceedCompression operations

long IXceedCompression::GetCompressionLevel()
{
    long result;
    InvokeHelper(0x64, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void IXceedCompression::SetCompressionLevel(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x64, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

CString IXceedCompression::GetEncryptionPassword()
{
    CString result;
    InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
    return result;
}

void IXceedCompression::SetEncryptionPassword(LPCTSTR lpszNewValue)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         lpszNewValue);
}

long IXceedCompression::Compress(VARIANT* vaSource, VARIANT* vaCompressed, BOOL bEndOfData)
{
    long result;
    static BYTE parms[] =
        VTS_PVARIANT VTS_PVARIANT VTS_BOOL;
    InvokeHelper(0xbb8, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        vaSource, vaCompressed, bEndOfData);
    return result;
}

long IXceedCompression::Uncompress(VARIANT* vaSource, VARIANT* vaUncompressed, BOOL bEndOfData)
{
    long result;
    static BYTE parms[] =
        VTS_PVARIANT VTS_PVARIANT VTS_BOOL;
    InvokeHelper(0xbb9, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        vaSource, vaUncompressed, bEndOfData);
    return result;
}

long IXceedCompression::CalculateCrc(VARIANT* vaData, long lPreviousCrc)
{
    long result;
    static BYTE parms[] =
        VTS_PVARIANT VTS_I4;
    InvokeHelper(0xbba, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        vaData, lPreviousCrc);
    return result;
}

BOOL IXceedCompression::License(LPCTSTR sLicense)
{
    BOOL result;
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x176f, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        sLicense);
    return result;
}

CString IXceedCompression::GetErrorDescription(long lValue)
{
    CString result;
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x1388, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
        lValue);
    return result;
}