/* -*- 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.
 */

// genframe.cpp : implementation file
//

#include "stdafx.h"
#include "confhook.h"
#ifdef MOZ_MAIL_NEWS
#include "mailfrm.h"
#endif
#ifdef EDITOR
#include "edt.h"
#endif
#include "winclose.h"
#include "prefapi.h"
#ifdef MOZ_OFFLINE
#include "dlgdwnld.h"
#endif
#include "genchrom.h"
#include "intl_csi.h"
#include "quickfil.h"
#ifndef XP_WIN16
#include "navFram.h"
#endif

#include "property.h"

#ifdef _WIN32
#include "intelli.h"
#endif

#ifdef JAVA
#include "java.h"
#endif

// for whitebox testing
//#define DEBUG_WHITEBOX
#ifdef DEBUG_WHITEBOX
#include "TestcaseDlg.h"
#endif

extern void wfe_Progress(MWContext *pContext, const char *pMessage);

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

//CLM: Global in TEMPLATE.CPP - saves last frame location
//     for new window postioning - cleared in ::OnClose method here
extern CGenericFrame *wfe_pLastFrame;

//
// Bookmark stuff
// 

// This is used to remember the number of existing menu items on the
// bookmark menu before we add the bookmark items. We need this so we
// know how many menu items to delete when the menu goes away
static int      nExistingBookmarkMenuItems;

// We destroy the menu items we added when we receive the WM_MENUSELECT.
// Because Windows sends the WM_MENUSELECT that the menu is going away
// before they send the WM_COMMAND, we need to remember the last menu item
// selected and its data (i.e. URL address or History_entry*)
static UINT     nLastSelectedCmdID;
static void*    nLastSelectedData;

// Macro to use for graying toolbar and menu items
//  when we don't have a context or it is in "waiting" mode
// This is used by both Navigator and Composer frames,
//  so we check if Editor is blocked
#define CAN_INTERACT_IF_EDITOR  (GetMainContext() != NULL && GetMainContext()->GetContext() != NULL \
                       && !GetMainContext()->GetContext()->waitingMode  \
                       && (!EDT_IS_EDITOR(GetMainContext()->GetContext()) \
						   || !EDT_IsBlocked(GetMainContext()->GetContext())))

#ifndef _AFXDLL
#undef new
#endif
IMPLEMENT_DYNCREATE(CNSGenFrame, CFrameWnd)
#ifndef _AFXDLL
#define new DEBUG_NEW
#endif
/////////////////////////////////////////////////////////////////////////////
// CGenericFrame

#ifndef _AFXDLL
#undef new
#endif
IMPLEMENT_DYNCREATE(CGenericFrame, CNSGenFrame)
#ifndef _AFXDLL
#define new DEBUG_NEW
#endif

// The Event Handler
static void qfNotifyProcedure (HT_Notification ns, HT_Resource n, HT_Event whatHappened) 
{
	if (whatHappened == HT_EVENT_NODE_OPENCLOSE_CHANGED)
	{
		// The node was opened.
		PRBool openState;
		HT_GetOpenState(n, &openState);
		if (openState)
		{
			CGenericFrame* pFrame = (CGenericFrame*)ns->data;
			pFrame->FinishMenuExpansion(n);
		}
	}
}

CGenericFrame::CGenericFrame()
{
	// Construct the notification struct used by HT
	HT_Notification ns = new HT_NotificationStruct;
	ns->notifyProc = qfNotifyProcedure;
	ns->data = this;

	m_BookmarkMenuPane = theApp.m_bInGetCriticalFiles ? NULL : HT_NewQuickFilePane(ns);
	m_nBookmarkItems = 0;
	m_nFileBookmarkItems = 0;
    m_pHotlistMenuMap = new CMapWordToPtr();
	m_isClosing = FALSE;
#ifdef XP_WIN32
	m_pSubmenuMap = new CMapPtrToPtr();
#else
	m_pSubmenuMap = new CMapWordToPtr();
#endif

#ifdef XP_WIN32
	m_pFileSubmenuMap = new CMapPtrToPtr();
#else
	m_pFileSubmenuMap = new CMapWordToPtr();
#endif

	m_pBookmarkBitmap = NULL;
	m_pBookmarkFolderBitmap = NULL;
	m_pBookmarkFolderOpenBitmap = NULL;
	m_pBookmarksMenu = NULL;
	m_BookmarksGarbageList = NULL;
	m_OriginalBookmarksGarbageList = NULL;

#ifdef _WIN32
	m_pMenuMap = new CMapPtrToPtr();
#else
	m_pMenuMap = new CMapWordToPtr();
#endif

#ifdef EDITOR
	extern void FED_SetupStrings(void);
	FED_SetupStrings();
    m_bCloseFrame = FALSE;
    m_bSkipSaveEditChanges = FALSE;
#endif

	//	Initially we'll be allowing the frame to resize.
	m_bCanResize = TRUE;
	m_bDisableHotkeys = FALSE;
	m_bPreCreated = FALSE;
	m_bZOrderLocked = FALSE;
	m_bBottommost = FALSE;

	m_pChrome = NULL;
	m_wAddedExStyles = 0L;
	m_wRemovedExStyles = 0L;

	m_hPopupParent = NULL;
	m_bConference = FALSE;

#ifdef XP_WIN32
	// jliu added the following to support CJK caption print
	m_bActive = FALSE;
	m_csid    = CIntlWin::GetSystemLocaleCsid();
	SetupCapFont( m_csid );		// setup the default font first
	DWORD dwVersion = ::GetVersion();
	if( LOBYTE(dwVersion) < 4 )
		capStyle = DT_CENTER;	// for NT 3.51
	else
		capStyle = DT_LEFT;		// for NT 4.0 and Win95
#endif
}



#ifdef XP_WIN32
// jliu added the following to support CJK caption print
int16 CGenericFrame::GetTitleWinCSID()
{
	CWinCX *pContext = GetMainWinContext();
	MWContext* pMWContext = NULL;
	if( pContext == NULL || ( pMWContext = pContext->GetContext() ) == NULL ){
		return -1;
	}
	INTL_CharSetInfo csi = LO_GetDocumentCharacterSetInfo(pMWContext);
	
	return INTL_GetCSIWinCSID(csi);
}

////////////////////////////////////////////////////////////////////
// this function is called outside to get the wincsid
// and then setup the Caption Font.
//
void CGenericFrame::SetupCapFont( int16 csid, BOOL force )
{
	if( !force && ( m_csid == csid ) && ( hCapFont.m_hObject != NULL ) )
		return;

	// set the wincsid
	if( csid <= 0 )
		m_csid = CIntlWin::GetSystemLocaleCsid();
	else
		m_csid = csid;

	// set the caption print font
	if( hCapFont.m_hObject != NULL )
		hCapFont.DeleteObject();

	// get the system caption print font first
	NONCLIENTMETRICS nc;
	nc.cbSize = sizeof(NONCLIENTMETRICS);
	BOOL b = SystemParametersInfo( SPI_GETNONCLIENTMETRICS, sizeof(NONCLIENTMETRICS), &nc, 0 );
	XP_ASSERT( b );

	LOGFONT lf = nc.lfCaptionFont;	// get the logic font used to paint the caption
	csid = CIntlWin::GetSystemLocaleCsid();
	if( force || ( m_csid !=  csid ) ){		// in case user changes system font
		lf.lfCharSet = IntlGetLfCharset( m_csid );
 		_tcscpy( lf.lfFaceName, IntlGetUIPropFaceName( m_csid ) );
		hCapFont.CreateFontIndirect( &lf );
	}

	// create the default font if the above step failure
	if( hCapFont.m_hObject == NULL ){
		hCapFont.CreateFontIndirect( &nc.lfCaptionFont );
		m_csid = csid;
	}
}

//////////////////
// User changed system settings, such  as font. Or changed
// encoding method, coming from compfrm.cpp
// Invalidate everything to generate anew.
// 
LRESULT CGenericFrame::OnSettingChange( WPARAM, LPARAM )
{
	SetupCapFont( GetTitleWinCSID(), TRUE );
	SendMessage(WM_NCPAINT);
	return 0;
}


//////////////////
// Someone called SetWindowText: paint new text.
//
LRESULT CGenericFrame::OnSetText(WPARAM wParam, LPARAM lParam)
{
	SetupCapFont( GetTitleWinCSID() );

	// Turn WS_VISIBLE style off before calling Windows to
	// set the text, then turn it back on again after.
	//
	DWORD dwStyle = GetStyle();
	if( dwStyle & WS_VISIBLE )
		SetWindowLong( m_hWnd, GWL_STYLE, dwStyle & ~WS_VISIBLE );
	LRESULT lRet = DefWindowProc(WM_SETTEXT, wParam, lParam); 
	if( dwStyle & WS_VISIBLE )
		SetWindowLong( m_hWnd, GWL_STYLE, dwStyle );

	SendMessage(WM_NCPAINT);	// paint non-client area (frame too)

	return lRet;
}

//////////////////
// Non-client area (de)activated: paint it
//
BOOL CGenericFrame::OnNcActivate(BOOL bActive)
{
	if( m_nFlags & WF_STAYACTIVE )
		bActive = TRUE;
	if( !IsWindowEnabled() )
		bActive = FALSE;
	if( bActive == m_bActive )	
		return TRUE;

	MSG& msg = AfxGetThreadState()->m_lastSentMsg;
	if( msg.wParam > 1 )
		msg.wParam = TRUE;
	m_bActive = bActive = msg.wParam;

	// Turn WS_VISIBLE off before calling DefWindowProc,
	// so DefWindowProc won't paint and thereby cause flicker.
	//
	DWORD dwStyle = GetStyle();
	if( dwStyle & WS_VISIBLE )
		::SetWindowLong(m_hWnd, GWL_STYLE, (dwStyle & ~WS_VISIBLE));
	DefWindowProc(WM_NCACTIVATE, bActive, 0L);	// don't call CFrameWnd::OnNcActivate()
	if( dwStyle & WS_VISIBLE )
		::SetWindowLong(m_hWnd, GWL_STYLE, dwStyle);

	SendMessage( WM_NCPAINT );	// paint non-client area and frame

	return TRUE;
}


void CGenericFrame::OnNcPaint()
{
	DWORD dwStyle = GetStyle();
	if( !( dwStyle & WS_CAPTION )  ){
		CFrameWnd::OnNcPaint();			// do the default one first
		return;
	}

	CSize szFrame = (dwStyle & WS_THICKFRAME) ?
		CSize(GetSystemMetrics(SM_CXSIZEFRAME),
			   GetSystemMetrics(SM_CYSIZEFRAME)) :
		CSize(GetSystemMetrics(SM_CXFIXEDFRAME),
				GetSystemMetrics(SM_CYFIXEDFRAME));

	int dxIcon = GetSystemMetrics(SM_CXSIZE); // width of caption icon/button

	// Compute rectangle
	CRect rc;		// window rect in screen coords
	GetWindowRect( &rc );
	rc.left  += szFrame.cx;				// frame
	rc.right -= szFrame.cx;				// frame
	rc.top   += szFrame.cy;				// top = end of frame
	rc.bottom = rc.top + GetSystemMetrics(SM_CYCAPTION)  // height of caption
		- GetSystemMetrics(SM_CYBORDER);				  // minus gray shadow border


	MSG& msg = AfxGetThreadState()->m_lastSentMsg;

	// Don't paint if the caption doesn't lie within the region.
	//
	if (msg.wParam > 1 && !::RectInRegion((HRGN)msg.wParam, &rc)) {
		CFrameWnd::OnNcPaint();			// do the default one first
		return;							// quit
	}


	// setup the update region, include the title text region

	CRect rectCaption;
	GetWindowRect( &rectCaption );

	CWindowDC dc(this);
	CFont* hFontOld = dc.SelectObject( &hCapFont );

	HRGN hRgnCaption = ::CreateRectRgnIndirect(&rc);
	HRGN hRgnNew     = ::CreateRectRgnIndirect(&rc);
	if( msg.wParam > 1 ){
		// wParam is a valid region: subtract caption from it
		::CombineRgn( hRgnNew, (HRGN)msg.wParam, hRgnCaption, RGN_OR );
	} else {
		// wParam is not a valid region: create one that's the whole window
		DeleteObject( hRgnNew );
		hRgnNew = ::CreateRectRgnIndirect(&rectCaption);
	}

	// call the default NcPaint

	WPARAM savewp = msg.wParam;		// save original wParam
	msg.wParam = (WPARAM)hRgnNew;	// set new region for DefWindowProc
	CFrameWnd::OnNcPaint();			// paint the caption bar except title text
	DeleteObject( hRgnCaption );	// clean up
	DeleteObject( hRgnNew );		// clean up
	msg.wParam = savewp;			// restore original wParam


	// Compute rectangle
	// Within the basic button rectangle, Windows 95 uses a 1 or 2 pixel border
	// Icon has 2 pixel border on left, 1 pixel on top/bottom, 0 right
	// Close box has a 2 pixel border on all sides but left, which is zero
	// Minimize button has 2 pixel border on all sides but right.

	rectCaption -= rectCaption.TopLeft(); // convert caption rectangle origin to (0,0)
	rectCaption.left  += (szFrame.cx + 2 + dxIcon);
	rectCaption.right -= (szFrame.cx + 2 + dxIcon);
	rectCaption.top   += szFrame.cy;				// top = end of frame
	rectCaption.bottom = rectCaption.top + GetSystemMetrics(SM_CYCAPTION)	// height of caption
		- GetSystemMetrics(SM_CYBORDER);			// minus gray shadow border


	// i don't know why MS supports this feature ...
	if( ( dwStyle & WS_MAXIMIZEBOX ) || ( dwStyle & WS_MINIMIZEBOX ) ){
		rectCaption.right -= ( dxIcon + 2 + dxIcon );
		if( capStyle != DT_LEFT )	// for NT 3.51
			rectCaption.right += dxIcon + 4;
	}

	// create a brush for caption background
	CBrush brCaption;
	brCaption.CreateSolidBrush(	
		::GetSysColor( m_bActive ? COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION ) );

	CString strTitle;
	GetWindowText( strTitle );

	dc.FillRect(&rectCaption, &brCaption);
	dc.SetTextColor(::GetSysColor(m_bActive ? COLOR_CAPTIONTEXT : COLOR_INACTIVECAPTIONTEXT));
	dc.SetBkMode(TRANSPARENT);

	int titleLen = _tcslen( strTitle );
	UINT cs = capStyle;
	if( cs != DT_LEFT ){	// it is NT 3.51
		CSize size = dc.GetTextExtent( strTitle, titleLen );
		if( size.cx >= rectCaption.Width() )
			cs = DT_LEFT;
	}
	CIntlWin::DrawText( m_csid, (HDC)dc, strTitle.GetBuffer( titleLen ), titleLen,
		&rectCaption, cs|DT_VCENTER|DT_SINGLELINE|DT_END_ELLIPSIS );

	dc.SelectObject(hFontOld);
}

#endif	// #ifdef XP_WIN32


CGenericFrame::~CGenericFrame()
{
	if (m_BookmarkMenuPane)
	{
		HT_DeletePane(m_BookmarkMenuPane);
		m_BookmarkMenuPane = NULL;
	}

#ifdef XP_WIN32
	if( hCapFont.m_hObject != NULL )
		hCapFont.DeleteObject();
#endif

	if (m_pHotlistMenuMap) {
    	delete m_pHotlistMenuMap;
		m_pHotlistMenuMap = NULL;
	}

	if (m_pSubmenuMap) {
		delete m_pSubmenuMap;
		m_pSubmenuMap = NULL;
	}

	if (m_pFileSubmenuMap) {
		delete m_pFileSubmenuMap;
		m_pFileSubmenuMap = NULL;
	}

	if (m_pMenuMap)
	{
		DeleteMenuMapIDs();
		delete m_pMenuMap;
		m_pMenuMap = NULL;
	}

	if (m_pChrome) {
		m_pChrome->Release();
	}

    // Remove it from the list of frames kept by theApp
    //  Done here as was done in OnClose, but needed here since
    //      hidden frame when in place never remove's itself from the
    //      list as OnClose never gets called if not active when
    //      deleted.
    if(theApp.m_pFrameList == this) {
        // first one
        theApp.m_pFrameList = m_pNext;

        // Reset the global last frame
        //  (this is unlikely unless we are only frame left)
        if( wfe_pLastFrame == this )
            wfe_pLastFrame = NULL;
    } else {
        // loop through for the one pointing to me
        for(CGenericFrame * f = theApp.m_pFrameList; f; f = f->m_pNext)
            if(f->m_pNext == this){
                // Change the "last frame" to the one before
                if( wfe_pLastFrame == this )
                    wfe_pLastFrame = f;    
                f->m_pNext = m_pNext;
            }
    }
}

#define SEPARATORS_BEFORE_BOOKMARKS_START 2
#define ITEMS_BEFORE_BOOKMARKS_START 6
#define ITEMS_AFTER_BOOKMARKS_END 0

void CGenericFrame::BuildDirectoryMenu(CMenu * pMenu) 
{
	if (!pMenu) return; 
	if(GetMainContext() == NULL)    {
		return;
	}

    int idx =0, idx2=0;
    int iItems = pMenu->GetMenuItemCount();	
    char *label;
	int bOK = PREF_NOERROR;
  
    for (idx=0; bOK==PREF_NOERROR; idx++) {
		bOK = PREF_CopyIndexConfigString("menu.places.item",idx,"label",&label);

		// if the label is blank, truncate the menu here.
		if (!label || !label[0])
			bOK = PREF_ERROR;

		if (bOK == PREF_NOERROR) {
			if (idx < iItems) {
				if (!strcmpi("SEPARATOR",label) || !strcmpi("-",label))
					pMenu->ModifyMenu(CASTUINT(idx),CASTUINT(MF_BYPOSITION | MF_SEPARATOR),NULL,"");
				else
					pMenu->ModifyMenu(CASTUINT(idx),CASTUINT(MF_BYPOSITION | MF_STRING),CASTUINT(FIRST_PLACES_MENU_ID + idx),label);
			} else {
				if (!strcmpi("SEPARATOR",label) || !strcmpi("-",label))
					pMenu->InsertMenu(CASTUINT(idx),CASTUINT(MF_BYPOSITION | MF_SEPARATOR),NULL,"");
				else
					pMenu->InsertMenu(CASTUINT(idx),CASTUINT(MF_BYPOSITION | MF_STRING),CASTUINT(FIRST_PLACES_MENU_ID + idx),label);
			}
		}
		if (label) {
			XP_FREE(label);
			label = NULL;
		}
    }
}            

void CGenericFrame::BuildFileBookmarkMenu(CTreeMenu* pMenu, HT_Resource pRoot) 
{
	char *entryName;

	entryName = HT_GetNodeName(pRoot);

	if(strcmp(entryName, "") == 0)
		entryName = szLoadString(IDS_UNTITLED_FOLDER);

	CTreeItem *item= new CTreeItem(NULL, NULL, FIRST_FILE_BOOKMARK_MENU_ID + m_nFileBookmarkItems, CString(entryName));

	pMenu->AddItem(item, 0, NULL);
	m_pHotlistMenuMap->SetAt(FIRST_FILE_BOOKMARK_MENU_ID + m_nFileBookmarkItems++,	pRoot);

	pMenu->InsertMenu(FIRST_FILE_BOOKMARK_MENU_ID + m_nFileBookmarkItems++, MF_BYPOSITION | MF_SEPARATOR);

	m_BookmarksGarbageList->Add(item);
	CTreeItem *pItem;

	HT_Cursor theCursor = HT_NewCursor(pRoot);
	HT_Resource pEntry = NULL;
	while (pEntry = HT_GetNextItem(theCursor))
	{
		if(HT_IsContainer(pEntry))
		{
			entryName = HT_GetNodeName(pEntry);
			
			if(strcmp(entryName, "") == 0)
				entryName = szLoadString(IDS_UNTITLED_FOLDER);

			pItem= new CTreeItem(NULL, NULL, FIRST_FILE_BOOKMARK_MENU_ID + m_nFileBookmarkItems, FEU_EscapeAmpersand(CString(entryName)));
			pMenu->AddItem(pItem, FIRST_FILE_BOOKMARK_MENU_ID + m_nFileBookmarkItems, NULL);
			m_pHotlistMenuMap->SetAt(FIRST_FILE_BOOKMARK_MENU_ID + m_nFileBookmarkItems++, pEntry);
			m_BookmarksGarbageList->Add(pItem);
		}
	}

}

// Append menu items for each of the bookmark entries in pRoot. Uses
// member data m_nBookmarkItems
void CGenericFrame::BuildBookmarkMenu(CTreeMenu* pMenu, HT_Resource pRoot, int nStart) 
{
	ASSERT(pMenu && pRoot);
	if (!pMenu || !pRoot)
		return;

	m_pCachedTreeMenu = pMenu;
	m_nCachedStartPoint = nStart;

	// Send the open/close event.
	PRBool isOpen;
	HT_GetOpenState(pRoot, &isOpen);
	if (!isOpen)
	{
		HT_SetOpenState(pRoot, PR_TRUE);
	}
	else FinishMenuExpansion(pRoot);
}

void CGenericFrame::FinishMenuExpansion(HT_Resource pRoot)
{
	CTreeMenu* pMenu = m_pCachedTreeMenu;
	int nStart = m_nCachedStartPoint;

	// See how big the menu can be. Menus taller than the screen cause GPFs and hangs
	// Do we want this static?  In Win95, menu font can change and this may no longer
	// be valid after the first time through
    //static int nItemHeight = GetSystemMetrics(SM_CYMENU);
	int nItemHeight = GetSystemMetrics(SM_CYMENU);
    static int nScreenHeight = GetSystemMetrics(SM_CYSCREEN);

    // While we have more items in the list and we haven't run out of screen
    // real-estate continue to add items
    BOOL        bStillRoom = TRUE;
    int         nItemsAdded = pMenu->GetMenuItemCount(); // remember the constant items

	HT_Cursor theCursor = HT_NewCursor(pRoot);
	HT_Resource pEntry = NULL;
	while (theCursor && (pEntry = HT_GetNextItem(theCursor)) && bStillRoom)
	{
    	char*   lpszShortName = NULL;
		CString	csAmpersandName;
	
		// Don't add more menu items than we can handle
		if((FIRST_BOOKMARK_MENU_ID + m_nBookmarkItems) > LAST_BOOKMARK_MENU_ID) 
			break;

		// fe_MiddleCutString() doesn't like NULL pointers
		if (HT_GetNodeName(pEntry)){
			lpszShortName = fe_MiddleCutString(HT_GetNodeName(pEntry), MAX_MENU_ITEM_LENGTH);
			csAmpersandName = FEU_EscapeAmpersand(CString(lpszShortName));
		}

		// If this is a nested list or an item we must have a name
		if ( !lpszShortName && !HT_IsSeparator(pEntry)) 
			continue;

		if (HT_IsSeparator(pEntry)) 
		{
			// Handle separators
			pMenu->InsertMenu(nStart, MF_BYPOSITION | MF_SEPARATOR);
		} 
		else if (HT_IsContainer(pEntry))
		{
			// Append a nested pop-up menu. We add an empty menu now, and when
			// the user displays the sub-menu we dynamically add the menu items.
			// This is faster, and it uses fewer USER resources (big deal for
			// Win16)

			CTreeMenu *pSubMenu=new CTreeMenu;
			pSubMenu->CreatePopupMenu();

			IconType nIconType = DetermineIconType(pEntry, FALSE);
			void* pCustomIcon = NULL;
			if (nIconType == LOCAL_FILE)
				pCustomIcon = FetchLocalFileIcon(pEntry);
			else if (nIconType == ARBITRARY_URL)
				pCustomIcon = FetchCustomIcon(pEntry, pMenu, FALSE);
			CTreeItem *item= new CTreeItem(m_pBookmarkFolderBitmap, m_pBookmarkFolderOpenBitmap,
										   (UINT)pSubMenu->GetSafeHmenu(),csAmpersandName, pSubMenu);

			pSubMenu->SetParent(this);
			pMenu->AddItem(item, nStart, pSubMenu, pCustomIcon, nIconType);
			m_BookmarksGarbageList->Add(item);
		
			// Add the HMENU to the map. We need to do this because Windows doesn't
			// allow any client data to be associated with menu items. We can't use
			// the same map as we use for menu items, because sub-menus don't have
			// command IDs
			m_pSubmenuMap->SetAt(pSubMenu->GetSafeHmenu(), pEntry);
		}
		else
		{
			// We're an URL
			IconType nIconType = DetermineIconType(pEntry, FALSE);
			void* pCustomIcon = NULL;
			if (nIconType == LOCAL_FILE)
				pCustomIcon = FetchLocalFileIcon(pEntry);
			else if (nIconType == ARBITRARY_URL)
				pCustomIcon = FetchCustomIcon(pEntry, pMenu, FALSE);
			CTreeItem *item= new CTreeItem(m_pBookmarkBitmap, m_pBookmarkBitmap, 
				FIRST_BOOKMARK_MENU_ID + m_nBookmarkItems, csAmpersandName);

			pMenu->AddItem(item, nStart, NULL, pCustomIcon, nIconType);
			m_BookmarksGarbageList->Add(item);
		
			// Add the URL to the map. We need to do this because Windows doesn't
			// allow any client data to be associated with menu items. Note that
			// we aren't making a copy of the string
			m_pHotlistMenuMap->SetAt(FIRST_BOOKMARK_MENU_ID + m_nBookmarkItems,
				HT_GetNodeURL(pEntry));
		} 	

		// Even though separators and pull-right sub-menus don't have command IDs,
		// increment the count of bookmark items for all three, because we rely
		// on this being greater than zero to indicate that we have already built
		// the bookmark menu
		m_nBookmarkItems++;

		// In all three cases we added a new menu item
		nItemsAdded++;

		nStart++;

		// Make sure we haven't grown too much -- allow to fill 4/5 of the
		// screen
		if ((nItemsAdded * nItemHeight > nScreenHeight * 4 / 5)) 
		{
			// Stop adding new ones
			bStillRoom = FALSE;

			// Let the user know we have truncated the list
			CTreeItem *item= new CTreeItem(NULL, NULL, ID_HOTLIST_VIEW, szLoadString(IDS_MORE_BOOKMARKS));

			pMenu->AddItem(item, nStart, NULL);
			m_BookmarksGarbageList->Add(item);
		}

		if (lpszShortName)
			XP_FREE(lpszShortName);
	}
}


BEGIN_MESSAGE_MAP(CGenericFrame, CFrameWnd)
    ON_WM_TIMER()
    ON_WM_ENTERIDLE()
    ON_WM_CLOSE()
	ON_WM_DESTROY()
	ON_WM_CREATE()
	ON_WM_SYSCOLORCHANGE()
	ON_WM_QUERYNEWPALETTE()
	ON_WM_PALETTECHANGED()
    ON_WM_INITMENUPOPUP()
	ON_WM_MENUSELECT()
	ON_WM_MEASUREITEM()
	ON_WM_MENUCHAR()
	ON_MESSAGE(WM_SETMESSAGESTRING, OnSetMessageString)
	ON_WM_SETFOCUS()
	ON_WM_WINDOWPOSCHANGED()
	ON_WM_WINDOWPOSCHANGING()
	ON_WM_SIZE()
	ON_WM_MOVE()
	ON_WM_GETMINMAXINFO()
	ON_WM_SETFOCUS()
	ON_WM_WINDOWPOSCHANGED()
	ON_WM_ACTIVATE()

    ON_COMMAND(ID_FILE_CLOSE, OnFrameExit)
	ON_COMMAND(ID_FILE_PAGE_SETUP, OnFilePageSetup)
	ON_COMMAND(ID_OPEN_MAIL_WINDOW, OnOpenMailWindow)
	ON_COMMAND(ID_OPEN_NEWS_WINDOW, OnOpenNewsWindow)
    ON_COMMAND(ID_WINDOW_BOOKMARKWINDOW, OnShowBookmarkWindow)
    ON_COMMAND(ID_WINDOW_ADDRESSBOOK, OnShowAddressBookWindow)
#ifdef JAVA
    ON_COMMAND(ID_OPTIONS_SHOWJAVACONSOLE, OnToggleJavaConsole)
    ON_UPDATE_COMMAND_UI(ID_OPTIONS_SHOWJAVACONSOLE, OnUpdateJavaConsole)
#endif
	ON_COMMAND(ID_FILE_MAILNEW, OnFileMailNew) 
#ifdef MOZ_TASKBAR
	ON_COMMAND(ID_WINDOW_TASKBAR, OnTaskbar)
#endif /* MOZ_TASKBAR */
	ON_COMMAND(ID_WINDOW_LIVECALL, OnLiveCall)
	ON_UPDATE_COMMAND_UI(ID_WINDOW_LIVECALL, OnUpdateLiveCall)
	ON_COMMAND(ID_WINDOW_CALENDAR, OnCalendar)
	ON_COMMAND(ID_WINDOW_IBMHOSTONDEMAND, OnIBMHostOnDemand)
	ON_COMMAND(ID_WINDOW_NETCASTER, OnNetcaster)
	ON_COMMAND(ID_WINDOW_AIM, OnAim)
	ON_COMMAND(ID_COMMAND_ABOUT, OnAbout)
    ON_COMMAND(ID_APP_ABOUT, OnAbout)
    ON_COMMAND(ID_DOCUMENT_TOP, OnDocumentTop)
    ON_COMMAND(ID_DOCUMENT_BOTTOM, OnDocumentBottom)
    ON_COMMAND(ID_HOTLIST_FISHCAM, OnFishCam)
    ON_COMMAND(ID_OPTIONS_PREFERENCES, OnDisplayPreferences)
    ON_COMMAND(ID_OPTIONS_MAILANDNEWS, OnPrefsMailNews)
    ON_COMMAND(ID_BIG_SWITCH, OnGoOffline)
	ON_UPDATE_COMMAND_UI(ID_BIG_SWITCH, OnUpdateGoOffline)
    ON_COMMAND(ID_DONEGOINGOFFLINE, OnDoneGoingOffline)
#ifdef FORTEZZA
    ON_COMMAND(ID_FORTEZZA_CARD, OnStartFortezzaCard)
    ON_COMMAND(ID_FORTEZZA_CHANGE, OnStartFortezzaChange)
    ON_COMMAND(ID_FORTEZZA_VIEW, OnStartFortezzaView)
    ON_COMMAND(ID_FORTEZZA_INFO, OnDoFortezzaInfo)
    ON_COMMAND(ID_FORTEZZA_LOG, OnDoFortezzaLog)
#endif
    ON_COMMAND(ID_FILE_CLOSE, OnFrameExit)

	ON_UPDATE_COMMAND_UI(ID_VIEW_COMMANDTOOLBAR, OnUpdateViewCommandToolbar)
	ON_COMMAND(ID_VIEW_COMMANDTOOLBAR, OnViewCommandToolbar)
	ON_UPDATE_COMMAND_UI(ID_VIEW_LOCATIONTOOLBAR, OnUpdateViewLocationToolbar)
	ON_COMMAND(ID_VIEW_LOCATIONTOOLBAR, OnViewLocationToolbar)
	ON_UPDATE_COMMAND_UI(ID_VIEW_CUSTOMTOOLBAR, OnUpdateViewCustomToolbar)
	ON_COMMAND(ID_VIEW_CUSTOMTOOLBAR, OnViewCustomToolbar)
	ON_UPDATE_COMMAND_UI(ID_VIEW_NAVCENTER, OnUpdateViewNavCenter)
	ON_COMMAND(ID_VIEW_NAVCENTER, OnViewNavCenter)
	ON_UPDATE_COMMAND_UI(ID_CUSTOMIZE_TOOLBAR, OnUpdateCustomizeToolbar)
	ON_COMMAND(ID_CUSTOMIZE_TOOLBAR, OnCustomizeToolbar)
	ON_UPDATE_COMMAND_UI(ID_PLACES, OnUpdatePlaces)
	ON_UPDATE_COMMAND_UI(ID_SECURITY, OnUpdateSecurity)
	ON_COMMAND(ID_SECURITY, OnSecurity)
    ON_COMMAND(ID_GO_HISTORY, OnGoHistory)

	ON_COMMAND(ID_VIEW_INCREASEFONT, OnIncreaseFont)
	ON_COMMAND(ID_VIEW_DECREASEFONT, OnDecreaseFont)

	ON_COMMAND(ID_ANIMATION_BONK, OnAnimationBonk )

	ON_COMMAND(ID_NEW_FRAME, OnNewFrame)
	ON_UPDATE_COMMAND_UI(ID_NEW_FRAME, OnUpdateNewFrame)
	ON_COMMAND(ID_FILE_OPENURL, OnFileOpenurl)
	ON_UPDATE_COMMAND_UI(ID_FILE_OPENURL, OnUpdateFileOpenurl)

    ON_COMMAND(ID_NEXT_WINDOW, OnNextWindow)
    ON_COMMAND(ID_SAVE_OPTIONS, OnSaveOptions)
    ON_COMMAND(ID_HOTLIST_VIEW,OnShowBookmarkWindow) 
	ON_COMMAND(ID_HOTLIST_ADDCURRENTTOHOTLIST, OnHotlistAddcurrenttohotlist)
	ON_UPDATE_COMMAND_UI(ID_HOTLIST_ADDCURRENTTOHOTLIST, OnUpdateHotlistAddcurrenttohotlist)
	ON_COMMAND(ID_HOTLIST_TOOLBAR, OnHotlistAddcurrenttotoolbar)
	ON_UPDATE_COMMAND_UI(ID_HOTLIST_TOOLBAR, OnUpdateHotlistAddcurrenttotoolbar)
#ifdef MOZ_TASKBAR
	ON_UPDATE_COMMAND_UI(ID_WINDOW_TASKBAR, OnUpdateTaskbar)
#endif /* MOZ_TASKBAR */   
	ON_COMMAND(ID_TOOLS_MAIL, OnOpenMailWindow)
	ON_COMMAND(ID_TOOLS_INBOX, OnOpenInboxWindow)
	ON_COMMAND(ID_TOOLS_NEWS, OnOpenNewsWindow)
	ON_COMMAND(ID_TOOLS_WEB, OnToolsWeb)
#ifdef EDITOR
	ON_COMMAND(ID_TOOLS_EDITOR, OnOpenComposerWindow)
#endif
#ifdef MOZ_MAIL_NEWS   
	ON_COMMAND(ID_TOOLS_ADDRESSBOOK, OnShowAddressBookWindow)
#endif /* MOZ_MAIL_NEWS */  
	ON_COMMAND(ID_TOOLS_BOOKMARKS, OnShowBookmarkWindow)
	ON_COMMAND(ID_VIEW_ADVANCEDTOOLBARS, OnShowAdvanced)
	ON_COMMAND(ID_EDIT_LDAPSEARCH, OnLDAPSearch)
	ON_UPDATE_COMMAND_UI(ID_VIEW_ADVANCEDTOOLBARS, OnUpdateShowAdvanced)
    ON_REGISTERED_MESSAGE(WM_FINDREPLACE, OnFindReplace)
    ON_COMMAND(IDM_SEARCHADDRESSES, OnLDAPSearch)
	ON_COMMAND(ID_COMMAND_PAGE_FROM_WIZARD, OnPageFromWizard)
    ON_REGISTERED_MESSAGE(WM_HELPMSG, OnHelpMsg)


#ifdef ON_COMMAND_RANGE
        ON_COMMAND_RANGE(ID_OPTIONS_ENCODING_1, ID_OPTIONS_ENCODING_70, OnToggleEncoding)
        ON_UPDATE_COMMAND_UI_RANGE(ID_OPTIONS_ENCODING_1, ID_OPTIONS_ENCODING_70, OnUpdateEncoding)
#endif

#ifdef EDITOR
	ON_COMMAND(ID_EDT_NEW_DOC_BLANK, OnEditNewBlankDocument)
  	ON_UPDATE_COMMAND_UI(ID_EDT_NEW_DOC_BLANK, OnUpdateCanInteract)
    ON_COMMAND(ID_ACTIVATE_SITE_MANAGER, OnActivateSiteManager)
    ON_UPDATE_COMMAND_UI(ID_ACTIVATE_SITE_MANAGER, OnUpdateActivateSiteManager)
	ON_COMMAND(ID_EDIT_DOCUMENT, OnNavigateToEdit)
	ON_COMMAND(ID_EDIT_FRAME, OnEditFrame)
	ON_UPDATE_COMMAND_UI(ID_EDIT_DOCUMENT, OnUpdateCanInteract)
	ON_UPDATE_COMMAND_UI(ID_EDIT_FRAME, OnUpdateEditFrame)
	ON_COMMAND(ID_EDT_NEW_DOC_FROM_TEMPLATE, OnEditNewDocFromTemplate)
  	ON_UPDATE_COMMAND_UI(ID_EDT_NEW_DOC_FROM_TEMPLATE, OnUpdateCanInteract)
#ifdef XP_WIN32
    ON_REGISTERED_MESSAGE(WM_SITE_MANAGER, OnSiteMgrMessage)
	// jliu added the following to support CJK caption print
	ON_WM_NCPAINT()
	ON_MESSAGE(WM_SETTEXT, OnSetText)
	ON_WM_NCACTIVATE()
	ON_MESSAGE(WM_SETTINGCHANGE, OnSettingChange)
#endif
    ON_REGISTERED_MESSAGE(WM_NG_IS_ACTIVE, OnNetscapeGoldIsActive)
    ON_REGISTERED_MESSAGE(WM_OPEN_EDITOR, OnOpenEditor)
    ON_REGISTERED_MESSAGE(WM_OPEN_NAVIGATOR, OnOpenNavigator)
#endif // EDITOR
	ON_COMMAND(ID_COMMAND_HELPINDEX, OnHelpMenu)
	ON_UPDATE_COMMAND_UI(ID_BOOKMARKS_FILEROOT, OnUpdateFileRoot)

//  Conditionally compile these if supported.
#ifdef WM_DEVICECHANGE
    ON_WM_DEVICECHANGE()
#endif
#ifdef WM_SIZING
	ON_WM_SIZING()
#endif

#ifdef _WIN32
    ON_REGISTERED_MESSAGE(msg_MouseWheel, OnHackedMouseWheel)
#endif

#ifdef DEBUG_WHITEBOX
	ON_COMMAND(IDS_WHITEBOX_MENU, OnWhiteBox)
#endif
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CGenericFrame message handlers

void CGenericFrame::RecalcLayout ( BOOL bNotify )
{
    for(CGenericFrame * f = theApp.m_pFrameList; f; f = f->m_pNext)
        f->CFrameWnd::RecalcLayout ( );
}

void CGenericFrame::GetMessageString( UINT nID, CString& rMessage ) const
{
	LPTSTR lpsz = NULL;
	if (nID >= FIRST_BOOKMARK_MENU_ID && nID <= LAST_BOOKMARK_MENU_ID) {
		m_pHotlistMenuMap->Lookup(nID, (void*&)lpsz);
		if (lpsz) {
			rMessage = lpsz;
		}
	} else if (IS_PLACESMENU_ID(nID)  || IS_HELPMENU_ID(nID)) {
		rMessage = "";  // for now -- jonm
	} else if (nID==ID_COMMAND_HELPINDEX) {
		rMessage = szLoadString(IDS_COMMAND_HELPINDEX);
	} else if (nID==ID_COMMAND_ABOUT) {
		rMessage = szLoadString(IDS_COMMAND_ABOUT);
	} else {
#ifdef _WIN32
		if ( nID ) {
			CFrameWnd::GetMessageString( nID, rMessage );
		}
#else
		// Use the wParam as a string ID
		lpsz = szLoadString(nID);
		// If we got an empty string, punt
		if (lpsz && lpsz[0]) {
			// Only display until the newline so we don't get the tool tip string
			AfxExtractSubString( rMessage, lpsz, 0 );
		}
#endif
	}
}

// Read the initial sizes out of preferences file
//
BOOL CGenericFrame::PreCreateWindow(CREATESTRUCT& cs)
{
	BOOL retval;

	if(m_hPopupParent)
		cs.style |= WS_POPUP;

	m_bPreCreated = TRUE;

	// Let's sanity check those values, kiddies

	if ( cs.x > ( GetSystemMetrics(SM_CXFULLSCREEN) - 100 ) ) {
		cs.x = GetSystemMetrics(SM_CXFULLSCREEN) - 100;
	}
	if ( cs.y > ( GetSystemMetrics(SM_CYFULLSCREEN) - 100 ) ) {
		cs.y = GetSystemMetrics(SM_CYFULLSCREEN) - 100;
	}
       
	retval = CFrameWnd::PreCreateWindow(cs);


#ifdef WIN32
	// Modify Ex_Styles set by MFC.
	cs.dwExStyle |= m_wAddedExStyles;
        cs.dwExStyle &= ~m_wRemovedExStyles;
#endif

        return(retval);
}

//
// Create widgets used by all frame windows 
//
static void CopyMenu(CMenu *srcMenu, CTreeMenu *destMenu, CTreeItemList *pGarbageList)
{
	if (!srcMenu)
	    return;

	int nCount = srcMenu->GetMenuItemCount();
	for(int dstPos = 0, srcPos = 0; dstPos< nCount; dstPos++, srcPos++)
	{
		UINT nID = srcMenu->GetMenuItemID(srcPos);
		
		if(nID == 0)
		{
			destMenu->InsertMenu(dstPos, MF_BYPOSITION | MF_SEPARATOR);
		}
		else
		{
			char lpszMenuString[64];
			
			srcMenu->GetMenuString(srcPos, lpszMenuString, 64, MF_BYPOSITION);
			CString menuString(lpszMenuString);
			int nMnemonicPos;
			TCHAR cMnemonicChar = 0;

			if((nMnemonicPos = menuString.Find('&')) != -1)
				if(nMnemonicPos + 1 < menuString.GetLength())
					cMnemonicChar = menuString[nMnemonicPos + 1];

			if(nID == (UINT) -1)
			{
				CMenu *pSubMenu = srcMenu->GetSubMenu(srcPos);
				CTreeMenu *pTreeSubMenu=new CTreeMenu;

				pTreeSubMenu->CreatePopupMenu();
				
				CopyMenu(pSubMenu, pTreeSubMenu, pGarbageList);

				srcMenu->RemoveMenu(srcPos, MF_BYPOSITION);
				CTreeItem *pItem= new CTreeItem(NULL, NULL,(UINT)pTreeSubMenu->GetSafeHmenu(), menuString, pTreeSubMenu);
				((CTreeMenu*)destMenu)->AddItem(pItem, dstPos,pTreeSubMenu );

				if(cMnemonicChar != 0)
					destMenu->AddMnemonic(cMnemonicChar, 0, dstPos);

				pGarbageList->Add(pItem);
				//since we removed a menu we want to use the same position next time
				//and there is one less item in the menu we are copying.
				srcPos--;
			}
			else if(nID > 0)
			{
				CTreeItem *pItem= new CTreeItem(NULL, NULL, nID, lpszMenuString);
				((CTreeMenu*)destMenu)->AddItem(pItem, dstPos);

				if(cMnemonicChar != 0)
					destMenu->AddMnemonic(cMnemonicChar, nID, dstPos);

				pGarbageList->Add(pItem);
				//destMenu->InsertMenu(i, MF_BYPOSITION | MF_STRING, nID, (const char*)menuString);
			}
		}
	}
	((CTreeMenu*)destMenu)->CalculateItemDimensions();

}


void CGenericFrame::InitFileBookmarkMenu(void)
{
	int nCount = m_pFileBookmarkMenu->GetMenuItemCount();

	for(int i = nCount - 1; i >=0; i--)
		m_pFileBookmarkMenu->DeleteMenu(i, MF_BYPOSITION);
	m_pFileBookmarkMenu->ClearItems(0, 0);
	m_pFileSubmenuMap->RemoveAll();

	HT_View pView = HT_GetSelectedView(m_BookmarkMenuPane);

	m_pFileSubmenuMap->SetAt(m_pFileBookmarkMenu->GetSafeHmenu(), HT_TopNode(pView));
}

void CGenericFrame::LoadBookmarkMenuBitmaps(void)
{
	HDC hDC = ::GetDC(m_hWnd);

	WFE_InitializeUIPalette(hDC);
	HPALETTE hPalette = WFE_GetUIPalette(this);
	m_pBookmarksMenu->SetParent(this);
	HPALETTE hOldPalette = ::SelectPalette(hDC, hPalette, FALSE);
	m_pBookmarkBitmap=new CBitmap;
	m_pBookmarkBitmap->Attach(wfe_LoadBitmap(AfxGetResourceHandle(), hDC, MAKEINTRESOURCE(IDB_BOOKMARK_ITEM)));

	m_pBookmarkFolderBitmap=new CBitmap;
	m_pBookmarkFolderBitmap->Attach(wfe_LoadBitmap(AfxGetResourceHandle(), hDC, MAKEINTRESOURCE(IDB_BOOKMARK_FOLDER2)));

	m_pBookmarkFolderOpenBitmap=new CBitmap;
	m_pBookmarkFolderOpenBitmap->Attach(wfe_LoadBitmap(AfxGetResourceHandle(), hDC, MAKEINTRESOURCE(IDB_BOOKMARK_FOLDER_OPEN)));

	::SelectPalette(hDC, hOldPalette, TRUE);
	::ReleaseDC(m_hWnd, hDC);
}

void CGenericFrame::AddToMenuMap(int nIndex, UINT nID)
{
	HMENU hMainMenu = ::GetMenu(m_hWnd);
	
	if(hMainMenu)
	{
		HMENU hSubMenu = ::GetSubMenu(hMainMenu, nIndex);

		if(hSubMenu && m_pMenuMap)
		{
			UINT * pID = new UINT;
			
			if(pID)
			{
				*pID = nID;
#ifdef _WIN32
				m_pMenuMap->SetAt(hSubMenu, pID);
#else
				m_pMenuMap->SetAt((WORD)hSubMenu, pID);
#endif
			}
		}

	}

}

void CGenericFrame::OnDestroy()
{
	ASSERT(!m_pHotlistMenuMap || m_pHotlistMenuMap->IsEmpty());
	ASSERT(!m_pSubmenuMap || m_pSubmenuMap->IsEmpty());
//	ASSERT(!m_pFileSubmenuMap || m_pFileSubmenuMap->IsEmpty());

	// Unload the bookmark bitmaps and delete them
	if ( m_pBookmarkBitmap ) {
		m_pBookmarkBitmap->DeleteObject();
		m_pBookmarkFolderBitmap->DeleteObject();
		m_pBookmarkFolderOpenBitmap->DeleteObject();
	}
	delete m_pBookmarkBitmap;
	delete m_pBookmarkFolderBitmap;
	delete m_pBookmarkFolderOpenBitmap;
	if ( m_pBookmarksMenu ) {
		HMENU hBookmarkMenu=m_pBookmarksMenu->m_hMenu;
		ASSERT(hBookmarkMenu);
		int nCount;
		if ((nCount = ::GetMenuItemCount(hBookmarkMenu)) > 0) {


			// Because the bookmark menu has separators and pull-right sub-menus,
			// neither of which have command IDs, we can't tell just by looking
			// at the menu items whether they should be deleted. So instead we
			// delete everything
			for (int i = nCount - 1;
				 i >= 0; i--) {
				// This will delete any sub-menus as well (recursively)
				if(m_pBookmarksMenu->GetSubMenu(i) != NULL)
					m_pBookmarksMenu->GetSubMenu(i)->DestroyMenu();
				VERIFY(::DeleteMenu(hBookmarkMenu, i, MF_BYPOSITION));
			}
			//don't care about separator before bookmarks
			m_pBookmarksMenu->ClearItems(0, 0);
			m_nBookmarkItems = 0;  // reset the number of current bookmark menu items
			delete m_OriginalBookmarksGarbageList;
		}

		m_pBookmarksMenu->DestroyMenu();
	}
	delete m_pBookmarksMenu;
    
    //
    // Explicitly destroy the status bar window.  Normally the status bar is a child of this
    // frame and receives a WM_DESTROY as a result of this window destroying.  However, when 
    // this frame is serving an OLE container the status bar's parent is the container, hence
    // we need to destroy the window now.  Note the status bar is an auto-delete CWnd object.
    //
 	LPNSSTATUSBAR pIStatusBar = NULL;
 	if( GetChrome() && 
        SUCCEEDED(GetChrome()->QueryInterface( IID_INSStatusBar, (LPVOID *)&pIStatusBar )) && 
        pIStatusBar ) 
 	{
        CNetscapeStatusBar *pStatusBar = ((CGenericStatusBar *)pIStatusBar)->GetNetscapeStatusBar();
        
        if( pStatusBar )
        {
            pStatusBar->DestroyWindow();
        }
 		pIStatusBar->Release();
 	}
    
	// we no longer need a taskbar.
#ifdef MOZ_TASKBAR
	theApp.GetTaskBarMgr().Reference(FALSE);
#endif /* MOZ_TASKBAR */   

}

BOOL CGenericFrame::OnQueryNewPalette() 
{
	// Have the main context in this window realize its palette.
	CWinCX *pWinCX = GetMainWinContext();
	CView* focusWnd = GetActiveView();
	BOOL retval = FALSE;
	HPALETTE hPal = WFE_GetUIPalette(this);	
	if (pWinCX) {
		if (!pWinCX->IsDestroyed()) {
		//	Make sure this is needed.
			if(pWinCX->GetPalette() != NULL) {
				//	Realize the palette.
				retval = CFrameGlue::GetFrameGlue(this)->RealizePalette(this, pWinCX->GetPane(), FALSE);
			}
		}
	}
	else  {
		CDC* pDC = GetDC();
		if (pDC) {
			::SelectPalette(pDC->GetSafeHdc(), hPal, FALSE);
			retval = ::RealizePalette(pDC->GetSafeHdc());
			Invalidate();
			SendMessageToDescendants(WM_PALETTECHANGED, (WPARAM)GetSafeHwnd());
#ifdef MOZ_TASKBAR
			if(theApp.GetTaskBarMgr().IsInitialized() && theApp.GetTaskBarMgr().IsFloating())
				theApp.GetTaskBarMgr().ChangeTaskBarsPalette(GetSafeHwnd());
#endif /* MOZ_TASKBAR */
			ReleaseDC(pDC);
		}

	}
	return retval;	
}

// Only top-level windows will receive this message
void CGenericFrame::OnPaletteChanged(CWnd* pFocusWnd) 
{

//	CFrameWnd::OnPaletteChanged(pFocusWnd);
	
	//	Don't do this if we caused it to happen.
	if(pFocusWnd == (CWnd *)this)	{
		return;
	}

	TRACE("CGenericFrame::OnPaletteChanged(%p)\n", pFocusWnd);
	// Tell the main context to realize the palette and redraw.		   f
	CWinCX *pWinCX = GetActiveWinContext();
	if(pWinCX && !pWinCX->IsDestroyed())	{
        HPALETTE pPal = pWinCX->GetPalette();
		//	Make sure this is needed.
		if( pPal )	{
			//	Realize the palette.
            //	Detect if it's a child view, and don't do anything.	 If we cause a
			//  palette change.

			if ((IsChild(pFocusWnd) == TRUE) && FEU_IsNetscapeFrame(pFocusWnd)) {
					TRACE("Blocking child view palette change\n");
            }
			else {
				// Either a plug-in or a Java child window realized its
				// palette, or a different top-level window realized
				// its palette.  Realize the Navigator's palette in
				// the background.
					CFrameGlue::GetFrameGlue(this)->RealizePalette(this, pFocusWnd->GetSafeHwnd(), TRUE);
			}
		}
	}
}
extern void FE_PokeLibSecOnIdle();

BOOL CGenericFrame::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo) 
{

   if( nID >= ID_OPTIONS_ENCODING_1 && nID <= ID_OPTIONS_ENCODING_70 && 
       (nCode == CN_UPDATE_COMMAND_UI))  
   {
          OnUpdateEncoding( (CCmdUI*) pExtra );
          return TRUE;
   }
    // give me extra randomness for the first couple of messages
    static int s_nLibSecCount = 0;
    if(s_nLibSecCount < 300) {
        FE_PokeLibSecOnIdle();
        s_nLibSecCount++;
    }
        

	//	Pump through any active child first.
	//	This will catch active control bars, etc.
	CWnd *pFocus = GetFocus();
	if( pFocus )	{
		//	Make sure it's a child of us, and not a CGenericView (we handle those below).
		//	Also make sure it's not a child of our main view.
		//		Those are handled by the view, not us.
		BOOL bFrameChild = IsChild(pFocus);
		BOOL bGenericView = pFocus->IsKindOf(RUNTIME_CLASS(CGenericView));
		BOOL bViewChild = FALSE;
		if(GetMainWinContext() && GetMainWinContext()->GetPane())	{
            bViewChild = ::IsChild(GetMainWinContext()->GetPane(), pFocus->m_hWnd);
		}

		if(bFrameChild == TRUE && bGenericView == FALSE && bViewChild == FALSE)	{
			//	Try an OnCmdMessage, probably a URL bar, or message list.
			//	Walk up the list of parents until we reach ourselves.
			CWnd *pTarget = pFocus;
			while(pTarget != NULL && pTarget != (CWnd *)this)	{
				if(pTarget->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))	{
					return(TRUE);
				}
				pTarget = pTarget->GetParent();
				
                //  There are cases now where a child is actually a CGenericView
                //      such as the NavCenter HTML pane.  Do not allow it to
                //      receive these messages.
                if(pTarget->IsKindOf(RUNTIME_CLASS(CGenericView))) {
                    pTarget = NULL;
                }
			}
		}
	}

	//	Pump the message through our active context first.
    CWinCX *pActiveCX = GetActiveWinContext();
    CGenericView *pGenView = pActiveCX ? pActiveCX->GetView() : NULL;
    if(pGenView)    {
        if(pGenView->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))  {
            return(TRUE);
        }
    }

	//	Next, pump the message through our main context.
    pActiveCX = GetMainWinContext();
    pGenView = pActiveCX ? pActiveCX->GetView() : NULL;
    if(pGenView)    {
        if(pGenView->OnCmdMsg(nID, nCode, pExtra, pHandlerInfo))  {
            return(TRUE);
        }
    }

    // always enable bookmark entries
    if((nID >= FIRST_BOOKMARK_MENU_ID) && (nID < LAST_BOOKMARK_MENU_ID) && (nCode == CN_UPDATE_COMMAND_UI))  {
        ASSERT(pExtra);
        CCmdUI* pCmdUI = (CCmdUI*)pExtra;
        pCmdUI->Enable();
        return(TRUE);
    }

    // always enable windows menu entries
    if((nID >= ID_WINDOW_WINDOW_0) && (nID < ID_WINDOW_WINDOW_0 + 10) && (nCode == CN_UPDATE_COMMAND_UI))  {
        ASSERT(pExtra);
        CCmdUI* pCmdUI = (CCmdUI*)pExtra;
        pCmdUI->Enable();
        return(TRUE);
    }

    // was this a windows menu selection ?
    if((nID >= ID_WINDOW_WINDOW_0) && (nID < ID_WINDOW_WINDOW_0 + 10) && (nCode == CN_COMMAND))  {
        CGenericFrame * pFrame = theApp.m_pFrameList;
		BOOL bDone = FALSE;
        // walk down frame list till we get to the one we wanted
        int iToGo = CASTINT(nID - ID_WINDOW_WINDOW_0);
        while( pFrame && !bDone ) {
			if (iToGo == 0) {
				bDone = TRUE;
	            break;
			} else {
				iToGo--;
				// Fall through to default to move to next frame.
			}
			pFrame = pFrame->m_pNext;
        }

        // if we got something un-minimize it and pop it to the front
        if(pFrame) {
            if(pFrame->IsIconic())  {
                pFrame->ShowWindow(SW_RESTORE);
            }
            pFrame->BringWindowToTop();
        }

        // assume we got something or at least the message was for us
        return(TRUE);
    }

	// then pump through frame  
	return(CFrameWnd::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo));
}


#ifdef EDITOR
// Used to gray menu/toolbar commands depending on presence of
//   context and its loading and blocked states
void CGenericFrame::OnUpdateCanInteract(CCmdUI* pCmdUI)
{
	pCmdUI->Enable(GetMainWinContext() && GetMainWinContext()->GetContext());
}

void CGenericFrame::OnUpdateEditFrame(CCmdUI *pCmdUI)
{
    // enable EditFrame menu only if a frame in a frameset is selected.
	pCmdUI->Enable(GetActiveWinContext() && GetActiveWinContext()->GetContext() && GetActiveWinContext()->IsGridCell());
}


//
// NOTE: Editor-related methods of CGenericFrame are in EDFRAME.CPP
//
#endif // EDITOR

void CGenericFrame::BuildHelpMenu(CMenu * pMenu) 
{
	if (!pMenu) return; 
	if(GetMainContext() == NULL)	{
		return;
	}
	//static bChanged = TRUE;
	
	//if (!bChanged) return;

    int idx =0, idx2=0;
    int iItems = pMenu->GetMenuItemCount();	
    char *label;
	int bOK = PREF_NOERROR;

	CString helpContents;
	helpContents.LoadString(IDS_HELPCONTENTS);
	if (idx < iItems) 
		pMenu->ModifyMenu(idx,MF_BYPOSITION | MF_STRING,ID_COMMAND_HELPINDEX, helpContents);
	else
		pMenu->InsertMenu(idx,MF_BYPOSITION | MF_STRING,ID_COMMAND_HELPINDEX, helpContents);

    for (idx=1; bOK==PREF_NOERROR; idx++) {
		bOK = PREF_CopyIndexConfigString("menu.help.item",idx,"label",&label);
		
		// if the label is blank, truncate the menu here.
		if (!label || !label[0])
			bOK = PREF_ERROR;

		if (bOK == PREF_NOERROR) {
			if (idx < iItems) {
				if (!strcmpi("SEPARATOR",label) || !strcmpi("-",label))
					pMenu->ModifyMenu(idx,MF_BYPOSITION | MF_SEPARATOR,NULL,"");
				else
					pMenu->ModifyMenu(CASTUINT(idx),CASTUINT(MF_BYPOSITION | MF_STRING),CASTUINT(FIRST_HELP_MENU_ID + idx),label);
			} else {
				if (!strcmpi("SEPARATOR",label) || !strcmpi("-",label))
					pMenu->InsertMenu(idx,MF_BYPOSITION | MF_SEPARATOR,NULL,"");
				else
					pMenu->InsertMenu(CASTUINT(idx),CASTUINT(MF_BYPOSITION | MF_STRING),CASTUINT(FIRST_HELP_MENU_ID + idx),label);
			}
		}
		if (label) {
			XP_FREE(label);
			label = NULL;
		}
    }

	//  Add about page item
	//  Must be done here, such that choice is always
	//      available.
	CString aboutCommunicator;
	aboutCommunicator.LoadString(IDS_ABOUTNETSCAPE);

	if (idx < iItems) 
		pMenu->ModifyMenu(idx,MF_BYPOSITION | MF_STRING,ID_COMMAND_ABOUT, aboutCommunicator);
	else
		pMenu->InsertMenu(idx,MF_BYPOSITION | MF_STRING,ID_COMMAND_ABOUT, aboutCommunicator);
}

/****************************************************************************
*
*	CGenericFrame::OnToolsWeb
*
*	PARAMETERS:
*		None
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		Handles the Tools->Web menu item, and can be called by anyone else
*		(such as the task bar) that wants to perform the trick of getting the
*		proper browser window up.
*
****************************************************************************/

void CGenericFrame::OnToolsWeb()
{
	// TODO - not exactly to spec yet...
	
	// Single click on web icon means bring forth the browser window
	CAbstractCX * pCX = GetMainContext();
	if (pCX != NULL)
	{
		int nCount = FEU_GetNumActiveFrames(MWContextBrowser);
		
		if((nCount == 1 && pCX->GetContext()->type == MWContextBrowser && !EDT_IS_EDITOR(pCX->GetContext())) || nCount == 0)
			pCX->NewWindow();
		else if(nCount > 1 || !(pCX->GetContext()->type == MWContextBrowser && !EDT_IS_EDITOR(pCX->GetContext())))
		{
			CFrameWnd *pFrame;

			//if we are a browser then get the bottom most browser
			if(pCX->GetContext()->type == MWContextBrowser)
			{
				pFrame = FEU_GetBottomFrame(MWContextBrowser);
			}
			else
			// if we are not a browser, then get the last active browser
				pFrame = FEU_GetLastActiveFrame(MWContextBrowser);

			if(pFrame)
			{
				if(pFrame->IsIconic())
		            pFrame->ShowWindow(SW_RESTORE);

#ifdef _WIN32
				pFrame->SetForegroundWindow();
#else
				pFrame->SetActiveWindow();
#endif
			}
		}
	}
			
} // END OF	FUNCTION CGenericFrame::OnToolsWeb()

//
// Build the "Window" menu 
//
void CGenericFrame::OnConstructWindowMenu(CMenu * pPopup)
{
	UINT nFlags = MF_STRING | MF_ENABLED; 

    ASSERT(pPopup);
    if(!pPopup)
        return;

	if(theApp.m_hPostalLib)
		FEU_AltMail_SetAltMailMenus(pPopup); 

    // delete the old menu items
	int index = 0;
	UINT nID = 0;
    int iCount = pPopup->GetMenuItemCount();

	while ( index < iCount && nID != ID_WINDOW_WINDOW_0 ) {
		nID = pPopup->GetMenuItemID(index);
		if (nID != ID_WINDOW_WINDOW_0)
			index++;
	}

	while ( iCount > index ) {
		pPopup->RemoveMenu(index, MF_BYPOSITION);
		iCount--;
	}
    
    // list windows here

    CGenericFrame * pFrame = NULL;
    int nItemCount = 0;

	// We can't have more than 10 window menu items because we only reserved 10 IDs. Sigh.
    for(pFrame = theApp.m_pFrameList; pFrame && nItemCount < 10; pFrame = pFrame->m_pNext) {
        CAbstractCX * pContext = pFrame->GetMainContext();

        // all better be enabled
        nFlags = MF_STRING | MF_ENABLED;
        if(!pContext)
            continue;

        MWContext * pXPContext = pContext->GetContext();
        if(!pXPContext)
            continue;

        if(pFrame == this)
            nFlags |= MF_CHECKED;

  		CString csContext = "";
		CString csTitle;

		csContext.Format(_T("&%d "), nItemCount);
		csTitle.LoadString(IDS_TITLE_NOTITLE);

		switch (pXPContext->type) {
		case MWContextBrowser:
            if( EDT_IS_EDITOR(pXPContext) ){
			    csContext += szLoadString(IDS_TITLE_COMPOSE_PAGE);
            } else {
			    csContext += szLoadString(IDS_TITLE_WEB);
            }
			break;
#ifdef MOZ_MAIL_NEWS         
		case MWContextMessageComposition:
			csContext += szLoadString(IDS_TITLE_COMPOSE_MESSAGE);
			csTitle.LoadString(IDS_TITLE_NOSUBJECT);
			break;
		case MWContextMail:
		case MWContextMailMsg:
			if ( pFrame->IsKindOf( RUNTIME_CLASS( CMailNewsFrame ) ) ) {
				csContext += ((CMailNewsFrame *) pFrame)->GetWindowMenuTitle();
			}
			break;
		case MWContextAddressBook:
			csContext += szLoadString( IDS_TITLE_ADDRESSBOOK );
			break;
#endif /* MOZ_MAIL_NEWS */        
		case MWContextBookmarks:
			csContext += szLoadString( IDS_TITLE_BOOKMARKS );
			break;
		default:
			continue;
		}

		switch (pXPContext->type) {
		case MWContextMessageComposition:
		case MWContextBrowser:
			if(pXPContext->title) {
				csContext += fe_MiddleCutString(pXPContext->title, 40);
			} else {
				csContext += csTitle;
			}
			break;
		}

        if(pFrame == this)
            nFlags |= MF_CHECKED;
		pPopup->AppendMenu( nFlags, CASTUINT(ID_WINDOW_WINDOW_0 + nItemCount), csContext);

        // we added an item
        nItemCount++;
    }

    // keep windows happy
    DrawMenuBar();
}

// this deletes all of the UINT * nIDs stored in the menu map.
void CGenericFrame::DeleteMenuMapIDs(void)
{
	if(!m_pMenuMap)
		return;

	POSITION pos = m_pMenuMap->GetStartPosition();
	HMENU hMenu;
	UINT * pID;

	while(pos != NULL)
	{
		pID = NULL;
#ifdef _WIN32
		m_pMenuMap->GetNextAssoc( pos, (void*&)hMenu, (void*&)pID );
#else
		m_pMenuMap->GetNextAssoc( pos, (WORD&)hMenu, (void*&)pID );
#endif
		if(pID)
		{
			delete pID;
		}

	}


}

// This copies src into dest.
static void CopyMenu(CMenu *srcMenu, CMenu *destMenu)
{
	if (!srcMenu)
	    return;

	int nCount = srcMenu->GetMenuItemCount();
	for(int dstPos = 0, srcPos = 0; dstPos< nCount; dstPos++, srcPos++)
	{
		UINT nID = srcMenu->GetMenuItemID(srcPos);
		
		// it's a separator
		if(nID == 0)
		{
			destMenu->InsertMenu(dstPos, MF_BYPOSITION | MF_SEPARATOR);
		}
		else
		{
			char lpszMenuString[64];
			
			srcMenu->GetMenuString(srcPos, lpszMenuString, 63, MF_BYPOSITION);
			CString menuString(lpszMenuString);

			// it's a submenu
			if(nID == (UINT) -1)
			{
				CMenu *pSubMenu = srcMenu->GetSubMenu(srcPos);
				CMenu *pNewSubMenu=new CMenu;
		
				if(pNewSubMenu)
				{
					pNewSubMenu->CreatePopupMenu();
					
					CopyMenu(pSubMenu, pNewSubMenu);
					destMenu->InsertMenu(dstPos, MF_STRING | MF_BYPOSITION | MF_POPUP, (UINT)pNewSubMenu->m_hMenu, menuString);
					// detach and delete the submenu created above.
					pNewSubMenu->Detach();
					delete pNewSubMenu;
				}

			}
			// it's a regular menu item.
			else if(nID > 0)
			{
				destMenu->InsertMenu(dstPos, MF_BYPOSITION | MF_STRING, nID, menuString);
			}
		}
	}

}

//  This loads a menu from the menubar dynamically
void CGenericFrame::LoadFrameMenu(CMenu *pPopup, UINT nIndex)
{
	
	CMenu *pMenu = GetMenu();

	if(pMenu)
	{
		CMenu *pSubMenu = pMenu->GetSubMenu(nIndex);
		// verify that this menu is on the main menubar.
		if(pSubMenu && (pSubMenu == pPopup))
		{
			UINT * pID;
			// find the resource id associated with the menu
#ifdef _WIN32
			if(m_pMenuMap && m_pMenuMap->Lookup(pPopup->m_hMenu, (void*&)pID))
#else
			if(m_pMenuMap && m_pMenuMap->Lookup((WORD)pPopup->m_hMenu, (void*&)pID))
#endif
			{
				// clear everything out
				int nCount = pPopup->GetMenuItemCount();
				for(int i = nCount - 1; i >= 0; i--)
				{
					pPopup->DeleteMenu(i, MF_BYPOSITION);
				}

				CMenu *pSrcPopup = new CMenu();
				if(pSrcPopup && pID)
				{
					// load the menu and copy it into pPopup.
					if(pSrcPopup->LoadMenu(*pID));	
						CopyMenu(pSrcPopup, pPopup);
					delete pSrcPopup;
				}
			}
		}
	}

}

// Delete the menu items in the menus in m_pMenuMap
void CGenericFrame::DeleteMenuMapMenus(void)
{
	if(!m_pMenuMap)
		return;

	POSITION pos = m_pMenuMap->GetStartPosition();
	HMENU hMenu;
	UINT * pID;

	while(pos != NULL)
	{
		hMenu = NULL;
#ifdef _WIN32
		m_pMenuMap->GetNextAssoc( pos, (void*&)hMenu, (void*&)pID );
#else
		m_pMenuMap->GetNextAssoc( pos, (WORD&)hMenu, (void*&)pID );
#endif
		if(hMenu)
		{
			DeleteFrameMenu(hMenu);
		}

	}


}

void CGenericFrame::DeleteFrameMenu(HMENU hMenu)
{
	if(hMenu)
	{
		int nCount = ::GetMenuItemCount(hMenu);

		// It's easiest to do this by walking backwards over the menu items
		for (int i = nCount - 1; i >= 0; i--) {
			VERIFY(::DeleteMenu(hMenu, i, MF_BYPOSITION));
		}
	}

}



void CGenericFrame::OnInitMenuPopup(CMenu * pPopup, UINT nIndex, BOOL bSysMenu) 
{
	AfxLockTempMaps();
	// load this menu if it needs to be loaded dynamically.
	LoadFrameMenu(pPopup, nIndex);
	CFrameWnd::OnInitMenuPopup(pPopup, nIndex, bSysMenu);
	if (!bSysMenu)
	{
		if( m_pBookmarksMenu && pPopup->m_hMenu == m_pBookmarksMenu->m_hMenu)
		{
			m_BookmarksGarbageList = new CTreeItemList;

			// 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
			//
			// Note: we use a different check to tell whether the menu has been
			// built. We do this because the bookmark menu can have pull-right
			// sub-menus and separators, neither of which have command IDs. That
			// means the check we use for history elements won't work
			if (m_nBookmarkItems == 0) {
				// Before we add the menu items, get the number of existing
				// menu items. We need to know this so we can remove the items
				// we have added
				nExistingBookmarkMenuItems = pPopup->GetMenuItemCount();
		
				// Now go ahead and add the bookmark items
				BuildBookmarkMenu((CTreeMenu*)pPopup,
							  HT_TopNode(HT_GetSelectedView(m_BookmarkMenuPane)),
							  ITEMS_BEFORE_BOOKMARKS_START);

				// if there were any bookmarks, add a separator after them
				int nCount = pPopup->GetMenuItemCount();
				if(nCount > nExistingBookmarkMenuItems && ITEMS_AFTER_BOOKMARKS_END > 0)
					pPopup->InsertMenu(nCount - ITEMS_AFTER_BOOKMARKS_END, MF_SEPARATOR | MF_BYPOSITION);
			}

			((CTreeMenu*)pPopup)->CalculateItemDimensions();		
		}  
		else if (pPopup->GetMenuItemID(0) == IDC_FIRST_PLACES_MENU_ID) 
		{
			BuildDirectoryMenu(pPopup);
		}  
		else if (pPopup->GetMenuItemID(0) == IDC_FIRST_HELP_MENU_ID) 
		{
			BuildHelpMenu(pPopup);
		} 
		else 
		{
			HT_Resource      pEntry;

			// See if this is a bookmark sub-menu
			ASSERT(m_pSubmenuMap);
			if (m_pSubmenuMap->Lookup(pPopup->GetSafeHmenu(), (void*&)pEntry)) 
			{
				// If the menu isn't empty then we've already added the bookmark
				// items
				if (pPopup->GetMenuItemCount() == 0) 
				{
					// Haven't yet added the bookmark menu items for this sub-menu.
					// Do it now
					BuildBookmarkMenu((CTreeMenu*)pPopup, pEntry);
					((CTreeMenu*)pPopup)->CalculateItemDimensions();
				}
			}

			//see if this is a file bookmark sub-menu
			if(pPopup == m_pFileBookmarkMenu)
				InitFileBookmarkMenu();

			if (m_pFileSubmenuMap->Lookup(pPopup->GetSafeHmenu(), (void*&)pEntry)) 
			{

				if(pPopup->GetMenuItemCount()==0)
				{
					BuildFileBookmarkMenu((CTreeMenu*)pPopup, pEntry);
					((CTreeMenu*)pPopup)->CalculateItemDimensions();
				}

			}
			CMenu * pFrameMenu = GetMenu();
			if (pFrameMenu != NULL)
			{
				if ((pPopup != NULL) &&
					(pPopup->GetMenuItemID(0) == ID_TOOLS_WEB))
				{
					OnConstructWindowMenu(pPopup);
				}
				if ((pPopup != NULL) &&
					(pPopup->GetMenuItemID(0) == IDC_FIRST_HELP_MENU_ID))
				{
					BuildHelpMenu(pPopup);
				}
			}
		}
	}
	// This function must always be executed, so please, do NOT put any
	// return statements in the above code!
	AfxUnlockTempMaps();
}

//
// Over-ride this cuz something is writing the status message into
//   pane 0 instead of actually looking up what the correct pane to write into
//   was.
//
LRESULT CGenericFrame::OnSetMessageString(WPARAM wParam, LPARAM lParam)
{
	CString csStatus = _T("");

	// set the message bar text
	if (lParam != NULL)
	{
		ASSERT(wParam == 0);    // can't have both an ID and a string
		// set an explicit string
		csStatus = (LPCSTR)lParam;
	} else {
		GetMessageString( (UINT) wParam, csStatus );
	}

    if( csStatus.IsEmpty() ) {
        CAbstractCX *pContext = GetMainContext();

        if( pContext ) {
            wfe_Progress( pContext->GetContext(), NULL );
        }
    }
    else {
    	CStatusBar* pMessageBar = (CStatusBar *) GetMessageBar();
    	if ( pMessageBar ) {
    		int nIndex = pMessageBar->CommandToIndex( ID_SEPARATOR );
    		if ( nIndex >= 0 ) {
    			pMessageBar->SetPaneText( nIndex, csStatus );
    		}
    	}
    }
	UINT nIDLast = m_nIDLastMessage;
	m_nIDLastMessage = (UINT)wParam;    // new ID (or 0)
	m_nIDTracking = (UINT)wParam;       // so F1 on toolbar buttons work
	return nIDLast;
}

void CGenericFrame::OnMenuSelect(UINT nItemID, UINT nFlags, HMENU hSysMenu)
{
	if ( nFlags == 0xffff ) {
        
 		DeleteMenuMapMenus();

		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 && m_pBookmarksMenu ) {
			int nCount;
			// Menu is going away so destroy all the menu items we added (both
			// bookmark and history). Cleanup the bookmark menu first.
			HMENU hBookmarkMenu=m_pBookmarksMenu->m_hMenu;
			ASSERT(hBookmarkMenu);

			if ((nCount = ::GetMenuItemCount(hBookmarkMenu)) > 
				 ITEMS_BEFORE_BOOKMARKS_START + ITEMS_AFTER_BOOKMARKS_END) {
	
				//FileBookMark is always the first popup menu in the Bookmark menu loop through to find it.
				UINT nfileBookmarksPosition = 0; 
				while(!m_pBookmarksMenu->GetSubMenu(nfileBookmarksPosition) && nfileBookmarksPosition < m_pBookmarksMenu->GetMenuItemCount())
					nfileBookmarksPosition++;
				CTreeMenu *pFileBookmarkMenu = (CTreeMenu*)m_pBookmarksMenu->GetSubMenu(nfileBookmarksPosition);

				// Because the bookmark menu has separators and pull-right sub-menus,
				// neither of which have command IDs, we can't tell just by looking
				// at the menu items whether they should be deleted. So instead we
				// delete everything
				for (int i = nCount - 1 - ITEMS_AFTER_BOOKMARKS_END;
					 i >= ITEMS_BEFORE_BOOKMARKS_START; i--) {
					// This will delete any sub-menus as well (recursively)
					if(m_pBookmarksMenu->GetSubMenu(i) != NULL)
						m_pBookmarksMenu->GetSubMenu(i)->DestroyMenu();
					VERIFY(::DeleteMenu(hBookmarkMenu, i, MF_BYPOSITION));
				}
				//don't care about separator before bookmarks
				m_pBookmarksMenu->ClearItems(ITEMS_BEFORE_BOOKMARKS_START - SEPARATORS_BEFORE_BOOKMARKS_START, 
											 ITEMS_AFTER_BOOKMARKS_END);

				// we also need to delete items added to file bookmarks
	
				nCount = pFileBookmarkMenu->GetMenuItemCount();

				for(i = nCount - 1; i >= 0 ; i--)
				{
					// This will delete any sub-menus as well (recursively)
					if(pFileBookmarkMenu->GetSubMenu(i) != NULL)
						pFileBookmarkMenu->GetSubMenu(i)->DestroyMenu();
					VERIFY(pFileBookmarkMenu->DeleteMenu(i, MF_BYPOSITION));
				}

				pFileBookmarkMenu->ClearItems(0, 0);

				delete m_BookmarksGarbageList;
				m_nBookmarkItems = 0;  // reset the number of current bookmark menu items
				m_nFileBookmarkItems = 0;
			}

			// The maps are no longer needed
			if (m_pHotlistMenuMap)
				m_pHotlistMenuMap->RemoveAll();

			if (m_pSubmenuMap)
				m_pSubmenuMap->RemoveAll();

			if (m_pFileSubmenuMap)
			{
				m_pFileSubmenuMap->RemoveAll();
				// but we need to make sure that the file menu is still in the map.
				//FileBookMark is always the first popup menu in the Bookmark menu loop through to find it.
				UINT nfileBookmarksPosition = 0; 
				while(!m_pBookmarksMenu->GetSubMenu(nfileBookmarksPosition) && nfileBookmarksPosition < m_pBookmarksMenu->GetMenuItemCount())
					nfileBookmarksPosition++;
				CTreeMenu *pFileBookmarkMenu = (CTreeMenu*)m_pBookmarksMenu->GetSubMenu(nfileBookmarksPosition);

				if(pFileBookmarkMenu != NULL)
				{
					m_pFileSubmenuMap->SetAt(pFileBookmarkMenu->GetSafeHmenu(), 
						HT_TopNode(HT_GetSelectedView(m_BookmarkMenuPane)));
				}
			}

		}
	} else if (!(nItemID == 0 || nFlags & (MF_SEPARATOR|MF_POPUP|MF_MENUBREAK|MF_MENUBARBREAK))) {
		// If the menu item is for a bookmark item or history entry, save
		// away the client data for later. We need to do this because Windows
		// sends the WM_COMMAND for a selected menu item after sending the
		// WM_MENUSELECT to indicate the menu has been taken down. Alternatively
		// we could wait to purge the map until later, but Win32 allows client
		// data to be associated with a menu item and there would be no map in that
		// case anyway
		if (IS_BOOKMARK_ID(nItemID) || IS_HISTORY_ID(nItemID)) {
			ASSERT(m_pHotlistMenuMap);

			if (m_pHotlistMenuMap->Lookup(nItemID, nLastSelectedData))
				nLastSelectedCmdID = nItemID;
		}

		if (IS_FILE_BOOKMARK_ID(nItemID)) {
			if(m_pHotlistMenuMap->Lookup(nItemID, nLastSelectedData))
				nLastSelectedCmdID = nItemID;
		}
    } 

#ifdef EDITOR
    // Do Composer stuff
    OnMenuSelectComposer(nItemID, nFlags, hSysMenu);
#endif // EDITOR

    CFrameWnd::OnMenuSelect(nItemID, nFlags, hSysMenu);
}


// Because CTreeMenu's are owner draw, they don't handle mnemonics.  Therefore
// we have to handle them ourselves.
LRESULT CGenericFrame::OnMenuChar( UINT nChar, UINT nFlags, CMenu* pMenu )
{

	LRESULT result = 0;


	if(pMenu == m_pBookmarksMenu)
	{
		int nPosition;
		UINT nCommand;

		if(m_pBookmarksMenu->GetMnemonic(nChar, nCommand, nPosition))
		{
			if(nCommand == 0)
				return MAKELRESULT(nPosition, 2);
			else
			{
				SendMessage(WM_COMMAND, nCommand);
				return MAKELRESULT(0, 1);
			}

		}
    }
	return CFrameWnd::OnMenuChar(nChar, nFlags, pMenu);
}

// Find a popup menu matching the given ID,
//   including searching into submenus
// This is necessary in order to act upon MeasureItem
//  messages in the OnMeasureItem function.  
// Userdata will always be of type CTreeItem *
static CMenu* FindPopupMenu(CMenu* pMenu, UINT nID, DWORD userData)
{
    if( pMenu )
    {
	    int iCount= pMenu->GetMenuItemCount();

	    for( int i = 0; i < iCount; i++ )
	    {
		    CMenu* pPopup = pMenu->GetSubMenu(i);
		    //if it's a submenu then see if it is or if it contains the submenu we want 
		    if( pPopup )
		    {
			    //if the submenu and the menu we are looking for are the same then return this
			    if( (UINT)pPopup->m_hMenu == ((CTreeItem*)userData)->GetID() )
			    {
				    return pMenu;
			    }
			    // otherwise recurse to child popup
			    pPopup = FindPopupMenu( pPopup, nID, userData );

			    // check popups on this popup
			    if( pPopup )
				    return pPopup;
		    }
		    // otherwise check to see if it is the menu item that we want
		    else if( nID == pMenu->GetMenuItemID(i) )
		    {
                return pMenu;
		    }
	    }
    }
	return NULL;
}

/****************************************************************************
*
*	CGenericFrame::OnMeasureItem
*
*	PARAMETERS:
*		nIDCtl	- control ID
*		lpMI	- pointer to MEASUREITEMSTRUCT
*
*	RETURNS:
*		void
*
*	DESCRIPTION:
*		We must override this handler because MFC has a bug that prevents
*		the CMenu::MeasureItem() from being called for owner draw sub-menus.
*
****************************************************************************/

void CGenericFrame::OnMeasureItem(int nIDCtl, LPMEASUREITEMSTRUCT lpMI) 
{
	if (lpMI->CtlType == ODT_MENU)
	{
		ASSERT(lpMI->CtlID == 0);
		CMenu * pMenu = NULL;
		
#if defined(WIN32)
		_AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
		if (pThreadState->m_hTrackingWindow == m_hWnd)
		{
			// start from popup
			pMenu = CMenu::FromHandle(pThreadState->m_hTrackingMenu);
		}
		else
		{
			// start from menubar
			pMenu = GetMenu();
		}
#else	// WIN16
		// start from menubar
		pMenu = GetMenu();
#endif	// WIN32
			
		ASSERT(pMenu != NULL);
		pMenu = FindPopupMenu(pMenu, lpMI->itemID, lpMI->itemData);
		if (pMenu != NULL)
		{
			pMenu->MeasureItem(lpMI);
		}
	}
	else
	{
		// Pass off to base class if not a menu
		CFrameWnd::OnMeasureItem(nIDCtl, lpMI);
	}

} // END OF	FUNCTION CGenericFrame::OnMeasureItem()

//  Scroll to the top of the document
//
void CGenericFrame::OnDocumentTop()  
{
   	MWContext *pContext = GetActiveWinContext() != NULL ? GetActiveWinContext()->GetContext() : NULL;
	if (pContext)
#ifdef EDITOR
		if (EDT_IS_EDITOR(pContext))
            EDT_BeginOfDocument(pContext, FALSE);
        else
#endif // EDITOR
			FE_SetDocPosition(GetActiveWinContext()->GetContext(), FE_VIEW, 0, 0);
}

//  Scroll to the bottom of the document
//
void CGenericFrame::OnDocumentBottom() 
{
   	MWContext *pContext = GetActiveWinContext() != NULL ? GetActiveWinContext()->GetContext() : NULL;
    if (pContext)
#ifdef EDITOR
		if (EDT_IS_EDITOR(pContext))
			EDT_EndOfDocument(pContext, FALSE);
		else
#endif // EDITOR
			FE_SetDocPosition(pContext, FE_VIEW, 0, GetActiveWinContext()->GetDocumentHeight());
}

void CGenericFrame::OnAbout()
{
    CAbstractCX * pContext = GetMainContext();
	if(pContext)	{
        if (pContext->GetContext()->type != MWContextBrowser ||
            EDT_IS_EDITOR(pContext->GetContext()))
    		pContext->NormalGetUrl(szLoadString(IDS_ABOUT_PAGE),NULL,NULL,TRUE);
        else
    		pContext->NormalGetUrl(szLoadString(IDS_ABOUT_PAGE));
	}
}

///////////////////////////////////////////////////////////////////////////////

void CGenericFrame::OnShowBookmarkWindow()
{   
    theApp.CreateNewNavCenter(NULL, TRUE, HT_VIEW_BOOKMARK);
}

///////////////////////////////////////////////////////////////////////////////
#ifdef JAVA
void CGenericFrame::OnToggleJavaConsole()
{
    if( LJ_IsConsoleShowing() ) {
	LJ_HideConsole();
    } else {
	LJ_ShowConsole();
    }
}

void CGenericFrame::OnUpdateJavaConsole(CCmdUI* pCmdUI)
{   
    if (LJJavaStatus_Failed != LJ_GetJavaStatus()) {
        pCmdUI->SetCheck( LJ_IsConsoleShowing() );
    } else {
        pCmdUI->Enable(FALSE);
    }
}
#endif  /* JAVA */

void CGenericFrame::OnTaskbar()
{
#ifdef MOZ_TASKBAR
	if(theApp.GetTaskBarMgr().IsFloating())
		theApp.GetTaskBarMgr().OnDockTaskBar();
	else
		theApp.GetTaskBarMgr().OnUnDockTaskBar();
#endif  /* MOZ_TASKBAR */
}

void CGenericFrame::OnUpdateTaskbar(CCmdUI *pCmdUI)
{
#ifdef MOZ_TASKBAR
	BOOL bUndocked = theApp.GetTaskBarMgr().IsFloating();
    if( pCmdUI->m_pMenu ){
        pCmdUI->m_pMenu->ModifyMenu(CASTUINT(ID_WINDOW_TASKBAR), CASTUINT(MF_BYCOMMAND | MF_STRING), CASTUINT(ID_WINDOW_TASKBAR),
                                    szLoadString(CASTUINT(bUndocked ? IDS_DOCK_TASKBAR : IDS_SHOW_TASKBAR)) );
    } else {
        pCmdUI->SetCheck(bUndocked);
    }
#endif /* MOZ_TASKBAR */


}

void CGenericFrame::OnUpdateLiveCall(CCmdUI* pCmdUI)
{   
    pCmdUI->Enable(m_bConference);
}

void CGenericFrame::OnIBMHostOnDemand()
{

	CString installDirectory, executable;
	
	if(!FEU_IsIBMHostOnDemandAvailable)
		return;

#ifdef WIN32
	CString ibmHostRegistry;

	ibmHostRegistry.LoadString(IDS_3270_REGISTRY);

	ibmHostRegistry = FEU_GetCurrentRegistry(ibmHostRegistry);
	if(ibmHostRegistry.IsEmpty())
		return;

    installDirectory = FEU_GetInstallationDirectory(ibmHostRegistry, szLoadString(IDS_INSTALL_DIRECTORY));
#else ifdef XP_WIN16
    installDirectory = FEU_GetInstallationDirectory(szLoadString(IDS_3270), szLoadString(IDS_INSTALL_DIRECTORY));
#endif
    if(!installDirectory.IsEmpty())

	{
		executable = installDirectory + szLoadString(IDS_3270HTML);

		if(((CDocTemplate *)theApp.m_ViewTmplate)->OpenDocumentFile( executable ))
		{
				return;
		}
	}
	MessageBox(szLoadString(IDS_CANT3270), szLoadString(IDS_IBMHOSTONDEMAND), MB_OK);


 }


void CGenericFrame::OnNetcaster()
{
	FEU_OpenNetcaster() ;
}

void CGenericFrame::OnAim()
{
	FEU_OpenAim();
}

void CGenericFrame::OnCalendar()
{

	if(!FEU_IsCalendarAvailable())
		return;

	CString installDirectory, executable;

#ifdef WIN32
	CString calRegistry;

	calRegistry.LoadString(IDS_CALENDAR_REGISTRY);

	calRegistry = FEU_GetCurrentRegistry(calRegistry);
	if(calRegistry.IsEmpty())
		return;

    installDirectory = FEU_GetInstallationDirectory(calRegistry, szLoadString(IDS_INSTALL_DIRECTORY));
	executable = szLoadString(IDS_CALENDAR32EXE);
#else ifdef XP_WIN16
    installDirectory = FEU_GetInstallationDirectory(szLoadString(IDS_CALENDAR),szLoadString(IDS_INSTALL_DIRECTORY));
	executable = szLoadString(IDS_CALENDAR16EXE);
#endif
    if(!installDirectory.IsEmpty())
	{
		executable = installDirectory + executable;

		if(	WinExec(executable, SW_SHOW) >= 31)
			return;
	}
	MessageBox(szLoadString(IDS_CANTCALENDAR), szLoadString(IDS_CALENDAR), MB_OK);


}
void CGenericFrame::OnShowAdvanced()
{
	int32 prefInt;
	PREF_GetIntPref("browser.chrome.button_style",&prefInt);
	
	prefInt = (prefInt + 1) % 3;  // reverse it!
	PREF_SetIntPref("browser.chrome.button_style",prefInt);
	theApp.m_pToolbarStyle = CASTINT(prefInt);

	//theApp.m_pAdvancedToolbar = theApp.m_pAdvancedToolbar->IsYes() ? "No" : "Yes";

	CGenericFrame *pGenFrame;
	for(pGenFrame = theApp.m_pFrameList; pGenFrame; pGenFrame = pGenFrame->m_pNext) {
		LPNSTOOLBAR pIToolBar = NULL;
		pGenFrame->GetChrome()->QueryInterface( IID_INSToolBar, (LPVOID *) &pIToolBar );
		if (pIToolBar) {
	       pIToolBar->SetToolbarStyle(theApp.m_pToolbarStyle);
		   pIToolBar->Release();
		   pGenFrame->RecalcLayout();
		}
    }
}

void CGenericFrame::OnUpdateShowAdvanced( CCmdUI *pCmdUI )
{
	pCmdUI->SetCheck(theApp.m_pToolbarStyle);
	pCmdUI->Enable(TRUE);
}

void CGenericFrame::OnViewCommandToolbar()
{
	GetChrome()->ShowToolbar(ID_NAVIGATION_TOOLBAR, !GetChrome()->GetToolbarVisible(ID_NAVIGATION_TOOLBAR));
}

void CGenericFrame::OnUpdateViewCommandToolbar(CCmdUI *pCmdUI)
{
	BOOL bShow = GetChrome()->GetToolbarVisible(ID_NAVIGATION_TOOLBAR);
    if( pCmdUI->m_pMenu ){
        pCmdUI->m_pMenu->ModifyMenu(CASTUINT(ID_VIEW_COMMANDTOOLBAR), CASTUINT(MF_BYCOMMAND | MF_STRING), CASTUINT(ID_VIEW_COMMANDTOOLBAR),
                                    szLoadString(CASTUINT(bShow ? IDS_HIDE_COMMANDTOOLBAR : IDS_SHOW_COMMANDTOOLBAR)) );
    } else {
        pCmdUI->SetCheck(bShow);
    }
}

void CGenericFrame::OnViewNavCenter()
{
	CNSNavFrame* pFrame = GetDockedNavCenter();
	if (pFrame)
		pFrame->DeleteNavCenter();
	else theApp.CreateNewNavCenter(this);
}

void CGenericFrame::OnUpdateViewNavCenter(CCmdUI *pCmdUI)
{
	CNSNavFrame* pFrame = GetDockedNavCenter();
	BOOL bShow = (pFrame != NULL);

    if( pCmdUI->m_pMenu )
	{
        pCmdUI->m_pMenu->ModifyMenu(CASTUINT(ID_VIEW_NAVCENTER), CASTUINT(MF_BYCOMMAND | MF_STRING), CASTUINT(ID_VIEW_NAVCENTER),
                                    szLoadString(CASTUINT(bShow ? IDS_HIDE_NAVCENTER : IDS_SHOW_NAVCENTER)) );
    } 
	else 
	{
        pCmdUI->SetCheck(bShow);
    }
}

void CGenericFrame::OnViewLocationToolbar()
{
	GetChrome()->ShowToolbar(ID_LOCATION_TOOLBAR, !GetChrome()->GetToolbarVisible(ID_LOCATION_TOOLBAR));
}

void CGenericFrame::OnUpdateViewLocationToolbar(CCmdUI *pCmdUI)
{
	BOOL bShow = GetChrome()->GetToolbarVisible(ID_LOCATION_TOOLBAR);
    if( pCmdUI->m_pMenu ){
        pCmdUI->m_pMenu->ModifyMenu(CASTUINT(ID_VIEW_LOCATIONTOOLBAR), CASTUINT(MF_BYCOMMAND | MF_STRING), CASTUINT(ID_VIEW_LOCATIONTOOLBAR),
                                    szLoadString(CASTUINT(bShow ? IDS_HIDE_LOCATIONTOOLBAR : IDS_SHOW_LOCATIONTOOLBAR)) );
    } else {
        pCmdUI->SetCheck(bShow);
    }
}

static void
NiceReloadAllWindows()
{
	for(CGenericFrame *f = theApp.m_pFrameList; f; f= f->m_pNext){
		CWinCX *pContext = f->GetMainWinContext();
		if(pContext && pContext->GetContext()) {
#ifdef EDITOR
			if( EDT_IS_EDITOR(pContext->GetContext())) 
				EDT_RefreshLayout(pContext->GetContext());
			else
#endif // EDITOR
				pContext->NiceReload();
		}
	}
}

void CGenericFrame::OnIncreaseFont()
{
	CWinCX *pWinCX = GetActiveWinContext();

	if(!pWinCX)
		pWinCX = GetMainWinContext();

	if(pWinCX)
		pWinCX->ChangeFontOffset(1);

}

int CGenericFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
    if(CFrameWnd::OnCreate(lpCreateStruct) == -1)
        return(-1);

	ApiApiPtr(api);
	LPUNKNOWN pUnk = api->CreateClassInstance(APICLASS_CHROME, NULL);
	if (pUnk) {
		HRESULT hRes = pUnk->QueryInterface(IID_IChrome,(LPVOID*)&m_pChrome);
		ASSERT(hRes==NOERROR);
		pUnk->Release();
		m_pChrome->Initialize(this);
	}

    // guess we made it

	m_bConference = FEU_IsConfAppAvailable();

	CMenu *pMenu=GetMenu();

	#ifdef DEBUG_WHITEBOX
		pMenu->AppendMenu(MF_STRING,IDS_WHITEBOX_MENU,"&WhiteBox");
	#endif

	CString communicatorStr, bookmarksStr, fileBookmarkStr;

	//Communicator is always the second to last menu popup so adjust accordingly
	int nWindowPosition = pMenu->GetMenuItemCount() - 2;

	if(nWindowPosition != -1)
	{
		CMenu *pWindowMenu = pMenu->GetSubMenu(nWindowPosition);

		// Check if we need to add the Calendar menu item

		if(FEU_IsCalendarAvailable())
		{
			int nTaskBarPosition = WFE_FindMenuItem(pWindowMenu, ID_WINDOW_TASKBAR);

			if(nTaskBarPosition != -1)
				pWindowMenu->InsertMenu(nTaskBarPosition - 1, MF_BYPOSITION, ID_WINDOW_CALENDAR, szLoadString(IDS_CALENDAR_MENU));
		}

		if(FEU_IsIBMHostOnDemandAvailable())
		{
			int nTaskBarPosition = WFE_FindMenuItem(pWindowMenu, ID_WINDOW_TASKBAR);

			if(nTaskBarPosition != -1)
				pWindowMenu->InsertMenu(nTaskBarPosition - 1, MF_BYPOSITION, ID_WINDOW_IBMHOSTONDEMAND, szLoadString(IDS_IBMHOSTONDEMAND_MENU));
		}

 		if(FEU_IsNetcasterAvailable())
 		{
 			int nTaskBarPosition = WFE_FindMenuItem(pWindowMenu, ID_WINDOW_TASKBAR);

#ifndef MOZ_TASKBAR
            if (nTaskBarPosition == -1)
                nTaskBarPosition = 2 ;  // Right below &Navigator on Lite version
#endif
 
 			if(nTaskBarPosition != -1)
 				pWindowMenu->InsertMenu(nTaskBarPosition - 1, MF_BYPOSITION, ID_WINDOW_NETCASTER, szLoadString(IDS_NETCASTER_MENU));
 		}
 
		if(FEU_IsAimAvailable())
 		{
 			int nTaskBarPosition = WFE_FindMenuItem(pWindowMenu, ID_WINDOW_TASKBAR);
 
 			if(nTaskBarPosition != -1)
 				pWindowMenu->InsertMenu(nTaskBarPosition - 1, MF_BYPOSITION, ID_WINDOW_AIM, szLoadString(IDS_AIM_MENU));
 		}

#ifdef XP_WIN32
        // We can start or activate LiveWire SiteManager
        //  if we have a registration handle
        if( bSiteMgrIsRegistered ){
			int nTaskBarPosition = WFE_FindMenuItem(pWindowMenu, ID_WINDOW_TASKBAR);

			if(nTaskBarPosition != -1)
				pWindowMenu->InsertMenu(nTaskBarPosition - 1, MF_BYPOSITION, ID_ACTIVATE_SITE_MANAGER, szLoadString(IDS_SITE_MANAGER));
        }
#endif


		// Replace the bookmark menu with a new menu that can have ON_DRAWITEM overridden
		//BookMark is the First Popup in the Communicator Menu so loop through to find it.
		UINT nBookmarksPosition = 0;
		while(!pWindowMenu->GetSubMenu(nBookmarksPosition) && nBookmarksPosition < pWindowMenu->GetMenuItemCount())
			nBookmarksPosition++;

		if(nBookmarksPosition < pWindowMenu->GetMenuItemCount())
		{
			CMenu *pOldBookmarksMenu = pWindowMenu->GetSubMenu(nBookmarksPosition);
			char bookmarksStr[30];

			if(pOldBookmarksMenu)
			{
				m_pBookmarksMenu=new CTreeMenu;

				m_pBookmarksMenu->CreatePopupMenu();
				
				m_OriginalBookmarksGarbageList = new CTreeItemList;

				CopyMenu(pOldBookmarksMenu, m_pBookmarksMenu, m_OriginalBookmarksGarbageList);
				pWindowMenu->GetMenuString(nBookmarksPosition, bookmarksStr, 30, MF_BYPOSITION);
				pWindowMenu->DeleteMenu(nBookmarksPosition, MF_BYPOSITION);
				pWindowMenu->InsertMenu(nBookmarksPosition, MF_BYPOSITION|MF_STRING|MF_POPUP, (UINT)m_pBookmarksMenu->GetSafeHmenu(), bookmarksStr);

				//FileBookmark is the First Popup in the BookMarks Menu so loop through to find it.
				UINT nfileBookmarksPosition = 0;
				while(!m_pBookmarksMenu->GetSubMenu(nfileBookmarksPosition) && nfileBookmarksPosition < m_pBookmarksMenu->GetMenuItemCount())
					nfileBookmarksPosition++;
				m_pFileBookmarkMenu = (CTreeMenu*)m_pBookmarksMenu->GetSubMenu(nfileBookmarksPosition);

				LoadBookmarkMenuBitmaps();
			}
		}

	}

#ifdef MOZ_TASKBAR
	// We use a taskbar
	theApp.GetTaskBarMgr().Reference(TRUE);
#endif // MOZ_TASKBAR
    return 0;
}


void CGenericFrame::OnDecreaseFont()
{
	CWinCX *pWinCX = GetActiveWinContext();

	if(!pWinCX)
		pWinCX = GetMainWinContext();

	if(pWinCX)
		pWinCX->ChangeFontOffset(-1);
}

void CGenericFrame::OnUpdateViewCustomToolbar(CCmdUI *pCmdUI)
{
	BOOL bShow = GetChrome()->GetToolbarVisible(ID_PERSONAL_TOOLBAR);
    if( pCmdUI->m_pMenu ){
        pCmdUI->m_pMenu->ModifyMenu(CASTUINT(ID_VIEW_CUSTOMTOOLBAR), CASTUINT(MF_BYCOMMAND | MF_STRING), CASTUINT(ID_VIEW_CUSTOMTOOLBAR),
                                    szLoadString(CASTUINT(bShow ? IDS_HIDE_CUSTOMTOOLBAR : IDS_SHOW_CUSTOMTOOLBAR)) );
    } else {
        pCmdUI->SetCheck(bShow);
    }
}

void CGenericFrame::OnViewCustomToolbar()
{
	GetChrome()->ShowToolbar(ID_PERSONAL_TOOLBAR, !GetChrome()->GetToolbarVisible(ID_PERSONAL_TOOLBAR));
}

void CGenericFrame::OnCustomizeToolbar()
{
	GetChrome()->Customize();
}

void CGenericFrame::OnUpdateCustomizeToolbar(CCmdUI *pCmdUI)
{
	pCmdUI->Enable(TRUE);
}

void CGenericFrame::OnUpdatePlaces(CCmdUI *pCmdUI)
{
	pCmdUI->Enable(TRUE);
}

void CGenericFrame::OnSaveConfiguration()
{
	// Save out the preferences that might have changed
	PREF_SavePrefFile();

  // Save global configuration stuff
  theApp.WriteProfileString("Main", "Temp Directory", theApp.m_pTempDir); 
    
  // security
  if(theApp.m_nSecurityCheck[SD_ENTERING_SECURE_SPACE])
    theApp.WriteProfileString("Security", "Warn Entering", "yes");
  else 
    theApp.WriteProfileString("Security", "Warn Entering", "no");

  if(theApp.m_nSecurityCheck[SD_LEAVING_SECURE_SPACE])
    theApp.WriteProfileString("Security", "Warn Leaving", "yes");
  else 
    theApp.WriteProfileString("Security", "Warn Leaving", "no");

  if(theApp.m_nSecurityCheck[SD_INSECURE_DOCS_WITHIN_SECURE_DOCS_NOT_SHOWN])
    theApp.WriteProfileString("Security", "Warn Mixed", "yes");
  else 
    theApp.WriteProfileString("Security", "Warn Mixed", "no");
    
  if(theApp.m_nSecurityCheck[SD_INSECURE_POST_FROM_INSECURE_DOC])
    theApp.WriteProfileString("Security", "Warn Insecure Forms", "yes");
  else 
    theApp.WriteProfileString("Security", "Warn Insecure Forms", "no");
}

// For Whitebox testing
#ifdef DEBUG_WHITEBOX
void CGenericFrame::OnWhiteBox() 
{
 	CWhiteBoxDlg WhiteBoxDlg;
	WhiteBoxDlg.DoModal();

}
#endif

/////////////////////////////////////////////////////////////////////////////
// CNetscapePropertySheet dialog

BEGIN_MESSAGE_MAP(CNetscapePropertySheet, CPropertySheet)
	ON_COMMAND(IDOK, OnOK)
    ON_COMMAND(ID_HELP, OnHelp)
    ON_WM_CREATE()
    ON_WM_DESTROY()
#ifdef XP_WIN32
    ON_WM_HELPINFO()
#endif //XP_WIN32
END_MESSAGE_MAP()

CNetscapePropertySheet::CNetscapePropertySheet(const char * pName, CWnd * pParent, UINT nStart,
                                               MWContext *pMWContext, BOOL bUseApplyButton)
    : CPropertySheet(pName, pParent, nStart),
      m_pMWContext(pMWContext),
      m_bUseApplyButton(bUseApplyButton)
{
#if defined(MSVC4) 
    // CLM: For preferences dialogs, ommitting the Apply button is good,
    //  but in the Editor, Apply is very useful, so I added this param
    //  Default behavior is to not use apply button
    if( !bUseApplyButton )
        m_psh.dwFlags |= PSH_NOAPPLYNOW;

#endif
}

void CNetscapePropertySheet::SetPageTitle (int nPage, LPCTSTR pszText)
{
    //TODO: How can we do this in Win16???

#ifndef XP_WIN16
    CTabCtrl* pTab = GetTabControl();
    ASSERT (pTab);
 
    TC_ITEM ti;
    ti.mask = TCIF_TEXT;
    ti.pszText = (char*)pszText;
    VERIFY (pTab->SetItem (nPage, &ti));
#endif

}
 


//
// Pass the help message along to the active page cuz that is the only
//   place we have easy access to the dialog ID
//
void CNetscapePropertySheet::OnHelp()
{
    CNetscapePropertyPage * pPage = (CNetscapePropertyPage *) GetActivePage();
    if(pPage)
        pPage->OnHelp();
}
                          

#ifdef XP_WIN32
BOOL CNetscapePropertySheet::OnHelpInfo(HELPINFO *)//32bit messagemapping.
{
    OnHelp();
    return TRUE;
}
#endif//XP_WIN32

//
// MFC's OnOK() only calls for current page, we want to do all pages
//
void CNetscapePropertySheet::OnOK()
{

	ASSERT_VALID(this);

#if defined(MSVC4)
    // Save active page to pass out after we close down
    m_nCurrentPage = GetActiveIndex();
#endif

    if (GetActivePage()->OnKillActive())
	{
        // call OnOK for everyone
        int count = m_pages.GetSize();
        for(int i = 0; i < count; i++)
            ((CPropertyPage *) m_pages[i])->OnOK();

		if (!m_bModeless)
			EndDialog(IDOK);
	}

}

#if defined(MSVC4)
//
// Make sure the starting page is actually a page that exists
//
BOOL CNetscapePropertySheet::SetCurrentPage(int iPage)
{
	int nCurPage = 0;

    if(iPage < m_pages.GetSize())
        nCurPage = iPage;

    m_nCurrentPage = nCurPage;
    return(SetActivePage(nCurPage));
            
}
#else	
//
// Make sure the starting page is actually a page that exists
//
int CNetscapePropertySheet::SetCurrentPage(int iPage)
{
    if(iPage < m_pages.GetSize())
        m_nCurPage = iPage;
    else
        m_nCurPage = 0;

    return(m_nCurPage);
            
}
#endif	// MSVC4

#if defined(MSVC4)
// A change to MFC broke this -- it doesn't return last page
//     once the dialog is closed, which is how we always use it!
int CNetscapePropertySheet::GetCurrentPage()
{
    if( m_hWnd ){
        m_nCurrentPage = GetActiveIndex();
    }
    // We will set this in OnOK so it reflects
    //  correct page just before exiting dialog
    return m_nCurrentPage;
}
#endif

int CNetscapePropertySheet::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
    if( CPropertySheet::OnCreate(lpCreateStruct) == -1 ){
        return -1;
    }

#ifdef XP_WIN16    
    // Since we can't remove Apply button using PSH_NOAPPLYNOW
    //   in MFC 1.52, let's do it ourselves
    if( !m_bUseApplyButton ){
        CWnd *pButton = GetDlgItem(ID_APPLY_NOW);
        CRect crRectApply;
        CRect crRectCancel;

        if( pButton ){
            pButton->GetWindowRect(&crRectApply);
            ScreenToClient(&crRectApply);
            // Hide Apply button
            GetDlgItem(ID_APPLY_NOW)->ShowWindow(SW_HIDE);

            // Move the Cancel button to the Apply position
            pButton = GetDlgItem(IDCANCEL);
            if( pButton ){
                pButton->GetWindowRect(&crRectCancel);
                ScreenToClient(&crRectCancel);
                pButton->SetWindowPos(NULL, crRectApply.left, crRectApply.top, 0,0,
                                      SWP_NOACTIVATE | SWP_NOSIZE);

                // Move the OK button to the Cancel position
                pButton = GetDlgItem(IDOK);
                if( pButton ){
                    pButton->SetWindowPos(NULL, crRectCancel.left, crRectCancel.top, 0,0, 
                                          SWP_NOACTIVATE | SWP_NOSIZE);
                }
            }
        }
    }
#endif
    return 0;
}

void CNetscapePropertySheet::OnDestroy()
{
    CPropertySheet::OnDestroy();
}

extern int32 wfe_iFontSizeMode;

// Toggle Go offline, Go online menu item
//
void CGenericFrame::OnGoOffline()
{
#ifdef MOZ_OFFLINE
	BOOL bOnline;
	CDownLoadDlg rDlg(this);
	PREF_GetBoolPref("network.online", &bOnline);
	rDlg.InitDialog(!bOnline);
	rDlg.DoModal();
	// don't set the offline preference here! GoOffline won't work if we're offline!
#endif /* MOZ_OFFLINE */   
}		

void CGenericFrame::OnUpdateGoOffline(CCmdUI* pCmdUI)
{
#ifdef MOZ_OFFLINE
	BOOL bOnline;
	CString menuText;

	PREF_GetBoolPref("network.online", &bOnline);
	if (bOnline)
	{	//online now, set to offline
		menuText.LoadString(IDS_GO_OFFLINE);
	}
	else
	{	//offline now, set to online
		menuText.LoadString(IDS_GO_ONLINE);
	}
	pCmdUI->SetText(LPCTSTR(menuText));
#endif /* MOZ_OFFLINE */
}		 

void CGenericFrame::OnDoneGoingOffline()
{
#ifdef MOZ_OFFLINE
	// I'm sure this could happen at the worst possible time
	if (!GetMainContext() || !GetMainContext()->GetContext())
		return;

	MWContext *pContext = GetMainContext()->GetContext();
	if (NET_IsOffline() && !XP_IsContextBusy(pContext)) {
		FE_Progress(pContext, szLoadString(IDS_STATUS_OFFLINE));
	} else {
		FE_Progress(pContext, szLoadString(IDS_DOC_DONE));
	}
#endif // MOZ_OFFLINE
}

#ifdef FORTEZZA
/*
 * It would be nice to replace the following code with a single routine
 * that switches off the Resource ID.  (do this in CGenericFrame::OnCmdMsg)
 */
void CGenericFrame::OnStartFortezzaCard()
{
	MWContext *pContext = GetMainContext() != NULL ? 
					GetMainContext()->GetContext() : NULL;
	SSL_FortezzaMenu(pContext,SSL_FORTEZZA_CARD_SELECT);
}
void CGenericFrame::OnStartFortezzaChange()
{
	MWContext *pContext = GetMainContext() != NULL ? 
					GetMainContext()->GetContext() : NULL;
	SSL_FortezzaMenu(pContext,SSL_FORTEZZA_CHANGE_PERSONALITY);
}
void CGenericFrame::OnStartFortezzaView()
{
	MWContext *pContext = GetMainContext() != NULL ? 
					GetMainContext()->GetContext() : NULL;
	SSL_FortezzaMenu(pContext,SSL_FORTEZZA_VIEW_PERSONALITY);
}
void CGenericFrame::OnDoFortezzaInfo()
{
	MWContext *pContext = GetMainContext() != NULL ? 
					GetMainContext()->GetContext() : NULL;
	SSL_FortezzaMenu(pContext,SSL_FORTEZZA_CARD_INFO);		
}
void CGenericFrame::OnDoFortezzaLog()
{
	MWContext *pContext = GetMainContext() != NULL ? 
					GetMainContext()->GetContext() : NULL;
	SSL_FortezzaMenu(pContext,SSL_FORTEZZA_LOGOUT);
}
#endif

//
// Just call OnClose
//
void CGenericFrame::OnFrameExit()
{
    PostMessage(WM_CLOSE);
}

void CGenericFrame::OnSetFocus(CWnd* pOldWnd) 
{
	CFrameWnd::OnSetFocus(pOldWnd);

	//	Put us on the active stack.
	SetAsActiveFrame();
}

void CGenericFrame::OnWindowPosChanged(WINDOWPOS *lpWndPos)
{
	//	Call the base.
	CFrameWnd::OnWindowPosChanged(lpWndPos);

	//	Tell ncapi people window is changing position.
	if(GetMainContext() && GetMainContext()->GetContext()->type == MWContextBrowser)	{
		CWindowChangeItem::Sizing(GetMainContext()->GetContextID(), lpWndPos->x, lpWndPos->y, lpWndPos->cx, lpWndPos->cy);
	}
}

void CGenericFrame::OnWindowPosChanging(WINDOWPOS *lpWndPos)
{
	if (m_bZOrderLocked){
		lpWndPos->flags = lpWndPos->flags | SWP_NOZORDER | SWP_NOOWNERZORDER;
	}
			  
	//  Call the base
	CFrameWnd::OnWindowPosChanging( lpWndPos);
}

void CGenericFrame::OnSize(UINT nType, int cx, int cy) 
{
	CFrameWnd::OnSize(nType, cx, cy);
	
    //  See what type of information we're going to be sending to our window tracking service.
	//	ncapi
	if(GetMainContext() != NULL && GetMainContext()->GetContext()->type == MWContextBrowser)	{
	    switch(nType)   {
	        case SIZE_MAXIMIZED:
	            CWindowChangeItem::Maximizing(GetMainContext()->GetContextID());
	            break;
	        case SIZE_MINIMIZED:
	            CWindowChangeItem::Minimizing(GetMainContext()->GetContextID());
	            break;
	        case SIZE_RESTORED:
	            CWindowChangeItem::Normalizing(GetMainContext()->GetContextID());
	            break;
	    }
	}
}


BOOL CGenericFrame::OnCommand(UINT wParam,LONG lParam)
{               
#ifdef WIN32
    int nCode = HIWORD(wParam);
#else
    int nCode = HIWORD(lParam);
#endif

    UINT nID = LOWORD(wParam);
    if( nID >= ID_OPTIONS_ENCODING_1 && nID <= ID_OPTIONS_ENCODING_70)
    {
          OnToggleEncoding( nID );
          return TRUE;
    }
    if (m_bDisableHotkeys && nCode==1) {
	switch (LOWORD(wParam)) {
	    case ID_SECURITY:
	    case ID_APP_EXIT:
	    case ID_EDIT_PASTE:
	    case ID_EDIT_COPY:
	    case ID_EDIT_CUT:
		break;
	    default:
		return(TRUE);
	}
    }
    
    if(CFrameWnd::OnCommand(wParam, lParam))	{
    	return(TRUE);
	}


	// See if it was a bookmark item
	if (IS_BOOKMARK_ID(nID) && GetMainContext()) {
		// Make sure the command ID is consistent with the last
		// selected menu item
		ASSERT(nLastSelectedCmdID == nID && nLastSelectedData);
		if (nLastSelectedCmdID != nID || !nLastSelectedData)
			return FALSE;
#ifdef EDITOR        
        // It is much safer to go through Composer's LoadUrl routine
	    if(EDT_IS_EDITOR(GetMainContext()->GetContext()))
    	    FE_LoadUrl((char*)nLastSelectedData, TRUE);
        else
#endif
 		    GetMainContext()->NormalGetUrl((char*)nLastSelectedData);
		return TRUE;
	}

	if(IS_FILE_BOOKMARK_ID(nID) && GetMainContext()) {
		if(nLastSelectedCmdID != nID || !nLastSelectedData)
			return FALSE;

		if(GetMainContext()) 
		{
			FileBookmark((HT_Resource)nLastSelectedData);
		}

		return TRUE;

	}

	return CommonCommand(wParam, lParam);
}

// returns TRUE if something was added to the folder, false otherwise
BOOL CGenericFrame::FileBookmark(HT_Resource pFolder)
{
	return FALSE;
}

void CGenericFrame::OnAnimationBonk()
{
	if ( GetMainContext() ) {
		GetMainContext()->NormalGetUrl( szLoadString( IDS_DIRECT_HOME ) );
	}
}

void CGenericFrame::OnUpdateFileRoot(CCmdUI* pCmdUI)
{
    if( pCmdUI->m_pMenu ){
        pCmdUI->m_pMenu->ModifyMenu(ID_BOOKMARKS_FILEROOT, MF_BYCOMMAND | MF_STRING, ID_BOOKMARKS_FILEROOT,
									HT_GetNodeName(HT_TopNode(HT_GetSelectedView(m_BookmarkMenuPane))));
    }

}

void CGenericFrame::OnNewFrame() 
{
	//      Pass it off to the context for handling.
	if(GetMainContext())        {
		GetMainContext()->NewWindow();
	}
}

void CGenericFrame::OnUpdateNewFrame(CCmdUI* pCmdUI) 
{
	//      Defer to the context's wisdom.
	if(GetMainContext())        {
		pCmdUI->Enable(GetMainContext()->CanNewWindow());
	}
	else    {
		pCmdUI->Enable(FALSE);
	}
}

// This is used by browser or editor
//   to open a URL into either a browser 
//   or editor window (Radio buttons 
//   added to dialog to choose destination)
// If destination is a Browser and calling from Browser, 
//  open in same window (same as current behavior), 
//  for all other cases, open in new window
void CGenericFrame::OnFileOpenurl() 
{
	if(GetMainContext())        {
		GetMainContext()->OpenUrl();
	}
}

void CGenericFrame::OnUpdateFileOpenurl(CCmdUI* pCmdUI) 
{
	if(GetMainContext())        {
		pCmdUI->Enable(GetMainContext()->CanOpenUrl());
	}
	else    {
		pCmdUI->Enable(FALSE);
	}
}

void CGenericFrame::OnHotlistAddcurrenttohotlist() 
{
	if(GetMainContext())        {
		GetMainContext()->AddToBookmarks();
	}
}

void CGenericFrame::OnUpdateHotlistAddcurrenttohotlist(CCmdUI* pCmdUI) 
{
	if(GetMainContext())        {
		pCmdUI->Enable(GetMainContext()->CanAddToBookmarks());
	}
	else    {
		pCmdUI->Enable(FALSE);
	}
}

void CGenericFrame::OnHotlistAddcurrenttotoolbar() 
{
/* PERSONAL
	if(GetMainContext())        {
		History_entry *pHistEnt = SHIST_GetCurrent( &(GetMainContext()->GetContext()->hist) );
		ASSERT(pHistEnt);

		BM_Entry *pEntry = BM_NewUrl( GetMainContext()->GetContext()->title, pHistEnt->address, NULL, 
									  pHistEnt->last_access );
		ASSERT(pEntry);

		BM_AppendToHeader( theApp.m_pBmContext, theApp.GetLinkToolbarManager().GetToolbarHeader(), 
						   pEntry );

		theApp.GetLinkToolbarManager().ToolbarHeaderChanged();

	}
*/
}

void CGenericFrame::OnUpdateHotlistAddcurrenttotoolbar(CCmdUI* pCmdUI) 
{
	if(GetMainContext())        {
		pCmdUI->Enable(GetMainContext()->CanAddToBookmarks());
	}
	else    {
		pCmdUI->Enable(FALSE);
	}
}

// Give the focus to the next top-level window
// 
void CGenericFrame::OnNextWindow()
{
	// User has pressed ctrl-tab to switch windows
	  
	if (this->m_pNext) {// goto next if exists
		this->m_pNext->SetActiveWindow(); 
	} else { // else start at beginning
		if(theApp.m_pFrameList)
			theApp.m_pFrameList->SetActiveWindow();
	}   
}


void CGenericFrame::OnSaveOptions()
{
	// Save Encoding Info
	theApp.m_iCSID = m_iCSID ;	// Change Global default CSID
	PREF_SetIntPref("intl.character_set",m_iCSID);
}

LRESULT CGenericFrame::OnFindReplace(WPARAM wParam, LPARAM lParam) 
{

    CWinCX *pContext = GetActiveWinContext();

    if(!pContext)
        pContext = GetMainWinContext();

    if(pContext && pContext->GetPane())
        return(pContext->GetView()->OnFindReplace(wParam, lParam));

    return(FALSE);

}

void CGenericFrame::OnMove(int x, int y) 
{
	CFrameWnd::OnMove(x, y);
	
	//	Tell our main context that we've moved.
	if(GetMainWinContext())	{
		GetMainWinContext()->OnMoveCX();
	}
}

void CGenericFrame::OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI) 
{
	//	Do the default first.
	CFrameWnd::OnGetMinMaxInfo(lpMMI);

	//	If we're not allowing resize, be sure and set the min max tracking information
	//		which effectively blocks the user from resizing the window.
	if(m_bCanResize == FALSE && IsIconic() == FALSE && IsZoomed() == FALSE)	{
		//	Set up the min and max tracking info to be the same to block resize.
		lpMMI->ptMinTrackSize.x = lpMMI->ptMaxTrackSize.x = m_crMinMaxRect.Width();
		lpMMI->ptMinTrackSize.y = lpMMI->ptMaxTrackSize.y = m_crMinMaxRect.Height();
	}
}

// Sets a flag determining wether or now we'll let the user resize the window.
void CGenericFrame::EnableResize(BOOL bEnable)
{
    long lStyles = 0;
    
    // Set the flag.
    m_bCanResize = bEnable;
    GetWindowRect(m_crMinMaxRect);

    lStyles = GetWindowLong(GetSafeHwnd(), GWL_STYLE);
    if (lStyles & WS_POPUP)
	return;
    if (bEnable) { 
	// We need to make sure the windows maximize buttons come back if we killed them.
	if (lStyles & WS_MAXIMIZEBOX)
	    return;
	lStyles |= WS_MAXIMIZEBOX;
	SetWindowLong(GetSafeHwnd(), GWL_STYLE, lStyles);
    }
    else { //The window is being set non-resizable.  Kill the windows maximize button as well.
	if (!(lStyles & WS_MAXIMIZEBOX))
	    return;
	lStyles &= ~WS_MAXIMIZEBOX;
	SetWindowLong(GetSafeHwnd(), GWL_STYLE, lStyles);
    }
}

void CGenericFrame::DisableHotkeys(BOOL bDisable)
{
    // Set the flag.
    m_bDisableHotkeys = bDisable;
}

void CGenericFrame::SetZOrder(BOOL bZLock, BOOL bBottommost)
{
    // Set the flag.
    m_bZOrderLocked = bZLock;
    m_bBottommost = bBottommost;

    if (m_bBottommost)
	m_bZOrderLocked = TRUE;
}

#ifdef WIN32
//These functions don't do anything on Win16.
void CGenericFrame::SetExStyles(DWORD wAddedExStyles, DWORD wRemovedExStyles)
{
    // Set any ws_ex_styles for the window
    m_wAddedExStyles |= wAddedExStyles;
    m_wRemovedExStyles |= wRemovedExStyles;
}

DWORD CGenericFrame::GetRemovedExStyles()
{
    // Set any ws_ex_styles we are setting for the window
    return (m_wRemovedExStyles);
}
#endif 

void CGenericFrame::SetAsPopup(HWND hPopupParent)
{

	m_hPopupParent = hPopupParent;
}

#ifdef WM_SIZING
void CGenericFrame::OnSizing(UINT nSide, LPRECT lpRect)
{
    //  User is resizing window.
    //  Save the current size of the window (used in get min max info)
    //      in case we have to hold us to that.
    GetWindowRect(m_crMinMaxRect);
}
#endif

#ifdef _WIN32
LONG CGenericFrame::OnHackedMouseWheel(WPARAM wParam, LPARAM lParam)
{
    //  Determine if we're the destination.
    BOOL bUs = TRUE;
    HWND hFocus = ::GetFocus();
    if(hFocus)  {
        //  Is the focus window our child?
        BOOL bChild = ::IsChild(m_hWnd, hFocus);
        if(bChild)    {
            //  Pass along.
            bUs = FALSE;
        }
    }

    //  Either call ourselves or pass along.
    if(bUs == TRUE) {
        //  Zero means not handled.
        return(0);
    }
    else    {
        return(::SendMessage(hFocus, msg_MouseWheel, wParam, lParam));
    }
}
#endif

// Call to start a new Browser window with supplied URL
//  or load homepage if none supplied

MWContext * wfe_CreateNavigator(char * pUrl)
{
	URL_Struct *pUrlStruct = NULL;
    
    if ( pUrl != NULL && XP_STRLEN(pUrl) > 0 )
    {
        // Create a new URL structure and copy URL string to it
        pUrlStruct = NET_CreateURLStruct(pUrl, NET_DONT_RELOAD);
        // Must clear this to correctly load URL
        if ( pUrlStruct ) {
	        pUrlStruct->fe_data = NULL;
        }
    }

    // Always create a new context 
    return CFE_CreateNewDocWindow(NULL, pUrlStruct );
}


