620 lines
21 KiB
C
620 lines
21 KiB
C
/**********************************************************************************
|
|
*
|
|
*
|
|
* contxtmnu.c - contains functions for handling/creating context menu extension
|
|
*
|
|
* Created - 9/97 - vikramm
|
|
*
|
|
**********************************************************************************/
|
|
#include "_apipch.h"
|
|
|
|
static const TCHAR szActionPropsRegKey[] = TEXT("Software\\Microsoft\\WAB\\WAB4\\ExtContext");
|
|
BOOL fContextExtCoinit = FALSE;
|
|
|
|
//$$//////////////////////////////////////////////////////////////////////
|
|
//
|
|
// UninitContextExtInfo
|
|
//
|
|
// OLE Unintialization
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////
|
|
void UninitContextExtInfo()
|
|
{
|
|
if(fContextExtCoinit)
|
|
{
|
|
CoUninitialize();
|
|
fContextExtCoinit = FALSE;
|
|
}
|
|
}
|
|
|
|
/*
|
|
- FreeActionItemList
|
|
-
|
|
* Frees up the Action Items list cached on the IAB object
|
|
*
|
|
*/
|
|
void FreeActionItemList(LPIAB lpIAB)
|
|
{
|
|
LPWABACTIONITEM lpItem = lpIAB->lpActionList;
|
|
while(lpItem)
|
|
{
|
|
lpIAB->lpActionList = lpItem->lpNext;
|
|
SafeRelease(lpItem->lpWABExtInit);
|
|
SafeRelease(lpItem->lpContextMenu);
|
|
LocalFree(lpItem);
|
|
lpItem = lpIAB->lpActionList;
|
|
}
|
|
lpIAB->lpActionList = NULL;
|
|
}
|
|
|
|
|
|
/*
|
|
- HrUpdateActionItemList
|
|
-
|
|
* Apps can register with the WAB for rt-click and toolbar Action items
|
|
* We load a list of registered action items here upfront and cache it on
|
|
* the IAB object.
|
|
*
|
|
*/
|
|
|
|
HRESULT HrUpdateActionItemList(LPIAB lpIAB)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
HKEY hKey = NULL;
|
|
LPWABACTIONITEM lpList = NULL;
|
|
DWORD dwIndex = 0, dwSize = 0;
|
|
int nCmdID = IDM_EXTENDED_START, nActionItems = 0;
|
|
|
|
EnterCriticalSection(&lpIAB->cs);
|
|
|
|
if(lpIAB->lpActionList)
|
|
FreeActionItemList(lpIAB);
|
|
|
|
lpIAB->lpActionList = NULL;
|
|
|
|
//
|
|
// We will look in the registry under HKLM\Software\Microsoft\WAB\WAB4\Actions
|
|
// If this key exists, we get all the key values under it - these key values
|
|
// are all GUIDs
|
|
// The format for this key is
|
|
//
|
|
// HKLM\Software\Microsoft\WAB\WAB4\Action Extensions
|
|
// GUID1
|
|
// GUID2
|
|
// GUID3 etc
|
|
//
|
|
|
|
if(ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
szActionPropsRegKey,
|
|
0, KEY_READ,&hKey))
|
|
{
|
|
goto out;
|
|
}
|
|
|
|
{
|
|
// Enumerate the GUIDs under this key one by one
|
|
//
|
|
TCHAR szGUIDName[MAX_PATH];
|
|
DWORD dwGUIDIndex = 0, dwGUIDSize = CharSizeOf(szGUIDName), dwType = 0;
|
|
|
|
*szGUIDName = '\0';
|
|
|
|
while(ERROR_SUCCESS == RegEnumValue(hKey, dwGUIDIndex,
|
|
szGUIDName, &dwGUIDSize,
|
|
0, &dwType,
|
|
NULL, NULL))
|
|
{
|
|
// The values under this entry are all GUIDs
|
|
// Read the GUID string and translate it into a GUID
|
|
//
|
|
GUID guidTmp = {0};
|
|
WCHAR szW[MAX_PATH];
|
|
StrCpyNW(szW, szGUIDName, ARRAYSIZE(szW));
|
|
if( !(HR_FAILED(hr = CLSIDFromString(szW, &guidTmp))) )
|
|
{
|
|
LPWABACTIONITEM lpTemp = LocalAlloc(LMEM_ZEROINIT, sizeof(WABACTIONITEM));
|
|
if(!lpTemp)
|
|
{
|
|
hr = MAPI_E_NOT_ENOUGH_MEMORY;
|
|
goto out;
|
|
}
|
|
// Temporarily cache the GUID
|
|
CopyMemory(&(lpTemp->guidContextMenu), &guidTmp, sizeof(GUID));
|
|
lpTemp->lpNext = lpList;
|
|
lpList = lpTemp;
|
|
}
|
|
|
|
dwGUIDIndex++;
|
|
*szGUIDName = '\0';
|
|
dwGUIDSize = CharSizeOf(szGUIDName);
|
|
}
|
|
}
|
|
|
|
if(lpList)
|
|
{
|
|
// If we have a list of GUIDs from the registry, we now
|
|
// need to open CoCreateInstance them one by one and get a handle
|
|
// to their method pointers
|
|
LPWABACTIONITEM lpItem = lpList;
|
|
|
|
if (CoInitialize(NULL) == S_FALSE)
|
|
CoUninitialize(); // Already initialized, undo the extra.
|
|
else
|
|
fContextExtCoinit = TRUE;
|
|
|
|
while(lpItem)
|
|
{
|
|
hr = CoCreateInstance( &(lpItem->guidContextMenu),
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
|
|
&IID_IContextMenu,
|
|
(LPVOID *)&(lpItem->lpContextMenu));
|
|
if(lpItem->lpContextMenu && !HR_FAILED(hr))
|
|
{
|
|
// Found an IContextMenu object, aslo want a IWABExtInit object
|
|
hr = lpItem->lpContextMenu->lpVtbl->QueryInterface(lpItem->lpContextMenu,
|
|
&IID_IWABExtInit,
|
|
(LPVOID *)&(lpItem->lpWABExtInit));
|
|
if(HR_FAILED(hr) || !lpItem->lpWABExtInit)
|
|
{
|
|
// Can't work without an IWABExtInit object
|
|
SafeRelease(lpItem->lpContextMenu);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = S_OK; //ignore error
|
|
lpItem->lpContextMenu = NULL;
|
|
}
|
|
lpItem = lpItem->lpNext;
|
|
}
|
|
}
|
|
|
|
lpIAB->lpActionList = lpList;
|
|
|
|
hr = S_OK;
|
|
out:
|
|
if(hKey)
|
|
RegCloseKey(hKey);
|
|
|
|
LeaveCriticalSection(&lpIAB->cs);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
- GetActionAdrList
|
|
-
|
|
* Based on the parameters for a particular rt-click action,
|
|
* scans the entries in the list view and creates an adrlist
|
|
* for the entries
|
|
*
|
|
* If only one entry is selected and it is an LDAP entry, then
|
|
* also creates an LDAP URL representing that entry .. this way
|
|
* if we are displaying properties or doing actions on a single
|
|
* entry, the property sheet extenstions can determine if they
|
|
* want to do anything extra for the entry. People most interested
|
|
* in this are the NTDS
|
|
*
|
|
* For now,we only look at the selected items in the list view
|
|
*
|
|
lpAdrBook - IAB object
|
|
hWndLV - the list view on which this action was initiated
|
|
*lppAdrList - created AdrList
|
|
*lpURL - returned URL
|
|
*lpbIsNTDSEntry - flag NTDS entries so they can be special treated
|
|
|
|
Note performance suffers for a large number of entries so we want to
|
|
really only return a list of entryids
|
|
*/
|
|
HRESULT HrGetActionAdrList(LPADRBOOK lpAdrBook,
|
|
HWND hWndLV,
|
|
LPADRLIST * lppAdrList,
|
|
LPTSTR * lppURL, BOOL * lpbIsNTDSEntry)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LPADRLIST lpAdrList = NULL;
|
|
int i = 0, iItemIndex = 0, nIndex= 0;
|
|
int nSel = ListView_GetSelectedCount(hWndLV);
|
|
SCODE sc;
|
|
if(!nSel)
|
|
goto out;
|
|
|
|
sc = MAPIAllocateBuffer(sizeof(ADRLIST) + nSel * sizeof(ADRENTRY), &lpAdrList);
|
|
|
|
if(sc)
|
|
{
|
|
hr = ResultFromScode(sc);
|
|
goto out;
|
|
}
|
|
|
|
// Get index of selected item
|
|
iItemIndex = ListView_GetNextItem(hWndLV,-1,LVNI_SELECTED);
|
|
|
|
while(iItemIndex != -1)
|
|
{
|
|
LPRECIPIENT_INFO lpItem = GetItemFromLV(hWndLV, iItemIndex);
|
|
|
|
if(lpItem)
|
|
{
|
|
ULONG ulObjType = 0;
|
|
LPSPropValue lpProps = NULL;
|
|
LPMAILUSER lpEntry = NULL;
|
|
ULONG cValues = 0;
|
|
|
|
if(lpItem->cbEntryID && lpItem->lpEntryID)
|
|
{
|
|
if (hr = lpAdrBook->lpVtbl->OpenEntry(lpAdrBook,
|
|
lpItem->cbEntryID,
|
|
lpItem->lpEntryID,
|
|
NULL, // interface
|
|
0, // flags
|
|
&ulObjType,
|
|
(LPUNKNOWN *)&lpEntry))
|
|
{
|
|
goto out;
|
|
}
|
|
hr = lpEntry->lpVtbl->GetProps( lpEntry, NULL, MAPI_UNICODE,
|
|
&cValues, &lpProps);
|
|
if(HR_FAILED(hr))
|
|
{
|
|
UlRelease(lpEntry);
|
|
goto out;
|
|
}
|
|
lpAdrList->aEntries[nIndex].cValues = cValues;
|
|
lpAdrList->aEntries[nIndex].rgPropVals = lpProps;
|
|
nIndex++;
|
|
|
|
UlRelease(lpEntry);
|
|
|
|
if(nSel == 1 && lppURL)
|
|
{
|
|
CreateLDAPURLFromEntryID(lpItem->cbEntryID, lpItem->lpEntryID,
|
|
lppURL, lpbIsNTDSEntry);
|
|
}
|
|
}
|
|
}
|
|
iItemIndex = ListView_GetNextItem(hWndLV,iItemIndex,LVNI_SELECTED);
|
|
}
|
|
|
|
lpAdrList->cEntries = nIndex;
|
|
*lppAdrList = lpAdrList;
|
|
lpAdrList = NULL;
|
|
hr = S_OK;
|
|
|
|
out:
|
|
if (lpAdrList)
|
|
MAPIFreeBuffer(lpAdrList);
|
|
|
|
return hr;
|
|
}
|
|
|
|
extern void MAILUSERAssociateContextData(LPMAILUSER lpMailUser, LPWABEXTDISPLAY lpWEC);
|
|
/*
|
|
- HrCreateContextDataStruct
|
|
-
|
|
* Creates the data necessary to initialize a ContextMenu implementor
|
|
* This structure is passed into the IWABExtInit::Initialize call
|
|
*
|
|
hWndLV - ListView containing the WAB entries
|
|
lppWABExt - returned data
|
|
*/
|
|
HRESULT HrCreateContextDataStruct( LPIAB lpIAB,
|
|
HWND hWndLV,
|
|
LPWABEXTDISPLAY * lppWABExt)
|
|
{
|
|
LPADRLIST lpAdrList = NULL;
|
|
LPWABEXTDISPLAY lpWEC = NULL;
|
|
LPMAILUSER lpMailUser = NULL;
|
|
LPTSTR lpURL = NULL;
|
|
BOOL bIsNTDSEntry = FALSE;
|
|
|
|
HRESULT hr = E_FAIL;
|
|
|
|
// Get an AdrList Corresponding to the LV contents
|
|
hr = HrGetActionAdrList((LPADRBOOK)lpIAB, hWndLV, &lpAdrList, &lpURL, &bIsNTDSEntry);
|
|
if(HR_FAILED(hr) || !lpAdrList || !lpAdrList->cEntries)
|
|
goto out; //dont bother invoking
|
|
|
|
// Create a dummy mailuser so callers can call GetIDsFromNames
|
|
// on this dummy mailuser - saves them the trouble of creating entries
|
|
// just to call GetIDsFromNames
|
|
hr = HrCreateNewObject((LPADRBOOK)lpIAB, NULL, MAPI_MAILUSER, CREATE_CHECK_DUP_STRICT, (LPMAPIPROP *) &lpMailUser);
|
|
if(HR_FAILED(hr))
|
|
goto out; //dont bother invoking
|
|
|
|
lpWEC = LocalAlloc(LMEM_ZEROINIT, sizeof(WABEXTDISPLAY));
|
|
if(!lpWEC)
|
|
{
|
|
hr = MAPI_E_NOT_ENOUGH_MEMORY;
|
|
goto out;
|
|
}
|
|
|
|
lpWEC->cbSize = sizeof(WABEXTDISPLAY);
|
|
lpWEC->ulFlags = WAB_CONTEXT_ADRLIST; // indicates ADRLIST is valid and in the lpv member
|
|
lpWEC->lpAdrBook = (LPADRBOOK) lpIAB;
|
|
lpWEC->lpWABObject = (LPWABOBJECT) lpIAB->lpWABObject;
|
|
lpWEC->lpPropObj = (LPMAPIPROP) lpMailUser;
|
|
lpWEC->lpv = (LPVOID) lpAdrList;
|
|
|
|
if(lpURL && lstrlen(lpURL))
|
|
{
|
|
lpWEC->lpsz = lpURL;
|
|
lpWEC->ulFlags |= WAB_DISPLAY_LDAPURL;
|
|
lpWEC->ulFlags |= MAPI_UNICODE;
|
|
if(bIsNTDSEntry)
|
|
lpWEC->ulFlags |= WAB_DISPLAY_ISNTDS;
|
|
}
|
|
|
|
// We associate this entire WABEXT structure with the mailuser
|
|
// so that when we get the IMailUser release, we can go ahead and clean
|
|
// up all the WABEXT memory .. since there is no other good time that we can
|
|
// free the memory since we won't know who is doing what withthe structure.
|
|
// Freeing it at IMailUser::Release time works out quite well
|
|
MAILUSERAssociateContextData(lpMailUser, lpWEC);
|
|
|
|
//
|
|
// Cache this mailUser on the IAB object
|
|
//
|
|
// At any given point of time, we are going to cache one ContextMenu related MailUser
|
|
// This is because we set this up before QueryCommandMenu and then we dont know whether
|
|
// or not the user actually managed to select a menu item, or went off and did something new.
|
|
// We set the data on a MailUser and we don't release the MailUser till the next time we are
|
|
// here. If someone is currently using the MailUser, they will addref it - the memory attached
|
|
// to the MailUser will be freed up with the last caller so we dont leak it ..
|
|
// If we never come back here, the mailuser will be released at shutdown
|
|
//
|
|
UlRelease(lpIAB->lpCntxtMailUser);
|
|
lpIAB->lpCntxtMailUser = lpMailUser;
|
|
|
|
*lppWABExt = lpWEC;
|
|
hr = S_OK;
|
|
out:
|
|
|
|
if(HR_FAILED(hr))
|
|
{
|
|
UlRelease(lpMailUser);
|
|
if(lpAdrList)
|
|
FreePadrlist(lpAdrList);
|
|
if(lpWEC)
|
|
LocalFree(lpWEC);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
//$$////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// AddExtendedMenuItems - Creates a list of extension menu items and adds them
|
|
// to the specified menu
|
|
//
|
|
// hMenuAction - menu on which to add this item
|
|
// bUpdateStatus - if TRUE, means only find the existing item in the menu and update
|
|
// its status - if FALSE, means add to the menu
|
|
// bAddSendMailToItems - if TRUE, means attempt to modify the SendMailTo menu item
|
|
//
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
void AddExtendedMenuItems( LPADRBOOK lpAdrBook,
|
|
HWND hWndLV,
|
|
HMENU hMenuAction,
|
|
BOOL bUpdateStatus,
|
|
BOOL bAddSendMailToItems)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LPWABEXTDISPLAY lpWEC = NULL;
|
|
LPIAB lpIAB = (LPIAB) lpAdrBook;
|
|
|
|
// Intialize the context menu extensions
|
|
if(!lpIAB->lpActionList)
|
|
HrUpdateActionItemList(lpIAB);
|
|
|
|
if(bUpdateStatus)
|
|
{
|
|
// This is only set to true from the call from ui_abook.c which means this
|
|
// is the Tools Menu item we are talking about.
|
|
// To update the status of the Tools menu item, we need to remove all the
|
|
// items we added before and then re-add them
|
|
// For indexing purposes, we will assume that the last pre-configured item in
|
|
// this list is the Internet Call item (since this menu list is quite variable)
|
|
|
|
// First get the position of the IDM_TOOLS_INTERNET_CALL item
|
|
int i, nPos = -1, nId = 0;
|
|
int nCmdCount = GetMenuItemCount(hMenuAction); // Append all items at end of this menu
|
|
for(i=0;i<nCmdCount;i++)
|
|
{
|
|
if(GetMenuItemID(hMenuAction, i) == IDM_TOOLS_INTERNET_CALL)
|
|
{
|
|
nPos = i;
|
|
break;
|
|
}
|
|
}
|
|
if(nPos >= 0 && nPos < nCmdCount-1)
|
|
{
|
|
for(i=nPos+1;i<nCmdCount;i++)
|
|
{
|
|
DeleteMenu(hMenuAction, nPos+1, MF_BYPOSITION);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Do any special treatment we need to do for SendMailTo
|
|
AddExtendedSendMailToItems(lpAdrBook, hWndLV, hMenuAction, bAddSendMailToItems);
|
|
|
|
|
|
// Before we can call QueryContextMenu - we must already have a list of all
|
|
// the selected items from the ListView and provide such items to the ContextMenu
|
|
// implementors so that they can decide how to handle the data being provided to them
|
|
// (e.g. they may want to disable their item for multi-selections etc)...
|
|
//
|
|
HrCreateContextDataStruct(lpIAB, hWndLV, &lpWEC);
|
|
|
|
if(lpIAB->lpActionList && lpWEC && lpWEC->lpv)
|
|
{
|
|
LPWABACTIONITEM lpItem = lpIAB->lpActionList;
|
|
int nCmdIdPos = GetMenuItemCount(hMenuAction); // Append all items at end of this menu
|
|
while(lpItem)
|
|
{
|
|
if(lpItem->lpContextMenu && lpItem->lpWABExtInit)// && !bUpdateStatus)
|
|
{
|
|
int nNumCmd = 0;
|
|
// Get the menu item added to this menu
|
|
hr = lpItem->lpWABExtInit->lpVtbl->Initialize(lpItem->lpWABExtInit, lpWEC);
|
|
if(!HR_FAILED(hr))
|
|
{
|
|
hr = lpItem->lpContextMenu->lpVtbl->QueryContextMenu(lpItem->lpContextMenu,
|
|
hMenuAction,
|
|
nCmdIdPos,
|
|
lpItem->nCmdIdFirst ? lpItem->nCmdIdFirst : IDM_EXTENDED_START+nCmdIdPos,
|
|
IDM_EXTENDED_END,
|
|
CMF_NODEFAULT | CMF_NORMAL);
|
|
if(!HR_FAILED(hr))
|
|
{
|
|
nNumCmd = HRESULT_CODE(hr);
|
|
if(nNumCmd)
|
|
{
|
|
// Record the range of IDs taken up by this menu ext implementor
|
|
if(!lpItem->nCmdIdFirst)
|
|
lpItem->nCmdIdFirst = nCmdIdPos+IDM_EXTENDED_START;
|
|
if(!lpItem->nCmdIdLast)
|
|
lpItem->nCmdIdLast = lpItem->nCmdIdFirst + nNumCmd - 1;
|
|
}
|
|
// Update the next available starting pos
|
|
nCmdIdPos = nCmdIdPos+nNumCmd;
|
|
}
|
|
}
|
|
}
|
|
lpItem = lpItem->lpNext;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
- ProcessActionCommands
|
|
-
|
|
* Process a WM_COMMAND message to see if it matches any of the extended
|
|
* rt-click action items ...
|
|
*
|
|
* Also process SendMailTo extended email-address mail processing here since
|
|
* this is a convenient place to do so ..
|
|
*
|
|
*/
|
|
LRESULT ProcessActionCommands(LPIAB lpIAB, HWND hWndLV, HWND hWnd,
|
|
UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
int nCmdID = GET_WM_COMMAND_ID(wParam, lParam);
|
|
int i = 0;
|
|
|
|
switch(nCmdID)
|
|
{
|
|
case IDM_DIALDLG_START:
|
|
HrExecDialDlg(hWndLV, (LPADRBOOK)lpIAB);
|
|
return 0;
|
|
break;
|
|
case IDM_LVCONTEXT_INTERNET_CALL:
|
|
case IDM_TOOLS_INTERNET_CALL:
|
|
HrShellExecInternetCall((LPADRBOOK)lpIAB, hWndLV);
|
|
return 0;
|
|
break;
|
|
|
|
case IDM_LVCONTEXT_SENDMAIL:
|
|
case IDM_FILE_SENDMAIL:
|
|
HrSendMailToSelectedContacts(hWndLV, (LPADRBOOK)lpIAB, 0);
|
|
break;
|
|
}
|
|
|
|
if( (nCmdID>=IDM_SENDMAILTO_START) && (nCmdID<=IDM_SENDMAILTO_START+IDM_SENDMAILTO_MAX))
|
|
{
|
|
HrSendMailToSelectedContacts(hWndLV, (LPADRBOOK)lpIAB, nCmdID - IDM_SENDMAILTO_START);
|
|
return 0;
|
|
}
|
|
|
|
// Check if this is any of the context menu extensions ..
|
|
if(lpIAB->lpActionList)
|
|
{
|
|
LPWABACTIONITEM lpListItem = lpIAB->lpActionList;
|
|
while(lpListItem)
|
|
{
|
|
if(nCmdID >= lpListItem->nCmdIdFirst && nCmdID <= lpListItem->nCmdIdLast)
|
|
{
|
|
CMINVOKECOMMANDINFO cmici = {0};
|
|
cmici.cbSize = sizeof(CMINVOKECOMMANDINFO);
|
|
cmici.fMask = 0;
|
|
cmici.hwnd = hWnd;
|
|
cmici.lpVerb = (LPCSTR) IntToPtr(nCmdID - lpListItem->nCmdIdFirst);
|
|
cmici.lpParameters = NULL;
|
|
cmici.lpDirectory = NULL;
|
|
cmici.nShow = SW_SHOWNORMAL;
|
|
|
|
lpListItem->lpContextMenu->lpVtbl->InvokeCommand(lpListItem->lpContextMenu,
|
|
&cmici);
|
|
return 0;
|
|
}
|
|
lpListItem = lpListItem->lpNext;
|
|
}
|
|
}
|
|
return DefWindowProc(hWnd,uMsg,wParam,lParam);
|
|
}
|
|
|
|
|
|
/*
|
|
- GetContextMenuExtCommandString
|
|
-
|
|
* gets the status bar helptext for context menu extensions
|
|
*
|
|
*/
|
|
void GetContextMenuExtCommandString(LPIAB lpIAB, int nCmdId, LPTSTR sz, ULONG cbsz)
|
|
{
|
|
int nStringID = 0;
|
|
|
|
switch(nCmdId)
|
|
{
|
|
case IDM_DIALDLG_START:
|
|
nStringID = idsMenuDialer;
|
|
break;
|
|
case IDM_LVCONTEXT_INTERNET_CALL:
|
|
case IDM_TOOLS_INTERNET_CALL:
|
|
nStringID = idsMenuInternetCall;
|
|
break;
|
|
case IDM_LVCONTEXT_SENDMAIL:
|
|
case IDM_FILE_SENDMAIL:
|
|
nStringID = idsMenuSendMail;
|
|
break;
|
|
}
|
|
if(nStringID)
|
|
{
|
|
LoadString(hinstMapiX, nStringID, sz, cbsz);
|
|
return;
|
|
}
|
|
|
|
if(lpIAB->lpActionList)
|
|
{
|
|
LPWABACTIONITEM lpListItem = lpIAB->lpActionList;
|
|
while(lpListItem)
|
|
{
|
|
if(nCmdId >= lpListItem->nCmdIdFirst && nCmdId <= lpListItem->nCmdIdLast)
|
|
{
|
|
char szC[MAX_PATH];
|
|
ULONG cbszC = CharSizeOf(szC);
|
|
lpListItem->lpContextMenu->lpVtbl->GetCommandString(lpListItem->lpContextMenu,
|
|
nCmdId - lpListItem->nCmdIdFirst,
|
|
GCS_HELPTEXT,
|
|
NULL,
|
|
szC,
|
|
cbszC);
|
|
{
|
|
LPTSTR lp = ConvertAtoW(szC);
|
|
if(lp)
|
|
{
|
|
StrCpyN(sz, lp, cbsz);
|
|
LocalFreeAndNull(&lp);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
lpListItem = lpListItem->lpNext;
|
|
}
|
|
}
|
|
}
|