// Script als Textdatei einlesen ----------------------------------------------
HRESULT CImpIPersistStream::LoadScript_FromDB (LPSTREAM pIStream, ebFILEHEADER &rHead)
{
ASSERT(pIStream);
ULONG ulBytes = 0;
if (m_pText) CoTaskMemFree (m_pText); m_pText = NULL;
m_pText = (LPSTR) CoTaskMemAlloc (rHead.dwScriptSz+1);
if (m_pText == NULL) return ResultFromScode(E_OUTOFMEMORY);
LARGE_INTEGER li;
LISet32 (li, rHead.dwScript);
HRESULT hr = pIStream -> Seek (li, STREAM_SEEK_SET, NULL);
if (FAILED(hr)) {
CoTaskMemFree(m_pText); m_pText = NULL; return hr;
}
hr = pIStream -> Read (m_pText, (ULONG)rHead.dwScriptSz, &ulBytes);
ASSERT(ulBytes<MAXTEXT);
ASSERT(ulBytes>0);
if (FAILED(hr) || ulBytes != (ULONG)rHead.dwScriptSz) {
CoTaskMemFree (m_pText); m_pText = NULL; return ResultFromScode(E_FAIL);
}
return hr;
}
FARINTERNAL UtDIBFileStmToPBrushNativeStm
(LPSTREAM pstmDIBFile, LPSTREAM pstmPBrush)
{
BITMAPFILEHEADER bfh;
HRESULT error;
if (error = pstmDIBFile->Read(&bfh, sizeof(bfh), 0))
return error;
// seek to the begining of the stream
LARGE_INTEGER large_int;
LISet32( large_int, 0);
if (error = pstmDIBFile->Seek(large_int, STREAM_SEEK_SET, 0))
return error;
if (error = pstmPBrush->Write(&(bfh.bfSize), sizeof(DWORD), 0))
return error;
ULARGE_INTEGER ularge_int;
ULISet32(ularge_int, bfh.bfSize);
if ((error = pstmDIBFile->CopyTo(pstmPBrush, ularge_int,
NULL, NULL)) == NOERROR)
StSetSize(pstmPBrush, 0, TRUE);
return error;
}
///////////////////////////////////////////////////////////////////////////////
// Schreiben/Lesen eines Variant
HRESULT SetVariantData (CComVariant &rv, IDataObject *pIDO, const FORMATETC *pcfe)
{
// Stream mit Variant generieren
WStream IStream;
HRESULT hr = CreateStreamOnHGlobal (NULL, true, IStream.ppi());
if (FAILED(hr)) return hr;
// Variant dort rein schreiben
hr = rv.WriteToStream (IStream);
if (FAILED(hr)) return hr;
LARGE_INTEGER li;
LISet32(li, 0L);
hr = IStream -> Seek (li, SEEK_SET, NULL);
if (FAILED(hr)) return hr;
// diesen Stream im DataObject setzen
STGMEDIUM stg;
stg.tymed = TYMED_ISTREAM;
stg.pstm = IStream.detach();
stg.pUnkForRelease = NULL;
hr = pIDO -> SetData ((FORMATETC *)pcfe, &stg, true);
if (FAILED(hr)) {
ReleaseStgMedium (&stg);
return hr;
}
return S_OK;
}
// Serialisieren/DeSerialisieren eines IUnknowns
// in diesem Falle ein IDataObject
HRESULT CreateStreamOnHGlobalFromIUnknown (
IUnknown *pIUnk, REFCLSID rClsID, IStream **ppIStream)
{
ASSERT(NULL != pIUnk);
ASSERT(NULL != ppIStream);
*ppIStream = NULL;
try {
// neuen Stream anlegen, kreiert eine neuen Memoryblock der Größe NULL
// wird selbstständig wieder freigegen (true)
WStream IStream;
THROW_FAILED_HRESULT(CreateStreamOnHGlobal (NULL, true, IStream.ppi()));
// den Enumerator wegschreiben
WPersistStream IPersStr (pIUnk); // throws hr
THROW_FAILED_HRESULT(OleSaveToStream (IPersStr, IStream));
// wieder zurück positionieren
LARGE_INTEGER li;
LISet32 (li, 0L);
THROW_FAILED_HRESULT(IStream -> Seek (li, STREAM_SEEK_SET, NULL));
*ppIStream = IStream.detach();
}
catch (_com_error &e)
{
return _COM_ERROR(e);
}
return S_OK;
}
STDMETHODIMP CPropertyAction::GetSizeMax (ULARGE_INTEGER FAR* pcbSize)
{
char cbBuffer[_MAX_PATH];
RETURN_FAILED_HRESULT(GetPropInfo (cbBuffer, sizeof(cbBuffer), NULL));
LISet32(*pcbSize, 2*sizeof(DWORD)+sizeof(ULONG)+strlen(cbBuffer)+1);
return S_OK;
}
DWORD CswFile::Seek (LONG lDistanceToMove, DWORD dwMoveMethod)
{
LARGE_INTEGER liVar;
ULARGE_INTEGER liVar2;
LISet32 (liVar, lDistanceToMove);
m_pStream->Seek (liVar, dwMoveMethod, &liVar2);
return liVar2.LowPart;
}
// Compilierten Script laden --------------------------------------------------
HRESULT CImpIPersistStream::LoadCode_FromDB (LPSTREAM pIStream, ebFILEHEADER &rHead)
{
LPVOID lpCode = CoTaskMemAlloc (rHead.dwCodeSz);
if(lpCode == NULL) return ResultFromScode(E_OUTOFMEMORY);
// Code lesen
LARGE_INTEGER li;
LISet32 (li, rHead.dwCode);
HRESULT hr = pIStream -> Seek (li, STREAM_SEEK_SET, NULL);
if (FAILED(hr)) {
CoTaskMemFree(lpCode); lpCode = NULL; return hr;
}
ULONG ulBytes = 0;
hr = pIStream -> Read (lpCode, rHead.dwCodeSz, &ulBytes);
if (FAILED(hr) || ulBytes != (ULONG)(rHead.dwCodeSz)) {
CoTaskMemFree(lpCode); lpCode = NULL; return ResultFromScode(E_FAIL);
}
if (m_pText) CoTaskMemFree (m_pText); m_pText = NULL;
m_pText = (LPSTR) CoTaskMemAlloc (rHead.dwScriptSz+1);
if (m_pText == NULL) {
CoTaskMemFree(lpCode); lpCode = NULL; return ResultFromScode(E_OUTOFMEMORY);
}
// Script an sich lesen
LISet32 (li, rHead.dwScript);
hr = pIStream -> Seek (li, STREAM_SEEK_SET, NULL);
if (FAILED(hr)) {
CoTaskMemFree(lpCode); lpCode = NULL; CoTaskMemFree(m_pText); m_pText = NULL; return hr;
}
hr = pIStream -> Read (m_pText, (ULONG)rHead.dwScriptSz, &ulBytes);
ASSERT(ulBytes<MAXTEXT);
ASSERT(ulBytes>0);
if (FAILED(hr) || ulBytes!=(ULONG)rHead.dwScriptSz || ulBytes==0 || ulBytes>MAXTEXT) {
CoTaskMemFree(lpCode); lpCode = NULL; CoTaskMemFree(m_pText); m_pText = NULL;
return ResultFromScode(E_FAIL);
}
m_hCode = ebCode_Create(lpCode);
return hr;
}
STDMETHODIMP CPropertyActionBase::GetSizeMax (ULARGE_INTEGER FAR* pcbSize)
{
char cbBuffer[_MAX_PATH];
HRESULT hr = GetPropInfo (cbBuffer, sizeof(cbBuffer), NULL);
if (FAILED(hr)) return hr;
LISet32(*pcbSize, strlen(cbBuffer)+1);
return NOERROR;
}
HRESULT CImpIPersistStream::LoadHeader (LPSTREAM pIStream, ebFILEHEADER *pHeader)
{
ASSERT(pIStream);
ULONG ulBytes = 0;
// erst Headerinfo lesen
LARGE_INTEGER li;
LISet32 (li, 0);
HRESULT hr = pIStream -> Seek (li, STREAM_SEEK_SET, NULL);
if (FAILED(hr)) return hr;
hr = pIStream -> Read ((LPVOID)pHeader, sizeof(ebFILEHEADER), &ulBytes);
if (FAILED(hr) || 0==ulBytes) return ResultFromScode(E_FAIL);
if (ulBytes==sizeof(ebFILEHEADER) && pHeader->id==FH_ID && pHeader->wVersion==FH_VERSION)
return NOERROR;
return hr;
}
BOOL AFXAPI _AfxGetClassIDFromStreamedPropset(LPCLSID lpClsid, LPSTREAM lpStream)
{
BOOL bSuccess = FALSE;
ULARGE_INTEGER uliSave;
LARGE_INTEGER liClsidOffset;
LISet32(liClsidOffset, 8);
if (SUCCEEDED(lpStream->Seek(_afxLargeZero, STREAM_SEEK_CUR, &uliSave)))
{
if (SUCCEEDED(lpStream->Seek(liClsidOffset, STREAM_SEEK_CUR, NULL)) &&
SUCCEEDED(lpStream->Read(lpClsid, sizeof(CLSID), NULL)))
{
bSuccess = TRUE;
}
lpStream->Seek(*(LARGE_INTEGER*)&uliSave, STREAM_SEEK_SET, NULL);
}
return bSuccess;
}
// Script speichern ----------------------------------------------
HRESULT CImpIPersistStream::SaveScript_InDB (LPSTREAM pIStream, DWORD dwFlag)
{
ASSERT (pIStream);
ULARGE_INTEGER libEndPos;
ebFILEHEADER Head;
memset (&Head, 0, sizeof (Head));
Head.wVersion = FH_VERSION;
Head.id = FH_ID;
LARGE_INTEGER li;
LISet32 (li, 0);
HRESULT hr = NOERROR;
if (dwFlag == CC_ALL) {
ASSERT(m_pText);
ASSERT(m_hCode);
ASSERT(strlen(m_pText)>0);
ASSERT(ebCode_GetSize(m_hCode)>0);
Head.dwScriptSz = strlen(m_pText)+1;
Head.dwCodeSz = ebCode_GetSize(m_hCode);
hr = pIStream -> Seek (li, SEEK_SET, NULL);
if(FAILED(hr)) return hr;
hr = pIStream -> Write ((LPCSTR)&Head, sizeof(Head), NULL); // Header schreiben
if(FAILED(hr)) return hr;
hr = pIStream -> Seek (li, SEEK_CUR, &libEndPos);
if(FAILED(hr)) return hr;
Head.dwCode = libEndPos.LowPart;
hr = pIStream -> Write (ebCode_GetPointer(m_hCode), Head.dwCodeSz, NULL);
if(FAILED(hr)) return hr;
hr = pIStream -> Seek (li, SEEK_CUR, &libEndPos);
if(FAILED(hr)) return hr;
Head.dwScript = libEndPos.LowPart;
hr = pIStream -> Write (m_pText, Head.dwScriptSz, NULL);
if(FAILED(hr)) return hr;
}
else if (dwFlag & CC_SCRIPT) {
ASSERT(m_pText);
ASSERT(strlen(m_pText)>0);
Head.dwScriptSz = strlen(m_pText)+1;
hr = pIStream -> Seek (li, SEEK_SET, NULL);
if(FAILED(hr)) return hr;
hr = pIStream -> Write ((LPCSTR)&Head, sizeof(Head), NULL); // Header schreiben
if(FAILED(hr)) return hr;
hr = pIStream -> Seek (li, SEEK_CUR, &libEndPos);
if(FAILED(hr)) return hr;
Head.dwScript = libEndPos.LowPart;
hr = pIStream -> Write (m_pText, strlen(m_pText)+1, NULL);
if(FAILED(hr)) return hr;
}
else if (dwFlag & CC_CODE) {
ASSERT(m_hCode);
ASSERT(ebCode_GetSize(m_hCode)>0);
Head.dwCodeSz = ebCode_GetSize(m_hCode);
hr = pIStream -> Seek (li, SEEK_SET, NULL);
if(FAILED(hr)) return hr;
hr = pIStream -> Write ((LPCSTR)&Head, sizeof(Head), NULL); // Header schreiben
if(FAILED(hr)) return hr;
hr = pIStream -> Seek (li, SEEK_CUR, &libEndPos);
if(FAILED(hr)) return hr;
Head.dwCode = libEndPos.LowPart;
hr = pIStream -> Write (ebCode_GetPointer(m_hCode), Head.dwCodeSz, NULL);
if(FAILED(hr)) return hr;
}
else ASSERT(0);
// nun Header mit den wirklich geschriebenen Groessen noch einmal schreiben
LISet32 (li, 0);
hr = pIStream -> Seek (li, SEEK_SET, NULL);
if(FAILED(hr)) return hr;
hr = pIStream -> Write ((LPCSTR)&Head, sizeof(Head), NULL);
if(FAILED(hr)) return hr;
return hr;
}
