home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / mfc / general / dynamenu / dmdoc.cpp < prev    next >
C/C++ Source or Header  |  1998-03-26  |  10KB  |  322 lines
  1. // dmdoc.cpp
  2. //
  3. // This is a part of the Microsoft Foundation Classes C++ library.
  4. // Copyright (C) 1992-1998 Microsoft Corporation
  5. // All rights reserved.
  6. //
  7. // This source code is only intended as a supplement to the
  8. // Microsoft Foundation Classes Reference and related
  9. // electronic documentation provided with the library.
  10. // See these sources for detailed information regarding the
  11. // Microsoft Foundation Classes product.
  12. //
  13. // Purpose: implementation of the CDynaMenuDoc class
  14. //
  15. // Functions:
  16. //      Most of this file was generated by AppWizard.  The functions
  17. //      which contain code specific to this sample are:
  18. //
  19. //      CDynaMenuDoc::CDynaMenuDoc()         -- document constructor
  20. //      CDynaMenuDoc::DoSelectColor()        -- handle text color commands
  21. //      CDynaMenuDoc::DoUpdateSelectColor()  -- update text color UI objects
  22. //      CDynaMenuDoc::GetMessageString()     -- get status msg for color cmds
  23. //      CDynaMenuDoc::OnCmdMsg()             -- perform command routing
  24. //      CDynaMenuDoc::OnColorOptions()       -- display color options dialog
  25.  
  26. #include "stdafx.h"
  27. #include "dynamenu.h"
  28. #include "dmdoc.h"
  29. #include "coloropt.h"  // for CColorOptDlg
  30. #include "mdichild.h"  // for CDynaMDIChildWnd
  31.  
  32. #ifdef _DEBUG
  33. #undef THIS_FILE
  34. static char BASED_CODE THIS_FILE[] = __FILE__;
  35. #endif
  36.  
  37. /////////////////////////////////////////////////////////////////////////////
  38. // This table defines the possible text colors which will be displayed in
  39. // the color options dialog.  The colors selected in the options dialog
  40. // for a document will appear on the Color submenu when that document is
  41. // active.
  42. //
  43. DynaMenuDef CDynaMenuDoc::m_aColorDef[NUM_TEXTCOLOR] =
  44. {
  45.     { IDS_BLACK,    ID_COLOR1, RGB(0,   0, 0) },
  46.     { IDS_RED,      ID_COLOR2, RGB(128, 0, 0) },
  47.     { IDS_PURPLE,   ID_COLOR3, RGB(128, 0, 128) },
  48.     { IDS_BLUE,     ID_COLOR4, RGB(0, 0, 128) },
  49. };
  50.  
  51. /////////////////////////////////////////////////////////////////////////////
  52. // CDynaMenuDoc
  53.  
  54. IMPLEMENT_DYNCREATE(CDynaMenuDoc, CDocument)
  55.  
  56. BEGIN_MESSAGE_MAP(CDynaMenuDoc, CDocument)
  57.     //{{AFX_MSG_MAP(CDynaMenuDoc)
  58.     ON_COMMAND(ID_COLOR_OPTIONS, OnColorOptions)
  59.     //}}AFX_MSG_MAP
  60. END_MESSAGE_MAP()
  61.  
  62. #define new DEBUG_NEW
  63.  
  64. /////////////////////////////////////////////////////////////////////////////
  65. // CDynaMenuDoc construction/destruction
  66.  
  67. CDynaMenuDoc::CDynaMenuDoc()
  68. {
  69.     // Initialize document data.  Start out by allowing all possible
  70.     // text colors and default to using the first one.
  71.     m_iColor = 0;
  72.     for (int i = 0; i < NUM_TEXTCOLOR; i++)
  73.        m_abAllowColor[i] = TRUE;
  74. }
  75.  
  76. CDynaMenuDoc::~CDynaMenuDoc()
  77. {
  78. }
  79.  
  80. BOOL CDynaMenuDoc::OnNewDocument()
  81. {
  82.     if (!CDocument::OnNewDocument())
  83.         return FALSE;
  84.  
  85.     // TODO: add reinitialization code here
  86.     // (SDI documents will reuse this document)
  87.  
  88.     return TRUE;
  89. }
  90.  
  91. /////////////////////////////////////////////////////////////////////////////
  92. // CDynaMenuDoc serialization
  93.  
  94. void CDynaMenuDoc::Serialize(CArchive& ar)
  95. {
  96.     if (ar.IsStoring())
  97.     {
  98.         // TODO: add storing code here
  99.     }
  100.     else
  101.     {
  102.         // TODO: add loading code here
  103.     }
  104. }
  105.  
  106. /////////////////////////////////////////////////////////////////////////////
  107. // CDynaMenuDoc diagnostics
  108.  
  109. #ifdef _DEBUG
  110. void CDynaMenuDoc::AssertValid() const
  111. {
  112.     CDocument::AssertValid();
  113. }
  114.  
  115. void CDynaMenuDoc::Dump(CDumpContext& dc) const
  116. {
  117.     CDocument::Dump(dc);
  118. }
  119. #endif //_DEBUG
  120.  
  121. /////////////////////////////////////////////////////////////////////////////
  122. // CDynaMenuDoc implementation
  123.  
  124. //***********************************************************************
  125. // Function: CDynaMenuDoc::OnCmdMsg()
  126. //
  127. // Purpose:
  128. //    OnCmdMsg() is called by the framework to route and dispatch
  129. //    command messages and to handle the update of command
  130. //    user-interface objects.
  131. //
  132. //    Here we extend the standard command routing to intercept command
  133. //    messages with variable command IDs.  In this sample, the
  134. //    currently defined text color options are stored in
  135. //    CDynaMenuDoc::m_aColorDef.  Each element of this array contains
  136. //    the command ID associated with that color.  When a command ID
  137. //    is passed to this function, we search m_aColorDef for a matching
  138. //    command ID.  If one is found, we process the message.  Otherwise,
  139. //    we route the command to the standard OnCmdMsg processing.
  140. //
  141. // Parameters:
  142. //    nID           -- contains the command ID
  143. //    nCode         -- identifies the command notification code
  144. //    pExtra        -- used according to the value of nCode
  145. //    pHandlerInfo  -- if not NULL, filled in with pTarget and pmf
  146. //                     members of CMDHANDLERINFO structure, instead
  147. //                     of dispatching the command.  Typically NULL.
  148. //
  149. // Returns:
  150. //    nonzero if message handled, otherwise 0.
  151. //
  152. // Comments:
  153. //    See the documentation for CCmdTarget::OnCmdMsg() for further
  154. //    information.  Command routing is also discussed in tech note #21.
  155. //
  156. //***********************************************************************
  157. BOOL CDynaMenuDoc::OnCmdMsg(UINT nID, int nCode, void* pExtra,
  158.                             AFX_CMDHANDLERINFO* pHandlerInfo)
  159. {
  160.     // If pHandlerInfo is NULL, then handle the message
  161.     if (pHandlerInfo == NULL)
  162.     {
  163.         // Filter the commands sent to a text color menu option
  164.         for (int i = NUM_TEXTCOLOR-1; i >= 0; i--)
  165.         {
  166.             if (nID == m_aColorDef[i].m_nID)
  167.             {
  168.                 if (nCode == CN_COMMAND)
  169.                 {
  170.                     // Handle WM_COMMAND message
  171.                     DoSelectColor(i);
  172.                 }
  173.                 else if (nCode == CN_UPDATE_COMMAND_UI)
  174.                 {
  175.                     // Update UI element state
  176.                     DoUpdateSelectColor(i, (CCmdUI*)pExtra);
  177.                 }
  178.                 return TRUE;
  179.             }
  180.         }
  181.     }
  182.  
  183.     // If we didn't process the command, call the base class
  184.     // version of OnCmdMsg so the message-map can handle the message
  185.     return CDocument::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
  186. }
  187.  
  188. //***********************************************************************
  189. // Function: CDynaMenuDoc::DoSelectColor()
  190. //
  191. // Purpose:
  192. //    DoSelectColor processes text color command messages for
  193. //    CDynaMenuDoc::OnCmdMsg(). It updates the document member variable
  194. //    m_iColor and calls UpdateAllViews() to redraw the document's
  195. //    views.
  196. //
  197. // Parameters:
  198. //    iColor -- index into CDynaMenuDoc::m_aColorDef for new
  199. //              color selection
  200. //
  201. // Returns:
  202. //    none.
  203. //
  204. // Comments:
  205. //    In the debug version, an assert is generated if the index is
  206. //    out of bounds or if the specified color is not currently
  207. //    enabled for the document.
  208. //
  209. //***********************************************************************
  210. void CDynaMenuDoc::DoSelectColor(int iColor)
  211. {
  212.     ASSERT(iColor >= 0 && iColor < NUM_TEXTCOLOR);
  213.     ASSERT(m_abAllowColor[iColor] == TRUE);
  214.  
  215.     m_iColor = iColor;
  216.     UpdateAllViews(NULL);
  217. }
  218.  
  219. //***********************************************************************
  220. // Function: CDynaMenuDoc::DoUpdateSelectColor()
  221. //
  222. // Purpose:
  223. //    DoUpdateSelectColor handled the updates to user-interface objects
  224. //    associated with text color command messages for
  225. //    CDynaMenuDoc::OnCmdMsg(). If the item is associated with the
  226. //    currently selected text color for the document, the item is checked.
  227. //
  228. // Parameters:
  229. //    iColor -- index into CDynaMenuDoc::m_aColorDef for new
  230. //              color selection
  231. //
  232. // Returns:
  233. //    none.
  234. //
  235. // Comments:
  236. //    In the debug version, an assert is generated if the index is
  237. //    out of bounds or if the item is disabled for the document.
  238. //
  239. //***********************************************************************
  240. void CDynaMenuDoc::DoUpdateSelectColor(int iColor, CCmdUI* pCmdUI)
  241. {
  242.     ASSERT(iColor >= 0 && iColor < NUM_TEXTCOLOR);
  243.     ASSERT(m_abAllowColor[iColor] == TRUE);
  244.  
  245.     pCmdUI->SetCheck(m_iColor == iColor);
  246.     pCmdUI->Enable(TRUE);
  247. }
  248.  
  249. //***********************************************************************
  250. // Function: CDynaMenuDoc::GetMessageString()
  251. //
  252. // Purpose:
  253. //    GetMessageString formats and returns a string containing the
  254. //    message text to display in a status bar for any of the color
  255. //    selection commands.
  256. //
  257. // Parameters:
  258. //    nID        -- command ID to get message for
  259. //    strMessage -- buffer to fill with message
  260. //
  261. // Returns:
  262. //    TRUE if nID is a color selection command ID, otherwise FALSE.
  263. //
  264. // Comments:
  265. //    If the function returns FALSE, strMessage is not changed
  266. //
  267. //***********************************************************************
  268. BOOL CDynaMenuDoc::GetMessageString(UINT nID, CString& strMessage)
  269. {
  270.     for (int i = 0; i < NUM_TEXTCOLOR; i++)
  271.     {
  272.         if (m_aColorDef[i].m_nID == nID)
  273.         {
  274.             CString strColor;
  275.             strColor.LoadString(m_aColorDef[i].m_nString);
  276.             AfxFormatString1(strMessage, IDS_COLORHELPFMT, strColor);
  277.             return TRUE;
  278.         }
  279.     }
  280.     return FALSE;
  281. }
  282.  
  283.  
  284. /////////////////////////////////////////////////////////////////////////////
  285. // CDynaMenuDoc commands
  286.  
  287. //***********************************************************************
  288. // Function: CDynaMenuDoc::OnColorOptions()
  289. //
  290. // Purpose:
  291. //    OnColorOptions displays a dialog which allows the user to pick
  292. //    the text colors which should be displayed on the Color submenu
  293. //    when the document is active.
  294. //
  295. // Parameters:
  296. //    none.
  297. //
  298. // Returns:
  299. //    none.
  300. //
  301. // Comments:
  302. //    none.
  303. //
  304. //***********************************************************************
  305. void CDynaMenuDoc::OnColorOptions()
  306. {
  307.     CColorOptDlg dlg(this);
  308.     if (dlg.DoModal())
  309.     {
  310.         // find the MDI frame window associated with this document
  311.         POSITION pos = GetFirstViewPosition();
  312.         CView* pview = GetNextView(pos);
  313.         ASSERT(pview != NULL);
  314.  
  315.         CDynaMDIChildWnd* pwnd = (CDynaMDIChildWnd*)pview->GetParentFrame();
  316.         ASSERT_KINDOF(CDynaMDIChildWnd, pwnd);
  317.  
  318.         // force an update of the Color submenu
  319.         pwnd->RefreshColorMenu();
  320.     }
  321. }
  322.