/////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 1996-2000 Microsoft Corporation
//
//  Module Name:
//      LCPair.cpp
//
//  Abstract:
//      Implementation of the CListCtrlPair class.
//
//  Author:
//      David Potter (davidp)   August 8, 1996
//
//  Revision History:
//
//  Notes:
//
/////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "CluAdmin.h"
#include "LCPair.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CListCtrlPair
/////////////////////////////////////////////////////////////////////////////

IMPLEMENT_DYNAMIC(CListCtrlPair, CCmdTarget)

/////////////////////////////////////////////////////////////////////////////
// Message Maps

BEGIN_MESSAGE_MAP(CListCtrlPair, CCmdTarget)
    //{{AFX_MSG_MAP(CListCtrlPair)
    //}}AFX_MSG_MAP
    ON_BN_CLICKED(IDC_LCP_ADD, OnAdd)
    ON_BN_CLICKED(IDC_LCP_REMOVE, OnRemove)
    ON_BN_CLICKED(IDC_LCP_PROPERTIES, OnProperties)
    ON_NOTIFY(NM_DBLCLK, IDC_LCP_LEFT_LIST, OnDblClkLeftList)
    ON_NOTIFY(NM_DBLCLK, IDC_LCP_RIGHT_LIST, OnDblClkRightList)
    ON_NOTIFY(LVN_ITEMCHANGED, IDC_LCP_LEFT_LIST, OnItemChangedLeftList)
    ON_NOTIFY(LVN_ITEMCHANGED, IDC_LCP_RIGHT_LIST, OnItemChangedRightList)
    ON_NOTIFY(LVN_COLUMNCLICK, IDC_LCP_LEFT_LIST, OnColumnClickLeftList)
    ON_NOTIFY(LVN_COLUMNCLICK, IDC_LCP_RIGHT_LIST, OnColumnClickRightList)
    ON_COMMAND(ID_FILE_PROPERTIES, OnProperties)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::CListCtrlPair
//
//  Routine Description:
//      Default constructor.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CListCtrlPair::CListCtrlPair(void)
{
    CommonConstruct();

}  //*** CListCtrlPair::CListCtrlPair()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::CListCtrlPair
//
//  Routine Description:
//      Cconstructor.
//
//  Arguments:
//      pdlg            [IN OUT] Dialog to which controls belong.
//      plpobjRight     [IN OUT] List for the right list control.
//      plpobjLeft      [IN] List for the left list control.
//      dwStyle         [IN] Style:
//                          LCPS_SHOW_IMAGES    Show images to left of items.
//                          LCPS_ALLOW_EMPTY    Allow right list to be empty.
//      pfnGetColumn    [IN] Function pointer for retrieving columns.
//      pfnDisplayProps [IN] Function pointer for displaying properties.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CListCtrlPair::CListCtrlPair(
    IN OUT CDialog *            pdlg,
    IN OUT CClusterItemList *   plpobjRight,
    IN const CClusterItemList * plpobjLeft,
    IN DWORD                    dwStyle,
    IN PFNLCPGETCOLUMN          pfnGetColumn,
    IN PFNLCPDISPPROPS          pfnDisplayProps
    )
{
    ASSERT(pfnGetColumn != NULL);
    ASSERT(pfnDisplayProps != NULL);

    CommonConstruct();

    m_pdlg = pdlg;

    if (plpobjRight != NULL)
        m_plpobjRight = plpobjRight;
    if (plpobjLeft != NULL)
        m_plpobjLeft = plpobjLeft;

    m_dwStyle = dwStyle;

    m_pfnGetColumn = pfnGetColumn;
    m_pfnDisplayProps = pfnDisplayProps;

}  //*** CListCtrlPair::CListCtrlPair()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::CommonConstruct
//
//  Routine Description:
//      Common construction.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CListCtrlPair::CommonConstruct(void)
{
    m_pdlg = NULL;
    m_plpobjLeft = NULL;
    m_plpobjRight = NULL;
    m_dwStyle = LCPS_ALLOW_EMPTY;
    m_pfnGetColumn = NULL;
    m_plcFocusList = NULL;

    // Set the sort info.
    SiLeft().m_nDirection = -1;
    SiLeft().m_nColumn = -1;
    SiRight().m_nDirection = -1;
    SiRight().m_nColumn = -1;

}  //*** CListCtrlPair::CommonConstruct()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::NAddColumn
//
//  Routine Description:
//      Add a column to the list of columns displayed in each list control.
//
//  Arguments:
//      idsText     [IN] String resource ID for text to display on column.
//      nWidth      [IN] Initial width of the column.
//
//  Return Value:
//      icol        Index of the column.
//
//  Exceptions Thrown:
//      Any exceptions thrown by CArray::Add.
//--
/////////////////////////////////////////////////////////////////////////////
int CListCtrlPair::NAddColumn(IN IDS idsText, IN int nWidth)
{
    CColumn     col;

    ASSERT(idsText != 0);
    ASSERT(nWidth > 0);
    ASSERT(LpobjRight().GetCount() == 0);

    col.m_idsText = idsText;
    col.m_nWidth = nWidth;

    return (int)m_aColumns.Add(col);

}  //*** CListCtrlPair::NAddColumn()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::DoDataExchange
//
//  Routine Description:
//      Do data exchange between the dialog and the class.
//
//  Arguments:
//      pDX     [IN OUT] Data exchange object
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CListCtrlPair::DoDataExchange(CDataExchange * pDX)
{
    DDX_Control(pDX, IDC_LCP_RIGHT_LIST, m_lcRight);
    DDX_Control(pDX, IDC_LCP_LEFT_LIST, m_lcLeft);
    DDX_Control(pDX, IDC_LCP_ADD, m_pbAdd);
    DDX_Control(pDX, IDC_LCP_REMOVE, m_pbRemove);
    if (BPropertiesButton())
        DDX_Control(pDX, IDC_LCP_PROPERTIES, m_pbProperties);

    if (pDX->m_bSaveAndValidate)
    {
        // Verify that the list is not empty.
        if (!BAllowEmpty() && (m_lcRight.GetItemCount() == 0))
        {
            CString     strMsg;
            CString     strLabel;
            TCHAR *     pszLabel;
            TCHAR       szStrippedLabel[1024];
            int         iSrc;
            int         iDst;
            TCHAR       ch;

            DDX_Text(pDX, IDC_LCP_RIGHT_LABEL, strLabel);

            // Remove ampersands (&) and colons (:).
            pszLabel = strLabel.GetBuffer(1);
            for (iSrc = 0, iDst = 0 ; pszLabel[iSrc] != _T('\0') ; iSrc++)
            {
                ch = pszLabel[iSrc];
                if ((ch != _T('&')) && (ch != _T(':')))
                    szStrippedLabel[iDst++] = ch;
            }  // for:  each character in the label
            szStrippedLabel[iDst] = _T('\0');

            strMsg.FormatMessage(IDS_EMPTY_RIGHT_LIST, szStrippedLabel);
            ::AfxMessageBox(strMsg, MB_OK | MB_ICONWARNING);

            strMsg.Empty();
            pDX->Fail();
        }  // if:  list is empty and isn't allowed to be
    }  // if:  saving data from the dialog
    else
    {
        // Fill the lists.
        if (m_plpobjRight != NULL)
            FillList(m_lcRight, LpobjRight());
        if (m_plpobjLeft != NULL)
            FillList(m_lcLeft, LpobjLeft());
    }  // else:  setting data to the dialog

}  //*** CListCtrlPair::DoDataExchange()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::OnInitDialog
//
//  Routine Description:
//      Handler for the WM_INITDIALOG message.
//
//  Arguments:
//      None.
//
//  Return Value:
//      TRUE    Focus needs to be set.
//      FALSE   Focus already set.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CListCtrlPair::OnInitDialog(void)
{
    ASSERT_VALID(Pdlg());
    ASSERT(PlpobjRight() != NULL);
    ASSERT(PlpobjLeft() != NULL);

    Pdlg()->UpdateData(FALSE /*bSaveAndValidate*/);

    if (BShowImages())
    {
        CClusterAdminApp *  papp    = GetClusterAdminApp();

        m_lcLeft.SetImageList(papp->PilSmallImages(), LVSIL_SMALL);
        m_lcRight.SetImageList(papp->PilSmallImages(), LVSIL_SMALL);
    }  // if:  showing images
    
    // Disable buttons by default.
    m_pbAdd.EnableWindow(FALSE);
    m_pbRemove.EnableWindow(FALSE);
    if (BPropertiesButton())
        m_pbProperties.EnableWindow(FALSE);

    // Set the right list to sort.  Set both to show selection always.
    m_lcRight.ModifyStyle(0, LVS_SHOWSELALWAYS | LVS_SORTASCENDING, 0);
    m_lcLeft.ModifyStyle(0, LVS_SHOWSELALWAYS, 0);

    // Change list view control extended styles.
    {
        DWORD   dwExtendedStyle;

        // Left control.
        dwExtendedStyle = (DWORD)m_lcLeft.SendMessage(LVM_GETEXTENDEDLISTVIEWSTYLE);
        m_lcLeft.SendMessage(
            LVM_SETEXTENDEDLISTVIEWSTYLE,
            0,
            dwExtendedStyle
                | LVS_EX_FULLROWSELECT
                | LVS_EX_HEADERDRAGDROP
            );

        // Right control.
        dwExtendedStyle = (DWORD)m_lcRight.SendMessage(LVM_GETEXTENDEDLISTVIEWSTYLE);
        m_lcRight.SendMessage(
            LVM_SETEXTENDEDLISTVIEWSTYLE,
            0,
            dwExtendedStyle
                | LVS_EX_FULLROWSELECT
                | LVS_EX_HEADERDRAGDROP
            );
    }  // Change list view control extended styles

    try
    {
        // Duplicate lists.
        DuplicateLists();

        // Insert all the columns.
        {
            int         icol;
            int         ncol;
            int         nUpperBound = (int)m_aColumns.GetUpperBound();
            CString     strColText;

            ASSERT(nUpperBound >= 0);

            for (icol = 0 ; icol <= nUpperBound ; icol++)
            {
                strColText.LoadString(m_aColumns[icol].m_idsText);
                ncol = m_lcLeft.InsertColumn(icol, strColText, LVCFMT_LEFT, m_aColumns[icol].m_nWidth, 0);
                ASSERT(ncol == icol);
                ncol = m_lcRight.InsertColumn(icol, strColText, LVCFMT_LEFT, m_aColumns[icol].m_nWidth, 0);
                ASSERT(ncol == icol);
            }  // for:  each column
        }  // Insert all the columns
    }  // try
    catch (CException * pe)
    {
        pe->Delete();
    }  // catch:  CException

    Pdlg()->UpdateData(FALSE /*bSaveAndValidate*/);

    // If read-only, set all controls to be either disabled or read-only.
    if (BReadOnly())
    {
        m_lcRight.EnableWindow(FALSE);
        m_lcLeft.EnableWindow(FALSE);
    }  // if:  sheet is read-only

    return TRUE;    // return TRUE unless you set the focus to a control
                    // EXCEPTION: OCX Property Pages should return FALSE

}  //*** CListCtrlPair::OnInitDialog()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::OnSetActive
//
//  Routine Description:
//      Handler for the PSN_SETACTIVE message.
//
//  Arguments:
//      None.
//
//  Return Value:
//      TRUE    Page successfully initialized.
//      FALSE   Page not initialized.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CListCtrlPair::OnSetActive(void)
{
    UINT    nSelCount;

    // Set the focus to the left list.
    m_lcLeft.SetFocus();
    m_plcFocusList = &m_lcLeft;

    // Enable/disable the Properties button.
    nSelCount = m_lcLeft.GetSelectedCount();
    if (BPropertiesButton())
        m_pbProperties.EnableWindow(nSelCount == 1);

    // Enable or disable the other buttons.
    if (!BReadOnly())
    {
        m_pbAdd.EnableWindow(nSelCount > 0);
        nSelCount = m_lcRight.GetSelectedCount();
        m_pbRemove.EnableWindow(nSelCount > 0);
    }  // if:  not read-only page

    return TRUE;

}  //*** CListCtrlPair::OnSetActive()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::BSaveChanges
//
//  Routine Description:
//      Handler for the BN_CLICKED message on the OK button.
//
//  Arguments:
//      None.
//
//  Return Value:
//      TRUE        Changes saved successfully.
//      FALSE       Error saving changes.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CListCtrlPair::BSaveChanges(void)
{
    POSITION        pos;
    CClusterItem *  pci;

    ASSERT(!BIsStyleSet(LCPS_DONT_OUTPUT_RIGHT_LIST));
    ASSERT(!BReadOnly());

    // Update the data first.
    if (!Pdlg()->UpdateData(TRUE /*bSaveAndValidate*/))
        return FALSE;

    // Copy the Nodes list.
    PlpobjRight()->RemoveAll();
    pos = LpobjRight().GetHeadPosition();
    while (pos != NULL)
    {
        pci = LpobjRight().GetNext(pos);
        ASSERT_VALID(pci);
        VERIFY(PlpobjRight()->AddTail(pci) != NULL);
    }  // while:  more items in the list

    return TRUE;

}  //*** CListCtrlPair::BSaveChanges()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::OnAdd
//
//  Routine Description:
//      Handler for the BN_CLICKED message on the Add button.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CListCtrlPair::OnAdd(void)
{
    ASSERT(!BReadOnly());

    // Move selected items from the left list to the right list.
    MoveItems(m_lcRight, LpobjRight(), m_lcLeft, LpobjLeft());

}  //*** CListCtrlPair::OnAdd()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::OnRemove
//
//  Routine Description:
//      Handler for the BN_CLICKED message on the Remove button.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CListCtrlPair::OnRemove(void)
{
    ASSERT(!BReadOnly());

    // Move selected items from the right list to the left list.
    MoveItems(m_lcLeft, LpobjLeft(), m_lcRight, LpobjRight());

}  //*** CListCtrlPair::OnRemove()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::OnProperties
//
//  Routine Description:
//      Handler for the BN_CLICKED message on the Properties button.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CListCtrlPair::OnProperties(void)
{
    int         iitem;
    CObject *   pobj;

    ASSERT(m_plcFocusList != NULL);
    ASSERT(m_pfnDisplayProps != NULL);

    // Get the index of the item with the focus.
    iitem = m_plcFocusList->GetNextItem(-1, LVNI_FOCUSED);
    ASSERT(iitem != -1);

    // Get a pointer to the selected item.
    pobj = (CObject *) m_plcFocusList->GetItemData(iitem);
    ASSERT_VALID(pobj);

    if ((*m_pfnDisplayProps)(pobj))
    {
        // Update this item.
        {
            CString     strText;
            int         iimg;
            int         icol;

            ASSERT(m_pfnGetColumn != NULL);
            ASSERT(Pdlg() != NULL);
            (*m_pfnGetColumn)(pobj, iitem, 0, Pdlg(), strText, &iimg);
            m_plcFocusList->SetItem(iitem, 0, LVIF_TEXT | LVIF_IMAGE, strText, iimg, 0, 0, 0);

            for (icol = 1 ; icol <= m_aColumns.GetUpperBound() ; icol++)
            {
                (*m_pfnGetColumn)(pobj, iitem, icol, Pdlg(), strText, NULL);
                m_plcFocusList->SetItemText(iitem, icol, strText);
            }  // for:  each column
        }  // Update this item
    }  // if:  properties changed

}  //*** CListCtrlPair::OnProperties()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::OnContextMenu
//
//  Routine Description:
//      Handler for the WM_CONTEXTMENU method.
//
//  Arguments:
//      pWnd        Window in which the user right clicked the mouse.
//      point       Position of the cursor, in screen coordinates.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CListCtrlPair::OnContextMenu(CWnd * pWnd, CPoint point)
{
    BOOL            bHandled    = FALSE;
    CMenu *         pmenu       = NULL;
    CListCtrl *     pListCtrl   = (CListCtrl *) pWnd;
    CString         strMenuName;
    CWaitCursor     wc;

    // If focus is not in the list control, don't handle the message.
    if ( ( pWnd != &m_lcRight ) && ( pWnd != &m_lcLeft ) )
    {
        return FALSE;
    } // if: focus not in list control

    // Create the menu to display.
    try
    {
        pmenu = new CMenu;
        if ( pmenu == NULL )
        {
            AfxThrowMemoryException();
        } // if: error allocating the memory

        if ( pmenu->CreatePopupMenu() )
        {
            UINT    nFlags  = MF_STRING;

            // If there are no items in the list, disable the menu item.
            if ( pListCtrl->GetItemCount() == 0 )
            {
                nFlags |= MF_GRAYED;
            } // if: no items in the list

            // Add the Properties item to the menu.
            strMenuName.LoadString( IDS_MENU_PROPERTIES );
            if ( pmenu->AppendMenu( nFlags, ID_FILE_PROPERTIES, strMenuName ) )
            {
                m_plcFocusList = pListCtrl;
                bHandled = TRUE;
            }  // if:  successfully added menu item
        }  // if:  menu created successfully
    }  // try
    catch ( CException * pe )
    {
        pe->ReportError();
        pe->Delete();
    }  // catch:  CException

    if ( bHandled )
    {
        // Display the menu.
        if ( ! pmenu->TrackPopupMenu(
                        TPM_LEFTALIGN | TPM_RIGHTBUTTON,
                        point.x,
                        point.y,
                        Pdlg()
                        ) )
        {
        }  // if:  unsuccessfully displayed the menu
    }  // if:  there is a menu to display

    delete pmenu;
    return bHandled;

}  //*** CListCtrlPair::OnContextMenu()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::OnDblClkLeftList
//
//  Routine Description:
//      Handler method for the NM_DBLCLK message for the left list.
//
//  Arguments:
//      pNMHDR      Notification message structure.
//      pResult     Place in which to return the result.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CListCtrlPair::OnDblClkLeftList(NMHDR * pNMHDR, LRESULT * pResult)
{
    ASSERT(!BReadOnly());

    m_plcFocusList = &m_lcLeft;
    OnAdd();
    *pResult = 0;

}  //*** CListCtrlPair::OnDblClkLeftList()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::OnDblClkRightList
//
//  Routine Description:
//      Handler method for the NM_DBLCLK message for the right list.
//
//  Arguments:
//      pNMHDR      Notification message structure.
//      pResult     Place in which to return the result.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CListCtrlPair::OnDblClkRightList(NMHDR * pNMHDR, LRESULT * pResult)
{
    ASSERT(!BReadOnly());

    m_plcFocusList = &m_lcRight;
    OnRemove();
    *pResult = 0;

}  //*** CListCtrlPair::OnDblClkRightList()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::OnItemChangedLeftList
//
//  Routine Description:
//      Handler method for the LVN_ITEMCHANGED message in the left list.
//
//  Arguments:
//      pNMHDR      [IN OUT] WM_NOTIFY structure.
//      pResult     [OUT] LRESULT in which to return the result of this operation.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CListCtrlPair::OnItemChangedLeftList(NMHDR * pNMHDR, LRESULT * pResult)
{
    NM_LISTVIEW * pNMListView = (NM_LISTVIEW *) pNMHDR;

    m_plcFocusList = &m_lcLeft;

    // If the selection changed, enable/disable the Add button.
    if ((pNMListView->uChanged & LVIF_STATE)
            && ((pNMListView->uOldState & LVIS_SELECTED)
                    || (pNMListView->uNewState & LVIS_SELECTED))
            && !BReadOnly())
    {
        UINT    cSelected = m_plcFocusList->GetSelectedCount();

        // If there is a selection, enable the Add button.  Otherwise disable it.
        m_pbAdd.EnableWindow((cSelected == 0) ? FALSE : TRUE);
        if (BPropertiesButton())
            m_pbProperties.EnableWindow((cSelected == 1) ? TRUE : FALSE);
    }  // if:  selection changed

    *pResult = 0;

}  //*** CListCtrlPair::OnItemChangedLeftList()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::OnItemChangedRightList
//
//  Routine Description:
//      Handler method for the LVN_ITEMCHANGED message in the right list.
//
//  Arguments:
//      pNMHDR      [IN OUT] WM_NOTIFY structure.
//      pResult     [OUT] LRESULT in which to return the result of this operation.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CListCtrlPair::OnItemChangedRightList(NMHDR * pNMHDR, LRESULT * pResult)
{
    NM_LISTVIEW *   pNMListView = (NM_LISTVIEW *) pNMHDR;

    m_plcFocusList = &m_lcRight;

    // If the selection changed, enable/disable the Remove button.
    if ((pNMListView->uChanged & LVIF_STATE)
            && ((pNMListView->uOldState & LVIS_SELECTED)
                    || (pNMListView->uNewState & LVIS_SELECTED))
            && !BReadOnly())
    {
        UINT    cSelected = m_plcFocusList->GetSelectedCount();

        // If there is a selection, enable the Remove button.  Otherwise disable it.
        m_pbRemove.EnableWindow((cSelected == 0) ? FALSE : TRUE);
        if (BPropertiesButton())
            m_pbProperties.EnableWindow((cSelected == 1) ? TRUE : FALSE);
    }  // if:  selection changed

    *pResult = 0;

}  //*** CListCtrlPair::OnItemChangedRightList()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::OnColumnClickLeftList
//
//  Routine Description:
//      Handler method for the LVN_COLUMNCLICK message on the left list.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CListCtrlPair::OnColumnClickLeftList(NMHDR * pNMHDR, LRESULT * pResult)
{
    NM_LISTVIEW *   pNMListView = (NM_LISTVIEW *) pNMHDR;

    ASSERT(m_pfnGetColumn != NULL);

    m_plcFocusList = &m_lcLeft;

    // Save the current sort column and direction.
    if (pNMListView->iSubItem == SiLeft().m_nColumn)
        SiLeft().m_nDirection ^= -1;
    else
    {
        SiLeft().m_nColumn = pNMListView->iSubItem;
        SiLeft().m_nDirection = 0;
    }  // else:  different column

    // Sort the list.
    m_psiCur = &SiLeft();
    VERIFY(m_lcLeft.SortItems(CompareItems, (LPARAM) this));

    *pResult = 0;

}  //*** CListCtrlPair::OnColumnClickLeftList()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::OnColumnClickRightList
//
//  Routine Description:
//      Handler method for the LVN_COLUMNCLICK message on the right list.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CListCtrlPair::OnColumnClickRightList(NMHDR * pNMHDR, LRESULT * pResult)
{
    NM_LISTVIEW *   pNMListView = (NM_LISTVIEW *) pNMHDR;

    ASSERT(m_pfnGetColumn != NULL);

    m_plcFocusList = &m_lcRight;

    // Save the current sort column and direction.
    if (pNMListView->iSubItem == SiRight().m_nColumn)
        SiRight().m_nDirection ^= -1;
    else
    {
        SiRight().m_nColumn = pNMListView->iSubItem;
        SiRight().m_nDirection = 0;
    }  // else:  different column

    // Sort the list.
    m_psiCur = &SiRight();
    VERIFY(m_lcRight.SortItems(CompareItems, (LPARAM) this));

    *pResult = 0;

}  //*** CListCtrlPair::OnColumnClickRightList()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::CompareItems [static]
//
//  Routine Description:
//      Callback function for the CListCtrl::SortItems method.
//
//  Arguments:
//      lparam1     First item to compare.
//      lparam2     Second item to compare.
//      lparamSort  Sort parameter.
//
//  Return Value:
//      -1          First parameter comes before second.
//      0           First and second parameters are the same.
//      1           First parameter comes after second.
//
//--
/////////////////////////////////////////////////////////////////////////////
int CALLBACK CListCtrlPair::CompareItems(
    LPARAM  lparam1,
    LPARAM  lparam2,
    LPARAM  lparamSort
    )
{
    CObject *           pobj1   = (CObject *) lparam1;
    CObject *           pobj2   = (CObject *) lparam2;
    CListCtrlPair *     plcp    = (CListCtrlPair *) lparamSort;
    int                 icol    = plcp->PsiCur()->m_nColumn;
    int                 nResult;
    CString             str1;
    CString             str2;

    ASSERT_VALID(pobj1);
    ASSERT_VALID(pobj2);
    ASSERT(plcp != NULL);
    ASSERT(plcp->PsiCur()->m_nColumn >= 0);
    ASSERT(icol >= 0);

    (*plcp->m_pfnGetColumn)(pobj1, 0, icol, plcp->Pdlg(), str1, NULL);
    (*plcp->m_pfnGetColumn)(pobj2, 0, icol, plcp->Pdlg(), str2, NULL);

    // Compare the two strings.
    // Use CompareString() so that it will sort properly on localized builds.
    nResult = CompareString(
                LOCALE_USER_DEFAULT,
                0,
                str1,
                str1.GetLength(),
                str2,
                str2.GetLength()
                );
    if ( nResult == CSTR_LESS_THAN )
    {
        nResult = -1;
    }
    else if ( nResult == CSTR_EQUAL )
    {
        nResult = 0;
    }
    else if ( nResult == CSTR_GREATER_THAN )
    {
        nResult = 1;
    }
    else
    {
        // An error occurred.  Ignore it.
        nResult = 0;
    }

    // Return the result based on the direction we are sorting.
    if (plcp->PsiCur()->m_nDirection != 0)
        nResult = -nResult;

    return nResult;

}  //*** CListCtrlPair::CompareItems()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::SetLists
//
//  Routine Description:
//      Set the lists for the list control pair.
//
//  Arguments:
//      plpobjRight     [IN OUT] List for the right list box.
//      plpobjLeft      [IN] List for the left list box.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CListCtrlPair::SetLists(
    IN OUT CClusterItemList *   plpobjRight,
    IN const CClusterItemList * plpobjLeft
    )
{
    if (plpobjRight != NULL)
        m_plpobjRight = plpobjRight;
    if (plpobjLeft != NULL)
        m_plpobjLeft = plpobjLeft;

    DuplicateLists();

}  //*** CListCtrlPair::SetLists()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::SetLists
//
//  Routine Description:
//      Set the lists for the list control pair where the right list should
//      not be modified.
//
//  Arguments:
//      plpobjRight     [IN] List for the right list box.
//      plpobjLeft      [IN] List for the left list box.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CListCtrlPair::SetLists(
    IN const CClusterItemList * plpobjRight,
    IN const CClusterItemList * plpobjLeft
    )
{
    m_dwStyle |= LCPS_DONT_OUTPUT_RIGHT_LIST;
    SetLists((CClusterItemList *) plpobjRight, plpobjLeft);

}  //*** CListCtrlPair::SetLists()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::DuplicateLists
//
//  Routine Description:
//      Duplicate the lists so that we have local copies.
//
//  Arguments:
//      rlc         [IN OUT] List control to fill.
//      rlpobj      [IN] List to use to fill the control.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CListCtrlPair::DuplicateLists(void)
{
    LpobjRight().RemoveAll();
    LpobjLeft().RemoveAll();

    if ((PlpobjRight() == NULL) || (PlpobjLeft() == NULL))
        return;

    // Duplicate the right list.
    {
        POSITION        pos;
        CClusterItem *  pci;

        pos = PlpobjRight()->GetHeadPosition();
        while (pos != NULL)
        {
            // Get the item pointer.
            pci = PlpobjRight()->GetNext(pos);
            ASSERT_VALID(pci);

            // Add it to our list.
            LpobjRight().AddTail(pci);
        }  // while:  more items in the list
    }  // Duplicate the right list

    // Duplicate the left list.
    {
        POSITION        pos;
        CClusterItem *  pci;

        pos = PlpobjLeft()->GetHeadPosition();
        while (pos != NULL)
        {
            // Get the item pointer.
            pci = PlpobjLeft()->GetNext(pos);
            ASSERT_VALID(pci);

            // If the item is not already in the other list,
            // add it to the left list.
            if (LpobjRight().Find(pci) == NULL)
                LpobjLeft().AddTail(pci);
        }  // while:  more items in the list
    }  // Duplicate the left list

}  //*** CListCtrlPair::DuplicateLists()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::FillList
//
//  Routine Description:
//      Fill a list control.
//
//  Arguments:
//      rlc         [IN OUT] List control to fill.
//      rlpobj      [IN] List to use to fill the control.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CListCtrlPair::FillList(
    IN OUT CListCtrl &          rlc,
    IN const CClusterItemList & rlpobj
    )
{
    POSITION    pos;
    CObject *   pobj;
    int         iItem;

    // Initialize the control.
    VERIFY(rlc.DeleteAllItems());

    rlc.SetItemCount((int)rlpobj.GetCount());

    // Add the items to the list.
    pos = rlpobj.GetHeadPosition();
    for (iItem = 0 ; pos != NULL ; iItem++)
    {
        pobj = rlpobj.GetNext(pos);
        ASSERT_VALID(pobj);
        NInsertItemInListCtrl(iItem, pobj, rlc);
    }  // for:  each string in the list

    // If there are any items, set the focus on the first one.
    if (rlc.GetItemCount() != 0)
        rlc.SetItemState(0, LVIS_FOCUSED, LVIS_FOCUSED);

}  //*** CListCtrlPair::FillList()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::NInsertItemInListCtrl
//
//  Routine Description:
//      Insert an item in a list control.
//
//  Arguments:
//      iitem       [IN] Index of the item in the list.
//      pobj        [IN OUT] Item to add.
//      rlc         [IN OUT] List control in which to insert the item.
//
//  Return Value:
//      iRetItem    Index of the new item in the list control.
//
//--
/////////////////////////////////////////////////////////////////////////////
int CListCtrlPair::NInsertItemInListCtrl(
    IN int              iitem,
    IN OUT CObject *    pobj,
    IN OUT CListCtrl &  rlc
    )
{
    int         iRetItem;
    CString     strText;
    int         iimg;
    int         icol;

    ASSERT(m_pfnGetColumn != NULL);
    ASSERT(Pdlg() != NULL);

    // Insert the first column.
    (*m_pfnGetColumn)(pobj, iitem, 0, Pdlg(), strText, &iimg);
    iRetItem = rlc.InsertItem(
                    LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM,    // nMask
                    iitem,                                  // nItem
                    strText,                                // lpszItem
                    0,                                      // nState
                    0,                                      // nStateMask
                    iimg,                                   // nImage
                    (LPARAM) pobj                           // lParam
                    );
    ASSERT(iRetItem != -1);

    for (icol = 1 ; icol <= m_aColumns.GetUpperBound() ; icol++)
    {
        (*m_pfnGetColumn)(pobj, iRetItem, icol, Pdlg(), strText, NULL);
        rlc.SetItemText(iRetItem, icol, strText);
    }  // for:  each column

    return iRetItem;

}  //*** CListCtrlPair::NInsertItemInListCtrl()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CListCtrlPair::MoveItems
//
//  Routine Description:
//      Move an item from one list to the other.
//
//  Arguments:
//      rlcDst      [IN OUT] Destination list control.
//      rlpobjDst   [IN OUT] Destination list.
//      rlcSrc      [IN OUT] Source list control.
//      rlpobjSrc   [IN OUT] Source list.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CListCtrlPair::MoveItems(
    IN OUT CListCtrl &          rlcDst,
    IN OUT CClusterItemList &   rlpobjDst,
    IN OUT CListCtrl &          rlcSrc,
    IN OUT CClusterItemList &   rlpobjSrc
    )
{
    int             iSrcItem;
    int             iDstItem;
    int             nItem   = -1;
    CClusterItem *  pci;
    POSITION        pos;

    ASSERT(!BReadOnly());

    iDstItem = rlcDst.GetItemCount();
    while ((iSrcItem = rlcSrc.GetNextItem(-1, LVNI_SELECTED)) != -1)
    {
        // Get the item pointer.
        pci = (CClusterItem *) rlcSrc.GetItemData(iSrcItem);
        ASSERT_VALID(pci);

        // Remove the item from the source list.
        pos = rlpobjSrc.Find(pci);
        ASSERT(pos != NULL);
        rlpobjSrc.RemoveAt(pos);

        // Add the item to the destination list.
        rlpobjDst.AddTail(pci);

        // Remove the item from the source list control and
        // add it to the destination list control.
        VERIFY(rlcSrc.DeleteItem(iSrcItem));
        nItem = NInsertItemInListCtrl(iDstItem++, pci, rlcDst);
        rlcDst.SetItemState(
            nItem,
            LVIS_SELECTED | LVIS_FOCUSED,
            LVIS_SELECTED | LVIS_FOCUSED
            );
    }  // while:  more items

    ASSERT(nItem != -1);

    rlcDst.EnsureVisible(nItem, FALSE /*bPartialOK*/);
    rlcDst.SetFocus();

    // Indicate that the data has changed.
    Pdlg()->GetParent()->SendMessage(PSM_CHANGED, (WPARAM)Pdlg()->m_hWnd);

}  //*** CListCtrlPair::MoveItems()