home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / x / volume12 / kterm / part15 < prev    next >
Text File  |  1991-05-11  |  52KB  |  1,799 lines
  1. Path: uunet!cs.utexas.edu!sun-barr!newstop!jethro!exodus!NMSU.Edu!mleisher
  2. From: mleisher@NMSU.Edu
  3. Newsgroups: comp.sources.x
  4. Subject: v12i096: kterm  - kanji xterm, Part15/18
  5. Message-ID: <13148@exodus.Eng.Sun.COM>
  6. Date: 11 May 91 00:51:44 GMT
  7. References: <csx-12i082:kterm@uunet.UU.NET>
  8. Sender: news@exodus.Eng.Sun.COM
  9. Lines: 1787
  10. Approved: argv@sun.com
  11.  
  12. Submitted-by: mleisher@NMSU.Edu
  13. Posting-number: Volume 12, Issue 96
  14. Archive-name: kterm/part15
  15.  
  16. #!/bin/sh
  17. # this is kt412.15 (part 15 of kterm-4.1.2)
  18. # do not concatenate these parts, unpack them in order with /bin/sh
  19. # file kterm-4.1.2/menu.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" != 15; 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/menu.c'
  35. else
  36. echo 'x - continuing file kterm-4.1.2/menu.c'
  37. sed 's/^X//' << 'SHAR_EOF' >> 'kterm-4.1.2/menu.c' &&
  38. X    String *params;
  39. X    Cardinal *param_count;
  40. {
  41. X    do_quit(w, NULL, NULL);
  42. }
  43. X
  44. void HandleScrollbar(w, event, params, param_count)
  45. X    Widget w;
  46. X    XEvent *event;
  47. X    String *params;
  48. X    Cardinal *param_count;
  49. {
  50. X    handle_toggle (do_scrollbar, (int) term->screen.scrollbar,
  51. X           params, *param_count, w, NULL, NULL);
  52. }
  53. X
  54. void HandleJumpscroll(w, event, params, param_count)
  55. X    Widget w;
  56. X    XEvent *event;
  57. X    String *params;
  58. X    Cardinal *param_count;
  59. {
  60. X    handle_toggle (do_jumpscroll, (int) term->screen.jumpscroll,
  61. X           params, *param_count, w, NULL, NULL);
  62. }
  63. X
  64. void HandleReverseVideo(w, event, params, param_count)
  65. X    Widget w;
  66. X    XEvent *event;
  67. X    String *params;
  68. X    Cardinal *param_count;
  69. {
  70. X    handle_toggle (do_reversevideo, (int) (term->flags & REVERSE_VIDEO),
  71. X           params, *param_count, w, NULL, NULL);
  72. }
  73. X
  74. void HandleAutoWrap(w, event, params, param_count)
  75. X    Widget w;
  76. X    XEvent *event;
  77. X    String *params;
  78. X    Cardinal *param_count;
  79. {
  80. X    handle_toggle (do_autowrap, (int) (term->flags & WRAPAROUND),
  81. X           params, *param_count, w, NULL, NULL);
  82. }
  83. X
  84. void HandleReverseWrap(w, event, params, param_count)
  85. X    Widget w;
  86. X    XEvent *event;
  87. X    String *params;
  88. X    Cardinal *param_count;
  89. {
  90. X    handle_toggle (do_reversewrap, (int) (term->flags & REVERSEWRAP),
  91. X           params, *param_count, w, NULL, NULL);
  92. }
  93. X
  94. void HandleAutoLineFeed(w, event, params, param_count)
  95. X    Widget w;
  96. X    XEvent *event;
  97. X    String *params;
  98. X    Cardinal *param_count;
  99. {
  100. X    handle_toggle (do_autolinefeed, (int) (term->flags & LINEFEED),
  101. X           params, *param_count, w, NULL, NULL);
  102. }
  103. X
  104. void HandleAppCursor(w, event, params, param_count)
  105. X    Widget w;
  106. X    XEvent *event;
  107. X    String *params;
  108. X    Cardinal *param_count;
  109. {
  110. X    handle_toggle (do_appcursor, (int) (term->keyboard.flags & CURSOR_APL),
  111. X           params, *param_count, w, NULL, NULL);
  112. }
  113. X
  114. void HandleAppKeypad(w, event, params, param_count)
  115. X    Widget w;
  116. X    XEvent *event;
  117. X    String *params;
  118. X    Cardinal *param_count;
  119. {
  120. X    handle_toggle (do_appkeypad, (int) (term->keyboard.flags & KYPD_APL),
  121. X           params, *param_count, w, NULL, NULL);
  122. }
  123. X
  124. void HandleScrollKey(w, event, params, param_count)
  125. X    Widget w;
  126. X    XEvent *event;
  127. X    String *params;
  128. X    Cardinal *param_count;
  129. {
  130. X    handle_toggle (do_scrollkey, (int) term->screen.scrollkey,
  131. X           params, *param_count, w, NULL, NULL);
  132. }
  133. X
  134. void HandleScrollTtyOutput(w, event, params, param_count)
  135. X    Widget w;
  136. X    XEvent *event;
  137. X    String *params;
  138. X    Cardinal *param_count;
  139. {
  140. X    handle_toggle (do_scrollttyoutput, (int) term->screen.scrollttyoutput,
  141. X           params, *param_count, w, NULL, NULL);
  142. }
  143. X
  144. void HandleAllow132(w, event, params, param_count)
  145. X    Widget w;
  146. X    XEvent *event;
  147. X    String *params;
  148. X    Cardinal *param_count;
  149. {
  150. X    handle_toggle (do_allow132, (int) term->screen.c132,
  151. X           params, *param_count, w, NULL, NULL);
  152. }
  153. X
  154. void HandleCursesEmul(w, event, params, param_count)
  155. X    Widget w;
  156. X    XEvent *event;
  157. X    String *params;
  158. X    Cardinal *param_count;
  159. {
  160. X    handle_toggle (do_cursesemul, (int) term->screen.curses,
  161. X           params, *param_count, w, NULL, NULL);
  162. }
  163. X
  164. void HandleMarginBell(w, event, params, param_count)
  165. X    Widget w;
  166. X    XEvent *event;
  167. X    String *params;
  168. X    Cardinal *param_count;
  169. {
  170. X    handle_toggle (do_marginbell, (int) term->screen.marginbell,
  171. X           params, *param_count, w, NULL, NULL);
  172. }
  173. X
  174. void HandleAltScreen(w, event, params, param_count)
  175. X    Widget w;
  176. X    XEvent *event;
  177. X    String *params;
  178. X    Cardinal *param_count;
  179. {
  180. X    /* eventually want to see if sensitive or not */
  181. X    handle_toggle (do_altscreen, (int) term->screen.alternate,
  182. X           params, *param_count, w, NULL, NULL);
  183. }
  184. X
  185. void HandleSoftReset(w, event, params, param_count)
  186. X    Widget w;
  187. X    XEvent *event;
  188. X    String *params;
  189. X    Cardinal *param_count;
  190. {
  191. X    do_softreset(w, NULL, NULL);
  192. }
  193. X
  194. void HandleHardReset(w, event, params, param_count)
  195. X    Widget w;
  196. X    XEvent *event;
  197. X    String *params;
  198. X    Cardinal *param_count;
  199. {
  200. X    do_hardreset(w, NULL, NULL);
  201. }
  202. X
  203. void HandleSetTerminalType(w, event, params, param_count)
  204. X    Widget w;
  205. X    XEvent *event;
  206. X    String *params;
  207. X    Cardinal *param_count;
  208. {
  209. X    if (*param_count == 1) {
  210. X    switch (params[0][0]) {
  211. X      case 'v': case 'V':
  212. X        if (term->screen.TekEmu) do_vtmode (w, NULL, NULL);
  213. X        break;
  214. X      case 't': case 'T':
  215. X        if (!term->screen.TekEmu) do_tekmode (w, NULL, NULL);
  216. X        break;
  217. X      default:
  218. X        Bell();
  219. X    }
  220. X    } else {
  221. X    Bell();
  222. X    }
  223. }
  224. X
  225. void HandleVisibility(w, event, params, param_count)
  226. X    Widget w;
  227. X    XEvent *event;
  228. X    String *params;
  229. X    Cardinal *param_count;
  230. {
  231. X    if (*param_count == 2) {
  232. X    switch (params[0][0]) {
  233. X      case 'v': case 'V':
  234. X        handle_toggle (do_vtonoff, (int) term->screen.Vshow,
  235. X               params+1, (*param_count) - 1, w, NULL, NULL);
  236. X        break;
  237. X      case 't': case 'T':
  238. X        handle_toggle (do_tekonoff, (int) term->screen.Tshow,
  239. X               params+1, (*param_count) - 1, w, NULL, NULL);
  240. X        break;
  241. X      default:
  242. X        Bell();
  243. X    }
  244. X    } else {
  245. X    Bell();
  246. X    }
  247. }
  248. X
  249. void HandleSetTekText(w, event, params, param_count)
  250. X    Widget w;
  251. X    XEvent *event;
  252. X    String *params;
  253. X    Cardinal *param_count;
  254. {
  255. X    void (*proc)() = NULL;
  256. X
  257. X    switch (*param_count) {
  258. X      case 0:
  259. X    proc = do_tektextlarge;
  260. X    break;
  261. X      case 1:
  262. X    switch (params[0][0]) {
  263. X      case 'l': case 'L': proc = do_tektextlarge; break;
  264. X      case '2': proc = do_tektext2; break;
  265. X      case '3': proc = do_tektext3; break;
  266. X      case 's': case 'S': proc = do_tektextsmall; break;
  267. X    }
  268. X    break;
  269. X    }
  270. X    if (proc) (*proc) (w, NULL, NULL);
  271. X    else Bell();
  272. }
  273. X
  274. void HandleTekPage(w, event, params, param_count)
  275. X    Widget w;
  276. X    XEvent *event;
  277. X    String *params;
  278. X    Cardinal *param_count;
  279. {
  280. X    do_tekpage(w, NULL, NULL);
  281. }
  282. X
  283. void HandleTekReset(w, event, params, param_count)
  284. X    Widget w;
  285. X    XEvent *event;
  286. X    String *params;
  287. X    Cardinal *param_count;
  288. {
  289. X    do_tekreset(w, NULL, NULL);
  290. }
  291. X
  292. void HandleTekCopy(w, event, params, param_count)
  293. X    Widget w;
  294. X    XEvent *event;
  295. X    String *params;
  296. X    Cardinal *param_count;
  297. {
  298. X    do_tekcopy(w, NULL, NULL);
  299. }
  300. X
  301. X
  302. #ifdef STATUSLINE
  303. void HandleStatusLine(w, event, params, param_count)
  304. X    Widget w;
  305. X    XEvent *event;
  306. X    String *params;
  307. X    Cardinal *param_count;
  308. {
  309. X    /* eventually want to see if sensitive or not */
  310. X    handle_toggle (do_statusline, (int) term->screen.statusline,
  311. X           params, *param_count, w, NULL, NULL);
  312. }
  313. X
  314. void HandleStatusReverse(w, event, params, param_count)
  315. X    Widget w;
  316. X    XEvent *event;
  317. X    String *params;
  318. X    Cardinal *param_count;
  319. {
  320. X    /* eventually want to see if sensitive or not */
  321. X    handle_toggle (do_reversestatus, (int) term->screen.reversestatus,
  322. X           params, *param_count, w, NULL, NULL);
  323. }
  324. #endif /* STATUSLINE */
  325. #ifdef KTERM_KANJI
  326. void HandleSetKanjiMode(w, event, params, param_count)
  327. X    Widget w;
  328. X    XEvent *event;
  329. X    String *params;
  330. X    Cardinal *param_count;
  331. {
  332. X    char lang = term->misc.lang[0];
  333. X
  334. X    if (!lang)
  335. X      lang = 'j';
  336. X
  337. X    /* eventually want to see if sensitive or not */
  338. X    handle_toggle (do_reversestatus, (int) term->screen.reversestatus,
  339. X           params, *param_count, w, NULL, NULL);
  340. X    if (*param_count == 1) {
  341. #if defined(KTERM_HANZI) || defined(KTERM_HANGUL)
  342. X    switch (params[0][0]) {
  343. X      case 'j': case 'J':
  344. X        do_jismode (w, NULL, NULL);
  345. X        break;
  346. X      case 'e': case 'E': case 'x': case 'X': case 'u': case 'U':
  347. X        term->flags &= ~EUC_KANJI;
  348. X        do_eucmode (w, NULL, NULL);
  349. X        break;
  350. X      case 'g': case 'G':
  351. X        term->flags &= ~GUOBIAO_HANZI;
  352. X        do_gbmode (w, NULL, NULL);
  353. X        break;
  354. X      case 's': case 'S': case 'm': case 'M':
  355. X            switch(lang) {
  356. X              case 'c': case 'C':
  357. X                term->flags &= ~SGB_HANZI;
  358. X                do_sgbmode (w, NULL, NULL);
  359. X                break;
  360. X              default:
  361. X                term->flags &= ~SJIS_KANJI;
  362. X                do_sjismode (w, NULL, NULL);
  363. X                break;
  364. X            }
  365. X        break;
  366. X      case 'b': case 'B':
  367. X        term->flags &= ~BIG5_HANZI;
  368. X        do_big5mode (w, NULL, NULL);
  369. X        break;
  370. X          case 'k': case 'K':
  371. X            term->flags &= ~KS_HANGUL;
  372. X            do_ksmode(w, NULL, NULL);
  373. X            break;
  374. X          case 'n': case 'N':
  375. X            term->flags &= ~NBYTE_HANGUL;
  376. X            do_nbmode(w, NULL, NULL);
  377. X            break;
  378. #else /* !KTERM_HANZI || !KTERM_HANGUL */
  379. X    switch (params[0][0]) {
  380. X      case 'j': case 'J':
  381. X        do_jismode (w, NULL, NULL);
  382. X        break;
  383. X      case 'e': case 'E': case 'x': case 'X': case 'u': case 'U':
  384. X        term->flags &= ~EUC_KANJI;
  385. X        do_eucmode (w, NULL, NULL);
  386. X        break;
  387. X      case 's': case 'S': case 'm': case 'M':
  388. X        term->flags &= ~SJIS_KANJI;
  389. X        do_sjismode (w, NULL, NULL);
  390. X        break;
  391. #endif /* KTERM_HANZI || KTERM_HANGUL */
  392. X      default:
  393. X        Bell();
  394. X    }
  395. X    } else {
  396. X    Bell();
  397. X    }
  398. }
  399. #endif /* KTERM_KANJI */
  400. SHAR_EOF
  401. echo 'File kterm-4.1.2/menu.c is complete' &&
  402. chmod 0664 kterm-4.1.2/menu.c ||
  403. echo 'restore of kterm-4.1.2/menu.c failed'
  404. Wc_c="`wc -c < 'kterm-4.1.2/menu.c'`"
  405. test 36692 -eq "$Wc_c" ||
  406.     echo 'kterm-4.1.2/menu.c: original size 36692, current size' "$Wc_c"
  407. rm -f _shar_wnt_.tmp
  408. fi
  409. # ============= kterm-4.1.2/menu.h ==============
  410. if test -f 'kterm-4.1.2/menu.h' -a X"$1" != X"-c"; then
  411.     echo 'x - skipping kterm-4.1.2/menu.h (File already exists)'
  412.     rm -f _shar_wnt_.tmp
  413. else
  414. > _shar_wnt_.tmp
  415. echo 'x - extracting kterm-4.1.2/menu.h (Text)'
  416. sed 's/^X//' << 'SHAR_EOF' > 'kterm-4.1.2/menu.h' &&
  417. /* Copyright 1989 Massachusetts Institute of Technology */
  418. /*
  419. X *    $Kagotani: /usr/src.yoshi/X/KTerm/4.1.0/RCS/menu.h,v 1.1 90/06/27 09:39:23 kagotani Rel $
  420. X *
  421. X * $Header: /usr/local/src/X11/contrib/clients/kterm-4.1.2/RCS/menu.h,v 1.4 1991/01/30 00:10:54 mleisher Exp $
  422. X */
  423. X
  424. /*
  425. X * Modified for Hanzi support:
  426. X * Mark Leisher mleisher@nmsu.edu Fri Nov  9 09:22:33 1990
  427. X */
  428. X
  429. typedef struct _MenuEntry {
  430. X    char *name;
  431. X    void (*function)();
  432. X    Widget widget;
  433. } MenuEntry;
  434. X
  435. extern MenuEntry mainMenuEntries[], vtMenuEntries[], tekMenuEntries[];
  436. extern MenuEntry fontMenuEntries[];
  437. extern Arg menuArgs[];
  438. X
  439. extern void HandleAllowSends(), HandleVisualBell(),
  440. X  HandleLogging(), HandleRedraw(), HandleSendSignal(), 
  441. X  HandleQuit(), HandleScrollbar(), HandleJumpscroll(), HandleReverseVideo(),
  442. X  HandleAutoWrap(), HandleReverseWrap(), HandleAutoLineFeed(), 
  443. X  HandleAppCursor(), HandleAppKeypad(), HandleScrollKey(), 
  444. X  HandleScrollTtyOutput(), HandleAllow132(), HandleCursesEmul(), 
  445. X  HandleMarginBell(), HandleAltScreen(), HandleSoftReset(), 
  446. X  HandleHardReset(), HandleSetTerminalType(), HandleVisibility(), 
  447. X  HandleSetTekText(), HandleTekPage(), HandleTekReset(), HandleTekCopy();
  448. #ifdef STATUSLINE
  449. extern void HandleStatusLine(), HandleStatusReverse();
  450. #endif /* STATUSLINE */
  451. #ifdef KTERM_KANJI
  452. extern void HandleSetKanjiMode();
  453. #endif /* KTERM_KANJI */
  454. X
  455. X
  456. X
  457. /*
  458. X * The following definitions MUST match the order of entries given in 
  459. X * the mainMenuEntries, vtMenuEntries, and tekMenuEntries arrays in menu.c.
  460. X */
  461. X
  462. /*
  463. X * items in primary menu
  464. X */
  465. #define mainMenu_securekbd 0
  466. #define mainMenu_allowsends 1
  467. #define mainMenu_logging 2
  468. #define mainMenu_redraw 3
  469. #define mainMenu_line1 4
  470. #define mainMenu_suspend 5
  471. #define mainMenu_continue 6
  472. #define mainMenu_interrupt 7
  473. #define mainMenu_hangup 8
  474. #define mainMenu_terminate 9
  475. #define mainMenu_kill 10
  476. #define mainMenu_line2 11
  477. #define mainMenu_quit 12
  478. X
  479. X
  480. /*
  481. X * items in vt100 mode menu
  482. X */
  483. #define vtMenu_scrollbar 0
  484. #define vtMenu_jumpscroll 1
  485. #define vtMenu_reversevideo 2
  486. #define vtMenu_autowrap 3
  487. #define vtMenu_reversewrap 4
  488. #define vtMenu_autolinefeed 5
  489. #define vtMenu_appcursor 6
  490. #define vtMenu_appkeypad 7
  491. #define vtMenu_scrollkey 8
  492. #define vtMenu_scrollttyoutput 9
  493. #define vtMenu_allow132 10
  494. #define vtMenu_cursesemul 11
  495. #define vtMenu_visualbell 12
  496. #define vtMenu_marginbell 13
  497. #define vtMenu_altscreen 14
  498. #define vtMenu_line1 15
  499. #define vtMenu_softreset 16
  500. #define vtMenu_hardreset 17
  501. #define vtMenu_line2 18
  502. #define vtMenu_tekshow 19
  503. #define vtMenu_tekmode 20
  504. #define vtMenu_vthide 21
  505. #if defined(STATUSLINE) || defined(KTERM_KANJI)
  506. # define vtMenu_line3 22
  507. #endif /* STATUSLINE || KTERM_KANJI */
  508. #ifdef STATUSLINE
  509. #  define vtMenu_statusline (vtMenu_line3+1)
  510. #  define vtMenu_reversestatus (vtMenu_statusline+1)
  511. #endif /* STATUSLINE */
  512. #ifdef KTERM_KANJI
  513. #  ifdef STATUSLINE
  514. #   define vtMenu_eucmode (vtMenu_reversestatus+1)
  515. #   define vtMenu_sjismode (vtMenu_eucmode+1)
  516. #  else
  517. #   define vtMenu_eucmode (vtMenu_line3+1)
  518. #   define vtMenu_sjismode (vtMenu_eucmode+1)
  519. #  endif
  520. #define vtMenu_jmodestart vtMenu_eucmode
  521. #define vtMenu_jmodeend   vtMenu_sjismode
  522. #endif /* KTERM_KANJI */
  523. X
  524. #ifdef KTERM_HANZI
  525. #define vtMenu_hzmodestart (vtMenu_sjismode+1)
  526. #define vtMenu_sgbmode     vtMenu_hzmodestart
  527. #define vtMenu_big5mode    (vtMenu_sgbmode+1)
  528. #define vtMenu_hzmodeend   vtMenu_big5mode
  529. #endif /* KTERM_HANZI */
  530. X
  531. #ifdef KTERM_HANGUL
  532. # ifdef KTERM_HANZI
  533. #define vtMenu_hgmodestart (vtMenu_big5mode+1)
  534. #define vtMenu_ksmode      vtMenu_hgmodestart
  535. # else /* !KTERM_HANZI */
  536. #define vtMenu_hgmodestart (vtMenu_sjismode+1)
  537. #define vtMenu_ksmode      vtMenu_hgmodestart
  538. # endif /* KTERM_HANZI */
  539. #define vtMenu_nbmode      (vtMenu_ksmode+1)
  540. #define vtMenu_hgmodeend   vtMenu_nbmode
  541. #endif /* KTERM_HANGUL */
  542. X
  543. /*
  544. X * items in vt100 font menu
  545. X */
  546. #define fontMenu_fontdefault 0
  547. #define fontMenu_font1 1
  548. #define fontMenu_font2 2
  549. #define fontMenu_font3 3
  550. #define fontMenu_font4 4
  551. #define fontMenu_fontescape 5
  552. #define fontMenu_fontsel 6
  553. /* number of non-line items should match NMENUFONTS in ptyx.h */
  554. X
  555. X
  556. /*
  557. X * items in tek4014 mode menu
  558. X */
  559. #define tekMenu_tektextlarge 0
  560. #define tekMenu_tektext2 1
  561. #define tekMenu_tektext3 2
  562. #define tekMenu_tektextsmall 3
  563. #define tekMenu_line1 4
  564. #define tekMenu_tekpage 5
  565. #define tekMenu_tekreset 6
  566. #define tekMenu_tekcopy 7
  567. #define tekMenu_line2 8
  568. #define tekMenu_vtshow 9
  569. #define tekMenu_vtmode 10
  570. #define tekMenu_tekhide 11
  571. X
  572. X
  573. /*
  574. X * macros for updating menus
  575. X */
  576. X
  577. #define update_menu_item(w,mi,val) { if (mi) { \
  578. X    menuArgs[0].value = (XtArgVal) ((val) ? term->screen.menu_item_bitmap \
  579. X                          : None); \
  580. X    XtSetValues (mi, menuArgs, (Cardinal) 1); }}
  581. X
  582. X
  583. #define set_sensitivity(w,mi,val) { if (mi) { \
  584. X    menuArgs[1].value = (XtArgVal) (val); \
  585. X    XtSetValues (mi, menuArgs+1, (Cardinal) 1);  }}
  586. X
  587. X
  588. X
  589. /*
  590. X * there should be one of each of the following for each checkable item
  591. X */
  592. X
  593. X
  594. #define update_securekbd() \
  595. X  update_menu_item (term->screen.mainMenu, \
  596. X            mainMenuEntries[mainMenu_securekbd].widget, \
  597. X            term->screen.grabbedKbd)
  598. X
  599. #define update_allowsends() \
  600. X  update_menu_item (term->screen.mainMenu, \
  601. X            mainMenuEntries[mainMenu_allowsends].widget, \
  602. X            term->screen.allowSendEvents)
  603. X
  604. #define update_logging() \
  605. X  update_menu_item (term->screen.mainMenu, \
  606. X            mainMenuEntries[mainMenu_logging].widget, \
  607. X            term->screen.logging)
  608. X
  609. #define update_scrollbar() \
  610. X  update_menu_item (term->screen.vtMenu, \
  611. X            vtMenuEntries[vtMenu_scrollbar].widget, \
  612. X            term->screen.scrollbar)
  613. X
  614. #define update_jumpscroll() \
  615. X  update_menu_item (term->screen.vtMenu, \
  616. X            vtMenuEntries[vtMenu_jumpscroll].widget, \
  617. X            term->screen.jumpscroll)
  618. X
  619. #define update_reversevideo() \
  620. X  update_menu_item (term->screen.vtMenu, \
  621. X            vtMenuEntries[vtMenu_reversevideo].widget, \
  622. X            (term->flags & REVERSE_VIDEO))
  623. X
  624. #define update_autowrap() \
  625. X  update_menu_item (term->screen.vtMenu, \
  626. X            vtMenuEntries[vtMenu_autowrap].widget, \
  627. X            (term->flags & WRAPAROUND))
  628. X
  629. #define update_reversewrap() \
  630. X  update_menu_item (term->screen.vtMenu, \
  631. X            vtMenuEntries[vtMenu_reversewrap].widget, \
  632. X            (term->flags & REVERSEWRAP))
  633. X
  634. #define update_autolinefeed() \
  635. X  update_menu_item (term->screen.vtMenu, \
  636. X            vtMenuEntries[vtMenu_autolinefeed].widget, \
  637. X            (term->flags & LINEFEED))
  638. X
  639. #define update_appcursor() \
  640. X  update_menu_item (term->screen.vtMenu, \
  641. X            vtMenuEntries[vtMenu_appcursor].widget, \
  642. X            (term->keyboard.flags & CURSOR_APL))
  643. X
  644. #define update_appkeypad() \
  645. X  update_menu_item (term->screen.vtMenu, \
  646. X            vtMenuEntries[vtMenu_appkeypad].widget, \
  647. X            (term->keyboard.flags & KYPD_APL))
  648. X
  649. #define update_scrollkey() \
  650. X  update_menu_item (term->screen.vtMenu, \
  651. X            vtMenuEntries[vtMenu_scrollkey].widget,  \
  652. X            term->screen.scrollkey)
  653. X
  654. #define update_scrollttyoutput() \
  655. X  update_menu_item (term->screen.vtMenu, \
  656. X            vtMenuEntries[vtMenu_scrollttyoutput].widget, \
  657. X            term->screen.scrollttyoutput)
  658. X
  659. #define update_allow132() \
  660. X  update_menu_item (term->screen.vtMenu, \
  661. X            vtMenuEntries[vtMenu_allow132].widget, \
  662. X            term->screen.c132)
  663. X  
  664. #define update_cursesemul() \
  665. X  update_menu_item (term->screen.vtMenu, \
  666. X            vtMenuEntries[vtMenu_cursesemul].widget, \
  667. X            term->screen.curses)
  668. X
  669. #define update_visualbell() \
  670. X  update_menu_item (term->screen.vtMenu, \
  671. X            vtMenuEntries[vtMenu_visualbell].widget, \
  672. X            term->screen.visualbell)
  673. X
  674. #define update_marginbell() \
  675. X  update_menu_item (term->screen.vtMenu, \
  676. X            vtMenuEntries[vtMenu_marginbell].widget, \
  677. X            term->screen.marginbell)
  678. X
  679. #define update_altscreen() \
  680. X  update_menu_item (term->screen.vtMenu, \
  681. X            vtMenuEntries[vtMenu_altscreen].widget, \
  682. X            term->screen.alternate)
  683. X
  684. #define update_tekshow() \
  685. X  update_menu_item (term->screen.vtMenu, \
  686. X            vtMenuEntries[vtMenu_tekshow].widget, \
  687. X            term->screen.Tshow)
  688. X
  689. #define update_vttekmode() { \
  690. X    update_menu_item (term->screen.vtMenu, \
  691. X              vtMenuEntries[vtMenu_tekmode].widget, \
  692. X              term->screen.TekEmu) \
  693. X    update_menu_item (term->screen.tekMenu, \
  694. X              tekMenuEntries[tekMenu_vtmode].widget, \
  695. X              !term->screen.TekEmu) }
  696. X
  697. #define update_vtshow() \
  698. X  update_menu_item (term->screen.tekMenu, \
  699. X            tekMenuEntries[tekMenu_vtshow].widget, \
  700. X            term->screen.Vshow)
  701. #ifdef STATUSLINE
  702. #define update_statusline() \
  703. X  update_menu_item (term->screen.vtMenu, \
  704. X            vtMenuEntries[vtMenu_statusline].widget, \
  705. X            term->screen.statusline)
  706. #define update_reversestatus() \
  707. X  update_menu_item (term->screen.vtMenu, \
  708. X            vtMenuEntries[vtMenu_reversestatus].widget, \
  709. X            term->screen.reversestatus)
  710. #endif /* STATUSLINE */
  711. #ifdef KTERM_KANJI
  712. #define update_eucmode() \
  713. X  update_menu_item (term->screen.vtMenu, \
  714. X            vtMenuEntries[vtMenu_eucmode].widget, \
  715. X            term->flags & EUC_KANJI)
  716. X
  717. #define update_sjismode() \
  718. X  update_menu_item (term->screen.vtMenu, \
  719. X            vtMenuEntries[vtMenu_sjismode].widget, \
  720. X            term->flags & SJIS_KANJI)
  721. X
  722. #endif /* KTERM_KANJI */
  723. #ifdef KTERM_HANZI
  724. #define update_sgbmode() \
  725. X  update_menu_item (term->screen.vtMenu, \
  726. X                    vtMenuEntries[vtMenu_sgbmode].widget, \
  727. X                    term->flags & SGB_HANZI)
  728. X
  729. #define update_big5mode() \
  730. X  update_menu_item (term->screen.vtMenu, \
  731. X                    vtMenuEntries[vtMenu_big5mode].widget, \
  732. X                    term->flags & BIG5_HANZI)
  733. #endif /* KTERM_HANZI */
  734. #ifdef KTERM_HANGUL
  735. #define update_ksmode() \
  736. X  update_menu_item (term->screen.vtMenu, \
  737. X                    vtMenuEntries[vtMenu_ksmode].widget, \
  738. X                    term->flags & KS_HANGUL)
  739. X
  740. #define update_nbmode() \
  741. X  update_menu_item (term->screen.vtMenu, \
  742. X                    vtMenuEntries[vtMenu_nbmode].widget, \
  743. X                    term->flags & NBYTE_HANGUL)
  744. #endif /* KTERM_HANGUL */
  745. X
  746. X
  747. #define set_vthide_sensitivity() \
  748. X  set_sensitivity (term->screen.vtMenu, \
  749. X           vtMenuEntries[vtMenu_vthide].widget, \
  750. X           term->screen.Tshow)
  751. X
  752. #define set_tekhide_sensitivity() \
  753. X  set_sensitivity (term->screen.tekMenu, \
  754. X           tekMenuEntries[tekMenu_tekhide].widget, \
  755. X           term->screen.Vshow)
  756. X
  757. #define set_altscreen_sensitivity(val) \
  758. X  set_sensitivity (term->screen.vtMenu,\
  759. X           vtMenuEntries[vtMenu_altscreen].widget, (val))
  760. #ifdef STATUSLINE
  761. #define set_reversestatus_sensitivity() \
  762. X  set_sensitivity (term->screen.vtMenu, \
  763. X           vtMenuEntries[vtMenu_reversestatus].widget, \
  764. X           term->screen.statusline)
  765. #endif /* STATUSLINE */
  766. X
  767. X
  768. /*
  769. X * macros for mapping font size to tekMenu placement
  770. X */
  771. #define FS2MI(n) (n)            /* font_size_to_menu_item */
  772. #define MI2FS(n) (n)            /* menu_item_to_font_size */
  773. X
  774. #define set_tekfont_menu_item(n,val) \
  775. X  update_menu_item (term->screen.tekMenu, \
  776. X            tekMenuEntries[FS2MI(n)].widget, \
  777. X            (val))
  778. X
  779. #define set_menu_font(val) \
  780. X  update_menu_item (term->screen.fontMenu, \
  781. X            fontMenuEntries[term->screen.menu_font_number].widget, \
  782. X            (val))
  783. SHAR_EOF
  784. chmod 0664 kterm-4.1.2/menu.h ||
  785. echo 'restore of kterm-4.1.2/menu.h failed'
  786. Wc_c="`wc -c < 'kterm-4.1.2/menu.h'`"
  787. test 10856 -eq "$Wc_c" ||
  788.     echo 'kterm-4.1.2/menu.h: original size 10856, current size' "$Wc_c"
  789. rm -f _shar_wnt_.tmp
  790. fi
  791. # ============= kterm-4.1.2/misc.c ==============
  792. if test -f 'kterm-4.1.2/misc.c' -a X"$1" != X"-c"; then
  793.     echo 'x - skipping kterm-4.1.2/misc.c (File already exists)'
  794.     rm -f _shar_wnt_.tmp
  795. else
  796. > _shar_wnt_.tmp
  797. echo 'x - extracting kterm-4.1.2/misc.c (Text)'
  798. sed 's/^X//' << 'SHAR_EOF' > 'kterm-4.1.2/misc.c' &&
  799. /*
  800. X *    $XConsortium: misc.c,v 1.65 90/03/12 10:30:17 jim Exp $
  801. X */
  802. X
  803. X
  804. #include <X11/copyright.h>
  805. X
  806. /*
  807. X * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
  808. X *
  809. X *                         All Rights Reserved
  810. X *
  811. X * Permission to use, copy, modify, and distribute this software and its
  812. X * documentation for any purpose and without fee is hereby granted,
  813. X * provided that the above copyright notice appear in all copies and that
  814. X * both that copyright notice and this permission notice appear in
  815. X * supporting documentation, and that the name of Digital Equipment
  816. X * Corporation not be used in advertising or publicity pertaining to
  817. X * distribution of the software without specific, written prior permission.
  818. X *
  819. X *
  820. X * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  821. X * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  822. X * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  823. X * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  824. X * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  825. X * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  826. X * SOFTWARE.
  827. X */
  828. X
  829. #include "ptyx.h"        /* X headers included here. */
  830. X
  831. #include <stdio.h>
  832. #include <X11/Xos.h>
  833. #include <setjmp.h>
  834. #include <ctype.h>
  835. #include <pwd.h>
  836. X
  837. #include <X11/Xatom.h>
  838. #include <X11/cursorfont.h>
  839. X
  840. #include <X11/Shell.h>
  841. #include <X11/Xmu/Error.h>
  842. #include <X11/Xmu/SysUtil.h>
  843. #include <X11/Xmu/WinUtil.h>
  844. X
  845. #include "data.h"
  846. #include "error.h"
  847. #include "menu.h"
  848. X
  849. extern char *malloc();
  850. extern char *mktemp();
  851. extern void exit();
  852. extern void perror();
  853. extern void abort();
  854. X
  855. static void DoSpecialEnterNotify();
  856. static void DoSpecialLeaveNotify();
  857. X
  858. #ifndef lint
  859. static char rcs_id[] = "$XConsortium: misc.c,v 1.65 90/03/12 10:30:17 jim Exp $";
  860. #endif    /* lint */
  861. X
  862. xevents()
  863. {
  864. X    XEvent event;
  865. X    register TScreen *screen = &term->screen;
  866. X
  867. X    if(screen->scroll_amt)
  868. X        FlushScroll(screen);
  869. X    XPending (screen->display);
  870. X    do {
  871. X        if (waitingForTrackInfo)
  872. X            return;
  873. X        XNextEvent (screen->display, &event);
  874. X        /*
  875. X         * Hack to get around problems with the toolkit throwing away
  876. X         * eventing during the exclusive grab of the menu popup.  By
  877. X         * looking at the event ourselves we make sure that we can
  878. X         * do the right thing.
  879. X         */
  880. X        if (event.type == EnterNotify &&
  881. X            (event.xcrossing.window == XtWindow(XtParent(term))) ||
  882. X            (tekWidget &&
  883. X             event.xcrossing.window == XtWindow(XtParent(tekWidget))))
  884. X          DoSpecialEnterNotify (&event);
  885. X        else 
  886. X        if (event.type == LeaveNotify &&
  887. X            (event.xcrossing.window == XtWindow(XtParent(term))) ||
  888. X            (tekWidget &&
  889. X             event.xcrossing.window == XtWindow(XtParent(tekWidget))))
  890. X          DoSpecialLeaveNotify (&event);
  891. X
  892. X        if (!event.xany.send_event ||
  893. X            screen->allowSendEvents ||
  894. X            ((event.xany.type != KeyPress) &&
  895. X             (event.xany.type != KeyRelease) &&
  896. X             (event.xany.type != ButtonPress) &&
  897. X             (event.xany.type != ButtonRelease)))
  898. X            XtDispatchEvent(&event);
  899. X    } while (QLength(screen->display) > 0);
  900. }
  901. X
  902. X
  903. Cursor make_colored_cursor (cursorindex, fg, bg)
  904. X    int cursorindex;            /* index into font */
  905. X    unsigned long fg, bg;            /* pixel value */
  906. {
  907. X    register TScreen *screen = &term->screen;
  908. X    Cursor c;
  909. X    register Display *dpy = screen->display;
  910. X    
  911. X    c = XCreateFontCursor (dpy, cursorindex);
  912. X    if (c == (Cursor) 0) return (c);
  913. X
  914. X    recolor_cursor (c, fg, bg);
  915. X    return (c);
  916. }
  917. X
  918. /* ARGSUSED */
  919. void HandleKeyPressed(w, event, params, nparams)
  920. X    Widget w;
  921. X    XEvent *event;
  922. X    String *params;
  923. X    Cardinal *nparams;
  924. {
  925. X    register TScreen *screen = &term->screen;
  926. X
  927. #ifdef ACTIVEWINDOWINPUTONLY
  928. X    if (w == (screen->TekEmu ? (Widget)tekWidget : (Widget)term))
  929. #endif
  930. X    Input (&term->keyboard, screen, event, False);
  931. }
  932. /* ARGSUSED */
  933. void HandleEightBitKeyPressed(w, event, params, nparams)
  934. X    Widget w;
  935. X    XEvent *event;
  936. X    String *params;
  937. X    Cardinal *nparams;
  938. {
  939. X    register TScreen *screen = &term->screen;
  940. X
  941. #ifdef ACTIVEWINDOWINPUTONLY
  942. X    if (w == (screen->TekEmu ? (Widget)tekWidget : (Widget)term))
  943. #endif
  944. X    Input (&term->keyboard, screen, event, True);
  945. }
  946. X
  947. /* ARGSUSED */
  948. void HandleStringEvent(w, event, params, nparams)
  949. X    Widget w;
  950. X    XEvent *event;
  951. X    String *params;
  952. X    Cardinal *nparams;
  953. {
  954. X    register TScreen *screen = &term->screen;
  955. X
  956. #ifdef ACTIVEWINDOWINPUTONLY
  957. X    if (w != (screen->TekEmu ? (Widget)tekWidget : (Widget)term)) return;
  958. #endif
  959. X
  960. X    if (*nparams != 1) return;
  961. X
  962. X    if ((*params)[0] == '0' && (*params)[1] == 'x' && (*params)[2] != '\0') {
  963. X    char c, *p, hexval[2];
  964. X    hexval[0] = hexval[1] = 0;
  965. X    for (p = *params+2; (c = *p); p++) {
  966. X        hexval[0] *= 16;
  967. X        if (isupper(c)) c = tolower(c);
  968. X        if (c >= '0' && c <= '9')
  969. X        hexval[0] += c - '0';
  970. X        else if (c >= 'a' && c <= 'f')
  971. X        hexval[0] += c - 'a' + 10;
  972. X        else break;
  973. X    }
  974. X    if (c == '\0')
  975. X        StringInput (screen, hexval);
  976. X    }
  977. X    else {
  978. X    StringInput (screen, *params);
  979. X    }
  980. }
  981. X
  982. static void DoSpecialEnterNotify (ev)
  983. X    register XEnterWindowEvent *ev;
  984. {
  985. X    register TScreen *screen = &term->screen;
  986. X
  987. #ifdef ACTIVEWINDOWINPUTONLY
  988. X    if (ev->window == XtWindow(XtParent(screen->TekEmu ?
  989. X                    (Widget)tekWidget : (Widget)term)))
  990. #endif
  991. X      if (((ev->detail) != NotifyInferior) &&
  992. X      ev->focus &&
  993. X      !(screen->select & FOCUS))
  994. X    selectwindow(screen, INWINDOW);
  995. }
  996. X
  997. /*ARGSUSED*/
  998. void HandleEnterWindow(w, eventdata, event)
  999. Widget w;
  1000. register XEnterWindowEvent *event;
  1001. caddr_t eventdata;
  1002. {
  1003. X    /* NOP since we handled it above */
  1004. }
  1005. X
  1006. X
  1007. static void DoSpecialLeaveNotify (ev)
  1008. X    register XEnterWindowEvent *ev;
  1009. {
  1010. X    register TScreen *screen = &term->screen;
  1011. X
  1012. #ifdef ACTIVEWINDOWINPUTONLY
  1013. X    if (ev->window == XtWindow(XtParent(screen->TekEmu ?
  1014. X                    (Widget)tekWidget : (Widget)term)))
  1015. #endif
  1016. X      if (((ev->detail) != NotifyInferior) &&
  1017. X      ev->focus &&
  1018. X      !(screen->select & FOCUS))
  1019. X    unselectwindow(screen, INWINDOW);
  1020. }
  1021. X
  1022. X
  1023. /*ARGSUSED*/
  1024. void HandleLeaveWindow(w, eventdata, event)
  1025. Widget w;
  1026. register XEnterWindowEvent *event;
  1027. caddr_t eventdata;
  1028. {
  1029. X    /* NOP since we handled it above */
  1030. }
  1031. X
  1032. X
  1033. /*ARGSUSED*/
  1034. void HandleFocusChange(w, eventdata, event)
  1035. Widget w;
  1036. register XFocusChangeEvent *event;
  1037. caddr_t eventdata;
  1038. {
  1039. X        register TScreen *screen = &term->screen;
  1040. X
  1041. X        if(event->type == FocusIn)
  1042. X                selectwindow(screen,
  1043. X                 (event->detail == NotifyPointer) ? INWINDOW :
  1044. X                                FOCUS);
  1045. X        else {
  1046. X                unselectwindow(screen,
  1047. X                   (event->detail == NotifyPointer) ? INWINDOW :
  1048. X                                  FOCUS);
  1049. X        if (screen->grabbedKbd && (event->mode == NotifyUngrab)) {
  1050. X            screen->grabbedKbd = FALSE;
  1051. X            ReverseVideo(term);
  1052. X            XBell(screen->display, 100);
  1053. X        }
  1054. X    }
  1055. }
  1056. X
  1057. X
  1058. X
  1059. selectwindow(screen, flag)
  1060. register TScreen *screen;
  1061. register int flag;
  1062. {
  1063. X    if(screen->TekEmu) {
  1064. X        if(!Ttoggled)
  1065. X            TCursorToggle(TOGGLE);
  1066. X        screen->select |= flag;
  1067. X        if(!Ttoggled)
  1068. X            TCursorToggle(TOGGLE);
  1069. X        return;
  1070. X    } else {
  1071. X        if(screen->cursor_state &&
  1072. X           (screen->cursor_col != screen->cur_col ||
  1073. X            screen->cursor_row != screen->cur_row))
  1074. X            HideCursor();
  1075. X        screen->select |= flag;
  1076. X        if(screen->cursor_state)
  1077. X            ShowCursor();
  1078. X        return;
  1079. X    }
  1080. }
  1081. X
  1082. unselectwindow(screen, flag)
  1083. register TScreen *screen;
  1084. register int flag;
  1085. {
  1086. X    if (screen->always_highlight) return;
  1087. X
  1088. X    if(screen->TekEmu) {
  1089. X    if(!Ttoggled) TCursorToggle(TOGGLE);
  1090. X    screen->select &= ~flag;
  1091. X    if(!Ttoggled) TCursorToggle(TOGGLE);
  1092. X    } else {
  1093. X    screen->select &= ~flag;
  1094. X    if(screen->cursor_state &&
  1095. X       (screen->cursor_col != screen->cur_col ||
  1096. X        screen->cursor_row != screen->cur_row))
  1097. X          HideCursor();
  1098. X    if(screen->cursor_state)
  1099. X      ShowCursor();
  1100. X    }
  1101. }
  1102. X
  1103. X
  1104. Bell()
  1105. {
  1106. X    extern XtermWidget term;
  1107. X    register TScreen *screen = &term->screen;
  1108. X    register Pixel xorPixel = screen->foreground ^ term->core.background_pixel;
  1109. X    XGCValues gcval;
  1110. X    GC visualGC;
  1111. X
  1112. X    if(screen->visualbell) {
  1113. X        gcval.function = GXxor;
  1114. X        gcval.foreground = xorPixel;
  1115. X        visualGC = XtGetGC((Widget)term, GCFunction+GCForeground, &gcval);
  1116. X        if(screen->TekEmu) {
  1117. X            XFillRectangle(
  1118. X                screen->display,
  1119. X                TWindow(screen), 
  1120. X                visualGC,
  1121. X                0, 0,
  1122. X                (unsigned) TFullWidth(screen),
  1123. X                (unsigned) TFullHeight(screen));
  1124. X            XFlush(screen->display);
  1125. X            XFillRectangle(
  1126. X                screen->display,
  1127. X                TWindow(screen), 
  1128. X                visualGC,
  1129. X                0, 0,
  1130. X                (unsigned) TFullWidth(screen),
  1131. X                (unsigned) TFullHeight(screen));
  1132. X        } else {
  1133. X            XFillRectangle(
  1134. X                screen->display,
  1135. X                VWindow(screen), 
  1136. X                visualGC,
  1137. X                0, 0,
  1138. X                (unsigned) FullWidth(screen),
  1139. X                (unsigned) FullHeight(screen));
  1140. X            XFlush(screen->display);
  1141. X            XFillRectangle(
  1142. X                screen->display,
  1143. X                VWindow(screen), 
  1144. X                visualGC,
  1145. X                0, 0,
  1146. X                (unsigned) FullWidth(screen),
  1147. X                (unsigned) FullHeight(screen));
  1148. X        }
  1149. X    } else
  1150. X        XBell(screen->display, 0);
  1151. }
  1152. X
  1153. Redraw()
  1154. {
  1155. X    extern XtermWidget term;
  1156. X    register TScreen *screen = &term->screen;
  1157. X    XExposeEvent event;
  1158. X
  1159. X    event.type = Expose;
  1160. X    event.display = screen->display;
  1161. X    event.x = 0;
  1162. X    event.y = 0;
  1163. X    event.count = 0; 
  1164. X    
  1165. X    if(VWindow(screen)) {
  1166. X            event.window = VWindow(screen);
  1167. X        event.width = term->core.width;
  1168. X        event.height = term->core.height;
  1169. X        (*term->core.widget_class->core_class.expose)(term, &event, NULL);
  1170. X        if(screen->scrollbar) 
  1171. X            (*screen->scrollWidget->core.widget_class->core_class.expose)(screen->scrollWidget, &event, NULL);
  1172. X        }
  1173. X
  1174. X    if(TWindow(screen) && screen->Tshow) {
  1175. X            event.window = TWindow(screen);
  1176. X        event.width = tekWidget->core.width;
  1177. X        event.height = tekWidget->core.height;
  1178. X        TekExpose (tekWidget, &event, NULL);
  1179. X    }
  1180. }
  1181. X
  1182. StartLog(screen)
  1183. register TScreen *screen;
  1184. {
  1185. X    register char *cp;
  1186. X    register int i;
  1187. X    static char *log_default;
  1188. X    char *malloc(), *rindex();
  1189. #ifdef ALLOWLOGFILEEXEC
  1190. X    void logpipe();
  1191. #ifdef SYSV
  1192. X    /* SYSV has another pointer which should be part of the
  1193. X    ** FILE structure but is actually a separate array.
  1194. X    */
  1195. X    unsigned char *old_bufend;
  1196. #endif    /* SYSV */
  1197. #endif /* ALLOWLOGFILEEXEC */
  1198. X
  1199. X    if(screen->logging || (screen->inhibit & I_LOG))
  1200. X        return;
  1201. X    if(screen->logfile == NULL || *screen->logfile == 0) {
  1202. X        if(screen->logfile)
  1203. X            free(screen->logfile);
  1204. X        if(log_default == NULL)
  1205. X            mktemp(log_default = log_def_name);
  1206. X        if((screen->logfile = malloc((unsigned)strlen(log_default) + 1)) == NULL)
  1207. X            return;
  1208. X        strcpy(screen->logfile, log_default);
  1209. X    }
  1210. X    if(*screen->logfile == '|') {    /* exec command */
  1211. #ifdef ALLOWLOGFILEEXEC
  1212. X        /*
  1213. X         * Warning, enabling this "feature" allows arbitrary programs
  1214. X         * to be run.  If ALLOWLOGFILECHANGES is enabled, this can be
  1215. X         * done through escape sequences....  You have been warned.
  1216. X         */
  1217. X        int p[2];
  1218. X        static char *shell;
  1219. X
  1220. X        if(pipe(p) < 0 || (i = fork()) < 0)
  1221. X            return;
  1222. X        if(i == 0) {    /* child */
  1223. X            close(p[1]);
  1224. X            dup2(p[0], 0);
  1225. X            close(p[0]);
  1226. X            dup2(fileno(stderr), 1);
  1227. X            dup2(fileno(stderr), 2);
  1228. #ifdef SYSV
  1229. X            old_bufend = _bufend(stderr);
  1230. #endif    /* SYSV */
  1231. X            close(fileno(stderr));
  1232. X            fileno(stderr) = 2;
  1233. #ifdef SYSV
  1234. X            _bufend(stderr) = old_bufend;
  1235. #endif    /* SYSV */
  1236. X            close(screen->display->fd);
  1237. X            close(screen->respond);
  1238. X            if(!shell) {
  1239. X                register struct passwd *pw;
  1240. X                char *getenv(), *malloc();
  1241. X                struct passwd *getpwuid();
  1242. X
  1243. X                if(((cp = getenv("SHELL")) == NULL || *cp == 0)
  1244. X                 && ((pw = getpwuid(screen->uid)) == NULL ||
  1245. X                 *(cp = pw->pw_shell) == 0) ||
  1246. X                 (shell = malloc((unsigned) strlen(cp) + 1)) == NULL)
  1247. X                    shell = "/bin/sh";
  1248. X                else
  1249. X                    strcpy(shell, cp);
  1250. X            }
  1251. X            signal(SIGHUP, SIG_DFL);
  1252. X            signal(SIGCHLD, SIG_DFL);
  1253. X            setgid(screen->gid);
  1254. X            setuid(screen->uid);
  1255. X            execl(shell, shell, "-c", &screen->logfile[1], 0);
  1256. X            fprintf(stderr, "%s: Can't exec `%s'\n", xterm_name,
  1257. X             &screen->logfile[1]);
  1258. X            exit(ERROR_LOGEXEC);
  1259. X        }
  1260. X        close(p[0]);
  1261. X        screen->logfd = p[1];
  1262. X        signal(SIGPIPE, logpipe);
  1263. #else
  1264. X        Bell();
  1265. X        Bell();
  1266. X        return;
  1267. #endif
  1268. X    } else {
  1269. X        if(access(screen->logfile, F_OK) == 0) {
  1270. X            if(access(screen->logfile, W_OK) < 0)
  1271. X                return;
  1272. X        } else if(cp = rindex(screen->logfile, '/')) {
  1273. X            *cp = 0;
  1274. X            i = access(screen->logfile, W_OK);
  1275. X            *cp = '/';
  1276. X            if(i < 0)
  1277. X                return;
  1278. X        } else if(access(".", W_OK) < 0)
  1279. X            return;
  1280. X        if((screen->logfd = open(screen->logfile, O_WRONLY | O_APPEND |
  1281. X         O_CREAT, 0644)) < 0)
  1282. X            return;
  1283. X        chown(screen->logfile, screen->uid, screen->gid);
  1284. X
  1285. X    }
  1286. X    screen->logstart = screen->TekEmu ? Tbptr : bptr;
  1287. X    screen->logging = TRUE;
  1288. X    update_logging();
  1289. }
  1290. X
  1291. CloseLog(screen)
  1292. register TScreen *screen;
  1293. {
  1294. X    if(!screen->logging || (screen->inhibit & I_LOG))
  1295. X        return;
  1296. X    FlushLog(screen);
  1297. X    close(screen->logfd);
  1298. X    screen->logging = FALSE;
  1299. X    update_logging();
  1300. }
  1301. X
  1302. FlushLog(screen)
  1303. register TScreen *screen;
  1304. {
  1305. X    register Char *cp;
  1306. X    register int i;
  1307. X
  1308. X    cp = screen->TekEmu ? Tbptr : bptr;
  1309. X    if((i = cp - screen->logstart) > 0)
  1310. X        write(screen->logfd, screen->logstart, i);
  1311. X    screen->logstart = screen->TekEmu ? Tbuffer : buffer;
  1312. }
  1313. X
  1314. #ifdef ALLOWLOGFILEEXEC
  1315. void logpipe()
  1316. {
  1317. X    register TScreen *screen = &term->screen;
  1318. X
  1319. #ifdef SYSV
  1320. X    (void) signal(SIGPIPE, SIG_IGN);
  1321. #endif    /* SYSV */
  1322. X    if(screen->logging)
  1323. X        CloseLog(screen);
  1324. }
  1325. #endif /* ALLOWLOGFILEEXEC */
  1326. X
  1327. X
  1328. do_osc(func)
  1329. int (*func)();
  1330. {
  1331. X    register TScreen *screen = &term->screen;
  1332. X    register int mode, c;
  1333. X    register char *cp;
  1334. X    char buf[512];
  1335. X    char *bufend = &buf[(sizeof buf) - 1];    /* leave room for null */
  1336. X    extern char *malloc();
  1337. X    Bool okay = True;
  1338. X
  1339. X    /* 
  1340. X     * lines should be of the form <ESC> ] number ; string <BEL>
  1341. X     *
  1342. X     * where number is one of 0, 1, 2, or 46
  1343. X     */
  1344. X    mode = 0;
  1345. X    while(isdigit(c = (*func)()))
  1346. X        mode = 10 * mode + (c - '0');
  1347. X    if (c != ';') okay = False;
  1348. X    cp = buf;
  1349. X    while(isprint((c = (*func)()) & 0x7f) && cp < bufend)
  1350. X        *cp++ = c;
  1351. X    if (c != 7) okay = False;
  1352. X    *cp = 0;
  1353. X    if (okay) switch(mode) {
  1354. X     case 0:    /* new icon name and title*/
  1355. X        Changename(buf);
  1356. X        Changetitle(buf);
  1357. X        break;
  1358. X
  1359. X     case 1:    /* new icon name only */
  1360. X        Changename(buf);
  1361. X        break;
  1362. X
  1363. X     case 2:    /* new title only */
  1364. X        Changetitle(buf);
  1365. X        break;
  1366. X
  1367. X     case 46:    /* new log file */
  1368. #ifdef ALLOWLOGFILECHANGES
  1369. X        /*
  1370. X         * Warning, enabling this feature allows people to overwrite
  1371. X         * arbitrary files accessible to the person running xterm.
  1372. X         */
  1373. X        if((cp = malloc((unsigned)strlen(buf) + 1)) == NULL)
  1374. X            break;
  1375. X        strcpy(cp, buf);
  1376. X        if(screen->logfile)
  1377. X            free(screen->logfile);
  1378. X        screen->logfile = cp;
  1379. #else
  1380. X        Bell();
  1381. X        Bell();
  1382. #endif
  1383. X        break;
  1384. X
  1385. X    case 50:
  1386. X        SetVTFont (fontMenu_fontescape, True, buf, NULL);
  1387. X        break;
  1388. X
  1389. X    /*
  1390. X     * One could write code to send back the display and host names,
  1391. X     * but that could potentially open a fairly nasty security hole.
  1392. X     */
  1393. X    }
  1394. }
  1395. X
  1396. static ChangeGroup(attribute, value)
  1397. X     String attribute;
  1398. X     XtArgVal value;
  1399. {
  1400. X    extern Widget toplevel;
  1401. X    Arg args[1];
  1402. X
  1403. X    XtSetArg( args[0], attribute, value );
  1404. X    XtSetValues( toplevel, args, 1 );
  1405. }
  1406. X
  1407. Changename(name)
  1408. register char *name;
  1409. {
  1410. X    ChangeGroup( XtNiconName, (XtArgVal)name );
  1411. }
  1412. X
  1413. Changetitle(name)
  1414. register char *name;
  1415. {
  1416. X    ChangeGroup( XtNtitle, (XtArgVal)name );
  1417. }
  1418. X
  1419. #ifndef DEBUG
  1420. /* ARGSUSED */
  1421. #endif
  1422. Panic(s, a)
  1423. char    *s;
  1424. int a;
  1425. {
  1426. #ifdef DEBUG
  1427. X    if(debug) {
  1428. X        fprintf(stderr, "%s: PANIC!    ", xterm_name);
  1429. X        fprintf(stderr, s, a);
  1430. X        fputs("\r\n", stderr);
  1431. X        fflush(stderr);
  1432. X    }
  1433. #endif    /* DEBUG */
  1434. }
  1435. X
  1436. char *SysErrorMsg (n)
  1437. X    int n;
  1438. {
  1439. X    extern char *sys_errlist[];
  1440. X    extern int sys_nerr;
  1441. X
  1442. X    return ((n >= 0 && n < sys_nerr) ? sys_errlist[n] : "unknown error");
  1443. }
  1444. X
  1445. X
  1446. SysError (i)
  1447. int i;
  1448. {
  1449. X    int oerrno;
  1450. X
  1451. X    oerrno = errno;
  1452. X    /* perror(3) write(2)s to file descriptor 2 */
  1453. X    fprintf (stderr, "%s: Error %d, errno %d: ", xterm_name, i, oerrno);
  1454. X    fprintf (stderr, "%s\n", SysErrorMsg (oerrno));
  1455. X    Cleanup(i);
  1456. }
  1457. X
  1458. Error (i)
  1459. int i;
  1460. {
  1461. X    fprintf (stderr, "%s: Error %d\n", xterm_name, i);
  1462. X    Cleanup(i);
  1463. }
  1464. X
  1465. X
  1466. /*
  1467. X * cleanup by sending SIGHUP to client processes
  1468. X */
  1469. Cleanup (code)
  1470. int code;
  1471. {
  1472. X    extern XtermWidget term;
  1473. X    register TScreen *screen;
  1474. X
  1475. X    screen = &term->screen;
  1476. X    if (screen->pid > 1) {
  1477. X        (void) killpg (screen->pid, SIGHUP);
  1478. X    }
  1479. X    Exit (code);
  1480. }
  1481. X
  1482. /*
  1483. X * sets the value of var to be arg in the Unix 4.2 BSD environment env.
  1484. X * Var should end with '=' (bindings are of the form "var=value").
  1485. X * This procedure assumes the memory for the first level of environ
  1486. X * was allocated using calloc, with enough extra room at the end so not
  1487. X * to have to do a realloc().
  1488. X */
  1489. Setenv (var, value)
  1490. register char *var, *value;
  1491. {
  1492. X    extern char **environ;
  1493. X    register int index = 0;
  1494. X    register int len = strlen(var);
  1495. X
  1496. X    while (environ [index] != NULL) {
  1497. X        if (strncmp (environ [index], var, len) == 0) {
  1498. X        /* found it */
  1499. X        environ[index] = (char *)malloc ((unsigned)len + strlen (value) + 1);
  1500. X        strcpy (environ [index], var);
  1501. X        strcat (environ [index], value);
  1502. X        return;
  1503. X        }
  1504. X        index ++;
  1505. X    }
  1506. X
  1507. #ifdef DEBUG
  1508. X    if (debug) fputs ("expanding env\n", stderr);
  1509. #endif    /* DEBUG */
  1510. X
  1511. X    environ [index] = (char *) malloc ((unsigned)len + strlen (value) + 1);
  1512. X    (void) strcpy (environ [index], var);
  1513. X    strcat (environ [index], value);
  1514. X    environ [++index] = NULL;
  1515. }
  1516. X
  1517. /*
  1518. X * returns a pointer to the first occurrence of s2 in s1,
  1519. X * or NULL if there are none.
  1520. X */
  1521. char *strindex (s1, s2)
  1522. register char    *s1, *s2;
  1523. {
  1524. X    register char    *s3;
  1525. X    char        *index();
  1526. X    int s2len = strlen (s2);
  1527. X
  1528. X    while ((s3=index(s1, *s2)) != NULL) {
  1529. X        if (strncmp(s3, s2, s2len) == 0)
  1530. X            return (s3);
  1531. X        s1 = ++s3;
  1532. X    }
  1533. X    return (NULL);
  1534. }
  1535. X
  1536. /*ARGSUSED*/
  1537. xerror(d, ev)
  1538. Display *d;
  1539. register XErrorEvent *ev;
  1540. {
  1541. X    fprintf (stderr, "%s:  warning, error event receieved:\n", xterm_name);
  1542. X    (void) XmuPrintDefaultErrorMessage (d, ev, stderr);
  1543. X    Exit (ERROR_XERROR);
  1544. }
  1545. X
  1546. /*ARGSUSED*/
  1547. xioerror(dpy)
  1548. Display *dpy;
  1549. {
  1550. X    (void) fprintf (stderr, 
  1551. X            "%s:  fatal IO error %d (%s) or KillClient on X server \"%s\"\r\n",
  1552. X            xterm_name, errno, SysErrorMsg (errno),
  1553. X            DisplayString (dpy));
  1554. X
  1555. X    Exit(ERROR_XIOERROR);
  1556. }
  1557. X
  1558. XXStrCmp(s1, s2)
  1559. char *s1, *s2;
  1560. {
  1561. X  if (s1 && s2) return(strcmp(s1, s2));
  1562. X  if (s1 && *s1) return(1);
  1563. X  if (s2 && *s2) return(-1);
  1564. X  return(0);
  1565. }
  1566. X
  1567. static void withdraw_window (dpy, w, scr)
  1568. X    Display *dpy;
  1569. X    Window w;
  1570. X    int scr;
  1571. {
  1572. X    (void) XmuUpdateMapHints (dpy, w, NULL);
  1573. X    XWithdrawWindow (dpy, w, scr);
  1574. X    return;
  1575. }
  1576. X
  1577. X
  1578. void set_vt_visibility (on)
  1579. X    Boolean on;
  1580. {
  1581. X    register TScreen *screen = &term->screen;
  1582. X
  1583. X    if (on) {
  1584. X    if (!screen->Vshow && term) {
  1585. X        VTInit ();
  1586. X        XtMapWidget (term->core.parent);
  1587. X        screen->Vshow = TRUE;
  1588. X    }
  1589. X    } else {
  1590. X    if (screen->Vshow && term) {
  1591. X        withdraw_window (XtDisplay (term), 
  1592. X                 XtWindow(XtParent(term)),
  1593. X                 XScreenNumberOfScreen(XtScreen(term)));
  1594. X        screen->Vshow = FALSE;
  1595. X    }
  1596. X    }
  1597. X    set_vthide_sensitivity();
  1598. X    set_tekhide_sensitivity();
  1599. X    update_vttekmode();
  1600. X    update_tekshow();
  1601. X    update_vtshow();
  1602. X    return;
  1603. }
  1604. X
  1605. void set_tek_visibility (on)
  1606. X    Boolean on;
  1607. {
  1608. X    register TScreen *screen = &term->screen;
  1609. X
  1610. X    if (on) {
  1611. X    if (!screen->Tshow && (tekWidget || TekInit())) {
  1612. X        XtRealizeWidget (tekWidget->core.parent);
  1613. X        XtMapWidget (tekWidget->core.parent);
  1614. X        screen->Tshow = TRUE;
  1615. X    }
  1616. X    } else {
  1617. X    if (screen->Tshow && tekWidget) {
  1618. X        withdraw_window (XtDisplay (tekWidget), 
  1619. X                 XtWindow(XtParent(tekWidget)),
  1620. X                 XScreenNumberOfScreen(XtScreen(tekWidget)));
  1621. X        screen->Tshow = FALSE;
  1622. X    }
  1623. X    }
  1624. X    set_tekhide_sensitivity();
  1625. X    set_vthide_sensitivity();
  1626. X    update_vtshow();
  1627. X    update_tekshow();
  1628. X    update_vttekmode();
  1629. X    return;
  1630. }
  1631. X
  1632. void end_tek_mode ()
  1633. {
  1634. X    register TScreen *screen = &term->screen;
  1635. X
  1636. X    if (screen->TekEmu) {
  1637. X    if (screen->logging) {
  1638. X        FlushLog (screen);
  1639. X        screen->logstart = buffer;
  1640. X    }
  1641. X    longjmp(Tekend, 1);
  1642. X    } 
  1643. X    return;
  1644. }
  1645. X
  1646. void end_vt_mode ()
  1647. {
  1648. X    register TScreen *screen = &term->screen;
  1649. X
  1650. X    if (!screen->TekEmu) {
  1651. X    if(screen->logging) {
  1652. X        FlushLog(screen);
  1653. X        screen->logstart = Tbuffer;
  1654. X    }
  1655. X    screen->TekEmu = TRUE;
  1656. X    longjmp(VTend, 1);
  1657. X    } 
  1658. X    return;
  1659. }
  1660. SHAR_EOF
  1661. chmod 0664 kterm-4.1.2/misc.c ||
  1662. echo 'restore of kterm-4.1.2/misc.c failed'
  1663. Wc_c="`wc -c < 'kterm-4.1.2/misc.c'`"
  1664. test 19514 -eq "$Wc_c" ||
  1665.     echo 'kterm-4.1.2/misc.c: original size 19514, current size' "$Wc_c"
  1666. rm -f _shar_wnt_.tmp
  1667. fi
  1668. # ============= kterm-4.1.2/n2ks ==============
  1669. if test -f 'kterm-4.1.2/n2ks' -a X"$1" != X"-c"; then
  1670.     echo 'x - skipping kterm-4.1.2/n2ks (File already exists)'
  1671.     rm -f _shar_wnt_.tmp
  1672. else
  1673. > _shar_wnt_.tmp
  1674. echo 'x - extracting kterm-4.1.2/n2ks (Text)'
  1675. sed 's/^X//' << 'SHAR_EOF' > 'kterm-4.1.2/n2ks' &&
  1676. xbtoa Begin
  1677. EhoC,UnVq+Uh-@"7AQkoUo@duYmPKHZ;IF(FJQ<DUpag0[s+XX=/<A6A#-\^Uq:lI]QU*aB;E7WUq^
  1678. iD^^=eO_,$lDC8AadUr7DO`DEAMBV`ZU9;KX"Urc<+b'Bf+DPYKKUs2Z1c3cn6cXN]sD5>QRUsa(Td
  1679. rK6.TlP(UZO1_eYe5!PYekEqYf1X%Ygd]9YhX7qYip+@YjDd<9<e858?o"39X1X=H*O\rDR$]l9!Q?
  1680. U:9htLE^I%UEal<'Ec&)5E_WgtEbr#?;JWQ*;K&i:$;tTDV,D'6W)@T?Z;PhN\5H//^/AXM^J[_1ap
  1681. M$;ZHlEBZI2WrZIi&mZIr,JZK"hXZKG+PZL/&t@^>T'D6ie3CpTjWCU:$^DmR&sBsYa!C9u%iF)\J;
  1682. F*4hIF&94-F(hoGF%`k5F%iq:F*Y-e$?L*lWH1\=Z?&dJZu\R@[<#fa\oV_q^iN5WbR/E-[*N<![+T
  1683. #/[-M:;[.IpE[.S!L[A@GW[B9jJ:pmW@BXP6Z9=;WJ8@?EJ9XVoPH*tn.DRIasAP0A]APTYcAO<fYA
  1684. R`(*ASnj:APKT$ASedD$:Sa<qaGG3VaY@/YXNN>]L?tO`C4IKa$iY0bR-d0[a%<8[a.B[[a@N=[b+#
  1685. 8[b4)d[bjMJ[c[udCpr\BCUWhHDmuEPBt(*SC:CBYE4<AiFgo0oAl,tZAn\[!AkTVaAk]\fApLlEAo
  1686. >*@AkKQ$$>*&BnRb+snn)@?q.=KRULn>PY$l+U[UF*a`<p$f\BeSu\C4l*\DCY:\E@9s\F3j>\F<p"
  1687. \G?P@9Xt(1H+Be\DRlfV9"DK@::\)I6Fjj>@_'>_@;WQq@;NKuEGN,<EGrDOEG;uSEGE&XEH&La$?:
  1688. 4"X`71K[W,ul\8b0Q_/W#W`,SJ^`c6:8bR/?-]$>:f]%_4"]&%En]&.L:]&[jJ]'=9O]($,)CV'F@D
  1689. nDuGBtLZJC:glNE4`h]Fh>FdBY2:l;,"UI;0fe";/X"n;.@/i;/Nr!;/El%FDJMO$?U3uolOo[rcCr
  1690. KW,udeX`SNp]QA;/`H4qhc3eZ,][Cmp]\R[#]]+$,]]aH_]^BlZ]_6G>]qc!W:;*NH6G9IB@_K-jD8
  1691. !N&Cq[_cCVA"mDnXd1<,0,*<,fP9<+ru5<(jq!<(O_"<(t"(<-c3R$<1oWV,U($XAhs/Y#Ia%Y>fAQ
  1692. Z;aQ4\l<L[^'\Cd^;a]%^=Hh/^>EHs^?T6D^@#NN^S,1\^SqQN:qsPOBYV>n9>A_^8AE_d9Y]@nH,&
  1693. ENDSPNFA4jW1A59o=A4")0A7E?XA8T,lA50k[A8K'*$?p:$g37JNkBCXUn97[DpNLAfqKHnpVK[1!X
  1694. pTAL_6nK#_7"P\_8:Ce_8pgo_97%J_:!OF_:As;9#9G0:;Pq66G_]+@_q>RD8GXaCr,gHCVlnT=)Ys
  1695. [=)#O^=),Ub=)c$q=*;C#=(oIm=%gEY$<Kd8elPP^fN2t-hH*=dj]=dckZ;61kuV`=l3^U/_X:oL_Y
  1696. 7PY_k^dV_l[E`_m<il_n9K%_o)ml:rC=`BZ%u&9>f1f9Z,FkH,JHJDSt@A9#Kg!@nsr+@m\*!@q*@H
  1697. @r9-X@r0)WH>CI"H>ga.$@6F)]R">2^Nsk;aa/*Jd<\X-fm7>Mg3QE1iX1!&`9;M@`9MYo`9_ef`9h
  1698. kC`:\FO`;+^G`;9mf@`>0iD8iK#CrNW'CW3f.DoKS<BuS8?C;nF)G]:XRG]h!_GYlB=G\G(WGY?$CG
  1699. Y#gBGYH*G$@$j8oQY8mols*JrHM)WTm/oDU3L.eWH`:"XpTDJ`j^2/`k6J1`l*%=`mAmC`n>NM`nPZ
  1700. U`oIJMFiNck:r`*MBZBdi9?3`L9ZNoOH,lb)DTAaaG"Tf^G!a6XG%/M(G&>:9G&54>B5>Q6B5biC$>
  1701. 4(niFcoGj(E>Olt:I]oOh"@rF]fbUM!6@XU8]3aKoMQaLGl.aM2A*aM_^`aNS9laO+WeaOU]2@`[D=
  1702. D91gO9uuj;Crl?kCN?YREbfa#UN1-]YbVVHCM'fIEbe1LVK-HHYbuMW@Bc\NCN6SXEbe%HWcDlsYcA
  1703. +OCK.O>Ebf3iX`A3$Yc`"^A$E.WCO!(fEbfj&Z#XVmYd+UVDfW(hEc6$'[;p1tYdSRj@Bd4]DfN"kE
  1704. c6'(\T2UfYdt0^De-)aEbTQu]lIh.YeG-lB!B$jBlpSpEbT'g_/`=mYepfg:M-iLEb]X!`c>g8YfCd
  1705. !A['6rC1a]lEb\=Qb&V6*YfdAoC2pK%Eb]^#c#RPuYg.9(A?aC#C3Qo/Eb]j'd;iuFYgNl!C1jd"Ec
  1706. ?*(eT,V@Yh!i6@Be@(E,i,7Ec?-)flD%2YhBG)E+H3-EclE,h/[X9YhjDCF0OPBF_.f8EckuuiGs'L
  1707. Yi6"1F`FYGEclK.jDoBBYiTnJA?b3:Fa1.RE_ph]l#KU4Yj)R9:iW`*E_pk^luHc[YjQOFF0P+RBP"
  1708. F;EbK'hnT&;;Yjr-ABMPf'EbIqHoQ"VRYk<$MENo.WBQUKQEbK!fpi:%lYk\WH96.96E_CJXr,PGBY
  1709. l/T89sFV;94>*!E_CDWU2inKZ(hYH94Y<'E_(8VVK,4>Z);V5ENuH_85ujnE_'`GWcCdRZ)e:Q9QRJ
  1710. @E_L)MY&[3EZ*/1AENu`g9Q[PEE_L#KZ>t53Z*XjYH"O=hEd;Z0[W6Y8Z+"akEj</qDKE(oEc,Hn]5
  1711. he$Z+LEaDF^tFEc+UV^2e*\Z+k<s@BmUgDK2qtEc-!(_K'O)Z,6ohDKiA(E_:AW`c=[mZ,^lWB!KEt
  1712. 8lW(;E_9lIb&U7!Z-3Pq6?9?VE^FiPcZ2?aZ-[MX@Bn4#6?09YE^FlQdrJo=Z.02%@V2mrEc#j%fQ(
  1713. hMZ.X/7A[0s0D.^'-Ec"=Ogi@7?Z/#b-D/li;Ec#p'hf<REZ/BY=Ej=YFCiclBEbo<lj`50LZ/uC6C
  1714. e_1tEbo0hk]1KZZ0?:FFKt+OCh0g:Ebos)luHocZ0_lrCN?]K;JT18n5=%CZ11_-B!Lo)CJD)*;JT^
  1715. GoMTIEZ1SH%CNQiT;JT7:pJPd;Z1q44Gd7'BDfW,[;K$W]r).HFZ2G#-DdfpM;K$Q\Ti,fNZD(68<3
  1716. i8sDe-/L;JC0WVG_,?ZDS%-C3$VZ;JK+8W`!SQZE$l<B!SL9C14EM;JL3WY#9"VZEFU5C/hLC;JKaJ
  1717. Yu5O]ZEmGJF0`/NE+-&[;K-``[Sh'TZF:0=F`Xk!;KZTW\l*ZmZFa"W<3j/7Fa14*;J:*V^f"ieZG?
  1718. lGBLoGG;J9[J_bt/VZG]XSEO*P]BQUQ";J9UHa&6SpZH*ANBOe?i;G2&9b>LuFZHQ3><3jbH94Y?R;
  1719. Fki6cr*DFZI'"W9QRMg;G:].e5AtKZIMiHEO+.n9OtH\;JpN\g/;g0ZJ,^aDJ$30;Jnt0h,8-!ZJJJ
  1720. sEO+J"DKN2B;Jp$NiDOQ;ZJl3h8nPBi;G'ooj\e]]ZK>%[EjFn,:33`*;GLi0l;CAcZKhiq:3!T+;G
  1721. L2sm8?8lZL:[XB!Uo(6=I1i;F5B/nks=FZLnQ&D0*#V;Jet1pJPj?ZM7=79sXRmD+:i-;JfjJqbh9N
  1722. ZMY&-D03)^;JfsMr_dTXZ_:95EjMN=CicqY;J]sOV,D,<Z_e(-CiQeZ;J^H]W)@GBZ`/"]EjMffCJq
  1723. L?F),j'X`J8hZ`XXVCM'oVF)+:PY]FSSZa"Re@C*7\CN6\eF),m(Zu^"^ZaC-]CLjc[F)-!+[rZ=pZ
  1724. ab'lGdFr%CM0ubF)Q**]Q8"4Zb6]eDe?>iF)PKn^N4=5ZbUX#FL/f)DcF'[F)PTq_fKO4Zc*8mBlgW
  1725. #F(o6ma)bs'ZcI3%A@'C!C3$Z(F)"X[b]@N?ZcrhuC1aftF)"FUcZ<heZd<c.@C+@&C2pT.F)#g'dr
  1726. T8'Zd]>'C1O[$F)#?oeoPeNZe0><F0jP@E+ZH1F)YQogN.=RZePn/E-/GBF)Y*bhK*XHZeohHEjO_G
  1727. F`XnKF*2*$j)]?OZfDI7F`FbLF*1Hgk&YZUZfcCPHF)gV:iiu.F(fU#luQi]ZgA*@BP+U=F(e:SmrN
  1728. /NZg`$LEO51VBQUTOF(f*jo5eSgZh+TGBP4[EF%^S\pN&u>ZhST7<3uCA9QRQ;F%g2Pr,YP?Zi(5P9
  1729. Q@E<F%g\_TlYL"[%h\fF0q`aH"OF[F*Vc4VK7$)[&47PH"=:\F)H$*WcN'![&\7cA[JO[DJ$8XF)GE
  1730. nY&eK#[''gXDKN7iF)GNqZ#`N:['Og?F0rAs6>!U6F$a<B\8suV[(-Nb@WJifF(/ag]Q7Oj[(UNiEO
  1731. <H$@Uuj\F)>s)_/jI7[)*/kD.^/mF)=FS`,fci[)I*'@C4$qD/lr'F)?$+aE)3/[)iYrD0NA0F)?*-
  1732. bB$C![*<YdB!fj)CiZo0F)5p)d;s,9[*f;&Ce_:cF)59le8oGG[+056FL9V?Ch0p)F)6$,fO\i=[+Y
  1733. juCJqOoASZ@oggt84[,#;/B!gE+CIbbhASY#Ii+6[i[,D@'CIY\jASY_]j(3"G[,be6FL:.@CK.\'A
  1734. SYh`k@JFQ[-.j.CLaa9ASYqcl=FmS[-V@BF0t=GDe?BEAT)"amq$EW[."E6DfiAVAT(PTnmu`M[.@j
  1735. DEjYOOC/VG5ASQ:npgn2O[.t&?C1ajLASOrHqdjM.[/=KM@C5uEC2pW[ASQ=pTk.tL[A"">C1FZHAS
  1736. QCrUh+Lc[AIMSF1%oWE+ZMVAT2(cWF^$g[AjRFE-/LgAT1VVXCZ?][B4"_F1&2_F_8%cAT^t[Z"8&g
  1737. [B^-N:ij%OAS?+l[Uj,n[C9^\A[T$ZBP+Z_AS=fG\n,PM[CZcWBOS<]AS?(k]k(l![D$3cA@90`BOe
  1738. HcAS?=r_.?8\[DN>_94kTMAOoe.`aqhb[E)oQB!o`l9OY?OAP@*Ob@O@h[EJthDK</2ASuRsct.*,[
  1739. F&Q'@C=NpDK3)5ASuUte7EN.[FGUq8lW4MAPQdDfk!Kk[G,7ZB!pE*6?0EhAO:LHhIT#a[GM=&@WSs
  1740. 9AR]8ZialS-[Gth-A@:K0D0!&HASlLrk@JLA[HIs/D.^3?ASk/Ll=Fg@[HhC@EOG.ED032QASktcmU
  1741. ^3T[IFT8Cid#TASbqco4;`M[Ie$H@C>c>CiQlVAScIrpLS/?[J1)?Ch0sLAScRuqF,1?[JWI/F1(s8
  1742. CM(!R7;H>?Tg`a:[\=*tCNR"[7;Gl2Ud]'0[\ZE.B==[+DfW:b7;m7UWC:`;[]0['Ddg)T7;m1SX@7
  1743. &L[]Mu:<48quDe-;[7;?kOYsiDK[^$6/C1ao\7;>Q*Zpe^q[^AP=@CEU5C2p\k7;?qQ\4(.3[^c`6C
  1744. 1Oca7;?JD]1$[Z[_5+KF1/eOE+ZPn7;u\D^dW3^[_W;>E-/P*7;u57_aSNT[_tUW<49e8BQCQ&7;-b
  1745. Na[KlT[`SqGBOnQp78%7$bsb<I[a7H\EjjCbDKE887;c_Ge4"7E[ab^RDIL!)7;cYEf0r#I[b=/:B"
  1746. $G_6=I=X77)"&h*jY@[b_?[D0!)C7;[+SiC.Tp[c0_mB"$_gD.0m67;[%Qj[F$.[cRoc9lmc,787C&
  1747. ks\<T[d$:UEOP1%Cid&P7;QSEmR:r#[dOPlCiQoQ7;R(SnO78)[dn$GEjkUPCNHrWAnu"ep1A)K[eC
  1748. ,@CN6fXAnuLsq.=DA[eaTOA@DAICNm5bAnuRurFThX[f-VGDfW=]AoDb"ULnFV\"mVS@CN(FDfN7`A
  1749. oDe#Ve0jH\#9XGDe->VAnc:pX(H'e\#a1UFLSAaBk4]UAnl@qY\%Wk\$69PC1ar\Ankb`ZY!rl\$Ta
  1750. ^FLSYiC/h[NAnkkc[q9Af\$ucWE,rG!AoMh#]4Q"o\%H<l@CNp^E,iA$AoMk$^LhFq\%i>_F`Ot.Ap
  1751. &1(_e+%'\&;m$@CO3fF`Fn1Ap&4)a(BHn\&\ngF_%u'Al*QXb@XRj\'/G\FLTM,BQCT.AnZ7pct6s'
  1752. \'YOpBOSBuAnZ1ndq398\(##'A@L*$967SoAkQ[DfOdZR\(M+#9QR\tAkZgGgh'5g\(tXiEOXe:9Q[
  1753. c$AkZaEi+@7U\)Ia,H"OPGApJC*jCW[Z\)h4IA@L]5DK<5MAo;\!l"4gF\*=<4DIL$?Ao;Utlt1-W\
  1754. *[dFA@Lu=8lW:hAjUOIo4C=1\+C#>6>!_"AjTq8p1?X5\+aK$A@M>G@WJsSAn#hjqds;L\,6SF@UZb
  1755. EAn#bhraoV]\=mMDA@S@GD0!.^Ao2V!V.ORV\>BUFD.0rPAo2OtW+Kmg\>a(WA@SXOD0NLjAo2e&XC
  1756. c<m\?-*MCi[%hAo)OuY\%]`\?TX^@CWUTCiQtkAo)S!Zt=,b\?uZPCN?qo@;Bqo\7'/D\@H$`A[o<[
  1757. CM()g@;ABC]O>SM\@i5XCLO`e@;Bkm^L:o"\A2NgA@THaCNm;*@;C+t_dR=n\AS__DfWA-@;g4sa'i
  1758. mu\B&)s@CXEfDfN;0@;g7tb@,<g\BG:gDe-B&@;gA"c=(F-\BnYuB"65sBk4a%@;9hme7!*5\CCppC
  1759. 1b!,@;8NHf3rE&\Cb5)EOa\1C36u>@;9>_gL4i@\D.F"C1k'4@;p7shdLJF\DUe7B"6f.E+-99@;p4
  1760. rj'cnK\E"!*E)a@/@;obek$`CQ\EI@DF1CICF_8/K@<H\%lX=p8\EjQ2F_&#L@<H(imU9dL\FF!@;n
  1761. 2C,BQL]T@;'8_oO2E-\Fg2;BOSFE@;'YjpL.`W\G0KGA@VGD967W?@7sS0r*`6/\GZbC9QRb<@8(:D
  1762. U1$`8\YES,FLe2U9Ot]1@<lq)VdXj_\YojDH#^Bo@<lt*WaTdc\ZB4W;Rro<DKE@k@;]YeY@2<\\Zc
  1763. ELDF_7B@;\fMZ=.WZ\[,^^EOiGbDKNFs@;]Vd[UF&u\[MoSDJ-Mi@7kUO\m\3C\[u9BEOi_j8p%VW@
  1764. 7#%G^gTQA\\SV]@WT)t@:EiZ`*m+`\]%udFLfD"D0*8/@;TVea^K$p\]P7fD03>3@;Ktpc!bF0\^"W
  1765. "A\$,qChC6)@;JZKd:$j"\^CgnCiR#7@;L%re7!/m\^b,)A@^9"Ch($-@;L2!fPt\I\_7C1CJq^tEG
  1766. JL`gi7+N\_V7@A\$Z;CM(-7EGJ(Ti,NO,\`!m8CI,MjEGK!nj)JjS\`@aGFLgLQCLk!<EGKg0kAbE\
  1767. \`jH@Df`JSEGoI"lZ$iO\a4<SEOkIVDfiPXEGngemr<8V\aTrGDg8h_EG9I(o5SJc\b'lUEOka^C3$
  1768. lZEGBR*pi1%[\bQSPC1b$QEGA4Yqf-@Z\bpG^EOl$fC37#cEGB$qTlFgk\tTOOE,rOcEH$!1V/^Hc\
  1769. u'IdB"Fm[E+->VEH#p/WGum!\uH*WE)aELEH#I"XDrB'\up$qF1SPpF_84hEHQ94Z#Oo.]!;Z_F]>r
  1770. YEHPg'ZuL55]!ZNSF1Si#BQC\pEG/7]\oDD)]"8;hBP+igEG/dl]l@_*]"W/tFLo5,BOn]iED(Aa_J
  1771. r4J]#+kp86!1>ED1Daa)Odo]#\kbB"H*(9OYNTED1A`bAhfK]$1S%DK<>7EGfj/cuEr7]$YM8B"HE1
  1772. DF_:eEGeL^e8]A7]%%.-DK38=EGfm0f5Y\=]%D"?Ge2RJDK`VFECsiSgi5qc]%m^56?9ZqEC+`XiGh
  1773. 1r]&I]rA@gf@@WT-BEFNOkk&Fj=]&sE?@W]3FEFNIil#CQ\]'F?QF1U^XD.^BHEG]-qmW!)`]'fuGD
  1774. 03AYEGT[,no8Je](9oXB"IVSCe_M6EGT'pp2Ong](ZPOCim8`EGT0sq/L4p])$D_A%MP7CN@#b;/:6
  1775. ar_[HC]:fR/CJDF8;/9UPUJYfH];/;>FM"AHCK.pC;/9^SVbq5B];Q'6DfWIi;/^NfX&3eI]<"kJ@C
  1776. rX=DfNCl;/^QgY>K4;]<DW>De-Jb;/('_ZVbFF]<kFMEkAbWC3."r;/0[S\5@!Q]=A8GC14`c;/13b
  1777. ]2<<B]=_!UA@oNPE+HSq;0?ok_,5>`]>=nPF`G%2;0?um`)1YV]>[WiA@oiYBQC`+;.t$_a\c_`]?1
  1778. SHAR_EOF
  1779. true || echo 'restore of kterm-4.1.2/n2ks failed'
  1780. fi
  1781. echo 'End of kterm-4.1.2 part 15'
  1782. echo 'File kterm-4.1.2/n2ks is continued in part 16'
  1783. echo 16 > _shar_seq_.tmp
  1784. exit 0
  1785.  
  1786.  
  1787. -----------------------------------------------------------------------------
  1788. mleisher@nmsu.edu                      "I laughed.
  1789. Mark Leisher                                I cried.
  1790. Computing Research Lab                          I fell down.
  1791. New Mexico State University                        It changed my life."
  1792. Las Cruces, NM                     - Rich [Cowboy Feng's Space Bar and Grille]
  1793.  
  1794. --
  1795. Dan Heller
  1796. O'Reilly && Associates       Z-Code Software    Comp-sources-x:
  1797. Senior Writer                President          comp-sources.x@uunet.uu.net
  1798. argv@ora.com                 argv@zipcode.com
  1799.