1372 lines
45 KiB
C++
1372 lines
45 KiB
C++
/*************************************************************************
|
|
**
|
|
** OLE 2.0 Property Set Utilities
|
|
**
|
|
** suminfo.cpp
|
|
**
|
|
** This file contains functions that are useful for the manipulation
|
|
** of OLE 2.0 Property Sets particularly to manage the Summary Info
|
|
** property set.
|
|
**
|
|
** (c) Copyright Microsoft Corp. 1990 - 1992 All Rights Reserved
|
|
**
|
|
*************************************************************************/
|
|
|
|
// Note: this file is designed to be stand-alone; it includes a
|
|
// carefully chosen, minimal set of headers.
|
|
//
|
|
// For conditional compilation we use the ole2 conventions,
|
|
// _MAC = mac
|
|
// WIN32 = Win32 (NT really)
|
|
// <nothing> = defaults to Win16
|
|
|
|
// REVIEW: the following needs to modified to handle _MAC
|
|
#define STRICT
|
|
#ifndef INC_OLE2
|
|
#define INC_OLE2
|
|
#endif
|
|
|
|
#include <windows.h>
|
|
#include <string.h>
|
|
#include <ole2.h>
|
|
#include "ole2ui.h"
|
|
|
|
OLEDBGDATA
|
|
|
|
/* A LPSUMINFO variable is a pointer to an instance of an abstract data
|
|
** type. There can be an arbitrary number of SummaryInfo streams open
|
|
** simultaneously (subject to available memory); each must have its
|
|
** own LPSUMINFO instance. Each LPSUMINFO instance must
|
|
** be initialized prior to use by calling Init and freed after its
|
|
** last use by calling Free. The param argument to Init is reserved
|
|
** for future expansion and should be zero initially. Once a LPSUMINFO
|
|
** instance is allocated (by Init), the user can call the Set
|
|
** procedures to initialize fields. A copy of the arguments is made
|
|
** in every case except SetThumbnail where control of the storage
|
|
** occupied by the METAFILEPICT is merely transferred. When the
|
|
** Free routine is called, all storage will be deallocated including
|
|
** that of the thumbnail. The arguments to SetThumbNail and the
|
|
** return values from GetThumbNail correspond to the OLE2.0 spec.
|
|
** Note that on input, the thumbnail is read on demand but all the
|
|
** other properties are pre-loaded. The thumbnail is manipulated as
|
|
** a windows handle to a METAFILEPICT structure, which in turn
|
|
** contains a handle to the METAFILE. The transferClip argument on
|
|
** GetThumbNail, when set to true, transfers responsibility for
|
|
** storage management of the thumbnail to the caller; that is, after
|
|
** Free has been called, the handle is still valid. Clear can be
|
|
** used to free storage for all the properties but then you must
|
|
** call Read to load them again. All the code is based on FAR
|
|
** pointers.
|
|
** CoInitialize MUST be called PRIOR to calling OleStdInitSummaryInfo.
|
|
** Memory is allocated using the currently active IMalloc*
|
|
** allocator (as is returned by call CoGetMalloc(MEMCTX_TASK) ).
|
|
**
|
|
** Common scenarios:
|
|
** Read SummaryInfo
|
|
** ----------------
|
|
** OleStdInitSummaryInfo()
|
|
** OleStdReadSummaryInfo()
|
|
** . . . . .
|
|
** call different Get routines
|
|
** . . . . .
|
|
** OleStdFreeSummaryInfo()
|
|
**
|
|
** Create SummaryInfo
|
|
** ------------------
|
|
** OleStdInitSummaryInfo()
|
|
** call different Set routines
|
|
** OleStdWriteSummaryInfo()
|
|
** OleStdFreeSummaryInfo()
|
|
**
|
|
** Update SummaryInfo
|
|
** ------------------
|
|
** OleStdInitSummaryInfo()
|
|
** OleStdReadSummaryInfo()
|
|
** OleStdGetThumbNailProperty(necessary only if no SetThumb)
|
|
** call different Set routines
|
|
** OleStdWriteSummaryInfo()
|
|
** OleStdFreeSummaryInfo()
|
|
*/
|
|
|
|
#ifdef WIN32
|
|
#define CHAR TCHAR
|
|
#else
|
|
#define CHAR unsigned char
|
|
#endif
|
|
#define fTrue 1
|
|
#define fFalse 0
|
|
#define BYTE unsigned char
|
|
#define WORD unsigned short
|
|
#define DWORD unsigned long
|
|
#define LPVOID void FAR *
|
|
#define uchar unsigned char
|
|
#define ulong unsigned long
|
|
#define BOOL unsigned char
|
|
#define BF unsigned int
|
|
|
|
#include "suminfo.h"
|
|
#include "wn_dos.h"
|
|
|
|
#if defined( _DEBUG )
|
|
#ifndef NOASSERT
|
|
// following is from compobj.dll (ole2)
|
|
#ifdef UNICODE
|
|
#define ASSERT(x) (!(x) ? FnAssert(TEXT(#x), NULL, \
|
|
TEXT(__FILE__), __LINE__) : 0)
|
|
#else
|
|
#define ASSERT(x) (!(x) ? \
|
|
{ \
|
|
WCHAR wsz[255]; \
|
|
wcscpy(wsz, (#x)); \
|
|
FnAssert(wsz, NULL, TEXT(__FILE__), __LINE__) \
|
|
} \
|
|
: 0)
|
|
#endif
|
|
#else
|
|
#define ASSERT(x)
|
|
#endif
|
|
#else
|
|
#define ASSERT(x)
|
|
#endif
|
|
|
|
|
|
typedef struct _RSUMINFO
|
|
{
|
|
WORD byteOrder;
|
|
WORD formatVersion;
|
|
WORD getOSVersion;
|
|
WORD osVersion;
|
|
CLSID classId; //from compobj.h
|
|
DWORD cSections;
|
|
PROPSETLIST rgPropSet[1/*cSections*/]; //one section in standard summary info
|
|
STANDARDSECINMEM section;
|
|
ULONG fileOffset; //offset for thumbnail to support demand read
|
|
} RSUMINFO;
|
|
|
|
typedef RSUMINFO FAR * LPRSI;
|
|
|
|
typedef union _foo{
|
|
ULARGE_INTEGER uli;
|
|
struct {
|
|
DWORD dw;
|
|
DWORD dwh;
|
|
};
|
|
struct {
|
|
WORD w0;
|
|
WORD w1;
|
|
WORD w2;
|
|
WORD w3;
|
|
};
|
|
} Foo;
|
|
|
|
|
|
|
|
/* MemAlloc
|
|
** ---------
|
|
** allocate memory using the currently active IMalloc* allocator
|
|
*/
|
|
static LPVOID MemAlloc(ULONG ulSize)
|
|
{
|
|
LPVOID pout;
|
|
LPMALLOC pmalloc;
|
|
|
|
if (CoGetMalloc(MEMCTX_TASK, &pmalloc) != NOERROR) {
|
|
OleDbgAssert(pmalloc);
|
|
return NULL;
|
|
}
|
|
|
|
pout = (LPVOID)pmalloc->Alloc(ulSize);
|
|
|
|
if (pmalloc != NULL) {
|
|
ULONG refs = pmalloc->Release();
|
|
}
|
|
|
|
return pout;
|
|
}
|
|
|
|
|
|
/* MemFree
|
|
** -------
|
|
** free memory using the currently active IMalloc* allocator
|
|
*/
|
|
static void MemFree(LPVOID pmem)
|
|
{
|
|
LPMALLOC pmalloc;
|
|
|
|
if (pmem == NULL)
|
|
return;
|
|
|
|
if (CoGetMalloc(MEMCTX_TASK, &pmalloc) != NOERROR) {
|
|
OleDbgAssert(pmalloc);
|
|
return;
|
|
}
|
|
|
|
pmalloc->Free(pmem);
|
|
|
|
if (pmalloc != NULL) {
|
|
ULONG refs = pmalloc->Release();
|
|
}
|
|
}
|
|
|
|
// Replace the first argument with the product of itself and the multiplier
|
|
static void ulargeMultiply(ULARGE_INTEGER FAR *ul, USHORT m)
|
|
{
|
|
Foo out, in;
|
|
in.uli = *ul;
|
|
out.dw = (ULONG)m * in.w0; in.w0 = out.w0;
|
|
out.dw = (ULONG)m * in.w1 + out.w1; in.w1 = out.w0;
|
|
out.dw = (ULONG)m * in.w2 + out.w1; in.w2 = out.w0;
|
|
out.dw = (ULONG)m * in.w3 + out.w1; in.w3 = out.w0;
|
|
*ul = in.uli;
|
|
}
|
|
|
|
// Replace the first argument with the product of itself and the multiplier
|
|
static void ulargeDivide(ULARGE_INTEGER FAR *ul, USHORT m)
|
|
{
|
|
Foo out, in;
|
|
DWORD i;
|
|
in.uli = *ul;
|
|
out.dwh = in.dwh/(ULONG)m;
|
|
i = in.dwh%(ULONG)m;
|
|
in.w2 = in.w1;
|
|
in.w3 = (WORD)i;
|
|
out.w1 = (WORD)(in.dwh/(ULONG)m);
|
|
in.w1 = (WORD)(in.dwh%(ULONG)m);
|
|
out.w0 = (WORD)(in.dw/(ULONG)m);
|
|
*ul = out.uli;
|
|
}
|
|
|
|
|
|
static void setStandard(LPRSI lprsi)
|
|
{
|
|
int i;
|
|
lprsi->cSections = 1;
|
|
SetSumInfFMTID(&lprsi->rgPropSet[0].formatID);
|
|
_fmemcpy(&lprsi->classId, &lprsi->rgPropSet[0].formatID, sizeof(FMTID));
|
|
lprsi->rgPropSet[0].byteOffset = cbNewSummaryInfo(1);
|
|
for (i=0; i<cPID_STANDARD; i++)
|
|
lprsi->section.rgPropId[i].propertyID = PID_TITLE+i;
|
|
lprsi->section.cProperties = cPID_STANDARD; //always; do null test to check validity
|
|
}
|
|
|
|
extern "C" {
|
|
|
|
/*************************************************************************
|
|
**
|
|
** OleStdInitSummaryInfo
|
|
**
|
|
** Purpose:
|
|
** Initialize a Summary Info structure.
|
|
**
|
|
** Parameters:
|
|
** int reserved - reserverd for future use. must be 0.
|
|
**
|
|
** Return Value:
|
|
** LPSUMINFO
|
|
**
|
|
** Comments:
|
|
** CoInitialize MUST be called PRIOR to calling OleStdInitSummaryInfo.
|
|
** Memory is allocated using the currently active IMalloc*
|
|
** allocator (as is returned by call CoGetMalloc(MEMCTX_TASK) ).
|
|
** Each LPSUMINFO instance must be initialized prior to use by
|
|
** calling OleStdInitSummaryInfo. Once a LPSUMINFO instance is allocated
|
|
** (by OleStdInitSummaryInfo), the user can call the Set procedures to
|
|
** initialize fields.
|
|
*************************************************************************/
|
|
|
|
STDAPI_(LPSUMINFO) OleStdInitSummaryInfo(int reserved)
|
|
{
|
|
LPRSI lprsi;
|
|
|
|
if ((lprsi = (LPRSI)MemAlloc(sizeof(RSUMINFO))) != NULL)
|
|
{
|
|
ClearSumInf(lprsi, sizeof(RSUMINFO));
|
|
} else return NULL;
|
|
|
|
setStandard(lprsi);
|
|
return (LPSUMINFO)lprsi;
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
**
|
|
** OleStdFreeSummaryInfo
|
|
**
|
|
** Purpose:
|
|
** Free a Summary Info structure.
|
|
**
|
|
** Parameters:
|
|
** LPSUMINFO FAR *lp - pointer to open Summary Info struct
|
|
**
|
|
** Return Value:
|
|
** void
|
|
**
|
|
** Comments:
|
|
** Memory is freed using the currently active IMalloc*
|
|
** allocator (as is returned by call CoGetMalloc(MEMCTX_TASK) ).
|
|
** Every LPSUMINFO struct must be freed after its last use.
|
|
** When the OleStdFreeSummaryInfo routine is called, all storage will be
|
|
** deallocated including that of the thumbnail (unless ownership of
|
|
** the thumbnail has been transfered to the caller -- see
|
|
** description of transferClip in GetThumbnail API).
|
|
**
|
|
*************************************************************************/
|
|
|
|
STDAPI_(void) OleStdFreeSummaryInfo(LPSUMINFO FAR *lplp)
|
|
{
|
|
if (lplp==NULL||*lplp==NULL) return;
|
|
OleStdClearSummaryInfo(*lplp);
|
|
MemFree(*lplp);
|
|
*lplp = NULL;
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
**
|
|
** OleStdClearSummaryInfo
|
|
**
|
|
** Purpose:
|
|
** Free storage (memory) for all the properties of the LPSUMINFO.
|
|
**
|
|
** Parameters:
|
|
** LPSUMINFO FAR *lp - pointer to open Summary Info struct
|
|
**
|
|
** Return Value:
|
|
** void
|
|
**
|
|
** Comments:
|
|
** After calling OleStdClearSummaryInfo you must call OleStdReadSummaryInfo to
|
|
** load them again.
|
|
**
|
|
*************************************************************************/
|
|
|
|
STDAPI_(void) OleStdClearSummaryInfo(LPSUMINFO lp)
|
|
{
|
|
OleStdSetStringProperty(lp, PID_TITLE, NULL);
|
|
OleStdSetStringProperty(lp, PID_SUBJECT, NULL);
|
|
OleStdSetStringProperty(lp, PID_AUTHOR, NULL);
|
|
OleStdSetStringProperty(lp, PID_KEYWORDS, NULL);
|
|
OleStdSetStringProperty(lp, PID_COMMENTS, NULL);
|
|
OleStdSetStringProperty(lp, PID_TEMPLATE, NULL);
|
|
OleStdSetStringProperty(lp, PID_REVNUMBER, NULL);
|
|
OleStdSetStringProperty(lp, PID_APPNAME, NULL);
|
|
OleStdSetThumbNailProperty(NULL, lp, VT_CF_EMPTY, 0, NULL, NULL, 0);
|
|
ClearSumInf((LPRSI)lp, sizeof(RSUMINFO));
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
**
|
|
** OleStdReadSummaryInfo
|
|
**
|
|
** Purpose:
|
|
** Read all Summary Info properties into memory (except thumbnail
|
|
** which is demand loaded).
|
|
**
|
|
** Parameters:
|
|
** LPSTREAM lps - open SummaryInfo IStream*
|
|
** LPSUMINFO FAR *lp - pointer to open Summary Info struct
|
|
**
|
|
** Return Value:
|
|
** int - 1 for success
|
|
** - 0 if error occurs
|
|
** Comments:
|
|
**
|
|
*************************************************************************/
|
|
|
|
STDAPI_(int) OleStdReadSummaryInfo(LPSTREAM lpStream, LPSUMINFO lp)
|
|
{
|
|
STANDARDSECINMEM FAR *lpSSIM=(STANDARDSECINMEM FAR*)&((LPRSI)lp)->section;
|
|
LPRSI lpSumInfo = (LPRSI)lp;
|
|
SCODE sc;
|
|
ULONG cbRead,i,sectionOffset;
|
|
LARGE_INTEGER a;
|
|
ULARGE_INTEGER b;
|
|
int j,k,l;
|
|
union {
|
|
RSUMINFO rsi;
|
|
STDZ stdz;
|
|
};
|
|
OleStdClearSummaryInfo(lp);
|
|
LISet32(a, 0);
|
|
sc = GetScode(lpStream->Seek(a, STREAM_SEEK_SET, &b));
|
|
if (FAILED(sc)) goto fail;
|
|
sectionOffset = cbNewSummaryInfo(1);
|
|
sc = GetScode(lpStream->Read(&rsi, sectionOffset, &cbRead));
|
|
if (FAILED(sc)||cbRead<sectionOffset) goto fail;
|
|
if (!FIntelOrder(&rsi)||rsi.formatVersion!=0) goto fail;
|
|
j = (int)rsi.cSections;
|
|
while (j-->0) {
|
|
if (FEqSumInfFMTID(&rsi.rgPropSet[0].formatID)) {
|
|
sectionOffset = rsi.rgPropSet[0].byteOffset;
|
|
break;
|
|
} else {
|
|
sc = GetScode(lpStream->Read(&rsi.rgPropSet[0].formatID, sizeof(PROPSETLIST), &cbRead));
|
|
if (FAILED(sc)||cbRead!=sizeof(PROPSETLIST)) goto fail;
|
|
}
|
|
if (j<=0) goto fail;
|
|
}
|
|
|
|
LISet32(a, sectionOffset);
|
|
sc = GetScode(lpStream->Seek(a, STREAM_SEEK_SET, &b));
|
|
if (FAILED(sc)) goto fail;
|
|
sc = GetScode(lpStream->Read(&rsi.section, cbNewSection(1), &cbRead));
|
|
if (FAILED(sc)||cbRead!=cbNewSection(1)) goto fail;
|
|
i = rsi.section.cBytes+sectionOffset;
|
|
j = (int)rsi.section.cProperties;
|
|
if (j>cPID_STANDARD) goto fail;
|
|
k = 0;
|
|
while (j-->0) {
|
|
k++;
|
|
switch (l=(int)rsi.section.rgPropId[0].propertyID) {
|
|
case PID_PAGECOUNT:
|
|
case PID_WORDCOUNT:
|
|
case PID_CHARCOUNT:
|
|
case PID_SECURITY:
|
|
if (l==PID_SECURITY) l=3; else l-=PID_PAGECOUNT;
|
|
cbRead = sectionOffset+rsi.section.rgPropId[0].byteOffset;
|
|
if (cbRead>=i) goto fail;
|
|
LISet32(a, cbRead);
|
|
sc = GetScode(lpStream->Seek(a, STREAM_SEEK_SET, &b));
|
|
if (FAILED(sc)) goto fail;
|
|
sc = GetScode(lpStream->Read(&lpSSIM->rgInts[l], sizeof(INTS), &cbRead));
|
|
if (FAILED(sc)||cbRead!=sizeof(INTS)) goto fail;
|
|
if (lpSSIM->rgInts[l].vtType==VT_EMPTY) break;
|
|
if (lpSSIM->rgInts[l].vtType!=VT_I4) goto fail;
|
|
break;
|
|
case PID_EDITTIME:
|
|
case PID_LASTPRINTED:
|
|
case PID_CREATE_DTM_RO:
|
|
case PID_LASTSAVE_DTM:
|
|
l-=PID_EDITTIME;
|
|
cbRead = sectionOffset+rsi.section.rgPropId[0].byteOffset;
|
|
if (cbRead>=i) goto fail;
|
|
LISet32(a, cbRead);
|
|
sc = GetScode(lpStream->Seek(a, STREAM_SEEK_SET, &b));
|
|
if (FAILED(sc)) goto fail;
|
|
sc = GetScode(lpStream->Read(&lpSSIM->rgTime[l], sizeof(TIME), &cbRead));
|
|
if (FAILED(sc)||cbRead!=sizeof(TIME)) goto fail;
|
|
if (lpSSIM->rgTime[l].vtType==VT_EMPTY) break;
|
|
if (lpSSIM->rgTime[l].vtType!=VT_FILETIME) goto fail;
|
|
break;
|
|
case PID_TITLE:
|
|
case PID_SUBJECT:
|
|
case PID_AUTHOR:
|
|
case PID_KEYWORDS:
|
|
case PID_COMMENTS:
|
|
case PID_TEMPLATE:
|
|
case PID_LASTAUTHOR:
|
|
case PID_REVNUMBER:
|
|
case PID_APPNAME:
|
|
cbRead = sectionOffset+rsi.section.rgPropId[0].byteOffset;
|
|
if (cbRead>=i) goto fail;
|
|
LISet32(a, cbRead);
|
|
sc = GetScode(lpStream->Seek(a, STREAM_SEEK_SET, &b));
|
|
if (FAILED(sc)) goto fail;
|
|
sc = GetScode(lpStream->Read(&stdz, sizeof(STDZ), &cbRead));
|
|
if (FAILED(sc)||cbRead<sizeof(DWORD)*2) goto fail;
|
|
if (stdz.vtType==VT_EMPTY||stdz.vtByteCount<=1) break;
|
|
if (stdz.vtType!=VT_LPSTR||stdz.vtByteCount>WORDMAX) goto fail;
|
|
stdz.rgchars[(int)stdz.vtByteCount-1] = TEXT('\0');
|
|
OleStdSetStringProperty(lp, (DWORD)l, (LPTSTR)&stdz.rgchars[0]);
|
|
break;
|
|
case PID_THUMBNAIL:
|
|
cbRead = sectionOffset+rsi.section.rgPropId[0].byteOffset;
|
|
if (cbRead>=i) goto fail;
|
|
LISet32(a, cbRead);
|
|
sc = GetScode(lpStream->Seek(a, STREAM_SEEK_SET, &b));
|
|
if (FAILED(sc)) goto fail;
|
|
lpSumInfo->fileOffset = cbRead+sizeof(DWORD)*3;
|
|
sc = GetScode(lpStream->Read(&lpSSIM->thumb, sizeof(DWORD)*4, &cbRead));
|
|
if (FAILED(sc)||cbRead!=sizeof(DWORD)*4) {
|
|
lpSSIM->thumb.vtType = VT_EMPTY;
|
|
goto fail;
|
|
}
|
|
if (lpSSIM->thumb.vtType == VT_EMPTY) {
|
|
lpSSIM->thumb.cBytes = 0;
|
|
break;
|
|
}
|
|
if (lpSSIM->thumb.vtType != VT_CF) {
|
|
lpSSIM->thumb.vtType = VT_EMPTY;
|
|
goto fail;
|
|
}
|
|
lpSSIM->thumb.cBytes -= sizeof(DWORD); //for selector
|
|
if (lpSSIM->thumb.selector==VT_CF_WIN||lpSSIM->thumb.selector==VT_CF_MAC) {
|
|
lpSumInfo->fileOffset += sizeof(DWORD);
|
|
lpSSIM->thumb.cBytes -= sizeof(DWORD); //for format val
|
|
}
|
|
break;
|
|
default: ;
|
|
}
|
|
if (j<=0)
|
|
{
|
|
// We should fail if the document is password-protected.
|
|
if(OleStdGetSecurityProperty(lp)==fSecurityPassworded)
|
|
goto fail;
|
|
return 1;
|
|
}
|
|
LISet32(a, sectionOffset+sizeof(DWORD)*2+k*sizeof(PROPIDLIST));
|
|
sc = GetScode(lpStream->Seek(a, STREAM_SEEK_SET, &b));
|
|
if (FAILED(sc)) goto fail;
|
|
sc = GetScode(lpStream->Read(&rsi.section.rgPropId[0], sizeof(PROPIDLIST), &cbRead));
|
|
if (FAILED(sc)||cbRead!=sizeof(PROPIDLIST)) goto fail;
|
|
}
|
|
|
|
fail:
|
|
OleStdClearSummaryInfo(lpSumInfo);
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
**
|
|
** OleStdWriteSummaryInfo
|
|
**
|
|
** Purpose:
|
|
** Write all Summary Info properties to a IStream*
|
|
**
|
|
** Parameters:
|
|
** LPSTREAM lps - open SummaryInfo IStream*
|
|
** LPSUMINFO FAR *lp - pointer to open Summary Info struct
|
|
**
|
|
** Return Value:
|
|
** int - 1 for success
|
|
** - 0 if error occurs
|
|
** Comments:
|
|
**
|
|
*************************************************************************/
|
|
|
|
STDAPI_(int) OleStdWriteSummaryInfo(LPSTREAM lpStream, LPSUMINFO lp)
|
|
{
|
|
|
|
|
|
STANDARDSECINMEM FAR *lpSSIM=(STANDARDSECINMEM FAR*)&((LPRSI)lp)->section;
|
|
// REVIEW: localization issues for propert sets
|
|
// do we need to include a code page and dictionary?
|
|
|
|
LPRSI lpSumInfo = (LPRSI)lp;
|
|
SCODE sc;
|
|
ULONG cbWritten;
|
|
ULONG cBytes, oBytes, k,l,m,n;
|
|
LARGE_INTEGER a;
|
|
ULARGE_INTEGER b;
|
|
CHAR FAR *lps;
|
|
LPMETAFILEPICT lpmfp;
|
|
int i,j,s;
|
|
|
|
setStandard(lpSumInfo);
|
|
oBytes = cbNewSection(cPID_STANDARD); //offsets are relative to the section
|
|
cBytes = cbNewSection(cPID_STANDARD)+(sizeof(TIME)*MAXTIME)+(sizeof(INTS)*MAXINTS);
|
|
|
|
lpSSIM->rgPropId[PID_EDITTIME-2].byteOffset = oBytes;
|
|
lpSSIM->rgPropId[PID_LASTPRINTED-2].byteOffset = oBytes+sizeof(TIME);
|
|
lpSSIM->rgPropId[PID_CREATE_DTM_RO-2].byteOffset = oBytes+sizeof(TIME)*2;
|
|
lpSSIM->rgPropId[PID_LASTSAVE_DTM-2].byteOffset = oBytes+sizeof(TIME)*3;
|
|
|
|
lpSSIM->rgPropId[PID_PAGECOUNT-2].byteOffset = oBytes+(sizeof(TIME)*MAXTIME);
|
|
lpSSIM->rgPropId[PID_WORDCOUNT-2].byteOffset = oBytes+(sizeof(TIME)*MAXTIME+sizeof(INTS));
|
|
lpSSIM->rgPropId[PID_CHARCOUNT-2].byteOffset = oBytes+(sizeof(TIME)*MAXTIME+sizeof(INTS)*2);
|
|
lpSSIM->rgPropId[PID_SECURITY-2].byteOffset = oBytes+(sizeof(TIME)*MAXTIME+sizeof(INTS)*3);
|
|
oBytes += sizeof(TIME)*MAXTIME + sizeof(INTS)*MAXINTS;
|
|
|
|
lpSSIM->rgPropId[PID_THUMBNAIL-2].byteOffset = oBytes;
|
|
l = 0;
|
|
if (lpSSIM->thumb.vtType==VT_EMPTY) k = sizeof(DWORD);
|
|
else {
|
|
l = ((lpSSIM->thumb.cBytes+4-1)>>2)<<2;
|
|
if (lpSSIM->thumb.selector==VT_CF_BYTES) k = sizeof(DWORD)*3;
|
|
else if (lpSSIM->thumb.selector==VT_CF_FMTID) {k = sizeof(DWORD)*3; l += sizeof(FMTID); }
|
|
else if (lpSSIM->thumb.selector==VT_CF_NAME) {k = sizeof(DWORD)*3; l += (((*lpSSIM->thumb.lpstzName+1+3)>>2)<<2);}
|
|
else k = sizeof(DWORD)*4;
|
|
}
|
|
cBytes += k+l;
|
|
oBytes += k+l;
|
|
|
|
for (i=0; i<MAXSTDZ; i++) {
|
|
j = 0;
|
|
if (lpSSIM->rglpsz[i]!=NULL) {
|
|
j = lpSSIM->rglpsz[i]->VTCB+1/*null*/;
|
|
lpSSIM->rglpsz[i]->vtByteCount = j;
|
|
j = (((j+4-1)>>2)<<2)+sizeof(DWORD);
|
|
cBytes += j;
|
|
}
|
|
if (i!=MAXSTDZ-1) lpSSIM->rgPropId[i].byteOffset = oBytes;
|
|
else lpSSIM->rgPropId[PID_APPNAME-2].byteOffset = oBytes;
|
|
oBytes += j+sizeof(DWORD);
|
|
cBytes += sizeof(DWORD); //type
|
|
}
|
|
lpSSIM->cBytes = cBytes;
|
|
|
|
|
|
LISet32(a, 0);
|
|
sc = GetScode(lpStream->Seek(a, STREAM_SEEK_SET, &b));
|
|
if (FAILED(sc)) return 0;
|
|
sc = GetScode(lpStream->Write(lpSumInfo, cbNewSummaryInfo(1), &cbWritten));
|
|
if (FAILED(sc)||cbWritten!=cbNewSummaryInfo(1)) return 0;
|
|
sc = GetScode(lpStream->Write(lpSSIM, cbNewSection(cPID_STANDARD)+sizeof(TIME)*MAXTIME+sizeof(INTS)*MAXINTS, &cbWritten));
|
|
if (FAILED(sc)||cbWritten!=cbNewSection(cPID_STANDARD)+sizeof(TIME)*MAXTIME+sizeof(INTS)*MAXINTS) return 0;
|
|
|
|
m = lpSSIM->thumb.cBytes;
|
|
if (lpSSIM->thumb.lpstzName!=NULL) s = *lpSSIM->thumb.lpstzName;
|
|
else s = 0;
|
|
if (m!=0) {
|
|
lpSSIM->thumb.cBytes = (k-sizeof(DWORD)*2)+
|
|
(((lpSSIM->thumb.cBytes+4-1)>>2)<<2)+(((s+4-1)>>2)<<2);
|
|
n = lpSSIM->thumb.selector;
|
|
lps = lpSSIM->thumb.lpByte;
|
|
OleDbgAssert(lps!=NULL); //maybe a GetThumbNail here
|
|
OleDbgAssert(n!=VT_CF_NAME);
|
|
if (n==VT_CF_WIN) { //bytes are in global memory
|
|
lpmfp = (LPMETAFILEPICT)GlobalLock((HANDLE)(DWORD)lps);
|
|
if (lpmfp==NULL) goto fail;
|
|
lps = (CHAR FAR*)GlobalLock(lpmfp->hMF);
|
|
}
|
|
if (n==VT_CF_NAME) lpSSIM->thumb.selector = *lpSSIM->thumb.lpstzName+1/*null*/;
|
|
}
|
|
sc = GetScode(lpStream->Write(&lpSSIM->thumb, k, &cbWritten));
|
|
if (FAILED(sc)||cbWritten!=k) goto fail;
|
|
if (s!=0) {
|
|
k = ((s+1+4-1)>>2)<<2;
|
|
sc = GetScode(lpStream->Write(lpSSIM->thumb.lpstzName+1, k, &cbWritten));
|
|
if (FAILED(sc)||cbWritten!=k) goto fail;
|
|
}
|
|
if (m!=0) {
|
|
k = ((m+3)>>2)<<2;
|
|
if (n==VT_CF_WIN||VT_CF_NAME) { //bytes are in global memory
|
|
sc = GetScode(lpStream->Write(lpmfp, sizeof(METAFILEPICT), &cbWritten));
|
|
k -= sizeof(METAFILEPICT);
|
|
}
|
|
sc = GetScode(lpStream->Write(lps, k, &cbWritten));
|
|
if (FAILED(sc)||cbWritten!=k) goto fail;
|
|
if (n==VT_CF_WIN||VT_CF_NAME) { //bytes are in global memory
|
|
GlobalUnlock(lpmfp->hMF);
|
|
GlobalUnlock((HANDLE)(DWORD)lpSSIM->thumb.lpByte);
|
|
}
|
|
}
|
|
lpSSIM->thumb.cBytes = m; //restore in mem value
|
|
lpSSIM->thumb.selector = n;
|
|
|
|
k = VT_EMPTY;
|
|
for (i=0; i<MAXSTDZ; i++) {
|
|
if (lpSSIM->rglpsz[i]!=NULL) {
|
|
l = lpSSIM->rglpsz[i]->vtByteCount;
|
|
j = ((((int)l+4-1)/4)*4)+sizeof(DWORD)*2;
|
|
sc = GetScode(lpStream->Write(lpSSIM->rglpsz[i], j, &cbWritten));
|
|
if (FAILED(sc)||cbWritten!=(ULONG)j) return 0;
|
|
lpSSIM->rglpsz[i]->vtByteCount = 0; //restore stz count convention
|
|
lpSSIM->rglpsz[i]->VTCB = (int)l;
|
|
} else {
|
|
sc = GetScode(lpStream->Write(&k, sizeof(DWORD), &cbWritten));
|
|
if (FAILED(sc)||cbWritten!=sizeof(DWORD)) return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
fail:
|
|
lpSSIM->thumb.cBytes = m; //restore in mem value
|
|
lpSSIM->thumb.selector = n;
|
|
if (m!=0&&(n==VT_CF_WIN||VT_CF_NAME)) { //bytes are in global memory
|
|
GlobalUnlock((HANDLE)(DWORD)lps);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
**
|
|
** OleStdGetSecurityProperty
|
|
**
|
|
** Purpose:
|
|
** Retrieve the Security Property
|
|
**
|
|
** Parameters:
|
|
** LPSUMINFO FAR *lp - pointer to open Summary Info struct
|
|
**
|
|
** Return Value:
|
|
** DWORD - security level
|
|
** AllSecurityFlagsEqNone 0 - no security
|
|
** fSecurityPassworded 1 - password required
|
|
** fSecurityRORecommended 2 - read-only is recommended
|
|
** fSecurityRO 4 - read-only is required
|
|
** fSecurityLockedForAnnotations 8 - locked for annotations
|
|
**
|
|
** Comments:
|
|
** by noting the (suggested; that is, application-enforced) security
|
|
** level on the document, an application other than the originator
|
|
** of the document can adjust its user interface to the properties
|
|
** appropriately. An application should not display any of the
|
|
** information about a password protected document, and should not
|
|
** allow modifications to enforced read-only or locked for
|
|
** annotations documents. It should warn the user about read-only
|
|
** recommended if the user attempts to modify properties.
|
|
**
|
|
*************************************************************************/
|
|
|
|
STDAPI_(DWORD) OleStdGetSecurityProperty(LPSUMINFO lp)
|
|
{
|
|
STANDARDSECINMEM FAR *lpSSIM=(STANDARDSECINMEM FAR*)&((LPRSI)lp)->section;
|
|
if (lpSSIM->rgInts[3].vtType == VT_I4) return lpSSIM->rgInts[3].value;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
**
|
|
** OleStdSetSecurityProperty
|
|
**
|
|
** Purpose:
|
|
** Set the Security Property
|
|
**
|
|
** Parameters:
|
|
** LPSUMINFO FAR *lp - pointer to open Summary Info struct
|
|
** DWORD security - security level
|
|
** AllSecurityFlagsEqNone 0 - no security
|
|
** fSecurityPassworded 1 - password required
|
|
** fSecurityRORecommended 2 - read-only is recommended
|
|
** fSecurityRO 4 - read-only is required
|
|
** fSecurityLockedForAnnotations 8 - locked for annotations
|
|
**
|
|
** Return Value:
|
|
** int - 1 for success
|
|
** - 0 if error occurs
|
|
** (there are no errors)
|
|
**
|
|
** Comments:
|
|
** by noting the (suggested; that is, application-enforced) security
|
|
** level on the document, an application other than the originator
|
|
** of the document can adjust its user interface to the properties
|
|
** appropriately. An application should not display any of the
|
|
** information about a password protected document, and should not
|
|
** allow modifications to enforced read-only or locked for
|
|
** annotations documents. It should warn the user about read-only
|
|
** recommended if the user attempts to modify properties.
|
|
**
|
|
*************************************************************************/
|
|
|
|
STDAPI_(int) OleStdSetSecurityProperty(LPSUMINFO lp, DWORD security)
|
|
{
|
|
STANDARDSECINMEM FAR *lpSSIM=(STANDARDSECINMEM FAR*)&((LPRSI)lp)->section;
|
|
|
|
// REVIEW: check valid transitions; how do we know APP called us?
|
|
|
|
if (security==0) {
|
|
lpSSIM->rgInts[3].vtType = VT_EMPTY;
|
|
return 1;
|
|
}
|
|
lpSSIM->rgInts[3].vtType = VT_I4;
|
|
lpSSIM->rgInts[3].value = security;
|
|
return 1;
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
**
|
|
** OleStdGetStringProperty
|
|
**
|
|
** Purpose:
|
|
** Retrieve a String Propety.
|
|
** (returns zero terminated string -- C string)
|
|
**
|
|
** Parameters:
|
|
** LPSUMINFO FAR *lp - pointer to open Summary Info struct
|
|
** DWORD pid - ID of String Property
|
|
**
|
|
** Return Value:
|
|
** LPTSTR - value of String Property
|
|
** (zero terminated string--C string)
|
|
**
|
|
** Comments:
|
|
** String should NOT be freed by caller. Memory for string will be
|
|
** freed when OleStdFreeSummaryInfo is called.
|
|
*************************************************************************/
|
|
|
|
STDAPI_(LPTSTR) OleStdGetStringProperty(LPSUMINFO lp, DWORD pid)
|
|
{
|
|
LPTSTR l = OleStdGetStringZProperty(lp,pid);
|
|
if (l==NULL) return NULL; else return l+1;
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
**
|
|
** OleStdSetStringProperty
|
|
**
|
|
** Purpose:
|
|
** Set a String Propety
|
|
** (takes zero terminated string -- C string)
|
|
**
|
|
** Parameters:
|
|
** LPSUMINFO FAR *lp - pointer to open Summary Info struct
|
|
** DWORD pid - ID of String Property
|
|
** LPTSTR lpsz - new value for String Property.
|
|
** zero terminated string -- C string.
|
|
** May be NULL, in which case the
|
|
** propery is cleared.
|
|
**
|
|
** Return Value:
|
|
** int - 1 if successful
|
|
** - 0 invalid property id
|
|
**
|
|
** Comments:
|
|
** The input string is copied.
|
|
**
|
|
*************************************************************************/
|
|
|
|
STDAPI_(int) OleStdSetStringProperty(LPSUMINFO lp, DWORD pid, LPTSTR lpsz)
|
|
{
|
|
LPRSI lprsi=(LPRSI)lp;
|
|
STANDARDSECINMEM FAR* lpSSIM=(STANDARDSECINMEM FAR*)&((LPRSI)lp)->section;
|
|
int i;
|
|
if (pid==PID_APPNAME) {
|
|
pid = MAXSTDZ-1;
|
|
} else if (pid<PID_TITLE || pid>PID_REVNUMBER) return 0; else pid -= 2;
|
|
OleDbgAssert(lpSSIM);
|
|
if (lpSSIM->rglpsz[pid]) MemFree(lpSSIM->rglpsz[pid]);
|
|
if ((lpsz==NULL)||(*lpsz==0)) {
|
|
lpSSIM->rglpsz[pid] = NULL;
|
|
return (1);
|
|
}
|
|
i = _fstrlen(lpsz);
|
|
lpSSIM->rglpsz[pid] = (STDZ FAR*)MemAlloc((i+1/*null*/)*sizeof(TCHAR)+
|
|
sizeof(DWORD)*2);
|
|
if (lpSSIM->rglpsz[pid]==NULL) return 0;
|
|
_fstrcpy((LPTSTR)&lpSSIM->rglpsz[pid]->rgchars, lpsz);
|
|
lpSSIM->rglpsz[pid]->vtType = VT_LPSTR;
|
|
lpSSIM->rglpsz[pid]->vtByteCount = 0;
|
|
lpSSIM->rglpsz[pid]->VTCB = i;
|
|
return (1);
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
**
|
|
** OleStdGetStringZProperty
|
|
**
|
|
** Purpose:
|
|
** Retrieve a String Propety.
|
|
** (returns zero-terminated with leading byte count string)
|
|
**
|
|
** Parameters:
|
|
** LPSUMINFO FAR *lp - pointer to open Summary Info struct
|
|
** DWORD pid - ID of Property
|
|
**
|
|
** Return Value:
|
|
** LPSTZR - value of String Property
|
|
** (zero-terminated with leading
|
|
** byte count)
|
|
**
|
|
** Comments:
|
|
** String should NOT be freed by caller. Memory for string will be
|
|
** freed when OleStdFreeSummaryInfo is called.
|
|
*************************************************************************/
|
|
|
|
STDAPI_(LPSTZR) OleStdGetStringZProperty(LPSUMINFO lp, DWORD pid)
|
|
{
|
|
STANDARDSECINMEM FAR *lpSSIM=(STANDARDSECINMEM FAR*)&((LPRSI)lp)->section;
|
|
if (pid==PID_APPNAME) {
|
|
pid = MAXSTDZ-1;
|
|
} else if (pid<PID_TITLE || pid>PID_REVNUMBER) return NULL; else pid -= 2;
|
|
if (lpSSIM->rglpsz[pid]!=NULL) {
|
|
return (LPTSTR)&lpSSIM->rglpsz[pid]->VTCB;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
**
|
|
** OleStdGetDocProperty
|
|
**
|
|
** Purpose:
|
|
** Retrieve document properties (no. pages, no. words, no. characters)
|
|
**
|
|
** Parameters:
|
|
** LPSUMINFO FAR *lp - pointer to open Summary Info struct
|
|
** DWORD FAR *nPage - (OUT) number of pages in document
|
|
** DWORD FAR *nWords - (OUT) number of words in document
|
|
** DWORD FAR *nChars - (OUT) number of charactrs in doc
|
|
**
|
|
** Return Value:
|
|
** void
|
|
**
|
|
** Comments:
|
|
**
|
|
*************************************************************************/
|
|
|
|
STDAPI_(void) OleStdGetDocProperty(
|
|
LPSUMINFO lp,
|
|
DWORD FAR* nPage,
|
|
DWORD FAR* nWords,
|
|
DWORD FAR* nChars
|
|
)
|
|
{
|
|
STANDARDSECINMEM FAR *lpSSIM=(STANDARDSECINMEM FAR*)&((LPRSI)lp)->section;
|
|
*nPage=0; *nWords=0; *nChars=0;
|
|
if (lpSSIM->rgInts[0].vtType == VT_I4) *nPage = lpSSIM->rgInts[0].value;
|
|
if (lpSSIM->rgInts[1].vtType == VT_I4) *nWords = lpSSIM->rgInts[1].value;
|
|
if (lpSSIM->rgInts[2].vtType == VT_I4) *nChars = lpSSIM->rgInts[2].value;
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
**
|
|
** OleStdSetDocProperty
|
|
**
|
|
** Purpose:
|
|
** Set document properties (no. pages, no. words, no. characters)
|
|
**
|
|
** Parameters:
|
|
** LPSUMINFO FAR *lp - pointer to open Summary Info struct
|
|
** DWORD nPage - number of pages in document
|
|
** DWORD nWords - number of words in document
|
|
** DWORD nChars - number of charactrs in doc
|
|
**
|
|
** Return Value:
|
|
** int - 1 for success
|
|
** - 0 if error occurs
|
|
** (there are no errors)
|
|
**
|
|
** Comments:
|
|
**
|
|
*************************************************************************/
|
|
|
|
STDAPI_(int) OleStdSetDocProperty(
|
|
LPSUMINFO lp,
|
|
DWORD nPage,
|
|
DWORD nWords,
|
|
DWORD nChars
|
|
)
|
|
{
|
|
DWORD vttype=VT_I4;
|
|
STANDARDSECINMEM FAR *lpSSIM=(STANDARDSECINMEM FAR*)&((LPRSI)lp)->section;
|
|
if ((nPage|nWords|nChars)==0) {
|
|
vttype = VT_EMPTY;
|
|
nPage=0; nWords=0; nChars=0;
|
|
}
|
|
lpSSIM->rgInts[0].vtType = vttype;
|
|
lpSSIM->rgInts[1].vtType = vttype;
|
|
lpSSIM->rgInts[2].vtType = vttype;
|
|
lpSSIM->rgInts[0].value = nPage;
|
|
lpSSIM->rgInts[1].value = nWords;
|
|
lpSSIM->rgInts[2].value = nChars;
|
|
return 1;
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
**
|
|
** OleStdGetThumbNailProperty
|
|
**
|
|
** Purpose:
|
|
** Retrieve a Thumbnail Property
|
|
**
|
|
** Parameters:
|
|
** LPSTREAM lps
|
|
** LPSUMINFO FAR *lp - pointer to open Summary Info struct
|
|
** DWORD FAR* clipFormatNo - clipboard format for thumbnail
|
|
** (type of value depends on vtcf
|
|
** return value.)
|
|
** NOTE: ONLY VT_CF_WIN is
|
|
** implemented, so clipFormatNo
|
|
** will be CF_METAFILEPICT
|
|
** LPTSTR FAR* lpszName - format name if VT_CF_NAME is
|
|
** returned
|
|
** NOTE: NOT IMPLEMENTED
|
|
** THUMBNAIL FAR* clip - handle to thumbnail
|
|
** for VT_CF_WIN clip will be
|
|
** handle to MetafilePict
|
|
** NOTE: only VT_CF_WIN IMPLEMENTED
|
|
** DWORD FAR* byteCount - size of thumbnail stream
|
|
** for VT_CF_WIN case this should
|
|
** be combined size of both the
|
|
** Metafile as well as the
|
|
** MetafilePict structure.
|
|
** BOOL transferClip - transfer ownership of thumbnail
|
|
** to caller. (see comment)
|
|
**
|
|
** Return Value:
|
|
** int vtcfNo - OLE thumbnail selector value
|
|
** VT_CF_WIN - Windows thumbnail
|
|
** (interpret clipFormatNo as
|
|
** Windows clipboard format)
|
|
** VT_CF_FMTID - (NOT IMPLEMENTED)
|
|
** thumbnail format is specified
|
|
** by ID. use clipFormatNo.
|
|
** (but NOT a Windows format ID)
|
|
**
|
|
** VT_CF_NAME - (NOT IMPLEMENTED)
|
|
** thumbnail format is specified
|
|
** by name. use lpszName.
|
|
** VT_CF_EMPTY - blank thumbnail
|
|
** (clip will be NULL)
|
|
** VT_CF_OOM - Memory allocation failure
|
|
**
|
|
** Comments:
|
|
** NOTE: Currently there is only proper support for VT_CF_WIN.
|
|
** OleStdSetThumbNailProperty does implement VT_CF_FMTID and VT_CF_NAME,
|
|
** however, OleStdGetThumbNailProperty, OleStdReadSummaryInfo and
|
|
** OleStdWriteSummaryInfo only support VT_CF_WIN.
|
|
**
|
|
** Note that on input, the thumbnail is read on demand while all the
|
|
** other properties are pre-loaded. The thumbnail is manipulated as
|
|
** a windows handle to a METAFILEPICT structure, which in turn
|
|
** contains a handle to the METAFILE. The transferClip argument on
|
|
** GetThumbNail, when set to true, transfers responsibility for
|
|
** storage management of the thumbnail to the caller; that is, after
|
|
** OleStdFreeSummaryInfo has been called, the handle is still valid.
|
|
*************************************************************************/
|
|
|
|
STDAPI_(int) OleStdGetThumbNailProperty(
|
|
LPSTREAM lps,
|
|
LPSUMINFO lp,
|
|
DWORD FAR* clipFormatNo,
|
|
LPTSTR FAR* lpszName,
|
|
THUMBNAIL FAR* clip,
|
|
DWORD FAR* byteCount,
|
|
BOOL transferClip
|
|
)
|
|
{
|
|
int i;
|
|
LPRSI lprsi=(LPRSI)lp;
|
|
STANDARDSECINMEM FAR *lpSSIM=(STANDARDSECINMEM FAR*)&((LPRSI)lp)->section;
|
|
ULONG cbRead, cbToRead;
|
|
LARGE_INTEGER a;
|
|
ULARGE_INTEGER b;
|
|
CHAR FAR *lpst;
|
|
LPMETAFILEPICT lpmfp;
|
|
HANDLE hst, hmfp;
|
|
SCODE sc;
|
|
*byteCount = 0;
|
|
if (lpSSIM->thumb.cBytes==0) return VT_CF_EMPTY;
|
|
if (lpSSIM->thumb.lpByte==NULL) {
|
|
LISet32(a, lprsi->fileOffset);
|
|
sc = GetScode(lps->Seek(a, STREAM_SEEK_SET, &b));
|
|
if (FAILED(sc)) return VT_CF_EMPTY;
|
|
i = (int) lpSSIM->thumb.selector;
|
|
if (i>0||i==VT_CF_FMTID) {
|
|
if (i>255) return VT_CF_EMPTY;
|
|
else if (i==VT_CF_FMTID) i = sizeof(FMTID);
|
|
else lpSSIM->thumb.selector = VT_CF_NAME;
|
|
cbToRead = ((i+3)>>2)<<2;
|
|
lpSSIM->thumb.lpstzName=(CHAR FAR*)MemAlloc(i+1/*n*/+1);
|
|
if (lpSSIM->thumb.lpstzName==NULL) return VT_CF_OOM;
|
|
sc = GetScode(lps->Read(lpSSIM->thumb.lpstzName+1, cbToRead, &cbRead));
|
|
if (FAILED(sc)||cbRead!=cbToRead) return VT_CF_EMPTY;
|
|
*lpSSIM->thumb.lpstzName = i;
|
|
*(lpSSIM->thumb.lpstzName+i) = 0;
|
|
lpSSIM->thumb.cBytes -= cbToRead+sizeof(DWORD);
|
|
}
|
|
i = (int) lpSSIM->thumb.selector;
|
|
cbToRead = lpSSIM->thumb.cBytes;
|
|
if (cbToRead>65535) return VT_CF_OOM;
|
|
OleDbgAssert(i!=VT_CF_NAME);
|
|
if (i==VT_CF_WIN) {
|
|
cbToRead -= sizeof(METAFILEPICT);
|
|
hmfp = GlobalAlloc(GMEM_MOVEABLE, sizeof(METAFILEPICT));
|
|
if (hmfp==NULL) return VT_CF_OOM;
|
|
hst = GlobalAlloc(GMEM_MOVEABLE, cbToRead);
|
|
if (hst==NULL) {
|
|
GlobalFree(hmfp);
|
|
return VT_CF_OOM;
|
|
}
|
|
lpmfp = (LPMETAFILEPICT)GlobalLock(hmfp);
|
|
sc = GetScode(lps->Read(lpmfp, sizeof(METAFILEPICT), &cbRead));
|
|
if (FAILED(sc)||cbRead!=sizeof(METAFILEPICT)) {
|
|
GlobalUnlock(hmfp);
|
|
GlobalFree(hmfp);
|
|
GlobalFree(hst);
|
|
return VT_CF_EMPTY;
|
|
}
|
|
lpst = (CHAR FAR*)GlobalLock(hst);
|
|
lpmfp->hMF = (HMETAFILE)hst;
|
|
lpSSIM->thumb.lpByte = (CHAR FAR*)hmfp;
|
|
} else {
|
|
lpst =(CHAR FAR*)MemAlloc((int)cbToRead);
|
|
if (lpst==NULL) return VT_CF_OOM;
|
|
lpSSIM->thumb.lpByte = lpst;
|
|
}
|
|
sc = GetScode(lps->Read(lpst, cbToRead, &cbRead));
|
|
if (i==VT_CF_WIN) {
|
|
GlobalUnlock(hst);
|
|
GlobalUnlock(hmfp);
|
|
}
|
|
if (FAILED(sc)||cbRead!=cbToRead) {
|
|
if (i==VT_CF_WIN) {
|
|
GlobalFree(hst);
|
|
GlobalFree(hmfp);
|
|
} else MemFree(lpst);
|
|
lpSSIM->thumb.lpByte = NULL;
|
|
if ((i==VT_CF_NAME||i==VT_CF_FMTID)&&(lpSSIM->thumb.lpstzName!=NULL))
|
|
MemFree(lpSSIM->thumb.lpstzName);
|
|
return VT_CF_EMPTY;
|
|
}
|
|
}
|
|
*clipFormatNo = lpSSIM->thumb.clipFormat;
|
|
*byteCount = lpSSIM->thumb.cBytes;
|
|
if(lpszName!=NULL)
|
|
*lpszName = (TCHAR FAR*)lpSSIM->thumb.lpstzName+1;
|
|
*clip = (TCHAR FAR*)lpSSIM->thumb.lpByte;
|
|
if (transferClip) lpSSIM->thumb.lpByte=NULL;
|
|
return (int)lpSSIM->thumb.selector;
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
**
|
|
** OleStdSetThumbNailProperty
|
|
**
|
|
** Purpose:
|
|
** Set a Thumbnail Property
|
|
**
|
|
** Parameters:
|
|
** LPSTREAM lps - open SummaryInfo IStream*
|
|
** LPSUMINFO FAR *lp - pointer to open Summary Info struct
|
|
** int vtcfNo - OLE thumbnail selector value
|
|
** VT_CF_WIN - Windows thumbnail
|
|
** (interpret clipFormatNo as
|
|
** Windows clipboard format)
|
|
** VT_CF_FMTID - thumbnail format is specified
|
|
** by ID. use clipFormatNo.
|
|
** (but NOT a Windows format ID)
|
|
**
|
|
** VT_CF_NAME - thumbnail format is specified
|
|
** by name. use lpszName.
|
|
** VT_CF_EMPTY - blank thumbnail
|
|
** (clip will be NULL)
|
|
**
|
|
** DWORD FAR* clipFormatNo - clipboard format for thumbnail
|
|
** used if vtcfNo is VT_CF_WIN or
|
|
** VT_CF_FMTID. interpretation of
|
|
** value depends on vtcfNo specified.
|
|
** (normally vtcfNo==VT_CF_WIN and
|
|
** clipFormatNo==CF_METAFILEPICT)
|
|
** LPSTR FAR* lpszName - format name if vtcfNo is VT_CF_NAME
|
|
** THUMBNAIL clip - handle to thumbnail
|
|
** for VT_CF_WIN clip will be
|
|
** handle to MetafilePict
|
|
** DWORD FAR* byteCount - size of thumbnail stream
|
|
** for VT_CF_WIN case this should
|
|
** be combined size of both the
|
|
** Metafile as well as the
|
|
** MetafilePict structure.
|
|
**
|
|
** Return Value:
|
|
** int - 1 for success
|
|
** - 0 if error occurs
|
|
**
|
|
** Comments:
|
|
** NOTE: Currently there is only proper support for VT_CF_WIN.
|
|
** OleStdSetThumbNailProperty does implement VT_CF_FMTID and VT_CF_NAME,
|
|
** however, OleStdGetThumbNailProperty, OleStdReadSummaryInfo and
|
|
** OleStdWriteSummaryInfo only support VT_CF_WIN.
|
|
**
|
|
** This function copies lpszName but saves the "clip" handle passed.
|
|
**
|
|
** NOTE: overwriting or emptying frees space for clip and name.
|
|
** The thumbnail is manipulated as a windows handle to a
|
|
** METAFILEPICT structure, which in turn contains a handle to the
|
|
** METAFILE.
|
|
*************************************************************************/
|
|
|
|
STDAPI_(int) OleStdSetThumbNailProperty(
|
|
LPSTREAM lps,
|
|
LPSUMINFO lp,
|
|
int vtcfNo,
|
|
DWORD clipFormatNo,
|
|
LPTSTR lpszName,
|
|
THUMBNAIL clip,
|
|
DWORD byteCount
|
|
)
|
|
{
|
|
int i;
|
|
LPRSI lprsi=(LPRSI)lp;
|
|
STANDARDSECINMEM FAR *lpSSIM=(STANDARDSECINMEM FAR*)&((LPRSI)lp)->section;
|
|
LPMETAFILEPICT lpmfp;
|
|
if (lpSSIM==NULL||vtcfNo>0||vtcfNo<VT_CF_EMPTY||(vtcfNo==VT_CF_NAME&&(lpszName==NULL||*lpszName==0))) {
|
|
return 0;
|
|
}
|
|
if (vtcfNo!=VT_CF_EMPTY&&(clip==0||byteCount==0)) return 0;
|
|
i = (int) lpSSIM->thumb.vtType;
|
|
if (i!=VT_EMPTY) {
|
|
i = (int) lpSSIM->thumb.selector;
|
|
OleDbgAssert(i!=VT_CF_NAME);
|
|
if (i==VT_CF_WIN) {
|
|
if (lpSSIM->thumb.lpByte!=NULL) {
|
|
lpmfp = (LPMETAFILEPICT)GlobalLock((HANDLE)(DWORD)lpSSIM->thumb.lpByte);
|
|
GlobalFree(lpmfp->hMF);
|
|
GlobalUnlock((HANDLE)(DWORD)lpSSIM->thumb.lpByte);
|
|
GlobalFree((HANDLE)(DWORD)lpSSIM->thumb.lpByte);
|
|
}
|
|
} else {
|
|
MemFree(lpSSIM->thumb.lpByte);
|
|
}
|
|
if ((i==VT_CF_NAME||i==VT_CF_FMTID)&&(lpSSIM->thumb.lpstzName!=NULL))
|
|
MemFree(lpSSIM->thumb.lpstzName);
|
|
lpSSIM->thumb.lpstzName = NULL;
|
|
lpSSIM->thumb.lpByte = NULL;
|
|
}
|
|
if (vtcfNo==VT_CF_EMPTY) {
|
|
lpSSIM->thumb.vtType = VT_EMPTY;
|
|
lpSSIM->thumb.cBytes = 0;
|
|
} else {
|
|
lpSSIM->thumb.vtType = VT_CF;
|
|
lpSSIM->thumb.selector = vtcfNo;
|
|
lpSSIM->thumb.cBytes = byteCount;
|
|
lpSSIM->thumb.clipFormat = clipFormatNo;
|
|
lpSSIM->thumb.lpByte = (CHAR FAR*)clip; //just save the hnadle
|
|
if (vtcfNo==VT_CF_NAME||vtcfNo==VT_CF_FMTID) {
|
|
i = _fstrlen(lpszName);
|
|
if (vtcfNo==VT_CF_FMTID) OleDbgAssert(i*sizeof(TCHAR)==sizeof(FMTID));
|
|
lpSSIM->thumb.lpstzName =
|
|
(CHAR FAR*)MemAlloc((i+1/*n*/+1/*null*/)*sizeof(TCHAR));
|
|
if (lpSSIM->thumb.lpstzName==NULL) {
|
|
lpSSIM->thumb.vtType = VT_EMPTY;
|
|
return 0;
|
|
}
|
|
_fstrcpy((TCHAR FAR*)lpSSIM->thumb.lpstzName+1, lpszName);
|
|
*lpSSIM->thumb.lpstzName = i;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
/*************************************************************************
|
|
**
|
|
** OleStdGetDateProperty
|
|
**
|
|
** Purpose:
|
|
** Retrieve Data Property
|
|
**
|
|
** Parameters:
|
|
** LPSUMINFO FAR *lp - pointer to open Summary Info struct
|
|
** DWORD pid - ID of Property
|
|
** int FAR *yr - (OUT) year
|
|
** int FAR *mo - (OUT) month
|
|
** int FAR *dy - (OUT) day
|
|
** DWORD FAR *sc - (OUT) seconds
|
|
**
|
|
** Return Value:
|
|
** void
|
|
**
|
|
** Comments:
|
|
**
|
|
*************************************************************************/
|
|
|
|
STDAPI_(void) OleStdGetDateProperty(
|
|
LPSUMINFO lp,
|
|
DWORD pid,
|
|
int FAR* yr,
|
|
int FAR* mo,
|
|
int FAR* dy,
|
|
DWORD FAR* sc
|
|
)
|
|
{
|
|
STANDARDSECINMEM FAR *lpSSIM=(STANDARDSECINMEM FAR*)&((LPRSI)lp)->section;
|
|
SFFS sffs;
|
|
pid -= PID_EDITTIME;
|
|
*yr = 0; *mo = 0; *dy = 0; *sc = 0;
|
|
if (pid<0||pid>=MAXTIME) return;
|
|
if (lpSSIM->rgTime[pid].vtType == VT_FILETIME) {
|
|
if (pid==0) {
|
|
//convert from 100ns to seconds
|
|
ulargeDivide((ULARGE_INTEGER FAR*)&lpSSIM->rgTime[0].time, 10000);
|
|
ulargeDivide((ULARGE_INTEGER FAR*)&lpSSIM->rgTime[0].time, 1000);
|
|
pid = lpSSIM->rgTime[0].time.dwLowDateTime;
|
|
*sc = pid%((DWORD)60*60*24);
|
|
pid /= (DWORD)60*60*24;
|
|
*dy = (int)(pid%(DWORD)30);
|
|
pid /= (DWORD)30;
|
|
*mo = (int)(pid%(DWORD)12);
|
|
*yr = (int)(pid/(DWORD)12);
|
|
} else {
|
|
if (CoFileTimeToDosDateTime(&lpSSIM->rgTime[pid].time,
|
|
&sffs.dateVariable, &sffs.timeVariable)) {
|
|
*yr = sffs.yr+1980;
|
|
*mo = sffs.mon;
|
|
*dy = sffs.dom;
|
|
*sc = (DWORD)sffs.hr*3600+sffs.mint*60+sffs.sec*2;
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
|
|
/*************************************************************************
|
|
**
|
|
** OleStdSetDateProperty
|
|
**
|
|
** Purpose:
|
|
** Set Data Property
|
|
**
|
|
** Parameters:
|
|
** LPSUMINFO FAR *lp - pointer to open Summary Info struct
|
|
** DWORD pid - ID of Property
|
|
** int yr - year
|
|
** int mo - month
|
|
** int dy - day
|
|
** DWORD sc - seconds
|
|
**
|
|
** Return Value:
|
|
** int - 1 for success
|
|
** - 0 if error occurs
|
|
**
|
|
** Comments:
|
|
** Use all zeros to clear.
|
|
** The following is an example of valid input:
|
|
** yr=1993 mo=1(Jan) dy=1(1st) hr=12(noon) mn=30 sc=23
|
|
** for PID_EDITTIME property, the values are a zero-origin duration
|
|
** of time.
|
|
**
|
|
*************************************************************************/
|
|
|
|
STDAPI_(int) OleStdSetDateProperty(
|
|
LPSUMINFO lp,
|
|
DWORD pid,
|
|
int yr,
|
|
int mo,
|
|
int dy,
|
|
int hr,
|
|
int mn,
|
|
int sc
|
|
)
|
|
{
|
|
STANDARDSECINMEM FAR *lpSSIM=(STANDARDSECINMEM FAR*)&((LPRSI)lp)->section;
|
|
SFFS sffs;
|
|
pid -= PID_EDITTIME;
|
|
if (pid<0||pid>=MAXTIME) return 0;
|
|
if ((yr|mo|dy|hr|mn|sc)==0) { //all must be zero
|
|
lpSSIM->rgTime[pid].vtType = VT_EMPTY;
|
|
return 1;
|
|
}
|
|
lpSSIM->rgTime[pid].vtType = VT_FILETIME;
|
|
if (pid==0) {
|
|
lpSSIM->rgTime[0].time.dwLowDateTime =
|
|
(((((DWORD)yr*365+mo*30)+dy)*24+hr)*60+mn)*60+sc;
|
|
lpSSIM->rgTime[0].time.dwHighDateTime = 0;
|
|
//10^7 nanoseconds/second
|
|
ulargeMultiply((ULARGE_INTEGER FAR*)&lpSSIM->rgTime[0].time, 10000);
|
|
//convert to units of 100 ns
|
|
ulargeMultiply((ULARGE_INTEGER FAR*)&lpSSIM->rgTime[0].time, 1000);
|
|
} else {
|
|
sffs.yr = max(yr-1980,0);
|
|
sffs.mon = mo;
|
|
sffs.dom = dy;
|
|
sffs.hr = hr;
|
|
sffs.mint= mn;
|
|
sffs.sec = sc/2; //dos is 2 second intervals
|
|
if (!CoDosDateTimeToFileTime(sffs.date, sffs.time,
|
|
&lpSSIM->rgTime[pid].time)) {
|
|
lpSSIM->rgTime[pid].vtType = VT_EMPTY;
|
|
return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
} //END C
|