// File: wizard.cpp

#include "precomp.h"

#include <vfw.h>
#include <ulsreg.h>
#include "call.h"
#include "ulswizrd.h"
#include "ConfWnd.h"
#include "ConfCpl.h"
#include "mrulist.h"
#include "conf.h"
#include "setupdd.h"
#include "vidwiz.h"
#include "dstest.h"
#include "splash.h"
#include "nmmkcert.h"

#include "confroom.h" // for GetConfRoom
#include "FnObjs.h"

#include "ConfPolicies.h"
#include "SysPol.h"
#include "confUtil.h"
#include "shlWAPI.h"

#include "help_ids.h"

extern VOID SaveDefaultCodecSettings(UINT uBandWidth);
INT_PTR CALLBACK ShortcutWizDialogProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

// from ulscpl.cpp
VOID FixServerDropList(HWND hdlg, int id, LPTSTR pszServer, UINT cchMax);

static const TCHAR g_szRegOwner[]    = WIN_REGKEY_REGOWNER;	// concatenated string of first name + last name
static const TCHAR g_szClientFld[]   = ULS_REGISTRY TEXT ("\\") ULS_REGFLD_CLIENT;

static const TCHAR g_szFirstName[]   = ULS_REGKEY_FIRST_NAME;
static const TCHAR g_szLastName[]    = ULS_REGKEY_LAST_NAME;
static const TCHAR g_szEmailName[]   = ULS_REGKEY_EMAIL_NAME;
static const TCHAR g_szLocation[]    = ULS_REGKEY_LOCATION;
static const TCHAR g_szComments[]    = ULS_REGKEY_COMMENTS;
static const TCHAR g_szServerName[]  = ULS_REGKEY_SERVER_NAME;
static const TCHAR g_szDontPublish[] = ULS_REGKEY_DONT_PUBLISH;
static const TCHAR g_szResolveName[] = ULS_REGKEY_RESOLVE_NAME; // concatenated string of uls://servername/emailname
static const TCHAR g_szUserName[]    = ULS_REGKEY_USER_NAME;	// concatenated string of first name + last name


// These functions are implemented below:
static INT_PTR APIENTRY IntroWiz(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
static INT_PTR APIENTRY AppSharingWiz(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
static INT_PTR APIENTRY BandwidthWiz(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
static BOOL NeedAudioWizard(LPLONG plSoundCaps, BOOL fForce);


static void FillWizardPages ( PROPSHEETPAGE *pPage, LPARAM lParam );


struct INTRO_PAGE_CONFIG
{
	BOOL *	fContinue;
	BOOL	fAllowBack;
};

BOOL g_fSilentWizard = FALSE;

// This holdn the user info page HWND...
static HWND s_hDlgUserInfo = NULL;
static HWND s_hDlgGKSettings = NULL;

class IntroWiz
{
public:
	// The order of the pages
	// Make sure to change the order the pages are created at the same time
	// you change this
	enum
	{
		Intro,
		AppSharing,
		ULSFirst,
		ULSLast,
		Bandwidth,
		Video,
		Shortcuts,
		AudioFirst,
		Count
	} ;

	static void InitPages()
	{
		// Init to NULL before adding any pages
		for (int i=0; i<Count; ++i)
		{
			g_idWizOrder[i] = 0;
		}
	}

	static void SetPage(UINT nPage, UINT_PTR id)
	{
		g_idWizOrder[nPage] = id;
	}

	static UINT_PTR GetPrevPage(UINT nPageCur)
	{
		if (0 == nPageCur)
		{
			return(0);
		}

		for (int i=nPageCur-1; i>=1; --i)
		{
			if (0 != g_idWizOrder[i])
			{
				break;
			}
		}

		return(g_idWizOrder[i]);
	}

	static UINT_PTR GetNextPage(UINT nPageCur)
	{
		if (Count-1 <= nPageCur)
		{
			return(0);
		}

		for (int i=nPageCur+1; i<Count-1; ++i)
		{
			if (0 != g_idWizOrder[i])
			{
				break;
			}
		}

		return(g_idWizOrder[i]);
	}

	static BOOL HandleWizNotify(HWND hPage, NMHDR *pHdr, UINT nPageCur)
	{
		switch(pHdr->code)
		{
		case PSN_SETACTIVE:
			InitBackNext(hPage, nPageCur);

			if (g_fSilentWizard)
			{
				PropSheet_PressButton(GetParent(hPage), PSBTN_NEXT);
			}
			break;

        case PSN_WIZBACK:
		{
			UINT_PTR iPrev = GetPrevPage(nPageCur);
			SetWindowLongPtr(hPage, DWLP_MSGRESULT, iPrev);
			break;
		}

		case PSN_WIZNEXT:
		{
			UINT_PTR iPrev = GetNextPage(nPageCur);
			SetWindowLongPtr(hPage, DWLP_MSGRESULT, iPrev);
			break;
		}

		default:
			return(FALSE);
		}

		return(TRUE);
	}

private:
	static UINT_PTR g_idWizOrder[Count];

	static void InitBackNext(HWND hPage, UINT nPageCur)
	{
		DWORD dwFlags = 0;

		if (0 != nPageCur && 0 != GetPrevPage(nPageCur))
		{
			dwFlags |= PSWIZB_BACK;
		}

		if (Count-1 != nPageCur && 0 != GetNextPage(nPageCur))
		{
			dwFlags |= PSWIZB_NEXT;
		}
		else
		{
			dwFlags |= PSWIZB_FINISH;
		}

		PropSheet_SetWizButtons(::GetParent(hPage), dwFlags);
	}
} ;

UINT_PTR IntroWiz::g_idWizOrder[Count];

UINT_PTR GetPageBeforeULS()
{
	return(IntroWiz::GetPrevPage(IntroWiz::ULSFirst));
}

UINT_PTR GetPageBeforeVideoWiz()
{
	return(IntroWiz::GetPrevPage(IntroWiz::Video));
}

UINT_PTR GetPageBeforeAudioWiz()
{
	return(IntroWiz::GetPrevPage(IntroWiz::AudioFirst));
}

UINT_PTR GetPageAfterVideo()
{
	return(IntroWiz::GetNextPage(IntroWiz::Video));
}

UINT_PTR GetPageAfterULS()
{
	return(IntroWiz::GetNextPage(IntroWiz::ULSLast));
}

void HideWizard(HWND hwnd)
{
	SetWindowPos(hwnd, NULL, -1000, -1000, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
}

void ShowWizard(HWND hwnd)
{
	CenterWindow(hwnd, HWND_DESKTOP);
	g_fSilentWizard = FALSE;
	PostMessage(hwnd, WM_SYSCOMMAND, SC_RESTORE, 0);
}


/*  F I L L  I N  P R O P E R T Y  P A G E  */
/*-------------------------------------------------------------------------
    %%Function: FillInPropertyPage

    Fill in the given PROPSHEETPAGE structure.
-------------------------------------------------------------------------*/
VOID FillInPropertyPage(PROPSHEETPAGE* psp, int idDlg,
    DLGPROC pfnDlgProc, LPARAM lParam, LPCTSTR pszProc)
{
	// Clear and set the size of the PROPSHEETPAGE
	InitStruct(psp);

	ASSERT(0 == psp->dwFlags);       // No special flags.
	ASSERT(NULL == psp->pszIcon);    // Don't use a special icon in the caption bar.

	psp->hInstance = ::GetInstanceHandle();
	psp->pszTemplate = MAKEINTRESOURCE(idDlg); // The dialog box template to use.
	psp->pfnDlgProc = pfnDlgProc;    // The dialog procedure that handles this page.
	psp->pszTitle = pszProc;         // The title for this page.
	psp->lParam = lParam;            // Special application-specific data.
}


static const UINT NOVALSpecified = 666;

UINT GetBandwidth()
{
	RegEntry reAudio(AUDIO_KEY, HKEY_CURRENT_USER);
	return(reAudio.GetNumber(REGVAL_TYPICALBANDWIDTH, NOVALSpecified ));
}

void SetBandwidth(UINT uBandwidth)
{
	RegEntry reAudio(AUDIO_KEY, HKEY_CURRENT_USER);
	reAudio.SetValue(REGVAL_TYPICALBANDWIDTH, uBandwidth);
}

HRESULT StartRunOnceWizard(LPLONG plSoundCaps, BOOL fForce, BOOL fVisible)
{
	LPPROPSHEETPAGE	pAudioPages = NULL;
	UINT			nNumAudioPages = 0;
	PWIZCONFIG		pAudioConfig;

	CULSWizard*		pIWizard = NULL;
	LPPROPSHEETPAGE	pULSPages = NULL;
	DWORD			dwNumULSPages = 0;
	ULS_CONF*		pulsConf = NULL;
	UINT			uOldBandwidth = 0;
	UINT			uBandwidth = 0;

	int				idAppSharingIntroWiz = 0;
	
	BOOL  fULSWiz     = FALSE;
	BOOL  fAudioWiz   = FALSE;
	BOOL  fVideoWiz   = FALSE;
	BOOL  fVidWizInit = FALSE;
	
    HRESULT         hrRet = E_FAIL;

	g_fSilentWizard = !fVisible;

    ASSERT(plSoundCaps);

	BOOL fNeedUlsWizard = FALSE;
	BOOL fNeedVideoWizard = FALSE;
	BOOL fNeedAudioWizard = NeedAudioWizard(plSoundCaps, fForce);

	if (fNeedAudioWizard)
	{
        if (GetAudioWizardPages(RUNDUE_NEVERBEFORE,
								WAVE_MAPPER,
								&pAudioPages,
								&pAudioConfig,
								&nNumAudioPages))
        {
            fAudioWiz = TRUE;
        }
        else
        {
			ERROR_OUT(("could not get AudioWiz pages"));
        }
	}

	fVidWizInit = InitVidWiz();
	if (fVidWizInit == FALSE)
	{
		fVideoWiz = FALSE;
		WARNING_OUT(("InitVidWiz failed"));
	}
		
	else
	{
		fNeedVideoWizard = NeedVideoPropPage(fForce);
		fVideoWiz = fNeedVideoWizard;
	}


    if (NULL != (pIWizard = new CULSWizard))
	{
		ASSERT (pIWizard);
		// BUGBUG: not checking return value:
		HRESULT hr = pIWizard->GetWizardPages (&pULSPages, &dwNumULSPages, &pulsConf);
		if (SUCCEEDED(hr))
		{
			ASSERT(pulsConf);
			
			TRACE_OUT(("ULS_CONF from UlsGetConfiguration:"));
			TRACE_OUT(("\tdwFlags:       0x%08x", pulsConf->dwFlags));
			TRACE_OUT(("\tszServerName:  >%s<", pulsConf->szServerName));
			TRACE_OUT(("\tszUserName:    >%s<", pulsConf->szUserName));
			TRACE_OUT(("\tszEmailName:   >%s<", pulsConf->szEmailName));

			fNeedUlsWizard = ((pulsConf->dwFlags &
			    (ULSCONF_F_EMAIL_NAME | ULSCONF_F_FIRST_NAME | ULSCONF_F_LAST_NAME)) !=
			    (ULSCONF_F_EMAIL_NAME | ULSCONF_F_FIRST_NAME | ULSCONF_F_LAST_NAME));

			// Don't bother with the ULS wizard if we have all the information
		    if ((!fForce) && !fNeedUlsWizard)
		    {
			    // We have all of the necessary names
                hrRet = S_OK;
                // release the pages we won't be needing them
        		pIWizard->ReleaseWizardPages (pULSPages);
        		delete pIWizard;
        		pIWizard = NULL;
                dwNumULSPages = 0;
            }
            else
			{
				// some information is not available - we need to run the
				// wizard...
				//SS: if for some reason the user name is not set
				//even though the others are set??
				fULSWiz = TRUE;
				if (::GetDefaultName(pulsConf->szUserName, CCHMAX(pulsConf->szUserName)))
				{
					// We have added a default name, so mark that structure
					// member as valid:
					pulsConf->dwFlags |= ULSCONF_F_USER_NAME;
				}
			}
        }
    }
    else
    {
		ERROR_OUT(("CreateUlsWizardInterface() failed!"));
    }

	// Determine if we need to display the app sharing info page, and if
	// so which one.
	if (::IsWindowsNT() && !g_fNTDisplayDriverEnabled)
	{
		idAppSharingIntroWiz = ::CanInstallNTDisplayDriver()
									? IDD_APPSHARINGWIZ_HAVESP
									: IDD_APPSHARINGWIZ_NEEDSP;
	}

    if ((fULSWiz || fAudioWiz || fVideoWiz))
    {
	    UINT nNumPages = 0;

        // Now fill in remaining PROPSHEETHEADER structures:
	    PROPSHEETHEADER	psh;
	    InitStruct(&psh);
	    psh.dwFlags = PSH_PROPSHEETPAGE | PSH_WIZARD | PSH_NOAPPLYNOW;
	    psh.hInstance = ::GetInstanceHandle();
	    ASSERT(0 == psh.nStartPage);

        // alocate enough space for all pages
        DWORD nPages = dwNumULSPages + nNumAudioPages
									 + ( (0 != idAppSharingIntroWiz) ? 1 : 0 )
									 + (fVideoWiz ? 1 : 0)
									 + 2 // intro page & bandwidth page
									 + 1 // shortcuts page
									 ;

        LPPROPSHEETPAGE ppsp = new PROPSHEETPAGE[ nPages ];

	    if (NULL != ppsp)
	    {
			IntroWiz::InitPages();

			BOOL fContinue = TRUE;
		    INTRO_PAGE_CONFIG ipcIntro = { &fContinue, FALSE };
		    INTRO_PAGE_CONFIG ipcAppSharing = { &fContinue, TRUE };

            if (fULSWiz)
		    {
			    // Insert the intro page:

			    FillInPropertyPage(&ppsp[nNumPages++], IDD_INTROWIZ,
                        IntroWiz, (LPARAM) &ipcIntro);

				IntroWiz::SetPage(IntroWiz::Intro, IDD_INTROWIZ);

				// Insert an NT application page, if necessary.  It uses the
				// same dialog proc as the intro page.
				if (0 != idAppSharingIntroWiz)
				{
					FillInPropertyPage(&ppsp[nNumPages++], idAppSharingIntroWiz,
							AppSharingWiz, (LPARAM) &ipcAppSharing);

					IntroWiz::SetPage(IntroWiz::AppSharing, idAppSharingIntroWiz);
				}

			    ASSERT(pulsConf);
			    pulsConf->dwFlags |= (ULSWIZ_F_SHOW_BACK |
						((fAudioWiz || fVideoWiz) ? ULSWIZ_F_NO_FINISH : 0));
			    ::CopyMemory(	&(ppsp[nNumPages]),
							    pULSPages,
							    dwNumULSPages * sizeof(PROPSHEETPAGE));

				IntroWiz::SetPage(IntroWiz::ULSFirst,
					reinterpret_cast<UINT_PTR>(pULSPages[0].pszTemplate));
				IntroWiz::SetPage(IntroWiz::ULSLast,
					reinterpret_cast<UINT_PTR>(pULSPages[dwNumULSPages-1].pszTemplate));
			    nNumPages += dwNumULSPages;

				uBandwidth = uOldBandwidth = GetBandwidth();
				if( NOVALSpecified == uBandwidth )
				{
					FillInPropertyPage(&ppsp[nNumPages++], IDD_BANDWIDTHWIZ,
							BandwidthWiz, (LPARAM) &uBandwidth);
					IntroWiz::SetPage(IntroWiz::Bandwidth, IDD_BANDWIDTHWIZ);
				}
            }

			BOOL fShortcuts = fForce && !g_fSilentWizard;

			if (fVideoWiz)
			{
				LONG button_mask = 0;
				if (fULSWiz == TRUE)
					button_mask |= PSWIZB_BACK;
				if (fShortcuts || fAudioWiz)
					button_mask |= PSWIZB_NEXT;
				else
					button_mask |= PSWIZB_FINISH;
				
				FillInPropertyPage(&ppsp[nNumPages], IDD_VIDWIZ,
	                   VidWizDlg, button_mask, "NetMeeting");
				nNumPages++;
			
				IntroWiz::SetPage(IntroWiz::Video, IDD_VIDWIZ);
			}

			if (fShortcuts)
			{
				FillInPropertyPage(&ppsp[nNumPages], IDD_SHRTCUTWIZ,
					   ShortcutWizDialogProc, 0);
				nNumPages++;

				IntroWiz::SetPage(IntroWiz::Shortcuts, IDD_SHRTCUTWIZ);
			}

		    if (fAudioWiz)
		    {
			     if (fULSWiz || fVideoWiz)
			     {
				     pAudioConfig->uFlags |= STARTWITH_BACK;
			     }
			     ::CopyMemory(	&(ppsp[nNumPages]),
							    pAudioPages,
							    nNumAudioPages * sizeof(PROPSHEETPAGE));
			    nNumPages += nNumAudioPages;
				
				IntroWiz::SetPage(IntroWiz::AudioFirst,
					reinterpret_cast<UINT_PTR>(pAudioPages[0].pszTemplate));
		    }

			psh.ppsp = ppsp;
			psh.nPages = nNumPages;

			if( !PropertySheet(&psh) )
			{		// User hit CANCEL
				pIWizard->ReleaseWizardPages (pULSPages);
				delete pIWizard;
				delete [] ppsp;
				return S_FALSE;
			}
		
		    delete [] ppsp;

            if ((FALSE == fContinue) && fULSWiz)
		    {
			    // Clear out the flags, because we don't want to store
			    // any info in the registry (and therefore, we don't want
			    // to run)
			    pulsConf->dwFlags = 0;
		    }
	    }
    }

    if (fULSWiz)
    {
	    if (!(ULSCONF_F_USER_NAME & pulsConf->dwFlags))
	    {
    	    if (::GetDefaultName(pulsConf->szUserName, CCHMAX(pulsConf->szUserName)))
		    {
			    pulsConf->dwFlags |= ULSCONF_F_USER_NAME;
		    }
	    }
	
	    if ((S_OK == pIWizard->SetConfig (pulsConf)) &&
		    (ULSCONF_F_USER_NAME & pulsConf->dwFlags) &&
		    (ULSCONF_F_EMAIL_NAME & pulsConf->dwFlags) &&
		    (ULSCONF_F_FIRST_NAME & pulsConf->dwFlags) &&
		    (ULSCONF_F_LAST_NAME & pulsConf->dwFlags))
	    {
		    // We have all of the necessary names
            hrRet = S_OK;
	    }
        else
        {
		    WARNING_OUT(("Unable to obtain a name!"));
	    }

        TRACE_OUT(("ULS_CONF after running wizard:"));
	    TRACE_OUT(("\tdwFlags:       0x%08x", pulsConf->dwFlags));
	    TRACE_OUT(("\tszServerName:  >%s<", pulsConf->szServerName));
	    TRACE_OUT(("\tszUserName:    >%s<", pulsConf->szUserName));
	    TRACE_OUT(("\tszEmailName:   >%s<", pulsConf->szEmailName));
	
	    pIWizard->ReleaseWizardPages (pULSPages);
	    delete pIWizard;
	    pIWizard = NULL;
    }

	// Display the Splash screen as soon as possible
    if( SUCCEEDED(hrRet) && fForce && fVisible && (NULL == GetConfRoom()))
    {
    	::StartSplashScreen(NULL);
    }


	if (uOldBandwidth != uBandwidth)
	{
		SetBandwidth(uBandwidth);
		SaveDefaultCodecSettings(uBandwidth);
	}

    if (fAudioWiz)
    {
	    AUDIOWIZOUTPUT awo;
	    ReleaseAudioWizardPages(pAudioPages, pAudioConfig, &awo);
	    if (awo.uValid & SOUNDCARDCAPS_CHANGED)
	    {
		    *plSoundCaps = awo.uSoundCardCaps;
	    }
	    else
	    {
		    // The wizard was cancelled, so we should only take the
		    // information that tells us whether or not a sound card
		    // is present.
		    *plSoundCaps = (awo.uSoundCardCaps & SOUNDCARD_PRESENT);
		
		    // Write this value to the registry so that the wizard will not
		    // auto-launch the next time we run:
            RegEntry reSoundCaps(AUDIO_KEY, HKEY_CURRENT_USER);
		    reSoundCaps.SetValue(REGVAL_SOUNDCARDCAPS, *plSoundCaps);
	    }
    }


	// Even if the VidWiz page wasn't shown, we still need to call this
	// function (UpdateVidConfigRegistry) to fix the registry if the video
   // capture device configurations have changed since the last time.
	if (fVidWizInit)
	{
		UpdateVidConfigRegistry();
		UnInitVidWiz();
	}
	g_fSilentWizard = FALSE;

	return hrRet;
}



INT_PTR APIENTRY AppSharingWiz( HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
		case WM_INITDIALOG:
		{
			// Save the lParam information. in DWL_USER
			::SetWindowLongPtr(hDlg, DWLP_USER, ((PROPSHEETPAGE*)lParam)->lParam);
			if (g_fSilentWizard)
			{
				HideWizard(GetParent(hDlg));
			}
			else
			{
				ShowWizard(GetParent(hDlg));
			}

			return TRUE;
		}

		case WM_NOTIFY:
		{
			switch (((NMHDR FAR *) lParam)->code)
			{
				case PSN_SETACTIVE:
				{
					ASSERT(lParam);
					INTRO_PAGE_CONFIG* pipc = (INTRO_PAGE_CONFIG*)
												::GetWindowLongPtr(hDlg, DWLP_USER);
					ASSERT(pipc);

					DWORD dwFlags = pipc->fAllowBack ? PSWIZB_BACK : 0;
					if( IntroWiz::GetNextPage(IntroWiz::AppSharing) == 0 )
					{
						dwFlags |= PSWIZB_FINISH;						
					}
					else
					{
						dwFlags |= PSWIZB_NEXT;						
					}

					// Initialize the controls.
					PropSheet_SetWizButtons( ::GetParent(hDlg), dwFlags );

					if (g_fSilentWizard)
					{
						PropSheet_PressButton(
							GetParent(hDlg), PSBTN_NEXT);
					}
					break;
				}

				case PSN_KILLACTIVE:
				{
					::SetWindowLongPtr(hDlg, DWLP_MSGRESULT, FALSE);
					return TRUE;
				}

				case PSN_WIZNEXT:
				{
					UINT_PTR iNext = IntroWiz::GetNextPage(IntroWiz::AppSharing);

					ASSERT( iNext );
					SetWindowLongPtr( hDlg, DWLP_MSGRESULT, iNext );
					return TRUE;
				}

				case PSN_RESET:
				{
					ASSERT(lParam);
					INTRO_PAGE_CONFIG* pipc = (INTRO_PAGE_CONFIG*)
												::GetWindowLongPtr(hDlg, DWLP_USER);
					ASSERT(pipc);
					*pipc->fContinue = FALSE;
					break;
				}
			}
			break;
		}

	default:
		break;
	}
	return FALSE;
}

INT_PTR APIENTRY IntroWiz( HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
		case WM_INITDIALOG:
		{
			// Save the lParam information. in DWL_USER
			::SetWindowLongPtr(hDlg, DWLP_USER, ((PROPSHEETPAGE*)lParam)->lParam);
			if (g_fSilentWizard)
			{
				HideWizard(GetParent(hDlg));
			}
			else
			{
				ShowWizard(GetParent(hDlg));
			}
			return TRUE;
		}

		case WM_NOTIFY:
		{
			switch (((NMHDR FAR *) lParam)->code)
			{
				case PSN_SETACTIVE:
				{
					ASSERT(lParam);
					INTRO_PAGE_CONFIG* pipc = (INTRO_PAGE_CONFIG*)
												::GetWindowLongPtr(hDlg, DWLP_USER);
					ASSERT(pipc);

					// Initialize the controls.
					PropSheet_SetWizButtons(
						::GetParent(hDlg),
						PSWIZB_NEXT | (pipc->fAllowBack ? PSWIZB_BACK : 0));

					if (g_fSilentWizard)
					{
						PropSheet_PressButton(
							GetParent(hDlg), PSBTN_NEXT);
					}
					break;
				}

				case PSN_KILLACTIVE:
				{
					::SetWindowLongPtr(hDlg, DWLP_MSGRESULT, FALSE);
					return TRUE;
				}

				case PSN_WIZNEXT:
				{
					break;
				}

				case PSN_RESET:
				{
					ASSERT(lParam);
					INTRO_PAGE_CONFIG* pipc = (INTRO_PAGE_CONFIG*)
												::GetWindowLongPtr(hDlg, DWLP_USER);
					ASSERT(pipc);
					*pipc->fContinue = FALSE;
					break;
				}
			}
			break;
		}

	default:
		break;
	}
	return FALSE;
}

static void BandwidthWiz_InitDialog(HWND hDlg, UINT uOldBandwidth)
{
	INT idChecked;
	
	//set the initial value
	switch (uOldBandwidth)
	{
		case BW_144KBS:
			idChecked = IDC_RADIO144KBS;
			break;
		case BW_ISDN:
			idChecked = IDC_RADIOISDN;
			break;
		case BW_MOREKBS:
			idChecked = IDC_RADIOMOREKBS;
			break;
		case BW_288KBS:
		default:
			idChecked = IDC_RADIO288KBS;
			break;
	}

	CheckRadioButton(hDlg, IDC_RADIO144KBS, IDC_RADIOISDN, idChecked);
}

static void BandwidthWiz_OK(HWND hDlg, UINT *puBandwidth)
{
	//check the radio button
	if (IsDlgButtonChecked(hDlg,IDC_RADIO144KBS))
	{
		*puBandwidth = BW_144KBS; 						
	}							
	else if (IsDlgButtonChecked(hDlg,IDC_RADIO288KBS))
	{
		*puBandwidth = BW_288KBS; 						
	}							
	else if (IsDlgButtonChecked(hDlg,IDC_RADIOISDN))
	{
		*puBandwidth = BW_ISDN;							
	}							
	else
	{
		*puBandwidth = BW_MOREKBS;							
	}							

//	if (BW_MOREKBS != *puBandwidth)
//	{
//		// disable refresh of speed dials if not on a LAN
//		RegEntry re(UI_KEY, HKEY_CURRENT_USER);
//		re.SetValue(REGVAL_ENABLE_FRIENDS_AUTOREFRESH, (ULONG) 0L);
//	}
}

INT_PTR APIENTRY BandwidthWiz( HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	PROPSHEETPAGE *ps;
	static UINT *puBandwidth;
	static UINT uOldBandwidth;

	switch (message) {
		case WM_INITDIALOG:
		{
			// Save the PROPSHEETPAGE information.
			ps = (PROPSHEETPAGE *)lParam;
			puBandwidth = (UINT*)ps->lParam;
			uOldBandwidth = *puBandwidth;

			BandwidthWiz_InitDialog(hDlg, uOldBandwidth);

			return (TRUE);
		}
		
		case WM_NOTIFY:
			switch (((NMHDR FAR *) lParam)->code) {
				case PSN_SETACTIVE:
				{
					// Initialize the controls.
					IntroWiz::HandleWizNotify(hDlg,
						reinterpret_cast<NMHDR*>(lParam), IntroWiz::Bandwidth);
					break;
				}

				case PSN_WIZBACK:
					return(IntroWiz::HandleWizNotify(hDlg,
						reinterpret_cast<NMHDR*>(lParam), IntroWiz::Bandwidth));

				case PSN_WIZFINISH:
				case PSN_WIZNEXT:
				{
					BandwidthWiz_OK(hDlg, puBandwidth);

					return(IntroWiz::HandleWizNotify(hDlg,
						reinterpret_cast<NMHDR*>(lParam), IntroWiz::Bandwidth));
				}

				case PSN_RESET:
					*puBandwidth = uOldBandwidth;
					break;

				default:
					break;													
			}
			break;

		default:
			break;
	}
	return FALSE;
}

static void BandwidthDlg_OnCommand(HWND hDlg, int id, HWND hwndCtl, UINT codeNotify)
{
	switch(id)
	{
	case IDOK:
	{
		UINT uBandwidth;
		BandwidthWiz_OK(hDlg, &uBandwidth);
		EndDialog(hDlg, uBandwidth);
		break;
	}

		// Fall through
	case IDCANCEL:
		EndDialog(hDlg, 0);
		break;

	default:
		break;
	}
}

INT_PTR CALLBACK BandwidthDlg(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	static const DWORD aContextHelpIds[] = {
		IDC_RADIO144KBS,	IDH_AUDIO_CONNECTION_SPEED,
		IDC_RADIO288KBS,	IDH_AUDIO_CONNECTION_SPEED,
		IDC_RADIOISDN,		IDH_AUDIO_CONNECTION_SPEED,
		IDC_RADIOMOREKBS,	IDH_AUDIO_CONNECTION_SPEED,

		0, 0   // terminator
	};

	switch (message) {
		HANDLE_MSG(hDlg, WM_COMMAND, BandwidthDlg_OnCommand);

	case WM_INITDIALOG:
		BandwidthWiz_InitDialog(hDlg, (UINT)lParam);
		break;

	case WM_CONTEXTMENU:
		DoHelpWhatsThis(wParam, aContextHelpIds);
		break;

	case WM_HELP:
		DoHelp(lParam, aContextHelpIds);
		break;
	
	default:
		return(FALSE);
	}

	return(TRUE);
}


BOOL NeedAudioWizard(LPLONG plSoundCaps, BOOL fForce)
{
	if (_Module.IsSDKCallerRTC() || SysPol::NoAudio())
	{
		WARNING_OUT(("Audio disabled through system policy switch"));
		return FALSE;
	}

	if (fForce)
	{
		return TRUE;
	}


    BOOL fAudioWiz = FALSE;

	RegEntry reSoundCaps(AUDIO_KEY, HKEY_CURRENT_USER);

	// a default that doesn't overlap with real values
	long lCapsNotPresent = 0x7FFFFFFF;

	*plSoundCaps = reSoundCaps.GetNumber(	REGVAL_SOUNDCARDCAPS,
											lCapsNotPresent);

	if (lCapsNotPresent == *plSoundCaps)
	{
		TRACE_OUT(("Missing sound caps - starting calib wizard"));
		fAudioWiz = TRUE;
	}
	else
	{
		if (!ISSOUNDCARDPRESENT(*plSoundCaps))
		{
			if (waveInGetNumDevs() && waveOutGetNumDevs())
				fAudioWiz = TRUE;
		}
		else
		{
			WAVEINCAPS	waveinCaps;
			WAVEOUTCAPS	waveoutCaps;
			
			//if the wavein has changed since last
			if (waveInGetDevCaps(reSoundCaps.GetNumber(REGVAL_WAVEINDEVICEID,WAVE_MAPPER),
				&waveinCaps, sizeof(WAVEINCAPS)) == MMSYSERR_NOERROR)
			{
				//check the name, if changed, run the wizard
				if (lstrcmp(reSoundCaps.GetString(REGVAL_WAVEINDEVICENAME),waveinCaps.szPname))
					fAudioWiz = TRUE;

			}
			else
				fAudioWiz = TRUE;


			//if the waveout has changed since last
			if (waveOutGetDevCaps(reSoundCaps.GetNumber(REGVAL_WAVEOUTDEVICEID,WAVE_MAPPER),
				&waveoutCaps, sizeof(WAVEOUTCAPS)) == MMSYSERR_NOERROR)
			{
				//check the name, if changed, run the wizard
				if (lstrcmp(reSoundCaps.GetString(REGVAL_WAVEOUTDEVICENAME),waveoutCaps.szPname))
					fAudioWiz = TRUE;

			}
			else
				fAudioWiz = TRUE;

		}

	}

    return fAudioWiz;
}


///////////////////////////////////////////////////////
//
// Wizard pages
//

DWORD SetUserPageWizButtons(HWND hDlg, DWORD dwConfFlags)
{
    DWORD dwButtonFlags = PSWIZB_BACK;

    // disable the 'Next' button if not all of first name, last name and email
    // are filled in
    if (!FEmptyDlgItem(hDlg, IDEC_FIRSTNAME) &&
    	!FEmptyDlgItem(hDlg, IDEC_LASTNAME) &&
		!FEmptyDlgItem(hDlg, IDC_USER_EMAIL))
    {
        dwButtonFlags |= (dwConfFlags & ULSWIZ_F_NO_FINISH) ? PSWIZB_NEXT : PSWIZB_FINISH;
    }
    PropSheet_SetWizButtons (GetParent (hDlg), dwButtonFlags);

    return dwButtonFlags;
}

void GetUserPageState(HWND hDlg, ULS_CONF *pConf)
{
    //strip the first name/email name and last name
    TrimDlgItemText(hDlg, IDEC_FIRSTNAME);
    TrimDlgItemText(hDlg, IDEC_LASTNAME);
    TrimDlgItemText(hDlg, IDC_USER_EMAIL);
    TrimDlgItemText(hDlg, IDC_USER_LOCATION);
	TrimDlgItemText(hDlg, IDC_USER_INTERESTS);

    Edit_GetText(GetDlgItem(hDlg, IDEC_FIRSTNAME),
            pConf->szFirstName, MAX_FIRST_NAME_LENGTH);
    Edit_GetText(GetDlgItem(hDlg, IDEC_LASTNAME),
            pConf->szLastName, MAX_LAST_NAME_LENGTH);
    Edit_GetText(GetDlgItem(hDlg, IDC_USER_EMAIL),
            pConf->szEmailName, MAX_EMAIL_NAME_LENGTH);
    Edit_GetText(GetDlgItem(hDlg, IDC_USER_LOCATION),
            pConf->szLocation, MAX_LOCATION_NAME_LENGTH);
    Edit_GetText(GetDlgItem(hDlg, IDC_USER_INTERESTS),
            pConf->szComments, MAX_COMMENTS_LENGTH);

    if (pConf->szFirstName[0]) pConf->dwFlags |= ULSCONF_F_FIRST_NAME;
    if (pConf->szLastName[0]) pConf->dwFlags |= ULSCONF_F_LAST_NAME;
    if (pConf->szEmailName[0]) pConf->dwFlags |= ULSCONF_F_EMAIL_NAME;
    if (pConf->szLocation[0]) pConf->dwFlags |= ULSCONF_F_LOCATION;
    if (pConf->szComments[0]) pConf->dwFlags |= ULSCONF_F_COMMENTS;
}

UINT_PTR GetPageAfterUser()
{
	UINT_PTR iNext = 0;

	if( SysPol::AllowDirectoryServices() )
	{
		iNext = IDD_PAGE_SERVER;
	}
	else
	{	
		iNext = GetPageAfterULS();
	}
	
	return iNext;
}

INT_PTR APIENTRY PageUserDlgProc ( HWND hDlg, UINT uMsg, WPARAM uParam, LPARAM lParam )
{
    ULS_CONF *pConf;
    PROPSHEETPAGE *pPage;
    static DWORD dwWizButtons;

    switch (uMsg)
    {
	
	case WM_DESTROY:
		s_hDlgUserInfo = NULL;
		break;

    case WM_INITDIALOG:
		s_hDlgUserInfo = hDlg;
        pPage = (PROPSHEETPAGE *) lParam;
        pConf = (ULS_CONF *) pPage->lParam;
        SetWindowLongPtr (hDlg, GWLP_USERDATA, lParam);

		// Set the font
		::SendDlgItemMessage(hDlg, IDEC_FIRSTNAME, WM_SETFONT, (WPARAM) g_hfontDlg, 0);
		::SendDlgItemMessage(hDlg, IDEC_LASTNAME, WM_SETFONT, (WPARAM) g_hfontDlg, 0);
		::SendDlgItemMessage(hDlg, IDC_USER_LOCATION, WM_SETFONT, (WPARAM) g_hfontDlg, 0);
		::SendDlgItemMessage(hDlg, IDC_USER_INTERESTS, WM_SETFONT, (WPARAM) g_hfontDlg, 0);

		// Limit the text
        Edit_LimitText(GetDlgItem(hDlg, IDEC_FIRSTNAME), MAX_FIRST_NAME_LENGTH - 1);
        Edit_LimitText(GetDlgItem(hDlg, IDEC_LASTNAME), MAX_LAST_NAME_LENGTH - 1);
        Edit_LimitText(GetDlgItem(hDlg, IDC_USER_EMAIL), MAX_EMAIL_NAME_LENGTH - 1);
        Edit_LimitText(GetDlgItem(hDlg, IDC_USER_LOCATION), MAX_LOCATION_NAME_LENGTH - 1);
        Edit_LimitText(GetDlgItem(hDlg, IDC_USER_INTERESTS), UI_COMMENTS_LENGTH - 1);

        if (pConf->dwFlags & ULSCONF_F_FIRST_NAME)
        {
            Edit_SetText(GetDlgItem(hDlg, IDEC_FIRSTNAME), pConf->szFirstName);
        }
        if (pConf->dwFlags & ULSCONF_F_LAST_NAME)
        {
            Edit_SetText(GetDlgItem(hDlg, IDEC_LASTNAME), pConf->szLastName);
        }

        if (pConf->dwFlags & ULSCONF_F_EMAIL_NAME)
        {
            Edit_SetText(GetDlgItem(hDlg, IDC_USER_EMAIL), pConf->szEmailName);
        }
        if (pConf->dwFlags & ULSCONF_F_LOCATION)
        {
            Edit_SetText(GetDlgItem(hDlg, IDC_USER_LOCATION), pConf->szLocation);
        }

#ifdef DEBUG
        if ((0 == (pConf->dwFlags & ULSCONF_F_COMMENTS)) &&
        	(0 == (pConf->dwFlags & ULSCONF_F_EMAIL_NAME)) )
		{
			extern VOID DbgGetComments(LPTSTR);
			DbgGetComments(pConf->szComments);
			pConf->dwFlags |= ULSCONF_F_COMMENTS;
		}
#endif

        if (pConf->dwFlags & ULSCONF_F_COMMENTS)
        {
            Edit_SetText(GetDlgItem (hDlg, IDC_USER_INTERESTS), pConf->szComments);
        }
        break;

    case WM_COMMAND:
        switch (GET_WM_COMMAND_ID (uParam, lParam))
        {
        case IDEC_FIRSTNAME:
        case IDEC_LASTNAME:
        case IDC_USER_EMAIL:
            if (GET_WM_COMMAND_CMD(uParam,lParam) == EN_CHANGE)
            {
                pPage = (PROPSHEETPAGE *) GetWindowLongPtr (hDlg, GWLP_USERDATA);
                pConf = (ULS_CONF *) pPage->lParam;

                dwWizButtons = SetUserPageWizButtons(hDlg, pConf->dwFlags);
            }
            break;
        }
        break;

    case WM_NOTIFY:
        pPage = (PROPSHEETPAGE *) GetWindowLongPtr (hDlg, GWLP_USERDATA);
        pConf = (ULS_CONF *) pPage->lParam;
        switch (((NMHDR *) lParam)->code)
        {
        case PSN_KILLACTIVE:
            SetWindowLongPtr (hDlg, DWLP_MSGRESULT, FALSE);
            break;
        case PSN_RESET:
            ZeroMemory (pConf, sizeof (ULS_CONF));
            SetWindowLongPtr (hDlg, DWLP_MSGRESULT, FALSE);
            break;
        case PSN_SETACTIVE:
            dwWizButtons = SetUserPageWizButtons(hDlg, pConf->dwFlags);
			if (g_fSilentWizard)
			{
				PropSheet_PressButton(GetParent(hDlg), PSBTN_NEXT);
			}
            break;
        case PSN_WIZBACK:
			return(IntroWiz::HandleWizNotify(hDlg,
				reinterpret_cast<NMHDR*>(lParam), IntroWiz::ULSFirst));

		case PSN_WIZNEXT:
		case PSN_WIZFINISH:

			if (!(dwWizButtons & ((PSN_WIZNEXT == ((NMHDR *) lParam)->code) ?
									PSWIZB_NEXT : PSWIZB_FINISH)))
            {
            	// Reject the next/finish button
				ShowWizard(GetParent(hDlg));
				::SetWindowLongPtr(hDlg, DWLP_MSGRESULT, -1);
				return TRUE;
			}

            if (!FLegalEmailName(hDlg, IDC_USER_EMAIL))
            {
				ShowWizard(GetParent(hDlg));
				ConfMsgBox(hDlg, (LPCTSTR)IDS_ILLEGALEMAILNAME);
				SetWindowLongPtr(hDlg, DWLP_MSGRESULT, -1);
				return TRUE;
            }
            GetUserPageState(hDlg, pConf);

			if( PSN_WIZNEXT == (((NMHDR *) lParam)->code) )
			{
				UINT_PTR iNext = GetPageAfterUser();
				ASSERT( iNext );
				SetWindowLongPtr(hDlg, DWLP_MSGRESULT, iNext);
					
				return TRUE;
			}
            break;

        default:
            return FALSE;
        }

    default:
        return FALSE;
    }

    return TRUE;
}


HRESULT CULSWizard::GetWizardPages ( PROPSHEETPAGE **ppPage, ULONG *pcPages, ULS_CONF **ppUlsConf )
{
	const int cULS_Pages = 5;

    PROPSHEETPAGE *pPage = NULL;
	ULONG cPages = 0;
    UINT cbSize = cULS_Pages * sizeof (PROPSHEETPAGE) + sizeof (ULS_CONF);
    ULS_CONF *pConf = NULL;
    HRESULT hr;

    if (ppPage == NULL || pcPages == NULL || ppUlsConf == NULL)
    {
        return E_POINTER;
    }

    pPage = (PROPSHEETPAGE*) LocalAlloc(LPTR, cbSize);
    if (pPage == NULL)
    {
        return E_OUTOFMEMORY;
    }

    pConf = (ULS_CONF *) (((LPBYTE) pPage) +
                               cULS_Pages * sizeof (PROPSHEETPAGE));
    hr = GetConfig (pConf);
    if (hr != S_OK)
    {
    	// REVIEW: GetConfig will never fail, but if it did, pPage would not be released.
        return hr;
    }

#if USE_GAL
	if( !ConfPolicies::IsGetMyInfoFromGALEnabled() ||
	    !ConfPolicies::GetMyInfoFromGALSucceeded() ||
		ConfPolicies::InvalidMyInfo()
	  )
#endif // USE_GAL
	{
	    FillInPropertyPage(&pPage[cPages], IDD_PAGE_USER, PageUserDlgProc, (LPARAM) pConf);
	    cPages++;
	}


	m_WizDirectCallingSettings.SetULS_CONF( pConf );

	FillInPropertyPage( &pPage[cPages++],
						IDD_PAGE_SERVER,
						CWizDirectCallingSettings::StaticDlgProc,
						reinterpret_cast<LPARAM>(&m_WizDirectCallingSettings)
					  );

    *ppPage = pPage;
	*pcPages = cPages;
	*ppUlsConf = pConf;

    return S_OK;
}


HRESULT CULSWizard::ReleaseWizardPages ( PROPSHEETPAGE *pPage)
{
    LocalFree(pPage);

    return S_OK;
}



HRESULT CULSWizard::GetConfig ( ULS_CONF *pConf )
{
    HRESULT hr = E_POINTER;

	if (NULL != pConf)
	{
		::ZeroMemory (pConf, sizeof (ULS_CONF));
		// always return these as valid
	    pConf->dwFlags = ULSCONF_F_SERVER_NAME | ULSCONF_F_PUBLISH;
	    RegEntry reULS(g_szClientFld, HKEY_CURRENT_USER);
		// BUGBUG: ChrisPi - this was a bad idea - lstrcpyn() returns NULL on failure!
		if (_T('\0') != *(lstrcpyn(	pConf->szEmailName,
									reULS.GetString(g_szEmailName),
									CCHMAX(pConf->szEmailName))))
		{
			pConf->dwFlags |= ULSCONF_F_EMAIL_NAME;
		}
		if (_T('\0') != *(lstrcpyn(	pConf->szFirstName,
						reULS.GetString(g_szFirstName),
						CCHMAX(pConf->szFirstName))))
		{
			pConf->dwFlags |= ULSCONF_F_FIRST_NAME;
		}
		if (_T('\0') != *(lstrcpyn(	pConf->szLastName,
						reULS.GetString(g_szLastName),
						CCHMAX(pConf->szLastName))))
		{
			pConf->dwFlags |= ULSCONF_F_LAST_NAME;
		}
		if (_T('\0') != *(lstrcpyn(	pConf->szLocation,
						reULS.GetString(g_szLocation),
						CCHMAX(pConf->szLocation))))
		{
			pConf->dwFlags |= ULSCONF_F_LOCATION;
		}
		if (_T('\0') != *(lstrcpyn(	pConf->szUserName,
						reULS.GetString(g_szUserName),
						CCHMAX(pConf->szUserName))))
		{
			pConf->dwFlags |= ULSCONF_F_USER_NAME;
		}
		if (_T('\0') != *(lstrcpyn(	pConf->szComments,
						reULS.GetString(g_szComments),
						CCHMAX(pConf->szComments))))
		{
			pConf->dwFlags |= ULSCONF_F_COMMENTS;
		}
		
		if (!_Module.IsSDKCallerRTC())
		{
			lstrcpyn( pConf->szServerName, CDirectoryManager::get_defaultServer(), CCHMAX( pConf->szServerName ) );
		}
		else
		{
			lstrcpyn( pConf->szServerName, _T(" "), CCHMAX( pConf->szServerName ) );
		}

		pConf->fDontPublish = reULS.GetNumber(g_szDontPublish,
										REGVAL_ULS_DONT_PUBLISH_DEFAULT);
		pConf->dwFlags |= ULSCONF_F_PUBLISH;
		hr = S_OK;
	}
	
	return hr;
}




/*  S E T  C O N F I G  */
/*-------------------------------------------------------------------------
    %%Function: SetConfig

-------------------------------------------------------------------------*/
HRESULT CULSWizard::SetConfig ( ULS_CONF *pConf )
{
	if (pConf->dwFlags == 0)
	{
		// nothing to set value
		return S_OK;
	}

	if ((pConf->dwFlags & ULSCONF_F_EMAIL_NAME) &&
		(!FLegalEmailSz(pConf->szEmailName)) )
	{
		// email name must be legal
		return E_INVALIDARG;
	}

	RegEntry re(g_szClientFld);

	if (pConf->dwFlags & ULSCONF_F_PUBLISH)
	{
		re.SetValue(g_szDontPublish, (LONG) pConf->fDontPublish);
	}

	if (pConf->dwFlags & ULSCONF_F_EMAIL_NAME)
	{
		re.SetValue(g_szEmailName, pConf->szEmailName);
	}

	if (pConf->dwFlags & ULSCONF_F_FIRST_NAME)
	{
		re.SetValue(g_szFirstName, pConf->szFirstName);
	}

    if (pConf->dwFlags & ULSCONF_F_LAST_NAME)
    {
		re.SetValue(g_szLastName, pConf->szLastName);
	}
	
	if (pConf->dwFlags & ULSCONF_F_LOCATION)
	{
		re.SetValue(g_szLocation, pConf->szLocation);
	}
	
	if (pConf->dwFlags & ULSCONF_F_COMMENTS)
	{
		re.SetValue(g_szComments, pConf->szComments);
	}

	if (pConf->dwFlags & ULSCONF_F_SERVER_NAME)
	{
		CDirectoryManager::set_defaultServer( pConf->szServerName );
	}

	//SS:may be oprah should do this and store it as their own key
    if ((pConf->dwFlags & ULSCONF_F_FIRST_NAME) || (pConf->dwFlags & ULSCONF_F_LAST_NAME))
    {
		ULS_CONF ulcExisting;
		if ((ULSCONF_F_FIRST_NAME | ULSCONF_F_LAST_NAME) !=
			(pConf->dwFlags & (ULSCONF_F_FIRST_NAME | ULSCONF_F_LAST_NAME)) )
		{
			// If only one of these fields is being set, load the previous config:
			GetConfig(&ulcExisting);
		}

		CombineNames(pConf->szUserName, MAX_DCL_NAME_LEN,
			 (pConf->dwFlags & ULSCONF_F_FIRST_NAME) ?
					pConf->szFirstName : ulcExisting.szFirstName,
			(pConf->dwFlags & ULSCONF_F_LAST_NAME) ?
					pConf->szLastName : ulcExisting.szLastName);

		pConf->dwFlags |= ULSCONF_F_USER_NAME;
		re.SetValue(g_szUserName, pConf->szUserName);
    }

    if ((pConf->dwFlags & ULSCONF_F_SERVER_NAME) || (pConf->dwFlags & ULSCONF_F_EMAIL_NAME))
    {
		TCHAR szTemp[MAX_SERVER_NAME_LENGTH + MAX_EMAIL_NAME_LENGTH + 6];

		ULS_CONF ulcExisting;
		if ((ULSCONF_F_SERVER_NAME | ULSCONF_F_EMAIL_NAME) !=
			(pConf->dwFlags & (ULSCONF_F_SERVER_NAME | ULSCONF_F_EMAIL_NAME)))
		{
			// If only one of these fields is being set, load the previous config:
			GetConfig(&ulcExisting);
		}

		FCreateIlsName(szTemp,
			(pConf->dwFlags & ULSCONF_F_SERVER_NAME) ?
						pConf->szServerName : ulcExisting.szServerName,
			(pConf->dwFlags & ULSCONF_F_EMAIL_NAME) ?
						pConf->szEmailName : ulcExisting.szEmailName,
					CCHMAX(szTemp));

    	re.SetValue(g_szResolveName, szTemp);
    }


	// Generate a cert based on the entered information for secure calls
	// ...make sure all fields we care about are valid first
	#define ULSCONF_F_IDFIELDS (ULSCONF_F_FIRST_NAME|ULSCONF_F_LAST_NAME|\
					ULSCONF_F_EMAIL_NAME)

	if ((pConf->dwFlags & ULSCONF_F_IDFIELDS ) == ULSCONF_F_IDFIELDS)
	{
        //
        // LAURABU BUGBUG:
        // If we can't make a cert (France?) or have wrong SCHANNEL or
        // buggy crypto or unrecognized provider, can we propagate that info
        // and act like security is diabled (not available)?
        //
        // How/can we make a common "security not possible" setting we
        // can use.
        //
        MakeCertWrap(pConf->szFirstName, pConf->szLastName,
		    pConf->szEmailName,	0);

        //
        // LAURABU BOGUS!
        // Only do this when RDS is installed.  And just ONCE.
        //

		// Now make a local machine cert for RDS
		CHAR szComputerName[MAX_COMPUTERNAME_LENGTH+1];
		DWORD cbComputerName = sizeof(szComputerName);
		if (GetComputerName(szComputerName, &cbComputerName))
		{
			MakeCertWrap(szComputerName, NULL, NULL, NMMKCERT_F_LOCAL_MACHINE);
		}
		else
		{
			ERROR_OUT(("GetComputerName failed: %x", GetLastError()));
		}
	}

	return S_OK;
}



bool IsLegalGatewaySz(LPCTSTR szServer)
{
	bool bRet = false;
	
	if( szServer && szServer[0] )
	{
		bRet = true;
	}
	
	return bRet;		
}

bool IsLegalGateKeeperServerSz(LPCTSTR szServer)
{
	
	bool bRet = false;
	
	if( szServer && szServer[0] )
	{
		bRet = true;
	}
	
	return bRet;		
}

bool IsLegalE164Number(LPCTSTR szPhone)
{
	
	if( (NULL == szPhone) || (0 == szPhone[0]) )
	{
		return false;
	}

	// assume a legal phone number is anything with at least 1
	// digit, *,or #.  Anything else will be considered the user's
	// own pretty print formatting (e.g. "876-5309")

	// the bad chars will get filtered out later

	while (*szPhone)
	{
		if ( ((*szPhone >= '0') && (*szPhone <= '9')) ||
		     ((*szPhone == '#') || (*szPhone == '*')) )
		{
			return true;
		}
		szPhone++;
	}
	
	return false;
}


/*  F  L E G A L  E M A I L  S Z  */
/*-------------------------------------------------------------------------
    %%Function: FLegalEmailSz

    A legal email name contains only ANSI characters.
	"a-z, A-Z, numbers 0-9 and some common symbols"
	It cannot include extended characters or < > ( ) /
-------------------------------------------------------------------------*/
BOOL FLegalEmailSz(PTSTR pszName)
{
    if (IS_EMPTY_STRING(pszName))
    	return FALSE;

    for ( ; ; )
    {
		UINT ch = (UINT) ((*pszName++) & 0x00FF);
		if (0 == ch)
			break;

		switch (ch)
			{
		default:
			if ((ch > (UINT) _T(' ')) && (ch <= (UINT) _T('~')) )
				break;
		// else fall thru to error code
		case '(': case ')':
		case '<': case '>':
		case '[': case ']':
		case '/': case '\\':
		case ':': case ';':
		case '+':
		case '=':
		case ',':
		case '\"':
			WARNING_OUT(("FLegalEmailSz: Invalid character '%s' (0x%02X)", &ch, ch));
			return FALSE;
			}
	}

	return TRUE;
}


/*  F  L E G A L  E M A I L  N A M E  */
/*-------------------------------------------------------------------------
    %%Function: FLegalEmailName

-------------------------------------------------------------------------*/
BOOL FLegalEmailName(HWND hdlg, UINT id)
{
	TCHAR sz[MAX_PATH];
	
	GetDlgItemTextTrimmed(hdlg, id, sz, CCHMAX(sz));
	return FLegalEmailSz(sz);
}


/*  F I L L  S E R V E R  C O M B O  B O X  */
/*-------------------------------------------------------------------------
    %%Function: FillServerComboBox

-------------------------------------------------------------------------*/
VOID FillServerComboBox(HWND hwndCombo)
{
	CMRUList	MRUList;

	MRUList.Load( DIR_MRU_KEY );

	const TCHAR * const	pszDomainDirectory	= CDirectoryManager::get_DomainDirectory();

	if( pszDomainDirectory != NULL )
	{
		//	Make sure the configured domain server name is in the list...
		MRUList.AppendEntry( pszDomainDirectory );
	}

	if( CDirectoryManager::isWebDirectoryEnabled() )
	{
		//	Make sure the web directory is in the list...
		MRUList.AppendEntry( CDirectoryManager::get_webDirectoryIls() );
	}

	const TCHAR * const	defaultServer	= CDirectoryManager::get_defaultServer();

	if( lstrlen( defaultServer ) > 0 )
	{
		//	Make sure the default server name is in the list and at the top...
		MRUList.AddNewEntry( defaultServer );
	}

	::SendMessage( hwndCombo, WM_SETREDRAW, FALSE, 0 );
	::SendMessage( hwndCombo, CB_RESETCONTENT, 0, 0 );

	int nCount = MRUList.GetNumEntries();

	for( int nn = MRUList.GetNumEntries() - 1; nn >= 0; nn-- )
	{
		::SendMessage( hwndCombo, CB_ADDSTRING, 0, (LPARAM) CDirectoryManager::get_displayName( MRUList.GetNameEntry( nn ) ) );
	}

	::SendMessage( hwndCombo, WM_SETREDRAW, TRUE, 0 );

}	//	End of FillServerComboBox.


//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
// CWizDirectCallingSettings wizard page
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

/* static */ HWND CWizDirectCallingSettings::s_hDlg;

INT_PTR CWizDirectCallingSettings::StaticDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	INT_PTR bRet = FALSE;

	if ( message == WM_INITDIALOG )
	{
		PROPSHEETPAGE* pPage = reinterpret_cast<PROPSHEETPAGE*>(lParam);
		SetWindowLongPtr( hDlg, GWLP_USERDATA, pPage->lParam );

		s_hDlg = hDlg;
		CWizDirectCallingSettings* pThis = reinterpret_cast<CWizDirectCallingSettings*>(pPage->lParam);
		if( pThis )
		{
			bRet = pThis->_OnInitDialog();
		}

	}
	else
	{
		CWizDirectCallingSettings* pThis = reinterpret_cast<CWizDirectCallingSettings*>( GetWindowLongPtr( hDlg, GWLP_USERDATA ) );
		if( pThis )
		{
			bRet = pThis->_DlgProc(hDlg, message, wParam, lParam );
		}
	}

	return bRet;
}

/* static */ void CWizDirectCallingSettings::OnWizFinish()
{
	if( s_hDlg && IsWindow( s_hDlg ) )
	{
		CWizDirectCallingSettings* pThis = reinterpret_cast<CWizDirectCallingSettings*>( GetWindowLongPtr( s_hDlg, GWLP_USERDATA ) );
		if( pThis )
		{
			pThis->_OnWizFinish();
		}
	}
}


INT_PTR APIENTRY CWizDirectCallingSettings::_DlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	BOOL bRet = FALSE;

	switch( message )
	{
		case WM_DESTROY:
			s_hDlg = NULL;
			break;

		case WM_NOTIFY:
		{
			NMHDR* pNmHdr = reinterpret_cast<NMHDR*>(lParam);
			switch(pNmHdr->code)
			{
				case PSN_SETACTIVE:		return _OnSetActive();
				case PSN_KILLACTIVE:	return _OnKillActive();
				case PSN_WIZBACK:		return _OnWizBack();
				case PSN_WIZNEXT:		bRet = _OnWizNext();

							// We fall through from the WIZ_NEXT becaus
							// we have to save the informaition when we change
							// pages
				case PSN_APPLY:
				case PSN_WIZFINISH:		_OnWizFinish();

			}
			break;
		}

		case WM_COMMAND:
			return _OnCommand(wParam, lParam);

		default:
			break;

	}
	return bRet;
}


/* static */ bool CWizDirectCallingSettings::IsGatewayNameInvalid()
{
	TCHAR szServer[MAX_SERVER_NAME_LENGTH];
	szServer[0] = NULL;

	if( s_hDlg )
	{
		GetDlgItemTextTrimmed(s_hDlg, IDE_CALLOPT_GW_SERVER, szServer, CCHMAX(szServer) );
	}
	else
	{
		GetDefaultGateway( szServer, CCHMAX( szServer ) );
	}

	return !IsLegalGatewaySz(szServer);
}

void CWizDirectCallingSettings::_SetWizButtons()
{
	DWORD dwFlags = NULL;
	
	if( ( BST_CHECKED == IsDlgButtonChecked( s_hDlg, IDC_CHECK_USE_GATEWAY ) ) && IsGatewayNameInvalid() )
	{
		dwFlags = PSWIZB_BACK;
	}
	else
	{
		dwFlags = PSWIZB_BACK | PSWIZB_NEXT;
	}

	if( 0 == GetPageAfterULS() )
	{
		dwFlags |= PSWIZB_FINISH;
	}
	else
	{
		dwFlags |= PSWIZB_NEXT;
	}

	PropSheet_SetWizButtons( GetParent( s_hDlg ), dwFlags );
}

BOOL CWizDirectCallingSettings::_OnCommand( WPARAM wParam, LPARAM lParam )
{
	BOOL bRet = TRUE;

	switch( LOWORD( wParam ) )
	{
		case IDC_CHECK_USE_GATEWAY:
		{
			bool bEnable = ( BST_CHECKED == IsDlgButtonChecked( s_hDlg, IDC_CHECK_USE_GATEWAY ) );
			EnableWindow( GetDlgItem( s_hDlg, IDC_STATIC_GATEWAY_NAME ), bEnable );
			EnableWindow( GetDlgItem( s_hDlg, IDE_CALLOPT_GW_SERVER ), bEnable );
			_SetWizButtons();
		}
		break;

		case IDE_CALLOPT_GW_SERVER:
			if( HIWORD( wParam ) == EN_CHANGE )
			{		
				_SetWizButtons();
			}
			break;

		default:			
			break;
	}

	return bRet;
}


BOOL CWizDirectCallingSettings::_OnInitDialog()
{
	BOOL bRet = TRUE;

	_SetWizButtons();

	InitDirectoryServicesDlgInfo( s_hDlg, m_pWiz, m_bInitialEnableGateway, m_szInitialServerName, CCHMAX(m_szInitialServerName) );

	return bRet;
}


BOOL CWizDirectCallingSettings::_OnSetActive()
{
	_SetWizButtons();

	if (g_fSilentWizard)
	{
		PropSheet_PressButton(GetParent(s_hDlg), PSBTN_NEXT);
	}

	return FALSE;
}

BOOL CWizDirectCallingSettings::_OnKillActive()
{
	return FALSE;
}

BOOL CWizDirectCallingSettings::_OnWizBack()
{
	UINT iPrev = IDD_PAGE_USER;

#if USE_GAL
	if( !ConfPolicies::IsGetMyInfoFromGALEnabled() )
	{
		iPrev = IDD_PAGE_USER;
	}
	else
	{
		iPrev = GetPageBeforeULS();
	}
#endif
		
	ASSERT( iPrev );
	SetWindowLongPtr( s_hDlg, DWLP_MSGRESULT, iPrev );
	return TRUE;
}

BOOL CWizDirectCallingSettings::_OnWizFinish()
{
	RegEntry reConf(CONFERENCING_KEY, HKEY_CURRENT_USER);

	m_pConf->dwFlags |= ULSCONF_F_PUBLISH | ULSCONF_F_SERVER_NAME;

	// Get the server name
	SendDlgItemMessage( s_hDlg, IDC_NAMESERVER, WM_GETTEXT, CCHMAX( m_pConf->szServerName ), (LPARAM) m_pConf->szServerName );
	TrimSz( m_pConf->szServerName );

	lstrcpyn( m_pConf->szServerName, CDirectoryManager::get_dnsName( m_pConf->szServerName ), CCHMAX( m_pConf->szServerName ) );

		// Get the don't publish flags			
	m_pConf->fDontPublish = ( BST_CHECKED == IsDlgButtonChecked( s_hDlg, IDC_USER_PUBLISH ) );

	reConf.SetValue(REGVAL_DONT_LOGON_ULS, BST_CHECKED != IsDlgButtonChecked( s_hDlg, IDC_USEULS ));

	return FALSE;
}

BOOL CWizDirectCallingSettings::_OnWizNext()
{

	UINT_PTR iNext = GetPageAfterULS();
	ASSERT( iNext );
	SetWindowLongPtr( s_hDlg, DWLP_MSGRESULT, iNext );
	return TRUE;
}

// Taken from MSDN:
static HRESULT CreateLink(LPCSTR lpszPathObj,
    LPCTSTR lpszPathLink, LPCSTR lpszDesc)
{
    HRESULT hres;
    IShellLink* psl;

    // Get a pointer to the IShellLink interface.
    hres = CoCreateInstance(CLSID_ShellLink, NULL,
        CLSCTX_INPROC_SERVER, IID_IShellLink, reinterpret_cast<LPVOID *>(&psl));
    if (SUCCEEDED(hres)) {
        IPersistFile* ppf;

        // Set the path to the shortcut target and add the
        // description.
        psl->SetPath(lpszPathObj);
        if (NULL != lpszDesc)
        {
        	psl->SetDescription(lpszDesc);
        }

       // Query IShellLink for the IPersistFile interface for saving the
       // shortcut in persistent storage.
        hres = psl->QueryInterface(IID_IPersistFile,
            reinterpret_cast<LPVOID *>(&ppf));

        if (SUCCEEDED(hres)) {
#ifndef UNICODE
            WCHAR wsz[MAX_PATH];

            // Ensure that the string is ANSI.
            MultiByteToWideChar(CP_ACP, 0, lpszPathLink, -1,
                wsz, MAX_PATH);
#else // UNICODE
			LPCWSTR wsz = lpszPathLink;
#endif // UNICODE

            // Save the link by calling IPersistFile::Save.
            hres = ppf->Save(wsz, TRUE);
            ppf->Release();
        }
        psl->Release();
    }
    return hres;
}

void DeleteShortcut(int csidl, LPCTSTR pszSubDir)
{
	TCHAR szSpecial[MAX_PATH];
	if (!NMGetSpecialFolderPath(NULL, szSpecial, csidl, TRUE))
	{
		return;
	}

	USES_RES2T
	LPCTSTR pszNetMtg = RES2T(IDS_MEDIAPHONE_TITLE);

	TCHAR szPath[MAX_PATH];
	wsprintf(szPath, TEXT("%s%s\\%s.lnk"), szSpecial, pszSubDir, pszNetMtg);
	DeleteFile(szPath);
}

static void CreateShortcut(HWND hDlg, int csidl, LPCTSTR pszSubDir)
{
	TCHAR szSpecial[MAX_PATH];
	if (!NMGetSpecialFolderPath(hDlg, szSpecial, csidl, TRUE))
	{
		return;
	}
	USES_RES2T
	LPCTSTR pszNetMtg = RES2T(IDS_MEDIAPHONE_TITLE);

	TCHAR szPath[MAX_PATH];
	wsprintf(szPath, TEXT("%s%s\\%s.lnk"), szSpecial, pszSubDir, pszNetMtg);

	char szThis[MAX_PATH];
	int cb = ARRAY_ELEMENTS(szThis);
	GetModuleFileNameA(NULL, szThis, cb -1);
	szThis[cb -1] = 0;
	CreateLink(szThis, szPath, NULL);
}

INT_PTR CALLBACK ShortcutWizDialogProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch(uMsg)
	{
	case WM_INITDIALOG:
		CheckDlgButton(hDlg, IDC_ONDESKTOP, BST_CHECKED);
		CheckDlgButton(hDlg, IDC_ONQUICKLAUNCH, BST_CHECKED);
		break;

	case WM_DESTROY:
		if (IsDlgButtonChecked(hDlg, IDC_ONDESKTOP))
		{
			CreateShortcut(hDlg, CSIDL_DESKTOP, g_szEmpty);
		}
		if (IsDlgButtonChecked(hDlg, IDC_ONQUICKLAUNCH))
		{
			CreateShortcut(hDlg, CSIDL_APPDATA, QUICK_LAUNCH_SUBDIR);
		}
		break;

	case WM_NOTIFY:
	{
		NMHDR* pNmHdr = reinterpret_cast<NMHDR*>(lParam);
		switch(pNmHdr->code)
		{
		case PSN_RESET:
			// HACKHACK georgep: Uncheck the buttons so we will not try to
			// create the shortcuts
			CheckDlgButton(hDlg, IDC_ONDESKTOP, BST_UNCHECKED);
			CheckDlgButton(hDlg, IDC_ONQUICKLAUNCH, BST_UNCHECKED);

			// Fall through
		default:
			return(IntroWiz::HandleWizNotify(hDlg, pNmHdr, IntroWiz::Shortcuts));
		}
		break;
	}

	default:
		return(FALSE);
	}

	return(TRUE);
}