Volian/SourceCode
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Files
4b1ca8d7bf1d3987031c26a99067e0c02528db6b
SourceCode/PROMS/DSOFramer/Source2005/utilities.cpp
Rich 93cbb4ef20
2007-12-10 20:53:52 +00:00

1360 lines
41 KiB
C++
Raw Blame History

/***************************************************************************
* UTILITIES.CPP
*
* Shared helper functions and routines.
*
* Copyright ©1999-2004; Microsoft Corporation. All rights reserved.
* Written by Microsoft Developer Support Office Integration (PSS DSOI)
*
* This code is provided via KB 311765 as a sample. It is not a formal
* product and has not been tested with all containers or servers. Use it
* for educational purposes only. See the EULA.TXT file included in the
* KB download for full terms of use and restrictions.
*
* THIS CODE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND,
* EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE.
*
***************************************************************************/
#include "dsoframer.h"
////////////////////////////////////////////////////////////////////////
// Core Utility Functions
//
////////////////////////////////////////////////////////////////////////
// Heap Allocation (Private Heap)
//
extern HANDLE v_hPrivateHeap;
STDAPI_(LPVOID) DsoMemAlloc(DWORD cbSize)
{
CHECK_NULL_RETURN(v_hPrivateHeap, NULL);
return HeapAlloc(v_hPrivateHeap, HEAP_ZERO_MEMORY, cbSize);
}
STDAPI_(void) DsoMemFree(LPVOID ptr)
{
if ((v_hPrivateHeap) && (ptr))
HeapFree(v_hPrivateHeap, 0, ptr);
}
void * _cdecl operator new(size_t size){ return DsoMemAlloc(size);}
void _cdecl operator delete(void *ptr){ DsoMemFree(ptr); }
int __cdecl _purecall(){__asm{int 3}; return 0;}
////////////////////////////////////////////////////////////////////////
// Global String Functions
//
////////////////////////////////////////////////////////////////////////
// DsoConvertToUnicodeEx
//
STDAPI DsoConvertToUnicodeEx(LPCSTR pszMbcsString, DWORD cbMbcsLen, LPWSTR pwszUnicode, DWORD cbUniLen, UINT uiCodePage)
{
DWORD cbRet;
UINT iCode = CP_ACP;
if (IsValidCodePage(uiCodePage))
iCode = uiCodePage;
CHECK_NULL_RETURN(pwszUnicode, E_POINTER);
pwszUnicode[0] = L'\0';
CHECK_NULL_RETURN(pszMbcsString, E_POINTER);
CHECK_NULL_RETURN(cbMbcsLen, E_INVALIDARG);
CHECK_NULL_RETURN(cbUniLen, E_INVALIDARG);
cbRet = MultiByteToWideChar(iCode, 0, pszMbcsString, cbMbcsLen, pwszUnicode, cbUniLen);
if (cbRet == 0) return E_WIN32_LASTERROR;
pwszUnicode[cbRet] = L'\0';
return S_OK;
}
////////////////////////////////////////////////////////////////////////
// DsoConvertToMBCSEx
//
STDAPI DsoConvertToMBCSEx(LPCWSTR pwszUnicodeString, DWORD cbUniLen, LPSTR pszMbcsString, DWORD cbMbcsLen, UINT uiCodePage)
{
DWORD cbRet;
UINT iCode = CP_ACP;
if (IsValidCodePage(uiCodePage))
iCode = uiCodePage;
CHECK_NULL_RETURN(pszMbcsString, E_POINTER);
pszMbcsString[0] = L'\0';
CHECK_NULL_RETURN(pwszUnicodeString, E_POINTER);
CHECK_NULL_RETURN(cbMbcsLen, E_INVALIDARG);
CHECK_NULL_RETURN(cbUniLen, E_INVALIDARG);
cbRet = WideCharToMultiByte(iCode, 0, pwszUnicodeString, -1, pszMbcsString, cbMbcsLen, NULL, NULL);
if (cbRet == 0) return E_WIN32_LASTERROR;
pszMbcsString[cbRet] = '\0';
return S_OK;
}
////////////////////////////////////////////////////////////////////////
// DsoConvertToLPWSTR
//
// Takes a MBCS string and returns a LPWSTR allocated on private heap.
//
STDAPI_(LPWSTR) DsoConvertToLPWSTR(LPCSTR pszMbcsString)
{
LPWSTR pwsz = NULL;
UINT cblen, cbnew;
if ((pszMbcsString) &&
((cblen = lstrlen(pszMbcsString)) > 0))
{
cbnew = ((cblen + 1) * sizeof(WCHAR));
if ((pwsz = (LPWSTR)DsoMemAlloc(cbnew)) != NULL)
{
if (FAILED(DsoConvertToUnicodeEx(pszMbcsString, cblen, pwsz, cbnew, GetACP())))
{
DsoMemFree(pwsz);
pwsz = NULL;
}
}
}
return pwsz;
}
////////////////////////////////////////////////////////////////////////
// DsoConvertToMBCS
//
// Takes a WCHAR string and returns a LPSTR on the private heap.
//
STDAPI_(LPSTR) DsoConvertToMBCS(LPCWSTR pwszUnicodeString)
{
LPSTR psz = NULL;
UINT cblen, cbnew;
if ((pwszUnicodeString) &&
((cblen = lstrlenW(pwszUnicodeString)) > 0))
{
cbnew = ((cblen + 1) * sizeof(WCHAR));
if ((psz = (LPSTR)DsoMemAlloc(cbnew)) != NULL)
{
if (FAILED(DsoConvertToMBCSEx(pwszUnicodeString, cblen, psz, cbnew, GetACP())))
{
DsoMemFree(psz); psz = NULL;
}
}
}
return psz;
}
////////////////////////////////////////////////////////////////////////
// DsoConvertToBSTR
//
// Takes a MBCS string and returns a BSTR. NULL is returned if the
// function fails or the string is empty.
//
STDAPI_(BSTR) DsoConvertToBSTR(LPCSTR pszMbcsString)
{
BSTR bstr = NULL;
LPWSTR pwsz = DsoConvertToLPWSTR(pszMbcsString);
if (pwsz)
{
bstr = SysAllocString(pwsz);
DsoMemFree(pwsz);
}
return bstr;
}
////////////////////////////////////////////////////////////////////////
// DsoConvertToLPOLESTR
//
// Returns Unicode string in COM Task Memory (CoTaskMemAlloc).
//
STDAPI_(LPWSTR) DsoConvertToLPOLESTR(LPCWSTR pwszUnicodeString)
{
LPWSTR pwsz;
UINT cblen;
CHECK_NULL_RETURN(pwszUnicodeString, NULL);
cblen = lstrlenW(pwszUnicodeString);
pwsz = (LPWSTR)CoTaskMemAlloc((cblen * sizeof(WCHAR)) + 2);
if (pwsz)
{
memcpy(pwsz, pwszUnicodeString, (cblen * sizeof(WCHAR)));
pwsz[cblen] = L'\0'; // Make sure it is NULL terminated.
}
return pwsz;
}
////////////////////////////////////////////////////////////////////////
// DsoCopyString
//
// Duplicates the string into private heap string.
//
STDAPI_(LPWSTR) DsoCopyString(LPCWSTR pwszString)
{
LPWSTR pwsz;
UINT cblen;
CHECK_NULL_RETURN(pwszString, NULL);
cblen = lstrlenW(pwszString);
pwsz = (LPWSTR)DsoMemAlloc((cblen * sizeof(WCHAR)) + 2);
if (pwsz)
{
memcpy(pwsz, pwszString, (cblen * sizeof(WCHAR)));
pwsz[cblen] = L'\0'; // Make sure it is NULL terminated.
}
return pwsz;
}
////////////////////////////////////////////////////////////////////////
// DsoCopyStringCat
//
STDAPI_(LPWSTR) DsoCopyStringCat(LPCWSTR pwszString1, LPCWSTR pwszString2)
{return DsoCopyStringCatEx(pwszString1, 1, &pwszString2);}
////////////////////////////////////////////////////////////////////////
// DsoCopyStringCatEx
//
// Duplicates the string into private heap string and appends one or more
// strings to the end (concatenation).
//
STDAPI_(LPWSTR) DsoCopyStringCatEx(LPCWSTR pwszBaseString, UINT cStrs, LPCWSTR *ppwszStrs)
{
LPWSTR pwsz;
UINT i, cblenb, cblent;
UINT *pcblens;
// We assume you have a base string to start with. If not, we return NULL...
if ((pwszBaseString == NULL) ||
((cblenb = lstrlenW(pwszBaseString)) < 1))
return NULL;
// If we have nothing to append, just do a plain copy...
if ((cStrs == 0) || (ppwszStrs == NULL))
return DsoCopyString(pwszBaseString);
// Determine the size of the final string by finding the lengths
// of each. We create an array of sizes to use later on...
cblent = cblenb;
pcblens = new UINT[cStrs];
CHECK_NULL_RETURN(pcblens, NULL);
for (i = 0; i < cStrs; i++)
{
pcblens[i] = lstrlenW(ppwszStrs[i]);
cblent += pcblens[i];
}
// If we have data to append, create the new string and append the
// data by copying them in place. We expect UTF-16 Unicode strings
// for this to work, but this should be normal...
if (cblent > cblenb)
{
pwsz = (LPWSTR)DsoMemAlloc(((cblent + 1) * sizeof(WCHAR)));
CHECK_NULL_RETURN(pwsz, NULL);
memcpy(pwsz, pwszBaseString, (cblenb * sizeof(WCHAR)));
cblent = cblenb;
for (i = 0; i < cStrs; i++)
{
memcpy((pwsz + cblent), ppwszStrs[i], (pcblens[i] * sizeof(WCHAR)));
cblent += pcblens[i];
}
}
else pwsz = DsoCopyString(pwszBaseString);
delete [] pcblens;
return pwsz;
}
////////////////////////////////////////////////////////////////////////
// DsoCLSIDtoLPSTR
//
STDAPI_(LPSTR) DsoCLSIDtoLPSTR(REFCLSID clsid)
{
LPSTR psz = NULL;
LPWSTR pwsz;
if (SUCCEEDED(StringFromCLSID(clsid, &pwsz)))
{
psz = DsoConvertToMBCS(pwsz);
CoTaskMemFree(pwsz);
}
return psz;
}
///////////////////////////////////////////////////////////////////////////////////
// DsoCompareStringsEx
//
// Calls CompareString API using Unicode version (if available on OS). Otherwise,
// we have to thunk strings down to MBCS to compare. This is fairly inefficient for
// Win9x systems that don't handle Unicode, but hey...this is only a sample.
//
STDAPI_(UINT) DsoCompareStringsEx(LPCWSTR pwsz1, INT cch1, LPCWSTR pwsz2, INT cch2)
{
UINT iret;
LCID lcid = GetThreadLocale();
UINT cblen1, cblen2;
// Check that valid parameters are passed and then contain somethimg...
if ((pwsz1 == NULL) || (cch1 == 0) ||
((cblen1 = ((cch1 > 0) ? cch1 : lstrlenW(pwsz1))) == 0))
return CSTR_LESS_THAN;
if ((pwsz2 == NULL) || (cch2 == 0) ||
((cblen2 = ((cch2 > 0) ? cch2 : lstrlenW(pwsz2))) == 0))
return CSTR_GREATER_THAN;
// If the string is of the same size, then we do quick compare to test for
// equality (this is slightly faster than calling the API, but only if we
// expect the calls to find an equal match)...
if (cblen1 == cblen2)
{
for (iret = 0; iret < cblen1; iret++)
{
if (pwsz1[iret] == pwsz2[iret])
continue;
if (((pwsz1[iret] >= 'A') && (pwsz1[iret] <= 'Z')) &&
((pwsz1[iret] + ('a' - 'A')) == pwsz2[iret]))
continue;
if (((pwsz2[iret] >= 'A') && (pwsz2[iret] <= 'Z')) &&
((pwsz2[iret] + ('a' - 'A')) == pwsz1[iret]))
continue;
break; // don't continue if we can't quickly match...
}
// If we made it all the way, then they are equal...
if (iret == cblen1)
return CSTR_EQUAL;
}
// Now ask the OS to check the strings and give us its read. (We prefer checking
// in Unicode since this is faster and we may have strings that can't be thunked
// down to the local ANSI code page)...
if (v_fUnicodeAPI)
{
iret = CompareStringW(lcid, NORM_IGNORECASE | NORM_IGNOREWIDTH, pwsz1, cblen1, pwsz2, cblen2);
}
else
{
// If we are on Win9x, we don't have much of choice (thunk the call)...
LPSTR psz1 = DsoConvertToMBCS(pwsz1);
LPSTR psz2 = DsoConvertToMBCS(pwsz2);
iret = CompareStringA(lcid, NORM_IGNORECASE, psz1, -1, psz2, -1);
DsoMemFree(psz2);
DsoMemFree(psz1);
}
return iret;
}
////////////////////////////////////////////////////////////////////////
// URL Helpers
//
////////////////////////////////////////////////////////////////////////
// General Functions (checks to see if we can recognize type)
//
STDAPI_(BOOL) LooksLikeUNC(LPCWSTR pwsz)
{
return ((pwsz) && (*pwsz == L'\\') && (*(pwsz + 1) == L'\\') && (*(pwsz + 2) != L'\\'));
}
STDAPI_(BOOL) LooksLikeLocalFile(LPCWSTR pwsz)
{
return ((pwsz) &&
(((*pwsz > 64) && (*pwsz < 91)) || ((*pwsz > 96) && (*pwsz < 123))) &&
(*(pwsz + 1) == L':') && (*(pwsz + 2) == L'\\'));
}
STDAPI_(BOOL) LooksLikeHTTP(LPCWSTR pwsz)
{
return ((pwsz) && ((*pwsz == L'H') || (*pwsz == L'h')) &&
((*(pwsz + 1) == L'T') || (*(pwsz + 1) == L't')) &&
((*(pwsz + 2) == L'T') || (*(pwsz + 2) == L't')) &&
((*(pwsz + 3) == L'P') || (*(pwsz + 3) == L'p')) &&
((*(pwsz + 4) == L':') || (((*(pwsz + 4) == L'S') || (*(pwsz + 4) == L's')) && (*(pwsz + 5) == L':'))));
}
////////////////////////////////////////////////////////////////////////
// GetTempPathForURLDownload
//
// Constructs a temp path for a downloaded file. Note we scan the URL
// to find the name of the file so we can use its exention for server
// association (in case it is a non-docfile -- like RTF) and also
// create our own subfolder to try and avoid name conflicts in temp
// folder itself.
//
STDAPI_(BOOL) GetTempPathForURLDownload(WCHAR* pwszURL, WCHAR** ppwszLocalFile)
{
DWORD dw;
LPWSTR pwszTPath = NULL;
LPWSTR pwszTFile = NULL;
CHAR szTmpPath[MAX_PATH];
// Do a little parameter checking and find length of the URL...
if (!(pwszURL) || ((dw = lstrlenW(pwszURL)) < 6) ||
!(LooksLikeHTTP(pwszURL)) || !(ppwszLocalFile))
return FALSE;
*ppwszLocalFile = NULL;
if (GetTempPath(MAX_PATH, szTmpPath))
{
DWORD dwtlen = lstrlen(szTmpPath);
if (dwtlen > 0 && szTmpPath[dwtlen-1] != '\\')
lstrcat(szTmpPath, "\\");
lstrcat(szTmpPath, "DsoFramer");
if (CreateDirectory(szTmpPath, NULL) || GetLastError() == ERROR_ALREADY_EXISTS)
{
lstrcat(szTmpPath, "\\");
pwszTPath = DsoConvertToLPWSTR(szTmpPath);
}
}
if (pwszTPath)
{
if (pwszTFile = DsoCopyString(pwszURL))
{
LPWSTR pwszT = pwszTFile;
while (*(++pwszT))
if (*pwszT == L'?'){*pwszT = L'\0'; break;}
while (*(--pwszT))
if (*pwszT == L'/'){++pwszT; break;}
*ppwszLocalFile = DsoCopyStringCat(pwszTPath, pwszT);
DsoMemFree(pwszTFile);
}
DsoMemFree(pwszTPath);
}
return (BOOL)(*ppwszLocalFile);
}
////////////////////////////////////////////////////////////////////////
// URLDownloadFile
//
// Does a simple URLMON download of file (no save back to server allowed),
// and no dependent files will be downloaded (just one temp file).
//
STDAPI URLDownloadFile(LPUNKNOWN punk, WCHAR* pwszURL, WCHAR* pwszLocalFile)
{
typedef HRESULT (WINAPI *PFN_URLDTFW)(LPUNKNOWN, LPCWSTR, LPCWSTR, DWORD, LPUNKNOWN);
static PFN_URLDTFW pfnURLDownloadToFileW = NULL;
HMODULE hUrlmon;
if (pfnURLDownloadToFileW == NULL)
{
if (hUrlmon = LoadLibrary("URLMON.DLL"))
pfnURLDownloadToFileW = (PFN_URLDTFW)GetProcAddress(hUrlmon, "URLDownloadToFileW");
}
if (pfnURLDownloadToFileW == NULL)
return E_UNEXPECTED;
return pfnURLDownloadToFileW(punk, pwszURL, pwszLocalFile, 0, NULL);
}
////////////////////////////////////////////////////////////////////////
// OLE Conversion Functions
//
#define HIMETRIC_PER_INCH 2540 // number HIMETRIC units per inch
#define PTS_PER_INCH 72 // number points (font size) per inch
#define MAP_PIX_TO_LOGHIM(x,ppli) MulDiv(HIMETRIC_PER_INCH, (x), (ppli))
#define MAP_LOGHIM_TO_PIX(x,ppli) MulDiv((ppli), (x), HIMETRIC_PER_INCH)
////////////////////////////////////////////////////////////////////////
// DsoHimetricToPixels
//
STDAPI_(void) DsoHimetricToPixels(LONG* px, LONG* py)
{
HDC hdc = GetDC(NULL);
if (px) *px = MAP_LOGHIM_TO_PIX(*px, GetDeviceCaps(hdc, LOGPIXELSX));
if (py) *py = MAP_LOGHIM_TO_PIX(*py, GetDeviceCaps(hdc, LOGPIXELSY));
ReleaseDC(NULL, hdc);
}
////////////////////////////////////////////////////////////////////////
// DsoPixelsToHimetric
//
STDAPI_(void) DsoPixelsToHimetric(LONG* px, LONG* py)
{
HDC hdc = GetDC(NULL);
if (px) *px = MAP_PIX_TO_LOGHIM(*px, GetDeviceCaps(hdc, LOGPIXELSX));
if (py) *py = MAP_PIX_TO_LOGHIM(*py, GetDeviceCaps(hdc, LOGPIXELSY));
ReleaseDC(NULL, hdc);
}
////////////////////////////////////////////////////////////////////////
// GDI Helper Functions
//
STDAPI_(HBITMAP) DsoGetBitmapFromWindow(HWND hwnd)
{
HBITMAP hbmpold, hbmp = NULL;
HDC hdcWin, hdcMem;
RECT rc;
INT x, y;
if (!GetWindowRect(hwnd, &rc))
return NULL;
x = (rc.right - rc.left); if (x < 0) x = 1;
y = (rc.bottom - rc.top); if (y < 0) y = 1;
hdcWin = GetDC(hwnd);
hdcMem = CreateCompatibleDC(hdcWin);
hbmp = CreateCompatibleBitmap(hdcWin, x, y);
hbmpold = (HBITMAP)SelectObject(hdcMem, hbmp);
BitBlt(hdcMem, 0,0, x, y, hdcWin, 0,0, SRCCOPY);
SelectObject(hdcMem, hbmpold);
DeleteDC(hdcMem);
ReleaseDC(hwnd, hdcWin);
return hbmp;
}
////////////////////////////////////////////////////////////////////////
// Windows Helper Functions
//
STDAPI_(BOOL) IsWindowChild(HWND hwndParent, HWND hwndChild)
{
HWND hwnd;
if ((hwndChild == NULL) || !IsWindow(hwndChild))
return FALSE;
if (hwndParent == NULL)
return TRUE;
if (!IsWindow(hwndParent))
return FALSE;
hwnd = hwndChild;
while (hwnd = GetParent(hwnd))
if (hwnd == hwndParent)
return TRUE;
return FALSE;
}
////////////////////////////////////////////////////////////////////////
// DsoGetTypeInfoEx
//
// Gets an ITypeInfo from the LIBID specified. Optionally can load and
// register the typelib from a module resource (if specified). Used to
// load our typelib on demand.
//
STDAPI DsoGetTypeInfoEx(REFGUID rlibid, LCID lcid, WORD wVerMaj, WORD wVerMin, HMODULE hResource, REFGUID rguid, ITypeInfo** ppti)
{
HRESULT hr;
ITypeLib* ptlib;
CHECK_NULL_RETURN(ppti, E_POINTER);
*ppti = NULL;
// Try to pull information from the registry...
hr = LoadRegTypeLib(rlibid, wVerMaj, wVerMin, lcid, &ptlib);
// If that failed, and we have a resource module to load from,
// try loading it from the module...
if (FAILED(hr) && (hResource))
{
LPWSTR pwszPath;
if (FGetModuleFileName(hResource, &pwszPath))
{
// Now, load the type library from module resource file...
hr = LoadTypeLib(pwszPath, &ptlib);
// Register library to make things easier next time...
if (SUCCEEDED(hr))
RegisterTypeLib(ptlib, pwszPath, NULL);
DsoMemFree(pwszPath);
}
}
// We have the typelib. Now get the requested typeinfo...
if (SUCCEEDED(hr))
hr = ptlib->GetTypeInfoOfGuid(rguid, ppti);
// Release the type library interface.
SAFE_RELEASE_INTERFACE(ptlib);
return hr;
}
////////////////////////////////////////////////////////////////////////
// DsoDispatchInvoke
//
// Wrapper for IDispatch::Invoke calls to event sinks, or late bound call
// to embedded object to get ambient property.
//
STDAPI DsoDispatchInvoke(LPDISPATCH pdisp, LPOLESTR pwszname, DISPID dspid, WORD wflags, DWORD cargs, VARIANT* rgargs, VARIANT* pvtret)
{
HRESULT hr = S_FALSE;
DISPID dspidPut = DISPID_PROPERTYPUT;
DISPPARAMS dspparm = {NULL, NULL, 0, 0};
CHECK_NULL_RETURN(pdisp, E_POINTER);
dspparm.rgvarg = rgargs;
dspparm.cArgs = cargs;
if ((wflags & DISPATCH_PROPERTYPUT) || (wflags & DISPATCH_PROPERTYPUTREF))
{
dspparm.rgdispidNamedArgs = &dspidPut;
dspparm.cNamedArgs = 1;
}
SEH_TRY
if (pwszname)
hr = pdisp->GetIDsOfNames(IID_NULL, &pwszname, 1, LOCALE_USER_DEFAULT, &dspid);
if (SUCCEEDED(hr))
hr = pdisp->Invoke(dspid, IID_NULL, LOCALE_USER_DEFAULT, (WORD)(DISPATCH_METHOD | wflags), &dspparm, pvtret, NULL, NULL);
SEH_EXCEPT(hr)
return hr;
}
////////////////////////////////////////////////////////////////////////
// DsoReportError -- Report Error for both ComThreadError and DispError.
//
STDAPI DsoReportError(HRESULT hr, LPWSTR pwszCustomMessage, EXCEPINFO* peiDispEx)
{
BSTR bstrSource, bstrDescription;
ICreateErrorInfo* pcerrinfo;
IErrorInfo* perrinfo;
CHAR szError[MAX_PATH];
UINT nID = 0;
// Don't need to do anything unless this is an error.
if ((hr == S_OK) || SUCCEEDED(hr)) return hr;
// Is this one of our custom errors (if so we will pull description from resource)...
if ((hr > DSO_E_ERR_BASE) && (hr < DSO_E_ERR_MAX))
nID = (hr & 0xFF);
// Set the source name...
bstrSource = SysAllocString(L"DsoFramerControl");
// Set the error description...
if (pwszCustomMessage)
{
bstrDescription = SysAllocString(pwszCustomMessage);
}
else if (((nID) && LoadString(v_hModule, nID, szError, sizeof(szError))) ||
(FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, NULL, hr, 0, szError, sizeof(szError), NULL)))
{
bstrDescription = DsoConvertToBSTR(szError);
}
else bstrDescription = NULL;
// Set ErrorInfo so that vtable clients can get rich error information...
if (SUCCEEDED(CreateErrorInfo(&pcerrinfo)))
{
pcerrinfo->SetSource(bstrSource);
pcerrinfo->SetDescription(bstrDescription);
if (SUCCEEDED(pcerrinfo->QueryInterface(IID_IErrorInfo, (void**) &perrinfo)))
{
SetErrorInfo(0, perrinfo);
perrinfo->Release();
}
pcerrinfo->Release();
}
// Fill-in DispException Structure for late-boud clients...
if (peiDispEx)
{
peiDispEx->scode = hr;
peiDispEx->bstrSource = SysAllocString(bstrSource);
peiDispEx->bstrDescription = SysAllocString(bstrDescription);
}
// Free temp strings...
SAFE_FREEBSTR(bstrDescription);
SAFE_FREEBSTR(bstrSource);
// We always return error passed (so caller can chain this in return call).
return hr;
}
////////////////////////////////////////////////////////////////////////
// Variant Type Helpers (Fast Access to Variant Data)
//
VARIANT* __fastcall DsoPVarFromPVarRef(VARIANT* px)
{return ((px->vt == (VT_VARIANT|VT_BYREF)) ? (px->pvarVal) : px);}
BOOL __fastcall DsoIsVarParamMissing(VARIANT* px)
{return ((px->vt == VT_EMPTY) || ((px->vt & VT_ERROR) == VT_ERROR));}
LPWSTR __fastcall DsoPVarWStrFromPVar(VARIANT* px)
{return ((px->vt == VT_BSTR) ? px->bstrVal : ((px->vt == (VT_BSTR|VT_BYREF)) ? *(px->pbstrVal) : NULL));}
SAFEARRAY* __fastcall DsoPVarArrayFromPVar(VARIANT* px)
{return (((px->vt & (VT_BYREF|VT_ARRAY)) == (VT_BYREF|VT_ARRAY)) ? *(px->pparray) : (((px->vt & VT_ARRAY) == VT_ARRAY) ? px->parray : NULL));}
IUnknown* __fastcall DsoPVarUnkFromPVar(VARIANT* px)
{return (((px->vt == VT_DISPATCH) || (px->vt == VT_UNKNOWN)) ? px->punkVal : (((px->vt == (VT_DISPATCH|VT_BYREF)) || (px->vt == (VT_UNKNOWN|VT_BYREF))) ? *(px->ppunkVal) : NULL));}
SHORT __fastcall DsoPVarShortFromPVar(VARIANT* px, SHORT fdef)
{return (((px->vt & 0xFF) != VT_I2) ? fdef : ((px->vt & VT_BYREF) == VT_BYREF) ? *(px->piVal) : px->iVal);}
LONG __fastcall DsoPVarLongFromPVar(VARIANT* px, LONG fdef)
{return (((px->vt & 0xFF) != VT_I4) ? (LONG)DsoPVarShortFromPVar(px, (SHORT)fdef) : ((px->vt & VT_BYREF) == VT_BYREF) ? *(px->plVal) : px->lVal);}
BOOL __fastcall DsoPVarBoolFromPVar(VARIANT* px, BOOL fdef)
{return (((px->vt & 0xFF) != VT_BOOL) ? (BOOL)DsoPVarLongFromPVar(px, (LONG)fdef) : ((px->vt & VT_BYREF) == VT_BYREF) ? (BOOL)(*(px->pboolVal)) : (BOOL)(px->boolVal));}
////////////////////////////////////////////////////////////////////////
// Win32 Unicode API wrappers
//
// This project is not compiled to Unicode in order for it to run on Win9x
// machines. However, in order to try to keep the code language/locale neutral
// we use these wrappers to call the Unicode API functions when supported,
// and thunk down strings to local code page if must run MBCS API.
//
////////////////////////////////////////////////////////////////////////
// FFileExists
//
// Returns TRUE if the given file exists. Does not handle URLs.
//
STDAPI_(BOOL) FFileExists(WCHAR* wzPath)
{
DWORD dw = 0xFFFFFFFF;
if (v_fUnicodeAPI)
{
dw = GetFileAttributesW(wzPath);
}
else
{
LPSTR psz = DsoConvertToMBCS(wzPath);
if (psz) dw = GetFileAttributesA(psz);
DsoMemFree(psz);
}
return (dw != 0xFFFFFFFF);
}
////////////////////////////////////////////////////////////////////////
// FOpenLocalFile
//
// Returns TRUE if the file can be opened with the access required.
// Use the handle for ReadFile/WriteFile operations as normal.
//
STDAPI_(BOOL) FOpenLocalFile(WCHAR* wzFilePath, DWORD dwAccess, DWORD dwShareMode, DWORD dwCreate, HANDLE* phFile)
{
CHECK_NULL_RETURN(phFile, FALSE);
*phFile = INVALID_HANDLE_VALUE;
if (v_fUnicodeAPI)
{
*phFile = CreateFileW(wzFilePath, dwAccess, dwShareMode, NULL, dwCreate, FILE_ATTRIBUTE_NORMAL, NULL);
}
else
{
LPSTR psz = DsoConvertToMBCS(wzFilePath);
if (psz) *phFile = CreateFileA(psz, dwAccess, dwShareMode, NULL, dwCreate, FILE_ATTRIBUTE_NORMAL, NULL);
DsoMemFree(psz);
}
return (*phFile != INVALID_HANDLE_VALUE);
}
////////////////////////////////////////////////////////////////////////
// FPerformShellOp
//
// This function started as a wrapper for SHFileOperation, but that
// shell function had an enormous performance hit, especially on Win9x
// and NT4. To speed things up we removed the shell32 call and are
// using the kernel32 APIs instead. The only drawback is we can't
// handle multiple files, but that is not critical for this project.
//
STDAPI_(BOOL) FPerformShellOp(DWORD dwOp, WCHAR* wzFrom, WCHAR* wzTo)
{
BOOL f = FALSE;
if (v_fUnicodeAPI)
{
switch (dwOp)
{
case FO_COPY: f = CopyFileW(wzFrom, wzTo, FALSE); break;
case FO_MOVE:
case FO_RENAME: f = MoveFileW(wzFrom, wzTo); break;
case FO_DELETE: f = DeleteFileW(wzFrom); break;
}
}
else
{
LPSTR pszFrom = DsoConvertToMBCS(wzFrom);
LPSTR pszTo = DsoConvertToMBCS(wzTo);
switch (dwOp)
{
case FO_COPY: f = CopyFileA(pszFrom, pszTo, FALSE); break;
case FO_MOVE:
case FO_RENAME: f = MoveFileA(pszFrom, pszTo); break;
case FO_DELETE: f = DeleteFileA(pszFrom); break;
}
if (pszFrom) DsoMemFree(pszFrom);
if (pszTo) DsoMemFree(pszTo);
}
return f;
}
////////////////////////////////////////////////////////////////////////
// FGetModuleFileName
//
// Handles Unicode/ANSI paths from a module handle.
//
STDAPI_(BOOL) FGetModuleFileName(HMODULE hModule, WCHAR** wzFileName)
{
LPWSTR pwsz;
DWORD dw;
CHECK_NULL_RETURN(wzFileName, FALSE);
*wzFileName = NULL;
pwsz = (LPWSTR)DsoMemAlloc((MAX_PATH * sizeof(WCHAR)));
CHECK_NULL_RETURN(pwsz, FALSE);
if (v_fUnicodeAPI)
{
dw = GetModuleFileNameW(hModule, pwsz, MAX_PATH);
if (dw == 0)
{
DsoMemFree(pwsz);
return FALSE;
}
}
else
{
dw = GetModuleFileNameA(hModule, (LPSTR)pwsz, MAX_PATH);
if (dw == 0)
{
DsoMemFree(pwsz);
return FALSE;
}
LPWSTR pwsz2 = DsoConvertToLPWSTR((LPSTR)pwsz);
if (pwsz2 == NULL)
{
DsoMemFree(pwsz);
return FALSE;
}
DsoMemFree(pwsz);
pwsz = pwsz2;
}
*wzFileName = pwsz;
return TRUE;
}
////////////////////////////////////////////////////////////////////////
// FIsIECacheFile
//
// Determines if file came from IE Cache (treat as read-only).
//
STDAPI_(BOOL) FIsIECacheFile(LPWSTR pwszFile)
{
BOOL fIsCacheFile = FALSE;
LPWSTR pwszTmpCache = NULL;
BYTE rgbuffer[MAX_PATH * sizeof(WCHAR)];
HKEY hk;
if (RegOpenKey(HKEY_CURRENT_USER,
"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders", &hk) == ERROR_SUCCESS)
{
DWORD dwT, dwS; dwT = MAX_PATH;
memset(rgbuffer, 0, (MAX_PATH * sizeof(WCHAR)));
if (v_fUnicodeAPI)
{
if ((RegQueryValueExA(hk, "Cache", 0, &dwT, rgbuffer, &dwS) == ERROR_SUCCESS) &&
(dwT == REG_SZ) && (dwS > 1))
pwszTmpCache = DsoConvertToLPWSTR((LPSTR)rgbuffer);
}
else
{
if ((RegQueryValueExW(hk, L"Cache", 0, &dwT, rgbuffer, &dwS) == ERROR_SUCCESS) &&
(dwT == REG_SZ) && (dwS > 1))
pwszTmpCache = DsoCopyString((LPWSTR)rgbuffer);
}
RegCloseKey(hk);
if (pwszTmpCache)
{
dwS = lstrlenW(pwszTmpCache);
dwT = lstrlenW(pwszFile);
fIsCacheFile = ((dwS < dwT) &&
(DsoCompareStringsEx(pwszTmpCache, dwS, pwszFile, dwS) == CSTR_EQUAL));
DsoMemFree(pwszTmpCache);
}
}
return fIsCacheFile;
}
////////////////////////////////////////////////////////////////////////
// FDrawText
//
// This is used by the control for drawing the caption in the titlebar.
// Since a custom caption could contain Unicode characters only printable
// on Unicode OS, we should try to use the Unicode version when available.
//
STDAPI_(BOOL) FDrawText(HDC hdc, WCHAR* pwsz, LPRECT prc, UINT fmt)
{
BOOL f;
if (v_fUnicodeAPI)
{
f = (BOOL)DrawTextW(hdc, pwsz, -1, prc, fmt);
}
else
{
LPSTR psz = DsoConvertToMBCS(pwsz);
f = (BOOL)DrawTextA(hdc, psz, -1, prc, fmt);
DsoMemFree(psz);
}
return f;
}
////////////////////////////////////////////////////////////////////////
// FSetRegKeyValue
//
// We use this for registration when dealing with the file path, since
// that path may have Unicode characters on some systems. Win9x boxes
// will have to be converted to ANSI.
//
STDAPI_(BOOL) FSetRegKeyValue(HKEY hk, WCHAR* pwsz)
{
LONG lret;
if (v_fUnicodeAPI)
{
lret = RegSetValueExW(hk, NULL, 0, REG_SZ, (BYTE*)pwsz, (lstrlenW(pwsz) * sizeof(WCHAR)));
}
else
{
LPSTR psz = DsoConvertToMBCS(pwsz);
lret = RegSetValueExA(hk, NULL, 0, REG_SZ, (BYTE*)psz, lstrlen(psz));
DsoMemFree(psz);
}
return (lret == ERROR_SUCCESS);
}
////////////////////////////////////////////////////////////////////////
// FOpenPrinter
//
// Open the specified printer by name.
//
STDAPI_(BOOL) FOpenPrinter(LPCWSTR pwszPrinter, LPHANDLE phandle)
{
BOOL fRet = FALSE;
DWORD dwLastError = 0;
if (v_fUnicodeAPI)
{
PRINTER_DEFAULTSW prtdef;
memset(&prtdef, 0, sizeof(PRINTER_DEFAULTSW));
prtdef.DesiredAccess = PRINTER_ACCESS_USE;
fRet = OpenPrinterW((LPWSTR)pwszPrinter, phandle, &prtdef);
}
else
{
LPSTR psz = DsoConvertToMBCS(pwszPrinter);
fRet = OpenPrinterA(psz, phandle, NULL);
if (!fRet) dwLastError = GetLastError();
DsoMemFree(psz);
}
if (dwLastError) SetLastError(dwLastError);
return fRet;
}
////////////////////////////////////////////////////////////////////////
// FGetPrinterSettings
//
// Returns the default device, port name, and DEVMODE structure for the
// printer passed. Handles Unicode translation of DEVMODE if on Win9x.
//
STDAPI_(BOOL) FGetPrinterSettings(HANDLE hprinter, LPWSTR *ppwszProcessor, LPWSTR *ppwszDevice, LPWSTR *ppwszOutput, LPDEVMODEW *ppdvmode, DWORD *pcbSize)
{
BOOL fRet = FALSE;
DWORD dwLastError = 0;
DWORD cbNeed, cbAlloc = 0;
if ((ppwszProcessor == NULL) || (ppwszDevice == NULL) || (ppwszOutput == NULL) ||
(ppdvmode == NULL) || (pcbSize == NULL))
return FALSE;
*ppwszProcessor = NULL; *ppwszDevice = NULL; *ppwszOutput = NULL;
*ppdvmode = NULL; *pcbSize = 0;
if (v_fUnicodeAPI) // Use Unicode API if possible (much easier)...
{
GetPrinterW(hprinter, 2, NULL, 0, &cbAlloc);
PRINTER_INFO_2W *pinfo = (PRINTER_INFO_2W*)DsoMemAlloc(++cbAlloc);
if (pinfo)
{
fRet = GetPrinterW(hprinter, 2, (BYTE*)pinfo, cbAlloc, &cbNeed);
if (fRet)
{
*ppwszProcessor = DsoConvertToLPWSTR("winspool");
*ppwszDevice = DsoCopyString(pinfo->pDriverName);
*ppwszOutput = DsoCopyString(pinfo->pPortName);
if (pinfo->pDevMode) // If we have the devmode, just need to copy it...
{
DWORD cbData = (pinfo->pDevMode->dmSize) + (pinfo->pDevMode->dmDriverExtra);
*ppdvmode = (DEVMODEW*)DsoMemAlloc(cbData);
if (*ppdvmode)
{
memcpy(*ppdvmode, pinfo->pDevMode, cbData);
*pcbSize = cbData;
}
}
}
else dwLastError = GetLastError();
DsoMemFree(pinfo);
}
else dwLastError = ERROR_NOT_ENOUGH_MEMORY;
}
else
{
GetPrinterA(hprinter, 2, NULL, 0, &cbAlloc);
PRINTER_INFO_2A *pinfo = (PRINTER_INFO_2A*)DsoMemAlloc(++cbAlloc);
if (pinfo)
{
fRet = GetPrinterA(hprinter, 2, (BYTE*)pinfo, cbAlloc, &cbNeed);
if (fRet)
{
*ppwszProcessor = DsoConvertToLPWSTR("winspool");
*ppwszDevice = DsoConvertToLPWSTR(pinfo->pDriverName);
*ppwszOutput = DsoConvertToLPWSTR(pinfo->pPortName);
if (pinfo->pDevMode) // For Win9x API, we have to convert the DEVMODEA
{ // into DEVMODEW so we have Unicode names for TARGETDEVICE...
DWORD cbData = sizeof(DEVMODEW) +
((pinfo->pDevMode->dmSize > sizeof(DEVMODEA)) ? (pinfo->pDevMode->dmSize - sizeof(DEVMODEA)) : 0) +
pinfo->pDevMode->dmDriverExtra;
*ppdvmode = (DEVMODEW*)DsoMemAlloc(cbData);
if (*ppdvmode)
{
DsoConvertToUnicodeEx(
(LPSTR)(pinfo->pDevMode->dmDeviceName), CCHDEVICENAME,
(LPWSTR)((*ppdvmode)->dmDeviceName), CCHDEVICENAME, 0);
// The rest of the copy depends on the default size of the DEVMODE.
// Just check the size and convert the form name if it exists...
if (pinfo->pDevMode->dmSize <= FIELD_OFFSET(DEVMODEA, dmFormName))
{
memcpy(&((*ppdvmode)->dmSpecVersion),
&(pinfo->pDevMode->dmSpecVersion),
pinfo->pDevMode->dmSize - CCHDEVICENAME);
}
else
{
memcpy(&((*ppdvmode)->dmSpecVersion),
&(pinfo->pDevMode->dmSpecVersion),
FIELD_OFFSET(DEVMODEA, dmFormName) -
FIELD_OFFSET(DEVMODEA, dmSpecVersion));
DsoConvertToUnicodeEx(
(LPSTR)(pinfo->pDevMode->dmFormName), CCHFORMNAME,
(LPWSTR)((*ppdvmode)->dmFormName), CCHFORMNAME, 0);
if (pinfo->pDevMode->dmSize > FIELD_OFFSET(DEVMODEA, dmLogPixels))
memcpy(&((*ppdvmode)->dmLogPixels),
&(pinfo->pDevMode->dmLogPixels),
pinfo->pDevMode->dmSize - FIELD_OFFSET(DEVMODEA, dmLogPixels));
}
(*ppdvmode)->dmSize = (WORD)((pinfo->pDevMode->dmSize > sizeof(DEVMODEA)) ?
(sizeof(DEVMODEW) + (pinfo->pDevMode->dmSize - sizeof(DEVMODEA))) :
sizeof(DEVMODEW));
memcpy((((BYTE*)(*ppdvmode)) + ((*ppdvmode)->dmSize)),
(((BYTE*)(pinfo->pDevMode)) + (pinfo->pDevMode->dmSize)),
pinfo->pDevMode->dmDriverExtra);
*pcbSize = cbData;
}
}
}
else dwLastError = GetLastError();
DsoMemFree(pinfo);
}
else dwLastError = ERROR_NOT_ENOUGH_MEMORY;
}
if (dwLastError) SetLastError(dwLastError);
return fRet;
}
///////////////////////////////////////////////////////////////////////////////////
// DsoGetFileFromUser
//
// Displays the Open/Save dialog using Unicode version if available. Returns the
// path as a unicode BSTR regardless of OS.
//
STDAPI DsoGetFileFromUser(HWND hwndOwner, LPCWSTR pwzTitle, DWORD dwFlags,
LPCWSTR pwzFilter, DWORD dwFiltIdx, LPCWSTR pwszDefExt, LPCWSTR pwszCurrentItem, BOOL fShowSave,
BSTR *pbstrFile, BOOL *pfReadOnly)
{
BYTE buffer[MAX_PATH * sizeof(WCHAR)];
BOOL fSuccess;
DWORD dw;
// Make sure they pass a *bstr...
CHECK_NULL_RETURN(pbstrFile, E_POINTER);
*pbstrFile = NULL;
buffer[0] = 0; buffer[1] = 0;
// See if we have Unicode function to call. If so, we use OPENFILENAMEW and
// get the file path in Unicode, returned as BSTR...
if (v_fUnicodeAPI)
{
OPENFILENAMEW ofnw;
memset(&ofnw, 0, sizeof(OPENFILENAMEW));
ofnw.lStructSize = sizeof(OPENFILENAMEW);
ofnw.hwndOwner = hwndOwner;
ofnw.lpstrFilter = pwzFilter;
ofnw.nFilterIndex = dwFiltIdx;
ofnw.lpstrDefExt = pwszDefExt;
ofnw.lpstrTitle = pwzTitle;
ofnw.lpstrFile = (LPWSTR)&buffer[0];
ofnw.nMaxFile = MAX_PATH;
ofnw.Flags = dwFlags;
if (pwszCurrentItem)
{
dw = lstrlenW(pwszCurrentItem);
if ((dw) && (dw < MAX_PATH))
{
memcpy(ofnw.lpstrFile, pwszCurrentItem, dw * sizeof(WCHAR));
ofnw.lpstrFile[dw] = L'\0';
}
}
if (fShowSave)
fSuccess = GetSaveFileNameW(&ofnw);
else
fSuccess = GetOpenFileNameW(&ofnw);
if (fSuccess)
{
*pbstrFile = SysAllocString((LPWSTR)&buffer[0]);
if (pfReadOnly) *pfReadOnly = (ofnw.Flags & OFN_READONLY);
}
}
else
{ // If not, then we use OPENFILENAMEA and thunk down our params to
// the MBCS of the system, and then thunk back the Unicode for the return...
OPENFILENAMEA ofn;
memset(&ofn, 0, sizeof(OPENFILENAMEA));
ofn.lStructSize = sizeof(OPENFILENAMEA);
ofn.hwndOwner = hwndOwner;
ofn.lpstrFilter = DsoConvertToMBCS(pwzFilter);
ofn.nFilterIndex = dwFiltIdx;
ofn.lpstrDefExt = DsoConvertToMBCS(pwszDefExt);
ofn.lpstrTitle = DsoConvertToMBCS(pwzTitle);
ofn.lpstrFile = (LPSTR)&buffer[0];
ofn.nMaxFile = MAX_PATH;
ofn.Flags = dwFlags;
if (pwszCurrentItem)
DsoConvertToMBCSEx(pwszCurrentItem, lstrlenW(pwszCurrentItem), (LPSTR)&buffer[0], MAX_PATH, GetACP());
if (fShowSave)
fSuccess = GetSaveFileNameA(&ofn);
else
fSuccess = GetOpenFileNameA(&ofn);
if (fSuccess)
{
*pbstrFile = DsoConvertToBSTR((LPCSTR)&buffer[0]);
if (pfReadOnly) *pfReadOnly = (ofn.Flags & OFN_READONLY);
}
DsoMemFree((void*)(ofn.lpstrDefExt));
DsoMemFree((void*)(ofn.lpstrFilter));
DsoMemFree((void*)(ofn.lpstrTitle));
}
// If we got a string, then success. All other errors (even user cancel) should
// be treated as a general failure (feel free to change this for more full function).
return ((*pbstrFile == NULL) ? E_FAIL : S_OK);
}
///////////////////////////////////////////////////////////////////////////////////
// DsoGetOleInsertObjectFromUser
//
// Displays the OLE InsertObject dialog using Unicode version if available.
//
STDAPI DsoGetOleInsertObjectFromUser(HWND hwndOwner, LPCWSTR pwzTitle, DWORD dwFlags,
BOOL fDocObjectOnly, BOOL fAllowControls, BSTR *pbstrResult, UINT *ptype)
{
BYTE buffer[MAX_PATH * sizeof(WCHAR)];
LPCLSID lpNewExcludeList = NULL;
int nNewExcludeCount = 0;
int nNewExcludeLen = 0;
// Make sure they pass a *bstr...
CHECK_NULL_RETURN(pbstrResult, E_POINTER);
*pbstrResult = NULL;
// To limit list to just those marked as DocObject servers, you have to enum
// the registry and create an exclude list for OLE dialog. Exclude all except
// those that are marked DocObject under their ProgID.
if (fDocObjectOnly)
{
HKEY hkCLSID;
HKEY hkItem;
HKEY hkDocObject;
DWORD dwIndex = 0;
CHAR szName[MAX_PATH+1];
if (RegOpenKeyEx(HKEY_CLASSES_ROOT, "CLSID", 0, KEY_READ|KEY_ENUMERATE_SUB_KEYS, &hkCLSID) == ERROR_SUCCESS)
{
while (RegEnumKey(hkCLSID, dwIndex++, szName, MAX_PATH) == ERROR_SUCCESS)
{
if (RegOpenKeyEx(hkCLSID, szName, 0, KEY_READ, &hkItem) == ERROR_SUCCESS)
{
if ((RegOpenKeyEx(hkItem, "DocObject", 0, KEY_READ, &hkDocObject) != ERROR_SUCCESS))
{
CLSID clsid;
LPWSTR pwszClsid = DsoConvertToLPWSTR(szName);
if ((pwszClsid) && SUCCEEDED(CLSIDFromString(pwszClsid, &clsid)))
{
if (lpNewExcludeList == NULL)
{
nNewExcludeCount = 0;
nNewExcludeLen = 16;
lpNewExcludeList = new CLSID[nNewExcludeLen];
}
if (nNewExcludeCount == nNewExcludeLen)
{
LPCLSID lpOldList = lpNewExcludeList;
nNewExcludeLen <<= 2;
lpNewExcludeList = new CLSID[nNewExcludeLen];
memcpy(lpNewExcludeList, lpOldList, sizeof(CLSID) * nNewExcludeCount);
delete [] lpOldList;
}
lpNewExcludeList[nNewExcludeCount] = clsid;
nNewExcludeCount++;
}
SAFE_FREESTRING(pwszClsid);
RegCloseKey(hkDocObject);
}
RegCloseKey(hkItem);
}
}
RegCloseKey(hkCLSID);
}
}
buffer[0] = 0; buffer[1] = 0;
// See if we have Unicode function to call...
if (v_fUnicodeAPI)
{
OLEUIINSERTOBJECTW oidlg = {0};
oidlg.cbStruct = sizeof(OLEUIINSERTOBJECTW);
oidlg.dwFlags = dwFlags;
oidlg.hWndOwner = hwndOwner;
oidlg.lpszCaption = pwzTitle;
oidlg.lpszFile = (LPWSTR)buffer;
oidlg.cchFile = MAX_PATH;
oidlg.lpClsidExclude = lpNewExcludeList;
oidlg.cClsidExclude = nNewExcludeCount;
if (OleUIInsertObjectW(&oidlg) == OLEUI_OK)
{
if ((oidlg.dwFlags & IOF_SELECTCREATENEW) && (oidlg.clsid != GUID_NULL))
{
LPOLESTR posz;
if (SUCCEEDED(ProgIDFromCLSID(oidlg.clsid, &posz)))
{
*pbstrResult = SysAllocString(posz);
CoTaskMemFree(posz);
}
if (ptype) *ptype = IOF_SELECTCREATENEW;
}
else if ((oidlg.dwFlags & IOF_SELECTCREATEFROMFILE) && (buffer[0] != 0))
{
*pbstrResult = SysAllocString((LPWSTR)buffer);
if (ptype) *ptype = IOF_SELECTCREATEFROMFILE;
}
}
}
else
{
OLEUIINSERTOBJECTA oidlg = {0};
oidlg.cbStruct = sizeof(OLEUIINSERTOBJECTA);
oidlg.dwFlags = dwFlags;
oidlg.hWndOwner = hwndOwner;
oidlg.lpszCaption = DsoConvertToMBCS(pwzTitle);
oidlg.lpszFile = (LPSTR)buffer;
oidlg.cchFile = MAX_PATH;
oidlg.lpClsidExclude = lpNewExcludeList;
oidlg.cClsidExclude = nNewExcludeCount;
if (OleUIInsertObjectA(&oidlg) == OLEUI_OK)
{
if ((oidlg.dwFlags & IOF_SELECTCREATENEW) && (oidlg.clsid != GUID_NULL))
{
LPOLESTR posz;
if (SUCCEEDED(ProgIDFromCLSID(oidlg.clsid, &posz)))
{
*pbstrResult = SysAllocString(posz);
CoTaskMemFree(posz);
}
if (ptype) *ptype = IOF_SELECTCREATENEW;
}
else if ((oidlg.dwFlags & IOF_SELECTCREATEFROMFILE) && (buffer[0] != 0))
{
*pbstrResult = DsoConvertToBSTR((LPSTR)buffer);
if (ptype) *ptype = IOF_SELECTCREATEFROMFILE;
}
}
DsoMemFree((void*)(oidlg.lpszCaption));
}
if (lpNewExcludeList)
delete [] lpNewExcludeList;
// If we got a string, then success. All other errors (even user cancel) should
// be treated as a general failure (feel free to change this for more full function).
return ((*pbstrResult == NULL) ? E_FAIL : S_OK);
}
Reference in New Issue View Git Blame Copy Permalink