ReadMe.txt
上传用户:pasef_zww
上传日期:2007-01-02
资源大小:109k
文件大小:7k
源码类别:

菜单

开发平台:

Visual C++

  1. This is another way to draw a menu with bitmaps item.
  2. Basically, this thing was created to let the user see visually the correspondence of
  3. a menu item and a toolbar button, so that he can learn easily the meanings of sometime
  4. strange button drawing.
  5. Now, the Visual C++ give us that new nice toolbar resources .. why bother with icons or
  6. bitmaps and link them to menus while we can automatically "connect" the toolbar resource
  7. to them ?
  8. So I wrote a small class, CMenuSpawn, which takes care with some help from FrameWnd of
  9. menu remapping and drawing.
  10. What has been updated, changed, added since the last version:
  11. - fix some memory/resource leaks reported from BoundsChecker but not from Msdev (I'm not an owner of
  12.   BoundsChecker - thanks to H.Tome, C. Schmidt, and all the others who rerport them
  13. - added support for shortcut for menu items and popups
  14. - added support for a user font for the menu
  15. - added support for user defined color of menu items
  16. - added support for using bitmap as menu background
  17. - (hope to have) fixed the bug who sometimes make the text (especially of popups) disappear and/or
  18.   enlarge VERY much the popup - however, yet to understand why it did so :)
  19. - added a contructor with a boolean value to be used when creating popup menu (look at
  20.   demo, in the view right mouse click)
  21. - added some base classes for CFrameWnd, CMDIFrameWnd and CMDIChildFrameWnd to make it easier the work;
  22.   you can now simply rederive your CMainFrame from CSpawnFrameWnd or CSpawnMDIFrameWnd and eventually
  23.   your CChildFrame from CSpawnMDIChildWnd to get the WM_MEASUREITEM, WM_DRAWITEM, WM_INITMENU, WM_INITMENUPOPUP
  24.   handled
  25. Now I will explain how to use it in a MDI application:
  26. Step 1: including files
  27. We need to include the CSpawnMenu class in our application and the Bitmap resource named
  28. IDB_MENUCHK from the sample application which comes along (it will be used to draw
  29. "check marks" aside menu item which need it - you can freely change it).
  30. Step 2: handling frame messages
  31. We also need to manage some of the frame windows handler; we have 2 ways to do this. The
  32. simplest is to derive the CMainFrame from the CSpawnMDIFrameWnd class instead of CMDIFrameWnd.
  33. This means you have to (using Search/Replace) replace all istance of CMDIFrameWnd with
  34. CSpawnMDIFrameWnd (and of course include in your project file the files
  35. SpawnMDIFrameWnd.cpp and SpawnMDIFrameWnd.h). You will also need to do this for the
  36. CChildFrame class, deriving from CSpawnMDIChildWnd and including SpawnMDIChildWnd.cpp/.h.
  37. The other way is to look at how this CSpawnFramexxx classes are been made and copy it
  38. (that means putting a CMenuSpawn member in the frame class header and handling the
  39. WM_DRAWITEM, WM_MEASUREITEM, WM_MENUCHAR, WM_INITMENU and WM_INITMENUPOPUP).
  40. If you are making an SDI application instead of an MDI, derive the CFrameWnd from
  41. CSpawnFrameWnd and include the SpawnFrameWnd.cpp/.h files.
  42. Step 3: initializing the CSpawnClass
  43. We need to modify the CMainFrame class in this way:
  44. - add a CMenuSpawn cSpawn instance in the include file
  45. - initialize the CMenuSpawn class in the CMainFrame constructor (cSpawn.LoadToolBarResource(IDR_MAINFRAME))
  46.   this will load the toolbar resource into the class; you can alse use the AddToolBarResource function
  47.   to add more than toolbar resource to the class. In the demo app, I add a toolbar for the system menu
  48. CMainFrame::CMainFrame()
  49. {
  50. cSpawn.LoadToolBarResource(IDR_MAINFRAME);
  51. }
  52. Step 4: Note to Stingray Software's Objective Toolkit Pro users
  53. If you are using the OT Pro, maybe along with the SECMenuBar to obtain Office97 menu
  54. button look and feel, you will also need to override the WindowProc virtual of the
  55. CMainFrame as noted below:
  56. LRESULT CMainFrame::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) 
  57. {
  58. if (message != WM_MEASUREITEM) return SECFrameWnd::WindowProc(message, wParam, lParam);
  59. else return CFrameWnd::WindowProc( message, wParam, lParam );
  60. }
  61. If you are using another OTPro class other than SECFrameWnd as base class, change SECFrameWnd
  62. to reflect your base class.
  63. And that's all to have basic coolmenu support.
  64. Looking at the demo application, which implements an MDI Edit application, you will find a way
  65. to implement popup coolmenu.
  66. Here follows a small description of the most useful function of the CSpawnMenu class:
  67. bool MeasureItem(..)
  68.   To be called from the CWnd OnMeasureItem(..); call the base class if it return false
  69. bool DrawItem(..)
  70.   To be called from the CWnd OnDrawItem(..); call the base class if it return false
  71. bool LoadToolBarResource(unsigned int resId)
  72.   Load a toolbar resource in the class; an array of command id will be created and
  73.   mapped to index of an imagelist
  74. bool AddToolBarResource(unsigned int resId)
  75.   Add a toolbar resource to the class; works as the LoadToolBarResource
  76. void RemapMenu(CMenu * pMenu)
  77.   Makes all the items of the menu OwnerDraw, (eventually) maps them with the appropiate
  78.   images index based on the item command id; has to be called from the WM_INITMENU and
  79.   WM_INITPOPUPMENU and before the TrackPopupMenu function
  80. void EnableMenuItems(CMenu * pMenu, CWnd * pWnd)
  81.   Use the MFC command enabler mechanism to enable/disable menu items; need the pointer of
  82.   the menu and the pointer of the CWnd of which the command enablers are to be used;
  83.   it is designed to be used with popups menu from the right button click in Views
  84.   (see the CEditView in sample apps for an example)
  85. bool SetFont(LOGFONT * lf) *New*
  86.   If someone, for evil pourpose, want to use a different font to draw the menu items,
  87.   it is possible to call this function (before the menu are displayed, for example in the
  88.   CMainFrame contructor after the LoadToolBarResource()). Look at the demo, there is commented
  89.   code.
  90. bool FindKeyboardShortcut(UINT nChar, UINT nFlags, CMenu * pMenu, LRESULT & lRes) *New*
  91.   This is needed to handle the shortcuts when the menu is displayed (the &Letter shortcurs); you
  92.   need to call it in response to WM_MENUCHAR messages of CMainFrame, CChildFrame if MDI app, and
  93.   CView if using Spawn popups; the usage is a bit complex, look at demo and copy/paste the
  94.   code.
  95. void SetTextColor(const COLORREF crNormal, const COLORREF crSelected) *New*
  96.   You can use this to specify different colors from default for the normal and
  97.   selected menu items
  98. void SetBackBitmap(const int iRes) *New*
  99. void SetBackBitmap(const int iRes, COLORREF crBackColor) *New*
  100.   Now you can use bitmaps as background for menu using one of this 2 function. The first
  101.   simply set a bitmap, the second change the color you specify to the menu background
  102.   obtaining a simple transparency. Pay attention to the bitmap you use, which can make
  103.   the menu text unreadable; you may need to use SetFont to set a bold font to read the
  104.   text and the SetTextColor to use brighter color if you use strange bitmaps.
  105.   In the demo, bitmap are enabled in the app menu, and disabled in the popup of the view.
  106.   To see how to disable it, comment the SetBackBitmap in the CMainFrame constructor of the
  107.   demo.
  108. The function for drawing disabled menu items has been stolen from the CToolbarEx of
  109. Joerg Koenig (thanx!).
  110. Very thanks to Craig Schmidt for support!
  111. Feel free to use and modify this class with all your software - I will only be glad to know
  112. for which apps it will be used and of any improvement you will do to it!