archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/inetcore/outlookexpress/iecont/baui.cpp

4319 lines
128 KiB
Raw Blame History

// baui.cpp : Implementation of CIEMsgAb
// Messenger integration to OE
// Created 04/20/98 by YST
// #define YST 1
#include "pch.hxx"
#include <windowsx.h>
#include "msoert.h"
#include "basicim2.h"
#include "shlwapi.h"
#include "bactrl.h"
#include "baprop.h"
#include "baui.h"
#include "bllist.h"
#include <wabapi.h>
#include "shlwapip.h"
#include "clutil.h"
#include <mapi.h>
#include "hotlinks.h"
static CAddressBookData * st_pAddrBook = NULL;
#define MAX_MENUSTR 256
//
// Pseudoclass for the variable-sized OLECMDTEXT structure.
// You need to declare it as a class (and not a BYTE buffer that is
// suitable cast) because BYTE buffers are not guaranteed to be aligned.
//
template <int n>
class OLECMDTEXTV : public OLECMDTEXT {
WCHAR wszBuf[n-1]; // "-1" because OLECMDTEXT includes 1 wchar
};
#ifdef DEBUG
DWORD dwDOUTLevel = 0;
#endif
HRESULT DropOnMailRecipient(IDataObject *pdtobj, DWORD grfKeyState);
STDAPI OESimulateDrop(IDropTarget *pdrop, IDataObject *pdtobj, DWORD grfKeyState,
const POINTL *ppt, DWORD *pdwEffect);
typedef enum _tagGetPropertyIDs
{
TBEX_BUTTONTEXT = 100, // VT_BSTR
TBEX_TOOLTIPTEXT = 101, // VT_BSTR
TBEX_GRAYICON = 102, // HICON as a VT_BYREF
TBEX_HOTICON = 103, // HICON as a VT_BYREF
TBEX_GRAYICONSM = 104, // HICON as a VT_BYREF
TBEX_HOTICONSM = 105, // HICON as a VT_BYREF
TBEX_DEFAULTVISIBLE = 106, // VT_BOOL
TMEX_MENUTEXT = 200, // VT_BSTR
TMEX_STATUSBARTEXT = 201, // VT_BSTR
TMEX_CUSTOM_MENU = 202, // VT_BSTR
} GETPROPERTYIDS;
static const int BA_SortOrder[] =
{
BIMSTATE_ONLINE,
BIMSTATE_BE_RIGHT_BACK,
BIMSTATE_OUT_TO_LUNCH,
BIMSTATE_IDLE,
BIMSTATE_AWAY,
BIMSTATE_ON_THE_PHONE,
BIMSTATE_BUSY,
BIMSTATE_INVISIBLE,
BIMSTATE_OFFLINE,
BIMSTATE_UNKNOWN
};
// Create control
HRESULT CreateIEMsgAbCtrl(IIEMsgAb **ppIEMsgAb)
{
HRESULT hr;
IUnknown *pUnknown;
TraceCall("CreateMessageList");
// Get the class factory for the MessageList object
IClassFactory *pFactory = NULL;
hr = _Module.GetClassObject(CLSID_IEMsgAb, IID_IClassFactory,
(LPVOID *) &pFactory);
// If we got the factory, then get an object pointer from it
if (SUCCEEDED(hr))
{
hr = pFactory->CreateInstance(NULL, IID_IUnknown,
(LPVOID *) &pUnknown);
if (SUCCEEDED(hr))
{
hr = pUnknown->QueryInterface(IID_IIEMsgAb, (LPVOID *) ppIEMsgAb);
pUnknown->Release();
}
pFactory->Release();
}
return (hr);
}
/////////////////////////////////////////////////////////////////////////////
// CIEMsgAb
CIEMsgAb::CIEMsgAb():m_ctlList(_T("SysListView32"), this, 1)
{
m_bWindowOnly = TRUE;
m_pDataObject = 0;
m_cf = 0;
m_hwndParent = NULL;
m_pFolderBar = NULL;
m_pObjSite = NULL;
m_nSortType = HIWORD(DwGetOptions());
m_pCMsgrList = NULL;
m_himl = NULL;
m_fLogged = FALSE;
m_dwFontCacheCookie = 0;
m_nChCount = 0;
m_lpWED = NULL;
m_lpWEDContext = NULL;
m_lpPropObj = NULL;
m_szOnline = NULL;
// m_szInvisible = NULL;
m_szBusy = NULL;
m_szBack = NULL;
m_szAway = NULL;
m_szOnPhone = NULL;
m_szLunch = NULL;
m_szOffline = NULL;
m_szIdle = NULL;
m_szEmptyList = NULL;
m_szMsgrEmptyList = NULL;
m_szLeftBr = NULL;
m_szRightBr = NULL;
m_fNoRemove = FALSE;
m_delItem = 0;
m_dwHideMessenger = DwGetMessStatus();
m_dwDisableMessenger = DwGetDisableMessenger();
WORD wShow = LOWORD(DwGetOptions());
m_fShowAllContacts = FALSE;
m_fShowOnlineContacts = FALSE;
m_fShowOfflineContacts = FALSE;
m_fShowEmailContacts = FALSE;
m_fShowOthersContacts = FALSE;
if(wShow == 0)
m_fShowAllContacts = TRUE;
else if (wShow == 1)
m_fShowOfflineContacts = TRUE;
else
m_fShowOnlineContacts = TRUE;
m_fWAB = TRUE;
// Initialize the applicaiton
#ifdef LATER
g_pInstance->DllAddRef();
#endif
// Raid-32933: OE: MSIMN.EXE doesn't always exit
// g_pInstance->CoIncrementInit();
// LATER this is temporary hack for resources!!!
_ASSERT(g_hLocRes);
// g_hLocRes = g_hInst; //_Module.GetResourceInstance();
}
CIEMsgAb::~CIEMsgAb()
{
// #ifdef TEST
SafeRelease(m_pObjSite);
// #endif
// unregister from Msgr list
if(m_pCMsgrList)
{
m_pCMsgrList->UnRegisterUIWnd(m_hWnd);
OE_CloseMsgrList(m_pCMsgrList);
m_pCMsgrList = NULL;
}
SafeMemFree(m_szOnline);
// SafeMemFree(m_szInvisible);
SafeMemFree(m_szBusy);
SafeMemFree(m_szBack);
SafeMemFree(m_szAway);
SafeMemFree(m_szOnPhone);
SafeMemFree(m_szLunch);
SafeMemFree(m_szOffline);
SafeMemFree(m_szIdle);
SafeMemFree(m_szMsgrEmptyList);
SafeMemFree(m_szEmptyList);
SafeMemFree(m_szLeftBr);
SafeMemFree(m_szRightBr);
// Raid-32933: OE: MSIMN.EXE doesn't always exit
// g_pInstance->CoDecrementInit();
#ifdef LATER
g_pInstance->DllRelease();
#endif
}
LRESULT CIEMsgAb::OnDestroy(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
WORD wShow;
if(m_fShowOnlineContacts)
wShow = 2;
else if(m_fShowOfflineContacts)
wShow = 1;
else
wShow = 0;
DwSetOptions((DWORD) MAKELONG(wShow, m_nSortType));
// KillTimer(IDT_PANETIMER);
if(m_delItem != 0)
m_fNoRemove = TRUE;
// else
// m_fNoRemove = FALSE;
m_delItem = ListView_GetItemCount(m_ctlList);
#ifdef LATER
if (m_dwFontCacheCookie && g_lpIFontCache)
{
IConnectionPoint *pConnection = NULL;
if (SUCCEEDED(g_lpIFontCache->QueryInterface(IID_IConnectionPoint, (LPVOID *) &pConnection)))
{
pConnection->Unadvise(m_dwFontCacheCookie);
pConnection->Release();
}
}
m_cAddrBook.Unadvise();
#endif
// RevokeDragDrop(m_hWnd);
if (m_himl != NULL)
ImageList_Destroy(m_himl);
return 0;
}
HRESULT CIEMsgAb::OnDraw(ATL_DRAWINFO& di)
{
RECT& rc = *(RECT*)di.prcBounds;
#if 0
int patGray[4];
HBITMAP hbm;
HBRUSH hbr;
COLORREF cFg;
COLORREF cBkg;
// Initialize the pattern
patGray[0] = 0x005500AA;
patGray[1] = 0x005500AA;
patGray[2] = 0x005500AA;
patGray[3] = 0x005500AA;
// Create a bitmap from the pattern
hbm = CreateBitmap(8, 8, 1, 1, (LPSTR)patGray);
if ((HBITMAP) NULL != hbm)
{
hbr = CreatePatternBrush(hbm);
if (hbr)
{
// Select the right colors into the DC
cFg = SetTextColor(di.hdcDraw, GetSysColor(COLOR_3DFACE));
cBkg = SetBkColor(di.hdcDraw, RGB(255, 255, 255));
// Fill the rectangle
FillRect(di.hdcDraw, &rc, hbr);
SetTextColor(di.hdcDraw, cFg);
SetBkColor(di.hdcDraw, cBkg);
DeleteObject(hbr);
}
DeleteObject(hbm);
}
#endif
// Rectangle(di.hdcDraw, rc.left, rc.top, rc.right, rc.bottom);
return S_OK;
}
LRESULT CIEMsgAb::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
// Define a bogus rectangle for the controls. They will get resized in
// our size handler.
RECT rcPos = {0, 0, 100, 100};
WCHAR sz[CCHMAX_STRINGRES];
// Create the various controls
m_ctlList.Create(m_hWnd, rcPos, _T("Outlook Express Address Book ListView"),
WS_TABSTOP | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN |
LVS_REPORT | LVS_NOCOLUMNHEADER | LVS_SHOWSELALWAYS | LVS_SHAREIMAGELISTS /* | LVS_SORTASCENDING*/);
if(m_ctlList.m_hWnd == NULL)
{
DWORD dwErr = GetLastError();
Assert(FALSE);
}
ListView_SetUnicodeFormat(m_ctlList, TRUE);
ListView_SetExtendedListViewStyleEx(m_ctlList, LVS_EX_INFOTIP | LVS_EX_LABELTIP, LVS_EX_INFOTIP | LVS_EX_LABELTIP);
// Image List
Assert(m_himl == NULL);
m_himl = ImageList_LoadImage(g_hLocRes, MAKEINTRESOURCE(idbAddrBookHot), 16, 0,
RGB(255, 0, 255), IMAGE_BITMAP,
LR_LOADMAP3DCOLORS | LR_CREATEDIBSECTION);
ListView_SetImageList(m_ctlList, m_himl, LVSIL_SMALL);
LVCOLUMN lvc;
lvc.mask = LVCF_SUBITEM;
lvc.iSubItem = 0;
ListView_InsertColumn(m_ctlList, 0, &lvc);
#ifdef LATER
m_ctlList.SendMessage(WM_SETFONT, NULL, 0);
SetListViewFont(m_ctlList, GetListViewCharset(), TRUE);
if (g_lpIFontCache)
{
IConnectionPoint *pConnection = NULL;
if (SUCCEEDED(g_lpIFontCache->QueryInterface(IID_IConnectionPoint, (LPVOID *) &pConnection)))
{
pConnection->Advise((IUnknown *)(IFontCacheNotify *) this, &m_dwFontCacheCookie);
pConnection->Release();
}
}
#endif
if(!m_dwHideMessenger && !m_dwDisableMessenger)
{
// Msgr Initialization
m_pCMsgrList = OE_OpenMsgrList();
// Register our control for Msgr list
if(m_pCMsgrList)
{
m_pCMsgrList->RegisterUIWnd(m_hWnd);
if(m_pCMsgrList->IsLocalOnline())
{
m_fLogged = TRUE;
FillMsgrList();
}
}
}
// Initialize the address book object too
m_fWAB = CheckForWAB();
if(m_fWAB)
{
HRESULT hr = m_cAddrBook.OpenWabFile(m_fWAB);
if(hr == S_OK) // && m_fShowAllContacts)
m_cAddrBook.LoadWabContents(m_ctlList, this);
}
else
{ if(m_fShowAllContacts)
{
// Bug 23934. We show only online/offline contacts if we use Outlook
m_fShowAllContacts = FALSE;
m_fShowOnlineContacts = FALSE;
m_fShowOfflineContacts = TRUE;
}
}
st_pAddrBook = &m_cAddrBook;
// Sort and Select the first item
ListView_SortItems(m_ctlList, BA_Sort, m_nSortType);
ListView_SetItemState(m_ctlList, 0, LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED);
// Add the tooltip
// Load Tooltip strings
if(AthLoadString(idsBAOnline, sz, ARRAYSIZE(sz)))
{
ULONG cchSize = lstrlenW(sz) + 1;
if(MemAlloc((LPVOID *) &m_szOnline, cchSize * sizeof(WCHAR)))
StrCpyNW(m_szOnline, sz, cchSize);
}
if(AthLoadString(idsBABusy, sz, ARRAYSIZE(sz)))
{
ULONG cchSize = lstrlenW(sz) + 1;
if(MemAlloc((LPVOID *) &m_szBusy, cchSize*sizeof(WCHAR)))
StrCpyNW(m_szBusy, sz, cchSize);
}
if(AthLoadString(idsBABack, sz, ARRAYSIZE(sz)))
{
ULONG cchSize = lstrlenW(sz) + 1;
if(MemAlloc((LPVOID *) &m_szBack, cchSize*sizeof(WCHAR)))
StrCpyNW(m_szBack, sz, cchSize);
}
if(AthLoadString(idsBAAway, sz, ARRAYSIZE(sz)))
{
ULONG cchSize = lstrlenW(sz) + 1;
if(MemAlloc((LPVOID *) &m_szAway, cchSize*sizeof(WCHAR)))
StrCpyNW(m_szAway, sz, cchSize);
}
if(AthLoadString(idsBAOnPhone, sz, ARRAYSIZE(sz)))
{
ULONG cchSize = lstrlenW(sz) + 1;
if(MemAlloc((LPVOID *) &m_szOnPhone, cchSize*sizeof(WCHAR)))
StrCpyNW(m_szOnPhone, sz, cchSize);
}
if(AthLoadString(idsBALunch, sz, ARRAYSIZE(sz)))
{
ULONG cchSize = lstrlenW(sz) + 1;
if(MemAlloc((LPVOID *) &m_szLunch, cchSize*sizeof(WCHAR)))
StrCpyNW(m_szLunch, sz, cchSize);
}
if(AthLoadString(idsBAOffline, sz, ARRAYSIZE(sz)))
{
ULONG cchSize = lstrlenW(sz) + 1;
if(MemAlloc((LPVOID *) &m_szOffline, cchSize*sizeof(WCHAR)))
StrCpyNW(m_szOffline, sz, cchSize);
}
if(AthLoadString(idsBAIdle, sz, ARRAYSIZE(sz)))
{
ULONG cchSize = lstrlenW(sz) + 1;
if(MemAlloc((LPVOID *) &m_szIdle, cchSize*sizeof(WCHAR)))
StrCpyNW(m_szIdle, sz, cchSize);
}
if(AthLoadString(idsMsgrEmptyList, sz, ARRAYSIZE(sz)))
{
ULONG cchSize = lstrlenW(sz) + 1;
if(MemAlloc((LPVOID *) &m_szEmptyList, cchSize*sizeof(WCHAR)))
StrCpyNW(m_szEmptyList, sz, cchSize);
}
if(AthLoadString(idsMSNEmptyList, sz, ARRAYSIZE(sz)))
{
ULONG cchSize = lstrlenW(sz) + 1;
if(MemAlloc((LPVOID *) &m_szMsgrEmptyList, cchSize*sizeof(WCHAR)))
StrCpyNW(m_szMsgrEmptyList, sz, cchSize);
}
if(AthLoadString(idsLeftBr, sz, ARRAYSIZE(sz)))
{
ULONG cchSize = lstrlenW(sz) + 1;
if(MemAlloc((LPVOID *) &m_szLeftBr, cchSize*sizeof(WCHAR)))
StrCpyNW(m_szLeftBr, sz, cchSize);
}
if(AthLoadString(idsRightBr, sz, ARRAYSIZE(sz)))
{
ULONG cchSize = lstrlenW(sz) + 1;
if(MemAlloc((LPVOID *) &m_szRightBr, cchSize*sizeof(WCHAR)))
StrCpyNW(m_szRightBr, sz, cchSize);
}
m_ctlList.SetFocus();
// Register ourselves as a drop target
// RegisterDragDrop(m_hWnd, (IDropTarget *) this);
// Update the size of the listview columns
_AutosizeColumns();
if(ListView_GetItemCount(m_ctlList) > 0)
m_cEmptyList.Hide();
else
m_cEmptyList.Show(m_ctlList, (LPWSTR) (m_fShowAllContacts ? m_szEmptyList : m_szMsgrEmptyList));
// SetTimer(IDT_PANETIMER, ELAPSE_MOUSEOVERCHECK, NULL);
// Finished
return (0);
}
LRESULT CIEMsgAb::OnSetFocus(UINT nMsg , WPARAM wParam , LPARAM lParam , BOOL& bHandled )
{
CComControlBase::OnSetFocus(nMsg, wParam, lParam, bHandled);
m_ctlList.SetFocus();
#ifdef TEST
if (m_pObjSite)
{
m_pObjSite->OnFocusChangeIS((IInputObject*) this, TRUE);
}
#endif //TEST
return 0;
}
LRESULT CIEMsgAb::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
RECT rc;
DWORD width = LOWORD(lParam);
DWORD height = HIWORD(lParam);
// Position the listview to fill the entire area
RECT rcList;
rcList.left = 0;
rcList.top = 0;
rcList.right = width;
rcList.bottom = height;
m_ctlList.SetWindowPos(NULL, &rcList, SWP_NOACTIVATE | SWP_NOZORDER);
// Update the size of the listview columns
_AutosizeColumns();
// bHandled = FALSE;
return (0);
}
void CIEMsgAb::_AutosizeColumns(void)
{
RECT rcList;
m_ctlList.GetClientRect(&rcList);
ListView_SetColumnWidth(m_ctlList, 0, rcList.right - 5);
}
#ifdef LATER
//
// FUNCTION: CMessageList::OnPreFontChange()
//
// PURPOSE: Get's hit by the Font Cache before it changes the fonts we're
// using. In response we tell the ListView to dump any custom
// font's it's using.
//
STDMETHODIMP CIEMsgAb::OnPreFontChange(void)
{
m_ctlList.SendMessage(WM_SETFONT, 0, 0);
return (S_OK);
}
//
// FUNCTION: CMessageList::OnPostFontChange()
//
// PURPOSE: Get's hit by the Font Cache after it updates the font's we're
// using. In response, we set the new font for the current charset.
//
STDMETHODIMP CIEMsgAb::OnPostFontChange(void)
{
SetListViewFont(m_ctlList, GetListViewCharset(), TRUE);
return (S_OK);
}
#endif
LRESULT CIEMsgAb::CmdSetOnline(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
LPMABENTRY pEntry = GetSelectedEntry();
if(!pEntry || (pEntry->tag == LPARAM_MENTRY) || !m_pCMsgrList)
return S_FALSE;
// m_cAddrBook.SetDefaultMsgrID(pEntry->lpSB, pEntry->pchWABID);
if(m_pCMsgrList && (PromptToGoOnline() == S_OK) )
m_pCMsgrList->AddUser(pEntry->pchWABID);
return S_OK;
}
LRESULT CIEMsgAb::CmdNewOnlineContact(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
if(m_pCMsgrList)
{
if(PromptToGoOnline() == S_OK)
m_pCMsgrList->NewOnlineContact();
}
return S_OK;
}
LRESULT CIEMsgAb::CmdNewContact(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
// Tell the WAB to bring up it's new contact UI
HRESULT hr = S_OK;
if(!m_cAddrBook.fIsWabLoaded())
{
if(FAILED(hr = m_cAddrBook.OpenWabFile(m_fWAB)))
goto exit;
}
if(FAILED(hr = m_cAddrBook.NewContact(m_hWnd)))
goto exit;
_ReloadListview();
exit:
return (hr);
}
LRESULT CIEMsgAb::NewInstantMessage(LPMABENTRY pEntry)
{
if(((INT_PTR) pEntry) == -1)
return(m_pCMsgrList->SendInstMessage(NULL));
else if(m_pCMsgrList)
{
if(PromptToGoOnline() == S_OK)
return(m_pCMsgrList->SendInstMessage(pEntry->lpMsgrInfo->pchID));
}
return(S_OK);
}
LRESULT CIEMsgAb::CmdDialPhone(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
return(CallPhone(NULL, FALSE));
}
LRESULT CIEMsgAb::CmdHomePhone(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
LPMABENTRY pEntry = GetSelectedEntry();
if(!pEntry || !(pEntry->lpPhones))
{
Assert(FALSE);
return(E_FAIL);
}
return(CallPhone(pEntry->lpPhones->pchHomePhone, (pEntry->tag == LPARAM_MENTRY)));
}
LRESULT CIEMsgAb::CmdWorkPhone(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
LPMABENTRY pEntry = GetSelectedEntry();
if(!pEntry || !(pEntry->lpPhones))
{
Assert(FALSE);
return(E_FAIL);
}
return(CallPhone(pEntry->lpPhones->pchWorkPhone, (pEntry->tag == LPARAM_MENTRY)));
}
LRESULT CIEMsgAb::CmdMobilePhone(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
LPMABENTRY pEntry = GetSelectedEntry();
if(!pEntry || !(pEntry->lpPhones))
{
Assert(FALSE);
return(E_FAIL);
}
return(CallPhone(pEntry->lpPhones->pchMobilePhone, (pEntry->tag == LPARAM_MENTRY)));
}
LRESULT CIEMsgAb::CmdIPPhone(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
LPMABENTRY pEntry = GetSelectedEntry();
if(!pEntry || !(pEntry->lpPhones))
{
Assert(FALSE);
return(E_FAIL);
}
return(CallPhone(pEntry->lpPhones->pchIPPhone, (pEntry->tag == LPARAM_MENTRY)));
}
LRESULT CIEMsgAb::CallPhone(WCHAR *wszPhone, BOOL fMessengerContact)
{
WCHAR wszTmp[MAX_PATH] ={0};
if((lstrlenW(wszPhone) + 5) >= MAX_PATH)
return(E_FAIL);
if(!(!m_pCMsgrList || !m_pCMsgrList->IsLocalOnline()))
{
// Use Messenger API
if(fMessengerContact)
{
StrCpyNW(wszTmp, L"+", ARRAYSIZE(wszTmp));
StrCatBuffW(wszTmp, wszPhone, ARRAYSIZE(wszTmp));
}
else
StrCpyNW(wszTmp, wszPhone, ARRAYSIZE(wszTmp));
if(SUCCEEDED(m_pCMsgrList->LaunchPhoneUI(wszTmp)))
return(S_OK);
}
Assert(IsTelInstalled());
StrCpyNW(wszTmp, L"Tel:", ARRAYSIZE(wszTmp));
if(wszPhone)
{
StrCatBuffW(wszTmp, wszPhone, ARRAYSIZE(wszTmp));
}
SHELLEXECUTEINFOW ExecInfo;
ExecInfo.cbSize = sizeof(SHELLEXECUTEINFOW);
ExecInfo.nShow = SW_SHOWNORMAL;
ExecInfo.fMask = 0;
ExecInfo.hwnd = m_hWnd;
ExecInfo.lpDirectory = NULL;
ExecInfo.lpParameters = NULL;
ExecInfo.lpVerb = L"open";
ExecInfo.lpFile = wszTmp;
if(!ShellExecuteExW(&ExecInfo))
{
WCHAR wszMsg[CCHMAX_STRINGRES];
WCHAR wszTitle[CCHMAX_STRINGRES];
if(!AthLoadString(idsAthena, wszTitle, ARRAYSIZE(wszTitle)))
wszTitle[0] = L'\0';
if(!AthLoadString(idsTelFail, wszMsg, ARRAYSIZE(wszMsg)))
wszMsg[0] = L'\0';
MessageBoxW(NULL, wszMsg, wszTitle, MB_OK | MB_ICONSTOP);
}
return(S_OK);
}
LRESULT CIEMsgAb::CmdNewEmaile(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
LVITEM lvi;
LPMABENTRY pEntry;
LPRECIPLIST lpList = NULL;
LPRECIPLIST lpListNext = lpList;
ULONG nRecipCount = 0;
TCHAR szBuf[MAX_PATH];
HRESULT hr = S_OK;
// Loop through the selected items
lvi.mask = LVIF_PARAM;
lvi.iItem = -1;
lvi.iSubItem = 0;
while (-1 != (lvi.iItem = ListView_GetNextItem(m_ctlList, lvi.iItem, LVIS_SELECTED)))
{
// We need to get the entry ID from the item
ListView_GetItem(m_ctlList, &lvi);
// Tell the data source to add this person to the message
pEntry = (LPMABENTRY) lvi.lParam;
Assert(pEntry);
if(pEntry->tag == LPARAM_MABENTRY || pEntry->tag == LPARAM_ABENTRY)
{
// m_cAddrBook.AddRecipient(pAddrTableW, pEntry->lpSB, FALSE);
lpListNext = AddTeimToRecipList(lpListNext, pEntry->pchWABID, pEntry->pchWABName, pEntry->lpSB);
if(!lpList)
lpList = lpListNext;
nRecipCount++;
}
/* else if(pEntry->tag == LPARAM_ABGRPENTRY)
m_cAddrBook.AddRecipient(pAddrTableW, pEntry->lpSB, TRUE);*/
else if(pEntry->tag == LPARAM_MENTRY)
{
Assert(pEntry->lpMsgrInfo);
lpListNext = AddTeimToRecipList(lpListNext, pEntry->lpMsgrInfo->pchID, pEntry->lpMsgrInfo->pchMsgrName, NULL);
if(!lpList)
lpList = lpListNext;
nRecipCount++;
}
else
Assert(FALSE);
}
if(nRecipCount)
hr = HrStartMailThread( m_hWnd, nRecipCount,
lpList, // HrSendMail frees lpList so dont reuse
CheckForOutlookExpress(szBuf, ARRAYSIZE(szBuf)));
return (hr);
}
LRESULT CIEMsgAb::CmdNewIMsg(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
return(CmdNewMessage(wNotifyCode, ID_SEND_INSTANT_MESSAGE, hWndCtl, bHandled));
}
LRESULT CIEMsgAb::CmdNewMessage(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
LVITEM lvi;
LPMABENTRY pEntry;
pEntry = GetEntryForSendInstMsg();
if(wID == ID_SEND_INSTANT_MESSAGE)
{
if(pEntry)
return(NewInstantMessage(pEntry));
else
{
Assert(FALSE);
return(-1);
}
}
else if((((INT_PTR) pEntry) != -1) && pEntry)
return(NewInstantMessage(pEntry));
else
return(CmdNewEmaile(wNotifyCode, wID, hWndCtl, bHandled));
}
// Exec for Properties command
LRESULT CIEMsgAb::CmdProperties(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = S_OK;
LPMABENTRY pEntry = GetSelectedEntry();
if(pEntry)
{
if(pEntry->tag == LPARAM_MABENTRY || pEntry->tag == LPARAM_ABENTRY || pEntry->tag == LPARAM_ABGRPENTRY)
{
if(!m_cAddrBook.fIsWabLoaded())
{
if(FAILED(hr = m_cAddrBook.OpenWabFile(m_fWAB)))
return(hr);
}
m_cAddrBook.ShowDetails(m_hWnd, pEntry->lpSB);
}
}
_ReloadListview();
return (0);
}
LRESULT CIEMsgAb::NotifyDeleteItem(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)
{
NMLISTVIEW *pnmlv = (NMLISTVIEW *) pnmh;
LVITEM lvi;
lvi.mask = LVIF_PARAM;
lvi.iItem = pnmlv->iItem;
lvi.iSubItem = 0;
ListView_GetItem(m_ctlList, &lvi);
LPMABENTRY pEntry = (LPMABENTRY) lvi.lParam;
if(pEntry->tag == LPARAM_MABENTRY || pEntry->tag == LPARAM_ABENTRY || pEntry->tag == LPARAM_ABGRPENTRY)
{
Assert(m_cAddrBook.fIsWabLoaded());
m_cAddrBook.FreeListViewItem(pEntry->lpSB);
}
RemoveBlabEntry(pEntry);
if(m_delItem > 0)
m_delItem--;
else
Assert(FALSE);
return (0);
}
LRESULT CIEMsgAb::NotifyItemChanged(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)
{
ULONG uChanged;
NMLISTVIEW *pnmlv = (NMLISTVIEW *) pnmh;
if (pnmlv->uChanged & LVIF_STATE)
{
uChanged = pnmlv->uNewState ^ pnmlv->uOldState;
if (uChanged & LVIS_SELECTED)
_EnableCommands();
}
return (0);
}
// Sort compare
int CALLBACK BA_Sort(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
{
LPMABENTRY pEntry1 = (LPMABENTRY) lParam1;
LPMABENTRY pEntry2 = (LPMABENTRY) lParam2;
WCHAR pchName1[MAXNAME];
WCHAR pchName2[MAXNAME];
int nIndex1 = 0;
int nIndex2 = 0 ;
if(!(pEntry1->lpMsgrInfo))
{
nIndex1 = sizeof(BA_SortOrder)/sizeof(int);
if(pEntry1->tag == LPARAM_ABGRPENTRY)
nIndex1++;
}
else
{
while((pEntry1->lpMsgrInfo) && (BA_SortOrder[nIndex1] != pEntry1->lpMsgrInfo->nStatus) && (BA_SortOrder[nIndex1] != BIMSTATE_UNKNOWN))
nIndex1++;
}
if(!(pEntry2->lpMsgrInfo))
{
nIndex2 = sizeof(BA_SortOrder)/sizeof(int);
if(pEntry2->tag == LPARAM_ABGRPENTRY)
nIndex2++;
}
else
{
while((BA_SortOrder[nIndex2] != pEntry2->lpMsgrInfo->nStatus) && (BA_SortOrder[nIndex2] != BIMSTATE_UNKNOWN))
nIndex2++;
}
if(pEntry1->tag == LPARAM_MENTRY) // if no AB entry
StrCpyNW(pchName1, pEntry1->lpMsgrInfo->pchMsgrName, ARRAYSIZE(pchName1));
else
StrCpyNW(pchName1, pEntry1->pchWABName, ARRAYSIZE(pchName1));
// st_pAddrBook->GetDisplayName(pEntry1->lpSB, pchName1);
pchName1[ARRAYSIZE(pchName1) - 1] = L'\0';
if(pEntry2->tag == LPARAM_MENTRY) // if no AB entry
StrCpyNW(pchName2, pEntry2->lpMsgrInfo->pchMsgrName, ARRAYSIZE(pchName2));
else
StrCpyNW(pchName2, pEntry2->pchWABName, ARRAYSIZE(pchName2));
// st_pAddrBook->GetDisplayName(pEntry2->lpSB, pchName2);
pchName2[ARRAYSIZE(pchName2) - 1] = L'\0';
switch(lParamSort)
{
case BASORT_NAME_ACSEND:
return(lstrcmpiW(pchName1, pchName2));
case BASORT_NAME_DESCEND:
return(lstrcmpiW(pchName2, pchName1));
default:
if((pEntry1->lpMsgrInfo) && (pEntry2->lpMsgrInfo) && (pEntry1->lpMsgrInfo->nStatus == pEntry2->lpMsgrInfo->nStatus))
{
if(lParamSort == BASORT_STATUS_ACSEND)
return(lstrcmpiW(pchName1, pchName2));
else
return(lstrcmpiW(pchName2, pchName1));
}
else
{
if(lParamSort == BASORT_STATUS_ACSEND)
return(nIndex1 - nIndex2);
else
return(nIndex2 - nIndex1);
}
}
Assert(FALSE);
return(0);
}
void CIEMsgAb::_EnableCommands(void)
{
#ifdef LATER
if(g_pBrowser)
g_pBrowser->UpdateToolbar();
#endif
}
LRESULT CIEMsgAb::NotifyItemActivate(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)
{
return (SendMessage(WM_COMMAND, ID_SEND_INSTANT_MESSAGE2, 0));
}
// GETDISPLAYINFO notification message
LRESULT CIEMsgAb::NotifyGetDisplayInfo(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)
{
LV_DISPINFOW * plvdi = (LV_DISPINFOW *)pnmh;
LRESULT hr;
if(plvdi->item.lParam)
{
LPMABENTRY pEntry = (LPMABENTRY) plvdi->item.lParam;
LPMABENTRY pFindEntry = NULL;
if (plvdi->item.mask & LVIF_IMAGE)
{
if((hr = SetUserIcon(pEntry, (pEntry->lpMsgrInfo ? pEntry->lpMsgrInfo->nStatus : BIMSTATE_OFFLINE), &(plvdi->item.iImage) ) ) != S_OK)
return(hr);
}
if (plvdi->item.mask & LVIF_TEXT)
{
if(pEntry->tag == LPARAM_ABENTRY || pEntry->tag == LPARAM_ABGRPENTRY)
{
// if((hr = m_cAddrBook.GetDisplayName(pEntry->lpSB, plvdi->item.pszText)) != S_OK)
// return(hr);
Assert(pEntry->pchWABName);
StrCpyNW(plvdi->item.pszText, pEntry->pchWABName, plvdi->item.cchTextMax - 1);
plvdi->item.pszText[plvdi->item.cchTextMax - 1] = L'\0';
}
else if(pEntry->tag == LPARAM_MABENTRY || pEntry->tag == LPARAM_MENTRY)
{
#ifdef LATER
if(pEntry->tag == LPARAM_MENTRY && (pEntry->lpMsgrInfo->nStatus == BIMSTATE_ONLINE) &&
lstrcmpiW(pEntry->lpMsgrInfo->pchMsgrName, pEntry->lpMsgrInfo->pchID) && m_fWAB)
{
StrCpyN(plvdi->item.pszText, pEntry->lpMsgrInfo->pchMsgrName, plvdi->item.cchTextMax - 1);
plvdi->item.pszText[plvdi->item.cchTextMax - 1] = L'\0';
// Don't need redraw now, do it later
hr = MAPI_E_COLLISION; // m_cAddrBook.AutoAddContact(pEntry->lpMsgrInfo->pchMsgrName, pEntry->lpMsgrInfo->pchID);
if(hr == MAPI_E_COLLISION) // already have a contact in AB
{
int Index = -1;
WCHAR *pchID = NULL;
ULONG cchSize = lstrlenW(pEntry->lpMsgrInfo->pchID) + 1;
if(MemAlloc((LPVOID *) &pchID, cchSize * sizeof(WCHAR)))
{
StrCpyN(pchID, pEntry->lpMsgrInfo->pchID, cchSize);
do
{
pFindEntry = FindUserEmail(pchID, &Index, FALSE);
}while((pFindEntry != NULL) && (pFindEntry->tag == LPARAM_MENTRY));
if(pFindEntry != NULL)
{
hr = m_cAddrBook.SetDefaultMsgrID(pFindEntry->lpSB, pchID);
if(hr == S_OK)
_ReloadListview();
}
MemFree(pchID);
}
}
//if we not found...
if(hr != S_OK)
{
hr = m_cAddrBook.AutoAddContact(pEntry->lpMsgrInfo->pchMsgrName, pEntry->lpMsgrInfo->pchID);
if(hr == S_OK)
_ReloadListview();
}
}
else
{
#endif //LATER
StrCpyNW(plvdi->item.pszText, pEntry->lpMsgrInfo->pchMsgrName, plvdi->item.cchTextMax - 1);
plvdi->item.pszText[plvdi->item.cchTextMax - 1] = L'\0';
// plvdi->item.pszText = pEntry->lpMsgrInfo->pchMsgrName;
// }
}
else // Unknown tag
Assert(FALSE);
}
}
return S_OK;
}
LRESULT CIEMsgAb::NotifyGetInfoTip(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)
{
NMLVGETINFOTIPW *plvgit = (NMLVGETINFOTIPW *) pnmh;
LVITEM lvi;
lvi.mask = LVIF_PARAM;
lvi.iItem = plvgit->iItem;
lvi.iSubItem = plvgit->iSubItem;
ListView_GetItem(m_ctlList, &lvi);
LPMABENTRY pEntry = (LPMABENTRY) lvi.lParam;
if (pEntry->lpMsgrInfo != NULL)
{
StrCpyNW(plvgit->pszText, pEntry->lpMsgrInfo->pchMsgrName, plvgit->cchTextMax);
StrCatBuffW(plvgit->pszText, m_szLeftBr, plvgit->cchTextMax);
StrCatBuffW(plvgit->pszText, pEntry->lpMsgrInfo->pchID, plvgit->cchTextMax);
StrCatBuffW(plvgit->pszText, m_szRightBr, plvgit->cchTextMax);
LPCWSTR szStatus;
switch(pEntry->lpMsgrInfo->nStatus)
{
case BIMSTATE_ONLINE:
szStatus = m_szOnline;
break;
case BIMSTATE_BUSY:
szStatus = m_szBusy;
break;
case BIMSTATE_BE_RIGHT_BACK:
szStatus = m_szBack;
break;
case BIMSTATE_IDLE:
szStatus = m_szIdle;
break;
case BIMSTATE_AWAY:
szStatus = m_szAway;
break;
case BIMSTATE_ON_THE_PHONE:
szStatus = m_szOnPhone;
break;
case BIMSTATE_OUT_TO_LUNCH:
szStatus = m_szLunch;
break;
default:
szStatus = m_szOffline;
break;
}
StrCatBuffW(plvgit->pszText, szStatus, plvgit->cchTextMax);
}
else if (plvgit->dwFlags & LVGIT_UNFOLDED)
{
// If this is not a messenger item and the text
// isn't truncated do not display a tooltip.
plvgit->pszText[0] = L'\0';
}
return 0;
}
LRESULT CIEMsgAb::SetUserIcon(LPMABENTRY pEntry, int nStatus, int * pImage)
{
switch(pEntry->tag)
{
case LPARAM_MENTRY:
case LPARAM_MABENTRY:
{
switch(nStatus)
{
case BIMSTATE_ONLINE:
*pImage = IMAGE_ONLINE;
break;
case BIMSTATE_INVISIBLE:
*pImage = IMAGE_STOPSIGN;
break;
case BIMSTATE_BUSY:
*pImage = IMAGE_STOPSIGN;
break;
case BIMSTATE_BE_RIGHT_BACK:
*pImage = IMAGE_CLOCKSIGN; // IMAGE_BE_RIGHT_BACK;
break;
case BIMSTATE_IDLE:
*pImage = IMAGE_CLOCKSIGN; // IMAGE_IDLE;
break;
case BIMSTATE_AWAY:
*pImage = IMAGE_CLOCKSIGN; // IMAGE_AWAY;
break;
case BIMSTATE_ON_THE_PHONE:
*pImage = IMAGE_STOPSIGN; // IMAGE_ON_THE_PHONE;
break;
case BIMSTATE_OUT_TO_LUNCH:
*pImage = IMAGE_CLOCKSIGN; // IMAGE_OUT_TO_LUNCH;
break;
default:
*pImage = IMAGE_OFFLINE;
break;
}
}
break;
case LPARAM_ABGRPENTRY:
// WAB group
*pImage = IMAGE_DISTRIBUTION_LIST;
break;
default:
// Not a buddy...
if(pEntry->fCertificate)
*pImage = IMAGE_CERT;
else
*pImage = IMAGE_NEW_MESSAGE;
break;
}
return(S_OK);
}
// Return MAB entry for first selected item
LPMABENTRY CIEMsgAb::GetSelectedEntry()
{
LVITEM lvi;
// Get the focused item
lvi.iItem = ListView_GetNextItem(m_ctlList, -1, LVNI_SELECTED | LVNI_FOCUSED);
// Get the lParam for that item
if (lvi.iItem != -1)
{
lvi.iSubItem = 0;
lvi.mask = LVIF_PARAM;
if(ListView_GetItem(m_ctlList, &lvi))
return((LPMABENTRY) lvi.lParam);
}
return(NULL); // unscucces
}
/*
LRESULT CIEMsgAb::CmdMsgrOptions(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
return(m_pCMsgrList->LaunchOptionsUI()); // (MOPTDLG_GENERAL_PAGE);
}
*/
// Check entry for possibility to send Instant message
LPMABENTRY CIEMsgAb::GetEntryForSendInstMsg(LPMABENTRY pEntry)
{
if(!IsMessengerInstalled())
return(NULL);
if(ListView_GetSelectedCount(m_ctlList) == 1)
{
if(!pEntry) // if we don'y have pEntry yet then get it
pEntry = GetSelectedEntry();
if(pEntry && (pEntry->tag == LPARAM_MABENTRY || pEntry->tag == LPARAM_MENTRY) &&
(pEntry->lpMsgrInfo->nStatus != BIMSTATE_OFFLINE) && (pEntry->lpMsgrInfo->nStatus != BIMSTATE_INVISIBLE) &&
!(m_pCMsgrList->IsLocalName(pEntry->lpMsgrInfo->pchID)))
return(pEntry);
}
#ifdef NEED
if(m_pCMsgrList)
{
if(m_pCMsgrList->IsLocalOnline() && (m_pCMsgrList->GetCount() > 0))
return(NULL); // should be /*return((LPMABENTRY) -1);*/ - temporary disabled (YST)
}
#endif
return(NULL);
}
// Display right-mouse click (context) menu
LRESULT CIEMsgAb::OnContextMenu(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
LPMABENTRY pEntry;
HMENU hPopup = 0;
HWND hwndHeader;
int id = 0;
POINT pt = { (int)(short) LOWORD(lParam), (int)(short) HIWORD(lParam) };
int n = -1;
// Figure out if this came from the keyboard or not
if (lParam == -1)
{
Assert((HWND) wParam == m_ctlList);
int i = ListView_GetFirstSel(m_ctlList);
if (i == -1)
return (0);
ListView_GetItemPosition(m_ctlList, i, &pt);
m_ctlList.ClientToScreen(&pt);
}
LVHITTESTINFO lvhti;
lvhti.pt = pt;
m_ctlList.ScreenToClient(&lvhti.pt);
ListView_HitTest(m_ctlList, &lvhti);
if (lvhti.iItem == -1)
return (0);
// Load the context menu
hPopup = LoadPopupMenu(IDR_BA_POPUP);
if (!hPopup)
goto exit;
pEntry = GetSelectedEntry();
pEntry = GetEntryForSendInstMsg(pEntry);
if(pEntry)
SetMenuDefaultItem(hPopup, ID_SEND_INSTANT_MESSAGE, FALSE);
else
SetMenuDefaultItem(hPopup, ID_SEND_MESSAGE, FALSE);
if (!m_pCMsgrList)
{
DeleteMenu(hPopup, ID_SEND_INSTANT_MESSAGE, MF_BYCOMMAND);
DeleteMenu(hPopup, ID_SET_ONLINE_CONTACT, MF_BYCOMMAND);
DeleteMenu(hPopup, ID_NEW_ONLINE_CONTACT, MF_BYCOMMAND);
}
MenuUtil_EnablePopupMenu(hPopup, this);
TrackPopupMenuEx(hPopup, TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON,
pt.x, pt.y, m_hWnd, NULL);
exit:
if (hPopup)
DestroyMenu(hPopup);
return (0);
}
//
// FUNCTION: CIEMsgAb::DragEnter()
//
// PURPOSE: This get's called when the user starts dragging an object
// over our target area.
//
// PARAMETERS:
// <in> pDataObject - Pointer to the data object being dragged
// <in> grfKeyState - Pointer to the current key states
// <in> pt - Point in screen coordinates of the mouse
// <out> pdwEffect - Where we return whether this is a valid place for
// pDataObject to be dropped and if so what type of
// drop.
//
// RETURN VALUE:
// S_OK - The function succeeded.
//
STDMETHODIMP CIEMsgAb::DragEnter(IDataObject* pDataObject, DWORD grfKeyState,
POINTL pt, DWORD* pdwEffect)
{
IEnumFORMATETC *pEnum;
FORMATETC fe;
ULONG celtFetched;
// Verify we got this
if (!pDataObject)
return (S_OK);
// Init
ZeroMemory(&fe, sizeof(FORMATETC));
// Set the default return value to be failure
*pdwEffect = DROPEFFECT_NONE;
// Get the FORMATETC enumerator for this data object
if (SUCCEEDED(pDataObject->EnumFormatEtc(DATADIR_GET, &pEnum)))
{
// Walk through the data types to see if we can find the ones we're
// interested in.
pEnum->Reset();
while (S_OK == pEnum->Next(1, &fe, &celtFetched))
{
Assert(celtFetched == 1);
#ifdef LATER
// The only format we care about is CF_INETMSG
if ((fe.cfFormat == CF_INETMSG) /*|| (fe.cfFormat == CF_OEMESSAGES)*/)
{
*pdwEffect = DROPEFFECT_COPY;
break;
}
#endif
}
pEnum->Release();
}
// We we're going to allow the drop, then keep a copy of the data object
if (*pdwEffect != DROPEFFECT_NONE)
{
m_pDataObject = pDataObject;
m_pDataObject->AddRef();
m_cf = fe.cfFormat;
m_fRight = (grfKeyState & MK_RBUTTON);
}
return (S_OK);
}
//
// FUNCTION: CIEMsgAb::DragOver()
//
// PURPOSE: This is called as the user drags an object over our target.
// If we allow this object to be dropped on us, then we will have
// a pointer in m_pDataObject.
//
// PARAMETERS:
// <in> grfKeyState - Pointer to the current key states
// <in> pt - Point in screen coordinates of the mouse
// <out> pdwEffect - Where we return whether this is a valid place for
// pDataObject to be dropped and if so what type of
// drop.
//
// RETURN VALUE:
// S_OK - The function succeeded.
//
STDMETHODIMP CIEMsgAb::DragOver(DWORD grfKeyState, POINTL pt, DWORD* pdwEffect)
{
// If we didn't cache a data object in IDropTarget::DragEnter(), we
// blow this off.
if (NULL == m_pDataObject)
{
*pdwEffect = DROPEFFECT_NONE;
return (S_OK);
}
// We always do a copy
*pdwEffect = DROPEFFECT_COPY;
return (S_OK);
}
//
// FUNCTION: CIEMsgAb::DragLeave()
//
// PURPOSE: Allows us to release any stored data we have from a successful
// DragEnter()
//
// RETURN VALUE:
// S_OK - Everything is groovy
//
STDMETHODIMP CIEMsgAb::DragLeave(void)
{
// Free everything up at this point.
if (NULL != m_pDataObject)
{
m_pDataObject->Release();
m_pDataObject = 0;
m_cf = 0;
}
return (S_OK);
}
//
// FUNCTION: CIEMsgAb::Drop()
//
// PURPOSE: The user has let go of the object over our target. If we
// can accept this object we will already have the pDataObject
// stored in m_pDataObject.
//
// PARAMETERS:
// <in> pDataObject - Pointer to the data object being dragged
// <in> grfKeyState - Pointer to the current key states
// <in> pt - Point in screen coordinates of the mouse
// <out> pdwEffect - Where we return whether this is a valid place for
// pDataObject to be dropped and if so what type of
// drop.
//
// RETURN VALUE:
// S_OK - Everything worked OK
//
STDMETHODIMP CIEMsgAb::Drop(IDataObject* pDataObject, DWORD grfKeyState,
POINTL pt, DWORD* pdwEffect)
{
HRESULT hr = S_OK;
#ifdef LATER
FORMATETC fe;
STGMEDIUM stm;
IMimeMessage *pMessage = 0;
// Get the stream from the DataObject
ZeroMemory(&stm, sizeof(STGMEDIUM));
SETDefFormatEtc(fe, CF_INETMSG, TYMED_ISTREAM);
if (FAILED(hr = pDataObject->GetData(&fe, &stm)))
goto exit;
// Create a new message object
if (FAILED(hr = HrCreateMessage(&pMessage)))
goto exit;
// Load the message from the stream
if (FAILED(hr = pMessage->Load(stm.pstm)))
goto exit;
// If this was a right-drag, then we bring up a context menu etc.
if (m_fRight)
_DoDropMenu(pt, pMessage);
else
_DoDropMessage(pMessage);
exit:
ReleaseStgMedium(&stm);
SafeRelease(pMessage);
m_pDataObject->Release();
m_pDataObject = 0;
m_cf = 0;
#endif
return (hr);
}
HRESULT CIEMsgAb::_DoDropMessage(LPMIMEMESSAGE pMessage)
{
HRESULT hr;
#ifdef LATER
ADDRESSLIST addrList = { 0 };
ULONG i;
SECSTATE secState = {0};
BOOL fSignTrusted = FALSE;
if(FAILED(hr = HandleSecurity(m_hWnd, pMessage)))
return hr;
if (IsSecure(pMessage) && SUCCEEDED(HrGetSecurityState(pMessage, &secState, NULL)))
{
fSignTrusted = !!IsSignTrusted(&secState);
CleanupSECSTATE(&secState);
}
// Get the address list from the message
hr = pMessage->GetAddressTypes(IAT_FROM | IAT_SENDER, IAP_FRIENDLYW | IAP_EMAIL | IAP_ADRTYPE, &addrList);
if (FAILED(hr))
goto exit;
// Loop through the addresses
for (i = 0; i < addrList.cAdrs; i++)
{
if(!m_cAddrBook.fIsWabLoaded())
{
if(FAILED(hr = m_cAddrBook.OpenWabFile(m_fWAB)))
return(hr);
}
m_cAddrBook.AddAddress(addrList.prgAdr[i].pszFriendlyW, addrList.prgAdr[i].pszEmail);
#ifdef DEAD
TCHAR *pch = StrStr(CharUpper(addrList.prgAdr[i].pszEmail), szHotMail);
if((pch != NULL) && m_pCMsgrList)
m_pCMsgrList->AddUser(addrList.prgAdr[i].pszEmail);
#endif // DEAD
}
if(fSignTrusted)
{
FILETIME ftNull = {0};
HrAddSenderCertToWab(NULL, pMessage, NULL, NULL, NULL, ftNull, WFF_CREATE);
}
#ifdef NEEDED
// Reload the table
_ReloadListview();
#endif
exit:
#endif
return (S_OK);
}
HRESULT CIEMsgAb::_DoDropMenu(POINTL pt, LPMIMEMESSAGE pMessage)
{
HRESULT hr = S_OK;
#ifdef LATER
ADDRESSLIST addrList = { 0 };
ULONG i;
HMENU hPopup = 0, hSubMenu = 0;
UINT id = 0;
BOOL fReload = FALSE;
SECSTATE secState = {0};
BOOL fSignTrusted = FALSE;
// Get the address list from the message
if(FAILED(hr = HandleSecurity(m_hWnd, pMessage)))
return hr;
if (IsSecure(pMessage) && SUCCEEDED(HrGetSecurityState(pMessage, &secState, NULL)))
{
fSignTrusted = !!IsSignTrusted(&secState);
CleanupSECSTATE(&secState);
}
hr = pMessage->GetAddressTypes(IAT_KNOWN, IAP_FRIENDLYW | IAP_EMAIL | IAP_ADRTYPE, &addrList);
if (FAILED(hr))
goto exit;
// Load the context menu
hPopup = LoadPopupMenu(IDR_BA_DRAGDROP_POPUP);
if (!hPopup)
goto exit;
// Bold the "Save All" item
MENUITEMINFO mii;
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_STATE;
if (GetMenuItemInfo(hPopup, ID_SAVE_ALL, FALSE, &mii))
{
mii.fState |= MFS_DEFAULT;
SetMenuItemInfo(hPopup, ID_SAVE_ALL, FALSE, &mii);
}
// Create the "Save >" item
hSubMenu = CreatePopupMenu();
// Loop through the addresses
for (i = 0; i < addrList.cAdrs; i++)
{
AppendMenuWrapW(hSubMenu, MF_STRING | MF_ENABLED, ID_SAVE_ADDRESS_FIRST + i, addrList.prgAdr[i].pszFriendlyW);
}
mii.fMask = MIIM_SUBMENU;
mii.hSubMenu = hSubMenu;
SetMenuItemInfo(hPopup, ID_SAVE, FALSE, &mii);
id = TrackPopupMenuEx(hPopup, TPM_RETURNCMD | TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON,
pt.x, pt.y, m_hWnd, NULL);
if (id == ID_SAVE_ALL_ADDRESSES)
{
for (i = 0; i < addrList.cAdrs; i++)
{
m_cAddrBook.AddAddress(addrList.prgAdr[i].pszFriendlyW, addrList.prgAdr[i].pszEmail);
}
fReload = TRUE;
}
else if (id >= ID_SAVE_ADDRESS_FIRST && id < ID_SAVE_ADDRESS_LAST)
{
m_cAddrBook.AddAddress(addrList.prgAdr[id - ID_SAVE_ADDRESS_FIRST].pszFriendlyW,
addrList.prgAdr[id - ID_SAVE_ADDRESS_FIRST].pszEmail);
fReload = TRUE;
}
if(fSignTrusted)
{
FILETIME ftNull = {0};
HrAddSenderCertToWab(NULL, pMessage, NULL, NULL, NULL, ftNull, WFF_CREATE);
}
if (fReload)
{
// Reload the table
_ReloadListview();
}
exit:
if (hSubMenu)
DestroyMenu(hSubMenu);
if (hPopup)
DestroyMenu(hPopup);
#endif
return (S_OK);
}
LRESULT CIEMsgAb::CmdDelete(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = S_OK;
LVITEM lvi;
ENTRYLIST rList;
ULONG cValues;
SBinary UNALIGNED *pEntryId;
BOOL fConfirm = TRUE;
TCHAR szText[CCHMAX_STRINGRES + MAXNAME];
WCHAR wszBuff[CCHMAX_STRINGRES];
if(m_delItem > 0)
{
MessageBeep(MB_OK);
return(S_OK);
}
if(m_fNoRemove)
m_fNoRemove = FALSE;
lvi.mask = LVIF_PARAM;
lvi.iSubItem = 0;
lvi.iItem = -1;
// Figure out how many items are selected
cValues = ListView_GetSelectedCount(m_ctlList);
m_delItem = cValues;
if (cValues != 1)
{
// Remove only Msgr entry
#ifdef LATER
AthLoadString(idsBADelMultiple, wszBuff, ARRAYSIZE(wszBuff));
wnsprintf(szText, ARRAYSIZE(szText), wszBuff, cValues);
if(IDNO == AthMessageBoxW(NULL, MAKEINTRESOURCE(idsAthena), MAKEINTRESOURCE(idsAthena),
NULL, MB_YESNO | MB_ICONEXCLAMATION))
{
return (0);
}
else
#endif // LATER
if(m_fNoRemove)
{
MessageBeep(MB_OK);
return(S_OK);
}
else
fConfirm = FALSE;
// Assert(FALSE);
// return (0);
}
while(cValues > 0)
{
lvi.iItem = ListView_GetNextItem(m_ctlList, lvi.iItem, LVNI_SELECTED);
if(lvi.iItem < 0)
{
ErrBeep:
MessageBeep(MB_OK);
return(S_OK);
}
// Get the item from the ListView
if(ListView_GetItem(m_ctlList, &lvi) == FALSE)
goto ErrBeep;
// Check buddy state
LPMABENTRY pEntry = (LPMABENTRY) lvi.lParam;
if(pEntry->tag == LPARAM_MENTRY)
{
if(m_pCMsgrList && m_pCMsgrList->IsLocalOnline())
{
// Remove only Msgr entry
if(fConfirm)
{
#ifdef LATER
AthLoadString(idsBADelBLEntry, wszBuff, ARRAYSIZE(wszBuff));
wnsprintf(szText, ARRAYSIZE(szTExt), wszBuff, pEntry->lpMsgrInfo->pchMsgrName);
if(IDNO == AthMessageBox(m_hWnd, MAKEINTRESOURCE(idsAthena), szText,
NULL, MB_YESNO | MB_ICONEXCLAMATION))
{
m_delItem = 0;
return (0);
}
else if(m_fNoRemove)
goto ErrBeep;
#endif // LATER
}
if(pEntry->lpMsgrInfo)
{
m_delItem--;
hr = m_pCMsgrList->FindAndDeleteUser(pEntry->lpMsgrInfo->pchID, TRUE /* fDelete*/);
}
else
{
m_delItem = 0;
return(S_OK);
}
}
else
goto ErrBeep;
}
else if(pEntry->tag == LPARAM_MABENTRY)
{
int nID = IDNO;
if(fConfirm)
{
#ifdef LATER
AthLoadString(idsBADelBLABEntry, wszBuff, ARRAYSIZE(wszBuff));
wnsprintf(szText, ARRAYSIZE(szText), wszBuff, pEntry->pchWABName);
nID = AthMessageBox(m_hWnd, MAKEINTRESOURCE(idsAthena), szText,
NULL, MB_YESNOCANCEL | MB_ICONEXCLAMATION);
#endif // LATER
}
if(((nID == IDYES) || !fConfirm) && !m_fNoRemove)
{
if(m_pCMsgrList && m_pCMsgrList->IsLocalOnline())
{
// Remove only Msgr & AB entry
if(pEntry->lpMsgrInfo)
hr = m_pCMsgrList->FindAndDeleteUser(pEntry->lpMsgrInfo->pchID, TRUE /* fDelete*/);
else
{
m_delItem = 0;
return(S_OK);
}
// Allocate a structure big enough for all of 'em
if (MemAlloc((LPVOID *) &(rList.lpbin), sizeof(SBinary)))
{
rList.cValues = 0;
pEntryId = rList.lpbin;
*pEntryId = *(pEntry->lpSB);
pEntryId++;
rList.cValues = 1;
// Tell the WAB to delete 'em
m_nChCount++; // increase count of our notification messages from WAB
if(!m_cAddrBook.fIsWabLoaded())
{
if(FAILED(hr = m_cAddrBook.OpenWabFile(m_fWAB)))
return(hr);
}
m_cAddrBook.DeleteItems(&rList);
// Free our array
MemFree(rList.lpbin);
}
// m_delItem++;
ListView_DeleteItem(m_ctlList, lvi.iItem);
lvi.iItem--;
ListView_SetItemState(m_ctlList, ((lvi.iItem >= 0) ? lvi.iItem : 0), LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED);
}
else
MessageBeep(MB_OK);
}
else if((nID == IDNO) && !m_fNoRemove)
{
// Remove only Msgr entry
m_delItem--;
hr = m_pCMsgrList->FindAndDeleteUser(pEntry->lpMsgrInfo->pchID, TRUE /* fDelete*/);
}
else
{
// Remove nothing
m_delItem--;
hr = S_OK;
}
}
else
{
// remove AN entry (group or contact)
if(fConfirm)
{
#ifdef LATER
AthLoadString(idsBADelABEntry, wszBuff, ARRAYSIZE(wszBuff));
wnsprintf(szText, ARRAYSIZE(szText), wszBuff, pEntry->pchWABName);
if(IDNO == AthMessageBox(m_hWnd, MAKEINTRESOURCE(idsAthena), szText,
NULL, MB_YESNO | MB_ICONEXCLAMATION))
{
m_delItem = 0;
return(0);
}
else if(m_fNoRemove)
goto ErrBeep;
#endif // LATER
}
// Allocate a structure big enough for all of 'em
if(pEntry->lpSB)
{
if (MemAlloc((LPVOID *) &(rList.lpbin), sizeof(SBinary)))
{
rList.cValues = 0;
pEntryId = rList.lpbin;
*pEntryId = *(pEntry->lpSB);
pEntryId++;
rList.cValues = 1;
// Tell the WAB to delete 'em
m_nChCount++; // increase count of our notification messages from WAB
if(!m_cAddrBook.fIsWabLoaded())
{
if(FAILED(hr = m_cAddrBook.OpenWabFile(m_fWAB)))
return(hr);
}
m_cAddrBook.DeleteItems(&rList);
// Free our array
MemFree(rList.lpbin);
}
}
// m_delItem++;
ListView_DeleteItem(m_ctlList, lvi.iItem);
lvi.iItem--;
}
cValues--;
}
if(ListView_GetItemCount(m_ctlList) > 0)
{
m_cEmptyList.Hide();
ListView_SetItemState(m_ctlList, ((lvi.iItem >= 0) ? lvi.iItem : 0), LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED);
}
else
m_cEmptyList.Show(m_ctlList, (LPWSTR) (m_fShowAllContacts ? m_szEmptyList : m_szMsgrEmptyList));
_ReloadListview();
return (hr);
}
STDMETHODIMP CIEMsgAb::get_InstMsg(BOOL * pVal)
{
*pVal = (GetEntryForSendInstMsg() != NULL);
return S_OK;
}
/* STDMETHODIMP CIEMsgAb::put_InstMsg(BOOL newVal)
{
return S_OK;
} */
STDMETHODIMP CIEMsgAb::HasFocusIO()
{
if (GetFocus() == m_ctlList)
return S_OK;
else
return S_FALSE;
}
STDMETHODIMP CIEMsgAb::TranslateAcceleratorIO(LPMSG pMsg)
{
if(!pMsg)
goto SNDMsg;
#ifdef NEED
if ((pMsg->message == WM_SYSKEYDOWN) && (pMsg->wParam == ((int) 'D')))
return(S_FALSE);
#endif
if (pMsg->message != WM_KEYDOWN)
goto SNDMsg;
if (! (pMsg->wParam == VK_TAB || pMsg->wParam == VK_F6))
goto SNDMsg;
m_ctlList.SendMessage(WM_KILLFOCUS, (WPARAM) NULL, (LPARAM) 0);
return S_OK;
SNDMsg:
::TranslateMessage(pMsg);
::DispatchMessage(pMsg);
// m_ctlList.SendMessage(pMsg->message, pMsg->wParam, pMsg->lParam);
return (S_OK);
}
STDMETHODIMP CIEMsgAb::UIActivateIO(BOOL fActivate, LPMSG lpMsg)
{
if (!m_pObjSite)
return E_FAIL;
if (!IsWindow(m_hWnd))
{
IOleWindow *pOleWnd;
if (SUCCEEDED(m_pObjSite->QueryInterface(IID_IOleWindow, (LPVOID*)&pOleWnd)))
{
if(SUCCEEDED(pOleWnd->GetWindow(&m_hwndParent)))
{
//Will be resized by parent
RECT rect = {0};
m_hWnd = CreateControlWindow(m_hwndParent, rect);
if (!m_hWnd)
return E_FAIL;
}
}
pOleWnd->Release();
}
if (fActivate)
{
m_ctlList.SetFocus();
}
m_pObjSite->OnFocusChangeIS((IInputObject*) this, fActivate);
return (S_OK);
}
STDMETHODIMP CIEMsgAb::SetSite(IUnknown *punksite)
{
//If we already have a site, we release it
SafeRelease(m_pObjSite);
IInputObjectSite *pObjSite;
if ((punksite) && (SUCCEEDED(punksite->QueryInterface(IID_IInputObjectSite, (LPVOID*)&pObjSite))))
{
m_pObjSite = pObjSite;
// IOleWindow* pOleWindow;
// if(SUCCEEDED(punksite->QueryInterface(IID_IOleWindowe, (LPVOID*)&pOleWindow))))
return S_OK;
}
return E_FAIL;
}
STDMETHODIMP CIEMsgAb::GetSite(REFIID riid, LPVOID *ppvSite)
{
return E_NOTIMPL;
}
HRESULT CIEMsgAb::RegisterFlyOut(CFolderBar *pFolderBar)
{
#ifdef LATER
Assert(m_pFolderBar == NULL);
m_pFolderBar = pFolderBar;
m_pFolderBar->AddRef();
#endif
return S_OK;
}
HRESULT CIEMsgAb::RevokeFlyOut(void)
{
#ifdef LATER
if (m_pFolderBar)
{
m_pFolderBar->Release();
m_pFolderBar = NULL;
}
#endif
return S_OK;
}
void CIEMsgAb::_ReloadListview(void)
{
// Kill timer first
// KillTimer(IDT_PANETIMER);
// Turn off redrawing
if(m_delItem != 0)
m_fNoRemove = TRUE;
// else
// m_fNoRemove = FALSE;
m_delItem = ListView_GetItemCount(m_ctlList);
SetWindowRedraw(m_ctlList, FALSE);
int index = ListView_GetNextItem(m_ctlList, -1, LVIS_SELECTED | LVIS_FOCUSED);
if(index == -1)
index = 0;
// Delete everything and reload
SideAssert(ListView_DeleteAllItems(m_ctlList));
if(m_pCMsgrList && m_pCMsgrList->IsLocalOnline())
{
m_fLogged = TRUE;
FillMsgrList(); // User list reload
}
if(m_fShowAllContacts)
{
if(!m_cAddrBook.fIsWabLoaded())
{
if(FAILED(m_cAddrBook.OpenWabFile(m_fWAB)))
return;
}
m_cAddrBook.LoadWabContents(m_ctlList, this);
}
ListView_SortItems(m_ctlList, BA_Sort, m_nSortType);
ListView_SetItemState(m_ctlList, index, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
ListView_EnsureVisible(m_ctlList, index, FALSE);
SetWindowRedraw(m_ctlList, TRUE);
// Invalidate(TRUE); //
if(ListView_GetItemCount(m_ctlList) > 0)
m_cEmptyList.Hide();
else
m_cEmptyList.Show(m_ctlList, (LPWSTR) (m_fShowAllContacts ? m_szEmptyList : m_szMsgrEmptyList));
UpdateWindow(/*m_ctlList*/);
// SetTimer(IDT_PANETIMER, ELAPSE_MOUSEOVERCHECK, NULL);
return;
}
ULONG STDMETHODCALLTYPE CIEMsgAb::OnNotify(ULONG cNotif, LPNOTIFICATION pNotifications)
{
// Well something changed in WAB, but we don't know what. We should reload.
// Sometimes these changes from us and we should ignore it.
if(m_nChCount > 0)
m_nChCount--;
else
_ReloadListview();
return (0);
}
LRESULT CIEMsgAb::CmdFind(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = S_OK;
if(!m_cAddrBook.fIsWabLoaded())
{
if(FAILED(hr = m_cAddrBook.OpenWabFile(m_fWAB)))
return(hr);
}
m_cAddrBook.Find(m_hWnd);
return (0);
}
LRESULT CIEMsgAb::CmdNewGroup(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = S_OK;
if(!m_cAddrBook.fIsWabLoaded())
{
if(FAILED(hr = m_cAddrBook.OpenWabFile(m_fWAB)))
return(hr);
}
m_cAddrBook.NewGroup(m_hWnd);
_ReloadListview();
return (0);
}
LRESULT CIEMsgAb::CmdIEMsgAb(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled)
{
HRESULT hr = S_OK;
if(!m_cAddrBook.fIsWabLoaded())
{
if(FAILED(hr = m_cAddrBook.OpenWabFile(m_fWAB)))
return(hr);
}
m_cAddrBook.AddressBook(m_hWnd);
return (0);
}
void CIEMsgAb::AddMsgrListItem(LPMINFO lpMsgrInfo)
{
LV_ITEMW lvItem;
m_cEmptyList.Hide(); // m,ust be sure that empty mesage is hide
lvItem.iItem = ListView_GetItemCount(m_ctlList);
lvItem.mask = LVIF_PARAM | LVIF_IMAGE | LVIF_TEXT;
lvItem.lParam = (LPARAM) AddBlabEntry(LPARAM_MENTRY, NULL, lpMsgrInfo, NULL, NULL, FALSE);
lvItem.iSubItem = 0;
lvItem.pszText = LPSTR_TEXTCALLBACKW;
lvItem.iImage = I_IMAGECALLBACK;
// SetUserIcon(LPARAM_MENTRY, lpMsgrInfo->nStatus, &(lvItem.iImage));
::SendMessage(m_ctlList, LVM_INSERTITEMW, 0, ((LPARAM) &lvItem));
return;
}
HRESULT CIEMsgAb::FillMsgrList()
{
LPMINFO pEntry = NULL;
if(!m_pCMsgrList)
{
// Assert(FALSE); // Possible situation. See Bug 31262
return(S_OK);
}
pEntry = m_pCMsgrList->GetFirstMsgrItem();
while(pEntry)
{
// if(m_fShowAllContacts || ((pEntry->nStatus != BIMSTATE_OFFLINE) && (pEntry->nStatus != BIMSTATE_INVISIBLE) &&
// !(m_pCMsgrList->IsLocalName(pEntry->pchID) )))
if(m_fShowAllContacts)
AddMsgrListItem(pEntry);
else if((m_fShowOnlineContacts || m_fShowOfflineContacts) && ((pEntry->nStatus != BIMSTATE_OFFLINE) && (pEntry->nStatus != BIMSTATE_INVISIBLE) &&
!(m_pCMsgrList->IsLocalName(pEntry->pchID))))
AddMsgrListItem(pEntry);
else if(m_fShowOfflineContacts && (((pEntry->nStatus == BIMSTATE_OFFLINE) || (pEntry->nStatus == BIMSTATE_INVISIBLE)) &&
!(m_pCMsgrList->IsLocalName(pEntry->pchID))))
AddMsgrListItem(pEntry);
pEntry = m_pCMsgrList->GetNextMsgrItem(pEntry);
}
return S_OK;
}
// Add BLAB table entry
LPMABENTRY CIEMsgAb::AddBlabEntry(MABENUM tag, LPSBinary lpSB, LPMINFO lpMsgrInfo, WCHAR *pchMail, WCHAR *pchDisplayName, BOOL fCert, LPPNONEENTRIES lpPhs)
{
WCHAR szName[MAXNAME];
LPMABENTRY pEntry = NULL;
WCHAR *pchName = NULL;
int nLen = 0;
if (!MemAlloc((LPVOID *) &pEntry, sizeof(mabEntry)))
return(NULL);
pEntry->tag = tag;
pEntry->lpSB = lpSB;
pEntry->pchWABName = NULL;
pEntry->pchWABID = NULL;
pEntry->fCertificate = fCert;
pEntry->lpPhones = NULL;
if(lpSB != NULL)
{
if(!pchDisplayName)
{
if(!m_cAddrBook.fIsWabLoaded())
{
if(FAILED(m_cAddrBook.OpenWabFile(m_fWAB)))
return(NULL);
}
m_cAddrBook.GetDisplayName(pEntry->lpSB, szName, ARRAYSIZE(szName));
pchName = szName;
}
else
pchName = pchDisplayName;
if(pchName)
{
ULONG cchSize = lstrlenW(pchName) + 1;
if (!MemAlloc((LPVOID *) &(pEntry->pchWABName), cchSize * sizeof(WCHAR) ))
{
MemFree(pEntry);
return(NULL);
}
StrCpyNW(pEntry->pchWABName, pchName, cchSize);
}
if(pchMail != NULL)
{
ULONG cchSize = lstrlenW(pchMail) + 1;
if (MemAlloc((LPVOID *) &(pEntry->pchWABID), cchSize * sizeof(WCHAR) ))
StrCpyNW(pEntry->pchWABID, pchMail, cchSize);
}
}
if(lpMsgrInfo && MemAlloc((LPVOID *) &(pEntry->lpMsgrInfo), sizeof(struct _tag_OEMsgrInfo)))
{
pEntry->lpMsgrInfo->nStatus = lpMsgrInfo->nStatus;
pEntry->lpMsgrInfo->pPrev = NULL;
pEntry->lpMsgrInfo->pNext = NULL;
if(lpMsgrInfo->pchMsgrName && MemAlloc((LPVOID *) &(pEntry->lpMsgrInfo->pchMsgrName), (lstrlenW(lpMsgrInfo->pchMsgrName) + 1)*sizeof(WCHAR)))
StrCpyNW(pEntry->lpMsgrInfo->pchMsgrName, lpMsgrInfo->pchMsgrName, lstrlenW(lpMsgrInfo->pchMsgrName) + 1);
else
pEntry->lpMsgrInfo->pchMsgrName = NULL;
if(lpMsgrInfo->pchID && MemAlloc((LPVOID *) &(pEntry->lpMsgrInfo->pchID), (lstrlenW(lpMsgrInfo->pchID) + 1)*sizeof(WCHAR)))
StrCpyNW(pEntry->lpMsgrInfo->pchID, lpMsgrInfo->pchID, lstrlenW(lpMsgrInfo->pchID) + 1);
else
pEntry->lpMsgrInfo->pchID = NULL;
if((lpMsgrInfo->pchWorkPhone || lpMsgrInfo->pchHomePhone || lpMsgrInfo->pchMobilePhone) && MemAlloc((LPVOID *) &(pEntry->lpPhones), sizeof(PNONEENTRIES)))
{
if(lpMsgrInfo->pchHomePhone && MemAlloc((LPVOID *) &(pEntry->lpPhones->pchHomePhone), (lstrlenW(lpMsgrInfo->pchHomePhone) + 1)*sizeof(WCHAR)))
StrCpyNW(pEntry->lpPhones->pchHomePhone, lpMsgrInfo->pchHomePhone, lstrlenW(lpMsgrInfo->pchHomePhone) + 1);
else
pEntry->lpPhones->pchHomePhone = NULL;
if(lpMsgrInfo->pchWorkPhone && MemAlloc((LPVOID *) &(pEntry->lpPhones->pchWorkPhone), (lstrlenW(lpMsgrInfo->pchWorkPhone) + 1)*sizeof(WCHAR)))
StrCpyNW(pEntry->lpPhones->pchWorkPhone, lpMsgrInfo->pchWorkPhone, lstrlenW(lpMsgrInfo->pchWorkPhone) + 1);
else
pEntry->lpPhones->pchWorkPhone = NULL;
if(lpMsgrInfo->pchMobilePhone && MemAlloc((LPVOID *) &(pEntry->lpPhones->pchMobilePhone), (lstrlenW(lpMsgrInfo->pchMobilePhone) + 1)*sizeof(WCHAR)))
StrCpyNW(pEntry->lpPhones->pchMobilePhone, lpMsgrInfo->pchMobilePhone, lstrlenW(lpMsgrInfo->pchMobilePhone) + 1);
else
pEntry->lpPhones->pchMobilePhone = NULL;
pEntry->lpPhones->pchIPPhone = NULL;
return(pEntry);
}
}
else
pEntry->lpMsgrInfo = NULL;
// Add information about pfones
if(lpPhs && MemAlloc((LPVOID *) &(pEntry->lpPhones), sizeof(PNONEENTRIES)))
{
if(lpPhs->pchHomePhone && (nLen = lstrlenW(lpPhs->pchHomePhone)))
{
if(MemAlloc((LPVOID *) &(pEntry->lpPhones->pchHomePhone), (nLen + 1)*sizeof(WCHAR)))
StrCpyNW(pEntry->lpPhones->pchHomePhone, lpPhs->pchHomePhone, nLen + 1);
else
pEntry->lpPhones->pchHomePhone = NULL;
}
else
pEntry->lpPhones->pchHomePhone = NULL;
if(lpPhs->pchWorkPhone && (nLen = lstrlenW(lpPhs->pchWorkPhone)))
{
if(MemAlloc((LPVOID *) &(pEntry->lpPhones->pchWorkPhone), (nLen + 1)*sizeof(WCHAR)))
StrCpyNW(pEntry->lpPhones->pchWorkPhone, lpPhs->pchWorkPhone, nLen + 1);
else
pEntry->lpPhones->pchWorkPhone = NULL;
}
else
pEntry->lpPhones->pchWorkPhone = NULL;
if(lpPhs->pchMobilePhone && (nLen = lstrlenW(lpPhs->pchMobilePhone)))
{
if(MemAlloc((LPVOID *) &(pEntry->lpPhones->pchMobilePhone), (nLen + 1)*sizeof(WCHAR)))
StrCpyNW(pEntry->lpPhones->pchMobilePhone, lpPhs->pchMobilePhone, nLen + 1);
else
pEntry->lpPhones->pchMobilePhone = NULL;
}
else
pEntry->lpPhones->pchMobilePhone = NULL;
if(lpPhs->pchIPPhone && (nLen = lstrlenW(lpPhs->pchIPPhone)))
{
if(MemAlloc((LPVOID *) &(pEntry->lpPhones->pchIPPhone), (nLen + 1)*sizeof(WCHAR)))
StrCpyNW(pEntry->lpPhones->pchIPPhone, lpPhs->pchIPPhone, nLen + 1);
else
pEntry->lpPhones->pchIPPhone = NULL;
}
else
pEntry->lpPhones->pchIPPhone = NULL;
}
return(pEntry);
}
void CIEMsgAb::RemoveMsgrInfo(LPMINFO lpMsgrInfo)
{
SafeMemFree(lpMsgrInfo->pchMsgrName);
SafeMemFree(lpMsgrInfo->pchID);
SafeMemFree(lpMsgrInfo);
}
// Remove BLAB table entry
void CIEMsgAb::RemoveBlabEntry(LPMABENTRY lpEntry)
{
if(lpEntry == NULL)
return;
if(lpEntry->pchWABName)
MemFree(lpEntry->pchWABName);
if(lpEntry->pchWABID)
MemFree(lpEntry->pchWABID);
if(lpEntry->lpPhones)
{
if(lpEntry->lpPhones->pchHomePhone)
MemFree(lpEntry->lpPhones->pchHomePhone);
if(lpEntry->lpPhones->pchWorkPhone)
MemFree(lpEntry->lpPhones->pchWorkPhone);
if(lpEntry->lpPhones->pchMobilePhone)
MemFree(lpEntry->lpPhones->pchMobilePhone);
if(lpEntry->lpPhones->pchIPPhone)
MemFree(lpEntry->lpPhones->pchIPPhone);
MemFree(lpEntry->lpPhones);
}
if(lpEntry->lpMsgrInfo)
{
RemoveMsgrInfo(lpEntry->lpMsgrInfo);
lpEntry->lpMsgrInfo = NULL;
}
MemFree(lpEntry);
lpEntry = NULL;
return;
}
// This function check buddy and if we have AB entry then set LPARAM_MABENTRY tag
void CIEMsgAb::CheckAndAddAbEntry(LPSBinary lpSB, WCHAR *pchEmail, WCHAR *pchDisplayName, DWORD nFlag, LPPNONEENTRIES pPhEnries)
{
WCHAR szName[MAXNAME];
LPMABENTRY pEntry = NULL;
LV_ITEMW lvItem;
lvItem.iItem = ListView_GetItemCount(m_ctlList);
lvItem.mask = LVIF_PARAM | LVIF_IMAGE | LVIF_TEXT;
lvItem.iSubItem = 0;
lvItem.pszText = LPSTR_TEXTCALLBACKW;
lvItem.iImage = I_IMAGECALLBACK;
m_cEmptyList.Hide(); // must be sure that empty mesage is hide
if(!(nFlag & MAB_BUDDY))
{
if(m_fShowAllContacts || (m_fShowEmailContacts && pchEmail) || (m_fShowOthersContacts && (pchEmail == NULL)))
{
lvItem.lParam = (LPARAM) AddBlabEntry((nFlag & MAB_GROUP) ? LPARAM_ABGRPENTRY : LPARAM_ABENTRY, lpSB, NULL, pchEmail,
pchDisplayName, (nFlag & MAB_CERT), pPhEnries);
// SetUserIcon(LPARAM_ABGRPENTRY, 0, &(lvItem.iImage));
::SendMessage(m_ctlList, LVM_INSERTITEMW, 0, ((LPARAM) &lvItem));
// ListView_InsertItem(m_ctlList, &lvItem);
}
return;
}
if(pchEmail)
pEntry = FindUserEmail(pchEmail, NULL, TRUE);
if(pEntry) // buddy found
{
// if we already linked this budyy to AN entry, add new list item)
if(pEntry->tag == LPARAM_MABENTRY)
{
lvItem.lParam = (LPARAM) AddBlabEntry(LPARAM_MABENTRY, lpSB, pEntry->lpMsgrInfo, pchEmail, pchDisplayName, (nFlag & MAB_CERT), pPhEnries);
// SetUserIcon(LPARAM_MABENTRY, pEntry->lpMsgrInfo->nStatus, &(lvItem.iImage));
ListView_InsertItem(m_ctlList, &lvItem);
}
else if(pEntry->tag == LPARAM_MENTRY) // buddy was not linked to AB entry
{
pEntry->tag = LPARAM_MABENTRY;
pEntry->lpSB = lpSB;
Assert(lpSB);
if(!m_cAddrBook.fIsWabLoaded())
{
if(FAILED(m_cAddrBook.OpenWabFile(m_fWAB)))
return;
}
m_cAddrBook.GetDisplayName(pEntry->lpSB, szName, ARRAYSIZE(szName));
pEntry->pchWABName = NULL;
pEntry->pchWABID = NULL;
ULONG cchSize = lstrlenW(szName) + 1;
if (MemAlloc((LPVOID *) &(pEntry->pchWABName), cchSize*sizeof(WCHAR) ))
StrCpyNW(pEntry->pchWABName, szName, cchSize);
cchSize = lstrlenW(pchEmail) + 1;
if(MemAlloc((LPVOID *) &(pEntry->pchWABID), cchSize*sizeof(WCHAR) ))
StrCpyNW(pEntry->pchWABID, pchEmail, cchSize);
}
else
Assert(FALSE); // something strange
}
else // buddy not found, simple AB entry
{
if(m_fShowAllContacts || (m_fShowEmailContacts && pchEmail) || (m_fShowOthersContacts && (pchEmail == NULL)))
{
lvItem.lParam = (LPARAM) AddBlabEntry(LPARAM_ABENTRY, lpSB, NULL, pchEmail, pchDisplayName, (nFlag & MAB_CERT), pPhEnries);
// SetUserIcon(LPARAM_ABENTRY, 0, &(lvItem.iImage));
ListView_InsertItem(m_ctlList, &lvItem);
}
}
}
LPMABENTRY CIEMsgAb::FindUserEmail(WCHAR *pchEmail, int *pIndex, BOOL fMsgrOnly)
{
LPMABENTRY pEntry = NULL;
LVITEMW lvi;
lvi.mask = LVIF_PARAM;
if(pIndex != NULL)
lvi.iItem = *pIndex;
else
lvi.iItem = -1;
lvi.iSubItem = 0;
while((lvi.iItem = ListView_GetNextItem(m_ctlList, lvi.iItem, LVNI_ALL)) != -1)
{
ListView_GetItem(m_ctlList, &lvi);
pEntry = (LPMABENTRY) lvi.lParam;
if(pEntry)
{
if(fMsgrOnly)
{
if(pEntry->lpMsgrInfo)
{
if((pEntry->lpMsgrInfo)->pchID)
{
if(!lstrcmpiW((pEntry->lpMsgrInfo)->pchID, pchEmail))
{
if(pIndex != NULL)
*pIndex = lvi.iItem;
return(pEntry);
}
}
}
}
else
{
if(pEntry->pchWABID)
{
if(!lstrcmpiW(pEntry->pchWABID, pchEmail))
{
if(pIndex != NULL)
*pIndex = lvi.iItem;
return(pEntry);
}
}
if(pEntry->lpSB)
{
Assert(m_cAddrBook.fIsWabLoaded());
if(m_cAddrBook.CheckEmailAddr(pEntry->lpSB, pchEmail))
{
if(pIndex != NULL)
*pIndex = lvi.iItem;
return(pEntry);
}
}
}
}
}
return(NULL);
}
// messenger want shutown. release messenger object
HRESULT CIEMsgAb::OnMsgrShutDown(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
if(m_pCMsgrList)
{
m_pCMsgrList->UnRegisterUIWnd(m_hWnd);
OE_CloseMsgrList(m_pCMsgrList);
m_pCMsgrList = NULL;
}
m_dwHideMessenger = 1;
m_dwDisableMessenger = 1;
_ReloadListview();
::SendMessage(m_hwndParent, WM_MSGR_LOGRESULT, 0, 0);
return(S_OK);
}
// Set new buddy status (online/ofline/etc. and redraw list view entry)
HRESULT CIEMsgAb::OnUserStateChanged(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
HRESULT hr = S_OK;
LPMABENTRY pEntry = NULL;
int index = -1;
BOOL fNeedRefresh = m_fShowOnlineContacts ;
if(fNeedRefresh)
{
m_fShowOfflineContacts = TRUE;
m_fShowOnlineContacts = FALSE;
_ReloadListview();
}
while((pEntry = FindUserEmail((LPWSTR) lParam, &index, TRUE)) != NULL)
{
pEntry->lpMsgrInfo->nStatus = (int) wParam;
ListView_RedrawItems(m_ctlList, index, index+1);
}
if(fNeedRefresh)
{
m_fShowOfflineContacts = FALSE;
m_fShowOnlineContacts = TRUE;
_ReloadListview();
}
ListView_SortItems(m_ctlList, BA_Sort, m_nSortType);
return(hr);
}
// Message: buddy was removed
HRESULT CIEMsgAb::OnUserRemoved(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
HRESULT hr = S_OK;
int index = -1;
LPMABENTRY pEntry = NULL;
while((pEntry = FindUserEmail((LPWSTR) lParam, &index, TRUE)) != NULL)
{
// Not removed yet
if(pEntry->tag == LPARAM_MABENTRY)
{
Assert(pEntry->lpMsgrInfo);
if(pEntry->lpMsgrInfo)
{
RemoveMsgrInfo(pEntry->lpMsgrInfo);
pEntry->lpMsgrInfo = NULL;
}
pEntry->tag = LPARAM_ABENTRY;
ListView_RedrawItems(m_ctlList, index, index+1);
}
else if(pEntry->tag == LPARAM_MENTRY)
{
int index1 = ListView_GetNextItem(m_ctlList, -1, LVIS_SELECTED | LVIS_FOCUSED);
m_delItem++;
ListView_DeleteItem(m_ctlList, index);
if(index == index1)
{
index1--;
ListView_SetItemState(m_ctlList, ((index1 >= 0) ? index1 : 0), LVIS_FOCUSED | LVIS_SELECTED, LVIS_FOCUSED | LVIS_SELECTED);
}
}
else
index++;
}
ListView_SortItems(m_ctlList, BA_Sort, m_nSortType);
if(ListView_GetItemCount(m_ctlList) > 0)
m_cEmptyList.Hide();
else
m_cEmptyList.Show(m_ctlList, (LPWSTR) (m_fShowAllContacts ? m_szEmptyList : m_szMsgrEmptyList));
return(hr);
}
// Event User was added => add buddy to our list.
HRESULT CIEMsgAb::OnUserAdded(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
LPMINFO pEntry = (LPMINFO) lParam;
if(m_fShowAllContacts)
AddMsgrListItem(pEntry);
else if((m_fShowOnlineContacts || m_fShowOfflineContacts) && ((pEntry->nStatus != BIMSTATE_OFFLINE) && (pEntry->nStatus != BIMSTATE_INVISIBLE) &&
!(m_pCMsgrList->IsLocalName(pEntry->pchID))))
AddMsgrListItem(pEntry);
else if(m_fShowOfflineContacts && (((pEntry->nStatus == BIMSTATE_OFFLINE) || (pEntry->nStatus == BIMSTATE_INVISIBLE)) &&
!(m_pCMsgrList->IsLocalName(pEntry->pchID))))
AddMsgrListItem(pEntry);
ListView_SortItems(m_ctlList, BA_Sort, m_nSortType);
return(S_OK);
}
HRESULT CIEMsgAb::OnUserNameChanged(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
HRESULT hr = S_OK;
#ifdef NEEDED
LPMINFO pItem = (LPMINFO) lParam;
LPMABENTRY pEntry = NULL;
int index = -1;
while((pEntry = FindUserEmail(pItem->pchID, &index, TRUE)) != NULL)
{
if((pEntry->tag == LPARAM_MENTRY) && lstrcmpi(pItem->pchID, pItem->pchMsgrName))
{
hr = m_cAddrBook.AutoAddContact(pItem->pchMsgrName, pItem->pchID);
// _ReloadListview();
}
ListView_RedrawItems(m_ctlList, index, index+1);
}
#endif
_ReloadListview();
return(hr);
}
HRESULT CIEMsgAb::OnUserLogoffEvent(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
HRESULT hr = S_OK;
::SendMessage(m_hwndParent, nMsg, wParam, lParam);
if(!m_fLogged)
return S_OK;
else
m_fLogged = FALSE;
SetWindowRedraw(m_ctlList, FALSE);
int index = ListView_GetNextItem(m_ctlList, -1, LVIS_SELECTED | LVIS_FOCUSED);
// Delete everything and reload
if(m_delItem != 0)
m_fNoRemove = TRUE;
// else
// m_fNoRemove = FALSE;
m_delItem = ListView_GetItemCount(m_ctlList);
ListView_DeleteAllItems(m_ctlList);
// FillMsgrList(); // User list reload
if(m_fShowAllContacts)
{
if(!m_cAddrBook.fIsWabLoaded())
{
if(FAILED(hr = m_cAddrBook.OpenWabFile(m_fWAB)))
return(hr);
}
m_cAddrBook.LoadWabContents(m_ctlList, this);
}
ListView_SetItemState(m_ctlList, index, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
SetWindowRedraw(m_ctlList, TRUE);
if(ListView_GetItemCount(m_ctlList) > 0)
m_cEmptyList.Hide();
else
m_cEmptyList.Show(m_ctlList, (LPWSTR) (m_fShowAllContacts ? m_szEmptyList : m_szMsgrEmptyList));
UpdateWindow(/*m_ctlList*/);
return S_OK;
}
HRESULT CIEMsgAb::OnLocalStateChanged(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
::SendMessage(m_hwndParent, nMsg, wParam, lParam);
return S_OK;
}
HRESULT CIEMsgAb::OnUserLogResultEvent(UINT nMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
::SendMessage(m_hwndParent, nMsg, wParam, lParam);
_ReloadListview();
if(SUCCEEDED(lParam))
{
m_fLogged = TRUE;
}
return S_OK;
}
LRESULT CIEMsgAb::NotifyKillFocus(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)
{
HRESULT hres = E_FAIL;
if (m_pObjSite != NULL)
{
IInputObjectSite *pis;
hres = m_pObjSite->QueryInterface(IID_IInputObjectSite, (LPVOID*)&pis);
if (SUCCEEDED(hres))
{
hres = pis->OnFocusChangeIS((IInputObject*) this, FALSE);
pis->Release();
}
}
return (hres);
}
LRESULT CIEMsgAb::NotifySetFocus(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)
{
// #ifdef LATER
// UnkOnFocusChangeIS(m_pObjSite, (IInputObject*) this, TRUE);
// #endif
HRESULT hres = S_OK;
/* if (m_pObjSite != NULL)
{
IInputObjectSite *pis;
hres = m_pObjSite->QueryInterface(IID_IInputObjectSite, (LPVOID*)&pis);
if (SUCCEEDED(hres))
{
hres = pis->OnFocusChangeIS((IInputObject*) this, TRUE);
pis->Release();
}
}*/
return (hres);
}
HRESULT STDMETHODCALLTYPE CIEMsgAb::QueryStatus(const GUID *pguidCmdGroup,
ULONG cCmds, OLECMD *prgCmds,
OLECMDTEXT *pCmdText)
{
int nEnable;
HRESULT hr;
DWORD cSelected = ListView_GetSelectedCount(m_ctlList);
UINT id;
BIMSTATE State;
// Loop through all the commands in the array
for ( ; cCmds > 0; cCmds--, prgCmds++)
{
// Only look at commands that don't have OLECMDF_SUPPORTED;
if (prgCmds->cmdf == 0)
{
switch (prgCmds->cmdID)
{
case ID_HIDE_IM:
if(m_dwHideMessenger)
prgCmds->cmdf = OLECMDF_INVISIBLE;
else if(!m_dwDisableMessenger)
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
else
prgCmds->cmdf = OLECMDF_INVISIBLE;
break;
case ID_SHOW_IM:
if(m_dwHideMessenger)
prgCmds->cmdf = OLECMDF_INVISIBLE;
else if(!m_dwDisableMessenger)
prgCmds->cmdf = OLECMDF_INVISIBLE;
else
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
break;
// These commands are enabled if and only if one item is selected
case ID_DELETE_CONTACT:
if (cSelected > 0)
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
break;
case ID_FIND_PEOPLE:
case ID_ADDRESS_BOOK:
if(m_fWAB)
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
else
prgCmds->cmdf = OLECMDF_INVISIBLE;
break;
case ID_SEND_MESSAGE:
if((HasFocusIO() == S_OK) && cSelected >= 1)
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
break;
case ID_SEND_INSTANT_MESSAGE2:
{
if (cSelected == 1)
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
else if(m_dwHideMessenger)
prgCmds->cmdf = OLECMDF_INVISIBLE;
else
prgCmds->cmdf = OLECMDF_SUPPORTED;
break;
}
case ID_SORT_BY_STATUS:
if(!IsMessengerInstalled())
{
prgCmds->cmdf = OLECMDF_SUPPORTED;
break;
}
else
if(ListView_GetItemCount(m_ctlList) > 1)
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
else
prgCmds->cmdf = OLECMDF_SUPPORTED;
if((m_nSortType == BASORT_STATUS_ACSEND) || (m_nSortType == BASORT_STATUS_DESCEND))
prgCmds->cmdf |= OLECMDF_NINCHED;
break;
case ID_SORT_BY_NAME:
if(!IsMessengerInstalled())
{
prgCmds->cmdf = OLECMDF_SUPPORTED;
break;
}
else if(ListView_GetItemCount(m_ctlList) > 1)
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
else
prgCmds->cmdf = OLECMDF_SUPPORTED;
if((m_nSortType == BASORT_NAME_ACSEND) || (m_nSortType == BASORT_NAME_DESCEND))
prgCmds->cmdf |= OLECMDF_NINCHED;
break;
// These commands are always enabled
case ID_POPUP_NEW_ACCOUNT:
case ID_NEW_HOTMAIL_ACCOUNT:
case ID_NEW_ATT_ACCOUNT:
case ID_NEW_CONTACT:
case ID_POPUP_MESSENGER:
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
break;
case ID_SET_ONLINE_CONTACT:
{
if(m_dwHideMessenger)
{
prgCmds->cmdf = OLECMDF_INVISIBLE;
break;
}
else if(cSelected != 1)
{
prgCmds->cmdf = OLECMDF_SUPPORTED;
break;
}
LPMABENTRY pEntry = GetSelectedEntry();
if(!pEntry && m_pCMsgrList)
{
prgCmds->cmdf = OLECMDF_SUPPORTED;
break;
}
else if(pEntry && pEntry->tag != LPARAM_ABENTRY)
{
prgCmds->cmdf = OLECMDF_SUPPORTED;
break;
}
}
case ID_NEW_ONLINE_CONTACT:
if(m_pCMsgrList)
{
if(m_pCMsgrList->IsLocalOnline())
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
else
prgCmds->cmdf = OLECMDF_SUPPORTED;
}
else if(m_dwHideMessenger)
prgCmds->cmdf = OLECMDF_INVISIBLE;
else
prgCmds->cmdf = OLECMDF_SUPPORTED;
break;
// Properties is only enabled if the input focus is in the
// list view. Otherwise, we don't mark it as supported at all.
case ID_PROPERTIES:
{
LPMABENTRY pEntry = GetSelectedEntry();
if(pEntry && pEntry->tag != LPARAM_MENTRY)
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
else
prgCmds->cmdf = OLECMDF_SUPPORTED;
break;
}
case ID_VIEW_ONLINE:
if(m_fShowOnlineContacts)
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED | OLECMDF_NINCHED;
else
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED ;
break;
case ID_VIEW_ONANDOFFLINE:
if(m_fShowOfflineContacts)
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED | OLECMDF_NINCHED;
else
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED ;
break;
case ID_VIEW_ALL:
if(m_fShowAllContacts)
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED | OLECMDF_NINCHED;
else
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED ;
break;
case ID_MESSENGER_OPTIONS:
if(m_dwHideMessenger)
prgCmds->cmdf = OLECMDF_INVISIBLE;
else if (!m_pCMsgrList)
prgCmds->cmdf = OLECMDF_SUPPORTED;
else
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
break;
case ID_CALL:
case ID_DIAL_PHONE_NUMBER:
if((ListView_GetItemCount(m_ctlList) < 1) || (!IsTelInstalled())) // && (!m_pCMsgrList || !m_pCMsgrList->IsLocalOnline())))
prgCmds->cmdf = OLECMDF_SUPPORTED;
else
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
break;
case ID_HOME_PHONE:
case ID_WORK_PHONE:
case ID_MOBILE_PHONE:
case ID_IP_PHONE:
if(_FillPhoneNumber(prgCmds->cmdID, pCmdText))
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
else
prgCmds->cmdf = OLECMDF_INVISIBLE;
break;
case SEP_PHONE:
{
LPMABENTRY pEntry = GetSelectedEntry();
if(pEntry && pEntry->lpPhones && (pEntry->lpPhones->pchIPPhone || pEntry->lpPhones->pchMobilePhone || pEntry->lpPhones->pchWorkPhone || pEntry->lpPhones->pchHomePhone))
prgCmds->cmdf = OLECMDF_SUPPORTED;
else
prgCmds->cmdf = OLECMDF_INVISIBLE;
}
break;
// These depend on whether
case ID_LOGIN_MESSENGER:
case ID_LOGOFF_MESSENGER:
case ID_MESSENGER_ONLINE:
case ID_MESSENGER_INVISIBLE:
case ID_MESSENGER_BUSY:
case ID_MESSENGER_BACK:
case ID_MESSENGER_AWAY:
case ID_MESSENGER_ON_PHONE:
case ID_MESSENGER_LUNCH:
case ID_POPUP_MESSENGER_STATUS:
{
// If messenger isn't installed, then none of these commands will
// be enabled.
if(m_dwHideMessenger)
{
prgCmds->cmdf = OLECMDF_INVISIBLE;
break;
}
else if (!m_pCMsgrList)
{
prgCmds->cmdf = OLECMDF_SUPPORTED;
break;
}
if (FAILED(m_pCMsgrList->GetLocalState(&State)))
State = BIMSTATE_UNKNOWN;
// Convert the online state to a command ID
switch (State)
{
case BIMSTATE_ONLINE:
case BIMSTATE_IDLE:
id = ID_MESSENGER_ONLINE;
break;
case BIMSTATE_INVISIBLE:
id = ID_MESSENGER_INVISIBLE;
break;
case BIMSTATE_BUSY:
id = ID_MESSENGER_BUSY;
break;
case BIMSTATE_BE_RIGHT_BACK:
id = ID_MESSENGER_BACK;
break;
case BIMSTATE_AWAY:
id = ID_MESSENGER_AWAY;
break;
case BIMSTATE_ON_THE_PHONE:
id = ID_MESSENGER_ON_PHONE;
break;
case BIMSTATE_OUT_TO_LUNCH:
id = ID_MESSENGER_LUNCH;
break;
default:
id = 0xffff;
}
// Logon is handled a bit seperatly
if (prgCmds->cmdID == ID_LOGIN_MESSENGER)
{
prgCmds->cmdf = OLECMDF_SUPPORTED;
if (id == 0xffff)
prgCmds->cmdf |= OLECMDF_ENABLED;
}
else if (prgCmds->cmdID == ID_LOGOFF_MESSENGER)
{
prgCmds->cmdf = OLECMDF_SUPPORTED;
if (id != 0xffff)
prgCmds->cmdf |= OLECMDF_ENABLED;
}
else
{
// For all other commands, if we in a known state
// then the command is enabled.
prgCmds->cmdf = OLECMDF_SUPPORTED;
if (id != 0xffff)
prgCmds->cmdf = OLECMDF_ENABLED;
// If the command is the same as our state, it should be checked
if (id == prgCmds->cmdID)
prgCmds->cmdf |= OLECMDF_NINCHED;
}
}
break;
case ID_SEND_INSTANT_MESSAGE:
{
if(m_dwHideMessenger)
prgCmds->cmdf = OLECMDF_INVISIBLE;
else if (GetEntryForSendInstMsg())
prgCmds->cmdf = OLECMDF_SUPPORTED | OLECMDF_ENABLED;
else
prgCmds->cmdf = OLECMDF_SUPPORTED;
break;
}
}
}
}
return S_OK;
}
HRESULT STDMETHODCALLTYPE CIEMsgAb::Exec(const GUID *pguidCmdGroup,
DWORD nCmdID,
DWORD nCmdExecOpt,
VARIANTARG *pvaIn,
VARIANTARG *pvaOut)
{
HRESULT hr = OLECMDERR_E_NOTSUPPORTED;
BOOL bHandled = 0;
BIMSTATE State = BIMSTATE_UNKNOWN;
switch (nCmdID)
{
case ID_HIDE_IM:
Assert(!m_dwHideMessenger && !m_dwDisableMessenger)
m_dwDisableMessenger = 1;
DwSetDisableMessenger(m_dwDisableMessenger);
if(m_pCMsgrList)
{
m_pCMsgrList->UnRegisterUIWnd(m_hWnd);
OE_CloseMsgrList(m_pCMsgrList);
m_pCMsgrList = NULL;
_ReloadListview();
}
::SendMessage(m_hwndParent, WM_MSGR_LOGRESULT, 0, 0);
break;
case ID_SHOW_IM:
Assert(!m_dwHideMessenger && m_dwDisableMessenger)
m_dwDisableMessenger = 0;
DwSetDisableMessenger(m_dwDisableMessenger);
if(!m_pCMsgrList)
{
m_pCMsgrList = OE_OpenMsgrList();
// Register our control for Msgr list
if(m_pCMsgrList)
{
m_pCMsgrList->RegisterUIWnd(m_hWnd);
if(m_pCMsgrList->IsLocalOnline())
{
m_fLogged = TRUE;
FillMsgrList();
ListView_SortItems(m_ctlList, BA_Sort, m_nSortType);
}
}
}
::SendMessage(m_hwndParent, WM_MSGR_LOGRESULT, 0, 0);
break;
case ID_SHOWALLCONTACT:
if(m_fShowAllContacts)
{
m_fShowAllContacts = FALSE;
m_fShowOnlineContacts = TRUE;
m_fShowOfflineContacts = FALSE;
}
else if(m_fShowOnlineContacts)
{
m_fShowAllContacts = FALSE;
m_fShowOnlineContacts = FALSE;
m_fShowOfflineContacts = TRUE;
}
else if(m_fShowOfflineContacts)
{
m_fShowAllContacts = TRUE;
m_fShowOnlineContacts = FALSE;
m_fShowOfflineContacts = FALSE;
}
_ReloadListview();
break;
case ID_VIEW_ONLINE:
m_fShowAllContacts = FALSE;
m_fShowOfflineContacts = FALSE;
m_fShowOnlineContacts = TRUE;
_ReloadListview();
break;
case ID_VIEW_ONANDOFFLINE:
m_fShowAllContacts = FALSE;
m_fShowOnlineContacts = FALSE;
m_fShowOfflineContacts = TRUE;
_ReloadListview();
break;
case ID_VIEW_ALL:
m_fShowAllContacts = TRUE;
m_fShowOnlineContacts = FALSE;
m_fShowOfflineContacts = FALSE;
_ReloadListview();
break;
case ID_DIAL_PHONE_NUMBER:
CallPhone(NULL, FALSE);
break;
case ID_HOME_PHONE:
case ID_WORK_PHONE:
case ID_MOBILE_PHONE:
case ID_IP_PHONE:
{
LPMABENTRY pEntry = GetSelectedEntry();
if(!pEntry || !(pEntry->lpPhones))
{
Assert(FALSE);
break;
}
switch(nCmdID)
{
case ID_HOME_PHONE:
CallPhone(pEntry->lpPhones->pchHomePhone, (pEntry->tag == LPARAM_MENTRY));
break;
case ID_WORK_PHONE:
CallPhone(pEntry->lpPhones->pchWorkPhone, (pEntry->tag == LPARAM_MENTRY));
break;
case ID_MOBILE_PHONE:
CallPhone(pEntry->lpPhones->pchMobilePhone, (pEntry->tag == LPARAM_MENTRY));
break;
case ID_IP_PHONE:
CallPhone(pEntry->lpPhones->pchIPPhone, (pEntry->tag == LPARAM_MENTRY));
break;
}
}
break;
case ID_SEND_INSTANT_MESSAGE2:
CmdNewMessage(HIWORD(nCmdID), ID_SEND_INSTANT_MESSAGE2, m_ctlList, bHandled);
hr = S_OK;
break;
case ID_DELETE_CONTACT:
hr = (HRESULT) CmdDelete(HIWORD(nCmdID), LOWORD(nCmdID), m_ctlList, bHandled);
break;
case ID_NEW_CONTACT:
// if(HasFocusIO() == S_OK)
CmdNewContact(HIWORD(nCmdID), LOWORD(nCmdID), m_ctlList, bHandled);
hr = S_OK;
break;
case ID_SET_ONLINE_CONTACT:
CmdSetOnline(HIWORD(nCmdID), LOWORD(nCmdID), m_ctlList, bHandled);
hr = S_OK;
break;
case ID_NEW_ONLINE_CONTACT:
CmdNewOnlineContact(HIWORD(nCmdID), LOWORD(nCmdID), m_ctlList, bHandled);
hr = S_OK;
break;
case ID_PROPERTIES:
CmdProperties(0, 0, m_ctlList, bHandled);
hr = S_OK;
break;
#ifdef GEORGEH
case ID_NEW_MSG_DEFAULT:
if(HasFocusIO() == S_OK)
hr = CmdNewMessage(HIWORD(nCmdID), LOWORD(nCmdID), m_ctlList, bHandled);
break;
#endif // GEORGEH
case ID_FIND_PEOPLE:
case ID_ADDRESS_BOOK:
{
WCHAR wszWABExePath[MAX_PATH];
if(S_OK == HrLoadPathWABEXE(wszWABExePath, sizeof(wszWABExePath)/sizeof(wszWABExePath[0])))
{
SHELLEXECUTEINFOW ExecInfo;
ExecInfo.cbSize = sizeof(SHELLEXECUTEINFOW);
ExecInfo.nShow = SW_SHOWNORMAL;
ExecInfo.fMask = 0;
ExecInfo.hwnd = NULL;
ExecInfo.lpDirectory = NULL;
ExecInfo.lpParameters = ((nCmdID == ID_FIND_PEOPLE) ? L"/find" : L"");
ExecInfo.lpVerb = L"open";
ExecInfo.lpFile = wszWABExePath;
ShellExecuteExW(&ExecInfo);
// ShellExecuteW(NULL, L"open", wszWABExePath,
// ((nCmdID == ID_FIND_PEOPLE) ? L"/find" : L""),
// "", SW_SHOWNORMAL);
}
break;
}
case ID_SEND_MESSAGE:
if(HasFocusIO() == S_OK)
hr = (HRESULT) CmdNewEmaile(HIWORD(nCmdID), LOWORD(nCmdID), m_ctlList, bHandled);
break;
case ID_SEND_INSTANT_MESSAGE:
// Assert(m_pCMsgrList);
CmdNewIMsg(HIWORD(nCmdID), LOWORD(nCmdID), m_ctlList, bHandled);
hr = S_OK;
break;
case ID_MESSENGER_OPTIONS:
if(m_pCMsgrList)
hr = m_pCMsgrList->LaunchOptionsUI(); //CmdMsgrOptions();
break;
case ID_MESSENGER_ONLINE:
if(m_pCMsgrList)
hr = m_pCMsgrList->SetLocalState(BIMSTATE_ONLINE);
break;
case ID_MESSENGER_INVISIBLE:
if(m_pCMsgrList)
hr = m_pCMsgrList->SetLocalState(BIMSTATE_INVISIBLE);
break;
case ID_MESSENGER_BUSY:
if(m_pCMsgrList)
hr = m_pCMsgrList->SetLocalState(BIMSTATE_BUSY);
break;
case ID_MESSENGER_BACK:
if(m_pCMsgrList)
hr = m_pCMsgrList->SetLocalState(BIMSTATE_BE_RIGHT_BACK);
break;
case ID_MESSENGER_AWAY:
if(m_pCMsgrList)
hr = m_pCMsgrList->SetLocalState(BIMSTATE_AWAY);
break;
case ID_MESSENGER_ON_PHONE:
if(m_pCMsgrList)
hr = m_pCMsgrList->SetLocalState(BIMSTATE_ON_THE_PHONE);
break;
case ID_MESSENGER_LUNCH:
if(m_pCMsgrList)
hr = m_pCMsgrList->SetLocalState(BIMSTATE_OUT_TO_LUNCH);
break;
case ID_LOGIN_MESSENGER:
if(m_pCMsgrList)
{
if(!m_pCMsgrList->IsLocalOnline())
{
if(PromptToGoOnline() == S_OK)
m_pCMsgrList->UserLogon();
}
hr = S_OK;
}
break;
case ID_LOGOFF_MESSENGER:
Assert(m_pCMsgrList);
if(m_pCMsgrList)
m_pCMsgrList->UserLogoff();
hr = S_OK;
break;
case ID_SORT_BY_NAME:
m_nSortType = BASORT_NAME_ACSEND;
ListView_SortItems(m_ctlList, BA_Sort, m_nSortType);
break;
case ID_SORT_BY_STATUS:
m_nSortType = BASORT_STATUS_ACSEND;
ListView_SortItems(m_ctlList, BA_Sort, m_nSortType);
break;
default:
break;
}
return hr;
}
// fill a phone number for menu
BOOL CIEMsgAb::_FillPhoneNumber(UINT Id, OLECMDTEXT *pcmdText)
{
LPMABENTRY pEntry = GetSelectedEntry();
WCHAR szTmp[CCHMAX_STRINGRES];
WCHAR * pch = NULL;
TCHAR * pchStr = NULL;
if(!pEntry || !(pEntry->lpPhones))
{
err:
pcmdText->cwBuf = 0;
return(FALSE);
}
szTmp[0] = L'\0';
switch(Id)
{
case ID_HOME_PHONE:
pch = pEntry->lpPhones->pchHomePhone;
AthLoadString(idsHome, szTmp, ARRAYSIZE(szTmp));
break;
case ID_WORK_PHONE:
pch = pEntry->lpPhones->pchWorkPhone;
AthLoadString(idsWork, szTmp, ARRAYSIZE(szTmp));
break;
case ID_MOBILE_PHONE:
pch = pEntry->lpPhones->pchMobilePhone;
AthLoadString(idsMobile, szTmp, ARRAYSIZE(szTmp));
break;
case ID_IP_PHONE:
pch = pEntry->lpPhones->pchIPPhone;
AthLoadString(idsIPPhone, szTmp, ARRAYSIZE(szTmp));
break;
default:
pch = NULL;
Assert(FALSE);
break;
}
if(!pch)
goto err;
if(pcmdText->cmdtextf == OLECMDTEXTF_NONE)
return(TRUE);
pcmdText->cwBuf = (lstrlenW(pch) + 2 + lstrlenW(szTmp));
if(pcmdText->cwBuf > MAX_MENUSTR)
Assert(FALSE);
else
{
#ifdef NEW
if(!MultiByteToWideChar(GetACP(), 0, pch, -1, pcmdText->rgwz, pcmdText->cwBuf))
{
Assert(FALSE);
pcmdText->cwBuf = 0;
}
#else
pchStr = ((TCHAR *)(pcmdText->rgwz));
LPTSTR pchTmpA = LPTSTRfromBstr(pch);
StrCpyN(pchStr, pchTmpA, ARRAYSIZE(pcmdText->rgwz));
MemFree(pchTmpA);
LPTSTR pchA = LPTSTRfromBstr(szTmp);
StrCatBuff(pchStr, pchA, ARRAYSIZE(pcmdText->rgwz));
MemFree(pchA);
pcmdText->cwActual = lstrlen(pchStr) + 1;
#endif
}
/* else
goto err; */
return(TRUE);
}
STDMETHODIMP CIEMsgAb::AddPages(LPFNADDPROPSHEETPAGE lpfnAddPage, LPARAM lParam)
{
#ifdef LATER
TCHAR sz[CCHMAX_STRINGRES];
if(m_lpWED->fReadOnly)
return NOERROR;
PROPSHEETPAGE psp;
// hinstApp = g_hInst;
psp.dwSize = sizeof(psp); // no extra data
psp.dwFlags = PSP_USEREFPARENT | PSP_USETITLE ;
psp.hInstance = g_hLocRes;
psp.lParam = (LPARAM) &(m_lpWED);
psp.pcRefParent = (UINT *)&(m_cRefThisDll);
psp.pszTemplate = MAKEINTRESOURCE(iddWabExt);
psp.pfnDlgProc = WabExtDlgProc;
psp.pszTitle = AthLoadString(idsWABExtTitle, sz, ARRAYSIZE(sz)); // Title for your tab AthLoadString(idsWABExtTitle, sz, ARRAYSIZE(sz))
m_hPage1 = ::CreatePropertySheetPage(&psp);
if (m_hPage1)
{
if (!lpfnAddPage(m_hPage1, lParam))
::DestroyPropertySheetPage(m_hPage1);
}
return NOERROR;
#else
return E_NOTIMPL;
#endif
}
STDMETHODIMP CIEMsgAb::ReplacePage(UINT uPageID, LPFNADDPROPSHEETPAGE lpfnReplaceWith, LPARAM lParam)
{
Assert(FALSE);
return E_NOTIMPL;
}
STDMETHODIMP CIEMsgAb::Initialize(LPWABEXTDISPLAY lpWABExtDisplay)
{
if (lpWABExtDisplay == NULL)
{
TRACE("CIEMsgAb::Initialize() no data object");
return E_FAIL;
}
if(st_pAddrBook == NULL)
{
TRACE("CIEMsgAb::Initialize() - run from not OE - no st_pAddrbook");
return E_FAIL;
}
if (!m_dwHideMessenger && !m_dwDisableMessenger)
{
if(!m_pCMsgrList)
{
m_pCMsgrList = OE_OpenMsgrList();
if(!m_pCMsgrList)
{
TRACE("CIEMsgAb::Initialize() - Messeneger not installed");
return E_FAIL;
}
}
}
// However if this is a context menu extension, we need to hang
// onto the propobj till such time as InvokeCommand is called ..
// At this point just AddRef the propobj - this will ensure that the
// data in the lpAdrList remains valid till we release the propobj..
// When we get another ContextMenu initiation, we can release the
// older cached propobj - if we dont get another initiation, we
// release the cached object at shutdown time
if(lpWABExtDisplay->ulFlags & WAB_CONTEXT_ADRLIST) // this means a IContextMenu operation is occuring
{
if(m_lpPropObj)
{
m_lpPropObj->Release();
m_lpPropObj = NULL;
}
m_lpPropObj = lpWABExtDisplay->lpPropObj;
m_lpPropObj->AddRef();
m_lpWEDContext = lpWABExtDisplay;
}
else
{
// For property sheet extensions, the lpWABExtDisplay will
// exist for the life of the property sheets ..
m_lpWED = lpWABExtDisplay;
}
return S_OK;
}
HRESULT CIEMsgAb::PromptToGoOnline()
{
HRESULT hr = S_OK;
#ifdef LATER
if (g_pConMan->IsGlobalOffline())
{
if (IDYES == AthMessageBoxW(m_hwndParent, MAKEINTRESOURCEW(idsAthena), MAKEINTRESOURCEW(idsErrWorkingOffline),
0, MB_YESNO | MB_ICONEXCLAMATION ))
{
g_pConMan->SetGlobalOffline(FALSE);
hr = S_OK;
}
else
{
hr = S_FALSE;
}
}
else
hr = S_OK;
#endif
return hr;
}
HRESULT CIEMsgAb::ResizeChildWindows(LPCRECT prcPos)
{
RECT rc;
// Get the size of the outer window
if (!prcPos)
{
GetClientRect(&rc);
rc.right = rc.right - rc.left;
rc.bottom = rc.bottom - rc.top;
}
else
{
rc.top = 0;
rc.left = 0;
rc.right = prcPos->right - prcPos->left;
rc.bottom = prcPos->bottom - prcPos->top;
}
#if 0
// If we have to reserve room for the status bar and menu bar, do it
if (m_fStatusBar)
rc.bottom -= m_cyStatusBar;
if (m_fMenuBar)
rc.top += m_cyMenuBar;
#endif
// Move the ListView into the right place
/* ::SetWindowPos(m_ctlList.m_hWnd, NULL, rc.top, rc.left,
rc.right, rc.bottom, SWP_NOZORDER | SWP_NOACTIVATE); */
return S_OK;
}
///////////////////////////////////////////////////////////////////////////
//
// IDeskBand implementation
//
///////////////////////////////////////////////////////////////////////////
//
// CIEMsgAb::GetBandInfo()
//
///////////////////////////////////////////////////////////////////////////
#define MIN_SIZE_X 50
#define MIN_SIZE_Y 50
STDMETHODIMP CIEMsgAb::GetBandInfo(DWORD dwBandID,
DWORD dwViewMode,
DESKBANDINFO* pdbi)
{
if (pdbi)
{
// _dwBandID = dwBandID;
// _dwViewMode = dwViewMode;
if (pdbi->dwMask & DBIM_MINSIZE)
{
pdbi->ptMinSize.x = MIN_SIZE_X;
pdbi->ptMinSize.y = MIN_SIZE_Y;
}
if (pdbi->dwMask & DBIM_MAXSIZE)
{
pdbi->ptMaxSize.x = -1;
pdbi->ptMaxSize.y = -1;
}
if (pdbi->dwMask & DBIM_INTEGRAL)
{
pdbi->ptIntegral.x = 1;
pdbi->ptIntegral.y = 1;
}
if (pdbi->dwMask & DBIM_ACTUAL)
{
pdbi->ptActual.x = 0;
pdbi->ptActual.y = 0;
}
if (pdbi->dwMask & DBIM_TITLE)
{
StrCpyNW(pdbi->wszTitle, L"WebBand Search", ARRAYSIZE(pdbi->wszTitle));
}
if (pdbi->dwMask & DBIM_MODEFLAGS)
pdbi->dwModeFlags = DBIMF_VARIABLEHEIGHT;
if (pdbi->dwMask & DBIM_BKCOLOR)
{
// Use the default background color by removing this flag.
pdbi->dwMask &= ~DBIM_BKCOLOR;
}
return S_OK;
}
return E_INVALIDARG;
}
///////////////////////////////////////////////////////////////////////////
//
// IDockingWindow Methods
//
///////////////////////////////////////////////////////////////////////////
//
// CIEMsgAb::ShowDW()
//
///////////////////////////////////////////////////////////////////////////
STDMETHODIMP CIEMsgAb::ShowDW(BOOL fShow)
{
if (m_hWnd)
{
//
// Hide or show the window depending on
// the value of the fShow parameter.
//
if (fShow)
::ShowWindow(m_hWnd, SW_SHOW);
else
::ShowWindow(m_hWnd, SW_HIDE);
}
return S_OK;
}
///////////////////////////////////////////////////////////////////////////
//
// CIEMsgAb::CloseDW()
//
///////////////////////////////////////////////////////////////////////////
STDMETHODIMP CIEMsgAb::CloseDW(DWORD dwReserved)
{
ShowDW(FALSE);
// Assert(FALSE);
if (IsWindow(m_hWnd))
::DestroyWindow(m_hWnd);
m_hWnd = NULL;
return S_OK;
}
///////////////////////////////////////////////////////////////////////////
//
// CIEMsgAb::ResizeBorderDW()
//
///////////////////////////////////////////////////////////////////////////
STDMETHODIMP CIEMsgAb::ResizeBorderDW(LPCRECT prcBorder, IUnknown* punkToolbarSite,
BOOL fReserved)
{
// This method is never called for Band Objects.
return E_NOTIMPL;
}
///////////////////////////////////////////////////////////////////////////
//
// IOleWindow Methods
//
///////////////////////////////////////////////////////////////////////////
//
// CIEMsgAb::GetWindow()
//
///////////////////////////////////////////////////////////////////////////
STDMETHODIMP CIEMsgAb::GetWindow(HWND *phwnd)
{
*phwnd = m_hWnd;
return S_OK;
}
///////////////////////////////////////////////////////////////////////////
//
// CIEMsgAb::ContextSensitiveHelp()
//
///////////////////////////////////////////////////////////////////////////
STDMETHODIMP CIEMsgAb::ContextSensitiveHelp(BOOL fEnterMode)
{
return E_NOTIMPL;
}
STDMETHODIMP CIEMsgAb::Init (REFGUID refguid)
{
return S_OK;
}
STDMETHODIMP CIEMsgAb::GetProperty(SHORT iPropID, VARIANTARG * pvarProperty)
{
HRESULT hr = S_OK;
switch (iPropID)
{
case TBEX_BUTTONTEXT:
if (pvarProperty)
{
pvarProperty->vt = VT_BSTR;
pvarProperty->bstrVal = SysAllocString(L"YST Button");
if (NULL == pvarProperty->bstrVal)
hr = E_OUTOFMEMORY;
}
break;
case TBEX_GRAYICON:
hr = E_NOTIMPL; // hr = _GetIcon(TEXT("Icon"), 20, 20, _hIcon, pvarProperty);
break;
case TBEX_GRAYICONSM:
hr = E_NOTIMPL; // hr = _GetIcon(TEXT("Icon"), 16, 16, _hIconSm, pvarProperty);
break;
case TBEX_HOTICON:
hr = E_NOTIMPL; // hr = _GetIcon(TEXT("HotIcon"), 20, 20, _hHotIcon, pvarProperty);
break;
case TBEX_HOTICONSM:
hr = E_NOTIMPL; //hr = _GetIcon(TEXT("HotIcon"), 16, 16, _hHotIcon, pvarProperty);
break;
case TBEX_DEFAULTVISIBLE:
if (pvarProperty)
{
// BOOL fVisible = _RegGetBoolValue(L"Default Visible", FALSE);
pvarProperty->vt = VT_BOOL;
pvarProperty->boolVal = VARIANT_TRUE;
}
break;
case TMEX_CUSTOM_MENU:
{
if (pvarProperty != NULL)
{
pvarProperty->vt = VT_BSTR;
pvarProperty->bstrVal = SysAllocString(L"YST test");
if (pvarProperty->bstrVal == NULL)
{
hr = E_OUTOFMEMORY;
}
}
}
break;
case TMEX_MENUTEXT:
if (pvarProperty)
{
pvarProperty->vt = VT_BSTR;
pvarProperty->bstrVal = SysAllocString(L"YST test 1");
if (NULL == pvarProperty->bstrVal)
hr = E_OUTOFMEMORY;
}
break;
case TMEX_STATUSBARTEXT:
if (pvarProperty)
{
pvarProperty->vt = VT_BSTR;
pvarProperty->bstrVal = SysAllocString(L"YST test 2");
if (NULL == pvarProperty->bstrVal)
hr = E_OUTOFMEMORY;
}
break;
default:
hr = E_NOTIMPL;
}
return hr;
}
// --------------------------------------------------------------------------------
// AthLoadString
// --------------------------------------------------------------------------------
LPSTR ANSI_AthLoadString(UINT id, TCHAR* sz, int cch)
{
LPSTR szT;
if (sz == NULL)
{
if (!MemAlloc((LPVOID*)&szT, CCHMAX_STRINGRES))
return(NULL);
cch = CCHMAX_STRINGRES;
}
else
szT = sz;
if(g_hLocRes)
{
cch = LoadString(g_hLocRes, id, szT, cch);
Assert(cch > 0);
if (cch == 0)
{
if (sz == NULL)
MemFree(szT);
szT = NULL;
}
}
else
{
if (sz == NULL)
MemFree(szT);
szT = NULL;
}
return(szT);
}
// --------------------------------------------------------------------------------
// AthLoadString
// --------------------------------------------------------------------------------
LPWSTR AthLoadString(UINT id, LPWSTR sz, int cch)
{
LPWSTR szT;
if (sz == NULL)
{
if (!MemAlloc((LPVOID*)&szT, CCHMAX_STRINGRES*sizeof(WCHAR)))
return(NULL);
cch = CCHMAX_STRINGRES;
}
else
szT = sz;
if(g_hLocRes)
{
cch = LoadStringW(g_hLocRes, id, szT, cch);
Assert(cch > 0);
if (cch == 0)
{
if (sz == NULL)
MemFree(szT);
szT = NULL;
}
}
else
{
if (sz == NULL)
MemFree(szT);
szT = NULL;
}
return(szT);
}
//
// REVIEW: We need this function because current version of USER.EXE does
// not support pop-up only menu.
//
HMENU LoadPopupMenu(UINT id)
{
HMENU hmenuParent = LoadMenuW(g_hLocRes, MAKEINTRESOURCEW(id));
if (hmenuParent) {
HMENU hpopup = GetSubMenu(hmenuParent, 0);
RemoveMenu(hmenuParent, 0, MF_BYPOSITION);
DestroyMenu(hmenuParent);
return hpopup;
}
return NULL;
}
void MenuUtil_BuildMenuIDList(HMENU hMenu, OLECMD **prgCmds, ULONG *pcStart, ULONG *pcCmds)
{
ULONG cItems = 0;
MENUITEMINFO mii;
if(!IsMenu(hMenu))
return;
// Start by getting the count of items on this menu
cItems = GetMenuItemCount(hMenu);
if (!cItems)
return;
// Realloc the array to be cItems elements bigger
if (!MemRealloc((LPVOID *) prgCmds, sizeof(OLECMD) * (cItems + (*pcCmds))))
return;
*pcCmds += cItems;
// Walk this menu and add our items to it
mii.cbSize = sizeof(MENUITEMINFO);
mii.fMask = MIIM_ID | MIIM_SUBMENU;
for (ULONG i = 0; i < cItems; i++)
{
if (GetMenuItemInfo(hMenu, i, TRUE, &mii))
{
// Make sure this isn't a separator
if (mii.wID != -1 && mii.wID != 0)
{
// Add the ID to our array
(*prgCmds)[*pcStart].cmdID = mii.wID;
(*prgCmds)[*pcStart].cmdf = 0;
(*pcStart)++;
// See if we need to recurse
if (mii.hSubMenu)
{
MenuUtil_BuildMenuIDList(mii.hSubMenu, prgCmds, pcStart, pcCmds);
}
}
}
}
return;
}
//
// FUNCTION: MenuUtil_EnablePopupMenu()
//
// PURPOSE: Walks the given menu and takes care of enabling and
// disabling each item via the provided commnand target.
//
// PARAMETERS:
// [in] hPopup
// [in] *pTarget
//
HRESULT MenuUtil_EnablePopupMenu(HMENU hPopup, CIEMsgAb *pTarget)
{
HRESULT hr = S_OK;
int i;
int cItems;
OLECMD *rgCmds = NULL;
ULONG cStart = 0;
ULONG cCmds = 0;
MENUITEMINFO mii = {0};
OLECMDTEXT CmdText;
OLECMDTEXTV<MAX_MENUSTR> CmdNewText;
Assert(hPopup && pTarget);
// Build the array of menu ids
MenuUtil_BuildMenuIDList(hPopup, &rgCmds, &cCmds, &cStart);
// Ask our parent for the state of the commands
CmdText.cmdtextf = OLECMDTEXTF_NONE;
if (SUCCEEDED(hr = pTarget->QueryStatus(NULL, cCmds, rgCmds, &CmdText)))
{
mii.cbSize = sizeof(MENUITEMINFO);
// Now loop through the menu and apply the state
for (i = 0; i < (int) cCmds; i++)
{
BOOL f;
CmdNewText.cwBuf = 0;
if(rgCmds[i].cmdf & OLECMDF_INVISIBLE)
RemoveMenu(hPopup, rgCmds[i].cmdID, MF_BYCOMMAND);
else
{
// The default thing we're going to update is the state
mii.fMask = MIIM_STATE;
// Enabled or Disabled
if (rgCmds[i].cmdf & OLECMDF_ENABLED)
{
mii.fState = MFS_ENABLED;
}
else
mii.fState = MFS_GRAYED;
// Checked?
if (rgCmds[i].cmdf & OLECMDF_LATCHED)
mii.fState |= MFS_CHECKED;
if(mii.fState == MFS_ENABLED)
{
// special for phones
if((rgCmds[i].cmdID > ID_DIAL_PHONE_NUMBER) && (rgCmds[i].cmdID < ID_DIAL_PHONE_LAST))
{
OLECMD Cmd[1];
Cmd[0].cmdf = 0;
Cmd[0].cmdID = rgCmds[i].cmdID;
CmdNewText.cmdtextf = OLECMDTEXTF_NAME;
if (SUCCEEDED(hr = pTarget->QueryStatus(NULL, 1, Cmd, &CmdNewText)))
{
if(CmdNewText.cwBuf)
{
mii.fType = MFT_STRING;
mii.fMask |= MIIM_TYPE;
mii.dwTypeData = ((LPSTR) CmdNewText.rgwz);
mii.cch = CmdNewText.cwBuf;
}
else
{
mii.dwTypeData = NULL;
mii.cch = 0;
}
}
}
}
// Set the item state
f = SetMenuItemInfo(hPopup, rgCmds[i].cmdID, FALSE, &mii);
// if(CmdNewText.cwBuf)
// MemFree(&(CmdNewText.rgwz[0]));
// Radio Check?
if ((rgCmds[i].cmdf & OLECMDF_NINCHED) && rgCmds[i].cmdID != (-1))
{
CheckMenuRadioItem(hPopup, rgCmds[i].cmdID, rgCmds[i].cmdID, rgCmds[i].cmdID, MF_BYCOMMAND);
// mii.fMask |= MIIM_TYPE;
// mii.fType = MFT_RADIOCHECK;
// mii.fState |= MFS_CHECKED;
}
// Assert(f);
}
}
}
SafeMemFree(rgCmds);
return (hr);
}
HRESULT CEmptyList::Show(HWND hwndList, LPWSTR pszString)
{
// We're already doing a window
if (m_hwndList)
{
Hide();
}
// Keep a copy of the listview window handle
m_hwndList = hwndList;
if(MemAlloc((LPVOID *) &m_pwszString, (lstrlenW(pszString) + 1)*sizeof(WCHAR)))
StrCpyNW(m_pwszString, pszString, lstrlenW(pszString) + 1);
// Get the header window handle from the listview
m_hwndHeader = ListView_GetHeader(m_hwndList);
// Save our this pointer on the listview window
SetProp(m_hwndList, _T("EmptyListClass"), (HANDLE) this);
// Subclass the listview so we can steal sizing messages
if (!m_pfnWndProc)
m_pfnWndProc = SubclassWindow(m_hwndList, SubclassWndProc);
// Create our window on top
if (!m_hwndBlocker)
{
m_hwndBlocker = CreateWindow(_T("Button"), _T("Blocker"),
WS_CHILD | WS_TABSTOP | WS_CLIPSIBLINGS | BS_OWNERDRAW /*| ES_MULTILINE | ES_READONLY*/,
0, 0, 0, 0, m_hwndList, (HMENU) NULL, g_hLocRes, NULL);
Assert(m_hwndBlocker);
}
// Set the font for the blocker
if(!m_hFont)
{
LOGFONT lf;
// Figure out which font to use
SystemParametersInfo(SPI_GETICONTITLELOGFONT, sizeof(LOGFONT), &lf, FALSE);
// Create the fonts
m_hFont = CreateFontIndirect(&lf);
}
// Show the silly thing
if(m_hFont)
{
SendMessageW(m_hwndBlocker, WM_SETFONT, (WPARAM) m_hFont, MAKELPARAM(TRUE, 0));
}
// SetWindowTextW(m_hwndBlocker, m_pwszString);
// Position the blocker
RECT rcList = {0};
RECT rcHead = {0};
GetClientRect(m_hwndList, &rcList);
if(m_hwndHeader)
GetClientRect(m_hwndHeader, &rcHead);
SetWindowPos(m_hwndBlocker, 0, 0, rcHead.bottom, rcList.right,
rcList.bottom - rcHead.bottom, SWP_NOACTIVATE | SWP_NOZORDER);
ShowWindow(m_hwndBlocker, SW_SHOW);
return (S_OK);
}
HRESULT CEmptyList::Hide(void)
{
// Verify we have the blocker up first
if (m_pfnWndProc)
{
// Hide the window
ShowWindow(m_hwndBlocker, SW_HIDE);
// Unsubclass the window
SubclassWindow(m_hwndList, m_pfnWndProc);
// Delete the property
RemoveProp(m_hwndList, _T("EmptyListClass"));
// Free the string
SafeMemFree(m_pwszString);
// NULL everything out
m_pfnWndProc = 0;
m_hwndList = 0;
}
return (S_OK);
}
CEmptyList::~CEmptyList()
{
if(m_hFont)
DeleteObject(m_hFont);
if (IsWindow(m_hwndBlocker))
DestroyWindow(m_hwndBlocker);
SafeMemFree(m_pwszString);
if (NULL != m_hbrBack)
DeleteObject(m_hbrBack);
}
LRESULT CEmptyList::SubclassWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
CEmptyList* pThis = (CEmptyList *) GetProp(hwnd, _T("EmptyListClass"));
Assert(pThis);
switch (uMsg)
{
case WM_DRAWITEM:
if (pThis && IsWindow(pThis->m_hwndBlocker))
{
LPDRAWITEMSTRUCT pdis = (LPDRAWITEMSTRUCT) lParam;
RECT rc = pdis->rcItem;
WCHAR wszStr[RESSTRMAX];
HBRUSH hbr3DFace = NULL;
hbr3DFace = CreateSolidBrush(GetSysColor(COLOR_WINDOW));
FillRect(pdis->hDC, &(pdis->rcItem), hbr3DFace);
SetBkColor(pdis->hDC, GetSysColor(COLOR_WINDOW));
DeleteObject(hbr3DFace);
// Position the blocker
RECT rcList = {0};
RECT rcHead = {0};
GetClientRect(pThis->m_hwndList, &rcList);
if(pThis->m_hwndHeader)
GetClientRect(pThis->m_hwndHeader, &rcHead);
SetWindowPos(pThis->m_hwndBlocker, 0, 0, rcHead.bottom, rcList.right,
rcList.bottom - rcHead.bottom, SWP_NOACTIVATE | SWP_NOZORDER);
SelectFont(pdis->hDC, pThis->m_hFont);
rc.left = 0;
rc.top = rcHead.bottom;
rc.right = rcList.right;
rc.bottom = rcList.bottom - rcHead.bottom;
hbr3DFace = CreateSolidBrush(GetSysColor(COLOR_WINDOW));
FillRect(pdis->hDC, &(pdis->rcItem), hbr3DFace);
SetBkColor(pdis->hDC, GetSysColor(COLOR_WINDOW));
DeleteObject(hbr3DFace);
DrawTextW(pdis->hDC, pThis->m_pwszString, -1, &rc, DT_WORDBREAK | DT_VCENTER | DT_CENTER );
return(0);
}
break;
case WM_SIZE:
if (pThis && IsWindow(pThis->m_hwndBlocker))
{
RECT rcHeader = {0};
GetClientRect(pThis->m_hwndHeader, &rcHeader);
SetWindowPos(pThis->m_hwndBlocker, 0, 0, 0, LOWORD(lParam),
HIWORD(lParam) - rcHeader.bottom,
SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
InvalidateRect(pThis->m_hwndBlocker, NULL, FALSE);
}
break;
case WM_CTLCOLORSTATIC:
if ((HWND) lParam == pThis->m_hwndBlocker)
{
if (!pThis->m_hbrBack)
{
pThis->m_hbrBack = CreateSolidBrush(GetSysColor(COLOR_WINDOW));
}
SetBkColor((HDC) wParam, GetSysColor(COLOR_WINDOW));
return (LRESULT) pThis->m_hbrBack;
}
break;
case WM_SYSCOLORCHANGE:
if (pThis)
{
DeleteObject(pThis->m_hbrBack);
pThis->m_hbrBack = 0;
SendMessage(pThis->m_hwndBlocker, uMsg, wParam, lParam);
}
break;
case WM_WININICHANGE:
case WM_FONTCHANGE:
if (pThis)
{
LRESULT lResult = CallWindowProc(pThis->m_pfnWndProc, hwnd, uMsg, wParam, lParam);
SendMessage(pThis->m_hwndBlocker, uMsg, wParam, lParam);
// HFONT hf = (HFONT) SendMessage(pThis->m_hwndList, WM_GETFONT, 0, 0);
// SendMessage(pThis->m_hwndBlocker, WM_SETFONT, (WPARAM) hf, MAKELPARAM(TRUE, 0));
return (lResult);
}
case WM_DESTROY:
{
if (pThis)
{
WNDPROC pfn = pThis->m_pfnWndProc;
pThis->Hide();
return (CallWindowProc(pfn, hwnd, uMsg, wParam, lParam));
}
}
break;
}
return (CallWindowProc(pThis->m_pfnWndProc, hwnd, uMsg, wParam, lParam));
}
extern "C" const GUID CLSID_MailRecipient;
HRESULT DropOnMailRecipient(IDataObject *pdtobj, DWORD grfKeyState)
{
IDropTarget *pdrop;
HRESULT hres = CoCreateInstance(CLSID_MailRecipient,
NULL, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
IID_IDropTarget, (void **) &pdrop);
if (SUCCEEDED(hres))
{
hres = OESimulateDrop(pdrop, pdtobj, grfKeyState, NULL, NULL);
pdrop->Release();
}
return hres;
}
STDAPI OESimulateDrop(IDropTarget *pdrop, IDataObject *pdtobj, DWORD grfKeyState,
const POINTL *ppt, DWORD *pdwEffect)
{
POINTL pt;
DWORD dwEffect;
if (!ppt)
{
ppt = &pt;
pt.x = 0;
pt.y = 0;
}
if (!pdwEffect)
{
pdwEffect = &dwEffect;
dwEffect = DROPEFFECT_LINK | DROPEFFECT_MOVE | DROPEFFECT_COPY;
}
DWORD dwEffectSave = *pdwEffect; // drag enter returns the default effect
HRESULT hr = pdrop->DragEnter(pdtobj, grfKeyState, *ppt, pdwEffect);
if (*pdwEffect)
{
*pdwEffect = dwEffectSave; // do Drop with the full set of bits
hr = pdrop->Drop(pdtobj, grfKeyState, *ppt, pdwEffect);
}
else
{
pdrop->DragLeave();
hr = S_FALSE; // HACK? S_FALSE DragEnter said no
}
return hr;
}