/* * CONVERT.CPP * * Implements the OleUIConvert function which invokes the complete * Convert dialog. * * Copyright (c)1992 Microsoft Corporation, All Right Reserved */ #include "precomp.h" #include "common.h" #include #include "utility.h" #include "iconbox.h" OLEDBGDATA // Internally used structure typedef struct tagCONVERT { // Keep this item first as the Standard* functions depend on it here. LPOLEUICONVERT lpOCV; // Original structure passed. UINT nIDD; // IDD of dialog (used for help info) /* * What we store extra in this structure besides the original caller's * pointer are those fields that we need to modify during the life of * the dialog but that we don't want to change in the original structure * until the user presses OK. */ DWORD dwFlags; // Flags passed in HWND hListVisible; // listbox that is currently visible HWND hListInvisible; // listbox that is currently hidden CLSID clsid; // Class ID sent in to dialog: IN only DWORD dvAspect; BOOL fCustomIcon; UINT IconIndex; // index (in exe) of current icon LPTSTR lpszIconSource; // path to current icon source LPTSTR lpszCurrentObject; LPTSTR lpszConvertDefault; LPTSTR lpszActivateDefault; } CONVERT, *PCONVERT, FAR *LPCONVERT; // Internal function prototypes // CONVERT.CPP INT_PTR CALLBACK ConvertDialogProc(HWND, UINT, WPARAM, LPARAM); BOOL FConvertInit(HWND hDlg, WPARAM, LPARAM); void SetConvertResults(HWND, LPCONVERT); UINT FillClassList(CLSID clsid, HWND hList, HWND hListInvisible, LPTSTR FAR *lplpszCurrentClass, BOOL fIsLinkedObject, WORD wFormat, UINT cClsidExclude, LPCLSID lpClsidExclude, BOOL bAddSameClass); BOOL FormatIncluded(LPTSTR szStringToSearch, WORD wFormat); void SwapWindows(HWND, HWND, HWND); void ConvertCleanup(HWND hDlg, LPCONVERT lpCV); static void UpdateClassIcon(HWND hDlg, LPCONVERT lpCV, HWND hList); /* * OleUIConvert * * Purpose: * Invokes the standard OLE Change Type dialog box allowing the user * to change the type of the single specified object, or change the * type of all OLE objects of a specified type. * * Parameters: * lpCV LPOLEUICONVERT pointing to the in-out structure * for this dialog. * * Return Value: * UINT One of the following codes, indicating success or error: * OLEUI_SUCCESS Success * OLEUI_ERR_STRUCTSIZE The dwStructSize value is wrong */ STDAPI_(UINT) OleUIConvert(LPOLEUICONVERT lpCV) { HGLOBAL hMemDlg = NULL; UINT uRet = UStandardValidation((LPOLEUISTANDARD)lpCV, sizeof(OLEUICONVERT), &hMemDlg); if (OLEUI_SUCCESS != uRet) return uRet; if (lpCV->hMetaPict != NULL && !IsValidMetaPict(lpCV->hMetaPict)) { return(OLEUI_CTERR_HMETAPICTINVALID); } if ((lpCV->dwFlags & CF_SETCONVERTDEFAULT) && (!IsValidClassID(lpCV->clsidConvertDefault))) uRet = OLEUI_CTERR_CLASSIDINVALID; if ((lpCV->dwFlags & CF_SETACTIVATEDEFAULT) && (!IsValidClassID(lpCV->clsidActivateDefault))) uRet = OLEUI_CTERR_CLASSIDINVALID; if ((lpCV->dvAspect != DVASPECT_ICON) && (lpCV->dvAspect != DVASPECT_CONTENT)) uRet = OLEUI_CTERR_DVASPECTINVALID; if ((lpCV->wFormat >= CF_CLIPBOARDMIN) && (lpCV->wFormat <= CF_CLIPBOARDMAX)) { TCHAR szTemp[8]; if (0 == GetClipboardFormatName(lpCV->wFormat, szTemp, 8)) uRet = OLEUI_CTERR_CBFORMATINVALID; } if ((NULL != lpCV->lpszUserType) && (IsBadReadPtr(lpCV->lpszUserType, 1))) uRet = OLEUI_CTERR_STRINGINVALID; if ( (NULL != lpCV->lpszDefLabel) && (IsBadReadPtr(lpCV->lpszDefLabel, 1)) ) uRet = OLEUI_CTERR_STRINGINVALID; if (0 != lpCV->cClsidExclude && IsBadReadPtr(lpCV->lpClsidExclude, lpCV->cClsidExclude * sizeof(CLSID))) { uRet = OLEUI_IOERR_LPCLSIDEXCLUDEINVALID; } if (OLEUI_ERR_STANDARDMIN <= uRet) { return uRet; } UINT nIDD; if (!bWin4) nIDD = lpCV->dwFlags & CF_CONVERTONLY ? IDD_CONVERTONLY : IDD_CONVERT; else nIDD = lpCV->dwFlags & CF_CONVERTONLY ? IDD_CONVERTONLY4 : IDD_CONVERT4; // Now that we've validated everything, we can invoke the dialog. uRet = UStandardInvocation(ConvertDialogProc, (LPOLEUISTANDARD)lpCV, hMemDlg, MAKEINTRESOURCE(nIDD)); return uRet; } /* * ConvertDialogProc * * Purpose: * Implements the OLE Convert dialog as invoked through the * OleUIConvert function. * * Parameters: * Standard * * Return Value: * Standard * */ INT_PTR CALLBACK ConvertDialogProc(HWND hDlg, UINT iMsg, WPARAM wParam, LPARAM lParam) { // Declare Win16/Win32 compatible WM_COMMAND parameters. COMMANDPARAMS(wID, wCode, hWndMsg); // This will fail under WM_INITDIALOG, where we allocate it. UINT uRet = 0; LPCONVERT lpCV = (LPCONVERT)LpvStandardEntry(hDlg, iMsg, wParam, lParam, &uRet); //If the hook processed the message, we're done. if (0 != uRet) return (INT_PTR)uRet; //Process the temination message if (iMsg == uMsgEndDialog) { EndDialog(hDlg, wParam); return TRUE; } // Process help message from Change Icon if (iMsg == uMsgHelp) { PostMessage(lpCV->lpOCV->hWndOwner, uMsgHelp, wParam, lParam); return FALSE; } switch (iMsg) { case WM_DESTROY: if (lpCV) { ConvertCleanup(hDlg, lpCV); StandardCleanup(lpCV, hDlg); } break; case WM_INITDIALOG: FConvertInit(hDlg, wParam, lParam); return TRUE; case WM_COMMAND: switch (wID) { case IDC_CV_ACTIVATELIST: case IDC_CV_CONVERTLIST: switch (wCode) { case LBN_SELCHANGE: // Change "Results" window to reflect current selection SetConvertResults(hDlg, lpCV); // Update the icon we display, if in display as icon mode if ((lpCV->dwFlags & CF_SELECTCONVERTTO) && lpCV->dvAspect == DVASPECT_ICON && !lpCV->fCustomIcon) { UpdateClassIcon(hDlg, lpCV, hWndMsg); } break; case LBN_DBLCLK: SendCommand(hDlg, IDOK, BN_CLICKED, hWndMsg); break; } break; case IDC_CV_CONVERTTO: case IDC_CV_ACTIVATEAS: { HWND hList = lpCV->hListVisible; HWND hListInvisible = lpCV->hListInvisible; if (IDC_CV_CONVERTTO == wParam) { // User just click on the button again - it was // already selected. if (lpCV->dwFlags & CF_SELECTCONVERTTO) break; // If we're working with a linked object, don't // add the activate list - just the object's // class should appear in the listbox. SwapWindows(hDlg, hList, hListInvisible); lpCV->hListVisible = hListInvisible; lpCV->hListInvisible = hList; EnableWindow(lpCV->hListInvisible, FALSE); EnableWindow(lpCV->hListVisible, TRUE); // Update our flags. lpCV->dwFlags &= ~CF_SELECTACTIVATEAS; lpCV->dwFlags |= CF_SELECTCONVERTTO; } else { if (lpCV->dwFlags & CF_SELECTACTIVATEAS) break; SwapWindows(hDlg, hList, hListInvisible); lpCV->hListVisible = hListInvisible; lpCV->hListInvisible = hList; EnableWindow(lpCV->hListInvisible, FALSE); EnableWindow(lpCV->hListVisible, TRUE); // Update our flags. lpCV->dwFlags |= CF_SELECTACTIVATEAS; lpCV->dwFlags &= ~CF_SELECTCONVERTTO; } LRESULT lRetVal; if (lpCV->dwFlags & CF_SELECTCONVERTTO) lRetVal = SendMessage(lpCV->hListVisible, LB_SELECTSTRING, (WPARAM)-1, (LPARAM)lpCV->lpszConvertDefault); else lRetVal = SendMessage(lpCV->hListVisible, LB_SELECTSTRING, (WPARAM)-1, (LPARAM)lpCV->lpszActivateDefault); if (LB_ERR == lRetVal) { TCHAR szCurrentObject[40]; GetDlgItemText(hDlg, IDC_CV_OBJECTTYPE, szCurrentObject, 40); SendMessage(lpCV->hListVisible, LB_SELECTSTRING, (WPARAM)-1, (LPARAM)szCurrentObject); } // Turn updates back on. SendMessage(hDlg, WM_SETREDRAW, TRUE, 0L); InvalidateRect(lpCV->hListVisible, NULL, TRUE); UpdateWindow(lpCV->hListVisible); if ((lpCV->dvAspect & DVASPECT_ICON) && (lpCV->dwFlags & CF_SELECTCONVERTTO)) UpdateClassIcon(hDlg, lpCV, lpCV->hListVisible); // Hide the icon stuff when Activate is selected...show // it again when Convert is selected. BOOL fState = ((lpCV->dwFlags & CF_SELECTACTIVATEAS) || (lpCV->dwFlags & CF_DISABLEDISPLAYASICON)) ? SW_HIDE : SW_SHOW; StandardShowDlgItem(hDlg, IDC_CV_DISPLAYASICON, fState); // Only display the icon if convert is selected AND // display as icon is checked. if ((SW_SHOW==fState) && (DVASPECT_ICON!=lpCV->dvAspect)) fState = SW_HIDE; StandardShowDlgItem(hDlg, IDC_CV_CHANGEICON, fState); StandardShowDlgItem(hDlg, IDC_CV_ICONDISPLAY, fState); SetConvertResults(hDlg, lpCV); } break; case IDOK: { // Set output flags to current ones lpCV->lpOCV->dwFlags = lpCV->dwFlags; // Update the dvAspect and fObjectsIconChanged members // as appropriate. if (lpCV->dwFlags & CF_SELECTACTIVATEAS) { // DON'T update aspect if activate as was selected. lpCV->lpOCV->fObjectsIconChanged = FALSE; } else lpCV->lpOCV->dvAspect = lpCV->dvAspect; // Get the new clsid TCHAR szBuffer[256]; LRESULT iCurSel = SendMessage(lpCV->hListVisible, LB_GETCURSEL, 0, 0); SendMessage(lpCV->hListVisible, LB_GETTEXT, iCurSel, (LPARAM)szBuffer); LPTSTR lpszCLSID = PointerToNthField(szBuffer, 2, '\t'); #if defined(WIN32) && !defined(UNICODE) OLECHAR wszCLSID[OLEUI_CCHKEYMAX]; ATOW(wszCLSID, lpszCLSID, OLEUI_CCHKEYMAX); CLSIDFromString(wszCLSID, (&(lpCV->lpOCV->clsidNew))); #else CLSIDFromString(lpszCLSID, (&(lpCV->lpOCV->clsidNew))); #endif // Free the hMetaPict we got in. OleUIMetafilePictIconFree(lpCV->lpOCV->hMetaPict); // Get the hMetaPict (if display as icon is checked) if (DVASPECT_ICON == lpCV->dvAspect) lpCV->lpOCV->hMetaPict = (HGLOBAL)SendDlgItemMessage(hDlg, IDC_CV_ICONDISPLAY, IBXM_IMAGEGET, 0, 0L); else lpCV->lpOCV->hMetaPict = (HGLOBAL)NULL; SendMessage(hDlg, uMsgEndDialog, OLEUI_OK, 0L); } break; case IDCANCEL: { HGLOBAL hMetaPict = (HGLOBAL)SendDlgItemMessage(hDlg, IDC_CV_ICONDISPLAY, IBXM_IMAGEGET, 0, 0L); OleUIMetafilePictIconFree(hMetaPict); SendMessage(hDlg, uMsgEndDialog, OLEUI_CANCEL, 0L); } break; case IDC_OLEUIHELP: PostMessage(lpCV->lpOCV->hWndOwner, uMsgHelp, (WPARAM)hDlg, MAKELPARAM(IDD_CONVERT, 0)); break; case IDC_CV_DISPLAYASICON: { BOOL fCheck = IsDlgButtonChecked(hDlg, wID); if (fCheck) lpCV->dvAspect = DVASPECT_ICON; else lpCV->dvAspect = DVASPECT_CONTENT; if (fCheck && !lpCV->fCustomIcon) UpdateClassIcon(hDlg, lpCV, lpCV->hListVisible); // Show or hide the icon depending on the check state. int i = (fCheck) ? SW_SHOWNORMAL : SW_HIDE; StandardShowDlgItem(hDlg, IDC_CV_CHANGEICON, i); StandardShowDlgItem(hDlg, IDC_CV_ICONDISPLAY, i); SetConvertResults(hDlg, lpCV); } break; case IDC_CV_CHANGEICON: { // Initialize the structure for the hook. OLEUICHANGEICON ci; memset(&ci, 0, sizeof(ci)); ci.hMetaPict = (HGLOBAL)SendDlgItemMessage(hDlg, IDC_CV_ICONDISPLAY, IBXM_IMAGEGET, 0, 0L); ci.cbStruct = sizeof(ci); ci.hWndOwner= hDlg; ci.dwFlags = CIF_SELECTCURRENT; // Only show help if we're showing it for this dialog. if (lpCV->dwFlags & CF_SHOWHELPBUTTON) ci.dwFlags |= CIF_SHOWHELP; int iSel = (INT)SendMessage(lpCV->hListVisible, LB_GETCURSEL, 0, 0); // Get whole string LPTSTR pszString = (LPTSTR)OleStdMalloc( OLEUI_CCHLABELMAX_SIZE + OLEUI_CCHCLSIDSTRING_SIZE); SendMessage(lpCV->hListVisible, LB_GETTEXT, iSel, (LPARAM)pszString); // Set pointer to CLSID (string) LPTSTR pszCLSID = PointerToNthField(pszString, 2, '\t'); // Get the clsid to pass to change icon. #if defined(WIN32) && !defined(UNICODE) OLECHAR wszCLSID[OLEUI_CCHKEYMAX]; ATOW(wszCLSID, pszCLSID, OLEUI_CCHKEYMAX); CLSIDFromString(wszCLSID, &(ci.clsid)); #else CLSIDFromString(pszCLSID, &(ci.clsid)); #endif OleStdFree(pszString); // Let the hook in to customize Change Icon if desired. uRet = UStandardHook(lpCV, hDlg, uMsgChangeIcon, 0, (LPARAM)&ci); if (0 == uRet) uRet= (OLEUI_OK == OleUIChangeIcon(&ci)); // Update the display if necessary. if (0 != uRet) { SendDlgItemMessage(hDlg, IDC_CV_ICONDISPLAY, IBXM_IMAGESET, 0, (LPARAM)ci.hMetaPict); // Update our custom/default flag if (ci.dwFlags & CIF_SELECTDEFAULT) lpCV->fCustomIcon = FALSE; // we're in default mode (icon changes on each LB selchange) else if (ci.dwFlags & CIF_SELECTFROMFILE) lpCV->fCustomIcon = TRUE; // we're in custom mode (icon doesn't change) // no change in fCustomIcon if user selected current lpCV->lpOCV->fObjectsIconChanged = TRUE; } } break; } break; } return FALSE; } /* * FConvertInit * * Purpose: * WM_INITIDIALOG handler for the Convert dialog box. * * Parameters: * hDlg HWND of the dialog * wParam WPARAM of the message * lParam LPARAM of the message * * Return Value: * BOOL Value to return for WM_INITDIALOG. */ BOOL FConvertInit(HWND hDlg, WPARAM wParam, LPARAM lParam) { // Copy the structure at lParam into our instance memory. HFONT hFont; // non-bold version of dialog's font LPCONVERT lpCV = (LPCONVERT)LpvStandardInit(hDlg, sizeof(CONVERT), &hFont); // PvStandardInit send a termination to us already. if (NULL == lpCV) return FALSE; LPOLEUICONVERT lpOCV = (LPOLEUICONVERT)lParam; lpCV->lpOCV = lpOCV; lpCV->nIDD = IDD_CONVERT; lpCV->fCustomIcon = FALSE; // Copy other information from lpOCV that we might modify. lpCV->dwFlags = lpOCV->dwFlags; lpCV->clsid = lpOCV->clsid; lpCV->dvAspect = lpOCV->dvAspect; lpCV->hListVisible = GetDlgItem(hDlg, IDC_CV_ACTIVATELIST); lpCV->hListInvisible = GetDlgItem(hDlg, IDC_CV_CONVERTLIST); OleDbgAssert(lpCV->hListInvisible != NULL); lpCV->lpszCurrentObject = lpOCV->lpszUserType; lpOCV->clsidNew = CLSID_NULL; lpOCV->fObjectsIconChanged = FALSE; lpCV->lpszConvertDefault = (LPTSTR)OleStdMalloc(OLEUI_CCHLABELMAX_SIZE); lpCV->lpszActivateDefault = (LPTSTR)OleStdMalloc(OLEUI_CCHLABELMAX_SIZE); lpCV->lpszIconSource = (LPTSTR)OleStdMalloc(MAX_PATH_SIZE); if ((lpCV->lpszConvertDefault == NULL) || (lpCV->lpszActivateDefault == NULL) || (lpCV->lpszIconSource == NULL)) { if (lpCV->lpszConvertDefault != NULL) OleStdFree (lpCV->lpszConvertDefault); if (lpCV->lpszActivateDefault != NULL) OleStdFree (lpCV->lpszActivateDefault); if (lpCV->lpszIconSource != NULL) OleStdFree (lpCV->lpszIconSource); // Gonna kill the window... PostMessage(hDlg, uMsgEndDialog, OLEUI_ERR_GLOBALMEMALLOC, 0L); return FALSE; } // If we got a font, send it to the necessary controls. if (NULL != hFont) { SendDlgItemMessage(hDlg, IDC_CV_OBJECTTYPE, WM_SETFONT, (WPARAM)hFont, 0L); SendDlgItemMessage(hDlg, IDC_CV_RESULTTEXT, WM_SETFONT, (WPARAM)hFont, 0L); } // Hide the help button if necessary if (!(lpCV->dwFlags & CF_SHOWHELPBUTTON)) StandardShowDlgItem(hDlg, IDC_OLEUIHELP, SW_HIDE); // Show or hide the Change icon button if (lpCV->dwFlags & CF_HIDECHANGEICON) DestroyWindow(GetDlgItem(hDlg, IDC_CV_CHANGEICON)); // Fill the Object Type listbox with entries from the reg DB. UINT nRet = FillClassList(lpOCV->clsid, lpCV->hListVisible, lpCV->hListInvisible, &(lpCV->lpszCurrentObject), lpOCV->fIsLinkedObject, lpOCV->wFormat, lpOCV->cClsidExclude, lpOCV->lpClsidExclude, !(lpCV->dwFlags & CF_CONVERTONLY)); if (nRet == -1) { // bring down dialog if error when filling list box PostMessage(hDlg, uMsgEndDialog, OLEUI_ERR_LOADSTRING, 0L); } // Set the name of the current object. SetDlgItemText(hDlg, IDC_CV_OBJECTTYPE, lpCV->lpszCurrentObject); // Disable the "Activate As" button if the Activate list doesn't // have any objects in it. int cItemsActivate = (INT)SendMessage(lpCV->hListVisible, LB_GETCOUNT, 0, 0L); if (1 >= cItemsActivate || (lpCV->dwFlags & CF_DISABLEACTIVATEAS)) StandardEnableDlgItem(hDlg, IDC_CV_ACTIVATEAS, FALSE); // Set the tab width in the list to push all the tabs off the side. RECT rect; if (lpCV->hListVisible != NULL) GetClientRect(lpCV->hListVisible, &rect); else GetClientRect(lpCV->hListInvisible, &rect); DWORD dw = GetDialogBaseUnits(); rect.right = (8*rect.right)/LOWORD(dw); //Convert pixels to 2x dlg units. if (lpCV->hListVisible != NULL) SendMessage(lpCV->hListVisible, LB_SETTABSTOPS, 1, (LPARAM)(LPINT)(&rect.right)); SendMessage(lpCV->hListInvisible, LB_SETTABSTOPS, 1, (LPARAM)(LPINT)(&rect.right)); // Make sure that either "Convert To" or "Activate As" is selected // and initialize listbox contents and selection accordingly if (lpCV->dwFlags & CF_SELECTACTIVATEAS) { // Don't need to adjust listbox here because FillClassList // initializes to the "Activate As" state. CheckRadioButton(hDlg, IDC_CV_CONVERTTO, IDC_CV_ACTIVATEAS, IDC_CV_ACTIVATEAS); // Hide the icon stuff when Activate is selected...it gets shown // again when Convert is selected. StandardShowDlgItem(hDlg, IDC_CV_DISPLAYASICON, SW_HIDE); StandardShowDlgItem(hDlg, IDC_CV_CHANGEICON, SW_HIDE); StandardShowDlgItem(hDlg, IDC_CV_ICONDISPLAY, SW_HIDE); } else { // Default case. If user hasn't selected either flag, we will // come here anyway. // swap listboxes. HWND hWndTemp = lpCV->hListVisible; if (lpCV->dwFlags & CF_DISABLEDISPLAYASICON) { StandardShowDlgItem(hDlg, IDC_CV_DISPLAYASICON, SW_HIDE); StandardShowDlgItem(hDlg, IDC_CV_CHANGEICON, SW_HIDE); StandardShowDlgItem(hDlg, IDC_CV_ICONDISPLAY, SW_HIDE); } lpCV->dwFlags |= CF_SELECTCONVERTTO; // Make sure flag is set if (!(lpCV->dwFlags & CF_CONVERTONLY)) CheckRadioButton(hDlg, IDC_CV_CONVERTTO, IDC_CV_ACTIVATEAS, IDC_CV_CONVERTTO); SwapWindows(hDlg, lpCV->hListVisible, lpCV->hListInvisible); lpCV->hListVisible = lpCV->hListInvisible; lpCV->hListInvisible = hWndTemp; if (lpCV->hListInvisible) EnableWindow(lpCV->hListInvisible, FALSE); EnableWindow(lpCV->hListVisible, TRUE); } // Initialize Default strings. // Default convert string is easy...just user the user type name from // the clsid we got, or the current object if ((lpCV->dwFlags & CF_SETCONVERTDEFAULT) && (IsValidClassID(lpCV->lpOCV->clsidConvertDefault))) { LPOLESTR lpszTemp = NULL; if (OleRegGetUserType(lpCV->lpOCV->clsidConvertDefault, USERCLASSTYPE_FULL, &lpszTemp) == NOERROR) { #if defined(WIN32) && !defined(UNICODE) WTOA(lpCV->lpszConvertDefault, lpszTemp, OLEUI_CCHLABELMAX); #else lstrcpyn(lpCV->lpszConvertDefault, lpszTemp, OLEUI_CCHLABELMAX); #endif OleStdFree(lpszTemp); } else { lstrcpy(lpCV->lpszConvertDefault, lpCV->lpszCurrentObject); } } else lstrcpy(lpCV->lpszConvertDefault, (lpCV->lpszCurrentObject ? lpCV->lpszCurrentObject : TEXT(""))); // Default activate is a bit trickier. We want to use the user type // name if from the clsid we got (assuming we got one), or the current // object if it fails or we didn't get a clsid. But...if there's a // Treat As entry in the reg db, then we use that instead. So... the // logic boils down to this: // // if ("Treat As" in reg db) // use it; // else // if (CF_SETACTIVATEDEFAULT) // use it; // else // use current object; HKEY hKey; LONG lRet = RegOpenKey(HKEY_CLASSES_ROOT, TEXT("CLSID"), &hKey); LPARAM lpRet; if (lRet != ERROR_SUCCESS) goto CheckInputFlag; LPOLESTR lpszCLSID; StringFromCLSID(lpCV->lpOCV->clsid, &lpszCLSID); TCHAR szKey[OLEUI_CCHKEYMAX]; #if defined(WIN32) && !defined(UNICODE) WTOA(szKey, lpszCLSID, OLEUI_CCHKEYMAX); #else lstrcpy(szKey, lpszCLSID); #endif lstrcat(szKey, TEXT("\\TreatAs")); OleStdFree(lpszCLSID); TCHAR szValue[OLEUI_CCHKEYMAX]; dw = OLEUI_CCHKEYMAX_SIZE; lRet = RegQueryValue(hKey, szKey, szValue, (LONG*)&dw); CLSID clsid; if (lRet != ERROR_SUCCESS) { RegCloseKey(hKey); goto CheckInputFlag; } else { #if defined(WIN32) && !defined(UNICODE) OLECHAR wszValue[OLEUI_CCHKEYMAX]; ATOW(wszValue,szValue,OLEUI_CCHKEYMAX); CLSIDFromString(wszValue, &clsid); #else CLSIDFromString(szValue, &clsid); #endif LPOLESTR lpszTemp = NULL; if (OleRegGetUserType(clsid, USERCLASSTYPE_FULL, &lpszTemp) == NOERROR) { if (lpCV->lpszActivateDefault) { #if defined(WIN32) && !defined(UNICODE) WTOA(lpCV->lpszActivateDefault, lpszTemp, OLEUI_CCHLABELMAX); #else lstrcpyn(lpCV->lpszActivateDefault, lpszTemp, OLEUI_CCHLABELMAX); #endif } OleStdFree(lpszTemp); } else { RegCloseKey(hKey); goto CheckInputFlag; } } RegCloseKey(hKey); goto SelectStringInListbox; CheckInputFlag: if ((lpCV->dwFlags & CF_SETACTIVATEDEFAULT) && (IsValidClassID(lpCV->lpOCV->clsidActivateDefault))) { LPOLESTR lpszTemp = NULL; if (OleRegGetUserType(lpCV->lpOCV->clsidActivateDefault, USERCLASSTYPE_FULL, &lpszTemp) == NOERROR) { #if defined(WIN32) && !defined(UNICODE) WTOA(lpCV->lpszActivateDefault, lpszTemp, OLEUI_CCHLABELMAX); #else lstrcpyn(lpCV->lpszActivateDefault, lpszTemp, OLEUI_CCHLABELMAX); #endif OleStdFree(lpszTemp); } else { lstrcpy(lpCV->lpszActivateDefault, lpCV->lpszCurrentObject); } } else if ((lpCV->lpszActivateDefault) && (lpCV->lpszCurrentObject)) lstrcpy((lpCV->lpszActivateDefault), lpCV->lpszCurrentObject); SelectStringInListbox: if (lpCV->dwFlags & CF_SELECTCONVERTTO) lpRet = SendMessage(lpCV->hListVisible, LB_SELECTSTRING, (WPARAM)-1, (LPARAM)lpCV->lpszConvertDefault); else lpRet = SendMessage(lpCV->hListVisible, LB_SELECTSTRING, (WPARAM)-1, (LPARAM)lpCV->lpszActivateDefault); if (LB_ERR == lpRet) SendMessage(lpCV->hListVisible, LB_SETCURSEL, (WPARAM)0, 0L); if ((HGLOBAL)NULL != lpOCV->hMetaPict) { HGLOBAL hMetaPict = OleDuplicateData(lpOCV->hMetaPict, CF_METAFILEPICT, NULL); SendDlgItemMessage(hDlg, IDC_CV_ICONDISPLAY, IBXM_IMAGESET, 0, (LPARAM)hMetaPict); lpCV->fCustomIcon = TRUE; } else { UpdateClassIcon(hDlg, lpCV, lpCV->hListVisible); } // Initialize icon stuff if (DVASPECT_ICON == lpCV->dvAspect ) { SendDlgItemMessage(hDlg, IDC_CV_DISPLAYASICON, BM_SETCHECK, TRUE, 0L); } else { // Hide & disable icon stuff StandardShowDlgItem(hDlg, IDC_CV_CHANGEICON, SW_HIDE); StandardShowDlgItem(hDlg, IDC_CV_ICONDISPLAY, SW_HIDE); } // Call the hook with lCustData in lParam UStandardHook((LPVOID)lpCV, hDlg, WM_INITDIALOG, wParam, lpOCV->lCustData); // Update results window SetConvertResults(hDlg, lpCV); // Update caption if lpszCaption was specified if (lpCV->lpOCV->lpszCaption && !IsBadReadPtr(lpCV->lpOCV->lpszCaption, 1)) { SetWindowText(hDlg, lpCV->lpOCV->lpszCaption); } return TRUE; } /* * FillClassList * * Purpose: * Enumerates available OLE object classes from the registration * database that we can convert or activate the specified clsid from. * * Note that this function removes any prior contents of the listbox. * * Parameters: * clsid Class ID for class to find convert classes for * hList HWND to the listbox to fill. * hListActivate HWND to invisible listbox that stores "activate as" list. * lpszClassName LPSTR to put the (hr) class name of the clsid; we * do it here since we've already got the reg db open. * fIsLinkedObject BOOL is the original object a linked object * wFormat WORD specifying the format of the original class. * cClsidExclude UINT number of entries in exclude list * lpClsidExclude LPCLSID array classes to exclude for list * * Return Value: * UINT Number of strings added to the listbox, -1 on failure. */ UINT FillClassList(CLSID clsid, HWND hListActivate, HWND hListConvert, LPTSTR FAR *lplpszCurrentClass, BOOL fIsLinkedObject, WORD wFormat, UINT cClsidExclude, LPCLSID lpClsidExclude, BOOL bAddSameClass) { // Clean out the existing strings. if (hListActivate) SendMessage(hListActivate, LB_RESETCONTENT, 0, 0L); OleDbgAssert(hListConvert != NULL); SendMessage(hListConvert, LB_RESETCONTENT, 0, 0L); // Open up the root key. HKEY hKey; LONG lRet = RegOpenKey(HKEY_CLASSES_ROOT, TEXT("CLSID"), &hKey); LPARAM lpRet; if (ERROR_SUCCESS != lRet) return (UINT)-1; if (NULL == *lplpszCurrentClass) { #if defined(WIN32) && !defined(UNICODE) LPOLESTR wszCurrentClass; if (OleRegGetUserType(clsid, USERCLASSTYPE_FULL, &wszCurrentClass) != NOERROR) #else if (OleRegGetUserType(clsid, USERCLASSTYPE_FULL, lplpszCurrentClass) != NOERROR) #endif { *lplpszCurrentClass = OleStdLoadString(_g_hOleStdResInst, IDS_PSUNKNOWNTYPE); if (*lplpszCurrentClass == NULL) { RegCloseKey(hKey); return (UINT)-1; } } #if defined(WIN32) && !defined(UNICODE) else { UINT uLen = WTOALEN(wszCurrentClass); *lplpszCurrentClass = (LPTSTR)OleStdMalloc(uLen); if (NULL == *lplpszCurrentClass) { RegCloseKey(hKey); OleStdFree(wszCurrentClass); return (UINT)-1; } WTOA(*lplpszCurrentClass, wszCurrentClass, uLen); OleStdFree(wszCurrentClass); } #endif } // Get the class name of the original class. LPTSTR lpszCLSID; #if defined(WIN32) && !defined(UNICODE) // This code does not report allocation errors because neither did // the original code before I extended it to support 32-bit ANSI builds. // (NOTE that the result of StringFromCLSID is never checked against // NULL after the #else case below, which contains the original code.) // In any event, if OleStdMalloc returns NULL, then the string will // simply be lost. Technically an error, but not a fatal one. LPOLESTR wszCLSID; StringFromCLSID(clsid, &wszCLSID); lpszCLSID = NULL; if (NULL != wszCLSID) { UINT uLen = WTOALEN(wszCLSID); lpszCLSID = (LPTSTR) OleStdMalloc(uLen); if (NULL != lpszCLSID) { WTOA(lpszCLSID, wszCLSID, uLen); } OleStdFree(wszCLSID); } #else StringFromCLSID(clsid, &lpszCLSID); #endif // Here, we step through the entire registration db looking for // class that can read or write the original class' format. We // maintain two lists - an activate list and a convert list. The // activate list is a subset of the convert list - activate == read/write // and convert == read. We swap the listboxes as needed with // SwapWindows, and keep track of which is which in the lpCV structure. // Every item has the following format: // // Class Name\tclsid\0 UINT cStrings = 0; TCHAR szClass[OLEUI_CCHKEYMAX]; lRet = RegEnumKey(hKey, cStrings++, szClass, sizeof(szClass) / sizeof(TCHAR)); TCHAR szFormatKey[OLEUI_CCHKEYMAX]; TCHAR szFormat[OLEUI_CCHKEYMAX]; TCHAR szHRClassName[OLEUI_CCHKEYMAX]; CLSID clsidForList; while (ERROR_SUCCESS == lRet) { UINT j; BOOL fExclude = FALSE; //Check if this CLSID is in the exclusion list. #if defined(WIN32) && !defined(UNICODE) OLECHAR wszClass[OLEUI_CCHKEYMAX]; ATOW(wszClass, szClass, OLEUI_CCHKEYMAX); HRESULT hr = CLSIDFromString(wszClass, &clsidForList); #else HRESULT hr = CLSIDFromString(szClass, &clsidForList); #endif if (SUCCEEDED(hr)) { for (j = 0; j < cClsidExclude; j++) { if (IsEqualCLSID(clsidForList, lpClsidExclude[j])) { fExclude=TRUE; break; } } if (fExclude) goto Next; // don't add this class to list } // Check for a \Conversion\Readwritable\Main - if its // readwriteable, then the class can be added to the ActivateAs // list. // NOTE: the presence of this key should NOT automatically be // used to add the class to the CONVERT list. lstrcpy(szFormatKey, szClass); lstrcat(szFormatKey, TEXT("\\Conversion\\Readwritable\\Main")); DWORD dw; dw = OLEUI_CCHKEYMAX_SIZE; lRet = RegQueryValue(hKey, szFormatKey, szFormat, (LONG*)&dw); if (ERROR_SUCCESS == lRet && FormatIncluded(szFormat, wFormat)) { // Here, we've got a list of formats that this class can read // and write. We need to see if the original class' format is // in this list. We do that by looking for wFormat in // szFormat - if it in there, then we add this class to the // ACTIVATEAS list only. we do NOT automatically add it to the // CONVERT list. Readable and Readwritable format lists should // be handled separately. dw=OLEUI_CCHKEYMAX_SIZE; lRet=RegQueryValue(hKey, szClass, szHRClassName, (LONG*)&dw); if (ERROR_SUCCESS == lRet && hListActivate != NULL) { // only add if not already in list lstrcat(szHRClassName, TEXT("\t")); if (LB_ERR == SendMessage(hListActivate, LB_FINDSTRING, 0, (LPARAM)szHRClassName)) { lstrcat(szHRClassName, szClass); SendMessage(hListActivate, LB_ADDSTRING, 0, (LPARAM)szHRClassName); } } } // Here we'll check to see if the original class' format is in the // readable list. if so, we will add the class to the CONVERTLIST // We've got a special case for a linked object here. // If an object is linked, then the only class that // should appear in the convert list is the object's // class. So, here we check to see if the object is // linked. If it is, then we compare the classes. If // they aren't the same, then we just go to the next key. if (!fIsLinkedObject || lstrcmp(lpszCLSID, szClass) == 0) { //Check for a \Conversion\Readable\Main entry lstrcpy(szFormatKey, szClass); lstrcat(szFormatKey, TEXT("\\Conversion\\Readable\\Main")); // Check to see if this class can read the original class // format. If it can, add the string to the listbox as // CONVERT_LIST. dw = OLEUI_CCHKEYMAX_SIZE; lRet = RegQueryValue(hKey, szFormatKey, szFormat, (LONG*)&dw); if (ERROR_SUCCESS == lRet && FormatIncluded(szFormat, wFormat)) { dw = OLEUI_CCHKEYMAX_SIZE; lRet = RegQueryValue(hKey, szClass, szHRClassName, (LONG*)&dw); if (ERROR_SUCCESS == lRet) { // only add if not already in list lstrcat(szHRClassName, TEXT("\t")); if (LB_ERR == SendMessage(hListConvert, LB_FINDSTRING, 0, (LPARAM)szHRClassName)) { lstrcat(szHRClassName, szClass); SendMessage(hListConvert, LB_ADDSTRING, 0, (LPARAM)szHRClassName); } } } } Next: //Continue with the next key. lRet = RegEnumKey(hKey, cStrings++, szClass, sizeof(szClass) / sizeof(TCHAR)); } // end while // If the original class isn't already in the list, add it. if (bAddSameClass) { lstrcpy(szHRClassName, *lplpszCurrentClass); lstrcat(szHRClassName, TEXT("\t")); lstrcat(szHRClassName, lpszCLSID); if (hListActivate != NULL) { // only add it if it's not there already. lpRet = SendMessage(hListActivate, LB_FINDSTRING, (WPARAM)-1, (LPARAM)szHRClassName); if (LB_ERR == lpRet) SendMessage(hListActivate, LB_ADDSTRING, 0, (LPARAM)szHRClassName); } // only add it if it's not there already. lpRet = SendMessage(hListConvert, LB_FINDSTRING, (WPARAM)-1, (LPARAM)szHRClassName); if (LB_ERR == lpRet) SendMessage(hListConvert, LB_ADDSTRING, 0, (LPARAM)szHRClassName); } // Free the string we got from StringFromCLSID. OleStdFree(lpszCLSID); RegCloseKey(hKey); return cStrings; // return # of strings added } /* * OleUICanConvertOrActivateAs * * Purpose: * Determine if there is any OLE object class from the registration * database that we can convert or activate the specified clsid from. * * Parameters: * rClsid REFCLSID Class ID for class to find convert classes for * fIsLinkedObject BOOL is the original object a linked object * wFormat WORD specifying the format of the original class. * * Return Value: * BOOL TRUE if Convert command should be enabled, else FALSE */ STDAPI_(BOOL) OleUICanConvertOrActivateAs( REFCLSID rClsid, BOOL fIsLinkedObject, WORD wFormat) { // Open up the root key. HKEY hKey; HRESULT hr; LONG lRet = RegOpenKey(HKEY_CLASSES_ROOT, TEXT("CLSID"), &hKey); if (ERROR_SUCCESS != lRet) return FALSE; // Get the class name of the original class. LPTSTR lpszCLSID = NULL; #if defined(WIN32) && !defined(UNICODE) // This code does not report allocation errors because neither did // the original code before I extended it to support 32-bit ANSI builds. // In any event, if OleStdMalloc returns NULL, then the string will // simply be lost. Technically an error, but not a fatal one. // Since this routine has no way to report errors anyway (a design flaw // IMHO) I consider this to be marginally acceptable. LPOLESTR wszCLSID; StringFromCLSID(rClsid, &wszCLSID); lpszCLSID = NULL; if (NULL != wszCLSID) { UINT uLen = WTOALEN(wszCLSID); lpszCLSID = (LPTSTR) OleStdMalloc(uLen); if (NULL != lpszCLSID) { WTOA(lpszCLSID, wszCLSID, uLen); } OleStdFree(wszCLSID); } #else hr = StringFromCLSID(rClsid, &lpszCLSID); #endif if (FAILED(hr) || lpszCLSID == NULL) //out of memory, most likely return FALSE; // Here, we step through the entire registration db looking for // class that can read or write the original class' format. // This loop stops if a single class is found. UINT cStrings = 0; TCHAR szClass[OLEUI_CCHKEYMAX]; lRet = RegEnumKey(hKey, cStrings++, szClass, sizeof(szClass) / sizeof(TCHAR)); TCHAR szFormatKey[OLEUI_CCHKEYMAX]; TCHAR szFormat[OLEUI_CCHKEYMAX]; TCHAR szHRClassName[OLEUI_CCHKEYMAX]; BOOL fEnableConvert = FALSE; while (ERROR_SUCCESS == lRet) { if (lstrcmp(lpszCLSID, szClass) == 0) goto next; // we don't want to consider the source class // Check for a \Conversion\ReadWriteable\Main entry first - if its // readwriteable, then we don't need to bother checking to see if // its readable. lstrcpy(szFormatKey, szClass); lstrcat(szFormatKey, TEXT("\\Conversion\\Readwritable\\Main")); DWORD dw; dw = OLEUI_CCHKEYMAX_SIZE; lRet = RegQueryValue(hKey, szFormatKey, szFormat, (LONG*)&dw); if (ERROR_SUCCESS != lRet) { // Try \\DataFormats\DefaultFile too lstrcpy(szFormatKey, szClass); lstrcat(szFormatKey, TEXT("\\DataFormats\\DefaultFile")); dw = OLEUI_CCHKEYMAX_SIZE; lRet = RegQueryValue(hKey, szFormatKey, szFormat, (LONG*)&dw); } if (ERROR_SUCCESS == lRet && FormatIncluded(szFormat, wFormat)) { // Here, we've got a list of formats that this class can read // and write. We need to see if the original class' format is // in this list. We do that by looking for wFormat in // szFormat - if it in there, then we add this class to the // both lists and continue. If not, then we look at the // class' readable formats. dw = OLEUI_CCHKEYMAX_SIZE; lRet = RegQueryValue(hKey, szClass, szHRClassName, (LONG*)&dw); if (ERROR_SUCCESS == lRet) { fEnableConvert = TRUE; break; // STOP -- found one! } } // We either didn't find the readwritable key, or the // list of readwritable formats didn't include the // original class format. So, here we'll check to // see if its in the readable list. // We've got a special case for a linked object here. // If an object is linked, then the only class that // should appear in the convert list is the object's // class. So, here we check to see if the object is // linked. If it is, then we compare the classes. If // they aren't the same, then we just go to the next key. else if (!fIsLinkedObject || lstrcmp(lpszCLSID, szClass) == 0) { // Check for a \Conversion\Readable\Main entry lstrcpy(szFormatKey, szClass); lstrcat(szFormatKey, TEXT("\\Conversion\\Readable\\Main")); // Check to see if this class can read the original class format. dw = OLEUI_CCHKEYMAX_SIZE; lRet = RegQueryValue(hKey, szFormatKey, szFormat, (LONG*)&dw); if (ERROR_SUCCESS == lRet && FormatIncluded(szFormat, wFormat)) { dw = OLEUI_CCHKEYMAX_SIZE; lRet = RegQueryValue(hKey, szClass, szHRClassName, (LONG*)&dw); if (ERROR_SUCCESS == lRet) { fEnableConvert = TRUE; break; // STOP -- found one! } } } next: // Continue with the next key. lRet = RegEnumKey(hKey, cStrings++, szClass, sizeof(szClass) / sizeof(TCHAR)); } // Free the string we got from StringFromCLSID. OleStdFree(lpszCLSID); RegCloseKey(hKey); return fEnableConvert; } /* * FormatIncluded * * Purpose: * Parses the string for format from the word. * * Parameters: * szStringToSearch String to parse * wFormat format to find * * Return Value: * BOOL TRUE if format is found in string, * FALSE otherwise. */ BOOL FormatIncluded(LPTSTR szStringToSearch, WORD wFormat) { TCHAR szFormat[255]; if (wFormat < 0xC000) wsprintf(szFormat, TEXT("%d"), wFormat); else GetClipboardFormatName(wFormat, szFormat, 255); LPTSTR lpToken = szStringToSearch; while (lpToken != NULL) { LPTSTR lpTokenNext = FindChar(lpToken, TEXT(',')); if (lpTokenNext != NULL) { *lpTokenNext = 0; ++lpTokenNext; } if (0 == lstrcmpi(lpToken, szFormat)) return TRUE; lpToken = lpTokenNext; } return FALSE; } /* * UpdateClassIcon * * Purpose: * Handles LBN_SELCHANGE for the Object Type listbox. On a selection * change, we extract an icon from the server handling the currently * selected object type using the utility function HIconFromClass. * Note that we depend on the behavior of FillClassList to stuff the * object class after a tab in the listbox string that we hide from * view (see WM_INITDIALOG). * * Parameters * hDlg HWND of the dialog box. * lpCV LPCONVERT pointing to the dialog structure * hList HWND of the Object Type listbox. * * Return Value: * None */ static void UpdateClassIcon(HWND hDlg, LPCONVERT lpCV, HWND hList) { if (GetDlgItem(hDlg, IDC_CV_ICONDISPLAY) == NULL) return; // Get current selection in the list box int iSel= (UINT)SendMessage(hList, LB_GETCURSEL, 0, 0L); if (LB_ERR == iSel) return; // Allocate a string to hold the entire listbox string DWORD cb = (DWORD)SendMessage(hList, LB_GETTEXTLEN, iSel, 0L); LPTSTR pszName = (LPTSTR)OleStdMalloc((cb+1) * sizeof(TCHAR)); if (pszName == NULL) return; // Get whole string SendMessage(hList, LB_GETTEXT, iSel, (LPARAM)pszName); // Set pointer to CLSID (string) LPTSTR pszCLSID = PointerToNthField(pszName, 2, '\t'); // Create the class ID with this string. CLSID clsid; #if defined(WIN32) && !defined(UNICODE) OLECHAR wszCLSID[OLEUI_CCHKEYMAX]; ATOW(wszCLSID, pszCLSID, OLEUI_CCHKEYMAX); HRESULT hr = CLSIDFromString(wszCLSID, &clsid); #else HRESULT hr = CLSIDFromString(pszCLSID, &clsid); #endif if (SUCCEEDED(hr)) { // Get Icon for that CLSID HGLOBAL hMetaPict = OleGetIconOfClass(clsid, NULL, TRUE); // Replace current icon with the new one. SendDlgItemMessage(hDlg, IDC_CV_ICONDISPLAY, IBXM_IMAGESET, 1, (LPARAM)hMetaPict); } OleStdFree(pszName); } /* * SetConvertResults * * Purpose: * Centralizes setting of the Result display in the Convert * dialog. Handles loading the appropriate string from the module's * resources and setting the text, displaying the proper result picture, * and showing the proper icon. * * Parameters: * hDlg HWND of the dialog box so we can access controls. * lpCV LPCONVERT in which we assume that the dwFlags is * set to the appropriate radio button selection, and * the list box has the appropriate class selected. * * Return Value: * None */ void SetConvertResults(HWND hDlg, LPCONVERT lpCV) { HWND hList = lpCV->hListVisible; /* * We need scratch memory for loading the stringtable string, loading * the object type from the listbox, loading the source object * type, and constructing the final string. We therefore allocate * four buffers as large as the maximum message length (512) plus * the object type, guaranteeing that we have enough * in all cases. */ UINT i = (UINT)SendMessage(hList, LB_GETCURSEL, 0, 0L); UINT cch = 512+(UINT)SendMessage(hList, LB_GETTEXTLEN, i, 0L); HGLOBAL hMem = GlobalAlloc(GHND, (DWORD)(4*cch)*sizeof(TCHAR)); if (NULL == hMem) return; LPTSTR lpszOutput = (LPTSTR)GlobalLock(hMem); LPTSTR lpszSelObj = lpszOutput + cch; LPTSTR lpszDefObj = lpszSelObj + cch; LPTSTR lpszString = lpszDefObj + cch; // Get selected object and null terminate human-readable name (1st field). SendMessage(hList, LB_GETTEXT, i, (LPARAM)lpszSelObj); LPTSTR pszT = PointerToNthField(lpszSelObj, 2, '\t'); pszT = CharPrev(lpszSelObj, pszT); *pszT = '\0'; // Get default object GetDlgItemText(hDlg, IDC_CV_OBJECTTYPE, lpszDefObj, 512); //Default is an empty string. *lpszOutput=0; if (lpCV->dwFlags & CF_SELECTCONVERTTO) { if (lpCV->lpOCV->fIsLinkedObject) // working with linked object LoadString(_g_hOleStdResInst, IDS_CVRESULTCONVERTLINK, lpszOutput, cch); else { if (0 !=lstrcmp(lpszDefObj, lpszSelObj)) { // converting to a new class if (0 != LoadString(_g_hOleStdResInst, IDS_CVRESULTCONVERTTO, lpszString, cch)) FormatString2(lpszOutput, lpszString, lpszDefObj, lpszSelObj); } else { // converting to the same class (no conversion) if (0 != LoadString(_g_hOleStdResInst, IDS_CVRESULTNOCHANGE, lpszString, cch)) wsprintf(lpszOutput, lpszString, lpszDefObj); } } if (lpCV->dvAspect == DVASPECT_ICON) // Display as icon is checked { if (0 != LoadString(_g_hOleStdResInst, IDS_CVRESULTDISPLAYASICON, lpszString, cch)) lstrcat(lpszOutput, lpszString); } } if (lpCV->dwFlags & CF_SELECTACTIVATEAS) { if (0 != LoadString(_g_hOleStdResInst, IDS_CVRESULTACTIVATEAS, lpszString, cch)) FormatString2(lpszOutput, lpszString, lpszDefObj, lpszSelObj); // activating as a new class if (0 != lstrcmp(lpszDefObj, lpszSelObj)) { if (0 != LoadString(_g_hOleStdResInst, IDS_CVRESULTACTIVATEDIFF, lpszString, cch)) lstrcat(lpszOutput, lpszString); } else // activating as itself. { lstrcat(lpszOutput, TEXT(".")); } } // If LoadString failed, we simply clear out the results (*lpszOutput=0 above) SetDlgItemText(hDlg, IDC_CV_RESULTTEXT, lpszOutput); GlobalUnlock(hMem); GlobalFree(hMem); } /* * ConvertCleanup * * Purpose: * Performs convert-specific cleanup before Convert termination. * * Parameters: * hDlg HWND of the dialog box so we can access controls. * * Return Value: * None */ void ConvertCleanup(HWND hDlg, LPCONVERT lpCV) { // Free our strings. Zero out the user type name string // the the calling app doesn't free to it. OleStdFree((LPVOID)lpCV->lpszConvertDefault); OleStdFree((LPVOID)lpCV->lpszActivateDefault); OleStdFree((LPVOID)lpCV->lpszIconSource); if (lpCV->lpOCV->lpszUserType) { OleStdFree((LPVOID)lpCV->lpOCV->lpszUserType); lpCV->lpOCV->lpszUserType = NULL; } if (lpCV->lpOCV->lpszDefLabel) { OleStdFree((LPVOID)lpCV->lpOCV->lpszDefLabel); lpCV->lpOCV->lpszDefLabel = NULL; } } /* * SwapWindows * * Purpose: * Moves hWnd1 to hWnd2's position and hWnd2 to hWnd1's position. * Does NOT change sizes. * * Parameters: * hDlg HWND of the dialog box so we can turn redraw off * * Return Value: * None */ void SwapWindows(HWND hDlg, HWND hWnd1, HWND hWnd2) { if (hWnd1 != NULL && hWnd2 != NULL) { RECT rect1; GetWindowRect(hWnd1, &rect1); MapWindowPoints(NULL, hDlg, (LPPOINT)&rect1, 2); RECT rect2; GetWindowRect(hWnd2, &rect2); MapWindowPoints(NULL, hDlg, (LPPOINT)&rect2, 2); SetWindowPos(hWnd1, NULL, rect2.left, rect2.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE); SetWindowPos(hWnd2, NULL, rect1.left, rect1.top, 0, 0, SWP_NOZORDER | SWP_NOSIZE); } }