1803 lines
58 KiB
C
1803 lines
58 KiB
C
/*
|
||
* CONVERT.C
|
||
*
|
||
* Implements the OleUIConvert function which invokes the complete
|
||
* Convert dialog.
|
||
*
|
||
* Copyright (c)1992 Microsoft Corporation, All Right Reserved
|
||
*/
|
||
|
||
#define STRICT 1
|
||
#include "ole2ui.h"
|
||
#include <stdlib.h>
|
||
#include "common.h"
|
||
#include "utility.h"
|
||
#include "geticon.h"
|
||
#include "regdb.h"
|
||
#include "convert.h"
|
||
|
||
#define CF_CLIPBOARDMIN 0xc000
|
||
#define CF_CLIPBOARDMAX 0xffff
|
||
|
||
#define AUXUSERTYPE_SHORTNAME USERCLASSTYPE_SHORT // short name
|
||
|
||
static TCHAR szOLE2DLL[] = TEXT("ole2.dll"); // name of OLE 2.0 library
|
||
|
||
static TCHAR szVanillaDocIcon[] = TEXT("DefIcon");
|
||
|
||
/*
|
||
* 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)
|
||
{
|
||
UINT uRet;
|
||
HGLOBAL hMemDlg=NULL;
|
||
|
||
uRet=UStandardValidation((LPOLEUISTANDARD)lpCV, sizeof(OLEUICONVERT)
|
||
, &hMemDlg);
|
||
|
||
if (OLEUI_SUCCESS!=uRet)
|
||
return uRet;
|
||
|
||
// Validate structure members passed in.
|
||
#if defined( OBSOLETE )
|
||
if (!IsValidClassID(lpCV->clsid))
|
||
uRet = OLEUI_CTERR_CLASSIDINVALID;
|
||
#endif
|
||
|
||
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, (LPTSTR)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)
|
||
{
|
||
if (NULL!=lpCV->lpClsidExclude && IsBadReadPtr(lpCV->lpClsidExclude
|
||
, lpCV->cClsidExclude*sizeof(CLSID)))
|
||
uRet=OLEUI_IOERR_LPCLSIDEXCLUDEINVALID;
|
||
}
|
||
|
||
|
||
if (OLEUI_ERR_STANDARDMIN <= uRet)
|
||
{
|
||
if (NULL!=hMemDlg)
|
||
FreeResource(hMemDlg);
|
||
|
||
return uRet;
|
||
}
|
||
|
||
//Now that we've validated everything, we can invoke the dialog.
|
||
uRet=UStandardInvocation(ConvertDialogProc, (LPOLEUISTANDARD)lpCV,
|
||
hMemDlg, MAKEINTRESOURCE(IDD_CONVERT));
|
||
|
||
return uRet;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
/*
|
||
* ConvertDialogProc
|
||
*
|
||
* Purpose:
|
||
* Implements the OLE Convert dialog as invoked through the
|
||
* OleUIConvert function.
|
||
*
|
||
* Parameters:
|
||
* Standard
|
||
*
|
||
* Return Value:
|
||
* Standard
|
||
*
|
||
*/
|
||
|
||
BOOL CALLBACK EXPORT ConvertDialogProc(HWND hDlg, UINT iMsg, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
LPCONVERT lpCV;
|
||
UINT uRet = 0;
|
||
OLEUICHANGEICON ci;
|
||
|
||
//Declare Win16/Win32 compatible WM_COMMAND parameters.
|
||
COMMANDPARAMS(wID, wCode, hWndMsg);
|
||
|
||
//This will fail under WM_INITDIALOG, where we allocate it.
|
||
lpCV=(LPCONVERT)LpvStandardEntry(hDlg, iMsg, wParam, lParam, (UINT FAR *)&uRet);
|
||
|
||
//If the hook processed the message, we're done.
|
||
if (0!=uRet)
|
||
return (BOOL)uRet;
|
||
|
||
//Process the temination message
|
||
if (iMsg==uMsgEndDialog)
|
||
{
|
||
ConvertCleanup(hDlg, lpCV);
|
||
StandardCleanup(lpCV, hDlg);
|
||
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_INITDIALOG:
|
||
FConvertInit(hDlg, wParam, lParam);
|
||
return TRUE;
|
||
|
||
case WM_COMMAND:
|
||
switch (wID)
|
||
{
|
||
case IDCV_ACTIVATELIST:
|
||
case IDCV_CONVERTLIST:
|
||
switch (wCode)
|
||
{
|
||
case LBN_SELCHANGE:
|
||
|
||
// Change "Results" window to reflect current selection
|
||
SetConvertResults(hDlg, lpCV);
|
||
|
||
// Update the icon we display, if we are indeed
|
||
// displaying an icon.
|
||
if ( (lpCV->dwFlags & CF_SELECTCONVERTTO)
|
||
&& (lpCV->dvAspect == DVASPECT_ICON)
|
||
&& (!lpCV->fCustomIcon) )
|
||
UpdateCVClassIcon(hDlg, lpCV, hWndMsg);
|
||
|
||
break;
|
||
|
||
case LBN_DBLCLK:
|
||
//Same as pressing OK.
|
||
SendCommand(hDlg, IDOK, BN_CLICKED, hWndMsg);
|
||
break;
|
||
}
|
||
break;
|
||
|
||
case IDCV_CONVERTTO:
|
||
case IDCV_ACTIVATEAS:
|
||
{
|
||
HWND hList, hListInvisible;
|
||
LRESULT lRetVal;
|
||
BOOL fState;
|
||
|
||
hList = lpCV->hListVisible;
|
||
hListInvisible = lpCV->hListInvisible;
|
||
|
||
|
||
if (IDCV_CONVERTTO == wParam)
|
||
{
|
||
|
||
// User just click on the button again - it was
|
||
// already selected.
|
||
if (lpCV->dwFlags & CF_SELECTCONVERTTO)
|
||
break;
|
||
|
||
|
||
// Turn painting updates off.
|
||
SendMessage(hDlg, WM_SETREDRAW, FALSE, 0L);
|
||
|
||
|
||
// 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;
|
||
|
||
// Turn painting updates off.
|
||
SendMessage(hDlg, WM_SETREDRAW, FALSE, 0L);
|
||
|
||
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;
|
||
}
|
||
|
||
|
||
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, IDCV_OBJECTTYPE, (LPTSTR)szCurrentObject, 40);
|
||
SendMessage(lpCV->hListVisible, LB_SELECTSTRING, (WPARAM)-1, (LPARAM)(LPTSTR)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))
|
||
UpdateCVClassIcon(hDlg, lpCV, lpCV->hListVisible);
|
||
|
||
// Hide the icon stuff when Activate is selected...show
|
||
// it again when Convert is selected.
|
||
|
||
fState = ((lpCV->dwFlags & CF_SELECTACTIVATEAS) ||
|
||
(lpCV->dwFlags & CF_DISABLEDISPLAYASICON)) ?
|
||
SW_HIDE : SW_SHOW;
|
||
|
||
StandardShowDlgItem(hDlg, IDCV_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, IDCV_CHANGEICON, fState);
|
||
StandardShowDlgItem(hDlg, IDCV_ICON, fState);
|
||
StandardShowDlgItem(hDlg, IDCV_ICONLABEL1, fState);
|
||
StandardShowDlgItem(hDlg, IDCV_ICONLABEL2, fState);
|
||
|
||
SetConvertResults(hDlg, lpCV);
|
||
|
||
}
|
||
break;
|
||
|
||
|
||
case IDOK:
|
||
{
|
||
|
||
LRESULT iCurSel;
|
||
LPTSTR lpszCLSID;
|
||
TCHAR szBuffer[256];
|
||
|
||
// Set OUT parameters
|
||
|
||
//
|
||
// 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
|
||
//
|
||
iCurSel = SendMessage(lpCV->hListVisible, LB_GETCURSEL, 0, 0);
|
||
SendMessage(lpCV->hListVisible, LB_GETTEXT, iCurSel, (LPARAM)szBuffer);
|
||
|
||
lpszCLSID = PointerToNthField((LPTSTR)szBuffer, 2, TEXT('\t'));
|
||
|
||
CLSIDFromStringA(lpszCLSID, (&(lpCV->lpOCV->clsidNew)));
|
||
|
||
// Free the hMetaPict we got in.
|
||
OleUIMetafilePictIconFree(lpCV->lpOCV->hMetaPict);
|
||
|
||
//
|
||
// Get the hMetaPict (if display as icon is checked)
|
||
//
|
||
if (DVASPECT_ICON == lpCV->dvAspect)
|
||
{
|
||
HICON hIcon;
|
||
TCHAR szLabel[OLEUI_CCHLABELMAX];
|
||
INT Index;
|
||
|
||
|
||
// Create the hMetaPict here from icon, label,
|
||
// index, and path
|
||
|
||
hIcon = (HICON)SendDlgItemMessage(hDlg, IDCV_ICON, STM_GETICON, 0, 0L);
|
||
|
||
// the combined length of the 2 label lines won't ever be more than
|
||
// OLEUI_CCHLABELMAX.
|
||
Index = (INT)SendDlgItemMessage(hDlg, IDCV_ICONLABEL1,
|
||
WM_GETTEXT, OLEUI_CCHLABELMAX, (LPARAM)szLabel);
|
||
|
||
if (Index < OLEUI_CCHLABELMAX)
|
||
{
|
||
LPTSTR lpszSecondLine = szLabel + Index;
|
||
|
||
|
||
SendDlgItemMessage(hDlg, IDCV_ICONLABEL2, WM_GETTEXT,
|
||
OLEUI_CCHLABELMAX-Index,
|
||
(LPARAM)lpszSecondLine);
|
||
}
|
||
|
||
#ifdef OLE201
|
||
lpCV->lpOCV->hMetaPict =
|
||
OleUIMetafilePictFromIconAndLabel(hIcon,
|
||
(LPTSTR)szLabel,
|
||
lpCV->lpszIconSource,
|
||
lpCV->IconIndex);
|
||
#endif
|
||
|
||
}
|
||
else
|
||
lpCV->lpOCV->hMetaPict = (HGLOBAL)NULL;
|
||
|
||
|
||
//
|
||
// End the dialog
|
||
//
|
||
SendMessage(hDlg, uMsgEndDialog, OLEUI_OK, 0L);
|
||
}
|
||
break;
|
||
|
||
case IDCANCEL:
|
||
SendMessage(hDlg, uMsgEndDialog, OLEUI_CANCEL, 0L);
|
||
break;
|
||
|
||
|
||
case ID_OLEUIHELP:
|
||
PostMessage(lpCV->lpOCV->hWndOwner,
|
||
uMsgHelp, (WPARAM)hDlg, MAKELPARAM(IDD_CONVERT, 0));
|
||
break;
|
||
|
||
case IDCV_DISPLAYASICON:
|
||
{
|
||
|
||
int i;
|
||
BOOL fCheck;
|
||
|
||
fCheck=IsDlgButtonChecked(hDlg, wID);
|
||
|
||
if (fCheck)
|
||
lpCV->dvAspect = DVASPECT_ICON;
|
||
else
|
||
lpCV->dvAspect = DVASPECT_CONTENT;
|
||
|
||
if (fCheck && (!lpCV->fCustomIcon))
|
||
UpdateCVClassIcon(hDlg, lpCV, lpCV->hListVisible);
|
||
|
||
//Show or hide the icon depending on the check state.
|
||
|
||
i=(fCheck) ? SW_SHOWNORMAL : SW_HIDE;
|
||
|
||
StandardShowDlgItem(hDlg, IDCV_CHANGEICON, i);
|
||
StandardShowDlgItem(hDlg, IDCV_ICON, i);
|
||
StandardShowDlgItem(hDlg, IDCV_ICONLABEL1, i);
|
||
StandardShowDlgItem(hDlg, IDCV_ICONLABEL2, i);
|
||
|
||
SetConvertResults(hDlg, lpCV);
|
||
|
||
}
|
||
break;
|
||
|
||
case IDCV_CHANGEICON:
|
||
{
|
||
LPMALLOC pIMalloc;
|
||
LPTSTR pszString, pszCLSID;
|
||
INT iSel;
|
||
HICON hIcon;
|
||
TCHAR szLabel[OLEUI_CCHLABELMAX];
|
||
INT Index;
|
||
|
||
|
||
//Initialize the structure for the hook.
|
||
_fmemset((LPOLEUICHANGEICON)&ci, 0, sizeof(ci));
|
||
|
||
// Create the hMetaPict here from icon, label,
|
||
// index, and path
|
||
|
||
hIcon = (HICON)SendDlgItemMessage(hDlg, IDCV_ICON, STM_GETICON, 0, 0L);
|
||
|
||
// the combined length of the 2 label lines won't ever be more than
|
||
// OLEUI_CCHLABELMAX.
|
||
|
||
Index = (INT)SendDlgItemMessage(hDlg, IDCV_ICONLABEL1, WM_GETTEXT,
|
||
OLEUI_CCHLABELMAX, (LPARAM)szLabel);
|
||
|
||
if (Index < OLEUI_CCHLABELMAX)
|
||
{
|
||
LPTSTR lpszSecondLine;
|
||
|
||
lpszSecondLine = szLabel + Index;
|
||
|
||
SendDlgItemMessage(hDlg, IDCV_ICONLABEL2, WM_GETTEXT,
|
||
OLEUI_CCHLABELMAX-Index,
|
||
(LPARAM)lpszSecondLine);
|
||
}
|
||
|
||
#ifdef OLE201
|
||
ci.hMetaPict =
|
||
OleUIMetafilePictFromIconAndLabel(hIcon,
|
||
szLabel,
|
||
lpCV->lpszIconSource,
|
||
lpCV->IconIndex);
|
||
#endif
|
||
|
||
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;
|
||
|
||
iSel = (INT)SendMessage(lpCV->hListVisible, LB_GETCURSEL, 0, 0L);
|
||
|
||
CoGetMalloc(MEMCTX_TASK, &pIMalloc);
|
||
|
||
pszString = (LPTSTR)pIMalloc->lpVtbl->Alloc(pIMalloc,
|
||
OLEUI_CCHLABELMAX_SIZE +
|
||
OLEUI_CCHCLSIDSTRING_SIZE);
|
||
|
||
// Get whole string
|
||
SendMessage(lpCV->hListVisible, LB_GETTEXT, iSel, (LONG)pszString);
|
||
|
||
// Set pointer to CLSID (string)
|
||
pszCLSID = PointerToNthField(pszString, 2, TEXT('\t'));
|
||
|
||
// Get the clsid to pass to change icon.
|
||
CLSIDFromStringA(pszCLSID, &(ci.clsid));
|
||
|
||
pIMalloc->lpVtbl->Free(pIMalloc, (LPVOID)pszString);
|
||
pIMalloc->lpVtbl->Release(pIMalloc);
|
||
|
||
//Let the hook in to customize Change Icon if desired.
|
||
uRet=UStandardHook(lpCV, hDlg, uMsgChangeIcon
|
||
, 0, (LONG)(LPTSTR)&ci);
|
||
|
||
if (0==uRet)
|
||
uRet=(UINT)(OLEUI_OK==OleUIChangeIcon((LPOLEUICHANGEICON)&ci));
|
||
|
||
//Update the display if necessary.
|
||
if (0!=uRet)
|
||
{
|
||
HICON hIcon;
|
||
TCHAR szLabel[OLEUI_CCHLABELMAX];
|
||
DWORD dwWrapIndex;
|
||
|
||
|
||
hIcon = OleUIMetafilePictExtractIcon(ci.hMetaPict);
|
||
|
||
SendDlgItemMessage(hDlg, IDCV_ICON, STM_SETICON, (WPARAM)hIcon, 0L);
|
||
|
||
OleUIMetafilePictExtractIconSource(ci.hMetaPict, lpCV->lpszIconSource, &(lpCV->IconIndex));
|
||
|
||
OleUIMetafilePictExtractLabel(ci.hMetaPict, szLabel, OLEUI_CCHLABELMAX, &dwWrapIndex);
|
||
|
||
if (0 == dwWrapIndex) // no second line
|
||
{
|
||
SendDlgItemMessage(hDlg, IDCV_ICONLABEL1, WM_SETTEXT, 0, (LPARAM)(LPTSTR)szLabel);
|
||
SendDlgItemMessage(hDlg, IDCV_ICONLABEL2, WM_SETTEXT, 0, (LPARAM)(LPTSTR)TEXT(""));
|
||
}
|
||
else
|
||
{
|
||
|
||
LPTSTR lpszSecondLine;
|
||
|
||
lpszSecondLine = szLabel + dwWrapIndex;
|
||
SendDlgItemMessage(hDlg, IDCV_ICONLABEL2,
|
||
WM_SETTEXT, 0, (LPARAM)lpszSecondLine);
|
||
|
||
*lpszSecondLine = TEXT('\0');
|
||
SendDlgItemMessage(hDlg, IDCV_ICONLABEL1,
|
||
WM_SETTEXT, 0, (LPARAM)(LPTSTR)szLabel);
|
||
}
|
||
|
||
|
||
// 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)
|
||
{
|
||
LPCONVERT lpCV;
|
||
LPOLEUICONVERT lpOCV;
|
||
LPMALLOC pIMalloc;
|
||
HFONT hFont; // non-bold version of dialog's font
|
||
RECT rc;
|
||
DWORD dw;
|
||
INT cItemsActivate;
|
||
HKEY hKey;
|
||
LONG lRet;
|
||
UINT nRet;
|
||
|
||
|
||
//Copy the structure at lParam into our instance memory.
|
||
lpCV=(LPCONVERT)LpvStandardInit(hDlg, sizeof(CONVERT), TRUE, (HFONT FAR *)&hFont);
|
||
|
||
//PvStandardInit send a termination to us already.
|
||
if (NULL==lpCV)
|
||
return FALSE;
|
||
|
||
lpOCV=(LPOLEUICONVERT)lParam;
|
||
|
||
lpCV->lpOCV=lpOCV;
|
||
|
||
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, IDCV_ACTIVATELIST);
|
||
lpCV->hListInvisible = GetDlgItem(hDlg, IDCV_CONVERTLIST);
|
||
lpCV->lpszCurrentObject = lpOCV->lpszUserType;
|
||
|
||
lpOCV->clsidNew = CLSID_NULL;
|
||
|
||
lpOCV->fObjectsIconChanged = FALSE;
|
||
|
||
//Allocate space for our strings
|
||
if (NOERROR != CoGetMalloc(MEMCTX_TASK, &pIMalloc))
|
||
return FALSE;
|
||
|
||
lpCV->lpszConvertDefault = (LPTSTR)pIMalloc->lpVtbl->Alloc(pIMalloc, OLEUI_CCHLABELMAX_SIZE);
|
||
lpCV->lpszActivateDefault = (LPTSTR)pIMalloc->lpVtbl->Alloc(pIMalloc, OLEUI_CCHLABELMAX_SIZE);
|
||
lpCV->lpszIconSource = (LPTSTR)pIMalloc->lpVtbl->Alloc(pIMalloc, OLEUI_CCHPATHMAX_SIZE);
|
||
pIMalloc->lpVtbl->Release(pIMalloc);
|
||
|
||
//If we got a font, send it to the necessary controls.
|
||
if (NULL!=hFont)
|
||
{
|
||
SendDlgItemMessage(hDlg, IDCV_OBJECTTYPE, WM_SETFONT, (WPARAM)hFont, 0L);
|
||
SendDlgItemMessage(hDlg, IDCV_RESULTTEXT, WM_SETFONT, (WPARAM)hFont, 0L);
|
||
SendDlgItemMessage(hDlg, IDCV_ICONLABEL1, WM_SETFONT, (WPARAM)hFont, 0L);
|
||
SendDlgItemMessage(hDlg, IDCV_ICONLABEL2, WM_SETFONT, (WPARAM)hFont, 0L);
|
||
}
|
||
|
||
//Hide the help button if necessary
|
||
if (!(lpCV->dwFlags & CF_SHOWHELPBUTTON))
|
||
StandardShowDlgItem(hDlg, ID_OLEUIHELP, SW_HIDE);
|
||
|
||
//Fill the Object Type listbox with entries from the reg DB.
|
||
nRet = FillClassList(lpOCV->clsid,
|
||
lpCV->hListVisible,
|
||
lpCV->hListInvisible,
|
||
&(lpCV->lpszCurrentObject),
|
||
lpOCV->fIsLinkedObject,
|
||
lpOCV->wFormat,
|
||
lpOCV->cClsidExclude,
|
||
lpOCV->lpClsidExclude);
|
||
|
||
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, IDCV_OBJECTTYPE, (LPTSTR)lpCV->lpszCurrentObject);
|
||
|
||
// Disable the "Activate As" button if the Activate list doesn't
|
||
// have any objects in it.
|
||
|
||
cItemsActivate = (INT)SendMessage(lpCV->hListVisible, LB_GETCOUNT, 0, 0L);
|
||
|
||
if (1 >= cItemsActivate || (lpCV->dwFlags & CF_DISABLEACTIVATEAS))
|
||
EnableWindow(GetDlgItem(hDlg, IDCV_ACTIVATEAS), FALSE);
|
||
|
||
//Set the tab width in the list to push all the tabs off the side.
|
||
GetClientRect(lpCV->hListVisible, (LPRECT)&rc);
|
||
dw=GetDialogBaseUnits();
|
||
rc.right =(8*rc.right)/LOWORD(dw); //Convert pixels to 2x dlg units.
|
||
SendMessage(lpCV->hListVisible, LB_SETTABSTOPS, 1, (LPARAM)(LPINT)(&rc.right));
|
||
SendMessage(lpCV->hListInvisible, LB_SETTABSTOPS, 1, (LPARAM)(LPINT)(&rc.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, IDCV_CONVERTTO, IDCV_ACTIVATEAS, IDCV_ACTIVATEAS);
|
||
|
||
// Hide the icon stuff when Activate is selected...it gets shown
|
||
// again when Convert is selected.
|
||
|
||
StandardShowDlgItem(hDlg, IDCV_DISPLAYASICON, SW_HIDE);
|
||
StandardShowDlgItem(hDlg, IDCV_CHANGEICON, SW_HIDE);
|
||
StandardShowDlgItem(hDlg, IDCV_ICON, SW_HIDE);
|
||
StandardShowDlgItem(hDlg, IDCV_ICONLABEL1, SW_HIDE);
|
||
StandardShowDlgItem(hDlg, IDCV_ICONLABEL2, 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, IDCV_DISPLAYASICON, SW_HIDE);
|
||
StandardShowDlgItem(hDlg, IDCV_CHANGEICON, SW_HIDE);
|
||
StandardShowDlgItem(hDlg, IDCV_ICON, SW_HIDE);
|
||
StandardShowDlgItem(hDlg, IDCV_ICONLABEL1, SW_HIDE);
|
||
StandardShowDlgItem(hDlg, IDCV_ICONLABEL2, SW_HIDE);
|
||
}
|
||
|
||
lpCV->dwFlags |= CF_SELECTCONVERTTO; // Make sure flag is set
|
||
CheckRadioButton(hDlg, IDCV_CONVERTTO, IDCV_ACTIVATEAS, IDCV_CONVERTTO);
|
||
|
||
SwapWindows(hDlg, lpCV->hListVisible, lpCV->hListInvisible);
|
||
|
||
lpCV->hListVisible = lpCV->hListInvisible;
|
||
lpCV->hListInvisible = hWndTemp;
|
||
|
||
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)) )
|
||
{
|
||
dw = OleStdGetUserTypeOfClass((LPCLSID)(&lpCV->lpOCV->clsidConvertDefault),
|
||
lpCV->lpszConvertDefault,
|
||
OLEUI_CCHLABELMAX_SIZE,
|
||
NULL);
|
||
|
||
if (0 == dw)
|
||
lstrcpy((LPTSTR)lpCV->lpszConvertDefault, (LPTSTR)lpCV->lpszCurrentObject);
|
||
}
|
||
else
|
||
lstrcpy((LPTSTR)lpCV->lpszConvertDefault, (LPTSTR)lpCV->lpszCurrentObject);
|
||
|
||
|
||
// 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;
|
||
|
||
|
||
|
||
lRet = RegOpenKey(HKEY_CLASSES_ROOT, TEXT("CLSID"), (HKEY FAR *)&hKey);
|
||
|
||
if (lRet != ERROR_SUCCESS)
|
||
goto CheckInputFlag;
|
||
|
||
else
|
||
{
|
||
LPTSTR lpszCLSID;
|
||
TCHAR szKey[OLEUI_CCHKEYMAX];
|
||
CLSID clsid;
|
||
TCHAR szValue[OLEUI_CCHKEYMAX];
|
||
|
||
StringFromCLSIDA(&(lpCV->lpOCV->clsid), &lpszCLSID);
|
||
lstrcpy(szKey, lpszCLSID);
|
||
lstrcat(szKey, TEXT("\\TreatAs"));
|
||
|
||
dw = OLEUI_CCHKEYMAX_SIZE;
|
||
lRet = RegQueryValue(hKey, (LPTSTR)szKey, (LPTSTR)szValue, (LPDWORD)&dw);
|
||
|
||
if (lRet != ERROR_SUCCESS)
|
||
{
|
||
|
||
RegCloseKey(hKey);
|
||
OleStdFreeString(lpszCLSID, NULL);
|
||
goto CheckInputFlag;
|
||
}
|
||
else
|
||
{
|
||
CLSIDFromStringA(szValue, &clsid);
|
||
|
||
if (0 == OleStdGetUserTypeOfClass(&clsid,
|
||
lpCV->lpszActivateDefault,
|
||
OLEUI_CCHLABELMAX_SIZE,
|
||
NULL))
|
||
{
|
||
RegCloseKey(hKey);
|
||
OleStdFreeString(lpszCLSID, NULL);
|
||
goto CheckInputFlag;
|
||
}
|
||
}
|
||
RegCloseKey(hKey);
|
||
OleStdFreeString(lpszCLSID, NULL);
|
||
goto SelectStringInListbox;
|
||
}
|
||
|
||
|
||
CheckInputFlag:
|
||
if ( (lpCV->dwFlags & CF_SETACTIVATEDEFAULT)
|
||
&& (IsValidClassID(lpCV->lpOCV->clsidActivateDefault)) )
|
||
{
|
||
dw = OleStdGetUserTypeOfClass((LPCLSID)(&lpCV->lpOCV->clsidActivateDefault),
|
||
lpCV->lpszActivateDefault,
|
||
OLEUI_CCHLABELMAX_SIZE,
|
||
NULL);
|
||
|
||
if (0 == dw)
|
||
lstrcpy((LPTSTR)lpCV->lpszActivateDefault, (LPTSTR)lpCV->lpszCurrentObject);
|
||
}
|
||
else
|
||
lstrcpy((LPTSTR)(lpCV->lpszActivateDefault), (LPTSTR)lpCV->lpszCurrentObject);
|
||
|
||
|
||
SelectStringInListbox:
|
||
|
||
if (lpCV->dwFlags & CF_SELECTCONVERTTO)
|
||
lRet = SendMessage(lpCV->hListVisible, LB_SELECTSTRING, (WPARAM)-1, (LPARAM)(LPTSTR)(lpCV->lpszConvertDefault));
|
||
|
||
else
|
||
lRet = SendMessage(lpCV->hListVisible, LB_SELECTSTRING, (WPARAM)-1, (LPARAM)(LPTSTR)(lpCV->lpszActivateDefault));
|
||
|
||
if (LB_ERR == lRet)
|
||
SendMessage(lpCV->hListVisible, LB_SETCURSEL, (WPARAM)0, 0L);
|
||
|
||
|
||
// Initialize icon stuff
|
||
if (DVASPECT_ICON == lpCV->dvAspect )
|
||
{
|
||
SendDlgItemMessage(hDlg, IDCV_DISPLAYASICON, BM_SETCHECK, TRUE, 0L);
|
||
|
||
if ((HGLOBAL)NULL != lpOCV->hMetaPict)
|
||
{
|
||
TCHAR szLabel[OLEUI_CCHLABELMAX];
|
||
HICON hIcon;
|
||
DWORD dwWrapIndex;
|
||
|
||
|
||
// Set the icon to the icon from the hMetaPict,
|
||
// set the label to the label from the hMetaPict.
|
||
|
||
if (0 != OleUIMetafilePictExtractLabel(lpOCV->hMetaPict, (LPTSTR)szLabel, OLEUI_CCHLABELMAX_SIZE, &dwWrapIndex))
|
||
{
|
||
if (0 == dwWrapIndex) // no second line
|
||
{
|
||
SendDlgItemMessage(hDlg, IDCV_ICONLABEL1, WM_SETTEXT, 0, (LPARAM)(LPTSTR)szLabel);
|
||
SendDlgItemMessage(hDlg, IDCV_ICONLABEL2, WM_SETTEXT, 0, (LPARAM)(LPTSTR)TEXT(""));
|
||
}
|
||
else
|
||
{
|
||
|
||
LPTSTR lpszSecondLine;
|
||
|
||
lpszSecondLine = szLabel + dwWrapIndex;
|
||
SendDlgItemMessage(hDlg, IDCV_ICONLABEL2,
|
||
WM_SETTEXT, 0, (LPARAM)lpszSecondLine);
|
||
|
||
*lpszSecondLine = TEXT('\0');
|
||
SendDlgItemMessage(hDlg, IDCV_ICONLABEL1,
|
||
WM_SETTEXT, 0, (LPARAM)(LPTSTR)szLabel);
|
||
}
|
||
|
||
|
||
}
|
||
|
||
hIcon = OleUIMetafilePictExtractIcon(lpOCV->hMetaPict);
|
||
|
||
if (NULL != hIcon)
|
||
{
|
||
SendDlgItemMessage(hDlg, IDCV_ICON, STM_SETICON, (WPARAM)hIcon, 0L);
|
||
lpCV->fCustomIcon = TRUE;
|
||
}
|
||
|
||
OleUIMetafilePictExtractIconSource(lpOCV->hMetaPict,
|
||
(LPTSTR)(lpCV->lpszIconSource),
|
||
&(lpCV->IconIndex));
|
||
|
||
}
|
||
else
|
||
UpdateCVClassIcon(hDlg, lpCV, lpCV->hListVisible);
|
||
}
|
||
else
|
||
{
|
||
// Hide & disable icon stuff
|
||
StandardShowDlgItem(hDlg, IDCV_ICON, SW_HIDE);
|
||
StandardShowDlgItem(hDlg, IDCV_ICONLABEL1, SW_HIDE);
|
||
StandardShowDlgItem(hDlg, IDCV_ICONLABEL2, SW_HIDE);
|
||
StandardShowDlgItem(hDlg, IDCV_CHANGEICON, 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)
|
||
&& lpCV->lpOCV->lpszCaption[0] != '\0')
|
||
SetWindowText(hDlg, (LPTSTR)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 hList,
|
||
HWND hListInvisible,
|
||
LPTSTR FAR *lplpszCurrentClass,
|
||
BOOL fIsLinkedObject,
|
||
WORD wFormat,
|
||
UINT cClsidExclude,
|
||
LPCLSID lpClsidExclude)
|
||
{
|
||
|
||
DWORD dw;
|
||
UINT cStrings=0;
|
||
HKEY hKey;
|
||
LONG lRet;
|
||
TCHAR szFormatKey[OLEUI_CCHKEYMAX];
|
||
TCHAR szClass[OLEUI_CCHKEYMAX];
|
||
TCHAR szFormat[OLEUI_CCHKEYMAX];
|
||
TCHAR szHRClassName[OLEUI_CCHKEYMAX];
|
||
CLSID clsidForList;
|
||
|
||
LPTSTR lpszCLSID;
|
||
|
||
|
||
//Clean out the existing strings.
|
||
SendMessage(hList, LB_RESETCONTENT, 0, 0L);
|
||
SendMessage(hListInvisible, LB_RESETCONTENT, 0, 0L);
|
||
|
||
//Open up the root key.
|
||
lRet=RegOpenKey(HKEY_CLASSES_ROOT, (LPCTSTR) TEXT("CLSID"), (HKEY FAR *)&hKey);
|
||
|
||
if ((LONG)ERROR_SUCCESS!=lRet)
|
||
return (UINT)-1;
|
||
|
||
if (NULL == *lplpszCurrentClass)
|
||
{
|
||
// alloc buffer here...
|
||
|
||
LPMALLOC pIMalloc = NULL;
|
||
HRESULT hrErr;
|
||
|
||
|
||
hrErr = CoGetMalloc(MEMCTX_TASK, &pIMalloc);
|
||
|
||
if (hrErr != NOERROR)
|
||
{
|
||
RegCloseKey(hKey);
|
||
return FALSE;
|
||
}
|
||
|
||
// Allocate space for lpszCurrentClass
|
||
*lplpszCurrentClass = (LPTSTR)pIMalloc->lpVtbl->Alloc(pIMalloc, OLEUI_CCHKEYMAX_SIZE);
|
||
pIMalloc->lpVtbl->Release(pIMalloc);
|
||
|
||
lRet = OleStdGetUserTypeOfClass((REFCLSID)&clsid,
|
||
*lplpszCurrentClass,
|
||
OLEUI_CCHLABELMAX_SIZE,
|
||
NULL);
|
||
|
||
if (0 ==lRet)
|
||
{
|
||
INT n = LoadString(ghInst, IDS_PSUNKNOWNTYPE, *lplpszCurrentClass,
|
||
OLEUI_CCHKEYMAX);
|
||
if (!n)
|
||
{
|
||
OutputDebugString(TEXT("Cannot LoadString\n"));
|
||
RegCloseKey(hKey);
|
||
return (UINT)-1;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Get the class name of the original class.
|
||
StringFromCLSIDA(&clsid, &lpszCLSID);
|
||
|
||
|
||
// 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
|
||
|
||
|
||
cStrings=0;
|
||
lRet=RegEnumKey(hKey, cStrings++, szClass, OLEUI_CCHKEYMAX_SIZE);
|
||
|
||
while ((LONG)ERROR_SUCCESS==lRet)
|
||
{
|
||
INT j;
|
||
BOOL fExclude=FALSE;
|
||
|
||
|
||
//Check if this CLSID is in the exclusion list.
|
||
CLSIDFromStringA(szClass, &clsidForList);
|
||
|
||
for (j=0; j < (int)cClsidExclude; j++)
|
||
{
|
||
if (IsEqualCLSID(&clsidForList, (LPCLSID)(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((LPTSTR)szFormatKey, (LPTSTR)szClass);
|
||
lstrcat((LPTSTR)szFormatKey, (LPTSTR) TEXT("\\Conversion\\Readwritable\\Main"));
|
||
|
||
dw=OLEUI_CCHKEYMAX_SIZE;
|
||
|
||
lRet=RegQueryValue(hKey, (LPTSTR)szFormatKey, (LPTSTR)szFormat, (LONG FAR *)&dw);
|
||
|
||
if ( ((LONG)ERROR_SUCCESS==lRet)
|
||
&& (FormatIncluded((LPTSTR)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, (LPTSTR)szClass, (LPTSTR)szHRClassName, (LPDWORD)&dw);
|
||
|
||
if ((LONG)ERROR_SUCCESS==lRet)
|
||
{
|
||
lstrcat((LPTSTR)szHRClassName, (LPTSTR) TEXT("\t"));
|
||
|
||
// only add if not already in list
|
||
if (LB_ERR==SendMessage(hList,LB_FINDSTRING, 0,
|
||
(LPARAM)(LPSTR)szHRClassName)) {
|
||
lstrcat((LPTSTR)szHRClassName, (LPTSTR)szClass);
|
||
SendMessage(hList, LB_ADDSTRING, 0,
|
||
(DWORD)(LPTSTR)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((LPCTSTR)lpszCLSID, szClass) == 0))
|
||
{
|
||
|
||
//Check for a \Conversion\Readable\Main entry
|
||
lstrcpy((LPTSTR)szFormatKey, (LPTSTR)szClass);
|
||
lstrcat((LPTSTR)szFormatKey, (LPTSTR) TEXT("\\Conversion\\Readable\\Main"));
|
||
|
||
dw=OLEUI_CCHKEYMAX_SIZE;
|
||
|
||
// Check to see if this class can read the original class
|
||
// format. If it can, add the string to the listbox as
|
||
// CONVERT_LIST.
|
||
|
||
lRet=RegQueryValue(hKey, (LPCTSTR)szFormatKey, (LPTSTR)szFormat, (LPDWORD)&dw);
|
||
|
||
if ( ((LONG)ERROR_SUCCESS==lRet)
|
||
&& (FormatIncluded((LPTSTR)szFormat, wFormat)) )
|
||
{
|
||
|
||
|
||
dw=OLEUI_CCHKEYMAX_SIZE;
|
||
lRet=RegQueryValue(hKey, (LPCTSTR)szClass, (LPTSTR)szHRClassName, (LPDWORD)&dw);
|
||
|
||
if ((LONG)ERROR_SUCCESS==lRet)
|
||
{
|
||
lstrcat((LPTSTR)szHRClassName, (LPTSTR) TEXT("\t"));
|
||
|
||
// only add if not already in list
|
||
if (LB_ERR==SendMessage(hListInvisible,LB_FINDSTRING, 0,
|
||
(LPARAM)(LPSTR)szHRClassName)) {
|
||
lstrcat((LPTSTR)szHRClassName, szClass);
|
||
SendMessage(hListInvisible, LB_ADDSTRING, 0,
|
||
(DWORD)(LPTSTR)szHRClassName);
|
||
}
|
||
} // end if
|
||
|
||
} // end if
|
||
} // end else
|
||
Next:
|
||
//Continue with the next key.
|
||
lRet=RegEnumKey(hKey, cStrings++, (LPTSTR)szClass, OLEUI_CCHKEYMAX_SIZE);
|
||
|
||
} // end while
|
||
|
||
// If the original class isn't already in the list, add it.
|
||
|
||
lstrcpy((LPTSTR)szHRClassName, *lplpszCurrentClass);
|
||
lstrcat((LPTSTR)szHRClassName, (LPTSTR) TEXT("\t"));
|
||
|
||
lRet = SendMessage(hList, LB_FINDSTRING, (WPARAM)-1, (LPARAM)(LPTSTR)szHRClassName);
|
||
|
||
// only add it if it's not there already.
|
||
if (LB_ERR == lRet) {
|
||
lstrcat((LPTSTR)szHRClassName, lpszCLSID);
|
||
SendMessage(hList, LB_ADDSTRING, 0, (LPARAM)(LPTSTR)szHRClassName);
|
||
}
|
||
|
||
lRet = SendMessage(hListInvisible, LB_FINDSTRING, (WPARAM)-1, (LPARAM)(LPTSTR)szHRClassName);
|
||
|
||
// only add it if it's not there already.
|
||
if (LB_ERR == lRet)
|
||
SendMessage(hListInvisible, LB_ADDSTRING, 0, (LPARAM)(LPTSTR)szHRClassName);
|
||
|
||
// Free the string we got from StringFromCLSID.
|
||
// OLE2NOTE: StringFromCLSID uses your IMalloc to alloc a
|
||
// string, so you need to be sure to free the string you
|
||
// get back, otherwise you'll have leaky memory.
|
||
|
||
OleStdFreeString(lpszCLSID, NULL);
|
||
|
||
RegCloseKey(hKey);
|
||
|
||
return cStrings;
|
||
}
|
||
|
||
|
||
/*
|
||
* 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
|
||
)
|
||
{
|
||
|
||
DWORD dw;
|
||
UINT cStrings=0;
|
||
HKEY hKey;
|
||
LONG lRet;
|
||
TCHAR szFormatKey[OLEUI_CCHKEYMAX];
|
||
TCHAR szClass[OLEUI_CCHKEYMAX];
|
||
TCHAR szFormat[OLEUI_CCHKEYMAX];
|
||
TCHAR szHRClassName[OLEUI_CCHKEYMAX];
|
||
BOOL fEnableConvert = FALSE;
|
||
|
||
LPTSTR lpszCLSID;
|
||
|
||
//Open up the root key.
|
||
lRet=RegOpenKey(HKEY_CLASSES_ROOT, "CLSID", (HKEY FAR *)&hKey);
|
||
|
||
if ((LONG)ERROR_SUCCESS!=lRet)
|
||
return FALSE;
|
||
|
||
// Get the class name of the original class.
|
||
StringFromCLSIDA(rClsid, &lpszCLSID);
|
||
|
||
// 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.
|
||
|
||
cStrings=0;
|
||
lRet=RegEnumKey(hKey, cStrings++, szClass, OLEUI_CCHKEYMAX_SIZE);
|
||
|
||
while ((LONG)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((LPTSTR)szFormatKey, (LPTSTR)szClass);
|
||
lstrcat((LPTSTR)szFormatKey, (LPTSTR) TEXT("\\Conversion\\Readwritable\\Main"));
|
||
|
||
dw=OLEUI_CCHKEYMAX_SIZE;
|
||
|
||
lRet=RegQueryValue(hKey, (LPCTSTR)szFormatKey, (LPTSTR)szFormat, (LONG FAR *)&dw);
|
||
|
||
if ( (LONG)ERROR_SUCCESS != lRet)
|
||
{
|
||
// Try \\DataFormats\DefaultFile too
|
||
|
||
lstrcpy((LPTSTR)szFormatKey, (LPTSTR)szClass);
|
||
lstrcat((LPTSTR)szFormatKey, (LPTSTR) TEXT("\\DataFormats\\DefaultFile"));
|
||
|
||
dw=OLEUI_CCHKEYMAX_SIZE;
|
||
|
||
lRet=RegQueryValue(hKey, (LPCTSTR)szFormatKey, (LPTSTR)szFormat, (LONG FAR *)&dw);
|
||
}
|
||
|
||
|
||
if ( ((LONG)ERROR_SUCCESS==lRet)
|
||
&& (FormatIncluded((LPTSTR)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, (LPCTSTR)szClass, (LPTSTR)szHRClassName, (LPDWORD)&dw);
|
||
|
||
if ((LONG)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((LPTSTR)lpszCLSID, (LPTSTR)szClass)== 0))
|
||
{
|
||
|
||
//Check for a \Conversion\Readable\Main entry
|
||
lstrcpy((LPTSTR)szFormatKey, (LPTSTR)szClass);
|
||
lstrcat((LPTSTR)szFormatKey, (LPTSTR) TEXT("\\Conversion\\Readable\\Main"));
|
||
|
||
dw=OLEUI_CCHKEYMAX_SIZE;
|
||
|
||
// Check to see if this class can read the original class
|
||
// format. If it can, add the string to the listbox as
|
||
// CONVERT_LIST.
|
||
|
||
lRet=RegQueryValue(hKey, (LPTSTR)szFormatKey, (LPTSTR)szFormat, (LPDWORD)&dw);
|
||
|
||
if ( ((LONG)ERROR_SUCCESS==lRet)
|
||
&& (FormatIncluded((LPTSTR)szFormat, wFormat)) )
|
||
{
|
||
|
||
|
||
dw=OLEUI_CCHKEYMAX_SIZE;
|
||
lRet=RegQueryValue(hKey, (LPTSTR)szClass, (LPTSTR)szHRClassName, (LPDWORD)&dw);
|
||
|
||
if ((LONG)ERROR_SUCCESS==lRet)
|
||
{
|
||
|
||
fEnableConvert = TRUE;
|
||
break; // STOP -- found one!
|
||
} // end if
|
||
|
||
} // end if
|
||
} // end else
|
||
next:
|
||
//Continue with the next key.
|
||
lRet=RegEnumKey(hKey, cStrings++, (LPTSTR)szClass, OLEUI_CCHKEYMAX_SIZE);
|
||
|
||
} // end while
|
||
|
||
// Free the string we got from StringFromCLSID.
|
||
// OLE2NOTE: StringFromCLSID uses your IMalloc to alloc a
|
||
// string, so you need to be sure to free the string you
|
||
// get back, otherwise you'll have leaky memory.
|
||
|
||
OleStdFreeString(lpszCLSID, NULL);
|
||
|
||
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)
|
||
{
|
||
|
||
LPTSTR lpToken;
|
||
TCHAR seps[] = TEXT(",");
|
||
static TCHAR szFormat[255]; // max size of atom (what GetClipboardName returns)
|
||
|
||
|
||
if (wFormat < 0xC000) // RegisterClipboardFormat returns values
|
||
{
|
||
char szTemp[11];
|
||
|
||
_itoa(wFormat, szTemp, 10); // between 0xC000 and 0xFFFF.
|
||
|
||
#ifdef UNICODE
|
||
mbstowcs(szFormat, szTemp, 11);
|
||
#else
|
||
strncpy(szFormat, szTemp, 11);
|
||
#endif
|
||
|
||
}
|
||
|
||
else
|
||
GetClipboardFormatName(wFormat, szFormat, 255);
|
||
|
||
lpToken = (LPTSTR)_fstrtok(szStringToSearch, seps);
|
||
|
||
while (lpToken != NULL)
|
||
{
|
||
|
||
if (0 ==lstrcmpi(lpToken, szFormat))
|
||
return TRUE;
|
||
|
||
else
|
||
lpToken = (LPTSTR)_fstrtok(NULL, seps);
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
/*
|
||
* UpdateCVClassIcon
|
||
*
|
||
* 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
|
||
*/
|
||
|
||
void UpdateCVClassIcon(HWND hDlg, LPCONVERT lpCV, HWND hList)
|
||
{
|
||
UINT iSel;
|
||
DWORD cb;
|
||
HGLOBAL hMem;
|
||
LPTSTR pszName, pszCLSID;
|
||
CLSID clsid;
|
||
HICON hIcon, hOldIcon;
|
||
UINT cch, uWrapIndex;
|
||
RECT LabelRect;
|
||
TCHAR szLabel[OLEUI_CCHLABELMAX];
|
||
LPTSTR lpszLabel = szLabel;
|
||
HFONT hFont;
|
||
HWND hLabel1;
|
||
|
||
/*
|
||
* When we change object type selection, get the new icon for that
|
||
* type into our structure and update it in the display.
|
||
*/
|
||
|
||
iSel=(UINT)SendMessage(hList, LB_GETCURSEL, 0, 0L);
|
||
|
||
if (LB_ERR==(INT)iSel)
|
||
return;
|
||
|
||
//Allocate a string to hold the entire listbox string
|
||
cb=SendMessage(hList, LB_GETTEXTLEN, iSel, 0L);
|
||
|
||
hMem=GlobalAlloc(GHND, cb+1);
|
||
|
||
if (NULL==hMem)
|
||
return;
|
||
|
||
pszName=GlobalLock(hMem);
|
||
|
||
// Get whole string
|
||
SendMessage(hList, LB_GETTEXT, iSel, (LONG)pszName);
|
||
|
||
// Set pointer to CLSID (string)
|
||
pszCLSID = PointerToNthField(pszName, 2, TEXT('\t'));
|
||
|
||
//Create the class ID with this string.
|
||
CLSIDFromStringA(pszCLSID, &clsid);
|
||
|
||
hIcon = HIconAndSourceFromClass(&clsid, (LPTSTR)(lpCV->lpszIconSource), &(lpCV->IconIndex));
|
||
|
||
if (NULL == hIcon) // Use Vanilla Document
|
||
{
|
||
lstrcpy((LPTSTR)(lpCV->lpszIconSource), (LPTSTR)szOLE2DLL);
|
||
lpCV->IconIndex = 0; // 1st icon in OLE2.DLL
|
||
hIcon = ExtractIcon(ghInst,
|
||
(LPTSTR)(lpCV->lpszIconSource),
|
||
lpCV->IconIndex);
|
||
}
|
||
|
||
//Replace the current display with this new one.
|
||
hOldIcon = (HICON)SendDlgItemMessage(hDlg, IDCV_ICON, STM_SETICON, (WPARAM)hIcon, 0L);
|
||
|
||
hLabel1 = GetDlgItem(hDlg, IDCV_ICONLABEL1);
|
||
|
||
GetWindowRect(hLabel1, &LabelRect);
|
||
|
||
// Get the label
|
||
if (lpCV->lpOCV->lpszDefLabel) {
|
||
// width is used as 1.5 times width of icon window
|
||
lpszLabel = ChopText(hLabel1, ((LabelRect.right-LabelRect.left)*3)/2, (LPTSTR)lpCV->lpOCV->lpszDefLabel);
|
||
LSTRCPYN(szLabel, lpCV->lpOCV->lpszDefLabel, sizeof(szLabel)/sizeof(TCHAR));
|
||
} else {
|
||
if ((cch = OleStdGetAuxUserType(&clsid, AUXUSERTYPE_SHORTNAME,
|
||
(LPTSTR)szLabel, OLEUI_CCHLABELMAX_SIZE, NULL)) == 0) {
|
||
// If we can't get the AuxUserType2, then try the long name
|
||
if ((cch = OleStdGetUserTypeOfClass(&clsid, (LPTSTR)szLabel,
|
||
OLEUI_CCHKEYMAX_SIZE, NULL)) == 0) {
|
||
// last resort; use "Document" as label
|
||
LoadString(ghInst,IDS_DEFICONLABEL,(LPTSTR)szLabel,OLEUI_CCHLABELMAX);
|
||
cch = lstrlen((LPCTSTR)szLabel);
|
||
}
|
||
}
|
||
}
|
||
|
||
hFont = (HFONT)SendMessage(hLabel1, WM_GETFONT, 0, 0L);
|
||
|
||
// Figure out where to split the label
|
||
uWrapIndex = OleStdIconLabelTextOut(NULL, hFont, 0, 0, 0, &LabelRect, (LPTSTR)lpszLabel, cch, NULL);
|
||
|
||
if (0 == uWrapIndex)
|
||
{
|
||
SendMessage(hLabel1, WM_SETTEXT, 0, (LPARAM)(LPTSTR)lpszLabel);
|
||
SendDlgItemMessage(hDlg, IDCV_ICONLABEL2, WM_SETTEXT, 0, (LPARAM)(LPTSTR)"");
|
||
}
|
||
else
|
||
{
|
||
TCHAR chKeep;
|
||
LPTSTR lpszSecondLine;
|
||
|
||
chKeep = szLabel[uWrapIndex];
|
||
lpszLabel[uWrapIndex] = TEXT('\0');
|
||
|
||
SendMessage(hLabel1, WM_SETTEXT, 0, (LPARAM)(LPTSTR)lpszLabel);
|
||
|
||
lpszLabel[uWrapIndex] = chKeep;
|
||
lpszSecondLine = lpszLabel + uWrapIndex;
|
||
|
||
SendDlgItemMessage(hDlg, IDCV_ICONLABEL2, WM_SETTEXT, 0, (LPARAM)lpszSecondLine);
|
||
}
|
||
|
||
// get rid of the old icon
|
||
if ((HICON)NULL != hOldIcon)
|
||
DestroyIcon(hOldIcon);
|
||
|
||
GlobalUnlock(hMem);
|
||
GlobalFree(hMem);
|
||
return;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
BOOL IsValidClassID(CLSID cID)
|
||
{
|
||
if (0 == _fmemcmp(&cID, &CLSID_NULL, sizeof(CLSID))) // if (CLSID_NULL == cID)
|
||
return FALSE;
|
||
else
|
||
return TRUE;
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* 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)
|
||
{
|
||
LPTSTR pszT, // temp
|
||
lpszOutput, // text sent in SetDlgItemText
|
||
lpszDefObj, // string containing default object class
|
||
lpszSelObj, // string containing selected object class
|
||
lpszString; // stirng we get from loadstring
|
||
|
||
UINT i, cch;
|
||
HGLOBAL hMem;
|
||
|
||
HWND hList; // handle to listbox (so we can just use SendMsg i
|
||
// instead of SendDlgItemMsg).
|
||
|
||
|
||
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.
|
||
*/
|
||
i=(UINT)SendMessage(hList, LB_GETCURSEL, 0, 0L);
|
||
|
||
cch=512+(UINT)SendMessage(hList, LB_GETTEXTLEN, i, 0L);
|
||
|
||
hMem=GlobalAlloc(GHND, (DWORD)(4*cch));
|
||
|
||
if (NULL==hMem)
|
||
return;
|
||
|
||
lpszOutput = (LPTSTR)GlobalLock(hMem);
|
||
lpszSelObj = lpszOutput + cch;
|
||
lpszDefObj = lpszSelObj + cch;
|
||
lpszString = lpszDefObj + cch;
|
||
|
||
// Get selected object and null terminate human-readable name (1st field).
|
||
SendMessage(hList, LB_GETTEXT, i, (LONG)lpszSelObj);
|
||
|
||
pszT = PointerToNthField(lpszSelObj, 2, TEXT('\t'));
|
||
|
||
#ifdef WIN32
|
||
// AnsiPrev is obsolete in Win32
|
||
pszT = CharPrev((LPCTSTR) lpszSelObj, (LPCTSTR) pszT);
|
||
#else
|
||
pszT = AnsiPrev((LPCTSTR) lpszSelObj, (LPCTSTR) pszT);
|
||
#endif
|
||
|
||
*pszT = TEXT('\0');
|
||
|
||
// Get default object
|
||
|
||
GetDlgItemText(hDlg, IDCV_OBJECTTYPE, lpszDefObj, 512);
|
||
|
||
|
||
//Default is an empty string.
|
||
*lpszOutput=0;
|
||
|
||
|
||
if (lpCV->dwFlags & CF_SELECTCONVERTTO)
|
||
{
|
||
|
||
if (lpCV->lpOCV->fIsLinkedObject) // working with linked object
|
||
LoadString(ghInst, IDS_CVRESULTCONVERTLINK, lpszOutput, cch);
|
||
|
||
else
|
||
{
|
||
// converting to a new class
|
||
if (0 !=lstrcmp(lpszDefObj, lpszSelObj))
|
||
{
|
||
if (0 != LoadString(ghInst, IDS_CVRESULTCONVERTTO, lpszString, cch))
|
||
wsprintf(lpszOutput, lpszString, lpszDefObj, lpszSelObj);
|
||
|
||
}
|
||
else // converting to the same class (no conversion)
|
||
{
|
||
|
||
if (0 != LoadString(ghInst, IDS_CVRESULTNOCHANGE, lpszString, cch))
|
||
wsprintf(lpszOutput, lpszString, lpszDefObj);
|
||
}
|
||
|
||
}
|
||
|
||
if (lpCV->dvAspect == DVASPECT_ICON) // Display as icon is checked
|
||
{
|
||
if (0 != LoadString(ghInst, IDS_CVRESULTDISPLAYASICON, lpszString, cch))
|
||
lstrcat(lpszOutput, lpszString);
|
||
}
|
||
}
|
||
|
||
if (lpCV->dwFlags & CF_SELECTACTIVATEAS)
|
||
{
|
||
|
||
if (0!=LoadString(ghInst, IDS_CVRESULTACTIVATEAS, lpszString, cch))
|
||
wsprintf(lpszOutput, lpszString, lpszDefObj, lpszSelObj);
|
||
|
||
// activating as a new class
|
||
if (0 !=lstrcmp(lpszDefObj, lpszSelObj))
|
||
{
|
||
if (0!=LoadString(ghInst, 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, IDCV_RESULTTEXT, lpszOutput);
|
||
|
||
GlobalUnlock(hMem);
|
||
GlobalFree(hMem);
|
||
return;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/*
|
||
* 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)
|
||
{
|
||
|
||
LPMALLOC pIMalloc;
|
||
|
||
|
||
// Free our strings. Zero out the user type name string
|
||
// the the calling app doesn't free to it.
|
||
|
||
if (NOERROR == CoGetMalloc(MEMCTX_TASK, &pIMalloc))
|
||
{
|
||
pIMalloc->lpVtbl->Free(pIMalloc, (LPVOID)lpCV->lpszConvertDefault);
|
||
pIMalloc->lpVtbl->Free(pIMalloc, (LPVOID)lpCV->lpszActivateDefault);
|
||
pIMalloc->lpVtbl->Free(pIMalloc, (LPVOID)lpCV->lpszIconSource);
|
||
if (lpCV->lpOCV->lpszUserType) {
|
||
pIMalloc->lpVtbl->Free(pIMalloc,(LPVOID)lpCV->lpOCV->lpszUserType);
|
||
lpCV->lpOCV->lpszUserType = NULL;
|
||
}
|
||
if (lpCV->lpOCV->lpszDefLabel) {
|
||
pIMalloc->lpVtbl->Free(pIMalloc,(LPVOID)lpCV->lpOCV->lpszDefLabel);
|
||
lpCV->lpOCV->lpszDefLabel = NULL;
|
||
}
|
||
|
||
pIMalloc->lpVtbl->Release(pIMalloc);
|
||
}
|
||
|
||
return;
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
/*
|
||
* 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)
|
||
{
|
||
|
||
RECT Rect1, Rect2;
|
||
|
||
|
||
GetWindowRect(hWnd1, &Rect1);
|
||
GetWindowRect(hWnd2, &Rect2);
|
||
|
||
ScreenToClient(hDlg, (LPPOINT)&Rect1.left);
|
||
ScreenToClient(hDlg, (LPPOINT)&Rect1.right);
|
||
|
||
ScreenToClient(hDlg, (LPPOINT)&Rect2.left);
|
||
ScreenToClient(hDlg, (LPPOINT)&Rect2.right);
|
||
|
||
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);
|
||
|
||
return;
|
||
|
||
}
|
||
|