winmini.cpp

vc6.0完整版

// This is a part of the Microsoft Foundation Classes C++ library.
// Copyright (C) 1992-1998 Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Microsoft Foundation Classes Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Microsoft Foundation Classes product.

#include "stdafx.h"

#ifdef AFX_CORE4_SEG
#pragma code_seg(AFX_CORE4_SEG)
#endif

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

#pragma warning(disable: 4706) // assignment within conditional

/////////////////////////////////////////////////////////////////////////////
// CMiniFrameWnd global data

AFX_STATIC_DATA HBITMAP _afx_hbmMiniSys = 0;
AFX_STATIC_DATA HFONT _afx_hfontMiniSys = 0;
AFX_STATIC_DATA SIZE _afx_sizeMiniSys = { 0, 0 };

void AFX_CDECL _AfxWinminiTerm()
{
	AfxDeleteObject((HGDIOBJ*)&_afx_hbmMiniSys);
	AfxDeleteObject((HGDIOBJ*)&_afx_hfontMiniSys);
}
int _afxWinminiTerm = atexit(_AfxWinminiTerm);

/////////////////////////////////////////////////////////////////////////////
// CMiniFrameWnd

BEGIN_MESSAGE_MAP(CMiniFrameWnd, CFrameWnd)
	//{{AFX_MSG_MAP(CMiniFrameWnd)
	ON_WM_NCPAINT()
	ON_WM_NCACTIVATE()
	ON_WM_NCCALCSIZE()
	ON_WM_NCHITTEST()
	ON_WM_NCLBUTTONDOWN()
	ON_WM_MOUSEMOVE()
	ON_WM_LBUTTONUP()
	ON_WM_SYSCOMMAND()
	ON_WM_GETMINMAXINFO()
	ON_WM_NCCREATE()
	ON_MESSAGE(WM_GETTEXT, OnGetText)
	ON_MESSAGE(WM_GETTEXTLENGTH, OnGetTextLength)
	ON_MESSAGE(WM_SETTEXT, OnSetText)
	ON_MESSAGE(WM_FLOATSTATUS, OnFloatStatus)
	ON_MESSAGE(WM_QUERYCENTERWND, OnQueryCenterWnd)
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

#define new DEBUG_NEW

/////////////////////////////////////////////////////////////////////////////
// CMiniFrameWnd constructors

CMiniFrameWnd::CMiniFrameWnd()
{
	m_bActive = FALSE;
	Initialize();
}

void AFX_CDECL CMiniFrameWnd::Initialize()
{
	// initialization not required if running latest Windows
	if (afxData.bSmCaption)
		return;

	AfxLockGlobals(CRIT_MINIFRAMEWND);
	if (_afx_hbmMiniSys == NULL)
	{
		HINSTANCE hInst = AfxFindResourceHandle(
			MAKEINTRESOURCE(AFX_IDB_MINIFRAME_MENU), RT_BITMAP);
		VERIFY(_afx_hbmMiniSys =
			LoadBitmap(hInst, MAKEINTRESOURCE(AFX_IDB_MINIFRAME_MENU)));
		BITMAP bmStruct;
		if (::GetObject(_afx_hbmMiniSys, sizeof(BITMAP), &bmStruct))
		{
			_afx_sizeMiniSys.cx = bmStruct.bmWidth;
			_afx_sizeMiniSys.cy = bmStruct.bmHeight;
		}
	}
	if (_afx_hfontMiniSys == NULL)
	{
		LOGFONT logFont; memset(&logFont, 0, sizeof(LOGFONT));
		logFont.lfHeight = -(_afx_sizeMiniSys.cy-1);
		logFont.lfCharSet = DEFAULT_CHARSET;
		logFont.lfWeight = FW_NORMAL;
		if (GetSystemMetrics(SM_DBCSENABLED))
			lstrcpy(logFont.lfFaceName, _T("Terminal"));
		else
			lstrcpy(logFont.lfFaceName, _T("Small Fonts"));
		if (!AfxCustomLogFont(AFX_IDS_MINI_FONT, &logFont))
			logFont.lfPitchAndFamily = DEFAULT_PITCH | FF_SWISS;
		_afx_hfontMiniSys = ::CreateFontIndirect(&logFont);
	}

	if (_afx_hfontMiniSys != NULL)
	{
		CClientDC dc(NULL);
		TEXTMETRIC tm;
		HFONT hFontOld = (HFONT)dc.SelectObject(_afx_hfontMiniSys);
		BOOL bResult = dc.GetTextMetrics(&tm);
		dc.SelectObject(hFontOld);

		if (!bResult || tm.tmHeight - tm.tmInternalLeading > _afx_sizeMiniSys.cy)
			AfxDeleteObject((HGDIOBJ*)&_afx_hfontMiniSys);
	}
	AfxUnlockGlobals(CRIT_MINIFRAMEWND);
}

CMiniFrameWnd::~CMiniFrameWnd()
{
	DestroyWindow();
}

BOOL CMiniFrameWnd::Create(LPCTSTR lpClassName, LPCTSTR lpszWindowName,
	DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID)
{
	return CMiniFrameWnd::CreateEx(0, lpClassName, lpszWindowName, dwStyle,
		rect, pParentWnd, nID);
}

BOOL CMiniFrameWnd::CreateEx(DWORD dwExStyle, LPCTSTR lpClassName,
	LPCTSTR lpszWindowName, DWORD dwStyle, const RECT& rect,
	CWnd* pParentWnd, UINT nID)
{
	m_strCaption = lpszWindowName;
	return CWnd::CreateEx(dwExStyle, lpClassName ? lpClassName :
		AfxRegisterWndClass(CS_DBLCLKS, ::LoadCursor(NULL, IDC_ARROW)),
		lpszWindowName, dwStyle, rect.left, rect.top, rect.right - rect.left,
		rect.bottom - rect.top, pParentWnd->GetSafeHwnd(), (HMENU)nID);
}

/////////////////////////////////////////////////////////////////////////////
// CMiniFrameWnd message handlers

BOOL CMiniFrameWnd::OnNcCreate(LPCREATESTRUCT lpcs)
{
	if (!CFrameWnd::OnNcCreate(lpcs))
		return FALSE;

	if (GetStyle() & MFS_SYNCACTIVE)
	{
		// syncronize activation state with top level parent
		CWnd* pParentWnd = GetTopLevelParent();
		ASSERT(pParentWnd != NULL);
		CWnd* pActiveWnd = GetForegroundWindow();
		BOOL bActive = (pParentWnd == pActiveWnd) ||
			(pParentWnd->GetLastActivePopup() == pActiveWnd &&
			 pActiveWnd->SendMessage(WM_FLOATSTATUS, FS_SYNCACTIVE) != 0);

		// the WM_FLOATSTATUS does the actual work
		SendMessage(WM_FLOATSTATUS, bActive ? FS_ACTIVATE : FS_DEACTIVATE);
	}

	return TRUE;
}

BOOL CMiniFrameWnd::PreCreateWindow(CREATESTRUCT& cs)
{
	if (afxData.bSmCaption)
	{
		// WS_4THICKFRAME and MFS_THICKFRAME imply WS_THICKFRAME
		if (cs.style & (MFS_4THICKFRAME | MFS_THICKFRAME))
			cs.style |= WS_THICKFRAME;

		// WS_CAPTION implies WS_EX_TOOLWINDOW
		if (cs.style & WS_CAPTION)
			cs.dwExStyle |= WS_EX_TOOLWINDOW;
	}

	VERIFY(CFrameWnd::PreCreateWindow(cs));
	cs.dwExStyle &= ~(WS_EX_CLIENTEDGE);

	return TRUE;
}

void CMiniFrameWnd::OnGetMinMaxInfo(MINMAXINFO* pMMI)
{
	// allow Windows to fill in the defaults
	CFrameWnd::OnGetMinMaxInfo(pMMI);

	// don't allow sizing smaller than the non-client area
	CRect rectWindow, rectClient;
	GetWindowRect(rectWindow);
	GetClientRect(rectClient);
	pMMI->ptMinTrackSize.x = rectWindow.Width() - rectClient.right;
	pMMI->ptMinTrackSize.y = rectWindow.Height() - rectClient.bottom;
}

BOOL CMiniFrameWnd::OnNcActivate(BOOL bActive)
{
	if ((GetStyle() & MFS_SYNCACTIVE) == 0)
	{
		if (afxData.bSmCaption)
			return Default();

		if (m_bActive != bActive)
		{
			m_bActive = bActive;
			SendMessage(WM_NCPAINT);
		}
	}
	else if(m_nFlags & WF_KEEPMINIACTIVE)
	{
		return FALSE;
	}
	return TRUE;
}

void CMiniFrameWnd::OnNcCalcSize(BOOL, NCCALCSIZE_PARAMS *lpParams)
{
	if (afxData.bSmCaption)
	{
		Default();
		return;
	}

	// Modify the first rectangle in rgrc.
	LONG dwStyle = GetStyle();
	if (dwStyle & (MFS_4THICKFRAME | MFS_THICKFRAME | WS_THICKFRAME))
	{
		::InflateRect(lpParams->rgrc,
			-GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME));
	}
	else
	{
		::InflateRect(lpParams->rgrc,
			-GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
	}
	if (dwStyle & WS_CAPTION)
		lpParams->rgrc[0].top += _afx_sizeMiniSys.cy;
}

UINT CMiniFrameWnd::OnNcHitTest(CPoint point)
{
	DWORD dwStyle = GetStyle();
	CRect rectWindow;
	GetWindowRect(&rectWindow);

	CSize sizeFrame(GetSystemMetrics(SM_CXFRAME),
		GetSystemMetrics(SM_CYFRAME));

	if (afxData.bSmCaption)
	{
		UINT nHit = CFrameWnd::OnNcHitTest(point);

		// MFS_BLOCKSYSMENU translates system menu hit to caption hit
		if (afxData.bWin4 && (dwStyle & MFS_BLOCKSYSMENU))
		{
			if (nHit == HTSYSMENU)
				nHit = HTCAPTION;
			if (GetKeyState(VK_RBUTTON) < 0)
				return HTNOWHERE;
		}

		if ((nHit < HTSIZEFIRST || nHit > HTSIZELAST) && nHit != HTGROWBOX)
			return nHit;

		// MFS_MOVEFRAME translates all size requests to move requests
		if (dwStyle & MFS_MOVEFRAME)
			return HTCAPTION;

		// MFS_4THICKFRAME does not allow diagonal sizing
		rectWindow.InflateRect(-sizeFrame.cx, -sizeFrame.cy);
		if (dwStyle & MFS_4THICKFRAME)
		{
			switch (nHit)
			{
			case HTTOPLEFT:
				return point.y < rectWindow.top ? HTTOP : HTLEFT;
			case HTTOPRIGHT:
				return point.y < rectWindow.top ? HTTOP : HTRIGHT;
			case HTBOTTOMLEFT:
				return point.y > rectWindow.bottom ? HTBOTTOM : HTLEFT;
			case HTGROWBOX:
			case HTBOTTOMRIGHT:
				return point.y > rectWindow.bottom ? HTBOTTOM : HTRIGHT;
			}
		}

		return nHit;    // no special translation
	}

	if (!rectWindow.PtInRect(point))
		return (UINT)HTNOWHERE;

	CSize sizeBorder(GetSystemMetrics(SM_CXBORDER),
		GetSystemMetrics(SM_CYBORDER));

	NCCALCSIZE_PARAMS Params;
	Params.rgrc[0].top = rectWindow.top;
	Params.rgrc[0].left = rectWindow.left;
	Params.rgrc[0].bottom = rectWindow.bottom;
	Params.rgrc[0].right = rectWindow.right;
	OnNcCalcSize(FALSE, &Params);

	CRect rcClient(Params.rgrc);
	if (rcClient.PtInRect(point))
		return HTCLIENT;

	if (dwStyle & (MFS_4THICKFRAME | MFS_THICKFRAME | WS_THICKFRAME))
	{
		UINT ht = HTNOWHERE;
		CSize sizeOffset(sizeFrame.cx + _afx_sizeMiniSys.cx - sizeBorder.cx * 3,
			sizeFrame.cy + _afx_sizeMiniSys.cy - sizeBorder.cy * 2);

		if (point.y < rectWindow.top + sizeFrame.cy)
		{
			if (dwStyle & MFS_4THICKFRAME)
				ht = HTTOP;
			else if (point.x <= rectWindow.left + sizeOffset.cx)
				ht = HTTOPLEFT;
			else if (point.x >= rectWindow.right - sizeOffset.cx)
				ht = HTTOPRIGHT;
			else
				ht = HTTOP;
		}
		else if (point.y >= rectWindow.bottom - sizeFrame.cy)
		{
			if (dwStyle & MFS_4THICKFRAME)
				ht = HTBOTTOM;
			else if (point.x <= rectWindow.left + sizeOffset.cx)
				ht = HTBOTTOMLEFT;
			else if (point.x >= rectWindow.right - sizeOffset.cx)
				ht = HTBOTTOMRIGHT;
			else
				ht = HTBOTTOM;
		}
		else if (point.x < rectWindow.left + sizeFrame.cx)
		{
			if (dwStyle & MFS_4THICKFRAME)
				ht = HTLEFT;
			else if (point.y <= rectWindow.top + sizeOffset.cy)
				ht = HTTOPLEFT;
			else if (point.y >= rectWindow.bottom - sizeOffset.cy)
				ht = HTBOTTOMLEFT;
			else
				ht = HTLEFT;
		}
		else if (point.x >= rectWindow.right - sizeFrame.cx)
		{
			if (dwStyle & MFS_4THICKFRAME)
				ht = HTRIGHT;
			else if (point.y <= rectWindow.top + sizeOffset.cy)
				ht = HTTOPRIGHT;
			else if (point.y >= rectWindow.bottom - sizeOffset.cy)
				ht = HTBOTTOMRIGHT;
			else
				ht = HTRIGHT;
		}

		if (ht != HTNOWHERE)
			return (dwStyle & MFS_MOVEFRAME) ? HTCAPTION : ht;

		rectWindow.InflateRect(-sizeFrame.cx, -sizeFrame.cy);
	}

	rectWindow.bottom = rectWindow.top + _afx_sizeMiniSys.cy + sizeBorder.cy;
	if (rectWindow.PtInRect(point))
	{
		if (point.x < rectWindow.left + (_afx_sizeMiniSys.cx - 2) &&
			(dwStyle & WS_SYSMENU))
			return HTSYSMENU;

		return HTCAPTION;
	}

	return (UINT)HTERROR;
}


void CMiniFrameWnd::OnNcLButtonDown(UINT nHitTest, CPoint pt)
{
	if (afxData.bSmCaption || nHitTest != HTSYSMENU)
	{
		CFrameWnd::OnNcLButtonDown(nHitTest, pt);
		return;
	}

	m_bSysTracking = TRUE;
	m_bInSys = TRUE;
	SetCapture();
	InvertSysMenu();
}

void CMiniFrameWnd::OnMouseMove(UINT /*nFlags*/, CPoint pt)
{
	if (!m_bSysTracking)