gecko-dev/cmd/winfe/frameglu.cpp

591 lines
17 KiB
C++
Raw Normal View History

1998-03-28 02:44:41 +00:00
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
#include "stdafx.h"
#include "secnav.h"
#include "frameglu.h"
#include "mainfrm.h"
#include "ipframe.h"
#include "prefapi.h"
// Our active frame stack.
CPtrList CFrameGlue::m_cplActiveFrameStack;
// A way to correctly get the frame glue out of a frame at run time though
// the class derivations and casting are not right....
CFrameGlue *CFrameGlue::GetFrameGlue(CFrameWnd *pFrame) {
// Use IsKindOf to determine the frame's class type.
// From there, we can correctly cast the frame window pointer, and
// further cast to the abstract base class of CFrameGlue.
CFrameGlue *pRetval = NULL;
if(pFrame->IsKindOf(RUNTIME_CLASS(CGenericFrame))) {
pRetval = (CFrameGlue *)((CGenericFrame *)pFrame);
}
else if(pFrame->IsKindOf(RUNTIME_CLASS(CInPlaceFrame))) {
pRetval = (CFrameGlue *)((CInPlaceFrame *)pFrame);
}
#ifdef DEBUG
if(pRetval == NULL) {
// If you got here, either you need to add appropriate casting statements
// in the above if to resolve the CFrameGlue, or you have found a bug.
TRACE("Invalid frame window has no frame glue!\n");
// ASSERT(0);
}
#endif // DEBUG
return(pRetval);
}
CFrameGlue::CFrameGlue() {
m_pActiveContext = NULL;
m_pMainContext = NULL;
m_bCanRestoreState = FALSE;
m_iCSID = theApp.m_iCSID;
m_pChrome = NULL;
// location bar
// note I just changed this from 1.0 version to be more appropriate chouck 24-jan-95
XP_Bool bBar;
PREF_GetBoolPref("browser.chrome.show_url_bar",&bBar);
m_bLocationBar = bBar;
// show the starter buttons?
PREF_GetBoolPref("browser.chrome.show_directory_buttons",&bBar);
m_bStarter = bBar;
PREF_GetBoolPref("browser.chrome.show_toolbar",&bBar);
m_bShowToolbar = bBar;
// No find replace dialog yet.
m_pFindReplace = NULL;
m_pClipChildMap = NULL;
m_isBackgroundPalette = FALSE;
}
CFrameGlue::~CFrameGlue() {
// Take all entries of this frame in the active frame stack out.
POSITION pos;
while( pos = m_cplActiveFrameStack.Find( (LPVOID) this ) ){
m_cplActiveFrameStack.RemoveAt( pos );
}
// When the frame goes down, let the window context know.
if(GetMainWinContext()) {
GetMainWinContext()->ClearFrame();
}
if( m_pClipChildMap != NULL ) {
m_pClipChildMap->RemoveAll();
delete m_pClipChildMap;
m_pClipChildMap = NULL;
}
}
// Generic way to get a frame out of the context.
CFrameGlue *GetFrame(MWContext *pContext)
{
CFrameGlue *pRetval = NULL;
if(pContext != NULL) {
if(ABSTRACTCX(pContext) && ABSTRACTCX(pContext)->IsFrameContext()) {
pRetval = ABSTRACTCX(pContext)->GetFrame();
}
}
return(pRetval);
}
CAbstractCX *CFrameGlue::GetMainContext() const
{
return(m_pMainContext);
}
CAbstractCX *CFrameGlue::GetActiveContext() const
{
return(m_pActiveContext);
}
CWinCX *CFrameGlue::GetMainWinContext() const
{
if (m_pMainContext && m_pMainContext->IsFrameContext()) {
return((CWinCX *) m_pMainContext);
}
return NULL;
}
CWinCX *CFrameGlue::GetActiveWinContext() const
{
if (m_pActiveContext && m_pActiveContext->IsFrameContext()) {
return((CWinCX *) m_pActiveContext);
}
return NULL;
}
void CFrameGlue::SetMainContext(CAbstractCX *pContext) {
m_pMainContext = pContext;
}
CPtrList CFrameGlue::m_cplActiveContextCBList;
void CFrameGlue::SetActiveContext(CAbstractCX *pContext)
{
m_pActiveContext = pContext;
POSITION rIndex = m_cplActiveContextCBList.GetHeadPosition();
while(rIndex != NULL) {
ActiveContextCB cb = (ActiveContextCB)m_cplActiveContextCBList.GetNext(rIndex);
(cb)(this, pContext);
}
}
void CFrameGlue::AddActiveContextCB(ActiveContextCB cb)
{
m_cplActiveContextCBList.AddTail((LPVOID)cb);
}
void CFrameGlue::RemoveActiveContextCB(ActiveContextCB cb)
{
POSITION rIndex = m_cplActiveContextCBList.Find((LPVOID)cb);
if(rIndex) {
m_cplActiveContextCBList.RemoveAt(rIndex);
}
}
// Override to test if frame is an editor
BOOL CFrameGlue::IsEditFrame()
{
return(FALSE);
}
CPtrList CFrameGlue::m_cplActiveNotifyCBList;
// Add to the top of the stack of active frames.
void CFrameGlue::SetAsActiveFrame()
{
POSITION rIndex = m_cplActiveNotifyCBList.GetHeadPosition();
while(rIndex != NULL) {
ActiveNotifyCB cb = (ActiveNotifyCB) m_cplActiveNotifyCBList.GetNext(rIndex);
(cb)(this);
}
POSITION pos = m_cplActiveFrameStack.Find( (LPVOID) this );
if (pos) {
m_cplActiveFrameStack.RemoveAt( pos );
}
TRY {
m_cplActiveFrameStack.AddHead((void *)this);
}
CATCH(CException, e) {
// didn't work, Silently fail...
ASSERT(0);
}
END_CATCH
}
void CFrameGlue::AddActiveNotifyCB( ActiveNotifyCB cb )
{
m_cplActiveNotifyCBList.AddTail( (LPVOID) cb );
}
void CFrameGlue::RemoveActiveNotifyCB( ActiveNotifyCB cb )
{
POSITION rIndex = m_cplActiveNotifyCBList.Find( (LPVOID) cb );
if (rIndex) {
m_cplActiveNotifyCBList.RemoveAt( rIndex );
}
}
// Find a browser window in the active stack, only use cxType types.
// Default is to NOT find editor windows when cxType = MWContextBrowser
CFrameGlue *CFrameGlue::GetLastActiveFrame(MWContextType cxType, int nFindEditor)
{
CFrameGlue *pRetval = NULL;
// Loop through all active frames.
POSITION rIndex = m_cplActiveFrameStack.GetHeadPosition();
while(rIndex != NULL) {
pRetval = (CFrameGlue *)m_cplActiveFrameStack.GetNext(rIndex);
// See if we can get the type from the context, and verify the type.
if(pRetval->GetMainContext() != NULL) {
MWContextType cxRetType = pRetval->GetMainContext()->GetContext()->type;
if(cxType == MWContextAny || cxRetType == cxType) {
// If looking for only Browser, skip an editor frame
if (cxType == MWContextBrowser){
BOOL bIsEditor = EDT_IS_EDITOR(pRetval->GetMainContext()->GetContext());
if((nFindEditor == FEU_FINDBROWSERONLY && bIsEditor) ||
(nFindEditor == FEU_FINDEDITORONLY && !bIsEditor)) {
// Failed the check. clear retval.
pRetval = NULL;
continue;
}
}
// Don't allow Netcaster either
if (pRetval->GetMainContext()->GetContext() == theApp.m_pNetcasterWindow
|| (pRetval->GetMainContext()->GetContext()->name && (XP_STRCASECMP(pRetval->GetMainContext()->GetContext()->name,"Netscape_Netcaster_Drawer") == 0))) {
pRetval = NULL;
continue;
}
// Found one.
break;
}
}
// Failed the check. clear retval.
pRetval = NULL;
}
return(pRetval);
}
CFrameGlue *CFrameGlue::GetLastActiveFrameByCustToolbarType(CString custToolbar, CFrameWnd *pCurrentFrame, BOOL bUseSaveInfo)
{
CFrameGlue *pRetval = NULL;
// Loop through all active frames.
POSITION rIndex = m_cplActiveFrameStack.GetHeadPosition();
while(rIndex != NULL) {
pRetval = (CFrameGlue *)m_cplActiveFrameStack.GetNext(rIndex);
// if it's the current frame, then keep looking because we want the one before it.
if(pRetval->GetFrameWnd() == pCurrentFrame) {
pRetval = NULL;
continue;
}
// See if we share the same custtoolbar string.
if((pRetval->m_pChrome) && (pRetval->m_pChrome->GetCustToolbarString() == custToolbar)){
if(bUseSaveInfo){
// if customizable toolbar saves its prefs, then break
// this is used to ignore windows like View Page Source and View Page Info
if(pRetval->m_pChrome->GetCustomizableToolbar()->GetSaveToolbarInfo())
break;
}
else
break;
}
// Failed the check. clear retval.
pRetval = NULL;
}
return(pRetval);
}
CFrameGlue *CFrameGlue::GetBottomFrame(MWContextType cxType, int nFindEditor)
{
CFrameGlue *pRetval = NULL;
// Loop through all active frames until we reach the bottom.
POSITION rIndex = m_cplActiveFrameStack.GetTailPosition();
while(rIndex != NULL) {
pRetval = (CFrameGlue *)m_cplActiveFrameStack.GetPrev(rIndex);
// See if we can get the type from the context, and verify the type.
if(pRetval->GetMainContext() != NULL) {
MWContextType cxRetType = pRetval->GetMainContext()->GetContext()->type;
if(cxType == MWContextAny || cxRetType == cxType) {
// If looking for only Browser, skip an editor frame
if (cxType == MWContextBrowser){
BOOL bIsEditor = EDT_IS_EDITOR(pRetval->GetMainContext()->GetContext());
if((nFindEditor == FEU_FINDBROWSERONLY && bIsEditor) ||
(nFindEditor == FEU_FINDEDITORONLY && !bIsEditor)) {
// Failed the check. clear retval.
continue;
}
}
// Found one
break;
}
}
}
return(pRetval);
}
// Find the number of active frames of type cxType
int CFrameGlue::GetNumActiveFrames(MWContextType cxType, int nFindEditor)
{
int nCount = 0;
CFrameGlue *pRetval = NULL;
// Loop through all active frames.
POSITION rIndex = m_cplActiveFrameStack.GetHeadPosition();
while(rIndex != NULL) {
pRetval = (CFrameGlue *)m_cplActiveFrameStack.GetNext(rIndex);
// See if we can get the type from the context, and verify the type.
if(pRetval->GetMainContext() != NULL) {
MWContextType cxRetType = pRetval->GetMainContext()->GetContext()->type;
if(cxType == MWContextAny || cxRetType == cxType) {
// If looking for only Browser, skip an editor frame
if (cxType == MWContextBrowser){
BOOL bIsEditor = EDT_IS_EDITOR(pRetval->GetMainContext()->GetContext());
if((nFindEditor == FEU_FINDBROWSERONLY && bIsEditor) ||
(nFindEditor == FEU_FINDEDITORONLY && !bIsEditor)) {
continue;
}
}
// Found one so increase count.
nCount++;
}
}
}
return(nCount);
}
// Find a browser window by context ID....
CFrameGlue *CFrameGlue::FindFrameByID(DWORD dwID, MWContextType cxType)
{
CFrameGlue *pRetval = NULL;
// Must have a context first.
CAbstractCX *pCX = CAbstractCX::FindContextByID(dwID);
if(pCX != NULL) {
// Must be a window context.
if(pCX->IsFrameContext() == TRUE) {
// Make sure the context is of the correct type.
if(cxType == MWContextAny || cxType == pCX->GetContext()->type) {
pRetval = VOID2CX(pCX, CAbstractCX)->GetFrame();
}
}
}
return(pRetval);
}
// Common command handler for all frames.
// Call in your OnCommand derivation.
BOOL CFrameGlue::CommonCommand(UINT wParam, LONG lParam) {
UINT nID = LOWORD(wParam);
if (IS_PLACESMENU_ID(nID) || IS_HELPMENU_ID(nID)) {
char * url = NULL;
if (IS_PLACESMENU_ID(nID))
PREF_CopyIndexConfigString("menu.places.item",CASTINT(nID-FIRST_PLACES_MENU_ID),"url",&url);
else
PREF_CopyIndexConfigString("menu.help.item",CASTINT(nID-FIRST_HELP_MENU_ID),"url",&url);
if (!url) return FALSE;
if(!GetMainContext())
return(FALSE);
// if we are a browser window and NOT an editor just load it locally
if(GetMainContext()->GetContext()->type == MWContextBrowser &&
!EDT_IS_EDITOR(GetMainContext()->GetContext()) ){
GetMainContext()->NormalGetUrl(url);
return(TRUE);
}
// look for a browser window we can load into
CFrameGlue *pFrameGlue = CFrameGlue::GetLastActiveFrame(MWContextBrowser);
if(pFrameGlue != NULL && pFrameGlue->GetMainContext() != NULL) {
CAbstractCX * pCX = pFrameGlue->GetMainContext();
if (pCX != NULL) {
CFrameWnd * pWnd = pFrameGlue->GetFrameWnd();
if (pWnd->IsIconic())
pWnd->ShowWindow(SW_RESTORE);
pWnd->BringWindowToTop();
pCX->NormalGetUrl(url);
}
// pFrameGlue->GetMainContext()->NormalGetUrl(szLoadString(nID + LOAD_URL_COUNT));
return(TRUE);
}
// if we got here we must not have found a viable window --- create a new one
MWContext * pContext = CFE_CreateNewDocWindow(NULL, NULL);
ABSTRACTCX(pContext)->NormalGetUrl(url);
XP_FREE(url);
return(TRUE);
} else if ( nID == ID_SECURITY_ADVISOR ) {
CAbstractCX *pCX = GetMainContext();
if (pCX != NULL)
{
MWContext * pContext = pCX->GetContext();
if (pContext != NULL)
{
URL_Struct * pURL = pCX->CreateUrlFromHist(TRUE);
SECNAV_SecurityAdvisor(pContext, pURL);
}
}
}
return(FALSE);
}
#define CLIP_BIT 0x80000000L
#define GET_CLIP_BIT(x) ( (DWORD)(x) & CLIP_BIT )
#define CLIP_COUNT(x) ( (DWORD)(x) & 0x0000FFFFL )
void CFrameGlue::ClipChildren(CWnd *pWnd, BOOL bSet)
{
// ASSERT( GetFrameWnd()->IsChild(pWnd) );
#ifdef _DEBUG
if (GetFrameWnd() && !GetFrameWnd()->IsChild(pWnd))
TRACE("pWnd is not a child of this frame\n");
#endif
// If the child window hash table does not exist, then create one
if( m_pClipChildMap == NULL ) {
m_pClipChildMap = new CMapPtrToPtr();
}
//
// For every window in the hierarchy between pWnd and the top level
// frame, set or clear its WS_CLIPCHILDREN style bit.
//
while( (pWnd = pWnd->GetParent()) != NULL ) {
DWORD dwStyle;
void *item = 0;
void *key = (void*)pWnd->m_hWnd;
dwStyle = ::GetWindowLong(pWnd->m_hWnd, GWL_STYLE);
// Add the window to the map if necessary...
if( m_pClipChildMap->Lookup(key, item) == FALSE && bSet ) {
item = (void *)((dwStyle & WS_CLIPCHILDREN) ? CLIP_BIT : 0L);
m_pClipChildMap->SetAt(key, item);
}
// Setting the WS_CLIPCHILDREN bit...
if( bSet ) {
// Set the style the first time...
if( CLIP_COUNT(item) == 0 ) {
::SetWindowLong(pWnd->m_hWnd, GWL_STYLE,(dwStyle|WS_CLIPCHILDREN));
}
// Increment the count and save the new state...
item = (void *) (((DWORD)item) + 1);
m_pClipChildMap->SetAt(key, item);
}
// Clearing the WS_CLIPCHILDREN bit...
else if (CLIP_COUNT(item)) {
// Decrement the count...
item = (void *) (((DWORD)item) - 1);
// Restore the window to its original state and remove it
// from the map.
if( CLIP_COUNT(item) == 0 ) {
if( GET_CLIP_BIT(item) == 0 ) {
::SetWindowLong(pWnd->m_hWnd, GWL_STYLE,
(dwStyle & ~WS_CLIPCHILDREN) );
}
m_pClipChildMap->RemoveKey(key);
}
// Save the new state...
else {
m_pClipChildMap->SetAt(key, item);
}
}
}
}
BOOL CFrameGlue::RealizePalette(CWnd *pWnd, HWND hFocusWnd,BOOL background)
{
CWinCX *pWinCX = GetMainWinContext();
HDC hdc = pWinCX->GetContextDC();
if (hdc) {
::SelectPalette(hdc, pWinCX->GetPalette(), background);
int colorRealized = ::RealizePalette(hdc);
int lCount = XP_ListCount(pWinCX->GetContext()->grid_children);
if (lCount) {
// Go through each child.
MWContext *pChild;
XP_List *pTraverse = pWinCX->GetContext()->grid_children;
while (pChild = (MWContext *)XP_ListNextObject(pTraverse)) {
ASSERT(ABSTRACTCX(pChild)->IsWindowContext());
::InvalidateRect(PANECX(pChild)->GetPane(), NULL, TRUE);
::UpdateWindow(PANECX(pChild)->GetPane());
}
}
SetIsBackgroundPalette(background);
::InvalidateRect(pWinCX->GetPane(), NULL, TRUE);
::UpdateWindow(pWinCX->GetPane());
#ifdef MOZ_TASKBAR
if(theApp.GetTaskBarMgr().IsInitialized() && theApp.GetTaskBarMgr().IsFloating())
theApp.GetTaskBarMgr().ChangeTaskBarsPalette(hFocusWnd);
#endif /* MOZ_TASKBAR */
pWnd->SendMessageToDescendants(WM_PALETTECHANGED, (WPARAM)hFocusWnd);
return (colorRealized > 0) ? TRUE : FALSE;
}
else return FALSE;
}
void CFrameGlue::ClearContext(CAbstractCX *pGone) {
// Clear out the appropriate context
// fields, if set.
// Can't have an active without a main.
if(GetMainContext() == pGone) {
SetActiveContext(NULL);
SetMainContext(NULL);
}
else if(GetActiveContext() == pGone) {
SetActiveContext(NULL);
}
else if(pGone && pGone->IsGridParent()) {
// Need to see if pGone is a parent of the active context.
// If so, we need to clear our active context as the child
// context won't be able to look us up to call this
// function due to the recursive implemenation of
// CWinCX::GetFrame() which it uses to make this call
MWContext *pChild;
XP_List *pTraverse = pGone->GetContext()->grid_children;
while((pChild = (MWContext*)XP_ListNextObject(pTraverse))) {
ClearContext(ABSTRACTCX(pChild));
}
}
}
// NULL frame implementation, for CFrameGlue when there is no frame.
CFrameWnd *CNullFrame::GetFrameWnd() {
return(NULL);
}
void CNullFrame::UpdateHistoryDialog() {
}
CAbstractCX *CNullFrame::GetMainContext() const {
return(NULL);
}
CAbstractCX *CNullFrame::GetActiveContext() const {
return(NULL);
}