home *** CD-ROM | disk | FTP | other *** search
/ The Developer Connection…ice Driver Kit for OS/2 3 / DEV3-D1.ISO / devtools / penos2 / hwxprocs.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-08-10  |  73.3 KB  |  1,768 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. * SIZING OF A CONTROL TO A SPECIFIC NUMBER OF ROWS AND COLUMNS. In this case  *
  435. * we will create a control with a 3d border and 2 rows of 5 columns. The      *
  436. * control uses the PPMSV_CHARACTER_BOX_DX and PPMSV_CHARACTER_BOX_DY system   *
  437. * values to size the control within the window.                               *
  438. *                                                                             *
  439. *     rows      = 2                                                           *
  440. *     columns   = 5                                                           *
  441. *     charboxdx = WrtQuerySysValue ( HWND_DESKTOP, PPMSV_CHARACTER_BOX_DX )   *
  442. *     charboxdy = WrtQuerySysValue ( HWND_DESKTOP, PPMSV_CHARACTER_BOX_DY )   *
  443. *     baseline  = charboxdy / 3                                               *
  444. *     controlcx = (columns * charboxdx ) + (charboxdx / 2)                    *
  445. *     controlcy = (rows    * ( charboxdy + baseline ) ) + baseline            *
  446. ******************************************************************************/
  447. MRESULT EXPENTRY HWX_SIZING ( HWND   hWnd,
  448.                               ULONG  ulMsg,
  449.                               MPARAM mp1,
  450.                               MPARAM mp2)
  451.    {
  452.    HWND            hHwxControl;
  453.    RECTL           rcl;
  454.    SHORT    CharBoxDX;
  455.    SHORT    CharBoxDY;
  456.    SHORT    Rows;
  457.    SHORT    Columns;
  458.    SHORT    BaseLineDY;
  459.    static ULONG    ControlDX;
  460.    static ULONG    ControlDY;
  461.    SHORT    BorderCX;
  462.    SHORT    BorderCY;
  463.    CHAR     debugvalue[50];
  464.  
  465.    switch ( ulMsg )
  466.       {
  467.       case  WM_CREATE:
  468.                WinPostMsg ( hWnd,
  469.                             WM_CREATEHWXCONTROL,
  470.                             (MPARAM) 0,
  471.                             (MPARAM) 0 );
  472.                WinShowWindow ( hWnd, TRUE );
  473.                break;
  474.  
  475.       case  WM_CREATEHWXCONTROL:
  476.  
  477.                BorderCX = WinQuerySysValue ( HWND_DESKTOP, SV_CXBORDER );
  478.                BorderCY = WinQuerySysValue ( HWND_DESKTOP, SV_CYBORDER );
  479.  
  480.                CharBoxDX  = WrtQuerySysValue ( HWND_DESKTOP, PPMSV_CHARACTER_BOX_DX );
  481.                CharBoxDY  = WrtQuerySysValue ( HWND_DESKTOP, PPMSV_CHARACTER_BOX_DY );
  482.                Rows       = 2;
  483.                Columns    = 5;
  484.                BaseLineDY = CharBoxDY / 3;
  485.                ControlDX  = ( ( Columns * CharBoxDX ) + ( CharBoxDX / 2 ) + ( 2 * BorderCX ) ) ;
  486.                ControlDY  = ( ( Rows * ( CharBoxDY + BaseLineDY ) ) + BaseLineDY + ( 2 * BorderCY ) );
  487.                WinQueryWindowRect ( hWnd, &rcl );
  488.                hHwxControl =  WinCreateWindow ( hWnd,
  489.                                                 WC_HWXENTRY,
  490.                                                 "",
  491.                                                 HX_3DBORDER |
  492.                                                    WS_VISIBLE,
  493.                                                 (rcl.xRight - ControlDX ) / 2,
  494.                                                 (rcl.yTop   - ControlDY ) / 2,
  495.                                                 ControlDX,
  496.                                                 ControlDY,
  497.                                                 hWnd,
  498.                                                 HWND_BOTTOM,
  499.                                                 ID_HWX_CONTROL1,
  500.                                                 NULL,
  501.                                                 NULL );
  502.                if ( !hHwxControl )
  503.                   {
  504.                   sprintf ( debugvalue, "x=%d, y=%d, dx=%d, dy=%d", (rcl.xRight - ControlDX ) / 2,
  505.                                                 (rcl.yTop   - ControlDY ) / 2,
  506.                                                 ControlDX,
  507.                                                 ControlDY );
  508.  
  509.                   DebugMessage ( debugvalue );
  510.                   return( (MRESULT) FALSE );
  511.                   };
  512.                return ( (MRESULT) TRUE );
  513.                break;
  514.  
  515.       case  WM_SIZE:
  516.                WinQueryWindowRect ( hWnd, &rcl );
  517.                WinSetWindowPos  ( WinWindowFromID ( hWnd, ID_HWX_CONTROL1 ),
  518.                                   HWND_TOP,
  519.                                   (rcl.xRight - ControlDX ) / 2,
  520.                                   (rcl.yTop   - ControlDY ) / 2,
  521.                                   ControlDX,
  522.                                   ControlDY,
  523.                                   SWP_ACTIVATE |
  524.                                     SWP_MOVE   |
  525.                                     SWP_SIZE   |
  526.                                     SWP_SHOW );
  527.                return ( (MRESULT) TRUE );
  528.                break;
  529.  
  530.       default:
  531.                break;
  532.       }
  533.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  534.    }
  535.  
  536. /******************************************************************************
  537. * STRINGS: LOADING OF STRINGS AT CREATION TIME                                *
  538. *                                                                             *
  539. * This example shows how to initialize the control with text at window        *
  540. * creation time.                                                              *
  541. ******************************************************************************/
  542. MRESULT EXPENTRY HWX_INITIAL_TEXT ( HWND   hWnd,
  543.                                     ULONG  ulMsg,
  544.                                     MPARAM mp1,
  545.                                     MPARAM mp2)
  546.    {
  547.    HWND     hHwxControl;
  548.    RECTL    rcl;
  549.  
  550.    switch ( ulMsg )
  551.       {
  552.       case  WM_CREATE:
  553.                WinPostMsg ( hWnd,
  554.                             WM_CREATEHWXCONTROL,
  555.                             (MPARAM) 0,
  556.                             (MPARAM) 0 );
  557.                WinShowWindow ( hWnd, TRUE );
  558.                break;
  559.  
  560.       case  WM_CREATEHWXCONTROL:
  561.                WinQueryWindowRect ( hWnd, &rcl );
  562.                hHwxControl =  WinCreateWindow ( hWnd,
  563.                                                 WC_HWXENTRY,
  564.                                                 "TEST OF LOADING A STRING",
  565.                                                 HX_3DBORDER |
  566.                                                    WS_VISIBLE,
  567.                                                 2,
  568.                                                 2,
  569.                                                 rcl.xRight-4,
  570.                                                 rcl.yTop-4,
  571.                                                 hWnd,
  572.                                                 HWND_BOTTOM,
  573.                                                 ID_HWX_CONTROL1,
  574.                                                 NULL,
  575.                                                 NULL );
  576.                if ( !hHwxControl )
  577.                   {
  578.                   DebugMessage ( "Control creation failed" );
  579.                   return( (MRESULT) FALSE );
  580.                   };
  581.                return ( (MRESULT) TRUE );
  582.                break;
  583.  
  584.       default:
  585.                break;
  586.       }
  587.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  588.    }
  589.  
  590. /******************************************************************************
  591. * NOTIFICATION MESSAGES: HXN_OVERFLOW                                         *
  592. *                                                                             *
  593. * This notification message is sent to the owner of the control to indicate   *
  594. * that the contents of the control have been truncated. This only happens     *
  595. * when the control's content is longer than 1024 characters.                  *
  596. ******************************************************************************/
  597. MRESULT EXPENTRY HWX_HXN_OVERFLOW ( HWND   hWnd,
  598.                                     ULONG  ulMsg,
  599.                                     MPARAM mp1,
  600.                                     MPARAM mp2)
  601.    {
  602.    HWND     hHwxControl;
  603.    RECTL    rcl;
  604.    int      i;
  605.    char     teststring[1050];
  606.  
  607.    switch ( ulMsg )
  608.       {
  609.       case  WM_CREATE:
  610.                WinPostMsg ( hWnd,
  611.                             WM_CREATEHWXCONTROL,
  612.                             (MPARAM) 0,
  613.                             (MPARAM) 0 );
  614.                WinShowWindow ( hWnd, TRUE );
  615.                break;
  616.  
  617.       case  WM_CREATEHWXCONTROL:
  618.                WinQueryWindowRect ( hWnd, &rcl );
  619.                for ( i=0; i<1050; i++ )
  620.                   {
  621.                   teststring[i] = 'a';
  622.                   };
  623.                teststring[1050] = '\0';
  624.                hHwxControl =  WinCreateWindow ( hWnd,
  625.                                                 WC_HWXENTRY,
  626.                                                 teststring,
  627.                                                 HX_3DBORDER |
  628.                                                    WS_VISIBLE,
  629.                                                 2,
  630.                                                 2,
  631.                                                 rcl.xRight-4,
  632.                                                 rcl.yTop-4,
  633.                                                 hWnd,
  634.                                                 HWND_BOTTOM,
  635.                                                 ID_HWX_CONTROL1,
  636.                                                 NULL,
  637.                                                 NULL );
  638.                if ( !hHwxControl )
  639.                   {
  640.                   DebugMessage ( "Control creation failed" );
  641.                   return( (MRESULT) FALSE );
  642.                   };
  643.                return ( (MRESULT) TRUE );
  644.                break;
  645.  
  646.       case  WM_CONTROL:
  647.                switch ( SHORT2FROMMP(mp1) )
  648.                   {
  649.                   case  HXN_OVERFLOW:
  650.                         StatusLine ( hWnd, "Handwriting Control Overflow" );
  651.                         break;
  652.  
  653.                   default:
  654.                         break;
  655.                   };
  656.                break;
  657.  
  658.       default:
  659.                break;
  660.       }
  661.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  662.    }
  663.  
  664. /******************************************************************************
  665. * NOTIFICATION MESSAGES: HXN_SETFOCUS                                         *
  666. *                                                                             *
  667. * When the control gets focus, this notification message is sent to the       *
  668. * owner of the control.                                                       *
  669. ******************************************************************************/
  670. MRESULT EXPENTRY HWX_HXN_SETFOCUS ( HWND   hWnd,
  671.                                     ULONG  ulMsg,
  672.                                     MPARAM mp1,
  673.                                     MPARAM mp2)
  674.    {
  675.    HWND     hHwxControl;
  676.    RECTL    rcl;
  677.  
  678.    switch ( ulMsg )
  679.       {
  680.       case  WM_CREATE:
  681.                WinPostMsg ( hWnd,
  682.                             WM_CREATEHWXCONTROL,
  683.                             (MPARAM) 0,
  684.                             (MPARAM) 0 );
  685.                WinShowWindow ( hWnd, TRUE );
  686.                break;
  687.  
  688.       case  WM_CREATEHWXCONTROL:
  689.                WinQueryWindowRect ( hWnd, &rcl );
  690.                hHwxControl =  WinCreateWindow ( hWnd,
  691.                                                 WC_HWXENTRY,
  692.                                                 "",
  693.                                                 HX_3DBORDER |
  694.                                                    WS_VISIBLE,
  695.                                                 2,
  696.                                                 2,
  697.                                                 rcl.xRight-4,
  698.                                                 rcl.yTop-4,
  699.                                                 hWnd,
  700.                                                 HWND_BOTTOM,
  701.                                                 ID_HWX_CONTROL1,
  702.                                                 NULL,
  703.                                                 NULL );
  704.                if ( !hHwxControl )
  705.                   {
  706.                   DebugMessage ( "Control creation failed" );
  707.                   return( (MRESULT) FALSE );
  708.                   };
  709.                return ( (MRESULT) TRUE );
  710.                break;
  711.  
  712.       case  WM_CONTROL:
  713.                switch ( SHORT2FROMMP(mp1) )
  714.                   {
  715.                   case  HXN_SETFOCUS:
  716.                         StatusLine ( hWnd, "Setting Focus" );
  717.                         WinSetWindowText ( WinWindowFromID ( hWnd, ID_HWX_CONTROL1 ),
  718.                                            "Hello" );
  719.                         return ( (MRESULT) 0 );
  720.                         break;
  721.  
  722.                   default:
  723.                         break;
  724.                   };
  725.                break;
  726.  
  727.       default:
  728.                break;
  729.       }
  730.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  731.    }
  732.  
  733. /******************************************************************************
  734. * NOTIFICATION MESSAGES: HXN_KILLFOCUS                                        *
  735. *                                                                             *
  736. * This message is sent to the owner of the control whenever the control gives *
  737. * up focus.                                                                   *
  738. ******************************************************************************/
  739. MRESULT EXPENTRY HWX_HXN_KILLFOCUS ( HWND   hWnd,
  740.                                      ULONG  ulMsg,
  741.                                      MPARAM mp1,
  742.                                      MPARAM mp2)
  743.    {
  744.    HWND     hHwxControl;
  745.    RECTL    rcl;
  746.  
  747.    switch ( ulMsg )
  748.       {
  749.       case  WM_CREATE:
  750.                WinPostMsg ( hWnd,
  751.                             WM_CREATEHWXCONTROL,
  752.                             (MPARAM) 0,
  753.                             (MPARAM) 0 );
  754.                WinShowWindow ( hWnd, TRUE );
  755.                break;
  756.  
  757.       case  WM_CREATEHWXCONTROL:
  758.                WinQueryWindowRect ( hWnd, &rcl );
  759.                hHwxControl =  WinCreateWindow ( hWnd,
  760.                                                 WC_HWXENTRY,
  761.                                                 "",
  762.                                                 HX_3DBORDER |
  763.                                                    WS_VISIBLE,
  764.                                                 2,
  765.                                                 2,
  766.                                                 rcl.xRight-4,
  767.                                                 rcl.yTop-4,
  768.                                                 hWnd,
  769.                                                 HWND_BOTTOM,
  770.                                                 ID_HWX_CONTROL1,
  771.                                                 NULL,
  772.                                                 NULL );
  773.                if ( !hHwxControl )
  774.                   {
  775.                   DebugMessage ( "Control creation failed" );
  776.                   return( (MRESULT) FALSE );
  777.                   };
  778.                return ( (MRESULT) TRUE );
  779.                break;
  780.  
  781.       case  WM_CONTROL:
  782.                switch ( SHORT2FROMMP(mp1) )
  783.                   {
  784.                   case  HXN_KILLFOCUS:
  785.                         StatusLine ( hWnd, "Losing Focus" );
  786.                         WinSetWindowText ( WinWindowFromID ( hWnd, ID_HWX_CONTROL1 ),
  787.                                            "Good Bye" );
  788.                         return ( (MRESULT) 0 );
  789.                         break;
  790.  
  791.                   default:
  792.                         break;
  793.                   };
  794.                break;
  795.  
  796.       default:
  797.                break;
  798.       }
  799.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  800.    }
  801.  
  802. /******************************************************************************
  803. * NOTIFICATION MESSAGES: HXN_CONTENTS_CHANGED                                 *
  804. *                                                                             *
  805. * This notification message is sent to the owner of the control whenever the  *
  806. * contents of the control has changed.                                        *
  807. ******************************************************************************/
  808. MRESULT EXPENTRY HWX_HXN_CONTENTS_CHANGED ( HWND   hWnd,
  809.                                             ULONG  ulMsg,
  810.                                             MPARAM mp1,
  811.                                             MPARAM mp2)
  812.    {
  813.    HWND     hHwxControl;
  814.    RECTL    rcl;
  815.  
  816.    switch ( ulMsg )
  817.       {
  818.       case  WM_CREATE:
  819.                WinPostMsg ( hWnd,
  820.                             WM_CREATEHWXCONTROL,
  821.                             (MPARAM) 0,
  822.                             (MPARAM) 0 );
  823.                WinShowWindow ( hWnd, TRUE );
  824.                break;
  825.  
  826.       case  WM_CREATEHWXCONTROL:
  827.                WinQueryWindowRect ( hWnd, &rcl );
  828.                hHwxControl =  WinCreateWindow ( hWnd,
  829.                                                 WC_HWXENTRY,
  830.                                                 "",
  831.                                                 HX_3DBORDER |
  832.                                                    WS_VISIBLE,
  833.                                                 2,
  834.                                                 2,
  835.                                                 rcl.xRight-4,
  836.                                                 rcl.yTop-4,
  837.                                                 hWnd,
  838.                                                 HWND_BOTTOM,
  839.                                                 ID_HWX_CONTROL1,
  840.                                                 NULL,
  841.                                                 NULL );
  842.                if ( !hHwxControl )
  843.                   {
  844.                   DebugMessage ( "Control creation failed" );
  845.                   return( (MRESULT) FALSE );
  846.                   };
  847.                return ( (MRESULT) TRUE );
  848.                break;
  849.  
  850.       case  WM_CONTROL:
  851.                switch ( SHORT2FROMMP(mp1) )
  852.                   {
  853.                   case  HXN_CONTENTS_CHANGED:
  854.                         StatusLine ( hWnd, "Handwriting Control Contents Changed" );
  855.                         break;
  856.  
  857.                   default:
  858.                         break;
  859.                   };
  860.                break;
  861.  
  862.       default:
  863.                break;
  864.       }
  865.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  866.    }
  867.  
  868. /******************************************************************************
  869. * NOTIFICATION MESSAGES: HXN_STROKE_ADD                                       *
  870. *                                                                             *
  871. * This notificatioom message is sent to inform the owner of the control that  *
  872. * the user has begun to ink into the control and thus the contents of the     *
  873. * control may be about to change.                                             *
  874. ******************************************************************************/
  875. MRESULT EXPENTRY HWX_HXN_STROKE_ADD ( HWND   hWnd,
  876.                                       ULONG  ulMsg,
  877.                                       MPARAM mp1,
  878.                                       MPARAM mp2)
  879.    {
  880.    HWND           hHwxControl;
  881.    RECTL          rcl;
  882.    HWND           hMenu;
  883.    MENUITEM       menuitem;
  884.    PMYWINDOWDATA  pMyWindowData ;
  885.  
  886.    switch ( ulMsg )
  887.       {
  888.       case  WM_CREATE:
  889.                WinPostMsg ( hWnd,
  890.                             WM_CREATEHWXCONTROL,
  891.                             (MPARAM) 0,
  892.                             (MPARAM) 0 );
  893.                WinShowWindow ( hWnd, TRUE );
  894.                break;
  895.  
  896.       case  WM_CREATEHWXCONTROL:
  897.                hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  898.                                          FID_MENU );
  899.                menuitem.iPosition   = MIT_END;
  900.                menuitem.afStyle     = MIS_TEXT;
  901.                menuitem.afAttribute = 0;
  902.                menuitem.id          = ID_MENUITEM;
  903.                menuitem.hItem       = 0;
  904.                menuitem.hwndSubMenu = 0;
  905.  
  906.                WinSendMsg ( hMenu,
  907.                             MM_INSERTITEM,
  908.                             (MPARAM) &menuitem,
  909.                             (MPARAM) "PreventStrokes" );
  910.                WinQueryWindowRect ( hWnd, &rcl );
  911.                hHwxControl =  WinCreateWindow ( hWnd,
  912.                                                 WC_HWXENTRY,
  913.                                                 "",
  914.                                                 HX_3DBORDER |
  915.                                                    WS_VISIBLE,
  916.                                                 2,
  917.                                                 2,
  918.                                                 rcl.xRight-4,
  919.                                                 rcl.yTop-4,
  920.                                                 hWnd,
  921.                                                 HWND_BOTTOM,
  922.                                                 ID_HWX_CONTROL1,
  923.                                                 NULL,
  924.                                                 NULL );
  925.                if ( !hHwxControl )
  926.                   {
  927.                   DebugMessage ( "Control creation failed" );
  928.                   return( (MRESULT) FALSE );
  929.                   };
  930.                return ( (MRESULT) TRUE );
  931.                break;
  932.  
  933.       case  WM_CONTROL:
  934.                switch ( SHORT2FROMMP(mp1) )
  935.                   {
  936.                   case  HXN_STROKE_ADDED:
  937.                         pMyWindowData = (PMYWINDOWDATA) WinQueryWindowPtr ( hWnd, 0 );
  938.                         if ( pMyWindowData->prevent )
  939.                            StatusLine ( hWnd, "Preventing strokes from being added" );
  940.                         else
  941.                            StatusLine ( hWnd, "Permiting strokes to be added" );
  942.                         return ( (MRESULT) pMyWindowData->prevent );
  943.                         break;
  944.  
  945.                   default:
  946.                         break;
  947.                   };
  948.                break;
  949.  
  950.       /***********************************************************************
  951.       * Messages from the menu                                               *
  952.       ***********************************************************************/
  953.       case  WM_COMMAND:
  954.                pMyWindowData = (PMYWINDOWDATA) WinQueryWindowPtr ( hWnd, 0 );
  955.                if ( SHORT1FROMMP (mp1) == ID_MENUITEM )
  956.                   {
  957.                   hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  958.                                             FID_MENU );
  959.                   if ( pMyWindowData->prevent )
  960.                      {
  961.                      pMyWindowData->prevent = FALSE;
  962.                      WinSendMsg ( hMenu,
  963.                                   MM_SETITEMTEXT,
  964.                                   (MPARAM) ID_MENUITEM,
  965.                                   (MPARAM) "PreventStrokes" );
  966.                      }
  967.                   else
  968.                      {
  969.                      pMyWindowData->prevent = TRUE;
  970.                      WinSendMsg ( hMenu,
  971.                                   MM_SETITEMTEXT,
  972.                                   (MPARAM) ID_MENUITEM,
  973.                                   (MPARAM) "PermitStrokes" );
  974.                      };
  975.  
  976.                   };
  977.                break;
  978.  
  979.       default:
  980.                break;
  981.       }
  982.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  983.    }
  984.  
  985. /******************************************************************************
  986. * NOTIFICATION MESSAGES: HXN_GESTURE_PENDING                                  *
  987. *                                                                             *
  988. * This notification message is sent to the owner of the control when the user *
  989. * has stroked a gesture in the control. The result of the gesture             *
  990. * recognition could cause the contents of the control to change.              *
  991. ******************************************************************************/
  992. MRESULT EXPENTRY HWX_HXN_GESTURE_PENDING ( HWND   hWnd,
  993.                                            ULONG  ulMsg,
  994.                                            MPARAM mp1,
  995.                                            MPARAM mp2)
  996.    {
  997.    HWND     hHwxControl;
  998.    RECTL    rcl;
  999.    HWND     hMenu;
  1000.    MENUITEM menuitem;
  1001.    PMYWINDOWDATA  pMyWindowData ;
  1002.  
  1003.    switch ( ulMsg )
  1004.       {
  1005.       case  WM_CREATE:
  1006.                WinPostMsg ( hWnd,
  1007.                             WM_CREATEHWXCONTROL,
  1008.                             (MPARAM) 0,
  1009.                             (MPARAM) 0 );
  1010.                WinShowWindow ( hWnd, TRUE );
  1011.                break;
  1012.  
  1013.       case  WM_CREATEHWXCONTROL:
  1014.                hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1015.                                          FID_MENU );
  1016.                menuitem.iPosition   = MIT_END;
  1017.                menuitem.afStyle     = MIS_TEXT;
  1018.                menuitem.afAttribute = 0;
  1019.                menuitem.id          = ID_MENUITEM;
  1020.                menuitem.hItem       = 0;
  1021.                menuitem.hwndSubMenu = 0;
  1022.  
  1023.                WinSendMsg ( hMenu,
  1024.                             MM_INSERTITEM,
  1025.                             (MPARAM) &menuitem,
  1026.                             (MPARAM) "PreventGestures" );
  1027.                WinQueryWindowRect ( hWnd, &rcl );
  1028.                hHwxControl =  WinCreateWindow ( hWnd,
  1029.                                                 WC_HWXENTRY,
  1030.                                                 "",
  1031.                                                 HX_3DBORDER |
  1032.                                                    WS_VISIBLE,
  1033.                                                 2,
  1034.                                                 2,
  1035.                                                 rcl.xRight-4,
  1036.                                                 rcl.yTop-4,
  1037.                                                 hWnd,
  1038.                                                 HWND_BOTTOM,
  1039.                                                 ID_HWX_CONTROL1,
  1040.                                                 NULL,
  1041.                                                 NULL );
  1042.                if ( !hHwxControl )
  1043.                   {
  1044.                   DebugMessage ( "Control creation failed" );
  1045.                   return( (MRESULT) FALSE );
  1046.                   };
  1047.                return ( (MRESULT) TRUE );
  1048.                break;
  1049.  
  1050.       case  WM_CONTROL:
  1051.                switch ( SHORT2FROMMP(mp1) )
  1052.                   {
  1053.                   case  HXN_GESTURE_PENDING:
  1054.                         pMyWindowData = (PMYWINDOWDATA) WinQueryWindowPtr ( hWnd, 0 );
  1055.                         if ( pMyWindowData->prevent )
  1056.                            StatusLine ( hWnd, "Preventing gesture processing" );
  1057.                         else
  1058.                            StatusLine ( hWnd, "Permiting gestures processing" );
  1059.                         return ( (MRESULT) pMyWindowData->prevent );
  1060.                         break;
  1061.  
  1062.                   default:
  1063.                         break;
  1064.                   };
  1065.                break;
  1066.  
  1067.       /***********************************************************************
  1068.       * Messages from the menu                                               *
  1069.       ***********************************************************************/
  1070.       case  WM_COMMAND:
  1071.                if ( SHORT1FROMMP (mp1) == ID_MENUITEM )
  1072.                   {
  1073.                   pMyWindowData = (PMYWINDOWDATA) WinQueryWindowPtr ( hWnd, 0 );
  1074.                   hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1075.                                             FID_MENU );
  1076.                   if ( pMyWindowData->prevent )
  1077.                      {
  1078.                      pMyWindowData->prevent = FALSE;
  1079.                      WinSendMsg ( hMenu,
  1080.                                   MM_SETITEMTEXT,
  1081.                                   (MPARAM) ID_MENUITEM,
  1082.                                   (MPARAM) "PreventGestures" );
  1083.                      }
  1084.                   else
  1085.                      {
  1086.                      pMyWindowData->prevent = TRUE;
  1087.                      WinSendMsg ( hMenu,
  1088.                                   MM_SETITEMTEXT,
  1089.                                   (MPARAM) ID_MENUITEM,
  1090.                                   (MPARAM) "PermitGestures" );
  1091.                      };
  1092.  
  1093.                   };
  1094.                break;
  1095.  
  1096.       default:
  1097.                break;
  1098.       }
  1099.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  1100.    }
  1101.  
  1102. /******************************************************************************
  1103. * NOTIFICATION MESSAGES: HXN_DELETE_PENDING                                   *
  1104. *                                                                             *
  1105. * This notification message is sent to the owner of the control when the user *
  1106. * has issued a deletion operation in the control. The result of the which     *
  1107. * will cause the contents of the control to change.                           *
  1108. ******************************************************************************/
  1109. MRESULT EXPENTRY HWX_HXN_DELETE_PENDING  ( HWND   hWnd,
  1110.                                            ULONG  ulMsg,
  1111.                                            MPARAM mp1,
  1112.                                            MPARAM mp2)
  1113.    {
  1114.    HWND     hHwxControl;
  1115.    RECTL    rcl;
  1116.    HWND     hMenu;
  1117.    MENUITEM menuitem;
  1118.    PMYWINDOWDATA  pMyWindowData ;
  1119.  
  1120.    switch ( ulMsg )
  1121.       {
  1122.       case  WM_CREATE:
  1123.                WinPostMsg ( hWnd,
  1124.                             WM_CREATEHWXCONTROL,
  1125.                             (MPARAM) 0,
  1126.                             (MPARAM) 0 );
  1127.                WinShowWindow ( hWnd, TRUE );
  1128.                break;
  1129.  
  1130.       case  WM_CREATEHWXCONTROL:
  1131.                hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1132.                                          FID_MENU );
  1133.                menuitem.iPosition   = MIT_END;
  1134.                menuitem.afStyle     = MIS_TEXT;
  1135.                menuitem.afAttribute = 0;
  1136.                menuitem.id          = ID_MENUITEM;
  1137.                menuitem.hItem       = 0;
  1138.                menuitem.hwndSubMenu = 0;
  1139.  
  1140.                WinSendMsg ( hMenu,
  1141.                             MM_INSERTITEM,
  1142.                             (MPARAM) &menuitem,
  1143.                             (MPARAM) "PreventDelete" );
  1144.                WinQueryWindowRect ( hWnd, &rcl );
  1145.                hHwxControl =  WinCreateWindow ( hWnd,
  1146.                                                 WC_HWXENTRY,
  1147.                                                 "",
  1148.                                                 HX_3DBORDER |
  1149.                                                    WS_VISIBLE,
  1150.                                                 2,
  1151.                                                 2,
  1152.                                                 rcl.xRight-4,
  1153.                                                 rcl.yTop-4,
  1154.                                                 hWnd,
  1155.                                                 HWND_BOTTOM,
  1156.                                                 ID_HWX_CONTROL1,
  1157.                                                 NULL,
  1158.                                                 NULL );
  1159.                if ( !hHwxControl )
  1160.                   {
  1161.                   DebugMessage ( "Control creation failed" );
  1162.                   return( (MRESULT) FALSE );
  1163.                   };
  1164.                return ( (MRESULT) TRUE );
  1165.                break;
  1166.  
  1167.       case  WM_CONTROL:
  1168.                switch ( SHORT2FROMMP(mp1) )
  1169.                   {
  1170.                   case  HXN_DELETE_PENDING:
  1171.                         pMyWindowData = (PMYWINDOWDATA) WinQueryWindowPtr ( hWnd, 0 );
  1172.                         if ( pMyWindowData->prevent )
  1173.                            StatusLine ( hWnd, "Preventing delete processing" );
  1174.                         else
  1175.                            StatusLine ( hWnd, "Permiting delete processing" );
  1176.                         return ( (MRESULT) pMyWindowData->prevent );
  1177.                         break;
  1178.  
  1179.                   default:
  1180.                         break;
  1181.                   };
  1182.                break;
  1183.  
  1184.       /***********************************************************************
  1185.       * Messages from the menu                                               *
  1186.       ***********************************************************************/
  1187.       case  WM_COMMAND:
  1188.                if ( SHORT1FROMMP (mp1) == ID_MENUITEM )
  1189.                   {
  1190.                   pMyWindowData = (PMYWINDOWDATA) WinQueryWindowPtr ( hWnd, 0 );
  1191.                   hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1192.                                             FID_MENU );
  1193.                   if ( pMyWindowData->prevent )
  1194.                      {
  1195.                      pMyWindowData->prevent = FALSE;
  1196.                      WinSendMsg ( hMenu,
  1197.                                   MM_SETITEMTEXT,
  1198.                                   (MPARAM) ID_MENUITEM,
  1199.                                   (MPARAM) "PreventDelete" );
  1200.                      }
  1201.                   else
  1202.                      {
  1203.                      pMyWindowData->prevent = TRUE;
  1204.                      WinSendMsg ( hMenu,
  1205.                                   MM_SETITEMTEXT,
  1206.                                   (MPARAM) ID_MENUITEM,
  1207.                                   (MPARAM) "PermitDelete" );
  1208.                      };
  1209.  
  1210.                   };
  1211.                break;
  1212.  
  1213.       default:
  1214.                break;
  1215.       }
  1216.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  1217.    }
  1218.  
  1219. /******************************************************************************
  1220. * NOTIFICATION MESSAGES: HXN_INSERT_PENDING                                   *
  1221. *                                                                             *
  1222. * This notification message is sent to the owner of the control when the user *
  1223. * has issued a insertion operation in the control. The result of the which    *
  1224. * will cause the contents of the control to change.                           *
  1225. ******************************************************************************/
  1226. MRESULT EXPENTRY HWX_HXN_INSERT_PENDING  ( HWND   hWnd,
  1227.                                            ULONG  ulMsg,
  1228.                                            MPARAM mp1,
  1229.                                            MPARAM mp2)
  1230.    {
  1231.    HWND     hHwxControl;
  1232.    RECTL    rcl;
  1233.    HWND     hMenu;
  1234.    MENUITEM menuitem;
  1235.    PMYWINDOWDATA  pMyWindowData ;
  1236.  
  1237.    switch ( ulMsg )
  1238.       {
  1239.       case  WM_CREATE:
  1240.                WinPostMsg ( hWnd,
  1241.                             WM_CREATEHWXCONTROL,
  1242.                             (MPARAM) 0,
  1243.                             (MPARAM) 0 );
  1244.                WinShowWindow ( hWnd, TRUE );
  1245.                break;
  1246.  
  1247.       case  WM_CREATEHWXCONTROL:
  1248.                hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1249.                                          FID_MENU );
  1250.                menuitem.iPosition   = MIT_END;
  1251.                menuitem.afStyle     = MIS_TEXT;
  1252.                menuitem.afAttribute = 0;
  1253.                menuitem.id          = ID_MENUITEM;
  1254.                menuitem.hItem       = 0;
  1255.                menuitem.hwndSubMenu = 0;
  1256.  
  1257.                WinSendMsg ( hMenu,
  1258.                             MM_INSERTITEM,
  1259.                             (MPARAM) &menuitem,
  1260.                             (MPARAM) "PreventInsert" );
  1261.                WinQueryWindowRect ( hWnd, &rcl );
  1262.                hHwxControl =  WinCreateWindow ( hWnd,
  1263.                                                 WC_HWXENTRY,
  1264.                                                 "",
  1265.                                                 HX_3DBORDER |
  1266.                                                    WS_VISIBLE,
  1267.                                                 2,
  1268.                                                 2,
  1269.                                                 rcl.xRight-4,
  1270.                                                 rcl.yTop-4,
  1271.                                                 hWnd,
  1272.                                                 HWND_BOTTOM,
  1273.                                                 ID_HWX_CONTROL1,
  1274.                                                 NULL,
  1275.                                                 NULL );
  1276.                if ( !hHwxControl )
  1277.                   {
  1278.                   DebugMessage ( "Control creation failed" );
  1279.                   return( (MRESULT) FALSE );
  1280.                   };
  1281.                return ( (MRESULT) TRUE );
  1282.                break;
  1283.  
  1284.       case  WM_CONTROL:
  1285.                switch ( SHORT2FROMMP(mp1) )
  1286.                   {
  1287.                   case  HXN_INSERT_PENDING:
  1288.                         pMyWindowData = (PMYWINDOWDATA) WinQueryWindowPtr ( hWnd, 0 );
  1289.                         if ( pMyWindowData->prevent )
  1290.                            StatusLine ( hWnd, "Preventing insert processing" );
  1291.                         else
  1292.                            StatusLine ( hWnd, "Permiting insert processing" );
  1293.                         return ( (MRESULT) pMyWindowData->prevent );
  1294.                         break;
  1295.  
  1296.                   default:
  1297.                         break;
  1298.                   };
  1299.                break;
  1300.  
  1301.       /***********************************************************************
  1302.       * Messages from the menu                                               *
  1303.       ***********************************************************************/
  1304.       case  WM_COMMAND:
  1305.                if ( SHORT1FROMMP (mp1) == ID_MENUITEM )
  1306.                   {
  1307.                   pMyWindowData = (PMYWINDOWDATA) WinQueryWindowPtr ( hWnd, 0 );
  1308.                   hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1309.                                             FID_MENU );
  1310.                   if ( pMyWindowData->prevent )
  1311.                      {
  1312.                      pMyWindowData->prevent = FALSE;
  1313.                      WinSendMsg ( hMenu,
  1314.                                   MM_SETITEMTEXT,
  1315.                                   (MPARAM) ID_MENUITEM,
  1316.                                   (MPARAM) "PreventInsert" );
  1317.                      }
  1318.                   else
  1319.                      {
  1320.                      pMyWindowData->prevent = TRUE;
  1321.                      WinSendMsg ( hMenu,
  1322.                                   MM_SETITEMTEXT,
  1323.                                   (MPARAM) ID_MENUITEM,
  1324.                                   (MPARAM) "PermitInsert" );
  1325.                      };
  1326.  
  1327.                   };
  1328.                break;
  1329.  
  1330.       default:
  1331.                break;
  1332.       }
  1333.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  1334.    }
  1335.  
  1336. /******************************************************************************
  1337. * NOTIFICATION MESSAGES: WM_HELP                                              *
  1338. *                                                                             *
  1339. * This is a standard PM message, however it is also generated as a result of  *
  1340. * the user entering a ? gesture into the control.                             *
  1341. ******************************************************************************/
  1342. MRESULT EXPENTRY HWX_WM_HELP ( HWND   hWnd,
  1343.                                ULONG  ulMsg,
  1344.                                MPARAM mp1,
  1345.                                MPARAM mp2)
  1346.    {
  1347.    HWND     hHwxControl;
  1348.    RECTL    rcl;
  1349.  
  1350.    switch ( ulMsg )
  1351.       {
  1352.       case  WM_CREATE:
  1353.                WinPostMsg ( hWnd,
  1354.                             WM_CREATEHWXCONTROL,
  1355.                             (MPARAM) 0,
  1356.                             (MPARAM) 0 );
  1357.                WinShowWindow ( hWnd, TRUE );
  1358.                break;
  1359.  
  1360.       case  WM_CREATEHWXCONTROL:
  1361.                WinQueryWindowRect ( hWnd, &rcl );
  1362.                hHwxControl =  WinCreateWindow ( hWnd,
  1363.                                                 WC_HWXENTRY,
  1364.                                                 "",
  1365.                                                 HX_3DBORDER |
  1366.                                                    WS_VISIBLE,
  1367.                                                 2,
  1368.                                                 2,
  1369.                                                 rcl.xRight-4,
  1370.                                                 rcl.yTop-4,
  1371.                                                 hWnd,
  1372.                                                 HWND_BOTTOM,
  1373.                                                 ID_HWX_CONTROL1,
  1374.                                                 NULL,
  1375.                                                 NULL );
  1376.                if ( !hHwxControl )
  1377.                   {
  1378.                   DebugMessage ( "Control creation failed" );
  1379.                   return( (MRESULT) FALSE );
  1380.                   };
  1381.                return ( (MRESULT) TRUE );
  1382.                break;
  1383.  
  1384.       case  WM_HELP:
  1385.                StatusLine ( hWnd, "Handwriting Control Help" );
  1386.                break;
  1387.  
  1388.       default:
  1389.                break;
  1390.       }
  1391.  
  1392.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  1393.    }
  1394.  
  1395. /******************************************************************************
  1396. * RELATED API'S: WinSetWindowText                                             *
  1397. *                                                                             *
  1398. * This is a standard PM API. It populates the control with the specified text *
  1399. ******************************************************************************/
  1400. MRESULT EXPENTRY HWX_WINSETWINDOWTEXT ( HWND   hWnd,
  1401.                                         ULONG  ulMsg,
  1402.                                         MPARAM mp1,
  1403.                                         MPARAM mp2)
  1404.    {
  1405.    HWND     hHwxControl;
  1406.    HWND     hMenu;
  1407.    MENUITEM menuitem;
  1408.    RECTL    rcl;
  1409.  
  1410.    switch ( ulMsg )
  1411.       {
  1412.       case  WM_CREATE:
  1413.                WinPostMsg ( hWnd,
  1414.                             WM_CREATEHWXCONTROL,
  1415.                             (MPARAM) 0,
  1416.                             (MPARAM) 0 );
  1417.                WinShowWindow ( hWnd, TRUE );
  1418.                break;
  1419.  
  1420.       case  WM_CREATEHWXCONTROL:
  1421.                hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1422.                                          FID_MENU );
  1423.                menuitem.iPosition   = MIT_END;
  1424.                menuitem.afStyle     = MIS_TEXT;
  1425.                menuitem.afAttribute = 0;
  1426.                menuitem.id          = ID_MENUITEM;
  1427.                menuitem.hItem       = 0;
  1428.                menuitem.hwndSubMenu = 0;
  1429.  
  1430.                WinSendMsg ( hMenu,
  1431.                             MM_INSERTITEM,
  1432.                             (MPARAM) &menuitem,
  1433.                             (MPARAM) "SetText" );
  1434.                WinShowWindow ( hWnd, TRUE );
  1435.                WinQueryWindowRect ( hWnd, &rcl );
  1436.                hHwxControl =  WinCreateWindow ( hWnd,
  1437.                                                 WC_HWXENTRY,
  1438.                                                 "",
  1439.                                                 HX_3DBORDER |
  1440.                                                    WS_VISIBLE,
  1441.                                                 2,
  1442.                                                 2,
  1443.                                                 rcl.xRight-4,
  1444.                                                 rcl.yTop-4,
  1445.                                                 hWnd,
  1446.                                                 HWND_BOTTOM,
  1447.                                                 ID_HWX_CONTROL1,
  1448.                                                 NULL,
  1449.                                                 NULL );
  1450.                if ( !hHwxControl )
  1451.                   {
  1452.                   DebugMessage ( "Control creation failed" );
  1453.                   return( (MRESULT) FALSE );
  1454.                   };
  1455.                return ( (MRESULT) TRUE );
  1456.                break;
  1457.  
  1458.       /***********************************************************************
  1459.       * Messages from the menu                                               *
  1460.       ***********************************************************************/
  1461.       case  WM_COMMAND:
  1462.                if ( SHORT1FROMMP (mp1) == ID_MENUITEM )
  1463.                   {
  1464.                   WinSetWindowText ( WinWindowFromID ( hWnd, ID_HWX_CONTROL1 ),
  1465.                                      "TESTING" );
  1466.                   };
  1467.                break;
  1468.  
  1469.       default:
  1470.                break;
  1471.       }
  1472.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  1473.    }
  1474.  
  1475. /******************************************************************************
  1476. * RELATED API'S: WinQueryWindowText                                           *
  1477. *                                                                             *
  1478. * This is a standard PM API. It supplies the text contents of the control.    *
  1479. ******************************************************************************/
  1480. MRESULT EXPENTRY HWX_WINQUERYWINDOWTEXT ( HWND   hWnd,
  1481.                                           ULONG  ulMsg,
  1482.                                           MPARAM mp1,
  1483.                                           MPARAM mp2)
  1484.    {
  1485.    HWND     hHwxControl;
  1486.    HWND     hMenu;
  1487.    MENUITEM menuitem;
  1488.    RECTL    rcl;
  1489.    CHAR     szText[1025];
  1490.  
  1491.    switch ( ulMsg )
  1492.       {
  1493.       case  WM_CREATE:
  1494.                WinPostMsg ( hWnd,
  1495.                             WM_CREATEHWXCONTROL,
  1496.                             (MPARAM) 0,
  1497.                             (MPARAM) 0 );
  1498.                WinShowWindow ( hWnd, TRUE );
  1499.                break;
  1500.  
  1501.       case  WM_CREATEHWXCONTROL:
  1502.                hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1503.                                          FID_MENU );
  1504.                menuitem.iPosition   = MIT_END;
  1505.                menuitem.afStyle     = MIS_TEXT;
  1506.                menuitem.afAttribute = 0;
  1507.                menuitem.id          = ID_MENUITEM;
  1508.                menuitem.hItem       = 0;
  1509.                menuitem.hwndSubMenu = 0;
  1510.  
  1511.                WinSendMsg ( hMenu,
  1512.                             MM_INSERTITEM,
  1513.                             (MPARAM) &menuitem,
  1514.                             (MPARAM) "QueryText" );
  1515.  
  1516.                WinQueryWindowRect ( hWnd, &rcl );
  1517.                hHwxControl =  WinCreateWindow ( hWnd,
  1518.                                                 WC_HWXENTRY,
  1519.                                                 "",
  1520.                                                 HX_3DBORDER |
  1521.                                                    WS_VISIBLE,
  1522.                                                 2,
  1523.                                                 2,
  1524.                                                 rcl.xRight-4,
  1525.                                                 rcl.yTop-4,
  1526.                                                 hWnd,
  1527.                                                 HWND_BOTTOM,
  1528.                                                 ID_HWX_CONTROL1,
  1529.                                                 NULL,
  1530.                                                 NULL );
  1531.                if ( !hHwxControl )
  1532.                   {
  1533.                   DebugMessage ( "Control creation failed" );
  1534.                   return( (MRESULT) FALSE );
  1535.                   };
  1536.                return ( (MRESULT) TRUE );
  1537.                break;
  1538.  
  1539.       /***********************************************************************
  1540.       * Messages from the menu                                               *
  1541.       ***********************************************************************/
  1542.       case  WM_COMMAND:
  1543.                if ( SHORT1FROMMP (mp1) == ID_MENUITEM )
  1544.                   {
  1545.                   WinQueryWindowText ( WinWindowFromID ( hWnd, ID_HWX_CONTROL1 ),
  1546.                                        sizeof(szText),
  1547.                                        szText );
  1548.                   StatusLine ( hWnd, szText );
  1549.                   };
  1550.                break;
  1551.  
  1552.       default:
  1553.                break;
  1554.       }
  1555.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  1556.    }
  1557.  
  1558. /******************************************************************************
  1559. * RELATED API'S: WinEnableWindow                                              *
  1560. *                                                                             *
  1561. * This is a standard PM API. It will enable and disable the control.          *
  1562. ******************************************************************************/
  1563. MRESULT EXPENTRY HWX_WINENABLEWINDOW ( HWND   hWnd,
  1564.                                        ULONG  ulMsg,
  1565.                                        MPARAM mp1,
  1566.                                        MPARAM mp2)
  1567.    {
  1568.    HWND        hHwxControl;
  1569.    HWND        hMenu;
  1570.    MENUITEM    menuitem;
  1571.    RECTL       rcl;
  1572.    static BOOL state = TRUE;
  1573.  
  1574.    switch ( ulMsg )
  1575.       {
  1576.       case  WM_CREATE:
  1577.                WinPostMsg ( hWnd,
  1578.                             WM_CREATEHWXCONTROL,
  1579.                             (MPARAM) 0,
  1580.                             (MPARAM) 0 );
  1581.                WinShowWindow ( hWnd, TRUE );
  1582.                break;
  1583.  
  1584.       case  WM_CREATEHWXCONTROL:
  1585.                hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1586.                                          FID_MENU );
  1587.                menuitem.iPosition   = MIT_END;
  1588.                menuitem.afStyle     = MIS_TEXT;
  1589.                menuitem.afAttribute = 0;
  1590.                menuitem.id          = ID_MENUITEM;
  1591.                menuitem.hItem       = 0;
  1592.                menuitem.hwndSubMenu = 0;
  1593.  
  1594.                WinSendMsg ( hMenu,
  1595.                             MM_INSERTITEM,
  1596.                             (MPARAM) &menuitem,
  1597.                             (MPARAM) "Disable" );
  1598.  
  1599.                WinQueryWindowRect ( hWnd, &rcl );
  1600.                hHwxControl =  WinCreateWindow ( hWnd,
  1601.                                                 WC_HWXENTRY,
  1602.                                                 "",
  1603.                                                 HX_3DBORDER |
  1604.                                                    WS_VISIBLE,
  1605.                                                 2,
  1606.                                                 2,
  1607.                                                 rcl.xRight-4,
  1608.                                                 rcl.yTop-4,
  1609.                                                 hWnd,
  1610.                                                 HWND_BOTTOM,
  1611.                                                 ID_HWX_CONTROL1,
  1612.                                                 NULL,
  1613.                                                 NULL );
  1614.                if ( !hHwxControl )
  1615.                   {
  1616.                   DebugMessage ( "Control creation failed" );
  1617.                   return( (MRESULT) FALSE );
  1618.                   };
  1619.                return ( (MRESULT) TRUE );
  1620.                break;
  1621.  
  1622.       /***********************************************************************
  1623.       * Messages from the menu                                               *
  1624.       ***********************************************************************/
  1625.       case  WM_COMMAND:
  1626.                if ( SHORT1FROMMP (mp1) == ID_MENUITEM )
  1627.                   {
  1628.                   hMenu = WinWindowFromID ( WinQueryWindow ( hWnd, QW_PARENT ),
  1629.                                             FID_MENU );
  1630.                   if ( state )
  1631.                      {
  1632.                      state = FALSE;
  1633.                      WinEnableWindow ( WinWindowFromID ( hWnd, ID_HWX_CONTROL1 ), FALSE );
  1634.                      WinSendMsg ( hMenu,
  1635.                                   MM_SETITEMTEXT,
  1636.                                   (MPARAM) ID_MENUITEM,
  1637.                                   (MPARAM) "Enable" );
  1638.                      StatusLine ( hWnd, "Control is disabled" );
  1639.                      }
  1640.                   else
  1641.                      {
  1642.                      state = TRUE;
  1643.                      WinEnableWindow ( WinWindowFromID ( hWnd, ID_HWX_CONTROL1 ), TRUE );
  1644.                      WinSendMsg ( hMenu,
  1645.                                   MM_SETITEMTEXT,
  1646.                                   (MPARAM) ID_MENUITEM,
  1647.                                   (MPARAM) "Disable" );
  1648.                      StatusLine ( hWnd, "Control is enabled" );
  1649.                      };
  1650.  
  1651.                   };
  1652.                break;
  1653.  
  1654.       default:
  1655.                break;
  1656.       }
  1657.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  1658.    }
  1659.  
  1660. /******************************************************************************
  1661. * MISC: MULTIPLE HANDWRITING CONTROLS                                         *
  1662. *                                                                             *
  1663. * This is a simple example to show that multiple handwriting controls can be  *
  1664. * used within the same parent window.                                         *
  1665. ******************************************************************************/
  1666. MRESULT EXPENTRY HWX_MULTIPLE_CONTROLS (  HWND   hWnd,
  1667.                                           ULONG  ulMsg,
  1668.                                           MPARAM mp1,
  1669.                                           MPARAM mp2)
  1670.    {
  1671.    HWND     hHwxControl[4];
  1672.    RECTL    rcl;
  1673.    ULONG    x[4];
  1674.    ULONG    y[4];
  1675.    ULONG    cx;
  1676.    ULONG    cy;
  1677.    ULONG    i;
  1678.    ULONG    id[4];
  1679.  
  1680.    id[0]   = ID_HWX_CONTROL1;
  1681.    id[1]   = ID_HWX_CONTROL2;
  1682.    id[2]   = ID_HWX_CONTROL3;
  1683.    id[3]   = ID_HWX_CONTROL4;
  1684.    switch ( ulMsg )
  1685.       {
  1686.       case  WM_CREATE:
  1687.                WinPostMsg ( hWnd,
  1688.                             WM_CREATEHWXCONTROL,
  1689.                             (MPARAM) 0,
  1690.                             (MPARAM) 0 );
  1691.                WinShowWindow ( hWnd, TRUE );
  1692.                break;
  1693.  
  1694.       case  WM_CREATEHWXCONTROL:
  1695.                WinQueryWindowRect ( hWnd, &rcl );
  1696.                cx      = rcl.xRight/2 - 2;
  1697.                cy      = rcl.yTop/2 - 2;
  1698.                x[0]    = 2;
  1699.                y[0]    = 2;
  1700.                x[1]    = x[0] + cx + 2;
  1701.                y[1]    = y[0];
  1702.                x[2]    = x[0];
  1703.                y[2]    = y[0] + cy + 2;
  1704.                x[3]    = x[1];
  1705.                y[3]    = y[2];
  1706.                for ( i = 0; i<4; i++ )
  1707.                   {
  1708.                   hHwxControl[i] =  WinCreateWindow ( hWnd,
  1709.                                                       WC_HWXENTRY,
  1710.                                                       "",
  1711.                                                       HX_BORDER,
  1712.                                                       x[i],
  1713.                                                       y[i],
  1714.                                                       cx,
  1715.                                                       cy,
  1716.                                                       hWnd,
  1717.                                                       HWND_BOTTOM,
  1718.                                                       id[i],
  1719.                                                       NULL,
  1720.                                                       NULL );
  1721.                   if ( !hHwxControl[i] )
  1722.                      {
  1723.                      DebugMessage ( "Control creation failed" );
  1724.                      return( (MRESULT) FALSE );
  1725.                      };
  1726.                   };
  1727.                for ( i=0; i<4; i++ )
  1728.                   {
  1729.                   WinShowWindow ( WinWindowFromID ( hWnd, id[i] ), TRUE );
  1730.                   };
  1731.                return ( (MRESULT) TRUE );
  1732.                break;
  1733.  
  1734.       case  WM_SIZE:
  1735.                WinQueryWindowRect ( hWnd, &rcl );
  1736.                cx      = rcl.xRight/2 - 2;
  1737.                cy      = rcl.yTop/2 - 2;
  1738.                x[0]    = 2;
  1739.                y[0]    = 2;
  1740.                x[1]    = x[0] + cx + 2;
  1741.                y[1]    = y[0];
  1742.                x[2]    = x[0];
  1743.                y[2]    = y[0] + cy + 2;
  1744.                x[3]    = x[1];
  1745.                y[3]    = y[2];
  1746.                for ( i = 0; i<4; i++ )
  1747.                   {
  1748.                   WinSetWindowPos  ( WinWindowFromID ( hWnd, id[i] ),
  1749.                                      HWND_TOP,
  1750.                                      x[i],
  1751.                                      y[i],
  1752.                                      cx,
  1753.                                      cy,
  1754.                                      SWP_ACTIVATE |
  1755.                                        SWP_MOVE   |
  1756.                                        SWP_SIZE   |
  1757.                                        SWP_SHOW );
  1758.                   };
  1759.                return ( (MRESULT) TRUE );
  1760.                break;
  1761.  
  1762.       default:
  1763.                break;
  1764.       }
  1765.    return ( HWXCOMMON ( hWnd, ulMsg, mp1, mp2 ) );
  1766.    }
  1767.  
  1768.