home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / STYLE.ZIP / STY_USER.C < prev    next >
C/C++ Source or Header  |  1992-03-30  |  29KB  |  897 lines
  1. /*************************************************************************
  2. *
  3. *  File Name   : STY_USER.C
  4. *
  5. *  Description : This module contains the code for processing
  6. *                messages sent to the standard window that the
  7. *                standard window does not process.
  8. *
  9. *  Concepts    : Message processing
  10. *
  11. *  API's       : WinSetWindowPos
  12. *                WinSetFocus
  13. *                WinDefWIndowProc
  14. *                WinDlgBox
  15. *                WinSendMsg
  16. *                WinOpenClipbrd
  17. *                WinQueryClipbrdFmtInfo
  18. *                WinCloseClipbrd
  19. *                WinMessageBox
  20. *                WinLoadString
  21. *                WinSendMsg
  22. *                GpiCreateLogFont
  23. *                GpiSetCharSet
  24. *                GpiQueryFontMetrics
  25. *                GpiDeleteSetId
  26. *                WinGetPS
  27. *                WinReleasePS
  28. *                WinFontDlg
  29. *
  30. *  Copyright (C) 1992 IBM Corporation
  31. *
  32. *      DISCLAIMER OF WARRANTIES.  The following [enclosed] code is
  33. *      sample code created by IBM Corporation. This sample code is not
  34. *      part of any standard or IBM product and is provided to you solely
  35. *      for  the purpose of assisting you in the development of your
  36. *      applications.  The code is provided "AS IS", without
  37. *      warranty of any kind.  IBM shall not be liable for any damages
  38. *      arising out of your use of the sample code, even if they have been
  39. *      advised of the possibility of such damages.                                                    *
  40. *
  41. ************************************************************************/
  42.  
  43. /*  Include files, macros, defined constants, and externs               */
  44.  
  45. #define INCL_WINMENUS
  46. #define INCL_WINWINDOWMGR
  47. #define INCL_WINCLIPBOARD
  48. #define INCL_WINMLE
  49. #define INCL_WINSTDFONT
  50. #define INCL_GPILCIDS
  51. #define INCL_GPIPRIMITIVES
  52. #define INCL_WINSYS
  53.  
  54. #include <os2.h>
  55. #include "sty_main.h"
  56. #include "sty_xtrn.h"
  57. #include "sty_dlg.h"
  58. #include <string.h>
  59.  
  60. /*  Global variables */
  61.  
  62. LONG lClrForeground = CLR_BLACK;                    /* color for window text */
  63. LONG lClrBackground = CLR_WHITE;                     /* color for background */
  64.  
  65. LONG lClrDefaultForeground = CLR_BLACK;             /* color for window text */
  66. LONG lClrDefaultBackground = CLR_WHITE;              /* color for background */
  67.  
  68. /*--------------------------------------------------------------*\
  69.  *  Entry point declarations
  70. \*--------------------------------------------------------------*/
  71.  
  72. VOID SetForegroundColor(SHORT idMenu);
  73. VOID SetBackgroundColor(SHORT idMenu);
  74. VOID SetFont(VOID);
  75. VOID ConvertVectorFontSize(FIXED fxPointSize, PFATTRS pfattrs);
  76. MRESULT EXPENTRY DemoDlgProc(HWND hwnd, USHORT msg,
  77.                                   MPARAM mp1, MPARAM mp2);
  78. MRESULT EXPENTRY PresParamDemoDlgProc(HWND hwnd, USHORT msg,
  79.                                   MPARAM mp1, MPARAM mp2);
  80. VOID ShowDemoDlg(SHORT idMenuItem);
  81. VOID ShowDemoMsgBox(SHORT idMenuItem);
  82.  
  83. /*********************************************************************
  84.  *  Name: UserWndProc
  85.  *
  86.  *  Description : Process any messages sent to hwndMain
  87.  *                that are not processed by the standard
  88.  *                window procedure.
  89.  *
  90.  *  Concepts : Routine is called for each message MainWndProc does
  91.  *             not process.  A switch statement branches control
  92.  *             based upon the message passed.  Any messages not
  93.  *             processed here must be passed onto
  94.  *             WinDefWindowProc()
  95.  *
  96.  *  API's : WinSetWindowPos
  97.  *          WinSetFocus
  98.  *          WinDefWIndowProc
  99.  *
  100.  * Parameters   : hwnd - Window handle to which message is addressed
  101.  *                msg - Message type
  102.  *                mp1 - First message parameter
  103.  *                mp2 - Second message parameter
  104.  *
  105.  *  Returns: Return value depended upon the message processed
  106.  *
  107.  ****************************************************************/
  108. MRESULT UserWndProc( HWND hwnd, USHORT msg, MPARAM mp1, MPARAM mp2)
  109. {
  110.    switch(msg)
  111.    {
  112.       case WM_SIZE:
  113.          /*
  114.           * Re-size the MLE to be the same width and height
  115.           * as the client window
  116.           */
  117.          WinSetWindowPos(hwndMLE, HWND_TOP, 0, 0, SHORT1FROMMP(mp2),
  118.                             SHORT2FROMMP(mp2), SWP_SIZE);
  119.          break;
  120.  
  121.       case WM_SETFOCUS:
  122.          if(SHORT1FROMMP(mp1))
  123.          {
  124.             WinPostMsg(hwnd, SM_SETFOCUS, NULL, NULL);
  125.          }
  126.          break;
  127.  
  128.       case SM_SETFOCUS:
  129.          WinSetFocus(HWND_DESKTOP, hwndMLE);
  130.          break;
  131.  
  132.       default:
  133.          /*
  134.           * Default must call WinDefWindowProc()
  135.           */
  136.          return(WinDefWindowProc(hwnd, msg, mp1, mp2));
  137.          break;
  138.    }
  139.  
  140.    return (MRESULT)0;
  141.  
  142. }   /*    End of UserWndProc()                                          */
  143.  
  144. /*********************************************************************
  145.  *  Name: UserCommand
  146.  *
  147.  *  Description : Process any WM_COMMAND messages send to
  148.  *                hwndMain that are not processed by MainCommand
  149.  *
  150.  *  Concepts : Routine is called for each WM_COMMAND that is not
  151.  *             posted by a standard menu item. A switch statement
  152.  *             branches control based upon the id of the control
  153.  *             which posted the message.
  154.  *
  155.  *  API's : WinDlgBox
  156.  *
  157.  *  Parameters :  mp1 - First message parameter
  158.  *                mp2 - Second message parameter
  159.  *
  160.  *  Returns: Void
  161.  *
  162.  ****************************************************************/
  163. VOID UserCommand(MPARAM mp1, MPARAM mp2)
  164. {
  165.    switch(SHORT1FROMMP(mp1))
  166.    {
  167.       case IDM_OPTIONSFORECOLORBLACK:
  168.       case IDM_OPTIONSFORECOLORBLUE:
  169.       case IDM_OPTIONSFORECOLORRED:
  170.       case IDM_OPTIONSFORECOLORDEFAULT:
  171.           SetForegroundColor(SHORT1FROMMP(mp1));
  172.           break;
  173.  
  174.       case IDM_OPTIONSBACKCOLORPINK:
  175.       case IDM_OPTIONSBACKCOLORCYAN:
  176.       case IDM_OPTIONSBACKCOLORYELLOW:
  177.       case IDM_OPTIONSBACKCOLORDEFAULT:
  178.           SetBackgroundColor(SHORT1FROMMP(mp1));
  179.           break;
  180.  
  181.       case IDM_OPTIONSFONT:
  182.           SetFont();
  183.           break;
  184.  
  185.       case IDM_DEMODLGBUTTONS:
  186.       case IDM_DEMODLGLISTBOXES:
  187.       case IDM_DEMODLGCOMBOBOXES:
  188.       case IDM_DEMODLGENTRYFIELDS:
  189.       case IDM_DEMODLGSTATIC:
  190.       case IDM_DEMODLGSLIDER:
  191.       case IDM_DEMODLGSPINBUTTON:
  192.       case IDM_DEMODLGVALUESET:
  193.       case IDM_DEMODLGNOTEBOOK:
  194.       case IDM_DEMODLGCONTAINER:
  195.           ShowDemoDlg(SHORT1FROMMP(mp1));
  196.           break;
  197.  
  198.       case IDM_DEMOMSGBOXOK:
  199.       case IDM_DEMOMSGBOXOKCANCEL:
  200.       case IDM_DEMOMSGBOXYESNO:
  201.       case IDM_DEMOMSGBOXYESNOCANCEL:
  202.       case IDM_DEMOMSGBOXRETRYCANCEL:
  203.       case IDM_DEMOMSGBOXABORT:
  204.       case IDM_DEMOMSGBOXENTER:
  205.       case IDM_DEMOMSGBOXENTERCANCEL:
  206.       case IDM_DEMOMSGBOXQUERY:
  207.       case IDM_DEMOMSGBOXWARNING:
  208.       case IDM_DEMOMSGBOXINFO:
  209.       case IDM_DEMOMSGBOXCRITICAL:
  210.       case IDM_DEMOMSGBOXAPP:
  211.       case IDM_DEMOMSGBOXSYS:
  212.       case IDM_DEMOMSGBOXHELP:
  213.           ShowDemoMsgBox(SHORT1FROMMP(mp1));
  214.           break;
  215.  
  216.       case IDM_DEMODLGPP:
  217.           WinDlgBox(hwndMain, hwndMain, (PFNWP)PresParamDemoDlgProc,
  218.                     (HMODULE)0, IDD_PPDEMODLG, (PVOID)NULL);
  219.           break;
  220.  
  221.       default:
  222.           break;
  223.    }
  224.  /*
  225.   * This routine currently doesn't use the mp2 parameter but
  226.   * it is referenced here to prevent an 'Unreferenced Parameter'
  227.   * warning at compile time.
  228.   */
  229.   mp2;
  230. }   /*    End of UserCommand()                                          */
  231.  
  232. /*********************************************************************
  233.  *  Name: InitMenu
  234.  *
  235.  *  Description : Processes the WM_INITMENU message for the main
  236.  *                window, disabling any menus that are not active
  237.  *
  238.  *  Concepts : Routine is called each time a menu is selected.  A
  239.  *             switch statement branches control based upon the
  240.  *             id of the menu which is being displayed.
  241.  *
  242.  *  API's : WinSendMsg
  243.  *          WinOpenClipbrd
  244.  *          WinQueryClipbrdFmtInfo
  245.  *          WinCloseClipbrd
  246.  *
  247.  *  Parameters :  mp1 - First message parameter
  248.  *                mp2 - Second message parameter
  249.  *
  250.  *  Returns: Nome
  251.  *
  252.  ****************************************************************/
  253. VOID InitMenu( MPARAM mp1, MPARAM mp2)
  254. {
  255.    ULONG  ulFmtInfo;
  256.    BOOL bEnable;
  257.    SHORT sRc1,sRc2;
  258.  
  259.    switch(SHORT1FROMMP(mp1))
  260.    {
  261.       case IDM_HELP:
  262.       /*
  263.        * Enable or disable the Help menu depending upon whether the
  264.        * help manager has been enabled
  265.        */
  266.          EnableMenuItem(HWNDFROMMP(mp2), IDM_HELPUSINGHELP, fHelpEnabled);
  267.          EnableMenuItem(HWNDFROMMP(mp2), IDM_HELPGENERAL, fHelpEnabled);
  268.          EnableMenuItem(HWNDFROMMP(mp2), IDM_HELPKEYS, fHelpEnabled);
  269.          EnableMenuItem(HWNDFROMMP(mp2), IDM_HELPINDEX, fHelpEnabled);
  270.          break;
  271.  
  272.       case IDM_EDIT:
  273.       /*
  274.        * if text is selected in the MLE, the enable the Cut, Copy,
  275.        * and Clear menus.  Otherwise, do not
  276.        */
  277.          sRc1 = (SHORT) WinSendMsg(hwndMLE, MLM_QUERYSEL,
  278.                            MPFROMSHORT(MLFQS_MINSEL), NULL);
  279.  
  280.          sRc2 = (SHORT) WinSendMsg(hwndMLE, MLM_QUERYSEL,
  281.                            MPFROMSHORT(MLFQS_MAXSEL), NULL);
  282.  
  283.          if (sRc1 != sRc2)
  284.             bEnable = TRUE;
  285.          else
  286.             bEnable = FALSE;
  287.  
  288.          EnableMenuItem(HWNDFROMMP(mp2), IDM_EDITCUT, bEnable);
  289.          EnableMenuItem(HWNDFROMMP(mp2), IDM_EDITCOPY, bEnable);
  290.          EnableMenuItem(HWNDFROMMP(mp2), IDM_EDITCLEAR, bEnable);
  291.  
  292.          /*
  293.           * determine if the MLE can Undo the last action.  If it can't,
  294.           * then disable he Undo menu
  295.           */
  296.  
  297.          sRc1 =  (SHORT) WinSendMsg(hwndMLE, MLM_QUERYUNDO, NULL, NULL);
  298.          if (sRc1 != 0)
  299.             bEnable = TRUE;
  300.          else
  301.             bEnable = FALSE;
  302.  
  303.          EnableMenuItem(HWNDFROMMP(mp2), IDM_EDITUNDO, bEnable);
  304.  
  305.          /*
  306.           * determine if the clipboard has some text on it.  If it
  307.           * doesn't, then disable the Paste menu
  308.           */
  309.          if(WinOpenClipbrd(hab))
  310.          {
  311.            if (WinQueryClipbrdFmtInfo(hab, CF_TEXT, &ulFmtInfo))
  312.               bEnable = TRUE;
  313.            else
  314.               bEnable = FALSE;
  315.            WinCloseClipbrd(hab);
  316.          }
  317.          else
  318.             bEnable = TRUE;
  319.  
  320.          EnableMenuItem(HWNDFROMMP(mp2), IDM_EDITPASTE, bEnable);
  321.          break;
  322.  
  323.       case IDM_OPTIONSFORECOLOR:
  324.          {
  325.           LONG lColor;
  326.           BOOL bBlack = TRUE;
  327.           BOOL bBlue = TRUE;
  328.           BOOL bRed = TRUE;
  329.           BOOL bDefault = TRUE;
  330.  
  331.           lColor = (LONG)WinSendMsg(hwndMLE,MLM_QUERYTEXTCOLOR, NULL, NULL);
  332.           switch (lColor)
  333.           {
  334.              case CLR_BLACK:
  335.                 bBlack = FALSE;
  336.                 break;
  337.              case CLR_BLUE:
  338.                 bBlue = FALSE;
  339.                 break;
  340.              case CLR_RED:
  341.                 bRed = FALSE;
  342.                 break;
  343.              default:
  344.                 bDefault = FALSE;
  345.                 break;
  346.            }
  347.  
  348.            EnableMenuItem(HWNDFROMMP(mp2), IDM_OPTIONSFORECOLORBLACK,
  349.                            bBlack);
  350.            EnableMenuItem(HWNDFROMMP(mp2), IDM_OPTIONSFORECOLORBLUE, bBlue);
  351.            EnableMenuItem(HWNDFROMMP(mp2), IDM_OPTIONSFORECOLORRED, bRed);
  352.            EnableMenuItem(HWNDFROMMP(mp2), IDM_OPTIONSFORECOLORDEFAULT,
  353.                            bDefault);
  354.          }
  355.          break;
  356.       case IDM_OPTIONSBACKCOLOR:
  357.          {
  358.           LONG lColor;
  359.           BOOL bYellow = TRUE;
  360.           BOOL bPink = TRUE;
  361.           BOOL bCyan = TRUE;
  362.           BOOL bDefault = TRUE;
  363.  
  364.           lColor = (LONG)WinSendMsg(hwndMLE,MLM_QUERYBACKCOLOR, NULL, NULL);
  365.           switch (lColor)
  366.           {
  367.              case CLR_YELLOW:
  368.                 bYellow = FALSE;
  369.                 break;
  370.              case CLR_PINK:
  371.                 bPink = FALSE;
  372.                 break;
  373.              case CLR_CYAN:
  374.                 bCyan = FALSE;
  375.                 break;
  376.              default:
  377.                 bDefault = FALSE;
  378.                 break;
  379.            }
  380.  
  381.            EnableMenuItem(HWNDFROMMP(mp2), IDM_OPTIONSBACKCOLORYELLOW,
  382.                            bYellow);
  383.            EnableMenuItem(HWNDFROMMP(mp2), IDM_OPTIONSBACKCOLORPINK, bPink);
  384.            EnableMenuItem(HWNDFROMMP(mp2), IDM_OPTIONSBACKCOLORCYAN, bCyan);
  385.            EnableMenuItem(HWNDFROMMP(mp2), IDM_OPTIONSBACKCOLORDEFAULT,
  386.                            bDefault);
  387.          }
  388.          break;
  389.  
  390.       default:
  391.           break;
  392.    }
  393. }   /*       End of InitMenu()                                          */
  394.  
  395. /*********************************************************************
  396.  *  Name: EnableMenuItem
  397.  *
  398.  *  Description : Enables or disables menu item.
  399.  *
  400.  *  Concepts : Called whenever a menu item is to be enabled or
  401.  *             disabled.  Sends a MM_SETITEMATTR to the menu with
  402.  *             the given item id.  Sets the MIA_DISABLED
  403.  *             attribute flag if the item is to be disabled,
  404.  *             clears the flag if enabling.
  405.  *
  406.  *  API's : WinSendMsg
  407.  *
  408.  *  Parameters   : hwnd - Window handle of the menu
  409.  *                 sIditem  - Id of the menu item.
  410.  *                 bEnable - Enable/Disable flag
  411.  *
  412.  *  Returns: Void
  413.  *
  414.  ****************************************************************/
  415. VOID EnableMenuItem( HWND hwndMenu, SHORT sIditem, BOOL bEnable)
  416. {
  417.   SHORT sFlag;
  418.  
  419.   if(bEnable)
  420.     sFlag = 0;
  421.   else
  422.     sFlag = MIA_DISABLED;
  423.  
  424.   WinSendMsg(hwndMenu, MM_SETITEMATTR, MPFROM2SHORT(sIditem, TRUE),
  425.                MPFROM2SHORT(MIA_DISABLED, sFlag));
  426.  
  427. }   /*         End of EnableMenuItem()                                  */
  428.  
  429. /*********************************************************************
  430.  *  Name: ShowDemoDlg
  431.  *
  432.  *  Description : Displays the demonstration dialog for the menu
  433.  *                id chosen.
  434.  *
  435.  *  Concepts : Called whenever a menu item from the Dialog Box
  436.  *             menu of the Demo menu is selected.  Determines the
  437.  *             id of the dialog template and creates a dialog of
  438.  *             that template.
  439.  *
  440.  *  API's : WinDlgBox
  441.  *
  442.  *  Parameters :   sIdMenuItem - Id of the menu item.
  443.  *
  444.  *  Returns: Void
  445.  *
  446.  ****************************************************************/
  447. VOID ShowDemoDlg( SHORT sIdMenuItem)
  448. {
  449.   static SHORT sIdDlg;
  450.  
  451.   switch(sIdMenuItem)
  452.   {
  453.      case IDM_DEMODLGBUTTONS:
  454.          sIdDlg = IDD_BUTTONSDLG;
  455.          break;
  456.  
  457.      case IDM_DEMODLGLISTBOXES:
  458.          sIdDlg = IDD_LISTBOXDLG;
  459.          break;
  460.  
  461.      case IDM_DEMODLGCOMBOBOXES:
  462.          sIdDlg = IDD_COMBOBOXDLG;
  463.          break;
  464.  
  465.      case IDM_DEMODLGENTRYFIELDS:
  466.          sIdDlg = IDD_ENTRYFIELDDLG;
  467.          break;
  468.  
  469.      case IDM_DEMODLGSTATIC:
  470.          sIdDlg = IDD_STATICDLG;
  471.          break;
  472.  
  473.      case IDM_DEMODLGSLIDER:
  474.          sIdDlg = IDD_SLIDERDLG;
  475.          break;
  476.  
  477.      case IDM_DEMODLGSPINBUTTON:
  478.          sIdDlg = IDD_SPINBUTTONDLG;
  479.          break;
  480.  
  481.      case IDM_DEMODLGVALUESET:
  482.          sIdDlg = IDD_VALUESETDLG;
  483.          break;
  484.  
  485.      case IDM_DEMODLGNOTEBOOK:
  486.          sIdDlg = IDD_NOTEBOOKDLG;
  487.          break;
  488.      case IDM_DEMODLGCONTAINER:
  489.          sIdDlg = IDD_CONTAINERDLG;
  490.          break;
  491.  
  492.      default:    /* unknown menu id */
  493.          return;
  494.          break;
  495.   }
  496.  
  497.   WinDlgBox(HWND_DESKTOP, hwndMain,
  498.            (PFNWP)DemoDlgProc,          /* all demos use DemoDlgProc    */
  499.            (HMODULE)0,
  500.            sIdDlg,                      /* id of template               */
  501.            (PVOID)&sIdDlg);             /* pass id as mp2 of WM_INITDLG */
  502.  
  503. }   /*      End of ShowDemoDlg()                                        */
  504.  
  505.  
  506. /*********************************************************************
  507.  *  Name: ShowDemoMsgBox
  508.  *
  509.  *  Description : Displays the demonstration message box for the menu
  510.  *                id chosen.
  511.  *
  512.  *  Concepts :  Called whenever a menu item from the Message Box menu
  513.  *              of the Demo menu is selected.  Determines the options
  514.  *              for the message box and then creates the box.
  515.  *
  516.  *  API's : WinLoadString
  517.  *          WinMessageBox
  518.  *
  519.  *  Parameters : sIdMenuItem - Id of the menu item.
  520.  *
  521.  *  Returns: VOID
  522.  *
  523.  ****************************************************************/
  524. VOID ShowDemoMsgBox( SHORT sIdMenuItem)
  525. {
  526.   SHORT sOptions, sIdText;
  527.   CHAR szText[MESSAGELEN];
  528.  
  529.   switch(sIdMenuItem)
  530.   {
  531.      case IDM_DEMOMSGBOXOK:
  532.         sOptions = MB_OK | MB_MOVEABLE;
  533.         sIdText = IDS_DEMOMSGBOXOK;
  534.         break;
  535.  
  536.      case IDM_DEMOMSGBOXOKCANCEL:
  537.         sOptions = MB_OKCANCEL | MB_MOVEABLE;
  538.         sIdText = IDS_DEMOMSGBOXOKCANCEL;
  539.         break;
  540.  
  541.      case IDM_DEMOMSGBOXYESNO:
  542.         sOptions = MB_YESNO | MB_MOVEABLE;
  543.         sIdText = IDS_DEMOMSGBOXYESNO;
  544.         break;
  545.  
  546.      case IDM_DEMOMSGBOXYESNOCANCEL:
  547.         sOptions = MB_YESNOCANCEL | MB_MOVEABLE;
  548.         sIdText = IDS_DEMOMSGBOXYESNOCANCEL;
  549.         break;
  550.  
  551.      case IDM_DEMOMSGBOXRETRYCANCEL:
  552.         sOptions = MB_RETRYCANCEL | MB_MOVEABLE;
  553.         sIdText = IDS_DEMOMSGBOXRETRYCANCEL;
  554.         break;
  555.  
  556.      case IDM_DEMOMSGBOXABORT:
  557.         sOptions = MB_ABORTRETRYIGNORE | MB_MOVEABLE;
  558.         sIdText = IDS_DEMOMSGBOXABORT;
  559.         break;
  560.  
  561.      case IDM_DEMOMSGBOXENTER:
  562.         sOptions = MB_ENTER | MB_MOVEABLE;
  563.         sIdText = IDS_DEMOMSGBOXENTER;
  564.         break;
  565.  
  566.      case IDM_DEMOMSGBOXENTERCANCEL:
  567.         sOptions = MB_ENTERCANCEL | MB_MOVEABLE;
  568.         sIdText = IDS_DEMOMSGBOXENTERCANCEL;
  569.         break;
  570.  
  571.      case IDM_DEMOMSGBOXQUERY:
  572.         sOptions = MB_OK | MB_QUERY | MB_MOVEABLE;
  573.         sIdText = IDS_DEMOMSGBOXQUERY;
  574.         break;
  575.  
  576.      case IDM_DEMOMSGBOXWARNING:
  577.         sOptions = MB_OK | MB_WARNING | MB_MOVEABLE;
  578.         sIdText = IDS_DEMOMSGBOXWARNING;
  579.         break;
  580.  
  581.      case IDM_DEMOMSGBOXINFO:
  582.         sOptions = MB_OK | MB_INFORMATION | MB_MOVEABLE;
  583.         sIdText = IDS_DEMOMSGBOXINFO;
  584.         break;
  585.  
  586.      case IDM_DEMOMSGBOXCRITICAL:
  587.         sOptions = MB_OK | MB_CRITICAL | MB_MOVEABLE;
  588.         sIdText = IDS_DEMOMSGBOXCRITICAL;
  589.         break;
  590.  
  591.      case IDM_DEMOMSGBOXAPP:
  592.         sOptions = MB_OK | MB_APPLMODAL | MB_MOVEABLE;
  593.         sIdText = IDS_DEMOMSGBOXAPP;
  594.         break;
  595.  
  596.      case IDM_DEMOMSGBOXSYS:
  597.         sOptions = MB_OK | MB_SYSTEMMODAL | MB_MOVEABLE;
  598.         sIdText = IDS_DEMOMSGBOXSYS;
  599.         break;
  600.  
  601.      case IDM_DEMOMSGBOXHELP:
  602.         sOptions = MB_OK | MB_HELP | MB_MOVEABLE;
  603.         sIdText = IDS_DEMOMSGBOXHELP;
  604.         break;
  605.  
  606.      default:
  607.         /*
  608.         * Unknown menu id
  609.         */
  610.         return;
  611.         break;
  612.   }
  613.  
  614.   /*
  615.   * Get the text for the message box
  616.   */
  617.   if(!WinLoadString(hab, (HMODULE)0, sIdText, MESSAGELEN, (PSZ)szText))
  618.   {
  619.      MessageBox(hwndMain, IDMSG_CANNOTLOADSTRING, MB_OK | MB_ERROR, FALSE);
  620.         return;
  621.   }
  622.  
  623.   /* bring up the message box                                           */
  624.   WinMessageBox(HWND_DESKTOP, hwndMain, szText, szAppName, IDD_DEMOMSGBOX,
  625.                 sOptions);
  626.  
  627. }   /*   End of ShowDemoMsgBox()                                        */
  628.  
  629. /*********************************************************************
  630.  *  Name: SetForegroundColor
  631.  *
  632.  *  Description : Allows the user to select a color for the
  633.  *                window foreground
  634.  *
  635.  *  Concepts : Routine is called each time the user selects one
  636.  *             of the Foreground colors listed in the Foreground
  637.  *             Color submenu of the Options menu.  A switch
  638.  *             statement determines which menu item was chosen
  639.  *             and then the appropriate color is placed into
  640.  *             lClrForeground.
  641.  *
  642.  *  API's : WinSendMsg
  643.  *
  644.  *  Parameters : sIdItem - Id of the menu item.
  645.  *
  646.  *  Returns: Void
  647.  *
  648.  ****************************************************************/
  649. VOID SetForegroundColor(SHORT sIdMenu)
  650. {
  651.    switch(sIdMenu)
  652.    {
  653.       case IDM_OPTIONSFORECOLORBLACK:
  654.          lClrForeground = CLR_BLACK;
  655.          break;
  656.  
  657.       case IDM_OPTIONSFORECOLORBLUE:
  658.          lClrForeground = CLR_BLUE;
  659.          break;
  660.  
  661.       case IDM_OPTIONSFORECOLORRED:
  662.          lClrForeground = CLR_RED;
  663.          break;
  664.  
  665.       /*
  666.        *  For any others, including IDM_OPTIONSBACKCOLORDEFAULT, set
  667.        *  the background color to the default back color
  668.        */
  669.       default:
  670.          lClrForeground = lClrDefaultForeground;
  671.          break;
  672.    }
  673.    WinSendMsg(hwndMLE, MLM_SETTEXTCOLOR, MPFROMLONG(lClrForeground), NULL);
  674. }   /*   End of SetForegroundColor()                                    */
  675.  
  676. /*********************************************************************
  677.  *  Name: SetBackgroundColor
  678.  *
  679.  *  Description : Allows the user to select a color for the
  680.  *                window Background
  681.  *
  682.  *  Concepts : Routine is called each time the user selects one
  683.  *             of the Background colors listed in the Background
  684.  *             Color submenu of the Options menu.  A switch
  685.  *             statement determines which menu item was chosen
  686.  *             and then the appropriate color is placed into
  687.  *             lClrBackground.
  688.  *
  689.  *  API's : WinSendMsg
  690.  *
  691.  *  Parameters : sIdItem - Id of the menu item.
  692.  *
  693.  *  Returns: Void
  694.  *
  695.  ****************************************************************/
  696. VOID SetBackgroundColor( SHORT idMenu)
  697. {
  698.    switch(idMenu)
  699.    {
  700.       case IDM_OPTIONSBACKCOLORPINK:
  701.          lClrBackground = CLR_PINK;
  702.          break;
  703.  
  704.       case IDM_OPTIONSBACKCOLORCYAN:
  705.          lClrBackground = CLR_CYAN;
  706.          break;
  707.  
  708.       case IDM_OPTIONSBACKCOLORYELLOW:
  709.          lClrBackground = CLR_YELLOW;
  710.          break;
  711.  
  712.       /*
  713.        *  For any others, including IDM_OPTIONSBACKCOLORDEFAULT, set
  714.        *  the background color to the default back color
  715.        */
  716.       default:
  717.          lClrBackground = lClrDefaultBackground;
  718.          break;
  719.    }
  720.    WinSendMsg(hwndMLE, MLM_SETBACKCOLOR, MPFROMLONG(lClrBackground), NULL);
  721. }   /*  End of SetBackgroundColor()                                     */
  722.  
  723.  
  724. /*********************************************************************
  725.  *  Name: SetFont
  726.  *
  727.  *  Description : Allows the user to select a font for the text
  728.  *                displayed in the MLE.
  729.  *
  730.  *  Concepts : Routine is called each time the user selects the
  731.  *             Font menu item from the Options menu.  The
  732.  *             standard font dialog is called with the current
  733.  *             available fonts.  If the user selects one, then
  734.  *             the MLM_SETFONT message is sent to the MLE to
  735.  *             display its text to the font chosen.
  736.  *
  737.  *  API's : WinSendMsg
  738.  *          GpiCreateLogFont
  739.  *          GpiSetCharSet
  740.  *          GpiQueryFontMetrics
  741.  *          GpiDeleteSetId
  742.  *          WinGetPS
  743.  *          WinReleasePS
  744.  *          WinLoadString
  745.  *          WinFontDlg
  746.  *
  747.  *  Parameters :  None
  748.  *
  749.  *  Returns: None
  750.  *
  751.  ****************************************************************/
  752. VOID SetFont(void)
  753. {
  754.    FONTDLG fontDlg;
  755.    HPS hps;
  756.    FONTMETRICS fontMetrics;
  757.    CHAR szTitle[MESSAGELEN];
  758.    CHAR szFamily[CCHMAXPATH];
  759.    static fxPointSize = 0;            /* keep track of this for vector fonts */
  760.  
  761.    memset(&fontDlg, 0, sizeof(fontDlg));            /* initialize all fields */
  762.    /*
  763.     * Get the current font attributes
  764.     */
  765.    hps = WinGetPS(hwndMLE);
  766.    WinSendMsg(hwndMLE, MLM_QUERYFONT,
  767.       MPFROMP((PFATTRS)&(fontDlg.fAttrs)), NULL);
  768.  
  769.    /* create system default font */
  770.  
  771.    GpiCreateLogFont(
  772.       hps,
  773.       (PSTR8)fontDlg.fAttrs.szFacename,
  774.       1,
  775.       &(fontDlg.fAttrs));
  776.  
  777.    GpiSetCharSet(hps, 1);
  778.  
  779.    GpiQueryFontMetrics(hps, sizeof(FONTMETRICS), &fontMetrics);
  780.  
  781.    GpiSetCharSet(hps, LCID_DEFAULT);
  782.    GpiDeleteSetId(hps, 1);
  783.    WinReleasePS(hps);
  784.  
  785.    /*
  786.     * Initialize the FONTDLG structure with the current font
  787.     */
  788.    fontDlg.cbSize     = sizeof(FONTDLG);                  /* sizeof(FONTDLG) */
  789.    fontDlg.hpsScreen  = WinGetScreenPS(HWND_DESKTOP);  /* Screen presentation space */
  790.    fontDlg.hpsPrinter = NULLHANDLE;            /* Printer presentation space */
  791.  
  792.    if(!WinLoadString(hab, (HMODULE)0, IDS_FONTDLGTITLE, MESSAGELEN, szTitle))
  793.    {
  794.       MessageBox(hwndMain, IDMSG_CANNOTLOADSTRING, MB_OK | MB_ERROR, TRUE);
  795.       return;
  796.    }
  797.  
  798.    fontDlg.pszTitle      = szTitle;       /* Application supplied title      */
  799.    fontDlg.pszPreview    = NULL;          /* String to print in preview wndw */
  800.    fontDlg.pszPtSizeList = NULL;          /* Application provided size list  */
  801.    fontDlg.pfnDlgProc    = NULL;          /* Dialog subclass procedure       */
  802.    strcpy(szFamily, fontMetrics.szFamilyname); /* Family name of font        */
  803.    fontDlg.pszFamilyname = szFamily;      /* point to Family name of font    */
  804.    fontDlg.fxPointSize = fxPointSize;     /* Point size the user selected    */
  805.    fontDlg.fl           = FNTS_CENTER |   /* FNTS_* flags - dialog styles    */
  806.                            FNTS_INITFROMFATTRS;
  807.    fontDlg.flFlags      = 0;              /* FNTF_* state flags              */
  808.                                           /* Font type option bits           */
  809.    fontDlg.flType       = (LONG) fontMetrics.fsType;
  810.    fontDlg.flTypeMask   = 0;              /* Mask of which font types to use */
  811.    fontDlg.flStyle      = 0;              /* The selected style bits         */
  812.    fontDlg.flStyleMask  = 0;              /* Mask of which style bits to use */
  813.    fontDlg.clrFore      = lClrForeground; /* Selected foreground color       */
  814.    fontDlg.clrBack      = lClrBackground; /* Selected background color       */
  815.    fontDlg.ulUser       = 0;              /* Blank field for application     */
  816.    fontDlg.lReturn      = 0;              /* Return Value of the Dialog      */
  817.    fontDlg.lSRC;                          /* System return code.             */
  818.    fontDlg.lEmHeight    = 0;              /* Em height of the current font   */
  819.    fontDlg.lXHeight     = 0;              /* X height of the current font    */
  820.    fontDlg.lExternalLeading = 0;          /* External Leading of font        */
  821.    fontDlg.hMod;                          /* Module to load custom template  */
  822.                                           /* Nominal Point Size of font      */
  823.    fontDlg.sNominalPointSize = fontMetrics.sNominalPointSize;
  824.    fontDlg.usWeight = fontMetrics.usWeightClass; /* The boldness of the font */
  825.    fontDlg.usWidth = fontMetrics.usWidthClass;  /* The width of the font     */
  826.    fontDlg.x            = 0;              /* X coordinate of the dialog      */
  827.    fontDlg.y            = 0;              /* Y coordinate of the dialog      */
  828.    fontDlg.usDlgId      = IDD_FONT;       /* ID of a custom dialog template  */
  829.    fontDlg.usFamilyBufLen = sizeof(szFamily); /*Length of family name buffer */
  830.    fontDlg.fAttrs;                        /* Font attribute structure        */
  831.  
  832.    /*
  833.     *   Bring up the standard Font Dialog
  834.     */
  835.  
  836.    if(WinFontDlg(HWND_DESKTOP, hwndMLE, &fontDlg) != DID_OK)
  837.    {
  838.       WinReleasePS(fontDlg.hpsScreen);
  839.       return;
  840.    }
  841.    fxPointSize = fontDlg.fxPointSize;     /* save point size for next dialog */
  842.  
  843.    /*
  844.     *   If outline font, calculate the maxbaselineext and
  845.     *   avecharwidth for the point size selected
  846.     */
  847.  
  848.    if ( fontDlg.fAttrs.fsFontUse == FATTR_FONTUSE_OUTLINE )
  849.    {
  850.       ConvertVectorFontSize(fontDlg.fxPointSize, &fontDlg.fAttrs);
  851.    }
  852.  
  853.    WinReleasePS(fontDlg.hpsScreen);
  854.    WinSendMsg(hwndMLE, MLM_SETFONT, MPFROMP(&(fontDlg.fAttrs)), NULL);
  855.  
  856. }   /* End of SetFont()                                                 */
  857.  
  858. /*
  859.  *   Convert vector font size using point size and fAttrs structure and
  860.  *   return it in that structure.
  861.  */
  862.  
  863. VOID ConvertVectorFontSize(FIXED fxPointSize, PFATTRS pfattrs)
  864. {
  865.   HPS   hps;
  866.   HDC   hDC;
  867.   LONG  lxFontResolution;
  868.   LONG  lyFontResolution;
  869.   SIZEF sizef;
  870.  
  871.   hps = WinGetScreenPS(HWND_DESKTOP);        /* Screen presentation space */
  872.  
  873.   /*
  874.    *   Query device context for the screen and then query
  875.    *   the resolution of the device for the device context.
  876.    */
  877.  
  878.   hDC = GpiQueryDevice(hps);
  879.   DevQueryCaps( hDC, CAPS_HORIZONTAL_FONT_RES, (LONG)1, &lxFontResolution);
  880.   DevQueryCaps( hDC, CAPS_VERTICAL_FONT_RES, (LONG)1, &lyFontResolution);
  881.  
  882.   /*
  883.    *   Calculate the size of the character box, based on the
  884.    *   point size selected and the resolution of the device.
  885.    *   The size parameters are of type FIXED, NOT int.
  886.    *   NOTE: 1 point == 1/72 of an inch.
  887.    */
  888.  
  889.   sizef.cx = (FIXED)(((fxPointSize) / 72 ) * lxFontResolution );
  890.   sizef.cy = (FIXED)(((fxPointSize) / 72 ) * lyFontResolution );
  891.  
  892.   pfattrs->lMaxBaselineExt = MAKELONG( HIUSHORT( sizef.cy ), 0 );
  893.   pfattrs->lAveCharWidth   = MAKELONG( HIUSHORT( sizef.cx ), 0 );
  894.   WinReleasePS(hps);
  895.  
  896. }   /* end ConvertVectorPointSize() */
  897.