able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/activec/conui/mdiuisim.cpp

477 lines
14 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*--------------------------------------------------------------------------*
*
* Microsoft Windows
* Copyright (C) Microsoft Corporation, 1992 - 1999
*
* File: mdiuisim.cpp
*
* Contents: Implementation file for CMDIMenuDecoration
*
* History: 17-Nov-97 jeffro Created
*
*--------------------------------------------------------------------------*/
#include "stdafx.h"
#include "amc.h"
#include "mdiuisim.h"
struct MDIDataMap {
DWORD dwStyle;
int nCommand;
};
const int cMapEntries = 4;
const MDIDataMap anMDIDataMap[cMapEntries] = {
{ MMDS_CLOSE, SC_CLOSE }, // DFCS_CAPTIONCLOSE
{ MMDS_MINIMIZE, SC_MINIMIZE }, // DFCS_CAPTIONMIN
{ MMDS_MAXIMIZE, SC_MAXIMIZE }, // DFCS_CAPTIONMAX
{ MMDS_RESTORE, SC_RESTORE }, // DFCS_CAPTIONRESTORE
};
// this array is in the order the decorations are drawn, left-to-right
const int anDrawOrder[cMapEntries] = {
DFCS_CAPTIONMIN,
DFCS_CAPTIONRESTORE,
DFCS_CAPTIONMAX,
DFCS_CAPTIONCLOSE
};
/*--------------------------------------------------------------------------*
* DrawCaptionControl
*
*
*--------------------------------------------------------------------------*/
static void DrawCaptionControl (
CDC * pdc,
LPCRECT pRect,
int nIndex,
bool fPushed)
{
const int cxInflate = -1;
const int cyInflate = -2;
CRect rectDraw = pRect;
rectDraw.InflateRect (cxInflate, cyInflate);
rectDraw.OffsetRect ((nIndex == DFCS_CAPTIONMIN) ? 1 : -1, 0);
if (fPushed)
nIndex |= DFCS_PUSHED;
pdc->DrawFrameControl (rectDraw, DFC_CAPTION, nIndex);
}
/*--------------------------------------------------------------------------*
* CMDIMenuDecoration::CMouseTrackContext::CMouseTrackContext
*
*
*--------------------------------------------------------------------------*/
CMDIMenuDecoration::CMouseTrackContext::CMouseTrackContext (
CMDIMenuDecoration* pMenuDec,
CPoint point)
: m_fHotButtonPressed (false),
m_pMenuDec (pMenuDec)
{
ASSERT_VALID (m_pMenuDec);
// set up hit testing rectangles for each button
int cxButton = GetSystemMetrics (SM_CXMENUSIZE);
int cyButton = GetSystemMetrics (SM_CYMENUSIZE);
DWORD dwStyle = m_pMenuDec->GetStyle ();
CRect rectT (0, 0, cxButton, cyButton);
for (int i = 0; i < cMapEntries; i++)
{
int nDataIndex = anDrawOrder[i];
if (dwStyle & anMDIDataMap[nDataIndex].dwStyle)
{
m_rectButton[nDataIndex] = rectT;
rectT.OffsetRect (cxButton, 0);
}
else
m_rectButton[nDataIndex].SetRectEmpty();
}
m_nHotButton = HitTest (point);
ASSERT (m_nHotButton != -1);
// if the user clicked on a disbled button, we don't want to track -- punt!
if (!m_pMenuDec->IsSysCommandEnabled (anMDIDataMap[m_nHotButton].nCommand))
AfxThrowUserException ();
// press the hot button initially
ToggleHotButton ();
// capture the mouse
m_pMenuDec->SetCapture ();
}
/*--------------------------------------------------------------------------*
* CMDIMenuDecoration::CMouseTrackContext::~CMouseTrackContext
*
*
*--------------------------------------------------------------------------*/
CMDIMenuDecoration::CMouseTrackContext::~CMouseTrackContext ()
{
ReleaseCapture();
if (m_fHotButtonPressed)
ToggleHotButton ();
}
/*--------------------------------------------------------------------------*
* CMDIMenuDecoration::CMouseTrackContext::Track
*
*
*--------------------------------------------------------------------------*/
void CMDIMenuDecoration::CMouseTrackContext::Track (CPoint point)
{
int nButton = HitTest (point);
/*-----------------------------------------------------*/
/* if we're over the hot button and it's not pressed, */
/* or we're not over the hot button and it is pressed, */
/* toggle the state of the hot button */
/*-----------------------------------------------------*/
if (((nButton != m_nHotButton) && m_fHotButtonPressed) ||
((nButton == m_nHotButton) && !m_fHotButtonPressed))
{
ToggleHotButton ();
}
}
/*--------------------------------------------------------------------------*
* CMDIMenuDecoration::CMouseTrackContext::ToggleHotButton
*
*
*--------------------------------------------------------------------------*/
void CMDIMenuDecoration::CMouseTrackContext::ToggleHotButton ()
{
DrawCaptionControl (&CClientDC (m_pMenuDec),
m_rectButton[m_nHotButton], m_nHotButton,
m_fHotButtonPressed = !m_fHotButtonPressed);
}
/*--------------------------------------------------------------------------*
* CMDIMenuDecoration::CMouseTrackContext::HitTest
*
*
*--------------------------------------------------------------------------*/
int CMDIMenuDecoration::CMouseTrackContext::HitTest (CPoint point) const
{
for (int i = 0; i < countof (m_rectButton); i++)
{
if (m_rectButton[i].PtInRect (point))
return (i);
}
return (-1);
}
/////////////////////////////////////////////////////////////////////////////
// CMDIMenuDecoration
CMDIMenuDecoration::CMDIMenuDecoration()
{
// anMDIDataMap is indexed by these values
ASSERT (DFCS_CAPTIONCLOSE == 0);
ASSERT (DFCS_CAPTIONMIN == 1);
ASSERT (DFCS_CAPTIONMAX == 2);
ASSERT (DFCS_CAPTIONRESTORE == 3);
}
CMDIMenuDecoration::~CMDIMenuDecoration()
{
}
BEGIN_MESSAGE_MAP(CMDIMenuDecoration, CWnd)
//{{AFX_MSG_MAP(CMDIMenuDecoration)
ON_WM_PAINT()
ON_WM_WINDOWPOSCHANGING()
ON_WM_LBUTTONDOWN()
ON_WM_LBUTTONUP()
ON_WM_MOUSEMOVE()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CMDIMenuDecoration message handlers
/*--------------------------------------------------------------------------*
* CMDIMenuDecoration::OnPaint
*
* WM_PAINT handler for CMDIMenuDecoration.
*--------------------------------------------------------------------------*/
void CMDIMenuDecoration::OnPaint()
{
CPaintDC dcPaint (this);
//#define DRAW_OFF_SCREEN
#ifndef DRAW_OFF_SCREEN
CDC& dc = dcPaint;
#else
CRect rect;
GetClientRect (rect);
const int cx = rect.Width();
const int cy = rect.Height();
CDC dcMem;
CDC& dc = dcMem;
dcMem.CreateCompatibleDC (&dcPaint);
CBitmap bmMem;
bmMem.CreateCompatibleBitmap (&dcPaint, cx, cy);
CBitmap* pbmOld = dcMem.SelectObject (&bmMem);
#endif
if (dcPaint.m_ps.fErase)
dc.FillRect (&dcPaint.m_ps.rcPaint, AMCGetSysColorBrush (COLOR_BTNFACE));
int cxButton = GetSystemMetrics (SM_CXMENUSIZE);
int cyButton = GetSystemMetrics (SM_CYMENUSIZE);
DWORD dwStyle = GetStyle ();
CRect rectDraw (0, 0, cxButton, cyButton);
// make sure we don't have both the maximize and restore styles
ASSERT ((dwStyle & (MMDS_MAXIMIZE | MMDS_RESTORE)) !=
(MMDS_MAXIMIZE | MMDS_RESTORE));
// we shouldn't get here if we're tracking
ASSERT (m_spTrackCtxt.get() == NULL);
CMenu* pSysMenu = GetActiveSystemMenu ();
for (int i = 0; i < cMapEntries; i++)
{
int nDataIndex = anDrawOrder[i];
if (dwStyle & anMDIDataMap[nDataIndex].dwStyle)
{
int nState = nDataIndex;
if (!IsSysCommandEnabled (anMDIDataMap[nDataIndex].nCommand, pSysMenu))
nState |= DFCS_INACTIVE;
DrawCaptionControl (&dc, rectDraw, nState, false);
rectDraw.OffsetRect (cxButton, 0);
}
}
#ifdef DRAW_OFF_SCREEN
dcPaint.BitBlt (0, 0, cx, cy, &dcMem, 0, 0, SRCCOPY);
dcMem.SelectObject (pbmOld);
#endif
}
/*--------------------------------------------------------------------------*
* CMDIMenuDecoration::OnWindowPosChanging
*
* WM_WINDOWPOSCHANGING handler for CMDIMenuDecoration.
*--------------------------------------------------------------------------*/
void CMDIMenuDecoration::OnWindowPosChanging(WINDOWPOS FAR* lpwndpos)
{
DWORD dwStyle = GetStyle ();
if (dwStyle & MMDS_AUTOSIZE)
{
int cxButton = GetSystemMetrics (SM_CXMENUSIZE);
int cyButton = GetSystemMetrics (SM_CYMENUSIZE);
lpwndpos->cx = 0;
lpwndpos->cy = cyButton;
dwStyle &= MMDS_BTNSTYLES;
while (dwStyle != 0)
{
if (dwStyle & 1)
lpwndpos->cx += cxButton;
dwStyle >>= 1;
}
}
else
CWnd::OnWindowPosChanging(lpwndpos);
}
/*--------------------------------------------------------------------------*
* CMDIMenuDecoration::OnLButtonDown
*
* WM_LBUTTONDOWN handler for CMDIMenuDecoration.
*--------------------------------------------------------------------------*/
// this routine needs placement new syntax --
// temporarily remove MFC's incompatible placement new definition
#ifdef _DEBUG
#undef new
#endif
void CMDIMenuDecoration::OnLButtonDown(UINT nFlags, CPoint point)
{
typedef std::auto_ptr<char> CharPtr;
CWnd::OnLButtonDown(nFlags, point);
try
{
/*------------------------------------------------------------------*/
/* This looks ugly. We'd like to write: */
/* */
/* m_spTrackCtxt = CMouseTrackContextPtr ( */
/* new CMouseTrackContext (this, point)); */
/* */
/* but CMouseTrackContext's ctor might throw an exception. If it */
/* does, the smart pointer won't yet have been initialized so the */
/* CMouseTrackContext won't be deleted. */
/* */
/* To get around it, we'll create a smart pointer pointing to a */
/* dynamically-allocated buffer of the right size. That buffer */
/* will not leak with an exception. We can then use a placement */
/* new to initialize a CMouseTrackContext in the hunk of memory. */
/* It's now not a problem if the CMouseTrackContext throws, because */
/* the buffer is still protected it's own smart pointer. Once */
/* the placement new completes successfully, we can transfer */
/* ownership of the object to a CMouseTrackContext smart pointer */
/* and we're golden. */
/*------------------------------------------------------------------*/
// allocate a hunk of memory and construct a CMouseTrackContext in it
CharPtr spchBuffer = CharPtr (new char[sizeof (CMouseTrackContext)]);
CMouseTrackContext* pNewCtxt = new (spchBuffer.get()) CMouseTrackContext (this, point);
// if we get here, the CMouseTrackContext initialized properly,
// so we can transfer ownership to the CMouseTrackContext smart pointer
spchBuffer.release ();
m_spTrackCtxt = CMouseTrackContextPtr (pNewCtxt);
}
catch (CUserException* pe)
{
// do nothing, just eat the exception
pe->Delete();
}
}
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
/*--------------------------------------------------------------------------*
* CMDIMenuDecoration::OnLButtonUp
*
* WM_LBUTTONUP handler for CMDIMenuDecoration.
*--------------------------------------------------------------------------*/
void CMDIMenuDecoration::OnLButtonUp(UINT nFlags, CPoint point)
{
if (m_spTrackCtxt.get() != NULL)
{
const int nHotButton = m_spTrackCtxt->m_nHotButton;
const int nHitButton = m_spTrackCtxt->HitTest (point);
// delete the track context
m_spTrackCtxt = CMouseTrackContextPtr (NULL);
if (nHitButton == nHotButton)
{
int cmd = anMDIDataMap[nHotButton].nCommand;
// make sure the command looks like a valid sys command
ASSERT (cmd >= 0xF000);
ClientToScreen (&point);
GetOwner()->SendMessage (WM_SYSCOMMAND, cmd,
MAKELPARAM (point.x, point.y));
}
}
}
/*--------------------------------------------------------------------------*
* CMDIMenuDecoration::OnMouseMove
*
* WM_MOUSEMOVE handler for CMDIMenuDecoration.
*--------------------------------------------------------------------------*/
void CMDIMenuDecoration::OnMouseMove(UINT nFlags, CPoint point)
{
if (m_spTrackCtxt.get() != NULL)
m_spTrackCtxt->Track (point);
}
/*--------------------------------------------------------------------------*
* CMDIMenuDecoration::GetActiveSystemMenu
*
*
*--------------------------------------------------------------------------*/
CMenu* CMDIMenuDecoration::GetActiveSystemMenu ()
{
CFrameWnd* pwndFrame = GetParentFrame()->GetActiveFrame();
ASSERT (pwndFrame != NULL);
CMenu* pSysMenu = pwndFrame->GetSystemMenu (FALSE);
ASSERT (pSysMenu != NULL);
return (pSysMenu);
}
/*--------------------------------------------------------------------------*
* CMDIMenuDecoration::IsSysCommandEnabled
*
*
*--------------------------------------------------------------------------*/
bool CMDIMenuDecoration::IsSysCommandEnabled (int nSysCommand, CMenu* pSysMenu)
{
if (pSysMenu == NULL)
pSysMenu = GetActiveSystemMenu ();
int nState = pSysMenu->GetMenuState (nSysCommand, MF_BYCOMMAND);
ASSERT (nState != 0xFFFFFFFF);
return ((nState & MF_GRAYED) == 0);
}
Reference in a new issue Copy permalink