1 files changed, 685 insertions, 0 deletions

diff --git a/private/ole2ui32/common.cpp b/private/ole2ui32/common.cpp
new file mode 100644
index 000000000..fb31a80e2
--- /dev/null
+++ b/private/ole2ui32/common.cpp
@@ -0,0 +1,685 @@
+/*
+ * COMMON.CPP
+ *
+ * Standardized (and centralized) pieces of each OLEDLG dialog function:
+ *
+ *  UStandardValidation     Validates standard fields in each dialog structure
+ *  UStandardInvocation     Invokes a dialog through DialogBoxIndirectParam
+ *  LpvStandardInit         Common WM_INITDIALOG processing
+ *  LpvStandardEntry        Common code to execute on dialog proc entry.
+ *  UStandardHook           Centralized hook calling function.
+ *  StandardCleanup         Common exit/cleanup code.
+ *  StandardShowDlgItem     Show-Enable/Hide-Disable dialog item
+ *      StandardEnableDlgItem   Enable/Disable dialog item
+ *  StandardResizeDlgY          Resize dialog to fit controls
+ *
+ * Copyright (c)1992 Microsoft Corporation, All Right Reserved
+ */
+
+#include "precomp.h"
+#include "common.h"
+#include "utility.h"
+
+OLEDBGDATA
+
+/*
+ * UStandardValidation
+ *
+ * Purpose:
+ *  Performs validation on the standard pieces of any dialog structure,
+ *  that is, the fields defined in the OLEUISTANDARD structure.
+ *
+ * Parameters:
+ *  lpUI            const LPOLEUISTANDARD pointing to the shared data of
+ *                  all structs.
+ *  cbExpect        const UINT structure size desired by the caller.
+ *  phDlgMem        const HGLOBAL FAR * in which to store a loaded customized
+ *                  template, if one exists.
+ *                  (This may be NULL in which case the template pointer isn't
+ *                  needed by the calling function and should be released.)
+ *
+ * Return Value:
+ *  UINT            OLEUI_SUCCESS if all validation succeeded.  Otherwise
+ *                  it will be one of the standard error codes.
+ */
+UINT WINAPI UStandardValidation(LPOLEUISTANDARD lpUI, const UINT cbExpect,
+        HGLOBAL* phMemDlg)
+{
+        /*
+         * 1.  Validate non-NULL pointer parameter.  Note:  We don't validate
+         *     phDlg since it's not passed from an external source.
+         */
+        if (NULL == lpUI)
+                return OLEUI_ERR_STRUCTURENULL;
+
+        // 2.  Validate that the structure is readable and writable.
+        if (IsBadWritePtr(lpUI, cbExpect))
+                return OLEUI_ERR_STRUCTUREINVALID;
+
+        // 3.  Validate the structure size
+        if (cbExpect != lpUI->cbStruct)
+                return OLEUI_ERR_CBSTRUCTINCORRECT;
+
+        // 4.  Validate owner-window handle.  NULL is considered valid.
+        if (NULL != lpUI->hWndOwner && !IsWindow(lpUI->hWndOwner))
+                return OLEUI_ERR_HWNDOWNERINVALID;
+
+        // 5.  Validate the dialog caption.  NULL is considered valid.
+        if (NULL != lpUI->lpszCaption && IsBadReadPtr(lpUI->lpszCaption, 1))
+                return OLEUI_ERR_LPSZCAPTIONINVALID;
+
+        // 6.  Validate the hook pointer.  NULL is considered valid.
+        if (NULL != lpUI->lpfnHook && IsBadCodePtr((FARPROC)lpUI->lpfnHook))
+                return OLEUI_ERR_LPFNHOOKINVALID;
+
+        /*
+         * 7.  If hInstance is non-NULL, we have to also check lpszTemplate.
+         *     Otherwise, lpszTemplate is not used and requires no validation.
+         *     lpszTemplate cannot be NULL if used.
+         */
+        HGLOBAL hMem = NULL;
+        if (NULL != lpUI->hInstance)
+        {
+                //Best we can try is one character
+                if (NULL == lpUI->lpszTemplate || (HIWORD(lpUI->lpszTemplate) != 0 &&
+                        IsBadReadPtr(lpUI->lpszTemplate, 1)))
+                        return OLEUI_ERR_LPSZTEMPLATEINVALID;
+                HRSRC hRes = FindResource(lpUI->hInstance, lpUI->lpszTemplate, RT_DIALOG);
+                if (NULL == hRes)
+                    return OLEUI_ERR_FINDTEMPLATEFAILURE;
+
+                hMem = LoadResource(lpUI->hInstance, hRes);
+                if (NULL == hMem)
+                    return OLEUI_ERR_LOADTEMPLATEFAILURE;
+        }
+
+        // 8. If hResource is non-NULL, be sure we can lock it.
+        if (NULL != lpUI->hResource)
+        {
+                if ((LPSTR)NULL == LockResource(lpUI->hResource))
+                        return OLEUI_ERR_HRESOURCEINVALID;
+        }
+
+        /*
+         * Here we have hMem==NULL if we should use the standard template
+         * or the one in lpUI->hResource.  If hMem is non-NULL, then we
+         * loaded one from the calling application's resources which the
+         * caller of this function has to free if it sees any other error.
+         */
+        if (NULL != phMemDlg)
+        {
+            *phMemDlg = hMem;
+        }
+        return OLEUI_SUCCESS;
+}
+
+/*
+ * UStandardInvocation
+ *
+ * Purpose:
+ *  Provides standard template loading and calling on DialogBoxIndirectParam
+ *  for all the OLE UI dialogs.
+ *
+ * Parameters:
+ *  lpDlgProc       DLGPROC of the dialog function.
+ *  lpUI            LPOLEUISTANDARD containing the dialog structure.
+ *  hMemDlg         HGLOBAL containing the dialog template.  If this
+ *                  is NULL and lpUI->hResource is NULL, then we load
+ *                  the standard template given the name in lpszStdTemplate
+ *  lpszStdTemplate LPCSTR standard template to load if hMemDlg is NULL
+ *                  and lpUI->hResource is NULL.
+ *
+ * Return Value:
+ *  UINT            OLEUI_SUCCESS if all is well, otherwise and error
+ *                  code.
+ */
+UINT WINAPI UStandardInvocation(
+        DLGPROC lpDlgProc, LPOLEUISTANDARD lpUI, HGLOBAL hMemDlg, LPTSTR lpszStdTemplate)
+{
+        // Make sure we have a template, then lock it down
+        HGLOBAL hTemplate = hMemDlg;
+        if (NULL == hTemplate)
+                hTemplate = lpUI->hResource;
+
+        if (NULL == hTemplate)
+        {
+                HRSRC hRes = FindResource(_g_hOleStdResInst, (LPCTSTR) lpszStdTemplate, RT_DIALOG);
+                if (NULL == hRes)
+                        return OLEUI_ERR_FINDTEMPLATEFAILURE;
+
+                hTemplate = LoadResource(_g_hOleStdResInst, hRes);
+                if (NULL == hTemplate)
+                        return OLEUI_ERR_LOADTEMPLATEFAILURE;
+        }
+
+        /*
+         * hTemplate has the template to use, so now we can invoke the dialog.
+         * Since we have exported all of our dialog procedures using the
+         * _keyword, we do not need to call MakeProcInstance,
+         * we can ue the dialog procedure address directly.
+         */
+
+        int iRet = DialogBoxIndirectParam(_g_hOleStdResInst, (LPCDLGTEMPLATE)hTemplate,
+                lpUI->hWndOwner, lpDlgProc, (LPARAM)lpUI);
+
+        if (-1 == iRet)
+                return OLEUI_ERR_DIALOGFAILURE;
+
+        // Return the code from EndDialog, generally OLEUI_OK or OLEUI_CANCEL
+        return (UINT)iRet;
+}
+
+/*
+ * LpvStandardInit
+ *
+ * Purpose:
+ *  Default actions for WM_INITDIALOG handling in the dialog, allocating
+ *  a dialog-specific structure, setting that memory as a dialog property,
+ *  and creating a small font if necessary setting that font as a property.
+ *
+ * Parameters:
+ *  hDlg            HWND of the dialog
+ *  cbStruct        UINT size of dialog-specific structure to allocate.
+ *  fCreateFont     BOOL indicating if we need to create a small Helv
+ *                  font for this dialog.
+ *  phFont          HFONT FAR * in which to place a created font.  Can be
+ *                  NULL if fCreateFont is FALSE.
+ *
+ * Return Value:
+ *  LPVOID          Pointer to global memory allocated for the dialog.
+ *                  The memory will have been set as a dialog property
+ *                  using the STRUCTUREPROP label.
+ */
+LPVOID WINAPI LpvStandardInit(HWND hDlg, UINT cbStruct, HFONT* phFont)
+{
+        // Must have at least sizeof(void*) bytes in cbStruct
+        if (sizeof(void*) > cbStruct)
+        {
+                PostMessage(hDlg, uMsgEndDialog, OLEUI_ERR_GLOBALMEMALLOC, 0L);
+                return NULL;
+        }
+
+        HGLOBAL gh = GlobalAlloc(GHND, cbStruct);
+        if (NULL == gh)
+        {
+                PostMessage(hDlg, uMsgEndDialog, OLEUI_ERR_GLOBALMEMALLOC, 0L);
+                return NULL;
+        }
+        LPVOID lpv = GlobalLock(gh);
+        SetProp(hDlg, STRUCTUREPROP, gh);
+
+        if (phFont != NULL)
+            *phFont = NULL;
+        if (!bWin4 && phFont != NULL)
+        {
+                // Create the non-bold font for result and file texts.  We call
+                HFONT hFont = (HFONT)SendMessage(hDlg, WM_GETFONT, 0, 0L);
+                LOGFONT lf;
+                GetObject(hFont, sizeof(LOGFONT), &lf);
+                lf.lfWeight = FW_NORMAL;
+
+                // Attempt to create the font.  If this fails, then we return no font.
+                *phFont = CreateFontIndirect(&lf);
+
+                // If we couldn't create the font, we'll do with the default.
+                if (NULL != *phFont)
+                        SetProp(hDlg, FONTPROP, (HANDLE)*phFont);
+        }
+
+        // Setup the context help mode (WS_EX_CONTEXTHELP)
+        if (bWin4)
+        {
+                DWORD dwExStyle = GetWindowLong(hDlg, GWL_EXSTYLE);
+                dwExStyle |= WS_EX_CONTEXTHELP;
+                SetWindowLong(hDlg, GWL_EXSTYLE, dwExStyle);
+        }
+
+        return lpv;
+}
+
+typedef struct COMMON
+{
+        OLEUISTANDARD*  pStandard;
+        UINT                    nIDD;
+
+} COMMON, *PCOMMON, FAR* LPCOMMON;
+
+/*
+ * LpvStandardEntry
+ *
+ * Purpose:
+ *  Retrieves the dialog's structure property and calls the hook
+ *  as necessary.  This should be called on entry into all dialog
+ *  procedures.
+ *
+ * Parameters:
+ *  hDlg            HWND of the dialog
+ *  iMsg            UINT message to the dialog
+ *  wParam, lParam  WPARAM, LPARAM message parameters
+ *  puHookResult    UINT FAR * in which this function stores the return value
+ *                  from the hook if it is called.  If no hook is available,
+ *                  this will be FALSE.
+ *
+ * Return Value:
+ *  LPVOID          Pointer to the dialog's extra structure held in the
+ *                  STRUCTUREPROP property.
+ */
+LPVOID WINAPI LpvStandardEntry(HWND hDlg, UINT iMsg,
+        WPARAM wParam, LPARAM lParam, UINT FAR * puHookResult)
+{
+        // This will fail under WM_INITDIALOG, where we allocate using StandardInit
+        LPVOID  lpv = NULL;
+        HGLOBAL gh = GetProp(hDlg, STRUCTUREPROP);
+
+        if (NULL != puHookResult && NULL != gh)
+        {
+                *puHookResult = 0;
+
+                // gh was locked previously, lock and unlock to get lpv
+                lpv = GlobalLock(gh);
+                GlobalUnlock(gh);
+
+                // Call the hook for all messages except WM_INITDIALOG
+                if (NULL != lpv && WM_INITDIALOG != iMsg)
+                        *puHookResult = UStandardHook(lpv, hDlg, iMsg, wParam, lParam);
+
+                // Default processing for various messages
+                LPCOMMON lpCommon = (LPCOMMON)lpv;
+                if (*puHookResult == 0 && NULL != lpv)
+                {
+                        switch (iMsg)
+                        {
+                        // handle standard Win4 help messages
+                        case WM_HELP:
+                        {
+                            HWND hWnd = (HWND)((LPHELPINFO)lParam)->hItemHandle;
+                            StandardHelp(hWnd, lpCommon->nIDD);
+                            break;
+                        }
+                        case WM_CONTEXTMENU:
+                                StandardContextMenu(wParam, lParam, lpCommon->nIDD);
+                                break;
+
+                        // make readonly edits have gray background
+                        case WM_CTLCOLOREDIT:
+                                if (bWin4 && (GetWindowLong((HWND)lParam, GWL_STYLE)
+                                        & ES_READONLY))
+                                {
+                                        *puHookResult = SendMessage(hDlg, WM_CTLCOLORSTATIC,
+                                            wParam, lParam);
+                                }
+                                break;
+                        }
+                }
+        }
+        return lpv;
+}
+
+/*
+ * UStandardHook
+ *
+ * Purpose:
+ *  Provides a generic hook calling function assuming that all private
+ *  dialog structures have a far pointer to their assocated public
+ *  structure as the first field, and that the first part of the public
+ *  structure matches an OLEUISTANDARD.
+ *
+ * Parameters:
+ *  pv              PVOID to the dialog structure.
+ *  hDlg            HWND to send with the call to the hook.
+ *  iMsg            UINT message to send to the hook.
+ *  wParam, lParam  WPARAM, LPARAM message parameters
+ *
+ * Return Value:
+ *  UINT            Return value from the hook, zero to indicate that
+ *                  default action should occur,  nonzero to specify
+ *                  that the hook did process the message.  In some
+ *                  circumstances it will be important for the hook to
+ *                  return a non-trivial non-zero value here, such as
+ *                  a brush from WM_CTLCOLOR, in which case the caller
+ *                  should return that value from the dialog procedure.
+ */
+UINT WINAPI UStandardHook(LPVOID lpv, HWND hDlg, UINT iMsg,
+        WPARAM wParam, LPARAM lParam)
+{
+        UINT uRet = 0;
+        LPOLEUISTANDARD lpUI = *((LPOLEUISTANDARD FAR *)lpv);
+        if (NULL != lpUI && NULL != lpUI->lpfnHook)
+        {
+                /*
+                 * In order for the hook to have the proper DS, they should be
+                 * compiling with -GA -GEs so and usin __to get everything
+                 * set up properly.
+                 */
+                uRet = (*lpUI->lpfnHook)(hDlg, iMsg, wParam, lParam);
+        }
+        return uRet;
+}
+
+/*
+ * StandardCleanup
+ *
+ * Purpose:
+ *  Removes properties and reverses any other standard initiazation
+ *  done through StandardSetup.
+ *
+ * Parameters:
+ *  lpv             LPVOID containing the private dialog structure.
+ *  hDlg            HWND of the dialog closing.
+ *
+ * Return Value:
+ *  None
+ */
+void WINAPI StandardCleanup(LPVOID lpv, HWND hDlg)
+{
+        HFONT hFont=(HFONT)GetProp(hDlg, FONTPROP);
+        if (NULL != hFont)
+        {
+            DeleteObject(hFont);
+            RemoveProp(hDlg, FONTPROP);
+        }
+
+        HGLOBAL gh = RemoveProp(hDlg, STRUCTUREPROP);
+        if (gh != NULL)
+        {
+                GlobalUnlock(gh);
+                GlobalFree(gh);
+        }
+}
+
+/* StandardShowDlgItem
+ * -------------------
+ *    Show & Enable or Hide & Disable a dialog item as appropriate.
+ *    it is NOT sufficient to simply hide the item; it must be disabled
+ *    too or the keyboard accelerator still functions.
+ */
+void WINAPI StandardShowDlgItem(HWND hDlg, int idControl, int nCmdShow)
+{
+        HWND hItem = GetDlgItem(hDlg, idControl);
+        if (hItem != NULL)
+        {
+                ShowWindow(hItem, nCmdShow);
+                EnableWindow(hItem, nCmdShow != SW_HIDE);
+        }
+}
+
+/* StandardEnableDlgItem
+ * -------------------
+ *    Enable/Disable a dialog item. If the item does not exist
+ *        this call is a noop.
+ */
+void WINAPI StandardEnableDlgItem(HWND hDlg, int idControl, BOOL bEnable)
+{
+        HWND hItem = GetDlgItem(hDlg, idControl);
+        if (hItem != NULL)
+                EnableWindow(hItem, bEnable);
+}
+
+/* StandardResizeDlgY
+ * ------------------
+ *    Resize a dialog to fit around the visible controls.  This is used
+ *        for dialogs which remove controls from the bottom of the dialogs.
+ *    A good example of this is the convert dialog, which when CF_HIDERESULTS
+ *    is selected, removes the "results box" at the bottom of the dialog.
+ *        This implementation currently
+ */
+BOOL WINAPI StandardResizeDlgY(HWND hDlg)
+{
+        RECT rect;
+
+        // determine maxY by looking at all child windows on the dialog
+        int maxY = 0;
+        HWND hChild = GetWindow(hDlg, GW_CHILD);
+        while (hChild != NULL)
+        {
+                if (GetWindowLong(hChild, GWL_STYLE) & WS_VISIBLE)
+                {
+                        GetWindowRect(hChild, &rect);
+                        if (rect.bottom > maxY)
+                                maxY = rect.bottom;
+                }
+                hChild = GetWindow(hChild, GW_HWNDNEXT);
+        }
+
+        if (maxY > 0)
+        {
+                // get current font that the dialog is using
+                HFONT hFont = (HFONT)SendMessage(hDlg, WM_GETFONT, 0, 0);
+                if (hFont == NULL)
+                        hFont = (HFONT)GetStockObject(SYSTEM_FONT);
+                OleDbgAssert(hFont != NULL);
+
+                // calculate height of the font in pixels
+                HDC hDC = GetDC(NULL);
+                hFont = (HFONT)SelectObject(hDC, hFont);
+                TEXTMETRIC tm;
+                GetTextMetrics(hDC, &tm);
+                SelectObject(hDC, hFont);
+                ReleaseDC(NULL, hDC);
+
+                // determine if window is too large and resize if necessary
+                GetWindowRect(hDlg, &rect);
+                if (rect.bottom > maxY + tm.tmHeight)
+                {
+                        // window is too large -- resize it
+                        rect.bottom = maxY + tm.tmHeight;
+                        SetWindowPos(hDlg, NULL,
+                                0, 0, rect.right-rect.left, rect.bottom-rect.top,
+                                SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
+                        return TRUE;
+                }
+        }
+
+        return FALSE;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Support for Windows 95 help
+// BUGBUG - probably need to rename
+#define HELPFILE        TEXT("mfcuix.hlp")
+
+LPDWORD LoadHelpInfo(UINT nIDD)
+{
+        HRSRC hrsrc = FindResource(_g_hOleStdResInst, MAKEINTRESOURCE(nIDD),
+                MAKEINTRESOURCE(RT_HELPINFO));
+        if (hrsrc == NULL)
+                return NULL;
+
+        HGLOBAL hHelpInfo = LoadResource(_g_hOleStdResInst, hrsrc);
+        if (hHelpInfo == NULL)
+                return NULL;
+
+        LPDWORD lpdwHelpInfo = (LPDWORD)LockResource(hHelpInfo);
+        return lpdwHelpInfo;
+}
+
+void WINAPI StandardHelp(HWND hWnd, UINT nIDD)
+{
+        LPDWORD lpdwHelpInfo = LoadHelpInfo(nIDD);
+        if (lpdwHelpInfo == NULL)
+        {
+                OleDbgOut1(TEXT("Warning: unable to load help information (RT_HELPINFO)\n"));
+                return;
+        }
+        WinHelp(hWnd, HELPFILE, HELP_WM_HELP, (DWORD)lpdwHelpInfo);
+}
+
+void WINAPI StandardContextMenu(WPARAM wParam, LPARAM, UINT nIDD)
+{
+        LPDWORD lpdwHelpInfo = LoadHelpInfo(nIDD);
+        if (lpdwHelpInfo == NULL)
+        {
+                OleDbgOut1(TEXT("Warning: unable to load help information (RT_HELPINFO)\n"));
+                return;
+        }
+        WinHelp((HWND)wParam, HELPFILE, HELP_CONTEXTMENU, (DWORD)lpdwHelpInfo);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// StandardPropertySheet (stub for Windows 95 API PropertySheet)
+
+typedef void (WINAPI* LPFNINITCOMMONCONTROLS)(VOID);
+
+int WINAPI StandardInitCommonControls()
+{
+        TASKDATA* pTaskData = GetTaskData();
+        OleDbgAssert(pTaskData != NULL);
+
+        if (pTaskData->hInstCommCtrl == NULL)
+        {
+                pTaskData->hInstCommCtrl = LoadLibrary(TEXT("comctl32.dll"));
+                if (pTaskData->hInstCommCtrl == NULL)
+                        goto Error;
+
+                LPFNINITCOMMONCONTROLS lpfnInitCommonControls = (LPFNINITCOMMONCONTROLS)
+                        GetProcAddress(pTaskData->hInstCommCtrl, "InitCommonControls");
+                if (lpfnInitCommonControls == NULL)
+                        goto ErrorFreeLibrary;
+                (*lpfnInitCommonControls)();
+        }
+        return 0;
+
+ErrorFreeLibrary:
+        if (pTaskData->hInstCommCtrl != NULL)
+        {
+                FreeLibrary(pTaskData->hInstCommCtrl);
+                pTaskData->hInstCommCtrl = NULL;
+        }
+
+Error:
+        return -1;
+}
+
+typedef int (WINAPI* LPFNPROPERTYSHEET)(LPCPROPSHEETHEADER);
+
+int WINAPI StandardPropertySheet(LPPROPSHEETHEADER lpPS, BOOL fWide)
+{
+        int nResult = StandardInitCommonControls();
+        if (nResult < 0)
+                return nResult;
+
+        TASKDATA* pTaskData = GetTaskData();
+        OleDbgAssert(pTaskData != NULL);
+
+        LPFNPROPERTYSHEET lpfnPropertySheet;
+        if (fWide)
+        {
+            lpfnPropertySheet = (LPFNPROPERTYSHEET)GetProcAddress(pTaskData->hInstCommCtrl, "PropertySheetW");
+        }
+        else
+        {
+            lpfnPropertySheet = (LPFNPROPERTYSHEET)GetProcAddress(pTaskData->hInstCommCtrl, "PropertySheetA");
+        }
+        if (lpfnPropertySheet == NULL)
+                return -1;
+
+        nResult = (*lpfnPropertySheet)(lpPS);
+        return nResult;
+}
+
+typedef HICON (WINAPI* LPFNEXTRACTICON)(HINSTANCE, LPCTSTR, UINT);
+
+HICON StandardExtractIcon(HINSTANCE hInst, LPCTSTR lpszExeFileName, UINT nIconIndex)
+{
+    TASKDATA* pTaskData = GetTaskData();
+    OleDbgAssert(pTaskData != NULL);
+    LPFNEXTRACTICON lpfnExtractIcon;
+
+    if (pTaskData->hInstShell == NULL)
+    {
+        pTaskData->hInstShell = LoadLibrary(TEXT("shell32.dll"));
+        if (pTaskData->hInstShell == NULL)
+            goto Error;
+    }
+    lpfnExtractIcon = (LPFNEXTRACTICON)
+#ifdef UNICODE
+    GetProcAddress(pTaskData->hInstShell, "ExtractIconW");
+#else
+    GetProcAddress(pTaskData->hInstShell, "ExtractIconA");
+#endif
+    if (lpfnExtractIcon == NULL)
+            goto ErrorFreeLibrary;
+    return (*lpfnExtractIcon)(hInst, lpszExeFileName, nIconIndex);
+
+ErrorFreeLibrary:
+    if (pTaskData->hInstShell != NULL)
+    {
+            FreeLibrary(pTaskData->hInstShell);
+            pTaskData->hInstShell = NULL;
+    }
+
+Error:
+    return NULL;
+}
+
+
+typedef BOOL (WINAPI* LPFNGETOPENFILENAME)(LPOPENFILENAME);
+
+BOOL StandardGetOpenFileName(LPOPENFILENAME lpofn)
+{
+    TASKDATA* pTaskData = GetTaskData();
+    OleDbgAssert(pTaskData != NULL);
+    LPFNGETOPENFILENAME lpfnGetOpenFileName;
+
+    if (pTaskData->hInstComDlg == NULL)
+    {
+        pTaskData->hInstComDlg = LoadLibrary(TEXT("comdlg32.dll"));
+        if (pTaskData->hInstComDlg == NULL)
+            goto Error;
+    }
+    lpfnGetOpenFileName = (LPFNGETOPENFILENAME)
+#ifdef UNICODE
+    GetProcAddress(pTaskData->hInstComDlg, "GetOpenFileNameW");
+#else
+    GetProcAddress(pTaskData->hInstComDlg, "GetOpenFileNameA");
+#endif
+    if (lpfnGetOpenFileName == NULL)
+            goto ErrorFreeLibrary;
+    return (*lpfnGetOpenFileName)(lpofn);
+
+ErrorFreeLibrary:
+    if (pTaskData->hInstComDlg != NULL)
+    {
+            FreeLibrary(pTaskData->hInstComDlg);
+            pTaskData->hInstComDlg = NULL;
+    }
+
+Error:
+    return FALSE;
+}
+
+typedef short (WINAPI* LPFNGETFILETITLE)(LPCTSTR, LPTSTR, WORD);
+
+short StandardGetFileTitle(LPCTSTR lpszFile, LPTSTR lpszTitle, WORD cbBuf)
+{
+    TASKDATA* pTaskData = GetTaskData();
+    OleDbgAssert(pTaskData != NULL);
+    LPFNGETFILETITLE lpfnGetFileTitle;
+
+    if (pTaskData->hInstComDlg == NULL)
+    {
+        pTaskData->hInstComDlg = LoadLibrary(TEXT("comdlg32.dll"));
+        if (pTaskData->hInstComDlg == NULL)
+            goto Error;
+    }
+    lpfnGetFileTitle = (LPFNGETFILETITLE)
+#ifdef UNICODE
+    GetProcAddress(pTaskData->hInstComDlg, "GetFileTitleW");
+#else
+    GetProcAddress(pTaskData->hInstComDlg, "GetFileTitleA");
+#endif
+    if (lpfnGetFileTitle == NULL)
+            goto ErrorFreeLibrary;
+    return (*lpfnGetFileTitle)(lpszFile, lpszTitle, cbBuf);
+
+ErrorFreeLibrary:
+    if (pTaskData->hInstComDlg != NULL)
+    {
+            FreeLibrary(pTaskData->hInstComDlg);
+            pTaskData->hInstComDlg = NULL;
+    }
+
+Error:
+    return -1;
+}
+