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

C/C++ Source or Header | 2001-06-06 | 18.5 KB | 701 lines

// Machine generated IDispatch wrapper class(es) created with ClassWizard

#include "stdafx.h"
#include "xceedcry.h"

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



/////////////////////////////////////////////////////////////////////////////
// DXceedEncryption properties

/////////////////////////////////////////////////////////////////////////////
// DXceedEncryption operations

LPDISPATCH DXceedEncryption::GetEncryptionMethod()
{
    LPDISPATCH result;
    InvokeHelper(0x12c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void DXceedEncryption::SetRefEncryptionMethod(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x12c, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
         newValue);
}

VARIANT DXceedEncryption::Encrypt(VARIANT* vaSource, BOOL bEndOfData)
{
    VARIANT result;
    static BYTE parms[] =
        VTS_PVARIANT VTS_BOOL;
    InvokeHelper(0x190, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
        vaSource, bEndOfData);
    return result;
}

VARIANT DXceedEncryption::Decrypt(VARIANT* vaEncrypted, BOOL bEndOfData)
{
    VARIANT result;
    static BYTE parms[] =
        VTS_PVARIANT VTS_BOOL;
    InvokeHelper(0x191, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
        vaEncrypted, bEndOfData);
    return result;
}

BOOL DXceedEncryption::Compare(VARIANT* vaSource1, VARIANT* vaSource2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PVARIANT VTS_PVARIANT;
    InvokeHelper(0x192, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        vaSource1, vaSource2);
    return result;
}

VARIANT DXceedEncryption::ReadFile(LPCTSTR sSourceFilename, long lSourceOffset, long lSourceSize, long eAction, BOOL bEndOfData, VARIANT* vaBytesRead)
{
    VARIANT result;
    static BYTE parms[] =
        VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_BOOL VTS_PVARIANT;
    InvokeHelper(0x193, DISPATCH_METHOD, VT_VARIANT, (void*)&result, parms,
        sSourceFilename, lSourceOffset, lSourceSize, eAction, bEndOfData, vaBytesRead);
    return result;
}

long DXceedEncryption::WriteFile(VARIANT* vaData, long eAction, BOOL bEndOfData, LPCTSTR sDestFilename, BOOL bAppend)
{
    long result;
    static BYTE parms[] =
        VTS_PVARIANT VTS_I4 VTS_BOOL VTS_BSTR VTS_BOOL;
    InvokeHelper(0x194, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        vaData, eAction, bEndOfData, sDestFilename, bAppend);
    return result;
}

long DXceedEncryption::ProcessFile(LPCTSTR sSourceFilename, long lSourceOffset, long lSourceSize, long eAction, BOOL bEndOfData, LPCTSTR sDestFilename, BOOL bAppend, VARIANT* vaBytesRead)
{
    long result;
    static BYTE parms[] =
        VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_BOOL VTS_BSTR VTS_BOOL VTS_PVARIANT;
    InvokeHelper(0x195, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        sSourceFilename, lSourceOffset, lSourceSize, eAction, bEndOfData, sDestFilename, bAppend, vaBytesRead);
    return result;
}

void DXceedEncryption::Reset()
{
    InvokeHelper(0x196, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// DXceedRijndaelEncryptionMethod properties

/////////////////////////////////////////////////////////////////////////////
// DXceedRijndaelEncryptionMethod operations

long DXceedRijndaelEncryptionMethod::GetEncryptionMode()
{
    long result;
    InvokeHelper(0x2bd, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void DXceedRijndaelEncryptionMethod::SetEncryptionMode(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x2bd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

LPDISPATCH DXceedRijndaelEncryptionMethod::GetHashingMethod()
{
    LPDISPATCH result;
    InvokeHelper(0x2be, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void DXceedRijndaelEncryptionMethod::SetRefHashingMethod(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2be, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
         newValue);
}

VARIANT DXceedRijndaelEncryptionMethod::GetSecretKey()
{
    VARIANT result;
    InvokeHelper(0x2bf, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
    return result;
}

void DXceedRijndaelEncryptionMethod::SetSecretKey(VARIANT* newValue)
{
    static BYTE parms[] =
        VTS_PVARIANT;
    InvokeHelper(0x2bf, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

VARIANT DXceedRijndaelEncryptionMethod::GetInitVector()
{
    VARIANT result;
    InvokeHelper(0x2c0, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
    return result;
}

void DXceedRijndaelEncryptionMethod::SetInitVector(VARIANT* newValue)
{
    static BYTE parms[] =
        VTS_PVARIANT;
    InvokeHelper(0x2c0, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

long DXceedRijndaelEncryptionMethod::GetPaddingMethod()
{
    long result;
    InvokeHelper(0x2c1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void DXceedRijndaelEncryptionMethod::SetPaddingMethod(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x2c1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

LPDISPATCH DXceedRijndaelEncryptionMethod::GetSubProcessing()
{
    LPDISPATCH result;
    InvokeHelper(0x2bc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void DXceedRijndaelEncryptionMethod::SetRefSubProcessing(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x2bc, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
         newValue);
}

void DXceedRijndaelEncryptionMethod::SetSecretKeyFromPassPhrase(LPCTSTR sPassPhrase, short nKeySize)
{
    static BYTE parms[] =
        VTS_BSTR VTS_I2;
    InvokeHelper(0x320, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sPassPhrase, nKeySize);
}

void DXceedRijndaelEncryptionMethod::SetRandomSecretKey(short nKeySize)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x321, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         nKeySize);
}

void DXceedRijndaelEncryptionMethod::SetInitVectorFromPassPhrase(LPCTSTR sPassPhrase)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x322, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sPassPhrase);
}

void DXceedRijndaelEncryptionMethod::SetRandomInitVector()
{
    InvokeHelper(0x323, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// DXceedTwofishEncryptionMethod properties

/////////////////////////////////////////////////////////////////////////////
// DXceedTwofishEncryptionMethod operations

long DXceedTwofishEncryptionMethod::GetEncryptionMode()
{
    long result;
    InvokeHelper(0x385, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void DXceedTwofishEncryptionMethod::SetEncryptionMode(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x385, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

LPDISPATCH DXceedTwofishEncryptionMethod::GetHashingMethod()
{
    LPDISPATCH result;
    InvokeHelper(0x386, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void DXceedTwofishEncryptionMethod::SetRefHashingMethod(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x386, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
         newValue);
}

VARIANT DXceedTwofishEncryptionMethod::GetSecretKey()
{
    VARIANT result;
    InvokeHelper(0x387, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
    return result;
}

void DXceedTwofishEncryptionMethod::SetSecretKey(VARIANT* newValue)
{
    static BYTE parms[] =
        VTS_PVARIANT;
    InvokeHelper(0x387, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

VARIANT DXceedTwofishEncryptionMethod::GetInitVector()
{
    VARIANT result;
    InvokeHelper(0x388, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
    return result;
}

void DXceedTwofishEncryptionMethod::SetInitVector(VARIANT* newValue)
{
    static BYTE parms[] =
        VTS_PVARIANT;
    InvokeHelper(0x388, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

long DXceedTwofishEncryptionMethod::GetPaddingMethod()
{
    long result;
    InvokeHelper(0x389, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
    return result;
}

void DXceedTwofishEncryptionMethod::SetPaddingMethod(long nNewValue)
{
    static BYTE parms[] =
        VTS_I4;
    InvokeHelper(0x389, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

LPDISPATCH DXceedTwofishEncryptionMethod::GetSubProcessing()
{
    LPDISPATCH result;
    InvokeHelper(0x384, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void DXceedTwofishEncryptionMethod::SetRefSubProcessing(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x384, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
         newValue);
}

void DXceedTwofishEncryptionMethod::SetSecretKeyFromPassPhrase(LPCTSTR sPassPhrase, short nKeySize)
{
    static BYTE parms[] =
        VTS_BSTR VTS_I2;
    InvokeHelper(0x3e8, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sPassPhrase, nKeySize);
}

void DXceedTwofishEncryptionMethod::SetRandomSecretKey(short nKeySize)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x3e9, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         nKeySize);
}

void DXceedTwofishEncryptionMethod::SetInitVectorFromPassPhrase(LPCTSTR sPassPhrase)
{
    static BYTE parms[] =
        VTS_BSTR;
    InvokeHelper(0x3ea, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         sPassPhrase);
}

void DXceedTwofishEncryptionMethod::SetRandomInitVector()
{
    InvokeHelper(0x3eb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// DXceedRSAEncryptionMethod properties

/////////////////////////////////////////////////////////////////////////////
// DXceedRSAEncryptionMethod operations

VARIANT DXceedRSAEncryptionMethod::GetPrivateKey()
{
    VARIANT result;
    InvokeHelper(0x44d, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
    return result;
}

void DXceedRSAEncryptionMethod::SetPrivateKey(VARIANT* newValue)
{
    static BYTE parms[] =
        VTS_PVARIANT;
    InvokeHelper(0x44d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

VARIANT DXceedRSAEncryptionMethod::GetPublicKey()
{
    VARIANT result;
    InvokeHelper(0x44e, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
    return result;
}

void DXceedRSAEncryptionMethod::SetPublicKey(VARIANT* newValue)
{
    static BYTE parms[] =
        VTS_PVARIANT;
    InvokeHelper(0x44e, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

short DXceedRSAEncryptionMethod::GetBlockSize()
{
    short result;
    InvokeHelper(0x44f, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

LPDISPATCH DXceedRSAEncryptionMethod::GetSubProcessing()
{
    LPDISPATCH result;
    InvokeHelper(0x44c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void DXceedRSAEncryptionMethod::SetRefSubProcessing(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x44c, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
         newValue);
}

void DXceedRSAEncryptionMethod::SetRandomKeyPair(short nKeySize, VARIANT* vaSeed)
{
    static BYTE parms[] =
        VTS_I2 VTS_PVARIANT;
    InvokeHelper(0x4b0, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         nKeySize, vaSeed);
}


/////////////////////////////////////////////////////////////////////////////
// DXceedHashing properties

/////////////////////////////////////////////////////////////////////////////
// DXceedHashing operations

LPDISPATCH DXceedHashing::GetHashingMethod()
{
    LPDISPATCH result;
    InvokeHelper(0x514, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void DXceedHashing::SetRefHashingMethod(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x514, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
         newValue);
}

void DXceedHashing::Hash(VARIANT* vaSource, BOOL bEndOfData)
{
    static BYTE parms[] =
        VTS_PVARIANT VTS_BOOL;
    InvokeHelper(0x578, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         vaSource, bEndOfData);
}

BOOL DXceedHashing::Compare(VARIANT* vaSource1, VARIANT* vaSource2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PVARIANT VTS_PVARIANT;
    InvokeHelper(0x579, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        vaSource1, vaSource2);
    return result;
}

long DXceedHashing::ReadFile(LPCTSTR sSourceFilename, long lSourceOffset, long lSourceSize, long eAction, BOOL bEndOfData)
{
    long result;
    static BYTE parms[] =
        VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_BOOL;
    InvokeHelper(0x57a, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        sSourceFilename, lSourceOffset, lSourceSize, eAction, bEndOfData);
    return result;
}

void DXceedHashing::Reset()
{
    InvokeHelper(0x57b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// DXceedSHAHashingMethod properties

/////////////////////////////////////////////////////////////////////////////
// DXceedSHAHashingMethod operations

short DXceedSHAHashingMethod::GetHashSize()
{
    short result;
    InvokeHelper(0x5dd, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void DXceedSHAHashingMethod::SetHashSize(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x5dd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

VARIANT DXceedSHAHashingMethod::GetHashValue()
{
    VARIANT result;
    InvokeHelper(0x5de, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
    return result;
}

LPDISPATCH DXceedSHAHashingMethod::GetSubProcessing()
{
    LPDISPATCH result;
    InvokeHelper(0x5dc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void DXceedSHAHashingMethod::SetRefSubProcessing(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x5dc, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
         newValue);
}


/////////////////////////////////////////////////////////////////////////////
// DXceedHavalHashingMethod properties

/////////////////////////////////////////////////////////////////////////////
// DXceedHavalHashingMethod operations

short DXceedHavalHashingMethod::GetHashSize()
{
    short result;
    InvokeHelper(0x6a5, DISPATCH_PROPERTYGET, VT_I2, (void*)&result, NULL);
    return result;
}

void DXceedHavalHashingMethod::SetHashSize(short nNewValue)
{
    static BYTE parms[] =
        VTS_I2;
    InvokeHelper(0x6a5, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         nNewValue);
}

VARIANT DXceedHavalHashingMethod::GetHashValue()
{
    VARIANT result;
    InvokeHelper(0x6a6, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
    return result;
}

LPDISPATCH DXceedHavalHashingMethod::GetSubProcessing()
{
    LPDISPATCH result;
    InvokeHelper(0x6a4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void DXceedHavalHashingMethod::SetRefSubProcessing(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x6a4, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
         newValue);
}


/////////////////////////////////////////////////////////////////////////////
// DXceedSigning properties

/////////////////////////////////////////////////////////////////////////////
// DXceedSigning operations

LPDISPATCH DXceedSigning::GetSigningMethod()
{
    LPDISPATCH result;
    InvokeHelper(0x76c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void DXceedSigning::SetRefSigningMethod(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x76c, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
         newValue);
}

void DXceedSigning::Sign(VARIANT* vaSource, BOOL bEndOfData)
{
    static BYTE parms[] =
        VTS_PVARIANT VTS_BOOL;
    InvokeHelper(0x7d0, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         vaSource, bEndOfData);
}

BOOL DXceedSigning::Verify(VARIANT* vaSource, BOOL bEndOfData)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PVARIANT VTS_BOOL;
    InvokeHelper(0x7d1, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        vaSource, bEndOfData);
    return result;
}

BOOL DXceedSigning::Compare(VARIANT* vaSource1, VARIANT* vaSource2)
{
    BOOL result;
    static BYTE parms[] =
        VTS_PVARIANT VTS_PVARIANT;
    InvokeHelper(0x7d2, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
        vaSource1, vaSource2);
    return result;
}

long DXceedSigning::ReadFile(LPCTSTR sSourceFilename, long lSourceOffset, long lSourceSize, long eAction, BOOL bEndOfData)
{
    long result;
    static BYTE parms[] =
        VTS_BSTR VTS_I4 VTS_I4 VTS_I4 VTS_BOOL;
    InvokeHelper(0x7d3, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
        sSourceFilename, lSourceOffset, lSourceSize, eAction, bEndOfData);
    return result;
}

void DXceedSigning::Reset()
{
    InvokeHelper(0x7d4, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}


/////////////////////////////////////////////////////////////////////////////
// DXceedRSASigningMethod properties

/////////////////////////////////////////////////////////////////////////////
// DXceedRSASigningMethod operations

VARIANT DXceedRSASigningMethod::GetPrivateKey()
{
    VARIANT result;
    InvokeHelper(0x835, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
    return result;
}

void DXceedRSASigningMethod::SetPrivateKey(VARIANT* newValue)
{
    static BYTE parms[] =
        VTS_PVARIANT;
    InvokeHelper(0x835, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

VARIANT DXceedRSASigningMethod::GetPublicKey()
{
    VARIANT result;
    InvokeHelper(0x836, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
    return result;
}

void DXceedRSASigningMethod::SetPublicKey(VARIANT* newValue)
{
    static BYTE parms[] =
        VTS_PVARIANT;
    InvokeHelper(0x836, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

VARIANT DXceedRSASigningMethod::GetSignature()
{
    VARIANT result;
    InvokeHelper(0x837, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
    return result;
}

void DXceedRSASigningMethod::SetSignature(VARIANT* newValue)
{
    static BYTE parms[] =
        VTS_PVARIANT;
    InvokeHelper(0x837, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
         newValue);
}

LPDISPATCH DXceedRSASigningMethod::GetSubProcessing()
{
    LPDISPATCH result;
    InvokeHelper(0x834, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&result, NULL);
    return result;
}

void DXceedRSASigningMethod::SetRefSubProcessing(LPDISPATCH newValue)
{
    static BYTE parms[] =
        VTS_DISPATCH;
    InvokeHelper(0x834, DISPATCH_PROPERTYPUTREF, VT_EMPTY, NULL, parms,
         newValue);
}

void DXceedRSASigningMethod::SetRandomKeyPair(short nKeySize, VARIANT* vaSeed)
{
    static BYTE parms[] =
        VTS_I2 VTS_PVARIANT;
    InvokeHelper(0x898, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
         nKeySize, vaSeed);
}