83717e9a536f3d6f8a12ca7b4a2e5d1d70dc355a
[dana/urxvt.git] / src / screen.C
1 /*---------------------------------------------------------------------------*
2  * File:        screen.C
3  *---------------------------------------------------------------------------*
4  *
5  * Copyright (c) 1997-2001 Geoff Wing <gcw@pobox.com>
6  * Copyright (c) 2003-2007 Marc Lehmann <pcg@goof.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  *--------------------------------------------------------------------------*/
22
23 /*
24  * This file handles _all_ screen updates and selections
25  */
26
27 #include "../config.h"          /* NECESSARY */
28 #include "rxvt.h"               /* NECESSARY */
29 #include "rxvtperl.h"           /* NECESSARY */
30
31 #include <inttypes.h>
32
33 #include "salloc.C" // HACK, should be a seperate compile!
34
35 static inline void fill_text (text_t *start, text_t value, int len)
36 {
37   while (len--)
38     *start++ = value;
39 }
40
41 /* ------------------------------------------------------------------------- */
42 #define PROP_SIZE               256*1024
43 #define PASTE_SIZE              32768
44 #define TABSIZE                 8       /* default tab size */
45
46 /* ------------------------------------------------------------------------- *
47  *             GENERAL SCREEN AND SELECTION UPDATE ROUTINES                  *
48  * ------------------------------------------------------------------------- */
49 #define ZERO_SCROLLBACK()                                              \
50     if (option (Opt_scrollTtyOutput))                                  \
51         view_start = 0
52 #define CLEAR_SELECTION()                                              \
53     selection.beg.row = selection.beg.col                              \
54         = selection.end.row = selection.end.col = 0
55 #define CLEAR_ALL_SELECTION()                                          \
56     selection.beg.row = selection.beg.col                              \
57         = selection.mark.row = selection.mark.col                      \
58         = selection.end.row = selection.end.col = 0
59
60 #define ROW_AND_COL_IS_AFTER(A, B, C, D)                               \
61     (((A) > (C)) || (((A) == (C)) && ((B) > (D))))
62 #define ROW_AND_COL_IS_BEFORE(A, B, C, D)                              \
63     (((A) < (C)) || (((A) == (C)) && ((B) < (D))))
64 #define ROW_AND_COL_IN_ROW_AFTER(A, B, C, D)                           \
65     (((A) == (C)) && ((B) > (D)))
66 #define ROW_AND_COL_IN_ROW_AT_OR_AFTER(A, B, C, D)                     \
67     (((A) == (C)) && ((B) >= (D)))
68 #define ROW_AND_COL_IN_ROW_BEFORE(A, B, C, D)                          \
69     (((A) == (C)) && ((B) < (D)))
70 #define ROW_AND_COL_IN_ROW_AT_OR_BEFORE(A, B, C, D)                    \
71     (((A) == (C)) && ((B) <= (D)))
72
73 /* these must be row_col_t */
74 #define ROWCOL_IS_AFTER(X, Y)                                          \
75     ROW_AND_COL_IS_AFTER ((X).row, (X).col, (Y).row, (Y).col)
76 #define ROWCOL_IS_BEFORE(X, Y)                                         \
77     ROW_AND_COL_IS_BEFORE ((X).row, (X).col, (Y).row, (Y).col)
78 #define ROWCOL_IN_ROW_AFTER(X, Y)                                      \
79     ROW_AND_COL_IN_ROW_AFTER ((X).row, (X).col, (Y).row, (Y).col)
80 #define ROWCOL_IN_ROW_BEFORE(X, Y)                                     \
81     ROW_AND_COL_IN_ROW_BEFORE ((X).row, (X).col, (Y).row, (Y).col)
82 #define ROWCOL_IN_ROW_AT_OR_AFTER(X, Y)                                \
83     ROW_AND_COL_IN_ROW_AT_OR_AFTER ((X).row, (X).col, (Y).row, (Y).col)
84 #define ROWCOL_IN_ROW_AT_OR_BEFORE(X, Y)                               \
85     ROW_AND_COL_IN_ROW_AT_OR_BEFORE ((X).row, (X).col, (Y).row, (Y).col)
86
87 /*
88  * CLEAR_CHARS: clear <num> chars starting from pixel position <x,y>
89  */
90 #define CLEAR_CHARS(x, y, num)                                         \
91     if (mapped)                                                        \
92         XClearArea (dpy, vt, x, y,                                     \
93                     (unsigned int)Width2Pixel (num),                   \
94                     (unsigned int)Height2Pixel (1), False)
95
96 /* ------------------------------------------------------------------------- *
97  *                        SCREEN `COMMON' ROUTINES                           *
98  * ------------------------------------------------------------------------- */
99
100 /* Fill part/all of a line with blanks. */
101 void
102 rxvt_term::scr_blank_line (line_t &l, unsigned int col, unsigned int width, rend_t efs) const NOTHROW
103 {
104   if (!l.t)
105     {
106       lalloc (l);
107       col = 0;
108       width = ncol;
109     }
110
111   l.touch ();
112
113   efs &= ~RS_baseattrMask; // remove italic etc. fontstyles
114   efs = SET_FONT (efs, FONTSET (efs)->find_font (' '));
115
116   text_t *et = l.t + col;
117   rend_t *er = l.r + col;
118
119   while (width--)
120     {
121       *et++ = ' ';
122       *er++ = efs;
123     }
124 }
125
126 /* ------------------------------------------------------------------------- */
127 /* Fill a full line with blanks - make sure it is allocated first */
128 void
129 rxvt_term::scr_blank_screen_mem (line_t &l, rend_t efs) const NOTHROW
130 {
131   scr_blank_line (l, 0, ncol, efs);
132
133   l.l = 0;
134   l.f = 0;
135 }
136
137 // nuke a single wide character at the given column
138 void
139 rxvt_term::scr_kill_char (line_t &l, int col) const NOTHROW
140 {
141   // find begin
142   while (col > 0 && l.t[col] == NOCHAR)
143     col--;
144
145   rend_t rend = l.r[col] & ~RS_baseattrMask;
146   rend = SET_FONT (rend, FONTSET (rend)->find_font (' '));
147
148   // found start, nuke
149   do {
150     l.t[col] = ' ';
151     l.r[col] = rend;
152     col++;
153   } while (col < ncol && l.t[col] == NOCHAR);
154 }
155
156 /* ------------------------------------------------------------------------- *
157  *                          SCREEN INITIALISATION                            *
158  * ------------------------------------------------------------------------- */
159
160 void
161 rxvt_term::scr_reset ()
162 {
163   view_start = 0;
164   num_scr = 0;
165
166   if (ncol == 0)
167     ncol = 80;
168
169   if (nrow == 0)
170     nrow = 24;
171
172   if (ncol == prev_ncol && nrow == prev_nrow)
173     return;
174
175   // we need at least two lines for wrapping to work correctly
176   while (nrow + saveLines < 2)
177     {
178       //TODO//FIXME
179       saveLines++;
180       prev_nrow--;
181       top_row--;
182     }
183
184   want_refresh = 1;
185
186   int prev_total_rows = prev_nrow + saveLines;
187   total_rows = nrow + saveLines;
188
189   screen.tscroll = 0;
190   screen.bscroll = nrow - 1;
191
192   if (!row_buf)
193     {
194       /*
195        * first time called so just malloc everything: don't rely on realloc
196        */
197       top_row    = 0;
198       term_start = 0;
199
200       talloc = new rxvt_salloc (ncol * sizeof (text_t));
201       ralloc = new rxvt_salloc (ncol * sizeof (rend_t));
202
203       row_buf   = (line_t *)rxvt_calloc (total_rows + nrow, sizeof (line_t));
204       drawn_buf = (line_t *)rxvt_calloc (nrow             , sizeof (line_t));
205       swap_buf  = (line_t *)rxvt_calloc (nrow             , sizeof (line_t));
206
207       for (int row = nrow; row--; )
208         {
209           scr_blank_screen_mem (ROW (row), DEFAULT_RSTYLE);
210           scr_blank_screen_mem (swap_buf [row], DEFAULT_RSTYLE);
211           scr_blank_screen_mem (drawn_buf[row], DEFAULT_RSTYLE);
212         }
213
214       memset (charsets, 'B', sizeof (charsets));
215       rstyle = DEFAULT_RSTYLE;
216       screen.flags = Screen_DefaultFlags;
217       screen.cur.row = screen.cur.col = 0;
218       screen.charset = 0;
219       current_screen = PRIMARY;
220       scr_cursor (SAVE);
221
222 #if NSCREENS
223       swap.flags = Screen_DefaultFlags;
224       swap.cur.row = swap.cur.col = 0;
225       swap.charset = 0;
226       current_screen = SECONDARY;
227       scr_cursor (SAVE);
228       current_screen = PRIMARY;
229 #endif
230
231       selection.text = NULL;
232       selection.len = 0;
233       selection.op = SELECTION_CLEAR;
234       selection.screen = PRIMARY;
235       selection.clicks = 0;
236     }
237   else
238     {
239       /*
240        * add or delete rows as appropriate
241        */
242
243       rxvt_salloc *old_ta = talloc; talloc = new rxvt_salloc (ncol * sizeof (text_t));
244       rxvt_salloc *old_ra = ralloc; ralloc = new rxvt_salloc (ncol * sizeof (rend_t));
245
246 #if 0
247       if (nrow < prev_nrow)
248         {
249           for (int row = nrow; row < prev_nrow; row++)
250             {
251               lfree (swap_buf [row]);
252               lfree (drawn_buf[row]);
253             }
254         }
255 #endif
256
257       drawn_buf = (line_t *)rxvt_realloc (drawn_buf, nrow * sizeof (line_t));
258       swap_buf  = (line_t *)rxvt_realloc (swap_buf , nrow * sizeof (line_t));
259
260       for (int row = min (nrow, prev_nrow); row--; )
261         {
262           lresize (drawn_buf[row]);
263           lresize (swap_buf [row]);
264         }
265
266       for (int row = prev_nrow; row < nrow; row++)
267         {
268           swap_buf [row].clear (); scr_blank_screen_mem (swap_buf [row], DEFAULT_RSTYLE);
269           drawn_buf[row].clear (); scr_blank_screen_mem (drawn_buf[row], DEFAULT_RSTYLE);
270         }
271
272       line_t *old_buf = row_buf;
273       row_buf = (line_t *)rxvt_calloc (total_rows + nrow, sizeof (line_t));
274
275       int p    = MOD (term_start + prev_nrow, prev_total_rows);  // previous row
276       int pend = MOD (term_start + top_row  , prev_total_rows);
277       int q    = total_rows; // rewrapped row
278
279       if (top_row)
280         {
281           // Re-wrap lines. This is rather ugly, possibly because I am too dumb
282           // to come up with a lean and mean algorithm.
283           // TODO: maybe optimise when width didn't change
284
285           row_col_t ocur = screen.cur;
286           ocur.row = MOD (term_start + ocur.row, prev_total_rows);
287
288           do
289             {
290               p = MOD (p - 1, prev_total_rows);
291               assert (old_buf [MOD (p, prev_total_rows)].t);
292               int plines = 1;
293               int llen = old_buf [MOD (p, prev_total_rows)].l;
294
295               while (p != pend && old_buf [MOD (p - 1, prev_total_rows)].is_longer ())
296                 {
297                   p = MOD (p - 1, prev_total_rows);
298
299                   plines++;
300                   llen += prev_ncol;
301                 }
302
303               int qlines = max (0, (llen - 1) / ncol) + 1;
304
305               // drop partial lines completely
306               if (q < qlines)
307                 break;
308
309               q -= qlines;
310
311               int lofs = 0;
312               line_t *qline;
313
314               // re-assemble the full line by destination lines
315               for (int qrow = q; qlines--; qrow++)
316                 {
317                   qline = row_buf + qrow;
318                   lalloc (*qline);
319                   qline->l = ncol;
320                   qline->is_longer (1);
321
322                   int qcol = 0;
323
324                   // see below for cursor adjustment rationale
325                   if (p == ocur.row)
326                     screen.cur.row = q - (total_rows - nrow);
327
328                   // fill a single destination line
329                   while (lofs < llen && qcol < ncol)
330                     {
331                       int prow = lofs / prev_ncol;
332                       int pcol = lofs % prev_ncol;
333
334                       prow = MOD (p + prow, prev_total_rows);
335
336                       // we only adjust the cursor _row_ and put it into
337                       // the topmost line of "long line" it was in, as
338                       // this seems to upset applications/shells/readline
339                       // least.
340                       if (prow == ocur.row)
341                         screen.cur.row = q - (total_rows - nrow);
342
343                       line_t &pline = old_buf [prow];
344
345                       int len = min (min (prev_ncol - pcol, ncol - qcol), llen - lofs);
346
347                       memcpy (qline->t + qcol, pline.t + pcol, len * sizeof (text_t));
348                       memcpy (qline->r + qcol, pline.r + pcol, len * sizeof (rend_t));
349
350                       lofs += len;
351                       qcol += len;
352                     }
353                 }
354
355               qline->l = llen ? MOD (llen - 1, ncol) + 1 : 0;
356               qline->is_longer (0);
357               scr_blank_line (*qline, qline->l, ncol - qline->l, DEFAULT_RSTYLE);
358             }
359           while (p != pend && q > 0);
360
361           term_start = total_rows - nrow;
362           top_row = q - term_start;
363
364           // make sure all terminal lines exist
365           while (top_row > 0)
366             scr_blank_screen_mem (ROW (--top_row), DEFAULT_RSTYLE);
367         }
368       else
369         {
370           // if no scrollback exists (yet), wing, instead of wrap
371
372           for (int row = min (nrow, prev_nrow); row--; )
373             {
374               line_t &pline = old_buf [MOD (term_start + row, prev_total_rows)];
375               line_t &qline = row_buf [row];
376
377               qline = pline;
378               lresize (qline);
379             }
380
381           for (int row = prev_nrow; row < nrow; row++)
382             {
383               row_buf [row].clear (); scr_blank_screen_mem (row_buf [row], DEFAULT_RSTYLE);
384             }
385
386           term_start = 0;
387         }
388
389       free (old_buf);
390       delete old_ta;
391       delete old_ra;
392
393       clamp_it (screen.cur.row, 0, nrow - 1);
394       clamp_it (screen.cur.col, 0, ncol - 1);
395     }
396
397   free (tabs);
398   tabs = (char *)rxvt_malloc (ncol);
399
400   for (int col = ncol; --col; )
401     tabs [col] = col % TABSIZE == 0;
402
403   CLEAR_ALL_SELECTION ();
404
405   prev_nrow = nrow;
406   prev_ncol = ncol;
407
408   tt_winch ();
409
410   HOOK_INVOKE ((this, HOOK_RESET, DT_END));
411 }
412
413 /* ------------------------------------------------------------------------- */
414 /*
415  * Free everything.  That way malloc debugging can find leakage.
416  */
417 void
418 rxvt_term::scr_release () NOTHROW
419 {
420   if (row_buf)
421     {
422       delete talloc; talloc = 0;
423       delete ralloc; ralloc = 0;
424
425       free (row_buf);
426       free (swap_buf);
427       free (drawn_buf);
428       row_buf = 0; // signal that we freed all the arrays above
429
430       free (tabs);
431       tabs = 0;
432     }
433 }
434
435 /* ------------------------------------------------------------------------- */
436 /*
437  * Hard/Soft reset
438  */
439 void
440 rxvt_term::scr_poweron ()
441 {
442   scr_release ();
443   prev_nrow = prev_ncol = 0;
444   rvideo_mode = false;
445   scr_soft_reset ();
446   scr_reset ();
447
448   scr_clear (true);
449   scr_refresh ();
450 }
451
452 void
453 rxvt_term::scr_soft_reset ()
454 {
455   /* only affects modes, nothing drastic such as clearing the screen */
456 #if ENABLE_OVERLAY
457   scr_overlay_off ();
458 #endif
459
460   if (current_screen != PRIMARY)
461     scr_swap_screen ();
462
463   scr_scroll_region (0, MAX_ROWS - 1);
464   scr_rendition (0, ~RS_None);
465   scr_insert_mode (0);
466 }
467
468 /* ------------------------------------------------------------------------- *
469  *                         PROCESS SCREEN COMMANDS                           *
470  * ------------------------------------------------------------------------- */
471 /*
472  * Save and Restore cursor
473  * XTERM_SEQ: Save cursor   : ESC 7
474  * XTERM_SEQ: Restore cursor: ESC 8
475  */
476 void
477 rxvt_term::scr_cursor (cursor_mode mode) NOTHROW
478 {
479   screen_t *s;
480
481 #if NSCREENS && !defined(NO_SECONDARY_SCREEN_CURSOR)
482   if (current_screen == SECONDARY)
483     s = &swap;
484   else
485 #endif
486     s = &screen;
487
488   switch (mode)
489     {
490       case SAVE:
491         s->s_cur.row = screen.cur.row;
492         s->s_cur.col = screen.cur.col;
493         s->s_rstyle = rstyle;
494         s->s_charset = screen.charset;
495         s->s_charset_char = charsets[screen.charset];
496         break;
497
498       case RESTORE:
499         want_refresh = 1;
500         screen.cur.row = s->s_cur.row;
501         screen.cur.col = s->s_cur.col;
502         screen.flags &= ~Screen_WrapNext;
503         rstyle = s->s_rstyle;
504         screen.charset = s->s_charset;
505         charsets[screen.charset] = s->s_charset_char;
506         set_font_style ();
507         break;
508     }
509
510   /* boundary check in case screen size changed between SAVE and RESTORE */
511   min_it (s->cur.row, nrow - 1);
512   min_it (s->cur.col, ncol - 1);
513   assert (s->cur.row >= 0);
514   assert (s->cur.col >= 0);
515 }
516
517 void
518 rxvt_term::scr_swap_screen ()
519 {
520   if (!option (Opt_secondaryScreen))
521     return;
522
523   for (int i = prev_nrow; i--; )
524     ::swap (ROW(i), swap_buf [i]);
525
526   ::swap (screen.cur, swap.cur);
527
528   screen.cur.row = clamp (screen.cur.row, 0, prev_nrow - 1);
529   screen.cur.col = clamp (screen.cur.col, 0, prev_ncol - 1);
530 }
531
532 /* ------------------------------------------------------------------------- */
533 /*
534  * Swap between primary and secondary screens
535  * XTERM_SEQ: Primary screen  : ESC [ ? 4 7 h
536  * XTERM_SEQ: Secondary screen: ESC [ ? 4 7 l
537  */
538 void
539 rxvt_term::scr_change_screen (int scrn)
540 {
541   if (scrn == current_screen)
542     return;
543
544   want_refresh = 1;
545   view_start = 0;
546
547   selection_check (2);        /* check for boundary cross */
548
549   current_screen = scrn;
550
551 #if NSCREENS
552   if (option (Opt_secondaryScreen))
553     {
554       num_scr = 0;
555
556       scr_swap_screen ();
557
558       ::swap (screen.charset, swap.charset);
559       ::swap (screen.flags,   swap.flags);
560       screen.flags |= Screen_VisibleCursor;
561       swap.flags   |= Screen_VisibleCursor;
562     }
563   else
564 #endif
565     if (option (Opt_secondaryScroll))
566       scr_scroll_text (0, prev_nrow - 1, prev_nrow);
567 }
568
569 // clear WrapNext indicator, solidifying position on next line
570 void
571 rxvt_term::scr_do_wrap () NOTHROW
572 {
573   if (!(screen.flags & Screen_WrapNext))
574     return;
575
576   screen.flags &= ~Screen_WrapNext;
577
578   screen.cur.col = 0;
579
580   if (screen.cur.row == screen.bscroll)
581     scr_scroll_text (screen.tscroll, screen.bscroll, 1);
582   else if (screen.cur.row < nrow - 1)
583     screen.cur.row++;
584 }
585
586 /* ------------------------------------------------------------------------- */
587 /*
588  * Change the colour for following text
589  */
590 void
591 rxvt_term::scr_color (unsigned int color, int fgbg) NOTHROW
592 {
593   if (!IN_RANGE_INC (color, minCOLOR, maxTermCOLOR))
594     color = fgbg;
595
596   if (fgbg == Color_fg)
597     rstyle = SET_FGCOLOR (rstyle, color);
598   else
599     rstyle = SET_BGCOLOR (rstyle, color);
600 }
601
602 /* ------------------------------------------------------------------------- */
603 /*
604  * Change the rendition style for following text
605  */
606 void
607 rxvt_term::scr_rendition (int set, int style) NOTHROW
608 {
609   if (set)
610     rstyle |= style;
611   else if (style == ~RS_None)
612     rstyle = DEFAULT_RSTYLE;
613   else
614     rstyle &= ~style;
615 }
616
617 /* ------------------------------------------------------------------------- */
618 /*
619  * Scroll text between <row1> and <row2> inclusive, by <count> lines
620  * count positive ==> scroll up
621  * count negative ==> scroll down
622  */
623 int
624 rxvt_term::scr_scroll_text (int row1, int row2, int count) NOTHROW
625 {
626   if (count == 0 || (row1 > row2))
627     return 0;
628
629   want_refresh = 1;
630   num_scr += count;
631
632   if (count > 0
633       && row1 == 0
634       && (current_screen == PRIMARY || option (Opt_secondaryScroll)))
635     {
636       top_row = max (top_row - count, -saveLines);
637
638       // scroll everything up 'count' lines
639       term_start = (term_start + count) % total_rows;
640
641       // sever bottommost line
642       {
643         line_t &l = ROW(row2 - count);
644         l.is_longer (0);
645         l.touch ();
646       }
647
648       // erase newly scrolled-in lines
649       for (int i = count; i--; )
650         {
651           line_t &l = ROW(nrow - 1 - i);
652
653           // optimize if already cleared, can be significant on slow machines
654           // could be rolled into scr_blank_screen_mem
655           if (l.r && l.l < ncol - 1 && !((l.r[l.l + 1] ^ rstyle) & (RS_fgMask | RS_bgMask)))
656             {
657               scr_blank_line (l, 0, l.l, rstyle);
658               l.l = 0;
659               l.f = 0;
660             }
661           else
662             scr_blank_screen_mem (l, rstyle);
663         }
664
665       // now copy lines below the scroll region bottom to the
666       // bottom of the screen again, so they look as if they
667       // hadn't moved.
668       for (int i = nrow; --i > row2; )
669         {
670           line_t &l1 = ROW(i - count);
671           line_t &l2 = ROW(i);
672
673           ::swap (l1, l2);
674           l2.touch ();
675         }
676
677       // move and/or clear selection, if any
678       if (selection.op && current_screen == selection.screen)
679         {
680           selection.beg.row  -= count;
681           selection.end.row  -= count;
682           selection.mark.row -= count;
683
684           if (selection.beg.row < top_row
685               || selection.end.row < top_row
686               || selection.mark.row < top_row)
687             {
688               CLEAR_ALL_SELECTION ();
689               selection.op = SELECTION_CLEAR;
690             }
691         }
692
693       // finally move the view window, if desired
694       if (option (Opt_scrollWithBuffer)
695           && view_start != 0
696           && view_start != -saveLines)
697         scr_page (UP, count);
698
699       if (SHOULD_INVOKE (HOOK_SCROLL_BACK))
700         HOOK_INVOKE ((this, HOOK_SCROLL_BACK, DT_INT, count, DT_INT, top_row, DT_END));
701     }
702   else
703     {
704       if (selection.op && current_screen == selection.screen)
705         {
706           if ((selection.beg.row < row1 && selection.end.row > row1)
707               || (selection.beg.row < row2 && selection.end.row > row2)
708               || (selection.beg.row - count < row1 && selection.beg.row >= row1)
709               || (selection.beg.row - count > row2 && selection.beg.row <= row2)
710               || (selection.end.row - count < row1 && selection.end.row >= row1)
711               || (selection.end.row - count > row2 && selection.end.row <= row2))
712             {
713               CLEAR_ALL_SELECTION ();
714               selection.op = SELECTION_CLEAR;
715             }
716           else if (selection.end.row >= row1 && selection.end.row <= row2)
717             {
718               /* move selected region too */
719               selection.beg.row  -= count;
720               selection.end.row  -= count;
721               selection.mark.row -= count;
722
723               selection_check (0);
724             }
725         }
726
727       // use a simple and robust scrolling algorithm, this
728       // part of scr_scroll_text is not time-critical.
729
730       int rows = row2 - row1 + 1;
731
732       min_it (count, rows);
733
734       line_t *temp_buf = row_buf + total_rows;
735
736       for (int row = 0; row < rows; row++)
737         {
738           temp_buf [row] = ROW(row1 + (row + count + rows) % rows);
739
740           if (!IN_RANGE_EXC (row + count, 0, rows))
741             scr_blank_screen_mem (temp_buf [row], rstyle);
742         }
743
744       for (int row = 0; row < rows; row++)
745         ROW(row1 + row) = temp_buf [row];
746     }
747
748   return count;
749 }
750
751 /* ------------------------------------------------------------------------- */
752 /*
753  * Add text given in <str> of length <len> to screen struct
754  */
755 void
756 rxvt_term::scr_add_lines (const wchar_t *str, int len, int minlines) NOTHROW
757 {
758   if (len <= 0)               /* sanity */
759     return;
760
761   unsigned char checksel;
762   unicode_t c;
763   int ncol = this->ncol;
764   const wchar_t *strend = str + len;
765
766   want_refresh = 1;
767   ZERO_SCROLLBACK ();
768
769   if (minlines > 0)
770     {
771       minlines += screen.cur.row - screen.bscroll;
772       min_it (minlines, screen.cur.row - top_row);
773
774       if (minlines > 0
775           && screen.tscroll == 0
776           && screen.bscroll == nrow - 1)
777         {
778           /* _at least_ this many lines need to be scrolled */
779           scr_scroll_text (screen.tscroll, screen.bscroll, minlines);
780           screen.cur.row -= minlines;
781         }
782     }
783
784   assert (screen.cur.col < ncol);
785   assert (screen.cur.row < nrow
786           && screen.cur.row >= top_row);
787   int row = screen.cur.row;
788
789   checksel = selection.op && current_screen == selection.screen ? 1 : 0;
790
791   line_t *line = &ROW(row);
792
793   while (str < strend)
794     {
795       c = (unicode_t)*str++; // convert to rxvt-unicodes representation
796
797       if (expect_false (c < 0x20))
798         if (c == C0_LF)
799           {
800             max_it (line->l, screen.cur.col);
801
802             screen.flags &= ~Screen_WrapNext;
803
804             if (screen.cur.row == screen.bscroll)
805               scr_scroll_text (screen.tscroll, screen.bscroll, 1);
806             else if (screen.cur.row < (nrow - 1))
807               row = ++screen.cur.row;
808
809             line = &ROW(row);  /* _must_ refresh */
810             continue;
811           }
812         else if (c == C0_CR)
813           {
814             max_it (line->l, screen.cur.col);
815
816             screen.flags &= ~Screen_WrapNext;
817             screen.cur.col = 0;
818             continue;
819           }
820         else if (c == C0_HT)
821           {
822             scr_tab (1, true);
823             continue;
824           }
825
826       if (expect_false (
827             checksel            /* see if we're writing within selection */
828             && !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
829             && ROWCOL_IS_BEFORE (screen.cur, selection.end)
830          ))
831         {
832           checksel = 0;
833           /*
834            * If we wrote anywhere in the selected area, kill the selection
835            * XXX: should we kill the mark too?  Possibly, but maybe that
836            *      should be a similar check.
837            */
838           CLEAR_SELECTION ();
839         }
840
841       if (expect_false (screen.flags & Screen_WrapNext))
842         {
843           scr_do_wrap ();
844
845           line->l = ncol;
846           line->is_longer (1);
847
848           row = screen.cur.row;
849           line = &ROW(row);   /* _must_ refresh */
850         }
851
852       // some utf-8 decoders "decode" surrogate characters: let's fix this.
853       if (expect_false (IN_RANGE_INC (c, 0xd800, 0xdfff)))
854         c = 0xfffd;
855
856       // rely on wcwidth to tell us the character width, do wcwidth before
857       // further replacements, as wcwidth might return -1 for the line
858       // drawing characters below as they might be invalid in the current
859       // locale.
860       int width = WCWIDTH (c);
861
862       if (expect_false (charsets [screen.charset] == '0')) // DEC SPECIAL
863         {
864           // vt100 special graphics and line drawing
865           // 5f-7e standard vt100
866           // 40-5e rxvt extension for extra curses acs chars
867           static uint16_t vt100_0[62] = { // 41 .. 7e
868                     0x2191, 0x2193, 0x2192, 0x2190, 0x2588, 0x259a, 0x2603, // 41-47 hi mr. snowman!
869                  0,      0,      0,      0,      0,      0,      0,      0, // 48-4f
870                  0,      0,      0,      0,      0,      0,      0,      0, // 50-57
871                  0,      0,      0,      0,      0,      0,      0, 0x0020, // 58-5f
872             0x25c6, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0, 0x00b1, // 60-67
873             0x2424, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c, 0x23ba, // 68-6f
874             0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534, 0x252c, // 70-77
875             0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7,         // 78-7e
876           };
877
878           if (c >= 0x41 && c <= 0x7e && vt100_0[c - 0x41])
879             {
880               c = vt100_0[c - 0x41];
881               width = 1; // vt100 line drawing characters are always single-width
882             }
883         }
884
885       if (expect_false (screen.flags & Screen_Insert))
886         scr_insdel_chars (width, INSERT);
887
888       if (width != 0)
889         {
890 #if !UNICODE_3
891           // trim characters we can't store directly :(
892           if (c >= 0x10000)
893 # if ENABLE_COMBINING
894             c = rxvt_composite.compose (c); // map to lower 16 bits
895 # else
896             c = 0xfffd;
897 # endif
898 #endif
899
900           // nuke the character at this position, if required
901           if (expect_false (
902                 line->t[screen.cur.col] == NOCHAR
903                 || (screen.cur.col < ncol - 1
904                     && line->t[screen.cur.col + 1] == NOCHAR)
905              ))
906             scr_kill_char (*line, screen.cur.col);
907
908           rend_t rend = SET_FONT (rstyle, FONTSET (rstyle)->find_font (c));
909
910           // if the character doesn't fit into the remaining columns...
911           if (expect_false (screen.cur.col > ncol - width && ncol >= width))
912             {
913               // ... artificially enlargen the previous one
914               c = NOCHAR;
915               // and try the same character next loop iteration
916               --str;
917             }
918
919           line->touch ();
920
921           do
922             {
923               line->t[screen.cur.col] = c;
924               line->r[screen.cur.col] = rend;
925
926               if (expect_true (screen.cur.col < ncol - 1))
927                 screen.cur.col++;
928               else
929                 {
930                   line->l = ncol;
931                   if (screen.flags & Screen_Autowrap)
932                     screen.flags |= Screen_WrapNext;
933                   break;
934                 }
935
936               c = NOCHAR;
937             }
938           while (expect_false (--width > 0));
939
940           // pad with spaces when overwriting wide character with smaller one
941           if (expect_false (!width))
942             {
943               line->touch ();
944
945               for (int c = screen.cur.col; c < ncol && line->t[c] == NOCHAR; c++)
946                 {
947                   line->t[c] = ' ';
948                   line->r[c] = rend;
949                 }
950             }
951         }
952 #if ENABLE_COMBINING
953       else // width == 0
954         {
955           if (c != 0xfeff) // ignore BOM
956             {
957               // handle combining characters
958               // we just tag the accent on the previous on-screen character.
959               // this is arguably not correct, but also arguably not wrong.
960               // we don't handle double-width characters nicely yet.
961               line_t *linep;
962               text_t *tp;
963               rend_t *rp;
964
965               if (screen.cur.col > 0)
966                 {
967                   linep = line;
968                   tp = line->t + screen.cur.col - 1;
969                   rp = line->r + screen.cur.col - 1;
970                 }
971               else if (screen.cur.row > 0
972                        && ROW(screen.cur.row - 1).is_longer ())
973                 {
974                   linep = &ROW(screen.cur.row - 1);
975                   tp = line->t + ncol - 1;
976                   rp = line->r + ncol - 1;
977                 }
978               else
979                 continue;
980
981               linep->touch ();
982
983               while (*tp == NOCHAR && tp > linep->t)
984                 tp--, rp--;
985
986               // first try to find a precomposed character
987               unicode_t n = rxvt_compose (*tp, c);
988               if (n == NOCHAR)
989                 n = rxvt_composite.compose (*tp, c);
990
991               *tp = n;
992               *rp = SET_FONT (*rp, FONTSET (*rp)->find_font (*tp));
993             }
994         }
995 #endif
996     }
997
998   max_it (line->l, screen.cur.col);
999
1000   assert (screen.cur.row >= 0);
1001 }
1002
1003 /* ------------------------------------------------------------------------- */
1004 /*
1005  * Process Backspace.  Move back the cursor back a position, wrap if have to
1006  * XTERM_SEQ: CTRL-H
1007  */
1008 void
1009 rxvt_term::scr_backspace () NOTHROW
1010 {
1011   if (screen.cur.col == 0)
1012     {
1013       if (screen.cur.row > 0)
1014         {
1015 #ifdef TERMCAP_HAS_BW
1016           screen.cur.col = ncol - 1;
1017           --screen.cur.row;
1018
1019           want_refresh = 1;
1020 #endif
1021         }
1022     }
1023   else
1024     scr_gotorc (0, -1, RELATIVE);
1025 }
1026
1027 /* ------------------------------------------------------------------------- */
1028 /*
1029  * Process Horizontal Tab
1030  * count: +ve = forward; -ve = backwards
1031  * XTERM_SEQ: CTRL-I
1032  */
1033 void
1034 rxvt_term::scr_tab (int count, bool ht) NOTHROW
1035 {
1036   int i, x;
1037
1038   want_refresh = 1;
1039   i = x = screen.cur.col;
1040
1041   if (count == 0)
1042     return;
1043   else if (count > 0)
1044     {
1045       line_t &l = ROW(screen.cur.row);
1046       rend_t base_rend = l.r[i];
1047       ht &= l.t[i] == ' ';
1048
1049       for (; ++i < ncol; )
1050         if (tabs[i])
1051           {
1052             x = i;
1053
1054             if (!--count)
1055               break;
1056           }
1057         else
1058           ht &= l.t[i] == ' '
1059                 && RS_SAME (l.r[i], base_rend);
1060
1061       if (count)
1062         x = ncol - 1;
1063
1064       // store horizontal tab commands as characters inside the text
1065       // buffer so they can be selected and pasted.
1066       if (ht && option (Opt_pastableTabs))
1067         {
1068           base_rend = SET_FONT (base_rend, 0);
1069
1070           l.touch (x);
1071
1072           i = screen.cur.col;
1073
1074           l.t[i] = '\t';
1075           l.r[i] = base_rend;
1076
1077           while (++i < x)
1078             {
1079               l.t[i] = NOCHAR;
1080               l.r[i] = base_rend;
1081             }
1082         }
1083     }
1084   else /* if (count < 0) */
1085     {
1086       for (; --i >= 0; )
1087         if (tabs[i])
1088           {
1089             x = i;
1090             if (!++count)
1091               break;
1092           }
1093
1094       if (count)
1095         x = 0;
1096     }
1097
1098   if (x != screen.cur.col)
1099     scr_gotorc (0, x, R_RELATIVE);
1100 }
1101
1102 /* ------------------------------------------------------------------------- */
1103 /*
1104  * Process DEC Back Index
1105  * XTERM_SEQ: ESC 6
1106  * Move cursor left in row.  If we're at the left boundary, shift everything
1107  * in that row right.  Clear left column.
1108  */
1109 #if !ENABLE_MINIMAL
1110 void
1111 rxvt_term::scr_backindex () NOTHROW
1112 {
1113   if (screen.cur.col > 0)
1114     scr_gotorc (0, -1, R_RELATIVE | C_RELATIVE);
1115   else
1116     scr_insdel_chars (1, INSERT);
1117 }
1118 #endif
1119 /* ------------------------------------------------------------------------- */
1120 /*
1121  * Process DEC Forward Index
1122  * XTERM_SEQ: ESC 9
1123  * Move cursor right in row.  If we're at the right boundary, shift everything
1124  * in that row left.  Clear right column.
1125  */
1126 #if !ENABLE_MINIMAL
1127 void
1128 rxvt_term::scr_forwardindex () NOTHROW
1129 {
1130   if (screen.cur.col < ncol - 1)
1131     scr_gotorc (0, 1, R_RELATIVE | C_RELATIVE);
1132   else
1133     {
1134       line_t &l = ROW(screen.cur.row);
1135
1136       l.touch ();
1137       l.is_longer (0);
1138
1139       scr_gotorc (0, 0, R_RELATIVE);
1140       scr_insdel_chars (1, DELETE);
1141       scr_gotorc (0, ncol - 1, R_RELATIVE);
1142     }
1143 }
1144 #endif
1145
1146 /* ------------------------------------------------------------------------- */
1147 /*
1148  * Goto Row/Column
1149  */
1150 void
1151 rxvt_term::scr_gotorc (int row, int col, int relative) NOTHROW
1152 {
1153   want_refresh = 1;
1154   ZERO_SCROLLBACK ();
1155
1156   screen.cur.col = relative & C_RELATIVE ? screen.cur.col + col : col;
1157   clamp_it (screen.cur.col, 0, ncol - 1);
1158
1159   screen.flags &= ~Screen_WrapNext;
1160
1161   if (relative & R_RELATIVE)
1162     {
1163       if (row > 0)
1164         {
1165           if (screen.cur.row <= screen.bscroll
1166               && (screen.cur.row + row) > screen.bscroll)
1167             screen.cur.row = screen.bscroll;
1168           else
1169             screen.cur.row += row;
1170         }
1171       else if (row < 0)
1172         {
1173           if (screen.cur.row >= screen.tscroll
1174               && (screen.cur.row + row) < screen.tscroll)
1175             screen.cur.row = screen.tscroll;
1176           else
1177             screen.cur.row += row;
1178         }
1179     }
1180   else
1181     {
1182       if (screen.flags & Screen_Relative)
1183         {
1184           /* relative origin mode */
1185           screen.cur.row = row + screen.tscroll;
1186           min_it (screen.cur.row, screen.bscroll);
1187         }
1188       else
1189         screen.cur.row = row;
1190     }
1191
1192   clamp_it (screen.cur.row, 0, nrow - 1);
1193 }
1194
1195 /* ------------------------------------------------------------------------- */
1196 /*
1197  * direction should be UP or DN
1198  */
1199 void
1200 rxvt_term::scr_index (enum page_dirn direction) NOTHROW
1201 {
1202   int dirn;
1203
1204   want_refresh = 1;
1205   ZERO_SCROLLBACK ();
1206
1207   dirn = ((direction == UP) ? 1 : -1);
1208
1209   screen.flags &= ~Screen_WrapNext;
1210
1211   if ((screen.cur.row == screen.bscroll && direction == UP)
1212       || (screen.cur.row == screen.tscroll && direction == DN))
1213     scr_scroll_text (screen.tscroll, screen.bscroll, dirn);
1214   else
1215     screen.cur.row += dirn;
1216
1217   clamp_it (screen.cur.row, 0, nrow - 1);
1218   selection_check (0);
1219 }
1220
1221 /* ------------------------------------------------------------------------- */
1222 /*
1223  * Erase part or whole of a line
1224  * XTERM_SEQ: Clear line to right: ESC [ 0 K
1225  * XTERM_SEQ: Clear line to left : ESC [ 1 K
1226  * XTERM_SEQ: Clear whole line   : ESC [ 2 K
1227  * extension: clear to right unless wrapped: ESC [ 3 K
1228  */
1229 void
1230 rxvt_term::scr_erase_line (int mode) NOTHROW
1231 {
1232   unsigned int col, num;
1233
1234   want_refresh = 1;
1235   ZERO_SCROLLBACK ();
1236
1237   selection_check (1);
1238
1239   line_t &line = ROW(screen.cur.row);
1240
1241   line.touch ();
1242   line.is_longer (0);
1243
1244   switch (mode)
1245     {
1246       case 3:
1247         if (screen.flags & Screen_WrapNext)
1248           return;
1249
1250         /* fall through */
1251
1252       case 0:                     /* erase to end of line */
1253         col = screen.cur.col;
1254         num = ncol - col;
1255         min_it (line.l, col);
1256
1257         if (ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur)
1258             || ROWCOL_IN_ROW_AT_OR_AFTER (selection.end, screen.cur))
1259           CLEAR_SELECTION ();
1260         break;
1261
1262       case 1:                     /* erase to beginning of line */
1263         col = 0;
1264         num = screen.cur.col + 1;
1265
1266         if (ROWCOL_IN_ROW_AT_OR_BEFORE (selection.beg, screen.cur)
1267             || ROWCOL_IN_ROW_AT_OR_BEFORE (selection.end, screen.cur))
1268           CLEAR_SELECTION ();
1269         break;
1270
1271       case 2:                     /* erase whole line */
1272         col = 0;
1273         num = ncol;
1274         line.l = 0;
1275         if (selection.beg.row <= screen.cur.row
1276             && selection.end.row >= screen.cur.row)
1277           CLEAR_SELECTION ();
1278         break;
1279       default:
1280         return;
1281     }
1282
1283   scr_blank_line (line, col, num, rstyle);
1284 }
1285
1286 /* ------------------------------------------------------------------------- */
1287 /*
1288  * Erase part of whole of the screen
1289  * XTERM_SEQ: Clear screen after cursor : ESC [ 0 J
1290  * XTERM_SEQ: Clear screen before cursor: ESC [ 1 J
1291  * XTERM_SEQ: Clear whole screen        : ESC [ 2 J
1292  */
1293 void
1294 rxvt_term::scr_erase_screen (int mode) NOTHROW
1295 {
1296   int num;
1297   int32_t row;
1298   rend_t ren;
1299   XGCValues gcvalue;
1300
1301   want_refresh = 1;
1302   ZERO_SCROLLBACK ();
1303
1304   switch (mode)
1305     {
1306       case 0:                     /* erase to end of screen */
1307         selection_check (1);
1308         scr_erase_line (0);
1309         row = screen.cur.row + 1;    /* possible OOB */
1310         num = nrow - row;
1311         break;
1312       case 1:                     /* erase to beginning of screen */
1313         selection_check (3);
1314         scr_erase_line (1);
1315         row = 0;
1316         num = screen.cur.row;
1317         break;
1318       case 2:                     /* erase whole screen */
1319         selection_check (3);
1320         row = 0;
1321         num = nrow;
1322         break;
1323       default:
1324         return;
1325     }
1326
1327   if (selection.op && current_screen == selection.screen
1328       && ((selection.beg.row >= row && selection.beg.row <= row + num)
1329           || (selection.end.row >= row
1330               && selection.end.row <= row + num)))
1331     CLEAR_SELECTION ();
1332
1333   if (row >= nrow) /* Out Of Bounds */
1334     return;
1335
1336   min_it (num, nrow - row);
1337
1338   // TODO: the code below does not work when view_start != 0
1339   // the workaround is to disable the clear and use a normal refresh
1340   // when view_start != 0. mysterious.
1341   if (rstyle & (RS_RVid | RS_Uline))
1342     ren = (rend_t) ~RS_None;
1343   else if (GET_BASEBG (rstyle) == Color_bg)
1344     {
1345       ren = DEFAULT_RSTYLE;
1346
1347       if (mapped && !view_start)
1348         XClearArea (dpy, vt, 0,
1349                     Row2Pixel (row - view_start), (unsigned int)width,
1350                     (unsigned int)Height2Pixel (num), False);
1351     }
1352   else
1353     {
1354       ren = rstyle & (RS_fgMask | RS_bgMask);
1355
1356       if (mapped && !view_start)
1357         {
1358           gcvalue.foreground = pix_colors[bgcolor_of (rstyle)];
1359           XChangeGC (dpy, gc, GCForeground, &gcvalue);
1360           XFillRectangle (dpy, vt, gc,
1361                           0, Row2Pixel (row - view_start),
1362                           (unsigned int)width,
1363                           (unsigned int)Height2Pixel (num));
1364           gcvalue.foreground = pix_colors[Color_fg];
1365           XChangeGC (dpy, gc, GCForeground, &gcvalue);
1366         }
1367     }
1368
1369   for (; num--; row++)
1370     {
1371       scr_blank_screen_mem (ROW(row), rstyle);
1372
1373       if (!view_start)
1374         scr_blank_line (drawn_buf [row], 0, ncol, ren);
1375     }
1376 }
1377
1378 #if !ENABLE_MINIMAL
1379 void
1380 rxvt_term::scr_erase_savelines () NOTHROW
1381 {
1382   want_refresh = 1;
1383   ZERO_SCROLLBACK ();
1384
1385   top_row = 0;
1386 }
1387 #endif
1388
1389 /* ------------------------------------------------------------------------- */
1390 /*
1391  * Fill the screen with `E's
1392  * XTERM_SEQ: Screen Alignment Test: ESC # 8
1393  */
1394 void
1395 rxvt_term::scr_E () NOTHROW
1396 {
1397   rend_t fs;
1398
1399   want_refresh = 1;
1400   ZERO_SCROLLBACK ();
1401
1402   num_scr_allow = 0;
1403   selection_check (3);
1404
1405   fs = SET_FONT (rstyle, FONTSET (rstyle)->find_font ('E'));
1406   for (int row = nrow; row--; )
1407     {
1408       line_t &line = ROW(row);
1409
1410       fill_text (line.t, 'E', ncol);
1411       rend_t *r1 = line.r;
1412
1413       for (int j = ncol; j--; )
1414         *r1++ = fs;
1415
1416       line.is_longer (0);
1417       line.touch (ncol);
1418     }
1419 }
1420
1421 /* ------------------------------------------------------------------------- */
1422 /*
1423  * Insert/Delete <count> lines
1424  */
1425 void
1426 rxvt_term::scr_insdel_lines (int count, int insdel) NOTHROW
1427 {
1428   int end;
1429
1430   ZERO_SCROLLBACK ();
1431
1432   selection_check (1);
1433
1434   if (screen.cur.row > screen.bscroll)
1435     return;
1436
1437   end = screen.bscroll - screen.cur.row + 1;
1438   if (count > end)
1439     {
1440       if (insdel == DELETE)
1441         return;
1442       else if (insdel == INSERT)
1443         count = end;
1444     }
1445
1446   scr_do_wrap ();
1447
1448   scr_scroll_text (screen.cur.row, screen.bscroll, insdel * count);
1449 }
1450
1451 /* ------------------------------------------------------------------------- */
1452 /*
1453  * Insert/Delete <count> characters from the current position
1454  */
1455 void
1456 rxvt_term::scr_insdel_chars (int count, int insdel) NOTHROW
1457 {
1458   want_refresh = 1;
1459   ZERO_SCROLLBACK ();
1460
1461   if (count <= 0)
1462     return;
1463
1464   scr_do_wrap ();
1465
1466   selection_check (1);
1467   min_it (count, ncol - screen.cur.col);
1468
1469   int row = screen.cur.row;
1470
1471   line_t *line = &ROW(row);
1472
1473   line->touch ();
1474   line->is_longer (0);
1475
1476   // nuke wide spanning the start
1477   if (line->t[screen.cur.col] == NOCHAR)
1478     scr_kill_char (*line, screen.cur.col);
1479
1480   switch (insdel)
1481     {
1482       case INSERT:
1483         line->l = min (line->l + count, ncol);
1484
1485         if (line->t[screen.cur.col] == NOCHAR)
1486           scr_kill_char (*line, screen.cur.col);
1487
1488         for (int col = ncol - 1; (col - count) >= screen.cur.col; col--)
1489           {
1490             line->t[col] = line->t[col - count];
1491             line->r[col] = line->r[col - count];
1492           }
1493
1494         if (selection.op && current_screen == selection.screen
1495             && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
1496           {
1497             if (selection.end.row != screen.cur.row
1498                 || (selection.end.col + count >= ncol))
1499               CLEAR_SELECTION ();
1500             else
1501               {
1502                 /* shift selection */
1503                 selection.beg.col  += count;
1504                 selection.mark.col += count; /* XXX: yes? */
1505                 selection.end.col  += count;
1506               }
1507           }
1508
1509         scr_blank_line (*line, screen.cur.col, count, rstyle);
1510         break;
1511
1512       case ERASE:
1513         screen.cur.col += count;     /* don't worry if > ncol */
1514         selection_check (1);
1515         screen.cur.col -= count;
1516
1517         // nuke wide char after the end
1518         if (screen.cur.col + count < ncol && line->t[screen.cur.col + count] == NOCHAR)
1519           scr_kill_char (*line, screen.cur.col + count);
1520
1521         scr_blank_line (*line, screen.cur.col, count, rstyle);
1522         break;
1523
1524       case DELETE:
1525         line->l = max (line->l - count, 0);
1526
1527         // nuke wide char spanning the end
1528         if (screen.cur.col + count < ncol && line->t[screen.cur.col + count] == NOCHAR)
1529           scr_kill_char (*line, screen.cur.col + count);
1530
1531         for (int col = screen.cur.col; (col + count) < ncol; col++)
1532           {
1533             line->t[col] = line->t[col + count];
1534             line->r[col] = line->r[col + count];
1535           }
1536
1537         scr_blank_line (*line, ncol - count, count, rstyle);
1538
1539         if (selection.op && current_screen == selection.screen
1540             && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
1541           {
1542             if (selection.end.row != screen.cur.row
1543                 || (screen.cur.col >= selection.beg.col - count)
1544                 || selection.end.col >= ncol)
1545               CLEAR_SELECTION ();
1546             else
1547               {
1548                 /* shift selection */
1549                 selection.beg.col  -= count;
1550                 selection.mark.col -= count; /* XXX: yes? */
1551                 selection.end.col  -= count;
1552               }
1553           }
1554
1555         break;
1556     }
1557 }
1558
1559 /* ------------------------------------------------------------------------- */
1560 /*
1561  * Set the scrolling region
1562  * XTERM_SEQ: Set region <top> - <bot> inclusive: ESC [ <top> ; <bot> r
1563  */
1564 void
1565 rxvt_term::scr_scroll_region (int top, int bot) NOTHROW
1566 {
1567   max_it (top, 0);
1568   min_it (bot, nrow - 1);
1569
1570   if (top > bot)
1571     return;
1572
1573   screen.tscroll = top;
1574   screen.bscroll = bot;
1575   scr_gotorc (0, 0, 0);
1576 }
1577
1578 /* ------------------------------------------------------------------------- */
1579 /*
1580  * Make the cursor visible/invisible
1581  * XTERM_SEQ: Make cursor visible  : ESC [ ? 25 h
1582  * XTERM_SEQ: Make cursor invisible: ESC [ ? 25 l
1583  */
1584 void
1585 rxvt_term::scr_cursor_visible (int mode) NOTHROW
1586 {
1587   want_refresh = 1;
1588
1589   if (mode)
1590     screen.flags |= Screen_VisibleCursor;
1591   else
1592     screen.flags &= ~Screen_VisibleCursor;
1593 }
1594
1595 /* ------------------------------------------------------------------------- */
1596 /*
1597  * Set/unset automatic wrapping
1598  * XTERM_SEQ: Set Wraparound  : ESC [ ? 7 h
1599  * XTERM_SEQ: Unset Wraparound: ESC [ ? 7 l
1600  */
1601 void
1602 rxvt_term::scr_autowrap (int mode) NOTHROW
1603 {
1604   if (mode)
1605     screen.flags |= Screen_Autowrap;
1606   else
1607     screen.flags &= ~(Screen_Autowrap | Screen_WrapNext);
1608 }
1609
1610 /* ------------------------------------------------------------------------- */
1611 /*
1612  * Set/unset margin origin mode
1613  * Absolute mode: line numbers are counted relative to top margin of screen
1614  *      and the cursor can be moved outside the scrolling region.
1615  * Relative mode: line numbers are relative to top margin of scrolling region
1616  *      and the cursor cannot be moved outside.
1617  * XTERM_SEQ: Set Absolute: ESC [ ? 6 h
1618  * XTERM_SEQ: Set Relative: ESC [ ? 6 l
1619  */
1620 void
1621 rxvt_term::scr_relative_origin (int mode) NOTHROW
1622 {
1623   if (mode)
1624     screen.flags |= Screen_Relative;
1625   else
1626     screen.flags &= ~Screen_Relative;
1627
1628   scr_gotorc (0, 0, 0);
1629 }
1630
1631 /* ------------------------------------------------------------------------- */
1632 /*
1633  * Set insert/replace mode
1634  * XTERM_SEQ: Set Insert mode : ESC [ ? 4 h
1635  * XTERM_SEQ: Set Replace mode: ESC [ ? 4 l
1636  */
1637 void
1638 rxvt_term::scr_insert_mode (int mode) NOTHROW
1639 {
1640   if (mode)
1641     screen.flags |= Screen_Insert;
1642   else
1643     screen.flags &= ~Screen_Insert;
1644 }
1645
1646 /* ------------------------------------------------------------------------- */
1647 /*
1648  * Set/Unset tabs
1649  * XTERM_SEQ: Set tab at current column  : ESC H
1650  * XTERM_SEQ: Clear tab at current column: ESC [ 0 g
1651  * XTERM_SEQ: Clear all tabs             : ESC [ 3 g
1652  */
1653 void
1654 rxvt_term::scr_set_tab (int mode) NOTHROW
1655 {
1656   if (mode < 0)
1657     memset (tabs, 0, ncol);
1658   else if (screen.cur.col < ncol)
1659     tabs [screen.cur.col] = !!mode;
1660 }
1661
1662 /* ------------------------------------------------------------------------- */
1663 /*
1664  * Set reverse/normal video
1665  * XTERM_SEQ: Reverse video: ESC [ ? 5 h
1666  * XTERM_SEQ: Normal video : ESC [ ? 5 l
1667  */
1668 void
1669 rxvt_term::scr_rvideo_mode (bool on) NOTHROW
1670 {
1671   rvideo_mode = on;
1672
1673 #ifndef NO_BELL
1674   on ^= rvideo_bell;
1675 #endif
1676
1677   if (rvideo_state != on)
1678     {
1679       rvideo_state = on;
1680
1681       ::swap (pix_colors[Color_fg], pix_colors[Color_bg]);
1682 #ifdef HAVE_BG_PIXMAP
1683       if (bgPixmap.pixmap == None)
1684 #endif
1685           XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
1686
1687       XGCValues gcvalue;
1688       gcvalue.foreground = pix_colors[Color_fg];
1689       gcvalue.background = pix_colors[Color_bg];
1690       XChangeGC (dpy, gc, GCBackground | GCForeground, &gcvalue);
1691
1692       scr_clear ();
1693       scr_touch (true);
1694     }
1695 }
1696
1697 /* ------------------------------------------------------------------------- */
1698 /*
1699  * Report current cursor position
1700  * XTERM_SEQ: Report position: ESC [ 6 n
1701  */
1702 void
1703 rxvt_term::scr_report_position () NOTHROW
1704 {
1705   tt_printf ("\033[%d;%dR", screen.cur.row + 1, screen.cur.col + 1);
1706 }
1707 \f
1708 /* ------------------------------------------------------------------------- *
1709  *                                  FONTS                                    *
1710  * ------------------------------------------------------------------------- */
1711
1712 /*
1713  * Set font style
1714  */
1715 void
1716 rxvt_term::set_font_style () NOTHROW
1717 {
1718 #if 0
1719   switch (charsets [screen.charset])
1720     {
1721       case '0':                   /* DEC Special Character & Line Drawing Set */
1722         break;
1723       case 'A':                   /* United Kingdom (UK) */
1724         break;
1725       case 'B':                   /* United States (USASCII) */
1726         break;
1727       case '<':                   /* Multinational character set */
1728         break;
1729       case '5':                   /* Finnish character set */
1730         break;
1731       case 'C':                   /* Finnish character set */
1732         break;
1733       case 'K':                   /* German character set */
1734         break;
1735     }
1736 #endif
1737 }
1738
1739 /* ------------------------------------------------------------------------- */
1740 /*
1741  * Choose a font
1742  * XTERM_SEQ: Invoke G0 character set: CTRL-O
1743  * XTERM_SEQ: Invoke G1 character set: CTRL-N
1744  * XTERM_SEQ: Invoke G2 character set: ESC N
1745  * XTERM_SEQ: Invoke G3 character set: ESC O
1746  */
1747 void
1748 rxvt_term::scr_charset_choose (int set) NOTHROW
1749 {
1750   screen.charset = set;
1751   set_font_style ();
1752 }
1753
1754 /* ------------------------------------------------------------------------- */
1755 /*
1756  * Set a font
1757  * XTERM_SEQ: Set G0 character set: ESC ( <C>
1758  * XTERM_SEQ: Set G1 character set: ESC ) <C>
1759  * XTERM_SEQ: Set G2 character set: ESC * <C>
1760  * XTERM_SEQ: Set G3 character set: ESC + <C>
1761  * See set_font_style for possible values for <C>
1762  */
1763 void
1764 rxvt_term::scr_charset_set (int set, unsigned int ch) NOTHROW
1765 {
1766   charsets[set] = (unsigned char)ch;
1767   set_font_style ();
1768 }
1769
1770 \f
1771 /* ------------------------------------------------------------------------- *
1772  *                        MAJOR SCREEN MANIPULATION                          *
1773  * ------------------------------------------------------------------------- */
1774
1775 /*
1776  * refresh matching text.
1777  */
1778 bool
1779 rxvt_term::scr_refresh_rend (rend_t mask, rend_t value) NOTHROW
1780 {
1781   bool found = false;
1782
1783   for (int i = 0; i < nrow; i++)
1784     {
1785       rend_t *drp = drawn_buf[i].r;
1786
1787       for (int col = 0; col < ncol; col++, drp++)
1788         if ((*drp & mask) == value)
1789           {
1790             found = true;
1791             *drp = ~value;
1792           }
1793     }
1794
1795   return found;
1796 }
1797
1798 /*
1799  * Refresh an area
1800  */
1801 enum {
1802   PART_BEG = 0,
1803   PART_END,
1804   RC_COUNT
1805 };
1806
1807 void
1808 rxvt_term::scr_expose (int x, int y, int ewidth, int eheight, bool refresh) NOTHROW
1809 {
1810   int i;
1811   row_col_t rc[RC_COUNT];
1812
1813   if (!drawn_buf)  /* sanity check */
1814     return;
1815
1816 #ifndef NO_SLOW_LINK_SUPPORT
1817   if (refresh_type == FAST_REFRESH && !display->is_local)
1818     {
1819       y = 0;
1820       eheight = height;
1821     }
1822 #endif
1823
1824   /* round down */
1825   rc[PART_BEG].col = Pixel2Col (x);
1826   rc[PART_BEG].row = Pixel2Row (y);
1827   /* round up */
1828   rc[PART_END].col = Pixel2Width (x + ewidth  + fwidth  - 1);
1829   rc[PART_END].row = Pixel2Row   (y + eheight + fheight - 1);
1830
1831   /* sanity checks */
1832   for (i = PART_BEG; i < RC_COUNT; i++)
1833     {
1834       min_it (rc[i].col, ncol - 1);
1835       min_it (rc[i].row, nrow - 1);
1836     }
1837 // TODO: this line somehow causes segfault if scr_expose() is called just after resize
1838   for (i = rc[PART_BEG].row; i <= rc[PART_END].row; i++)
1839     fill_text (&drawn_buf[i].t[rc[PART_BEG].col], 0, rc[PART_END].col - rc[PART_BEG].col + 1);
1840
1841   num_scr_allow = 0;
1842
1843   if (refresh)
1844     scr_refresh ();
1845 }
1846
1847 /* ------------------------------------------------------------------------- */
1848 /*
1849  * Refresh the entire screen
1850  */
1851 void
1852 rxvt_term::scr_touch (bool refresh) NOTHROW
1853 {
1854   scr_expose (0, 0, width, height, refresh);
1855 }
1856
1857 /* ------------------------------------------------------------------------- */
1858 /*
1859  * Move the display so that the line represented by scrollbar value Y is at
1860  * the top of the screen
1861  */
1862 void
1863 rxvt_term::scr_move_to (int y, int len) NOTHROW
1864 {
1865   scr_changeview ((top_row - nrow) * (len - y) / len + (nrow - 1));
1866 }
1867
1868 /* ------------------------------------------------------------------------- */
1869 /*
1870  * Page the screen up/down nlines
1871  * direction should be UP or DN
1872  */
1873 bool
1874 rxvt_term::scr_page (enum page_dirn direction, int nlines) NOTHROW
1875 {
1876   int new_view_start =
1877     direction == UP ? view_start - nlines
1878                     : view_start + nlines;
1879
1880   return scr_changeview (new_view_start);
1881 }
1882
1883 bool
1884 rxvt_term::scr_changeview (int new_view_start) NOTHROW
1885 {
1886   clamp_it (new_view_start, top_row, 0);
1887
1888   if (new_view_start == view_start)
1889     return false;
1890
1891   num_scr += new_view_start - view_start;
1892   view_start = new_view_start;
1893   want_refresh = 1;
1894
1895   HOOK_INVOKE ((this, HOOK_VIEW_CHANGE, DT_INT, view_start, DT_END));
1896
1897   return true;
1898 }
1899
1900 #ifndef NO_BELL
1901 void
1902 rxvt_term::bell_cb (ev::timer &w, int revents)
1903 {
1904   rvideo_bell = false;
1905   scr_rvideo_mode (rvideo_mode);
1906   refresh_check ();
1907 }
1908 #endif
1909
1910 /* ------------------------------------------------------------------------- */
1911 void
1912 rxvt_term::scr_bell () NOTHROW
1913 {
1914 #ifndef NO_BELL
1915
1916 # ifndef NO_MAPALERT
1917 #  ifdef MAPALERT_OPTION
1918   if (option (Opt_mapAlert))
1919 #  endif
1920     XMapWindow (dpy, parent[0]);
1921 # endif
1922
1923 # if ENABLE_FRILLS
1924   if (option (Opt_urgentOnBell))
1925     set_urgency (1);
1926 # endif
1927
1928   if (option (Opt_visualBell))
1929     {
1930       rvideo_bell = true;
1931       scr_rvideo_mode (rvideo_mode);
1932       flush ();
1933
1934       bell_ev.start (VISUAL_BELL_DURATION);
1935     }
1936   else
1937     XBell (dpy, 0);
1938   HOOK_INVOKE ((this, HOOK_BELL, DT_END));
1939 #endif
1940 }
1941
1942 /* ------------------------------------------------------------------------- */
1943 /* ARGSUSED */
1944 void
1945 rxvt_term::scr_printscreen (int fullhist) NOTHROW
1946 {
1947 #ifdef PRINTPIPE
1948   int nrows, row_start;
1949   FILE *fd = popen_printer ();
1950
1951   if (!fd)
1952     return;
1953
1954   if (fullhist)
1955     {
1956       nrows = nrow - top_row;
1957       row_start = top_row;
1958     }
1959   else
1960     {
1961       nrows = nrow;
1962       row_start = view_start;
1963     }
1964
1965   wctomb (0, 0);
1966
1967   for (int r1 = row_start; r1 < row_start + nrows; r1++)
1968     {
1969       text_t *tp = ROW(r1).t;
1970       int len    = ROW(r1).l;
1971
1972       for (int i = len >= 0 ? len : ncol - 1; i--; ) //TODO//FIXME//LEN
1973         {
1974           char mb[MB_LEN_MAX];
1975           text_t t = *tp++;
1976           if (t == NOCHAR)
1977             continue;
1978
1979           len = wctomb (mb, t);
1980
1981           if (len <= 0)
1982             {
1983               mb[0] = ' ';
1984               len = 1;
1985             }
1986
1987           fwrite (mb, 1, len, fd);
1988         }
1989
1990       fputc ('\n', fd);
1991     }
1992
1993   pclose_printer (fd);
1994 #endif
1995 }
1996
1997 /* ------------------------------------------------------------------------- */
1998 /*
1999  * Refresh the screen
2000  * drawn_text/drawn_rend contain the screen information before the update.
2001  * screen.text/screen.rend contain what the screen will change to.
2002  */
2003 void
2004 rxvt_term::scr_refresh () NOTHROW
2005 {
2006   int16_t col, row,   /* column/row we're processing               */
2007           ocrow;      /* old cursor row                            */
2008   int i;              /* tmp                                       */
2009 #ifndef NO_CURSORCOLOR
2010   rend_t cc1;         /* store colours at cursor position (s)      */
2011 #endif
2012   rend_t *crp;        // cursor rendition pointer
2013   rend_t ccol1,  /* Cursor colour       */
2014          ccol2;  /* Cursor colour2      */
2015
2016   want_refresh = 0;        /* screen is current */
2017
2018   if (refresh_type == NO_REFRESH || !mapped)
2019     return;
2020
2021   /*
2022    * A: set up vars
2023    */
2024   refresh_count = 0;
2025
2026   unsigned int old_screen_flags = screen.flags;
2027   char have_bg = 0;
2028 #ifdef HAVE_BG_PIXMAP
2029   have_bg = bgPixmap.pixmap != None;
2030 #endif
2031   ocrow = oldcursor.row; /* is there an old outline cursor on screen? */
2032
2033   /*
2034    * B: reverse any characters which are selected
2035    */
2036   scr_reverse_selection ();
2037
2038   HOOK_INVOKE ((this, HOOK_REFRESH_BEGIN, DT_END));
2039 #if ENABLE_OVERLAY
2040   scr_swap_overlay ();
2041 #endif
2042
2043   char showcursor = screen.flags & Screen_VisibleCursor;
2044
2045   /*
2046    * C: set the cursor character (s)
2047    */
2048   {
2049     unsigned char setoldcursor;
2050
2051 #ifdef CURSOR_BLINK
2052     if (hidden_cursor)
2053       showcursor = 0;
2054 #endif
2055
2056     if (showcursor)
2057       {
2058         int col = screen.cur.col;
2059
2060         while (col && ROW(screen.cur.row).t[col] == NOCHAR)
2061           col--;
2062
2063         crp = &ROW(screen.cur.row).r[col];
2064
2065 #ifndef NO_CURSORCOLOR
2066         cc1 = *crp & (RS_fgMask | RS_bgMask);
2067         if (ISSET_PIXCOLOR (Color_cursor))
2068           ccol1 = Color_cursor;
2069         else
2070 #endif
2071 #ifdef CURSOR_COLOR_IS_RENDITION_COLOR
2072           ccol1 = fgcolor_of (rstyle);
2073 #else
2074           ccol1 = Color_fg;
2075 #endif
2076
2077 #ifndef NO_CURSORCOLOR
2078         if (ISSET_PIXCOLOR (Color_cursor2))
2079           ccol2 = Color_cursor2;
2080         else
2081 #endif
2082 #ifdef CURSOR_COLOR_IS_RENDITION_COLOR
2083           ccol2 = bgcolor_of (rstyle);
2084 #else
2085           ccol2 = Color_bg;
2086 #endif
2087
2088         if (showcursor && focus)
2089           {
2090             if (option (Opt_cursorUnderline))
2091               *crp ^= RS_Uline;
2092             else
2093               {
2094                 *crp ^= RS_RVid;
2095                 *crp = SET_FGCOLOR (*crp, ccol1);
2096                 *crp = SET_BGCOLOR (*crp, ccol2);
2097               }
2098           }
2099       }
2100
2101     /* make sure no outline cursor is left around */
2102     setoldcursor = 0;
2103     if (ocrow != -1)
2104       {
2105         if (screen.cur.row - view_start != ocrow
2106             || screen.cur.col != oldcursor.col)
2107           {
2108             if (ocrow < nrow
2109                 && oldcursor.col < ncol)
2110               drawn_buf[ocrow].r[oldcursor.col] ^= (RS_RVid | RS_Uline);
2111
2112             if (focus || !showcursor)
2113               oldcursor.row = -1;
2114             else
2115               setoldcursor = 1;
2116           }
2117       }
2118     else if (!focus)
2119       setoldcursor = 1;
2120
2121     if (setoldcursor)
2122       {
2123         if (screen.cur.row - view_start >= nrow)
2124           oldcursor.row = -1;
2125         else
2126           {
2127             oldcursor.row = screen.cur.row - view_start;
2128             oldcursor.col = screen.cur.col;
2129           }
2130       }
2131   }
2132
2133 #ifndef NO_SLOW_LINK_SUPPORT
2134   /*
2135    * D: CopyArea pass - very useful for slower links
2136    *    This has been deliberately kept simple.
2137    */
2138   if (!display->is_local
2139       && refresh_type == FAST_REFRESH && num_scr_allow && num_scr
2140       && abs (num_scr) < nrow && !have_bg)
2141     {
2142       int16_t nits;
2143       int i = num_scr;
2144       int j;
2145       int len, wlen;
2146       dLocal (int, num_scr);
2147
2148       j = nrow;
2149       wlen = len = -1;
2150       row = i > 0 ? 0 : j - 1;
2151
2152       for (; j-- >= 0; row += (i > 0 ? 1 : -1))
2153         {
2154           if (row + i >= 0 && row + i < nrow && row + i != ocrow)
2155             {
2156               line_t s  = ROW(view_start + row);
2157               line_t d  = drawn_buf[row];
2158               line_t d2 = drawn_buf[row + i];
2159
2160               for (nits = 0, col = ncol; col--; )
2161                 if (s.t[col] != d2.t[col] || s.r[col] != d2.r[col])
2162                   nits--;
2163                 else if (s.t[col] != d.t[col] || s.r[col] != d.r[col])
2164                   nits++;
2165
2166               if (nits > 8) /* XXX: arbitrary choice */
2167                 {
2168                   for (col = ncol; col--; )
2169                     {
2170                       *d.t++ = *d2.t++;
2171                       *d.r++ = *d2.r++;
2172                     }
2173
2174                   if (len == -1)
2175                     len = row;
2176
2177                   wlen = row;
2178                   continue;
2179                 }
2180             }
2181
2182           if (len >= 0)
2183             {
2184               /* also comes here at end if needed because of >= above */
2185               if (wlen < len)
2186                 ::swap (wlen, len);
2187
2188               XGCValues gcv;
2189
2190               gcv.graphics_exposures = 1; XChangeGC (dpy, gc, GCGraphicsExposures, &gcv);
2191               XCopyArea (dpy, vt, vt,
2192                          gc, 0, Row2Pixel (len + i),
2193                          (unsigned int)this->width,
2194                          (unsigned int)Height2Pixel (wlen - len + 1),
2195                          0, Row2Pixel (len));
2196               gcv.graphics_exposures = 0; XChangeGC (dpy, gc, GCGraphicsExposures, &gcv);
2197
2198               len = -1;
2199             }
2200         }
2201     }
2202 #endif
2203
2204   /*
2205    * E: main pass across every character
2206    */
2207   for (row = 0; row < nrow; row++)
2208     {
2209       text_t *stp = ROW(view_start + row).t;
2210       rend_t *srp = ROW(view_start + row).r;
2211       text_t *dtp = drawn_buf[row].t;
2212       rend_t *drp = drawn_buf[row].r;
2213
2214       /*
2215        * E2: OK, now the real pass
2216        */
2217       int ypixel = (int)Row2Pixel (row);
2218
2219       for (col = 0; col < ncol; col++)
2220         {
2221           /* compare new text with old - if exactly the same then continue */
2222           if (stp[col] == dtp[col]    /* Must match characters to skip. */
2223               && (RS_SAME (srp[col], drp[col])    /* Either rendition the same or   */
2224                   || (stp[col] == ' ' /* space w/ no background change  */
2225                       && GET_BGATTR (srp[col]) == GET_BGATTR (drp[col]))))
2226             continue;
2227
2228           // redraw one or more characters
2229
2230           // seek to the beginning of wide characters
2231           while (expect_false (stp[col] == NOCHAR && col > 0))
2232             --col;
2233
2234           rend_t rend = srp[col];     /* screen rendition (target rendtion) */
2235           text_t *text = stp + col;
2236           int count = 1;
2237
2238           dtp[col] = stp[col];
2239           drp[col] = rend;
2240
2241           int xpixel = Col2Pixel (col);
2242
2243           for (i = 0; ++col < ncol; )
2244             {
2245               if (stp[col] == NOCHAR)
2246                 {
2247                   dtp[col] = stp[col];
2248                   drp[col] = srp[col];
2249
2250                   count++;
2251                   i++;
2252
2253                   continue;
2254                 }
2255
2256               if (!RS_SAME (rend, srp[col]))
2257                 break;
2258
2259               count++;
2260
2261               if (stp[col] != dtp[col]
2262                   || !RS_SAME (srp[col], drp[col]))
2263                 {
2264                   if (have_bg && (i++ > count / 2))
2265                     break;
2266
2267                   dtp[col] = stp[col];
2268                   drp[col] = rend;
2269                   i = 0;
2270                 }
2271               else if (have_bg || (stp[col] != ' ' && ++i >= 16))
2272                 break;
2273             }
2274
2275           col--;      /* went one too far.  move back */
2276           count -= i; /* dump any matching trailing chars */
2277
2278           // sometimes we optimize away the trailing NOCHAR's, add them back
2279           while (expect_false (i && text[count] == NOCHAR))
2280             count++, i--;
2281
2282           /*
2283            * Determine the attributes for the string
2284            */
2285           int fore = fgcolor_of (rend); // desired foreground
2286           int back = bgcolor_of (rend); // desired background
2287
2288           // only do special processing if any attributes are set, which is unlikely
2289           if (expect_false (rend & (RS_Bold | RS_Italic | RS_Uline | RS_RVid | RS_Blink | RS_Careful)))
2290             {
2291               bool invert = rend & RS_RVid;
2292
2293 #ifndef NO_BOLD_UNDERLINE_REVERSE
2294               if (rend & RS_Bold && fore == Color_fg)
2295                 {
2296                   if (ISSET_PIXCOLOR (Color_BD))
2297                     fore = Color_BD;
2298 # if !ENABLE_STYLES
2299                   else
2300                     invert = !invert;
2301 # endif
2302                 }
2303
2304               if (rend & RS_Italic && fore == Color_fg)
2305                 {
2306                   if (ISSET_PIXCOLOR (Color_IT))
2307                     fore = Color_IT;
2308 # if !ENABLE_STYLES
2309                   else
2310                     invert = !invert;
2311 # endif
2312                 }
2313
2314               if (rend & RS_Uline && fore == Color_fg && ISSET_PIXCOLOR (Color_UL))
2315                 fore = Color_UL;
2316 #endif
2317
2318               if (invert)
2319                 {
2320 #ifdef OPTION_HC
2321                   if ((showcursor && row == screen.cur.row && text - stp == screen.cur.col)
2322                       || !ISSET_PIXCOLOR (Color_HC))
2323 #endif
2324                     /* invert the column if no highlightColor is set or it is the
2325                      * current cursor column */
2326                     ::swap (fore, back);
2327 #ifdef OPTION_HC
2328                   else if (ISSET_PIXCOLOR (Color_HC))
2329                     back = Color_HC;
2330 #endif
2331
2332 #ifndef NO_BOLD_UNDERLINE_REVERSE
2333 # ifndef OPTION_HC
2334                   if (ISSET_PIXCOLOR (Color_RV))
2335                     back = Color_RV;
2336 # endif
2337                   if (fore == back)
2338                     {
2339                       fore = Color_bg;
2340                       back = Color_fg;
2341                     }
2342 #endif
2343                 }
2344
2345 #ifdef TEXT_BLINK
2346               if (rend & RS_Blink && (back == Color_bg || fore == Color_bg))
2347                 {
2348                   if (!text_blink_ev.is_active ())
2349                     {
2350                       text_blink_ev.again ();
2351                       hidden_text = 0;
2352                     }
2353                   else if (hidden_text)
2354                     fore = back;
2355                 }
2356 #endif
2357
2358 #if ENABLE_STYLES
2359               // "careful" (too wide) character handling
2360
2361               // include previous careful character(s) if possible, looks nicer (best effort...)
2362               while (text > stp
2363                   && srp[text - stp - 1] & RS_Careful
2364                   && RS_SAME (rend, srp[text - stp - 1]))
2365                 text--, count++, xpixel -= fwidth;
2366
2367               // force redraw after "careful" characters to avoid pixel droppings
2368               for (int i = 0; srp[col + i] & RS_Careful && col + i < ncol - 1; i++)
2369                 drp[col + i + 1] = srp[col + i + 1] ^ RS_redraw;
2370
2371               // force redraw before "careful" characters to avoid pixel droppings
2372               for (int i = 0; srp[text - stp - i] & RS_Careful && text - i > stp; i++)
2373                 drp[text - stp - i - 1] = srp[text - stp - i - 1] ^ RS_redraw;
2374 #endif
2375             }
2376
2377           /*
2378            * Actually do the drawing of the string here
2379            */
2380           rxvt_font *font = (*fontset[GET_STYLE (rend)])[GET_FONT (rend)];
2381
2382           if (expect_true (have_bg && back == Color_bg))
2383             {
2384               // this is very ugly, maybe push it into ->draw?
2385
2386               for (i = 0; i < count; i++) /* don't draw empty strings */
2387                 if (text[i] != ' ')
2388                   {
2389                     font->draw (*drawable, xpixel, ypixel, text, count, fore, Color_transparent);
2390                     goto did_clear;
2391                   }
2392
2393               CLEAR_CHARS (xpixel, ypixel, count);
2394               did_clear: ;
2395             }
2396           else
2397             font->draw (*drawable, xpixel, ypixel, text, count, fore, back);
2398
2399           if (expect_false (rend & RS_Uline && font->descent > 1 && fore != back))
2400             {
2401 #if ENABLE_FRILLS
2402               if (ISSET_PIXCOLOR (Color_underline))
2403                 XSetForeground (dpy, gc, pix_colors[Color_underline]);
2404               else
2405 #endif
2406                 XSetForeground (dpy, gc, pix_colors[fore]);
2407
2408               XDrawLine (dpy, vt, gc,
2409                          xpixel, ypixel + font->ascent + 1,
2410                          xpixel + Width2Pixel (count) - 1, ypixel + font->ascent + 1);
2411             }
2412         }                     /* for (col....) */
2413     }                         /* for (row....) */
2414
2415   /*
2416    * G: cleanup cursor and display outline cursor if necessary
2417    */
2418   if (showcursor)
2419     {
2420       if (focus)
2421         {
2422           if (option (Opt_cursorUnderline))
2423             *crp ^= RS_Uline;
2424           else
2425             {
2426               *crp ^= RS_RVid;
2427 #ifndef NO_CURSORCOLOR
2428               *crp = (*crp & ~ (RS_fgMask | RS_bgMask)) | cc1;
2429 #endif
2430             }
2431         }
2432       else if (oldcursor.row >= 0)
2433         {
2434           int cursorwidth = 1;
2435           int col = oldcursor.col;
2436
2437           while (col && ROW(screen.cur.row).t[col] == NOCHAR)
2438             col--;
2439
2440           while (col + cursorwidth < ncol
2441                  && drawn_buf[oldcursor.row].t[col + cursorwidth] == NOCHAR)
2442             cursorwidth++;
2443
2444 #ifndef NO_CURSORCOLOR
2445           if (ISSET_PIXCOLOR (Color_cursor))
2446             XSetForeground (dpy, gc, pix_colors[Color_cursor]);
2447           else
2448 #endif
2449             XSetForeground (dpy, gc, pix_colors[ccol1]);
2450
2451           XDrawRectangle (dpy, vt, gc,
2452                           Col2Pixel (col),
2453                           Row2Pixel (oldcursor.row),
2454                           (unsigned int) (Width2Pixel (cursorwidth) - 1),
2455                           (unsigned int) (Height2Pixel (1) - lineSpace - 1));
2456         }
2457     }
2458
2459   /*
2460    * H: cleanup selection
2461    */
2462 #if ENABLE_OVERLAY
2463   scr_swap_overlay ();
2464 #endif
2465   HOOK_INVOKE ((this, HOOK_REFRESH_END, DT_END));
2466
2467   scr_reverse_selection ();
2468
2469   screen.flags = old_screen_flags;
2470   num_scr = 0;
2471   num_scr_allow = 1;
2472 }
2473
2474 void
2475 rxvt_term::scr_remap_chars (line_t &l) NOTHROW
2476 {
2477   if (!l.t)
2478     return;
2479
2480   l.touch (); // maybe a bit of an overkill, but it's not performance-relevant
2481
2482   for (int i = ncol; i--; )
2483     l.r[i] = SET_FONT (l.r[i], FONTSET (l.r[i])->find_font (l.t[i]));
2484 }
2485
2486 void
2487 rxvt_term::scr_remap_chars () NOTHROW
2488 {
2489   for (int i = total_rows; i--; )
2490     scr_remap_chars (row_buf [i]);
2491
2492   for (int i = nrow; i--; )
2493     {
2494       scr_remap_chars (drawn_buf [i]);
2495       scr_remap_chars (swap_buf [i]);
2496     }
2497 }
2498
2499 void
2500 rxvt_term::scr_recolour () NOTHROW
2501 {
2502 #ifdef HAVE_BG_PIXMAP
2503   bgPixmap.apply ();
2504 #else
2505
2506   XSetWindowBackground (dpy, parent[0], pix_colors[Color_border]);
2507   XClearWindow (dpy, parent[0]);
2508   XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
2509
2510   if (scrollBar.win)
2511    {
2512      XSetWindowBackground (dpy, scrollBar.win, pix_colors[Color_border]);
2513      scrollBar.state = STATE_IDLE;
2514      scrollBar.show (0);
2515    }
2516
2517 #endif
2518
2519   /* bgPixmap.apply () does not do the following : */
2520   scr_clear ();
2521   scr_touch (true);
2522   want_refresh = 1;
2523 }
2524
2525 /* ------------------------------------------------------------------------- */
2526 void
2527 rxvt_term::scr_clear (bool really) NOTHROW
2528 {
2529   if (!mapped)
2530     return;
2531
2532   num_scr_allow = 0;
2533   want_refresh = 1;
2534
2535   if (really)
2536     XClearWindow (dpy, vt);
2537 }
2538
2539 void
2540 rxvt_term::scr_xor_rect (int beg_row, int beg_col, int end_row, int end_col, rend_t rstyle1, rend_t rstyle2) NOTHROW
2541 {
2542   int view_end = view_start + nrow;
2543   int row, col;
2544
2545   for (row = max (beg_row, view_start); row <= min (end_row, view_end); row++)
2546     {
2547       text_t *stp = ROW(row).t;
2548       rend_t *srp = ROW(row).r;
2549
2550       for (col = beg_col; col < end_col; col++)
2551         srp[col] ^= rstyle1;
2552
2553       while (col-- > beg_col && (stp[col] == NOCHAR || unicode::is_space (stp[col])))
2554         srp[col] ^= rstyle2;
2555
2556       if (++col < end_col)
2557         srp[col] ^= rstyle2;
2558     }
2559 }
2560
2561 void
2562 rxvt_term::scr_xor_span (int beg_row, int beg_col, int end_row, int end_col, rend_t rstyle) NOTHROW
2563 {
2564   int view_end = view_start + nrow;
2565   int row, col;
2566
2567   if (beg_row >= view_start)
2568     {
2569       col = beg_col;
2570       row = beg_row;
2571     }
2572   else
2573     {
2574       col = 0;
2575       row = view_start;
2576     }
2577
2578   for (; row < min (end_row, view_end); row++, col = 0)
2579     for (rend_t *srp = ROW(row).r; col < ncol; col++)
2580       srp[col] ^= rstyle;
2581
2582   if (row == end_row)
2583     for (rend_t *srp = ROW(row).r; col < end_col; col++)
2584       srp[col] ^= rstyle;
2585 }
2586
2587 /* ------------------------------------------------------------------------- */
2588 void
2589 rxvt_term::scr_reverse_selection () NOTHROW
2590 {
2591   if (selection.op
2592       && current_screen == selection.screen
2593       && selection.end.row >= view_start)
2594     {
2595 #if !ENABLE_MINIMAL
2596       if (selection.rect)
2597         scr_xor_rect (selection.beg.row, selection.beg.col,
2598                       selection.end.row, selection.end.col,
2599                       RS_RVid, RS_RVid | RS_Uline);
2600       else
2601 #endif
2602         scr_xor_span (selection.beg.row, selection.beg.col,
2603                       selection.end.row, selection.end.col,
2604                       RS_RVid);
2605     }
2606 }
2607
2608 /* ------------------------------------------------------------------------- */
2609 /*
2610  * Dump the whole scrollback and screen to the passed filedescriptor.  The
2611  * invoking routine must close the fd.
2612  */
2613 #if 0
2614 void
2615 rxvt_term::scr_dump (int fd) NOTHROW
2616 {
2617   int             row, wrote;
2618   unsigned int    width, towrite;
2619   char            r1[] = "\n";
2620
2621   for (row = saveLines + top_row;
2622        row < saveLines + nrow - 1; row++)
2623     {
2624       width = row_buf[row].l >= 0 ? row_buf[row].l
2625               : ncol;
2626       for (towrite = width; towrite; towrite -= wrote)
2627         {
2628           wrote = write (fd, & (row_buf[row].t[width - towrite]),
2629                         towrite);
2630           if (wrote < 0)
2631             return;         /* XXX: death, no report */
2632         }
2633       if (row_buf[row].l >= 0)
2634         if (write (fd, r1, 1) <= 0)
2635           return; /* XXX: death, no report */
2636     }
2637 }
2638 #endif
2639 \f
2640 /* ------------------------------------------------------------------------- *
2641  *                           CHARACTER SELECTION                             *
2642  * ------------------------------------------------------------------------- */
2643 void
2644 rxvt_term::selection_check (int check_more) NOTHROW
2645 {
2646   row_col_t pos;
2647
2648   if (!selection.op)
2649     return;
2650
2651   pos.row = pos.col = 0;
2652   if (!IN_RANGE_EXC (selection.beg.row, top_row, nrow)
2653       || !IN_RANGE_EXC (selection.mark.row, top_row, nrow)
2654       || !IN_RANGE_EXC (selection.end.row, top_row, nrow)
2655       || (check_more == 1
2656           && current_screen == selection.screen
2657           && !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
2658           && ROWCOL_IS_BEFORE (screen.cur, selection.end))
2659       || (check_more == 2
2660           && ROWCOL_IS_BEFORE (selection.beg, pos)
2661           && ROWCOL_IS_AFTER (selection.end, pos))
2662       || (check_more == 3
2663           && ROWCOL_IS_AFTER (selection.end, pos))
2664       || (check_more == 4     /* screen width change */
2665           && (selection.beg.row != selection.end.row
2666               || selection.end.col > ncol)))
2667     CLEAR_SELECTION ();
2668 }
2669
2670 /* ------------------------------------------------------------------------- */
2671 /*
2672  * Paste a selection direct to the command fd
2673  */
2674 void
2675 rxvt_term::paste (char *data, unsigned int len) NOTHROW
2676 {
2677   /* convert normal newline chars into common keyboard Return key sequence */
2678   for (unsigned int i = 0; i < len; i++)
2679     if (data[i] == C0_LF)
2680       data[i] = C0_CR;
2681
2682   if (priv_modes & PrivMode_BracketPaste)
2683     tt_printf ("\e[200~");
2684
2685   tt_write (data, len);
2686
2687   if (priv_modes & PrivMode_BracketPaste)
2688     tt_printf ("\e[201~");
2689 }
2690
2691 /* ------------------------------------------------------------------------- */
2692 /*
2693  * Respond to a notification that a primary selection has been sent
2694  * EXT: SelectionNotify
2695  */
2696 void
2697 rxvt_term::selection_paste (Window win, Atom prop, bool delete_prop) NOTHROW
2698 {
2699   if (prop == None)         /* check for failed XConvertSelection */
2700     {
2701       if ((selection_type & Sel_CompoundText))
2702         {
2703           int selnum = selection_type & Sel_whereMask;
2704
2705           selection_type = 0;
2706           if (selnum != Sel_direct)
2707             selection_request_other (XA_STRING, selnum);
2708         }
2709
2710       if ((selection_type & Sel_UTF8String))
2711         {
2712           int selnum = selection_type & Sel_whereMask;
2713
2714           selection_type = Sel_CompoundText;
2715           if (selnum != Sel_direct)
2716             selection_request_other (xa[XA_COMPOUND_TEXT], selnum);
2717           else
2718             selection_type = 0;
2719         }
2720
2721       return;
2722     }
2723
2724   unsigned long bytes_after;
2725   XTextProperty ct;
2726
2727   if (XGetWindowProperty (dpy, win, prop,
2728                           0, PROP_SIZE / 4,
2729                           delete_prop, AnyPropertyType,
2730                           &ct.encoding, &ct.format,
2731                           &ct.nitems, &bytes_after,
2732                           &ct.value) != Success)
2733     {
2734       ct.value = 0;
2735       goto bailout;
2736     }
2737
2738   if (ct.encoding == None)
2739     goto bailout;
2740
2741   if (bytes_after)
2742     {
2743       // fetch and append remaining data
2744       XTextProperty ct2;
2745
2746       if (XGetWindowProperty (dpy, win, prop,
2747                               ct.nitems / 4, (bytes_after + 3) / 4,
2748                               delete_prop, AnyPropertyType,
2749                               &ct2.encoding, &ct2.format,
2750                               &ct2.nitems, &bytes_after,
2751                               &ct2.value) != Success)
2752         goto bailout;
2753
2754       // realloc should be compatible to XFree, here, and elsewhere, too
2755       ct.value = (unsigned char *)realloc (ct.value, ct.nitems + ct2.nitems + 1);
2756       memcpy (ct.value + ct.nitems, ct2.value, ct2.nitems + 1);
2757       ct.nitems += ct2.nitems;
2758
2759       XFree (ct2.value);
2760     }
2761
2762   if (ct.value == 0)
2763     goto bailout;
2764
2765   if (ct.encoding == xa[XA_INCR])
2766     {
2767       // INCR selection, start handshake
2768       if (!delete_prop)
2769         XDeleteProperty (dpy, win, prop);
2770
2771       selection_wait = Sel_incr;
2772       incr_buf_fill = 0;
2773       incr_ev.start (10);
2774
2775       goto bailout;
2776     }
2777
2778   if (ct.nitems == 0)
2779     {
2780       if (selection_wait == Sel_incr)
2781         {
2782           XFree (ct.value);
2783
2784           // finally complete, now paste the whole thing
2785           selection_wait = Sel_normal;
2786           ct.value = (unsigned char *)incr_buf;
2787           ct.nitems = incr_buf_fill;
2788           incr_buf = 0;
2789           incr_buf_size = 0;
2790           incr_ev.stop ();
2791         }
2792       else
2793         {
2794           if (selection_wait == Sel_normal
2795               && (win != display->root || prop != XA_CUT_BUFFER0)) // avoid recursion
2796             {
2797               /*
2798                * pass through again trying CUT_BUFFER0 if we've come from
2799                * XConvertSelection () but nothing was presented
2800                */
2801               selection_paste (display->root, XA_CUT_BUFFER0, False);
2802             }
2803
2804           goto bailout;
2805         }
2806     }
2807   else if (selection_wait == Sel_incr)
2808     {
2809       incr_ev.start (10);
2810
2811       while (incr_buf_fill + ct.nitems > incr_buf_size)
2812         {
2813           incr_buf_size = incr_buf_size ? incr_buf_size * 2 : 128*1024;
2814           incr_buf = (char *)realloc (incr_buf, incr_buf_size);
2815         }
2816
2817       memcpy (incr_buf + incr_buf_fill, ct.value, ct.nitems);
2818       incr_buf_fill += ct.nitems;
2819
2820       goto bailout;
2821     }
2822
2823   char **cl;
2824   int cr;
2825
2826 #if !ENABLE_MINIMAL
2827   // xlib is horribly broken with respect to UTF8_STRING, and nobody cares to fix it
2828   // so recode it manually
2829   if (ct.encoding == xa[XA_UTF8_STRING])
2830     {
2831       wchar_t *w = rxvt_utf8towcs ((const char *)ct.value, ct.nitems);
2832       char *s = rxvt_wcstombs (w);
2833       free (w);
2834       // TODO: strlen == only the first element will be converted. well...
2835       paste (s, strlen (s));
2836       free (s);
2837     }
2838   else
2839 #endif
2840   if (XmbTextPropertyToTextList (dpy, &ct, &cl, &cr) >= 0
2841       && cl)
2842     {
2843       for (int i = 0; i < cr; i++)
2844         paste (cl[i], strlen (cl[i]));
2845
2846       XFreeStringList (cl);
2847     }
2848   else
2849     paste ((char *)ct.value, ct.nitems); // paste raw
2850
2851 bailout:
2852   XFree (ct.value);
2853
2854   if (selection_wait == Sel_normal)
2855     selection_wait = Sel_none;
2856 }
2857
2858 void
2859 rxvt_term::incr_cb (ev::timer &w, int revents) NOTHROW
2860 {
2861   selection_wait = Sel_none;
2862
2863   incr_buf_size = 0;
2864   free (incr_buf);
2865
2866   rxvt_warn ("data loss: timeout on INCR selection paste, ignoring.\n");
2867 }
2868
2869 void
2870 rxvt_term::selection_property (Window win, Atom prop) NOTHROW
2871 {
2872   if (prop == None || selection_wait != Sel_incr)
2873     return;
2874
2875   selection_paste (win, prop, true);
2876 }
2877
2878 /* ------------------------------------------------------------------------- */
2879 /*
2880  * Request the current selection:
2881  * Order: > internal selection if available
2882  *        > PRIMARY, SECONDARY, CLIPBOARD if ownership is claimed (+)
2883  *        > CUT_BUFFER0
2884  * (+) if ownership is claimed but property is empty, rxvt_selection_paste ()
2885  *     will auto fallback to CUT_BUFFER0
2886  * EXT: button 2 release
2887  */
2888 void
2889 rxvt_term::selection_request (Time tm, int selnum) NOTHROW
2890 {
2891   if (selection.text && selnum == Sel_Primary)
2892     {
2893       /* internal selection */
2894       char *str = rxvt_wcstombs (selection.text, selection.len);
2895       paste (str, strlen (str));
2896       free (str);
2897       return;
2898     }
2899   else
2900     {
2901       selection_request_time = tm;
2902       selection_wait = Sel_normal;
2903
2904 #if X_HAVE_UTF8_STRING
2905       selection_type = Sel_UTF8String;
2906       if (selection_request_other (xa[XA_UTF8_STRING], selnum))
2907         return;
2908 #else
2909       selection_type = Sel_CompoundText;
2910       if (selection_request_other (xa[XA_COMPOUND_TEXT], selnum))
2911         return;
2912 #endif
2913     }
2914
2915   selection_wait = Sel_none;       /* don't loop in selection_paste () */
2916   selection_paste (display->root, XA_CUT_BUFFER0, false);
2917 }
2918
2919 int
2920 rxvt_term::selection_request_other (Atom target, int selnum) NOTHROW
2921 {
2922   Atom sel;
2923
2924   selection_type |= selnum;
2925
2926   if (selnum == Sel_Primary)
2927     sel = XA_PRIMARY;
2928   else if (selnum == Sel_Secondary)
2929     sel = XA_SECONDARY;
2930   else
2931     sel = xa[XA_CLIPBOARD];
2932
2933   if (XGetSelectionOwner (dpy, sel) != None)
2934     {
2935       XConvertSelection (dpy, sel, target, xa[XA_VT_SELECTION],
2936                          vt, selection_request_time);
2937       return 1;
2938     }
2939
2940   return 0;
2941 }
2942
2943 /* ------------------------------------------------------------------------- */
2944 /*
2945  * Clear all selected text
2946  * EXT: SelectionClear
2947  */
2948 void
2949 rxvt_term::selection_clear () NOTHROW
2950 {
2951   want_refresh = 1;
2952   free (selection.text);
2953   selection.text = NULL;
2954   selection.len = 0;
2955   CLEAR_SELECTION ();
2956
2957   if (display->selection_owner == this)
2958     display->selection_owner = 0;
2959 }
2960
2961 /* ------------------------------------------------------------------------- */
2962 /*
2963  * Copy a selection into the cut buffer
2964  * EXT: button 1 or 3 release
2965  */
2966 void
2967 rxvt_term::selection_make (Time tm)
2968 {
2969   int i;
2970   wchar_t *new_selection_text;
2971   text_t *t;
2972
2973   switch (selection.op)
2974     {
2975       case SELECTION_CONT:
2976         break;
2977       case SELECTION_INIT:
2978         CLEAR_SELECTION ();
2979         /* FALLTHROUGH */
2980       case SELECTION_BEGIN:
2981         selection.op = SELECTION_DONE;
2982         /* FALLTHROUGH */
2983       default:
2984         return;
2985     }
2986
2987   selection.op = SELECTION_DONE;
2988
2989   if (selection.clicks == 4)
2990     return;                 /* nothing selected, go away */
2991
2992   if (HOOK_INVOKE ((this, HOOK_SEL_MAKE, DT_LONG, (long)tm, DT_END)))
2993     return;
2994
2995   i = (selection.end.row - selection.beg.row + 1) * (ncol + 1);
2996   new_selection_text = (wchar_t *)rxvt_malloc ((i + 4) * sizeof (wchar_t));
2997
2998   int ofs = 0;
2999   int extra = 0;
3000
3001   int col = selection.beg.col;
3002   int row = selection.beg.row;
3003
3004   int end_col;
3005
3006   for (; row <= selection.end.row; row++, col = 0)
3007     {
3008 #if !ENABLE_MINIMAL
3009       if (selection.rect)
3010         {
3011           col = selection.beg.col;
3012           end_col = ncol + 1;
3013         }
3014       else
3015 #endif
3016         end_col = ROW(row).l;
3017
3018       col = max (col, 0);
3019
3020       if (row == selection.end.row
3021 #if !ENABLE_MINIMAL
3022           || selection.rect
3023 #endif
3024           )
3025         min_it (end_col, selection.end.col);
3026
3027       t = ROW(row).t + col;
3028
3029       for (; col < end_col; col++)
3030         {
3031           if (*t == NOCHAR)
3032             t++;
3033 #if ENABLE_COMBINING
3034           else if (IS_COMPOSE (*t))
3035             {
3036               int len = rxvt_composite.expand (*t, 0);
3037
3038               extra -= (len - 1);
3039
3040               if (extra < 0)
3041                 {
3042                   extra += i;
3043                   i += i;
3044                   new_selection_text = (wchar_t *)rxvt_realloc (new_selection_text, (i + 4) * sizeof (wchar_t));
3045                 }
3046
3047               ofs += rxvt_composite.expand (*t++, new_selection_text + ofs);
3048             }
3049 #endif
3050           else
3051             new_selection_text[ofs++] = *t++;
3052         }
3053
3054 #if !ENABLE_MINIMAL
3055       if (selection.rect)
3056         {
3057           while (ofs
3058                  && new_selection_text[ofs - 1] != C0_LF
3059                  && unicode::is_space (new_selection_text[ofs - 1]))
3060             --ofs;
3061
3062           new_selection_text[ofs++] = C0_LF;
3063         }
3064       else
3065 #endif
3066         if (!ROW(row).is_longer () && row != selection.end.row)
3067           new_selection_text[ofs++] = C0_LF;
3068     }
3069
3070   if (end_col != selection.end.col)
3071     new_selection_text[ofs++] = C0_LF;
3072
3073   new_selection_text[ofs] = 0;
3074
3075   if (ofs == 0)
3076     {
3077       free (new_selection_text);
3078       return;
3079     }
3080
3081   free (selection.text);
3082
3083   // we usually allocate much more than necessary, so realloc it smaller again
3084   selection.len = ofs;
3085   selection.text = (wchar_t *)rxvt_realloc (new_selection_text, (ofs + 1) * sizeof (wchar_t));
3086
3087   if (HOOK_INVOKE ((this, HOOK_SEL_GRAB, DT_LONG, (long)tm, DT_END)))
3088     return;
3089
3090   selection_grab (tm);
3091 }
3092
3093 bool
3094 rxvt_term::selection_grab (Time tm) NOTHROW
3095 {
3096   selection_time = tm;
3097
3098   XSetSelectionOwner (dpy, XA_PRIMARY, vt, tm);
3099   if (XGetSelectionOwner (dpy, XA_PRIMARY) == vt)
3100     {
3101       display->set_selection_owner (this);
3102       return true;
3103     }
3104   else
3105     {
3106       selection_clear ();
3107       return false;
3108     }
3109
3110 #if 0
3111   XTextProperty ct;
3112
3113   if (XwcTextListToTextProperty (dpy, &selection.text, 1, XStringStyle, &ct) >= 0)
3114     {
3115       set_string_property (XA_CUT_BUFFER0, ct.value, ct.nitems);
3116       XFree (ct.value);
3117     }
3118 #endif
3119 }
3120
3121 /* ------------------------------------------------------------------------- */
3122 /*
3123  * Mark or select text based upon number of clicks: 1, 2, or 3
3124  * EXT: button 1 press
3125  */
3126 void
3127 rxvt_term::selection_click (int clicks, int x, int y) NOTHROW
3128 {
3129   clicks = ((clicks - 1) % 3) + 1;
3130   selection.clicks = clicks;       /* save clicks so extend will work */
3131
3132   if (clicks == 2 && !selection.rect
3133       && HOOK_INVOKE ((this, HOOK_SEL_EXTEND, DT_END)))
3134     {
3135       MEvent.clicks = 1; // what a mess
3136       selection.screen = current_screen;
3137       selection.op = SELECTION_CONT;
3138       return;
3139     }
3140
3141   selection_start_colrow (Pixel2Col (x), Pixel2Row (y));
3142
3143   if (clicks == 2 || clicks == 3)
3144     selection_extend_colrow (selection.mark.col,
3145                              selection.mark.row - view_start,
3146                              0, /* button 3     */
3147                              1, /* button press */
3148                              0);        /* click change */
3149 }
3150
3151 /* ------------------------------------------------------------------------- */
3152 /*
3153  * Mark a selection at the specified col/row
3154  */
3155 void
3156 rxvt_term::selection_start_colrow (int col, int row) NOTHROW
3157 {
3158   want_refresh = 1;
3159
3160   selection.mark.row = row + view_start;
3161   selection.mark.col = col;
3162
3163   selection.mark.row = clamp (selection.mark.row, top_row, nrow - 1);
3164   selection.mark.col = clamp (selection.mark.col,       0, ncol - 1);
3165
3166   while (selection.mark.col > 0
3167          && ROW(selection.mark.row).t[selection.mark.col] == NOCHAR)
3168     --selection.mark.col;
3169
3170   if (selection.op)
3171     {
3172       /* clear the old selection */
3173       selection.beg.row = selection.end.row = selection.mark.row;
3174       selection.beg.col = selection.end.col = selection.mark.col;
3175     }
3176
3177   selection.op = SELECTION_INIT;
3178   selection.screen = current_screen;
3179 }
3180
3181 /* ------------------------------------------------------------------------- */
3182 /*
3183  * Word select: select text for 2 clicks
3184  * We now only find out the boundary in one direction
3185  */
3186
3187 /* what do we want: spaces/tabs are delimiters or cutchars or non-cutchars */
3188 #define DELIMIT_TEXT(x)                 \
3189     (unicode::is_space (x) ? 2 : (x) <= 0xff && !!strchr (rs[Rs_cutchars], (x)))
3190 #define DELIMIT_REND(x)        1
3191
3192 void
3193 rxvt_term::selection_delimit_word (enum page_dirn dirn, const row_col_t *mark, row_col_t *ret) NOTHROW
3194 {
3195   int col, row, dirnadd, tcol, trow, w1, w2;
3196   row_col_t bound;
3197   text_t *stp;
3198   rend_t *srp;
3199
3200   if (dirn == UP)
3201     {
3202       bound.row = top_row - 1;
3203       bound.col = 0;
3204       dirnadd = -1;
3205     }
3206   else
3207     {
3208       bound.row = nrow;
3209       bound.col = ncol - 1;
3210       dirnadd = 1;
3211     }
3212
3213   row = mark->row;
3214   col = max (mark->col, 0);
3215
3216   /* find the edge of a word */
3217   stp = ROW(row).t + col; w1 = DELIMIT_TEXT (*stp);
3218   srp = ROW(row).r + col; w2 = DELIMIT_REND (*srp);
3219
3220   for (;;)
3221     {
3222       for (; col != bound.col; col += dirnadd)
3223         {
3224           stp += dirnadd;
3225           srp += dirnadd;
3226
3227           if (*stp == NOCHAR)
3228             continue;
3229
3230           if (DELIMIT_TEXT (*stp) != w1)
3231             break;
3232           if (DELIMIT_REND (*srp) != w2)
3233             break;
3234         }
3235
3236       if ((col == bound.col) && (row != bound.row))
3237         {
3238           if (ROW(row - (dirn == UP ? 1 : 0)).is_longer ())
3239             {
3240               trow = row + dirnadd;
3241               tcol = dirn == UP ? ncol - 1 : 0;
3242
3243               if (!ROW(trow).t)
3244                 break;
3245
3246               stp = ROW(trow).t + tcol;
3247               srp = ROW(trow).r + tcol;
3248
3249               if (DELIMIT_TEXT (*stp) != w1 || DELIMIT_REND (*srp) != w2)
3250                 break;
3251
3252               row = trow;
3253               col = tcol;
3254               continue;
3255             }
3256         }
3257       break;
3258     }
3259
3260   if (dirn == DN)
3261     col++;                  /* put us on one past the end */
3262
3263   /* Poke the values back in */
3264   ret->row = row;
3265   ret->col = col;
3266 }
3267
3268 /* ------------------------------------------------------------------------- */
3269 /*
3270  * Extend the selection to the specified x/y pixel location
3271  * EXT: button 3 press; button 1 or 3 drag
3272  * flag == 0 ==> button 1
3273  * flag == 1 ==> button 3 press
3274  * flag == 2 ==> button 3 motion
3275  */
3276 void
3277 rxvt_term::selection_extend (int x, int y, int flag) NOTHROW
3278 {
3279   int col = clamp (Pixel2Col (x), 0, ncol);
3280   int row = clamp (Pixel2Row (y), 0, nrow - 1);
3281
3282   /*
3283   * If we're selecting characters (single click) then we must check first
3284   * if we are at the same place as the original mark.  If we are then
3285   * select nothing.  Otherwise, if we're to the right of the mark, you have to
3286   * be _past_ a character for it to be selected.
3287   */
3288   if (((selection.clicks % 3) == 1) && !flag
3289       && (col == selection.mark.col
3290           && (row == selection.mark.row - view_start)))
3291     {
3292       /* select nothing */
3293       selection.beg.row = selection.end.row = 0;
3294       selection.beg.col = selection.end.col = 0;
3295       selection.clicks = 4;
3296       want_refresh = 1;
3297       return;
3298     }
3299
3300   if (selection.clicks == 4)
3301     selection.clicks = 1;
3302
3303   selection_extend_colrow (col, row, !!flag,  /* ? button 3      */
3304                            flag == 1 ? 1 : 0,     /* ? button press  */
3305                            0);    /* no click change */
3306 }
3307
3308 /* ------------------------------------------------------------------------- */
3309 /*
3310  * Extend the selection to the specified col/row
3311  */
3312 void
3313 rxvt_term::selection_extend_colrow (int32_t col, int32_t row, int button3, int buttonpress, int clickchange) NOTHROW
3314 {
3315   row_col_t pos;
3316   enum {
3317     LEFT, RIGHT
3318   } closeto = RIGHT;
3319
3320   want_refresh = 1;
3321
3322   switch (selection.op)
3323     {
3324       case SELECTION_INIT:
3325         CLEAR_SELECTION ();
3326         selection.op = SELECTION_BEGIN;
3327         /* FALLTHROUGH */
3328       case SELECTION_BEGIN:
3329         if (row != selection.mark.row || col != selection.mark.col
3330             || (!button3 && buttonpress))
3331           selection.op = SELECTION_CONT;
3332         break;
3333       case SELECTION_DONE:
3334         selection.op = SELECTION_CONT;
3335         /* FALLTHROUGH */
3336       case SELECTION_CONT:
3337         break;
3338       case SELECTION_CLEAR:
3339         selection_start_colrow (col, row);
3340         /* FALLTHROUGH */
3341       default:
3342         return;
3343     }
3344
3345   if (selection.beg.col == selection.end.col
3346       && selection.beg.col != selection.mark.col
3347       && selection.beg.row == selection.end.row
3348       && selection.beg.row != selection.mark.row)
3349     {
3350       selection.beg.col = selection.end.col = selection.mark.col;
3351       selection.beg.row = selection.end.row = selection.mark.row;
3352     }
3353
3354   pos.col = col;
3355   pos.row = view_start + row;
3356
3357   /*
3358    * This is mainly xterm style selection with a couple of differences, mainly
3359    * in the way button3 drag extension works.
3360    * We're either doing: button1 drag; button3 press; or button3 drag
3361    *  a) button1 drag : select around a midpoint/word/line - that point/word/line
3362    *     is always at the left/right edge of the selection.
3363    *  b) button3 press: extend/contract character/word/line at whichever edge of
3364    *     the selection we are closest to.
3365    *  c) button3 drag : extend/contract character/word/line - we select around
3366    *     a point/word/line which is either the start or end of the selection
3367    *     and it was decided by whichever point/word/line was `fixed' at the
3368    *     time of the most recent button3 press
3369    */
3370   if (button3 && buttonpress)
3371     {
3372       /* button3 press */
3373       /*
3374        * first determine which edge of the selection we are closest to
3375        */
3376       if (ROWCOL_IS_BEFORE (pos, selection.beg)
3377           || (!ROWCOL_IS_AFTER (pos, selection.end)
3378               && (((pos.col - selection.beg.col)
3379                    + ((pos.row - selection.beg.row) * ncol))
3380                   < ((selection.end.col - pos.col)
3381                      + ((selection.end.row - pos.row) * ncol)))))
3382         closeto = LEFT;
3383
3384       if (closeto == LEFT)
3385         {
3386           selection.beg.row = pos.row;
3387           selection.beg.col = pos.col;
3388           selection.mark.row = selection.end.row;
3389           selection.mark.col = selection.end.col - (selection.clicks == 2);
3390         }
3391       else
3392         {
3393           selection.end.row = pos.row;
3394           selection.end.col = pos.col;
3395           selection.mark.row = selection.beg.row;
3396           selection.mark.col = selection.beg.col;
3397         }
3398     }
3399   else
3400     {
3401       /* button1 drag or button3 drag */
3402       if (ROWCOL_IS_AFTER (selection.mark, pos))
3403         {
3404           if (selection.mark.row == selection.end.row
3405               && selection.mark.col == selection.end.col
3406               && clickchange
3407               && selection.clicks == 2)
3408             selection.mark.col--;
3409
3410           selection.beg.row = pos.row;
3411           selection.beg.col = pos.col;
3412           selection.end.row = selection.mark.row;
3413           selection.end.col = selection.mark.col + (selection.clicks == 2);
3414         }
3415       else
3416         {
3417           selection.beg.row = selection.mark.row;
3418           selection.beg.col = selection.mark.col;
3419           selection.end.row = pos.row;
3420           selection.end.col = pos.col;
3421         }
3422     }
3423
3424   if (selection.clicks == 1)
3425     {
3426       if (selection.beg.col > ROW(selection.beg.row).l //TODO//FIXME//LEN
3427           && !ROW(selection.beg.row).is_longer ()
3428 #if !ENABLE_MINIMAL
3429           && !selection.rect
3430 #endif
3431          )
3432         selection.beg.col = ncol;
3433
3434       if (
3435           selection.end.col > ROW(selection.end.row).l //TODO//FIXME//LEN
3436           && !ROW(selection.end.row).is_longer ()
3437 #if !ENABLE_MINIMAL
3438           && !selection.rect
3439 #endif
3440          )
3441         selection.end.col = ncol;
3442     }
3443   else if (selection.clicks == 2)
3444     {
3445       if (ROWCOL_IS_AFTER (selection.end, selection.beg))
3446         selection.end.col--;
3447
3448       selection_delimit_word (UP, &selection.beg, &selection.beg);
3449       selection_delimit_word (DN, &selection.end, &selection.end);
3450     }
3451   else if (selection.clicks == 3)
3452     {
3453 #if ENABLE_FRILLS
3454       if (option (Opt_tripleclickwords))
3455         {
3456           selection_delimit_word (UP, &selection.beg, &selection.beg);
3457
3458           for (int end_row = selection.mark.row; end_row < nrow; end_row++)
3459             {
3460               if (!ROW(end_row).is_longer ())
3461                 {
3462                   selection.end.row = end_row;
3463                   selection.end.col = ROW(end_row).l;
3464 # if !ENABLE_MINIMAL
3465                   selection_remove_trailing_spaces ();
3466 # endif
3467                   break;
3468                 }
3469             }
3470         }
3471       else
3472 #endif
3473         {
3474           if (ROWCOL_IS_AFTER (selection.mark, selection.beg))
3475             selection.mark.col++;
3476
3477           selection.beg.col = 0;
3478           selection.end.col = ncol;
3479
3480           // select a complete logical line
3481           while (selection.beg.row > -saveLines
3482                  && ROW(selection.beg.row - 1).is_longer ())
3483             selection.beg.row--;
3484
3485           while (selection.end.row < nrow
3486                  && ROW(selection.end.row).is_longer ())
3487             selection.end.row++;
3488         }
3489     }
3490
3491   if (button3 && buttonpress)
3492     {
3493       /* mark may need to be changed */
3494       if (closeto == LEFT)
3495         {
3496           selection.mark.row = selection.end.row;
3497           selection.mark.col = selection.end.col - (selection.clicks == 2);
3498         }
3499       else
3500         {
3501           selection.mark.row = selection.beg.row;
3502           selection.mark.col = selection.beg.col;
3503         }
3504     }
3505
3506 #if !ENABLE_MINIMAL
3507   if (selection.rect && selection.beg.col > selection.end.col)
3508     ::swap (selection.beg.col, selection.end.col);
3509 #endif
3510 }
3511
3512 #if !ENABLE_MINIMAL
3513 void
3514 rxvt_term::selection_remove_trailing_spaces () NOTHROW
3515 {
3516   int32_t end_col, end_row;
3517   text_t *stp;
3518
3519   end_col = selection.end.col;
3520   end_row = selection.end.row;
3521
3522   for (; end_row >= selection.beg.row; )
3523     {
3524       stp = ROW(end_row).t;
3525
3526       while (--end_col >= 0)
3527         {
3528           if (stp[end_col] != NOCHAR
3529               && !unicode::is_space (stp[end_col]))
3530             break;
3531         }
3532
3533       if (end_col >= 0
3534           || !ROW(end_row - 1).is_longer ())
3535         {
3536           selection.end.col = end_col + 1;
3537           selection.end.row = end_row;
3538           break;
3539         }
3540
3541       end_row--;
3542       end_col = ncol;
3543     }
3544
3545   if (selection.mark.row > selection.end.row)
3546     {
3547       selection.mark.row = selection.end.row;
3548       selection.mark.col = selection.end.col;
3549     }
3550   else if (selection.mark.row == selection.end.row
3551            && selection.mark.col > selection.end.col)
3552     selection.mark.col = selection.end.col;
3553 }
3554 #endif
3555
3556 /* ------------------------------------------------------------------------- */
3557 /*
3558  * Double click on button 3 when already selected
3559  * EXT: button 3 double click
3560  */
3561 void
3562 rxvt_term::selection_rotate (int x, int y) NOTHROW
3563 {
3564   selection.clicks = selection.clicks % 3 + 1;
3565   selection_extend_colrow (Pixel2Col (x), Pixel2Row (y), 1, 0, 1);
3566 }
3567
3568 /* ------------------------------------------------------------------------- */
3569 /*
3570  * Respond to a request for our current selection
3571  * EXT: SelectionRequest
3572  */
3573 void
3574 rxvt_term::selection_send (const XSelectionRequestEvent &rq) NOTHROW
3575 {
3576   XSelectionEvent ev;
3577
3578   ev.type = SelectionNotify;
3579   ev.property = None;
3580   ev.display = rq.display;
3581   ev.requestor = rq.requestor;
3582   ev.selection = rq.selection;
3583   ev.target = rq.target;
3584   ev.time = rq.time;
3585
3586   if (rq.target == xa[XA_TARGETS])
3587     {
3588       Atom target_list[6];
3589       Atom *target = target_list;
3590
3591       *target++ = xa[XA_TARGETS];
3592       *target++ = xa[XA_TIMESTAMP];
3593       *target++ = XA_STRING;
3594       *target++ = xa[XA_TEXT];
3595       *target++ = xa[XA_COMPOUND_TEXT];
3596 #if X_HAVE_UTF8_STRING
3597       *target++ = xa[XA_UTF8_STRING];
3598 #endif
3599
3600       XChangeProperty (dpy, rq.requestor, rq.property, XA_ATOM,
3601                        32, PropModeReplace,
3602                        (unsigned char *)target_list, target - target_list);
3603       ev.property = rq.property;
3604     }
3605 #if TODO // TODO
3606   else if (rq.target == xa[XA_MULTIPLE])
3607     {
3608       /* TODO: Handle MULTIPLE */
3609     }
3610 #endif
3611   else if (rq.target == xa[XA_TIMESTAMP] && selection.text)
3612     {
3613       XChangeProperty (dpy, rq.requestor, rq.property, rq.target,
3614                        32, PropModeReplace, (unsigned char *)&selection_time, 1);
3615       ev.property = rq.property;
3616     }
3617   else if (rq.target == XA_STRING
3618            || rq.target == xa[XA_TEXT]
3619            || rq.target == xa[XA_COMPOUND_TEXT]
3620            || rq.target == xa[XA_UTF8_STRING]
3621           )
3622     {
3623       XTextProperty ct;
3624       Atom target = rq.target;
3625       short freect = 0;
3626       int selectlen;
3627       wchar_t *cl;
3628       enum {
3629         enc_string        = XStringStyle,
3630         enc_text          = XStdICCTextStyle,
3631         enc_compound_text = XCompoundTextStyle,
3632 #ifdef X_HAVE_UTF8_STRING
3633         enc_utf8          = XUTF8StringStyle,
3634 #else
3635         enc_utf8          = -1,
3636 #endif
3637       } style;
3638
3639       if (target == XA_STRING)
3640         // we actually don't do XA_STRING, but who cares, as i18n clients
3641         // will ask for another format anyways.
3642         style = enc_string;
3643       else if (target == xa[XA_TEXT])
3644         style = enc_text;
3645       else if (target == xa[XA_COMPOUND_TEXT])
3646         style = enc_compound_text;
3647 #if !ENABLE_MINIMAL
3648       else if (target == xa[XA_UTF8_STRING])
3649         style = enc_utf8;
3650 #endif
3651       else
3652         {
3653           target = xa[XA_COMPOUND_TEXT];
3654           style = enc_compound_text;
3655         }
3656
3657       if (selection.text)
3658         {
3659           cl = selection.text;
3660           selectlen = selection.len;
3661         }
3662       else
3663         {
3664           cl = L"";
3665           selectlen = 0;
3666         }
3667
3668 #if !ENABLE_MINIMAL
3669       // xlib is horribly broken with respect to UTF8_STRING, and nobody cares to fix it
3670       // so recode it manually
3671       if (style == enc_utf8)
3672         {
3673           freect = 1;
3674           ct.encoding = target;
3675           ct.format = 8;
3676           ct.value = (unsigned char *)rxvt_wcstoutf8 (cl, selectlen);
3677           ct.nitems = strlen ((char *)ct.value);
3678         }
3679       else
3680 #endif
3681       if (XwcTextListToTextProperty (dpy, &cl, 1, (XICCEncodingStyle) style, &ct) >= 0)
3682         freect = 1;
3683       else
3684         {
3685           /* if we failed to convert then send it raw */
3686           ct.value = (unsigned char *)cl;
3687           ct.nitems = selectlen;
3688           ct.encoding = target;
3689         }
3690
3691       XChangeProperty (dpy, rq.requestor, rq.property,
3692                        ct.encoding, 8, PropModeReplace,
3693                        ct.value, (int)ct.nitems);
3694       ev.property = rq.property;
3695
3696       if (freect)
3697         XFree (ct.value);
3698     }
3699
3700   XSendEvent (dpy, rq.requestor, False, 0L, (XEvent *)&ev);
3701 }
3702
3703 /* ------------------------------------------------------------------------- */
3704 #ifdef USE_XIM
3705 void
3706 rxvt_term::im_set_position (XPoint &pos) NOTHROW
3707 {
3708   XWindowAttributes xwa;
3709
3710   XGetWindowAttributes (dpy, vt, &xwa);
3711
3712   pos.x = xwa.x + Col2Pixel    (screen.cur.col);
3713   pos.y = xwa.y + Height2Pixel (screen.cur.row) + fbase;
3714 }
3715 #endif
3716
3717 #if ENABLE_OVERLAY
3718 void
3719 rxvt_term::scr_overlay_new (int x, int y, int w, int h) NOTHROW
3720 {
3721   if (nrow < 1 || ncol < 1)
3722     return;
3723
3724   want_refresh = 1;
3725
3726   scr_overlay_off ();
3727
3728   if (x < 0) x = ncol - w;
3729   if (y < 0) y = nrow - h;
3730
3731   // make space for border
3732   w += 2; min_it (w, ncol);
3733   h += 2; min_it (h, nrow);
3734
3735   x -= 1; clamp_it (x, 0, ncol - w);
3736   y -= 1; clamp_it (y, 0, nrow - h);
3737
3738   ov.x = x; ov.y = y;
3739   ov.w = w; ov.h = h;
3740
3741   ov.text = new text_t *[h];
3742   ov.rend = new rend_t *[h];
3743
3744   for (y = 0; y < h; y++)
3745     {
3746       text_t *tp = ov.text[y] = new text_t[w];
3747       rend_t *rp = ov.rend[y] = new rend_t[w];
3748
3749       text_t t0, t1, t2;
3750       rend_t r = OVERLAY_RSTYLE;
3751
3752       if (y == 0)
3753         t0 = 0x2554, t1 = 0x2550, t2 = 0x2557;
3754       else if (y < h - 1)
3755         t0 = 0x2551, t1 = 0x0020, t2 = 0x2551;
3756       else
3757         t0 = 0x255a, t1 = 0x2550, t2 = 0x255d;
3758
3759       *tp++ = t0;
3760       *rp++ = r;
3761
3762       for (x = w - 2; x > 0; --x)
3763         {
3764           *tp++ = t1;
3765           *rp++ = r;
3766         }
3767
3768       *tp = t2;
3769       *rp = r;
3770     }
3771 }
3772
3773 void
3774 rxvt_term::scr_overlay_off () NOTHROW
3775 {
3776   if (!ov.text)
3777     return;
3778
3779   want_refresh = 1;
3780
3781   for (int y = 0; y < ov.h; y++)
3782     {
3783       delete [] ov.text[y];
3784       delete [] ov.rend[y];
3785     }
3786
3787   delete [] ov.text; ov.text = 0;
3788   delete [] ov.rend; ov.rend = 0;
3789 }
3790
3791 void
3792 rxvt_term::scr_overlay_set (int x, int y, text_t text, rend_t rend) NOTHROW
3793 {
3794   if (!ov.text || x >= ov.w - 2 || y >= ov.h - 2)
3795     return;
3796
3797   x++, y++;
3798
3799   ov.text[y][x] = text;
3800   ov.rend[y][x] = rend;
3801 }
3802
3803 void
3804 rxvt_term::scr_overlay_set (int x, int y, const char *s) NOTHROW
3805 {
3806   while (*s)
3807     scr_overlay_set (x++, y, *s++);
3808 }
3809
3810 void
3811 rxvt_term::scr_overlay_set (int x, int y, const wchar_t *s) NOTHROW
3812 {
3813   while (*s)
3814     {
3815       text_t t = *s++;
3816       int width = WCWIDTH (t);
3817
3818       while (width--)
3819         {
3820           scr_overlay_set (x++, y, t);
3821           t = NOCHAR;
3822         }
3823     }
3824 }
3825
3826 void
3827 rxvt_term::scr_swap_overlay () NOTHROW
3828 {
3829   if (!ov.text)
3830     return;
3831
3832   // hide cursor if it is within the overlay area
3833   if (IN_RANGE_EXC (screen.cur.col - ov.x, 0, ov.w)
3834       && IN_RANGE_EXC (screen.cur.row - ov.y, 0, ov.h))
3835     screen.flags &= ~Screen_VisibleCursor;
3836
3837   // swap screen mem with overlay
3838   for (int y = ov.h; y--; )
3839     {
3840       text_t *t1 = ov.text[y];
3841       rend_t *r1 = ov.rend[y];
3842
3843       text_t *t2 = ROW(y + ov.y + view_start).t + ov.x;
3844       rend_t *r2 = ROW(y + ov.y + view_start).r + ov.x;
3845
3846       for (int x = ov.w; x--; )
3847         {
3848           text_t t = *t1; *t1++ = *t2; *t2++ = t;
3849           rend_t r = *r1; *r1++ = *r2; *r2++ = SET_FONT (r, FONTSET (r)->find_font (t));
3850         }
3851     }
3852 }
3853
3854 #endif
3855 /* ------------------------------------------------------------------------- */
3856