ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/rxvt-unicode/src/screen.C
(Generate patch)

Comparing rxvt-unicode/src/screen.C (file contents):
Revision 1.347 by sf-exg, Sat Aug 28 11:03:04 2010 UTC vs.
Revision 1.414 by sf-exg, Tue Jan 24 17:05:05 2012 UTC

1/*---------------------------------------------------------------------------* 1/*---------------------------------------------------------------------------*
2 * File: screen.C 2 * File: screen.C
3 *---------------------------------------------------------------------------* 3 *---------------------------------------------------------------------------*
4 * 4 *
5 * Copyright (c) 1997-2001 Geoff Wing <gcw@pobox.com> 5 * Copyright (c) 1997-2001 Geoff Wing <gcw@pobox.com>
6 * Copyright (c) 2003-2007 Marc Lehmann <pcg@goof.com> 6 * Copyright (c) 2003-2007 Marc Lehmann <schmorp@schmorp.de>
7 * 7 *
8 * This program is free software; you can redistribute it and/or modify 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 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 10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version. 11 * (at your option) any later version.
38 while (len--) 38 while (len--)
39 *start++ = value; 39 *start++ = value;
40} 40}
41 41
42/* ------------------------------------------------------------------------- */ 42/* ------------------------------------------------------------------------- */
43#define PROP_SIZE 256*1024
44#define PASTE_SIZE 32768
45#define TABSIZE 8 /* default tab size */ 43#define TABSIZE 8 /* default tab size */
46 44
47/* ------------------------------------------------------------------------- * 45/* ------------------------------------------------------------------------- *
48 * GENERAL SCREEN AND SELECTION UPDATE ROUTINES * 46 * GENERAL SCREEN AND SELECTION UPDATE ROUTINES *
49 * ------------------------------------------------------------------------- */ 47 * ------------------------------------------------------------------------- */
144 col--; 142 col--;
145 143
146 rend_t rend = l.r[col] & ~RS_baseattrMask; 144 rend_t rend = l.r[col] & ~RS_baseattrMask;
147 rend = SET_FONT (rend, FONTSET (rend)->find_font (' ')); 145 rend = SET_FONT (rend, FONTSET (rend)->find_font (' '));
148 146
147 l.touch ();
148
149 // found start, nuke 149 // found start, nuke
150 do { 150 do {
151 l.t[col] = ' '; 151 l.t[col] = ' ';
152 l.r[col] = rend; 152 l.r[col] = rend;
153 col++; 153 col++;
159 * ------------------------------------------------------------------------- */ 159 * ------------------------------------------------------------------------- */
160 160
161void 161void
162rxvt_term::scr_reset () 162rxvt_term::scr_reset ()
163{ 163{
164#if ENABLE_OVERLAY
165 scr_overlay_off ();
166#endif
167
164 view_start = 0; 168 view_start = 0;
165 num_scr = 0; 169 num_scr = 0;
166 170
167 if (ncol == 0) 171 if (ncol == 0)
168 ncol = 80; 172 ncol = 80;
199 term_start = 0; 203 term_start = 0;
200 204
201 talloc = new rxvt_salloc (ncol * sizeof (text_t)); 205 talloc = new rxvt_salloc (ncol * sizeof (text_t));
202 ralloc = new rxvt_salloc (ncol * sizeof (rend_t)); 206 ralloc = new rxvt_salloc (ncol * sizeof (rend_t));
203 207
204 row_buf = (line_t *)rxvt_calloc (total_rows + nrow, sizeof (line_t)); 208 row_buf = (line_t *)rxvt_calloc (total_rows , sizeof (line_t));
205 drawn_buf = (line_t *)rxvt_calloc (nrow , sizeof (line_t)); 209 drawn_buf = (line_t *)rxvt_calloc (nrow , sizeof (line_t));
206 swap_buf = (line_t *)rxvt_calloc (nrow , sizeof (line_t)); 210 swap_buf = (line_t *)rxvt_calloc (nrow , sizeof (line_t));
207 211
208 for (int row = nrow; row--; ) 212 for (int row = nrow; row--; )
209 { 213 {
271 swap_buf [row].clear (); scr_blank_screen_mem (swap_buf [row], DEFAULT_RSTYLE); 275 swap_buf [row].clear (); scr_blank_screen_mem (swap_buf [row], DEFAULT_RSTYLE);
272 drawn_buf[row].clear (); scr_blank_screen_mem (drawn_buf[row], DEFAULT_RSTYLE); 276 drawn_buf[row].clear (); scr_blank_screen_mem (drawn_buf[row], DEFAULT_RSTYLE);
273 } 277 }
274 278
275 line_t *old_buf = row_buf; 279 line_t *old_buf = row_buf;
276 row_buf = (line_t *)rxvt_calloc (total_rows + nrow, sizeof (line_t)); 280 row_buf = (line_t *)rxvt_calloc (total_rows, sizeof (line_t));
277 281
278 int p = MOD (term_start + prev_nrow, prev_total_rows); // previous row 282 int p = MOD (term_start + prev_nrow, prev_total_rows); // previous row
279 int pend = MOD (term_start + top_row , prev_total_rows); 283 int pend = MOD (term_start + top_row , prev_total_rows);
280 int q = total_rows; // rewrapped row 284 int q = total_rows; // rewrapped row
281 285
398 } 402 }
399 403
400 free (tabs); 404 free (tabs);
401 tabs = (char *)rxvt_malloc (ncol); 405 tabs = (char *)rxvt_malloc (ncol);
402 406
403 for (int col = ncol; --col; ) 407 for (int col = ncol; col--; )
404 tabs [col] = col % TABSIZE == 0; 408 tabs [col] = col % TABSIZE == 0;
405 409
406 CLEAR_ALL_SELECTION (); 410 CLEAR_ALL_SELECTION ();
407 411
408 prev_nrow = nrow; 412 prev_nrow = nrow;
451 scr_clear (true); 455 scr_clear (true);
452 scr_refresh (); 456 scr_refresh ();
453} 457}
454 458
455void 459void
456rxvt_term::scr_soft_reset () 460rxvt_term::scr_soft_reset () NOTHROW
457{ 461{
458 /* only affects modes, nothing drastic such as clearing the screen */ 462 /* only affects modes, nothing drastic such as clearing the screen */
459#if ENABLE_OVERLAY 463#if ENABLE_OVERLAY
460 scr_overlay_off (); 464 scr_overlay_off ();
461#endif 465#endif
516 assert (s->cur.row >= 0); 520 assert (s->cur.row >= 0);
517 assert (s->cur.col >= 0); 521 assert (s->cur.col >= 0);
518} 522}
519 523
520void 524void
521rxvt_term::scr_swap_screen () 525rxvt_term::scr_swap_screen () NOTHROW
522{ 526{
523 if (!option (Opt_secondaryScreen)) 527 if (!option (Opt_secondaryScreen))
524 return; 528 return;
525 529
526 for (int i = prev_nrow; i--; ) 530 for (int i = prev_nrow; i--; )
545 return; 549 return;
546 550
547 want_refresh = 1; 551 want_refresh = 1;
548 view_start = 0; 552 view_start = 0;
549 553
550 selection_check (2); /* check for boundary cross */ 554 /* check for boundary cross */
555 row_col_t pos;
556 pos.row = pos.col = 0;
557 if (ROWCOL_IS_BEFORE (selection.beg, pos)
558 && ROWCOL_IS_AFTER (selection.end, pos))
559 CLEAR_SELECTION ();
551 560
552 current_screen = scrn; 561 current_screen = scrn;
553 562
554#if NSCREENS 563#if NSCREENS
555 if (option (Opt_secondaryScreen)) 564 if (option (Opt_secondaryScreen))
634 643
635 if (count > 0 644 if (count > 0
636 && row1 == 0 645 && row1 == 0
637 && (current_screen == PRIMARY || option (Opt_secondaryScroll))) 646 && (current_screen == PRIMARY || option (Opt_secondaryScroll)))
638 { 647 {
648 min_it (count, total_rows - (nrow - (row2 + 1)));
649
639 top_row = max (top_row - count, -saveLines); 650 top_row = max (top_row - count, -saveLines);
640
641 // scroll everything up 'count' lines
642 term_start = (term_start + count) % total_rows;
643 651
644 // sever bottommost line 652 // sever bottommost line
645 { 653 {
646 line_t &l = ROW(row2 - count); 654 line_t &l = ROW(row2);
647 l.is_longer (0); 655 l.is_longer (0);
648 l.touch (); 656 l.touch ();
649 } 657 }
650 658
659 // scroll everything up 'count' lines
660 term_start = (term_start + count) % total_rows;
661
662 // now copy lines below the scroll region bottom to the
663 // bottom of the screen again, so they look as if they
664 // hadn't moved.
665 for (int i = nrow; --i > row2; )
666 {
667 line_t &l1 = ROW(i - count);
668 line_t &l2 = ROW(i);
669
670 ::swap (l1, l2);
671 l2.touch ();
672 }
673
651 // erase newly scrolled-in lines 674 // erase newly scrolled-in lines
652 for (int i = count; i--; ) 675 for (int i = count; i--; )
653 { 676 {
654 line_t &l = ROW(nrow - 1 - i); 677 line_t &l = ROW(row2 - i);
655 678
656 // optimize if already cleared, can be significant on slow machines 679 // optimise if already cleared, can be significant on slow machines
657 // could be rolled into scr_blank_screen_mem 680 // could be rolled into scr_blank_screen_mem
658 if (l.r && l.l < ncol - 1 && !((l.r[l.l + 1] ^ rstyle) & (RS_fgMask | RS_bgMask))) 681 if (l.r && l.l < ncol - 1 && !((l.r[l.l + 1] ^ rstyle) & (RS_fgMask | RS_bgMask)))
659 { 682 {
660 scr_blank_line (l, 0, l.l, rstyle); 683 scr_blank_line (l, 0, l.l, rstyle);
661 l.l = 0; 684 l.l = 0;
663 } 686 }
664 else 687 else
665 scr_blank_screen_mem (l, rstyle); 688 scr_blank_screen_mem (l, rstyle);
666 } 689 }
667 690
668 // now copy lines below the scroll region bottom to the
669 // bottom of the screen again, so they look as if they
670 // hadn't moved.
671 for (int i = nrow; --i > row2; )
672 {
673 line_t &l1 = ROW(i - count);
674 line_t &l2 = ROW(i);
675
676 ::swap (l1, l2);
677 l2.touch ();
678 }
679
680 // move and/or clear selection, if any 691 // move and/or clear selection, if any
681 if (selection.op && current_screen == selection.screen) 692 if (selection.op && current_screen == selection.screen
693 && selection.beg.row <= row2)
682 { 694 {
683 selection.beg.row -= count; 695 selection.beg.row -= count;
684 selection.end.row -= count; 696 selection.end.row -= count;
685 selection.mark.row -= count; 697 selection.mark.row -= count;
686 698
687 if (selection.beg.row < top_row 699 selection_check (0);
688 || selection.end.row < top_row
689 || selection.mark.row < top_row)
690 {
691 CLEAR_ALL_SELECTION ();
692 selection.op = SELECTION_CLEAR;
693 }
694 } 700 }
695 701
696 // finally move the view window, if desired 702 // finally move the view window, if desired
697 if (option (Opt_scrollWithBuffer) 703 if (option (Opt_scrollWithBuffer)
698 && view_start != 0 704 && view_start != 0
728 } 734 }
729 735
730 // use a simple and robust scrolling algorithm, this 736 // use a simple and robust scrolling algorithm, this
731 // part of scr_scroll_text is not time-critical. 737 // part of scr_scroll_text is not time-critical.
732 738
739 // sever line above scroll region
740 if (row1)
741 {
742 line_t &l = ROW(row1 - 1);
743 l.is_longer (0);
744 l.touch ();
745 }
746
733 int rows = row2 - row1 + 1; 747 int rows = row2 - row1 + 1;
734 748
735 min_it (count, rows); 749 min_it (count, rows);
736 750
737 line_t *temp_buf = row_buf + total_rows; 751 line_t *temp_buf = rxvt_temp_buf<line_t> (rows);
738 752
739 for (int row = 0; row < rows; row++) 753 for (int row = 0; row < rows; row++)
740 { 754 {
741 temp_buf [row] = ROW(row1 + (row + count + rows) % rows); 755 temp_buf [row] = ROW(row1 + (row + count + rows) % rows);
742 756
744 scr_blank_screen_mem (temp_buf [row], rstyle); 758 scr_blank_screen_mem (temp_buf [row], rstyle);
745 } 759 }
746 760
747 for (int row = 0; row < rows; row++) 761 for (int row = 0; row < rows; row++)
748 ROW(row1 + row) = temp_buf [row]; 762 ROW(row1 + row) = temp_buf [row];
763
764 // sever bottommost line
765 {
766 line_t &l = ROW(row2);
767 l.is_longer (0);
768 l.touch ();
769 }
749 } 770 }
750 771
751 return count; 772 return count;
752} 773}
753 774
759rxvt_term::scr_add_lines (const wchar_t *str, int len, int minlines) NOTHROW 780rxvt_term::scr_add_lines (const wchar_t *str, int len, int minlines) NOTHROW
760{ 781{
761 if (len <= 0) /* sanity */ 782 if (len <= 0) /* sanity */
762 return; 783 return;
763 784
764 unsigned char checksel; 785 bool checksel;
765 unicode_t c; 786 unicode_t c;
766 int ncol = this->ncol; 787 int ncol = this->ncol;
767 const wchar_t *strend = str + len; 788 const wchar_t *strend = str + len;
768 789
769 want_refresh = 1; 790 want_refresh = 1;
795 816
796 while (str < strend) 817 while (str < strend)
797 { 818 {
798 c = (unicode_t)*str++; // convert to rxvt-unicodes representation 819 c = (unicode_t)*str++; // convert to rxvt-unicodes representation
799 820
800 if (expect_false (c < 0x20)) 821 if (ecb_unlikely (c < 0x20))
801 if (c == C0_LF) 822 if (c == C0_LF)
802 { 823 {
803 max_it (line->l, screen.cur.col); 824 max_it (line->l, screen.cur.col);
804 825
805 screen.flags &= ~Screen_WrapNext; 826 screen.flags &= ~Screen_WrapNext;
824 { 845 {
825 scr_tab (1, true); 846 scr_tab (1, true);
826 continue; 847 continue;
827 } 848 }
828 849
829 if (expect_false ( 850 if (ecb_unlikely (
830 checksel /* see if we're writing within selection */ 851 checksel /* see if we're writing within selection */
831 && !ROWCOL_IS_BEFORE (screen.cur, selection.beg) 852 && !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
832 && ROWCOL_IS_BEFORE (screen.cur, selection.end) 853 && ROWCOL_IS_BEFORE (screen.cur, selection.end)
833 )) 854 ))
834 { 855 {
839 * should be a similar check. 860 * should be a similar check.
840 */ 861 */
841 CLEAR_SELECTION (); 862 CLEAR_SELECTION ();
842 } 863 }
843 864
844 if (expect_false (screen.flags & Screen_WrapNext)) 865 if (ecb_unlikely (screen.flags & Screen_WrapNext))
845 { 866 {
846 scr_do_wrap (); 867 scr_do_wrap ();
847 868
848 line->l = ncol; 869 line->l = ncol;
849 line->is_longer (1); 870 line->is_longer (1);
851 row = screen.cur.row; 872 row = screen.cur.row;
852 line = &ROW(row); /* _must_ refresh */ 873 line = &ROW(row); /* _must_ refresh */
853 } 874 }
854 875
855 // some utf-8 decoders "decode" surrogate characters: let's fix this. 876 // some utf-8 decoders "decode" surrogate characters: let's fix this.
856 if (expect_false (IN_RANGE_INC (c, 0xd800, 0xdfff))) 877 if (ecb_unlikely (IN_RANGE_INC (c, 0xd800, 0xdfff)))
857 c = 0xfffd; 878 c = 0xfffd;
858 879
859 // rely on wcwidth to tell us the character width, do wcwidth before 880 // rely on wcwidth to tell us the character width, do wcwidth before
860 // further replacements, as wcwidth might return -1 for the line 881 // further replacements, as wcwidth might return -1 for the line
861 // drawing characters below as they might be invalid in the current 882 // drawing characters below as they might be invalid in the current
862 // locale. 883 // locale.
863 int width = WCWIDTH (c); 884 int width = WCWIDTH (c);
864 885
865 if (expect_false (charsets [screen.charset] == '0')) // DEC SPECIAL 886 if (ecb_unlikely (charsets [screen.charset] == '0')) // DEC SPECIAL
866 { 887 {
867 // vt100 special graphics and line drawing 888 // vt100 special graphics and line drawing
868 // 5f-7e standard vt100 889 // 5f-7e standard vt100
869 // 40-5e rxvt extension for extra curses acs chars 890 // 40-5e rxvt extension for extra curses acs chars
870 static uint16_t vt100_0[62] = { // 41 .. 7e 891 static uint16_t vt100_0[62] = { // 41 .. 7e
883 c = vt100_0[c - 0x41]; 904 c = vt100_0[c - 0x41];
884 width = 1; // vt100 line drawing characters are always single-width 905 width = 1; // vt100 line drawing characters are always single-width
885 } 906 }
886 } 907 }
887 908
888 if (expect_false (screen.flags & Screen_Insert)) 909 if (ecb_unlikely (screen.flags & Screen_Insert))
889 scr_insdel_chars (width, INSERT); 910 scr_insdel_chars (width, INSERT);
890 911
891 if (width != 0) 912 if (width != 0)
892 { 913 {
893#if !UNICODE_3 914#if !UNICODE_3
898# else 919# else
899 c = 0xfffd; 920 c = 0xfffd;
900# endif 921# endif
901#endif 922#endif
902 923
924 rend_t rend = SET_FONT (rstyle, FONTSET (rstyle)->find_font (c));
925
926 // if the character doesn't fit into the remaining columns...
927 if (ecb_unlikely (screen.cur.col > ncol - width && ncol >= width))
928 {
929 if (screen.flags & Screen_Autowrap)
930 {
931 // ... artificially enlargen the previous one
932 c = NOCHAR;
933 // and try the same character next loop iteration
934 --str;
935 }
936 else
937 screen.cur.col = ncol - width;
938 }
939
903 // nuke the character at this position, if required 940 // nuke the character at this position, if required
904 if (expect_false ( 941 // due to wonderful coincidences everywhere else in this loop
942 // we never have to check for overwriting a wide char itself,
943 // only its tail.
905 line->t[screen.cur.col] == NOCHAR 944 if (ecb_unlikely (line->t[screen.cur.col] == NOCHAR))
906 || (screen.cur.col < ncol - 1
907 && line->t[screen.cur.col + 1] == NOCHAR)
908 ))
909 scr_kill_char (*line, screen.cur.col); 945 scr_kill_char (*line, screen.cur.col);
910
911 rend_t rend = SET_FONT (rstyle, FONTSET (rstyle)->find_font (c));
912
913 // if the character doesn't fit into the remaining columns...
914 if (expect_false (screen.cur.col > ncol - width && ncol >= width))
915 {
916 // ... artificially enlargen the previous one
917 c = NOCHAR;
918 // and try the same character next loop iteration
919 --str;
920 }
921 946
922 line->touch (); 947 line->touch ();
923 948
924 do 949 do
925 { 950 {
926 line->t[screen.cur.col] = c; 951 line->t[screen.cur.col] = c;
927 line->r[screen.cur.col] = rend; 952 line->r[screen.cur.col] = rend;
928 953
929 if (expect_true (screen.cur.col < ncol - 1)) 954 if (ecb_likely (screen.cur.col < ncol - 1))
930 screen.cur.col++; 955 screen.cur.col++;
931 else 956 else
932 { 957 {
933 line->l = ncol; 958 line->l = ncol;
934 if (screen.flags & Screen_Autowrap) 959 if (screen.flags & Screen_Autowrap)
935 screen.flags |= Screen_WrapNext; 960 screen.flags |= Screen_WrapNext;
936 break; 961
962 goto end_of_line;
937 } 963 }
938 964
939 c = NOCHAR; 965 c = NOCHAR;
940 } 966 }
941 while (expect_false (--width > 0)); 967 while (ecb_unlikely (--width > 0));
942 968
943 // pad with spaces when overwriting wide character with smaller one 969 // pad with spaces when overwriting wide character with smaller one
944 if (expect_false (!width)) 970 for (int c = screen.cur.col; ecb_unlikely (c < ncol && line->t[c] == NOCHAR); c++)
945 { 971 {
946 line->touch ();
947
948 for (int c = screen.cur.col; c < ncol && line->t[c] == NOCHAR; c++)
949 {
950 line->t[c] = ' '; 972 line->t[c] = ' ';
951 line->r[c] = rend; 973 line->r[c] = rend;
952 }
953 } 974 }
975
976end_of_line:
977 ;
954 } 978 }
955#if ENABLE_COMBINING 979#if ENABLE_COMBINING
956 else // width == 0 980 else // width == 0
957 { 981 {
958 if (c != 0xfeff) // ignore BOM 982 if (c != 0xfeff) // ignore BOM
1021 1045
1022 want_refresh = 1; 1046 want_refresh = 1;
1023#endif 1047#endif
1024 } 1048 }
1025 } 1049 }
1050 else if (screen.flags & Screen_WrapNext)
1051 screen.flags &= ~Screen_WrapNext;
1026 else 1052 else
1027 scr_gotorc (0, -1, RELATIVE); 1053 scr_gotorc (0, -1, RELATIVE);
1028} 1054}
1029 1055
1030/* ------------------------------------------------------------------------- */ 1056/* ------------------------------------------------------------------------- */
1286 scr_blank_line (line, col, num, rstyle); 1312 scr_blank_line (line, col, num, rstyle);
1287} 1313}
1288 1314
1289/* ------------------------------------------------------------------------- */ 1315/* ------------------------------------------------------------------------- */
1290/* 1316/*
1291 * Erase part of whole of the screen 1317 * Erase part or whole of the screen
1292 * XTERM_SEQ: Clear screen after cursor : ESC [ 0 J 1318 * XTERM_SEQ: Clear screen after cursor : ESC [ 0 J
1293 * XTERM_SEQ: Clear screen before cursor: ESC [ 1 J 1319 * XTERM_SEQ: Clear screen before cursor: ESC [ 1 J
1294 * XTERM_SEQ: Clear whole screen : ESC [ 2 J 1320 * XTERM_SEQ: Clear whole screen : ESC [ 2 J
1295 */ 1321 */
1296void 1322void
1305 ZERO_SCROLLBACK (); 1331 ZERO_SCROLLBACK ();
1306 1332
1307 switch (mode) 1333 switch (mode)
1308 { 1334 {
1309 case 0: /* erase to end of screen */ 1335 case 0: /* erase to end of screen */
1310 selection_check (1);
1311 scr_erase_line (0); 1336 scr_erase_line (0);
1312 row = screen.cur.row + 1; /* possible OOB */ 1337 row = screen.cur.row + 1; /* possible OOB */
1313 num = nrow - row; 1338 num = nrow - row;
1314 break; 1339 break;
1315 case 1: /* erase to beginning of screen */ 1340 case 1: /* erase to beginning of screen */
1316 selection_check (3);
1317 scr_erase_line (1); 1341 scr_erase_line (1);
1318 row = 0; 1342 row = 0;
1319 num = screen.cur.row; 1343 num = screen.cur.row;
1320 break; 1344 break;
1321 case 2: /* erase whole screen */ 1345 case 2: /* erase whole screen */
1322 selection_check (3);
1323 row = 0; 1346 row = 0;
1324 num = nrow; 1347 num = nrow;
1325 break; 1348 break;
1326 default: 1349 default:
1327 return; 1350 return;
1344 { 1367 {
1345 ren = DEFAULT_RSTYLE; 1368 ren = DEFAULT_RSTYLE;
1346 1369
1347 if (mapped) 1370 if (mapped)
1348 XClearArea (dpy, vt, 0, 1371 XClearArea (dpy, vt, 0,
1349 Row2Pixel (row - view_start), (unsigned int)width, 1372 Row2Pixel (row - view_start), (unsigned int)vt_width,
1350 (unsigned int)Height2Pixel (num), False); 1373 (unsigned int)Height2Pixel (num), False);
1351 } 1374 }
1352 else 1375 else
1353 { 1376 {
1354 ren = rstyle & (RS_fgMask | RS_bgMask); 1377 ren = rstyle & (RS_fgMask | RS_bgMask);
1357 { 1380 {
1358 gcvalue.foreground = pix_colors[bgcolor_of (rstyle)]; 1381 gcvalue.foreground = pix_colors[bgcolor_of (rstyle)];
1359 XChangeGC (dpy, gc, GCForeground, &gcvalue); 1382 XChangeGC (dpy, gc, GCForeground, &gcvalue);
1360 XFillRectangle (dpy, vt, gc, 1383 XFillRectangle (dpy, vt, gc,
1361 0, Row2Pixel (row - view_start), 1384 0, Row2Pixel (row - view_start),
1362 (unsigned int)width, 1385 (unsigned int)vt_width,
1363 (unsigned int)Height2Pixel (num)); 1386 (unsigned int)Height2Pixel (num));
1364 gcvalue.foreground = pix_colors[Color_fg]; 1387 gcvalue.foreground = pix_colors[Color_fg];
1365 XChangeGC (dpy, gc, GCForeground, &gcvalue); 1388 XChangeGC (dpy, gc, GCForeground, &gcvalue);
1366 } 1389 }
1367 } 1390 }
1398 1421
1399 want_refresh = 1; 1422 want_refresh = 1;
1400 ZERO_SCROLLBACK (); 1423 ZERO_SCROLLBACK ();
1401 1424
1402 num_scr_allow = 0; 1425 num_scr_allow = 0;
1403 selection_check (3); 1426
1427 row_col_t pos;
1428 pos.row = pos.col = 0;
1429 if (ROWCOL_IS_AFTER (selection.end, pos))
1430 CLEAR_SELECTION ();
1404 1431
1405 fs = SET_FONT (rstyle, FONTSET (rstyle)->find_font ('E')); 1432 fs = SET_FONT (rstyle, FONTSET (rstyle)->find_font ('E'));
1406 for (int row = nrow; row--; ) 1433 for (int row = nrow; row--; )
1407 { 1434 {
1408 line_t &line = ROW(row); 1435 line_t &line = ROW(row);
1678 { 1705 {
1679 rvideo_state = on; 1706 rvideo_state = on;
1680 1707
1681 ::swap (pix_colors[Color_fg], pix_colors[Color_bg]); 1708 ::swap (pix_colors[Color_fg], pix_colors[Color_bg]);
1682#ifdef HAVE_BG_PIXMAP 1709#ifdef HAVE_BG_PIXMAP
1683 if (bgPixmap.pixmap == None) 1710 if (bg_pixmap == None)
1684#endif 1711#endif
1685 XSetWindowBackground (dpy, vt, pix_colors[Color_bg]); 1712 XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
1686 1713
1687 XGCValues gcvalue; 1714 XGCValues gcvalue;
1688 gcvalue.foreground = pix_colors[Color_fg]; 1715 gcvalue.foreground = pix_colors[Color_fg];
1849 * Refresh the entire screen 1876 * Refresh the entire screen
1850 */ 1877 */
1851void 1878void
1852rxvt_term::scr_touch (bool refresh) NOTHROW 1879rxvt_term::scr_touch (bool refresh) NOTHROW
1853{ 1880{
1854 scr_expose (0, 0, width, height, refresh); 1881 scr_expose (0, 0, vt_width, vt_height, refresh);
1855} 1882}
1856 1883
1857/* ------------------------------------------------------------------------- */ 1884/* ------------------------------------------------------------------------- */
1858/* 1885/*
1859 * Move the display so that the line represented by scrollbar value Y is at 1886 * Move the display so that the line represented by scrollbar value Y is at
1915 1942
1916# ifndef NO_MAPALERT 1943# ifndef NO_MAPALERT
1917# ifdef MAPALERT_OPTION 1944# ifdef MAPALERT_OPTION
1918 if (option (Opt_mapAlert)) 1945 if (option (Opt_mapAlert))
1919# endif 1946# endif
1920 XMapWindow (dpy, parent[0]); 1947 XMapWindow (dpy, parent);
1921# endif 1948# endif
1922 1949
1923# if ENABLE_FRILLS 1950# if ENABLE_FRILLS
1924 if (option (Opt_urgentOnBell)) 1951 if (option (Opt_urgentOnBell))
1925 set_urgency (1); 1952 set_urgency (1);
1938 HOOK_INVOKE ((this, HOOK_BELL, DT_END)); 1965 HOOK_INVOKE ((this, HOOK_BELL, DT_END));
1939#endif 1966#endif
1940} 1967}
1941 1968
1942/* ------------------------------------------------------------------------- */ 1969/* ------------------------------------------------------------------------- */
1943/* ARGSUSED */
1944void 1970void
1945rxvt_term::scr_printscreen (int fullhist) NOTHROW 1971rxvt_term::scr_printscreen (int fullhist) NOTHROW
1946{ 1972{
1947#ifdef PRINTPIPE 1973#ifdef PRINTPIPE
1948 int nrows, row_start; 1974 int nrows, row_start;
2022 * A: set up vars 2048 * A: set up vars
2023 */ 2049 */
2024 refresh_count = 0; 2050 refresh_count = 0;
2025 2051
2026 unsigned int old_screen_flags = screen.flags; 2052 unsigned int old_screen_flags = screen.flags;
2027 char have_bg = 0; 2053 bool have_bg = 0;
2028#ifdef HAVE_BG_PIXMAP 2054#ifdef HAVE_BG_PIXMAP
2029 have_bg = bgPixmap.pixmap != None; 2055 have_bg = bg_pixmap != None;
2030#endif 2056#endif
2031 ocrow = oldcursor.row; /* is there an old outline cursor on screen? */ 2057 ocrow = oldcursor.row; /* is there an old outline cursor on screen? */
2032 2058
2033 /* 2059 /*
2034 * B: reverse any characters which are selected 2060 * B: reverse any characters which are selected
2038 HOOK_INVOKE ((this, HOOK_REFRESH_BEGIN, DT_END)); 2064 HOOK_INVOKE ((this, HOOK_REFRESH_BEGIN, DT_END));
2039#if ENABLE_OVERLAY 2065#if ENABLE_OVERLAY
2040 scr_swap_overlay (); 2066 scr_swap_overlay ();
2041#endif 2067#endif
2042 2068
2043 char showcursor = screen.flags & Screen_VisibleCursor; 2069 bool showcursor = screen.flags & Screen_VisibleCursor;
2044 2070
2045 /* 2071 /*
2046 * C: set the cursor character (s) 2072 * C: set the cursor character (s)
2047 */ 2073 */
2048 { 2074 {
2049 unsigned char setoldcursor; 2075 bool setoldcursor;
2050 2076
2051#ifdef CURSOR_BLINK 2077#ifdef CURSOR_BLINK
2052 if (hidden_cursor) 2078 if (hidden_cursor)
2053 showcursor = 0; 2079 showcursor = 0;
2054#endif 2080#endif
2141 { 2167 {
2142 int16_t nits; 2168 int16_t nits;
2143 int i = num_scr; 2169 int i = num_scr;
2144 int j; 2170 int j;
2145 int len, wlen; 2171 int len, wlen;
2146 dLocal (int, num_scr);
2147 2172
2148 j = nrow; 2173 j = nrow;
2149 wlen = len = -1; 2174 wlen = len = -1;
2150 row = i > 0 ? 0 : j - 1; 2175 row = i > 0 ? 0 : j - 1;
2151 2176
2226 continue; 2251 continue;
2227 2252
2228 // redraw one or more characters 2253 // redraw one or more characters
2229 2254
2230 // seek to the beginning of wide characters 2255 // seek to the beginning of wide characters
2231 while (expect_false (stp[col] == NOCHAR && col > 0)) 2256 while (ecb_unlikely (stp[col] == NOCHAR && col > 0))
2232 --col; 2257 --col;
2233 2258
2234 rend_t rend = srp[col]; /* screen rendition (target rendition) */ 2259 rend_t rend = srp[col]; /* screen rendition (target rendition) */
2235 text_t *text = stp + col; 2260 text_t *text = stp + col;
2236 int count = 1; 2261 int count = 1;
2274 2299
2275 col--; /* went one too far. move back */ 2300 col--; /* went one too far. move back */
2276 count -= i; /* dump any matching trailing chars */ 2301 count -= i; /* dump any matching trailing chars */
2277 2302
2278 // sometimes we optimize away the trailing NOCHAR's, add them back 2303 // sometimes we optimize away the trailing NOCHAR's, add them back
2279 while (expect_false (i && text[count] == NOCHAR)) 2304 while (ecb_unlikely (i && text[count] == NOCHAR))
2280 count++, i--; 2305 count++, i--;
2281 2306
2282 /* 2307 /*
2283 * Determine the attributes for the string 2308 * Determine the attributes for the string
2284 */ 2309 */
2285 int fore = fgcolor_of (rend); // desired foreground 2310 int fore = fgcolor_of (rend); // desired foreground
2286 int back = bgcolor_of (rend); // desired background 2311 int back = bgcolor_of (rend); // desired background
2287 2312
2288 // only do special processing if any attributes are set, which is unlikely 2313 // only do special processing if any attributes are set, which is unlikely
2289 if (expect_false (rend & (RS_baseattrMask | RS_Careful | RS_Sel))) 2314 if (ecb_unlikely (rend & (RS_baseattrMask | RS_Careful | RS_Sel)))
2290 { 2315 {
2291 bool invert = rend & RS_RVid; 2316 bool invert = rend & RS_RVid;
2292 2317
2293#ifndef NO_BOLD_UNDERLINE_REVERSE 2318#ifndef NO_BOLD_UNDERLINE_REVERSE
2294 if (rend & RS_Bold && fore == Color_fg) 2319 if (rend & RS_Bold && fore == Color_fg)
2383 /* 2408 /*
2384 * Actually do the drawing of the string here 2409 * Actually do the drawing of the string here
2385 */ 2410 */
2386 rxvt_font *font = (*fontset[GET_STYLE (rend)])[GET_FONT (rend)]; 2411 rxvt_font *font = (*fontset[GET_STYLE (rend)])[GET_FONT (rend)];
2387 2412
2388 if (expect_true (have_bg && back == Color_bg)) 2413 if (ecb_likely (have_bg && back == Color_bg))
2389 { 2414 {
2390 // this is very ugly, maybe push it into ->draw? 2415 // this is very ugly, maybe push it into ->draw?
2391 2416
2392 for (i = 0; i < count; i++) /* don't draw empty strings */ 2417 for (i = 0; i < count; i++) /* don't draw empty strings */
2393 if (text[i] != ' ') 2418 if (text[i] != ' ')
2400 did_clear: ; 2425 did_clear: ;
2401 } 2426 }
2402 else 2427 else
2403 font->draw (*drawable, xpixel, ypixel, text, count, fore, back); 2428 font->draw (*drawable, xpixel, ypixel, text, count, fore, back);
2404 2429
2405 if (expect_false (rend & RS_Uline && font->descent > 1 && fore != back)) 2430 if (ecb_unlikely (rend & RS_Uline && font->descent > 1 && fore != back))
2406 { 2431 {
2407#if ENABLE_FRILLS 2432#if ENABLE_FRILLS
2408 if (ISSET_PIXCOLOR (Color_underline)) 2433 if (ISSET_PIXCOLOR (Color_underline))
2409 XSetForeground (dpy, gc, pix_colors[Color_underline]); 2434 XSetForeground (dpy, gc, pix_colors[Color_underline]);
2410 else 2435 else
2456 2481
2457 XDrawRectangle (dpy, vt, gc, 2482 XDrawRectangle (dpy, vt, gc,
2458 Col2Pixel (col), 2483 Col2Pixel (col),
2459 Row2Pixel (oldcursor.row), 2484 Row2Pixel (oldcursor.row),
2460 (unsigned int) (Width2Pixel (cursorwidth) - 1), 2485 (unsigned int) (Width2Pixel (cursorwidth) - 1),
2461 (unsigned int) (Height2Pixel (1) - lineSpace - 1)); 2486 (unsigned int) (Height2Pixel (1) - 1));
2462 } 2487 }
2463 } 2488 }
2464 2489
2465 /* 2490 /*
2466 * H: cleanup selection 2491 * H: cleanup selection
2501 scr_remap_chars (swap_buf [i]); 2526 scr_remap_chars (swap_buf [i]);
2502 } 2527 }
2503} 2528}
2504 2529
2505void 2530void
2506rxvt_term::scr_recolour () NOTHROW 2531rxvt_term::scr_recolour (bool refresh) NOTHROW
2507{ 2532{
2533 bool transparent = false;
2534
2508#ifdef HAVE_BG_PIXMAP 2535#ifdef HAVE_BG_PIXMAP
2509 bgPixmap.apply (); 2536 if (bg_pixmap != None)
2510#else 2537 {
2538# ifdef ENABLE_TRANSPARENCY
2539 if (bg_flags & BG_IS_TRANSPARENT)
2540 {
2541 XSetWindowBackgroundPixmap (dpy, parent, bg_pixmap);
2542 XSetWindowBackgroundPixmap (dpy, vt, ParentRelative);
2511 2543
2544 transparent = true;
2545 }
2546 else
2547# endif
2548 {
2549 XSetWindowBackground (dpy, parent, pix_colors[Color_border]);
2550 XSetWindowBackgroundPixmap (dpy, vt, bg_pixmap);
2551 }
2552 }
2553 else
2554#endif
2555 {
2512 XSetWindowBackground (dpy, parent[0], pix_colors[Color_border]); 2556 XSetWindowBackground (dpy, parent, pix_colors[Color_border]);
2513 XClearWindow (dpy, parent[0]);
2514 XSetWindowBackground (dpy, vt, pix_colors[Color_bg]); 2557 XSetWindowBackground (dpy, vt, pix_colors[Color_bg]);
2558 }
2559
2560 XClearWindow (dpy, parent);
2515 2561
2516 if (scrollBar.win) 2562 if (scrollBar.win)
2517 { 2563 {
2564 if (transparent)
2565 XSetWindowBackgroundPixmap (dpy, scrollBar.win, ParentRelative);
2566 else
2518 XSetWindowBackground (dpy, scrollBar.win, pix_colors[Color_border]); 2567 XSetWindowBackground (dpy, scrollBar.win, pix_colors[Color_border]);
2519 scrollBar.state = STATE_IDLE; 2568 scrollBar.state = SB_STATE_IDLE;
2520 scrollBar.show (0); 2569 scrollBar.show (0);
2521 } 2570 }
2522 2571
2523#endif 2572 if (refresh)
2524 2573 {
2525 /* bgPixmap.apply () does not do the following : */
2526 scr_clear (); 2574 scr_clear ();
2527 scr_touch (true); 2575 scr_touch (true);
2576 }
2528 want_refresh = 1; 2577 want_refresh = 1;
2529} 2578}
2530 2579
2531/* ------------------------------------------------------------------------- */ 2580/* ------------------------------------------------------------------------- */
2532void 2581void
2618 */ 2667 */
2619#if 0 2668#if 0
2620void 2669void
2621rxvt_term::scr_dump (int fd) NOTHROW 2670rxvt_term::scr_dump (int fd) NOTHROW
2622{ 2671{
2623 int row, wrote; 2672 // if this method is needed, it can be implemented by factoring the
2624 unsigned int width, towrite; 2673 // relevant code in scr_printscreen
2625 char r1[] = "\n";
2626
2627 for (row = saveLines + top_row;
2628 row < saveLines + nrow - 1; row++)
2629 {
2630 width = row_buf[row].l >= 0 ? row_buf[row].l
2631 : ncol;
2632 for (towrite = width; towrite; towrite -= wrote)
2633 {
2634 wrote = write (fd, & (row_buf[row].t[width - towrite]),
2635 towrite);
2636 if (wrote < 0)
2637 return; /* XXX: death, no report */
2638 }
2639 if (row_buf[row].l >= 0)
2640 if (write (fd, r1, 1) <= 0)
2641 return; /* XXX: death, no report */
2642 }
2643} 2674}
2644#endif 2675#endif
2645 2676
2646/* ------------------------------------------------------------------------- * 2677/* ------------------------------------------------------------------------- *
2647 * CHARACTER SELECTION * 2678 * CHARACTER SELECTION *
2648 * ------------------------------------------------------------------------- */ 2679 * ------------------------------------------------------------------------- */
2649void 2680void
2650rxvt_term::selection_check (int check_more) NOTHROW 2681rxvt_term::selection_check (int check_more) NOTHROW
2651{ 2682{
2652 row_col_t pos;
2653
2654 if (!selection.op) 2683 if (!selection.op)
2655 return; 2684 return;
2656 2685
2657 pos.row = pos.col = 0;
2658 if (!IN_RANGE_EXC (selection.beg.row, top_row, nrow) 2686 if (!IN_RANGE_EXC (selection.beg.row, top_row, nrow)
2659 || !IN_RANGE_EXC (selection.mark.row, top_row, nrow) 2687 || !IN_RANGE_EXC (selection.mark.row, top_row, nrow)
2660 || !IN_RANGE_EXC (selection.end.row, top_row, nrow) 2688 || !IN_RANGE_EXC (selection.end.row, top_row, nrow)
2661 || (check_more == 1 2689 || (check_more == 1
2662 && current_screen == selection.screen 2690 && current_screen == selection.screen
2663 && !ROWCOL_IS_BEFORE (screen.cur, selection.beg) 2691 && !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
2664 && ROWCOL_IS_BEFORE (screen.cur, selection.end)) 2692 && ROWCOL_IS_BEFORE (screen.cur, selection.end)))
2665 || (check_more == 2
2666 && ROWCOL_IS_BEFORE (selection.beg, pos)
2667 && ROWCOL_IS_AFTER (selection.end, pos))
2668 || (check_more == 3
2669 && ROWCOL_IS_AFTER (selection.end, pos))
2670 || (check_more == 4 /* screen width change */
2671 && (selection.beg.row != selection.end.row
2672 || selection.end.col > ncol)))
2673 CLEAR_SELECTION (); 2693 CLEAR_ALL_SELECTION ();
2674} 2694}
2675 2695
2676/* ------------------------------------------------------------------------- */ 2696/* ------------------------------------------------------------------------- */
2677/* 2697/*
2678 * Paste a selection direct to the command fd 2698 * Paste a selection direct to the command fd
2684 for (unsigned int i = 0; i < len; i++) 2704 for (unsigned int i = 0; i < len; i++)
2685 if (data[i] == C0_LF) 2705 if (data[i] == C0_LF)
2686 data[i] = C0_CR; 2706 data[i] = C0_CR;
2687 2707
2688 if (priv_modes & PrivMode_BracketPaste) 2708 if (priv_modes & PrivMode_BracketPaste)
2689 tt_printf ("\e[200~"); 2709 tt_printf ("\x1b[200~");
2690 2710
2691 tt_write (data, len); 2711 tt_write (data, len);
2692 2712
2693 if (priv_modes & PrivMode_BracketPaste) 2713 if (priv_modes & PrivMode_BracketPaste)
2694 tt_printf ("\e[201~"); 2714 tt_printf ("\x1b[201~");
2695} 2715}
2696 2716
2697void 2717void
2698rxvt_term::paste (char *data, unsigned int len) NOTHROW 2718rxvt_term::paste (char *data, unsigned int len) NOTHROW
2699{ 2719{
2703 tt_paste (data, len); 2723 tt_paste (data, len);
2704} 2724}
2705 2725
2706/* ------------------------------------------------------------------------- */ 2726/* ------------------------------------------------------------------------- */
2707/* 2727/*
2708 * Respond to a notification that a primary selection has been sent 2728 * Request PRIMARY, SECONDARY or CLIPBOARD selection.
2709 * EXT: SelectionNotify 2729 * if the requested selection has no owner or is empty CUT_BUFFER0 is used
2710 */ 2730 * as fallback
2711void
2712rxvt_term::selection_paste (Window win, Atom prop, bool delete_prop) NOTHROW
2713{
2714 if (prop == None) /* check for failed XConvertSelection */
2715 {
2716 if ((selection_type & Sel_CompoundText))
2717 {
2718 int selnum = selection_type & Sel_whereMask;
2719
2720 selection_type = 0;
2721 if (selnum != Sel_direct)
2722 selection_request_other (XA_STRING, selnum);
2723 }
2724
2725 if ((selection_type & Sel_UTF8String))
2726 {
2727 int selnum = selection_type & Sel_whereMask;
2728
2729 selection_type = Sel_CompoundText;
2730 if (selnum != Sel_direct)
2731 selection_request_other (xa[XA_COMPOUND_TEXT], selnum);
2732 else
2733 selection_type = 0;
2734 }
2735
2736 return;
2737 }
2738
2739 unsigned long bytes_after;
2740 XTextProperty ct;
2741
2742 if (XGetWindowProperty (dpy, win, prop,
2743 0, PROP_SIZE / 4,
2744 delete_prop, AnyPropertyType,
2745 &ct.encoding, &ct.format,
2746 &ct.nitems, &bytes_after,
2747 &ct.value) != Success)
2748 {
2749 ct.value = 0;
2750 goto bailout;
2751 }
2752
2753 if (ct.encoding == None)
2754 goto bailout;
2755
2756 if (bytes_after)
2757 {
2758 // fetch and append remaining data
2759 XTextProperty ct2;
2760
2761 if (XGetWindowProperty (dpy, win, prop,
2762 ct.nitems / 4, (bytes_after + 3) / 4,
2763 delete_prop, AnyPropertyType,
2764 &ct2.encoding, &ct2.format,
2765 &ct2.nitems, &bytes_after,
2766 &ct2.value) != Success)
2767 goto bailout;
2768
2769 // realloc should be compatible to XFree, here, and elsewhere, too
2770 ct.value = (unsigned char *)realloc (ct.value, ct.nitems + ct2.nitems + 1);
2771 memcpy (ct.value + ct.nitems, ct2.value, ct2.nitems + 1);
2772 ct.nitems += ct2.nitems;
2773
2774 XFree (ct2.value);
2775 }
2776
2777 if (ct.value == 0)
2778 goto bailout;
2779
2780 if (ct.encoding == xa[XA_INCR])
2781 {
2782 // INCR selection, start handshake
2783 if (!delete_prop)
2784 XDeleteProperty (dpy, win, prop);
2785
2786 selection_wait = Sel_incr;
2787 incr_buf_fill = 0;
2788 incr_ev.start (10);
2789
2790 goto bailout;
2791 }
2792
2793 if (ct.nitems == 0)
2794 {
2795 if (selection_wait == Sel_incr)
2796 {
2797 XFree (ct.value);
2798
2799 // finally complete, now paste the whole thing
2800 selection_wait = Sel_normal;
2801 ct.value = (unsigned char *)incr_buf;
2802 ct.nitems = incr_buf_fill;
2803 incr_buf = 0;
2804 incr_buf_size = 0;
2805 incr_ev.stop ();
2806 }
2807 else
2808 {
2809 if (selection_wait == Sel_normal
2810 && (win != display->root || prop != XA_CUT_BUFFER0)) // avoid recursion
2811 {
2812 /*
2813 * pass through again trying CUT_BUFFER0 if we've come from
2814 * XConvertSelection () but nothing was presented
2815 */
2816 selection_paste (display->root, XA_CUT_BUFFER0, False);
2817 }
2818
2819 goto bailout;
2820 }
2821 }
2822 else if (selection_wait == Sel_incr)
2823 {
2824 incr_ev.start (10);
2825
2826 while (incr_buf_fill + ct.nitems > incr_buf_size)
2827 {
2828 incr_buf_size = incr_buf_size ? incr_buf_size * 2 : 128*1024;
2829 incr_buf = (char *)realloc (incr_buf, incr_buf_size);
2830 }
2831
2832 memcpy (incr_buf + incr_buf_fill, ct.value, ct.nitems);
2833 incr_buf_fill += ct.nitems;
2834
2835 goto bailout;
2836 }
2837
2838 char **cl;
2839 int cr;
2840
2841#if !ENABLE_MINIMAL
2842 // xlib is horribly broken with respect to UTF8_STRING, and nobody cares to fix it
2843 // so recode it manually
2844 if (ct.encoding == xa[XA_UTF8_STRING])
2845 {
2846 wchar_t *w = rxvt_utf8towcs ((const char *)ct.value, ct.nitems);
2847 char *s = rxvt_wcstombs (w);
2848 free (w);
2849 // TODO: strlen == only the first element will be converted. well...
2850 paste (s, strlen (s));
2851 free (s);
2852 }
2853 else
2854#endif
2855 if (XmbTextPropertyToTextList (dpy, &ct, &cl, &cr) >= 0
2856 && cl)
2857 {
2858 for (int i = 0; i < cr; i++)
2859 paste (cl[i], strlen (cl[i]));
2860
2861 XFreeStringList (cl);
2862 }
2863 else
2864 paste ((char *)ct.value, ct.nitems); // paste raw
2865
2866bailout:
2867 XFree (ct.value);
2868
2869 if (selection_wait == Sel_normal)
2870 selection_wait = Sel_none;
2871}
2872
2873void
2874rxvt_term::incr_cb (ev::timer &w, int revents) NOTHROW
2875{
2876 selection_wait = Sel_none;
2877
2878 incr_buf_size = 0;
2879 free (incr_buf);
2880
2881 rxvt_warn ("data loss: timeout on INCR selection paste, ignoring.\n");
2882}
2883
2884void
2885rxvt_term::selection_property (Window win, Atom prop) NOTHROW
2886{
2887 if (prop == None || selection_wait != Sel_incr)
2888 return;
2889
2890 selection_paste (win, prop, true);
2891}
2892
2893/* ------------------------------------------------------------------------- */
2894/*
2895 * Request the current selection:
2896 * Order: > internal selection if available
2897 * > PRIMARY, SECONDARY, CLIPBOARD if ownership is claimed (+)
2898 * > CUT_BUFFER0
2899 * (+) if ownership is claimed but property is empty, rxvt_selection_paste ()
2900 * will auto fallback to CUT_BUFFER0
2901 * EXT: button 2 release 2731 * EXT: button 2 release
2902 */ 2732 */
2903void 2733void
2904rxvt_term::selection_request (Time tm, int selnum) NOTHROW 2734rxvt_term::selection_request (Time tm, int selnum) NOTHROW
2905{ 2735{
2906 if (selection.text && selnum == Sel_Primary) 2736 if (!selection_req)
2907 {
2908 /* internal selection */
2909 char *str = rxvt_wcstombs (selection.text, selection.len);
2910 paste (str, strlen (str));
2911 free (str);
2912 return;
2913 } 2737 {
2914 else 2738 selection_req = new rxvt_selection (display, selnum, tm, vt, xa[XA_VT_SELECTION], this);
2739 selection_req->run ();
2915 { 2740 }
2916 selection_request_time = tm;
2917 selection_wait = Sel_normal;
2918
2919#if X_HAVE_UTF8_STRING
2920 selection_type = Sel_UTF8String;
2921 if (selection_request_other (xa[XA_UTF8_STRING], selnum))
2922 return;
2923#else
2924 selection_type = Sel_CompoundText;
2925 if (selection_request_other (xa[XA_COMPOUND_TEXT], selnum))
2926 return;
2927#endif
2928 }
2929
2930 selection_wait = Sel_none; /* don't loop in selection_paste () */
2931 selection_paste (display->root, XA_CUT_BUFFER0, false);
2932}
2933
2934int
2935rxvt_term::selection_request_other (Atom target, int selnum) NOTHROW
2936{
2937 Atom sel;
2938
2939 selection_type |= selnum;
2940
2941 if (selnum == Sel_Primary)
2942 sel = XA_PRIMARY;
2943 else if (selnum == Sel_Secondary)
2944 sel = XA_SECONDARY;
2945 else
2946 sel = xa[XA_CLIPBOARD];
2947
2948 if (XGetSelectionOwner (dpy, sel) != None)
2949 {
2950 XConvertSelection (dpy, sel, target, xa[XA_VT_SELECTION],
2951 vt, selection_request_time);
2952 return 1;
2953 }
2954
2955 return 0;
2956} 2741}
2957 2742
2958/* ------------------------------------------------------------------------- */ 2743/* ------------------------------------------------------------------------- */
2959/* 2744/*
2960 * Clear all selected text 2745 * Clear all selected text
2991 * EXT: button 1 or 3 release 2776 * EXT: button 1 or 3 release
2992 */ 2777 */
2993void 2778void
2994rxvt_term::selection_make (Time tm) 2779rxvt_term::selection_make (Time tm)
2995{ 2780{
2996 int i; 2781 int size;
2997 wchar_t *new_selection_text; 2782 wchar_t *new_selection_text;
2998 text_t *t; 2783 text_t *t;
2999 2784
3000 switch (selection.op) 2785 switch (selection.op)
3001 { 2786 {
3017 return; /* nothing selected, go away */ 2802 return; /* nothing selected, go away */
3018 2803
3019 if (HOOK_INVOKE ((this, HOOK_SEL_MAKE, DT_LONG, (long)tm, DT_END))) 2804 if (HOOK_INVOKE ((this, HOOK_SEL_MAKE, DT_LONG, (long)tm, DT_END)))
3020 return; 2805 return;
3021 2806
3022 i = (selection.end.row - selection.beg.row + 1) * (ncol + 1); 2807 size = (selection.end.row - selection.beg.row + 1) * (ncol + 1);
3023 new_selection_text = (wchar_t *)rxvt_malloc ((i + 4) * sizeof (wchar_t)); 2808 new_selection_text = (wchar_t *)rxvt_malloc ((size + 4) * sizeof (wchar_t));
3024 2809
3025 int ofs = 0; 2810 int ofs = 0;
3026 int extra = 0; 2811 int extra = 0;
3027 2812
3028 int col = selection.beg.col; 2813 int col = selection.beg.col;
3034 { 2819 {
3035#if !ENABLE_MINIMAL 2820#if !ENABLE_MINIMAL
3036 if (selection.rect) 2821 if (selection.rect)
3037 { 2822 {
3038 col = selection.beg.col; 2823 col = selection.beg.col;
3039 end_col = ncol + 1; 2824 end_col = selection.end.col;
3040 } 2825 }
3041 else 2826 else
3042#endif 2827#endif
3043 end_col = ROW(row).l; 2828 end_col = ROW(row).l;
3044 2829
3045 col = max (col, 0); 2830 col = max (col, 0);
3046 2831
3047 if (row == selection.end.row 2832 if (row == selection.end.row)
3048#if !ENABLE_MINIMAL
3049 || selection.rect
3050#endif
3051 )
3052 min_it (end_col, selection.end.col); 2833 min_it (end_col, selection.end.col);
3053 2834
3054 t = ROW(row).t + col; 2835 t = ROW(row).t + col;
3055 2836
3056 for (; col < end_col; col++) 2837 for (; col < end_col; col++)
3064 2845
3065 extra -= (len - 1); 2846 extra -= (len - 1);
3066 2847
3067 if (extra < 0) 2848 if (extra < 0)
3068 { 2849 {
3069 extra += i; 2850 extra += size;
3070 i += i; 2851 size += size;
3071 new_selection_text = (wchar_t *)rxvt_realloc (new_selection_text, (i + 4) * sizeof (wchar_t)); 2852 new_selection_text = (wchar_t *)rxvt_realloc (new_selection_text, (size + 4) * sizeof (wchar_t));
3072 } 2853 }
3073 2854
3074 ofs += rxvt_composite.expand (*t++, new_selection_text + ofs); 2855 ofs += rxvt_composite.expand (*t++, new_selection_text + ofs);
3075 } 2856 }
3076#endif 2857#endif
3088 2869
3089 new_selection_text[ofs++] = C0_LF; 2870 new_selection_text[ofs++] = C0_LF;
3090 } 2871 }
3091 else 2872 else
3092#endif 2873#endif
3093 if (!ROW(row).is_longer () && row != selection.end.row) 2874 if (!ROW(row).is_longer ()
2875 && (row != selection.end.row || end_col != selection.end.col)
2876 && (row != selection.beg.row || selection.beg.col < ncol))
3094 new_selection_text[ofs++] = C0_LF; 2877 new_selection_text[ofs++] = C0_LF;
3095 } 2878 }
3096
3097 if (end_col != selection.end.col)
3098 new_selection_text[ofs++] = C0_LF;
3099 2879
3100 new_selection_text[ofs] = 0; 2880 new_selection_text[ofs] = 0;
3101 2881
3102 if (ofs == 0) 2882 if (ofs == 0)
3103 { 2883 {
3609 * EXT: SelectionRequest 3389 * EXT: SelectionRequest
3610 */ 3390 */
3611void 3391void
3612rxvt_term::selection_send (const XSelectionRequestEvent &rq) NOTHROW 3392rxvt_term::selection_send (const XSelectionRequestEvent &rq) NOTHROW
3613{ 3393{
3394 Atom property = rq.property == None ? rq.target : rq.property;
3614 XSelectionEvent ev; 3395 XSelectionEvent ev;
3615 3396
3616 ev.type = SelectionNotify; 3397 ev.type = SelectionNotify;
3617 ev.property = None; 3398 ev.property = None;
3618 ev.display = rq.display; 3399 ev.display = rq.display;
3633 *target++ = xa[XA_COMPOUND_TEXT]; 3414 *target++ = xa[XA_COMPOUND_TEXT];
3634#if X_HAVE_UTF8_STRING 3415#if X_HAVE_UTF8_STRING
3635 *target++ = xa[XA_UTF8_STRING]; 3416 *target++ = xa[XA_UTF8_STRING];
3636#endif 3417#endif
3637 3418
3638 XChangeProperty (dpy, rq.requestor, rq.property, XA_ATOM, 3419 XChangeProperty (dpy, rq.requestor, property, XA_ATOM,
3639 32, PropModeReplace, 3420 32, PropModeReplace,
3640 (unsigned char *)target_list, target - target_list); 3421 (unsigned char *)target_list, target - target_list);
3641 ev.property = rq.property; 3422 ev.property = property;
3642 } 3423 }
3643#if TODO // TODO 3424#if TODO // TODO
3644 else if (rq.target == xa[XA_MULTIPLE]) 3425 else if (rq.target == xa[XA_MULTIPLE])
3645 { 3426 {
3646 /* TODO: Handle MULTIPLE */ 3427 /* TODO: Handle MULTIPLE */
3647 } 3428 }
3648#endif 3429#endif
3649 else if (rq.target == xa[XA_TIMESTAMP] && rq.selection == XA_PRIMARY && selection.text) 3430 else if (rq.target == xa[XA_TIMESTAMP] && rq.selection == XA_PRIMARY && selection.text)
3650 { 3431 {
3651 XChangeProperty (dpy, rq.requestor, rq.property, rq.target, 3432 XChangeProperty (dpy, rq.requestor, property, rq.target,
3652 32, PropModeReplace, (unsigned char *)&selection_time, 1); 3433 32, PropModeReplace, (unsigned char *)&selection_time, 1);
3653 ev.property = rq.property; 3434 ev.property = property;
3654 } 3435 }
3655 else if (rq.target == xa[XA_TIMESTAMP] && rq.selection == xa[XA_CLIPBOARD] && selection.clip_text) 3436 else if (rq.target == xa[XA_TIMESTAMP] && rq.selection == xa[XA_CLIPBOARD] && selection.clip_text)
3656 { 3437 {
3657 XChangeProperty (dpy, rq.requestor, rq.property, rq.target, 3438 XChangeProperty (dpy, rq.requestor, property, rq.target,
3658 32, PropModeReplace, (unsigned char *)&clipboard_time, 1); 3439 32, PropModeReplace, (unsigned char *)&clipboard_time, 1);
3659 ev.property = rq.property; 3440 ev.property = property;
3660 } 3441 }
3661 else if (rq.target == XA_STRING 3442 else if (rq.target == XA_STRING
3662 || rq.target == xa[XA_TEXT] 3443 || rq.target == xa[XA_TEXT]
3663 || rq.target == xa[XA_COMPOUND_TEXT] 3444 || rq.target == xa[XA_COMPOUND_TEXT]
3664 || rq.target == xa[XA_UTF8_STRING] 3445 || rq.target == xa[XA_UTF8_STRING]
3735 ct.value = (unsigned char *)cl; 3516 ct.value = (unsigned char *)cl;
3736 ct.nitems = selectlen; 3517 ct.nitems = selectlen;
3737 ct.encoding = target; 3518 ct.encoding = target;
3738 } 3519 }
3739 3520
3740 XChangeProperty (dpy, rq.requestor, rq.property, 3521 XChangeProperty (dpy, rq.requestor, property,
3741 ct.encoding, 8, PropModeReplace, 3522 ct.encoding, 8, PropModeReplace,
3742 ct.value, (int)ct.nitems); 3523 ct.value, (int)ct.nitems);
3743 ev.property = rq.property; 3524 ev.property = property;
3744 3525
3745 if (freect) 3526 if (freect)
3746 XFree (ct.value); 3527 XFree (ct.value);
3747 } 3528 }
3748 3529

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines