home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume3 / ttype < prev    next >
Encoding:
Internet Message Format  |  1986-11-30  |  14.4 KB
  1. From: talcott!harvard!uucp
  2. Newsgroups: mod.sources
  3. Subject: ttype: typing tutor
  4. Approved: jpn@panda.UUCP
  5.  
  6. Mod.sources:  Volume 3, Issue 42
  7. Submitted by: ??? (Chris Bertin)
  8.  
  9.  
  10. Several people have been asking for a touch-type program. I wrote this a
  11. long time ago (and posted it back then). It used to be called 'type' but
  12. should be renamed 'ttype' to avoid conflict with the shell's builtin.
  13. The instructions are on line and it needs -lcurses and -ltermcap. It should
  14. work on any BSD system with very few modifications.
  15.  
  16. --------------------------  cut here  -------------------------------
  17. static char cpright[] = "(C) Chris Bertin, 1983";
  18.  
  19. /*
  20.  * Learn how to type ( using cursor control if run on a CRT )
  21.  */
  22.  
  23. #include <sys/types.h>
  24. #include <sys/stat.h>
  25. #include <sys/timeb.h>
  26. #include <sys/time.h>
  27. #include <sys/ioctl.h>
  28. #include <stdio.h>
  29. #include <ctype.h>
  30. #include <signal.h>
  31. #include <curses.h>
  32.  
  33. #define WORDLIST    "/usr/dict/words"
  34. #define LFCR        "\n\r"
  35. #define CHAR    0    /* answer types */
  36. #define NUM    1    /* ... */
  37. #define PRACTICE 0    /* run types */
  38. #define DICT    1    /* ... */
  39. #define FILEIN    2    /* ... */
  40. #define MAX    128    /* std array size as well as max ASCII */
  41. #define SPEED    0    /* screen locations */
  42. #define SCORE    2    /* ... */
  43. #define TYPE    LINES -12    /* ... */
  44. #define ASK    LINES - 3    /* ... */
  45. #define BOTTOM    LINES - 2    /* ... */
  46. #define ALLCHARS "&*()_+|\\{}:\"~<>?-=[];'`,./!#$%^ ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890 abcdefghijklmnopqrstuvwxyz"
  47.  
  48. #define moveto(x,y,str) if(CA)move(x,y),clrtoeol();else pr(0,str);
  49. #define dorefresh()    if(CA){clearok(stdscr,TRUE);refresh();clearok(stdscr,FALSE);}
  50. #define sethelp()    wclear(helpscr);wrefresh(helpscr);moveto(TYPE,0,LFCR);
  51.  
  52. char what_chars[MAX*2];    /* the characters to practice on */
  53. char try_str[MAX*2];    /* the string to be retyped */
  54. char typed_str[MAX*2];    /* the chars being typed by the user */
  55. char work_str[MAX*2];    /* work space (temp string) */
  56. char badchar[MAX];    /* errors; the mistyped chars are pointers into them */
  57. char gbadchar[MAX];    /* same but session total */
  58. int echo_it;        /* echo flag */
  59. int isafastscreen;    /* is a fast screen? */
  60. int trials;        /* number of trials */
  61. int npractice;        /* number of characters to practice on (practice opt.)*/
  62. int lasterr;        /* last error, the next string will start with it */
  63. int linerrors, toterrors, gtoterrors;    /* errors per line / run / session */
  64. float totlngth, gtotlngth;    /* chars typed per run / session */
  65. float tottime, gtottime;    /* time spent per run / session */
  66.  
  67. struct timeb tb, ta;
  68. struct stat sbuf;
  69. FILE *fp, *dictfp, *fopen();
  70. WINDOW *helpscr, *subwin();
  71.  
  72. main()
  73. {
  74.     register option, screenloc, lngth, more = 1;
  75.     int out_size, nwords, instruct;
  76.     char fname[MAX];
  77.     float chkstr();
  78.  
  79.     setbuf(stdin, (char *)NULL);
  80.     ftime(&ta);
  81.     srandom(getpid() + ta.millitm - getuid()); /* should be unique... */
  82.     initscr();
  83.     scrollok(stdscr, FALSE);
  84.     (void) signal(SIGFPE, SIG_IGN);
  85.     if(CA) /* Do we have cursor control?? */
  86.         isafastscreen = highspeed();
  87.     else
  88.         pr(1, "[No cursor addressing, using hard copy mode]\n");
  89.     raw(), noecho();
  90.     moveto(TYPE - 6, 0, "");
  91.     pr(2, "\t\t\tL E A R N  H O W  T O  T Y P E");
  92.     pr(2, "\t\t\t~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
  93.     if(instruct = answer(work_str, "Instructions? (y or n)", CHAR) == 1)
  94.         helpscr = subwin(stdscr, 9, COLS, TYPE, 0);
  95.     gtoterrors = gtotlngth = gtottime = 0.;
  96.     zero(gbadchar, sizeof gbadchar);
  97.     while(more) {
  98.         screenloc = TYPE;
  99.         if(instruct)
  100.             help1();
  101.         (void) answer(work_str, "What characters do you want?", CHAR);
  102.         if(! strcmp(work_str, "words")) {
  103.             option = DICT;
  104.             if(dictfp == NULL) /* don't redo it */
  105.                 if(((stat(WORDLIST, &sbuf)) < 0) ||
  106.                    ((dictfp = fopen(WORDLIST,"r")) == NULL)){
  107.                     note("Can't open %s", WORDLIST);
  108.                     continue;
  109.                 }
  110.             if(instruct)
  111.                 help3();
  112.             nwords = answer(work_str,
  113.                 "How many words in each line?", NUM);
  114.             if(nwords > COLS/11)
  115.                 note("Set to maximum allowed (%d)",
  116.                     (nwords = COLS/11));
  117.         }
  118.         else if(! strcmp(work_str, "file")) {
  119.             option = FILEIN;
  120.             if(instruct)
  121.                 help2();
  122.             (void) answer(fname, "Enter file name", CHAR);
  123.             if(! *fname)
  124.                 continue;
  125.             if((fp = fopen(fname, "r")) == NULL) {
  126.                 note("Can't open %s", fname);
  127.                 continue;
  128.             }
  129.         }
  130.         else {
  131.             option = PRACTICE;
  132.             strcpy(what_chars, work_str[0] ? work_str : ALLCHARS);
  133.             npractice = strlen(what_chars);
  134.             if(instruct)
  135.                 help4();
  136.             out_size = answer(work_str,
  137.                 "How many characters in each string?", NUM);
  138.         }
  139.         if(option != FILEIN) {
  140.             if(instruct)
  141.                 help5();
  142.             trials = answer(work_str, "How many trials?", NUM);
  143.         }
  144.         if(instruct)
  145.             help6();
  146.         echo_it = answer(work_str, "Do you want echo?", CHAR);
  147.         if(instruct)
  148.             help7();
  149.         zero(badchar, sizeof badchar);
  150.         lasterr = toterrors = 0;
  151.         totlngth = tottime = 0.;
  152.         if(CA)
  153.             clear();
  154.         moveto(SCORE, 0, LFCR);
  155.         pr(2, "\tNext line: ^C, Quit: ^D, Move Cursor: ^A, Redraw: ^L");
  156.         while(makestr(option, out_size, nwords) >= 0) {
  157.             ioctl(0, TIOCFLUSH, 0);
  158.             if(CA)
  159.                 note("", "");
  160.             if((lngth = chkstr(screenloc)) == 0)
  161.                 continue;
  162.             totlngth += lngth;
  163.             toterrors += linerrors;
  164.             if(isafastscreen)
  165.                 score(badchar, toterrors, totlngth, tottime);
  166.             if((screenloc += 3) > (ASK - 2))
  167.                 screenloc = TYPE;
  168.         }
  169.         gtotlngth += totlngth;
  170.         gtoterrors += toterrors;
  171.         if( ! CA || ! isafastscreen)
  172.             score(badchar, toterrors, totlngth, tottime);
  173.         more = answer(work_str, "Try again?", CHAR);
  174.     }
  175.     leave();
  176. }
  177.  
  178. answer(str, msg, type)
  179. register char *str;
  180. char *msg;
  181. {
  182.     register c, i, ret = 0;
  183.  
  184.     for(;;) {
  185.         moveto(ASK, 10, "\n\r> ");
  186.         pr(1, "%s: ", msg);
  187.         for(i=0; ((c = getch()) != '\n' && c != '\r') ;)
  188.             switch(c) {
  189.             case '\f':
  190.                 dorefresh();
  191.                 break;
  192.             case '\10':
  193.                 if(i>0)
  194.                     --i, pr(1, "\010 \010");
  195.                 break;
  196.             case '\04':
  197.             case '\03':
  198.             case 0177:
  199.                 leave();
  200.             default:
  201.                 pr(1, "%c", (str[i++] = noctrl(c)));
  202.             }
  203.         if(CA)
  204.             note("", "");
  205.         while(str[--i] == ' ') ;
  206.         str[++i] = 0;
  207.         if(type == CHAR)
  208.             if(*str == 'y')
  209.                 return(1);
  210.             else
  211.                 return(0);
  212.         if((ret = atoi(str)) <= 0) {
  213.             note("Numeric value (> 0) required", "");
  214.             continue;
  215.         }
  216.         return(ret);
  217.     }
  218. }
  219.  
  220. makestr(opt, lng, n_of_wrds) /* builds the string to be typed */
  221. {
  222.     register ind;
  223.  
  224.     if(opt != FILEIN && trials <= 0)
  225.         return(-1);
  226.     zero(try_str, sizeof try_str);
  227.     switch(opt) {
  228.     case FILEIN:
  229.         if(fgets(try_str, sizeof try_str, fp) == NULL)
  230.             return(fclose(fp));
  231.         fixstr(try_str);
  232.         return(1);
  233.     case DICT:
  234.         for(ind = 0; ind < n_of_wrds ; ++ind, strcat(try_str, " ")) {
  235.             if(fseek(dictfp, random()%(long)sbuf.st_size, 0) == -1)
  236.                 strcpy(work_str, "fseek failed!!!");
  237.             fgets(work_str, sizeof work_str, dictfp);
  238.             if(fgets(work_str, sizeof work_str, dictfp) == NULL)
  239.                 strcpy(work_str, "End of file!!!");
  240.             work_str[strlen(work_str) - 1] = 0;
  241.             strcat(try_str, work_str);
  242.         }
  243.         return(--trials);
  244.     case PRACTICE:
  245.         for(ind = 0 ; ind < lng ; ++ind)
  246.             try_str[ind] = what_chars[(int)random() % npractice];
  247.         try_str[0] = (lasterr ? lasterr : try_str[0]);
  248.         lasterr = 0;
  249.         return(--trials);
  250.     }
  251.     /* NOTREACHED */
  252. }
  253.  
  254. fixstr(str)
  255. char *str;
  256. {
  257.     register char *in, *out;
  258.     short space = 0;
  259.  
  260.     for(in = str ; isspace(*in) ; ++in) ;
  261.     for(out = str ; *in ; ++in) {
  262.         if(*in == '\010') {
  263.             if(out > str)
  264.                 out--;
  265.             continue;
  266.         }
  267.         if(isspace(*in) && space)
  268.             continue;
  269.         space = isspace(*in);
  270.         *out++ = noctrl(*in);
  271.     }
  272.     *out = 0;
  273. }
  274.  
  275. float
  276. chkstr(location) /* checks the typing */
  277. {
  278.     register ind, c = 0;
  279.     register char *typed_pnt;
  280.     register float n_of_chars;
  281.     float f, elapsed, starttime, gettime();
  282.  
  283.     zero(typed_str, sizeof typed_str);
  284.     typed_pnt = typed_str;
  285.     if(strlen(try_str) >= COLS-1) {
  286.         note("Line too long, truncated", "");
  287.         try_str[COLS-1] = 0;
  288.     }
  289.     if((n_of_chars = (float) putline(try_str, location)) == 0.)
  290.         return(0.);
  291.     moveto(location+1, 0, LFCR);
  292.     refresh();
  293.     for(linerrors = ind = 0; ind < n_of_chars ; ++ind) {
  294.         switch(c = getch()) {
  295.           case '\01':
  296.             *typed_pnt = '^';
  297.             *(typed_pnt+1) = 0;
  298.             (void) putline(typed_str, location+1);
  299.             printw("%c", '\10');
  300.             refresh(); /* fall through */
  301.           case '\n':
  302.           case '\r':
  303.             --ind;
  304.             break;
  305.           case '\f':
  306.             dorefresh();
  307.             --ind;
  308.             break;
  309.           case '\03':
  310.             if((n_of_chars = ind) == 0) /* force out */
  311.                 return(0.);
  312.             break;
  313.           case '\04':
  314.           case 0177:
  315.             gtotlngth += totlngth + ind;
  316.             gtoterrors += toterrors + linerrors;
  317.             leave();
  318.           default: /* a character... */
  319.             if(ind == 0)
  320.                 starttime = gettime(0, "");
  321.             if(c != try_str[ind]) { /* error */
  322.                 if(echo_it)
  323.                     pr(0, "%c", ch_case(c, try_str[ind]));
  324.                 else {
  325. #ifdef SHOWALL
  326.                     *typed_pnt++ = ch_case(c, try_str[ind);
  327. #else
  328.                     *typed_pnt++ = noctrl(c);
  329. #endif
  330.                     *typed_pnt = 0;
  331.                     (void) putline(typed_str, location+1);
  332.                 }
  333.                 warnerror(location+1, ind+1, c, try_str[ind]);
  334.                 lasterr = try_str[ind];
  335.                 ++linerrors;
  336.                 ++badchar[lasterr];
  337.                 ++gbadchar[lasterr];
  338.             }
  339.             else {
  340.                 if(echo_it)
  341.                     pr(0, "%c", noctrl(c));
  342.                 else
  343. #ifdef SHOWALL
  344.                     *typed_pnt++ = noctrl(c);
  345. #else
  346.                     *typed_pnt++ = ' ';
  347. #endif
  348.                 clrtoeol();
  349.             }
  350.             refresh();
  351.             break;
  352.         }
  353.     }
  354.     *typed_pnt = 0;
  355. #ifdef SHOWALL
  356.     if(! echo_it)
  357.         (void) putline(typed_str, location+1);
  358. #endif
  359.     standend();
  360.     clrtoeol();
  361.     elapsed = gettime(12, "/ ") - starttime;
  362.     tottime += elapsed;
  363.     gtottime += elapsed;
  364.     moveto(SPEED, COLS-40, LFCR);
  365.     standout();
  366.     if(! CA)
  367.         printf("\t\t\t\t");
  368.     pr(2, "%.1f secs, %d error(s), %.2f w/min", elapsed, linerrors,
  369.         (f=((n_of_chars / 5.) - linerrors) / (elapsed / 60.))>0.?f:0.0);
  370.     standend();
  371.     refresh();
  372.     return(n_of_chars);
  373. }
  374.  
  375. float
  376. gettime(where, str)
  377. register char *str;
  378. {
  379.     struct tm *localtime();
  380.     register struct tm *tm;
  381.     register x, y;
  382.  
  383.     ftime(&tb);
  384.     if(isafastscreen) {
  385.         tm = localtime(&tb.time);
  386.         getyx(stdscr, y, x);
  387.         move(SPEED, where);
  388.         pr(1, "%s%02d:%02d:%02d.%02d", str, tm->tm_hour, tm->tm_min,
  389.             tm->tm_sec, (tb.millitm / 10));
  390.         clrtoeol();
  391.         move(y, x);
  392.         refresh();
  393.     }
  394.     return((float) (tb.time - ta.time) + ((float)tb.millitm / 1000.));
  395. }
  396.  
  397. putline(outstr, where)
  398. register char *outstr;
  399. {
  400.     register n;
  401.     char *rindex();
  402.     register char *back = rindex(outstr, '\0') - 1;
  403.  
  404.     while(isspace(*back))
  405.         *back-- = 0;
  406.     moveto(where, 0, "\r");
  407.     for(n = 0 ; *outstr ; ++n)
  408.         pr(0, "%c", noctrl(*outstr++));
  409.     if(n)
  410.         refresh();
  411.     return(n);
  412. }
  413.  
  414. warnerror(x, y, goodc, badc)
  415. {
  416.     if(! isafastscreen || y > COLS-15) {
  417.         putchar('\07');
  418.         return;
  419.     }
  420.     clrtoeol();
  421.     move(x, y+3);
  422.     standout();
  423.     pr(0, "Error (%c/%c)", goodc, badc);
  424.     standend();
  425.     move(x, y);
  426.     refresh();
  427. }
  428.  
  429. /* NOSTRICT */
  430. /* VARARGS */
  431. note(str1, str2)
  432. char *str1;
  433. long str2;
  434. {
  435.     moveto(BOTTOM+1, COLS-40, LFCR);
  436.     clrtoeol();
  437.     standout();
  438.     pr(2, str1, str2);
  439.     standend();
  440. }
  441.  
  442. ch_case(bad, good) /* converts to upper or lower case */
  443. {
  444.     register ret;
  445.  
  446.     if(isupper(bad))
  447.         return((good - (ret=tolower(bad))) ? ret : bad);
  448.     if(islower(bad))
  449.         return((good - (ret=toupper(bad))) ? ret : bad);
  450.     return(noctrl(bad));
  451. }
  452.  
  453. noctrl(ch)
  454. register ch;
  455. {
  456.     if(ch == '\t')
  457.         return(' ');
  458.     return(iscntrl(ch) ? (ch - '\01' + 'A') : ch);
  459. }
  460.  
  461. score(errstr, err, lng, ttime) /* prints the score */
  462. char *errstr;
  463. register float lng, ttime;
  464. {
  465.     register s, i, n=0;
  466.     float f;
  467.  
  468.     if(lng == 0.)
  469.         return;
  470.     moveto(SCORE, 0, "\n\n\r");
  471.     s = (lng - (float) err) * 100. / lng;
  472.     pr(0,"%d errors on %.0f characters (%d %% error), ", err, lng, (100-s));
  473.     pr(1, "average speed: %.2f words/minute",
  474.         ((f = ((lng / 5.) - err) / (ttime / 60.)) >0. ? f : 0.), err);
  475.     if(err) {
  476.         moveto(SCORE + 2, 0, LFCR);
  477.         for(n = i = 0 ; i < MAX ; ++i)
  478.             if(errstr[i] != 0) {
  479.                 pr(0, "%4d errors on '%c'", errstr[i], i);
  480.                 if(++n > 3) {
  481.                     n = 0;
  482.                     pr(1, LFCR);
  483.                 }
  484.             }
  485.         pr(1, LFCR);
  486.     }
  487.     return;
  488. }
  489.  
  490. /* NOSTRICT */
  491. /* VARARGS */
  492. pr(mode, fmt, str1, str2, str3, str4, str5) /* mode 2: add LFCR, 1: refresh() */
  493. char *fmt;
  494. long str1, str2, str3, str4, str5;
  495. {
  496.     if( CA) {
  497.         printw(fmt, str1, str2, str3, str4, str5);
  498.         if(mode == 2)
  499.             printw(LFCR);
  500.         if(mode > 0)
  501.             refresh();
  502.     }
  503.     else {
  504.         printf(fmt, str1, str2, str3, str4, str5);
  505.         if(mode == 2)
  506.             printf(LFCR);
  507.         fflush(stdout);
  508.     }
  509. }
  510.  
  511. highspeed() /*return 1 if 1200 baud or more */
  512. {
  513.     struct sgttyb mod;
  514.  
  515.     gtty(0, &mod);
  516.     if(mod.sg_ispeed >= B1200)
  517.         return(1);
  518.     move(ASK, 10);
  519.     pr(1, "[Using slow terminal mode]");
  520.     return(0);
  521. }
  522.  
  523. help1()
  524. {
  525.     sethelp();
  526.     pr(2,"\t If you just hit  <RETURN>,  the system will give you  random");
  527.     pr(2,"\tcharacters  picked from all the  characters of your  keyboard");
  528.     pr(2,"\tto practice on. If you want to limit the range of characters,");
  529.     pr(2,"\tenter the list followed by a <RETURN>.");
  530.     pr(2,"\t If you want to practice on random words from the dictionnary");
  531.     pr(2,"\ttype 'words', and if you want to practice on an existing file");
  532.     pr(2,"\ttype 'file'.");
  533. }
  534.  
  535. help2()
  536. {
  537.     sethelp();
  538.     pr(2, "\tThe system will print one by one all the lines from the file");
  539.     pr(2, "\tand wait for you to retype them.   If the file is not in the");
  540.     pr(2, "\tcurrent directory, enter the full path name (Ex:/home/test).");
  541.     pr(2, "\t Note:   trailing spaces and tabs are truncated, tabs in the");
  542.     pr(2, "\tlines are replaced with spaces and empty lines are skipped.");
  543. }
  544.  
  545. help3()
  546. {
  547.     sethelp();
  548.     pr(2, "\t The system will now pick random words from the dictionary.");
  549.     pr(2, "\tEnter  the number of words you want the system to  give you");
  550.     pr(2, "\ton each line.");
  551. }
  552.  
  553. help4()
  554. {
  555.     sethelp();
  556.     pr(2, "\t The system will now make strings of characters for you to");
  557.     pr(2, "\tpractice on. Enter the length that you want each string to");
  558.     pr(2, "\tbe.");
  559. }
  560.  
  561. help5()
  562. {
  563.     sethelp();
  564.     pr(2, "\t How many lines do you want the system to give you before");
  565.     pr(2, "\tit resets the errors to zero?");
  566. }
  567.  
  568. help6()
  569. {
  570.     sethelp();
  571.     pr(2,"\t Do you want to see the characters you are typing as you type");
  572. #ifdef SHOWALL
  573.     pr(2,"\tthem?  If you type 'no', the line will be printed only if you");
  574.     pr(2,"\tmake a mistake.  In any case, it is  printed in full when the");
  575.     pr(2,"\tline is complete.");
  576. #else
  577.     pr(2,"\tthem?  If you type 'no', only the errors will be printed.");
  578. #endif
  579. }
  580.  
  581. help7()
  582. {
  583.     sethelp();
  584.     pr(2, "\tMiscellaneous Notes: <RETURN>  and  <LINE-FEED> are ignored.");
  585.     pr(2, "\tCtrl_A   moves the cursor to the next character to be typed.");
  586.     pr(2, "\tEach error subtracts one word from the speed.    (The longer");
  587.     pr(2, "\tthe strings to be typed are, the more accurate the speed is)");
  588.     pr(2, "\n\t     ---- Written by Chris Bertin, May 1983 ----");
  589.     if(CA)
  590.         (void) answer(work_str, "Hit <RETURN> to continue", CHAR);
  591. }
  592.  
  593. leave()
  594. {
  595.     if(gtotlngth) {
  596.         moveto(SPEED, 0, LFCR);
  597.         pr(2, "\t\t\tS E S S I O N    T O T A L");
  598.         score(gbadchar, gtoterrors, gtotlngth, gtottime);
  599.     }
  600.     clrtobot();
  601.     moveto(BOTTOM, 0, LFCR);
  602.     refresh();
  603.     endwin();
  604.     exit(0);
  605. }
  606.  
  607. zero(str, n)
  608. register char *str;
  609. register n;
  610. {
  611.     while(n--)
  612.         *str++ = 0;
  613. }
  614. -------------------------- cut here ----------------------------------
  615.  
  616. Chris
  617.  
  618.  
  619.  
  620.  
  621.