// -------------------------------------------------------------------------------- // Msoert.h // Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved // -------------------------------------------------------------------------------- // -------------------------------------------------------------------------------- // Debug Crap // -------------------------------------------------------------------------------- #include "msoedbg.h" // -------------------------------------------------------------------------------- // GUIDS // -------------------------------------------------------------------------------- #if !defined(__MSOERT_H) || defined(INITGUID) // {220D5CC1-853A-11d0-84BC-00C04FD43F8F} #ifdef ENABLE_RULES DEFINE_GUID(PST_IDENT_TYPE_GUID, 0x220d5cc3, 0x853a, 0x11d0, 0x84, 0xbc, 0x0, 0xc0, 0x4f, 0xd4, 0x3f, 0x8f); #elif defined(N_TEST) DEFINE_GUID(PST_IDENT_TYPE_GUID, 0x220d5cc2, 0x853a, 0x11d0, 0x84, 0xbc, 0x0, 0xc0, 0x4f, 0xd4, 0x3f, 0x8f); #else DEFINE_GUID(PST_IDENT_TYPE_GUID, 0x220d5cc1, 0x853a, 0x11d0, 0x84, 0xbc, 0x0, 0xc0, 0x4f, 0xd4, 0x3f, 0x8f); #endif // {417E2D75-84BD-11d0-84BB-00C04FD43F8F} #ifdef ENABLE_RULES DEFINE_GUID(PST_IMNACCT_SUBTYPE_GUID, 0x417e2d77, 0x84bd, 0x11d0, 0x84, 0xbb, 0x0, 0xc0, 0x4f, 0xd4, 0x3f, 0x8f); #elif defined(N_TEST) DEFINE_GUID(PST_IMNACCT_SUBTYPE_GUID, 0x417e2d76, 0x84bd, 0x11d0, 0x84, 0xbb, 0x0, 0xc0, 0x4f, 0xd4, 0x3f, 0x8f); #else DEFINE_GUID(PST_IMNACCT_SUBTYPE_GUID, 0x417e2d75, 0x84bd, 0x11d0, 0x84, 0xbb, 0x0, 0xc0, 0x4f, 0xd4, 0x3f, 0x8f); #endif // {6ADF2E20-8803-11d0-84BF-00C04FD43F8F} DEFINE_GUID(PST_CERTS_SUBTYPE_GUID, 0x6adf2e20, 0x8803, 0x11d0, 0x84, 0xbf, 0x0, 0xc0, 0x4f, 0xd4, 0x3f, 0x8f); #endif // !defined(__MSOERT_H) || defined(INITGUID) // -------------------------------------------------------------------------------- // Include the rest of the stuff // -------------------------------------------------------------------------------- #ifndef __MSOERT_H #define __MSOERT_H // -------------------------------------------------------------------------------- // Define API decoration for direct importing of DLL references. // -------------------------------------------------------------------------------- // OESTDAPI - Things exported from msoert2.dll (no debug exports) #if !defined(_MSOERT_) #define OESTDAPI_(type) EXTERN_C DECLSPEC_IMPORT type STDAPICALLTYPE #else // _MSOERT_ #define OESTDAPI_(type) STDAPI_(type) #endif // !_MSOERT_ #define DLLEXPORT __declspec(dllexport) #ifndef NOFLAGS #define NOFLAGS 0 #endif // -------------------------------------------------------------------------------- // IN OUT OPTIONS Definitions // -------------------------------------------------------------------------------- #ifndef OUT #define OUT #endif #ifndef IN #define IN #endif #ifndef IN_OUT #define IN_OUT #endif #ifndef IN_OPT #define IN_OPT #endif #ifndef OUT_OPT #define OUT_OPT #endif #ifndef IN_OUT_OPT #define IN_OUT_OPT #endif //WIn64 macros #ifdef _WIN64 #if defined (_AMD64_) || defined (_IA64_) #define ALIGNTYPE LARGE_INTEGER #else #define ALIGNTYPE DWORD #endif #define ALIGN ((ULONG) (sizeof(ALIGNTYPE) - 1)) #define LcbAlignLcb(lcb) (((lcb) + ALIGN) & ~ALIGN) #define PbAlignPb(pb) ((LPBYTE) ((((DWORD) (pb)) + ALIGN) & ~ALIGN)) #define MYALIGN ((POINTER_64_INT) (sizeof(ALIGNTYPE) - 1)) #define MyPbAlignPb(pb) ((LPBYTE) ((((POINTER_64_INT) (pb)) + MYALIGN) & ~MYALIGN)) #else //!WIN64 #define LcbAlignLcb(lcb) (lcb) #define PbAlignPb(pb) (pb) #define MyPbAlignPb(pb) (pb) #endif // -------------------------------------------------------------------------------- // CRLF Definitions // -------------------------------------------------------------------------------- #define wchCR L'\r' #define wchLF L'\n' #define chCR '\r' #define chLF '\n' #define szCRLF "\r\n" // -------------------------------------------------------------------------------- // Versioning Magic // -------------------------------------------------------------------------------- typedef enum tagOEDLLVERSION { OEDLL_VERSION_5=1 } OEDLLVERSION; #define OEDLL_VERSION_CURRENT OEDLL_VERSION_5 #define STR_GETDLLMAJORVERSION "GetDllMajorVersion" typedef OEDLLVERSION (APIENTRY *PFNGETDLLMAJORVERSION)(void); // -------------------------------------------------------------------------------- // RGB_AUTOCOLOR // -------------------------------------------------------------------------------- #define RGB_AUTOCOLOR ((COLORREF)-1) // -------------------------------------------------------------------------------- // NEXTID // -------------------------------------------------------------------------------- #define NEXTID(pidl) ((LPITEMIDLIST)(((BYTE *)(pidl))+(pidl)->mkid.cb)) #define PAD4(x) (((x)+3)&~3) // -------------------------------------------------------------------------------- // INLINE // -------------------------------------------------------------------------------- #ifdef INLINE #error define overlap #else // speed up debug build by turning off inline functions #ifdef DEBUG #define INLINE #else #define INLINE inline #endif #endif // -------------------------------------------------------------------------------- // IS_EXTENDED // -------------------------------------------------------------------------------- #define IS_EXTENDED(ch) \ ((ch > 126 || ch < 32) && ch != '\t' && ch != '\n' && ch != '\r') // -------------------------------------------------------------------------------- // Flag Utility Functions // -------------------------------------------------------------------------------- #define FLAGSET(_dw, _f) do {_dw |= (_f);} while (0) #define FLAGTOGGLE(_dw, _f) do {_dw ^= (_f);} while (0) #define FLAGCLEAR(_dw, _f) do {_dw &= ~(_f);} while (0) #define ISFLAGSET(_dw, _f) (BOOL)(((_dw) & (_f)) == (_f)) #define ISFLAGCLEAR(_dw, _f) (BOOL)(((_dw) & (_f)) != (_f)) // -------------------------------------------------------------------------------- // Used for building an IDataObject format enumerator // -------------------------------------------------------------------------------- #define SETDefFormatEtc(fe, cf, med) {\ (fe).cfFormat = ((CLIPFORMAT) (cf)); \ (fe).dwAspect = DVASPECT_CONTENT; \ (fe).ptd = NULL; \ (fe).tymed = med; \ (fe).lindex = -1; \ } // -------------------------------------------------------------------------------- // Some defines to create bit fields easier // -------------------------------------------------------------------------------- #define FLAG01 0x00000001 #define FLAG02 0x00000002 #define FLAG03 0x00000004 #define FLAG04 0x00000008 #define FLAG05 0x00000010 #define FLAG06 0x00000020 #define FLAG07 0x00000040 #define FLAG08 0x00000080 #define FLAG09 0x00000100 #define FLAG10 0x00000200 #define FLAG11 0x00000400 #define FLAG12 0x00000800 #define FLAG13 0x00001000 #define FLAG14 0x00002000 #define FLAG15 0x00004000 #define FLAG16 0x00008000 #define FLAG17 0x00010000 #define FLAG18 0x00020000 #define FLAG19 0x00040000 #define FLAG20 0x00080000 #define FLAG21 0x00100000 #define FLAG22 0x00200000 #define FLAG23 0x00400000 #define FLAG24 0x00800000 #define FLAG25 0x01000000 #define FLAG26 0x02000000 #define FLAG27 0x04000000 #define FLAG28 0x08000000 #define FLAG29 0x10000000 #define FLAG30 0x20000000 #define FLAG31 0x40000000 #define FLAG32 0x80000000 // -------------------------------------------------------------------------------- // Support Inclusion into a C file // -------------------------------------------------------------------------------- #ifdef __cplusplus extern "C" { #endif // -------------------------------------------------------------------------------- // Common String Lengths // -------------------------------------------------------------------------------- #define cchMaxDate 64 #define cchMaxTime 22 // -------------------------------------------------------------------------------- // ARRAYSIZE - Don't use this on extern'ed global data structures, it won't work // -------------------------------------------------------------------------------- #ifndef ARRAYSIZE #define ARRAYSIZE(_rg) (sizeof((_rg))/sizeof((_rg)[0])) #endif // ARRAYSIZE // -------------------------------------------------------------------------------- // HANDLE_COMMAND - Used in a WindowProc to simplify handling of WM_COMMAND messages // -------------------------------------------------------------------------------- #define HANDLE_COMMAND(hwnd, id, hwndCtl, codeNotify, fn) \ case (id): { (fn)((HWND)(hwnd), (HWND)(hwndCtl), (UINT)(codeNotify)); break; } // -------------------------------------------------------------------------------- // Standard Boolean Constants // -------------------------------------------------------------------------------- #define fFalse ((BOOL) 0) #define fTrue ((BOOL) 1) // -------------------------------------------------------------------------------- // Storage class macros // -------------------------------------------------------------------------------- #ifdef _X86_ #define BEGIN_CODESPACE_DATA data_seg(".rdata") #define BEGIN_NAME_CODESPACE_DATA(a) data_seg(".rdata$"#a, ".rdata") #define BEGIN_FUNCTION_CODESPACE_DATA data_seg(".rdata") #define END_CODESPACE_DATA data_seg() #define BEGIN_NAME_DATA(a) data_seg(".data$"#a, ".data") #define END_NAME_DATA data_seg() #else #define BEGIN_FUNCTION_CODESPACE_DATA #define BEGIN_NAME_CODESPACE_DATA(a) #define BEGIN_CODESPACE_DATA #define END_CODESPACE_DATA #define BEGIN_NAME_DATA(a) #define END_NAME_DATA #endif // -------------------------------------------------------------------------------- // Macro that causes the compiler to ignore a local variable or // parameter without generating a warning. // -------------------------------------------------------------------------------- #ifndef Unreferenced #define Unreferenced(a) ((void)a) #endif // -------------------------------------------------------------------------------- // SAFECAST - Insures that a cast is valid, otherwise it won't compile // -------------------------------------------------------------------------------- #define SAFECAST(_src, _type) (((_type)(_src)==(_src)?0:0), (_type)(_src)) // -------------------------------------------------------------------------------- // Computes the size of a member in a structure // -------------------------------------------------------------------------------- #define sizeofMember(s,m) sizeof(((s *)0)->m) #if 0 // -------------------------------------------------------------------------------- // Computes the byte offset to the parent class from a nested class // -------------------------------------------------------------------------------- #define _OEOffset(class, itf) ((UINT)&(((class *)0)->itf)) // -------------------------------------------------------------------------------- // Computes the parent interface of a nested class // -------------------------------------------------------------------------------- /------------------Merge Conflict------------------\ #define IToClass(class, itf, pitf) ((class *)(((LPSTR)pitf)-_OEOffset(class, itf))) #endif // -------------------------------------------------------------------------------- // SafeReleaseCnt - SafeRelease and set ulCount to the after release ref count // -------------------------------------------------------------------------------- #define SafeReleaseCnt(_object, _refcount) \ if (_object) { \ (_refcount) = (_object)->Release (); \ (_object) = NULL; \ } else // -------------------------------------------------------------------------------- // SafeRelease - Releases an object and sets the object to NULL // -------------------------------------------------------------------------------- #define SafeRelease(_object) \ if (_object) { \ (_object)->Release(); \ (_object) = NULL; \ } else // -------------------------------------------------------------------------------- // SafeFreeLibrary - Checks if _hinst is non null and then calls FreeLibrary // -------------------------------------------------------------------------------- #define SafeFreeLibrary(_hinst) \ if (_hinst) { \ FreeLibrary(_hinst); \ _hinst = NULL; \ } else // -------------------------------------------------------------------------------- // SafeCloseHandle // -------------------------------------------------------------------------------- #define SafeCloseHandle(_handle) \ if (_handle) { \ CloseHandle(_handle); \ _handle = NULL; \ } else // -------------------------------------------------------------------------------- // SafeUnmapViewOfFile // -------------------------------------------------------------------------------- #define SafeUnmapViewOfFile(_pView) \ if (_pView) { \ UnmapViewOfFile((LPVOID)_pView); \ _pView = NULL; \ } else // -------------------------------------------------------------------------------- // SafePidlFree // -------------------------------------------------------------------------------- #define SafePidlFree(_pidl) \ if (_pidl) { \ PidlFree(_pidl); \ _pidl = NULL; \ } else // -------------------------------------------------------------------------------- // SafeInternetCloseHandle // -------------------------------------------------------------------------------- #define SafeInternetCloseHandle(_handle) \ if (_handle) { \ InternetCloseHandle(_handle); \ _handle = NULL; \ } else // -------------------------------------------------------------------------------- // SafeDelete - safely deletes a non-referenced counted object // -------------------------------------------------------------------------------- #define SafeDelete(_obj) \ if (_obj) { \ delete _obj; \ _obj = NULL; \ } else // -------------------------------------------------------------------------------- // ReleaseObj - Releases an Object if it is not NULL // -------------------------------------------------------------------------------- #ifndef ReleaseObj #ifdef __cplusplus #define ReleaseObj(_object) (_object) ? (_object)->Release() : 0 #else #define ReleaseObj(_object) (_object) ? (_object)->lpVtbl->Release(_object) : 0 #endif // __cplusplus #endif // -------------------------------------------------------------------------------- // SafeSysFreeString - Frees a bstr if not NULL // -------------------------------------------------------------------------------- #define SafeSysFreeString(_x) \ if (_x) { \ SysFreeString(_x);\ _x = NULL; \ } else // ------------------------------------------------------------------------- // ReplaceInterface - Replaces a member interface with a new interface // ------------------------------------------------------------------------- #define ReplaceInterface(_pUnk, _pUnkNew) \ { \ if (_pUnk) \ (_pUnk)->Release(); \ if ((_pUnk) = (_pUnkNew)) \ (_pUnk)->AddRef(); \ } #ifdef __cplusplus } #endif // -------------------------------------------------------------------------------- // SetWndThisPtrOnCreate // -------------------------------------------------------------------------------- #define SetWndThisPtrOnCreate(hwnd, lpcs) \ SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)(((LPCREATESTRUCT)lpcs)->lpCreateParams)) // -------------------------------------------------------------------------------- // SetWndThisPtr // -------------------------------------------------------------------------------- #define SetWndThisPtr(hwnd, THIS) \ SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)THIS) // -------------------------------------------------------------------------------- // GetWndThisPtr // -------------------------------------------------------------------------------- #define GetWndThisPtr(hwnd) \ GetWindowLongPtr(hwnd, GWLP_USERDATA) // -------------------------------------------------------------------------------- // ListView Helper Macros // -------------------------------------------------------------------------------- #define ListView_GetSelFocused(_hwndlist) ListView_GetNextItem(_hwndlist, -1, LVNI_SELECTED|LVIS_FOCUSED) #define ListView_GetFirstSel(_hwndlist) ListView_GetNextItem(_hwndlist, -1, LVNI_SELECTED) #define ListView_GetFocusedItem(_hwndlist) ListView_GetNextItem(_hwndlist, -1, LVNI_FOCUSED) #define ListView_SelectItem(_hwndlist, _i) ListView_SetItemState(_hwndlist, _i, LVIS_SELECTED|LVIS_FOCUSED, LVIS_SELECTED|LVIS_FOCUSED) #define ListView_UnSelectItem(_hwndlist, _i) ListView_SetItemState(_hwndlist, _i, 0, LVIS_SELECTED) #define ListView_FocusItem(_hwndlist, _i) ListView_SetItemState(_hwndlist, _i, LVIS_FOCUSED, LVIS_FOCUSED) #if (_WIN32_IE >= 0x0400) #define ListView_UnSelectAll(_hwndlist) { \ ListView_SetItemState(_hwndlist, -1, 0, LVIS_SELECTED|LVIS_FOCUSED); \ ListView_SetSelectionMark(_hwndlist, -1); \ } #else #define ListView_UnSelectAll(_hwndlist) ListView_SetItemState(_hwndlist, -1, 0, LVIS_SELECTED|LVIS_FOCUSED); #endif #define ListView_SelectAll(_hwndlist) ListView_SetItemState(_hwndlist, -1, LVIS_SELECTED, LVIS_SELECTED) // -------------------------------------------------------------------------------- // MAX Move Memory Definitions // -------------------------------------------------------------------------------- #ifdef RtlMoveMemory #undef RtlMoveMemory #ifdef __cplusplus extern "C" { #endif __declspec(dllimport) void RtlMoveMemory(void *, const void *, unsigned long); #ifdef __cplusplus } #endif #endif #ifndef MSOERT_NO_MEMUTIL // -------------------------------------------------------------------------------- // Memory Utility Functions // -------------------------------------------------------------------------------- extern IMalloc *g_pMalloc; // -------------------------------------------------------------------------------- // SafeMemFree // -------------------------------------------------------------------------------- #ifndef SafeMemFree #ifdef __cplusplus #define SafeMemFree(_pv) \ if (_pv) { \ g_pMalloc->Free(_pv); \ _pv = NULL; \ } else #else #define SafeMemFree(_pv) \ if (_pv) { \ g_pMalloc->lpVtbl->Free(g_pMalloc, _pv); \ _pv = NULL; \ } else #endif // __cplusplus #endif // SafeMemFree // -------------------------------------------------------------------------------- // MemFree // -------------------------------------------------------------------------------- #define MemFree(_pv) g_pMalloc->Free(_pv) #define ReleaseMem(_pv) MemFree(_pv) #define AthFreeString(_psz) g_pMalloc->Free((LPVOID)_psz) // -------------------------------------------------------------------------------- // Memory Allocation Functions // -------------------------------------------------------------------------------- LPVOID ZeroAllocate(DWORD cbSize); BOOL MemAlloc(LPVOID* ppv, ULONG cb); BOOL MemRealloc(LPVOID *ppv, ULONG cbNew); HRESULT HrAlloc(LPVOID *ppv, ULONG cb); HRESULT HrRealloc(LPVOID *ppv, ULONG cbNew); #endif // !MSOERT_NO_MEMUTIL // -------------------------------------------------------------------------------- // Debug Utility Functions // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_DEBUG #endif // !MSOERT_NO_DEBUG // -------------------------------------------------------------------------------- // String Utility Functions // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_STRUTIL #define CCHMAX_STRINGRES 512 // Used with HrFindInetTimeZone typedef struct tagINETTIMEZONE { LPSTR lpszZoneCode; INT cHourOffset; INT cMinuteOffset; } INETTIMEZONE, *LPINETTIMEZONE; // Used with CchFileTimeToDateTimeSz #define DTM_LONGDATE 0x00000001 #define DTM_NOSECONDS 0x00000002 #define DTM_NOTIME 0x00000004 #define DTM_NODATE 0x00000008 #define DTM_DOWSHORTDATE 0x00000010 #define DTM_FORCEWESTERN 0x00000020 #define DTM_NOTIMEZONEOFFSET 0x00000040 #define TOUPPERA(_ch) (CHAR)LOWORD(CharUpperA((LPSTR)(DWORD_PTR)MAKELONG(_ch, 0))) #define TOLOWERA(_ch) (CHAR)LOWORD(CharLowerA((LPSTR)(DWORD_PTR)MAKELONG(_ch, 0))) OESTDAPI_(LPWSTR) PszDupW(LPCWSTR pcwszSource); OESTDAPI_(LPSTR) PszDupA(LPCSTR pcszSource); OESTDAPI_(LPSTR) PszDupLenA(LPCSTR pcszSource, int nLen); OESTDAPI_(BOOL) FIsEmptyA(LPCSTR pcszString); OESTDAPI_(BOOL) FIsEmptyW(LPCWSTR pcwszString); OESTDAPI_(LPWSTR) PszToUnicode(UINT cp, LPCSTR pcszSource); OESTDAPI_(ULONG) UlStripWhitespace(LPTSTR lpsz, BOOL fLeading, BOOL fTrailing, ULONG *pcb); OESTDAPI_(ULONG) UlStripWhitespaceW(LPWSTR lpwsz, BOOL fLeading, BOOL fTrailing, ULONG *pcb); OESTDAPI_(LPSTR) PszSkipWhiteA(LPSTR psz); OESTDAPI_(LPWSTR) PszSkipWhiteW(LPWSTR psz); OESTDAPI_(LPSTR) PszScanToWhiteA(LPSTR psz); OESTDAPI_(LPSTR) PszScanToCharA(LPSTR psz, CHAR ch); OESTDAPI_(VOID) StripCRLF(LPSTR lpsz, ULONG *pcb); OESTDAPI_(LPSTR) PszAllocA(INT nLen); OESTDAPI_(LPWSTR) PszAllocW(INT nLen); OESTDAPI_(BOOL) FIsSpaceA(LPSTR psz); OESTDAPI_(BOOL) FIsSpaceW(LPWSTR psz); OESTDAPI_(LPSTR) PszToANSI(UINT cp, LPCWSTR pcwszSource); OESTDAPI_(UINT) StrToUintW(LPCWSTR lpSrc); OESTDAPI_(UINT) StrToUintA(LPCSTR lpSrc); OESTDAPI_(INT) IsDigit(LPSTR psz); OESTDAPI_(CHAR) ChConvertFromHex(CHAR ch); OESTDAPI_(LPSTR) PszFromANSIStreamA(LPSTREAM pstm); OESTDAPI_(HRESULT) HrIndexOfMonth(LPCSTR pszMonth, ULONG *pulIndex); OESTDAPI_(HRESULT) HrIndexOfWeek(LPCSTR pszDay, ULONG *pulIndex); OESTDAPI_(HRESULT) HrFindInetTimeZone(LPCSTR pszTimeZone, LPINETTIMEZONE pTimeZone); OESTDAPI_(LPCSTR) PszDayFromIndex(ULONG ulIndex); OESTDAPI_(LPCSTR) PszMonthFromIndex(ULONG ulIndex); OESTDAPI_(LPSTR) PszEscapeMenuStringA(LPCSTR pszSource, LPSTR pszQuoted, int cch); OESTDAPI_(INT) IsPrint(LPSTR psz); OESTDAPI_(INT) IsUpper(LPSTR psz); OESTDAPI_(INT) IsAlphaNum(LPSTR psz); OESTDAPI_(LPSTR) strtrim(char *s); OESTDAPI_(LPWSTR) strtrimW(WCHAR *s); OESTDAPI_(INT) CchFileTimeToDateTimeSz(FILETIME * pft, CHAR * szDateTime, int cch, DWORD dwFlags); OESTDAPI_(LPCSTR) StrChrExA(UINT codepage, LPCSTR pszString, CHAR ch); OESTDAPI_(BOOL) FIsValidFileNameCharW(WCHAR wch); OESTDAPI_(BOOL) FIsValidFileNameCharA(UINT codepage, CHAR ch); OESTDAPI_(ULONG) CleanupFileNameInPlaceA(UINT codepage, LPSTR psz); OESTDAPI_(ULONG) CleanupFileNameInPlaceW(LPWSTR pwsz); OESTDAPI_(INT) ReplaceChars(LPCSTR pszString, CHAR chFind, CHAR chReplace); OESTDAPI_(INT) ReplaceCharsW(LPCWSTR pszString, WCHAR chFind, WCHAR chReplace); OESTDAPI_(LPCSTR) _MSG(LPSTR pszFormat, ...); OESTDAPI_(BOOL) IsValidFileIfFileUrl(LPSTR pszUrl); OESTDAPI_(BOOL) IsValidFileIfFileUrlW(LPWSTR pwszUrl); OESTDAPI_(BOOL) fGetBrowserUrlEncoding(LPDWORD pdwFlags); typedef int (*PFGETTIMEFORMATW)(LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpTime, LPCWSTR pwzFormat, LPWSTR pwzTimeStr, int cchTime); typedef int (*PFGETDATEFORMATW)(LCID Locale, DWORD dwFlags, CONST SYSTEMTIME * lpDate, LPCWSTR pwzFormat, LPWSTR pwzDateStr, int cchDate); typedef int (*PFGETLOCALEINFOW)(LCID Locale, LCTYPE LCType, LPWSTR lpsz, int cchData); OESTDAPI_(BOOL) CchFileTimeToDateTimeW(FILETIME *pft, WCHAR * wsDateTime, int cch, DWORD dwFlags, PFGETDATEFORMATW pfGetDateFormatW, PFGETTIMEFORMATW pfGetTimeFormatW, PFGETLOCALEINFOW pfGetLocaleInfo); // -------------------------------------------------------------------------------- // Unicode/ANSI Function Mapping // -------------------------------------------------------------------------------- #ifdef UNICODE #define FIsEmpty FIsEmptyW #define PszDup PszDupW #define PszAlloc PszAllocW #define FIsSpace FIsSpaceW #define StrToUint StrToUintW #else #define FIsEmpty FIsEmptyA #define PszDup PszDupA #define PszAlloc PszAllocA #define FIsSpace FIsSpaceA #define StrToUint StrToUintA #endif #define IsSpace FIsSpaceA #endif // !MSOERT_NO_STRUTIL // -------------------------------------------------------------------------------- // IStream Utility Functions // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_STMUTIL OESTDAPI_(HRESULT) HrIsStreamUnicode(LPSTREAM pstm, BOOL *pfLittleEndian); OESTDAPI_(HRESULT) HrCopyStreamToByte(LPSTREAM lpstmIn, LPBYTE pbDest, ULONG *pcb); OESTDAPI_(HRESULT) HrByteToStream(LPSTREAM *lppstm, LPBYTE lpb, ULONG cb); OESTDAPI_(HRESULT) HrGetStreamSize(LPSTREAM pstm, ULONG *pcb); OESTDAPI_(HRESULT) HrRewindStream(LPSTREAM pstm); OESTDAPI_(HRESULT) HrCopyStream(LPSTREAM pstmIn, LPSTREAM pstmOut, ULONG *pcb); OESTDAPI_(HRESULT) HrCopyLockBytesToStream(ILockBytes *pLockBytes, IStream *pStream, ULONG *pcbCopied); OESTDAPI_(HRESULT) HrSafeGetStreamSize(LPSTREAM pstm, ULONG *pcb); OESTDAPI_(HRESULT) HrGetStreamPos(LPSTREAM pstm, ULONG *piPos); OESTDAPI_(HRESULT) HrStreamSeekSet(LPSTREAM pstm, ULONG iPos); OESTDAPI_(HRESULT) HrCopyStreamCBEndOnCRLF(LPSTREAM lpstmIn, LPSTREAM lpstmOut, ULONG cb, ULONG *pcbActual); OESTDAPI_(HRESULT) CreateTempFileStream(LPSTREAM *ppstmFile); OESTDAPI_(HRESULT) HrStreamToByte(LPSTREAM lpstm, LPBYTE *lppb, ULONG *pcb); OESTDAPI_(HRESULT) HrCopyStreamCB(LPSTREAM lpstmIn, LPSTREAM lpstmOut, ULARGE_INTEGER uliCopy, ULARGE_INTEGER *puliRead, ULARGE_INTEGER *puliWritten); OESTDAPI_(HRESULT) HrStreamSeekCur(LPSTREAM pstm, LONG iPos); OESTDAPI_(HRESULT) HrStreamSeekEnd(LPSTREAM pstm); OESTDAPI_(HRESULT) HrStreamSeekBegin(LPSTREAM pstm); OESTDAPI_(BOOL) StreamSubStringMatch(LPSTREAM pstm, TCHAR *sz); OESTDAPI_(HRESULT) OpenFileStream(LPSTR pszFile, DWORD dwCreationDistribution, DWORD dwAccess, LPSTREAM *ppstmFile); OESTDAPI_(HRESULT) OpenFileStreamWithFlags(LPSTR pszFile, DWORD dwCreationDistribution, DWORD dwAccess, DWORD dwFlagsAndAttributes, LPSTREAM *ppstmFile); OESTDAPI_(HRESULT) OpenFileStreamShare(LPSTR pszFile, DWORD dwCreationDistribution, DWORD dwAccess, DWORD dwShare, LPSTREAM *ppstmFile); OESTDAPI_(HRESULT) WriteStreamToFile(LPSTREAM pstm, LPSTR lpszFile, DWORD dwCreationDistribution, DWORD dwAccess); OESTDAPI_(HRESULT) OpenFileStreamW(LPWSTR pszFile, DWORD dwCreationDistribution, DWORD dwAccess, LPSTREAM *ppstmFile); OESTDAPI_(HRESULT) OpenFileStreamWithFlagsW(LPWSTR pszFile, DWORD dwCreationDistribution, DWORD dwAccess, DWORD dwFlagsAndAttributes, LPSTREAM *ppstmFile); OESTDAPI_(HRESULT) OpenFileStreamShareW(LPWSTR pszFile, DWORD dwCreationDistribution, DWORD dwAccess, DWORD dwShare, LPSTREAM *ppstmFile); OESTDAPI_(HRESULT) WriteStreamToFileW(LPSTREAM pstm, LPWSTR lpszFile, DWORD dwCreationDistribution, DWORD dwAccess); #endif // !MSOERT_NO_STRUTIL // -------------------------------------------------------------------------------- // Protected Storage // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_PROTSTOR #include "pstore.h" #ifdef ENABLE_RULES #define PST_IDENT_TYPE_STRING L"Identification with rules" #elif defined(N_TEST) #define PST_IDENT_TYPE_STRING L"Identification test" #else #define PST_IDENT_TYPE_STRING L"Identification" #endif #define PST_IMNACCT_SUBTYPE_STRING L"INETCOMM Server Passwords" #define PST_CERTS_SUBTYPE_STRING L"Certificate Trust" // -------------------------------------------------------------------------------- // Protected Storage Functions // -------------------------------------------------------------------------------- OESTDAPI_(HRESULT) PSTSetNewData( IN IPStore *const pISecProv, IN const GUID *const guidType, IN const GUID *const guidSubt, IN LPCWSTR wszAccountName, IN const BLOB *const pclear, OUT BLOB *const phandle); OESTDAPI_(HRESULT) PSTGetData( IN IPStore *const pISecProv, IN const GUID *const guidType, IN const GUID *const guidSubt, IN LPCWSTR wszLookupName, OUT BLOB *const pclear); OESTDAPI_(HRESULT) PSTCreateTypeSubType_NoUI( IN IPStore *const pISecProv, IN const GUID *const guidType, IN LPCWSTR szType, IN const GUID *const guidSubt, IN LPCWSTR szSubt); OESTDAPI_(LPWSTR) WszGenerateNameFromBlob(IN BLOB blob); OESTDAPI_(void) PSTFreeHandle(IN LPBYTE pb); #endif // !MSOERT_NO_PROTSTOR // -------------------------------------------------------------------------------- // CAPI Utility - A few helper functions for the crypt32 utilities // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_CAPIUTIL #ifndef __WINCRYPT_H__ #define _CRYPT32_ #include #endif typedef enum tagCERTSTATE CERTSTATE; // From mimeole.h OESTDAPI_(LPSTR) SzGetCertificateEmailAddress(const PCCERT_CONTEXT pCert); OESTDAPI_(HRESULT) HrDecodeObject(const BYTE *pbEncoded, DWORD cbEncoded, LPCSTR item, DWORD dwFlags, DWORD *pcbOut, LPVOID *ppvOut); OESTDAPI_(LPVOID) PVDecodeObject(const BYTE *pbEncoded, DWORD cbEncoded, LPCSTR item, DWORD *pcbOut); OESTDAPI_(LPVOID) PVGetCertificateParam(PCCERT_CONTEXT pCert, DWORD dwParam, DWORD *cbOut); OESTDAPI_(HRESULT) HrGetCertificateParam(PCCERT_CONTEXT pCert, DWORD dwParam, LPVOID * pvOut, DWORD *cbOut); OESTDAPI_(BOOL) FMissingCert(const CERTSTATE cs); OESTDAPI_(LPVOID) PVGetMsgParam(HCRYPTMSG hCryptMsg, DWORD dwParam, DWORD dwIndex, DWORD *pcbData); OESTDAPI_(HRESULT) HrGetMsgParam(HCRYPTMSG hCryptMsg, DWORD dwParam, DWORD dwIndex, LPVOID * ppv, DWORD * pcbData); LPVOID WINAPI CryptAllocFunc(size_t cbSize); VOID WINAPI CryptFreeFunc(LPVOID pv); HRESULT HrGetCertKeyUsage(PCCERT_CONTEXT pccert, DWORD * pdwUsage); HRESULT HrVerifyCertEnhKeyUsage(PCCERT_CONTEXT pccert, LPCSTR pszOidUsage); #endif // !MSOERT_NO_CAPIUTIL // -------------------------------------------------------------------------------- // CAPI Utility - A few helper functions for the crypt32 utilities // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_RASUTIL OESTDAPI_(HRESULT) HrCreatePhonebookEntry(HWND hwnd, DWORD *pdwRASResult); OESTDAPI_(HRESULT) HrEditPhonebookEntry(HWND hwnd, LPTSTR pszEntryName, DWORD *pdwRASResult); OESTDAPI_(HRESULT) HrFillRasCombo(HWND hwndComboBox, BOOL fUpdateOnly, DWORD *pdwRASResult); #endif // !MSOERT_NO_RASUTIL // -------------------------------------------------------------------------------- // Win32 Registry Utilities // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_REGUTIL OESTDAPI_(VOID) CopyRegistry(HKEY hSourceKey, HKEY hDestinationKey); #endif // !MSOERT_NO_REGUTIL // -------------------------------------------------------------------------------- // t-wstrings // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_WSTRINGS OESTDAPI_(BOOL) UnlocStrEqNW(LPCWSTR pwsz1, LPCWSTR pwsz2, DWORD cch); #endif // !MSOERT_NO_WSTRINGS // -------------------------------------------------------------------------------- // CStringParser // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_STRPARSE #ifdef __cplusplus #include "strparse.h" #endif // !__cplusplus #endif // !MSOERT_NO_STRPARSE // -------------------------------------------------------------------------------- // DataObject Utility // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_ENUMFMT #ifdef __cplusplus typedef struct tagDATAOBJINFO { FORMATETC fe; LPVOID pData; DWORD cbData; } DATAOBJINFO, *PDATAOBJINFO; OESTDAPI_(HRESULT) CreateEnumFormatEtc(LPUNKNOWN pUnkRef, ULONG celt, PDATAOBJINFO rgInfo, LPFORMATETC rgfe, IEnumFORMATETC ** lppstmHFile); #endif // !__cplusplus #endif // !MSOERT_NO_ENUMFMT // -------------------------------------------------------------------------------- // CPrivateUnknown Utility // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_PRIVUNK #ifdef __cplusplus #include "privunk.h" #endif // !__cplusplus #endif // !MSOERT_NO_PRIVUNK // -------------------------------------------------------------------------------- // CByteStream Object // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_BYTESTM #ifdef __cplusplus #include "bytestm.h" #endif // !__cplusplus #endif // !MSOERT_NO_BYTESTM // -------------------------------------------------------------------------------- // CLogFile Object // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_CLOGFILE #ifdef __cplusplus #include "..\\msoert\\clogfile.h" #endif // !__cplusplus #endif // !MSOERT_NO_CLOGFILE // -------------------------------------------------------------------------------- // CDataObject Object // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_DATAOBJ #ifdef __cplusplus #include "..\\msoert\\dataobj.h" #endif // !__cplusplus #endif // !MSOERT_NO_DATAOBJ // -------------------------------------------------------------------------------- // CUnknownList and CVoidPtrList Objects // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_LISTOBJS #ifdef __cplusplus #include "..\\msoert\\listintr.h" #endif // !__cplusplus #endif // !MSOERT_NO_LISTOBJS // -------------------------------------------------------------------------------- // MSHTML utilities // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_MSHTMLUTILS #ifdef __cplusplus #include "..\\msoert\\mshtutil.h" #endif // !__cplusplus #endif // !MSOERT_NO_MSHTMLUTILS // -------------------------------------------------------------------------------- // BSTR utilities // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_BSTUTILS #ifdef __cplusplus #include "..\\msoert\\bstr.h" #endif // !__cplusplus #endif // !MSOERT_NO_BSTRUTILS // -------------------------------------------------------------------------------- // HFILESTM utilities // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_HFILESTM #ifdef __cplusplus OESTDAPI_(HRESULT) CreateStreamOnHFile (LPTSTR lpszFile, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDistribution, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile, LPSTREAM *lppstmHFile); OESTDAPI_(HRESULT) CreateStreamOnHFileW(LPWSTR lpwszFile, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDistribution, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile, LPSTREAM *lppstmHFile); #endif // !__cplusplus #endif // !MSOERT_NO_HFILESTM // -------------------------------------------------------------------------------- // Outlook Express Runtime Utilities // -------------------------------------------------------------------------------- #ifndef MSOERT_NO_OERTUTIL typedef struct tagTEMPFILEINFO *LPTEMPFILEINFO; typedef struct tagTEMPFILEINFO { LPTEMPFILEINFO pNext; LPSTR pszFilePath; HANDLE hProcess; } TEMPFILEINFO; #ifndef HIMAGELIST struct _IMAGELIST; typedef struct _IMAGELIST NEAR* HIMAGELIST; #endif OESTDAPI_(HIMAGELIST) LoadMappedToolbarBitmap(HINSTANCE hInst, int idBitmap, int cx); OESTDAPI_(VOID) UpdateRebarBandColors(HWND hwnd); OESTDAPI_(HRESULT) IsPlatformWinNT(void); OESTDAPI_(HRESULT) GenerateUniqueFileName(LPCSTR pszDirectory, LPCSTR pszFileName, LPCSTR pszExtension, LPSTR pszFilePath, ULONG cchMaxPath); OESTDAPI_(HRESULT) CreateTempFile(LPCSTR pszSuggest, LPCSTR pszExtension, LPSTR *ppszFilePath, HANDLE *phFile); OESTDAPI_(HRESULT) WriteStreamToFileHandle(IStream *pStream, HANDLE hFile, ULONG *pcbTotal); OESTDAPI_(HRESULT) AppendTempFileList(LPTEMPFILEINFO *ppHead, LPSTR pszFilePath, HANDLE hProcess); OESTDAPI_(VOID) DeleteTempFileOnShutdown(LPTEMPFILEINFO pTempFile); OESTDAPI_(VOID) DeleteTempFileOnShutdownEx(LPSTR pszFilePath, HANDLE hProcess); OESTDAPI_(VOID) CleanupGlobalTempFiles(void); OESTDAPI_(HRESULT) DeleteTempFile(LPTEMPFILEINFO pTempFile); OESTDAPI_(VOID) FreeTempFileList(LPTEMPFILEINFO pTempFileHead); #define SafeFreeTempFileList(_p) \ { \ if (_p) \ { \ FreeTempFileList(_p); \ _p=NULL; \ } \ } OESTDAPI_(BOOL) FBuildTempPath(LPTSTR lpszOrigFile, LPTSTR lpszPath, ULONG cbMaxPath, BOOL fLink); OESTDAPI_(BOOL) FBuildTempPathW(LPWSTR lpszOrigFile, LPWSTR lpszPath, ULONG cchMaxPath, BOOL fLink); OESTDAPI_(HRESULT) ShellUtil_GetSpecialFolderPath(DWORD dwSpecialFolder, LPSTR rgchPath); OESTDAPI_(BOOL) FIsHTMLFile(LPSTR pszFile); OESTDAPI_(BOOL) FIsHTMLFileW(LPWSTR pwszFile); typedef int (*PFLOADSTRINGW)(HINSTANCE,UINT,LPWSTR,int); typedef int (*PFMESSAGEBOXW)(HWND,LPCWSTR,LPCWSTR,UINT); OESTDAPI_(int) MessageBoxInst(HINSTANCE hInst, HWND hwndOwner, LPTSTR pszTitle, LPTSTR psz1, LPTSTR psz2, UINT fuStyle); OESTDAPI_(int) MessageBoxInstW(HINSTANCE hInst, HWND hwndOwner, LPWSTR pwszTitle, LPWSTR pwsz1, LPWSTR pwsz2, UINT fuStyle, PFLOADSTRINGW pfLoadStringW, PFMESSAGEBOXW pfMessageBoxW); // window utils OESTDAPI_(void) IDrawText(HDC hdc, LPCTSTR pszText, RECT FAR* prc, BOOL fEllipses, int cyChar); OESTDAPI_(HRESULT) RicheditStreamIn(HWND hwndRE, LPSTREAM pstm, ULONG uSelFlags); OESTDAPI_(HRESULT) RicheditStreamOut(HWND hwndRE, LPSTREAM pstm, ULONG uSelFlags); OESTDAPI_(VOID) CenterDialog(HWND hwndDlg); OESTDAPI_(VOID) SetIntlFont(HWND hwnd); OESTDAPI_(BOOL) GetExePath(LPCTSTR szExe, TCHAR *szPath, DWORD cch, BOOL fDirOnly); OESTDAPI_(BOOL) BrowseForFolder(HINSTANCE hInst, HWND hwnd, TCHAR *pszDir, int cch, int idsText, BOOL fFileSysOnly); OESTDAPI_(BOOL) BrowseForFolderW(HINSTANCE hInst, HWND hwnd, WCHAR *pwszDir, int cch, int idsText, BOOL fFileSysOnly); OESTDAPI_(HRESULT) DoHotMailWizard(HWND hwndOwner, LPSTR pszUrl, LPSTR pszFriendly, RECT *prc, IUnknown *pUnkHost); OESTDAPI_(LONG_PTR) SetWindowLongPtrAthW(HWND hWnd, int nIndex, LONG_PTR dwNewLong); HRESULT GetHtmlCharset(IStream *pStmHtml, LPSTR *ppszCharset); #endif // MSOERT_NO_OERTUTIL typedef HANDLE HTHREAD; typedef HANDLE HEVENT; typedef HANDLE HPROCESS; typedef HANDLE HANDLE_16; typedef WPARAM WPARAM_16; #define EXTERN_C_16 #define WINAPI_16 #define CALLBACK_16 #define EXPORT_16 #define LOADDS_16 #define HUGEP_16 #define WaitForSingleObject_16 WaitForSingleObject #define GlobalAlloc_16 GlobalAlloc #define GlobalFree_16 GlobalFree #define CreateFileMapping_16 CreateFileMapping #define MapViewOfFile_16 MapViewOfFile #define UnmapViewOfFile_16 UnmapViewOfFile #define CloseHandle_FM16 CloseHandle #define CloseHandle_F16 CloseHandle #define INVALID_HANDLE_VALUE_16 INVALID_HANDLE_VALUE #define SetDlgThisPtr(hwnd, THIS) SetWndThisPtr(hwnd, THIS) #define GetDlgThisPtr(hwnd) GetWndThisPtr(hwnd) // Some one liners can be wrapped in IF_WIN16 or IF_WIN32 so that the // code is more readable. #define IF_WIN16(x) #define IF_NOT_WIN16(x) x #define IF_WIN32(x) x #endif // __MSOERT_H