Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-31 14:15:30 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
a1cde307de
gecko-dev/cmd/winfe/dialog.cpp

1731 lines
46 KiB
C++
Executable File
Raw Blame History

/* -*- 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);
}
}
Reference in New Issue View Git Blame Copy Permalink