home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume4 / kterm / part03 < prev    next >
Encoding:
Text File  |  1989-05-31  |  55.2 KB  |  2,087 lines
  1. Path: uunet!island!argv
  2. From: argv@island.uu.net (Dan Heller)
  3. Newsgroups: comp.sources.x
  4. Subject: v04i012:  kterm -- Kanji (japanese) xterm, Part03/04
  5. Message-ID: <781@island.uu.net>
  6. Date: 31 May 89 06:01:48 GMT
  7. Sender: news@island.uu.net
  8. Organization: Island Graphics, Marin County, California
  9. Lines: 2075
  10. Approved: island!argv@sun.com
  11.  
  12. Submitted-by: Hiroto Kagotani <kagotani@cs.titech.ac.jp>
  13. Posting-number: Volume 4, Issue 12
  14. Archive-name: kterm/part03
  15.  
  16. diff -rc ../xterm/charproc.c ./charproc.c
  17. *** ../xterm/charproc.c    Thu May  4 20:19:22 1989
  18. --- ./charproc.c    Tue May 30 14:53:35 1989
  19. ***************
  20. *** 1,5 ****
  21. --- 1,6 ----
  22.   /*
  23.    * $XConsortium: charproc.c,v 1.64 89/01/04 13:37:50 jim Exp $
  24. +  * $Header: charproc.c,v 1.1 89/05/30 14:53:32 kagotani Rel $
  25.    */
  26.   
  27.   
  28. ***************
  29. *** 96,106 ****
  30. --- 97,118 ----
  31.   #define    XtNscrollKey        "scrollKey"
  32.   #define XtNscrollPos        "scrollPos"
  33.   #define    XtNsignalInhibit    "signalInhibit"
  34. + #ifdef    STATUSLINE    /* michael */
  35. + #define    XtNstatusLine        "statusLine"
  36. + #define    XtNstatusNormal        "statusNormal"
  37. + #endif    STATUSLINE
  38.   #define    XtNtekInhibit        "tekInhibit"
  39.   #define    XtNtekStartup        "tekStartup"
  40.   #define XtNtiteInhibit        "titeInhibit"
  41.   #define    XtNvisualBell        "visualBell"
  42.   #define XtNallowSendEvents    "allowSendEvents"
  43. + #ifdef    KANJI    /* sano */
  44. + #define    XtNkanaFont        "kanaFont"
  45. + #define    XtNkanaBoldFont        "kanaBoldFont"
  46. + #define    XtNkanjiFont        "kanjiFont"
  47. + #define    XtNkanjiBoldFont    "kanjiBoldFont"
  48. + #define    XtNkanjiMode        "kanjiMode"
  49. + #endif    KANJI
  50.   
  51.   #define XtCAlwaysHighlight    "AlwaysHighlight"
  52.   #define    XtCC132            "C132"
  53. ***************
  54. *** 125,140 ****
  55. --- 137,171 ----
  56.   #define XtCScrollPos         "ScrollPos"
  57.   #define    XtCScrollCond        "ScrollCond"
  58.   #define    XtCSignalInhibit    "SignalInhibit"
  59. + #ifdef    STATUSLINE    /* michael */
  60. + #define    XtCStatusLine        "StatusLine"
  61. + #define    XtCStatusNormal        "StatusNormal"
  62. + #endif    STATUSLINE
  63.   #define    XtCTekInhibit        "TekInhibit"
  64.   #define    XtCTekStartup        "TekStartup"
  65.   #define XtCTiteInhibit        "TiteInhibit"
  66.   #define    XtCVisualBell        "VisualBell"
  67.   #define XtCAllowSendEvents    "AllowSendEvents"
  68. + #ifdef    KANJI    /* sano */
  69. + #define    XtCKanaFont        "KanaFont"
  70. + #define    XtCKanaBoldFont        "KanaBoldFont"
  71. + #define    XtCKanjiFont        "KanjiFont"
  72. + #define    XtCKanjiBoldFont    "KanjiBoldFont"
  73. + #define    XtCKanjiMode        "KanjiMode"
  74. + #endif    KANJI
  75.   
  76. + #ifdef    KANJI    /* sano */
  77. +     /*
  78. +      * To avoid the sign-extension problem, masks lower 8 bites.
  79. +      */
  80. + #define    doinput()        (0xff & (bcnt-- > 0 ? *bptr++ : in_put()))
  81. + #else    KANJI
  82.   #define    doinput()        (bcnt-- > 0 ? *bptr++ : in_put())
  83. + #endif    KANJI
  84.   
  85.   #ifndef lint
  86.   static char rcs_id[] = "$XConsortium: charproc.c,v 1.64 89/01/04 13:37:50 jim Exp $";
  87. + static char kterm_id[] = "$Header: charproc.c,v 1.1 89/05/30 14:53:32 kagotani Rel $";
  88.   #endif    /* lint */
  89.   
  90.   static long arg;
  91. ***************
  92. *** 155,160 ****
  93. --- 186,196 ----
  94.   extern int igntable[];
  95.   extern int scrtable[];
  96.   extern int scstable[];
  97. + #ifdef    KANJI    /* sano */
  98. + extern int mbcstable[];
  99. + static char pending_char;
  100. + static int pending_bad;
  101. + #endif    KANJI
  102.   
  103.   
  104.   /* event handlers */
  105. ***************
  106. *** 316,321 ****
  107. --- 352,365 ----
  108.   {XtNsignalInhibit,XtCSignalInhibit,XtRBoolean, sizeof(Boolean),
  109.       XtOffset(XtermWidget, misc.signalInhibit),
  110.       XtRBoolean, (caddr_t) &defaultFALSE},
  111. + #ifdef    STATUSLINE    /* michael */
  112. + {XtNstatusLine, XtCStatusLine, XtRBoolean, sizeof(Boolean),
  113. +     XtOffset(XtermWidget, screen.statusline),
  114. +     XtRBoolean, (caddr_t) &defaultFALSE},
  115. + {XtNstatusNormal, XtCStatusNormal, XtRBoolean, sizeof(Boolean),
  116. +     XtOffset(XtermWidget, misc.statusnormal),
  117. +     XtRBoolean, (caddr_t) &defaultFALSE},
  118. + #endif    STATUSLINE
  119.   {XtNtekInhibit, XtCTekInhibit, XtRBoolean, sizeof(Boolean),
  120.       XtOffset(XtermWidget, misc.tekInhibit),
  121.       XtRBoolean, (caddr_t) &defaultFALSE},
  122. ***************
  123. *** 331,336 ****
  124. --- 375,398 ----
  125.   {XtNallowSendEvents, XtCAllowSendEvents, XtRBoolean, sizeof(Boolean),
  126.       XtOffset(XtermWidget, screen.allowSendEvents),
  127.       XtRBoolean, (caddr_t) &defaultFALSE}
  128. + #ifdef    KANJI    /* sano */
  129. + ,
  130. + {XtNkanaFont, XtCKanaFont, XtRString, sizeof(char *),
  131. +     XtOffset(XtermWidget, misc.f_rn),
  132. +     XtRString, DEFKANAFONT},
  133. + {XtNkanaBoldFont, XtCKanaFont, XtRString, sizeof(char *),
  134. +     XtOffset(XtermWidget, misc.f_rb),
  135. +     XtRString, DEFKANABOLDFONT},
  136. + {XtNkanjiFont, XtCKanjiFont, XtRString, sizeof(char *),
  137. +     XtOffset(XtermWidget, misc.f_kn),
  138. +     XtRString, DEFKANJIFONT},
  139. + {XtNkanjiBoldFont, XtCKanjiFont, XtRString, sizeof(char *),
  140. +     XtOffset(XtermWidget, misc.f_kb),
  141. +     XtRString, DEFKANJIBOLDFONT},
  142. + {XtNkanjiMode,  XtCKanjiMode,  XtRString,  sizeof(char *),
  143. +     XtOffset(XtermWidget, misc.k_m),
  144. +     XtRString, (caddr_t) NULL}
  145. + #endif    KANJI
  146.   };
  147.   
  148.   
  149. ***************
  150. *** 384,400 ****
  151. --- 446,626 ----
  152.       register int c;
  153.       register char *cp;
  154.       register int row, col, top, bot, scstype;
  155. + #ifdef    KANJI
  156. +     int    mbcs;
  157. +     register short  gset;
  158. +     register unsigned char *ucp;
  159. + #endif    KANJI
  160.       extern int bitset(), bitclr(), finput(), TrackMouse();
  161.   
  162.       if(setjmp(vtjmpbuf))
  163.           parsestate = groundtable;
  164. + #ifdef    KANJI    /* sano */
  165. +     pending_char = pending_bad = 0;
  166. +     for( ; ; ) {
  167. +         if ((c = doinput()) & 0x80) {    /* if MSB is on */
  168. +             if (term->flags & EUC_KANJI) {
  169. +                     /*
  170. +                      * Do processing for EUC code
  171. +                      */
  172. + #define    EKANJI(c)    (0xa1 <= c && c <= 0xfe)/* true if EUC KANJI */
  173. + #define    EKANA1(c)    (0x8e == c)        /* true if SS2 */
  174. + #define    EKANA2(c)    (0xa1 <= c && c <= 0xdf)/* true if KANA */
  175. +                 if (EKANJI(c)) {
  176. +                     *--bptr = c;
  177. +                     bcnt++;
  178. +                     top = bcnt > TEXT_BUF_SIZE ?
  179. +                         TEXT_BUF_SIZE : bcnt;
  180. +                     ucp = (unsigned char *)bptr;
  181. +                     while (top > 1 && EKANJI(*ucp)
  182. +                                && EKANJI(*(ucp + 1))) {
  183. +                         top -= 2, bcnt -= 2;
  184. +                         /*
  185. +                          * Strip off of the both MSB
  186. +                          * to convert JIS code
  187. +                          */
  188. +                         *ucp &= 0x7f; ucp++;
  189. +                         *ucp &= 0x7f; ucp++;
  190. +                     }
  191. +                     dotext(screen, term->flags, MBCS|'B',
  192. +                         bptr, ucp);
  193. +                     bptr = (char *)ucp;
  194. +                     if (top > 1 && EKANJI(*ucp) &&
  195. +                              !EKANJI(*(ucp + 1))) {
  196. +                          doinput();
  197. +                     } else if (1 == top && EKANJI(*ucp) &&
  198. +                             1 == bcnt) {
  199. +                         pending_char = doinput();
  200. +                     }
  201. +                     continue;
  202. +                 } else if (EKANA1(c)) {
  203. +                     if (0 != bcnt) {
  204. +                         if (EKANA2((unsigned char)*bptr)) {
  205. +                             dotext(screen, term->flags, 'I', bptr, (bptr + 1));
  206. +                             doinput();
  207. +                         }
  208. +                     } else {
  209. +                         pending_char = c;
  210. +                     }
  211. +                     continue;
  212. +                 }
  213. +             } else if (term->flags & SJIS_KANJI) {
  214. +                 /*
  215. +                  * Do processing for Shift-JIS Kanji code
  216. +                  */
  217. + #define SJIS1(c) (0x81 <= c && c <= 0x9f) || (0xe0 <= c && c <= 0xef)
  218. +         /* SJIS1 is according to the range of 1st byte in Shift JIS */
  219. + #define SJIS2(c) (0x40 <= c && c <= 0xfc && c != 0x7f)
  220. +         /* SJIS2 is according to the range of 2nd byte in Shift JIS */
  221. + #define SJISK(c) (0xa1 <= c && c <= 0xdf)
  222. +         /* SJISK is according to the range of KANA (only one byte,
  223. +            the width is the same of ascii char (half of Kanji)) */
  224. +                 if (SJIS1(c)) {
  225. +                     *--bptr = c;
  226. +                     bcnt++;
  227. +                     top = bcnt > TEXT_BUF_SIZE ? TEXT_BUF_SIZE : bcnt;
  228. +                     ucp = (unsigned char *)bptr;
  229. +                     while (top > 1 && SJIS1(*ucp) && SJIS2(*(ucp + 1))) {
  230. +                         top -= 2, bcnt -= 2;
  231. +                         /*
  232. +                          * Do code conversion.
  233. +                          * It is quite complicated....
  234. +                          */
  235. +                         *ucp = (*ucp - ((*ucp <= 0x9f) ? 0x81 : 0xc1)) * 2 + 0x21;
  236. +                         ucp++;
  237. +                         if (*ucp <= 0x7e) {
  238. +                             *ucp -= 0x1f;
  239. +                         } else if (*ucp <= 0x9e) {
  240. +                             *ucp -= 0x20;
  241. +                         } else {
  242. +                             *ucp -= 0x7e;
  243. +                             *(ucp - 1) += 1;
  244. +                         }
  245. +                         ucp++;
  246. +                     }
  247. +                     dotext(screen, term->flags, MBCS|'B',
  248. +                         bptr, ucp);
  249. +                     bptr = (char *)ucp;
  250. +                     if (top > 1 && SJIS1(*ucp)
  251. +                             && !SJIS2(*(ucp + 1))) {
  252. +                         doinput();
  253. +                     } else if (1 == top && SJIS1(*ucp)
  254. +                                 && 1 == bcnt) {
  255. +                         pending_char = doinput();
  256. +                     }
  257. +                     continue;
  258. +                 } else if (SJISK(c)) {
  259. +                     top = bcnt > TEXT_BUF_SIZE ? TEXT_BUF_SIZE : bcnt;
  260. +                     cp = bptr;
  261. +                     *--bptr = c;
  262. +                     while (top > 0 &&
  263. +                         SJISK((unsigned char)*cp)) {
  264. +                         top--, bcnt--, cp++;
  265. +                     }
  266. +                     dotext(screen, term->flags, 'I', bptr, cp);
  267. +                     bptr = cp;
  268. +                     continue;
  269. +                 }
  270. +             }
  271. +             /*
  272. +              * If kanji code is JIS, then no processing is required
  273. +              * here. The preceeding escape sequence will turn on/off
  274. +              * the MBCS flags when dotext() is called.
  275. +              */
  276. +         }
  277. +         switch(parsestate[c &= CHAR]) {
  278. + #else    KANJI
  279.       for( ; ; )
  280.           switch(parsestate[c = doinput()]) {
  281. + #endif
  282.            case CASE_PRINT:
  283.               /* printable characters */
  284.               top = bcnt > TEXT_BUF_SIZE ? TEXT_BUF_SIZE : bcnt;
  285.               cp = bptr;
  286.               *--bptr = c;
  287. + #ifdef    KANJI    /* sano */
  288. +             if(screen->curss) {
  289. +                 dotext(screen, term->flags,
  290. +                  screen->gsets[screen->curss], bptr, bptr + 1) ;
  291. +                 screen->curss = 0;
  292. +                 bptr++;
  293. +                 c = *bptr & 0xff;
  294. +             }
  295. +             if ((gset = screen->gsets[screen->curgl]) & MBCS) {
  296. +                 if (' ' == c) {
  297. +                     gset &= ~MBCS;
  298. +                     while (top > 0 &&
  299. +                         ' ' == (unsigned char)*cp) {
  300. +                         top--; bcnt--; cp++;
  301. +                     }
  302. +                 } else {
  303. +                     while (top > 0 && 0x20 < *cp &&
  304. +                         *cp < 0x7f) {
  305. +                         top--; bcnt--; cp++;
  306. +                     }
  307. +                     if ((cp - bptr) & 1) {
  308. +                         --cp;
  309. +                         if (top == 0) {
  310. +                             if (bcnt == 0)
  311. +                                 pending_char = *cp;
  312. +                             else
  313. +                                 bcnt++;
  314. +                         } else
  315. +                             pending_bad = 1;
  316. +                     }
  317. +                 }
  318. +             } else
  319. +                 while (top > 0 && isprint((unsigned char)*cp)) {
  320. +                     top--; bcnt--; cp++;
  321. +             }
  322. +             if (bptr < cp)
  323. +                 dotext(screen, term->flags, gset, bptr, cp);
  324. +             bptr = cp;
  325. +             if (pending_bad) {
  326. +                 pending_bad = 0;
  327. +                 bptr++;
  328. +             }
  329. + #else    KANJI
  330.               while(top > 0 && isprint(*cp)) {
  331.                   top--;
  332.                   bcnt--;
  333. ***************
  334. *** 410,415 ****
  335. --- 636,642 ----
  336.                   dotext(screen, term->flags,
  337.                    screen->gsets[screen->curgl], bptr, cp);
  338.               bptr = cp;
  339. + #endif    KANJI
  340.               break;
  341.   
  342.            case CASE_GROUND_STATE:
  343. ***************
  344. *** 455,460 ****
  345. --- 682,690 ----
  346.               /*
  347.                * form feed, line feed, vertical tab
  348.                */
  349. + #ifdef    STATUSLINE    /* michael */
  350. +             if (!screen->instatus)
  351. + #endif    STATUSLINE
  352.               Index(screen, 1);
  353.               if (term->flags & LINEFEED)
  354.                   CarriageReturn(screen);
  355. ***************
  356. *** 507,512 ****
  357. --- 737,751 ----
  358.               parsestate = scstable;
  359.               break;
  360.   
  361. + #ifdef    KANJI    /* kagotani */
  362. +          case CASE_MBCS:
  363. +             /* enter smbcs mbcsesc */
  364. +             mbcs = 1;
  365. +             scstype = 0;
  366. +             parsestate = mbcstable;
  367. +             break;
  368. + #endif    KANJI
  369. + 
  370.            case CASE_ESC_IGNORE:
  371.               /* unknown escape sequence */
  372.               parsestate = eigtable;
  373. ***************
  374. *** 539,555 ****
  375. --- 778,808 ----
  376.   
  377.            case CASE_CUU:
  378.               /* CUU */
  379. + #ifdef    STATUSLINE    /* michael */
  380. +             /* only if not in status line */
  381. +             if (!screen->instatus) {
  382. + #endif    STATUSLINE
  383.               if((c = param[0]) < 1)
  384.                   c = 1;
  385.               CursorUp(screen, c);
  386. + #ifdef    STATUSLINE    /* michael */
  387. +             }
  388. + #endif    STATUSLINE
  389.               parsestate = groundtable;
  390.               break;
  391.   
  392.            case CASE_CUD:
  393.               /* CUD */
  394. + #ifdef    STATUSLINE    /* michael */
  395. +             /* only if not in status line */
  396. +             if (!screen->instatus) {
  397. + #endif    STATUSLINE
  398.               if((c = param[0]) < 1)
  399.                   c = 1;
  400.               CursorDown(screen, c);
  401. + #ifdef    STATUSLINE    /* michael */
  402. +             }
  403. + #endif    STATUSLINE
  404.               parsestate = groundtable;
  405.               break;
  406.   
  407. ***************
  408. *** 571,581 ****
  409. --- 824,841 ----
  410.   
  411.            case CASE_CUP:
  412.               /* CUP | HVP */
  413. + #ifdef    STATUSLINE    /* michael */
  414. +             /* only if not in status line */
  415. +             if (!screen->instatus) {
  416. + #endif    STATUSLINE
  417.               if((row = param[0]) < 1)
  418.                   row = 1;
  419.               if(nparam < 2 || (col = param[1]) < 1)
  420.                   col = 1;
  421.               CursorSet(screen, row-1, col-1, term->flags);
  422. + #ifdef    STATUSLINE    /* michael */
  423. +             }
  424. + #endif    STATUSLINE
  425.               parsestate = groundtable;
  426.               break;
  427.   
  428. ***************
  429. *** 584,597 ****
  430. --- 844,872 ----
  431.               switch (param[0]) {
  432.                case DEFAULT:
  433.                case 0:
  434. + #ifdef    STATUSLINE    /* michael */
  435. +                 if (screen->instatus)
  436. +                     ClearRight(screen);
  437. +                 else
  438. + #endif    STATUSLINE
  439.                   ClearBelow(screen);
  440.                   break;
  441.   
  442.                case 1:
  443. + #ifdef    STATUSLINE    /* michael */
  444. +                 if (screen->instatus)
  445. +                     ClearLeft(screen);
  446. +                 else
  447. + #endif    STATUSLINE
  448.                   ClearAbove(screen);
  449.                   break;
  450.   
  451.                case 2:
  452. + #ifdef    STATUSLINE    /* michael */
  453. +                 if (screen->instatus)
  454. +                     ClearLine(screen);
  455. +                 else
  456. + #endif    STATUSLINE
  457.                   ClearScreen(screen);
  458.                   break;
  459.               }
  460. ***************
  461. *** 617,633 ****
  462. --- 892,922 ----
  463.   
  464.            case CASE_IL:
  465.               /* IL */
  466. + #ifdef    STATUSLINE    /* michael */
  467. +             /* only if not in status line */
  468. +             if (!screen->instatus) {
  469. + #endif    STATUSLINE
  470.               if((c = param[0]) < 1)
  471.                   c = 1;
  472.               InsertLine(screen, c);
  473. + #ifdef    STATUSLINE    /* michael */
  474. +             }
  475. + #endif    STATUSLINE
  476.               parsestate = groundtable;
  477.               break;
  478.   
  479.            case CASE_DL:
  480.               /* DL */
  481. + #ifdef    STATUSLINE    /* michael */
  482. +             /* only if not in status line */
  483. +             if (!screen->instatus) {
  484. + #endif    STATUSLINE
  485.               if((c = param[0]) < 1)
  486.                   c = 1;
  487.               DeleteLine(screen, c);
  488. + #ifdef    STATUSLINE    /* michael */
  489. +             }
  490. + #endif    STATUSLINE
  491.               parsestate = groundtable;
  492.               break;
  493.   
  494. ***************
  495. *** 732,737 ****
  496. --- 1021,1030 ----
  497.   
  498.            case CASE_DECSTBM:
  499.               /* DECSTBM */
  500. + #ifdef    STATUSLINE    /* michael */
  501. +             /* only if not in status line */
  502. +             if (!screen->instatus) {
  503. + #endif    STATUSLINE
  504.               if((top = param[0]) < 1)
  505.                   top = 1;
  506.               if(nparam < 2 || (bot = param[1]) == DEFAULT
  507. ***************
  508. *** 745,750 ****
  509. --- 1038,1046 ----
  510.                   screen->bot_marg = bot-1;
  511.                   CursorSet(screen, 0, 0, term->flags);
  512.               }
  513. + #ifdef    STATUSLINE    /* michael */
  514. +             }
  515. + #endif    STATUSLINE
  516.               parsestate = groundtable;
  517.               break;
  518.   
  519. ***************
  520. *** 800,805 ****
  521. --- 1096,1107 ----
  522.               break;
  523.   
  524.            case CASE_GSETS:
  525. + #ifdef    KANJI    /* sano & kagotani */
  526. +             if (mbcs) {
  527. +                 c |= MBCS;
  528. +                 mbcs = 0;
  529. +             }
  530. + #endif    KANJI
  531.               screen->gsets[scstype] = c;
  532.               parsestate = groundtable;
  533.               break;
  534. ***************
  535. *** 830,835 ****
  536. --- 1132,1141 ----
  537.   
  538.            case CASE_IND:
  539.               /* IND */
  540. + #ifdef    STATUSLINE    /* michael */
  541. +             /* only if not in status line */
  542. +             if (!screen->instatus)
  543. + #endif    STATUSLINE
  544.               Index(screen, 1);
  545.               if(screen->display->qlen > 0 ||
  546.                (ioctl(screen->display->fd, FIONREAD, (char *)&arg), arg) > 0)
  547. ***************
  548. *** 839,844 ****
  549. --- 1145,1154 ----
  550.   
  551.            case CASE_NEL:
  552.               /* NEL */
  553. + #ifdef    STATUSLINE    /* michael */
  554. +             /* only if not in status line */
  555. +             if (!screen->instatus)
  556. + #endif    STATUSLINE
  557.               Index(screen, 1);
  558.               CarriageReturn(screen);
  559.               if(screen->display->qlen > 0 ||
  560. ***************
  561. *** 855,860 ****
  562. --- 1165,1174 ----
  563.   
  564.            case CASE_RI:
  565.               /* RI */
  566. + #ifdef    STATUSLINE    /* michael */
  567. +             /* only if not in status line */
  568. +             if (!screen->instatus)
  569. + #endif    STATUSLINE
  570.               RevIndex(screen, 1);
  571.               parsestate = groundtable;
  572.               break;
  573. ***************
  574. *** 920,925 ****
  575. --- 1234,1268 ----
  576.               parsestate = groundtable;
  577.               break;
  578.   
  579. + #ifdef    STATUSLINE    /* michael */
  580. +          case CASE_TO_STATUS:
  581. +             if ((c = param[0]) < 1)
  582. +                 c = 1;
  583. +             ToStatus(c - 1);
  584. +             parsestate = groundtable;
  585. +             break ;
  586. + 
  587. +          case CASE_FROM_STATUS:
  588. +             FromStatus();
  589. +             parsestate = groundtable;
  590. +             break ;
  591. + 
  592. +          case CASE_SHOW_STATUS:
  593. +             ShowStatus();
  594. +             parsestate = groundtable;
  595. +             break ;
  596. + 
  597. +          case CASE_HIDE_STATUS:
  598. +             HideStatus();
  599. +             parsestate = groundtable;
  600. +             break ;
  601. + 
  602. +          case CASE_ERASE_STATUS:
  603. +             EraseStatus();
  604. +             parsestate = groundtable;
  605. +             break ;
  606. + #endif    STATUSLINE
  607. + 
  608.            case CASE_XTERM_SAVE:
  609.               savemodes(term);
  610.               parsestate = groundtable;
  611. ***************
  612. *** 930,935 ****
  613. --- 1273,1281 ----
  614.               parsestate = groundtable;
  615.               break;
  616.           }
  617. + #ifdef    KANJI    /* sano */
  618. +     }
  619. + #endif    KANJI
  620.   }
  621.   
  622.   finput()
  623. ***************
  624. *** 1031,1038 ****
  625. --- 1377,1392 ----
  626.           if((select_mask & pty_mask) && (eventMode == NORMAL)) {
  627.               if(screen->logging)
  628.                   FlushLog(screen);
  629. + #ifdef    KANJI    /* sano */
  630. +             /*
  631. +              * buffer[0] is reserved for the pending_char.
  632. +              */
  633. +             if((bcnt = read(screen->respond, bptr = &buffer[1],
  634. +              BUF_SIZE)) < 0) {
  635. + #else    KANJI
  636.               if((bcnt = read(screen->respond, bptr = buffer,
  637.                BUF_SIZE)) < 0) {
  638. + #endif    KANJI
  639.                   if(errno == EIO)
  640.                       Cleanup (0);
  641.                   else if(errno != EWOULDBLOCK)
  642. ***************
  643. *** 1042,1050 ****
  644. --- 1396,1416 ----
  645.               } else if(bcnt == 0)
  646.                   Panic("input: read returned zero\n", 0);
  647.               else {
  648. + #ifdef    KANJI    /* sano */
  649. +                 if (pending_char) {
  650. +                     /*
  651. +                      * restore pending_char to the top of
  652. +                      * the text which just read.
  653. +                      */
  654. +                     *--bptr = pending_char;
  655. +                     bcnt++;
  656. +                     pending_char = 0;
  657. +                 }
  658. + #else    KANJI
  659.                   /* strip parity bit */
  660.                   for(i = bcnt, cp = bptr ; i > 0 ; i--)
  661.                       *cp++ &= CHAR;
  662. + #endif    KANJI
  663.                   if(screen->scrollWidget && screen->scrollinput &&
  664.                    screen->topline < 0)
  665.                       /* Scroll to bottom */
  666. ***************
  667. *** 1119,1125 ****
  668. --- 1485,1495 ----
  669.   dotext(screen, flags, charset, buf, ptr)
  670.   register TScreen    *screen;
  671.   unsigned    flags;
  672. + #ifdef    KANJI    /* sano */
  673. + short        charset;
  674. + #else    KANJI
  675.   char        charset;
  676. + #endif    KANJI
  677.   char    *buf;
  678.   char    *ptr;
  679.   {
  680. ***************
  681. *** 1127,1132 ****
  682. --- 1497,1505 ----
  683.       register int    len;
  684.       register int    n;
  685.       register int    next_col;
  686. + #ifdef    KANJI    /* sano */
  687. +     register int    do_wrap = 0;
  688. + #endif    KANJI
  689.   
  690.       switch (charset) {
  691.       case 'A':    /* United Kingdom set            */
  692. ***************
  693. *** 1136,1141 ****
  694. --- 1509,1526 ----
  695.           break;
  696.   
  697.       case 'B':    /* ASCII set                */
  698. + #ifdef    KANJI    /* sano */
  699. +         /*
  700. +          * 'H' should be removed here because it is *not*
  701. +          * ascii but Swedish character set. Some Kanji text
  702. +          * still includes ESC-(-H, which does not designate
  703. +          * Romaji nor ascii character set. This is due to
  704. +          * the mis-printing of early JIS documentation.
  705. +          */
  706. +     case 'J':
  707. +     case 'H':
  708. +     case '@':
  709. + #endif    KANJI
  710.           break;
  711.   
  712.       case '0':    /* special graphics (line drawing)    */
  713. ***************
  714. *** 1144,1149 ****
  715. --- 1529,1549 ----
  716.                   *s = *s == 0x5f ? 0x7f : *s - 0x5f;
  717.           break;
  718.   
  719. + #ifdef    KANJI    /* sano */
  720. +     case 'I':
  721. +         flags |= KANACS;
  722. +         for (s = buf; s < ptr; ++s)
  723. +             *s &= 0x7f;
  724. +         break;
  725. +         /*
  726. +          * ESC-$-(-@ and ESC-$-(-B designate the Kanji character set.
  727. +          * set KCS flags...
  728. +          */
  729. +     case MBCS|'@':
  730. +     case MBCS|'B':
  731. +         flags |= KCS;
  732. +         break;
  733. + #endif
  734.       default:    /* any character sets we don't recognize*/
  735.           return;
  736.       }
  737. ***************
  738. *** 1153,1159 ****
  739. --- 1553,1564 ----
  740.       while (len > 0) {
  741.           n = screen->max_col-screen->cur_col+1;
  742.           if (n <= 1) {
  743. + #ifdef    STATUSLINE    /* michael */
  744. +             if (screen->do_wrap && (flags&WRAPAROUND) &&
  745. +                 !screen->instatus) {
  746. + #else    STATUSLINE
  747.               if (screen->do_wrap && (flags&WRAPAROUND)) {
  748. + #endif    STATUSLINE
  749.                   Index(screen, 1);
  750.                   screen->cur_col = 0;
  751.                   screen->do_wrap = 0;
  752. ***************
  753. *** 1163,1168 ****
  754. --- 1568,1585 ----
  755.           }
  756.           if (len < n)
  757.               n = len;
  758. + #ifdef    KANJI
  759. +         if (flags & KCS) {
  760. +             if (n == 1) {
  761. +                 if (flags & WRAPAROUND) {
  762. +                     n--; do_wrap = 1;
  763. +                 } else
  764. +                     n++;
  765. +             } else
  766. +                 if (n & 1)
  767. +                     n--;
  768. +         }
  769. + #endif
  770.           next_col = screen->cur_col + n;
  771.           WriteText(screen, ptr, n, flags);
  772.           /*
  773. ***************
  774. *** 1170,1176 ****
  775. --- 1587,1597 ----
  776.            * If screen->cur_col != next_col, we must have
  777.            * hit the right margin, so set the do_wrap flag.
  778.            */
  779. + #ifdef    KANJI    /* sano */
  780. +         screen->do_wrap = (screen->cur_col < next_col) | do_wrap;
  781. + #else    KANJI
  782.           screen->do_wrap = (screen->cur_col < next_col);
  783. + #endif    KANJI
  784.           len -= n;
  785.           ptr += n;
  786.       }
  787. ***************
  788. *** 1190,1196 ****
  789. --- 1611,1624 ----
  790.       register unsigned fgs = flags;
  791.       GC    currentGC;
  792.    
  793. + #ifdef    STATUSLINE    /* michael */
  794. +    if(screen->instatus && screen->reversestatus)
  795. +     fgs ^= INVERSE;
  796. +    if(screen->cur_row - screen->topline <= screen->max_row ||
  797. +       screen->instatus) {
  798. + #else    STATUSLINE
  799.      if(screen->cur_row - screen->topline <= screen->max_row) {
  800. + #endif    STATUSLINE
  801.       /*
  802.       if(screen->cur_row == screen->cursor_row && screen->cur_col <=
  803.        screen->cursor_col && screen->cursor_col <= screen->cur_col + len - 1)
  804. ***************
  805. *** 1203,1208 ****
  806. --- 1631,1667 ----
  807.        *    make sure that the correct GC is current
  808.        */
  809.   
  810. + #ifdef    KANJI    /* sano */
  811. +     if (fgs & KCS) {    /* kanji */
  812. +         if (fgs & BOLD) {
  813. +             if (fgs & INVERSE) {
  814. +                 currentGC = screen->w_reverseboldGC;
  815. +             } else {
  816. +                 currentGC = screen->w_normalboldGC;
  817. +             }
  818. +         } else {
  819. +             if (fgs & INVERSE) {
  820. +                 currentGC = screen->w_reverseGC;
  821. +             } else {
  822. +                 currentGC = screen->w_normalGC;
  823. +             }
  824. +         }
  825. +     } else if (fgs & KANACS) {    /* kana */
  826. +         if (fgs & BOLD) {
  827. +             if (fgs & INVERSE) {
  828. +                 currentGC = screen->r_reverseboldGC;
  829. +             } else {
  830. +                 currentGC = screen->r_normalboldGC;
  831. +             }
  832. +         } else {
  833. +             if (fgs & INVERSE) {
  834. +                 currentGC = screen->r_reverseGC;
  835. +             } else {
  836. +                 currentGC = screen->r_normalGC;
  837. +             }
  838. +         }
  839. +     } else
  840. + #endif    KANJI
  841.       if (fgs & BOLD)
  842.           if (fgs & INVERSE)
  843.               currentGC = screen->reverseboldGC;
  844. ***************
  845. *** 1219,1231 ****
  846.               FlushScroll(screen);
  847.       cx = CursorX(screen, screen->cur_col);
  848.       cy = CursorY(screen, screen->cur_row)+screen->fnt_norm->ascent;
  849.        XDrawImageString(screen->display, TextWindow(screen), currentGC,
  850.               cx, cy, str, len);
  851.   
  852.       if((fgs & BOLD) && screen->enbolden) 
  853. !         if (currentGC == screen->normalGC || screen->reverseGC)
  854.               XDrawString(screen->display, TextWindow(screen),
  855.                         currentGC,cx + 1, cy, str, len);
  856.   
  857.       if(fgs & UNDERLINE) 
  858.           XDrawLine(screen->display, TextWindow(screen), currentGC,
  859. --- 1678,1727 ----
  860.               FlushScroll(screen);
  861.       cx = CursorX(screen, screen->cur_col);
  862.       cy = CursorY(screen, screen->cur_row)+screen->fnt_norm->ascent;
  863. + #ifdef    KANJI    /* sano & michael */
  864. +     if (fgs & KCS) {
  865. +         /*
  866. +          * Draw Kanji string with currentGC. If no k_boldGC nor
  867. +          * k_reverseboldGC, then overstrike it.
  868. +          */
  869. +         XDrawImageString16(screen->display, TextWindow(screen),
  870. +             currentGC, cx, cy, (XChar2b *)str, len / 2);
  871. +         if ((fgs & BOLD) && screen->w_enbolden)
  872. +             if (currentGC == screen->w_normalGC ||
  873. +                 currentGC == screen->w_reverseGC)
  874. +                 XDrawString16(screen->display, 
  875. +                     TextWindow(screen), currentGC,
  876. +                     cx + 1, cy, (XChar2b *)str, len / 2);
  877. +     } else if (fgs & KANACS) {
  878. +         /*
  879. +          * Draw Kanji string with currentGC. If no k_boldGC nor
  880. +          * k_reverseboldGC, then overstrike it.
  881. +          */
  882. +         XDrawImageString(screen->display, TextWindow(screen),
  883. +             currentGC, cx, cy, str, len);
  884. +         if ((fgs & BOLD) && screen->r_enbolden)
  885. +             if (currentGC == screen->r_normalGC ||
  886. +                 currentGC == screen->r_reverseGC)
  887. +                 XDrawString(screen->display, 
  888. +                     TextWindow(screen), currentGC,
  889. +                     cx + 1, cy, str, len);
  890. +     } else {
  891. + #endif    KANJI
  892.        XDrawImageString(screen->display, TextWindow(screen), currentGC,
  893.               cx, cy, str, len);
  894.   
  895.       if((fgs & BOLD) && screen->enbolden) 
  896. ! /*
  897. !  * Bug fix by michael
  898. !  * original:    if (currentGC == screen->normalGC || screen->reverseGC) 
  899. !  */
  900. !         if (currentGC == screen->normalGC ||
  901. !             currentGC == screen->reverseGC)
  902.               XDrawString(screen->display, TextWindow(screen),
  903.                         currentGC,cx + 1, cy, str, len);
  904. + #ifdef    KANJI    /* sano */
  905. +     }
  906. + #endif    KANJI
  907.   
  908.       if(fgs & UNDERLINE) 
  909.           XDrawLine(screen->display, TextWindow(screen), currentGC,
  910. ***************
  911. *** 1309,1314 ****
  912. --- 1805,1813 ----
  913.                           + screen->scrollbar,
  914.                           (Dimension) FontHeight(screen)
  915.                           * (screen->max_row + 1)
  916. + #ifdef    STATUSLINE    /* michael */
  917. +                         + screen->statusheight
  918. + #endif    STATUSLINE
  919.                           + 2 * screen->border,
  920.                           &replyWidth, &replyHeight);
  921.   
  922. ***************
  923. *** 1399,1404 ****
  924. --- 1898,1912 ----
  925.               else
  926.                   FromAlternate(screen);
  927.               break;
  928. + #ifdef    STATUSLINE    /* michael */
  929. +         case 48:
  930. +             j = screen->reversestatus;
  931. +             (*func)(&screen->reversestatus, 1);
  932. +             if (j != screen->reversestatus)
  933. +                 ScrnRefresh(screen, screen->max_row + 1, 0, 1,
  934. +                     screen->max_col + 1);
  935. +             break;
  936. + #endif    STATUSLINE
  937.           case 1000:        /* xtem bogus sequence        */
  938.               if(func == bitset)
  939.                   screen->send_mouse_pos = 2;
  940. ***************
  941. *** 1474,1479 ****
  942. --- 1982,1992 ----
  943.           case 47:        /* alternate buffer        */
  944.               screen->save_modes[15] = screen->alternate;
  945.               break;
  946. + #ifdef    STATUSLINE    /* michael */
  947. +         case 48:
  948. +             screen->save_modes[16] = screen->reversestatus;
  949. +             break;
  950. + #endif    STATUSLINE
  951.           case 1000:        /* mouse bogus sequence        */
  952.           case 1001:
  953.               screen->save_modes[7] = screen->send_mouse_pos;
  954. ***************
  955. *** 1514,1519 ****
  956. --- 2027,2035 ----
  957.                           + screen->scrollbar,
  958.                           (Dimension) FontHeight(screen)
  959.                           * (screen->max_row + 1)
  960. + #ifdef    STATUSLINE    /* michael */
  961. +                         + screen->statusheight
  962. + #endif    STATUSLINE
  963.                           + 2*screen->border,
  964.                           &replyWidth, &replyHeight);
  965.   
  966. ***************
  967. *** 1601,1606 ****
  968. --- 2117,2131 ----
  969.               else
  970.                   FromAlternate(screen);
  971.               break;
  972. + #ifdef    STATUSLINE    /* michael */
  973. +         case 48:        /* reverse status line */
  974. +             if (screen->save_modes[16] != screen->reversestatus) {
  975. +                 screen->reversestatus = screen->save_modes[16];
  976. +                 ScrnRefresh(screen, screen->max_row + 1, 0, 1,
  977. +                         screen->max_col + 1);
  978. +             }
  979. +             break;
  980. + #endif    STATUSLINE
  981.           case 1000:        /* mouse bogus sequence        */
  982.           case 1001:
  983.               screen->send_mouse_pos = screen->save_modes[7];
  984. ***************
  985. *** 1695,1702 ****
  986. --- 2220,2232 ----
  987.       if(screen->alternate)
  988.           return;
  989.       if(!screen->altbuf)
  990. + #ifdef    STATUSLINE    /* michael */
  991. +         screen->altbuf = Allocate(screen->max_row + 2, screen->max_col
  992. +          + 1);
  993. + #else    STATUSLINE
  994.           screen->altbuf = Allocate(screen->max_row + 1, screen->max_col
  995.            + 1);
  996. + #endif    STATUSLINE
  997.       SwitchBufs(screen);
  998.       screen->alternate = TRUE;
  999.   }
  1000. ***************
  1001. *** 1727,1733 ****
  1002. --- 2257,2267 ----
  1003.       if((top = -screen->topline) <= screen->max_row) {
  1004.           if(screen->scroll_amt)
  1005.               FlushScroll(screen);
  1006. + #ifdef    STATUSLINE    /* michael */
  1007. +         if(top == 0 && !screen->statusline)
  1008. + #else    STATUSLINE
  1009.           if(top == 0)
  1010. + #endif    STATUSLINE
  1011.               XClearWindow(screen->display, TextWindow(screen));
  1012.           else
  1013.               XClearArea(
  1014. ***************
  1015. *** 1846,1852 ****
  1016. --- 2380,2397 ----
  1017.   Widget w;
  1018.   {
  1019.          if (XtIsRealized(w))
  1020. + #ifdef    STATUSLINE    /* kato */
  1021. +     {
  1022.             ScreenResize (&term->screen, term->core.width, term->core.height, &term->flags);
  1023. +       XClearWindow(term->screen.display, term->screen.fullVwin.window);
  1024. +       ScrnRefresh(&term->screen, 0, 0,
  1025. +         term->screen.max_row,
  1026. +         term->screen.max_col);
  1027. +     }
  1028. + #else    STATUSLINE
  1029. +           ScreenResize (&term->screen, term->core.width, term->core.height, &term->flags);
  1030. + #endif    STATUSLINE
  1031. + 
  1032.   }
  1033.   
  1034.   static Boolean failed = FALSE;
  1035. ***************
  1036. *** 1909,1914 ****
  1037. --- 2454,2463 ----
  1038.      new->screen.always_highlight = request->screen.always_highlight;
  1039.      new->screen.pointer_cursor = request->screen.pointer_cursor;
  1040.      new->misc.titeInhibit = request->misc.titeInhibit;
  1041. + #ifdef    STATUSLINE    /* kato */
  1042. +    new->screen.statusline = request->screen.statusline;
  1043. +    new->screen.reversestatus = request->screen.reversestatus;
  1044. + #endif    STATUSLINE
  1045.   
  1046.       /*
  1047.        * set the colors if reverse video; this is somewhat tricky since
  1048. ***************
  1049. *** 1993,1998 ****
  1050. --- 2542,2551 ----
  1051.       
  1052.       TabReset (term->tabs);
  1053.   
  1054. + #ifdef    KANJI    /* sano */
  1055. +     screen->fnt_r_norm = screen->fnt_r_bold =
  1056. +     screen->fnt_w_norm = screen->fnt_w_bold =
  1057. + #endif    KANJI
  1058.       screen->fnt_norm = screen->fnt_bold = NULL;
  1059.       
  1060.       /* do the XFont calls */
  1061. ***************
  1062. *** 2014,2020 ****
  1063. --- 2567,2596 ----
  1064.           screen->fnt_bold = screen->fnt_norm;
  1065.           screen->enbolden = TRUE;  /*no bold font */
  1066.       }
  1067. + #ifdef    KANJI    /* sano */
  1068. +     if (!term->misc.f_rn ||
  1069. +         !(screen->fnt_r_norm =
  1070. +             XLoadQueryFont(screen->display, term->misc.f_rn)))
  1071. +         screen->fnt_r_norm = screen->fnt_norm;
  1072. +     if (!term->misc.f_rb ||
  1073. +         !(screen->fnt_r_bold =
  1074. +             XLoadQueryFont(screen->display, term->misc.f_rb))) {
  1075. +         screen->fnt_r_bold = screen->fnt_r_norm;
  1076. +         screen->r_enbolden = TRUE;    /* no bold font */
  1077. +     }
  1078.   
  1079. +     if (!term->misc.f_kn ||
  1080. +         !(screen->fnt_w_norm =
  1081. +             XLoadQueryFont(screen->display, term->misc.f_kn)))
  1082. +         screen->fnt_w_norm = screen->fnt_norm;
  1083. +     if (!term->misc.f_kb ||
  1084. +         !(screen->fnt_w_bold =
  1085. +             XLoadQueryFont(screen->display, term->misc.f_kb))) {
  1086. +         screen->fnt_w_bold = screen->fnt_w_norm;
  1087. +         screen->w_enbolden = TRUE;    /* no bold font */
  1088. +     }
  1089. + #endif    KANJI
  1090. + 
  1091.       /* find the max width and higth of the font */
  1092.   
  1093.       screen->fullVwin.f_width = screen->fnt_norm->max_bounds.width;
  1094. ***************
  1095. *** 2042,2051 ****
  1096. --- 2618,2635 ----
  1097.                  screen->scrollWidget->core.width : 0);
  1098.       i = 2 * screen->border + scrollbar_width;
  1099.       j = 2 * screen->border;
  1100. + #ifdef    STATUSLINE    /* michael */
  1101. +     if (screen->statusline)
  1102. +         j += (screen->statusheight = screen->fullVwin.f_height + 2);
  1103. + #endif    STATUSLINE
  1104.   
  1105.   
  1106.       /* set defaults */
  1107. + #ifdef    KANJI    /* ishisone */
  1108. +     xpos = 0; ypos = 0; width = 80; height = 24;
  1109. + #else    /* KANJI */
  1110.       xpos = 1; ypos = 1; width = 80; height = 24;
  1111. + #endif    /* KANJI */
  1112.   
  1113.       pr = XParseGeometry(term->misc.geo_metry, &xpos, &ypos, &width, &height);
  1114.   
  1115. ***************
  1116. *** 2064,2069 ****
  1117. --- 2648,2656 ----
  1118.       /* set up size hints for window manager */
  1119.       sizehints.min_width = 2 * screen->border + scrollbar_width;
  1120.       sizehints.min_height = 2 * screen->border;
  1121. + #ifdef    STATUSLINE    /* ishisone */
  1122. +     sizehints.min_height += screen->statusheight;
  1123. + #endif
  1124.       sizehints.width_inc = FontWidth(screen);
  1125.       sizehints.height_inc = FontHeight(screen);
  1126.       sizehints.flags = PMinSize|PResizeInc;
  1127. ***************
  1128. *** 2101,2107 ****
  1129. --- 2688,2698 ----
  1130.       if (term->misc.re_verse && (term->core.border_pixel == term->core.background_pixel))
  1131.           values->border_pixel = term->core.border_pixel = term->screen.foreground;
  1132.       
  1133. + #ifdef STATUSLINE
  1134. +     values->bit_gravity = ForgetGravity;
  1135. + #else
  1136.       values->bit_gravity = NorthWestGravity;
  1137. + #endif
  1138.       term->screen.fullVwin.window = term->core.window =
  1139.         XCreateWindow(XtDisplay(term), XtWindow(term->core.parent),
  1140.           term->core.x, term->core.y,
  1141. ***************
  1142. *** 2122,2127 ****
  1143. --- 2713,2732 ----
  1144.       xgcv.background = term->core.background_pixel;
  1145.   
  1146.       screen->normalGC = XtGetGC((Widget)term, mask, &xgcv);
  1147. + #ifdef    KANJI    /* sano */
  1148. +     if (screen->fnt_r_norm == screen->fnt_norm) {
  1149. +         screen->r_normalGC = screen->normalGC;
  1150. +     } else {
  1151. +         xgcv.font = screen->fnt_r_norm->fid;
  1152. +         screen->r_normalGC = XtGetGC((Widget)term, mask, &xgcv) ;
  1153. +     }
  1154. +     if (screen->fnt_w_norm == screen->fnt_norm) {
  1155. +         screen->w_normalGC = screen->normalGC;
  1156. +     } else {
  1157. +         xgcv.font = screen->fnt_w_norm->fid;
  1158. +         screen->w_normalGC = XtGetGC((Widget)term, mask, &xgcv) ;
  1159. +     }
  1160. + #endif    KANJI
  1161.   
  1162.       if (screen->enbolden) { /* there is no bold font */
  1163.           xgcv.font = screen->fnt_norm->fid;
  1164. ***************
  1165. *** 2130,2135 ****
  1166. --- 2735,2756 ----
  1167.           xgcv.font = screen->fnt_bold->fid;
  1168.           screen->normalboldGC = XtGetGC((Widget)term, mask, &xgcv);
  1169.       }
  1170. + #ifdef    KANJI    /* sano */
  1171. +     if (screen->r_enbolden) {    /* there is no bold kana font */
  1172. +         xgcv.font = screen->fnt_r_norm->fid;
  1173. +         screen->r_normalboldGC = screen->r_normalGC;
  1174. +     } else {
  1175. +         xgcv.font = screen->fnt_r_bold->fid;
  1176. +         screen->r_normalboldGC = XtGetGC((Widget)term, mask, &xgcv);
  1177. +     }
  1178. +     if (screen->w_enbolden) {    /* there is no bold kanji font */
  1179. +         xgcv.font = screen->fnt_w_norm->fid;
  1180. +         screen->w_normalboldGC = screen->w_normalGC;
  1181. +     } else {
  1182. +         xgcv.font = screen->fnt_w_bold->fid;
  1183. +         screen->w_normalboldGC = XtGetGC((Widget)term, mask, &xgcv);
  1184. +     }
  1185. + #endif    KANJI
  1186.   
  1187.       xgcv.font = screen->fnt_norm->fid;
  1188.       xgcv.foreground = term->core.background_pixel;
  1189. ***************
  1190. *** 2137,2142 ****
  1191. --- 2758,2778 ----
  1192.   
  1193.       screen->reverseGC = XtGetGC((Widget)term, mask, &xgcv);
  1194.   
  1195. + #ifdef    KANJI    /* sano */
  1196. +     if (screen->fnt_r_norm == screen->fnt_norm) {
  1197. +         screen->r_reverseGC = screen->reverseGC;
  1198. +     } else {
  1199. +         xgcv.font = screen->fnt_r_norm->fid;
  1200. +         screen->r_reverseGC = XtGetGC((Widget)term, mask, &xgcv);
  1201. +     }
  1202. +     if (screen->fnt_w_norm == screen->fnt_norm) {
  1203. +         screen->w_reverseGC = screen->reverseGC;
  1204. +     } else {
  1205. +         xgcv.font = screen->fnt_w_norm->fid;
  1206. +         screen->w_reverseGC = XtGetGC((Widget)term, mask, &xgcv);
  1207. +     }
  1208. + #endif    KANJI
  1209. + 
  1210.       if (screen->enbolden) /* there is no bold font */
  1211.           xgcv.font = screen->fnt_norm->fid;
  1212.       else
  1213. ***************
  1214. *** 2144,2149 ****
  1215. --- 2780,2801 ----
  1216.   
  1217.       screen->reverseboldGC = XtGetGC((Widget)term, mask, &xgcv);
  1218.   
  1219. + #ifdef    KANJI    /* sano */
  1220. +     if (screen->r_enbolden) {    /* there is no bold kana font */
  1221. +         xgcv.font = screen->fnt_r_norm->fid;
  1222. +     } else {
  1223. +         xgcv.font = screen->fnt_r_bold->fid;
  1224. +     }
  1225. +     screen->r_reverseboldGC = XtGetGC((Widget)term, mask, &xgcv);
  1226. + 
  1227. +     if (screen->w_enbolden) {    /* there is no bold kanji font */
  1228. +         xgcv.font = screen->fnt_w_norm->fid;
  1229. +     } else {
  1230. +         xgcv.font = screen->fnt_w_bold->fid;
  1231. +     }
  1232. +     screen->w_reverseboldGC = XtGetGC((Widget)term, mask, &xgcv);
  1233. + #endif    KANJI
  1234. + 
  1235.       /* we also need a set of caret (called a cursor here) gc's */
  1236.   
  1237.       xgcv.font = screen->fnt_norm->fid;
  1238. ***************
  1239. *** 2198,2208 ****
  1240. --- 2850,2908 ----
  1241.           screen->cursoroutlineGC = (GC) 0;
  1242.           }
  1243.       }
  1244. + #ifdef    KANJI    /* michael */
  1245. +     xgcv.font = screen->fnt_r_norm->fid;
  1246. +     {
  1247. +         unsigned long cc = screen->cursorcolor;
  1248. +         unsigned long fg = screen->foreground;
  1249. +         unsigned long bg = term->core.background_pixel;
  1250.   
  1251. +         if (cc != fg && cc != bg) {
  1252. +         /* we have a colored cursor */
  1253. +         xgcv.foreground = fg;
  1254. +         xgcv.background = cc;
  1255. +         screen->r_cursorGC = XtGetGC ((Widget) term, mask, &xgcv);
  1256. + 
  1257. +         xgcv.foreground = bg;
  1258. +         xgcv.background = cc;
  1259. +         screen->r_reversecursorGC = XtGetGC ((Widget) term, mask, &xgcv);
  1260. +         } else {
  1261. +         screen->r_cursorGC = (GC) 0;
  1262. +         screen->r_reversecursorGC = (GC) 0;
  1263. +         }
  1264. +     }
  1265. + 
  1266. +     xgcv.font = screen->fnt_w_norm->fid;
  1267. +     {
  1268. +         unsigned long cc = screen->cursorcolor;
  1269. +         unsigned long fg = screen->foreground;
  1270. +         unsigned long bg = term->core.background_pixel;
  1271. + 
  1272. +         if (cc != fg && cc != bg) {
  1273. +         /* we have a colored cursor */
  1274. +         xgcv.foreground = fg;
  1275. +         xgcv.background = cc;
  1276. +         screen->w_cursorGC = XtGetGC ((Widget) term, mask, &xgcv);
  1277. + 
  1278. +         xgcv.foreground = bg;
  1279. +         xgcv.background = cc;
  1280. +         screen->w_reversecursorGC = XtGetGC ((Widget) term, mask, &xgcv);
  1281. +         } else {
  1282. +         screen->w_cursorGC = (GC) 0;
  1283. +         screen->w_reversecursorGC = (GC) 0;
  1284. +         }
  1285. +     }
  1286. + #endif    KANJI
  1287. +     
  1288. + 
  1289.       /* Reset variables used by ANSI emulation. */
  1290.   
  1291.       screen->gsets[0] = 'B';            /* ASCII_G        */
  1292. + #ifdef    KANJI    /* sano */
  1293. +     screen->gsets[1] = 'I';
  1294. + #else    KANJI
  1295.       screen->gsets[1] = 'B';
  1296. + #endif    KANJI
  1297.       screen->gsets[2] = 'B';            /* DEC supplemental.    */
  1298.       screen->gsets[3] = 'B';
  1299.       screen->curgl = 0;            /* G0 => GL.        */
  1300. ***************
  1301. *** 2230,2240 ****
  1302. --- 2930,2969 ----
  1303.       screen->scrolls = screen->incopy = 0;
  1304.   /*    free((char *)fInfo);    */
  1305.       vp = &VTbox[1];
  1306. + #ifdef R2SERVER
  1307.       (vp++)->x = FontWidth(screen) - 1;
  1308. +     (vp++)->y = screen->fnt_norm->max_bounds.ascent +
  1309. +             screen->fnt_norm->max_bounds.descent - 1;
  1310. +     (vp++)->x = -(FontWidth(screen) - 1);
  1311. +     vp->y = -(screen->fnt_norm->max_bounds.ascent +
  1312. +             screen->fnt_norm->max_bounds.descent - 1);
  1313. + #else
  1314. +     (vp++)->x = FontWidth(screen) - 1;
  1315.       (vp++)->y = FontHeight(screen) - 1;
  1316.       (vp++)->x = -(FontWidth(screen) - 1);
  1317.       vp->y = -(FontHeight(screen) - 1);
  1318. + #endif
  1319.       screen->box = VTbox;
  1320. + #ifdef    KANJI    /* sano */
  1321. +     vp = &VTwbox[1];
  1322. + #ifdef R2SERVER
  1323. +     (vp++)->x = FontWidth(screen) * 2 - 1;
  1324. +     (vp++)->y = screen->fnt_norm->max_bounds.ascent +
  1325. +             screen->fnt_norm->max_bounds.descent - 1;
  1326. +     (vp++)->x = -(FontWidth(screen) * 2 - 1);
  1327. +     vp->y = -(screen->fnt_norm->max_bounds.ascent +
  1328. +             screen->fnt_norm->max_bounds.descent - 1);
  1329. + #else
  1330. +     (vp++)->x = FontWidth(screen) * 2 - 1;
  1331. +     (vp++)->y = FontHeight(screen) - 1;
  1332. +     (vp++)->x = -(FontWidth(screen) * 2 - 1);
  1333. +     vp->y = -(FontHeight(screen) - 1);
  1334. + #endif
  1335. +     screen->w_box = VTwbox;
  1336. + #endif    KANJI
  1337. + #ifdef    STATUSLINE    /* michael */
  1338. +     status_box[0].x = screen->border - 1;
  1339. + #endif    STATUSLINE
  1340.   
  1341.       screen->savedlines = 0;
  1342.   
  1343. ***************
  1344. *** 2254,2272 ****
  1345. --- 2983,3030 ----
  1346.   {
  1347.       register TScreen *screen = &term->screen;
  1348.       register int x, y, flags;
  1349. + #ifdef    KANJI    /* sano */
  1350. +     register int offset = 0;
  1351. +     unsigned char cc[2];
  1352. + #else    KANJI
  1353.       char c;
  1354. + #endif    KANJI
  1355.       GC    currentGC;
  1356.       Boolean    in_selection;
  1357.   
  1358.       if (eventMode != NORMAL) return;
  1359.   
  1360. + #ifdef    STATUSLINE    /* michael */
  1361. +     if (!screen->instatus &&
  1362. +         screen->cur_row - screen->topline > screen->max_row)
  1363. + #else    STATUSLINE
  1364.       if (screen->cur_row - screen->topline > screen->max_row)
  1365. + #endif    STATUSLINE
  1366.           return;
  1367. + #ifdef    KANJI    /* sano */
  1368. +     cc[0] = screen->buf[y = 2 * (screen->cursor_row = screen->cur_row)]
  1369. + #else    KANJI
  1370.       c = screen->buf[y = 2 * (screen->cursor_row = screen->cur_row)]
  1371. + #endif    KANJI
  1372.        [x = screen->cursor_col = screen->cur_col];
  1373.       flags = screen->buf[y + 1][x];
  1374. + #ifdef    KANJI    /* sano */
  1375. +     if (cc[0] == 0) {
  1376. +         cc[0] = ' ';
  1377. +         flags &= ~(KCS|KANACS);
  1378. +     } else if (flags & KCS) {
  1379. +         if (flags & KCS1)
  1380. +             cc[1] = screen->buf[y][x + 1];
  1381. +         else {
  1382. +             offset = -1;
  1383. +             cc[1] = cc[0];
  1384. +             cc[0] = screen->buf[y][x - 1];
  1385. +         }
  1386. +     }
  1387. + #else    KANJI
  1388.       if (c == 0)
  1389.           c = ' ';
  1390. + #endif    KANJI
  1391.   
  1392.       if (screen->cur_row > screen->endHRow ||
  1393.           (screen->cur_row == screen->endHRow &&
  1394. ***************
  1395. *** 2278,2284 ****
  1396. --- 3036,3109 ----
  1397.       else
  1398.           in_selection = True;
  1399.   
  1400. + #ifdef    STATUSLINE    /* michael */
  1401. +     if(screen->instatus && screen->reversestatus)
  1402. + /*    if (screen->instatus)    */
  1403. +         flags ^= INVERSE;
  1404. + #endif    STATUSLINE
  1405. + 
  1406.       if(screen->select || screen->always_highlight) {
  1407. + #ifdef    KANJI    /* sano & micheal */
  1408. +         if (flags & KCS) {
  1409. +             if (( (flags & INVERSE) && !in_selection) ||
  1410. +                 (!(flags & INVERSE) &&  in_selection)){
  1411. +                 /* text is reverse video */
  1412. +                 if (screen->w_cursorGC) {
  1413. +                     currentGC = screen->w_cursorGC;
  1414. +                 } else {
  1415. +                     if (flags & BOLD) {
  1416. +                         currentGC =
  1417. +                             screen->w_normalboldGC;
  1418. +                     } else {
  1419. +                         currentGC =
  1420. +                             screen->w_normalGC;
  1421. +                     }
  1422. +                 }
  1423. +             } else {    /* normal video */
  1424. +                 if (screen->w_reversecursorGC) {
  1425. +                     currentGC = screen->w_reversecursorGC;
  1426. +                 } else {
  1427. +                     if (flags & BOLD) {
  1428. +                         currentGC =
  1429. +                             screen->w_reverseboldGC;
  1430. +                     } else {
  1431. +                         currentGC =
  1432. +                             screen->w_reverseGC;
  1433. +                     }
  1434. +                 }
  1435. + 
  1436. +             }
  1437. +         } else if (flags & KANACS) {
  1438. +             if (( (flags & INVERSE) && !in_selection) ||
  1439. +                 (!(flags & INVERSE) &&  in_selection)){
  1440. +                 /* text is reverse video */
  1441. +                 if (screen->r_cursorGC) {
  1442. +                     currentGC = screen->r_cursorGC;
  1443. +                 } else {
  1444. +                     if (flags & BOLD) {
  1445. +                         currentGC =
  1446. +                             screen->r_normalboldGC;
  1447. +                     } else {
  1448. +                         currentGC =
  1449. +                             screen->r_normalGC;
  1450. +                     }
  1451. +                 }
  1452. +             } else {    /* normal video */
  1453. +                 if (screen->r_reversecursorGC) {
  1454. +                     currentGC = screen->r_reversecursorGC;
  1455. +                 } else {
  1456. +                     if (flags & BOLD) {
  1457. +                         currentGC =
  1458. +                             screen->r_reverseboldGC;
  1459. +                     } else {
  1460. +                         currentGC =
  1461. +                             screen->r_reverseGC;
  1462. +                     }
  1463. +                 }
  1464. + 
  1465. +             }
  1466. +         } else
  1467. + #endif    KANJI
  1468.           if (( (flags & INVERSE) && !in_selection) ||
  1469.               (!(flags & INVERSE) &&  in_selection)){
  1470.               /* text is reverse video */
  1471. ***************
  1472. *** 2303,2321 ****
  1473.               }
  1474.           }
  1475.       } else { /* not selected */
  1476.           if (( (flags & INVERSE) && !in_selection) ||
  1477.               (!(flags & INVERSE) &&  in_selection)) {
  1478.               /* text is reverse video */
  1479. !             currentGC = screen->reverseGC;
  1480.           } else { /* normal video */
  1481. !             currentGC = screen->normalGC;
  1482.           }
  1483.           
  1484.       }
  1485.   
  1486.       x = CursorX (screen, screen->cur_col);
  1487.       y = CursorY(screen, screen->cur_row) + 
  1488.         screen->fnt_norm->ascent;
  1489.       XDrawImageString(screen->display, TextWindow(screen), currentGC,
  1490.           x, y, &c, 1);
  1491.   
  1492. --- 3128,3254 ----
  1493.               }
  1494.           }
  1495.       } else { /* not selected */
  1496. + #ifdef    KANJI    /* sano */
  1497. +         if (flags & KCS) {
  1498. +             if (( (flags & INVERSE) && !in_selection) ||
  1499. +                 (!(flags & INVERSE) &&  in_selection)) {
  1500. +                 /* text is reverse video */
  1501. +                 if (screen->w_reversecursorGC) {
  1502. +                     currentGC = screen->w_reversecursorGC;
  1503. +                 } else {
  1504. +                     currentGC = screen->w_reverseGC;
  1505. +                 }
  1506. +             } else {    /* normal video */
  1507. +                 if (screen->w_cursorGC) {
  1508. +                     currentGC = screen->w_cursorGC;
  1509. +                 } else {
  1510. +                     currentGC = screen->w_normalGC;
  1511. +                 }
  1512. +             }
  1513. +         } else if (flags & KANACS) {
  1514. +             if (( (flags & INVERSE) && !in_selection) ||
  1515. +                 (!(flags & INVERSE) &&  in_selection)) {
  1516. +                 /* text is reverse video */
  1517. +                 if (screen->r_reversecursorGC) {
  1518. +                     currentGC = screen->r_reversecursorGC;
  1519. +                 } else {
  1520. +                     currentGC = screen->r_reverseGC;
  1521. +                 }
  1522. +             } else {    /* normal video */
  1523. +                 if (screen->r_cursorGC) {
  1524. +                     currentGC = screen->r_cursorGC;
  1525. +                 } else {
  1526. +                     currentGC = screen->r_normalGC;
  1527. +                 }
  1528. +             }
  1529. +         } else
  1530. + #endif    KANJI
  1531. + 
  1532. + /*
  1533. +  * Bug fix by michael
  1534. +  * Originials:
  1535. +  *        if(flags & INVERSE) { /* is reverse video */
  1536. + /*            currentGC = screen->reverseGC;
  1537. +  *        } else { /* normal video */
  1538. + /*            currentGC = screen->normalGC;
  1539. +  *        }
  1540. +  */
  1541.           if (( (flags & INVERSE) && !in_selection) ||
  1542.               (!(flags & INVERSE) &&  in_selection)) {
  1543.               /* text is reverse video */
  1544. !             if (screen->reversecursorGC) {
  1545. !                 currentGC = screen->reversecursorGC;
  1546. !             } else {
  1547. !                 currentGC = screen->reverseGC;
  1548. !             }
  1549.           } else { /* normal video */
  1550. !             if (screen->cursorGC) {
  1551. !                 currentGC = screen->cursorGC;
  1552. !             } else {
  1553. !                 currentGC = screen->normalGC;
  1554. !             }
  1555.           }
  1556.           
  1557.       }
  1558.   
  1559. + 
  1560. + #ifdef    KANJI    /* sano */
  1561. +     x = CursorX (screen, screen->cur_col + offset);
  1562. + #else    KANJI
  1563.       x = CursorX (screen, screen->cur_col);
  1564. + #endif    KANJI
  1565.       y = CursorY(screen, screen->cur_row) + 
  1566.         screen->fnt_norm->ascent;
  1567. + #ifdef    KANJI    /* sano */
  1568. +     if (flags & KCS) {
  1569. +         /*
  1570. +          * If the cursor is on a Kanji character, then it should
  1571. +          * be drawn as the double sized cursor. If the screen is
  1572. +          * selected, the currentGC should be k_reverseGC or
  1573. +          * k_reverseboldGC, and then inversed cursor is obtained.
  1574. +          * If the screen is not selected, draw a box with w_box.
  1575. +          */
  1576. +         XDrawImageString16(screen->display, TextWindow(screen),
  1577. +             currentGC, x, y, (XChar2b *)cc, 1);
  1578. +         if ((flags & BOLD) && screen->w_enbolden) /* no bold kanji font*/
  1579. +             XDrawString16(screen->display, TextWindow(screen),
  1580. +                 currentGC, x + 1, y, (XChar2b *)cc, 1);
  1581. +         if (flags & UNDERLINE)
  1582. +             XDrawLine(screen->display, TextWindow(screen),
  1583. +                 currentGC, x, y + 1,
  1584. +                 x + FontWidth(screen) * 2, y + 1);
  1585. +         if (!screen->select) {
  1586. +             screen->w_box->x = x;
  1587. +             screen->w_box->y = y - screen->fnt_norm->ascent;
  1588. +             XDrawLines(screen->display, TextWindow(screen),
  1589. +                 currentGC, screen->w_box, NBOX,
  1590. +                 CoordModePrevious);
  1591. +         }
  1592. +     } else {
  1593. +         XDrawImageString(screen->display, TextWindow(screen),
  1594. +             currentGC, x, y, cc, 1);
  1595. +         if (flags & KANACS) {
  1596. +             if ((flags & BOLD) && screen->r_enbolden) /* no bold */
  1597. +                 XDrawString(screen->display, TextWindow(screen),
  1598. +                     currentGC, x + 1, y, cc, 1);
  1599. +         } else {
  1600. +             if ((flags & BOLD) && screen->enbolden) /* no bold */
  1601. +                 XDrawString(screen->display, TextWindow(screen),
  1602. +                     currentGC, x + 1, y, cc, 1);
  1603. +         }
  1604. +         if (flags & UNDERLINE)
  1605. +             XDrawLine(screen->display, TextWindow(screen),
  1606. +                 currentGC, x, y + 1,
  1607. +                 x + FontWidth(screen), y + 1);
  1608. +         if (!screen->select) {
  1609. +             screen->box->x = x;
  1610. +             screen->box->y = y - screen->fnt_norm->ascent;
  1611. +             XDrawLines(screen->display, TextWindow(screen),
  1612. +                 currentGC, screen->box,
  1613. +                 NBOX, CoordModePrevious);
  1614. +         }
  1615. +     }
  1616. + #else    KANJI
  1617.       XDrawImageString(screen->display, TextWindow(screen), currentGC,
  1618.           x, y, &c, 1);
  1619.   
  1620. ***************
  1621. *** 2333,2338 ****
  1622. --- 3266,3272 ----
  1623.                                   : currentGC,
  1624.                   screen->box, NBOX, CoordModePrevious);
  1625.       }
  1626. + #endif    KANJI
  1627.       screen->cursor_state = ON;
  1628.   }
  1629.   
  1630. ***************
  1631. *** 2344,2355 ****
  1632. --- 3278,3306 ----
  1633.       register TScreen *screen = &term->screen;
  1634.       GC    currentGC;
  1635.       register int x, y, flags;
  1636. + #ifdef    STATUSLINE    /* michael */
  1637. +     register int instatus;
  1638. + #endif    STATUSLINE
  1639. + #ifdef    KANJI    /* sano */
  1640. +     register offset = 0;
  1641. +     unsigned char cc[2];
  1642. + #else    KANJI
  1643.       char c;
  1644. + #endif    KANJI
  1645.       Boolean    in_selection;
  1646.   
  1647. + #ifdef    STATUSLINE    /* michael */
  1648. +     if(!(instatus = screen->cursor_row > screen->max_row) &&
  1649. +        screen->cursor_row - screen->topline > screen->max_row)
  1650. + #else    STATUSLINE
  1651.       if(screen->cursor_row - screen->topline > screen->max_row)
  1652. + #endif    STATUSLINE
  1653.           return;
  1654. + #ifdef    KANJI    /* sano */
  1655. +     cc[0] = screen->buf[y = 2 * screen->cursor_row][x = screen->cursor_col];
  1656. + #else    KANJI
  1657.       c = screen->buf[y = 2 * screen->cursor_row][x = screen->cursor_col];
  1658. + #endif    KANJI
  1659.       flags = screen->buf[y + 1][x];
  1660.   
  1661.       if (screen->cursor_row > screen->endHRow ||
  1662. ***************
  1663. *** 2362,2367 ****
  1664. --- 3313,3356 ----
  1665.       else
  1666.           in_selection = True;
  1667.   
  1668. + #ifdef    STATUSLINE    /* michael */
  1669. +     if(screen->instatus && screen->reversestatus)
  1670. + /*    if (screen->instatus)    */
  1671. +         flags ^= INVERSE;
  1672. + #endif    STATUSLINE
  1673. + #ifdef    KANJI    /* sano */
  1674. +     if (flags & KCS) {
  1675. +         if (( (flags & INVERSE) && !in_selection) ||
  1676. +             (!(flags & INVERSE) &&  in_selection)) {
  1677. +             if (flags & BOLD) {
  1678. +                 currentGC = screen->w_reverseboldGC;
  1679. +             } else {
  1680. +                 currentGC = screen->w_reverseGC;
  1681. +             }
  1682. +         } else {
  1683. +             if (flags & BOLD) {
  1684. +                 currentGC = screen->w_normalboldGC;
  1685. +             } else {
  1686. +                 currentGC = screen->w_normalGC;
  1687. +             }
  1688. +         }
  1689. +     } else if (flags & KANACS) {
  1690. +         if (( (flags & INVERSE) && !in_selection) ||
  1691. +             (!(flags & INVERSE) &&  in_selection)) {
  1692. +             if (flags & BOLD) {
  1693. +                 currentGC = screen->r_reverseboldGC;
  1694. +             } else {
  1695. +                 currentGC = screen->r_reverseGC;
  1696. +             }
  1697. +         } else {
  1698. +             if (flags & BOLD) {
  1699. +                 currentGC = screen->r_normalboldGC;
  1700. +             } else {
  1701. +                 currentGC = screen->r_normalGC;
  1702. +             }
  1703. +         }
  1704. +     } else
  1705. + #endif    KANJI
  1706.       if (( (flags & INVERSE) && !in_selection) ||
  1707.           (!(flags & INVERSE) &&  in_selection)) {
  1708.           if(flags & BOLD) {
  1709. ***************
  1710. *** 2377,2388 ****
  1711. --- 3366,3430 ----
  1712.           }
  1713.       }
  1714.   
  1715. + #ifdef    KANJI    /* sano */
  1716. +     if (cc[0] == 0) {
  1717. +         cc[0] = ' ';
  1718. +         flags &= ~(KCS|KANACS);
  1719. +     } else if (flags & KCS) {
  1720. +         if (flags & KCS1)
  1721. +             cc[1] = screen->buf[y][x + 1];
  1722. +         else {
  1723. +             offset = -1;
  1724. +             cc[1] = cc[0];
  1725. +             cc[0] = screen->buf[y][x - 1];
  1726. +         }
  1727. +     }
  1728. + #else     KANJI
  1729.       if (c == 0)
  1730.           c = ' ';
  1731. + #endif    KANJI
  1732. + #ifdef    KANJI    /* sano */
  1733. +     x = CursorX (screen, screen->cursor_col + offset);
  1734. + #else    KANJI
  1735.       x = CursorX (screen, screen->cursor_col);
  1736. + #endif    KANJI
  1737. + #ifdef    STATUSLINE    /* michael */
  1738. +     y = (instatus ? (screen->cursor_row * FontHeight(screen) + 1) :
  1739. +           ((screen->cursor_row - screen->topline) * FontHeight(screen))) +
  1740. + #else    STATUSLINE
  1741.       y = (((screen->cursor_row - screen->topline) * FontHeight(screen))) +
  1742. + #endif    STATUSLINE
  1743.        screen->border;
  1744.       y = y+screen->fnt_norm->ascent;
  1745. + #ifdef    KANJI    /* sano */
  1746. +     if (flags & KCS) {
  1747. +         XDrawImageString16(screen->display, TextWindow(screen),
  1748. +             currentGC, x, y, (XChar2b *)cc, 1);
  1749. +         if ((flags & BOLD) && screen->w_enbolden)
  1750. +             XDrawString16(screen->display, TextWindow(screen),
  1751. +                 currentGC, x + 1, y, (XChar2b *)cc, 1);
  1752. +         if (flags & UNDERLINE)
  1753. +             XDrawLine(screen->display, TextWindow(screen),
  1754. +                 currentGC, x, y + 1,
  1755. +                 x + FontWidth(screen) * 2, y + 1);
  1756. +     } else {
  1757. +         XDrawImageString(screen->display, TextWindow(screen),
  1758. +             currentGC, x, y, cc, 1);
  1759. +         if (flags & KANACS) {
  1760. +             if ((flags & BOLD) && screen->r_enbolden)
  1761. +                 XDrawString(screen->display, TextWindow(screen),
  1762. +                     currentGC, x + 1, y, cc, 1);
  1763. +         } else {
  1764. +             if ((flags & BOLD) && screen->enbolden)
  1765. +                 XDrawString(screen->display, TextWindow(screen),
  1766. +                     currentGC, x + 1, y, cc, 1);
  1767. +         }
  1768. +         if (flags & UNDERLINE)
  1769. +             XDrawLine(screen->display, TextWindow(screen),
  1770. +                 currentGC, x, y + 1,
  1771. +                 x + FontWidth(screen), y + 1);
  1772. +     }
  1773. + #else    KANJI
  1774.       XDrawImageString(screen->display, TextWindow(screen), currentGC,
  1775.           x, y, &c, 1);
  1776.       if((flags & BOLD) && screen->enbolden)
  1777. ***************
  1778. *** 2391,2396 ****
  1779. --- 3433,3439 ----
  1780.       if(flags & UNDERLINE) 
  1781.           XDrawLine(screen->display, TextWindow(screen), currentGC,
  1782.               x, y+1, x + FontWidth(screen), y+1);
  1783. + #endif    KANJI
  1784.       screen->cursor_state = OFF;
  1785.   }
  1786.   
  1787. ***************
  1788. *** 2444,2450 ****
  1789. --- 3487,3498 ----
  1790.                   (Dimension) 80*FontWidth(screen)
  1791.                   + 2 * screen->border + screen->scrollbar,
  1792.                   (Dimension) FontHeight(screen)
  1793. + #ifdef    STATUSLINE    /* michael */
  1794. +                     * (screen->max_row + 1) + screen->statusheight +
  1795. +                 2 * screen->border,
  1796. + #else    STATUSLINE
  1797.                       * (screen->max_row + 1) + 2 * screen->border,
  1798. + #endif    STATUSLINE
  1799.                   &junk, &junk);
  1800.               XSync(screen->display, FALSE);    /* synchronize */
  1801.               if(QLength(screen->display) > 0)
  1802. ***************
  1803. *** 2455,2461 ****
  1804. --- 3503,3603 ----
  1805.       longjmp(vtjmpbuf, 1);    /* force ground state in parser */
  1806.   }
  1807.   
  1808. + #ifdef    STATUSLINE    /* michael */
  1809. + ToStatus(col)
  1810. + int col;
  1811. + {
  1812. +     register TScreen *screen = &term->screen;
  1813.   
  1814. +     if (screen->cursor_state)
  1815. +         HideCursor();
  1816. +     if (col > screen->max_col)
  1817. +         col = screen->max_col;
  1818. +     if (!screen->instatus) {
  1819. +         if (!screen->statusline)
  1820. +             ShowStatus();
  1821. +         CursorSave(term, &screen->statussc);
  1822. +         screen->instatus = TRUE;
  1823. +         screen->cur_row = screen->max_row + 1;
  1824. +     }
  1825. +     screen->cur_col = col;
  1826. + }
  1827. + 
  1828. + FromStatus()
  1829. + {
  1830. +     register TScreen *screen = &term->screen;
  1831. + 
  1832. +     if (!screen->instatus)
  1833. +         return;
  1834. +     screen->instatus = FALSE;
  1835. +     CursorRestore(term, &screen->statussc);
  1836. + }
  1837. + 
  1838. + ShowStatus()
  1839. + {
  1840. +     register TScreen *screen = &term->screen;
  1841. +     register int border = 2 * screen->border;
  1842. + 
  1843. +     if (screen->statusline)
  1844. +         return;
  1845. +     screen->statusline = 1;
  1846. +     screen->statusheight = FontHeight(screen) + 2;
  1847. +     ResizeScreen(term, border + screen->scrollbar, border);
  1848. + }
  1849. + 
  1850. + HideStatus()
  1851. + {
  1852. +     register TScreen *screen = &term->screen;
  1853. +     register int border = 2 * screen->border;
  1854. +     register int i, j;
  1855. + 
  1856. +     if (!screen->statusline)
  1857. +         return;
  1858. +     if (screen->instatus)
  1859. +         FromStatus();
  1860. +     screen->statusline = 0;
  1861. +     screen->statusheight = 0;
  1862. +     bzero(screen->buf[i = 2 * (screen->max_row + 1)],
  1863. +         j = screen->max_col + 1);
  1864. +     bzero(screen->buf[i + 1], j);
  1865. +     ResizeScreen(term, border + screen->scrollbar, border);
  1866. + }
  1867. + 
  1868. + EraseStatus()
  1869. + {
  1870. +     register TScreen *screen = &term->screen;
  1871. +     register int i, j, pix;
  1872. + 
  1873. +     if (!screen->statusline)
  1874. +         return;
  1875. +     bzero(screen->buf[i = 2 * (screen->max_row + 1)],
  1876. +         j = screen->max_col + 1);
  1877. +     bzero(screen->buf[i + 1], j) ;
  1878. +     XFillRectangle(screen->display, TextWindow(screen),
  1879. +         screen->reversestatus ? screen->normalGC : screen->reverseGC,
  1880. +         screen->border - 1 + screen->scrollbar,
  1881. +         (screen->max_row + 1) * FontHeight(screen) +
  1882. +         screen->border,
  1883. +         j * FontWidth(screen) + 2, screen->statusheight);
  1884. +     if (!screen->reversestatus)
  1885. +         StatusBox(screen);
  1886. + }
  1887. + 
  1888. + StatusBox(screen)
  1889. + register TScreen *screen;
  1890. + {
  1891. +     status_box[0].x = screen->scrollbar;
  1892. +     status_box[0].y = (screen->max_row + 1) * FontHeight(screen) +
  1893. +         screen->border;
  1894. +     status_box[3].x = -(status_box[1].x = (screen->max_col + 1) *
  1895. +         FontWidth(screen) + screen->border + 1);
  1896. +     status_box[4].y = -(status_box[2].y = FontHeight(screen) + 1);
  1897. +     XDrawLines(screen->display, TextWindow(screen), screen->normalGC,
  1898. +         status_box, NBOX, CoordModePrevious);
  1899. + }
  1900. + #endif    STATUSLINE
  1901. + 
  1902. + 
  1903.   #ifdef MODEMENU
  1904.   #define    MMENU_SCROLLBAR        0
  1905.   #define    MMENU_SCROLL        (MMENU_SCROLLBAR+1)
  1906. ***************
  1907. *** 2472,2483 ****
  1908. --- 3614,3637 ----
  1909.   #define MMENU_SCROLLKEY        (MMENU_PAD+1)
  1910.   #endif /* DO_AUTOREPEAT */
  1911.   #define    MMENU_SCROLLINPUT    (MMENU_SCROLLKEY+1)
  1912. + #ifdef    STATUSLINE    /* michael */
  1913. + #define    MMENU_STATUS        (MMENU_SCROLLINPUT+1)
  1914. + #define    MMENU_REVSTATUS        (MMENU_STATUS+1)
  1915. + #define    MMENU_C132        (MMENU_REVSTATUS+1)
  1916. + #else    STATUSLINE
  1917.   #define    MMENU_C132        (MMENU_SCROLLINPUT+1)
  1918. + #endif    STATUSLINE
  1919.   #define    MMENU_CURSES        (MMENU_C132+1)
  1920.   #define    MMENU_MARGBELL        (MMENU_CURSES+1)
  1921.   #define    MMENU_TEKWIN        (MMENU_MARGBELL+1)
  1922.   #define    MMENU_ALTERN        (MMENU_TEKWIN+1)
  1923. + #ifdef    KANJI    /* sano */
  1924. + #define    MMENU_EUC        (MMENU_ALTERN+1)
  1925. + #define    MMENU_SJIS        (MMENU_EUC+1)
  1926. + #define    MMENU_LINE        (MMENU_SJIS+1)
  1927. + #else    KANJI
  1928.   #define    MMENU_LINE        (MMENU_ALTERN+1)
  1929. + #endif    KANJI
  1930.   #define    MMENU_RESET        (MMENU_LINE+1)
  1931.   #define    MMENU_FULLRESET        (MMENU_RESET+1)
  1932.   #define    MMENU_TEKMODE        (MMENU_FULLRESET+1)
  1933. ***************
  1934. *** 2497,2507 ****
  1935. --- 3651,3669 ----
  1936.   #endif /* DO_AUTOREPEAT */
  1937.       "Scroll to bottom on key press",
  1938.       "Scroll to bottom on tty output",
  1939. + #ifdef    STATUSLINE    /* michael */
  1940. +     "Status Line",
  1941. +     "Reverse Status Line",
  1942. + #endif    STATUSLINE
  1943.       "Allow 80/132 switching",
  1944.       "Curses Emulation",
  1945.       "Margin Bell",
  1946.       "Tek Window Showing",
  1947.       "Alternate Screen",
  1948. + #ifdef    KANJI    /* sano */
  1949. +     "EUC Mode",
  1950. +     "Shift-JIS Mode",
  1951. + #endif    KANJI
  1952.       "-",
  1953.       "Soft Reset",
  1954.       "Full Reset",
  1955. ***************
  1956. *** 2521,2526 ****
  1957. --- 3683,3692 ----
  1958.   static int tscrollkey;
  1959.   static int tscrollinput;
  1960.   static Boolean tshow;
  1961. + #ifdef    STATUSLINE    /* michael */
  1962. + static int tstatusline;
  1963. + static int trevstatus;
  1964. + #endif    STATUSLINE
  1965.   
  1966.   Menu *setupmenu(menu)
  1967.   register Menu **menu;
  1968. ***************
  1969. *** 2565,2570 ****
  1970. --- 3731,3746 ----
  1971.               tscrollinput = FALSE;
  1972.               DisableItem(*menu, MMENU_SCROLLINPUT);
  1973.           }
  1974. + #ifdef    STATUSLINE    /* michael */
  1975. +         if (tstatusline = screen->statusline) {
  1976. +             CheckItem(*menu, MMENU_STATUS);
  1977. +             if (trevstatus = screen->reversestatus)
  1978. +                 CheckItem(*menu, MMENU_REVSTATUS);
  1979. +         } else {
  1980. +             trevstatus = FALSE;
  1981. +             DisableItem(*menu, MMENU_REVSTATUS);
  1982. +         }
  1983. + #endif    STATUSLINE
  1984.           if(t132 = screen->c132)
  1985.               CheckItem(*menu, MMENU_C132);
  1986.           if(tcurses = screen->curses)
  1987. ***************
  1988. *** 2584,2589 ****
  1989. --- 3760,3771 ----
  1990.               DisableItem(*menu, MMENU_TEKWIN);
  1991.               DisableItem(*menu, MMENU_TEKMODE);
  1992.           }
  1993. + #ifdef    KANJI    /* sano */
  1994. +         if (flags & EUC_KANJI)
  1995. +             CheckItem(*menu, MMENU_EUC);
  1996. +         if (flags & SJIS_KANJI)
  1997. +             CheckItem(*menu, MMENU_SJIS);
  1998. + #endif    KANJI
  1999.           menutermflags = flags;
  2000.           menukbdflags = kflags;
  2001.           return(*menu);
  2002. ***************
  2003. *** 2625,2630 ****
  2004. --- 3807,3825 ----
  2005.               SetItemCheck(*menu, MMENU_SCROLLINPUT,
  2006.                tscrollinput = screen->scrollinput);
  2007.       }
  2008. + #ifdef    STATUSLINE    /* michael */
  2009. +     if (tstatusline != screen->statusline) {
  2010. +         SetItemCheck(*menu, MMENU_STATUS,
  2011. +             tstatusline = screen->statusline);
  2012. +         SetItemDisable(*menu, MMENU_REVSTATUS, !tstatusline);
  2013. +         SetItemCheck(*menu, MMENU_REVSTATUS,
  2014. +             trevstatus = (tstatusline && screen->reversestatus));
  2015. +     } else if (tstatusline) {
  2016. +         if (tstatusline != screen->reversestatus)
  2017. +             SetItemCheck(*menu, MMENU_REVSTATUS,
  2018. +                 trevstatus = screen->reversestatus);
  2019. +     }
  2020. + #endif    STATUSLINE
  2021.       if(t132 != screen->c132)
  2022.           SetItemCheck(*menu, MMENU_C132, (t132 = screen->c132));
  2023.       if(tcurses != screen->curses)
  2024. ***************
  2025. *** 2640,2645 ****
  2026. --- 3835,3846 ----
  2027.           SetItemCheck(*menu, MMENU_ALTERN, (taltern =
  2028.            screen->alternate));
  2029.       }
  2030. + #ifdef    KANJI    /* sano */
  2031. +     if (menutermflags & EUC_KANJI)
  2032. +         SetItemCheck(*menu, MMENU_EUC, flags & EUC_KANJI);
  2033. +     if (menutermflags & SJIS_KANJI)
  2034. +         SetItemCheck(*menu, MMENU_SJIS, flags & SJIS_KANJI);
  2035. + #endif    KANJI
  2036.       menutermflags = flags;
  2037.       menukbdflags = kflags;
  2038.       return(*menu);
  2039. ***************
  2040. *** 2710,2715 ****
  2041. --- 3911,3930 ----
  2042.           screen->scrollinput = !screen->scrollinput;
  2043.           break;
  2044.   
  2045. + #ifdef    STATUSLINE    /* michael */
  2046. +     case MMENU_STATUS:
  2047. +         if (screen->statusline)
  2048. +             HideStatus();
  2049. +         else
  2050. +             ShowStatus();
  2051. +         break;
  2052. + 
  2053. +     case MMENU_REVSTATUS:
  2054. +         screen->reversestatus = !screen->reversestatus;
  2055. +         ScrnRefresh(screen, screen->max_row + 1, 0, 1,
  2056. +             screen->max_col + 1);
  2057. +         break;
  2058. + #endif    STATUSLINE
  2059.           
  2060.       case MMENU_C132:
  2061.           screen->c132 = !screen->c132;
  2062. ***************
  2063. *** 2750,2755 ****
  2064. --- 3965,3986 ----
  2065.           }
  2066.           reselectwindow(screen);
  2067.           break;
  2068. + #ifdef    KANJI    /* sano */
  2069. +     case MMENU_EUC:
  2070. +         term->flags ^= EUC_KANJI;
  2071. +         if (term->flags & EUC_KANJI)
  2072. +             /*
  2073. +              * Reset SJIS_KANJI mode because
  2074. +              * EUC_KANJI and SJIS_KANJI are specified exclusively.
  2075. +              */
  2076. +             term->flags &= ~SJIS_KANJI;
  2077. +         break;
  2078. +     case MMENU_SJIS:
  2079. +         term->flags ^= SJIS_KANJI;
  2080. +         if (term->flags & SJIS_KANJI)
  2081. +             term->flags &= ~EUC_KANJI;
  2082. +         break;
  2083. + #endif    KANJI
  2084.       }
  2085.   }
  2086.   #endif    /* MODEMENU */
  2087.