mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-11 16:32:59 +00:00
1178 lines
27 KiB
C++
Executable File
1178 lines
27 KiB
C++
Executable File
/* -*- 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 "widgetry.h"
|
|
#include "genchrom.h"
|
|
#include "toolbar.cpp"
|
|
#include "prefapi.h"
|
|
#include "navfram.h"
|
|
|
|
#include "wfedde.h" //JOKI
|
|
|
|
#define MAIN_PICT_HEIGHT 21
|
|
#define MAIN_PICT_WIDTH 23
|
|
|
|
static SIZE sizeBitmapDefault = { 23, 21 };
|
|
|
|
// these button sizes INCLUDE HIGHLIGHT_WIDTH on each edge
|
|
static SIZE sizeNoviceButton = { 50, 40 };
|
|
// according to CToolBar::SetSizes(): "button must be big enough
|
|
// to hold image + 3 pixels on each side"
|
|
static SIZE sizeAdvancedButton = { 30, 27 };
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// CGenericToolBar
|
|
|
|
CGenericToolBar::CGenericToolBar( LPUNKNOWN pOuterUnk )
|
|
{
|
|
m_ulRefCount = 0;
|
|
m_pOuterUnk = pOuterUnk;
|
|
m_nBitmapID = 0;
|
|
m_pCommandToolbar = NULL;
|
|
}
|
|
|
|
CGenericToolBar::~CGenericToolBar()
|
|
{
|
|
if(m_pCommandToolbar)
|
|
delete m_pCommandToolbar;
|
|
}
|
|
|
|
STDMETHODIMP CGenericToolBar::QueryInterface(REFIID refiid, LPVOID * ppv)
|
|
{
|
|
if ( m_pOuterUnk )
|
|
return m_pOuterUnk->QueryInterface(refiid, ppv);
|
|
else {
|
|
*ppv = NULL;
|
|
if (IsEqualIID(refiid,IID_IUnknown))
|
|
*ppv = (LPUNKNOWN) (LPNSTOOLBAR) this;
|
|
else if (IsEqualIID(refiid, IID_INSToolBar))
|
|
*ppv = (LPNSTOOLBAR) this;
|
|
else if (IsEqualIID(refiid, IID_INSAnimation))
|
|
*ppv = (LPNSANIMATION) this;
|
|
|
|
if (*ppv != NULL) {
|
|
AddRef();
|
|
return NOERROR;
|
|
}
|
|
|
|
return ResultFromScode(E_NOINTERFACE);
|
|
}
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CGenericToolBar::AddRef(void)
|
|
{
|
|
if ( m_pOuterUnk )
|
|
return m_pOuterUnk->AddRef();
|
|
else
|
|
return ++m_ulRefCount;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CGenericToolBar::Release(void)
|
|
{
|
|
if ( m_pOuterUnk )
|
|
return m_pOuterUnk->Release();
|
|
else {
|
|
ULONG ulRef = --m_ulRefCount;
|
|
if (m_ulRefCount == 0) {
|
|
delete this;
|
|
}
|
|
return ulRef;
|
|
}
|
|
}
|
|
|
|
int CGenericToolBar::Create( CFrameWnd *pParent,
|
|
DWORD dwStyle,
|
|
UINT nID )
|
|
{
|
|
#ifdef WIN32
|
|
dwStyle |= CBRS_TOOLTIPS | CBRS_FLYBY;
|
|
#endif
|
|
|
|
// int res = m_barTool.Create( pParent, dwStyle, nID );
|
|
// if ( res == -1 ) {
|
|
// return res;
|
|
// }
|
|
|
|
m_pCommandToolbar = new CCommandToolbar(20, theApp.m_pToolbarStyle, 43, 27, 27);
|
|
|
|
int res = m_pCommandToolbar->Create(pParent);
|
|
|
|
|
|
if(res)
|
|
{
|
|
m_pCommandToolbar->ShowWindow(SW_SHOW);
|
|
//m_barTool.SetToolbar(m_pCommandToolbar);
|
|
}
|
|
pParent->RecalcLayout();
|
|
return res;
|
|
}
|
|
|
|
void CGenericToolBar::SetSizes( SIZE sizeButton,
|
|
SIZE sizeImage )
|
|
{
|
|
m_pCommandToolbar->SetBitmapSize(sizeImage.cx, sizeImage.cy);
|
|
}
|
|
|
|
void CGenericToolBar::SetButtons( const UINT *lpIDArray,
|
|
int nIDCount, UINT nBitmapID )
|
|
{
|
|
m_pCommandToolbar->RemoveAllButtons();
|
|
|
|
if(nBitmapID != 0)
|
|
{
|
|
m_nBitmapID = nBitmapID;
|
|
m_pCommandToolbar->SetBitmap(nBitmapID);
|
|
}
|
|
|
|
HBITMAP hBitmap = m_pCommandToolbar->GetBitmap();
|
|
|
|
for(int i = 0; i < nIDCount; i++)
|
|
{
|
|
CCommandToolbarButton *pButton = new CCommandToolbarButton;
|
|
|
|
CString statusStr, toolTipStr, textStr;
|
|
|
|
WFE_ParseButtonString(lpIDArray[i], statusStr, toolTipStr, textStr);
|
|
|
|
pButton->Create(m_pCommandToolbar, theApp.m_pToolbarStyle,
|
|
CSize(sizeNoviceButton.cx , sizeNoviceButton.cy),
|
|
CSize(sizeAdvancedButton.cx, sizeAdvancedButton.cy),(const char*)textStr,
|
|
(const char *)toolTipStr, (const char *)statusStr, m_nBitmapID, i,
|
|
CSize(sizeBitmapDefault.cx , sizeBitmapDefault.cy), lpIDArray[i], SHOW_ALL_CHARACTERS);
|
|
|
|
|
|
if(hBitmap != NULL)
|
|
pButton->SetBitmap(hBitmap, TRUE);
|
|
|
|
m_pCommandToolbar->AddButton(pButton);
|
|
|
|
}
|
|
// m_barTool.PlaceToolbar();
|
|
}
|
|
|
|
CToolbarButton *CGenericToolBar::GetButtonByIndex(int index)
|
|
{
|
|
return m_pCommandToolbar->GetNthButton(index);
|
|
|
|
}
|
|
|
|
CToolbarButton *CGenericToolBar::GetButtonByID(int nCmd)
|
|
{
|
|
return m_pCommandToolbar->GetButton(nCmd);
|
|
}
|
|
|
|
void CGenericToolBar::SetButtonStyle( UINT nIDButtonCommand, DWORD dwButtonStyle )
|
|
{
|
|
CToolbarButton * pButton = m_pCommandToolbar->GetButton(nIDButtonCommand);
|
|
if( pButton ){
|
|
pButton->SetStyle(dwButtonStyle);
|
|
}
|
|
}
|
|
|
|
void CGenericToolBar::GetButtonRect( UINT nIDButtonCommand, RECT * pRect)
|
|
{
|
|
CToolbarButton * pButton = m_pCommandToolbar->GetButton(nIDButtonCommand);
|
|
if( pButton ){
|
|
pButton->GetWindowRect(pRect);
|
|
}
|
|
}
|
|
|
|
void CGenericToolBar::AddButton( CToolbarButton *pButton, int index )
|
|
{
|
|
m_pCommandToolbar->AddButton( pButton, index );
|
|
}
|
|
|
|
void CGenericToolBar::RemoveAllButtons()
|
|
{
|
|
m_pCommandToolbar->RemoveAllButtons( );
|
|
}
|
|
|
|
CToolbarButton *CGenericToolBar::RemoveButton( int index )
|
|
{
|
|
return m_pCommandToolbar->RemoveButton( index );
|
|
}
|
|
|
|
BOOL CGenericToolBar::LoadBitmap( LPCSTR lpszResourceName )
|
|
{
|
|
// return m_barTool.LoadBitmap( lpszResourceName );
|
|
m_nBitmapID = (UINT) LOWORD(lpszResourceName);
|
|
|
|
m_pCommandToolbar->SetBitmap(m_nBitmapID);
|
|
|
|
int nCount = m_pCommandToolbar->GetNumButtons();
|
|
|
|
for(int i = 0; i < nCount; i++)
|
|
{
|
|
m_pCommandToolbar->GetNthButton(i)->ReplaceBitmap(m_pCommandToolbar->GetBitmap(), i, TRUE);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
void CGenericToolBar::SetToolbarStyle( int nToolbarStyle )
|
|
{
|
|
if(m_pCommandToolbar)
|
|
{
|
|
m_pCommandToolbar->SetToolbarStyle(nToolbarStyle);
|
|
m_pCommandToolbar->GetParentFrame()->RecalcLayout();
|
|
// m_barTool.RedrawWindow();
|
|
}
|
|
}
|
|
|
|
void CGenericToolBar::Show( BOOL bShow )
|
|
{
|
|
if(m_pCommandToolbar)
|
|
m_pCommandToolbar->ShowWindow( bShow ? SW_SHOW : SW_HIDE );
|
|
}
|
|
|
|
void CGenericToolBar::SetButtonsSameWidth(BOOL bSameWidth)
|
|
{
|
|
if(m_pCommandToolbar)
|
|
m_pCommandToolbar->SetButtonsSameWidth(bSameWidth);
|
|
}
|
|
|
|
HWND CGenericToolBar::GetHWnd()
|
|
{
|
|
if(m_pCommandToolbar){
|
|
return m_pCommandToolbar->m_hWnd;
|
|
}
|
|
return (HWND)0;
|
|
}
|
|
|
|
void CGenericToolBar::StartAnimation( )
|
|
{
|
|
// m_barTool.StartAnimation( );
|
|
}
|
|
|
|
void CGenericToolBar::StopAnimation( )
|
|
{
|
|
// m_barTool.StopAnimation( );
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// CGenericStatusBar
|
|
|
|
class CModalStatus: public CDialog {
|
|
protected:
|
|
|
|
CProgressMeter m_progressMeter;
|
|
UINT m_idTimer;
|
|
BOOL m_bInModal;
|
|
|
|
enum { IDD = IDD_NEWMAIL };
|
|
|
|
virtual BOOL OnInitDialog();
|
|
virtual void OnCancel( );
|
|
|
|
afx_msg void OnTimer( UINT nIDEvent );
|
|
afx_msg void OnDestroy();
|
|
DECLARE_MESSAGE_MAP()
|
|
|
|
public:
|
|
CModalStatus();
|
|
~CModalStatus( );
|
|
|
|
BOOL Create( CWnd *pParentWnd, UINT uDelay );
|
|
|
|
void SetPercentDone( int iPercent );
|
|
void SetStatusText( LPCTSTR lpszStatus );
|
|
void ProgressComplete();
|
|
};
|
|
|
|
CModalStatus::CModalStatus()
|
|
{
|
|
m_idTimer = 0;
|
|
m_bInModal = FALSE;
|
|
}
|
|
|
|
CModalStatus::~CModalStatus( )
|
|
{
|
|
}
|
|
|
|
BOOL CModalStatus::Create( CWnd *pParentWnd, UINT uDelay )
|
|
{
|
|
BOOL res = CDialog::Create( IDD, pParentWnd );
|
|
|
|
if ( res ) {
|
|
m_idTimer = SetTimer( 1, uDelay, NULL );
|
|
}
|
|
return res;
|
|
}
|
|
|
|
BOOL CModalStatus::OnInitDialog( )
|
|
{
|
|
CDialog::OnInitDialog();
|
|
|
|
SetWindowText(szLoadString(IDS_PROGRESS));
|
|
|
|
m_progressMeter.SubclassDlgItem( IDC_PROGRESS, this );
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void CModalStatus::OnCancel()
|
|
{
|
|
GetParentFrame()->PostMessage( WM_COMMAND, (WPARAM) ID_NAVIGATE_INTERRUPT, (LPARAM) 0 );
|
|
}
|
|
|
|
BEGIN_MESSAGE_MAP(CModalStatus, CDialog)
|
|
ON_WM_TIMER()
|
|
ON_WM_DESTROY()
|
|
END_MESSAGE_MAP()
|
|
|
|
void CModalStatus::OnTimer( UINT nIDEvent )
|
|
{
|
|
KillTimer( m_idTimer );
|
|
m_idTimer = 0;
|
|
|
|
m_bInModal = TRUE;
|
|
CWnd* pParentWnd = GetParentFrame();
|
|
pParentWnd->EnableWindow(FALSE);
|
|
ShowWindow(SW_SHOW);
|
|
EnableWindow(TRUE);
|
|
UpdateWindow();
|
|
}
|
|
|
|
void CModalStatus::OnDestroy()
|
|
{
|
|
if (m_idTimer) {
|
|
KillTimer( m_idTimer );
|
|
m_idTimer = 0;
|
|
}
|
|
}
|
|
|
|
void CModalStatus::SetStatusText( LPCTSTR lpszStatus )
|
|
{
|
|
CWnd *widget = GetDlgItem( IDC_STATIC1 );
|
|
widget->SetWindowText( lpszStatus );
|
|
}
|
|
|
|
void CModalStatus::SetPercentDone( int iPercent )
|
|
{
|
|
CWnd *widget = GetDlgItem( IDC_STATIC2 );
|
|
CString cs;
|
|
cs.Format("%d%%", iPercent);
|
|
widget->SetWindowText(cs);
|
|
|
|
m_progressMeter.StepItTo( iPercent );
|
|
}
|
|
|
|
void CModalStatus::ProgressComplete()
|
|
{
|
|
if (m_bInModal) {
|
|
CWnd* pParentWnd = GetParentFrame();
|
|
pParentWnd->EnableWindow(TRUE);
|
|
if (::GetActiveWindow() == m_hWnd)
|
|
pParentWnd->SetActiveWindow();
|
|
m_bInModal = FALSE;
|
|
DestroyWindow();
|
|
} else {
|
|
DestroyWindow();
|
|
}
|
|
}
|
|
|
|
CGenericStatusBar::CGenericStatusBar( LPUNKNOWN pOuterUnk )
|
|
{
|
|
m_ulRefCount = 0;
|
|
|
|
m_pOuterUnk = pOuterUnk;
|
|
m_pStatusBar = NULL;
|
|
m_pCreatedBar = NULL;
|
|
|
|
m_bModal = FALSE;
|
|
m_pModalStatus = NULL;
|
|
|
|
m_iProg = 0;
|
|
}
|
|
|
|
CGenericStatusBar::~CGenericStatusBar()
|
|
{
|
|
//## NOTE: If we instantiate the status bar on the heap (via new), it is auto-deleted.
|
|
}
|
|
|
|
STDMETHODIMP CGenericStatusBar::QueryInterface(REFIID refiid, LPVOID * ppv)
|
|
{
|
|
if ( m_pOuterUnk )
|
|
return m_pOuterUnk->QueryInterface(refiid, ppv);
|
|
else {
|
|
*ppv = NULL;
|
|
if (IsEqualIID(refiid,IID_IUnknown))
|
|
*ppv = (LPUNKNOWN) this;
|
|
else if (IsEqualIID(refiid, IID_INSStatusBar))
|
|
*ppv = (LPNSSTATUSBAR) this;
|
|
|
|
if (*ppv != NULL) {
|
|
AddRef();
|
|
return NOERROR;
|
|
}
|
|
|
|
return ResultFromScode(E_NOINTERFACE);
|
|
}
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CGenericStatusBar::AddRef(void)
|
|
{
|
|
if ( m_pOuterUnk )
|
|
return m_pOuterUnk->AddRef();
|
|
else
|
|
return ++m_ulRefCount;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CGenericStatusBar::Release(void)
|
|
{
|
|
if ( m_pOuterUnk )
|
|
return m_pOuterUnk->Release();
|
|
else {
|
|
ULONG ulRef = --m_ulRefCount;
|
|
if (m_ulRefCount == 0) {
|
|
delete this;
|
|
}
|
|
return ulRef;
|
|
}
|
|
}
|
|
|
|
CNetscapeStatusBar *CGenericStatusBar::GetNetscapeStatusBar()
|
|
{
|
|
return m_pStatusBar;
|
|
}
|
|
|
|
BOOL CGenericStatusBar::Create( CWnd* pParentWnd, DWORD dwStyle, UINT nID, BOOL bxxx /*=TRUE*/, BOOL bTaskbar /*=TRUE*/ )
|
|
{
|
|
m_pCreatedBar = new CNetscapeStatusBar;
|
|
|
|
if( !m_pCreatedBar->Create( pParentWnd, bxxx, bTaskbar ) )
|
|
{
|
|
delete m_pCreatedBar;
|
|
m_pCreatedBar = NULL;
|
|
|
|
TRACE("Failed to create status bar\n");
|
|
|
|
return FALSE; // fail to create
|
|
}
|
|
|
|
m_pStatusBar = m_pCreatedBar;
|
|
m_pStatusBar->m_bAutoDelete = TRUE;
|
|
|
|
m_pStatusBar->GetParentFrame()->RecalcLayout();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void CGenericStatusBar::Attach( CNetscapeStatusBar *pBar )
|
|
{
|
|
m_pStatusBar = pBar;
|
|
}
|
|
|
|
void CGenericStatusBar::Show(BOOL bShow)
|
|
{
|
|
if ( m_pStatusBar ) {
|
|
m_pStatusBar->ShowWindow( bShow ? SW_SHOW : SW_HIDE);
|
|
m_pStatusBar->GetParentFrame()->RecalcLayout();
|
|
}
|
|
}
|
|
|
|
void CGenericStatusBar::ModalStatus( BOOL bModal, UINT uDelay, char * pszTitle )
|
|
{
|
|
if ( bModal != m_bModal ) {
|
|
m_bModal = bModal;
|
|
if ( bModal ) {
|
|
if (!m_pModalStatus && m_pStatusBar ) {
|
|
m_pModalStatus = new CModalStatus;
|
|
m_pModalStatus->Create( m_pStatusBar->GetParentFrame(), uDelay );
|
|
if (pszTitle)
|
|
m_pModalStatus->SetWindowText(pszTitle);
|
|
}
|
|
} else {
|
|
if ( m_pModalStatus ) {
|
|
m_pModalStatus->ProgressComplete();
|
|
m_pModalStatus = NULL;
|
|
}
|
|
}
|
|
SetStatusText( m_csStatus );
|
|
SetProgress( m_iProg );
|
|
}
|
|
}
|
|
|
|
void CGenericStatusBar::SetStatusText(const char * lpszText)
|
|
{
|
|
m_csStatus = lpszText ? lpszText : "";
|
|
|
|
if ( m_bModal ) {
|
|
if ( m_pModalStatus ) {
|
|
m_pModalStatus->SetStatusText( m_csStatus );
|
|
}
|
|
}
|
|
if ( m_pStatusBar ) {
|
|
m_pStatusBar->SetPaneText(m_pStatusBar->CommandToIndex(ID_SEPARATOR), m_csStatus);
|
|
// WHS - if we're showing status for a foreground operation,
|
|
// we need to manually repaint
|
|
m_pStatusBar->UpdateWindow();
|
|
|
|
// Tell ncapi people window is changing position. //JOKI
|
|
if( m_pStatusBar->m_pProxy2Frame) {
|
|
CFrameGlue *pFrame = m_pStatusBar->m_pProxy2Frame;
|
|
if(pFrame->GetMainContext() && pFrame->GetMainContext()->GetContext()->type == MWContextBrowser){
|
|
CStatusBarChangeItem::Changing(pFrame->GetMainContext()->GetContextID(), lpszText);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
const char *CGenericStatusBar::GetStatusText()
|
|
{
|
|
return m_csStatus;
|
|
}
|
|
|
|
void CGenericStatusBar::SetProgress(int iProg)
|
|
{
|
|
m_iProg = iProg < -1 ? 0 : (iProg > 100 ? 100 : iProg);
|
|
|
|
if ( m_bModal ) {
|
|
if ( m_pModalStatus ) {
|
|
m_pModalStatus->SetPercentDone(m_iProg);
|
|
}
|
|
}
|
|
if ( m_pStatusBar ) {
|
|
m_pStatusBar->SetPercentDone(m_iProg);
|
|
}
|
|
}
|
|
|
|
int CGenericStatusBar::GetProgress()
|
|
{
|
|
return m_iProg;
|
|
}
|
|
|
|
void CGenericStatusBar::ProgressComplete()
|
|
{
|
|
ModalStatus( FALSE, 0, NULL );
|
|
}
|
|
|
|
HWND CGenericStatusBar::GetHWnd()
|
|
{
|
|
if (m_pStatusBar)
|
|
return m_pStatusBar->m_hWnd;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
void CGenericStatusBar::StartAnimation()
|
|
{
|
|
//
|
|
// It uses this notification as a cue to be in "Cylon" mode when progress is unspecified.
|
|
//
|
|
if( m_pStatusBar )
|
|
{
|
|
m_pStatusBar->StartAnimation();
|
|
}
|
|
}
|
|
|
|
void CGenericStatusBar::StopAnimation()
|
|
{
|
|
//
|
|
// It uses this notification as a cue to end "Cylon" mode.
|
|
//
|
|
if( m_pStatusBar )
|
|
{
|
|
m_pStatusBar->StopAnimation();
|
|
}
|
|
}
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CStatusBarChangeItem
|
|
|
|
//Begin JOKI
|
|
CPtrList CStatusBarChangeRegistry::m_Registry;
|
|
|
|
void CStatusBarChangeItem::Changing(DWORD dwWindowID, LPCSTR lpStatusMsg)
|
|
{
|
|
POSITION rIndex = m_Registry.GetHeadPosition();
|
|
CStatusBarChangeItem *pChange;
|
|
while(rIndex != NULL) {
|
|
pChange = (CStatusBarChangeItem *)m_Registry.GetNext(rIndex);
|
|
if(pChange->GetWindowID() == dwWindowID) {
|
|
pChange->StatusChanging(lpStatusMsg);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDDEStatusBarChangeItem::StatusChanging(LPCSTR lpStatusMsg)
|
|
{
|
|
//TRACE("----------------"); TRACE(lpStatusMsg); TRACE("\r\n");
|
|
|
|
// Just call the DDE implementation, it will handle the details.
|
|
if(*lpStatusMsg && *lpStatusMsg != ' ' && !IsSameAsLastMsgSent(lpStatusMsg))
|
|
CDDEWrapper::StatusBarChange(this, lpStatusMsg);
|
|
}
|
|
|
|
BOOL CDDEStatusBarChangeItem::IsSameAsLastMsgSent(LPCSTR lpCurMsg)
|
|
{
|
|
|
|
if(m_csLastMsgSent.CompareNoCase(lpCurMsg) == 0)
|
|
return TRUE;
|
|
else
|
|
{
|
|
m_csLastMsgSent = lpCurMsg;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
BOOL CDDEStatusBarChangeItem::DDERegister(CString& csServiceName, DWORD dwWindowID)
|
|
{
|
|
// Purpose: Register a server to monitor when a status bar msg changes
|
|
|
|
// Don't allow the mimimized window to be monitored.
|
|
if(dwWindowID == 0) {
|
|
return(FALSE);
|
|
}
|
|
|
|
// Make sure such a window exists.
|
|
CAbstractCX *pCX = CAbstractCX::FindContextByID(dwWindowID);
|
|
if(NULL == pCX) {
|
|
return(FALSE);
|
|
}
|
|
if(pCX->GetContext()->type != MWContextBrowser) {
|
|
return(FALSE);
|
|
}
|
|
|
|
// Looks like it will work.
|
|
CDDEStatusBarChangeItem *pDontCare = new CDDEStatusBarChangeItem(csServiceName, dwWindowID);
|
|
return(TRUE);
|
|
}
|
|
|
|
BOOL CDDEStatusBarChangeItem::DDEUnRegister(CString& csServiceName, DWORD dwWindowID)
|
|
{
|
|
// Purpose: UnRegister a server to monitor when a status bar msg changes
|
|
|
|
// Allright, we need to go through ever entry in our registry.
|
|
POSITION rIndex = m_Registry.GetHeadPosition();
|
|
CStatusBarChangeItem *pCmp;
|
|
CDDEStatusBarChangeItem *pDelme = NULL;
|
|
while(rIndex != NULL) {
|
|
pCmp = (CStatusBarChangeItem *)m_Registry.GetNext(rIndex);
|
|
pDelme = (CDDEStatusBarChangeItem *)pCmp;
|
|
|
|
if(pDelme->GetServiceName() == csServiceName && pDelme->GetWindowID() == dwWindowID) {
|
|
break;
|
|
}
|
|
pDelme = NULL;
|
|
}
|
|
|
|
if(pDelme == NULL) {
|
|
return(FALSE);
|
|
}
|
|
else {
|
|
delete(pDelme);
|
|
return(TRUE);
|
|
}
|
|
}
|
|
//End JOKI
|
|
|
|
/////////////////////////////////////////////////////////////////////
|
|
// CGenericChrome
|
|
|
|
STDMETHODIMP CGenericChrome::QueryInterface(REFIID refiid, LPVOID * ppv)
|
|
{
|
|
*ppv = NULL;
|
|
if (IsEqualIID(refiid,IID_IUnknown))
|
|
*ppv = (LPUNKNOWN) this;
|
|
else if (IsEqualIID(refiid,IID_IChrome))
|
|
*ppv = (LPCHROME) this;
|
|
else if (IsEqualIID(refiid, IID_INSToolBar))
|
|
*ppv = (LPNSTOOLBAR) m_pToolBar;
|
|
else if (IsEqualIID(refiid, IID_INSAnimation))
|
|
*ppv = (LPNSANIMATION) m_pToolBar;
|
|
else if (IsEqualIID(refiid, IID_INSStatusBar))
|
|
*ppv = (LPNSSTATUSBAR) m_pStatusBar;
|
|
else if (m_pOuterUnk)
|
|
return m_pOuterUnk->QueryInterface(refiid, ppv);
|
|
|
|
if (*ppv != NULL) {
|
|
AddRef();
|
|
return NOERROR;
|
|
}
|
|
|
|
return ResultFromScode(E_NOINTERFACE);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CGenericChrome::AddRef(void)
|
|
{
|
|
if (m_pOuterUnk)
|
|
m_pOuterUnk->AddRef();
|
|
return ++m_ulRefCount;
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CGenericChrome::Release(void)
|
|
{
|
|
ULONG ulRef;
|
|
// Can't do this yet since contexts are not true
|
|
// COM objectects.
|
|
// if (m_pOuterUnk)
|
|
// m_pOuterUnk->Release();
|
|
|
|
ulRef = --m_ulRefCount;
|
|
if (m_ulRefCount == 0) {
|
|
delete this;
|
|
}
|
|
return ulRef;
|
|
}
|
|
// Menu bar stuff
|
|
|
|
void CGenericChrome::SetMenu( UINT nIDResource )
|
|
{
|
|
HMENU hMenuOld = ::GetMenu(m_pParent->m_hWnd);
|
|
HMENU hMenuNew = ::LoadMenu( AfxGetResourceHandle(),
|
|
MAKEINTRESOURCE(nIDResource) );
|
|
if ( hMenuNew ) {
|
|
m_pParent->m_hMenuDefault = hMenuNew;
|
|
if ( hMenuOld ) {
|
|
::DestroyMenu( hMenuOld );
|
|
}
|
|
::SetMenu(m_pParent->m_hWnd, hMenuNew);
|
|
::DrawMenuBar(m_pParent->m_hWnd);
|
|
}
|
|
|
|
HACCEL hAccelOld = m_pParent->m_hAccelTable;
|
|
HACCEL hAccelNew = ::LoadAccelerators( AfxGetResourceHandle(),
|
|
MAKEINTRESOURCE(nIDResource) );
|
|
if( hAccelNew ) {
|
|
if ( hAccelOld ) {
|
|
::FreeResource((HGLOBAL) hAccelOld);
|
|
}
|
|
m_pParent->m_hAccelTable = hAccelNew;
|
|
}
|
|
|
|
}
|
|
|
|
//#ifndef NO_TAB_NAVIGATION
|
|
BOOL CGenericChrome::procTabNavigation( UINT nChar, UINT firstTime, UINT controlKey )
|
|
{
|
|
// spaceBar will be received by child who has focus.
|
|
if( nChar != VK_TAB )
|
|
return( FALSE );
|
|
|
|
|
|
if( ( firstTime || m_tabFocusInChrom == TAB_FOCUS_IN_NULL)
|
|
&& GetToolbarVisible(ID_LOCATION_TOOLBAR) ) {
|
|
// location bar is the first child to get the focus.
|
|
SetToolbarFocus(ID_LOCATION_TOOLBAR);
|
|
m_tabFocusInChrom = TAB_FOCUS_IN_LOCATION_BAR ;
|
|
return TRUE;
|
|
}
|
|
|
|
// I have nothing to tab to.
|
|
m_tabFocusInChrom = TAB_FOCUS_IN_NULL;
|
|
return( FALSE );
|
|
}
|
|
//#endif /* NO_TAB_NAVIGATION */
|
|
|
|
// General Toolbar functionality
|
|
void CGenericChrome::ShowToolbar(UINT nToolbarID, BOOL bShow)
|
|
{
|
|
if(m_pCustToolbar)
|
|
{
|
|
m_pCustToolbar->ShowToolbar(nToolbarID, bShow);
|
|
}
|
|
}
|
|
|
|
BOOL CGenericChrome::GetToolbarVisible(UINT nToolbarID)
|
|
{
|
|
if(m_pCustToolbar)
|
|
return m_pCustToolbar->IsWindowShowing(nToolbarID);
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
CWnd *CGenericChrome::GetToolbar(UINT nToolbarID)
|
|
{
|
|
if(m_pCustToolbar)
|
|
return m_pCustToolbar->GetToolbar(nToolbarID);
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
void CGenericChrome::SetToolbarFocus(UINT nToolbarID)
|
|
{
|
|
if(m_pCustToolbar)
|
|
{
|
|
CWnd *pToolbar = m_pCustToolbar->GetToolbar(nToolbarID);
|
|
if(pToolbar && pToolbar->IsWindowVisible())
|
|
pToolbar->SetFocus();
|
|
}
|
|
}
|
|
|
|
// nPos, bOpen, and bShowing are IN/OUT parameters. Values going in are default values and values
|
|
// coming out are the values from the registry or default if not in the registry. Or if there's
|
|
// another window open of the same type, the values are taken from that window.
|
|
void CGenericChrome::LoadToolbarConfiguration(UINT nToolbarID, CString &csToolbarName, int32 & nPos, BOOL & bOpen, BOOL & bShowing)
|
|
{
|
|
|
|
if(m_pCustToolbar)
|
|
{
|
|
CFrameWnd *pFrame = FEU_GetLastActiveFrameByCustToolbarType(m_toolbarName, m_pParent, TRUE);
|
|
|
|
// if there's another window of this type, copy its settings
|
|
if(pFrame && pFrame != m_pParent && pFrame->IsKindOf(RUNTIME_CLASS(CGenericFrame)))
|
|
{
|
|
CGenericFrame *pGenFrame = (CGenericFrame *)pFrame;
|
|
|
|
CWnd *pToolbar = pGenFrame->GetChrome()->GetCustomizableToolbar()->GetToolbar(nToolbarID);
|
|
|
|
if(pToolbar)
|
|
{
|
|
nPos = pGenFrame->GetChrome()->GetCustomizableToolbar()->GetWindowPosition(pToolbar);
|
|
bShowing = pGenFrame->GetChrome()->GetCustomizableToolbar()->IsWindowShowing(pToolbar);
|
|
bOpen = !pGenFrame->GetChrome()->GetCustomizableToolbar()->IsWindowIconized(pToolbar);
|
|
}
|
|
}
|
|
// otherwise use the settings from the registry.
|
|
else
|
|
{
|
|
CString prefName = CString("custtoolbar.") + m_toolbarName;
|
|
|
|
prefName = prefName + ".";
|
|
prefName = prefName + csToolbarName;
|
|
|
|
int nSize = 100;
|
|
LPTSTR pBuffer = prefName.GetBuffer(nSize);
|
|
FEU_ReplaceChar(pBuffer, ' ', '_');
|
|
prefName.ReleaseBuffer();
|
|
|
|
PREF_GetBoolPref(prefName + ".open", &bOpen);
|
|
PREF_GetIntPref(prefName + ".position", &nPos);
|
|
PREF_GetBoolPref(prefName + ".showing", &bShowing);
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
void CGenericChrome::SaveToolbarConfiguration(UINT nToolbarID, CString &csToolbarName)
|
|
{
|
|
if(m_pCustToolbar)
|
|
{
|
|
// if we aren't supposed to save, then return
|
|
if(!m_pCustToolbar->GetSaveToolbarInfo()) return;
|
|
|
|
CString prefName = CString("custtoolbar.") + m_toolbarName;
|
|
CWnd *pToolbar = m_pCustToolbar->GetToolbar(nToolbarID);
|
|
|
|
if(pToolbar != NULL)
|
|
{
|
|
int nPos = m_pCustToolbar->GetWindowPosition(pToolbar);
|
|
BOOL bShowing = m_pCustToolbar->IsWindowShowing(pToolbar);
|
|
BOOL bOpen = !m_pCustToolbar->IsWindowIconized(pToolbar);
|
|
|
|
prefName = prefName + ".";
|
|
prefName = prefName + csToolbarName;
|
|
|
|
int nSize = 100;
|
|
LPTSTR pBuffer = prefName.GetBuffer(nSize);
|
|
FEU_ReplaceChar(pBuffer, ' ', '_');
|
|
prefName.ReleaseBuffer();
|
|
|
|
PREF_SetIntPref(prefName + ".position", nPos);
|
|
PREF_SetBoolPref(prefName + ".showing", bShowing);
|
|
PREF_SetBoolPref(prefName + ".open", bOpen);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CGenericChrome::SetSaveToolbarInfo(BOOL bSaveToolbarInfo)
|
|
{
|
|
if(m_pCustToolbar)
|
|
m_pCustToolbar->SetSaveToolbarInfo(bSaveToolbarInfo);
|
|
|
|
}
|
|
|
|
// Animation Stuff
|
|
void CGenericChrome::StartAnimation()
|
|
{
|
|
LPNSANIMATION pIAnimation = NULL;
|
|
QueryInterface( IID_INSAnimation, (LPVOID *) &pIAnimation );
|
|
if (pIAnimation) {
|
|
pIAnimation->StartAnimation();
|
|
pIAnimation->Release();
|
|
}
|
|
LPNSSTATUSBAR pIStatusBar = NULL;
|
|
QueryInterface( IID_INSStatusBar, (LPVOID *) &pIStatusBar );
|
|
if ( pIStatusBar ) {
|
|
pIStatusBar->StartAnimation();
|
|
pIStatusBar->Release();
|
|
}
|
|
if(m_pCustToolbar)
|
|
{
|
|
// CCommandToolbar * pCommandToolbar =(CCommandToolbar*)GetToolbar(ID_NAVIGATION_TOOLBAR);
|
|
|
|
// if(pCommandToolbar)
|
|
// pCommandToolbar->ReplaceButton(ID_NAVIGATE_RELOAD, ID_NAVIGATE_INTERRUPT);
|
|
m_pCustToolbar->StartAnimation();
|
|
}
|
|
}
|
|
|
|
void CGenericChrome::StopAnimation()
|
|
{
|
|
LPNSANIMATION pIAnimation = NULL;
|
|
QueryInterface( IID_INSAnimation, (LPVOID *) &pIAnimation );
|
|
if (pIAnimation) {
|
|
pIAnimation->StopAnimation();
|
|
pIAnimation->Release();
|
|
}
|
|
|
|
LPNSSTATUSBAR pIStatusBar = NULL;
|
|
QueryInterface( IID_INSStatusBar, (LPVOID *) &pIStatusBar );
|
|
if ( pIStatusBar ) {
|
|
pIStatusBar->ProgressComplete();
|
|
pIStatusBar->StopAnimation();
|
|
pIStatusBar->Release();
|
|
}
|
|
|
|
if(m_pCustToolbar)
|
|
{
|
|
// CCommandToolbar * pCommandToolbar =(CCommandToolbar*)GetToolbar(ID_NAVIGATION_TOOLBAR);
|
|
|
|
// if(pCommandToolbar)
|
|
// pCommandToolbar->ReplaceButton(ID_NAVIGATE_INTERRUPT, ID_NAVIGATE_RELOAD);
|
|
m_pCustToolbar->StopAnimation();
|
|
}
|
|
}
|
|
|
|
int CGenericChrome::CreateRDFToolbar(CString toolbarName, int nMaxToolbars, BOOL bHasAnimation)
|
|
{
|
|
CRDFToolbarHolder* pHolder = new CRDFToolbarHolder(nMaxToolbars, m_pParent);
|
|
m_pCustToolbar = pHolder;
|
|
|
|
if(! m_pCustToolbar->Create(m_pParent, bHasAnimation))
|
|
return FALSE;
|
|
|
|
m_toolbarName = toolbarName;
|
|
|
|
// Toolbars will start coming in here.
|
|
pHolder->InitializeRDFData();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
int CGenericChrome::CreateCustomizableToolbar(CString toolbarName, int nMaxToolbars, BOOL bHasAnimation)
|
|
{
|
|
m_pCustToolbar=new CCustToolbar(nMaxToolbars);
|
|
|
|
if(! m_pCustToolbar->Create(m_pParent, bHasAnimation))
|
|
return FALSE;
|
|
|
|
m_pParent->RecalcLayout();
|
|
m_toolbarName = toolbarName;
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
int CGenericChrome::CreateCustomizableToolbar(UINT nStringID, int nMaxToolbars, BOOL bHasAnimation)
|
|
{
|
|
CString str;
|
|
|
|
str.LoadString(nStringID);
|
|
|
|
return CreateCustomizableToolbar(str, nMaxToolbars, bHasAnimation);
|
|
|
|
}
|
|
|
|
CString CGenericChrome::GetCustToolbarString()
|
|
{
|
|
return m_toolbarName;
|
|
}
|
|
|
|
void CGenericChrome::RenameCustomizableToolbar(UINT nStringID)
|
|
{
|
|
m_toolbarName.LoadString(nStringID);
|
|
}
|
|
|
|
void CGenericChrome::FinishedAddingBrowserToolbars(void)
|
|
{
|
|
m_pCustToolbar->FinishedAddingNewWindows();
|
|
|
|
}
|
|
|
|
void CGenericChrome::SetToolbarStyle( int nToolbarStyle )
|
|
{
|
|
if(m_pCustToolbar != NULL)
|
|
{
|
|
m_pCustToolbar->SetToolbarStyle(nToolbarStyle);
|
|
}
|
|
}
|
|
|
|
void CGenericChrome::ToolbarActivation()
|
|
{
|
|
if (m_pCustToolbar != NULL)
|
|
m_pCustToolbar->BeActiveToolbar();
|
|
}
|
|
|
|
BOOL CGenericChrome::CustToolbarShowing(void)
|
|
{
|
|
return m_pCustToolbar->IsWindowVisible();
|
|
}
|
|
|
|
void CGenericChrome::ViewCustToolbar(BOOL bShow)
|
|
{
|
|
if( m_pCustToolbar ){
|
|
if(bShow)
|
|
m_pCustToolbar->ShowWindow(SW_SHOWNA);
|
|
else
|
|
m_pCustToolbar->ShowWindow(SW_HIDE);
|
|
|
|
m_pCustToolbar->GetParentFrame()->RecalcLayout();
|
|
}
|
|
}
|
|
|
|
void CGenericChrome::Customize(void)
|
|
{
|
|
|
|
}
|
|
|
|
|
|
CCustToolbar * CGenericChrome::GetCustomizableToolbar(void)
|
|
{
|
|
return m_pCustToolbar;
|
|
}
|
|
|
|
|
|
void CGenericChrome::ImagesButton(BOOL bShowImagesButton)
|
|
{
|
|
|
|
CCommandToolbar * pCommandToolbar =(CCommandToolbar*)GetToolbar(ID_NAVIGATION_TOOLBAR);
|
|
|
|
if(pCommandToolbar)
|
|
{
|
|
if(bShowImagesButton)
|
|
{
|
|
pCommandToolbar->ShowButtonByCommand(ID_VIEW_LOADIMAGES, 5);
|
|
}
|
|
else
|
|
{
|
|
pCommandToolbar->HideButtonByCommand(ID_VIEW_LOADIMAGES);
|
|
}
|
|
}
|
|
}
|
|
|
|
// URL Bar Stuff
|
|
void CGenericChrome::UpdateURLBars(char* url)
|
|
{
|
|
if(m_pCustToolbar)
|
|
m_pCustToolbar->UpdateURLBars(url);
|
|
}
|
|
|
|
// Window Title Stuff
|
|
void CGenericChrome::SetWindowTitle(const char *lpszText)
|
|
{
|
|
m_csWindowTitle = lpszText;
|
|
|
|
CString cs;
|
|
cs = m_csDocTitle;
|
|
if (!m_csDocTitle.IsEmpty()) {
|
|
cs += " - ";
|
|
}
|
|
cs += m_csWindowTitle;
|
|
m_pParent->SetWindowText(cs);
|
|
}
|
|
|
|
void CGenericChrome::SetDocumentTitle(const char *lpszText)
|
|
{
|
|
m_csDocTitle = lpszText;
|
|
|
|
CString cs;
|
|
cs = m_csDocTitle;
|
|
if (!m_csDocTitle.IsEmpty()) {
|
|
cs += " - ";
|
|
}
|
|
cs += m_csWindowTitle;
|
|
m_pParent->SetWindowText(cs);
|
|
}
|
|
|
|
// Constructor and Destructor
|
|
CGenericChrome::CGenericChrome( LPUNKNOWN pOuterUnk )
|
|
{
|
|
// XXX WHS Remove this when you make sure that
|
|
// SetWindowTitle is called in all the right
|
|
// places.
|
|
m_csWindowTitle = XP_AppName;
|
|
|
|
m_bHasStatus = FALSE;
|
|
m_pParent = NULL;
|
|
m_pOuterUnk = pOuterUnk;
|
|
m_ulRefCount = 0;
|
|
m_pToolBar = new CGenericToolBar( (LPUNKNOWN ) this );
|
|
m_pStatusBar = new CGenericStatusBar( (LPUNKNOWN) this );
|
|
m_pCustToolbar = NULL;
|
|
|
|
//#ifndef NO_TAB_NAVIGATION
|
|
m_tabFocusInChrom = TAB_FOCUS_IN_NULL; // I don't have tab focus
|
|
//#endif /* NO_TAB_NAVIGATION */
|
|
|
|
}
|
|
|
|
CGenericChrome::~CGenericChrome()
|
|
{
|
|
ApiApiPtr(api);
|
|
api->RemoveInstance(this);
|
|
|
|
if(m_pCustToolbar != NULL)
|
|
delete m_pCustToolbar;
|
|
|
|
delete m_pToolBar;
|
|
|
|
delete m_pStatusBar;
|
|
}
|
|
|
|
void CGenericChrome::Initialize(CFrameWnd * pParent)
|
|
{
|
|
ASSERT(pParent);
|
|
m_pParent = pParent;
|
|
}
|
|
|
|
//
|
|
// Class Factory
|
|
|
|
class CGenericChromeFactory : public CGenericFactory
|
|
{
|
|
public:
|
|
CGenericChromeFactory();
|
|
~CGenericChromeFactory();
|
|
// IClassFactory Interface
|
|
STDMETHODIMP CreateInstance(LPUNKNOWN,REFIID,LPVOID*);
|
|
};
|
|
|
|
STDMETHODIMP CGenericChromeFactory::CreateInstance(
|
|
LPUNKNOWN pUnkOuter,REFIID refiid, LPVOID * ppvObj)
|
|
{
|
|
*ppvObj = NULL;
|
|
CGenericChrome * pChrome = new CGenericChrome( pUnkOuter );
|
|
return pChrome->QueryInterface(refiid,ppvObj);
|
|
}
|
|
|
|
|
|
CGenericChromeFactory::CGenericChromeFactory()
|
|
{
|
|
ApiApiPtr(api);
|
|
api->RegisterClassFactory(APICLASS_CHROME,(LPCLASSFACTORY)this);
|
|
}
|
|
|
|
CGenericChromeFactory::~CGenericChromeFactory()
|
|
{
|
|
}
|
|
|
|
DECLARE_FACTORY(CGenericChromeFactory);
|