|
|
//+----------------------------------------------------------------------------
//
// File:
// utils.h
//
// Contents:
// prototypes and constants for OLE internal utility routines
//
// Classes:
//
// Functions:
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup begins
// 11/29/93 - ChrisWe - remove signature for non-existent
// function UtGlobalHandlCpy; moved manifest constants
// to be with functions they are used with (OPCODE_*,
// CONVERT_*); removed default parameters from functions;
// replace '!' with '~' in STREAMTYPE_OTHER definition
// 04/07/94 - AlexGo - added UtCreateStorageOnHGlobal
//
//-----------------------------------------------------------------------------
#ifndef _UTILS_H_
#define _UTILS_H_
// We need to serialize the placeable metafile structure in the same format
// that was used by WIN16, since RECT used LONGs under Win32.
// We ensure that no padding is added by using the #pragma pack() calls.
#pragma pack(1)
typedef struct tagWIN16RECT{ WORD left; WORD top; WORD right; WORD bottom;} WIN16RECT;
typedef struct tagPLACEABLEMETAHEADER{ DWORD key; /* must be PMF_KEY */#define PMF_KEY 0x9ac6cdd7
WORD hmf; /* must be zero */ WIN16RECT bbox; /* bounding rectangle of the metafile */ WORD inch; /* # of metafile units per inch must be < 1440 */ /* most apps use 576 or 1000 */ DWORD reserved; /* must be zero */ WORD checksum;} PLACEABLEMETAHEADER;#pragma pack()
//+-------------------------------------------------------------------------
//
// Function: UtGetUNICODEData, PRIVATE INTERNAL
//
// Synopsis: Given a string length, and two pointers (one ANSI, one
// OLESTR), returns the UNICODE version of whichever string
// is valid.
//
// Effects: Memory is allocated on the caller's pointer for new OLESTR
//
// Arguments: [ulLength] -- length of string in CHARACTERS (not bytes)
// (including terminator)
// [szANSI] -- candidate ANSI string
// [szOLESTR] -- candidate OLESTR string
// [pstr] -- OLESTR OUT parameter
//
// Returns: NOERROR on success
// E_OUTOFMEMORY on allocation failure
// E_ANSITOUNICODE if ANSI cannot be converted to UNICODE
//
// Algorithm: If szOLESTR is available, a simple copy is performed
// If szOLESTR is not available, szANSI is converted to UNICODE
// and the result is copied.
//
// History: dd-mmm-yy Author Comment
// 08-Mar-94 davepl Created
//
// Notes: Only one of the two input strings (ANSI or UNICODE) should
// be set on entry.
//
//--------------------------------------------------------------------------
INTERNAL UtGetUNICODEData( ULONG, LPSTR, LPOLESTR, LPOLESTR *);
//+-------------------------------------------------------------------------
//
// Function: UtPutUNICODEData, PRIVATE INTERNAL
//
// Synopsis: Given an OLESTR and two possible buffer pointer, one ANSI
// and the other OLESTR, this fn tries to convert the string
// down to ANSI. If it succeeds, it allocates memory on the
// ANSI ptr for the result. If it fails, it allocates memory
// on the UNICODE ptr and copies the input string over. The
// length of the final result (ANSI or UNICODE) is returned
// in dwResultLen.
//
// Arguments: [ulLength] -- input length of OLESTR str
// [str] -- the OLESTR to store
// [pszANSI] -- candidate ANSI str ptr
// [pszOLESTR] -- candidate OLESTR str ptr
// [pdwResultLen] -- where to store the length of result
//
// Returns: NOERROR on success
// E_OUTOFMEMORY on allocation failure
//
// History: dd-mmm-yy Author Comment
// 08-Mar-94 davepl Created
//
//--------------------------------------------------------------------------
INTERNAL UtPutUNICODEData( ULONG ulLength, LPOLESTR str, LPSTR * pszANSI, LPOLESTR * pszOLESTR, DWORD * pdwResultLen );
//+----------------------------------------------------------------------------
//
// Function:
// UtDupGlobal, internal
//
// Synopsis:
// Duplicate the contents of an HGlobal into a new HGlobal. If
// there is no allocated memory, no new global is allocated.
//
// Arguments:
// [hsrc] -- the source HGLobal; need not be locked
// [uiFlags] -- flags to be passed on to GlobalAlloc()
//
// Returns:
// The new HGLOBAL, if successful, or NULL
//
// History:
// 11/28/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL_(HANDLE) UtDupGlobal(HANDLE hSrc, UINT uiFlags);
//+----------------------------------------------------------------------------
//
// Function:
// UtIsFormatSupported, internal
//
// Synopsis:
// Checks a data object to see if it will accept
// IDataObject::SetData() and/or IDataObject::GetData() calls
// on the specified format. The direction of transfer is specified
// with the dwDirection flags. The function returns TRUE only
// if all requested transfers are possible.
//
// Arguments:
// [lpObj] -- the data object to check for the format
// [dwDirection] -- a combination of values from DATADIR_*
// [cfFormat] -- the format to look for
//
// Returns:
// TRUE, if transfers of [cfFormat] are supported in [dwDirection],
// FALSE otherwise
//
// Notes:
//
// History:
// 11/29/93 - ChrisWe - file inspection and cleanup; noted that
// enumerators are expected to be able to return
// formats for multiple DATADIR_* flags
//
//-----------------------------------------------------------------------------
FARINTERNAL_(BOOL) UtIsFormatSupported(LPDATAOBJECT lpObj, DWORD dwDirection, CLIPFORMAT cfFormat);
//+----------------------------------------------------------------------------
//
// Function:
// UtDupString, internal
//
// Synopsis:
// Copies the argument string into a new string allocated
// using the task allocator
//
// Arguments:
// [lpszIn] -- the string to duplicate
//
// Returns:
// a pointer to a copy of [lpszIn], or NULL if the allocator
// could not be acquired, or was out of memory
//
// History:
// 11/28/93 - ChrisWe - file cleanup and inspection
//
//-----------------------------------------------------------------------------
FARINTERNAL_(LPOLESTR) UtDupString(LPCOLESTR lpszIn);
//+-------------------------------------------------------------------------
//
// Function: utGetProtseqFromTowerId
//
// Synopsis: Get protseq string from DCE TowerID
//
// Effects:
//
// Arguments: [wTowerId] -- TowerID to retrieve
//
// Returns: protseq string - NULL if not found
//
// History: dd-mmm-yy Author Comment
// 28-Oct-96 t-KevinH Created as findProtseq
// 06-Feb-97 Ronans Converted to utility fn
//
//--------------------------------------------------------------------------
FARINTERNAL_(LPCWSTR) utGetProtseqFromTowerId(USHORT wTowerId);
//+-------------------------------------------------------------------------
//
// Function: utGetTowerId
//
// Synopsis: Get DCE TowerId for protseq string
//
// Effects:
//
// Arguments: [pwszProtseq] -- string to look up
//
// Returns: protseq string - NULL if not found
//
// History: dd-mmm-yy Author Comment
// 28-Oct-96 t-KevinH Created as findProtseq
// 06-Feb-97 Ronans Converted to utility fn
//
//--------------------------------------------------------------------------
FARINTERNAL_(USHORT) utGetTowerId(LPCWSTR pwszProtseq);
//+-------------------------------------------------------------------------
//
// Function: UtDupStringA
//
// Synopsis: Duplicates an ANSI string using the TASK allocator
//
// Effects:
//
// Arguments: [pszAnsi] -- the string to duplicate
//
// Requires:
//
// Returns: the newly allocated string duplicate or NULL
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 04-Jun-94 alexgo author
//
// Notes:
//
//--------------------------------------------------------------------------
LPSTR UtDupStringA( LPCSTR pszAnsi );
//+----------------------------------------------------------------------------
//
// Function:
// UtCopyFormatEtc, internal
//
// Synopsis:
// Copies a format etc, creating copies of data structures
// pointed to inside (the target device descriptor.)
//
// Arguments:
// [pFetcIn] -- pointer to the FORMATETC to copy
// [pFetcCopy] -- pointer to where to copy the FORMATETC to
//
// Returns:
// FALSE if pointed to data could not be copied because it
// could not be allocated
// TRUE otherwise
//
// Notes:
//
// History:
// 11/01/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL_(BOOL) UtCopyFormatEtc(FORMATETC FAR* pFetcIn, FORMATETC FAR* pFetcCopy);
//+----------------------------------------------------------------------------
//
// Function:
// UtCompareFormatEtc, internal
//
// Synopsis:
//
// Arguments:
// [pFetcLeft] -- pointer to a FORMATETC
// [pFetcRight] -- pointer to a FORMATETC
//
// Returns:
// UTCMPFETC_EQ is the two FORMATETCs match exactly
// UTCMPFETC_NEQ if the two FORMATETCs do not match
// UTCMPFETC_PARTIAL if the left FORMATETC is a subset of the
// right: fewer aspects, null target device, or
// fewer media
//
// Notes:
//
// History:
// 11/01/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL_(int) UtCompareFormatEtc(FORMATETC FAR* pFetcLeft, FORMATETC FAR* pFetcRight);#define UTCMPFETC_EQ 0 /* exact match */
#define UTCMPFETC_NEQ 1 /* no match */
#define UTCMPFETC_PARTIAL (-1) /* partial match; left is subset of right */
//+----------------------------------------------------------------------------
//
// Function:
// UtCompareTargetDevice, internal
//
// Synopsis:
// Compares two target devices to see if they are the same
//
// Arguments:
// [ptdLeft] -- pointer to a target device description
// [ptdRight] -- pointer to a target device description
//
// Returns:
// TRUE if the two devices are the same, FALSE otherwise
//
// Notes:
//
// History:
// 11/01/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL_(BOOL) UtCompareTargetDevice(DVTARGETDEVICE FAR* ptdLeft, DVTARGETDEVICE FAR* ptdRight);
//+----------------------------------------------------------------------------
//
// Function:
// UtCopyStatData, internal
//
// Synopsis:
// Copies the contents of one STATDATA into another, including
// creating a copy of data pointed to, and incrementing the
// reference count on the advise sink to reflect the copy.
//
// Arguments:
// [pSDIn] -- the source STATDATA
// [pSDCopy] -- where to copy the information to
//
// Returns:
// FALSE if memory could not be allocated for the copy of
// the target device, TRUE otherwise
//
// Notes:
//
// History:
// 11/01/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL_(BOOL) UtCopyStatData(STATDATA FAR* pSDIn, STATDATA FAR* pSDCopy);
//+----------------------------------------------------------------------------
//
// Function:
// UtReleaseStatData, internal
//
// Synopsis:
// Release resources associated with the argument STATDATA; this
// frees the device description within the FORMATETC, and releases
// the advise sink, if there is one.
//
// Arguments:
// [pStatData] -- The STATDATA to clean up
//
// Notes:
//
// History:
// 11/01/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL_(void) UtReleaseStatData(STATDATA FAR* pStatData);
//+----------------------------------------------------------------------------
//
// Function:
// UtDupPalette, internal
//
// Synopsis:
// Creates a duplicate palette.
//
// Arguments:
// [hpalette] -- the palette to duplicate
//
// Returns:
// if successful, a handle to the duplicate palette; if any
// allocations or calls fail during the duplication process, NULL
//
// History:
// 11/29//93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL_(HPALETTE) UtDupPalette(HPALETTE hpalette);
//+----------------------------------------------------------------------------
//
// Function:
// UtPaletteSize, internal
//
// Synopsis:
// Returns the size of a color table for a palette given the
// number of bits of color desired.
//
// Arguments:
// [lpHeader] -- ptr to BITMAPINFOHEADER structure
//
// Returns:
// Size in bytes of color information
//
// Notes:
//
// History:
// 11/29/93 - ChrisWe - change bit count argument to unsigned,
// and return value to size_t
//
// 07/18/94 - DavePl - Fixed for 16, 24, 32bpp DIBs
//
//-----------------------------------------------------------------------------
FARINTERNAL_(size_t) UtPaletteSize(BITMAPINFOHEADER *);
//+----------------------------------------------------------------------------
//
// Function:
// UtFormatToTymed, internal
//
// Synopsis:
// Maps a clipboard format to a medium used to transport it.
//
// Arguments:
// [cf] -- the clipboard format to map
//
// Returns:
// a TYMED_* value
//
// Notes:
//
// History:
// 11/29/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL_(DWORD) UtFormatToTymed(CLIPFORMAT cf);
//+----------------------------------------------------------------------------
//
// Function:
// UtQueryPictFormat, internal
//
// Synopsis:
// Check to see if the argument data object supports one of
// our preferred data formats for presentations:
// CF_METAFILEPICT, CF_DIB, CF_BITMAP, in that order. Returns
// TRUE, if success, and alters the given format descriptor
// to match the supported format. The given format descriptor
// is not altered if there is no match.
//
// Arguments:
// [lpSrcDataObj] -- the data object to query
// [lpforetc] - the format descriptor
//
// Returns:
// TRUE if a preferred format is found, FALSE otherwise
//
// Notes:
//
// History:
// 11/09/93 - ChrisWe - modified to not alter the descriptor
// if no match is found
// 11/09/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL_(BOOL) UtQueryPictFormat(LPDATAOBJECT lpSrcDataObj, LPFORMATETC lpforetc);
//+----------------------------------------------------------------------------
//
// Function:
// UtConvertDibToBitmap, internal
//
// Synopsis:
// Converts a DIB to a bitmap, returning a new handle to the
// bitmap. The original DIB is left untouched.
//
// Arguments:
// [hDib] -- handle to the DIB to convert
//
// Returns:
// if successful, and handle to the new bitmap
//
// Notes:
// REVIEW, the function uses the screen DC when creating the
// new bitmap. It may be the case that the bitmap was intended
// for another target, in which case this may not be appropriate.
// It may be necessary to alter this function to take a DC as
// an argument.
//
// History:
// 11/29/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL_(HBITMAP) UtConvertDibToBitmap(HANDLE hDib);
//+----------------------------------------------------------------------------
//
// Function:
// UtConvertBitmapToDib, internal
//
// Synopsis:
// Creates a Device Independent Bitmap capturing the content of
// the argument bitmap.
//
// Arguments:
// [hBitmap] -- Handle to the bitmap to convert
// [hpal] -- color palette for the bitmap; may be null for
// default stock palette
//
// Returns:
// Handle to the DIB. May be null if any part of the conversion
// failed.
//
// Notes:
//
// History:
// 11/29/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL_(HANDLE) UtConvertBitmapToDib(HBITMAP hBitmap, HPALETTE hpal);
//+----------------------------------------------------------------------------
//
// Function:
// UtGetClassId, internal
//
// Synopsis:
// Attempt to find the class id of the object. First,
// query for IOleObject, and if successful, call
// IOleObject::GetUserClassID(). If that fails, query for
// IPersist, and if successful, call IPersist::GetClassID.
//
// Arguments:
// [lpUnk] -- pointer to an IUnknown instance
// [lpClsid] -- pointer to where to copy the class id to
//
// Returns:
// TRUE, if the class id was obtained, or FALSE otherwise
// If unsuccessful, *[lpClsid] is set to CLSID_NULL
//
// Notes:
//
// History:
// 11/29/93 - ChrisWe - change to return BOOL to indicate success
//
//-----------------------------------------------------------------------------
FARINTERNAL_(BOOL) UtGetClassID(LPUNKNOWN lpUnk, CLSID FAR* lpClsid);
//+----------------------------------------------------------------------------
//
// Function:
// UtCopyTargetDevice, internal
//
// Synopsis:
// Allocates a new target device description, and copies
// the given one into it
//
// Arguments:
// [ptd] -- pointer to a target device
//
// Returns:
// NULL, if the no memory can be allocated
//
// Notes:
//
// History:
// 11/01/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL_(DVTARGETDEVICE FAR*) UtCopyTargetDevice(DVTARGETDEVICE FAR* ptd);
//+----------------------------------------------------------------------------
//
// Function:
// UtGetIconData, internal
//
// Synopsis:
// Attempts to get the icon for an object.
//
// Arguments:
// [lpSrcDataObj] -- The source data object
// [rclsid] -- the class id the object is known to be
// (may be CLSID_NULL)
// [lpforetc] -- the format of the data to fetch
// [lpstgmed] -- a place to return the medium it was fetched on
//
// Returns:
// E_OUTOFMEMORY, S_OK
//
// Notes:
// REVIEW, this method seems to assume that the contents of
// lpforetc are correct for fetching an icon. It passes this
// on to [lpSrcDataObj]->GetData first, and if that fails,
// calls OleGetIconOfClass, without checking the requested
// format in lpforetc. This could fetch anything
//
// History:
// 11/30/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL UtGetIconData(LPDATAOBJECT lpSrcDataObj, REFCLSID rclsid, LPFORMATETC lpforetc, LPSTGMEDIUM lpstgmed);
//+----------------------------------------------------------------------------
//
// Function:
// UtDoStreamOperation, internal
//
// Synopsis:
// Iterate over the streams in [pstgSrc], performing the
// operation indicated by [iOpCode] to those that are specified
// by [grfAllowedStmTypes].
//
// Arguments:
// [pstgSrc] -- source IStorage instance
// [pstgDst] -- destination IStorage instance; may be null for
// some operations (OPCODE_REMOVE)
// [iOpCode] -- 1 value from the OPCODE_* values below
// [grfAllowedStmTypes] -- a logical or of one or more of the
// STREAMTYPE_* values below
//
// Returns:
// HRESULT
//
// Notes:
//
// History:
// 11/30/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
STDAPI UtDoStreamOperation(LPSTORAGE pstgSrc, LPSTORAGE pstgDst, int iOpCode, DWORD grfAllowedStmTypes);
#define OPCODE_COPY 1 /* copy the stream from pstgSrc to pstgDst */
#define OPCODE_REMOVE 2 /* delete the stream from pstgSrc */
#define OPCODE_MOVE 3 /* move the stream from pstgSrc to pstgDst */
#define OPCODE_EXCLUDEFROMCOPY 4
/* unimplemented, undocumented, intent unknown */
#define STREAMTYPE_CONTROL 0x00000001 /* OLE 0x1 stream (REVIEW const) */
#define STREAMTYPE_CACHE 0x00000002 /* OLE 0x2 stream (REVIEW const) */
#define STREAMTYPE_CONTAINER 0x00000004 /* OLE 0x3 stream (REVIEW const) */
#define STREAMTYPE_OTHER \
(~(STREAMTYPE_CONTROL | STREAMTYPE_CACHE | STREAMTYPE_CONTAINER))#define STREAMTYPE_ALL 0xFFFFFFFF /* all stream types are allowed */
//+----------------------------------------------------------------------------
//
// Function:
// UtGetPresStreamName, internal
//
// Synopsis:
// Modify [lpszName] to be a presentation stream name based
// on [iStreamNum].
//
// Arguments:
// [lpszName] -- a copy of OLE_PRESENTATION_STREAM; see below
// [iStreamNum] -- the number of the stream
//
// Notes:
// The digit field of [lpszName] is always completely overwritten,
// allowing repeated use of UtGetPresStreamName() on the same
// string; this removes the need to repeatedly start with a fresh
// copy of OLE_PRESENTATION_STREAM each time this is used in a
// loop.
//
// The validity of the implementation depends on the values of
// OLE_PRESENTATION_STREAM and OLE_MAX_PRES_STREAMS; if those
// change, the implementation must change
//
// History:
// 11/30/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL_(void)UtGetPresStreamName(LPOLESTR lpszName, int iStreamNum);
//+----------------------------------------------------------------------------
//
// Function:
// UtRemoveExtraOlePresStreams, internal
//
// Synopsis:
// Deletes presentation streams in [pstg] starting with the
// presentation numbered [iStart]. All streams after that one
// (numbered sequentially) are deleted, up to OLE_MAX_PRES_STREAMS.
//
// Arguments:
// [pstg] -- the IStorage instance to operate on
// [iStart] -- the number of the first stream to remove
//
// Returns:
//
// Notes:
// The presentation stream names are generated with
// UtGetPresStreamName().
//
// History:
// 11/30/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL_(void) UtRemoveExtraOlePresStreams(LPSTORAGE pstg, int iStart);
//+-------------------------------------------------------------------------
//
// Function: UtCreateStorageOnHGlobal
//
// Synopsis: creates a storage on top of an HGlobal
//
// Effects:
//
// Arguments: [hGlobal] -- the memory on which to create the
// storage
// [fDeleteOnRelease] -- if TRUE, then delete the memory
// ILockBytes once the storage is
// released.
// [ppStg] -- where to put the storage interface
// [ppILockBytes] -- where to put the underlying ILockBytes,
// maybe NULL. The ILB must be released.
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm: create an ILockBytes on HGLOBAL and then create the docfile
// on top of the ILockBytes
//
// History: dd-mmm-yy Author Comment
// 07-Apr-94 alexgo author
//
// Notes:
//
//--------------------------------------------------------------------------
HRESULT UtCreateStorageOnHGlobal( HGLOBAL hGlobal, BOOL fDeleteOnRelease, IStorage **ppStg, ILockBytes **ppILockBytes );
//+-------------------------------------------------------------------------
//
// Function: UtGetTempFileName
//
// Synopsis: retrieves a temporary filename (for use in GetData, TYMED_FILE
// and temporary docfiles)
//
// Effects:
//
// Arguments: [pszPrefix] -- prefix of the temp filename
// [pszTempName] -- buffer that will receive the temp path.
// must be MAX_PATH or greater.
//
// Requires:
//
// Returns: HRESULT;
//
// Signals:
//
// Modifies:
//
// Algorithm: tries to get a file in the temp directory, failing that, in
// the windows directory
//
// History: dd-mmm-yy Author Comment
// 07-Apr-94 alexgo author
//
// Notes:
//
//--------------------------------------------------------------------------
HRESULT UtGetTempFileName( LPOLESTR pszPrefix, LPOLESTR pszTempName );
//+----------------------------------------------------------------------------
//
// Function:
// UtHGLOBALToStm, internal
//
// Synopsis:
// Write the contents of an HGLOBAL to a stream
//
// Arguments:
// [hdata] -- handle to the data to write out
// [dwSize] -- size of the data to write out
// [pstm] -- stream to write the data out to; on exit, the
// stream is positioned after the written data
//
// Returns:
// HRESULT
//
// Notes:
//
// History:
// 11/30/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
HRESULT UtHGLOBALtoStm(HANDLE hdata, DWORD dwSize, LPSTREAM pstm);
//+-------------------------------------------------------------------------
//
// Function: UtHGLOBALtoHGLOBAL, internal
//
// Synopsis: Copies the source HGLOBAL into the target HGLOBAL
//
// Effects:
//
// Arguments: [hGlobalSrc] -- the source HGLOBAL
// [dwSize] -- the number of bytes to copy
// [hGlobalTgt] -- the target HGLOBAL
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 10-Apr-94 alexgo author
//
// Notes: this function will fail if the target hglobal is not large
// enough
//
//--------------------------------------------------------------------------
HRESULT UtHGLOBALtoHGLOBAL( HGLOBAL hGlobalSrc, DWORD dwSize, HGLOBAL hGlobalTgt);
//+-------------------------------------------------------------------------
//
// Function: UtHGLOBALtoStorage, internal
//
// Synopsis: Copies the source HGLOBAL into the target storage
//
// Effects:
//
// Arguments: [hGlobalSrc] -- the source HGLOBAL
// [hpStg] -- the target storage
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 10-Apr-94 alexgo author
//
// Notes: this function will fail if the source HGLOBAL did not
// originally have a storage layered on top of it.
//
//--------------------------------------------------------------------------
HRESULT UtHGLOBALtoStorage( HGLOBAL hGlobalSrc, IStorage *pStg);
//+-------------------------------------------------------------------------
//
// Function: UtHGLOBALtoFile, internal
//
// Synopsis: Copies the source HGLOBAL into the target file
//
// Effects:
//
// Arguments: [hGlobalSrc] -- the source HGLOBAL
// [dwSize] -- the number of bytes to copy
// [pszFileName] -- the target file
//
// Requires:
//
// Returns: HRESULT
//
// Signals:
//
// Modifies:
//
// Algorithm:
//
// History: dd-mmm-yy Author Comment
// 10-Apr-94 alexgo author
//
// Notes:
//
//--------------------------------------------------------------------------
HRESULT UtHGLOBALtoFile( HGLOBAL hGlobalSrc, DWORD dwSize, LPCOLESTR pszFileName);
/*** Following routines can be found in convert.cpp *****/
//+----------------------------------------------------------------------------
//
// Function:
// UtGetHGLOBALFromStm, internal
//
// Synopsis:
// Create a new HGLOBAL, and read [dwSize] bytes into it
// from [lpstream].
//
// Arguments:
// [lpstream] -- the stream to read the content of the new
// HGLOBAL from; on exit, points just past the data read
// [dwSize] -- the amount of material to read from the stream
// [lphPres] -- pointer to where to return the new handle
//
// Returns:
// HRESULT
//
// Notes:
// In case of any error, the new handle is freed. If the
// amount of material expected from [lpstream] is less than
// [dwSize], nothing is returned.
//
// History:
// 11/30/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL UtGetHGLOBALFromStm(LPSTREAM lpstream, DWORD dwSize, HANDLE FAR* lphPres);
//+----------------------------------------------------------------------------
//
// Function:
// UtGetHDIBFromDIBFileStm, internal
//
// Synopsis:
// Produce a handle to a DIB from a file stream
//
// Arguments:
// [pstm] -- the stream to read the DIB from; on exit, the
// stream is positioned just past the data read
// [lphdata] -- pointer to where to return the handle to the data
//
// Returns:
// HRESULT
//
// Notes:
//
// History:
// 11/30/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL UtGetHDIBFromDIBFileStm(LPSTREAM pstm, HANDLE FAR* lphdata);
//+----------------------------------------------------------------------------
//
// Function:
// UtGetHMFPICT, internal
//
// Synopsis:
// Given a handle to a METAFILE, conjure up a handle to a
// METAFILEPICT, based on the metafile
//
// Arguments:
// [hMF] -- handle to the METAFILE
// [fDeleteOnError] -- if TRUE, delete the METAFILE [hMF] in there
// is any error
// [xExt] -- the x extent of the desired METAFILEPICT
// [yExt] -- the y extent of the desired METAFILEPICT
//
// Returns:
// Handle to the new METAFILEPICT, if successful, or NULL
//
// Notes:
//
// History:
// 11/30/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL_(HANDLE) UtGetHMFPICT(HMETAFILE hMF, BOOL fDeletOnError, DWORD xExt, DWORD yExt);
//+----------------------------------------------------------------------------
//
// Function:
// UtGetHMFFromMFStm, internal
//
// Synopsis:
// Create a handle to a METAFILE, loaded with content from
// the given stream
//
// Arguments:
// [lpstream] -- the source stream to initialize the METAFILE with;
// on exit, the stream is positioned just past the
// data read
// [dwSize] -- the amount of material to read from [lpstream]
// [fConvert] -- if TRUE, tries to convert a Macintosh QuickDraw
// file to METAFILE format
// [lphPres] -- pointer to where to return the new handle to
// the metafile
//
// Returns:
// HRESULT
//
// Notes:
// If [dwSize] is too large, and goes past the end of the
// stream, the error causes everything allocated to be freed,
// and nothing is returned in [lphPres].
//
// History:
// 11/30/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL UtGetHMFFromMFStm(LPSTREAM lpstream, DWORD dwSize, BOOL fConvert, HANDLE FAR* lphPres);
//+----------------------------------------------------------------------------
//
// Function:
// UtGetSizeAndExtentsFromPlaceableMFStm, internal
//
// Synopsis:
// Obtain the size, width, and height of the metafile stored
// in a placeable metafile stream.
//
// Arguments:
// [lpstream] -- the stream to read the placeable metafile
// from; on exit, the stream is positioned at the
// beginning of the metafile header, after the
// placeable metafile header.
// [pdwSize] -- a pointer to where to return the size of the
// metafile; may be NULL
// [plWidth] -- a pointer to where to return the width of the
// metafile; may be NULL
// [plHeight] -- a pointer to where to return the height of the
// metafile; may be NULL
//
// Returns:
// HRESULT
//
// Notes:
//
// History:
// 11/30/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL UtGetSizeAndExtentsFromPlaceableMFStm(LPSTREAM pstm, DWORD FAR* dwSize, LONG FAR* plWidth, LONG FAR* plHeight);
//+----------------------------------------------------------------------------
//
// Function:
// UtGetHMFPICTFromPlaceableMFStm, internal
//
// Synopsis:
// Create a handle to a METAFILEPICT initialized from a
// placeable METAFILE stream.
//
// Arguments:
// [pstm] -- the stream to load the METAFILE from; on exit
// points just past the METAFILE data
// [lphdata] -- pointer to where to return the handle to the
// new METAFILEPICT
//
// Returns:
// HRESULT
//
// Notes:
//
// History:
// 11/30/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL UtGetHMFPICTFromPlaceableMFStm(LPSTREAM pstm, HANDLE FAR* lphdata);
//+----------------------------------------------------------------------------
//
// Function:
// UtGetDibExtents, internal
//
// Synopsis:
// Return the width and height of a DIB, in HIMETRIC units
// per pixel.
//
// Arguments:
// [lpbmi] -- pointer to a BITMAPINFOHEADER
// [plWidth] -- pointer to where to return the width
// REVIEW, this should be a DWORD
// [plHeight] -- pointer to where to return the height
// REVIEW, this should be a DWORD
//
// Notes:
//
// History:
// 12/02/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL_(void) UtGetDibExtents(LPBITMAPINFOHEADER lpbmi, LONG FAR* plWidth, LONG FAR* plHeight);#ifdef LATER
FARINTERNAL_(void) UtGetDibExtents(LPBITMAPINFOHEADER lpbmi, DWORD FAR* pdwWidth, DWORD FAR* pdwHeight);#endif
//+----------------------------------------------------------------------------
//
// Function:
// UtHDIBToDIBFileStm, internal
//
// Synopsis:
// Given a handle to a DIB, write out out a DIB file stream.
//
// Arguments:
// [hdata] -- handle to the DIB
// [dwSize] -- the size of the DIB
// [pstm] -- the stream to write the DIB out to; on exit, the
// stream is positioned after the DIB data; the DIB
// data is prepended with a BITMAPFILEHEADER
//
// Returns:
// HRESULT
//
// Notes:
//
// History:
// 12/02/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL UtHDIBToDIBFileStm(HANDLE hdata, DWORD dwSize, LPSTREAM pstm);
//+----------------------------------------------------------------------------
//
// Function:
// UtDIBStmToDIBFileStm, internal
//
// Synopsis:
// copy convert a DIB in a stream to a DIB file stream
//
// Arguments:
// [pstmDIB] -- the source DIB
// REVIEW, what does CopyTo do to the stream pointer?
// [dwSize] -- the size of the source DIB
// [pstmDIBFile] -- where to write the converted DIB file stream;
// should not be the same as [pstmDIB]; on exit, the
// stream is positioned after the DIB file data
//
// Returns:
// HRESULT
//
// Notes:
//
// History:
// 12/02/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL UtDIBStmToDIBFileStm(LPSTREAM pstmDIB, DWORD dwSize, LPSTREAM pstmDIBFile);
//+----------------------------------------------------------------------------
//
// Function:
// UtHDIBFileToOlePresStm, internal
//
// Synopsis:
// Given a handle to a DIB file, write it out to a stream
//
// Arguments:
// [hdata] -- the handle to the DIB file
// [pstm] -- the stream to write it out to; on exit, the
// stream is positioned after the written data
//
// Returns:
// HRESULT
//
// Notes:
// A small header with size information precedes the DIB file
// data.
//
// History:
// 12/02/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL UtHDIBFileToOlePresStm(HANDLE hdata, LPSTREAM pstm);
//+----------------------------------------------------------------------------
//
// Function:
// UtHMFToMFStm, internal
//
// Synopsis:
// Given a handle to a METAFILE, write it out to a METAFILE stream
//
// Arguments:
// [lphMF] -- a *pointer* to a handle to a METAFILE
// REVIEW, why is this a pointer?
// [dwSize] -- the size of the METAFILE
// [lpstream] -- the stream to write the METAFILE out to; on
// exit, the stream is positioned after the written data
//
// Returns:
// HRESULT
//
// Notes:
//
// History:
// 12/02/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL UtHMFToMFStm(HANDLE FAR* lphMF, DWORD dwSize, LPSTREAM lpstream);
//+----------------------------------------------------------------------------
//
// Function:
// UtHMFToPlaceableMFStm, internal
//
// Synopsis:
// Given a handle to a METAFILE, write it to a stream as a
// placeable METAFILE
//
// Arguments:
// [lphMF] -- a *pointer* to a METAFILE handle
// REVIEW, why is this a pointer?
// [dwSize] -- size of the METAFILE
// [lWidth] -- width of the metafile
// REVIEW, in what units?
// REVIEW, why isn't this a DWORD?
// [lHeight] -- height of the metafile
// REVIEW, in what units?
// REVIEW, why isn't this a DWORD?
// [pstm] -- the stream to write the data to; on exit, the stream
// is positioned after the written data
//
// Returns:
// HRESULT
//
// Notes:
//
// History:
// 12/02/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL UtHMFToPlaceableMFStm(HANDLE FAR* lphMF, DWORD dwSize, LONG lWidth, LONG lHeight, LPSTREAM pstm);
//+----------------------------------------------------------------------------
//
// Function:
// UtNFStmToPlaceableMFStm, internal
//
// Synopsis:
// Copy converts a METAFILE in a stream to a placeable METAFILE
// in another stream.
//
// Arguments:
// [pstmMF] -- the IStream instance from which to read the
// original METAFILE, positioned at the METAFILE
// REVIEW, where does CopyTo leave this stream pointer?
// [dwSize] -- the size of the source METAFILE
// [lWidth] -- the width of the source METAFILE
// REVIEW, in what units?
// REVIEW, why isn't this a DWORD?
// [lHeight] -- the height of the source METAFILE
// REVIEW, in what units?
// REVIEW, why isn't this a DWORD?
// [pstmPMF] -- the IStream instance to which to write the
// placeable METAFILE; on exit, the stream is positioned
// after the written data
//
// Returns:
// HRESULT
//
// Notes:
//
// History:
// 12/02/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL UtMFStmToPlaceableMFStm(LPSTREAM pstmMF, DWORD dwSize, LONG lWidth, LONG lHeight, LPSTREAM pstmPMF);
//+----------------------------------------------------------------------------
//
// Function:
// UtWriteOlePresStmHeader, internal
//
// Synopsis:
// Write out the header information for an Ole presentation stream.
//
// Arguments:
// [lpstream] -- the stream to write to; on exit, the stream is
// positioned after the header information
// [pforetc] -- pointer to the FORMATETC for the presentation
// data
// [dwAdvf] -- the advise control flags for this presentation
//
// Returns:
// HRESULT
//
// Notes:
// This writes the clipboard information, the target device
// information, if any, some FORMATETC data, and the advise
// control flags.
//
// History:
// 12/02/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL UtWriteOlePresStmHeader(LPSTREAM lppstream, LPFORMATETC pforetc, DWORD dwAdvf);
//+----------------------------------------------------------------------------
//
// Function:
// UtReadOlePresStmHeader, internal
//
// Synopsis:
// Reads the presentation description information from an Ole
// presentation stream, as written by
// UtWriteOlePresStmHeader().
//
// Arguments:
// [pstm] -- the IStream instance to read the presentation
// description data from
// [pforetc] -- pointer to the FORMATETC to initialize based
// on data in the stream
// [pdwAdvf] -- pointer to where to put the advise flags for
// this presentation; may be NULL
// [pfConvert] -- pointer to a flag that is set to TRUE if
// the presentation will require conversion from
// Macintosh PICT format.
//
// Returns:
// HRESULT
//
// Notes:
//
// History:
// 12/02/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL UtReadOlePresStmHeader(LPSTREAM pstm, LPFORMATETC pforetc, DWORD FAR* pdwAdvf, BOOL FAR* pfConvert);
//+----------------------------------------------------------------------------
//
// Function:
// UtOlePresStmToContentsStm, internal
//
// Synopsis:
// Copy the content of a presentation stream to a contents stream,
// adjusting the format as necessary.
//
// Arguments:
// [pstg] -- the IStorage instance in which the presentation
// stream is, and in which to create the contents stream
// [lpszPresStm] -- the name of the source presentation stream
// [fDeletePresStm] -- flag that indicates that the presentation
// stream should be deleted if the copy and convert is
// successful. This is ignored if the source was
// DVASPECT_ICON.
// [puiStatus] -- pointer to a UINT where status bits from
// the CONVERT_* values below may be returned.
//
// Returns:
// HRESULT
//
// Notes:
// The content stream is named by the constant OLE_CONTENTS_STREAM.
//
// History:
// 12/05/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL UtOlePresStmToContentsStm(LPSTORAGE pstg, LPOLESTR lpszPresStm, BOOL fDeletePresStm, UINT FAR* puiStatus);#define CONVERT_NOSOURCE 0x0001
#define CONVERT_NODESTINATION 0x0002
#define CONVERT_SOURCEISICON 0x0004
// 2nd variation
FARINTERNAL UtOlePresStmToContentsStm(LPSTORAGE pSrcStg, LPOLESTR lpszPresStm, LPSTREAM pDestStm, UINT FAR* puiStatus);
FARINTERNAL UtGetHMFPICTFromMSDrawNativeStm(LPSTREAM pstm, DWORD dwSize, HANDLE FAR* lphdata);
FARINTERNAL UtPlaceableMFStmToMSDrawNativeStm(LPSTREAM pstmPMF, LPSTREAM pstmMSDraw); FARINTERNAL UtDIBFileStmToPBrushNativeStm(LPSTREAM pstmDIBFile, LPSTREAM pstmPBrush);
FARINTERNAL UtContentsStmTo10NativeStm(LPSTORAGE pstg, REFCLSID rclsid, BOOL fDeleteContents, UINT FAR* puiStatus);
FARINTERNAL Ut10NativeStmToContentsStm(LPSTORAGE pstg, REFCLSID rclsid, BOOL fDeleteSrcStm);
//+----------------------------------------------------------------------------
//
// Function:
// UtGetHPRESFromNative, internal
//
// Synopsis:
// Get a handle to a presentation from a native representation.
//
// Arguments:
// [pstg] -- the storage in which the native content is
// [cfFormat] -- the native format to attempt to read
// [fOle10Native] -- attempt to read the OLE10_NATIVE_STREAM
// stream in that format; if this is FALSE, we read the
// OLE_CONTENTS_STREAM
//
// Returns:
// HRESULT
//
// Notes:
//
// History:
// 12/05/93 - ChrisWe - file inspection and cleanup
//
//-----------------------------------------------------------------------------
FARINTERNAL_(HANDLE) UtGetHPRESFromNative(LPSTORAGE pstg, LPSTREAM pstm, CLIPFORMAT cfFormat, BOOL fOle10Native);
//+-------------------------------------------------------------------------
//
// Function: ConvertPixelsToHIMETRIC
//
// Synopsis: Converts a pixel dimension to HIMETRIC units
//
// Effects:
//
// Arguments: [hdcRef] -- the reference DC
// [ulPels] -- dimension in pixel measurement
// [pulHIMETRIC] -- OUT param of converted HIMETRIC result
// [tDimension] -- indicates XDIMENSION or YDIMENSION of input
//
// Returns: S_OK, E_FAIL
//
// Algorithm: screen_mm * input_pels HIMETRICS/
// ---------------------- * / == HIMETRICS
// screen_pels /mm
//
// History: dd-mmm-yy Author Comment
// 04-Aug-94 Davepl Created
//
// Notes: We need to know whether the input size is in the X or
// Y dimension, since the aspect ratio could vary
//
//--------------------------------------------------------------------------
// This enumeration is used to indicate in which diretion a
// dimension, when passed as a parameter, is to be relative to.
// This is needed for our Pixel -> HIMETRIC conversion function,
// since the aspect ratio could vary by dimension.
typedef enum tagDIMENSION{ XDIMENSION = 'X', YDIMENSION = 'Y'} DIMENSION;
FARINTERNAL ConvertPixelsToHIMETRIC (HDC hdcRef, ULONG lPels, ULONG * pulHIMETRIC, DIMENSION tDimension);
//+-------------------------------------------------------------------------
//
// Function: IsTaskName
//
// Synopsis: Determines if the passed name is the current task
//
// Effects:
//
// Arguments: [lpszIn] -- Task name
//
// Returns: TRUE, FALSE
//
// History: dd-mmm-yy Author Comment
// 03-Mar-95 Scottsk Created
//
// Notes:
//
//--------------------------------------------------------------------------
FARINTERNAL_(BOOL) IsTaskName(LPCWSTR lpszIn);
//+-------------------------------------------------------------------------
//
// Function: utGetModuleName
//
// Synopsis: Get Module Name for current module
//
// Effects:
//
// Arguments: [lpszModuleName] -- Buffer to hold module name
// [dwLength] -- length in characters
//
// Returns: S_OK, E_UNEXPECTED, E_OUTOFMEMORY
//
// History: dd-mmm-yy Author Comment
// 06-Feb-97 Ronans Created
//
//--------------------------------------------------------------------------
FARINTERNAL utGetModuleName(LPWSTR lpszModuleName, DWORD dwLength);
//+-------------------------------------------------------------------------
//
// Function: utGetAppIdForModule
//
// Synopsis: Get AppID for the current module in string form
//
// Effects:
//
// Arguments: [lpszAppId] -- Buffer to hold string represntation of AppId
// [dwLength] -- length of buffer in characters
//
// Returns: S_OK, E_UNEXPECTED, E_OUTOFMEMORY or error value from
// registry functions.
//
// History: dd-mmm-yy Author Comment
// 06-Feb-97 Ronans Created
//
//--------------------------------------------------------------------------
FARINTERNAL utGetAppIdForModule(LPWSTR lpszAppId, DWORD dwLength);
//+-------------------------------------------------------------------------
//
// Function: UtGetDvtd16Info
// UtConvertDvtd16toDvtd32
//
// UtGetDvtd32Info
// UtConvertDvtd32toDvtd16
//
// Synopsis: Utility functions for converting Ansi to Unicode DVTARGETDEVICEs
//
// Algorithm: UtGetDvtdXXInfo gets sizing data, which is then passed to
// UtConvertDvtdXXtoDvtdXX to perform the conversion.
//
// History: 06-May-94 AlexT Created
//
// Notes: Here's a sample usage of these functions:
//
// // pdvtd16 is a Ansi DVTARGETDEVICE
// DVTDINFO dvtdInfo;
// DVTARGETDEVICE pdvtd32;
//
// hr = UtGetDvtd16Info(pdvtd16, &dvtdInfo);
// // check hr
// pdvtd32 = CoTaskMemAlloc(dvtdInfo.cbConvertSize);
// // check pdvtd32
// hr = UtConvertDvtd16toDvtd32(pdvtd16, &dvtdInfo, pdvtd32);
// // check hr
// // pdvtd32 now contains the converted data
//
//--------------------------------------------------------------------------
typedef struct{ UINT cbConvertSize; UINT cchDrvName; UINT cchDevName; UINT cchPortName;} DVTDINFO, *PDVTDINFO;
extern "C" HRESULT UtGetDvtd16Info(DVTARGETDEVICE const UNALIGNED *pdvtd16, PDVTDINFO pdvtdInfo);extern "C" HRESULT UtConvertDvtd16toDvtd32(DVTARGETDEVICE const UNALIGNED *pdvtd16, DVTDINFO const *pdvtdInfo, DVTARGETDEVICE *pdvtd32);extern "C" HRESULT UtGetDvtd32Info(DVTARGETDEVICE const *pdvtd32, PDVTDINFO pdvtdInfo);extern "C" HRESULT UtConvertDvtd32toDvtd16(DVTARGETDEVICE const *pdvtd32, DVTDINFO const *pdvtdInfo, DVTARGETDEVICE UNALIGNED *pdvtd16);class CStdIdentity;
HRESULT CreateEmbeddingServerHandler(CStdIdentity *pStdId, IUnknown **ppunkServerHandler);
// Number to wide-char conversion routine. See xtow.c for description.
extern "C" BOOL __cdecl our_ultow( unsigned long val, wchar_t *buf, int bufsize, int radix );
#endif // _UTILS_H
|
