able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/themes/test/mditest/mainfrm.cpp

941 lines
24 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
// MainFrm.cpp : implementation of the CMainFrame class
//
#include "stdafx.h"
#include "mditest.h"
#include "rgn.h"
#include "MainFrm.h"
#include "NCMetricsDlg.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#define TESTFLAG(bits,flag) (((bits) & (flag))!=0)
void TestRgnData();
/////////////////////////////////////////////////////////////////////////////
// CMainFrame
IMPLEMENT_DYNAMIC(CMainFrame, CMDIFrameWnd)
BEGIN_MESSAGE_MAP(CMainFrame, CMDIFrameWnd)
//{{AFX_MSG_MAP(CMainFrame)
ON_WM_CREATE()
ON_WM_GETMINMAXINFO()
ON_COMMAND(ID_FULLSCRNMAXIMIZED, OnFullScrnMaximized)
ON_UPDATE_COMMAND_UI(ID_FULLSCRNMAXIMIZED, OnUpdateFullScrnMaximized)
ON_COMMAND(ID_AWRWINDOW, OnAwrWindow)
ON_COMMAND(ID_AWRWINDOWMENU, OnAwrWindowMenu)
ON_COMMAND(ID_NONCLIENTMETRICS, OnNonClientMetrics)
ON_COMMAND(ID_THINFRAME, OnThinFrame)
ON_COMMAND(ID_DUMPMETRICS, OnDumpMetrics)
ON_COMMAND(ID_MINIMIZEBOX, OnMinimizeBox)
ON_UPDATE_COMMAND_UI(ID_MINIMIZEBOX, OnUpdateMinimizeBox)
ON_COMMAND(ID_MAXIMIZEBOX, OnMaximizeBox)
ON_UPDATE_COMMAND_UI(ID_MAXIMIZEBOX, OnUpdateMaximizeBox)
ON_COMMAND(ID_SYSMENU, OnSysMenu)
ON_UPDATE_COMMAND_UI(ID_SYSMENU, OnUpdateSysMenu)
ON_UPDATE_COMMAND_UI(ID_CLOSEBTN, OnUpdateCloseBtn)
ON_COMMAND(ID_CLOSEBTN, OnCloseBtn)
ON_COMMAND(ID_TOOLFRAME, OnToolframe)
ON_COMMAND(ID_ALTICON, OnAltIcon)
ON_UPDATE_COMMAND_UI(ID_ALTICON, OnUpdateAltIcon)
ON_COMMAND(ID_ALTTEXT, OnAltTitle)
ON_UPDATE_COMMAND_UI(ID_ALTTEXT, OnUpdateAltTitle)
ON_COMMAND(IDC_DCAPPCOMPAT, OnDcAppcompat)
ON_UPDATE_COMMAND_UI(IDC_DCAPPCOMPAT, OnUpdateDcAppcompat)
ON_COMMAND(IDC_DFCAPPCOMPAT, OnDfcAppcompat)
ON_UPDATE_COMMAND_UI(IDC_DFCAPPCOMPAT, OnUpdateDfcAppcompat)
ON_WM_NCPAINT()
ON_COMMAND(ID_MINMAXSTRESS, OnMinMaxStress)
ON_UPDATE_COMMAND_UI(ID_MINMAXSTRESS, OnUpdateMinMaxStress)
ON_WM_WINDOWPOSCHANGING()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
static UINT indicators[] =
{
ID_SEPARATOR, // status line indicator
ID_INDICATOR_CAPS,
ID_INDICATOR_NUM,
ID_INDICATOR_SCRL,
};
/////////////////////////////////////////////////////////////////////////////
// CMainFrame construction/destruction
CMainFrame::CMainFrame()
: m_fFullScrnMax(TRUE),
m_fAltIcon(FALSE),
m_fAltTitle(FALSE),
m_fDfcAppCompat(FALSE),
m_fDcAppCompat(FALSE),
m_fMinMaxStress(FALSE),
m_pwiNormal0(NULL),
m_hIcon(NULL)
{
}
CMainFrame::~CMainFrame()
{
if( m_hAltIcon )
DeleteObject( m_hAltIcon );
if( m_hIcon )
DeleteObject( m_hIcon );
}
LRESULT CALLBACK MsgWndProc( HWND hwnd, UINT uMsg, WPARAM lParam, LPARAM wParam )
{
return DefWindowProc( hwnd, uMsg, lParam, wParam );
}
int GetPrime( ULONG number )
{
int cPrimeCount = 0;
if( number > 1 )
{
for( UINT i = 2; i < number; i++ )
{
if( 0 == number % i )
cPrimeCount++;
}
}
return cPrimeCount;
}
int CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CMDIFrameWnd::OnCreate(lpCreateStruct) == -1)
return -1;
if (!m_wndToolBar.CreateEx(this) ||
!m_wndToolBar.LoadToolBar(IDR_MAINFRAME))
{
TRACE0("Failed to create toolbar\n");
return -1; // fail to create
}
if (!m_wndDlgBar.Create(this, IDR_MAINFRAME,
CBRS_ALIGN_TOP, AFX_IDW_DIALOGBAR))
{
TRACE0("Failed to create dialogbar\n");
return -1; // fail to create
}
if (!m_wndReBar.Create(this) ||
!m_wndReBar.AddBar(&m_wndToolBar) ||
!m_wndReBar.AddBar(&m_wndDlgBar))
{
TRACE0("Failed to create rebar\n");
return -1; // fail to create
}
if (!m_wndStatusBar.Create(this) ||
!m_wndStatusBar.SetIndicators(indicators,
sizeof(indicators)/sizeof(UINT)))
{
TRACE0("Failed to create status bar\n");
return -1; // fail to create
}
m_wndToolBar.SetBarStyle(m_wndToolBar.GetBarStyle() |
CBRS_TOOLTIPS | CBRS_FLYBY);
TestRgnData();
return 0;
}
void _GetRectSize( LPCRECT prc, PPOINT pptSize )
{
pptSize->x = RECTWIDTH(prc);
pptSize->y = RECTHEIGHT(prc);
}
BOOL _EqualPoint( PPOINT pt1, PPOINT pt2 )
{
return (pt1->x == pt2->x) && (pt1->y == pt2->y);
}
LRESULT CALLBACK AWRWndProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
switch(uMsg)
{
case WM_COMMAND:
{
if( ID_CLOSE == LOWORD(wParam) )
DestroyWindow(hwnd);
break;
}
case WM_SIZE:
{
RECT rcCli, rcWnd, rcAwr;
POINT sizeWnd, sizeCli, sizeAwr;
GetWindowRect(hwnd, &rcWnd);
_GetRectSize(&rcWnd, &sizeWnd);
GetClientRect(hwnd, &rcCli);
_GetRectSize(&rcCli, &sizeCli);
int cyMenu = GetSystemMetrics(SM_CYMENU);
int cyMenuSize = GetSystemMetrics(SM_CYMENUSIZE);
WINDOWINFO wi = {0};
wi.cbSize = sizeof(wi);
GetWindowInfo(hwnd, &wi);
rcAwr = rcCli;
AdjustWindowRectEx(&rcAwr, wi.dwStyle, GetMenu(hwnd) != NULL, wi.dwExStyle);
_GetRectSize(&rcAwr, &sizeAwr);
TRACE( TEXT("AWRex: cli(%d,%d), wnd(%d,%d), awr(%d,%d), %s\n\n"),
sizeCli, sizeWnd, sizeAwr,
_EqualPoint(&sizeWnd, &sizeAwr) ? TEXT("Ok.") : TEXT("ERROR!") );
break;
}
}
return DefWindowProc( hwnd, uMsg, wParam, lParam );
}
//---------------------------------------------------------------------------
HRESULT _PrepareRegionDataForScaling(RGNDATA *pRgnData, LPCRECT prcImage, MARGINS *pMargins)
{
//---- compute margin values ----
int sw = prcImage->left;
int lw = prcImage->left + pMargins->cxLeftWidth;
int rw = prcImage->right - pMargins->cxRightWidth;
int sh = prcImage->top;
int th = prcImage->top + pMargins->cyTopHeight;
int bh = prcImage->bottom - pMargins->cyBottomHeight;
//---- step thru region data & customize it ----
//---- classify each POINT according to a gridnum and ----
//---- make it 0-relative to its grid location ----
POINT *pt = (POINT *)pRgnData->Buffer;
BYTE *pByte = (BYTE *)pRgnData->Buffer + pRgnData->rdh.nRgnSize;
int iCount = 2 * pRgnData->rdh.nCount;
for (int i=0; i < iCount; i++, pt++, pByte++)
{
if (pt->x < lw)
{
pt->x -= sw;
if (pt->y < th) // left top
{
*pByte = GN_LEFTTOP;
pt->y -= sh;
}
else if (pt->y < bh) // left middle
{
*pByte = GN_LEFTMIDDLE;
pt->y -= th;
}
else // left bottom
{
*pByte = GN_LEFTBOTTOM;
pt->y -= bh;
}
}
else if (pt->x < rw)
{
pt->x -= lw;
if (pt->y < th) // middle top
{
*pByte = GN_MIDDLETOP;
pt->y -= sh;
}
else if (pt->y < bh) // middle middle
{
*pByte = GN_MIDDLEMIDDLE;
pt->y -= th;
}
else // middle bottom
{
*pByte = GN_MIDDLEBOTTOM;
pt->y -= bh;
}
}
else
{
pt->x -= rw;
if (pt->y < th) // right top
{
*pByte = GN_RIGHTTOP;
pt->y -= sh;
}
else if (pt->y < bh) // right middle
{
*pByte = GN_RIGHTMIDDLE;
pt->y -= th;
}
else // right bottom
{
*pByte = GN_RIGHTBOTTOM;
pt->y -= bh;
}
}
}
return S_OK;
}
//---------------------------------------------------------------------------
void TestRgnData()
{
HBITMAP hbm = (HBITMAP)LoadImage(
NULL, TEXT("f:\\testapplets\\mditest\\rgndatatest.bmp"),
IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE );
if( hbm )
{
HRGN hrgn;
BITMAP bm;
GetObject( hbm, sizeof(bm), &bm );
if( SUCCEEDED( CreateBitmapRgn( hbm, 0, 0, -1, -1, FALSE, 0, RGB(255,0,255), 0, &hrgn ) ) )
{
LONG cb = GetRegionData(hrgn, 0, NULL);
LONG cbRgnData = cb + sizeof(RGNDATAHEADER);
BYTE* pbData = NULL;
if( (pbData = new BYTE[cbRgnData]) != NULL )
{
RGNDATA* pRgnData = (RGNDATA*)pbData;
if( GetRegionData(hrgn, cbRgnData, pRgnData) )
{
MARGINS marSizing = {12,6,1,6};
RECT rcImage;
SetRect(&rcImage, 0, 0, bm.bmWidth, bm.bmHeight);
_PrepareRegionDataForScaling( pRgnData, &rcImage, &marSizing );
}
delete [] pbData;
}
}
}
}
void TestPidHash()
{
for( int rep = 0; rep < 500; rep++ )
{
ULONG cBestCollisions = -1;
int cBestBuckets = 0;
for( int cBuckets = 0xFD9; cBuckets <= 0xFF3; cBuckets++ )
{
ULONG hashtable[2][1000] = {0};
srand(GetTickCount());
ULONG cCollisions = 0;
for( int i=0; i < 1000; i++ )
{
ULONG pid = rand();
ULONG hash = (pid << 4);
hash %= cBuckets;
for( int j = 0; j < i; j++ )
{
if( hashtable[1][j] == hash )
{
ULONG pidOther = hashtable[0][j];
ULONG hashOther = hashtable[1][j];
cCollisions++;
}
}
hashtable[0][i] = pid;
hashtable[1][i] = hash;
}
if( cCollisions < cBestCollisions )
{
cBestCollisions = cCollisions;
cBestBuckets = cBuckets;
}
//TRACE("Collision count using bucket count %04X: %d\n", cBuckets, cCollisions );
}
TRACE(TEXT("%04X\t%d\t%d\n"), cBestBuckets, cBestCollisions, GetPrime(cBestBuckets) );
}
}
//---------------------------------------------------------------------------
HWND CreateAWRWindow( HWND hwndParent, DWORD dwStyle, DWORD dwExStyle, BOOL fMenu )
{
static WNDCLASS wc = {0};
if( !wc.lpfnWndProc )
{
wc.style = CS_HREDRAW|CS_VREDRAW;
wc.lpfnWndProc = AWRWndProc;
wc.hInstance = AfxGetInstanceHandle();
wc.hCursor = ::LoadCursor( NULL, IDC_ARROW );
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wc.lpszClassName = TEXT("AWRTestWnd");
if( !RegisterClass( &wc ) )
return NULL;
}
HMENU hMenu = NULL;
if( fMenu )
hMenu = LoadMenu( AfxGetInstanceHandle(), MAKEINTRESOURCE(IDR_AWRMENU) );
return CreateWindowEx( dwExStyle, wc.lpszClassName, TEXT("AdustWindowRect test"), dwStyle,
0, 0, 640, 480, hwndParent, hMenu, wc.hInstance, NULL );
}
//---------------------------------------------------------------------------
BOOL CMainFrame::PreCreateWindow(CREATESTRUCT& cs)
{
if( !CMDIFrameWnd::PreCreateWindow(cs) )
return FALSE;
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////
// CMainFrame diagnostics
#ifdef _DEBUG
void CMainFrame::AssertValid() const
{
CMDIFrameWnd::AssertValid();
}
void CMainFrame::Dump(CDumpContext& dc) const
{
CMDIFrameWnd::Dump(dc);
}
#endif //_DEBUG
/////////////////////////////////////////////////////////////////////////////
// CMainFrame message handlers
void CMainFrame::OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI)
{
CMDIFrameWnd::OnGetMinMaxInfo(lpMMI);
if( !m_fFullScrnMax )
{
//lpMMI->ptMaxPosition.x = lpMMI->ptMaxPosition.y = 0;
lpMMI->ptMaxTrackSize.x = GetSystemMetrics(SM_CXSCREEN)/2;
lpMMI->ptMaxTrackSize.y = GetSystemMetrics(SM_CYSCREEN)/2;
}
}
void CMainFrame::OnFullScrnMaximized()
{
m_fFullScrnMax = !m_fFullScrnMax;
}
void CMainFrame::OnUpdateFullScrnMaximized(CCmdUI* pCmdUI)
{
pCmdUI->SetCheck( m_fFullScrnMax );
}
void CMainFrame::OnAwrWindow()
{
HWND hwnd;
if( (hwnd = CreateAWRWindow(
*this, WS_OVERLAPPEDWINDOW & ~WS_SYSMENU, WS_EX_CLIENTEDGE|WS_EX_CONTEXTHELP, FALSE )) != NULL )
{
::ShowWindow(hwnd, SW_SHOW);
::UpdateWindow(hwnd);
}
}
void CMainFrame::OnAwrWindowMenu()
{
HWND hwnd;
if( (hwnd = CreateAWRWindow(
*this, WS_OVERLAPPEDWINDOW, WS_EX_CLIENTEDGE, TRUE )) != NULL )
{
::ShowWindow(hwnd, SW_SHOW);
::UpdateWindow(hwnd);
}
}
void CMainFrame::OnNonClientMetrics()
{
CNCMetricsDlg dlg;
dlg.DoModal();
}
LRESULT CALLBACK ToolFrameWndProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
return DefWindowProc( hwnd, uMsg, wParam, lParam );
}
LRESULT CALLBACK ThinFrameWndProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
return DefWindowProc( hwnd, uMsg, wParam, lParam );
}
void CMainFrame::OnToolframe()
{
static WNDCLASS wc = {0};
if( !wc.lpfnWndProc )
{
wc.style = CS_HREDRAW|CS_VREDRAW;
wc.lpfnWndProc = ToolFrameWndProc;
wc.hInstance = AfxGetInstanceHandle();
wc.hCursor = ::LoadCursor( NULL, IDC_ARROW );
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wc.lpszClassName = TEXT("ToolFrameTestWnd");
if( !RegisterClass( &wc ) )
return;
}
HWND hwnd = CreateWindowEx( WS_EX_TOOLWINDOW, wc.lpszClassName, TEXT("Tool Frame"),
WS_CAPTION|WS_SYSMENU|WS_THICKFRAME|WS_MINIMIZEBOX|WS_MAXIMIZEBOX,
CW_USEDEFAULT, 0, 280, 320, *this, NULL, wc.hInstance, NULL );
if( hwnd )
{
::UpdateWindow(hwnd);
::ShowWindow(hwnd, SW_SHOW);
}
}
void CMainFrame::OnThinFrame()
{
static WNDCLASS wc = {0};
if( !wc.lpfnWndProc )
{
wc.style = CS_HREDRAW|CS_VREDRAW;
wc.lpfnWndProc = ThinFrameWndProc;
wc.hInstance = AfxGetInstanceHandle();
wc.hCursor = ::LoadCursor( NULL, IDC_ARROW );
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wc.lpszClassName = TEXT("ThinFrameTestWnd");
if( !RegisterClass( &wc ) )
return;
}
HWND hwnd = CreateWindowEx( WS_EX_DLGMODALFRAME, wc.lpszClassName, TEXT("Thin Frame"), WS_CAPTION|WS_SYSMENU,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, *this, NULL, wc.hInstance, NULL );
if( hwnd )
{
::UpdateWindow(hwnd);
::ShowWindow(hwnd, SW_SHOW);
}
}
void CMainFrame::OnDumpMetrics()
{
NONCLIENTMETRICS ncm = {0};
ncm.cbSize = sizeof(ncm);
int iBorder;
SystemParametersInfo( SPI_GETNONCLIENTMETRICS, 0, &ncm, 0 );
SystemParametersInfo( SPI_GETBORDER, 0, &iBorder, 0 );
#define SPEW_NCM(i) TRACE(TEXT("NONCLIENTMETRICS::") TEXT(#i) TEXT(":\t%d\n"), ncm.##i );
#define SPEW_SYSMET(sm) TRACE(TEXT(#sm) TEXT(":\t%d\n"), GetSystemMetrics(sm) );
TRACE(TEXT("SPI_BORDER:\t%d\n"), iBorder);
SPEW_NCM(iBorderWidth);
SPEW_NCM(iScrollWidth);
SPEW_NCM(iScrollHeight);
SPEW_NCM(iCaptionWidth);
SPEW_NCM(iCaptionHeight);
SPEW_NCM(iSmCaptionWidth);
SPEW_NCM(iSmCaptionHeight);
SPEW_NCM(iMenuWidth);
SPEW_NCM(iMenuHeight);
SPEW_SYSMET( SM_CXVSCROLL )
SPEW_SYSMET( SM_CYHSCROLL )
SPEW_SYSMET( SM_CYCAPTION )
SPEW_SYSMET( SM_CXBORDER )
SPEW_SYSMET( SM_CYBORDER )
SPEW_SYSMET( SM_CYVTHUMB )
SPEW_SYSMET( SM_CXHTHUMB )
SPEW_SYSMET( SM_CXICON )
SPEW_SYSMET( SM_CYICON )
SPEW_SYSMET( SM_CYMENU )
SPEW_SYSMET( SM_CYVSCROLL )
SPEW_SYSMET( SM_CXHSCROLL )
SPEW_SYSMET( SM_SWAPBUTTON )
SPEW_SYSMET( SM_CXSIZE )
SPEW_SYSMET( SM_CYSIZE )
SPEW_SYSMET( SM_CXFIXEDFRAME )
SPEW_SYSMET( SM_CYFIXEDFRAME )
SPEW_SYSMET( SM_CXSIZEFRAME )
SPEW_SYSMET( SM_CYSIZEFRAME )
SPEW_SYSMET( SM_CXEDGE )
SPEW_SYSMET( SM_CYEDGE )
SPEW_SYSMET( SM_CXSMICON )
SPEW_SYSMET( SM_CYSMICON )
SPEW_SYSMET( SM_CYSMCAPTION )
SPEW_SYSMET( SM_CXSMSIZE )
SPEW_SYSMET( SM_CYSMSIZE )
SPEW_SYSMET( SM_CXMENUSIZE )
SPEW_SYSMET( SM_CYMENUSIZE )
SPEW_SYSMET( SM_CXMINIMIZED )
SPEW_SYSMET( SM_CYMINIMIZED )
SPEW_SYSMET( SM_CXMAXIMIZED )
SPEW_SYSMET( SM_CYMAXIMIZED )
SPEW_SYSMET( SM_CXDRAG )
SPEW_SYSMET( SM_CYDRAG )
}
void _ToggleStyle( CWnd* pwnd, DWORD dwStyle )
{
BOOL fStyle = pwnd->GetStyle() & dwStyle;
pwnd->ModifyStyle( fStyle ? dwStyle : 0,
fStyle ? 0 : dwStyle );
pwnd->SetWindowPos( NULL, 0, 0, 0, 0,
SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_DRAWFRAME );
}
void CMainFrame::OnMinimizeBox()
{
_ToggleStyle( this, WS_MINIMIZEBOX );
}
void CMainFrame::OnUpdateMinimizeBox(CCmdUI* pCmdUI)
{
pCmdUI->Enable( GetStyle() & WS_SYSMENU );
pCmdUI->SetCheck( GetStyle() & WS_MINIMIZEBOX );
}
void CMainFrame::OnMaximizeBox()
{
_ToggleStyle( this, WS_MAXIMIZEBOX );
}
void CMainFrame::OnUpdateMaximizeBox(CCmdUI* pCmdUI)
{
pCmdUI->Enable( GetStyle() & WS_SYSMENU );
pCmdUI->SetCheck( GetStyle() & WS_MAXIMIZEBOX );
}
void CMainFrame::OnSysMenu()
{
_ToggleStyle( this, WS_SYSMENU );
}
void CMainFrame::OnUpdateSysMenu(CCmdUI* pCmdUI)
{
pCmdUI->SetCheck( GetStyle() & WS_SYSMENU );
}
BOOL _MNCanClose(HWND hwnd)
{
BOOL fRetVal = FALSE;
TITLEBARINFO tbi = {sizeof(tbi)};
//---- don't use GetSystemMenu() - has user handle leak issues ----
if (GetTitleBarInfo(hwnd, &tbi))
{
//---- mask out the good bits ----
DWORD dwVal = (tbi.rgstate[5] & (~(STATE_SYSTEM_PRESSED | STATE_SYSTEM_FOCUSABLE)));
fRetVal = (dwVal == 0); // only if no bad bits are left
}
if ( !fRetVal && TESTFLAG(GetWindowLong(hwnd, GWL_EXSTYLE), WS_EX_MDICHILD) )
{
HMENU hMenu = GetSystemMenu(hwnd, FALSE);
MENUITEMINFO menuInfo;
menuInfo.cbSize = sizeof(MENUITEMINFO);
menuInfo.fMask = MIIM_STATE;
if ( GetMenuItemInfo(hMenu, SC_CLOSE, FALSE, &menuInfo) )
{
fRetVal = !(menuInfo.fState & MFS_GRAYED) ? TRUE : FALSE;
}
}
return fRetVal;
}
void CMainFrame::OnUpdateCloseBtn(CCmdUI* pCmdUI)
{
pCmdUI->SetCheck( _MNCanClose(m_hWnd) );
}
void CMainFrame::OnCloseBtn()
{
HMENU hMenu = ::GetSystemMenu(m_hWnd, FALSE);
if( hMenu )
{
MENUITEMINFO mii;
mii.cbSize = sizeof(mii);
mii.fMask = MIIM_ID|MIIM_STATE;
if( GetMenuItemInfo(hMenu, SC_CLOSE, FALSE, &mii ) )
{
if( TESTFLAG(mii.fState, MF_DISABLED) )
{
mii.fState &= ~MF_DISABLED;
}
else
{
mii.fState |= MF_DISABLED;
}
SetMenuItemInfo(hMenu, SC_CLOSE, FALSE, &mii);
SetWindowPos( NULL, 0, 0, 0, 0,
SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_DRAWFRAME );
}
DestroyMenu(hMenu);
}
}
void CMainFrame::OnAltIcon()
{
HICON hIcon = NULL;
m_fAltIcon = !m_fAltIcon;
if( m_fAltIcon )
{
if( !m_hAltIcon )
m_hAltIcon = LoadIcon( AfxGetResourceHandle(), MAKEINTRESOURCE(IDI_ALTICON) );
hIcon = m_hAltIcon;
}
else
{
if( !m_hIcon )
m_hIcon = LoadIcon( AfxGetResourceHandle(), MAKEINTRESOURCE(IDR_MAINFRAME) );
hIcon = m_hIcon;
}
if( hIcon )
{
SendMessage( WM_SETICON, ICON_BIG, (LPARAM)hIcon );
}
}
void CMainFrame::OnUpdateAltIcon(CCmdUI* pCmdUI)
{
pCmdUI->SetCheck( m_fAltIcon );
}
void CMainFrame::OnAltTitle()
{
m_fAltTitle = !m_fAltTitle;
LPCTSTR pszTitle = NULL;
if( m_fAltTitle )
{
if( m_csAltTitle.IsEmpty() )
m_csAltTitle.LoadString( IDS_ALTTEXT );
pszTitle = m_csAltTitle;
}
else
{
if( m_csTitle.IsEmpty() )
m_csTitle.LoadString( IDR_MAINFRAME );
pszTitle = m_csTitle;
}
if( pszTitle )
SetWindowText( pszTitle );
}
void CMainFrame::OnUpdateAltTitle(CCmdUI* pCmdUI)
{
pCmdUI->SetCheck( m_fAltTitle );
}
void CMainFrame::OnDcAppcompat()
{
m_fDcAppCompat = ! m_fDcAppCompat;
if( m_fDcAppCompat )
m_fDfcAppCompat = FALSE;
SetWindowPos( NULL, 0, 0, 0, 0,
SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_DRAWFRAME );
}
void CMainFrame::OnUpdateDcAppcompat(CCmdUI* pCmdUI)
{
pCmdUI->SetCheck(m_fDcAppCompat);
}
void CMainFrame::OnDfcAppcompat()
{
m_fDfcAppCompat = ! m_fDfcAppCompat;
if( m_fDfcAppCompat )
m_fDcAppCompat = FALSE;
SetWindowPos( NULL, 0, 0, 0, 0,
SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_NOACTIVATE|SWP_DRAWFRAME );
}
void CMainFrame::OnUpdateDfcAppcompat(CCmdUI* pCmdUI)
{
pCmdUI->SetCheck(m_fDfcAppCompat);
}
void CMainFrame::OnNcPaint()
{
if( m_fDcAppCompat || m_fDfcAppCompat )
{
RECT rc, rcCaption;
GetWindowRect(&rc);
OffsetRect(&rc, -rc.left, -rc.top );
int cxFrame = GetSystemMetrics( SM_CXSIZEFRAME );
int cyFrame = GetSystemMetrics( SM_CYSIZEFRAME );
int cyCaption = GetSystemMetrics( SM_CYCAPTION );
rcCaption = rc;
rcCaption.left += cxFrame;
rcCaption.right -= cxFrame;
rcCaption.top += cyFrame;
rcCaption.bottom = rcCaption.top + cyCaption;
HDC hdc = ::GetWindowDC(*this);
if( hdc )
{
if( m_fDcAppCompat )
{
DrawCaption( *this, hdc, &rcCaption, DC_GRADIENT|DC_ICON|DC_SMALLCAP|DC_TEXT|0x1000 );
}
else if( m_fDfcAppCompat )
{
int cxEdge = GetSystemMetrics(SM_CXEDGE);
int cyEdge = GetSystemMetrics(SM_CYEDGE);
int cxSize = GetSystemMetrics(SM_CXSIZE);
InflateRect(&rcCaption, -cxEdge, -cyEdge);
rcCaption.left = rcCaption.right - cxSize;
CMDIFrameWnd::OnNcPaint();
DrawFrameControl( hdc, &rcCaption, DFC_CAPTION, DFCS_CAPTIONCLOSE );
}
::ReleaseDC(*this, hdc);
}
}
else
{
CMDIFrameWnd::OnNcPaint();
}
}
void CMainFrame::DoMinMaxStress()
{
// Set up restored position as 1/2 screen size:
int cxScrn = GetSystemMetrics(SM_CXSCREEN);
int cyScrn = GetSystemMetrics(SM_CYSCREEN);
ShowWindow( SW_SHOWNORMAL );
SetWindowPos( NULL,
cxScrn/4, cyScrn/4,
cxScrn/2, cyScrn/2,
SWP_NOZORDER|SWP_NOACTIVATE );
// Make note of SHOWNORMAL window pos
WINDOWINFO wiNormal0, wiNormal, wiTest;
wiNormal.cbSize = wiTest.cbSize = sizeof(wiNormal);
GetWindowInfo( m_hWnd, &wiNormal0 );
int nCmdShowTest = SW_MINIMIZE;
do
{
MSG msg;
while( PeekMessage( &msg, m_hWnd, 0, 0, PM_REMOVE ) )
{
if( WM_KEYDOWN == msg.message && VK_ESCAPE == msg.wParam )
{
m_fMinMaxStress = FALSE;
break;
}
TranslateMessage( &msg );
DispatchMessage( &msg );
}
ShowWindow( nCmdShowTest );
GetWindowInfo( m_hWnd, &wiTest );
m_pwiNormal0 = &wiNormal0;
ShowWindow( SW_SHOWNORMAL );
m_pwiNormal0 = NULL;
GetWindowInfo( m_hWnd, &wiNormal );
if( RECTWIDTH(&wiNormal.rcWindow) != RECTWIDTH(&wiNormal0.rcWindow) ||
RECTHEIGHT(&wiNormal.rcWindow) != RECTHEIGHT(&wiNormal0.rcWindow) )
{
OutputDebugString( TEXT("MDITEST: SW_SHOWNORMAL size mismatch!!!\n") );
DebugBreak();
}
nCmdShowTest = nCmdShowTest==SW_MINIMIZE ? SW_MAXIMIZE : SW_MINIMIZE;
} while( m_fMinMaxStress );
m_fMinMaxStress = FALSE;
}
void CMainFrame::OnMinMaxStress()
{
m_fMinMaxStress = !m_fMinMaxStress;
if( m_fMinMaxStress )
{
DoMinMaxStress();
}
}
void CMainFrame::OnUpdateMinMaxStress(CCmdUI* pCmdUI)
{
pCmdUI->SetCheck(m_fMinMaxStress);
}
void CMainFrame::OnWindowPosChanging(WINDOWPOS FAR* lpwndpos)
{
if( m_fMinMaxStress && m_pwiNormal0 )
{
if( 0 == (lpwndpos->flags & SWP_NOSIZE) )
{
if( lpwndpos->cx != RECTWIDTH(&m_pwiNormal0->rcWindow) ||
lpwndpos->cy!= RECTHEIGHT(&m_pwiNormal0->rcWindow) )
{
OutputDebugString( TEXT("MDITEST: WM_WINDOWPOSCHANGING SW_SHOWNORMAL size mismatch!!!\n") );
DebugBreak();
}
}
}
CMDIFrameWnd::OnWindowPosChanging(lpwndpos);
// TODO: Add your message handler code here
}
Reference in a new issue Copy permalink