STDMETHODIMP CValueAxis::Load(LPSTREAM pStm)
{
pStm->Read(&m_iWholeDigits, sizeof(int), NULL);
pStm->Read(&m_iDecimalDigits, sizeof(int), NULL);
pStm->Read(&m_dMinVal, sizeof(double), NULL);
pStm->Read(&m_dMaxVal, sizeof(double), NULL);
return CAxis::Load(pStm);
}
STDMETHODIMP CAxis::Load(LPSTREAM pStm)
{
m_bstrDisplayFormat.ReadFromStream(pStm);
m_bstrTitle.ReadFromStream(pStm);
pStm->Read(&m_lNumTicks, sizeof(m_lNumTicks), NULL);
pStm->Read(&m_bShowAxis, sizeof(m_bShowAxis), NULL);
pStm->Read(&m_bShowTitle, sizeof(m_bShowTitle), NULL);
pStm->Read(&m_clrAxis, sizeof(m_clrAxis), NULL);
pStm->Read(&m_clrTitle, sizeof(m_clrTitle), NULL);
ReadFontFromStream(&m_spTickFont, pStm);
ReadFontFromStream(&m_spTitleFont, pStm);
return S_OK;
}
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;
}
HRESULT STDMETHODCALLTYPE CXMLDocument::Load(/* [in] */ LPSTREAM pStm)
{
if (pStm == NULL)
{
return E_INVALIDARG;
}
// Load the XML from the stream
STATSTG statstg;
pStm->Stat(&statstg, STATFLAG_NONAME);
ULONG cbBufSize = statstg.cbSize.LowPart;
char *pBuffer = new char[cbBufSize];
if (pBuffer == NULL)
{
return E_OUTOFMEMORY;
}
memset(pBuffer, 0, cbBufSize);
pStm->Read(pBuffer, cbBufSize, NULL);
m_spRoot.Release();
ParseExpat(pBuffer, cbBufSize, (IXMLDocument *) this, &m_spRoot);
delete []pBuffer;
m_nReadyState = READYSTATE_LOADED;
return S_OK;
}
STDMETHODIMP CTimeAxis::Load(LPSTREAM pStm)
{
double dTimeSpan;
pStm->Read(&dTimeSpan, sizeof(double), NULL);
m_dMinVal = m_dMaxVal - dTimeSpan;
return CAxis::Load(pStm);
}
STDMETHODIMP CGrid::Load(LPSTREAM pStm)
{
pStm->Read(&m_bShowVertical, sizeof(m_bShowVertical), NULL);
pStm->Read(&m_bShowHorizontal, sizeof(m_bShowHorizontal), NULL);
pStm->Read(&m_lNumberOfVerticalLines, sizeof(m_lNumberOfVerticalLines), NULL);
pStm->Read(&m_lNumberOfHorizontalLines, sizeof(m_lNumberOfHorizontalLines), NULL);
pStm->Read(&m_enumVerticalStyle, sizeof(m_enumVerticalStyle), NULL);
pStm->Read(&m_enumHorizontalStyle, sizeof(m_enumHorizontalStyle), NULL);
pStm->Read(&m_nWidth, sizeof(m_nWidth), NULL);
pStm->Read(&m_clrVerticalColor, sizeof(m_clrVerticalColor), NULL);
pStm->Read(&m_clrHorizontalColor, sizeof(m_clrHorizontalColor), NULL);
return S_OK;
}
LPFONT AFXAPI _AfxCreateFontFromStream(LPSTREAM pstm)
{
BOOL bSuccess = FALSE;
LPFONT pFont = NULL;
LPPERSISTSTREAM pPersStm = NULL;
CLSID clsid;
if (SUCCEEDED(pstm->Read(&clsid, sizeof(CLSID), NULL)))
{
HRESULT hr;
if (IsEqualCLSID(clsid, CLSID_StdFont) ||
IsEqualCLSID(clsid, _afx_CLSID_StdFont_V1))
{
// We know this kind of font; create it using the API.
hr = ::OleCreateFontIndirect((LPFONTDESC)&_afxFontDescHelv, IID_IFont,
(LPVOID*)&pFont);
}
else
{
// Some other implementation of IFont.
hr = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, IID_IFont,
(LPVOID*)&pFont);
}
if (SUCCEEDED(hr))
{
// Successfully created font, now get its IPersistStream interface.
ASSERT_POINTER(pFont, IFont);
if (SUCCEEDED(pFont->QueryInterface(IID_IPersistStream,
(LPVOID*)&pPersStm)))
{
ASSERT_POINTER(pPersStm, IPersistStream);
}
}
if (pPersStm != NULL)
{
// Load the font.
ASSERT_POINTER(pFont, IFont);
bSuccess = SUCCEEDED(pPersStm->Load(pstm));
pPersStm->Release();
}
}
// If we failed for any reason, clean up the font.
if (!bSuccess && pFont != NULL)
{
pFont->Release();
pFont = NULL;
}
return pFont;
}
HRESULT CGifSmileyCtrl::IPersistStreamInit_Load(LPSTREAM pStm,const ATL_PROPMAP_ENTRY* pMap)
{
HRESULT hr = S_OK;
INFO_GIF infoGif;
hr = pStm->Read(&infoGif, sizeof(INFO_GIF), NULL);
hr = IPersistStreamInitImpl<CGifSmileyCtrl>::IPersistStreamInit_Load( pStm, pMap);
CopySmile(infoGif.hwndFrom, infoGif.filePath, infoGif.clrBackground, 0);
return hr;
}
HRESULT CDrawMenu::DoLoad(DWORD dwVer, LPSTREAM pStm)
{
if (dwVer > _SUPERCX_VER_0200)
{
pStm->Read(&m_bButtonDisplayed, sizeof(m_bButtonDisplayed), NULL);
m_bstrButtonCaption.ReadFromStream(pStm);
}
else
{
m_bButtonDisplayed = FALSE;
}
int nCount;
pStm->Read(&nCount, sizeof(nCount), NULL);
for (int i = 0; i < nCount; i++)
{
CMenuItem item;
item.m_bstrText.ReadFromStream(pStm);
pStm->Read(&item.m_dwState, sizeof(DWORD), NULL);
if (dwVer > _SUPERCX_VER_0203)
{
item.m_bstrID.ReadFromStream(pStm);
pStm->Read(&item.m_dwShiftState, sizeof(DWORD), NULL);
pStm->Read(&item.m_dwKeyCode, sizeof(DWORD), NULL);
}
m_arrItems.Add(item);
}
pStm->Read(&m_rcPosition, sizeof(m_rcPosition), NULL);
m_bstrDescription.ReadFromStream(pStm);
return CCxDrawObjectBase::DoLoad(dwVer, pStm);
}
STDMETHODIMP CDrawTxt::LoadOldVer(LPSTREAM pStm)
{
// pStm->Read(&m_bAutoSize, sizeof(BOOL), NULL);
pStm->Read(&m_dFontHeight, sizeof(double), NULL);
pStm->Read(&m_dFontWidth, sizeof(double), NULL);
pStm->Read(&m_lWeight, sizeof(long), NULL);
pStm->Read(&m_bItalic, sizeof(BOOL), NULL);
pStm->Read(&m_bUnderLine, sizeof(BOOL), NULL);
pStm->Read(&m_bStrikethrough, sizeof(BOOL), NULL);
m_bstrFontName.ReadFromStream(pStm);
m_bstrCaption.ReadFromStream(pStm);
pStm->Read(&m_clrForeColor, sizeof(OLE_COLOR), NULL);
pStm->Read(&m_clrBackColor, sizeof(OLE_COLOR), NULL);
pStm->Read(&m_nTextAlign, sizeof(UINT), NULL);
pStm->Read(&m_bsBackStyle, sizeof(enumBackStyle), NULL);
pStm->Read(&m_rcPosition, sizeof(RECTF), NULL);
return ICxDrawObjectImpl<CDrawTxt>::LoadOldVer(pStm);
}
void ReadStorage(LPSTORAGE pStg)
// reads one storage -- recursive calls for substorages
{
USES_CONVERSION;
LPSTORAGE pSubStg = NULL;
LPSTREAM pStream = NULL;
LPENUMSTATSTG pEnum = NULL;
LPMALLOC pMalloc = NULL; // for freeing statstg
STATSTG statstg;
ULONG nLength;
BYTE buffer[101];
g_nIndent++;
::CoGetMalloc(MEMCTX_TASK, &pMalloc); // assumes AfxOleInit
// was called
VERIFY(pStg->EnumElements(0, NULL, 0, &pEnum) == S_OK);
while (pEnum->Next(1, &statstg, NULL) == S_OK) {
if (statstg.type == STGTY_STORAGE) {
VERIFY(pStg->OpenStorage(statstg.pwcsName, NULL,
STGM_READ | STGM_SHARE_EXCLUSIVE,
NULL, 0, &pSubStg) == S_OK);
ASSERT(pSubStg != NULL);
TRACE("%0.*sStorage = %s\n", (g_nIndent - 1) * 4,
g_szBlanks, OLE2CT(statstg.pwcsName));
ReadStorage(pSubStg);
pSubStg->Release();
}
else if (statstg.type == STGTY_STREAM) {
VERIFY(pStg->OpenStream(statstg.pwcsName, NULL,
STGM_READ | STGM_SHARE_EXCLUSIVE,
0, &pStream) == S_OK);
ASSERT(pStream != NULL);
TRACE("%0.*sStream = %s\n", (g_nIndent - 1) * 4,
g_szBlanks, OLE2CT(statstg.pwcsName));
pStream->Read(buffer, 100, &nLength);
buffer[nLength] = '\0';
TRACE("%s\n", buffer);
pStream->Release();
}
else {
ASSERT(FALSE); // LockBytes?
}
pMalloc->Free(statstg.pwcsName); // avoids memory leaks
}
pMalloc->Release();
pEnum->Release();
g_nIndent--;
}
// --------------------------------------------------------------------------------------------
STDMETHODIMP CRegOperatPropAct::Load (LPSTREAM pStm)
{
if (m_bIsInitialized) // m_bIsInitialized == true, wenn Page schon durch InitNew()
return E_UNEXPECTED; // initialisiert wurde
// Daten einlesen
// zuerst Bezeichner einlesen
HRESULT hr = CPropertyAction::Load (pStm);
if (FAILED(hr)) return hr;
// meine Versionsnummer und Signatur lesen und überprüfen
DWORD dwSignature = 0;
DWORD dwVersion = 0;
RETURN_FAILED_HRESULT(pStm->Read (&dwSignature, sizeof(DWORD), NULL));
if (REGOPERATPROPACT_SIGNATURE != dwSignature)
return E_UNEXPECTED;
RETURN_FAILED_HRESULT(pStm->Read (&dwVersion, sizeof(DWORD), NULL));
if ((dwVersion & ~ MINOR_VERSION_MASK) > REGOPERATPROPACT_ACTVERSION)
return STG_E_OLDDLL; // File was written with a newer version
// dann selektierte Info der letzten Auswahl
RETURN_FAILED_HRESULT (pStm->Read (&m_caSelInfo.bClassKey, sizeof(BOOL), NULL));
RETURN_FAILED_HRESULT (pStm->Read (&m_caSelInfo.bInter, sizeof(BOOL), NULL));
RETURN_FAILED_HRESULT (pStm->Read (&m_caSelInfo.bExter, sizeof(BOOL), NULL));
RETURN_FAILED_HRESULT (pStm->Read (&m_caSelInfo.bBound, sizeof(BOOL), NULL));
// ggf. Moniker einlesen
BOOL fHasMoniker = TRUE;
if (dwVersion >= REGOPERATPROPACT_VERSION_1_0_2) {
RETURN_FAILED_HRESULT (pStm->Read (&fHasMoniker, sizeof(BOOL), NULL));
}
if (fHasMoniker) {
RETURN_FAILED_HRESULT (OleLoadFromStream(pStm, IID_IMoniker, m_mkOperOptions.ppv()));
}
if (NULL == m_pRegOperDlg)
// Initialisierungsdaten für den Dialog wurden zwar soeben von Load() bereitgestellt,
// können hier aber noch nicht an diesen weitergereicht werden
m_bHasInitData = true;
else
// Initialisierungsdaten an den Dialog weiterreichen
m_pRegOperDlg->SetSelectedInfo (&m_caSelInfo);
m_bIsInitialized = true; // Page wurde jetzt durch Load() initialisiert
m_bIsDirty = false; // Dialogparameter wurden (noch) nicht verändert
return S_OK;
} // Load
STDMETHODIMP CPoint::IMyPersistStreamImpl_Load(LPSTREAM pIStream)
{
ULONG cb;
HRESULT hr;
if (NULL==pIStream)
return ResultFromScode(E_POINTER);
//
// Read an object from the stream.
//
hr=pIStream->Read(&m_Point, sizeof(POINT), &cb);
if (FAILED(hr))
return hr;
if (sizeof(POINT) != cb)
return E_FAIL;
return NOERROR;
}
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;
}
BOOL CMapiApi::GetLargeStringProperty( LPMAPIPROP pProp, ULONG tag, nsCString& val)
{
LPSTREAM lpStream;
HRESULT hr = pProp->OpenProperty( tag, &IID_IStream, 0, 0, (LPUNKNOWN *)&lpStream);
if (HR_FAILED( hr))
return( FALSE);
STATSTG st;
BOOL bResult = TRUE;
hr = lpStream->Stat( &st, STATFLAG_NONAME);
if (HR_FAILED( hr))
bResult = FALSE;
else {
if (!st.cbSize.QuadPart)
st.cbSize.QuadPart = 1;
char *pVal = new char[ (int) st.cbSize.QuadPart + 1];
// val.SetCapacity( (int) st.cbSize.QuadPart);
if (pVal) {
ULONG sz;
hr = lpStream->Read( pVal, (ULONG) st.cbSize.QuadPart, &sz);
if (HR_FAILED( hr)) {
bResult = FALSE;
*pVal = 0;
sz = 0;
}
else
pVal[(int) st.cbSize.QuadPart] = 0;
val = pVal;
delete [] pVal;
}
else
bResult = FALSE;
}
lpStream->Release();
return( bResult);
}
BOOL AFXAPI _AfxSaveStreamDataAsBlobProp(LPSTREAM pstm, CPropertySection& psec,
DWORD dwPropID, DWORD dwType)
{
BOOL bSuccess = FALSE;
ULARGE_INTEGER uliStart;
ULARGE_INTEGER uliEnd;
// Note: Stream length must fit in a DWORD.
if (SUCCEEDED(pstm->Seek(_afxLargeZero, STREAM_SEEK_CUR, &uliStart)) &&
SUCCEEDED(pstm->Seek(_afxLargeZero, STREAM_SEEK_END, &uliEnd)) &&
SUCCEEDED(pstm->Seek(*(LARGE_INTEGER*)&uliStart, STREAM_SEEK_SET,
NULL)))
{
DWORD cb = uliEnd.LowPart - uliStart.LowPart;
HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE|GMEM_SHARE,
cb + (DWORD)sizeof(cb));
if (hGlobal != NULL)
{
LPBYTE pbData = (LPBYTE)GlobalLock(hGlobal);
if (pbData != NULL)
{
*(DWORD*)pbData = cb;
if (SUCCEEDED(pstm->Read(pbData + (DWORD)sizeof(DWORD), cb,
NULL)))
{
bSuccess = psec.Set(dwPropID, pbData, dwType);
}
GlobalUnlock(hGlobal);
}
GlobalFree(hGlobal);
}
}
return bSuccess;
}
FARINTERNAL UtGetHMFPICTFromMSDrawNativeStm
(LPSTREAM pstm, DWORD dwSize, HANDLE FAR* lphdata)
{
HRESULT error;
WORD mfp[3]; // mm, xExt, yExt
HMETAFILE hMF = NULL;
*lphdata = NULL;
if (error = pstm->Read(mfp, sizeof(mfp), NULL))
return error;
dwSize -= sizeof(mfp);
if (error = UtGetHMFFromMFStm(pstm, dwSize, FALSE, (void **)&hMF))
return error;
AssertSz(mfp[0] == MM_ANISOTROPIC, "invalid map mode in MsDraw native data");
if (*lphdata = UtGetHMFPICT(hMF, TRUE, (int) mfp[1], (int) mfp[2]))
return NOERROR;
return ResultFromScode(E_OUTOFMEMORY);
}
STDMETHODIMP CDirectDynamic::Load(LPSTREAM pStm)
{
m_bstrSource.ReadFromStream(pStm);
pStm->Read(&m_bEnableMouseInput, sizeof(m_bEnableMouseInput), NULL);
return S_OK;
}
HRESULT CDrawTxt::DoLoad(DWORD dwVer, LPSTREAM pStm)
{
pStm->Read(&m_enumMousePointer, sizeof(m_enumMousePointer), NULL);
m_bstrDescription.ReadFromStream(pStm);
pStm->Read(&m_dFontHeight, sizeof(double), NULL);
pStm->Read(&m_dFontWidth, sizeof(double), NULL);
pStm->Read(&m_lWeight, sizeof(long), NULL);
pStm->Read(&m_bItalic, sizeof(BOOL), NULL);
pStm->Read(&m_bUnderLine, sizeof(BOOL), NULL);
pStm->Read(&m_bStrikethrough, sizeof(BOOL), NULL);
m_bstrFontName.ReadFromStream(pStm);
m_bstrCaption.ReadFromStream(pStm);
pStm->Read(&m_clrForeColor, sizeof(OLE_COLOR), NULL);
pStm->Read(&m_clrBackColor, sizeof(OLE_COLOR), NULL);
pStm->Read(&m_nTextAlign, sizeof(UINT), NULL);
pStm->Read(&m_bsBackStyle, sizeof(enumBackStyle), NULL);
pStm->Read(&m_rcPosition, sizeof(RECTF), NULL);
if (dwVer > _SUPERCX_VER_0207)
{
pStm->Read(&m_bAutoSize, sizeof(BOOL), NULL);
pStm->Read(&m_bWordWrap, sizeof(BOOL), NULL);
}
return CCxDrawObjectBase::DoLoad(dwVer, pStm);
}
HRESULT STDMETHODCALLTYPE TinySmiley::LoadStream(LPSTREAM pStm)
{
if (!pStm) return S_FALSE;
STATSTG pstatstg;
if (FAILED(pStm->Stat(&pstatstg, 0)))
{
return S_FALSE;
}
INT comp = 0;
BYTE* pData = NULL;
//获得字节流大小
BYTE* pv = new BYTE[(UINT)pstatstg.cbSize.QuadPart];
if (!pv) return S_FALSE;
ULONG bytesSaved = 0;
if (FAILED(pStm->Read(pv, (LONG)pstatstg.cbSize.QuadPart, &bytesSaved)))
{
goto error;
}
pData = stbi_load_from_memory_ex(pv, (INT)pstatstg.cbSize.QuadPart, &m_cx, &m_cy, &comp, 4, &m_count);
SAFE_DELETE_ARRAY(pv);
if (!pData)
{
goto error;
}
if (m_count == 1)
{
BITMAPINFO bmi;
memset(&bmi, 0, sizeof(BITMAPINFO));
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biWidth = m_cx;
bmi.bmiHeader.biHeight = -m_cy;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 32;
bmi.bmiHeader.biCompression = BI_RGB;
bmi.bmiHeader.biSizeImage = m_cx * m_cy * 4;
BYTE* pvBits = NULL;
HBITMAP hBitmap = ::CreateDIBSection(NULL, &bmi, DIB_RGB_COLORS, (void**)&pvBits, NULL, 0);
if (hBitmap)
{
for (INT i = 0; i < m_cx * m_cy; i++)
{
pvBits[i * 4 + 3] = pData[i * 4 + 3];
if (pvBits[i * 4 + 3] < 255)
{
pvBits[i * 4] = (BYTE)(DWORD(pData[i * 4 + 2])*pData[i * 4 + 3] / 255);//B
pvBits[i * 4 + 1] = (BYTE)(DWORD(pData[i * 4 + 1])*pData[i * 4 + 3] / 255);//G
pvBits[i * 4 + 2] = (BYTE)(DWORD(pData[i * 4])*pData[i * 4 + 3] / 255);//R
}
else
{
pvBits[i * 4] = pData[i * 4 + 2];
pvBits[i * 4 + 1] = pData[i * 4 + 1];
pvBits[i * 4 + 2] = pData[i * 4];
}
}
m_images.push_back(hBitmap);
}
}
else
{
BYTE* seek = pData + m_count * 4 * m_cx * m_cy;
for (size_t i = 0; i < m_count; i++)
{
BITMAPINFO bmi;
memset(&bmi, 0, sizeof(BITMAPINFO));
bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
bmi.bmiHeader.biWidth = m_cx;
bmi.bmiHeader.biHeight = -m_cy;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = 32;
bmi.bmiHeader.biCompression = BI_RGB;
bmi.bmiHeader.biSizeImage = m_cx * m_cy * 4;
BYTE* pvBits = NULL;
HBITMAP hBitmap = ::CreateDIBSection(NULL, &bmi, DIB_RGB_COLORS, (void**)&pvBits, NULL, 0);
if (hBitmap)
{
BYTE* ps = pData + i * m_cx * m_cy;
for (INT i = 0; i < m_cx * m_cy; i++)
{
pvBits[i * 4 + 3] = ps[i * 4 + 3];
if (pvBits[i * 4 + 3] < 255)
{
pvBits[i * 4] = (BYTE)(DWORD(ps[i * 4 + 2])*ps[i * 4 + 3] / 255);//B
pvBits[i * 4 + 1] = (BYTE)(DWORD(ps[i * 4 + 1])*ps[i * 4 + 3] / 255);//G
pvBits[i * 4 + 2] = (BYTE)(DWORD(ps[i * 4])*ps[i * 4 + 3] / 255);//R
}
else
{
pvBits[i * 4] = ps[i * 4 + 2];
pvBits[i * 4 + 1] = ps[i * 4 + 1];
pvBits[i * 4 + 2] = ps[i * 4];
}
}
m_images.push_back(hBitmap);
m_delays.push_back(*(UINT*)seek);
seek += sizeof(UINT);
}
}
}
stbi_image_free(pData);
return m_images.size() == m_count ? S_OK : S_FALSE;
error:
SAFE_DELETE_ARRAY(pv);
stbi_image_free(pData);
return S_FALSE;
}
/* This seems to be called if one clicks on Save in the context menu.
And also sometimes before an Open click. */
STDMETHODIMP
GpgolAttachedFileEvents::OnWritePattToSzFile
(LPATTACH att, LPTSTR file, ULONG flags)
{
HRESULT hr;
ULONG tag;
char *iv;
size_t ivlen;
symenc_t symenc;
LPSTREAM stream;
char tmpbuf[16];
ULONG nread;
int rc;
log_debug ("%s:%s: att=%p file=`%s' flags=%lx\n",
SRCNAME, __func__, att, file, flags);
if (!att)
return E_FAIL;
if (get_gpgolprotectiv_tag ((LPMESSAGE)att, &tag) )
return E_ABORT;
iv = mapi_get_binary_prop ((LPMESSAGE)att, tag, &ivlen);
if (!iv)
return S_FALSE; /* Not encrypted by us - Let OL continue as usual. */
symenc = symenc_open (get_128bit_session_key (), 16, iv, ivlen);
xfree (iv);
if (!symenc)
{
log_error ("%s:%s: can't open encryption context", SRCNAME, __func__);
return E_ABORT;
}
hr = att->OpenProperty (PR_ATTACH_DATA_BIN, &IID_IStream,
0, 0, (LPUNKNOWN*) &stream);
if (FAILED (hr))
{
log_error ("%s:%s: can't open data stream of attachment: hr=%#lx",
SRCNAME, __func__, hr);
symenc_close (symenc);
return E_ABORT;
}
hr = stream->Read (tmpbuf, 16, &nread);
if (hr)
{
log_debug ("%s:%s: Read failed: hr=%#lx", SRCNAME, __func__, hr);
stream->Release ();
symenc_close (symenc);
return E_ABORT;
}
symenc_cfb_decrypt (symenc, tmpbuf, tmpbuf, 16);
if (memcmp (tmpbuf, "GpgOL attachment", 16))
{
MessageBox (NULL,
_("Sorry, we are not able to decrypt this attachment.\n\n"
"Please use the decrypt/verify button to decrypt the\n"
"entire message again. Then open this attachment."),
"GpgOL", MB_ICONERROR|MB_OK);
stream->Release ();
symenc_close (symenc);
return E_ABORT;
}
rc = decrypt_and_write_file (stream, file, symenc);
stream->Release ();
symenc_close (symenc);
return rc;
}
int _tmain(int argc, wchar_t* argv[])
{
GdiplusStartupInput gdiplusStartupInput;
ULONG_PTR gdiplusToken;
GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
if (argc != 4) {
wprintf(L"Usage: %s outfile.jpg(or - for stdout) WxH JPEG_quality(0-100)\n", argv[0]);
return 1;
}
int outWidth = 0, outHeight = 0;
swscanf(argv[2], L"%dx%d", &outWidth, &outHeight);
ULONG jpegQuality = 0;
swscanf(argv[3], L"%d", &jpegQuality);
BOOL useStdout = wcscmp(L"-", argv[1]) == 0;
HWND desktop = GetDesktopWindow();
HDC desktopdc = GetDC(desktop);
HDC mydc = CreateCompatibleDC(desktopdc);
int width = GetSystemMetrics(SM_CXSCREEN);
int height = GetSystemMetrics(SM_CYSCREEN);
if (!outWidth || !outHeight) {
outWidth = width;
outHeight = height;
}
HBITMAP mybmp = CreateCompatibleBitmap(desktopdc, outWidth, outHeight);
HBITMAP oldbmp = (HBITMAP)SelectObject(mydc, mybmp);
//BitBlt(mydc,0,0,width,height,desktopdc,0,0, SRCCOPY|CAPTUREBLT);
StretchBlt(mydc, 0, 0, outWidth, outHeight, desktopdc, 0, 0, width, height, SRCCOPY|CAPTUREBLT);
SelectObject(mydc, oldbmp);
const wchar_t* filename = argv[1];
EncoderParameters encoderParameters;
encoderParameters.Count = 1;
encoderParameters.Parameter[0].Guid = EncoderQuality;
encoderParameters.Parameter[0].Type = EncoderParameterValueTypeLong;
encoderParameters.Parameter[0].NumberOfValues = 1;
encoderParameters.Parameter[0].Value = &jpegQuality;
LPSTREAM lpStream = NULL;
CreateStreamOnHGlobal(NULL, TRUE, &lpStream);
Bitmap* b = Bitmap::FromHBITMAP(mybmp, NULL);
CLSID encoderClsid;
Status stat = GenericError;
if (b && GetEncoderClsid(L"image/jpeg", &encoderClsid) != -1) {
if (useStdout)
stat = b->Save(lpStream, &encoderClsid, &encoderParameters);
else
stat = b->Save(filename, &encoderClsid, &encoderParameters);
}
if (useStdout) {
ULARGE_INTEGER pos, newpos;
LARGE_INTEGER seek;
ULONG read;
seek.QuadPart = 0L;
lpStream->Seek(seek, STREAM_SEEK_CUR, &pos);
lpStream->Seek(seek, STREAM_SEEK_SET, &newpos);
void *buf = malloc(pos.QuadPart);
lpStream->Read(buf, pos.QuadPart, &read);
_setmode(_fileno(stdout), _O_BINARY);
fwrite(buf, 1, pos.QuadPart, stdout);
}
if (b)
delete b;
// cleanup
GdiplusShutdown(gdiplusToken);
ReleaseDC(desktop, desktopdc);
DeleteObject(mybmp);
DeleteDC(mydc);
return !(stat == Ok);
}
/* Copy STREAM to a new file FILENAME while decrypting it using the
context SYMENC. */
static int
decrypt_and_write_file (LPSTREAM stream, const char *filename, symenc_t symenc)
{
int rc = E_ABORT;
HRESULT hr;
ULONG nread;
char *buf = NULL;
FILE *fpout = NULL;
fpout = fopen (filename, "wb");
if (!fpout)
{
log_error ("%s:%s: fwrite failed: %s", SRCNAME, __func__,
strerror (errno));
MessageBox (NULL,
_("Error creating file for attachment."),
"GpgOL", MB_ICONERROR|MB_OK);
goto leave;
}
buf = (char*)xmalloc (COPYBUFFERSIZE);
do
{
hr = stream->Read (buf, COPYBUFFERSIZE, &nread);
if (hr)
{
log_error ("%s:%s: Read failed: hr=%#lx", SRCNAME, __func__, hr);
MessageBox (NULL,
_("Error reading attachment."),
"GpgOL", MB_ICONERROR|MB_OK);
goto leave;
}
if (nread)
symenc_cfb_decrypt (symenc, buf, buf, nread);
if (nread && fwrite (buf, nread, 1, fpout) != 1)
{
log_error ("%s:%s: fwrite failed: %s", SRCNAME, __func__,
strerror (errno));
MessageBox (NULL,
_("Error writing attachment."),
"GpgOL", MB_ICONERROR|MB_OK);
goto leave;
}
}
while (nread == COPYBUFFERSIZE);
xfree (buf);
buf = NULL;
if (fclose (fpout))
{
log_error ("%s:%s: fclose failed: %s",
SRCNAME, __func__, strerror (errno));
MessageBox (NULL,
_("Error writing attachment."),
"GpgOL", MB_ICONERROR|MB_OK);
goto leave;
}
rc = S_OK;
leave:
xfree (buf);
if (fpout)
fclose (fpout);
if (rc != S_OK)
remove (filename);
return rc;
}
FARINTERNAL Ut10NativeStmToContentsStm
(LPSTORAGE pstg, REFCLSID rclsid, BOOL fDeleteSrcStm)
{
CLIPFORMAT cfOld;
CLIPFORMAT cfNew;
LPOLESTR lpszUserType = NULL;
HRESULT error;
LPSTREAM pstmSrc = NULL;
LPSTREAM pstmDst = NULL;
if (error = ReadFmtUserTypeStg(pstg, &cfOld, &lpszUserType))
return error;
if (rclsid == CLSID_StaticDib)
cfNew = CF_DIB;
else if (rclsid == CLSID_StaticMetafile)
cfNew = CF_METAFILEPICT;
else {
AssertSz(FALSE, "Internal Error: this routine shouldn't have been called for this class");
return ResultFromScode(E_FAIL);
}
if (cfOld == g_cfPBrush) {
if (cfNew != CF_DIB) {
error = ResultFromScode(DV_E_CLIPFORMAT);
goto errRtn;
}
} else if (cfOld == g_cfMSDraw) {
if (cfNew != CF_METAFILEPICT) {
error = ResultFromScode(DV_E_CLIPFORMAT);
goto errRtn;
}
} else {
// Converted to static object from some class other than PBrush or
// MSDraw. The data must be in a proper format in the CONTENTS
// stream.
return NOERROR;
}
if (error = pstg->OpenStream(OLE10_NATIVE_STREAM, NULL,
(STGM_READ|STGM_SHARE_EXCLUSIVE),
0, &pstmSrc))
goto errRtn;
if (error = OpenOrCreateStream(pstg, OLE_CONTENTS_STREAM, &pstmDst))
goto errRtn;
DWORD dwSize;
if (error = pstmSrc->Read(&dwSize, sizeof(DWORD), NULL))
goto errRtn;
if (cfOld == g_cfMSDraw) {
WORD mfp[3]; // mm, xExt, yExt
if (error = pstmSrc->Read(mfp, sizeof(mfp), NULL))
goto errRtn;
dwSize -= sizeof(mfp);
error = UtMFStmToPlaceableMFStm(pstmSrc, dwSize,
(LONG) mfp[1], (LONG) mfp[2], pstmDst);
} else {
// The PBrush native data format is DIB File format. So all we got to
// do is CopyTo.
ULARGE_INTEGER ularge_int;
ULISet32(ularge_int, dwSize);
if ((error = pstmSrc->CopyTo(pstmDst, ularge_int, NULL,
NULL)) == NOERROR)
StSetSize(pstmDst, 0, TRUE);
}
errRtn:
if (pstmDst)
pstmDst->Release();
if (pstmSrc)
pstmSrc->Release();
if (error == NOERROR) {
error = WriteFmtUserTypeStg(pstg, cfNew, lpszUserType);
if (fDeleteSrcStm)
pstg->DestroyElement(OLE10_NATIVE_STREAM);
} else {
pstg->DestroyElement(OLE_CONTENTS_STREAM);
}
if (lpszUserType)
PubMemFree(lpszUserType);
return error;
}
HRESULT CDrawEllipse::DoLoad(DWORD dwVer, LPSTREAM pStm)
{
pStm->Read(&m_enumFillStyle, sizeof(m_enumFillStyle), NULL);
pStm->Read(&m_enumHorFillDirection, sizeof(m_enumHorFillDirection), NULL);
pStm->Read(&m_enumVerFillDirection, sizeof(m_enumVerFillDirection), NULL);
pStm->Read(&m_nHorFillPercent, sizeof(m_nHorFillPercent), NULL);
pStm->Read(&m_nVerFillPercent, sizeof(m_nVerFillPercent), NULL);
m_BrushImageFileName.ReadFromStream(pStm);
pStm->Read(&m_clrFillColor, sizeof(m_clrFillColor), NULL);
pStm->Read(&m_clrHighLightFill, sizeof(m_clrHighLightFill), NULL);
pStm->Read(&m_enumEdgeStyle, sizeof(m_enumEdgeStyle), NULL);
pStm->Read(&m_fEdgeWidth, sizeof(m_fEdgeWidth), NULL);
pStm->Read(&m_enumLineJoinStyle, sizeof(m_enumLineJoinStyle), NULL);
pStm->Read(&m_clrEdgeColor, sizeof(m_clrEdgeColor), NULL);
pStm->Read(&m_clrHighLightEdge, sizeof(m_clrHighLightEdge), NULL);
pStm->Read(&m_ptRotateBase, sizeof(m_ptRotateBase), NULL);
pStm->Read(&m_enumScaleBase, sizeof(m_enumScaleBase), NULL);
pStm->Read(&m_enumMousePointer, sizeof(m_enumMousePointer), NULL);
m_bstrDescription.ReadFromStream(pStm);
return CCxDrawObjectBase::DoLoad(dwVer, pStm);
}
