/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.0 (the "NPL"); you may not use this file except in
 * compliance with the NPL.  You may obtain a copy of the NPL at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the NPL is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
 * for the specific language governing rights and limitations under the
 * NPL.
 *
 * The Initial Developer of this code under the NPL is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
 * Reserved.
 */

// addrfrm.cpp : implementation file
//

#include "stdafx.h"
#include "addrfrm.h"
#ifdef FEATURE_ADDRPROP
#include "addrprop.h"
#endif
#include "template.h"
#include "xpgetstr.h"
#include "wfemsg.h"
#include "msg_srch.h"
#include "dirprefs.h"
#include "nethelp.h"
#include "xp_help.h"
#include "prefapi.h"
#include "intlwin.h"
#include "srchdlg.h"
#include "intl_csi.h"
#include "mailpriv.h"
#include "mnprefs.h"

//RHP - Need this include for the call in confhook.cpp
#include "confhook.h"

#ifndef _AFXDLL
#undef new
#endif
IMPLEMENT_DYNCREATE(CAddrFrame, CGenericFrame)
#ifndef _AFXDLL
#define new DEBUG_NEW
#endif

extern "C" {
#include "xpgetstr.h"
extern int MK_MSG_CANT_CALL_MAILING_LIST;
extern int MK_MSG_CALL_NEEDS_IPADDRESS;
extern int MK_MSG_CALL_NEEDS_EMAILADDRESS;
extern int MK_MSG_CANT_FIND_CALLPOINT;
extern int MK_ADDR_BOOK_CARD;
extern int MK_ADDR_NEW_CARD;
extern int MK_OUT_OF_MEMORY;
extern int	MK_ADDR_FIRST_LAST_SEP;
extern int	MK_ADDR_LAST_FIRST_SEP;
};


#define ADDRESS_BOOK_TIMER          6
#define OUTLINER_TYPEDOWN_TIMER     250
#define TYPEDOWN_SPEED				300
#define LDAP_SEARCH_SPEED			1250
#define OUTLINER_TYPEDOWN_SPEED		1250

static UINT AddrCodes[] = {
    ID_ITEM_ADDUSER,
	ID_ITEM_ADDLIST,
	ID_ITEM_PROPERTIES,
	ID_FILE_NEWMESSAGE,
	ID_LIVE_CALL,
	ID_EDIT_DELETE,
	ID_NAVIGATE_INTERRUPT
    };

int FE_ShowPropertySheetFor (MWContext* context, ABID entryID, PersonEntry* pPerson)
{
	DIR_Server *pab = NULL;
	BOOL result = FALSE;

#ifdef FEATURE_ADDRPROP
	DIR_GetPersonalAddressBook (theApp.m_directories, &pab);
	XP_ASSERT (pab);

	if (pab) 
	{
		if (entryID != MSG_MESSAGEIDNONE) 
		{
			CString formattedString;
			char fullname [kMaxFullNameLength];
			AB_GetFullName(pab, theApp.m_pABook, entryID, fullname);
			formattedString.Format(XP_GetString (MK_ADDR_BOOK_CARD), fullname);
			CAddrEditProperties prop(NULL, pab,
				(const char *) formattedString, ABSTRACTCX(context)->GetDialogOwner(), entryID, pPerson, context);
			prop.SetCurrentPage(0);
			result = prop.DoModal();
		}
		else 
		{
			CString formattedString;
			char* name = NULL;
			name = (char *) XP_ALLOC(kMaxFullNameLength);
			if (!name)
				return MK_OUT_OF_MEMORY;
			XP_STRCPY (name, pPerson->pGivenName);
			if (pPerson->pFamilyName)
			{
				XP_STRNCPY_SAFE (name, XP_GetString (MK_ADDR_FIRST_LAST_SEP), kMaxFullNameLength);
				XP_STRNCPY_SAFE (name, pPerson->pFamilyName, kMaxFullNameLength);
			}

			formattedString.Format(XP_GetString (MK_ADDR_BOOK_CARD), name);
			XP_FREEIF (name);
			CAddrEditProperties prop(NULL, pab,
				(const char *) formattedString, ABSTRACTCX(context)->GetDialogOwner(), 0, pPerson, context);
			prop.SetCurrentPage(0);
			result = prop.DoModal();
		}
	}

	if (result == IDOK)
		result = TRUE;
	if (result == IDCANCEL)
		result = FALSE;
	// if it is -1 then there was a memory problem creating the dialog 
	// and we should return that
#endif

	return result;
}
  
void CAddrCX::DestroyContext()
{
	CStubsCX::DestroyContext();
}


CAddrBar::CAddrBar()
{
	m_iWidth = 0;
	m_uTypedownClock = 0;
	m_save = "";
	m_savedir = -1;
	m_pFont = NULL;
	m_bRemoveLDAPDir = FALSE;

	PREF_GetBoolPref("mail.addr_book.ldap.disabled", &m_bRemoveLDAPDir);

	//{{AFX_DATA_INIT(CAddrbkView)
	m_name = _T("");
	m_directory = 0;
	//}}AFX_DATA_INIT
	// TODO: add construction code here
}

CAddrBar::~CAddrBar()
{
	if (m_pFont) {
		theApp.ReleaseAppFont(m_pFont);
	}
}

/////////////////////////////////////////////////////////////////////////////
// CAddrBar Message handlers

BEGIN_MESSAGE_MAP(CAddrBar, CDialogBar)
	//{{AFX_MSG_MAP(CAddrFrame)
	ON_WM_CREATE()
	ON_WM_SIZE()
	ON_WM_TIMER ()
	ON_EN_CHANGE(IDC_ADDRNAME, OnChangeName)
 	ON_EN_SETFOCUS(IDC_ADDRNAME, OnSetFocusName)
	ON_CBN_SELCHANGE(IDC_DIRECTORIES, OnChangeDirectory)
	ON_BN_CLICKED(IDC_DIRSEARCH, OnExtDirectorySearch)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


BOOL CAddrBar::Create(CWnd* pParentWnd, UINT nIDTemplate, UINT nStyle, UINT nID)
{
	BOOL res = CDialogBar::Create(pParentWnd, nIDTemplate, nStyle, nID);

	m_iWidth = m_sizeDefault.cx;

	return res;
}


int CAddrBar::OnCreate( LPCREATESTRUCT lpCreateStruct )
{
    int retval =  CDialogBar::OnCreate( lpCreateStruct);

	HDC hDC = ::GetDC(m_hWnd);
	LOGFONT lf;  
	memset(&lf,0,sizeof(LOGFONT));
	lf.lfPitchAndFamily = FF_SWISS;
	lf.lfWeight = FW_NORMAL;
	lf.lfCharSet = IntlGetLfCharset(CIntlWin::GetSystemLocaleCsid());
	if (CIntlWin::GetSystemLocaleCsid() == CS_LATIN1)
		_tcscpy(lf.lfFaceName, "MS Sans Serif");
	else
		_tcscpy(lf.lfFaceName, IntlGetUIPropFaceName(CIntlWin::GetSystemLocaleCsid()));
	lf.lfHeight = -MulDiv(9, ::GetDeviceCaps(hDC, LOGPIXELSY), 72);
	m_pFont = theApp.CreateAppFont( lf );
    ::ReleaseDC(m_hWnd,hDC);

	CRect rect;
	GetClientRect(&rect);
	m_sizeDefault = rect.Size();

	return retval;
}

void CAddrBar::SetDirectoryIndex( int dirIndex )
{
   	CComboBox *widget = (CComboBox*) GetDlgItem(IDC_DIRECTORIES);
	m_savedir = -1;
	widget->SetCurSel (dirIndex);
	UpdateData(TRUE);
	if (m_directory != m_savedir) {
		m_savedir = m_directory;
		if (m_directory != -1) {
			XP_Bool bSelectable = FALSE, bPlural = FALSE;
			MSG_COMMAND_CHECK_STATE sState;
			CAddrFrame* frame = (CAddrFrame*) GetParentFrame();
			AB_CommandStatus((ABPane*) frame->GetPane(),
							  AB_LDAPSearchCmd,
							  NULL, NULL,
							  &bSelectable,
							  &sState,
							  NULL,
							  &bPlural);
			CWnd* widget = GetDlgItem ( IDC_DIRSEARCH );
			widget->EnableWindow(bSelectable);
		}
	}
}


void CAddrBar::UpdateDirectories()
{
	DIR_Server* dir;
	CComboBox *widget = (CComboBox*) GetDlgItem(IDC_DIRECTORIES);

	widget->ResetContent();

	XP_List *pTraverse = theApp.m_directories;
	while (dir = (DIR_Server*) XP_ListNextObject(pTraverse)) {
		if (m_bRemoveLDAPDir){
			if (dir->dirType == PABDirectory)
				widget->AddString(dir->description);
		}
		else if (dir->dirType == PABDirectory || dir->dirType == LDAPDirectory)
			widget->AddString(dir->description);
	}

	if (m_directory == -1)
		widget->SetCurSel(0);
	else
		widget->SetCurSel(m_directory);
}

void CAddrBar::OnTimer(UINT nID)
{
	CWnd::OnTimer(nID);
	if (nID == ADDRESS_BOOK_TIMER) {
		KillTimer(m_uTypedownClock);
		CAddrFrame* frame = (CAddrFrame*) GetParentFrame();
		if (!m_name.IsEmpty()) {
			frame->OnTypedown(m_name.GetBuffer(0));
			m_name.ReleaseBuffer();
		}
	}
}

void CAddrBar::OnKillFocus( CWnd* pNewWnd )
{
	KillTimer(m_uTypedownClock);
}

void CAddrBar::DoDataExchange(CDataExchange* pDX)
{
	CDialogBar::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CAddrbkView)
	DDX_Text(pDX, IDC_ADDRNAME, m_name);
	DDX_CBIndex(pDX, IDC_DIRECTORIES, m_directory);
	//}}AFX_DATA_MAP
}


void CAddrBar::OnChangeName() 
{
	// TODO: Add your control notification handler code here
	CAddrFrame* frame = (CAddrFrame*) GetParentFrame();
	if (frame->IsSearching()) {
		frame->OnExtendedDirectorySearch();
	}

	UpdateData(TRUE);
	if (m_name != m_save) {
		m_save = m_name;
		KillTimer(m_uTypedownClock);
		if (m_name.GetLength())
		{
			DIR_Server* dir;
			CComboBox *widget = (CComboBox*) GetDlgItem(IDC_DIRECTORIES);
			dir = (DIR_Server*) XP_ListGetObjectNum (theApp.m_directories, widget->GetCurSel() + 1);
			if (dir->dirType == PABDirectory)
				m_uTypedownClock = SetTimer(ADDRESS_BOOK_TIMER, TYPEDOWN_SPEED, NULL);
			else {
				int32 prefInt = LDAP_SEARCH_SPEED;
				PREF_GetIntPref("ldap_1.autoComplete.interval", &prefInt);
				m_uTypedownClock = SetTimer(ADDRESS_BOOK_TIMER, prefInt, NULL);
			}
		}
	}
}


void CAddrBar::OnSetFocusName() 
{
	CEdit *widget = (CEdit*) GetDlgItem(IDC_ADDRNAME);
	widget->SetSel(0, -1, TRUE);
}


void CAddrBar::OnChangeDirectory() 
{
	// TODO: Add your control notification handler code here
	CAddrFrame* frame = (CAddrFrame*) GetParentFrame();
	if (frame->IsSearching())
		return;

	UpdateData(TRUE);
	if (m_directory != m_savedir) {
		m_savedir = m_directory;
		if (m_directory != -1) {

			frame->OnChangeDirectory(m_directory);
			XP_Bool bSelectable = FALSE, bPlural = FALSE;
			MSG_COMMAND_CHECK_STATE sState;
			AB_CommandStatus((ABPane*) frame->GetPane(),
							  AB_LDAPSearchCmd,
							  NULL, NULL,
							  &bSelectable,
							  &sState,
							  NULL,
							  &bPlural);
			CWnd* widget = GetDlgItem ( IDC_DIRSEARCH );
			widget->EnableWindow(bSelectable);
		}
	}
}


void CAddrBar::OnExtDirectorySearch() 
{
	// TODO: Add your control notification handler code here	
	CAddrFrame* frame = (CAddrFrame*) GetParentFrame();
	if (m_directory != -1) {
		KillTimer(m_uTypedownClock);
		frame->OnExtendedDirectorySearch();
	}
} 


static void GrowWindow( CWnd *pWnd, int dx, int dy )
{
	CRect rect;
	CWnd *parent;

	pWnd->GetWindowRect(&rect);
	if (parent = pWnd->GetParent())
		parent->ScreenToClient(&rect);

	rect.bottom += dy;
	if (rect.right + dx > 0)
		rect.right += dx;

	pWnd->MoveWindow(&rect);
}


static void SlideWindow( CWnd *pWnd, int dx, int dy )
{
	CRect rect;
	CWnd *parent;

	pWnd->GetWindowRect(&rect);
	if (parent = pWnd->GetParent())
		parent->ScreenToClient(&rect);

	rect.top += dy;
	rect.left += dx;
	rect.bottom += dy;
	rect.right += dx;

	pWnd->MoveWindow(&rect, TRUE);
}


void CAddrBar::OnSize( UINT nType, int cx, int cy )
{
	CDialogBar::OnSize( nType, cx, cy );
	if ( cx && m_iWidth && ( cx != m_iWidth ) ) {
		CWnd *widget;
		CRect rect1 (0,0,0,0);
		int dx = cx - m_iWidth;

		widget = GetDlgItem(IDC_DIRSEARCH);
		if (widget) {
			SlideWindow(widget, dx, 0);
			widget->GetWindowRect(&rect1);
		}

		widget = GetDlgItem(IDC_ADDRNAME);
		if (widget) {
			CWnd *parent;
			CRect rect;

			widget->GetWindowRect(&rect);
			if (parent = widget->GetParent()) {
				parent->ScreenToClient(&rect1);
				parent->ScreenToClient(&rect);
				rect.right = rect1.left - 8;
			}
			widget->MoveWindow(&rect);
		}
		m_iWidth = cx;
	}
}

class CAddrFrame;

/////////////////////////////////////////////////////////////////////////////
// CAddrEntryList

class CAddrEntryList: public IMsgList {

	CAddrFrame *m_pAddrFrame;
	unsigned long m_ulRefCount;

public:
// IUnknown Interface
	STDMETHODIMP			QueryInterface(REFIID,LPVOID *);
	STDMETHODIMP_(ULONG)	AddRef(void);
	STDMETHODIMP_(ULONG)	Release(void);

// IMsgList Interface
	virtual void ListChangeStarting( MSG_Pane* pane, XP_Bool asynchronous,
									 MSG_NOTIFY_CODE notify, MSG_ViewIndex where,
									 int32 num);
	virtual void ListChangeFinished( MSG_Pane* pane, XP_Bool asynchronous,
									 MSG_NOTIFY_CODE notify, MSG_ViewIndex where,
									 int32 num);
	virtual void GetSelection( MSG_Pane* pane, MSG_ViewIndex **indices, int *count, 
							    int *focus);
	virtual void SelectItem( MSG_Pane* pane, int item );

	virtual void CopyMessagesInto( MSG_Pane *pane, MSG_ViewIndex *indices, int count,
								   MSG_FolderInfo *folderInfo) {}
	virtual void MoveMessagesInto( MSG_Pane *pane, MSG_ViewIndex *indices, int count,
								   MSG_FolderInfo *folderInfo) {}

	CAddrEntryList( CAddrFrame *pAddrFrame ) {
		m_ulRefCount = 0;
		m_pAddrFrame = pAddrFrame;
	}
};


STDMETHODIMP CAddrEntryList::QueryInterface(REFIID refiid, LPVOID * ppv)
{
	*ppv = NULL;
	if (IsEqualIID(refiid,IID_IUnknown))
   		*ppv = (LPUNKNOWN) this;
	else if (IsEqualIID(refiid,IID_IMsgList))
   		*ppv = (LPMSGLIST) this;
	else if (IsEqualIID(refiid,IID_IMailFrame))
		*ppv = (LPMAILFRAME) m_pAddrFrame;

	if (*ppv != NULL) {
   		AddRef();
		return NOERROR;
	}
            
	return ResultFromScode(E_NOINTERFACE);
}

STDMETHODIMP_(ULONG) CAddrEntryList::AddRef(void)
{
	return ++m_ulRefCount;
}

STDMETHODIMP_(ULONG) CAddrEntryList::Release(void)
{
	ULONG ulRef;
	ulRef = --m_ulRefCount;
	if (m_ulRefCount == 0) 
		delete this;   	
	return ulRef;   	
}

void CAddrEntryList::ListChangeStarting( MSG_Pane* pane, XP_Bool asynchronous,
									   MSG_NOTIFY_CODE notify, MSG_ViewIndex where,
									   int32 num)
{
	if (m_pAddrFrame) {
		m_pAddrFrame->ListChangeStarting( pane, asynchronous,
												 notify, where, num );
	}
}

void CAddrEntryList::ListChangeFinished( MSG_Pane* pane, XP_Bool asynchronous,
									   MSG_NOTIFY_CODE notify, MSG_ViewIndex where,
									   int32 num)
{
	if (m_pAddrFrame) {
		m_pAddrFrame->ListChangeFinished( pane, asynchronous,
												 notify, where, num );
	}
}

void CAddrEntryList::GetSelection( MSG_Pane* pane, MSG_ViewIndex **indices, int *count, 
							    int *focus)
{
}

void CAddrEntryList::SelectItem( MSG_Pane* pane, int item )
{
}

/////////////////////////////////////////////////////////////////////////////
// CAddrFrame

CAddrFrame *CAddrFrame::Open()
{
	if (!WFE_MSGCheckWizard())
		return NULL;

	if (!theApp.m_pAddressWindow)	//starts the address book window
	{
		CCreateContext context;
		context.m_pCurrentFrame = NULL;
		context.m_pCurrentDoc = NULL;
		context.m_pNewViewClass = NULL;
		context.m_pNewDocTemplate = NULL;

		theApp.m_pAddressWindow = new CAddrFrame();
		if(!theApp.m_pAddressWindow) return NULL;
		CCreateContext Context;
		Context.m_pCurrentFrame = NULL; //  nothing to base on
		Context.m_pCurrentDoc = NULL;  //  nothing to base on
		Context.m_pNewViewClass = NULL; // nothing to base on
		Context.m_pNewDocTemplate = NULL;   //  nothing to base on
		theApp.m_pAddressWindow->LoadFrame(IDR_ADDRESS_MENU, 
		WS_OVERLAPPEDWINDOW | FWS_ADDTOTITLE |WS_CLIPCHILDREN|WS_CLIPSIBLINGS, NULL, &Context);
	} 
	else
	{
		theApp.m_pAddressWindow->ActivateFrame();
	}	
	
	return theApp.m_pAddressWindow; 
}


CAddrFrame::CAddrFrame()
{
	CString msg;
	INTL_CharSetInfo csi = LO_GetDocumentCharacterSetInfo(GetContext());

	m_cxType = AddressCX;

	GetContext()->type = MWContextAddressBook;
	GetContext()->fancyFTP = TRUE;
	GetContext()->fancyNews = TRUE;
	GetContext()->intrupt = FALSE;
	GetContext()->reSize = FALSE;
	INTL_SetCSIWinCSID(csi, CIntlWin::GetSystemLocaleCsid());

	m_pOutliner = NULL;
	m_pOutlinerParent = NULL;
	m_addrBookPane = NULL;
	m_bSearching = FALSE;
	m_iProgress = 0;
	m_iWidth = 0;
	m_pSplitter = NULL;

	CAddrEntryList *pInstance = new CAddrEntryList( this );
	pInstance->QueryInterface( IID_IMsgList, (LPVOID *) &m_pIAddrList );
}


CAddrFrame::~CAddrFrame()
{
	if (m_pIAddrList)
		m_pIAddrList->Release();

	if (m_addrBookPane)
		HandleErrorReturn(AB_CloseAddressBookPane(&m_addrBookPane));

	theApp.m_pAddressWindow = NULL;
}

/////////////////////////////////////////////////////////////////////////////
// CAddrFrame Overloaded methods

BOOL CAddrFrame::PreCreateWindow(CREATESTRUCT& cs) 
{
	cs.hwndParent = NULL;

	cs.x = cs.y = 0;
	cs.cx = cs.cy = 300; // Arbitrary

	BOOL bRet = CGenericFrame::PreCreateWindow(cs);

#ifdef _WIN32
    cs.dwExStyle &= ~WS_EX_CLIENTEDGE;
#endif

	return bRet;
}


BOOL CAddrFrame::LoadFrame( UINT nIDResource, DWORD dwDefaultStyle, 
		CWnd* pParentWnd, CCreateContext* pContext)
{
	BOOL ret = CGenericFrame::LoadFrame(nIDResource, dwDefaultStyle, pParentWnd, pContext);

	if (ret) {

		WINDOWPLACEMENT wp;
		wp.length = sizeof(WINDOWPLACEMENT);
		GetWindowPlacement(&wp);

		if (wp.rcNormalPosition.left < 0 || wp.rcNormalPosition.top < 0) {
			SetWindowPos( NULL, 0 , 0, 0, 0, SWP_NOSIZE);
			GetWindowPlacement(&wp);
			SetWindowPos( NULL, abs (wp.rcNormalPosition.left) , abs (wp.rcNormalPosition.top),
				0, 0, SWP_SHOWWINDOW | SWP_NOSIZE);
		}
		else
			ShowWindow(SW_SHOW);
	}

	return ret;
}


BOOL CAddrFrame::OnCreateClient( LPCREATESTRUCT lpcs, CCreateContext* pContext )
{
	BOOL res = CGenericFrame::OnCreateClient(lpcs, pContext);
	if (res) {

		m_pSplitter = (CMailNewsSplitter *) RUNTIME_CLASS(CMailNewsSplitter)->CreateObject();

        ASSERT(m_pSplitter);

#ifdef _WIN32
		m_pSplitter->CreateEx(0, NULL, NULL,
								  WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS,
								  0,0,0,0, this->m_hWnd, (HMENU)AFX_IDW_PANE_FIRST, pContext );
#else
		m_pSplitter->Create( NULL, NULL,
								 WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS,
								 CRect(0,0,0,0), this, AFX_IDW_PANE_FIRST, pContext ); 
#endif
		        
		m_pOutlinerParent = new CAddrOutlinerParent;
#ifdef _WIN32
		m_pOutlinerParent->CreateEx(WS_EX_CLIENTEDGE, NULL, NULL,
								  WS_CHILD|WS_VISIBLE|WS_CLIPCHILDREN|WS_CLIPSIBLINGS,
								  0,0,0,0, m_pSplitter->m_hWnd, (HMENU) IDW_RESULTS_PANE, NULL );
#else
		m_pOutlinerParent->Create( NULL, NULL,
								 WS_BORDER|WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS,
								 CRect(0,0,0,0), m_pSplitter, IDW_RESULTS_PANE );
#endif

		m_pOutliner = (CAddrOutliner *) m_pOutlinerParent->m_pOutliner;
		m_pOutlinerParent->CreateColumns ( );
		m_pOutlinerParent->EnableFocusFrame(TRUE);
		m_pOutliner->SetContext( GetContext() );
		SetMainContext (this);
		SetActiveContext (this);

		m_pDirOutlinerParent = new CDirOutlinerParent;
#ifdef _WIN32
		m_pDirOutlinerParent->CreateEx(WS_EX_CLIENTEDGE, NULL, NULL,
								  WS_CHILD|WS_VISIBLE|WS_CLIPCHILDREN|WS_CLIPSIBLINGS,
								  0,0,0,0, m_pSplitter->m_hWnd, (HMENU) IDW_RESULTS_PANE, NULL );
#else
		m_pDirOutlinerParent->Create( NULL, NULL,
								 WS_BORDER|WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS,
								 CRect(0,0,0,0), m_pSplitter, IDW_RESULTS_PANE );
#endif

		m_pDirOutliner = (CDirOutliner *) m_pDirOutlinerParent->m_pOutliner;
		m_pDirOutlinerParent->CreateColumns ( );
		m_pDirOutlinerParent->EnableFocusFrame(TRUE);
		m_pDirOutliner->SetContext( GetContext() );

		int32 prefInt = -1;
		PREF_GetIntPref("mail.addr_book.sliderwidth", &prefInt);
		RECT rect;
		GetClientRect(&rect);
		m_pSplitter->AddPanes(m_pDirOutlinerParent, m_pOutlinerParent, prefInt, TRUE);
	}
	
	return res;
}


BOOL CAddrFrame::PreTranslateMessage( MSG* pMsg )
{
	if (pMsg->message == WM_KEYDOWN)
	{
        if (pMsg->wParam == VK_DELETE)
        {
            if (GetFocus() == m_barAddr.GetDlgItem(IDC_ADDRNAME)) {
				return FALSE;
			}
        }

		if (pMsg->wParam == VK_TAB) {
			HWND hwndNext = NULL;
			HWND hwndFocus = ::GetFocus();

			HWND hwndDirOutliner = m_pDirOutliner ? m_pDirOutliner->m_hWnd : NULL;
			HWND hwndOutliner = m_pOutliner ? m_pOutliner->m_hWnd : NULL;
	
			HWND hwndAddrBarFirst = ::GetNextDlgTabItem( m_barAddr.m_hWnd, NULL, FALSE );

			HWND hwndAddrBarLast = ::GetNextDlgTabItem( m_barAddr.m_hWnd, hwndAddrBarFirst, TRUE );

			if ( GetKeyState(VK_SHIFT) & 0x8000 ) {

				// Tab backward
				if ( hwndFocus == hwndAddrBarFirst ) {
					// Handle tabbing into outliner
					hwndNext = hwndOutliner;
				} else if (hwndFocus == hwndOutliner) {
					// Handle tabbing out of outliner into the directory list
					if (m_pSplitter->IsOnePaneClosed())
						hwndNext = hwndAddrBarLast;
					else
						hwndNext = hwndDirOutliner;
				} else if ( hwndFocus == hwndDirOutliner ) {
					// Handle tabbing into the outliner
					hwndNext = hwndAddrBarLast;
				}

			} else {

				// Tab forward
				if (hwndFocus == hwndOutliner) {
					// Handle tabbing out of outliner
					hwndNext = hwndAddrBarFirst;
				} else if ( hwndFocus == hwndAddrBarLast ) {
					// handle tabbing into the directory list
					if (m_pSplitter->IsOnePaneClosed())
						hwndNext = hwndOutliner;
					else
						hwndNext = hwndDirOutliner;
				} else if (hwndFocus == hwndDirOutliner) {
					// Handle tabbing out of the directory list
					hwndNext = hwndOutliner;
				}

			}
			if ( hwndNext ) {
				::SetFocus( hwndNext );
				return TRUE;
			}
		} // if tab
	} // if keydown
	return CGenericFrame::PreTranslateMessage(pMsg);
}


void CAddrFrame::OnHelpMenu()
{
	NetHelp(HELP_ADDRESS_BOOK);
}


void CAddrFrame::Progress(MWContext *pContext, const char *pMessage)
{
	LPNSSTATUSBAR pIStatusBar = NULL;
	m_pChrome->QueryInterface( IID_INSStatusBar, (LPVOID *) &pIStatusBar );
	if ( pIStatusBar ) {
		pIStatusBar->SetStatusText(pMessage);
		pIStatusBar->Release();
	}
}


void CAddrFrame::SetProgressBarPercent(MWContext *pContext, int32 lPercent)
{
	lPercent = lPercent < 0 ? 0 : ( lPercent > 100 ? 100 : lPercent );

	if ( m_iProgress == lPercent ) {
		return;
	}

	m_iProgress = lPercent;
	if (GetChrome()) {
		LPNSSTATUSBAR pIStatusBar = NULL;
		GetChrome()->QueryInterface( IID_INSStatusBar, (LPVOID *) &pIStatusBar );
		if ( pIStatusBar ) {
			pIStatusBar->SetProgress( CASTINT(lPercent) );
			pIStatusBar->Release();
		}
	}
} 


STDMETHODIMP CAddrFrame::QueryInterface(REFIID refiid, LPVOID * ppv)
{
	*ppv = NULL;
	if (IsEqualIID(refiid,IID_IUnknown))
   		*ppv = (LPUNKNOWN) (LPMSGLIST) m_pIAddrList;
	else if (IsEqualIID(refiid,IID_IMailFrame))
		*ppv = (LPMAILFRAME) this;
	else if (IsEqualIID(refiid,IID_IMsgList))
   		*ppv = (LPMSGLIST) m_pIAddrList;

	if (*ppv != NULL) {
   		AddRef();
		return NOERROR;
	}
            
	return ResultFromScode(E_NOINTERFACE);
}

STDMETHODIMP_(ULONG) CAddrFrame::AddRef(void)
{
	return 0; // Not a real component
}

STDMETHODIMP_(ULONG) CAddrFrame::Release(void)
{
	return 0; // Not a real component
}

// IMailFrame interface
CMailNewsFrame *CAddrFrame::GetMailNewsFrame()
{
	return (CMailNewsFrame *) NULL; 
}

MSG_Pane *CAddrFrame::GetPane()
{
	return (MSG_Pane*) m_addrBookPane;
}

void CAddrFrame::PaneChanged(MSG_Pane *pane, XP_Bool asynchronous, 
								 MSG_PANE_CHANGED_NOTIFY_CODE notify, int32 value)
{
	if (notify == MSG_PaneDirectoriesChanged) {
		// stop an ldap search if we need to 
		if (m_bSearching) 
			OnStopSearch();
		UpdateDirectories();
	}
}


#ifdef FEATURE_ADDRESS_BOOK
#include "addrfrm.i00"
#endif

/////////////////////////////////////////////////////////////////////////////
// CAddrFrame message handlers

BEGIN_MESSAGE_MAP(CAddrFrame, CGenericFrame)
	//{{AFX_MSG_MAP(CAddrFrame)
	ON_WM_CREATE()
	ON_WM_CLOSE()
	ON_WM_SHOWWINDOW( )
	ON_WM_DESTROY()
	ON_WM_GETMINMAXINFO()
	ON_UPDATE_COMMAND_UI(ID_VIEW_ABTOOLBAR, OnUpdateViewCommandToolbar)
	ON_COMMAND(ID_VIEW_ABTOOLBAR, OnViewCommandToolbar)
	ON_UPDATE_COMMAND_UI(ID_TOOLS_ADDRESSBOOK, OnUpdateShowAddressBookWindow)
	ON_UPDATE_COMMAND_UI(IDS_SECURITY_STATUS, OnUpdateSecureStatus)
	ON_COMMAND(ID_FILE_IMPORT, OnImportFile)
	ON_UPDATE_COMMAND_UI( ID_FILE_IMPORT, OnUpdateImport )
	ON_COMMAND(ID_FILE_SAVEAS, OnExportFile)
	ON_UPDATE_COMMAND_UI( ID_FILE_SAVEAS, OnUpdateExport )
	ON_COMMAND(ID_FILE_CLOSE, OnFileClose)
	ON_UPDATE_COMMAND_UI( IDC_DIRSEARCH, OnUpdateSearch )
	ON_COMMAND(IDC_DIRSEARCH, OnExtDirectorySearch)
	ON_COMMAND(ID_NAVIGATE_INTERRUPT, OnStopSearch)
	ON_UPDATE_COMMAND_UI(ID_NAVIGATE_INTERRUPT, OnUpdateStopSearch)
	ON_COMMAND(ID_FILE_NEWMESSAGE, OnComposeMsg)
	ON_UPDATE_COMMAND_UI(ID_FILE_NEWMESSAGE, OnUpdateComposeMsg)
	ON_COMMAND(ID_LIVE_CALL, OnCall)
	ON_UPDATE_COMMAND_UI(ID_LIVE_CALL, OnUpdateCall)
	ON_COMMAND(ID_ITEM_ADDUSER, OnAddUser)
	ON_UPDATE_COMMAND_UI(ID_ITEM_ADDUSER, OnUpdateAddUser)
	ON_COMMAND(ID_FILE_NEWAB, OnAddAB)
	ON_UPDATE_COMMAND_UI(ID_FILE_NEWAB, OnUpdateAddAB)
	ON_COMMAND(ID_FILE_NEWDIR, OnAddDir)
	ON_UPDATE_COMMAND_UI(ID_FILE_NEWDIR, OnUpdateAddDir)
	ON_COMMAND(ID_EDIT_DOMAINS, OnHTMLDomains)
	ON_UPDATE_COMMAND_UI(ID_EDIT_DOMAINS, OnUpdateHTMLDomains)
	ON_COMMAND(ID_ITEM_ADDLIST, OnAddList)
	ON_UPDATE_COMMAND_UI(ID_ITEM_ADDLIST, OnUpdateAddList)
	ON_COMMAND(ID_SWITCH_SORT, OnSwitchSortFirstLast)
	ON_UPDATE_COMMAND_UI(ID_SWITCH_SORT, OnUpdateSwitchSort)
	ON_COMMAND(ID_EDIT_DELETE, OnDeleteItem)
	ON_UPDATE_COMMAND_UI(ID_EDIT_DELETE, OnUpdateDeleteItem)
	ON_COMMAND(ID_EDIT_UNDO, OnUndo)
	ON_UPDATE_COMMAND_UI(ID_EDIT_UNDO, OnUpdateUndo)
	ON_COMMAND(ID_EDIT_REDO, OnRedo)
	ON_UPDATE_COMMAND_UI(ID_EDIT_REDO, OnUpdateRedo)
	ON_COMMAND(ID_ITEM_PROPERTIES, OnItemProperties)
	ON_UPDATE_COMMAND_UI(ID_ITEM_PROPERTIES, OnUpdateItemProperties)
	ON_COMMAND(ID_SORT_TYPE, OnSortType)
	ON_UPDATE_COMMAND_UI(ID_SORT_TYPE, OnUpdateSortType)
	ON_COMMAND(ID_SORT_NAME, OnSortName)
	ON_UPDATE_COMMAND_UI(ID_SORT_NAME, OnUpdateSortName)
	ON_COMMAND(ID_SORT_NICKNAME, OnSortNickName)
	ON_UPDATE_COMMAND_UI(ID_SORT_NICKNAME, OnUpdateSortNickName)
	ON_COMMAND(ID_SORT_EMAILADDRESS, OnSortEmailAddress)
	ON_UPDATE_COMMAND_UI(ID_SORT_EMAILADDRESS, OnUpdateSortEmailAddress)
	ON_COMMAND(ID_SORT_COMPANY, OnSortCompany)
	ON_UPDATE_COMMAND_UI(ID_SORT_COMPANY, OnUpdateSortCompany)
	ON_COMMAND(ID_SORT_LOCALITY, OnSortLocality)
	ON_UPDATE_COMMAND_UI(ID_SORT_LOCALITY, OnUpdateSortLocality)
	ON_COMMAND(ID_ASCENDING, OnSortAscending)
	ON_UPDATE_COMMAND_UI(ID_ASCENDING, OnUpdateSortAscending)
	ON_COMMAND(ID_DECENDING, OnSortDescending)
	ON_UPDATE_COMMAND_UI(ID_DECENDING, OnUpdateSortDescending)
	ON_COMMAND(ID_CREATE_CARD, OnCreateCard)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

int CAddrFrame::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	void	WFE_AddNewFrameToFrameList(CGenericFrame * pFrame);
	int res = CGenericFrame::OnCreate(lpCreateStruct);

	unsigned long sortby;
	int32 prefInt;
	PREF_GetIntPref("mail.addr_book.sortby",&prefInt);
	switch (prefInt) {
	case ID_COLADDR_TYPE:
	case ID_COLADDR_COMPANY:
	case ID_COLADDR_LOCALITY:
		sortby = ABFullName;
		break;
	case ID_COLADDR_NAME:
		sortby = ABFullName;
		break;
	case ID_COLADDR_EMAIL:
		sortby = ABEmailAddress;
		break;
	case ID_COLADDR_NICKNAME:
		sortby = ABNickname;
		break;
	default:
		sortby = ABFullName;
		break;
	}

	int result = 0;

	DIR_Server* dir = (DIR_Server*)XP_ListGetObjectNum(theApp.m_directories, 1);

	XP_ASSERT (dir);

	if (!dir)
		return -1;

	XP_Bool prefBool;
	PREF_GetBoolPref("mail.addr_book.sort_ascending",&prefBool);

	HandleErrorReturn((result = AB_CreateAddressBookPane(&m_addrBookPane,
			GetContext(),
			WFE_MSGGetMaster())));

	if (result)
		return -1;

	HandleErrorReturn((result = AB_InitializeAddressBookPane(m_addrBookPane,
								dir,
								theApp.m_pABook,
								sortby,
								prefBool)));
	if (result)
		return -1;

	//I'm hardcoding because I don't want this translated
	GetChrome()->CreateCustomizableToolbar("Address_Book"/*ID_ADDRESS_BOOK*/, 3, TRUE);
	CButtonToolbarWindow *pWindow;
	BOOL bOpen, bShowing;

	int32 nPos;

	//I'm hardcoding because I don't want this translated
	GetChrome()->LoadToolbarConfiguration(ID_ADDRESS_BOOK_TOOLBAR, CString("Address_Book_Toolbar"), nPos, bOpen, bShowing);

	LPNSTOOLBAR pIToolBar = NULL;
	GetChrome()->QueryInterface( IID_INSToolBar, (LPVOID *) &pIToolBar );
	if ( pIToolBar ) {
		pIToolBar->Create( this, WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE | CBRS_TOP | WS_BORDER);
		pIToolBar->SetButtons( AddrCodes, sizeof(AddrCodes)/sizeof(UINT) );
		pIToolBar->SetSizes( CSize( 30, 27 ), CSize( 23, 21 ) );
		pIToolBar->LoadBitmap( MAKEINTRESOURCE( IDB_ADDRESSTOOLBARP ) );
		pIToolBar->SetToolbarStyle( theApp.m_pToolbarStyle );
		pWindow = new CButtonToolbarWindow(CWnd::FromHandlePermanent(pIToolBar->GetHWnd()), theApp.m_pToolbarStyle, 43, 27, eLARGE_HTAB);
		GetChrome()->GetCustomizableToolbar()->AddNewWindow(ID_ADDRESS_BOOK_TOOLBAR, pWindow,nPos, 50, 37, 0, CString(szLoadString(ID_ADDRESS_BOOK_TOOLBAR)),theApp.m_pToolbarStyle, bOpen, FALSE);
		GetChrome()->ShowToolbar(ID_ADDRESS_BOOK_TOOLBAR, bShowing);
#ifdef XP_WIN16
		GetChrome()->GetCustomizableToolbar()->SetBottomBorder(TRUE);
#endif

		pIToolBar->Release();
	}

	LPNSSTATUSBAR pIStatusBar = NULL;
	GetChrome()->QueryInterface( IID_INSStatusBar, (LPVOID *) &pIStatusBar );
	if ( pIStatusBar ) {
		pIStatusBar->Create( this );
		pIStatusBar->Release();
	}


	m_barAddr.Create( this, IDD_ADDRESSBOOK, CBRS_TOP, 1 );

	// Initially size window to only dialog + title bar.
	int BorderX = GetSystemMetrics(SM_CXFRAME);

	CRect rect;
	m_barAddr.GetWindowRect(rect);
#ifdef _WIN32
	CSize size = m_barAddr.CalcFixedLayout(FALSE, FALSE);
#else
	CSize size = m_barAddr.m_sizeDefault;
#endif

	// Figure height of title bar + bottom border
	m_iWidth = size.cx;

	int16 iLeft,iRight,iTop,iBottom;
	PREF_GetRectPref("mail.addr_book_window_rect", &iLeft, &iTop, &iRight, &iBottom);
	int screenY = ::GetSystemMetrics(SM_CYFULLSCREEN);
	int screenX = ::GetSystemMetrics(SM_CXFULLSCREEN);

	if ((iLeft >= 0) && (iTop >= 0) && (iRight < screenX) && (iBottom < screenY))
	{
		if (iRight - iLeft > m_iWidth)
			size.cx = iRight - iLeft;
		size.cy = iBottom - iTop;
		SetWindowPos( NULL, iLeft, iTop, size.cx, size.cy,
				  SWP_HIDEWINDOW);
	}
	else {
		size.cy = 300;
		SetWindowPos( NULL, 0, 0, size.cx, size.cy,
				  SWP_HIDEWINDOW);

	}

	m_barAddr.UpdateDirectories();
	m_pOutliner->SetPane(m_addrBookPane);
	m_pDirOutliner->SetPane(m_addrBookPane);
	MSG_SetFEData( (MSG_Pane*) m_addrBookPane, (void *) m_pIAddrList );

	WFE_AddNewFrameToFrameList(this);

	CFrameWnd::RecalcLayout();

	if (m_barAddr.m_pFont)
		::SendMessage(::GetDlgItem(m_barAddr.GetSafeHwnd(), IDC_ADDRNAME),
					  WM_SETFONT, (WPARAM)m_barAddr.m_pFont, FALSE);
	if (m_barAddr.m_bRemoveLDAPDir)
		m_barAddr.GetDlgItem(IDC_DIRSEARCH)->ShowWindow(SW_HIDE);
	m_barAddr.GetDlgItem(IDC_ADDRNAME)->SetFocus();

	return res;
}

void CAddrFrame::UpdateDirectories ( void )
{
	m_barAddr.SetDirectoryIndex(0);
	m_barAddr.OnChangeDirectory();
    m_barAddr.UpdateDirectories();
	m_pDirOutliner->UpdateCount();
}

void CAddrFrame::OnFileClose ( void )
{
    PostMessage ( WM_CLOSE );
}

void CAddrFrame::OnViewCommandToolbar()
{
	GetChrome()->ShowToolbar(ID_ADDRESS_BOOK_TOOLBAR, !GetChrome()->GetToolbarVisible(ID_ADDRESS_BOOK_TOOLBAR));
}

void CAddrFrame::OnUpdateViewCommandToolbar(CCmdUI *pCmdUI)
{
	BOOL bShow = GetChrome()->GetToolbarVisible(ID_ADDRESS_BOOK_TOOLBAR);
    if( pCmdUI->m_pMenu ){
        pCmdUI->m_pMenu->ModifyMenu(CASTUINT(ID_VIEW_ABTOOLBAR), CASTUINT(MF_BYCOMMAND | MF_STRING), CASTUINT(ID_VIEW_ABTOOLBAR),
                                    szLoadString(CASTUINT(bShow ? IDS_HIDE_ABTOOLBAR : IDS_SHOW_ABTOOLBAR)) );
    } else {
        pCmdUI->SetCheck(bShow);
    }
}

void CAddrFrame::OnGetMinMaxInfo( MINMAXINFO FAR* lpMMI )
{
	CGenericFrame::OnGetMinMaxInfo( lpMMI );

	if (m_iWidth) {
		lpMMI->ptMinTrackSize.x = m_iWidth;
	}
}


void CAddrFrame::OnDestroy()
{
	// DestroyContext will call Interrupt, but if we wait until after DestroyContext
	// to call MSG_SearchFree, the MWContext will be gone, and we'll be reading freed memory
	if (XP_IsContextBusy (GetContext()))
		XP_InterruptContext (GetContext());

	if (m_addrBookPane)
		MSG_SearchFree ((MSG_Pane*) m_addrBookPane);

 	CGenericFrame::OnDestroy();

	if(!IsDestroyed()) {
		DestroyContext();
	}
}


void CAddrFrame::OnClose()
{
	CRect rect;
    WINDOWPLACEMENT wp;
	int i;
    wp.length = sizeof(WINDOWPLACEMENT);
    GetWindowPlacement(&wp);

	ASSERT(theApp.m_pAddressWindow == this);
                  
	if ( !IsIconic() && !IsZoomed() )
	{
		GetWindowRect ( &rect );
		PREF_SetRectPref("mail.addr_book_window_rect", 
			(int16) rect.left, (int16) rect.top, (int16) rect.right, (int16) rect.bottom);
	}
    
	PREF_SetIntPref("mail.wfe.addr_book.show_value",(int)wp.showCmd);
	PREF_SetIntPref("mail.addr_book.sliderwidth", m_pSplitter->GetPaneSize());

	// we should prompt if changes aren't saved
	// MW fix
	for (i = 0; i < m_listPropList.GetSize(); i++) {
		((CWnd*) m_listPropList.GetAt(i))->DestroyWindow();
	}

	for (i = 0; i < m_userPropList.GetSize(); i++) {
		((CWnd*) m_userPropList.GetAt(i))->DestroyWindow();
	}

	//I'm hardcoding because I don't want this translated
	GetChrome()->SaveToolbarConfiguration(ID_ADDRESS_BOOK_TOOLBAR, CString("Address_Book_Toolbar"));

	CGenericFrame::OnClose();
}



void CAddrFrame::ListChangeStarting( MSG_Pane* pane, XP_Bool asynchronous,
										MSG_NOTIFY_CODE notify, MSG_ViewIndex where,
										int32 num)
{
	if ( pane == (MSG_Pane*) m_addrBookPane ) {
		if ( m_pOutliner ) {
			m_pOutliner->MysticStuffStarting( asynchronous, notify,
												   where, num );
		}
	}
}

void CAddrFrame::ListChangeFinished( MSG_Pane* pane, XP_Bool asynchronous,
										MSG_NOTIFY_CODE notify, MSG_ViewIndex where,
										int32 num)
{
	if ( pane == (MSG_Pane*) m_addrBookPane ) {
		if ( m_pOutliner ) {
			m_pOutliner->MysticStuffFinishing( asynchronous, notify,
												    where, num );
		}
	}
}


void CAddrFrame::SetSearchResults(MSG_ViewIndex index, int32 num)
{

	CString csStatus;

	ASSERT(m_pOutliner);
	AB_LDAPSearchResults(m_addrBookPane, index, num);
	if (num > 1) {
		csStatus.Format( szLoadString(IDS_SEARCHHITS), num );
	} else if ( num > 0 ) {
		csStatus.LoadString( IDS_SEARCHONEHIT );
	} else {
		csStatus.LoadString( IDS_SEARCHNOHITS );
	}

	if (GetChrome()) {
		LPNSSTATUSBAR pIStatusBar = NULL;
		GetChrome()->QueryInterface( IID_INSStatusBar, (LPVOID *) &pIStatusBar );
		if ( pIStatusBar ) {
			pIStatusBar->SetStatusText(csStatus);
			pIStatusBar->Release();
		}
	}
}


void CAddrFrame::AllConnectionsComplete( MWContext *pContext )
{
	CStubsCX::AllConnectionsComplete( pContext );

	if (m_bSearching) {

		OnStopSearch();

		int32 total = m_pOutliner->GetTotalLines();
		CString csStatus;
		if ( total > 1 ) {
			csStatus.Format( szLoadString( IDS_SEARCHHITS ), total );
		} else if ( total > 0 ) {
			csStatus.LoadString( IDS_SEARCHONEHIT );
		} else {
			csStatus.LoadString( IDS_SEARCHNOHITS );
			CString s;
			if (s.LoadString( IDS_BOOKMARK_ADDRESSPROPERTIES ))
				MessageBox(csStatus, s, MB_OK | MB_APPLMODAL);
		}

		LPNSSTATUSBAR pIStatusBar = NULL;
		m_pChrome->QueryInterface( IID_INSStatusBar, (LPVOID *) &pIStatusBar );
		if ( pIStatusBar ) {
			pIStatusBar->SetStatusText( csStatus );
			pIStatusBar->SetProgress( 0 );
			pIStatusBar->Release();
		}
	
		SendMessageToDescendants(WM_IDLEUPDATECMDUI, (WPARAM)TRUE, (LPARAM)0);
	}
}

void CAddrFrame::Close()
{
	if (theApp.m_pAddressWindow) {
		theApp.m_pAddressWindow->PostMessage(WM_CLOSE);
	}       
}

void CAddrFrame::OnImportFile()
{
	HandleErrorReturn(AB_ImportFromFile(m_addrBookPane, GetContext()), this);
}

void CAddrFrame::OnExportFile()
{
	HandleErrorReturn(AB_ExportToFile(m_addrBookPane, GetContext()), this);
}


void CAddrFrame::OnTypedown (char* name)
{
	DIR_Server* dir = GetCurrentDirectoryServer();

	if (dir->dirType == LDAPDirectory)	{
		OnDirectoryList(name);
	}
	else
		m_pOutliner->OnTypedown (name);
}


void CAddrFrame::DoUpdateAddressBook( CCmdUI* pCmdUI, AB_CommandType cmd, BOOL bUseCheck )
{
	if(!pCmdUI)
        return;

    XP_Bool bSelectable = FALSE, bPlural = FALSE;
    MSG_COMMAND_CHECK_STATE sState;

	if (m_addrBookPane) {
		if (m_pOutliner) {
			MSG_ViewIndex *indices;
			int count;
			m_pOutliner->GetSelection(indices, count);
			AB_CommandStatus(m_addrBookPane,
							  cmd,
							  indices, count,
							  &bSelectable,
							  &sState,
							  NULL,
							  &bPlural);
		} else {
			AB_CommandStatus(m_addrBookPane,
							  cmd,
							  NULL, 0,
							  &bSelectable,
							  &sState,
							  NULL,
							  &bPlural);
		}
	}
    pCmdUI->Enable(bSelectable);
    if (bUseCheck)
        pCmdUI->SetCheck(sState == MSG_Checked);
    else
        pCmdUI->SetRadio(sState == MSG_Checked);
}


void CAddrFrame::OnExtDirectorySearch()
{
	m_barAddr.OnExtDirectorySearch();
}

void CAddrFrame::OnUpdateShowAddressBookWindow( CCmdUI *pCmdUI )
{
	pCmdUI->Enable(FALSE);
}

void CAddrFrame::OnUpdateSecureStatus(CCmdUI *pCmdUI)
{
	DIR_Server* dir = GetCurrentDirectoryServer();

	if (dir->isSecure)
		pCmdUI->Enable(TRUE);
	else
		pCmdUI->Enable(FALSE);
}


void CAddrFrame::OnUpdateSearch( CCmdUI *pCmdUI )
{
	DoUpdateAddressBook(pCmdUI, AB_LDAPSearchCmd, TRUE);
}


void CAddrFrame::OnUpdateImport(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_ImportCmd, TRUE);
}

void CAddrFrame::OnUpdateExport(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_SaveCmd, TRUE);
}

void CAddrFrame::OnUpdateSortType(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_SortByTypeCmd, TRUE);
}

void CAddrFrame::OnUpdateSortName(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_SortByFullNameCmd, TRUE);
}

void CAddrFrame::OnUpdateSortNickName(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_SortByNickname, TRUE);
}

void CAddrFrame::OnUpdateSortEmailAddress(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_SortByEmailAddress, TRUE);
}

void CAddrFrame::OnUpdateSortCompany(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_SortByCompanyName, TRUE);
}

void CAddrFrame::OnUpdateSortLocality(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_SortByLocality, TRUE);
}

void CAddrFrame::OnUpdateSortAscending(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_SortAscending, TRUE);
}

void CAddrFrame::OnUpdateSortDescending(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_SortDescending, TRUE);
}

void CAddrFrame::OnUpdateComposeMsg(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_NewMessageCmd);
}

void CAddrFrame::OnUpdateStopSearch(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_LDAPSearchCmd);
}

void CAddrFrame::OnUpdateAddUser(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_AddUserCmd);
}

void CAddrFrame::OnUpdateAddList(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_AddMailingListCmd);
}

void CAddrFrame::OnUpdateAddAB(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_NewAddressBook);
}

void CAddrFrame::OnUpdateAddDir(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_NewLDAPDirectory);
}

void CAddrFrame::OnUpdateItemProperties(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_PropertiesCmd);
}

void CAddrFrame::OnUpdateCall(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_CallCmd);
}

void CAddrFrame::OnUpdateSwitchSort(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_AddUserCmd);
}

void CAddrFrame::OnUpdateDeleteItem(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_DeleteCmd);
}

void CAddrFrame::OnUpdateUndo(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_UndoCmd);
}

void CAddrFrame::OnUpdateRedo(CCmdUI* pCmdUI)
{
    DoUpdateAddressBook(pCmdUI, AB_RedoCmd);
}

void CAddrFrame::OnSwitchSortFirstLast()
{
	SetCursor ( theApp.LoadStandardCursor ( IDC_WAIT ) );

	AB_SetSortByFirstName(theApp.m_pABook, !AB_GetSortByFirstName(theApp.m_pABook));

	SetCursor ( theApp.LoadStandardCursor ( IDC_ARROW ) );
}


void CAddrFrame::OnAddUser ( void )
{	
#ifdef FEATURE_ADDRPROP
	CAddrEditProperties* prop;
	prop = new CAddrEditProperties (this,
	GetCurrentDirectoryServer(),
	XP_GetString (MK_ADDR_NEW_CARD), this, 0, NULL, GetContext());

	prop->SetCurrentPage(0);
	if (prop->Create(this, WS_SYSMENU | WS_POPUP | WS_CAPTION | WS_VISIBLE,
		WS_EX_DLGMODALFRAME)) {
		m_userPropList.Add (prop);	
	} 
#endif
}

void CAddrFrame::OnAddAB ( void )
{
	HandleErrorReturn(AB_Command (m_addrBookPane, AB_NewAddressBook, 0, 0), this);
}


void CAddrFrame::OnAddDir ( void )
{
#ifdef FEATURE_ADDRPROP
	CString label;
	label.LoadString(IDS_ADD_LDAP_SERVER);
	CAddrLDAPProperties serverProperties(this, GetContext(), NULL, label);
	if (IDOK == serverProperties.DoModal())
	{
		DIR_Server* pServer = &serverProperties.m_serverInfo;
		DIR_Server *pNewServer = (DIR_Server *) XP_ALLOC(sizeof(DIR_Server));
		if (pNewServer)
		{
			DIR_InitServer(pNewServer);
			DIR_CopyServer(pServer, &pNewServer);
			if (pNewServer->dirType == LDAPDirectory) {
				DIR_SetServerFileName(pNewServer, pNewServer->serverName);
			}
		}
		XP_ListAddObjectToEnd(theApp.m_directories, pNewServer);
	   	DIR_SaveServerPreferences (theApp.m_directories); 
	}
#endif
}


void CAddrFrame::OnHTMLDomains ( void )
{
	MSG_DisplayHTMLDomainsDialog(GetContext());
}

void CAddrFrame::OnUpdateHTMLDomains( CCmdUI *pCmdUI )
{
	pCmdUI->Enable( TRUE );
}

void CAddrFrame::OnCreateCard ( void )
{
#ifdef FEATURE_ADDRPROP
	CAddrEditProperties* prop;
	char* email = NULL;
	char* name = NULL;
	DIR_Server* pab  = NULL;
	PersonEntry person;
	person.Initialize();
	ABID entryID = MSG_MESSAGEIDNONE;
	INTL_CharSetInfo csi = LO_GetDocumentCharacterSetInfo(GetContext());

	if (FE_UsersMailAddress())
		email = XP_STRDUP (FE_UsersMailAddress());
	if (FE_UsersFullName())
		name = XP_STRDUP (FE_UsersFullName());
	person.pGivenName = name;
	person.pEmailAddress = email;
	person.WinCSID = INTL_GetCSIWinCSID(csi);

	DIR_GetPersonalAddressBook (theApp.m_directories, &pab);
	XP_ASSERT (pab);

	if (pab) {

		AB_GetEntryIDForPerson(pab,
			theApp.m_pABook, &entryID, &person);

		if (entryID != MSG_MESSAGEIDNONE) {
			// see it it is already opened 
			if (m_userPropList.GetSize()) { 
				// try to find it
				for (int i = 0; i < m_userPropList.GetSize(); i++) {
					if (((CAddrEditProperties*)m_userPropList.GetAt(i))->GetEntryID() == entryID) {
						((CAddrEditProperties*)m_userPropList.GetAt(i))->BringWindowToTop();
						return;
					}
				}			
			}

			// otherwise open the window
			CString formattedString;
			char fullname [kMaxFullNameLength];
			AB_GetFullName(pab, theApp.m_pABook, entryID, fullname);
			formattedString.Format(XP_GetString (MK_ADDR_BOOK_CARD), fullname);
			prop = new CAddrEditProperties(this,
				pab, (const char *) formattedString, this, entryID, NULL, GetContext());

			prop->SetCurrentPage(0);
			if (prop->Create(this, WS_SYSMENU | WS_POPUP | WS_CAPTION | WS_VISIBLE,
				WS_EX_DLGMODALFRAME)) {
				m_userPropList.Add (prop);	
			}
		}
		else {
			CString formattedString;
			formattedString.Format(XP_GetString (MK_ADDR_BOOK_CARD), name);
			prop = new CAddrEditProperties (this,
				pab, formattedString, this, 0, &person, GetContext());
			prop->SetCurrentPage(0);
			if (prop->Create(this, WS_SYSMENU | WS_POPUP | WS_CAPTION | WS_VISIBLE,
					WS_EX_DLGMODALFRAME)) {
				m_userPropList.Add (prop);	
			}
		}
	}
	if (email)
		XP_FREE (email);
	if (name)
		XP_FREE (name);
#endif
}


DIR_Server * CAddrFrame::GetCurrentDirectoryServer()
{
	return (DIR_Server*)XP_ListGetObjectNum(theApp.m_directories, m_pOutliner->GetDirectoryIndex() + 1);
}

void CAddrFrame::OnAddList ( void )
{
	CABMLDialog* dialog;

	dialog = new CABMLDialog (GetCurrentDirectoryServer(),
		this, 0, GetContext());

	if (dialog->Create(this)) {
		m_listPropList.Add (dialog);	
	}  
}


void CAddrFrame::OnDeleteItem()
{
#ifdef FEATURE_ADDRPROP
	MSG_ViewIndex *indices;
	int count;
	m_pOutliner->GetSelection(indices, count);
	for (int i = 0; i < count; i++)
	{
		ABID type;
		ABID entryID;
		// check the entry type and add/remove pages
		entryID  = AB_GetEntryIDAt((AddressPane*)m_addrBookPane, indices[i]);

		AB_GetType(GetCurrentDirectoryServer(), theApp.m_pABook, 
			entryID, &type);
		if (m_userPropList.GetSize() && type == ABTypePerson) { 
			// try to find 
			for (int i = 0; i < m_userPropList.GetSize(); i++) {
				if (((CAddrEditProperties*)m_userPropList.GetAt(i))->GetEntryID() == entryID) {
					((CAddrEditProperties*)m_userPropList.GetAt(i))->DestroyWindow();
				}
			}			
		}

		if (m_listPropList.GetSize() && type == ABTypeList) { 
			for (int i = 0; i < m_listPropList.GetSize(); i++) {
				if (((CABMLDialog*)m_listPropList.GetAt(i))->GetEntryID() == entryID) {
					((CABMLDialog*)m_listPropList.GetAt(i))->DestroyWindow();
				}
			}			
		}
	}

	SetCursor ( theApp.LoadStandardCursor ( IDC_WAIT ) );

	HandleErrorReturn(AB_Command (m_addrBookPane, AB_DeleteCmd, indices, count), this);
	m_pOutliner->UpdateCount();
	if ((m_pOutliner->GetFocusLine() > m_pOutliner->GetTotalLines() - 1))
		m_pOutliner->SelectItem(m_pOutliner->GetTotalLines() - 1);
	else
		m_pOutliner->SelectItem(m_pOutliner->GetFocusLine());
	SetCursor ( theApp.LoadStandardCursor ( IDC_ARROW ) );
#endif
}


void CAddrFrame::OnUndo()
{
	SetCursor ( theApp.LoadStandardCursor ( IDC_WAIT ) );
	HandleErrorReturn(AB_Command (m_addrBookPane, AB_UndoCmd, 0, 0), this);
	m_pOutliner->UpdateCount();
	if ((m_pOutliner->GetFocusLine() > m_pOutliner->GetTotalLines() - 1))
		m_pOutliner->SelectItem(m_pOutliner->GetTotalLines() - 1);
	else
		m_pOutliner->SelectItem(m_pOutliner->GetFocusLine());
	SetCursor ( theApp.LoadStandardCursor ( IDC_ARROW ) );
}


void CAddrFrame::OnRedo()
{
	SetCursor ( theApp.LoadStandardCursor ( IDC_WAIT ) );
	HandleErrorReturn(AB_Command (m_addrBookPane, AB_RedoCmd, 0, 0), this);
	m_pOutliner->UpdateCount();
	if ((m_pOutliner->GetFocusLine() > m_pOutliner->GetTotalLines() - 1))
		m_pOutliner->SelectItem(m_pOutliner->GetTotalLines() - 1);
	else
		m_pOutliner->SelectItem(m_pOutliner->GetFocusLine());
	SetCursor ( theApp.LoadStandardCursor ( IDC_ARROW ) );
}

void CAddrFrame::OnComposeMsg()
{
	MSG_ViewIndex *indices;
	int count;
	m_pOutliner->GetSelection(indices, count);
	HandleErrorReturn(AB_Command (m_addrBookPane, AB_NewMessageCmd, indices, count), this);
}


void CAddrFrame::CloseUserProperties (CAddrEditProperties* wnd, ABID entryID) 
{
#ifdef FEATURE_ADDRPROP
	CAddrEditProperties* prop;
	for (int i = 0; i < m_userPropList.GetSize(); i++) {
		prop = (CAddrEditProperties*) (m_userPropList.GetAt(i));
		if (prop->GetEntryID() == entryID && prop == wnd) {
			m_userPropList.RemoveAt(i);
			break;
		}
	}			
#endif
}


void CAddrFrame::CloseListProperties (CABMLDialog* wnd, ABID entryID) 
{
	CABMLDialog* prop;
	for (int i = 0; i < m_listPropList.GetSize(); i++) {
		prop = (CABMLDialog*) (m_listPropList.GetAt(i));
		if (prop->GetEntryID() == entryID && prop == wnd) {
			m_listPropList.RemoveAt(i);
			break;
		}
	}
}


void CAddrFrame::OnItemProperties()
{
#ifdef FEATURE_ADDRPROP
	if (GetCurrentDirectoryServer()->dirType == LDAPDirectory) {
		MSG_ViewIndex *indices;
		int count;
		m_pOutliner->GetSelection(indices, count);
		HandleErrorReturn(AB_Command (m_addrBookPane, AB_PropertiesCmd, indices, count), this);
	}
	else {
		MSG_ViewIndex *indices;
		int count;
		m_pOutliner->GetSelection(indices, count);
		for (int i = 0; i < count; i++) {
			ABID type;
			ABID entryID;
			// check the entry type and add/remove pages
			entryID  = AB_GetEntryIDAt((AddressPane*)m_addrBookPane, indices[i]);

			AB_GetType(GetCurrentDirectoryServer(), theApp.m_pABook, 
				entryID, &type);
			if (m_userPropList.GetSize() && type == ABTypePerson) { 
				// try to find 
				for (int i = 0; i < m_userPropList.GetSize(); i++) {
					if (((CAddrEditProperties*)m_userPropList.GetAt(i))->GetEntryID() == entryID) {
						((CAddrEditProperties*)m_userPropList.GetAt(i))->BringWindowToTop();
						return;
					}
				}			
			}

			if (m_listPropList.GetSize() && type == ABTypeList) { 
				for (int i = 0; i < m_listPropList.GetSize(); i++) {
					if (((CABMLDialog*)m_listPropList.GetAt(i))->GetEntryID() == entryID) {
						((CABMLDialog*)m_listPropList.GetAt(i))->BringWindowToTop();
						return;
					}
				}			
			}

			// otherwise open an new property sheet
			if (type == ABTypePerson) {
				CAddrEditProperties* prop = NULL;
				CString formattedString;
				char fullname [kMaxFullNameLength];
				AB_GetFullName(GetCurrentDirectoryServer(), theApp.m_pABook, entryID, fullname);
				formattedString.Format(XP_GetString (MK_ADDR_BOOK_CARD), fullname);
				prop = new CAddrEditProperties(this,
				GetCurrentDirectoryServer(),
				(const char *) formattedString, this, entryID, NULL, GetContext());

				prop->SetCurrentPage(0);
				if (prop->Create(this, WS_SYSMENU | WS_POPUP | WS_CAPTION | WS_VISIBLE,
						WS_EX_DLGMODALFRAME)) {
					m_userPropList.Add (prop);	
				}
			}
			else {
				CABMLDialog* dialog;
				dialog = new CABMLDialog (GetCurrentDirectoryServer(),
					this, entryID, GetContext());
				if (dialog->Create(this)) {
					dialog->ShowWindow(SW_SHOW);
					m_listPropList.Add (dialog);	
				}  
			}
		}
	}
#endif
}


void CAddrFrame::OnCall()
{
	ABID type;
	ABID entryID;
	CString ipAddress;
	CString emailAddress;
	short useServer = 0;

	char szCommandLine[_MAX_PATH];

	// check the entry type and add/remove pages
	entryID  = AB_GetEntryIDAt((AddressPane*)m_addrBookPane, m_pOutliner->GetFocusLine());

	AB_GetType(GetCurrentDirectoryServer(), theApp.m_pABook, 
		entryID, &type);

	if (type != ABTypePerson) {
		CString s;
		if (s.LoadString( IDS_BOOKMARK_ADDRESSPROPERTIES ))
			MessageBox(XP_GetString (MK_MSG_CANT_CALL_MAILING_LIST), s, MB_OK | MB_APPLMODAL);
		return;
	}

	// check that info exists for this person
	AB_GetCoolAddress (GetCurrentDirectoryServer(),
		theApp.m_pABook, entryID, ipAddress.GetBuffer(kMaxCoolAddress));
	ipAddress.ReleaseBuffer(-1);
	AB_GetEmailAddress (GetCurrentDirectoryServer(),
		theApp.m_pABook, entryID, emailAddress.GetBuffer(kMaxEmailAddressLength));
	emailAddress.ReleaseBuffer(-1);
	AB_GetUseServer (GetCurrentDirectoryServer(),
		theApp.m_pABook, entryID, &useServer);

	if ((useServer == kSpecificDLS || useServer == kHostOrIPAddress) && !ipAddress.GetLength()) {
		CString s;
		if (s.LoadString( IDS_BOOKMARK_ADDRESSPROPERTIES ))
			MessageBox(XP_GetString (MK_MSG_CALL_NEEDS_IPADDRESS), s, MB_OK | MB_APPLMODAL);
		OnItemProperties();
		return;
	}

	if ((useServer == kSpecificDLS || useServer == kDefaultDLS) && !emailAddress.GetLength()) {
		CString s;
		if (s.LoadString( IDS_BOOKMARK_ADDRESSPROPERTIES ))
			MessageBox(XP_GetString (MK_MSG_CALL_NEEDS_EMAILADDRESS), s, MB_OK | MB_APPLMODAL);
		OnItemProperties();
		return;
	}

	strcpy (szCommandLine, "");

		if (useServer == 0) 
		{
			CString emailFlag = FEU_GetConfAppProfileString(IDS_CONFAPP_EMAIL);

			if (!emailFlag.IsEmpty())
			{
				strcat(szCommandLine, emailFlag);
				strcat(szCommandLine, " ");
				strcat(szCommandLine, emailAddress);
			}
		}
		else {
			if (useServer == 1) 
			{
				CString emailFlag = FEU_GetConfAppProfileString(IDS_CONFAPP_EMAIL);
				if (!emailFlag.IsEmpty())
				{
					strcat(szCommandLine, emailFlag);
					strcat(szCommandLine, " ");
					strcat(szCommandLine, emailAddress);
					strcat(szCommandLine, " ");
				}

				CString serverFlag = FEU_GetConfAppProfileString(IDS_CONFAPP_SERVER);
				if (!serverFlag.IsEmpty())
				{
					strcat(szCommandLine, serverFlag);
					strcat(szCommandLine, " ");
					strcat(szCommandLine, ipAddress);
				}
			}
			else {
				CString directFlag = FEU_GetConfAppProfileString(IDS_CONFAPP_DIRECTIP);

				if (!directFlag.IsEmpty())
				{
					strcat(szCommandLine, directFlag);
					strcat(szCommandLine, " ");
					strcat(szCommandLine, ipAddress);
				}
			}
		}

		// 
		// Something a bit new...this will be here for passing a users name at the
		// end of a command line.
		//
		CString userNameFlag = FEU_GetConfAppProfileString(IDS_CONFAPP_USERNAME);
		
		if (!userNameFlag.IsEmpty())
		{
			CString szFullUserName;
			AB_GetFullName (GetCurrentDirectoryServer(),
				theApp.m_pABook, entryID, szFullUserName.GetBuffer(kMaxFullNameLength));
			strcat(szCommandLine, " ");
			strcat(szCommandLine, userNameFlag);
			strcat(szCommandLine, " ");
			strcat(szCommandLine, szFullUserName);
		}
	//
	//RHP - Launch conference app
	//
	LaunchConfEndpoint(szCommandLine, GetSafeHwnd());

}


void CAddrFrame::OnSortName()
{
	m_pOutlinerParent->ColumnCommand ( ID_COLADDR_NAME );
}

void CAddrFrame::OnSortType()
{
	m_pOutlinerParent->ColumnCommand ( ID_COLADDR_TYPE );
}

void CAddrFrame::OnSortNickName()
{
	m_pOutlinerParent->ColumnCommand ( ID_COLADDR_NICKNAME );
}

void CAddrFrame::OnSortEmailAddress()
{
	m_pOutlinerParent->ColumnCommand ( ID_COLADDR_EMAIL );
}

void CAddrFrame::OnSortCompany()
{
	m_pOutlinerParent->ColumnCommand ( ID_COLADDR_COMPANY );
}

void CAddrFrame::OnSortLocality()
{
	m_pOutlinerParent->ColumnCommand ( ID_COLADDR_LOCALITY );
}

void CAddrFrame::OnSortAscending()
{
	m_pOutlinerParent->ColumnCommand ( m_pOutliner->GetSortBy() );
}

void CAddrFrame::OnSortDescending()
{
	m_pOutlinerParent->ColumnCommand ( m_pOutliner->GetSortBy() );
}

void CAddrFrame::HandleErrorReturn(int XPErrorId, CWnd* parent, int errorid)
{	
	if (errorid) {
		CString s;
		HWND parentWnd = NULL;
		if (parent)
			parentWnd = parent->m_hWnd;
		if (s.LoadString( IDS_BOOKMARK_ADDRESSPROPERTIES )) {
			if (XPErrorId)
			::MessageBox(parentWnd, XP_GetString(XPErrorId), s, MB_OK | MB_APPLMODAL);
			else {
				CString s2;
				s2.LoadString (errorid);
				::MessageBox(parentWnd, s2, s, MB_OK | MB_APPLMODAL);
			}
		}
	}
}


void CAddrFrame::OnSave()
{
}


void CAddrFrame::OnChangeDirectory (int dirIndex)
{
	m_pDirOutliner->SetDirectoryIndex(dirIndex);
}

void CAddrFrame::OnShowWindow( BOOL bShow, UINT nStatus )
{
	CFrameWnd::OnShowWindow (bShow, nStatus);
	if (bShow && (nStatus == 0)) {
		m_pOutliner->SetDirectoryIndex(0);
		m_pDirOutliner->SetDirectoryIndex(0);
	}
}


void CAddrFrame::OnUpdateDirectorySelection (int dirIndex)
{
	// the user has selected a different directory in the left pane
	m_barAddr.SetDirectoryIndex(dirIndex);
	m_pOutliner->SetDirectoryIndex(dirIndex);
	HandleErrorReturn(AB_ChangeDirectory(m_addrBookPane, GetCurrentDirectoryServer()), this);
}


void CAddrFrame::OnStopSearch ()
{
	CWnd* widget = m_barAddr.GetDlgItem(IDC_DIRECTORIES);
	CWnd* widget2 = m_barAddr.GetDlgItem (IDC_DIRSEARCH);
	// We've turned into stop button
	HandleErrorReturn(AB_FinishSearch(m_addrBookPane, GetContext()), this);
	m_bSearching = FALSE;
	GetChrome()->StopAnimation();
	widget->EnableWindow(TRUE);
	widget2->EnableWindow(TRUE);
	m_pDirOutliner->EnableWindow(TRUE);

	MSG_ViewIndex *indices = NULL;
	int count = 0;
	m_pOutliner->GetSelection(indices, count);
	if (!count)
		m_pOutliner->SelectItem (0);
	return;
}

void CAddrFrame::OnExtendedDirectorySearch ()
{
	CWnd* widget = m_barAddr.GetDlgItem(IDC_DIRECTORIES);
	CWnd* widget2 = m_barAddr.GetDlgItem (IDC_DIRSEARCH);

	if (m_bSearching) {
		OnStopSearch();
		return;
	}

	CUIntArray buttonLabels;
	buttonLabels.SetSize (4, 1);
	buttonLabels [0] = IDS_ADRSEARCH;
	buttonLabels [1] = IDS_CANCEL_BUTTON;
	buttonLabels [2] = IDS_HELP_BUTTON;
	buttonLabels [3] = IDS_ADVSEARCH;

	CSearchDialog searchDlg ((UINT) IDS_ADRSEARCH, 
		(MSG_Pane*) m_addrBookPane, 
		GetCurrentDirectoryServer(),
		this, 4, BUTTON_RIGHT, &buttonLabels);
	int result = searchDlg.DoModal(); 

	// Build Search
	if (result == IDOK)
	{
		GetChrome()->StartAnimation();
		LPNSSTATUSBAR pIStatusBar = NULL;
		m_pChrome->QueryInterface( IID_INSStatusBar, (LPVOID *) &pIStatusBar );
		if ( pIStatusBar ) {
			pIStatusBar->SetStatusText(szLoadString( IDS_SEARCHING ));
			pIStatusBar->Release();
		}

		m_barAddr.GetDlgItem(IDC_ADDRNAME)->SetWindowText("");
		m_bSearching = TRUE;
		widget->EnableWindow(FALSE);
		widget2->EnableWindow(FALSE);
		m_pOutliner->SetTotalLines(0);
		m_pOutliner->SetFocus();
		m_pOutliner->SetFocusLine(0);
		m_pDirOutliner->EnableWindow(FALSE);

		HandleErrorReturn(AB_SearchDirectory(m_addrBookPane, NULL), this);
	}

}

void CAddrFrame::OnDirectoryList (char * name)
{
	CWnd* widget;
	CWnd* widget2;
	CString cs;
	widget = m_barAddr.GetDlgItem(IDC_DIRECTORIES);
	widget2 = m_barAddr.GetDlgItem(IDC_DIRSEARCH);

	// Build Search
	GetChrome()->StartAnimation();
	LPNSSTATUSBAR pIStatusBar = NULL;
	m_pChrome->QueryInterface( IID_INSStatusBar, (LPVOID *) &pIStatusBar );
	if ( pIStatusBar ) {
		pIStatusBar->SetStatusText(szLoadString( IDS_SEARCHING ));
		pIStatusBar->Release();
	}
	m_bSearching = TRUE;
	widget->EnableWindow(FALSE);
	widget2->EnableWindow(FALSE);
	m_pDirOutliner->EnableWindow(FALSE);

	HandleErrorReturn(AB_SearchDirectory(m_addrBookPane, name), this);
	m_pOutliner->UpdateCount();
}

//////////////////////////////////////////////////////////////////////////////
// CAddrOutliner
BEGIN_MESSAGE_MAP(CAddrOutliner, CMSelectOutliner)
	//{{AFX_MSG_MAP(CAddrOutliner)
	ON_WM_KEYDOWN()
	ON_WM_TIMER()
	ON_WM_KILLFOCUS()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

CAddrOutliner::CAddrOutliner ( )
{
	int32 prefInt;
	PREF_GetIntPref("mail.addr_book.sortby",&prefInt);
	if (prefInt != ID_COLADDR_NAME && prefInt != ID_COLADDR_EMAIL
		&& prefInt != ID_COLADDR_NICKNAME)
		prefInt = ID_COLADDR_NAME;

	m_attribSortBy = CASTINT(prefInt);
	ApiApiPtr(api);
    m_pUnkUserImage = api->CreateClassInstance(APICLASS_IMAGEMAP);
    if (m_pUnkUserImage) {
        m_pUnkUserImage->QueryInterface(IID_IImageMap,(LPVOID*)&m_pIUserImage);
        ASSERT(m_pIUserImage);
        m_pIUserImage->Initialize(IDB_ADDRESSBOOK,16,16);
    }
	XP_Bool prefBool;
	PREF_GetBoolPref("mail.addr_book.sort_ascending",&prefBool);
	m_bSortAscending = prefBool;
	m_iMysticPlane = 0;
	m_dirIndex = 0;
	m_hFont = NULL;
	m_psTypedown = "";
	m_uTypedownClock = 0;
}

CAddrOutliner::~CAddrOutliner ( )
{
	if (m_pUnkUserImage) {
        if (m_pIUserImage)
            m_pUnkUserImage->Release();
    }
	if (m_hFont) {
		theApp.ReleaseAppFont(m_hFont);
	}

}

void CAddrOutliner::OnKillFocus( CWnd* pNewWnd )
{
	CMSelectOutliner::OnKillFocus (pNewWnd );
	m_psTypedown = "";	
	KillTimer(m_uTypedownClock);
}

void CAddrOutliner::OnTypedown (char* name)
{
	MSG_ViewIndex	index;
	int	startIndex;
	
	if (GetFocusLine() != -1)
		startIndex = GetFocusLine();
	else
		startIndex = 0;

	AB_GetIndexMatchingTypedown(m_pane, &index, 
		(LPCTSTR) name, startIndex);

	ScrollIntoView(CASTINT(index));
	SelectItem (CASTINT(index));
}

HFONT CAddrOutliner::GetLineFont(void *pLineData)
{
	if (!m_hFont)
	{
		HDC hDC = ::GetDC(m_hWnd);
		LOGFONT lf;  
		memset(&lf,0,sizeof(LOGFONT));

		lf.lfPitchAndFamily = FF_SWISS;
		lf.lfWeight = FW_NORMAL;
		lf.lfCharSet = IntlGetLfCharset(CIntlWin::GetSystemLocaleCsid());
		if (CIntlWin::GetSystemLocaleCsid() == CS_LATIN1)
 			_tcscpy(lf.lfFaceName, "MS Sans Serif");
		else
 			_tcscpy(lf.lfFaceName, IntlGetUIPropFaceName(CIntlWin::GetSystemLocaleCsid()));
		lf.lfHeight = -MulDiv(9, ::GetDeviceCaps(hDC, LOGPIXELSY), 72);
		m_hFont = theApp.CreateAppFont( lf );
	    ::ReleaseDC(m_hWnd,hDC);
	}
	return m_hFont;
}


DIR_Server* CAddrOutliner::GetCurrentDirectoryServer ()
{
	return (DIR_Server*)XP_ListGetObjectNum(theApp.m_directories, m_dirIndex + 1);
}


void CAddrOutliner::SetDirectoryIndex (int dirIndex)
{
	m_dirIndex = dirIndex;
	DIR_Server* pServer = GetCurrentDirectoryServer ();
	int iCount = GetNumColumns();
	for (int i = 0; i < iCount; i++) {
		CString cs;
		int iColumn = GetColumnAtPos(i);
		if (pServer->dirType == LDAPDirectory)
		{
			DIR_AttributeId id;
			const char *text = NULL;
			switch (iColumn) {
			case ID_COLADDR_TYPE:
				text = NULL;
				break;
			case ID_COLADDR_NAME:
				MSG_SearchAttribToDirAttrib(attribCommonName, &id);		
				text = DIR_GetAttributeName(pServer, id);
				break;
			case ID_COLADDR_EMAIL:
				MSG_SearchAttribToDirAttrib(attrib822Address, &id);	
				text = DIR_GetAttributeName(pServer, id);
				break;
			case ID_COLADDR_COMPANY:
				MSG_SearchAttribToDirAttrib(attribOrganization, &id);	
				text = DIR_GetAttributeName(pServer, id);
				break;
			case ID_COLADDR_LOCALITY:
				MSG_SearchAttribToDirAttrib(attribLocality, &id);				
				text = DIR_GetAttributeName(pServer, id);
				break;
			case ID_COLADDR_PHONE:
				MSG_SearchAttribToDirAttrib(attribPhoneNumber, &id);				
				text = DIR_GetAttributeName(pServer, id);
				break;
			case ID_COLADDR_NICKNAME:
				text = NULL;	
				break;
			default:
				break;
			}
			if (text)
				SetColumnName(iColumn, text);
		}
		else
		{
			switch (iColumn) {
			case ID_COLADDR_TYPE:
				cs = "";
				break;
			case ID_COLADDR_NAME:
				cs.LoadString(IDS_USERNAME);		
				break;
			case ID_COLADDR_EMAIL:
				cs.LoadString(IDS_EMAILADDRESS);
				break;
			case ID_COLADDR_COMPANY:
				cs.LoadString(IDS_COMPANYNAME);	
				break;
			case ID_COLADDR_PHONE:
				cs.LoadString(IDS_PHONE);	
				break;
			case ID_COLADDR_LOCALITY:
				cs.LoadString(IDS_LOCALITY);				
				break;
			case ID_COLADDR_NICKNAME:
				cs.LoadString(IDS_NICKNAME);	
				break;
			default:
				break;
			}
		if (cs.GetLength())
			SetColumnName(iColumn, cs);
		}
	}
	GetParent()->Invalidate();
	GetParent()->UpdateWindow();
	ClearSelection();
	SelectItem(dirIndex);
}

void CAddrOutliner::UpdateCount( )
{
	uint32 count;

	AB_GetEntryCount(GetCurrentDirectoryServer (), theApp.m_pABook, &count, ABTypeAll, NULL);
	m_iTotalLines = CASTINT(count);
	if (!m_iTotalLines)
		ClearSelection();
}


BOOL CAddrOutliner::DeleteItem ( int iLine )
{
    XP_Bool bSelectable, bPlural;
	MSG_ViewIndex indices[1];
	indices[0] = (MSG_ViewIndex) iLine;
    MSG_COMMAND_CHECK_STATE sState;
    AB_CommandStatus( m_pane, 
					   AB_DeleteCmd,
					   indices, 1,
					   &bSelectable, 
					   &sState, 
					   NULL,
					   &bPlural);
    if (bSelectable) {
        AB_Command ( m_pane, AB_DeleteCmd, indices, 1 );
        return TRUE;
    }
    else
        MessageBeep(0);
    return FALSE;
}

void CAddrOutliner::SetPane(ABPane *pane)
{
	m_pane = pane;
	uint32 count;

	if (m_pane) {
		AB_GetEntryCount(GetCurrentDirectoryServer (), theApp.m_pABook, &count, ABTypeAll, NULL);
		SetTotalLines(CASTINT(count));
		Invalidate();
		UpdateWindow();
	}
}

void CAddrOutliner::MysticStuffStarting( XP_Bool asynchronous,
											MSG_NOTIFY_CODE notify, 
											MSG_ViewIndex where,
											int32 num )
{
	++m_iMysticPlane;
}

void CAddrOutliner::MysticStuffFinishing( XP_Bool asynchronous,
											 MSG_NOTIFY_CODE notify, 
											 MSG_ViewIndex where,
											 int32 num )
{
	switch ( notify ) {
	case MSG_NotifyNone:
		break;

	case MSG_NotifyInsertOrDelete:
		// if its insert or delete then tell my frame to add the next chunk of values
		// from the search
		if (notify == MSG_NotifyInsertOrDelete 
			&& ((CAddrFrame*) GetParentFrame())->IsSearching() && num > 0) 
		{
			((CAddrFrame*) GetParentFrame())->SetSearchResults(where, num);
			HandleInsert(where, num);
			// Invalidate();
		}
		else
		{
			if (num > 0)
				HandleInsert(where, num);
			else
				HandleDelete(where, -num);
		}
		break;

	case MSG_NotifyChanged:
		InvalidateLines( (int) where, (int) num );
		break;

	case MSG_NotifyAll:
	case MSG_NotifyScramble:
		Invalidate();
		break;
	}

	if (( !--m_iMysticPlane && m_pane)) {
		uint32 count;
		AB_GetEntryCount(GetCurrentDirectoryServer (), theApp.m_pABook, &count, ABTypeAll, NULL);
		SetTotalLines(CASTINT(count));
		Invalidate();
		UpdateWindow();
	}
}

void CAddrOutliner::PropertyMenu ( int iSel, UINT flags )	
{
	BOOL bHasItems = FALSE;
	CMenu cmPopup;
	CString cs;
	
	if(cmPopup.CreatePopupMenu() == 0) 
		return;

    if (iSel < m_iTotalLines) {
		cs.LoadString(ID_POPUP_MAILNEW);
		cmPopup.AppendMenu(MF_ENABLED, ID_FILE_NEWMESSAGE, cs);
		cmPopup.AppendMenu(MF_SEPARATOR);
		cs.LoadString(IDS_AB_NEW_USER);
		cmPopup.AppendMenu(MF_ENABLED, ID_ITEM_ADDUSER, cs);
		cs.LoadString(IDS_AB_NEW_LIST);
		cmPopup.AppendMenu(MF_ENABLED, ID_ITEM_ADDLIST, cs);
		cmPopup.AppendMenu(MF_SEPARATOR);
		cs.LoadString(IDS_COMPOSE_REMOVE);
		cmPopup.AppendMenu(MF_ENABLED, ID_EDIT_DELETE, cs);
		cmPopup.AppendMenu(MF_SEPARATOR);
		cs.LoadString(IDS_AB_PROPERTIES);
		cmPopup.AppendMenu(MF_ENABLED, ID_ITEM_PROPERTIES, cs);
		bHasItems = TRUE;
	}


	//	Track the popup now.
	POINT pt = m_ptHit;
	ClientToScreen(&pt);

	cmPopup.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x, pt.y, 
						   GetParentFrame(), NULL);

    //  Cleanup
    cmPopup.DestroyMenu();
}

void CAddrOutliner::AcceptDrop( int iLineNo, COleDataObject *pDataObject,
							    DROPEFFECT dropEffect )
{
    if(!pDataObject)
        return;

	// Dont allow us to drop on ourselves
	if(pDataObject->IsDataAvailable(m_cfSourceTarget))
	   return;

	if(!pDataObject->IsDataAvailable(m_cfAddresses) &&
	   !pDataObject->IsDataAvailable(CF_TEXT))
	   return;

		if(pDataObject->IsDataAvailable(m_cfAddresses)) {
			HGLOBAL hAddresses = pDataObject->GetGlobalData(m_cfAddresses);
			LPSTR pAddresses = (LPSTR)GlobalLock(hAddresses);
			ASSERT(pAddresses);
			// Parse the vcards and add them to the address book
			AB_ImportFromVcard((AddressPane*) m_pane, pAddresses);
			GlobalUnlock(hAddresses);
		}
		else {
			HGLOBAL hString = pDataObject->GetGlobalData(CF_TEXT);
			char * pAddress = (char*)GlobalLock(hString);
			ASSERT(pAddress);
			// parse the vcard from the text
			AB_ImportFromVcard((AddressPane*) m_pane, pAddress);
			GlobalUnlock(hString);
		}
}

void CAddrOutliner::InitializeClipFormats(void)
{
     m_cfAddresses = (CLIPFORMAT)RegisterClipboardFormat(vCardClipboardFormat);
	 m_cfSourceTarget = (CLIPFORMAT)RegisterClipboardFormat(ADDRESSBOOK_SOURCETARGET_FORMAT);
}

CLIPFORMAT * CAddrOutliner::GetClipFormatList(void)
{
    static CLIPFORMAT cfFormatList[3];
    cfFormatList[0] = m_cfAddresses;
	cfFormatList[1] = m_cfSourceTarget;
    cfFormatList[2] = 0;
    return cfFormatList;
}


COleDataSource * CAddrOutliner::GetDataSource(void)
{
    COleDataSource * pDataSource = new COleDataSource;
	ABID	entryID;
	char* pVcard = NULL;
	char* pVcards = XP_STRDUP("");
	char  szTemp[10];
	char  szEntryID[20];
	char* pEntryIDs = XP_STRDUP("");
	HANDLE hString = 0;
	MSG_ViewIndex *indices;
	int count;

	GetSelection(indices, count);

	for (int i = 0 ; i < count; i++) {
		if ((entryID = AB_GetEntryIDAt((AddressPane*) m_pane, indices[i])) != 0) {
			AB_ExportToVCard(theApp.m_pABook, 
				GetCurrentDirectoryServer (), entryID, &pVcard);
			pVcards = StrAllocCat(pVcards, pVcard);
			XP_FREE(pVcard);
			pVcard = NULL;

			ltoa(entryID, szTemp, 10);
			sprintf(szEntryID, "%s-", szTemp);
			pEntryIDs = StrAllocCat(pEntryIDs, szEntryID);
		}
	}

	if (pVcards) {
		hString = GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE|GMEM_ZEROINIT,strlen(pVcards)+1);
        LPSTR lpszString = (LPSTR)GlobalLock(hString);
        strcpy(lpszString,pVcards);
		XP_FREE (pVcards);
        GlobalUnlock(hString);

		HANDLE hEntryID = GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE|GMEM_ZEROINIT,strlen(pEntryIDs)+1);
        LPSTR lpszEntryID = (LPSTR)GlobalLock(hEntryID);
        strcpy(lpszEntryID,pEntryIDs);
		XP_FREE (pEntryIDs);
        GlobalUnlock(hEntryID);
        pDataSource->CacheGlobalData(m_cfAddresses, hString);
		pDataSource->CacheGlobalData(m_cfSourceTarget, hEntryID);
		pDataSource->CacheGlobalData(CF_TEXT, hString);
    }

    return pDataSource;
}


BOOL CAddrOutliner::RenderData  ( UINT iColumn, CRect &rect, CDC &dc, const char * text )
{
	if ( iColumn != ID_COLADDR_TYPE )
        return CMSelectOutliner::RenderData ( iColumn, rect, dc, text );
	int idxImage;

    if (m_EntryLine.entryType == ABTypeList)
		idxImage = IDX_ADDRESSBOOKLIST;
	else
		idxImage = IDX_ADDRESSBOOKPERSON;

	m_pIUserImage->DrawImage ( idxImage,
		rect.left + ( ( rect.Width ( ) - 16 ) / 2 ), rect.top, &dc, FALSE );
	return TRUE;
}


int CAddrOutliner::TranslateIcon ( void * pLineData )
{
	AB_EntryLine* line = (AB_EntryLine*) pLineData;
	int idxImage = 0;

    if (line->entryType == ABTypeList)
		idxImage = IDX_ADDRESSBOOKLIST;
	else
		idxImage = IDX_ADDRESSBOOKPERSON;
	return idxImage;
}

int CAddrOutliner::TranslateIconFolder (void * pData)
{
	// We're a flat list, so we're never a folder
    return ( OUTLINER_ITEM );
}


BOOL CAddrOutliner::ColumnCommand ( int iColumn, int iLine )
{
	// We have no column commands
    return FALSE;
}

void * CAddrOutliner::AcquireLineData ( int line )
{
	m_lineindex = line + 1;
	if ( line >= m_iTotalLines)
		return NULL;
	if (!AB_GetEntryLine(m_pane, line, &m_EntryLine ))
        return NULL;

	return &m_EntryLine;
}

void CAddrOutliner::GetTreeInfo ( int iLine, uint32 * pFlags, int * pDepth, OutlinerAncestorInfo ** pAncestor )
{
    if ( pFlags ) *pFlags = 0; // Flags? 
    if ( pDepth ) *pDepth = 0; // We're flat, remember?
}

void CAddrOutliner::ReleaseLineData ( void * )
{
}

LPCTSTR CAddrOutliner::GetColumnText ( UINT iColumn, void * pLineData )
{
	AB_EntryLine* line = (AB_EntryLine*) pLineData;

	switch (iColumn) {
		case ID_COLADDR_NAME:
			return line->fullname;
			break;
		case ID_COLADDR_EMAIL:
			return line->emailAddress;
			break;
		case ID_COLADDR_COMPANY:
			return line->companyName;
			break;
		case ID_COLADDR_PHONE:
			if (line->entryType == ABTypePerson)
				return line->workPhone;
			break;
		case ID_COLADDR_LOCALITY:
			return line->locality;
			break;
		case ID_COLADDR_NICKNAME:
			return line->nickname;
			break;
		default:
			break;
	}
    return ("");
}

void CAddrOutliner::OnSelChanged()
{
	// No Op
}

void CAddrOutliner::OnSelDblClk()
{
	GetParentFrame()->SendMessage(WM_COMMAND, ID_ITEM_PROPERTIES, 0);
}


void CAddrOutliner::OnTimer(UINT nID)
{
	CMSelectOutliner::OnTimer(nID);
	if (nID == OUTLINER_TYPEDOWN_TIMER) {
		KillTimer(m_uTypedownClock);
		m_psTypedown = "";
	}
}

void CAddrOutliner::OnKeyDown ( UINT nChar, UINT nRepCnt, UINT nFlags )
{
	CMSelectOutliner::OnKeyDown ( nChar, nRepCnt, nFlags );
	KillTimer(m_uTypedownClock);
	if (nChar > VK_HELP) {
		KillTimer(m_uTypedownClock);
		m_psTypedown += nChar;
		OnTypedown (m_psTypedown.GetBuffer (0));
		m_psTypedown.ReleaseBuffer(-1);
		int32 prefInt = OUTLINER_TYPEDOWN_SPEED;
		PREF_GetIntPref("ldap_1.autoComplete.interval", &prefInt);
		m_uTypedownClock = SetTimer(OUTLINER_TYPEDOWN_TIMER, prefInt, NULL);
	}
}

/////////////////////////////////////////////////////////////////////////////
// CAddrOutlinerParent

BEGIN_MESSAGE_MAP(CAddrOutlinerParent, COutlinerParent)
	//{{AFX_MSG_MAP(CAddrOutlinerParent)
	ON_WM_DESTROY()
	ON_WM_LBUTTONUP()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

CAddrOutlinerParent::CAddrOutlinerParent()
{

}


CAddrOutlinerParent::~CAddrOutlinerParent()
{
 
}


BOOL CAddrOutlinerParent::RenderData ( int idColumn, CRect & rect, CDC &dc, const char * text )
{
	int cx = 3, cy = 0;
    CAddrOutliner *pOutliner = (CAddrOutliner *) m_pOutliner;
	
	// Calculate text offset from top using font height.
    TEXTMETRIC tm;
    dc.GetTextMetrics ( &tm );
    cy = ( rect.bottom - rect.top - tm.tmHeight ) / 2;
        
	// Draw Text String
	dc.TextOut (rect.left + cx, rect.top + cy, text, _tcslen(text) );
    
	// Draw Sort Indicator
	MSG_COMMAND_CHECK_STATE sortType = pOutliner->m_attribSortBy == idColumn ? MSG_Checked : MSG_Unchecked;

	int idxImage = pOutliner->m_bSortAscending ? IDX_SORTINDICATORDOWN : IDX_SORTINDICATORUP;
	CSize cs = dc.GetTextExtent(text, _tcslen(text));

	if (idColumn == pOutliner->m_attribSortBy && cs.cx + 22 <= rect.Width()) {
        m_pIImage->DrawTransImage( idxImage,
								   rect.left + 8 + cs.cx,
								   (rect.top + rect.bottom) / 2 - 4,
								   &dc );
	}

    return TRUE;
}

COutliner * CAddrOutlinerParent::GetOutliner ( void )
{
    return new CAddrOutliner;
}

void CAddrOutlinerParent::CreateColumns ( void )
{
	int iCol0 = 0,
		iCol1 = 0,
	    iCol2 = 0,
        iCol3 = 0,
        iCol4 = 0,
		iCol5 = 0;
	CString cs; 

	m_pOutliner->AddColumn ("",			ID_COLADDR_TYPE,		24, 0, ColumnFixed, 0, TRUE );
	cs.LoadString(IDS_USERNAME);
    m_pOutliner->AddColumn (cs,			ID_COLADDR_NAME,		1500, 0, ColumnVariable, iCol0 ? iCol0 : 1500 );
	cs.LoadString(IDS_EMAILADDRESS);
    m_pOutliner->AddColumn (cs,			ID_COLADDR_EMAIL,		1500, 0, ColumnVariable, iCol2 ? iCol2 : 1500 ); 
	cs.LoadString(IDS_COMPANYNAME);
    m_pOutliner->AddColumn (cs,			ID_COLADDR_COMPANY,		1500, 0, ColumnVariable, iCol5 ? iCol5 : 1500 ); 
	cs.LoadString(IDS_PHONE);
    m_pOutliner->AddColumn (cs,			ID_COLADDR_PHONE,		1500, 0, ColumnVariable, iCol4 ? iCol4 : 1500, FALSE);
	cs.LoadString(IDS_LOCALITY);
    m_pOutliner->AddColumn (cs,			ID_COLADDR_LOCALITY,	1500, 0, ColumnVariable, iCol4 ? iCol4 : 1500 );
	cs.LoadString(IDS_NICKNAME);
    m_pOutliner->AddColumn (cs,			ID_COLADDR_NICKNAME,	1500, 0, ColumnVariable, iCol3 ? iCol3 : 1500 );
	m_pOutliner->SetHasPipes( FALSE );

	m_pOutliner->SetVisibleColumns(DEF_VISIBLE_COLUMNS);
	m_pOutliner->LoadXPPrefs("mailnews.abook_columns_win");
}

void CAddrOutlinerParent::OnDestroy()
{
	int32 prefInt = ((CAddrOutliner*)m_pOutliner)->GetSortBy();
	if (prefInt != ID_COLADDR_NAME && prefInt != ID_COLADDR_EMAIL
		&& prefInt != ID_COLADDR_NICKNAME)
		prefInt = ID_COLADDR_NAME;

	PREF_SetIntPref("mail.addr_book.sortby", prefInt);
	PREF_SetBoolPref("mail.addr_book.sort_ascending",((CAddrOutliner*)m_pOutliner)->GetSortAscending());
	
	COutlinerParent::OnDestroy();
}

void CAddrOutlinerParent::OnLButtonUp( UINT nFlags, CPoint point )
{
	BOOL bSaveColumns = (m_pOutliner && 
		(m_bResizeColumn || m_bDraggingHeader || m_iPusherHit))? TRUE : FALSE;
	COutlinerParent::OnLButtonUp(nFlags, point);
	if (bSaveColumns)
		m_pOutliner->SaveXPPrefs("mailnews.abook_columns_win");
}

BOOL CAddrOutlinerParent::ColumnCommand ( int idColumn )
{	
	ABID lastSelection;

	CAddrOutliner *pOutliner = (CAddrOutliner *) m_pOutliner;
	
	if (pOutliner->GetFocusLine() != -1)
		lastSelection = AB_GetEntryIDAt((AddressPane*) pOutliner->GetPane(), pOutliner->GetFocusLine());

	SetCursor ( theApp.LoadStandardCursor ( IDC_WAIT ) );

	if (idColumn == pOutliner->m_attribSortBy) {
		pOutliner->m_bSortAscending = !pOutliner->m_bSortAscending; 
	}
	else
		pOutliner->m_bSortAscending = TRUE;

	pOutliner->m_attribSortBy = idColumn;

	switch (idColumn) {
		case ID_COLADDR_TYPE:
			AB_Command(pOutliner->GetPane(), AB_SortByTypeCmd, 0, 0);
			break;
		case ID_COLADDR_NAME:
			AB_Command(pOutliner->GetPane(), AB_SortByFullNameCmd, 0, 0);
			break;
		case ID_COLADDR_NICKNAME:
			AB_Command(pOutliner->GetPane(), AB_SortByNickname, 0, 0);
			break;
		case ID_COLADDR_LOCALITY:
			AB_Command(pOutliner->GetPane(), AB_SortByLocality, 0, 0);
			break;
		case ID_COLADDR_COMPANY:
			AB_Command(pOutliner->GetPane(), AB_SortByCompanyName, 0, 0);
			break;
		case ID_COLADDR_EMAIL:
			AB_Command(pOutliner->GetPane(), AB_SortByEmailAddress, 0, 0);
			break;
		default:
			AB_Command(pOutliner->GetPane(), AB_SortByFullNameCmd, 0, 0);
			break;
	}
	

	if (pOutliner->GetFocusLine() != -1) {
		uint32 index = AB_GetIndexOfEntryID ((AddressPane *) pOutliner->GetPane(), lastSelection);
		pOutliner->SelectItem (CASTINT(index));
		pOutliner->ScrollIntoView(CASTINT(index));
	}

	Invalidate();
	pOutliner->Invalidate();
	SetCursor ( theApp.LoadStandardCursor ( IDC_ARROW ) );
	return TRUE;
}




//////////////////////////////////////////////////////////////////////////////
// CAddrOutliner
BEGIN_MESSAGE_MAP(CDirOutliner, CMSelectOutliner)
	//{{AFX_MSG_MAP(CDirOutliner)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

CDirOutliner::CDirOutliner ( )
{
	m_attribSortBy = 0;
	ApiApiPtr(api);
    m_pUnkUserImage = api->CreateClassInstance(APICLASS_IMAGEMAP);
    if (m_pUnkUserImage) {
        m_pUnkUserImage->QueryInterface(IID_IImageMap,(LPVOID*)&m_pIUserImage);
        ASSERT(m_pIUserImage);
        m_pIUserImage->Initialize(IDB_DIRLIST,16,16);
    }
	
	m_attribSortBy = 1;
	m_bSortAscending = TRUE;
	m_iMysticPlane = 0;
	m_dirIndex = 0;
	m_hFont = NULL;
	m_pDirLine = NULL;
}

CDirOutliner::~CDirOutliner ( )
{
	if (m_pUnkUserImage) {
        if (m_pIUserImage)
            m_pUnkUserImage->Release();
    }
	if (m_hFont) {
		theApp.ReleaseAppFont(m_hFont);
	}

}


HFONT CDirOutliner::GetLineFont(void *pLineData)
{
	if (!m_hFont)
	{
		HDC hDC = ::GetDC(m_hWnd);
		LOGFONT lf;  
		memset(&lf,0,sizeof(LOGFONT));

		lf.lfPitchAndFamily = FF_SWISS;
		lf.lfWeight = FW_NORMAL;
		lf.lfCharSet = IntlGetLfCharset(CIntlWin::GetSystemLocaleCsid());
		if (CIntlWin::GetSystemLocaleCsid() == CS_LATIN1)
 			_tcscpy(lf.lfFaceName, "MS Sans Serif");
		else
 			_tcscpy(lf.lfFaceName, IntlGetUIPropFaceName(CIntlWin::GetSystemLocaleCsid()));
		lf.lfHeight = -MulDiv(9, ::GetDeviceCaps(hDC, LOGPIXELSY), 72);
		m_hFont = theApp.CreateAppFont( lf );
	    ::ReleaseDC(m_hWnd,hDC);
	}
	return m_hFont;
}

void CDirOutliner::SetDirectoryIndex (int dirIndex)
{
	m_dirIndex = dirIndex;
	SelectItem (CASTINT(m_dirIndex));
}

void CDirOutliner::UpdateCount( )
{
	m_iTotalLines = XP_ListCount (theApp.m_directories);
	if (!m_iTotalLines)
		ClearSelection();
	Invalidate();
	UpdateWindow();
}


BOOL CDirOutliner::DeleteItem ( int iLine )
{
	MSG_ViewIndex indices[1];
	indices[0] = (MSG_ViewIndex) iLine;
    MessageBeep(0);
    return TRUE;
}

void CDirOutliner::SetPane(ABPane *pane)
{
	m_pane = pane;

	if (m_pane) {
		SetTotalLines(XP_ListCount (theApp.m_directories));
		Invalidate();
		UpdateWindow();
	}
}

void CDirOutliner::MysticStuffStarting( XP_Bool asynchronous,
											MSG_NOTIFY_CODE notify, 
											MSG_ViewIndex where,
											int32 num )
{
	++m_iMysticPlane;
}

void CDirOutliner::MysticStuffFinishing( XP_Bool asynchronous,
											 MSG_NOTIFY_CODE notify, 
											 MSG_ViewIndex where,
											 int32 num )
{
	switch ( notify ) {
	case MSG_NotifyNone:
		break;

	case MSG_NotifyInsertOrDelete:
		if (num > 0)
			HandleInsert(where, num);
		else
			HandleDelete(where, -num);
		break;

	case MSG_NotifyChanged:
		InvalidateLines( (int) where, (int) num );
		break;

	case MSG_NotifyAll:
	case MSG_NotifyScramble:
		Invalidate();
		break;
	}

	if (( !--m_iMysticPlane && m_pane)) {
		SetTotalLines(XP_ListCount (theApp.m_directories));
		Invalidate();
		UpdateWindow();
	}
}

void CDirOutliner::PropertyMenu ( int iSel, UINT flags )	
{
	BOOL bHasItems = FALSE;
	CMenu cmPopup;
	CString cs;
	
	if(cmPopup.CreatePopupMenu() == 0) 
		return;

    if (iSel < m_iTotalLines) {
		cs.LoadString(IDS_AB_NEW_USER);
		cmPopup.AppendMenu(MF_ENABLED, ID_ITEM_ADDUSER, cs);
		cs.LoadString(IDS_AB_NEW_LIST);
		cmPopup.AppendMenu(MF_ENABLED, ID_ITEM_ADDLIST, cs);
		cmPopup.AppendMenu(MF_SEPARATOR);
		cs.LoadString(IDS_COMPOSE_REMOVE);
		cmPopup.AppendMenu(MF_ENABLED, ID_EDIT_DELETE, cs);
		cmPopup.AppendMenu(MF_SEPARATOR);
		cs.LoadString(IDS_AB_PROPERTIES);
		cmPopup.AppendMenu(MF_ENABLED, ID_ITEM_PROPERTIES, cs);
		bHasItems = TRUE;
	}


	//	Track the popup now.
	POINT pt = m_ptHit;
	ClientToScreen(&pt);

	cmPopup.TrackPopupMenu(TPM_LEFTALIGN | TPM_RIGHTBUTTON, pt.x, pt.y, 
						   GetParentFrame(), NULL);

    //  Cleanup
    cmPopup.DestroyMenu();
}

void CDirOutliner::AcceptDrop( int iLineNo, COleDataObject *pDataObject,
							    DROPEFFECT dropEffect )
{
    if(!pDataObject)
        return;

	// Dont allow us to drop on ourselves
	if(pDataObject->IsDataAvailable(m_cfSourceTarget))
	   return;

	if(!pDataObject->IsDataAvailable(m_cfAddresses) &&
	   !pDataObject->IsDataAvailable(CF_TEXT))
	   return;

		if(pDataObject->IsDataAvailable(m_cfAddresses)) {
			HGLOBAL hAddresses = pDataObject->GetGlobalData(m_cfAddresses);
			LPSTR pAddresses = (LPSTR)GlobalLock(hAddresses);
			ASSERT(pAddresses);
			// Parse the vcards and add them to the address book
			// AB_ImportFromVcard((AddressPane*) m_pane, pAddresses);
			GlobalUnlock(hAddresses);
		}
		else {
			HGLOBAL hString = pDataObject->GetGlobalData(CF_TEXT);
			char * pAddress = (char*)GlobalLock(hString);
			ASSERT(pAddress);
			// parse the vcard from the text
			// AB_ImportFromVcard((AddressPane*) m_pane, pAddress);
			GlobalUnlock(hString);
		}
}

void CDirOutliner::InitializeClipFormats(void)
{
     m_cfAddresses = (CLIPFORMAT)RegisterClipboardFormat(vCardClipboardFormat);
	 m_cfSourceTarget = (CLIPFORMAT)RegisterClipboardFormat(ADDRESSBOOK_SOURCETARGET_FORMAT);
}

CLIPFORMAT * CDirOutliner::GetClipFormatList(void)
{
    static CLIPFORMAT cfFormatList[3];
    cfFormatList[0] = m_cfAddresses;
	cfFormatList[1] = m_cfSourceTarget;
    cfFormatList[2] = 0;
    return cfFormatList;
}


COleDataSource * CDirOutliner::GetDataSource(void)
{
    COleDataSource * pDataSource = new COleDataSource;
	MSG_ViewIndex *indices;
	int count;

	/*
	ABID	entryID;
	char* pVcard = NULL;
	char* pVcards = XP_STRDUP("");
	char  szTemp[10];
	char  szEntryID[20];
	char* pEntryIDs = XP_STRDUP("");
	HANDLE hString = 0;
	*/

	GetSelection(indices, count);

	/* for (int i = 0 ; i < count; i++) {
		if ((entryID = AB_GetEntryIDAt((AddressPane*) m_pane, indices[i])) != 0) {
			AB_ExportToVCard(theApp.m_pABook, 
				(DIR_Server*)XP_ListGetObjectNum(theApp.m_directories, m_dirIndex + 1), entryID, &pVcard);
			pVcards = StrAllocCat(pVcards, pVcard);
			XP_FREE(pVcard);
			pVcard = NULL;

			ltoa(entryID, szTemp, 10);
			sprintf(szEntryID, "%s-", szTemp);
			pEntryIDs = StrAllocCat(pEntryIDs, szEntryID);
		}
	}

	if (pVcards) {
		hString = GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE|GMEM_ZEROINIT,strlen(pVcards)+1);
        LPSTR lpszString = (LPSTR)GlobalLock(hString);
        strcpy(lpszString,pVcards);
		XP_FREE (pVcards);
        GlobalUnlock(hString);

		HANDLE hEntryID = GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE|GMEM_ZEROINIT,strlen(pEntryIDs)+1);
        LPSTR lpszEntryID = (LPSTR)GlobalLock(hEntryID);
        strcpy(lpszEntryID,pEntryIDs);
		XP_FREE (pEntryIDs);
        GlobalUnlock(hEntryID);
        pDataSource->CacheGlobalData(m_cfAddresses, hString);
		pDataSource->CacheGlobalData(m_cfSourceTarget, hEntryID);
		pDataSource->CacheGlobalData(CF_TEXT, hString);
    } */

    return pDataSource;
}


BOOL CDirOutliner::RenderData  ( UINT iColumn, CRect &rect, CDC &dc, const char * text )
{
	if ( iColumn != ID_COLDIR_TYPE )
        return CMSelectOutliner::RenderData ( iColumn, rect, dc, text );
	int idxImage;

    if (m_pDirLine->dirType == LDAPDirectory)
		idxImage = IDX_DIRLDAPAB;
	else
		idxImage = IDX_DIRPERSONALAB;

	m_pIUserImage->DrawImage ( idxImage,
		rect.left + ( ( rect.Width ( ) - 16 ) / 2 ), rect.top, &dc, FALSE );
	return TRUE;
}


int CDirOutliner::TranslateIcon ( void * pLineData )
{
	DIR_Server* line = (DIR_Server*) pLineData;
	int idxImage = 0;

    if (m_pDirLine->dirType == ABTypeList)
		idxImage = IDX_DIRLDAPAB;
	else
		idxImage = IDX_DIRPERSONALAB;
	return idxImage;
}

int CDirOutliner::TranslateIconFolder (void * pData)
{
	// We're a flat list, so we're never a folder
    return ( OUTLINER_ITEM );
}


BOOL CDirOutliner::ColumnCommand ( int iColumn, int iLine )
{
	// We have no column commands
    return FALSE;
}

void * CDirOutliner::AcquireLineData ( int line )
{
	m_lineindex = line + 1;
	if ( line >= m_iTotalLines)
		return NULL;
	m_pDirLine = (DIR_Server*) XP_ListGetObjectNum(theApp.m_directories, line + 1);

	return m_pDirLine;
}

void CDirOutliner::GetTreeInfo ( int iLine, uint32 * pFlags, int * pDepth, OutlinerAncestorInfo ** pAncestor )
{
    if ( pFlags ) *pFlags = 0; // Flags? 
    if ( pDepth ) *pDepth = 0; // We're flat, remember?
}

void CDirOutliner::ReleaseLineData ( void * )
{
}

LPCTSTR CDirOutliner::GetColumnText ( UINT iColumn, void * pLineData )
{
	DIR_Server* line = (DIR_Server*) pLineData;

	switch (iColumn) {
		case ID_COLDIR_NAME:
			return line->description;
			break;
		default:
			break;
	}
    return ("");
}

void CDirOutliner::OnSelChanged()
{
	MSG_ViewIndex *indices;
	int count;

	CAddrFrame* frame = (CAddrFrame*) GetParentFrame();
	if (frame->IsSearching()) 
		return;

	GetSelection(indices, count);

	if (count == 1) {
		frame->OnUpdateDirectorySelection(indices[0]);
	}
}

void CDirOutliner::OnSelDblClk()
{
	GetParentFrame()->SendMessage(WM_COMMAND, ID_ITEM_PROPERTIES, 0);
}


/////////////////////////////////////////////////////////////////////////////
// CAddrOutlinerParent

BEGIN_MESSAGE_MAP(CDirOutlinerParent, COutlinerParent)
	//{{AFX_MSG_MAP(CDirOutlinerParent)
	ON_WM_DESTROY()
	ON_WM_LBUTTONUP()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

CDirOutlinerParent::CDirOutlinerParent()
{

}


CDirOutlinerParent::~CDirOutlinerParent()
{
 
}


BOOL CDirOutlinerParent::RenderData ( int idColumn, CRect & rect, CDC &dc, const char * text )
{
	int cx = 3, cy = 0;
    CDirOutliner *pOutliner = (CDirOutliner *) m_pOutliner;
	
	// Calculate text offset from top using font height.
    TEXTMETRIC tm;
    dc.GetTextMetrics ( &tm );
    cy = ( rect.bottom - rect.top - tm.tmHeight ) / 2;
        
	// Draw Text String
	dc.TextOut (rect.left + cx, rect.top + cy, text, _tcslen(text) );
    
	// Draw Sort Indicator
	MSG_COMMAND_CHECK_STATE sortType = pOutliner->m_attribSortBy == idColumn ? MSG_Checked : MSG_Unchecked;

	int idxImage = pOutliner->m_bSortAscending ? IDX_SORTINDICATORDOWN : IDX_SORTINDICATORUP;
	CSize cs = dc.GetTextExtent(text, _tcslen(text));

	if (idColumn == pOutliner->m_attribSortBy && cs.cx + 22 <= rect.Width()) {
        m_pIImage->DrawTransImage( idxImage,
								   rect.left + 8 + cs.cx,
								   (rect.top + rect.bottom) / 2 - 4,
								   &dc );
	}

    return TRUE;
}

COutliner * CDirOutlinerParent::GetOutliner ( void )
{
    return new CDirOutliner;
}

void CDirOutlinerParent::CreateColumns ( void )
{
	int iCol0 = 0,
		iCol1 = 0;
	CString cs; 

	m_pOutliner->AddColumn ("",			ID_COLDIR_TYPE,		24, 0, ColumnFixed, 0, TRUE );
	cs.LoadString(IDS_USERNAME);
    m_pOutliner->AddColumn (cs,			ID_COLDIR_NAME,		1500, 0, ColumnVariable, iCol0 ? iCol0 : 1500 );
	m_pOutliner->SetHasPipes( FALSE );

	m_pOutliner->SetVisibleColumns(DEF_DIRVISIBLE_COLUMNS);
	m_pOutliner->LoadXPPrefs("mailnews.abook_dir_columns_win");
}

void CDirOutlinerParent::OnDestroy()
{
	int32 prefInt = ((CDirOutliner*)m_pOutliner)->GetSortBy();
	
	COutlinerParent::OnDestroy();
}

void CDirOutlinerParent::OnLButtonUp( UINT nFlags, CPoint point )
{
	BOOL bSaveColumns = (m_pOutliner && 
		(m_bResizeColumn || m_bDraggingHeader || m_iPusherHit))? TRUE : FALSE;
	COutlinerParent::OnLButtonUp(nFlags, point);
	if (bSaveColumns)
		m_pOutliner->SaveXPPrefs("mailnews.abook_dir_columns_win");
}

BOOL CDirOutlinerParent::ColumnCommand ( int idColumn )
{	
	ABID lastSelection;

	// no sorting for right now
	return TRUE;

	CDirOutliner *pOutliner = (CDirOutliner *) m_pOutliner;
	
	if (pOutliner->GetFocusLine() != -1)
		lastSelection = AB_GetEntryIDAt((AddressPane*) pOutliner->GetPane(), pOutliner->GetFocusLine());

	SetCursor ( theApp.LoadStandardCursor ( IDC_WAIT ) );

	if (idColumn == pOutliner->m_attribSortBy) {
		pOutliner->m_bSortAscending = !pOutliner->m_bSortAscending; 
	}
	else
		pOutliner->m_bSortAscending = TRUE;

	pOutliner->m_attribSortBy = idColumn;

	switch (idColumn) {
		case ID_COLDIR_TYPE:
			AB_Command(pOutliner->GetPane(), AB_SortByTypeCmd, 0, 0);
			break;
		case ID_COLDIR_NAME:
			AB_Command(pOutliner->GetPane(), AB_SortByFullNameCmd, 0, 0);
			break;
		default:
			AB_Command(pOutliner->GetPane(), AB_SortByFullNameCmd, 0, 0);
			break;
	}
	

	if (pOutliner->GetFocusLine() != -1) {
		uint32 index = AB_GetIndexOfEntryID ((AddressPane *) pOutliner->GetPane(), lastSelection);
		pOutliner->SelectItem (CASTINT(index));
		pOutliner->ScrollIntoView(CASTINT(index));
	}

	Invalidate();
	pOutliner->Invalidate();
	SetCursor ( theApp.LoadStandardCursor ( IDC_ARROW ) );
	return TRUE;
}


void WFE_MSGOpenAB()
{
	CAddrFrame::Open();
}


void CAddrFrame::UpdateMenu(HMENU hMenu, UINT &nID)
{
	// *** If you change the way this menu is built, you also need to
	// change CAddrFrame::FolderInfoFromMenuID

	MSG_Master *pMaster = WFE_MSGGetMaster();
	int i, j;
	MSG_FolderInfo **folderInfos;
	int32 iCount;
	MSG_FolderLine folderLine;
	char buffer[_MAX_PATH];

	j = 0;

	iCount = MSG_GetFolderChildren( pMaster, NULL, NULL, NULL );

	folderInfos = new MSG_FolderInfo*[iCount];
	if (folderInfos) {
		MSG_GetFolderChildren( pMaster, NULL, folderInfos, iCount );

		for ( i = 0; i < iCount; i++) {
			if ( MSG_GetFolderLineById( pMaster, folderInfos[ i ], &folderLine ) ) {
				if (j < 10) {
					sprintf( buffer, "&%d %s", j, folderLine.name);
				} else if ( j < 36 ) {
					sprintf( buffer, "&%c %s", 'a' + j - 10, folderLine.name);
				} else {
					sprintf( buffer, "  %s", folderLine.name);
				}
				::AppendMenu( hMenu, MF_STRING, nID, buffer);
				nID++;
				j++;
			}
		}
		delete [] folderInfos;
	}
}

void WFE_MSGBuildAddressBookPopup( HMENU hmenu, BOOL bAddSender )
{
	UINT nID;
	if (bAddSender)
		nID = FIRST_ADDSENDER_MENU_ID;
	else
		nID = FIRST_ADDALL_MENU_ID;
	HMENU hABAddMenu = CreatePopupMenu();
	HMENU hAddMenu = CreatePopupMenu();

	// ::AppendMenu( hmenu, MF_POPUP|MF_STRING, (UINT) hFileMenu, szLoadString( IDS_POPUP_FILE ) );
	::AppendMenu( hAddMenu, MF_STRING, ID_MESSAGE_ADDSENDER, szLoadString( IDS_POPUP_ADDSENDER ) );
	::AppendMenu( hAddMenu, MF_STRING, ID_MESSAGE_ADDALL, szLoadString( IDS_POPUP_ADDALL ) );
	::AppendMenu( hmenu, MF_STRING|MF_POPUP, (UINT) hAddMenu, szLoadString( IDS_POPUP_ADDTOADDRESSBOOK ) );
	::AppendMenu( hmenu, MF_SEPARATOR, 0, NULL );
	CAddrFrame::UpdateMenu( hABAddMenu, nID );
}