2147 lines
67 KiB
C
2147 lines
67 KiB
C
/*
|
||
* links.c
|
||
*
|
||
* Implements the OleUIEditLinks function which invokes the complete
|
||
* Edit Links dialog.
|
||
*
|
||
* Copyright (c)1992 Microsoft Corporation, All Right Reserved
|
||
*/
|
||
|
||
#define STRICT 1
|
||
|
||
#include "ole2ui.h"
|
||
#include "common.h"
|
||
#include "edlinks.h"
|
||
#include "utility.h"
|
||
#include <commdlg.h>
|
||
#include <dlgs.h>
|
||
#include <stdlib.h>
|
||
|
||
OLEDBGDATA
|
||
|
||
/*
|
||
* OleUIEditLinks
|
||
*
|
||
* Purpose:
|
||
* Invokes the standard OLE Edit Links dialog box allowing the user
|
||
* to manipulate ole links (delete, update, change source, etc).
|
||
*
|
||
* Parameters:
|
||
* lpEL LPOLEUIEditLinks 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) OleUIEditLinks(LPOLEUIEDITLINKS lpEL)
|
||
{
|
||
UINT uRet;
|
||
HGLOBAL hMemDlg=NULL;
|
||
|
||
uRet=UStandardValidation((LPOLEUISTANDARD)lpEL, sizeof(OLEUIEDITLINKS)
|
||
, &hMemDlg);
|
||
|
||
if (OLEUI_SUCCESS!=uRet)
|
||
return uRet;
|
||
|
||
/*
|
||
* PERFORM ANY STRUCTURE-SPECIFIC VALIDATION HERE!
|
||
* ON FAILURE:
|
||
* {
|
||
* if (NULL!=hMemDlg)
|
||
* FreeResource(hMemDlg)
|
||
*
|
||
* return OLEUI_<ABBREV>ERR_<ERROR>
|
||
* }
|
||
*/
|
||
|
||
//Now that we've validated everything, we can invoke the dialog.
|
||
uRet=UStandardInvocation(EditLinksDialogProc, (LPOLEUISTANDARD)lpEL,
|
||
hMemDlg, MAKEINTRESOURCE(IDD_EDITLINKS));
|
||
|
||
/*
|
||
* IF YOU ARE CREATING ANYTHING BASED ON THE RESULTS, DO IT HERE.
|
||
*/
|
||
|
||
|
||
return uRet;
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* EditLinksDialogProc
|
||
*
|
||
* Purpose:
|
||
* Implements the OLE Edit Links dialog as invoked through the
|
||
* OleUIEditLinks function.
|
||
*
|
||
* Parameters:
|
||
* Standard
|
||
*
|
||
* Return Value:
|
||
* Standard
|
||
*/
|
||
|
||
BOOL CALLBACK EXPORT EditLinksDialogProc(HWND hDlg, UINT iMsg, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
LPEDITLINKS lpEL = NULL;
|
||
BOOL fHook=FALSE;
|
||
UINT uRet=0;
|
||
HRESULT hErr;
|
||
static int nColPos[3];
|
||
|
||
//Declare Win16/Win32 compatible WM_COMMAND parameters.
|
||
COMMANDPARAMS(wID, wCode, hWndMsg);
|
||
|
||
//This will fail under WM_INITDIALOG, where we allocate it.
|
||
lpEL=(LPEDITLINKS)LpvStandardEntry(hDlg, iMsg, wParam, lParam, &uRet);
|
||
|
||
//If the hook processed the message, we're done.
|
||
if (0!=uRet)
|
||
return (BOOL)uRet;
|
||
|
||
// Process help message from secondary dialog
|
||
if (iMsg == uMsgHelp) {
|
||
|
||
PostMessage(lpEL->lpOEL->hWndOwner, uMsgHelp, wParam, lParam);
|
||
return FALSE;
|
||
|
||
}
|
||
|
||
|
||
//Process the temination message
|
||
if (iMsg==uMsgEndDialog) {
|
||
|
||
//Free any specific allocations before calling StandardCleanup
|
||
|
||
StandardCleanup(lpEL, hDlg);
|
||
|
||
EndDialog(hDlg, wParam);
|
||
return TRUE;
|
||
}
|
||
|
||
switch (iMsg) {
|
||
static int nHeightLine = -1;
|
||
static int nMaxCharWidth = -1;
|
||
|
||
case WM_INITDIALOG:
|
||
{
|
||
RECT rc;
|
||
int nStart;
|
||
|
||
/* calculate the column positions relative to the listbox */
|
||
GetWindowRect(GetDlgItem(hDlg, ID_EL_LINKSLISTBOX), (LPRECT)&rc);
|
||
nStart = rc.left;
|
||
GetWindowRect(GetDlgItem(hDlg, ID_EL_COL1), (LPRECT)&rc);
|
||
nColPos[0] = rc.left - nStart;
|
||
GetWindowRect(GetDlgItem(hDlg, ID_EL_COL2), (LPRECT)&rc);
|
||
nColPos[1] = rc.left - nStart;
|
||
GetWindowRect(GetDlgItem(hDlg, ID_EL_COL3), (LPRECT)&rc);
|
||
nColPos[2] = rc.left - nStart;
|
||
|
||
return FEditLinksInit(hDlg, wParam, lParam);
|
||
}
|
||
break;
|
||
|
||
case WM_MEASUREITEM:
|
||
{
|
||
LPMEASUREITEMSTRUCT lpMIS;
|
||
|
||
lpMIS = (LPMEASUREITEMSTRUCT)lParam;
|
||
|
||
if (nHeightLine == -1) {
|
||
HFONT hFont;
|
||
HDC hDC;
|
||
TEXTMETRIC tm;
|
||
|
||
/* Attempt to get font dialog. If that fails,
|
||
use system font
|
||
*/
|
||
|
||
hFont = (HANDLE)(UINT)SendMessage(hDlg, WM_GETFONT, 0, 0L);
|
||
|
||
if (hFont == NULL)
|
||
hFont = GetStockObject(SYSTEM_FONT);
|
||
|
||
hDC = GetDC(hDlg);
|
||
hFont = SelectObject(hDC, hFont);
|
||
|
||
GetTextMetrics(hDC, &tm);
|
||
nHeightLine = tm.tmHeight;
|
||
nMaxCharWidth = tm.tmMaxCharWidth;
|
||
|
||
ReleaseDC(hDlg, hDC);
|
||
}
|
||
|
||
lpMIS->itemHeight = nHeightLine;
|
||
}
|
||
break;
|
||
|
||
case WM_DRAWITEM:
|
||
{
|
||
LPDRAWITEMSTRUCT lpDIS;
|
||
COLORREF crText;
|
||
LPLINKINFO lpLI;
|
||
HBRUSH hbr;
|
||
int nOldBkMode;
|
||
TCHAR tsz[OLEUI_CCHPATHMAX];
|
||
LPTSTR lpsz;
|
||
RECT rcClip;
|
||
|
||
lpDIS = (LPDRAWITEMSTRUCT)lParam;
|
||
lpLI = (LPLINKINFO)lpDIS->itemData;
|
||
|
||
if ((int)lpDIS->itemID < 0)
|
||
break;
|
||
|
||
if ((ODA_DRAWENTIRE | ODA_SELECT) & lpDIS->itemAction) {
|
||
|
||
if (ODS_SELECTED & lpDIS->itemState) {
|
||
/*Get proper txt colors */
|
||
crText = SetTextColor(lpDIS->hDC,
|
||
GetSysColor(COLOR_HIGHLIGHTTEXT));
|
||
hbr = CreateSolidBrush(GetSysColor(COLOR_HIGHLIGHT));
|
||
lpLI->fIsSelected = TRUE;
|
||
}
|
||
else {
|
||
hbr = CreateSolidBrush(GetSysColor(COLOR_WINDOW));
|
||
lpLI->fIsSelected = FALSE;
|
||
}
|
||
|
||
FillRect(lpDIS->hDC, &lpDIS->rcItem, hbr);
|
||
DeleteObject(hbr);
|
||
|
||
nOldBkMode = SetBkMode(lpDIS->hDC, TRANSPARENT);
|
||
|
||
if (lpLI->lpszDisplayName) {
|
||
lstrcpy((LPTSTR)tsz, lpLI->lpszDisplayName);
|
||
lpsz = ChopText(
|
||
lpDIS->hwndItem,
|
||
nColPos[1] - nColPos[0]
|
||
- (nMaxCharWidth > 0 ? nMaxCharWidth : 5),
|
||
tsz
|
||
);
|
||
rcClip.left = lpDIS->rcItem.left + nColPos[0];
|
||
rcClip.top = lpDIS->rcItem.top;
|
||
rcClip.right = lpDIS->rcItem.left + nColPos[1]
|
||
- (nMaxCharWidth > 0 ? nMaxCharWidth : 5);
|
||
rcClip.bottom = lpDIS->rcItem.bottom;
|
||
ExtTextOut(
|
||
lpDIS->hDC,
|
||
rcClip.left,
|
||
rcClip.top,
|
||
ETO_CLIPPED,
|
||
(LPRECT)&rcClip,
|
||
lpsz,
|
||
lstrlen(lpsz),
|
||
NULL
|
||
);
|
||
}
|
||
if (lpLI->lpszShortLinkType) {
|
||
rcClip.left = lpDIS->rcItem.left + nColPos[1];
|
||
rcClip.top = lpDIS->rcItem.top;
|
||
rcClip.right = lpDIS->rcItem.left + nColPos[2]
|
||
- (nMaxCharWidth > 0 ? nMaxCharWidth : 5);
|
||
|
||
rcClip.bottom = lpDIS->rcItem.bottom;
|
||
ExtTextOut(
|
||
lpDIS->hDC,
|
||
rcClip.left,
|
||
rcClip.top,
|
||
ETO_CLIPPED,
|
||
(LPRECT)&rcClip,
|
||
lpLI->lpszShortLinkType,
|
||
lstrlen(lpLI->lpszShortLinkType),
|
||
NULL
|
||
);
|
||
}
|
||
if (lpLI->lpszAMX) {
|
||
rcClip.left = lpDIS->rcItem.left + nColPos[2];
|
||
rcClip.top = lpDIS->rcItem.top;
|
||
rcClip.right = lpDIS->rcItem.right;
|
||
rcClip.bottom = lpDIS->rcItem.bottom;
|
||
ExtTextOut(
|
||
lpDIS->hDC,
|
||
rcClip.left,
|
||
rcClip.top,
|
||
ETO_CLIPPED,
|
||
(LPRECT)&rcClip,
|
||
lpLI->lpszAMX,
|
||
lstrlen(lpLI->lpszAMX),
|
||
NULL
|
||
);
|
||
}
|
||
|
||
SetBkMode(lpDIS->hDC, nOldBkMode);
|
||
|
||
// restore orig colors if we changed them
|
||
if (ODS_SELECTED & lpDIS->itemState)
|
||
SetTextColor(lpDIS->hDC, crText);
|
||
|
||
}
|
||
|
||
InitControls(hDlg, lpEL);
|
||
|
||
if (ODA_FOCUS & lpDIS->itemAction)
|
||
DrawFocusRect(lpDIS->hDC, &lpDIS->rcItem);
|
||
|
||
}
|
||
return TRUE;
|
||
|
||
|
||
case WM_DELETEITEM:
|
||
{
|
||
UINT idCtl;
|
||
LPDELETEITEMSTRUCT lpDIS;
|
||
LPLINKINFO lpLI;
|
||
|
||
lpDIS = (LPDELETEITEMSTRUCT)lParam;
|
||
idCtl = wParam;
|
||
lpLI = (LPLINKINFO)lpDIS->itemData;
|
||
|
||
if (lpLI->lpszDisplayName)
|
||
OleStdFree((LPVOID)lpLI->lpszDisplayName);
|
||
if (lpLI->lpszShortLinkType)
|
||
OleStdFree((LPVOID)lpLI->lpszShortLinkType);
|
||
if (lpLI->lpszFullLinkType)
|
||
OleStdFree((LPVOID)lpLI->lpszFullLinkType);
|
||
|
||
/* The ChangeSource processing reuses allocated space for
|
||
** links that have been modified.
|
||
*/
|
||
// Don't free the LINKINFO for the changed links
|
||
if (lpLI->fDontFree)
|
||
lpLI->fDontFree = FALSE;
|
||
else {
|
||
if (lpLI->lpszAMX)
|
||
OleStdFree((LPVOID)lpLI->lpszAMX);
|
||
OleStdFree((LPVOID)lpLI);
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
case WM_COMPAREITEM:
|
||
{
|
||
LPCOMPAREITEMSTRUCT lpCIS = (LPCOMPAREITEMSTRUCT)lParam;
|
||
LPLINKINFO lpLI1 = (LPLINKINFO)lpCIS->itemData1;
|
||
LPLINKINFO lpLI2 = (LPLINKINFO)lpCIS->itemData2;
|
||
|
||
// Sort list entries by DisplayName
|
||
return lstrcmp(lpLI1->lpszDisplayName,lpLI2->lpszDisplayName);
|
||
}
|
||
|
||
case WM_COMMAND:
|
||
switch (wID) {
|
||
|
||
case ID_EL_CHANGESOURCE:
|
||
{
|
||
BOOL fRet = FALSE;
|
||
|
||
/* This will bring up the file open dlg with one
|
||
edit field containing the whole link name. The file part
|
||
will (eventually) be highlighted to indicate where the
|
||
file part is. We need to hook on OK here to be able to
|
||
send the changed string to the Parse function */
|
||
|
||
fRet = Container_ChangeSource(hDlg, lpEL);
|
||
if (!fRet)
|
||
PopupMessage(hDlg, IDS_LINKS, IDS_FAILED,
|
||
MB_ICONEXCLAMATION | MB_OK);
|
||
InitControls(hDlg, lpEL);
|
||
}
|
||
break;
|
||
|
||
case ID_EL_AUTOMATIC:
|
||
{
|
||
/* This is available for single or multi-select. There is
|
||
a flag in the structure that is set initially indicating
|
||
whether the link is auto or manual so that we need not
|
||
query the link each time we want to find out.
|
||
|
||
This command will make the link automatic if not already.
|
||
It will have no effect on links already set to auto.
|
||
*/
|
||
// turn the button ON
|
||
|
||
CheckDlgButton(hDlg, ID_EL_AUTOMATIC, 1);
|
||
CheckDlgButton(hDlg, ID_EL_MANUAL, 0);
|
||
|
||
hErr = Container_AutomaticManual(hDlg, TRUE, lpEL);
|
||
if (hErr != NOERROR)
|
||
PopupMessage(hDlg, IDS_LINKS, IDS_FAILED,
|
||
MB_ICONEXCLAMATION | MB_OK);
|
||
|
||
InitControls(hDlg, lpEL);
|
||
}
|
||
break;
|
||
|
||
case ID_EL_MANUAL:
|
||
{
|
||
/* Same rules apply here as they do to auto link.
|
||
Additional note - just because something is changed does
|
||
not mean that it updates at the moment. It simply
|
||
reflects what kind of updating it does while it lives in
|
||
the document.
|
||
*/
|
||
// turn the button ON
|
||
|
||
CheckDlgButton(hDlg, ID_EL_MANUAL, 1);
|
||
CheckDlgButton(hDlg, ID_EL_AUTOMATIC, 0);
|
||
|
||
hErr = Container_AutomaticManual(hDlg, FALSE, lpEL);
|
||
if (hErr != NOERROR)
|
||
PopupMessage(hDlg, IDS_LINKS, IDS_FAILED,
|
||
MB_ICONEXCLAMATION | MB_OK);
|
||
|
||
InitControls(hDlg, lpEL);
|
||
}
|
||
break;
|
||
|
||
case ID_EL_CANCELLINK:
|
||
{
|
||
/* This is Break Link now in the dlg. This sets the
|
||
moniker to null, thereby effectively breaking the link.
|
||
The object still has its data effective at the time of
|
||
breaking, but becomes a static object.
|
||
*****It will need to be deleted from the listbox
|
||
*/
|
||
|
||
CancelLink(hDlg,lpEL);
|
||
InitControls(hDlg, lpEL);
|
||
}
|
||
break;
|
||
|
||
case ID_EL_UPDATENOW:
|
||
{
|
||
/* This forces an immediate update of the selected
|
||
links. This will start the server etc, so this is a very
|
||
expensive operation.
|
||
*/
|
||
hErr = Container_UpdateNow(hDlg, lpEL);
|
||
InitControls(hDlg, lpEL);
|
||
}
|
||
break;
|
||
|
||
case ID_EL_OPENSOURCE:
|
||
{
|
||
/* This will only work on single selection. It makes no
|
||
sense to open multiple sources at the same time, since
|
||
the one opened will try to show itself and become the
|
||
primary operating target, so to speak. Button is greyed
|
||
if multi select.
|
||
|
||
Here we do not add the break because we want to exit the
|
||
dlg in this case.
|
||
*/
|
||
hErr = Container_OpenSource(hDlg, lpEL);
|
||
if (hErr != NOERROR) {
|
||
InitControls(hDlg, lpEL);
|
||
break; // don't close dialog
|
||
}
|
||
} // fall through
|
||
|
||
case ID_EL_CLOSE:
|
||
{
|
||
/* The user is finished with their editing - they now
|
||
return to their container document.
|
||
|
||
*/
|
||
SendMessage(hDlg, uMsgEndDialog, OLEUI_OK, 0L);
|
||
}
|
||
break;
|
||
|
||
case IDCANCEL:
|
||
{
|
||
/* This changes to CLOSE after the user does even ONE
|
||
thing in the dlg. Nothing can really effectively be undone.
|
||
*/
|
||
SendMessage(hDlg, uMsgEndDialog, OLEUI_CANCEL, 0L);
|
||
}
|
||
break;
|
||
|
||
case ID_OLEUIHELP:
|
||
{
|
||
PostMessage(lpEL->lpOEL->hWndOwner, uMsgHelp
|
||
, (WPARAM)hDlg, MAKELPARAM(IDD_EDITLINKS, 0));
|
||
break;
|
||
}
|
||
break;
|
||
}
|
||
break;
|
||
|
||
default:
|
||
{
|
||
if (lpEL && iMsg == lpEL->nChgSrcHelpID) {
|
||
PostMessage(lpEL->lpOEL->hWndOwner, uMsgHelp,
|
||
(WPARAM)hDlg, MAKELPARAM(IDD_CHANGESOURCE, 0));
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
/*
|
||
* FEditLinksInit
|
||
*
|
||
* Purpose:
|
||
* WM_INITIDIALOG handler for the Edit Links 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 FEditLinksInit(HWND hDlg, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
LPEDITLINKS lpEL;
|
||
LPOLEUIEDITLINKS lpOEL;
|
||
HFONT hFont;
|
||
BOOL fDlgItem = FALSE;
|
||
DWORD dwLink = 0;
|
||
ULONG cLinks;
|
||
LPOLEUILINKCONTAINER lpOleUILinkCntr;
|
||
int n;
|
||
HWND hListBox = GetDlgItem(hDlg, ID_EL_LINKSLISTBOX);
|
||
|
||
|
||
|
||
//1. Copy the structure at lParam into our instance memory.
|
||
lpEL = (LPEDITLINKS)LpvStandardInit(hDlg, sizeof(OLEUIEDITLINKS), TRUE,
|
||
&hFont);
|
||
|
||
//PvStandardInit send a termination to us already.
|
||
if (NULL==lpEL)
|
||
return FALSE;
|
||
|
||
lpOEL=(LPOLEUIEDITLINKS)lParam;
|
||
|
||
lpEL->lpOEL=lpOEL;
|
||
|
||
lpOleUILinkCntr = lpEL->lpOEL->lpOleUILinkContainer;
|
||
|
||
cLinks = LoadLinkLB(hListBox, lpOleUILinkCntr);
|
||
if (cLinks < 0)
|
||
return FALSE;
|
||
|
||
fDlgItem = (BOOL)cLinks;
|
||
lpEL->fItemsExist = (BOOL)cLinks;
|
||
|
||
|
||
InitControls(hDlg, lpEL);
|
||
|
||
//Copy other information from lpOEL that we might modify.
|
||
|
||
//2. If we got a font, send it to the necessary controls.
|
||
if (NULL != hFont) {
|
||
// Do this for as many controls as you need it for.
|
||
// SendDlgItemMessage(hDlg, ID_<UFILL>, WM_SETFONT, (WPARAM)hFont, 0L);
|
||
}
|
||
|
||
|
||
//3. Show or hide the help button
|
||
if (!(lpEL->lpOEL->dwFlags & ELF_SHOWHELP))
|
||
StandardShowDlgItem(hDlg, ID_OLEUIHELP, SW_HIDE);
|
||
|
||
/*
|
||
* PERFORM OTHER INITIALIZATION HERE. ON ANY LoadString
|
||
* FAILURE POST OLEUI_MSG_ENDDIALOG WITH OLEUI_ERR_LOADSTRING.
|
||
*/
|
||
|
||
//4. If requested disable UpdateNow button
|
||
if ((lpEL->lpOEL->dwFlags & ELF_DISABLEUPDATENOW))
|
||
StandardShowDlgItem(hDlg, ID_EL_UPDATENOW, SW_HIDE);
|
||
|
||
//5. If requested disable OpenSource button
|
||
if ((lpEL->lpOEL->dwFlags & ELF_DISABLEOPENSOURCE))
|
||
StandardShowDlgItem(hDlg, ID_EL_OPENSOURCE, SW_HIDE);
|
||
|
||
//6. If requested disable UpdateNow button
|
||
if ((lpEL->lpOEL->dwFlags & ELF_DISABLECHANGESOURCE))
|
||
StandardShowDlgItem(hDlg, ID_EL_CHANGESOURCE, SW_HIDE);
|
||
|
||
//7. If requested disable CancelLink button
|
||
if ((lpEL->lpOEL->dwFlags & ELF_DISABLECANCELLINK))
|
||
StandardShowDlgItem(hDlg, ID_EL_CANCELLINK, SW_HIDE);
|
||
|
||
//8. Load 'Close' string used to rename Cancel button
|
||
n = LoadString(ghInst, IDS_CLOSE, lpEL->szClose, sizeof(lpEL->szClose)/sizeof(TCHAR));
|
||
if (!n)
|
||
{
|
||
PostMessage(hDlg, uMsgEndDialog, OLEUI_ERR_LOADSTRING, 0L);
|
||
return FALSE;
|
||
}
|
||
|
||
if (cLinks > 0)
|
||
SetFocus(hListBox);
|
||
else
|
||
SetFocus(GetDlgItem(hDlg, IDCANCEL));
|
||
|
||
lpEL->nChgSrcHelpID = RegisterWindowMessage(HELPMSGSTRING);
|
||
|
||
//n. Call the hook with lCustData in lParam
|
||
UStandardHook(lpEL, hDlg, WM_INITDIALOG, wParam, lpOEL->lCustData);
|
||
|
||
return FALSE;
|
||
}
|
||
|
||
|
||
|
||
/*
|
||
* ChangeSourceHook
|
||
*
|
||
* Purpose:
|
||
* Hooks the ChangeSource dialog to attempt to validate link source changes
|
||
* specified by the user.
|
||
*
|
||
* Parameters:
|
||
* hDlg HWND of the dialog
|
||
* uMsg UINT Message
|
||
* wParam WPARAM of the message
|
||
* lParam LPARAM of the message
|
||
*
|
||
* Return Value:
|
||
* UNIT Zero = Do default processing;
|
||
* Non Zero = Don't do default processing.
|
||
*/
|
||
|
||
UINT CALLBACK EXPORT ChangeSourceHook(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
||
{
|
||
LPCHANGESOURCEHOOKDATA lpCshData = NULL;
|
||
LPLINKINFO lpLI = NULL;
|
||
LPEDITLINKS lpEL = NULL;
|
||
LPOLEUILINKCONTAINER lpOleUILinkCntr;
|
||
HRESULT hErr;
|
||
UINT uRet;
|
||
ULONG ulChEaten;
|
||
HGLOBAL gh;
|
||
|
||
//This will fail under WM_INITDIALOG, where we allocate it.
|
||
if (NULL!=(gh = GetProp(hDlg, STRUCTUREPROP)))
|
||
{
|
||
// gh was locked previously, lock and unlock to get lpv
|
||
lpCshData=(LPCHANGESOURCEHOOKDATA)GlobalLock(gh);
|
||
GlobalUnlock(gh);
|
||
if (lpCshData)
|
||
{
|
||
lpLI = lpCshData->lpOCshData->lpLI;
|
||
lpEL = lpCshData->lpOCshData->lpEL;
|
||
}
|
||
}
|
||
|
||
//Process the temination message
|
||
if (uMsg==uMsgEndDialog)
|
||
{
|
||
if (NULL!=(gh = RemoveProp(hDlg, STRUCTUREPROP)))
|
||
{
|
||
GlobalUnlock(gh);
|
||
GlobalFree(gh);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
// User pressed the OK button
|
||
if (uMsg == uMsgFileOKString) {
|
||
lpOleUILinkCntr = lpEL->lpOEL->lpOleUILinkContainer;
|
||
|
||
/* NOTE: trigger the focus lost of the edit control. This is
|
||
** not necessary if the user click OK with the mouse but is
|
||
** needed when the user just press <Enter>. If the mouse was
|
||
** used, no extra is done as the MODIFY flag of the edit control
|
||
** has been cleared.
|
||
*/
|
||
SendMessage(hDlg, WM_COMMAND, edt1,
|
||
MAKELPARAM(GetDlgItem(hDlg, edt1), EN_KILLFOCUS));
|
||
if (lpCshData->bItemNameStored) {
|
||
lpCshData->nFileLength = lstrlen((LPTSTR)lpCshData->szEdit) -
|
||
lstrlen((LPTSTR)lpCshData->szItemName);
|
||
}
|
||
else {
|
||
lpCshData->nFileLength = lstrlen((LPTSTR)lpCshData->szEdit);
|
||
}
|
||
|
||
// Try to validate link source change
|
||
OLEDBG_BEGIN2(TEXT("IOleUILinkContainer::SetLinkSource called\r\n"));
|
||
hErr = lpOleUILinkCntr->lpVtbl->SetLinkSource(
|
||
lpOleUILinkCntr,
|
||
lpLI->dwLink,
|
||
(LPTSTR)lpCshData->szEdit,
|
||
(ULONG)lpCshData->nFileLength,
|
||
&ulChEaten,
|
||
TRUE
|
||
);
|
||
OLEDBG_END2
|
||
|
||
// Link source change not validated
|
||
if (hErr != NOERROR) {
|
||
uRet =PopupMessage(hDlg, IDS_CHANGESOURCE, IDS_INVALIDSOURCE,
|
||
MB_ICONQUESTION | MB_YESNO);
|
||
|
||
if (uRet == IDYES) {
|
||
/* User wants to correct invalid link. Set the edit
|
||
** control selection to the invalid part of the contents.
|
||
*/
|
||
SetFocus(GetDlgItem(hDlg, edt1));
|
||
SendDlgItemMessage(hDlg, edt1, EM_SETSEL, 0,
|
||
MAKELPARAM(ulChEaten, -1));
|
||
return 1; // Don't close ChangeSource dialog
|
||
}
|
||
else {
|
||
/* User does not want to correct invalid link. So set
|
||
** the link source but don't validate the link.
|
||
*/
|
||
OLEDBG_BEGIN2(TEXT("IOleUILinkContainer::SetLinkSource called\r\n"));
|
||
hErr = lpOleUILinkCntr->lpVtbl->SetLinkSource(
|
||
lpOleUILinkCntr,
|
||
lpLI->dwLink,
|
||
(LPTSTR)lpCshData->szEdit,
|
||
(ULONG)lpCshData->nFileLength,
|
||
&ulChEaten,
|
||
FALSE
|
||
);
|
||
OLEDBG_END2
|
||
lpCshData->fValidLink = FALSE;
|
||
}
|
||
}
|
||
else { // Link source change validated
|
||
lpCshData->fValidLink = TRUE;
|
||
}
|
||
|
||
if (lpCshData->bItemNameStored && lpCshData->bFileNameStored) {
|
||
HWND hListBox = GetDlgItem(lpCshData->lpOfn->hwndOwner, ID_EL_LINKSLISTBOX);
|
||
|
||
DiffPrefix(
|
||
lpLI->lpszDisplayName,
|
||
(LPTSTR)lpCshData->szEdit,
|
||
(TCHAR FAR* FAR*)&lpCshData->lpszFrom,
|
||
(TCHAR FAR* FAR*)&lpCshData->lpszTo
|
||
);
|
||
|
||
/* we keep the strings if there is a difference between the
|
||
** lpszFrom and lpszTo strings AND if the change is only
|
||
** in the file portion otherwise free them and other
|
||
** links won't be compared.
|
||
*/
|
||
if ( (lstrcmp(lpCshData->lpszTo, lpCshData->lpszFrom)==0)
|
||
|| (lstrlen(lpCshData->lpszTo)>lpCshData->nFileLength)) {
|
||
if (lpCshData->lpszFrom) {
|
||
OleStdFree(lpCshData->lpszFrom);
|
||
lpCshData->lpszFrom = NULL;
|
||
}
|
||
if (lpCshData->lpszTo) {
|
||
OleStdFree(lpCshData->lpszTo);
|
||
lpCshData->lpszTo = NULL;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Copy OUT results to original structure
|
||
lpCshData->lpOCshData->lpszFrom = lpCshData->lpszFrom;
|
||
lpCshData->lpOCshData->lpszTo = lpCshData->lpszTo;
|
||
lpCshData->lpOCshData->fValidLink = lpCshData->fValidLink;
|
||
|
||
SendMessage(hDlg, uMsgEndDialog, 0, 0L); // do cleanup
|
||
return 0; // Close ChangeSource dialog
|
||
}
|
||
|
||
switch (uMsg) {
|
||
case WM_INITDIALOG:
|
||
{
|
||
LPOPENFILENAME lpOfn = (LPOPENFILENAME)lParam;
|
||
LPOLEUICHANGESOURCEHOOKDATA lpOCshData =
|
||
(LPOLEUICHANGESOURCEHOOKDATA)lpOfn->lCustData;
|
||
|
||
gh=GlobalAlloc(
|
||
GMEM_MOVEABLE|GMEM_ZEROINIT,sizeof(CHANGESOURCEHOOKDATA));
|
||
if (NULL==gh)
|
||
{
|
||
// Memory allocation error; fail to bring up dialog
|
||
PostMessage(hDlg, uMsgEndDialog, 0, 0L);
|
||
return 0;
|
||
}
|
||
lpCshData = GlobalLock(gh);
|
||
SetProp(hDlg, STRUCTUREPROP, gh);
|
||
|
||
lpCshData->lpOCshData = lpOCshData;
|
||
lpCshData->lpOfn = lpOfn;
|
||
lpLI = lpCshData->lpOCshData->lpLI;
|
||
|
||
lpCshData->bFileNameStored = TRUE;
|
||
lpCshData->bItemNameStored = TRUE;
|
||
lpCshData->nFileLength = (int)lpLI->clenFileName;
|
||
if (lpLI->lpszDisplayName) {
|
||
LSTRCPYN((LPTSTR)lpCshData->szFileName, lpLI->lpszDisplayName,
|
||
lpCshData->nFileLength + 1);
|
||
lstrcpy((LPTSTR)lpCshData->szEdit, lpLI->lpszDisplayName);
|
||
} else {
|
||
lpCshData->szFileName[0] = TEXT('\0');
|
||
lpCshData->szEdit[0] = TEXT('\0');
|
||
}
|
||
if (lpLI->lpszItemName)
|
||
lstrcpy((LPTSTR)lpCshData->szItemName, lpLI->lpszItemName);
|
||
else
|
||
lpCshData->szItemName[0] = TEXT('\0');
|
||
|
||
return 0;
|
||
}
|
||
|
||
case WM_COMMAND:
|
||
|
||
// User pressed the CANCEL button
|
||
if (wParam == IDCANCEL)
|
||
{
|
||
if (lpCshData->lpszFrom)
|
||
{
|
||
OleStdFree(lpCshData->lpszFrom);
|
||
lpCshData->lpszFrom = NULL;
|
||
}
|
||
if (lpCshData->lpszTo)
|
||
{
|
||
OleStdFree(lpCshData->lpszTo);
|
||
lpCshData->lpszTo = NULL;
|
||
}
|
||
|
||
// Copy OUT results to original structure
|
||
lpCshData->lpOCshData->lpszFrom = NULL;
|
||
lpCshData->lpOCshData->lpszTo = NULL;
|
||
lpCshData->lpOCshData->fValidLink = FALSE;
|
||
|
||
SendMessage(hDlg, uMsgEndDialog, 0, 0L); // do cleanup
|
||
return 0; // Close ChangeSource dialog
|
||
}
|
||
|
||
if ((wParam == lst1) &&
|
||
(HIWORD(lParam) == LBN_SELCHANGE)) {
|
||
|
||
int nIndex;
|
||
HWND hListBox = (HWND)LOWORD(lParam);
|
||
static TCHAR szFileNameBuf[OLEUI_CCHPATHMAX];
|
||
static TCHAR szEditBuf[OLEUI_CCHPATHMAX];
|
||
|
||
nIndex = (int)SendMessage(hListBox, LB_GETCURSEL, 0, 0L);
|
||
SendMessage(hListBox, LB_GETTEXT,
|
||
(WPARAM)nIndex, (LPARAM)(LPTSTR)szFileNameBuf);
|
||
|
||
/* need to build the full path filename for the moniker */
|
||
#ifdef WIN32
|
||
CharToOem(szFileNameBuf, szFileNameBuf);
|
||
#else
|
||
AnsiToOem(szFileNameBuf, szFileNameBuf);
|
||
#endif
|
||
_fullpath(szEditBuf, szFileNameBuf, sizeof(szEditBuf));
|
||
#ifdef WIN32
|
||
OemToChar(szEditBuf, szEditBuf);
|
||
#else
|
||
OemToAnsi(szEditBuf, szEditBuf);
|
||
#endif
|
||
|
||
/* convert filename to lower case as it appears in the
|
||
** listbox
|
||
*/
|
||
#ifdef WIN32
|
||
CharLower(szEditBuf);
|
||
#else
|
||
AnsiLower(szEditBuf);
|
||
#endif
|
||
LSTRCPYN((LPTSTR)lpCshData->szEdit, (LPTSTR)szEditBuf,
|
||
sizeof(lpCshData->szEdit) / sizeof(TCHAR));
|
||
LSTRCPYN((LPTSTR)lpCshData->szFileName,
|
||
(LPTSTR)lpCshData->szEdit,
|
||
sizeof(lpCshData->szFileName) / sizeof(TCHAR) );
|
||
lpCshData->nFileLength = lstrlen((LPTSTR)lpCshData->szEdit);
|
||
if (lpCshData->bItemNameStored)
|
||
lstrcat((LPTSTR)lpCshData->szEdit, lpCshData->szItemName);
|
||
|
||
SetDlgItemText(hDlg, edt1, (LPTSTR)lpCshData->szEdit);
|
||
lpCshData->nEditLength = lstrlen((LPTSTR)lpCshData->szEdit);
|
||
lpCshData->bFileNameStored = TRUE;
|
||
|
||
return 1;
|
||
}
|
||
|
||
if ((wParam == lst2) &&
|
||
(HIWORD(lParam) == LBN_SELCHANGE)) {
|
||
|
||
if (lpCshData->bItemNameStored)
|
||
SetDlgItemText(hDlg, edt1, (LPTSTR)lpCshData->szItemName);
|
||
|
||
return 1;
|
||
}
|
||
|
||
if ((wParam == cmb2) &&
|
||
(HIWORD(lParam) == CBN_SELCHANGE)) {
|
||
|
||
if (lpCshData->bItemNameStored)
|
||
SetDlgItemText(hDlg, edt1, (LPTSTR)lpCshData->szItemName);
|
||
|
||
return 1;
|
||
}
|
||
|
||
if (wParam == edt1) {
|
||
HWND hEdit = (HWND)LOWORD(lParam);
|
||
|
||
switch (HIWORD(lParam)) {
|
||
case EN_SETFOCUS:
|
||
SendMessage(hEdit, EM_SETSEL, 0,
|
||
MAKELPARAM(0, lpCshData->nFileLength));
|
||
return 1;
|
||
|
||
case EN_KILLFOCUS:
|
||
if (SendMessage(hEdit, EM_GETMODIFY, 0, 0L)) {
|
||
TCHAR szTmp[OLEUI_CCHPATHMAX];
|
||
int nItemLength = lstrlen((LPTSTR)lpCshData->szItemName);
|
||
|
||
*(LPWORD)lpCshData->szEdit = sizeof(lpCshData->szEdit)/
|
||
sizeof(TCHAR) - 1;
|
||
lpCshData->nEditLength = (int)SendMessage(hEdit,
|
||
EM_GETLINE, 0, (LPARAM)(LPTSTR)lpCshData->szEdit);
|
||
lpCshData->szEdit[lpCshData->nEditLength] = TEXT('\0');
|
||
LSTRCPYN((LPTSTR)szTmp, (LPTSTR)lpCshData->szEdit,
|
||
lpCshData->nFileLength + 1);
|
||
|
||
if (lpCshData->bFileNameStored &&
|
||
!lstrcmp((LPTSTR)lpCshData->szFileName, (LPTSTR)szTmp)) {
|
||
lstrcpy((LPTSTR)lpCshData->szItemName,
|
||
(LPTSTR)lpCshData->szEdit + lpCshData->nFileLength);
|
||
lpCshData->bItemNameStored = TRUE;
|
||
}
|
||
else if (lpCshData->bItemNameStored &&
|
||
!lstrcmp((LPTSTR)lpCshData->szItemName,
|
||
(LPTSTR)lpCshData->szEdit +
|
||
lpCshData->nEditLength -
|
||
nItemLength)) {
|
||
if (lpCshData->nEditLength==nItemLength) {
|
||
|
||
lpCshData->bFileNameStored = FALSE;
|
||
} else {
|
||
LSTRCPYN((LPTSTR)lpCshData->szFileName,
|
||
(LPTSTR)lpCshData->szEdit,
|
||
lpCshData->nEditLength -
|
||
nItemLength+1);
|
||
lpCshData->bFileNameStored = TRUE;
|
||
}
|
||
}
|
||
else {
|
||
lpCshData->bItemNameStored = FALSE;
|
||
lpCshData->bFileNameStored = FALSE;
|
||
}
|
||
|
||
SendMessage(hEdit, EM_SETMODIFY, FALSE, 0L);
|
||
}
|
||
return 0;
|
||
}
|
||
}
|
||
return 0;
|
||
|
||
default:
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
|
||
/*
|
||
* ChangeSource
|
||
*
|
||
* Purpose:
|
||
* Displays the standard GetOpenFileName dialog with a customized template and
|
||
* hook.
|
||
*
|
||
* Parameters:
|
||
* hWndOwner HWND owning the dialog
|
||
* lpszFile LPSTR specifying the initial file. If there is no
|
||
* initial file the first character of this string should
|
||
* be a null.
|
||
* cchFile UINT length of pszFile
|
||
* iFilterString UINT index into the stringtable for the filter string.
|
||
* lpfnBrowseHook COMMDLGHOOKPROC hook to process link source information when user
|
||
* presses OK
|
||
* lpCshData LPCHANGESOURCEHOOKDATA custom data that is accessible to the hook
|
||
*
|
||
* Return Value:
|
||
* BOOL TRUE if the user selected a file and pressed OK.
|
||
* FALSE otherwise, such as on pressing Cancel.
|
||
*/
|
||
|
||
BOOL WINAPI ChangeSource(
|
||
HWND hWndOwner,
|
||
LPTSTR lpszFile,
|
||
UINT cchFile,
|
||
UINT iFilterString,
|
||
COMMDLGHOOKPROC lpfnBrowseHook,
|
||
LPOLEUICHANGESOURCEHOOKDATA lpCshData
|
||
)
|
||
{
|
||
UINT cch;
|
||
TCHAR szFilters[OLEUI_CCHPATHMAX];
|
||
TCHAR szDir[OLEUI_CCHPATHMAX];
|
||
TCHAR szTitle[OLEUI_CCHPATHMAX];
|
||
OPENFILENAME ofn;
|
||
BOOL fStatus;
|
||
LPTSTR lpszFileBuffer;
|
||
|
||
if (NULL==lpszFile || 0==cchFile)
|
||
return FALSE;
|
||
|
||
lpszFileBuffer = (LPTSTR)OleStdMalloc(cchFile * sizeof(TCHAR));
|
||
if (!lpszFileBuffer)
|
||
return FALSE;
|
||
|
||
lstrcpy(lpszFileBuffer, lpszFile);
|
||
|
||
// Get filters
|
||
if (0!=iFilterString)
|
||
cch = LoadString(ghInst, iFilterString, (LPTSTR)szFilters,
|
||
OLEUI_CCHPATHMAX);
|
||
else
|
||
{
|
||
szFilters[0]=0;
|
||
cch=1;
|
||
}
|
||
if (0==cch) {
|
||
fStatus = FALSE;
|
||
goto cleanup;
|
||
}
|
||
|
||
ReplaceCharWithNull(szFilters, szFilters[cch-1]);
|
||
|
||
LSTRCPYN((LPTSTR)szDir, lpszFile, OLEUI_CCHPATHMAX);
|
||
for (cch = lstrlen((LPTSTR)szDir) - 1; cch >= 0; cch--)
|
||
{
|
||
if ((szDir[cch]==TEXT('\\')) || (szDir[cch]==TEXT(':')) || (szDir[cch]==TEXT('/')))
|
||
break;
|
||
}
|
||
if (cch < 0)
|
||
cch = 0;
|
||
|
||
szDir[cch] = TEXT('\0');
|
||
|
||
LoadString(ghInst, IDS_CHANGESOURCE, (LPTSTR)szTitle, OLEUI_CCHPATHMAX);
|
||
_fmemset((LPOPENFILENAME)&ofn, 0, sizeof(ofn));
|
||
ofn.lStructSize = sizeof(ofn);
|
||
ofn.hwndOwner = hWndOwner;
|
||
ofn.lpstrFile = lpszFileBuffer;
|
||
ofn.nMaxFile = cchFile;
|
||
ofn.lpstrFilter = (LPTSTR)szFilters;
|
||
ofn.nFilterIndex = 1;
|
||
ofn.lpstrTitle = (LPTSTR)szTitle;
|
||
ofn.lpstrInitialDir = (LPTSTR)szDir;
|
||
ofn.lpTemplateName = MAKEINTRESOURCE(IDD_FILEOPEN);
|
||
ofn.lpfnHook = lpfnBrowseHook;
|
||
ofn.hInstance = ghInst;
|
||
ofn.lCustData = (LPARAM)lpCshData;
|
||
ofn.Flags = OFN_NOVALIDATE | OFN_HIDEREADONLY |
|
||
OFN_ENABLETEMPLATE | OFN_ENABLEHOOK;
|
||
|
||
// Only show help button if edit links dialog shows it.
|
||
if (lpCshData->lpEL->lpOEL->dwFlags & ELF_SHOWHELP)
|
||
ofn.Flags |= OFN_SHOWHELP;
|
||
|
||
fStatus = GetOpenFileName((LPOPENFILENAME)&ofn);
|
||
|
||
cleanup:
|
||
OleStdFree((LPVOID)lpszFileBuffer);
|
||
return fStatus;
|
||
|
||
}
|
||
|
||
/*
|
||
* Container_ChangeSource
|
||
*
|
||
* Purpose:
|
||
* Tunnel to File Open type dlg and allow user to select new file
|
||
* for file based monikers, OR to change the whole moniker to what
|
||
* the user types into the editable field.
|
||
*
|
||
* Parameters:
|
||
* hDlg HWND of the dialog
|
||
* LPEDITLINKS Pointer to EditLinks structure (contains all nec.
|
||
* info)
|
||
*
|
||
* Return Value:
|
||
* BOOL for now, because we are not using any ole functions
|
||
* to return an HRESULT.
|
||
* HRESULT HRESULT value indicating success or failure of
|
||
* changing the moniker value
|
||
*/
|
||
|
||
BOOL Container_ChangeSource(HWND hDlg, LPEDITLINKS lpEL)
|
||
{
|
||
UINT uRet;
|
||
int cSelItems;
|
||
int FAR* rgIndex;
|
||
int i = 0;
|
||
LPLINKINFO lpLI;
|
||
HWND hListBox = GetDlgItem(hDlg, ID_EL_LINKSLISTBOX);
|
||
LPOLEUILINKCONTAINER lpOleUILinkCntr = lpEL->lpOEL->lpOleUILinkContainer;
|
||
OLEUICHANGESOURCEHOOKDATA cshData; // Data that needs to be accessed
|
||
// by the ChangeSource dialog hook
|
||
|
||
cSelItems = GetSelectedItems(hListBox, &rgIndex);
|
||
|
||
if (cSelItems < 0)
|
||
return FALSE;
|
||
|
||
if (!cSelItems)
|
||
return TRUE;
|
||
|
||
if (!lpEL->fClose) {
|
||
SetWindowText(GetDlgItem(hDlg, IDCANCEL), (LPTSTR)lpEL->szClose);
|
||
lpEL->fClose = TRUE;
|
||
}
|
||
|
||
_fmemset((LPOLEUICHANGESOURCEHOOKDATA)&cshData, 0, sizeof(cshData));
|
||
cshData.cbStruct=sizeof(cshData);
|
||
cshData.hWndOwner=hDlg;
|
||
cshData.lpEL = (LPEDITLINKS)lpEL;
|
||
cshData.lpszFrom = NULL;
|
||
cshData.lpszTo = NULL;
|
||
|
||
for (i = cSelItems-1; i >=0; i--) {
|
||
SendMessage(hListBox, LB_GETTEXT, rgIndex[i],
|
||
(LPARAM) (LPLINKINFO FAR*) &lpLI);
|
||
|
||
uRet = UStandardHook(lpEL, hDlg, uMsgBrowse,
|
||
OLEUI_CCHPATHMAX_SIZE, (LONG)(LPTSTR)lpLI->lpszDisplayName);
|
||
|
||
if (!uRet) {
|
||
cshData.lpLI = lpLI;
|
||
/* Bring up the ChangeSource dialog after hooking it so
|
||
** that the user specified link source is verified
|
||
** when OK is pressed.
|
||
*/
|
||
uRet = (UINT)ChangeSource(hDlg, lpLI->lpszDisplayName,
|
||
OLEUI_CCHPATHMAX, IDS_FILTERS, ChangeSourceHook,
|
||
&cshData);
|
||
}
|
||
|
||
/* If Cancel is pressed in any ChangeSource dialog, stop
|
||
** the ChangeSource processing for all links.
|
||
*/
|
||
if (!uRet) {
|
||
if (rgIndex)
|
||
OleStdFree(rgIndex);
|
||
return TRUE;
|
||
}
|
||
|
||
UpdateLinkLBItem(hListBox, rgIndex[i], lpEL, TRUE);
|
||
|
||
if (cshData.lpszFrom && cshData.lpszTo) {
|
||
ChangeAllLinks(hListBox, lpOleUILinkCntr, cshData.lpszFrom,
|
||
cshData.lpszTo);
|
||
OleStdFree(cshData.lpszFrom);
|
||
OleStdFree(cshData.lpszTo);
|
||
}
|
||
|
||
} // end FOR
|
||
|
||
|
||
if (rgIndex)
|
||
OleStdFree(rgIndex);
|
||
|
||
return TRUE;
|
||
|
||
}
|
||
|
||
|
||
/*
|
||
* Container_AutomaticManual
|
||
*
|
||
* Purpose:
|
||
* To change the selected moniker to manual or automatic update.
|
||
*
|
||
* Parameters:
|
||
* hDlg HWND of the dialog
|
||
* FAutoMan Flag indicating AUTO (TRUE/1) or MANUAL(FALSE/0)
|
||
* LPEDITLINKS Pointer to EditLinks structure (contains all nec.
|
||
* info)
|
||
* * this may change - don't know how the linked list
|
||
* * of multi-selected items will work.
|
||
* Return Value:
|
||
* HRESULT HRESULT value indicating success or failure of
|
||
* changing the moniker value
|
||
*/
|
||
|
||
HRESULT Container_AutomaticManual(HWND hDlg, BOOL fAutoMan, LPEDITLINKS lpEL)
|
||
{
|
||
|
||
HRESULT hErr = NOERROR;
|
||
int cSelItems;
|
||
int FAR* rgIndex;
|
||
int i = 0;
|
||
LPLINKINFO lpLI;
|
||
LPOLEUILINKCONTAINER lpOleUILinkCntr = lpEL->lpOEL->lpOleUILinkContainer;
|
||
HWND hListBox = GetDlgItem(hDlg, ID_EL_LINKSLISTBOX);
|
||
BOOL bUpdate = FALSE;
|
||
|
||
OleDbgAssert(lpOleUILinkCntr);
|
||
|
||
/* Change so looks at flag in structure. Only update those that
|
||
need to be updated. Make sure to change flag if status changes.
|
||
*/
|
||
|
||
cSelItems = GetSelectedItems(hListBox, &rgIndex);
|
||
|
||
if (cSelItems < 0)
|
||
return ResultFromScode(E_FAIL);
|
||
|
||
if (!cSelItems)
|
||
return NOERROR;
|
||
|
||
if (!lpEL->fClose)
|
||
SetDlgItemText(hDlg, IDCANCEL, (LPTSTR)lpEL->szClose);
|
||
|
||
for (i = 0; i < cSelItems; i++) {
|
||
SendMessage(hListBox, LB_GETTEXT, (WPARAM)rgIndex[i],
|
||
(LPARAM) (LPLINKINFO FAR*) &lpLI);
|
||
|
||
if (fAutoMan) { // If switching to AUTOMATIC
|
||
if (!lpLI->fIsAuto) { // Only change MANUAL links
|
||
OLEDBG_BEGIN2(TEXT("IOleUILinkContainer::SetLinkUpdateOptions called\r\n"));
|
||
hErr=lpOleUILinkCntr->lpVtbl->SetLinkUpdateOptions(
|
||
lpOleUILinkCntr,
|
||
lpLI->dwLink,
|
||
OLEUPDATE_ALWAYS
|
||
);
|
||
OLEDBG_END2
|
||
|
||
lpLI->fIsAuto=TRUE;
|
||
lpLI->fIsMarked = TRUE;
|
||
bUpdate = TRUE;
|
||
}
|
||
}
|
||
else { // If switching to MANUAL
|
||
if (lpLI->fIsAuto) { // Only do AUTOMATIC Links
|
||
OLEDBG_BEGIN2(TEXT("IOleUILinkContainer::SetLinkUpdateOptions called\r\n"));
|
||
hErr=lpOleUILinkCntr->lpVtbl->SetLinkUpdateOptions(
|
||
lpOleUILinkCntr,
|
||
lpLI->dwLink,
|
||
OLEUPDATE_ONCALL
|
||
);
|
||
OLEDBG_END2
|
||
|
||
lpLI->fIsAuto = FALSE;
|
||
lpLI->fIsMarked = TRUE;
|
||
bUpdate = TRUE;
|
||
}
|
||
}
|
||
|
||
if (hErr != NOERROR) {
|
||
OleDbgOutHResult(TEXT("WARNING: IOleUILinkContainer::SetLinkUpdateOptions returned"),hErr);
|
||
break;
|
||
}
|
||
|
||
}
|
||
|
||
if (bUpdate)
|
||
RefreshLinkLB(hListBox, lpOleUILinkCntr);
|
||
|
||
if (rgIndex)
|
||
OleStdFree((LPVOID)rgIndex);
|
||
|
||
return hErr;
|
||
}
|
||
|
||
|
||
HRESULT CancelLink(HWND hDlg, LPEDITLINKS lpEL)
|
||
{
|
||
HRESULT hErr;
|
||
LPMONIKER lpmk;
|
||
int cSelItems;
|
||
int FAR* rgIndex;
|
||
int i = 0;
|
||
LPLINKINFO lpLI;
|
||
LPOLEUILINKCONTAINER lpOleUILinkCntr = lpEL->lpOEL->lpOleUILinkContainer;
|
||
HWND hListBox = GetDlgItem(hDlg, ID_EL_LINKSLISTBOX);
|
||
BOOL bUpdate = FALSE;
|
||
|
||
OleDbgAssert(lpOleUILinkCntr);
|
||
|
||
lpmk = NULL;
|
||
|
||
cSelItems = GetSelectedItems(hListBox, &rgIndex);
|
||
|
||
if (cSelItems < 0)
|
||
return ResultFromScode(E_FAIL);
|
||
|
||
if (!cSelItems)
|
||
return NOERROR;
|
||
|
||
if (!lpEL->fClose) {
|
||
SetWindowText(GetDlgItem(hDlg, IDCANCEL), (LPTSTR)lpEL->szClose);
|
||
lpEL->fClose = TRUE;
|
||
}
|
||
|
||
for (i = 0; i < cSelItems; i++) {
|
||
SendMessage(hListBox, LB_GETTEXT, (WPARAM)rgIndex[i],
|
||
(LPARAM)(LPLINKINFO FAR*) &lpLI);
|
||
|
||
OLEDBG_BEGIN2(TEXT("IOleUILinkContainer::CancelLink called\r\n"));
|
||
hErr = lpOleUILinkCntr->lpVtbl->CancelLink(
|
||
lpOleUILinkCntr,
|
||
lpLI->dwLink
|
||
);
|
||
OLEDBG_END2
|
||
|
||
if (hErr != NOERROR) {
|
||
OleDbgOutHResult(TEXT("WARNING: IOleUILinkContainer::CancelLink returned"),hErr);
|
||
lpLI->fIsMarked = TRUE;
|
||
bUpdate = TRUE;
|
||
}
|
||
else
|
||
// Delete links that we make null from listbox
|
||
SendMessage(hListBox, LB_DELETESTRING, (WPARAM) rgIndex[i], 0L);
|
||
|
||
}
|
||
|
||
if (bUpdate)
|
||
RefreshLinkLB(hListBox, lpOleUILinkCntr);
|
||
|
||
if (rgIndex)
|
||
OleStdFree((LPVOID)rgIndex);
|
||
|
||
return hErr;
|
||
|
||
}
|
||
|
||
|
||
/*
|
||
* Container_UpdateNow
|
||
*
|
||
* Purpose:
|
||
* Immediately force an update for all (manual) links
|
||
*
|
||
* Parameters:
|
||
* hDlg HWND of the dialog
|
||
* LPEDITLINKS Pointer to EditLinks structure (contains all nec. info)
|
||
* * this may change - don't know how the linked list
|
||
* * of multi-selected items will work.
|
||
* Return Value:
|
||
* HRESULT HRESULT value indicating success or failure of
|
||
* changing the moniker value
|
||
*/
|
||
|
||
HRESULT Container_UpdateNow(HWND hDlg, LPEDITLINKS lpEL)
|
||
{
|
||
HRESULT hErr;
|
||
LPLINKINFO lpLI;
|
||
int cSelItems;
|
||
int FAR* rgIndex;
|
||
int i = 0;
|
||
LPOLEUILINKCONTAINER lpOleUILinkCntr = lpEL->lpOEL->lpOleUILinkContainer;
|
||
HWND hListBox = GetDlgItem(hDlg, ID_EL_LINKSLISTBOX);
|
||
BOOL bUpdate = FALSE;
|
||
|
||
OleDbgAssert(lpOleUILinkCntr);
|
||
|
||
cSelItems = GetSelectedItems(hListBox, &rgIndex);
|
||
|
||
if (cSelItems < 0)
|
||
return ResultFromScode(E_FAIL);
|
||
|
||
if (!cSelItems)
|
||
return NOERROR;
|
||
|
||
if (!lpEL->fClose) {
|
||
SetWindowText(GetDlgItem(hDlg, IDCANCEL), (LPTSTR)lpEL->szClose);
|
||
lpEL->fClose = TRUE;
|
||
}
|
||
|
||
for (i = 0; i < cSelItems; i++) {
|
||
SendMessage(hListBox, LB_GETTEXT,
|
||
(WPARAM)rgIndex[i], (LPARAM)(LPLINKINFO FAR*)&lpLI);
|
||
|
||
OLEDBG_BEGIN2(TEXT("IOleUILinkContainer::UpdateLink called\r\n"));
|
||
hErr = lpOleUILinkCntr->lpVtbl->UpdateLink(
|
||
lpOleUILinkCntr,
|
||
lpLI->dwLink,
|
||
TRUE,
|
||
FALSE
|
||
);
|
||
OLEDBG_END2
|
||
bUpdate = TRUE;
|
||
lpLI->fIsMarked = TRUE;
|
||
|
||
if (hErr != NOERROR) {
|
||
OleDbgOutHResult(TEXT("WARNING: IOleUILinkContainer::UpdateLink returned"),hErr);
|
||
break;
|
||
}
|
||
|
||
}
|
||
|
||
if (bUpdate)
|
||
RefreshLinkLB(hListBox, lpOleUILinkCntr);
|
||
|
||
if (rgIndex)
|
||
OleStdFree((LPVOID)rgIndex);
|
||
|
||
return hErr;
|
||
|
||
}
|
||
|
||
/*
|
||
* Container_OpenSource
|
||
*
|
||
* Purpose:
|
||
* Immediately force an update for all (manual) links
|
||
*
|
||
* Parameters:
|
||
* hDlg HWND of the dialog
|
||
* LPEDITLINKS Pointer to EditLinks structure (contains all nec.
|
||
* info)
|
||
*
|
||
* Return Value:
|
||
* HRESULT HRESULT value indicating success or failure of
|
||
* changing the moniker value
|
||
*/
|
||
|
||
HRESULT Container_OpenSource(HWND hDlg, LPEDITLINKS lpEL)
|
||
{
|
||
HRESULT hErr;
|
||
int cSelItems;
|
||
int FAR* rgIndex;
|
||
LPLINKINFO lpLI;
|
||
RECT rcPosRect;
|
||
LPOLEUILINKCONTAINER lpOleUILinkCntr = lpEL->lpOEL->lpOleUILinkContainer;
|
||
HWND hListBox = GetDlgItem(hDlg, ID_EL_LINKSLISTBOX);
|
||
|
||
OleDbgAssert(lpOleUILinkCntr);
|
||
|
||
rcPosRect.top = 0;
|
||
rcPosRect.left = 0;
|
||
rcPosRect.right = 0;
|
||
rcPosRect.bottom = 0;
|
||
|
||
cSelItems = GetSelectedItems(hListBox, &rgIndex);
|
||
|
||
if (cSelItems < 0)
|
||
return ResultFromScode(E_FAIL);
|
||
|
||
if (cSelItems != 1) // can't open source for multiple items
|
||
return NOERROR;
|
||
|
||
if (!lpEL->fClose) {
|
||
SetWindowText(GetDlgItem(hDlg, IDCANCEL), (LPTSTR)lpEL->szClose);
|
||
lpEL->fClose = TRUE;
|
||
}
|
||
|
||
SendMessage(hListBox, LB_GETTEXT, (WPARAM)rgIndex[0],
|
||
(LPARAM)(LPLINKINFO FAR*)&lpLI);
|
||
|
||
OLEDBG_BEGIN2(TEXT("IOleUILinkContainer::OpenLinkSource called\r\n"));
|
||
hErr = lpOleUILinkCntr->lpVtbl->OpenLinkSource(
|
||
lpOleUILinkCntr,
|
||
lpLI->dwLink
|
||
);
|
||
OLEDBG_END2
|
||
|
||
UpdateLinkLBItem(hListBox, rgIndex[0], lpEL, TRUE);
|
||
if (hErr != NOERROR)
|
||
OleDbgOutHResult(TEXT("WARNING: IOleUILinkContainer::OpenLinkSource returned"),hErr);
|
||
|
||
if (rgIndex)
|
||
OleStdFree((LPVOID)rgIndex);
|
||
|
||
return hErr;
|
||
}
|
||
|
||
|
||
|
||
/* AddLinkLBItem
|
||
** -------------
|
||
**
|
||
** Add the item pointed to by lpLI to the Link ListBox and return
|
||
** the index of it in the ListBox
|
||
*/
|
||
int AddLinkLBItem(HWND hListBox, LPOLEUILINKCONTAINER lpOleUILinkCntr, LPLINKINFO lpLI, BOOL fGetSelected)
|
||
{
|
||
HRESULT hErr;
|
||
DWORD dwUpdateOpt;
|
||
int nIndex;
|
||
|
||
OleDbgAssert(lpOleUILinkCntr && hListBox && lpLI);
|
||
|
||
lpLI->fDontFree = FALSE;
|
||
|
||
OLEDBG_BEGIN2(TEXT("IOleUILinkContainer::GetLinkSource called\r\n"));
|
||
hErr = lpOleUILinkCntr->lpVtbl->GetLinkSource(
|
||
lpOleUILinkCntr,
|
||
lpLI->dwLink,
|
||
(LPTSTR FAR*)&lpLI->lpszDisplayName,
|
||
(ULONG FAR*)&lpLI->clenFileName,
|
||
(LPTSTR FAR*)&lpLI->lpszFullLinkType,
|
||
(LPTSTR FAR*)&lpLI->lpszShortLinkType,
|
||
(BOOL FAR*)&lpLI->fSourceAvailable,
|
||
fGetSelected ? (BOOL FAR*)&lpLI->fIsSelected : NULL
|
||
);
|
||
OLEDBG_END2
|
||
|
||
if (hErr != NOERROR) {
|
||
OleDbgOutHResult(TEXT("WARNING: IOleUILinkContainer::GetLinkSource returned"),hErr);
|
||
PopupMessage(hListBox, IDS_LINKS, IDS_ERR_GETLINKSOURCE,
|
||
MB_ICONEXCLAMATION | MB_OK);
|
||
|
||
goto cleanup;
|
||
}
|
||
|
||
OLEDBG_BEGIN2(TEXT("IOleUILinkContainer::GetLinkUpdateOptions called\r\n"));
|
||
hErr=lpOleUILinkCntr->lpVtbl->GetLinkUpdateOptions(
|
||
lpOleUILinkCntr,
|
||
lpLI->dwLink,
|
||
(LPDWORD)&dwUpdateOpt
|
||
);
|
||
OLEDBG_END2
|
||
|
||
|
||
if (hErr != NOERROR) {
|
||
OleDbgOutHResult(TEXT("WARNING: IOleUILinkContainer::GetLinkUpdateOptions returned"),hErr);
|
||
PopupMessage(hListBox, IDS_LINKS, IDS_ERR_GETLINKUPDATEOPTIONS,
|
||
MB_ICONEXCLAMATION | MB_OK);
|
||
|
||
goto cleanup;
|
||
}
|
||
|
||
if (lpLI->fSourceAvailable) {
|
||
if (dwUpdateOpt == OLEUPDATE_ALWAYS) {
|
||
lpLI->fIsAuto = TRUE;
|
||
LoadString(ghInst, IDS_LINK_AUTO, lpLI->lpszAMX,
|
||
(int)OleStdGetSize((LPVOID)lpLI->lpszAMX));
|
||
}
|
||
else {
|
||
lpLI->fIsAuto = FALSE;
|
||
LoadString(ghInst, IDS_LINK_MANUAL, lpLI->lpszAMX,
|
||
(int)OleStdGetSize((LPVOID)lpLI->lpszAMX));
|
||
}
|
||
}
|
||
else
|
||
LoadString(ghInst, IDS_LINK_UNKNOWN, lpLI->lpszAMX,
|
||
(int)OleStdGetSize((LPVOID)lpLI->lpszAMX));
|
||
|
||
BreakString(lpLI);
|
||
|
||
nIndex = (int)SendMessage(hListBox, LB_ADDSTRING, (WPARAM)0,
|
||
(LPARAM)(DWORD)lpLI);
|
||
|
||
if (nIndex == LB_ERR) {
|
||
PopupMessage(hListBox, IDS_LINKS, IDS_ERR_ADDSTRING,
|
||
MB_ICONEXCLAMATION | MB_OK);
|
||
|
||
goto cleanup;
|
||
}
|
||
|
||
return nIndex;
|
||
|
||
cleanup:
|
||
if (lpLI->lpszDisplayName)
|
||
OleStdFree((LPVOID)lpLI->lpszDisplayName);
|
||
|
||
if (lpLI->lpszShortLinkType)
|
||
OleStdFree((LPVOID)lpLI->lpszShortLinkType);
|
||
|
||
if (lpLI->lpszFullLinkType)
|
||
OleStdFree((LPVOID)lpLI->lpszFullLinkType);
|
||
|
||
return -1;
|
||
}
|
||
|
||
|
||
/* BreakString
|
||
* -----------
|
||
*
|
||
* Purpose:
|
||
* Break the lpszDisplayName into various parts
|
||
*
|
||
* Parameters:
|
||
* lpLI pointer to LINKINFO structure
|
||
*
|
||
* Returns:
|
||
*
|
||
*/
|
||
VOID BreakString(LPLINKINFO lpLI)
|
||
{
|
||
LPTSTR lpsz;
|
||
|
||
if (!lpLI->clenFileName ||
|
||
(lstrlen(lpLI->lpszDisplayName)==(int)lpLI->clenFileName)) {
|
||
|
||
lpLI->lpszItemName = NULL;
|
||
}
|
||
else {
|
||
lpLI->lpszItemName = lpLI->lpszDisplayName + lpLI->clenFileName;
|
||
}
|
||
|
||
// search from last character of filename
|
||
lpsz = lpLI->lpszDisplayName + lstrlen(lpLI->lpszDisplayName);
|
||
while (lpsz > lpLI->lpszDisplayName) {
|
||
#ifdef WIN32
|
||
// AnsiPrev is obsolete in Win32
|
||
lpsz = CharPrev(lpLI->lpszDisplayName, lpsz);
|
||
#else
|
||
lpsz = AnsiPrev(lpLI->lpszDisplayName, lpsz);
|
||
#endif
|
||
if ((*lpsz == TEXT('\\')) || (*lpsz == TEXT('/')) || (*lpsz == TEXT(':')))
|
||
break;
|
||
}
|
||
|
||
if (lpsz == lpLI->lpszDisplayName)
|
||
lpLI->lpszShortFileName = lpsz;
|
||
else
|
||
#ifdef WIN32
|
||
// AnsiNext is obsolete in Win32
|
||
lpLI->lpszShortFileName = CharNext(lpsz);
|
||
#else
|
||
lpLI->lpszShortFileName = AnsiNext(lpsz);
|
||
#endif
|
||
}
|
||
|
||
|
||
/* GetSelectedItems
|
||
* ----------------
|
||
*
|
||
* Purpose:
|
||
* Retrieve the indices of the selected items in the listbox
|
||
* Note that *lprgIndex needed to be free after using the function
|
||
*
|
||
* Parameters:
|
||
* hListBox window handle of listbox
|
||
* lprgIndex pointer to an integer array to receive the indices
|
||
* must be freed afterwards
|
||
*
|
||
* Returns:
|
||
* number of indices retrieved, -1 if error
|
||
*/
|
||
int GetSelectedItems(HWND hListBox, int FAR* FAR* lprgIndex)
|
||
{
|
||
DWORD cSelItems;
|
||
DWORD cCheckItems;
|
||
|
||
*lprgIndex = NULL;
|
||
|
||
cSelItems = SendMessage(hListBox, LB_GETSELCOUNT, 0, 0L);
|
||
if (cSelItems < 0) // error
|
||
return (int)cSelItems;
|
||
|
||
if (!cSelItems)
|
||
return 0;
|
||
|
||
*lprgIndex = (int FAR*)OleStdMalloc((int)cSelItems * sizeof(int));
|
||
|
||
cCheckItems = SendMessage(hListBox, LB_GETSELITEMS,
|
||
(WPARAM) cSelItems, (LPARAM) (int FAR*) *lprgIndex);
|
||
|
||
if (cCheckItems == cSelItems)
|
||
return (int)cSelItems;
|
||
else {
|
||
if (*lprgIndex)
|
||
OleStdFree((LPVOID)*lprgIndex);
|
||
*lprgIndex = NULL;
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
|
||
/* InitControls
|
||
* ------------
|
||
*
|
||
* Purpose:
|
||
* Initialize the state of the Auto/Manual button, Link source/type
|
||
* static field, etc in the dialogs according to the selection in the
|
||
* listbox
|
||
*
|
||
* Parameters:
|
||
* hDlg handle to the dialog window
|
||
*/
|
||
VOID InitControls(HWND hDlg, LPEDITLINKS lpEL)
|
||
{
|
||
int cSelItems;
|
||
HWND hListBox;
|
||
int i;
|
||
int FAR* rgIndex;
|
||
LPLINKINFO lpLI;
|
||
LPTSTR lpszType = NULL;
|
||
LPTSTR lpszSource = NULL;
|
||
int cAuto = 0;
|
||
int cManual = 0;
|
||
BOOL bSameType = TRUE;
|
||
BOOL bSameSource = TRUE;
|
||
TCHAR tsz[OLEUI_CCHPATHMAX];
|
||
LPTSTR lpsz;
|
||
|
||
|
||
hListBox = GetDlgItem(hDlg, ID_EL_LINKSLISTBOX);
|
||
|
||
cSelItems = GetSelectedItems(hListBox, &rgIndex);
|
||
if (cSelItems < 0)
|
||
return;
|
||
|
||
EnableWindow(GetDlgItem(hDlg, ID_EL_AUTOMATIC), (BOOL)cSelItems);
|
||
EnableWindow(GetDlgItem(hDlg, ID_EL_MANUAL), (BOOL)cSelItems);
|
||
if (lpEL && !(lpEL->lpOEL->dwFlags & ELF_DISABLECANCELLINK))
|
||
EnableWindow(GetDlgItem(hDlg, ID_EL_CANCELLINK), (BOOL)cSelItems);
|
||
if (lpEL && !(lpEL->lpOEL->dwFlags & ELF_DISABLEOPENSOURCE))
|
||
EnableWindow(GetDlgItem(hDlg, ID_EL_OPENSOURCE), cSelItems == 1);
|
||
if (lpEL && !(lpEL->lpOEL->dwFlags & ELF_DISABLECHANGESOURCE))
|
||
EnableWindow(GetDlgItem(hDlg, ID_EL_CHANGESOURCE), cSelItems == 1);
|
||
if (lpEL && !(lpEL->lpOEL->dwFlags & ELF_DISABLEUPDATENOW))
|
||
EnableWindow(GetDlgItem(hDlg, ID_EL_UPDATENOW), (BOOL)cSelItems);
|
||
|
||
for (i = 0; i < cSelItems; i++) {
|
||
SendDlgItemMessage(
|
||
hDlg,
|
||
ID_EL_LINKSLISTBOX,
|
||
LB_GETTEXT,
|
||
(WPARAM)rgIndex[i],
|
||
(LPARAM)(LPLINKINFO FAR*)&lpLI);
|
||
|
||
if (lpszSource && lpLI->lpszDisplayName) {
|
||
if (bSameSource && lstrcmp(lpszSource, lpLI->lpszDisplayName)) {
|
||
bSameSource = FALSE;
|
||
}
|
||
}
|
||
else
|
||
lpszSource = lpLI->lpszDisplayName;
|
||
|
||
if (lpszType && lpLI->lpszFullLinkType) {
|
||
if (bSameType && lstrcmp(lpszType, lpLI->lpszFullLinkType)) {
|
||
bSameType = FALSE;
|
||
}
|
||
}
|
||
else
|
||
lpszType = lpLI->lpszFullLinkType;
|
||
|
||
if (lpLI->fIsAuto)
|
||
cAuto++;
|
||
else
|
||
cManual++;
|
||
}
|
||
|
||
CheckDlgButton(hDlg, ID_EL_AUTOMATIC, cAuto && !cManual);
|
||
CheckDlgButton(hDlg, ID_EL_MANUAL, !cAuto && cManual);
|
||
|
||
/* fill full source in static text box
|
||
** below list
|
||
*/
|
||
if (!bSameSource || !lpszSource)
|
||
lpszSource = szNULL;
|
||
lstrcpy((LPTSTR)tsz, lpszSource);
|
||
lpsz = ChopText(GetDlgItem(hDlg, ID_EL_LINKSOURCE), 0, tsz);
|
||
SetDlgItemText(hDlg, ID_EL_LINKSOURCE, lpsz);
|
||
|
||
/* fill full link type name in static
|
||
** "type" text box
|
||
*/
|
||
if (!bSameType || !lpszType)
|
||
lpszType = szNULL;
|
||
SetDlgItemText(hDlg, ID_EL_LINKTYPE, lpszType);
|
||
|
||
if (rgIndex)
|
||
OleStdFree((LPVOID)rgIndex);
|
||
}
|
||
|
||
|
||
/* UpdateLinkLBItem
|
||
* -----------------
|
||
*
|
||
* Purpose:
|
||
* Update the linkinfo struct in the listbox to reflect the changes
|
||
* made by the last operation. It is done simply by removing the item
|
||
* from the listbox and add it back.
|
||
*
|
||
* Parameters:
|
||
* hListBox handle of listbox
|
||
* nIndex index of listbox item
|
||
* lpEL pointer to editlinks structure
|
||
* bSelect select the item or not after update
|
||
*/
|
||
VOID UpdateLinkLBItem(HWND hListBox, int nIndex, LPEDITLINKS lpEL, BOOL bSelect)
|
||
{
|
||
LPLINKINFO lpLI;
|
||
DWORD dwErr;
|
||
LPOLEUILINKCONTAINER lpOleUILinkCntr;
|
||
|
||
if (!hListBox || (nIndex < 0) || !lpEL)
|
||
return;
|
||
|
||
lpOleUILinkCntr = lpEL->lpOEL->lpOleUILinkContainer;
|
||
|
||
dwErr = SendMessage(hListBox, LB_GETTEXT, nIndex,
|
||
(LPARAM)(LPLINKINFO FAR*) &lpLI);
|
||
|
||
if ((dwErr == LB_ERR) || !lpLI)
|
||
return;
|
||
|
||
/* Don't free the data associated with this listbox item
|
||
** because we are going to reuse the allocated space for
|
||
** the modified link. WM_DELETEITEM processing in the
|
||
** dialog checks this flag before deleting data
|
||
** associcated with list item.
|
||
*/
|
||
lpLI->fDontFree = TRUE;
|
||
SendMessage(hListBox, LB_DELETESTRING, nIndex, 0L);
|
||
|
||
nIndex = AddLinkLBItem(hListBox, lpOleUILinkCntr, lpLI, FALSE);
|
||
if (bSelect) {
|
||
SendMessage(hListBox, LB_SETSEL, (WPARAM)TRUE, MAKELPARAM(nIndex, 0));
|
||
SendMessage(hListBox, LB_SETCARETINDEX, (WPARAM)nIndex, MAKELPARAM(TRUE, 0));
|
||
}
|
||
}
|
||
|
||
|
||
|
||
/* DiffPrefix
|
||
* ----------
|
||
*
|
||
* Purpose:
|
||
* Compare (case-insensitive) two strings and return the prefixes of the
|
||
* the strings formed by removing the common suffix string from them.
|
||
* Integrity of tokens (directory name, filename and object names) are
|
||
* preserved. Note that the prefixes are converted to upper case
|
||
* characters.
|
||
*
|
||
* Parameters:
|
||
* lpsz1 string 1
|
||
* lpsz2 string 2
|
||
* lplpszPrefix1 prefix of string 1
|
||
* lplpszPrefix2 prefix of string 2
|
||
*
|
||
* Returns:
|
||
*
|
||
*/
|
||
VOID DiffPrefix(LPCTSTR lpsz1, LPCTSTR lpsz2, TCHAR FAR* FAR* lplpszPrefix1, TCHAR FAR* FAR* lplpszPrefix2)
|
||
{
|
||
LPTSTR lpstr1;
|
||
LPTSTR lpstr2;
|
||
|
||
OleDbgAssert(lpsz1 && lpsz2 && *lpsz1 && *lpsz2 && lplpszPrefix1 &&
|
||
lplpszPrefix2);
|
||
|
||
*lplpszPrefix1 = NULL;
|
||
*lplpszPrefix2 = NULL;
|
||
#ifdef WIN32
|
||
*lplpszPrefix1 = OleStdMalloc((lstrlen(lpsz1)+1) * sizeof(TCHAR));
|
||
#else
|
||
*lplpszPrefix1 = OleStdMalloc((lstrlen(lpsz1)+1) * sizeof(BYTE));
|
||
#endif
|
||
if (!*lplpszPrefix1)
|
||
return;
|
||
|
||
#ifdef WIN32
|
||
*lplpszPrefix2 = OleStdMalloc((lstrlen(lpsz2)+1) * sizeof(TCHAR));
|
||
#else
|
||
*lplpszPrefix2 = OleStdMalloc((lstrlen(lpsz2)+1) * sizeof(BYTE));
|
||
#endif
|
||
if (!*lplpszPrefix2) {
|
||
OleStdFree(*lplpszPrefix1);
|
||
*lplpszPrefix1 = NULL;
|
||
return;
|
||
}
|
||
|
||
lstrcpy(*lplpszPrefix1, lpsz1);
|
||
lstrcpy(*lplpszPrefix2, lpsz2);
|
||
// AnsiLower(*lplpszPrefix1);
|
||
// AnsiLower(*lplpszPrefix2);
|
||
|
||
lpstr1 = *lplpszPrefix1 + lstrlen(*lplpszPrefix1);
|
||
lpstr2 = *lplpszPrefix2 + lstrlen(*lplpszPrefix2);
|
||
|
||
while ((lpstr1>*lplpszPrefix1) && (lpstr2>*lplpszPrefix2)) {
|
||
#ifdef WIN32
|
||
lpstr1 = CharPrev(*lplpszPrefix1, lpstr1);
|
||
lpstr2 = CharPrev(*lplpszPrefix2, lpstr2);
|
||
#else
|
||
lpstr1 = AnsiPrev(*lplpszPrefix1, lpstr1);
|
||
lpstr2 = AnsiPrev(*lplpszPrefix2, lpstr2);
|
||
#endif
|
||
if (*lpstr1 != *lpstr2) {
|
||
#ifdef WIN32
|
||
// AnsiNext is obsolete in Win32
|
||
lpstr1 = CharNext(lpstr1);
|
||
lpstr2 = CharNext(lpstr2);
|
||
#else
|
||
lpstr1 = AnsiNext(lpstr1);
|
||
lpstr2 = AnsiNext(lpstr2);
|
||
#endif
|
||
break;
|
||
}
|
||
}
|
||
|
||
for (; *lpstr1 && *lpstr1!=TEXT('\\') && *lpstr1!=TEXT('!');
|
||
#ifdef WIN32
|
||
lpstr1=CharNext(lpstr1));
|
||
#else
|
||
lpstr1=AnsiNext(lpstr1));
|
||
#endif
|
||
for (; *lpstr2 && *lpstr2!=TEXT('\\') && *lpstr2!=TEXT('!');
|
||
#ifdef WIN32
|
||
lpstr2=CharNext(lpstr2));
|
||
#else
|
||
lpstr2=AnsiNext(lpstr2));
|
||
#endif
|
||
|
||
*lpstr1 = TEXT('\0');
|
||
*lpstr2 = TEXT('\0');
|
||
}
|
||
|
||
|
||
/* PopupMessage
|
||
* ------------
|
||
*
|
||
* Purpose:
|
||
* Popup s messagebox and get some response from the user. It is the same
|
||
* as MessageBox() except that the title and message string are loaded
|
||
* from the resource file.
|
||
*
|
||
* Parameters:
|
||
* hwndParent parent window of message box
|
||
* idTitle id of title string
|
||
* idMessage id of message string
|
||
* fuStyle style of message box
|
||
*/
|
||
int PopupMessage(HWND hwndParent, UINT idTitle, UINT idMessage, UINT fuStyle)
|
||
{
|
||
TCHAR szTitle[256];
|
||
TCHAR szMsg[256];
|
||
|
||
LoadString(ghInst, idTitle, (LPTSTR)szTitle, sizeof(szTitle)/sizeof(TCHAR));
|
||
LoadString(ghInst, idMessage, (LPTSTR)szMsg, sizeof(szMsg)/sizeof(TCHAR));
|
||
return MessageBox(hwndParent, szMsg, szTitle, fuStyle);
|
||
}
|
||
|
||
|
||
/* ChangeAllLinks
|
||
* --------------
|
||
*
|
||
* Purpose:
|
||
* Enumerate all the links in the listbox and change those starting
|
||
* with lpszFrom to lpszTo.
|
||
*
|
||
* Parameters:
|
||
* hListBox window handle of
|
||
* lpOleUILinkCntr pointer to OleUI Link Container
|
||
* lpszFrom prefix for matching
|
||
* lpszTo prefix to substitution
|
||
*
|
||
* Returns:
|
||
*/
|
||
VOID ChangeAllLinks(HWND hListBox, LPOLEUILINKCONTAINER lpOleUILinkCntr, LPTSTR lpszFrom, LPTSTR lpszTo)
|
||
{
|
||
int cItems;
|
||
int nIndex;
|
||
int cFrom;
|
||
LPLINKINFO lpLI;
|
||
LPTSTR szTmp[OLEUI_CCHPATHMAX];
|
||
BOOL bFound;
|
||
|
||
cFrom = lstrlen(lpszFrom);
|
||
|
||
cItems = (int)SendMessage(hListBox, LB_GETCOUNT, 0, 0L);
|
||
OleDbgAssert(cItems >= 0);
|
||
|
||
bFound = FALSE;
|
||
|
||
OleDbgPrint(3, TEXT("From : "), lpszFrom, 0);
|
||
OleDbgPrint(3, TEXT(""), TEXT("\r\n"), 0);
|
||
OleDbgPrint(3, TEXT("To : "), lpszTo, 0);
|
||
OleDbgPrint(3, TEXT(""), TEXT("\r\n"), 0);
|
||
|
||
for (nIndex=0; nIndex<cItems; nIndex++) {
|
||
SendMessage(hListBox, LB_GETTEXT, nIndex,
|
||
(LPARAM)(LPLINKINFO FAR*)&lpLI);
|
||
|
||
// unmark the item
|
||
lpLI->fIsMarked = FALSE;
|
||
|
||
/* if the corresponding position for the end of lpszFrom in the
|
||
** display name is not a separator. We stop comparing this
|
||
** link.
|
||
*/
|
||
if (!*(lpLI->lpszDisplayName + cFrom) ||
|
||
(*(lpLI->lpszDisplayName + cFrom) == TEXT('\\')) ||
|
||
(*(lpLI->lpszDisplayName + cFrom) == TEXT('!'))) {
|
||
|
||
LSTRCPYN((LPTSTR)szTmp, lpLI->lpszDisplayName, cFrom + 1);
|
||
if (!lstrcmp((LPTSTR)szTmp, lpszFrom)) {
|
||
HRESULT hErr;
|
||
int nFileLength;
|
||
ULONG ulDummy;
|
||
|
||
if (!bFound) {
|
||
TCHAR szTitle[256];
|
||
TCHAR szMsg[256];
|
||
TCHAR szBuf[256];
|
||
int uRet;
|
||
|
||
LoadString(ghInst, IDS_CHANGESOURCE, (LPTSTR)szTitle,
|
||
sizeof(szTitle)/sizeof(TCHAR));
|
||
LoadString(ghInst, IDS_CHANGEADDITIONALLINKS,
|
||
(LPTSTR)szMsg, sizeof(szMsg)/sizeof(TCHAR));
|
||
wsprintf((LPTSTR)szBuf, (LPTSTR)szMsg, lpszFrom);
|
||
uRet = MessageBox(hListBox, (LPTSTR)szBuf, (LPTSTR)szTitle,
|
||
MB_ICONQUESTION | MB_YESNO);
|
||
if (uRet == IDYES)
|
||
bFound = TRUE;
|
||
else
|
||
return; // exit function
|
||
}
|
||
|
||
lstrcpy((LPTSTR)szTmp, lpszTo);
|
||
lstrcat((LPTSTR)szTmp, lpLI->lpszDisplayName + cFrom);
|
||
nFileLength = lstrlen((LPTSTR)szTmp) -
|
||
(lpLI->lpszItemName ? lstrlen(lpLI->lpszItemName) : 0);
|
||
|
||
|
||
hErr = lpOleUILinkCntr->lpVtbl->SetLinkSource(
|
||
lpOleUILinkCntr,
|
||
lpLI->dwLink,
|
||
(LPTSTR)szTmp,
|
||
(ULONG)nFileLength,
|
||
(ULONG FAR*)&ulDummy,
|
||
TRUE
|
||
);
|
||
if (hErr != NOERROR)
|
||
lpOleUILinkCntr->lpVtbl->SetLinkSource(
|
||
lpOleUILinkCntr,
|
||
lpLI->dwLink,
|
||
(LPTSTR)szTmp,
|
||
(ULONG)nFileLength,
|
||
(ULONG FAR*)&ulDummy,
|
||
FALSE
|
||
);
|
||
lpLI->fIsMarked = TRUE;
|
||
}
|
||
}
|
||
}
|
||
|
||
/* have to do the refreshing after processing all links, otherwise
|
||
** the item positions will change during the process as the
|
||
** listbox stores items in order
|
||
*/
|
||
if (bFound)
|
||
RefreshLinkLB(hListBox, lpOleUILinkCntr);
|
||
}
|
||
|
||
|
||
|
||
/* LoadLinkLB
|
||
* ----------
|
||
*
|
||
* Purpose:
|
||
* Enumerate all links from the Link Container and build up the Link
|
||
* ListBox
|
||
*
|
||
* Parameters:
|
||
* hListBox window handle of
|
||
* lpOleUILinkCntr pointer to OleUI Link Container
|
||
* lpszFrom prefix for matching
|
||
* lpszTo prefix to substitution
|
||
*
|
||
* Returns:
|
||
* number of link items loaded, -1 if error
|
||
*/
|
||
int LoadLinkLB(HWND hListBox, LPOLEUILINKCONTAINER lpOleUILinkCntr)
|
||
{
|
||
DWORD dwLink = 0;
|
||
LPLINKINFO lpLI;
|
||
int nIndex;
|
||
int cLinks;
|
||
|
||
cLinks = 0;
|
||
|
||
while ((dwLink = lpOleUILinkCntr->lpVtbl->GetNextLink(lpOleUILinkCntr,
|
||
dwLink)) != 0) {
|
||
lpLI = (LPLINKINFO)OleStdMalloc(sizeof(LINKINFO));
|
||
if (NULL == lpLI)
|
||
return -1;
|
||
|
||
lpLI->fIsMarked = FALSE;
|
||
lpLI->fIsSelected = FALSE;
|
||
lpLI->fDontFree = FALSE;
|
||
|
||
#ifdef WIN32
|
||
lpLI->lpszAMX = (LPTSTR)OleStdMalloc((LINKTYPELEN+1)*sizeof(TCHAR));
|
||
#else
|
||
lpLI->lpszAMX = (LPTSTR)OleStdMalloc((LINKTYPELEN+1)*sizeof(BYTE));
|
||
#endif
|
||
|
||
lpLI->dwLink = dwLink;
|
||
cLinks++;
|
||
if ((nIndex = AddLinkLBItem(hListBox,lpOleUILinkCntr,lpLI,TRUE)) < 0)
|
||
// can't load list box
|
||
return -1;
|
||
|
||
if (lpLI->fIsSelected) {
|
||
SendMessage(hListBox, LB_SETSEL, TRUE, MAKELPARAM(nIndex, 0));
|
||
}
|
||
}
|
||
if (SendMessage(hListBox,LB_GETSELITEMS,(WPARAM)1,(LPARAM)(int FAR*)&nIndex))
|
||
SendMessage(hListBox, LB_SETCARETINDEX, (WPARAM)nIndex, MAKELPARAM(TRUE, 0));
|
||
|
||
return cLinks;
|
||
}
|
||
|
||
|
||
/* RefreshLinkLB
|
||
* -------------
|
||
*
|
||
* Purpose:
|
||
* Enumerate all items in the links listbox and update those with
|
||
* fIsMarked set.
|
||
* Note that this is a time consuming routine as it keeps iterating
|
||
* all items in the listbox until all of them are unmarked.
|
||
*
|
||
* Parameters:
|
||
* hListBox window handle of listbox
|
||
* lpOleUILinkCntr pointer to OleUI Link Container
|
||
*
|
||
* Returns:
|
||
*
|
||
*/
|
||
VOID RefreshLinkLB(HWND hListBox, LPOLEUILINKCONTAINER lpOleUILinkCntr)
|
||
{
|
||
int cItems;
|
||
int nIndex;
|
||
LPLINKINFO lpLI;
|
||
BOOL bStop;
|
||
|
||
OleDbgAssert(hListBox);
|
||
|
||
cItems = (int)SendMessage(hListBox, LB_GETCOUNT, 0, 0L);
|
||
OleDbgAssert(cItems >= 0);
|
||
|
||
do {
|
||
bStop = TRUE;
|
||
for (nIndex=0; nIndex<cItems; nIndex++) {
|
||
SendMessage(hListBox, LB_GETTEXT, nIndex,
|
||
(LPARAM)(LPLINKINFO FAR*)&lpLI);
|
||
if (lpLI->fIsMarked) {
|
||
lpLI->fIsMarked = FALSE;
|
||
lpLI->fDontFree = TRUE;
|
||
|
||
SendMessage(hListBox, LB_DELETESTRING, nIndex, 0L);
|
||
nIndex=AddLinkLBItem(hListBox, lpOleUILinkCntr, lpLI, FALSE);
|
||
if (lpLI->fIsSelected) {
|
||
SendMessage(hListBox, LB_SETSEL, (WPARAM)TRUE,
|
||
MAKELPARAM(nIndex, 0));
|
||
SendMessage(hListBox, LB_SETCARETINDEX, (WPARAM)nIndex,
|
||
MAKELPARAM(TRUE, 0));
|
||
}
|
||
bStop = FALSE;
|
||
break;
|
||
}
|
||
}
|
||
} while (!bStop);
|
||
}
|
||
|
||
|