windows-xp/Source/XPSP1/NT/admin/snapin/dsadmin/uiutil.cpp

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 1999
//
//  File:      Util.cpp
//
//  Contents:  Utility functions
//
//  History:   08-Nov-99 JeffJon  Created
//             
//
//--------------------------------------------------------------------------

#include "stdafx.h"

#include "util.h"
#include "uiutil.h"
#include "dsutil.h"

#include "dsdlgs.h"
#include "helpids.h"


/////////////////////////////////////////////////////////////////////
// Combo box Utilities
//
int ComboBox_AddString(HWND hwndCombobox, UINT uStringId)
{
	ASSERT(IsWindow(hwndCombobox));
	CString str;
	VERIFY( str.LoadString(uStringId) );
	LRESULT i = SendMessage(hwndCombobox, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)str);
	Report(i >= 0);
	SendMessage(hwndCombobox, CB_SETITEMDATA, (WPARAM)i, uStringId);
	return (int)i;
}

void ComboBox_AddStrings(HWND hwndCombobox, const UINT rgzuStringId[])
{
	ASSERT(IsWindow(hwndCombobox));
	ASSERT(rgzuStringId != NULL);
	CString str;
	for (const UINT * puStringId = rgzuStringId; *puStringId != 0; puStringId++)
	{
		VERIFY( str.LoadString(*puStringId) );
		LRESULT i = SendMessage(hwndCombobox, CB_ADDSTRING, 0, (LPARAM)(LPCTSTR)str);
		Report(i >= 0);
		SendMessage(hwndCombobox, CB_SETITEMDATA, (WPARAM)i, *puStringId);
	}
}

int ComboBox_FindItemByLParam(HWND hwndCombobox, LPARAM lParam)
{
	ASSERT(IsWindow(hwndCombobox));
	Report(lParam != CB_ERR && "Ambiguous parameter.");
	LRESULT iItem = SendMessage(hwndCombobox, CB_GETCOUNT, 0, 0);
	ASSERT(iItem >= 0);
	while (iItem-- > 0)
	{
		LRESULT l = SendMessage(hwndCombobox, CB_GETITEMDATA, (WPARAM)iItem, 0);
		Report(l != CB_ERR);
		if (l == lParam)
    {
			return ((int)iItem);
    }
  }
	return -1;
}

int ComboBox_SelectItemByLParam(HWND hwndCombobox, LPARAM lParam)
{
	ASSERT(IsWindow(hwndCombobox));
	int iItem = ComboBox_FindItemByLParam(hwndCombobox, lParam);
	if (iItem >= 0)
	{
		SendMessage(hwndCombobox, CB_SETCURSEL, iItem, 0);
	}
	return iItem;
}


LPARAM ComboBox_GetSelectedItemLParam(HWND hwndCombobox)
{
	LRESULT iItem = SendMessage(hwndCombobox, CB_GETCURSEL, 0, 0);
	if (iItem < 0)
	{
		// No item selected
		return NULL;
	}
	LRESULT lParam = SendMessage(hwndCombobox, CB_GETITEMDATA, (WPARAM)iItem, 0);
	if (lParam == CB_ERR)
	{
		Report(FALSE && "Ambiguous return value.");
		return NULL;
	}
	return (LPARAM)lParam;
}

/////////////////////////////////////////////////////////////////////
// Dialog Utilities
//

HWND HGetDlgItem(HWND hdlg, INT nIdDlgItem)
{
	ASSERT(IsWindow(hdlg));
	ASSERT(IsWindow(GetDlgItem(hdlg, nIdDlgItem)));
	return GetDlgItem(hdlg, nIdDlgItem);
} // HGetDlgItem()

void SetDlgItemFocus(HWND hdlg, INT nIdDlgItem)
{
	SetFocus(HGetDlgItem(hdlg, nIdDlgItem));
}

void EnableDlgItem(HWND hdlg, INT nIdDlgItem, BOOL fEnable)
{
	EnableWindow(HGetDlgItem(hdlg, nIdDlgItem), fEnable);
}

void HideDlgItem(HWND hdlg, INT nIdDlgItem, BOOL fHideItem)
{
	HWND hwndCtl = HGetDlgItem(hdlg, nIdDlgItem);
	ShowWindow(hwndCtl, fHideItem ? SW_HIDE : SW_SHOW);
	EnableWindow(hwndCtl, !fHideItem);
}

void EnableDlgItemGroup(HWND hdlg,				// IN: Parent dialog of the controls
                        const UINT rgzidCtl[],	// IN: Group (array) of control Ids to be enabled (or disabled)
	                      BOOL fEnableAll)		// IN: TRUE => We want to enable the controls; FALSE => We want to disable the controls
{
	ASSERT(IsWindow(hdlg));
	ASSERT(rgzidCtl != NULL);
	for (const UINT * pidCtl = rgzidCtl; *pidCtl != 0; pidCtl++)
	{
		EnableWindow(HGetDlgItem(hdlg, *pidCtl), fEnableAll);
	}
} // EnableDlgItemGroup()


void HideDlgItemGroup(HWND hdlg,				// IN: Parent dialog of the controls
	                    const UINT rgzidCtl[],	// IN: Group (array) of control Ids to be shown (or hidden)
	                    BOOL fHideAll)			// IN: TRUE => We want to hide all the controls; FALSE => We want to show all the controls
{
	ASSERT(IsWindow(hdlg));
	ASSERT(rgzidCtl != NULL);
	for (const UINT * pidCtl = rgzidCtl; *pidCtl != 0; pidCtl++)
	{
		HideDlgItem(hdlg, *pidCtl, fHideAll);
	}
} // HideDlgItemGroup()

/////////////////////////////////////////////////////////////////////
// List View Utilities
//

void ListView_AddColumnHeaders(HWND hwndListview,		// IN: Handle of the listview we want to add columns
                              const TColumnHeaderItem rgzColumnHeader[])	// IN: Array of column header items
{
	RECT rcClient;
	INT cxTotalWidth;		// Total width of the listview control
	LV_COLUMN lvColumn;
	INT cxColumn;	// Width of the individual column
	CString str;

	ASSERT(IsWindow(hwndListview));
	ASSERT(rgzColumnHeader != NULL);

	GetClientRect(hwndListview, OUT &rcClient);
	cxTotalWidth = rcClient.right;
	
	for (INT i = 0; rgzColumnHeader[i].uStringId != 0; i++)
	{
		if (!str.LoadString(rgzColumnHeader[i].uStringId))
		{
			TRACE(L"Unable to load string Id=%d\n", rgzColumnHeader[i].uStringId);
			ASSERT(FALSE && "String not found");
			continue;
		}
		lvColumn.mask = LVCF_TEXT;
		lvColumn.pszText = (LPTSTR)(LPCTSTR)str;
		cxColumn = rgzColumnHeader[i].nColWidth;
		if (cxColumn > 0)
		{
			ASSERT(cxColumn <= 100);
			cxColumn = (cxTotalWidth * cxColumn) / 100;
			lvColumn.mask |= LVCF_WIDTH;
			lvColumn.cx = cxColumn;
		}

		int iColRet = ListView_InsertColumn(hwndListview, i, IN &lvColumn);
		Report(iColRet == i);
	} // for
} // ListView_AddColumnHeaders()

int ListView_AddString(HWND hwndListview,
                       const LPCTSTR psz,	// IN: String to insert
 	                     LPARAM lParam)		// IN: User-defined parameter
{
	ASSERT(IsWindow(hwndListview));
	ASSERT(psz != NULL);

	LV_ITEM lvItem;
	int iItem;
	GarbageInit(&lvItem, sizeof(lvItem));

	lvItem.mask = LVIF_TEXT | LVIF_PARAM;
	lvItem.lParam = lParam;
	lvItem.iSubItem = 0;
	lvItem.pszText = const_cast<LPTSTR>(psz);
	iItem = ListView_InsertItem(hwndListview, IN &lvItem);
	Report(iItem >= 0);
	return iItem;
} // ListView_AddString()

int ListView_AddStrings(HWND hwndListview,
	                      const LPCTSTR rgzpsz[],	// IN: Array of strings
	                      LPARAM lParam)			// IN: User-defined parameter
{
	ASSERT(IsWindow(hwndListview));
	ASSERT(rgzpsz != NULL);

	LV_ITEM lvItem;
	int iItem;
	GarbageInit(&lvItem, sizeof(lvItem));

	lvItem.mask = LVIF_TEXT | LVIF_PARAM;
	lvItem.lParam = lParam;
	lvItem.iSubItem = 0;
	lvItem.pszText = const_cast<LPTSTR>(rgzpsz[0]);
	iItem = ListView_InsertItem(hwndListview, IN &lvItem);
	Report(iItem >= 0);
	if (rgzpsz[0] == NULL)
  {
		return iItem;
  }

	lvItem.iItem = iItem;
	lvItem.mask = LVIF_TEXT;
	for (lvItem.iSubItem = 1 ; rgzpsz[lvItem.iSubItem] != NULL; lvItem.iSubItem++)
	{
		lvItem.pszText = const_cast<LPTSTR>(rgzpsz[lvItem.iSubItem]);
		VERIFY( ListView_SetItem(hwndListview, IN &lvItem) );
	}
	return iItem;
} // ListView_AddStrings()

void ListView_SelectItem(HWND hwndListview,
	                       int iItem)
{
	ASSERT(IsWindow(hwndListview));
	ASSERT(iItem >= 0);

	ListView_SetItemState(hwndListview, iItem, LVIS_SELECTED, LVIS_SELECTED);
} // ListView_SelectItem()

int ListView_GetSelectedItem(HWND hwndListview)
{
	ASSERT(IsWindow(hwndListview));
	return ListView_GetNextItem(hwndListview, -1, LVNI_SELECTED);
}

void ListView_SetItemString(HWND hwndListview,
	                          int iItem,
	                          int iSubItem,
	                          IN const CString& rstrText)
{
	ASSERT(IsWindow(hwndListview));
	ASSERT(iItem >= 0);
	ASSERT(iSubItem >= 0);
	ListView_SetItemText(hwndListview, iItem, iSubItem,
		const_cast<LPTSTR>((LPCTSTR)rstrText));
} // ListView_SetItemString()

int ListView_GetItemString(HWND hwndListview, 	
                           int iItem,
                           int iSubItem,
                           OUT CString& rstrText)
{
	ASSERT(IsWindow(hwndListview));
	if (iItem == -1)
	{
		// Find out the selected item
		iItem = ListView_GetSelectedItem(hwndListview);
		if (iItem == -1)
		{
			// No item selected
			rstrText.Empty();
			return -1;
		}
	}
	ASSERT(iItem >= 0);
	const int cchBuffer = 1024;	// Initial buffer
	TCHAR * psz = rstrText.GetBuffer(cchBuffer);
	ASSERT(psz != NULL);
	*psz = '\0';
	ListView_GetItemText(hwndListview, iItem, iSubItem, OUT psz, cchBuffer-1);
	rstrText.ReleaseBuffer();
	Report((rstrText.GetLength() < cchBuffer - 16) && "Buffer too small to hold entire string");
	rstrText.FreeExtra();
	return iItem;
} // ListView_GetItemString()

LPARAM ListView_GetItemLParam(HWND hwndListview,
	                            int iItem,
	                            int * piItem)	// OUT: OPTIONAL: Pointer to the index of the listview item
{
	ASSERT(IsWindow(hwndListview));
	Endorse(piItem == NULL);	// TRUE => Don't care about the index
	if (iItem == -1)
	{
		// Find out the selected item
		iItem = ListView_GetSelectedItem(hwndListview);
		if (iItem == -1)
		{
			// No item selected
			if (piItem != NULL)
      {
				*piItem = -1;
      }
			return NULL;
		}
	}
	ASSERT(iItem >= 0);
	if (piItem != NULL)
  {
		*piItem = iItem;
  }
	LV_ITEM lvItem;
	GarbageInit(&lvItem, sizeof(lvItem));
	lvItem.mask = LVIF_PARAM;
	lvItem.iItem = iItem;
	lvItem.iSubItem = 0;
	lvItem.lParam = 0;	// Just in case
	VERIFY(ListView_GetItem(hwndListview, OUT &lvItem));
	return lvItem.lParam;
} // ListView_GetItemLParam()

int ListView_FindString(HWND hwndListview,
                      	LPCTSTR pszTextSearch)
{
	ASSERT(IsWindow(hwndListview));
	ASSERT(pszTextSearch != NULL);

	LV_FINDINFO lvFindInfo;
	GarbageInit(&lvFindInfo, sizeof(lvFindInfo));
	lvFindInfo.flags = LVFI_STRING;
	lvFindInfo.psz = pszTextSearch;
	return ListView_FindItem(hwndListview, -1, &lvFindInfo);
} // ListView_FindString()

int ListView_FindLParam(HWND hwndListview,
	                      LPARAM lParam)
{
	ASSERT(IsWindow(hwndListview));

	LV_FINDINFO lvFindInfo;
	GarbageInit(&lvFindInfo, sizeof(lvFindInfo));
	lvFindInfo.flags = LVFI_PARAM;
	lvFindInfo.lParam = lParam;
	return ListView_FindItem(hwndListview, -1, &lvFindInfo);
} // ListView_FindLParam()

int ListView_SelectLParam(HWND hwndListview,
	                        LPARAM lParam)
{
	int iItem = ListView_FindLParam(hwndListview, lParam);
	if (iItem >= 0)
  {
		ListView_SelectItem(hwndListview, iItem);
	}
	else
	{
		TRACE2("ListView_SelectLParam() - Unable to find lParam=%x (%d).\n",
			lParam, lParam);
	}
	return iItem;
} // ListView_SelectLParam()


////////////////////////////////////////////////////////////////////////////
// CMultiselectErrorDialog
BEGIN_MESSAGE_MAP(CMultiselectErrorDialog, CDialog)
END_MESSAGE_MAP()

HRESULT CMultiselectErrorDialog::Initialize(CUINode** ppNodeArray,
                                            HRESULT* pErrorArray,
                                            UINT nErrorCount,
                                            PCWSTR pszTitle, 
                                            PCWSTR pszCaption,
                                            PCWSTR pszColumnHeader)
{
  ASSERT(ppNodeArray != NULL);
  ASSERT(pErrorArray != NULL);
  ASSERT(pszTitle != NULL);
  ASSERT(pszCaption != NULL);
  ASSERT(pszColumnHeader != NULL);

  if (ppNodeArray == NULL ||
      pErrorArray == NULL ||
      pszTitle == NULL ||
      pszCaption == NULL ||
      pszColumnHeader == NULL)
  {
    return E_POINTER;
  }

  m_ppNodeList = ppNodeArray;
  m_pErrorArray = pErrorArray;
  m_nErrorCount = nErrorCount;
  m_szTitle = pszTitle;
  m_szCaption = pszCaption;
  m_szColumnHeader = pszColumnHeader;

  return S_OK;
}

HRESULT CMultiselectErrorDialog::Initialize(PWSTR*    pPathArray,
                                            PWSTR*    pClassArray,
                                            HRESULT*  pErrorArray,
                                            UINT      nErrorCount,
                                            PCWSTR    pszTitle, 
                                            PCWSTR    pszCaption,
                                            PCWSTR    pszColumnHeader)
{
  ASSERT(pPathArray != NULL);
  ASSERT(pClassArray != NULL);
  ASSERT(pErrorArray != NULL);
  ASSERT(pszTitle != NULL);
  ASSERT(pszCaption != NULL);
  ASSERT(pszColumnHeader != NULL);

  if (pPathArray == NULL ||
      pClassArray == NULL ||
      pErrorArray == NULL ||
      pszTitle == NULL ||
      pszCaption == NULL ||
      pszColumnHeader == NULL)
  {
    return E_POINTER;
  }

  m_pPathArray = pPathArray;
  m_pClassArray = pClassArray;
  m_pErrorArray = pErrorArray;
  m_nErrorCount = nErrorCount;
  m_szTitle     = pszTitle;
  m_szCaption   = pszCaption;
  m_szColumnHeader = pszColumnHeader;

  return S_OK;
}

const int OBJ_LIST_NAME_COL_WIDTH = 100;
const int IDX_NAME_COL = 0;
const int IDX_ERR_COL = 1;

BOOL CMultiselectErrorDialog::OnInitDialog()
{
  CDialog::OnInitDialog();

  SetWindowText(m_szTitle);
  SetDlgItemText(IDC_STATIC_MESSAGE, m_szCaption);

  HWND hList = GetDlgItem(IDC_ERROR_LIST)->GetSafeHwnd();
  ListView_SetExtendedListViewStyle(hList, LVS_EX_FULLROWSELECT);

  //
  // Create the image list
  //
  m_hImageList = ImageList_Create(16, 16, ILC_COLOR | ILC_MASK, 1, 1);
  ASSERT(m_hImageList != NULL);
 
  if (m_hImageList != NULL)
  {
    ListView_SetImageList(hList, m_hImageList, LVSIL_SMALL);
  }

  //
  // Set the column headings.
  //
  RECT rect;
  ::GetClientRect(hList, &rect);

  LV_COLUMN lvc = {0};
  lvc.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
  lvc.fmt = LVCFMT_LEFT;
  lvc.cx = OBJ_LIST_NAME_COL_WIDTH;
  lvc.pszText = (PWSTR)(PCWSTR)m_szColumnHeader;
  lvc.iSubItem = IDX_NAME_COL;

  ListView_InsertColumn(hList, IDX_NAME_COL, &lvc);

  CString szError;
  VERIFY(szError.LoadString(IDS_ERROR));

  lvc.cx = rect.right - OBJ_LIST_NAME_COL_WIDTH;
  lvc.pszText = (PWSTR)(PCWSTR)szError;
  lvc.iSubItem = IDX_ERR_COL;

  ListView_InsertColumn(hList, IDX_ERR_COL, &lvc);

  //
  // Insert the errors
  //

  //
  // Use the node list if its not NULL
  //
  if (m_ppNodeList != NULL)
  {
    ASSERT(m_pErrorArray != NULL && m_ppNodeList != NULL);

    for (UINT nIdx = 0; nIdx < m_nErrorCount; nIdx++)
    {
      CUINode* pNode = m_ppNodeList[nIdx];
      if (pNode != NULL)
      {
        if (nIdx < m_nErrorCount && FAILED(m_pErrorArray[nIdx]))
        {
          //
          // Create the list view item
          //
          LV_ITEM lvi = {0};
          lvi.mask = LVIF_TEXT | LVIF_PARAM;
          lvi.iSubItem = IDX_NAME_COL;

          lvi.lParam = (LPARAM)pNode->GetName();
          lvi.pszText = (PWSTR)pNode->GetName();
          lvi.iItem = nIdx;

          if (m_hImageList != NULL)
          {
            //
            // REVIEW_JEFFJON : this will add multiple icons of the same class
            //                  need to provide a better means for managing the icons
            //
            CDSCookie* pCookie = GetDSCookieFromUINode(pNode);
            if (pCookie != NULL)
            {
              HICON icon = m_pComponentData->GetBasePathsInfo()->GetIcon(
                             // someone really blew it with const correctness...
                             const_cast<LPTSTR>(pCookie->GetClass()),
                             DSGIF_ISNORMAL | DSGIF_GETDEFAULTICON,
                             16,
                             16);
      
              int i = ::ImageList_AddIcon(m_hImageList, icon);
              ASSERT(i != -1);
              if (i != -1)
              {
                lvi.mask |= LVIF_IMAGE;
                lvi.iImage = i;
              }
            }
          }

          //
          // Insert the new item
          //
          int NewIndex = ListView_InsertItem(hList, &lvi);
          ASSERT(NewIndex != -1);
          if (NewIndex == -1)
          {
            continue;
          }

          //
          // Get the error message
          //
          PWSTR pszErrMessage;
          int iChar = cchLoadHrMsg(m_pErrorArray[nIdx], &pszErrMessage, TRUE);
      	  if (pszErrMessage != NULL && iChar > 0)
	        {
            ListView_SetItemText(hList, NewIndex, IDX_ERR_COL, pszErrMessage);
            LocalFree(pszErrMessage);
          }
        }
      }
    }
  }
  else if (m_pPathArray != NULL)   // if the node list is NULL then use the string list
  {
    ASSERT(m_pErrorArray != NULL && m_pPathArray != NULL);

    for (UINT nIdx = 0; nIdx < m_nErrorCount; nIdx++)
    {
      if (nIdx < m_nErrorCount && FAILED(m_pErrorArray[nIdx]))
      {
        //
        // Use the path cracker to retrieve the name of the object
        //
        PCWSTR pszPath = m_pPathArray[nIdx];
        CPathCracker pathCracker;
        VERIFY(SUCCEEDED(pathCracker.Set((BSTR)(PWSTR)pszPath, ADS_SETTYPE_DN)));
        VERIFY(SUCCEEDED(pathCracker.put_EscapedMode(ADS_ESCAPEDMODE_OFF_EX)));
        VERIFY(SUCCEEDED(pathCracker.SetDisplayType(ADS_DISPLAY_VALUE_ONLY)));

        CComBSTR bstrName;
        VERIFY(SUCCEEDED(pathCracker.GetElement(0, &bstrName)));

        //
        // Create the list view item
        //
        LV_ITEM lvi = {0};
        lvi.mask = LVIF_TEXT | LVIF_PARAM;
        lvi.iSubItem = IDX_NAME_COL;

        //
        // Make the LPARAM be the path to the object
        // Not used at this time but may be useful in 
        // the future for bringing up property pages or
        // other special features.
        //
        lvi.lParam = (LPARAM)m_pPathArray[nIdx];
        lvi.pszText = (PWSTR)bstrName;
        lvi.iItem = nIdx;

        if (m_hImageList != NULL)
        {
          //
          // REVIEW_JEFFJON : this will add multiple icons of the same class
          //                  need to provide a better means for managing the icons
          //
          ASSERT(m_pClassArray[nIdx] != NULL);
          HICON icon = m_pComponentData->GetBasePathsInfo()->GetIcon(
                         // someone really blew it with const correctness...
                         const_cast<LPTSTR>(m_pClassArray[nIdx]),
                         DSGIF_ISNORMAL | DSGIF_GETDEFAULTICON,
                         16,
                         16);
  
          int i = ::ImageList_AddIcon(m_hImageList, icon);
          ASSERT(i != -1);
          if (i != -1)
          {
            lvi.mask |= LVIF_IMAGE;
            lvi.iImage = i;
          }
        }

        //
        // Insert the new item
        //
        int NewIndex = ListView_InsertItem(hList, &lvi);
        ASSERT(NewIndex != -1);
        if (NewIndex == -1)
        {
          continue;
        }

        //
        // Get the error message
        //
        PWSTR pszErrMessage;
        int iChar = cchLoadHrMsg(m_pErrorArray[nIdx], &pszErrMessage, TRUE);
      	if (pszErrMessage != NULL && iChar > 0)
	      {
          //
          // REVIEW_JEFFJON : this is a hack to get rid of two extra characters
          //                  at the end of the error message
          //
          size_t iLen = wcslen(pszErrMessage);
          pszErrMessage[iLen - 2] = L'\0';
          
          ListView_SetItemText(hList, NewIndex, IDX_ERR_COL, pszErrMessage);
          LocalFree(pszErrMessage);
        }
      }
    }
  }
  UpdateListboxHorizontalExtent();
  return TRUE;
}

void CMultiselectErrorDialog::UpdateListboxHorizontalExtent()
{
  CListCtrl* pListView = reinterpret_cast<CListCtrl*>(GetDlgItem(IDC_ERROR_LIST));
  pListView->SetColumnWidth(IDX_ERR_COL, LVSCW_AUTOSIZE);
}

/////////////////////////////////////////////////////////////////////
// MFC Utilities
//
// CDialogEx
//

CDialogEx::CDialogEx(UINT nIDTemplate, CWnd * pParentWnd) : CDialog(nIDTemplate, pParentWnd)
{
}

HWND CDialogEx::HGetDlgItem(INT nIdDlgItem)
{
	return ::HGetDlgItem(m_hWnd, nIdDlgItem);
}

void CDialogEx::SetDlgItemFocus(INT nIdDlgItem)
{
	::SetDlgItemFocus(m_hWnd, nIdDlgItem);
}

void CDialogEx::EnableDlgItem(INT nIdDlgItem, BOOL fEnable)
{
	::EnableDlgItem(m_hWnd, nIdDlgItem, fEnable);
}

void CDialogEx::HideDlgItem(INT nIdDlgItem, BOOL fHideItem)
{
	::HideDlgItem(m_hWnd, nIdDlgItem, fHideItem);
}

/////////////////////////////////////////////////////////////////////////////////////
// CPropertyPageEx_Mine
//

CPropertyPageEx_Mine::CPropertyPageEx_Mine(UINT nIDTemplate) : CPropertyPage(nIDTemplate)
{
}

HWND CPropertyPageEx_Mine::HGetDlgItem(INT nIdDlgItem)
{
	return ::HGetDlgItem(m_hWnd, nIdDlgItem);
}

void CPropertyPageEx_Mine::SetDlgItemFocus(INT nIdDlgItem)
{
	::SetDlgItemFocus(m_hWnd, nIdDlgItem);
}

void CPropertyPageEx_Mine::EnableDlgItem(INT nIdDlgItem, BOOL fEnable)
{
	::EnableDlgItem(m_hWnd, nIdDlgItem, fEnable);
}

void CPropertyPageEx_Mine::HideDlgItem(INT nIdDlgItem, BOOL fHideItem)
{
	::HideDlgItem(m_hWnd, nIdDlgItem, fHideItem);
}

/////////////////////////////////////////////////////////////////////////////
// CProgressDialogBase

UINT CProgressDialogBase::s_nNextStepMessage = WM_USER + 100;

CProgressDialogBase::CProgressDialogBase(HWND hParentWnd)
: CDialog(IDD_PROGRESS, CWnd::FromHandle(hParentWnd))
{
  m_nSteps = 0;
  m_nCurrStep = 0;
  m_nTitleStringID = 0;
}

BEGIN_MESSAGE_MAP(CProgressDialogBase, CDialog)
	ON_WM_SHOWWINDOW()
  ON_WM_CLOSE()
	ON_MESSAGE(CProgressDialogBase::s_nNextStepMessage, OnNextStepMessage )
END_MESSAGE_MAP()

BOOL CProgressDialogBase::OnInitDialog() 
{
	CDialog::OnInitDialog();
	m_progressCtrl.SubclassDlgItem(IDC_PROG_BAR, this);

  if (m_nTitleStringID >0)
  {
    CString szTitle;
    if (szTitle.LoadString(m_nTitleStringID))
      SetWindowText(szTitle);
  }

  GetDlgItemText(IDC_PROG_STATIC, m_szProgressFormat);
  SetDlgItemText(IDC_PROG_STATIC, NULL);

  OnStart();
  
  ASSERT(m_nSteps > 0);
  if (m_nSteps == 0)
    PostMessage(WM_CLOSE);
#if _MFC_VER >= 0x0600
  m_progressCtrl.SetRange32(0, m_nSteps);
#else
  m_progressCtrl.SetRange(0, m_nSteps);
#endif

  //
  // We want to walk backwards through the list for UI performance reasons
  //
  m_nCurrStep = m_nSteps - 1;
  return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}


void CProgressDialogBase::OnShowWindow(BOOL bShow, UINT nStatus) 
{
	CDialog::OnShowWindow(bShow, nStatus);
	
  // kick the process
  if (bShow && (m_nSteps > 0) && (m_nCurrStep == m_nSteps - 1))
  {
    m_bDone = FALSE;
    PostMessage(s_nNextStepMessage);
  }
}

void CProgressDialogBase::OnClose() 
{
  OnEnd();
	CDialog::OnClose();
}

afx_msg LONG CProgressDialogBase::OnNextStepMessage( WPARAM, LPARAM)
{
  ASSERT(!m_bDone);
  BOOL bExit = FALSE;
  if (m_nCurrStep > 0)
  {
    m_progressCtrl.OffsetPos(1);
    _SetProgressText();
    if (!OnStep(m_nCurrStep--))
      bExit = TRUE; // aborted by user
	}
  else if (m_nCurrStep == 0)
  {
    m_progressCtrl.OffsetPos(1);
    _SetProgressText();
    OnStep(m_nCurrStep--);
    bExit = TRUE;
    m_bDone = TRUE;
  }
  else
  {
    bExit = TRUE;
    m_bDone = TRUE;
  }

  if (bExit)
  {
		PostMessage(WM_CLOSE);
  }
  else
  {
    MSG tempMSG;
		while(::PeekMessage(&tempMSG,NULL, 0, 0, PM_REMOVE))
		{
			DispatchMessage(&tempMSG);
		}
    PostMessage(s_nNextStepMessage);
	}
	return 0;
}

void CProgressDialogBase::_SetProgressText()
{
  CString szMessage;
  WCHAR szCurrStep[128], szMaxSteps[128];
  wsprintf(szCurrStep, L"%d",(m_nSteps - m_nCurrStep));
  wsprintf(szMaxSteps, L"%d",m_nSteps);
  szMessage.FormatMessage(m_szProgressFormat, szCurrStep, szMaxSteps);
  SetDlgItemText(IDC_PROG_STATIC, szMessage);
}

////////////////////////////////////////////////////////////////////////////
// CMultipleProgressDialogBase
//

CMultipleProgressDialogBase::~CMultipleProgressDialogBase()
{
  //
  // Delete the error reporting structures
  //
  if (m_phrArray != NULL)
  {
    delete[] m_phrArray;
  }

  if (m_pPathArray != NULL)
  {
    for (UINT nIdx = 0; nIdx < m_nErrorCount; nIdx++)
    {
      if (m_pPathArray[nIdx] != NULL)
      {
        delete[] m_pPathArray[nIdx];
      }
    }
    delete[] m_pPathArray;
    m_pPathArray = NULL;
  }

  if (m_pClassArray != NULL)
  {
    for (UINT nIdx = 0; nIdx < m_nErrorCount; nIdx++)
    {
      if (m_pClassArray[nIdx] != NULL)
      {
        delete[] m_pClassArray[nIdx];
      }
    }
    delete[] m_pClassArray;
    m_pClassArray = NULL;
  }
}

HRESULT CMultipleProgressDialogBase::AddError(HRESULT hr,
                                              PCWSTR pszPath,
                                              PCWSTR pszClass)
{
  //
  // Prepare the multiselect error handling structures if necessary
  //
  if (m_phrArray == NULL)
  {
    m_phrArray = new HRESULT[GetStepCount()];
  }

  if (m_pPathArray == NULL)
  {
    m_pPathArray = new PWSTR[GetStepCount()];
  }

  if (m_pClassArray == NULL)
  {
    m_pClassArray = new PWSTR[GetStepCount()];
  }

  if (m_phrArray == NULL    ||
      m_pPathArray == NULL  ||
      m_pClassArray == NULL)
  {
    return E_OUTOFMEMORY;
  }

  m_phrArray[m_nErrorCount] = hr;
  
  m_pPathArray[m_nErrorCount] = new WCHAR[wcslen(pszPath) + 1];
  if (m_pPathArray[m_nErrorCount] == NULL)
  {
    return E_OUTOFMEMORY;
  }
  wcscpy(m_pPathArray[m_nErrorCount], pszPath);

  m_pClassArray[m_nErrorCount] = new WCHAR[wcslen(pszClass) + 1];
  if (m_pClassArray[m_nErrorCount] == NULL)
  {
    return E_OUTOFMEMORY;
  }
  wcscpy(m_pClassArray[m_nErrorCount], pszClass);

  m_nErrorCount++;
  return S_OK;
}

void CMultipleProgressDialogBase::OnEnd()
{
  if (m_nErrorCount > 0)
  {
    if (m_pComponentData != NULL)
    {
      ASSERT(m_pPathArray != NULL);
      ASSERT(m_pClassArray != NULL);
      ASSERT(m_phrArray != NULL);

      CString szTitle;
      if (m_pComponentData->QuerySnapinType() == SNAPINTYPE_SITE)
      {
        VERIFY(szTitle.LoadString(IDS_SITESNAPINNAME));
      }
      else
      {
        VERIFY(szTitle.LoadString(IDS_DSSNAPINNAME));
      }

      CString szHeader;
      VERIFY(szHeader.LoadString(IDS_COLUMN_NAME));

      CString szCaption;
      GetCaptionString(szCaption);

      //
      // Initialize and show the multiselect error dialog
      //
      CMultiselectErrorDialog errorDlg(m_pComponentData);

      HRESULT hr = errorDlg.Initialize(m_pPathArray,
                                       m_pClassArray,
                                       m_phrArray,
                                       m_nErrorCount,
                                       szTitle,
                                       szCaption,
                                       szHeader);
      ASSERT(SUCCEEDED(hr));
      
      errorDlg.DoModal();
    }
    else
    {
      ASSERT(m_pComponentData != NULL);
    }
  }
  else
  {
    m_pComponentData->InvalidateSavedQueriesContainingObjects(m_szObjPathList);
  }
}

////////////////////////////////////////////////////////////////////////////
// CMultipleDeleteProgressDialog
//

void CMultipleDeleteProgressDialog::OnStart()
{
  SetStepCount(m_pDeleteHandler->GetItemCount());
  m_hWndOld = m_pDeleteHandler->GetParentHwnd();
  m_pDeleteHandler->SetParentHwnd(GetSafeHwnd());
  m_pDeleteHandler->m_confirmationUI.SetWindow(GetSafeHwnd());
}

BOOL CMultipleDeleteProgressDialog::OnStep(UINT i)
{
  BOOL bContinue = TRUE;
  CString szPath;
  CString szClass;

  HRESULT hr = m_pDeleteHandler->OnDeleteStep(i, 
                                              &bContinue,
                                              szPath,
                                              szClass,
                                              TRUE /*silent*/);
  if (FAILED(hr) && hr != E_FAIL)
  {
    AddError(hr, szPath, szClass);
  }
  m_szObjPathList.AddTail(szPath);
  return bContinue;
}

void CMultipleDeleteProgressDialog::OnEnd()
{
  CMultipleProgressDialogBase::OnEnd();
  m_pDeleteHandler->GetTransaction()->End();
  m_pDeleteHandler->SetParentHwnd(m_hWndOld);
  m_pDeleteHandler->m_confirmationUI.SetWindow(m_hWndOld);
}


/////////////////////////////////////////////////////////////////////////////
// CMultipleMoveProgressDialog
//

void CMultipleMoveProgressDialog::OnStart()
{
  SetStepCount(m_pMoveHandler->GetItemCount());
  m_hWndOld = m_pMoveHandler->GetParentHwnd();
  m_pMoveHandler->SetParentHwnd(GetSafeHwnd());
}

BOOL CMultipleMoveProgressDialog::OnStep(UINT i)
{
  BOOL bContinue = TRUE;
  CString szPath;
  CString szClass;

  HRESULT hr = m_pMoveHandler->_OnMoveStep(i, 
                                           &bContinue,
                                           szPath,
                                           szClass);
  if (FAILED(hr) && hr != E_FAIL && hr != E_POINTER)
  {
    AddError(hr, szPath, szClass);
  }
  m_szObjPathList.AddTail(szPath);
  return bContinue;
}

void CMultipleMoveProgressDialog::OnEnd() 
{
  CMultipleProgressDialogBase::OnEnd();
  m_pMoveHandler->GetTransaction()->End();
  m_pMoveHandler->SetParentHwnd(m_hWndOld);
}

/////////////////////////////////////////////////////////////////////////////
// CConfirmOperationDialog
//
void CConfirmOperationDialog::OnYes() 
{ 
  m_pTransaction->ReadFromCheckListBox(&m_extensionsList);
  EndDialog(IDYES);
}

/////////////////////////////////////////////////////////////////////////////
// CConfirmOperationDialog
//

CConfirmOperationDialog::CConfirmOperationDialog(HWND hParentWnd,
                                                 CDSNotifyHandlerTransaction* pTransaction)
: CDialog(IDD_CONFIRM_OPERATION_EXT, CWnd::FromHandle(hParentWnd))
{
  ASSERT(pTransaction != NULL);
  m_pTransaction = pTransaction;
  m_nTitleStringID = IDS_ERRMSG_TITLE;
}

BEGIN_MESSAGE_MAP(CConfirmOperationDialog, CDialog)
	ON_BN_CLICKED(IDYES, OnYes)
  ON_BN_CLICKED(IDNO, OnNo)
END_MESSAGE_MAP()

BOOL CConfirmOperationDialog::OnInitDialog() 
{
	CDialog::OnInitDialog();
	m_extensionsList.SubclassDlgItem(IDC_EXTENS_LIST, this);
  m_extensionsList.SetCheckStyle(BS_AUTOCHECKBOX);
	
  m_pTransaction->SetCheckListBox(&m_extensionsList);
  UpdateListBoxHorizontalExtent();

  if (m_nTitleStringID > 0)
  {
    CString szTitle;
    if (szTitle.LoadString(m_nTitleStringID))
      SetWindowText(szTitle);
  }

  SetDlgItemText(IDC_STATIC_OPERATION, m_lpszOperation);
  SetDlgItemText(IDC_STATIC_ASSOC_DATA, m_lpszAssocData);

  GetDlgItem(IDNO)->SetFocus();
  return FALSE; // we set focus

}

void CConfirmOperationDialog::UpdateListBoxHorizontalExtent()
{
	int nHorzExtent = 0;
	CClientDC dc(&m_extensionsList);
	int nItems = m_extensionsList.GetCount();
	for	(int i=0; i < nItems; i++)
	{
		TEXTMETRIC tm;
		VERIFY(dc.GetTextMetrics(&tm));
		CString szBuffer;
		m_extensionsList.GetText(i, szBuffer);
		CSize ext = dc.GetTextExtent(szBuffer,szBuffer.GetLength());
		nHorzExtent = max(ext.cx ,nHorzExtent); 
	}
	m_extensionsList.SetHorizontalExtent(nHorzExtent);
}

////////////////////////////////////////////////////////////////////////////////
// Message reporting and message boxes
//

//+----------------------------------------------------------------------------
//
//  Function:   ReportError
//
//  Sysnopsis:  Attempts to get a user-friendly error message from the system.
//
//  CODEWORK:   If called with hr == 0 (hrFallback case), this will generate
//              ptzSysMsg unnecessarily.
//
//-----------------------------------------------------------------------------
void ReportError(HRESULT hr, int nStr, HWND hWnd)
{
  TCHAR tzSysMsgBuf[255];

  TRACE (_T("*+*+* ReportError called with hr = %lx, nStr = %lx"), hr, nStr);

  if (S_OK == hr && 0 == nStr)
  {
    nStr = IDS_ERRMSG_DEFAULT_TEXT;
  }

  PTSTR ptzSysMsg = NULL;
  BOOL fDelSysMsg = TRUE;
  int cch = cchLoadHrMsg( hr, &ptzSysMsg, FALSE );
  if (!cch)
  {
    PTSTR ptzFallbackSysMsgFormat = NULL;
    BOOL fDelFallbackSysMsgFormat = TRUE;
    LoadStringToTchar(IDS_ERRMSG_FALLBACK_TEXT, &ptzFallbackSysMsgFormat);
    if (NULL == ptzFallbackSysMsgFormat)
    {
      ptzFallbackSysMsgFormat = TEXT("Active Directory failure with code '0x%08x'!");
      fDelFallbackSysMsgFormat = FALSE;
    }
    ptzSysMsg = (PTSTR)LocalAlloc(LPTR, (lstrlen(ptzFallbackSysMsgFormat)+10)*sizeof(TCHAR));
    if (NULL == ptzSysMsg)
    {
      ptzSysMsg = tzSysMsgBuf;
      fDelSysMsg = FALSE;
    }
    wsprintf(ptzSysMsg, ptzFallbackSysMsgFormat, hr);
    if (fDelFallbackSysMsgFormat)
    {
      delete ptzFallbackSysMsgFormat;
    }
  }

  PTSTR ptzMsg = ptzSysMsg;
  BOOL fDelMsg = FALSE;
  PTSTR ptzFormat = NULL;
  if (nStr)
  {
    LoadStringToTchar(nStr, &ptzFormat);
  }
  if (ptzFormat)
  {
    ptzMsg = new TCHAR[lstrlen(ptzFormat) + lstrlen(ptzSysMsg) + 1];
    if (ptzMsg)
    {
      wsprintf(ptzMsg, ptzFormat, ptzSysMsg);
      fDelMsg = TRUE;
    }
  }

  PTSTR ptzTitle = NULL;
  BOOL fDelTitle = TRUE;
  if (!LoadStringToTchar(IDS_ERRMSG_TITLE, &ptzTitle))
  {
    ptzTitle = TEXT("Active Directory");
    fDelTitle = FALSE;
  }

  if (ptzMsg)
  {
    MessageBox((hWnd)?hWnd:GetDesktopWindow(), ptzMsg, ptzTitle, MB_OK | MB_ICONINFORMATION);
  }

  if (fDelSysMsg && ptzSysMsg != NULL)
  {
    LocalFree(ptzSysMsg);
  }
  if (fDelTitle && ptzTitle != NULL)
  {
    delete ptzTitle;
  }
  if (fDelMsg && ptzMsg != NULL)
  {
    delete ptzMsg;
  }
  if (ptzFormat != NULL)
  {
    delete ptzFormat;
  }
}

int ReportMessageWorker(HWND hWnd,
                        DWORD dwMessageId,
                        UINT fuStyle,
                        PVOID* lpArguments,
                        int nArguments,
                        DWORD dwTitleId,
                        HRESULT hrFallback,
                        LPCTSTR pszHelpTopic = NULL,
                        MSGBOXCALLBACK lpfnMsgBoxCallback = NULL );

// Don't bother with LoadLibrary, MMC is hardlinked with HtmlHelp anyway
VOID CALLBACK MsgBoxStdCallback(LPHELPINFO pHelpInfo)
{
  ASSERT( NULL != pHelpInfo && NULL != pHelpInfo->dwContextId );
  TRACE(_T("MsgBoxStdCallback: CtrlId = %d, ContextId = \"%s\"\n"),
           pHelpInfo->iCtrlId, pHelpInfo->dwContextId);

  HtmlHelp( (HWND)pHelpInfo->hItemHandle,
             DSADMIN_LINKED_HELP_FILE,
             HH_DISPLAY_TOPIC,
             pHelpInfo->dwContextId );
}

int ReportMessageWorker(HWND hWnd,
                        DWORD dwMessageId,
                        UINT fuStyle,
                        PVOID* lpArguments,
                        int,
                        DWORD dwTitleId,
                        HRESULT hrFallback,
                        LPCTSTR pszHelpTopic,
                        MSGBOXCALLBACK lpfnMsgBoxCallback )
{
  ASSERT( !pszHelpTopic || !lpfnMsgBoxCallback );
  LPTSTR ptzFormat = NULL;
  LPTSTR ptzMessage = NULL;
  LPTSTR ptzTitle = NULL;
  int retval = MB_OK;
  do 
  {

    // load message format
    if (!LoadStringToTchar(dwMessageId, &ptzFormat))
    {
      ASSERT(FALSE);
      break;
    }

    // generate actual message
    int cch = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
                            | FORMAT_MESSAGE_FROM_STRING
                            | FORMAT_MESSAGE_ARGUMENT_ARRAY,
                            ptzFormat,
                            NULL,
                            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                            (PTSTR)&ptzMessage, 0, (va_list*)lpArguments);
    if (!cch)
    {
      ASSERT(FALSE);
      ReportError( hrFallback, 0, hWnd );
      break;
    }

      // load title string
	  if (0 == dwTitleId)
    {
      dwTitleId = IDS_ERRMSG_TITLE;
    }
    
    if (!LoadStringToTchar(dwTitleId, &ptzTitle))
    {
      ptzTitle = NULL;
    }

    // display actual message
    if ((fuStyle & S_MB_YES_TO_ALL) == S_MB_YES_TO_ALL) //use special message box
    { 
      if (fuStyle & MB_HELP)
      {
        ASSERT(FALSE); // not supported
        fuStyle &= ~MB_HELP;
      }
      retval = SpecialMessageBox(hWnd,
                                 ptzMessage,
                                 (NULL != ptzTitle) ? ptzTitle : TEXT("Active Directory"),
                                 fuStyle );
    } 
    else 
    {
      MSGBOXPARAMS mbp;
      ::ZeroMemory( &mbp, sizeof(mbp) );
      mbp.cbSize = sizeof(mbp);
      mbp.hwndOwner = hWnd;

      mbp.lpszText = ptzMessage;
      mbp.lpszCaption = (NULL != ptzTitle) ? ptzTitle : TEXT("Active Directory");
      mbp.dwStyle = fuStyle;
      mbp.dwContextHelpId = (DWORD_PTR)pszHelpTopic;
      mbp.lpfnMsgBoxCallback = (NULL == pszHelpTopic)
                                  ? lpfnMsgBoxCallback
                                  : MsgBoxStdCallback;
      
      //
      // Display the actual message box
      //
      retval = MessageBoxIndirect( &mbp );
    }
  } while (FALSE); // false loop

  //
  // cleanup
  //
  if (NULL != ptzFormat)
  {
    delete ptzFormat;
  }
  if (NULL != ptzMessage)
  {
    LocalFree(ptzMessage);
  }
  if (NULL != ptzTitle)
  {
    delete ptzTitle;
  }
  return retval;
}

int ReportMessageEx(HWND hWnd,
                    DWORD dwMessageId,
                    UINT fuStyle,
                    PVOID* lpArguments,
                    int nArguments,
                    DWORD dwTitleId,
                    LPCTSTR pszHelpTopic,
                    MSGBOXCALLBACK lpfnMsgBoxCallback )
{
	return ReportMessageWorker(
		hWnd,
		dwMessageId,
		fuStyle,
		lpArguments,
		nArguments,
		dwTitleId,
		0,
		pszHelpTopic,
		lpfnMsgBoxCallback );
}

int ReportErrorEx(HWND hWnd,
                  DWORD dwMessageId,
                  HRESULT hr,
                  UINT fuStyle,
                  PVOID* lpArguments,
                  int nArguments,
                  DWORD dwTitleId,
                  BOOL TryADsIErrors)
{
  LPTSTR ptzSysMsg = NULL;
  int retval = MB_OK;
  do 
  { // false loop
    // load message for this HRESULT
    int cch = cchLoadHrMsg( hr, &ptzSysMsg, TryADsIErrors );
    if (!cch)
    {
      //
      // JonN 5/10/01 375461 fallback message cleanup
      //

      // load message format
      LPTSTR ptzFormat = NULL;
      if (!LoadStringToTchar(IDS_ERRMSG_UNKNOWN_HR, &ptzFormat) || !ptzFormat)
      {
        ASSERT(FALSE);
        ReportError( hr, 0, hWnd );
        break;
      }

      // format in HRESULT
      cch = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
                          | FORMAT_MESSAGE_FROM_STRING
                          | FORMAT_MESSAGE_ARGUMENT_ARRAY,
                          ptzFormat,
                          NULL,
                          MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                          (PTSTR)&ptzSysMsg,
                          1, (va_list*)&hr);
      delete ptzFormat;
      if (!cch)
      {
        ReportError( hr, 0, hWnd );
        break;
      }
    }

    // prepare argument array
    PVOID* ppvArguments = (PVOID*)new BYTE[(nArguments+1)*sizeof(PVOID)];
    if (!ppvArguments)
    {
      ASSERT(ppvArguments );
      ReportError( hr, 0, hWnd);
      break;
    }

    ppvArguments[0] = ptzSysMsg;
    if (0 != nArguments)
    {
      ::CopyMemory( ppvArguments+1, lpArguments, nArguments*sizeof(PVOID) );
    }

    retval = ReportMessageWorker(hWnd,
                                 dwMessageId,
                                 fuStyle,
                                 ppvArguments,
                                 nArguments+1,
                                 dwTitleId,
                                 hr );

    delete[] ppvArguments;
    ppvArguments = 0;
  } while (FALSE); // false loop

  //
  // cleanup
  //
  if (NULL != ptzSysMsg)
  {
    LocalFree(ptzSysMsg);
  }
  return retval;
}

int SpecialMessageBox (HWND,
                       LPWSTR pwszMessage,
                       LPWSTR pwszTitle,
                       DWORD)
{
  CSpecialMessageBox MBDlg;
 
  MBDlg.m_title = pwszTitle;
  MBDlg.m_message = pwszMessage;

  int answer = (int)MBDlg.DoModal();
  return answer;
}


///////////////////////////////////////////////////////////////////////////
// CNameFormatterBase

HRESULT CNameFormatterBase::Initialize(IN MyBasePathsInfo* pBasePathInfo,
                    IN LPCWSTR lpszClassName, IN UINT nStringID)
{
  CString szFormatString;

  HRESULT hr = _ReadFromDS(pBasePathInfo, lpszClassName, szFormatString);
  if (FAILED(hr))
  {
    // nothing in the display specifiers, load from resource
    if (!szFormatString.LoadString(nStringID))
    {
      // if failed for some reason, use this default
      szFormatString = L"%<givenName> %<initials>. %<sn>";
    }
  }
  Initialize(szFormatString);
  return S_OK;
}


HRESULT CNameFormatterBase::_ReadFromDS(IN MyBasePathsInfo* pBasePathInfo,
                                    IN LPCWSTR lpszClassName,
                                    OUT CString& szFormatString)
{
  static LPCWSTR lpszObjectClass = L"displaySpecifier";
  static LPCWSTR lpszSettingsObjectFmt = L"cn=%s-Display";
  static LPCWSTR lpszFormatProperty = L"createDialog";

  szFormatString.Empty();

  if ( (pBasePathInfo == NULL) || 
        (lpszClassName == NULL) || (lpszClassName[0] == NULL) )
  {
    return E_INVALIDARG;
  }

  // get the display specifiers locale container (e.g. 409)
  CComPtr<IADsContainer> spLocaleContainer;
  HRESULT hr = pBasePathInfo->GetDisplaySpecifier(NULL, IID_IADsContainer, (void**)&spLocaleContainer);
  if (FAILED(hr))
    return hr;

  // bind to the settings object
  CString szSettingsObject;
  szSettingsObject.Format(lpszSettingsObjectFmt, lpszClassName);
  CComPtr<IDispatch> spIDispatchObject;
  hr = spLocaleContainer->GetObject((LPWSTR)lpszObjectClass, 
                                    (LPWSTR)(LPCWSTR)szSettingsObject, 
                                    &spIDispatchObject);
  if (FAILED(hr))
    return hr;

  CComPtr<IADs> spSettingsObject;
  hr = spIDispatchObject->QueryInterface(IID_IADs, (void**)&spSettingsObject);
  if (FAILED(hr))
    return hr;

  // get single valued property in string list form
  CComVariant var;
  hr = spSettingsObject->Get((LPWSTR)lpszFormatProperty, &var);
  if (FAILED(hr))
    return hr;

  if (var.vt != VT_BSTR)
    return E_UNEXPECTED;

  szFormatString = var.bstrVal;
  return S_OK;
}



BOOL CNameFormatterBase::Initialize(IN LPCWSTR lpszFormattingString)
{
  TRACE(L"CNameFormatterBase::Initialize(%s)\n", lpszFormattingString);
  _Clear();

  if (lpszFormattingString == NULL)
  {
    return FALSE;
  }

  // copy the formatting string (it will be modified)
  m_lpszFormattingString = new WCHAR[lstrlen(lpszFormattingString)+1];
  wcscpy(m_lpszFormattingString, lpszFormattingString);


  // allocate memory for the arrays
  _AllocateMemory(lpszFormattingString);

 // loop thugh the string and extract tokens

  // Establish string and get the first token
  WCHAR szSeparators[]   = L"%>";
  WCHAR* lpszToken = wcstok(m_lpszFormattingString, szSeparators);

  while (lpszToken != NULL)
  {
    // While there are tokens in "string"
    //TRACE( L" %s\n", token );
    
    if ( (lpszToken[0] == L'<') && 
         !((lpszFormattingString[0] == L'<') && (m_tokenArrCount == 0)) )
    {
      // parameter
      m_tokenArray[m_tokenArrCount].m_bIsParam = TRUE;
      m_tokenArray[m_tokenArrCount].m_nIndex = m_paramArrCount;
      m_lpszParamArr[m_paramArrCount++] = (lpszToken+1);
    }
    else
    {
      // constant
      m_tokenArray[m_tokenArrCount].m_bIsParam = FALSE;
      m_tokenArray[m_tokenArrCount].m_nIndex = m_constArrCount;
      m_lpszConstArr[m_constArrCount++] = lpszToken;
    }
    m_tokenArrCount++;

    /* Get next token: */
    lpszToken = wcstok(NULL, szSeparators);
  }  // while

  return TRUE;
}


void CNameFormatterBase::SetMapping(IN LPCWSTR* lpszArgMapping, IN int nArgCount)
{
  if (m_mapArr != NULL)
  {
    delete[] m_mapArr;
  }

  // do the mapping

  m_mapArr = new int[m_paramArrCount];

  for (int kk=0; kk<m_paramArrCount;kk++)
  {
    m_mapArr[kk] = -1; // clear
    for (int jj=0; jj<nArgCount;jj++)
    {
      if (wcscmp(m_lpszParamArr[kk], lpszArgMapping[jj]) == 0)
      {
        m_mapArr[kk] = jj;
      }
    }
  }

}

void CNameFormatterBase::Format(OUT CString& szBuffer, IN LPCWSTR* lpszArgArr)
{
  szBuffer.Empty();

  //TRACE(L"\nResult:#");

  BOOL bLastParamNull = FALSE;
  for (int k=0; k<m_tokenArrCount; k++)
  {
    if (m_tokenArray[k].m_bIsParam)
    {
      if (m_mapArr[m_tokenArray[k].m_nIndex] >= 0)
      {
        LPCWSTR lpszVal = lpszArgArr[m_mapArr[m_tokenArray[k].m_nIndex]];

        if (lpszVal != NULL)
        {
          //TRACE(L"%s", lpszVal);
          szBuffer += lpszVal;
          bLastParamNull = FALSE;
        }
        else
        {
          bLastParamNull = TRUE;
        }
      }
    }
    else
    {
      if (!bLastParamNull)
      {
        //TRACE(L"%s", m_lpszConstArr[m_tokenArray[k].m_nIndex]);
        szBuffer += m_lpszConstArr[m_tokenArray[k].m_nIndex];
      }
    }
  }
  szBuffer.TrimRight(); // in case we got a trailing space.
  //TRACE(L"#\n");
}



void CNameFormatterBase::_AllocateMemory(LPCWSTR lpszFormattingString)
{
  int nFieldCount = 1;  // conservative, have at least one
  for (WCHAR* pChar = (WCHAR*)lpszFormattingString; *pChar != NULL; pChar++)
  {
    if (*pChar == L'%')
    {
      nFieldCount++;
    }
  }

  // conservative estimates on array sizes
  m_tokenArray = new CToken[2*nFieldCount];
  m_lpszConstArr = new LPCWSTR[nFieldCount];
  m_lpszParamArr = new LPCWSTR[nFieldCount];

}



/////////////////////////////////////////////////////////////////////////////
// CHelpDialog

CHelpDialog::CHelpDialog(UINT uIDD, CWnd* pParentWnd) : 
    CDialog(uIDD, pParentWnd),
    m_hWndWhatsThis (0)
{
}

CHelpDialog::CHelpDialog(UINT uIDD) :
    CDialog(uIDD),
    m_hWndWhatsThis (0)
{
}

CHelpDialog::~CHelpDialog()
{
}

BEGIN_MESSAGE_MAP(CHelpDialog, CDialog)
	ON_WM_CONTEXTMENU()
  ON_MESSAGE(WM_HELP, OnHelp)
  ON_COMMAND(IDM_WHATS_THIS, OnWhatsThis)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CHelpDialog message handlers
void CHelpDialog::OnWhatsThis()
{
  //
  // Display context help for a control
  //
  if ( m_hWndWhatsThis )
  {
    DoContextHelp (m_hWndWhatsThis);
  }
}

BOOL CHelpDialog::OnHelp(WPARAM /*wParam*/, LPARAM lParam)
{
  const LPHELPINFO pHelpInfo = (LPHELPINFO)lParam;

  if (pHelpInfo && pHelpInfo->iContextType == HELPINFO_WINDOW)
  {
    //
    // Display context help for a control
    //
    DoContextHelp ((HWND) pHelpInfo->hItemHandle);
  }

  return TRUE;
}

void CHelpDialog::DoContextHelp (HWND /*hWndControl*/)
{
}

void CHelpDialog::OnContextMenu(CWnd* /*pWnd*/, CPoint point) 
{
  //
  // point is in screen coordinates
  //

  CMenu bar;
	if ( bar.LoadMenu(IDR_WHATS_THIS_CONTEXT_MENU1) )
	{
		CMenu& popup = *bar.GetSubMenu (0);
		ASSERT(popup.m_hMenu);

		if ( popup.TrackPopupMenu (TPM_RIGHTBUTTON | TPM_LEFTBUTTON,
			   point.x,     // in screen coordinates
				 point.y,     // in screen coordinates
			   this) )      // route commands through main window
		{
			m_hWndWhatsThis = 0;
			ScreenToClient (&point);
			CWnd* pChild = ChildWindowFromPoint (point,  // in client coordinates
					                                 CWP_SKIPINVISIBLE | CWP_SKIPTRANSPARENT);
			if ( pChild )
      {
				m_hWndWhatsThis = pChild->m_hWnd;
      }
	  }
	}
}

/////////////////////////////////////////////////////////////////////////////
// CHelpPropertyPage

CHelpPropertyPage::CHelpPropertyPage(UINT uIDD) : 
    CPropertyPage(uIDD),
    m_hWndWhatsThis (0)
{
}

CHelpPropertyPage::~CHelpPropertyPage()
{
}

BEGIN_MESSAGE_MAP(CHelpPropertyPage, CPropertyPage)
	ON_WM_CONTEXTMENU()
  ON_MESSAGE(WM_HELP, OnHelp)
  ON_COMMAND(IDM_WHATS_THIS, OnWhatsThis)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CHelpPropertyPage message handlers
void CHelpPropertyPage::OnWhatsThis()
{
  //
  // Display context help for a control
  //
  if ( m_hWndWhatsThis )
  {
    DoContextHelp (m_hWndWhatsThis);
  }
}

BOOL CHelpPropertyPage::OnHelp(WPARAM /*wParam*/, LPARAM lParam)
{
  const LPHELPINFO pHelpInfo = (LPHELPINFO)lParam;

  if (pHelpInfo && pHelpInfo->iContextType == HELPINFO_WINDOW)
  {
    //
    // Display context help for a control
    //
    DoContextHelp ((HWND) pHelpInfo->hItemHandle);
  }

  return TRUE;
}

void CHelpPropertyPage::DoContextHelp (HWND /*hWndControl*/)
{
}

void CHelpPropertyPage::OnContextMenu(CWnd* /*pWnd*/, CPoint point) 
{
  //
  // point is in screen coordinates
  //

  CMenu bar;
	if ( bar.LoadMenu(IDR_WHATS_THIS_CONTEXT_MENU1) )
	{
		CMenu& popup = *bar.GetSubMenu (0);
		ASSERT(popup.m_hMenu);

		if ( popup.TrackPopupMenu (TPM_RIGHTBUTTON | TPM_LEFTBUTTON,
			   point.x,     // in screen coordinates
				 point.y,     // in screen coordinates
			   this) )      // route commands through main window
		{
			m_hWndWhatsThis = 0;
			ScreenToClient (&point);
			CWnd* pChild = ChildWindowFromPoint (point,  // in client coordinates
					                                 CWP_SKIPINVISIBLE | CWP_SKIPTRANSPARENT);
			if ( pChild )
      {
				m_hWndWhatsThis = pChild->m_hWnd;
      }
	  }
	}
}

//////////////////////////////////////////////////////////////////
// CMoreInfoMessageBox
//

BEGIN_MESSAGE_MAP(CMoreInfoMessageBox, CDialog)
	ON_BN_CLICKED(ID_BUTTON_MORE_INFO, OnMoreInfo)
END_MESSAGE_MAP()