Copy w32api from trunk
[reactos.git] / rosapps / mc / slang / sldisply.c
1 /* Copyright (c) 1992, 1995 John E. Davis
2 * All rights reserved.
3 *
4 * You may distribute under the terms of either the GNU General Public
5 * License or the Perl Artistic License.
6 */
7
8 /*
9 * SLTT_TRANSP_ACS_PATCH (#define/#undef):
10 *
11 * The problem: some terminals (e.g. QNX/qansi*) map the whole upper half of
12 * the ASCII table to the lower half, when alt-char-set is activated with
13 * the smacs/as string-sequence. This means, that if 0 <= ch < 128 written
14 * to the terminal, it will be translated to (ch+128) automatically by the
15 * terminal: so not only the line-drawing characters can be written, when
16 * the alt-char-set is activated. It implicitly means, that space, NL, CR,
17 * etc. characters (exactly: anything besides the "standard" line drawing
18 * characters) can not be written directly to the terminal, when the
19 * alt-char-set is activated, because writing these characters doesn't cause
20 * an implicit/temporary switching-back to the standard char-set!
21 *
22 * The original code in SLang assumes that space, NL, CR, etc. can be
23 * printed when alt-char-set is activated. If SLTT_TRANSP_ACS_PATCH is
24 * defined, the modified code will not use this assumption.
25 * [Remark: the patch-code is not the most exact solution, but works...]
26 */
27 /*#define SLTT_TRANSP_ACS_PATCH 1*/
28
29 /*
30 * QNX_QANSI_SLANG_COMPAT_ACS (#define/#undef):
31 *
32 * A more OS/terminal-specific solution for the problem mentioned above
33 * (->SLTT_TRANSP_ACS_PATCH).
34 *
35 * If QNX_QANSI_SLANG_COMPAT_ACS is defined, the default smacs/sa, rmacs/ae,
36 * acsc/ac [and sgr/sa, if it would be used!] command sequences will be
37 * replaced internally with the "old style" (pre-QNX 4.23) sequences in case
38 * of QNX/qansi terminals. Using these optional command sequences the terminal
39 * remains compatible with the original SLang code (without using the
40 * workaround-code enabled by defining SLTT_TRANSP_ACS_PATCH).
41 */
42 /*#define QNX_QANSI_SLANG_COMPAT_ACS 1*/
43
44 /* auto-configuration */
45 #ifdef SLTT_TRANSP_ACS_PATCH
46 # if defined(__QNX__) && defined(QNX_QANSI_SLANG_COMPAT_ACS)
47 # undef SLTT_TRANSP_ACS_PATCH
48 # endif
49 #else
50 # if defined(__QNX__) && !defined(QNX_QANSI_SLANG_COMPAT_ACS)
51 # define QNX_QANSI_SLANG_COMPAT_ACS 1
52 # endif
53 #endif
54
55 #include "sl-feat.h"
56 #include "config.h"
57
58 #include <stdio.h>
59 #include <string.h>
60 #ifdef SCO_FLAVOR
61 # include <sys/types.h>
62 # include <sys/timeb.h> /* for struct timeb, used in time.h */
63 #endif
64 #include <time.h>
65 #include <ctype.h>
66
67 #ifndef VMS
68 # include <sys/time.h>
69 # ifdef __QNX__
70 # include <sys/select.h>
71 # endif
72 # include <sys/types.h>
73 #endif
74
75 #ifdef __BEOS__
76 /* Prototype for select */
77 # include <net/socket.h>
78 #endif
79
80 #ifdef HAVE_TERMIOS_H
81 # include <termios.h>
82 #endif
83
84 #ifdef VMS
85 # include <unixlib.h>
86 # include <unixio.h>
87 # include <dvidef.h>
88 # include <descrip.h>
89 # include <lib$routines.h>
90 # include <starlet.h>
91 #else
92 # if !defined(sun)
93 # include <sys/ioctl.h>
94 # endif
95 #endif
96
97
98 #ifdef SYSV
99 # include <sys/termio.h>
100 # include <sys/stream.h>
101 # include <sys/ptem.h>
102 # include <sys/tty.h>
103 #endif
104
105 #if defined (_AIX) && !defined (FD_SET)
106 # include <sys/select.h> /* for FD_ISSET, FD_SET, FD_ZERO */
107 #endif
108
109 #include <errno.h>
110 #include "slang.h"
111 #include "_slang.h"
112
113 #ifdef HAVE_STDLIB_H
114 # include <stdlib.h>
115 #endif
116
117 #ifdef HAVE_UNISTD_H
118 # include <unistd.h>
119 #endif
120
121 #if defined(__DECC) && defined(VMS)
122 /* These get prototypes for write an sleep */
123 # include <unixio.h>
124 #endif
125 #include <signal.h>
126
127
128 /* Colors: These definitions are used for the display. However, the
129 * application only uses object handles which get mapped to this
130 * internal representation. The mapping is performed by the Color_Map
131 * structure below. */
132
133 #define CHAR_MASK 0x000000FF
134 #define FG_MASK 0x0000FF00
135 #define BG_MASK 0x00FF0000
136 #define ATTR_MASK 0x1F000000
137 #define BGALL_MASK 0x0FFF0000
138
139 /* The 0x10000000 bit represents the alternate character set. BGALL_MASK does
140 * not include this attribute.
141 */
142
143
144
145 #define GET_FG(color) ((color & FG_MASK) >> 8)
146 #define GET_BG(color) ((color & BG_MASK) >> 16)
147 #define MAKE_COLOR(fg, bg) (((fg) | ((bg) << 8)) << 8)
148
149 int SLtt_Screen_Cols;
150 int SLtt_Screen_Rows;
151 int SLtt_Term_Cannot_Insert;
152 int SLtt_Term_Cannot_Scroll;
153 int SLtt_Use_Ansi_Colors;
154 int SLtt_Blink_Mode = 1;
155 int SLtt_Use_Blink_For_ACS = 0;
156 int SLtt_Newline_Ok = 0;
157 int SLtt_Has_Alt_Charset = 0;
158 int SLtt_Force_Keypad_Init = 0;
159
160 /* -1 means unknown */
161 int SLtt_Has_Status_Line = -1; /* hs */
162
163 static int Automatic_Margins;
164 /* static int No_Move_In_Standout; */
165 static int Worthless_Highlight;
166 #define HP_GLITCH_CODE
167 #ifdef HP_GLITCH_CODE
168 /* This glitch is exclusive to HP term. Basically it means that to clear
169 * attributes, one has to erase to the end of the line.
170 */
171 static int Has_HP_Glitch;
172 #endif
173
174 static char *Reset_Color_String;
175
176 static int Linux_Console;
177
178 /* It is crucial that JMAX_COLORS must be less than 128 since the high bit
179 * is used to indicate a character from the ACS (alt char set). The exception
180 * to this rule is if SLtt_Use_Blink_For_ACS is true. This means that of
181 * the highbit is set, we interpret that as a blink character. This is
182 * exploited by DOSemu.
183 */
184 #define JMAX_COLORS 256
185 #define JNORMAL_COLOR 0
186
187 typedef struct
188 {
189 SLtt_Char_Type fgbg;
190 SLtt_Char_Type mono;
191 char *custom_esc;
192 } Ansi_Color_Type;
193
194 #define RGB1(r, g, b) ((r) | ((g) << 1) | ((b) << 2))
195 #define RGB(r, g, b, br, bg, bb) ((RGB1(r, g, b) << 8) | (RGB1(br, bg, bb) << 16))
196
197 static Ansi_Color_Type Ansi_Color_Map[JMAX_COLORS] =
198 {
199 {RGB(1, 1, 1, 0, 0, 0), 0x00000000, NULL}, /* white/black */
200 {RGB(0, 1, 0, 0, 0, 0), SLTT_REV_MASK, NULL}, /* green/black */
201 {RGB(1, 0, 1, 0, 0, 0), SLTT_REV_MASK, NULL}, /* magenta/black */
202 {RGB(0, 1, 1, 0, 0, 0), SLTT_REV_MASK, NULL}, /* cyan/black */
203 {RGB(1, 0, 0, 0, 0, 0), SLTT_REV_MASK, NULL},
204 {RGB(0, 1, 0, 0, 0, 1), SLTT_REV_MASK, NULL},
205 {RGB(1, 0, 0, 0, 0, 1), SLTT_REV_MASK, NULL},
206 {RGB(1, 0, 0, 0, 1, 0), SLTT_REV_MASK, NULL},
207 {RGB(0, 0, 1, 1, 0, 0), SLTT_REV_MASK, NULL},
208 {RGB(0, 1, 0, 1, 0, 0), SLTT_REV_MASK, NULL},
209 {RGB(0, 1, 1, 1, 1, 1), SLTT_REV_MASK, NULL},
210 {RGB(1, 1, 0, 1, 1, 1), SLTT_REV_MASK, NULL},
211 {RGB(1, 0, 1, 1, 1, 1), SLTT_REV_MASK, NULL},
212 {RGB(0, 0, 0, 0, 1, 1), SLTT_REV_MASK, NULL},
213 {RGB(0, 1, 0, 1, 1, 1), SLTT_REV_MASK, NULL},
214 {RGB(0, 1, 0, 1, 1, 1), SLTT_REV_MASK, NULL},
215 {RGB(0, 1, 0, 1, 1, 1), SLTT_REV_MASK, NULL},
216 {RGB(0, 1, 0, 1, 1, 1), SLTT_REV_MASK, NULL}
217 };
218
219
220 /* This is the string to use to use when outputting color information.
221 */
222 #ifdef M_UNIX
223 /* work around for sco console bug that can't handle combined sequences */
224 static char *Color_Escape_Sequence = "\033[3%dm\033[4%dm";
225 #else
226 /* Believe it or not, this is what is in the linux terminfo database. It
227 * produces the same escape sequence but it is much more CPU intensive.
228 * Why not just encode it as "\033[3%p1%dm\033[4%p2%dm" ???
229 */
230 /* static char *Color_Escape_Sequence = "\033[%p1%{30}%+%dm\033[%p2%{40}%+%dm"; */
231 static char *Color_Escape_Sequence = "\033[3%d;4%dm";
232 #endif
233
234 char *SLtt_Graphics_Char_Pairs; /* ac termcap string -- def is vt100 */
235
236
237 /* 1 if terminal lacks the ability to do into insert mode or into delete
238 mode. Currently controlled by S-Lang but later perhaps termcap. */
239
240 static char *UnderLine_Vid_Str;
241 static char *Blink_Vid_Str;
242 static char *Bold_Vid_Str;
243 static char *Ins_Mode_Str; /* = "\033[4h"; */ /* ins mode (im) */
244 static char *Eins_Mode_Str; /* = "\033[4l"; */ /* end ins mode (ei) */
245 static char *Scroll_R_Str; /* = "\033[%d;%dr"; */ /* scroll region */
246 static char *Cls_Str; /* = "\033[2J\033[H"; */ /* cl termcap STR for ansi terminals */
247 static char *Rev_Vid_Str; /* = "\033[7m"; */ /* mr,so termcap string */
248 static char *Norm_Vid_Str; /* = "\033[m"; */ /* me,se termcap string */
249 static char *Del_Eol_Str; /* = "\033[K"; */ /* ce */
250 static char *Del_Char_Str; /* = "\033[P"; */ /* dc */
251 static char *Del_N_Lines_Str; /* = "\033[%dM"; */ /* DL */
252 static char *Add_N_Lines_Str; /* = "\033[%dL"; */ /* AL */
253 static char *Rev_Scroll_Str;
254 static char *Curs_Up_Str;
255 static char *Curs_F_Str; /* RI termcap string */
256 static char *Cursor_Visible_Str; /* ve termcap string */
257 static char *Cursor_Invisible_Str; /* vi termcap string */
258
259 static char *Start_Alt_Chars_Str; /* as */
260 static char *End_Alt_Chars_Str; /* ae */
261 static char *Enable_Alt_Char_Set; /* eA */
262
263 static char *Term_Init_Str;
264 static char *Keypad_Init_Str;
265 static char *Term_Reset_Str;
266 static char *Keypad_Reset_Str;
267
268 /* status line functions */
269 static char *Disable_Status_line_Str; /* ds */
270 static char *Return_From_Status_Line_Str; /* fs */
271 static char *Goto_Status_Line_Str; /* ts */
272 static int Num_Status_Line_Columns; /* ws */
273 static int Status_Line_Esc_Ok; /* es */
274
275 /* static int Len_Curs_F_Str = 5; */
276
277 /* cm string has %i%d since termcap numbers columns from 0 */
278 /* char *CURS_POS_STR = "\033[%d;%df"; ansi-- hor and vert pos */
279 static char *Curs_Pos_Str; /* = "\033[%i%d;%dH";*/ /* cm termcap string */
280
281
282 /* scrolling region */
283 static int Scroll_r1 = 0, Scroll_r2 = 23;
284 static int Cursor_r, Cursor_c; /* 0 based */
285
286 /* current attributes --- initialized to impossible value */
287 static SLtt_Char_Type Current_Fgbg = 0xFFFFFFFFU;
288
289 static int Cursor_Set; /* 1 if cursor position known, 0
290 * if not. -1 if only row is known
291 */
292
293
294 #define MAX_OUTPUT_BUFFER_SIZE 4096
295
296 static unsigned char Output_Buffer[MAX_OUTPUT_BUFFER_SIZE];
297 static unsigned char *Output_Bufferp = Output_Buffer;
298
299 unsigned long SLtt_Num_Chars_Output;
300
301 #ifdef SLTT_TRANSP_ACS_PATCH
302 static int SLtt_ACS_Active = 0;
303 #endif
304
305 static int sl_usleep (unsigned long usecs)
306 {
307 #ifndef VMS
308 struct timeval tv;
309 tv.tv_sec = usecs / 1000000;
310 tv.tv_usec = usecs % 1000000;
311 return select(0, NULL, NULL, NULL, &tv);
312 #else
313 return 0;
314 #endif
315 }
316
317 int SLtt_flush_output (void)
318 {
319 int nwrite = 0;
320 unsigned int total;
321 int n = (int) (Output_Bufferp - Output_Buffer);
322
323 SLtt_Num_Chars_Output += n;
324
325 total = 0;
326 while (n > 0)
327 {
328 nwrite = write (fileno(stdout), (char *) Output_Buffer + total, n);
329 if (nwrite == -1)
330 {
331 nwrite = 0;
332 #ifdef EAGAIN
333 if (errno == EAGAIN)
334 {
335 sl_usleep (100000); /* 1/10 sec */
336 continue;
337 }
338 #endif
339 #ifdef EWOULDBLOCK
340 if (errno == EWOULDBLOCK)
341 {
342 sl_usleep (100000);
343 continue;
344 }
345 #endif
346 #ifdef EINTR
347 if (errno == EINTR) continue;
348 #endif
349 break;
350 }
351 n -= nwrite;
352 total += nwrite;
353 }
354 Output_Bufferp = Output_Buffer;
355 return n;
356 }
357
358
359 int SLtt_Baud_Rate;
360 static void tt_write(char *str, unsigned int n)
361 {
362 static unsigned long last_time;
363 static int total;
364 unsigned long now;
365 unsigned int ndiff;
366
367 if ((str == NULL) || (n == 0)) return;
368 total += n;
369
370 while (1)
371 {
372 ndiff = MAX_OUTPUT_BUFFER_SIZE - (int) (Output_Bufferp - Output_Buffer);
373 if (ndiff < n)
374 {
375 SLMEMCPY ((char *) Output_Bufferp, (char *) str, ndiff);
376 Output_Bufferp += ndiff;
377 SLtt_flush_output ();
378 n -= ndiff;
379 str += ndiff;
380 }
381 else
382 {
383 SLMEMCPY ((char *) Output_Bufferp, str, n);
384 Output_Bufferp += n;
385 break;
386 }
387 }
388
389 if (((SLtt_Baud_Rate > 150) && (SLtt_Baud_Rate <= 9600))
390 && (10 * total > SLtt_Baud_Rate))
391 {
392 total = 0;
393 if ((now = (unsigned long) time(NULL)) - last_time <= 1)
394 {
395 SLtt_flush_output ();
396 sleep((unsigned) 1);
397 }
398 last_time = now;
399 }
400 }
401
402
403 void SLtt_write_string (char *str)
404 {
405 if (str != NULL) tt_write(str, strlen(str));
406 }
407
408
409 void SLtt_putchar (char ch)
410 {
411 #ifdef SLTT_TRANSP_ACS_PATCH
412 int restore_acs = 0;
413 #endif
414
415 SLtt_normal_video ();
416 if (Cursor_Set == 1)
417 {
418 if (ch >= ' ') Cursor_c++;
419 #ifndef SLTT_TRANSP_ACS_PATCH
420 else if (ch == '\b') Cursor_c--;
421 #else
422 if (ch <= ' ' && SLtt_ACS_Active)
423 {
424 SLtt_set_alt_char_set (0);
425 restore_acs = 1;
426 }
427 if (ch == '\b') Cursor_c--;
428 #endif
429 else if (ch == '\r') Cursor_c = 0;
430 else Cursor_Set = 0;
431
432 if ((Cursor_c + 1 == SLtt_Screen_Cols)
433 && Automatic_Margins) Cursor_Set = 0;
434 }
435
436 if (Output_Bufferp < Output_Buffer + MAX_OUTPUT_BUFFER_SIZE)
437 {
438 *Output_Bufferp++ = (unsigned char) ch;
439 }
440 else tt_write (&ch, 1);
441
442 #ifdef SLTT_TRANSP_ACS_PATCH
443 if (restore_acs)
444 {
445 SLtt_set_alt_char_set (1);
446 }
447 #endif
448 }
449
450 /* this is supposed to be fast--- also handles
451 termcap: %d, &i, %., %+, %r strings as well as terminfo stuff */
452 static unsigned int tt_sprintf(char *buf, char *fmt, int x, int y)
453 {
454 register unsigned char *f = (unsigned char *) fmt, *b, ch;
455 int offset = 0, tinfo = 0;
456 int stack[10];
457 int i = 0, z;
458 stack[0] = y; stack[1] = x; i = 2;
459
460 b = (unsigned char *) buf;
461 if (fmt != NULL) while ((ch = *f++) != 0)
462 {
463 if (ch != '%') *b++ = ch;
464 else
465 {
466 ch = *f++;
467 if (tinfo)
468 {
469 if ((ch <= '3') && (ch >= '0'))
470 {
471 /* map it to termcap. Since this is terminfo,
472 * it must be one of:
473 * %2d, %3d, %02d, %03d
474 *
475 * I am assuming that a terminal that understands
476 * %2d form will also understand the %02d form. These
477 * only differ by a space padding the field.
478 */
479
480 /* skip the 'd'-- hope it is there */
481 if (ch == '0')
482 {
483 ch = *f;
484 f += 2;
485 }
486 else f++;
487 }
488 }
489
490 switch (ch)
491 {
492 case 'p':
493 tinfo = 1;
494 ch = *f++;
495 if (ch == '1') stack[i++] = x; else stack[i++] = y;
496 break;
497
498 case '\'': /* 'x' */
499 stack[i++] = *f++;
500 f++;
501 break;
502
503 case '{': /* literal constant, e.g. {30} */
504 z = 0;
505 while (((ch = *f) <= '9') && (ch >= '0'))
506 {
507 z = z * 10 + (ch - '0');
508 f++;
509 }
510 stack[i++] = z;
511 if (ch == '}') f++;
512 break;
513
514 case 'd':
515 case '2':
516 case '3':
517 z = stack[--i];
518 z += offset;
519 if (z >= 100)
520 {
521 *b++ = z / 100 + '0';
522 z = z % 100;
523 goto ten;
524 }
525 else if (ch == 3)
526 {
527 *b++ = '0';
528 ch = '2';
529 }
530
531 if (z >= 10)
532 {
533 ten:
534 *b++ = z / 10 + '0';
535 z = z % 10;
536 }
537 else if (ch == 2) *b++ = '0';
538
539 *b++ = z + '0';
540 break;
541
542 case 'i':
543 offset = 1;
544 break;
545
546 case '+':
547 if (tinfo)
548 {
549 z = stack[--i];
550 stack[i-1] += z;
551 }
552 else
553 {
554 ch = *f++;
555 if ((unsigned char) ch == 128) ch = 0;
556 ch = ch + (unsigned char) stack[--i];
557 if (ch == '\n') ch++;
558 *b++ = ch;
559 }
560 break;
561
562 case 'r':
563 stack[0] = x;
564 stack[1] = y;
565 break;
566
567 case '.':
568 case 'c':
569 ch = (unsigned char) stack[--i];
570 if (ch == '\n') ch++;
571 *b++ = ch;
572 break;
573
574 default:
575 *b++ = ch;
576 }
577 }
578 }
579 *b = 0;
580 return((unsigned int) (b - (unsigned char *) buf));
581 }
582
583 static void tt_printf(char *fmt, int x, int y)
584 {
585 char buf[256];
586 unsigned int n;
587 if (fmt == NULL) return;
588 n = tt_sprintf(buf, fmt, x, y);
589 tt_write(buf, n);
590 }
591
592
593 void SLtt_set_scroll_region (int r1, int r2)
594 {
595 Scroll_r1 = r1;
596 Scroll_r2 = r2;
597 tt_printf (Scroll_R_Str, Scroll_r1, Scroll_r2);
598 Cursor_Set = 0;
599 }
600
601 void SLtt_reset_scroll_region (void)
602 {
603 SLtt_set_scroll_region(0, SLtt_Screen_Rows - 1);
604 }
605
606 int SLtt_set_cursor_visibility (int show)
607 {
608 if ((Cursor_Visible_Str == NULL) || (Cursor_Invisible_Str == NULL))
609 return -1;
610
611 SLtt_write_string (show ? Cursor_Visible_Str : Cursor_Invisible_Str);
612 return 0;
613 }
614
615
616 /* the goto_rc function moves to row relative to scrolling region */
617 void SLtt_goto_rc(int r, int c)
618 {
619 char *s = NULL;
620 int n;
621 char buf[6];
622 #ifdef SLTT_TRANSP_ACS_PATCH
623 int check_alt_acs = 0;
624 #endif
625
626 if (c < 0)
627 {
628 c = -c - 1;
629 Cursor_Set = 0;
630 }
631
632 /* if (No_Move_In_Standout && Current_Fgbg) SLtt_normal_video (); */
633 r += Scroll_r1;
634
635 if ((Cursor_Set > 0) || ((Cursor_Set < 0) && !Automatic_Margins))
636 {
637 n = r - Cursor_r;
638 if ((n == -1) && (Cursor_Set > 0) && (Cursor_c == c)
639 && (Curs_Up_Str != NULL))
640 {
641 s = Curs_Up_Str;
642 }
643 else if ((n >= 0) && (n <= 4))
644 {
645 if ((n == 0) && (Cursor_Set == 1)
646 && ((c > 1) || (c == Cursor_c)))
647 {
648 if (Cursor_c == c) return;
649 if (Cursor_c == c + 1)
650 {
651 s = buf;
652 *s++ = '\b'; *s = 0;
653 s = buf;
654 #ifdef SLTT_TRANSP_ACS_PATCH
655 check_alt_acs = 1;
656 #endif
657 }
658 }
659 else if (c == 0)
660 {
661 s = buf;
662 if ((Cursor_Set != 1) || (Cursor_c != 0)) *s++ = '\r';
663 while (n--) *s++ = '\n';
664 #ifdef VMS
665 /* Need to add this after \n to start a new record. Sheesh. */
666 *s++ = '\r';
667 #endif
668 *s = 0;
669 s = buf;
670 #ifdef SLTT_TRANSP_ACS_PATCH
671 check_alt_acs = 1;
672 #endif
673 }
674 /* Will fail on VMS */
675 #ifndef VMS
676 else if (SLtt_Newline_Ok && (Cursor_Set == 1) &&
677 (Cursor_c >= c) && (c + 3 > Cursor_c))
678 {
679 s = buf;
680 while (n--) *s++ = '\n';
681 n = Cursor_c - c;
682 while (n--) *s++ = '\b';
683 *s = 0;
684 s = buf;
685 #ifdef SLTT_TRANSP_ACS_PATCH
686 check_alt_acs = 1;
687 #endif
688 }
689 #endif
690 }
691 }
692 #ifndef SLTT_TRANSP_ACS_PATCH
693 if (s != NULL) SLtt_write_string(s);
694 #else
695 if (s != NULL)
696 {
697 if (check_alt_acs && SLtt_ACS_Active)
698 {
699 SLtt_set_alt_char_set (0);
700 SLtt_write_string(s);
701 SLtt_set_alt_char_set (1);
702 }
703 else SLtt_write_string(s);
704 }
705 #endif
706 else tt_printf(Curs_Pos_Str, r, c);
707 Cursor_c = c; Cursor_r = r;
708 Cursor_Set = 1;
709 }
710
711 void SLtt_begin_insert (void)
712 {
713 SLtt_write_string(Ins_Mode_Str);
714 }
715
716 void SLtt_end_insert (void)
717 {
718 SLtt_write_string(Eins_Mode_Str);
719 }
720
721 void SLtt_delete_char (void)
722 {
723 SLtt_normal_video ();
724 SLtt_write_string(Del_Char_Str);
725 }
726
727 void SLtt_erase_line (void)
728 {
729 SLtt_write_string("\r");
730 Cursor_Set = 1; Cursor_c = 0;
731 SLtt_del_eol();
732 }
733
734 void SLtt_delete_nlines (int n)
735 {
736 int r1, curs;
737 char buf[132];
738 #ifdef SLTT_TRANSP_ACS_PATCH
739 int restore_acs = 0;
740 #endif
741
742 if (n <= 0) return;
743 SLtt_normal_video ();
744 if (Del_N_Lines_Str != NULL) tt_printf(Del_N_Lines_Str,n, 0);
745 else
746 /* get a new terminal */
747 {
748 r1 = Scroll_r1;
749 curs = Cursor_r;
750 SLtt_set_scroll_region(curs, Scroll_r2);
751 SLtt_goto_rc(Scroll_r2 - Scroll_r1, 0);
752 #ifdef SLTT_TRANSP_ACS_PATCH
753 if (SLtt_ACS_Active)
754 {
755 SLtt_set_alt_char_set (0);
756 restore_acs = 1;
757 }
758 #endif
759 SLMEMSET(buf, '\n', (unsigned int) n);
760 tt_write(buf, (unsigned int) n);
761 #ifdef SLTT_TRANSP_ACS_PATCH
762 if (restore_acs) SLtt_set_alt_char_set (1);
763 #endif
764 /* while (n--) tt_putchar('\n'); */
765 SLtt_set_scroll_region(r1, Scroll_r2);
766 SLtt_goto_rc(curs, 0);
767 }
768 }
769
770 void SLtt_cls (void)
771 {
772 SLtt_normal_video();
773 SLtt_reset_scroll_region ();
774 SLtt_write_string(Cls_Str);
775 }
776
777 void SLtt_reverse_index (int n)
778 {
779 if (!n) return;
780
781 SLtt_normal_video();
782 if (Add_N_Lines_Str != NULL) tt_printf(Add_N_Lines_Str,n, 0);
783 else
784 {
785 while(n--) SLtt_write_string(Rev_Scroll_Str);
786 }
787 }
788
789
790 int SLtt_Ignore_Beep = 1;
791 static char *Visible_Bell_Str;
792
793 void SLtt_beep (void)
794 {
795 if (SLtt_Ignore_Beep & 0x1) SLtt_putchar('\007');
796
797 if (SLtt_Ignore_Beep & 0x2)
798 {
799 if (Visible_Bell_Str != NULL) SLtt_write_string (Visible_Bell_Str);
800 #ifdef __linux__
801 else if (Linux_Console)
802 {
803 SLtt_write_string ("\033[?5h");
804 SLtt_flush_output ();
805 sl_usleep (50000);
806 SLtt_write_string ("\033[?5l");
807 }
808 #endif
809 }
810 SLtt_flush_output ();
811 }
812
813 void SLtt_del_eol (void)
814 {
815 if (Current_Fgbg != 0xFFFFFFFFU) SLtt_normal_video ();
816 SLtt_write_string(Del_Eol_Str);
817 }
818
819 typedef struct
820 {
821 char *name;
822 SLtt_Char_Type color;
823 }
824 Color_Def_Type;
825
826 #define MAX_COLOR_NAMES 17
827 static Color_Def_Type Color_Defs [MAX_COLOR_NAMES] =
828 {
829 {"black", SLSMG_COLOR_BLACK},
830 {"red", SLSMG_COLOR_RED},
831 {"green", SLSMG_COLOR_GREEN},
832 {"brown", SLSMG_COLOR_BROWN},
833 {"blue", SLSMG_COLOR_BLUE},
834 {"magenta", SLSMG_COLOR_MAGENTA},
835 {"cyan", SLSMG_COLOR_CYAN},
836 {"lightgray", SLSMG_COLOR_LGRAY},
837 {"gray", SLSMG_COLOR_GRAY},
838 {"brightred", SLSMG_COLOR_BRIGHT_RED},
839 {"brightgreen", SLSMG_COLOR_BRIGHT_GREEN},
840 {"yellow", SLSMG_COLOR_BRIGHT_BROWN},
841 {"brightblue", SLSMG_COLOR_BRIGHT_BLUE},
842 {"brightmagenta", SLSMG_COLOR_BRIGHT_CYAN},
843 {"brightcyan", SLSMG_COLOR_BRIGHT_MAGENTA},
844 {"white", SLSMG_COLOR_BRIGHT_WHITE},
845 {"default", 25}
846 };
847
848
849 void SLtt_set_mono (int obj, char *what, SLtt_Char_Type mask)
850 {
851 (void) what;
852 if ((obj < 0) || (obj >= JMAX_COLORS))
853 {
854 return;
855 }
856 Ansi_Color_Map[obj].mono = mask & ATTR_MASK;
857 }
858
859 static char *check_color_for_digit_form (char *color)
860 {
861 unsigned int i, ich;
862 char *s = color;
863
864 i = 0;
865 while ((ich = (int) *s) != 0)
866 {
867 if ((ich < '0') || (ich > '9'))
868 return color;
869
870 i = i * 10 + (ich - '0');
871 s++;
872 }
873
874 if (i < MAX_COLOR_NAMES)
875 color = Color_Defs[i].name;
876
877 return color;
878 }
879
880 static int get_default_colors (char **fgp, char **bgp)
881 {
882 static char fg_buf[16], bg_buf[16], *bg, *fg;
883 static int already_parsed;
884 char *p, *pmax;
885
886 if (already_parsed == -1)
887 return -1;
888
889 if (already_parsed)
890 {
891 *fgp = fg;
892 *bgp = bg;
893 return 0;
894 }
895
896 already_parsed = -1;
897
898 bg = getenv ("COLORFGBG");
899
900 if (bg == NULL)
901 {
902 bg = getenv ("DEFAULT_COLORS");
903 if (bg == NULL)
904 return -1;
905 }
906
907 p = fg_buf;
908 pmax = p + (sizeof (fg_buf) - 1);
909
910 while ((*bg != 0) && (*bg != ';'))
911 {
912 if (p < pmax) *p++ = *bg;
913 bg++;
914 }
915 *p = 0;
916
917 if (*bg) bg++;
918
919 p = bg_buf;
920 pmax = p + (sizeof (bg_buf) - 1);
921
922 /* Mark suggested allowing for extra spplication specific stuff following
923 * the background color. That is what the check for the semi-colon is for.
924 */
925 while ((*bg != 0) && (*bg != ';'))
926 {
927 if (p < pmax) *p++ = *bg;
928 bg++;
929 }
930 *p = 0;
931
932 if (!strcmp (fg_buf, "default") || !strcmp(bg_buf, "default"))
933 {
934 *fgp = *bgp = fg = bg = "default";
935 }
936 else
937 {
938 *fgp = fg = check_color_for_digit_form (fg_buf);
939 *bgp = bg = check_color_for_digit_form (bg_buf);
940 }
941 already_parsed = 1;
942 return 0;
943 }
944
945
946 static unsigned char FgBg_Stats[JMAX_COLORS];
947
948 static int Color_0_Modified = 0;
949
950 void SLtt_set_color_object (int obj, SLtt_Char_Type attr)
951 {
952 char *cust_esc;
953
954 if ((obj < 0) || (obj >= JMAX_COLORS)) return;
955
956 cust_esc = Ansi_Color_Map[obj].custom_esc;
957 if (cust_esc != NULL)
958 {
959 SLFREE (cust_esc);
960 FgBg_Stats[(Ansi_Color_Map[obj].fgbg >> 8) & 0x7F] -= 1;
961 Ansi_Color_Map[obj].custom_esc = NULL;
962 }
963
964 Ansi_Color_Map[obj].fgbg = attr;
965 if (obj == 0) Color_0_Modified = 1;
966 }
967
968 SLtt_Char_Type SLtt_get_color_object (int obj)
969 {
970 if ((obj < 0) || (obj >= JMAX_COLORS)) return 0;
971 return Ansi_Color_Map[obj].fgbg;
972 }
973
974
975 void SLtt_add_color_attribute (int obj, SLtt_Char_Type attr)
976 {
977 if ((obj < 0) || (obj >= JMAX_COLORS)) return;
978
979 Ansi_Color_Map[obj].fgbg |= (attr & ATTR_MASK);
980 if (obj == 0) Color_0_Modified = 1;
981 }
982
983 static SLtt_Char_Type fb_to_fgbg (SLtt_Char_Type f, SLtt_Char_Type b)
984 {
985 SLtt_Char_Type attr = 0;
986
987 if ((f & 0xF0) == 0)
988 {
989 if (f & 0x8) attr = SLTT_BOLD_MASK;
990 f &= 0x7;
991 }
992 else f = 9;
993
994 if ((b & 0xF0) == 0)
995 {
996 if (b & 0x8) attr |= SLTT_BLINK_MASK;
997 b &= 0x7;
998 }
999 else b = 9;
1000
1001 return ((f << 8) | (b << 16) | attr);
1002 }
1003
1004 static int make_color_fgbg (char *fg, char *bg, SLtt_Char_Type *fgbg)
1005 {
1006 SLtt_Char_Type f = 0xFFFFFFFFU, b = 0xFFFFFFFFU;
1007 char *dfg, *dbg;
1008 unsigned int i;
1009
1010 if ((fg != NULL) && (*fg == 0)) fg = NULL;
1011 if ((bg != NULL) && (*bg == 0)) bg = NULL;
1012
1013 if ((fg == NULL) || (bg == NULL))
1014 {
1015 if (-1 == get_default_colors (&dfg, &dbg))
1016 return -1;
1017
1018 if (fg == NULL) fg = dfg;
1019 if (bg == NULL) bg = dbg;
1020 }
1021
1022 for (i = 0; i < MAX_COLOR_NAMES; i++)
1023 {
1024 if (strcmp(fg, Color_Defs[i].name)) continue;
1025 f = Color_Defs[i].color;
1026 break;
1027 }
1028
1029 for (i = 0; i < MAX_COLOR_NAMES; i++)
1030 {
1031 if (strcmp(bg, Color_Defs[i].name)) continue;
1032 b = Color_Defs[i].color;
1033 break;
1034 }
1035
1036 if ((f == 0xFFFFFFFFU) || (b == 0xFFFFFFFFU))
1037 return -1;
1038
1039 *fgbg = fb_to_fgbg (f, b);
1040 return 0;
1041 }
1042
1043 void SLtt_set_color (int obj, char *what, char *fg, char *bg)
1044 {
1045 SLtt_Char_Type fgbg;
1046
1047 (void) what;
1048 if ((obj < 0) || (obj >= JMAX_COLORS))
1049 return;
1050
1051 if (-1 != make_color_fgbg (fg, bg, &fgbg))
1052 SLtt_set_color_object (obj, fgbg);
1053 }
1054
1055 void SLtt_set_color_fgbg (int obj, SLtt_Char_Type f, SLtt_Char_Type b)
1056 {
1057 SLtt_set_color_object (obj, fb_to_fgbg (f, b));
1058 }
1059
1060 void SLtt_set_color_esc (int obj, char *esc)
1061 {
1062 char *cust_esc;
1063 SLtt_Char_Type fgbg = 0;
1064 int i;
1065
1066 if ((obj < 0) || (obj >= JMAX_COLORS))
1067 {
1068 return;
1069 }
1070
1071 cust_esc = Ansi_Color_Map[obj].custom_esc;
1072 if (cust_esc != NULL)
1073 {
1074 SLFREE (cust_esc);
1075 FgBg_Stats[(Ansi_Color_Map[obj].fgbg >> 8) & 0x7F] -= 1;
1076 }
1077
1078 cust_esc = (char *) SLMALLOC (strlen(esc) + 1);
1079 if (cust_esc != NULL) strcpy (cust_esc, esc);
1080
1081 Ansi_Color_Map[obj].custom_esc = cust_esc;
1082 if (cust_esc == NULL) fgbg = 0;
1083 else
1084 {
1085 /* The whole point of this is to generate a unique fgbg */
1086 for (i = 0; i < JMAX_COLORS; i++)
1087 {
1088 if (FgBg_Stats[i] == 0) fgbg = i;
1089
1090 if (obj == i) continue;
1091 if ((Ansi_Color_Map[i].custom_esc) == NULL) continue;
1092 if (!strcmp (Ansi_Color_Map[i].custom_esc, cust_esc))
1093 {
1094 fgbg = (Ansi_Color_Map[i].fgbg >> 8) & 0x7F;
1095 break;
1096 }
1097 }
1098 FgBg_Stats[fgbg] += 1;
1099 }
1100
1101 fgbg |= 0x80;
1102 Ansi_Color_Map[obj].fgbg = (fgbg | (fgbg << 8)) << 8;
1103 if (obj == 0) Color_0_Modified = 1;
1104 }
1105
1106 void SLtt_set_alt_char_set (int i)
1107 {
1108 #ifndef SLTT_TRANSP_ACS_PATCH
1109 static int last_i;
1110 #else
1111 #define last_i SLtt_ACS_Active
1112 #endif
1113 if (SLtt_Has_Alt_Charset == 0) return;
1114 if (i == last_i) return;
1115 SLtt_write_string (i ? Start_Alt_Chars_Str : End_Alt_Chars_Str );
1116 /* if (i) Current_Fgbg |= SLTT_ALTC_MASK;
1117 else Current_Fgbg &= ~SLTT_ALTC_MASK; */
1118 last_i = i;
1119 #ifdef SLTT_TRANSP_ACS_PATCH
1120 #undef last_i
1121 #endif
1122 }
1123
1124 static void write_attributes (SLtt_Char_Type fgbg)
1125 {
1126 int bg0, fg0;
1127
1128 if (Worthless_Highlight) return;
1129 if (fgbg == Current_Fgbg) return;
1130
1131 /* Before spitting out colors, fix attributes */
1132 if ((fgbg & ATTR_MASK) != (Current_Fgbg & ATTR_MASK))
1133 {
1134 if (Current_Fgbg & ATTR_MASK)
1135 {
1136 SLtt_write_string(Norm_Vid_Str);
1137 /* In case normal video turns off ALL attributes: */
1138 if (fgbg & SLTT_ALTC_MASK)
1139 Current_Fgbg &= ~SLTT_ALTC_MASK;
1140 SLtt_set_alt_char_set (0);
1141 }
1142
1143 if ((fgbg & SLTT_ALTC_MASK)
1144 != (Current_Fgbg & SLTT_ALTC_MASK))
1145 {
1146 SLtt_set_alt_char_set ((int) (fgbg & SLTT_ALTC_MASK));
1147 }
1148
1149 if (fgbg & SLTT_ULINE_MASK) SLtt_write_string (UnderLine_Vid_Str);
1150 if (fgbg & SLTT_BOLD_MASK) SLtt_bold_video ();
1151 if (fgbg & SLTT_REV_MASK) SLtt_write_string (Rev_Vid_Str);
1152 if (fgbg & SLTT_BLINK_MASK)
1153 {
1154 /* Someday Linux will have a blink mode that set high intensity
1155 * background. Lets be prepared.
1156 */
1157 if (SLtt_Blink_Mode) SLtt_write_string (Blink_Vid_Str);
1158 }
1159 }
1160
1161 if (SLtt_Use_Ansi_Colors)
1162 {
1163 fg0 = (int) GET_FG(fgbg);
1164 bg0 = (int) GET_BG(fgbg);
1165 tt_printf(Color_Escape_Sequence, fg0, bg0);
1166 }
1167 Current_Fgbg = fgbg;
1168 }
1169
1170 static int Video_Initialized;
1171
1172 void SLtt_reverse_video (int color)
1173 {
1174 SLtt_Char_Type fgbg;
1175 char *esc;
1176
1177 if (Worthless_Highlight) return;
1178 if ((color < 0) || (color >= JMAX_COLORS)) return;
1179
1180 if (Video_Initialized == 0)
1181 {
1182 if (color == JNORMAL_COLOR)
1183 {
1184 SLtt_write_string (Norm_Vid_Str);
1185 }
1186 else SLtt_write_string (Rev_Vid_Str);
1187 Current_Fgbg = 0xFFFFFFFFU;
1188 return;
1189 }
1190
1191 if (SLtt_Use_Ansi_Colors)
1192 {
1193 fgbg = Ansi_Color_Map[color].fgbg;
1194 if ((esc = Ansi_Color_Map[color].custom_esc) != NULL)
1195 {
1196 if (fgbg != Current_Fgbg)
1197 {
1198 Current_Fgbg = fgbg;
1199 SLtt_write_string (esc);
1200 return;
1201 }
1202 }
1203 }
1204 else fgbg = Ansi_Color_Map[color].mono;
1205
1206 if (fgbg == Current_Fgbg) return;
1207 write_attributes (fgbg);
1208 }
1209
1210
1211
1212
1213 void SLtt_normal_video (void)
1214 {
1215 SLtt_reverse_video(JNORMAL_COLOR);
1216 }
1217
1218 void SLtt_narrow_width (void)
1219 {
1220 SLtt_write_string("\033[?3l");
1221 }
1222
1223 void SLtt_wide_width (void)
1224 {
1225 SLtt_write_string("\033[?3h");
1226 }
1227
1228 /* Highest bit represents the character set. */
1229 #define COLOR_MASK 0x7F00
1230
1231 #define COLOR_OF(x) (((unsigned int)(x) & COLOR_MASK) >> 8)
1232 /*
1233 #define COLOR_EQS(a, b) \
1234 (Ansi_Color_Map[COLOR_OF(a)].fgbg == Ansi_Color_Map[COLOR_OF(b)].fgbg)
1235 */
1236
1237 #define COLOR_EQS(a, b) \
1238 (SLtt_Use_Ansi_Colors \
1239 ? (Ansi_Color_Map[COLOR_OF(a)].fgbg == Ansi_Color_Map[COLOR_OF(b)].fgbg)\
1240 : (Ansi_Color_Map[COLOR_OF(a)].mono == Ansi_Color_Map[COLOR_OF(b)].mono))
1241
1242
1243 #define CHAR_EQS(a, b) (((a) == (b))\
1244 || ((((a) & ~COLOR_MASK) == ((b) & ~COLOR_MASK))\
1245 && COLOR_EQS((a), (b))))
1246
1247
1248 /* The whole point of this routine is to prevent writing to the last column
1249 * and last row on terminals with automatic margins.
1250 */
1251 static void write_string_with_care (char *str)
1252 {
1253 unsigned int len;
1254
1255 if (str == NULL) return;
1256
1257 len = strlen (str);
1258 if (Automatic_Margins && (Cursor_r + 1 == SLtt_Screen_Rows))
1259 {
1260 if (len + (unsigned int) Cursor_c >= (unsigned int) SLtt_Screen_Cols)
1261 {
1262 /* For now, just do not write there. Later, something more
1263 * sophisticated will be implemented.
1264 */
1265 if (SLtt_Screen_Cols > Cursor_c)
1266 len = SLtt_Screen_Cols - Cursor_c - 1;
1267 else len = 0;
1268 }
1269 }
1270 tt_write (str, len);
1271 }
1272
1273 static void send_attr_str (unsigned short *s)
1274 {
1275 unsigned char out[256], ch, *p;
1276 register SLtt_Char_Type attr;
1277 register unsigned short sh;
1278 int color, last_color = -1;
1279
1280 p = out;
1281 while (0 != (sh = *s++))
1282 {
1283 ch = sh & 0xFF;
1284 color = ((int) sh & 0xFF00) >> 8;
1285 #ifdef SLTT_TRANSP_ACS_PATCH
1286 if (ch <= ' ' && (color & 0x80)) color &= ~0x80;
1287 #endif
1288 if (color != last_color)
1289 {
1290 if (SLtt_Use_Ansi_Colors) attr = Ansi_Color_Map[color & 0x7F].fgbg;
1291 else attr = Ansi_Color_Map[color & 0x7F].mono;
1292
1293 /* sh => color */
1294 if (color & 0x80) /* alternate char set */
1295 {
1296 if (SLtt_Use_Blink_For_ACS)
1297 {
1298 if (SLtt_Blink_Mode) attr |= SLTT_BLINK_MASK;
1299 }
1300 else attr |= SLTT_ALTC_MASK;
1301 }
1302
1303
1304 if (attr != Current_Fgbg)
1305 {
1306 #ifndef SLTT_TRANSP_ACS_PATCH
1307 if ((ch != ' ') ||
1308 /* it is a space so only consider it different if it
1309 * has different attributes.
1310 */
1311 (attr & BGALL_MASK) != (Current_Fgbg & BGALL_MASK))
1312 #endif
1313 {
1314 if (p != out)
1315 {
1316 *p = 0;
1317 write_string_with_care ((char *) out);
1318 Cursor_c += (int) (p - out);
1319 p = out;
1320 }
1321
1322 if (SLtt_Use_Ansi_Colors && (NULL != Ansi_Color_Map[color & 0x7F].custom_esc))
1323 {
1324 SLtt_write_string (Ansi_Color_Map[color & 0x7F].custom_esc);
1325 /* Just in case the custom escape sequence screwed up
1326 * the alt character set state...
1327 */
1328 if ((attr & SLTT_ALTC_MASK) != (Current_Fgbg & SLTT_ALTC_MASK))
1329 SLtt_set_alt_char_set ((int) (attr & SLTT_ALTC_MASK));
1330 Current_Fgbg = attr;
1331 }
1332 else write_attributes (attr);
1333
1334 last_color = color;
1335 }
1336 }
1337 }
1338 *p++ = ch;
1339 }
1340 *p = 0;
1341 if (p != out) write_string_with_care ((char *) out);
1342 Cursor_c += (int) (p - out);
1343 }
1344
1345 static void forward_cursor (unsigned int n, int row)
1346 {
1347 char buf[30];
1348
1349
1350 if (n <= 4)
1351 {
1352 SLtt_normal_video ();
1353 SLMEMSET (buf, ' ', n);
1354 buf[n] = 0;
1355 write_string_with_care (buf);
1356 Cursor_c += n;
1357 }
1358 else if (Curs_F_Str != NULL)
1359 {
1360 Cursor_c += n;
1361 n = tt_sprintf(buf, Curs_F_Str, (int) n, 0);
1362 tt_write(buf, n);
1363 }
1364 else SLtt_goto_rc (row, (int) (Cursor_c + n));
1365 }
1366
1367
1368 #define SPACE_CHAR (0x20 | (JNORMAL_COLOR << 8))
1369
1370 void SLtt_smart_puts(unsigned short *neww, unsigned short *oldd, int len, int row)
1371 {
1372 register unsigned short *p, *q, *qmax, *pmax, *buf;
1373 unsigned short buffer[256];
1374 unsigned int n_spaces;
1375 unsigned short *space_match, *last_buffered_match;
1376 #ifdef HP_GLITCH_CODE
1377 int handle_hp_glitch = 0;
1378 #endif
1379
1380 q = oldd; p = neww;
1381 qmax = oldd + len;
1382 pmax = p + len;
1383
1384 /* Find out where to begin --- while they match, we are ok */
1385 while (1)
1386 {
1387 if (q == qmax) return;
1388 #if SLANG_HAS_KANJI_SUPPORT
1389 if (*p & 0x80)
1390 { /* new is kanji */
1391 if ((*q & 0x80) && ((q + 1) < qmax))
1392 { /* old is also kanji */
1393 if (((0xFF & *q) != (0xFF & *p))
1394 || ((0xFF & q[1]) != (0xFF & p[1])))
1395 break; /* both kanji, but not match */
1396
1397 else
1398 { /* kanji match ! */
1399 if (!COLOR_EQS(*q, *p)) break;
1400 q++; p++;
1401 if (!COLOR_EQS(*q, *p)) break;
1402 /* really match! */
1403 q++; p++;
1404 continue;
1405 }
1406 }
1407 else break; /* old is not kanji */
1408 }
1409 else
1410 { /* new is not kanji */
1411 if (*q & 0x80) break; /* old is kanji */
1412 }
1413 #endif
1414 if (!CHAR_EQS(*q, *p)) break;
1415 q++; p++;
1416 }
1417
1418 /*position the cursor */
1419 SLtt_goto_rc (row, (int) (p - neww));
1420
1421 #ifdef HP_GLITCH_CODE
1422 if (Has_HP_Glitch)
1423 {
1424 unsigned short *qq = q;
1425 while (qq < qmax)
1426 {
1427 if (*qq & 0xFF00)
1428 {
1429 SLtt_normal_video ();
1430 SLtt_del_eol ();
1431 qmax = q;
1432 handle_hp_glitch = 1;
1433 break;
1434 }
1435 qq++;
1436 }
1437 }
1438 #endif
1439 /* Find where the last non-blank character on old/new screen is */
1440
1441 while (qmax > q)
1442 {
1443 qmax--;
1444 if (!CHAR_EQS(*qmax, SPACE_CHAR))
1445 {
1446 qmax++;
1447 break;
1448 }
1449 }
1450
1451 while (pmax > p)
1452 {
1453 pmax--;
1454 if (!CHAR_EQS(*pmax, SPACE_CHAR))
1455 {
1456 pmax++;
1457 break;
1458 }
1459 }
1460
1461 last_buffered_match = buf = buffer; /* buffer is empty */
1462
1463 #ifdef HP_GLITCH_CODE
1464 if (handle_hp_glitch)
1465 {
1466 while (p < pmax)
1467 {
1468 *buf++ = *p++;
1469 }
1470 }
1471 #endif
1472
1473 /* loop using overwrite then skip algorithm until done */
1474 while (1)
1475 {
1476 /* while they do not match and we do not hit a space, buffer them up */
1477 n_spaces = 0;
1478 while (p < pmax)
1479 {
1480 if (CHAR_EQS(*q,SPACE_CHAR) && CHAR_EQS(*p, SPACE_CHAR))
1481 {
1482 /* If *q is not a space, we would have to overwrite it.
1483 * However, if *q is a space, then while *p is also one,
1484 * we only need to skip over the blank field.
1485 */
1486 space_match = p;
1487 p++; q++;
1488 while ((p < pmax)
1489 && CHAR_EQS(*q,SPACE_CHAR)
1490 && CHAR_EQS(*p, SPACE_CHAR))
1491 {
1492 p++;
1493 q++;
1494 }
1495 n_spaces = (unsigned int) (p - space_match);
1496 break;
1497 }
1498 #if SLANG_HAS_KANJI_SUPPORT
1499 if ((*p & 0x80) && ((p + 1) < pmax))
1500 { /* new is kanji */
1501 if (*q & 0x80)
1502 { /* old is also kanji */
1503 if (((0xFF & *q) != (0xFF & *p))
1504 || ((0xFF & q[1]) != (0xFF & p[1])))
1505 {
1506 /* both kanji, but not match */
1507 *buf++ = *p++;
1508 *buf++ = *p++;
1509 q += 2;
1510 continue;
1511 }
1512 else
1513 { /* kanji match ? */
1514 if (!COLOR_EQS(*q, *p) || !COLOR_EQS(*(q+1), *(p+1)))
1515 {
1516 /* code is match ,but color is diff */
1517 *buf++ = *p++;
1518 *buf++ = *p++;
1519 continue;
1520 }
1521 /* really match ! */
1522 break;
1523 }
1524 }
1525 else
1526 { /* old is not kanji */
1527 *buf++ = *p++;
1528 *buf++ = *p++;
1529 q += 2;
1530 continue;
1531 }
1532 }
1533 else
1534 { /* new is not kanji */
1535 if (*q & 0x80)
1536 { /* old is kanji */
1537 *buf++ = *p++;
1538 q++;
1539 continue;
1540 }
1541 }
1542 #endif
1543
1544 if (CHAR_EQS(*q, *p)) break;
1545 *buf++ = *p++;
1546 q++;
1547 }
1548 *buf = 0;
1549
1550 if (buf != buffer) send_attr_str (buffer);
1551 buf = buffer;
1552
1553 if (n_spaces && (p < pmax))
1554 {
1555 forward_cursor (n_spaces, row);
1556 }
1557
1558 /* Now we overwrote what we could and cursor is placed at position
1559 * of a possible match of new and old. If this is the case, skip
1560 * some more.
1561 */
1562 #if !SLANG_HAS_KANJI_SUPPORT
1563 while ((p < pmax) && CHAR_EQS(*p, *q))
1564 {
1565 *buf++ = *p++;
1566 q++;
1567 }
1568 #else
1569 /* Kanji */
1570 while (p < pmax)
1571 {
1572 if ((*p & 0x80) && ((p + 1) < pmax))
1573 { /* new is kanji */
1574 if (*q & 0x80)
1575 { /* old is also kanji */
1576 if (((0xFF & *q) == (0xFF & *p))
1577 && ((0xFF & q[1]) == (0xFF & p[1])))
1578 {
1579 /* kanji match ? */
1580 if (!COLOR_EQS(*q, *p)
1581 || !COLOR_EQS(q[1], p[1]))
1582 break;
1583
1584 *buf++ = *p++;
1585 q++;
1586 if (p >= pmax)
1587 {
1588 *buf++ = SPACE_CHAR;
1589 p++;
1590 break;
1591 }
1592 else
1593 {
1594 *buf++ = *p++;
1595 q++;
1596 continue;
1597 }
1598 }
1599 else break; /* both kanji, but not match */
1600 }
1601 else break; /* old is not kanji */
1602 }
1603 else
1604 { /* new is not kanji */
1605 if (*q & 0x80) break; /* old is kanji */
1606 if (!CHAR_EQS(*q, *p)) break;
1607 *buf++ = *p++;
1608 q++;
1609 }
1610 }
1611 #endif
1612 last_buffered_match = buf;
1613 if (p >= pmax) break;
1614
1615 /* jump to new position is it is greater than 5 otherwise
1616 * let it sit in the buffer and output it later.
1617 */
1618 if ((int) (buf - buffer) >= 5)
1619 {
1620 forward_cursor ((unsigned int) (buf - buffer), row);
1621 last_buffered_match = buf = buffer;
1622 }
1623 }
1624
1625 if (buf != buffer)
1626 {
1627 if (q < qmax)
1628 {
1629 if ((buf == last_buffered_match)
1630 && ((int) (buf - buffer) >= 5))
1631 {
1632 forward_cursor ((unsigned int) (buf - buffer), row);
1633 }
1634 else
1635 {
1636 *buf = 0;
1637 send_attr_str (buffer);
1638 }
1639 }
1640 }
1641 if (q < qmax) SLtt_del_eol ();
1642 if (Automatic_Margins && (Cursor_c + 1 >= SLtt_Screen_Cols)) Cursor_Set = 0;
1643 }
1644
1645
1646 static void get_color_info (void)
1647 {
1648 char *fg, *bg;
1649
1650 SLtt_Use_Ansi_Colors = (NULL != getenv ("COLORTERM"));
1651
1652 if (-1 == get_default_colors (&fg, &bg))
1653 return;
1654
1655 /* Check to see if application has already set them. */
1656 if (Color_0_Modified)
1657 return;
1658
1659 SLtt_set_color (0, NULL, fg, bg);
1660 SLtt_set_color (1, NULL, bg, fg);
1661 }
1662
1663
1664 /* termcap stuff */
1665
1666 #ifdef __unix__
1667
1668 #ifndef USE_TERMCAP
1669 static char *Tbuf;
1670 static char *Tstr_Buf;
1671
1672 #define tgetstr SLtt_tigetstr
1673 #define tgetent SLtt_tigetent
1674 #define TGETNUM(x) SLtt_tigetnum((x), &Tbuf)
1675 #define TGETFLAG(x) SLtt_tigetflag((x), &Tbuf)
1676 #else
1677
1678 extern char *tgetstr(char *, char **);
1679 extern int tgetent(char *, char *);
1680 extern int tgetnum(char *);
1681 extern int tgetflag(char *);
1682 static char Tstr_Buf[1024];
1683 static char Tbuf[4096];
1684 #define TGETNUM tgetnum
1685 #define TGETFLAG tgetflag
1686 #endif
1687
1688 static char *my_tgetstr(char *what, char **p)
1689 {
1690 register char *w, *w1;
1691 char *wsave;
1692 what = tgetstr(what, p);
1693 if (what != NULL)
1694 {
1695 /* Check for AIX brain-damage */
1696 if (*what == '@')
1697 return NULL;
1698
1699 /* lose pad info --- with today's technology, term is a loser if
1700 it is really needed */
1701 while ((*what == '.') ||
1702 ((*what >= '0') && (*what <= '9'))) what++;
1703 if (*what == '*') what++;
1704
1705 /* lose terminfo padding--- looks like $<...> */
1706 w = what;
1707 while (*w) if ((*w++ == '$') && (*w == '<'))
1708 {
1709 w1 = w - 1;
1710 while (*w && (*w != '>')) w++;
1711 if (*w == 0) break;
1712 w++;
1713 wsave = w1;
1714 while ((*w1++ = *w++) != 0);
1715 w = wsave;
1716 }
1717 if (*what == 0) what = NULL;
1718 }
1719 return(what);
1720 }
1721
1722 char *SLtt_tgetstr (char *s)
1723 {
1724 #ifdef USE_TERMCAP
1725 static
1726 #endif
1727 char *p = Tstr_Buf;
1728 return my_tgetstr (s, &p);
1729 }
1730
1731 int SLtt_tgetnum (char *s)
1732 {
1733 return TGETNUM (s);
1734 }
1735 int SLtt_tgetflag (char *s)
1736 {
1737 return TGETFLAG (s);
1738 }
1739
1740
1741 static int Vt100_Like = 0;
1742
1743 void SLtt_get_terminfo (void)
1744 {
1745 char *term, *t, ch;
1746 int is_xterm;
1747 int almost_vtxxx;
1748
1749 get_color_info ();
1750
1751 if (NULL == (term = (char *) getenv("TERM")))
1752 {
1753 SLang_exit_error("TERM environment variable needs set.");
1754 }
1755
1756 Linux_Console = (!strncmp (term, "linux", 5)
1757 #ifdef linux
1758 || !strncmp(term, "con", 3)
1759 #endif
1760 );
1761
1762 t = term;
1763
1764 if (strcmp(t, "vt52") && (*t++ == 'v') && (*t++ == 't')
1765 && (ch = *t, (ch >= '1') && (ch <= '9'))) Vt100_Like = 1;
1766
1767 is_xterm = !strncmp (term, "xterm", 5);
1768 almost_vtxxx = (Vt100_Like
1769 || Linux_Console
1770 || is_xterm
1771 || !strcmp (term, "screen"));
1772
1773 #ifndef USE_TERMCAP
1774 if (NULL == (Tbuf = tgetent (term)))
1775 {
1776 char err_buf[512];
1777 if (almost_vtxxx) /* Special cases. */
1778 {
1779 int vt102 = 1;
1780 if (!strcmp (term, "vt100")) vt102 = 0;
1781 SLtt_set_term_vtxxx (&vt102);
1782 return;
1783 }
1784 sprintf (err_buf, "Unknown terminal: %s\n\
1785 Check the TERM environment variable.\n\
1786 Also make sure that the terminal is defined in the terminfo database.\n\
1787 Alternatively, set the TERMCAP environment variable to the desired\n\
1788 termcap entry.", term);
1789 SLang_exit_error(err_buf);
1790 }
1791 Tstr_Buf = Tbuf;
1792 #else /* USE_TERMCAP */
1793 if (1 != tgetent(Tbuf, term)) SLang_exit_error("Unknown terminal.");
1794 #endif /* NOT USE_TERMCAP */
1795
1796 if ((NULL == (Cls_Str = SLtt_tgetstr("cl")))
1797 || (NULL == (Curs_Pos_Str = SLtt_tgetstr("cm"))))
1798 {
1799 SLang_exit_error("Terminal not powerful enough for SLang.");
1800 }
1801
1802 if ((NULL == (Ins_Mode_Str = SLtt_tgetstr("im")))
1803 || ( NULL == (Eins_Mode_Str = SLtt_tgetstr("ei")))
1804 || ( NULL == (Del_Char_Str = SLtt_tgetstr("dc"))))
1805 SLtt_Term_Cannot_Insert = 1;
1806
1807 Visible_Bell_Str = SLtt_tgetstr ("vb");
1808 Curs_Up_Str = SLtt_tgetstr ("up");
1809 Rev_Scroll_Str = SLtt_tgetstr("sr");
1810 Del_N_Lines_Str = SLtt_tgetstr("DL");
1811 Add_N_Lines_Str = SLtt_tgetstr("AL");
1812
1813 /* Actually these are used to initialize terminals that use cursor
1814 * addressing. Hard to believe.
1815 */
1816 Term_Init_Str = SLtt_tgetstr ("ti");
1817 Term_Reset_Str = SLtt_tgetstr ("te");
1818
1819 /* If I do this for vtxxx terminals, arrow keys start sending ESC O A,
1820 * which I do not want. This is mainly for HP terminals.
1821 */
1822 if ((almost_vtxxx == 0) || SLtt_Force_Keypad_Init)
1823 {
1824 Keypad_Init_Str = SLtt_tgetstr ("ks");
1825 Keypad_Reset_Str = SLtt_tgetstr ("ke");
1826 }
1827
1828 /* Make up for defective termcap/terminfo databases */
1829 if ((Vt100_Like && (term[2] != '1'))
1830 || Linux_Console
1831 || is_xterm
1832 )
1833 {
1834 if (Del_N_Lines_Str == NULL) Del_N_Lines_Str = "\033[%dM";
1835 if (Add_N_Lines_Str == NULL) Add_N_Lines_Str = "\033[%dL";
1836 }
1837
1838 Scroll_R_Str = SLtt_tgetstr("cs");
1839
1840 SLtt_get_screen_size ();
1841
1842 if ((Scroll_R_Str == NULL)
1843 || (((NULL == Del_N_Lines_Str) || (NULL == Add_N_Lines_Str))
1844 && (NULL == Rev_Scroll_Str)))
1845 {
1846 if (is_xterm
1847 || Linux_Console
1848 )
1849 {
1850 /* Defective termcap mode!!!! */
1851 SLtt_set_term_vtxxx (NULL);
1852 }
1853 else SLtt_Term_Cannot_Scroll = 1;
1854 }
1855
1856 Del_Eol_Str = SLtt_tgetstr("ce");
1857
1858 Rev_Vid_Str = SLtt_tgetstr("mr");
1859 if (Rev_Vid_Str == NULL) Rev_Vid_Str = SLtt_tgetstr("so");
1860
1861 Bold_Vid_Str = SLtt_tgetstr("md");
1862
1863 /* Although xterm cannot blink, it does display the blinking characters
1864 * as bold ones. Some Rxvt will display the background as high intensity.
1865 */
1866 if ((NULL == (Blink_Vid_Str = SLtt_tgetstr("mb")))
1867 && is_xterm)
1868 Blink_Vid_Str = "\033[5m";
1869
1870 UnderLine_Vid_Str = SLtt_tgetstr("us");
1871
1872 Start_Alt_Chars_Str = SLtt_tgetstr ("as"); /* smacs */
1873 End_Alt_Chars_Str = SLtt_tgetstr ("ae"); /* rmacs */
1874 Enable_Alt_Char_Set = SLtt_tgetstr ("eA"); /* enacs */
1875 SLtt_Graphics_Char_Pairs = SLtt_tgetstr ("ac");
1876
1877 #ifndef NCURSES_BRAIN_DAMAGE_CONTROL
1878 # define NCURSES_BRAIN_DAMAGE_CONTROL 0
1879 #endif
1880
1881 #if NCURSES_BRAIN_DAMAGE_CONTROL
1882 if (Linux_Console)
1883 {
1884 # if 0
1885 char *lgcp = "l\332m\300k\277j\331u\264t\303v\301w\302q\304x\263n\053o\176s\137`\004a\260f\370g\361~\011,\020+\021.\031-\030h\261i\0250\333";
1886
1887 SLtt_Graphics_Char_Pairs = lgcp;
1888 Start_Alt_Chars_Str = "\033(B\033)U\016";
1889 End_Alt_Chars_Str = "\033(B\033)0\017";
1890 Enable_Alt_Char_Set = NULL;
1891 # else
1892 char *lgcp = "`\004a\261f\370g\361h\260j\331k\277l\332m\300n\305o\302q\304r\362s_t\303u\264v\301w\302x\263y\371z\372{\373|\374}\375~";
1893
1894 SLtt_Graphics_Char_Pairs = lgcp;
1895 Start_Alt_Chars_Str = "\033[11m";
1896 End_Alt_Chars_Str = "\033[10m";
1897 Enable_Alt_Char_Set = NULL;
1898 # endif
1899 }
1900 #endif
1901
1902 if (NULL == SLtt_Graphics_Char_Pairs)
1903 {
1904 /* make up for defective termcap/terminfo */
1905 if (Vt100_Like)
1906 {
1907 Start_Alt_Chars_Str = "\016";
1908 End_Alt_Chars_Str = "\017";
1909 Enable_Alt_Char_Set = "\033)0";
1910 }
1911 }
1912
1913 /* aixterm added by willi */
1914 if (is_xterm || !strncmp (term, "aixterm", 7))
1915 {
1916 Start_Alt_Chars_Str = "\016";
1917 End_Alt_Chars_Str = "\017";
1918 Enable_Alt_Char_Set = "\033(B\033)0";
1919 }
1920
1921 if ((SLtt_Graphics_Char_Pairs == NULL) &&
1922 ((Start_Alt_Chars_Str == NULL) || (End_Alt_Chars_Str == NULL)))
1923 {
1924 SLtt_Has_Alt_Charset = 0;
1925 Enable_Alt_Char_Set = NULL;
1926 }
1927 else SLtt_Has_Alt_Charset = 1;
1928
1929
1930 /* status line capabilities */
1931 if ((SLtt_Has_Status_Line == -1)
1932 && (0 != (SLtt_Has_Status_Line = TGETFLAG ("hs"))))
1933 {
1934 Disable_Status_line_Str = SLtt_tgetstr ("ds");
1935 Return_From_Status_Line_Str = SLtt_tgetstr ("fs");
1936 Goto_Status_Line_Str = SLtt_tgetstr ("ts");
1937 Status_Line_Esc_Ok = TGETFLAG("es");
1938 Num_Status_Line_Columns = TGETNUM("ws");
1939 if (Num_Status_Line_Columns < 0) Num_Status_Line_Columns = 0;
1940 }
1941
1942 if (NULL == (Norm_Vid_Str = SLtt_tgetstr("me")))
1943 {
1944 Norm_Vid_Str = SLtt_tgetstr("se");
1945 }
1946
1947 Cursor_Invisible_Str = SLtt_tgetstr("vi");
1948 Cursor_Visible_Str = SLtt_tgetstr("ve");
1949
1950 Curs_F_Str = SLtt_tgetstr("RI");
1951
1952 #if 0
1953 if (NULL != Curs_F_Str)
1954 {
1955 Len_Curs_F_Str = strlen(Curs_F_Str);
1956 }
1957 else Len_Curs_F_Str = strlen(Curs_Pos_Str);
1958 #endif
1959
1960 Automatic_Margins = TGETFLAG ("am");
1961 /* No_Move_In_Standout = !TGETFLAG ("ms"); */
1962 #ifdef HP_GLITCH_CODE
1963 Has_HP_Glitch = TGETFLAG ("xs");
1964 #else
1965 Worthless_Highlight = TGETFLAG ("xs");
1966 #endif
1967
1968 if (Worthless_Highlight == 0)
1969 { /* Magic cookie glitch */
1970 Worthless_Highlight = (TGETNUM ("sg") > 0);
1971 }
1972
1973 if (Worthless_Highlight)
1974 SLtt_Has_Alt_Charset = 0;
1975
1976 /* Check for color information in the termcap. A program should not
1977 * rely on this information being accurate.
1978 */
1979 if (SLtt_Use_Ansi_Colors == 0)
1980 {
1981 Reset_Color_String = SLtt_tgetstr ("op");
1982
1983 SLtt_Use_Ansi_Colors = ((NULL != Reset_Color_String)
1984 || (NULL != SLtt_tgetstr ("Sf"))
1985 || (NULL != SLtt_tgetstr ("Sb"))
1986 || (NULL != SLtt_tgetstr ("AF"))
1987 || (NULL != SLtt_tgetstr ("AB"))
1988 || (-1 != SLtt_tgetnum ("Co"))
1989 || (-1 != SLtt_tgetnum ("pa")));
1990
1991 }
1992
1993 #if defined(__QNX__) && defined(QNX_QANSI_SLANG_COMPAT_ACS)
1994 /*
1995 * Override the alt-char-set handling string in case of a
1996 * QNX/qansi terminal: use the "old style" strings in order
1997 * to be compatible with S-Lang without the SLTT_TRANSP_ACS_PATCH
1998 * code...
1999 */
2000 if (SLtt_Has_Alt_Charset &&
2001 strncmp(term, "qansi", 5) == 0 &&
2002 Start_Alt_Chars_Str[0] != '\016')
2003 {
2004 Start_Alt_Chars_Str = "\016"; /* smacs/as (^N) */
2005 End_Alt_Chars_Str = "\017"; /* rmacs/ae (^O) */
2006 SLtt_Graphics_Char_Pairs = /* acsc/ac */
2007 "``aaffggjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~O\141";
2008
2009 /*
2010 * it would be required to modify the sgr/sa entry also, if it
2011 * would be used (->embedded as/ae sequences)...
2012 */
2013 }
2014 #endif /* __QNX__ && QNX_QANSI_SLANG_COMPAT_ACS */
2015
2016 }
2017
2018 #endif
2019 /* Unix */
2020
2021 /* specific to vtxxx only */
2022 void SLtt_enable_cursor_keys (void)
2023 {
2024 #ifdef __unix__
2025 if (Vt100_Like)
2026 #endif
2027 SLtt_write_string("\033=\033[?1l");
2028 }
2029
2030 #ifdef VMS
2031 void SLtt_get_terminfo ()
2032 {
2033 int zero = 0;
2034
2035 get_color_info ();
2036
2037 SLtt_set_term_vtxxx(&zero);
2038 Start_Alt_Chars_Str = "\016";
2039 End_Alt_Chars_Str = "\017";
2040 SLtt_Has_Alt_Charset = 1;
2041 SLtt_Graphics_Char_Pairs = "aaffgghhjjkkllmmnnooqqssttuuvvwwxx";
2042 Enable_Alt_Char_Set = "\033(B\033)0";
2043 SLtt_get_screen_size ();
2044 }
2045 #endif
2046
2047 /* This sets term for vt102 terminals it parameter vt100 is 0. If vt100
2048 * is non-zero, set terminal appropriate for a only vt100
2049 * (no add line capability). */
2050
2051 void SLtt_set_term_vtxxx(int *vt100)
2052 {
2053 Norm_Vid_Str = "\033[m";
2054
2055 Scroll_R_Str = "\033[%i%d;%dr";
2056 Cls_Str = "\033[2J\033[H";
2057 Rev_Vid_Str = "\033[7m";
2058 Bold_Vid_Str = "\033[1m";
2059 Blink_Vid_Str = "\033[5m";
2060 UnderLine_Vid_Str = "\033[4m";
2061 Del_Eol_Str = "\033[K";
2062 Rev_Scroll_Str = "\033M";
2063 Curs_F_Str = "\033[%dC";
2064 /* Len_Curs_F_Str = 5; */
2065 Curs_Pos_Str = "\033[%i%d;%dH";
2066 if ((vt100 == NULL) || (*vt100 == 0))
2067 {
2068 Ins_Mode_Str = "\033[4h";
2069 Eins_Mode_Str = "\033[4l";
2070 Del_Char_Str = "\033[P";
2071 Del_N_Lines_Str = "\033[%dM";
2072 Add_N_Lines_Str = "\033[%dL";
2073 SLtt_Term_Cannot_Insert = 0;
2074 }
2075 else
2076 {
2077 Del_N_Lines_Str = NULL;
2078 Add_N_Lines_Str = NULL;
2079 SLtt_Term_Cannot_Insert = 1;
2080 }
2081 SLtt_Term_Cannot_Scroll = 0;
2082 /* No_Move_In_Standout = 0; */
2083 }
2084
2085 void SLtt_init_video (void)
2086 {
2087 /* send_string_to_term("\033[?6h"); */
2088 /* relative origin mode */
2089 SLtt_write_string (Term_Init_Str);
2090 SLtt_write_string (Keypad_Init_Str);
2091 SLtt_reset_scroll_region();
2092 SLtt_end_insert();
2093 SLtt_write_string (Enable_Alt_Char_Set);
2094 Video_Initialized = 1;
2095 }
2096
2097
2098 void SLtt_reset_video (void)
2099 {
2100 SLtt_goto_rc (SLtt_Screen_Rows - 1, 0);
2101 Cursor_Set = 0;
2102 SLtt_normal_video (); /* MSKermit requires this */
2103 SLtt_write_string(Norm_Vid_Str);
2104
2105 Current_Fgbg = 0xFFFFFFFFU;
2106 SLtt_set_alt_char_set (0);
2107 if (SLtt_Use_Ansi_Colors)
2108 {
2109 if (Reset_Color_String == NULL)
2110 {
2111 SLtt_Char_Type attr;
2112 if (-1 != make_color_fgbg (NULL, NULL, &attr))
2113 write_attributes (attr);
2114 else SLtt_write_string ("\033[0m\033[m");
2115 }
2116 else SLtt_write_string (Reset_Color_String);
2117 Current_Fgbg = 0xFFFFFFFFU;
2118 }
2119 SLtt_erase_line ();
2120 SLtt_write_string (Keypad_Reset_Str);
2121 SLtt_write_string (Term_Reset_Str);
2122 SLtt_flush_output ();
2123 Video_Initialized = 0;
2124 }
2125
2126 void SLtt_bold_video (void)
2127 {
2128 SLtt_write_string (Bold_Vid_Str);
2129 }
2130
2131 int SLtt_set_mouse_mode (int mode, int force)
2132 {
2133 char *term;
2134
2135 if (force == 0)
2136 {
2137 if (NULL == (term = (char *) getenv("TERM"))) return -1;
2138 if (strncmp ("xterm", term, 5))
2139 return -1;
2140 }
2141
2142 if (mode)
2143 SLtt_write_string ("\033[?9h");
2144 else
2145 SLtt_write_string ("\033[?9l");
2146
2147 return 0;
2148 }
2149
2150
2151 void SLtt_disable_status_line (void)
2152 {
2153 if (SLtt_Has_Status_Line > 0)
2154 SLtt_write_string (Disable_Status_line_Str);
2155 }
2156
2157 int SLtt_write_to_status_line (char *s, int col)
2158 {
2159 if ((SLtt_Has_Status_Line <= 0)
2160 || (Goto_Status_Line_Str == NULL)
2161 || (Return_From_Status_Line_Str == NULL))
2162 return -1;
2163
2164 tt_printf (Goto_Status_Line_Str, col, 0);
2165 SLtt_write_string (s);
2166 SLtt_write_string (Return_From_Status_Line_Str);
2167 return 0;
2168 }
2169
2170
2171 void SLtt_get_screen_size (void)
2172 {
2173 #ifdef VMS
2174 int status, code;
2175 unsigned short chan;
2176 $DESCRIPTOR(dev_dsc, "SYS$INPUT:");
2177 #endif
2178 #ifdef __os2__
2179 VIOMODEINFO vioModeInfo;
2180 #endif
2181 int r = 0, c = 0;
2182
2183 #if defined(TIOCGWINSZ) && !defined(SCO_FLAVOR)
2184 struct winsize wind_struct;
2185
2186 do
2187 {
2188 if ((ioctl(1,TIOCGWINSZ,&wind_struct) == 0)
2189 || (ioctl(0, TIOCGWINSZ, &wind_struct) == 0)
2190 || (ioctl(2, TIOCGWINSZ, &wind_struct) == 0))
2191 {
2192 c = (int) wind_struct.ws_col;
2193 r = (int) wind_struct.ws_row;
2194 break;
2195 }
2196 }
2197 while (errno == EINTR);
2198
2199 #endif
2200
2201 #ifdef VMS
2202 status = sys$assign(&dev_dsc,&chan,0,0,0);
2203 if (status & 1)
2204 {
2205 code = DVI$_DEVBUFSIZ;
2206 status = lib$getdvi(&code, &chan,0, &c, 0,0);
2207 if (!(status & 1))
2208 c = 80;
2209 code = DVI$_TT_PAGE;
2210 status = lib$getdvi(&code, &chan,0, &r, 0,0);
2211 if (!(status & 1))
2212 r = 24;
2213 sys$dassgn(chan);
2214 }
2215 #endif
2216
2217 #ifdef __os2__
2218 vioModeInfo.cb = sizeof(vioModeInfo);
2219 VioGetMode (&vioModeInfo, 0);
2220 c = vioModeInfo.col;
2221 r = vioModeInfo.row;
2222 #endif
2223
2224 if (r <= 0)
2225 {
2226 char *s = getenv ("LINES");
2227 if (s != NULL) r = atoi (s);
2228 }
2229
2230 if (c <= 0)
2231 {
2232 char *s = getenv ("COLUMNS");
2233 if (s != NULL) c = atoi (s);
2234 }
2235
2236 if ((r <= 0) || (r > 200)) r = 24;
2237 if ((c <= 0) || (c > 250)) c = 80;
2238 SLtt_Screen_Rows = r;
2239 SLtt_Screen_Cols = c;
2240 }