gecko-dev/cmd/winfe/dialog.cpp

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.0 (the "NPL"); you may not use this file except in
 * compliance with the NPL.  You may obtain a copy of the NPL at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the NPL is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
 * for the specific language governing rights and limitations under the
 * NPL.
 *
 * The Initial Developer of this code under the NPL is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
 * Reserved.
 */

#include "stdafx.h"

#include "dialog.h"

#include "helper.h"
#include "nethelp.h"

#include "nsIDefaultBrowser.h"
#include "prefapi.h"
#include "edt.h" // For EDT_GetEditHistory and MAX_EDT_HISTORY_LOCATIONS

#ifdef _DEBUG
#undef THIS_FILE
static char BASED_CODE THIS_FILE[] = __FILE__;
#endif

extern "C" void sample_exit_routine(URL_Struct *URL_s,int status,MWContext *window_id);

// Last URL entered in the Open Page dialog
static CString url_string = "";

/////////////////////////////////////////////////////////////////////////////
// CDialogURL dialog


CDialogURL::CDialogURL(CWnd* pParent, MWContext * context)
    : CDialog(CDialogURL::IDD, pParent)
{
    //{{AFX_DATA_INIT(CDialogURL)
    m_csURL = url_string;
    //}}AFX_DATA_INIT
	ASSERT(context);
    m_Context = context;
    m_bInitNavComboBox = FALSE;
    m_bInternalChange = FALSE;

#ifdef EDITOR
    m_bInitComposerComboBox = FALSE;
#endif
    XP_MEMSET(m_pNavTitleList, 0, MAX_HISTORY_LOCATIONS*sizeof(char*));
}

CDialogURL::~CDialogURL() 
{
    for( int i = 0; i < MAX_HISTORY_LOCATIONS; i++ )
        XP_FREEIF(m_pNavTitleList[i]);

    // Note: Composer history list points to other static strings,
    //  don't delete here
}


#ifndef EDITOR
#define MOVE_CONTROL_AMOUNT 30
static void wfe_MoveControl(CDialog *pDialog, UINT nID)
{
    CRect cRect;
    CWnd *pWnd = pDialog->GetDlgItem(nID);
    if( pWnd )
    {
        pWnd->GetWindowRect(&cRect);
        pDialog->ScreenToClient(&cRect);
        pWnd->SetWindowPos(0, cRect.left, cRect.top-MOVE_CONTROL_AMOUNT, 0, 0, SWP_NOSIZE | SWP_NOZORDER);
    }
}
#endif

BOOL CDialogURL::OnInitDialog() 
{
	CDialog::OnInitDialog();
	CComboBox *pNavBox = (CComboBox*)GetDlgItem(IDC_URL);
    if( !pNavBox )
        return(1);

    // Used a separate define in dialog.h to avoid having to include edt.h for MAX_EDIT_HISTORY_LOCATIONS
    XP_ASSERT(MAX_HISTORY_LOCATIONS <= MAX_EDIT_HISTORY_LOCATIONS); 

#ifdef EDITOR
	CComboBox *pComposerBox = (CComboBox *) GetDlgItem(IDC_URL_EDITOR); 
    if( !pComposerBox )
        return(1);

    if( EDT_IS_EDITOR(m_Context) )
    {
        // Default is to open into Composer
    	((CButton *)GetDlgItem(IDC_OPEN_URL_EDITOR))->SetCheck(1);
        // Hide Navigator's editbox
        pNavBox->ShowWindow(SW_HIDE);

        // This will init the dropdown list
        GetComposerComboBox();

        pComposerBox->SetFocus();
        pComposerBox->SetEditSel(0, -1);
    }
    else
    {
        // Default is open in Navigator
    	((CButton *)GetDlgItem(IDC_OPEN_URL_BROWSER))->SetCheck(1);
        // Hide the editor's combobox
        pComposerBox->ShowWindow(SW_HIDE);

        // This will init the dropdown list
        GetNavComboBox();

        pNavBox->SetFocus();
        pNavBox->SetEditSel(0, -1);
    }
	return(0);
#else
    GetNavComboBox();
	pNavBox->SetFocus();
	pNavBox->SetSel(0, -1);

    // Move all controls up and resize the dialog as well
    // We could have made a different dialog, but that makes it more difficult
    //  for I18N, so just move the controls instead
    wfe_MoveControl(this, IDC_ENTER_URL_MSG);
    wfe_MoveControl(this, IDC_URL);
    wfe_MoveControl(this, IDC_BROWSE_FILE);
    wfe_MoveControl(this, IDOK);
    wfe_MoveControl(this, IDCANCEL);
    wfe_MoveControl(this, ID_HELP);
    CRect cRect;
    GetWindowRect(&cRect);
    SetWindowPos(0, 0, 0, cRect.Width(), cRect.Height()-MOVE_CONTROL_AMOUNT, SWP_NOMOVE | SWP_NOZORDER);
#endif // EDITOR
	return(0);
}

BEGIN_MESSAGE_MAP(CDialogURL, CDialog)
	//{{AFX_MSG_MAP(CDialogURL)
	ON_BN_CLICKED(IDC_BROWSE_FILE, OnBrowseForFile)
	ON_COMMAND(ID_HELP, OnHelp)
	ON_CBN_EDITCHANGE(IDC_URL, OnChangeNavLocation)
	ON_CBN_SELCHANGE(IDC_URL, OnSelchangeNavList)
	//}}AFX_MSG_MAP
#ifdef EDITOR
	ON_BN_CLICKED(IDC_OPEN_URL_BROWSER, OnOpenInBrowser)
	ON_BN_CLICKED(IDC_OPEN_URL_EDITOR, OnOpenInEditor)
	ON_CBN_SELCHANGE(IDC_URL_EDITOR, OnSelchangeComposerList)
	ON_CBN_EDITCHANGE(IDC_URL_EDITOR, OnChangeComposerLocation)
#endif
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CDialogURL message handlers
/////////////////////////////////////////////////////////////////////////////

void CDialogURL::OnBrowseForFile()
{
    int type = HTM;
#ifdef EDITOR
    // Restrict to only *.HTML and allow *.SHTML if loading in Composer
    if( ((CButton *)GetDlgItem(IDC_OPEN_URL_EDITOR))->GetCheck() ){
        type = HTM_ONLY;
    }
#endif
    char * pName = wfe_GetExistingFileName( this->m_hWnd, szLoadString(IDS_OPEN), type, TRUE, NULL);
    if( pName ){
        GetDlgItem(EDT_IS_EDITOR(m_Context) ? IDC_URL_EDITOR: IDC_URL)->SetWindowText(pName);
        XP_FREE(pName);
        // New behavior - immediately end dialog with filename selected
        OnOK();
    }
}

void CDialogURL::OnHelp()
{

	NetHelp( HELP_OPEN_PAGE );
}

void CDialogURL::OnOK()
{

	CWnd *pNavBox = GetNavComboBox();

#ifdef EDITOR
    BOOL bEdit = ((CButton *)GetDlgItem(IDC_OPEN_URL_EDITOR))->GetCheck() != 0;
    CWnd *pComposerBox = GetComposerComboBox();
    if( bEdit ) {
		pComposerBox->GetWindowText(url_string);
    } else
		pNavBox->GetWindowText(url_string);
#else
	if(pNavBox) {
		pNavBox->GetWindowText(url_string);
	}
#endif

	CDialog::OnOK();
#ifdef XP_WIN32
	url_string.TrimLeft();
	url_string.TrimRight();
#endif

	// this was typed in so no referrer -> OK to do an OnNormalLoad
	if(!url_string.IsEmpty())
    {
        // Bug 36087: Convert relative URL strings to an absolute URL based on current location
        char *pAbsoluteURL = (char *)LPCSTR(url_string);

        int  iType = NET_URL_Type(pAbsoluteURL);

        CString csTemp;
        if( iType == 0 )
        {
            WFE_ConvertFile2Url( csTemp, pAbsoluteURL );
            pAbsoluteURL = (char*)LPCSTR(csTemp);
        }

        BOOL bFreeString = FALSE;
        BOOL bIsFile = NET_IsLocalFileURL(pAbsoluteURL);

        History_entry * pEntry = SHIST_GetCurrent(&m_Context->hist);
        if( pEntry && pEntry->address ) {
            pAbsoluteURL = NET_MakeAbsoluteURL(pEntry->address, pAbsoluteURL );
            bFreeString = TRUE;            
        }

#ifdef EDITOR
        if (bEdit || EDT_IS_EDITOR(m_Context)) {
            // This creates a new edit or browser window
            FE_LoadUrl((char *)LPCSTR(url_string), bEdit);
        } else
#endif
            // Load the URL into the same window only if called from an existing browser
    		ABSTRACTCX(m_Context)->NormalGetUrl(url_string);

        if( pAbsoluteURL && bFreeString )
            XP_FREE(pAbsoluteURL);
	}
}

CComboBox *CDialogURL::GetNavComboBox()
{
    CComboBox *pComboBox = (CComboBox*)GetDlgItem(IDC_URL); 
    
    // Use flag to init once only when we need to
    if( m_bInitNavComboBox )
        return pComboBox;

    m_bInitNavComboBox = TRUE;

    CDC *pDC = pComboBox->GetDC();
    // Get the size of the strings added in the dropdown...
    CSize cSize;
    int iMaxWidth = 0;
    int wincsid = INTL_CharSetNameToID(INTL_ResourceCharSet());

    // Fill the combobox with Composer's "Recent Files" list
    char * pUrl = NULL;
    int j = 0; // Separate counter for title array

// We would like to get Browser history items from the new history system (RDF store?)

    // Use this for the current Browser History (same as in the Go menu)
    // Get the session history list
    XP_List* pList = SHIST_GetList(m_Context);
    if( pList )
    {
        // Get the pointer to the current history entry
	    for( int i = 0; i < MAX_HISTORY_LOCATIONS; i++, pList = pList->prev )
	    {
            //pList = pList->prev;
            if( !pList )
                break;

		    History_entry*  pEntry = (History_entry*)pList->object;
		    //ASSERT(pEntry);
		    if( !pEntry )
                continue;

            // Don't include current page's URL
            if( pEntry == m_Context->hist.cur_doc_ptr )
                continue;

            pComboBox->AddString(pEntry->address);
            m_pNavTitleList[j] = XP_STRDUP(pEntry->title);

            CString csTemp(pUrl);
            if ( pDC )
            {
    		    cSize = CIntlWin::GetTextExtent(wincsid, pDC->GetSafeHdc(), csTemp, csTemp.GetLength());
	            pDC->LPtoDP(&cSize);
	    	    if ( cSize.cx > iMaxWidth )
    			    iMaxWidth = cSize.cx;
    	    }
            j++;
	    }
    }

    if( pComboBox->GetDroppedWidth() < iMaxWidth )
        pComboBox->SetDroppedWidth(iMaxWidth);
    
    // Initialize the edit field with the first history item
    //   or last-used global string
    if( pComboBox->GetCount() > 0 )
    {
        pComboBox->SetCurSel(0);
        SetCaption(m_pNavTitleList[0]);
    }
    else
    {
        pComboBox->SetWindowText((const char*)url_string);
        SetCaption();
    }
    return pComboBox;
}

void CDialogURL::SetCaption(char *pPageTitle)
{
    CString csCaption(szLoadString(pPageTitle ? IDS_OPEN_FILE : IDS_OPEN_PAGE));
    if( pPageTitle )
    {
        // Append the page title so caption is "Open: My Page Title"
        csCaption += pPageTitle;
    }
    SetWindowText((const char*)csCaption);
}

void CDialogURL::OnChangeNavLocation()
{
    // Any text typed in the edit box invalidates the page title
    //  show in the dialog caption, 
    //  but search the title list to find a match
    if( !m_bInternalChange )
    {
    	CString csString;
        CComboBox *pComboBox = GetNavComboBox();
        pComboBox->GetWindowText(csString);
        csString.TrimLeft();
        csString.TrimRight();
        char *pCaption = NULL;
        if( !csString.IsEmpty() )
        {
            // Find user-typed string in the combobox
            //  and set corresponding title
            int nIndex = pComboBox->FindStringExact(0,csString);
            if( nIndex >= 0 )
                pCaption = m_pNavTitleList[nIndex];
        }
        SetCaption(pCaption);
    }
}

void CDialogURL::OnSelchangeNavList()
{
    if( !m_bInternalChange )
        SetCaption(m_pNavTitleList[GetNavComboBox()->GetCurSel()]);
}


#ifdef EDITOR
CComboBox *CDialogURL::GetComposerComboBox()
{
    CComboBox *pComboBox = (CComboBox*)GetDlgItem(IDC_URL_EDITOR); 
    
    // Use flag to init once only when we need to
    if( m_bInitComposerComboBox )
        return pComboBox;

    m_bInitComposerComboBox = TRUE;

    CDC *pDC = pComboBox->GetDC();
    // Get the size of the strings added in the dropdown...
    CSize cSize;
    int iMaxWidth = 0;
    int wincsid = INTL_CharSetNameToID(INTL_ResourceCharSet());

    // Fill the combobox with Composer's "Recent Files" list
    char * pUrl = NULL;
    char * pTitle = NULL;
    int j = 0; // Separate counter for title array
	for( int i = 0; i < MAX_EDIT_HISTORY_LOCATIONS; i++ )
	{
        // Save the Page Title for each URL as well
        // NOTE: We don't have to free these - static list is in xp edit code
		m_pComposerTitleList[i] = 0;
        if(EDT_GetEditHistory(m_Context, i, &pUrl, &m_pComposerTitleList[j]))
        {
            pComboBox->AddString(pUrl);
            CString csTemp(pUrl);
            if ( pDC ){            
    		    cSize = CIntlWin::GetTextExtent(wincsid, pDC->GetSafeHdc(), csTemp, csTemp.GetLength());
	        	pDC->LPtoDP(&cSize);
	    	    if ( cSize.cx > iMaxWidth ){
    			    iMaxWidth = cSize.cx;
		        }
    		}
            j++;
        }
    }
    // ...so we can be sure it's visible by using wider dropdown width
    iMaxWidth += 4;
    if( pComboBox->GetDroppedWidth() < iMaxWidth )
        pComboBox->SetDroppedWidth(iMaxWidth);
    
    // Initialize the edit field with the first history item
    //   or last-used global string (shared with Navigator)
    if( pComboBox->GetCount() > 0 )
    {
        pComboBox->SetCurSel(0);
        SetCaption(m_pComposerTitleList[0]);
    }
    else
    {
        pComboBox->SetWindowText((const char*)url_string);
        SetCaption();
    }

    return pComboBox;
}

void CDialogURL::OnSelchangeComposerList()
{
    if( !m_bInternalChange )
        SetCaption(m_pComposerTitleList[GetComposerComboBox()->GetCurSel()]);
}

void CDialogURL::OnChangeComposerLocation()
{
    // Any text typed in the edit box invalidates the page title
    //  show in the dialog caption, but search the title list
    if( !m_bInternalChange )
    {
    	CString csString;
        CComboBox *pComboBox = GetComposerComboBox();
        pComboBox->GetWindowText(csString);
        csString.TrimLeft();
        csString.TrimRight();
        char *pCaption = NULL;
        if( !csString.IsEmpty() )
        {
            // Find user-typed string in the combobox
            //  and set corresponding title
            int nIndex = pComboBox->FindStringExact(0,csString);
            if( nIndex >= 0 )
                pCaption = m_pComposerTitleList[nIndex];
        }
        SetCaption(pCaption);
    }
}

void CDialogURL::OnOpenInBrowser()
{
	CComboBox *pComposerComboBox = GetComposerComboBox();
    CWnd *pNavComboBox = GetNavComboBox();
    CString csString;
    pComposerComboBox->GetWindowText(csString);
    csString.TrimLeft();
    csString.TrimRight();
    if( !csString.IsEmpty() )
    {
        m_bInternalChange = TRUE;
        pNavComboBox->SetWindowText(csString);
        m_bInternalChange = FALSE;
    }
    pComposerComboBox->ShowWindow(SW_HIDE);
    pNavComboBox->ShowWindow(SW_SHOW);
}

void CDialogURL::OnOpenInEditor()
{
	CComboBox *pComposerComboBox = GetComposerComboBox();
    CWnd *pNavComboBox = GetNavComboBox();
    CString csString;
    pNavComboBox->GetWindowText(csString);
    csString.TrimLeft();
    csString.TrimRight();
    if( !csString.IsEmpty() )
    {
        m_bInternalChange = TRUE;
        pComposerComboBox->SetWindowText(csString);
        m_bInternalChange = FALSE;
    }
    pNavComboBox->ShowWindow(SW_HIDE);
    pComposerComboBox->ShowWindow(SW_SHOW);
}
#endif //EDITOR

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// CDialogLicense dialog

CDialogLicense::CDialogLicense(CWnd* pParent /*=NULL*/)
    : CDialog(CDialogLicense::IDD, pParent)
{
}

BEGIN_MESSAGE_MAP(CDialogLicense, CDialog)
END_MESSAGE_MAP()

int CDialogLicense::DoModal()
{
    int status;
    
    status = CDialog::DoModal();

    if(status == IDOK)
        return(TRUE);
    else
        return(FALSE);

}

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

	CEdit * edit = (CEdit *) GetDlgItem(IDC_EDIT1);  
	if(edit) {
		LPSTR	lpszLicenseText = wfe_LoadResourceString("license");

		if (lpszLicenseText) {
			edit->SetWindowText(lpszLicenseText);
            CDC * pdc = GetDC();
            LOGFONT lf;			// Instead of using ANSI_VAR_FONT for i18n
            XP_MEMSET(&lf,0,sizeof(LOGFONT));
            lf.lfPitchAndFamily = FF_MODERN | FIXED_PITCH;
            lf.lfCharSet = DEFAULT_CHARSET;
	        strcpy(lf.lfFaceName, szLoadString(IDS_FONT_FIXNAME));
   	        lf.lfHeight = -MulDiv(10,pdc->GetDeviceCaps(LOGPIXELSY), 72);
            lf.lfQuality = PROOF_QUALITY;    
            m_cfTextFont.CreateFontIndirect ( &lf );
			edit->SetFont( &m_cfTextFont );
			ReleaseDC(pdc);
			XP_FREE(lpszLicenseText);
		}
	}

	return(1);
}


/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// CDialogSecurity dialog

CDialogSecurity::CDialogSecurity(int myType, XP_Bool *returnPref, CWnd* pParent /*=NULL*/)
    : CDialog(CDialogSecurity::IDD, pParent)
{   
	if((myType < 0) || (myType > MAX_SECURITY_CHECKS - 1))
		myType = 0;

	m_Type = myType;

	returnpref = returnPref;
}

BEGIN_MESSAGE_MAP(CDialogSecurity, CDialog)
END_MESSAGE_MAP()

int CDialogSecurity::DoModal()
{
    int status;
    
    status = CDialog::DoModal();

    if(status == IDOK)
        return(TRUE);
    else
        return(FALSE);

}

//
// If we've gotten here then obviously the dialog is enabled so
//   turn the little button thingie on and shove the proper text into
//   the edit area
//
BOOL CDialogSecurity::OnInitDialog() 
{   
    Bool      allowTurnOff = TRUE;
    Bool      allowCancel  = TRUE;
	CButton * button;

	CDialog::OnInitDialog();

	if ( returnpref == NULL ) {
		allowTurnOff = FALSE;
	}
	CEdit * edit = (CEdit *) GetDlgItem(IDC_SECUREALERTEDIT);  
	if(edit) {
		switch(m_Type) {
	  	case SD_ENTERING_SECURE_SPACE:
			  edit->SetWindowText(szLoadString(IDS_ENTER_SECURE_0));
			  allowCancel = FALSE;
			  break;
		case SD_LEAVING_SECURE_SPACE:
			  edit->SetWindowText(szLoadString(IDS_LEAVE_SECURE_0));
			  break;
		case SD_INSECURE_POST_FROM_INSECURE_DOC:
			  edit->SetWindowText(szLoadString(IDS_NONSEC_POST_FR_NONSEC_0));
			  break;  
		case SD_INSECURE_POST_FROM_SECURE_DOC:
			  edit->SetWindowText(szLoadString(IDS_NONSEC_POST_FR_SEC_0));
			  break;  
		case SD_INSECURE_DOCS_WITHIN_SECURE_DOCS_NOT_SHOWN:
			  edit->SetWindowText(szLoadString(IDS_NONSEC_INLINES_0));
			  allowCancel = FALSE;
			  break;  
		case SD_REDIRECTION_TO_INSECURE_DOC:
			  edit->SetWindowText(szLoadString(IDS_NONSEC_REDIRECT_0)); 
			  break;  
		case SD_REDIRECTION_TO_SECURE_SITE:
			  edit->SetWindowText(szLoadString(IDS_REDIRECT_TO_SECURE)); 
			  break;  
		default:
		  edit->SetWindowText(szLoadString(IDS_NONSEC_UNKNOWN));
		} 
	}
  
	button = (CButton *) GetDlgItem(IDC_SECURESHOWAGAIN);
	if(button)
	  button->SetCheck(TRUE);  

	// can't turn off redirection warning
	if(!allowTurnOff && button)
		button->ShowWindow(SW_HIDE);


	button = (CButton *) GetDlgItem(IDCANCEL);
	if(!allowCancel)
		button->EnableWindow(FALSE);
  
	return(1);
}

void CDialogSecurity::OnOK()
{ 

	CButton * button = (CButton *) GetDlgItem(IDC_SECURESHOWAGAIN);
	if(button) {
		theApp.m_nSecurityCheck[m_Type] = button->GetCheck(); 
		if ( returnpref ) {
			if ( theApp.m_nSecurityCheck[m_Type] ) {
				*returnpref = TRUE;
			} else {
				*returnpref = FALSE;
			}
		}
	}

	CDialog::OnOK();
}


/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// CDialogPRMT dialog

CDialogPRMT::CDialogPRMT(CWnd* pParent /*=NULL*/)
    : CDialog(CDialogPRMT::IDD, pParent)
{
    m_csTitle = _T("");
    
    //{{AFX_DATA_INIT(CDialogPRMT)
    m_csAns = "";
    //}}AFX_DATA_INIT
}

void CDialogPRMT::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);
    //{{AFX_DATA_MAP(CDialogPRMT)
    DDX_Text(pDX, IDC_PROMPT_ASK, m_csAsk);
    DDX_Text(pDX, IDC_PROMPT_ANS, m_csAns);
    //}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CDialogPRMT, CDialog)
    //{{AFX_MSG_MAP(CDialogPRMT)
        // NOTE: the ClassWizard will add message map macros here
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CDialogPRMT message handlers

char * CDialogPRMT::DoModal(const char * Msg, const char * Dflt, const char *pszCaption)
{
    int status;
    if(!m_csAsk.IsEmpty()) 
        m_csAsk.Empty();

    if(!m_csAns.IsEmpty())
        m_csAns.Empty();

    m_csAsk = Msg;
    m_csAns = Dflt;
	if (pszCaption)
		m_csCaption = pszCaption;
	else
		m_csCaption.Format(szLoadString(IDS_USER_PROMPT), szLoadString(AFX_IDS_APP_TITLE));


    status = CDialog::DoModal();

    if(status == IDOK)
        return(XP_STRDUP((const char *) m_csAns));
    else    
        return(NULL);
}                        

int CDialogPRMT::OnInitDialog()
{   
    if( !m_csTitle.IsEmpty() )
        SetWindowText( (LPCSTR)m_csTitle );
    else
    	SetWindowText(m_csCaption);   
    
	CWnd *pWnd = GetDlgItem(IDC_PROMPT_ASK);
	if (pWnd)
		pWnd->SetWindowText(m_csAsk);

	CEdit *edit = (CEdit *) GetDlgItem(IDC_PROMPT_ANS);
	if (edit) {
		edit->SetWindowText(m_csAns);
		edit->SetFocus();
		edit->SetSel(0, -1);
		return(0);
	}

	return(TRUE);
}

/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// CDialogPASS dialog

CDialogPASS::CDialogPASS(CWnd* pParent /*=NULL*/)
    : CDialog(CDialogPASS::IDD, pParent)
{
    m_csTitle = _T("");
    
    //{{AFX_DATA_INIT(CDialogPASS)
    m_csAns = "";
    //}}AFX_DATA_INIT
}

void CDialogPASS::DoDataExchange(CDataExchange* pDX)
{
    CDialog::DoDataExchange(pDX);
    //{{AFX_DATA_MAP(CDialogPASS)
    DDX_Text(pDX, IDC_PROMPT_ASK, m_csAsk);
    DDX_Text(pDX, IDC_PROMPT_ANS, m_csAns);
    //}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CDialogPASS, CDialog)
    //{{AFX_MSG_MAP(CDialogPASS)
        // NOTE: the ClassWizard will add message map macros here
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CDialogPASS message handlers

char * CDialogPASS::DoModal(const char * Msg)
{
    int status;
    if(!m_csAsk.IsEmpty()) 
        m_csAsk.Empty();

    if(!m_csAns.IsEmpty())
        m_csAns.Empty();

    m_csAsk = Msg;
    status = CDialog::DoModal();

    if(status == IDOK)
        return(XP_STRDUP((const char *) m_csAns));
    else    
        return(NULL);
}
                                                             
int CDialogPASS::OnInitDialog()
{

    CDialog::OnInitDialog();

#ifndef XP_WIN32
	//win16 only
	if ( m_hWnd ) {
		BringWindowToTop();
		SetWindowPos( &wndTopMost, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
	}
#endif

    if( !m_csTitle.IsEmpty() )
        SetWindowText( (LPCSTR)m_csTitle );
    
	CEdit * edit = (CEdit *) GetDlgItem(IDC_PROMPT_ANS);

	if(edit) {
		edit->SetFocus();
		edit->SetSel(0, -1);
		return(0);
	}

	return(1);

}

                                                             
/////////////////////////////////////////////////////////////////////////////
// CDialogUPass dialog


CDialogUPass::CDialogUPass(CWnd* pParent /*=NULL*/)
  : CDialog(CDialogUPass::IDD, pParent)
{
  //{{AFX_DATA_INIT(CDialogUPass)
    // NOTE: the ClassWizard will add member initialization here
  //}}AFX_DATA_INIT
}

void CDialogUPass::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CDialogUPass)
	DDX_Text(pDX, IDC_PROMPT, m_csMessage);
	DDX_Text(pDX, IDC_EDIT1, m_csUser);
	DDX_Text(pDX, IDC_EDIT2, m_csPasswd);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CDialogUPass, CDialog)
  //{{AFX_MSG_MAP(CDialogUPass)
    // NOTE: the ClassWizard will add message map macros here
  //}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CDialogUPass message handlers

int CDialogUPass::DoModal(char * message, char ** user, char ** passwd)
{

	int status;

	if(!user || !passwd)
		return(FALSE);

	if(message)
		m_csMessage = message;
	else
		m_csMessage = szLoadString(IDS_AUTH_DEFAULT);

	if(*user)
		m_csUser   = *user;
    else
        m_csUser   = "";

#if defined(SingleSignon)
    if(*passwd)
	m_csPasswd = *passwd;
    else
#endif
    m_csPasswd = "";

	status = CDialog::DoModal();

	if(status != IDOK)
		return(FALSE);
  
	*user   = XP_STRDUP((const char *) m_csUser);
	*passwd = XP_STRDUP((const char *) m_csPasswd);

	return(TRUE);

}

int CDialogUPass::OnInitDialog()
{
    CDialog::OnInitDialog();

#ifndef XP_WIN32
	//win16 only
	if ( m_hWnd ) {
		BringWindowToTop();
		SetWindowPos( &wndTopMost, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
	}
#endif

    if( !m_csTitle.IsEmpty() )
        SetWindowText( (LPCSTR)m_csTitle );
    
	return(1);
}


/////////////////////////////////////////////////////////////////////////////
// CUnknownTypeDlg dialog


CUnknownTypeDlg::CUnknownTypeDlg(CWnd* pParent /*=NULL*/, char * filetype,CHelperApp * app)
  : CDialog(CUnknownTypeDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CUnknownTypeDlg)
	m_FileType = filetype;
	m_app = app;
	//}}AFX_DATA_INIT
}

void CUnknownTypeDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CUnknownTypeDlg)
	DDX_Text(pDX, IDC_FILETYPE, m_FileType);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CUnknownTypeDlg, CDialog)
	//{{AFX_MSG_MAP(CUnknownTypeDlg)
	ON_BN_CLICKED(ID_CONFIGUREVIEWER, OnConfigureviewer)
	ON_BN_CLICKED(ID_SAVETODISK, OnSavetodisk)
	ON_BN_CLICKED(IDC_MORE_INFO, OnMoreInfo)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CUnknownTypeDlg message handlers

void CUnknownTypeDlg::OnConfigureviewer()
{
	CConfigureViewerSmall dlg(this, (const char *)m_FileType, m_app);

	if (dlg.DoModal() == IDOK) {
		//	Ensure the app points to what the user actually typed in.
		m_app->csCmd = dlg.m_AppName;
		m_app->bChanged = TRUE;
		m_app->how_handle = HANDLE_EXTERNAL;
		EndDialog(HANDLE_EXTERNAL);
	}
}

void CUnknownTypeDlg::OnSavetodisk()
{
    EndDialog(HANDLE_SAVE); 
}

void CUnknownTypeDlg::OnCancel()
{
    CDialog::OnCancel();
}

void CUnknownTypeDlg::OnMoreInfo()
{
    EndDialog(HANDLE_MOREINFO); 
}
/////////////////////////////////////////////////////////////////////////////
// CNewMimeType dialog


CNewMimeType::CNewMimeType(CWnd* pParent /*=NULL*/)
  : CDialog(CNewMimeType::IDD, pParent)
{
	//{{AFX_DATA_INIT(CNewMimeType)
	m_MimeSubtype = "";
	m_MimeType = "";
	//}}AFX_DATA_INIT
}

void CNewMimeType::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CNewMimeType)
	DDX_Text(pDX, IDC_MIMESUBTYPE_EDIT, m_MimeSubtype);
	DDX_Text(pDX, IDC_MIMETYPE_EDIT, m_MimeType);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CNewMimeType, CDialog)
  //{{AFX_MSG_MAP(CNewMimeType)
    // NOTE: the ClassWizard will add message map macros here
  //}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CNewMimeType message handlers
/////////////////////////////////////////////////////////////////////////////
// CConfigureViewerSmall dialog


CConfigureViewerSmall::CConfigureViewerSmall(CWnd* pParent /*=NULL*/, const char * filetype,  CHelperApp * app)
  : CDialog(CConfigureViewerSmall::IDD, pParent)
{
	//{{AFX_DATA_INIT(CConfigureViewerSmall)
	m_MimeType = filetype;
	m_AppName = _T("");
	//}}AFX_DATA_INIT

	m_app = app;
}

void CConfigureViewerSmall::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CConfigureViewerSmall)
	DDX_Text(pDX, IDC_MIMETYPE_EDIT, m_MimeType);
	DDX_Text(pDX, IDC_HELPER_PATH, m_AppName);
	//}}AFX_DATA_MAP
}

BEGIN_MESSAGE_MAP(CConfigureViewerSmall, CDialog)
  //{{AFX_MSG_MAP(CConfigureViewerSmall)
  ON_BN_CLICKED(IDC_HELPER_BROWSE, OnHelperBrowse)
  //}}AFX_MSG_MAP
END_MESSAGE_MAP()


/////////////////////////////////////////////////////////////////////////////
// CConfigureViewerSmall message handlers

void CConfigureViewerSmall::OnHelperBrowse()
{
	char * name;

	name = wfe_GetExistingFileName(m_hWnd,
	                      szLoadString(IDS_SELECT_APPROPRIATE_VIEWER), EXE, TRUE);

	// user selected a file
	if(name) {
		CStatic   * pIcon = (CStatic *)GetDlgItem(IDC_HELPER_STATIC4);
		HICON hIcon;

		//	NT can't handle paths with spaces
		//	We don't deal with it here, so it's up to the user.
		//	If they quote it in their registry, then we preserve their string.

		//	Force redraw of the name they enetered.
		CEdit *pEdit = (CEdit *)GetDlgItem(IDC_HELPER_PATH);
		if(pEdit)	{
			pEdit->SetWindowText(name);
		}

		hIcon = ExtractIcon(theApp.m_hInstance,(const char *)m_AppName,0);
		pIcon->SetIcon(hIcon);
		XP_FREE(name);    
	} 
}


/****************************************************************************
*
*	Class: CDefaultBrowserDlg
*
*	DESCRIPTION:
*		This provides a dialog for notifying the user that another application
*		has made themselves the "default browser" by changing our registry
*		entries.
*
****************************************************************************/

BEGIN_MESSAGE_MAP(CDefaultBrowserDlg, CDefaultBrowserDlgBase)
	//{{AFX_MSG_MAP(CDefaultBrowserDlg)
	ON_BN_CLICKED(ID_NO, OnNo)
	ON_WM_PAINT()
    ON_BN_CLICKED(IDC_SHOW_DESKTOP_PREFS,OnDetails)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/****************************************************************************
*
*	CDefaultBrowserDlg::CDefaultBrowserDlg
*
*	PARAMETERS:
*		pParent	- pointer to parent window (= NULL)
*
*	RETURNS:
*		N/A
*
*	DESCRIPTION:
*		Standard dialog constructor.
*
****************************************************************************/

CDefaultBrowserDlg::CDefaultBrowserDlg(CWnd* pParent /*=NULL*/, nsIDefaultBrowser* pDefaultBrowser /*=NULL*/)
	: CDefaultBrowserDlgBase(CDefaultBrowserDlg::IDD, pParent)
{
	//{{AFX_DATA_INIT(CDefaultBrowserDlg)
	m_bPerformCheck = TRUE; // If false, we wouldn't be here, now would we?
    m_pDefaultBrowser = pDefaultBrowser;
    if ( m_pDefaultBrowser ) {
        m_pDefaultBrowser->AddRef();
    }
	//}}AFX_DATA_INIT
	
} // END OF	FUNCTION CDefaultBrowserDlg::CDefaultBrowserDlg()

CDefaultBrowserDlg::CDefaultBrowserDlg(nsIDefaultBrowser* pDefaultBrowser)
    : CDefaultBrowserDlgBase(CDefaultBrowserDlg::IDD, NULL)
{
    m_bPerformCheck = TRUE; // If false, we wouldn't be here, now would we?
    m_pDefaultBrowser = pDefaultBrowser;
    if ( m_pDefaultBrowser ) {
        m_pDefaultBrowser->AddRef();
    }
}

CDefaultBrowserDlg::~CDefaultBrowserDlg() {
    if ( m_pDefaultBrowser ) {
        m_pDefaultBrowser->Release();
    }
}

/****************************************************************************
*
*	CDefaultBrowserDlg::DoDataExchange
*
*	PARAMETERS:
*		pDX	- the usual CDataExchange pointer
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Standard dialog data exchange function.
*
****************************************************************************/

void CDefaultBrowserDlg::DoDataExchange(CDataExchange* pDX)
{
	CDefaultBrowserDlgBase::DoDataExchange(pDX);
	
	//{{AFX_DATA_MAP(CDefaultBrowserDlg)
	DDX_Check(pDX, IDC_IGNORE, m_bPerformCheck);
	DDX_Control(pDX, IDC_LIST1, m_Listbox);
	//}}AFX_DATA_MAP
	
} // END OF	FUNCTION CDefaultBrowserDlg::DoDataExchange()

/****************************************************************************
*
*	CDefaultBrowserDlg::OnNo
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		This handles the 'No' button. We treat it just like OnOK, except
*		for the return value.
*
****************************************************************************/

void CDefaultBrowserDlg::OnNo() 
{
	if (UpdateData(TRUE))
	{
		EndDialog(ID_NO);

        // Update "perform check" preference per check-box setting.
        if ( !m_bPerformCheck ) {
            PREF_SetBoolPref("browser.wfe.ignore_def_check",TRUE);
        }
    
	}  /* end if */
	
} // END OF	FUNCTION CDefaultBrowserDlg::OnNo()

/****************************************************************************
*
*	CDefaultBrowserDlg::OnDetails
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		This handles the 'Details...' button. We treat it just like OnOK, except
*		for the return value.
*
****************************************************************************/

void CDefaultBrowserDlg::OnDetails() 
{
	if (UpdateData(TRUE))
	{
		EndDialog(IDC_SHOW_DESKTOP_PREFS);

	}  /* end if */
	
} // END OF	FUNCTION CDefaultBrowserDlg::OnDetails()

/****************************************************************************
*
*	CDefaultBrowserDlg::OnPaint
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		We use this WM_PAINT handler to draw the standard Windows question
*		icon on the dialog, so it looks more like a message box.
*
****************************************************************************/

void CDefaultBrowserDlg::OnPaint() 
{
	CPaintDC dc(this);
	
	// Draw the Windows question icon in the placeholder
	CWnd * pwndIcon = GetDlgItem(IDC_WARNING_ICON);
	ASSERT(pwndIcon != NULL);
	if (pwndIcon != NULL)
	{
		CRect rc;
		pwndIcon->GetWindowRect(rc);
		ScreenToClient(rc);
		dc.DrawIcon(rc.TopLeft(), ::LoadIcon(NULL, IDI_EXCLAMATION));
	}  /* end if */
	
	// Do not call CDefaultBrowserDlgBase::OnPaint() for painting messages
	
} // END OF	FUNCTION CDefaultBrowserDlg::OnPaint()

BOOL CDefaultBrowserDlg::OnInitDialog()
{
	BOOL res = CDialog::OnInitDialog();

	// Fill in the dialog's list box
	CPtrArray* lostList = theApp.m_OwnedAndLostList.GetLostList();
	
	// Add to list
	int size = lostList->GetSize();
	for (int i = 0; i < size; i++)
	{
		COwnedLostItem* theItem = (COwnedLostItem*)((*lostList)[i]);

		if (!theItem->m_bIgnored)
		{
			theItem->FetchPrettyName();
			if (theItem->m_csPrettyName != "")
			{
				int index = m_Listbox.AddString(theItem->m_csPrettyName);
				m_Listbox.SetItemDataPtr(index, theItem);
			}
		}

		m_Listbox.SetSel(-1);
	}

	return res;
}

static BOOL IsListItemSelected(int* selArray, int count, int i)
{
	for (int x = 0; x < count; x++)
	{
		int item = selArray[x];
		if (i == item)
			return TRUE;
	}
	return FALSE;
}

void CDefaultBrowserDlg::OnOK()
{
    // Dismiss the dialog.
    CDefaultBrowserDlgBase::OnOK();

    // Update "perform check" preference per check-box setting.
    if ( !m_bPerformCheck ) {
        PREF_SetBoolPref("browser.wfe.ignore_def_check",TRUE);
    }

    if ( m_pDefaultBrowser ) {
        // synchronize registry with these preferences.
        nsresult result = m_pDefaultBrowser->HandlePerPreferences();
        ASSERT( result == NS_OK );
    }

#if 0 // Old code.
	// Let's do it. Selected items become owned.
	// Unselected items become ignored (if the checkbox is checked)
	CDefaultBrowserDlgBase::OnOK();

	int count = m_Listbox.GetCount();
	int* selArray = new int[count];

	int nSelectedArraySize = m_Listbox.GetSelItems(count, selArray);
		
	for (int i = 0; i < count; i++)
	{
		COwnedLostItem* theItem = (COwnedLostItem*)(m_Listbox.GetItemDataPtr(i));
		
		if (IsListItemSelected(selArray, count, i))
		{
			// Remove it from the lost list.
			theApp.m_OwnedAndLostList.RemoveFromLostList(theItem->m_csMimeType);
			
			// Add it to the owned list.
			theApp.m_OwnedAndLostList.GetOwnedList()->Add(theItem);

			// Modify the HelperApp information (write to the registry)
			// Fun fun fun!
			theItem->GiveControlToNetscape();
		}
		else if (m_bIgnore)
		{
			// User wants to ignore this item. Add it to the ignore list.
			theItem->SetIgnored(TRUE);
		}
	}	
#endif
}

/* CCheckConfirmDialog: a generic "confirm" dialog including a checkbox.
   It's used by XP.
 */

BEGIN_MESSAGE_MAP(CCheckConfirmDialog, CSelfAdjustingDialog)
END_MESSAGE_MAP()

CCheckConfirmDialog::CCheckConfirmDialog (CWnd *pParent,
	const char *pMessage, const char *pCheckMessage,
	const char *pOKMessage, const char *pCancelMessage,
	BOOL checked) :

	CSelfAdjustingDialog(CCheckConfirmDialog::IDD, pParent),
	mMessage(pMessage), mCheckMessage(pCheckMessage),
	mOKMessage(pOKMessage), mCancelMessage(pCancelMessage)
{
	mCheckState = checked ? 1 : 0;
}


BOOL CCheckConfirmDialog::OnInitDialog()
{
	CSelfAdjustingDialog::OnInitDialog();

	CStatic *messageItem = (CStatic *) GetDlgItem(IDC_STATIC1);
	CButton *checkItem = (CButton *) GetDlgItem(IDC_CHECK1),
			*okButton = (CButton *) GetDlgItem(IDOK),
			*cancelButton = (CButton *) GetDlgItem(IDCANCEL);
	POINT	windRectDiff,
			border;

	// set subwindows' text
	messageItem->SetWindowText((const char *) mMessage);
	checkItem->SetWindowText((const char *) mCheckMessage);
	if (!mOKMessage.IsEmpty())
		okButton->SetWindowText((const char *) mOKMessage);
	if (!mCancelMessage.IsEmpty())
		cancelButton->SetWindowText((const char *) mCancelMessage);
	checkItem->SetCheck(mCheckState);

	// adjust sizes to match text
	CheckOverallSize(&border, FALSE);
	ResizeItemToFitText(messageItem, (const char *) mMessage, &windRectDiff);
	AdjustForItemSize(messageItem, &windRectDiff);
	ResizeItemToFitText(checkItem, (const char *) mCheckMessage, &windRectDiff);
	AdjustForItemSize(checkItem, &windRectDiff);
	AdjustButtons(okButton, cancelButton, border.x);
	CheckOverallSize(&border, TRUE);

	return TRUE;
}

BOOL CCheckConfirmDialog::DoModal(XP_Bool *checkboxSet)
{
	BOOL	rtnval = CSelfAdjustingDialog::DoModal() == IDOK;
	*checkboxSet = mCheckState == 1;
	return rtnval;
}

void CCheckConfirmDialog::OnOK()
{
	CButton	*checkItem = (CButton *) GetDlgItem(IDC_CHECK1);
	mCheckState = checkItem->GetCheck() == 1;
	CSelfAdjustingDialog::OnOK();
}

/* "cancel" really means "no," so fetch the value of the checkbox */
void CCheckConfirmDialog::OnCancel()
{
	CButton	*checkItem = (CButton *) GetDlgItem(IDC_CHECK1);
	mCheckState = checkItem->GetCheck() == 1;
	CSelfAdjustingDialog::OnCancel();
}

/* if (!adjust), calculate the border around our subwindows.
   if (adjust), resize to have the given border. */
void CCheckConfirmDialog::CheckOverallSize(LPPOINT diff, BOOL adjust) {

	CStatic *messageItem = (CStatic *) GetDlgItem(IDC_STATIC1);
	CButton *checkItem = (CButton *) GetDlgItem(IDC_CHECK1),
			*okButton = (CButton *) GetDlgItem(IDOK),
			*cancelButton = (CButton *) GetDlgItem(IDCANCEL);
	RECT	wRect,
			parentRect;
	POINT	border;
	HWND	parent = m_pParentWnd ? m_pParentWnd->GetSafeHwnd() : NULL;

	// calculate current minimum border. assumes buttons fix the bottom margin and
	// other items fix the right margin
	messageItem->GetWindowRect(&wRect);
	border.x = wRect.right;
	checkItem->GetWindowRect(&wRect);
	if (wRect.right > border.x)
		border.x = wRect.right;
	cancelButton->GetWindowRect(&wRect);
	border.y = wRect.bottom;
	if (wRect.right > border.x)
		border.x = wRect.right;
	GetWindowRect(&wRect);

	if (adjust) {
		// since moving the window seems to make the system no longer center it,
		// we have to do it ourselves
		if (m_pParentWnd)
			m_pParentWnd->GetWindowRect(&parentRect);
		else
			GetDesktopWindow()->GetWindowRect(&parentRect);

		// adjust dialog window size to keep the same borders between it and its subwindows
		border.x = diff->x - (wRect.right - border.x);
		border.y = diff->y - (wRect.bottom - border.y);
		wRect.right += border.x;
		wRect.bottom += border.y;

		// center it in its parent
		border.x = ((parentRect.right + parentRect.left) - (wRect.right + wRect.left)) / 2;
		border.y = ((parentRect.bottom + parentRect.top) - (wRect.bottom + wRect.top)) / 2;
		wRect.left += border.x;
		wRect.right += border.x;
		wRect.top += border.y;
		wRect.bottom += border.y;
		MoveWindow(&wRect, TRUE);
	} else {
		diff->x = wRect.right - border.x;
		diff->y = wRect.bottom - border.y;
	}
}

/* special adjustment for the buttons.  we won't make them smaller, and we'll keep
   them centered.  we also assume they're in a row at the bottom, with OK on the left,
   and the same size. */
void CCheckConfirmDialog::AdjustButtons(CWnd *okButton, CWnd *cancelButton,
										LONG expectedMargin) {

	RECT	okRect,
			cancelRect,
			newOKRect,
			newCancelRect,
			dialogRect;
	POINT	diff,
			tempDiff;
	LONG	separation,
			width;

	// assume if OK has no text change, than cancel doesn't either. no adjustment, then.
	if (mOKMessage.IsEmpty())
		return;

	okButton->GetWindowRect(&okRect);
	cancelButton->GetWindowRect(&cancelRect);
	GetWindowRect(&dialogRect);

	// calculate appropriate size
	RectForText(okButton, (const char *) mOKMessage, &newOKRect, &diff);
	RectForText(cancelButton, (const char *) mCancelMessage, &newCancelRect, &tempDiff);
	if (newOKRect.right - newOKRect.left > newCancelRect.right - newCancelRect.left)
		width = newOKRect.right - newOKRect.left;
	else {
		width = newCancelRect.right - newCancelRect.left;
		diff.x = tempDiff.x;
	}

	// don't shrink the buttons; only expand them
	if (diff.x > 0) {
		separation = cancelRect.left - okRect.right;
		okRect.left -= diff.x;
		cancelRect.right += diff.x;
		if (okRect.left - dialogRect.left < expectedMargin) {
			okRect.left = dialogRect.left + expectedMargin;
			okRect.right = okRect.left + width;
		}
		if (cancelRect.left < okRect.right + separation) {
			cancelRect.left = okRect.right + separation;
			cancelRect.right = cancelRect.left + width;
		}
		::MapWindowPoints(HWND_DESKTOP, GetSafeHwnd(), (LPPOINT) &okRect, 2);
		::MapWindowPoints(HWND_DESKTOP, GetSafeHwnd(), (LPPOINT) &cancelRect, 2);
		okButton->MoveWindow(&okRect, TRUE);
		cancelButton->MoveWindow(&cancelRect, TRUE);
	}
}

/* CUserSelectionDialog: presents a scrolling list of items with an initial
   selection, allowing the user to specify a selection
*/
BEGIN_MESSAGE_MAP(CUserSelectionDialog, CDialog)
END_MESSAGE_MAP()

CUserSelectionDialog::CUserSelectionDialog(CWnd *pParent, const char *pMessage,
        const char **pUserList, int16 nUserListCount) :

	CDialog(CUserSelectionDialog::IDD, pParent),
	mMessage(pMessage) {

	int16	ctr;

	mSelection = -1;
	// copy pUserList
	mList = (char **) XP_ALLOC(nUserListCount*sizeof(char *));
	mListCount = nUserListCount;
	if (mList) {
		for (ctr = 0; ctr < nUserListCount; ctr++) {
			int len = 1 + XP_STRLEN(pUserList[ctr]);
			char *newStr = (char *) XP_ALLOC(len*sizeof(char));
			if (newStr) {
				XP_STRCPY(newStr, pUserList[ctr]);
				mList[ctr] = newStr;
			} else {
				mListCount = ctr;
				break;
			}
		}
		if (mListCount == 0) {
			XP_FREE(mList);
			mList = 0;
		}
	}
}

CUserSelectionDialog::~CUserSelectionDialog() {

	int16 ctr;

	if (mList) {
		for (ctr = 0; ctr < mListCount; ctr++)
			XP_FREE(mList[ctr]);
		XP_FREE(mList);
	}
}

BOOL CUserSelectionDialog::DoModal(int16 *nSelection)
{
	BOOL	rtnval = CDialog::DoModal() == IDOK;
	*nSelection = mSelection;
	return rtnval;
}

void CUserSelectionDialog::OnOK()
{
	CListBox *listItem = (CListBox *) GetDlgItem(IDC_LIST1);
	int selection = listItem->GetCurSel();
	mSelection = selection == LB_ERR ? -1 : (int16) selection;
	CDialog::OnOK();
}

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

	CStatic *messageItem = (CStatic *) GetDlgItem(IDC_STATIC1);
	CListBox *listItem = (CListBox *) GetDlgItem(IDC_LIST1);
	int16 ctr;

	// set subwindows' text
	messageItem->SetWindowText((const char *) mMessage);
	if (mList)
		for (ctr = 0; ctr < mListCount; ctr++) {
			int err;
			err = listItem->AddString(mList[ctr]);
			if (err == LB_ERR || err == LB_ERRSPACE)
				break;
		}

	return TRUE;
}

/* CSelfAdjustingDialog: some base code for a dialog that can adjust its size
   and its subwindows
 */

BEGIN_MESSAGE_MAP(CSelfAdjustingDialog, CDialog)
END_MESSAGE_MAP()

CSelfAdjustingDialog::CSelfAdjustingDialog(UINT nIDTemplate, CWnd* pParent) :
	CDialog(nIDTemplate, pParent) {
}

/* calculate appropriate window rect for its text. assumes average character width.
   returns actual (desktop-relative) window rect, adjusted for appropriate size,
   (without actually changing the window's rect). */
void CSelfAdjustingDialog::RectForText(CWnd *window, const char *text,
									   LPRECT wrect, LPPOINT diff) {

	int			height,
				width;
	const char	*mark;
	char		thisChar;
	BOOL		lastWasCR;
	CDC			*dc = window->GetDC();
	CSize		basicExtent = dc->GetTextExtent("W",1),
				extent;

	window->GetWindowRect(wrect);

	// calculate width and height of text.
	height = 0;
	width = 0;
	mark = text;
	lastWasCR = FALSE;
	while (1) {
		thisChar = *text;
		if (lastWasCR && thisChar == '\n') {
			lastWasCR = FALSE;
			mark = ++text;
			continue;
		}
		if (thisChar == '\r' || thisChar == '\n' || thisChar == '\0') {
			if (text-mark == 0) // it's a zero-length line
				height += basicExtent.cy;
			else {
				extent = dc->GetTextExtent(mark, text-mark);
				if (width < extent.cx)
					width = extent.cx;
				height += extent.cy;
			}
			mark = text+1;
			if (*text == '\0')
				break;
		}
		lastWasCR = *text++ == '\r';
	}
	if (width == 0)
		width = basicExtent.cx;
	if (height == 0)
		height = basicExtent.cy;
	diff->x = width - (wrect->right - wrect->left);
	diff->y = height - (wrect->bottom - wrect->top);
	wrect->right = wrect->left + width;
	wrect->bottom = wrect->top + height;
}

/* resize subwindow to fit its text. assumes average character width */
void CSelfAdjustingDialog::ResizeItemToFitText(CWnd *window, const char *text, LPPOINT diff) {

	RECT	windRect;

	RectForText(window, text, &windRect, diff);
	::MapWindowPoints(HWND_DESKTOP, GetSafeHwnd(), (LPPOINT) &windRect, 2);
	window->MoveWindow(&windRect, TRUE);
}

/* adjust window size for a change in an item size, and then adjust positions of
   affected subwindows */
void CCheckConfirmDialog::AdjustForItemSize(CWnd *afterWind, LPPOINT diff) {

	CStatic *messageItem = (CStatic *) GetDlgItem(IDC_STATIC1);
	CButton *checkItem = (CButton *) GetDlgItem(IDC_CHECK1),
			*okButton = (CButton *) GetDlgItem(IDOK),
			*cancelButton = (CButton *) GetDlgItem(IDCANCEL);
	HWND	parent = m_pParentWnd ? m_pParentWnd->GetSafeHwnd() : NULL;

	// adjust positions of trailing subwindows
	BumpItemIfAfter(messageItem, afterWind, diff);
	BumpItemIfAfter(checkItem, afterWind, diff);
	BumpItemIfAfter(okButton, afterWind, diff);
	BumpItemIfAfter(cancelButton, afterWind, diff);
}

/* adjust subwindows affected by a change in size of another subwindow */
void CSelfAdjustingDialog::BumpItemIfAfter(CWnd *item, CWnd *afterWind, LPPOINT diff) {

	RECT	afterRect,
			itemRect;

	item->GetWindowRect(&itemRect);
	afterWind->GetWindowRect(&afterRect);
	if (	diff->x != 0 &&
			itemRect.left > afterRect.left &&
			itemRect.top < afterRect.bottom && itemRect.bottom >= afterRect.top) {
		::MapWindowPoints(HWND_DESKTOP, GetSafeHwnd(), (LPPOINT) &itemRect, 2);
		itemRect.left += diff->x;
		itemRect.right += diff->x;
		item->MoveWindow(&itemRect, TRUE);
	}
	else if (	diff->y != 0 &&
				itemRect.top > afterRect.top &&
				itemRect.left < afterRect.right && itemRect.right >= afterRect.left) {
		::MapWindowPoints(HWND_DESKTOP, GetSafeHwnd(), (LPPOINT) &itemRect, 2);
		itemRect.top += diff->y;
		itemRect.bottom += diff->y;
		item->MoveWindow(&itemRect, TRUE);
	}
}