|
|
/*--------------------------------------------------------------
*** ui_addr.c - contains stuff for showing the :Address UI*******--------------------------------------------------------------*/#include "_apipch.h"
extern HINSTANCE ghCommCtrlDLLInst;
#define SET_UNICODE_STR(lp1,lp2,lpAdrParms) if(lpAdrParms->ulFlags & MAPI_UNICODE)\
lp1 = (LPWSTR)lp2; \ else \ lp1 = ConvertAtoW((LPSTR)lp2); \
#define FREE_UNICODE_STR(lp1,lp2) if(lp1 != lp2) LocalFreeAndNull(&lp1);
typedef struct _AddressParms{ LPADRBOOK lpIAB; //Stores a pointer to the ADRBOOK object
LPADRPARM lpAdrParms; //AdrParms structure passed into Address
LPADRLIST *lppAdrList; //AdrList of input names
HANDLE hPropertyStore; //pointer to the property store
int DialogState; //Identifies the ongoing function
LPRECIPIENT_INFO lpContentsList;//Contains a list of entries in the contents structure
LPRECIPIENT_INFO lpListTo; //Entries in the To Well
LPRECIPIENT_INFO lpListCC; //Entries in the CC well
LPRECIPIENT_INFO lpListBCC; //Entries in the BCC well
SORT_INFO SortInfo; //Contains current sort info
int nContextID; //identifies which list view called the context menu
BOOL bDontRefresh; //Used to ensure that nothing refreshes during modal operations
BOOL bLDAPinProgress; HCURSOR hWaitCur; int nRetVal; LPMAPIADVISESINK lpAdviseSink; ULONG ulAdviseConnection; BOOL bDeferNotification; // Used to defer next notification request
HWND hDlg; HWND hWndAddr;} ADDRESS_PARMS, *LPADDRESS_PARMS;
enum _lppAdrListReturnedProps{ propPR_DISPLAY_NAME, propPR_ENTRYID, propPR_RECIPIENT_TYPE, TOTAL_ADRLIST_PROPS};
static DWORD rgAddrHelpIDs[] ={ IDC_ADDRBK_EDIT_QUICKFIND, IDH_WAB_PICK_RECIP_TYPE_NAME, IDC_ADDRBK_STATIC_CONTENTS, IDH_WAB_PICK_RECIP_NAME_LIST, IDC_ADDRBK_LIST_ADDRESSES, IDH_WAB_PICK_RECIP_NAME_LIST, IDC_ADDRBK_BUTTON_PROPS, IDH_WAB_PICK_RECIP_NAME_PROPERTIES, IDC_ADDRBK_BUTTON_NEW, IDH_WAB_PICK_RECIP_NAME_NEW, IDC_ADDRBK_BUTTON_TO, IDH_WAB_PICK_RECIP_NAME_TO_BUTTON, IDC_ADDRBK_BUTTON_CC, IDH_WAB_PICK_RECIP_NAME_CC_BUTTON, IDC_ADDRBK_BUTTON_BCC, IDH_WAB_PICK_RECIP_NAME_BCC_BUTTON, IDC_ADDRBK_LIST_TO, IDH_WAB_PICK_RECIP_NAME_TO_LIST, IDC_ADDRBK_LIST_CC, IDH_WAB_PICK_RECIP_NAME_CC_LIST, IDC_ADDRBK_LIST_BCC, IDH_WAB_PICK_RECIP_NAME_BCC_LIST, IDC_ADDRBK_BUTTON_DELETE, IDH_WAB_PICK_RECIP_NAME_DELETE, IDC_ADDRBK_BUTTON_NEWGROUP, IDH_WAB_PICK_RECIP_NAME_NEW_GROUP, IDC_ADDRBK_STATIC_RECIP_TITLE, IDH_WAB_COMM_GROUPBOX, IDC_ADDRBK_BUTTON_FIND, IDH_WAB_PICK_RECIP_NAME_FIND, IDC_ADDRBK_COMBO_CONT, IDH_WAB_GROUPS_CONTACTS_FOLDER, 0,0};
// forward declarations
INT_PTR CALLBACK fnAddress(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
BOOL SetAddressBookUI(HWND hDlg, LPADDRESS_PARMS lpAP);
void FillListFromCurrentContainer(HWND hDlg, LPADDRESS_PARMS lpAP);
BOOL FillWells(HWND hDlg, LPADRLIST lpAdrList, LPADRPARM lpAdrParms, LPRECIPIENT_INFO * lppListTo, LPRECIPIENT_INFO * lppListCC, LPRECIPIENT_INFO * lppListBCC);
BOOL ListDeleteItem(HWND hDlg, int CtlID, LPRECIPIENT_INFO * lppList);
BOOL ListAddItem(HWND hDlg, HWND hWndAddr, int CtlID, LPRECIPIENT_INFO * lppList, ULONG RecipientType);
void UpdateLVItems(HWND hWndLV,LPTSTR lpszName);
void ShowAddrBkLVProps(LPIAB lpIAB, HWND hDlg, HWND hWndAddr, LPADDRESS_PARMS lpAP, LPFILETIME lpftLast);
HRESULT HrUpdateAdrListEntry( LPADRBOOK lpIAB, LPENTRYID lpEntryID, ULONG cbEntryID, ULONG ulFlags, LPADRLIST * lppAdrList);
enum _AddressDialogReturnValues{ ADDRESS_RESET = 0, //Blank initialization value
ADDRESS_CANCEL, ADDRESS_OK,};
//$$/////////////////////////////////////////////////////////////////////////////////////////
//
// FillContainerCombo - Fills the container combo with container names
//
/////////////////////////////////////////////////////////////////////////////////////////////
void FillContainerCombo(HWND hWndCombo, LPIAB lpIAB){ ULONG iolkci, colkci; OlkContInfo *rgolkci; int nPos, nDefault=0; LPPTGDATA lpPTGData=GetThreadStoragePointer(); // Clear out the combo
SendMessage(hWndCombo, CB_RESETCONTENT, 0, 0);
Assert(lpIAB);
EnterCriticalSection(&lpIAB->cs); if(pt_bIsWABOpenExSession || bIsWABSessionProfileAware(lpIAB)) { colkci = pt_bIsWABOpenExSession ? lpIAB->lpPropertyStore->colkci : lpIAB->cwabci; Assert(colkci); rgolkci = lpIAB->lpPropertyStore->colkci ? lpIAB->lpPropertyStore->rgolkci : lpIAB->rgwabci; Assert(rgolkci);
// Add the multiple folders here
for(iolkci = 0; iolkci < colkci; iolkci++) { nPos = (int) SendMessage(hWndCombo, CB_ADDSTRING, 0, (LPARAM) rgolkci[iolkci].lpszName); if(nPos != CB_ERR) SendMessage(hWndCombo, CB_SETITEMDATA, (WPARAM)nPos, (LPARAM) (DWORD_PTR)(iolkci==0 ? NULL : rgolkci[iolkci].lpEntryID)); if( bIsThereACurrentUser(lpIAB) && !lstrcmpi(lpIAB->lpWABCurrentUserFolder->lpFolderName, rgolkci[iolkci].lpszName) &&//folder names are unique
nPos != CB_ERR) { nDefault = nPos; } } } LeaveCriticalSection(&lpIAB->cs); SendMessage(hWndCombo, CB_SETCURSEL, (WPARAM) nDefault, 0);}
//$$*------------------------------------------------------------------------
//| IAddrBook::Advise::OnNotify handler
//|
//*------------------------------------------------------------------------
ULONG AddrAdviseOnNotify(LPVOID lpvContext, ULONG cNotif, LPNOTIFICATION lpNotif){ LPADDRESS_PARMS lpAP = (LPADDRESS_PARMS) lpvContext;
DebugTrace( TEXT("+++ AddrAdviseOnNotify ===\n"));
if(lpAP->bDeferNotification) { DebugTrace( TEXT("+++ Advise Defered ===\n")); lpAP->bDeferNotification = FALSE; return S_OK; } if(!lpAP->bDontRefresh) { DebugTrace( TEXT("+++ Calling FillListFromCurrentContainer ===\n")); FillListFromCurrentContainer(lpAP->hDlg, lpAP); }
return S_OK;}
/////////////////////////////////////////////////////////////////////////////////
//
// ShowAddressUI - does some parameter checking and calls the PropertySheets
//
//
//
/////////////////////////////////////////////////////////////////////////////////
HRESULT HrShowAddressUI(IN LPADRBOOK lpIAB, IN HANDLE hPropertyStore, IN ULONG_PTR * lpulUIParam, IN LPADRPARM lpAdrParms, IN LPADRLIST *lppAdrList){ HRESULT hr = E_FAIL; //ADDRESS_PARMS AP = {0};
LPADDRESS_PARMS lpAP = NULL; TCHAR szBuf[MAX_UI_STR];
HWND hWndParent = NULL; int nRetVal = 0; int DialogState = 0;
//Addref the AdrBook object to make sure it stays valid throughout ..
// Remember to release before leaving ...
// NOTE: Must be before any jumps to out!
UlAddRef(lpIAB);
// if no common control, exit
if (NULL == ghCommCtrlDLLInst) { hr = ResultFromScode(MAPI_E_UNCONFIGURED); goto out; }
if (lpulUIParam) hWndParent = (HWND) *lpulUIParam;
if ( // Can't pick-user with wells
((lpAdrParms->ulFlags & ADDRESS_ONE) && (lpAdrParms->cDestFields != 0)) || // cDestFields has limited for tier 0.5
(lpAdrParms->cDestFields > 3) || // Cant pick user without an input lpAdrList
//((lpAdrParms->ulFlags & ADDRESS_ONE) && (*lppAdrList == NULL)) ||
((lpAdrParms->ulFlags & DIALOG_SDI) && (lpAdrParms->cDestFields != 0)) ) { hr = MAPI_E_INVALID_PARAMETER; goto out; }
//
// The possible states of this dialog box are
// 1. Select recipients Wells shown, returns an AdrList of picked up entries, Cant delete entries
// 2. Select a single user, No wells shown, single selection, cannot delete, must have input Adrlist
// 3. Open for browsing only, multiple selection, can create delete, create, view details
// Determine what the dialog state is
if (lpAdrParms->cDestFields > 0) { //lpAP->DialogState = STATE_SELECT_RECIPIENTS;
DialogState = STATE_SELECT_RECIPIENTS; } else if (lpAdrParms->ulFlags & ADDRESS_ONE) { DialogState = STATE_PICK_USER; } else if (lpAdrParms->ulFlags & DIALOG_MODAL) { DialogState = STATE_BROWSE_MODAL; } else if (lpAdrParms->ulFlags & DIALOG_SDI) { DialogState = STATE_BROWSE; }
if (DialogState == STATE_BROWSE) { // Show the browse window and leave
//
HWND hWndAB = NULL; hWndAB = hCreateAddressBookWindow( lpIAB, hWndParent, lpAdrParms); if (hWndAB) { *lpulUIParam = (ULONG_PTR) hWndAB; hr = S_OK; } goto out;
}
lpAP = LocalAlloc(LMEM_ZEROINIT, sizeof(ADDRESS_PARMS));
if (!lpAP) { hr = MAPI_E_NOT_ENOUGH_MEMORY; goto out; }
lpAP->DialogState = DialogState;
lpAP->lpIAB = lpIAB; lpAP->lpAdrParms = lpAdrParms; lpAP->lppAdrList = lppAdrList; lpAP->hPropertyStore = hPropertyStore;
ReadRegistrySortInfo((LPIAB)lpIAB, &(lpAP->SortInfo));
lpAP->lpContentsList = NULL;
lpAP->bDontRefresh = FALSE;
lpAP->bLDAPinProgress = FALSE; lpAP->hWaitCur = NULL;
HrAllocAdviseSink(&AddrAdviseOnNotify, (LPVOID) lpAP, &(lpAP->lpAdviseSink));
nRetVal = (int) DialogBoxParam( hinstMapiX, MAKEINTRESOURCE(IDD_DIALOG_ADDRESSBOOK), hWndParent, fnAddress, (LPARAM) lpAP); switch(nRetVal) { case -1: //some error occured
hr = E_FAIL; break; case ADDRESS_CANCEL: hr = MAPI_E_USER_CANCEL; break; case ADDRESS_OK: default: hr = S_OK; break; }
if(lpAP->lpAdviseSink) { lpAP->lpIAB->lpVtbl->Unadvise(lpAP->lpIAB, lpAP->ulAdviseConnection); lpAP->lpAdviseSink->lpVtbl->Release(lpAP->lpAdviseSink); lpAP->lpAdviseSink = NULL; lpAP->ulAdviseConnection = 0; }
out:
lpIAB->lpVtbl->Release(lpIAB);
LocalFreeAndNull(&lpAP); return hr;}
#define lpAP_lppContentsList (&(lpAP->lpContentsList))
#define lpAP_lppListTo (&(lpAP->lpListTo))
#define lpAP_lppListCC (&(lpAP->lpListCC))
#define lpAP_lppListBCC (&(lpAP->lpListBCC))
#define lpAP_bDontRefresh (lpAP->bDontRefresh)
#define _hWndAddr lpAP->hWndAddr
//$$/////////////////////////////////////////////////////////////////////////////
//
// GetCurrentComboSelection - Get the current selection from the combo
//
/////////////////////////////////////////////////////////////////////////////////
LPSBinary GetCurrentComboSelection(HWND hWndCombo){ int nPos = (int) SendMessage(hWndCombo, CB_GETCURSEL, 0, 0); LPSBinary lpsbCont = NULL;
if(nPos == CB_ERR) nPos = 0; lpsbCont = (LPSBinary) SendMessage(hWndCombo, CB_GETITEMDATA, (WPARAM) nPos, 0); if(CB_ERR == (DWORD_PTR) lpsbCont) lpsbCont = NULL;
return lpsbCont;}//$$/////////////////////////////////////////////////////////////////////////////
//
// FillListFromCurrentContainer - Get the selection from the combo and fill it
//
/////////////////////////////////////////////////////////////////////////////////
void FillListFromCurrentContainer(HWND hDlg, LPADDRESS_PARMS lpAP){ HWND hWndAddr = GetDlgItem(hDlg,IDC_ADDRBK_LIST_ADDRESSES); LPPTGDATA lpPTGData=GetThreadStoragePointer(); LPSBinary lpsbCont = NULL;
if(pt_bIsWABOpenExSession || bIsWABSessionProfileAware((LPIAB)lpAP->lpIAB)) { HWND hWndCombo = GetDlgItem(hDlg, IDC_ADDRBK_COMBO_CONT); int nPos = (int) SendMessage(hWndCombo, CB_GETCURSEL, 0, 0);
if(nPos != CB_ERR) { // Refill the combo in case the folder list changed
FillContainerCombo(hWndCombo, (LPIAB)lpAP->lpIAB); nPos = (int) SendMessage(hWndCombo, CB_SETCURSEL, (WPARAM) nPos, 0); } lpsbCont = GetCurrentComboSelection(hWndCombo); }
HrGetWABContents( hWndAddr, lpAP->lpIAB, lpsbCont, lpAP->SortInfo, lpAP_lppContentsList);}
extern BOOL APIENTRY_16 fnFolderDlgProc(HWND hDlg, UINT message, UINT wParam, LPARAM lParam);
/////////////////////////////////////////////////////////////////////////////////
//
// fnAddress - the PropertySheet Message Handler
//
//
//
/////////////////////////////////////////////////////////////////////////////////
INT_PTR CALLBACK fnAddress(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam){ static FILETIME ftLast = {0};
LPADDRESS_PARMS lpAP = (LPADDRESS_PARMS ) GetWindowLongPtr(hDlg,DWLP_USER);
switch(message) { case WM_INITDIALOG: SetWindowLongPtr(hDlg,DWLP_USER,lParam); //Save this for future reference
lpAP = (LPADDRESS_PARMS) lParam;
lpAP->hWndAddr = GetDlgItem(hDlg,IDC_ADDRBK_LIST_ADDRESSES); lpAP->hDlg = hDlg; lpAP_bDontRefresh = FALSE;
lpAP->nContextID = IDC_ADDRBK_LIST_ADDRESSES;
SetAddressBookUI(hDlg,lpAP);
// if this is a pick-user dialog, need to have the names by
// first name so we can find the closest match ..
if(lpAP->DialogState == STATE_PICK_USER) (lpAP->SortInfo).bSortByLastName = FALSE;
FillListFromCurrentContainer(hDlg, lpAP);
if (lpAP->DialogState == STATE_SELECT_RECIPIENTS) { FillWells(hDlg,*(lpAP->lppAdrList),(lpAP->lpAdrParms),lpAP_lppListTo,lpAP_lppListCC,lpAP_lppListBCC);
// we want to highlight the first item in the list
if (ListView_GetItemCount(_hWndAddr) > 0) LVSelectItem( _hWndAddr, 0); } else if (lpAP->DialogState == STATE_PICK_USER && *(lpAP->lppAdrList) ) { // if this is a pick user dialog, then try to match the supplied name to the
// closest entry in the List Box
if (ListView_GetItemCount(_hWndAddr) > 0) { LPTSTR lpszDisplayName = NULL; ULONG i;
// Scan only the first entry in the lpAdrList for a display name
for(i=0;i< (*(lpAP->lppAdrList))->aEntries[0].cValues;i++) { ULONG ulPropTag = PR_DISPLAY_NAME; if(!(lpAP->lpAdrParms->ulFlags & MAPI_UNICODE)) ulPropTag = CHANGE_PROP_TYPE(ulPropTag, PT_STRING8); if((*(lpAP->lppAdrList))->aEntries[0].rgPropVals[i].ulPropTag == ulPropTag) { SET_UNICODE_STR(lpszDisplayName, (*(lpAP->lppAdrList))->aEntries[0].rgPropVals[i].Value.LPSZ,lpAP->lpAdrParms); break; } }
if (lpszDisplayName) { // We have Something to search for
TCHAR szBuf[MAX_UI_STR]; ULONG nLen; LV_FINDINFO lvF = {0};
// Typically, we are not going to get a full match ...
// Instead we want to make a partial match on disply name.
// The ListViewFindItem does an exact partial match if the supplied
// string matches the first few entries of an existing item
// Hence, to obtain a semi-partial match, we start with the
// original Display Name working our way backwards from last
// character to first character until we get a match or run
// out of characters.
int iItemIndex = -1; nLen = lstrlen(lpszDisplayName);
if (nLen >= CharSizeOf(szBuf)) nLen = CharSizeOf(szBuf)-1; lvF.flags = LVFI_PARTIAL | LVFI_STRING;
while((nLen > 0) && (iItemIndex == -1)) { nLen = TruncatePos(lpszDisplayName, nLen); if (nLen==0) break;
CopyMemory(szBuf, lpszDisplayName, sizeof(TCHAR)*nLen); szBuf[nLen] = '\0';
lvF.psz = szBuf; iItemIndex = ListView_FindItem(_hWndAddr,-1, &lvF);
nLen--; }
// Set focus to the selected item or to the first item in the list
if (iItemIndex < 0) iItemIndex = 0;
LVSelectItem(_hWndAddr, iItemIndex);
FREE_UNICODE_STR(lpszDisplayName, (*(lpAP->lppAdrList))->aEntries[0].rgPropVals[i].Value.LPSZ); } } }
if(lpAP->lpAdviseSink) { // Register for notifications
lpAP->lpIAB->lpVtbl->Advise(lpAP->lpIAB, 0, NULL, fnevObjectModified, lpAP->lpAdviseSink, &lpAP->ulAdviseConnection); }
if (ListView_GetSelectedCount(_hWndAddr) <= 0) LVSelectItem(_hWndAddr, 0); // if we want the user to pick something actively, we disable OK until they click on something
// or do something specific ..
if( lpAP->DialogState == STATE_PICK_USER ) { EnableWindow(GetDlgItem(hDlg, IDOK), FALSE); SendMessage (hDlg, DM_SETDEFID, IDCANCEL, 0); }
SetFocus(GetDlgItem(hDlg,IDC_ADDRBK_EDIT_QUICKFIND)); return FALSE;// return TRUE;
break;
case WM_SYSCOLORCHANGE: //Forward any system changes to the list view
SendMessage(_hWndAddr, message, wParam, lParam); SetColumnHeaderBmp(_hWndAddr, lpAP->SortInfo); break;
case WM_HELP: WABWinHelp(((LPHELPINFO)lParam)->hItemHandle, g_szWABHelpFileName, HELP_WM_HELP, (DWORD_PTR)(LPSTR) rgAddrHelpIDs ); break;
case WM_SETCURSOR: if (lpAP->bLDAPinProgress) { SetCursor(lpAP->hWaitCur); SetWindowLongPtr(hDlg, DWLP_MSGRESULT, MAKELONG(TRUE, 0)); return(TRUE); } break;
case WM_COMMAND: switch(GET_WM_COMMAND_CMD(wParam,lParam)) //check the notification code
{ case CBN_SELCHANGE: FillListFromCurrentContainer(hDlg, lpAP); break; } switch(GET_WM_COMMAND_ID(wParam, lParam)) { default: if (lpAP->nContextID != -1) { LRESULT fRet = FALSE; lpAP_bDontRefresh = TRUE; fRet = ProcessActionCommands((LPIAB) lpAP->lpIAB,_hWndAddr, hDlg, message, wParam, lParam); lpAP_bDontRefresh = FALSE; return fRet; } break;
case IDC_ADDRBK_BUTTON_DELETE: if(!lpAP->bLDAPinProgress) { lpAP->bLDAPinProgress = TRUE; lpAP_bDontRefresh = TRUE; DeleteSelectedItems(_hWndAddr, lpAP->lpIAB, lpAP->hPropertyStore, &ftLast); lpAP->bDeferNotification = TRUE; lpAP_bDontRefresh = FALSE; lpAP->bLDAPinProgress = FALSE; } break;
case IDM_LVCONTEXT_DELETE: if(!lpAP->bLDAPinProgress) { lpAP->bLDAPinProgress = TRUE; switch(lpAP->nContextID) { case IDC_ADDRBK_LIST_ADDRESSES: lpAP_bDontRefresh = TRUE; DeleteSelectedItems(_hWndAddr, lpAP->lpIAB, lpAP->hPropertyStore, &ftLast); lpAP->bDeferNotification = TRUE; lpAP_bDontRefresh = FALSE; break; case IDC_ADDRBK_LIST_TO: ListDeleteItem(hDlg, IDC_ADDRBK_LIST_TO, lpAP_lppListTo); break; case IDC_ADDRBK_LIST_CC: ListDeleteItem(hDlg, IDC_ADDRBK_LIST_CC, lpAP_lppListCC); break; case IDC_ADDRBK_LIST_BCC: ListDeleteItem(hDlg, IDC_ADDRBK_LIST_BCC, lpAP_lppListBCC); break; default: break; } lpAP->bLDAPinProgress = FALSE; } break;
case IDM_LVCONTEXT_COPY: lpAP_bDontRefresh = TRUE; HrCopyItemDataToClipboard(hDlg, lpAP->lpIAB, GetDlgItem(hDlg,lpAP->nContextID)); lpAP_bDontRefresh = FALSE; break;
case IDM_LVCONTEXT_PROPERTIES: case IDC_ADDRBK_BUTTON_PROPS: if(!lpAP->bLDAPinProgress) { lpAP->bLDAPinProgress = TRUE; if (lpAP->nContextID != -1) { lpAP_bDontRefresh = TRUE; ShowAddrBkLVProps((LPIAB)lpAP->lpIAB, hDlg, GetDlgItem(hDlg, lpAP->nContextID), lpAP, &ftLast); lpAP->bDeferNotification = TRUE; lpAP_bDontRefresh = FALSE; } lpAP->bLDAPinProgress = FALSE; } break;
/* Uncomment to enable NEW_FOLDER functionality from this dialog
case IDM_LVCONTEXT_NEWFOLDER: { TCHAR sz[MAX_UI_STR]; LPTSTR lpsz = NULL; *sz = '\0'; if( IDCANCEL != DialogBoxParam( hinstMapiX, MAKEINTRESOURCE(IDD_DIALOG_FOLDER), hDlg, fnFolderDlgProc, (LPARAM) sz) && lstrlen(sz)) { // if we're here we have a valid folder name ..
if(!HR_FAILED(HrCreateNewFolder((LPIAB)lpAP->lpIAB, sz, NULL, FALSE, NULL, NULL))) { int i,nTotal; HWND hWndC = GetDlgItem(hDlg, IDC_ADDRBK_COMBO_CONT); // Fill in the Combo with the container names
FillContainerCombo(hWndC, (LPIAB)lpAP->lpIAB); nTotal = SendMessage(hWndC, CB_GETCOUNT, 0, 0); if(nTotal != CB_ERR) { // Find the item we just added in the combo and set the sel on it
TCHAR szC[MAX_UI_STR]; for(i=0;i<nTotal;i++) { *szC = '\0'; SendMessage(hWndC, CB_GETLBTEXT, (WPARAM) i, (LPARAM) szC); if(!lstrcmpi(sz, szC)) { SendMessage(hWndC, CB_SETCURSEL, (WPARAM) i, 0); break; } } } FillListFromCurrentContainer(hDlg, lpAP); } } } break;*/
case IDM_LVCONTEXT_NEWCONTACT: case IDC_ADDRBK_BUTTON_NEW: // only difference between contact and group is the object being added
case IDM_LVCONTEXT_NEWGROUP: case IDC_ADDRBK_BUTTON_NEWGROUP: if(!lpAP->bLDAPinProgress) { ULONG cbEID = 0; LPENTRYID lpEID = NULL; int nID = GET_WM_COMMAND_ID(wParam, lParam); ULONG ulObjType = (nID == IDM_LVCONTEXT_NEWCONTACT || nID == IDC_ADDRBK_BUTTON_NEW) ? MAPI_MAILUSER : MAPI_DISTLIST; LPSBinary lpsbContEID = NULL;
if(bIsWABSessionProfileAware((LPIAB)lpAP->lpIAB)) lpsbContEID = GetCurrentComboSelection(GetDlgItem(hDlg,IDC_ADDRBK_COMBO_CONT));
lpAP->bLDAPinProgress = TRUE; lpAP_bDontRefresh = TRUE;
AddNewObjectToListViewEx( lpAP->lpIAB, _hWndAddr, NULL, NULL, lpsbContEID, ulObjType, &(lpAP->SortInfo), lpAP_lppContentsList, &ftLast, &cbEID, &lpEID);
FreeBufferAndNull(&lpEID); SetFocus(_hWndAddr); lpAP->bDeferNotification = TRUE; lpAP_bDontRefresh = FALSE; lpAP->bLDAPinProgress = FALSE; } break;
case IDM_LVCONTEXT_ADDWELL1: case IDC_ADDRBK_BUTTON_TO: if(!lpAP->bLDAPinProgress) { ULONG ulMapiTo = MAPI_TO; lpAP->bLDAPinProgress = TRUE; if ((lpAP->lpAdrParms->cDestFields > 0) && (lpAP->lpAdrParms->lpulDestComps)) { ulMapiTo = lpAP->lpAdrParms->lpulDestComps[0]; } if(ListAddItem(hDlg, _hWndAddr, IDC_ADDRBK_LIST_TO, lpAP_lppListTo, ulMapiTo)) SendMessage (hDlg, DM_SETDEFID, IDOK/*IDC_ADDRBK_BUTTON_OK*/, 0); lpAP->bLDAPinProgress = FALSE; } break;
case IDM_LVCONTEXT_ADDWELL2: case IDC_ADDRBK_BUTTON_CC: if(!lpAP->bLDAPinProgress) { ULONG ulMapiCC = MAPI_CC; lpAP->bLDAPinProgress = TRUE; if ((lpAP->lpAdrParms->cDestFields > 0) && (lpAP->lpAdrParms->lpulDestComps)) { ulMapiCC = lpAP->lpAdrParms->lpulDestComps[1]; } if(ListAddItem(hDlg, _hWndAddr, IDC_ADDRBK_LIST_CC, lpAP_lppListCC, ulMapiCC)) SendMessage (hDlg, DM_SETDEFID, IDOK/*IDC_ADDRBK_BUTTON_OK*/, 0); lpAP->bLDAPinProgress = FALSE; } break;
case IDM_LVCONTEXT_ADDWELL3: case IDC_ADDRBK_BUTTON_BCC: if(!lpAP->bLDAPinProgress) { ULONG ulMapiBCC = MAPI_BCC; lpAP->bLDAPinProgress = TRUE; if ((lpAP->lpAdrParms->cDestFields > 0) && (lpAP->lpAdrParms->lpulDestComps)) { ulMapiBCC = lpAP->lpAdrParms->lpulDestComps[2]; } if(ListAddItem(hDlg, _hWndAddr, IDC_ADDRBK_LIST_BCC, lpAP_lppListBCC, ulMapiBCC)) SendMessage (hDlg, DM_SETDEFID, IDOK/*IDC_ADDRBK_BUTTON_OK*/, 0); lpAP->bLDAPinProgress = FALSE; } break;
case IDM_LVCONTEXT_FIND: case IDC_ADDRBK_BUTTON_FIND: if(!lpAP->bLDAPinProgress) { ADRPARM_FINDINFO apfi = {0}; LPADRPARM_FINDINFO lpapfi = NULL; ULONG ulOldFlags = lpAP->lpAdrParms->ulFlags; lpAP->bLDAPinProgress = TRUE;
apfi.DialogState = lpAP->DialogState;
if (lpAP->DialogState==STATE_SELECT_RECIPIENTS) { apfi.lpAdrParms = lpAP->lpAdrParms; apfi.lppTo = lpAP_lppListTo; apfi.lppCC = lpAP_lppListCC; apfi.lppBCC = lpAP_lppListBCC; lpapfi = &apfi; } else if (lpAP->DialogState == STATE_PICK_USER) { TCHAR sz[MAX_UI_STR]; LPTSTR lpsz = NULL;
LoadString(hinstMapiX, idsPickUserSelect, sz, CharSizeOf(sz)); lpsz = (LPTSTR) sz;
apfi.lpAdrParms = lpAP->lpAdrParms; apfi.lpAdrParms->cDestFields = 1; apfi.lpAdrParms->lppszDestTitles = &lpsz; // <TBD> use resource
apfi.lpAdrParms->ulFlags |= MAPI_UNICODE; apfi.cbEntryID = 0; apfi.lpEntryID = NULL; apfi.nRetVal = 0; lpapfi = &apfi; { // Setup the Find persistent info to show the name we are trying to resolve
ULONG i; LPPTGDATA lpPTGData=GetThreadStoragePointer(); for(i=0;i<ldspMAX;i++) { pt_LDAPsp.szData[i][0] = TEXT('\0'); } if(*(lpAP->lppAdrList)) { for(i=0;i<(*(lpAP->lppAdrList))->aEntries[0].cValues;i++) { ULONG ulPropTag = PR_DISPLAY_NAME; if(!(lpAP->lpAdrParms->ulFlags & MAPI_UNICODE)) ulPropTag = CHANGE_PROP_TYPE(ulPropTag, PT_STRING8); if ((*(lpAP->lppAdrList))->aEntries[0].rgPropVals[i].ulPropTag == ulPropTag) { LPTSTR lpTitle = NULL; SET_UNICODE_STR(lpTitle, (*(lpAP->lppAdrList))->aEntries[0].rgPropVals[i].Value.LPSZ,lpAP->lpAdrParms); StrCpyN(pt_LDAPsp.szData[ldspDisplayName], lpTitle, ARRAYSIZE(pt_LDAPsp.szData[ldspDisplayName])); FREE_UNICODE_STR(lpTitle, (*(lpAP->lppAdrList))->aEntries[0].rgPropVals[i].Value.LPSZ); break; } } } } }
//lpAP_bDontRefresh = TRUE;
HrShowSearchDialog(lpAP->lpIAB, hDlg, lpapfi, (LPLDAPURL) NULL, &(lpAP->SortInfo));
//lpAP_bDontRefresh = FALSE;
lpAP->bLDAPinProgress = FALSE;
// reset
lpAP->lpAdrParms->ulFlags = ulOldFlags;
if (lpAP->DialogState == STATE_PICK_USER) { // Reset these fake values
lpAP->lpAdrParms->cDestFields = 0; lpAP->lpAdrParms->lppszDestTitles = NULL; // <TBD> use resource
// If the above dialog was CANCELed or CLOSEd, we dont do anything
// If the above dialog was closed with the Use button, then we basically
// have the person we were looking for .. we will just return that name
// and EntryID because that is all we need to return
if((lpapfi->nRetVal == SEARCH_USE) && lpapfi->lpEntryID && lpapfi->cbEntryID) { HCURSOR hOldCur = SetCursor(LoadCursor(NULL, IDC_WAIT));
// Prevent the user from doing anything on this window ..
EnableWindow(hDlg, FALSE);
// Figure out what to do here ...
// We could add a hidden item to the listview, select it and send
// an ok message to the dialog which would then do the needful.
if(HR_FAILED(HrUpdateAdrListEntry( lpAP->lpIAB, lpapfi->lpEntryID, lpapfi->cbEntryID, (lpAP->lpAdrParms->ulFlags & MAPI_UNICODE)?MAPI_UNICODE:0, lpAP->lppAdrList))) { lpAP->nRetVal = -1; } else { lpAP->nRetVal = ADDRESS_OK; } LocalFreeAndNull(&(lpapfi->lpEntryID)); lpapfi->cbEntryID = 0; // Since we've done our processing, we'll fall thru to
// the cancel dialog
SetCursor(hOldCur); SendMessage (hDlg, WM_COMMAND, (WPARAM) IDC_ADDRBK_BUTTON_CANCEL, 0); }
}
} break;
case IDC_ADDRBK_EDIT_QUICKFIND: if(!lpAP->bLDAPinProgress) { lpAP->bLDAPinProgress = TRUE; switch(HIWORD(wParam)) //check the notification code
{ case EN_CHANGE: //edit box changed
/***/ DoLVQuickFind((HWND)lParam,_hWndAddr); /***
DoLVQuickFilter(lpAP->lpIAB, (HWND)lParam, _hWndAddr, &(lpAP->SortInfo), AB_FUZZY_FIND_NAME | AB_FUZZY_FIND_EMAIL, 1, lpAP_lppContentsList); ***/ break; } lpAP->bLDAPinProgress = FALSE; } break;
case IDOK: case IDC_ADDRBK_BUTTON_OK: if(!lpAP->bLDAPinProgress) { HCURSOR hOldCur;
lpAP->nRetVal = ADDRESS_OK;
lpAP->hWaitCur = LoadCursor(NULL, IDC_WAIT); hOldCur = SetCursor(lpAP->hWaitCur); lpAP->bLDAPinProgress = TRUE; SetWindowLongPtr(hDlg, DWLP_MSGRESULT, MAKELONG(TRUE, 0));
//ShowWindow(hDlg, SW_HIDE);
//EnableWindow(hDlg, FALSE);
//SetWindowPos(hDlg, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
EnableWindow(GetDlgItem(hDlg, IDOK), FALSE); EnableWindow(GetDlgItem(hDlg, IDCANCEL), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_ADDRBK_BUTTON_FIND), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_ADDRBK_BUTTON_TO), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_ADDRBK_BUTTON_CC), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_ADDRBK_BUTTON_BCC), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_ADDRBK_LIST_TO), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_ADDRBK_LIST_CC), FALSE); EnableWindow(GetDlgItem(hDlg, IDC_ADDRBK_LIST_BCC), FALSE); EnableWindow(_hWndAddr, FALSE);
//
// Do TEXT("OK") stuff here and then Fall Thru to the cancel stuff
// in PSN_RESET where we clean up
//
// if the ADDRESS_ONE flag was set we're supposed to return the
// selected entry
//
// else if wells were displayed we return the recipients in the AdrList
//
// else we dont change the AdrList ..
//
if (lpAP->DialogState == STATE_PICK_USER) { // We have been asked to return an entry in the LpAdrList,
// we dont care about recipient type - just Display Name and EntryID
// First check if anything is selected at all
int iItemIndex = ListView_GetNextItem(_hWndAddr,-1,LVNI_SELECTED); if (iItemIndex != -1) { LPRECIPIENT_INFO lpItem = GetItemFromLV(_hWndAddr, iItemIndex); if (lpItem) { if(HR_FAILED(HrUpdateAdrListEntry( lpAP->lpIAB, lpItem->lpEntryID, lpItem->cbEntryID, (lpAP->lpAdrParms->ulFlags & MAPI_UNICODE)?MAPI_UNICODE:0, lpAP->lppAdrList))) { lpAP->nRetVal = -1; } } } } else if ((lpAP->DialogState==STATE_SELECT_RECIPIENTS) && ((*lpAP_lppListTo)||(*lpAP_lppListCC)||(*lpAP_lppListBCC))) { //
//if user selected something in the TO/CC wells, we want to return
//a relevant AdrList back ...
//
ULONG ulcEntryCount = 0; LPRECIPIENT_INFO lpItem = NULL;
//
// get a count of how many elements we need to return
//
lpItem = (*lpAP_lppListTo); while(lpItem) { ulcEntryCount++; lpItem = lpItem->lpNext; }
lpItem = (*lpAP_lppListCC); while(lpItem) { ulcEntryCount++; lpItem = lpItem->lpNext; }
lpItem = (*lpAP_lppListBCC); while(lpItem) { ulcEntryCount++; lpItem = lpItem->lpNext; }
if (ulcEntryCount != 0) { ULONG nIndex = 0; LPADRENTRY lpAdrEntryTemp = NULL; LPADRLIST lpAdrList = NULL; SCODE sc; BOOL bProcessingCC = FALSE;
//
// if there was something in the passed in AdrList, free it and
// create a new list
//
if(!FAILED(sc = MAPIAllocateBuffer( sizeof(ADRLIST) + ulcEntryCount * sizeof(ADRENTRY), &lpAdrList))) { lpAdrList->cEntries = ulcEntryCount;
nIndex = 0;
// Start getting items from the TO list
lpItem = (*lpAP_lppListTo);
while(nIndex < ulcEntryCount) { if (lpItem == NULL) { if (bProcessingCC == FALSE) { lpItem = (*lpAP_lppListCC); bProcessingCC = TRUE; } else lpItem = (*lpAP_lppListBCC); }
if (lpItem != NULL) { LPSPropValue rgProps = NULL; ULONG cValues = 0; LPSPropValue lpPropArrayNew = NULL; ULONG cValuesNew = 0; LPTSTR lpszTemp = NULL; LPVOID lpbTemp = NULL; ULONG i = 0; SCODE sc; HRESULT hr = hrSuccess;
//reset hr
hr = hrSuccess;
// We are walking through our linked lists representing the TO and CC
// selected recipients. We want to return proper set of existing props
// for all the resolved users and the passed in set of props for the
// unresolved user. Hence we compare to see what we can get for each
// individual user. For unresolved users, the only distinctive criteria is
// their display name .. we have no other information .. <TBD> this is
// problematic because if there are 2 entries in the input adrlist with the
// same unresolved display name, even if they have difference rgPropVals
// we might end up giving them identical ones back .... what to do .. <TBD>
// Items that have entry ids are resolved ... items that dont have entryids
// are not resolved ...
if (lpItem->cbEntryID != 0) { // if this was an item from the original list .. we dont really
// want to mess with it irrespective of whether it is a resolved
// or unresolved entry.
// However, if this is a new entry, then we want to get its
// minimum props from the store ...
if (lpItem->ulOldAdrListEntryNumber == 0) {
//resolved entry
hr = HrGetPropArray(lpAP->lpIAB, (LPSPropTagArray) &ptaResolveDefaults, lpItem->cbEntryID, lpItem->lpEntryID, (lpAP->lpAdrParms->ulFlags & MAPI_UNICODE) ? MAPI_UNICODE : 0, &cValues, &rgProps); } else { rgProps = NULL; cValues = 0; }
if (!HR_FAILED(hr)) { if(lpItem->ulOldAdrListEntryNumber != 0) { ULONG index = lpItem->ulOldAdrListEntryNumber - 1; //remember the increment-by-one ..
// This is from the original entry list ...
// We want to merge the newly generated properties with the old
// original properties .. the original properties will include a
// PR_RECIPIENT_TYPE (or this entry would have been rejected)
sc = ScMergePropValues( (*(lpAP->lppAdrList))->aEntries[index].cValues, (*(lpAP->lppAdrList))->aEntries[index].rgPropVals, cValues, rgProps, &cValuesNew, &lpPropArrayNew);
if (sc != S_OK) { // If errors then dont merge .. just take the temp set of props
// in rgProps
if (lpPropArrayNew) MAPIFreeBuffer(lpPropArrayNew); lpPropArrayNew = rgProps; cValuesNew = cValues; lpAP->nRetVal = -1; } else { // merged successfully, discard the temp sets of props
if (rgProps) MAPIFreeBuffer(rgProps); } } else { // totally new item
// we have to give it a valid PR_RECIPIENT_TYPE
// so create a new one and merge it with the above props
SPropValue Prop = {0}; Prop.ulPropTag = PR_RECIPIENT_TYPE; Prop.Value.l = lpItem->ulRecipientType;
sc = ScMergePropValues( 1, &Prop, cValues, rgProps, &cValuesNew, &lpPropArrayNew); if (sc != S_OK) { // oops this failed
if (lpPropArrayNew) MAPIFreeBuffer(lpPropArrayNew); lpPropArrayNew = NULL; lpAP->nRetVal = -1; }
//free rgProps
if (rgProps) MAPIFreeBuffer(rgProps);
} // end have previous adr list items
// [PaulHi] 2/15/99 Make sure that the new property string
// values are converted to ANSI if our client is non-UNICODE.
if ( !FAILED(sc) && !(lpAP->lpAdrParms->ulFlags & MAPI_UNICODE) && lpPropArrayNew ) { sc = ScConvertWPropsToA((LPALLOCATEMORE) (&MAPIAllocateMore), lpPropArrayNew, cValuesNew, 0); if (FAILED(sc)) { if (lpPropArrayNew) MAPIFreeBuffer(lpPropArrayNew); lpPropArrayNew = NULL; lpAP->nRetVal = -1; } }
} // end GetProps succeeded
} else { // this is an unresolved entry
// we need to get its original sets of props from the original AdrList
if (lpItem->ulOldAdrListEntryNumber == 0) { // ouch - this kind of error shouldnt have happened
DebugPrintError(( TEXT("Address: Unresolved entry has no index number!!!\n"))); lpAP->nRetVal = -1; //error code
} else { ULONG cb = 0; ULONG index = lpItem->ulOldAdrListEntryNumber - 1; //remember to decrement the +1 increment
cValuesNew = (*(lpAP->lppAdrList))->aEntries[index].cValues; // copy over the props from our old array into a new one
if (!(FAILED(sc = ScCountProps( cValuesNew, (*(lpAP->lppAdrList))->aEntries[index].rgPropVals, &cb)))) { if (!(FAILED(sc = MAPIAllocateBuffer(cb, &lpPropArrayNew)))) {
if (FAILED(sc = ScCopyProps( cValuesNew, (*(lpAP->lppAdrList))->aEntries[index].rgPropVals, lpPropArrayNew, NULL))) { DebugPrintError(( TEXT("Address: ScCopyProps fails!!!\n"))); lpAP->nRetVal = -1; } } else { lpAP->nRetVal = -1; } } else { lpAP->nRetVal = -1; } } } // At this point, if we've still got no errors,
// we should have a valid lpPropArrayNew and cValuesNew which we should
// be able to add to our new AdrList
if (lpAP->nRetVal != -1) { lpAdrList->aEntries[nIndex].cValues = cValuesNew; lpAdrList->aEntries[nIndex].rgPropVals = lpPropArrayNew; } else { // some error
if (lpPropArrayNew) { MAPIFreeBuffer(lpPropArrayNew); lpPropArrayNew = NULL; } }
lpItem = lpItem->lpNext; nIndex++; } }
if (*(lpAP->lppAdrList)) { FreePadrlist(*(lpAP->lppAdrList)); }
*(lpAP->lppAdrList) = lpAdrList;
} }
} else if ((lpAP->DialogState==STATE_SELECT_RECIPIENTS) && ((*lpAP_lppListTo)==NULL) && ((*lpAP_lppListCC)==NULL) && ((*lpAP_lppListBCC)==NULL)) { // we were asked to select recipients but if these pointers are null
// then the user deleted the entries in the wells and we thus dont
// want to return anything. So free the lpaddrlist
// and make it NULL
if (*(lpAP->lppAdrList)) { // Bug 27483 - dont NULL the lpAdrList - just set cEntries to 0
ULONG iEntry = 0; for (iEntry = 0; iEntry < (*(lpAP->lppAdrList))->cEntries; iEntry++) { MAPIFreeBuffer((*(lpAP->lppAdrList))->aEntries[iEntry].rgPropVals); } (*(lpAP->lppAdrList))->cEntries = 0; } }
//
// Save the sort info to the registry
//
if(lpAP->DialogState != STATE_PICK_USER) WriteRegistrySortInfo((LPIAB)lpAP->lpIAB, lpAP->SortInfo);
lpAP->bLDAPinProgress = FALSE; lpAP->hWaitCur = NULL; SetCursor(hOldCur); } // fall thru to cleanup code
case IDCANCEL: case IDC_ADDRBK_BUTTON_CANCEL: if(!lpAP->bLDAPinProgress) { if ((lpAP->nRetVal != ADDRESS_OK) && // Are we falling thru from above ??
(lpAP->nRetVal != -1) ) // or did someone trigger an error above ??
{ // if not ..
lpAP->nRetVal = ADDRESS_CANCEL; }
if ((*lpAP_lppContentsList)) ClearListView( GetDlgItem(hDlg, IDC_ADDRBK_LIST_ADDRESSES), lpAP_lppContentsList);
if ((*lpAP_lppListTo)) ClearListView( GetDlgItem(hDlg, IDC_ADDRBK_LIST_TO), lpAP_lppListTo);
if ((*lpAP_lppListCC)) ClearListView( GetDlgItem(hDlg, IDC_ADDRBK_LIST_CC), lpAP_lppListCC);
if ((*lpAP_lppListBCC)) ClearListView( GetDlgItem(hDlg, IDC_ADDRBK_LIST_BCC), lpAP_lppListBCC);
lpAP->bLDAPinProgress = FALSE;
EndDialog(hDlg,lpAP->nRetVal);
return TRUE; } break;
} break;
case WM_CLOSE: //treat it like a cancel button
SendMessage (hDlg, WM_COMMAND, (WPARAM) IDC_ADDRBK_BUTTON_CANCEL, 0); break;
case WM_CONTEXTMENU: { int id = GetDlgCtrlID((HWND)wParam); //
//This call to the context menu may generate any one of several
//command messages - for properties and for delete, we need to
//know which List View initiated the command ...
//
lpAP->nContextID = id; switch(id) { case IDC_ADDRBK_LIST_ADDRESSES: if (lpAP->DialogState == STATE_BROWSE_MODAL) ShowLVContextMenu( lvDialogModalABContents, (HWND)wParam, NULL, //GetDlgItem(hDlg, IDC_ADDRBK_COMBO_SHOWNAMES),
lParam, (LPVOID) lpAP->lpAdrParms, lpAP->lpIAB, NULL); else ShowLVContextMenu( lvDialogABContents, (HWND)wParam, NULL, //GetDlgItem(hDlg, IDC_ADDRBK_COMBO_SHOWNAMES),
lParam, (LPVOID) lpAP->lpAdrParms, lpAP->lpIAB, NULL); break;
case IDC_ADDRBK_LIST_TO: ShowLVContextMenu(lvDialogABTo,(HWND)wParam, NULL, lParam, NULL,lpAP->lpIAB, NULL); break; case IDC_ADDRBK_LIST_BCC: ShowLVContextMenu(lvDialogABCC,(HWND)wParam, NULL, lParam, NULL,lpAP->lpIAB, NULL); break; case IDC_ADDRBK_LIST_CC: ShowLVContextMenu(lvDialogABBCC,(HWND)wParam, NULL, lParam, NULL,lpAP->lpIAB, NULL); break; default: //reset it ..
lpAP->nContextID = -1; WABWinHelp((HWND) wParam, g_szWABHelpFileName, HELP_CONTEXTMENU, (DWORD_PTR)(LPVOID) rgAddrHelpIDs ); break; } } break;
case WM_NOTIFY: { LV_DISPINFO * pLvdi = (LV_DISPINFO *)lParam; NM_LISTVIEW * pNm = (NM_LISTVIEW *)lParam;
switch((int) wParam) { case IDC_ADDRBK_LIST_TO: case IDC_ADDRBK_LIST_CC: case IDC_ADDRBK_LIST_BCC: switch(((LV_DISPINFO *)lParam)->hdr.code) { case LVN_KEYDOWN: switch(((LV_KEYDOWN FAR *) lParam)->wVKey) { case VK_DELETE: if ((int) wParam == IDC_ADDRBK_LIST_TO) ListDeleteItem(hDlg, (int) wParam, lpAP_lppListTo); else if ((int) wParam == IDC_ADDRBK_LIST_CC) ListDeleteItem(hDlg, (int) wParam, lpAP_lppListCC); else ListDeleteItem(hDlg, (int) wParam, lpAP_lppListBCC); break; } break;
case NM_SETFOCUS: lpAP->nContextID = GetDlgCtrlID(((NM_LISTVIEW *)lParam)->hdr.hwndFrom); break;
case NM_DBLCLK: //properties of the item ...
lpAP->nContextID = GetDlgCtrlID(((NM_LISTVIEW *)lParam)->hdr.hwndFrom); SendMessage (hDlg, WM_COMMAND, (WPARAM) IDM_LVCONTEXT_PROPERTIES, 0); break;
case NM_CUSTOMDRAW: return ProcessLVCustomDraw(hDlg, lParam, TRUE); break; } break;
case IDC_ADDRBK_LIST_ADDRESSES:
switch(pLvdi->hdr.code) { case LVN_KEYDOWN: switch(((LV_KEYDOWN FAR *) lParam)->wVKey) { case VK_DELETE: if (lpAP->DialogState == STATE_BROWSE_MODAL) SendMessage(hDlg, WM_COMMAND, IDC_ADDRBK_BUTTON_DELETE, 0); break; } break;
case LVN_COLUMNCLICK: SortListViewColumn((LPIAB)lpAP->lpIAB, pNm->hdr.hwndFrom, pNm->iSubItem, &(lpAP->SortInfo), FALSE); break;
case NM_CLICK: case NM_RCLICK: if(lpAP->DialogState == STATE_PICK_USER) { int iItemIndex = ListView_GetNextItem(pNm->hdr.hwndFrom,-1,LVNI_SELECTED); if (iItemIndex == -1) { //Nothing is selected .. dont let them say OK
EnableWindow(GetDlgItem(hDlg,IDOK/*IDC_ADDRBK_BUTTON_OK*/),FALSE); SendMessage (hDlg, DM_SETDEFID, IDCANCEL, 0); } else { EnableWindow(GetDlgItem(hDlg,IDOK/*IDC_ADDRBK_BUTTON_OK*/),TRUE); SendMessage (hDlg, DM_SETDEFID, IDOK, 0); } }
break;
case NM_SETFOCUS: lpAP->nContextID = GetDlgCtrlID(pNm->hdr.hwndFrom); if(lpAP->DialogState == STATE_PICK_USER) { int iItemIndex = ListView_GetNextItem(pNm->hdr.hwndFrom,-1,LVNI_SELECTED); if (iItemIndex == -1) { //Nothing is selected .. dont let them say OK
EnableWindow(GetDlgItem(hDlg,IDOK/*IDC_ADDRBK_BUTTON_OK*/),FALSE); SendMessage (hDlg, DM_SETDEFID, IDCANCEL, 0); } else { EnableWindow(GetDlgItem(hDlg,IDOK/*IDC_ADDRBK_BUTTON_OK*/),TRUE); SendMessage (hDlg, DM_SETDEFID, IDOK, 0); } } break;
case NM_DBLCLK: { //if an entry is selected - do this - otherwise dont do anything
int iItemIndex = ListView_GetNextItem(pNm->hdr.hwndFrom,-1,LVNI_SELECTED); if (iItemIndex == -1) break; { //DWORD dwDefId = SendMessage(hDlg, DM_GETDEFID, 0, 0);
//if(dwDefId)
// SendMessage(hDlg, WM_COMMAND, (WPARAM) LOWORD(dwDefId), 0);
SendMessage(hDlg, WM_COMMAND, (WPARAM) IDC_ADDRBK_BUTTON_TO + lpAP->lpAdrParms->nDestFieldFocus, 0); } } break;
case NM_CUSTOMDRAW: return ProcessLVCustomDraw(hDlg, lParam, TRUE); break; } break;
} } break;
default: if( (g_msgMSWheel && message == g_msgMSWheel) // || message == WM_MOUSEWHEEL
) { if(GetFocus() == GetDlgItem(hDlg, IDC_ADDRBK_LIST_TO)) SendMessage(GetDlgItem(hDlg, IDC_ADDRBK_LIST_TO), message, wParam, lParam); else if(GetFocus() == GetDlgItem(hDlg, IDC_ADDRBK_LIST_CC)) SendMessage(GetDlgItem(hDlg, IDC_ADDRBK_LIST_CC), message, wParam, lParam); else if(GetFocus() == GetDlgItem(hDlg, IDC_ADDRBK_LIST_BCC)) SendMessage(GetDlgItem(hDlg, IDC_ADDRBK_LIST_TO), message, wParam, lParam); else SendMessage(_hWndAddr, message, wParam, lParam); } break;
}
return FALSE;
}
/////////////////////////////////////////////////////////////////////////////////
//
// ListAddItem - Adds an item to the wells
//
// hDlg - HWND of parent
// hWndAddr - HWND of source ListView from which the item will be added
// CtlID - control ID of the target list view
// lppList - Item list corresponding to the target list view to which this item will be appended
// RecipientType - Specified recipient type to tag the new item with
//
/////////////////////////////////////////////////////////////////////////////////
BOOL ListAddItem(HWND hDlg, HWND hWndAddr, int CtlID, LPRECIPIENT_INFO * lppList, ULONG RecipientType){ BOOL bRet = FALSE; int iItemIndex = 0; HWND hWndList = GetDlgItem(hDlg,CtlID);
iItemIndex = ListView_GetNextItem(hWndAddr,-1,LVNI_SELECTED); if (iItemIndex != -1) { int iLastIndex = 0; do { // otherwise get the entry id of this thing
LPRECIPIENT_INFO lpItem = GetItemFromLV(hWndAddr, iItemIndex); if (lpItem) { LV_ITEM lvI; LPRECIPIENT_INFO lpNew = LocalAlloc(LMEM_ZEROINIT, sizeof(RECIPIENT_INFO));
if(!lpNew) { DebugPrintError(( TEXT("LocalAlloc failed to allocate memory\n"))); goto out; }
lpNew->ulObjectType = lpItem->ulObjectType; StrCpyN(lpNew->szDisplayName, lpItem->szDisplayName, ARRAYSIZE(lpNew->szDisplayName)); StrCpyN(lpNew->szByFirstName, lpItem->szByFirstName, ARRAYSIZE(lpNew->szByFirstName)); StrCpyN(lpNew->szByLastName, lpItem->szByLastName, ARRAYSIZE(lpNew->szByLastName)); StrCpyN(lpNew->szEmailAddress, lpItem->szEmailAddress, ARRAYSIZE(lpNew->szEmailAddress)); StrCpyN(lpNew->szHomePhone, lpItem->szHomePhone, ARRAYSIZE(lpNew->szHomePhone)); StrCpyN(lpNew->szOfficePhone, lpItem->szOfficePhone, ARRAYSIZE(lpNew->szOfficePhone)); lpNew->bHasCert = lpItem->bHasCert; lpNew->ulRecipientType = RecipientType; lpNew->ulOldAdrListEntryNumber = 0; //Flag this as not from the original AdrList
if (lpItem->cbEntryID) { lpNew->cbEntryID = lpItem->cbEntryID; lpNew->lpEntryID = LocalAlloc(LMEM_ZEROINIT, lpItem->cbEntryID); if(!lpNew->lpEntryID) { DebugPrintError(( TEXT("LocalAlloc failed to allocate memory\n"))); LocalFree(lpNew); goto out; } CopyMemory(lpNew->lpEntryID,lpItem->lpEntryID,lpItem->cbEntryID); }
lpNew->lpNext = (*lppList); if (*lppList) (*lppList)->lpPrev = lpNew; lpNew->lpPrev = NULL; (*lppList) = lpNew;
lvI.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE; lvI.state = 0; lvI.stateMask = 0; lvI.iSubItem = 0; lvI.cchTextMax = MAX_DISPLAY_NAME_LENGTH;
lvI.iImage = GetWABIconImage(lpNew);
// now fill in the List
lvI.iItem = ListView_GetItemCount(hWndList); lvI.pszText = lpNew->szDisplayName; lvI.lParam = (LPARAM) lpNew; ListView_InsertItem(hWndList, &lvI); ListView_EnsureVisible(hWndList,ListView_GetItemCount(hWndList)-1,FALSE); } iLastIndex = iItemIndex; // Get next selected item ...
iItemIndex = ListView_GetNextItem(hWndAddr,iLastIndex,LVNI_SELECTED); } while (iItemIndex != -1); //SetFocus(hWndAddr);
} else { ShowMessageBox(hDlg, IDS_ADDRBK_MESSAGE_NO_ITEMS_ADD, MB_ICONEXCLAMATION); goto out; }
if((ListView_GetItemCount(hWndList) > 0) && (ListView_GetSelectedCount(hWndList) <= 0)) LVSelectItem(hWndList, 0);
bRet = TRUE;
out: return bRet;
}
/////////////////////////////////////////////////////////////////////////////////
//
// ListDeleteItem - deletes an item from the Wells - unlike the Address COntents list we
// make sure to delete it here because we want the linked lists to only have valid entries
//
//
/////////////////////////////////////////////////////////////////////////////////
BOOL ListDeleteItem(HWND hDlg, int CtlID, LPRECIPIENT_INFO * lppList){ BOOL bRet = TRUE; LPRECIPIENT_INFO lpItem = NULL; HWND hWndAddr = GetDlgItem(hDlg,CtlID); int iItemIndex=0;
iItemIndex = ListView_GetNextItem(hWndAddr,-1,LVNI_SELECTED); if (iItemIndex != -1) { int iLastItem = 0; do { // otherwise get the entry id of this thing
lpItem = GetItemFromLV(hWndAddr, iItemIndex); if (lpItem) { // remove this item from our linked list of arrays
// if this is the first item in the list then handle that special case too
if ((*lppList) == lpItem) (*lppList) = lpItem->lpNext; if (lpItem->lpNext) lpItem->lpNext->lpPrev = lpItem->lpPrev; if (lpItem->lpPrev) lpItem->lpPrev->lpNext = lpItem->lpNext;
// we need to update our display
ListView_DeleteItem(hWndAddr,iItemIndex); //UpdateWindow(hWndAddr);
FreeRecipItem(&lpItem); } iLastItem = iItemIndex; // Get next selected item ...
iItemIndex = ListView_GetNextItem(hWndAddr,-1,LVNI_SELECTED); }while (iItemIndex != -1);
// select the previous or next item ...
if (iLastItem >= ListView_GetItemCount(hWndAddr)) iLastItem = ListView_GetItemCount(hWndAddr) - 1; LVSelectItem(hWndAddr, iLastItem); } SetFocus(hWndAddr);
return bRet;
}
/////////////////////////////////////////////////////////////////////////////////
//
// FillWells - Dismembers the lpAdrList to create the To and CC wells
//
// Scans the AdrEntry Structures in the LpAdrList, looks at PR_RECIPIENT_TYPE,
// ignores entries which it cant understand ... creates a temporary linked
// list of To and CC recipient lists which are used to populate the
// To and CC List boxes
//
/////////////////////////////////////////////////////////////////////////////////
BOOL FillWells(HWND hDlg, LPADRLIST lpAdrList, LPADRPARM lpAdrParms, LPRECIPIENT_INFO * lppListTo, LPRECIPIENT_INFO * lppListCC, LPRECIPIENT_INFO * lppListBCC){ BOOL bRet = FALSE; LPRECIPIENT_INFO lpNew = NULL; LPADRENTRY lpAdrEntry = NULL; ULONG i=0,j=0,nLen=0; int index=0; LV_ITEM lvI; HWND hWndAddr = NULL; ULONG ulMapiTo = MAPI_TO; ULONG ulMapiCC = MAPI_CC; ULONG ulMapiBCC = MAPI_BCC; BOOL bUnicode = (lpAdrParms->ulFlags & MAPI_UNICODE);
*lppListTo = NULL; *lppListCC = NULL; *lppListBCC = NULL;
if (lpAdrList == NULL) //nothing to do
{ bRet = TRUE; goto out; }
//
// The Input AdrParms structure has a lpulDestComps field that lets the
// caller specify his own recipient types. If this is missing, we are supposed
// to use the default recipient types.
//
if ((lpAdrParms->cDestFields > 0) && (lpAdrParms->lpulDestComps)) { ULONG i=0; for (i=0;i<lpAdrParms->cDestFields;i++) { switch(i) { case 0: ulMapiTo = lpAdrParms->lpulDestComps[i]; break; case 1: ulMapiCC = lpAdrParms->lpulDestComps[i]; break; case 2: ulMapiBCC = lpAdrParms->lpulDestComps[i]; break; } } }
for(i=0; i < lpAdrList->cEntries; i++) { lpAdrEntry = &(lpAdrList->aEntries[i]); if (lpAdrEntry->cValues != 0) { TCHAR szBuf[MAX_DISPLAY_NAME_LENGTH]; ULONG ulRecipientType = 0; ULONG ulObjectType = 0; ULONG cbEntryID = 0; BOOL bHasCert = FALSE; LPENTRYID lpEntryID = NULL; szBuf[0]='\0';
for(j=0;j<lpAdrEntry->cValues;j++) { ULONG ulPropTag = lpAdrEntry->rgPropVals[j].ulPropTag; if(!bUnicode && PROP_TYPE(ulPropTag) == PT_STRING8) ulPropTag = CHANGE_PROP_TYPE(ulPropTag, PT_UNICODE);
switch(ulPropTag) { case(PR_DISPLAY_NAME): { LPTSTR lpNameW = NULL; SET_UNICODE_STR(lpNameW, lpAdrEntry->rgPropVals[j].Value.LPSZ,lpAdrParms); nLen = CopyTruncate(szBuf, lpNameW, MAX_DISPLAY_NAME_LENGTH); FREE_UNICODE_STR(lpNameW, lpAdrEntry->rgPropVals[j].Value.LPSZ); } break; case(PR_RECIPIENT_TYPE): ulRecipientType = lpAdrEntry->rgPropVals[j].Value.l; break; case(PR_OBJECT_TYPE): ulObjectType = lpAdrEntry->rgPropVals[j].Value.l; break; case(PR_ENTRYID): cbEntryID = lpAdrEntry->rgPropVals[j].Value.bin.cb; lpEntryID = (LPENTRYID) lpAdrEntry->rgPropVals[j].Value.bin.lpb; break; case PR_USER_X509_CERTIFICATE: bHasCert = TRUE; break; } }
if (lstrlen(szBuf) && ((ulRecipientType == ulMapiBCC) || (ulRecipientType == ulMapiTo) || (ulRecipientType == ulMapiCC))) { lpNew = LocalAlloc(LMEM_ZEROINIT, sizeof(RECIPIENT_INFO)); if(!lpNew) { DebugPrintError(( TEXT("LocalAlloc failed to allocate memory\n"))); goto out; }
// ***NOTE***
// Store this index number, ie 1st item in AdrList is 1, then 2, 3, so on
// we do a plus 1 here because 0 value means it wasnt passed in and thus the
// minimum valid value is 1
lpNew->ulOldAdrListEntryNumber = i+1;
lpNew->bHasCert = bHasCert; StrCpyN(lpNew->szDisplayName,szBuf,ARRAYSIZE(lpNew->szDisplayName)); lpNew->ulRecipientType = ulRecipientType; lpNew->ulObjectType = ulObjectType;
if (cbEntryID != 0) { lpNew->cbEntryID = cbEntryID; lpNew->lpEntryID = LocalAlloc(LMEM_ZEROINIT,cbEntryID); if(!lpNew->lpEntryID) { DebugPrintError(( TEXT("LocalAlloc failed to allocate memory\n"))); goto out; } CopyMemory(lpNew->lpEntryID,lpEntryID,cbEntryID); }
if (ulRecipientType == ulMapiTo) { lpNew->lpNext = *lppListTo; if (*lppListTo) (*lppListTo)->lpPrev = lpNew; lpNew->lpPrev = NULL; *lppListTo = lpNew; } else if (ulRecipientType == ulMapiCC) { lpNew->lpNext = *lppListCC; if (*lppListCC) (*lppListCC)->lpPrev = lpNew; lpNew->lpPrev = NULL; *lppListCC = lpNew; } else if (ulRecipientType == ulMapiBCC) { lpNew->lpNext = *lppListBCC; if (*lppListBCC) (*lppListBCC)->lpPrev = lpNew; lpNew->lpPrev = NULL; *lppListBCC = lpNew; } }
} }
lvI.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE; lvI.state = 0; lvI.stateMask = 0; lvI.iSubItem = 0; lvI.cchTextMax = MAX_DISPLAY_NAME_LENGTH;
for(i=0;i<3;i++) { switch(i) { case 0: lpNew = *lppListTo; break; case 1: lpNew = *lppListCC; break; case 2: lpNew = *lppListBCC; break; }
hWndAddr = GetDlgItem(hDlg, IDC_ADDRBK_LIST_TO+i); index = 0; while(lpNew) { lvI.iItem = index; lvI.pszText = lpNew->szDisplayName; lvI.lParam = (LPARAM) lpNew;
lvI.iImage = GetWABIconImage(lpNew);
ListView_InsertItem(hWndAddr, &lvI);
index++; lpNew = lpNew->lpNext; } }
// We will highlight the first item in any filled list box
// because basically that looks good when tabbing through them ...
for(i=0;i<lpAdrParms->cDestFields;i++) { HWND hWndLV = GetDlgItem(hDlg, IDC_ADDRBK_LIST_TO+i);
if (ListView_GetItemCount(hWndLV) > 0) LVSelectItem(hWndLV,0); }
bRet = TRUE;
out:
return bRet;}
/////////////////////////////////////////////////////////////////////////////////
//
// SetAddressBookUI - juggles the address book UI in response to various parameters
//
// This function will probably be more complex with each tier
//
//
//
/////////////////////////////////////////////////////////////////////////////////
BOOL SetAddressBookUI(HWND hDlg, LPADDRESS_PARMS lpAP){ BOOL bRet = FALSE; //LV_COLUMN lvC;
RECT rc, rc1, rc2; POINT ptLU1,ptRB1; int nButtonsVisible = 0; int nButtonSpacing = 7; int nButtonWidth = 0; ULONG nLen = 0; TCHAR szBuf[MAX_UI_STR*4]; LPPTGDATA lpPTGData=GetThreadStoragePointer(); HWND hWndListAddresses = GetDlgItem(hDlg, IDC_ADDRBK_LIST_ADDRESSES);
LPTSTR szCaption = NULL;
SET_UNICODE_STR(szCaption, lpAP->lpAdrParms->lpszCaption,lpAP->lpAdrParms);
if(!szCaption || !lstrlen(szCaption)) { LoadString(hinstMapiX, IDS_ADDRBK_CAPTION, szBuf, CharSizeOf(szBuf)); szCaption = szBuf; } // Set the font of all the children to the default GUI font
EnumChildWindows( hDlg, SetChildDefaultGUIFont, (LPARAM) 0);
if(pt_bIsWABOpenExSession || bIsWABSessionProfileAware((LPIAB)lpAP->lpIAB)) { // Fill in the Combo with the container names
FillContainerCombo(GetDlgItem(hDlg, IDC_ADDRBK_COMBO_CONT), (LPIAB)lpAP->lpIAB); } else { HWND hWndCombo = GetDlgItem(hDlg, IDC_ADDRBK_COMBO_CONT); EnableWindow(hWndCombo, FALSE); ShowWindow(hWndCombo, SW_HIDE);
// resize the listview to take place of the hidden combo
GetWindowRect(hWndCombo,&rc2); GetWindowRect(hWndListAddresses,&rc); //
//This api works for both mirrored and unmirrored windows.
//
MapWindowPoints(NULL, hDlg, (LPPOINT)&rc2, 2); MapWindowPoints(NULL, hDlg, (LPPOINT)&rc, 2); ptLU1.x = rc2.left; ptLU1.y = rc2.top; ptRB1.x = rc.right; ptRB1.y = rc.bottom; MoveWindow(hWndListAddresses,ptLU1.x,ptLU1.y,(ptRB1.x - ptLU1.x), (ptRB1.y - ptLU1.y), TRUE); }
//
// There are only two states that need configuration -
// Pick User - in which we have to hide the wells
// and
// Select Recipients, in which we have to hide the wells
// as per the input criteria and resize accordingly and
// also set the labels based on the input criteria
//
if (lpAP->DialogState == STATE_SELECT_RECIPIENTS) { SendMessage (hDlg, DM_SETDEFID, IDC_ADDRBK_BUTTON_TO, 0);
// in case the nDestFieldFocus parameter is supplied, use it ..
if ( (lpAP->lpAdrParms->nDestFieldFocus < lpAP->lpAdrParms->cDestFields)) { if (lpAP->lpAdrParms->nDestFieldFocus == 1) SendMessage (hDlg, DM_SETDEFID, IDC_ADDRBK_BUTTON_CC, 0); else if (lpAP->lpAdrParms->nDestFieldFocus == 2) SendMessage (hDlg, DM_SETDEFID, IDC_ADDRBK_BUTTON_BCC, 0); } } else if (lpAP->DialogState == STATE_PICK_USER) SendMessage (hDlg, DM_SETDEFID, IDOK/*IDC_ADDRBK_BUTTON_OK*/, 0); else if (lpAP->DialogState == STATE_BROWSE_MODAL) SendMessage (hDlg, DM_SETDEFID, IDC_ADDRBK_BUTTON_PROPS, 0);
// Set the window caption
if (szCaption) SetWindowText(hDlg,szCaption);
// Set the caption over the destination wells
if (lpAP->lpAdrParms->lpszDestWellsTitle) { LPWSTR lpTitle = NULL; // <note> assumes UNICODE defined
SET_UNICODE_STR(lpTitle,lpAP->lpAdrParms->lpszDestWellsTitle,lpAP->lpAdrParms); SetDlgItemText(hDlg,IDC_ADDRBK_STATIC_RECIP_TITLE,lpTitle); FREE_UNICODE_STR(lpTitle, lpAP->lpAdrParms->lpszDestWellsTitle); }
if (lpAP->DialogState == STATE_PICK_USER && *(lpAP->lppAdrList) ) { ULONG i=0; LPTSTR lpszRecipName = NULL;
//Get the user whose name we are trying to find
for(i=0;i<(*(lpAP->lppAdrList))->aEntries[0].cValues;i++) { ULONG ulPropTag = PR_DISPLAY_NAME; if(!(lpAP->lpAdrParms->ulFlags & MAPI_UNICODE)) ulPropTag = CHANGE_PROP_TYPE(ulPropTag, PT_STRING8); if ((*(lpAP->lppAdrList))->aEntries[0].rgPropVals[i].ulPropTag == ulPropTag) { SET_UNICODE_STR(lpszRecipName,(*(lpAP->lppAdrList))->aEntries[0].rgPropVals[i].Value.LPSZ,lpAP->lpAdrParms); break; } }
if(lpszRecipName) { LPTSTR lpszBuffer = NULL; TCHAR szTmp[MAX_PATH], *lpszTmp;
LoadString(hinstMapiX, IDS_ADDRBK_RESOLVE_CAPTION, szBuf, CharSizeOf(szBuf));
CopyTruncate(szTmp, lpszRecipName, MAX_PATH - 1); lpszTmp = szTmp;
if(FormatMessage( FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY | FORMAT_MESSAGE_ALLOCATE_BUFFER, szBuf, 0,0, //ignored
(LPTSTR) &lpszBuffer, MAX_UI_STR, (va_list *)&lpszTmp)) { // if the display name is too long, it doesnt show up properly in the UI ..
// so we will purposely limit the visible portion to 64 characters - arbitarily defined limit..
szBuf[0]='\0'; nLen = CopyTruncate(szBuf, lpszBuffer, 2 * MAX_DISPLAY_NAME_LENGTH);
LocalFreeAndNull(&lpszBuffer); }
//Increase the size of the static control to = what the Contents List width will be
GetWindowRect(GetDlgItem(hDlg,IDC_ADDRBK_STATIC_CONTENTS),&rc2); GetWindowRect(GetDlgItem(hDlg,IDC_ADDRBK_LIST_TO),&rc); //
//This api working in both mirrored and unmirrored windows.
//
MapWindowPoints(NULL, hDlg, (LPPOINT)&rc2, 2); MapWindowPoints(NULL, hDlg, (LPPOINT)&rc, 2); ptLU1.x = rc2.left; ptLU1.y = rc2.top; ptRB1.x = rc.right; ptRB1.y = rc2.bottom; MoveWindow(GetDlgItem(hDlg,IDC_ADDRBK_STATIC_CONTENTS),ptLU1.x,ptLU1.y,(ptRB1.x - ptLU1.x), (ptRB1.y - ptLU1.y), TRUE);
SetDlgItemText(hDlg,IDC_ADDRBK_STATIC_CONTENTS,szBuf);
FREE_UNICODE_STR(lpszRecipName,(*(lpAP->lppAdrList))->aEntries[0].rgPropVals[i].Value.LPSZ); }
}
if (lpAP->DialogState == STATE_PICK_USER) { // If ADDRESS_ONE has been selected, then make the IDC_ADDRBK_LIST_ADDRESSES
// single selection only
DWORD dwStyle; dwStyle = GetWindowLong(hWndListAddresses, GWL_STYLE); SetWindowLong(hWndListAddresses, GWL_STYLE, dwStyle | LVS_SINGLESEL); }
if ((lpAP->DialogState == STATE_PICK_USER)||(lpAP->DialogState == STATE_BROWSE_MODAL)) { int i = 0; // Dont show wells which means we have to do some rearranging
// * Hide the wells and the To, CC, BCC buttons
// * Resize the IDC_ADDRBK_LIST_ADDRESSES to fill the whole dialog
// * Move the 3 buttons below it to the left side of the dialog
//
// Get the dimensions of the ToListBox
GetWindowRect(GetDlgItem(hDlg,IDC_ADDRBK_LIST_TO),&rc2); GetWindowRect(hWndListAddresses,&rc); //
//This api works for in both mirrored and unmirrored windows.
//
MapWindowPoints(NULL, hDlg, (LPPOINT)&rc2, 2); MapWindowPoints(NULL, hDlg, (LPPOINT)&rc, 2); ptLU1.x = rc.left; ptLU1.y = rc.top; ptRB1.x = rc2.right; ptRB1.y = rc.bottom;
MoveWindow(hWndListAddresses,ptLU1.x,ptLU1.y,(ptRB1.x - ptLU1.x), (ptRB1.y - ptLU1.y), TRUE);
for(i=0;i<3;i++) { ShowWindow(GetDlgItem(hDlg, IDC_ADDRBK_BUTTON_TO + i), SW_HIDE); ShowWindow(GetDlgItem(hDlg, IDC_ADDRBK_LIST_TO + i), SW_HIDE); }
ShowWindow(GetDlgItem(hDlg, IDC_ADDRBK_STATIC_RECIP_TITLE), SW_HIDE); // TEXT("Message Recipients") label
}
// other things to do
// Load Headers for List box
GetWindowRect(hWndListAddresses,&rc); HrInitListView(hWndListAddresses, LVS_REPORT, TRUE);
GetWindowRect(GetDlgItem(hDlg,IDC_ADDRBK_BUTTON_PROPS),&rc2); nButtonsVisible = 2;
nButtonWidth = (rc2.right - rc2.left);
// get the new coordinates of the 1st visible button
//
//This api working in both mirrored and unmirrored windows.
//
MapWindowPoints(NULL, hDlg, (LPPOINT)&rc2, 2); MapWindowPoints(NULL, hDlg, (LPPOINT)&rc, 2); ptLU1.x = rc.left; ptLU1.y = rc2.top; ptRB1.x = ptLU1.x + nButtonWidth; ptRB1.y = rc2.bottom;
MoveWindow(GetDlgItem(hDlg,IDC_ADDRBK_BUTTON_NEW),ptLU1.x,ptLU1.y,nButtonWidth, (ptRB1.y - ptLU1.y), TRUE); ptLU1.x += nButtonWidth + nButtonSpacing; ptRB1.x = ptLU1.x + nButtonWidth; if (lpAP->DialogState == STATE_BROWSE_MODAL) { MoveWindow(GetDlgItem(hDlg,IDC_ADDRBK_BUTTON_NEWGROUP),ptLU1.x,ptLU1.y,nButtonWidth, (ptRB1.y - ptLU1.y), TRUE); ptLU1.x += nButtonWidth + nButtonSpacing; ptRB1.x = ptLU1.x + nButtonWidth; } else { // The NewGroup button is visible only in the DialogModalView
EnableWindow(GetDlgItem(hDlg, IDC_ADDRBK_BUTTON_NEWGROUP), FALSE); ShowWindow(GetDlgItem(hDlg, IDC_ADDRBK_BUTTON_NEWGROUP), SW_HIDE); } MoveWindow(GetDlgItem(hDlg,IDC_ADDRBK_BUTTON_PROPS),ptLU1.x,ptLU1.y,nButtonWidth, (ptRB1.y - ptLU1.y), TRUE); ptLU1.x += nButtonWidth + nButtonSpacing; ptRB1.x = ptLU1.x + nButtonWidth; MoveWindow(GetDlgItem(hDlg,IDC_ADDRBK_BUTTON_DELETE),ptLU1.x,ptLU1.y,nButtonWidth, (ptRB1.y - ptLU1.y), TRUE);
// The delete button is visible only in the DialogModalView
if (lpAP->DialogState != STATE_BROWSE_MODAL) { EnableWindow(GetDlgItem(hDlg, IDC_ADDRBK_BUTTON_DELETE), FALSE); ShowWindow(GetDlgItem(hDlg, IDC_ADDRBK_BUTTON_DELETE), SW_HIDE); }
//
// We now need to customize this window if we are selecting
// recipients ...
//
if (lpAP->DialogState == STATE_SELECT_RECIPIENTS) { // We need to see which wells are visible and
// then we need to resize the buttons based on their captions
//
int i=0; int nLen=0; int cDF = lpAP->lpAdrParms->cDestFields; int iLeft=0,iTop=0;
SIZE size={0}; ULONG MaxWidth=0; ULONG maxHeightPerLV = 0; HWND hw; HDC hdc=GetDC(hDlg);
if (lpAP->lpAdrParms->lppszDestTitles) { for(i=0; i < cDF; i++) { LPTSTR lpTitle = NULL; ULONG Len = 0; SET_UNICODE_STR(lpTitle,lpAP->lpAdrParms->lppszDestTitles[i],lpAP->lpAdrParms); if(!lpTitle) continue; Len = lstrlen(lpTitle); if (Len > CharSizeOf(szBuf) - 4) { ULONG iLen = TruncatePos(lpTitle, CharSizeOf(szBuf) - 4); CopyMemory(szBuf,lpTitle,iLen*sizeof(TCHAR)); szBuf[iLen] = '\0'; } else { StrCpyN(szBuf,lpTitle,ARRAYSIZE(szBuf)); } StrCatBuff(szBuf,szArrow,ARRAYSIZE(szBuf)); if (lstrlen(szBuf) >= nLen) { nLen = lstrlen(szBuf); GetTextExtentPoint32(hdc, szBuf, nLen, &size); MaxWidth = size.cx; } // Set the new text
SetDlgItemText(hDlg,IDC_ADDRBK_BUTTON_TO+i,szBuf); FREE_UNICODE_STR(lpTitle,lpAP->lpAdrParms->lppszDestTitles[i]); }
}
ReleaseDC(hDlg,hdc);
if (MaxWidth == 0) { //get the default width
GetWindowRect(GetDlgItem(hDlg,IDC_ADDRBK_BUTTON_TO),&rc1); MaxWidth = rc1.right - rc1.left; }
//Get the maximum allowable height per well
GetWindowRect(hWndListAddresses,&rc); GetChildClientRect(hWndListAddresses, &rc); GetWindowRect(GetDlgItem(hDlg,IDC_ADDRBK_BUTTON_NEW),&rc1); GetChildClientRect(GetDlgItem(hDlg,IDC_ADDRBK_BUTTON_NEW), &rc1); maxHeightPerLV = (rc1.bottom-rc.top - (cDF - 1)*CONTROL_SPACING)/cDF; iTop = rc.top;
for(i=0;i<cDF;i++) { hw = GetDlgItem(hDlg,IDC_ADDRBK_BUTTON_TO + i);
// resize the buttons to fit the text
GetWindowRect(hw,&rc1); GetChildClientRect(hw,&rc1); MoveWindow(hw,rc1.left,iTop,MaxWidth,rc1.bottom - rc1.top,FALSE);
iLeft = rc1.left + MaxWidth + 2*CONTROL_SPACING;
// Move the list boxes to accomodate the resized buttons
hw = GetDlgItem(hDlg,IDC_ADDRBK_LIST_TO + i); GetWindowRect(hw, &rc1); GetChildClientRect(hw, &rc1); MoveWindow(hw,iLeft,iTop,rc1.right-iLeft,maxHeightPerLV,FALSE);
ListView_SetExtendedListViewStyle(hw,LVS_EX_FULLROWSELECT);
iTop += maxHeightPerLV + CONTROL_SPACING;
}
//Move the label over the wells and restrict it's size
hw = GetDlgItem(hDlg,IDC_ADDRBK_STATIC_RECIP_TITLE); GetWindowRect(hw, &rc2); GetChildClientRect(hw, &rc2); if(pt_bIsWABOpenExSession || bIsWABSessionProfileAware((LPIAB)lpAP->lpIAB)) // need to move this to the same height as combo
{ int ht = rc2.bottom - rc2.top; rc2.bottom = rc.top - CONTROL_SPACING; rc2.top = rc2.bottom - ht; } MoveWindow(hw,iLeft,rc2.top,rc1.right-iLeft,rc2.bottom-rc2.top,FALSE);
// Now we have the position and width of the list boxes .. need to get their height
if (cDF!=3) //if not the default preset position, reposition
{ switch(cDF) { case 1: ShowWindow(GetDlgItem(hDlg, IDC_ADDRBK_BUTTON_CC), SW_HIDE); ShowWindow(GetDlgItem(hDlg, IDC_ADDRBK_LIST_CC), SW_HIDE); case 2: ShowWindow(GetDlgItem(hDlg, IDC_ADDRBK_BUTTON_BCC), SW_HIDE); ShowWindow(GetDlgItem(hDlg, IDC_ADDRBK_LIST_BCC), SW_HIDE); break; }
}
for(i=0;i<cDF;i++) HrInitListView(GetDlgItem(hDlg, IDC_ADDRBK_LIST_TO + i), LVS_REPORT, FALSE);
/***
// Add a column to the To,CC,BCC List Boxes
GetWindowRect(GetDlgItem(hDlg,IDC_ADDRBK_LIST_TO),&rc);
lvC.mask = LVCF_FMT | LVCF_WIDTH;// | LVCF_TEXT;
lvC.fmt = LVCFMT_LEFT; lvC.cx = (rc.right - rc.left)-20; lvC.iSubItem = 0; lvC.pszText = NULL; // TEXT(" 'TO' Recipients");
ListView_InsertColumn(GetDlgItem(hDlg,IDC_ADDRBK_LIST_TO),lvC.iSubItem, &lvC); ListView_InsertColumn(GetDlgItem(hDlg,IDC_ADDRBK_LIST_CC),lvC.iSubItem, &lvC); ListView_InsertColumn(GetDlgItem(hDlg,IDC_ADDRBK_LIST_BCC),lvC.iSubItem, &lvC);/***/ for (i=0;i<cDF;i++) { ShowWindow(GetDlgItem(hDlg,IDC_ADDRBK_BUTTON_TO+i), SW_SHOWNORMAL); UpdateWindow(GetDlgItem(hDlg,IDC_ADDRBK_BUTTON_TO+i)); ShowWindow(GetDlgItem(hDlg,IDC_ADDRBK_LIST_TO+i), SW_SHOWNORMAL); UpdateWindow(GetDlgItem(hDlg,IDC_ADDRBK_LIST_TO+i)); } }
// The window is taking too long to display with several 100 entries in the
// property store ... so we force all the contents to visible so that we
// can view the fill contents ...
//ShowWindow(GetDlgItem(hDlg,IDC_ADDRBK_LIST_ADDRESSES), SW_SHOWNORMAL);
//UpdateWindow(GetDlgItem(hDlg,IDC_ADDRBK_LIST_ADDRESSES));
ShowWindow(GetDlgItem(hDlg,IDC_ADDRBK_BUTTON_PROPS), SW_SHOWNORMAL); UpdateWindow(GetDlgItem(hDlg,IDC_ADDRBK_BUTTON_PROPS)); ShowWindow(GetDlgItem(hDlg,IDC_ADDRBK_BUTTON_NEW), SW_SHOWNORMAL); UpdateWindow(GetDlgItem(hDlg,IDC_ADDRBK_BUTTON_NEW)); ShowWindow(GetDlgItem(hDlg,IDOK/*IDC_ADDRBK_BUTTON_OK*/), SW_SHOWNORMAL); UpdateWindow(GetDlgItem(hDlg,IDOK/*IDC_ADDRBK_BUTTON_OK*/)); ShowWindow(GetDlgItem(hDlg,IDCANCEL/*IDC_ADDRBK_BUTTON_CANCEL*/), SW_SHOWNORMAL); UpdateWindow(GetDlgItem(hDlg,IDCANCEL/*IDC_ADDRBK_BUTTON_CANCEL*/)); ShowWindow(GetDlgItem(hDlg,IDC_ADDRBK_STATIC_CONTENTS), SW_SHOWNORMAL); UpdateWindow(GetDlgItem(hDlg,IDC_ADDRBK_STATIC_CONTENTS)); ShowWindow(GetDlgItem(hDlg,IDC_ADDRBK_STATIC_15), SW_SHOWNORMAL); UpdateWindow(GetDlgItem(hDlg,IDC_ADDRBK_STATIC_15)); ShowWindow(hDlg,SW_SHOWNORMAL); UpdateWindow(hDlg);
{// HICON hIcon = LoadIcon(hinstMapiX,MAKEINTRESOURCE(IDI_ICON_FIND));
// associate the icon with the button.
// SendMessage(GetDlgItem(hDlg,IDC_ADDRBK_BUTTON_FIND),BM_SETIMAGE,(WPARAM)IMAGE_ICON,(LPARAM)(HANDLE)hIcon);
} bRet = TRUE;
if( szCaption != lpAP->lpAdrParms->lpszCaption && szCaption != szBuf) LocalFreeAndNull(&szCaption);
return bRet;}
//$$///////////////////////////////////////////////////////////////////////////////////////////
//
// UpdateLVItems ....
// When we call properties on an object, its props can change ...
// Since the particular user may appear in any of the 4 list views,
// we have to make sure that all views are updated for that entry
//
///////////////////////////////////////////////////////////////////////////////////////////////
void UpdateLVItems(HWND hWndLV,LPTSTR lpszName){ // We have the handle to the list view initiating the Properties call
// We know the old name to look for
//
// We know which item is selected - we can get its entryid and lParam
// We then search all the list views for the old display name
// if the old display name matches, we compare the entry id
// if the entryid matches, then we update that item ...
int iItemIndex = 0, iLastItemIndex = 0; LPRECIPIENT_INFO lpOriginalItem; ULONG i=0; ULONG nCount = 0; int id = 0; HWND hDlg = GetParent(hWndLV); HWND hw = NULL; LV_FINDINFO lvf={0};
if ( (ListView_GetSelectedCount(hWndLV) != 1) || (lpszName == NULL) ) { goto out; }
iItemIndex = ListView_GetNextItem(hWndLV, -1, LVNI_SELECTED);
lpOriginalItem = GetItemFromLV(hWndLV, iItemIndex);
if(!lpOriginalItem) goto out;
// There can be upto 4 list view boxes in the view, each of which can
// contain a displayed copy of this item ..
// We want to go through all 4 and update all entries that match this item
// Our strategy is to search for each and every item that
// matches the display name - check its entry ID and if
// the entry ID matches, update it ...
lvf.flags = LVFI_STRING; lvf.psz = lpszName;
for(i=0;i<4;i++) { switch(i) { case 0: id = IDC_ADDRBK_LIST_ADDRESSES; break; case 1: id = IDC_ADDRBK_LIST_TO; break; case 2: id = IDC_ADDRBK_LIST_CC; break; case 3: id = IDC_ADDRBK_LIST_BCC; break; }
hw = GetDlgItem(hDlg,id);
// if its hidden, ignore it
if (!IsWindowVisible(hw)) continue;
// if its empty, ignore it
nCount = ListView_GetItemCount(hw); if (nCount <= 0) continue;
// The contents list view wont have duplicates so ignore it if its the original
if ((id == IDC_ADDRBK_LIST_ADDRESSES) && (hw == hWndLV)) continue;
// see if we can find the matching items
iLastItemIndex = -1; iItemIndex = ListView_FindItem(hw,iLastItemIndex,&lvf); while (iItemIndex != -1) { // inspect this item
LPRECIPIENT_INFO lpItem = GetItemFromLV(hWndLV, iItemIndex); if (lpItem && (lpItem->cbEntryID != 0) && (lpOriginalItem->cbEntryID == lpItem->cbEntryID)) { if(!memcmp(lpOriginalItem->lpEntryID,lpItem->lpEntryID,lpItem->cbEntryID)) { // this is the same item ... update it
if (lstrcmpi(lpItem->szDisplayName,lpOriginalItem->szDisplayName)) { ListView_SetItemText(hw,iItemIndex,colDisplayName,lpOriginalItem->szDisplayName); StrCpyN(lpItem->szDisplayName,lpOriginalItem->szDisplayName,ARRAYSIZE(lpItem->szDisplayName)); }
if (lstrcmpi(lpItem->szEmailAddress,lpOriginalItem->szEmailAddress)) { ListView_SetItemText(hw,iItemIndex,colEmailAddress,lpOriginalItem->szEmailAddress); StrCpyN(lpItem->szEmailAddress,lpOriginalItem->szEmailAddress,ARRAYSIZE(lpItem->szEmailAddress)); }
if (lstrcmpi(lpItem->szHomePhone,lpOriginalItem->szHomePhone)) { ListView_SetItemText(hw,iItemIndex,colHomePhone,lpOriginalItem->szHomePhone); StrCpyN(lpItem->szHomePhone,lpOriginalItem->szHomePhone,ARRAYSIZE(lpItem->szHomePhone)); }
if (lstrcmpi(lpItem->szOfficePhone,lpOriginalItem->szOfficePhone)) { ListView_SetItemText(hw,iItemIndex,colOfficePhone,lpOriginalItem->szOfficePhone); StrCpyN(lpItem->szOfficePhone,lpOriginalItem->szOfficePhone,ARRAYSIZE(lpItem->szOfficePhone)); }
if (lstrcmpi(lpItem->szByFirstName,lpOriginalItem->szByFirstName)) StrCpyN(lpItem->szByFirstName,lpOriginalItem->szByFirstName,ARRAYSIZE(lpItem->szByFirstName));
if (lstrcmpi(lpItem->szByLastName,lpOriginalItem->szByLastName)) StrCpyN(lpItem->szByLastName,lpOriginalItem->szByLastName,ARRAYSIZE(lpItem->szByLastName)); } }
iLastItemIndex = iItemIndex; iItemIndex = ListView_FindItem(hw,iLastItemIndex,&lvf); } }out: return;}
//$$///////////////////////////////////////////////////////////////////////////////////////////
//
// ShowAddrBkLVProps ....
//
///////////////////////////////////////////////////////////////////////////////////////////////
void ShowAddrBkLVProps(LPIAB lpIAB, HWND hDlg, HWND hWndAddr,LPADDRESS_PARMS lpAP, LPFILETIME lpftLast){ // get the display name of this item
TCHAR szName[MAX_DISPLAY_NAME_LENGTH]; szName[0]='\0'; if (ListView_GetSelectedCount(hWndAddr) == 1) { ListView_GetItemText( hWndAddr, ListView_GetNextItem(hWndAddr,-1,LVNI_SELECTED), 0, szName, CharSizeOf(szName)); } if( (MAPI_E_OBJECT_CHANGED == HrShowLVEntryProperties(hWndAddr, 0, lpAP->lpIAB, lpftLast)) && (szName) && (lpAP->DialogState == STATE_SELECT_RECIPIENTS) ) { // if the entry has changed and we have multiple list views visible,
// we need to update all instances of the entry in all the list views
//
UpdateLVItems(hWndAddr,szName); SortListViewColumn(lpIAB, GetDlgItem(hDlg,IDC_ADDRBK_LIST_ADDRESSES), colDisplayName, &(lpAP->SortInfo), TRUE);
} SetFocus(hWndAddr);
}
//$$///////////////////////////////////////////////////////////////////////////////////////////
//
// HrUpdateAdrListEntry ....
//
// When returning from a PickUser operation, updates the
// entry in the lpAdrList with the newly found item
//
// ulFLags 0 or MAPI_UNICODE passed down to GetProps
//
// Returns: Hr
//
///////////////////////////////////////////////////////////////////////////////////////////////
HRESULT HrUpdateAdrListEntry( LPADRBOOK lpIAB, LPENTRYID lpEntryID, ULONG cbEntryID, ULONG ulFlags, LPADRLIST * lppAdrList){
LPSPropValue rgProps = NULL; ULONG cValues = 0; LPSPropValue lpPropArrayNew = NULL; ULONG cValuesNew = 0; LPTSTR lpszTemp = NULL; LPVOID lpbTemp = NULL; ULONG i = 0; SCODE sc; HRESULT hr = E_FAIL;
if (!lppAdrList || !lpEntryID || !lpIAB || !cbEntryID) goto out;
hr = HrGetPropArray(lpIAB, (LPSPropTagArray) &ptaResolveDefaults, cbEntryID, lpEntryID, ulFlags, &cValues, &rgProps); if (!HR_FAILED(hr)) {
if(!*lppAdrList) { // Allocate one ..
LPADRLIST lpAdrList = NULL;
sc = MAPIAllocateBuffer(sizeof(ADRLIST) + sizeof(ADRENTRY), &lpAdrList);
if(FAILED(sc)) { hr = MAPI_E_NOT_ENOUGH_MEMORY; goto out; }
*lppAdrList = lpAdrList; (*lppAdrList)->cEntries = 1; (*lppAdrList)->aEntries[0].ulReserved1 = 0; (*lppAdrList)->aEntries[0].cValues = 0; (*lppAdrList)->aEntries[0].rgPropVals = NULL; }
//Merge the new list with the old list
sc = ScMergePropValues( (*lppAdrList)->aEntries[0].cValues, (*lppAdrList)->aEntries[0].rgPropVals, cValues, rgProps, &cValuesNew, &lpPropArrayNew); if (sc == S_OK) { // if OK replace the lpspropvalue array
// if not we havent changed anything
(*lppAdrList)->aEntries[0].cValues = cValuesNew; if((*lppAdrList)->aEntries[0].rgPropVals) MAPIFreeBuffer((*lppAdrList)->aEntries[0].rgPropVals); (*lppAdrList)->aEntries[0].rgPropVals = lpPropArrayNew; } else { // If errors Free up the allocated memory
if (lpPropArrayNew) MAPIFreeBuffer(lpPropArrayNew); hr = E_FAIL; }
}
// we free this anyway whether the above succeeded or not
if (rgProps) MAPIFreeBuffer(rgProps);
out:
return hr;}
|
