home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / x / volume12 / kterm / part08 < prev    next >
Text File  |  1991-05-08  |  52KB  |  1,917 lines
  1. Path: uunet!cs.utexas.edu!convex!central!newstop!male!jethro!exodus!NMSU.Edu!mleisher
  2. From: mleisher@NMSU.Edu
  3. Newsgroups: comp.sources.x
  4. Subject: v12i089: kterm  - kanji xterm, Part08/18
  5. Message-ID: <12973@exodus.Eng.Sun.COM>
  6. Date: 8 May 91 02:39:37 GMT
  7. References: <csx-12i082:kterm@uunet.UU.NET>
  8. Sender: news@exodus.Eng.Sun.COM
  9. Lines: 1905
  10. Approved: argv@sun.com
  11.  
  12. Submitted-by: mleisher@NMSU.Edu
  13. Posting-number: Volume 12, Issue 89
  14. Archive-name: kterm/part08
  15.  
  16. #!/bin/sh
  17. # this is kt412.08 (part 8 of kterm-4.1.2)
  18. # do not concatenate these parts, unpack them in order with /bin/sh
  19. # file kterm-4.1.2/charproc.c continued
  20. #
  21. if test ! -r _shar_seq_.tmp; then
  22.     echo 'Please unpack part 1 first!'
  23.     exit 1
  24. fi
  25. (read Scheck
  26.  if test "$Scheck" != 8; then
  27.     echo Please unpack part "$Scheck" next!
  28.     exit 1
  29.  else
  30.     exit 0
  31.  fi
  32. ) < _shar_seq_.tmp || exit 1
  33. if test ! -f _shar_wnt_.tmp; then
  34.     echo 'x - still skipping kterm-4.1.2/charproc.c'
  35. else
  36. echo 'x - continuing file kterm-4.1.2/charproc.c'
  37. sed 's/^X//' << 'SHAR_EOF' >> 'kterm-4.1.2/charproc.c' &&
  38. X            break;
  39. X
  40. X         case CASE_HIDE_STATUS:
  41. X            HideStatus();
  42. X            parsestate = groundtable;
  43. X            break;
  44. X
  45. X         case CASE_ERASE_STATUS:
  46. X            EraseStatus();
  47. X            parsestate = groundtable;
  48. X            break;
  49. #endif /* STATUSLINE */
  50. X
  51. X         case CASE_XTERM_SAVE:
  52. X            savemodes(term);
  53. X            parsestate = groundtable;
  54. X            break;
  55. X
  56. X         case CASE_XTERM_RESTORE:
  57. X            restoremodes(term);
  58. X            parsestate = groundtable;
  59. X            break;
  60. #ifdef KTERM_KANJI
  61. X        }
  62. #else /* !KTERM_KANJI */
  63. X        }
  64. #endif /* !KTERM_KANJI */
  65. X    }
  66. }
  67. X
  68. finput()
  69. {
  70. X    return(doinput());
  71. }
  72. X
  73. static int select_mask;
  74. static int write_mask;
  75. X
  76. static char v_buffer[4096];
  77. static char *v_bufstr;
  78. static char *v_bufptr;
  79. static char *v_bufend;
  80. #define    ptymask()    (v_bufptr > v_bufstr ? pty_mask : 0)
  81. X
  82. v_write(f, d, l)
  83. int f;
  84. char *d;
  85. int l;
  86. {
  87. X    int r;
  88. X    int c = l;
  89. X
  90. X    if (!v_bufstr) {
  91. X        v_bufstr = v_buffer;
  92. X        v_bufptr = v_buffer;
  93. X        v_bufend = &v_buffer[4096];
  94. X    }
  95. X
  96. X
  97. X    if ((1 << f) != pty_mask)
  98. X        return(write(f, d, l));
  99. X
  100. X    if (v_bufptr > v_bufstr) {
  101. X        if (l) {
  102. X            if (v_bufend > v_bufptr + l) {
  103. X                bcopy(d, v_bufptr, l);
  104. X                v_bufptr += l;
  105. X            } else {
  106. X                if (v_bufstr != v_buffer) {
  107. X                    bcopy(v_bufstr, v_buffer,
  108. X                          v_bufptr - v_bufstr);
  109. X                    v_bufptr -= v_bufstr - v_buffer;
  110. X                    v_bufstr = v_buffer;
  111. X                }
  112. X                if (v_bufend > v_bufptr + l) {
  113. X                    bcopy(d, v_bufptr, l);
  114. X                    v_bufptr += l;
  115. X                } else if (v_bufptr < v_bufend) {
  116. X                    fprintf(stderr, "Out of buffer space\n");
  117. X                    c = v_bufend - v_bufptr;
  118. X                    bcopy(d, v_bufptr, c);
  119. X                    v_bufptr = v_bufend;
  120. X                } else {
  121. X                    fprintf(stderr, "Out of buffer space\n");
  122. X                    c = 0;
  123. X                }
  124. X            }
  125. X        }
  126. X        if (v_bufptr > v_bufstr) {
  127. X            if ((r = write(f, v_bufstr, v_bufptr - v_bufstr)) <= 0)
  128. X                return(r);
  129. X            if ((v_bufstr += r) >= v_bufptr)
  130. X                v_bufstr = v_bufptr = v_buffer;
  131. X        }
  132. X    } else if (l) {
  133. X        if ((r = write(f, d, l)) < 0) {
  134. X            if (errno == EWOULDBLOCK)
  135. X                r = 0;
  136. X            else if (errno == EINTR)
  137. X                r = 0;
  138. X            else
  139. X                return(r);
  140. X        }
  141. X        if (l - r) {
  142. X            if (l - r > v_bufend - v_buffer) {
  143. X                fprintf(stderr, "Truncating to %d\n",
  144. X                        v_bufend - v_buffer);
  145. X                l = (v_bufend - v_buffer) + r;
  146. X            }
  147. X            bcopy(d + r, v_buffer, l - r);
  148. X            v_bufstr = v_buffer;
  149. X            v_bufptr = v_buffer + (l - r);
  150. X        }
  151. X    }
  152. X    return(c);
  153. }
  154. X
  155. in_put()
  156. {
  157. X    register TScreen *screen = &term->screen;
  158. X    register int i;
  159. X    static struct timeval trackTimeOut;
  160. X
  161. X    select_mask = pty_mask;    /* force initial read */
  162. X    for( ; ; ) {
  163. #ifdef        CRAY
  164. X        trackTimeOut.tv_sec = 0;
  165. X        trackTimeOut.tv_usec = 0;
  166. X        (void) select(max_plus1, &select_mask, (int *) NULL,
  167. X            (int *)NULL, &trackTimeOut);
  168. #endif        /* CRAY */
  169. X
  170. X        if((select_mask & pty_mask) && (eventMode == NORMAL)) {
  171. X            if(screen->logging)
  172. X                FlushLog(screen);
  173. X            if((bcnt = read(screen->respond, bptr = buffer,
  174. X             BUF_SIZE)) < 0) {
  175. X                if(errno == EIO)
  176. X                    Cleanup (0);
  177. X                else if(errno != EWOULDBLOCK)
  178. X                    Panic(
  179. X                 "input: read returned unexpected error (%d)\n",
  180. X                     errno);
  181. X            } else if(bcnt == 0)
  182. X                Panic("input: read returned zero\n", 0);
  183. X            else {
  184. #ifdef KTERM_KANJI
  185. X                if (pending_byte) {
  186. X                    /*
  187. X                     * restore pending_byte to the top of
  188. X                     * the text which just read.
  189. X                     */
  190. X                    *--bptr = pending_byte;
  191. X                    bcnt++;
  192. X                    pending_byte = 0;
  193. X                }
  194. #endif /* KTERM_KANJI */
  195. X                if(screen->scrollWidget && screen->scrollttyoutput &&
  196. X                 screen->topline < 0)
  197. X                    /* Scroll to bottom */
  198. X                    WindowScroll(screen, 0);
  199. X                break;
  200. X            }
  201. X        }
  202. X        if(screen->scroll_amt)
  203. X            FlushScroll(screen);
  204. X        if(screen->cursor_set && (screen->cursor_col != screen->cur_col
  205. X         || screen->cursor_row != screen->cur_row)) {
  206. X            if(screen->cursor_state)
  207. X                HideCursor();
  208. X            ShowCursor();
  209. X        } else if(screen->cursor_set != screen->cursor_state) {
  210. X            if(screen->cursor_set)
  211. X                ShowCursor();
  212. X            else
  213. X                HideCursor();
  214. X        }
  215. X        
  216. X    if (waitingForTrackInfo) {
  217. X            trackTimeOut.tv_sec = TRACKTIMESEC;
  218. X            trackTimeOut.tv_usec = TRACKTIMEUSEC;
  219. X            select_mask = pty_mask;
  220. X            if ((i = select(max_plus1, &select_mask, (int *)NULL, (int *)NULL,
  221. X             &trackTimeOut)) < 0) {
  222. X                 if (errno != EINTR)
  223. X                    SysError(ERROR_SELECT);
  224. X                continue;
  225. X            } else if (i == 0) {
  226. X                /* emacs just isn't replying, go on */
  227. X                waitingForTrackInfo = 0;
  228. X                Bell();
  229. X                select_mask = Select_mask;
  230. X            }
  231. X        } else if (QLength(screen->display))
  232. X            select_mask = X_mask;
  233. X        else {
  234. X            write_mask = ptymask();
  235. X            XFlush(screen->display);
  236. X            select_mask = Select_mask;
  237. X            if (eventMode != NORMAL)
  238. X                select_mask = X_mask;
  239. X            if(select(max_plus1, &select_mask, &write_mask, 
  240. X                (int *)NULL, (struct timeval *) NULL) < 0){
  241. X                if (errno != EINTR)
  242. X                    SysError(ERROR_SELECT);
  243. X                continue;
  244. X            } 
  245. X        }
  246. X        if (write_mask & ptymask())
  247. X            v_write(screen->respond, 0, 0);    /* flush buffer */
  248. X        if(select_mask & X_mask) {
  249. X            if (bcnt <= 0) {
  250. X                bcnt = 0;
  251. X                bptr = buffer;
  252. X            }
  253. X            xevents();
  254. X            if (bcnt > 0)
  255. X                break;
  256. X        }
  257. X    }
  258. X    bcnt--;
  259. X    return(*bptr++);
  260. }
  261. X
  262. /*
  263. X * process a string of characters according to the character set indicated
  264. X * by charset.  worry about end of line conditions (wraparound if selected).
  265. X */
  266. dotext(screen, flags, charset, buf, ptr)
  267. register TScreen    *screen;
  268. unsigned    flags;
  269. #ifdef KTERM
  270. Char        charset;
  271. Char    *buf;
  272. Char    *ptr;
  273. #else /* !KTERM */
  274. char        charset;
  275. char    *buf;
  276. char    *ptr;
  277. #endif /* !KTERM */
  278. {
  279. #ifdef KTERM
  280. X    int    do_wrap = 0;
  281. X    register Char    *s;
  282. #else /* !KTERM */
  283. X    register char    *s;
  284. #endif /* !KTERM */
  285. X    register int    len;
  286. X    register int    n;
  287. X    register int    next_col;
  288. X
  289. #ifdef KTERM
  290. X    switch (charset) {
  291. X    case GSET_UK:        /* United Kingdom set            */
  292. X        for (s=buf; s<ptr; ++s)
  293. X            *s &= ~NEEDMAP;
  294. X            if (*s == '#') /* UK pound sign */
  295. X                *s |= NEEDMAP;
  296. X        break;
  297. X
  298. X    case GSET_KANA:        /* JIS Kana set                */
  299. X        for (s=buf; s<ptr; ++s) {
  300. X            *s |= NEEDMAP;
  301. X        }
  302. X        break;
  303. X
  304. X    case GSET_GRAPH:    /* special graphics (line drawing)    */
  305. X    case GSET_ASCII:    /* ASCII set                */
  306. X    case GSET_JISROMAN:    /* JIS Roman set            */
  307. X    case GSET_LATIN1R:    /* Right part of ISO8859-1    */
  308. X    case GSET_LATIN2R:    /* Right part of ISO8859-2    */
  309. X    case GSET_LATIN3R:    /* Right part of ISO8859-3    */
  310. X    case GSET_LATIN4R:    /* Right part of ISO8859-4    */
  311. X    case GSET_LATIN7R:    /* Right part of ISO8859-7    */
  312. X    case GSET_LATIN6R:    /* Right part of ISO8859-6    */
  313. X    case GSET_LATIN8R:    /* Right part of ISO8859-8    */
  314. X    case GSET_LATIN5R:    /* Right part of ISO8859-5    */
  315. X    case GSET_LATIN9R:    /* Right part of ISO8859-9    */
  316. X    case GSET_KANJI:    /* JISX0208 Kanji set        */
  317. X    case GSET_OLDKANJI:    /* JISX0208 Kanji set        */
  318. #ifdef KTERM_HANZI
  319. X        case GSET_HANZI:        /* GB2312 Hanzi set */
  320. #endif /* KTERM_HANZI */
  321. #ifdef KTERM_HANGUL
  322. X        case GSET_HANGUL:    /* KSC5601 Hangul set */
  323. #endif /* KTERM_HANGUL */
  324. X
  325. X                if (FontType(screen, FNUM(charset), 0) == LOW) {
  326. X                    for (s=buf; s<ptr; ++s) {
  327. X            *s &= ~NEEDMAP;
  328. X                    }
  329. X                }
  330. X                break;
  331. X
  332. X    default:    /* any character sets we don't recognize*/
  333. X        return;
  334. X    }
  335. #else /* !KTERM */
  336. X    switch (charset) {
  337. X    case 'A':    /* United Kingdom set            */
  338. X        for (s=buf; s<ptr; ++s)
  339. X            if (*s == '#')
  340. X                *s = '\036';    /* UK pound sign*/
  341. X        break;
  342. X
  343. X    case 'B':    /* ASCII set                */
  344. X        break;
  345. X
  346. X    case '0':    /* special graphics (line drawing)    */
  347. X        for (s=buf; s<ptr; ++s)
  348. X            if (*s>=0x5f && *s<=0x7e)
  349. X                *s = *s == 0x5f ? 0x7f : *s - 0x5f;
  350. X        break;
  351. X
  352. X    default:    /* any character sets we don't recognize*/
  353. X        return;
  354. X    }
  355. #endif /* !KTERM */
  356. X
  357. X    len = ptr - buf; 
  358. X    ptr = buf;
  359. X    while (len > 0) {
  360. X        n = screen->max_col-screen->cur_col+1;
  361. X        if (n <= 1) {
  362. #ifdef STATUSLINE
  363. X            if (screen->do_wrap && (flags&WRAPAROUND) &&
  364. X                !screen->instatus) {
  365. #else /* !STATUSLINE */
  366. X            if (screen->do_wrap && (flags&WRAPAROUND)) {
  367. #endif /* !STATUSLINE */
  368. X                Index(screen, 1);
  369. X                screen->cur_col = 0;
  370. X                screen->do_wrap = 0;
  371. X                n = screen->max_col+1;
  372. X            } else
  373. X                n = 1;
  374. X        }
  375. X        if (len < n)
  376. X            n = len;
  377. #ifdef KTERM_KANJI
  378. X        if (charset & MBCS) {
  379. X            if (n == 1) {
  380. X                if (flags & WRAPAROUND) {
  381. X                    n--; do_wrap = 1;
  382. X                } else
  383. X                    n++;
  384. X            } else
  385. X                if (n & 1)
  386. X                    n--;
  387. X        }
  388. #endif /* KTERM_KANJI */
  389. X        next_col = screen->cur_col + n;
  390. #ifdef KTERM
  391. X        WriteText(screen, ptr, n, flags, charset);
  392. #else /* !KTERM */
  393. X        WriteText(screen, ptr, n, flags);
  394. #endif /* !KTERM */
  395. X        /*
  396. X         * the call to WriteText updates screen->cur_col.
  397. X         * If screen->cur_col != next_col, we must have
  398. X         * hit the right margin, so set the do_wrap flag.
  399. X         */
  400. X        screen->do_wrap = (screen->cur_col < next_col);
  401. #ifdef KTERM_KANJI
  402. X        screen->do_wrap |= do_wrap;
  403. #endif /* KTERM_KANJI */
  404. X        len -= n;
  405. X        ptr += n;
  406. X    }
  407. }
  408. X 
  409. /*
  410. X * write a string str of length len onto the screen at
  411. X * the current cursor position.  update cursor position.
  412. X */
  413. #ifdef KTERM
  414. WriteText(screen, str, len, flags, gset)
  415. #else /* !KTERM */
  416. WriteText(screen, str, len, flags)
  417. #endif /* !KTERM */
  418. register TScreen    *screen;
  419. register char    *str;
  420. register int    len;
  421. unsigned    flags;
  422. #ifdef KTERM
  423. register Char    gset;
  424. #endif /* KTERM */
  425. {
  426. X    register int cx, cy;
  427. X    register unsigned fgs = flags;
  428. #ifdef KTERM
  429. X    register int    i, n;
  430. X    XChar2b drawbuf[256], *dbuf;
  431. X
  432. X    dbuf = (len > 256) ? (XChar2b *)XtMalloc(len * sizeof(XChar2b))
  433. X               : drawbuf;
  434. #else /* !KTERM */
  435. X    GC    currentGC;
  436. #endif /* !KTERM */
  437. X 
  438. #ifdef STATUSLINE
  439. X   if(screen->instatus && screen->reversestatus)
  440. X    fgs ^= INVERSE;
  441. X   if(screen->cur_row - screen->topline <= screen->max_row ||
  442. X      screen->instatus) {
  443. #else /* !STATUSLINE */
  444. X   if(screen->cur_row - screen->topline <= screen->max_row) {
  445. #endif /* !STATUSLINE */
  446. X    /*
  447. X    if(screen->cur_row == screen->cursor_row && screen->cur_col <=
  448. X     screen->cursor_col && screen->cursor_col <= screen->cur_col + len - 1)
  449. X        screen->cursor_state = OFF;
  450. X     */
  451. X    if(screen->cursor_state)
  452. X        HideCursor();
  453. X
  454. #ifndef KTERM
  455. X    /*
  456. X     *    make sure that the correct GC is current
  457. X     */
  458. X
  459. X    if (fgs & BOLD)
  460. X        if (fgs & INVERSE)
  461. X            currentGC = screen->reverseboldGC;
  462. X        else    currentGC = screen->normalboldGC;
  463. X    else  /* not bold */
  464. X        if (fgs & INVERSE)
  465. X            currentGC = screen->reverseGC;
  466. X        else    currentGC = screen->normalGC;
  467. #endif /* !KTERM */
  468. X
  469. X    if (fgs & INSERT)
  470. X        InsertChar(screen, len);
  471. X      if (!(AddToRefresh(screen))) {
  472. X        if(screen->scroll_amt)
  473. X            FlushScroll(screen);
  474. #ifdef KTERM
  475. #ifdef KTERM_KANJI
  476. X    if (gset & MBCS) {
  477. X        for (i = n = 0; i < len; n++) {
  478. X            dbuf[n].byte1 = str[i++];
  479. X            dbuf[n].byte2 = str[i++];
  480. X        }
  481. X    } else
  482. #endif /* KTERM_KANJI */
  483. X    for (n = 0; n < len; n++) {
  484. X        dbuf[n].byte1 = 0;
  485. X        dbuf[n].byte2 = MapOnFont(gset, str[n]);
  486. X    }
  487. #endif /* KTERM */
  488. X    cx = CursorX(screen, screen->cur_col);
  489. #ifdef KTERM
  490. X    cy = CursorY(screen, screen->cur_row);
  491. #ifdef STATUSLINE
  492. X    if (screen->instatus)
  493. X        cy ++;
  494. #endif /* STATUSLINE */
  495. X    BreakMBchar(screen);
  496. X    screen->cur_col += len;
  497. X    BreakMBchar(screen);
  498. X    screen->cur_col -= len;
  499. #ifdef  COLOR_TEXT /* mukawa */
  500. X    ScreenDraw(screen, cx, cy, dbuf, n, gset, fgs,
  501. #else    /* COLOR_TEXT */
  502. X    ScreenDraw(screen, cx, cy, dbuf, n, gset,
  503. #endif  /* COLOR_TEXT */
  504. X        fgs & BOLD, fgs & INVERSE, fgs & UNDERLINE, False);
  505. #else /* !KTERM */
  506. X    cy = CursorY(screen, screen->cur_row)+screen->fnt_norm->ascent;
  507. X     XDrawImageString(screen->display, TextWindow(screen), currentGC,
  508. X            cx, cy, str, len);
  509. X
  510. X    if((fgs & BOLD) && screen->enbolden) 
  511. X        if (currentGC == screen->normalGC || screen->reverseGC)
  512. X            XDrawString(screen->display, TextWindow(screen),
  513. X                      currentGC,cx + 1, cy, str, len);
  514. X
  515. X    if(fgs & UNDERLINE) 
  516. X        XDrawLine(screen->display, TextWindow(screen), currentGC,
  517. X            cx, cy+1,
  518. X            cx + len * FontWidth(screen), cy+1);
  519. #endif /* !KTERM */
  520. X    /*
  521. X     * the following statements compile data to compute the average 
  522. X     * number of characters written on each call to XText.  The data
  523. X     * may be examined via the use of a "hidden" escape sequence.
  524. X     */
  525. X    ctotal += len;
  526. X    ++ntotal;
  527. X      }
  528. X    }
  529. #ifdef KTERM
  530. X    ScreenWrite(screen, str, flags, gset, len);
  531. #else /* !KTERM */
  532. X    ScreenWrite(screen, str, flags, len);
  533. #endif /* !KTERM */
  534. X    CursorForward(screen, len);
  535. }
  536. X 
  537. /*
  538. X * process ANSI modes set, reset
  539. X */
  540. modes(term, func)
  541. XXtermWidget    term;
  542. int        (*func)();
  543. {
  544. X    register int    i;
  545. X
  546. X    for (i=0; i<nparam; ++i) {
  547. X        switch (param[i]) {
  548. X        case 4:            /* IRM                */
  549. X            (*func)(&term->flags, INSERT);
  550. X            break;
  551. X
  552. X        case 20:        /* LNM                */
  553. X            (*func)(&term->flags, LINEFEED);
  554. X            update_autolinefeed();
  555. X            break;
  556. X        }
  557. X    }
  558. }
  559. X
  560. /*
  561. X * process DEC private modes set, reset
  562. X */
  563. dpmodes(term, func)
  564. XXtermWidget    term;
  565. int        (*func)();
  566. {
  567. X    register TScreen    *screen    = &term->screen;
  568. X    register int    i, j;
  569. X    extern int bitset();
  570. X
  571. X    for (i=0; i<nparam; ++i) {
  572. X        switch (param[i]) {
  573. X        case 1:            /* DECCKM            */
  574. X            (*func)(&term->keyboard.flags, CURSOR_APL);
  575. X            break;
  576. X        case 2:            /* ANSI/VT52 mode        */
  577. X            if (func == bitset) {
  578. X                screen->gsets[0] =
  579. X                    screen->gsets[1] =
  580. X                    screen->gsets[2] =
  581. X                    screen->gsets[3] = 'B';
  582. X                screen->curgl = 0;
  583. X                screen->curgr = 2;
  584. X            }
  585. X            break;
  586. X        case 3:            /* DECCOLM            */
  587. X            if(screen->c132) {
  588. X                ClearScreen(screen);
  589. X                CursorSet(screen, 0, 0, term->flags);
  590. X                if((j = func == bitset ? 132 : 80) !=
  591. X                 ((term->flags & IN132COLUMNS) ? 132 : 80) ||
  592. X                 j != screen->max_col + 1) {
  593. X                        Dimension replyWidth, replyHeight;
  594. X                    XtGeometryResult status;
  595. X
  596. X                    status = XtMakeResizeRequest (
  597. X                        (Widget) term, 
  598. X                        (Dimension) FontWidth(screen) * j
  599. X                            + 2*screen->border
  600. X                        + screen->scrollbar,
  601. X                        (Dimension) FontHeight(screen)
  602. X                        * (screen->max_row + 1)
  603. X                        + 2 * screen->border,
  604. X                        &replyWidth, &replyHeight);
  605. X
  606. X                    if (status == XtGeometryYes ||
  607. X                        status == XtGeometryDone) {
  608. X                        ScreenResize (&term->screen,
  609. X                              replyWidth,
  610. X                              replyHeight,
  611. X                              &term->flags);
  612. X                    }
  613. X                }
  614. X                (*func)(&term->flags, IN132COLUMNS);
  615. X            }
  616. X            break;
  617. X        case 4:            /* DECSCLM (slow scroll)    */
  618. X            if (func == bitset) {
  619. X                screen->jumpscroll = 0;
  620. X                if (screen->scroll_amt)
  621. X                    FlushScroll(screen);
  622. X            } else
  623. X                screen->jumpscroll = 1;
  624. X            (*func)(&term->flags, SMOOTHSCROLL);
  625. X            update_jumpscroll();
  626. X            break;
  627. X        case 5:            /* DECSCNM            */
  628. X            j = term->flags;
  629. X            (*func)(&term->flags, REVERSE_VIDEO);
  630. X            if ((term->flags ^ j) & REVERSE_VIDEO)
  631. X                ReverseVideo(term);
  632. X            /* update_reversevideo done in RevVid */
  633. X            break;
  634. X
  635. X        case 6:            /* DECOM            */
  636. X            (*func)(&term->flags, ORIGIN);
  637. X            CursorSet(screen, 0, 0, term->flags);
  638. X            break;
  639. X
  640. X        case 7:            /* DECAWM            */
  641. X            (*func)(&term->flags, WRAPAROUND);
  642. X            update_autowrap();
  643. X            break;
  644. X        case 8:            /* DECARM            */
  645. X            /* ignore autorepeat */
  646. X            break;
  647. X        case 9:            /* MIT bogus sequence        */
  648. X            if(func == bitset)
  649. X                screen->send_mouse_pos = 1;
  650. X            else
  651. X                screen->send_mouse_pos = 0;
  652. X            break;
  653. X        case 38:        /* DECTEK            */
  654. X            if(func == bitset & !(screen->inhibit & I_TEK)) {
  655. X                if(screen->logging) {
  656. X                    FlushLog(screen);
  657. X                    screen->logstart = Tbuffer;
  658. X                }
  659. X                screen->TekEmu = TRUE;
  660. X            }
  661. X            break;
  662. X        case 40:        /* 132 column mode        */
  663. X            screen->c132 = (func == bitset);
  664. X            update_allow132();
  665. X            break;
  666. X        case 41:        /* curses hack            */
  667. X            screen->curses = (func == bitset);
  668. X            update_cursesemul();
  669. X            break;
  670. X        case 44:        /* margin bell            */
  671. X            screen->marginbell = (func == bitset);
  672. X            if(!screen->marginbell)
  673. X                screen->bellarmed = -1;
  674. X            update_marginbell();
  675. X            break;
  676. X        case 45:        /* reverse wraparound    */
  677. X            (*func)(&term->flags, REVERSEWRAP);
  678. X            update_reversewrap();
  679. X            break;
  680. X        case 46:        /* logging        */
  681. #ifdef ALLOWLOGFILEONOFF
  682. X            /*
  683. X             * if this feature is enabled, logging may be 
  684. X             * enabled and disabled via escape sequences.
  685. X             */
  686. X            if(func == bitset)
  687. X                StartLog(screen);
  688. X            else
  689. X                CloseLog(screen);
  690. #else
  691. X            Bell();
  692. X            Bell();
  693. #endif /* ALLOWLOGFILEONOFF */
  694. X            break;
  695. X        case 47:        /* alternate buffer        */
  696. X            if(func == bitset)
  697. X                ToAlternate(screen);
  698. X            else
  699. X                FromAlternate(screen);
  700. X            break;
  701. #ifdef STATUSLINE
  702. X        case 48:        /* reverse statusline        */
  703. X            j = screen->reversestatus;
  704. X            (*func)(&screen->reversestatus, 1);
  705. X            if (j != screen->reversestatus)
  706. X                ScrnRefresh(screen, screen->max_row + 1, 0, 1,
  707. X                    screen->max_col + 1);
  708. X            break;
  709. #endif /* STATUSLINE */
  710. X        case 1000:        /* xtem bogus sequence        */
  711. X            if(func == bitset)
  712. X                screen->send_mouse_pos = 2;
  713. X            else
  714. X                screen->send_mouse_pos = 0;
  715. X            break;
  716. X        case 1001:        /* xtem sequence w/hilite tracking */
  717. X            if(func == bitset)
  718. X                screen->send_mouse_pos = 3;
  719. X            else
  720. X                screen->send_mouse_pos = 0;
  721. X            break;
  722. X        }
  723. X    }
  724. }
  725. X
  726. /*
  727. X * process xterm private modes save
  728. X */
  729. savemodes(term)
  730. XXtermWidget term;
  731. {
  732. X    register TScreen    *screen    = &term->screen;
  733. X    register int i;
  734. X
  735. X    for (i = 0; i < nparam; i++) {
  736. X        switch (param[i]) {
  737. X        case 1:            /* DECCKM            */
  738. X            screen->save_modes[0] = term->keyboard.flags &
  739. X             CURSOR_APL;
  740. X            break;
  741. X        case 3:            /* DECCOLM            */
  742. X            if(screen->c132)
  743. X                screen->save_modes[1] = term->flags &
  744. X                 IN132COLUMNS;
  745. X            break;
  746. X        case 4:            /* DECSCLM (slow scroll)    */
  747. X            screen->save_modes[2] = term->flags & SMOOTHSCROLL;
  748. X            break;
  749. X        case 5:            /* DECSCNM            */
  750. X            screen->save_modes[3] = term->flags & REVERSE_VIDEO;
  751. X            break;
  752. X        case 6:            /* DECOM            */
  753. X            screen->save_modes[4] = term->flags & ORIGIN;
  754. X            break;
  755. X
  756. X        case 7:            /* DECAWM            */
  757. X            screen->save_modes[5] = term->flags & WRAPAROUND;
  758. X            break;
  759. X        case 8:            /* DECARM            */
  760. X            /* ignore autorepeat */
  761. X            break;
  762. X        case 9:            /* mouse bogus sequence */
  763. X            screen->save_modes[7] = screen->send_mouse_pos;
  764. X            break;
  765. X        case 40:        /* 132 column mode        */
  766. X            screen->save_modes[8] = screen->c132;
  767. X            break;
  768. X        case 41:        /* curses hack            */
  769. X            screen->save_modes[9] = screen->curses;
  770. X            break;
  771. X        case 44:        /* margin bell            */
  772. X            screen->save_modes[12] = screen->marginbell;
  773. X            break;
  774. X        case 45:        /* reverse wraparound    */
  775. X            screen->save_modes[13] = term->flags & REVERSEWRAP;
  776. X            break;
  777. X        case 46:        /* logging        */
  778. X            screen->save_modes[14] = screen->logging;
  779. X            break;
  780. X        case 47:        /* alternate buffer        */
  781. X            screen->save_modes[15] = screen->alternate;
  782. X            break;
  783. #ifdef STATUSLINE
  784. X        case 48:        /* reverse statusline        */
  785. X            screen->save_modes[16] = screen->reversestatus;
  786. X            break;
  787. #endif /* STATUSLINE */
  788. X        case 1000:        /* mouse bogus sequence        */
  789. X        case 1001:
  790. X            screen->save_modes[7] = screen->send_mouse_pos;
  791. X            break;
  792. X        }
  793. X    }
  794. }
  795. X
  796. /*
  797. X * process xterm private modes restore
  798. X */
  799. restoremodes(term)
  800. XXtermWidget term;
  801. {
  802. X    register TScreen    *screen    = &term->screen;
  803. X    register int i, j;
  804. X
  805. X    for (i = 0; i < nparam; i++) {
  806. X        switch (param[i]) {
  807. X        case 1:            /* DECCKM            */
  808. X            term->keyboard.flags &= ~CURSOR_APL;
  809. X            term->keyboard.flags |= screen->save_modes[0] &
  810. X             CURSOR_APL;
  811. X            update_appcursor();
  812. X            break;
  813. X        case 3:            /* DECCOLM            */
  814. X            if(screen->c132) {
  815. X                ClearScreen(screen);
  816. X                CursorSet(screen, 0, 0, term->flags);
  817. X                if((j = (screen->save_modes[1] & IN132COLUMNS)
  818. X                 ? 132 : 80) != ((term->flags & IN132COLUMNS)
  819. X                 ? 132 : 80) || j != screen->max_col + 1) {
  820. X                        Dimension replyWidth, replyHeight;
  821. X                    XtGeometryResult status;
  822. X                    status = XtMakeResizeRequest (
  823. X                        (Widget) term,
  824. X                        (Dimension) FontWidth(screen) * j 
  825. X                        + 2*screen->border
  826. X                        + screen->scrollbar,
  827. X                        (Dimension) FontHeight(screen)
  828. X                        * (screen->max_row + 1)
  829. X                        + 2*screen->border,
  830. X                        &replyWidth, &replyHeight);
  831. X
  832. X                    if (status == XtGeometryYes ||
  833. X                        status == XtGeometryDone) {
  834. X                        ScreenResize (&term->screen,
  835. X                              replyWidth,
  836. X                              replyHeight,
  837. X                              &term->flags);
  838. X                    }
  839. X                }
  840. X                term->flags &= ~IN132COLUMNS;
  841. X                term->flags |= screen->save_modes[1] &
  842. X                 IN132COLUMNS;
  843. X            }
  844. X            break;
  845. X        case 4:            /* DECSCLM (slow scroll)    */
  846. X            if (screen->save_modes[2] & SMOOTHSCROLL) {
  847. X                screen->jumpscroll = 0;
  848. X                if (screen->scroll_amt)
  849. X                    FlushScroll(screen);
  850. X            } else
  851. X                screen->jumpscroll = 1;
  852. X            term->flags &= ~SMOOTHSCROLL;
  853. X            term->flags |= screen->save_modes[2] & SMOOTHSCROLL;
  854. X            update_jumpscroll();
  855. X            break;
  856. X        case 5:            /* DECSCNM            */
  857. X            if((screen->save_modes[3] ^ term->flags) &
  858. X             REVERSE_VIDEO) {
  859. X                term->flags &= ~REVERSE_VIDEO;
  860. X                term->flags |= screen->save_modes[3] &
  861. X                 REVERSE_VIDEO;
  862. X                ReverseVideo(term);
  863. X                /* update_reversevideo done in RevVid */
  864. X            }
  865. X            break;
  866. X        case 6:            /* DECOM            */
  867. X            term->flags &= ~ORIGIN;
  868. X            term->flags |= screen->save_modes[4] & ORIGIN;
  869. X            CursorSet(screen, 0, 0, term->flags);
  870. X            break;
  871. X
  872. X        case 7:            /* DECAWM            */
  873. X            term->flags &= ~WRAPAROUND;
  874. X            term->flags |= screen->save_modes[5] & WRAPAROUND;
  875. X            update_autowrap();
  876. X            break;
  877. X        case 8:            /* DECARM            */
  878. X            /* ignore autorepeat */
  879. X            break;
  880. X        case 9:            /* MIT bogus sequence        */
  881. X            screen->send_mouse_pos = screen->save_modes[7];
  882. X            break;
  883. X        case 40:        /* 132 column mode        */
  884. X            screen->c132 = screen->save_modes[8];
  885. X            update_allow132();
  886. X            break;
  887. X        case 41:        /* curses hack            */
  888. X            screen->curses = screen->save_modes[9];
  889. X            update_cursesemul();
  890. X            break;
  891. X        case 44:        /* margin bell            */
  892. X            if(!(screen->marginbell = screen->save_modes[12]))
  893. X                screen->bellarmed = -1;
  894. X            update_visualbell();
  895. X            break;
  896. X        case 45:        /* reverse wraparound    */
  897. X            term->flags &= ~REVERSEWRAP;
  898. X            term->flags |= screen->save_modes[13] & REVERSEWRAP;
  899. X            update_reversewrap();
  900. X            break;
  901. X        case 46:        /* logging        */
  902. #ifdef ALLOWLOGFILEONOFF
  903. X            if(screen->save_modes[14])
  904. X                StartLog(screen);
  905. X            else
  906. X                CloseLog(screen);
  907. #endif /* ALLOWLOGFILEONOFF */
  908. X            /* update_logging done by StartLog and CloseLog */
  909. X            break;
  910. X        case 47:        /* alternate buffer        */
  911. X            if(screen->save_modes[15])
  912. X                ToAlternate(screen);
  913. X            else
  914. X                FromAlternate(screen);
  915. X            /* update_altscreen done by ToAlt and FromAlt */
  916. X            break;
  917. #ifdef STATUSLINE
  918. X        case 48:        /* reverse statusline        */
  919. X            if (screen->save_modes[16] != screen->reversestatus) {
  920. X                screen->reversestatus = screen->save_modes[16];
  921. X                ScrnRefresh(screen, screen->max_row + 1, 0, 1,
  922. X                        screen->max_col + 1);
  923. X            }
  924. X            break;
  925. #endif /* STATUSLINE */
  926. X        case 1000:        /* mouse bogus sequence        */
  927. X        case 1001:
  928. X            screen->send_mouse_pos = screen->save_modes[7];
  929. X            break;
  930. X        }
  931. X    }
  932. }
  933. X
  934. /*
  935. X * set a bit in a word given a pointer to the word and a mask.
  936. X */
  937. bitset(p, mask)
  938. int    *p;
  939. {
  940. X    *p |= mask;
  941. }
  942. X
  943. /*
  944. X * clear a bit in a word given a pointer to the word and a mask.
  945. X */
  946. bitclr(p, mask)
  947. int    *p;
  948. {
  949. X    *p &= ~mask;
  950. }
  951. X
  952. unparseseq(ap, fd)
  953. register ANSI    *ap;
  954. {
  955. X    register int    c;
  956. X    register int    i;
  957. X    register int    inters;
  958. X
  959. X    c = ap->a_type;
  960. X    if (c>=0x80 && c<=0x9F) {
  961. X        unparseputc(ESC, fd);
  962. X        c -= 0x40;
  963. X    }
  964. X    unparseputc(c, fd);
  965. X    c = ap->a_type;
  966. X    if (c==ESC || c==DCS || c==CSI || c==OSC || c==PM || c==APC) {
  967. X        if (ap->a_pintro != 0)
  968. X            unparseputc((char) ap->a_pintro, fd);
  969. X        for (i=0; i<ap->a_nparam; ++i) {
  970. X            if (i != 0)
  971. X                unparseputc(';', fd);
  972. X            unparseputn((unsigned int) ap->a_param[i], fd);
  973. X        }
  974. X        inters = ap->a_inters;
  975. X        for (i=3; i>=0; --i) {
  976. X            c = (inters >> (8*i)) & 0xff;
  977. X            if (c != 0)
  978. X                unparseputc(c, fd);
  979. X        }
  980. X        unparseputc((char) ap->a_final, fd);
  981. X    }
  982. }
  983. X
  984. unparseputn(n, fd)
  985. unsigned int    n;
  986. int fd;
  987. {
  988. X    unsigned int    q;
  989. X
  990. X    q = n/10;
  991. X    if (q != 0)
  992. X        unparseputn(q, fd);
  993. X    unparseputc((char) ('0' + (n%10)), fd);
  994. }
  995. X
  996. unparseputc(c, fd)
  997. char c;
  998. int fd;
  999. {
  1000. X    char    buf[2];
  1001. X    register i = 1;
  1002. X    extern XtermWidget term;
  1003. X
  1004. X    if((buf[0] = c) == '\r' && (term->flags & LINEFEED)) {
  1005. X        buf[1] = '\n';
  1006. X        i++;
  1007. X    }
  1008. X    if (write(fd, buf, i) != i)
  1009. X        Panic("unparseputc: error writing character\n", 0);
  1010. }
  1011. X
  1012. unparsefputs (s, fd)
  1013. X    register char *s;
  1014. X    int fd;
  1015. {
  1016. X    if (s) {
  1017. X    while (*s) unparseputc (*s++, fd);
  1018. X    }
  1019. }
  1020. X
  1021. X
  1022. ToAlternate(screen)
  1023. register TScreen *screen;
  1024. {
  1025. X    extern ScrnBuf Allocate();
  1026. X
  1027. X    if(screen->alternate)
  1028. X        return;
  1029. X    if(!screen->altbuf)
  1030. X        screen->altbuf = Allocate(screen->max_row + 1, screen->max_col
  1031. X         + 1, &screen->abuf_address);
  1032. X    SwitchBufs(screen);
  1033. X    screen->alternate = TRUE;
  1034. X    update_altscreen();
  1035. }
  1036. X
  1037. XFromAlternate(screen)
  1038. register TScreen *screen;
  1039. {
  1040. X    if(!screen->alternate)
  1041. X        return;
  1042. X    screen->alternate = FALSE;
  1043. X    SwitchBufs(screen);
  1044. X    update_altscreen();
  1045. }
  1046. X
  1047. SwitchBufs(screen)
  1048. register TScreen *screen;
  1049. {
  1050. X    register int rows, top;
  1051. #ifdef KTERM
  1052. X    Bchr *save [MAX_ROWS];
  1053. #else /* !KTERM */
  1054. X    char *save [2 * MAX_ROWS];
  1055. #endif /* !KTERM */
  1056. X
  1057. X    if(screen->cursor_state)
  1058. X        HideCursor();
  1059. X    rows = screen->max_row + 1;
  1060. #ifdef KTERM
  1061. X    bcopy((char *)screen->buf, (char *)save, sizeof(Bchr *) * rows);
  1062. X    bcopy((char *)screen->altbuf, (char *)screen->buf, sizeof(Bchr *) *
  1063. X     rows);
  1064. X    bcopy((char *)save, (char *)screen->altbuf, sizeof(Bchr *) * rows);
  1065. #else /* !KTERM */
  1066. X    bcopy((char *)screen->buf, (char *)save, 2 * sizeof(char *) * rows);
  1067. X    bcopy((char *)screen->altbuf, (char *)screen->buf, 2 * sizeof(char *) *
  1068. X     rows);
  1069. X    bcopy((char *)save, (char *)screen->altbuf, 2 * sizeof(char *) * rows);
  1070. #endif /* !KTERM */
  1071. X
  1072. X    if((top = -screen->topline) <= screen->max_row) {
  1073. X        if(screen->scroll_amt)
  1074. X            FlushScroll(screen);
  1075. #ifdef STATUSLINE
  1076. X        if(top == 0 && !screen->statusline)
  1077. #else /* !STATUSLINE */
  1078. X        if(top == 0)
  1079. #endif /* !STATUSLINE */
  1080. X            XClearWindow(screen->display, TextWindow(screen));
  1081. X        else
  1082. X            XClearArea(
  1083. X                screen->display,
  1084. X                TextWindow(screen),
  1085. X                (int) screen->border + screen->scrollbar,
  1086. X                (int) top * FontHeight(screen) + screen->border,
  1087. X                (unsigned) Width(screen),
  1088. X                (unsigned) (screen->max_row - top + 1)
  1089. X                * FontHeight(screen),
  1090. X                FALSE);
  1091. X    }
  1092. #ifndef ENBUG /* kagotani */
  1093. X    TrackText(0, 0, 0, 0);
  1094. #endif
  1095. X    ScrnRefresh(screen, 0, 0, rows, screen->max_col + 1, False);
  1096. }
  1097. X
  1098. VTRun()
  1099. {
  1100. X    register TScreen *screen = &term->screen;
  1101. X    register int i;
  1102. X    
  1103. X    if (!screen->Vshow) {
  1104. X        XtRealizeWidget (term->core.parent);
  1105. X        set_vt_visibility (TRUE);
  1106. X    } 
  1107. X    update_vttekmode();
  1108. X    update_vtshow();
  1109. X    update_tekshow();
  1110. X    set_vthide_sensitivity();
  1111. X
  1112. X    if (screen->allbuf == NULL) VTallocbuf ();
  1113. X
  1114. X    screen->cursor_state = OFF;
  1115. X    screen->cursor_set = ON;
  1116. X
  1117. X    bcnt = 0;
  1118. X    bptr = buffer;
  1119. X    while(Tpushb > Tpushback) {
  1120. X        *bptr++ = *--Tpushb;
  1121. X        bcnt++;
  1122. X    }
  1123. X    bcnt += (i = Tbcnt);
  1124. X    for( ; i > 0 ; i--)
  1125. X        *bptr++ = *Tbptr++;
  1126. X    bptr = buffer;
  1127. X    if(!setjmp(VTend))
  1128. X        VTparse();
  1129. X    HideCursor();
  1130. X    screen->cursor_set = OFF;
  1131. }
  1132. X
  1133. /*ARGSUSED*/
  1134. static void VTExpose(w, event, region)
  1135. Widget w;
  1136. XXEvent *event;
  1137. Region region;
  1138. {
  1139. X    register TScreen *screen = &term->screen;
  1140. X
  1141. #ifdef DEBUG
  1142. X    if(debug)
  1143. X        fputs("Expose\n", stderr);
  1144. #endif    /* DEBUG */
  1145. X    if (event->type == Expose)
  1146. X        HandleExposure (screen, (XExposeEvent *)event);
  1147. }
  1148. X
  1149. static void VTGraphicsOrNoExpose (event)
  1150. XXEvent *event;
  1151. X    {
  1152. X    register TScreen *screen = &term->screen;
  1153. X    if (screen->incopy <= 0) {
  1154. X        screen->incopy = 1;
  1155. X        if (screen->scrolls > 0)
  1156. X            screen->scrolls--;
  1157. X    }
  1158. X    if (event->type == GraphicsExpose)
  1159. X      if (HandleExposure (screen, (XExposeEvent *)event))
  1160. X        screen->cursor_state = OFF;
  1161. X    if ((event->type == NoExpose) || ((XGraphicsExposeEvent *)event)->count == 0) {
  1162. X        if (screen->incopy <= 0 && screen->scrolls > 0)
  1163. X            screen->scrolls--;
  1164. X        if (screen->scrolls)
  1165. X            screen->incopy = -1;
  1166. X        else
  1167. X            screen->incopy = 0;
  1168. X    }
  1169. }
  1170. X
  1171. /*ARGSUSED*/
  1172. static void VTNonMaskableEvent (w, closure, event)
  1173. Widget w;
  1174. caddr_t closure;
  1175. XXEvent *event;
  1176. X    {
  1177. X    switch (event->type) {
  1178. X       case MappingNotify:
  1179. X      XRefreshKeyboardMapping (&event->xmapping);
  1180. X      break;
  1181. X       case GraphicsExpose:
  1182. X       case NoExpose:
  1183. X      VTGraphicsOrNoExpose (event);
  1184. X      break;
  1185. X      }
  1186. X    }
  1187. X
  1188. X
  1189. X
  1190. X
  1191. static void VTResize(w)
  1192. X    Widget w;
  1193. {
  1194. X    if (XtIsRealized(w))
  1195. X      ScreenResize (&term->screen, term->core.width, term->core.height,
  1196. X            &term->flags);
  1197. }
  1198. X
  1199. X
  1200. int VTInit ()
  1201. {
  1202. X    register TScreen *screen = &term->screen;
  1203. X
  1204. X    XtRealizeWidget (term->core.parent);
  1205. X    if (screen->allbuf == NULL) VTallocbuf ();
  1206. X    return (1);
  1207. }
  1208. X
  1209. static void VTallocbuf ()
  1210. {
  1211. X    register TScreen *screen = &term->screen;
  1212. X    int nrows = screen->max_row + 1;
  1213. X    extern ScrnBuf Allocate();
  1214. X
  1215. X    /* allocate screen buffer now, if necessary. */
  1216. X    if (screen->scrollWidget)
  1217. X      nrows += screen->savelines;
  1218. X    screen->allbuf = Allocate (nrows, screen->max_col + 1,
  1219. X     &screen->sbuf_address);
  1220. X    if (screen->scrollWidget)
  1221. #ifdef KTERM
  1222. X      screen->buf = &screen->allbuf[screen->savelines];
  1223. #else /* !KTERM */
  1224. X      screen->buf = &screen->allbuf[2 * screen->savelines];
  1225. #endif /* !KTERM */
  1226. X    else
  1227. X      screen->buf = screen->allbuf;
  1228. X    return;
  1229. }
  1230. X
  1231. static void VTInitialize (request, new)
  1232. X   XtermWidget request, new;
  1233. {
  1234. X   int i;
  1235. #ifdef KTERM
  1236. X   int fnum;
  1237. #endif /* KTERM */
  1238. X   /* Zero out the entire "screen" component of "new" widget,
  1239. X      then do field-by-field assigment of "screen" fields
  1240. X      that are named in the resource list. */
  1241. X
  1242. X   bzero ((char *) &new->screen, sizeof(new->screen));
  1243. X   new->screen.c132 = request->screen.c132;
  1244. X   new->screen.curses = request->screen.curses;
  1245. X   new->screen.foreground = request->screen.foreground;
  1246. X   new->screen.cursorcolor = request->screen.cursorcolor;
  1247. #ifdef  COLOR_TEXT /* mukawa */
  1248. X   new->screen.textcolor[0] = request->screen.textcolor[0];
  1249. X   new->screen.textcolor[1] = request->screen.textcolor[1];
  1250. X   new->screen.textcolor[2] = request->screen.textcolor[2];
  1251. X   new->screen.textcolor[3] = request->screen.textcolor[3];
  1252. X   new->screen.textcolor[4] = request->screen.textcolor[4];
  1253. X   new->screen.textcolor[5] = request->screen.textcolor[5];
  1254. X   new->screen.textcolor[6] = request->screen.textcolor[6];
  1255. X   new->screen.textcolor[7] = request->screen.textcolor[7];
  1256. #endif  /* COLOR_TEXT */
  1257. X   new->screen.border = request->screen.border;
  1258. X   new->screen.jumpscroll = request->screen.jumpscroll;
  1259. X   new->screen.logfile = request->screen.logfile;
  1260. X   new->screen.marginbell = request->screen.marginbell;
  1261. X   new->screen.mousecolor = request->screen.mousecolor;
  1262. X   new->screen.mousecolorback = request->screen.mousecolorback;
  1263. X   new->screen.multiscroll = request->screen.multiscroll;
  1264. X   new->screen.nmarginbell = request->screen.nmarginbell;
  1265. X   new->screen.savelines = request->screen.savelines;
  1266. X   new->screen.scrolllines = request->screen.scrolllines;
  1267. X   new->screen.scrollttyoutput = request->screen.scrollttyoutput;
  1268. X   new->screen.scrollkey = request->screen.scrollkey;
  1269. X   new->screen.visualbell = request->screen.visualbell;
  1270. X   new->screen.TekEmu = request->screen.TekEmu;
  1271. X   new->misc.re_verse = request->misc.re_verse;
  1272. X   new->screen.multiClickTime = request->screen.multiClickTime;
  1273. X   new->screen.charClass = request->screen.charClass;
  1274. X   new->screen.cutNewline = request->screen.cutNewline;
  1275. X   new->screen.cutToBeginningOfLine = request->screen.cutToBeginningOfLine;
  1276. X   new->screen.always_highlight = request->screen.always_highlight;
  1277. X   new->screen.pointer_cursor = request->screen.pointer_cursor;
  1278. X   new->screen.eight_bits = request->screen.eight_bits;
  1279. X   new->screen.allowSendEvents = request->screen.allowSendEvents;
  1280. X   new->misc.titeInhibit = request->misc.titeInhibit;
  1281. #ifdef KTERM
  1282. X  for (fnum = F_ISO8859_1; fnum < FCNT; fnum++) {
  1283. #endif /* KTERM */
  1284. X   for (i = 0; i < NMENUFONTS; i++) {
  1285. X       new->screen.menu_font_names[i] = request->screen.menu_font_names[i];
  1286. X   }
  1287. X   /* set default in realize proc */
  1288. X   new->screen.menu_font_names[fontMenu_fontdefault] = NULL;
  1289. X   new->screen.menu_font_names[fontMenu_fontescape] = NULL;
  1290. X   new->screen.menu_font_names[fontMenu_fontsel] = NULL;
  1291. #ifdef KTERM
  1292. X   new->screen.menu_bfont_names[fontMenu_fontdefault] = NULL;
  1293. X   new->screen.menu_bfont_names[fontMenu_fontescape] = NULL;
  1294. X   new->screen.menu_bfont_names[fontMenu_fontsel] = NULL;
  1295. X  }
  1296. X   for (i = 0; i < NMENUFONTS; i++) {
  1297. X       new->screen.menu_font_list[i] = request->screen.menu_font_list[i];
  1298. X       new->screen.menu_bfont_list[i] = request->screen.menu_bfont_list[i];
  1299. X   }
  1300. X   /* set default in realize proc */
  1301. X   new->screen.menu_font_list[fontMenu_fontdefault] = NULL;
  1302. X   new->screen.menu_font_list[fontMenu_fontescape] = NULL;
  1303. X   new->screen.menu_font_list[fontMenu_fontsel] = NULL;
  1304. X   new->screen.menu_bfont_list[fontMenu_fontdefault] = NULL;
  1305. X   new->screen.menu_bfont_list[fontMenu_fontescape] = NULL;
  1306. X   new->screen.menu_bfont_list[fontMenu_fontsel] = NULL;
  1307. #endif /* KTERM */
  1308. X   new->screen.menu_font_number = fontMenu_fontdefault;
  1309. #ifdef STATUSLINE
  1310. X   new->screen.statusline = request->screen.statusline;
  1311. X   new->screen.reversestatus = request->screen.reversestatus;
  1312. #endif /* STATUSLINE */
  1313. #ifdef KTERM
  1314. X   new->screen.linespace = request->screen.linespace;
  1315. #endif /* KTERM */
  1316. X
  1317. X    /*
  1318. X     * The definition of -rv now is that it changes the definition of 
  1319. X     * XtDefaultForeground and XtDefaultBackground.  So, we no longer
  1320. X     * need to do anything special.
  1321. X     */
  1322. X   new->keyboard.flags = 0;
  1323. X   new->screen.display = new->core.screen->display;
  1324. X   new->core.height = new->core.width = 1;
  1325. X      /* dummy values so that we don't try to Realize the parent shell 
  1326. X     with height or width of 0, which is illegal in X.  The real
  1327. X     size is computed in the xtermWidget's Realize proc,
  1328. X     but the shell's Realize proc is called first, and must see
  1329. X     a valid size. */
  1330. X
  1331. X   /* look for focus related events on the shell, because we need
  1332. X    * to care about the shell's border being part of our focus.
  1333. X    */
  1334. X   XtAddEventHandler(XtParent(new), EnterWindowMask, FALSE,
  1335. X        HandleEnterWindow, (Opaque)NULL);
  1336. X   XtAddEventHandler(XtParent(new), LeaveWindowMask, FALSE,
  1337. X        HandleLeaveWindow, (Opaque)NULL);
  1338. X   XtAddEventHandler(XtParent(new), FocusChangeMask, FALSE,
  1339. X        HandleFocusChange, (Opaque)NULL);
  1340. X   XtAddEventHandler(new, 0L, TRUE,
  1341. X        VTNonMaskableEvent, (Opaque)NULL);
  1342. X
  1343. X   set_character_class (new->screen.charClass);
  1344. X
  1345. X   /* create it, but don't realize it */
  1346. X   ScrollBarOn (new, TRUE, FALSE);
  1347. X   return;
  1348. }
  1349. X
  1350. X
  1351. static void VTDestroy (w)
  1352. Widget w;
  1353. {
  1354. X    XtFree(((XtermWidget)w)->screen.selection);
  1355. }
  1356. X
  1357. /*ARGSUSED*/
  1358. static void VTRealize (w, valuemask, values)
  1359. Widget w;
  1360. XXtValueMask *valuemask;
  1361. XXSetWindowAttributes *values;
  1362. {
  1363. X    unsigned int width, height;
  1364. X    register TScreen *screen = &term->screen;
  1365. X    int xpos, ypos, pr;
  1366. X    extern char *malloc();
  1367. X    XSizeHints        sizehints;
  1368. X    extern int        VTgcFontMask;
  1369. X    int scrollbar_width;
  1370. #ifdef KTERM
  1371. X    int fnum = F_ISO8859_1;
  1372. #endif /* KTERM */
  1373. X
  1374. X    TabReset (term->tabs);
  1375. X
  1376. #ifdef KTERM
  1377. X    screen->menu_font_list[fontMenu_fontdefault] = term->misc.fontlist;
  1378. X    screen->menu_bfont_list[fontMenu_fontdefault] = term->misc.bfontlist;
  1379. X    for (fnum = F_ISO8859_1; fnum < FCNT; fnum ++) {
  1380. X        screen->menu_font_names[fontMenu_fontdefault] = term->misc.f_n;
  1381. X        screen->menu_bfont_names[fontMenu_fontdefault] = term->misc.f_b;
  1382. X        screen->fnt_norm = screen->fnt_bold = NULL;
  1383. X    }
  1384. X    fnum = F_ISO8859_1;
  1385. X    if (!LoadNewFont(screen, NULL, NULL, False, 0)) {
  1386. X        if (term->misc.f_n == NULL
  1387. X         || XmuCompareISOLatin1(term->misc.f_n, "fixed") != 0) {
  1388. #else /* !KTERM */
  1389. X    screen->menu_font_names[fontMenu_fontdefault] = term->misc.f_n;
  1390. X    screen->fnt_norm = screen->fnt_bold = NULL;
  1391. X    if (!LoadNewFont(screen, term->misc.f_n, term->misc.f_b, False, 0)) {
  1392. X        if (XmuCompareISOLatin1(term->misc.f_n, "fixed") != 0) {
  1393. #endif /* !KTERM */
  1394. X        fprintf (stderr, 
  1395. X             "%s:  unable to open font \"%s\", trying \"fixed\"....\n",
  1396. X             xterm_name, term->misc.f_n);
  1397. #ifdef KTERM
  1398. X        screen->menu_font_names[fontMenu_fontdefault] = "fixed";
  1399. X        (void) LoadNewFont (screen, NULL, NULL, False, 0);
  1400. #else /* !KTERM */
  1401. X        (void) LoadNewFont (screen, "fixed", NULL, False, 0);
  1402. X        screen->menu_font_names[fontMenu_fontdefault] = "fixed";
  1403. #endif /* !KTERM */
  1404. X        }
  1405. X    }
  1406. X
  1407. X    /* really screwed if we couldn't open default font */
  1408. X    if (!screen->fnt_norm) {
  1409. X        fprintf (stderr, "%s:  unable to locate a suitable font\n",
  1410. X             xterm_name);
  1411. X        Exit (1);
  1412. X    }
  1413. X
  1414. X    /* making cursor */
  1415. X    if (!screen->pointer_cursor) 
  1416. X      screen->pointer_cursor = make_colored_cursor(XC_xterm, 
  1417. X                               screen->mousecolor,
  1418. X                               screen->mousecolorback);
  1419. X    else 
  1420. X      recolor_cursor (screen->pointer_cursor, 
  1421. X              screen->mousecolor, screen->mousecolorback);
  1422. X
  1423. X    scrollbar_width = (term->misc.scrollbar ?
  1424. X               screen->scrollWidget->core.width : 0);
  1425. X
  1426. X
  1427. X    /* set defaults */
  1428. X    xpos = 1; ypos = 1; width = 80; height = 24;
  1429. X    pr = XParseGeometry (term->misc.geo_metry, &xpos, &ypos,
  1430. X                 &width, &height);
  1431. X    screen->max_col = (width - 1);    /* units in character cells */
  1432. X    screen->max_row = (height - 1);    /* units in character cells */
  1433. X    update_font_info (&term->screen, False);
  1434. X
  1435. X    width = screen->fullVwin.fullwidth;
  1436. X    height = screen->fullVwin.fullheight;
  1437. X
  1438. X    if ((pr & XValue) && (XNegative&pr)) 
  1439. X      xpos += DisplayWidth(screen->display, DefaultScreen(screen->display))
  1440. X            - width - (term->core.parent->core.border_width * 2);
  1441. X    if ((pr & YValue) && (YNegative&pr))
  1442. X      ypos += DisplayHeight(screen->display,DefaultScreen(screen->display))
  1443. X            - height - (term->core.parent->core.border_width * 2);
  1444. X
  1445. X    /* set up size hints for window manager; min 1 char by 1 char */
  1446. X    sizehints.base_width = 2 * screen->border + scrollbar_width;
  1447. X    sizehints.base_height = 2 * screen->border;
  1448. X    sizehints.width_inc = FontWidth(screen);
  1449. X    sizehints.height_inc = FontHeight(screen);
  1450. X    sizehints.min_width = sizehints.base_width + sizehints.width_inc;
  1451. X    sizehints.min_height = sizehints.base_height + sizehints.height_inc;
  1452. X    sizehints.flags = (PBaseSize|PMinSize|PResizeInc);
  1453. X    sizehints.x = xpos;
  1454. X    sizehints.y = ypos;
  1455. X    if ((XValue&pr) || (YValue&pr)) {
  1456. X        sizehints.flags |= USSize|USPosition;
  1457. X        sizehints.flags |= PWinGravity;
  1458. X        switch (pr & (XNegative | YNegative)) {
  1459. X          case 0:
  1460. X        sizehints.win_gravity = NorthWestGravity;
  1461. X        break;
  1462. X          case XNegative:
  1463. X        sizehints.win_gravity = NorthEastGravity;
  1464. X        break;
  1465. X          case YNegative:
  1466. X        sizehints.win_gravity = SouthWestGravity;
  1467. X        break;
  1468. X          default:
  1469. X        sizehints.win_gravity = SouthEastGravity;
  1470. X        break;
  1471. X        }
  1472. X    } else {
  1473. X        /* set a default size, but do *not* set position */
  1474. X        sizehints.flags |= PSize;
  1475. X    }
  1476. X    sizehints.width = width;
  1477. X    sizehints.height = height;
  1478. X    if ((WidthValue&pr) || (HeightValue&pr)) 
  1479. X      sizehints.flags |= USSize;
  1480. X    else sizehints.flags |= PSize;
  1481. #ifdef STATUSLINE
  1482. X    sizehints.base_height += screen->statusheight;
  1483. X    sizehints.min_height += screen->statusheight;
  1484. #endif /* STATUSLINE */
  1485. X
  1486. X    (void) XtMakeResizeRequest((Widget) term,
  1487. X                   (Dimension)width, (Dimension)height,
  1488. X                   &term->core.width, &term->core.height);
  1489. X
  1490. X    /* XXX This is bogus.  We are parsing geometries too late.  This
  1491. X     * is information that the shell widget ought to have before we get
  1492. X     * realized, so that it can do the right thing.
  1493. X     */
  1494. X        if (sizehints.flags & USPosition)
  1495. X        XMoveWindow (XtDisplay(term), term->core.parent->core.window,
  1496. X             sizehints.x, sizehints.y);
  1497. X
  1498. X    XSetWMNormalHints (XtDisplay(term), term->core.parent->core.window,
  1499. X               &sizehints);
  1500. X
  1501. #ifdef STATUSLINE
  1502. X    values->bit_gravity = ForgetGravity;
  1503. #else /* !STATUSLINE */
  1504. X    values->bit_gravity = NorthWestGravity;
  1505. #endif /* !STATUSLINE */
  1506. X    term->screen.fullVwin.window = term->core.window =
  1507. X      XCreateWindow(XtDisplay(term), XtWindow(term->core.parent),
  1508. X        term->core.x, term->core.y,
  1509. X        term->core.width, term->core.height, term->core.border_width,
  1510. X        (int) term->core.depth,
  1511. X        InputOutput, CopyFromParent,    
  1512. X        *valuemask|CWBitGravity, values);
  1513. X
  1514. #ifdef KTERM
  1515. X    set_cursor_gcs (screen, F_ISO8859_1);
  1516. #else /* !KTERM */
  1517. X    set_cursor_gcs (screen);
  1518. #endif /* !KTERM */
  1519. X
  1520. X    /* Reset variables used by ANSI emulation. */
  1521. X
  1522. #ifdef KTERM
  1523. X    screen->gsets[0] = GSET_ASCII;
  1524. # ifdef KTERM_KANJI
  1525. X        switch(term->misc.lang[0]) {
  1526. #  ifdef KTERM_HANZI
  1527. X          case 'c': case 'C':
  1528. X            screen->gsets[1] = GSET_HANZI;
  1529. X            screen->gsets[2] = GSET_ASCII;
  1530. X            break;
  1531. #  endif /* KTERM_HANZI */
  1532. #  ifdef KTERM_HANGUL
  1533. X          case 'k': case 'K':
  1534. X            screen->gsets[1] = GSET_HANGUL;
  1535. X            screen->gsets[2] = GSET_ASCII;
  1536. X            break;
  1537. #  endif /* KTERM_HANGUL */
  1538. X          default:
  1539. X            screen->gsets[1] = (term->flags & EUC_KANJI) ? GSET_KANJI : GSET_KANA;
  1540. X            screen->gsets[2] = (term->flags & EUC_KANJI) ? GSET_KANA : GSET_ASCII;
  1541. X            break;
  1542. X        }
  1543. # else /* !KTERM_KANJI */
  1544. X    screen->gsets[1] = GSET_KANA;
  1545. X    screen->gsets[2] = GSET_ASCII;
  1546. # endif /* !KTERM_KANJI */
  1547. X    screen->gsets[3] = GSET_ASCII;
  1548. #else /* !KTERM */
  1549. X    screen->gsets[0] = 'B';            /* ASCII_G        */
  1550. X    screen->gsets[1] = 'B';
  1551. X    screen->gsets[2] = 'B';            /* DEC supplemental.    */
  1552. X    screen->gsets[3] = 'B';
  1553. #endif /* !KTERM */
  1554. X    screen->curgl = 0;            /* G0 => GL.        */
  1555. #ifdef KTERM
  1556. X    screen->curgr = 1;            /* G1 => GR.        */
  1557. #else /* !KTERM */
  1558. X    screen->curgr = 2;            /* G2 => GR.        */
  1559. #endif /* !KTERM */
  1560. X    screen->curss = 0;            /* No single shift.    */
  1561. X
  1562. X    XDefineCursor(screen->display, VShellWindow, screen->pointer_cursor);
  1563. X
  1564. X        screen->cur_col = screen->cur_row = 0;
  1565. #ifdef KTERM
  1566. X    screen->max_col = Width(screen)/FontWidth(screen) - 1;
  1567. X    screen->top_marg = 0;
  1568. X    screen->bot_marg = screen->max_row = Height(screen) /
  1569. X                FontHeight(screen) - 1;
  1570. #else /* !KTERM */
  1571. X    screen->max_col = Width(screen)/screen->fullVwin.f_width - 1;
  1572. X    screen->top_marg = 0;
  1573. X    screen->bot_marg = screen->max_row = Height(screen) /
  1574. X                screen->fullVwin.f_height - 1;
  1575. #endif /* !KTERM */
  1576. X
  1577. X    screen->sc.row = screen->sc.col = screen->sc.flags = NULL;
  1578. X
  1579. X    /* Mark screen buffer as unallocated.  We wait until the run loop so
  1580. X       that the child process does not fork and exec with all the dynamic
  1581. X       memory it will never use.  If we were to do it here, the
  1582. X       swap space for new process would be huge for huge savelines. */
  1583. X    if (!tekWidget)            /* if not called after fork */
  1584. X      screen->buf = screen->allbuf = NULL;
  1585. X
  1586. X    screen->do_wrap = NULL;
  1587. X    screen->scrolls = screen->incopy = 0;
  1588. X    set_vt_box (screen);
  1589. #ifdef STATUSLINE
  1590. X    status_box[0].x = screen->border - 1;
  1591. #endif /* STATUSLINE */
  1592. X
  1593. X    screen->savedlines = 0;
  1594. X
  1595. X    if (term->misc.scrollbar) {
  1596. X        screen->scrollbar = 0;
  1597. X        ScrollBarOn (term, FALSE, TRUE);
  1598. X    }
  1599. X    CursorSave (term, &screen->sc);
  1600. X    return;
  1601. }
  1602. X
  1603. /*
  1604. X * Shows cursor at new cursor position in screen.
  1605. X */
  1606. ShowCursor()
  1607. {
  1608. X    register TScreen *screen = &term->screen;
  1609. X    register int x, y, flags;
  1610. #ifdef KTERM
  1611. X    XChar2b c;
  1612. X    Char gset;
  1613. #else /* !KTERM */
  1614. X    Char c;
  1615. X    GC    currentGC;
  1616. #endif /* !KTERM */
  1617. X    Boolean    in_selection;
  1618. X
  1619. X    if (eventMode != NORMAL) return;
  1620. X
  1621. #ifdef STATUSLINE
  1622. X    if (!screen->instatus &&
  1623. X        screen->cur_row - screen->topline > screen->max_row)
  1624. #else /* !STATUSLINE */
  1625. X    if (screen->cur_row - screen->topline > screen->max_row)
  1626. #endif /* !STATUSLINE */
  1627. X        return;
  1628. #ifdef KTERM
  1629. X    gset = screen->buf[y = screen->cursor_row = screen->cur_row]
  1630. X                [x = screen->cursor_col = screen->cur_col].gset;
  1631. X    if (gset == MBC2) {
  1632. X        gset = screen->buf[y][x-1].gset;
  1633. X        x --;
  1634. X    }
  1635. X    if (gset & MBCS) {
  1636. X        c.byte1 = screen->buf[y][x].code;
  1637. X        c.byte2 = screen->buf[y][x+1].code;
  1638. X    } else {
  1639. X        c.byte1 = 0;
  1640. X        c.byte2 = screen->buf[y][x].code;
  1641. X        if (c.byte2 == 0) {
  1642. X            c.byte2 = ' ';
  1643. X            gset = GSET_ASCII;
  1644. X        }
  1645. X    }
  1646. X    flags = screen->buf[y][x].attr;
  1647. #else /* !KTERM */
  1648. X    c = screen->buf[y = 2 * (screen->cursor_row = screen->cur_row)]
  1649. X     [x = screen->cursor_col = screen->cur_col];
  1650. X    flags = screen->buf[y + 1][x];
  1651. X    if (c == 0)
  1652. X        c = ' ';
  1653. #endif /* !KTERM */
  1654. X
  1655. X    if (screen->cur_row > screen->endHRow ||
  1656. X        (screen->cur_row == screen->endHRow &&
  1657. X         screen->cur_col >= screen->endHCol) ||
  1658. X        screen->cur_row < screen->startHRow ||
  1659. X        (screen->cur_row == screen->startHRow &&
  1660. X         screen->cur_col < screen->startHCol))
  1661. X        in_selection = False;
  1662. X    else
  1663. X        in_selection = True;
  1664. X
  1665. #ifdef STATUSLINE
  1666. X    if (screen->instatus && screen->reversestatus)
  1667. X        flags ^= INVERSE;
  1668. #endif /* STATUSLINE */
  1669. X
  1670. #ifdef KTERM
  1671. X    x = CursorX(screen, x);
  1672. X    y = CursorY(screen, y);
  1673. #ifdef  COLOR_TEXT /* mukawa */
  1674. X    ScreenDraw(screen, x, y, &c, 1, gset, flags,
  1675. #else    /* COLOR_TEXT */
  1676. X    ScreenDraw(screen, x, y, &c, 1, gset,
  1677. #endif  /* COLOR_TEXT */
  1678. X        flags & BOLD,
  1679. X        (screen->select || screen->always_highlight)
  1680. X        ^ ((flags & INVERSE) != 0) ^ (in_selection != 0),
  1681. X        flags & UNDERLINE,
  1682. X        True);
  1683. #else /* !KTERM */
  1684. X    if(screen->select || screen->always_highlight) {
  1685. X        if (( (flags & INVERSE) && !in_selection) ||
  1686. X            (!(flags & INVERSE) &&  in_selection)){
  1687. X            /* text is reverse video */
  1688. X            if (screen->cursorGC) {
  1689. X            currentGC = screen->cursorGC;
  1690. X            } else {
  1691. X            if (flags & BOLD) {
  1692. X                currentGC = screen->normalboldGC;
  1693. X            } else {
  1694. X                currentGC = screen->normalGC;
  1695. X            }
  1696. X            }
  1697. X        } else { /* normal video */
  1698. X            if (screen->reversecursorGC) {
  1699. X            currentGC = screen->reversecursorGC;
  1700. X            } else {
  1701. X            if (flags & BOLD) {
  1702. X                currentGC = screen->reverseboldGC;
  1703. X            } else {
  1704. X                currentGC = screen->reverseGC;
  1705. X            }
  1706. X            }
  1707. X        }
  1708. X    } else { /* not selected */
  1709. X        if (( (flags & INVERSE) && !in_selection) ||
  1710. X            (!(flags & INVERSE) &&  in_selection)) {
  1711. X            /* text is reverse video */
  1712. X            currentGC = screen->reverseGC;
  1713. X        } else { /* normal video */
  1714. X            currentGC = screen->normalGC;
  1715. X        }
  1716. X        
  1717. X    }
  1718. X
  1719. X    x = CursorX (screen, screen->cur_col);
  1720. X    y = CursorY(screen, screen->cur_row) + 
  1721. X      screen->fnt_norm->ascent;
  1722. X    XDrawImageString(screen->display, TextWindow(screen), currentGC,
  1723. X        x, y, (char *) &c, 1);
  1724. X
  1725. X    if((flags & BOLD) && screen->enbolden) /* no bold font */
  1726. X        XDrawString(screen->display, TextWindow(screen), currentGC,
  1727. X            x + 1, y, (char *) &c, 1);
  1728. X    if(flags & UNDERLINE) 
  1729. X        XDrawLine(screen->display, TextWindow(screen), currentGC,
  1730. X            x, y+1, x + FontWidth(screen), y+1);
  1731. X    if (!screen->select && !screen->always_highlight) {
  1732. X        screen->box->x = x;
  1733. X        screen->box->y = y - screen->fnt_norm->ascent;
  1734. X        XDrawLines (screen->display, TextWindow(screen), 
  1735. X                screen->cursoroutlineGC ? screen->cursoroutlineGC 
  1736. X                                : currentGC,
  1737. X                screen->box, NBOX, CoordModePrevious);
  1738. X    }
  1739. #endif /* !KTERM */
  1740. X    screen->cursor_state = ON;
  1741. }
  1742. X
  1743. /*
  1744. X * hide cursor at previous cursor position in screen.
  1745. X */
  1746. HideCursor()
  1747. {
  1748. X    register TScreen *screen = &term->screen;
  1749. #ifdef KTERM
  1750. X    register int x, y, flags;
  1751. X    XChar2b c;
  1752. X    Char gset;
  1753. #else /* !KTERM */
  1754. X    GC    currentGC;
  1755. X    register int x, y, flags;
  1756. X    char c;
  1757. #endif /* !KTERM */
  1758. X    Boolean    in_selection;
  1759. X
  1760. #ifdef STATUSLINE
  1761. X    Boolean instatus;
  1762. X
  1763. X    if(!(instatus = screen->cursor_row > screen->max_row) &&
  1764. X       screen->cursor_row - screen->topline > screen->max_row)
  1765. #else /* !STATUSLINE */
  1766. X    if(screen->cursor_row - screen->topline > screen->max_row)
  1767. #endif /* !STATUSLINE */
  1768. X        return;
  1769. #ifdef KTERM
  1770. X    gset = screen->buf[y = screen->cursor_row][x = screen->cursor_col].gset;
  1771. X    if (gset == MBC2) {
  1772. X        gset = screen->buf[y][x-1].gset;
  1773. X        x --;
  1774. X    }
  1775. X    if (gset & MBCS) {
  1776. X        c.byte1 = screen->buf[y][x].code;
  1777. X        c.byte2 = screen->buf[y][x+1].code;
  1778. X    } else {
  1779. X        c.byte1 = 0;
  1780. X        c.byte2 = screen->buf[y][x].code;
  1781. X        if (c.byte2 == 0) {
  1782. X            c.byte2 = ' ';
  1783. X            gset = GSET_ASCII;
  1784. X        }
  1785. X    }
  1786. X    flags = screen->buf[y][x].attr;
  1787. #else /* !KTERM */
  1788. X    c = screen->buf[y = 2 * screen->cursor_row][x = screen->cursor_col];
  1789. X    flags = screen->buf[y + 1][x];
  1790. #endif /* !KTERM */
  1791. X
  1792. X    if (screen->cursor_row > screen->endHRow ||
  1793. X        (screen->cursor_row == screen->endHRow &&
  1794. X         screen->cursor_col >= screen->endHCol) ||
  1795. X        screen->cursor_row < screen->startHRow ||
  1796. X        (screen->cursor_row == screen->startHRow &&
  1797. X         screen->cursor_col < screen->startHCol))
  1798. X        in_selection = False;
  1799. X    else
  1800. X        in_selection = True;
  1801. X
  1802. #ifdef STATUSLINE
  1803. X    if (screen->instatus && screen->reversestatus)
  1804. X        flags ^= INVERSE;
  1805. #endif /* STATUSLINE */
  1806. X
  1807. #ifdef KTERM
  1808. X    x = CursorX(screen, x);
  1809. #else /* !KTERM */
  1810. X    if (( (flags & INVERSE) && !in_selection) ||
  1811. X        (!(flags & INVERSE) &&  in_selection)) {
  1812. X        if(flags & BOLD) {
  1813. X            currentGC = screen->reverseboldGC;
  1814. X        } else {
  1815. X            currentGC = screen->reverseGC;
  1816. X        }
  1817. X    } else {
  1818. X        if(flags & BOLD) {
  1819. X            currentGC = screen->normalboldGC;
  1820. X        } else {
  1821. X            currentGC = screen->normalGC;
  1822. X        }
  1823. X    }
  1824. X
  1825. X    if (c == 0)
  1826. X        c = ' ';
  1827. X    x = CursorX (screen, screen->cursor_col);
  1828. #endif /* !KTERM */
  1829. #ifdef STATUSLINE
  1830. X    y = (instatus ? (screen->cursor_row * FontHeight(screen) + 1) :
  1831. X         ((screen->cursor_row - screen->topline) * FontHeight(screen))) +
  1832. #else /* !STATUSLINE */
  1833. X    y = (((screen->cursor_row - screen->topline) * FontHeight(screen))) +
  1834. #endif /* !STATUSLINE */
  1835. X     screen->border;
  1836. #ifdef KTERM
  1837. #ifdef  COLOR_TEXT /* mukawa */
  1838. X    ScreenDraw(screen, x, y, &c, 1, gset, flags,
  1839. #else    /* COLOR_TEXT */
  1840. X    ScreenDraw(screen, x, y, &c, 1, gset,
  1841. #endif  /* COLOR_TEXT */
  1842. X        flags & BOLD,
  1843. X        ((flags & INVERSE) != 0) ^ (in_selection != 0),
  1844. X        flags & UNDERLINE,
  1845. X        False);
  1846. #else /* !KTERM */
  1847. X    y = y+screen->fnt_norm->ascent;
  1848. X    XDrawImageString(screen->display, TextWindow(screen), currentGC,
  1849. X        x, y, &c, 1);
  1850. X    if((flags & BOLD) && screen->enbolden)
  1851. X        XDrawString(screen->display, TextWindow(screen), currentGC,
  1852. X            x + 1, y, &c, 1);
  1853. X    if(flags & UNDERLINE) 
  1854. X        XDrawLine(screen->display, TextWindow(screen), currentGC,
  1855. X            x, y+1, x + FontWidth(screen), y+1);
  1856. #endif /* !KTERM */
  1857. X    screen->cursor_state = OFF;
  1858. }
  1859. X
  1860. VTReset(full)
  1861. int full;
  1862. {
  1863. X    register TScreen *screen = &term->screen;
  1864. X
  1865. X    /* reset scrolling region */
  1866. X    screen->top_marg = 0;
  1867. X    screen->bot_marg = screen->max_row;
  1868. X    term->flags &= ~ORIGIN;
  1869. X    if(full) {
  1870. X        TabReset (term->tabs);
  1871. X        term->keyboard.flags = NULL;
  1872. #ifdef KTERM
  1873. X        screen->gsets[0] = GSET_ASCII;
  1874. # ifdef KTERM_KANJI
  1875. X                switch(term->misc.lang[0]) {
  1876. #  ifdef KTERM_HANZI
  1877. X                  case 'c': case 'C':
  1878. X                    screen->gsets[1] = GSET_HANZI;
  1879. X                    screen->gsets[2] = GSET_ASCII;
  1880. X                    break;
  1881. #  endif /* KTERM_HANZI */
  1882. #  ifdef KTERM_HANGUL
  1883. X                  case 'k': case 'K':
  1884. X                    screen->gsets[1] = GSET_HANGUL;
  1885. X                    screen->gsets[2] = GSET_ASCII;
  1886. X                    break;
  1887. #  endif /* KTERM_HANGUL */
  1888. X                  default:
  1889. X                    screen->gsets[1] = (term->flags & EUC_KANJI)
  1890. X                      ? GSET_KANJI : GSET_KANA;
  1891. X                    screen->gsets[2] = (term->flags & EUC_KANJI)
  1892. X                      ? GSET_KANA : GSET_ASCII;
  1893. X                    break;
  1894. X                }
  1895. # else /* !KTERM_KANJI */
  1896. SHAR_EOF
  1897. true || echo 'restore of kterm-4.1.2/charproc.c failed'
  1898. fi
  1899. echo 'End of kterm-4.1.2 part 8'
  1900. echo 'File kterm-4.1.2/charproc.c is continued in part 9'
  1901. echo 9 > _shar_seq_.tmp
  1902. exit 0
  1903.  
  1904.  
  1905. -----------------------------------------------------------------------------
  1906. mleisher@nmsu.edu                      "I laughed.
  1907. Mark Leisher                                I cried.
  1908. Computing Research Lab                          I fell down.
  1909. New Mexico State University                        It changed my life."
  1910. Las Cruces, NM                     - Rich [Cowboy Feng's Space Bar and Grille]
  1911.  
  1912. --
  1913. Dan Heller
  1914. O'Reilly && Associates       Z-Code Software    Comp-sources-x:
  1915. Senior Writer                President          comp-sources.x@uunet.uu.net
  1916. argv@ora.com                 argv@zipcode.com
  1917.