// 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 }