home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / x / volume12 / kterm / part09 < prev    next >
Internet Message Format  |  1991-05-08  |  52KB
  1. Path: uunet!wuarchive!cs.utexas.edu!convex!central!newstop!grapevine!male!jethro!exodus!NMSU.Edu!mleisher
  2. From: mleisher@NMSU.Edu
  3. Newsgroups: comp.sources.x
  4. Subject: v12i090: kterm  - kanji xterm, Part09/18
  5. Message-ID: <12974@exodus.Eng.Sun.COM>
  6. Date: 8 May 91 02:40:18 GMT
  7. References: <csx-12i082:kterm@uunet.UU.NET>
  8. Sender: news@exodus.Eng.Sun.COM
  9. Lines: 1997
  10. Approved: argv@sun.com
  11.  
  12. Submitted-by: mleisher@NMSU.Edu
  13. Posting-number: Volume 12, Issue 90
  14. Archive-name: kterm/part09
  15.  
  16. #!/bin/sh
  17. # this is kt412.09 (part 9 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" != 9; 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        screen->gsets[1] = GSET_KANA;
  39. X        screen->gsets[2] = GSET_ASCII;
  40. # endif /* KTERM_KANJI */
  41. X        screen->gsets[3] = GSET_ASCII;
  42. #else /* !KTERM */
  43. X        screen->gsets[0] = 'B';
  44. X        screen->gsets[1] = 'B';
  45. X        screen->gsets[2] = 'B';
  46. X        screen->gsets[3] = 'B';
  47. #endif /* !KTERM */
  48. X        screen->curgl = 0;
  49. #ifdef KTERM
  50. X        screen->curgr = 1;
  51. #else /* !KTERM */
  52. X        screen->curgr = 2;
  53. #endif /* !KTERM */
  54. X        screen->curss = 0;
  55. X        ClearScreen(screen);
  56. #ifdef STATUSLINE
  57. X        EraseStatus();
  58. #endif /* STATUSLINE */
  59. X        screen->cursor_state = OFF;
  60. X        if (term->flags & REVERSE_VIDEO)
  61. X            ReverseVideo(term);
  62. X
  63. X        term->flags = term->initflags;
  64. X        if(screen->c132 && (term->flags & IN132COLUMNS)) {
  65. X                Dimension junk;
  66. X            XtMakeResizeRequest(
  67. X                (Widget) term,
  68. X                (Dimension) 80*FontWidth(screen)
  69. X                + 2 * screen->border + screen->scrollbar,
  70. #ifdef STATUSLINE
  71. X                (Dimension) screen->statusheight +
  72. #endif /* STATUSLINE */
  73. X                (Dimension) FontHeight(screen)
  74. X                    * (screen->max_row + 1) + 2 * screen->border,
  75. X                &junk, &junk);
  76. X            XSync(screen->display, FALSE);    /* synchronize */
  77. X            if(QLength(screen->display) > 0)
  78. X                xevents();
  79. X        }
  80. X        CursorSet(screen, 0, 0, term->flags);
  81. X    }
  82. X    longjmp(vtjmpbuf, 1);    /* force ground state in parser */
  83. }
  84. X
  85. X
  86. #ifdef STATUSLINE
  87. ToStatus(col)
  88. int col;
  89. {
  90. X    register TScreen *screen = &term->screen;
  91. X
  92. X    if (screen->cursor_state)
  93. X        HideCursor();
  94. X    if (col > screen->max_col)
  95. X        col = screen->max_col;
  96. X    if (!screen->instatus) {
  97. X        if (!screen->statusline)
  98. X            ShowStatus();
  99. X        CursorSave(term, &screen->statussc);
  100. X        screen->instatus = TRUE;
  101. X        screen->cur_row = screen->max_row + 1;
  102. X    }
  103. X    screen->cur_col = col;
  104. }
  105. X
  106. XFromStatus()
  107. {
  108. X    register TScreen *screen = &term->screen;
  109. X
  110. X    if (!screen->instatus)
  111. X        return;
  112. X    screen->instatus = FALSE;
  113. X    CursorRestore(term, &screen->statussc);
  114. }
  115. X
  116. ShowStatus()
  117. {
  118. X    register TScreen *screen = &term->screen;
  119. X    register int border = 2 * screen->border;
  120. X
  121. X    if (screen->statusline)
  122. X        return;
  123. X    screen->statusline = 1;
  124. X    screen->statusheight = FontHeight(screen) + 2;
  125. X    ResizeScreen(term, border + screen->scrollbar, border);
  126. }
  127. X
  128. HideStatus()
  129. {
  130. X    register TScreen *screen = &term->screen;
  131. X    register int border = 2 * screen->border;
  132. #ifndef KTERM
  133. X    register int i, j;
  134. #endif /* !KTERM */
  135. X
  136. X    if (!screen->statusline)
  137. X        return;
  138. X    if (screen->instatus)
  139. X        FromStatus();
  140. X    screen->statusline = 0;
  141. X    screen->statusheight = 0;
  142. #ifdef KTERM
  143. X    bzero(screen->buf[screen->max_row + 1],
  144. X        sizeof(Bchr) * (screen->max_col+1));
  145. #else /* !KTERM */
  146. X    bzero(screen->buf[i = 2 * (screen->max_row + 1)],
  147. X        j = screen->max_col + 1);
  148. X    bzero(screen->buf[i + 1], j);
  149. #endif /* !KTERM */
  150. X    ResizeScreen(term, border + screen->scrollbar, border);
  151. }
  152. X
  153. EraseStatus()
  154. {
  155. X    register TScreen *screen = &term->screen;
  156. X    register int j, pix;
  157. #ifdef KTERM
  158. X    int fnum = F_ISO8859_1; /* referd by normalGC and reverseGC */
  159. #else /* !KTERM */
  160. X    register int i;
  161. #endif /* !KTERM */
  162. X
  163. X    if (!screen->statusline)
  164. X        return;
  165. #ifdef KTERM
  166. X    bzero(screen->buf[screen->max_row + 1],
  167. X        j = sizeof(Bchr) * (screen->max_col+1));
  168. #else /* !KTERM */
  169. X    bzero(screen->buf[i = 2 * (screen->max_row + 1)],
  170. X        j = screen->max_col + 1);
  171. X    bzero(screen->buf[i + 1], j) ;
  172. #endif /* !KTERM */
  173. X    XFillRectangle(screen->display, TextWindow(screen),
  174. X        screen->reversestatus ? screen->normalGC : screen->reverseGC,
  175. X        screen->border - 1 + screen->scrollbar,
  176. X        (screen->max_row + 1) * FontHeight(screen) +
  177. X        screen->border,
  178. X        j * FontWidth(screen) + 2, screen->statusheight);
  179. X    if (!screen->reversestatus)
  180. X        StatusBox(screen);
  181. }
  182. X
  183. StatusBox(screen)
  184. register TScreen *screen;
  185. {
  186. #ifdef KTERM
  187. X    int fnum = F_ISO8859_1; /* referd by normalGC */
  188. #endif /* KTERM */
  189. X
  190. X    status_box[0].x = screen->scrollbar;
  191. X    status_box[0].y = (screen->max_row + 1) * FontHeight(screen) +
  192. X        screen->border;
  193. X    status_box[3].x = -(status_box[1].x = (screen->max_col + 1) *
  194. X        FontWidth(screen) + screen->border + 1);
  195. X    status_box[4].y = -(status_box[2].y = FontHeight(screen) + 1);
  196. X    XDrawLines(screen->display, TextWindow(screen), screen->normalGC,
  197. X        status_box, NBOX, CoordModePrevious);
  198. }
  199. #endif /* STATUSLINE */
  200. X
  201. X
  202. /*
  203. X * set_character_class - takes a string of the form
  204. X * 
  205. X *                 low[-high]:val[,low[-high]:val[...]]
  206. X * 
  207. X * and sets the indicated ranges to the indicated values.
  208. X */
  209. X
  210. int set_character_class (s)
  211. X    register char *s;
  212. {
  213. X    register int i;            /* iterator, index into s */
  214. X    int len;                /* length of s */
  215. X    int acc;                /* accumulator */
  216. X    int low, high;            /* bounds of range [0..127] */
  217. X    int base;                /* 8, 10, 16 (octal, decimal, hex) */
  218. X    int numbers;            /* count of numbers per range */
  219. X    int digits;                /* count of digits in a number */
  220. X    static char *errfmt = "%s:  %s in range string \"%s\" (position %d)\n";
  221. X    extern char *ProgramName;
  222. X
  223. X    if (!s || !s[0]) return -1;
  224. X
  225. X    base = 10;                /* in case we ever add octal, hex */
  226. X    low = high = -1;            /* out of range */
  227. X
  228. X    for (i = 0, len = strlen (s), acc = 0, numbers = digits = 0;
  229. X     i < len; i++) {
  230. X    char c = s[i];
  231. X
  232. X    if (isspace(c)) {
  233. X        continue;
  234. X    } else if (isdigit(c)) {
  235. X        acc = acc * base + (c - '0');
  236. X        digits++;
  237. X        continue;
  238. X    } else if (c == '-') {
  239. X        low = acc;
  240. X        acc = 0;
  241. X        if (digits == 0) {
  242. X        fprintf (stderr, errfmt, ProgramName, "missing number", s, i);
  243. X        return (-1);
  244. X        }
  245. X        digits = 0;
  246. X        numbers++;
  247. X        continue;
  248. X    } else if (c == ':') {
  249. X        if (numbers == 0)
  250. X          low = acc;
  251. X        else if (numbers == 1)
  252. X          high = acc;
  253. X        else {
  254. X        fprintf (stderr, errfmt, ProgramName, "too many numbers",
  255. X             s, i);
  256. X        return (-1);
  257. X        }
  258. X        digits = 0;
  259. X        numbers++;
  260. X        acc = 0;
  261. X        continue;
  262. X    } else if (c == ',') {
  263. X        /*
  264. X         * now, process it
  265. X         */
  266. X
  267. X        if (high < 0) {
  268. X        high = low;
  269. X        numbers++;
  270. X        }
  271. X        if (numbers != 2) {
  272. X        fprintf (stderr, errfmt, ProgramName, "bad value number", 
  273. X             s, i);
  274. X        } else if (SetCharacterClassRange (low, high, acc) != 0) {
  275. X        fprintf (stderr, errfmt, ProgramName, "bad range", s, i);
  276. X        }
  277. X
  278. X        low = high = -1;
  279. X        acc = 0;
  280. X        digits = 0;
  281. X        numbers = 0;
  282. X        continue;
  283. X    } else {
  284. X        fprintf (stderr, errfmt, ProgramName, "bad character", s, i);
  285. X        return (-1);
  286. X    }                /* end if else if ... else */
  287. X
  288. X    }
  289. X
  290. X    if (low < 0 && high < 0) return (0);
  291. X
  292. X    /*
  293. X     * now, process it
  294. X     */
  295. X
  296. X    if (high < 0) high = low;
  297. X    if (numbers < 1 || numbers > 2) {
  298. X    fprintf (stderr, errfmt, ProgramName, "bad value number", s, i);
  299. X    } else if (SetCharacterClassRange (low, high, acc) != 0) {
  300. X    fprintf (stderr, errfmt, ProgramName, "bad range", s, i);
  301. X    }
  302. X
  303. X    return (0);
  304. }
  305. X
  306. /* ARGSUSED */
  307. static void HandleKeymapChange(w, event, params, param_count)
  308. X    Widget w;
  309. X    XEvent *event;
  310. X    String *params;
  311. X    Cardinal *param_count;
  312. {
  313. X    static XtTranslations keymap, original;
  314. X    static XtResource resources[] = {
  315. X    { XtNtranslations, XtCTranslations, XtRTranslationTable,
  316. X          sizeof(XtTranslations), 0, XtRTranslationTable, (caddr_t)NULL}
  317. X    };
  318. X    char mapName[1000];
  319. X    char mapClass[1000];
  320. X
  321. X    if (*param_count != 1) return;
  322. X
  323. X    if (original == NULL) original = w->core.tm.translations;
  324. X
  325. X    if (strcmp(params[0], "None") == 0) {
  326. X    XtOverrideTranslations(w, original);
  327. X    return;
  328. X    }
  329. X    (void) sprintf( mapName, "%sKeymap", params[0] );
  330. X    (void) strcpy( mapClass, mapName );
  331. X    if (islower(mapClass[0])) mapClass[0] = toupper(mapClass[0]);
  332. X    XtGetSubresources( w, &keymap, mapName, mapClass,
  333. X               resources, (Cardinal)1, NULL, (Cardinal)0 );
  334. X    if (keymap != NULL)
  335. X    XtOverrideTranslations(w, keymap);
  336. }
  337. X
  338. X
  339. /* ARGSUSED */
  340. static void HandleBell(w, event, params, param_count)
  341. X    Widget w;
  342. X    XEvent *event;        /* unused */
  343. X    String *params;        /* [0] = volume */
  344. X    Cardinal *param_count;    /* 0 or 1 */
  345. {
  346. X    int percent = (*param_count) ? atoi(params[0]) : 0;
  347. X
  348. X    XBell( XtDisplay(w), percent );
  349. }
  350. X
  351. X
  352. /* ARGSUSED */
  353. static void HandleIgnore(w, event, params, param_count)
  354. X    Widget w;
  355. X    XEvent *event;        /* unused */
  356. X    String *params;        /* unused */
  357. X    Cardinal *param_count;    /* unused */
  358. {
  359. X    /* do nothing, but check for funny escape sequences */
  360. X    (void) SendMousePosition(w, event);
  361. }
  362. X
  363. X
  364. /* ARGSUSED */
  365. void DoSetSelectedFont(w, client_data, selection, type, value, length, format)
  366. X    Widget w;
  367. X    XtPointer client_data;
  368. X    Atom *selection, *type;
  369. X    XtPointer value;
  370. X    unsigned long *length;
  371. X    int *format;
  372. {
  373. X    char *val = (char *)value;
  374. X    int len;
  375. X    if (*type != XA_STRING || *format != 8) { Bell(); return; }
  376. X    len = strlen(value);
  377. X    if (len > 0) {
  378. X    if (val[len-1] == '\n') val[len-1] = '\0';
  379. X    if (!LoadNewFont (&term->screen, val, NULL, True, 
  380. X              fontMenu_fontescape))
  381. X      Bell();
  382. X    }
  383. }
  384. X
  385. void FindFontSelection (atom_name, justprobe)
  386. X    char *atom_name;
  387. X    Bool justprobe;
  388. {
  389. X    static AtomPtr *atoms;
  390. X    static int atomCount = 0;
  391. X    AtomPtr *pAtom;
  392. X    int a;
  393. X    Atom target;
  394. #ifdef KTERM
  395. X    int fnum = F_ISO8859_1;
  396. #endif /* KTERM */
  397. X
  398. X    if (!atom_name) atom_name = "PRIMARY";
  399. X
  400. X    for (pAtom = atoms, a = atomCount; a; a--, pAtom++) {
  401. X    if (strcmp(atom_name, XmuNameOfAtom(*pAtom)) == 0) break;
  402. X    }
  403. X    if (!a) {
  404. X    atoms = (AtomPtr*) XtRealloc (atoms, sizeof(AtomPtr)*(atomCount+1));
  405. X    *(pAtom = &atoms[atomCount++]) = XmuMakeAtom(atom_name);
  406. X    }
  407. X
  408. X    target = XmuInternAtom(XtDisplay(term), *pAtom);
  409. X    if (justprobe) {
  410. X    term->screen.menu_font_names[fontMenu_fontsel] = 
  411. X      XGetSelectionOwner(XtDisplay(term), target) ? _Font_Selected_ : NULL;
  412. X    } else {
  413. X    XtGetSelectionValue(term, target, XA_STRING,
  414. X                DoSetSelectedFont, NULL,
  415. X                XtLastTimestampProcessed(XtDisplay(term)));
  416. X    }
  417. X    return;
  418. }
  419. X
  420. X
  421. /* ARGSUSED */
  422. void HandleSetFont(w, event, params, param_count)
  423. X    Widget w;
  424. X    XEvent *event;        /* unused */
  425. X    String *params;        /* unused */
  426. X    Cardinal *param_count;    /* unused */
  427. {
  428. X    int fontnum;
  429. X    char *name1 = NULL, *name2 = NULL;
  430. X
  431. X    if (*param_count == 0) {
  432. X    fontnum = fontMenu_fontdefault;
  433. X    } else {
  434. X    int maxparams = 1;        /* total number of params allowed */
  435. X
  436. X    switch (params[0][0]) {
  437. X      case 'd': case 'D': case '0':
  438. X        fontnum = fontMenu_fontdefault; break;
  439. X      case '1':
  440. X        fontnum = fontMenu_font1; break;
  441. X      case '2':
  442. X        fontnum = fontMenu_font2; break;
  443. X      case '3':
  444. X        fontnum = fontMenu_font3; break;
  445. X      case '4':
  446. X        fontnum = fontMenu_font4; break;
  447. X      case 'e': case 'E':
  448. X        fontnum = fontMenu_fontescape; maxparams = 3; break;
  449. X      case 's': case 'S':
  450. X        fontnum = fontMenu_fontsel; maxparams = 2; break;
  451. X      default:
  452. X        Bell();
  453. X        return;
  454. X    }
  455. X    if (*param_count > maxparams) {     /* see if extra args given */
  456. X        Bell();
  457. X        return;
  458. X    }
  459. X    switch (*param_count) {        /* assign 'em */
  460. X      case 3:
  461. X        name2 = params[2];
  462. X        /* fall through */
  463. X      case 2:
  464. X        name1 = params[1];
  465. X        break;
  466. X    }
  467. X    }
  468. X
  469. X    SetVTFont (fontnum, True, name1, name2);
  470. }
  471. X
  472. X
  473. void SetVTFont (i, doresize, name1, name2)
  474. X    int i;
  475. X    Bool doresize;
  476. X    char *name1, *name2;
  477. {
  478. X    TScreen *screen = &term->screen;
  479. X
  480. X    if (i < 0 || i >= NMENUFONTS) {
  481. X    Bell();
  482. X    return;
  483. X    }
  484. X    if (i == fontMenu_fontsel) {    /* go get the selection */
  485. X    FindFontSelection (name1, False);  /* name1 = atom, name2 is ignored */
  486. X    return;
  487. X    }
  488. #ifndef KTERM
  489. X    if (!name1) name1 = screen->menu_font_names[i];
  490. #endif /* !KTERM */
  491. X    if (!LoadNewFont(screen, name1, name2, doresize, i)) {
  492. X    Bell();
  493. X    }
  494. X    return;
  495. }
  496. X
  497. X
  498. #ifdef KTERM
  499. static char *search_font_matching(screen, fontpattern, fonttail)
  500. TScreen *screen;
  501. char *fontpattern;
  502. char *fonttail;
  503. {
  504. X    static char **fontnamelist;
  505. X    char *tmptail;
  506. X    int count, i;
  507. X    int fonttaillen;
  508. X
  509. X    if (!fontpattern) return NULL;
  510. X
  511. X    fonttaillen = strlen(fonttail);
  512. X    if (fontnamelist) {
  513. X        XFreeFontNames(fontnamelist);
  514. X    }
  515. X    fontnamelist = XListFonts(screen->display, fontpattern, 1000, &count);
  516. X    for (i = 0; i < count; i ++) {
  517. X        tmptail = fontnamelist[i]+strlen(fontnamelist[i])-fonttaillen;
  518. X        if (XmuCompareISOLatin1(fonttail, tmptail) == 0) {
  519. X            return fontnamelist[i];
  520. X        }
  521. X    }
  522. X    return NULL;
  523. }
  524. #endif /* KTERM */
  525. X
  526. #ifdef KTERM
  527. int LoadNewFont (screen, nfontpat, bfontpat, doresize, fontnum)
  528. X    TScreen *screen;
  529. X    char *nfontpat, *bfontpat;
  530. #else /* !KTERM */
  531. int LoadNewFont (screen, nfontname, bfontname, doresize, fontnum)
  532. X    TScreen *screen;
  533. X    char *nfontname, *bfontname;
  534. #endif /* !KTERM */
  535. X    Bool doresize;
  536. X    int fontnum;
  537. {
  538. X    XFontStruct *nfs = NULL, *bfs = NULL;
  539. X    XGCValues xgcv;
  540. X    unsigned long mask;
  541. X    GC new_normalGC = NULL, new_normalboldGC = NULL;
  542. X    GC new_reverseGC = NULL, new_reverseboldGC = NULL;
  543. X    char *tmpname = NULL;
  544. #ifdef KTERM
  545. X    char *tmpbname = NULL;
  546. X    XFontStruct *asciinfs = NULL;
  547. X    int fnum;
  548. X    char *nfontname, *bfontname;
  549. X    static char *fonttail[FCNT] = {
  550. X    "-iso8859-1",
  551. X    "-jisx0201.1976-0",
  552. #ifdef KTERM_KANJI
  553. X    "-jisx0208.1983-0",
  554. #endif /* KTERM_KANJI */
  555. #ifdef KTERM_HANZI
  556. X        "-gb2312.1980-0",
  557. #endif /* KTERM_HANZI */
  558. #ifdef KTERM_HANGUL
  559. X        "-ksc5601.1987-0",
  560. #endif /* KTERM_HANGUL */
  561. X    };
  562. #endif /* KTERM */
  563. X
  564. #ifdef KTERM
  565. X  for (fnum = F_ISO8859_1; fnum < FCNT; fnum ++) {
  566. X
  567. X    nfontname = search_font_matching(screen, nfontpat, fonttail[fnum]);
  568. X
  569. X    if (!nfontname) {
  570. X        switch(term->misc.lang[0]) {
  571. #ifdef KTERM_HANZI
  572. X          case 'c': case 'C':
  573. X            if ((F_ISO8859_1 < fnum && fnum < F_GB2312_0) ||
  574. X                fnum > F_GB2312_0)
  575. X              continue;
  576. X            break;
  577. #endif /* KTERM_HANZI */
  578. #ifdef KTERM_HANGUL
  579. X          case 'k': case 'K':
  580. X            if ((F_ISO8859_1 < fnum && fnum < F_KSC5601_0) ||
  581. X                fnum > F_KSC5601_0)
  582. X              continue;
  583. X            break;
  584. #endif /* KTERM_HANGUL */
  585. X          default:
  586. X            if (fnum > F_JISX0208_0)
  587. X              continue;
  588. X            break;
  589. X        }
  590. X        nfontname = screen->menu_font_names[fontnum];
  591. X    }
  592. X
  593. X    if (!(nfontname && (nfs = XLoadQueryFont (screen->display, nfontname)))) {
  594. /**
  595. fprintf (stderr, "n%d: failed to load \"%s\"\n", fnum, nfontname);
  596. **/
  597. X    nfontname = search_font_matching(screen,
  598. X            screen->menu_font_list[fontnum], fonttail[fnum]);
  599. X    if (!(nfontname &&
  600. X          (nfs = XLoadQueryFont (screen->display, nfontname)))) {
  601. /**
  602. fprintf (stderr, "n%d: failed to load \"%s\"\n", fnum, nfontname);
  603. **/
  604. X        if (fnum > F_ISO8859_1) {
  605. X            nfs = asciinfs;
  606. X        } else goto bad;
  607. X    }
  608. X    }
  609. X    if (fnum == F_ISO8859_1) asciinfs = nfs;
  610. /**
  611. fprintf (stderr, "n%d: loaded \"%s\"\n", fnum, nfontname);
  612. **/
  613. X
  614. X    if (nfontname && fontnum == fontMenu_fontescape &&
  615. X    nfontname != screen->menu_font_names[fontnum]) {
  616. X    tmpname = (char *) malloc (strlen(nfontname) + 1);
  617. X    if (!tmpname) return 0;
  618. X    strcpy (tmpname, nfontname);
  619. X    }
  620. #else /* !KTERM */
  621. X    if (!nfontname) return 0;
  622. X
  623. X    if (fontnum == fontMenu_fontescape &&
  624. X    nfontname != screen->menu_font_names[fontnum]) {
  625. X    tmpname = (char *) malloc (strlen(nfontname) + 1);
  626. X    if (!tmpname) return 0;
  627. X    strcpy (tmpname, nfontname);
  628. X    }
  629. X
  630. X    if (!(nfs = XLoadQueryFont (screen->display, nfontname))) goto bad;
  631. #endif /* !KTERM */
  632. X
  633. #ifdef KTERM
  634. X    bfontname = search_font_matching(screen, bfontpat, fonttail[fnum]);
  635. X    if (!bfontname) bfontname = screen->menu_bfont_names[fontnum];
  636. X
  637. X    if (!(bfontname && (bfs = XLoadQueryFont (screen->display, bfontname)))) {
  638. /**
  639. fprintf (stderr, "b%d: failed to load \"%s\"\n", fnum, bfontname);
  640. **/
  641. X    bfontname = search_font_matching(screen,
  642. X            screen->menu_bfont_list[fontnum], fonttail[fnum]);
  643. X    if (!(bfontname &&
  644. X          (bfs = XLoadQueryFont (screen->display, bfontname)))) {
  645. /**
  646. fprintf (stderr, "b%d: failed to load \"%s\"\n", fnum, bfontname);
  647. **/
  648. X              bfs = nfs;
  649. X    }
  650. /**
  651. else fprintf (stderr, "b%d: loaded \"%s\"\n", fnum, bfontname);
  652. **/
  653. X    }
  654. /**
  655. else fprintf (stderr, "b%d: loaded \"%s\"\n", fnum, bfontname);
  656. **/
  657. X
  658. X    if (bfontname && fontnum == fontMenu_fontescape &&
  659. X    bfontname != screen->menu_bfont_names[fontnum]) {
  660. X    tmpbname = (char *) malloc (strlen(bfontname) + 1);
  661. X    if (!tmpbname) return 0;
  662. X    strcpy (tmpbname, bfontname);
  663. X    }
  664. #else /* !KTERM */
  665. X    if (!(bfontname && 
  666. X      (bfs = XLoadQueryFont (screen->display, bfontname))))
  667. X      bfs = nfs;
  668. #endif /* !KTERM */
  669. X
  670. X    mask = (GCFont | GCForeground | GCBackground | GCGraphicsExposures |
  671. X        GCFunction);
  672. X
  673. X    xgcv.font = nfs->fid;
  674. X    xgcv.foreground = screen->foreground;
  675. X    xgcv.background = term->core.background_pixel;
  676. X    xgcv.graphics_exposures = TRUE;    /* default */
  677. X    xgcv.function = GXcopy;
  678. X
  679. X    new_normalGC = XtGetGC((Widget)term, mask, &xgcv);
  680. X    if (!new_normalGC) goto bad;
  681. X
  682. X    if (nfs == bfs) {            /* there is no bold font */
  683. X    new_normalboldGC = new_normalGC;
  684. X    } else {
  685. X    xgcv.font = bfs->fid;
  686. X    new_normalboldGC = XtGetGC((Widget)term, mask, &xgcv);
  687. X    if (!new_normalboldGC) goto bad;
  688. X    }
  689. X
  690. X    xgcv.font = nfs->fid;
  691. X    xgcv.foreground = term->core.background_pixel;
  692. X    xgcv.background = screen->foreground;
  693. X    new_reverseGC = XtGetGC((Widget)term, mask, &xgcv);
  694. X    if (!new_reverseGC) goto bad;
  695. X
  696. X    if (nfs == bfs) {            /* there is no bold font */
  697. X    new_reverseboldGC = new_reverseGC;
  698. X    } else {
  699. X    xgcv.font = bfs->fid;
  700. X    new_reverseboldGC = XtGetGC((Widget)term, mask, &xgcv);
  701. X    if (!new_reverseboldGC) goto bad;
  702. X    }
  703. X
  704. X    XtReleaseGC ((Widget) term, screen->normalGC);
  705. X    if (screen->normalGC != screen->normalboldGC)
  706. X      XtReleaseGC ((Widget) term, screen->normalboldGC);
  707. X    XtReleaseGC ((Widget) term, screen->reverseGC);
  708. X    if (screen->reverseGC != screen->reverseboldGC)
  709. X      XtReleaseGC ((Widget) term, screen->reverseboldGC);
  710. X    screen->normalGC = new_normalGC;
  711. X    screen->normalboldGC = new_normalboldGC;
  712. X    screen->reverseGC = new_reverseGC;
  713. X    screen->reverseboldGC = new_reverseboldGC;
  714. X    screen->fnt_norm = nfs;
  715. X    screen->fnt_bold = bfs;
  716. X    screen->fnt_bold = screen->fnt_norm;
  717. X    screen->enbolden = (nfs == bfs);
  718. X    set_menu_font (False);
  719. X    screen->menu_font_number = fontnum;
  720. X    set_menu_font (True);
  721. X    if (tmpname) {            /* if setting escape or sel */
  722. X    if (screen->menu_font_names[fontnum])
  723. X      free (screen->menu_font_names[fontnum]);
  724. X    screen->menu_font_names[fontnum] = tmpname;
  725. X    if (fontnum == fontMenu_fontescape) {
  726. X        set_sensitivity (term->screen.fontMenu,
  727. X                 fontMenuEntries[fontMenu_fontescape].widget,
  728. X                 TRUE);
  729. X    }
  730. X    }
  731. #ifdef KTERM
  732. X    set_cursor_gcs (screen, fnum);
  733. X  }
  734. #else /* !KTERM */
  735. X    set_cursor_gcs (screen);
  736. #endif /* !KTERM */
  737. X    update_font_info (screen, doresize);
  738. X    return 1;
  739. X
  740. X  bad:
  741. X    if (tmpname) free (tmpname);
  742. X    if (new_normalGC)
  743. X      XtReleaseGC ((Widget) term, screen->normalGC);
  744. X    if (new_normalGC && new_normalGC != new_normalboldGC)
  745. X      XtReleaseGC ((Widget) term, new_normalboldGC);
  746. X    if (new_reverseGC)
  747. X      XtReleaseGC ((Widget) term, new_reverseGC);
  748. X    if (new_reverseGC && new_reverseGC != new_reverseboldGC)
  749. X      XtReleaseGC ((Widget) term, new_reverseboldGC);
  750. X    if (nfs) XFreeFont (screen->display, nfs);
  751. X    if (nfs && nfs != bfs) XFreeFont (screen->display, bfs);
  752. X    return 0;
  753. }
  754. X
  755. X
  756. update_font_info (screen, doresize)
  757. X    TScreen *screen;
  758. X    Bool doresize;
  759. {
  760. X    int i, j, width, height, scrollbar_width;
  761. #ifdef KTERM
  762. X    int fnum;
  763. X    int max_ascent = 0, max_descent = 0, max_width = 0;
  764. X
  765. X    for (fnum = F_ISO8859_1; fnum < FCNT; fnum ++) {
  766. X    if (screen->_fnt_norm[fnum]) {
  767. #ifdef KTERM_KANJI
  768. X      if (screen->_fnt_norm[fnum]->max_byte1 > 0) { /* MB font */
  769. X        if (max_width < screen->_fnt_norm[fnum]->max_bounds.width/2) {
  770. X        max_width = screen->_fnt_norm[fnum]->max_bounds.width/2;
  771. X        }
  772. X      } else
  773. #endif /* KTERM_KANJI */
  774. X        if (max_width < screen->_fnt_norm[fnum]->max_bounds.width) {
  775. X        max_width = screen->_fnt_norm[fnum]->max_bounds.width;
  776. X        }
  777. X    }
  778. X    }
  779. X    screen->fullVwin.f_width = max_width;
  780. X    for (fnum = F_ISO8859_1; fnum < FCNT; fnum ++) {
  781. X    if (screen->_fnt_norm[fnum]) {
  782. X        if (max_ascent < screen->_fnt_norm[fnum]->ascent) {
  783. X        max_ascent = screen->_fnt_norm[fnum]->ascent;
  784. X        }
  785. X        if (max_descent < screen->_fnt_norm[fnum]->descent) {
  786. X        max_descent = screen->_fnt_norm[fnum]->descent;
  787. X        }
  788. X    }
  789. X    }
  790. X    screen->max_ascent = max_ascent;
  791. X    screen->max_descent = max_descent;
  792. X    screen->fullVwin.f_height = max_ascent + max_descent;
  793. #else /* !KTERM */
  794. X
  795. X    screen->fullVwin.f_width = screen->fnt_norm->max_bounds.width;
  796. X    screen->fullVwin.f_height = (screen->fnt_norm->ascent +
  797. X                 screen->fnt_norm->descent);
  798. #endif /* !KTERM */
  799. X    scrollbar_width = (term->misc.scrollbar ? 
  800. X               screen->scrollWidget->core.width : 0);
  801. X    i = 2 * screen->border + scrollbar_width;
  802. X    j = 2 * screen->border;
  803. #ifdef STATUSLINE
  804. X    if (screen->statusline)
  805. #ifdef KTERM
  806. X    j += (screen->statusheight = FontHeight(screen) + 2);
  807. #else /* !KTERM */
  808. X    j += (screen->statusheight = screen->fullVwin.f_height + 2);
  809. #endif /* !KTERM */
  810. #endif /* STATUSLINE */
  811. #ifdef KTERM
  812. X    width = (screen->max_col + 1) * FontWidth(screen) + i;
  813. X    height = (screen->max_row + 1) * FontHeight(screen) + j;
  814. #else /* !KTERM */
  815. X    width = (screen->max_col + 1) * screen->fullVwin.f_width + i;
  816. X    height = (screen->max_row + 1) * screen->fullVwin.f_height + j;
  817. #endif /* !KTERM */
  818. X    screen->fullVwin.fullwidth = width;
  819. X    screen->fullVwin.fullheight = height;
  820. X    screen->fullVwin.width = width - i;
  821. X    screen->fullVwin.height = height - j;
  822. X
  823. X    if (doresize) {
  824. X    if (VWindow(screen)) {
  825. X        XClearWindow (screen->display, VWindow(screen));
  826. X    }
  827. X    DoResizeScreen (term);        /* set to the new natural size */
  828. X    if (screen->scrollWidget)
  829. X      ResizeScrollBar (screen->scrollWidget, -1, -1,
  830. X               Height(screen) + screen->border * 2);
  831. X    Redraw ();
  832. X    }
  833. X    set_vt_box (screen);
  834. }
  835. X
  836. set_vt_box (screen)
  837. X    TScreen *screen;
  838. {
  839. X    XPoint    *vp;
  840. X
  841. #ifdef KTERM
  842. X    vp = &VTbox[1];
  843. X    (vp++)->x = FontWidth(screen) - 1;
  844. X    (vp++)->y = screen->fullVwin.f_height - 1;
  845. X    (vp++)->x = -(FontWidth(screen) - 1);
  846. X    vp->y = -(screen->fullVwin.f_height - 1);
  847. X    screen->_box[F_ISO8859_1] = VTbox;
  848. X    screen->_box[F_JISX0201_0] = VTbox;
  849. # ifdef KTERM_KANJI
  850. X    vp = &VTwbox[1];
  851. X    (vp++)->x = FontWidth(screen) * 2 - 1;
  852. X    (vp++)->y = screen->fullVwin.f_height - 1;
  853. X    (vp++)->x = -(FontWidth(screen) * 2 - 1);
  854. X    vp->y = -(screen->fullVwin.f_height - 1);
  855. X        switch(term->misc.lang[0]) {
  856. #ifdef KTERM_HANZI
  857. X          case 'c': case 'C':
  858. X            screen->_box[F_GB2312_0] = VTwbox;
  859. X            break;
  860. #endif /* KTERM_HANZI */
  861. #ifdef KTERM_HANGUL
  862. X          case 'k': case 'K':
  863. X            screen->_box[F_KSC5601_0] = VTwbox;
  864. X            break;
  865. #endif /* KTERM_HANGUL */
  866. X          default:
  867. X            screen->_box[F_JISX0208_0] = VTwbox;
  868. X            break;
  869. X        }
  870. # endif /* KTERM_KANJI */
  871. #else /* !KTERM */
  872. X    vp = &VTbox[1];
  873. X    (vp++)->x = FontWidth(screen) - 1;
  874. X    (vp++)->y = FontHeight(screen) - 1;
  875. X    (vp++)->x = -(FontWidth(screen) - 1);
  876. X    vp->y = -(FontHeight(screen) - 1);
  877. X    screen->box = VTbox;
  878. #endif /* !KTERM */
  879. }
  880. X
  881. X
  882. #ifdef KTERM
  883. set_cursor_gcs (screen, fnum)
  884. X    int fnum;
  885. #else /* !KTERM */
  886. set_cursor_gcs (screen)
  887. #endif /* !KTERM */
  888. X    TScreen *screen;
  889. {
  890. X    XGCValues xgcv;
  891. X    unsigned long mask;
  892. X    unsigned long cc = screen->cursorcolor;
  893. X    unsigned long fg = screen->foreground;
  894. X    unsigned long bg = term->core.background_pixel;
  895. X    GC new_cursorGC = NULL, new_reversecursorGC = NULL;
  896. X    GC new_cursoroutlineGC = NULL;
  897. X
  898. X    /*
  899. X     * Let's see, there are three things that have "color":
  900. X     *
  901. X     *     background
  902. X     *     text
  903. X     *     cursorblock
  904. X     *
  905. X     * And, there are four situation when drawing a cursor, if we decide
  906. X     * that we like have a solid block of cursor color with the letter
  907. X     * that it is highlighting shown in the background color to make it
  908. X     * stand out:
  909. X     *
  910. X     *     selected window, normal video - background on cursor
  911. X     *     selected window, reverse video - foreground on cursor
  912. X     *     unselected window, normal video - foreground on background
  913. X     *     unselected window, reverse video - background on foreground
  914. X     *
  915. X     * Since the last two are really just normalGC and reverseGC, we only
  916. X     * need two new GC's.  Under monochrome, we get the same effect as
  917. X     * above by setting cursor color to foreground.
  918. X     */
  919. X
  920. X    xgcv.font = screen->fnt_norm->fid;
  921. X    mask = (GCForeground | GCBackground | GCFont);
  922. X    if (cc != fg && cc != bg) {
  923. X    /* we have a colored cursor */
  924. X    xgcv.foreground = fg;
  925. X    xgcv.background = cc;
  926. X    new_cursorGC = XtGetGC ((Widget) term, mask, &xgcv);
  927. X
  928. X    if (screen->always_highlight) {
  929. X        new_reversecursorGC = (GC) 0;
  930. X        new_cursoroutlineGC = (GC) 0;
  931. X    } else {
  932. X        xgcv.foreground = bg;
  933. X        xgcv.background = cc;
  934. X        new_reversecursorGC = XtGetGC ((Widget) term, mask, &xgcv);
  935. X        xgcv.foreground = cc;
  936. X        xgcv.background = bg;
  937. X        new_cursoroutlineGC = XtGetGC ((Widget) term, mask, &xgcv);
  938. X        }
  939. X    } else {
  940. X    new_cursorGC = (GC) 0;
  941. X    new_reversecursorGC = (GC) 0;
  942. X    new_cursoroutlineGC = (GC) 0;
  943. X    }
  944. X    if (screen->cursorGC) XtReleaseGC (term, screen->cursorGC);
  945. X    if (screen->reversecursorGC) XtReleaseGC (term, screen->reversecursorGC);
  946. X    if (screen->cursoroutlineGC) XtReleaseGC (term, screen->cursoroutlineGC);
  947. X    screen->cursorGC = new_cursorGC;
  948. X    screen->reversecursorGC = new_reversecursorGC;
  949. X    screen->cursoroutlineGC = new_cursoroutlineGC;
  950. }
  951. SHAR_EOF
  952. echo 'File kterm-4.1.2/charproc.c is complete' &&
  953. chmod 0664 kterm-4.1.2/charproc.c ||
  954. echo 'restore of kterm-4.1.2/charproc.c failed'
  955. Wc_c="`wc -c < 'kterm-4.1.2/charproc.c'`"
  956. test 139105 -eq "$Wc_c" ||
  957.     echo 'kterm-4.1.2/charproc.c: original size 139105, current size' "$Wc_c"
  958. rm -f _shar_wnt_.tmp
  959. fi
  960. # ============= kterm-4.1.2/colortest ==============
  961. if test -f 'kterm-4.1.2/colortest' -a X"$1" != X"-c"; then
  962.     echo 'x - skipping kterm-4.1.2/colortest (File already exists)'
  963.     rm -f _shar_wnt_.tmp
  964. else
  965. > _shar_wnt_.tmp
  966. echo 'x - extracting kterm-4.1.2/colortest (Text)'
  967. sed 's/^X//' << 'SHAR_EOF' > 'kterm-4.1.2/colortest' &&
  968. #!/bin/sh
  969. X
  970. for f in 0 4 1 5 2 6 3 7
  971. do
  972. X    echo '[3'${f}'m  $@%+%i!<%F%-%9%HBP1~$N(J [4'${f}'m kterm [3'${f}'m $@$G$9!#(J("^[[X'${f}'m")'
  973. done
  974. echo "[0m"
  975. Xexit 0
  976. SHAR_EOF
  977. chmod 0775 kterm-4.1.2/colortest ||
  978. echo 'restore of kterm-4.1.2/colortest failed'
  979. Wc_c="`wc -c < 'kterm-4.1.2/colortest'`"
  980. test 166 -eq "$Wc_c" ||
  981.     echo 'kterm-4.1.2/colortest: original size 166, current size' "$Wc_c"
  982. rm -f _shar_wnt_.tmp
  983. fi
  984. # ============= kterm-4.1.2/convert.c ==============
  985. if test -f 'kterm-4.1.2/convert.c' -a X"$1" != X"-c"; then
  986.     echo 'x - skipping kterm-4.1.2/convert.c (File already exists)'
  987.     rm -f _shar_wnt_.tmp
  988. else
  989. > _shar_wnt_.tmp
  990. echo 'x - extracting kterm-4.1.2/convert.c (Text)'
  991. sed 's/^X//' << 'SHAR_EOF' > 'kterm-4.1.2/convert.c' &&
  992. /*
  993. X *    convert.c -- code converters for kterm
  994. X *    $Kagotani: /usr/src.yoshi/X/KTerm/4.1.0/RCS/convert.c,v 1.1 90/06/27 09:38:46 kagotani Rel $
  995. X *
  996. X * $Header: /usr/local/src/X11/contrib/clients/kterm-4.1.2/RCS/convert.c,v 1.5 1991/03/15 09:28:40 mleisher Exp $
  997. X */
  998. X
  999. /*
  1000. X * Modified for Hanzi support:
  1001. X * Mark Leisher mleisher@nmsu.edu Fri Nov  9 09:22:33 1990
  1002. X */
  1003. X
  1004. /*
  1005. X * Copyright (c) 1989  Software Research Associates, Inc.
  1006. X *
  1007. X * Permission to use, copy, modify, and distribute this software and its
  1008. X * documentation for any purpose and without fee is hereby granted, provided
  1009. X * that the above copyright notice appear in all copies and that both that
  1010. X * copyright notice and this permission notice appear in supporting
  1011. X * documentation, and that the name of Software Research Associates not be
  1012. X * used in advertising or publicity pertaining to distribution of the
  1013. X * software without specific, written prior permission.  Software Research
  1014. X * Associates makes no representations about the suitability of this software
  1015. X * for any purpose.  It is provided "as is" without express or implied
  1016. X * warranty.
  1017. X *
  1018. X * Author:  Makoto Ishisone, Software Research Associates, Inc., Japan
  1019. X */
  1020. #include <stdio.h>
  1021. #include "kterm.h"
  1022. X
  1023. #ifdef KTERM_HANZI
  1024. #include "hzutil.h"
  1025. #endif /* KTERM HANZI */
  1026. X
  1027. #ifdef KTERM_HANGUL
  1028. #include "hgutil.h"
  1029. #endif /* KTERM_HANGUL */
  1030. X
  1031. #ifdef KTERM
  1032. X
  1033. #define NULL    0
  1034. #define SS2    0x8E
  1035. #define CSI    0x9B
  1036. X
  1037. #ifdef KTERM_HANZI
  1038. X
  1039. Ichr *
  1040. convNSHzToGB(hz, from)
  1041. Ichr *hz;
  1042. int from;
  1043. {
  1044. X    Ichr *ptr;
  1045. X    int i, j, len = 0;
  1046. X    unsigned char c1, c2, oc1, oc2, gs1, gs2;
  1047. X
  1048. X    i = 0;
  1049. X    while(hz[i++].code) len++;
  1050. X    ptr = (Ichr *)XtMalloc((len + 1) * sizeof(Ichr));
  1051. X
  1052. X    i = j = 0;
  1053. X    while(i < len) {
  1054. X        gs1 = hz[i].gset;
  1055. X        c1 = hz[i].code;
  1056. X        if (gs1 != GSET_HANZI) {
  1057. X            ptr[j].gset = gs1;
  1058. X            ptr[j++].code = c1;
  1059. X        } else {
  1060. X            i++;
  1061. X            gs2 = hz[i].gset;
  1062. X            c2 = hz[i].code;
  1063. X            hzconvert(from, c1, c2, &oc1, &oc2);
  1064. X            ptr[j].gset = gs1;
  1065. X            ptr[j++].code = oc1;
  1066. X            ptr[j].gset = gs2;
  1067. X            ptr[j++].code = oc2;
  1068. X        }
  1069. X        i++;
  1070. X    }
  1071. X    ptr[j].gset = 0;
  1072. X    ptr[j].code = '\0';
  1073. X    return(ptr);
  1074. }
  1075. X
  1076. /* CS -> GUOBIAO */
  1077. static int
  1078. CStoGB(cs_p, gs_p)
  1079. Ichr        **cs_p;
  1080. unsigned char    **gs_p;
  1081. {
  1082. X    int        c1, c2;
  1083. X    Ichr        *cs = *cs_p;
  1084. X    unsigned char    *gs = *gs_p;
  1085. X
  1086. X        if (cs->gset == GSET_HANZI) {
  1087. X            c1 = cs++->code;
  1088. X            c2 = cs++->code;
  1089. X            if (gs) {
  1090. X                *gs++ = c1 | 0x80;
  1091. X                *gs++ = c2 | 0x80;
  1092. X            }
  1093. X            *gs_p = gs;
  1094. X            *cs_p = cs;
  1095. X            return(2);
  1096. X        }
  1097. X        return(0);
  1098. }
  1099. X
  1100. /* CS -> SGB */
  1101. static int
  1102. CStoSGB(cs_p, sgs_p)
  1103. Ichr        **cs_p;
  1104. unsigned char    **sgs_p;
  1105. {
  1106. X        int             c1, c2;
  1107. X    Ichr        *cs = *cs_p;
  1108. X    unsigned char    *sgs = *sgs_p;
  1109. X        unsigned char   oc1, oc2;
  1110. X
  1111. X        if (cs->gset == GSET_HANZI) {
  1112. X            c1 = cs++->code;
  1113. X            c2 = cs++->code;
  1114. X            if (sgs) {
  1115. X                hzconvert(GBtoSGB, c1, c2, &oc1, &oc2);
  1116. X                *sgs++ = oc1 | 0x80;
  1117. X                *sgs++ = oc2 | 0x80;
  1118. X            }
  1119. X            *sgs_p = sgs;
  1120. X            *cs_p = cs;
  1121. X            return(2);
  1122. X        }
  1123. X        return(0);
  1124. }
  1125. X
  1126. /* CS -> BIG5 */
  1127. static int
  1128. CStoBIG5(cs_p, bs_p)
  1129. Ichr        **cs_p;
  1130. unsigned char    **bs_p;
  1131. {
  1132. X    int        c1, c2;
  1133. X    Ichr        *cs = *cs_p;
  1134. X    unsigned char    *bs = *bs_p;
  1135. X        unsigned char    ch1, ch2, och1, och2;
  1136. X
  1137. X        if (cs->gset == GSET_HANZI) {
  1138. X            c1 = cs++->code;
  1139. X            c2 = cs++->code;
  1140. X            if (bs) {
  1141. X                ch1 = c1 | 0x80;
  1142. X                ch2 = c2 | 0x80;
  1143. X                hzconvert(GBtoBIG, ch1, ch2, &och1, &och2);
  1144. X                *bs++ = och1;
  1145. X                *bs++ = och2;
  1146. X            }
  1147. X            *bs_p = bs;
  1148. X            *cs_p = cs;
  1149. X            return(2);
  1150. X        }
  1151. X        return(0);
  1152. }
  1153. X
  1154. /* CS -> GUOBIAO using ESC-$-A */
  1155. int
  1156. convCStoGB(cs, gs)
  1157. Ichr           *cs;
  1158. unsigned char  *gs;
  1159. {
  1160. X    return convCStoANY(cs, gs, CStoGB);
  1161. }
  1162. X
  1163. /* CS -> SGB using ESC-$-A */
  1164. int
  1165. convCStoSGB(cs, sgs)
  1166. Ichr           *cs;
  1167. unsigned char  *sgs;
  1168. {
  1169. X    return convCStoANY(cs, sgs, CStoSGB);
  1170. }
  1171. X
  1172. /* CS -> BIG5 using ESC-$-A */
  1173. int
  1174. convCStoBIG5(cs, bs)
  1175. Ichr           *cs;
  1176. unsigned char  *bs;
  1177. {
  1178. X    return convCStoANY(cs, bs, CStoBIG5);
  1179. }
  1180. #endif /* KTERM_HANZI */
  1181. X
  1182. #ifdef KTERM_HANGUL
  1183. /* CS -> KS */
  1184. static int
  1185. CStoKS(cs_p, ks_p)
  1186. Ichr        **cs_p;
  1187. unsigned char    **ks_p;
  1188. {
  1189. X    int        c1, c2;
  1190. X    Ichr        *cs = *cs_p;
  1191. X    unsigned char    *ks = *ks_p;
  1192. X
  1193. X        if (cs->gset == GSET_HANGUL) {
  1194. X            c1 = cs++->code;
  1195. X            c2 = cs++->code;
  1196. X            if (ks) {
  1197. X                *ks++ = c1 | 0x80;
  1198. X                *ks++ = c2 | 0x80;
  1199. X            }
  1200. X            *ks_p = ks;
  1201. X            *cs_p = cs;
  1202. X            return(2);
  1203. X        }
  1204. X        return(0);
  1205. }
  1206. X
  1207. /* CS -> KS using ESC-$-C */
  1208. int
  1209. convCStoKS(cs, ks)
  1210. Ichr        *cs;
  1211. unsigned char    *ks;
  1212. {
  1213. X    return convCStoANY(cs, ks, CStoKS);
  1214. }
  1215. #endif /* KTERM_HANGUL */
  1216. X
  1217. X
  1218. /* CS -> JIS using ESC-$-B */
  1219. int
  1220. convCStoJIS(cs, js)
  1221. Ichr        *cs;
  1222. unsigned char    *js;
  1223. {
  1224. X    return convCStoANY(cs, js, NULL);
  1225. }
  1226. X
  1227. /* CS -> EUC */
  1228. static int
  1229. CStoEUC(cs_p, es_p)
  1230. Ichr        **cs_p;
  1231. unsigned char    **es_p;
  1232. {
  1233. X    int        c1, c2;
  1234. X    Ichr        *cs = *cs_p;
  1235. X    unsigned char    *es = *es_p;
  1236. X    if (cs->gset == GSET_KANA) {
  1237. X        c1 = cs++->code;
  1238. X        if (es) {
  1239. X            *es++ = SS2;
  1240. X            *es++ = c1 | 0x80;
  1241. X        }
  1242. X        *es_p = es;
  1243. X        *cs_p = cs;
  1244. X        return 2;
  1245. X    } else if (cs->gset == GSET_KANJI
  1246. X        || cs->gset == GSET_OLDKANJI) {
  1247. X        c1 = cs++->code;
  1248. X        c2 = cs++->code;
  1249. X        if (es) {
  1250. X            *es++ = c1 | 0x80;
  1251. X            *es++ = c2 | 0x80;
  1252. X        }
  1253. X        *es_p = es;
  1254. X        *cs_p = cs;
  1255. X        return 2;
  1256. X    }
  1257. X    return 0;
  1258. }
  1259. X
  1260. int
  1261. convCStoEUC(cs, es)
  1262. Ichr        *cs;
  1263. unsigned char    *es;
  1264. {
  1265. X    return convCStoANY(cs, es, CStoEUC);
  1266. }
  1267. X
  1268. /* CS -> SJIS */
  1269. static int
  1270. CStoSJIS(cs_p, ss_p)
  1271. Ichr        **cs_p;
  1272. unsigned char    **ss_p;
  1273. {
  1274. X    int        c1, c2;
  1275. X    Ichr        *cs = *cs_p;
  1276. X    unsigned char    *ss = *ss_p;
  1277. X    if (cs->gset == GSET_KANA) {
  1278. X        c1 = cs++->code;
  1279. X        if (ss) {
  1280. X            *ss++ = c1 | 0x80;
  1281. X        }
  1282. X        *ss_p = ss;
  1283. X        *cs_p = cs;
  1284. X        return 1;
  1285. X    } else if (cs->gset == GSET_KANJI || cs->gset == GSET_OLDKANJI) {
  1286. X        c1 = cs++->code;
  1287. X        c2 = cs++->code;
  1288. X        if (ss) {
  1289. X            *ss++ = (c1 - 0x21) / 2 + ((c1 <= 0x5e) ? 0x81 : 0xc1);
  1290. X            if (c1 & 1)    /* odd */
  1291. X                *ss++ = c2 + ((c2 <= 0x5f) ? 0x1f : 0x20);
  1292. X            else
  1293. X                *ss++ = c2 + 0x7e;
  1294. X        }
  1295. X        *ss_p = ss;
  1296. X        *cs_p = cs;
  1297. X        return 2;
  1298. X    }
  1299. X    return 0;
  1300. }
  1301. X
  1302. int
  1303. convCStoSJIS(cs, ss)
  1304. Ichr        *cs;
  1305. unsigned char    *ss;
  1306. {
  1307. X    return convCStoANY(cs, ss, CStoSJIS);
  1308. }
  1309. X
  1310. /* CS -> any */
  1311. int
  1312. convCStoANY(cs, as, func)
  1313. Ichr        *cs;
  1314. unsigned char    *as;
  1315. int        (*func)();
  1316. {
  1317. X    register int    c1, c2;
  1318. X    register int    gset = GSET_ASCII;
  1319. X    register int    n = 0, m;
  1320. X
  1321. X    while (c1 = cs->code) {
  1322. X        if (func && (m = (*func)(&cs, &as))) {
  1323. X            n += m;
  1324. X            continue;
  1325. X        }
  1326. X        if (gset != cs->gset) {
  1327. X            if (gset & CS96 && !(cs->gset & CS96)) {
  1328. X                if (as)
  1329. X                    *as++ = '\025'; /* SI */
  1330. X                n++;
  1331. X            } else if (!(gset & CS96) && cs->gset & CS96) {
  1332. X                if (as)
  1333. X                    *as++ = '\024'; /* SO */
  1334. X                n++;
  1335. X            }
  1336. X            /*
  1337. X             *    A HACK FOR JISROMAN
  1338. X             */
  1339. X            if (cs->gset == GSET_ASCII
  1340. X             || cs->gset == GSET_JISROMAN) {
  1341. X                if (gset != GSET_ASCII
  1342. X                 && gset != GSET_JISROMAN) {
  1343. X                    if (as) {
  1344. X                        *as++ = '\033';
  1345. X                        *as++ = '(';
  1346. X                        *as++ = TESG(cs->gset);
  1347. X                    }
  1348. X                    n += 3;
  1349. X                }
  1350. X            } else if (cs->gset == GSET_KANJI
  1351. X            /*
  1352. X             * if (cs->gset == GSET_KANJI
  1353. X             */
  1354. X             || cs->gset == GSET_OLDKANJI) {
  1355. X                if (as) {
  1356. X                    *as++ = '\033';
  1357. X                    *as++ = '$';
  1358. X                    *as++ = TESG(cs->gset);
  1359. X                }
  1360. X                n += 3;
  1361. X            } else {
  1362. X                if (as) {
  1363. X                    *as++ = '\033';
  1364. X                    if (cs->gset & MBCS) {
  1365. X                        *as++ = '$';
  1366. X                    }
  1367. X                    if (cs->gset & CS96) {
  1368. X                        *as++ = '-';
  1369. X                    } else {
  1370. X                        *as++ = '(';
  1371. X                    }
  1372. X                    *as++ = TESG(cs->gset);
  1373. X                }
  1374. X                n += 3;
  1375. X                if (cs->gset & MBCS)
  1376. X                    n ++;
  1377. X            }
  1378. X            gset = cs->gset;
  1379. X        }
  1380. X        cs++;
  1381. X        if (gset & MBCS) {
  1382. X            c2 = cs++->code;
  1383. X            if (as) {
  1384. X                *as++ = c1 & ~0x80;
  1385. X                *as++ = c2 & ~0x80;
  1386. X            }
  1387. X            n += 2;
  1388. X        } else {
  1389. X            if (as)
  1390. X                *as++ = c1 & ~0x80;
  1391. X            n++;
  1392. X        }
  1393. X    }
  1394. X    /*
  1395. X     *    A HACK FOR JISROMAN
  1396. X     * if (gset != GSET_ASCII) {
  1397. X     */
  1398. X    if (gset != GSET_ASCII && gset != GSET_JISROMAN) {
  1399. X        if (as) {
  1400. X            *as++ = '\033';
  1401. X            *as++ = '(';
  1402. X            *as++ = 'B';
  1403. X        }
  1404. X        n += 3;
  1405. X    }
  1406. X    if (as)
  1407. X        *as = '\0';
  1408. X
  1409. X    return n;
  1410. }
  1411. X
  1412. /* CS -> ISO Latin-1 */
  1413. int
  1414. convCStoLatin1(cs, ls)
  1415. Ichr *cs;
  1416. unsigned char *ls;
  1417. {
  1418. X    register int    c;
  1419. X    register int    n = 0;
  1420. X
  1421. X    if (ls) {
  1422. X        while (c = cs->code) {
  1423. X            if (cs++->gset == GSET_ASCII) {
  1424. X                *ls++ = c & 0x7f;
  1425. X                n++;
  1426. X            }
  1427. X        }
  1428. X        *ls = '\0';
  1429. X    } else {
  1430. X        while (c = cs->code) {
  1431. X            if (cs++->gset == GSET_ASCII) {
  1432. X                n++;
  1433. X            }
  1434. X        }
  1435. X    }
  1436. X    return n;
  1437. }
  1438. X
  1439. /******************************************************************************
  1440. COMPOUND_TEXT Summary
  1441. X  (based on Comopund Text Encoding Version 1 -- MIT X Consortium Standard)
  1442. (1) Only G0 and G1 are used. G2 and G3 are not.
  1443. (2) G0 is invoked into GL and G1 into GR. These invocation are not changed.
  1444. X    (In other words, Locking Shift and Single Shift are not used)
  1445. (3) In initial state, ISO Latin-1 is designated into G0/G1.
  1446. (4) To designate MBCS into G0, ESC-$-F is not used but ESC-$-(-F.
  1447. (5) In C0, only HT, NL, and ESC are used.
  1448. (6) In C1, only CSI is used.
  1449. (7) Text direction can be indecated.
  1450. X    begin left-to-right string
  1451. X    begin right-to-left string
  1452. X    end of string
  1453. ******************************************************************************/
  1454. X
  1455. /* convCStoCT -- Wide Character String -> COMPOUND_TEXT */
  1456. int
  1457. convCStoCT(cs, as)
  1458. register Ichr *cs;
  1459. register unsigned char *as;
  1460. /* Convert Wide Character String cs to COMPOUND_TEXT xstr, return
  1461. X * length of xstr in bytes (not including the terminating null character).
  1462. X * If xstr is NULL, no conversion is done, but return length of xstr.
  1463. X */
  1464. {
  1465. X    register int    c1, c2;
  1466. X    register int    g0 = GSET_ASCII;
  1467. X    register int    g1 = GSET_LATIN1R;
  1468. X    register int    n = 0;
  1469. X
  1470. X    while (c1 = cs->code) {
  1471. X        if (cs->gset & CS96
  1472. X         || cs->gset & MBCS
  1473. X         || cs->gset == GSET_KANA) {
  1474. X        if (g1 != cs->gset) {
  1475. X            g1 = cs->gset;
  1476. X            if (as) {
  1477. X                *as++ = '\033';
  1478. X                if (g1 & MBCS) {
  1479. X                    *as++ = '$';
  1480. X                }
  1481. X                if (g1 & CS96) {
  1482. X                    *as++ = '-';
  1483. X                } else {
  1484. X                    *as++ = ')';
  1485. X                }
  1486. X                *as++ = TESG(g1);
  1487. X            }
  1488. X            n += 3;
  1489. X            if (g1 & MBCS)
  1490. X                n ++;
  1491. X        }
  1492. X        cs++;
  1493. X        if (g1 & MBCS) {
  1494. X            c2 = cs++->code;
  1495. X            if (as) {
  1496. X                *as++ = c1 | 0x80;
  1497. X                *as++ = c2 | 0x80;
  1498. X            }
  1499. X            n += 2;
  1500. X        } else {
  1501. X            if (as)
  1502. X                *as++ = c1 | 0x80;
  1503. X            n++;
  1504. X        }
  1505. X        } else {
  1506. X        if (g0 != cs->gset) {
  1507. X            g0 = cs->gset;
  1508. X            if (as) {
  1509. X                *as++ = '\033';
  1510. X                *as++ = '(';
  1511. X                *as++ = TESG(g0);
  1512. X            }
  1513. X            n += 3;
  1514. X        }
  1515. X        cs++;
  1516. X        if (as)
  1517. X            *as++ = c1 & ~0x80;
  1518. X        n++;
  1519. X        }
  1520. X    }
  1521. X    if (g0 != GSET_ASCII) {
  1522. X        if (as) {
  1523. X            *as++ = '\033';
  1524. X            *as++ = '(';
  1525. X            *as++ = 'B';
  1526. X        }
  1527. X        n += 3;
  1528. X    }
  1529. X    if (as)
  1530. X        *as = '\0';
  1531. X
  1532. X    return n;
  1533. }
  1534. X
  1535. static unsigned char *
  1536. getesc(str, len)
  1537. unsigned char *str;
  1538. int len;
  1539. {
  1540. X    register int    c;
  1541. X
  1542. X    /* Find intermediate characters and final character
  1543. X     * following the escape character in an escape sequence.
  1544. X     */
  1545. X    /* The intermediate character is 02/00 to 02/15 */
  1546. X    while (len > 0) {
  1547. X        c = *str;
  1548. X        if (c < 0x20 || 0x2f < c)
  1549. X            break;
  1550. X        len--, str++;
  1551. X    }
  1552. X    /* The final character is 03/00 to 07/14 */
  1553. X    if (--len < 0 || (c = *str++) < 0x30 || 0x7e < c)
  1554. X        return (unsigned char *)NULL;
  1555. X
  1556. X    return str;
  1557. }
  1558. X
  1559. static unsigned char *
  1560. getcsi(str, len)
  1561. unsigned char *str;
  1562. int len;
  1563. {
  1564. X    register int    c;
  1565. X
  1566. X    /* Find parameter characters, intermediate characters
  1567. X     * and final character following the CSI character
  1568. X     * in a CSI sequence.
  1569. X     */
  1570. X    /* The parameter characters is 03/00 to 03/15 */
  1571. X    while (len > 0) {
  1572. X        c = *str;
  1573. X        if (c < 0x30 || 0x3f < c)
  1574. X            break;
  1575. X        len--, str++;
  1576. X    }
  1577. X    /* The intermediate character is 02/00 to 02/15 */
  1578. X    while (len > 0) {
  1579. X        c = *str;
  1580. X        if (c < 0x20 || 0x2f < c)
  1581. X            break;
  1582. X        len--, str++;
  1583. X    }
  1584. X    /* The final character is 04/00 to 07/14 */
  1585. X    if (--len < 0 || (c = *str++) < 0x40 || 0x7e < c)
  1586. X        return (unsigned char *)NULL;
  1587. X
  1588. X    return str;
  1589. }
  1590. X
  1591. /* convCTtoCS -- COMPOUND_TEXT -> Wide Character String */
  1592. int
  1593. convCTtoCS(xstr, len, cs)
  1594. register unsigned char *xstr;
  1595. int len;
  1596. Ichr *cs;
  1597. /* Convert COMPOUND_TEXT xstr to Wide Character String cs, return
  1598. X * length of cs in characters (not including the terminating null character).
  1599. X * If cs is NULL, no conversion is done, but return length of cs.
  1600. X */
  1601. {
  1602. X    register int    c;
  1603. X    int    nskip;
  1604. X    int    n = 0;
  1605. X    int    g0, g1, gs;
  1606. X    unsigned char    *xstr1;
  1607. X
  1608. X    /*
  1609. X     * Compound Text can include null octet. Therefore the length
  1610. X     * of xstr is able to be specified by parameter len.
  1611. X     * But if len is zero or negative, get length by strlen() assuming
  1612. X     * that no null octet exists.
  1613. X     */
  1614. X    if (len <= 0) {
  1615. X        len = strlen((char *)xstr);
  1616. X    }
  1617. X
  1618. X    /* In initial state, ISO 8859/1 is designated into G0/G1 */
  1619. X    g0 = GSET_ASCII;    /* ASCII -> G0 */
  1620. X    g1 = GSET_LATIN1R;    /* Latin/1 right hand part -> G1 */
  1621. X
  1622. X    while (len-- > 0) {
  1623. X        switch (c = *xstr++) {
  1624. X        case '\n':    /* NEWLINE */
  1625. X        case '\t':    /* TAB */
  1626. X            if (cs) {
  1627. X                cs->code = c;
  1628. X                cs->gset = g0;
  1629. X                cs++;
  1630. X            }
  1631. X            n++;
  1632. X            break;
  1633. X        case 0x9b:    /* CSI */
  1634. X            /*
  1635. X             * CSI sequence is generally in following form:
  1636. X             *    CSI {P} {I} F
  1637. X             *        P : 03/00 to 03/15
  1638. X             *        I : 02/00 to 02/15
  1639. X             *        F : 04/00 to 07/14
  1640. X             */
  1641. X            /*
  1642. X             * Currently only directionality is definde
  1643. X             * as following:
  1644. X             *    CSI-1-]        begin left-to-right text
  1645. X             *    CSI-2-]        begin right-to-left text
  1646. X             *    CSI-]        end of string
  1647. X             * But this implementation ignores them.
  1648. X             */
  1649. X            xstr1 = getcsi(xstr, len);
  1650. X            if (xstr1 == NULL)
  1651. X                return -1;
  1652. X            len -= xstr1 - xstr;
  1653. X            xstr = xstr1;
  1654. X            break;
  1655. X        case '\033':    /* ESC */
  1656. X            /*
  1657. X             * ESC sequence is generally in following form:
  1658. X             *    ESC {I} F
  1659. X             *        I : 02/00 to 02/15
  1660. X             *        F : 03/00 to 07/14
  1661. X             */
  1662. X            /*
  1663. X             * Currently, following functions are defined:
  1664. X             *   Standard character set
  1665. X             *    ESC-(-F
  1666. X             *    ESC-$-(-F
  1667. X             *    ESC-)-F
  1668. X             *    ESC---F
  1669. X             *    ESC-$-)-F
  1670. X             *   Non standard character set
  1671. X             *    ESC-%-/-[0123]
  1672. X             * Standard character set must be accepted correctly.
  1673. X             * Non standard one is ignored but must be parsed
  1674. X             * for skipping data.
  1675. X             */
  1676. X            xstr1 = getesc(xstr, len);
  1677. X            if (xstr1 == NULL)
  1678. X                return -1;
  1679. X            len -= xstr1 - xstr;
  1680. X            switch (xstr1 - xstr) {
  1681. X            case 2:        /* ESC - I - F */
  1682. X                switch (*xstr++) {
  1683. X                case '(':    /* 94chars CS -> G0 */
  1684. X                    g0 = GSET(*xstr);
  1685. X                    break;
  1686. X                case ')':    /* 94chars CS -> G1 */
  1687. X                    g1 = GSET(*xstr);
  1688. X                    break;
  1689. X                case '-':    /* 96chars CS -> G1 */
  1690. X                    g1 = GSET(*xstr) | CS96;
  1691. X                    break;
  1692. X                default:    /* ignore */
  1693. X                    break;
  1694. X                }
  1695. X                break;
  1696. X            case 3:        /* ESC - I - I - F */
  1697. X                switch (*xstr++) {
  1698. X                case '$':
  1699. X                    switch (*xstr++) {
  1700. X                    case '(':    /* 94chars MBCS -> G0 */
  1701. X                        g0 = GSET(*xstr) | MBCS;
  1702. X                        break;
  1703. X                    case ')':    /* 94chars MBCS -> G1 */
  1704. X                        g1 = GSET(*xstr) | MBCS;
  1705. X                        break;
  1706. X                    case '-':    /* 96chars MBCS -> G1 */
  1707. X                        g1 = GSET(*xstr) | CS96 | MBCS;
  1708. X                        break;
  1709. X                    default:    /* ignore */
  1710. X                        break;
  1711. X                    }
  1712. X                    break;
  1713. X                case '%':
  1714. X                    if (*xstr++ != '/') {
  1715. X                        /* unknown sequence */
  1716. X                        break;
  1717. X                    }
  1718. X                    /*
  1719. X                     * Private encoding is ignored.
  1720. X                     * But following data must be skipped.
  1721. X                     *    ESC-%-/-F-M-L
  1722. X                     */
  1723. X                    len -= 2;
  1724. X                    if (len < 0)
  1725. X                        return -1;
  1726. X                    nskip = (*xstr1 & 0x7f) * 128 +
  1727. X                        (*(xstr1 + 1) & 0x7f);
  1728. X                    if ((len -= nskip) < 0)
  1729. X                        return -1;
  1730. X                    xstr1 += nskip + 2;
  1731. X                    break;
  1732. X                default:
  1733. X                    break;
  1734. X                }
  1735. X                break;
  1736. X            default:
  1737. X                break;
  1738. X            }
  1739. X            xstr = xstr1;
  1740. X            break;
  1741. X        default:
  1742. X            if (!(c & 0x60)) {
  1743. X                /*
  1744. X                 * Non NL/TAB/ESC/CSI character in C0 or C1
  1745. X                 * is an obvious error.
  1746. X                 */
  1747. X                return -1;
  1748. X            }
  1749. X            gs = (c & 0x80) ? g1 : g0;
  1750. X            if (cs) {
  1751. X                cs->code = c & ~0x80;
  1752. X                cs->gset = gs;
  1753. X                cs++;
  1754. X            }
  1755. X            n++;
  1756. X            break;
  1757. X        }
  1758. X    }
  1759. X    if (cs) {
  1760. X        cs->code = 0;
  1761. X        cs->gset = 0;
  1762. X    }
  1763. X    return n;
  1764. }
  1765. #endif
  1766. SHAR_EOF
  1767. chmod 0664 kterm-4.1.2/convert.c ||
  1768. echo 'restore of kterm-4.1.2/convert.c failed'
  1769. Wc_c="`wc -c < 'kterm-4.1.2/convert.c'`"
  1770. test 15524 -eq "$Wc_c" ||
  1771.     echo 'kterm-4.1.2/convert.c: original size 15524, current size' "$Wc_c"
  1772. rm -f _shar_wnt_.tmp
  1773. fi
  1774. # ============= kterm-4.1.2/convlib.c ==============
  1775. if test -f 'kterm-4.1.2/convlib.c' -a X"$1" != X"-c"; then
  1776.     echo 'x - skipping kterm-4.1.2/convlib.c (File already exists)'
  1777.     rm -f _shar_wnt_.tmp
  1778. else
  1779. > _shar_wnt_.tmp
  1780. echo 'x - extracting kterm-4.1.2/convlib.c (Text)'
  1781. sed 's/^X//' << 'SHAR_EOF' > 'kterm-4.1.2/convlib.c' &&
  1782. /*
  1783. X *    convlib.c -- conversion input library for X11 Toolkit (Xt)
  1784. X *    $Header: /usr/src.yoshi/X/KTerm/4.1.0/RCS/convlib.c,v 1.1 90/06/27 09:38:48 kagotani Rel $
  1785. X *
  1786. X *        ishisone@sra.co.jp
  1787. X */
  1788. X
  1789. /*
  1790. X * Modified for Hanzi support:
  1791. X * Mark Leisher mleisher@nmsu.edu Fri Nov  9 09:22:33 1990
  1792. X */
  1793. X
  1794. /*
  1795. X * Copyright (C) 1988 by Software Research Associates, Inc.
  1796. X *
  1797. X * Permission to use, copy, modify, and distribute this software and its
  1798. X * documentation for any purpose and without fee is hereby granted, provided
  1799. X * that the above copyright notice appear in all copies and that both that
  1800. X * copyright notice and this permission notice appear in supporting
  1801. X * documentation, and that the name of Software Research Associates not be
  1802. X * used in advertising or publicity pertaining to distribution of the
  1803. X * software without specific, written prior permission.  Software Research
  1804. X * Associates makes no representations about the suitability of this software
  1805. X * for any purpose.  It is provided "as is" without express or implied
  1806. X * warranty.
  1807. X *
  1808. X * Author:  Makoto Ishisone, Software Research Associates, Inc., Japan
  1809. X *        ishisone@sra.co.jp
  1810. X */
  1811. X
  1812. /*
  1813. X * This library is for languages that need complex input method
  1814. X * (such as Japanese or Chinese).
  1815. X * It communicates with the conversion server using the standard X11
  1816. X * inter-client communication mechanism (selection/property/clientmessage),
  1817. X * so that you can easily input these languages (if you have the conversion
  1818. X * server).
  1819. X */
  1820. X
  1821. X
  1822. /*
  1823. X * see protocol document for the protocol used between client and 
  1824. X * conversion server.
  1825. X */
  1826. X
  1827. /*
  1828. X * How to use this library:
  1829. X *
  1830. X *    1. add the following entry to the widget's action table.
  1831. X *
  1832. X *        {"begin-conversion",    beginConversion},
  1833. X *
  1834. X *    2. add the following entry to the translation table.
  1835. X *
  1836. X *        [trigger-event]: begin-conversion(<language>_CONVERSION)
  1837. X *
  1838. X *    where:
  1839. X *        [trigger-event]    - an trigger event of starting conversion
  1840. X *        <language> - the language you want to input
  1841. X *    ex)
  1842. X *        Ctrl<Key>Kanji: begin-conversion(JAPANESE_CONVERSION)
  1843. X *
  1844. X *    3. write a function beginConversion().
  1845. X *    Since function beginConversion is called by the translation manager,
  1846. X *    the arguments passed are Widget, XEvent*, and parameter strings.
  1847. X *    This function should call _beginConversion() defined in this library.
  1848. X *    _beginConversion()'s interface is:
  1849. X *
  1850. X *    void _beginConversion(Widget w, Atom catom, Atom tatom,
  1851. X *                  void (*inputproc)(), caddr_t client_data);
  1852. X *    where:
  1853. X *        catom - Selection Atom (JAPANESE_CONVERSION for Japanese)
  1854. X *                       (CHINESE_CONVERSION for Chinese)
  1855. X *        tatom - Property type of the conversion text
  1856. X *                (e.g. COMPOUND_TEXT)
  1857. X *        inputproc - conversion text callback function (see below)
  1858. X *        client_data - client_data passed to inputproc
  1859. X *
  1860. X *    this callback function interface is:
  1861. X *
  1862. X *        textInput(Widget w, Atom selection,
  1863. X *                Atom proptype, int propformat,
  1864. X *                unsigned long propsize,
  1865. X *                unsigned char *propvalue,
  1866. X *                caddr_t client_data);
  1867. X *
  1868. X *    the callback function should free propvalue data area by calling
  1869. X *    XtFree().
  1870. X *
  1871. X *    So, the simplest beginConversion() will be like this:
  1872. X *
  1873. X *    /-* ARGSUSED *-/
  1874. X *    void beginConversion(w, event, params, nparams)
  1875. X *    Widget    w;
  1876. X *    XEvent    *event;
  1877. X *    String    *params;
  1878. X *    Cardinal    *nparams;
  1879. X *    {
  1880. X *        void    textInput();
  1881. X *        Atom    catom, tatom;
  1882. X *
  1883. X *        if (*nparams != 1) {
  1884. X *            /-* Error *-/
  1885. X *        }
  1886. X *        catom = XInternAtom(XtDisplay(w), *params, False);
  1887. X *        tatom = XInternAtom(XtDisplay(w), "COMPOUND_TEXT", False);
  1888. X *        _beginConversion(w, catom, tatom, textInput, NULL);
  1889. X *    }
  1890. X */
  1891. X
  1892. #include "kterm.h"
  1893. X
  1894. #include <X11/StringDefs.h>
  1895. #include <X11/Intrinsic.h>
  1896. #include <X11/Xutil.h>
  1897. X
  1898. #ifndef lint
  1899. static char    *rcsid = "$Id: convlib.c,v 1.1 90/06/27 09:38:48 kagotani Rel $";
  1900. #endif
  1901. X
  1902. /*
  1903. X * Atoms:
  1904. X *    reqAtom ("CONVERSION_REQUEST")
  1905. X *        message_type in ClientMessage event that is sent
  1906. X *        when requesting conversion service to conversion server.
  1907. X *    notifyAtom ("CONVERSION_NOTIFY")
  1908. X *        message_type in ClientMessage event that is sent
  1909. X *        from conversion server.
  1910. X *    endAtom ("CONVERSION_END")
  1911. X *        message_type in ClientMessage event that is sent
  1912. X *        from conversion server when conversion ends.
  1913. X *    endReqAtom ("CONVERSION_END_REQUEST")
  1914. X *        message_type in ClientMessage event that is sent
  1915. X *        from clients for stopping conversion.
  1916. X */
  1917. X
  1918. typedef struct {
  1919. X    Display    *display;
  1920. X    Atom    reqAtom;    /* "CONVERSION_REQUEST" */
  1921. X    Atom    notifyAtom;    /* "CONVERSION_NOTIFY" */
  1922. X    Atom    endAtom;    /* "CONVERSION_END" */
  1923. X    Atom    endReqAtom;    /* "CONVERSION_END_REQUEST" */
  1924. } ConversionAtoms;
  1925. X
  1926. typedef struct {
  1927. X    Atom    convatom;
  1928. X    Window    convowner;
  1929. X    Atom    property;
  1930. X    void    (*inputproc)();
  1931. X    caddr_t    closure;
  1932. } ConversionContext;
  1933. X
  1934. static XContext    convertPrivContext;
  1935. X
  1936. #if __STDC__ == 1
  1937. /* function prototype */
  1938. static ConversionAtoms *getAtoms(Widget);
  1939. static ConversionContext *getConversionContext(Widget);
  1940. static void recvConvAck(Widget, caddr_t, XEvent *);
  1941. static void getConv(Widget, caddr_t, XEvent *);
  1942. #else
  1943. static ConversionAtoms *getAtoms();
  1944. static ConversionContext *getConversionContext();
  1945. static void recvConvAck();
  1946. static void getConv();
  1947. #endif
  1948. X
  1949. static ConversionAtoms *
  1950. getAtoms(w)
  1951. Widget    w;
  1952. /* make atoms used for communicating with conversion server
  1953. X * and a context for holding the property name
  1954. X */
  1955. {
  1956. X    int            i;
  1957. X    Display            *disp = XtDisplay(w);
  1958. X    ConversionAtoms        *cap;
  1959. X    static ConversionAtoms    *convatomp;
  1960. X    static Cardinal        ndisp = 0;
  1961. #define nalloc    2
  1962. X
  1963. X    /*
  1964. X     * Atoms should be made for each display
  1965. X     */
  1966. X
  1967. X    /* check if the atoms are already made */
  1968. X    cap = convatomp;
  1969. X    for (i = 0; i < ndisp; i++, cap++) {
  1970. X        if (cap->display == disp)
  1971. X            return cap;
  1972. X    }
  1973. X
  1974. X    /* not made yet, so create them */
  1975. X    if (ndisp == 0) {
  1976. X        /* it's a first time, so a context should also be made */
  1977. X        convertPrivContext = XUniqueContext();
  1978. X        convatomp = (ConversionAtoms *)
  1979. X            XtMalloc(sizeof(ConversionAtoms) * nalloc);
  1980. X        cap = convatomp;
  1981. X    } else if (ndisp % nalloc == 0) {
  1982. X        /* increase size */
  1983. X        convatomp = (ConversionAtoms *)
  1984. X            XtRealloc(convatomp, sizeof(ConversionAtoms) * (ndisp +nalloc));
  1985. X        cap = convatomp + ndisp;
  1986. X    } else {
  1987. X        cap = convatomp + ndisp;
  1988. SHAR_EOF
  1989. true || echo 'restore of kterm-4.1.2/convlib.c failed'
  1990. fi
  1991. echo 'End of kterm-4.1.2 part 9'
  1992. echo 'File kterm-4.1.2/convlib.c is continued in part 10'
  1993. echo 10 > _shar_seq_.tmp
  1994. exit 0
  1995.  
  1996.  
  1997. -----------------------------------------------------------------------------
  1998. mleisher@nmsu.edu                      "I laughed.
  1999. Mark Leisher                                I cried.
  2000. Computing Research Lab                          I fell down.
  2001. New Mexico State University                        It changed my life."
  2002. Las Cruces, NM                     - Rich [Cowboy Feng's Space Bar and Grille]
  2003.  
  2004. --
  2005. Dan Heller
  2006. O'Reilly && Associates       Z-Code Software    Comp-sources-x:
  2007. Senior Writer                President          comp-sources.x@uunet.uu.net
  2008. argv@ora.com                 argv@zipcode.com
  2009.