home *** CD-ROM | disk | FTP | other *** search
/ kermit.columbia.edu / kermit.columbia.edu.tar / kermit.columbia.edu / win100b / wktmsc.c < prev    next >
C/C++ Source or Header  |  1991-10-19  |  43KB  |  1,656 lines
  1. /*
  2.  * Dialog box support for Win100
  3.  * 
  4.  * Copyright (c) 1990, 1991 by
  5.  * William S. Hall
  6.  * 3665 Benton Street  #66
  7.  * Santa Clara, CA 95051
  8.  *
  9.  */
  10.  
  11. #define NOBITMAP
  12. #define NOBRUSH
  13. #define NOKANJI
  14. #define NOATOM
  15. #define NOMINMAX
  16. #include <windows.h>
  17. #include <string.h>
  18. #include <stdlib.h>
  19. #include <fcntl.h>
  20. #include <io.h>
  21. #include <stdio.h>
  22. #include <direct.h>
  23. #if defined(WIN2)
  24. #include <winexp.h>
  25. #endif
  26. #ifdef COLUMBIA
  27. #include "wktsmt.h"
  28. #include "wkt100.h"
  29. #include "wktdlg.h"
  30. #else
  31. #include "smterm.h"
  32. #include "w600dg.h"
  33. #include "win600.h"
  34. #endif
  35.  
  36. typedef struct _FONTDAT {
  37.     HWND hDlg;
  38.     int action;
  39. } FONTDAT;
  40.  
  41. static void NEAR InitModemBox(HWND hDlg);
  42. // static int NEAR FindInitialPort(HWND hDlg, int index);
  43. static int NEAR FindXoffLimit(WORD val);
  44. static int FindParityIndex(BYTE parity, BYTE size);
  45. static int NEAR FindBaudIndex(WORD rate);
  46. static void NEAR SetModemBox(HWND hDlg);
  47. static void NEAR SaveModemBoxParams(HWND hDlg);
  48. static void NEAR SetDisplayBox(HWND hDlg);
  49. static void NEAR InitDisplayBox(HWND hDlg);
  50. static void NEAR SetGeneralBox(HWND hDlg);
  51. static void NEAR InitGeneralBox(HWND hDlg);
  52. static void NEAR InitMiniBox(HWND hDlg);
  53. static void NEAR SetMiniBox(HWND hDlg);
  54. static void NEAR InitCopyBox(HWND hDlg);
  55. static void NEAR RangeCopyBox(HWND hDlg);
  56. static void NEAR SetCopyBox(HWND hDlg);
  57. static void NEAR StringOp(HWND hDlg, WORD param);
  58. static void NEAR InitLogFileBox(HWND hDlg);
  59. static BOOL NEAR SetLogFileBox(HWND hDlg);
  60. static void NEAR InitKeyboardBox(HWND hDlg);
  61. static void NEAR SetKeyboardBox(HWND hDlg);
  62. static void NEAR InitFontsBoxProc(HWND hDlg);
  63. short FAR PASCAL GetFixedFontInfo(LPLOGFONT lf,
  64.                  LPTEXTMETRIC tm, short type, FONTDAT FAR *Data);
  65. static void NEAR ScrollCopyBox(HWND hDlg, WORD wParam, LONG lParam);
  66. static void NEAR SelectFontsBox(HWND hDlg);
  67. static void NEAR SizeFontsBox(HWND hDlg);
  68. static void NEAR SetFontsBox(HWND hDlg);
  69. CBInsertString(HWND hDlg, int id, int index, char * buf);
  70. CBSetCursel(HWND hDlg, int id, int index);
  71. CBGetCursel(HWND hDlg, int id);
  72. static void NEAR SaveInitData(int id, int val);
  73.  
  74. static char *format = "%2d %2d";
  75. static char *black = "Black";
  76. static char *dgray = "Dark Gray";
  77. static char *lgray = "Light Gray";
  78. static char *white = "White";
  79.  
  80. BOOL OpenDlgBox(HWND hWnd, FARPROC fpProc, WORD boxnum)
  81. {
  82.  
  83.     FARPROC fp;
  84.     BOOL result;
  85.  
  86.   /* make a proc instance for the about box window function */
  87.     fp = MakeProcInstance(fpProc, hInst);
  88.   /* create a modal dialog box */
  89.     result = DialogBox(hInst, MAKEINTRESOURCE(boxnum),hWnd,fp);
  90.     FreeProcInstance(fp);
  91.     return result;
  92.  
  93. }
  94.  
  95. /* This is the window proc for the about box when it is displayed */
  96. BOOL FAR PASCAL AboutBoxProc(HWND hDlg,unsigned message,
  97.                  WORD wParam,LONG lParam)
  98. {
  99.  
  100.     switch (message) {
  101.  
  102.       /* nothing to initialize */
  103.     case WM_INITDIALOG:
  104.         break;
  105.  
  106.       /* this dialog box has only an OK button */
  107.     case WM_COMMAND:
  108.         switch (wParam) {
  109.         case IDOK:
  110.         case IDCANCEL:
  111.         /* destroy the dialog box */
  112.             EndDialog(hDlg,TRUE);
  113.             break;
  114.         default:
  115.             return FALSE;        /* we did not process */
  116.         }
  117.         break;
  118.         
  119.     default:
  120.         return FALSE;
  121.     }
  122.     return TRUE;        /* we processed message */
  123. }
  124.  
  125. BOOL FAR PASCAL FontsBoxProc(HWND hDlg,unsigned message,
  126.                  WORD wParam,LONG lParam)
  127. {
  128.  
  129.     switch (message) {
  130.  
  131.     case WM_INITDIALOG:
  132.         InitFontsBoxProc(hDlg);
  133.         break;
  134.  
  135.     case WM_COMMAND:
  136.         switch (wParam) {
  137. /*
  138.         case IDD_SAVE:
  139.             if (IsDlgButtonChecked(hDlg, wParam))
  140.             CheckDlgButton(hDlg, wParam, FALSE);
  141.             else
  142.             CheckDlgButton(hDlg, wParam, TRUE);
  143.               break;
  144. */
  145.  
  146.         case IDD_FONTFACE:
  147.             SelectFontsBox(hDlg);
  148.             break;
  149.  
  150.         case IDD_NORMALFONT:
  151.         case IDD_SMALLFONT:
  152.             SizeFontsBox(hDlg);
  153.             break;
  154.  
  155.         case IDOK:
  156.             SetFontsBox(hDlg);
  157.             EndDialog(hDlg,TRUE);
  158.             break;
  159.  
  160.         case IDCANCEL:
  161.             EndDialog(hDlg,FALSE);
  162.             break;
  163.  
  164.         default:
  165.             return FALSE;        /* we did not process */
  166.         }
  167.         break;
  168.         
  169.     default:
  170.         return FALSE;
  171.     }
  172.     return TRUE;        /* we processed message */
  173. }
  174.  
  175. short FAR PASCAL GetFixedFontInfo(LPLOGFONT lf, LPTEXTMETRIC tm,
  176.                   short type, FONTDAT FAR *pfd)
  177. {
  178.  
  179.     HWND hdlg = pfd->hDlg;
  180.     WORD boxid = pfd->action;
  181.     char buf[20];
  182.  
  183.     switch(boxid) {
  184.     case IDD_FONTFACE:
  185.         if ((lf->lfPitchAndFamily & FIXED_PITCH) && 
  186.         (lf->lfWeight == FW_NORMAL) && 
  187.         (lf->lfItalic == 0) &&
  188.         (lf->lfStrikeOut == 0) &&
  189.         (lf->lfUnderline == 0) &&
  190.         (lf->lfCharSet == ANSI_CHARSET))
  191.         SendDlgItemMessage(hdlg,boxid,LB_ADDSTRING,0,
  192.                    (LONG)(LPSTR)lf->lfFaceName);
  193.         break;
  194.  
  195.     case IDD_NORMALFONT:
  196.         if ((lf->lfPitchAndFamily & FIXED_PITCH) && 
  197.         (lf->lfWeight == FW_NORMAL) && 
  198.         (lf->lfItalic == 0) &&
  199.         (lf->lfStrikeOut == 0) &&
  200.         (lf->lfUnderline == 0) &&
  201.         (lf->lfCharSet == ANSI_CHARSET)) {
  202.             sprintf(buf, format, lf->lfWidth, lf->lfHeight);
  203.             SendDlgItemMessage(hdlg, boxid,
  204.                    LB_INSERTSTRING, -1, (LONG)(LPSTR)buf);
  205.             SendDlgItemMessage(hdlg, boxid + 1,
  206.                    LB_INSERTSTRING,-1,(LONG)(LPSTR)buf);
  207.         }
  208.         break;
  209.  
  210.     }
  211.     return TRUE;
  212. }
  213.  
  214. static void NEAR SizeFontsBox(HWND hDlg)
  215. {
  216.     WORD index, index1;
  217.     HWND hctl = GetDlgItem(hDlg, IDOK);
  218.  
  219.     index = (WORD)SendDlgItemMessage(hDlg,IDD_NORMALFONT,LB_GETCURSEL,0,0L);
  220.     index1 = (WORD)SendDlgItemMessage(hDlg,IDD_SMALLFONT,LB_GETCURSEL,0,0L);
  221.     if ((index == LB_ERR) || (index1 == LB_ERR))
  222.         EnableWindow(hctl, FALSE);
  223.     else
  224.     EnableWindow(hctl, TRUE);
  225.  
  226. }
  227.  
  228. static void NEAR SelectFontsBox(HWND hDlg)
  229. {
  230.     FARPROC fp;
  231.     HDC hDC;
  232.     char curfont[LF_FACESIZE];
  233.     WORD index, index1;
  234.     FONTDAT fd;
  235.  
  236.     index = (WORD)SendDlgItemMessage(hDlg, IDD_FONTFACE, LB_GETCURSEL, 0, 0L);
  237.     if (index != LB_ERR) {
  238.     SendDlgItemMessage(hDlg, IDD_FONTFACE, LB_GETTEXT, index,
  239.                         (LONG)(LPSTR)curfont);
  240.     SendDlgItemMessage(hDlg, IDD_SMALLFONT, WM_SETREDRAW, 0, 0L);
  241.     SendDlgItemMessage(hDlg, IDD_NORMALFONT, WM_SETREDRAW, 0, 0L);
  242.     SendDlgItemMessage(hDlg, IDD_NORMALFONT, LB_RESETCONTENT, 0, 0L);
  243.     SendDlgItemMessage(hDlg, IDD_SMALLFONT, LB_RESETCONTENT, 0, 0L);
  244.         hDC = GetDC(hDlg);
  245.         fp = MakeProcInstance((FARPROC)GetFixedFontInfo, hInst);
  246.     fd.hDlg = hDlg;
  247.     fd.action = IDD_NORMALFONT;
  248.         EnumFonts(hDC, curfont, fp, (LPSTR)&fd);
  249.         FreeProcInstance(fp);
  250.         ReleaseDC(hDlg, hDC);
  251.     SendDlgItemMessage(hDlg, IDD_SMALLFONT, WM_SETREDRAW, TRUE, 0L);
  252.     SendDlgItemMessage(hDlg, IDD_NORMALFONT, WM_SETREDRAW, TRUE, 0L);
  253.     InvalidateRect(GetDlgItem(hDlg,IDD_SMALLFONT), NULL, TRUE);
  254.     InvalidateRect(GetDlgItem(hDlg,IDD_NORMALFONT), NULL, TRUE);
  255.     }
  256.     index = (WORD)SendDlgItemMessage(hDlg,IDD_NORMALFONT,LB_GETCURSEL,0,0L);
  257.     index1 = (WORD)SendDlgItemMessage(hDlg,IDD_SMALLFONT,LB_GETCURSEL,0,0L);
  258.     if ((index == LB_ERR) || (index1 == LB_ERR))
  259.         EnableWindow(GetDlgItem(hDlg, IDOK), FALSE);
  260. }
  261.  
  262. static void NEAR SetFontsBox(HWND hDlg)
  263. {
  264.     WORD index, index1, index2;
  265.     char curfont[LF_FACESIZE];
  266.     char nfont[10], sfont[10];
  267.     short nfontwidth, nfontheight;
  268.     short sfontwidth, sfontheight;
  269.     char szKeyStr[80];
  270.     SETFONT sf;
  271.  
  272.     index = (WORD)SendDlgItemMessage(hDlg, IDD_FONTFACE, LB_GETCURSEL, 0, 0L);
  273.     index1 = (WORD)SendDlgItemMessage(hDlg,IDD_NORMALFONT,LB_GETCURSEL, 0, 0L);
  274.     index2 = (WORD)SendDlgItemMessage(hDlg,IDD_SMALLFONT,LB_GETCURSEL,0,0L);
  275.     if ((index != LB_ERR) && (index1 != LB_ERR) && (index2 != LB_ERR)) {
  276.     SendDlgItemMessage(hDlg, IDD_FONTFACE, LB_GETTEXT, index,
  277.                         (LONG)(LPSTR)curfont);
  278.     SendDlgItemMessage(hDlg, IDD_NORMALFONT, LB_GETTEXT, index1,
  279.                         (LONG)(LPSTR)nfont);
  280.     SendDlgItemMessage(hDlg, IDD_SMALLFONT, LB_GETTEXT, index2,
  281.                         (LONG)(LPSTR)sfont);
  282.     sscanf(nfont, format, &nfontwidth, &nfontheight);
  283.     sscanf(sfont, format, &sfontwidth, &sfontheight);
  284.  
  285.     sf.nwidth = nfontwidth;
  286.     sf.nheight = nfontheight;
  287.     sf.swidth = sfontwidth;
  288.     sf.sheight = sfontheight;
  289.     strcpy(sf.FaceName, curfont);
  290.     
  291.     SendMessage(hWndActive,SMT_COMMAND,SM_SETFONT,
  292.             (LONG)(SETFONT FAR *)&sf);
  293.  
  294.     if (IsDlgButtonChecked(hDlg, IDD_SAVE)) {
  295.             LoadString(hInst,IDS_FONTFACE,(LPSTR)szKeyStr,sizeof(szKeyStr));
  296.             WritePrivateProfileString(szAppName,szKeyStr,curfont,szIniName);
  297.         SaveInitData(IDS_NORMALWIDTH, nfontwidth);
  298.         SaveInitData(IDS_NORMALHEIGHT, nfontheight);
  299.         SaveInitData(IDS_SMALLWIDTH, sfontwidth);
  300.         SaveInitData(IDS_SMALLHEIGHT, sfontheight);
  301.     }
  302.     }
  303. }
  304.  
  305. static void NEAR InitFontsBoxProc(HWND hDlg)
  306. {
  307.     FARPROC fp;
  308.     HDC hDC;
  309.     char curfont[LF_FACESIZE];
  310.     long len;
  311.     FONTDAT fd;
  312.     
  313.     CheckDlgButton(hDlg, IDD_SAVE, FALSE);
  314. //    EnableWindow(GetDlgItem(hDlg, IDD_SAVE), FALSE);
  315.  
  316.     hDC = GetDC(hDlg);
  317.     fp = MakeProcInstance((FARPROC)GetFixedFontInfo, hInst);
  318.     fd.hDlg = hDlg;
  319.     fd.action = IDD_FONTFACE;
  320.     EnumFonts(hDC, NULL, fp, (LPSTR)&fd);
  321.     SendDlgItemMessage(hDlg,IDD_FONTFACE,LB_ADDSTRING,0,(LONG)(LPSTR)"System");
  322.                    
  323.     len = SendMessage(hWndText,SMT_GETATTRIBUTE,SM_FONTFACE,
  324.               (LONG)(LPSTR)curfont);
  325.  
  326.     if (len) {
  327.         SendDlgItemMessage(hDlg,IDD_FONTFACE,LB_SELECTSTRING, -1,
  328.                      (LONG)(LPSTR)curfont);
  329.     fd.action = IDD_NORMALFONT;
  330.         EnumFonts(hDC, curfont, fp, (LPSTR)&fd);
  331.     len = SendMessage(hWndText, SMT_GETATTRIBUTE, SM_NORMALFONT, 0L);
  332.     sprintf(curfont, format, LOWORD(len), HIWORD(len));
  333.         SendDlgItemMessage(hDlg,IDD_NORMALFONT,LB_SELECTSTRING, -1,
  334.                      (LONG)(LPSTR)curfont);
  335.     len = SendMessage(hWndText, SMT_GETATTRIBUTE, SM_SMALLFONT, 0L);
  336.     sprintf(curfont, format, LOWORD(len), HIWORD(len));
  337.         SendDlgItemMessage(hDlg,IDD_SMALLFONT,LB_SELECTSTRING, -1,
  338.                      (LONG)(LPSTR)curfont);
  339.     }
  340.     FreeProcInstance(fp);
  341.     ReleaseDC(hDlg, hDC);
  342. }
  343.  
  344. BOOL FAR PASCAL LogFileBoxProc(HWND hDlg,unsigned message,
  345.                    WORD wParam,LONG lParam)
  346. {
  347.     int count;
  348.  
  349.     switch (message) {
  350.  
  351.     case WM_INITDIALOG:
  352.         InitLogFileBox(hDlg);
  353.         break;
  354.  
  355.     case WM_COMMAND:
  356.         switch (wParam) {
  357.         case IDD_GETFILE:
  358.             if (HIWORD(lParam) == EN_CHANGE) {
  359.                 count = (int)SendDlgItemMessage(hDlg,
  360.                      wParam,WM_GETTEXTLENGTH,0,0L);
  361.                 EnableWindow(GetDlgItem(hDlg, IDOK), count);
  362.             }
  363.             break;
  364.  
  365.         case IDOK:
  366.             if (SetLogFileBox(hDlg))
  367.                 EndDialog(hDlg,TRUE);
  368.             break;
  369.  
  370.         case IDCANCEL:
  371.             EndDialog(hDlg,FALSE);
  372.             break;
  373.  
  374.         default:
  375.             return FALSE;        /* we did not process */
  376.         }
  377.         break;
  378.         
  379.     default:
  380.         return FALSE;
  381.     }
  382.     return TRUE;        /* we processed message */
  383. }
  384.  
  385. static char namebuf[14];
  386.  
  387. static BOOL NEAR SetLogFileBox(HWND hDlg)
  388. {
  389.     char buf[132];
  390.     int hfile;
  391.     int reply;
  392.     WORD style;
  393.  
  394.     GetDlgItemText(hDlg, IDD_GETFILE, buf, sizeof(buf));
  395.   
  396.     if ((hfile = OpenFile(buf, &ofLogFile, OF_EXIST)) > 0) {
  397.     if (strpbrk(buf, ":\\")) {    // path specified
  398.         reply = ShowMessage(hDlg,IDS_FILEEXISTS, 
  399.                 MB_YESNOCANCEL | MB_ICONQUESTION);
  400.         if (reply == IDCANCEL)
  401.         return FALSE;
  402.         style = reply == IDNO ? OF_WRITE | OF_CREATE : OF_WRITE;
  403.     }
  404.     else {        // not a path
  405. //            reply = GetDlgItemText(hDlg,IDD_LOGFILEPATH,buf,sizeof(buf));
  406.             getcwd(buf, sizeof(buf));
  407.         if (buf[reply - 1] == '\\')
  408.         buf[reply - 1] = 0;
  409.         strcat(buf, strrchr(ofLogFile.szPathName,'\\'));
  410.         if (strcmp(buf, ofLogFile.szPathName)) //file not in this directory
  411.         style = OF_WRITE | OF_CREATE;
  412.         else {        // yes, in this directory, so append or clear ?
  413.             reply = ShowMessage(hDlg,IDS_FILEEXISTS, 
  414.                     MB_YESNOCANCEL | MB_ICONQUESTION);
  415.             if (reply == IDCANCEL)
  416.             return FALSE;
  417.             style = reply == IDNO ? OF_WRITE | OF_CREATE : OF_WRITE;
  418.         }
  419.     }
  420.     }
  421.     else
  422.         style = OF_WRITE | OF_CREATE;
  423.  
  424.     hLogFile = OpenFile(buf, &ofLogFile, style);
  425.     if (hLogFile > 0) {
  426.     lseek(hLogFile, 0L, SEEK_END);
  427.     strcpy(namebuf, strrchr(ofLogFile.szPathName,'\\') + 1);
  428.     return TRUE;
  429.     }
  430.     ShowMessage(hDlg, IDS_OPENFILEERROR, MB_OK | MB_ICONASTERISK);
  431.     return FALSE;
  432. }
  433.  
  434. static void NEAR InitLogFileBox(HWND hDlg)
  435. {
  436.  
  437.     static namelen = 0;
  438.     HWND hctl;
  439.     LONG style;
  440.  
  441.     hctl = GetDlgItem(hDlg, IDD_GETFILE);
  442.     style = GetWindowLong(hctl, GWL_STYLE);
  443.     style |= ES_OEMCONVERT;
  444.     SetWindowLong(hctl, GWL_STYLE, style);
  445.  
  446. // set limits
  447.     SendDlgItemMessage(hDlg,IDD_GETFILE,EM_LIMITTEXT,128,0L);
  448. // show current directory
  449.     DlgDirList(hDlg, (LPSTR)0, 0, IDD_LOGFILEPATH, 0);
  450. // get default name
  451.     if (namelen == 0)
  452.         namelen = LoadString(hInst,IDS_LOGFILENAME,namebuf,sizeof(namebuf));
  453. // set the name
  454.     SetDlgItemText(hDlg, IDD_GETFILE, namebuf);
  455. }
  456.  
  457. static short Start, End;
  458.  
  459. BOOL FAR PASCAL CopyBoxProc(HWND hDlg,unsigned message,WORD wParam,LONG lParam)
  460. {
  461.  
  462.     switch (message) {
  463.  
  464.     case WM_VSCROLL:
  465.         ScrollCopyBox(hDlg, wParam, lParam);
  466.         break;
  467.  
  468.     case WM_INITDIALOG:
  469.         InitCopyBox(hDlg);
  470.         break;
  471.  
  472.     case WM_COMMAND:
  473.         switch (wParam) {
  474.         case IDD_STARTLINE:
  475.         case IDD_ENDLINE:
  476.             if (HIWORD(lParam) == EN_CHANGE)
  477.             RangeCopyBox(hDlg);
  478.             break;
  479.  
  480.         case IDOK:
  481.             SetCopyBox(hDlg);
  482.             EndDialog(hDlg, TRUE);
  483.             SendMessage(hWndText, SMT_INVERT, 0,
  484.                 MAKELONG(Start - 1,End - 1));
  485.             Start = End = 0;
  486.             break;
  487.  
  488.         case IDCANCEL:
  489.             EndDialog(hDlg,FALSE);
  490.             SendMessage(hWndText, SMT_INVERT, 0,
  491.                         MAKELONG(Start - 1,End - 1));
  492.             Start = End = 0;
  493.             break;
  494.  
  495.         default:
  496.             return FALSE;        /* we did not process */
  497.         }
  498.         break;
  499.         
  500.     default:
  501.         return FALSE;
  502.     }
  503.     return TRUE;        /* we processed message */
  504. }
  505.  
  506. static void NEAR ScrollCopyBox(HWND hDlg, WORD wParam, LONG lParam)
  507. {
  508.     BOOL change = FALSE;
  509.  
  510.     int size = LOWORD(SendMessage(hWndText,SMT_GETATTRIBUTE,SM_SCREENSIZE,0L));
  511.     int startline = GetDlgItemInt(hDlg, IDD_STARTLINE, NULL, FALSE);
  512.     int endline = GetDlgItemInt(hDlg, IDD_ENDLINE, NULL, FALSE);
  513.  
  514.     if (HIWORD(lParam) == GetDlgItem(hDlg, IDD_STARTSCROLL)) {
  515.     SetFocus(GetDlgItem(hDlg,IDD_STARTLINE));
  516.         switch(wParam) {
  517.           case SB_LINEUP:
  518.         if (startline > 1) {
  519.             startline -= 1;
  520.             change = TRUE;
  521.         }
  522.             break;
  523.  
  524.         case SB_LINEDOWN:
  525.         if (startline < endline) {
  526.             startline += 1;
  527.             change = TRUE;
  528.         }
  529.             break;
  530.         }
  531.     }
  532.     else {
  533.     SetFocus(GetDlgItem(hDlg,IDD_ENDLINE));
  534.         switch(wParam) {
  535.           case SB_LINEUP:
  536.         if (endline > startline) {
  537.             endline -= 1;
  538.             change = TRUE;
  539.         }
  540.             break;
  541.  
  542.         case SB_LINEDOWN:
  543.         if (endline < size) {
  544.             endline += 1;
  545.             change = TRUE;
  546.         }
  547.             break;
  548.         }
  549.     }
  550.     if (change) {
  551.         SetDlgItemInt(hDlg, IDD_STARTLINE, startline, FALSE);
  552.         SetDlgItemInt(hDlg, IDD_ENDLINE, endline, FALSE);
  553.     }
  554. }
  555.  
  556. static void NEAR RangeCopyBox(HWND hDlg)
  557. {
  558.     int size = LOWORD(SendMessage(hWndText,SMT_GETATTRIBUTE,SM_SCREENSIZE,0L));
  559.     int startline = GetDlgItemInt(hDlg, IDD_STARTLINE, NULL, FALSE);
  560.     int endline = GetDlgItemInt(hDlg, IDD_ENDLINE, NULL, FALSE);
  561.     BOOL enable = (startline >= 1) && (endline <= size)
  562.           && (startline <= endline);
  563.     EnableWindow(GetDlgItem(hDlg, IDOK), enable);
  564.  
  565.     if (enable) {
  566.     if (startline > Start)
  567.         SendMessage(hWndText,SMT_INVERT,0,MAKELONG(Start-1,startline-2));
  568.     else if (startline < Start)
  569.         SendMessage(hWndText,SMT_INVERT,0,MAKELONG(startline-1,Start-2));
  570.     if (endline > End)
  571.         SendMessage(hWndText,SMT_INVERT,0,MAKELONG(End,endline-1));
  572.     else if (endline < End)
  573.         SendMessage(hWndText,SMT_INVERT,0,MAKELONG(endline,End-1));
  574.     Start = startline;
  575.     End = endline;
  576.     }
  577. }
  578.  
  579. static void NEAR SetCopyBox(HWND hDlg)
  580. {
  581.     HANDLE hText;
  582.     LPSTR pText;
  583.  
  584.     BYTE startline = (BYTE)GetDlgItemInt(hDlg, IDD_STARTLINE, NULL, FALSE);
  585.     BYTE endline = (BYTE)GetDlgItemInt(hDlg, IDD_ENDLINE, NULL, FALSE);
  586.     long size = SendMessage(hWndText,SMT_GETATTRIBUTE,SM_SCREENSIZE,0L);
  587.     long alloc = (LONG)(16 + (HIWORD(size) + 2) * LOWORD(size));
  588.     WORD wParam = 256 * (endline - 1) + startline - 1;
  589.  
  590.     if (hText = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, alloc)) {
  591.         if (pText = GlobalLock(hText)) {
  592.         SendMessage(hWndText,SMT_COPYLINES, wParam, (LONG)pText);
  593.         GlobalUnlock(hText);
  594.         if (OpenClipboard(MWnd.hWnd)) {
  595.             EmptyClipboard();
  596.             SetClipboardData(CF_TEXT, hText);
  597.             CloseClipboard();
  598.         }
  599.         else
  600.             GlobalFree(hText);
  601.         }
  602.     else
  603.         GlobalFree(hText);
  604.     }
  605. }
  606.  
  607. static void NEAR InitCopyBox(HWND hDlg)
  608. {
  609.  
  610.     long size = SendMessage(hWndText, SMT_GETATTRIBUTE, SM_SCREENSIZE, 0L);
  611.     int maxrows = LOWORD(size);
  612.  
  613.     Start = 1;
  614.     End = maxrows;
  615.  
  616.     SendMessage(hWndText,SMT_INVERT,0, MAKELONG(Start - 1, End - 1));
  617.  
  618.     SetDlgItemInt(hDlg, IDD_STARTLINE, 1, FALSE);
  619.     SetDlgItemInt(hDlg, IDD_ENDLINE, maxrows, FALSE);
  620. }
  621.  
  622. BOOL FAR PASCAL MiniBoxProc(HWND hDlg,unsigned message,WORD wParam,LONG lParam)
  623. {
  624.  
  625.     switch (message) {
  626.  
  627.     case WM_INITDIALOG:
  628.         InitMiniBox(hDlg);
  629.         break;
  630.  
  631.       /* this dialog box has only an OK button */
  632.     case WM_COMMAND:
  633.         switch (wParam) {
  634.  
  635.         case IDOK:
  636.             SetMiniBox(hDlg);
  637.             EndDialog(hDlg,TRUE);
  638.             break;
  639.  
  640.         case IDCANCEL:
  641.             EndDialog(hDlg,TRUE);
  642.             break;
  643.  
  644.         default:
  645.             return FALSE;        /* we did not process */
  646.         }
  647.         break;
  648.         
  649.     default:
  650.         return FALSE;
  651.     }
  652.     return TRUE;        /* we processed message */
  653. }
  654.  
  655. static void NEAR InitMiniBox(HWND hDlg)
  656. {
  657.     register int val;
  658.     char buf[80];
  659.  
  660.     val = (LineState & LINE_ON ? 0 : 1);
  661.     CheckRadioButton(hDlg, IDD_LINE, IDD_LOCAL, IDD_LINE + val);
  662.  
  663.     val = MWnd.Reverse ? 1 : 0;
  664.     CheckRadioButton(hDlg, IDD_NORMAL, IDD_REVERSE, IDD_NORMAL + val);
  665.  
  666.     for (val = IDS_JUMP; val <= IDS_SMOOTH8; val++) {
  667.     LoadString(hInst, val, buf, sizeof(buf));
  668.     CBInsertString(hDlg, IDD_SCROLL, -1, buf);
  669.     }
  670.     val = (BOOL)SendMessage(hWndText, SMT_GETATTRIBUTE, SM_SMOOTHSCROLL, 0L);
  671.     if (val) {
  672.         val = (BOOL)SendMessage(hWndText,SMT_GETATTRIBUTE,SM_SCROLLUNITS,0L);
  673.     CBSetCursel(hDlg,IDD_SCROLL,
  674.             val == 1 ? 1: val == 2 ? 2: val == 4 ? 3: 4);
  675.     }
  676.     else
  677.     CBSetCursel(hDlg, IDD_SCROLL, 0);
  678.  
  679.     val = HIWORD(SendMessage(hWndText, SMT_GETATTRIBUTE, SM_SCREENSIZE, 0L));
  680.     val = (val == 80 ? 0 : 1);
  681.     CheckRadioButton(hDlg, IDD_80COL, IDD_132COL, IDD_80COL + val);
  682.     
  683.     CheckDlgButton(hDlg, IDD_SAVE, FALSE);
  684.  
  685. }
  686.  
  687. static void NEAR SetMiniBox(HWND hDlg)
  688. {
  689.  
  690.     int val;
  691.     register int i;
  692.     register BOOL save = IsDlgButtonChecked(hDlg, IDD_SAVE);
  693.  
  694.     for (i = IDD_LINE; i < IDD_LOCAL; i++)
  695.     if (SendDlgItemMessage(hDlg, i, BM_GETCHECK, 0, 0L))
  696.         break;
  697.     if (i == IDD_LINE) {
  698.     LineState = LINE_ON + LocalEcho;
  699.     DoMessage = DoPeekMessage;
  700.     } else {
  701.     LineState = LOCAL_ON;
  702.     DoMessage = DoGetMessage;
  703.     }
  704.     if (save) {
  705.     Initdata.LocalMode = (LineState == LOCAL_ON ? TRUE : FALSE);
  706.     SaveInitData(IDS_LOCALMODE, Initdata.LocalMode);
  707.     }
  708.  
  709.     for (i = IDD_NORMAL; i < IDD_REVERSE; i++)
  710.     if (SendDlgItemMessage(hDlg, i, BM_GETCHECK, 0, 0L))
  711.         break;
  712.     val = MWnd.Reverse;
  713.     MWnd.Reverse = i - IDD_NORMAL;
  714.     if (val != MWnd.Reverse)
  715.         InvertScreen(MWnd.Reverse); /* does this take care of graph window? */
  716.     if (save) {
  717.     Initdata.ReverseVideo = MWnd.Reverse;
  718.     SaveInitData(IDS_REVERSEVIDEO, Initdata.ReverseVideo);
  719.     }
  720.  
  721.     val = CBGetCursel(hDlg, IDD_SCROLL);    
  722.     SendMessage(hWndText, SMT_SETATTRIBUTE, SM_SMOOTHSCROLL,
  723.         val ? (LONG)TRUE : (LONG)FALSE);
  724.     if (val)
  725.     SendMessage(hWndText, SMT_SETATTRIBUTE, SM_SCROLLUNITS,
  726.             val == 1 ? 1: val == 2 ? 2 : val == 3 ? 4 : 8);
  727.  
  728.     if (save) {
  729.     Initdata.SmoothScroll = val ? TRUE : FALSE;
  730.     SaveInitData(IDS_SMOOTHSCROLL, Initdata.SmoothScroll);
  731.     Initdata.ScrollUnits = val == 1 ? 1: val == 2 ? 2 : val == 3 ? 4 : 8;
  732.     SaveInitData(IDS_SCROLLUNITS, Initdata.ScrollUnits);
  733.     }
  734.  
  735.     for (i = IDD_80COL; i < IDD_132COL; i++)
  736.     if (SendDlgItemMessage(hDlg, i, BM_GETCHECK, 0, 0L))
  737.         break;
  738.     val = (i == IDD_80COL ? 80 : 132);
  739.     if (val != (int)HIWORD(SendMessage(hWndText,SMT_GETATTRIBUTE,
  740.                        SM_SCREENSIZE,0L)))
  741.         SetCols(val);
  742.     if (save) {
  743.     Initdata.TermCols = val;
  744.     SaveInitData(IDS_COLS, val);
  745.     }
  746.     if (save)
  747.     BroadcastWinIniChange();    
  748. }
  749.  
  750. BOOL FAR PASCAL ModemBoxProc(HWND hDlg,unsigned message,
  751.                  WORD wParam,LONG lParam)
  752. {
  753.  
  754.     switch (message) {
  755.  
  756.     case WM_INITDIALOG:
  757.         InitModemBox(hDlg);
  758.         break;        
  759.  
  760.     case WM_COMMAND:
  761.         switch (wParam) {
  762.  
  763.         case IDD_SAVE:
  764.             if (IsDlgButtonChecked(hDlg, wParam)) {
  765.                 EnableWindow(GetDlgItem(hDlg, IDD_DEFPORT), FALSE);
  766.             SendDlgItemMessage(hDlg, IDD_DEFPORT,
  767.                        CB_SHOWDROPDOWN, FALSE, 0L);
  768.             CheckDlgButton(hDlg, wParam, FALSE);
  769.             }
  770.             else {
  771.                 EnableWindow(GetDlgItem(hDlg, IDD_DEFPORT), TRUE);
  772.             SendDlgItemMessage(hDlg, IDD_DEFPORT,
  773.                        CB_SHOWDROPDOWN, TRUE, 0L);
  774.             CheckDlgButton(hDlg, wParam, TRUE);
  775.             }
  776.             break;
  777.  
  778.         case IDOK:
  779.             SetModemBox(hDlg);
  780.             EndDialog(hDlg,TRUE);
  781.             break;
  782.  
  783.         case IDCANCEL:
  784.             EndDialog(hDlg, FALSE);
  785.             break;
  786.             
  787.         default:
  788.             return FALSE;        /* we did not process */
  789.         }
  790.         break;
  791.         
  792.     default:
  793.         return FALSE;
  794.     }
  795.     return TRUE;        /* we processed message */
  796. }
  797.  
  798. static void NEAR SetModemBox(HWND hDlg)
  799. {
  800.     register int i;
  801.     WORD oldbaud = CommData.BaudRate;
  802.     BYTE oldparity = CommData.Parity;
  803.     BYTE oldbytesize = CommData.ByteSize;
  804.     BYTE oldstopbits = CommData.StopBits;
  805.     BYTE oldparitycheck = CommData.fParity;
  806.     BYTE oldxonxoff = CommData.fOutX & CommData.fInX;
  807.     WORD oldxofflim = CommData.XoffLim;
  808.     BYTE oldport = CommData.Id;
  809.     BYTE newport;
  810.     int result;
  811.  
  812.   // read selected port
  813.     newport = (BYTE)CBGetCursel(hDlg, IDD_PORT);
  814.     if (newport != oldport) {
  815.     char comstr[10];
  816.     char wintitle[50];
  817.     LoadString(hInst,IDS_COM1 + newport, comstr, sizeof(comstr));
  818.     result = OpenComm(comstr, DEFRXQUE, DEFTXQUE);
  819.     if (result >= 0) {
  820.         CloseComm(cid);
  821.         cid = result;
  822.         CommData.Id = (BYTE)cid;
  823.         LoadString(hInst, IDS_TITLE, wintitle, sizeof(wintitle));
  824.         strcat(wintitle, comstr);
  825.         SetWindowText(MWnd.hWnd, wintitle);        
  826.     }
  827.     else {
  828.         ShowMessage(hDlg, result, MB_OK | MB_ICONASTERISK);
  829.         return;
  830.     }
  831.     }
  832.  
  833.   // set local echo
  834.     LocalEcho = (IsDlgButtonChecked(hDlg, IDD_LOCALECHO) ? 1 : 0);
  835.     if (LineState != LOCAL_ON)
  836.     LineState = LINE_ON + LocalEcho;
  837.  
  838.   // read the baud rate selected
  839.     for (i = IDD_110BAUD; i < IDD_19200BAUD; i++)
  840.     if (SendDlgItemMessage(hDlg, i, BM_GETCHECK, 0, 0L))
  841.         break;
  842.     CommData.BaudRate = BaudRateTable[i - IDD_110BAUD];
  843.  
  844.   // read parity/wordsize
  845.     for (i = IDD_8BITNONE; i < IDD_7BITSPACE; i++)
  846.     if (SendDlgItemMessage(hDlg, i, BM_GETCHECK, 0, 0L))
  847.         break;
  848.     CommData.ByteSize = ParityTable[i - IDD_8BITNONE].ByteSize;
  849.     CommData.Parity = ParityTable[i - IDD_8BITNONE].Parity;
  850.  
  851.   // read parity check enabled
  852.     CommData.fParity = (BYTE)(IsDlgButtonChecked(hDlg, IDD_PARCHECK) ? 1 : 0);
  853.     CommData.fPeChar = CommData.fParity;
  854.  
  855.   // read stopbits
  856.     for (i = IDD_ONESTOPBIT; i < IDD_TWOSTOPBITS; i++)
  857.     if (SendDlgItemMessage(hDlg, i, BM_GETCHECK, 0, 0L))
  858.         break;
  859.     CommData.StopBits = (BYTE)(i == IDD_ONESTOPBIT ? ONESTOPBIT : TWOSTOPBITS);
  860.  
  861.   // read flow control
  862.     CommData.fOutX = (BYTE)(IsDlgButtonChecked(hDlg,
  863.                 IDD_XONXOFF) ? TRUE : FALSE);
  864.     CommData.fInX = CommData.fOutX;
  865.  
  866.   // read xofflimit
  867.     for (i = IDD_XOFF64; i < IDD_XOFF768; i++)
  868.     if (SendDlgItemMessage(hDlg, i, BM_GETCHECK, 0, 0L))
  869.         break;
  870.     CommData.XoffLim = DEFRXQUE - XoffSizeTable[i - IDD_XOFF64];
  871.  
  872.   // set the state of the comm DCB
  873.     result = SetCommState((DCB FAR *)&CommData);
  874.     if (result == 0) {
  875.     if (IsDlgButtonChecked(hDlg, IDD_SAVE))
  876.         SaveModemBoxParams(hDlg);
  877.     }
  878.     else {
  879.     CommData.BaudRate = oldbaud;
  880.     CommData.Parity = oldparity;
  881.     CommData.ByteSize = oldbytesize;
  882.     CommData.StopBits = oldstopbits;
  883.     CommData.fParity = CommData.fPeChar = oldparitycheck;
  884.     CommData.fOutX = CommData.fInX = oldxonxoff;
  885.     CommData.XoffLim = oldxofflim;
  886.     SetCommState((DCB FAR *)&CommData);
  887.     ShowMessage(hDlg, result, MB_OK | MB_ICONASTERISK);
  888.     }    
  889. }
  890.  
  891. static void NEAR SaveModemBoxParams(HWND hDlg)
  892. {
  893.  
  894.     char szKeyStr[80];
  895.     char szValStr[80];
  896.     int i, v[MAXCOMPORTS];
  897.     int defport;
  898.  
  899.     defport = CBGetCursel(hDlg, IDD_DEFPORT);
  900.     switch(defport) {
  901.     case 0:
  902.         v[0] = IDS_COM1; v[1] = IDS_COM2; v[2] = IDS_COM3; v[3] = IDS_COM4;
  903.         break;
  904.     case 1:
  905.         v[0] = IDS_COM2; v[1] = IDS_COM1; v[2] = IDS_COM3; v[3] = IDS_COM4;
  906.         break;
  907.     case 2:
  908.         v[0] = IDS_COM3; v[1] = IDS_COM1; v[2] = IDS_COM2; v[3] = IDS_COM4;
  909.         break;
  910.     case 3:
  911.         v[0] = IDS_COM4; v[1] = IDS_COM1; v[2] = IDS_COM2; v[3] = IDS_COM3;
  912.         break;
  913.     }
  914.     for (i = 0; i < MAXCOMPORTS; i++) {
  915.         LoadString(hInst,IDS_FIRSTPORT + i,szKeyStr,sizeof(szKeyStr));
  916.         LoadString(hInst,v[i],szValStr,sizeof(szValStr));
  917.         strcpy(Initdata.portname[i], szValStr);
  918.         WritePrivateProfileString(szAppName,szKeyStr,szValStr,szIniName);
  919.     }
  920.  
  921.     Initdata.LocalEcho = LocalEcho;
  922.     SaveInitData(IDS_LOCALECHO, Initdata.LocalEcho);
  923.  
  924.     Initdata.BaudRate = CommData.BaudRate;
  925.     SaveInitData(IDS_BAUD, Initdata.BaudRate);
  926.  
  927.     Initdata.Parity = CommData.Parity;
  928.     SaveInitData(IDS_PARITY, Initdata.Parity);
  929.  
  930.     Initdata.ByteSize = CommData.ByteSize;
  931.     SaveInitData(IDS_BYTESIZE, Initdata.ByteSize);
  932.  
  933.     Initdata.StopBits = (BYTE)(CommData.StopBits == ONESTOPBIT ? 1 : 2);
  934.     SaveInitData(IDS_STOPBITS, Initdata.StopBits);
  935.     
  936.     Initdata.fParity = CommData.fParity;
  937.     SaveInitData(IDS_PARCHECK, Initdata.fParity);
  938.  
  939.     Initdata.XonXoff = CommData.fOutX & CommData.fInX;
  940.     SaveInitData(IDS_XONXOFF, Initdata.XonXoff);
  941.  
  942.     Initdata.XoffLim = DEFRXQUE - CommData.XoffLim;
  943.     SaveInitData(IDS_XOFFLIM, Initdata.XoffLim);
  944.         
  945.     BroadcastWinIniChange();
  946. }
  947.  
  948. static void NEAR InitModemBox(HWND hDlg)
  949. {
  950.  
  951.     char buf[80];
  952.     register int i;
  953.  
  954.   // set baud rate
  955.     int index;
  956.     index = FindBaudIndex(CommData.BaudRate);
  957.     CheckRadioButton(hDlg, IDD_110BAUD, IDD_19200BAUD, IDD_110BAUD + index);
  958.  
  959.   // set parity
  960.     index = FindParityIndex(CommData.Parity, CommData.ByteSize);
  961.     CheckRadioButton(hDlg, IDD_8BITNONE, IDD_7BITSPACE, IDD_8BITNONE + index);
  962.  
  963.   // set parity flag
  964.     CheckDlgButton(hDlg, IDD_PARCHECK, CommData.fParity);
  965.  
  966.   // set stop bits
  967.     if (CommData.StopBits == ONESTOPBIT)
  968.     index = 0;
  969.     else 
  970.     index = 1;
  971.     CheckRadioButton(hDlg,IDD_ONESTOPBIT,IDD_TWOSTOPBITS,IDD_ONESTOPBIT+index);
  972.  
  973.   // set xonxoff
  974.     index = CommData.fOutX & CommData.fInX;
  975.     CheckDlgButton(hDlg, IDD_XONXOFF, index);
  976.  
  977.  // set xofflimit
  978.     index = FindXoffLimit(DEFRXQUE - CommData.XoffLim);
  979.     CheckRadioButton(hDlg, IDD_XOFF64, IDD_XOFF768, IDD_XOFF64 + index);
  980.     
  981.   // set port and initial port
  982.     for (i = 0; i < MAXCOMPORTS; i++) {
  983.     LoadString(hInst, IDS_COM1 + i, buf, sizeof(buf));
  984.     CBInsertString(hDlg, IDD_PORT, i, buf);
  985.     CBInsertString(hDlg, IDD_DEFPORT, i, buf);
  986.     if (strcmp(Initdata.portname[0], buf) == 0)
  987.         CBSetCursel(hDlg, IDD_DEFPORT, i);
  988.     }
  989.     CBSetCursel(hDlg, IDD_PORT, CommData.Id);
  990.  
  991.   // set local echo
  992.     CheckDlgButton(hDlg, IDD_LOCALECHO, LocalEcho);
  993.  
  994.   // set save
  995.     CheckDlgButton(hDlg, IDD_SAVE, FALSE);
  996.  
  997.   // disable default port choices
  998.     EnableWindow(GetDlgItem(hDlg, IDD_DEFPORT), FALSE);
  999.        
  1000. }
  1001.  
  1002. /*
  1003. static int NEAR FindInitialPort(HWND hDlg, int index)
  1004. {
  1005.     int i;
  1006.     char buf[10];
  1007.  
  1008.     for (i = 0; i < MAXCOMPORTS; i++) {
  1009.     LoadString(hInst, IDS_COM1+i, buf, sizeof(buf));
  1010.     if (strcmp(Initdata.portname[index], buf) == 0)
  1011.         break;    
  1012.     }
  1013.     return i;
  1014. }
  1015. */
  1016.  
  1017. static int NEAR FindXoffLimit(WORD val)
  1018. {
  1019.     int i;
  1020.     for (i = 0; i < XOFFLIMSIZE; i++)
  1021.     if (val == XoffSizeTable[i])
  1022.         break;
  1023.     return i;
  1024. }
  1025.  
  1026. static int FindParityIndex(BYTE parity, BYTE size)
  1027. {
  1028.     int i;
  1029.     for (i = 0; i < PARITYTABLESIZE; i++)
  1030.     if ((parity == ParityTable[i].Parity) && 
  1031.                     (size == ParityTable[i].ByteSize))
  1032.         break;
  1033.     return i;
  1034.  
  1035. }
  1036.  
  1037. static int NEAR FindBaudIndex(WORD rate)
  1038. {
  1039.     int i;
  1040.     for (i = 0; i < BAUDRATETABLESIZE; i++)
  1041.     if (rate == BaudRateTable[i])
  1042.         break;
  1043.     return i;
  1044. }
  1045.  
  1046. BOOL FAR PASCAL DisplayBoxProc(HWND hDlg,unsigned message,
  1047.                    WORD wParam,LONG lParam)
  1048. {
  1049.  
  1050.     switch (message) {
  1051.  
  1052.       /* nothing to initialize */
  1053.     case WM_INITDIALOG:
  1054.         InitDisplayBox(hDlg);
  1055.         break;        
  1056.  
  1057.       /* this dialog box has only an OK button */
  1058.     case WM_COMMAND:
  1059.         switch (wParam) {
  1060.  
  1061.         case IDOK:
  1062.             SetDisplayBox(hDlg);
  1063.             EndDialog(hDlg,TRUE);
  1064.             break;
  1065.  
  1066.         case IDCANCEL:
  1067.             EndDialog(hDlg, FALSE);
  1068.             break;
  1069.             
  1070.         default:
  1071.             return FALSE;        /* we did not process */
  1072.         }
  1073.         break;
  1074.         
  1075.     default:
  1076.         return FALSE;
  1077.     }
  1078.     return TRUE;        /* we processed message */
  1079. }
  1080.  
  1081. static void NEAR InitDisplayBox(HWND hDlg)
  1082. {
  1083.     register int val;
  1084.  
  1085.     CheckDlgButton(hDlg, IDD_AUTOWRAP, MWnd.Wrap);
  1086.  
  1087.     CheckDlgButton(hDlg, IDD_AUTOLFCR, MWnd.LFCR);
  1088.  
  1089.     val = (BOOL)SendMessage(hWndActive, SMT_GETATTRIBUTE, SM_MARGINBELL, 0L);
  1090.     CheckDlgButton(hDlg, IDD_MARGINBELL, val);
  1091.  
  1092.     val = MWnd.Cursor;
  1093.     CheckRadioButton(hDlg,IDD_CURSOROFF,IDD_CURSORON,IDD_CURSOROFF + val);
  1094.  
  1095.     val = MWnd.CursorType;
  1096.     CheckRadioButton(hDlg,IDD_CURSORULINE,IDD_CURSORBLOCK,IDD_CURSORULINE+val);
  1097.  
  1098.     CheckDlgButton(hDlg, IDD_CONTROLREP, MWnd.ControlRep);
  1099.  
  1100.     CheckDlgButton(hDlg, IDD_SAVE, FALSE);
  1101. }
  1102.  
  1103. static void NEAR SetDisplayBox(HWND hDlg)
  1104. {
  1105.     WORD val;
  1106.     register int i;
  1107.     register BOOL save = IsDlgButtonChecked(hDlg, IDD_SAVE);
  1108.  
  1109.     val = (IsDlgButtonChecked(hDlg, IDD_AUTOWRAP) ? 1 : 0);
  1110.     SendMessage(hWndActive, SMT_SETATTRIBUTE, SM_AUTOWRAP, (LONG)val);
  1111.     MWnd.Wrap = val;
  1112.     if (save) {
  1113.     Initdata.Wrap = val;
  1114.     SaveInitData(IDS_WRAP, val);
  1115.     }
  1116.  
  1117.     val = (IsDlgButtonChecked(hDlg, IDD_CONTROLREP) ? 1 : 0);
  1118.     MWnd.ControlRep = val;
  1119.     if (val) {
  1120.     if (curproto.atype == 52)
  1121.         vt52SetState(-1);
  1122.     else
  1123.         vt100SetState(-1);
  1124.         SendMessage(hWndActive, SMT_SETATTRIBUTE, SM_AUTOWRAP, (LONG)TRUE);
  1125.     }
  1126.     else {
  1127.     if (curproto.atype == 52)
  1128.         vt52SetState(0);
  1129.     else
  1130.         vt100SetState(0);
  1131.         SendMessage(hWndActive,SMT_SETATTRIBUTE,SM_AUTOWRAP,(LONG)MWnd.Wrap);
  1132.     }
  1133.     if (save) {
  1134.     Initdata.ControlRep = val;
  1135.     SaveInitData(IDS_CONTROLREP, val);
  1136.     }
  1137.  
  1138.     val = (IsDlgButtonChecked(hDlg, IDD_AUTOLFCR) ? 1 : 0);
  1139.     MWnd.LFCR = val;
  1140.     if (save) {
  1141.     Initdata.LFCR = val;
  1142.     SaveInitData(IDS_AUTOLFCR, val);
  1143.     }
  1144.  
  1145.     val = (IsDlgButtonChecked(hDlg, IDD_MARGINBELL) ? 1 : 0);
  1146.     SendMessage(hWndActive, SMT_SETATTRIBUTE, SM_MARGINBELL, (LONG)val);
  1147.     if (save) {
  1148.     Initdata.MarginBell = val;
  1149.     SaveInitData(IDS_MARGINBELL, val);
  1150.     }
  1151.  
  1152.     for (i = IDD_CURSOROFF; i < IDD_CURSORON; i++)
  1153.     if (SendDlgItemMessage(hDlg, i, BM_GETCHECK, 0, 0L))
  1154.         break;
  1155.     MWnd.Cursor = i - IDD_CURSOROFF;
  1156.     if (save) {
  1157.     Initdata.Cursor = MWnd.Cursor;
  1158.     SaveInitData(IDS_CURSOR, Initdata.Cursor);
  1159.     }
  1160.  
  1161.     for (i = IDD_CURSORULINE; i < IDD_CURSORBLOCK; i++)
  1162.     if (SendDlgItemMessage(hDlg, i, BM_GETCHECK, 0, 0L))
  1163.         break;
  1164.     MWnd.CursorType = i - IDD_CURSORULINE;
  1165.     if (save) {
  1166.     Initdata.CursorType = MWnd.CursorType;
  1167.     SaveInitData(IDS_CURSORTYPE, Initdata.CursorType);
  1168.     }
  1169.  
  1170.     if (save)
  1171.     BroadcastWinIniChange();
  1172.  
  1173. }
  1174.  
  1175. BOOL FAR PASCAL GeneralBoxProc(HWND hDlg,unsigned message,
  1176.                    WORD wParam,LONG lParam)
  1177. {
  1178.  
  1179.     switch (message) {
  1180.  
  1181.     case WM_INITDIALOG:
  1182.         InitGeneralBox(hDlg);
  1183.         break;        
  1184.  
  1185.     case WM_COMMAND:
  1186.         switch (wParam) {
  1187.         case IDD_SCREENCOLOR:
  1188.             if (HIWORD(lParam) == CBN_SELCHANGE) {
  1189.             int scrcolor, textcolor;
  1190.             scrcolor = (int)SendDlgItemMessage(hDlg,
  1191.                      IDD_SCREENCOLOR,
  1192.                     CB_GETCURSEL, 0, 0L);
  1193.             textcolor = (int)SendDlgItemMessage(hDlg,IDD_TEXTCOLOR,
  1194.                     CB_GETCURSEL, 0, 0L);
  1195.             if (scrcolor == textcolor) {
  1196.                 int mask;
  1197.                 if (MWnd.PelSize == 1)
  1198.                 mask = 1;
  1199.                 else
  1200.                 mask = COLORTABLESIZE - 1;
  1201.                 SendDlgItemMessage(hDlg,IDD_TEXTCOLOR,CB_SETCURSEL,
  1202.                     ~textcolor & mask, 0L);
  1203.             }
  1204.             }
  1205.             break;
  1206.  
  1207.         case IDD_TEXTCOLOR:
  1208.             if (HIWORD(lParam) == CBN_SELCHANGE) {
  1209.             int scrcolor, textcolor;
  1210.             scrcolor = (int)SendDlgItemMessage(hDlg,
  1211.                     IDD_SCREENCOLOR,
  1212.                     CB_GETCURSEL, 0, 0L);
  1213.             textcolor = (int)SendDlgItemMessage(hDlg,IDD_TEXTCOLOR,
  1214.                     CB_GETCURSEL, 0, 0L);
  1215.             if (scrcolor == textcolor) {
  1216.                 int mask;
  1217.                 if (MWnd.PelSize == 1)
  1218.                 mask = 1;
  1219.                 else
  1220.                 mask = COLORTABLESIZE - 1;
  1221.                 SendDlgItemMessage(hDlg,IDD_SCREENCOLOR,
  1222.                 CB_SETCURSEL, ~scrcolor & mask, 0L);
  1223.             }
  1224.             }
  1225.             break;
  1226.  
  1227.         case IDD_VT52:
  1228.             CheckRadioButton(hDlg, IDD_7BITS, IDD_8BITS, IDD_7BITS);
  1229.             EnableWindow(GetDlgItem(hDlg, IDD_8BITS), FALSE);
  1230.             break;
  1231.  
  1232.         case IDD_VT100:
  1233.             EnableWindow(GetDlgItem(hDlg, IDD_8BITS), TRUE);
  1234.             break;
  1235.  
  1236.         case IDOK:
  1237.             SetGeneralBox(hDlg);
  1238.             EndDialog(hDlg,TRUE);
  1239.             break;
  1240.  
  1241.         case IDCANCEL:
  1242.             EndDialog(hDlg, FALSE);
  1243.             break;
  1244.             
  1245.         default:
  1246.             return FALSE;        /* we did not process */
  1247.         }
  1248.         break;
  1249.         
  1250.     default:
  1251.         return FALSE;
  1252.     }
  1253.     return TRUE;        /* we processed message */
  1254. }
  1255.  
  1256. static void NEAR InitGeneralBox(HWND hDlg)
  1257. {
  1258.     register int val;
  1259.     register int i;
  1260.     char buf[80];
  1261.  
  1262.     for (i = 0; i < COLORTABLESIZE; i++) {
  1263.     if ((MWnd.PelSize == 1) && (i > 0) && (i < COLORTABLESIZE - 1))
  1264.         continue;
  1265.     LoadString(hInst, IDS_BLACK + i, buf, sizeof(buf));
  1266.     SendDlgItemMessage(hDlg, IDD_SCREENCOLOR, CB_INSERTSTRING, -1,
  1267.                (LONG)(LPSTR)buf);
  1268.     SendDlgItemMessage(hDlg, IDD_TEXTCOLOR, CB_INSERTSTRING, -1,
  1269.                (LONG)(LPSTR)buf);
  1270.     }
  1271.     val = MWnd.BGColor;
  1272.     if (MWnd.PelSize == 1)
  1273.     val = MWnd.BGColor ? 1 : 0;
  1274.     SendDlgItemMessage(hDlg, IDD_SCREENCOLOR, CB_SETCURSEL, val, 0L);
  1275.     val = MWnd.TextColor;
  1276.     if (MWnd.PelSize == 1)
  1277.     val = MWnd.TextColor ? 1 : 0;
  1278.     SendDlgItemMessage(hDlg, IDD_TEXTCOLOR, CB_SETCURSEL, val, 0L);
  1279.  
  1280.     val = curproto.atype == 52 ? 0 : 1;
  1281.     CheckRadioButton(hDlg, IDD_VT52, IDD_VT100, IDD_VT52 + val);
  1282.  
  1283.     val = curproto.mask == 0x7f ? 0 : 1;
  1284.     CheckRadioButton(hDlg, IDD_7BITS, IDD_8BITS, IDD_7BITS + val);
  1285.  
  1286.     val = MWnd.WarningBell;
  1287.     CheckDlgButton(hDlg, IDD_WARNINGBELL, val);
  1288.  
  1289. }
  1290.  
  1291. static void NEAR SetGeneralBox(HWND hDlg)
  1292. {
  1293.  
  1294.     register int i;
  1295.     int val;
  1296.     register BOOL save = IsDlgButtonChecked(hDlg, IDD_SAVE);
  1297.  
  1298.     val = (IsDlgButtonChecked(hDlg, IDD_WARNINGBELL) ? 1 : 0);
  1299.     MWnd.WarningBell = val;
  1300.     if (save) {
  1301.     Initdata.WarningBell = val;
  1302.     SaveInitData(IDS_WARNINGBELL, val);
  1303.     }
  1304.  
  1305.     for (i = IDD_VT52; i < IDD_VT100; i++)
  1306.     if (SendDlgItemMessage(hDlg, i, BM_GETCHECK, 0, 0L))
  1307.         break;
  1308.     SetAlphaParams(i == IDD_VT52 ? 52 : 100);
  1309.     if (save) {
  1310.     Initdata.AlphaEmulation = curproto.atype;
  1311.     SaveInitData(IDS_TERMTYPE, Initdata.AlphaEmulation);
  1312.     }
  1313.  
  1314.     for (i = IDD_7BITS; i < IDD_8BITS; i++)
  1315.     if (SendDlgItemMessage(hDlg, i, BM_GETCHECK, 0, 0L))
  1316.         break;
  1317.     curproto.mask = (BYTE)(i == IDD_7BITS ? 0x7f : 0xff);
  1318.     if (save) {
  1319.     Initdata.EWidth = i == IDD_7BITS ? 7 : 8;
  1320.     SaveInitData(IDS_EMULATIONWIDTH, Initdata.EWidth);
  1321.     }
  1322.  
  1323.     MWnd.BGColor = (int)SendDlgItemMessage(hDlg, IDD_SCREENCOLOR, CB_GETCURSEL,
  1324.                        0, 0L);
  1325.     MWnd.TextColor = (int)SendDlgItemMessage(hDlg, IDD_TEXTCOLOR, CB_GETCURSEL,
  1326.                          0, 0L);
  1327.     if (MWnd.PelSize == 1) {
  1328.     MWnd.BGColor = MWnd.BGColor ? COLORTABLESIZE - 1 : 0;
  1329.     MWnd.TextColor = MWnd.TextColor ? COLORTABLESIZE - 1 : 0;
  1330.     }
  1331.  
  1332.     if (save) {
  1333.     Initdata.TextColor = MWnd.TextColor;
  1334.     SaveInitData(IDS_TEXTCOLOR, Initdata.TextColor);
  1335.     Initdata.BGColor = MWnd.BGColor;
  1336.     SaveInitData(IDS_BGCOLOR, Initdata.BGColor);
  1337.     }
  1338.     InvertScreen(MWnd.Reverse);
  1339.  
  1340.     if (save)
  1341.     BroadcastWinIniChange();
  1342. }
  1343.  
  1344. /* dialog box function to edit function key strings */
  1345. BOOL FAR PASCAL EditFunctionKeys(HWND hDlg,unsigned message,
  1346.                  WORD wParam,LONG lParam)
  1347. {
  1348.  
  1349.     register int i;
  1350.  
  1351.     switch (message) {
  1352.     case WM_INITDIALOG:
  1353.         CheckRadioButton(hDlg, IDD_F1, IDD_F12, IDD_F6);
  1354.         CheckRadioButton(hDlg,IDD_UNSHIFTED,IDD_CTRLSHIFT,IDD_UNSHIFTED);
  1355.         for (i = IDD_F1; i <= IDD_F12; i++) {
  1356.         if ((i <= IDD_F5) || (i == IDD_F10))
  1357.             EnableWindow(GetDlgItem(hDlg, i), FALSE);
  1358.         else
  1359.             EnableWindow(GetDlgItem(hDlg, i), TRUE);
  1360.         }
  1361.             SendDlgItemMessage(hDlg,IDD_STRINGEDIT,EM_LIMITTEXT,80,0L);
  1362.         StringOp(hDlg, IDOK+1);
  1363.         break;
  1364.  
  1365.     case WM_COMMAND:
  1366.         switch (wParam) {
  1367.         case IDD_F1:
  1368.         case IDD_F2:
  1369.         case IDD_F3:
  1370.         case IDD_F4:
  1371.         case IDD_F5:
  1372.         case IDD_F6:
  1373.         case IDD_F7:
  1374.         case IDD_F8:
  1375.         case IDD_F9:
  1376.         case IDD_F10:
  1377.         case IDD_F11:
  1378.         case IDD_F12:
  1379.             CheckRadioButton(hDlg, IDD_F1, IDD_F12, wParam);
  1380.             StringOp(hDlg, wParam);
  1381.             break;
  1382.  
  1383.         case IDD_UNSHIFTED:
  1384.             CheckRadioButton(hDlg, IDD_F1, IDD_F12, IDD_F6);
  1385.             CheckRadioButton(hDlg,IDD_UNSHIFTED,IDD_CTRLSHIFT,wParam);
  1386.             for (i = IDD_F1; i <= IDD_F12; i++) {
  1387.             if ((i <= IDD_F5) || (i == IDD_F10))
  1388.                 EnableWindow(GetDlgItem(hDlg, i), FALSE);
  1389.             else
  1390.                 EnableWindow(GetDlgItem(hDlg, i), TRUE);
  1391.             }
  1392.             StringOp(hDlg, wParam);
  1393.             break;
  1394.  
  1395.         case IDD_SHIFT:
  1396.         case IDD_CONTROL:
  1397.         case IDD_CTRLSHIFT:
  1398.             CheckRadioButton(hDlg, IDD_F1, IDD_F12, IDD_F1);
  1399.             CheckRadioButton(hDlg,IDD_UNSHIFTED,IDD_CTRLSHIFT,wParam);
  1400.             for (i = IDD_F1; i <= IDD_F12; i++) {
  1401.             if ((i == IDD_F5) || (i == IDD_F10))
  1402.                 EnableWindow(GetDlgItem(hDlg, i), FALSE);
  1403.             else
  1404.                 EnableWindow(GetDlgItem(hDlg, i), TRUE);
  1405.             }
  1406.             if (wParam == IDD_CTRLSHIFT)
  1407.             EnableWindow(GetDlgItem(hDlg, IDD_F5), TRUE);
  1408.             StringOp(hDlg, wParam);
  1409.             break;
  1410. /*
  1411.         case IDD_STRINGEDIT:
  1412.             if (HIWORD(lParam) == EN_CHANGE) {
  1413.                 i = (int)SendDlgItemMessage(hDlg,wParam,
  1414.                             WM_GETTEXTLENGTH,0,0L);
  1415.                 EnableWindow(GetDlgItem(hDlg, IDOK), i);
  1416.             }
  1417.             break;
  1418. */
  1419.         case IDOK:
  1420.             StringOp(hDlg, wParam);
  1421.             break;
  1422.  
  1423.         case IDCANCEL:
  1424.             EndDialog(hDlg, FALSE);
  1425.             break;
  1426.  
  1427.         default:
  1428.             return FALSE;
  1429.         }
  1430.         break;
  1431.  
  1432.     default:
  1433.         return FALSE;
  1434.     }
  1435.     return TRUE;
  1436. }
  1437.  
  1438. /* support function for function key edit dialog box */
  1439. static void NEAR StringOp(HWND hDlg, WORD param)
  1440. {
  1441.  
  1442.     register int index, i;
  1443.     char fstring[80];
  1444.     char *ptr;
  1445.  
  1446.     index = 0;
  1447.     for (i = IDD_F1; i <= IDD_F12; i++)
  1448.     if (SendDlgItemMessage(hDlg,i,BM_GETCHECK,0,0L)) {
  1449.         index = i - IDD_F1;
  1450.         break;
  1451.     }
  1452.     
  1453.     for (i = IDD_UNSHIFTED; i <= IDD_CTRLSHIFT; i++)
  1454.     if (SendDlgItemMessage(hDlg,i,BM_GETCHECK,0,0L)) {
  1455.         switch (i) {
  1456.         default:
  1457.         case IDD_UNSHIFTED:
  1458.             ptr = szFKey[index];
  1459.             break;
  1460.         case IDD_SHIFT:
  1461.             ptr = szSFKey[index];
  1462.             break;
  1463.         case IDD_CONTROL:
  1464.             ptr = szCFKey[index];
  1465.             break;
  1466.         case IDD_CTRLSHIFT:
  1467.             ptr = szCSFKey[index];
  1468.             break;
  1469.         }
  1470.         break;
  1471.     }
  1472.     if (param == IDOK) {
  1473.     SetFocus(GetDlgItem(hDlg,IDOK));
  1474.         GetDlgItemText(hDlg, IDD_STRINGEDIT, (LPSTR)fstring, 80);
  1475.         WritePrivateProfileString(szAppName,ptr,fstring,szIniName);
  1476.     BroadcastWinIniChange();
  1477.         SetDlgItemText(hDlg,IDD_STRINGEDIT,(LPSTR)fstring);        
  1478.     SetFocus(GetDlgItem(hDlg,IDD_STRINGEDIT));
  1479.     }
  1480.     else {
  1481.         GetPrivateProfileString((LPSTR)szAppName,(LPSTR)ptr,
  1482.                 (LPSTR)"",(LPSTR)fstring,80, szIniName);
  1483.         SetDlgItemText(hDlg,IDD_STRINGEDIT,(LPSTR)fstring);        
  1484.         SendDlgItemMessage(hDlg,IDD_STRINGEDIT,EM_SETSEL,0,MAKELONG(0,32767));
  1485.     }
  1486. }
  1487.  
  1488. BOOL FAR PASCAL KeyboardBoxProc(HWND hDlg,unsigned message,
  1489.                 WORD wParam,LONG lParam)
  1490. {
  1491.  
  1492.     switch (message) {
  1493.  
  1494.     case WM_INITDIALOG:
  1495.         InitKeyboardBox(hDlg);
  1496.         break;
  1497.  
  1498.     case WM_COMMAND:
  1499.         switch (wParam) {
  1500.         case IDD_KEYPADNUMERIC:
  1501.         case IDD_KEYPADAPPL:
  1502.             CheckRadioButton(hDlg,IDD_KEYPADNUMERIC,
  1503.                     IDD_KEYPADAPPL,wParam);
  1504.             break;
  1505.  
  1506.         case IDD_CURKEYSNORMAL:
  1507.         case IDD_CURKEYSAPPL:
  1508.             CheckRadioButton(hDlg,IDD_CURKEYSNORMAL,
  1509.                     IDD_CURKEYSAPPL,wParam);
  1510.             break;
  1511.  
  1512.         case IDD_BKSPNORMAL:
  1513.         case IDD_BKSPDELETE:
  1514.             CheckRadioButton(hDlg,IDD_BKSPNORMAL,
  1515.                      IDD_BKSPDELETE,wParam);
  1516.             break;
  1517.  
  1518.         case IDD_AUTOANSWER:
  1519.         case IDD_BREAKKEY:
  1520.         case IDD_SAVE:
  1521.             if (IsDlgButtonChecked(hDlg, wParam))
  1522.             CheckDlgButton(hDlg, wParam, FALSE);
  1523.             else
  1524.             CheckDlgButton(hDlg, wParam, TRUE);
  1525.               break;
  1526.  
  1527.         case IDOK:
  1528.             SetKeyboardBox(hDlg);
  1529.             EndDialog(hDlg,TRUE);
  1530.             break;
  1531.  
  1532.         case IDCANCEL:
  1533.             EndDialog(hDlg,FALSE);
  1534.             break;
  1535.  
  1536.         default:
  1537.             return FALSE;        /* we did not process */
  1538.         }
  1539.         break;
  1540.         
  1541.     default:
  1542.         return FALSE;
  1543.     }
  1544.     return TRUE;        /* we processed message */
  1545. }
  1546.  
  1547. static void NEAR InitKeyboardBox(HWND hDlg)
  1548. {
  1549.     register int val;
  1550.     char buf[80];
  1551.     char key[20];
  1552.  
  1553.     val = MWnd.ApplMode + IDD_KEYPADNUMERIC;
  1554.     CheckRadioButton(hDlg,IDD_KEYPADNUMERIC,IDD_KEYPADAPPL, val);
  1555.  
  1556.     val = IDD_CURKEYSNORMAL + MWnd.CurKeyMode;
  1557.     CheckRadioButton(hDlg,IDD_CURKEYSNORMAL,IDD_CURKEYSAPPL, val);
  1558.  
  1559.     val = IDD_BKSPNORMAL + MWnd.DeleteKey;
  1560.     CheckRadioButton(hDlg,IDD_BKSPNORMAL,IDD_BKSPDELETE, val);
  1561.  
  1562.     CheckDlgButton(hDlg, IDD_BREAKKEY, MWnd.BreakEnabled);
  1563.  
  1564.     CheckDlgButton(hDlg, IDD_AUTOANSWER, MWnd.AutoAnswer);
  1565.  
  1566.     SendDlgItemMessage(hDlg,IDD_ANSWERBACK,EM_LIMITTEXT,80,0L);
  1567.     LoadString(hInst,IDS_ANSWERBACKKEY,(LPSTR)key,sizeof(key));
  1568.     GetPrivateProfileString((LPSTR)szAppName,(LPSTR)key,
  1569.                 (LPSTR)"",buf, sizeof(buf),szIniName);
  1570.     SetDlgItemText(hDlg, IDD_ANSWERBACK, buf);
  1571.  
  1572. }
  1573.  
  1574. static void NEAR SetKeyboardBox(HWND hDlg)
  1575. {
  1576.     register int i, val;
  1577.     BOOL save = IsDlgButtonChecked(hDlg, IDD_SAVE);
  1578.  
  1579.     char szKeyStr[80];
  1580.     char szValStr[80];
  1581.  
  1582.     for (i = IDD_KEYPADNUMERIC; i < IDD_KEYPADAPPL; i++)
  1583.     if (SendDlgItemMessage(hDlg, i, BM_GETCHECK, 0, 0L))
  1584.         break;
  1585.     MWnd.ApplMode = i - IDD_KEYPADNUMERIC;
  1586.     if (save) {
  1587.     Initdata.AltKeypad = MWnd.ApplMode;
  1588.     SaveInitData(IDS_ALTKEYPAD, Initdata.AltKeypad);
  1589.     }
  1590.  
  1591.     for (i = IDD_CURKEYSNORMAL; i < IDD_CURKEYSAPPL; i++)
  1592.     if (SendDlgItemMessage(hDlg, i, BM_GETCHECK, 0, 0L))
  1593.         break;
  1594.     MWnd.CurKeyMode = i - IDD_CURKEYSNORMAL;
  1595.     if (save) {
  1596.     Initdata.CursorKeys = MWnd.CurKeyMode;
  1597.     SaveInitData(IDS_CURSORKEYS, Initdata.CursorKeys);
  1598.     }
  1599.  
  1600.     for (i = IDD_BKSPNORMAL; i < IDD_BKSPDELETE; i++)
  1601.     if (SendDlgItemMessage(hDlg, i, BM_GETCHECK, 0, 0L))
  1602.         break;
  1603.     MWnd.DeleteKey = i - IDD_BKSPNORMAL;
  1604.     if (save) {
  1605.     Initdata.DeleteKey = MWnd.DeleteKey;
  1606.     SaveInitData(IDS_DELETEKEY, Initdata.DeleteKey);
  1607.     }
  1608.  
  1609.     val = (IsDlgButtonChecked(hDlg, IDD_BREAKKEY) ? 1 : 0);
  1610.     MWnd.BreakEnabled = val;
  1611.     if (save) {
  1612.     Initdata.BreakEnabled = val;
  1613.     SaveInitData(IDS_BREAKKEYENABLED, val);
  1614.     }
  1615.  
  1616.     val = (IsDlgButtonChecked(hDlg, IDD_AUTOANSWER) ? 1 : 0);
  1617.     MWnd.AutoAnswer = val;
  1618.     if (save) {
  1619.     Initdata.AutoAnswer = val;
  1620.     SaveInitData(IDS_AUTOANSWER, val);
  1621.     }
  1622.  
  1623.     LoadString(hInst,IDS_ANSWERBACKKEY,(LPSTR)szKeyStr,sizeof(szKeyStr));
  1624.     GetDlgItemText(hDlg, IDD_ANSWERBACK, (LPSTR)szValStr, sizeof(szValStr));
  1625.     WritePrivateProfileString(szAppName, szKeyStr, szValStr, szIniName);
  1626.  
  1627.     BroadcastWinIniChange();
  1628. }
  1629.  
  1630. CBInsertString(HWND hDlg, int id, int index, char * buf)
  1631. {
  1632.     return (int)SendDlgItemMessage(hDlg, (unsigned)id, CB_INSERTSTRING,
  1633.                   (WORD)index, (LONG)(LPSTR)buf);
  1634. }
  1635.  
  1636. CBSetCursel(HWND hDlg, int id, int index)
  1637. {
  1638.     return (int)SendDlgItemMessage(hDlg,(unsigned)id,
  1639.                    CB_SETCURSEL,(WORD)index,0L);
  1640. }
  1641.  
  1642. CBGetCursel(HWND hDlg, int id)
  1643. {
  1644.     return (int)SendDlgItemMessage(hDlg,(unsigned)id,CB_GETCURSEL,0,0L);
  1645. }
  1646.  
  1647. static void NEAR SaveInitData(int id, int val)
  1648. {
  1649.     char szKeyStr[80];
  1650.     char buf[40];
  1651.  
  1652.     LoadString(hInst, id, szKeyStr, sizeof(szKeyStr));
  1653.     WritePrivateProfileString(szAppName,szKeyStr,itoa(val,buf,10),szIniName);
  1654.  
  1655. }
  1656.