home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / wpentk.zip / WBPENTK2.DSK / HWXPROCS.C < prev    next >
C/C++ Source or Header  |  1994-10-06  |  75KB  |  1,769 lines
  1. /*****************************************************************************
  2. *                                                                            *
  3. *  File Name   : HWXPROCS.C                                                  *
  4. *                                                                            *
  5. *  Description : Window Procedures for the HWX_SAMP.EXE                      *
  6. *                                                                            *
  7. *  Function:  This file has all the window procedures for the HWX_SAMP.EXE   *
  8. *                                                                            *
  9. *  Copyright (C) 1993 IBM Corporation                                        *
  10. *                                                                            *
  11. *      DISCLAIMER OF WARRANTIES.  The following [enclosed] code is           *
  12. *      sample code created by IBM Corporation. This sample code is not       *
  13. *      part of any standard or IBM product and is provided to you solely     *
  14. *      for  the purpose of assisting you in the development of your          *
  15. *      applications.  The code is provided "AS IS", without                  *
  16. *      warranty of any kind.  IBM shall not be liable for any damages        *
  17. *      arising out of your use of the sample code, even if they have been    *
  18. *      advised of the possibility of such damages.                           *
  19. *                                                                            *
  20. *****************************************************************************/
  21.  
  22. /*****************************************************************************
  23. * DEFINES                                                                    *
  24. *****************************************************************************/
  25. #define INCL_PM
  26.  
  27. /*****************************************************************************
  28. * INCLUDES                                                                   *
  29. *****************************************************************************/
  30. #include <os2.h>
  31. #include <penpm.h>
  32. #include "hwx_samp.h"
  33.  
  34. /*****************************************************************************
  35. * DEBUG MESSAGES                                                             *
  36. *****************************************************************************/
  37. VOID DebugMessage ( char dmessage[50] )
  38.    {
  39.    WinMessageBox ( HWND_DESKTOP,
  40.                    HWND_DESKTOP,
  41.                    dmessage,
  42.                    "Debug Message",
  43.                    0,
  44.                    MB_OK            |
  45.                    MB_ERROR         |
  46.                    MB_SYSTEMMODAL   |
  47.                    MB_MOVEABLE );
  48.    }
  49.  
  50. /*****************************************************************************
  51. * Update the status window                                                   *
  52. *****************************************************************************/
  53. VOID StatusLine ( HWND hWnd, CHAR *StatusText )
  54.    {
  55.    int   x;
  56.    CHAR  *tempchar;
  57.    PMYWINDOWDATA pMyWindowData;
  58.  
  59.    pMyWindowData = (PMYWINDOWDATA) WinQueryWindowULong ( hWnd, 0 );
  60.  
  61.    x = strlen ( StatusText );
  62.  
  63.    for ( x; x>=0; x-- )
  64.       {
  65.       tempchar = &StatusText[x];
  66.       WinSetWindowText ( pMyWindowData->StatusWindow, tempchar );
  67.       };
  68.    return;
  69.    }
  70.  
  71. /*****************************************************************************
  72. * COMMON WINDOWPROC MESSAGE HANDLING                                         *
  73. *                                                                            *
  74. * All of the window procedures will call this module if they do not handle   *
  75. * any given message. This routine will in turn call the default window       *
  76. * procedure ( WinDefWindowProc ) if the message isn't handled here.          *
  77. *****************************************************************************/
  78. MRESULT EXPENTRY HWXCOMMON ( HWND hWnd,
  79.                              ULONG ulMsg,
  80.                              MPARAM mp1,
  81.                              MPARAM mp2 )
  82.    {
  83.    RECTL          rcl;
  84.    HPS            hps;
  85.    HWND           hFrame;
  86.    PMYWINDOWDATA  pMyWindowData;
  87.  
  88.    switch ( ulMsg )
  89.       {
  90.       case  WM_INITMYWINDOW:
  91.                DosAllocMem ( (VOID *) &pMyWindowData,
  92.                              sizeof(MYWINDOWDATA),
  93.                              PAG_COMMIT   |
  94.                                  PAG_READ |
  95.                                  PAG_WRITE );
  96.                WinSetWindowULong ( hWnd, 0, (ULONG) pMyWindowData );
  97.                pMyWindowData->StatusWindow = (HWND) mp1;
  98.                pMyWindowData->prevent = FALSE;
  99.                return ( (MRESULT) TRUE );
  100.                break;
  101.  
  102.       case  WM_CLOSE:
  103.                StatusLine ( hWnd, "" );
  104.                hFrame = WinQueryWindow ( hWnd, QW_PARENT );
  105.                WinDestroyWindow ( hFrame );
  106.                return ( (MRESULT) 0 );
  107.                break;
  108.  
  109.       case  WM_SETFOCUS:
  110.                pMyWindowData = (PMYWINDOWDATA) WinQueryWindowPtr ( hWnd, 0 );
  111.                if ( pMyWindowData != NULL )
  112.                   StatusLine ( hWnd, "" );
  113.                break;
  114.  
  115.       case  WM_COMMAND:
  116.                switch ( LONGFROMMP(mp1) )
  117.                   {
  118.                   case  ID_QUIT:
  119.                         WinPostMsg ( hWnd, WM_CLOSE, 0, 0 );
  120.                         return ( (MRESULT) TRUE );
  121.                         break;
  122.  
  123.                   case  ID_CLEAR:
  124.                         WinSetWindowText ( WinQueryFocus ( HWND_DESKTOP ), " " );
  125.                         return ( (MRESULT) TRUE );
  126.                         break;
  127.  
  128.                   default:
  129.                         break;
  130.                   }
  131.                break;
  132.  
  133.  
  134.       case  WM_PAINT:
  135.                hps = WinBeginPaint  ( hWnd, NULLHANDLE, (PRECTL)NULL );
  136.                WinQueryWindowRect   ( hWnd, &rcl );
  137.                WinFillRect          ( hps,  &rcl, SYSCLR_MENU );
  138.                WinEndPaint          ( hps );
  139.                return ( (MRESULT) TRUE );
  140.                break;
  141.  
  142.       case  WM_SIZE:
  143.                WinQueryWindowRect ( hWnd, &rcl );
  144.                WinSetWindowPos  ( WinWindowFromID ( hWnd, ID_HWX_CONTROL1 ),
  145.                                   HWND_TOP,
  146.                                   2,
  147.                                   2,
  148.                                   rcl.xRight-4,
  149.                                   rcl.yTop-4,
  150.                                   SWP_ACTIVATE |
  151.                                     SWP_MOVE   |
  152.                                     SWP_SIZE   |
  153.                                     SWP_SHOW );
  154.                return ( (MRESULT) TRUE );
  155.                break;
  156.  
  157.       default:
  158.             break;
  159.       }
  160.    return( (MRESULT) WinDefWindowProc ( hWnd, ulMsg, mp1, mp2 )  );
  161.    }
  162.  
  163. /******************************************************************************
  164. * HX_BORDER                                                                   *
  165. *                                                                             *
  166. * Create a control with a solid black border.                                 *
  167. ******************************************************************************/
  168. MRESULT EXPENTRY HWX_HX_BORDER ( HWND   hWnd,
  169.                                  ULONG  ulMsg,
  170.                                  MPARAM mp1,
  171.                                  MPARAM mp2)
  172.    {
  173.    HWND     hHwxControl;
  174.    RECTL    rcl;
  175.  
  176.    switch ( ulMsg )
  177.       {
  178.       case  WM_CREATE:
  179.                WinPostMsg ( hWnd,
  180.                             WM_CREATEHWXCONTROL,
  181.                             (MPARAM) 0,
  182.                             (MPARAM) 0 );
  183.                WinShowWindow ( hWnd, TRUE );
  184.                break;
  185.  
  186.       case  WM_CREATEHWXCONTROL:
  187.                WinQueryWindowRect ( hWnd, &rcl );
  188.                hHwxControl =  WinCreateWindow ( hWnd,
  189.                                                 WC_HWXENTRY,
  190.                                                 "",
  191.                                                 HX_BORDER |
  192.                                                 WS_VISIBLE,
  193.                                                 2,
  194.                                                 2,
  195.                                                 rcl.xRight-4,
  196.                                                 rcl.yTop-4,
  197.                                                 hWnd,
  198.                                                 HWND_BOTTOM,
  199.                                                 ID_HWX_CONTROL1,
  200.                                                 NULL,
  201.                                                 NULL );
  202.                if ( !hHwxControl )
  203.                   {
  204.                   DebugMessage ( "Control creation failed" );
  205.                   return( (MRESULT) FALSE );
  206.                   };
  207.                return ( (MRESULT) TRUE );
  208.                break;
  209.  
  210.       default:
  211.                break;
  212.       }
  213.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  214.    }
  215.  
  216. /******************************************************************************
  217. * HX_3DBORDER                                                                 *
  218. *                                                                             *
  219. * Create a control with a 3D type of border.                                  *
  220. ******************************************************************************/
  221. MRESULT EXPENTRY HWX_HX_3DBORDER ( HWND   hWnd,
  222.                                    ULONG  ulMsg,
  223.                                    MPARAM mp1,
  224.                                    MPARAM mp2)
  225.    {
  226.    HWND     hHwxControl;
  227.    RECTL    rcl;
  228.  
  229.    switch ( ulMsg )
  230.       {
  231.       case  WM_CREATE:
  232.                WinPostMsg ( hWnd,
  233.                             WM_CREATEHWXCONTROL,
  234.                             (MPARAM) 0,
  235.                             (MPARAM) 0 );
  236.                WinShowWindow ( hWnd, TRUE );
  237.                break;
  238.  
  239.       case  WM_CREATEHWXCONTROL:
  240.                WinQueryWindowRect ( hWnd, &rcl );
  241.                hHwxControl =  WinCreateWindow ( hWnd,
  242.                                                 WC_HWXENTRY,
  243.                                                 "",
  244.                                                 HX_3DBORDER |
  245.                                                 WS_VISIBLE,
  246.                                                 2,
  247.                                                 2,
  248.                                                 rcl.xRight-4,
  249.                                                 rcl.yTop-4,
  250.                                                 hWnd,
  251.                                                 HWND_BOTTOM,
  252.                                                 ID_HWX_CONTROL1,
  253.                                                 NULL,
  254.                                                 NULL );
  255.                if ( !hHwxControl )
  256.                   {
  257.                   DebugMessage ( "Control creation failed" );
  258.                   return( (MRESULT) FALSE );
  259.                   };
  260.                return ( (MRESULT) TRUE );
  261.                break;
  262.  
  263.       default:
  264.                break;
  265.       }
  266.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  267.    }
  268.  
  269. /******************************************************************************
  270. * WS_VISIBLE                                                                  *
  271. *                                                                             *
  272. * Create a visible control.                                                   *
  273. ******************************************************************************/
  274. MRESULT EXPENTRY HWX_WS_VISIBLE ( HWND   hWnd,
  275.                                   ULONG  ulMsg,
  276.                                   MPARAM mp1,
  277.                                   MPARAM mp2)
  278.    {
  279.    HWND     hHwxControl;
  280.    RECTL    rcl;
  281.  
  282.    switch ( ulMsg )
  283.       {
  284.       case  WM_CREATE:
  285.                WinPostMsg ( hWnd,
  286.                             WM_CREATEHWXCONTROL,
  287.                             (MPARAM) 0,
  288.                             (MPARAM) 0 );
  289.                WinShowWindow ( hWnd, TRUE );
  290.                break;
  291.  
  292.       case  WM_CREATEHWXCONTROL:
  293.                WinQueryWindowRect ( hWnd, &rcl );
  294.                hHwxControl =  WinCreateWindow ( hWnd,
  295.                                                 WC_HWXENTRY,
  296.                                                 "",
  297.                                                 WS_VISIBLE,
  298.                                                 2,
  299.                                                 2,
  300.                                                 rcl.xRight-4,
  301.                                                 rcl.yTop-4,
  302.                                                 hWnd,
  303.                                                 HWND_BOTTOM,
  304.                                                 ID_HWX_CONTROL1,
  305.                                                 NULL,
  306.                                                 NULL );
  307.                if ( !hHwxControl )
  308.                   {
  309.                   DebugMessage ( "Control creation failed" );
  310.                   return( (MRESULT) FALSE );
  311.                   };
  312.                return ( (MRESULT) TRUE );
  313.                break;
  314.  
  315.       default:
  316.                break;
  317.       }
  318.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  319.    }
  320.  
  321. /******************************************************************************
  322. * WS_DISABLED                                                                 *
  323. *                                                                             *
  324. * Create a disabled control.                                                  *
  325. ******************************************************************************/
  326. MRESULT EXPENTRY HWX_WS_DISABLED ( HWND   hWnd,
  327.                                    ULONG  ulMsg,
  328.                                    MPARAM mp1,
  329.                                    MPARAM mp2)
  330.    {
  331.    HWND     hHwxControl;
  332.    RECTL    rcl;
  333.  
  334.    switch ( ulMsg )
  335.       {
  336.       case  WM_CREATE:
  337.                WinPostMsg ( hWnd,
  338.                             WM_CREATEHWXCONTROL,
  339.                             (MPARAM) 0,
  340.                             (MPARAM) 0 );
  341.                WinShowWindow ( hWnd, TRUE );
  342.                break;
  343.  
  344.       case  WM_CREATEHWXCONTROL:
  345.                WinQueryWindowRect ( hWnd, &rcl );
  346.                hHwxControl =  WinCreateWindow ( hWnd,
  347.                                                 WC_HWXENTRY,
  348.                                                 "",
  349.                                                 WS_DISABLED |
  350.                                                 WS_VISIBLE,
  351.                                                 2,
  352.                                                 2,
  353.                                                 rcl.xRight-4,
  354.                                                 rcl.yTop-4,
  355.                                                 hWnd,
  356.                                                 HWND_BOTTOM,
  357.                                                 ID_HWX_CONTROL1,
  358.                                                 NULL,
  359.                                                 NULL );
  360.                if ( !hHwxControl )
  361.                   {
  362.                   DebugMessage ( "Control creation failed" );
  363.                   return( (MRESULT) FALSE );
  364.                   };
  365.                return ( (MRESULT) TRUE );
  366.                break;
  367.  
  368.       case  WM_TAP:
  369.                WinEnableWindow ( WinWindowFromID ( hWnd, ID_HWX_CONTROL1 ), TRUE );
  370.                break;
  371.  
  372.       default:
  373.                break;
  374.       }
  375.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  376.    }
  377.  
  378. /******************************************************************************
  379. * HX_3DBORDER | HX_BORDER                                                     *
  380. *                                                                             *
  381. * The default action when both border styles are specified is to use the      *
  382. * HX_BORDER style.                                                            *
  383. ******************************************************************************/
  384. MRESULT EXPENTRY HWX_HX_3DBORDER_AND_BORDER ( HWND   hWnd,
  385.                                               ULONG  ulMsg,
  386.                                               MPARAM mp1,
  387.                                               MPARAM mp2)
  388.    {
  389.    HWND     hHwxControl;
  390.    RECTL    rcl;
  391.  
  392.    switch ( ulMsg )
  393.       {
  394.       case  WM_CREATE:
  395.                WinPostMsg ( hWnd,
  396.                             WM_CREATEHWXCONTROL,
  397.                             (MPARAM) 0,
  398.                             (MPARAM) 0 );
  399.                WinShowWindow ( hWnd, TRUE );
  400.                break;
  401.  
  402.       case  WM_CREATEHWXCONTROL:
  403.                WinQueryWindowRect ( hWnd, &rcl );
  404.                hHwxControl =  WinCreateWindow ( hWnd,
  405.                                                 WC_HWXENTRY,
  406.                                                 "",
  407.                                                 HX_3DBORDER |
  408.                                                 HX_BORDER |
  409.                                                 WS_VISIBLE,
  410.                                                 2,
  411.                                                 2,
  412.                                                 rcl.xRight-4,
  413.                                                 rcl.yTop-4,
  414.                                                 hWnd,
  415.                                                 HWND_BOTTOM,
  416.                                                 ID_HWX_CONTROL1,
  417.                                                 NULL,
  418.                                                 NULL );
  419.                if ( !hHwxControl )
  420.                   {
  421.                   DebugMessage ( "Control creation failed" );
  422.                   return( (MRESULT) FALSE );
  423.                   };
  424.                return ( (MRESULT) TRUE );
  425.                break;
  426.  
  427.       default:
  428.                break;
  429.       }
  430.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  431.    }
  432.  
  433.  
  434. /******************************************************************************
  435. * SIZING OF A CONTROL TO A SPECIFIC NUMBER OF ROWS AND COLUMNS. In this case  *
  436. * we will create a control with a 3d border and 2 rows of 5 columns. The      *
  437. * control uses the PPMSV_CHARACTER_BOX_DX and PPMSV_CHARACTER_BOX_DY system   *
  438. * values to size the control within the window.                               *
  439. *                                                                             *
  440. *     rows      = 2                                                           *
  441. *     columns   = 5                                                           *
  442. *     charboxdx = WrtQuerySysValue ( HWND_DESKTOP, PPMSV_CHARACTER_BOX_DX )   *
  443. *     charboxdy = WrtQuerySysValue ( HWND_DESKTOP, PPMSV_CHARACTER_BOX_DY )   *
  444. *     baseline  = charboxdy / 3                                               *
  445. *     controlcx = (columns * charboxdx ) + (charboxdx / 2)                    *
  446. *     controlcy = (rows    * ( charboxdy + baseline ) ) + baseline            *
  447. ******************************************************************************/
  448. MRESULT EXPENTRY HWX_SIZING ( HWND   hWnd,
  449.                               ULONG  ulMsg,
  450.                               MPARAM mp1,
  451.                               MPARAM mp2)
  452.    {
  453.    HWND            hHwxControl;
  454.    RECTL           rcl;
  455.    SHORT    CharBoxDX;
  456.    SHORT    CharBoxDY;
  457.    SHORT    Rows;
  458.    SHORT    Columns;
  459.    SHORT    BaseLineDY;
  460.    static ULONG    ControlDX;
  461.    static ULONG    ControlDY;
  462.    SHORT    BorderCX;
  463.    SHORT    BorderCY;
  464.    CHAR     debugvalue[50];
  465.  
  466.    switch ( ulMsg )
  467.       {
  468.       case  WM_CREATE:
  469.                WinPostMsg ( hWnd,
  470.                             WM_CREATEHWXCONTROL,
  471.                             (MPARAM) 0,
  472.                             (MPARAM) 0 );
  473.                WinShowWindow ( hWnd, TRUE );
  474.                break;
  475.  
  476.       case  WM_CREATEHWXCONTROL:
  477.  
  478.                BorderCX = WinQuerySysValue ( HWND_DESKTOP, SV_CXBORDER );
  479.                BorderCY = WinQuerySysValue ( HWND_DESKTOP, SV_CYBORDER );
  480.  
  481.                CharBoxDX  = WrtQuerySysValue ( HWND_DESKTOP, PPMSV_CHARACTER_BOX_DX );
  482.                CharBoxDY  = WrtQuerySysValue ( HWND_DESKTOP, PPMSV_CHARACTER_BOX_DY );
  483.                Rows       = 2;
  484.                Columns    = 5;
  485.                BaseLineDY = CharBoxDY / 3;
  486.                ControlDX  = ( ( Columns * CharBoxDX ) + ( CharBoxDX / 2 ) + ( 2 * BorderCX ) ) ;
  487.                ControlDY  = ( ( Rows * ( CharBoxDY + BaseLineDY ) ) + BaseLineDY + ( 2 * BorderCY ) );
  488.                WinQueryWindowRect ( hWnd, &rcl );
  489.                hHwxControl =  WinCreateWindow ( hWnd,
  490.                                                 WC_HWXENTRY,
  491.                                                 "",
  492.                                                 HX_3DBORDER |
  493.                                                    WS_VISIBLE,
  494.                                                 (rcl.xRight - ControlDX ) / 2,
  495.                                                 (rcl.yTop   - ControlDY ) / 2,
  496.                                                 ControlDX,
  497.                                                 ControlDY,
  498.                                                 hWnd,
  499.                                                 HWND_BOTTOM,
  500.                                                 ID_HWX_CONTROL1,
  501.                                                 NULL,
  502.                                                 NULL );
  503.                if ( !hHwxControl )
  504.                   {
  505.                   sprintf ( debugvalue, "x=%d, y=%d, dx=%d, dy=%d", (rcl.xRight - ControlDX ) / 2,
  506.                                                 (rcl.yTop   - ControlDY ) / 2,
  507.                                                 ControlDX,
  508.                                                 ControlDY );
  509.  
  510.                   DebugMessage ( debugvalue );
  511.                   return( (MRESULT) FALSE );
  512.                   };
  513.                return ( (MRESULT) TRUE );
  514.                break;
  515.  
  516.       case  WM_SIZE:
  517.                WinQueryWindowRect ( hWnd, &rcl );
  518.                WinSetWindowPos  ( WinWindowFromID ( hWnd, ID_HWX_CONTROL1 ),
  519.                                   HWND_TOP,
  520.                                   (rcl.xRight - ControlDX ) / 2,
  521.                                   (rcl.yTop   - ControlDY ) / 2,
  522.                                   ControlDX,
  523.                                   ControlDY,
  524.                                   SWP_ACTIVATE |
  525.                                     SWP_MOVE   |
  526.                                     SWP_SIZE   |
  527.                                     SWP_SHOW );
  528.                return ( (MRESULT) TRUE );
  529.                break;
  530.  
  531.       default:
  532.                break;
  533.       }
  534.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  535.    }
  536.  
  537. /******************************************************************************
  538. * STRINGS: LOADING OF STRINGS AT CREATION TIME                                *
  539. *                                                                             *
  540. * This example shows how to initialize the control with text at window        *
  541. * creation time.                                                              *
  542. ******************************************************************************/
  543. MRESULT EXPENTRY HWX_INITIAL_TEXT ( HWND   hWnd,
  544.                                     ULONG  ulMsg,
  545.                                     MPARAM mp1,
  546.                                     MPARAM mp2)
  547.    {
  548.    HWND     hHwxControl;
  549.    RECTL    rcl;
  550.  
  551.    switch ( ulMsg )
  552.       {
  553.       case  WM_CREATE:
  554.                WinPostMsg ( hWnd,
  555.                             WM_CREATEHWXCONTROL,
  556.                             (MPARAM) 0,
  557.                             (MPARAM) 0 );
  558.                WinShowWindow ( hWnd, TRUE );
  559.                break;
  560.  
  561.       case  WM_CREATEHWXCONTROL:
  562.                WinQueryWindowRect ( hWnd, &rcl );
  563.                hHwxControl =  WinCreateWindow ( hWnd,
  564.                                                 WC_HWXENTRY,
  565.                                                 "TEST OF LOADING A STRING",
  566.                                                 HX_3DBORDER |
  567.                                                    WS_VISIBLE,
  568.                                                 2,
  569.                                                 2,
  570.                                                 rcl.xRight-4,
  571.                                                 rcl.yTop-4,
  572.                                                 hWnd,
  573.                                                 HWND_BOTTOM,
  574.                                                 ID_HWX_CONTROL1,
  575.                                                 NULL,
  576.                                                 NULL );
  577.                if ( !hHwxControl )
  578.                   {
  579.                   DebugMessage ( "Control creation failed" );
  580.                   return( (MRESULT) FALSE );
  581.                   };
  582.                return ( (MRESULT) TRUE );
  583.                break;
  584.  
  585.       default:
  586.                break;
  587.       }
  588.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  589.    }
  590.  
  591. /******************************************************************************
  592. * NOTIFICATION MESSAGES: HXN_OVERFLOW                                         *
  593. *                                                                             *
  594. * This notification message is sent to the owner of the control to indicate   *
  595. * that the contents of the control have been truncated. This only happens     *
  596. * when the control's content is longer than 1024 characters.                  *
  597. ******************************************************************************/
  598. MRESULT EXPENTRY HWX_HXN_OVERFLOW ( HWND   hWnd,
  599.                                     ULONG  ulMsg,
  600.                                     MPARAM mp1,
  601.                                     MPARAM mp2)
  602.    {
  603.    HWND     hHwxControl;
  604.    RECTL    rcl;
  605.    int      i;
  606.    char     teststring[1050];
  607.  
  608.    switch ( ulMsg )
  609.       {
  610.       case  WM_CREATE:
  611.                WinPostMsg ( hWnd,
  612.                             WM_CREATEHWXCONTROL,
  613.                             (MPARAM) 0,
  614.                             (MPARAM) 0 );
  615.                WinShowWindow ( hWnd, TRUE );
  616.                break;
  617.  
  618.       case  WM_CREATEHWXCONTROL:
  619.                WinQueryWindowRect ( hWnd, &rcl );
  620.                for ( i=0; i<1050; i++ )
  621.                   {
  622.                   teststring[i] = 'a';
  623.                   };
  624.                teststring[1050] = '\0';
  625.                hHwxControl =  WinCreateWindow ( hWnd,
  626.                                                 WC_HWXENTRY,
  627.                                                 teststring,
  628.                                                 HX_3DBORDER |
  629.                                                    WS_VISIBLE,
  630.                                                 2,
  631.                                                 2,
  632.                                                 rcl.xRight-4,
  633.                                                 rcl.yTop-4,
  634.                                                 hWnd,
  635.                                                 HWND_BOTTOM,
  636.                                                 ID_HWX_CONTROL1,
  637.                                                 NULL,
  638.                                                 NULL );
  639.                if ( !hHwxControl )
  640.                   {
  641.                   DebugMessage ( "Control creation failed" );
  642.                   return( (MRESULT) FALSE );
  643.                   };
  644.                return ( (MRESULT) TRUE );
  645.                break;
  646.  
  647.       case  WM_CONTROL:
  648.                switch ( SHORT2FROMMP(mp1) )
  649.                   {
  650.                   case  HXN_OVERFLOW:
  651.                         StatusLine ( hWnd, "Handwriting Control Overflow" );
  652.                         break;
  653.  
  654.                   default:
  655.                         break;
  656.                   };
  657.                break;
  658.  
  659.       default:
  660.                break;
  661.       }
  662.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  663.    }
  664.  
  665. /******************************************************************************
  666. * NOTIFICATION MESSAGES: HXN_SETFOCUS                                         *
  667. *                                                                             *
  668. * When the control gets focus, this notification message is sent to the       *
  669. * owner of the control.                                                       *
  670. ******************************************************************************/
  671. MRESULT EXPENTRY HWX_HXN_SETFOCUS ( HWND   hWnd,
  672.                                     ULONG  ulMsg,
  673.                                     MPARAM mp1,
  674.                                     MPARAM mp2)
  675.    {
  676.    HWND     hHwxControl;
  677.    RECTL    rcl;
  678.  
  679.    switch ( ulMsg )
  680.       {
  681.       case  WM_CREATE:
  682.                WinPostMsg ( hWnd,
  683.                             WM_CREATEHWXCONTROL,
  684.                             (MPARAM) 0,
  685.                             (MPARAM) 0 );
  686.                WinShowWindow ( hWnd, TRUE );
  687.                break;
  688.  
  689.       case  WM_CREATEHWXCONTROL:
  690.                WinQueryWindowRect ( hWnd, &rcl );
  691.                hHwxControl =  WinCreateWindow ( hWnd,
  692.                                                 WC_HWXENTRY,
  693.                                                 "",
  694.                                                 HX_3DBORDER |
  695.                                                    WS_VISIBLE,
  696.                                                 2,
  697.                                                 2,
  698.                                                 rcl.xRight-4,
  699.                                                 rcl.yTop-4,
  700.                                                 hWnd,
  701.                                                 HWND_BOTTOM,
  702.                                                 ID_HWX_CONTROL1,
  703.                                                 NULL,
  704.                                                 NULL );
  705.                if ( !hHwxControl )
  706.                   {
  707.                   DebugMessage ( "Control creation failed" );
  708.                   return( (MRESULT) FALSE );
  709.                   };
  710.                return ( (MRESULT) TRUE );
  711.                break;
  712.  
  713.       case  WM_CONTROL:
  714.                switch ( SHORT2FROMMP(mp1) )
  715.                   {
  716.                   case  HXN_SETFOCUS:
  717.                         StatusLine ( hWnd, "Setting Focus" );
  718.                         WinSetWindowText ( WinWindowFromID ( hWnd, ID_HWX_CONTROL1 ),
  719.                                            "Hello" );
  720.                         return ( (MRESULT) 0 );
  721.                         break;
  722.  
  723.                   default:
  724.                         break;
  725.                   };
  726.                break;
  727.  
  728.       default:
  729.                break;
  730.       }
  731.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  732.    }
  733.  
  734. /******************************************************************************
  735. * NOTIFICATION MESSAGES: HXN_KILLFOCUS                                        *
  736. *                                                                             *
  737. * This message is sent to the owner of the control whenever the control gives *
  738. * up focus.                                                                   *
  739. ******************************************************************************/
  740. MRESULT EXPENTRY HWX_HXN_KILLFOCUS ( HWND   hWnd,
  741.                                      ULONG  ulMsg,
  742.                                      MPARAM mp1,
  743.                                      MPARAM mp2)
  744.    {
  745.    HWND     hHwxControl;
  746.    RECTL    rcl;
  747.  
  748.    switch ( ulMsg )
  749.       {
  750.       case  WM_CREATE:
  751.                WinPostMsg ( hWnd,
  752.                             WM_CREATEHWXCONTROL,
  753.                             (MPARAM) 0,
  754.                             (MPARAM) 0 );
  755.                WinShowWindow ( hWnd, TRUE );
  756.                break;
  757.  
  758.       case  WM_CREATEHWXCONTROL:
  759.                WinQueryWindowRect ( hWnd, &rcl );
  760.                hHwxControl =  WinCreateWindow ( hWnd,
  761.                                                 WC_HWXENTRY,
  762.                                                 "",
  763.                                                 HX_3DBORDER |
  764.                                                    WS_VISIBLE,
  765.                                                 2,
  766.                                                 2,
  767.                                                 rcl.xRight-4,
  768.                                                 rcl.yTop-4,
  769.                                                 hWnd,
  770.                                                 HWND_BOTTOM,
  771.                                                 ID_HWX_CONTROL1,
  772.                                                 NULL,
  773.                                                 NULL );
  774.                if ( !hHwxControl )
  775.                   {
  776.                   DebugMessage ( "Control creation failed" );
  777.                   return( (MRESULT) FALSE );
  778.                   };
  779.                return ( (MRESULT) TRUE );
  780.                break;
  781.  
  782.       case  WM_CONTROL:
  783.                switch ( SHORT2FROMMP(mp1) )
  784.                   {
  785.                   case  HXN_KILLFOCUS:
  786.                         StatusLine ( hWnd, "Losing Focus" );
  787.                         WinSetWindowText ( WinWindowFromID ( hWnd, ID_HWX_CONTROL1 ),
  788.                                            "Good Bye" );
  789.                         return ( (MRESULT) 0 );
  790.                         break;
  791.  
  792.                   default:
  793.                         break;
  794.                   };
  795.                break;
  796.  
  797.       default:
  798.                break;
  799.       }
  800.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  801.    }
  802.  
  803. /******************************************************************************
  804. * NOTIFICATION MESSAGES: HXN_CONTENTS_CHANGED                                 *
  805. *                                                                             *
  806. * This notification message is sent to the owner of the control whenever the  *
  807. * contents of the control has changed.                                        *
  808. ******************************************************************************/
  809. MRESULT EXPENTRY HWX_HXN_CONTENTS_CHANGED ( HWND   hWnd,
  810.                                             ULONG  ulMsg,
  811.                                             MPARAM mp1,
  812.                                             MPARAM mp2)
  813.    {
  814.    HWND     hHwxControl;
  815.    RECTL    rcl;
  816.  
  817.    switch ( ulMsg )
  818.       {
  819.       case  WM_CREATE:
  820.                WinPostMsg ( hWnd,
  821.                             WM_CREATEHWXCONTROL,
  822.                             (MPARAM) 0,
  823.                             (MPARAM) 0 );
  824.                WinShowWindow ( hWnd, TRUE );
  825.                break;
  826.  
  827.       case  WM_CREATEHWXCONTROL:
  828.                WinQueryWindowRect ( hWnd, &rcl );
  829.                hHwxControl =  WinCreateWindow ( hWnd,
  830.                                                 WC_HWXENTRY,
  831.                                                 "",
  832.                                                 HX_3DBORDER |
  833.                                                    WS_VISIBLE,
  834.                                                 2,
  835.                                                 2,
  836.                                                 rcl.xRight-4,
  837.                                                 rcl.yTop-4,
  838.                                                 hWnd,
  839.                                                 HWND_BOTTOM,
  840.                                                 ID_HWX_CONTROL1,
  841.                                                 NULL,
  842.                                                 NULL );
  843.                if ( !hHwxControl )
  844.                   {
  845.                   DebugMessage ( "Control creation failed" );
  846.                   return( (MRESULT) FALSE );
  847.                   };
  848.                return ( (MRESULT) TRUE );
  849.                break;
  850.  
  851.       case  WM_CONTROL:
  852.                switch ( SHORT2FROMMP(mp1) )
  853.                   {
  854.                   case  HXN_CONTENTS_CHANGED:
  855.                         StatusLine ( hWnd, "Handwriting Control Contents Changed" );
  856.                         break;
  857.  
  858.                   default:
  859.                         break;
  860.                   };
  861.                break;
  862.  
  863.       default:
  864.                break;
  865.       }
  866.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  867.    }
  868.  
  869. /******************************************************************************
  870. * NOTIFICATION MESSAGES: HXN_STROKE_ADD                                       *
  871. *                                                                             *
  872. * This notificatioom message is sent to inform the owner of the control that  *
  873. * the user has begun to ink into the control and thus the contents of the     *
  874. * control may be about to change.                                             *
  875. ******************************************************************************/
  876. MRESULT EXPENTRY HWX_HXN_STROKE_ADD ( HWND   hWnd,
  877.                                       ULONG  ulMsg,
  878.                                       MPARAM mp1,
  879.                                       MPARAM mp2)
  880.    {
  881.    HWND           hHwxControl;
  882.    RECTL          rcl;
  883.    HWND           hMenu;
  884.    MENUITEM       menuitem;
  885.    PMYWINDOWDATA  pMyWindowData ;
  886.  
  887.    switch ( ulMsg )
  888.       {
  889.       case  WM_CREATE:
  890.                WinPostMsg ( hWnd,
  891.                             WM_CREATEHWXCONTROL,
  892.                             (MPARAM) 0,
  893.                             (MPARAM) 0 );
  894.                WinShowWindow ( hWnd, TRUE );
  895.                break;
  896.  
  897.       case  WM_CREATEHWXCONTROL:
  898.                hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  899.                                          FID_MENU );
  900.                menuitem.iPosition   = MIT_END;
  901.                menuitem.afStyle     = MIS_TEXT;
  902.                menuitem.afAttribute = 0;
  903.                menuitem.id          = ID_MENUITEM;
  904.                menuitem.hItem       = 0;
  905.                menuitem.hwndSubMenu = 0;
  906.  
  907.                WinSendMsg ( hMenu,
  908.                             MM_INSERTITEM,
  909.                             (MPARAM) &menuitem,
  910.                             (MPARAM) "PreventStrokes" );
  911.                WinQueryWindowRect ( hWnd, &rcl );
  912.                hHwxControl =  WinCreateWindow ( hWnd,
  913.                                                 WC_HWXENTRY,
  914.                                                 "",
  915.                                                 HX_3DBORDER |
  916.                                                    WS_VISIBLE,
  917.                                                 2,
  918.                                                 2,
  919.                                                 rcl.xRight-4,
  920.                                                 rcl.yTop-4,
  921.                                                 hWnd,
  922.                                                 HWND_BOTTOM,
  923.                                                 ID_HWX_CONTROL1,
  924.                                                 NULL,
  925.                                                 NULL );
  926.                if ( !hHwxControl )
  927.                   {
  928.                   DebugMessage ( "Control creation failed" );
  929.                   return( (MRESULT) FALSE );
  930.                   };
  931.                return ( (MRESULT) TRUE );
  932.                break;
  933.  
  934.       case  WM_CONTROL:
  935.                switch ( SHORT2FROMMP(mp1) )
  936.                   {
  937.                   case  HXN_STROKE_ADDED:
  938.                         pMyWindowData = (PMYWINDOWDATA) WinQueryWindowPtr ( hWnd, 0 );
  939.                         if ( pMyWindowData->prevent )
  940.                            StatusLine ( hWnd, "Preventing strokes from being added" );
  941.                         else
  942.                            StatusLine ( hWnd, "Permiting strokes to be added" );
  943.                         return ( (MRESULT) pMyWindowData->prevent );
  944.                         break;
  945.  
  946.                   default:
  947.                         break;
  948.                   };
  949.                break;
  950.  
  951.       /***********************************************************************
  952.       * Messages from the menu                                               *
  953.       ***********************************************************************/
  954.       case  WM_COMMAND:
  955.                pMyWindowData = (PMYWINDOWDATA) WinQueryWindowPtr ( hWnd, 0 );
  956.                if ( SHORT1FROMMP (mp1) == ID_MENUITEM )
  957.                   {
  958.                   hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  959.                                             FID_MENU );
  960.                   if ( pMyWindowData->prevent )
  961.                      {
  962.                      pMyWindowData->prevent = FALSE;
  963.                      WinSendMsg ( hMenu,
  964.                                   MM_SETITEMTEXT,
  965.                                   (MPARAM) ID_MENUITEM,
  966.                                   (MPARAM) "PreventStrokes" );
  967.                      }
  968.                   else
  969.                      {
  970.                      pMyWindowData->prevent = TRUE;
  971.                      WinSendMsg ( hMenu,
  972.                                   MM_SETITEMTEXT,
  973.                                   (MPARAM) ID_MENUITEM,
  974.                                   (MPARAM) "PermitStrokes" );
  975.                      };
  976.  
  977.                   };
  978.                break;
  979.  
  980.       default:
  981.                break;
  982.       }
  983.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  984.    }
  985.  
  986. /******************************************************************************
  987. * NOTIFICATION MESSAGES: HXN_GESTURE_PENDING                                  *
  988. *                                                                             *
  989. * This notification message is sent to the owner of the control when the user *
  990. * has stroked a gesture in the control. The result of the gesture             *
  991. * recognition could cause the contents of the control to change.              *
  992. ******************************************************************************/
  993. MRESULT EXPENTRY HWX_HXN_GESTURE_PENDING ( HWND   hWnd,
  994.                                            ULONG  ulMsg,
  995.                                            MPARAM mp1,
  996.                                            MPARAM mp2)
  997.    {
  998.    HWND     hHwxControl;
  999.    RECTL    rcl;
  1000.    HWND     hMenu;
  1001.    MENUITEM menuitem;
  1002.    PMYWINDOWDATA  pMyWindowData ;
  1003.  
  1004.    switch ( ulMsg )
  1005.       {
  1006.       case  WM_CREATE:
  1007.                WinPostMsg ( hWnd,
  1008.                             WM_CREATEHWXCONTROL,
  1009.                             (MPARAM) 0,
  1010.                             (MPARAM) 0 );
  1011.                WinShowWindow ( hWnd, TRUE );
  1012.                break;
  1013.  
  1014.       case  WM_CREATEHWXCONTROL:
  1015.                hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1016.                                          FID_MENU );
  1017.                menuitem.iPosition   = MIT_END;
  1018.                menuitem.afStyle     = MIS_TEXT;
  1019.                menuitem.afAttribute = 0;
  1020.                menuitem.id          = ID_MENUITEM;
  1021.                menuitem.hItem       = 0;
  1022.                menuitem.hwndSubMenu = 0;
  1023.  
  1024.                WinSendMsg ( hMenu,
  1025.                             MM_INSERTITEM,
  1026.                             (MPARAM) &menuitem,
  1027.                             (MPARAM) "PreventGestures" );
  1028.                WinQueryWindowRect ( hWnd, &rcl );
  1029.                hHwxControl =  WinCreateWindow ( hWnd,
  1030.                                                 WC_HWXENTRY,
  1031.                                                 "",
  1032.                                                 HX_3DBORDER |
  1033.                                                    WS_VISIBLE,
  1034.                                                 2,
  1035.                                                 2,
  1036.                                                 rcl.xRight-4,
  1037.                                                 rcl.yTop-4,
  1038.                                                 hWnd,
  1039.                                                 HWND_BOTTOM,
  1040.                                                 ID_HWX_CONTROL1,
  1041.                                                 NULL,
  1042.                                                 NULL );
  1043.                if ( !hHwxControl )
  1044.                   {
  1045.                   DebugMessage ( "Control creation failed" );
  1046.                   return( (MRESULT) FALSE );
  1047.                   };
  1048.                return ( (MRESULT) TRUE );
  1049.                break;
  1050.  
  1051.       case  WM_CONTROL:
  1052.                switch ( SHORT2FROMMP(mp1) )
  1053.                   {
  1054.                   case  HXN_GESTURE_PENDING:
  1055.                         pMyWindowData = (PMYWINDOWDATA) WinQueryWindowPtr ( hWnd, 0 );
  1056.                         if ( pMyWindowData->prevent )
  1057.                            StatusLine ( hWnd, "Preventing gesture processing" );
  1058.                         else
  1059.                            StatusLine ( hWnd, "Permiting gestures processing" );
  1060.                         return ( (MRESULT) pMyWindowData->prevent );
  1061.                         break;
  1062.  
  1063.                   default:
  1064.                         break;
  1065.                   };
  1066.                break;
  1067.  
  1068.       /***********************************************************************
  1069.       * Messages from the menu                                               *
  1070.       ***********************************************************************/
  1071.       case  WM_COMMAND:
  1072.                if ( SHORT1FROMMP (mp1) == ID_MENUITEM )
  1073.                   {
  1074.                   pMyWindowData = (PMYWINDOWDATA) WinQueryWindowPtr ( hWnd, 0 );
  1075.                   hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1076.                                             FID_MENU );
  1077.                   if ( pMyWindowData->prevent )
  1078.                      {
  1079.                      pMyWindowData->prevent = FALSE;
  1080.                      WinSendMsg ( hMenu,
  1081.                                   MM_SETITEMTEXT,
  1082.                                   (MPARAM) ID_MENUITEM,
  1083.                                   (MPARAM) "PreventGestures" );
  1084.                      }
  1085.                   else
  1086.                      {
  1087.                      pMyWindowData->prevent = TRUE;
  1088.                      WinSendMsg ( hMenu,
  1089.                                   MM_SETITEMTEXT,
  1090.                                   (MPARAM) ID_MENUITEM,
  1091.                                   (MPARAM) "PermitGestures" );
  1092.                      };
  1093.  
  1094.                   };
  1095.                break;
  1096.  
  1097.       default:
  1098.                break;
  1099.       }
  1100.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  1101.    }
  1102.  
  1103. /******************************************************************************
  1104. * NOTIFICATION MESSAGES: HXN_DELETE_PENDING                                   *
  1105. *                                                                             *
  1106. * This notification message is sent to the owner of the control when the user *
  1107. * has issued a deletion operation in the control. The result of the which     *
  1108. * will cause the contents of the control to change.                           *
  1109. ******************************************************************************/
  1110. MRESULT EXPENTRY HWX_HXN_DELETE_PENDING  ( HWND   hWnd,
  1111.                                            ULONG  ulMsg,
  1112.                                            MPARAM mp1,
  1113.                                            MPARAM mp2)
  1114.    {
  1115.    HWND     hHwxControl;
  1116.    RECTL    rcl;
  1117.    HWND     hMenu;
  1118.    MENUITEM menuitem;
  1119.    PMYWINDOWDATA  pMyWindowData ;
  1120.  
  1121.    switch ( ulMsg )
  1122.       {
  1123.       case  WM_CREATE:
  1124.                WinPostMsg ( hWnd,
  1125.                             WM_CREATEHWXCONTROL,
  1126.                             (MPARAM) 0,
  1127.                             (MPARAM) 0 );
  1128.                WinShowWindow ( hWnd, TRUE );
  1129.                break;
  1130.  
  1131.       case  WM_CREATEHWXCONTROL:
  1132.                hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1133.                                          FID_MENU );
  1134.                menuitem.iPosition   = MIT_END;
  1135.                menuitem.afStyle     = MIS_TEXT;
  1136.                menuitem.afAttribute = 0;
  1137.                menuitem.id          = ID_MENUITEM;
  1138.                menuitem.hItem       = 0;
  1139.                menuitem.hwndSubMenu = 0;
  1140.  
  1141.                WinSendMsg ( hMenu,
  1142.                             MM_INSERTITEM,
  1143.                             (MPARAM) &menuitem,
  1144.                             (MPARAM) "PreventDelete" );
  1145.                WinQueryWindowRect ( hWnd, &rcl );
  1146.                hHwxControl =  WinCreateWindow ( hWnd,
  1147.                                                 WC_HWXENTRY,
  1148.                                                 "",
  1149.                                                 HX_3DBORDER |
  1150.                                                    WS_VISIBLE,
  1151.                                                 2,
  1152.                                                 2,
  1153.                                                 rcl.xRight-4,
  1154.                                                 rcl.yTop-4,
  1155.                                                 hWnd,
  1156.                                                 HWND_BOTTOM,
  1157.                                                 ID_HWX_CONTROL1,
  1158.                                                 NULL,
  1159.                                                 NULL );
  1160.                if ( !hHwxControl )
  1161.                   {
  1162.                   DebugMessage ( "Control creation failed" );
  1163.                   return( (MRESULT) FALSE );
  1164.                   };
  1165.                return ( (MRESULT) TRUE );
  1166.                break;
  1167.  
  1168.       case  WM_CONTROL:
  1169.                switch ( SHORT2FROMMP(mp1) )
  1170.                   {
  1171.                   case  HXN_DELETE_PENDING:
  1172.                         pMyWindowData = (PMYWINDOWDATA) WinQueryWindowPtr ( hWnd, 0 );
  1173.                         if ( pMyWindowData->prevent )
  1174.                            StatusLine ( hWnd, "Preventing delete processing" );
  1175.                         else
  1176.                            StatusLine ( hWnd, "Permiting delete processing" );
  1177.                         return ( (MRESULT) pMyWindowData->prevent );
  1178.                         break;
  1179.  
  1180.                   default:
  1181.                         break;
  1182.                   };
  1183.                break;
  1184.  
  1185.       /***********************************************************************
  1186.       * Messages from the menu                                               *
  1187.       ***********************************************************************/
  1188.       case  WM_COMMAND:
  1189.                if ( SHORT1FROMMP (mp1) == ID_MENUITEM )
  1190.                   {
  1191.                   pMyWindowData = (PMYWINDOWDATA) WinQueryWindowPtr ( hWnd, 0 );
  1192.                   hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1193.                                             FID_MENU );
  1194.                   if ( pMyWindowData->prevent )
  1195.                      {
  1196.                      pMyWindowData->prevent = FALSE;
  1197.                      WinSendMsg ( hMenu,
  1198.                                   MM_SETITEMTEXT,
  1199.                                   (MPARAM) ID_MENUITEM,
  1200.                                   (MPARAM) "PreventDelete" );
  1201.                      }
  1202.                   else
  1203.                      {
  1204.                      pMyWindowData->prevent = TRUE;
  1205.                      WinSendMsg ( hMenu,
  1206.                                   MM_SETITEMTEXT,
  1207.                                   (MPARAM) ID_MENUITEM,
  1208.                                   (MPARAM) "PermitDelete" );
  1209.                      };
  1210.  
  1211.                   };
  1212.                break;
  1213.  
  1214.       default:
  1215.                break;
  1216.       }
  1217.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  1218.    }
  1219.  
  1220. /******************************************************************************
  1221. * NOTIFICATION MESSAGES: HXN_INSERT_PENDING                                   *
  1222. *                                                                             *
  1223. * This notification message is sent to the owner of the control when the user *
  1224. * has issued a insertion operation in the control. The result of the which    *
  1225. * will cause the contents of the control to change.                           *
  1226. ******************************************************************************/
  1227. MRESULT EXPENTRY HWX_HXN_INSERT_PENDING  ( HWND   hWnd,
  1228.                                            ULONG  ulMsg,
  1229.                                            MPARAM mp1,
  1230.                                            MPARAM mp2)
  1231.    {
  1232.    HWND     hHwxControl;
  1233.    RECTL    rcl;
  1234.    HWND     hMenu;
  1235.    MENUITEM menuitem;
  1236.    PMYWINDOWDATA  pMyWindowData ;
  1237.  
  1238.    switch ( ulMsg )
  1239.       {
  1240.       case  WM_CREATE:
  1241.                WinPostMsg ( hWnd,
  1242.                             WM_CREATEHWXCONTROL,
  1243.                             (MPARAM) 0,
  1244.                             (MPARAM) 0 );
  1245.                WinShowWindow ( hWnd, TRUE );
  1246.                break;
  1247.  
  1248.       case  WM_CREATEHWXCONTROL:
  1249.                hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1250.                                          FID_MENU );
  1251.                menuitem.iPosition   = MIT_END;
  1252.                menuitem.afStyle     = MIS_TEXT;
  1253.                menuitem.afAttribute = 0;
  1254.                menuitem.id          = ID_MENUITEM;
  1255.                menuitem.hItem       = 0;
  1256.                menuitem.hwndSubMenu = 0;
  1257.  
  1258.                WinSendMsg ( hMenu,
  1259.                             MM_INSERTITEM,
  1260.                             (MPARAM) &menuitem,
  1261.                             (MPARAM) "PreventInsert" );
  1262.                WinQueryWindowRect ( hWnd, &rcl );
  1263.                hHwxControl =  WinCreateWindow ( hWnd,
  1264.                                                 WC_HWXENTRY,
  1265.                                                 "",
  1266.                                                 HX_3DBORDER |
  1267.                                                    WS_VISIBLE,
  1268.                                                 2,
  1269.                                                 2,
  1270.                                                 rcl.xRight-4,
  1271.                                                 rcl.yTop-4,
  1272.                                                 hWnd,
  1273.                                                 HWND_BOTTOM,
  1274.                                                 ID_HWX_CONTROL1,
  1275.                                                 NULL,
  1276.                                                 NULL );
  1277.                if ( !hHwxControl )
  1278.                   {
  1279.                   DebugMessage ( "Control creation failed" );
  1280.                   return( (MRESULT) FALSE );
  1281.                   };
  1282.                return ( (MRESULT) TRUE );
  1283.                break;
  1284.  
  1285.       case  WM_CONTROL:
  1286.                switch ( SHORT2FROMMP(mp1) )
  1287.                   {
  1288.                   case  HXN_INSERT_PENDING:
  1289.                         pMyWindowData = (PMYWINDOWDATA) WinQueryWindowPtr ( hWnd, 0 );
  1290.                         if ( pMyWindowData->prevent )
  1291.                            StatusLine ( hWnd, "Preventing insert processing" );
  1292.                         else
  1293.                            StatusLine ( hWnd, "Permiting insert processing" );
  1294.                         return ( (MRESULT) pMyWindowData->prevent );
  1295.                         break;
  1296.  
  1297.                   default:
  1298.                         break;
  1299.                   };
  1300.                break;
  1301.  
  1302.       /***********************************************************************
  1303.       * Messages from the menu                                               *
  1304.       ***********************************************************************/
  1305.       case  WM_COMMAND:
  1306.                if ( SHORT1FROMMP (mp1) == ID_MENUITEM )
  1307.                   {
  1308.                   pMyWindowData = (PMYWINDOWDATA) WinQueryWindowPtr ( hWnd, 0 );
  1309.                   hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1310.                                             FID_MENU );
  1311.                   if ( pMyWindowData->prevent )
  1312.                      {
  1313.                      pMyWindowData->prevent = FALSE;
  1314.                      WinSendMsg ( hMenu,
  1315.                                   MM_SETITEMTEXT,
  1316.                                   (MPARAM) ID_MENUITEM,
  1317.                                   (MPARAM) "PreventInsert" );
  1318.                      }
  1319.                   else
  1320.                      {
  1321.                      pMyWindowData->prevent = TRUE;
  1322.                      WinSendMsg ( hMenu,
  1323.                                   MM_SETITEMTEXT,
  1324.                                   (MPARAM) ID_MENUITEM,
  1325.                                   (MPARAM) "PermitInsert" );
  1326.                      };
  1327.  
  1328.                   };
  1329.                break;
  1330.  
  1331.       default:
  1332.                break;
  1333.       }
  1334.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  1335.    }
  1336.  
  1337. /******************************************************************************
  1338. * NOTIFICATION MESSAGES: WM_HELP                                              *
  1339. *                                                                             *
  1340. * This is a standard PM message, however it is also generated as a result of  *
  1341. * the user entering a ? gesture into the control.                             *
  1342. ******************************************************************************/
  1343. MRESULT EXPENTRY HWX_WM_HELP ( HWND   hWnd,
  1344.                                ULONG  ulMsg,
  1345.                                MPARAM mp1,
  1346.                                MPARAM mp2)
  1347.    {
  1348.    HWND     hHwxControl;
  1349.    RECTL    rcl;
  1350.  
  1351.    switch ( ulMsg )
  1352.       {
  1353.       case  WM_CREATE:
  1354.                WinPostMsg ( hWnd,
  1355.                             WM_CREATEHWXCONTROL,
  1356.                             (MPARAM) 0,
  1357.                             (MPARAM) 0 );
  1358.                WinShowWindow ( hWnd, TRUE );
  1359.                break;
  1360.  
  1361.       case  WM_CREATEHWXCONTROL:
  1362.                WinQueryWindowRect ( hWnd, &rcl );
  1363.                hHwxControl =  WinCreateWindow ( hWnd,
  1364.                                                 WC_HWXENTRY,
  1365.                                                 "",
  1366.                                                 HX_3DBORDER |
  1367.                                                    WS_VISIBLE,
  1368.                                                 2,
  1369.                                                 2,
  1370.                                                 rcl.xRight-4,
  1371.                                                 rcl.yTop-4,
  1372.                                                 hWnd,
  1373.                                                 HWND_BOTTOM,
  1374.                                                 ID_HWX_CONTROL1,
  1375.                                                 NULL,
  1376.                                                 NULL );
  1377.                if ( !hHwxControl )
  1378.                   {
  1379.                   DebugMessage ( "Control creation failed" );
  1380.                   return( (MRESULT) FALSE );
  1381.                   };
  1382.                return ( (MRESULT) TRUE );
  1383.                break;
  1384.  
  1385.       case  WM_HELP:
  1386.                StatusLine ( hWnd, "Handwriting Control Help" );
  1387.                break;
  1388.  
  1389.       default:
  1390.                break;
  1391.       }
  1392.  
  1393.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  1394.    }
  1395.  
  1396. /******************************************************************************
  1397. * RELATED API'S: WinSetWindowText                                             *
  1398. *                                                                             *
  1399. * This is a standard PM API. It populates the control with the specified text *
  1400. ******************************************************************************/
  1401. MRESULT EXPENTRY HWX_WINSETWINDOWTEXT ( HWND   hWnd,
  1402.                                         ULONG  ulMsg,
  1403.                                         MPARAM mp1,
  1404.                                         MPARAM mp2)
  1405.    {
  1406.    HWND     hHwxControl;
  1407.    HWND     hMenu;
  1408.    MENUITEM menuitem;
  1409.    RECTL    rcl;
  1410.  
  1411.    switch ( ulMsg )
  1412.       {
  1413.       case  WM_CREATE:
  1414.                WinPostMsg ( hWnd,
  1415.                             WM_CREATEHWXCONTROL,
  1416.                             (MPARAM) 0,
  1417.                             (MPARAM) 0 );
  1418.                WinShowWindow ( hWnd, TRUE );
  1419.                break;
  1420.  
  1421.       case  WM_CREATEHWXCONTROL:
  1422.                hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1423.                                          FID_MENU );
  1424.                menuitem.iPosition   = MIT_END;
  1425.                menuitem.afStyle     = MIS_TEXT;
  1426.                menuitem.afAttribute = 0;
  1427.                menuitem.id          = ID_MENUITEM;
  1428.                menuitem.hItem       = 0;
  1429.                menuitem.hwndSubMenu = 0;
  1430.  
  1431.                WinSendMsg ( hMenu,
  1432.                             MM_INSERTITEM,
  1433.                             (MPARAM) &menuitem,
  1434.                             (MPARAM) "SetText" );
  1435.                WinShowWindow ( hWnd, TRUE );
  1436.                WinQueryWindowRect ( hWnd, &rcl );
  1437.                hHwxControl =  WinCreateWindow ( hWnd,
  1438.                                                 WC_HWXENTRY,
  1439.                                                 "",
  1440.                                                 HX_3DBORDER |
  1441.                                                    WS_VISIBLE,
  1442.                                                 2,
  1443.                                                 2,
  1444.                                                 rcl.xRight-4,
  1445.                                                 rcl.yTop-4,
  1446.                                                 hWnd,
  1447.                                                 HWND_BOTTOM,
  1448.                                                 ID_HWX_CONTROL1,
  1449.                                                 NULL,
  1450.                                                 NULL );
  1451.                if ( !hHwxControl )
  1452.                   {
  1453.                   DebugMessage ( "Control creation failed" );
  1454.                   return( (MRESULT) FALSE );
  1455.                   };
  1456.                return ( (MRESULT) TRUE );
  1457.                break;
  1458.  
  1459.       /***********************************************************************
  1460.       * Messages from the menu                                               *
  1461.       ***********************************************************************/
  1462.       case  WM_COMMAND:
  1463.                if ( SHORT1FROMMP (mp1) == ID_MENUITEM )
  1464.                   {
  1465.                   WinSetWindowText ( WinWindowFromID ( hWnd, ID_HWX_CONTROL1 ),
  1466.                                      "TESTING" );
  1467.                   };
  1468.                break;
  1469.  
  1470.       default:
  1471.                break;
  1472.       }
  1473.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  1474.    }
  1475.  
  1476. /******************************************************************************
  1477. * RELATED API'S: WinQueryWindowText                                           *
  1478. *                                                                             *
  1479. * This is a standard PM API. It supplies the text contents of the control.    *
  1480. ******************************************************************************/
  1481. MRESULT EXPENTRY HWX_WINQUERYWINDOWTEXT ( HWND   hWnd,
  1482.                                           ULONG  ulMsg,
  1483.                                           MPARAM mp1,
  1484.                                           MPARAM mp2)
  1485.    {
  1486.    HWND     hHwxControl;
  1487.    HWND     hMenu;
  1488.    MENUITEM menuitem;
  1489.    RECTL    rcl;
  1490.    CHAR     szText[1025];
  1491.  
  1492.    switch ( ulMsg )
  1493.       {
  1494.       case  WM_CREATE:
  1495.                WinPostMsg ( hWnd,
  1496.                             WM_CREATEHWXCONTROL,
  1497.                             (MPARAM) 0,
  1498.                             (MPARAM) 0 );
  1499.                WinShowWindow ( hWnd, TRUE );
  1500.                break;
  1501.  
  1502.       case  WM_CREATEHWXCONTROL:
  1503.                hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1504.                                          FID_MENU );
  1505.                menuitem.iPosition   = MIT_END;
  1506.                menuitem.afStyle     = MIS_TEXT;
  1507.                menuitem.afAttribute = 0;
  1508.                menuitem.id          = ID_MENUITEM;
  1509.                menuitem.hItem       = 0;
  1510.                menuitem.hwndSubMenu = 0;
  1511.  
  1512.                WinSendMsg ( hMenu,
  1513.                             MM_INSERTITEM,
  1514.                             (MPARAM) &menuitem,
  1515.                             (MPARAM) "QueryText" );
  1516.  
  1517.                WinQueryWindowRect ( hWnd, &rcl );
  1518.                hHwxControl =  WinCreateWindow ( hWnd,
  1519.                                                 WC_HWXENTRY,
  1520.                                                 "",
  1521.                                                 HX_3DBORDER |
  1522.                                                    WS_VISIBLE,
  1523.                                                 2,
  1524.                                                 2,
  1525.                                                 rcl.xRight-4,
  1526.                                                 rcl.yTop-4,
  1527.                                                 hWnd,
  1528.                                                 HWND_BOTTOM,
  1529.                                                 ID_HWX_CONTROL1,
  1530.                                                 NULL,
  1531.                                                 NULL );
  1532.                if ( !hHwxControl )
  1533.                   {
  1534.                   DebugMessage ( "Control creation failed" );
  1535.                   return( (MRESULT) FALSE );
  1536.                   };
  1537.                return ( (MRESULT) TRUE );
  1538.                break;
  1539.  
  1540.       /***********************************************************************
  1541.       * Messages from the menu                                               *
  1542.       ***********************************************************************/
  1543.       case  WM_COMMAND:
  1544.                if ( SHORT1FROMMP (mp1) == ID_MENUITEM )
  1545.                   {
  1546.                   WinQueryWindowText ( WinWindowFromID ( hWnd, ID_HWX_CONTROL1 ),
  1547.                                        sizeof(szText),
  1548.                                        szText );
  1549.                   StatusLine ( hWnd, szText );
  1550.                   };
  1551.                break;
  1552.  
  1553.       default:
  1554.                break;
  1555.       }
  1556.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  1557.    }
  1558.  
  1559. /******************************************************************************
  1560. * RELATED API'S: WinEnableWindow                                              *
  1561. *                                                                             *
  1562. * This is a standard PM API. It will enable and disable the control.          *
  1563. ******************************************************************************/
  1564. MRESULT EXPENTRY HWX_WINENABLEWINDOW ( HWND   hWnd,
  1565.                                        ULONG  ulMsg,
  1566.                                        MPARAM mp1,
  1567.                                        MPARAM mp2)
  1568.    {
  1569.    HWND        hHwxControl;
  1570.    HWND        hMenu;
  1571.    MENUITEM    menuitem;
  1572.    RECTL       rcl;
  1573.    static BOOL state = TRUE;
  1574.  
  1575.    switch ( ulMsg )
  1576.       {
  1577.       case  WM_CREATE:
  1578.                WinPostMsg ( hWnd,
  1579.                             WM_CREATEHWXCONTROL,
  1580.                             (MPARAM) 0,
  1581.                             (MPARAM) 0 );
  1582.                WinShowWindow ( hWnd, TRUE );
  1583.                break;
  1584.  
  1585.       case  WM_CREATEHWXCONTROL:
  1586.                hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1587.                                          FID_MENU );
  1588.                menuitem.iPosition   = MIT_END;
  1589.                menuitem.afStyle     = MIS_TEXT;
  1590.                menuitem.afAttribute = 0;
  1591.                menuitem.id          = ID_MENUITEM;
  1592.                menuitem.hItem       = 0;
  1593.                menuitem.hwndSubMenu = 0;
  1594.  
  1595.                WinSendMsg ( hMenu,
  1596.                             MM_INSERTITEM,
  1597.                             (MPARAM) &menuitem,
  1598.                             (MPARAM) "Disable" );
  1599.  
  1600.                WinQueryWindowRect ( hWnd, &rcl );
  1601.                hHwxControl =  WinCreateWindow ( hWnd,
  1602.                                                 WC_HWXENTRY,
  1603.                                                 "",
  1604.                                                 HX_3DBORDER |
  1605.                                                    WS_VISIBLE,
  1606.                                                 2,
  1607.                                                 2,
  1608.                                                 rcl.xRight-4,
  1609.                                                 rcl.yTop-4,
  1610.                                                 hWnd,
  1611.                                                 HWND_BOTTOM,
  1612.                                                 ID_HWX_CONTROL1,
  1613.                                                 NULL,
  1614.                                                 NULL );
  1615.                if ( !hHwxControl )
  1616.                   {
  1617.                   DebugMessage ( "Control creation failed" );
  1618.                   return( (MRESULT) FALSE );
  1619.                   };
  1620.                return ( (MRESULT) TRUE );
  1621.                break;
  1622.  
  1623.       /***********************************************************************
  1624.       * Messages from the menu                                               *
  1625.       ***********************************************************************/
  1626.       case  WM_COMMAND:
  1627.                if ( SHORT1FROMMP (mp1) == ID_MENUITEM )
  1628.                   {
  1629.                   hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1630.                                             FID_MENU );
  1631.                   if ( state )
  1632.                      {
  1633.                      state = FALSE;
  1634.                      WinEnableWindow ( WinWindowFromID ( hWnd, ID_HWX_CONTROL1 ), FALSE );
  1635.                      WinSendMsg ( hMenu,
  1636.                                   MM_SETITEMTEXT,
  1637.                                   (MPARAM) ID_MENUITEM,
  1638.                                   (MPARAM) "Enable" );
  1639.                      StatusLine ( hWnd, "Control is disabled" );
  1640.                      }
  1641.                   else
  1642.                      {
  1643.                      state = TRUE;
  1644.                      WinEnableWindow ( WinWindowFromID ( hWnd, ID_HWX_CONTROL1 ), TRUE );
  1645.                      WinSendMsg ( hMenu,
  1646.                                   MM_SETITEMTEXT,
  1647.                                   (MPARAM) ID_MENUITEM,
  1648.                                   (MPARAM) "Disable" );
  1649.                      StatusLine ( hWnd, "Control is enabled" );
  1650.                      };
  1651.  
  1652.                   };
  1653.                break;
  1654.  
  1655.       default:
  1656.                break;
  1657.       }
  1658.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  1659.    }
  1660.  
  1661. /******************************************************************************
  1662. * MISC: MULTIPLE HANDWRITING CONTROLS                                         *
  1663. *                                                                             *
  1664. * This is a simple example to show that multiple handwriting controls can be  *
  1665. * used within the same parent window.                                         *
  1666. ******************************************************************************/
  1667. MRESULT EXPENTRY HWX_MULTIPLE_CONTROLS (  HWND   hWnd,
  1668.                                           ULONG  ulMsg,
  1669.                                           MPARAM mp1,
  1670.                                           MPARAM mp2)
  1671.    {
  1672.    HWND     hHwxControl[4];
  1673.    RECTL    rcl;
  1674.    ULONG    x[4];
  1675.    ULONG    y[4];
  1676.    ULONG    cx;
  1677.    ULONG    cy;
  1678.    ULONG    i;
  1679.    ULONG    id[4];
  1680.  
  1681.    id[0]   = ID_HWX_CONTROL1;
  1682.    id[1]   = ID_HWX_CONTROL2;
  1683.    id[2]   = ID_HWX_CONTROL3;
  1684.    id[3]   = ID_HWX_CONTROL4;
  1685.    switch ( ulMsg )
  1686.       {
  1687.       case  WM_CREATE:
  1688.                WinPostMsg ( hWnd,
  1689.                             WM_CREATEHWXCONTROL,
  1690.                             (MPARAM) 0,
  1691.                             (MPARAM) 0 );
  1692.                WinShowWindow ( hWnd, TRUE );
  1693.                break;
  1694.  
  1695.       case  WM_CREATEHWXCONTROL:
  1696.                WinQueryWindowRect ( hWnd, &rcl );
  1697.                cx      = rcl.xRight/2 - 2;
  1698.                cy      = rcl.yTop/2 - 2;
  1699.                x[0]    = 2;
  1700.                y[0]    = 2;
  1701.                x[1]    = x[0] + cx + 2;
  1702.                y[1]    = y[0];
  1703.                x[2]    = x[0];
  1704.                y[2]    = y[0] + cy + 2;
  1705.                x[3]    = x[1];
  1706.                y[3]    = y[2];
  1707.                for ( i = 0; i<4; i++ )
  1708.                   {
  1709.                   hHwxControl[i] =  WinCreateWindow ( hWnd,
  1710.                                                       WC_HWXENTRY,
  1711.                                                       "",
  1712.                                                       HX_BORDER,
  1713.                                                       x[i],
  1714.                                                       y[i],
  1715.                                                       cx,
  1716.                                                       cy,
  1717.                                                       hWnd,
  1718.                                                       HWND_BOTTOM,
  1719.                                                       id[i],
  1720.                                                       NULL,
  1721.                                                       NULL );
  1722.                   if ( !hHwxControl[i] )
  1723.                      {
  1724.                      DebugMessage ( "Control creation failed" );
  1725.                      return( (MRESULT) FALSE );
  1726.                      };
  1727.                   };
  1728.                for ( i=0; i<4; i++ )
  1729.                   {
  1730.                   WinShowWindow ( WinWindowFromID ( hWnd, id[i] ), TRUE );
  1731.                   };
  1732.                return ( (MRESULT) TRUE );
  1733.                break;
  1734.  
  1735.       case  WM_SIZE:
  1736.                WinQueryWindowRect ( hWnd, &rcl );
  1737.                cx      = rcl.xRight/2 - 2;
  1738.                cy      = rcl.yTop/2 - 2;
  1739.                x[0]    = 2;
  1740.                y[0]    = 2;
  1741.                x[1]    = x[0] + cx + 2;
  1742.                y[1]    = y[0];
  1743.                x[2]    = x[0];
  1744.                y[2]    = y[0] + cy + 2;
  1745.                x[3]    = x[1];
  1746.                y[3]    = y[2];
  1747.                for ( i = 0; i<4; i++ )
  1748.                   {
  1749.                   WinSetWindowPos  ( WinWindowFromID ( hWnd, id[i] ),
  1750.                                      HWND_TOP,
  1751.                                      x[i],
  1752.                                      y[i],
  1753.                                      cx,
  1754.                                      cy,
  1755.                                      SWP_ACTIVATE |
  1756.                                        SWP_MOVE   |
  1757.                                        SWP_SIZE   |
  1758.                                        SWP_SHOW );
  1759.                   };
  1760.                return ( (MRESULT) TRUE );
  1761.                break;
  1762.  
  1763.       default:
  1764.                break;
  1765.       }
  1766.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  1767.    }
  1768.  
  1769.