923 lines
26 KiB
C++
923 lines
26 KiB
C++
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1999
|
|
//
|
|
// File: childfrm.cpp
|
|
//
|
|
// Contents: Child frame implementation
|
|
//
|
|
// History: 01-Jan-96 TRomano Created
|
|
// 16-Jul-96 WayneSc Add code to switch views
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
#include "stdafx.h"
|
|
#include "AMC.h"
|
|
#include "ChildFrm.h"
|
|
#include "AMCDoc.h"
|
|
#include "AMCView.h"
|
|
#include "treectrl.h"
|
|
#include "afxpriv.h"
|
|
#include "mainfrm.h"
|
|
#include "amcpriv.h"
|
|
#include "sysmenu.h"
|
|
#include "amcmsgid.h"
|
|
#include "caption.h"
|
|
#include "strings.h"
|
|
#include "menubtns.h"
|
|
|
|
bool CanCloseDoc(void);
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CChildFrame
|
|
|
|
IMPLEMENT_DYNCREATE(CChildFrame, CMDIChildWnd)
|
|
|
|
BEGIN_MESSAGE_MAP(CChildFrame, CMDIChildWnd)
|
|
//{{AFX_MSG_MAP(CChildFrame)
|
|
ON_WM_CREATE()
|
|
ON_WM_SIZE()
|
|
ON_WM_DESTROY()
|
|
ON_WM_CLOSE()
|
|
ON_WM_MDIACTIVATE()
|
|
ON_COMMAND(ID_CUSTOMIZE_VIEW, OnCustomizeView)
|
|
ON_WM_NCPAINT()
|
|
ON_WM_NCACTIVATE()
|
|
ON_WM_SYSCOMMAND()
|
|
ON_WM_INITMENUPOPUP()
|
|
//}}AFX_MSG_MAP
|
|
|
|
ON_MESSAGE(WM_SETTEXT, OnSetText)
|
|
ON_MESSAGE(WM_GETICON, OnGetIcon)
|
|
ON_MESSAGE(WM_SETMESSAGESTRING, OnSetMessageString)
|
|
ON_COMMAND_RANGE(ID_MMC_MAXIMIZE, ID_MMC_RESTORE, OnMaximizeOrRestore)
|
|
ON_UPDATE_COMMAND_UI(ID_CUSTOMIZE_VIEW, OnUpdateCustomizeView)
|
|
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CChildFrame construction/destruction
|
|
|
|
CChildFrame::CChildFrame()
|
|
{
|
|
m_pAMCView = NULL;
|
|
m_fDestroyed = false;
|
|
m_fCurrentlyMinimized = false;
|
|
m_fCurrentlyActive = false;
|
|
m_fCreateVisible = true;
|
|
}
|
|
|
|
CChildFrame::~CChildFrame()
|
|
{
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CChildFrame diagnostics
|
|
|
|
#ifdef _DEBUG
|
|
void CChildFrame::AssertValid() const
|
|
{
|
|
CMDIChildWnd::AssertValid();
|
|
}
|
|
|
|
void CChildFrame::Dump(CDumpContext& dc) const
|
|
{
|
|
CMDIChildWnd::Dump(dc);
|
|
}
|
|
|
|
#endif //_DEBUG
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CChildFrame message handlers
|
|
|
|
BOOL CChildFrame::PreCreateWindow(CREATESTRUCT& cs)
|
|
{
|
|
BOOL bSuccess=FALSE;
|
|
|
|
// Let default implementation fill in most of the details
|
|
if (!CMDIChildWnd::PreCreateWindow(cs))
|
|
return (FALSE);
|
|
|
|
// Remove the edge from the window so the splitter can paint it.
|
|
cs.dwExStyle &=~WS_EX_CLIENTEDGE;
|
|
|
|
WNDCLASS wc;
|
|
LPCTSTR pszChildFrameClassName = g_szChildFrameClassName;
|
|
|
|
if (::GetClassInfo(AfxGetInstanceHandle(), cs.lpszClass, &wc))
|
|
{
|
|
// Clear the H and V REDRAW flags
|
|
wc.style &= ~(CS_HREDRAW | CS_VREDRAW);
|
|
wc.hIcon = AfxGetApp()->LoadIcon(IDR_AMCTYPE);
|
|
wc.lpszClassName = pszChildFrameClassName;
|
|
|
|
// Register this new style;
|
|
bSuccess=AfxRegisterClass(&wc);
|
|
}
|
|
|
|
|
|
// Use the new child frame window class
|
|
cs.lpszClass = pszChildFrameClassName;
|
|
//cs.style &= ~FWS_ADDTOTITLE;
|
|
|
|
// force maximized if in SDI User mode
|
|
if (AMCGetApp()->GetMode() == eMode_User_SDI)
|
|
cs.style |= WS_MAXIMIZE;
|
|
|
|
// do not paint over the children
|
|
cs.style |= WS_CLIPCHILDREN;
|
|
|
|
return bSuccess;
|
|
}
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
*
|
|
* CChildFrame::OnUpdateFrameTitle
|
|
*
|
|
* PURPOSE: Sets the window title. It might be possible to short out this
|
|
* function.
|
|
*
|
|
* PARAMETERS:
|
|
* BOOL bAddToTitle :
|
|
*
|
|
* RETURNS:
|
|
* void
|
|
*
|
|
*+-------------------------------------------------------------------------*/
|
|
void
|
|
CChildFrame::OnUpdateFrameTitle(BOOL bAddToTitle)
|
|
{
|
|
DECLARE_SC(sc,TEXT("CChildFrame::OnUpdateFrameTitle"));
|
|
|
|
if ((GetStyle() & FWS_ADDTOTITLE) == 0)
|
|
return; // leave child window alone!
|
|
|
|
CDocument* pDocument = GetActiveDocument();
|
|
if (bAddToTitle && pDocument != NULL)
|
|
{
|
|
sc = ScCheckPointers(m_pAMCView, E_UNEXPECTED);
|
|
if(sc)
|
|
return;
|
|
|
|
sc = ScCheckPointers(m_pAMCView->GetWindowTitle());
|
|
if(sc)
|
|
return;
|
|
|
|
// set title if changed, but don't remove completely
|
|
AfxSetWindowText(m_hWnd, m_pAMCView->GetWindowTitle());
|
|
}
|
|
|
|
// update our parent window last
|
|
GetMDIFrame()->OnUpdateFrameTitle(bAddToTitle);
|
|
}
|
|
|
|
int CChildFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
|
|
{
|
|
static UINT anIndicators[] =
|
|
{
|
|
ID_SEPARATOR, // status line indicator
|
|
IDS_PROGRESS, // place holder for progress bar
|
|
IDS_STATUS_STATIC, // place holder for static control
|
|
};
|
|
|
|
DECLARE_SC (sc, _T("CChildFrame::OnCreate"));
|
|
|
|
if (CMDIChildWnd::OnCreate(lpCreateStruct) == -1)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
* status bar should be themed (block controls the scope of activator)
|
|
*/
|
|
{
|
|
CThemeContextActivator activator;
|
|
|
|
// Create the status bar and panes
|
|
m_wndStatusBar.Create(this, WS_CHILD|WS_VISIBLE|SBARS_SIZEGRIP, 0x1003);
|
|
m_wndStatusBar.CreatePanes(anIndicators, countof(anIndicators));
|
|
}
|
|
|
|
// Add the control to the dock site
|
|
m_StatusDockSite.Create(CDockSite::DSS_BOTTOM);
|
|
m_StatusDockSite.Attach(&m_wndStatusBar);
|
|
m_StatusDockSite.Show();
|
|
|
|
// Tell the dock manager about the site.
|
|
m_DockingManager.Attach(&m_StatusDockSite);
|
|
|
|
CAMCView* const pAMCView = GetAMCView();
|
|
if (pAMCView == NULL)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return -1;
|
|
}
|
|
|
|
pAMCView->SetChildFrameWnd(m_hWnd);
|
|
|
|
SViewData* pVD = pAMCView->GetViewData();
|
|
if (NULL == pVD)
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return -1;
|
|
}
|
|
|
|
// Create the menubuttons manager and toolbars manager (one per view).
|
|
m_spMenuButtonsMgr = std::auto_ptr<CMenuButtonsMgrImpl>(new CMenuButtonsMgrImpl());
|
|
if (NULL == m_spMenuButtonsMgr.get())
|
|
{
|
|
sc = E_UNEXPECTED;
|
|
return -1;
|
|
}
|
|
|
|
// Let SViewData be aware of the CMenuButtonsMgr.
|
|
pVD->SetMenuButtonsMgr(static_cast<CMenuButtonsMgr*>(m_spMenuButtonsMgr.get()));
|
|
|
|
CMainFrame* pFrame = AMCGetMainWnd();
|
|
sc = ScCheckPointers (pFrame, E_UNEXPECTED);
|
|
if (sc)
|
|
return -1;
|
|
|
|
ASSERT_KINDOF (CMainFrame, pFrame);
|
|
|
|
// Init the CMenuButtonsMgr.
|
|
sc = m_spMenuButtonsMgr->ScInit(pFrame, this);
|
|
if (sc)
|
|
return -1;
|
|
|
|
// Create the Standard toolbar UI.
|
|
pVD->m_spNodeManager->InitViewData(reinterpret_cast<LONG_PTR>(pVD));
|
|
ASSERT(pVD->m_spVerbSet != NULL);
|
|
|
|
AppendToSystemMenu (this, eMode_User_SDI);
|
|
RenderDockSites();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
void CChildFrame::RenderDockSites()
|
|
{
|
|
CRect clientRect;
|
|
GetClientRect(&clientRect);
|
|
|
|
CWnd* pWnd=GetWindow(GW_CHILD);
|
|
|
|
if(pWnd)
|
|
{
|
|
m_DockingManager.BeginLayout();
|
|
m_DockingManager.RenderDockSites(pWnd->m_hWnd, clientRect);
|
|
m_DockingManager.EndLayout();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
bool CChildFrame::IsCustomizeViewEnabled()
|
|
{
|
|
bool fEnable = false;
|
|
CAMCDoc* pDoc = CAMCDoc::GetDocument();
|
|
|
|
if (pDoc != NULL)
|
|
{
|
|
fEnable = (AMCGetApp()->GetMode() == eMode_Author) ||
|
|
pDoc->AllowViewCustomization();
|
|
}
|
|
|
|
return (fEnable);
|
|
}
|
|
|
|
void CChildFrame::OnUpdateCustomizeView(CCmdUI* pCmdUI)
|
|
{
|
|
pCmdUI->Enable (IsCustomizeViewEnabled());
|
|
}
|
|
|
|
// Display Customize View dialog
|
|
// When a child window is maximized, then it becomes a CMainFrame so the handler is
|
|
// necessary here to process the Scope Pane command on the system menu
|
|
void CChildFrame::OnCustomizeView()
|
|
{
|
|
CAMCView* pView = GetAMCView();
|
|
|
|
if (pView != NULL)
|
|
{
|
|
INodeCallback* pCallback = pView->GetNodeCallback();
|
|
SViewData* pViewData = pView->GetViewData();
|
|
|
|
ASSERT (pCallback != NULL);
|
|
ASSERT (pViewData != NULL);
|
|
|
|
pCallback->OnCustomizeView (reinterpret_cast<LONG_PTR>(pViewData));
|
|
}
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CChildFrame::OnInitMenuPopup
|
|
*
|
|
* WM_INITMENUPOPUP handler for CChildFrame.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CChildFrame::OnInitMenuPopup(CMenu* pPopupMenu, UINT nIndex, BOOL bSysMenu)
|
|
{
|
|
/*
|
|
* Bug 201113: don't allow child system menus in SDI mode
|
|
*/
|
|
if (bSysMenu && (AMCGetApp()->GetMode() == eMode_User_SDI))
|
|
{
|
|
SendMessage (WM_CANCELMODE);
|
|
return;
|
|
}
|
|
|
|
CMDIChildWnd::OnInitMenuPopup(pPopupMenu, nIndex, bSysMenu);
|
|
|
|
/*
|
|
* CFrameWnd::OnInitMenuPopup doesn't do UI updates for system menus,
|
|
* so we have to do it here
|
|
*/
|
|
if (bSysMenu)
|
|
{
|
|
int nEnable = IsCustomizeViewEnabled() ? MF_ENABLED : MF_GRAYED;
|
|
pPopupMenu->EnableMenuItem (ID_CUSTOMIZE_VIEW, MF_BYCOMMAND | nEnable);
|
|
}
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CChildFrame::OnSize
|
|
*
|
|
* WM_SIZE handler for CChildFrame.
|
|
*--------------------------------------------------------------------------*/
|
|
void CChildFrame::OnSize(UINT nType, int cx, int cy)
|
|
{
|
|
DECLARE_SC(sc, TEXT("CChildFrame::OnSize"));
|
|
|
|
// bypass CMDIChildWnd::OnSize so we won't get MFC's docking stuff
|
|
// (we still need to call Default so Windows' MDI stuff will work right)
|
|
CWnd::OnSize(nType, cx, cy);
|
|
|
|
if (nType != SIZE_MINIMIZED)
|
|
{
|
|
RenderDockSites();
|
|
CAMCView* pAMCView = GetAMCView();
|
|
ASSERT (pAMCView != NULL);
|
|
|
|
if (pAMCView)
|
|
pAMCView->AdjustTracker (cx, cy);
|
|
}
|
|
|
|
|
|
// update our parent frame - in case we are now maximized or not
|
|
CMDIFrameWnd* pwndMDIFrame = GetMDIFrame();
|
|
|
|
if (pwndMDIFrame)
|
|
pwndMDIFrame->OnUpdateFrameTitle(TRUE);
|
|
|
|
/*
|
|
* If we're moving to or from the minimized state, notify snap-ins.
|
|
* We don't need to send the notification if we're only creating a
|
|
* temporary view that will never be shown.
|
|
*/
|
|
if (m_fCurrentlyMinimized != (nType == SIZE_MINIMIZED) && m_fCreateVisible)
|
|
{
|
|
m_fCurrentlyMinimized = (nType == SIZE_MINIMIZED);
|
|
SendMinimizeNotification (m_fCurrentlyMinimized);
|
|
}
|
|
|
|
// send the size notification to the view.
|
|
if(GetAMCView())
|
|
{
|
|
sc = GetAMCView()->ScOnSize(nType, cx, cy);
|
|
if(sc)
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
BOOL CChildFrame::Create(LPCTSTR lpszClassName, LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect, CMDIFrameWnd* pParentWnd, CCreateContext* pContext)
|
|
{
|
|
if (pParentWnd == NULL)
|
|
{
|
|
CWnd* pMainWnd = AfxGetThread()->m_pMainWnd;
|
|
ASSERT(pMainWnd != NULL);
|
|
ASSERT_KINDOF(CMDIFrameWnd, pMainWnd);
|
|
pParentWnd = (CMDIFrameWnd*)pMainWnd;
|
|
}
|
|
ASSERT(::IsWindow(pParentWnd->m_hWndMDIClient));
|
|
|
|
// first copy into a CREATESTRUCT for PreCreate
|
|
CREATESTRUCT cs;
|
|
cs.dwExStyle = 0L;
|
|
cs.lpszClass = lpszClassName;
|
|
cs.lpszName = lpszWindowName;
|
|
cs.style = dwStyle;
|
|
cs.x = rect.left;
|
|
cs.y = rect.top;
|
|
cs.cx = rect.right - rect.left;
|
|
cs.cy = rect.bottom - rect.top;
|
|
cs.hwndParent = pParentWnd->m_hWnd;
|
|
cs.hMenu = NULL;
|
|
cs.hInstance = AfxGetInstanceHandle();
|
|
cs.lpCreateParams = (LPVOID)pContext;
|
|
|
|
if (!PreCreateWindow(cs))
|
|
{
|
|
PostNcDestroy();
|
|
return FALSE;
|
|
}
|
|
// extended style must be zero for MDI Children (except under Win4)
|
|
// ASSERT(afxData.bWin4 || cs.dwExStyle == 0);
|
|
ASSERT(cs.hwndParent == pParentWnd->m_hWnd); // must not change
|
|
|
|
// now copy into a MDICREATESTRUCT for real create
|
|
MDICREATESTRUCT mcs;
|
|
mcs.szClass = cs.lpszClass;
|
|
mcs.szTitle = cs.lpszName;
|
|
mcs.hOwner = cs.hInstance;
|
|
mcs.x = cs.x;
|
|
mcs.y = cs.y;
|
|
mcs.cx = cs.cx;
|
|
mcs.cy = cs.cy;
|
|
mcs.style = cs.style & ~(WS_MAXIMIZE | WS_VISIBLE);
|
|
mcs.lParam = reinterpret_cast<LPARAM>(cs.lpCreateParams);
|
|
|
|
// create the window through the MDICLIENT window
|
|
AfxHookWindowCreate(this);
|
|
HWND hWnd = (HWND)::SendMessage(pParentWnd->m_hWndMDIClient,
|
|
WM_MDICREATE, 0, (LPARAM)&mcs);
|
|
if (!AfxUnhookWindowCreate())
|
|
PostNcDestroy(); // cleanup if MDICREATE fails too soon
|
|
|
|
if (hWnd == NULL)
|
|
return FALSE;
|
|
|
|
// special handling of visibility (always created invisible)
|
|
if (cs.style & WS_VISIBLE)
|
|
{
|
|
// place the window on top in z-order before showing it
|
|
::BringWindowToTop(hWnd);
|
|
|
|
// show it as specified
|
|
if (cs.style & WS_MINIMIZE)
|
|
ShowWindow(SW_SHOWMINIMIZED);
|
|
else if (cs.style & WS_MAXIMIZE)
|
|
ShowWindow(SW_SHOWMAXIMIZED);
|
|
else
|
|
ShowWindow(SW_SHOWNORMAL);
|
|
|
|
// make sure it is active (visibility == activation)
|
|
pParentWnd->MDIActivate(this);
|
|
|
|
// refresh MDI Window menu
|
|
::SendMessage(pParentWnd->m_hWndMDIClient, WM_MDIREFRESHMENU, 0, 0);
|
|
}
|
|
|
|
ASSERT(hWnd == m_hWnd);
|
|
return TRUE;
|
|
}
|
|
|
|
void CChildFrame::OnDestroy()
|
|
{
|
|
// NOTE - The un-hooking of the dock manager stops the rebar sending a height change
|
|
// when the rebar goes away.
|
|
m_DockingManager.RemoveAll();
|
|
|
|
m_fDestroyed = true;
|
|
|
|
CMDIChildWnd::OnDestroy();
|
|
}
|
|
|
|
void CChildFrame::OnMaximizeOrRestore(UINT nID)
|
|
{
|
|
ASSERT(nID == ID_MMC_MAXIMIZE || nID == ID_MMC_RESTORE);
|
|
|
|
WINDOWPLACEMENT wp;
|
|
wp.length = sizeof(wp);
|
|
GetWindowPlacement(&wp);
|
|
|
|
UINT newShowCmd = (nID == ID_MMC_MAXIMIZE) ? SW_SHOWMAXIMIZED : SW_SHOWNORMAL;
|
|
|
|
if (wp.showCmd != newShowCmd)
|
|
{
|
|
wp.showCmd = newShowCmd;
|
|
SetWindowPlacement(&wp);
|
|
}
|
|
}
|
|
|
|
|
|
void CChildFrame::OnClose()
|
|
{
|
|
CAMCDoc* pDoc = CAMCDoc::GetDocument();
|
|
ASSERT(pDoc != NULL);
|
|
if (pDoc)
|
|
{
|
|
int cViews = 0;
|
|
CAMCViewPosition pos = pDoc->GetFirstAMCViewPosition();
|
|
while (pos != NULL)
|
|
{
|
|
CAMCView* pView = pDoc->GetNextAMCView(pos);
|
|
|
|
if ((pView != NULL) && ++cViews >= 2)
|
|
break;
|
|
}
|
|
|
|
if (cViews == 1)
|
|
{
|
|
if (!CanCloseDoc())
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
// if not closing last view, then give it
|
|
// a chance to clean up first.
|
|
// (if whole doc is closing CAMCDoc will handle
|
|
// closing all the views.)
|
|
CAMCView* pView = GetAMCView();
|
|
if (pView != NULL)
|
|
{
|
|
CAMCDoc* pAMCDoc = CAMCDoc::GetDocument();
|
|
|
|
/*
|
|
* Don't allow the user to close the last persisted view.
|
|
*/
|
|
if (pView->IsPersisted() &&
|
|
(pAMCDoc != NULL) &&
|
|
(pAMCDoc->GetNumberOfPersistedViews() == 1))
|
|
{
|
|
MMCMessageBox (IDS_CantCloseLastPersistableView);
|
|
return;
|
|
}
|
|
|
|
pView->CloseView();
|
|
}
|
|
}
|
|
}
|
|
|
|
CMDIChildWnd::OnClose();
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CChildFrame::OnUpdateFrameMenu
|
|
*
|
|
* WM_UPDATEFRAMEMENU handler for CChildFrame.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CChildFrame::OnUpdateFrameMenu(BOOL bActivate, CWnd* pActivateWnd,
|
|
HMENU hMenuAlt)
|
|
{
|
|
ASSERT_VALID (this);
|
|
DECLARE_SC (sc, _T("CChildFrame::OnUpdateFrameMenu"));
|
|
|
|
// let the base class select the right menu
|
|
CMDIChildWnd::OnUpdateFrameMenu (bActivate, pActivateWnd, hMenuAlt);
|
|
|
|
// make sure the child has the WS_SYSMENU bit
|
|
// (it won't if it's created maximized)
|
|
ModifyStyle (0, WS_SYSMENU);
|
|
|
|
// by now, the right menu is selected; reflect it to the toolbar
|
|
CMainFrame* pFrame = static_cast<CMainFrame *>(GetParentFrame ());
|
|
ASSERT_KINDOF (CMainFrame, pFrame);
|
|
pFrame->NotifyMenuChanged ();
|
|
|
|
// Add the menubuttons only on activate, the CMenubar
|
|
// removes all menus during deactivate.
|
|
if (bActivate)
|
|
{
|
|
ASSERT(NULL != m_spMenuButtonsMgr.get());
|
|
if (NULL != m_spMenuButtonsMgr.get())
|
|
{
|
|
// Now add the menu buttons to main menu
|
|
sc = m_spMenuButtonsMgr->ScAddMenuButtonsToMainMenu();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CChildFrame::OnGetIcon
|
|
*
|
|
* WM_GETICON handler for CChildFrame.
|
|
*
|
|
* NOTE: the control over the icon remains with the callee - it is responsible
|
|
* for releasing the resource. Coller should never release the returned
|
|
* handle
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
LRESULT CChildFrame::OnGetIcon (WPARAM wParam, LPARAM lParam)
|
|
{
|
|
CAMCDoc* pDoc = CAMCDoc::GetDocument();
|
|
|
|
/*
|
|
* use the custom icon if we have one
|
|
*/
|
|
if ((pDoc != NULL) && pDoc->HasCustomIcon())
|
|
return ((LRESULT) pDoc->GetCustomIcon ((wParam == ICON_BIG)));
|
|
|
|
/*
|
|
* no custom icon, use the default icon
|
|
*/
|
|
const int cxIcon = GetSystemMetrics ((wParam == ICON_BIG) ? SM_CXICON : SM_CXSMICON);
|
|
const int cyIcon = GetSystemMetrics ((wParam == ICON_BIG) ? SM_CYICON : SM_CYSMICON);
|
|
|
|
// use cached copy - it never changes
|
|
// do not delete this ever - since we only have one copy,
|
|
// we do not leak. releassing is expensive and does not pay off
|
|
static HICON s_hMMCIcon = (HICON)::LoadImage (AfxGetResourceHandle(),
|
|
MAKEINTRESOURCE (IDR_AMCTYPE),
|
|
IMAGE_ICON, cxIcon, cyIcon, 0);
|
|
|
|
return (LRESULT)s_hMMCIcon;
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CChildFrame::OnSysCommand
|
|
*
|
|
* WM_SYSCOMMAND handler for CChildFrame.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CChildFrame::OnSysCommand(UINT nID, LPARAM lParam)
|
|
{
|
|
switch (nID)
|
|
{
|
|
case ID_CUSTOMIZE_VIEW:
|
|
OnCustomizeView();
|
|
break;
|
|
|
|
case SC_CLOSE:
|
|
{
|
|
// eat Ctrl+F4 in SDI simulation mode...
|
|
if (AMCGetApp()->GetMode() == eMode_User_SDI)
|
|
break;
|
|
|
|
// ...or if Close is disabled or doesn't exist on the system menu
|
|
CMenu* pSysMenu = GetSystemMenu (FALSE);
|
|
UINT nCloseState = pSysMenu->GetMenuState (SC_CLOSE, MF_BYCOMMAND);
|
|
|
|
if ((nCloseState == 0xFFFFFFFF) ||
|
|
(nCloseState & (MF_GRAYED | MF_DISABLED)))
|
|
break;
|
|
|
|
// all systems go, let MDI have it
|
|
CMDIChildWnd::OnSysCommand(nID, lParam);
|
|
break;
|
|
}
|
|
|
|
case SC_NEXTWINDOW:
|
|
case SC_PREVWINDOW:
|
|
// eat Ctrl+(Shift+)Tab and Ctrl+(Shift+)F6 in SDI simulation mode
|
|
if (AMCGetApp()->GetMode() != eMode_User_SDI)
|
|
CMDIChildWnd::OnSysCommand(nID, lParam);
|
|
break;
|
|
|
|
default:
|
|
CMDIChildWnd::OnSysCommand(nID, lParam);
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CChildFrame::GetDefaultAccelerator
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
HACCEL CChildFrame::GetDefaultAccelerator()
|
|
{
|
|
// use document specific accelerator table ONLY
|
|
// Dont use CFrameWnd::m_hAccel, because we don't base accelerators
|
|
// on document type but rather on mode. This is taken care of
|
|
// in CAMCDoc.
|
|
return (NULL);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CChildFrame::OnSetMessageString
|
|
*
|
|
* WM_SETMESSAGESTRING handler for CChildFrame.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
LRESULT CChildFrame::OnSetMessageString(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
/*
|
|
* if this we're going to set the idle message string and we've
|
|
* been given a custom status line string, use that one instead
|
|
*/
|
|
if ((wParam == AFX_IDS_IDLEMESSAGE) && !m_strStatusText.IsEmpty())
|
|
{
|
|
ASSERT (lParam == 0);
|
|
wParam = 0;
|
|
lParam = (LPARAM)(LPCTSTR) m_strStatusText;
|
|
}
|
|
|
|
// sometimes we'll get a WM_SETMESSAGESTRING after being destroyed,
|
|
// don't pass it through or we'll crash inside the status bar code
|
|
if (m_fDestroyed)
|
|
return (0);
|
|
|
|
return (CMDIChildWnd::OnSetMessageString (wParam, lParam));
|
|
}
|
|
|
|
void CChildFrame::ToggleStatusBar ()
|
|
{
|
|
m_StatusDockSite.Toggle();
|
|
RenderDockSites();
|
|
|
|
if (m_StatusDockSite.IsVisible())
|
|
UpdateStatusText ();
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CChildFrame::OnMDIActivate
|
|
*
|
|
* WM_MDIACTIVATE handler for CChildFrame.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CChildFrame::OnMDIActivate(BOOL bActivate, CWnd* pActivateWnd, CWnd* pDeactivateWnd)
|
|
{
|
|
DECLARE_SC (sc, _T("CChildFrame::OnMDIActivate"));
|
|
SetChildFrameActive(bActivate);
|
|
|
|
CMDIChildWnd::OnMDIActivate(bActivate, pActivateWnd, pDeactivateWnd);
|
|
|
|
sc = ScCheckPointers(m_pAMCView, E_UNEXPECTED);
|
|
if (sc)
|
|
return;
|
|
|
|
if (bActivate)
|
|
{
|
|
// If the window being de-activated is not of childframe type then this
|
|
// is the first active view (childframe).
|
|
bool bFirstActiveView = pDeactivateWnd ? (FALSE == pDeactivateWnd->IsKindOf (RUNTIME_CLASS (CChildFrame)))
|
|
: true;
|
|
sc = m_pAMCView->ScFireEvent(CAMCViewObserver::ScOnActivateView, m_pAMCView, bFirstActiveView);
|
|
|
|
// if activation changes - need to set frame to dirty
|
|
CAMCDoc* pDoc = CAMCDoc::GetDocument ();
|
|
|
|
if (pDoc == NULL)
|
|
(sc = E_UNEXPECTED).TraceAndClear();
|
|
else
|
|
{
|
|
pDoc->SetFrameModifiedFlag (true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If the window being activated is not of childframe type then this is
|
|
// the last active view (childframe).
|
|
bool bLastActiveView = pActivateWnd ? (FALSE == pActivateWnd->IsKindOf (RUNTIME_CLASS (CChildFrame)))
|
|
: true;
|
|
sc = m_pAMCView->ScFireEvent(CAMCViewObserver::ScOnDeactivateView, m_pAMCView, bLastActiveView);
|
|
}
|
|
|
|
if (sc)
|
|
return;
|
|
|
|
/*
|
|
* Notify snap-ins of an activation change
|
|
*/
|
|
NotifyCallback (NCLBK_ACTIVATE, bActivate, 0);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CChildFrame::SendMinimizeNotification
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CChildFrame::SendMinimizeNotification (bool fMinimized) const
|
|
{
|
|
if(m_pAMCView != NULL)
|
|
m_pAMCView->ScOnMinimize(m_fCurrentlyMinimized);
|
|
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CChildFrame::NotifyCallback
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
HRESULT CChildFrame::NotifyCallback (
|
|
NCLBK_NOTIFY_TYPE event,
|
|
LONG_PTR arg,
|
|
LPARAM param) const
|
|
{
|
|
if (m_pAMCView == NULL)
|
|
return (E_FAIL);
|
|
|
|
HNODE hNode = m_pAMCView->GetSelectedNode();
|
|
|
|
if (hNode == NULL)
|
|
return (E_FAIL);
|
|
|
|
INodeCallback* pNodeCallback = m_pAMCView->GetNodeCallback();
|
|
|
|
if (pNodeCallback == NULL)
|
|
return (E_FAIL);
|
|
|
|
return (pNodeCallback->Notify (hNode, event, arg, param));
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CChildFrame::OnNcPaint
|
|
*
|
|
* WM_NCPAINT handler for CChildFrame.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CChildFrame::OnNcPaint()
|
|
{
|
|
Default();
|
|
DrawFrameCaption (this, m_fCurrentlyActive);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CChildFrame::OnNcActivate
|
|
*
|
|
* WM_NCACTIVATE handler for CChildFrame.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
BOOL CChildFrame::OnNcActivate(BOOL bActive)
|
|
{
|
|
BOOL rc = CMDIChildWnd::OnNcActivate(bActive);
|
|
|
|
m_fCurrentlyActive = bActive;
|
|
DrawFrameCaption (this, m_fCurrentlyActive);
|
|
|
|
return (rc);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CChildFrame::OnSetText
|
|
*
|
|
* WM_SETTEXT handler for CChildFrame.
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
LRESULT CChildFrame::OnSetText (WPARAM wParam, LPARAM lParam)
|
|
{
|
|
LRESULT rc = Default();
|
|
DrawFrameCaption (this, m_fCurrentlyActive);
|
|
|
|
return (rc);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CChildFrame::ActivateFrame
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
void CChildFrame::ActivateFrame(int nCmdShow /*= -1*/)
|
|
{
|
|
if ((nCmdShow == -1) && !m_fCreateVisible)
|
|
nCmdShow = SW_SHOWNOACTIVATE;
|
|
/*
|
|
* When this flag [m_fCreateVisible] is set, the frame will show itself with the
|
|
* SW_SHOWMINNOACTIVE flag instead of the default flag. Doing this will
|
|
* avoid the side effect of restoring the currently active child frame
|
|
* if it is maximized at the time the new frame is created invisibly.
|
|
*/
|
|
// The SW_SHOWMINNOACTIVE was changed to SW_SHOWNOACTIVATE.
|
|
// It does preserve the active window from mentioned side effect,
|
|
// plus it also allows scripts (using Object Moded) to create invisible views,
|
|
// position and then show them as normal (not minimized) windows,
|
|
// thus providing same result as creating visible and then hiding the view.
|
|
// While minimized window must be restored first in order to change their position.
|
|
|
|
CMDIChildWnd::ActivateFrame (nCmdShow);
|
|
}
|
|
|
|
|
|
/*+-------------------------------------------------------------------------*
|
|
* CChildFrame::SetCreateVisible
|
|
*
|
|
*
|
|
*--------------------------------------------------------------------------*/
|
|
|
|
bool CChildFrame::SetCreateVisible (bool fCreateVisible)
|
|
{
|
|
bool fOldState = m_fCreateVisible;
|
|
m_fCreateVisible = fCreateVisible;
|
|
|
|
return (fOldState);
|
|
}
|