home *** CD-ROM | disk | FTP | other *** search
/ Stars of Shareware: Programmierung / SOURCE.mdf / programm / windows / c / mobjm260 / winmenu.cp_ / winmenu.cp
Encoding:
Text File  |  1994-09-06  |  11.2 KB  |  447 lines
  1. //    Microworks ObjectMate  2.6
  2. //
  3. //    WinMenu - 3D Ownerdraw Menu Demonstration
  4. //
  5. //    Copyright 1992-94 Microworks Sydney, Australia.
  6. //
  7. //  WINMENU.CPP
  8.  
  9. /* WinMenu implements 3-dimensional ownerdraw menu's that let you change the
  10.  * menu text font and highlight and text highlight colors.
  11.  */
  12.  
  13. #define CM_ITEM1      101
  14. #define CM_ITEM2      102
  15. #define CM_ITEM3      103
  16. #define CM_ITEM4      104
  17. #define CM_EXITWINDOW 105
  18. #define CM_FONT       106
  19. #define CM_COLOR      107
  20. #define CM_COLORTEXT  109
  21. #define CM_ABOUT      110
  22. #define APPNAME       "WINMENU"
  23.  
  24. #include <owl\owlpch.h>
  25. #include <sfx\sfx200.h>
  26. #include <sfx\sframe.h>
  27. #include <sfx\swindow.h>
  28. #include <sfx\smenu.h>
  29. #include <owl\chooseco.h>
  30. #include <owl\choosefo.h>
  31.  
  32. //    TAboutDialog class
  33.  
  34. class TAboutDialog : public TDialog {
  35.   public:
  36.     TAboutDialog(TWindow*, TResId);
  37.     void SetupWindow();
  38.   DECLARE_RESPONSE_TABLE(TAboutDialog);
  39. };
  40.  
  41. DEFINE_RESPONSE_TABLE1(TAboutDialog, TDialog)
  42. END_RESPONSE_TABLE;
  43.  
  44. TAboutDialog::TAboutDialog(TWindow* parent, TResId resId)
  45.     :TDialog(parent, resId),
  46.      TWindow(parent)
  47. {
  48. }
  49.  
  50. void
  51. TAboutDialog::SetupWindow()
  52. {
  53.     TDialog::SetupWindow();
  54.     CenterWindow(Parent->HWindow, HWindow);
  55. }
  56.  
  57. //    TClientWindow class
  58.  
  59. class TClientWindow : public TSFXWindow {
  60.   public:
  61.     TClientWindow();
  62.   DECLARE_RESPONSE_TABLE(TClientWindow);
  63. };
  64.  
  65. DEFINE_RESPONSE_TABLE2(TClientWindow, TSFXWindow, TWindow)
  66. END_RESPONSE_TABLE;
  67.  
  68. TClientWindow::TClientWindow()
  69.   : TSFXWindow(0, 0, 0)
  70. {
  71.     //Attr.Style |= MWS_RAISEDCLIENT | MWS_GLAZE;
  72.     Attr.Style |= MWS_RAISEDCLIENT | MWS_STEEL;
  73. }
  74.  
  75. //    TMenuWindow class
  76.  
  77. class TMenuWindow : public TSFXFrameWindow {
  78.   public:
  79.     HFONT             Font;
  80.     COLORREF          Color;
  81.     COLORREF          TextColor;
  82.     LOGFONT           LogFont;
  83.     HMENU             Menu, SubMenu;
  84.     TMenuWindow(TWindow*, const char*, TWindow*);
  85.     ~TMenuWindow();
  86.     char far*         GetClassName();
  87.     void              GetWindowClass(WNDCLASS& wndClass);
  88.     void              SetupWindow();
  89.     void              Create3DMenus();
  90.     void              EvDrawItem(UINT, DRAWITEMSTRUCT far&);
  91.     void              EvMeasureItem(UINT, MEASUREITEMSTRUCT far&);
  92.     LRESULT           EvMenuChar(WPARAM, LPARAM);
  93.     void              CmItem1();
  94.     void              CmItem2();
  95.     void              CmItem3();
  96.     void              CmItem4();
  97.     void              CmExitWindow();
  98.     void              CmFont();
  99.     void              CmColor();
  100.     void              CmColorText();
  101.     void              CmAbout();
  102.   DECLARE_RESPONSE_TABLE(TMenuWindow);
  103. };
  104.  
  105. DEFINE_RESPONSE_TABLE2(TMenuWindow, TSFXFrameWindow, TFrameWindow)
  106.   EV_WM_DRAWITEM,
  107.   EV_WM_MEASUREITEM,
  108.   EV_COMMAND(CM_ITEM1, CmItem1),
  109.   EV_COMMAND(CM_ITEM2, CmItem2),
  110.   EV_COMMAND(CM_ITEM3, CmItem3),
  111.   EV_COMMAND(CM_ITEM4, CmItem4),
  112.   EV_COMMAND(CM_EXITWINDOW, CmExitWindow),
  113.   EV_COMMAND(CM_FONT, CmFont),
  114.   EV_COMMAND(CM_COLOR, CmColor),
  115.   EV_COMMAND(CM_COLORTEXT, CmColorText),
  116.   EV_COMMAND(CM_ABOUT, CmAbout),
  117.   EV_MESSAGE(WM_MENUCHAR, EvMenuChar),
  118. END_RESPONSE_TABLE;
  119.  
  120. TMenuWindow::TMenuWindow(TWindow* parent, const char* title, TWindow* clientWnd)
  121.    :TSFXFrameWindow(parent, title, clientWnd),
  122.     TFrameWindow(parent, title, clientWnd),
  123.     TWindow(parent, title)
  124. {
  125.     Attr.Style |= MWS_SFXCAPTION;
  126.     //Attr.Style |= MWS_SFXFRAME;  // Also remove Attr.Style flags for client window
  127.  
  128.     AssignMenu(APPNAME);
  129.     Color = 0;
  130.     TextColor = 0;
  131.  
  132.     //Set up fine system font for menu items
  133.     Font = (HFONT)GetStockObject(SYSTEM_FONT);
  134.     GetObject(Font, sizeof(LOGFONT), &LogFont);
  135.     LogFont.lfWeight = FW_NORMAL;
  136.     strcpy(LogFont.lfFaceName, "MS Sans Serif");
  137.     Font = CreateFontIndirect(&LogFont);
  138. }
  139.  
  140. TMenuWindow::~TMenuWindow()
  141. {
  142.     EraseObject(Font);
  143. }
  144.  
  145. char far*
  146. TMenuWindow::GetClassName()
  147. {
  148.     return APPNAME;
  149. }
  150.  
  151. void
  152. TMenuWindow::GetWindowClass(WNDCLASS& wndClass)
  153. {
  154.     TSFXFrameWindow::GetWindowClass(wndClass);
  155.     wndClass.hbrBackground = 0;
  156. }
  157.  
  158. void TMenuWindow::SetupWindow()
  159. {
  160.     TSFXFrameWindow::SetupWindow();
  161.     Create3DMenus();
  162. }
  163.  
  164. void
  165. TMenuWindow::Create3DMenus()
  166. {
  167.     /* Since the system menu rarely gets modified, Set3DSystemMenu can be used to
  168.      * automatically set up a basic ownerdraw system menu.
  169.      */
  170.     Set3DSystemMenu(HWindow, "WinMenu");
  171.  
  172.     //Create popup submenu with add ownerdraw items
  173.     SubMenu = CreatePopupMenu();
  174.     AppendMenu(SubMenu, MF_OWNERDRAW, CM_ITEM1, "SubMenu Item &A");
  175.     AppendMenu(SubMenu, MF_OWNERDRAW, CM_ITEM2, "SubMenu Item &B");
  176.     AppendMenu(SubMenu, MF_OWNERDRAW | MF_CHECKED, CM_ITEM3, "SubMenu Item &C");
  177.     AppendMenu(SubMenu, MF_OWNERDRAW, CM_ITEM4, "SubMenu Item &D");
  178.  
  179.     //Modify main menu to display ownerdraw items
  180.     Menu = GetSubMenu(GetMenu(), 0);
  181.     ModifyMenu(Menu, 0, MF_BYPOSITION | MF_OWNERDRAW, CM_ITEM1, "Menu Item &A");
  182.     ModifyMenu(Menu, 1, MF_BYPOSITION | MF_OWNERDRAW, CM_ITEM2, "Menu Item &B");
  183.     ModifyMenu(Menu, 2, MF_BYPOSITION | MF_OWNERDRAW, CM_ITEM3, "Menu Item &C");
  184.     ModifyMenu(Menu, 3, MF_BYPOSITION | MF_OWNERDRAW | MF_CHECKED, CM_ITEM4, "Menu Item &D");
  185.     ModifyMenu(Menu, 5, MF_BYPOSITION | MF_OWNERDRAW, CM_EXITWINDOW, "&Exit WinMenu");
  186.     Menu = GetSubMenu(GetMenu(), 1);
  187.     ModifyMenu(Menu, 0, MF_BYPOSITION | MF_OWNERDRAW, CM_ITEM1, "Menu Item &A");
  188.     ModifyMenu(Menu, 1, MF_BYPOSITION | MF_OWNERDRAW, CM_ITEM2, "Menu Item &B");
  189.     ModifyMenu(Menu, 2, MF_BYPOSITION | MF_OWNERDRAW | MF_POPUP, (int)SubMenu, "&Sub Menu");
  190.     ModifyMenu(Menu, 3, MF_BYPOSITION | MF_OWNERDRAW, CM_ITEM4, "Menu Item &D");
  191.     Menu = GetSubMenu(GetMenu(), 2);
  192.     ModifyMenu(Menu, 0, MF_BYPOSITION | MF_OWNERDRAW, CM_ITEM1, "Menu Item &A");
  193.     ModifyMenu(Menu, 1, MF_BYPOSITION | MF_OWNERDRAW, CM_ITEM2, "Menu Item &B");
  194.     ModifyMenu(Menu, 2, MF_BYPOSITION | MF_OWNERDRAW, CM_ITEM3, "Menu Item &C");
  195.     ModifyMenu(Menu, 3, MF_BYPOSITION | MF_OWNERDRAW | MF_POPUP, (int)SubMenu, "&Sub Menu");
  196.     Menu = GetSubMenu(GetMenu(), 3);
  197.     ModifyMenu(Menu, 0, MF_BYPOSITION | MF_OWNERDRAW, CM_FONT, "Menu &Font");
  198.     ModifyMenu(Menu, 1, MF_BYPOSITION | MF_OWNERDRAW, CM_COLOR, "Hilite &Color");
  199.     ModifyMenu(Menu, 2, MF_BYPOSITION | MF_OWNERDRAW, CM_COLORTEXT, "Hilite &Text Color");
  200.     Menu = GetSubMenu(GetMenu(), 4);
  201.     ModifyMenu(Menu, 0, MF_BYPOSITION | MF_OWNERDRAW, CM_ABOUT, "&About WinMenu");
  202. }
  203.  
  204. void
  205. TMenuWindow::EvDrawItem(UINT /*ctlId*/, DRAWITEMSTRUCT far& drawinfo)
  206. {
  207.     /* Pass EvDrawItem onto DrawMenuItem. If you don't want the user to
  208.      * change fonts and highlight colors you can use the default values
  209.      * for this function and just call 'DrawMenuItem(drawinfo);'.
  210.      */
  211.     if (drawinfo.CtlType == ODT_MENU)
  212.         DrawMenuItem(drawinfo, Font, Color, TextColor);
  213. }
  214.  
  215. void
  216. TMenuWindow::EvMeasureItem(UINT /*ctlId*/, MEASUREITEMSTRUCT far& measureinfo)
  217. {
  218.     /* The same font handle passed to DrawMenuItem must be passed to MeasureMenuItem
  219.      */
  220.     if (measureinfo.CtlType == ODT_MENU)
  221.         MeasureMenuItem(HWindow, measureinfo, Font);
  222. }
  223.  
  224. LRESULT
  225. TMenuWindow::EvMenuChar(WPARAM wParam, LPARAM lParam)
  226. {
  227.     /* A mnemonic is the undelined letter in the text of a menu item. When a menu
  228.      * is active the user can select a menu item by pressing the key that corresponds
  229.      * to the item's underlined letter. Ownerdraw menus don't process standard menu
  230.      * mnemonics so you must trap the WM_MENUCHAR message and process them yourself.
  231.      * A WM_MENUCHAR message is sent when a menu is active and the user presses a key.
  232.      * wParam is the key's ascii character, the LOWORD of lParam is the menu type,
  233.      * either MF_POPUP or MF_SYSMENU and the HIWORD of lParam is the handle of the
  234.      * menu. The return value must be a long integer specifying the menu item's zero
  235.      * based position in its LOWORD and '2' in its HIWORD.
  236.      *
  237.      * It was necessary to redefine EvMenuChar using the EV_MESSAGE macro because
  238.      * there is an apparent bug in OWL's EvMenuChar event, and it wont work. 
  239.      *
  240.      * Since the system menu rarely gets modified, ProcessSystemChar can be used to
  241.      * automatically handle system menu mnemonics.
  242.      */
  243.     if (LOWORD(lParam) & MF_SYSMENU)
  244.         return ProcessSystemChar(wParam);
  245.     else
  246.     if ((HMENU)HIWORD(lParam) == SubMenu)
  247.     {
  248.         switch (wParam)
  249.         {
  250.             case 65:
  251.             case 97:
  252.                 return MAKELONG(0, 2);
  253.  
  254.             case 66:
  255.             case 98:
  256.                 return MAKELONG(1, 2);
  257.  
  258.             case 67:
  259.             case 99:
  260.                 return MAKELONG(2, 2);
  261.  
  262.             case 68:
  263.             case 100:
  264.                 return MAKELONG(3, 2);
  265.         }
  266.     }
  267.     else
  268.     if ((HMENU)HIWORD(lParam) == GetSubMenu(GetMenu(), 0))
  269.     {
  270.         switch (wParam)
  271.         {
  272.             case 65:
  273.             case 97:
  274.                 return MAKELONG(0, 2);
  275.  
  276.             case 66:
  277.             case 98:
  278.                 return MAKELONG(1, 2);
  279.  
  280.             case 67:
  281.             case 99:
  282.                 return MAKELONG(2, 2);
  283.  
  284.             case 68:
  285.             case 100:
  286.                 return MAKELONG(3, 2);
  287.  
  288.             case 69:
  289.             case 101:
  290.                 return MAKELONG(5, 2);
  291.         }
  292.     }
  293.     else
  294.     if ((HMENU)HIWORD(lParam) == GetSubMenu(GetMenu(), 1))
  295.     {
  296.         switch (wParam)
  297.         {
  298.             case 65:
  299.             case 97:
  300.                 return MAKELONG(0, 2);
  301.  
  302.             case 66:
  303.             case 98:
  304.                 return MAKELONG(1, 2);
  305.  
  306.             case 83:
  307.             case 115:
  308.                 return MAKELONG(2, 2);
  309.  
  310.             case 68:
  311.             case 100:
  312.                 return MAKELONG(3, 2);
  313.         }
  314.     }
  315.     else
  316.     if ((HMENU)HIWORD(lParam) == GetSubMenu(GetMenu(), 2))
  317.     {
  318.         switch (wParam)
  319.         {
  320.             case 65:
  321.             case 97:
  322.                 return MAKELONG(0, 2);
  323.  
  324.             case 66:
  325.             case 98:
  326.                 return MAKELONG(1, 2);
  327.  
  328.             case 67:
  329.             case 99:
  330.                 return MAKELONG(2, 2);
  331.  
  332.             case 83:
  333.             case 115:
  334.                 return MAKELONG(3, 2);
  335.         }
  336.     }
  337.     else
  338.     if ((HMENU)HIWORD(lParam) == GetSubMenu(GetMenu(), 3))
  339.     {
  340.         switch (wParam)
  341.         {
  342.             case 70:
  343.             case 102:
  344.                 return MAKELONG(0, 2);
  345.  
  346.             case 67:
  347.             case 99:
  348.                 return MAKELONG(1, 2);
  349.  
  350.             case 84:
  351.             case 116:
  352.                 return MAKELONG(2, 2);
  353.         }
  354.     }
  355.     return 0L;
  356. }
  357.  
  358. void
  359. TMenuWindow::CmItem1()
  360. {
  361.     SFXMsgBox(HWindow, "You selected item A", "Information", MB_ICONINFORMATION, 0);
  362. }
  363.  
  364. void
  365. TMenuWindow::CmItem2()
  366. {
  367.     SFXMsgBox(HWindow, "You selected item B", "Information", MB_ICONINFORMATION, 0);
  368. }
  369.  
  370. void
  371. TMenuWindow::CmItem3()
  372. {
  373.     SFXMsgBox(HWindow, "You selected item C", "Information", MB_ICONINFORMATION, 0);
  374. }
  375.  
  376. void
  377. TMenuWindow::CmItem4()
  378. {
  379.     SFXMsgBox(HWindow, "You selected item D", "Information", MB_ICONINFORMATION, 0);
  380. }
  381.  
  382. void
  383. TMenuWindow::CmExitWindow()
  384. {
  385.     CloseWindow();
  386. }
  387.  
  388. void
  389. TMenuWindow::CmFont()
  390. {
  391.     DWORD flags = CF_SCREENFONTS | CF_FORCEFONTEXIST;
  392.     int id = GetSFXTemplateId("SFX3DDlg", DLG_EXFONT);
  393.  
  394.     if (SFXChooseFont(HWindow, (LOGFONT far*)&LogFont, flags, id, TRUE))
  395.     {
  396.         EraseObject(Font);
  397.         Font = CreateFontIndirect(&LogFont);
  398.         AssignMenu("WinMenu");
  399.         Create3DMenus();
  400.     }
  401. }
  402.  
  403. void
  404. TMenuWindow::CmColor()
  405. {
  406.     DWORD flags = CC_RGBINIT;
  407.     int id = GetSFXTemplateId("SFX3DDlg", DLG_EXCOLOR);
  408.     SFXChooseColor(HWindow, (COLORREF far*)&Color, flags, id, TRUE);
  409. }
  410.  
  411. void
  412. TMenuWindow::CmColorText()
  413. {
  414.     DWORD flags = CC_RGBINIT;
  415.     int id = GetSFXTemplateId("SFX3DDlg", DLG_EXCOLOR);
  416.     SFXChooseColor(HWindow, (COLORREF far*)&TextColor, flags, id, TRUE);
  417. }
  418.  
  419. void
  420. TMenuWindow::CmAbout()
  421. {
  422.     TAboutDialog(this, "AboutDialog").Execute();
  423. }
  424.  
  425. //    TMenuApp
  426.  
  427. class TMenuApp : public TApplication {
  428.   public:
  429.     TMenuApp() : TApplication() {}
  430.     void  InitMainWindow();
  431. };
  432.  
  433. void
  434. TMenuApp::InitMainWindow()
  435. {
  436.     MainWindow = new TMenuWindow(0, "WinMenu - 3D Menu Demonstration", new TClientWindow);
  437.     MainWindow->SetIcon(this, APPNAME);
  438. }
  439.  
  440. //    OwlMain
  441.  
  442. int
  443. OwlMain(int /*argc*/, char* /*argv*/ [])
  444. {
  445.     return TMenuApp().Run();
  446. }
  447.