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

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

/////////////////////////////////////////////////////////////////////
//	dlgcreat.cpp
//
//	Implementation of dialogs that create new ADs objects.
//
//	DIALOGS SUPPORTED
//		CCreateNewObjectCnDlg - Dialog asking for "cn" attribute.
//		CCreateNewVolumeDlg - Create a new volume "shared folder" object
//		CCreateNewComputerDlg - Create a new computer object.
//		CCreateNewSiteLinkDlg - Create a new Site Link.
//		CCreateNewSiteLinkBridgeDlg - Create a new Site Link Bridge.

//
//	DIALOGS NOT YET IMPLEMENTED
//		site (validation only)
//		organizationalUnit
//		localPolicy
//		auditingPolicy
//
//	HISTORY
//	24-Aug-97	Dan Morin	Creation.
//
/////////////////////////////////////////////////////////////////////

#include "stdafx.h"

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

#include <windowsx.h>
#include <lmaccess.h>
#include <dnsapi.h>             // DnsvalidateDnsName_W
#include "winsprlp.h"           //PublishPrinter

#include "newobj.h"		// CNewADsObjectCreateInfo
#include "dscmn.h"
#include "dlgcreat.h"

extern "C"
{
#include "lmerr.h" // NET_API_STATUS
#include "icanon.h" // I_NetPathType
}


///////////////////////////////////////////////////////////////////////////
// CHPropSheetPageArr
CHPropSheetPageArr::CHPropSheetPageArr()
{
  m_nCount = 0;
  m_nSize = 4;
  ULONG nBytes = sizeof(HPROPSHEETPAGE)*m_nSize;
  m_pArr = (HPROPSHEETPAGE*)malloc(nBytes);
  if (m_pArr != NULL)
  {
    ZeroMemory(m_pArr, nBytes);
  }
}


void CHPropSheetPageArr::AddHPage(HPROPSHEETPAGE hPage)
{
  // see if there is space in the array
  if (m_nCount == m_nSize)
  {
    // grow the array
    int nAlloc = m_nSize*2;
    m_pArr = (HPROPSHEETPAGE*)realloc(m_pArr, sizeof(HPROPSHEETPAGE)*nAlloc);
    if (m_pArr != NULL)
    {
      ::ZeroMemory(&m_pArr[m_nSize], sizeof(HPROPSHEETPAGE)*m_nSize);
      m_nSize = nAlloc;
    }
    else
    {
      m_nSize = 0;
    }
  }
  m_pArr[m_nCount] = hPage;
  m_nCount++;
}

///////////////////////////////////////////////////////////////////////////
// CDsAdminNewObjSiteImpl




BOOL CDsAdminNewObjSiteImpl::_IsPrimarySite()
{
  return (m_pSite->GetSiteManager()->GetPrimaryExtensionSite() == m_pSite);
}


STDMETHODIMP CDsAdminNewObjSiteImpl::SetButtons(ULONG nCurrIndex, BOOL bValid)
{
  CCreateNewObjectWizardBase* pWiz = m_pSite->GetSiteManager()->GetWiz();
  return pWiz->SetWizardButtons(m_pSite, nCurrIndex, bValid);
}


STDMETHODIMP CDsAdminNewObjSiteImpl::GetPageCounts(/*OUT*/ LONG* pnTotal,
                               /*OUT*/ LONG* pnStartIndex)
{
  if ( (pnTotal == NULL) || (pnStartIndex == NULL) )
    return E_INVALIDARG;

  m_pSite->GetSiteManager()->GetWiz()->GetPageCounts(m_pSite, pnTotal,pnStartIndex); 
  return S_OK;
}

STDMETHODIMP CDsAdminNewObjSiteImpl::CreateNew(LPCWSTR pszName)
{
  if (m_pSite->GetSiteManager()->GetPrimaryExtensionSite() != m_pSite)
  {
    // cannot do if not a primary extension
    return E_FAIL;
  }

  CCreateNewObjectWizardBase* pWiz = m_pSite->GetSiteManager()->GetWiz();
  return pWiz->CreateNewFromPrimaryExtension(pszName);
}


STDMETHODIMP CDsAdminNewObjSiteImpl::Commit()
{
  if (m_pSite->GetSiteManager()->GetPrimaryExtensionSite() != m_pSite)
  {
    // cannot do if not a primary extension
    return E_FAIL;
  }

  if (m_pSite->GetHPageArr()->GetCount() > 1)
  {
    // valid only if the primary extension has one page only
    return E_FAIL;
  }

  CCreateNewObjectWizardBase* pWiz = m_pSite->GetSiteManager()->GetWiz();
  if (pWiz->HasFinishPage())
  {
    // if we have the finish page, the finish page must handle it
    return E_FAIL;
  }

  // trigger the finish code
  return (pWiz->OnFinish() ? S_OK : E_FAIL);
}


///////////////////////////////////////////////////////////////////////////
// CWizExtensionSite

// static function
BOOL CALLBACK FAR CWizExtensionSite::_OnAddPage(HPROPSHEETPAGE hsheetpage, LPARAM lParam)
{
  TRACE(L"CWizExtensionSite::_OnAddPage(HPROPSHEETPAGE = 0x%x, lParam = 0x%x)\n",
          hsheetpage, lParam);
  CWizExtensionSite* pThis = (CWizExtensionSite*)lParam;
  pThis->m_pageArray.AddHPage(hsheetpage);
  return TRUE;
}

HRESULT CWizExtensionSite::InitializeExtension(GUID* pGuid)
{
  ASSERT(m_pSiteImplComObject == NULL);
  ASSERT(pGuid != NULL);

  WCHAR szBuf[256];
  StringFromGUID2(*(pGuid), szBuf, 256);

  TRACE(L"CWizExtensionSite::InitializeExtension( Guid = %s,\n", szBuf);

  // create extension COM object
  HRESULT hr = ::CoCreateInstance(*pGuid, NULL, CLSCTX_INPROC_SERVER, 
                        IID_IDsAdminNewObjExt, (void**)(&m_spIDsAdminNewObjExt));
  if (FAILED(hr))
  {
    TRACE(L"CoCreateInstance() failed, hr = 0x%x\n", hr);
    return hr;
  }

  // create a CDsAdminNewObjSiteImpl COM object
  ASSERT(m_pSiteImplComObject == NULL);
  CComObject<CDsAdminNewObjSiteImpl>::CreateInstance(&m_pSiteImplComObject);
  if (m_pSiteImplComObject == NULL) 
  {
    TRACE(L"CComObject<CDsAdminNewObjSiteImpl>::CreateInstance() failed\n");
    return E_OUTOFMEMORY;
  }

  // fully construct the object
  hr = m_pSiteImplComObject->FinalConstruct();
  if (FAILED(hr))
  {
    TRACE(L"CComObject<CDsAdminNewObjSiteImpl>::FinalConstruct failed hr = 0x%x\n", hr);

    // ref counting not yet into play, just use operator delete
    delete m_pSiteImplComObject; 
    m_pSiteImplComObject = NULL;
    return hr;
  }
  
  // object has ref count == 0, need to add ref
  // no smart pointer, ref counting on m_pSiteImplComObject

  IDsAdminNewObj* pDsAdminNewObj = NULL;
  m_pSiteImplComObject->QueryInterface(IID_IDsAdminNewObj, (void**)&pDsAdminNewObj);
  ASSERT(pDsAdminNewObj != NULL);

  // now ref count == 1

  // set back pointer to ourselves
  m_pSiteImplComObject->Init(this);

  // initialize the object
  

  CCreateNewObjectWizardBase* pWiz = GetSiteManager()->GetWiz();
  ASSERT(pWiz != NULL);

  CNewADsObjectCreateInfo* pInfo = pWiz->GetInfo();
  ASSERT(pInfo != NULL);


  // create a temporary struct on the stack
  DSA_NEWOBJ_DISPINFO dispinfo;
  ZeroMemory(&dispinfo, sizeof(DSA_NEWOBJ_DISPINFO));

  dispinfo.dwSize = sizeof(DSA_NEWOBJ_DISPINFO);
  dispinfo.hObjClassIcon = pWiz->GetClassIcon();
  dispinfo.lpszWizTitle = const_cast<LPTSTR>(pWiz->GetCaption());
  dispinfo.lpszContDisplayName = const_cast<LPTSTR>(pWiz->GetInfo()->GetContainerCanonicalName());

  TRACE(_T("dispinfo.dwSize = %d\n"), dispinfo.dwSize);
  TRACE(_T("dispinfo.hObjClassIcon = 0x%x\n"), dispinfo.hObjClassIcon);
  TRACE(_T("dispinfo.lpszWizTitle = <%s>\n"), dispinfo.lpszWizTitle);
  TRACE(_T("dispinfo.lpszContDisplayName = <%s>\n"), dispinfo.lpszContDisplayName);


  TRACE(L"\ncalling m_spIDsAdminWizExt->Initialize()\n");

  hr = m_spIDsAdminNewObjExt->Initialize(
                              pInfo->m_pIADsContainer,                              
                              pInfo->GetCopyFromObject(),
                              pInfo->m_pszObjectClass,
                              pDsAdminNewObj,
                              &dispinfo
                              );
  if (FAILED(hr))
  {
    TRACE(L"m_spIDsAdminNewObjExt->Initialize() failed hr = 0x%x\n", hr);
    return hr;
  }

  // collect property pages
  return m_spIDsAdminNewObjExt->AddPages(_OnAddPage, (LPARAM)this);
}

BOOL CWizExtensionSite::GetSummaryInfo(CString& s)
{
  CComBSTR bstr;
  HRESULT hr = GetNewObjExt()->GetSummaryInfo(&bstr);
  if (SUCCEEDED(hr) && bstr != NULL)
  {
    s += bstr;
    s += L"\n";
    return TRUE;
  }
  return FALSE;
}

///////////////////////////////////////////////////////////////////////////
// CWizExtensionSiteManager

HRESULT CWizExtensionSiteManager::CreatePrimaryExtension(GUID* pGuid, 
                                IADsContainer*,
                                LPCWSTR)
{
  ASSERT(m_pPrimaryExtensionSite == NULL);
  m_pPrimaryExtensionSite = new CWizExtensionSite(this);
  if (m_pPrimaryExtensionSite == NULL)
    return E_OUTOFMEMORY;

  // initialize COM object
  HRESULT hr = m_pPrimaryExtensionSite->InitializeExtension(pGuid);

  if (FAILED(hr))
  {
    delete m_pPrimaryExtensionSite;
    m_pPrimaryExtensionSite = NULL;
    return hr;
  }
  
  // make sure it provided at least a page
  if (m_pPrimaryExtensionSite->GetHPageArr()->GetCount() == 0)
  {
    hr = E_INVALIDARG;
    delete m_pPrimaryExtensionSite;
    m_pPrimaryExtensionSite = NULL;
  }
  return hr;
}



HRESULT CWizExtensionSiteManager::CreateExtensions(GUID* aCreateWizExtGUIDArr, ULONG nCount,
                                                    IADsContainer*,
                                                    LPCWSTR lpszClassName)
{
  HRESULT hr;
  TRACE(L"CWizExtensionSiteManager::CreateExtensions(_, nCount = %d, _ , lpszClassName = %s\n",
            nCount,lpszClassName);

  for (ULONG i=0; i<nCount; i++)
  {
    CWizExtensionSite* pSite = new CWizExtensionSite(this);
    if (pSite == NULL)
    {
      hr = E_OUTOFMEMORY;
      break;
    }
    hr = pSite->InitializeExtension(&(aCreateWizExtGUIDArr[i]));
    if (FAILED(hr))
    {
      TRACE(L"pSite->InitializeExtension() failed hr = 0x%x", hr);
      delete pSite;
    }
    else
    {
      m_extensionSiteList.AddTail(pSite);
    }
  }
  TRACE(L"m_extensionSiteList.GetCount() returned %d\n", m_extensionSiteList.GetCount());
  return S_OK;
}

UINT CWizExtensionSiteManager::GetTotalHPageCount()
{
  UINT nCount = 0;
  for (POSITION pos = m_extensionSiteList.GetHeadPosition(); pos != NULL; )
  {
    CWizExtensionSite* pSite = m_extensionSiteList.GetNext(pos);
    nCount += pSite->GetHPageArr()->GetCount();
  } // for
  return nCount;
}

void CWizExtensionSiteManager::SetObject(IADs* pADsObj)
{
  CWizExtensionSite* pPrimarySite = GetPrimaryExtensionSite();
  if (pPrimarySite != NULL)
  {
    pPrimarySite->GetNewObjExt()->SetObject(pADsObj);
  }

  for (POSITION pos = m_extensionSiteList.GetHeadPosition(); pos != NULL; )
  {
    CWizExtensionSite* pSite = m_extensionSiteList.GetNext(pos);
    HRESULT hr = pSite->GetNewObjExt()->SetObject(pADsObj);
    ASSERT(SUCCEEDED(hr));
  }
}

HRESULT CWizExtensionSiteManager::WriteExtensionData(HWND hWnd, ULONG uContext)
{
  for (POSITION pos = m_extensionSiteList.GetHeadPosition(); pos != NULL; )
  {
    CWizExtensionSite* pSite = m_extensionSiteList.GetNext(pos);
    HRESULT hr = pSite->GetNewObjExt()->WriteData(hWnd, uContext);
    if (FAILED(hr))
        return hr;
  } // for
  return S_OK;
}

HRESULT CWizExtensionSiteManager::NotifyExtensionsOnError(HWND hWnd, HRESULT hr, ULONG uContext)
{
  for (POSITION pos = m_extensionSiteList.GetHeadPosition(); pos != NULL; )
  {
    CWizExtensionSite* pSite = m_extensionSiteList.GetNext(pos);
    pSite->GetNewObjExt()->OnError(hWnd, hr, uContext);
  } // for
  return S_OK;
}


void CWizExtensionSiteManager::GetExtensionsSummaryInfo(CString& s)
{
  // just go through regular extensions
  for (POSITION pos = m_extensionSiteList.GetHeadPosition(); pos != NULL; )
  {
    CWizExtensionSite* pSite = m_extensionSiteList.GetNext(pos);
    pSite->GetSummaryInfo(s);
  } // for
}

/////////////////////////////////////////////////////////////////////
// CCreateNewObjectWizardBase

HWND g_hWndHack = NULL;

int CALLBACK CCreateNewObjectWizardBase::PropSheetProc(HWND hwndDlg, UINT uMsg, LPARAM)
{
  if (uMsg == PSCB_INITIALIZED)
  {
    ASSERT(::IsWindow(hwndDlg));
    g_hWndHack = hwndDlg;
    DWORD dwStyle = GetWindowLong (hwndDlg, GWL_EXSTYLE);
    dwStyle &= ~WS_EX_CONTEXTHELP;
    SetWindowLong (hwndDlg, GWL_EXSTYLE, dwStyle);
  }
  return 0;
}



CCreateNewObjectWizardBase::CCreateNewObjectWizardBase(CNewADsObjectCreateInfo* pNewADsObjectCreateInfo)
                  : m_siteManager(this)
{
  memset(&m_psh, 0x0, sizeof(PROPSHEETHEADER));
  m_psh.dwSize              = sizeof( m_psh );
  m_psh.dwFlags             = PSH_WIZARD | PSH_PROPTITLE | PSH_USECALLBACK;
  m_psh.hInstance           = _Module.GetModuleInstance();
  m_psh.pszCaption          = NULL; // will set later on per page

  ASSERT(pNewADsObjectCreateInfo != NULL);
  m_pNewADsObjectCreateInfo = pNewADsObjectCreateInfo;

  m_psh.hwndParent = m_pNewADsObjectCreateInfo->GetParentHwnd();
  m_psh.pfnCallback = PropSheetProc;

  m_hWnd = NULL;
  m_pFinishPage = NULL;
  m_hrReturnValue = S_FALSE; // default is cancel

  m_hClassIcon = NULL;
}

CCreateNewObjectWizardBase::~CCreateNewObjectWizardBase()
{
  if (m_pFinishPage != NULL)
    delete m_pFinishPage;

  if (m_hClassIcon)
  {
     DestroyIcon(m_hClassIcon);
  }
}


HRESULT CCreateNewObjectWizardBase::DoModal()
{
  TRACE(L"CCreateNewObjectWizardBase::DoModal()\n");
  ASSERT(m_pNewADsObjectCreateInfo != NULL);
  
  // load the sheet caption
  LoadCaptions();

  CWizExtensionSite* pPrimarySite = m_siteManager.GetPrimaryExtensionSite();

  // load the extensions, if any
  HRESULT hr = m_siteManager.CreateExtensions(
                    m_pNewADsObjectCreateInfo->GetCreateInfo()->aWizardExtensions,
                    m_pNewADsObjectCreateInfo->GetCreateInfo()->cWizardExtensions,
                    m_pNewADsObjectCreateInfo->m_pIADsContainer,
                    m_pNewADsObjectCreateInfo->m_pszObjectClass);
  if (FAILED(hr))
    return (hr);


  // get the # of primary property pages (excluding the Finish Page)
  UINT nBasePagesCount = 0;
  if (pPrimarySite != NULL)
  {
    nBasePagesCount += pPrimarySite->GetHPageArr()->GetCount();
  }
  else
  {
    nBasePagesCount += (UINT)m_pages.GetSize();
  }

  ASSERT(nBasePagesCount > 0);

  // get the handle count for the extensions (total for extension property pages)
  UINT nExtensionHPagesCount = m_siteManager.GetTotalHPageCount();

  // if we have more than one page, add the finish page
  UINT nTotalPageCount = nBasePagesCount + nExtensionHPagesCount;

  if ( (nBasePagesCount + nExtensionHPagesCount) > 1)
  {
    m_pFinishPage = new CCreateNewObjectFinishPage;
    AddPage(m_pFinishPage);
    nTotalPageCount++;
  }
  
  // need to allocate a contiguous chunk of memory to pack
  // all the property sheet handles
  m_psh.nPages = nTotalPageCount;
  m_psh.phpage = new HPROPSHEETPAGE[nTotalPageCount];
  if (m_psh.phpage)
  {
    UINT nOffset = 0; // offset where to write to

    // add the primary pages first
    if (pPrimarySite != NULL)
    {
      ASSERT(nBasePagesCount > 0);
      memcpy(&(m_psh.phpage[nOffset]), pPrimarySite->GetHPageArr()->GetArr(), 
                      sizeof(HPROPSHEETPAGE)*nBasePagesCount);
      nOffset += nBasePagesCount;
    }
    else
    {
      for (UINT i = 0; i < nBasePagesCount; i++)
      {
        CCreateNewObjectPageBase* pPage = m_pages[i];
        m_psh.phpage[nOffset] = ::CreatePropertySheetPage(&(pPage->m_psp));
        nOffset++;
      } // for
    }

    // add the extension pages
    CWizExtensionSiteList* pSiteList = m_siteManager.GetExtensionSiteList();
    for (POSITION pos = pSiteList->GetHeadPosition(); pos != NULL; )
    {
      CWizExtensionSite* pSite = pSiteList->GetNext(pos);
      UINT nCurrCount = pSite->GetHPageArr()->GetCount();
      if (nCurrCount > 0)
      {
        memcpy(&(m_psh.phpage[nOffset]), pSite->GetHPageArr()->GetArr(), 
                        sizeof(HPROPSHEETPAGE)*nCurrCount);
        nOffset += nCurrCount;
      } // if
    } // for

    // add the finish page last, if any
    if (m_pFinishPage != NULL)
    {
      ASSERT( nOffset == (nTotalPageCount-1) );
      m_psh.phpage[nOffset] = ::CreatePropertySheetPage(&(m_pFinishPage->m_psp));
    }

    // finally, invoke the modal sheet
    TRACE(L"::PropertySheet(&m_psh) called with m_psh.nPages = %d\n", m_psh.nPages);

    ::PropertySheet(&m_psh);

    delete[] m_psh.phpage;
    m_psh.phpage = 0;
  }
  return m_hrReturnValue; 
}

void CCreateNewObjectWizardBase::GetPageCounts(CWizExtensionSite* pSite,
                                               /*OUT*/ LONG* pnTotal,
                                                /*OUT*/ LONG* pnStartIndex)
{
  CWizExtensionSite* pPrimarySite = m_siteManager.GetPrimaryExtensionSite();

  *pnTotal = 0;
  // get the # of primary property pages (excluding the Finish Page)
  UINT nBasePagesCount = 0;
  if (pPrimarySite != NULL)
  {
    nBasePagesCount += pPrimarySite->GetHPageArr()->GetCount();
  }
  else
  {
    nBasePagesCount += (UINT)(m_pages.GetSize()-1); // -1 because we exclude finish page
  }

  *pnTotal = nBasePagesCount + m_siteManager.GetTotalHPageCount();

  if (m_pFinishPage != NULL)
  {
    (*pnTotal)++;
  }

  if (pPrimarySite == pSite)
  {
    *pnStartIndex = 0;
  }
  else
  {
    // which site is it?
    *pnStartIndex = nBasePagesCount;
    CWizExtensionSiteList* pSiteList = m_siteManager.GetExtensionSiteList();
    for (POSITION pos = pSiteList->GetHeadPosition(); pos != NULL; )
    {
      CWizExtensionSite* pCurrSite = pSiteList->GetNext(pos);
      if (pCurrSite == pSite)
        break; // got it, we are done
      
      // keep adding the previous counts
      UINT nCurrCount = pCurrSite->GetHPageArr()->GetCount();
      (*pnStartIndex) += nCurrCount;
    } // for
  } // else

}

HWND CCreateNewObjectWizardBase::GetWnd()
{
  if (m_hWnd == NULL)
  {
    for (int i = 0; i < m_pages.GetSize(); i++)
	  {
      CCreateNewObjectPageBase* pPage = m_pages[i];
      if (pPage->m_hWnd != NULL)
      {
        m_hWnd = ::GetParent(pPage->m_hWnd);
        break;
      }
    } // for
  } // if

  if (m_hWnd == NULL)
  {
    m_hWnd = g_hWndHack;
    g_hWndHack = NULL;
  }

  ASSERT(m_hWnd != NULL);
  ASSERT(::IsWindow(m_hWnd));
  return m_hWnd;
}

void CCreateNewObjectWizardBase::AddPage(CCreateNewObjectPageBase* pPage)
{
  m_pages.Add(pPage);
  pPage->m_pWiz = this;
}


HRESULT CCreateNewObjectWizardBase::CreateNewFromPrimaryExtension(LPCWSTR pszName)
{
  // NOTICE: we call with bAllowCopy = FALSE because
  // primary extensions will have to handle the copy semantics 
  // by themselves

  // NOTICE: we pass bSilentError = TRUE because
  // primary extensions will have to handle the message for
  // creation failure

  HRESULT hr = GetInfo()->HrCreateNew(pszName, TRUE /* bSilentError */, FALSE /* bAllowCopy */);

  GetInfo()->PGetIADsPtr();
  m_siteManager.SetObject(GetInfo()->PGetIADsPtr());
  return hr;
}


void CCreateNewObjectWizardBase::SetWizardButtons(
    CCreateNewObjectPageBase* pPage, BOOL bValid)
{
  ASSERT(pPage != NULL);
  if (m_pFinishPage != NULL)
  {
    ASSERT(m_pages.GetSize() >= 1); // at least finish page
    if (pPage == (CCreateNewObjectPageBase*)m_pFinishPage)
    {
      SetWizardButtonsLast(bValid);
    }
    else
    {
      if (m_pages[0] == pPage)
        SetWizardButtonsFirst(bValid);
      else
        SetWizardButtonsMiddle(bValid);
    }
  }
  else
  {
    // single page wizard
    ASSERT(m_pages.GetSize() == 1);
    SetWizardOKCancel();
    EnableOKButton(bValid);
  }
}


HRESULT CCreateNewObjectWizardBase::SetWizardButtons(CWizExtensionSite* pSite, 
                                                     ULONG nCurrIndex, BOOL bValid)
{
  UINT nSitePagesCount = pSite->GetHPageArr()->GetCount();
  if (nSitePagesCount == 0)
  {
    // cannot call from UI less extension
    return E_INVALIDARG;
  }
  if (nCurrIndex >= nSitePagesCount)
  {
    // out of range
    return E_INVALIDARG;
  }

  // get the handle count for the secondary extensions (total for extension property pages)
  UINT nExtensionHPagesCount = m_siteManager.GetTotalHPageCount();

  if (m_siteManager.GetPrimaryExtensionSite() == pSite)
  {
    // called from the primary extension
    if ((nSitePagesCount == 1) && (nExtensionHPagesCount == 0))
    {
      // single page, so we have the OK/Cancel buttons
      SetWizardOKCancel();
      EnableOKButton(bValid);
    }
    else
    {
      // multiple pages
      if (nCurrIndex == 0)
        SetWizardButtonsFirst(bValid);
      else
        SetWizardButtonsMiddle(bValid);
    }
  }
  else
  {
    // called from a secondary extension, we must have the finish page and
    // some primary extension or primary page(s), so we are always in the middle
    ASSERT(m_pFinishPage != NULL);
    SetWizardButtonsMiddle(bValid);
  }
  return S_OK;
}



void CCreateNewObjectWizardBase::SetObjectForExtensions(CCreateNewObjectPageBase* pPage)
{
  ASSERT(pPage != NULL);
  ASSERT(pPage != m_pFinishPage);
  UINT nPages = (UINT)m_pages.GetSize();

  if (m_pFinishPage != NULL)
  {
    ASSERT(nPages > 1); // at least 1 page + finish
    if (pPage == m_pages[nPages-2])
    {
      // this is the last primary page
      // give the ADSI object pointer to all the extensions
      m_siteManager.SetObject(m_pNewADsObjectCreateInfo->PGetIADsPtr());
    }
  }
  else
  {
    // this is the case of a single primary page, but at least one
    // UI-less extension (i.e. no finish page)
    ASSERT(nPages == 1); // just this page, no finish page
    if (pPage == m_pages[0])
    {
      // this is the only primary page
      // give the ADSI object pointer to all the extensions
      m_siteManager.SetObject(m_pNewADsObjectCreateInfo->PGetIADsPtr());
    }
  } // if
}

HRESULT CCreateNewObjectWizardBase::WriteData(ULONG uContext)
{
  HRESULT hr = S_OK;
  CWizExtensionSite* pPrimarySite = m_siteManager.GetPrimaryExtensionSite();
  if (uContext == DSA_NEWOBJ_CTX_POSTCOMMIT)
  {
    // call the post commit on all the data primary pages
    if (pPrimarySite != NULL)
    {
      hr = pPrimarySite->GetNewObjExt()->WriteData(GetWnd(), uContext);
      if (FAILED(hr))
        hr = pPrimarySite->GetNewObjExt()->OnError(GetWnd(), hr, uContext);
    }
    else
    {
      for (int i = 0; i < m_pages.GetSize(); i++)
	    {
        CCreateNewObjectPageBase* pPage = m_pages[i];
        if (pPage != m_pFinishPage)
        {
          CCreateNewObjectDataPage* pDataPage = dynamic_cast<CCreateNewObjectDataPage*>(pPage);
          ASSERT(pDataPage != NULL);
          hr = pDataPage->OnPostCommit();
          if (FAILED(hr))
          {
            m_siteManager.NotifyExtensionsOnError(GetWnd(), hr, uContext);
            break;
          }
        }
      } // for
    } // if
  } // if

  if (uContext == DSA_NEWOBJ_CTX_PRECOMMIT)
  {
    // call the pre commit on all the data primary pages
    // (As per Exchange request)
    if (pPrimarySite != NULL)
    {
      hr = pPrimarySite->GetNewObjExt()->WriteData(GetWnd(), uContext);
      if (FAILED(hr))
        hr = pPrimarySite->GetNewObjExt()->OnError(GetWnd(), hr, uContext);
    }
  }

  if (SUCCEEDED(hr))
  {
    // call the extensions to write data
    hr = m_siteManager.WriteExtensionData(GetWnd(), uContext);
    if (FAILED(hr))
    {
      if (pPrimarySite != NULL)
      {
        pPrimarySite->GetNewObjExt()->OnError(GetWnd(),hr, uContext);
      }
      m_siteManager.NotifyExtensionsOnError(GetWnd(), hr, uContext);
    }
  }
  return hr;
}


void CCreateNewObjectWizardBase::GetSummaryInfoHeader(CString& s)
{
  // by default, add just the name of object
  CString szFmt; 
  szFmt.LoadString(IDS_s_CREATE_NEW_SUMMARY_NAME);
  CString szBuffer;
  szBuffer.Format((LPCWSTR)szFmt, GetInfo()->GetName());
  s += szBuffer;
}


void CCreateNewObjectWizardBase::GetSummaryInfo(CString& s)
{
  // if we have a primary site, tell it to do it all
  CWizExtensionSite* pPrimarySite = m_siteManager.GetPrimaryExtensionSite();
  if (pPrimarySite != NULL)
  {
    // the primary extension has a chance to override
    // the default behavior
    if (!pPrimarySite->GetSummaryInfo(s))
    {
      // failed, we put up the default header
      GetSummaryInfoHeader(s);
    }
  }
  else
  {
    GetSummaryInfoHeader(s);

    // go first through our pages
	  for (int i = 0; i < m_pages.GetSize(); i++)
	  {
      CCreateNewObjectPageBase* pPage = m_pages[i];
      if (pPage != m_pFinishPage)
      {
        CString szTemp;
        pPage->GetSummaryInfo(szTemp);
        if (!szTemp.IsEmpty())
        {
          s += L"\n";
          s += szTemp;
        }
      }
    } // for

    s += L"\n";

  } // if

  // go through the extension pages
  m_siteManager.GetExtensionsSummaryInfo(s);
}

HRESULT CCreateNewObjectWizardBase::RecreateObject()
{
  CWizExtensionSite* pPrimarySite = m_siteManager.GetPrimaryExtensionSite();

  // remove object from backend
  HRESULT hr = m_pNewADsObjectCreateInfo->HrDeleteFromBackend();
  if (FAILED(hr))
  {
    ASSERT(m_pNewADsObjectCreateInfo->PGetIADsPtr() != NULL);
    // could not delete from backend (possibly for lack of delete right)

    HRESULT hrDeleteFail = E_FAIL;
    if (pPrimarySite != NULL)
    {
      hrDeleteFail = pPrimarySite->GetNewObjExt()->OnError(GetWnd(), hr, DSA_NEWOBJ_CTX_CLEANUP);
    }

    if (FAILED(hrDeleteFail))
    {
      // put out a warning
      ReportErrorEx(m_hWnd,IDS_CANT_DELETE_BAD_NEW_OBJECT,S_OK,
                       MB_OK, NULL, 0);
    }
    return hr; 
  }

  // tell all the extensions to release the temporary object
  ASSERT(m_pNewADsObjectCreateInfo->PGetIADsPtr() == NULL);
  m_siteManager.SetObject(NULL);

  if (pPrimarySite != NULL)
  {
    hr = pPrimarySite->GetNewObjExt()->WriteData(GetWnd(), DSA_NEWOBJ_CTX_CLEANUP);
    ASSERT(SUCCEEDED(hr));
    if (FAILED(hr))
      return hr;
  }
  else
  {
    // collect data from the primary pages
	  // the first of them will do a create new
    for (int i = 0; i < m_pages.GetSize(); i++)
	  {
      CCreateNewObjectPageBase* pPage = m_pages[i];
      if (pPage != m_pFinishPage)
      {
        hr = ((CCreateNewObjectDataPage*)pPage)->OnPreCommit(TRUE);
        ASSERT(SUCCEEDED(hr));
        if (FAILED(hr))
          return hr; // some of the primary pages failed
      }
    } // for
  }
  
  // tell the extensions about the new object
  ASSERT(m_pNewADsObjectCreateInfo->PGetIADsPtr() != NULL);
  m_siteManager.SetObject(m_pNewADsObjectCreateInfo->PGetIADsPtr());

  // collect data from extensions
  hr = WriteData(DSA_NEWOBJ_CTX_CLEANUP);
  return hr;
}

BOOL CCreateNewObjectWizardBase::OnFinish() 
{
  CWaitCursor wait;

  BOOL bRetVal = TRUE; // default is dismiss

  // before doing the commit give the extensions a chance to 
  // write their data
  BOOL bPostCommit = FALSE;
  HRESULT hr = WriteData(DSA_NEWOBJ_CTX_PRECOMMIT);
  if (FAILED(hr))
    return FALSE; // do not dismiss

  // do the commit to the backend
  hr = m_pNewADsObjectCreateInfo->HrSetInfo(TRUE /*fSilentError*/);
  if (FAILED(hr))
  {
    // if present, the primary extension will have to handle the failure
    // by displaying an error message
    HRESULT hrSetInfoFail = E_FAIL;
    CWizExtensionSite* pPrimarySite = m_siteManager.GetPrimaryExtensionSite();
    if (pPrimarySite != NULL)
    {
      hrSetInfoFail = pPrimarySite->GetNewObjExt()->OnError(GetWnd(), hr, DSA_NEWOBJ_CTX_COMMIT);
    }

    if (FAILED(hrSetInfoFail))
    {
      // either no primary extension or not handled by it,
      // use the internal handler
      OnFinishSetInfoFailed(hr);      
    }
    return FALSE; // do not dismiss
  }


  // start the post commit phase
  bPostCommit = TRUE;
  m_pNewADsObjectCreateInfo->SetPostCommit(bPostCommit);
  hr = m_pNewADsObjectCreateInfo->HrAddDefaultAttributes();
  if (FAILED(hr))
    return FALSE; // do not dismiss

  BOOL bNeedDeleteFromBackend = FALSE;

  if (SUCCEEDED(hr))
  {
    // the commit went well, need to tell the primary pages and
    // the extensions to write
    hr = WriteData(DSA_NEWOBJ_CTX_POSTCOMMIT);
    if (FAILED(hr))
    {
      bNeedDeleteFromBackend = TRUE;
    }
  }
  m_pNewADsObjectCreateInfo->SetPostCommit(/*bPostCommit*/FALSE); // restore

  // failed the post commit, try to remove from
  // the backend and recreate a valid temporary object
  if (bNeedDeleteFromBackend)
  {
    ASSERT(bRetVal); // the wizard would be hosed
    hr = RecreateObject();
    if (FAILED(hr))
    {
      // we are really up creek
      bRetVal = TRUE; //bail out, the m_hrReturnValue will be set below
      hr = S_FALSE; // avoid error message in the snapin
    }
    else
    {
      // we deleted the committed object, we can keep the wizard up 
      return FALSE;
    }
  }

  if (bRetVal)
  {
    // we are actually dismissing the wizard,
    // set the hr value that will be returned by the modal wizard call itself
    m_hrReturnValue = hr;
  }
  return bRetVal;
}


void CCreateNewObjectWizardBase::OnFinishSetInfoFailed(HRESULT hr)
{
  PVOID apv[1] = {(LPWSTR)m_pNewADsObjectCreateInfo->GetName()};
  ReportErrorEx(GetWnd(),IDS_12_GENERIC_CREATION_FAILURE,hr,
                 MB_OK | MB_ICONERROR, apv, 1);
}

void CCreateNewObjectWizardBase::LoadCaptions()
{
  
  // compute the caption only the first time
  if (m_szCaption.IsEmpty())
  {
    LPCTSTR pszObjectClass = GetInfo()->m_pszObjectClass;
    ASSERT(pszObjectClass != NULL);
    ASSERT(lstrlen(pszObjectClass) > 0);
    WCHAR szFriendlyName[256];
    GetInfo()->GetBasePathsInfo()->GetFriendlyClassName(pszObjectClass, szFriendlyName, 256);
    
    UINT nCaptionRes = (GetInfo()->GetCopyFromObject() == NULL) ? 
                  IDS_s_CREATE_NEW : IDS_s_COPY;

    m_szCaption.Format(nCaptionRes, szFriendlyName);
    ASSERT(!m_szCaption.IsEmpty());
  }  
  if (m_szOKButtonCaption.IsEmpty())
  {
    m_szOKButtonCaption.LoadString(IDS_WIZARD_OK);
  }
}

HICON CCreateNewObjectWizardBase::GetClassIcon()
{
  if (m_hClassIcon == NULL)
  {
    DWORD dwFlags = DSGIF_ISNORMAL | DSGIF_GETDEFAULTICON;
    if (GetInfo()->IsContainer())
      dwFlags |= DSGIF_DEFAULTISCONTAINER;
    m_hClassIcon = GetInfo()->GetBasePathsInfo()->GetIcon(GetInfo()->m_pszObjectClass, 
                              dwFlags, 32,32);
  }
  return m_hClassIcon;
}

HRESULT CCreateNewObjectWizardBase::InitPrimaryExtension()
{
  ASSERT(m_pNewADsObjectCreateInfo != NULL);

  HRESULT hr = m_siteManager.CreatePrimaryExtension(
                              &(m_pNewADsObjectCreateInfo->GetCreateInfo()->clsidWizardPrimaryPage),
                              m_pNewADsObjectCreateInfo->m_pIADsContainer,
                              m_pNewADsObjectCreateInfo->m_pszObjectClass);
  return hr;
}


/////////////////////////////////////////////////////////////////////
// CIconCtrl

BEGIN_MESSAGE_MAP(CIconCtrl, CStatic)
  ON_WM_PAINT()
END_MESSAGE_MAP()

void CIconCtrl::OnPaint()
{
  PAINTSTRUCT ps;
  CDC* pDC = BeginPaint(&ps);
  if (m_hIcon != NULL)
    pDC->DrawIcon(0, 0, m_hIcon); 
  EndPaint(&ps);
}


/////////////////////////////////////////////////////////////////////
// CCreateNewObjectPageBase

#define WM_FORMAT_CAPTION (WM_USER+1)

BEGIN_MESSAGE_MAP(CCreateNewObjectPageBase, CPropertyPageEx_Mine)
  ON_MESSAGE(WM_FORMAT_CAPTION, OnFormatCaption )
END_MESSAGE_MAP()

CCreateNewObjectPageBase::CCreateNewObjectPageBase(UINT nIDTemplate)
      : CPropertyPageEx_Mine(nIDTemplate)
{
  m_pWiz = NULL;          
}          

BOOL CCreateNewObjectPageBase::OnInitDialog()
{
  CPropertyPageEx_Mine::OnInitDialog();

  // set the name of the container
  CNewADsObjectCreateInfo* pNewADsObjectCreateInfo = GetWiz()->GetInfo();
  SetDlgItemText(IDC_EDIT_CONTAINER,
                  pNewADsObjectCreateInfo->GetContainerCanonicalName());

  // set the class icon
  VERIFY(m_iconCtrl.SubclassDlgItem(IDC_STATIC_ICON, this));
  m_iconCtrl.SetIcon(GetWiz()->GetClassIcon()); 

  return TRUE;
}

BOOL CCreateNewObjectPageBase::OnSetActive()
{
  BOOL bRet = CPropertyPageEx_Mine::OnSetActive();
  PostMessage(WM_FORMAT_CAPTION);
  return bRet;
}


LONG CCreateNewObjectPageBase::OnFormatCaption(WPARAM, LPARAM)
{
  // set the title of the Wizard window
  HWND hWndSheet = ::GetParent(m_hWnd);
  ASSERT(::IsWindow(hWndSheet));
  ::SetWindowText(hWndSheet, (LPCWSTR)GetWiz()->GetCaption());
  return 0;
}


/////////////////////////////////////////////////////////////////////
// CCreateNewObjectDataPage


CCreateNewObjectDataPage::CCreateNewObjectDataPage(UINT nIDTemplate)
: CCreateNewObjectPageBase(nIDTemplate)
{
  m_bFirstTimeGetDataCalled = TRUE;
}

BOOL CCreateNewObjectDataPage::OnSetActive()
{
  BOOL bValid = FALSE;
  if (m_bFirstTimeGetDataCalled)
  {
    // first time we call, pass the IADs* pIADsCopyFrom pointer we copy from
    IADs* pIADsCopyFrom = GetWiz()->GetInfo()->GetCopyFromObject();
    bValid = GetData(pIADsCopyFrom);
    m_bFirstTimeGetDataCalled = FALSE;
  }
  else
  {
    bValid = GetData(NULL);
  }

  GetWiz()->SetWizardButtons(this, bValid);
  return CCreateNewObjectPageBase::OnSetActive();
}

LRESULT CCreateNewObjectDataPage::OnWizardNext()
{
  CWaitCursor wait;
  // move to next page only if SetData() succeeded
  if (SUCCEEDED(SetData()))
  {
    // if this is the last primary page, notify the extensions
    GetWiz()->SetObjectForExtensions(this);
    return 0; // move to the next page
  }
  return -1; // do not advance
}

LRESULT CCreateNewObjectDataPage::OnWizardBack()
{
  // move to prev page only if SetData() succeeded
  return SUCCEEDED(SetData()) ? 0 : -1;
}

BOOL CCreateNewObjectDataPage::OnKillActive()
{
  // we do not know what page it will jump to, so we
  // set it to the most sensible choice for an extension
  GetWiz()->SetWizardButtonsMiddle(TRUE);
  return CCreateNewObjectPageBase::OnKillActive();
}

BOOL CCreateNewObjectDataPage::OnWizardFinish()
{
  // this method is called only if this page is the 
  // last one  (that is this is the only primary native page
  // and there are no pages from secondary extensions)
  if (FAILED(SetData()))
    return FALSE;

  // notify the extensions of a new IADs* pointer
  GetWiz()->SetObjectForExtensions(this);

  return GetWiz()->OnFinish();
}


/////////////////////////////////////////////////////////////////////
// CCreateNewObjectFinishPage

BEGIN_MESSAGE_MAP(CCreateNewObjectFinishPage, CCreateNewObjectPageBase)
  ON_EN_SETFOCUS(IDC_EDIT_SUMMARY, OnSetFocusEdit)
END_MESSAGE_MAP()


CCreateNewObjectFinishPage::CCreateNewObjectFinishPage()
: CCreateNewObjectPageBase(CCreateNewObjectFinishPage::IDD)
{
  m_bNeedSetFocus = FALSE;
}

BOOL CCreateNewObjectFinishPage::OnSetActive()
{
  // need to collect all info from pages
  // and put it in the summary info edit box
  CString szBuf;
  GetWiz()->GetSummaryInfo(szBuf);
  WriteSummary(szBuf);
  m_bNeedSetFocus = TRUE;

  GetWiz()->SetWizardButtons(this, TRUE);
  return CCreateNewObjectPageBase::OnSetActive();
}

BOOL CCreateNewObjectFinishPage::OnKillActive()
{
  GetWiz()->SetWizardButtonsMiddle(TRUE);
  return CCreateNewObjectPageBase::OnKillActive();
}

BOOL CCreateNewObjectFinishPage::OnWizardFinish()
{
  return GetWiz()->OnFinish();
}


void CCreateNewObjectFinishPage::OnSetFocusEdit()
{
  CEdit* pEdit = (CEdit*)GetDlgItem(IDC_EDIT_SUMMARY);
	pEdit->SetSel(-1,0, TRUE);
   if (m_bNeedSetFocus)
  {
    m_bNeedSetFocus = FALSE;
    TRACE(_T("Resetting Focus\n"));

    HWND hwndSheet = ::GetParent(m_hWnd);
    ASSERT(::IsWindow(hwndSheet));
    HWND hWndFinishCtrl =::GetDlgItem(hwndSheet, 0x3025);
    ASSERT(::IsWindow(hWndFinishCtrl));
    ::SetFocus(hWndFinishCtrl);
  }
}

void CCreateNewObjectFinishPage::WriteSummary(LPCWSTR lpszSummaryText)
{
  // allocate temporary buffer
  size_t nLen = wcslen(lpszSummaryText) + 1;
  WCHAR* pBuf = new WCHAR[nLen*2];
  if (!pBuf)
  {
    return;
  }

  // change '\n' into '\r\n' sequence
  LPCTSTR pSrc = lpszSummaryText;
  TCHAR* pDest = pBuf;
  while (*pSrc != NULL)
  {
    if ( ( pSrc != lpszSummaryText) && 
          (*(pSrc-1) != TEXT('\r')) && (*pSrc == TEXT('\n')) )
    {
      *(pDest++) = '\r';
    }
    *(pDest++) = *(pSrc++);
  }
  *pDest = NULL; // NULL terminate the destination buffer

  CEdit* pEdit = (CEdit*)GetDlgItem(IDC_EDIT_SUMMARY);
  pEdit->SetWindowText(pBuf);
  delete[] pBuf;
  pBuf = 0;
}

///////////////////////////////////////////////////////////////////
// CCreateNewNamedObjectPage

BEGIN_MESSAGE_MAP(CCreateNewNamedObjectPage, CCreateNewObjectDataPage)
  ON_EN_CHANGE(IDC_EDIT_OBJECT_NAME, OnNameChange)
END_MESSAGE_MAP()

BOOL CCreateNewNamedObjectPage::ValidateName(LPCTSTR)
{
	return TRUE;
}

BOOL CCreateNewNamedObjectPage::OnInitDialog() 
{
  CCreateNewObjectDataPage::OnInitDialog();

  SetDlgItemText(IDC_EDIT_OBJECT_NAME, GetWiz()->GetInfo()->m_strDefaultObjectName);
  return TRUE;
}

BOOL CCreateNewNamedObjectPage::GetData(IADs*)
{
  return !m_strName.IsEmpty();
}

void CCreateNewNamedObjectPage::OnNameChange()
{
  GetDlgItemText(IDC_EDIT_OBJECT_NAME, OUT m_strName);
  m_strName.TrimLeft();
  m_strName.TrimRight();
  // Enable the OK button only if the name is not empty
  GetWiz()->SetWizardButtons(this, !m_strName.IsEmpty());
}

HRESULT CCreateNewNamedObjectPage::SetData(BOOL)
{
  if ( !ValidateName( m_strName ) )
	return E_INVALIDARG;
  // Store the object name in the temporary storage
  HRESULT hr = GetWiz()->GetInfo()->HrCreateNew(m_strName);
  return hr;
}

///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
// NEW CN UNC WIZARD

BEGIN_MESSAGE_MAP(CCreateNewVolumePage, CCreateNewObjectDataPage)
  ON_EN_CHANGE(IDC_EDIT_OBJECT_NAME, OnNameChange)
  ON_EN_CHANGE(IDC_EDIT_UNC_PATH, OnPathChange)
END_MESSAGE_MAP()

CCreateNewVolumePage::CCreateNewVolumePage()
: CCreateNewObjectDataPage(CCreateNewVolumePage::IDD)
{
}

BOOL CCreateNewVolumePage::OnInitDialog() 
{
  CCreateNewObjectDataPage::OnInitDialog();
  SetDlgItemText(IDC_EDIT_OBJECT_NAME, GetWiz()->GetInfo()->m_strDefaultObjectName);
  Edit_LimitText(GetDlgItem(IDC_EDIT_OBJECT_NAME)->m_hWnd, 64);
  Edit_LimitText (GetDlgItem(IDC_EDIT_UNC_PATH)->m_hWnd, MAX_PATH - 1);
  return TRUE;
}

void CCreateNewVolumePage::OnNameChange()
{
  GetDlgItemText(IDC_EDIT_OBJECT_NAME, OUT m_strName);
  m_strName.TrimLeft();
  m_strName.TrimRight();
  _UpdateUI();
}

void CCreateNewVolumePage::OnPathChange()
{
  GetDlgItemText(IDC_EDIT_UNC_PATH, OUT m_strUncPath);
  m_strUncPath.TrimLeft();
  m_strUncPath.TrimRight();
  _UpdateUI();
}

void CCreateNewVolumePage::_UpdateUI()
{
  //
  // Enable the OK button only if both name and path are not empty and it is a valid 
  // UNC path
  //
  BOOL bIsValidShare = FALSE;
  DWORD dwPathType = 0;
  if (!I_NetPathType(NULL, (PWSTR)(PCWSTR)m_strUncPath, &dwPathType, 0) && dwPathType == ITYPE_UNC)
  {
    bIsValidShare = TRUE;
  }

  GetWiz()->SetWizardButtons(this, !m_strName.IsEmpty() && bIsValidShare);
}

BOOL CCreateNewVolumePage::GetData(IADs*)
{
  return !m_strName.IsEmpty() && !m_strUncPath.IsEmpty();
}

HRESULT CCreateNewVolumePage::SetData(BOOL)
{
  // Store the object name in the temporary storage
  CNewADsObjectCreateInfo* pNewADsObjectCreateInfo = GetWiz()->GetInfo();
  HRESULT hr = pNewADsObjectCreateInfo->HrCreateNew(m_strName);
  if (FAILED(hr))
  {
    return hr;
  }
  
  hr = pNewADsObjectCreateInfo->HrAddVariantBstr(const_cast<PWSTR>(gsz_uNCName), m_strUncPath);
  ASSERT(SUCCEEDED(hr));
  return hr;
}

CCreateNewVolumeWizard:: CCreateNewVolumeWizard(CNewADsObjectCreateInfo* pNewADsObjectCreateInfo) : 
    CCreateNewObjectWizardBase(pNewADsObjectCreateInfo)
{
  AddPage(&m_page1);
}

///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
// NEW PRINT QUEUE WIZARD

BEGIN_MESSAGE_MAP(CCreateNewPrintQPage, CCreateNewObjectDataPage)
  ON_EN_CHANGE(IDC_EDIT_UNC_PATH, OnPathChange)
END_MESSAGE_MAP()


CCreateNewPrintQPage::CCreateNewPrintQPage() 
: CCreateNewObjectDataPage(CCreateNewPrintQPage::IDD)
{
}

BOOL CCreateNewPrintQPage::GetData(IADs*) 
{
  CNewADsObjectCreateInfo* pNewADsObjectCreateInfo = GetWiz()->GetInfo();

  CComPtr<IADs> spObj;
  HRESULT hr = pNewADsObjectCreateInfo->m_pIADsContainer->QueryInterface(
                  IID_IADs, (void **)&spObj);
  if (SUCCEEDED(hr)) 
  {
    CComBSTR bsPath;
    spObj->get_ADsPath (&bsPath);
    m_strContainer = bsPath;
  }
  return FALSE;
}

void CCreateNewPrintQPage::OnPathChange()
{
  GetDlgItemText(IDC_EDIT_UNC_PATH, OUT m_strUncPath);
  m_strUncPath.TrimLeft();
  m_strUncPath.TrimRight();
  _UpdateUI();
}

void CCreateNewPrintQPage::_UpdateUI()
{
  // Enable the OK button only if both name and path are not empty
  GetWiz()->SetWizardButtons(this, !m_strUncPath.IsEmpty());
}

HRESULT CCreateNewPrintQPage::SetData(BOOL bSilent)
{
  CNewADsObjectCreateInfo* pNewADsObjectCreateInfo = GetWiz()->GetInfo();

  CWaitCursor CWait;

  HINSTANCE hWinspool = NULL;
  BOOL (*pfnPublishPrinter)(HWND, PCWSTR, PCWSTR, PCWSTR, PWSTR *, DWORD);
  hWinspool = LoadLibrary(L"Winspool.drv");
  if (!hWinspool) 
  {
    INT Result2 = GetLastError();
    if (!bSilent)
    {
      PVOID apv[1] = {(LPWSTR)(LPCWSTR)m_strUncPath};
      ReportErrorEx (::GetParent(m_hWnd),IDS_12_FAILED_TO_CREATE_PRINTER,HRESULT_FROM_WIN32(Result2),
                     MB_OK | MB_ICONERROR, apv, 1);
    }
    return HRESULT_FROM_WIN32(Result2);
  }
  pfnPublishPrinter =   (BOOL (*)(HWND, PCWSTR, PCWSTR, PCWSTR, PWSTR *, DWORD)) 
                                GetProcAddress(hWinspool, (LPCSTR) 217);
  if (!pfnPublishPrinter) 
  {
    INT Result2 = GetLastError();
    if (!bSilent)
    {
      PVOID apv[1] = {(LPWSTR)(LPCWSTR)m_strUncPath};
      ReportErrorEx (::GetParent(m_hWnd),IDS_12_FAILED_TO_CREATE_PRINTER,HRESULT_FROM_WIN32(Result2),
                     MB_OK | MB_ICONERROR, apv, 1);
    }
    FreeLibrary(hWinspool);
    return HRESULT_FROM_WIN32(Result2);
  }


  BOOL Result = pfnPublishPrinter ( m_hWnd,
                                   (LPCWSTR)m_strUncPath,
                                   (LPCWSTR)m_strContainer,
                                   (LPCWSTR)NULL,
                                   &m_pwszNewObj,
                                   PUBLISHPRINTER_QUERY);

  FreeLibrary(hWinspool);


  if (!Result) 
  {
    INT Result2 = GetLastError();
    if (Result2 == ERROR_INVALID_LEVEL)
    {
      if (!bSilent)
      {
        ReportErrorEx (::GetParent(m_hWnd),IDS_CANT_CREATE_NT5_PRINTERS,S_OK,
                       MB_OK, NULL, 0);
      }
    } 
    else 
    {
      if (!bSilent)
      {
        PVOID apv[1] = {(LPWSTR)(LPCWSTR)m_strUncPath};
        ReportErrorEx (::GetParent(m_hWnd),IDS_12_FAILED_TO_CREATE_PRINTER,HRESULT_FROM_WIN32(Result2),
                       MB_OK | MB_ICONERROR, apv, 1);
      }
    }
    return HRESULT_FROM_WIN32(Result2);
  } 
  else 
  {
    IADs* pIADs = NULL;
    HRESULT hr = DSAdminOpenObject(m_pwszNewObj,
                                   IID_IADs, 
                                   (void **)&pIADs,
                                   TRUE /*bServer*/);
  
    GlobalFree(m_pwszNewObj);
    m_pwszNewObj = NULL;

    if (SUCCEEDED(hr)) 
    {
      pNewADsObjectCreateInfo->SetIADsPtr(pIADs);
      pIADs->Release(); // addref'd by the above Set()
    } 
    else 
    {
      if (!bSilent)
      {
        PVOID apv[1] = {(LPWSTR)(LPCWSTR)m_strUncPath};
        ReportErrorEx (m_hWnd,IDS_12_FAILED_TO_ACCESS_PRINTER,hr,
                       MB_OK | MB_ICONERROR, apv, 1);  
      }
      return hr;
    }

  }
  return S_OK;
}

CCreateNewPrintQWizard:: CCreateNewPrintQWizard(CNewADsObjectCreateInfo* pNewADsObjectCreateInfo) : 
    CCreateNewObjectWizardBase(pNewADsObjectCreateInfo)
{
  AddPage(&m_page1);
}

///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
// NEW COMPUTER WIZARD

BEGIN_MESSAGE_MAP(CCreateNewComputerPage, CCreateNewObjectDataPage)
  ON_EN_CHANGE(IDC_EDIT_DNS_NAME, OnNameChange)
  ON_EN_CHANGE(IDC_EDIT_SAM_NAME, OnSamNameChange)
  ON_BN_CLICKED(IDC_CHANGE_PRINCIPAL_BUTTON, OnChangePrincipalButton)
END_MESSAGE_MAP()

CCreateNewComputerPage::CCreateNewComputerPage()
: CCreateNewObjectDataPage(CCreateNewComputerPage::IDD)
{
}

BOOL CCreateNewComputerPage::OnInitDialog() 
{
  Edit_LimitText (GetDlgItem(IDC_EDIT_DNS_NAME)->m_hWnd, 63);
  Edit_LimitText (GetDlgItem(IDC_EDIT_SAM_NAME)->m_hWnd, 15);

  CCreateNewObjectDataPage::OnInitDialog();

  CString szDefault;
  szDefault.LoadString(IDS_NEW_COMPUTER_PRINCIPAL_DEFAULT);
  SetDlgItemText(IDC_PRINCIPAL_EDIT, szDefault);

  return TRUE;
}

BOOL CCreateNewComputerPage::GetData(IADs*) 
{
  return !m_strName.IsEmpty(); //we need a computer name
}





inline LPWSTR WINAPI MyA2WHelper(LPWSTR lpw, LPCSTR lpa, int nChars, UINT acp)
{
	ATLASSERT(lpa != NULL);
	ATLASSERT(lpw != NULL);
	// verify that no illegal character present
	// since lpw was allocated based on the size of lpa
	// don't worry about the number of chars
	lpw[0] = '\0';
	MultiByteToWideChar(acp, 0, lpa, -1, lpw, nChars);
	return lpw;
}


#define A2W_OEM(lpa) (\
	((_lpaMine = lpa) == NULL) ? NULL : (\
		_convert = (lstrlenA(_lpaMine)+1),\
		MyA2WHelper((LPWSTR) alloca(_convert*2), _lpaMine, _convert, CP_OEMCP)))


void _UnicodeToOemConvert(IN PCWSTR pszUnicode, OUT CString& szOemUnicode)
{
  USES_CONVERSION;

  // add this for the macro to work
  PCSTR _lpaMine = NULL;

  // convert to CHAR OEM
  int nLen = lstrlen(pszUnicode);
  PSTR pszOemAnsi = new CHAR[3*(nLen+1)]; // more, to be sure...
  if (pszOemAnsi)
  {
    CharToOem(pszUnicode, pszOemAnsi);

    // convert it back to WCHAR on OEM CP
    szOemUnicode = A2W_OEM(pszOemAnsi);
    delete[] pszOemAnsi;
    pszOemAnsi = 0;
  }
}

void CCreateNewComputerPage::OnNameChange()
{
  GetDlgItemText(IDC_EDIT_DNS_NAME, OUT m_strName);
  m_strName.TrimLeft();
  m_strName.TrimRight();
  
  // generate a SAM account name from the name
  CONST DWORD computerNameLen = 32;
  DWORD Len = computerNameLen;
  WCHAR szDownLevel[computerNameLen];

  if (m_strName.IsEmpty())
  {
    Len = 0;
  }
  else
  {
    // generate the SAM account name from CN

    // run through the OEM conversion, just to
    // behave the same way as typing in the OEM
    // edit box
    CString szOemUnicode;
    _UnicodeToOemConvert(m_strName, szOemUnicode);
    //TRACE(L"szOemUnicode = %s\n", (LPCWSTR)szOemUnicode);
  
    // run through the DNS validation
    if (!DnsHostnameToComputerName((LPWSTR)(LPCWSTR)szOemUnicode, szDownLevel, &Len))
    {
      Len = 0;
    }
  }

  if (Len > 0)
  {
    m_strSamName = szDownLevel;
  }
  else
  {
    m_strSamName.Empty();
  }

  SetDlgItemText(IDC_EDIT_SAM_NAME, m_strSamName);

  GetWiz()->SetWizardButtons(this, 
            !m_strName.IsEmpty() && !m_strSamName.IsEmpty());
}

void CCreateNewComputerPage::OnSamNameChange()
{
  GetDlgItemText(IDC_EDIT_SAM_NAME, OUT m_strSamName);

  GetWiz()->SetWizardButtons(this, 
            !m_strName.IsEmpty() && !m_strSamName.IsEmpty());
}


HRESULT CCreateNewComputerPage::_ValidateSamName()
{
  ASSERT(!m_strSamName.IsEmpty());

  // prep name for error if needed
  PVOID apv[1] = {(LPWSTR)(LPCWSTR)m_strSamName};
  
  CONST DWORD computerNameLen = 32;
  DWORD Len = computerNameLen;
  WCHAR szDownLevel[computerNameLen];
  UINT status = 0;
  UINT answer = IDNO;

  NET_API_STATUS netstatus = I_NetNameValidate( 0,
                                             (LPWSTR)(LPCWSTR)m_strSamName,
                                             NAMETYPE_COMPUTER,
                                             0);
  if (netstatus != NERR_Success) {
    ReportErrorEx(m_hWnd,IDS_12_INVALID_SAM_COMPUTER_NAME,HRESULT_FROM_WIN32(netstatus),
                   MB_OK | MB_ICONERROR, apv, 1);
    return HRESULT_FROM_WIN32(netstatus);
  }    

  status = DnsValidateDnsName_W((LPWSTR)(LPCWSTR)m_strSamName);
  if (status == DNS_ERROR_NON_RFC_NAME) {
    answer = ReportErrorEx(m_hWnd,IDS_12_NON_RFC_SAM_COMPUTER_NAME,HRESULT_FROM_WIN32(status),
                           MB_YESNO | MB_ICONWARNING, apv, 1);
    if (answer == IDNO) {
      return HRESULT_FROM_WIN32(status);
    }
  } else {
    if (status != ERROR_SUCCESS) {
      ReportErrorEx(m_hWnd,IDS_12_INVALID_SAM_COMPUTER_NAME,HRESULT_FROM_WIN32(status),
                    MB_OK | MB_ICONERROR, apv, 1);
      return HRESULT_FROM_WIN32(status);
    }
  }

  if (m_strSamName.Find(L".") >= 0) {
    ReportErrorEx(m_hWnd,IDS_12_SAM_COMPUTER_NAME_DOTTED,S_OK/*ignored*/,
                   MB_OK | MB_ICONERROR, apv, 1);
    return HRESULT_FROM_WIN32(DNS_STATUS_DOTTED_NAME);
  }


  // further validate the SAM account name, to make sure it did not get changed
  
  BOOL bValidSamName = 
        DnsHostnameToComputerName((LPWSTR)(LPCWSTR)m_strSamName, szDownLevel, &Len);

  TRACE(L"DnsHostnameToComputerName(%s) returned szDownLevel = %s and bValidSamName = 0x%x\n", 
                        (LPCWSTR)m_strSamName, szDownLevel, bValidSamName);


  if (!bValidSamName || (_wcsicmp(m_strSamName, szDownLevel) != 0))
  {
    ReportErrorEx(m_hWnd,IDS_12_SAM_COMPUTER_NAME_NOT_VALIDATED, S_OK/*ignored*/,
                   MB_OK | MB_ICONERROR, apv, 1);

    return E_FAIL;
  }


  return S_OK;
}


HRESULT CCreateNewComputerPage::_ValidateName()
{
  // prep name for error if needed
  PVOID apv[1] = {(LPWSTR)(LPCWSTR)m_strName};
  
  UINT status = 0;
  UINT answer = IDNO;

  NET_API_STATUS netstatus = I_NetNameValidate( 0,
                                             (LPWSTR)(LPCWSTR)m_strName,
                                             NAMETYPE_COMPUTER,
                                             0);
  if (netstatus != NERR_Success) {
    ReportErrorEx(m_hWnd,IDS_12_INVALID_COMPUTER_NAME,HRESULT_FROM_WIN32(netstatus),
                   MB_OK | MB_ICONERROR, apv, 1);
    return HRESULT_FROM_WIN32(netstatus);
  }    

  status = DnsValidateDnsName_W((LPWSTR)(LPCWSTR)m_strName);
  if (status == DNS_ERROR_NON_RFC_NAME) {
    answer = ReportErrorEx(m_hWnd,IDS_12_NON_RFC_COMPUTER_NAME,HRESULT_FROM_WIN32(status),
                           MB_YESNO | MB_ICONWARNING, apv, 1);
    if (answer == IDNO) {
      return HRESULT_FROM_WIN32(status);
    }
  } else {
    if (status != ERROR_SUCCESS) {
      ReportErrorEx(m_hWnd,IDS_12_INVALID_COMPUTER_NAME,HRESULT_FROM_WIN32(status),
                    MB_OK | MB_ICONERROR, apv, 1);
      return HRESULT_FROM_WIN32(status);
    }
  }

  if (m_strName.Find(L".") >= 0) {
    ReportErrorEx(m_hWnd,IDS_12_COMPUTER_NAME_DOTTED,S_OK/*ignored*/,
                   MB_OK | MB_ICONERROR, apv, 1);
    return HRESULT_FROM_WIN32(DNS_STATUS_DOTTED_NAME);
  }
  return S_OK;
}

HRESULT CCreateNewComputerPage::SetData(BOOL)
{
  CNewADsObjectCreateInfo* pNewADsObjectCreateInfo = GetWiz()->GetInfo();

  // name validation
  HRESULT hr = _ValidateName();
  if (FAILED(hr))
  {
    TRACE(L"_ValidateName() failed\n");
    return hr;
  }

  hr = _ValidateSamName();
  if (FAILED(hr))
  {
    TRACE(L"_ValidateSamName() failed\n");
    return hr;
  }

  // do object creation
  hr = pNewADsObjectCreateInfo->HrCreateNew(m_strName);
  if (FAILED(hr))
  {
    return hr;
  }

  // create the ADSI attribute by adding $ at the end
  CString szTemp = m_strSamName + L"$";
  hr = pNewADsObjectCreateInfo->HrAddVariantBstr(const_cast<PWSTR>(gsz_samAccountName), szTemp);

  // set the account type and the desired flags
  LONG lFlags = UF_WORKSTATION_TRUST_ACCOUNT | UF_ACCOUNTDISABLE | UF_PASSWD_NOTREQD;
  hr = pNewADsObjectCreateInfo->HrAddVariantLong(const_cast<PWSTR>(gsz_userAccountControl), lFlags);

  ASSERT(SUCCEEDED(hr));

  return hr;
}

HRESULT CCreateNewComputerPage::OnPostCommit(BOOL bSilent)
{
  HRESULT hr;
  CNewADsObjectCreateInfo* pNewADsObjectCreateInfo = GetWiz()->GetInfo();
  IADs * pIADs = NULL;
  IADsUser * pIADsUser = NULL;
  BOOL bSetPasswordOK = FALSE;
  BOOL bSetSecurityOK = FALSE;

  //prepare for error message, if needed
  PVOID apv[1] = {(LPWSTR)(LPCWSTR)m_strName};
  
  // The object was created successfully, so try to update some other attributes

  // try to set the password
  pIADs = pNewADsObjectCreateInfo->PGetIADsPtr();
  ASSERT(pIADs != NULL);
  hr = pIADs->QueryInterface(IID_IADsUser, OUT (void **)&pIADsUser);
  if (FAILED(hr) && !bSilent)
  {
    ASSERT(FALSE); // should never get here in normal operations
    ReportErrorEx(::GetParent(m_hWnd),IDS_ERR_FATAL,hr,
               MB_OK | MB_ICONERROR, NULL, 0);
  }
  else
  {
    ASSERT(pIADsUser != NULL);
    
    if (IsDlgButtonChecked(IDC_NT4_CHECK))
    {
      // NT 4 password, "$<computername>"
      CString szPassword;
      szPassword = m_strSamName;
      szPassword = szPassword.Left(14);
      INT loc = szPassword.Find(L"$");
      if (loc > 0) {
        szPassword = szPassword.Left(loc);
      }
      szPassword.MakeLower();
      CWaitCursor cwait;

      TRACE(L"Setting NT 4 style password\n");
      hr = pIADsUser->SetPassword(const_cast<LPTSTR>((LPCTSTR)szPassword));
    }
    else
    {
      // W2K password, randomly generated. The generated password
      // is not necessarily readable
      CWaitCursor cwait;
      HCRYPTPROV hCryptProv = NULL;
      if (::CryptAcquireContext(&hCryptProv, NULL, NULL, 
                                      PROV_RSA_FULL, 
                                      CRYPT_SILENT|CRYPT_VERIFYCONTEXT))
      {
        int nChars = 14; // password length
        WCHAR* pszPassword = new WCHAR[nChars+1]; // allow one more for NULL
        if (!pszPassword)
        {
          return E_OUTOFMEMORY;
        }

        if (::CryptGenRandom(hCryptProv, (nChars*sizeof(WCHAR)), (BYTE*)pszPassword))
        {
          // there is a VERY REMOTE possibility of a 16 bit
          // pattern of all zeroes that looks like a WCHAR NULL
          // so we check this and we substitute an arbitrary value
          for (int k=0; k<nChars; k++)
          {
            if (pszPassword[k] == NULL)
              pszPassword[k] = 0x1; // arbitrary
          }
          // put a NULL at the end
          pszPassword[nChars] = NULL;
          ASSERT(lstrlen(pszPassword) == nChars);

          TRACE(L"Setting W2K random password\n");
          hr = pIADsUser->SetPassword(pszPassword);
        }
        else
        {
          // CryptGenRandom() failed 
          hr = HRESULT_FROM_WIN32(::GetLastError());
        }
        ::CryptReleaseContext(hCryptProv, 0x0);
        delete[] pszPassword;
        pszPassword = 0;
      }
      else
      {
        // CryptAcquireContext() failed 
        hr = HRESULT_FROM_WIN32(::GetLastError());
      }
    } // QI

    if (SUCCEEDED(hr))
    {
      bSetPasswordOK = TRUE;
    }
    else
    {
      if (!bSilent)
      {
        ReportErrorEx (::GetParent(m_hWnd),IDS_12_CANT_SET_COMP_PWD,hr,
                       MB_OK | MB_ICONWARNING, apv, 1);
      }
    }
    pIADsUser->Release();
  }
  
  // try to write ACL
  hr = S_OK;
  if (m_securityPrincipalSidHolder.Get() == NULL)
  {
    // no need to set the ACL, we are fine
    bSetSecurityOK = TRUE;
  }
  else
  {
    CWaitCursor cwait;
    hr = SetSecurity();
  }
  if (SUCCEEDED(hr))
  {
    bSetSecurityOK = TRUE;
  }
  else
  {
    TRACE1("INFO: Unable to set security for computer %s.\n", (LPCTSTR)m_strName);
    if (!bSilent)
    {
      ReportErrorEx (::GetParent(m_hWnd),IDS_12_UNABLE_TO_WRITE_COMP_ACL,hr,
                     MB_OK | MB_ICONWARNING, apv, 1);
    }
  }

  hr = S_OK;
  if (bSetPasswordOK && bSetSecurityOK)
  {
    // success on the first steps, finally can enable the account
    CComVariant varAccount;
    hr = pNewADsObjectCreateInfo->HrGetAttributeVariant(const_cast<PWSTR>(gsz_userAccountControl), OUT &varAccount);
    if (SUCCEEDED(hr))
    {
      // got user account control, can change flag
      ASSERT(varAccount.vt == VT_I4);
      varAccount.lVal &= ~UF_ACCOUNTDISABLE;
  
      hr = pNewADsObjectCreateInfo->HrAddVariantLong(const_cast<PWSTR>(gsz_userAccountControl), varAccount.lVal);
      
      if (SUCCEEDED(hr))
      {
        // Try to persist the changes
        CWaitCursor cwait;
        hr = pNewADsObjectCreateInfo->HrSetInfo(TRUE /* fSilentError */);
      }
    }
    // handle errors, if any
    if (FAILED(hr)) 
    {
      TRACE1("INFO: Unable to commit account control for computer %s.\n", (LPCTSTR)m_strName);
      if (!bSilent)
      {
        ReportErrorEx (::GetParent(m_hWnd),IDS_12_UNABLE_TO_WRITE_ACCT_CTRL,hr,
                       MB_OK | MB_ICONWARNING, apv, 1);
      }
      hr = S_OK; // treat as a warning, the account is left disabled
    }
  }
  return hr;
} 

#define FILTER_ONE (UGOP_USERS | \
                    UGOP_ACCOUNT_GROUPS_SE | \
                    UGOP_RESOURCE_GROUPS_SE | \
                    UGOP_UNIVERSAL_GROUPS_SE | \
                    UGOP_BUILTIN_GROUPS | \
                    UGOP_WELL_KNOWN_PRINCIPALS_USERS \
                    )


#define FILTER_TWO (UGOP_USERS | \
                    UGOP_ACCOUNT_GROUPS_SE | \
                    UGOP_UNIVERSAL_GROUPS_SE | \
                    UGOP_WELL_KNOWN_PRINCIPALS_USERS | \
                    UGOP_USERS | \
                    UGOP_GLOBAL_GROUPS | \
                    UGOP_ALL_NT4_WELLKNOWN_SIDS \
                    )



void CCreateNewComputerPage::GetSummaryInfo(CString& s)
{
  if (IsDlgButtonChecked(IDC_NT4_CHECK))
  {
    CString sz;
    sz.LoadString(IDS_COMPUTER_CREATE_DLG_NT4_ACCOUNT);
    s += sz;
    s += L"\n";
  }
}



HRESULT CCreateNewComputerPage::_LookupSamAccountNameFromSid(PSID pSid, 
                                                             CString& szSamAccountName)
{
  HRESULT hr = S_OK;
  // need to use the SID and lookup the SAM account name
  WCHAR szName[MAX_PATH], szDomain[MAX_PATH];
  DWORD cchName = MAX_PATH-1, cchDomain = MAX_PATH-1;
  SID_NAME_USE sne;

  LPCWSTR lpszServerName = GetWiz()->GetInfo()->GetBasePathsInfo()->GetServerName();
  if (!LookupAccountSid(lpszServerName, pSid, szName, &cchName, szDomain, &cchDomain, &sne))
  {
    DWORD dwErr = GetLastError();
    TRACE(_T("LookupAccountSid failed with error %d\n"), dwErr);
    return HRESULT_FROM_WIN32(dwErr);
  }

  szSamAccountName = szDomain;
  szSamAccountName += L"\\";
  szSamAccountName += szName;
  return hr;
}





DSOP_SCOPE_INIT_INFO g_aComputerPrincipalDSOPScopes[] =
{
#if 0
    {
        cbSize,
        flType,
        flScope,
        {
            { flBothModes, flMixedModeOnly, flNativeModeOnly },
            flDownlevel,
        },
        pwzDcName,
        pwzADsPath,
        hr // OUT
    },
#endif

    // The Global Catalog
    {
        sizeof(DSOP_SCOPE_INIT_INFO),
        DSOP_SCOPE_TYPE_GLOBAL_CATALOG,
        DSOP_SCOPE_FLAG_DEFAULT_FILTER_USERS | DSOP_SCOPE_FLAG_DEFAULT_FILTER_GROUPS,
        {
            { DSOP_FILTER_INCLUDE_ADVANCED_VIEW | DSOP_FILTER_USERS | 
              DSOP_FILTER_UNIVERSAL_GROUPS_SE | DSOP_FILTER_GLOBAL_GROUPS_SE | 
              DSOP_FILTER_WELL_KNOWN_PRINCIPALS, 0, 0 },
            0,
        },
        NULL,
        NULL,
        S_OK
    },

    // The domain to which the target computer is joined.
    {
        sizeof(DSOP_SCOPE_INIT_INFO),
        DSOP_SCOPE_TYPE_UPLEVEL_JOINED_DOMAIN,
        DSOP_SCOPE_FLAG_STARTING_SCOPE |
        DSOP_SCOPE_FLAG_DEFAULT_FILTER_USERS | DSOP_SCOPE_FLAG_DEFAULT_FILTER_GROUPS,
        {
          // joined domain is always NT5 for DS ACLs Editor
          { 0, 
          //mixed: users, well known SIDs, local groups, builtin groups, global groups, computers
          DSOP_FILTER_INCLUDE_ADVANCED_VIEW | DSOP_FILTER_USERS  | 
          DSOP_FILTER_WELL_KNOWN_PRINCIPALS | DSOP_FILTER_DOMAIN_LOCAL_GROUPS_SE | 
          DSOP_FILTER_BUILTIN_GROUPS | DSOP_FILTER_GLOBAL_GROUPS_SE, 

          //native users, well known SIDs, local groups, builtin groups, global groups, universal groups, computers
          DSOP_FILTER_INCLUDE_ADVANCED_VIEW | DSOP_FILTER_USERS  | DSOP_FILTER_WELL_KNOWN_PRINCIPALS | 
          DSOP_FILTER_DOMAIN_LOCAL_GROUPS_SE | DSOP_FILTER_BUILTIN_GROUPS |
          DSOP_FILTER_GLOBAL_GROUPS_SE | DSOP_FILTER_UNIVERSAL_GROUPS_SE
          },
        0, // zero for downlevel joined domain, should be DS-aware
        },
        NULL,
        NULL,
        S_OK
    },

    // The domains in the same forest (enterprise) as the domain to which
    // the target machine is joined.  Note these can only be DS-aware
    {
        sizeof(DSOP_SCOPE_INIT_INFO),
        DSOP_SCOPE_TYPE_ENTERPRISE_DOMAIN,
        DSOP_SCOPE_FLAG_DEFAULT_FILTER_USERS | DSOP_SCOPE_FLAG_DEFAULT_FILTER_GROUPS,
        {
            { DSOP_FILTER_INCLUDE_ADVANCED_VIEW | DSOP_FILTER_USERS | 
              DSOP_FILTER_UNIVERSAL_GROUPS_SE | DSOP_FILTER_GLOBAL_GROUPS_SE, 0, 0},
            0,
        },
        NULL,
        NULL,
        S_OK
    },

    // Domains external to the enterprise but trusted directly by the
    // domain to which the target machine is joined.
    {
        sizeof(DSOP_SCOPE_INIT_INFO),
        DSOP_SCOPE_TYPE_EXTERNAL_UPLEVEL_DOMAIN | DSOP_SCOPE_TYPE_EXTERNAL_DOWNLEVEL_DOMAIN,
        DSOP_SCOPE_FLAG_DEFAULT_FILTER_USERS | DSOP_SCOPE_FLAG_DEFAULT_FILTER_GROUPS,
        {
            { DSOP_FILTER_INCLUDE_ADVANCED_VIEW | DSOP_FILTER_USERS | 
              DSOP_FILTER_UNIVERSAL_GROUPS_SE | DSOP_FILTER_GLOBAL_GROUPS_SE, 0, 0},
            DSOP_DOWNLEVEL_FILTER_USERS | DSOP_DOWNLEVEL_FILTER_GLOBAL_GROUPS,
        },
        NULL,
        NULL,
        S_OK
    },
};





void CCreateNewComputerPage::OnChangePrincipalButton()
{
  static UINT cfDsObjectPicker = 0;
  if (cfDsObjectPicker == 0)
    cfDsObjectPicker = RegisterClipboardFormat(CFSTR_DSOP_DS_SELECTION_LIST);


  // create object picker COM object
  CComPtr<IDsObjectPicker> spDsObjectPicker;
  HRESULT hr = CoCreateInstance(CLSID_DsObjectPicker, NULL, CLSCTX_INPROC_SERVER,
                              IID_IDsObjectPicker, (void**)&spDsObjectPicker);
  if (FAILED(hr))
    return;

  // set init info
  DSOP_INIT_INFO InitInfo;
  ZeroMemory(&InitInfo, sizeof(InitInfo));

  InitInfo.cbSize = sizeof(DSOP_INIT_INFO);
  InitInfo.pwzTargetComputer = GetWiz()->GetInfo()->GetBasePathsInfo()->GetServerName();
  InitInfo.cDsScopeInfos = sizeof(g_aComputerPrincipalDSOPScopes)/sizeof(DSOP_SCOPE_INIT_INFO);
  InitInfo.aDsScopeInfos = g_aComputerPrincipalDSOPScopes;
  InitInfo.flOptions = 0;
  InitInfo.cAttributesToFetch = 1;
  LPCWSTR lpszObjectSID = L"objectSid";
  InitInfo.apwzAttributeNames = const_cast<LPCTSTR *>(&lpszObjectSID);

  //
  // Loop through the scopes assigning the DC name
  //
  for (UINT idx = 0; idx < InitInfo.cDsScopeInfos; idx++)
  {
    InitInfo.aDsScopeInfos[idx].pwzDcName = GetWiz()->GetInfo()->GetBasePathsInfo()->GetServerName();
  }

  //
  // initialize object picker
  //
  hr = spDsObjectPicker->Initialize(&InitInfo);
  if (FAILED(hr))
    return;

  // invoke the dialog
  CComPtr<IDataObject> spdoSelections;

  hr = spDsObjectPicker->InvokeDialog(m_hWnd, &spdoSelections);
  if (hr == S_FALSE || !spdoSelections)
  {
    return;
  }

  // retrieve data from data object
  FORMATETC fmte = {(CLIPFORMAT)cfDsObjectPicker, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
	STGMEDIUM medium = {TYMED_NULL, NULL, NULL};
  PDS_SELECTION_LIST pDsSelList = NULL;

  hr = spdoSelections->GetData(&fmte, &medium);
  if (FAILED(hr))
    return;

  pDsSelList = (PDS_SELECTION_LIST)GlobalLock(medium.hGlobal);
  CComBSTR bsDN;

  if (pDsSelList != NULL)
  {
    ASSERT(pDsSelList->cItems == 1); // single selection


    TRACE(_T("pwzName = %s\n"), pDsSelList->aDsSelection[0].pwzName);
    TRACE(_T("pwzADsPath = %s\n"), pDsSelList->aDsSelection[0].pwzADsPath);
    TRACE(_T("pwzClass = %s\n"), pDsSelList->aDsSelection[0].pwzClass);
    TRACE(_T("pwzUPN = %s\n"), pDsSelList->aDsSelection[0].pwzUPN);

    // get the SID
    ASSERT(pDsSelList->aDsSelection[0].pvarFetchedAttributes != NULL);
    if (pDsSelList->aDsSelection[0].pvarFetchedAttributes[0].vt != VT_EMPTY)
    {
      ASSERT(pDsSelList->aDsSelection[0].pvarFetchedAttributes[0].vt == (VT_ARRAY | VT_UI1));
      PSID pSid = pDsSelList->aDsSelection[0].pvarFetchedAttributes[0].parray->pvData;
      ASSERT(IsValidSid(pSid));

      // deep copy SID
      if (!m_securityPrincipalSidHolder.Copy(pSid))
      {
        ASSERT(FALSE); // should never get here in normal operations
        ReportErrorEx(::GetParent(m_hWnd),IDS_ERR_FATAL,hr,
                 MB_OK | MB_ICONERROR, NULL, 0);
    	  goto Exit;
      }
    }


    UpdateSecurityPrincipalUI(&(pDsSelList->aDsSelection[0]));
  }
  else
  {
    PVOID apv[1] = {(LPWSTR)(pDsSelList->aDsSelection[0].pwzName)};
    ReportErrorEx(::GetParent(m_hWnd),IDS_12_CANT_GET_SAM_ACCNT_NAME,hr,
                   MB_OK | MB_ICONERROR, apv, 1);
    goto Exit;
  }

Exit:
  GlobalUnlock(medium.hGlobal);
  ReleaseStgMedium(&medium);

}



void CCreateNewComputerPage::UpdateSecurityPrincipalUI(PDS_SELECTION pDsSelection)
{
  TRACE(L"CCreateNewComputerPage::UpdateSecurityPrincipalUI()\n");

  HRESULT hr = S_OK;

  CString szText;

  LPWSTR pwzADsPath = pDsSelection->pwzADsPath;
  TRACE(L"pDsSelection->pwzADsPath = %s\n", pDsSelection->pwzADsPath);

  // get the X500 name (remove the provider ("LDAP://") in front of the name
  if ((pwzADsPath != NULL) && (pwzADsPath[0] != NULL)) 
  {
    CComBSTR bstrProvider;

    // need a fresh instance because we can set it to WINNT provider
    // and pretty much trash it (oh boy!!!)
    CPathCracker pathCracker;
    hr = pathCracker.Set(pwzADsPath, ADS_SETTYPE_FULL);
    if (FAILED(hr))
    {
      goto End;
    }
    hr = pathCracker.Retrieve(ADS_FORMAT_PROVIDER, &bstrProvider);
    TRACE(L"bstrProvider = %s\n", bstrProvider);
    if (FAILED(hr))
    {
      goto End;
    }

    if (_wcsicmp(bstrProvider, L"LDAP") == 0)
    {
      // it is an LDAP path, get the DN out of it
      // get the DN
      CComBSTR bstrDN;
      hr = pathCracker.Retrieve(ADS_FORMAT_X500_DN, &bstrDN);
      if (FAILED(hr))
      {
        goto End;
      }

      // get the canonical name out of the DN
      LPWSTR pszCanonical = NULL;
      hr = ::CrackName((LPWSTR)bstrDN, &pszCanonical, GET_OBJ_CAN_NAME, NULL);
      if (pszCanonical != NULL)
      {
        szText = pszCanonical;
        ::LocalFreeStringW(&pszCanonical);
      }

    }
    else if (_wcsicmp(bstrProvider, L"WinNT") == 0)
    {
      // we got an NT 4.0 user or group,
      // the mpath is something like: "WinNT://mydomain/JoeB"
      CComBSTR bstrWindows;
      // get "mydomain/JoeB"
      hr = pathCracker.Retrieve(ADS_FORMAT_WINDOWS_DN, &bstrWindows);
      if (FAILED(hr))
      {
        goto End;
      }
      szText = bstrWindows;
      // flip the slash to reverse slash
      int nCh = szText.Find(L'/');
      if (nCh != -1)
      {
        szText.SetAt(nCh, L'\\');
      }
    }
  }

End:

  if (szText.IsEmpty())
  {
    szText = pDsSelection->pwzName;
  }

  SetDlgItemText(IDC_PRINCIPAL_EDIT, szText);
}






DWORD AddEntryInAcl(EXPLICIT_ACCESS* pAccessEntry,
						        PACL* ppDacl)

{
  TRACE(_T("AddEntryInAcl:\n"));

#ifdef DBG

  TRACE(_T("\tpAccessEntry->grfAccessPermissions: 0x%x\n"), pAccessEntry->grfAccessPermissions);
  TRACE(_T("\tpAccessEntry->grfAccessMode: 0x%x\n"), pAccessEntry->grfAccessMode);
  TRACE(_T("\tpAccessEntry->grfInheritance: 0x%x\n"), pAccessEntry->grfInheritance);

  TRACE(L"\n");

  TRUSTEE* pTrustee = &(pAccessEntry->Trustee);
  
  TRACE(L"\tpTrustee: 0x%x\n", pTrustee);
  if (pTrustee != NULL)
  {
    TRACE(L"\tpTrustee->TrusteeForm: 0x%x\n", pTrustee->TrusteeForm);
    TRACE(L"\tpTrustee->TrusteeType: 0x%x\n", pTrustee->TrusteeType);
  }

#endif // DBG


  // add an entry in the DACL
  PACL pOldDacl = *ppDacl;
  *ppDacl = NULL;

  TRACE(L"Calling SetEntriesInAcl()\n");

  DWORD dwErr = ::SetEntriesInAcl(1, pAccessEntry, pOldDacl, ppDacl);

  TRACE(L"SetEntriesInAcl() returned dwErr = 0x%x\n", dwErr);

  if (dwErr == ERROR_SUCCESS)
	{
		LocalFree(pOldDacl);
	}

  return dwErr;
}


HRESULT CCreateNewComputerPage::BuildNewAccessList(PACL* ppDacl)
{
  // SCHEMA.INI [User-Force-Change-Password], rightsGUID=00299570-246d-11d0-a768-00aa006e0529
  static GUID ResetPasswordGUID = 
  { 0x00299570, 0x246d, 0x11d0, { 0xa7, 0x68, 0x00, 0xaa, 0x00, 0x6e, 0x05, 0x29 } }; 

  // rightsGuid of CN=Validated-DNS-Host-Name,CN-Extended-Rights,CN=Configuration
  static GUID ValidatedDNSHostNameGUID =
  { 0x72e39547, 0x7b18, 0x11d1, { 0xad, 0xef, 0x00, 0xc0, 0x4f, 0xd8, 0xd5, 0xcd } };

  // rightsGuid of CN=Validated-SPN,CN-Extended-Rights,CN=Configuration
  static GUID ValidatedSPNGUID =
  { 0xf3a64788, 0x5306, 0x11d1, { 0xa9, 0xc5, 0x00, 0x00, 0xf8, 0x03, 0x67, 0xc1 } };

  // rightsGuid of CN=User-Account-Restrictions,CN-Extended-Rights,CN=Configuration
  static GUID UserAccountRestrictionsGUID =
  { 0x4c164200, 0x20c0, 0x11d0, { 0xa7, 0x68, 0x00, 0xaa, 0x00, 0x6e, 0x05, 0x29 } };

  // create an EXPLICIT_ACCESS struct
  EXPLICIT_ACCESS AccessEntry;
  ZeroMemory(&AccessEntry, sizeof(EXPLICIT_ACCESS));

  // initialize EXPLICIT_ACCESS
  AccessEntry.grfAccessPermissions = ACTRL_DS_CONTROL_ACCESS;
  AccessEntry.grfAccessMode = GRANT_ACCESS;
  AccessEntry.grfInheritance = NO_INHERITANCE;


  OBJECTS_AND_SID ObjectsAndSid;
  ZeroMemory(&ObjectsAndSid, sizeof(OBJECTS_AND_SID));

  PSID pSid = m_securityPrincipalSidHolder.Get();

  //
  // We don't really care if this succeeds because it is just used in the TRACE
  //
  CString sSamAccountName;
  _LookupSamAccountNameFromSid(pSid, sSamAccountName);
  TRACE(L"Building trustee for <%s>\n", (LPCWSTR)sSamAccountName);


  BuildTrusteeWithObjectsAndSid(&(AccessEntry.Trustee), 
                                &ObjectsAndSid,
                                &ResetPasswordGUID,
                                NULL, // inherit guid
                                pSid
                                );

  // add an entry in the DACL

  DWORD dwErr = ::AddEntryInAcl(&AccessEntry, ppDacl);

  // Add Self Write on Validated-DNS-Host-Name
  if ( ERROR_SUCCESS == dwErr )
  {
    AccessEntry.grfAccessPermissions = ACTRL_DS_SELF;
    BuildTrusteeWithObjectsAndSid(&(AccessEntry.Trustee), 
                                  &ObjectsAndSid,
                                  &ValidatedDNSHostNameGUID,
                                  NULL, // inherit guid
                                  pSid
                                  );

    dwErr = ::AddEntryInAcl(&AccessEntry, ppDacl);
  }

  // Add Self Write on Validated-SPN
  if ( ERROR_SUCCESS == dwErr )
  {
    AccessEntry.grfAccessPermissions = ACTRL_DS_SELF;
    BuildTrusteeWithObjectsAndSid(&(AccessEntry.Trustee), 
                                  &ObjectsAndSid,
                                  &ValidatedSPNGUID,
                                  NULL, // inherit guid
                                  pSid
                                  );

    dwErr = ::AddEntryInAcl(&AccessEntry, ppDacl);
  }

  // Add Write Property on User-Account-Restrictions
  if ( ERROR_SUCCESS == dwErr )
  {
    AccessEntry.grfAccessPermissions = ACTRL_DS_WRITE_PROP;
    BuildTrusteeWithObjectsAndSid(&(AccessEntry.Trustee), 
                                  &ObjectsAndSid,
                                  &UserAccountRestrictionsGUID,
                                  NULL, // inherit guid
                                  pSid
                                  );

    dwErr = ::AddEntryInAcl(&AccessEntry, ppDacl);
  }

  return HRESULT_FROM_WIN32(dwErr);
}



HRESULT CCreateNewComputerPage::SetSecurity()
{
  // get the ADSI object pointer
  CNewADsObjectCreateInfo* pNewADsObjectCreateInfo = GetWiz()->GetInfo();
  IADs* pObj = pNewADsObjectCreateInfo->PGetIADsPtr();

  // get the full LDAP path of the object
  CComBSTR bstrObjectLdapPath;
  HRESULT hr = pObj->get_ADsPath(&bstrObjectLdapPath);
  ASSERT (SUCCEEDED(hr));
  if (FAILED(hr))
  {
    return hr;
  }

  UnescapePath(bstrObjectLdapPath, /*bDN*/ FALSE, bstrObjectLdapPath);

  PACL pAcl = NULL;
  CSimpleSecurityDescriptorHolder SDHolder;

  TRACE(_T("GetNamedSecurityInfo(%s)\n"), bstrObjectLdapPath);

  // read info
  DWORD dwErr = ::GetNamedSecurityInfo(
                        IN  bstrObjectLdapPath,
                        IN  SE_DS_OBJECT_ALL,
                        IN  DACL_SECURITY_INFORMATION,
                        OUT NULL,
                        OUT NULL,
                        OUT &pAcl,
                        OUT NULL,
                        OUT &(SDHolder.m_pSD));

  TRACE(L"GetNamedSecurityInfo() returned dwErr = 0x%x\n", dwErr);

  hr = HRESULT_FROM_WIN32(dwErr);

	if (FAILED(hr))
	{
		TRACE(_T("failed on GetNamedSecurityInfo()\n"));
		return hr;
	}

	// build the new DACL 
	hr = BuildNewAccessList(&pAcl); 

  TRACE(L"SetEntriesInAcl() returned hr = 0x%x\n", hr);

	if (FAILED(hr))
	{
		TRACE(_T("failed on BuildNewAccessList()\n"));
		return hr;
	}

	// commit changes
  dwErr = ::SetNamedSecurityInfo(
                        IN   bstrObjectLdapPath,
                        IN   SE_DS_OBJECT_ALL,
                        IN   DACL_SECURITY_INFORMATION,
                        IN   NULL,
                        IN   NULL,
                        IN   pAcl,
                        IN   NULL);

  TRACE(L"SetNamedSecurityInfo() returned dwErr = 0x%x\n", dwErr);

  hr = HRESULT_FROM_WIN32(dwErr);

  return hr;
}


BOOL CCreateNewComputerPage::OnError(HRESULT hr)
{
  BOOL bRetVal = FALSE;

  if( HRESULT_CODE(hr) == ERROR_OBJECT_ALREADY_EXISTS )
  {

    HRESULT Localhr;
    DWORD LastError; 
    WCHAR Buf1[256], Buf2[256];
    Localhr = ADsGetLastError (&LastError,
                               Buf1, 256, Buf2, 256);
    switch( LastError )
    {
      case ERROR_USER_EXISTS:
      {
        PVOID apv[1] = {(LPWSTR)(LPCWSTR)m_strSamName};
        ReportErrorEx (::GetParent(m_hWnd),IDS_ERROR_COMPUTER_EXISTS,hr,
                   MB_OK|MB_ICONWARNING , apv, 1);
        bRetVal = TRUE;
      }
      break;

      case ERROR_DS_OBJ_STRING_NAME_EXISTS:
      {
        PVOID apv[1] = {(LPWSTR)(LPCWSTR)m_strName};
        ReportErrorEx (::GetParent(m_hWnd),IDS_ERROR_COMPUTER_DS_OBJ_STRING_NAME_EXISTS,hr,
                   MB_OK|MB_ICONWARNING , apv, 1);
        bRetVal = TRUE;
      }
      break;
    }
  }
  return bRetVal;
}



CCreateNewComputerWizard:: CCreateNewComputerWizard(CNewADsObjectCreateInfo* pNewADsObjectCreateInfo) : 
    CCreateNewObjectWizardBase(pNewADsObjectCreateInfo)
{
  AddPage(&m_page1);
}


void CCreateNewComputerWizard::OnFinishSetInfoFailed(HRESULT hr)
{

  AFX_MANAGE_STATE(AfxGetStaticModuleState());
  
  if ( !( HRESULT_CODE(hr) == ERROR_OBJECT_ALREADY_EXISTS && 
        m_page1.OnError( hr ) ) )
  {
    // everything else is handled by the base class
    CCreateNewObjectWizardBase::OnFinishSetInfoFailed(hr);
  }
}



///////////////////////////////////////////////////////////////
// NEW OU WIZARD

BEGIN_MESSAGE_MAP(CCreateNewOUPage, CCreateNewObjectDataPage)
  ON_EN_CHANGE(IDC_EDIT_OBJECT_NAME, OnNameChange)
END_MESSAGE_MAP()

CCreateNewOUPage::CCreateNewOUPage()
: CCreateNewObjectDataPage(CCreateNewOUPage::IDD)
{
}

BOOL CCreateNewOUPage::OnInitDialog() 
{
  Edit_LimitText (GetDlgItem(IDC_EDIT_OBJECT_NAME)->m_hWnd, 64);
  CCreateNewObjectDataPage::OnInitDialog();
  return TRUE;
}

BOOL CCreateNewOUPage::GetData(IADs*) 
{
  return !m_strOUName.IsEmpty();
}


void CCreateNewOUPage::OnNameChange()
{
  GetDlgItemText(IDC_EDIT_OBJECT_NAME, OUT m_strOUName);
  m_strOUName.TrimLeft();
  m_strOUName.TrimRight();
  GetWiz()->SetWizardButtons(this, !m_strOUName.IsEmpty());
}

HRESULT CCreateNewOUPage::SetData(BOOL)
{
  // Store the object name in the temporary storage
  HRESULT hr = GetWiz()->GetInfo()->HrCreateNew(m_strOUName);
  return hr;
} 

BOOL CCreateNewOUPage::OnSetActive()
{
  BOOL bRet = CCreateNewObjectDataPage::OnSetActive();
  SetDlgItemFocus(IDC_EDIT_OBJECT_NAME);
  SendDlgItemMessage(IDC_EDIT_OBJECT_NAME, EM_SETSEL, 0, -1);

  return bRet;
}

BOOL CCreateNewOUPage::OnWizardFinish()
{
  BOOL bFinish = CCreateNewObjectDataPage::OnWizardFinish();
  if (!bFinish)
  {
    SetDlgItemFocus(IDC_EDIT_OBJECT_NAME);
    SendDlgItemMessage(IDC_EDIT_OBJECT_NAME, EM_SETSEL, 0, -1);
  }
  return bFinish;
}


CCreateNewOUWizard:: CCreateNewOUWizard(CNewADsObjectCreateInfo* pNewADsObjectCreateInfo) : 
    CCreateNewObjectWizardBase(pNewADsObjectCreateInfo)
{
  AddPage(&m_page1);
}
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
// NEW GROUP WIZARD

BEGIN_MESSAGE_MAP(CCreateNewGroupPage, CCreateNewObjectDataPage)
  ON_EN_CHANGE(IDC_EDIT_OBJECT_NAME, OnNameChange)
  ON_EN_CHANGE(IDC_EDIT_SAM_NAME, OnSamNameChange)
  ON_BN_CLICKED(IDC_RADIO_SEC_GROUP, OnSecurityOrTypeChange)
  ON_BN_CLICKED(IDC_RADIO_DISTRIBUTION_GROUP, OnSecurityOrTypeChange)
  ON_BN_CLICKED(IDC_RADIO_RESOURCE, OnSecurityOrTypeChange)
  ON_BN_CLICKED(IDC_RADIO_ACCOUNT, OnSecurityOrTypeChange)
  ON_BN_CLICKED(IDC_RADIO_UNIVERSAL, OnSecurityOrTypeChange)
END_MESSAGE_MAP()

CCreateNewGroupPage::CCreateNewGroupPage() : 
CCreateNewObjectDataPage(CCreateNewGroupPage::IDD)
{
  m_fMixed = FALSE;
  m_SAMLength = 256; 
}


BOOL CCreateNewGroupPage::OnInitDialog()
{
  CCreateNewObjectDataPage::OnInitDialog();
  VERIFY(_InitUI());
  return TRUE;
}


BOOL CCreateNewGroupPage::_InitUI()
{
  // set limit to edit boxes
  Edit_LimitText(::GetDlgItem(m_hWnd, IDC_EDIT_OBJECT_NAME), 64);
  Edit_LimitText(::GetDlgItem(m_hWnd, IDC_EDIT_SAM_NAME), m_SAMLength);
  
  // determine if we are in mixed mode by
  // retriving the domain we are bound to
  CNewADsObjectCreateInfo* pNewADsObjectCreateInfo = GetWiz()->GetInfo();
  CComPtr<IADs> spContainerObj;
  HRESULT hr = pNewADsObjectCreateInfo->m_pIADsContainer->QueryInterface(
                  IID_IADs, (void **)&spContainerObj);

  if (SUCCEEDED(hr))
  {
    // retrieve the DN of the container
    CComBSTR bstrPath, bstrDN;
    spContainerObj->get_ADsPath(&bstrPath);

    CPathCracker pathCracker;
    pathCracker.Set(bstrPath, ADS_SETTYPE_FULL);
    pathCracker.SetDisplayType(ADS_DISPLAY_FULL);
    pathCracker.Retrieve(ADS_FORMAT_X500_DN, &bstrDN);

    // get the 1779 name of the domain
    LPWSTR pszDomain1779 = NULL;
    hr = CrackName (bstrDN, &pszDomain1779, GET_FQDN_DOMAIN_NAME, NULL);
    if (SUCCEEDED(hr))
    {
      // build LDAP path for domain
      CString strDomObj;
      
      pNewADsObjectCreateInfo->GetBasePathsInfo()->ComposeADsIPath(strDomObj, pszDomain1779);

      LocalFreeStringW(&pszDomain1779);

      // bind to the domain object
      CComPtr<IADs> spDomainObj;
      hr = DSAdminOpenObject(strDomObj,
                             IID_IADs,
                             (void **) &spDomainObj,
                             TRUE /*bServer*/);
      if (SUCCEEDED(hr)) 
      {
        // retrieve the mixed node attribute
        CComVariant Mixed;
        CComBSTR bsMixed(L"nTMixedDomain");
        spDomainObj->Get(bsMixed, &Mixed);
        m_fMixed = (BOOL)Mixed.bVal;
      }
    }
  }

  // initial setup of radiobutton state
  if (m_fMixed) {
    EnableDlgItem (IDC_RADIO_UNIVERSAL, FALSE); // no universal groups allowed
  } 
  // default is global security group 
  ((CButton *)GetDlgItem(IDC_RADIO_ACCOUNT))->SetCheck(1);
  ((CButton *)GetDlgItem(IDC_RADIO_SEC_GROUP))->SetCheck(1);

  return TRUE;
}


HRESULT CCreateNewGroupPage::SetData(BOOL)
{
  HRESULT hr;

  //
  // First check for illegal characters
  //
  int iFind = m_strSamName.FindOneOf(INVALID_ACCOUNT_NAME_CHARS);
  if (iFind != -1 && !m_strSamName.IsEmpty())
  {
    PVOID apv[1] = {(LPWSTR)(LPCWSTR)m_strSamName};
    if (IDYES == ReportErrorEx (m_hWnd,IDS_GROUP_SAMNAME_ILLEGAL,S_OK,
                                MB_YESNO | MB_ICONWARNING, apv, 1))
    {
      while (iFind != -1)
      {
        m_strSamName.SetAt(iFind, L'_');
        iFind = m_strSamName.FindOneOf(INVALID_ACCOUNT_NAME_CHARS);
      }
      SetDlgItemText(IDC_EDIT_SAM_NAME, m_strSamName);
    }
    else
    {
      //
      // Set the focus to the edit box and select the text
      //
      GetDlgItem(IDC_EDIT_SAM_NAME)->SetFocus();
      SendDlgItemMessage(IDC_EDIT_SAM_NAME, EM_SETSEL, 0 , -1);
      return E_INVALIDARG;
    }
  }

  CNewADsObjectCreateInfo* pNewADsObjectCreateInfo = GetWiz()->GetInfo();
  // Store the object name in the temporary storage
  hr = pNewADsObjectCreateInfo->HrCreateNew(m_strGroupName);
  if (FAILED(hr))
  {
    return hr;
  }

  // Create and persist the object
  // Store the object name in the temporary storage
  hr = pNewADsObjectCreateInfo->HrAddVariantBstr(const_cast<PWSTR>(gsz_samAccountName),
                                                 m_strSamName);
  ASSERT(SUCCEEDED(hr));

  CComVariant varGroupType;
  varGroupType.vt = VT_I4;

  BOOL Account = IsDlgButtonChecked (IDC_RADIO_ACCOUNT);
  BOOL Resource = IsDlgButtonChecked (IDC_RADIO_RESOURCE);
  BOOL Security = IsDlgButtonChecked (IDC_RADIO_SEC_GROUP);

  if (Security)
    varGroupType.lVal = GROUP_TYPE_SECURITY_ENABLED;
  else
    varGroupType.lVal = 0;

  if (Resource)
    varGroupType.lVal |= GROUP_TYPE_RESOURCE_GROUP;
  else
    if (Account)
      varGroupType.lVal |= GROUP_TYPE_ACCOUNT_GROUP;
    else
      varGroupType.lVal |= GROUP_TYPE_UNIVERSAL_GROUP;
      

  // Update the GroupType
  hr = pNewADsObjectCreateInfo->HrAddVariantCopyVar(const_cast<PWSTR>(gsz_groupType), varGroupType);
  ASSERT(SUCCEEDED(hr));

  return hr;
}

BOOL CCreateNewGroupPage::GetData(IADs*)
{
  return !m_strGroupName.IsEmpty();
}


void CCreateNewGroupPage::OnNameChange()
{
  GetDlgItemText(IDC_EDIT_OBJECT_NAME, OUT m_strGroupName);
  m_strGroupName.TrimLeft();
  m_strGroupName.TrimRight();
  SetDlgItemText(IDC_EDIT_SAM_NAME, OUT m_strGroupName.Left(m_SAMLength));
  GetWiz()->SetWizardButtons(this,(!m_strGroupName.IsEmpty() &&
                                   !m_strSamName.IsEmpty()));
}

void CCreateNewGroupPage::OnSamNameChange()
{
  GetDlgItemText(IDC_EDIT_SAM_NAME, OUT m_strSamName);
  m_strSamName.TrimLeft();
  m_strSamName.TrimRight();
  GetWiz()->SetWizardButtons(this,(!m_strGroupName.IsEmpty() &&
                                   !m_strSamName.IsEmpty()));
}

void CCreateNewGroupPage::OnSecurityOrTypeChange()
{
  if (!IsDlgButtonChecked (IDC_RADIO_SEC_GROUP)) {
    EnableDlgItem (IDC_RADIO_UNIVERSAL, TRUE);
  } else {
    if (m_fMixed) {
      if (IsDlgButtonChecked (IDC_RADIO_UNIVERSAL)) {
        ((CButton *)GetDlgItem(IDC_RADIO_ACCOUNT))->SetCheck(1);
        ((CButton *)GetDlgItem(IDC_RADIO_UNIVERSAL))->SetCheck(0);
      }
      EnableDlgItem (IDC_RADIO_UNIVERSAL, FALSE);
    }
  }
}

CCreateNewGroupWizard::CCreateNewGroupWizard(
        CNewADsObjectCreateInfo* pNewADsObjectCreateInfo)
: CCreateNewObjectWizardBase(pNewADsObjectCreateInfo)
{
  AddPage(&m_page1);
}

///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
// NEW CONTACT WIZARD

BEGIN_MESSAGE_MAP(CCreateNewContactPage, CCreateNewObjectDataPage)
  ON_EN_CHANGE(IDC_EDIT_FIRST_NAME, OnNameChange)
  ON_EN_CHANGE(IDC_EDIT_INITIALS, OnNameChange)
  ON_EN_CHANGE(IDC_EDIT_LAST_NAME, OnNameChange)
  ON_EN_CHANGE(IDC_EDIT_FULL_NAME, OnFullNameChange)
  ON_EN_CHANGE(IDC_EDIT_DISP_NAME, OnDispNameChange)
END_MESSAGE_MAP()

CCreateNewContactPage::CCreateNewContactPage() : 
CCreateNewObjectDataPage(CCreateNewContactPage::IDD)
{
}


BOOL CCreateNewContactPage::OnInitDialog()
{
  CCreateNewObjectDataPage::OnInitDialog();

  Edit_LimitText (GetDlgItem(IDC_EDIT_FULL_NAME)->m_hWnd, 64);
  Edit_LimitText (GetDlgItem(IDC_EDIT_LAST_NAME)->m_hWnd, 29);
  Edit_LimitText (GetDlgItem(IDC_EDIT_FIRST_NAME)->m_hWnd, 28);
  Edit_LimitText (GetDlgItem(IDC_EDIT_INITIALS)->m_hWnd, 4);
  Edit_LimitText (GetDlgItem(IDC_EDIT_DISP_NAME)->m_hWnd, 256);

  CNewADsObjectCreateInfo* pNewADsObjectCreateInfo = GetWiz()->GetInfo();
  m_nameFormatter.Initialize(pNewADsObjectCreateInfo->GetBasePathsInfo(), 
                  pNewADsObjectCreateInfo->m_pszObjectClass);

  return TRUE;
}


HRESULT CCreateNewContactPage::SetData(BOOL)
{
  HRESULT hr;
  // Store the object name in the temporary storage
  CNewADsObjectCreateInfo* pNewADsObjectCreateInfo = GetWiz()->GetInfo();

  // create a new temporary ADs object
  hr = pNewADsObjectCreateInfo->HrCreateNew(m_strFullName);
  if (FAILED(hr)) {
    return hr;
  }
  // set the attributes in the cache
  hr = pNewADsObjectCreateInfo->HrAddVariantBstrIfNotEmpty(L"givenName", m_strFirstName);
  ASSERT(SUCCEEDED(hr));
  hr = pNewADsObjectCreateInfo->HrAddVariantBstrIfNotEmpty(L"initials", m_strInitials);
  ASSERT(SUCCEEDED(hr));
  hr = pNewADsObjectCreateInfo->HrAddVariantBstrIfNotEmpty(L"sn", m_strLastName);
  ASSERT(SUCCEEDED(hr));
  hr = pNewADsObjectCreateInfo->HrAddVariantBstrIfNotEmpty(L"displayName", m_strDispName);
  ASSERT(SUCCEEDED(hr));

  return hr;
}



BOOL CCreateNewContactPage::GetData(IADs*)
{
  return !m_strFullName.IsEmpty();
}


void CCreateNewContactPage::OnNameChange()
{
  GetDlgItemText(IDC_EDIT_FIRST_NAME, OUT m_strFirstName);
  GetDlgItemText(IDC_EDIT_INITIALS, OUT m_strInitials);
  GetDlgItemText(IDC_EDIT_LAST_NAME, OUT m_strLastName);

  m_strFirstName.TrimLeft();
  m_strFirstName.TrimRight();

  m_strInitials.TrimLeft();
  m_strInitials.TrimRight();

  m_strLastName.TrimLeft();
  m_strLastName.TrimRight();

  m_nameFormatter.FormatName(m_strFullName, 
                             m_strFirstName.IsEmpty() ? NULL : (LPCWSTR)m_strFirstName, 
                             m_strInitials.IsEmpty() ? NULL : (LPCWSTR)m_strInitials,
                             m_strLastName.IsEmpty() ? NULL : (LPCWSTR)m_strLastName);
  SetDlgItemText(IDC_EDIT_FULL_NAME, 
                  IN m_strFullName);

  GetWiz()->SetWizardButtons(this, !m_strFullName.IsEmpty());
}

void CCreateNewContactPage::OnFullNameChange()
{
  GetDlgItemText(IDC_EDIT_FULL_NAME, OUT m_strFullName);
  GetWiz()->SetWizardButtons(this, !m_strFullName.IsEmpty());
}

void CCreateNewContactPage::OnDispNameChange()
{
  GetDlgItemText(IDC_EDIT_DISP_NAME, OUT m_strDispName);
  m_strDispName.TrimLeft();
  m_strDispName.TrimRight();
}




CCreateNewContactWizard::CCreateNewContactWizard(
        CNewADsObjectCreateInfo* pNewADsObjectCreateInfo)
: CCreateNewObjectWizardBase(pNewADsObjectCreateInfo)
{
  AddPage(&m_page1);
}



#ifdef FRS_CREATE
///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
// NEW FRS SUBSCRIBER WIZARD

HRESULT CCreateNewFrsSubscriberPage::SetData(BOOL bSilent)
{
  CString strRootPath;
  CString strStagingPath;
  if ( !ReadAbsolutePath( IDC_FRS_ROOT_PATH, strRootPath) ||
       !ReadAbsolutePath( IDC_FRS_STAGING_PATH, strStagingPath ) )
    {
      return E_INVALIDARG;
    }

  HRESULT hr = S_OK;

  // Add more properties, we don't want to create it unless all of these work
  CNewADsObjectCreateInfo* pNewADsObjectCreateInfo = GetWiz()->GetInfo();
  ASSERT( NULL != pNewADsObjectCreateInfo );
  hr = pNewADsObjectCreateInfo->HrAddVariantBstrIfNotEmpty(  gsz_fRSRootPath,
                                                             strRootPath,
                                                             TRUE );
  ASSERT(SUCCEEDED(hr));
  hr = pNewADsObjectCreateInfo->HrAddVariantBstrIfNotEmpty(  gsz_fRSStagingPath,
                                                             strStagingPath,
                                                             TRUE );
  ASSERT(SUCCEEDED(hr));

  // no need to commit here, wait until after extensions have had a shot
  return CCreateNewNamedObjectPage::SetData(bSilent);
}

BOOL CCreateNewFrsSubscriberPage::ReadAbsolutePath( int ctrlID, OUT CString& strrefValue )
{
  // CODEWORK this should also select the text in this field
  GetDlgItemText(ctrlID, OUT strrefValue);
  DWORD PathType = 0;
  if ( NERR_Success != I_NetPathType(
                                     NULL,
                                     const_cast<LPTSTR>((LPCTSTR)strrefValue),
                                     &PathType,
                                     0 ) ||
       ITYPE_PATH_ABSD != PathType )
    {
      PVOID apv[1] = {(LPWSTR)(LPCWSTR)strrefValue};
      ReportErrorEx (::GetParent(m_hWnd),IDS_2_INVALID_ABSOLUTE_PATH,S_OK,
                     MB_OK, apv, 1);

      SetDlgItemFocus(ctrlID);
      return FALSE;
    }
  return TRUE;
} 
#endif // FRS_CREATE


///////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////
// NEW SITE LINKWIZARD

BEGIN_MESSAGE_MAP(CCreatePageWithDuellingListboxes, CCreateNewObjectDataPage)
  ON_EN_CHANGE(IDC_NEW_OBJECT_NAME, OnNameChange)
  ON_BN_CLICKED(IDC_DUELLING_RB_ADD, OnDuellingButtonAdd)
  ON_BN_CLICKED(IDC_DUELLING_RB_REMOVE, OnDuellingButtonRemove)
  ON_LBN_SELCHANGE(IDC_DUELLING_LB_OUT, OnDuellingListboxSelchange)
  ON_LBN_SELCHANGE(IDC_DUELLING_LB_IN, OnDuellingListboxSelchange)
  ON_WM_DESTROY()
END_MESSAGE_MAP()

CCreatePageWithDuellingListboxes::CCreatePageWithDuellingListboxes(
    UINT nIDTemplate,
    LPCWSTR lpcwszAttrName,
    const DSPROP_BSTR_BLOCK& bstrblock )
: CCreateNewObjectDataPage(nIDTemplate)
, m_strAttrName( lpcwszAttrName )
, m_bstrblock( bstrblock )
{
}

BOOL CCreatePageWithDuellingListboxes::GetData(IADs*)
{
  return FALSE; // start disabled
}

void CCreatePageWithDuellingListboxes::OnNameChange()
{
  GetDlgItemText(IDC_NEW_OBJECT_NAME, OUT m_strName);
  m_strName.TrimLeft();
  m_strName.TrimRight();
  SetWizardButtons();
}

void CCreatePageWithDuellingListboxes::SetWizardButtons()
{
  BOOL fAllowApply = !(m_strName.IsEmpty());
  GetWiz()->SetWizardButtons(this, fAllowApply);
}

  
HRESULT CCreatePageWithDuellingListboxes::SetData(BOOL)
{
  HRESULT hr = S_OK;
  CNewADsObjectCreateInfo* pNewADsObjectCreateInfo = GetWiz()->GetInfo();
  // Store the object name in the temporary storage
  hr = pNewADsObjectCreateInfo->HrCreateNew(m_strName);
  if (FAILED(hr))
  {
    return hr;
  }

  // build the siteList attribute
  CStringList strlist;
  int cItems = ListBox_GetCount( m_hwndInListbox );
  ASSERT( 0 <= cItems );
  for (int i = cItems-1; i >= 0; i--)
  {
    BSTR bstrDN = (BSTR)ListBox_GetItemData( m_hwndInListbox, i );
    ASSERT( NULL != bstrDN );
    strlist.AddHead( bstrDN );
  }
  ASSERT( strlist.GetCount() > 0 );
  CComVariant svar;
  hr = HrStringListToVariant( OUT svar, IN strlist );
  ASSERT( SUCCEEDED(hr) );

  //
  // set the siteList attribute
  //
  hr = pNewADsObjectCreateInfo->HrAddVariantCopyVar(const_cast<PWSTR>((LPCWSTR)m_strAttrName), svar);
  ASSERT(SUCCEEDED(hr));

  //
  // no need to commit here, wait until after extensions have had a shot
  //
  return hr;
}

//
// The duelling listbox support uses exports from DSPROP.DLL.  Correct
// functioning requires that the control IDs be numbered correctly.
// JonN 8/31/98
//

void CCreatePageWithDuellingListboxes::OnDuellingButtonAdd()
{
    DSPROP_Duelling_ButtonClick(
        m_hWnd,
        IDC_DUELLING_RB_ADD );
    SetWizardButtons();
}

void CCreatePageWithDuellingListboxes::OnDuellingButtonRemove()
{
    DSPROP_Duelling_ButtonClick(
        m_hWnd,
        IDC_DUELLING_RB_REMOVE );
    SetWizardButtons();
}

void CCreatePageWithDuellingListboxes::OnDuellingListboxSelchange()
{
    // don't allow Add/Remove if there are <3 sites
    if (2 < (ListBox_GetCount(m_hwndInListbox)
           + ListBox_GetCount(m_hwndOutListbox)) )
    {
        DSPROP_Duelling_UpdateButtons( m_hWnd, IDC_DUELLING_RB_ADD );
    }
}

void CCreatePageWithDuellingListboxes::OnDestroy()
{
    DSPROP_Duelling_ClearListbox( m_hwndInListbox );
    DSPROP_Duelling_ClearListbox( m_hwndOutListbox );
    CCreateNewObjectDataPage::OnDestroy();
}

BOOL CCreatePageWithDuellingListboxes::OnSetActive()
{
    m_hwndInListbox  = ::GetDlgItem( m_hWnd, IDC_DUELLING_LB_IN  );
    m_hwndOutListbox = ::GetDlgItem( m_hWnd, IDC_DUELLING_LB_OUT );
    ASSERT( NULL != m_hwndInListbox && NULL != m_hwndOutListbox );

    HWND hwndInitial = m_hwndOutListbox;
    if (3 > m_bstrblock.QueryCount())
    {
        // move all sitelinks to "in"
        // Add/Remove will never be enabled
        hwndInitial = m_hwndInListbox;
    }
    HRESULT hr = DSPROP_Duelling_Populate(
        hwndInitial,
        m_bstrblock
        );
    if ( FAILED(hr) )
        return FALSE;
    return CCreateNewObjectDataPage::OnSetActive();
}


CCreateNewSiteLinkPage::CCreateNewSiteLinkPage(
        const DSPROP_BSTR_BLOCK& bstrblock )
: CCreatePageWithDuellingListboxes(
        CCreateNewSiteLinkPage::IDD,
        gsz_siteList,
        bstrblock)
{
}

BOOL CCreateNewSiteLinkPage::OnSetActive()
{
    if (m_bstrblock.QueryCount() < 2)
    {
        // change "must contain two sites" text
        CString sz;
        sz.LoadString(IDS_SITELINK_DLGTEXT_ONE_SITE);
        ::SetDlgItemText( m_hWnd, IDC_STATIC_MESSAGE, sz );
    }

    return CCreatePageWithDuellingListboxes::OnSetActive();
}

HRESULT CCreateNewSiteLinkPage::SetData(BOOL bSilent)
{
    BOOL fAllowApply = TRUE;
    int cIn = ListBox_GetCount(m_hwndInListbox);
    if (1 > cIn)
        fAllowApply = FALSE; // zero sites is a constraint violation
    else if (2 > cIn)
    {
      int cOut = ListBox_GetCount(m_hwndOutListbox);
      if (1 <= cOut) // allow one site if the "out" listbox is empty
        fAllowApply = FALSE;
    }
    if (fAllowApply)
      return CCreatePageWithDuellingListboxes::SetData(bSilent);

    if (!bSilent)
    {
      ReportMessageEx(m_hWnd,
                      IDS_SITELINK_NEEDS_TWO_SITES,
                      MB_OK | MB_ICONSTOP);
    }

    return E_FAIL;
}


CCreateNewSiteLinkWizard::CCreateNewSiteLinkWizard(
        CNewADsObjectCreateInfo* pNewADsObjectCreateInfo,
        const DSPROP_BSTR_BLOCK& bstrblock )
    : CCreateNewObjectWizardBase(pNewADsObjectCreateInfo)
    , m_page1( bstrblock )
{
  AddPage(&m_page1);
}


CCreateNewSiteLinkBridgePage::CCreateNewSiteLinkBridgePage(
        const DSPROP_BSTR_BLOCK& bstrblock )
: CCreatePageWithDuellingListboxes(
        CCreateNewSiteLinkBridgePage::IDD,
        gsz_siteLinkList,
        bstrblock)
{
}

HRESULT CCreateNewSiteLinkBridgePage::SetData(BOOL bSilent)
{
    BOOL fAllowApply = TRUE;
    int cIn = ListBox_GetCount(m_hwndInListbox);
    if (2 > cIn)
    {
      fAllowApply = FALSE;
    }
    if (fAllowApply)
      return CCreatePageWithDuellingListboxes::SetData(bSilent);

    if (!bSilent)
    {
      ReportMessageEx(m_hWnd,
                      IDS_SITELINKBRIDGE_NEEDS_TWO_SITELINKS,
                      MB_OK | MB_ICONSTOP);
    }

    return E_FAIL;
}

CCreateNewSiteLinkBridgeWizard:: CCreateNewSiteLinkBridgeWizard(
        CNewADsObjectCreateInfo* pNewADsObjectCreateInfo,
        const DSPROP_BSTR_BLOCK& bstrblockSiteLinks )
    : CCreateNewObjectWizardBase(pNewADsObjectCreateInfo)
    , m_page1( bstrblockSiteLinks )
{
  AddPage(&m_page1);
}