home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / x / volume4 / kterm / part04 < prev    next >
Encoding:
Text File  |  1989-05-31  |  43.9 KB  |  1,498 lines
  1. Path: uunet!island!argv
  2. From: argv@island.uu.net (Dan Heller)
  3. Newsgroups: comp.sources.x
  4. Subject: v04i013:  kterm -- Kanji (japanese) xterm, Part04/04
  5. Message-ID: <782@island.uu.net>
  6. Date: 31 May 89 06:02:35 GMT
  7. Sender: news@island.uu.net
  8. Organization: Island Graphics, Marin County, California
  9. Lines: 1486
  10. Approved: island!argv@sun.com
  11.  
  12. Submitted-by: Hiroto Kagotani <kagotani@cs.titech.ac.jp>
  13. Posting-number: Volume 4, Issue 13
  14. Archive-name: kterm/part04
  15.  
  16. diff -rc ../xterm/data.c ./data.c
  17. *** ../xterm/data.c    Wed Sep  7 06:08:02 1988
  18. --- ./data.c    Tue May 30 14:53:39 1989
  19. ***************
  20. *** 1,5 ****
  21. --- 1,6 ----
  22.   /*
  23.    *    $XConsortium: data.c,v 1.4 88/09/06 17:08:01 jim Exp $
  24. +  *    $Header: data.c,v 1.1 89/05/30 14:53:38 kagotani Rel $
  25.    */
  26.   
  27.   #include <X11/copyright.h>
  28. ***************
  29. *** 35,40 ****
  30. --- 36,42 ----
  31.   
  32.   #ifndef lint
  33.   static char rcs_id[] = "$XConsortium: data.c,v 1.4 88/09/06 17:08:01 jim Exp $";
  34. + static char kterm_id[] = "$Header: data.c,v 1.1 89/05/30 14:53:38 kagotani Rel $";
  35.   #endif    /* lint */
  36.   
  37.   XPoint T_boxlarge[NBOX] = {
  38. ***************
  39. *** 84,89 ****
  40. --- 86,109 ----
  41.       {0, 0},
  42.       {0, 0},
  43.   };
  44. + #ifdef    KANJI    /* sano */
  45. + XPoint VTwbox[NBOX] = {
  46. +     {0, 0},
  47. +     {0, 0},
  48. +     {0, 0},
  49. +     {0, 0},
  50. +     {0, 0},
  51. + };
  52. + #endif    KANJI
  53. + #ifdef    STATUSLINE    /* michael */
  54. + XPoint status_box[NBOX] = {
  55. +     {0, 0},
  56. +     {0, 0},
  57. +     {0, 0},
  58. +     {0, 0},
  59. +     {0, 0},
  60. + };
  61. + #endif    STATUSLINE
  62.   T_fontsize Tfontsize[TEKNUMFONTS] = {
  63.       {9, 15},    /* large */
  64.       {8, 13},    /* #2 */
  65. diff -rc ../xterm/data.h ./data.h
  66. *** ../xterm/data.h    Wed Sep  7 06:08:03 1988
  67. --- ./data.h    Tue May 30 14:53:40 1989
  68. ***************
  69. *** 1,5 ****
  70. --- 1,6 ----
  71.   /*
  72.    *    $XConsortium: data.h,v 1.3 88/09/06 17:08:02 jim Exp $
  73. +  *    $Header: data.h,v 1.1 89/05/30 14:53:40 kagotani Rel $
  74.    */
  75.   
  76.   
  77. ***************
  78. *** 38,44 ****
  79. --- 39,51 ----
  80.   extern XPoint T_boxlarge[];
  81.   extern XPoint T_boxsmall[];
  82.   extern XPoint VTbox[];
  83. + #ifdef    KANJI    /* sano */
  84. + extern XPoint VTwbox[];
  85. + #endif    KANJI
  86.   extern T_fontsize Tfontsize[];
  87. + #ifdef    STATUSLINE    /* michael */
  88. + extern XPoint status_box[];
  89. + #endif    STATUSLINE
  90.   extern char *Tbptr;
  91.   extern char *Tbuffer;
  92.   extern char *Tpushb;
  93. diff -rc ../xterm/main.c ./main.c
  94. *** ../xterm/main.c    Fri May  5 00:43:59 1989
  95. --- ./main.c    Tue May 30 14:53:47 1989
  96. ***************
  97. *** 1,5 ****
  98. --- 1,6 ----
  99.   #ifndef lint
  100.   static char rcs_id[] = "$XConsortium: main.c,v 1.99 89/01/04 14:33:47 jim Exp $";
  101. + static char kterm_id[] = "$Header: main.c,v 1.1 89/05/30 14:53:43 kagotani Rel $";
  102.   #endif    /* lint */
  103.   
  104.   /*
  105. ***************
  106. *** 121,126 ****
  107. --- 122,131 ----
  108.   #endif
  109.   #endif
  110.   
  111. + #ifdef KEEPALIVE
  112. + #include <sys/socket.h>
  113. + #endif
  114. + 
  115.   #include "ptyx.h"
  116.   #include "data.h"
  117.   #include "error.h"
  118. ***************
  119. *** 271,276 ****
  120. --- 276,284 ----
  121.       char *tty_modes;
  122.       Boolean utmpInhibit;
  123.       Boolean sunFunctionKeys;    /* %%% should be widget resource? */
  124. + #ifdef KEEPALIVE
  125. +     Boolean keepalive;
  126. + #endif
  127.   } resource;
  128.   
  129.   #ifndef GETTY_EXE
  130. ***************
  131. *** 285,291 ****
  132. --- 293,303 ----
  133.   
  134.   static XtResource application_resources[] = {
  135.       {"name", "Name", XtRString, sizeof(char *),
  136. + #ifdef    KANJI    /* sano */
  137. +     offset(xterm_name), XtRString, "kterm"},
  138. + #else    KANJI
  139.       offset(xterm_name), XtRString, "xterm"},
  140. + #endif    KANJI
  141.       {"iconGeometry", "IconGeometry", XtRString, sizeof(char *),
  142.       offset(icon_geometry), XtRString, (caddr_t) NULL},
  143.       {XtNtitle, XtCTitle, XtRString, sizeof(char *),
  144. ***************
  145. *** 300,305 ****
  146. --- 312,321 ----
  147.       offset(utmpInhibit), XtRString, "false"},
  148.       {"sunFunctionKeys", "SunFunctionKeys", XtRBoolean, sizeof (Boolean),
  149.       offset(sunFunctionKeys), XtRString, "false"},
  150. + #ifdef KEEPALIVE
  151. +     {"keepAlive", "KeepAlive", XtRBoolean, sizeof (Boolean),
  152. +     offset(keepalive), XtRString, "false"},
  153. + #endif
  154.   };
  155.   #undef offset
  156.   
  157. ***************
  158. *** 323,330 ****
  159. --- 339,357 ----
  160.   {"+cu",        "*curses",    XrmoptionNoArg,        (caddr_t) "off"},
  161.   {"-e",        NULL,        XrmoptionSkipLine,    (caddr_t) NULL},
  162.   {"-fb",        "*boldFont",    XrmoptionSepArg,    (caddr_t) NULL},
  163. + #ifdef    KANJI    /* sano */
  164. + {"-fr",        "*kanaFont",    XrmoptionSepArg,    (caddr_t) NULL},
  165. + {"-frb",    "*kanaboldFont",XrmoptionSepArg,    (caddr_t) NULL},
  166. + {"-fk",        "*kanjiFont",    XrmoptionSepArg,    (caddr_t) NULL},
  167. + {"-fkb",    "*kanjiboldFont", XrmoptionSepArg,    (caddr_t) NULL},
  168. + {"-km",        "*kanjiMode",    XrmoptionSepArg,    (caddr_t) NULL},
  169. + #endif    KANJI
  170.   {"-j",        "*jumpScroll",    XrmoptionNoArg,        (caddr_t) "on"},
  171.   {"+j",        "*jumpScroll",    XrmoptionNoArg,        (caddr_t) "off"},
  172. + #ifdef KEEPALIVE
  173. + {"-ka",        "*keepAlive",    XrmoptionNoArg,        (caddr_t) "on"},
  174. + {"+ka",        "*keepAlive",    XrmoptionNoArg,        (caddr_t) "off"},
  175. + #endif
  176.   {"-l",        "*logging",    XrmoptionNoArg,        (caddr_t) "on"},
  177.   {"+l",        "*logging",    XrmoptionNoArg,        (caddr_t) "off"},
  178.   {"-lf",        "*logFile",    XrmoptionSepArg,    (caddr_t) NULL},
  179. ***************
  180. *** 347,352 ****
  181. --- 374,385 ----
  182.   {"+si",        "*scrollInput",    XrmoptionNoArg,        (caddr_t) "on"},
  183.   {"-sk",        "*scrollKey",    XrmoptionNoArg,        (caddr_t) "on"},
  184.   {"+sk",        "*scrollKey",    XrmoptionNoArg,        (caddr_t) "off"},
  185. + #ifdef    STATUSLINE    /* michael */
  186. + {"-st",        "*statusLine",    XrmoptionNoArg,        (caddr_t) "on"},
  187. + {"+st",        "*statusLine",    XrmoptionNoArg,        (caddr_t) "off"},
  188. + {"-sn",        "*statusNormal",XrmoptionNoArg,        (caddr_t) "on"},
  189. + {"+sn",        "*statusNormal",XrmoptionNoArg,        (caddr_t) "off"},
  190. + #endif    STATUSLINE
  191.   {"-sl",        "*saveLines",    XrmoptionSepArg,    (caddr_t) NULL},
  192.   {"-t",        "*tekStartup",    XrmoptionNoArg,        (caddr_t) "on"},
  193.   {"+t",        "*tekStartup",    XrmoptionNoArg,        (caddr_t) "off"},
  194. ***************
  195. *** 395,401 ****
  196. --- 428,444 ----
  197.   { "-cr color",             "text cursor color" },
  198.   { "-/+cu",                 "turn on/off curses emulation" },
  199.   { "-fb fontname",          "bold text font" },
  200. + #ifdef    KANJI    /* sano */
  201. + { "-fr fontname",          "normal kana font" },
  202. + { "-frb fontname",         "bold kana font" },
  203. + { "-fk fontname",          "normal kanji font" },
  204. + { "-fkb fontname",         "bold kanji font" },
  205. + { "-km kanjimode",         "input kanji code (jis|euc|sjis)" },
  206. + #endif    KANJI
  207.   { "-/+j",                  "turn on/off jump scroll" },
  208. + #ifdef KEEPALIVE
  209. + { "-/+ka",                  "turn on/off keeping connection alive" },
  210. + #endif
  211.   { "-/+l",                  "turn on/off logging" },
  212.   { "-lf filename",          "logging filename" },
  213.   { "-/+ls",                 "turn on/off login shell" },
  214. ***************
  215. *** 410,415 ****
  216. --- 453,462 ----
  217.   { "-/+si",                 "turn on/off scroll-on-input inhibit" },
  218.   { "-/+sk",                 "turn on/off scroll-on-keypress" },
  219.   { "-sl number",            "number of scrolled lines to save" },
  220. + #ifdef    STATUSLINE    /* michael */
  221. + { "-sn",                   "make status line normal video" },
  222. + { "-st",                   "turn on status line" },
  223. + #endif    STATUSLINE
  224.   { "-/+t",                  "turn on/off Tek emulation window" },
  225.   { "-tm string",            "terminal mode keywords and characters" },
  226.   { "-tn name",              "TERM environment variable name" },
  227. ***************
  228. *** 627,638 ****
  229. --- 674,701 ----
  230.           }
  231.       }
  232.       /* Init the Toolkit. */
  233. + #ifdef    KANJI    /* sano */
  234. +     toplevel = XtInitialize("xterm", "KTerm",
  235. + #else    KANJI
  236.       toplevel = XtInitialize("xterm", "XTerm",
  237. + #endif    KANJI
  238.           optionDescList, XtNumber(optionDescList), &argc, argv);
  239.   
  240.       XtGetApplicationResources( toplevel, &resource, application_resources,
  241.                      XtNumber(application_resources), NULL, 0 );
  242.   
  243. + #ifdef KEEPALIVE
  244. +     if (resource.keepalive) {
  245. +         int     on = 1;
  246. +         (void)setsockopt(ConnectionNumber(XtDisplay(toplevel)),
  247. +                 SOL_SOCKET, SO_KEEPALIVE,
  248. +                 (char *)&on, sizeof(on));
  249. +     }
  250. + #endif
  251. + #ifdef KANJI
  252. +     /* Atom Initialize */
  253. +     SelAtomInitialize();
  254. + #endif
  255.       /*
  256.        * fill in terminal modes
  257.        */
  258. ***************
  259. *** 649,655 ****
  260. --- 712,722 ----
  261.   
  262.       xterm_name = resource.xterm_name;
  263.       sunFunctionKeys = resource.sunFunctionKeys;
  264. + #ifdef    KANJI    /* sano */
  265. +     if (strcmp(xterm_name, "-") == 0) xterm_name = "kterm";
  266. + #else    KANJI
  267.       if (strcmp(xterm_name, "-") == 0) xterm_name = "xterm";
  268. + #endif    KANJI
  269.       if (resource.icon_geometry != NULL) {
  270.           int scr, junk;
  271.           Arg args[2];
  272. ***************
  273. *** 743,748 ****
  274. --- 810,831 ----
  275.   #endif /* DO_AUTOREPEAT */
  276.       if (!screen->jumpscroll)    term->flags |= SMOOTHSCROLL;
  277.       if (term->misc.reverseWrap)        term->flags |= REVERSEWRAP;
  278. + #ifdef    KANJI    /* sano */
  279. +     /*
  280. +      * Reflect the kanji mode into the flags.
  281. +      * Note that SJIS_KANJI and EUC_KANJI are mutually exclusive.
  282. +      * Reset both bits if `jis' is specified.
  283. +      */
  284. +     if (term->misc.k_m)
  285. +         if (strcmp(term->misc.k_m, "euc") == 0) {
  286. +             term->flags &= ~SJIS_KANJI;
  287. +             term->flags |= EUC_KANJI;
  288. +         } else if (strcmp(term->misc.k_m, "sjis") == 0) {
  289. +             term->flags &= ~EUC_KANJI;
  290. +             term->flags |= SJIS_KANJI;
  291. +         } else if (strcmp(term->misc.k_m, "jis") == 0)
  292. +             term->flags &= ~(EUC_KANJI | SJIS_KANJI);
  293. + #endif
  294.   
  295.       inhibit = 0;
  296.       if (term->misc.logInhibit)            inhibit |= I_LOG;
  297. ***************
  298. *** 749,754 ****
  299. --- 832,841 ----
  300.       if (term->misc.signalInhibit)        inhibit |= I_SIGNAL;
  301.       if (term->misc.tekInhibit)            inhibit |= I_TEK;
  302.   
  303. + #ifdef    STATUSLINE    /* michael */
  304. +     screen->reversestatus = !term->misc.statusnormal;
  305. + #endif    STATUSLINE
  306. + 
  307.       term->initflags = term->flags;
  308.   
  309.   /*
  310. ***************
  311. *** 1035,1040 ****
  312. --- 1122,1130 ----
  313.   };
  314.   
  315.   static char *vtterm[] = {
  316. + #ifdef    KANJI    /* sano */
  317. +     "kterm",
  318. + #endif    KANJI
  319.   #ifdef USE_X11TERM
  320.       "x11term",        /* for people who want special term name */
  321.   #endif
  322. ***************
  323. *** 1537,1543 ****
  324. --- 1627,1642 ----
  325.               }
  326.   #endif    /* TIOCCONS */
  327.   #else    /* USE_SYSV_TERMIO */
  328. + #ifdef    KANJI    /* michael */
  329. +             /*
  330. +              * EUC and SJIS require 8bit transparent pty module.
  331. +              * Even in such a case, parity should not be specified.
  332. +              */
  333. +             sg.sg_flags &= ~(ALLDELAY | XTABS | CBREAK | RAW
  334. +                     | EVENP | ODDP);
  335. + #else    KANJI
  336.               sg.sg_flags &= ~(ALLDELAY | XTABS | CBREAK | RAW);
  337. + #endif    KANJI
  338.               sg.sg_flags |= ECHO | CRMOD;
  339.               /* make sure speed is set on pty so that editors work right*/
  340.               sg.sg_ispeed = B9600;
  341. diff -rc ../xterm/main.h ./main.h
  342. *** ../xterm/main.h    Wed Sep  7 06:08:13 1988
  343. --- ./main.h    Tue May 30 14:53:49 1989
  344. ***************
  345. *** 1,5 ****
  346. --- 1,6 ----
  347.   /*
  348.    *    $XConsortium: main.h,v 1.3 88/09/06 17:08:12 jim Exp $
  349. +  *    $Header: main.h,v 1.1 89/05/30 14:53:48 kagotani Rel $
  350.    */
  351.   
  352.   
  353. ***************
  354. *** 30,36 ****
  355. --- 31,48 ----
  356.   
  357.   /* @(#)main.h\tX10/6.6\t11/10/86 */
  358.   
  359. + #ifdef    KANJI
  360. + #define    DEFBOLDFONT        " "
  361. + #define    DEFBORDER        2
  362. + #define    DEFBORDERWIDTH        1
  363. + #define    DEFFONT            "a14"
  364. + #define    DEFKANAFONT        "kana14"
  365. + #define    DEFKANABOLDFONT        " "
  366. + #define    DEFKANJIFONT        "k14"
  367. + #define    DEFKANJIBOLDFONT    " "
  368. + #else    KANJI
  369.   #define    DEFBOLDFONT        "fixed"
  370.   #define    DEFBORDER        2
  371.   #define    DEFBORDERWIDTH        2
  372.   #define    DEFFONT            "fixed"
  373. + #endif    KANJI
  374. diff -rc ../xterm/ptyx.h ./ptyx.h
  375. *** ../xterm/ptyx.h    Mon Nov 21 13:12:07 1988
  376. --- ./ptyx.h    Tue May 30 14:53:52 1989
  377. ***************
  378. *** 1,5 ****
  379. --- 1,6 ----
  380.   /*
  381.    *    $XConsortium: ptyx.h,v 1.20 88/11/16 18:13:26 rws Exp $
  382. +  *    $Header: ptyx.h,v 1.1 89/05/30 14:53:51 kagotani Rel $
  383.    */
  384.   
  385.   #include <X11/copyright.h>
  386. ***************
  387. *** 106,111 ****
  388. --- 107,119 ----
  389.   #endif    /* !hpux */
  390.   #endif    /* !PTYCHAR2 */
  391.   
  392. + #ifdef KANJI
  393. + #ifndef WCHAR_T
  394. + #define WCHAR_T
  395. + typedef unsigned short    wchar_t;
  396. + #endif
  397. + #endif
  398. + 
  399.   /* Until the translation manager comes along, I have to do my own translation of
  400.    * mouse events into the proper routines. */
  401.   
  402. ***************
  403. *** 164,170 ****
  404. --- 172,182 ----
  405.       unsigned    flags;    /* Vt100 saves graphics rendition. Ugh! */
  406.       char        curgl;
  407.       char        curgr;
  408. + #ifdef    KANJI    /* sano */
  409. +     short        gsets[4];
  410. + #else    KANJI
  411.       char        gsets[4];
  412. + #endif    KANJI
  413.   } SavedCursor;
  414.   
  415.   #define    TEKNUMFONTS    4
  416. ***************
  417. *** 205,212 ****
  418. --- 217,240 ----
  419.       GC        reverseGC;    /* reverse painting        */
  420.       GC        normalboldGC;    /* normal painting, bold font    */
  421.       GC        reverseboldGC;    /* reverse painting, bold font    */
  422. + #ifdef    KANJI    /* sano */
  423. +     GC        r_normalGC;    /* normal GR painting        */
  424. +     GC        r_reverseGC;    /* reverse GR painting        */
  425. +     GC        r_normalboldGC;    /* normal GR painting, bold font*/
  426. +     GC        r_reverseboldGC;/* reverse GR painting, bold font*/
  427. +     GC        w_normalGC;    /* normal kanji painting    */
  428. +     GC        w_reverseGC;    /* reverse kanji painting    */
  429. +     GC        w_normalboldGC;    /* normal kanji, bold font    */
  430. +     GC        w_reverseboldGC;/* reverse kanji, bold font    */
  431. + #endif    KANJI
  432.       GC        cursorGC;    /* normal cursor painting    */
  433.       GC        reversecursorGC;/* reverse cursor painting    */
  434. + #ifdef    KANJI    /* michael */
  435. +     GC        r_cursorGC;    /* normal kana cursor painting    */
  436. +     GC        r_reversecursorGC;/* reverse kana cursor     */
  437. +     GC        w_cursorGC;    /* normal kanji cursor painting    */
  438. +     GC        w_reversecursorGC;/* reverse kanji cursor     */
  439. + #endif    KANJI
  440.       GC        cursoroutlineGC;/* for painting lines around    */
  441.       Pixel        foreground;    /* foreground color        */
  442.       Pixel        cursorcolor;    /* Cursor color            */
  443. ***************
  444. *** 242,248 ****
  445. --- 270,287 ----
  446.       /* Terminal fonts must be of the same size and of fixed width */
  447.       XFontStruct    *fnt_norm;    /* normal font of terminal    */
  448.       XFontStruct    *fnt_bold;    /* bold font of terminal    */
  449. + #ifdef    KANJI    /* sano */
  450. +     XFontStruct    *fnt_r_norm;    /* normal GR font of terminal    */
  451. +     XFontStruct    *fnt_r_bold;    /* bold GR font of terminal    */
  452. +     XFontStruct    *fnt_w_norm;    /* normal kanji font of terminal*/
  453. +     XFontStruct    *fnt_w_bold;    /* bold kanji font of terminal    */
  454. + #endif    KANJI
  455.       int        enbolden;    /* overstrike for bold font    */
  456. + #ifdef    KANJI    /* sano */
  457. +     int        r_enbolden;    /* overstrike for GR bold    */
  458. +     int        w_enbolden;    /* overstrike for kanji bold    */
  459. +     XPoint        *w_box;        /* draw unselected cursor    */
  460. + #endif    KANJI
  461.       XPoint        *box;        /* draw unselected cursor    */
  462.   
  463.       int        cursor_state;    /* ON or OFF            */
  464. ***************
  465. *** 283,291 ****
  466. --- 322,341 ----
  467.       int        scrolls;    /* outstanding scroll count    */
  468.       SavedCursor    sc;        /* data for restore cursor    */
  469.       int        save_modes[19];    /* save dec private modes    */
  470. + #ifdef    STATUSLINE    /* michael */
  471. +     Boolean        statusline;    /* status line showing        */
  472. +     int        statusheight;    /* status line height        */
  473. +     Boolean        instatus;    /* cursor in status line    */
  474. +     SavedCursor    statussc;    /* status line restore cursor    */
  475. +     Boolean        reversestatus;    /* status line reversed        */
  476. + #endif    STATUSLINE
  477.   
  478.       /* Improved VT100 emulation stuff.                */
  479. + #ifdef    KANJI    /* sano */
  480. +     short        gsets[4];    /* G0 through G3.        */
  481. + #else    KANJI
  482.       char        gsets[4];    /* G0 through G3.        */
  483. + #endif    KANJI
  484.       char        curgl;        /* Current GL setting.        */
  485.       char        curgr;        /* Current GR setting.        */
  486.       char        curss;        /* Current single shift.    */
  487. ***************
  488. *** 334,340 ****
  489. --- 384,394 ----
  490.       char        *charClass;    /* for overriding word selection */
  491.       Boolean        cutNewline;    /* whether or not line cut has \n */
  492.       Boolean        cutToBeginningOfLine;  /* line cuts to BOL? */
  493. + #ifdef KANJI
  494. +     wchar_t        *selection;    /* the current selection */
  495. + #else
  496.       char        *selection;    /* the current selection */
  497. + #endif
  498.       int        selection_size; /* size of allocated buffer */
  499.       int        selection_length; /* number of significant bytes */
  500.       int        selection_time;    /* latest event timestamp */
  501. ***************
  502. *** 362,367 ****
  503. --- 416,428 ----
  504.       char *T_geometry;
  505.       char *f_n;
  506.       char *f_b;
  507. + #ifdef    KANJI    /* sano */
  508. +     char *f_rn;
  509. +     char *f_rb;
  510. +     char *f_kn;
  511. +     char *f_kb;
  512. +     char *k_m;
  513. + #endif
  514.       Boolean log_on;
  515.       Boolean login_shell;
  516.       Boolean re_verse;
  517. ***************
  518. *** 371,376 ****
  519. --- 432,440 ----
  520.       Boolean tekInhibit;
  521.       Boolean scrollbar;
  522.       Boolean titeInhibit;
  523. + #ifdef    STATUSLINE    /* michael */
  524. +     Boolean statusnormal;
  525. + #endif    STATUSLINE
  526.   } Misc;
  527.   
  528.   typedef struct {int foo;} XtermClassPart, TekClassPart;
  529. ***************
  530. *** 418,423 ****
  531. --- 482,504 ----
  532.   #define INVERSE        0x01    /* invert the characters to be output */
  533.   #define UNDERLINE    0x02    /* true if underlining */
  534.   #define BOLD        0x04
  535. + #ifdef    KANJI    /* sano */
  536. + #define    KCS        0x18    /* true if on KANJI char */
  537. + #define    KCS1        0x08    /* true if on the first byte of a Kanji char */
  538. + #define    KCS2        0x10    /* true if on the second byte of a Kanji char */
  539. + #define    KANACS        0x20    /* true if on KANA char */
  540. + #define WRAPAROUND    0x2000
  541. + #define REVERSE_VIDEO    0x4000    /* true if screen white on black */
  542. + #define ORIGIN        0x8000    /* true if in origin mode */
  543. + #define INSERT        0x10000    /* true if in insert mode */
  544. + #define SMOOTHSCROLL    0x20000    /* true if in smooth scroll mode */
  545. + #define AUTOREPEAT    0x40000    /* true if in autorepeat mode */
  546. + #define IN132COLUMNS    0x80000    /* true if in 132 column mode */
  547. + #define LINEFEED    0x100000
  548. + #define    REVERSEWRAP    0x200000/* true if reverse wraparound mode */
  549. + #define    EUC_KANJI    0x400000/* true if in EUC mode */
  550. + #define    SJIS_KANJI    0x800000/* true if in SJIS mode */
  551. + #else    KANJI
  552.   #define WRAPAROUND    0x08
  553.   #define REVERSE_VIDEO    0x10    /* true if screen white on black */
  554.   #define ORIGIN        0x20    /* true if in origin mode */
  555. ***************
  556. *** 429,438 ****
  557. --- 510,528 ----
  558.   #define IN132COLUMNS    0x200    /* true if in 132 column mode */
  559.   #define LINEFEED    0x400
  560.   #define    REVERSEWRAP    0x800    /* true if reverse wraparound mode */
  561. + #endif    KANJI
  562.   
  563. + #ifdef    KANJI    /* sano */
  564. + #define    ATTRIBUTES    0x3f    /* attributes mask including KCS/KANACS */
  565. + #else    KANJI
  566.   #define    ATTRIBUTES    0x07    /* attributes mask */
  567. + #endif    KANJI
  568.   #define CHAR        0177
  569.   
  570. + #ifdef    KANJI    /* sano */
  571. + #define    MBCS        0x80    /* MBCS stands for Multi Byte Character Set */
  572. + #endif    KANJI
  573. + 
  574.   #define VWindow(screen)        (screen->fullVwin.window)
  575.   #define VShellWindow        term->core.parent->core.window
  576.   #define TextWindow(screen)      (screen->fullVwin.window)
  577. ***************
  578. *** 452,459 ****
  579. --- 542,556 ----
  580.   
  581.   #define CursorX(screen,col) ((col) * FontWidth(screen) + screen->border \
  582.               + screen->scrollbar)
  583. + #ifdef    STATUSLINE    /* michael */
  584. + #define    CursorY(screen,row) ((screen->instatus?\
  585. +             ((row) * FontHeight(screen) + 1)\
  586. +             : (((row) - screen->topline) * FontHeight(screen)))\
  587. +             + screen->border)
  588. + #else    STATUSLINE
  589.   #define CursorY(screen,row) ((((row) - screen->topline) * FontHeight(screen)) \
  590.               + screen->border)
  591. + #endif    STATUSLINE
  592.   
  593.   #define    TWINDOWEVENTS    (KeyPressMask | ExposureMask | ButtonPressMask |\
  594.                ButtonReleaseMask | StructureNotifyMask |\
  595. diff -rc ../xterm/screen.c ./screen.c
  596. *** ../xterm/screen.c    Thu May  4 20:19:27 1989
  597. --- ./screen.c    Tue May 30 14:53:54 1989
  598. ***************
  599. *** 1,5 ****
  600. --- 1,6 ----
  601.   /*
  602.    *    $XConsortium: screen.c,v 1.10 89/01/03 16:18:06 jim Exp $
  603. +  *    $Header: screen.c,v 1.1 89/05/30 14:53:53 kagotani Rel $
  604.    */
  605.   
  606.   #include <X11/copyright.h>
  607. ***************
  608. *** 31,36 ****
  609. --- 32,38 ----
  610.   
  611.   #ifndef lint
  612.   static char rcs_id[] = "$XConsortium: screen.c,v 1.10 89/01/03 16:18:06 jim Exp $";
  613. + static char kterm_id[] = "$Header: screen.c,v 1.1 89/05/30 14:53:53 kagotani Rel $";
  614.   #endif    /* lint */
  615.   
  616.   #include <X11/Xlib.h>
  617. ***************
  618. *** 57,62 ****
  619. --- 59,67 ----
  620.   {
  621.       register ScrnBuf base;
  622.   
  623. + #ifdef    STATUSLINE    /* kato */
  624. +     nrow++;
  625. + #endif    STATUSLINE
  626.       if ((base = (ScrnBuf) calloc ((unsigned)(nrow *= 2), sizeof (char *))) == 0)
  627.           SysError (ERROR_SCALLOC);
  628.   
  629. ***************
  630. *** 90,95 ****
  631. --- 95,109 ----
  632.       att = screen->buf[avail + 1] + screen->cur_col;
  633.       flags &= ATTRIBUTES;
  634.       Bcopy(str, col, length);
  635. + #ifdef    KANJI    /* sano */
  636. +     if (flags & KCS) {
  637. +         while (length > 0) {
  638. +             *att++ = flags & ~KCS2;
  639. +             *att++ = flags & ~KCS1;
  640. +             length -= 2;
  641. +         }
  642. +     } else
  643. + #endif    KANJI
  644.       while(length-- > 0)
  645.           *att++ = flags;
  646.   }
  647. ***************
  648. *** 224,234 ****
  649. --- 238,260 ----
  650.       int maxrow = toprow + nrows - 1;
  651.       int scrollamt = screen->scroll_amt;
  652.       int max = screen->max_row;
  653. + #ifdef    STATUSLINE    /* michael */
  654. +     int dostatus = 0, left, width;
  655. + #endif    STATUSLINE
  656.   
  657. + #ifdef    STATUSLINE    /* michael */
  658. +     if (screen->statusline && maxrow == screen->max_row + 1) {
  659. +         dostatus++;
  660. +         maxrow--;
  661. +     }
  662. + #endif    STATUSLINE
  663.       if(screen->cursor_col >= leftcol && screen->cursor_col <=
  664.        (leftcol + ncols - 1) && screen->cursor_row >= toprow + topline &&
  665.        screen->cursor_row <= maxrow + topline)
  666.           screen->cursor_state = OFF;
  667. + #ifdef    STATUSLINE    /* michael */
  668. +     for ( ; ; ) {
  669. + #endif    STATUSLINE
  670.       for (row = toprow; row <= maxrow; y += FontHeight(screen), row++) {
  671.          register char *chars;
  672.          register char *att;
  673. ***************
  674. *** 283,297 ****
  675.              hilite = True;
  676.          }
  677.   
  678.          if (col > maxcol) continue;
  679.   
  680.          flags = att[col];
  681.   
  682.          if ( (!hilite && (flags & INVERSE) != 0) ||
  683.               (hilite && (flags & INVERSE) == 0) )
  684.              if (flags & BOLD) gc = screen->reverseboldGC;
  685.              else gc = screen->reverseGC;
  686. !        else 
  687.              if (flags & BOLD) gc = screen->normalboldGC;
  688.              else gc = screen->normalGC;
  689.   
  690. --- 309,377 ----
  691.              hilite = True;
  692.          }
  693.   
  694. + #ifdef    KANJI    /* sano */
  695. +        if ((att[col] & KCS2) && col != 0)
  696. +            col--;
  697. +        if (att[maxcol] & KCS1)
  698. +            maxcol++;
  699. + #endif
  700. + 
  701.          if (col > maxcol) continue;
  702.   
  703.          flags = att[col];
  704.   
  705. + #ifdef    KANJI    /* sano */
  706. +        if (flags & KCS)
  707. + #ifdef    STATUSLINE    /* michael */
  708. +         if ((!hilite && (flags & INVERSE) != 0
  709. +             || hilite && (flags & INVERSE) == 0)
  710. +             ^ (dostatus < 0 && screen->reversestatus)) {
  711. + #else    STATUSLINE
  712. +         if (!hilite && (flags & INVERSE) != 0
  713. +             || hilite && (flags & INVERSE) == 0) {
  714. + #endif    STATUSLINE
  715. +             if (flags & BOLD)
  716. +                 gc = screen->w_reverseboldGC;
  717. +             else
  718. +                 gc = screen->w_reverseGC;
  719. +         } else {
  720. +             if (flags & BOLD)
  721. +                 gc = screen->w_normalboldGC;
  722. +             else
  723. +                 gc = screen->w_normalGC;
  724. +         }
  725. +        else if (flags & KANACS)
  726. + #ifdef    STATUSLINE    /* michael */
  727. +         if ((!hilite && (flags & INVERSE) != 0
  728. +             || hilite && (flags & INVERSE) == 0)
  729. +             ^ (dostatus < 0 && screen->reversestatus)) {
  730. + #else    STATUSLINE
  731. +         if (!hilite && (flags & INVERSE) != 0
  732. +             || hilite && (flags & INVERSE) == 0) {
  733. + #endif    STATUSLINE
  734. +             if (flags & BOLD)
  735. +                 gc = screen->r_reverseboldGC;
  736. +             else
  737. +                 gc = screen->r_reverseGC;
  738. +         } else {
  739. +             if (flags & BOLD)
  740. +                 gc = screen->r_normalboldGC;
  741. +             else
  742. +                 gc = screen->r_normalGC;
  743. +         }
  744. +     else
  745. + #endif    KANJI
  746. + #ifdef    STATUSLINE    /* michael */
  747. +         if ((!hilite && (flags & INVERSE) != 0
  748. +             || hilite && (flags & INVERSE) == 0)
  749. +             ^ (dostatus < 0 && screen->reversestatus))
  750. + #else    STATUSLINE
  751.          if ( (!hilite && (flags & INVERSE) != 0) ||
  752.               (hilite && (flags & INVERSE) == 0) )
  753. + #endif    STATUSLINE
  754.              if (flags & BOLD) gc = screen->reverseboldGC;
  755.              else gc = screen->reverseGC;
  756. !        else
  757.              if (flags & BOLD) gc = screen->normalboldGC;
  758.              else gc = screen->normalGC;
  759.   
  760. ***************
  761. *** 300,310 ****
  762. --- 380,409 ----
  763.   
  764.          for (; col <= maxcol; col++) {
  765.           if (att[col] != flags) {
  766. + #ifdef    KANJI    /* sano */
  767. +            if (flags & KCS) {
  768. +             XDrawImageString16(screen->display, TextWindow(screen),
  769. +                 gc, x, y, (XChar2b *)&chars[lastind],
  770. +                 (n = col - lastind) / 2);
  771. +             if ((flags & BOLD) && screen->w_enbolden)
  772. +                 XDrawString16(screen->display, TextWindow(screen),
  773. +                 gc, x + 1, y, (XChar2b *)&chars[lastind], n/2);
  774. +            } else if (flags & KANACS) {
  775. +                XDrawImageString(screen->display, TextWindow(screen),
  776. +                 gc, x, y, &chars[lastind], n = col - lastind);
  777. +                if ((flags & BOLD) && screen->r_enbolden)
  778. +                  XDrawString(screen->display, TextWindow(screen),
  779. +                      gc, x + 1, y, &chars[lastind], n);
  780. +            } else {
  781. + #endif    KANJI
  782.              XDrawImageString(screen->display, TextWindow(screen), 
  783.                       gc, x, y, &chars[lastind], n = col - lastind);
  784.              if((flags & BOLD) && screen->enbolden)
  785.                XDrawString(screen->display, TextWindow(screen), 
  786.                gc, x + 1, y, &chars[lastind], n);
  787. + #ifdef    KANJI    /* sano */
  788. +            }
  789. + #endif    KANJI
  790.              if(flags & UNDERLINE) 
  791.               XDrawLine(screen->display, TextWindow(screen), 
  792.                gc, x, y+1, x+n*FontWidth(screen), y+1);
  793. ***************
  794. *** 315,322 ****
  795.   
  796.              flags = att[col];
  797.   
  798. !               if ((!hilite && (flags & INVERSE) != 0) ||
  799. !                (hilite && (flags & INVERSE) == 0) )
  800.                      if (flags & BOLD) gc = screen->reverseboldGC;
  801.                      else gc = screen->reverseGC;
  802.                 else 
  803. --- 414,469 ----
  804.   
  805.              flags = att[col];
  806.   
  807. ! #ifdef    KANJI    /* sano */
  808. !            if (flags & KCS)
  809. ! #ifdef    STATUSLINE    /* michael */
  810. !             if ((!hilite && (flags & INVERSE) != 0
  811. !                 || hilite && (flags & INVERSE) == 0)
  812. !                 ^ (dostatus < 0 && screen->reversestatus)) {
  813. ! #else    STATUSLINE
  814. !             if (!hilite && (flags & INVERSE) != 0
  815. !                 || hilite && (flags & INVERSE) == 0) {
  816. ! #endif    STATUSLINE
  817. !                 if (flags & BOLD)
  818. !                 gc = screen->w_reverseboldGC;
  819. !                 else
  820. !                 gc = screen->w_reverseGC;
  821. !             } else {
  822. !                 if (flags & BOLD)
  823. !                 gc = screen->w_normalboldGC;
  824. !                 else
  825. !                 gc = screen->w_normalGC;
  826. !             }
  827. !             else if (flags & KANACS)
  828. ! #ifdef    STATUSLINE    /* michael */
  829. !             if ((!hilite && (flags & INVERSE) != 0
  830. !                 || hilite && (flags & INVERSE) == 0)
  831. !                 ^ (dostatus < 0 && screen->reversestatus)) {
  832. ! #else    STATUSLINE
  833. !             if (!hilite && (flags & INVERSE) != 0
  834. !                 || hilite && (flags & INVERSE) == 0) {
  835. ! #endif    STATUSLINE
  836. !                 if (flags & BOLD)
  837. !                 gc = screen->r_reverseboldGC;
  838. !                 else
  839. !                 gc = screen->r_reverseGC;
  840. !             } else {
  841. !                 if (flags & BOLD)
  842. !                 gc = screen->r_normalboldGC;
  843. !                 else
  844. !                 gc = screen->r_normalGC;
  845. !             }
  846. !             else
  847. ! #endif    KANJI
  848. !                 
  849. ! #ifdef    STATUSLINE    /* michael */
  850. !             if ((!hilite && (flags & INVERSE) != 0
  851. !             || hilite && (flags & INVERSE) == 0)
  852. !             ^ (dostatus < 0 && screen->reversestatus))
  853. ! #else    STATUSLINE
  854. !                if (!hilite && (flags & INVERSE) != 0
  855. !                 || hilite && (flags & INVERSE) == 0)
  856. ! #endif    STATUSLINE
  857.                      if (flags & BOLD) gc = screen->reverseboldGC;
  858.                      else gc = screen->reverseGC;
  859.                 else 
  860. ***************
  861. *** 326,350 ****
  862.   
  863.           if(chars[col] == 0)
  864.               chars[col] = ' ';
  865.          }
  866.   
  867.   
  868. !        if ( (!hilite && (flags & INVERSE) != 0) ||
  869. !             (hilite && (flags & INVERSE) == 0) )
  870.              if (flags & BOLD) gc = screen->reverseboldGC;
  871.              else gc = screen->reverseGC;
  872.          else 
  873.              if (flags & BOLD) gc = screen->normalboldGC;
  874.              else gc = screen->normalGC;
  875.          XDrawImageString(screen->display, TextWindow(screen), gc, 
  876.                x, y, &chars[lastind], n = col - lastind);
  877.          if((flags & BOLD) && screen->enbolden)
  878.           XDrawString(screen->display, TextWindow(screen), gc,
  879.           x + 1, y, &chars[lastind], n);
  880.          if(flags & UNDERLINE) 
  881.           XDrawLine(screen->display, TextWindow(screen), gc, 
  882.            x, y+1, x + n * FontWidth(screen), y+1);
  883.       }
  884.   }
  885.   
  886.   ClearBufRows (screen, first, last)
  887. --- 473,592 ----
  888.   
  889.           if(chars[col] == 0)
  890.               chars[col] = ' ';
  891. + #ifdef    KANJI    /* sano */
  892. +         if (att[col] & KCS1)
  893. +             col++;
  894. + #endif    KANJI
  895.          }
  896.   
  897.   
  898. ! #ifdef    KANJI    /* sano */
  899. !        if (flags & KCS)
  900. ! #ifdef    STATUSLINE    /* michael */
  901. !         if ((!hilite && (flags & INVERSE) != 0
  902. !              || hilite && (flags & INVERSE) == 0)
  903. !             ^ (dostatus < 0 && screen->reversestatus)) {
  904. ! #else    STATUSLINE
  905. !         if (!hilite && (flags & INVERSE) != 0
  906. !             || hilite && (flags & INVERSE) == 0) {
  907. ! #endif    STATUSLINE
  908. !             if (flags & BOLD)
  909. !             gc = screen->w_reverseboldGC;
  910. !             else
  911. !             gc = screen->w_reverseGC;
  912. !         } else {
  913. !             if (flags & BOLD)
  914. !             gc = screen->w_normalboldGC;
  915. !             else
  916. !             gc = screen->w_normalGC;
  917. !         }
  918. !        else if (flags & KANACS)
  919. ! #ifdef    STATUSLINE    /* michael */
  920. !         if ((!hilite && (flags & INVERSE) != 0
  921. !              || hilite && (flags & INVERSE) == 0)
  922. !             ^ (dostatus < 0 && screen->reversestatus)) {
  923. ! #else    STATUSLINE
  924. !         if (!hilite && (flags & INVERSE) != 0
  925. !             || hilite && (flags & INVERSE) == 0) {
  926. ! #endif    STATUSLINE
  927. !             if (flags & BOLD)
  928. !             gc = screen->r_reverseboldGC;
  929. !             else
  930. !             gc = screen->r_reverseGC;
  931. !         } else {
  932. !             if (flags & BOLD)
  933. !             gc = screen->r_normalboldGC;
  934. !             else
  935. !             gc = screen->r_normalGC;
  936. !         }
  937. !        else
  938. ! #endif    KANJI
  939. !         
  940. ! #ifdef    STATUSLINE    /* michael */
  941. !         if ((!hilite && (flags & INVERSE) != 0
  942. !          || hilite && (flags & INVERSE) == 0)
  943. !         ^ (dostatus < 0 && screen->reversestatus))
  944. ! #else    STATUSLINE
  945. !        if (!hilite && (flags & INVERSE) != 0
  946. !            || hilite && (flags & INVERSE) == 0)
  947. ! #endif    STATUSLINE
  948.              if (flags & BOLD) gc = screen->reverseboldGC;
  949.              else gc = screen->reverseGC;
  950.          else 
  951.              if (flags & BOLD) gc = screen->normalboldGC;
  952.              else gc = screen->normalGC;
  953. + #ifdef    KANJI    /* sano */
  954. +        if (flags & KCS) {
  955. +         XDrawImageString16(screen->display, TextWindow(screen), gc,
  956. +             x, y, (XChar2b *)&chars[lastind],
  957. +             (n = col - lastind) / 2);
  958. +         if ((flags & BOLD) && screen->w_enbolden)
  959. +             XDrawString16(screen->display, TextWindow(screen), gc,
  960. +             x + 1, y, (XChar2b *)&chars[lastind], n / 2);
  961. +        } else if (flags & KANACS) {
  962. +            XDrawImageString(screen->display, TextWindow(screen), gc, 
  963. +                  x, y, &chars[lastind], n = col - lastind);
  964. +            if((flags & BOLD) && screen->r_enbolden)
  965. +             XDrawString(screen->display, TextWindow(screen), gc,
  966. +             x + 1, y, &chars[lastind], n);
  967. +        } else {
  968. + #endif    KANJI
  969.          XDrawImageString(screen->display, TextWindow(screen), gc, 
  970.                x, y, &chars[lastind], n = col - lastind);
  971.          if((flags & BOLD) && screen->enbolden)
  972.           XDrawString(screen->display, TextWindow(screen), gc,
  973.           x + 1, y, &chars[lastind], n);
  974. + #ifdef    KANJI    /* sano */
  975. +        }
  976. + #endif    KANJI
  977.          if(flags & UNDERLINE) 
  978.           XDrawLine(screen->display, TextWindow(screen), gc, 
  979.            x, y+1, x + n * FontWidth(screen), y+1);
  980.       }
  981. + #ifdef    STATUSLINE    /* michael */
  982. +     if (dostatus <= 0)
  983. +         break;
  984. +     dostatus = -1;
  985. +     topline = 0;
  986. +     scrollamt = 0;
  987. +     toprow = maxrow = max = screen->max_row + 1;
  988. +     left = CursorX(screen, leftcol);
  989. +     width = ncols * FontWidth(screen);
  990. +     if (leftcol == 0) {
  991. +         left--;
  992. +         width++;
  993. +     }
  994. +     if (leftcol + ncols - 1 >= screen->max_col)
  995. +         width++;
  996. +     XFillRectangle(screen->display, TextWindow(screen),
  997. +         screen->reversestatus ? screen->normalGC : screen->reverseGC,
  998. +         left, y - screen->fnt_norm->max_bounds.ascent,
  999. +         width, screen->statusheight);
  1000. +     if (!screen->reversestatus)
  1001. +         StatusBox(screen);
  1002. +     y++;
  1003. +     }    /* end of for(;;) { */
  1004. + #endif    STATUSLINE
  1005.   }
  1006.   
  1007.   ClearBufRows (screen, first, last)
  1008. ***************
  1009. *** 390,395 ****
  1010. --- 632,640 ----
  1011.       register int x;
  1012.       int border = 2 * screen->border;
  1013.       int i, j, k;
  1014. + #ifdef    STATUSLINE    /* michael */
  1015. +     register char *s10, *s11;    /* keep status line */
  1016. + #endif    STATUSLINE
  1017.   #ifdef sun
  1018.   #ifdef TIOCSSIZE
  1019.       struct ttysize ts;
  1020. ***************
  1021. *** 414,420 ****
  1022. --- 659,669 ----
  1023.   
  1024.       /* round so that it is unlikely the screen will change size on  */
  1025.       /* small mouse movements.                    */
  1026. + #ifdef    STATUSLINE    /* michael */
  1027. +     rows = (height + FontHeight(screen) / 2 - border - screen->statusheight) /
  1028. + #else    STATUSLINE
  1029.       rows = (height + FontHeight(screen) / 2 - border) /
  1030. + #endif    STATUSLINE
  1031.        FontHeight(screen);
  1032.       cols = (width + FontWidth(screen) / 2 - border - screen->scrollbar) /
  1033.        FontWidth(screen);
  1034. ***************
  1035. *** 452,458 ****
  1036. --- 701,711 ----
  1037.               }
  1038.           }
  1039.           /* resize current lines */
  1040. + #ifdef    STATUSLINE    /* michael */
  1041. +                 k += savelines + 1;    /* includes status line */
  1042. + #else    STATUSLINE
  1043.                   k += savelines;
  1044. + #endif    STATUSLINE
  1045.           for (index = x = 0; index <= k; x += 2, index++) {
  1046.               if ((sb[x] = realloc(sb[x], (unsigned) cols)) == NULL)
  1047.                   SysError(ERROR_SREALLOC3);
  1048. ***************
  1049. *** 463,470 ****
  1050. --- 716,731 ----
  1051.                   bzero (sb [x + 1] + j, i);
  1052.               }
  1053.           }
  1054. + #ifdef    STATUSLINE    /* michael */
  1055. +         /* save status line */
  1056. +         s10 = sb[i = 2 * (savelines + screen->max_row + 1)];
  1057. +         s11 = sb[i + 1];
  1058.           /* discard excess bottom rows */
  1059. +         for (index = rows, x = 2 * (k - 1); index <= screen->max_row;
  1060. + #else    STATUSLINE
  1061. +         /* discard excess bottom rows */
  1062.           for (index = rows, x = 2 * k; index <= screen->max_row;
  1063. + #endif    STATUSLINE
  1064.            x += 2, index++) {
  1065.              free (sb [x]);
  1066.              free (sb [x + 1]);
  1067. ***************
  1068. *** 475,481 ****
  1069. --- 736,746 ----
  1070.               SysError (ERROR_RESIZE);
  1071.               screen->altbuf = ab;
  1072.           }
  1073. + #ifdef    STATUSLINE    /* michael */
  1074. +         k = 2 * (rows + savelines + 1);    /* includes status line */
  1075. + #else    STATUSLINE
  1076.           k = 2 * (rows + savelines);
  1077. + #endif    STATUSLINE
  1078.           /* resize sb */
  1079.           if((sb = (ScrnBuf)realloc((char *) sb, (unsigned) k * sizeof(char *)))
  1080.             == NULL)
  1081. ***************
  1082. *** 504,509 ****
  1083. --- 769,778 ----
  1084.   
  1085.           screen->max_row = rows - 1;
  1086.           screen->max_col = cols - 1;
  1087. + #ifdef    STATUSLINE    /* michael */
  1088. +         sb[i = 2 * (savelines + screen->max_row + 1)] = s10;
  1089. +         sb[i + 1] = s11;
  1090. + #endif    STATUSLINE
  1091.       
  1092.           /* adjust scrolling region */
  1093.           screen->top_marg = 0;
  1094. ***************
  1095. *** 510,521 ****
  1096. --- 779,799 ----
  1097.           screen->bot_marg = screen->max_row;
  1098.           *flags &= ~ORIGIN;
  1099.       
  1100. + #ifdef    STATUSLINE    /* michael */
  1101. +         if (screen->instatus)
  1102. +             screen->cur_row = screen->max_row + 1;
  1103. +         else
  1104. + #endif    STATUSLINE
  1105.           if (screen->cur_row > screen->max_row)
  1106.               screen->cur_row = screen->max_row;
  1107.           if (screen->cur_col > screen->max_col)
  1108.               screen->cur_col = screen->max_col;
  1109.       
  1110. + #ifdef    STATUSLINE    /* michael */
  1111. +         screen->fullVwin.height = height - border - screen->statusheight;
  1112. + #else    STATUSLINE
  1113.           screen->fullVwin.height = height - border;
  1114. + #endif    STATUSLINE
  1115.           screen->fullVwin.width = width - border - screen->scrollbar;
  1116.   
  1117.       } else if(FullHeight(screen) == height && FullWidth(screen) == width)
  1118. diff -rc ../xterm/scrollbar.c ./scrollbar.c
  1119. *** ../xterm/scrollbar.c    Thu May  4 20:19:28 1989
  1120. --- ./scrollbar.c    Tue May 30 14:53:56 1989
  1121. ***************
  1122. *** 1,5 ****
  1123. --- 1,6 ----
  1124.   /*
  1125.    *    $XConsortium: scrollbar.c,v 1.17 88/11/23 13:56:05 rws Exp $
  1126. +  *    $Header: scrollbar.c,v 1.1 89/05/30 14:53:55 kagotani Rel $
  1127.    */
  1128.   
  1129.   #include <X11/copyright.h>
  1130. ***************
  1131. *** 43,48 ****
  1132. --- 44,50 ----
  1133.   
  1134.   #ifndef lint
  1135.   static char rcs_id[] = "$XConsortium: scrollbar.c,v 1.17 88/11/23 13:56:05 rws Exp $";
  1136. + static char kterm_id[] = "$Header: scrollbar.c,v 1.1 89/05/30 14:53:55 kagotani Rel $";
  1137.   #endif    /* lint */
  1138.   
  1139.   /* Event handlers */
  1140. ***************
  1141. *** 63,69 ****
  1142. --- 65,75 ----
  1143.    * appropriate WM_SIZE_HINTS and taking advantage of bit gravity.
  1144.    */
  1145.   
  1146. + #ifdef    STATUSLINE    /* michael */
  1147. + void ResizeScreen(xw, min_width, min_height )
  1148. + #else    STATUSLINE
  1149.   static void ResizeScreen(xw, min_width, min_height )
  1150. + #endif    STATUSLINE
  1151.       register XtermWidget xw;
  1152.       int min_width, min_height;
  1153.   {
  1154. ***************
  1155. *** 94,108 ****
  1156.                    &sizehints))
  1157.           sizehints.flags = 0;
  1158.       sizehints.min_width = min_width;
  1159.       sizehints.min_height = min_height;
  1160.       sizehints.width_inc = FontWidth(screen);
  1161.       sizehints.height_inc = FontHeight(screen);
  1162.       sizehints.width =  (screen->max_col + 1) * FontWidth(screen)
  1163.                   + min_width;
  1164.       sizehints.height = FontHeight(screen) * (screen->max_row + 1)
  1165.                   + min_height;
  1166.       sizehints.flags |= PMinSize|PResizeInc;
  1167. ! #endif
  1168.   
  1169.       argList[0].value = (XtArgVal)min_width;
  1170.       argList[1].value = (XtArgVal)min_height;
  1171. --- 100,121 ----
  1172.                    &sizehints))
  1173.           sizehints.flags = 0;
  1174.       sizehints.min_width = min_width;
  1175. + #ifdef    STATUSLINE    /* michael */
  1176. +     sizehints.min_height = min_height + screen->statusheight;
  1177. + #else    STATUSLINE
  1178.       sizehints.min_height = min_height;
  1179. + #endif    STATUSLINE
  1180.       sizehints.width_inc = FontWidth(screen);
  1181.       sizehints.height_inc = FontHeight(screen);
  1182.       sizehints.width =  (screen->max_col + 1) * FontWidth(screen)
  1183.                   + min_width;
  1184.       sizehints.height = FontHeight(screen) * (screen->max_row + 1)
  1185. + #ifdef    STATUSLINE    /* michael */
  1186. +                 + screen->statusheight
  1187. + #endif    STATUSLINE
  1188.                   + min_height;
  1189.       sizehints.flags |= PMinSize|PResizeInc;
  1190. ! #endif    nothack
  1191.   
  1192.       argList[0].value = (XtArgVal)min_width;
  1193.       argList[1].value = (XtArgVal)min_height;
  1194. ***************
  1195. *** 115,121 ****
  1196. --- 128,138 ----
  1197.   
  1198.       newAttributes.event_mask =
  1199.           oldAttributes.your_event_mask | StructureNotifyMask;
  1200. + #ifdef    STATUSLINE    /* michael */
  1201. +     newAttributes.bit_gravity = NorthEastGravity;
  1202. + #else    STATUSLINE
  1203.       newAttributes.bit_gravity = EastGravity;
  1204. + #endif    STATUSLINE
  1205.   
  1206.           /* The following statement assumes scrollbar is on Left! 
  1207.              If we ever have scrollbars on the right, then the
  1208. ***************
  1209. *** 126,132 ****
  1210. --- 143,154 ----
  1211.       oldWidth = xw->core.width;
  1212.       oldHeight = xw->core.height;
  1213.       reqWidth = (screen->max_col + 1) * FontWidth(screen) + min_width;
  1214. + #ifdef    STATUSLINE    /* michael */
  1215. +     reqHeight = FontHeight(screen) * (screen->max_row + 1)
  1216. +             + screen->statusheight + min_height;
  1217. + #else    STATUSLINE
  1218.       reqHeight = FontHeight(screen) * (screen->max_row + 1) + min_height;
  1219. + #endif    STATUSLINE
  1220.       geomreqresult = XtMakeResizeRequest ((Widget)xw, reqWidth, reqHeight,
  1221.                            &repWidth, &repHeight);
  1222.   
  1223. ***************
  1224. *** 342,350 ****
  1225. --- 364,379 ----
  1226.       }
  1227.   
  1228.       ResizeScrollBar (screen->scrollWidget, -1, -1, 
  1229. + #ifdef    STATUSLINE    /* michael */
  1230. +              Height (screen) + border + screen->statusheight);
  1231. + #else    STATUSLINE
  1232.                Height (screen) + border);
  1233. + #endif    STATUSLINE
  1234.       RealizeScrollBar (screen->scrollWidget, screen);
  1235.       screen->scrollbar = screen->scrollWidget->core.width;
  1236. + #ifdef    STATUSLINE    /* michael */
  1237. +     status_box[0].x += screen->scrollbar;
  1238. + #endif    STATUSLINE
  1239.   
  1240.       ScrollBarDrawThumb(screen->scrollWidget);
  1241.       ResizeScreen (xw, border + screen->scrollWidget->core.width, border);
  1242. ***************
  1243. *** 359,364 ****
  1244. --- 388,396 ----
  1245.   
  1246.       if(!screen->scrollbar)
  1247.           return;
  1248. + #ifdef    STATUSLINE    /* michael */
  1249. +     status_box[0].x -= screen->scrollbar;
  1250. + #endif    STATUSLINE
  1251.       screen->scrollbar = 0;
  1252.       XUnmapWindow(screen->display, XtWindow(screen->scrollWidget));
  1253.       ResizeScreen( term, border, border );
  1254. diff -rc ../xterm/termcap ./termcap
  1255. *** ../xterm/termcap    Sat Oct  8 02:26:20 1988
  1256. --- ./termcap    Tue May 30 14:53:57 1989
  1257. ***************
  1258. *** 8,13 ****
  1259. --- 8,15 ----
  1260.   #
  1261.   #     :ic=\E[@:\
  1262.   #
  1263. + vk|kterm|kterm| (X window system):\
  1264. +     :KJ:sc=\E7:rc=\E8:cs=\E[%i%d;%dr:TY=ascii:tc=xterms:
  1265.   vs|xterm|vs100|xterm terminal emulator (X window system):\
  1266.       :AL=\E[%dL:DC=\E[%dP:DL=\E[%dM:DO=\E[%dB:IC=\E[%d@:MT:UP=\E[%dA:\
  1267.       :al=\E[L:am:\
  1268. diff -rc ../xterm/util.c ./util.c
  1269. *** ../xterm/util.c    Fri Oct  7 21:20:55 1988
  1270. --- ./util.c    Tue May 30 14:53:59 1989
  1271. ***************
  1272. *** 1,5 ****
  1273. --- 1,6 ----
  1274.   /*
  1275.    *    $XConsortium: util.c,v 1.10 88/10/07 08:20:08 swick Exp $
  1276. +  *    $Header: util.c,v 1.1 89/05/30 14:53:58 kagotani Rel $
  1277.    */
  1278.   
  1279.   #include <X11/copyright.h>
  1280. ***************
  1281. *** 31,36 ****
  1282. --- 32,38 ----
  1283.   
  1284.   #ifndef lint
  1285.   static char rcs_id[] = "$XConsortium: util.c,v 1.10 88/10/07 08:20:08 swick Exp $";
  1286. + static char kterm_id[] = "$Header: util.c,v 1.1 89/05/30 14:53:58 kagotani Rel $";
  1287.   #endif    /* lint */
  1288.   
  1289.   #include <stdio.h>
  1290. ***************
  1291. *** 158,164 ****
  1292. --- 160,170 ----
  1293.       register int amount = screen->refresh_amt;
  1294.       register int row = screen->cur_row;
  1295.   
  1296. + #ifdef    STATUSLINE    /* michael */
  1297. +     if(amount == 0 || screen->instatus)
  1298. + #else    STATUSLINE
  1299.       if(amount == 0)
  1300. + #endif    STATUSLINE
  1301.           return(0);
  1302.       if(amount > 0) {
  1303.           register int bottom;
  1304. ***************
  1305. *** 572,578 ****
  1306. --- 578,589 ----
  1307.       if(screen->cursor_state)
  1308.           HideCursor();
  1309.       screen->do_wrap = 0;
  1310. + #ifdef    STATUSLINE    /* michael */
  1311. +     if(screen->cur_row - screen->topline <= screen->max_row ||
  1312. +        screen->instatus) {
  1313. + #else    STATUSLINE
  1314.       if(screen->cur_row - screen->topline <= screen->max_row) {
  1315. + #endif    STATUSLINE
  1316.           if(!AddToRefresh(screen)) {
  1317.           if(screen->scroll_amt)
  1318.               FlushScroll(screen);
  1319. ***************
  1320. *** 595,600 ****
  1321. --- 606,614 ----
  1322.           XFillRectangle(
  1323.               screen->display,
  1324.               TextWindow(screen), 
  1325. + #ifdef    STATUSLINE    /* michael */
  1326. +             screen->instatus ? screen->normalGC :
  1327. + #endif    STATUSLINE
  1328.               screen->reverseGC,
  1329.               cx, cy,
  1330.               (unsigned) width, (unsigned) FontHeight(screen));
  1331. ***************
  1332. *** 620,626 ****
  1333. --- 634,645 ----
  1334.       if (n > (width = screen->max_col + 1 - screen->cur_col))
  1335.             n = width;
  1336.           
  1337. + #ifdef    STATUSLINE    /* michael */
  1338. +     if(screen->cur_row - screen->topline <= screen->max_row ||
  1339. +        screen->instatus) {
  1340. + #else    STATUSLINE
  1341.       if(screen->cur_row - screen->topline <= screen->max_row) {
  1342. + #endif    STATUSLINE
  1343.           if(!AddToRefresh(screen)) {
  1344.           if(screen->scroll_amt)
  1345.               FlushScroll(screen);
  1346. ***************
  1347. *** 641,646 ****
  1348. --- 660,668 ----
  1349.                FontHeight(screen), 
  1350.                cx, cy);
  1351.           XFillRectangle (screen->display, TextWindow(screen),
  1352. + #ifdef    STATUSLINE    /* michael */
  1353. +              screen->instatus? screen->normalGC :
  1354. + #endif    STATUSLINE
  1355.                screen->reverseGC,
  1356.                screen->border + screen->scrollbar + Width(screen) - width,
  1357.                cy, width, FontHeight(screen));
  1358. ***************
  1359. *** 710,720 ****
  1360. --- 732,750 ----
  1361.       if(screen->cursor_state)
  1362.           HideCursor();
  1363.       screen->do_wrap = 0;
  1364. + #ifdef    STATUSLINE    /* michael */
  1365. +     if(screen->cur_row - screen->topline <= screen->max_row ||
  1366. +        screen->instatus) {
  1367. + #else    STATUSLINE
  1368.       if(screen->cur_row - screen->topline <= screen->max_row) {
  1369. + #endif    STATUSLINE
  1370.           if(!AddToRefresh(screen)) {
  1371.       if(screen->scroll_amt)
  1372.           FlushScroll(screen);
  1373.           XFillRectangle(screen->display, TextWindow(screen),
  1374. + #ifdef    STATUSLINE    /* michael */
  1375. +         screen->instatus ? screen->normalGC :
  1376. + #endif    STATUSLINE
  1377.             screen->reverseGC,
  1378.            CursorX(screen, screen->cur_col),
  1379.            CursorY(screen, screen->cur_row),
  1380. ***************
  1381. *** 737,747 ****
  1382. --- 767,785 ----
  1383.       if(screen->cursor_state)
  1384.           HideCursor();
  1385.       screen->do_wrap = 0;
  1386. + #ifdef    STATUSLINE    /* michael */
  1387. +     if(screen->cur_row - screen->topline <= screen->max_row ||
  1388. +        screen->instatus) {
  1389. + #else    STATUSLINE
  1390.       if(screen->cur_row - screen->topline <= screen->max_row) {
  1391. + #endif    STATUSLINE
  1392.           if(!AddToRefresh(screen)) {
  1393.           if(screen->scroll_amt)
  1394.               FlushScroll(screen);
  1395.           XFillRectangle (screen->display, TextWindow(screen),
  1396. + #ifdef    STATUSLINE    /* michael */
  1397. +              screen->instatus ? screen->normalGC :
  1398. + #endif    STATUSLINE
  1399.                screen->reverseGC,
  1400.                screen->border + screen->scrollbar,
  1401.                 CursorY (screen, screen->cur_row),
  1402. ***************
  1403. *** 762,772 ****
  1404. --- 800,819 ----
  1405.       if(screen->cursor_state)
  1406.           HideCursor();
  1407.       screen->do_wrap = 0;
  1408. + #ifdef    STATUSLINE    /* michael */
  1409. +     if(screen->cur_row - screen->topline <= screen->max_row ||
  1410. +        screen->instatus) {
  1411. + #else    STATUSLINE
  1412.       if(screen->cur_row - screen->topline <= screen->max_row) {
  1413. + #endif    STATUSLINE
  1414.           if(!AddToRefresh(screen)) {
  1415.           if(screen->scroll_amt)
  1416.               FlushScroll(screen);
  1417.           XFillRectangle (screen->display, TextWindow(screen), 
  1418. + #ifdef    STATUSLINE    /* michael & kato */
  1419. +              screen->instatus && screen->reversestatus ?
  1420. +              screen->normalGC :
  1421. + #endif    STATUSLINE
  1422.                screen->reverseGC,
  1423.                screen->border + screen->scrollbar,
  1424.                 CursorY (screen, screen->cur_row),
  1425. ***************
  1426. *** 788,794 ****
  1427. --- 835,845 ----
  1428.       if((top = -screen->topline) <= screen->max_row) {
  1429.           if(screen->scroll_amt)
  1430.               FlushScroll(screen);
  1431. + #ifdef    STATUSLINE    /* michael */
  1432. +         if(top == 0 && !screen->statusline)
  1433. + #else    STATUSLINE
  1434.           if(top == 0)
  1435. + #endif    STATUSLINE
  1436.               XClearWindow(screen->display, TextWindow(screen));
  1437.           else
  1438.               XClearArea(screen->display, TextWindow(screen),
  1439. ***************
  1440. *** 863,869 ****
  1441. --- 914,924 ----
  1442.           toprow = 0;
  1443.       }
  1444.       if (toprow + nrows - 1 > screen->max_row)
  1445. + #ifdef    STATUSLINE    /* michael */
  1446. +         nrows = screen->max_row - toprow + 1 + screen->statusline;
  1447. + #else    STATUSLINE
  1448.           nrows = screen->max_row - toprow + 1;
  1449. + #endif    STATUSLINE
  1450.       if (leftcol + ncols - 1 > screen->max_col)
  1451.           ncols = screen->max_col - leftcol + 1;
  1452.   
  1453. ***************
  1454. *** 901,907 ****
  1455. --- 956,983 ----
  1456.       tmpGC = screen->normalboldGC;
  1457.       screen->normalboldGC = screen->reverseboldGC;
  1458.       screen->reverseboldGC = tmpGC;
  1459. + /*
  1460. +  * Bug fix by michael
  1461. +  * 3 non null lines are inserted.
  1462. +  */
  1463. +     tmpGC = screen->cursorGC;
  1464. +     screen->cursorGC = screen->reversecursorGC;
  1465. +     screen->reversecursorGC = tmpGC;
  1466.   
  1467. + #ifdef    KANJI    /* ariza & michael */
  1468. +     tmpGC = screen->w_normalGC;
  1469. +     screen->w_normalGC = screen->w_reverseGC;
  1470. +     screen->w_reverseGC = tmpGC;
  1471. + 
  1472. +     tmpGC = screen->w_normalboldGC;
  1473. +     screen->w_normalboldGC = screen->w_reverseboldGC;
  1474. +     screen->w_reverseboldGC = tmpGC;
  1475. + 
  1476. +     tmpGC = screen->w_cursorGC;
  1477. +     screen->w_cursorGC = screen->w_reversecursorGC;
  1478. +     screen->w_reversecursorGC = tmpGC;
  1479. + #endif    KANJI
  1480. + 
  1481.       {
  1482.           unsigned long fg, bg;
  1483.           bg = term->core.background_pixel;
  1484. ***************
  1485. *** 945,951 ****
  1486. --- 1021,1031 ----
  1487.           TekReverseVideo(screen);
  1488.       }
  1489.       XClearWindow(screen->display, TextWindow(screen));
  1490. + #ifdef    STATUSLINE    /* michael */
  1491. +     ScrnRefresh (screen, 0, 0, screen->max_row + 1 + screen->statusline,
  1492. + #else    STATUSLINE
  1493.       ScrnRefresh (screen, 0, 0, screen->max_row + 1,
  1494. + #endif    STATUSLINE
  1495.        screen->max_col + 1, False);
  1496.       if(screen->Tshow) {
  1497.           XClearWindow(screen->display, tek);
  1498.