projects / u / mdw / putty / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ANSI remote printer support. Raw mode only.
[u/mdw/putty] / terminal.c
1 #include <windows.h>
2
3 #include <stdio.h>
4 #include <stdlib.h>
5 #include <ctype.h>
6
7 #include <time.h>
8 #include <assert.h>
9 #include "putty.h"
10 #include "tree234.h"
11
12 #define VT52_PLUS
13
14 #define CL_ANSIMIN 0x0001 /* Codes in all ANSI like terminals. */
15 #define CL_VT100 0x0002 /* VT100 */
16 #define CL_VT100AVO 0x0004 /* VT100 +AVO; 132x24 (not 132x14) & attrs */
17 #define CL_VT102 0x0008 /* VT102 */
18 #define CL_VT220 0x0010 /* VT220 */
19 #define CL_VT320 0x0020 /* VT320 */
20 #define CL_VT420 0x0040 /* VT420 */
21 #define CL_VT510 0x0080 /* VT510, NB VT510 includes ANSI */
22 #define CL_VT340TEXT 0x0100 /* VT340 extensions that appear in the VT420 */
23 #define CL_SCOANSI 0x1000 /* SCOANSI not in ANSIMIN. */
24 #define CL_ANSI 0x2000 /* ANSI ECMA-48 not in the VT100..VT420 */
25 #define CL_OTHER 0x4000 /* Others, Xterm, linux, putty, dunno, etc */
26
27 #define TM_VT100 (CL_ANSIMIN|CL_VT100)
28 #define TM_VT100AVO (TM_VT100|CL_VT100AVO)
29 #define TM_VT102 (TM_VT100AVO|CL_VT102)
30 #define TM_VT220 (TM_VT102|CL_VT220)
31 #define TM_VTXXX (TM_VT220|CL_VT340TEXT|CL_VT510|CL_VT420|CL_VT320)
32 #define TM_SCOANSI (CL_ANSIMIN|CL_SCOANSI)
33
34 #define TM_PUTTY (0xFFFF)
35
36 #define compatibility(x) \
37 if ( ((CL_##x)&compatibility_level) == 0 ) { \
38 termstate=TOPLEVEL; \
39 break; \
40 }
41 #define compatibility2(x,y) \
42 if ( ((CL_##x|CL_##y)&compatibility_level) == 0 ) { \
43 termstate=TOPLEVEL; \
44 break; \
45 }
46
47 #define has_compat(x) ( ((CL_##x)&compatibility_level) != 0 )
48
49 static int compatibility_level = TM_PUTTY;
50
51 static tree234 *scrollback; /* lines scrolled off top of screen */
52 static tree234 *screen; /* lines on primary screen */
53 static tree234 *alt_screen; /* lines on alternate screen */
54 static int disptop; /* distance scrolled back (0 or -ve) */
55
56 static unsigned long *cpos; /* cursor position (convenience) */
57
58 static unsigned long *disptext; /* buffer of text on real screen */
59 static unsigned long *dispcurs; /* location of cursor on real screen */
60 static unsigned long curstype; /* type of cursor on real screen */
61
62 #define VBELL_TIMEOUT 100 /* millisecond len of visual bell */
63
64 struct beeptime {
65 struct beeptime *next;
66 unsigned long ticks;
67 };
68 static struct beeptime *beephead, *beeptail;
69 int nbeeps;
70 int beep_overloaded;
71 long lastbeep;
72
73 #define TSIZE (sizeof(unsigned long))
74 #define fix_cpos do { cpos = lineptr(curs.y) + curs.x; } while(0)
75
76 static unsigned long curr_attr, save_attr;
77 static unsigned long erase_char = ERASE_CHAR;
78
79 typedef struct {
80 int y, x;
81 } pos;
82 #define poslt(p1,p2) ( (p1).y < (p2).y || ( (p1).y == (p2).y && (p1).x < (p2).x ) )
83 #define posle(p1,p2) ( (p1).y < (p2).y || ( (p1).y == (p2).y && (p1).x <= (p2).x ) )
84 #define poseq(p1,p2) ( (p1).y == (p2).y && (p1).x == (p2).x )
85 #define posdiff(p1,p2) ( ((p1).y - (p2).y) * (cols+1) + (p1).x - (p2).x )
86 #define incpos(p) ( (p).x == cols ? ((p).x = 0, (p).y++, 1) : ((p).x++, 0) )
87 #define decpos(p) ( (p).x == 0 ? ((p).x = cols, (p).y--, 1) : ((p).x--, 0) )
88
89 /* Product-order comparisons for rectangular block selection. */
90 #define posPlt(p1,p2) ( (p1).y <= (p2).y && (p1).x < (p2).x )
91 #define posPle(p1,p2) ( (p1).y <= (p2).y && (p1).x <= (p2).x )
92
93 static bufchain inbuf; /* terminal input buffer */
94 static pos curs; /* cursor */
95 static pos savecurs; /* saved cursor position */
96 static int marg_t, marg_b; /* scroll margins */
97 static int dec_om; /* DEC origin mode flag */
98 static int wrap, wrapnext; /* wrap flags */
99 static int insert; /* insert-mode flag */
100 static int cset; /* 0 or 1: which char set */
101 static int save_cset, save_csattr; /* saved with cursor position */
102 static int save_utf, save_wnext; /* saved with cursor position */
103 static int rvideo; /* global reverse video flag */
104 static unsigned long rvbell_startpoint;/* for ESC[?5hESC[?5l vbell */
105 static int cursor_on; /* cursor enabled flag */
106 static int reset_132; /* Flag ESC c resets to 80 cols */
107 static int use_bce; /* Use Background coloured erase */
108 static int blinker; /* When blinking is the cursor on ? */
109 static int tblinker; /* When the blinking text is on */
110 static int blink_is_real; /* Actually blink blinking text */
111 static int term_echoing; /* Does terminal want local echo? */
112 static int term_editing; /* Does terminal want local edit? */
113 static int sco_acs, save_sco_acs; /* CSI 10,11,12m -> OEM charset */
114 static int vt52_bold; /* Force bold on non-bold colours */
115 static int utf_state; /* Is there a pending UTF-8 character */
116 static int utf_char; /* and what is it so far. */
117 static int utf_size; /* The size of the UTF character. */
118 static int printing, only_printing; /* Are we doing ANSI printing? */
119 static int print_state; /* state of print-end-sequence scan */
120 static bufchain printer_buf; /* buffered data for printer */
121 static printer_job *print_job;
122
123 static int xterm_mouse; /* send mouse messages to app */
124
125 static unsigned long cset_attr[2];
126
127 /*
128 * Saved settings on the alternate screen.
129 */
130 static int alt_x, alt_y, alt_om, alt_wrap, alt_wnext, alt_ins, alt_cset, alt_sco_acs, alt_utf;
131 static int alt_t, alt_b;
132 static int alt_which;
133
134 #define ARGS_MAX 32 /* max # of esc sequence arguments */
135 #define ARG_DEFAULT 0 /* if an arg isn't specified */
136 #define def(a,d) ( (a) == ARG_DEFAULT ? (d) : (a) )
137 static int esc_args[ARGS_MAX];
138 static int esc_nargs;
139 static int esc_query;
140 #define ANSI(x,y) ((x)+((y)<<8))
141 #define ANSI_QUE(x) ANSI(x,TRUE)
142
143 #define OSC_STR_MAX 2048
144 static int osc_strlen;
145 static char osc_string[OSC_STR_MAX + 1];
146 static int osc_w;
147
148 static char id_string[1024] = "\033[?6c";
149
150 static unsigned char *tabs;
151
152 static enum {
153 TOPLEVEL,
154 SEEN_ESC,
155 SEEN_CSI,
156 SEEN_OSC,
157 SEEN_OSC_W,
158
159 DO_CTRLS,
160
161 SEEN_OSC_P,
162 OSC_STRING, OSC_MAYBE_ST,
163 VT52_ESC,
164 VT52_Y1,
165 VT52_Y2,
166 VT52_FG,
167 VT52_BG
168 } termstate;
169
170 static enum {
171 NO_SELECTION, ABOUT_TO, DRAGGING, SELECTED
172 } selstate;
173 static enum {
174 LEXICOGRAPHIC, RECTANGULAR
175 } seltype;
176 static enum {
177 SM_CHAR, SM_WORD, SM_LINE
178 } selmode;
179 static pos selstart, selend, selanchor;
180
181 static short wordness[256] = {
182 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
183 0, 0, 0, 0, 0, 0, 0, 0, /* 01 */
184 0, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
185 2, 2, 1, 1, 1, 1, 1, 1, /* 23 */
186 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
187 2, 2, 2, 1, 1, 1, 1, 2, /* 45 */
188 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
189 2, 2, 2, 1, 1, 1, 1, 1, /* 67 */
190 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
191 1, 1, 1, 1, 1, 1, 1, 1, /* 89 */
192 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
193 1, 1, 1, 1, 1, 1, 1, 1, /* AB */
194 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1,
195 2, 2, 2, 2, 2, 2, 2, 2, /* CD */
196 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1,
197 2, 2, 2, 2, 2, 2, 2, 2, /* EF */
198 };
199
200 #define sel_nl_sz (sizeof(sel_nl)/sizeof(wchar_t))
201 static wchar_t sel_nl[] = SEL_NL;
202 static wchar_t *paste_buffer = 0;
203 static int paste_len, paste_pos, paste_hold;
204
205 /*
206 * Internal prototypes.
207 */
208 static void do_paint(Context, int);
209 static void erase_lots(int, int, int);
210 static void swap_screen(int);
211 static void update_sbar(void);
212 static void deselect(void);
213 static void term_print_finish(void);
214
215 /*
216 * Resize a line to make it `cols' columns wide.
217 */
218 unsigned long *resizeline(unsigned long *line, int cols)
219 {
220 int i, oldlen;
221 unsigned long lineattrs;
222
223 if (line[0] != (unsigned long)cols) {
224 /*
225 * This line is the wrong length, which probably means it
226 * hasn't been accessed since a resize. Resize it now.
227 */
228 oldlen = line[0];
229 lineattrs = line[oldlen + 1];
230 line = srealloc(line, TSIZE * (2 + cols));
231 line[0] = cols;
232 for (i = oldlen; i < cols; i++)
233 line[i + 1] = ERASE_CHAR;
234 line[cols + 1] = lineattrs & LATTR_MODE;
235 }
236
237 return line;
238 }
239
240 /*
241 * Retrieve a line of the screen or of the scrollback, according to
242 * whether the y coordinate is non-negative or negative
243 * (respectively).
244 */
245 unsigned long *lineptr(int y, int lineno)
246 {
247 unsigned long *line, *newline;
248 tree234 *whichtree;
249 int treeindex;
250
251 if (y >= 0) {
252 whichtree = screen;
253 treeindex = y;
254 } else {
255 whichtree = scrollback;
256 treeindex = y + count234(scrollback);
257 }
258 line = index234(whichtree, treeindex);
259
260 /* We assume that we don't screw up and retrieve something out of range. */
261 assert(line != NULL);
262
263 newline = resizeline(line, cols);
264 if (newline != line) {
265 delpos234(whichtree, treeindex);
266 addpos234(whichtree, newline, treeindex);
267 line = newline;
268 }
269
270 return line + 1;
271 }
272
273 #define lineptr(x) lineptr(x,__LINE__)
274 /*
275 * Set up power-on settings for the terminal.
276 */
277 static void power_on(void)
278 {
279 curs.x = curs.y = alt_x = alt_y = savecurs.x = savecurs.y = 0;
280 alt_t = marg_t = 0;
281 if (rows != -1)
282 alt_b = marg_b = rows - 1;
283 else
284 alt_b = marg_b = 0;
285 if (cols != -1) {
286 int i;
287 for (i = 0; i < cols; i++)
288 tabs[i] = (i % 8 == 0 ? TRUE : FALSE);
289 }
290 alt_om = dec_om = cfg.dec_om;
291 alt_wnext = wrapnext = alt_ins = insert = FALSE;
292 alt_wrap = wrap = cfg.wrap_mode;
293 alt_cset = cset = 0;
294 alt_utf = utf = 0;
295 alt_sco_acs = sco_acs = 0;
296 cset_attr[0] = cset_attr[1] = ATTR_ASCII;
297 rvideo = 0;
298 in_vbell = FALSE;
299 cursor_on = 1;
300 big_cursor = 0;
301 save_attr = curr_attr = ATTR_DEFAULT;
302 term_editing = term_echoing = FALSE;
303 ldisc_send(NULL, 0, 0); /* cause ldisc to notice changes */
304 app_cursor_keys = cfg.app_cursor;
305 app_keypad_keys = cfg.app_keypad;
306 use_bce = cfg.bce;
307 blink_is_real = cfg.blinktext;
308 erase_char = ERASE_CHAR;
309 alt_which = 0;
310 term_print_finish();
311 {
312 int i;
313 for (i = 0; i < 256; i++)
314 wordness[i] = cfg.wordness[i];
315 }
316 if (screen) {
317 swap_screen(1);
318 erase_lots(FALSE, TRUE, TRUE);
319 swap_screen(0);
320 erase_lots(FALSE, TRUE, TRUE);
321 }
322 }
323
324 /*
325 * Force a screen update.
326 */
327 void term_update(void)
328 {
329 Context ctx;
330 ctx = get_ctx();
331 if (ctx) {
332 int need_sbar_update = seen_disp_event;
333 if ((seen_key_event && (cfg.scroll_on_key)) ||
334 (seen_disp_event && (cfg.scroll_on_disp))) {
335 disptop = 0; /* return to main screen */
336 seen_disp_event = seen_key_event = 0;
337 need_sbar_update = TRUE;
338 }
339 if (need_sbar_update)
340 update_sbar();
341 do_paint(ctx, TRUE);
342 sys_cursor(curs.x, curs.y - disptop);
343 free_ctx(ctx);
344 }
345 }
346
347 /*
348 * Same as power_on(), but an external function.
349 */
350 void term_pwron(void)
351 {
352 power_on();
353 fix_cpos;
354 disptop = 0;
355 deselect();
356 term_update();
357 }
358
359 /*
360 * When the user reconfigures us, we need to check the forbidden-
361 * alternate-screen config option, disable raw mouse mode if the
362 * user has disabled mouse reporting, and abandon a print job if
363 * the user has disabled printing.
364 */
365 void term_reconfig(void)
366 {
367 if (cfg.no_alt_screen)
368 swap_screen(0);
369 if (cfg.no_mouse_rep) {
370 xterm_mouse = 0;
371 set_raw_mouse_mode(0);
372 }
373 if (cfg.no_remote_charset) {
374 cset_attr[0] = cset_attr[1] = ATTR_ASCII;
375 sco_acs = alt_sco_acs = 0;
376 utf = 0;
377 }
378 if (!*cfg.printer) {
379 term_print_finish();
380 }
381 }
382
383 /*
384 * Clear the scrollback.
385 */
386 void term_clrsb(void)
387 {
388 unsigned long *line;
389 disptop = 0;
390 while ((line = delpos234(scrollback, 0)) != NULL) {
391 sfree(line);
392 }
393 update_sbar();
394 }
395
396 /*
397 * Initialise the terminal.
398 */
399 void term_init(void)
400 {
401 screen = alt_screen = scrollback = NULL;
402 disptop = 0;
403 disptext = dispcurs = NULL;
404 tabs = NULL;
405 deselect();
406 rows = cols = -1;
407 power_on();
408 beephead = beeptail = NULL;
409 nbeeps = 0;
410 lastbeep = FALSE;
411 beep_overloaded = FALSE;
412 }
413
414 /*
415 * Set up the terminal for a given size.
416 */
417 void term_size(int newrows, int newcols, int newsavelines)
418 {
419 tree234 *newalt;
420 unsigned long *newdisp, *line;
421 int i, j;
422 int sblen;
423 int save_alt_which = alt_which;
424
425 if (newrows == rows && newcols == cols && newsavelines == savelines)
426 return; /* nothing to do */
427
428 deselect();
429 swap_screen(0);
430
431 alt_t = marg_t = 0;
432 alt_b = marg_b = newrows - 1;
433
434 if (rows == -1) {
435 scrollback = newtree234(NULL);
436 screen = newtree234(NULL);
437 rows = 0;
438 }
439
440 /*
441 * Resize the screen and scrollback. We only need to shift
442 * lines around within our data structures, because lineptr()
443 * will take care of resizing each individual line if
444 * necessary. So:
445 *
446 * - If the new screen and the old screen differ in length, we
447 * must shunt some lines in from the scrollback or out to
448 * the scrollback.
449 *
450 * - If doing that fails to provide us with enough material to
451 * fill the new screen (i.e. the number of rows needed in
452 * the new screen exceeds the total number in the previous
453 * screen+scrollback), we must invent some blank lines to
454 * cover the gap.
455 *
456 * - Then, if the new scrollback length is less than the
457 * amount of scrollback we actually have, we must throw some
458 * away.
459 */
460 sblen = count234(scrollback);
461 /* Do this loop to expand the screen if newrows > rows */
462 for (i = rows; i < newrows; i++) {
463 if (sblen > 0) {
464 line = delpos234(scrollback, --sblen);
465 } else {
466 line = smalloc(TSIZE * (newcols + 2));
467 line[0] = newcols;
468 for (j = 0; j <= newcols; j++)
469 line[j + 1] = ERASE_CHAR;
470 }
471 addpos234(screen, line, 0);
472 }
473 /* Do this loop to shrink the screen if newrows < rows */
474 for (i = newrows; i < rows; i++) {
475 line = delpos234(screen, 0);
476 addpos234(scrollback, line, sblen++);
477 }
478 assert(count234(screen) == newrows);
479 while (sblen > newsavelines) {
480 line = delpos234(scrollback, 0);
481 sfree(line);
482 sblen--;
483 }
484 assert(count234(scrollback) <= newsavelines);
485 disptop = 0;
486
487 newdisp = smalloc(newrows * (newcols + 1) * TSIZE);
488 for (i = 0; i < newrows * (newcols + 1); i++)
489 newdisp[i] = ATTR_INVALID;
490 sfree(disptext);
491 disptext = newdisp;
492 dispcurs = NULL;
493
494 newalt = newtree234(NULL);
495 for (i = 0; i < newrows; i++) {
496 line = smalloc(TSIZE * (newcols + 2));
497 line[0] = newcols;
498 for (j = 0; j <= newcols; j++)
499 line[j + 1] = erase_char;
500 addpos234(newalt, line, i);
501 }
502 if (alt_screen) {
503 while (NULL != (line = delpos234(alt_screen, 0)))
504 sfree(line);
505 freetree234(alt_screen);
506 }
507 alt_screen = newalt;
508
509 tabs = srealloc(tabs, newcols * sizeof(*tabs));
510 {
511 int i;
512 for (i = (cols > 0 ? cols : 0); i < newcols; i++)
513 tabs[i] = (i % 8 == 0 ? TRUE : FALSE);
514 }
515
516 if (rows > 0)
517 curs.y += newrows - rows;
518 if (curs.y < 0)
519 curs.y = 0;
520 if (curs.y >= newrows)
521 curs.y = newrows - 1;
522 if (curs.x >= newcols)
523 curs.x = newcols - 1;
524 alt_x = alt_y = 0;
525 wrapnext = alt_wnext = FALSE;
526
527 rows = newrows;
528 cols = newcols;
529 savelines = newsavelines;
530 fix_cpos;
531
532 swap_screen(save_alt_which);
533
534 update_sbar();
535 term_update();
536 back->size();
537 }
538
539 /*
540 * Swap screens.
541 */
542 static void swap_screen(int which)
543 {
544 int t;
545 tree234 *ttr;
546
547 if (which == alt_which)
548 return;
549
550 alt_which = which;
551
552 ttr = alt_screen;
553 alt_screen = screen;
554 screen = ttr;
555 t = curs.x;
556 curs.x = alt_x;
557 alt_x = t;
558 t = curs.y;
559 curs.y = alt_y;
560 alt_y = t;
561 t = marg_t;
562 marg_t = alt_t;
563 alt_t = t;
564 t = marg_b;
565 marg_b = alt_b;
566 alt_b = t;
567 t = dec_om;
568 dec_om = alt_om;
569 alt_om = t;
570 t = wrap;
571 wrap = alt_wrap;
572 alt_wrap = t;
573 t = wrapnext;
574 wrapnext = alt_wnext;
575 alt_wnext = t;
576 t = insert;
577 insert = alt_ins;
578 alt_ins = t;
579 t = cset;
580 cset = alt_cset;
581 alt_cset = t;
582 t = utf;
583 utf = alt_utf;
584 alt_utf = t;
585 t = sco_acs;
586 sco_acs = alt_sco_acs;
587 alt_sco_acs = t;
588
589 fix_cpos;
590 }
591
592 /*
593 * Update the scroll bar.
594 */
595 static void update_sbar(void)
596 {
597 int nscroll;
598
599 nscroll = count234(scrollback);
600
601 set_sbar(nscroll + rows, nscroll + disptop, rows);
602 }
603
604 /*
605 * Check whether the region bounded by the two pointers intersects
606 * the scroll region, and de-select the on-screen selection if so.
607 */
608 static void check_selection(pos from, pos to)
609 {
610 if (poslt(from, selend) && poslt(selstart, to))
611 deselect();
612 }
613
614 /*
615 * Scroll the screen. (`lines' is +ve for scrolling forward, -ve
616 * for backward.) `sb' is TRUE if the scrolling is permitted to
617 * affect the scrollback buffer.
618 *
619 * NB this function invalidates all pointers into lines of the
620 * screen data structures. In particular, you MUST call fix_cpos
621 * after calling scroll() and before doing anything else that
622 * uses the cpos shortcut pointer.
623 */
624 static void scroll(int topline, int botline, int lines, int sb)
625 {
626 unsigned long *line, *line2;
627 int i, seltop;
628
629 if (topline != 0 || alt_which != 0)
630 sb = FALSE;
631
632 if (lines < 0) {
633 while (lines < 0) {
634 line = delpos234(screen, botline);
635 line = resizeline(line, cols);
636 for (i = 0; i < cols; i++)
637 line[i + 1] = erase_char;
638 line[cols + 1] = 0;
639 addpos234(screen, line, topline);
640
641 if (selstart.y >= topline && selstart.y <= botline) {
642 selstart.y++;
643 if (selstart.y > botline) {
644 selstart.y = botline;
645 selstart.x = 0;
646 }
647 }
648 if (selend.y >= topline && selend.y <= botline) {
649 selend.y++;
650 if (selend.y > botline) {
651 selend.y = botline;
652 selend.x = 0;
653 }
654 }
655
656 lines++;
657 }
658 } else {
659 while (lines > 0) {
660 line = delpos234(screen, topline);
661 if (sb && savelines > 0) {
662 int sblen = count234(scrollback);
663 /*
664 * We must add this line to the scrollback. We'll
665 * remove a line from the top of the scrollback to
666 * replace it, or allocate a new one if the
667 * scrollback isn't full.
668 */
669 if (sblen == savelines) {
670 sblen--, line2 = delpos234(scrollback, 0);
671 } else {
672 line2 = smalloc(TSIZE * (cols + 2));
673 line2[0] = cols;
674 }
675 addpos234(scrollback, line, sblen);
676 line = line2;
677
678 /*
679 * If the user is currently looking at part of the
680 * scrollback, and they haven't enabled any options
681 * that are going to reset the scrollback as a
682 * result of this movement, then the chances are
683 * they'd like to keep looking at the same line. So
684 * we move their viewpoint at the same rate as the
685 * scroll, at least until their viewpoint hits the
686 * top end of the scrollback buffer, at which point
687 * we don't have the choice any more.
688 *
689 * Thanks to Jan Holmen Holsten for the idea and
690 * initial implementation.
691 */
692 if (disptop > -savelines && disptop < 0)
693 disptop--;
694 }
695 line = resizeline(line, cols);
696 for (i = 0; i < cols; i++)
697 line[i + 1] = erase_char;
698 line[cols + 1] = 0;
699 addpos234(screen, line, botline);
700
701 /*
702 * If the selection endpoints move into the scrollback,
703 * we keep them moving until they hit the top. However,
704 * of course, if the line _hasn't_ moved into the
705 * scrollback then we don't do this, and cut them off
706 * at the top of the scroll region.
707 *
708 * This applies to selstart and selend (for an existing
709 * selection), and also selanchor (for one being
710 * selected as we speak).
711 */
712 seltop = sb ? -savelines : topline;
713
714 if (selstart.y >= seltop && selstart.y <= botline) {
715 selstart.y--;
716 if (selstart.y < seltop) {
717 selstart.y = seltop;
718 selstart.x = 0;
719 }
720 }
721 if (selend.y >= seltop && selend.y <= botline) {
722 selend.y--;
723 if (selend.y < seltop) {
724 selend.y = seltop;
725 selend.x = 0;
726 }
727 }
728 if (selanchor.y >= seltop && selanchor.y <= botline) {
729 selanchor.y--;
730 if (selanchor.y < seltop) {
731 selanchor.y = seltop;
732 selanchor.x = 0;
733 }
734 }
735
736 lines--;
737 }
738 }
739 }
740
741 /*
742 * Move the cursor to a given position, clipping at boundaries. We
743 * may or may not want to clip at the scroll margin: marg_clip is 0
744 * not to, 1 to disallow _passing_ the margins, and 2 to disallow
745 * even _being_ outside the margins.
746 */
747 static void move(int x, int y, int marg_clip)
748 {
749 if (x < 0)
750 x = 0;
751 if (x >= cols)
752 x = cols - 1;
753 if (marg_clip) {
754 if ((curs.y >= marg_t || marg_clip == 2) && y < marg_t)
755 y = marg_t;
756 if ((curs.y <= marg_b || marg_clip == 2) && y > marg_b)
757 y = marg_b;
758 }
759 if (y < 0)
760 y = 0;
761 if (y >= rows)
762 y = rows - 1;
763 curs.x = x;
764 curs.y = y;
765 fix_cpos;
766 wrapnext = FALSE;
767 }
768
769 /*
770 * Save or restore the cursor and SGR mode.
771 */
772 static void save_cursor(int save)
773 {
774 if (save) {
775 savecurs = curs;
776 save_attr = curr_attr;
777 save_cset = cset;
778 save_utf = utf;
779 save_wnext = wrapnext;
780 save_csattr = cset_attr[cset];
781 save_sco_acs = sco_acs;
782 } else {
783 curs = savecurs;
784 /* Make sure the window hasn't shrunk since the save */
785 if (curs.x >= cols)
786 curs.x = cols - 1;
787 if (curs.y >= rows)
788 curs.y = rows - 1;
789
790 curr_attr = save_attr;
791 cset = save_cset;
792 utf = save_utf;
793 wrapnext = save_wnext;
794 /*
795 * wrapnext might reset to False if the x position is no
796 * longer at the rightmost edge.
797 */
798 if (wrapnext && curs.x < cols-1)
799 wrapnext = FALSE;
800 cset_attr[cset] = save_csattr;
801 sco_acs = save_sco_acs;
802 fix_cpos;
803 if (use_bce)
804 erase_char = (' ' | ATTR_ASCII |
805 (curr_attr & (ATTR_FGMASK | ATTR_BGMASK)));
806 }
807 }
808
809 /*
810 * Erase a large portion of the screen: the whole screen, or the
811 * whole line, or parts thereof.
812 */
813 static void erase_lots(int line_only, int from_begin, int to_end)
814 {
815 pos start, end;
816 int erase_lattr;
817 unsigned long *ldata;
818
819 if (line_only) {
820 start.y = curs.y;
821 start.x = 0;
822 end.y = curs.y + 1;
823 end.x = 0;
824 erase_lattr = FALSE;
825 } else {
826 start.y = 0;
827 start.x = 0;
828 end.y = rows;
829 end.x = 0;
830 erase_lattr = TRUE;
831 }
832 if (!from_begin) {
833 start = curs;
834 }
835 if (!to_end) {
836 end = curs;
837 incpos(end);
838 }
839 check_selection(start, end);
840
841 /* Clear screen also forces a full window redraw, just in case. */
842 if (start.y == 0 && start.x == 0 && end.y == rows)
843 term_invalidate();
844
845 ldata = lineptr(start.y);
846 while (poslt(start, end)) {
847 if (start.x == cols && !erase_lattr)
848 ldata[start.x] &= ~LATTR_WRAPPED;
849 else
850 ldata[start.x] = erase_char;
851 if (incpos(start) && start.y < rows)
852 ldata = lineptr(start.y);
853 }
854 }
855
856 /*
857 * Insert or delete characters within the current line. n is +ve if
858 * insertion is desired, and -ve for deletion.
859 */
860 static void insch(int n)
861 {
862 int dir = (n < 0 ? -1 : +1);
863 int m;
864 pos cursplus;
865 unsigned long *ldata;
866
867 n = (n < 0 ? -n : n);
868 if (n > cols - curs.x)
869 n = cols - curs.x;
870 m = cols - curs.x - n;
871 cursplus.y = curs.y;
872 cursplus.x = curs.x + n;
873 check_selection(curs, cursplus);
874 ldata = lineptr(curs.y);
875 if (dir < 0) {
876 memmove(ldata + curs.x, ldata + curs.x + n, m * TSIZE);
877 while (n--)
878 ldata[curs.x + m++] = erase_char;
879 } else {
880 memmove(ldata + curs.x + n, ldata + curs.x, m * TSIZE);
881 while (n--)
882 ldata[curs.x + n] = erase_char;
883 }
884 }
885
886 /*
887 * Toggle terminal mode `mode' to state `state'. (`query' indicates
888 * whether the mode is a DEC private one or a normal one.)
889 */
890 static void toggle_mode(int mode, int query, int state)
891 {
892 unsigned long ticks;
893
894 if (query)
895 switch (mode) {
896 case 1: /* application cursor keys */
897 app_cursor_keys = state;
898 break;
899 case 2: /* VT52 mode */
900 vt52_mode = !state;
901 if (vt52_mode) {
902 blink_is_real = FALSE;
903 vt52_bold = FALSE;
904 } else {
905 blink_is_real = cfg.blinktext;
906 }
907 break;
908 case 3: /* 80/132 columns */
909 deselect();
910 if (!cfg.no_remote_resize)
911 request_resize(state ? 132 : 80, rows);
912 reset_132 = state;
913 break;
914 case 5: /* reverse video */
915 /*
916 * Toggle reverse video. If we receive an OFF within the
917 * visual bell timeout period after an ON, we trigger an
918 * effective visual bell, so that ESC[?5hESC[?5l will
919 * always be an actually _visible_ visual bell.
920 */
921 ticks = GetTickCount();
922 /* turn off a previous vbell to avoid inconsistencies */
923 if (ticks - vbell_startpoint >= VBELL_TIMEOUT)
924 in_vbell = FALSE;
925 if (rvideo && !state && /* we're turning it off... */
926 (ticks - rvbell_startpoint) < VBELL_TIMEOUT) { /* ...soon */
927 /* If there's no vbell timeout already, or this one lasts
928 * longer, replace vbell_timeout with ours. */
929 if (!in_vbell ||
930 (rvbell_startpoint - vbell_startpoint < VBELL_TIMEOUT))
931 vbell_startpoint = rvbell_startpoint;
932 in_vbell = TRUE; /* we may clear rvideo but we set in_vbell */
933 } else if (!rvideo && state) {
934 /* This is an ON, so we notice the time and save it. */
935 rvbell_startpoint = ticks;
936 }
937 rvideo = state;
938 seen_disp_event = TRUE;
939 if (state)
940 term_update();
941 break;
942 case 6: /* DEC origin mode */
943 dec_om = state;
944 break;
945 case 7: /* auto wrap */
946 wrap = state;
947 break;
948 case 8: /* auto key repeat */
949 repeat_off = !state;
950 break;
951 case 10: /* set local edit mode */
952 term_editing = state;
953 ldisc_send(NULL, 0, 0); /* cause ldisc to notice changes */
954 break;
955 case 25: /* enable/disable cursor */
956 compatibility2(OTHER, VT220);
957 cursor_on = state;
958 seen_disp_event = TRUE;
959 break;
960 case 47: /* alternate screen */
961 compatibility(OTHER);
962 deselect();
963 swap_screen(cfg.no_alt_screen ? 0 : state);
964 disptop = 0;
965 break;
966 case 1000: /* xterm mouse 1 */
967 xterm_mouse = state ? 1 : 0;
968 set_raw_mouse_mode(state);
969 break;
970 case 1002: /* xterm mouse 2 */
971 xterm_mouse = state ? 2 : 0;
972 set_raw_mouse_mode(state);
973 break;
974 } else
975 switch (mode) {
976 case 4: /* set insert mode */
977 compatibility(VT102);
978 insert = state;
979 break;
980 case 12: /* set echo mode */
981 term_echoing = !state;
982 ldisc_send(NULL, 0, 0); /* cause ldisc to notice changes */
983 break;
984 case 20: /* Return sends ... */
985 cr_lf_return = state;
986 break;
987 case 34: /* Make cursor BIG */
988 compatibility2(OTHER, VT220);
989 big_cursor = !state;
990 }
991 }
992
993 /*
994 * Process an OSC sequence: set window title or icon name.
995 */
996 static void do_osc(void)
997 {
998 if (osc_w) {
999 while (osc_strlen--)
1000 wordness[(unsigned char) osc_string[osc_strlen]] = esc_args[0];
1001 } else {
1002 osc_string[osc_strlen] = '\0';
1003 switch (esc_args[0]) {
1004 case 0:
1005 case 1:
1006 if (!cfg.no_remote_wintitle)
1007 set_icon(osc_string);
1008 if (esc_args[0] == 1)
1009 break;
1010 /* fall through: parameter 0 means set both */
1011 case 2:
1012 case 21:
1013 if (!cfg.no_remote_wintitle)
1014 set_title(osc_string);
1015 break;
1016 }
1017 }
1018 }
1019
1020 /*
1021 * ANSI printing routines.
1022 */
1023 static void term_print_setup(void)
1024 {
1025 bufchain_clear(&printer_buf);
1026 print_job = printer_start_job(cfg.printer);
1027 }
1028 static void term_print_flush(void)
1029 {
1030 void *data;
1031 int len;
1032 int size;
1033 while ((size = bufchain_size(&printer_buf)) > 5) {
1034 bufchain_prefix(&printer_buf, &data, &len);
1035 if (len > size-5)
1036 len = size-5;
1037 printer_job_data(print_job, data, len);
1038 bufchain_consume(&printer_buf, len);
1039 }
1040 }
1041 static void term_print_finish(void)
1042 {
1043 void *data;
1044 int len, size;
1045 char c;
1046
1047 term_print_flush();
1048 while ((size = bufchain_size(&printer_buf)) > 0) {
1049 bufchain_prefix(&printer_buf, &data, &len);
1050 c = *(char *)data;
1051 if (c == '\033' || c == '\233') {
1052 bufchain_consume(&printer_buf, size);
1053 break;
1054 } else {
1055 printer_job_data(print_job, &c, 1);
1056 bufchain_consume(&printer_buf, 1);
1057 }
1058 }
1059 printer_finish_job(print_job);
1060 print_job = NULL;
1061 printing = only_printing = FALSE;
1062 }
1063
1064 /*
1065 * Remove everything currently in `inbuf' and stick it up on the
1066 * in-memory display. There's a big state machine in here to
1067 * process escape sequences...
1068 */
1069 void term_out(void)
1070 {
1071 int c, unget;
1072 unsigned char localbuf[256], *chars;
1073 int nchars = 0;
1074
1075 unget = -1;
1076
1077 while (nchars > 0 || bufchain_size(&inbuf) > 0) {
1078 if (unget == -1) {
1079 if (nchars == 0) {
1080 void *ret;
1081 bufchain_prefix(&inbuf, &ret, &nchars);
1082 if (nchars > sizeof(localbuf))
1083 nchars = sizeof(localbuf);
1084 memcpy(localbuf, ret, nchars);
1085 bufchain_consume(&inbuf, nchars);
1086 chars = localbuf;
1087 assert(chars != NULL);
1088 }
1089 c = *chars++;
1090 nchars--;
1091
1092 /*
1093 * Optionally log the session traffic to a file. Useful for
1094 * debugging and possibly also useful for actual logging.
1095 */
1096 if (cfg.logtype == LGTYP_DEBUG)
1097 logtraffic((unsigned char) c, LGTYP_DEBUG);
1098 } else {
1099 c = unget;
1100 unget = -1;
1101 }
1102
1103 /* Note only VT220+ are 8-bit VT102 is seven bit, it shouldn't even
1104 * be able to display 8-bit characters, but I'll let that go 'cause
1105 * of i18n.
1106 */
1107
1108 /*
1109 * If we're printing, add the character to the printer
1110 * buffer.
1111 */
1112 if (printing) {
1113 char cc = c;
1114 bufchain_add(&printer_buf, &c, 1);
1115
1116 /*
1117 * If we're in print-only mode, we use a much simpler
1118 * state machine designed only to recognise the ESC[4i
1119 * termination sequence.
1120 */
1121 if (only_printing) {
1122 if (c == '\033')
1123 print_state = 1;
1124 else if (c == (unsigned char)'\233')
1125 print_state = 2;
1126 else if (c == '[' && print_state == 1)
1127 print_state = 2;
1128 else if (c == '4' && print_state == 2)
1129 print_state = 3;
1130 else if (c == 'i' && print_state == 3)
1131 print_state = 4;
1132 else
1133 print_state = 0;
1134 if (print_state == 4) {
1135 printing = only_printing = FALSE;
1136 term_print_finish();
1137 }
1138 continue;
1139 }
1140 }
1141
1142 /* First see about all those translations. */
1143 if (termstate == TOPLEVEL) {
1144 if (in_utf)
1145 switch (utf_state) {
1146 case 0:
1147 if (c < 0x80) {
1148 /* UTF-8 must be stateless so we ignore iso2022. */
1149 if (unitab_ctrl[c] != 0xFF)
1150 c = unitab_ctrl[c];
1151 else c = ((unsigned char)c) | ATTR_ASCII;
1152 break;
1153 } else if ((c & 0xe0) == 0xc0) {
1154 utf_size = utf_state = 1;
1155 utf_char = (c & 0x1f);
1156 } else if ((c & 0xf0) == 0xe0) {
1157 utf_size = utf_state = 2;
1158 utf_char = (c & 0x0f);
1159 } else if ((c & 0xf8) == 0xf0) {
1160 utf_size = utf_state = 3;
1161 utf_char = (c & 0x07);
1162 } else if ((c & 0xfc) == 0xf8) {
1163 utf_size = utf_state = 4;
1164 utf_char = (c & 0x03);
1165 } else if ((c & 0xfe) == 0xfc) {
1166 utf_size = utf_state = 5;
1167 utf_char = (c & 0x01);
1168 } else {
1169 c = UCSERR;
1170 break;
1171 }
1172 continue;
1173 case 1:
1174 case 2:
1175 case 3:
1176 case 4:
1177 case 5:
1178 if ((c & 0xC0) != 0x80) {
1179 unget = c;
1180 c = UCSERR;
1181 utf_state = 0;
1182 break;
1183 }
1184 utf_char = (utf_char << 6) | (c & 0x3f);
1185 if (--utf_state)
1186 continue;
1187
1188 c = utf_char;
1189
1190 /* Is somebody trying to be evil! */
1191 if (c < 0x80 ||
1192 (c < 0x800 && utf_size >= 2) ||
1193 (c < 0x10000 && utf_size >= 3) ||
1194 (c < 0x200000 && utf_size >= 4) ||
1195 (c < 0x4000000 && utf_size >= 5))
1196 c = UCSERR;
1197
1198 /* Unicode line separator and paragraph separator are CR-LF */
1199 if (c == 0x2028 || c == 0x2029)
1200 c = 0x85;
1201
1202 /* High controls are probably a Baaad idea too. */
1203 if (c < 0xA0)
1204 c = 0xFFFD;
1205
1206 /* The UTF-16 surrogates are not nice either. */
1207 /* The standard give the option of decoding these:
1208 * I don't want to! */
1209 if (c >= 0xD800 && c < 0xE000)
1210 c = UCSERR;
1211
1212 /* ISO 10646 characters now limited to UTF-16 range. */
1213 if (c > 0x10FFFF)
1214 c = UCSERR;
1215
1216 /* This is currently a TagPhobic application.. */
1217 if (c >= 0xE0000 && c <= 0xE007F)
1218 continue;
1219
1220 /* U+FEFF is best seen as a null. */
1221 if (c == 0xFEFF)
1222 continue;
1223 /* But U+FFFE is an error. */
1224 if (c == 0xFFFE || c == 0xFFFF)
1225 c = UCSERR;
1226
1227 /* Oops this is a 16bit implementation */
1228 if (c >= 0x10000)
1229 c = 0xFFFD;
1230 break;
1231 }
1232 /* Are we in the nasty ACS mode? Note: no sco in utf mode. */
1233 else if(sco_acs &&
1234 (c!='\033' && c!='\n' && c!='\r' && c!='\b'))
1235 {
1236 if (sco_acs == 2) c ^= 0x80;
1237 c |= ATTR_SCOACS;
1238 } else {
1239 switch (cset_attr[cset]) {
1240 /*
1241 * Linedraw characters are different from 'ESC ( B'
1242 * only for a small range. For ones outside that
1243 * range, make sure we use the same font as well as
1244 * the same encoding.
1245 */
1246 case ATTR_LINEDRW:
1247 if (unitab_ctrl[c] != 0xFF)
1248 c = unitab_ctrl[c];
1249 else
1250 c = ((unsigned char) c) | ATTR_LINEDRW;
1251 break;
1252
1253 case ATTR_GBCHR:
1254 /* If UK-ASCII, make the '#' a LineDraw Pound */
1255 if (c == '#') {
1256 c = '}' | ATTR_LINEDRW;
1257 break;
1258 }
1259 /*FALLTHROUGH*/ case ATTR_ASCII:
1260 if (unitab_ctrl[c] != 0xFF)
1261 c = unitab_ctrl[c];
1262 else
1263 c = ((unsigned char) c) | ATTR_ASCII;
1264 break;
1265 case ATTR_SCOACS:
1266 if (c>=' ') c = ((unsigned char)c) | ATTR_SCOACS;
1267 break;
1268 }
1269 }
1270 }
1271
1272 /* How about C1 controls ? */
1273 if ((c & -32) == 0x80 && termstate < DO_CTRLS && !vt52_mode &&
1274 has_compat(VT220)) {
1275 termstate = SEEN_ESC;
1276 esc_query = FALSE;
1277 c = '@' + (c & 0x1F);
1278 }
1279
1280 /* Or the GL control. */
1281 if (c == '\177' && termstate < DO_CTRLS && has_compat(OTHER)) {
1282 if (curs.x && !wrapnext)
1283 curs.x--;
1284 wrapnext = FALSE;
1285 fix_cpos;
1286 if (!cfg.no_dbackspace) /* destructive bksp might be disabled */
1287 *cpos = (' ' | curr_attr | ATTR_ASCII);
1288 } else
1289 /* Or normal C0 controls. */
1290 if ((c & -32) == 0 && termstate < DO_CTRLS) {
1291 switch (c) {
1292 case '\005': /* terminal type query */
1293 /* Strictly speaking this is VT100 but a VT100 defaults to
1294 * no response. Other terminals respond at their option.
1295 *
1296 * Don't put a CR in the default string as this tends to
1297 * upset some weird software.
1298 *
1299 * An xterm returns "xterm" (5 characters)
1300 */
1301 compatibility(ANSIMIN);
1302 {
1303 char abuf[256], *s, *d;
1304 int state = 0;
1305 for (s = cfg.answerback, d = abuf; *s; s++) {
1306 if (state) {
1307 if (*s >= 'a' && *s <= 'z')
1308 *d++ = (*s - ('a' - 1));
1309 else if ((*s >= '@' && *s <= '_') ||
1310 *s == '?' || (*s & 0x80))
1311 *d++ = ('@' ^ *s);
1312 else if (*s == '~')
1313 *d++ = '^';
1314 state = 0;
1315 } else if (*s == '^') {
1316 state = 1;
1317 } else
1318 *d++ = *s;
1319 }
1320 lpage_send(CP_ACP, abuf, d - abuf, 0);
1321 }
1322 break;
1323 case '\007':
1324 {
1325 struct beeptime *newbeep;
1326 unsigned long ticks;
1327
1328 ticks = GetTickCount();
1329
1330 if (!beep_overloaded) {
1331 newbeep = smalloc(sizeof(struct beeptime));
1332 newbeep->ticks = ticks;
1333 newbeep->next = NULL;
1334 if (!beephead)
1335 beephead = newbeep;
1336 else
1337 beeptail->next = newbeep;
1338 beeptail = newbeep;
1339 nbeeps++;
1340 }
1341
1342 /*
1343 * Throw out any beeps that happened more than
1344 * t seconds ago.
1345 */
1346 while (beephead &&
1347 beephead->ticks < ticks - cfg.bellovl_t) {
1348 struct beeptime *tmp = beephead;
1349 beephead = tmp->next;
1350 sfree(tmp);
1351 if (!beephead)
1352 beeptail = NULL;
1353 nbeeps--;
1354 }
1355
1356 if (cfg.bellovl && beep_overloaded &&
1357 ticks - lastbeep >= (unsigned)cfg.bellovl_s) {
1358 /*
1359 * If we're currently overloaded and the
1360 * last beep was more than s seconds ago,
1361 * leave overload mode.
1362 */
1363 beep_overloaded = FALSE;
1364 } else if (cfg.bellovl && !beep_overloaded &&
1365 nbeeps >= cfg.bellovl_n) {
1366 /*
1367 * Now, if we have n or more beeps
1368 * remaining in the queue, go into overload
1369 * mode.
1370 */
1371 beep_overloaded = TRUE;
1372 }
1373 lastbeep = ticks;
1374
1375 /*
1376 * Perform an actual beep if we're not overloaded.
1377 */
1378 if (!cfg.bellovl || !beep_overloaded) {
1379 beep(cfg.beep);
1380 if (cfg.beep == BELL_VISUAL) {
1381 in_vbell = TRUE;
1382 vbell_startpoint = ticks;
1383 term_update();
1384 }
1385 }
1386 disptop = 0;
1387 }
1388 break;
1389 case '\b':
1390 if (curs.x == 0 && (curs.y == 0 || wrap == 0));
1391 else if (curs.x == 0 && curs.y > 0)
1392 curs.x = cols - 1, curs.y--;
1393 else if (wrapnext)
1394 wrapnext = FALSE;
1395 else
1396 curs.x--;
1397 fix_cpos;
1398 seen_disp_event = TRUE;
1399 break;
1400 case '\016':
1401 compatibility(VT100);
1402 cset = 1;
1403 break;
1404 case '\017':
1405 compatibility(VT100);
1406 cset = 0;
1407 break;
1408 case '\033':
1409 if (vt52_mode)
1410 termstate = VT52_ESC;
1411 else {
1412 compatibility(ANSIMIN);
1413 termstate = SEEN_ESC;
1414 esc_query = FALSE;
1415 }
1416 break;
1417 case '\r':
1418 curs.x = 0;
1419 wrapnext = FALSE;
1420 fix_cpos;
1421 seen_disp_event = TRUE;
1422 paste_hold = 0;
1423 logtraffic((unsigned char) c, LGTYP_ASCII);
1424 break;
1425 case '\014':
1426 if (has_compat(SCOANSI)) {
1427 move(0, 0, 0);
1428 erase_lots(FALSE, FALSE, TRUE);
1429 disptop = 0;
1430 wrapnext = FALSE;
1431 seen_disp_event = 1;
1432 break;
1433 }
1434 case '\013':
1435 compatibility(VT100);
1436 case '\n':
1437 if (curs.y == marg_b)
1438 scroll(marg_t, marg_b, 1, TRUE);
1439 else if (curs.y < rows - 1)
1440 curs.y++;
1441 if (cfg.lfhascr)
1442 curs.x = 0;
1443 fix_cpos;
1444 wrapnext = FALSE;
1445 seen_disp_event = 1;
1446 paste_hold = 0;
1447 logtraffic((unsigned char) c, LGTYP_ASCII);
1448 break;
1449 case '\t':
1450 {
1451 pos old_curs = curs;
1452 unsigned long *ldata = lineptr(curs.y);
1453
1454 do {
1455 curs.x++;
1456 } while (curs.x < cols - 1 && !tabs[curs.x]);
1457
1458 if ((ldata[cols] & LATTR_MODE) != LATTR_NORM) {
1459 if (curs.x >= cols / 2)
1460 curs.x = cols / 2 - 1;
1461 } else {
1462 if (curs.x >= cols)
1463 curs.x = cols - 1;
1464 }
1465
1466 fix_cpos;
1467 check_selection(old_curs, curs);
1468 }
1469 seen_disp_event = TRUE;
1470 break;
1471 }
1472 } else
1473 switch (termstate) {
1474 case TOPLEVEL:
1475 /* Only graphic characters get this far, ctrls are stripped above */
1476 if (wrapnext && wrap) {
1477 cpos[1] |= LATTR_WRAPPED;
1478 if (curs.y == marg_b)
1479 scroll(marg_t, marg_b, 1, TRUE);
1480 else if (curs.y < rows - 1)
1481 curs.y++;
1482 curs.x = 0;
1483 fix_cpos;
1484 wrapnext = FALSE;
1485 }
1486 if (insert)
1487 insch(1);
1488 if (selstate != NO_SELECTION) {
1489 pos cursplus = curs;
1490 incpos(cursplus);
1491 check_selection(curs, cursplus);
1492 }
1493 if ((c & CSET_MASK) == ATTR_ASCII || (c & CSET_MASK) == 0)
1494 logtraffic((unsigned char) c, LGTYP_ASCII);
1495 {
1496 extern int wcwidth(wchar_t ucs);
1497 int width = 0;
1498 if (DIRECT_CHAR(c))
1499 width = 1;
1500 if (!width)
1501 width = wcwidth((wchar_t) c);
1502 switch (width) {
1503 case 2:
1504 *cpos++ = c | curr_attr;
1505 if (++curs.x == cols) {
1506 *cpos |= LATTR_WRAPPED;
1507 if (curs.y == marg_b)
1508 scroll(marg_t, marg_b, 1, TRUE);
1509 else if (curs.y < rows - 1)
1510 curs.y++;
1511 curs.x = 0;
1512 fix_cpos;
1513 }
1514 *cpos++ = UCSWIDE | curr_attr;
1515 break;
1516 case 1:
1517 *cpos++ = c | curr_attr;
1518 break;
1519 default:
1520 continue;
1521 }
1522 }
1523 curs.x++;
1524 if (curs.x == cols) {
1525 cpos--;
1526 curs.x--;
1527 wrapnext = TRUE;
1528 if (wrap && vt52_mode) {
1529 cpos[1] |= LATTR_WRAPPED;
1530 if (curs.y == marg_b)
1531 scroll(marg_t, marg_b, 1, TRUE);
1532 else if (curs.y < rows - 1)
1533 curs.y++;
1534 curs.x = 0;
1535 fix_cpos;
1536 wrapnext = FALSE;
1537 }
1538 }
1539 seen_disp_event = 1;
1540 break;
1541
1542 case OSC_MAYBE_ST:
1543 /*
1544 * This state is virtually identical to SEEN_ESC, with the
1545 * exception that we have an OSC sequence in the pipeline,
1546 * and _if_ we see a backslash, we process it.
1547 */
1548 if (c == '\\') {
1549 do_osc();
1550 termstate = TOPLEVEL;
1551 break;
1552 }
1553 /* else fall through */
1554 case SEEN_ESC:
1555 if (c >= ' ' && c <= '/') {
1556 if (esc_query)
1557 esc_query = -1;
1558 else
1559 esc_query = c;
1560 break;
1561 }
1562 termstate = TOPLEVEL;
1563 switch (ANSI(c, esc_query)) {
1564 case '[': /* enter CSI mode */
1565 termstate = SEEN_CSI;
1566 esc_nargs = 1;
1567 esc_args[0] = ARG_DEFAULT;
1568 esc_query = FALSE;
1569 break;
1570 case ']': /* xterm escape sequences */
1571 /* Compatibility is nasty here, xterm, linux, decterm yuk! */
1572 compatibility(OTHER);
1573 termstate = SEEN_OSC;
1574 esc_args[0] = 0;
1575 break;
1576 case '7': /* save cursor */
1577 compatibility(VT100);
1578 save_cursor(TRUE);
1579 break;
1580 case '8': /* restore cursor */
1581 compatibility(VT100);
1582 save_cursor(FALSE);
1583 seen_disp_event = TRUE;
1584 break;
1585 case '=':
1586 compatibility(VT100);
1587 app_keypad_keys = TRUE;
1588 break;
1589 case '>':
1590 compatibility(VT100);
1591 app_keypad_keys = FALSE;
1592 break;
1593 case 'D': /* exactly equivalent to LF */
1594 compatibility(VT100);
1595 if (curs.y == marg_b)
1596 scroll(marg_t, marg_b, 1, TRUE);
1597 else if (curs.y < rows - 1)
1598 curs.y++;
1599 fix_cpos;
1600 wrapnext = FALSE;
1601 seen_disp_event = TRUE;
1602 break;
1603 case 'E': /* exactly equivalent to CR-LF */
1604 compatibility(VT100);
1605 curs.x = 0;
1606 if (curs.y == marg_b)
1607 scroll(marg_t, marg_b, 1, TRUE);
1608 else if (curs.y < rows - 1)
1609 curs.y++;
1610 fix_cpos;
1611 wrapnext = FALSE;
1612 seen_disp_event = TRUE;
1613 break;
1614 case 'M': /* reverse index - backwards LF */
1615 compatibility(VT100);
1616 if (curs.y == marg_t)
1617 scroll(marg_t, marg_b, -1, TRUE);
1618 else if (curs.y > 0)
1619 curs.y--;
1620 fix_cpos;
1621 wrapnext = FALSE;
1622 seen_disp_event = TRUE;
1623 break;
1624 case 'Z': /* terminal type query */
1625 compatibility(VT100);
1626 ldisc_send(id_string, strlen(id_string), 0);
1627 break;
1628 case 'c': /* restore power-on settings */
1629 compatibility(VT100);
1630 power_on();
1631 if (reset_132) {
1632 if (!cfg.no_remote_resize)
1633 request_resize(80, rows);
1634 reset_132 = 0;
1635 }
1636 fix_cpos;
1637 disptop = 0;
1638 seen_disp_event = TRUE;
1639 break;
1640 case 'H': /* set a tab */
1641 compatibility(VT100);
1642 tabs[curs.x] = TRUE;
1643 break;
1644
1645 case ANSI('8', '#'): /* ESC # 8 fills screen with Es :-) */
1646 compatibility(VT100);
1647 {
1648 unsigned long *ldata;
1649 int i, j;
1650 pos scrtop, scrbot;
1651
1652 for (i = 0; i < rows; i++) {
1653 ldata = lineptr(i);
1654 for (j = 0; j < cols; j++)
1655 ldata[j] = ATTR_DEFAULT | 'E';
1656 ldata[cols] = 0;
1657 }
1658 disptop = 0;
1659 seen_disp_event = TRUE;
1660 scrtop.x = scrtop.y = 0;
1661 scrbot.x = 0;
1662 scrbot.y = rows;
1663 check_selection(scrtop, scrbot);
1664 }
1665 break;
1666
1667 case ANSI('3', '#'):
1668 case ANSI('4', '#'):
1669 case ANSI('5', '#'):
1670 case ANSI('6', '#'):
1671 compatibility(VT100);
1672 {
1673 unsigned long nlattr;
1674 unsigned long *ldata;
1675 switch (ANSI(c, esc_query)) {
1676 case ANSI('3', '#'):
1677 nlattr = LATTR_TOP;
1678 break;
1679 case ANSI('4', '#'):
1680 nlattr = LATTR_BOT;
1681 break;
1682 case ANSI('5', '#'):
1683 nlattr = LATTR_NORM;
1684 break;
1685 default: /* spiritually case ANSI('6', '#'): */
1686 nlattr = LATTR_WIDE;
1687 break;
1688 }
1689 ldata = lineptr(curs.y);
1690 ldata[cols] &= ~LATTR_MODE;
1691 ldata[cols] |= nlattr;
1692 }
1693 break;
1694
1695 case ANSI('A', '('):
1696 compatibility(VT100);
1697 if (!cfg.no_remote_charset)
1698 cset_attr[0] = ATTR_GBCHR;
1699 break;
1700 case ANSI('B', '('):
1701 compatibility(VT100);
1702 if (!cfg.no_remote_charset)
1703 cset_attr[0] = ATTR_ASCII;
1704 break;
1705 case ANSI('0', '('):
1706 compatibility(VT100);
1707 if (!cfg.no_remote_charset)
1708 cset_attr[0] = ATTR_LINEDRW;
1709 break;
1710 case ANSI('U', '('):
1711 compatibility(OTHER);
1712 if (!cfg.no_remote_charset)
1713 cset_attr[0] = ATTR_SCOACS;
1714 break;
1715
1716 case ANSI('A', ')'):
1717 compatibility(VT100);
1718 if (!cfg.no_remote_charset)
1719 cset_attr[1] = ATTR_GBCHR;
1720 break;
1721 case ANSI('B', ')'):
1722 compatibility(VT100);
1723 if (!cfg.no_remote_charset)
1724 cset_attr[1] = ATTR_ASCII;
1725 break;
1726 case ANSI('0', ')'):
1727 compatibility(VT100);
1728 if (!cfg.no_remote_charset)
1729 cset_attr[1] = ATTR_LINEDRW;
1730 break;
1731 case ANSI('U', ')'):
1732 compatibility(OTHER);
1733 if (!cfg.no_remote_charset)
1734 cset_attr[1] = ATTR_SCOACS;
1735 break;
1736
1737 case ANSI('8', '%'): /* Old Linux code */
1738 case ANSI('G', '%'):
1739 compatibility(OTHER);
1740 if (!cfg.no_remote_charset)
1741 utf = 1;
1742 break;
1743 case ANSI('@', '%'):
1744 compatibility(OTHER);
1745 if (!cfg.no_remote_charset)
1746 utf = 0;
1747 break;
1748 }
1749 break;
1750 case SEEN_CSI:
1751 termstate = TOPLEVEL; /* default */
1752 if (isdigit(c)) {
1753 if (esc_nargs <= ARGS_MAX) {
1754 if (esc_args[esc_nargs - 1] == ARG_DEFAULT)
1755 esc_args[esc_nargs - 1] = 0;
1756 esc_args[esc_nargs - 1] =
1757 10 * esc_args[esc_nargs - 1] + c - '0';
1758 }
1759 termstate = SEEN_CSI;
1760 } else if (c == ';') {
1761 if (++esc_nargs <= ARGS_MAX)
1762 esc_args[esc_nargs - 1] = ARG_DEFAULT;
1763 termstate = SEEN_CSI;
1764 } else if (c < '@') {
1765 if (esc_query)
1766 esc_query = -1;
1767 else if (c == '?')
1768 esc_query = TRUE;
1769 else
1770 esc_query = c;
1771 termstate = SEEN_CSI;
1772 } else
1773 switch (ANSI(c, esc_query)) {
1774 case 'A': /* move up N lines */
1775 move(curs.x, curs.y - def(esc_args[0], 1), 1);
1776 seen_disp_event = TRUE;
1777 break;
1778 case 'e': /* move down N lines */
1779 compatibility(ANSI);
1780 /* FALLTHROUGH */
1781 case 'B':
1782 move(curs.x, curs.y + def(esc_args[0], 1), 1);
1783 seen_disp_event = TRUE;
1784 break;
1785 case ANSI('c', '>'): /* report xterm version */
1786 compatibility(OTHER);
1787 /* this reports xterm version 136 so that VIM can
1788 use the drag messages from the mouse reporting */
1789 ldisc_send("\033[>0;136;0c", 11, 0);
1790 break;
1791 case 'a': /* move right N cols */
1792 compatibility(ANSI);
1793 /* FALLTHROUGH */
1794 case 'C':
1795 move(curs.x + def(esc_args[0], 1), curs.y, 1);
1796 seen_disp_event = TRUE;
1797 break;
1798 case 'D': /* move left N cols */
1799 move(curs.x - def(esc_args[0], 1), curs.y, 1);
1800 seen_disp_event = TRUE;
1801 break;
1802 case 'E': /* move down N lines and CR */
1803 compatibility(ANSI);
1804 move(0, curs.y + def(esc_args[0], 1), 1);
1805 seen_disp_event = TRUE;
1806 break;
1807 case 'F': /* move up N lines and CR */
1808 compatibility(ANSI);
1809 move(0, curs.y - def(esc_args[0], 1), 1);
1810 seen_disp_event = TRUE;
1811 break;
1812 case 'G':
1813 case '`': /* set horizontal posn */
1814 compatibility(ANSI);
1815 move(def(esc_args[0], 1) - 1, curs.y, 0);
1816 seen_disp_event = TRUE;
1817 break;
1818 case 'd': /* set vertical posn */
1819 compatibility(ANSI);
1820 move(curs.x,
1821 (dec_om ? marg_t : 0) + def(esc_args[0],
1822 1) - 1,
1823 (dec_om ? 2 : 0));
1824 seen_disp_event = TRUE;
1825 break;
1826 case 'H':
1827 case 'f': /* set horz and vert posns at once */
1828 if (esc_nargs < 2)
1829 esc_args[1] = ARG_DEFAULT;
1830 move(def(esc_args[1], 1) - 1,
1831 (dec_om ? marg_t : 0) + def(esc_args[0],
1832 1) - 1,
1833 (dec_om ? 2 : 0));
1834 seen_disp_event = TRUE;
1835 break;
1836 case 'J': /* erase screen or parts of it */
1837 {
1838 unsigned int i = def(esc_args[0], 0) + 1;
1839 if (i > 3)
1840 i = 0;
1841 erase_lots(FALSE, !!(i & 2), !!(i & 1));
1842 }
1843 disptop = 0;
1844 seen_disp_event = TRUE;
1845 break;
1846 case 'K': /* erase line or parts of it */
1847 {
1848 unsigned int i = def(esc_args[0], 0) + 1;
1849 if (i > 3)
1850 i = 0;
1851 erase_lots(TRUE, !!(i & 2), !!(i & 1));
1852 }
1853 seen_disp_event = TRUE;
1854 break;
1855 case 'L': /* insert lines */
1856 compatibility(VT102);
1857 if (curs.y <= marg_b)
1858 scroll(curs.y, marg_b, -def(esc_args[0], 1),
1859 FALSE);
1860 fix_cpos;
1861 seen_disp_event = TRUE;
1862 break;
1863 case 'M': /* delete lines */
1864 compatibility(VT102);
1865 if (curs.y <= marg_b)
1866 scroll(curs.y, marg_b, def(esc_args[0], 1),
1867 TRUE);
1868 fix_cpos;
1869 seen_disp_event = TRUE;
1870 break;
1871 case '@': /* insert chars */
1872 /* XXX VTTEST says this is vt220, vt510 manual says vt102 */
1873 compatibility(VT102);
1874 insch(def(esc_args[0], 1));
1875 seen_disp_event = TRUE;
1876 break;
1877 case 'P': /* delete chars */
1878 compatibility(VT102);
1879 insch(-def(esc_args[0], 1));
1880 seen_disp_event = TRUE;
1881 break;
1882 case 'c': /* terminal type query */
1883 compatibility(VT100);
1884 /* This is the response for a VT102 */
1885 ldisc_send(id_string, strlen(id_string), 0);
1886 break;
1887 case 'n': /* cursor position query */
1888 if (esc_args[0] == 6) {
1889 char buf[32];
1890 sprintf(buf, "\033[%d;%dR", curs.y + 1,
1891 curs.x + 1);
1892 ldisc_send(buf, strlen(buf), 0);
1893 } else if (esc_args[0] == 5) {
1894 ldisc_send("\033[0n", 4, 0);
1895 }
1896 break;
1897 case 'h': /* toggle modes to high */
1898 case ANSI_QUE('h'):
1899 compatibility(VT100);
1900 {
1901 int i;
1902 for (i = 0; i < esc_nargs; i++)
1903 toggle_mode(esc_args[i], esc_query, TRUE);
1904 }
1905 break;
1906 case 'i':
1907 case ANSI_QUE('i'):
1908 compatibility(VT100);
1909 {
1910 int i;
1911 if (esc_nargs != 1) break;
1912 if (esc_args[0] == 5 && *cfg.printer) {
1913 printing = TRUE;
1914 only_printing = !esc_query;
1915 print_state = 0;
1916 term_print_setup();
1917 } else if (esc_args[0] == 4 && printing) {
1918 printing = FALSE;
1919 only_printing = FALSE;
1920 term_print_finish();
1921 }
1922 }
1923 break;
1924 case 'l': /* toggle modes to low */
1925 case ANSI_QUE('l'):
1926 compatibility(VT100);
1927 {
1928 int i;
1929 for (i = 0; i < esc_nargs; i++)
1930 toggle_mode(esc_args[i], esc_query, FALSE);
1931 }
1932 break;
1933 case 'g': /* clear tabs */
1934 compatibility(VT100);
1935 if (esc_nargs == 1) {
1936 if (esc_args[0] == 0) {
1937 tabs[curs.x] = FALSE;
1938 } else if (esc_args[0] == 3) {
1939 int i;
1940 for (i = 0; i < cols; i++)
1941 tabs[i] = FALSE;
1942 }
1943 }
1944 break;
1945 case 'r': /* set scroll margins */
1946 compatibility(VT100);
1947 if (esc_nargs <= 2) {
1948 int top, bot;
1949 top = def(esc_args[0], 1) - 1;
1950 bot = (esc_nargs <= 1
1951 || esc_args[1] ==
1952 0 ? rows : def(esc_args[1], rows)) - 1;
1953 if (bot >= rows)
1954 bot = rows - 1;
1955 /* VTTEST Bug 9 - if region is less than 2 lines
1956 * don't change region.
1957 */
1958 if (bot - top > 0) {
1959 marg_t = top;
1960 marg_b = bot;
1961 curs.x = 0;
1962 /*
1963 * I used to think the cursor should be
1964 * placed at the top of the newly marginned
1965 * area. Apparently not: VMS TPU falls over
1966 * if so.
1967 *
1968 * Well actually it should for Origin mode - RDB
1969 */
1970 curs.y = (dec_om ? marg_t : 0);
1971 fix_cpos;
1972 seen_disp_event = TRUE;
1973 }
1974 }
1975 break;
1976 case 'm': /* set graphics rendition */
1977 {
1978 /*
1979 * A VT100 without the AVO only had one attribute, either
1980 * underline or reverse video depending on the cursor type,
1981 * this was selected by CSI 7m.
1982 *
1983 * case 2:
1984 * This is sometimes DIM, eg on the GIGI and Linux
1985 * case 8:
1986 * This is sometimes INVIS various ANSI.
1987 * case 21:
1988 * This like 22 disables BOLD, DIM and INVIS
1989 *
1990 * The ANSI colours appear on any terminal that has colour
1991 * (obviously) but the interaction between sgr0 and the
1992 * colours varies but is usually related to the background
1993 * colour erase item.
1994 * The interaction between colour attributes and the mono
1995 * ones is also very implementation dependent.
1996 *
1997 * The 39 and 49 attributes are likely to be unimplemented.
1998 */
1999 int i;
2000 for (i = 0; i < esc_nargs; i++) {
2001 switch (def(esc_args[i], 0)) {
2002 case 0: /* restore defaults */
2003 curr_attr = ATTR_DEFAULT;
2004 break;
2005 case 1: /* enable bold */
2006 compatibility(VT100AVO);
2007 curr_attr |= ATTR_BOLD;
2008 break;
2009 case 21: /* (enable double underline) */
2010 compatibility(OTHER);
2011 case 4: /* enable underline */
2012 compatibility(VT100AVO);
2013 curr_attr |= ATTR_UNDER;
2014 break;
2015 case 5: /* enable blink */
2016 compatibility(VT100AVO);
2017 curr_attr |= ATTR_BLINK;
2018 break;
2019 case 7: /* enable reverse video */
2020 curr_attr |= ATTR_REVERSE;
2021 break;
2022 case 10: /* SCO acs off */
2023 compatibility(SCOANSI);
2024 if (cfg.no_remote_charset) break;
2025 sco_acs = 0; break;
2026 case 11: /* SCO acs on */
2027 compatibility(SCOANSI);
2028 if (cfg.no_remote_charset) break;
2029 sco_acs = 1; break;
2030 case 12: /* SCO acs on flipped */
2031 compatibility(SCOANSI);
2032 if (cfg.no_remote_charset) break;
2033 sco_acs = 2; break;
2034 case 22: /* disable bold */
2035 compatibility2(OTHER, VT220);
2036 curr_attr &= ~ATTR_BOLD;
2037 break;
2038 case 24: /* disable underline */
2039 compatibility2(OTHER, VT220);
2040 curr_attr &= ~ATTR_UNDER;
2041 break;
2042 case 25: /* disable blink */
2043 compatibility2(OTHER, VT220);
2044 curr_attr &= ~ATTR_BLINK;
2045 break;
2046 case 27: /* disable reverse video */
2047 compatibility2(OTHER, VT220);
2048 curr_attr &= ~ATTR_REVERSE;
2049 break;
2050 case 30:
2051 case 31:
2052 case 32:
2053 case 33:
2054 case 34:
2055 case 35:
2056 case 36:
2057 case 37:
2058 /* foreground */
2059 curr_attr &= ~ATTR_FGMASK;
2060 curr_attr |=
2061 (esc_args[i] - 30) << ATTR_FGSHIFT;
2062 break;
2063 case 39: /* default-foreground */
2064 curr_attr &= ~ATTR_FGMASK;
2065 curr_attr |= ATTR_DEFFG;
2066 break;
2067 case 40:
2068 case 41:
2069 case 42:
2070 case 43:
2071 case 44:
2072 case 45:
2073 case 46:
2074 case 47:
2075 /* background */
2076 curr_attr &= ~ATTR_BGMASK;
2077 curr_attr |=
2078 (esc_args[i] - 40) << ATTR_BGSHIFT;
2079 break;
2080 case 49: /* default-background */
2081 curr_attr &= ~ATTR_BGMASK;
2082 curr_attr |= ATTR_DEFBG;
2083 break;
2084 }
2085 }
2086 if (use_bce)
2087 erase_char = (' ' | ATTR_ASCII |
2088 (curr_attr &
2089 (ATTR_FGMASK | ATTR_BGMASK)));
2090 }
2091 break;
2092 case 's': /* save cursor */
2093 save_cursor(TRUE);
2094 break;
2095 case 'u': /* restore cursor */
2096 save_cursor(FALSE);
2097 seen_disp_event = TRUE;
2098 break;
2099 case 't': /* set page size - ie window height */
2100 /*
2101 * VT340/VT420 sequence DECSLPP, DEC only allows values
2102 * 24/25/36/48/72/144 other emulators (eg dtterm) use
2103 * illegal values (eg first arg 1..9) for window changing
2104 * and reports.
2105 */
2106 if (esc_nargs <= 1
2107 && (esc_args[0] < 1 || esc_args[0] >= 24)) {
2108 compatibility(VT340TEXT);
2109 if (!cfg.no_remote_resize)
2110 request_resize(cols, def(esc_args[0], 24));
2111 deselect();
2112 } else if (esc_nargs >= 1 &&
2113 esc_args[0] >= 1 &&
2114 esc_args[0] < 24) {
2115 compatibility(OTHER);
2116
2117 switch (esc_args[0]) {
2118 int x, y, len;
2119 char buf[80], *p;
2120 case 1:
2121 set_iconic(FALSE);
2122 break;
2123 case 2:
2124 set_iconic(TRUE);
2125 break;
2126 case 3:
2127 if (esc_nargs >= 3) {
2128 if (!cfg.no_remote_resize)
2129 move_window(def(esc_args[1], 0),
2130 def(esc_args[2], 0));
2131 }
2132 break;
2133 case 4:
2134 /* We should resize the window to a given
2135 * size in pixels here, but currently our
2136 * resizing code isn't healthy enough to
2137 * manage it. */
2138 break;
2139 case 5:
2140 set_zorder(TRUE); /* move to top */
2141 break;
2142 case 6:
2143 set_zorder(FALSE); /* move to bottom */
2144 break;
2145 case 7:
2146 refresh_window();
2147 break;
2148 case 8:
2149 if (esc_nargs >= 3) {
2150 if (!cfg.no_remote_resize)
2151 request_resize(def(esc_args[2], cfg.width),
2152 def(esc_args[1], cfg.height));
2153 }
2154 break;
2155 case 9:
2156 if (esc_nargs >= 2)
2157 set_zoomed(esc_args[1] ? TRUE : FALSE);
2158 break;
2159 case 11:
2160 ldisc_send(is_iconic() ? "\033[1t" : "\033[2t",
2161 4, 0);
2162 break;
2163 case 13:
2164 get_window_pos(&x, &y);
2165 len = sprintf(buf, "\033[3;%d;%dt", x, y);
2166 ldisc_send(buf, len, 0);
2167 break;
2168 case 14:
2169 get_window_pixels(&x, &y);
2170 len = sprintf(buf, "\033[4;%d;%dt", x, y);
2171 ldisc_send(buf, len, 0);
2172 break;
2173 case 18:
2174 len = sprintf(buf, "\033[8;%d;%dt",
2175 rows, cols);
2176 ldisc_send(buf, len, 0);
2177 break;
2178 case 19:
2179 /*
2180 * Hmmm. Strictly speaking we
2181 * should return `the size of the
2182 * screen in characters', but
2183 * that's not easy: (a) window
2184 * furniture being what it is it's
2185 * hard to compute, and (b) in
2186 * resize-font mode maximising the
2187 * window wouldn't change the
2188 * number of characters. *shrug*. I
2189 * think we'll ignore it for the
2190 * moment and see if anyone
2191 * complains, and then ask them
2192 * what they would like it to do.
2193 */
2194 break;
2195 case 20:
2196 p = get_window_title(TRUE);
2197 len = strlen(p);
2198 ldisc_send("\033]L", 3, 0);
2199 ldisc_send(p, len, 0);
2200 ldisc_send("\033\\", 2, 0);
2201 break;
2202 case 21:
2203 p = get_window_title(FALSE);
2204 len = strlen(p);
2205 ldisc_send("\033]l", 3, 0);
2206 ldisc_send(p, len, 0);
2207 ldisc_send("\033\\", 2, 0);
2208 break;
2209 }
2210 }
2211 break;
2212 case 'S':
2213 compatibility(SCOANSI);
2214 scroll(marg_t, marg_b, def(esc_args[0], 1), TRUE);
2215 fix_cpos;
2216 wrapnext = FALSE;
2217 seen_disp_event = TRUE;
2218 break;
2219 case 'T':
2220 compatibility(SCOANSI);
2221 scroll(marg_t, marg_b, -def(esc_args[0], 1), TRUE);
2222 fix_cpos;
2223 wrapnext = FALSE;
2224 seen_disp_event = TRUE;
2225 break;
2226 case ANSI('|', '*'):
2227 /* VT420 sequence DECSNLS
2228 * Set number of lines on screen
2229 * VT420 uses VGA like hardware and can support any size in
2230 * reasonable range (24..49 AIUI) with no default specified.
2231 */
2232 compatibility(VT420);
2233 if (esc_nargs == 1 && esc_args[0] > 0) {
2234 if (!cfg.no_remote_resize)
2235 request_resize(cols, def(esc_args[0], cfg.height));
2236 deselect();
2237 }
2238 break;
2239 case ANSI('|', '$'):
2240 /* VT340/VT420 sequence DECSCPP
2241 * Set number of columns per page
2242 * Docs imply range is only 80 or 132, but I'll allow any.
2243 */
2244 compatibility(VT340TEXT);
2245 if (esc_nargs <= 1) {
2246 if (!cfg.no_remote_resize)
2247 request_resize(def(esc_args[0], cfg.width), rows);
2248 deselect();
2249 }
2250 break;
2251 case 'X': /* write N spaces w/o moving cursor */
2252 /* XXX VTTEST says this is vt220, vt510 manual says vt100 */
2253 compatibility(ANSIMIN);
2254 {
2255 int n = def(esc_args[0], 1);
2256 pos cursplus;
2257 unsigned long *p = cpos;
2258 if (n > cols - curs.x)
2259 n = cols - curs.x;
2260 cursplus = curs;
2261 cursplus.x += n;
2262 check_selection(curs, cursplus);
2263 while (n--)
2264 *p++ = erase_char;
2265 seen_disp_event = TRUE;
2266 }
2267 break;
2268 case 'x': /* report terminal characteristics */
2269 compatibility(VT100);
2270 {
2271 char buf[32];
2272 int i = def(esc_args[0], 0);
2273 if (i == 0 || i == 1) {
2274 strcpy(buf, "\033[2;1;1;112;112;1;0x");
2275 buf[2] += i;
2276 ldisc_send(buf, 20, 0);
2277 }
2278 }
2279 break;
2280 case 'Z': /* BackTab for xterm */
2281 compatibility(OTHER);
2282 {
2283 int i = def(esc_args[0], 1);
2284 pos old_curs = curs;
2285
2286 for(;i>0 && curs.x>0; i--) {
2287 do {
2288 curs.x--;
2289 } while (curs.x >0 && !tabs[curs.x]);
2290 }
2291 fix_cpos;
2292 check_selection(old_curs, curs);
2293 }
2294 break;
2295 case ANSI('L', '='):
2296 compatibility(OTHER);
2297 use_bce = (esc_args[0] <= 0);
2298 erase_char = ERASE_CHAR;
2299 if (use_bce)
2300 erase_char = (' ' | ATTR_ASCII |
2301 (curr_attr &
2302 (ATTR_FGMASK | ATTR_BGMASK)));
2303 break;
2304 case ANSI('E', '='):
2305 compatibility(OTHER);
2306 blink_is_real = (esc_args[0] >= 1);
2307 break;
2308 case ANSI('p', '"'):
2309 /* Allow the host to make this emulator a 'perfect' VT102.
2310 * This first appeared in the VT220, but we do need to get
2311 * back to PuTTY mode so I won't check it.
2312 *
2313 * The arg in 40..42,50 are a PuTTY extension.
2314 * The 2nd arg, 8bit vs 7bit is not checked.
2315 *
2316 * Setting VT102 mode should also change the Fkeys to
2317 * generate PF* codes as a real VT102 has no Fkeys.
2318 * The VT220 does this, F11..F13 become ESC,BS,LF other Fkeys
2319 * send nothing.
2320 *
2321 * Note ESC c will NOT change this!
2322 */
2323
2324 switch (esc_args[0]) {
2325 case 61:
2326 compatibility_level &= ~TM_VTXXX;
2327 compatibility_level |= TM_VT102;
2328 break;
2329 case 62:
2330 compatibility_level &= ~TM_VTXXX;
2331 compatibility_level |= TM_VT220;
2332 break;
2333
2334 default:
2335 if (esc_args[0] > 60 && esc_args[0] < 70)
2336 compatibility_level |= TM_VTXXX;
2337 break;
2338
2339 case 40:
2340 compatibility_level &= TM_VTXXX;
2341 break;
2342 case 41:
2343 compatibility_level = TM_PUTTY;
2344 break;
2345 case 42:
2346 compatibility_level = TM_SCOANSI;
2347 break;
2348
2349 case ARG_DEFAULT:
2350 compatibility_level = TM_PUTTY;
2351 break;
2352 case 50:
2353 break;
2354 }
2355
2356 /* Change the response to CSI c */
2357 if (esc_args[0] == 50) {
2358 int i;
2359 char lbuf[64];
2360 strcpy(id_string, "\033[?");
2361 for (i = 1; i < esc_nargs; i++) {
2362 if (i != 1)
2363 strcat(id_string, ";");
2364 sprintf(lbuf, "%d", esc_args[i]);
2365 strcat(id_string, lbuf);
2366 }
2367 strcat(id_string, "c");
2368 }
2369 #if 0
2370 /* Is this a good idea ?
2371 * Well we should do a soft reset at this point ...
2372 */
2373 if (!has_compat(VT420) && has_compat(VT100)) {
2374 if (!cfg.no_remote_resize) {
2375 if (reset_132)
2376 request_resize(132, 24);
2377 else
2378 request_resize(80, 24);
2379 }
2380 }
2381 #endif
2382 break;
2383 }
2384 break;
2385 case SEEN_OSC:
2386 osc_w = FALSE;
2387 switch (c) {
2388 case 'P': /* Linux palette sequence */
2389 termstate = SEEN_OSC_P;
2390 osc_strlen = 0;
2391 break;
2392 case 'R': /* Linux palette reset */
2393 palette_reset();
2394 term_invalidate();
2395 termstate = TOPLEVEL;
2396 break;
2397 case 'W': /* word-set */
2398 termstate = SEEN_OSC_W;
2399 osc_w = TRUE;
2400 break;
2401 case '0':
2402 case '1':
2403 case '2':
2404 case '3':
2405 case '4':
2406 case '5':
2407 case '6':
2408 case '7':
2409 case '8':
2410 case '9':
2411 esc_args[0] = 10 * esc_args[0] + c - '0';
2412 break;
2413 case 'L':
2414 /*
2415 * Grotty hack to support xterm and DECterm title
2416 * sequences concurrently.
2417 */
2418 if (esc_args[0] == 2) {
2419 esc_args[0] = 1;
2420 break;
2421 }
2422 /* else fall through */
2423 default:
2424 termstate = OSC_STRING;
2425 osc_strlen = 0;
2426 }
2427 break;
2428 case OSC_STRING:
2429 /*
2430 * This OSC stuff is EVIL. It takes just one character to get into
2431 * sysline mode and it's not initially obvious how to get out.
2432 * So I've added CR and LF as string aborts.
2433 * This shouldn't effect compatibility as I believe embedded
2434 * control characters are supposed to be interpreted (maybe?)
2435 * and they don't display anything useful anyway.
2436 *
2437 * -- RDB
2438 */
2439 if (c == '\n' || c == '\r') {
2440 termstate = TOPLEVEL;
2441 } else if (c == 0234 || c == '\007') {
2442 /*
2443 * These characters terminate the string; ST and BEL
2444 * terminate the sequence and trigger instant
2445 * processing of it, whereas ESC goes back to SEEN_ESC
2446 * mode unless it is followed by \, in which case it is
2447 * synonymous with ST in the first place.
2448 */
2449 do_osc();
2450 termstate = TOPLEVEL;
2451 } else if (c == '\033')
2452 termstate = OSC_MAYBE_ST;
2453 else if (osc_strlen < OSC_STR_MAX)
2454 osc_string[osc_strlen++] = c;
2455 break;
2456 case SEEN_OSC_P:
2457 {
2458 int max = (osc_strlen == 0 ? 21 : 16);
2459 int val;
2460 if (c >= '0' && c <= '9')
2461 val = c - '0';
2462 else if (c >= 'A' && c <= 'A' + max - 10)
2463 val = c - 'A' + 10;
2464 else if (c >= 'a' && c <= 'a' + max - 10)
2465 val = c - 'a' + 10;
2466 else {
2467 termstate = TOPLEVEL;
2468 break;
2469 }
2470 osc_string[osc_strlen++] = val;
2471 if (osc_strlen >= 7) {
2472 palette_set(osc_string[0],
2473 osc_string[1] * 16 + osc_string[2],
2474 osc_string[3] * 16 + osc_string[4],
2475 osc_string[5] * 16 + osc_string[6]);
2476 term_invalidate();
2477 termstate = TOPLEVEL;
2478 }
2479 }
2480 break;
2481 case SEEN_OSC_W:
2482 switch (c) {
2483 case '0':
2484 case '1':
2485 case '2':
2486 case '3':
2487 case '4':
2488 case '5':
2489 case '6':
2490 case '7':
2491 case '8':
2492 case '9':
2493 esc_args[0] = 10 * esc_args[0] + c - '0';
2494 break;
2495 default:
2496 termstate = OSC_STRING;
2497 osc_strlen = 0;
2498 }
2499 break;
2500 case VT52_ESC:
2501 termstate = TOPLEVEL;
2502 seen_disp_event = TRUE;
2503 switch (c) {
2504 case 'A':
2505 move(curs.x, curs.y - 1, 1);
2506 break;
2507 case 'B':
2508 move(curs.x, curs.y + 1, 1);
2509 break;
2510 case 'C':
2511 move(curs.x + 1, curs.y, 1);
2512 break;
2513 case 'D':
2514 move(curs.x - 1, curs.y, 1);
2515 break;
2516 /*
2517 * From the VT100 Manual
2518 * NOTE: The special graphics characters in the VT100
2519 * are different from those in the VT52
2520 *
2521 * From VT102 manual:
2522 * 137 _ Blank - Same
2523 * 140 ` Reserved - Humm.
2524 * 141 a Solid rectangle - Similar
2525 * 142 b 1/ - Top half of fraction for the
2526 * 143 c 3/ - subscript numbers below.
2527 * 144 d 5/
2528 * 145 e 7/
2529 * 146 f Degrees - Same
2530 * 147 g Plus or minus - Same
2531 * 150 h Right arrow
2532 * 151 i Ellipsis (dots)
2533 * 152 j Divide by
2534 * 153 k Down arrow
2535 * 154 l Bar at scan 0
2536 * 155 m Bar at scan 1
2537 * 156 n Bar at scan 2
2538 * 157 o Bar at scan 3 - Similar
2539 * 160 p Bar at scan 4 - Similar
2540 * 161 q Bar at scan 5 - Similar
2541 * 162 r Bar at scan 6 - Same
2542 * 163 s Bar at scan 7 - Similar
2543 * 164 t Subscript 0
2544 * 165 u Subscript 1
2545 * 166 v Subscript 2
2546 * 167 w Subscript 3
2547 * 170 x Subscript 4
2548 * 171 y Subscript 5
2549 * 172 z Subscript 6
2550 * 173 { Subscript 7
2551 * 174 | Subscript 8
2552 * 175 } Subscript 9
2553 * 176 ~ Paragraph
2554 *
2555 */
2556 case 'F':
2557 cset_attr[cset = 0] = ATTR_LINEDRW;
2558 break;
2559 case 'G':
2560 cset_attr[cset = 0] = ATTR_ASCII;
2561 break;
2562 case 'H':
2563 move(0, 0, 0);
2564 break;
2565 case 'I':
2566 if (curs.y == 0)
2567 scroll(0, rows - 1, -1, TRUE);
2568 else if (curs.y > 0)
2569 curs.y--;
2570 fix_cpos;
2571 wrapnext = FALSE;
2572 break;
2573 case 'J':
2574 erase_lots(FALSE, FALSE, TRUE);
2575 disptop = 0;
2576 break;
2577 case 'K':
2578 erase_lots(TRUE, FALSE, TRUE);
2579 break;
2580 #if 0
2581 case 'V':
2582 /* XXX Print cursor line */
2583 break;
2584 case 'W':
2585 /* XXX Start controller mode */
2586 break;
2587 case 'X':
2588 /* XXX Stop controller mode */
2589 break;
2590 #endif
2591 case 'Y':
2592 termstate = VT52_Y1;
2593 break;
2594 case 'Z':
2595 ldisc_send("\033/Z", 3, 0);
2596 break;
2597 case '=':
2598 app_keypad_keys = TRUE;
2599 break;
2600 case '>':
2601 app_keypad_keys = FALSE;
2602 break;
2603 case '<':
2604 /* XXX This should switch to VT100 mode not current or default
2605 * VT mode. But this will only have effect in a VT220+
2606 * emulation.
2607 */
2608 vt52_mode = FALSE;
2609 blink_is_real = cfg.blinktext;
2610 break;
2611 #if 0
2612 case '^':
2613 /* XXX Enter auto print mode */
2614 break;
2615 case '_':
2616 /* XXX Exit auto print mode */
2617 break;
2618 case ']':
2619 /* XXX Print screen */
2620 break;
2621 #endif
2622
2623 #ifdef VT52_PLUS
2624 case 'E':
2625 /* compatibility(ATARI) */
2626 move(0, 0, 0);
2627 erase_lots(FALSE, FALSE, TRUE);
2628 disptop = 0;
2629 break;
2630 case 'L':
2631 /* compatibility(ATARI) */
2632 if (curs.y <= marg_b)
2633 scroll(curs.y, marg_b, -1, FALSE);
2634 break;
2635 case 'M':
2636 /* compatibility(ATARI) */
2637 if (curs.y <= marg_b)
2638 scroll(curs.y, marg_b, 1, TRUE);
2639 break;
2640 case 'b':
2641 /* compatibility(ATARI) */
2642 termstate = VT52_FG;
2643 break;
2644 case 'c':
2645 /* compatibility(ATARI) */
2646 termstate = VT52_BG;
2647 break;
2648 case 'd':
2649 /* compatibility(ATARI) */
2650 erase_lots(FALSE, TRUE, FALSE);
2651 disptop = 0;
2652 break;
2653 case 'e':
2654 /* compatibility(ATARI) */
2655 cursor_on = TRUE;
2656 break;
2657 case 'f':
2658 /* compatibility(ATARI) */
2659 cursor_on = FALSE;
2660 break;
2661 /* case 'j': Save cursor position - broken on ST */
2662 /* case 'k': Restore cursor position */
2663 case 'l':
2664 /* compatibility(ATARI) */
2665 erase_lots(TRUE, TRUE, TRUE);
2666 curs.x = 0;
2667 wrapnext = FALSE;
2668 fix_cpos;
2669 break;
2670 case 'o':
2671 /* compatibility(ATARI) */
2672 erase_lots(TRUE, TRUE, FALSE);
2673 break;
2674 case 'p':
2675 /* compatibility(ATARI) */
2676 curr_attr |= ATTR_REVERSE;
2677 break;
2678 case 'q':
2679 /* compatibility(ATARI) */
2680 curr_attr &= ~ATTR_REVERSE;
2681 break;
2682 case 'v': /* wrap Autowrap on - Wyse style */
2683 /* compatibility(ATARI) */
2684 wrap = 1;
2685 break;
2686 case 'w': /* Autowrap off */
2687 /* compatibility(ATARI) */
2688 wrap = 0;
2689 break;
2690
2691 case 'R':
2692 /* compatibility(OTHER) */
2693 vt52_bold = FALSE;
2694 curr_attr = ATTR_DEFAULT;
2695 if (use_bce)
2696 erase_char = (' ' | ATTR_ASCII |
2697 (curr_attr &
2698 (ATTR_FGMASK | ATTR_BGMASK)));
2699 break;
2700 case 'S':
2701 /* compatibility(VI50) */
2702 curr_attr |= ATTR_UNDER;
2703 break;
2704 case 'W':
2705 /* compatibility(VI50) */
2706 curr_attr &= ~ATTR_UNDER;
2707 break;
2708 case 'U':
2709 /* compatibility(VI50) */
2710 vt52_bold = TRUE;
2711 curr_attr |= ATTR_BOLD;
2712 break;
2713 case 'T':
2714 /* compatibility(VI50) */
2715 vt52_bold = FALSE;
2716 curr_attr &= ~ATTR_BOLD;
2717 break;
2718 #endif
2719 }
2720 break;
2721 case VT52_Y1:
2722 termstate = VT52_Y2;
2723 move(curs.x, c - ' ', 0);
2724 break;
2725 case VT52_Y2:
2726 termstate = TOPLEVEL;
2727 move(c - ' ', curs.y, 0);
2728 break;
2729
2730 #ifdef VT52_PLUS
2731 case VT52_FG:
2732 termstate = TOPLEVEL;
2733 curr_attr &= ~ATTR_FGMASK;
2734 curr_attr &= ~ATTR_BOLD;
2735 curr_attr |= (c & 0x7) << ATTR_FGSHIFT;
2736 if ((c & 0x8) || vt52_bold)
2737 curr_attr |= ATTR_BOLD;
2738
2739 if (use_bce)
2740 erase_char = (' ' | ATTR_ASCII |
2741 (curr_attr & (ATTR_FGMASK | ATTR_BGMASK)));
2742 break;
2743 case VT52_BG:
2744 termstate = TOPLEVEL;
2745 curr_attr &= ~ATTR_BGMASK;
2746 curr_attr &= ~ATTR_BLINK;
2747 curr_attr |= (c & 0x7) << ATTR_BGSHIFT;
2748
2749 /* Note: bold background */
2750 if (c & 0x8)
2751 curr_attr |= ATTR_BLINK;
2752
2753 if (use_bce)
2754 erase_char = (' ' | ATTR_ASCII |
2755 (curr_attr & (ATTR_FGMASK | ATTR_BGMASK)));
2756 break;
2757 #endif
2758 default: break; /* placate gcc warning about enum use */
2759 }
2760 if (selstate != NO_SELECTION) {
2761 pos cursplus = curs;
2762 incpos(cursplus);
2763 check_selection(curs, cursplus);
2764 }
2765 }
2766
2767 term_print_flush();
2768 }
2769
2770 #if 0
2771 /*
2772 * Compare two lines to determine whether they are sufficiently
2773 * alike to scroll-optimise one to the other. Return the degree of
2774 * similarity.
2775 */
2776 static int linecmp(unsigned long *a, unsigned long *b)
2777 {
2778 int i, n;
2779
2780 for (i = n = 0; i < cols; i++)
2781 n += (*a++ == *b++);
2782 return n;
2783 }
2784 #endif
2785
2786 /*
2787 * Given a context, update the window. Out of paranoia, we don't
2788 * allow WM_PAINT responses to do scrolling optimisations.
2789 */
2790 static void do_paint(Context ctx, int may_optimise)
2791 {
2792 int i, j, our_curs_y;
2793 unsigned long rv, cursor;
2794 pos scrpos;
2795 char ch[1024];
2796 long cursor_background = ERASE_CHAR;
2797 unsigned long ticks;
2798
2799 /*
2800 * Check the visual bell state.
2801 */
2802 if (in_vbell) {
2803 ticks = GetTickCount();
2804 if (ticks - vbell_startpoint >= VBELL_TIMEOUT)
2805 in_vbell = FALSE;
2806 }
2807
2808 rv = (!rvideo ^ !in_vbell ? ATTR_REVERSE : 0);
2809
2810 /* Depends on:
2811 * screen array, disptop, scrtop,
2812 * selection, rv,
2813 * cfg.blinkpc, blink_is_real, tblinker,
2814 * curs.y, curs.x, blinker, cfg.blink_cur, cursor_on, has_focus, wrapnext
2815 */
2816
2817 /* Has the cursor position or type changed ? */
2818 if (cursor_on) {
2819 if (has_focus) {
2820 if (blinker || !cfg.blink_cur)
2821 cursor = TATTR_ACTCURS;
2822 else
2823 cursor = 0;
2824 } else
2825 cursor = TATTR_PASCURS;
2826 if (wrapnext)
2827 cursor |= TATTR_RIGHTCURS;
2828 } else
2829 cursor = 0;
2830 our_curs_y = curs.y - disptop;
2831
2832 if (dispcurs && (curstype != cursor ||
2833 dispcurs !=
2834 disptext + our_curs_y * (cols + 1) + curs.x)) {
2835 if (dispcurs > disptext &&
2836 (*dispcurs & (CHAR_MASK | CSET_MASK)) == UCSWIDE)
2837 dispcurs[-1] |= ATTR_INVALID;
2838 if ( (dispcurs[1] & (CHAR_MASK | CSET_MASK)) == UCSWIDE)
2839 dispcurs[1] |= ATTR_INVALID;
2840 *dispcurs |= ATTR_INVALID;
2841 curstype = 0;
2842 }
2843 dispcurs = NULL;
2844
2845 /* The normal screen data */
2846 for (i = 0; i < rows; i++) {
2847 unsigned long *ldata;
2848 int lattr;
2849 int idx, dirty_line, dirty_run, selected;
2850 unsigned long attr = 0;
2851 int updated_line = 0;
2852 int start = 0;
2853 int ccount = 0;
2854 int last_run_dirty = 0;
2855
2856 scrpos.y = i + disptop;
2857 ldata = lineptr(scrpos.y);
2858 lattr = (ldata[cols] & LATTR_MODE);
2859
2860 idx = i * (cols + 1);
2861 dirty_run = dirty_line = (ldata[cols] != disptext[idx + cols]);
2862 disptext[idx + cols] = ldata[cols];
2863
2864 for (j = 0; j < cols; j++, idx++) {
2865 unsigned long tattr, tchar;
2866 unsigned long *d = ldata + j;
2867 int break_run;
2868 scrpos.x = j;
2869
2870 tchar = (*d & (CHAR_MASK | CSET_MASK));
2871 tattr = (*d & (ATTR_MASK ^ CSET_MASK));
2872 switch (tchar & CSET_MASK) {
2873 case ATTR_ASCII:
2874 tchar = unitab_line[tchar & 0xFF];
2875 break;
2876 case ATTR_LINEDRW:
2877 tchar = unitab_xterm[tchar & 0xFF];
2878 break;
2879 case ATTR_SCOACS:
2880 tchar = unitab_scoacs[tchar&0xFF];
2881 break;
2882 }
2883 tattr |= (tchar & CSET_MASK);
2884 tchar &= CHAR_MASK;
2885 if ((d[1] & (CHAR_MASK | CSET_MASK)) == UCSWIDE)
2886 tattr |= ATTR_WIDE;
2887
2888 /* Video reversing things */
2889 if (seltype == LEXICOGRAPHIC)
2890 selected = posle(selstart, scrpos) && poslt(scrpos, selend);
2891 else
2892 selected = posPle(selstart, scrpos) && posPlt(scrpos, selend);
2893 tattr = (tattr ^ rv
2894 ^ (selected ? ATTR_REVERSE : 0));
2895
2896 /* 'Real' blinking ? */
2897 if (blink_is_real && (tattr & ATTR_BLINK)) {
2898 if (has_focus && tblinker) {
2899 tchar = ' ';
2900 tattr &= ~CSET_MASK;
2901 tattr |= ATTR_ACP;
2902 }
2903 tattr &= ~ATTR_BLINK;
2904 }
2905
2906 /*
2907 * Check the font we'll _probably_ be using to see if
2908 * the character is wide when we don't want it to be.
2909 */
2910 if ((tchar | tattr) != (disptext[idx]& ~ATTR_NARROW)) {
2911 if ((tattr & ATTR_WIDE) == 0 &&
2912 CharWidth(ctx, (tchar | tattr) & 0xFFFF) == 2)
2913 tattr |= ATTR_NARROW;
2914 } else if (disptext[idx]&ATTR_NARROW)
2915 tattr |= ATTR_NARROW;
2916
2917 /* Cursor here ? Save the 'background' */
2918 if (i == our_curs_y && j == curs.x) {
2919 cursor_background = tattr | tchar;
2920 dispcurs = disptext + idx;
2921 }
2922
2923 if ((disptext[idx] ^ tattr) & ATTR_WIDE)
2924 dirty_line = TRUE;
2925
2926 break_run = (tattr != attr || j - start >= sizeof(ch));
2927
2928 /* Special hack for VT100 Linedraw glyphs */
2929 if ((attr & CSET_MASK) == 0x2300 && tchar >= 0xBA
2930 && tchar <= 0xBD) break_run = TRUE;
2931
2932 if (!dbcs_screenfont && !dirty_line) {
2933 if ((tchar | tattr) == disptext[idx])
2934 break_run = TRUE;
2935 else if (!dirty_run && ccount == 1)
2936 break_run = TRUE;
2937 }
2938
2939 if (break_run) {
2940 if ((dirty_run || last_run_dirty) && ccount > 0) {
2941 do_text(ctx, start, i, ch, ccount, attr, lattr);
2942 updated_line = 1;
2943 }
2944 start = j;
2945 ccount = 0;
2946 attr = tattr;
2947 if (dbcs_screenfont)
2948 last_run_dirty = dirty_run;
2949 dirty_run = dirty_line;
2950 }
2951
2952 if ((tchar | tattr) != disptext[idx])
2953 dirty_run = TRUE;
2954 ch[ccount++] = (char) tchar;
2955 disptext[idx] = tchar | tattr;
2956
2957 /* If it's a wide char step along to the next one. */
2958 if (tattr & ATTR_WIDE) {
2959 if (++j < cols) {
2960 idx++;
2961 d++;
2962 /* Cursor is here ? Ouch! */
2963 if (i == our_curs_y && j == curs.x) {
2964 cursor_background = *d;
2965 dispcurs = disptext + idx;
2966 }
2967 if (disptext[idx] != *d)
2968 dirty_run = TRUE;
2969 disptext[idx] = *d;
2970 }
2971 }
2972 }
2973 if (dirty_run && ccount > 0) {
2974 do_text(ctx, start, i, ch, ccount, attr, lattr);
2975 updated_line = 1;
2976 }
2977
2978 /* Cursor on this line ? (and changed) */
2979 if (i == our_curs_y && (curstype != cursor || updated_line)) {
2980 ch[0] = (char) (cursor_background & CHAR_MASK);
2981 attr = (cursor_background & ATTR_MASK) | cursor;
2982 do_cursor(ctx, curs.x, i, ch, 1, attr, lattr);
2983 curstype = cursor;
2984 }
2985 }
2986 }
2987
2988 /*
2989 * Flick the switch that says if blinking things should be shown or hidden.
2990 */
2991
2992 void term_blink(int flg)
2993 {
2994 static long last_blink = 0;
2995 static long last_tblink = 0;
2996 long now, blink_diff;
2997
2998 now = GetTickCount();
2999 blink_diff = now - last_tblink;
3000
3001 /* Make sure the text blinks no more than 2Hz */
3002 if (blink_diff < 0 || blink_diff > 450) {
3003 last_tblink = now;
3004 tblinker = !tblinker;
3005 }
3006
3007 if (flg) {
3008 blinker = 1;
3009 last_blink = now;
3010 return;
3011 }
3012
3013 blink_diff = now - last_blink;
3014
3015 /* Make sure the cursor blinks no faster than GetCaretBlinkTime() */
3016 if (blink_diff >= 0 && blink_diff < (long) GetCaretBlinkTime())
3017 return;
3018
3019 last_blink = now;
3020 blinker = !blinker;
3021 }
3022
3023 /*
3024 * Invalidate the whole screen so it will be repainted in full.
3025 */
3026 void term_invalidate(void)
3027 {
3028 int i;
3029
3030 for (i = 0; i < rows * (cols + 1); i++)
3031 disptext[i] = ATTR_INVALID;
3032 }
3033
3034 /*
3035 * Paint the window in response to a WM_PAINT message.
3036 */
3037 void term_paint(Context ctx, int left, int top, int right, int bottom)
3038 {
3039 int i, j;
3040 if (left < 0) left = 0;
3041 if (top < 0) top = 0;
3042 if (right >= cols) right = cols-1;
3043 if (bottom >= rows) bottom = rows-1;
3044
3045 for (i = top; i <= bottom && i < rows; i++) {
3046 if ((disptext[i * (cols + 1) + cols] & LATTR_MODE) == LATTR_NORM)
3047 for (j = left; j <= right && j < cols; j++)
3048 disptext[i * (cols + 1) + j] = ATTR_INVALID;
3049 else
3050 for (j = left / 2; j <= right / 2 + 1 && j < cols; j++)
3051 disptext[i * (cols + 1) + j] = ATTR_INVALID;
3052 }
3053
3054 /* This should happen soon enough, also for some reason it sometimes
3055 * fails to actually do anything when re-sizing ... painting the wrong
3056 * window perhaps ?
3057 */
3058 if (alt_pressed)
3059 do_paint (ctx, FALSE);
3060 }
3061
3062 /*
3063 * Attempt to scroll the scrollback. The second parameter gives the
3064 * position we want to scroll to; the first is +1 to denote that
3065 * this position is relative to the beginning of the scrollback, -1
3066 * to denote it is relative to the end, and 0 to denote that it is
3067 * relative to the current position.
3068 */
3069 void term_scroll(int rel, int where)
3070 {
3071 int sbtop = -count234(scrollback);
3072
3073 disptop = (rel < 0 ? 0 : rel > 0 ? sbtop : disptop) + where;
3074 if (disptop < sbtop)
3075 disptop = sbtop;
3076 if (disptop > 0)
3077 disptop = 0;
3078 update_sbar();
3079 term_update();
3080 }
3081
3082 static void clipme(pos top, pos bottom, int rect)
3083 {
3084 wchar_t *workbuf;
3085 wchar_t *wbptr; /* where next char goes within workbuf */
3086 int old_top_x;
3087 int wblen = 0; /* workbuf len */
3088 int buflen; /* amount of memory allocated to workbuf */
3089
3090 buflen = 5120; /* Default size */
3091 workbuf = smalloc(buflen * sizeof(wchar_t));
3092 wbptr = workbuf; /* start filling here */
3093 old_top_x = top.x; /* needed for rect==1 */
3094
3095 while (poslt(top, bottom)) {
3096 int nl = FALSE;
3097 unsigned long *ldata = lineptr(top.y);
3098 pos nlpos;
3099
3100 /*
3101 * nlpos will point at the maximum position on this line we
3102 * should copy up to. So we start it at the end of the
3103 * line...
3104 */
3105 nlpos.y = top.y;
3106 nlpos.x = cols;
3107
3108 /*
3109 * ... move it backwards if there's unused space at the end
3110 * of the line (and also set `nl' if this is the case,
3111 * because in normal selection mode this means we need a
3112 * newline at the end)...
3113 */
3114 if (!(ldata[cols] & LATTR_WRAPPED)) {
3115 while (((ldata[nlpos.x - 1] & 0xFF) == 0x20 ||
3116 (DIRECT_CHAR(ldata[nlpos.x - 1]) &&
3117 (ldata[nlpos.x - 1] & CHAR_MASK) == 0x20))
3118 && poslt(top, nlpos))
3119 decpos(nlpos);
3120 if (poslt(nlpos, bottom))
3121 nl = TRUE;
3122 }
3123
3124 /*
3125 * ... and then clip it to the terminal x coordinate if
3126 * we're doing rectangular selection. (In this case we
3127 * still did the above, so that copying e.g. the right-hand
3128 * column from a table doesn't fill with spaces on the
3129 * right.)
3130 */
3131 if (rect) {
3132 if (nlpos.x > bottom.x)
3133 nlpos.x = bottom.x;
3134 nl = (top.y < bottom.y);
3135 }
3136
3137 while (poslt(top, bottom) && poslt(top, nlpos)) {
3138 #if 0
3139 char cbuf[16], *p;
3140 sprintf(cbuf, "<U+%04x>", (ldata[top.x] & 0xFFFF));
3141 #else
3142 wchar_t cbuf[16], *p;
3143 int uc = (ldata[top.x] & 0xFFFF);
3144 int set, c;
3145
3146 if (uc == UCSWIDE) {
3147 top.x++;
3148 continue;
3149 }
3150
3151 switch (uc & CSET_MASK) {
3152 case ATTR_LINEDRW:
3153 if (!cfg.rawcnp) {
3154 uc = unitab_xterm[uc & 0xFF];
3155 break;
3156 }
3157 case ATTR_ASCII:
3158 uc = unitab_line[uc & 0xFF];
3159 break;
3160 case ATTR_SCOACS:
3161 uc = unitab_scoacs[uc&0xFF];
3162 break;
3163 }
3164 switch (uc & CSET_MASK) {
3165 case ATTR_ACP:
3166 uc = unitab_font[uc & 0xFF];
3167 break;
3168 case ATTR_OEMCP:
3169 uc = unitab_oemcp[uc & 0xFF];
3170 break;
3171 }
3172
3173 set = (uc & CSET_MASK);
3174 c = (uc & CHAR_MASK);
3175 cbuf[0] = uc;
3176 cbuf[1] = 0;
3177
3178 if (DIRECT_FONT(uc)) {
3179 if (c >= ' ' && c != 0x7F) {
3180 unsigned char buf[4];
3181 WCHAR wbuf[4];
3182 int rv;
3183 if (IsDBCSLeadByteEx(font_codepage, (BYTE) c)) {
3184 buf[0] = c;
3185 buf[1] = (unsigned char) ldata[top.x + 1];
3186 rv = MultiByteToWideChar(font_codepage,
3187 0, buf, 2, wbuf, 4);
3188 top.x++;
3189 } else {
3190 buf[0] = c;
3191 rv = MultiByteToWideChar(font_codepage,
3192 0, buf, 1, wbuf, 4);
3193 }
3194
3195 if (rv > 0) {
3196 memcpy(cbuf, wbuf, rv * sizeof(wchar_t));
3197 cbuf[rv] = 0;
3198 }
3199 }
3200 }
3201 #endif
3202
3203 for (p = cbuf; *p; p++) {
3204 /* Enough overhead for trailing NL and nul */
3205 if (wblen >= buflen - 16) {
3206 workbuf =
3207 srealloc(workbuf,
3208 sizeof(wchar_t) * (buflen += 100));
3209 wbptr = workbuf + wblen;
3210 }
3211 wblen++;
3212 *wbptr++ = *p;
3213 }
3214 top.x++;
3215 }
3216 if (nl) {
3217 int i;
3218 for (i = 0; i < sel_nl_sz; i++) {
3219 wblen++;
3220 *wbptr++ = sel_nl[i];
3221 }
3222 }
3223 top.y++;
3224 top.x = rect ? old_top_x : 0;
3225 }
3226 wblen++;
3227 *wbptr++ = 0;
3228 write_clip(workbuf, wblen, FALSE); /* transfer to clipboard */
3229 if (buflen > 0) /* indicates we allocated this buffer */
3230 sfree(workbuf);
3231 }
3232
3233 void term_copyall(void)
3234 {
3235 pos top;
3236 top.y = -count234(scrollback);
3237 top.x = 0;
3238 clipme(top, curs, 0);
3239 }
3240
3241 /*
3242 * The wordness array is mainly for deciding the disposition of the US-ASCII
3243 * characters.
3244 */
3245 static int wordtype(int uc)
3246 {
3247 static struct {
3248 int start, end, ctype;
3249 } *wptr, ucs_words[] = {
3250 {
3251 128, 160, 0}, {
3252 161, 191, 1}, {
3253 215, 215, 1}, {
3254 247, 247, 1}, {
3255 0x037e, 0x037e, 1}, /* Greek question mark */
3256 {
3257 0x0387, 0x0387, 1}, /* Greek ano teleia */
3258 {
3259 0x055a, 0x055f, 1}, /* Armenian punctuation */
3260 {
3261 0x0589, 0x0589, 1}, /* Armenian full stop */
3262 {
3263 0x0700, 0x070d, 1}, /* Syriac punctuation */
3264 {
3265 0x104a, 0x104f, 1}, /* Myanmar punctuation */
3266 {
3267 0x10fb, 0x10fb, 1}, /* Georgian punctuation */
3268 {
3269 0x1361, 0x1368, 1}, /* Ethiopic punctuation */
3270 {
3271 0x166d, 0x166e, 1}, /* Canadian Syl. punctuation */
3272 {
3273 0x17d4, 0x17dc, 1}, /* Khmer punctuation */
3274 {
3275 0x1800, 0x180a, 1}, /* Mongolian punctuation */
3276 {
3277 0x2000, 0x200a, 0}, /* Various spaces */
3278 {
3279 0x2070, 0x207f, 2}, /* superscript */
3280 {
3281 0x2080, 0x208f, 2}, /* subscript */
3282 {
3283 0x200b, 0x27ff, 1}, /* punctuation and symbols */
3284 {
3285 0x3000, 0x3000, 0}, /* ideographic space */
3286 {
3287 0x3001, 0x3020, 1}, /* ideographic punctuation */
3288 {
3289 0x303f, 0x309f, 3}, /* Hiragana */
3290 {
3291 0x30a0, 0x30ff, 3}, /* Katakana */
3292 {
3293 0x3300, 0x9fff, 3}, /* CJK Ideographs */
3294 {
3295 0xac00, 0xd7a3, 3}, /* Hangul Syllables */
3296 {
3297 0xf900, 0xfaff, 3}, /* CJK Ideographs */
3298 {
3299 0xfe30, 0xfe6b, 1}, /* punctuation forms */
3300 {
3301 0xff00, 0xff0f, 1}, /* half/fullwidth ASCII */
3302 {
3303 0xff1a, 0xff20, 1}, /* half/fullwidth ASCII */
3304 {
3305 0xff3b, 0xff40, 1}, /* half/fullwidth ASCII */
3306 {
3307 0xff5b, 0xff64, 1}, /* half/fullwidth ASCII */
3308 {
3309 0xfff0, 0xffff, 0}, /* half/fullwidth ASCII */
3310 {
3311 0, 0, 0}
3312 };
3313
3314 uc &= (CSET_MASK | CHAR_MASK);
3315
3316 switch (uc & CSET_MASK) {
3317 case ATTR_LINEDRW:
3318 uc = unitab_xterm[uc & 0xFF];
3319 break;
3320 case ATTR_ASCII:
3321 uc = unitab_line[uc & 0xFF];
3322 break;
3323 case ATTR_SCOACS:
3324 uc = unitab_scoacs[uc&0xFF];
3325 break;
3326 }
3327 switch (uc & CSET_MASK) {
3328 case ATTR_ACP:
3329 uc = unitab_font[uc & 0xFF];
3330 break;
3331 case ATTR_OEMCP:
3332 uc = unitab_oemcp[uc & 0xFF];
3333 break;
3334 }
3335
3336 /* For DBCS font's I can't do anything usefull. Even this will sometimes
3337 * fail as there's such a thing as a double width space. :-(
3338 */
3339 if (dbcs_screenfont && font_codepage == line_codepage)
3340 return (uc != ' ');
3341
3342 if (uc < 0x80)
3343 return wordness[uc];
3344
3345 for (wptr = ucs_words; wptr->start; wptr++) {
3346 if (uc >= wptr->start && uc <= wptr->end)
3347 return wptr->ctype;
3348 }
3349
3350 return 2;
3351 }
3352
3353 /*
3354 * Spread the selection outwards according to the selection mode.
3355 */
3356 static pos sel_spread_half(pos p, int dir)
3357 {
3358 unsigned long *ldata;
3359 short wvalue;
3360 int topy = -count234(scrollback);
3361
3362 ldata = lineptr(p.y);
3363
3364 switch (selmode) {
3365 case SM_CHAR:
3366 /*
3367 * In this mode, every character is a separate unit, except
3368 * for runs of spaces at the end of a non-wrapping line.
3369 */
3370 if (!(ldata[cols] & LATTR_WRAPPED)) {
3371 unsigned long *q = ldata + cols;
3372 while (q > ldata && (q[-1] & CHAR_MASK) == 0x20)
3373 q--;
3374 if (q == ldata + cols)
3375 q--;
3376 if (p.x >= q - ldata)
3377 p.x = (dir == -1 ? q - ldata : cols - 1);
3378 }
3379 break;
3380 case SM_WORD:
3381 /*
3382 * In this mode, the units are maximal runs of characters
3383 * whose `wordness' has the same value.
3384 */
3385 wvalue = wordtype(ldata[p.x]);
3386 if (dir == +1) {
3387 while (1) {
3388 if (p.x < cols-1) {
3389 if (wordtype(ldata[p.x + 1]) == wvalue)
3390 p.x++;
3391 else
3392 break;
3393 } else {
3394 if (ldata[cols] & LATTR_WRAPPED) {
3395 unsigned long *ldata2;
3396 ldata2 = lineptr(p.y+1);
3397 if (wordtype(ldata2[0]) == wvalue) {
3398 p.x = 0;
3399 p.y++;
3400 ldata = ldata2;
3401 } else
3402 break;
3403 } else
3404 break;
3405 }
3406 }
3407 } else {
3408 while (1) {
3409 if (p.x > 0) {
3410 if (wordtype(ldata[p.x - 1]) == wvalue)
3411 p.x--;
3412 else
3413 break;
3414 } else {
3415 unsigned long *ldata2;
3416 if (p.y <= topy)
3417 break;
3418 ldata2 = lineptr(p.y-1);
3419 if ((ldata2[cols] & LATTR_WRAPPED) &&
3420 wordtype(ldata2[cols-1]) == wvalue) {
3421 p.x = cols-1;
3422 p.y--;
3423 ldata = ldata2;
3424 } else
3425 break;
3426 }
3427 }
3428 }
3429 break;
3430 case SM_LINE:
3431 /*
3432 * In this mode, every line is a unit.
3433 */
3434 p.x = (dir == -1 ? 0 : cols - 1);
3435 break;
3436 }
3437 return p;
3438 }
3439
3440 static void sel_spread(void)
3441 {
3442 if (seltype == LEXICOGRAPHIC) {
3443 selstart = sel_spread_half(selstart, -1);
3444 decpos(selend);
3445 selend = sel_spread_half(selend, +1);
3446 incpos(selend);
3447 }
3448 }
3449
3450 void term_do_paste(void)
3451 {
3452 wchar_t *data;
3453 int len;
3454
3455 get_clip(&data, &len);
3456 if (data) {
3457 wchar_t *p, *q;
3458
3459 if (paste_buffer)
3460 sfree(paste_buffer);
3461 paste_pos = paste_hold = paste_len = 0;
3462 paste_buffer = smalloc(len * sizeof(wchar_t));
3463
3464 p = q = data;
3465 while (p < data + len) {
3466 while (p < data + len &&
3467 !(p <= data + len - sel_nl_sz &&
3468 !memcmp(p, sel_nl, sizeof(sel_nl))))
3469 p++;
3470
3471 {
3472 int i;
3473 for (i = 0; i < p - q; i++) {
3474 paste_buffer[paste_len++] = q[i];
3475 }
3476 }
3477
3478 if (p <= data + len - sel_nl_sz &&
3479 !memcmp(p, sel_nl, sizeof(sel_nl))) {
3480 paste_buffer[paste_len++] = '\r';
3481 p += sel_nl_sz;
3482 }
3483 q = p;
3484 }
3485
3486 /* Assume a small paste will be OK in one go. */
3487 if (paste_len < 256) {
3488 luni_send(paste_buffer, paste_len, 0);
3489 if (paste_buffer)
3490 sfree(paste_buffer);
3491 paste_buffer = 0;
3492 paste_pos = paste_hold = paste_len = 0;
3493 }
3494 }
3495 get_clip(NULL, NULL);
3496 }
3497
3498 void term_mouse(Mouse_Button b, Mouse_Action a, int x, int y,
3499 int shift, int ctrl, int alt)
3500 {
3501 pos selpoint;
3502 unsigned long *ldata;
3503 int raw_mouse = (xterm_mouse &&
3504 !cfg.no_mouse_rep &&
3505 !(cfg.mouse_override && shift));
3506 int default_seltype;
3507
3508 if (y < 0) {
3509 y = 0;
3510 if (a == MA_DRAG && !raw_mouse)
3511 term_scroll(0, -1);
3512 }
3513 if (y >= rows) {
3514 y = rows - 1;
3515 if (a == MA_DRAG && !raw_mouse)
3516 term_scroll(0, +1);
3517 }
3518 if (x < 0) {
3519 if (y > 0) {
3520 x = cols - 1;
3521 y--;
3522 } else
3523 x = 0;
3524 }
3525 if (x >= cols)
3526 x = cols - 1;
3527
3528 selpoint.y = y + disptop;
3529 selpoint.x = x;
3530 ldata = lineptr(selpoint.y);
3531 if ((ldata[cols] & LATTR_MODE) != LATTR_NORM)
3532 selpoint.x /= 2;
3533
3534 if (raw_mouse) {
3535 int encstate = 0, r, c;
3536 char abuf[16];
3537 static int is_down = 0;
3538
3539 switch (b) {
3540 case MBT_LEFT:
3541 encstate = 0x20; /* left button down */
3542 break;
3543 case MBT_MIDDLE:
3544 encstate = 0x21;
3545 break;
3546 case MBT_RIGHT:
3547 encstate = 0x22;
3548 break;
3549 case MBT_WHEEL_UP:
3550 encstate = 0x60;
3551 break;
3552 case MBT_WHEEL_DOWN:
3553 encstate = 0x61;
3554 break;
3555 default: break; /* placate gcc warning about enum use */
3556 }
3557 switch (a) {
3558 case MA_DRAG:
3559 if (xterm_mouse == 1)
3560 return;
3561 encstate += 0x20;
3562 break;
3563 case MA_RELEASE:
3564 encstate = 0x23;
3565 is_down = 0;
3566 break;
3567 case MA_CLICK:
3568 if (is_down == b)
3569 return;
3570 is_down = b;
3571 break;
3572 default: break; /* placate gcc warning about enum use */
3573 }
3574 if (shift)
3575 encstate += 0x04;
3576 if (ctrl)
3577 encstate += 0x10;
3578 r = y + 33;
3579 c = x + 33;
3580
3581 sprintf(abuf, "\033[M%c%c%c", encstate, c, r);
3582 ldisc_send(abuf, 6, 0);
3583 return;
3584 }
3585
3586 b = translate_button(b);
3587
3588 /*
3589 * Set the selection type (rectangular or normal) at the start
3590 * of a selection attempt, from the state of Alt.
3591 */
3592 if (!alt ^ !cfg.rect_select)
3593 default_seltype = RECTANGULAR;
3594 else
3595 default_seltype = LEXICOGRAPHIC;
3596
3597 if (selstate == NO_SELECTION) {
3598 seltype = default_seltype;
3599 }
3600
3601 if (b == MBT_SELECT && a == MA_CLICK) {
3602 deselect();
3603 selstate = ABOUT_TO;
3604 seltype = default_seltype;
3605 selanchor = selpoint;
3606 selmode = SM_CHAR;
3607 } else if (b == MBT_SELECT && (a == MA_2CLK || a == MA_3CLK)) {
3608 deselect();
3609 selmode = (a == MA_2CLK ? SM_WORD : SM_LINE);
3610 selstate = DRAGGING;
3611 selstart = selanchor = selpoint;
3612 selend = selstart;
3613 incpos(selend);
3614 sel_spread();
3615 } else if ((b == MBT_SELECT && a == MA_DRAG) ||
3616 (b == MBT_EXTEND && a != MA_RELEASE)) {
3617 if (selstate == ABOUT_TO && poseq(selanchor, selpoint))
3618 return;
3619 if (b == MBT_EXTEND && a != MA_DRAG && selstate == SELECTED) {
3620 if (seltype == LEXICOGRAPHIC) {
3621 /*
3622 * For normal selection, we extend by moving
3623 * whichever end of the current selection is closer
3624 * to the mouse.
3625 */
3626 if (posdiff(selpoint, selstart) <
3627 posdiff(selend, selstart) / 2) {
3628 selanchor = selend;
3629 decpos(selanchor);
3630 } else {
3631 selanchor = selstart;
3632 }
3633 } else {
3634 /*
3635 * For rectangular selection, we have a choice of
3636 * _four_ places to put selanchor and selpoint: the
3637 * four corners of the selection.
3638 */
3639 if (2*selpoint.x < selstart.x + selend.x)
3640 selanchor.x = selend.x-1;
3641 else
3642 selanchor.x = selstart.x;
3643
3644 if (2*selpoint.y < selstart.y + selend.y)
3645 selanchor.y = selend.y;
3646 else
3647 selanchor.y = selstart.y;
3648 }
3649 selstate = DRAGGING;
3650 }
3651 if (selstate != ABOUT_TO && selstate != DRAGGING)
3652 selanchor = selpoint;
3653 selstate = DRAGGING;
3654 if (seltype == LEXICOGRAPHIC) {
3655 /*
3656 * For normal selection, we set (selstart,selend) to
3657 * (selpoint,selanchor) in some order.
3658 */
3659 if (poslt(selpoint, selanchor)) {
3660 selstart = selpoint;
3661 selend = selanchor;
3662 incpos(selend);
3663 } else {
3664 selstart = selanchor;
3665 selend = selpoint;
3666 incpos(selend);
3667 }
3668 } else {
3669 /*
3670 * For rectangular selection, we may need to
3671 * interchange x and y coordinates (if the user has
3672 * dragged in the -x and +y directions, or vice versa).
3673 */
3674 selstart.x = min(selanchor.x, selpoint.x);
3675 selend.x = 1+max(selanchor.x, selpoint.x);
3676 selstart.y = min(selanchor.y, selpoint.y);
3677 selend.y = max(selanchor.y, selpoint.y);
3678 }
3679 sel_spread();
3680 } else if ((b == MBT_SELECT || b == MBT_EXTEND) && a == MA_RELEASE) {
3681 if (selstate == DRAGGING) {
3682 /*
3683 * We've completed a selection. We now transfer the
3684 * data to the clipboard.
3685 */
3686 clipme(selstart, selend, (seltype == RECTANGULAR));
3687 selstate = SELECTED;
3688 } else
3689 selstate = NO_SELECTION;
3690 } else if (b == MBT_PASTE
3691 && (a == MA_CLICK || a == MA_2CLK || a == MA_3CLK)) {
3692 term_do_paste();
3693 }
3694
3695 term_update();
3696 }
3697
3698 void term_nopaste()
3699 {
3700 if (paste_len == 0)
3701 return;
3702 sfree(paste_buffer);
3703 paste_buffer = 0;
3704 paste_len = 0;
3705 }
3706
3707 void term_paste()
3708 {
3709 static long last_paste = 0;
3710 long now, paste_diff;
3711
3712 if (paste_len == 0)
3713 return;
3714
3715 /* Don't wait forever to paste */
3716 if (paste_hold) {
3717 now = GetTickCount();
3718 paste_diff = now - last_paste;
3719 if (paste_diff >= 0 && paste_diff < 450)
3720 return;
3721 }
3722 paste_hold = 0;
3723
3724 while (paste_pos < paste_len) {
3725 int n = 0;
3726 while (n + paste_pos < paste_len) {
3727 if (paste_buffer[paste_pos + n++] == '\r')
3728 break;
3729 }
3730 luni_send(paste_buffer + paste_pos, n, 0);
3731 paste_pos += n;
3732
3733 if (paste_pos < paste_len) {
3734 paste_hold = 1;
3735 return;
3736 }
3737 }
3738 sfree(paste_buffer);
3739 paste_buffer = 0;
3740 paste_len = 0;
3741 }
3742
3743 static void deselect(void)
3744 {
3745 selstate = NO_SELECTION;
3746 selstart.x = selstart.y = selend.x = selend.y = 0;
3747 }
3748
3749 void term_deselect(void)
3750 {
3751 deselect();
3752 term_update();
3753 }
3754
3755 int term_ldisc(int option)
3756 {
3757 if (option == LD_ECHO)
3758 return term_echoing;
3759 if (option == LD_EDIT)
3760 return term_editing;
3761 return FALSE;
3762 }
3763
3764 /*
3765 * from_backend(), to get data from the backend for the terminal.
3766 */
3767 int from_backend(int is_stderr, char *data, int len)
3768 {
3769 assert(len > 0);
3770
3771 bufchain_add(&inbuf, data, len);
3772
3773 /*
3774 * term_out() always completely empties inbuf. Therefore,
3775 * there's no reason at all to return anything other than zero
3776 * from this function, because there _can't_ be a question of
3777 * the remote side needing to wait until term_out() has cleared
3778 * a backlog.
3779 *
3780 * This is a slightly suboptimal way to deal with SSH2 - in
3781 * principle, the window mechanism would allow us to continue
3782 * to accept data on forwarded ports and X connections even
3783 * while the terminal processing was going slowly - but we
3784 * can't do the 100% right thing without moving the terminal
3785 * processing into a separate thread, and that might hurt
3786 * portability. So we manage stdout buffering the old SSH1 way:
3787 * if the terminal processing goes slowly, the whole SSH
3788 * connection stops accepting data until it's ready.
3789 *
3790 * In practice, I can't imagine this causing serious trouble.
3791 */
3792 return 0;
3793 }
Local modifications for Simon Tatham's `PuTTY' SSH client and terminal emulator