home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / pc3270sa.zip / spl2file / spspool.c < prev    next >
Text File  |  2002-02-28  |  37KB  |  763 lines
  1. //******************************************************************************
  2. //
  3. //  File name   : SPSPOOL.C
  4. //
  5. //  Description : Make ascii file from host spool file
  6. //
  7. //  FUNCTIONS:
  8. //
  9. //
  10. //  COMMENTS:
  11. //
  12. //  Copyright  (C) 1993, 1996 IBM Corporation
  13. //                        All rights reserved.
  14. //
  15. //******************************************************************************
  16.  
  17. #include <windows.h>                // required for all Windows applications
  18. #include <windowsx.h>
  19. #include <string.h>                 // C string functions
  20. #include <stdio.h>                  // C functions
  21.  
  22. #include "spl2file.h"               // specific to this program
  23. #include "spdata.h"                 // Global Data
  24. #include "dde_c.h"                  // required for PCOM DDE Appls
  25.  
  26. //******************************************************************************
  27. //
  28. // Local Functions
  29. //
  30. //******************************************************************************
  31.  
  32. void SPL_SetPsCond();    /* SF_EPSCOND    */
  33. void SPL_GetPPs();       /* SF_GETPPS     */
  34. void SPL_SetCsr();       /* SF_SETCSR     */
  35. void SPL_ToTop();        /* SF_TOTOP      */
  36. void SPL_ToLeftEnd();    /* SF_TOLEFTEND  */
  37. void SPL_GetPs();        /* SF_GETPS      */
  38. void SPL_IsRightEnd();   /* SF_ISRIGHTEND */
  39. void SPL_ToRight();      /* SF_TORIGHT    */
  40. void SPL_IsEnd();        /* SF_ISEND      */
  41. void SPL_RollUp();       /* SF_ROLLUP     */
  42. void SPL_AbortPend();    /* SF_ABORT      */
  43. void SPL_Terminate();    /* SF_TERM       */
  44.  
  45. BOOL SPL_CheckItem( ATOM );
  46.  
  47. //******************************************************************************
  48. //
  49. // Local Data
  50. //
  51. //******************************************************************************
  52.  
  53. #define SPL_STATE_NO      12                      // number of states
  54. #define SPL_EVENT_NO      8                       // number of events
  55.  
  56. #define SF_EPSCOND        0
  57. #define SF_GETPPS         1
  58. #define SF_SETCSR         2
  59. #define SF_TOTOP          3
  60. #define SF_TOLEFTEND      4
  61. #define SF_GETPS          5
  62. #define SF_ISRIGHTEND     6
  63. #define SF_TORIGHT        7
  64. #define SF_ISEND          8
  65. #define SF_ROLLUP         9
  66. #define SF_ABORT         10
  67. #define SF_TERM          11
  68.  
  69. static void (*SPL_fns[SPL_STATE_NO])() =
  70.   {
  71.   SPL_SetPsCond,         /* SF_EPSCOND    */
  72.   SPL_GetPPs,            /* SF_GETPPS     */
  73.   SPL_SetCsr,            /* SF_SETCSR     */
  74.   SPL_ToTop,             /* SF_TOTOP      */
  75.   SPL_ToLeftEnd,         /* SF_TOLEFTEND  */
  76.   SPL_GetPs,             /* SF_GETPS      */
  77.   SPL_IsRightEnd,        /* SF_ISRIGHTEND */
  78.   SPL_ToRight,           /* SF_TORIGHT    */
  79.   SPL_IsEnd,             /* SF_ISEND      */
  80.   SPL_RollUp,            /* SF_ROLLUP     */
  81.   SPL_AbortPend,         /* SF_ABORT      */
  82.   SPL_Terminate          /* SF_TERM       */
  83.   };
  84.  
  85. static BYTE FSM_SPL[SPL_STATE_NO][SPL_EVENT_NO] =
  86.   {
  87.   //  events -->
  88.   // states
  89.   //   |
  90.   //   V                EV_DATA         EV_ACK         EV_NACK     EV_END      EV_ERROR    EV_ABORT    EV_CONT      EV_BRK
  91.   /* SF_EPSCOND    */ { 0xff          , SF_GETPPS    , SF_TERM   , 0xff      , SF_TERM   , 0xff      , 0xff       , 0xff      },
  92.   /* SF_GETPPS     */ { SF_SETCSR     , 0xff         , SF_TERM   , 0xff      , SF_TERM   , 0xff      , 0xff       , 0xff      },
  93.   /* SF_SETCSR     */ { 0xff          , SF_TOTOP     , SF_TERM   , 0xff      , SF_TERM   , SF_ABORT  , 0xff       , 0xff      },
  94.   /* SF_TOTOP      */ { 0xff          , SF_TOLEFTEND , SF_TERM   , 0xff      , SF_TERM   , SF_ABORT  , 0xff       , 0xff      },
  95.   /* SF_TOLEFTEND  */ { 0xff          , SF_GETPS     , SF_TERM   , 0xff      , SF_TERM   , SF_ABORT  , 0xff       , 0xff      },
  96.   /* SF_GETPS      */ { SF_ISRIGHTEND , 0xff         , SF_TERM   , 0xff      , SF_TERM   , SF_ABORT  , 0xff       , 0xff      },
  97.   /* SF_ISRIGHTEND */ { 0xff          , 0xff         , 0xff      , 0xff      , SF_TERM   , SF_ABORT  , SF_TORIGHT , SF_ISEND  },
  98.   /* SF_TORIGHT    */ { 0xff          , SF_GETPS     , SF_TERM   , 0xff      , SF_TERM   , SF_ABORT  , 0xff       , 0xff      },
  99.   /* SF_ISEND      */ { 0xff          , 0xff         , 0xff      , 0xff      , SF_TERM   , SF_ABORT  , SF_ROLLUP  , SF_TERM   },
  100.   /* SF_ROLLUP     */ { 0xff          , SF_TOLEFTEND , SF_TERM   , 0xff      , SF_TERM   , SF_ABORT  , 0xff       , 0xff      },
  101.   /* SF_ABORT      */ { SF_TERM       , SF_TERM      , SF_TERM   , SF_TERM   , SF_TERM   , SF_TERM   , SF_TERM    , SF_TERM   },
  102.   /* SF_TERM       */ { 0xff          , 0xff         , 0xff      , 0xff      , 0xff      , 0xff      , 0xff       , 0xff      }
  103.   };
  104.  
  105. int       hFile=-1;
  106. OFSTRUCT  of;
  107. int       nStartCol;
  108. int       nEndCol;
  109. int       nMaxCol;
  110. BOOL      bJpnMode;
  111. BOOL      bDbcsText;
  112. char      Footor[7];
  113. int       BufferPtr[16];
  114. char      PsBuffer[16][256];
  115.  
  116. //******************************************************************************
  117. //
  118. //  StartSpoolToFile - Make an ASCII file from a host spool file
  119. //
  120. //  PURPOSE:
  121. //
  122. //
  123. //  COMMENTS:
  124. //
  125. //******************************************************************************
  126. void StartSpoolToFile( HWND hWnd )               //
  127. {                                                //
  128.   FARPROC lpProcModalDialog;                     //
  129.   BOOL    bContinue;                             //
  130.                                                  //
  131.   lpProcModalDialog = MakeProcInstance(PCFilenameDialog, hGlobalInst);
  132.                                                  //
  133.   bContinue = DialogBox(hGlobalInst, MAKEINTRESOURCE(PCFILENAME), hWnd,     lpProcModalDialog);
  134.                                                  // Get PC file name
  135.   FreeProcInstance(lpProcModalDialog);           //
  136.  
  137.   if ( bContinue && InitSession () )             // Initiate session conversation
  138.   {                                              //
  139.     aEPSCOND   = GlobalAddAtom(zEPSCOND  );      // Register Items
  140.     aEPS       = GlobalAddAtom(zEPS      );      //
  141.     aPS        = GlobalAddAtom(zPS       );      //
  142.     aSETCURSOR = GlobalAddAtom(zSETCURSOR);      //
  143.     wOperation = SPOOL_TO_FILE;                  //
  144.     State = SF_EPSCOND;                          // Set Initial state
  145.     nStartCol  = 0;                              // Initializes variables
  146.     nEndCol    = 0;                              //
  147.     nMaxCol    = 0;                              //
  148.     SPL_SetPsCond();                             // Start Finite State Machine
  149.   }                                              //
  150. }                                                //
  151.  
  152. //******************************************************************************
  153. //
  154. //  FSM_SpoolToFile - Finite State Machine for Spool To File
  155. //
  156. //  PURPOSE:
  157. //
  158. //
  159. //  COMMENTS:
  160. //
  161. //******************************************************************************
  162. void FSM_SpoolToFile( BYTE Event, ATOM aItem,  HANDLE hData )
  163. {                                                //
  164.   if (hData)                                     // receive new data?
  165.   {                                              //
  166.     if (hRcvData)                                // old data remains?
  167.     {                                            //
  168.       GlobalFree(hRcvData);                      // free it
  169.     }                                            //
  170.     hRcvData = hData;                            // save the handle
  171.   }                                              //
  172.   if ( ( (Event != EV_DATA) &&                   // check if item is correct
  173.          (Event != EV_ACK)  &&                   //
  174.          (Event != EV_NACK)    ) ||              //
  175.        (SPL_CheckItem(aItem)   )   )             //
  176.   {                                              //
  177.     State = FSM_SPL[State][Event];               // get new state
  178.     (*SPL_fns[State])();                         // process for new state
  179.   }                                              //
  180. }                                                //
  181.  
  182. //******************************************************************************
  183. //
  184. //  SPL_SetPsCond - Process in SF_EPSCOND state
  185. //
  186. //  PURPOSE: Set condition for getting a part of PS (from (1,31) to (1,50)).
  187. //
  188. //
  189. //  COMMENTS:
  190. //
  191. //******************************************************************************
  192. void SPL_SetPsCond( void )                       //
  193. {                                                //
  194.   PrepGetPartialPs ( 1, 29, 24 );                // Set PS service condition
  195. }                                                //
  196.  
  197. //******************************************************************************
  198. //
  199. //  SPL_GetPPs - Process in SF_GETPPS state
  200. //
  201. //  PURPOSE: Get a part of PS (from (1,29) to (1,53)).
  202. //
  203. //
  204. //  COMMENTS:
  205. //
  206. //******************************************************************************
  207. void SPL_GetPPs( void )                          //
  208. {                                                //
  209.   RequestGetPartPs();                            // Get partial PS
  210. }                                                //
  211.  
  212. //******************************************************************************
  213. //
  214. //  SPL_SetCsr - Process in SF_SETCSR state
  215. //
  216. //  PURPOSE: Set the cursor to the command line (3,22)
  217. //
  218. //
  219. //  COMMENTS:
  220. //
  221. //******************************************************************************
  222. void SPL_SetCsr( void )                          //
  223. {                                                //
  224.   lpDDE_EPS_CF_DSPTEXT  lpData;                  //
  225.   BOOL                  bFree;                   //
  226.   BOOL                  bAck;                    //
  227.   BOOL                  bValidPs = FALSE;        //
  228.                                                  //
  229.   if (hRcvData)                                  //
  230.   {                                              //
  231.     lpData = (lpDDE_EPS_CF_DSPTEXT) GlobalLock(hRcvData);
  232.     if (HIWORD(lpData) != (int)NULL)             //
  233.     {                                            //
  234.       bFree = lpData->DDEdata.fRelease;          // Save flags
  235.       bAck  = lpData->DDEdata.fAckReq;           //
  236.                                                  //
  237.       if (_fmemicmp(lpData->DDEeps.PSData,       //
  238.                     zTopIDJ,                     //
  239.                     lstrlen(zTopIDJ)) == (int)NULL) // Test for "âXâvü[âïüEâtâ@âCâïé╠ò\Ī"
  240.       {                                          //
  241.         bValidPs = TRUE;                         // Valid screen
  242.         bJpnMode = TRUE;                         // Screen is in Japanese
  243.       }                                          //
  244.       else if (_fmemicmp(&(lpData->DDEeps.PSData[2]),
  245.                          zTopID,                 //
  246.                          lstrlen(zTopID)) == (int)NULL) // Test for "DISPLAY SPOOLED FILE"
  247.       {                                          //
  248.         bValidPs = TRUE;                         // Valid screen
  249.         bJpnMode = FALSE;                        // Screen is in English
  250.       }                                          //
  251.                                                  //
  252.       GlobalUnlock(hRcvData);                    //
  253.                                                  //
  254.       if (bFree)                                 // Should be freed?
  255.       {                                          //
  256.         GlobalFree(hRcvData);                    // Free it
  257.         hRcvData = NULL;                         //
  258.       }                                          //
  259.       if (bAck)                                  // Must post ack to DDE server?
  260.       {                                          //
  261.         PostMessage (hSessWnd,                   //  Post DDE ACK message
  262.                      WM_DDE_ACK,                 //
  263.                      (WPARAM)hMainWnd,           //
  264.                      PackDDElParam(WM_DDE_ACK, DDE_ACK, aEPS) );  //
  265.       }                                          //
  266.                                                  //
  267.       if (bValidPs)                              // "Display Spool File" screen?
  268.       {                                          // Yes
  269.         LoadString(hGlobalInst,                  // put up modeless abort box
  270.                    LS_ABORT_TITLEF,              //
  271.                    zAbortTitle,                  //
  272.                    sizeof(zAbortTitle));         //
  273.         hAbortDialog = DisplayAbortDialog( hMainWnd );
  274.                                                  //
  275.         SetCursorPosition ( 3, 22 );             // Set the cursor position
  276.       }                                          //
  277.     }                                            //
  278.     else                                         //  GlobalLock Error
  279.     {                                            //
  280.       GlobalFree(hRcvData);                      //
  281.       hRcvData = NULL;                           //
  282.     }                                            //
  283.   }                                              //
  284.   if (!bValidPs)                                 // Not "Display Spool File" screen or
  285.   {                                              //  some error happens
  286.     LoadString(hGlobalInst,                      // put up modeless abort box
  287.                LS_ERROR3_TEXT,                   //
  288.                zMsgBuffer,                       //
  289.                sizeof(zMsgBuffer));              //
  290.     MessageBox(NULL,                             // Display error message
  291.                (LPSTR) zMsgBuffer,               //
  292.                (LPSTR) zSpoolToFileClassPrefix,  //
  293.                MB_OK | MB_ICONQUESTION );        //
  294.     PostMessage (hMainWnd,                       // post messgae for EV_ERROR
  295.                  WM_USER_ERROR,                  //
  296.                  (WPARAM)hMainWnd,               //
  297.                  MAKELONG(NULL, NULL) );         //
  298.   }                                              //
  299. }                                                //
  300.  
  301. //******************************************************************************
  302. //
  303. //  SPL_ToTop - Process in SF_TOTOP state
  304. //
  305. //  PURPOSE: Send "*TOP  " and Enter Key.
  306. //
  307. //
  308. //  COMMENTS:
  309. //
  310. //******************************************************************************
  311. void SPL_ToTop( void )                           //
  312. {                                                //
  313.   hFile = OpenFile(zPCFilename, &of, OF_CREATE); // Open file
  314.   if (hFile > 0)                                 //
  315.   {                                              //
  316.     ExecuteKeystrokes("\"*TOP  \", backtab, enter");  // Send keystrokes ("*TOP  ", backtab, enter)
  317.   }                                              //
  318.   else                                           //
  319.   {                                              //
  320.     LoadString(hGlobalInst,                      // put up modeless abort box
  321.                LS_ERROR4_TEXT,                   //
  322.                zMsgBuffer,                       //
  323.                sizeof(zMsgBuffer));              //
  324.     MessageBox(NULL,                             // Display error message
  325.                (LPSTR) zMsgBuffer,               //
  326.                (LPSTR) zSpoolToFileClassPrefix,  //
  327.                MB_OK | MB_ICONQUESTION );        //
  328.     PostMessage (hMainWnd,                       // post messgae for EV_ERROR
  329.                  WM_USER_ERROR,                  //
  330.                  (WPARAM)hMainWnd,               //
  331.                  MAKELONG(NULL, NULL) );         //
  332.   }                                              //
  333. }                                                //
  334.  
  335. //******************************************************************************
  336. //
  337. //  SPL_ToLeftEnd - Process in SF_TOLEFTEND state
  338. //
  339. //  PURPOSE: Send keystrokes ("W1    ", backtab, enter)
  340. //
  341. //
  342. //  COMMENTS:
  343. //
  344. //******************************************************************************
  345. void SPL_ToLeftEnd( void )                       //
  346. {                                                //
  347.   int  i;                                        //
  348.   ExecuteKeystrokes("\"W1    \", backtab, enter");  // Send keystrokes ("W1    ", backtab, enter)
  349.                                                  //
  350.   for (i=0; i<16; i++)                           // Initializes the table
  351.   {                                              // of Buffer pointor
  352.     BufferPtr[i] = 0;                            //
  353.   }                                              //
  354. }                                                //
  355.  
  356. //******************************************************************************
  357. //
  358. //  SPL_GetPs - Process in SF_GETPS state
  359. //
  360. //  PURPOSE: Get PS in CF_DSPTEXT format
  361. //
  362. //
  363. //  COMMENTS:
  364. //
  365. //******************************************************************************
  366. void SPL_GetPs( void )                           //
  367. {                                                //
  368.   RequestGetPs();                                // Get PS in CF\DSPTEXT format
  369. }                                                //
  370.  
  371. //******************************************************************************
  372. //
  373. //  SPL_IsRightEnd - Process in SF_ISRIGHTEND state
  374. //
  375. //  PURPOSE: Gather lines of Profs Note and determine if the right end of the
  376. //           note.
  377. //
  378. //  COMMENTS:
  379. //
  380. //******************************************************************************
  381. void SPL_IsRightEnd( void )                      //
  382. {                                                //
  383.   lpDDE_PS_CF_DSPTEXT  lpData;                   //
  384.   BOOL                 bFree;                    //
  385.   BOOL                 bAck;                     //
  386.   BOOL                 bEnd = FALSE;             //
  387.   int                  i,j;                      //
  388.   int                  nPtr;                     //
  389.   int                  offset;                   //
  390.                                                  //
  391.   if (hRcvData)                                  //
  392.   {                                              //
  393.     lpData = (lpDDE_PS_CF_DSPTEXT) GlobalLock(hRcvData);
  394.     if (HIWORD(lpData) != (int)NULL)             //
  395.     {                                            //
  396.       bFree = lpData->DDEdata.fRelease;          // save flags
  397.       bAck  = lpData->DDEdata.fAckReq;           //
  398.                                                  //
  399.       GetStartEndCol( (LPSTR)&(lpData->DDEps.PSData[OffsetInPs(3, 67)]),
  400.                       (LPINT)&nStartCol,         // Retrieve the start and end
  401.                       (LPINT)&nEndCol );         //  column numbers
  402.       if (nMaxCol > 0)                           // Already max Column number
  403.       {                                          //  has been deterimend?
  404.         if (nEndCol == nMaxCol)                  // compare with it
  405.         {                                        //
  406.           bEnd = TRUE;                           // Reached the right edge
  407.         }                                        //
  408.       }                                          //
  409.       else                                       // The very first line
  410.       {                                          //
  411.         if ((nEndCol - nStartCol) < 74 )         // text truncated in the middle
  412.         {                                        //  of screen?
  413.           nMaxCol = nEndCol;                     // found the max column number
  414.           bEnd = TRUE;                           //
  415.         }                                        //
  416.         else                                     //
  417.         {                                        //
  418.           if ((nEndCol - nStartCol) == 74)       // 74 columns per row displayed?
  419.           {                                      //
  420.             bDbcsText = TRUE;                    // Japanes file
  421.           }                                      //
  422.           else                                   //
  423.           {                                      //
  424.             bDbcsText = FALSE;                   // English file
  425.           }                                      //
  426.         }                                        //
  427.       }                                          //
  428.                                                  //
  429.       for (i=6; i<22; i++)                       // Gathers text lines
  430.       {                                          //
  431.         if (bDbcsText)                           // Japanese Text?
  432.         {                                        //
  433.           offset = OffsetInPs(i, 2);             //
  434.           nPtr = BufferPtr[i-6];                 //
  435.           if ( (lpData->DDEps.PSData[offset] == ' ' ) ||
  436.                (lpData->DDEps.PSData[offset] == 0x0e)    )
  437.           {                                      // Check if this line starts
  438.             j=0;                                 //  from DBCS 2nd byte
  439.             if (nPtr > 0)                        //
  440.             {                                    //
  441.               nPtr--;                            //
  442.             }                                    //
  443.           }                                      //
  444.           else                                   //
  445.           {                                      //
  446.             j=1;                                 //
  447.           }                                      //
  448.           for (; j <= (nEndCol-nStartCol); j++)  // retrieve each line of  data
  449.           {                                      //
  450.             if (IsSoSi(lpData->DDEps.PSData[offset+j+1]))
  451.             {                                    // SO/SI character?
  452.               if (j == (nEndCol - nStartCol))    // Last position?
  453.               {                                  //
  454.                 nPtr++;                          // adjust write pointor
  455.               }                                  //  for future use
  456.               else                               //
  457.               {                                  //
  458.                 if (!bRemoveSoSi)                // SO/SI remove?
  459.                 {                                //
  460.                   PsBuffer[i-6][nPtr] = lpData->DDEps.PSData[offset+j+1];
  461.                   nPtr++;                        //
  462.                 }                                //
  463.               }                                  //
  464.             }                                    //
  465.             else                                 // not SO/SI character
  466.             {                                    //
  467.               if (IsDbcsHiByte(lpData->DDEps.PSData[offset+j+1]))
  468.               {                                  // DBCS 1st byte?
  469.                 PsBuffer[i-6][nPtr] = lpData->DDEps.PSData[offset+j+1];
  470.                 nPtr++;                          //
  471.                 j++;                             //
  472.                 PsBuffer[i-6][nPtr] = lpData->DDEps.PSData[offset+j+1];
  473.                 nPtr++;                          //
  474.               }                                  //
  475.               else                               // SBCS character
  476.               {                                  //
  477.                 PsBuffer[i-6][nPtr] = lpData->DDEps.PSData[offset+j+1];
  478.                 nPtr++;                          //
  479.               }                                  //
  480.             }                                    //
  481.           }                                      //
  482.           BufferPtr[i-6] = nPtr;                 // save write pointer
  483.         }                                        //
  484.         else                                     // English Text
  485.         {                                        //
  486.           offset = OffsetInPs(i, 2);             //
  487.           nPtr = BufferPtr[i-6];                 //
  488.           if (nPtr > 0)                          //
  489.           {                                      //
  490.             nPtr--;                              //
  491.           }                                      //
  492.           for (j=0; j <= (nEndCol-nStartCol); j++) // copy one line data
  493.           {                                      //
  494.             PsBuffer[i-6][nPtr] = lpData->DDEps.PSData[offset+j];
  495.             nPtr++;                              //
  496.           }                                      //
  497.           BufferPtr[i-6] = nPtr;                 // save write pointer
  498.         }                                        //
  499.       }                                          //
  500.                                                  //
  501.       if (bEnd)                                  // reached the right edge?
  502.       {                                          //
  503.          offset = OffsetInPs(22, 74);            //
  504.          for (i = 0; i < 6; i++)                 // Save "More..." or "BOTTOM"
  505.          {                                       //
  506.             Footor[i] = lpData->DDEps.PSData[offset+i];  //
  507.          }                                       //
  508.          Footor[6] = 0;                          //
  509.          for (i=0; i < 16; i++)                  // Write data to disk
  510.          {                                       //
  511.            nPtr = BufferPtr[i];                  //
  512.            PsBuffer[i][nPtr] = 0x0d;             //
  513.            nPtr++;                               //
  514.            PsBuffer[i][nPtr] = 0x0a;             //
  515.            nPtr++;                               //
  516.            _lwrite (hFile, PsBuffer[i], (WORD)nPtr );
  517.          }                                       //
  518.       }                                          //
  519.                                                  //
  520.       GlobalUnlock(hRcvData);                    //
  521.                                                  //
  522.       if (bFree)                                 // Should be freed?
  523.       {                                          //
  524.         GlobalFree(hRcvData);                    //
  525.         hRcvData = NULL;                         //
  526.       }                                          //
  527.       if (bAck)                                  // Must post ack to DDE server?
  528.       {                                          //
  529.         PostMessage (hSessWnd,                   //
  530.                      WM_DDE_ACK,                 //
  531.                      (WPARAM)hMainWnd,           //
  532.                      PackDDElParam(WM_DDE_ACK, DDE_ACK, aPS) );   //
  533.       }                                          //
  534.                                                  //
  535.       if (bEnd)                                  // Reached the right edge ?
  536.       {                                          //
  537.         PostMessage (hMainWnd,                   // post messgae for EV_BRK
  538.                      WM_USER_BREAK,              //
  539.                      (WPARAM)hMainWnd,           //
  540.                      MAKELONG(NULL, NULL) );     //
  541.       }                                          //
  542.       else                                       //
  543.       {                                          //
  544.         PostMessage (hMainWnd,                   // post messgae for EV_CONT
  545.                      WM_USER_CONT,               //
  546.                      (WPARAM)hMainWnd,           //
  547.                      MAKELONG(NULL, NULL) );     //
  548.       }                                          //
  549.     }                                            //
  550.     else                                         //
  551.     {                                            //
  552.       GlobalFree(hRcvData);                      //
  553.       hRcvData = NULL;                           //
  554.     }                                            //
  555.   }                                              //
  556. }                                                //
  557.  
  558. //******************************************************************************
  559. //
  560. //  SPL_ToRignt - Process in SF_TORIGHT state
  561. //
  562. //  PURPOSE: Send "Wnnn  " and Enter Key.
  563. //
  564. //
  565. //  COMMENTS:
  566. //
  567. //******************************************************************************
  568. void SPL_ToRight( void )                         //
  569. {                                                //
  570.   char   Temp[50];                               //
  571.                                                  //
  572.   lstrcpy (Temp, "\"W     \", backtab, enter");  //
  573.                                                  //
  574.   if (nEndCol >= 100)                            //
  575.   {                                              //
  576.     Temp[2] = (char)('0' + nEndCol/100);         //
  577.     Temp[3] = (char)('0' + (nEndCol%100)/10);    //
  578.     Temp[4] = (char)('0' + (nEndCol%10));        //
  579.   }                                              //
  580.   else                                           //
  581.   {                                              //
  582.     Temp[2] = (char)('0' + (nEndCol%100)/10);    //
  583.     Temp[3] = (char)('0' + (nEndCol%10));        //
  584.   }                                              //
  585.   ExecuteKeystrokes( (LPSTR)Temp );              // Send keystrokes ("Wnnn  ", backtab, enter)
  586. }                                                //
  587.  
  588. //******************************************************************************
  589. //
  590. //  SPL_IsEnd - Process in SF_ISEND state
  591. //
  592. //  PURPOSE: Gather lines of Profs Note and determine if the end of the note
  593. //
  594. //
  595. //  COMMENTS:
  596. //
  597. //******************************************************************************
  598. void SPL_IsEnd( void )                           //
  599. {                                                //
  600.   BOOL   bCont = TRUE;                           //
  601.                                                  //
  602.   if (bJpnMode)                                  // Is screen in Japanese?
  603.   {                                              //
  604.     Footor[4] = 0x00;                            // Compare with "ÅIéΦ"
  605.     if ( !lstrcmpi( (LPSTR)Footor, (LPSTR)zBottomIDJ ) )
  606.     {                                            //
  607.       bCont = FALSE;                             //
  608.     }                                            //
  609.   }                                              //
  610.   else                                           // In English
  611.   {                                              //
  612.     if ( !lstrcmpi( (LPSTR)Footor, (LPSTR)zBottomID ) )
  613.     {                                            // Compare with "BOTTOM"
  614.       bCont = FALSE;                             //
  615.     }                                            //
  616.   }                                              //
  617.                                                  //
  618.   if (bCont)                                     //
  619.   {                                              //
  620.     PostMessage (hMainWnd,                       // post messgae for EV_CONT
  621.                  WM_USER_CONT,                   //
  622.                  (WPARAM)hMainWnd,               //
  623.                  MAKELONG(NULL, NULL) );         //
  624.   }                                              //
  625.   else                                           //
  626.   {                                              //
  627.     PostMessage (hMainWnd,                       // post messgae for EV_BRK
  628.                  WM_USER_BREAK,                  //
  629.                  (WPARAM)hMainWnd,               //
  630.                  MAKELONG(NULL, NULL) );         //
  631.   }                                              //
  632. }                                                //
  633.  
  634. //******************************************************************************
  635. //
  636. //  SPL_RollUp - Process in SF_ROLLUP state
  637. //
  638. //  PURPOSE: Send "Roll Up" keystroke.
  639. //
  640. //
  641. //  COMMENTS:
  642. //
  643. //******************************************************************************
  644. void SPL_RollUp( void )                          //
  645. {                                                //
  646.   ExecuteKeystrokes("roll up");                  // Send keystroke (RollUp key)
  647. }                                                //
  648.  
  649. //******************************************************************************
  650. //
  651. //  SPL_AbortPend - Process in SF_ABORT state
  652. //
  653. //  PURPOSE: Wait for WM_DDE_DATA or WM_DDE_ACK, and then abort printing.
  654. //
  655. //
  656. //  COMMENTS:
  657. //
  658. //******************************************************************************
  659. void SPL_AbortPend( void )                       //
  660. {                                                //
  661.   if (hAbortDialog)                              // Abort DialogBox displayed?
  662.   {                                              //
  663.     DestroyAbortDialog(hAbortDialog, hMainWnd);  // Destroy it
  664.     hAbortDialog = NULL;                         //
  665.   }                                              //
  666. }                                                //
  667.  
  668. //******************************************************************************
  669. //
  670. //  SPL_Terminate - Process in SF_TERM state
  671. //
  672. //  PURPOSE: Terminate session conversation.
  673. //
  674. //
  675. //  COMMENTS:
  676. //
  677. //******************************************************************************
  678. void SPL_Terminate( void )                       //
  679. {                                                //
  680.   if (hFile > 0)                                 //
  681.   {                                              //
  682.     _lclose(hFile);                              //
  683.     hFile = -1;                                  //
  684.   }                                              //
  685.   if (hRcvData)                                  // data remains?
  686.   {                                              //
  687.     GlobalFree(hRcvData);                        // Free it
  688.     hRcvData = NULL;                             //
  689.   }                                              //
  690.   if (hAbortDialog)                              // Abort DialogBox displayed?
  691.   {                                              //
  692.     DestroyAbortDialog(hAbortDialog, hMainWnd);  // Destroy it
  693.     hAbortDialog = NULL;                         //
  694.   }                                              //
  695.   GlobalDeleteAtom(aSETCURSOR);                  // Unregister items
  696.   GlobalDeleteAtom(aPS       );                  //
  697.   GlobalDeleteAtom(aEPS      );                  //
  698.   GlobalDeleteAtom(aEPSCOND  );                  //
  699.   TerminateSession();                            // terminate session conversation
  700.   wOperation = (unsigned short)NULL;             //
  701. }                                                //
  702.  
  703. //******************************************************************************
  704. //
  705. //  SPL_CheckItem - Check the item is proper to the current state
  706. //
  707. //  PURPOSE: Determine if the ATOM value is correct or not.
  708. //
  709. //
  710. //  COMMENTS:
  711. //
  712. //******************************************************************************
  713. BOOL SPL_CheckItem( ATOM aItem )                 //
  714. {                                                //
  715.   BOOL   bRC = FALSE;                            //
  716.                                                  //
  717.   switch (State)                                 //
  718.   {                                              //
  719.     case SF_EPSCOND:                             //
  720.       if (aItem == aEPSCOND)                     //
  721.       {                                          //
  722.         bRC = TRUE;                              //
  723.       }                                          //
  724.       break;                                     //
  725.                                                  //
  726.     case SF_GETPPS:                              //
  727.       if (aItem == aEPS)                         //
  728.       {                                          //
  729.         bRC = TRUE;                              //
  730.       }                                          //
  731.       break;                                     //
  732.                                                  //
  733.     case SF_GETPS:                               //
  734.       if (aItem == aPS)                          //
  735.       {                                          //
  736.         bRC = TRUE;                              //
  737.       }                                          //
  738.       break;                                     //
  739.                                                  //
  740.     case SF_SETCSR:                              //
  741.       if (aItem == aSETCURSOR)                   //
  742.       {                                          //
  743.         bRC = TRUE;                              //
  744.       }                                          //
  745.       break;                                     //
  746.                                                  //
  747.     case SF_TOTOP:                               //
  748.     case SF_TOLEFTEND:                           //
  749.     case SF_ISRIGHTEND:                          //
  750.     case SF_TORIGHT:                             //
  751.     case SF_ISEND:                               //
  752.     case SF_ROLLUP:                              //
  753.     case SF_ABORT:                               //
  754.     case SF_TERM:                                //
  755.       bRC = TRUE;                                //
  756.       break;                                     //
  757.                                                  //
  758.     default:                                     //
  759.       break;                                     //
  760.   }                                              //
  761.   return (bRC);                                  //
  762. }                                                //
  763.