1 /*--------------------------------*-C-*--------------------------------------*
3 *---------------------------------------------------------------------------*
5 * Copyright (c) 1997-2001 Geoff Wing <gcw@pobox.com>
6 * Copyright (c) 2003-2004 Marc Lehmann <pcg@goof.com>
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.
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.
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 *--------------------------------------------------------------------------*/
24 * This file handles _all_ screen updates and selections
27 #include "../config.h" /* NECESSARY */
29 #include "rxvt.h" /* NECESSARY */
31 #include <X11/Xmd.h> /* get the typedef for CARD32 */
36 #include "salloc.C" // HACK, should be a seperate compile!
38 inline void fill_text (text_t *start, text_t value, int len)
44 /* ------------------------------------------------------------------------- */
45 #define PROP_SIZE 16384
46 #define TABSIZE 8 /* default tab size */
48 /* ------------------------------------------------------------------------- *
49 * GENERAL SCREEN AND SELECTION UPDATE ROUTINES *
50 * ------------------------------------------------------------------------- */
51 #define ZERO_SCROLLBACK() \
52 if (options & Opt_scrollTtyOutput) \
53 TermWin.view_start = 0
54 #define CLEAR_SELECTION() \
55 selection.beg.row = selection.beg.col \
56 = selection.end.row = selection.end.col = 0
57 #define CLEAR_ALL_SELECTION() \
58 selection.beg.row = selection.beg.col \
59 = selection.mark.row = selection.mark.col \
60 = selection.end.row = selection.end.col = 0
62 #define ROW_AND_COL_IS_AFTER(A, B, C, D) \
63 (((A) > (C)) || (((A) == (C)) && ((B) > (D))))
64 #define ROW_AND_COL_IS_BEFORE(A, B, C, D) \
65 (((A) < (C)) || (((A) == (C)) && ((B) < (D))))
66 #define ROW_AND_COL_IN_ROW_AFTER(A, B, C, D) \
67 (((A) == (C)) && ((B) > (D)))
68 #define ROW_AND_COL_IN_ROW_AT_OR_AFTER(A, B, C, D) \
69 (((A) == (C)) && ((B) >= (D)))
70 #define ROW_AND_COL_IN_ROW_BEFORE(A, B, C, D) \
71 (((A) == (C)) && ((B) < (D)))
72 #define ROW_AND_COL_IN_ROW_AT_OR_BEFORE(A, B, C, D) \
73 (((A) == (C)) && ((B) <= (D)))
75 /* these must be row_col_t */
76 #define ROWCOL_IS_AFTER(X, Y) \
77 ROW_AND_COL_IS_AFTER ((X).row, (X).col, (Y).row, (Y).col)
78 #define ROWCOL_IS_BEFORE(X, Y) \
79 ROW_AND_COL_IS_BEFORE ((X).row, (X).col, (Y).row, (Y).col)
80 #define ROWCOL_IN_ROW_AFTER(X, Y) \
81 ROW_AND_COL_IN_ROW_AFTER ((X).row, (X).col, (Y).row, (Y).col)
82 #define ROWCOL_IN_ROW_BEFORE(X, Y) \
83 ROW_AND_COL_IN_ROW_BEFORE ((X).row, (X).col, (Y).row, (Y).col)
84 #define ROWCOL_IN_ROW_AT_OR_AFTER(X, Y) \
85 ROW_AND_COL_IN_ROW_AT_OR_AFTER ((X).row, (X).col, (Y).row, (Y).col)
86 #define ROWCOL_IN_ROW_AT_OR_BEFORE(X, Y) \
87 ROW_AND_COL_IN_ROW_AT_OR_BEFORE ((X).row, (X).col, (Y).row, (Y).col)
90 * CLEAR_ROWS : clear <num> rows starting from row <row>
91 * CLEAR_CHARS: clear <num> chars starting from pixel position <x,y>
92 * ERASE_ROWS : set <num> rows starting from row <row> to the foreground colour
94 #define drawBuffer TermWin.vt
96 #define CLEAR_ROWS(row, num) \
98 XClearArea (display->display, drawBuffer, 0, \
99 Row2Pixel (row), (unsigned int)TermWin.width, \
100 (unsigned int)Height2Pixel (num), False)
102 #define CLEAR_CHARS(x, y, num) \
103 if (TermWin.mapped) \
104 XClearArea (display->display, drawBuffer, x, y, \
105 (unsigned int)Width2Pixel (num), \
106 (unsigned int)Height2Pixel (1), False)
108 #define ERASE_ROWS(row, num) \
109 XFillRectangle (display->display, drawBuffer, TermWin.gc, \
110 0, Row2Pixel (row), \
111 (unsigned int)TermWin.width, \
112 (unsigned int)Height2Pixel (num))
114 /* ------------------------------------------------------------------------- *
115 * SCREEN `COMMON' ROUTINES *
116 * ------------------------------------------------------------------------- */
117 /* Fill part/all of a line with blanks. */
119 rxvt_term::scr_blank_line (text_t *et, rend_t *er, unsigned int width, rend_t efs)
121 efs &= ~RS_baseattrMask;
122 efs = SET_FONT (efs, TermWin.ascii_map [' ' - 0x20]);
131 /* ------------------------------------------------------------------------- */
132 /* Fill a full line with blanks - make sure it is allocated first */
134 rxvt_term::scr_blank_screen_mem (text_t **tp, rend_t **rp, unsigned int row, rend_t efs)
137 assert ((tp[row] && rp[row]) || (tp[row] == NULL && rp[row] == NULL));
141 tp[row] = (text_t *)talloc->alloc ();
142 rp[row] = (rend_t *)ralloc->alloc ();
145 scr_blank_line (tp[row], rp[row], TermWin.ncol, efs);
148 /* ------------------------------------------------------------------------- *
149 * SCREEN INITIALISATION *
150 * ------------------------------------------------------------------------- */
152 rxvt_term::scr_reset ()
154 unsigned int ncol, nrow, total_rows, prev_total_rows;
163 TermWin.view_start = 0;
166 if (TermWin.ncol == 0)
169 if (TermWin.nrow == 0)
175 if (ncol == prev_ncol && nrow == prev_nrow)
178 // we need at least two lines for wrapping to work correctly
179 if (nrow + TermWin.saveLines < 2)
188 prev_total_rows = prev_nrow + TermWin.saveLines;
189 total_rows = nrow + TermWin.saveLines;
192 screen.bscroll = nrow - 1;
196 talloc = new rxvt_salloc (ncol * sizeof (text_t));
197 ralloc = new rxvt_salloc (ncol * sizeof (rend_t));
203 * first time called so just malloc everything: don't rely on realloc
204 * Note: this is still needed so that all the scrollback lines are NULL
206 screen.text = (text_t **)rxvt_calloc (total_rows, sizeof (text_t *));
207 buf_text = (text_t **)rxvt_calloc (total_rows, sizeof (text_t *));
208 drawn_text = (text_t **)rxvt_calloc (nrow, sizeof (text_t *));
209 swap.text = (text_t **)rxvt_calloc (nrow, sizeof (text_t *));
211 screen.tlen = (int16_t *)rxvt_calloc (total_rows, sizeof (int16_t));
212 swap.tlen = (int16_t *)rxvt_calloc (nrow, sizeof (int16_t));
214 screen.rend = (rend_t **)rxvt_calloc (total_rows, sizeof (rend_t *));
215 buf_rend = (rend_t **)rxvt_calloc (total_rows, sizeof (rend_t *));
216 drawn_rend = (rend_t **)rxvt_calloc (nrow, sizeof (rend_t *));
217 swap.rend = (rend_t **)rxvt_calloc (nrow, sizeof (rend_t *));
219 for (p = 0; p < nrow; p++)
221 q = p + TermWin.saveLines;
222 scr_blank_screen_mem (screen.text, screen.rend, q, DEFAULT_RSTYLE);
223 scr_blank_screen_mem (swap.text, swap.rend, p, DEFAULT_RSTYLE);
224 screen.tlen[q] = swap.tlen[p] = 0;
225 scr_blank_screen_mem (drawn_text, drawn_rend, p, DEFAULT_RSTYLE);
228 memset (charsets, 'B', sizeof (charsets));
229 TermWin.nscrolled = 0; /* no saved lines */
230 rstyle = DEFAULT_RSTYLE;
231 screen.flags = Screen_DefaultFlags;
232 screen.cur.row = screen.cur.col = 0;
234 current_screen = PRIMARY;
238 swap.flags = Screen_DefaultFlags;
239 swap.cur.row = swap.cur.col = 0;
241 current_screen = SECONDARY;
243 current_screen = PRIMARY;
246 selection.text = NULL;
248 selection.op = SELECTION_CLEAR;
249 selection.screen = PRIMARY;
250 selection.clicks = 0;
251 CLEAR_ALL_SELECTION ();
257 * add or delete rows as appropriate
259 setrstyle = DEFAULT_RSTYLE;
261 if (nrow < prev_nrow)
264 k = min (TermWin.nscrolled, prev_nrow - nrow);
265 scr_scroll_text (0, (int)prev_nrow - 1, k, 1);
267 for (p = nrow; p < prev_nrow; p++)
269 q = p + TermWin.saveLines;
274 assert (screen.rend[q]);
276 talloc->free (screen.text[q]);
277 ralloc->free (screen.rend[q]);
283 assert (swap.rend[p]);
285 talloc->free (swap.text[p]);
286 ralloc->free (swap.rend[p]);
290 assert (drawn_text[p] && drawn_rend[p]);
292 talloc->free (drawn_text[p]);
293 ralloc->free (drawn_rend[p]);
296 /* we have fewer rows so fix up cursor position */
297 MIN_IT (screen.cur.row, (int32_t)nrow - 1);
298 MIN_IT (swap.cur.row, (int32_t)nrow - 1);
300 scr_reset_realloc (); /* realloc _last_ */
302 else if (nrow > prev_nrow)
305 scr_reset_realloc (); /* realloc _first_ */
307 TermWin.ncol = prev_ncol; // save b/c scr_blank_screen_mem uses this
309 k = min (TermWin.nscrolled, nrow - prev_nrow);
311 for (p = prev_total_rows; p < total_rows; p++)
314 screen.text[p] = NULL;
315 screen.rend[p] = NULL;
318 for (p = prev_total_rows; p < total_rows - k; p++)
319 scr_blank_screen_mem (screen.text, screen.rend, p, setrstyle);
321 for (p = prev_nrow; p < nrow; p++)
326 drawn_text[p] = NULL;
327 drawn_rend[p] = NULL;
328 scr_blank_screen_mem (swap.text, swap.rend, p, setrstyle);
329 scr_blank_screen_mem (drawn_text, drawn_rend, p, setrstyle);
334 scr_scroll_text (0, (int)nrow - 1, -k, 1);
336 screen.s_cur.row += k;
337 TermWin.nscrolled -= k;
340 assert (screen.cur.row < TermWin.nrow);
341 assert (swap.cur.row < TermWin.nrow);
342 #else /* drive with your eyes closed */
344 MIN_IT (screen.cur.row, nrow - 1);
345 MIN_IT (swap.cur.row, nrow - 1);
347 TermWin.ncol = ncol; // save b/c scr_blank_screen_mem uses this
351 if (ncol != prev_ncol)
353 rxvt_salloc *ta = new rxvt_salloc (ncol * sizeof (text_t));
354 rxvt_salloc *ra = new rxvt_salloc (ncol * sizeof (rend_t));
356 for (p = 0; p < total_rows; p++)
360 screen.text[p] = (text_t *)ta->alloc (screen.text[p], prev_ncol * sizeof (text_t));
361 screen.rend[p] = (rend_t *)ra->alloc (screen.rend[p], prev_ncol * sizeof (rend_t));
363 MIN_IT (screen.tlen[p], (int16_t)ncol);
365 if (ncol > prev_ncol)
366 scr_blank_line (&screen.text[p][prev_ncol],
367 &screen.rend[p][prev_ncol],
368 ncol - prev_ncol, setrstyle);
372 for (p = 0; p < nrow; p++)
374 drawn_text[p] = (text_t *)ta->alloc (drawn_text[p], prev_ncol * sizeof (text_t));
375 drawn_rend[p] = (rend_t *)ra->alloc (drawn_rend[p], prev_ncol * sizeof (rend_t));
377 if (ncol > prev_ncol)
378 scr_blank_line (&drawn_text[p][prev_ncol],
379 &drawn_rend[p][prev_ncol],
380 ncol - prev_ncol, setrstyle);
384 swap.text[p] = (text_t *)ta->alloc (swap.text[p], prev_ncol * sizeof (text_t));
385 swap.rend[p] = (rend_t *)ra->alloc (swap.rend[p], prev_ncol * sizeof (rend_t));
387 MIN_IT (swap.tlen[p], (int16_t)ncol);
389 if (ncol > prev_ncol)
390 scr_blank_line (&swap.text[p][prev_ncol],
391 &swap.rend[p][prev_ncol],
392 ncol - prev_ncol, setrstyle);
397 MIN_IT (screen.cur.col, (int16_t)ncol - 1);
398 MIN_IT (swap.cur.col, (int16_t)ncol - 1);
400 delete talloc; talloc = ta;
401 delete ralloc; ralloc = ra;
411 tabs = (char *)rxvt_malloc (ncol * sizeof (char));
413 for (p = 0; p < ncol; p++)
414 tabs[p] = (p % TABSIZE == 0) ? 1 : 0;
420 rxvt_term::scr_reset_realloc ()
422 uint16_t total_rows, nrow;
425 total_rows = nrow + TermWin.saveLines;
427 screen.text = (text_t **)rxvt_realloc (screen.text, total_rows * sizeof (text_t *));
428 buf_text = (text_t **)rxvt_realloc (buf_text , total_rows * sizeof (text_t *));
429 drawn_text = (text_t **)rxvt_realloc (drawn_text , nrow * sizeof (text_t *));
430 swap.text = (text_t **)rxvt_realloc (swap.text , nrow * sizeof (text_t *));
432 screen.tlen = (int16_t *)rxvt_realloc (screen.tlen, total_rows * sizeof (int16_t));
433 swap.tlen = (int16_t *)rxvt_realloc (swap.tlen , total_rows * sizeof (int16_t));
435 screen.rend = (rend_t **)rxvt_realloc (screen.rend, total_rows * sizeof (rend_t *));
436 buf_rend = (rend_t **)rxvt_realloc (buf_rend , total_rows * sizeof (rend_t *));
437 drawn_rend = (rend_t **)rxvt_realloc (drawn_rend , nrow * sizeof (rend_t *));
438 swap.rend = (rend_t **)rxvt_realloc (swap.rend , nrow * sizeof (rend_t *));
442 /* ------------------------------------------------------------------------- */
444 * Free everything. That way malloc debugging can find leakage.
447 rxvt_term::scr_release ()
452 total_rows = TermWin.nrow + TermWin.saveLines;
454 delete talloc; talloc = 0;
455 delete ralloc; ralloc = 0;
469 /* NULL these so if anything tries to use them, we'll know about it */
470 screen.text = drawn_text = swap.text = NULL;
471 screen.rend = drawn_rend = swap.rend = NULL;
472 screen.tlen = swap.tlen = NULL;
478 /* ------------------------------------------------------------------------- */
483 rxvt_term::scr_poweron ()
486 prev_nrow = prev_ncol = 0;
490 scr_refresh (SLOW_REFRESH);
493 /* ------------------------------------------------------------------------- *
494 * PROCESS SCREEN COMMANDS *
495 * ------------------------------------------------------------------------- */
497 * Save and Restore cursor
498 * XTERM_SEQ: Save cursor : ESC 7
499 * XTERM_SEQ: Restore cursor: ESC 8
502 rxvt_term::scr_cursor (int mode)
506 #if NSCREENS && !defined(NO_SECONDARY_SCREEN_CURSOR)
507 if (current_screen == SECONDARY)
516 s->s_cur.row = s->cur.row;
517 s->s_cur.col = s->cur.col;
518 s->s_rstyle = rstyle;
519 s->s_charset = s->charset;
520 s->s_charset_char = charsets[s->charset];
525 s->cur.row = s->s_cur.row;
526 s->cur.col = s->s_cur.col;
527 s->flags &= ~Screen_WrapNext;
528 rstyle = s->s_rstyle;
529 s->charset = s->s_charset;
530 charsets[s->charset] = s->s_charset_char;
535 /* boundary check in case screen size changed between SAVE and RESTORE */
536 MIN_IT (s->cur.row, TermWin.nrow - 1);
537 MIN_IT (s->cur.col, TermWin.ncol - 1);
539 assert (s->cur.row >= 0);
540 assert (s->cur.col >= 0);
541 #else /* drive with your eyes closed */
542 MAX_IT (s->cur.row, 0);
543 MAX_IT (s->cur.col, 0);
547 /* ------------------------------------------------------------------------- */
549 * Swap between primary and secondary screens
550 * XTERM_SEQ: Primary screen : ESC [ ? 4 7 h
551 * XTERM_SEQ: Secondary screen: ESC [ ? 4 7 l
554 rxvt_term::scr_change_screen (int scrn)
563 TermWin.view_start = 0;
565 if (current_screen == scrn)
568 selection_check (2); /* check for boundary cross */
570 SWAP_IT (current_screen, scrn, int);
572 if (options & Opt_secondaryScreen)
575 offset = TermWin.saveLines;
576 for (i = prev_nrow; i--;)
578 SWAP_IT (screen.text[i + offset], swap.text[i], text_t *);
579 SWAP_IT (screen.tlen[i + offset], swap.tlen[i], int16_t);
580 SWAP_IT (screen.rend[i + offset], swap.rend[i], rend_t *);
582 SWAP_IT (screen.cur.row, swap.cur.row, int16_t);
583 SWAP_IT (screen.cur.col, swap.cur.col, int16_t);
585 assert ((screen.cur.row >= 0) && (screen.cur.row < prev_nrow));
586 assert ((screen.cur.col >= 0) && (screen.cur.col < prev_ncol));
587 # else /* drive with your eyes closed */
588 MAX_IT (screen.cur.row, 0);
589 MIN_IT (screen.cur.row, (int32_t)prev_nrow - 1);
590 MAX_IT (screen.cur.col, 0);
591 MIN_IT (screen.cur.col, (int32_t)prev_ncol - 1);
593 SWAP_IT (screen.charset, swap.charset, int16_t);
594 SWAP_IT (screen.flags, swap.flags, int);
595 screen.flags |= Screen_VisibleCursor;
596 swap.flags |= Screen_VisibleCursor;
600 if (options & Opt_secondaryScroll)
601 //if (current_screen == PRIMARY)
602 scr_scroll_text (0, (prev_nrow - 1), prev_nrow, 0);
606 // clear WrapNext indicator, solidifying position on next line
608 rxvt_term::scr_do_wrap ()
610 if (!(screen.flags & Screen_WrapNext))
613 screen.flags &= ~Screen_WrapNext;
617 if (screen.cur.row == screen.bscroll)
618 scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);
619 else if (screen.cur.row < TermWin.nrow - 1)
623 /* ------------------------------------------------------------------------- */
625 * Change the colour for following text
628 rxvt_term::scr_color (unsigned int color, int fgbg)
631 if (fgbg == Color_fg)
632 rstyle = SET_FGCOLOR (rstyle, color);
634 rstyle = SET_BGCOLOR (rstyle, color);
637 /* ------------------------------------------------------------------------- */
639 * Change the rendition style for following text
642 rxvt_term::scr_rendition (int set, int style)
646 else if (style == ~RS_None)
647 rstyle = DEFAULT_RSTYLE;
652 /* ------------------------------------------------------------------------- */
654 * Scroll text between <row1> and <row2> inclusive, by <count> lines
655 * count positive ==> scroll up
656 * count negative ==> scroll down
657 * spec == 0 for normal routines
660 rxvt_term::scr_scroll_text (int row1, int row2, int count, int spec)
665 if (count == 0 || (row1 > row2))
670 if (row1 == 0 && count > 0
671 && (current_screen == PRIMARY || options & Opt_secondaryScroll))
673 nscrolled = (long)TermWin.nscrolled + (long)count;
675 if (nscrolled > (long)TermWin.saveLines)
676 TermWin.nscrolled = TermWin.saveLines;
678 TermWin.nscrolled = (uint16_t)nscrolled;
680 if ((options & Opt_scrollWithBuffer)
681 && TermWin.view_start != 0
682 && TermWin.view_start != TermWin.saveLines)
683 scr_page (UP, count);
686 row1 += TermWin.saveLines;
688 row2 += TermWin.saveLines;
690 if (selection.op && current_screen == selection.screen)
692 i = selection.beg.row + TermWin.saveLines;
693 j = selection.end.row + TermWin.saveLines;
694 if ((i < row1 && j > row1)
695 || (i < row2 && j > row2)
696 || (i - count < row1 && i >= row1)
697 || (i - count > row2 && i <= row2)
698 || (j - count < row1 && j >= row1)
699 || (j - count > row2 && j <= row2))
701 CLEAR_ALL_SELECTION ();
702 selection.op = SELECTION_CLEAR; /* XXX: too aggressive? */
704 else if (j >= row1 && j <= row2)
706 /* move selected region too */
707 selection.beg.row -= count;
708 selection.end.row -= count;
709 selection.mark.row -= count;
713 selection_check (0); /* _after_ TermWin.nscrolled update */
728 /* A1: Copy lines that will get clobbered by the rotation */
729 memcpy (buf_text, screen.text + row1, count * sizeof (text_t *));
730 memcpy (buf_rend, screen.rend + row1, count * sizeof (rend_t *));
732 /* A2: Rotate lines */
733 i = row2 - row1 - count + 1;
734 memmove (screen.tlen + row1, screen.tlen + row1 + count, i * sizeof (int16_t));
735 memmove (screen.text + row1, screen.text + row1 + count, i * sizeof (text_t *));
736 memmove (screen.rend + row1, screen.rend + row1 + count, i * sizeof (rend_t *));
738 j = row2 - count + 1, i = count;
740 else /* if (j < 0) */
744 /* B1: Copy lines that will get clobbered by the rotation */
745 for (i = 0, j = row2; i < count; i++, j--)
747 buf_text[i] = screen.text[j];
748 buf_rend[i] = screen.rend[j];
751 /* B2: Rotate lines */
752 for (j = row2, i = j - count; i >= row1; i--, j--)
754 screen.tlen[j] = screen.tlen[i];
755 screen.text[j] = screen.text[i];
756 screen.rend[j] = screen.rend[i];
763 /* C: Resurrect lines */
764 memset (screen.tlen + j, 0, i * sizeof (int16_t));
765 memcpy (screen.text + j, buf_text, i * sizeof (text_t *));
766 memcpy (screen.rend + j, buf_rend, i * sizeof (text_t *));
767 if (!spec) /* line length may not equal TermWin.ncol */
769 scr_blank_screen_mem (screen.text, screen.rend, (unsigned int)j, rstyle);
774 /* ------------------------------------------------------------------------- */
776 * Add text given in <str> of length <len> to screen struct
779 rxvt_term::scr_add_lines (const unicode_t *str, int nlines, int len)
781 unsigned char checksel;
783 int i, row, last_col;
787 if (len <= 0) /* sanity */
792 last_col = TermWin.ncol;
796 nlines += screen.cur.row - screen.bscroll;
798 && (screen.tscroll == 0)
799 && (screen.bscroll == (TermWin.nrow - 1)))
801 /* _at least_ this many lines need to be scrolled */
802 scr_scroll_text (screen.tscroll, screen.bscroll, nlines, 0);
803 screen.cur.row -= nlines;
808 assert (screen.cur.col < last_col);
809 assert ((screen.cur.row < TermWin.nrow)
810 && (screen.cur.row >= - (int32_t)TermWin.nscrolled));
811 #else /* drive with your eyes closed */
812 MIN_IT (screen.cur.col, last_col - 1);
813 MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);
814 MAX_IT (screen.cur.row, - (int32_t)TermWin.nscrolled);
816 row = screen.cur.row + TermWin.saveLines;
818 checksel = selection.op && current_screen == selection.screen ? 1 : 0;
820 stp = screen.text[row];
821 srp = screen.rend[row];
835 if (screen.tlen[row] != -1) /* XXX: think about this */
836 MAX_IT (screen.tlen[row], screen.cur.col);
838 screen.flags &= ~Screen_WrapNext;
840 if (screen.cur.row == screen.bscroll)
841 scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);
842 else if (screen.cur.row < (TermWin.nrow - 1))
843 row = (++screen.cur.row) + TermWin.saveLines;
845 stp = screen.text[row]; /* _must_ refresh */
846 srp = screen.rend[row]; /* _must_ refresh */
850 if (screen.tlen[row] != -1) /* XXX: think about this */
851 MAX_IT (screen.tlen[row], screen.cur.col);
853 screen.flags &= ~Screen_WrapNext;
858 if (checksel /* see if we're writing within selection */
859 && !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
860 && ROWCOL_IS_BEFORE (screen.cur, selection.end))
864 * If we wrote anywhere in the selected area, kill the selection
865 * XXX: should we kill the mark too? Possibly, but maybe that
866 * should be a similar check.
871 if (screen.flags & Screen_WrapNext)
873 screen.tlen[row] = -1;
875 scr_do_wrap (); row = screen.cur.row + TermWin.saveLines;
877 stp = screen.text[row]; /* _must_ refresh */
878 srp = screen.rend[row]; /* _must_ refresh */
881 if (screen.flags & Screen_Insert)
882 scr_insdel_chars (1, INSERT);
884 // rely on wcwidth to tell us the character width, at least for non-latin1
885 // do wcwidth before further replacements, as wcwidth says that line-drawing
886 // characters have width -1 (DOH!) on GNU/Linux sometimes.
887 int width = c < 0x100 ? 1 : wcwidth (c);
889 if (charsets[screen.charset] == '0') // DEC SPECIAL
891 // vt100 special graphics and line drawing
892 static uint16_t vt100_0[32] = { // 5f .. 7e
893 0x0020, 0x25c6, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0,
894 0x00b1, 0x2424, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c,
895 0x23ba, 0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534,
896 0x252c, 0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7,
899 if (c >= 0x5f && c <= 0x7e)
901 c = vt100_0[c - 0x5f];
909 // trim characters we can't store directly :(
911 # if ENABLE_COMBINING
912 c = rxvt_composite.compose (c); // map to lower 16 bits
917 bool bold = (options & Opt_realBold) && ((rstyle & RS_Bold) != 0);
918 rend_t rend = SET_FONT (rstyle,
919 c > 0x7f || bold || c < 0x20
920 ? TermWin.fontset->find_font (c, bold)
921 : TermWin.ascii_map [c - 0x20]);
925 stp[screen.cur.col] = c;
926 srp[screen.cur.col] = rend;
928 if (screen.cur.col < last_col - 1)
932 screen.tlen[row] = last_col;
933 if (screen.flags & Screen_Autowrap)
934 screen.flags |= Screen_WrapNext;
942 // pad with spaces when overwriting wide character with smaller one
943 for (int c = screen.cur.col; c < last_col && stp[c] == NOCHAR; c++)
952 // handle combining characters
953 // we just tag the accent on the previous on-screen character.
954 // this is arguably not correct, but also arguably not wrong.
955 // we don't handle double-width characters nicely yet.
960 if (screen.cur.col > 0)
962 tp = stp + screen.cur.col - 1;
963 rp = srp + screen.cur.col - 1;
965 else if (screen.cur.row > 0
966 && screen.tlen [screen.cur.row - 1 + TermWin.saveLines] == -1)
968 tp = screen.text[screen.cur.row - 1 + TermWin.saveLines] + last_col - 1;
969 rp = screen.rend[screen.cur.row - 1 + TermWin.saveLines] + last_col - 1;
974 // handle double-width-chars by making them look extremely ugly
976 *tp = ' '; // hack //D //TODO //--tp, --rp;
978 // first try to find a precomposed character
979 unicode_t n = rxvt_compose (*tp, c);
981 n = rxvt_composite.compose (*tp, c);
984 *rp = SET_FONT (*rp, TermWin.fontset->find_font (*tp));
989 if (screen.tlen[row] != -1) /* XXX: think about this */
990 MAX_IT (screen.tlen[row], screen.cur.col);
993 assert (screen.cur.row >= 0);
994 #else /* drive with your eyes closed */
995 MAX_IT (screen.cur.row, 0);
999 /* ------------------------------------------------------------------------- */
1001 * Process Backspace. Move back the cursor back a position, wrap if have to
1005 rxvt_term::scr_backspace ()
1009 if (screen.cur.col == 0)
1011 if (screen.cur.row > 0)
1013 #ifdef TERMCAP_HAS_BW
1014 screen.cur.col = TermWin.ncol - 1;
1020 else if (!(screen.flags & Screen_WrapNext))
1021 scr_gotorc (0, -1, RELATIVE);
1023 screen.flags &= ~Screen_WrapNext;
1026 /* ------------------------------------------------------------------------- */
1028 * Process Horizontal Tab
1029 * count: +ve = forward; -ve = backwards
1033 rxvt_term::scr_tab (int count)
1038 i = x = screen.cur.col;
1044 for (; ++i < TermWin.ncol; )
1053 x = TermWin.ncol - 1;
1055 else /* if (count < 0) */
1069 if (x != screen.cur.col)
1070 scr_gotorc (0, x, R_RELATIVE);
1073 /* ------------------------------------------------------------------------- */
1075 * Process DEC Back Index
1077 * Move cursor left in row. If we're at the left boundary, shift everything
1078 * in that row right. Clear left column.
1082 rxvt_term::scr_backindex ()
1084 if (screen.cur.col > 0)
1085 scr_gotorc (0, -1, R_RELATIVE | C_RELATIVE);
1088 if (screen.tlen[screen.cur.row + TermWin.saveLines] == 0)
1089 return; /* um, yeah? */
1091 scr_insdel_chars (1, INSERT);
1095 /* ------------------------------------------------------------------------- */
1097 * Process DEC Forward Index
1099 * Move cursor right in row. If we're at the right boundary, shift everything
1100 * in that row left. Clear right column.
1104 rxvt_term::scr_forwardindex ()
1108 if (screen.cur.col < TermWin.ncol - 1)
1109 scr_gotorc (0, 1, R_RELATIVE | C_RELATIVE);
1112 row = screen.cur.row + TermWin.saveLines;
1114 if (screen.tlen[row] == 0)
1115 return; /* um, yeah? */
1116 else if (screen.tlen[row] == -1)
1117 screen.tlen[row] = TermWin.ncol;
1119 scr_gotorc (0, 0, R_RELATIVE);
1120 scr_insdel_chars (1, DELETE);
1121 scr_gotorc (0, TermWin.ncol - 1, R_RELATIVE);
1126 /* ------------------------------------------------------------------------- */
1131 rxvt_term::scr_gotorc (int row, int col, int relative)
1136 screen.cur.col = relative & C_RELATIVE ? screen.cur.col + col : col;
1137 MAX_IT (screen.cur.col, 0);
1138 MIN_IT (screen.cur.col, (int32_t)TermWin.ncol - 1);
1140 screen.flags &= ~Screen_WrapNext;
1142 if (relative & R_RELATIVE)
1146 if (screen.cur.row <= screen.bscroll
1147 && (screen.cur.row + row) > screen.bscroll)
1148 screen.cur.row = screen.bscroll;
1150 screen.cur.row += row;
1154 if (screen.cur.row >= screen.tscroll
1155 && (screen.cur.row + row) < screen.tscroll)
1156 screen.cur.row = screen.tscroll;
1158 screen.cur.row += row;
1163 if (screen.flags & Screen_Relative)
1164 { /* relative origin mode */
1165 screen.cur.row = row + screen.tscroll;
1166 MIN_IT (screen.cur.row, screen.bscroll);
1169 screen.cur.row = row;
1172 MAX_IT (screen.cur.row, 0);
1173 MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);
1176 /* ------------------------------------------------------------------------- */
1178 * direction should be UP or DN
1181 rxvt_term::scr_index (enum page_dirn direction)
1188 dirn = ((direction == UP) ? 1 : -1);
1190 screen.flags &= ~Screen_WrapNext;
1192 if ((screen.cur.row == screen.bscroll && direction == UP)
1193 || (screen.cur.row == screen.tscroll && direction == DN))
1194 scr_scroll_text (screen.tscroll, screen.bscroll, dirn, 0);
1196 screen.cur.row += dirn;
1198 MAX_IT (screen.cur.row, 0);
1199 MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);
1200 selection_check (0);
1203 /* ------------------------------------------------------------------------- */
1205 * Erase part or whole of a line
1206 * XTERM_SEQ: Clear line to right: ESC [ 0 K
1207 * XTERM_SEQ: Clear line to left : ESC [ 1 K
1208 * XTERM_SEQ: Clear whole line : ESC [ 2 K
1211 rxvt_term::scr_erase_line (int mode)
1213 unsigned int row, col, num;
1218 selection_check (1);
1220 row = TermWin.saveLines + screen.cur.row;
1223 case 0: /* erase to end of line */
1224 col = screen.cur.col;
1225 num = TermWin.ncol - col;
1226 MIN_IT (screen.tlen[row], (int16_t)col);
1227 if (ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur)
1228 || ROWCOL_IN_ROW_AT_OR_AFTER (selection.end, screen.cur))
1231 case 1: /* erase to beginning of line */
1233 num = screen.cur.col + 1;
1234 if (ROWCOL_IN_ROW_AT_OR_BEFORE (selection.beg, screen.cur)
1235 || ROWCOL_IN_ROW_AT_OR_BEFORE (selection.end, screen.cur))
1238 case 2: /* erase whole line */
1241 screen.tlen[row] = 0;
1242 if (selection.beg.row <= screen.cur.row
1243 && selection.end.row >= screen.cur.row)
1250 if (screen.text[row])
1251 scr_blank_line (&screen.text[row][col], &screen.rend[row][col], num, rstyle);
1253 scr_blank_screen_mem (screen.text, screen.rend, row, rstyle);
1256 /* ------------------------------------------------------------------------- */
1258 * Erase part of whole of the screen
1259 * XTERM_SEQ: Clear screen after cursor : ESC [ 0 J
1260 * XTERM_SEQ: Clear screen before cursor: ESC [ 1 J
1261 * XTERM_SEQ: Clear whole screen : ESC [ 2 J
1264 rxvt_term::scr_erase_screen (int mode)
1267 int32_t row, row_offset;
1274 row_offset = (int32_t)TermWin.saveLines;
1278 case 0: /* erase to end of screen */
1279 selection_check (1);
1281 row = screen.cur.row + 1; /* possible OOB */
1282 num = TermWin.nrow - row;
1284 case 1: /* erase to beginning of screen */
1285 selection_check (3);
1288 num = screen.cur.row;
1290 case 2: /* erase whole screen */
1291 selection_check (3);
1299 if (selection.op && current_screen == selection.screen
1300 && ((selection.beg.row >= row && selection.beg.row <= row + num)
1301 || (selection.end.row >= row
1302 && selection.end.row <= row + num)))
1305 if (row >= TermWin.nrow) /* Out Of Bounds */
1308 MIN_IT (num, (TermWin.nrow - row));
1310 if (rstyle & (RS_RVid | RS_Uline))
1311 ren = (rend_t) ~RS_None;
1312 else if (GET_BASEBG (rstyle) == Color_bg)
1314 ren = DEFAULT_RSTYLE;
1315 CLEAR_ROWS (row, num);
1319 ren = (rstyle & (RS_fgMask | RS_bgMask));
1320 gcvalue.foreground = pix_colors[GET_BGCOLOR (rstyle)];
1321 XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);
1322 ERASE_ROWS (row, num);
1323 gcvalue.foreground = pix_colors[Color_fg];
1324 XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);
1327 for (; num--; row++)
1329 scr_blank_screen_mem (screen.text, screen.rend,
1330 (unsigned int) (row + row_offset), rstyle);
1331 screen.tlen[row + row_offset] = 0;
1332 scr_blank_line (drawn_text[row], drawn_rend[row],
1333 (unsigned int)TermWin.ncol, ren);
1337 /* ------------------------------------------------------------------------- */
1339 * Fill the screen with `E's
1340 * XTERM_SEQ: Screen Alignment Test: ESC # 8
1352 selection_check (3);
1354 fs = SET_FONT (rstyle, TermWin.fontset->find_font ('E'));
1355 for (k = TermWin.saveLines, i = TermWin.nrow; i--; k++)
1357 screen.tlen[k] = TermWin.ncol; /* make the `E's selectable */
1358 fill_text (screen.text[k], 'E', TermWin.ncol);
1359 for (r1 = screen.rend[k], j = TermWin.ncol; j--; )
1364 /* ------------------------------------------------------------------------- */
1366 * Insert/Delete <count> lines
1369 rxvt_term::scr_insdel_lines (int count, int insdel)
1375 selection_check (1);
1377 if (screen.cur.row > screen.bscroll)
1380 end = screen.bscroll - screen.cur.row + 1;
1383 if (insdel == DELETE)
1385 else if (insdel == INSERT)
1391 scr_scroll_text (screen.cur.row, screen.bscroll, insdel * count, 0);
1394 /* ------------------------------------------------------------------------- */
1396 * Insert/Delete <count> characters from the current position
1399 rxvt_term::scr_insdel_chars (int count, int insdel)
1415 selection_check (1);
1416 MIN_IT (count, (TermWin.ncol - screen.cur.col));
1418 row = screen.cur.row + TermWin.saveLines;
1420 stp = screen.text[row];
1421 srp = screen.rend[row];
1422 slp = &screen.tlen[row];
1427 for (col = TermWin.ncol - 1; (col - count) >= screen.cur.col;
1430 stp[col] = stp[col - count];
1431 srp[col] = srp[col - count];
1437 MIN_IT (*slp, TermWin.ncol);
1440 if (selection.op && current_screen == selection.screen
1441 && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
1443 if (selection.end.row != screen.cur.row
1444 || (selection.end.col + count >= TermWin.ncol))
1447 { /* shift selection */
1448 selection.beg.col += count;
1449 selection.mark.col += count; /* XXX: yes? */
1450 selection.end.col += count;
1454 scr_blank_line (& (stp[screen.cur.col]), & (srp[screen.cur.col]),
1455 (unsigned int)count, rstyle);
1459 screen.cur.col += count; /* don't worry if > TermWin.ncol */
1460 selection_check (1);
1461 screen.cur.col -= count;
1462 scr_blank_line (& (stp[screen.cur.col]), & (srp[screen.cur.col]),
1463 (unsigned int)count, rstyle);
1467 tr = srp[TermWin.ncol - 1] & (RS_fgMask | RS_bgMask | RS_baseattrMask);
1469 for (col = screen.cur.col; (col + count) < TermWin.ncol; col++)
1471 stp[col] = stp[col + count];
1472 srp[col] = srp[col + count];
1475 scr_blank_line (& (stp[TermWin.ncol - count]),
1476 & (srp[TermWin.ncol - count]),
1477 (unsigned int)count, tr);
1479 if (*slp == -1) /* break line continuation */
1480 *slp = TermWin.ncol;
1485 if (selection.op && current_screen == selection.screen
1486 && ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
1488 if (selection.end.row != screen.cur.row
1489 || (screen.cur.col >= selection.beg.col - count)
1490 || selection.end.col >= TermWin.ncol)
1494 /* shift selection */
1495 selection.beg.col -= count;
1496 selection.mark.col -= count; /* XXX: yes? */
1497 selection.end.col -= count;
1505 /* ------------------------------------------------------------------------- */
1507 * Set the scrolling region
1508 * XTERM_SEQ: Set region <top> - <bot> inclusive: ESC [ <top> ; <bot> r
1511 rxvt_term::scr_scroll_region (int top, int bot)
1514 MIN_IT (bot, (int)TermWin.nrow - 1);
1519 screen.tscroll = top;
1520 screen.bscroll = bot;
1521 scr_gotorc (0, 0, 0);
1524 /* ------------------------------------------------------------------------- */
1526 * Make the cursor visible/invisible
1527 * XTERM_SEQ: Make cursor visible : ESC [ ? 25 h
1528 * XTERM_SEQ: Make cursor invisible: ESC [ ? 25 l
1531 rxvt_term::scr_cursor_visible (int mode)
1536 screen.flags |= Screen_VisibleCursor;
1538 screen.flags &= ~Screen_VisibleCursor;
1541 /* ------------------------------------------------------------------------- */
1543 * Set/unset automatic wrapping
1544 * XTERM_SEQ: Set Wraparound : ESC [ ? 7 h
1545 * XTERM_SEQ: Unset Wraparound: ESC [ ? 7 l
1548 rxvt_term::scr_autowrap (int mode)
1551 screen.flags |= Screen_Autowrap;
1553 screen.flags &= ~(Screen_Autowrap | Screen_WrapNext);
1556 /* ------------------------------------------------------------------------- */
1558 * Set/unset margin origin mode
1559 * Absolute mode: line numbers are counted relative to top margin of screen
1560 * and the cursor can be moved outside the scrolling region.
1561 * Relative mode: line numbers are relative to top margin of scrolling region
1562 * and the cursor cannot be moved outside.
1563 * XTERM_SEQ: Set Absolute: ESC [ ? 6 h
1564 * XTERM_SEQ: Set Relative: ESC [ ? 6 l
1567 rxvt_term::scr_relative_origin (int mode)
1570 screen.flags |= Screen_Relative;
1572 screen.flags &= ~Screen_Relative;
1573 scr_gotorc (0, 0, 0);
1576 /* ------------------------------------------------------------------------- */
1578 * Set insert/replace mode
1579 * XTERM_SEQ: Set Insert mode : ESC [ ? 4 h
1580 * XTERM_SEQ: Set Replace mode: ESC [ ? 4 l
1583 rxvt_term::scr_insert_mode (int mode)
1586 screen.flags |= Screen_Insert;
1588 screen.flags &= ~Screen_Insert;
1591 /* ------------------------------------------------------------------------- */
1594 * XTERM_SEQ: Set tab at current column : ESC H
1595 * XTERM_SEQ: Clear tab at current column: ESC [ 0 g
1596 * XTERM_SEQ: Clear all tabs : ESC [ 3 g
1599 rxvt_term::scr_set_tab (int mode)
1602 memset (tabs, 0, TermWin.ncol * sizeof (char));
1603 else if (screen.cur.col < TermWin.ncol)
1604 tabs[screen.cur.col] = (mode ? 1 : 0);
1607 /* ------------------------------------------------------------------------- */
1609 * Set reverse/normal video
1610 * XTERM_SEQ: Reverse video: ESC [ ? 5 h
1611 * XTERM_SEQ: Normal video : ESC [ ? 5 l
1614 rxvt_term::scr_rvideo_mode (int mode)
1621 SWAP_IT (pix_colors[Color_fg], pix_colors[Color_bg], rxvt_color);
1622 #if defined(XPM_BACKGROUND)
1623 if (bgPixmap.pixmap == None)
1625 #if defined(TRANSPARENT)
1626 if (! (options & Opt_transparent) || am_transparent == 0)
1628 XSetWindowBackground (display->display, TermWin.vt,
1629 pix_colors[Color_bg]);
1631 gcvalue.foreground = pix_colors[Color_fg];
1632 gcvalue.background = pix_colors[Color_bg];
1633 XChangeGC (display->display, TermWin.gc, GCBackground | GCForeground,
1640 /* ------------------------------------------------------------------------- */
1642 * Report current cursor position
1643 * XTERM_SEQ: Report position: ESC [ 6 n
1646 rxvt_term::scr_report_position ()
1648 tt_printf ("\033[%d;%dR", screen.cur.row + 1, screen.cur.col + 1);
1651 /* ------------------------------------------------------------------------- *
1653 * ------------------------------------------------------------------------- */
1659 rxvt_term::set_font_style ()
1661 switch (charsets[screen.charset])
1663 case '0': /* DEC Special Character & Line Drawing Set */
1665 case 'A': /* United Kingdom (UK) */
1667 case 'B': /* United States (USASCII) */
1669 case '<': /* Multinational character set */
1671 case '5': /* Finnish character set */
1673 case 'C': /* Finnish character set */
1675 case 'K': /* German character set */
1680 /* ------------------------------------------------------------------------- */
1683 * XTERM_SEQ: Invoke G0 character set: CTRL-O
1684 * XTERM_SEQ: Invoke G1 character set: CTRL-N
1685 * XTERM_SEQ: Invoke G2 character set: ESC N
1686 * XTERM_SEQ: Invoke G3 character set: ESC O
1689 rxvt_term::scr_charset_choose (int set)
1691 screen.charset = set;
1695 /* ------------------------------------------------------------------------- */
1698 * XTERM_SEQ: Set G0 character set: ESC ( <C>
1699 * XTERM_SEQ: Set G1 character set: ESC ) <C>
1700 * XTERM_SEQ: Set G2 character set: ESC * <C>
1701 * XTERM_SEQ: Set G3 character set: ESC + <C>
1702 * See set_font_style for possible values for <C>
1705 rxvt_term::scr_charset_set (int set, unsigned int ch)
1707 charsets[set] = (unsigned char)ch;
1712 /* ------------------------------------------------------------------------- *
1713 * MAJOR SCREEN MANIPULATION *
1714 * ------------------------------------------------------------------------- */
1717 * refresh matching text.
1720 rxvt_term::scr_refresh_rend (rend_t mask, rend_t value)
1724 for (int i = 0; i < TermWin.nrow; i++)
1727 rend_t *drp = drawn_rend [i];
1729 for (; col < TermWin.ncol; col++, drp++)
1730 if ((*drp & mask) == value)
1750 rxvt_term::scr_expose (int x, int y, int width, int height, bool refresh)
1753 row_col_t rc[RC_COUNT];
1755 if (drawn_text == NULL) /* sanity check */
1758 #ifndef NO_SLOW_LINK_SUPPORT
1759 if (refresh_type == FAST_REFRESH && !display->is_local)
1762 height = TermWin.height;
1768 x = min (x, (int)TermWin.width);
1770 y = min (y, (int)TermWin.height);
1774 rc[PART_BEG].col = Pixel2Col (x);
1775 rc[PART_BEG].row = Pixel2Row (y);
1777 rc[PART_END].col = Pixel2Width (x + width + TermWin.fwidth - 1);
1778 rc[PART_END].row = Pixel2Row (y + height + TermWin.fheight - 1);
1781 for (i = PART_BEG; i < RC_COUNT; i++)
1783 MIN_IT (rc[i].col, TermWin.ncol - 1);
1784 MIN_IT (rc[i].row, TermWin.nrow - 1);
1787 for (i = rc[PART_BEG].row; i <= rc[PART_END].row; i++)
1788 fill_text (&drawn_text[i][rc[PART_BEG].col], 0, rc[PART_END].col - rc[PART_BEG].col + 1);
1791 scr_refresh (SLOW_REFRESH);
1794 /* ------------------------------------------------------------------------- */
1796 * Refresh the entire screen
1799 rxvt_term::scr_touch (bool refresh)
1801 scr_expose (0, 0, TermWin.width, TermWin.height, refresh);
1804 /* ------------------------------------------------------------------------- */
1806 * Move the display so that the line represented by scrollbar value Y is at
1807 * the top of the screen
1810 rxvt_term::scr_move_to (int y, int len)
1813 uint16_t oldviewstart;
1815 oldviewstart = TermWin.view_start;
1819 p = (TermWin.nrow + TermWin.nscrolled) * (len - y) / len;
1820 p -= (long) (TermWin.nrow - 1);
1824 TermWin.view_start = (uint16_t)min (p, TermWin.nscrolled);
1826 return scr_changeview (oldviewstart);
1829 /* ------------------------------------------------------------------------- */
1831 * Page the screen up/down nlines
1832 * direction should be UP or DN
1835 rxvt_term::scr_page (enum page_dirn direction, int nlines)
1838 uint16_t oldviewstart;
1841 assert ((nlines >= 0) && (nlines <= TermWin.nrow));
1843 oldviewstart = TermWin.view_start;
1844 if (direction == UP)
1846 n = TermWin.view_start + nlines;
1847 TermWin.view_start = min (n, TermWin.nscrolled);
1851 n = TermWin.view_start - nlines;
1852 TermWin.view_start = max (n, 0);
1854 return scr_changeview (oldviewstart);
1858 rxvt_term::scr_changeview (uint16_t oldviewstart)
1860 if (TermWin.view_start != oldviewstart)
1863 num_scr -= (TermWin.view_start - oldviewstart);
1866 return (int) (TermWin.view_start - oldviewstart);
1869 /* ------------------------------------------------------------------------- */
1871 rxvt_term::scr_bell ()
1874 # ifndef NO_MAPALERT
1875 # ifdef MAPALERT_OPTION
1876 if (options & Opt_mapAlert)
1878 XMapWindow (display->display, TermWin.parent[0]);
1880 if (options & Opt_visualBell)
1882 scr_rvideo_mode (!rvideo); /* refresh also done */
1883 scr_rvideo_mode (!rvideo); /* refresh also done */
1886 XBell (display->display, 0);
1890 /* ------------------------------------------------------------------------- */
1893 rxvt_term::scr_printscreen (int fullhist)
1896 int i, r1, nrows, row_offset;
1899 if ((fd = popen_printer ()) == NULL)
1902 nrows = TermWin.nrow;
1903 row_offset = TermWin.saveLines;
1906 row_offset -= TermWin.view_start;
1909 nrows += TermWin.nscrolled;
1910 row_offset -= TermWin.nscrolled;
1915 for (r1 = 0; r1 < nrows; r1++)
1917 text_t *tp = screen.text[r1 + row_offset];
1918 int len = screen.tlen[r1 + row_offset];
1920 for (i = len >= 0 ? len : TermWin.ncol - 1; i--; )
1922 char mb[MB_LEN_MAX];
1927 len = wctomb (mb, t);
1935 fwrite (mb, 1, len, fd);
1941 pclose_printer (fd);
1945 /* ------------------------------------------------------------------------- */
1947 * Refresh the screen
1948 * drawn_text/drawn_rend contain the screen information before the update.
1949 * screen.text/screen.rend contain what the screen will change to.
1952 #define FONT_WIDTH(X, Y) \
1953 (X)->per_char[ (Y) - (X)->min_char_or_byte2].width
1954 #define FONT_RBEAR(X, Y) \
1955 (X)->per_char[ (Y) - (X)->min_char_or_byte2].rbearing
1956 #define FONT_LBEAR(X, Y) \
1957 (X)->per_char[ (Y) - (X)->min_char_or_byte2].lbearing
1958 #define IS_FONT_CHAR(X, Y) \
1959 ((Y) >= (X)->min_char_or_byte2 && (Y) <= (X)->max_char_or_byte2)
1962 rxvt_term::scr_refresh (unsigned char refresh_type)
1964 unsigned char must_clear, /* use draw_string not draw_image_string */
1965 rvid, /* reverse video this position */
1966 showcursor; /* show the cursor */
1967 int16_t col, row, /* column/row we're processing */
1968 ocrow; /* old cursor row */
1970 row_offset; /* basic offset in screen structure */
1971 #ifndef NO_CURSORCOLOR
1972 rend_t cc1; /* store colours at cursor position (s) */
1974 rend_t *crp; // cursor rendition pointer
1976 if (refresh_type == NO_REFRESH || !TermWin.mapped)
1985 row_offset = TermWin.saveLines - TermWin.view_start;
1987 #ifdef XPM_BACKGROUND
1988 must_clear |= (bgPixmap.pixmap != None);
1991 must_clear |= ((options & Opt_transparent) && am_transparent);
1993 ocrow = oldcursor.row; /* is there an old outline cursor on screen? */
1996 * B: reverse any characters which are selected
1998 scr_reverse_selection ();
2000 scr_swap_overlay ();
2004 * C: set the cursor character (s)
2007 unsigned char setoldcursor;
2008 rend_t ccol1, /* Cursor colour */
2009 ccol2; /* Cursor colour2 */
2011 showcursor = (screen.flags & Screen_VisibleCursor);
2019 int col = screen.cur.col;
2021 while (col && screen.text[screen.cur.row + TermWin.saveLines][col] == NOCHAR)
2024 crp = &screen.rend[screen.cur.row + TermWin.saveLines][col];
2026 if (showcursor && TermWin.focus)
2029 #ifndef NO_CURSORCOLOR
2030 cc1 = *crp & (RS_fgMask | RS_bgMask);
2031 if (ISSET_PIXCOLOR (Color_cursor))
2032 ccol1 = Color_cursor;
2034 #ifdef CURSOR_COLOR_IS_RENDITION_COLOR
2035 ccol1 = GET_FGCOLOR (rstyle);
2039 if (ISSET_PIXCOLOR (Color_cursor2))
2040 ccol2 = Color_cursor2;
2042 #ifdef CURSOR_COLOR_IS_RENDITION_COLOR
2043 ccol2 = GET_BGCOLOR (rstyle);
2047 *crp = SET_FGCOLOR (*crp, ccol1);
2048 *crp = SET_BGCOLOR (*crp, ccol2);
2053 /* make sure no outline cursor is left around */
2057 if (screen.cur.row + TermWin.view_start != ocrow
2058 || screen.cur.col != oldcursor.col)
2060 if (ocrow < TermWin.nrow
2061 && oldcursor.col < TermWin.ncol)
2062 drawn_rend[ocrow][oldcursor.col] ^= (RS_RVid | RS_Uline);
2064 if (TermWin.focus || !showcursor)
2070 else if (!TermWin.focus)
2075 if (screen.cur.row + TermWin.view_start >= TermWin.nrow)
2079 oldcursor.row = screen.cur.row + TermWin.view_start;
2080 oldcursor.col = screen.cur.col;
2085 rend_t *drp, *srp; /* drawn-rend-pointer, screen-rend-pointer */
2086 text_t *dtp, *stp; /* drawn-text-pointer, screen-text-pointer */
2087 #ifndef NO_SLOW_LINK_SUPPORT
2089 * D: CopyArea pass - very useful for slower links
2090 * This has been deliberately kept simple.
2093 if (!display->is_local
2094 && refresh_type == FAST_REFRESH && num_scr_allow && i
2095 && abs (i) < TermWin.nrow && !must_clear)
2103 row = i > 0 ? 0 : j - 1;
2104 for (; j-- >= 0; row += (i > 0 ? 1 : -1))
2106 if (row + i >= 0 && row + i < TermWin.nrow && row + i != ocrow)
2108 text_t *stp = screen.text[row + row_offset];
2109 rend_t *srp = screen.rend[row + row_offset];
2110 text_t *dtp = drawn_text[row];
2111 text_t *dtp2 = drawn_text[row + i];
2112 rend_t *drp = drawn_rend[row];
2113 rend_t *drp2 = drawn_rend[row + i];
2115 for (nits = 0, col = TermWin.ncol; col--; )
2116 if (stp[col] != dtp2[col] || srp[col] != drp2[col])
2118 else if (stp[col] != dtp[col] || srp[col] != drp[col])
2121 if (nits > 8) /* XXX: arbitrary choice */
2123 for (col = TermWin.ncol; col--; )
2139 /* also comes here at end if needed because of >= above */
2141 SWAP_IT (wlen, len, int);
2143 XCopyArea (display->display, TermWin.vt, TermWin.vt,
2144 TermWin.gc, 0, Row2Pixel (len + i),
2145 (unsigned int)TermWin_TotalWidth (),
2146 (unsigned int)Height2Pixel (wlen - len + 1),
2147 0, Row2Pixel (len));
2155 * E: main pass across every character
2157 for (row = 0; row < TermWin.nrow; row++)
2159 text_t *stp = screen.text[row + row_offset];
2160 rend_t *srp = screen.rend[row + row_offset];
2161 text_t *dtp = drawn_text[row];
2162 rend_t *drp = drawn_rend[row];
2165 * E2: OK, now the real pass
2167 int ypixel = (int)Row2Pixel (row);
2169 for (col = 0; col < TermWin.ncol; col++)
2171 /* compare new text with old - if exactly the same then continue */
2172 if (stp[col] == dtp[col] /* Must match characters to skip. */
2173 && (srp[col] == drp[col] /* Either rendition the same or */
2174 || (stp[col] == ' ' /* space w/ no background change */
2175 && GET_BGATTR (srp[col]) == GET_BGATTR (drp[col]))))
2178 // redraw one or more characters
2180 // seek to the beginning if wide characters
2181 while (stp[col] == NOCHAR && col > 0)
2184 rend_t rend = srp[col]; /* screen rendition (target rendtion) */
2185 text_t *text = stp + col;
2188 dtp[col] = stp[col];
2191 int xpixel = Col2Pixel (col);
2193 // this loop looks very messy, it can probably be optimized
2194 // and cleaned a bit by you?
2195 for (i = 0; ++col < TermWin.ncol; )
2197 if (stp[col] == NOCHAR)
2199 dtp[col] = stp[col];
2207 if (rend != srp[col])
2212 if (stp[col] != dtp[col]
2213 || srp[col] != drp[col])
2215 if (must_clear && (i++ > count / 2))
2218 dtp[col] = stp[col];
2222 else if (must_clear || (stp[col] != ' ' && ++i >= 16))
2226 col--; /* went one too far. move back */
2227 count -= i; /* dump any matching trailing chars */
2229 // sometimes we optimize away the trailing NOCHAR's, add them back
2230 while (i && text[count] == NOCHAR)
2234 * Determine the attributes for the string
2236 int fid = GET_FONT (rend);
2237 int fore = GET_FGCOLOR (rend); // desired foreground
2238 int back = GET_BGCOLOR (rend); // desired background
2240 rend = GET_ATTR (rend);
2242 rvid = !!(rend & RS_RVid);
2244 #ifndef NO_BOLD_UNDERLINE_REVERSE
2245 if (rend & RS_Bold && fore == Color_fg && !(options & Opt_realBold))
2247 if (ISSET_PIXCOLOR (Color_BD))
2253 if (rend & RS_Uline)
2254 if (ISSET_PIXCOLOR (Color_UL))
2260 SWAP_IT (fore, back, int);
2262 #ifndef NO_BOLD_UNDERLINE_REVERSE
2263 if (ISSET_PIXCOLOR (Color_RV)
2264 # ifndef NO_CURSORCOLOR
2265 && !ISSET_PIXCOLOR (Color_cursor)
2273 if (rend & RS_Blink && (back == Color_bg || fore == Color_bg))
2275 if (!text_blink_ev.active)
2277 text_blink_ev.start (NOW + TEXT_BLINK_INTERVAL);
2280 else if (hidden_text)
2286 * Actually do the drawing of the string here
2288 rxvt_font *font = (*TermWin.fontset)[fid];
2291 font->clear_rect (*TermWin.drawable, xpixel, ypixel,
2292 TermWin.fwidth * count, TermWin.fheight,
2294 else if (back == Color_bg)
2298 CLEAR_CHARS (xpixel, ypixel, count);
2300 for (i = 0; i < count; i++) /* don't draw empty strings */
2303 font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, -1);
2308 font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, Color_bg);
2311 font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, back);
2313 if (rend & RS_Uline && font->descent > 1 && fore != back)
2314 XDrawLine (display->display, drawBuffer, TermWin.gc,
2315 xpixel, ypixel + font->ascent + 1,
2316 xpixel + Width2Pixel (count) - 1, ypixel + font->ascent + 1);
2317 } /* for (col....) */
2318 } /* for (row....) */
2321 * G: cleanup cursor and display outline cursor if necessary
2328 #ifndef NO_CURSORCOLOR
2329 *crp = (*crp & ~ (RS_fgMask | RS_bgMask)) | cc1;
2332 else if (oldcursor.row >= 0)
2334 #ifndef NO_CURSORCOLOR
2335 if (ISSET_PIXCOLOR (Color_cursor))
2336 XSetForeground (display->display, TermWin.gc, pix_colors[Color_cursor]);
2338 int cursorwidth = 1;
2339 while (oldcursor.col + cursorwidth < TermWin.ncol
2340 && drawn_text[oldcursor.row][oldcursor.col + cursorwidth] == NOCHAR)
2343 XDrawRectangle (display->display, drawBuffer, TermWin.gc,
2344 Col2Pixel (oldcursor.col),
2345 Row2Pixel (oldcursor.row),
2346 (unsigned int) (Width2Pixel (cursorwidth) - 1),
2347 (unsigned int) (Height2Pixel (1) - TermWin.lineSpace - 1));
2352 * H: cleanup selection
2355 scr_swap_overlay ();
2357 scr_reverse_selection ();
2359 if (refresh_type & SMOOTH_REFRESH)
2360 XFlush (display->display);
2364 want_refresh = 0; /* screen is current */
2368 rxvt_term::scr_remap_chars (text_t *tp, rend_t *rp)
2373 for (int i = TermWin.ncol; i; i--, rp++, tp++)
2374 *rp = SET_FONT (*rp, TermWin.fontset->find_font (*tp));
2378 rxvt_term::scr_remap_chars ()
2380 for (int i = TermWin.nrow + TermWin.saveLines; i--; )
2381 scr_remap_chars (screen.text[i], screen.rend[i]);
2383 for (int i = TermWin.nrow; i--; )
2385 scr_remap_chars (drawn_text[i], drawn_rend[i]);
2386 scr_remap_chars (swap.text[i], swap.rend[i]);
2390 /* ------------------------------------------------------------------------- */
2392 rxvt_term::scr_clear (bool really)
2394 if (!TermWin.mapped)
2401 if ((options & Opt_transparent) && (am_pixmap_trans == 0))
2405 if (! (options & Opt_transparent_all))
2408 i = (int) (sizeof (TermWin.parent) / sizeof (Window));
2411 if (TermWin.parent[i] != None)
2412 XClearWindow (display->display, TermWin.parent[i]);
2417 XClearWindow (display->display, TermWin.vt);
2420 /* ------------------------------------------------------------------------- */
2422 rxvt_term::scr_reverse_selection ()
2424 if (selection.op && current_screen == selection.screen)
2426 int end_row = TermWin.saveLines - TermWin.view_start;
2427 int i = selection.beg.row + TermWin.saveLines;
2428 int col, row = selection.end.row + TermWin.saveLines;
2432 col = selection.beg.col;
2439 end_row += TermWin.nrow;
2440 for (; i < row && i < end_row; i++, col = 0)
2441 for (srp = screen.rend[i]; col < TermWin.ncol; col++)
2442 srp[col] ^= RS_RVid;
2444 if (i == row && i < end_row)
2445 for (srp = screen.rend[i]; col < selection.end.col; col++)
2446 srp[col] ^= RS_RVid;
2450 /* ------------------------------------------------------------------------- */
2452 * Dump the whole scrollback and screen to the passed filedescriptor. The
2453 * invoking routine must close the fd.
2457 rxvt_term::scr_dump (int fd)
2460 unsigned int width, towrite;
2463 for (row = TermWin.saveLines - TermWin.nscrolled;
2464 row < TermWin.saveLines + TermWin.nrow - 1; row++)
2466 width = screen.tlen[row] >= 0 ? screen.tlen[row]
2468 for (towrite = width; towrite; towrite -= wrote)
2470 wrote = write (fd, & (screen.text[row][width - towrite]),
2473 return; /* XXX: death, no report */
2475 if (screen.tlen[row] >= 0)
2476 if (write (fd, r1, 1) <= 0)
2477 return; /* XXX: death, no report */
2482 /* ------------------------------------------------------------------------- *
2483 * CHARACTER SELECTION *
2484 * ------------------------------------------------------------------------- */
2487 * -TermWin.nscrolled <= (selection row) <= TermWin.nrow - 1
2490 rxvt_term::selection_check (int check_more)
2497 pos.row = pos.col = 0;
2498 if ((selection.beg.row < - (int32_t)TermWin.nscrolled)
2499 || (selection.beg.row >= TermWin.nrow)
2500 || (selection.mark.row < - (int32_t)TermWin.nscrolled)
2501 || (selection.mark.row >= TermWin.nrow)
2502 || (selection.end.row < - (int32_t)TermWin.nscrolled)
2503 || (selection.end.row >= TermWin.nrow)
2505 && current_screen == selection.screen
2506 && !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
2507 && ROWCOL_IS_BEFORE (screen.cur, selection.end))
2509 && ROWCOL_IS_BEFORE (selection.beg, pos)
2510 && ROWCOL_IS_AFTER (selection.end, pos))
2512 && ROWCOL_IS_AFTER (selection.end, pos))
2513 || (check_more == 4 /* screen width change */
2514 && (selection.beg.row != selection.end.row
2515 || selection.end.col > TermWin.ncol)))
2519 /* ------------------------------------------------------------------------- */
2521 * Paste a selection direct to the command fd
2524 rxvt_term::paste (const unsigned char *data, unsigned int len)
2526 unsigned int i, j, n;
2527 unsigned char *ds = (unsigned char *)rxvt_malloc (PROP_SIZE);
2529 /* convert normal newline chars into common keyboard Return key sequence */
2530 for (i = 0; i < len; i += PROP_SIZE)
2532 n = min (len - i, PROP_SIZE);
2533 memcpy (ds, data + i, n);
2535 for (j = 0; j < n; j++)
2539 tt_write (ds, (int)n);
2545 /* ------------------------------------------------------------------------- */
2547 * Respond to a notification that a primary selection has been sent
2548 * EXT: SelectionNotify
2551 rxvt_term::selection_paste (Window win, Atom prop, bool delete_prop)
2554 unsigned long bytes_after;
2557 if (prop == None) /* check for failed XConvertSelection */
2559 if ((selection_type & Sel_CompoundText))
2561 int selnum = selection_type & Sel_whereMask;
2564 if (selnum != Sel_direct)
2565 selection_request_other (XA_STRING, selnum);
2568 if ((selection_type & Sel_UTF8String))
2570 int selnum = selection_type & Sel_whereMask;
2572 selection_type = Sel_CompoundText;
2573 if (selnum != Sel_direct)
2574 selection_request_other (xa[XA_COMPOUND_TEXT], selnum);
2584 if (XGetWindowProperty (display->display, win, prop, (long) (nread / 4),
2585 (long) (PROP_SIZE / 4), delete_prop,
2586 AnyPropertyType, &ct.encoding, &ct.format,
2587 &ct.nitems, &bytes_after,
2588 &ct.value) != Success)
2591 if (ct.encoding == 0)
2594 if (ct.encoding == xa[XA_INCR])
2596 // INCR selection, start handshake
2597 XDeleteProperty (display->display, win, prop);
2598 selection_wait = Sel_incr;
2599 incr_ev.start (NOW + 10);
2603 if (ct.value == NULL)
2608 if (selection_wait == Sel_normal && nread == 0
2609 && (win != display->root || prop != XA_CUT_BUFFER0)) // avoid recursion
2612 * pass through again trying CUT_BUFFER0 if we've come from
2613 * XConvertSelection () but nothing was presented
2615 selection_paste (display->root, XA_CUT_BUFFER0, False);
2618 nread = -1; /* discount any previous stuff */
2626 if (XmbTextPropertyToTextList (display->display, &ct, &cl, &cr) >= 0 && cl)
2628 for (int i = 0; i < cr; i++)
2629 paste ((unsigned char *)cl[i], strlen (cl[i]));
2631 XFreeStringList (cl);
2634 paste (ct.value, ct.nitems);
2636 if (bytes_after == 0)
2645 if (selection_wait == Sel_normal)
2646 selection_wait = Sel_none;
2652 rxvt_term::incr_cb (time_watcher &w)
2654 selection_wait = Sel_none;
2656 rxvt_warn ("data loss: timeout on INCR selection paste, ignoring.\n");
2660 * INCR support originally provided by Paul Sheer <psheer@obsidian.co.za>
2663 rxvt_term::selection_property (Window win, Atom prop)
2665 if (prop == None || selection_wait != Sel_incr)
2668 if (selection_paste (win, prop, 1) > 0)
2669 incr_ev.start (NOW + 10);
2672 selection_wait = Sel_none;
2677 /* ------------------------------------------------------------------------- */
2679 * Request the current selection:
2680 * Order: > internal selection if available
2681 * > PRIMARY, SECONDARY, CLIPBOARD if ownership is claimed (+)
2683 * (+) if ownership is claimed but property is empty, rxvt_selection_paste ()
2684 * will auto fallback to CUT_BUFFER0
2685 * EXT: button 2 release
2688 rxvt_term::selection_request (Time tm, int x, int y)
2690 if (x < 0 || x >= TermWin.width || y < 0 || y >= TermWin.height)
2691 return; /* outside window */
2694 { /* internal selection */
2695 char *str = rxvt_wcstombs (selection.text, selection.len);
2696 paste ((unsigned char *)str, strlen (str));
2704 selection_request_time = tm;
2705 selection_wait = Sel_normal;
2707 for (i = Sel_Primary; i <= Sel_Clipboard; i++)
2709 #if X_HAVE_UTF8_STRING
2710 selection_type = Sel_UTF8String;
2711 if (selection_request_other (xa[XA_UTF8_STRING], i))
2714 selection_type = Sel_CompoundText;
2715 if (selection_request_other (xa[XA_COMPOUND_TEXT], i))
2722 selection_wait = Sel_none; /* don't loop in rxvt_selection_paste () */
2723 selection_paste (display->root, XA_CUT_BUFFER0, False);
2727 rxvt_term::selection_request_other (Atom target, int selnum)
2731 char *debug_xa_names[] = { "PRIMARY", "SECONDARY", "CLIPBOARD" };
2734 selection_type |= selnum;
2736 if (selnum == Sel_Primary)
2738 else if (selnum == Sel_Secondary)
2741 sel = xa[XA_CLIPBOARD];
2743 if (XGetSelectionOwner (display->display, sel) != None)
2745 XConvertSelection (display->display, sel, target, xa[XA_VT_SELECTION],
2746 TermWin.vt, selection_request_time);
2753 /* ------------------------------------------------------------------------- */
2755 * Clear all selected text
2756 * EXT: SelectionClear
2759 rxvt_term::selection_clear ()
2762 free (selection.text);
2763 selection.text = NULL;
2767 if (display->selection_owner == this)
2768 display->selection_owner = 0;
2771 /* ------------------------------------------------------------------------- */
2773 * Copy a selection into the cut buffer
2774 * EXT: button 1 or 3 release
2777 rxvt_term::selection_make (Time tm)
2779 int i, col, end_col, row, end_row;
2780 wchar_t *new_selection_text;
2783 switch (selection.op)
2785 case SELECTION_CONT:
2787 case SELECTION_INIT:
2790 case SELECTION_BEGIN:
2791 selection.op = SELECTION_DONE;
2797 selection.op = SELECTION_DONE;
2799 if (selection.clicks == 4)
2800 return; /* nothing selected, go away */
2802 i = (selection.end.row - selection.beg.row + 1) * (TermWin.ncol + 1);
2803 new_selection_text = (wchar_t *)rxvt_malloc ((i + 4) * sizeof (wchar_t));
2805 col = selection.beg.col;
2807 row = selection.beg.row + TermWin.saveLines;
2808 end_row = selection.end.row + TermWin.saveLines;
2812 for (; row <= end_row; row++, col = 0)
2814 t = &screen.text[row][col];
2816 end_col = screen.tlen[row];
2819 end_col = TermWin.ncol;
2822 MIN_IT (end_col, selection.end.col);
2824 for (; col < end_col; col++)
2828 #if ENABLE_COMBINING
2829 else if (IS_COMPOSE (*t))
2831 int len = rxvt_composite.expand (*t, 0);
2839 new_selection_text = (wchar_t *)rxvt_realloc (new_selection_text, (i + 4) * sizeof (wchar_t));
2842 ofs += rxvt_composite.expand (*t++, new_selection_text + ofs);
2846 new_selection_text[ofs++] = *t++;
2849 if (screen.tlen[row] != -1 && row != end_row)
2850 new_selection_text[ofs++] = C0_LF;
2853 if (end_col != selection.end.col)
2854 new_selection_text[ofs++] = C0_LF;
2856 new_selection_text[ofs] = 0;
2860 free (new_selection_text);
2864 free (selection.text);
2866 // we usually allocate much more than necessary, so realloc it smaller again
2867 selection.len = ofs;
2868 selection.text = (wchar_t *)rxvt_realloc (new_selection_text, (ofs + 1) * sizeof (wchar_t));
2870 XSetSelectionOwner (display->display, XA_PRIMARY, TermWin.vt, tm);
2871 if (XGetSelectionOwner (display->display, XA_PRIMARY) == TermWin.vt)
2872 display->set_selection_owner (this);
2874 rxvt_warn ("can't get primary selection, ignoring.\n");
2879 if (XwcTextListToTextProperty (display->display, &selection.text, 1, XStringStyle, &ct) >= 0)
2881 XChangeProperty (display->display, display->root, XA_CUT_BUFFER0, XA_STRING, 8,
2882 PropModeReplace, ct.value, ct.nitems);
2887 selection_time = tm;
2890 /* ------------------------------------------------------------------------- */
2892 * Mark or select text based upon number of clicks: 1, 2, or 3
2893 * EXT: button 1 press
2896 rxvt_term::selection_click (int clicks, int x, int y)
2898 clicks = ((clicks - 1) % 3) + 1;
2899 selection.clicks = clicks; /* save clicks so extend will work */
2901 selection_start_colrow (Pixel2Col (x), Pixel2Row (y));
2903 if (clicks == 2 || clicks == 3)
2904 selection_extend_colrow (selection.mark.col,
2905 selection.mark.row + TermWin.view_start,
2907 1, /* button press */
2908 0); /* click change */
2911 /* ------------------------------------------------------------------------- */
2913 * Mark a selection at the specified col/row
2916 rxvt_term::selection_start_colrow (int col, int row)
2919 selection.mark.col = col;
2920 selection.mark.row = row - TermWin.view_start;
2922 MAX_IT (selection.mark.row, - (int32_t)TermWin.nscrolled);
2923 MIN_IT (selection.mark.row, (int32_t)TermWin.nrow - 1);
2924 MAX_IT (selection.mark.col, 0);
2925 MIN_IT (selection.mark.col, (int32_t)TermWin.ncol - 1);
2927 while (selection.mark.col > 0
2928 && screen.text[selection.mark.row + TermWin.saveLines][selection.mark.col] == NOCHAR)
2929 --selection.mark.col;
2932 { /* clear the old selection */
2933 selection.beg.row = selection.end.row = selection.mark.row;
2934 selection.beg.col = selection.end.col = selection.mark.col;
2937 selection.op = SELECTION_INIT;
2938 selection.screen = current_screen;
2941 /* ------------------------------------------------------------------------- */
2943 * Word select: select text for 2 clicks
2944 * We now only find out the boundary in one direction
2947 /* what do we want: spaces/tabs are delimiters or cutchars or non-cutchars */
2948 #define DELIMIT_TEXT(x) \
2949 (unicode::is_space (x) ? 2 : (x) <= 0xff && !!strchr (rs[Rs_cutchars], (x)))
2950 #define DELIMIT_REND(x) 1
2953 rxvt_term::selection_delimit_word (enum page_dirn dirn, const row_col_t *mark, row_col_t *ret)
2955 int col, row, dirnadd, tcol, trow, w1, w2;
2962 bound.row = TermWin.saveLines - TermWin.nscrolled - 1;
2968 bound.row = TermWin.saveLines + TermWin.nrow;
2969 bound.col = TermWin.ncol - 1;
2973 row = mark->row + TermWin.saveLines;
2976 /* find the edge of a word */
2977 stp = &screen.text[row][col];
2978 w1 = DELIMIT_TEXT (*stp);
2980 srp = &screen.rend[row][col];
2981 w2 = DELIMIT_REND (*srp);
2985 for (; col != bound.col; col += dirnadd)
2993 if (DELIMIT_TEXT (*stp) != w1)
2995 if (DELIMIT_REND (*srp) != w2)
2999 if ((col == bound.col) && (row != bound.row))
3001 if (screen.tlen[ (row - (dirn == UP ? 1 : 0))] == -1)
3003 trow = row + dirnadd;
3004 tcol = dirn == UP ? TermWin.ncol - 1 : 0;
3006 if (screen.text[trow] == NULL)
3009 stp = & (screen.text[trow][tcol]);
3010 srp = & (screen.rend[trow][tcol]);
3012 if (DELIMIT_TEXT (*stp) != w1 || DELIMIT_REND (*srp) != w2)
3023 Old_Word_Selection_You_Die:
3025 col++; /* put us on one past the end */
3027 /* Poke the values back in */
3028 ret->row = row - TermWin.saveLines;
3032 /* ------------------------------------------------------------------------- */
3034 * Extend the selection to the specified x/y pixel location
3035 * EXT: button 3 press; button 1 or 3 drag
3036 * flag == 0 ==> button 1
3037 * flag == 1 ==> button 3 press
3038 * flag == 2 ==> button 3 motion
3041 rxvt_term::selection_extend (int x, int y, int flag)
3045 col = Pixel2Col (x);
3046 row = Pixel2Row (y);
3048 MIN_IT (row, (int)TermWin.nrow - 1);
3050 MIN_IT (col, (int)TermWin.ncol);
3053 * If we're selecting characters (single click) then we must check first
3054 * if we are at the same place as the original mark. If we are then
3055 * select nothing. Otherwise, if we're to the right of the mark, you have to
3056 * be _past_ a character for it to be selected.
3058 if (((selection.clicks % 3) == 1) && !flag
3059 && (col == selection.mark.col
3060 && (row == selection.mark.row + TermWin.view_start)))
3062 /* select nothing */
3063 selection.beg.row = selection.end.row = 0;
3064 selection.beg.col = selection.end.col = 0;
3065 selection.clicks = 4;
3070 if (selection.clicks == 4)
3071 selection.clicks = 1;
3073 selection_extend_colrow (col, row, !!flag, /* ? button 3 */
3074 flag == 1 ? 1 : 0, /* ? button press */
3075 0); /* no click change */
3078 /* ------------------------------------------------------------------------- */
3080 * Extend the selection to the specified col/row
3083 rxvt_term::selection_extend_colrow (int32_t col, int32_t row, int button3, int buttonpress, int clickchange)
3085 int16_t ncol = TermWin.ncol;
3093 switch (selection.op)
3095 case SELECTION_INIT:
3097 selection.op = SELECTION_BEGIN;
3099 case SELECTION_BEGIN:
3100 if (row != selection.mark.row || col != selection.mark.col
3101 || (!button3 && buttonpress))
3102 selection.op = SELECTION_CONT;
3104 case SELECTION_DONE:
3105 selection.op = SELECTION_CONT;
3107 case SELECTION_CONT:
3109 case SELECTION_CLEAR:
3110 selection_start_colrow (col, row);
3115 if (selection.beg.col == selection.end.col
3116 && selection.beg.col != selection.mark.col
3117 && selection.beg.row == selection.end.row
3118 && selection.beg.row != selection.mark.row)
3120 selection.beg.col = selection.end.col = selection.mark.col;
3121 selection.beg.row = selection.end.row = selection.mark.row;
3127 pos.row -= TermWin.view_start; /* adjust for scroll */
3130 * This is mainly xterm style selection with a couple of differences, mainly
3131 * in the way button3 drag extension works.
3132 * We're either doing: button1 drag; button3 press; or button3 drag
3133 * a) button1 drag : select around a midpoint/word/line - that point/word/line
3134 * is always at the left/right edge of the selection.
3135 * b) button3 press: extend/contract character/word/line at whichever edge of
3136 * the selection we are closest to.
3137 * c) button3 drag : extend/contract character/word/line - we select around
3138 * a point/word/line which is either the start or end of the selection
3139 * and it was decided by whichever point/word/line was `fixed' at the
3140 * time of the most recent button3 press
3142 if (button3 && buttonpress)
3143 { /* button3 press */
3145 * first determine which edge of the selection we are closest to
3147 if (ROWCOL_IS_BEFORE (pos, selection.beg)
3148 || (!ROWCOL_IS_AFTER (pos, selection.end)
3149 && (((pos.col - selection.beg.col)
3150 + ((pos.row - selection.beg.row) * ncol))
3151 < ((selection.end.col - pos.col)
3152 + ((selection.end.row - pos.row) * ncol)))))
3155 if (closeto == LEFT)
3157 selection.beg.row = pos.row;
3158 selection.beg.col = pos.col;
3159 selection.mark.row = selection.end.row;
3160 selection.mark.col = selection.end.col - (selection.clicks == 2);
3164 selection.end.row = pos.row;
3165 selection.end.col = pos.col;
3166 selection.mark.row = selection.beg.row;
3167 selection.mark.col = selection.beg.col;
3171 { /* button1 drag or button3 drag */
3172 if (ROWCOL_IS_AFTER (selection.mark, pos))
3174 if ((selection.mark.row == selection.end.row)
3175 && (selection.mark.col == selection.end.col)
3176 && clickchange && selection.clicks == 2)
3177 selection.mark.col--;
3179 selection.beg.row = pos.row;
3180 selection.beg.col = pos.col;
3181 selection.end.row = selection.mark.row;
3182 selection.end.col = selection.mark.col + (selection.clicks == 2);
3186 selection.beg.row = selection.mark.row;
3187 selection.beg.col = selection.mark.col;
3188 selection.end.row = pos.row;
3189 selection.end.col = pos.col;
3193 if (selection.clicks == 1)
3195 end_col = screen.tlen[selection.beg.row + TermWin.saveLines];
3197 if (end_col != -1 && selection.beg.col > end_col)
3200 selection.beg.col = ncol;
3202 if (selection.beg.row != selection.end.row)
3203 selection.beg.col = ncol;
3205 selection.beg.col = selection.mark.col;
3209 end_col = screen.tlen[selection.end.row + TermWin.saveLines];
3211 if (end_col != -1 && selection.end.col > end_col)
3212 selection.end.col = ncol;
3214 else if (selection.clicks == 2)
3216 if (ROWCOL_IS_AFTER (selection.end, selection.beg))
3217 selection.end.col--;
3219 selection_delimit_word (UP, & (selection.beg), & (selection.beg));
3220 selection_delimit_word (DN, & (selection.end), & (selection.end));
3222 else if (selection.clicks == 3)
3225 if ((options & Opt_tripleclickwords))
3229 selection_delimit_word (UP, & (selection.beg), & (selection.beg));
3230 end_row = screen.tlen[selection.mark.row + TermWin.saveLines];
3232 for (end_row = selection.mark.row; end_row < TermWin.nrow; end_row++)
3234 end_col = screen.tlen[end_row + TermWin.saveLines];
3238 selection.end.row = end_row;
3239 selection.end.col = end_col;
3240 selection_remove_trailing_spaces ();
3248 if (ROWCOL_IS_AFTER (selection.mark, selection.beg))
3249 selection.mark.col++;
3250 selection.beg.col = 0;
3251 selection.end.col = ncol;
3255 if (button3 && buttonpress)
3256 { /* mark may need to be changed */
3257 if (closeto == LEFT)
3259 selection.mark.row = selection.end.row;
3260 selection.mark.col = selection.end.col - (selection.clicks == 2);
3264 selection.mark.row = selection.beg.row;
3265 selection.mark.col = selection.beg.col;
3272 rxvt_term::selection_remove_trailing_spaces ()
3274 int32_t end_col, end_row;
3277 end_col = selection.end.col;
3278 end_row = selection.end.row;
3279 for ( ; end_row >= selection.beg.row; )
3281 stp = screen.text[end_row + TermWin.saveLines];
3282 while (--end_col >= 0)
3284 if (stp[end_col] != ' ' && stp[end_col] != '\t')
3288 || screen.tlen[end_row - 1 + TermWin.saveLines] != -1)
3290 selection.end.col = end_col + 1;
3291 selection.end.row = end_row;
3295 end_col = TermWin.ncol;
3297 if (selection.mark.row > selection.end.row)
3299 selection.mark.row = selection.end.row;
3300 selection.mark.col = selection.end.col;
3302 else if (selection.mark.row == selection.end.row
3303 && selection.mark.col > selection.end.col)
3304 selection.mark.col = selection.end.col;
3308 /* ------------------------------------------------------------------------- */
3310 * Double click on button 3 when already selected
3311 * EXT: button 3 double click
3314 rxvt_term::selection_rotate (int x, int y)
3316 selection.clicks = selection.clicks % 3 + 1;
3317 selection_extend_colrow (Pixel2Col (x), Pixel2Row (y), 1, 0, 1);
3320 /* ------------------------------------------------------------------------- */
3322 * On some systems, the Atom typedef is 64 bits wide. We need to have a type
3323 * that is exactly 32 bits wide, because a format of 64 is not allowed by
3326 typedef CARD32 Atom32;
3328 /* ------------------------------------------------------------------------- */
3330 * Respond to a request for our current selection
3331 * EXT: SelectionRequest
3334 rxvt_term::selection_send (const XSelectionRequestEvent &rq)
3338 XICCEncodingStyle style;
3341 ev.type = SelectionNotify;
3343 ev.display = rq.display;
3344 ev.requestor = rq.requestor;
3345 ev.selection = rq.selection;
3346 ev.target = rq.target;
3349 if (rq.target == xa[XA_TARGETS])
3351 Atom32 target_list[6];
3352 Atom32 *target = target_list;
3354 *target++ = (Atom32) xa[XA_TARGETS];
3355 *target++ = (Atom32) xa[XA_TIMESTAMP];
3356 *target++ = (Atom32) XA_STRING;
3357 *target++ = (Atom32) xa[XA_TEXT];
3358 *target++ = (Atom32) xa[XA_COMPOUND_TEXT];
3359 #if X_HAVE_UTF8_STRING
3360 *target++ = (Atom32) xa[XA_UTF8_STRING];
3363 XChangeProperty (display->display, rq.requestor, rq.property, XA_ATOM,
3364 (8 * sizeof (target_list[0])), PropModeReplace,
3365 (unsigned char *)target_list,
3366 target - target_list);
3367 ev.property = rq.property;
3370 else if (rq.target == xa[XA_MULTIPLE])
3372 /* TODO: Handle MULTIPLE */
3375 else if (rq.target == xa[XA_TIMESTAMP] && selection.text)
3377 XChangeProperty (display->display, rq.requestor, rq.property, XA_INTEGER,
3378 (8 * sizeof (Time)), PropModeReplace,
3379 (unsigned char *)&selection_time, 1);
3380 ev.property = rq.property;
3382 else if (rq.target == XA_STRING
3383 || rq.target == xa[XA_TEXT]
3384 || rq.target == xa[XA_COMPOUND_TEXT]
3385 || rq.target == xa[XA_UTF8_STRING]
3394 if (target == XA_STRING)
3395 // we actually don't do XA_STRING, but who cares, as i18n clients
3396 // will ask for another format anyways.
3397 style = XStringStyle;
3398 else if (target == xa[XA_TEXT])
3399 style = XStdICCTextStyle;
3400 else if (target == xa[XA_COMPOUND_TEXT])
3401 style = XCompoundTextStyle;
3402 #if X_HAVE_UTF8_STRING
3403 else if (target == xa[XA_UTF8_STRING])
3404 style = XUTF8StringStyle;
3408 target = xa[XA_COMPOUND_TEXT];
3409 style = XCompoundTextStyle;
3414 cl = selection.text;
3415 selectlen = selection.len;
3423 // Xwc doesn't handle iso-10646 in wchar_t gracefully, so maybe recode it
3424 // manually for XUTF8StringStyle.
3425 if (XwcTextListToTextProperty (display->display, &cl, 1, style, &ct) >= 0)
3429 /* if we failed to convert then send it raw */
3430 ct.value = (unsigned char *)cl;
3431 ct.nitems = selectlen;
3434 XChangeProperty (display->display, rq.requestor, rq.property,
3435 target, 8, PropModeReplace,
3436 ct.value, (int)ct.nitems);
3437 ev.property = rq.property;
3443 XSendEvent (display->display, rq.requestor, False, 0L, (XEvent *)&ev);
3446 /* ------------------------------------------------------------------------- *
3448 * ------------------------------------------------------------------------- */
3451 * return col/row values corresponding to x/y pixel values
3454 rxvt_term::pixel_position (int *x, int *y)
3456 *x = Pixel2Col (*x);
3457 /* MAX_IT (*x, 0); MIN_IT (*x, (int)TermWin.ncol - 1); */
3458 *y = Pixel2Row (*y);
3459 /* MAX_IT (*y, 0); MIN_IT (*y, (int)TermWin.nrow - 1); */
3462 /* ------------------------------------------------------------------------- */
3465 rxvt_term::im_set_position (XPoint &pos)
3467 XWindowAttributes xwa;
3469 XGetWindowAttributes (display->display, TermWin.vt, &xwa);
3471 pos.x = xwa.x + Col2Pixel (screen.cur.col);
3472 pos.y = xwa.y + Height2Pixel (screen.cur.row) + TermWin.fbase;
3478 rxvt_term::scr_overlay_new (int x, int y, int w, int h)
3480 if (TermWin.nrow < 3 || TermWin.ncol < 3)
3487 if (x < 0) x = TermWin.ncol - w;
3488 if (y < 0) y = TermWin.nrow - h;
3490 // make space for border
3491 w += 2; MIN_IT (w, TermWin.ncol);
3492 h += 2; MIN_IT (h, TermWin.nrow);
3494 x -= 1; MAX_IT (x, 0);
3495 y -= 1; MAX_IT (y, 0);
3497 MIN_IT (x, TermWin.ncol - w);
3498 MIN_IT (y, TermWin.nrow - h);
3503 ov_text = new text_t *[h];
3504 ov_rend = new rend_t *[h];
3506 for (y = 0; y < h; y++)
3508 text_t *tp = ov_text[y] = new text_t[w];
3509 rend_t *rp = ov_rend[y] = new rend_t[w];
3512 rend_t r = SET_BGCOLOR (SET_FGCOLOR (RS_None, Color_bg), Color_fg);
3515 t0 = 0x2554, t1 = 0x2550, t2 = 0x2557;
3517 t0 = 0x2551, t1 = 0x0020, t2 = 0x2551;
3519 t0 = 0x255a, t1 = 0x2550, t2 = 0x255d;
3524 for (x = w - 2; x > 0; --x)
3536 rxvt_term::scr_overlay_off ()
3543 for (int y = 0; y < ov_h; y++)
3545 delete [] ov_text[y];
3546 delete [] ov_rend[y];
3549 delete [] ov_text; ov_text = 0;
3550 delete [] ov_rend; ov_rend = 0;
3554 rxvt_term::scr_overlay_set (int x, int y, text_t text, rend_t rend)
3556 if (!ov_text || x >= ov_w - 2 || y >= ov_h)
3561 ov_text[y][x] = text;
3562 ov_rend[y][x] = rend;
3566 rxvt_term::scr_overlay_set (int x, int y, const char *s)
3569 scr_overlay_set (x++, y, *s++);
3573 rxvt_term::scr_swap_overlay ()
3578 int row_offset = ov_y + TermWin.saveLines - TermWin.view_start;
3580 // swap screen mem with overlay
3581 for (int y = ov_h; y--; )
3583 text_t *t1 = ov_text[y];
3584 rend_t *r1 = ov_rend[y];
3586 text_t *t2 = screen.text[y + row_offset] + ov_x;
3587 rend_t *r2 = screen.rend[y + row_offset] + ov_x;
3589 for (int x = ov_w; x--; )
3591 text_t t = *t1; *t1++ = *t2; *t2++ = t;
3592 rend_t r = *r1; *r1++ = *r2; *r2++ = SET_FONT (r, TermWin.fontset->find_font (t, false));
3598 /* ------------------------------------------------------------------------- */