clients/userreg/display.c

   1 /*
   2  *      $Source$
   3  *      $Author$
   4  *      $Locker$
   5  *      $Header$
   6  */
   7
   8 #ifndef lint
   9 static char *rcsid_display_c = "$Header$";
  10 #endif  lint
  11
  12 #include <stdio.h>
  13 #include <curses.h>
  14 #include <sys/time.h>
  15 #include "userreg.h"
  16
  17 #define DESC_WIDTH 18
  18 #define HEADER "*** Project Athena User Registration ***"
  19 #ifdef ibm032
  20 #define HELP   " Press backspace to delete a character.  Press Ctrl-C to start over."
  21 #else
  22 #ifdef vax
  23 #define HELP   " Press the key marked <X| to delete a character.  Press Ctrl-C to start over."
  24 #endif
  25 #endif
  26 #define BORDER_CHAR '-'
  27 #define MIN_COLS 80
  28 #define MIN_LINES 24
  29
  30 WINDOW * displayw, *queryw;
  31 WINDOW * dataw, *helpw;
  32 WINDOW * fnamew, *midw, *lnamew, *idw, *loginw;
  33
  34 /* Set up the windows and subwindows on the display */
  35 setup_display () {
  36   FILE * freopen ();
  37
  38   initscr ();                   /* Start up curses */
  39
  40   if (COLS < MIN_COLS || LINES < MIN_LINES) {
  41     fprintf (stderr, "Screen must be at least %d x %d\n", MIN_LINES, MIN_COLS);
  42     exit (1);
  43   }
  44
  45   noecho ();                    /* And the tty input */
  46   raw ();
  47   freopen ("/dev/null", "w", stderr);/* Toss the standard error output */
  48
  49  /* Make sure the place is clean */
  50   clear ();
  51
  52  /* Set up the top-level windows */
  53  /* First line is the header */
  54   displayw = subwin (stdscr, 12, 0, 2, 0);/* Lines 2-13 */
  55   scrollok (displayw, TRUE);
  56
  57   queryw = subwin (stdscr, 1, 0, 15, 0);/* Line 15 */
  58   scrollok (queryw, TRUE);
  59
  60   dataw = subwin (stdscr, 5, 0, 17, 0);/* Lines 17-21 */
  61
  62  /* Set up the data windows */
  63   fnamew = subwin (stdscr, 1, 0, 17, DESC_WIDTH);
  64   midw = subwin (stdscr, 1, 0, 18, DESC_WIDTH);
  65   lnamew = subwin (stdscr, 1, 0, 19, DESC_WIDTH);
  66   idw = subwin (stdscr, 1, 0, 20, DESC_WIDTH);
  67   loginw = subwin (stdscr, 1, 0, 21, DESC_WIDTH);
  68
  69 }
  70
  71 /* Clear and restore the display */
  72 reset_display () {
  73   clear ();
  74
  75  /* Put back the borders */
  76   make_border (1);
  77   make_border (14);
  78   make_border (16);
  79   make_border (22);
  80
  81
  82  /* Put in the window dressing */
  83   wmove (dataw, 0, 0);
  84   waddstr (dataw, "First Name:\n");
  85   waddstr (dataw, "Middle Initial:\n");
  86   waddstr (dataw, "Family Name:\n");
  87   waddstr (dataw, "MIT ID #:\n\n");
  88   waddstr (dataw, "Username:\n");
  89   wclrtoeol (dataw);
  90
  91  /* Set up the header */
  92   mvaddstr (0, (COLS - strlen (HEADER)) / 2, HEADER);
  93   mvaddstr (23, 0, HELP);
  94
  95  /* Put it all up */
  96   refresh ();
  97 }
  98
  99
 100 /* Make a one-line border on line l of stdscr */
 101 make_border (l)
 102 int   l;
 103 {
 104   int   i;
 105
 106   move (l, 0);
 107   for (i = 0; i < COLS - 1; i++) {
 108     addch (BORDER_CHAR);
 109   }
 110 }
 111
 112 /* This replaces several "useful" display functions in the old userreg */
 113 redisp () {
 114   mvwprintw (fnamew, 0, 0, "%-24s", user.u_first);
 115   mvwprintw (midw, 0, 0, "%-24s", user.u_mid_init);
 116   mvwprintw (lnamew, 0, 0, "%-24s", user.u_last);
 117   mvwprintw (idw, 0, 0, "%-24s", typed_mit_id);
 118   mvwprintw (loginw, 0, 0, "%-24s", user.u_login);
 119
 120   wrefresh (dataw);
 121 }
 122
 123
 124 /* Input and input_no_echo exist only to save on retyping */
 125 input (prompt, buf, maxsize, timeout, emptyok)
 126 char *prompt;
 127 char *buf;
 128 int   maxsize, timeout, emptyok;
 129 {
 130   query_user (prompt, buf, maxsize, timeout, TRUE, emptyok, TRUE);
 131 }
 132
 133 input_no_echo (prompt, buf, maxsize, timeout)
 134 char *prompt;
 135 char *buf;
 136 int   maxsize, timeout;
 137 {
 138   query_user (prompt, buf, maxsize, timeout, FALSE, FALSE, TRUE);
 139 }
 140
 141
 142 /* make the user press any key to continue */
 143 wait_for_user ()
 144 {
 145     char buf[BUFSIZ];
 146
 147     redisp();
 148     query_user ("Press RETURN or ENTER to continue", buf, 1,
 149                 15 * 60, FALSE, TRUE, FALSE);
 150 }
 151
 152
 153 /* Gets input through the query buffer */
 154 /* Exit(1)'s on read errors */
 155 /* Signals SIGALRM after 'timeout' seconds */
 156 query_user (prompt, buf, maxsize, timeout, echop, emptyok, valuep)
 157 char *prompt;
 158 char *buf;
 159 int   maxsize, timeout;
 160 bool echop, emptyok, valuep;
 161 {
 162   char  c;
 163   int   i;
 164   struct itimerval it;
 165
 166 retry:
 167   /* Set up interval timer */
 168   it.it_interval.tv_sec = 0;
 169   it.it_interval.tv_usec = 0;
 170   it.it_value.tv_sec = timeout;
 171   it.it_value.tv_usec = 0;
 172   setitimer (ITIMER_REAL, &it, (struct itimerval *) 0);
 173
 174   /* Erase the query window and put up a prompt */
 175   werase (queryw);
 176   mvwaddstr (queryw, 0, 0, prompt);
 177   waddch (queryw, ' ');         /* Put in a space, as Blox does */
 178   wrefresh (queryw);
 179
 180   i = 0;
 181   while ((c = getchar ()) != '\r') {
 182    switch (c) {
 183      case '\025':               /* Ctl-U */
 184         goto retry;
 185         break;
 186       case EOF:
 187         /* We're in raw mode, so EOF means disaster */
 188         exit(1);
 189         break;
 190       case '\177':              /* Delete */
 191       case '\010':              /* Backspace */
 192         if (i) {
 193           i--;
 194           if (echop) {
 195             wmove (queryw, queryw -> _cury, queryw -> _curx - 1);
 196             wclrtoeol (queryw);
 197             wrefresh (queryw);
 198           }
 199         }
 200         break;
 201       case '\003':              /* Ctrl-C */
 202         if (getuid() != 0)
 203           { clear();            /* Exit if not root. */
 204             restore_display();
 205             exit(0);
 206           }
 207         else
 208           restart();
 209         break;
 210       default:
 211         if (c >= ' ') {         /* Ignore all other control chars */
 212           buf[i++] = c;
 213           if (echop) {
 214             waddch (queryw, c);
 215             wrefresh (queryw);
 216           }
 217         }
 218         break;
 219     }
 220     if (valuep && i >= maxsize) {
 221       wprintw (displayw,
 222   "You are not allowed to type more than %d characters for this answer.\n",
 223           maxsize);
 224       wrefresh (displayw);
 225       goto retry;
 226     }
 227  }
 228
 229   if (i == 0) {
 230       if (emptyok && valuep &&
 231           (askyn("Do you really want this field left blank (y/n)? ") == NO))
 232         goto retry;
 233       if (!emptyok) {
 234           wprintw(displayw, "You must enter something here.\n");
 235           wrefresh(displayw);
 236           goto retry;
 237       }
 238   }
 239
 240
 241   /* Input is complete so disable interval timer. */
 242   it.it_interval.tv_sec = 0;
 243   it.it_interval.tv_usec = 0;
 244   it.it_value.tv_sec = 0;
 245   it.it_value.tv_usec = 0;
 246   setitimer (ITIMER_REAL, &it, (struct itimerval *) 0);
 247
 248   buf[i] = '\0';                /* Put a null on the end */
 249
 250   werase (queryw);              /* Clean up the query window */
 251   wrefresh (queryw);
 252
 253   return;                       /* And get out of here. */
 254 }
 255
 256 int
 257 askyn(prompt)
 258      char *prompt;
 259 {
 260   int ypos, xpos;
 261   int answer;
 262   struct itimerval it;
 263   char c;
 264
 265  start:
 266   werase (queryw);
 267   mvwaddstr (queryw, 0, 0, prompt);
 268   wrefresh (queryw);
 269
 270   xpos = queryw->_curx;
 271   ypos = queryw->_cury;
 272   answer = 2;                   /* No answer. */
 273
 274   /* Reset interval timer for y/n question. */
 275   it.it_interval.tv_sec = 0;
 276   it.it_interval.tv_usec = 0;
 277   it.it_value.tv_sec = YN_TIMEOUT;
 278   it.it_value.tv_usec = 0;
 279   setitimer (ITIMER_REAL, &it, (struct itimerval *) 0);
 280
 281   while ((c = getchar ()) != '\r') {    /* Wait for CR. */
 282       switch (c) {
 283       case 'n':                 /* No. */
 284       case 'N':
 285         wmove(queryw, ypos, xpos);
 286         wclrtoeol(queryw);
 287         waddstr(queryw, "no");
 288         wrefresh(queryw);
 289         answer = NO;
 290         continue;
 291       case 'y':                 /* Yes. */
 292       case 'Y':
 293         wmove(queryw, ypos, xpos);
 294         wclrtoeol(queryw);
 295         waddstr(queryw, "yes");
 296         wrefresh(queryw);
 297         answer = YES;
 298         continue;
 299       case '\177':              /* Delete */
 300       case '\010':              /* Backspace */
 301       case '\025':              /* Ctl-U */
 302         wmove(queryw, ypos, xpos);
 303         wclrtoeol(queryw);
 304         wrefresh(queryw);
 305         answer = 2;             /* No answer. */
 306         break;
 307       case EOF:
 308         /* We're in raw mode, so EOF means disaster */
 309         exit(1);
 310         break;
 311       case '\003':              /* Ctrl-C */
 312 /*      if (getuid() != 0) */
 313           { clear();            /* Exit if not root. */
 314             restore_display();
 315             exit(0);
 316           }
 317         break;
 318       default:                  /* Ignore everything else. */
 319         break;
 320       }
 321     }
 322
 323   if (answer == 2)              /* No answer. */
 324     { display_text_line(0);
 325       display_text_line("Please answer y or n.");
 326       goto start;
 327     }
 328
 329   return(answer);
 330 }
 331
 332 /* Display_text_line puts up a line of text in the display window */
 333 /* Special case: if line is 0, clear the display area */
 334 display_text_line (line)
 335 char *line;
 336 {
 337   if (line) {
 338     waddstr (displayw, line);
 339     waddch (displayw, '\n');
 340     wrefresh (displayw);
 341   }
 342   else {
 343     werase (displayw);
 344   }
 345   wrefresh (displayw);
 346 }
 347
 348 /* Display_text displays a canned message from a file */
 349 display_text (filename)
 350 char *filename;
 351 {
 352   FILE * fp;
 353   char  buf[100];
 354
 355   werase (displayw);
 356   if ((fp = fopen (filename, "r")) == NULL) {
 357     wprintw (displayw, "Can't open file %s for reading.\n", filename);
 358     return;
 359   }
 360
 361   while (fgets (buf, 100, fp)) {
 362   /* get rid of the newline */
 363     buf[strlen (buf) - 1] = 0;
 364     display_text_line (buf);
 365   }
 366
 367   fclose (fp);
 368 }
 369
 370 /* Clear_display wipes the display and turns off curses */
 371 restore_display()
 372 {
 373   clear();
 374   refresh();
 375   noraw();
 376   echo();
 377   endwin();
 378 }
 379
 380 timer_on()
 381 {
 382   struct itimerval it;
 383
 384   it.it_interval.tv_sec = 0;
 385   it.it_interval.tv_usec = 0;
 386   it.it_value.tv_sec = TIMER_TIMEOUT;
 387   it.it_value.tv_usec = 0;
 388   setitimer (ITIMER_REAL, &it, (struct itimerval *) 0);
 389 }
 390
 391 timer_off()
 392 {
 393   struct itimerval it;
 394
 395   it.it_interval.tv_sec = 0;
 396   it.it_interval.tv_usec = 0;
 397   it.it_value.tv_sec = 0;
 398   it.it_value.tv_usec = 0;
 399   setitimer (ITIMER_REAL, &it, (struct itimerval *) 0);
 400 }
 401
 402
 403 wfeep()
 404 {
 405     char buf = '\007';
 406     write(1, &buf, 1);
 407 }