home *** CD-ROM | disk | FTP | other *** search
/ Tools / WinSN5.0Ver.iso / NETSCAP.50 / WIN1998.ZIP / ns / cmd / winfe / dialog.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-08  |  23.1 KB  |  917 lines
  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  2.  *
  3.  * The contents of this file are subject to the Netscape Public License
  4.  * Version 1.0 (the "NPL"); you may not use this file except in
  5.  * compliance with the NPL.  You may obtain a copy of the NPL at
  6.  * http://www.mozilla.org/NPL/
  7.  *
  8.  * Software distributed under the NPL is distributed on an "AS IS" basis,
  9.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
  10.  * for the specific language governing rights and limitations under the
  11.  * NPL.
  12.  *
  13.  * The Initial Developer of this code under the NPL is Netscape
  14.  * Communications Corporation.  Portions created by Netscape are
  15.  * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
  16.  * Reserved.
  17.  */
  18.  
  19. #include "stdafx.h"
  20.  
  21. #include "dialog.h"
  22.  
  23. #include "helper.h"
  24. #include "nethelp.h"
  25.  
  26. #ifdef _DEBUG
  27. #undef THIS_FILE
  28. static char BASED_CODE THIS_FILE[] = __FILE__;
  29. #endif
  30.  
  31. extern "C" void sample_exit_routine(URL_Struct *URL_s,int status,MWContext *window_id);
  32.  
  33. static CString url_string = "";
  34. // Retain radio button setting across dialog calls
  35. // 0 = Load URL into Browser, 1 = Editor
  36. static int browse_or_edit = 0;
  37. /////////////////////////////////////////////////////////////////////////////
  38. // CDialogURL dialog
  39.  
  40.  
  41. CDialogURL::CDialogURL(CWnd* pParent, MWContext * context)
  42.     : CDialog(CDialogURL::IDD, pParent)
  43. {
  44.     //{{AFX_DATA_INIT(CDialogURL)
  45.     m_csURL = url_string;
  46.     //}}AFX_DATA_INIT
  47.     ASSERT(context);
  48.     m_Context = context;
  49. }
  50.  
  51.  
  52. BOOL CDialogURL::OnInitDialog() 
  53. {
  54.     CDialog::OnInitDialog();
  55.  
  56.     CEdit * pBox = (CEdit *) GetDlgItem(IDC_URL); 
  57.  
  58.     if(pBox) {
  59.         pBox->SetWindowText((const char *) url_string);
  60.         pBox->SetFocus();
  61.         pBox->SetSel(0, -1);
  62. #ifdef EDITOR
  63.         // Communicator version has radio buttons to select 
  64.         //  loading URL into a browser or editor
  65.         if ( EDT_IS_EDITOR(m_Context) ){
  66.             ((CButton *)GetDlgItem(IDC_OPEN_URL_EDITOR))->SetCheck(1);
  67.         } else {
  68.             ((CButton *)GetDlgItem(IDC_OPEN_URL_BROWSER))->SetCheck(1);
  69.         }
  70. #endif // EDITOR
  71.         return(0);
  72.     } 
  73.     return(1);
  74. }
  75.  
  76. BEGIN_MESSAGE_MAP(CDialogURL, CDialog)
  77.     //{{AFX_MSG_MAP(CDialogURL)
  78.     ON_BN_CLICKED(IDC_BROWSE_FILE, OnBrowseForFile)
  79.     ON_COMMAND(ID_HELP, OnHelp)
  80.     //}}AFX_MSG_MAP
  81. END_MESSAGE_MAP()
  82.  
  83. /////////////////////////////////////////////////////////////////////////////
  84. // CDialogURL message handlers
  85. /////////////////////////////////////////////////////////////////////////////
  86.  
  87. void CDialogURL::OnBrowseForFile()
  88. {
  89.     int type = HTM;
  90. #ifdef EDITOR
  91.     // Restrict to only *.HTML and allow *.SHTML if loading in Composer
  92.     if( ((CButton *)GetDlgItem(IDC_OPEN_URL_EDITOR))->GetCheck() ){
  93.         type = HTM_ONLY;
  94.     }
  95. #endif
  96.     char * pName = wfe_GetExistingFileName( this->m_hWnd, szLoadString(IDS_OPEN), type, TRUE, NULL);
  97.     if( pName ){
  98.         GetDlgItem(IDC_URL)->SetWindowText(pName);
  99.         XP_FREE(pName);
  100.         // Set focus to Open button so Enter can be used 
  101.         // immediately after choosing file
  102.         GotoDlgCtrl(GetDlgItem(IDOK));
  103.     }
  104. }
  105.  
  106. void CDialogURL::OnHelp()
  107. {
  108.  
  109.     NetHelp( HELP_OPEN_PAGE );
  110. }
  111.  
  112. void CDialogURL::OnOK()
  113. {
  114.  
  115.     CEdit * pBox = (CEdit *) GetDlgItem(IDC_URL); 
  116.  
  117.     if(pBox) {
  118.         pBox->GetWindowText(url_string);
  119.     }
  120.  
  121.     CDialog::OnOK();
  122. #ifdef XP_WIN32
  123.     url_string.TrimLeft();
  124.     url_string.TrimRight();
  125. #endif
  126.  
  127.     // this was typed in so no referrer -> OK to do an OnNormalLoad
  128.     if(!url_string.IsEmpty()) {
  129.  
  130. #ifdef EDITOR
  131.         BOOL bEdit = ((CButton *)GetDlgItem(IDC_OPEN_URL_EDITOR))->GetCheck() != 0;
  132.  
  133.         if (bEdit || EDT_IS_EDITOR(m_Context)) {
  134.             FE_LoadUrl((char*)LPCSTR(url_string), bEdit);
  135.         } else
  136. #endif
  137.             // Load the URL into the same window only if called from an existing browser
  138.             ABSTRACTCX(m_Context)->NormalGetUrl(url_string);
  139.     }
  140.  
  141. }
  142.  
  143.  
  144. /////////////////////////////////////////////////////////////////////////////
  145. /////////////////////////////////////////////////////////////////////////////
  146. /////////////////////////////////////////////////////////////////////////////
  147. /////////////////////////////////////////////////////////////////////////////
  148. /////////////////////////////////////////////////////////////////////////////
  149. // CDialogLicense dialog
  150.  
  151. CDialogLicense::CDialogLicense(CWnd* pParent /*=NULL*/)
  152.     : CDialog(CDialogLicense::IDD, pParent)
  153. {
  154. }
  155.  
  156. BEGIN_MESSAGE_MAP(CDialogLicense, CDialog)
  157. END_MESSAGE_MAP()
  158.  
  159. int CDialogLicense::DoModal()
  160. {
  161.     int status;
  162.     
  163.     status = CDialog::DoModal();
  164.  
  165.     if(status == IDOK)
  166.         return(TRUE);
  167.     else
  168.         return(FALSE);
  169.  
  170. }
  171.  
  172. BOOL CDialogLicense::OnInitDialog() 
  173. {
  174.     CDialog::OnInitDialog();
  175.  
  176.     CEdit * edit = (CEdit *) GetDlgItem(IDC_EDIT1);  
  177.     if(edit) {
  178.         LPSTR    lpszLicenseText = wfe_LoadResourceString("license");
  179.  
  180.         if (lpszLicenseText) {
  181.             edit->SetWindowText(lpszLicenseText);
  182.             CDC * pdc = GetDC();
  183.             LOGFONT lf;            // Instead of using ANSI_VAR_FONT for i18n
  184.             XP_MEMSET(&lf,0,sizeof(LOGFONT));
  185.             lf.lfPitchAndFamily = FF_MODERN | FIXED_PITCH;
  186.             lf.lfCharSet = DEFAULT_CHARSET;
  187.             strcpy(lf.lfFaceName, szLoadString(IDS_FONT_FIXNAME));
  188.                lf.lfHeight = -MulDiv(10,pdc->GetDeviceCaps(LOGPIXELSY), 72);
  189.             lf.lfQuality = PROOF_QUALITY;    
  190.             m_cfTextFont.CreateFontIndirect ( &lf );
  191.             edit->SetFont( &m_cfTextFont );
  192.             ReleaseDC(pdc);
  193.             XP_FREE(lpszLicenseText);
  194.         }
  195.     }
  196.  
  197.     return(1);
  198. }
  199.  
  200.  
  201. /////////////////////////////////////////////////////////////////////////////
  202. /////////////////////////////////////////////////////////////////////////////
  203. /////////////////////////////////////////////////////////////////////////////
  204. /////////////////////////////////////////////////////////////////////////////
  205. /////////////////////////////////////////////////////////////////////////////
  206. // CDialogSecurity dialog
  207.  
  208. CDialogSecurity::CDialogSecurity(int myType, XP_Bool *returnPref, CWnd* pParent /*=NULL*/)
  209.     : CDialog(CDialogSecurity::IDD, pParent)
  210. {   
  211.     if((myType < 0) || (myType > MAX_SECURITY_CHECKS - 1))
  212.         myType = 0;
  213.  
  214.     m_Type = myType;
  215.  
  216.     returnpref = returnPref;
  217. }
  218.  
  219. BEGIN_MESSAGE_MAP(CDialogSecurity, CDialog)
  220. END_MESSAGE_MAP()
  221.  
  222. int CDialogSecurity::DoModal()
  223. {
  224.     int status;
  225.     
  226.     status = CDialog::DoModal();
  227.  
  228.     if(status == IDOK)
  229.         return(TRUE);
  230.     else
  231.         return(FALSE);
  232.  
  233. }
  234.  
  235. //
  236. // If we've gotten here then obviously the dialog is enabled so
  237. //   turn the little button thingie on and shove the proper text into
  238. //   the edit area
  239. //
  240. BOOL CDialogSecurity::OnInitDialog() 
  241. {   
  242.     Bool      allowTurnOff = TRUE;
  243.     Bool      allowCancel  = TRUE;
  244.     CButton * button;
  245.  
  246.     CDialog::OnInitDialog();
  247.  
  248.     if ( returnpref == NULL ) {
  249.         allowTurnOff = FALSE;
  250.     }
  251.     CEdit * edit = (CEdit *) GetDlgItem(IDC_SECUREALERTEDIT);  
  252.     if(edit) {
  253.         switch(m_Type) {
  254.           case SD_ENTERING_SECURE_SPACE:
  255.               edit->SetWindowText(szLoadString(IDS_ENTER_SECURE_0));
  256.               allowCancel = FALSE;
  257.               break;
  258.         case SD_LEAVING_SECURE_SPACE:
  259.               edit->SetWindowText(szLoadString(IDS_LEAVE_SECURE_0));
  260.               break;
  261.         case SD_INSECURE_POST_FROM_INSECURE_DOC:
  262.               edit->SetWindowText(szLoadString(IDS_NONSEC_POST_FR_NONSEC_0));
  263.               break;  
  264.         case SD_INSECURE_POST_FROM_SECURE_DOC:
  265.               edit->SetWindowText(szLoadString(IDS_NONSEC_POST_FR_SEC_0));
  266.               break;  
  267.         case SD_INSECURE_DOCS_WITHIN_SECURE_DOCS_NOT_SHOWN:
  268.               edit->SetWindowText(szLoadString(IDS_NONSEC_INLINES_0));
  269.               allowCancel = FALSE;
  270.               break;  
  271.         case SD_REDIRECTION_TO_INSECURE_DOC:
  272.               edit->SetWindowText(szLoadString(IDS_NONSEC_REDIRECT_0)); 
  273.               break;  
  274.         case SD_REDIRECTION_TO_SECURE_SITE:
  275.               edit->SetWindowText(szLoadString(IDS_REDIRECT_TO_SECURE)); 
  276.               break;  
  277.         default:
  278.           edit->SetWindowText(szLoadString(IDS_NONSEC_UNKNOWN));
  279.         } 
  280.     }
  281.   
  282.     button = (CButton *) GetDlgItem(IDC_SECURESHOWAGAIN);
  283.     if(button)
  284.       button->SetCheck(TRUE);  
  285.  
  286.     // can't turn off redirection warning
  287.     if(!allowTurnOff && button)
  288.         button->ShowWindow(SW_HIDE);
  289.  
  290.  
  291.     button = (CButton *) GetDlgItem(IDCANCEL);
  292.     if(!allowCancel)
  293.         button->EnableWindow(FALSE);
  294.   
  295.     return(1);
  296. }
  297.  
  298. void CDialogSecurity::OnOK()
  299. { 
  300.  
  301.     CButton * button = (CButton *) GetDlgItem(IDC_SECURESHOWAGAIN);
  302.     if(button) {
  303.         theApp.m_nSecurityCheck[m_Type] = button->GetCheck(); 
  304.         if ( returnpref ) {
  305.             if ( theApp.m_nSecurityCheck[m_Type] ) {
  306.                 *returnpref = TRUE;
  307.             } else {
  308.                 *returnpref = FALSE;
  309.             }
  310.         }
  311.     }
  312.  
  313.     CDialog::OnOK();
  314. }
  315.  
  316.  
  317. /////////////////////////////////////////////////////////////////////////////
  318. /////////////////////////////////////////////////////////////////////////////
  319. /////////////////////////////////////////////////////////////////////////////
  320. // CDialogPRMT dialog
  321.  
  322. CDialogPRMT::CDialogPRMT(CWnd* pParent /*=NULL*/)
  323.     : CDialog(CDialogPRMT::IDD, pParent)
  324. {
  325.     m_csTitle = _T("");
  326.     
  327.     //{{AFX_DATA_INIT(CDialogPRMT)
  328.     m_csAns = "";
  329.     //}}AFX_DATA_INIT
  330. }
  331.  
  332. void CDialogPRMT::DoDataExchange(CDataExchange* pDX)
  333. {
  334.     CDialog::DoDataExchange(pDX);
  335.     //{{AFX_DATA_MAP(CDialogPRMT)
  336.     DDX_Text(pDX, IDC_PROMPT_ASK, m_csAsk);
  337.     DDX_Text(pDX, IDC_PROMPT_ANS, m_csAns);
  338.     //}}AFX_DATA_MAP
  339. }
  340.  
  341. BEGIN_MESSAGE_MAP(CDialogPRMT, CDialog)
  342.     //{{AFX_MSG_MAP(CDialogPRMT)
  343.         // NOTE: the ClassWizard will add message map macros here
  344.     //}}AFX_MSG_MAP
  345. END_MESSAGE_MAP()
  346.  
  347. /////////////////////////////////////////////////////////////////////////////
  348. // CDialogPRMT message handlers
  349.  
  350. char * CDialogPRMT::DoModal(const char * Msg, const char * Dflt, const char *pszCaption)
  351. {
  352.     int status;
  353.     if(!m_csAsk.IsEmpty()) 
  354.         m_csAsk.Empty();
  355.  
  356.     if(!m_csAns.IsEmpty())
  357.         m_csAns.Empty();
  358.  
  359.     m_csAsk = Msg;
  360.     m_csAns = Dflt;
  361.     if (pszCaption)
  362.         m_csCaption = pszCaption;
  363.     else
  364.         m_csCaption.Format(szLoadString(IDS_USER_PROMPT), szLoadString(AFX_IDS_APP_TITLE));
  365.  
  366.  
  367.     status = CDialog::DoModal();
  368.  
  369.     if(status == IDOK)
  370.         return(XP_STRDUP((const char *) m_csAns));
  371.     else    
  372.         return(NULL);
  373. }                        
  374.  
  375. int CDialogPRMT::OnInitDialog()
  376. {   
  377.     if( !m_csTitle.IsEmpty() )
  378.         SetWindowText( (LPCSTR)m_csTitle );
  379.     else
  380.         SetWindowText(m_csCaption);   
  381.     
  382.     CWnd *pWnd = GetDlgItem(IDC_PROMPT_ASK);
  383.     if (pWnd)
  384.         pWnd->SetWindowText(m_csAsk);
  385.  
  386.     CEdit *edit = (CEdit *) GetDlgItem(IDC_PROMPT_ANS);
  387.     if (edit) {
  388.         edit->SetWindowText(m_csAns);
  389.         edit->SetFocus();
  390.         edit->SetSel(0, -1);
  391.         return(0);
  392.     }
  393.  
  394.     return(TRUE);
  395. }
  396.  
  397. /////////////////////////////////////////////////////////////////////////////
  398. /////////////////////////////////////////////////////////////////////////////
  399. /////////////////////////////////////////////////////////////////////////////
  400. // CDialogPASS dialog
  401.  
  402. CDialogPASS::CDialogPASS(CWnd* pParent /*=NULL*/)
  403.     : CDialog(CDialogPASS::IDD, pParent)
  404. {
  405.     m_csTitle = _T("");
  406.     
  407.     //{{AFX_DATA_INIT(CDialogPASS)
  408.     m_csAns = "";
  409.     //}}AFX_DATA_INIT
  410. }
  411.  
  412. void CDialogPASS::DoDataExchange(CDataExchange* pDX)
  413. {
  414.     CDialog::DoDataExchange(pDX);
  415.     //{{AFX_DATA_MAP(CDialogPASS)
  416.     DDX_Text(pDX, IDC_PROMPT_ASK, m_csAsk);
  417.     DDX_Text(pDX, IDC_PROMPT_ANS, m_csAns);
  418.     //}}AFX_DATA_MAP
  419. }
  420.  
  421. BEGIN_MESSAGE_MAP(CDialogPASS, CDialog)
  422.     //{{AFX_MSG_MAP(CDialogPASS)
  423.         // NOTE: the ClassWizard will add message map macros here
  424.     //}}AFX_MSG_MAP
  425. END_MESSAGE_MAP()
  426.  
  427. /////////////////////////////////////////////////////////////////////////////
  428. // CDialogPASS message handlers
  429.  
  430. char * CDialogPASS::DoModal(const char * Msg)
  431. {
  432.     int status;
  433.     if(!m_csAsk.IsEmpty()) 
  434.         m_csAsk.Empty();
  435.  
  436.     if(!m_csAns.IsEmpty())
  437.         m_csAns.Empty();
  438.  
  439.     m_csAsk = Msg;
  440.     status = CDialog::DoModal();
  441.  
  442.     if(status == IDOK)
  443.         return(XP_STRDUP((const char *) m_csAns));
  444.     else    
  445.         return(NULL);
  446. }
  447.                                                              
  448.                                                              
  449. int CDialogPASS::OnInitDialog()
  450. {
  451.  
  452.     CDialog::OnInitDialog();
  453.  
  454. #ifndef XP_WIN32
  455.     //win16 only
  456.     if ( m_hWnd ) {
  457.         BringWindowToTop();
  458.         SetWindowPos( &wndTopMost, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
  459.     }
  460. #endif
  461.  
  462.     if( !m_csTitle.IsEmpty() )
  463.         SetWindowText( (LPCSTR)m_csTitle );
  464.     
  465.     CEdit * edit = (CEdit *) GetDlgItem(IDC_PROMPT_ANS);
  466.  
  467.     if(edit) {
  468.         edit->SetFocus();
  469.         edit->SetSel(0, -1);
  470.         return(0);
  471.     }
  472.  
  473.     return(1);
  474.  
  475. }
  476.  
  477.                                                              
  478. /////////////////////////////////////////////////////////////////////////////
  479. // CDialogUPass dialog
  480.  
  481.  
  482. CDialogUPass::CDialogUPass(CWnd* pParent /*=NULL*/)
  483.   : CDialog(CDialogUPass::IDD, pParent)
  484. {
  485.   //{{AFX_DATA_INIT(CDialogUPass)
  486.     // NOTE: the ClassWizard will add member initialization here
  487.   //}}AFX_DATA_INIT
  488. }
  489.  
  490. void CDialogUPass::DoDataExchange(CDataExchange* pDX)
  491. {
  492.     CDialog::DoDataExchange(pDX);
  493.     //{{AFX_DATA_MAP(CDialogUPass)
  494.     DDX_Text(pDX, IDC_PROMPT, m_csMessage);
  495.     DDX_Text(pDX, IDC_EDIT1, m_csUser);
  496.     DDX_Text(pDX, IDC_EDIT2, m_csPasswd);
  497.     //}}AFX_DATA_MAP
  498. }
  499.  
  500. BEGIN_MESSAGE_MAP(CDialogUPass, CDialog)
  501.   //{{AFX_MSG_MAP(CDialogUPass)
  502.     // NOTE: the ClassWizard will add message map macros here
  503.   //}}AFX_MSG_MAP
  504. END_MESSAGE_MAP()
  505.  
  506.  
  507. /////////////////////////////////////////////////////////////////////////////
  508. // CDialogUPass message handlers
  509.  
  510. int CDialogUPass::DoModal(char * message, char ** user, char ** passwd)
  511. {
  512.  
  513.     int status;
  514.  
  515.     if(!user || !passwd)
  516.         return(FALSE);
  517.  
  518.     if(message)
  519.         m_csMessage = message;
  520.     else
  521.         m_csMessage = szLoadString(IDS_AUTH_DEFAULT);
  522.  
  523.     if(*user)
  524.         m_csUser   = *user;
  525.     else
  526.         m_csUser   = "";
  527.  
  528.     m_csPasswd = "";
  529.  
  530.     status = CDialog::DoModal();
  531.  
  532.     if(status != IDOK)
  533.         return(FALSE);
  534.   
  535.     *user   = XP_STRDUP((const char *) m_csUser);
  536.     *passwd = XP_STRDUP((const char *) m_csPasswd);
  537.  
  538.     return(TRUE);
  539.  
  540. }
  541.  
  542. int CDialogUPass::OnInitDialog()
  543. {
  544.     CDialog::OnInitDialog();
  545.  
  546. #ifndef XP_WIN32
  547.     //win16 only
  548.     if ( m_hWnd ) {
  549.         BringWindowToTop();
  550.         SetWindowPos( &wndTopMost, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
  551.     }
  552. #endif
  553.  
  554.     if( !m_csTitle.IsEmpty() )
  555.         SetWindowText( (LPCSTR)m_csTitle );
  556.     
  557.     return(1);
  558. }
  559.  
  560.  
  561. /////////////////////////////////////////////////////////////////////////////
  562. // CUnknownTypeDlg dialog
  563.  
  564.  
  565. CUnknownTypeDlg::CUnknownTypeDlg(CWnd* pParent /*=NULL*/, char * filetype,CHelperApp * app)
  566.   : CDialog(CUnknownTypeDlg::IDD, pParent)
  567. {
  568.     //{{AFX_DATA_INIT(CUnknownTypeDlg)
  569.     m_FileType = filetype;
  570.     m_app = app;
  571.     //}}AFX_DATA_INIT
  572. }
  573.  
  574. void CUnknownTypeDlg::DoDataExchange(CDataExchange* pDX)
  575. {
  576.     CDialog::DoDataExchange(pDX);
  577.     //{{AFX_DATA_MAP(CUnknownTypeDlg)
  578.     DDX_Text(pDX, IDC_FILETYPE, m_FileType);
  579.     //}}AFX_DATA_MAP
  580. }
  581.  
  582. BEGIN_MESSAGE_MAP(CUnknownTypeDlg, CDialog)
  583.     //{{AFX_MSG_MAP(CUnknownTypeDlg)
  584.     ON_BN_CLICKED(ID_CONFIGUREVIEWER, OnConfigureviewer)
  585.     ON_BN_CLICKED(ID_SAVETODISK, OnSavetodisk)
  586.     ON_BN_CLICKED(IDC_MORE_INFO, OnMoreInfo)
  587.     //}}AFX_MSG_MAP
  588. END_MESSAGE_MAP()
  589.  
  590.  
  591. /////////////////////////////////////////////////////////////////////////////
  592. // CUnknownTypeDlg message handlers
  593.  
  594. void CUnknownTypeDlg::OnConfigureviewer()
  595. {
  596.     CConfigureViewerSmall dlg(this, (const char *)m_FileType, m_app);
  597.  
  598.     if (dlg.DoModal() == IDOK) {
  599.         //    Ensure the app points to what the user actually typed in.
  600.         m_app->csCmd = dlg.m_AppName;
  601.         m_app->bChanged = TRUE;
  602.         m_app->how_handle = HANDLE_EXTERNAL;
  603.         EndDialog(HANDLE_EXTERNAL);
  604.     }
  605. }
  606.  
  607. void CUnknownTypeDlg::OnSavetodisk()
  608. {
  609.     EndDialog(HANDLE_SAVE); 
  610. }
  611.  
  612. void CUnknownTypeDlg::OnCancel()
  613. {
  614.     CDialog::OnCancel();
  615. }
  616.  
  617. void CUnknownTypeDlg::OnMoreInfo()
  618. {
  619.     EndDialog(HANDLE_MOREINFO); 
  620. }
  621. /////////////////////////////////////////////////////////////////////////////
  622. // CNewMimeType dialog
  623.  
  624.  
  625. CNewMimeType::CNewMimeType(CWnd* pParent /*=NULL*/)
  626.   : CDialog(CNewMimeType::IDD, pParent)
  627. {
  628.     //{{AFX_DATA_INIT(CNewMimeType)
  629.     m_MimeSubtype = "";
  630.     m_MimeType = "";
  631.     //}}AFX_DATA_INIT
  632. }
  633.  
  634. void CNewMimeType::DoDataExchange(CDataExchange* pDX)
  635. {
  636.     CDialog::DoDataExchange(pDX);
  637.     //{{AFX_DATA_MAP(CNewMimeType)
  638.     DDX_Text(pDX, IDC_MIMESUBTYPE_EDIT, m_MimeSubtype);
  639.     DDX_Text(pDX, IDC_MIMETYPE_EDIT, m_MimeType);
  640.     //}}AFX_DATA_MAP
  641. }
  642.  
  643. BEGIN_MESSAGE_MAP(CNewMimeType, CDialog)
  644.   //{{AFX_MSG_MAP(CNewMimeType)
  645.     // NOTE: the ClassWizard will add message map macros here
  646.   //}}AFX_MSG_MAP
  647. END_MESSAGE_MAP()
  648.  
  649.  
  650. /////////////////////////////////////////////////////////////////////////////
  651. // CNewMimeType message handlers
  652. /////////////////////////////////////////////////////////////////////////////
  653. // CConfigureViewerSmall dialog
  654.  
  655.  
  656. CConfigureViewerSmall::CConfigureViewerSmall(CWnd* pParent /*=NULL*/, const char * filetype,  CHelperApp * app)
  657.   : CDialog(CConfigureViewerSmall::IDD, pParent)
  658. {
  659.     //{{AFX_DATA_INIT(CConfigureViewerSmall)
  660.     m_MimeType = filetype;
  661.     m_AppName = _T("");
  662.     //}}AFX_DATA_INIT
  663.  
  664.     m_app = app;
  665. }
  666.  
  667. void CConfigureViewerSmall::DoDataExchange(CDataExchange* pDX)
  668. {
  669.     CDialog::DoDataExchange(pDX);
  670.     //{{AFX_DATA_MAP(CConfigureViewerSmall)
  671.     DDX_Text(pDX, IDC_MIMETYPE_EDIT, m_MimeType);
  672.     DDX_Text(pDX, IDC_HELPER_PATH, m_AppName);
  673.     //}}AFX_DATA_MAP
  674. }
  675.  
  676. BEGIN_MESSAGE_MAP(CConfigureViewerSmall, CDialog)
  677.   //{{AFX_MSG_MAP(CConfigureViewerSmall)
  678.   ON_BN_CLICKED(IDC_HELPER_BROWSE, OnHelperBrowse)
  679.   //}}AFX_MSG_MAP
  680. END_MESSAGE_MAP()
  681.  
  682.  
  683. /////////////////////////////////////////////////////////////////////////////
  684. // CConfigureViewerSmall message handlers
  685.  
  686. void CConfigureViewerSmall::OnHelperBrowse()
  687. {
  688.     char * name;
  689.  
  690.     name = wfe_GetExistingFileName(m_hWnd,
  691.                           szLoadString(IDS_SELECT_APPROPRIATE_VIEWER), EXE, TRUE);
  692.  
  693.     // user selected a file
  694.     if(name) {
  695.         CStatic   * pIcon = (CStatic *)GetDlgItem(IDC_HELPER_STATIC4);
  696.         HICON hIcon;
  697.  
  698.         //    NT can't handle paths with spaces
  699.         //    We don't deal with it here, so it's up to the user.
  700.         //    If they quote it in their registry, then we preserve their string.
  701.  
  702.         //    Force redraw of the name they enetered.
  703.         CEdit *pEdit = (CEdit *)GetDlgItem(IDC_HELPER_PATH);
  704.         if(pEdit)    {
  705.             pEdit->SetWindowText(name);
  706.         }
  707.  
  708.         hIcon = ExtractIcon(theApp.m_hInstance,(const char *)m_AppName,0);
  709.         pIcon->SetIcon(hIcon);
  710.         XP_FREE(name);    
  711.     } 
  712. }
  713.  
  714.  
  715. /****************************************************************************
  716. *
  717. *    Class: CDefaultBrowserDlg
  718. *
  719. *    DESCRIPTION:
  720. *        This provides a dialog for notifying the user that another application
  721. *        has made themselves the "default browser" by changing our registry
  722. *        entries.
  723. *
  724. ****************************************************************************/
  725.  
  726. BEGIN_MESSAGE_MAP(CDefaultBrowserDlg, CDefaultBrowserDlgBase)
  727.     //{{AFX_MSG_MAP(CDefaultBrowserDlg)
  728.     ON_BN_CLICKED(ID_NO, OnNo)
  729.     ON_WM_PAINT()
  730.     //}}AFX_MSG_MAP
  731. END_MESSAGE_MAP()
  732.  
  733. /****************************************************************************
  734. *
  735. *    CDefaultBrowserDlg::CDefaultBrowserDlg
  736. *
  737. *    PARAMETERS:
  738. *        pParent    - pointer to parent window (= NULL)
  739. *
  740. *    RETURNS:
  741. *        N/A
  742. *
  743. *    DESCRIPTION:
  744. *        Standard dialog constructor.
  745. *
  746. ****************************************************************************/
  747.  
  748. CDefaultBrowserDlg::CDefaultBrowserDlg(CWnd* pParent /*=NULL*/)
  749.     : CDefaultBrowserDlgBase(CDefaultBrowserDlg::IDD, pParent)
  750. {
  751.     //{{AFX_DATA_INIT(CDefaultBrowserDlg)
  752.     m_bIgnore = FALSE;
  753.     //}}AFX_DATA_INIT
  754.     
  755. } // END OF    FUNCTION CDefaultBrowserDlg::CDefaultBrowserDlg()
  756.  
  757. /****************************************************************************
  758. *
  759. *    CDefaultBrowserDlg::DoDataExchange
  760. *
  761. *    PARAMETERS:
  762. *        pDX    - the usual CDataExchange pointer
  763. *
  764. *    RETURNS:
  765. *        void
  766. *
  767. *    DESCRIPTION:
  768. *        Standard dialog data exchange function.
  769. *
  770. ****************************************************************************/
  771.  
  772. void CDefaultBrowserDlg::DoDataExchange(CDataExchange* pDX)
  773. {
  774.     CDefaultBrowserDlgBase::DoDataExchange(pDX);
  775.     
  776.     //{{AFX_DATA_MAP(CDefaultBrowserDlg)
  777.     DDX_Check(pDX, IDC_IGNORE, m_bIgnore);
  778.     DDX_Control(pDX, IDC_LIST1, m_Listbox);
  779.     //}}AFX_DATA_MAP
  780.     
  781. } // END OF    FUNCTION CDefaultBrowserDlg::DoDataExchange()
  782.  
  783. /****************************************************************************
  784. *
  785. *    CDefaultBrowserDlg::OnNo
  786. *
  787. *    PARAMETERS:
  788. *        None
  789. *
  790. *    RETURNS:
  791. *        void
  792. *
  793. *    DESCRIPTION:
  794. *        This handles the 'No' button. We treat it just like OnOK, except
  795. *        for the return value.
  796. *
  797. ****************************************************************************/
  798.  
  799. void CDefaultBrowserDlg::OnNo() 
  800. {
  801.     if (UpdateData(TRUE))
  802.     {
  803.         EndDialog(ID_NO);
  804.     }  /* end if */
  805.     
  806. } // END OF    FUNCTION CDefaultBrowserDlg::OnNo()
  807.  
  808. /****************************************************************************
  809. *
  810. *    CDefaultBrowserDlg::OnPaint
  811. *
  812. *    PARAMETERS:
  813. *        None
  814. *
  815. *    RETURNS:
  816. *        void
  817. *
  818. *    DESCRIPTION:
  819. *        We use this WM_PAINT handler to draw the standard Windows question
  820. *        icon on the dialog, so it looks more like a message box.
  821. *
  822. ****************************************************************************/
  823.  
  824. void CDefaultBrowserDlg::OnPaint() 
  825. {
  826.     CPaintDC dc(this);
  827.     
  828.     // Draw the Windows question icon in the placeholder
  829.     CWnd * pwndIcon = GetDlgItem(IDC_WARNING_ICON);
  830.     ASSERT(pwndIcon != NULL);
  831.     if (pwndIcon != NULL)
  832.     {
  833.         CRect rc;
  834.         pwndIcon->GetWindowRect(rc);
  835.         ScreenToClient(rc);
  836.         dc.DrawIcon(rc.TopLeft(), ::LoadIcon(NULL, IDI_EXCLAMATION));
  837.     }  /* end if */
  838.     
  839.     // Do not call CDefaultBrowserDlgBase::OnPaint() for painting messages
  840.     
  841. } // END OF    FUNCTION CDefaultBrowserDlg::OnPaint()
  842.  
  843. BOOL CDefaultBrowserDlg::OnInitDialog()
  844. {
  845.     BOOL res = CDialog::OnInitDialog();
  846.  
  847.     // Fill in the dialog's list box
  848.     CPtrArray* lostList = theApp.m_OwnedAndLostList.GetLostList();
  849.     
  850.     // Add to list
  851.     int size = lostList->GetSize();
  852.     for (int i = 0; i < size; i++)
  853.     {
  854.         COwnedLostItem* theItem = (COwnedLostItem*)((*lostList)[i]);
  855.  
  856.         if (!theItem->m_bIgnored)
  857.         {
  858.             theItem->FetchPrettyName();
  859.             if (theItem->m_csPrettyName != "")
  860.             {
  861.                 int index = m_Listbox.AddString(theItem->m_csPrettyName);
  862.                 m_Listbox.SetItemDataPtr(index, theItem);
  863.             }
  864.         }
  865.  
  866.         m_Listbox.SetSel(-1);
  867.     }
  868.  
  869.     return res;
  870. }
  871.  
  872. static BOOL IsListItemSelected(int* selArray, int count, int i)
  873. {
  874.     for (int x = 0; x < count; x++)
  875.     {
  876.         int item = selArray[x];
  877.         if (i == item)
  878.             return TRUE;
  879.     }
  880.     return FALSE;
  881. }
  882.  
  883. void CDefaultBrowserDlg::OnOK()
  884. {
  885.     // Let's do it. Selected items become owned.
  886.     // Unselected items become ignored (if the checkbox is checked)
  887.     CDefaultBrowserDlgBase::OnOK();
  888.  
  889.     int count = m_Listbox.GetCount();
  890.     int* selArray = new int[count];
  891.  
  892.     int nSelectedArraySize = m_Listbox.GetSelItems(count, selArray);
  893.         
  894.     for (int i = 0; i < count; i++)
  895.     {
  896.         COwnedLostItem* theItem = (COwnedLostItem*)(m_Listbox.GetItemDataPtr(i));
  897.         
  898.         if (IsListItemSelected(selArray, count, i))
  899.         {
  900.             // Remove it from the lost list.
  901.             theApp.m_OwnedAndLostList.RemoveFromLostList(theItem->m_csMimeType);
  902.             
  903.             // Add it to the owned list.
  904.             theApp.m_OwnedAndLostList.GetOwnedList()->Add(theItem);
  905.  
  906.             // Modify the HelperApp information (write to the registry)
  907.             // Fun fun fun!
  908.             theItem->GiveControlToNetscape();
  909.         }
  910.         else if (m_bIgnore)
  911.         {
  912.             // User wants to ignore this item. Add it to the ignore list.
  913.             theItem->SetIgnored(TRUE);
  914.         }
  915.     }    
  916. }
  917.