home *** CD-ROM | disk | FTP | other *** search
/ kermit.columbia.edu / kermit.columbia.edu.tar / kermit.columbia.edu / win100 / win19m.c < prev    next >
C/C++ Source or Header  |  1991-10-19  |  20KB  |  866 lines
  1. /*
  2.  * Windows H19 Terminal Emulator - less frequently used functions
  3.  * 
  4.  * Written by William S. Hall
  5.  *          3665 Benton Street, #66
  6.  *          Santa Clara, CA 95051
  7.  */
  8.  
  9. #define NOKANJI
  10. #define NOATOM
  11. #define NOMINMAX
  12. #include <windows.h>
  13. #include <limits.h>
  14. #include <string.h>
  15. #include <stdlib.h>
  16.  
  17. #include "winasc.h"
  18. #include "winh19.h"
  19. #include "win19d.h"
  20.  
  21. /* local functions */
  22. static void NEAR LoadBuf(BYTE FAR *dest, BYTE FAR *source, int count);
  23. static void NEAR LoadOneLine(BYTE FAR *, BYTE *, short, BOOL);
  24. static void NEAR LoadPrefixAndData(int, int, BYTE *, BYTE FAR *, int);
  25. static void NEAR TermParamInit(HWND hDlg);
  26. static void NEAR TermParamSet(HWND hDlg);
  27. static void NEAR SaveCommParams(void);
  28. static void NEAR SetDefaultPort(void);
  29. static void NEAR StringOp(HWND hDlg, WORD param);
  30.  
  31. /* about box window procedure */
  32. BOOL FAR PASCAL AboutBoxProc(hDlg, message, wParam, lParam)
  33. HWND hDlg;
  34. unsigned message;
  35. WORD wParam;
  36. LONG lParam;
  37. {
  38.  
  39.     switch (message) {
  40.     case WM_INITDIALOG:
  41.         break;
  42.     case WM_COMMAND:
  43.         switch (wParam) {
  44.         case IDOK:
  45.         case IDCANCEL:
  46.             EndDialog(hDlg,TRUE);
  47.             break;
  48.         default:
  49.             return FALSE;
  50.         }
  51.         break;
  52.  
  53.     default:
  54.         return FALSE;
  55.     }
  56.     return TRUE;
  57. }
  58.  
  59. /* close communications port */
  60. void CloseCommPort(HWND hWnd, short *pCid)
  61. {
  62.  
  63.     if (*pCid >=0) {
  64.         if (CloseComm(*pCid) >= 0)
  65.             *pCid = INT_MIN;
  66.     else 
  67.         ShowMessage(hWnd, IDS_CANNOTCLOSECOM);
  68.     }
  69. }
  70.  
  71. /* show message box */
  72. void ShowMessage(HWND hWnd, int msgnum)
  73. {
  74.  
  75.     char szMessage[80];
  76.  
  77.     LoadString(hInst, msgnum, (LPSTR)szMessage,sizeof(szMessage));
  78.     
  79.     MessageBox(hWnd,(LPSTR)szMessage, (LPSTR)szAppName, 
  80.         MB_ICONHAND | MB_OK);
  81.  
  82. }
  83.  
  84. /* reset the terminal to power up */
  85. void ResetTerminal()
  86. {
  87.  
  88.     BOOL *ptr, *ptr1;
  89.     int i;
  90.  
  91.     SendMessage(hWndActive,WH19_CARETFUNCTION,
  92.             H19_DESTROYCARET,(LONG)CD.OwnCaret);
  93.     hWndActive = TW.hWnd;
  94.  
  95.     ptr = &CD.BlockCursor;
  96.     ptr1 = &S402.BlockCursor;
  97.     for (i = 0; i < 8; i++)
  98.     *ptr++ = *ptr1++;
  99.  
  100.     ProcessResetCommand(1);    /* turn off status line */
  101.  
  102.     CD.InverseVideo = FALSE;
  103.     CD.GraphicsMode = FALSE;
  104.     CD.ICToggle = FALSE;
  105.     CD.HoldScreen = FALSE;
  106.     CD.CursorOff = FALSE;
  107.     CD.KeyboardDisabled = FALSE;
  108.     CD.AltKeypad = FALSE;
  109.     CD.CommandState = NO_COMMAND;
  110.     CD.CurSaveRow = CD.CurSaveCol = 0;
  111.  
  112.     SendMessage(hWndActive, WH19_COMMAND, H19_CLRSCREEN,0L);
  113.  
  114.     CommData.BaudRate = S401.BaudRate;
  115.     CommData.ByteSize = S401.ByteSize;
  116.     CommData.Parity = S401.Parity;
  117.     CommData.StopBits = S401.StopBits;
  118.  
  119.     if ( SetCommState((DCB FAR *)&CommData) < 0)
  120.     ShowMessage(MW.hWnd, IDS_NOCOMSET);
  121.  
  122.     SendMessage(hWndActive,WH19_CARETFUNCTION,
  123.             H19_CREATECARET,(LONG)CD.OwnCaret);
  124.  
  125. }
  126.  
  127. /* transmit status line */
  128. void SendStatusLine(PTWND pSW)
  129. {
  130.  
  131.     BYTE outstr[2];
  132.     BYTE FAR *lpgBuf;
  133.     register short cols = pSW->MaxCols;
  134.     
  135.     if ((CD.StatOpen) && (CD.LineState == IDM_ONLINE)) {
  136.     if (GB.hBuf == NULL) {
  137.         if (CD.ANSIMode)
  138.         GB.lBufSize = 10 * cols + 2;
  139.         else 
  140.             GB.lBufSize = 5 * cols + 2;
  141.         GB.hBuf = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,GB.lBufSize);
  142.         if (GB.hBuf != NULL) {
  143.         GB.lBufHead = GB.lBufTail = 0;
  144.             lpgBuf = GlobalLock(GB.hBuf);
  145.         LoadOneLine(lpgBuf, pSW->pVidBuffer, cols, TRUE);
  146.         outstr[0] = CR;
  147.             LoadBuf(lpgBuf + GB.lBufTail, (BYTE FAR *)outstr,1);
  148.             GB.lBufTail += 1;
  149.         GlobalUnlock(GB.hBuf);
  150.         }
  151.     }
  152.     }
  153.     MessageBeep(0);
  154. }
  155.  
  156. /* transmit screen contents */
  157. void SendScreen(PTWND pTW)
  158. {
  159.  
  160.     short lines = pTW->MaxLines;
  161.     register short cols = pTW->MaxCols; 
  162.     BYTE *pBuf = pTW->pVidBuffer;
  163.     BYTE *lineptr = pBuf + pTW->oTopLine;
  164.     BYTE *pEnd = pBuf + pTW->oVidLastLine;
  165.     register int i;
  166.     BYTE outstr[2];
  167.     BYTE FAR *lpgBuf;
  168.     int state;
  169.  
  170.     if (CD.LineState == IDM_ONLINE) {
  171.     if (GB.hBuf == NULL) {
  172.         if (CD.ANSIMode)
  173.             GB.lBufSize = 10 * pTW->ScreenSize + 2;
  174.         else
  175.         GB.lBufSize = 5 * pTW->ScreenSize  + 2;
  176.         GB.hBuf = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT,GB.lBufSize);
  177.         if (GB.hBuf != NULL) {
  178.         GB.lBufHead = GB.lBufTail = 0;
  179.             lpgBuf = GlobalLock(GB.hBuf);
  180.             for (i = 0; i < lines; i++) {
  181.             if (i == 0)
  182.             state = TRUE;
  183.             else
  184.             state = FALSE;
  185.             LoadOneLine(lpgBuf, lineptr, cols, state);
  186.             if ((lineptr += cols) >pEnd)
  187.                     lineptr = pBuf;
  188.         }
  189.         outstr[0] = CR;
  190.             LoadBuf(lpgBuf + GB.lBufTail, (BYTE FAR *)outstr,1);
  191.             GB.lBufTail += 1;
  192.         GlobalUnlock(GB.hBuf);
  193.         }
  194.     }
  195.     }
  196.     MessageBeep(0);
  197. }
  198.  
  199. /* transmit screen support arrays */
  200. #define NC    0
  201. #define NG    1
  202. #define IC    2
  203. #define IG    3
  204.  
  205. /* old mode across, new mode down */
  206. static BYTE *ANSITransitionCmd[4][4] = {
  207.     "",        "\033[11m",    "\033[m",    "\033[11m\033[m",
  208.     "\033[10m",    "",        "\033[m\033[10m","\033[m",
  209.     "\033[7m",    "\033[11m\033[7m","",        "\033[11m",
  210.     "\033[10m\033[7m","\033[7m","\033[10m",    "",
  211. };
  212. static BYTE *HeathTransitionCmd[4][4] = {
  213.     "",        "\033G",    "\033q",    "\033G\033q",
  214.     "\033F",    "",        "\033F\033q",    "\033q",
  215.     "\033p",    "\033G\033p",    "",        "\033G",
  216.     "\033F\033p","\033p",    "\033F",    "",
  217. };
  218.  
  219. /* load a line into the global buffer and add escape codes */
  220. static void NEAR LoadOneLine(BYTE FAR *lpgBuf,BYTE *pBuf,
  221.             short len,BOOL resetflag)
  222. {
  223.  
  224.     BYTE tBuf[TERMMAXCOLS + 10];
  225.     int i = 0;
  226.     short linewidth = len;
  227.     register int j;
  228.     register BYTE ch;
  229.     static int oldmode, newmode;
  230.  
  231.     if (resetflag)
  232.     newmode = NC;
  233.  
  234.     while (i < linewidth) {
  235.     for (j = 0; j < linewidth - i; j++) {
  236.         if (((ch = *pBuf) < DEL) && (ch >= SP)) {    /* normal */
  237.         tBuf[j] = ch;
  238.         pBuf++;
  239.         }
  240.         else
  241.         break;
  242.     }
  243.     if (j > 0) {
  244.         oldmode = newmode;
  245.         newmode = NC;
  246.         LoadPrefixAndData(oldmode, newmode, tBuf, lpgBuf, j);
  247.         i += j;
  248.     }
  249.         for (j = 0; j < linewidth - i; j++) {
  250.         if (((ch = *pBuf) < 255) && (ch >= 160)) {    /* inverse */
  251.         tBuf[j] = ch & 0x7f;
  252.         pBuf++;
  253.         }
  254.         else
  255.         break;
  256.     }
  257.     if (j > 0) {
  258.         oldmode = newmode;
  259.         newmode = IC;
  260.         LoadPrefixAndData(oldmode, newmode, tBuf, lpgBuf, j);
  261.         i += j;
  262.     }
  263.         for (j = 0; j < linewidth - i; j++) {        /* normal graphics */
  264.         if ( (((ch = *pBuf) < SP) && (ch >= 0)) || (ch == DEL)) {
  265.         tBuf[j] = (ch == DEL ? ch - 1 : ch + 94);
  266.         pBuf++;
  267.         }
  268.         else
  269.         break;
  270.     }
  271.     if (j > 0) {
  272.         oldmode = newmode;
  273.         newmode = NG;
  274.         LoadPrefixAndData(oldmode, newmode, tBuf, lpgBuf, j);
  275.         i += j;
  276.     }
  277.         for (j = 0; j < linewidth - i; j++) {        /* inverse graphics */
  278.         if ( (((ch = *pBuf) < 160) && (ch > DEL)) || (ch == 255)) {
  279.         ch &= 0x7f;
  280.         tBuf[j] = (ch == DEL ? ch - 1 : ch + 94);
  281.         pBuf++;
  282.         }
  283.         else
  284.         break;
  285.     }
  286.     if (j > 0) {
  287.         oldmode = newmode;
  288.         newmode = IG;
  289.         LoadPrefixAndData(oldmode, newmode, tBuf, lpgBuf, j);
  290.         i += j;
  291.     }
  292.     }
  293. }
  294.  
  295. /* support routine for load one line */
  296. static void NEAR LoadPrefixAndData(int oldmode, int newmode, 
  297.                     BYTE *tBuf, BYTE FAR * lpgBuf, int j)
  298. {
  299.  
  300.     register short cmdlen;
  301.     register BYTE *cmdstr;
  302.  
  303.     if (CD.ANSIMode)
  304.         cmdstr = ANSITransitionCmd[newmode][oldmode];
  305.     else 
  306.     cmdstr = HeathTransitionCmd[newmode][oldmode];
  307.     cmdlen = strlen(cmdstr);
  308.     LoadBuf(lpgBuf + GB.lBufTail, (BYTE FAR *)cmdstr, cmdlen);
  309.     GB.lBufTail += cmdlen;
  310.     LoadBuf(lpgBuf + GB.lBufTail, (BYTE FAR *)tBuf, j);
  311.     GB.lBufTail += j;
  312. }
  313.  
  314. /* long pointer strncpy */
  315. static void NEAR LoadBuf(BYTE FAR *dest, BYTE FAR *source, int count)
  316. {
  317.  
  318.     register int i;
  319.  
  320.     for (i = 0; i < count; i++)
  321.     *dest++ = *source++;
  322. }    
  323.  
  324. /* dialog box support variables and functions */
  325. static int bytesizeindex;
  326. static int parityindex;
  327. static int commportindex;
  328. static BOOL NEAR SetCommValues(HWND hDlg);
  329. static void NEAR InitCommParams(HWND hDlg);
  330. static WORD GetBaudRateID(WORD rate);
  331.  
  332. /* dialog box handler to set communications parameters */
  333. BOOL FAR PASCAL SetCommParams(hDlg, message, wParam, lParam)
  334. HWND hDlg;
  335. unsigned message;
  336. WORD wParam;
  337. LONG lParam;
  338. {
  339.  
  340.     int result;
  341.  
  342.     switch (message) {
  343.     case WM_INITDIALOG:
  344.         InitCommParams(hDlg);
  345.         break;
  346.  
  347.     case WM_COMMAND:
  348.         switch (wParam) {
  349.  
  350.         case IDD_BAUDRATE:
  351.             if (HIWORD(lParam) == EN_CHANGE) {
  352.                 result = GetDlgItemInt(hDlg,IDD_BAUDRATE, 
  353.                         (LONG)NULL, FALSE);
  354.             CheckRadioButton(hDlg, IDD_110, IDD_OTHER,
  355.                         GetBaudRateID(result));
  356.             }
  357.             break;
  358.             
  359.         case IDOK:
  360.             result = SetCommValues(hDlg);
  361.             if (result)
  362.                 EndDialog(hDlg, TRUE);
  363.             break;
  364.         
  365.         case IDCANCEL:
  366.             EndDialog(hDlg, FALSE);
  367.             break;
  368.  
  369.         case IDD_COM1:
  370.         case IDD_COM2:
  371.             CheckRadioButton(hDlg, IDD_COM1, IDD_COM2, wParam);
  372.             commportindex = wParam;
  373.             break;
  374.  
  375.         case IDD_7BIT:
  376.         case IDD_8BIT:
  377.             CheckRadioButton(hDlg, IDD_7BIT, IDD_8BIT, wParam);
  378.             bytesizeindex = wParam;
  379.             break;
  380.  
  381.         case IDD_NONE:
  382.         case IDD_ODD:
  383.         case IDD_EVEN:
  384.         case IDD_MARK:
  385.         case IDD_SPACE:
  386.             parityindex = wParam;
  387.             CheckRadioButton(hDlg, IDD_NONE, IDD_SPACE, wParam);
  388.             break;
  389.  
  390.         case IDD_110:
  391.         case IDD_150:
  392.         case IDD_300:
  393.         case IDD_600:
  394.         case IDD_1200:
  395.         case IDD_1800:
  396.         case IDD_2000:
  397.         case IDD_2400:
  398.         case IDD_3600:
  399.         case IDD_4800:
  400.         case IDD_7200:
  401.         case IDD_9600:
  402.         case IDD_19200:
  403.             SetDlgItemInt(hDlg, IDD_BAUDRATE, 
  404.                     BaudRateTable[wParam - IDD_110], FALSE);
  405.             break;
  406.         case IDD_OTHER:
  407.             CheckRadioButton(hDlg, IDD_110, IDD_OTHER, wParam);
  408.             SetFocus(GetDlgItem(hDlg,IDD_BAUDRATE));
  409.             break;
  410.  
  411.         case IDD_SAVE:
  412.         case IDD_DEFPORT:
  413.             if (IsDlgButtonChecked(hDlg, wParam))
  414.             CheckDlgButton(hDlg, wParam, FALSE);
  415.             else
  416.             CheckDlgButton(hDlg, wParam, TRUE);
  417.               break;
  418.  
  419.         default:
  420.             return FALSE;
  421.         }
  422.         break;
  423.  
  424.     default:
  425.         return FALSE;
  426.     }
  427.     return TRUE;
  428. }
  429.  
  430. /* set DCB */
  431. static BOOL NEAR SetCommValues(HWND hDlg)
  432. {
  433.  
  434.     int result;
  435.     WORD oldbaud;
  436.     BYTE oldstop;
  437.     BYTE oldparity;
  438.     BYTE oldbytesize;
  439.     BYTE newport, oldport;
  440.     char comstr[10];
  441.     short newcid;
  442.     char wintitle[WINTITLELEN];
  443.         
  444.     oldbaud = CommData.BaudRate;
  445.     oldbytesize = CommData.ByteSize;
  446.     oldparity = CommData.Parity;
  447.     oldstop = CommData.StopBits;
  448.     oldport = CommData.Id;
  449.     
  450.     newport = (BYTE)(commportindex - IDD_COM1);
  451.     if (newport != oldport) {
  452.         LoadString(hInst, IDS_COM1 + newport, (LPSTR)comstr, sizeof(comstr));
  453.     newcid = OpenComm((LPSTR)comstr, RXQUESIZE, TXQUESIZE);
  454.     if (newcid >= 0) {
  455.         CloseCommPort(hDlg, &cid);
  456.         if (cid == INT_MIN) {
  457.         cid = newcid;
  458.             CommData.Id = (BYTE)cid;
  459.             LoadString(hInst,IDS_WINTITLE,(LPSTR)wintitle,sizeof(wintitle));
  460.         strcat(wintitle,comstr);
  461.         SetWindowText(MW.hWnd, (LPSTR)wintitle);                
  462.         }
  463.         else {
  464.         CloseCommPort(hDlg, &newcid);
  465.             ShowMessage(hDlg, IDS_CANNOTCHANGEPORT);
  466.         return FALSE;
  467.         }
  468.     }
  469.     else {
  470.         ShowMessage(hDlg, IDS_CANNOTCHANGEPORT);
  471.         return FALSE;
  472.     }
  473.     }
  474.  
  475.     CommData.BaudRate = GetDlgItemInt(hDlg,IDD_BAUDRATE, (LONG)NULL, FALSE);
  476.     CommData.ByteSize = (BYTE)(bytesizeindex - IDD_7BIT + 7);
  477.     CommData.Parity = (BYTE)(parityindex - IDD_NONE);
  478.     if (CommData.BaudRate <= 110)
  479.     CommData.StopBits = TWOSTOPBITS;
  480.     else
  481.     CommData.StopBits = ONESTOPBIT;
  482.  
  483.     result = SetCommState((DCB FAR *)&CommData);
  484.  
  485.     if (result == 0) {
  486.     if (IsDlgButtonChecked(hDlg, IDD_SAVE))
  487.         SaveCommParams();
  488.         if (IsDlgButtonChecked(hDlg, IDD_DEFPORT))
  489.         SetDefaultPort();
  490.     return TRUE;
  491.     }
  492.     else {
  493.     CommData.BaudRate = oldbaud;
  494.     CommData.ByteSize = oldbytesize;
  495.     CommData.Parity = oldparity;
  496.     CommData.StopBits = oldstop;
  497.     SetCommState((DCB FAR *)&CommData);
  498.     InitCommParams(hDlg);
  499.         ShowMessage(hDlg, IDS_NOCOMSET);
  500.     return FALSE;
  501.     }
  502. }
  503.  
  504. /* set up a default port */
  505. static void NEAR SetDefaultPort()
  506. {
  507.     char keystr[10];
  508.     char valstr[10];
  509.     int val1, val2;
  510.  
  511.     if (commportindex == IDD_COM1) {
  512.     val1 = IDS_COM1;
  513.     val2 = IDS_COM2;
  514.     }
  515.     else {
  516.     val1 = IDS_COM2;
  517.     val2 = IDS_COM1;
  518.     }
  519.     
  520.     LoadString(hInst, IDS_FIRSTPORT, (LPSTR)keystr, sizeof(keystr));
  521.     LoadString(hInst, val1, (LPSTR)valstr, sizeof(valstr));
  522.     WriteProfileString((LPSTR)szAppName,(LPSTR)keystr,(LPSTR)valstr);
  523.     LoadString(hInst, IDS_SECONDPORT, (LPSTR)keystr, sizeof(keystr));
  524.     LoadString(hInst, val2, (LPSTR)valstr, sizeof(valstr));
  525.     WriteProfileString((LPSTR)szAppName,(LPSTR)keystr,(LPSTR)valstr);
  526.  
  527.     BroadcastWinIniChange();
  528. }
  529.  
  530. /* save parameters to win.ini */
  531. static void NEAR SaveCommParams()
  532. {
  533.     char keystr[10];
  534.     char valstr[30];
  535.     int portval;
  536.  
  537.     S401.BaudRate = CommData.BaudRate;
  538.     S401.ByteSize = CommData.ByteSize;
  539.     S401.Parity = CommData.Parity;
  540.     S401.StopBits = CommData.StopBits;
  541.  
  542.     portval = commportindex - IDD_COM1;
  543.     LoadString(hInst, IDS_COM1 + portval, (LPSTR)keystr, sizeof(keystr));
  544.     itoa(CommData.BaudRate, valstr, 10);
  545.  
  546.     switch (CommData.Parity) {
  547.     case EVENPARITY:
  548.         strcat(valstr, ",e");
  549.         break;
  550.     case ODDPARITY:
  551.         strcat(valstr, ",o");
  552.         break;
  553.     default:
  554.         strcat(valstr, ",n");
  555.         break;
  556.     }
  557.  
  558.     if (CommData.ByteSize == 8)
  559.     strcat(valstr, ",8");
  560.     else
  561.         strcat(valstr, ",7");
  562.  
  563.     if (CommData.BaudRate <= 110)
  564.     strcat(valstr, ",2");
  565.     else
  566.     strcat(valstr, ",1");
  567.  
  568.     WriteProfileString((LPSTR)szAppName,(LPSTR)keystr,(LPSTR)valstr);
  569.  
  570.     BroadcastWinIniChange();
  571. }
  572.  
  573. /* initialize comm parameters */
  574. static void NEAR InitCommParams(HWND hDlg)
  575. {
  576.  
  577.     parityindex = IDD_NONE + CommData.Parity;
  578.     bytesizeindex = IDD_7BIT + CommData.ByteSize - 7;
  579.     commportindex = IDD_COM1 + CommData.Id;
  580.  
  581.     SetDlgItemInt(hDlg, IDD_BAUDRATE, CommData.BaudRate, FALSE);
  582.     CheckRadioButton(hDlg, IDD_NONE, IDD_SPACE, parityindex);
  583.     CheckRadioButton(hDlg, IDD_7BIT, IDD_8BIT, bytesizeindex);
  584.     CheckRadioButton(hDlg, IDD_COM1, IDD_COM2, commportindex);
  585. }
  586.  
  587. /* read baud rate from table */
  588. static WORD GetBaudRateID(WORD rate)
  589. {
  590.  
  591.     register int i;
  592.     register WORD id;
  593.  
  594.     id = IDD_OTHER;
  595.  
  596.     for (i = 0; i < BAUDTABLESIZE; i++) {
  597.     if (rate == BaudRateTable[i]) {
  598.         id = IDD_110 + i;    
  599.         break;
  600.     }
  601.     }
  602.     return id;
  603. }
  604.  
  605. /* dialog box for setting terminal parameters */
  606. BOOL FAR PASCAL SetTermParams(hDlg, message, wParam, lParam)
  607. HWND hDlg;
  608. unsigned message;
  609. WORD wParam;
  610. LONG lParam;
  611. {
  612.  
  613.     switch (message) {
  614.     case WM_INITDIALOG:
  615.         TermParamInit(hDlg);
  616.         break;
  617.  
  618.     case WM_COMMAND:
  619.         switch (wParam) {
  620.         case IDOK:
  621.             TermParamSet(hDlg);
  622.             EndDialog(hDlg, TRUE);
  623.             break;
  624.         
  625.         case IDCANCEL:
  626.             EndDialog(hDlg, FALSE);
  627.             break;
  628.  
  629.         case IDD_WRAP:
  630.         case IDD_LFCR:
  631.         case IDD_CRLF:
  632.         case IDD_SAVE:
  633.             if (IsDlgButtonChecked(hDlg, wParam))
  634.             CheckDlgButton(hDlg, wParam, FALSE);
  635.             else
  636.             CheckDlgButton(hDlg, wParam, TRUE);
  637.               break;
  638.  
  639.         case IDD_LINE:
  640.         case IDD_BLOCK:
  641.             CheckRadioButton(hDlg, IDD_LINE, IDD_BLOCK, wParam);
  642.             break;
  643.  
  644.         case IDD_HALF:
  645.         case IDD_FULL:
  646.             CheckRadioButton(hDlg, IDD_HALF, IDD_FULL, wParam);
  647.             break;
  648.  
  649.         case IDD_HEATH:
  650.         case IDD_ANSI:
  651.             CheckRadioButton(hDlg, IDD_HEATH, IDD_ANSI, wParam);
  652.             break;
  653.  
  654.         case IDD_NORMAL:
  655.         case IDD_SHIFTED:
  656.             CheckRadioButton(hDlg, IDD_NORMAL, IDD_SHIFTED, wParam);
  657.             break;
  658.  
  659.         default:
  660.             return FALSE;
  661.         }
  662.         break;
  663.  
  664.     default:
  665.         return FALSE;
  666.     }
  667.     return TRUE;
  668. }
  669.  
  670. /* dialog box initialization */
  671. static void NEAR TermParamInit(HWND hDlg)
  672. {
  673.  
  674.     CheckRadioButton(hDlg, IDD_HALF, IDD_FULL, IDD_HALF + CD.FullDuplex);
  675.     CheckRadioButton(hDlg, IDD_HEATH, IDD_ANSI, IDD_HEATH + CD.ANSIMode);
  676.     CheckRadioButton(hDlg,IDD_NORMAL,IDD_SHIFTED,IDD_NORMAL + CD.ShiftedKeypad);
  677.     CheckRadioButton(hDlg, IDD_LINE, IDD_BLOCK,IDD_LINE + CD.BlockCursor);
  678.     CheckDlgButton(hDlg, IDD_WRAP, CD.WrapAround);
  679.     CheckDlgButton(hDlg, IDD_CRLF, CD.CRonLF);
  680.     CheckDlgButton(hDlg, IDD_LFCR, CD.LFonCR);
  681. }
  682.  
  683. /* set terminal parameters */
  684. static void NEAR TermParamSet(HWND hDlg)
  685. {
  686.  
  687.     int *ptr, *ptr1;
  688.     int i, index;
  689.     char szValStr[30], szKeyStr[30];
  690.  
  691.     for (i = IDD_HALF; i <= IDD_FULL; i++)
  692.     if (SendDlgItemMessage(hDlg,i,BM_GETCHECK,0,0L)) {
  693.         CD.FullDuplex = i - IDD_HALF;
  694.         break;
  695.     }
  696.  
  697.     for (i = IDD_HEATH; i <= IDD_ANSI; i++)
  698.     if (SendDlgItemMessage(hDlg,i,BM_GETCHECK,0,0L)) {
  699.         CD.ANSIMode = i - IDD_HEATH;
  700.         break;
  701.     }
  702.  
  703.     for (i = IDD_NORMAL; i <= IDD_SHIFTED; i++)
  704.     if (SendDlgItemMessage(hDlg,i,BM_GETCHECK,0,0L)) {
  705.         CD.ShiftedKeypad = i - IDD_NORMAL;
  706.         break;
  707.     }
  708.  
  709.     for (i = IDD_LINE; i <= IDD_BLOCK; i++)
  710.     if (SendDlgItemMessage(hDlg,i,BM_GETCHECK,0,0L)) {
  711.         index = i - IDD_LINE;
  712.         break;
  713.     }
  714.  
  715.     if (index != CD.BlockCursor)
  716.     if (index)
  717.         ProcessSetCommand(4);
  718.     else
  719.         ProcessResetCommand(4);
  720.  
  721.     CD.WrapAround = IsDlgButtonChecked(hDlg, IDD_WRAP);
  722.     CD.LFonCR = IsDlgButtonChecked(hDlg, IDD_LFCR);
  723.     CD.CRonLF = IsDlgButtonChecked(hDlg, IDD_CRLF);
  724.  
  725.     if (IsDlgButtonChecked(hDlg, IDD_SAVE)) {
  726.     ptr = &S402.BlockCursor;
  727.         ptr1 = &CD.BlockCursor;
  728.         for (i = 0; i < 8; i++) {
  729.             itoa(*ptr1,szValStr,sizeof(szValStr));
  730.         *ptr++ = *ptr1++;
  731.             LoadString(hInst,IDS_BLOCKCURSOR+i,(LPSTR)szKeyStr,
  732.                 sizeof(szKeyStr));
  733.         WriteProfileString((LPSTR)szAppName,(LPSTR)szKeyStr,
  734.             (LPSTR)szValStr);
  735.     }
  736.     BroadcastWinIniChange();
  737.     }
  738. }
  739.  
  740. /* dialog box function to edit function key strings */
  741. BOOL FAR PASCAL SetStringParams(hDlg, message, wParam, lParam)
  742. HWND hDlg;
  743. unsigned message;
  744. WORD wParam;
  745. LONG lParam;
  746. {
  747.  
  748.     register int i;
  749.  
  750.     switch (message) {
  751.     case WM_INITDIALOG:
  752.         CheckRadioButton(hDlg, IDD_F1, IDD_F12, IDD_F1);
  753.         CheckRadioButton(hDlg,IDD_NOSHIFT,IDD_CTRLSHIFT,IDD_SHIFT);
  754.             SendDlgItemMessage(hDlg,IDD_STRINGEDIT,EM_LIMITTEXT,80,0L);
  755.         StringOp(hDlg, IDOK+1);
  756.         break;
  757.  
  758.     case WM_COMMAND:
  759.         switch (wParam) {
  760.         case IDD_F1:
  761.         case IDD_F2:
  762.         case IDD_F3:
  763.         case IDD_F4:
  764.         case IDD_F5:
  765.         case IDD_F6:
  766.         case IDD_F7:
  767.         case IDD_F8:
  768.         case IDD_F9:
  769.         case IDD_F10:
  770.         case IDD_F11:
  771.         case IDD_F12:
  772.             CheckRadioButton(hDlg, IDD_F1, IDD_F12, wParam);
  773.             StringOp(hDlg, wParam);
  774.             break;
  775.  
  776.         case IDD_NOSHIFT:
  777.             CheckRadioButton(hDlg, IDD_F1, IDD_F12, IDD_F10);
  778.             CheckRadioButton(hDlg, IDD_NOSHIFT, IDD_CTRLSHIFT, wParam);
  779.             for (i = IDD_F1; i < IDD_F12; i++) {
  780.             if (i >= IDD_F10)
  781.                 continue;
  782.             else
  783.                 EnableWindow(GetDlgItem(hDlg, i), FALSE);
  784.             }
  785.             StringOp(hDlg, wParam);
  786.             break;
  787.  
  788.         case IDD_SHIFT:
  789.         case IDD_CONTROL:
  790.         case IDD_CTRLSHIFT:
  791.             CheckRadioButton(hDlg, IDD_NOSHIFT, IDD_CTRLSHIFT, wParam);
  792.             for (i = IDD_F1; i < IDD_F12; i++) {
  793.             if (i == IDD_F6)
  794.                 continue;
  795.             else
  796.                 EnableWindow(GetDlgItem(hDlg, i), TRUE);
  797.             }
  798.             StringOp(hDlg, wParam);
  799.             break;
  800.  
  801.         case IDOK:
  802.             StringOp(hDlg, wParam);
  803.             break;
  804.  
  805.         case IDCANCEL:
  806.             EndDialog(hDlg, FALSE);
  807.             break;
  808.  
  809.         default:
  810.             return FALSE;
  811.         }
  812.         break;
  813.  
  814.     default:
  815.         return FALSE;
  816.     }
  817.     return TRUE;
  818. }
  819.  
  820. /* support function for function key edit dialog box */
  821. static void NEAR StringOp(HWND hDlg, WORD param)
  822. {
  823.  
  824.     register int index, i;
  825.     char fstring[80];
  826.     char *ptr;
  827.  
  828.     for (i = IDD_F1; i <= IDD_F12; i++)
  829.     if (SendDlgItemMessage(hDlg,i,BM_GETCHECK,0,0L)) {
  830.         index = i - IDD_F1;
  831.         break;
  832.     }
  833.     
  834.     for (i = IDD_NOSHIFT; i <= IDD_CTRLSHIFT; i++)
  835.     if (SendDlgItemMessage(hDlg,i,BM_GETCHECK,0,0L)) {
  836.         switch (i) {
  837.         case IDD_NOSHIFT:
  838.             ptr = szFKey[index];
  839.             break;
  840.         case IDD_SHIFT:
  841.             ptr = szSFKey[index];
  842.             break;
  843.         case IDD_CONTROL:
  844.             ptr = szCFKey[index];
  845.             break;
  846.         case IDD_CTRLSHIFT:
  847.             ptr = szCSFKey[index];
  848.             break;
  849.         }
  850.         break;
  851.     }
  852.     if (param == IDOK) {
  853.         GetDlgItemText(hDlg, IDD_STRINGEDIT, (LPSTR)fstring, 80);
  854.         WriteProfileString((LPSTR)szAppName,(LPSTR)ptr,(LPSTR)fstring);
  855.     BroadcastWinIniChange();
  856.         SetDlgItemText(hDlg,IDD_STRINGEDIT,(LPSTR)fstring);        
  857.     }
  858.     else {
  859.         GetProfileString((LPSTR)szAppName,
  860.              (LPSTR)ptr,(LPSTR)"",(LPSTR)fstring,80);
  861.         SetDlgItemText(hDlg,IDD_STRINGEDIT,(LPSTR)fstring);        
  862.         SendDlgItemMessage(hDlg,IDD_STRINGEDIT,EM_SETSEL,0,MAKELONG(0,32767));
  863.     }
  864. /*    SetFocus(GetDlgItem(hDlg,IDD_STRINGEDIT));   */
  865. }
  866.