C / C++ / MFC

Step 1. Add two Boolean member variables to your main application window class

<code>class CMainFrame : public CMDIFrameWnd
{
// . . . 

// Implementation
protected:		// Full Screen view implementation
	BOOL m_bFullScreen;
	BOOL m_bWasZoomed;
};</code>

Step 2. Add code to the constructor of your main application window class to initialize to FALSE the member variables added in step 1:

<code>CMainFrame::CMainFrame()
{
	// . . . 

	m_bFullScreen = FALSE;
	m_bWasZoomed = FALSE;
}</code>

Step 3. Add the "View, Full Screen" menu command to all your menu resources. Because this command is handled by the main application window, it should always be available whatever the currently active document or view type. Optionally add a toolbar button for the "View, Full Screen" command.

Step 4. Use ClassWizard to add an 0N_COMMAND handler in your main application window class for the "View, Full Screen" menu command. Use ClassWizard again to add a handler for the WM_GETMINMAXINFO message to your main application window class. Implement these handlers as shown below. Note that these two functions work in coordination to achieve the desired behavior.

<code>void CmainFrame::OnViewFullScreen()
{
   // 1 – Read the various system metrics
   int cyCaption = ::GetSystemMetrics( SM_CYCAPTION );
   int cxFrame = ::GetSystemMetrics( SM_CXFRAME );
   int cyFrame = ::GetSystemMetrics( SM_CYFRAME );
   int cxScreen = ::GetSystemMetrics( SM_CXSCREEN );
   int cyScreen = ::GetSystemMetrics( SM_CYSCREEN );
   int cyMenu = ::GetSystemMetrics( SM_CYMENU );

   // 2 – Toggle the current full-screen mode
   m_bFullScreen = ! m_bFullScreen;

   // 3 – Go into full-screen mode or back into normal
   // NOTE: The following code works together with the
   // OnGetMinMaxInfo() function
   if( m_bFullScreen )
   {
      // 4 – Go from normal into full-screen mode
      m_bWasZoomed = IsZoomed();      // Store current state
      if( m_bWasZoomed )
      {

         // Go from maximized to full-screen mode using SetWindowPos()
         SetWindowPos( NULL,
                       -cxFrame,
                       -( cyFrame + cyCaption + cyMenu ),
                       cxScreen + 2 * cxFrame,
                       cyScreen + 2 * cyFrame + cyCaption + cyMenu,
                       SWP_NOZORDER );
      }
      else
      {

         // Go from normal to full-screen mode using ShowWindow()
         ShowWindow( SW_SHOWMAXIMIZED );
      }
   }
   else
   {
      // 5 – Restore the window to the previous state
      // ( can be either "normal" or "maximized" )
 
      if( m_bWasZoomed )
      {
         // Restore to maximized state using SetWindowPos()
         SetWindowPos( NULL,
                       -cxFrame, -cyFrame,
                       cxScreen+2*cxFrame,
                       cyScreen+2*cyFrame,
                       SWP_NOZORDER );
      }
      else
      {
         // Restore to normal state using ShowWindow()
         ShowWindow( SW_RESTORE );
      }
   }
}

void CmainFrame::OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI)
{
   // 1 – Read the various system metrics
   int cyCaption = ::GetSystemMetrics( SM_CYCAPTION );
   int cxFrame = ::GetSystemMetrics( SM_CXFRAME );
   int cyFrame = ::GetSystemMetrics( SM_CYFRAME );
   int cxScreen = ::GetSystemMetrics( SM_CXSCREEN );
   int cyScreen = ::GetSystemMetrics( SM_CYSCREEN );
   int cyMenu = ::GetSystemMetrics( SM_CYMENU );

   // 2 – Let the default window proc fill the MINMAXINFO structure
   CFrameWnd::OngetMinMaxInfo( lpMMI );

   if( m_bFullScreen )
   {
      // 3 – Full-screen MinMaxInfo
      lpMMI->ptMaxPosition.y = -( cyFrame+cyCaption+cyMenu );
      lpMMI->ptMaxSize.y = lpMMI->ptMaxTrackSize.y = 
                      cyScreen+2*cyFrame+ cyCaption+cyMenu; 
   }
   else
   {
      // 4 – Normal MinMaxInfo
      lpMMI->ptMaxPosition.y = -cyFrame;
      lpMMI->ptMaxSize.y = lpMMI->ptMaxTrackSize.y = cyScreen+2*cyFrame;
   }

   lpMMI->ptMaxPosition.x = -cxFrame;
   lpMMI->ptMaxSize.x = lpMMI->ptMaxTrackSize.x = cxScreen+2*cxFrame;

}</code>

At this point, your application already supports the full-screen view. However, you may wish to add a nice touch to the implementation by helping the user get back from the full-screen view to normal mode by simply pressing the Escape key. To do this, follow these additional steps:

Step 5. Create a new resource symbol called (for example) ID_VIEW_BACK_TO_NORMAL. (Click "View, Resource Symbols" click the New button.)

Step 6. Use ClassWizard to add an ON_COMMAND handler in your main application window class for the ID_VIEW_BACK_TO_NORMAL symbol that you defined in step 5. Implement this handler. 

<code>void CmainFrame::OnViewBackToNormal()
{
   if( m_bFullScreen )   // Only if already in full-screen
   {
      // Toggle view back to normal mode
      OnViewFullScreen();
   }
}</code>

Step 7. Edit your IDR_MAINFRAME accelerator table to define a new accelerator entry that associates the Escape key with the ID_VIEW_BACK_TO_NORMAL symbol that you created in step 5.

Do you like this?    O Yes   O No   O Dunno

COleDateTime dtm1 = d1;
COleDateTime dtm2 = d2;
 
int minutes = static_cast<int>((dtm1 - dtm2).GetTotalMinutes());

BOOL CYourDocument::SaveModified()
{
  return TRUE;
}