//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 1998 - 1999
//
//  File:       connectui.cpp
//
//--------------------------------------------------------------------------

#include "pch.h"
#include <SnapBase.h>

#include "resource.h"
#include "connection.h"
#include "connectionui.h"
#include <aclpage.h>


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

////////////////////////////////////////////////////////////////////////////////

extern LPCWSTR g_lpszGC;
extern LPCWSTR g_lpszLDAP;
extern LPCWSTR g_lpszRootDSE;

///////////////////////////////////////////////////////////////////////////////

BEGIN_MESSAGE_MAP(CADSIEditConnectDialog, CDialog)
    //{{AFX_MSG_MAP(CADsObjectDialog)
    ON_CBN_SELCHANGE(IDC_NC_BOX, OnSelChangeContextList)
    ON_CBN_SELCHANGE(IDC_DOMAIN_SERVER_BOX, OnSelChangeDSList)
    ON_CBN_SELCHANGE(IDC_DN_BOX, OnSelChangeDNList)
    ON_CBN_EDITCHANGE(IDC_DOMAIN_SERVER_BOX, OnEditChangeDSList)
    ON_CBN_EDITCHANGE(IDC_DN_BOX, OnEditChangeDNList)
    ON_BN_CLICKED(IDC_DN_RADIO, OnDNRadio)
    ON_BN_CLICKED(IDC_NC_RADIO, OnNCRadio)
    ON_BN_CLICKED(IDC_DOMAIN_SERVER_RADIO, OnDSRadio)
    ON_BN_CLICKED(IDC_DEFAULT_RADIO, OnDefaultRadio)
    ON_BN_CLICKED(IDC_ADVANCED_BUTTON, OnAdvanced)
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

CADSIEditConnectDialog::CADSIEditConnectDialog(CContainerNode* pRootnode,
                                                              CTreeNode* pTreeNode,
                                                              CComponentDataObject* pComponentData,
                                                              CConnectionData* pConnectData
                                                             ) : CDialog(IDD_CONNECTION_DIALOG)
{
    m_pContainerNode = pRootnode;
    m_pTreeNode = pTreeNode;
    m_pComponentData = pComponentData;
    m_pNewConnectData = pConnectData;
    m_szDisplayExtra = L"";
    m_sDefaultServerName = L"";
}

CADSIEditConnectDialog::~CADSIEditConnectDialog()
{
  if (m_bNewConnect && m_pNewConnectData != NULL)
    delete m_pNewConnectData;
}


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

    CConnectionData* pConnectData = GetConnectionData();

    if (pConnectData == NULL)
    {
        m_pNewConnectData = new CConnectionData();
    if (m_pNewConnectData)
    {
          m_bNewConnect = TRUE;

          CString sServerName;
          m_pNewConnectData->GetDomainServer(sServerName);

          if (sServerName == L"")
          {
              HRESULT hr = CConnectionData::GetServerNameFromDefault(m_pNewConnectData);
        if (SUCCEEDED(hr))
        {
                m_pNewConnectData->GetDomainServer(m_sDefaultServerName);
        }
          }
          m_pNewConnectData->GetDomainServer(m_szDisplayExtra);
    }
    }
    else
    {
        m_pNewConnectData = pConnectData;
        m_bNewConnect = FALSE;
    }

    LoadNamingContext();
    SetupUI();
    SetDirty();

    return TRUE;
}

void CADSIEditConnectDialog::LoadNamingContext()
{
    CComboBox* pcNCBox = (CComboBox*)GetDlgItem(IDC_NC_BOX);

    // NOTICE-2002/03/01-artm  CString can throw out of memory exception,
    // but that needs to be handled at a higher level so don't worry about
    // it here.
    m_szDomain.LoadString(IDS_DOMAIN_NC);
    m_szConfigContainer.LoadString(IDS_CONFIG_CONTAINER);
    m_szRootDSE.LoadString(IDS_ROOTDSE);
    m_szSchema.LoadString(IDS_SCHEMA);

    pcNCBox->AddString(m_szDomain);
    pcNCBox->AddString(m_szConfigContainer);
    pcNCBox->AddString(m_szRootDSE);
    pcNCBox->AddString(m_szSchema);
}

void CADSIEditConnectDialog::SetupUI()
{
    CComboBox* pcDNBox = (CComboBox*)GetDlgItem(IDC_DN_BOX);
    CComboBox* pcNCBox = (CComboBox*)GetDlgItem(IDC_NC_BOX);
    CComboBox* pcDomainServerBox = (CComboBox*)GetDlgItem(IDC_DOMAIN_SERVER_BOX);
    CButton* pcDNRadio = (CButton*)GetDlgItem(IDC_DN_RADIO);
    CButton* pcNCRadio = (CButton*)GetDlgItem(IDC_NC_RADIO);
    CButton* pcDSRadio  = (CButton*)GetDlgItem(IDC_DOMAIN_SERVER_RADIO);
    CButton* pcDefaultRadio = (CButton*)GetDlgItem(IDC_DEFAULT_RADIO);
    CEdit* pcNameBox = (CEdit*)GetDlgItem(IDC_CONNECTION_NAME);


    //Setup UI to reflect data
    LoadMRUs();

    CString  sDistinguishedName;
    m_pNewConnectData->GetDistinguishedName(sDistinguishedName);

    if (!sDistinguishedName.IsEmpty())
    {
        int iIndex = pcDNBox->FindStringExact(-1, sDistinguishedName);
        if (iIndex != CB_ERR)
        {
            pcDNBox->SetCurSel(iIndex);
        }
        else
        {
            int nIndex = pcDNBox->AddString(sDistinguishedName);
            pcDNBox->SetCurSel(nIndex);
        }
        OnSelChangeDNList();
        pcDNRadio->SetCheck(BST_CHECKED);
    }
    else
    {
        CString sNamingContext;
        m_pNewConnectData->GetNamingContext(sNamingContext);

        int iIndex = pcNCBox->FindStringExact(-1, sNamingContext);
        if (iIndex != CB_ERR)
        {
            pcNCBox->SetCurSel(iIndex);

        }
        else
        {
            pcNCBox->SetCurSel(0);
        }
        OnSelChangeContextList();
        pcNCRadio->SetCheck(BST_CHECKED);
    }

    CString sServer;
    m_pNewConnectData->GetDomainServer(sServer);

    BOOL bUserDefinedServer;
    bUserDefinedServer = m_pNewConnectData->GetUserDefinedServer();

    if (!sServer.IsEmpty() && bUserDefinedServer)
    {
        int iIndex = pcDomainServerBox->FindStringExact(-1, sServer);
        if (iIndex != CB_ERR)
        {
            pcDomainServerBox->SetCurSel(iIndex);
        }
        else
        {
            int nIndex = pcDomainServerBox->AddString(sServer);
            pcDomainServerBox->SetCurSel(nIndex);
        }
        OnSelChangeDSList();
        pcDSRadio->SetCheck(BST_CHECKED);
    }
    else
    {
        pcDefaultRadio->SetCheck(BST_CHECKED);
    }
    CString sName;
    m_pNewConnectData->GetName(sName);

    pcNameBox->SetLimitText(MAX_CONNECT_NAME_LENGTH);
    if (sName.IsEmpty())
    {
        if (pcNCRadio->GetCheck())
        {
            CString szNCName;
            pcNCBox->GetLBText(pcNCBox->GetCurSel(), szNCName);
            pcNameBox->SetWindowText(szNCName);
            m_pNewConnectData->GetDomainServer(m_szDisplayExtra);
        }
        else
        {
            CString szMyConnection;
            // NOTICE-2002/03/01-artm  CString can throw out of memory exception,
            // but that needs to be handled at a higher level so don't worry about
            // it here.
            szMyConnection.LoadString(IDS_MY_CONNECTION);
            pcNameBox->SetWindowText(szMyConnection);
        }
    }
    else
    {
        pcNameBox->SetWindowText(sName);
    }

    SetAndDisplayPath();
}

void CADSIEditConnectDialog::LoadMRUs()
{
    CComboBox* pcDomainServerBox = (CComboBox*)GetDlgItem(IDC_DOMAIN_SERVER_BOX);
    CComboBox* pcDNBox = (CComboBox*)GetDlgItem(IDC_DN_BOX);

    CADSIEditRootData* pRootNode = GetRootNode();
    CStringList sServerMRU, sDNMRU;
    pRootNode->GetServerMRU(&sServerMRU);
    pRootNode->GetDNMRU(&sDNMRU);

    POSITION pos = sServerMRU.GetHeadPosition();
    while (pos != NULL)
    {
        CString sMRU;
        sMRU = sServerMRU.GetNext(pos);
        pcDomainServerBox->AddString(sMRU);
    }

    pos = sDNMRU.GetHeadPosition();
    while (pos != NULL)
    {
        CString sMRU;
        sMRU = sDNMRU.GetNext(pos);
        pcDNBox->AddString(sMRU);
    }
}

void CADSIEditConnectDialog::SaveMRUs()
{
    CADSIEditRootData* pRootNode = GetRootNode();
    CStringList sDNMRU, sServerMRU;
    CString sDS, sDN;
    BOOL bFound = FALSE;

    m_pNewConnectData->GetDistinguishedName(sDN);
    m_pNewConnectData->GetDomainServer(sDS);

    pRootNode->GetServerMRU(&sServerMRU);
    pRootNode->GetDNMRU(&sDNMRU);

    POSITION pos = sServerMRU.GetHeadPosition();
    while (pos != NULL)
    {
        CString sServer;
        sServer = sServerMRU.GetNext(pos);
        if (sServer == sDS)
        {
            bFound = TRUE;
            break;
        }
    }

    if (!bFound && !sDS.IsEmpty())
    {
        sServerMRU.AddHead(sDS);
        pRootNode->SetServerMRU(&sServerMRU);
    }

    bFound = FALSE;
    pos = sDNMRU.GetHeadPosition();
    while (pos != NULL)
    {
        CString sDistinguishedName;
        sDistinguishedName = sDNMRU.GetNext(pos);
        if (sDistinguishedName == sDN)
        {
            bFound = TRUE;
            break;
        }
    }

    if (!bFound && !sDN.IsEmpty())
    {
        sDNMRU.AddHead(sDN);
        pRootNode->SetDNMRU(&sDNMRU);
    }
}

void CADSIEditConnectDialog::OnDNRadio()
{
    SetDirty();
    SetAndDisplayPath();
}

void CADSIEditConnectDialog::OnNCRadio()
{
    SetDirty();
    SetAndDisplayPath();
}

void CADSIEditConnectDialog::OnDSRadio()
{
    CComboBox* pcDomainServerBox = (CComboBox*)GetDlgItem(IDC_DOMAIN_SERVER_BOX);

    CString szDS;
    pcDomainServerBox->GetWindowText(szDS);
    m_pNewConnectData->SetDomainServer(szDS);
    m_pNewConnectData->SetUserDefinedServer(TRUE);

    SetDirty();
    SetAndDisplayPath();
}

void CADSIEditConnectDialog::OnDefaultRadio()
{
    m_pNewConnectData->SetUserDefinedServer(FALSE);

  if (m_pNewConnectData->IsGC())
  {
    m_pNewConnectData->SetDomainServer(L"");
  }
  else
  {
    m_pNewConnectData->SetDomainServer(m_sDefaultServerName);
  }

    SetDirty();
    SetAndDisplayPath();
}

void CADSIEditConnectDialog::SetAndDisplayPath()
{
    CEdit* pcPathBox = (CEdit*)GetDlgItem(IDC_FULLPATH_BOX);
    CButton* pcDSRadio  = (CButton*)GetDlgItem(IDC_DOMAIN_SERVER_RADIO);
    CButton* pcDNRadio = (CButton*)GetDlgItem(IDC_DN_RADIO);
    CComboBox* pcNCBox = (CComboBox*)GetDlgItem(IDC_NC_BOX);

    // Get data from connection node
    //
    CString szLDAP, sServer, sPort, sDistinguishedName, sNamingContext;
    m_pNewConnectData->GetLDAP(szLDAP);
    m_pNewConnectData->GetDomainServer(sServer);
    m_pNewConnectData->GetPort(sPort);
    m_pNewConnectData->GetDistinguishedName(sDistinguishedName);
    m_pNewConnectData->GetNamingContext(sNamingContext);
    m_pNewConnectData->SetRootDSE(FALSE);

    CString szFullPath;
    if (!sServer.IsEmpty())
    {
        szFullPath = szFullPath + sServer;
        if (!sPort.IsEmpty())
        {
            szFullPath = szFullPath + _T(":") + sPort + _T("/");
        }
        else
        {
            szFullPath = szFullPath + _T("/");
        }
    }

    if (pcDNRadio->GetCheck() && !sDistinguishedName.IsEmpty())
    {
        szFullPath = szFullPath + sDistinguishedName;
        // NOTICE-2002/03/01-artm  Both strings always null terminated, wcscmp() okay.
        // sDistinguishedName is a CString and g_lpszRootDSE is a constant.
        if (wcscmp(sDistinguishedName, g_lpszRootDSE) == 0)
        {
            m_pNewConnectData->SetRootDSE(TRUE);
        }
    }
    else
    {
        szFullPath = szFullPath + sNamingContext;
        // NOTICE-2002/03/01-artm  Both strings always null terminated, wcscmp() okay.
        // sNamingContext is a CString and g_lpszRootDSE is a constant.
        if (wcscmp(sNamingContext, g_lpszRootDSE) == 0)
        {
            m_pNewConnectData->SetRootDSE(TRUE);
        }
    }   

    m_pNewConnectData->GetDomainServer(m_szDisplayExtra);
    m_szDisplayExtra = L" [" + m_szDisplayExtra + L"]";

    szFullPath = szLDAP + szFullPath;
    pcPathBox->SetWindowText(szFullPath);
}

void CADSIEditConnectDialog::OnSelChangeContextList()
{
    CComboBox* pcNCBox = (CComboBox*)GetDlgItem(IDC_NC_BOX);
    CButton* pcDNRadio = (CButton*)GetDlgItem(IDC_DN_RADIO);
    CButton* pcNCRadio = (CButton*)GetDlgItem(IDC_NC_RADIO);
    CEdit* pcNameBox = (CEdit*)GetDlgItem(IDC_CONNECTION_NAME);

    CString szContext;
    SetDirty();
    pcNCBox->GetLBText(pcNCBox->GetCurSel(), szContext);
    m_pNewConnectData->SetNamingContext(szContext);
    pcNCRadio->SetCheck(BST_CHECKED);
    pcDNRadio->SetCheck(BST_UNCHECKED);

    CString sName;
    pcNCBox->GetLBText(pcNCBox->GetCurSel(), sName);
    pcNameBox->SetWindowText(sName);

    SetAndDisplayPath();
}

void CADSIEditConnectDialog::OnSelChangeDSList()
{
    CComboBox* pcDomainServerBox = (CComboBox*)GetDlgItem(IDC_DOMAIN_SERVER_BOX);
    CButton* pcDSRadio  = (CButton*)GetDlgItem(IDC_DOMAIN_SERVER_RADIO);
    CButton* pcDefaultRadio = (CButton*)GetDlgItem(IDC_DEFAULT_RADIO);

    SetDirty();
    if (pcDomainServerBox->GetCount() > 0)
    {
        CString sServer;
        pcDomainServerBox->GetLBText(pcDomainServerBox->GetCurSel(), sServer);
        m_pNewConnectData->SetDomainServer(sServer);
        m_pNewConnectData->SetUserDefinedServer(TRUE);
    }
    pcDSRadio->SetCheck(BST_CHECKED);
    pcDefaultRadio->SetCheck(BST_UNCHECKED);
    SetAndDisplayPath();
}

void CADSIEditConnectDialog::OnSelChangeDNList()
{
    CComboBox* pcDNBox = (CComboBox*)GetDlgItem(IDC_DN_BOX);
    CButton* pcDNRadio = (CButton*)GetDlgItem(IDC_DN_RADIO);
    CButton* pcNCRadio = (CButton*)GetDlgItem(IDC_NC_RADIO);

    SetDirty();
    if (pcDNBox->GetCount() > 0)
    {
        CString sDistinguishedName;
        pcDNBox->GetLBText(pcDNBox->GetCurSel(), sDistinguishedName);
        m_pNewConnectData->SetDistinguishedName(sDistinguishedName);
    }
    pcDNRadio->SetCheck(BST_CHECKED);
    pcNCRadio->SetCheck(BST_UNCHECKED);
    SetAndDisplayPath();
}


void CADSIEditConnectDialog::OnEditChangeDSList()
{
    CComboBox* pcDomainServerBox = (CComboBox*)GetDlgItem(IDC_DOMAIN_SERVER_BOX);
    CButton* pcDSRadio  = (CButton*)GetDlgItem(IDC_DOMAIN_SERVER_RADIO);
    CButton* pcDefaultRadio = (CButton*)GetDlgItem(IDC_DEFAULT_RADIO);

    SetDirty();
    CString szDS, sOldDS;

    pcDomainServerBox->GetWindowText(szDS);
    m_pNewConnectData->SetDomainServer(szDS);

    pcDSRadio->SetCheck(BST_CHECKED);
    pcDefaultRadio->SetCheck(BST_UNCHECKED);
    SetAndDisplayPath();
    m_pNewConnectData->SetUserDefinedServer(TRUE);
}

void CADSIEditConnectDialog::OnEditChangeDNList()
{
    CComboBox* pcDNBox = (CComboBox*)GetDlgItem(IDC_DN_BOX);
    CButton* pcDNRadio = (CButton*)GetDlgItem(IDC_DN_RADIO);
    CButton* pcNCRadio = (CButton*)GetDlgItem(IDC_NC_RADIO);

    SetDirty();
    CString s, sOldDN;

    pcDNBox->GetWindowText(s);
    m_pNewConnectData->SetDistinguishedName(s);

    pcDNRadio->SetCheck(BST_CHECKED);
    pcNCRadio->SetCheck(BST_UNCHECKED);
    SetAndDisplayPath();
}

void CADSIEditConnectDialog::OnAdvanced()
{
  CWaitCursor cursor;
   CThemeContextActivator activator;
    CADSIEditRootData* pRootNode = GetRootNode();
    
    CADSIEditAdvancedConnectionDialog AdvancedDialog(NULL, 
                                                                     pRootNode, 
                                                                     m_pComponentData, 
                                                                     m_pNewConnectData);
    if (AdvancedDialog.DoModal() == IDOK)
    {
    cursor.Restore();
    if (m_pNewConnectData->IsGC() && !m_pNewConnectData->GetUserDefinedServer())
    {
      m_pNewConnectData->SetDomainServer(L"");
    }
    else if (!m_pNewConnectData->IsGC())
    {
            CConnectionData::GetServerNameFromDefault(m_pNewConnectData);
    }

        SetDirty();
        SetAndDisplayPath();
    }
}

void CADSIEditConnectDialog::OnOK()
{
    if (OnApply())
    {
        CDialog::OnOK();
    }
}

BOOL CADSIEditConnectDialog::OnApply()
{
    CEdit* pcNameBox = (CEdit*)GetDlgItem(IDC_CONNECTION_NAME);

    CADSIEditRootData* pRootNode = GetRootNode();
    ASSERT(pRootNode != NULL);
    CComponentDataObject* pComponentData = GetComponentData();

    BSTR bstrPath;

    CString sName;
    pcNameBox->GetWindowText(sName);
    m_pNewConnectData->SetName(sName);

    if (m_bDirty)
    {
        if (!DoDirty())
        {
            return FALSE;
        }
    }
    else
    {
        if (pRootNode->GetDisplayName() != sName)
        {
            pRootNode->SetDisplayName(sName + m_szDisplayExtra);
        }
        else
        {
            ADSIEditMessageBox(IDS_MSG_CONNECTION_NAME, MB_OK);
            return FALSE;
        }
    }

    return TRUE;
}

BOOL CADSIEditConnectDialog::DoDirty()
{
    CEdit* pcNameBox = (CEdit*)GetDlgItem(IDC_CONNECTION_NAME);

    CADSIEditContainerNode* pTreeNode = dynamic_cast<CADSIEditContainerNode*>(GetTreeNode());

    CADSIEditRootData* pRootNode = GetRootNode();
    ASSERT(pRootNode != NULL);
    CComponentDataObject* pComponentData = GetComponentData();

    SaveMRUs();

    CString sRootDSE, s;
    BuildRootDSE(sRootDSE);

    CComPtr<IADs> spRootADs;
    HRESULT hr, hCredResult;
    hr = OpenObjectWithCredentials(
                                             m_pNewConnectData, 
                                             m_pNewConnectData->GetCredentialObject()->UseCredentials(),
                                             sRootDSE,
                                             IID_IADs, 
                                             (LPVOID*) &spRootADs,
                                             GetSafeHwnd(),
                                             hCredResult
                                             );
    if ( FAILED(hr) )
    {
        if (SUCCEEDED(hCredResult))
        {
            ADSIEditErrorMessage(hr);
        }
        return FALSE;
    }

    CString sNamingContext, sDistinguishedName, sServerName;
    m_pNewConnectData->GetNamingContext(sNamingContext);
    m_pNewConnectData->GetDistinguishedName(sDistinguishedName);

    if ( m_pNewConnectData->IsRootDSE())
    {
        s = g_lpszRootDSE;
        if (!m_bNewConnect)
        {
            CString sName;
            pcNameBox->GetWindowText(sName);
            m_pNewConnectData->SetName(sName);

      CString szProvider, sServer, sPort, sPath;
        m_pNewConnectData->GetDomainServer(sServer);
        m_pNewConnectData->GetPort(sPort);
      m_pNewConnectData->GetLDAP(szProvider);

      if (sServer != _T(""))
      {
        if (sPort != _T(""))
        {
          sPath = szProvider + sServer + _T(":") + sPort + _T("/") + CString(sName);
        }
        else
        {
          sPath = szProvider + sServer + _T("/") + CString(sName);
        }
      }
      else
      {
        sPath = szProvider + CString(sName);
      }
            m_pNewConnectData->SetPath(sPath);
            
            ASSERT(pTreeNode != NULL);
            pTreeNode->SetDisplayName(sName + m_szDisplayExtra);
            m_pNewConnectData->SetBasePath(_T(""));
        }
        else
        {
            // Name
            LPWSTR objectName;
            spRootADs->get_Name(&objectName);
            if (objectName == NULL)
            {
                ADSIEditMessageBox(IDS_MSG_ROOTDSE_ERROR, MB_OK);
                return FALSE;
            }
            m_pNewConnectData->SetName(objectName);

      CString szProvider, sServer, sPort, sPath;
        m_pNewConnectData->GetDomainServer(sServer);
        m_pNewConnectData->GetPort(sPort);
      m_pNewConnectData->GetLDAP(szProvider);

      if (sServer != _T(""))
      {
        if (sPort != _T(""))
        {
          sPath = szProvider + sServer + _T(":") + sPort + _T("/") + CString(objectName);
        }
        else
        {
          sPath = szProvider + sServer + _T("/") + CString(objectName);
        }
      }
      else
      {
        sPath = szProvider + CString(objectName);
      }
            m_pNewConnectData->SetPath(sPath);

      m_pNewConnectData->SetClass(_T(""));

            CString sName;
            pcNameBox->GetWindowText(sName);
            if (sName.GetLength() > 0)
            {
                //Create a connection node
                m_pNewConnectData->SetName(sName);
                CADSIEditConnectionNode *pConnectNode = new CADSIEditConnectionNode(m_pNewConnectData);
                pConnectNode->SetDisplayName(sName + m_szDisplayExtra);
                pConnectNode->GetConnectionData()->SetConnectionNode(pConnectNode);
                VERIFY(pRootNode->AddChildToListAndUI(pConnectNode, pComponentData));
        pComponentData->SetDescriptionBarText(pRootNode);
            }
    
            else
            {
                ADSIEditMessageBox(IDS_MSG_CONNECTION_NAME, MB_OK);
                return FALSE;
            }
        }
    }       //if RootDSE
    else
    {
        CComBSTR bstrPath;
        if (!BuildNamingContext(bstrPath))
        {
            return FALSE;
        }

      if (!bstrPath)
      {
         return FALSE;
      }

        if (!BuildPath(s, (BSTR)bstrPath, spRootADs))
        {
            return FALSE;
        }
        
        if (!m_bNewConnect)
        {
            CString sName;
            pcNameBox->GetWindowText(sName);
            m_pNewConnectData->SetName(sName);
            m_pNewConnectData->SetPath(s);

            ASSERT(pTreeNode != NULL);
            pTreeNode->SetDisplayName(sName + m_szDisplayExtra);

            if (!pTreeNode->OnEnumerate(pComponentData))
            {
                return FALSE;
            }

/*          if (!pTreeNode->OnRefresh(pComponentData))
            {
                return FALSE;
            }
            */
        }
        else
        {
            CComPtr<IDirectoryObject> spDirObject;

            hr = OpenObjectWithCredentials(
                                                     m_pNewConnectData, 
                                                     m_pNewConnectData->GetCredentialObject()->UseCredentials(),
                                                     s,
                                                     IID_IDirectoryObject, 
                                                     (LPVOID*) &spDirObject,
                                                     GetSafeHwnd(),
                                                     hCredResult
                                                    );
            if ( FAILED(hr) )
            {
                if (SUCCEEDED(hCredResult))
                {
                    ADSIEditErrorMessage(hr);
                }
                return FALSE;
            }

            ADS_OBJECT_INFO* pInfo;
            hr = spDirObject->GetObjectInformation(&pInfo);
            if (FAILED(hr))
            {
                ADSIEditErrorMessage(hr);
                return FALSE;
            }

            // Name
            m_pNewConnectData->SetName(pInfo->pszRDN);
            m_pNewConnectData->SetPath(s);

            // Class
            m_pNewConnectData->SetClass(pInfo->pszClassName);
            FreeADsMem(pInfo);

            CString sName;
            pcNameBox->GetWindowText(sName);
            if (sName.GetLength() > 0)
            {
                //Create a connection node
                m_pNewConnectData->SetName(sName);
                CADSIEditConnectionNode *pConnectNode = new CADSIEditConnectionNode(m_pNewConnectData);
                pConnectNode->SetDisplayName(sName + m_szDisplayExtra);
                pConnectNode->GetConnectionData()->SetConnectionNode(pConnectNode);
                VERIFY(pRootNode->AddChildToListAndUI(pConnectNode, pComponentData));
        pComponentData->SetDescriptionBarText(pRootNode);
            }
            else
            {
                ADSIEditMessageBox(IDS_MSG_CONNECTION_NAME, MB_OK);
                return FALSE;
            }
        }
    }       //else

    return TRUE;
}

BOOL CADSIEditConnectDialog::BuildPath(CString& s, BSTR bstrPath, IADs* pADs)
{
    CButton* pcDNRadio = (CButton*)GetDlgItem(IDC_DN_RADIO);
    CButton* pcNCRadio = (CButton*)GetDlgItem(IDC_NC_RADIO);

    HRESULT hr;
    CString szLDAP, basePath, sServer, sPort, sDistinguishedName;
    m_pNewConnectData->GetLDAP(szLDAP);
    m_pNewConnectData->GetDomainServer(sServer);
    m_pNewConnectData->GetPort(sPort);
    m_pNewConnectData->GetDistinguishedName(sDistinguishedName);

    if ( pcNCRadio->GetCheck())
    {
        VARIANT var;
        VariantInit(&var);
        hr = pADs->Get( bstrPath, &var );

        if ( FAILED(hr) )
        {
            VariantClear(&var);
            return FALSE;
        }

        if (!sServer.IsEmpty())
        {
            s = s + sServer;
            if (!sPort.IsEmpty())
            {
                s = s + _T(":") + sPort + _T("/");
            }
            else
            {
                s = s + _T("/");
            }
        }
        s = s  + V_BSTR(&var);
        basePath = V_BSTR(&var);
        VariantClear(&var);
    }
    else if(pcDNRadio->GetCheck())
    {
        if (!sServer.IsEmpty())
        {
            s = s + sServer;
            if (!sPort.IsEmpty())
            {
                s = s + _T(":") + sPort + _T("/");
            }
            else
            {
                s = s + _T("/");
            }
        }
        s = s + sDistinguishedName;
        basePath = sDistinguishedName;
    }

    m_pNewConnectData->SetBasePath(basePath);
    s = szLDAP + s;
    return TRUE;
}

BOOL CADSIEditConnectDialog::BuildNamingContext(CComBSTR& bstrPath)
{
    CButton* pcDNRadio = (CButton*)GetDlgItem(IDC_DN_RADIO);
    CButton* pcNCRadio = (CButton*)GetDlgItem(IDC_NC_RADIO);

    CString sNamingContext;
    m_pNewConnectData->GetNamingContext(sNamingContext);

    if ( pcNCRadio->GetCheck())
    {
        if ( sNamingContext == m_szDomain)
        {
            bstrPath = SysAllocString( L"defaultNamingContext");
        }
        else if ( sNamingContext == m_szSchema)
        {
            bstrPath = SysAllocString(L"schemaNamingContext");
        }
        else if ( sNamingContext == m_szConfigContainer)
        {
            bstrPath = SysAllocString(L"configurationNamingContext");
        }
        else
        {
            bstrPath = SysAllocString( L"defaultNamingContext");
        }   
        m_pNewConnectData->SetDistinguishedName(_T(""));
    }
    else if (pcDNRadio->GetCheck())
    {
        CString sDistinguishedName;
        m_pNewConnectData->GetDistinguishedName(sDistinguishedName);
        if (sDistinguishedName.Find(L'=') == -1)
        {
            int iResult = ADSIEditMessageBox(IDS_MSG_NOT_X500_PATH, MB_YESNO | MB_DEFBUTTON2);
            if (iResult ==  IDNO)
            {
                return FALSE;
            }
        }
        bstrPath = sDistinguishedName.AllocSysString();
        m_pNewConnectData->SetNamingContext(_T(""));
    }
    return TRUE;
}

void CADSIEditConnectDialog::BuildRootDSE(CString& sRootDSE)
{
    CButton* pDefaultRadio = (CButton*)GetDlgItem(IDC_DEFAULT_RADIO);

    CString sServer, sPort, sLDAP;
    m_pNewConnectData->GetDomainServer(sServer);
    m_pNewConnectData->GetPort(sPort);
    m_pNewConnectData->GetLDAP(sLDAP);

    if (!sServer.IsEmpty())
    {
        sRootDSE = sLDAP + sServer;
        if (!sPort.IsEmpty())
        {
            sRootDSE = sRootDSE + _T(":") + sPort + _T("/");
        }
        else
        {
            sRootDSE = sRootDSE + _T("/");
        }
        sRootDSE = sRootDSE + g_lpszRootDSE;
    }
    else
    {
        sRootDSE = sLDAP + g_lpszRootDSE;
    }
}


/////////////////////////////////////////////////////////////////////////////////////////////////
// CADSIEditAdvancedConnectionDialog :

BEGIN_MESSAGE_MAP(CADSIEditAdvancedConnectionDialog, CDialog)
    //{{AFX_MSG_MAP(CADsObjectDialog)
    ON_BN_CLICKED(IDC_CREDENTIALS_CHECK, OnCredentials)
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()


CADSIEditAdvancedConnectionDialog::CADSIEditAdvancedConnectionDialog(CContainerNode* pRootDataNode, 
            CTreeNode* pContainerNode, CComponentDataObject* pComponentData, CConnectionData* pConnectData) 
                : CDialog(IDD_CONNECTION_ADVANCED)
{
    // Get the local data
    //
    m_pTreeNode = pContainerNode;
    m_pContainerNode = pRootDataNode;
    ASSERT(pComponentData != NULL);
    m_pComponentData = pComponentData;
    ASSERT(pConnectData != NULL);
    m_pConnectData = pConnectData;
}

CADSIEditAdvancedConnectionDialog::~CADSIEditAdvancedConnectionDialog() 
{
}

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

    // Attach all the controls
    //
    CEdit* pcPortBox = (CEdit*)GetDlgItem(IDC_PORT);
    CButton* pcLDAPRadio = (CButton*)GetDlgItem(IDC_LDAP_RADIO);
    CButton* pcGCRadio = (CButton*)GetDlgItem(IDC_GC_RADIO);
    CButton* pcCredCheck = (CButton*)GetDlgItem(IDC_CREDENTIALS_CHECK);
    CEdit* pcUsernameBox = (CEdit*)GetDlgItem(IDC_USERNAME);
    CEdit* pcPasswordBox = (CEdit*)GetDlgItem(IDC_PASSWORD);

  // disable IME support on numeric edit fields
  ImmAssociateContext(pcPortBox->GetSafeHwnd(), NULL);

    // Set the initial state of the controls
    //
    CString sLDAP;
    m_pConnectData->GetLDAP(sLDAP);

    // NOTICE-2002/03/01-artm  Both strings always null terminated, wcscmp() okay.
    // sLDAP is a CString and g_lpszLDAP is a constant.
    if (wcscmp(sLDAP, g_lpszLDAP) == 0)
    {
        pcLDAPRadio->SetCheck(BST_CHECKED);
    }
    else
    {
        pcGCRadio->SetCheck(BST_CHECKED);
    }

    CString sPort;
    m_pConnectData->GetPort(sPort);
    pcPortBox->SetWindowText(sPort);

    if (m_pConnectData->GetCredentialObject()->UseCredentials())
    {
        CString sUser;
        m_pConnectData->GetCredentialObject()->GetUsername(sUser);
        pcCredCheck->SetCheck(TRUE);
        OnCredentials();
        pcUsernameBox->SetWindowText(sUser);
    }

    pcPasswordBox->SetLimitText(MAX_PASSWORD_LENGTH);

    return TRUE;
}

void CADSIEditAdvancedConnectionDialog::OnOK()
{
    OnApply();
    CDialog::OnOK();
}

BOOL CADSIEditAdvancedConnectionDialog::OnApply()
{
    BOOL success = TRUE;
    CEdit* pcPortBox = (CEdit*)GetDlgItem(IDC_PORT);
    CButton* pcLDAPRadio = (CButton*)GetDlgItem(IDC_LDAP_RADIO);
    CButton* pcCredCheck = (CButton*)GetDlgItem(IDC_CREDENTIALS_CHECK);
    CEdit* pcUsernameBox = (CEdit*)GetDlgItem(IDC_USERNAME);

    // Make the connection data reflect the controls
    //
    CString sPort;
    pcPortBox->GetWindowText(sPort);
    m_pConnectData->SetPort(sPort);

    if (pcLDAPRadio->GetCheck())
    {
        m_pConnectData->SetLDAP(g_lpszLDAP);
    }
    else
    {
        m_pConnectData->SetLDAP(g_lpszGC);
    }

    if (pcCredCheck->GetCheck())
    {
        // Get user name and password
        //
        CString sUser;
        HRESULT hr;
        pcUsernameBox->GetWindowText(sUser);
        
        m_pConnectData->GetCredentialObject()->SetUsername(sUser);

        hr = m_pConnectData->GetCredentialObject()->SetPasswordFromHwnd(
            GetSafeHwnd(),
            IDC_PASSWORD);
        
        if (FAILED(hr))
        {
            success = FALSE;
        }

        m_pConnectData->GetCredentialObject()->SetUseCredentials(TRUE);
    }
    else
    {
        m_pConnectData->GetCredentialObject()->SetUseCredentials(FALSE);
    }

    return success;
}

void CADSIEditAdvancedConnectionDialog::OnCredentials()
{
    CButton* pcCredCheck = (CButton*)GetDlgItem(IDC_CREDENTIALS_CHECK);
    CButton* pcCredGroup = (CButton*)GetDlgItem(IDC_CREDENTIALS_GROUP);
    CStatic* pcCredUser = (CStatic*)GetDlgItem(IDC_CREDENTIALS_USER);
    CStatic* pcCredPassword = (CStatic*)GetDlgItem(IDC_CREDENTIALS_PASSWORD);
    CEdit* pcUsernameBox = (CEdit*)GetDlgItem(IDC_USERNAME);
    CEdit* pcPasswordBox = (CEdit*)GetDlgItem(IDC_PASSWORD);

    BOOL bResult = pcCredCheck->GetCheck();
    if (bResult)
    {
        // Enable Username and password fields
        //
        pcCredGroup->EnableWindow(bResult);
        pcCredUser->EnableWindow(bResult);
        pcCredPassword->EnableWindow(bResult);
        pcUsernameBox->EnableWindow(bResult);
        pcPasswordBox->EnableWindow(bResult);
    }
    else
    {
        // Enable Username and password fields
        //
        pcCredGroup->EnableWindow(FALSE);
        pcCredUser->EnableWindow(FALSE);
        pcCredPassword->EnableWindow(FALSE);
        pcUsernameBox->EnableWindow(FALSE);
        pcPasswordBox->EnableWindow(FALSE);
    }
}