开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Modem编程 > 查看源码
window.c
资源名称：minicom-1.83.tar.gz　[点击查看]
上传用户：tianjinjs
上传日期：2007-01-05
资源大小：309k
文件大小：41k
源码类别：

Modem编程

开发平台：

Unix_Linux

window.c：源码内容
  1. /*
  2.  * window.c Very portable window routines.
  3.  * Currently this code is used in _both_ the BBS
  4.  * system and minicom.
  5.  *
  6.  * This file is part of the minicom communications package,
  7.  * Copyright 1991-1996 Miquel van Smoorenburg.
  8.  *
  9.  * This program is free software; you can redistribute it and/or
  10.  * modify it under the terms of the GNU General Public License
  11.  * as published by the Free Software Foundation; either version
  12.  * 2 of the License, or (at your option) any later version.
  13.  *
  14.  * 01.01.98 dickey@clark.net: fix for a history window closing bug
  15.  * fmg 8/20/97: Added support for Search of History Buffer
  16.  */
  18. #include "port.h"
  19. #include "window.h"
  20. #include "charmap.h"
  21. #include "intl.h"
  23. /* Status line code on/off. */
  24. #define ST_LINE 1
  26. /* fmg 2/20/94 macros - Length of Macros */
  28. #ifndef MAC_LEN
  29. #define MAC_LEN 257
  30. #endif
  32. /* Don't want to include all header stuff for three prototypes from sysdep.c */
  33. #if __STDC__
  34.   int setcbreak(int);
  35.   int wxgetch(void);
  36.   void getrowcols(int *rows, int *cols);
  37. #else
  38.   int setcbreak();
  39.   int wxgetch();
  40.   void getrowcols();
  41. #endif
  43. #ifndef BBS
  44. #include "config.h"
  45. #endif
  47. #define BUFFERSIZE 2048
  49. #define swap(x, y) { int d = (x); (x) = (y); (y) = d; }
  51. /* Terminal capabilities */
  52. static char *CM, *IS, *RS, *AC, *EA;
  53. static char *ME, *SE, *UE, *AE;
  54. static char *AS, *MB, *MD, *MR, *SO, *US;
  55. static char *CE, *Al, *Dl, *AL, *DL;
  56. static char *CS, *SF, *SR, *VB, *BL;
  57. static char *VE, *VI, *KS, *KE;
  58. static char *CD, *CL, *IC, *DC;
  59. static char *BC, *CR, *NL;
  60. #if ST_LINE
  61. static char *TS, *FS, *DS;
  62. #endif
  64. /* Special characters */
  65. static char D_UL;
  66. static char D_HOR;
  67. static char D_UR;
  68. static char D_LL;
  69. static char D_VER;
  70. static char D_LR;
  72. static char S_UL;
  73. static char S_HOR;
  74. static char S_UR;
  75. static char S_LL;
  76. static char S_VER;
  77. static char S_LR;
  79. static char _bufstart[BUFFERSIZE];
  80. static char *_bufpos = _bufstart;
  81. static char *_buffend;
  82. static ELM *gmap;
  84. static char curattr = -1;
  85. static char curcolor = -1;
  86. static int curx = -1;
  87. static int cury = -1;
  88. static int _intern = 0;
  89. static int _curstype = CNORMAL;
  90. static int _has_am = 0;
  91. static int _mv_standout = 0;
  92. static ELM oldc;
  93. static int sflag = 0;
  95. /*
  96.  * Smooth is only defined for slow machines running Minicom.
  97.  * With this defined, Minicom will buffer only per-line
  98.  * and the output will look much less 'jerky'. (I hope :-)
  99.  */
  100. #ifdef SMOOTH
  101. static WIN *curwin = NIL_WIN;
  102. extern WIN *us;
  103. #endif
  105. int useattr = 1;
  106. int dirflush = 1;
  107. extern int LINES, COLS;
  108. int usecolor = 0;
  109. WIN *stdwin;
  110. char *_tptr = CNULL;
  111. int screen_ibmpc = 0;
  112. int screen_iso = 0;
  113. int w_init = 0;
  114. #if ST_LINE
  115. int use_status = 0; /* Turned on in main() */
  116. #else
  117. int use_status = 0;
  118. #endif
  120. /* Standard vt100 map (ac cpability) */
  121. static char *def_ac = "+273,253aaffggjjkkllmmnnooqqssttuuvvwwxx";
  123. #if DEBUG
  125. /*
  126.  * Debug to stdout
  127.  */
  128. int debug(s, a1, a2, a3, a4)
  129. char *s;
  130. int a1, a2, a3, a4;
  131. {
  132.   char lala[80];
  134.   snprintf(lala, sizeof(lala), s, a1, a2, a3, a4);
  135.   write(2, lala, strlen(lala));
  136.   return(0);
  137. }
  138. #endif
  140. /* ===== Low level routines ===== */
  142. /*
  143.  * Flush the screen buffer
  144.  */
  145. void wflush()
  146. {
  147.   int todo, done;
  149.   todo = _bufpos - _bufstart;
  150.   _bufpos = _bufstart;
  152.   while(todo > 0) {
  153.    done = write(1, _bufpos, todo);
  154.    if (done > 0) {
  155.    todo -= done;
  156.    _bufpos += done;
  157.    }
  158. if (done < 0 && errno != EINTR) break;
  159.   }
  160.   _bufpos = _bufstart;
  161. }
  163. /*
  164.  * Output a raw character to the screen
  165.  */
  166. static int outchar(c)
  167. int c;
  168. {
  169.   *_bufpos++ = c;
  170.   if (_bufpos >= _buffend) wflush();
  171. #if defined(SMOOTH)
  172.   if (curwin == us && (c == 'n' || c == 'r')) wflush();
  173. #endif
  174.   return(0);
  175. }
  177. /*
  178.  * Output a raw string to the screen.
  179.  */
  180. static void outstr(s)
  181. char *s;
  182. {
  183.   tputs(s, 1, outchar);
  184. }
  187. /*
  188.  * Turn off all attributes
  189.  */
  190. static void _attroff()
  191. {
  192.   if (ME != CNULL)
  193.    outstr(ME);
  194.   else {
  195.    if (SE != CNULL) outstr(SE);
  196.    if (UE != CNULL) outstr(UE);
  197.   }
  198.   if (AE != CNULL) outstr(AE);
  199. }
  201. /*
  202.  * Turn some attributes on
  203.  */
  204. static void _attron(attr)
  205. char attr;
  206. {
  207.   if (!usecolor || (attr & XA_REVERSE) == 0) {
  208. /* Reverse standout does not look too good.. */
  209. if (attr & XA_BOLD && MD != CNULL)  outstr(MD);
  210.    if (attr & XA_STANDOUT   && SO != CNULL)  outstr(SO);
  211. if (attr & XA_UNDERLINE  && US != CNULL)  outstr(US);
  212.   }
  213.   if (attr & XA_REVERSE   && MR != CNULL)  outstr(MR);
  214.   if (attr & XA_BLINK      && MB != CNULL)  outstr(MB);
  215.   if (attr & XA_ALTCHARSET && AS != CNULL)  outstr(AS);
  216. }
  218. /*
  219.  * Set the colors
  220.  */
  221. static void _colson(color)
  222. char color;
  223. {
  224.   char buf[12];
  225.   sprintf(buf, "33[%d;%dm", COLFG(color) + 30, COLBG(color) + 40);
  226.   outstr(buf);
  227. }
  228.   
  229. /*
  230.  * Set global attributes, if different.
  231.  */
  232. static void _setattr(attr, color)
  233. char attr, color;
  234. {
  235.   if (!useattr) return;
  237.   if (!usecolor) {
  238.    curcolor = color;
  239.    if (attr == curattr) return;
  240.    curattr = attr;
  241.    _attroff();
  242.    _attron(attr);
  243.    return;
  244.   }
  245.   if (attr == curattr && color == curcolor) return;
  246.   _attroff();
  247.   _colson(color);
  248.   _attron(attr);
  249.   curattr = attr;
  250.   curcolor = color;
  251. }
  253. /*
  254.  * Goto (x, y) in stdwin
  255.  */
  256. static void _gotoxy(x, y)
  257. int x, y;
  258. {
  259.   int oldattr = -1;
  261. #if ST_LINE
  262.   int tmp;
  264.   /* Sanity check. */
  265.   if (x >= COLS || y > LINES || (x == curx && y == cury)) return;
  267.   if (use_status) {
  268. /* Leaving status line? */
  269. if (cury == LINES && y < cury) {
  270. outstr(FS);
  271. /* Re-set attributes. */
  272. tmp = curattr;
  273. curattr = -1;
  274. _setattr(tmp, curcolor);
  275. outstr(tgoto(CM, x, y));
  276. curx = x; cury = y;
  277. return;
  278. }
  279. /* Writing on status line? */
  280. else if (y == LINES) {
  281. /* From normal screen? */
  282. if (cury < y) {
  283. outstr(tgoto(TS, x, x));
  284. curx = x;
  285. cury = y;
  286. /* Set the right attributes. */
  287. tmp = curattr;
  288. curattr = -1;
  289. _setattr(tmp, curcolor);
  290. return;
  291. }
  292. }
  293.   }
  294. #else
  295.   /* Sanity check. */
  296.   if (x >= COLS || y >= LINES || (x == curx && y == cury)) {
  297. #  if 0
  298. if (x >= COLS || y >= LINES)
  299. fprintf(stderr, "OOPS: (x, y) == (%d, %d)n",
  300. COLS, LINES);
  301. #  endif
  302. return;
  303.   }
  304. #endif
  306.   if (!_mv_standout && curattr != XA_NORMAL) {
  307.   oldattr = curattr;
  308.    _setattr(XA_NORMAL, curcolor);
  309.   }
  310.   if (CR != CNULL && y == cury && x == 0)
  311.    outstr(CR);
  312. #if 0 /* Hmm, sometimes NL only works in the first column */
  313.   else if (NL != CNULL && x == curx && y == cury + 1)
  314. outstr(NL);
  315. #else
  316.   else if (NL != CNULL && x == 0 && x == curx && y == cury + 1)
  317. outstr(NL);
  318. #endif
  319.   else if (BC != CNULL && y == cury && x == curx - 1)
  320.    outstr(BC);
  321.   else
  322.    outstr(tgoto(CM, x, y));
  323.   curx = x;
  324.   cury = y;
  325.   if (oldattr != -1) _setattr(oldattr, curcolor);
  326. }
  328. /*
  329.  * Write a character in stdwin at x, y with attr & color
  330.  * 'doit' can be  -1: only write to screen, not to memory
  331.  *                 0: only write to memory, not to screen
  332.  *                 1: write to both screen and memory
  333.  */
  334. static void _write(c, doit, x, y,attr, color)
  335. int c, doit;
  336. int x, y;
  337. char attr, color;
  338. {
  339.   ELM *e;
  341.   /* If the terminal has automatic margins, we can't write to the
  342.    * last line, last character. After scrolling, this "invisible"
  343.    * character is automatically restored.
  344.    */
  345.   if (_has_am && y >= LINES - 1 && x >= COLS - 1) {
  346.    doit = 0;
  347.    sflag = 1;
  348.    oldc.value = c;
  349.    oldc.attr = attr;
  350.    oldc.color = color;
  351.   }
  352. #if ST_LINE
  353.   if (x < COLS && y <= LINES) {
  354. #else
  355.   if (x < COLS && y < LINES) {
  356. #endif
  357.      if (doit != 0) {
  358. static int x0=-1, y0=-1, c0=0;
  359. static char attr0, color0;
  360. if (x!=x0+1 || y!=y0 || attr!=attr0 || color!=color0 || !(c0&128)) {
  361.    _gotoxy(x, y);
  362.    _setattr(attr, color);
  363. }
  364. x0=x; y0=y; attr0=attr; color0=color; c0=c;
  365. (void) outchar((screen_ibmpc || screen_iso || (attr & XA_ALTCHARSET)) ? c : wcharmap[(unsigned char)c]); 
  366. /* a little test at 10.3.1998 / jl */
  367. /* (void) outchar((unsigned char) c); */
  369. curx++;
  370.      }
  371.      if (doit >= 0) {
  372. e = &gmap[x + y * COLS];
  373. e->value = c;
  374. e->attr = attr;
  375. e->color = color;
  376.      }
  377.   }
  378. }
  380. /*
  381.  * Set cursor type.
  382.  */
  383. static void _cursor(type)
  384. int type;
  385. {
  386.   _curstype = type;
  388.   if (type == CNORMAL && VE != CNULL) outstr(VE);
  389.   if (type == CNONE && VE != CNULL && VI != CNULL) outstr(VI);
  390. }
  393. /* ==== High level routines ==== */
  396. #if 0
  397. /* This code is functional, but not yet used.
  398.  * It might be one day....
  399.  */
  400. /*
  401.  * Resize a window
  402.  */
  403. void wresize(win, lines, cols)
  404. WIN *win;
  405. int lines, cols;
  406. {
  407.   int x, y;
  408.   ELM *oldmap, *newmap, *e, *n;
  410.   if ((newmap = (ELM *)malloc((lines + 1) * cols * sizeof(ELM))) == (ELM *)NULL)
  411. return;
  412.   if (win == stdwin)
  413. oldmap = gmap;
  414.   else
  415. oldmap = win->map;
  417.   for(y = 0; y < lines; y++)
  418. for(x = 0; x < cols; x++) {
  419. n = &newmap[y + x * cols];
  420. if (x < win->xs && y < win->ys) {
  421. e = &oldmap[y + x * COLS];
  422. n->value = e->value;
  423. n->color = e->color;
  424. n->attr = e->attr;
  425. } else {
  426. n->value = ' ';
  427. n->color = win->color;
  428. n->attr = win->attr;
  429. }
  430. }
  431.   if (win->sy2 == win->y2) win->sy2 = win->y1 + lines - 1;
  432.   win->y2 = win->y1 + lines - 1;
  433.   win->ys = lines;
  434.   win->xs = cols;
  435.   free(oldmap);
  436.   if (win == stdwin) {
  437. gmap = newmap;
  438. LINES = lines;
  439. COLS = cols;
  440.   } else
  441. win->map = newmap;
  442. }
  443. #endif
  445. /*
  446.  * Create a new window.
  447.  */
  448. /*ARGSUSED*/
  449. WIN *wopen(x1, y1, x2, y2, border, attr, fg, bg, direct, histlines, doclr)
  450. int x1, y1, x2, y2;
  451. int border;
  452. int attr, fg, bg, direct;
  453. int histlines;
  454. int doclr;
  455. {
  456.   WIN *w;
  457.   ELM *e;
  458.   int bytes;
  459.   int x, y;
  460.   int color;
  461.   int offs;
  462.   int xattr;
  463. #ifdef SMOOTH
  464.   curwin = NIL_WIN;
  465. #endif
  467.   if ((w = (WIN *)malloc(sizeof(WIN))) == (WIN *)0) return(w);
  468.   
  469.   offs = (border != BNONE);
  470.   if (!screen_ibmpc && AS) 
  471. xattr = attr | XA_ALTCHARSET;
  472.   else
  473. xattr = attr;
  475.   if (x1 < offs) x1 = offs;
  476.   if (y1 < offs) y1 = offs;
  477. #if 0
  478.   if (x2 >= COLS - offs) x2 = COLS - offs - 1;
  479.   if (y2 >= LINES - offs) y2 = LINES - offs - 1;
  480. #endif
  481.   if (x1 > x2) swap(x1, x2);
  482.   if (y1 > y2) swap(y1, y2);
  484.   w->xs = x2 - x1 + 1;
  485.   w->ys = y2 - y1 + 1;
  486.   w->x1 = x1;
  487.   w->x2 = x2;
  488.   w->y1 = w->sy1 = y1;
  489.   w->y2 = w->sy2 = y2;
  490.   w->doscroll = 1;
  491.   w->border = border;
  492.   w->cursor = CNORMAL;
  493.   w->attr = attr;
  494.   w->autocr = 1;
  495.   w->wrap = 1;
  496.   color = w->color = COLATTR(fg, bg);
  497.   w->curx = 0;
  498.   w->cury = 0;
  500.   w->o_curx = curx;
  501.   w->o_cury = cury;
  502.   w->o_attr = curattr;
  503.   w->o_color = curcolor;
  504.   w->o_cursor = _curstype;
  505.   w->direct = direct;
  507.   if (border != BNONE) {
  508.    x1--; x2++;
  509.    y1--; y2++;
  510.   }
  511.   /* Store whatever we are overlapping */
  512.   bytes = (y2 - y1 + 1) * (x2 - x1 + 1) * sizeof(ELM) + 100;
  513.   if ((e = (ELM *)malloc(bytes)) == (ELM *)0) {
  514.    free(w);
  515.    return((WIN *)0);
  516.   }
  517.   w->map = e;
  518.   /* How many bytes is one line */
  519.   bytes = (x2 - x1 + 1) * sizeof(ELM);
  520.   /* Loop */
  521.   for(y = y1; y <= y2; y++) {
  522.    memcpy(e, gmap + COLS * y + x1, bytes);
  523.    e += (x2 - x1 + 1);
  524.   }
  525.   
  526. #if HISTORY
  527.   /* Do we want history? */
  528.   w->histline = w->histlines = 0;
  529.   w->histbuf = (ELM *)0;
  530.   if (histlines) {
  531. /* Reserve some memory. */
  532. bytes = w->xs * histlines * sizeof(ELM);
  533. if ((w->histbuf = (ELM *)malloc(bytes)) == NULL) {
  534. free(w->map);
  535. free(w);
  536. return((WIN *)0);
  537. }
  538. w->histlines = histlines;
  540. /* Clear the history buf. */
  541. e = w->histbuf;
  542. for(y = 0; y < w->xs * histlines; y++) {
  543. e->value = ' ';
  544. e->attr = attr;
  545. e->color = color;
  546. e++;
  547. }
  548.   }
  549. #endif
  551.   /* And draw the window */
  552.   if (border) {
  553. _write(border == BSINGLE ? S_UL : D_UL, w->direct, x1, y1,
  554. xattr, color);
  555. for(x = x1 + 1; x < x2; x++)
  556. _write(border == BSINGLE ? S_HOR : D_HOR, w->direct, x, y1,
  557. xattr, color);
  558. _write(border == BSINGLE ? S_UR : D_UR, w->direct, x2, y1,
  559. xattr, color);
  560. for(y = y1 + 1; y < y2; y++) {
  561. _write(border == BSINGLE ? S_VER : D_VER, w->direct, x1, y,
  562. xattr, color);
  563. for(x = x1 + 1; x < x2; x++)
  564. _write(' ', w->direct, x, y, attr, color);
  565. _write(border == BSINGLE ? S_VER : D_VER, w->direct, x2, y,
  566. xattr, color);
  567. }
  568. _write(border == BSINGLE ? S_LL : D_LL, w->direct, x1, y2,
  569. xattr, color);
  570. for(x = x1 + 1; x < x2; x++)
  571. _write(border == BSINGLE ? S_HOR : D_HOR, w->direct,
  572. x, y2, xattr, color);
  573. _write(border == BSINGLE ? S_LR : D_LR, w->direct, x2, y2,
  574. xattr, color);
  575. if (w->direct) _gotoxy(x1 + 1, y1 + 1);
  576.   } else
  577.    if (doclr) winclr(w);
  578.   wcursor(w, CNORMAL);
  580.   if (w->direct) wflush();
  581.   return(w);
  582. }
  584. /*
  585.  * Close a window.
  586.  */
  587. void wclose(win, replace)
  588. WIN *win;
  589. int replace;
  590. {
  591.   ELM *e;
  592.   int x, y;
  594. #ifdef SMOOTH
  595.   curwin = NIL_WIN;
  596. #endif
  598.   if (!win) return;
  600.   if (win == stdwin) {
  601.    win_end();
  602.    return;
  603.   }
  604.   e = win->map;
  606.   if (win->border) {
  607.    win->x1--; win->x2++;
  608.    win->y1--; win->y2++;
  609.   }
  610.   wcursor(win, win->o_cursor);
  611.   if (replace) {
  612. for(y = win->y1; y <= win->y2; y++) {
  613. /* temporal way to avoid 'half-character' problem */
  614. /* in multibyte characters such as Japanese -- from here */
  615. ELM *g;
  616. g = gmap + (y * stdwin->xs);
  617. for(x = 0 ; x < win->x1; x++) {
  618. _write(g->value, 1, x, y, g->attr, g->color);
  619. g++;
  620. }
  621. /* to here */
  622.    for(x = win->x1; x <= win->x2; x++) {
  623.    _write(e->value, 1, x, y, e->attr, e->color);
  624.    e++;
  625.    }
  626.   }
  627. _gotoxy(win->o_curx, win->o_cury);
  628. _setattr(win->o_attr, win->o_color);
  629.   }
  630.   free(win->map);
  631. #if HISTORY
  632.   if (win->histbuf) free(win->histbuf);
  633. #endif
  634.   free(win); /* 1.1.98 dickey@clark.net  */
  635.   wflush();
  636. }
  638. static int oldx, oldy;
  639. static int ocursor;
  641. /*
  642.  * Clear screen & restore keyboard modes
  643.  */
  644. void wleave()
  645. {
  646.   oldx = curx;
  647.   oldy = cury;
  648.   ocursor = _curstype;
  650.   (void) setcbreak(0); /* Normal */
  651.   _gotoxy(0, LINES - 1);
  652.   _setattr(XA_NORMAL, COLATTR(WHITE, BLACK));
  653.   _cursor(CNORMAL);
  654.   if (CL != CNULL)
  655. outstr(CL);
  656.   else
  657. outstr("n");
  658. #if ST_LINE
  659.   if (DS) outstr(DS);
  660. #endif
  661.   if (KE != CNULL) outstr(KE);
  662.   if (RS != CNULL) outstr(RS);
  663.   wflush();
  664. }
  666. void wreturn()
  667. {
  668.   int x, y;
  669.   ELM *e;
  671. #ifdef SMOOTH
  672.   curwin = NIL_WIN;
  673. #endif
  675.   curattr = -1;
  676.   curcolor = -1;
  678.   (void) setcbreak(1); /* Cbreak, no echo */
  680.   if (IS != CNULL) outstr(IS); /* Initialization string */
  681.   if (EA != CNULL) outstr(EA); /* Graphics init. */
  682.   if (KS != CNULL) outstr(KS); /* Keypad mode */
  683.   
  684.   _gotoxy(0, 0);
  685.   _cursor(ocursor);
  687.   e = gmap;
  688.   for(y = 0; y <LINES; y++) {
  689.    for(x = 0; x < COLS; x++) {
  690.    _write(e->value, -1, x, y, e->attr, e->color);
  691.    e++;
  692.    }
  693.   }
  694.   _gotoxy(oldx, oldy);
  695.   wflush();
  696. }
  698. /*
  699.  * Redraw the whole window.
  700.  */
  701. void wredraw(w, newdirect)
  702. WIN *w;
  703. int newdirect;
  704. {
  705.   int minx, maxx, miny, maxy;
  706.   ELM *e;
  707.   int x, y;
  708.   int addcnt;
  710.   minx = w->x1;
  711.   maxx = w->x2;
  712.   miny = w->y1;
  713.   maxy = w->y2;
  714.   addcnt = stdwin->xs - w->xs;
  716.   if (w->border) {
  717.    minx--;
  718.    maxx++;
  719.    miny--;
  720.    maxy++;
  721.    addcnt -= 2;
  722.   }
  724.   _gotoxy(minx, miny);
  725.   _cursor(CNONE);
  726.   e = gmap + (miny * stdwin->xs) + minx;
  728.   for(y = miny; y <= maxy; y++) {
  729.    for(x = minx; x <= maxx; x++) {
  730.    _write(e->value, -1, x, y, e->attr, e->color);
  731.    e++;
  732.    }
  733.    e += addcnt;
  734.   }
  735.   _gotoxy(w->x1 + w->curx, w->y1 + w->cury);
  736.   _cursor(w->cursor);
  737.   wflush();
  738.   w->direct = newdirect;
  739. }
  741. /*
  742.  * Clear to end of line, low level.
  743.  */
  744. static int _wclreol(w)
  745. WIN *w;
  746. {
  747.   int x;
  748.   int doit = 1;
  749.   int y;
  750.   
  751. #ifdef SMOOTH
  752.   curwin = w;
  753. #endif
  754.   y = w->cury + w->y1;
  756.   if (w->direct && (w->x2 == COLS - 1) && CE) {
  757.    _gotoxy(w->curx + w->x1, y);
  758.    _setattr(w->attr, w->color);
  759.    outstr(CE);
  760.    doit = 0;
  761.   }
  762.   for(x = w->curx + w->x1; x <= w->x2; x++) {
  763.    _write(' ', (w->direct && doit) ? 1 : 0, x, y, w->attr, w->color);
  764.   }
  765.   return(doit);
  766. }
  768. /*
  769.  * Scroll a window.
  770.  */
  771. void wscroll(win, dir)
  772. WIN *win;
  773. int dir;
  774. {
  775.   ELM *e, *f;
  776.   char *src, *dst;
  777.   int x, y;
  778.   int doit = 1;
  779.   int ocurx, fs = 0, len;
  780.   int phys_scr = 0;
  782. #ifdef SMOOTH
  783.   curwin = win;
  784. #endif
  786.   /*
  787.    * If the window *is* the physical screen, we can scroll very simple.
  788.    * This improves performance on slow screens (eg ATARI ST) dramatically.
  789.    */
  790.   if (win->direct && SF != CNULL &&
  791.    (dir == S_UP || SR != CNULL) && (LINES == win->sy2 - win->sy1 + 1)) {
  792.    doit = 0;
  793.    phys_scr = 1;
  794.    _setattr(win->attr, win->color);
  795.    if (dir == S_UP) {
  796.    _gotoxy(0, LINES - 1);
  797.    outstr(SF);
  798.    } else {
  799.    _gotoxy(0, 0);
  800.    outstr(SR);
  801.    }
  802.   }
  803.   /*
  804.    * If the window is as wide as the physical screen, we can
  805.    * scroll it with insert/delete line (or set scroll region - vt100!)
  806.    */
  807.   else if (win->direct && win->xs == COLS &&
  808.    ((CS != CNULL && SF != CNULL && SR != CNULL)
  809.    || (Dl != CNULL && Al != CNULL))) {
  810.    doit = 0;
  811.    phys_scr = 1;
  812.    _setattr(win->attr, win->color);
  813.    if (CS != CNULL && SF != CNULL && SR != CNULL) { /* Scrolling Region */
  814. /* If the scroll region we want to initialize already is as
  815.  * big as the physical screen, we don't _have_ to
  816.  * initialize it.
  817.  */
  818.    if (win->sy2 == LINES - 1 && win->sy1 == 0) fs = 1;
  819.    if (!fs) {
  820.    outstr(tgoto(CS, win->sy2, win->sy1));
  821.    cury = 0;
  822.    }
  823.    if (dir == S_UP) {
  824.      _gotoxy(0, win->sy2);
  825.      outstr(SF);
  826.    } else {
  827.      _gotoxy(0, win->sy1);
  828.      outstr(SR);
  829.    }
  830.    if (!fs) {
  831.    outstr(tgoto(CS, LINES - 1, 0));
  832.    cury = 0;
  833.    }
  834.    _gotoxy(0, win->sy2);
  835.    } else { /* Use insert/delete line */
  836.    if (dir == S_UP) {
  837.    _gotoxy(0, win->sy1);
  838.    outstr(Dl);
  839.    _gotoxy(0, win->sy2);
  840.    outstr(Al);
  841.    } else {
  842.    _gotoxy(0, win->sy2);
  843.    outstr(Dl);
  844.    _gotoxy(0, win->sy1);
  845.    outstr(Al);
  846.    }
  847.    }
  848.   }
  850.   /* If a terminal has automatic margins, we can't write
  851.    * to the lower right. After scrolling we have to restore
  852.    * the non-visible character that is now visible.
  853.    */
  854.   if (sflag && win->sy2 == (LINES - 1) && win->sy1 != win->sy2) {
  855.    if (dir == S_UP) {
  856.    _write(oldc.value, 1, COLS - 1, LINES - 2,
  857.    oldc.attr, oldc.color);
  858.    }
  859.    sflag = 0;
  860.   }
  862.   ocurx = win->curx;
  864. #if HISTORY
  865.   /* If this window has a history buf, see if we want to use it. */
  866.   if (win->histbuf && dir == S_UP &&
  867. win->sy2 == win->y2 && win->sy1 == win->y1) {
  869. /* Calculate screen buffer */
  870.    e = gmap + win->y1 * COLS + win->x1;
  872. /* Calculate history buffer */
  873. f = win->histbuf + (win->xs * win->histline);
  875. /* Copy line from screen to history buffer */
  876. memcpy((char *)f, (char *)e, win->xs * sizeof(ELM));
  878. /* Postion the next line in the history buffer */
  879. win->histline++;
  880. if (win->histline >= win->histlines) win->histline = 0;
  881.   }
  882. #endif
  884.   /* If the window is screen-wide and has no border, there
  885.    * is a much simpler & FASTER way of scrolling the memory image !!
  886.    */
  887.   if (phys_scr) {
  888.    len = (win->sy2 - win->sy1) * win->xs * sizeof(ELM);
  889.    if (dir == S_UP)  {
  890.    dst = (char *)&gmap[0]; /* First line */
  891.    src = (char *)&gmap[win->xs]; /* Second line */
  892.    win->cury = win->sy2 - win->y1;
  893.    } else {
  894.    src = (char *)&gmap[0]; /* First line */
  895.    dst = (char *)&gmap[win->xs]; /* Second line */
  896.    win->cury = win->sy1 - win->y1;
  897.    }
  898.    /* memmove copies len bytes from src to dst, even if the
  899.     * objects overlap.
  900.     */
  901.    fflush(stdout);
  902. #ifdef _SYSV
  903.    memcpy((char *)dst, (char *)src, len);
  904. #else
  905. #  ifdef _BSD43
  906.    bcopy((char *)src, (char *)dst, len);
  907. #  else
  908.    memmove((char *)dst, (char *)src, len);
  909. #  endif
  910. #endif
  911.   } else {
  912. /* Now scroll the memory image. */
  913.    if (dir == S_UP) {
  914.    for(y = win->sy1 + 1; y <= win->sy2; y++) {
  915.    e = gmap + y * COLS + win->x1;
  916.    for(x = win->x1; x <= win->x2; x++) {
  917.       _write(e->value, win->direct && doit,
  918.        x, y - 1, e->attr, e->color);
  919.       e++;
  920.     }
  921.    }
  922.    win->curx = 0;
  923.    win->cury = win->sy2 - win->y1;
  924.    if (doit) (void) _wclreol(win);
  925.    } else {
  926.    for(y = win->sy2 - 1; y >= win->sy1; y--) {
  927.    e = gmap + y * COLS + win->x1;
  928.    for(x = win->x1; x <= win->x2; x++) {
  929.       _write(e->value, win->direct && doit,
  930.        x, y + 1, e->attr, e->color);
  931.       e++;
  932.    }
  933.    }
  934.    win->curx = 0;
  935.    win->cury = win->sy1 - win->y1;
  936.    if (doit) (void) _wclreol(win);
  937.    }
  938.   }
  940.   win->curx = ocurx;
  942.   if (!doit) for(x = win->x1; x <= win->x2; x++)
  943. _write(' ', 0, x, win->y1 + win->cury, win->attr, win->color);
  944.   if (!_intern && win->direct)
  945.    _gotoxy(win->x1 + win->curx, win->y1 + win->cury);
  946.   if (dirflush && !_intern && win->direct) wflush();
  947. }
  949. /*
  950.  * Locate the cursor in a window.
  951.  */
  952. void wlocate(win, x, y)
  953. WIN *win;
  954. int x, y;
  955. {
  956.   if (x < 0) x = 0;
  957.   if (y < 0) y = 0;
  958.   if (x >= win->xs) x = win->xs - 1;
  959.   if (y >= win->ys) y = win->ys - 1;
  961.   win->curx = x;
  962.   win->cury = y;
  963.   if (win->direct) _gotoxy(win->x1 + x, win->y1 + y);
  965.   if (dirflush) wflush();
  966. }
  968. /*
  969.  * Print a character in a window.
  970.  */
  971. void wputc(win, c)
  972. WIN *win;
  973. int c;
  974. {
  975.   int mv = 0;
  977. #ifdef SMOOTH
  978.   curwin = win;
  979. #endif
  981.   switch(c) {
  982.    case 'r':
  983.    win->curx = 0;
  984.    mv++;
  985.    break;
  986.    case 'b':
  987.    if (win->curx == 0) break;
  988.    win->curx--;
  989.    mv++;
  990.    break;
  991.    case '07':
  992.    wbell();
  993.    break;
  994.    case 't':
  995.    do {
  996.    wputc(win, ' '); /* Recursion! */
  997.    } while(win->curx % 8);
  998.    break;
  999.    case 'n':
  1000.    if (win->autocr) win->curx = 0;
  1001. /*FALLTHRU*/
  1002.    default:
  1003. /* See if we need to scroll/move. (vt100 behaviour!) */
  1004. if (c == 'n' || (win->curx >= win->xs && win->wrap)) {
  1005. if (c != 'n') win->curx = 0;
  1006. win->cury++;
  1007. mv++;
  1008. if (win->cury == win->sy2 - win->y1 + 1) {
  1009.    if (win->doscroll)
  1010.    wscroll(win, S_UP);
  1011.    else
  1012.    win->cury = win->sy1 - win->y1;
  1013. }
  1014. if (win->cury >= win->ys) win->cury = win->ys - 1;
  1015. }
  1016. /* Now write the character. */
  1017. if (c != 'n') {
  1018. _write(c, win->direct, win->curx + win->x1,
  1019. win->cury + win->y1, win->attr, win->color);
  1020.    if (++win->curx >= win->xs && !win->wrap) {
  1021. win->curx--;
  1022. curx = 0; /* Force to move */
  1023. mv++;
  1024. }
  1025. }
  1026. break;
  1027.   }
  1028.   if (mv && win->direct)
  1029.    _gotoxy(win->x1 + win->curx, win->y1 + win->cury);
  1031.   if (win->direct && dirflush && !_intern) wflush();
  1032. }
  1034. /* Draw one line in a window */
  1035. void wdrawelm(w, y, e)
  1036. WIN *w;
  1037. int y;
  1038. ELM *e;
  1039. {
  1040.   int x;
  1042.   /* MARK updated 02/17/94 - Fixes bug, to do all 80 cols, not 79 cols */
  1043.   for(x = w->x1; x <= w->x2; x++)
  1044.   {
  1045. _write(e->value, w->direct, x, y + w->y1, e->attr, e->color);
  1046. /*y + w->y1, XA_NORMAL, e->color);*/
  1047. e++;
  1048.   }
  1049. }
  1051. #if _SEARCH_HISTORY
  1052. /*
  1053.  * fmg 8/20/97
  1054.  * 'accumulate' one line of ELM's into a string
  1055.  * WHY: need this in search function to see if line contains search pattern
  1056.  */
  1057. void wdrawelm_var(w, y, e, buf)
  1058. WIN *w;
  1059. int y;
  1060. ELM *e;
  1061. char *buf;
  1062. {
  1063.   int x,c=0;
  1065.   /* MARK updated 02/17/94 - Fixes bug, to do all 80 cols, not 79 cols */
  1066.   for(x = w->x1; x <= w->x2; x++)
  1067.   {
  1068. buf[c++]=e->value;
  1069. e++;
  1070.   }
  1071. }
  1072. #endif /*SEARCH_HISTORY*/
  1074. /*
  1075.  * fmg 8/20/97
  1076.  * 'draw' one line of ELM's in a window INVERTED (text-mode-wise)
  1077.  * WHY: need this in search function to see if line contains search pattern
  1078.  */
  1079. void wdrawelm_inverse(w, y, e)
  1080. WIN *w;
  1081. int y;
  1082. ELM *e;
  1083. {
  1084.   int x;
  1086.   /* MARK updated 02/17/94 - Fixes bug, to do all 80 cols, not 79 cols */
  1087.   /* filipg 8/19/97: this will BOLD-up the line */
  1088.   /* first position */
  1089.   x = w->x1;
  1090.   _write(e->value, w->direct, x, y + w->y1, XA_NORMAL, e->color);
  1092.   e++;
  1094.   /* everything in the middle will be BLINK */
  1095.   for(x = (w->x1+1); x <= (w->x2-1); x++)
  1096.   {
  1097. _write(e->value, w->direct, x, y + w->y1, XA_BOLD, WHITE);
  1098. e++;
  1099.   }
  1101.   /* last position */
  1102.   x = w->x2;
  1103.   _write(e->value, w->direct, x, y + w->y1, XA_NORMAL, e->color);
  1104. }
  1106. /*
  1107.  * Print a string in a window.
  1108.  */
  1109. void wputs(win, s)
  1110. WIN *win;
  1111. char *s;
  1112. {
  1113.   _intern = 1;
  1115.   while(*s) wputc(win, *s++);
  1116.   if (dirflush && win->direct) wflush();
  1117.   _intern = 0;
  1118. }
  1120. /*
  1121.  * Print a formatted string in a window.
  1122.  * Should return stringlength - but who cares.
  1123.  */
  1124. /*VARARGS1*/
  1125. int wprintf(win, s, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
  1126. WIN *win;
  1127. char *s, *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8, *a9, *a10;
  1128. {
  1129.   char buf[160];
  1130.   char *t;
  1132.   t = buf;
  1134.   _intern = 1;
  1135.   snprintf(buf, sizeof(buf), s, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10);
  1136.   while(*t) wputc(win, *t++);
  1137.   _intern = 0;
  1138.   if (dirflush && win->direct) wflush();
  1140.   return(0);
  1141. }
  1143. /*
  1144.  * Sound a bell.
  1145.  */
  1146. void wbell()
  1147. {
  1148.   if (BL != CNULL)
  1149. outstr(BL);
  1150.   else if (VB != CNULL)
  1151.    outstr(VB);
  1152.   else
  1153.    (void) outchar('07');
  1154.   wflush();
  1155. }
  1157. /*
  1158.  * Set cursor type.
  1159.  */
  1160. void wcursor(win, type)
  1161. WIN *win;
  1162. int type;
  1163. {
  1164.   win->cursor = type;
  1165.   if (win->direct) {
  1166.    _cursor(type);
  1167. if (dirflush) wflush();
  1168.   }
  1169. }
  1171. void wtitle(w, pos, s)
  1172. WIN *w;
  1173. int pos;
  1174. char *s;
  1175. {
  1176.   int x = 0;
  1178. #ifdef SMOOTH
  1179.   curwin = NIL_WIN;
  1180. #endif
  1182.   if (w->border == BNONE) return;
  1183.   
  1184.   if (pos == TLEFT) x = w->x1;
  1185.   if (pos == TRIGHT) x = w->x2 - strlen(s) - 1;
  1186.   if (pos == TMID) x = w->x1 + (w->xs - strlen(s)) / 2 - 1;
  1187.   if (x < w->x1) x = w->x1;
  1189.   if (x < w->x2) _write('[', w->direct, x++, w->y1 - 1, w->attr, w->color);
  1190.   while(*s && x <= w->x2) _write(*s++, w->direct, x++, w->y1 - 1,
  1191.    w->attr, w->color);
  1192.   if (x <= w->x2) _write(']', w->direct, x++, w->y1 - 1, w->attr, w->color);
  1194.   if (w->direct) {
  1195.    _gotoxy(w->x1 + w->curx, w->y1 + w->cury);
  1196. if (dirflush) wflush();
  1197.   }
  1198. }
  1201. /* ==== Menu Functions ==== */
  1203. /*
  1204.  * Change attributes of one line of a window.
  1205.  */
  1206. void wcurbar(w, y, attr)
  1207. WIN *w;
  1208. int y;
  1209. int attr;
  1210. {
  1211.   ELM *e;
  1212.   int x;
  1214. #ifdef SMOOTH
  1215.   curwin = w;
  1216. #endif
  1218.   y += w->y1;
  1220.   e = gmap + y * COLS + w->x1;
  1221.   
  1222.   /* If we can't do reverse, just put a '>' in front of
  1223.    * the line. We only support XA_NORMAL & XA_REVERSE.
  1224.    */
  1225.   if (!useattr || MR == CNULL) {
  1226.    if (attr & XA_REVERSE)
  1227.    x = '>';
  1228.    else
  1229.    x = ' ';
  1230.    _write(x, w->direct, w->x1, y, attr, e->color);
  1231.   } else {
  1232. for(x = w->x1; x <= w->x2; x++) {
  1233.    _write(e->value, w->direct, x, y, attr, e->color);
  1234.    e++;
  1235. }
  1236.   }
  1237.   if ((VI == CNULL || _curstype == CNORMAL) && w->direct)
  1238.    _gotoxy(w->x1, y);
  1239.   if (w->direct) wflush();
  1240. }
  1242. /*
  1243.  * wselect - select one of many choices.
  1244.  */
  1245. int wselect(x, y, choices, funlist, title, attr, fg, bg)
  1246. int x, y;
  1247. char **choices;
  1248. void (**funlist)();
  1249. char *title;
  1250. int attr, fg, bg;
  1251. {
  1252.   char **a = choices;
  1253.   int len = 0;
  1254.   int count = 0;
  1255.   int cur = 0;
  1256.   int c;
  1257.   WIN *w;
  1258.   int high_on = XA_REVERSE | attr;
  1259.   int high_off = attr;
  1260.   
  1261.   /* first count how many, and max. width. */
  1263.   while(*a != CNULL) {
  1264.    count++;
  1265.    if (strlen(_(*a)) > len) len = strlen(_(*a));
  1266.    a++;
  1267.   }
  1268.   if (title != CNULL && strlen(title) + 2 > len) len = strlen(title) + 2;
  1269.   if (attr & XA_REVERSE) {
  1270.    high_on = attr & ~XA_REVERSE;
  1271.    high_off = attr;
  1272.   }
  1274.   if ((w = wopen(x, y, x + len + 2, y + count - 1, BDOUBLE,
  1275. attr, fg, bg, 0, 0, 0)) == (WIN *)0) return(-1);
  1276.   wcursor(w, CNONE);
  1278.   if (title != CNULL) wtitle(w, TMID, title);
  1280.   for(c = 0; c < count; c++) {
  1281.    wprintf(w, " %s%s", _(choices[c]), c == count - 1 ? "" : "n");
  1282.   }
  1284.   wcurbar(w, cur, high_on);
  1285.   wredraw(w, 1);
  1287.   while (1) {
  1288. while((c = wxgetch()) != 27 && c != 'n' && c!= 'r' && c != ' ') {
  1289. if (c == K_UP || c == K_DN || c == 'j' || c == 'k' ||
  1290.     c == K_HOME || c == K_END)
  1291. wcurbar(w, cur, high_off);
  1292. switch(c) {
  1293. case K_UP:
  1294. case 'k':
  1295. cur--;
  1296. if (cur < 0) cur = count - 1;
  1297. break;
  1298. case K_DN:
  1299. case 'j':
  1300. cur++;
  1301. if (cur >= count) cur = 0;
  1302. break;
  1303. case K_HOME:
  1304.    cur = 0;
  1305. break;
  1306. case K_END:
  1307.         cur = count - 1;
  1308. break;
  1309. }
  1310. if (c == K_UP || c == K_DN || c == 'j' || c == 'k' ||
  1311.     c == K_HOME || c == K_END)
  1312. wcurbar(w, cur, high_on);
  1313. }
  1314. wcursor(w, CNORMAL);
  1315. if (c == ' ' || c == 27) {
  1316. wclose(w, 1);
  1317. return(0);
  1318. }
  1319. if (funlist == NIL_FUNLIST || funlist[cur] == NIL_FUN) {
  1320. wclose(w, 1);
  1321. return(cur + 1);
  1322. }
  1323. (*funlist[cur])();
  1324. wcursor(w, CNONE);
  1325.   }
  1326. }
  1329. /* ==== Clearing functions ==== */
  1331. /*
  1332.  * Clear entire line.
  1333.  */
  1334. void wclrel(w)
  1335. WIN *w;
  1336. {
  1337.   int ocurx = w->curx;
  1338.   
  1339.   w->curx = 0;
  1340.   (void) _wclreol(w);
  1341.   w->curx = ocurx;
  1342.   wlocate(w, ocurx, w->cury);
  1343. }
  1345. /*
  1346.  * Clear to end of line.
  1347.  */
  1348. void wclreol(w)
  1349. WIN *w;
  1350. {
  1351.   if (_wclreol(w) && w->direct) _gotoxy(w->x1 + w->curx, w->y1 + w->cury);
  1352.   if (dirflush) wflush();
  1353. }
  1355. /*
  1356.  * Clear to begin of line
  1357.  */
  1358. void wclrbol(w)
  1359. WIN *w;
  1360. {
  1361.    int x, y, n;
  1362.  
  1363. #ifdef SMOOTH
  1364.   curwin = w;
  1365. #endif
  1367.   y = w->cury + w->y1;
  1369.   if (w->direct) _gotoxy(w->x1, y);
  1370.   
  1371.   n = w->x1 + w->curx;
  1372.   if( n > w->x2) n = w->x2;
  1373.   for(x = w->x1; x <= n; x++) _write(' ', w->direct, x, y,
  1374.    w->attr, w->color);
  1375.   if (w->direct) {
  1376.    _gotoxy(n, y);
  1377. if (dirflush) wflush();
  1378.   }
  1379. }
  1381. /*
  1382.  * Clear to end of screen
  1383.  */
  1384. void wclreos(w)
  1385. WIN *w;
  1386. {
  1387.   int y;
  1388.   int ocurx, ocury;
  1389.   
  1390.   ocurx = w->curx;
  1391.   ocury = w->cury;
  1392.   
  1393.   w->curx = 0;
  1395.   for(y = w->cury + 1; y <= w->y2 - w->y1; y++) {
  1396.    w->cury = y;
  1397.    (void) _wclreol(w);
  1398.   }
  1399.   w->curx = ocurx;
  1400.   w->cury = ocury;
  1401.   if (_wclreol(w) && w->direct) _gotoxy(w->x1 + w->curx, w->y1 + w->cury);
  1402.   if (dirflush && w->direct) wflush();
  1403. }
  1405. /*
  1406.  * Clear to begin of screen.
  1407.  */
  1408. void wclrbos(w)
  1409. WIN *w;
  1410. {
  1411.   int ocurx, ocury;
  1412.   int y;
  1413.   
  1414.   ocurx = w->curx;
  1415.   ocury = w->cury;
  1416.   
  1417.   w->curx = 0;
  1418.   
  1419.   for(y = 0; y < ocury; y++) {
  1420.    w->cury = y;
  1421.    (void) _wclreol(w);
  1422.   }
  1423.   w->curx = ocurx;
  1424.   w->cury = ocury;
  1425.   wclrbol(w);
  1426. }
  1428. /*
  1429.  * Clear a window.
  1430.  */
  1431. void winclr(w)
  1432. WIN *w;
  1433. {
  1434.   int y;
  1435.   int olddir = w->direct;
  1436. #if HISTORY
  1437.   ELM *e, *f;
  1438.   int i;
  1439.   int m;
  1441.   /* If this window has history, save the image. */
  1442.   if (w->histbuf) {
  1444. /* MARK updated 02/17/95 - Scan backwards from the bottom of the */
  1445. /* window for the first non-empty line.  We should save all other */
  1446. /* blank lines inside screen, since some nice BBS ANSI menus */
  1447. /* contains them for cosmetic purposes or as separators. */
  1448. for(m = w->y2; m >= w->y1; m--) {
  1449. /* Start of this line in the global map. */
  1450. e = gmap + m * COLS + w->x1;
  1452. /* Quick check to see if line is empty. */
  1453. for(i = 0; i < w->xs; i++)
  1454. if (e[i].value != ' ') break;
  1456. if (i != w->xs) break; /* Non empty line */
  1457. }
  1459. /* Copy window into history buffer line-by-line. */
  1460. for(y = w->y1; y <= m; y++) {
  1461. /* Start of this line in the global map. */
  1462. e = gmap + y * COLS + w->x1;
  1464. /* Now copy this line. */
  1465. f = w->histbuf + (w->xs * w->histline); /* History buffer */
  1466. memcpy((char *)f, (char *)e, w->xs * sizeof(ELM));
  1467. w->histline++;
  1468. if (w->histline >= w->histlines) w->histline = 0;
  1469. }
  1470.   }
  1471. #endif
  1473.   _setattr(w->attr, w->color);
  1474.   w->curx = 0;
  1476.   if (CL && w->y1 == 0 && w->y2 == LINES-1 &&
  1477.             w->x1 == 0 && w->x2 == COLS-1) {
  1478. w->direct = 0;
  1479. curx = 0;
  1480. cury = 0;
  1481. outstr(CL);
  1482.   }
  1483.   for(y = w->ys - 1; y >= 0; y--) {
  1484.   w->cury = y;
  1485.   (void) _wclreol(w);
  1486.   }
  1487.   w->direct = olddir;
  1488.   _gotoxy(w->x1, w->y1);
  1489.   if (dirflush) wflush();
  1490. }
  1492. /* ==== Insert / Delete functions ==== */
  1494. void winsline(w)
  1495. WIN *w;
  1496. {
  1497.   int osy1, osy2;
  1498.   
  1499.   osy1 = w->sy1;
  1500.   osy2 = w->sy2;
  1501.   
  1502.   w->sy1 = w->y1 + w->cury;
  1503.   w->sy2 = w->y2;
  1504.   if (w->sy1 < osy1) w->sy1 = osy1;
  1505.   if (w->sy2 > osy2) w->sy2 = osy2;
  1506.   wscroll(w, S_DOWN);
  1507.   
  1508.   w->sy1 = osy1;
  1509.   w->sy2 = osy2;
  1510. }
  1512. void wdelline(w)
  1513. WIN *w;
  1514. {
  1515.   int osy1, osy2;
  1516.   int ocury;
  1517.   
  1518.   ocury = w->cury;
  1519.   osy1 = w->sy1;
  1520.   osy2 = w->sy2;
  1521.   
  1522.   w->sy1 = w->y1 + w->cury;
  1523.   w->sy2 = w->y2;
  1524.   if (w->sy1 < osy1) w->sy1 = osy1;
  1525.   if (w->sy2 > osy2) w->sy2 = osy2;
  1526.   
  1527.   _intern = 1;
  1528.   wscroll(w, S_UP);
  1529.   _intern = 0;
  1530.   wlocate(w, 0, ocury);
  1532.   w->sy1 = osy1;
  1533.   w->sy2 = osy2;
  1534. }
  1536. /*
  1537.  * Insert a space at cursor position.
  1538.  */
  1539. void winschar2(w, c, move)
  1540. WIN *w;
  1541. int c;
  1542. int move;
  1543. {
  1544.   int y;
  1545.   int x;
  1546.   int doit = 1;
  1547.   ELM buf[160];
  1548.   ELM *e;
  1549.   int len, odir;
  1550.   int oldx;
  1552. #ifdef SMOOTH
  1553.   curwin = w;
  1554. #endif
  1556.   /* See if we need to insert. */
  1557.   if (c == 0 || strchr("rntb07", c) || w->curx >= w->xs - 1) {
  1558.    wputc(w, c);
  1559.    return;
  1560.   }
  1562.   odir = w->direct;
  1563.   if (w->xs == COLS && IC != CNULL) {
  1564. /* We can use the insert character capability. */
  1565.    if (w->direct) outstr(IC);
  1567. /* No need to draw the character if it's a space. */
  1568.    if (c == ' ') w->direct = 0;
  1570. /* We don't need to draw the new line at all. */
  1571. doit = 0;
  1572.   }
  1573.   
  1574.   /* Get the rest of line into buffer */
  1575.   y = w->y1 + w->cury;
  1576.   x = w->x1 + w->curx;
  1577.   oldx = w->curx;
  1578.   len = w->xs - w->curx;
  1579.   memcpy(buf, gmap + COLS * y + x, sizeof(ELM) * len);
  1581.   /* Now, put the new character on screen. */
  1582.   wputc(w, c);
  1583.   if (!move) w->curx = oldx;
  1585.   /* Write buffer to screen */
  1586.   e = buf;
  1587.   for(++x; x <= w->x2; x++) {
  1588.    _write(e->value, doit && w->direct, x, y, e->attr, e->color);
  1589.    e++;
  1590.   }
  1591.   w->direct = odir;
  1592.   wlocate(w, w->curx, w->cury);
  1593. }
  1595. void winschar(w)
  1596. WIN *w;
  1597. {
  1598.   winschar2(w, ' ', 0);
  1599. }
  1601. /*
  1602.  * Delete character under the cursor.
  1603.  */
  1604. void wdelchar(w)
  1605. WIN *w;
  1606. {
  1607.   int x, y;
  1608.   int doit = 1;
  1609.   ELM *e;
  1611. #ifdef SMOOTH
  1612.   curwin = w;
  1613. #endif
  1615.   x = w->x1 + w->curx;
  1616.   y = w->y1 + w->cury;
  1617.   
  1618.   if (w->direct && w->xs == COLS && DC != CNULL) {
  1619.    /*_gotoxy(x - 1, y);*/
  1620.    _gotoxy(x, y);
  1621.    outstr(DC);
  1622.    doit = 0;
  1623.   }
  1624.   
  1625.   e = gmap + y * COLS + x + 1;
  1626.   
  1627.   for(; x < w->x2; x++) {
  1628.    _write(e->value, doit && w->direct, x, y, e->attr, e->color);
  1629.    e++;
  1630.   }
  1631.   _write(' ', doit && w->direct, x, y, w->attr, w->color);
  1632.   wlocate(w, w->curx, w->cury);
  1633. }
  1635. /* ============= Support: edit a line on the screen. ============ */
  1637. /* Redraw the line we are editting. */
  1638. static void lredraw(w, x, y, s, len)
  1639. WIN *w;
  1640. int x;
  1641. int y;
  1642. char *s;
  1643. int len;
  1644. {
  1645.   int i, f;
  1647.   i = 0;
  1648.   wlocate(w, x, y);
  1649.   for(f = 0; f < len; f++) {
  1650. if (s[f] == 0) i++;
  1651. wputc(w, i ? ' ' : s[f]);
  1652.   }
  1653. }
  1655. #if MAC_LEN > 256
  1656. #  define BUFLEN MAC_LEN
  1657. #else
  1658. #  define BUFLEN 256
  1659. #endif
  1661. /* wgets - edit one line in a window. */
  1662. int wgets(w, s, linelen, maxlen)
  1663. WIN *w;
  1664. char *s;
  1665. int linelen;
  1666. int maxlen;
  1667. {
  1668.   int c;
  1669.   int idx;
  1670.   int offs = 0;
  1671.   int f, st = 0, i;
  1672.   char buf[BUFLEN];
  1673.   int quit = 0;
  1674.   int once = 1;
  1675.   int x, y, r;
  1676.   int direct = dirflush;
  1677.   int delete = 1;
  1679.   x = w->curx;
  1680.   y = w->cury;
  1682.   i = w->xs - x;
  1683.   if (linelen >= i - 1) linelen = i - 1;
  1685.   /* We assume the line has already been drawn on the screen. */
  1686.   if ((idx = strlen(s)) > linelen)
  1687. idx = linelen;
  1688.   strncpy(buf, s, sizeof(buf));
  1689.   wlocate(w, x + idx, y);
  1690.   dirflush = 0;
  1691.   wflush();
  1693.   while(!quit) {
  1694. if (once) {
  1695. c = K_END;
  1696. once--;
  1697. } else {
  1698. c = wxgetch();
  1699. if (c > 255 || c == K_BS || c == K_DEL) delete = 0;
  1700. }
  1701. switch(c) {
  1702. case 'r':
  1703. case 'n':
  1704. st = 0;
  1705. quit = 1;
  1706. break;
  1707. case K_ESC: /* Exit without changing. */
  1708. wlocate(w, x, y);
  1709. lredraw(w, x, y, s, linelen);
  1710. wflush();
  1711. st = -1;
  1712. quit = 1;
  1713. break;
  1714. case K_HOME: /* Home */
  1715. r = (offs > 0);
  1716. offs = 0;
  1717. idx = 0;
  1718. if (r) lredraw(w, x, y, buf, linelen);
  1719. wlocate(w, x, y);
  1720. wflush();
  1721. break;
  1722. case K_END: /* End of line. */
  1723. idx = strlen(buf);
  1724. r = 0;
  1725. while(idx - offs > linelen) {
  1726. r = 1;
  1727. offs += 4;
  1728. }
  1729. if (r) lredraw(w, x, y, buf + offs, linelen);
  1730. wlocate(w, x + idx - offs, y);
  1731. wflush();
  1732. break;
  1733. case K_LT: /* Cursor left. */
  1734. case K_BS: /* Backspace is first left, then DEL. */
  1735. if (idx == 0) break;
  1736. idx--;
  1737. if (idx < offs) {
  1738. offs -= 4;
  1739. /*if (c == K_LT) FIXME? */
  1740. lredraw(w, x, y, buf + offs, linelen);
  1741. }
  1742. if(c == K_LT) {
  1743. wlocate(w, x + idx - offs, y);
  1744. wflush();
  1745. break;
  1746. }
  1747. /*FALLTHRU*/
  1748. case K_DEL: /* Delete character under cursor. */
  1749. if (buf[idx] == 0) break;
  1750. for(f = idx; buf[f]; f++)
  1751. buf[f] = buf[f+1];
  1752. lredraw(w, x + idx - offs, y, buf + idx,
  1753. linelen - (idx - offs));
  1754. wlocate(w, x + idx - offs, y);
  1755. wflush();
  1756. break;
  1757. case K_RT:
  1758. if (buf[idx] == 0) break;
  1759. idx++;
  1760. if (idx - offs > linelen) {
  1761. offs += 4;
  1762. lredraw(w, x, y, buf + offs, linelen);
  1763. }
  1764. wlocate(w, x + idx - offs, y);
  1765. wflush();
  1766. break;
  1767. default:
  1768. /* If delete == 1, delete the buffer. */
  1769. if (delete) {
  1770. if ((i = strlen(buf)) > linelen)
  1771. i = linelen;
  1772. buf[0] = 0;
  1773. idx = 0;
  1774. offs = 0;
  1775. wlocate(w, x, y);
  1776. for(f = 0; f < i; f++) wputc(w, ' ');
  1777. delete = 0;
  1778. }
  1780. /* Insert character at cursor position. */
  1781. if (c < 32 || c > 127) break;
  1782. if (idx + 1 >= maxlen) break;
  1783. for(f = strlen(buf) + 1; f > idx; f--)
  1784. buf[f] = buf[f-1];
  1785. i = buf[idx];
  1786. buf[idx] = c;
  1787. if (i == 0) buf[idx+1] = i;
  1788. if (idx - offs >= linelen) {
  1789. offs += 4;
  1790. lredraw(w, x, y, buf + offs, linelen);
  1791. } else
  1792. lredraw(w, x + idx - offs, y, buf + idx,
  1793. linelen - (idx - offs));
  1794. idx++;
  1795. wlocate(w, x + idx - offs, y);
  1796. wflush();
  1797. break;
  1798. }
  1799.   }
  1800.   if (st == 0) strcpy(s, buf);
  1801.   dirflush = direct;
  1802.   return(st);
  1803. }
  1805. /* ==== Initialization code ==== */
  1807. static char tbuf[1024];
  1808. static char cbuf[2048];
  1810. /* Map AC characters. */
  1811. static int acmap(c)
  1812. int c;
  1813. {
  1814.   char *p;
  1816.   for(p = AC; *p; p += 2)
  1817. if (*p == c) return(*++p);
  1818.   return('.');
  1819. }
  1821. /*
  1822.  * Initialize the window system
  1823.  */
  1824. #ifdef BBS
  1825. /* Code for the BBS system.. */
  1826. int win_init(term, lines)
  1827. char *term;
  1828. int lines;
  1829. {
  1830.   int fg = WHITE;
  1831.   int bg = BLACK;
  1832.   int attr = XA_NORMAL;
  1833. #else
  1834. /* Code for other applications (minicom!) */
  1835. int win_init(fg, bg, attr)
  1836. int fg;
  1837. int bg;
  1838. int attr;
  1839. {
  1840.   char *term;
  1841. #endif
  1842.   static WIN _stdwin;
  1843.   int f, olduseattr;
  1845.   if (w_init) return(0);
  1847. #ifndef BBS
  1848.   if ((term = getenv("TERM")) == CNULL) {
  1849.    fprintf(stderr, "Environment variable TERM not setn");
  1850. return(-1);
  1851.   }
  1852. #endif
  1853.   switch((f = tgetent(cbuf, term))) {
  1854.    case 0:
  1855.    fprintf(stderr, "No termcap entry for %sn", term);
  1856.    return(-1);
  1857.    case -1:
  1858.    fprintf(stderr, "No termcap database present!n");
  1859.    return(-1);
  1860.    default:
  1861.    break;
  1862.   }
  1863.   _tptr = tbuf;
  1865.   if ((CM = tgetstr("cm", &_tptr)) == CNULL) {
  1866.    fprintf(stderr, "No cursor motion capability (cm)n");
  1867.    return(-1);
  1868.   }
  1869.   LINES = COLS = 0;
  1870.   getrowcols(&LINES, &COLS);
  1871. #ifdef BBS
  1872.   LINES = lines;
  1873. #endif
  1874.   if (LINES == 0 && (LINES = tgetnum("li")) <= 0) {
  1875.    fprintf(stderr, "Number of terminal lines unknownn");
  1876.    return(-1);
  1877.   }
  1878.   if (COLS == 0 && (COLS = tgetnum("co")) <= 0) {
  1879.    fprintf(stderr, "Number of terminal columns unknownn");
  1880.    return(-1);
  1881.   }
  1883.   /* Terminal Capabilities */
  1884.   ME = tgetstr("me", &_tptr);
  1885.   SE = tgetstr("se", &_tptr);
  1886.   UE = tgetstr("ue", &_tptr);
  1887.   AS = tgetstr("as", &_tptr);
  1888.   AE = tgetstr("ae", &_tptr);
  1889.   MB = tgetstr("mb", &_tptr);
  1890.   MD = tgetstr("md", &_tptr);
  1891.   MR = tgetstr("mr", &_tptr);
  1892.   SO = tgetstr("so", &_tptr);
  1893.   US = tgetstr("us", &_tptr);
  1894.   CE = tgetstr("ce", &_tptr);
  1895.   Al = tgetstr("al", &_tptr);
  1896.   Dl = tgetstr("dl", &_tptr);
  1897.   AL = tgetstr("AL", &_tptr);
  1898.   DL = tgetstr("DL", &_tptr);
  1899.   CS = tgetstr("cs", &_tptr);
  1900.   SF = tgetstr("sf", &_tptr);
  1901.   SR = tgetstr("sr", &_tptr);
  1902.   VB = tgetstr("vb", &_tptr);
  1903.   BL = tgetstr("bl", &_tptr);
  1904.   VE = tgetstr("ve", &_tptr);
  1905.   VI = tgetstr("vi", &_tptr);
  1906.   IS = tgetstr("is", &_tptr);
  1907.   RS = tgetstr("rs", &_tptr);
  1908.   KS = tgetstr("ks", &_tptr);
  1909.   KE = tgetstr("ke", &_tptr);
  1910.   CD = tgetstr("cd", &_tptr);
  1911.   CL = tgetstr("cl", &_tptr);
  1912.   IC = tgetstr("ic", &_tptr);
  1913.   DC = tgetstr("dc", &_tptr);
  1914.   BC = tgetstr("bc", &_tptr);
  1915.   CR = tgetstr("cr", &_tptr);
  1916.   NL = tgetstr("nl", &_tptr);
  1917.   AC = tgetstr("ac", &_tptr);
  1918.   EA = tgetstr("eA", &_tptr);
  1919. #if ST_LINE
  1920.   TS = tgetstr("ts", &_tptr);
  1921.   FS = tgetstr("fs", &_tptr);
  1922.   DS = tgetstr("ds", &_tptr);
  1923. #endif
  1925.   if (MR == CNULL) MR = SO;  /* Try standout */
  1926.   if (MR == CNULL) MR = US;  /* Try underline */
  1927.   if (MR == CNULL) MR = MD;  /* Try bold */
  1928.   if (SF == CNULL) SF = "n";
  1929.   if (AC == NULL || *AC == 0) AC = def_ac; /* Standard vt100 mappings. */
  1931.   /* cr and nl are often not defined but result in great optimization.
  1932.    * I only hope that minicom does not break on terminals where this
  1933.    * really does not work..
  1934.    */
  1935.   if (CR == CNULL) CR = "r";
  1936.   if (NL == CNULL) NL = "n";
  1938. #if ST_LINE
  1939.   /* See if we can use the status line. */
  1940.   if (!tgetflag("hs") || !tgetflag("es") || !TS || !FS)
  1941. use_status = 0;
  1942. #else
  1943.   use_status = 0;
  1944. #endif
  1946.   if (IS != CNULL) outstr(IS); /* Initialization string */
  1948.   /* Reset attributes */
  1949.   olduseattr = useattr;
  1950.   useattr = 1;
  1951.   _setattr(XA_NORMAL, COLATTR(WHITE, BLACK));
  1952.   useattr = olduseattr;
  1954.   /* No reverse? don't use attributes at all. */
  1955.   if (MR == CNULL) useattr = 0;
  1957.   /* If we have the "ug" flag, don't allow attributes to be displayed. */
  1958.   if (tgetnum("ug") > 0) useattr = 0;
  1959.   
  1960.   _has_am = tgetflag("am");
  1961.   _mv_standout = tgetflag("ms");
  1962.   if (tgetflag("bs")) {
  1963.     if (BC == CNULL) BC = "b";
  1964.   } 
  1965.   else
  1966.     BC = CNULL;
  1968.   /* Special IBM box-drawing characters */
  1969.   D_UL  = 201;
  1970.   D_HOR = 205;
  1971.   D_UR  = 187;
  1972.   D_LL  = 200;
  1973.   D_VER = 186;
  1974.   D_LR  = 188;
  1975.   
  1976.   S_UL  = 218;
  1977.   S_HOR = 240;
  1978.   S_UR  = 191;
  1979.   S_LL  = 192;
  1980.   S_VER = 179;
  1981.   S_LR  = 217;
  1983.   if (AS != NULL && !screen_ibmpc) {
  1984. /* Try to find AC mappings. */
  1985. D_UL  = S_UL  = acmap('l');
  1986. D_HOR = S_HOR = acmap('q');
  1987. D_UR  = S_UR  = acmap('k');
  1988. D_LL  = S_LL  = acmap('m');
  1989. D_VER = S_VER = acmap('x');
  1990. D_LR  = S_LR  = acmap('j');
  1991.   }
  1993.   if (screen_iso) {
  1994.         /* Try to find AC mappings. */
  1995. D_UL  = S_UL  = '+';
  1996. D_HOR = S_HOR = '-';
  1997. D_UR  = S_UR  = '+';
  1998. D_LL  = S_LL  = '+';
  1999. D_VER = S_VER = '|';
  2000. D_LR  = S_LR  = '+';
  2001.   }
  2004. #if VERY_OLD
  2005.   if ((p = tgetstr("gA", &_tptr)) != CNULL) wcharmap[201] = *p;
  2006.   if ((p = tgetstr("gB", &_tptr)) != CNULL) wcharmap[205] = *p;
  2007.   if ((p = tgetstr("gC", &_tptr)) != CNULL) wcharmap[187] = *p;
  2008.   if ((p = tgetstr("gD", &_tptr)) != CNULL) wcharmap[200] = *p;
  2009.   if ((p = tgetstr("gE", &_tptr)) != CNULL) wcharmap[186] = *p;
  2010.   if ((p = tgetstr("gF", &_tptr)) != CNULL) wcharmap[188] = *p;
  2011.   if ((p = tgetstr("gG", &_tptr)) != CNULL) wcharmap[218] = *p;
  2012.   if ((p = tgetstr("gH", &_tptr)) != CNULL) wcharmap[240] = *p;
  2013.   if ((p = tgetstr("gI", &_tptr)) != CNULL) wcharmap[191] = *p;
  2014.   if ((p = tgetstr("gJ", &_tptr)) != CNULL) wcharmap[192] = *p;
  2015.   if ((p = tgetstr("gK", &_tptr)) != CNULL) wcharmap[179] = *p;
  2016.   if ((p = tgetstr("gL", &_tptr)) != CNULL) wcharmap[217] = *p;
  2017. #endif
  2019.   /* Memory for global map */
  2020.   if ((gmap = (ELM *)malloc(sizeof(ELM) * (LINES + 1) * COLS)) == (ELM *)0) {
  2021.    fprintf(stderr, "Not enough memoryn");
  2022.    return(-1);
  2023.   };
  2024.   _buffend = _bufstart + BUFFERSIZE;
  2026.   /* Initialize stdwin */
  2027.   stdwin = &_stdwin;
  2029.   stdwin->wrap = 1;
  2030.   stdwin->cursor = CNORMAL;
  2031.   stdwin->autocr = 1;
  2032.   stdwin->doscroll = 1;
  2033.   stdwin->x1 = 0;
  2034.   stdwin->sy1 = stdwin->y1 = 0;
  2035.   stdwin->x2 = COLS - 1;
  2036.   stdwin->sy2 = stdwin->y2 = LINES - 1;
  2037.   stdwin->xs = COLS;
  2038.   stdwin->ys = LINES;
  2039.   stdwin->attr = attr;
  2040.   stdwin->color = COLATTR(fg, bg);
  2041.   stdwin->direct = 1;
  2042. #if HISTORY
  2043.   stdwin->histbuf = (ELM *)0;
  2044. #endif
  2046.   if (EA != CNULL) outstr(EA); /* Graphics init. */
  2047.   if (KS != CNULL) outstr(KS); /* Keypad mode */
  2048.   
  2049.   (void) setcbreak(1); /* Cbreak, no echo */
  2051.   winclr(stdwin);
  2052.   w_init = 1;
  2053.   return(0);
  2054. }
  2056. void win_end()
  2057. {
  2058.   if (gmap == (ELM *)0 || w_init == 0) return;
  2059.   (void) setcbreak(0); /* Reset */
  2060.   stdwin->attr = XA_NORMAL;
  2061.   stdwin->color = COLATTR(WHITE, BLACK);
  2062.   _setattr(stdwin->attr, stdwin->color);
  2063.   winclr(stdwin);
  2064. #if ST_LINE
  2065.   if (DS) outstr(DS);
  2066. #endif
  2067.   wcursor(stdwin, CNORMAL);
  2068.   if (KE != CNULL) outstr(KE);
  2069.   if (RS != CNULL) outstr(RS);
  2070.   else if (IS != CNULL) outstr(IS);
  2072.   wflush();
  2073.   free(gmap);
  2074.   gmap = (ELM *)0;
  2075.   stdwin = NIL_WIN;
  2076.   w_init = 0;
  2077. }