зеркало из https://github.com/mozilla/pjs.git
799 строки
21 KiB
C++
799 строки
21 KiB
C++
/* -*- 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.
|
|
*/
|
|
|
|
// mainfrm.cpp : implementation of the CMainFrame class
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include "rosetta.h"
|
|
#include "dialog.h"
|
|
#include "winclose.h"
|
|
#include "cntritem.h"
|
|
#include "timer.h"
|
|
#include "cxsave.h"
|
|
#include "edt.h"
|
|
#include "mainfrm.h"
|
|
#include "edframe.h"
|
|
#include "netsvw.h"
|
|
#include "hiddenfr.h"
|
|
#include "intlwin.h"
|
|
#include "msgcom.h"
|
|
#include "custom.h"
|
|
#include "statbar.h"
|
|
#include "histbld.h"
|
|
#include "nethelp.h"
|
|
#include "mnwizard.h"
|
|
#include "ssl.h"
|
|
#include "prefapi.h"
|
|
#include "prefInfo.h"
|
|
#include "medit.h"
|
|
|
|
#include "np.h"
|
|
#include "npapi.h" // for NPWindow
|
|
|
|
#if defined(OJI)
|
|
#include "jvmmgr.h"
|
|
#elif defined(JAVA)
|
|
#include "java.h"
|
|
#endif
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static char BASED_CODE THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
#ifndef _AFXDLL
|
|
#define new DEBUG_NEW // MSVC Debugging new...goes to regular new in release mode
|
|
#endif
|
|
|
|
#define SECURE_BITMAP_INDEX 10
|
|
#define MIDSECURE_BITMAP_INDEX 9
|
|
#define UNSECURE_BITMAP_INDEX 8
|
|
//
|
|
// If we are already calling NET_ProcessNet() cuz of a socket ready message
|
|
// do not call it again via a timer interrupt
|
|
//
|
|
MODULE_PRIVATE int winfeInProcessNet = FALSE;
|
|
static int calledProcessNet = FALSE;
|
|
|
|
// remember a socket which got a network event while we were thinking
|
|
static long m_nSocketToDealWith = 0;
|
|
|
|
extern CMapStringToOb DNSCacheMap;
|
|
|
|
static CHistoryMenuBuilder histBuilder;
|
|
|
|
#include "toolbar.cpp"
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CMainFrame diagnostics
|
|
|
|
#ifdef _DEBUG
|
|
void CMainFrame::AssertValid() const
|
|
{
|
|
CGenericFrame::AssertValid();
|
|
}
|
|
|
|
void CMainFrame::Dump(CDumpContext& dc) const
|
|
{
|
|
CGenericFrame::Dump(dc);
|
|
}
|
|
|
|
#endif //_DEBUG
|
|
|
|
//
|
|
// Pop up an alert box for the user
|
|
//
|
|
void CMainFrame::Alert(char * Msg)
|
|
{
|
|
MessageBox(Msg, szLoadString(AFX_IDS_APP_TITLE), MB_ICONEXCLAMATION | MB_OK);
|
|
}
|
|
|
|
//
|
|
// Pop up a message to the user.
|
|
// Return TRUE if the user clicks on the "OK" button else FALSE
|
|
//
|
|
int CMainFrame::Confirm(char * Msg)
|
|
{
|
|
int res = GetActiveWindow()->MessageBox(Msg, szLoadString(AFX_IDS_APP_TITLE), MB_ICONQUESTION | MB_OKCANCEL);
|
|
return(res == IDOK);
|
|
}
|
|
|
|
char * CMainFrame::Prompt(const char * Msg, const char * Dflt)
|
|
{
|
|
// CDialogPRMT foo(this->GetActiveWindow());
|
|
// Must always use ActiveWindow so preference dialogs are the parent,
|
|
// else user can move focus to preference dialog and loose prompt dialog
|
|
CDialogPRMT foo(this->GetActiveWindow());
|
|
return(foo.DoModal(Msg, Dflt));
|
|
}
|
|
|
|
|
|
char * CMainFrame::PromptPassword(char * Msg)
|
|
{
|
|
// CDialogPASS foo(this);
|
|
CDialogPASS foo(this->GetActiveWindow());
|
|
return(foo.DoModal(Msg));
|
|
}
|
|
|
|
#define IS_IN_WINDOW(hParent,hChild)\
|
|
(((hParent) == (hChild)) || ::IsChild(hParent, hChild))
|
|
|
|
BOOL CMainFrame::setNextTabFocus( int forward )
|
|
{
|
|
CWinCX *pWinCX = GetMainWinContext();
|
|
if( pWinCX ) {
|
|
// setTabFocusNext will search siblings
|
|
BOOL ret = pWinCX->setTabFocusNext( forward );
|
|
if( ret )
|
|
return( TRUE );
|
|
}
|
|
|
|
return( FALSE );
|
|
}
|
|
|
|
BOOL CMainFrame::PreTranslateMessage(MSG* pMsg)
|
|
{
|
|
|
|
BOOL bTranslated = CGenericFrame::PreTranslateMessage(pMsg);
|
|
|
|
if (bTranslated)
|
|
return TRUE; // msg handled
|
|
|
|
if (pMsg->message != WM_KEYDOWN)
|
|
return FALSE; // we're not interested in translating this message
|
|
|
|
// Do not continue with tab processing if in an editor
|
|
if( (pMsg->wParam != VK_TAB && pMsg->wParam != VK_SPACE && pMsg->wParam != VK_RETURN)
|
|
|| EDT_IS_EDITOR(GetMainContext()->GetContext()) )
|
|
return( FALSE );
|
|
|
|
// if a plugin has the focus, we don't touch the any (TAB,SAPCE,CR) key.
|
|
if( GetActiveWinContext() && GetActiveWinContext()->GetContext() ) {
|
|
// get the plugin list
|
|
NPEmbeddedApp * pPlugin = GetActiveWinContext()->GetContext()->pluginList;
|
|
// check each plugin in the list, to see if a plugin is the parent
|
|
// of the focus window.
|
|
while( pPlugin != NULL ) {
|
|
NPWindow* npWindow = pPlugin->wdata;
|
|
if( npWindow && npWindow->type == NPWindowTypeWindow ) {
|
|
// check relation of parent(plugin) - child(msg window)
|
|
if( npWindow->window && IS_IN_WINDOW( (HWND)npWindow->window, pMsg->hwnd) )
|
|
return(FALSE); // plugin has focus, dont touch TAB key
|
|
}
|
|
pPlugin = pPlugin->next;
|
|
}
|
|
}
|
|
|
|
/*
|
|
The windows messaging systems such as CWnd::WalkPreTranslateTree(), only
|
|
walk from leaf to root of the window tree.
|
|
|
|
To navigate in frames(grids), Tab navigation needs to go from one window(view)
|
|
to its sibling. Therefor, we need to walk the tree.
|
|
*/
|
|
CGenericView *pView;
|
|
UINT forward = GetKeyState(VK_SHIFT)<0 ? 0 : 1 ; // 1 is forward
|
|
UINT controlKey = GetKeyState(VK_CONTROL)<0 ? 1 : 0 ; // 1 controlKey, go to next group
|
|
int ii;
|
|
|
|
// IF child A reached the end of tabable elements, and child B
|
|
// has no tabable elements, we need go back to child A to set
|
|
// tab focus. That is the "for" loop for.
|
|
for( ii = 0; ii < 2 && !bTranslated; ii ++ ) {
|
|
|
|
// the chrome(location and starter bar) get Tab focus first
|
|
if( GetChrome() != NULL ) {
|
|
if( m_tabFocusInMainFrm == TAB_FOCUS_IN_NULL ) {
|
|
|
|
// first time,
|
|
if( pMsg->wParam != VK_TAB ) // #49928 only handle Tab key in Chrome
|
|
return( FALSE );
|
|
|
|
// set focus to the location box.
|
|
bTranslated = GetChrome()->procTabNavigation( pMsg->wParam, 1, controlKey );
|
|
if( bTranslated ) {
|
|
m_tabFocusInMainFrm = TAB_FOCUS_IN_CHROME;
|
|
return( TRUE );
|
|
} // else, do nothing, fall to setting focus in views.
|
|
} else if( m_tabFocusInMainFrm == TAB_FOCUS_IN_CHROME ) {
|
|
|
|
if( pMsg->wParam != VK_TAB ) // #49928 only handle Tab key in Chrome
|
|
return( FALSE );
|
|
|
|
bTranslated = GetChrome()->procTabNavigation( pMsg->wParam, 0, controlKey );
|
|
if( bTranslated ) {
|
|
// chrome consummed the Tab key
|
|
m_tabFocusInMainFrm = TAB_FOCUS_IN_CHROME;
|
|
return( TRUE );
|
|
} else {
|
|
m_tabFocusInMainFrm = TAB_FOCUS_IN_NULL;
|
|
// fall to setting focus in views.
|
|
}
|
|
|
|
}
|
|
} else { // no chrome, user may just close the chrom
|
|
if( m_tabFocusInMainFrm == TAB_FOCUS_IN_CHROME )
|
|
m_tabFocusInMainFrm = TAB_FOCUS_IN_NULL;
|
|
// fall to setting focus in views.
|
|
}
|
|
|
|
if( bTranslated )
|
|
return(TRUE);
|
|
|
|
#ifdef DEBUG_aliu
|
|
// we should have returned, if focus was set in chrome.
|
|
ASSERT( m_tabFocusInMainFrm != TAB_FOCUS_IN_CHROME );
|
|
#endif
|
|
if( ! GetActiveView() ) { // #55453 something wrong, try my best.
|
|
bTranslated = setNextTabFocus(forward); // setNextTabableFrame( NULL, forward ); //NULL start with the first frame
|
|
} else {
|
|
if( ! GetActiveView()->IsKindOf(RUNTIME_CLASS( CGenericView ) ) )
|
|
return(FALSE); // not html, maybe print-preview #44362
|
|
|
|
// now try to set tab focus to the views(grids)
|
|
if( m_tabFocusInMainFrm == TAB_FOCUS_IN_GRID ) {
|
|
// Starting with the active view, procTabNavigation() will
|
|
// search siblings in this frame window.
|
|
pView = (CGenericView *) GetActiveView( );
|
|
|
|
if( pView == NULL )
|
|
return(FALSE);
|
|
|
|
// TODO control key is for Tab-group(Form, table) or for Frame???
|
|
if( ! controlKey ) {
|
|
// try active view first
|
|
bTranslated = pView->procTabNavigation( pMsg->wParam, forward, controlKey ); // for Tab, or SpaceBar
|
|
if ( bTranslated ) {
|
|
m_tabFocusInMainFrm = TAB_FOCUS_IN_GRID ;
|
|
return( TRUE ); // msg handled
|
|
}
|
|
}
|
|
|
|
if( pMsg->wParam != VK_TAB )
|
|
return( FALSE );
|
|
|
|
// active frame has nothing to tab to.
|
|
m_tabFocusInMainFrm = TAB_FOCUS_IN_NULL;
|
|
|
|
// try other frames(if any), starting from this
|
|
// bTranslated = setNextTabableFrame( this, forward );
|
|
} else { // TAB_FOCUS_IN_NULL,
|
|
// start with the first frame
|
|
bTranslated = setNextTabFocus(forward); // setNextTabableFrame( NULL, forward );
|
|
}
|
|
} // if( ! GetActiveView() )
|
|
|
|
if ( bTranslated ) {
|
|
m_tabFocusInMainFrm = TAB_FOCUS_IN_GRID ;
|
|
return( TRUE ); // msg handled
|
|
}
|
|
|
|
} // for( ii = 0; ii < 2; ii ++ )
|
|
return(FALSE);
|
|
} // BOOL CMainFrame::PreTranslateMessage(MSG* pMsg)
|
|
|
|
|
|
void CMainFrame::OnToggleFancyFtp()
|
|
{
|
|
if(GetMainContext()) {
|
|
GetMainContext()->GetContext()->fancyFTP = !GetMainContext()->GetContext()->fancyFTP;
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnUpdateToggleFancyFtp(CCmdUI* pCmdUI)
|
|
{
|
|
if(GetMainContext()) {
|
|
pCmdUI->SetCheck(GetMainContext()->GetContext()->fancyFTP);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::RefreshNewEncoding(int16 csid, BOOL bIgnore)
|
|
{
|
|
if (m_iCSID != csid)
|
|
{
|
|
if(GetMainContext()) {
|
|
int iOldCSID = m_iCSID;
|
|
|
|
// Must set before EDT_SetEncoding.
|
|
m_iCSID = csid;
|
|
#ifdef EDITOR
|
|
if( EDT_IS_EDITOR(GetMainContext()->GetContext()) )
|
|
{
|
|
// EDT_SetEncoding takes care of reloading.
|
|
if ( ! EDT_SetEncoding(GetMainContext()->GetContext(), csid) ) {
|
|
// revert m_iCSID
|
|
m_iCSID = iOldCSID;
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
#endif /* EDITOR */
|
|
{
|
|
GetMainContext()->NiceReload();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Toggle the showing of the location bar
|
|
//
|
|
void CMainFrame::OnOptionsTitlelocationBar()
|
|
{
|
|
if(GetChrome()->GetToolbarVisible(ID_LOCATION_TOOLBAR)) {
|
|
GetChrome()->ShowToolbar(ID_LOCATION_TOOLBAR, FALSE);
|
|
m_bLocationBar= FALSE;
|
|
} else {
|
|
GetChrome()->ShowToolbar(ID_LOCATION_TOOLBAR, TRUE);
|
|
m_bLocationBar= TRUE;
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnUpdateOptionsTitlelocationBar(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->SetCheck(GetChrome()->GetToolbarVisible(ID_LOCATION_TOOLBAR));
|
|
}
|
|
|
|
XP_BEGIN_PROTOS
|
|
extern char * NET_PrintNetlibStatus();
|
|
XP_END_PROTOS
|
|
|
|
void CMainFrame::OnOptionsTogglenetdebug()
|
|
{
|
|
if(GetActiveContext() != NULL) {
|
|
char *rv = NET_PrintNetlibStatus();
|
|
FE_Alert(GetActiveContext()->GetContext(), rv);
|
|
XP_FREE(rv);
|
|
NET_ToggleTrace();
|
|
}
|
|
}
|
|
|
|
|
|
void CMainFrame::OnToggleImageLoad()
|
|
{
|
|
CWinCX *pWinCX;
|
|
if( pWinCX = GetMainWinContext()) {
|
|
if( prefInfo.m_bAutoLoadImages) {
|
|
prefInfo.m_bAutoLoadImages = FALSE;
|
|
GetChrome()->ImagesButton(TRUE);
|
|
} else {
|
|
prefInfo.m_bAutoLoadImages = TRUE;;
|
|
GetChrome()->ImagesButton(FALSE);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnUpdateToggleImageLoad(CCmdUI* pCmdUI)
|
|
{
|
|
CWinCX *pWinCX;
|
|
if( pWinCX = GetMainWinContext()) {
|
|
pCmdUI->SetCheck(prefInfo.m_bAutoLoadImages);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnNetSearch()
|
|
{
|
|
char * url = NULL;
|
|
PREF_CopyConfigString("internal_url.net_search.url",&url);
|
|
|
|
if(GetMainContext() && url)
|
|
{
|
|
GetMainContext()->NormalGetUrl(url);
|
|
XP_FREE(url);
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnUpdateNetSearch(CCmdUI *pCmdUI)
|
|
{
|
|
pCmdUI->Enable(TRUE);
|
|
}
|
|
|
|
|
|
void CMainFrame::OnUpdateSecurity(CCmdUI *pCmdUI)
|
|
{
|
|
|
|
HG73537
|
|
MWContext *pContext = GetMainContext()->GetContext();
|
|
|
|
if(EDT_IS_EDITOR(pContext))
|
|
CGenericFrame::OnUpdateSecurity(pCmdUI);
|
|
else
|
|
{
|
|
int status = XP_GetSecurityStatus(pContext);
|
|
|
|
BOOL bHasSecurity = status == SSL_SECURITY_STATUS_ON_LOW || status == SSL_SECURITY_STATUS_ON_HIGH;
|
|
|
|
if(m_pCommandToolbar)
|
|
{
|
|
switch(status)
|
|
{
|
|
case SSL_SECURITY_STATUS_ON_LOW:
|
|
m_pCommandToolbar->ReplaceButtonBitmapIndex(ID_SECURITY, SECURE_BITMAP_INDEX);
|
|
break;
|
|
case SSL_SECURITY_STATUS_ON_HIGH:
|
|
m_pCommandToolbar->ReplaceButtonBitmapIndex(ID_SECURITY, SECURE_BITMAP_INDEX);
|
|
break;
|
|
default:
|
|
m_pCommandToolbar->ReplaceButtonBitmapIndex(ID_SECURITY, UNSECURE_BITMAP_INDEX);
|
|
break;
|
|
}
|
|
pCmdUI->Enable(TRUE);
|
|
}
|
|
else
|
|
pCmdUI->Enable(FALSE);
|
|
}
|
|
|
|
}
|
|
|
|
void CMainFrame::OnUpdateSecurityStatus(CCmdUI *pCmdUI)
|
|
{
|
|
HG73537
|
|
int status = XP_GetSecurityStatus(GetMainContext()->GetContext());
|
|
pCmdUI->Enable(status == SSL_SECURITY_STATUS_ON_LOW || status == SSL_SECURITY_STATUS_ON_HIGH);
|
|
}
|
|
|
|
void CMainFrame::OnUpdateViewCommandToolbar(CCmdUI *pCmdUI)
|
|
{
|
|
CGenericFrame::OnUpdateViewCommandToolbar(pCmdUI);
|
|
|
|
if(!IsEditFrame() && PREF_PrefIsLocked("browser.chrome.show_toolbar"))
|
|
pCmdUI->Enable(FALSE);
|
|
}
|
|
|
|
|
|
void CMainFrame::OnUpdateViewLocationToolbar(CCmdUI *pCmdUI)
|
|
{
|
|
CGenericFrame::OnUpdateViewLocationToolbar(pCmdUI);
|
|
|
|
if(!IsEditFrame() && PREF_PrefIsLocked("browser.chrome.show_url_bar"))
|
|
pCmdUI->Enable(FALSE);
|
|
}
|
|
|
|
void CMainFrame::OnUpdateViewCustomToolbar(CCmdUI *pCmdUI)
|
|
{
|
|
CGenericFrame::OnUpdateViewCustomToolbar(pCmdUI);
|
|
|
|
if(!IsEditFrame() && PREF_PrefIsLocked("browser.chrome.show_directory_buttons"))
|
|
pCmdUI->Enable(FALSE);
|
|
}
|
|
|
|
BOOL CMainFrame::OnCommand(UINT wParam,LONG lParam)
|
|
{
|
|
if(CGenericFrame::OnCommand(wParam, lParam))
|
|
return TRUE;
|
|
|
|
// Extract the command ID
|
|
UINT nID = LOWORD(wParam);
|
|
|
|
// IS it a command or a menu?
|
|
if ((nID == 0) || (LOWORD(lParam) != 0)) {
|
|
// Menu IDs cannot be 0
|
|
// For menus, the low-order word of lParam is zero
|
|
return FALSE;
|
|
}
|
|
|
|
// See if it was one of the items in the history list
|
|
if (IS_HISTORY_ID(nID) && GetMainContext()) {
|
|
// Make sure the command ID is consistent with the last
|
|
// selected menu item
|
|
histBuilder.Execute(nID);
|
|
|
|
return TRUE;
|
|
}
|
|
if (IS_SHORTCUT_ID(nID) && GetMainContext()) {
|
|
LoadShortcut(nID-FIRST_SHORTCUT_ID);
|
|
}
|
|
|
|
return FALSE; // no obe wanted it
|
|
}
|
|
|
|
void CMainFrame::OnInitMenuPopup(CMenu* pPopup, UINT nIndex, BOOL bSysMenu)
|
|
{
|
|
AfxLockTempMaps();
|
|
|
|
CGenericFrame::OnInitMenuPopup(pPopup,nIndex,bSysMenu);
|
|
|
|
if (!bSysMenu && pPopup) {
|
|
// if it contains Back has the first item and nIndex is not 0 then
|
|
// fill in the menu. nIndex would be 0 if it's a popup or if
|
|
// it's the first menu in the system
|
|
if (pPopup->GetMenuItemID(0) == ID_NAVIGATE_BACK && nIndex != 0){
|
|
// We need to check whether we have already built the menu.
|
|
// Even though we destroy the menu items each time the menus go away,
|
|
// this only happens when the user is all done with the menu bar and
|
|
// not when each individual pop-up menu is dismissed
|
|
if (pPopup->GetMenuState(FIRST_HISTORY_MENU_ID, MF_BYCOMMAND) == (UINT)-1)
|
|
BuildHistoryMenu(pPopup);
|
|
}
|
|
}
|
|
|
|
// This function must always be executed, so please, do NOT put any
|
|
// return statements in the above code!
|
|
AfxUnlockTempMaps();
|
|
}
|
|
|
|
void CMainFrame::GetMessageString( UINT nID, CString& rMessage ) const
|
|
{
|
|
// See if it's a history entry
|
|
if (nID >= FIRST_HISTORY_MENU_ID && nID <= LAST_HISTORY_MENU_ID) {
|
|
rMessage = histBuilder.GetURL(nID);
|
|
if (rMessage.IsEmpty())
|
|
{
|
|
ASSERT(FALSE);
|
|
}
|
|
} else {
|
|
CGenericFrame::GetMessageString( nID, rMessage );
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnMenuSelect(UINT nItemID, UINT nFlags, HMENU hSysMenu)
|
|
{
|
|
if (nFlags == 0xFFFF) {
|
|
HMENU hMenu = ::GetMenu(m_hWnd);
|
|
|
|
// Not all top-level windows have a menu bar (e.g. the chromeless ones)
|
|
// Also, Editor frame doesn't have these submenus
|
|
if (hMenu && !IsEditFrame() ) {
|
|
int nCount;
|
|
UINT nCmdID;
|
|
|
|
// Menu is going away so destroy all the menu items we
|
|
|
|
// Now cleanup the history menu. We don't need to make any assumptions
|
|
// about the number of menu items, because there are no separators or
|
|
// pull-right sub-menus so we can tell by looking at the command IDs
|
|
HMENU hPopupMenu = FEU_FindSubmenu(hMenu, ID_NAVIGATE_BACK);
|
|
|
|
if (hPopupMenu) {
|
|
ASSERT(hPopupMenu);
|
|
nCount = ::GetMenuItemCount(hPopupMenu);
|
|
|
|
// It's easiest to do this by walking backwards over the menu items
|
|
for (int i = nCount - 1; i >= 0; i--) {
|
|
nCmdID = ::GetMenuItemID(hPopupMenu, i);
|
|
|
|
if (IS_HISTORY_ID(nCmdID))
|
|
VERIFY(::DeleteMenu(hPopupMenu, i, MF_BYPOSITION));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
CGenericFrame::OnMenuSelect(nItemID, nFlags, hSysMenu);
|
|
}
|
|
|
|
void CMainFrame::BuildHistoryMenu(CMenu * pMenu)
|
|
{
|
|
ASSERT_VALID(pMenu);
|
|
if (!pMenu)
|
|
return;
|
|
|
|
histBuilder.Fill(pMenu->m_hMenu, MAX_MENU_ITEM_LENGTH, eFILLALL);
|
|
}
|
|
|
|
LRESULT CMainFrame::OnButtonMenuOpen(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
HMENU hMenu = (HMENU) lParam;
|
|
UINT nCommand = (UINT) LOWORD(wParam);
|
|
|
|
if(nCommand == ID_NAVIGATE_BACK)
|
|
{
|
|
histBuilder.Fill(hMenu, MAX_MENU_ITEM_LENGTH, eFILLBACKWARD);
|
|
}
|
|
else if(nCommand == ID_NAVIGATE_FORWARD)
|
|
{
|
|
|
|
histBuilder.Fill(hMenu, MAX_MENU_ITEM_LENGTH, eFILLFORWARD);
|
|
}
|
|
else if(nCommand == ID_PLACES)
|
|
{
|
|
FillPlacesMenu(hMenu);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
void CMainFrame::FillPlacesMenu(HMENU hMenu)
|
|
{
|
|
CString str;
|
|
int bOK = PREF_NOERROR;
|
|
char * label;
|
|
|
|
for(int i = 0; bOK == PREF_NOERROR ; i++)
|
|
{
|
|
bOK = PREF_CopyIndexConfigString("toolbar.places.item",i,"label",&label);
|
|
if (bOK == PREF_NOERROR && label && label[0]) {
|
|
if (!strcmp(label,"-"))
|
|
AppendMenu(hMenu, MF_SEPARATOR, FIRST_SHORTCUT_ID+i, "");
|
|
else
|
|
AppendMenu(hMenu, MF_STRING, FIRST_SHORTCUT_ID+i, label);
|
|
XP_FREE(label);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//lpttt->szText can only hold 80 characters
|
|
#define MAX_TOOLTIP_CHARS 79
|
|
//status can only hold 1000 characters
|
|
#define MAX_STATUS_CHARS 999
|
|
|
|
LRESULT CMainFrame::OnFillInToolTip(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
HWND hwnd = (HWND)wParam;
|
|
LPTOOLTIPTEXT lpttt = (LPTOOLTIPTEXT) lParam;
|
|
|
|
CToolbarButton *pButton = (CToolbarButton *)CWnd::FromHandle(hwnd);
|
|
UINT nCommand = pButton->GetButtonCommand();
|
|
const char * pTipText = pButton->GetToolTipText();
|
|
const char * pText = NULL;
|
|
if(nCommand == ID_NAVIGATE_BACK || nCommand == ID_NAVIGATE_FORWARD)
|
|
{
|
|
pText = FindHistoryToolTipText(nCommand);
|
|
}
|
|
else if(nCommand == ID_GO_HOME)
|
|
{
|
|
pText = theApp.m_pHomePage;
|
|
}
|
|
else if(nCommand == ID_FILE_PRINT)
|
|
{
|
|
if(GetActiveWinContext() && GetActiveWinContext()->IsGridCell())
|
|
pText = szLoadString(ID_PRINT_FRAME_SELECTED);
|
|
else if(GetMainContext() && GetMainContext()->IsGridParent())
|
|
pText = szLoadString(ID_PRINT_FRAME_NOSELECTION);
|
|
else
|
|
pText = szLoadString(ID_PRINT_PAGE);
|
|
|
|
}
|
|
if(pText == NULL || XP_STRCMP(pText, "") == 0)
|
|
strncpy(lpttt->szText, pTipText, MAX_TOOLTIP_CHARS);
|
|
else
|
|
strncpy(lpttt->szText, pText, MAX_TOOLTIP_CHARS);
|
|
|
|
return 1;
|
|
}
|
|
|
|
LRESULT CMainFrame::OnFillInToolbarButtonStatus(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
UINT nCommand = LOWORD(wParam);
|
|
char *pStatus = (char*)lParam;
|
|
|
|
if(nCommand == ID_FILE_PRINT)
|
|
{
|
|
if(GetActiveWinContext() && GetActiveWinContext()->IsGridCell())
|
|
strncpy(pStatus, szLoadString(ID_PRINT_FRAME_SELECTED), MAX_STATUS_CHARS);
|
|
else if(GetMainContext() && GetMainContext()->IsGridParent())
|
|
strncpy(pStatus, szLoadString(ID_PRINT_FRAME_NOSELECTION), MAX_STATUS_CHARS);
|
|
else
|
|
strncpy(pStatus, szLoadString(ID_PRINT_PAGE), MAX_STATUS_CHARS);
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
void CMainFrame::OnIncreaseFont()
|
|
{
|
|
CGenericFrame::OnIncreaseFont();
|
|
}
|
|
|
|
void CMainFrame::OnDecreaseFont()
|
|
{
|
|
CGenericFrame::OnDecreaseFont();
|
|
}
|
|
|
|
const char *CMainFrame::FindHistoryToolTipText(UINT nCommand)
|
|
{
|
|
|
|
CGenericFrame * pFrame = (CGenericFrame * )FEU_GetLastActiveFrame();
|
|
|
|
if(!pFrame)
|
|
return NULL;
|
|
|
|
CAbstractCX * pCX = pFrame->GetMainContext();
|
|
|
|
if (!pCX)
|
|
return NULL;
|
|
|
|
|
|
// Get the session history list
|
|
XP_List* pList = SHIST_GetList(pCX->GetContext());
|
|
|
|
// Get the pointer to the current history entry
|
|
History_entry* pCurrentDoc = pCX->GetContext()->hist.cur_doc_ptr;
|
|
|
|
XP_List *pCurrentNode = XP_ListFindObject(pList, pCurrentDoc);
|
|
|
|
if (!pCurrentNode)
|
|
return NULL;
|
|
|
|
XP_List *pNode = NULL;
|
|
|
|
if(nCommand == ID_NAVIGATE_FORWARD)
|
|
{
|
|
pNode = pCurrentNode->next;
|
|
}
|
|
else if(nCommand == ID_NAVIGATE_BACK)
|
|
{
|
|
pNode = pCurrentNode->prev;
|
|
}
|
|
|
|
if(pNode == NULL)
|
|
return NULL;
|
|
|
|
History_entry * pEntry = (History_entry*)pNode->object;
|
|
//if the page has no title, then the url is in the title field
|
|
return pEntry->title;
|
|
}
|
|
|
|
void CMainFrame::OnFlushCache()
|
|
{
|
|
FE_FlushCache();
|
|
}
|
|
|
|
void CMainFrame::OnOptionsViewToolBar()
|
|
{
|
|
LPNSTOOLBAR pIToolBar = NULL;
|
|
GetChrome()->QueryInterface(IID_INSToolBar, (LPVOID *) &pIToolBar );
|
|
if ( pIToolBar && pIToolBar->GetHWnd() ) {
|
|
if (::IsWindowVisible( pIToolBar->GetHWnd()) ) {
|
|
m_bShowToolbar = FALSE;
|
|
} else {
|
|
m_bShowToolbar = TRUE;
|
|
}
|
|
pIToolBar->Show( m_bShowToolbar );
|
|
pIToolBar->Release();
|
|
}
|
|
}
|
|
|
|
void CMainFrame::OnHelpMenu()
|
|
{
|
|
CGenericFrame::OnHelpMenu();
|
|
}
|
|
|
|
//
|
|
// Toggle the starter bar
|
|
//
|
|
void CMainFrame::OnOptionsShowstarterbuttons()
|
|
{
|
|
}
|
|
|
|
void CMainFrame::OnUpdateOptionsShowstarterbuttons(CCmdUI* pCmdUI)
|
|
{
|
|
}
|
|
|
|
// Post a close message on the approprate system command, can't let
|
|
// it handle or we GPF when closing the minimized main window.
|
|
void CMainFrame::OnSysCommand(UINT nID, LPARAM lParam)
|
|
{
|
|
if(nID == SC_CLOSE) {
|
|
PostMessage(WM_CLOSE);
|
|
return;
|
|
}
|
|
|
|
CGenericFrame::OnSysCommand(nID, lParam);
|
|
}
|
|
|
|
|
|
// No meaning in generic frame windows?
|
|
// The only possible thing to undo is typing in the URL/Location edit field
|
|
void CMainFrame::OnUpdateEditUndo(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable(FALSE);
|
|
}
|