ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/rxvt-unicode/src/screen.C

Comparing rxvt-unicode/src/screen.C (file contents):
Revision 1.37 by pcg, Tue Feb 24 23:58:13 2004 UTC vs.
Revision 1.66 by pcg, Sun Mar 28 02:07:08 2004 UTC

1	/*--------------------------------*-C-*--------------------------------------*	1	/*--------------------------------*-C-*--------------------------------------*
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-2004 Marc Lehmann <pcg@goof.com>
6	*	7	*
7	* 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
8	* 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
9	* the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation; either version 2 of the License, or
10	* (at your option) any later version.	11	* (at your option) any later version.
…		…
16	*	17	*
17	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
18	* along with this program; if not, write to the Free Software	19	* along with this program; if not, write to the Free Software
19	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20	*--------------------------------------------------------------------------*/	21	*--------------------------------------------------------------------------*/
		22
21	/*	23	/*
22	* We handle _all_ screen updates and selections	24	* This file handles _all_ screen updates and selections
23	*/	25	*/
24		26
25	#include "../config.h" /* NECESSARY */	27	#include "../config.h" /* NECESSARY */
26	#define INTERN_SCREEN	28	#define INTERN_SCREEN
27	#include "rxvt.h" /* NECESSARY */	29	#include "rxvt.h" /* NECESSARY */
…		…
30	#include <X11/Xmd.h> /* get the typedef for CARD32 */	32	#include <X11/Xmd.h> /* get the typedef for CARD32 */
31		33
32	#include <stdint.h>	34	#include <stdint.h>
33	#include <wchar.h>	35	#include <wchar.h>
34		36
35	#include "salloc.C" // HACK!!	37	#include "salloc.C" // HACK, should be a seperate compile!
36		38
37	inline void fill_text (text_t *start, text_t value, int len)	39	inline void fill_text (text_t *start, text_t value, int len)
38	{	40	{
39	while (len--)	41	while (len--)
40	*start++ = value;	42	*start++ = value;
…		…
437	uint16_t total_rows;	439	uint16_t total_rows;
438	int i;	440	int i;
439		441
440	total_rows = TermWin.nrow + TermWin.saveLines;	442	total_rows = TermWin.nrow + TermWin.saveLines;
441		443
442	#ifdef DEBUG_STRICT
443	for (i = 0; i < total_rows; i++)
444	{
445	if (screen.text[i])
446	/* then so is screen.rend[i] */
447	assert (screen.rend[i]);
448	}
449	#endif
450
451	delete talloc; talloc = 0;	444	delete talloc; talloc = 0;
452	delete ralloc; ralloc = 0;	445	delete ralloc; ralloc = 0;
453		446
454	free (screen.text);	447	free (screen.text);
455	free (screen.tlen);	448	free (screen.tlen);
…		…
498	* XTERM_SEQ: Restore cursor: ESC 8	491	* XTERM_SEQ: Restore cursor: ESC 8
499	*/	492	*/
500	void	493	void
501	rxvt_term::scr_cursor (int mode)	494	rxvt_term::scr_cursor (int mode)
502	{	495	{
503	screen_t *s;	496	screen_t *s;
504		497
505	D_SCREEN ((stderr, "rxvt_scr_cursor (%c)", mode));	498	D_SCREEN ((stderr, "rxvt_scr_cursor (%c)", mode));
506		499
507	#if NSCREENS && !defined(NO_SECONDARY_SCREEN_CURSOR)	500	#if NSCREENS && !defined(NO_SECONDARY_SCREEN_CURSOR)
508	if (current_screen == SECONDARY)	501	if (current_screen == SECONDARY)
509	s = & (swap);	502	s = &swap;
510	else	503	else
511	#endif	504	#endif
512	s = & (screen);	505	s = &screen;
		506
513	switch (mode)	507	switch (mode)
514	{	508	{
515	case SAVE:	509	case SAVE:
516	s->s_cur.row = s->cur.row;	510	s->s_cur.row = s->cur.row;
517	s->s_cur.col = s->cur.col;	511	s->s_cur.col = s->cur.col;
…		…
528	s->charset = s->s_charset;	522	s->charset = s->s_charset;
529	charsets[s->charset] = s->s_charset_char;	523	charsets[s->charset] = s->s_charset_char;
530	set_font_style ();	524	set_font_style ();
531	break;	525	break;
532	}	526	}
		527
533	/* boundary check in case screen size changed between SAVE and RESTORE */	528	/* boundary check in case screen size changed between SAVE and RESTORE */
534	MIN_IT (s->cur.row, TermWin.nrow - 1);	529	MIN_IT (s->cur.row, TermWin.nrow - 1);
535	MIN_IT (s->cur.col, TermWin.ncol - 1);	530	MIN_IT (s->cur.col, TermWin.ncol - 1);
536	#ifdef DEBUG_STRICT	531	#ifdef DEBUG_STRICT
537	assert (s->cur.row >= 0);	532	assert (s->cur.row >= 0);
…		…
549	* XTERM_SEQ: Secondary screen: ESC [ ? 4 7 l	544	* XTERM_SEQ: Secondary screen: ESC [ ? 4 7 l
550	*/	545	*/
551	int	546	int
552	rxvt_term::scr_change_screen (int scrn)	547	rxvt_term::scr_change_screen (int scrn)
553	{	548	{
554	int i;	549	int i;
555	#if NSCREENS	550	#if NSCREENS
556	int offset;	551	int offset;
557	#endif	552	#endif
558		553
559	want_refresh = 1;	554	want_refresh = 1;
560		555
561	D_SCREEN ((stderr, "rxvt_scr_change_screen (%d)", scrn));	556	D_SCREEN ((stderr, "rxvt_scr_change_screen (%d)", scrn));
…		…
760	/* ------------------------------------------------------------------------- */	755	/* ------------------------------------------------------------------------- */
761	/*	756	/*
762	* Add text given in <str> of length <len> to screen struct	757	* Add text given in <str> of length <len> to screen struct
763	*/	758	*/
764	void	759	void
765	rxvt_term::scr_add_lines (const uint32_t *str, int nlines, int len)	760	rxvt_term::scr_add_lines (const unicode_t *str, int nlines, int len)
766	{	761	{
767	unsigned char checksel, clearsel;	762	unsigned char checksel, clearsel;
768	uint32_t c;	763	unicode_t c;
769	int i, row, last_col;	764	int i, row, last_col;
770	text_t *stp;	765	text_t *stp;
771	rend_t *srp;	766	rend_t *srp;
772		767
773	if (len <= 0) /* sanity */	768	if (len <= 0) /* sanity */
774	return;	769	return;
775		770
776	want_refresh = 1;	771	want_refresh = 1;
…		…
799	MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);	794	MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);
800	MAX_IT (screen.cur.row, - (int32_t)TermWin.nscrolled);	795	MAX_IT (screen.cur.row, - (int32_t)TermWin.nscrolled);
801	#endif	796	#endif
802	row = screen.cur.row + TermWin.saveLines;	797	row = screen.cur.row + TermWin.saveLines;
803		798
804	checksel = (selection.op	799	checksel = selection.op && current_screen == selection.screen ? 1 : 0;
805	&& current_screen == selection.screen) ? 1 : 0;
806	clearsel = 0;	800	clearsel = 0;
807		801
808	stp = screen.text[row];	802	stp = screen.text[row];
809	srp = screen.rend[row];	803	srp = screen.rend[row];
810		804
811	for (i = 0; i < len;)	805	while (len--)
812	{	806	{
813	c = str[i++];	807	c = *str++;
		808
		809	if (c < 0x20)
814	switch (c)	810	switch (c)
815	{	811	{
816	case '\t':	812	case '\t':
817	scr_tab (1);	813	scr_tab (1);
818	continue;	814	continue;
		815
819	case '\n':	816	case '\n':
820	if (screen.tlen[row] != -1) /* XXX: think about this */	817	if (screen.tlen[row] != -1) /* XXX: think about this */
821	MAX_IT (screen.tlen[row], screen.cur.col);	818	MAX_IT (screen.tlen[row], screen.cur.col);
		819
822	screen.flags &= ~Screen_WrapNext;	820	screen.flags &= ~Screen_WrapNext;
		821
823	if (screen.cur.row == screen.bscroll)	822	if (screen.cur.row == screen.bscroll)
824	scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);	823	scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);
825	else if (screen.cur.row < (TermWin.nrow - 1))	824	else if (screen.cur.row < (TermWin.nrow - 1))
826	row = (++screen.cur.row) + TermWin.saveLines;	825	row = (++screen.cur.row) + TermWin.saveLines;
		826
827	stp = screen.text[row]; /* _must_ refresh */	827	stp = screen.text[row]; /* _must_ refresh */
828	srp = screen.rend[row]; /* _must_ refresh */	828	srp = screen.rend[row]; /* _must_ refresh */
829	continue;	829	continue;
		830
830	case '\r':	831	case '\r':
831	if (screen.tlen[row] != -1) /* XXX: think about this */	832	if (screen.tlen[row] != -1) /* XXX: think about this */
832	MAX_IT (screen.tlen[row], screen.cur.col);	833	MAX_IT (screen.tlen[row], screen.cur.col);
		834
833	screen.flags &= ~Screen_WrapNext;	835	screen.flags &= ~Screen_WrapNext;
834	screen.cur.col = 0;	836	screen.cur.col = 0;
835	continue;	837	continue;
836	default:
837	if (c == 127)
838	continue; /* yummmm..... */
839	break;
840	}	838	}
841		839
842	if (checksel /* see if we're writing within selection */	840	if (checksel /* see if we're writing within selection */
843	&& !ROWCOL_IS_BEFORE (screen.cur, selection.beg)	841	&& !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
844	&& ROWCOL_IS_BEFORE (screen.cur, selection.end))	842	&& ROWCOL_IS_BEFORE (screen.cur, selection.end))
845	{	843	{
846	checksel = 0;	844	checksel = 0;
847	clearsel = 1;	845	clearsel = 1;
848	}	846	}
		847
849	if (screen.flags & Screen_WrapNext)	848	if (screen.flags & Screen_WrapNext)
850	{	849	{
851	screen.tlen[row] = -1;	850	screen.tlen[row] = -1;
852	if (screen.cur.row == screen.bscroll)	851	if (screen.cur.row == screen.bscroll)
853	scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);	852	scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);
854	else if (screen.cur.row < (TermWin.nrow - 1))	853	else if (screen.cur.row < (TermWin.nrow - 1))
855	row = (++screen.cur.row) + TermWin.saveLines;	854	row = (++screen.cur.row) + TermWin.saveLines;
		855
856	stp = screen.text[row]; /* _must_ refresh */	856	stp = screen.text[row]; /* _must_ refresh */
857	srp = screen.rend[row]; /* _must_ refresh */	857	srp = screen.rend[row]; /* _must_ refresh */
858	screen.cur.col = 0;	858	screen.cur.col = 0;
859	screen.flags &= ~Screen_WrapNext;	859	screen.flags &= ~Screen_WrapNext;
860	}	860	}
		861
861	if (screen.flags & Screen_Insert)	862	if (screen.flags & Screen_Insert)
862	scr_insdel_chars (1, INSERT);	863	scr_insdel_chars (1, INSERT);
863		864
		865	// rely on wcwidth to tell us the character width, at least for non-latin1
		866	// do wcwidth before further replacements, as wcwidth says that line-drawing
		867	// characters have width -1 (DOH!) on GNU/Linux sometimes.
		868	int width = c < 256 ? 1 : wcwidth (c);
		869
864	if (charsets[screen.charset] == '0') // DEC SPECIAL	870	if (charsets[screen.charset] == '0') // DEC SPECIAL
865	switch (c)
866	{	871	{
867	// dunno where these come from
868	#if 0
869	case '+': c = 0x2192; break; case ',': c = 0x2190; break; case '-': c = 0x2191; break;
870	case '.': c = 0x2193; break; case '0': c = 0x25ae; break;
871	#endif
872	// vt100 special graphics and line drawing	872	// vt100 special graphics and line drawing
873	case '`': c = 0x25c6; break; case '_': c = 0x0020; break;	873	static uint16_t vt100_0[32] = { // 5f .. 7e
874	case 'a': c = 0x2592; break; case 'b': c = 0x2409; break; case 'c': c = 0x240c; break;	874	0x0020, 0x25c6, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0,
875	case 'd': c = 0x240d; break; case 'e': c = 0x240a; break; case 'f': c = 0x00b0; break;	875	0x00b1, 0x2424, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c,
876	case 'g': c = 0x00b1; break; case 'h': c = 0x2424; break; case 'i': c = 0x240b; break;	876	0x23ba, 0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534,
877	case 'j': c = 0x2518; break; case 'k': c = 0x2510; break; case 'l': c = 0x250c; break;	877	0x252c, 0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7,
878	case 'm': c = 0x2514; break; case 'n': c = 0x253c; break; case 'o': c = 0x23ba; break;
879	case 'p': c = 0x23bb; break; case 'q': c = 0x2500; break; case 'r': c = 0x23bc; break;
880	case 's': c = 0x23bd; break; case 't': c = 0x251c; break; case 'u': c = 0x2524; break;
881	case 'v': c = 0x2534; break; case 'w': c = 0x252c; break; case 'x': c = 0x2502; break;
882	case 'y': c = 0x2264; break; case 'z': c = 0x2265; break; case '{': c = 0x03c0; break;
883	case '|': c = 0x2260; break; case '}': c = 0x00a3; break; case '~': c = 0x00b7; break;
884	}	878	};
885		879
886	rend_t rend = SET_FONT (rstyle, TermWin.fontset->find_font (c));	880	if (c >= 0x5f && c <= 0x7e)
887	// rely on wcwidth to tell us the character width, at least for non-ascii	881	{
888	int width = c <= 128 ? 1 : wcwidth (c);	882	c = vt100_0[c - 0x5f];
		883	width = 1;
		884	}
		885	}
889		886
890	// width -1 characters (e.g. combining chars) are ignored currently.
891	if (width > 0)	887	if (width > 0)
		888	{
		889	#if !UNICODE_3 && ENABLE_COMBINING
		890	// trim characters we can't store directly :(
		891	if (c >= 0x10000)
		892	c = rxvt_composite.compose (c); // map to lower 16 bits
		893	#endif
		894	rend_t rend = SET_FONT (rstyle, TermWin.fontset->find_font (c));
		895
892	do	896	do
893	{	897	{
894	stp[screen.cur.col] = c;	898	stp[screen.cur.col] = c;
895	srp[screen.cur.col] = rend;	899	srp[screen.cur.col] = rend;
896		900
897	if (screen.cur.col < last_col - 1)	901	if (screen.cur.col < last_col - 1)
898	screen.cur.col++;	902	screen.cur.col++;
899	else	903	else
900	{	904	{
901	screen.tlen[row] = last_col;	905	screen.tlen[row] = last_col;
902	if (screen.flags & Screen_Autowrap)	906	if (screen.flags & Screen_Autowrap)
903	screen.flags |= Screen_WrapNext;	907	screen.flags |= Screen_WrapNext;
904	break;	908	break;
905	}	909	}
906		910
907	c = NOCHAR;	911	c = NOCHAR;
908	}	912	}
909	while (--width > 0);	913	while (--width > 0);
		914
		915	// pad with spaces when overwriting wide character with smaller one
		916	for (int c = screen.cur.col; c < last_col && stp[c] == NOCHAR; c++)
		917	{
		918	stp[c] = ' ';
		919	srp[c] = rend;
		920	}
		921	}
		922	else if (width == 0)
		923	{
		924	#if ENABLE_COMBINING
		925	// handle combining characters
		926	// we just tag the accent on the previous on-screen character.
		927	// this is arguably not correct, but also arguably not wrong.
		928	// we don't handle double-width characters nicely yet.
		929
		930	text_t *tp;
		931	rend_t *rp;
		932
		933	if (screen.cur.col > 0)
		934	{
		935	tp = stp + screen.cur.col - 1;
		936	rp = srp + screen.cur.col - 1;
		937	}
		938	else if (screen.cur.row > 0
		939	&& screen.tlen [screen.cur.row - 1 + TermWin.saveLines] == -1)
		940	{
		941	tp = screen.text[screen.cur.row - 1 + TermWin.saveLines] + last_col - 1;
		942	rp = screen.rend[screen.cur.row - 1 + TermWin.saveLines] + last_col - 1;
		943	}
910	else	944	else
911	(void)0; /* handle combining character etc. here. */	945	continue;
		946
		947	// handle double-width-chars by making them look extremely ugly
		948	if (*tp == NOCHAR)
		949	*tp = ' '; // hack //D //TODO //--tp, --rp;
		950
		951	// first try to find a precomposed character
		952	unicode_t n = rxvt_compose (*tp, c);
		953	if (n == NOCHAR)
		954	n = rxvt_composite.compose (*tp, c);
		955
		956	*tp = n;
		957	*rp = SET_FONT (*rp, TermWin.fontset->find_font (*tp));
		958	#endif
		959	}
912	}	960	}
913		961
914	if (screen.tlen[row] != -1) /* XXX: think about this */	962	if (screen.tlen[row] != -1) /* XXX: think about this */
915	MAX_IT (screen.tlen[row], screen.cur.col);	963	MAX_IT (screen.tlen[row], screen.cur.col);
916		964
…		…
962	* XTERM_SEQ: CTRL-I	1010	* XTERM_SEQ: CTRL-I
963	*/	1011	*/
964	void	1012	void
965	rxvt_term::scr_tab (int count)	1013	rxvt_term::scr_tab (int count)
966	{	1014	{
967	int i, x;	1015	int i, x;
968		1016
969	D_SCREEN ((stderr, "rxvt_scr_tab (%d)", count));	1017	D_SCREEN ((stderr, "rxvt_scr_tab (%d)", count));
970	want_refresh = 1;	1018	want_refresh = 1;
971	i = x = screen.cur.col;	1019	i = x = screen.cur.col;
		1020
972	if (count == 0)	1021	if (count == 0)
973	return;	1022	return;
974	else if (count > 0)	1023	else if (count > 0)
975	{	1024	{
976	for (; ++i < TermWin.ncol; )	1025	for (; ++i < TermWin.ncol; )
…		…
978	{	1027	{
979	x = i;	1028	x = i;
980	if (!--count)	1029	if (!--count)
981	break;	1030	break;
982	}	1031	}
		1032
983	if (count)	1033	if (count)
984	x = TermWin.ncol - 1;	1034	x = TermWin.ncol - 1;
985	}	1035	}
986	else /* if (count < 0) */	1036	else /* if (count < 0) */
987	{	1037	{
…		…
990	{	1040	{
991	x = i;	1041	x = i;
992	if (!++count)	1042	if (!++count)
993	break;	1043	break;
994	}	1044	}
		1045
995	if (count)	1046	if (count)
996	x = 0;	1047	x = 0;
997	}	1048	}
		1049
998	if (x != screen.cur.col)	1050	if (x != screen.cur.col)
999	scr_gotorc (0, x, R_RELATIVE);	1051	scr_gotorc (0, x, R_RELATIVE);
1000	}	1052	}
1001		1053
1002	/* ------------------------------------------------------------------------- */	1054	/* ------------------------------------------------------------------------- */
…		…
1096	else	1148	else
1097	screen.cur.row = row;	1149	screen.cur.row = row;
1098	}	1150	}
1099	MAX_IT (screen.cur.row, 0);	1151	MAX_IT (screen.cur.row, 0);
1100	MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);	1152	MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);
		1153
		1154	while (screen.cur.col > 0
		1155	&& screen.text[screen.cur.row + TermWin.saveLines][screen.cur.col] == NOCHAR)
		1156	screen.cur.col--;
1101	}	1157	}
1102		1158
1103	/* ------------------------------------------------------------------------- */	1159	/* ------------------------------------------------------------------------- */
1104	/*	1160	/*
1105	* direction should be UP or DN	1161	* direction should be UP or DN
…		…
1191	* XTERM_SEQ: Clear whole screen : ESC [ 2 J	1247	* XTERM_SEQ: Clear whole screen : ESC [ 2 J
1192	*/	1248	*/
1193	void	1249	void
1194	rxvt_term::scr_erase_screen (int mode)	1250	rxvt_term::scr_erase_screen (int mode)
1195	{	1251	{
1196	int num;	1252	int num;
1197	int32_t row, row_offset;	1253	int32_t row, row_offset;
1198	rend_t ren;	1254	rend_t ren;
1199	XGCValues gcvalue;	1255	XGCValues gcvalue;
1200		1256
1201	want_refresh = 1;	1257	want_refresh = 1;
1202	D_SCREEN ((stderr, "rxvt_scr_erase_screen (%d) at screen row: %d", mode, screen.cur.row));	1258	D_SCREEN ((stderr, "rxvt_scr_erase_screen (%d) at screen row: %d", mode, screen.cur.row));
1203	ZERO_SCROLLBACK ();	1259	ZERO_SCROLLBACK ();
1204	row_offset = (int32_t)TermWin.saveLines;	1260	row_offset = (int32_t)TermWin.saveLines;
…		…
1223	num = TermWin.nrow;	1279	num = TermWin.nrow;
1224	break;	1280	break;
1225	default:	1281	default:
1226	return;	1282	return;
1227	}	1283	}
		1284
1228	refresh_type |= REFRESH_BOUNDS;	1285	refresh_type |= REFRESH_BOUNDS;
		1286
1229	if (selection.op && current_screen == selection.screen	1287	if (selection.op && current_screen == selection.screen
1230	&& ((selection.beg.row >= row && selection.beg.row <= row + num)	1288	&& ((selection.beg.row >= row && selection.beg.row <= row + num)
1231	|| (selection.end.row >= row	1289	|| (selection.end.row >= row
1232	&& selection.end.row <= row + num)))	1290	&& selection.end.row <= row + num)))
1233	CLEAR_SELECTION ();	1291	CLEAR_SELECTION ();
		1292
1234	if (row >= TermWin.nrow) /* Out Of Bounds */	1293	if (row >= TermWin.nrow) /* Out Of Bounds */
1235	return;	1294	return;
		1295
1236	MIN_IT (num, (TermWin.nrow - row));	1296	MIN_IT (num, (TermWin.nrow - row));
		1297
1237	if (rstyle & (RS_RVid | RS_Uline))	1298	if (rstyle & (RS_RVid | RS_Uline))
1238	ren = (rend_t) ~RS_None;	1299	ren = (rend_t) ~RS_None;
1239	else if (GET_BASEBG (rstyle) == Color_bg)	1300	else if (GET_BASEBG (rstyle) == Color_bg)
1240	{	1301	{
1241	ren = DEFAULT_RSTYLE;	1302	ren = DEFAULT_RSTYLE;
…		…
1248	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);	1309	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);
1249	ERASE_ROWS (row, num);	1310	ERASE_ROWS (row, num);
1250	gcvalue.foreground = PixColors[Color_fg];	1311	gcvalue.foreground = PixColors[Color_fg];
1251	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);	1312	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);
1252	}	1313	}
		1314
1253	for (; num--; row++)	1315	for (; num--; row++)
1254	{	1316	{
1255	scr_blank_screen_mem (screen.text, screen.rend,	1317	scr_blank_screen_mem (screen.text, screen.rend,
1256	(unsigned int) (row + row_offset), rstyle);	1318	(unsigned int) (row + row_offset), rstyle);
1257	screen.tlen[row + row_offset] = 0;	1319	screen.tlen[row + row_offset] = 0;
…		…
1291	* Insert/Delete <count> lines	1353	* Insert/Delete <count> lines
1292	*/	1354	*/
1293	void	1355	void
1294	rxvt_term::scr_insdel_lines (int count, int insdel)	1356	rxvt_term::scr_insdel_lines (int count, int insdel)
1295	{	1357	{
1296	int end;	1358	int end;
1297		1359
1298	ZERO_SCROLLBACK ();	1360	ZERO_SCROLLBACK ();
1299		1361
1300	selection_check (1);	1362	selection_check (1);
1301		1363
…		…
1320	* Insert/Delete <count> characters from the current position	1382	* Insert/Delete <count> characters from the current position
1321	*/	1383	*/
1322	void	1384	void
1323	rxvt_term::scr_insdel_chars (int count, int insdel)	1385	rxvt_term::scr_insdel_chars (int count, int insdel)
1324	{	1386	{
1325	int col, row;	1387	int col, row;
1326	rend_t tr;	1388	rend_t tr;
1327	text_t *stp;	1389	text_t *stp;
1328	rend_t *srp;	1390	rend_t *srp;
1329	int16_t *slp;	1391	int16_t *slp;
1330		1392
1331	want_refresh = 1;	1393	want_refresh = 1;
1332	ZERO_SCROLLBACK ();	1394	ZERO_SCROLLBACK ();
1333		1395
1334	if (count <= 0)	1396	if (count <= 0)
…		…
1341	screen.flags &= ~Screen_WrapNext;	1403	screen.flags &= ~Screen_WrapNext;
1342		1404
1343	stp = screen.text[row];	1405	stp = screen.text[row];
1344	srp = screen.rend[row];	1406	srp = screen.rend[row];
1345	slp = & (screen.tlen[row]);	1407	slp = & (screen.tlen[row]);
		1408
1346	switch (insdel)	1409	switch (insdel)
1347	{	1410	{
1348	case INSERT:	1411	case INSERT:
1349	for (col = TermWin.ncol - 1; (col - count) >= screen.cur.col;	1412	for (col = TermWin.ncol - 1; (col - count) >= screen.cur.col;
1350	col--)	1413	col--)
1351	{	1414	{
1352	stp[col] = stp[col - count];	1415	stp[col] = stp[col - count];
1353	srp[col] = srp[col - count];	1416	srp[col] = srp[col - count];
1354	}	1417	}
		1418
1355	if (*slp != -1)	1419	if (*slp != -1)
1356	{	1420	{
1357	*slp += count;	1421	*slp += count;
1358	MIN_IT (*slp, TermWin.ncol);	1422	MIN_IT (*slp, TermWin.ncol);
1359	}	1423	}
		1424
1360	if (selection.op && current_screen == selection.screen	1425	if (selection.op && current_screen == selection.screen
1361	&& ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))	1426	&& ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
1362	{	1427	{
1363	if (selection.end.row != screen.cur.row	1428	if (selection.end.row != screen.cur.row
1364	|| (selection.end.col + count >= TermWin.ncol))	1429	|| (selection.end.col + count >= TermWin.ncol))
…		…
1368	selection.beg.col += count;	1433	selection.beg.col += count;
1369	selection.mark.col += count; /* XXX: yes? */	1434	selection.mark.col += count; /* XXX: yes? */
1370	selection.end.col += count;	1435	selection.end.col += count;
1371	}	1436	}
1372	}	1437	}
		1438
1373	scr_blank_line (& (stp[screen.cur.col]), & (srp[screen.cur.col]),	1439	scr_blank_line (& (stp[screen.cur.col]), & (srp[screen.cur.col]),
1374	(unsigned int)count, rstyle);	1440	(unsigned int)count, rstyle);
1375	break;	1441	break;
		1442
1376	case ERASE:	1443	case ERASE:
1377	screen.cur.col += count; /* don't worry if > TermWin.ncol */	1444	screen.cur.col += count; /* don't worry if > TermWin.ncol */
1378	selection_check (1);	1445	selection_check (1);
1379	screen.cur.col -= count;	1446	screen.cur.col -= count;
1380	scr_blank_line (& (stp[screen.cur.col]), & (srp[screen.cur.col]),	1447	scr_blank_line (& (stp[screen.cur.col]), & (srp[screen.cur.col]),
1381	(unsigned int)count, rstyle);	1448	(unsigned int)count, rstyle);
1382	break;	1449	break;
		1450
1383	case DELETE:	1451	case DELETE:
1384	tr = srp[TermWin.ncol - 1]
1385	& (RS_fgMask | RS_bgMask | RS_baseattrMask);	1452	tr = srp[TermWin.ncol - 1] & (RS_fgMask | RS_bgMask | RS_baseattrMask);
		1453
1386	for (col = screen.cur.col; (col + count) < TermWin.ncol; col++)	1454	for (col = screen.cur.col; (col + count) < TermWin.ncol; col++)
1387	{	1455	{
1388	stp[col] = stp[col + count];	1456	stp[col] = stp[col + count];
1389	srp[col] = srp[col + count];	1457	srp[col] = srp[col + count];
1390	}	1458	}
		1459
1391	scr_blank_line (& (stp[TermWin.ncol - count]),	1460	scr_blank_line (& (stp[TermWin.ncol - count]),
1392	& (srp[TermWin.ncol - count]),	1461	& (srp[TermWin.ncol - count]),
1393	(unsigned int)count, tr);	1462	(unsigned int)count, tr);
		1463
1394	if (*slp == -1) /* break line continuation */	1464	if (*slp == -1) /* break line continuation */
1395	*slp = TermWin.ncol;	1465	*slp = TermWin.ncol;
		1466
1396	*slp -= count;	1467	*slp -= count;
1397	MAX_IT (*slp, 0);	1468	MAX_IT (*slp, 0);
		1469
1398	if (selection.op && current_screen == selection.screen	1470	if (selection.op && current_screen == selection.screen
1399	&& ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))	1471	&& ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
1400	{	1472	{
1401	if (selection.end.row != screen.cur.row	1473	if (selection.end.row != screen.cur.row
1402	|| (screen.cur.col >= selection.beg.col - count)	1474	|| (screen.cur.col >= selection.beg.col - count)
…		…
1408	selection.beg.col -= count;	1480	selection.beg.col -= count;
1409	selection.mark.col -= count; /* XXX: yes? */	1481	selection.mark.col -= count; /* XXX: yes? */
1410	selection.end.col -= count;	1482	selection.end.col -= count;
1411	}	1483	}
1412	}	1484	}
		1485
1413	break;	1486	break;
1414	}	1487	}
1415	}	1488	}
1416		1489
1417	/* ------------------------------------------------------------------------- */	1490	/* ------------------------------------------------------------------------- */
…		…
1422	void	1495	void
1423	rxvt_term::scr_scroll_region (int top, int bot)	1496	rxvt_term::scr_scroll_region (int top, int bot)
1424	{	1497	{
1425	MAX_IT (top, 0);	1498	MAX_IT (top, 0);
1426	MIN_IT (bot, (int)TermWin.nrow - 1);	1499	MIN_IT (bot, (int)TermWin.nrow - 1);
		1500
1427	if (top > bot)	1501	if (top > bot)
1428	return;	1502	return;
		1503
1429	screen.tscroll = top;	1504	screen.tscroll = top;
1430	screen.bscroll = bot;	1505	screen.bscroll = bot;
1431	scr_gotorc (0, 0, 0);	1506	scr_gotorc (0, 0, 0);
1432	}	1507	}
1433		1508
…		…
1891		1966
1892	/*	1967	/*
1893	* C: set the cursor character (s)	1968	* C: set the cursor character (s)
1894	*/	1969	*/
1895	{	1970	{
1896	unsigned char setoldcursor;	1971	unsigned char setoldcursor;
1897	rend_t ccol1, /* Cursor colour */	1972	rend_t ccol1, /* Cursor colour */
1898	ccol2; /* Cursor colour2 */	1973	ccol2; /* Cursor colour2 */
1899		1974
1900	showcursor = (screen.flags & Screen_VisibleCursor);	1975	showcursor = (screen.flags & Screen_VisibleCursor);
1901	#ifdef CURSOR_BLINK	1976	#ifdef CURSOR_BLINK
1902	if (hidden_cursor)	1977	if (hidden_cursor)
1903	showcursor = 0;	1978	showcursor = 0;
1904	#endif	1979	#endif
1905		1980
1906	if (showcursor)	1981	if (showcursor)
1907	{	1982	{
1908	srp = & (screen.rend[screen.cur.row + TermWin.saveLines]	1983	srp = &(screen.rend[screen.cur.row + TermWin.saveLines][screen.cur.col]);
1909	[screen.cur.col]);
1910		1984
1911	if (showcursor && TermWin.focus)	1985	if (showcursor && TermWin.focus)
1912	{	1986	{
1913	*srp ^= RS_RVid;	1987	*srp ^= RS_RVid;
1914	#ifndef NO_CURSORCOLOR	1988	#ifndef NO_CURSORCOLOR
…		…
1942	if (screen.cur.row + TermWin.view_start != ocrow	2016	if (screen.cur.row + TermWin.view_start != ocrow
1943	|| screen.cur.col != oldcursor.col)	2017	|| screen.cur.col != oldcursor.col)
1944	{	2018	{
1945	if (ocrow < TermWin.nrow	2019	if (ocrow < TermWin.nrow
1946	&& oldcursor.col < TermWin.ncol)	2020	&& oldcursor.col < TermWin.ncol)
1947	{
1948	drawn_rend[ocrow][oldcursor.col] ^= (RS_RVid | RS_Uline);	2021	drawn_rend[ocrow][oldcursor.col] ^= (RS_RVid | RS_Uline);
1949	}	2022
1950	if (TermWin.focus || !showcursor)	2023	if (TermWin.focus || !showcursor)
1951	oldcursor.row = -1;	2024	oldcursor.row = -1;
1952	else	2025	else
1953	setoldcursor = 1;	2026	setoldcursor = 1;
1954	}	2027	}
1955	}	2028	}
1956	else if (!TermWin.focus)	2029	else if (!TermWin.focus)
1957	setoldcursor = 1;	2030	setoldcursor = 1;
		2031
1958	if (setoldcursor)	2032	if (setoldcursor)
1959	{	2033	{
1960	if (screen.cur.row + TermWin.view_start >= TermWin.nrow)	2034	if (screen.cur.row + TermWin.view_start >= TermWin.nrow)
1961	oldcursor.row = -1;	2035	oldcursor.row = -1;
1962	else	2036	else
…		…
1974	*/	2048	*/
1975	i = num_scr;	2049	i = num_scr;
1976	if (refresh_type == FAST_REFRESH && num_scr_allow && i	2050	if (refresh_type == FAST_REFRESH && num_scr_allow && i
1977	&& abs (i) < TermWin.nrow && !must_clear)	2051	&& abs (i) < TermWin.nrow && !must_clear)
1978	{	2052	{
1979	int16_t nits;	2053	int16_t nits;
1980	int j;	2054	int j;
1981	rend_t *drp2;	2055	rend_t *drp2;
1982	text_t *dtp2;	2056	text_t *dtp2;
1983	int len, wlen;	2057	int len, wlen;
1984		2058
1985	j = TermWin.nrow;	2059	j = TermWin.nrow;
1986	wlen = len = -1;	2060	wlen = len = -1;
1987	row = i > 0 ? 0 : j - 1;	2061	row = i > 0 ? 0 : j - 1;
1988	for (; j-- >= 0; row += (i > 0 ? 1 : -1))	2062	for (; j-- >= 0; row += (i > 0 ? 1 : -1))
…		…
2052	int ypixel = (int)Row2Pixel (row);	2126	int ypixel = (int)Row2Pixel (row);
2053		2127
2054	for (col = 0; col < TermWin.ncol; col++)	2128	for (col = 0; col < TermWin.ncol; col++)
2055	{	2129	{
2056	/* compare new text with old - if exactly the same then continue */	2130	/* compare new text with old - if exactly the same then continue */
		2131	if (stp[col] == dtp[col] /* Must match characters to skip. */
		2132	&& (srp[col] == drp[col] /* Either rendition the same or */
		2133	|| (stp[col] == ' ' /* space w/ no background change */
		2134	&& GET_BGATTR (srp[col]) == GET_BGATTR (drp[col]))))
		2135	continue;
		2136
		2137	// redraw one or more characters
		2138
		2139	// seek to the beginning if wide characters
		2140	while (stp[col] == NOCHAR && col > 0)
		2141	--col;
		2142
2057	rend_t rend = srp[col]; /* screen rendition (target rendtion) */	2143	rend_t rend = srp[col]; /* screen rendition (target rendtion) */
2058
2059	if (stp[col] == dtp[col] /* Must match characters to skip. */
2060	&& (rend == drp[col] /* Either rendition the same or */
2061	|| (stp[col] == ' ' /* space w/ no background change */
2062	&& GET_BGATTR (rend) == GET_BGATTR (drp[col]))))
2063	continue;
2064
2065	text_t *text = stp + col;	2144	text_t *text = stp + col;
2066	int count = 1;	2145	int count = 1;
2067		2146
2068	/* redraw one or more characters */
2069
2070	dtp[col] = stp[col];	2147	dtp[col] = stp[col];
2071	drp[col] = rend;	2148	drp[col] = rend;
2072
2073	if (*text == NOCHAR) // never start redrawing at invisible characters. */
2074	continue;
2075		2149
2076	int xpixel = Col2Pixel (col);	2150	int xpixel = Col2Pixel (col);
2077		2151
2078	// this loop looks very messy, it can probably be optimized	2152	// this loop looks very messy, it can probably be optimized
2079	// and cleaned a bit by you?	2153	// and cleaned a bit by you?
…		…
2132	else	2206	else
2133	rvid = !rvid;	2207	rvid = !rvid;
2134	}	2208	}
2135		2209
2136	if (rend & RS_Uline)	2210	if (rend & RS_Uline)
2137	{
2138	if (ISSET_PIXCOLOR (Color_UL))	2211	if (ISSET_PIXCOLOR (Color_UL))
2139	fore = Color_UL;	2212	fore = Color_UL;
2140	}
2141	#endif	2213	#endif
2142		2214
2143	if (rvid)	2215	if (rvid)
2144	{	2216	{
2145	SWAP_IT (fore, back, int);	2217	SWAP_IT (fore, back, int);
…		…
2153	back = Color_RV;	2225	back = Color_RV;
2154	#endif	2226	#endif
2155	}	2227	}
2156		2228
2157	#ifdef TEXT_BLINK	2229	#ifdef TEXT_BLINK
2158	if (rend & RS_Blink)	2230	if (rend & RS_Blink && back == Color_bg)
2159	{	2231	{
2160	if (!text_blink_ev.active)	2232	if (!text_blink_ev.active)
2161	{	2233	{
2162	text_blink_ev.start (NOW + TEXT_BLINK_INTERVAL);	2234	text_blink_ev.start (NOW + TEXT_BLINK_INTERVAL);
2163	hidden_text = 0;	2235	hidden_text = 0;
…		…
2195	else	2267	else
2196	font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, back);	2268	font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, back);
2197		2269
2198	if ((rend & RS_Uline) && (font->descent > 1))	2270	if ((rend & RS_Uline) && (font->descent > 1))
2199	XDrawLine (display->display, drawBuffer, TermWin.gc,	2271	XDrawLine (display->display, drawBuffer, TermWin.gc,
2200	xpixel, ypixel + font->ascent + 1,	2272	xpixel, ypixel + font->ascent + 1,
2201	xpixel + Width2Pixel (count) - 1, ypixel + font->ascent + 1);	2273	xpixel + Width2Pixel (count) - 1, ypixel + font->ascent + 1);
2202	} /* for (col....) */	2274	} /* for (col....) */
2203	} /* for (row....) */	2275	} /* for (row....) */
2204		2276
2205	/*	2277	/*
2206	* G: cleanup cursor and display outline cursor if necessary	2278	* G: cleanup cursor and display outline cursor if necessary
…		…
2226	while (oldcursor.col + cursorwidth < TermWin.ncol	2298	while (oldcursor.col + cursorwidth < TermWin.ncol
2227	&& drawn_text[oldcursor.row][oldcursor.col + cursorwidth] == NOCHAR)	2299	&& drawn_text[oldcursor.row][oldcursor.col + cursorwidth] == NOCHAR)
2228	cursorwidth++;	2300	cursorwidth++;
2229		2301
2230	XDrawRectangle (display->display, drawBuffer, TermWin.gc,	2302	XDrawRectangle (display->display, drawBuffer, TermWin.gc,
2231	Col2Pixel (oldcursor.col),	2303	Col2Pixel (oldcursor.col),
2232	Row2Pixel (oldcursor.row),	2304	Row2Pixel (oldcursor.row),
2233	(unsigned int) (Width2Pixel (cursorwidth) - 1),	2305	(unsigned int) (Width2Pixel (cursorwidth) - 1),
2234	(unsigned int) (Height2Pixel (1) - TermWin.lineSpace - 1));	2306	(unsigned int) (Height2Pixel (1) - TermWin.lineSpace - 1));
2235	}	2307	}
2236	}	2308	}
2237		2309
2238	/*	2310	/*
2239	* H: cleanup selection	2311	* H: cleanup selection
…		…
2247	/*	2319	/*
2248	* clear the whole screen height, note that width == 0 is treated	2320	* clear the whole screen height, note that width == 0 is treated
2249	* specially by XClearArea	2321	* specially by XClearArea
2250	*/	2322	*/
2251	XClearArea (display->display, TermWin.vt, 0, 0,	2323	XClearArea (display->display, TermWin.vt, 0, 0,
2252	(unsigned int)TermWin.int_bwidth,	2324	(unsigned int)TermWin.int_bwidth,
2253	(unsigned int)TermWin_TotalHeight (), False);	2325	(unsigned int)TermWin_TotalHeight (), False);
		2326
2254	if (clearlast && TermWin.int_bwidth)	2327	if (clearlast && TermWin.int_bwidth)
2255	/*	2328	/*
2256	* clear the whole screen height, note that width == 0 is treated	2329	* clear the whole screen height, note that width == 0 is treated
2257	* specially by XClearArea	2330	* specially by XClearArea
2258	*/	2331	*/
2259	XClearArea (display->display, TermWin.vt,	2332	XClearArea (display->display, TermWin.vt,
2260	TermWin.width + TermWin.int_bwidth, 0,	2333	TermWin.width + TermWin.int_bwidth, 0,
2261	(unsigned int)TermWin.int_bwidth,	2334	(unsigned int)TermWin.int_bwidth,
2262	(unsigned int)TermWin_TotalHeight (), False);	2335	(unsigned int)TermWin_TotalHeight (), False);
		2336
2263	if (refresh_type & SMOOTH_REFRESH)	2337	if (refresh_type & SMOOTH_REFRESH)
2264	XSync (display->display, False);	2338	XSync (display->display, False);
2265		2339
2266	num_scr = 0;	2340	num_scr = 0;
2267	num_scr_allow = 1;	2341	num_scr_allow = 1;
…		…
2291	}	2365	}
2292	}	2366	}
2293		2367
2294	/* ------------------------------------------------------------------------- */	2368	/* ------------------------------------------------------------------------- */
2295	void	2369	void
2296	rxvt_term::scr_clear ()	2370	rxvt_term::scr_clear (bool really)
2297	{	2371	{
2298	if (!TermWin.mapped)	2372	if (!TermWin.mapped)
2299	return;	2373	return;
2300		2374
2301	num_scr_allow = 0;	2375	num_scr_allow = 0;
2302	want_refresh = 1;	2376	want_refresh = 1;
		2377
2303	#ifdef TRANSPARENT	2378	#ifdef TRANSPARENT
2304	if ((Options & Opt_transparent) && (am_pixmap_trans == 0))	2379	if ((Options & Opt_transparent) && (am_pixmap_trans == 0))
2305	{	2380	{
2306	int i;	2381	int i;
2307		2382
…		…
2314	if (TermWin.parent[i] != None)	2389	if (TermWin.parent[i] != None)
2315	XClearWindow (display->display, TermWin.parent[i]);	2390	XClearWindow (display->display, TermWin.parent[i]);
2316	}	2391	}
2317	#endif	2392	#endif
2318		2393
		2394	if (really)
2319	XClearWindow (display->display, TermWin.vt);	2395	XClearWindow (display->display, TermWin.vt);
2320	}	2396	}
2321		2397
2322	/* ------------------------------------------------------------------------- */	2398	/* ------------------------------------------------------------------------- */
2323	void	2399	void
2324	rxvt_term::scr_reverse_selection ()	2400	rxvt_term::scr_reverse_selection ()
2325	{	2401	{
2326	int i, col, row, end_row;
2327	rend_t *srp;
2328
2329	if (selection.op && current_screen == selection.screen)	2402	if (selection.op && current_screen == selection.screen)
2330	{	2403	{
2331	end_row = TermWin.saveLines - TermWin.view_start;	2404	int end_row = TermWin.saveLines - TermWin.view_start;
2332	i = selection.beg.row + TermWin.saveLines;	2405	int i = selection.beg.row + TermWin.saveLines;
2333	row = selection.end.row + TermWin.saveLines;	2406	int col, row = selection.end.row + TermWin.saveLines;
		2407	rend_t *srp;
		2408
2334	if (i >= end_row)	2409	if (i >= end_row)
2335	col = selection.beg.col;	2410	col = selection.beg.col;
2336	else	2411	else
2337	{	2412	{
2338	col = 0;	2413	col = 0;
2339	i = end_row;	2414	i = end_row;
2340	}	2415	}
		2416
2341	end_row += TermWin.nrow;	2417	end_row += TermWin.nrow;
2342	for (; i < row && i < end_row; i++, col = 0)	2418	for (; i < row && i < end_row; i++, col = 0)
2343	for (srp = screen.rend[i]; col < TermWin.ncol; col++)	2419	for (srp = screen.rend[i]; col < TermWin.ncol; col++)
2344	srp[col] ^= RS_RVid;	2420	srp[col] ^= RS_RVid;
		2421
2345	if (i == row && i < end_row)	2422	if (i == row && i < end_row)
2346	for (srp = screen.rend[i]; col < selection.end.col; col++)	2423	for (srp = screen.rend[i]; col < selection.end.col; col++)
2347	srp[col] ^= RS_RVid;	2424	srp[col] ^= RS_RVid;
2348	}	2425	}
2349	}	2426	}
…		…
2488	}	2565	}
2489		2566
2490	for (;;)	2567	for (;;)
2491	{	2568	{
2492	if (XGetWindowProperty (display->display, win, prop, (long) (nread / 4),	2569	if (XGetWindowProperty (display->display, win, prop, (long) (nread / 4),
2493	(long) (PROP_SIZE / 4), delete_prop,	2570	(long) (PROP_SIZE / 4), delete_prop,
2494	AnyPropertyType, &ct.encoding, &ct.format,	2571	AnyPropertyType, &ct.encoding, &ct.format,
2495	&ct.nitems, &bytes_after,	2572	&ct.nitems, &bytes_after,
2496	&ct.value) != Success)	2573	&ct.value) != Success)
2497	break;	2574	break;
2498		2575
2499	if (ct.encoding == 0)	2576	if (ct.encoding == 0)
2500	{	2577	{
2501	D_SELECT ((stderr, "rxvt_selection_paste: property didn't exist!"));	2578	D_SELECT ((stderr, "rxvt_selection_paste: property didn't exist!"));
…		…
2509	}	2586	}
2510		2587
2511	if (ct.nitems == 0)	2588	if (ct.nitems == 0)
2512	{	2589	{
2513	D_SELECT ((stderr, "rxvt_selection_paste: property empty - also INCR end"));	2590	D_SELECT ((stderr, "rxvt_selection_paste: property empty - also INCR end"));
		2591
2514	if (selection_wait == Sel_normal && nread == 0)	2592	if (selection_wait == Sel_normal && nread == 0
		2593	&& (win != display->root || prop != XA_CUT_BUFFER0)) // avoid recursion
2515	{	2594	{
2516	/*	2595	/*
2517	* pass through again trying CUT_BUFFER0 if we've come from	2596	* pass through again trying CUT_BUFFER0 if we've come from
2518	* XConvertSelection () but nothing was presented	2597	* XConvertSelection () but nothing was presented
2519	*/	2598	*/
…		…
2559	void	2638	void
2560	rxvt_term::incr_cb (time_watcher &w)	2639	rxvt_term::incr_cb (time_watcher &w)
2561	{	2640	{
2562	selection_wait = Sel_none;	2641	selection_wait = Sel_none;
2563		2642
2564	rxvt_print_error ("data loss: timeout on INCR selection paste");	2643	rxvt_warn ("data loss: timeout on INCR selection paste, ignoring.\n");
2565	}	2644	}
2566		2645
2567	/*	2646	/*
2568	* INCR support originally provided by Paul Sheer <psheer@obsidian.co.za>	2647	* INCR support originally provided by Paul Sheer <psheer@obsidian.co.za>
2569	*/	2648	*/
…		…
2572	{	2651	{
2573	int reget_time = 0;	2652	int reget_time = 0;
2574		2653
2575	if (prop == None)	2654	if (prop == None)
2576	return;	2655	return;
		2656
2577	D_SELECT ((stderr, "rxvt_selection_property (%08lx, %lu)", win, (unsigned long)prop));	2657	D_SELECT ((stderr, "rxvt_selection_property (%08lx, %lu)", win, (unsigned long)prop));
2578	if (selection_wait == Sel_normal)	2658	if (selection_wait == Sel_normal)
2579	{	2659	{
2580	int a, afmt;	2660	int a, afmt;
2581	Atom atype;	2661	Atom atype;
2582	unsigned long bytes_after, nitems;	2662	unsigned long bytes_after, nitems;
2583	unsigned char *s = NULL;	2663	unsigned char *s = NULL;
2584		2664
2585	a = XGetWindowProperty (display->display, win, prop, 0L, 1L, False,	2665	a = XGetWindowProperty (display->display, win, prop, 0L, 1L, False,
2586	xa[XA_INCR], &atype, &afmt, &nitems,	2666	xa[XA_INCR], &atype, &afmt, &nitems,
2587	&bytes_after, &s);	2667	&bytes_after, &s);
2588	if (s)	2668	if (s)
2589	XFree (s);	2669	XFree (s);
2590	if (a != Success)	2670	if (a != Success)
2591	return;	2671	return;
		2672
2592	#ifndef __CYGWIN32__	2673	#ifndef __CYGWIN32__
2593	if (atype == xa[XA_INCR])	2674	if (atype == xa[XA_INCR])
2594	{ /* start an INCR transfer */	2675	{ /* start an INCR transfer */
2595	D_SELECT ((stderr, "rxvt_selection_property: INCR: starting transfer"));	2676	D_SELECT ((stderr, "rxvt_selection_property: INCR: starting transfer"));
2596	XDeleteProperty (display->display, win, prop);	2677	XDeleteProperty (display->display, win, prop);
…		…
2602		2683
2603	}	2684	}
2604	else if (selection_wait == Sel_incr)	2685	else if (selection_wait == Sel_incr)
2605	{	2686	{
2606	reget_time = 1;	2687	reget_time = 1;
		2688
2607	if (selection_paste (win, prop, True) == -1)	2689	if (selection_paste (win, prop, True) == -1)
2608	{	2690	{
2609	D_SELECT ((stderr, "rxvt_selection_property: INCR: clean end"));	2691	D_SELECT ((stderr, "rxvt_selection_property: INCR: clean end"));
2610	selection_wait = Sel_none;	2692	selection_wait = Sel_none;
2611	incr_ev.stop ();	2693	incr_ev.stop ();
2612	}	2694	}
2613	}	2695	}
2614	if (reget_time) /* received more data so reget time */	2696	if (reget_time) /* received more data so reget time */
2615	incr_ev.start (NOW + 10);	2697	incr_ev.start (NOW + 10);
2616	}	2698	}
		2699
2617	/* ------------------------------------------------------------------------- */	2700	/* ------------------------------------------------------------------------- */
2618	/*	2701	/*
2619	* Request the current selection:	2702	* Request the current selection:
2620	* Order: > internal selection if available	2703	* Order: > internal selection if available
2621	* > PRIMARY, SECONDARY, CLIPBOARD if ownership is claimed (+)	2704	* > PRIMARY, SECONDARY, CLIPBOARD if ownership is claimed (+)
…		…
2626	*/	2709	*/
2627	void	2710	void
2628	rxvt_term::selection_request (Time tm, int x, int y)	2711	rxvt_term::selection_request (Time tm, int x, int y)
2629	{	2712	{
2630	D_SELECT ((stderr, "rxvt_selection_request (%lu, %d, %d)", tm, x, y));	2713	D_SELECT ((stderr, "rxvt_selection_request (%lu, %d, %d)", tm, x, y));
		2714
2631	if (x < 0 || x >= TermWin.width || y < 0 || y >= TermWin.height)	2715	if (x < 0 || x >= TermWin.width || y < 0 || y >= TermWin.height)
2632	return; /* outside window */	2716	return; /* outside window */
2633		2717
2634	if (selection.text != NULL)	2718	if (selection.text)
2635	{ /* internal selection */	2719	{ /* internal selection */
2636	D_SELECT ((stderr, "rxvt_selection_request: pasting internal"));	2720	D_SELECT ((stderr, "rxvt_selection_request: pasting internal"));
2637	paste (selection.text, selection.len);	2721	char *str = rxvt_wcstombs (selection.text, selection.len);
		2722	paste ((unsigned char *)str, strlen (str));
		2723	free (str);
2638	return;	2724	return;
2639	}	2725	}
2640	else	2726	else
2641	{	2727	{
2642	int i;	2728	int i;
2643		2729
2644	selection_request_time = tm;	2730	selection_request_time = tm;
2645	selection_wait = Sel_normal;	2731	selection_wait = Sel_normal;
		2732
2646	for (i = Sel_Primary; i <= Sel_Clipboard; i++)	2733	for (i = Sel_Primary; i <= Sel_Clipboard; i++)
2647	{	2734	{
2648	#if X_HAVE_UTF8_STRING	2735	#if X_HAVE_UTF8_STRING
2649	selection_type = Sel_UTF8String;	2736	selection_type = Sel_UTF8String;
2650	if (selection_request_other (xa[XA_UTF8_STRING], i))	2737	if (selection_request_other (xa[XA_UTF8_STRING], i))
…		…
2655	return;	2742	return;
2656	#endif	2743	#endif
2657		2744
2658	}	2745	}
2659	}	2746	}
		2747
2660	selection_wait = Sel_none; /* don't loop in rxvt_selection_paste () */	2748	selection_wait = Sel_none; /* don't loop in rxvt_selection_paste () */
2661	D_SELECT ((stderr, "rxvt_selection_request: pasting CUT_BUFFER0"));	2749	D_SELECT ((stderr, "rxvt_selection_request: pasting CUT_BUFFER0"));
2662	selection_paste (display->root, XA_CUT_BUFFER0, False);	2750	selection_paste (display->root, XA_CUT_BUFFER0, False);
2663	}	2751	}
2664		2752
2665	int	2753	int
2666	rxvt_term::selection_request_other (Atom target, int selnum)	2754	rxvt_term::selection_request_other (Atom target, int selnum)
2667	{	2755	{
2668	Atom sel;	2756	Atom sel;
2669	#ifdef DEBUG_SELECT	2757	#ifdef DEBUG_SELECT
2670	char *debug_xa_names[] = { "PRIMARY", "SECONDARY", "CLIPBOARD" };	2758	char *debug_xa_names[] = { "PRIMARY", "SECONDARY", "CLIPBOARD" };
2671	#endif	2759	#endif
2672		2760
2673	selection_type |= selnum;	2761	selection_type |= selnum;
		2762
2674	if (selnum == Sel_Primary)	2763	if (selnum == Sel_Primary)
2675	sel = XA_PRIMARY;	2764	sel = XA_PRIMARY;
2676	else if (selnum == Sel_Secondary)	2765	else if (selnum == Sel_Secondary)
2677	sel = XA_SECONDARY;	2766	sel = XA_SECONDARY;
2678	else	2767	else
2679	sel = xa[XA_CLIPBOARD];	2768	sel = xa[XA_CLIPBOARD];
		2769
2680	if (XGetSelectionOwner (display->display, sel) != None)	2770	if (XGetSelectionOwner (display->display, sel) != None)
2681	{	2771	{
2682	D_SELECT ((stderr, "rxvt_selection_request_other: pasting %s", debug_xa_names[selnum]));	2772	D_SELECT ((stderr, "rxvt_selection_request_other: pasting %s", debug_xa_names[selnum]));
2683	XConvertSelection (display->display, sel, target, xa[XA_VT_SELECTION],	2773	XConvertSelection (display->display, sel, target, xa[XA_VT_SELECTION],
2684	TermWin.vt, selection_request_time);	2774	TermWin.vt, selection_request_time);
2685	return 1;	2775	return 1;
2686	}	2776	}
		2777
2687	return 0;	2778	return 0;
2688	}	2779	}
2689		2780
2690	/* ------------------------------------------------------------------------- */	2781	/* ------------------------------------------------------------------------- */
2691	/*	2782	/*
…		…
2700	want_refresh = 1;	2791	want_refresh = 1;
2701	free (selection.text);	2792	free (selection.text);
2702	selection.text = NULL;	2793	selection.text = NULL;
2703	selection.len = 0;	2794	selection.len = 0;
2704	CLEAR_SELECTION ();	2795	CLEAR_SELECTION ();
		2796
		2797	if (display->selection_owner == this)
		2798	display->selection_owner = 0;
2705	}	2799	}
2706		2800
2707	/* ------------------------------------------------------------------------- */	2801	/* ------------------------------------------------------------------------- */
2708	/*	2802	/*
2709	* Copy a selection into the cut buffer	2803	* Copy a selection into the cut buffer
2710	* EXT: button 1 or 3 release	2804	* EXT: button 1 or 3 release
2711	*/	2805	*/
2712	void	2806	void
2713	rxvt_term::selection_make (Time tm)	2807	rxvt_term::selection_make (Time tm)
2714	{	2808	{
2715	int i, col, end_col, row, end_row;	2809	int i, col, end_col, row, end_row;
2716	unsigned char *new_selection_text;	2810	wchar_t *new_selection_text;
2717	char *str;
2718	text_t *t;	2811	text_t *t;
2719	#ifdef ACS_ASCII
2720	rend_t *re;
2721	#endif
2722		2812
2723	D_SELECT ((stderr, "rxvt_selection_make (): selection.op=%d, selection.clicks=%d", selection.op, selection.clicks));	2813	D_SELECT ((stderr, "rxvt_selection_make (): selection.op=%d, selection.clicks=%d", selection.op, selection.clicks));
2724	switch (selection.op)	2814	switch (selection.op)
2725	{	2815	{
2726	case SELECTION_CONT:	2816	case SELECTION_CONT:
…		…
2732	selection.op = SELECTION_DONE;	2822	selection.op = SELECTION_DONE;
2733	/* FALLTHROUGH */	2823	/* FALLTHROUGH */
2734	default:	2824	default:
2735	return;	2825	return;
2736	}	2826	}
		2827
2737	selection.op = SELECTION_DONE;	2828	selection.op = SELECTION_DONE;
2738		2829
2739	if (selection.clicks == 4)	2830	if (selection.clicks == 4)
2740	return; /* nothing selected, go away */	2831	return; /* nothing selected, go away */
2741		2832
2742	i = (selection.end.row - selection.beg.row + 1) * (TermWin.ncol + 1) + 1;	2833	i = (selection.end.row - selection.beg.row + 1) * (TermWin.ncol + 1);
2743	str = (char *)rxvt_malloc (i * MB_CUR_MAX + 1);	2834	new_selection_text = (wchar_t *)rxvt_malloc ((i + 4) * sizeof (wchar_t));
2744
2745	new_selection_text = (unsigned char *)str;
2746		2835
2747	col = selection.beg.col;	2836	col = selection.beg.col;
2748	MAX_IT (col, 0);	2837	MAX_IT (col, 0);
2749	row = selection.beg.row + TermWin.saveLines;	2838	row = selection.beg.row + TermWin.saveLines;
2750	end_row = selection.end.row + TermWin.saveLines;	2839	end_row = selection.end.row + TermWin.saveLines;
		2840	int ofs = 0;
		2841	int extra = 0;
2751		2842
2752	for (; row <= end_row; row++, col = 0)	2843	for (; row <= end_row; row++, col = 0)
2753	{	2844	{
2754	t = & (screen.text[row][col]);	2845	t = &(screen.text[row][col]);
2755		2846
2756	end_col = screen.tlen[row];	2847	end_col = screen.tlen[row];
2757		2848
2758	if (end_col == -1)	2849	if (end_col == -1)
2759	end_col = TermWin.ncol;	2850	end_col = TermWin.ncol;
2760		2851
2761	if (row == end_row)	2852	if (row == end_row)
2762	MIN_IT (end_col, selection.end.col);	2853	MIN_IT (end_col, selection.end.col);
2763		2854
2764	for (; col < end_col; col++)	2855	for (; col < end_col; col++)
		2856	{
2765	if (*t == NOCHAR)	2857	if (*t == NOCHAR)
2766	t++;	2858	t++;
		2859	#if ENABLE_COMBINING
		2860	else if (IS_COMPOSE (*t))
		2861	{
		2862	int len = rxvt_composite.expand (*t, 0);
		2863
		2864	extra -= (len - 1);
		2865
		2866	if (extra < 0)
		2867	{
		2868	extra += i;
		2869	i += i;
		2870	new_selection_text = (wchar_t *)rxvt_realloc (new_selection_text, (i + 4) * sizeof (wchar_t));
		2871	}
		2872
		2873	ofs += rxvt_composite.expand (*t++, new_selection_text + ofs);
		2874	}
		2875	#endif
2767	else	2876	else
2768	{	2877	new_selection_text[ofs++] = *t++;
2769	int len = wctomb (str, *t++);
2770	if (len > 0)
2771	str += len;
2772	}	2878	}
2773		2879
2774	if (screen.tlen[row] != -1 && row != end_row)	2880	if (screen.tlen[row] != -1 && row != end_row)
2775	*str++ = '\n';	2881	new_selection_text[ofs++] = L'\n';
2776	}	2882	}
2777		2883
2778	#ifndef NO_OLD_SELECTION
2779	if (selection_style == OLD_SELECT)
2780	if (end_col == TermWin.ncol)
2781	*str++ = '\n';
2782	#endif
2783	#ifndef NO_NEW_SELECTION
2784	if (selection_style != OLD_SELECT)
2785	if (end_col != selection.end.col)	2884	if (end_col != selection.end.col)
2786	*str++ = '\n';	2885	new_selection_text[ofs++] = L'\n';
2787	#endif
2788	*str = '\0';
2789		2886
2790	i = str - (char *)new_selection_text;	2887	new_selection_text[ofs] = 0;
		2888
2791	if (i == 0)	2889	if (ofs == 0)
2792	{	2890	{
2793	free (new_selection_text);	2891	free (new_selection_text);
2794	return;	2892	return;
2795	}	2893	}
2796		2894
2797	// due to MB_MAX_CUR, selection wastage is usually high, so realloc
2798	if (str - (char *)new_selection_text > 1024)
2799	new_selection_text = (unsigned char *)rxvt_realloc (new_selection_text, i + 1);
2800
2801	selection.len = i;
2802
2803	if (selection.text)
2804	free (selection.text);	2895	free (selection.text);
2805		2896
2806	selection.text = new_selection_text;	2897	// we usually allocate much more than necessary, so realloc it smaller again
		2898	selection.len = ofs;
		2899	selection.text = (wchar_t *)rxvt_realloc (new_selection_text, (ofs + 1) * sizeof (wchar_t));
2807		2900
2808	XSetSelectionOwner (display->display, XA_PRIMARY, TermWin.vt, tm);	2901	XSetSelectionOwner (display->display, XA_PRIMARY, TermWin.vt, tm);
2809	if (XGetSelectionOwner (display->display, XA_PRIMARY) == TermWin.vt)	2902	if (XGetSelectionOwner (display->display, XA_PRIMARY) == TermWin.vt)
2810	display->set_selection_owner (this);	2903	display->set_selection_owner (this);
2811	else	2904	else
2812	rxvt_print_error ("can't get primary selection");	2905	rxvt_warn ("can't get primary selection, ignoring.\n");
2813		2906
2814	{	2907	#if 0
2815	XTextProperty ct;	2908	XTextProperty ct;
2816	char *cl = (char *)selection.text;
2817		2909
2818	if (XmbTextListToTextProperty (display->display, &cl, 1, XStringStyle, &ct) >= 0)	2910	if (XwcTextListToTextProperty (display->display, &selection.text, 1, XStringStyle, &ct) >= 0)
2819	{	2911	{
2820	XChangeProperty (display->display, display->root, XA_CUT_BUFFER0, XA_STRING, 8,
2821	PropModeReplace, ct.value, ct.nitems);
2822	XFree (ct.value);
2823	}
2824	else
2825	XChangeProperty (display->display, display->root, XA_CUT_BUFFER0, XA_STRING, 8,	2912	XChangeProperty (display->display, display->root, XA_CUT_BUFFER0, XA_STRING, 8,
2826	PropModeReplace, selection.text, (int)selection.len);	2913	PropModeReplace, ct.value, ct.nitems);
		2914	XFree (ct.value);
2827	}	2915	}
		2916	#endif
2828		2917
2829	selection_time = tm;	2918	selection_time = tm;
2830	D_SELECT ((stderr, "rxvt_selection_make (): selection.len=%d", selection.len));	2919	D_SELECT ((stderr, "rxvt_selection_make (): selection.len=%d", selection.len));
2831	}	2920	}
2832		2921
…		…
2861	rxvt_term::selection_start_colrow (int col, int row)	2950	rxvt_term::selection_start_colrow (int col, int row)
2862	{	2951	{
2863	want_refresh = 1;	2952	want_refresh = 1;
2864	selection.mark.col = col;	2953	selection.mark.col = col;
2865	selection.mark.row = row - TermWin.view_start;	2954	selection.mark.row = row - TermWin.view_start;
		2955
2866	MAX_IT (selection.mark.row, - (int32_t)TermWin.nscrolled);	2956	MAX_IT (selection.mark.row, - (int32_t)TermWin.nscrolled);
2867	MIN_IT (selection.mark.row, (int32_t)TermWin.nrow - 1);	2957	MIN_IT (selection.mark.row, (int32_t)TermWin.nrow - 1);
2868	MAX_IT (selection.mark.col, 0);	2958	MAX_IT (selection.mark.col, 0);
2869	MIN_IT (selection.mark.col, (int32_t)TermWin.ncol - 1);	2959	MIN_IT (selection.mark.col, (int32_t)TermWin.ncol - 1);
2870		2960
		2961	while (selection.mark.col > 0
		2962	&& screen.text[selection.mark.row + TermWin.saveLines][selection.mark.col] == NOCHAR)
		2963	--selection.mark.col;
		2964
2871	if (selection.op)	2965	if (selection.op)
2872	{ /* clear the old selection */	2966	{ /* clear the old selection */
2873	selection.beg.row = selection.end.row = selection.mark.row;	2967	selection.beg.row = selection.end.row = selection.mark.row;
2874	selection.beg.col = selection.end.col = selection.mark.col;	2968	selection.beg.col = selection.end.col = selection.mark.col;
2875	}	2969	}
		2970
2876	selection.op = SELECTION_INIT;	2971	selection.op = SELECTION_INIT;
2877	selection.screen = current_screen;	2972	selection.screen = current_screen;
2878	}	2973	}
2879		2974
2880	/* ------------------------------------------------------------------------- */	2975	/* ------------------------------------------------------------------------- */
…		…
2882	* Word select: select text for 2 clicks	2977	* Word select: select text for 2 clicks
2883	* We now only find out the boundary in one direction	2978	* We now only find out the boundary in one direction
2884	*/	2979	*/
2885		2980
2886	/* what do we want: spaces/tabs are delimiters or cutchars or non-cutchars */	2981	/* what do we want: spaces/tabs are delimiters or cutchars or non-cutchars */
2887	#define DELIMIT_TEXT(x) \	2982	#define DELIMIT_TEXT(x) \
2888	(((x) == ' ' || (x) == '\t') ? 2 : (STRCHR (rs[Rs_cutchars], (x)) != NULL))	2983	(unicode::is_space (x) ? 2 : (x) <= 0xff && !!STRCHR (rs[Rs_cutchars], (x)))
2889	#define DELIMIT_REND(x) 1	2984	#define DELIMIT_REND(x) 1
2890		2985
2891	void	2986	void
2892	rxvt_term::selection_delimit_word (enum page_dirn dirn, const row_col_t *mark, row_col_t *ret)	2987	rxvt_term::selection_delimit_word (enum page_dirn dirn, const row_col_t *mark, row_col_t *ret)
2893	{	2988	{
2894	int col, row, dirnadd, tcol, trow, w1, w2;	2989	int col, row, dirnadd, tcol, trow, w1, w2;
2895	row_col_t bound;	2990	row_col_t bound;
2896	text_t *stp;	2991	text_t *stp;
2897	rend_t *srp;	2992	rend_t *srp;
2898		2993
2899	if (dirn == UP)	2994	if (dirn == UP)
2900	{	2995	{
2901	bound.row = TermWin.saveLines - TermWin.nscrolled - 1;	2996	bound.row = TermWin.saveLines - TermWin.nscrolled - 1;
2902	bound.col = 0;	2997	bound.col = 0;
…		…
2906	{	3001	{
2907	bound.row = TermWin.saveLines + TermWin.nrow;	3002	bound.row = TermWin.saveLines + TermWin.nrow;
2908	bound.col = TermWin.ncol - 1;	3003	bound.col = TermWin.ncol - 1;
2909	dirnadd = 1;	3004	dirnadd = 1;
2910	}	3005	}
		3006
2911	row = mark->row + TermWin.saveLines;	3007	row = mark->row + TermWin.saveLines;
2912	col = mark->col;	3008	col = mark->col;
2913	MAX_IT (col, 0);	3009	MAX_IT (col, 0);
2914	/* find the edge of a word */	3010	/* find the edge of a word */
2915	stp = & (screen.text[row][col]);	3011	stp = & (screen.text[row][col]);
2916	w1 = DELIMIT_TEXT (*stp);	3012	w1 = DELIMIT_TEXT (*stp);
2917		3013
2918	if (selection_style != NEW_SELECT)
2919	{
2920	if (w1 == 1)
2921	{
2922	stp += dirnadd;
2923	if (DELIMIT_TEXT (*stp) == 1)
2924	goto Old_Word_Selection_You_Die;
2925	col += dirnadd;
2926	}
2927	w1 = 0;
2928	}
2929	srp = (&screen.rend[row][col]);	3014	srp = (&screen.rend[row][col]);
2930	w2 = DELIMIT_REND (*srp);	3015	w2 = DELIMIT_REND (*srp);
2931		3016
2932	for (;;)	3017	for (;;)
2933	{	3018	{
2934	for (; col != bound.col; col += dirnadd)	3019	for (; col != bound.col; col += dirnadd)
2935	{	3020	{
2936	stp += dirnadd;	3021	stp += dirnadd;
		3022	srp += dirnadd;
		3023
		3024	if (*stp == NOCHAR)
		3025	continue;
		3026
2937	if (DELIMIT_TEXT (*stp) != w1)	3027	if (DELIMIT_TEXT (*stp) != w1)
2938	break;	3028	break;
2939	srp += dirnadd;
2940	if (DELIMIT_REND (*srp) != w2)	3029	if (DELIMIT_REND (*srp) != w2)
2941	break;	3030	break;
2942	}	3031	}
		3032
2943	if ((col == bound.col) && (row != bound.row))	3033	if ((col == bound.col) && (row != bound.row))
2944	{	3034	{
2945	if (screen.tlen[ (row - (dirn == UP ? 1 : 0))] == -1)	3035	if (screen.tlen[ (row - (dirn == UP ? 1 : 0))] == -1)
2946	{	3036	{
2947	trow = row + dirnadd;	3037	trow = row + dirnadd;
2948	tcol = dirn == UP ? TermWin.ncol - 1 : 0;	3038	tcol = dirn == UP ? TermWin.ncol - 1 : 0;
		3039
2949	if (screen.text[trow] == NULL)	3040	if (screen.text[trow] == NULL)
2950	break;	3041	break;
		3042
2951	stp = & (screen.text[trow][tcol]);	3043	stp = & (screen.text[trow][tcol]);
2952	srp = & (screen.rend[trow][tcol]);	3044	srp = & (screen.rend[trow][tcol]);
		3045
2953	if (DELIMIT_TEXT (*stp) != w1 || DELIMIT_REND (*srp) != w2)	3046	if (DELIMIT_TEXT (*stp) != w1 || DELIMIT_REND (*srp) != w2)
2954	break;	3047	break;
		3048
2955	row = trow;	3049	row = trow;
2956	col = tcol;	3050	col = tcol;
2957	continue;	3051	continue;
2958	}	3052	}
2959	}	3053	}
2960	break;	3054	break;
2961	}	3055	}
		3056
2962	Old_Word_Selection_You_Die:	3057	Old_Word_Selection_You_Die:
2963	D_SELECT ((stderr, "rxvt_selection_delimit_word (%s,...) @ (r:%3d, c:%3d) has boundary (r:%3d, c:%3d)", (dirn == UP ? "up " : "down"), mark->row, mark->col, row - TermWin.saveLines, col));	3058	D_SELECT ((stderr, "rxvt_selection_delimit_word (%s,...) @ (r:%3d, c:%3d) has boundary (r:%3d, c:%3d)", (dirn == UP ? "up " : "down"), mark->row, mark->col, row - TermWin.saveLines, col));
2964		3059
2965	if (dirn == DN)	3060	if (dirn == DN)
2966	col++; /* put us on one past the end */	3061	col++; /* put us on one past the end */
…		…
2988	MAX_IT (row, 0);	3083	MAX_IT (row, 0);
2989	MIN_IT (row, (int)TermWin.nrow - 1);	3084	MIN_IT (row, (int)TermWin.nrow - 1);
2990	MAX_IT (col, 0);	3085	MAX_IT (col, 0);
2991	MIN_IT (col, (int)TermWin.ncol);	3086	MIN_IT (col, (int)TermWin.ncol);
2992		3087
2993	#ifndef NO_NEW_SELECTION
2994	/*	3088	/*
2995	* If we're selecting characters (single click) then we must check first	3089	* If we're selecting characters (single click) then we must check first
2996	* if we are at the same place as the original mark. If we are then	3090	* if we are at the same place as the original mark. If we are then
2997	* select nothing. Otherwise, if we're to the right of the mark, you have to	3091	* select nothing. Otherwise, if we're to the right of the mark, you have to
2998	* be _past_ a character for it to be selected.	3092	* be _past_ a character for it to be selected.
2999	*/	3093	*/
3000	if (selection_style != OLD_SELECT)
3001	{
3002	if (((selection.clicks % 3) == 1) && !flag	3094	if (((selection.clicks % 3) == 1) && !flag
3003	&& (col == selection.mark.col	3095	&& (col == selection.mark.col
3004	&& (row == selection.mark.row + TermWin.view_start)))	3096	&& (row == selection.mark.row + TermWin.view_start)))
3005	{	3097	{
3006	/* select nothing */	3098	/* select nothing */
3007	selection.beg.row = selection.end.row = 0;	3099	selection.beg.row = selection.end.row = 0;
3008	selection.beg.col = selection.end.col = 0;	3100	selection.beg.col = selection.end.col = 0;
3009	selection.clicks = 4;	3101	selection.clicks = 4;
3010	want_refresh = 1;	3102	want_refresh = 1;
3011	D_SELECT ((stderr, "rxvt_selection_extend () selection.clicks = 4"));	3103	D_SELECT ((stderr, "rxvt_selection_extend () selection.clicks = 4"));
3012	return;	3104	return;
3013	}
3014	}	3105	}
3015	#endif	3106
3016	if (selection.clicks == 4)	3107	if (selection.clicks == 4)
3017	selection.clicks = 1;	3108	selection.clicks = 1;
3018		3109
3019	selection_extend_colrow (col, row, !!flag, /* ? button 3 */	3110	selection_extend_colrow (col, row, !!flag, /* ? button 3 */
3020	flag == 1 ? 1 : 0, /* ? button press */	3111	flag == 1 ? 1 : 0, /* ? button press */
…		…
3074	pos.col = col;	3165	pos.col = col;
3075	pos.row = row;	3166	pos.row = row;
3076		3167
3077	pos.row -= TermWin.view_start; /* adjust for scroll */	3168	pos.row -= TermWin.view_start; /* adjust for scroll */
3078		3169
3079	#ifndef NO_OLD_SELECTION
3080	/*
3081	* This mimics some of the selection behaviour of version 2.20 and before.
3082	* There are no ``selection modes'', button3 is always character extension.
3083	* Note: button3 drag is always available, c.f. v2.20
3084	* Selection always terminates (left or right as appropriate) at the mark.
3085	*/
3086	if (selection_style == OLD_SELECT)
3087	{
3088	if (selection.clicks == 1 || button3)
3089	{
3090	if (hate_those_clicks)
3091	{
3092	hate_those_clicks = 0;
3093	if (selection.clicks == 1)
3094	{
3095	selection.beg.row = selection.mark.row;
3096	selection.beg.col = selection.mark.col;
3097	}
3098	else
3099	{
3100	selection.mark.row = selection.beg.row;
3101	selection.mark.col = selection.beg.col;
3102	}
3103	}
3104	if (ROWCOL_IS_BEFORE (pos, selection.mark))
3105	{
3106	selection.end.row = selection.mark.row;
3107	selection.end.col = selection.mark.col + 1;
3108	selection.beg.row = pos.row;
3109	selection.beg.col = pos.col;
3110	}
3111	else
3112	{
3113	selection.beg.row = selection.mark.row;
3114	selection.beg.col = selection.mark.col;
3115	selection.end.row = pos.row;
3116	selection.end.col = pos.col + 1;
3117	}
3118	}
3119	else if (selection.clicks == 2)
3120	{
3121	selection_delimit_word (UP, & (selection.mark),
3122	& (selection.beg));
3123	selection_delimit_word (DN, & (selection.mark),
3124	& (selection.end));
3125	hate_those_clicks = 1;
3126	}
3127	else if (selection.clicks == 3)
3128	{
3129	selection.beg.row = selection.end.row = selection.mark.row;
3130	selection.beg.col = 0;
3131	selection.end.col = ncol;
3132	hate_those_clicks = 1;
3133	}
3134	D_SELECT ((stderr, "rxvt_selection_extend_colrow () EXIT b: (r:%d,c:%d) m: (r:%d,c:%d), e: (r:%d,c:%d)", selection.beg.row, selection.beg.col, selection.mark.row, selection.mark.col, selection.end.row, selection.end.col));
3135	return;
3136	}
3137	#endif /* ! NO_OLD_SELECTION */
3138	#ifndef NO_NEW_SELECTION
3139	/* selection_style must not be OLD_SELECT to get here */
3140	/*	3170	/*
3141	* This is mainly xterm style selection with a couple of differences, mainly	3171	* This is mainly xterm style selection with a couple of differences, mainly
3142	* in the way button3 drag extension works.	3172	* in the way button3 drag extension works.
3143	* We're either doing: button1 drag; button3 press; or button3 drag	3173	* We're either doing: button1 drag; button3 press; or button3 drag
3144	* a) button1 drag : select around a midpoint/word/line - that point/word/line	3174	* a) button1 drag : select around a midpoint/word/line - that point/word/line
…		…
3149	* a point/word/line which is either the start or end of the selection	3179	* a point/word/line which is either the start or end of the selection
3150	* and it was decided by whichever point/word/line was `fixed' at the	3180	* and it was decided by whichever point/word/line was `fixed' at the
3151	* time of the most recent button3 press	3181	* time of the most recent button3 press
3152	*/	3182	*/
3153	if (button3 && buttonpress)	3183	if (button3 && buttonpress)
3154	{ /* button3 press */	3184	{ /* button3 press */
3155	/*	3185	/*
3156	* first determine which edge of the selection we are closest to	3186	* first determine which edge of the selection we are closest to
3157	*/	3187	*/
3158	if (ROWCOL_IS_BEFORE (pos, selection.beg)	3188	if (ROWCOL_IS_BEFORE (pos, selection.beg)
3159	|| (!ROWCOL_IS_AFTER (pos, selection.end)	3189	|| (!ROWCOL_IS_AFTER (pos, selection.end)
3160	&& (((pos.col - selection.beg.col)	3190	&& (((pos.col - selection.beg.col)
3161	+ ((pos.row - selection.beg.row) * ncol))	3191	+ ((pos.row - selection.beg.row) * ncol))
3162	< ((selection.end.col - pos.col)	3192	< ((selection.end.col - pos.col)
3163	+ ((selection.end.row - pos.row) * ncol)))))	3193	+ ((selection.end.row - pos.row) * ncol)))))
3164	closeto = LEFT;	3194	closeto = LEFT;
		3195
3165	if (closeto == LEFT)	3196	if (closeto == LEFT)
3166	{	3197	{
3167	selection.beg.row = pos.row;	3198	selection.beg.row = pos.row;
3168	selection.beg.col = pos.col;	3199	selection.beg.col = pos.col;
3169	selection.mark.row = selection.end.row;	3200	selection.mark.row = selection.end.row;
3170	selection.mark.col = selection.end.col	3201	selection.mark.col = selection.end.col - (selection.clicks == 2);
3171	- (selection.clicks == 2);
3172	}	3202	}
3173	else	3203	else
3174	{	3204	{
3175	selection.end.row = pos.row;	3205	selection.end.row = pos.row;
3176	selection.end.col = pos.col;	3206	selection.end.col = pos.col;
3177	selection.mark.row = selection.beg.row;	3207	selection.mark.row = selection.beg.row;
3178	selection.mark.col = selection.beg.col;	3208	selection.mark.col = selection.beg.col;
3179	}	3209	}
3180	}	3210	}
3181	else	3211	else
3182	{ /* button1 drag or button3 drag */	3212	{ /* button1 drag or button3 drag */
3183	if (ROWCOL_IS_AFTER (selection.mark, pos))	3213	if (ROWCOL_IS_AFTER (selection.mark, pos))
3184	{	3214	{
3185	if ((selection.mark.row == selection.end.row)	3215	if ((selection.mark.row == selection.end.row)
3186	&& (selection.mark.col == selection.end.col)	3216	&& (selection.mark.col == selection.end.col)
3187	&& clickchange && selection.clicks == 2)	3217	&& clickchange && selection.clicks == 2)
3188	selection.mark.col--;	3218	selection.mark.col--;
		3219
3189	selection.beg.row = pos.row;	3220	selection.beg.row = pos.row;
3190	selection.beg.col = pos.col;	3221	selection.beg.col = pos.col;
3191	selection.end.row = selection.mark.row;	3222	selection.end.row = selection.mark.row;
3192	selection.end.col = selection.mark.col	3223	selection.end.col = selection.mark.col + (selection.clicks == 2);
3193	+ (selection.clicks == 2);
3194	}	3224	}
3195	else	3225	else
3196	{	3226	{
3197	selection.beg.row = selection.mark.row;	3227	selection.beg.row = selection.mark.row;
3198	selection.beg.col = selection.mark.col;	3228	selection.beg.col = selection.mark.col;
…		…
3202	}	3232	}
3203		3233
3204	if (selection.clicks == 1)	3234	if (selection.clicks == 1)
3205	{	3235	{
3206	end_col = screen.tlen[selection.beg.row + TermWin.saveLines];	3236	end_col = screen.tlen[selection.beg.row + TermWin.saveLines];
		3237
3207	if (end_col != -1 && selection.beg.col > end_col)	3238	if (end_col != -1 && selection.beg.col > end_col)
3208	{	3239	{
3209	#if 1	3240	#if 1
3210	selection.beg.col = ncol;	3241	selection.beg.col = ncol;
3211	#else	3242	#else
3212	if (selection.beg.row != selection.end.row)	3243	if (selection.beg.row != selection.end.row)
3213	selection.beg.col = ncol;	3244	selection.beg.col = ncol;
3214	else	3245	else
3215	selection.beg.col = selection.mark.col;	3246	selection.beg.col = selection.mark.col;
3216	#endif	3247	#endif
3217
3218	}	3248	}
		3249
3219	end_col = screen.tlen[selection.end.row + TermWin.saveLines];	3250	end_col = screen.tlen[selection.end.row + TermWin.saveLines];
		3251
3220	if (end_col != -1 && selection.end.col > end_col)	3252	if (end_col != -1 && selection.end.col > end_col)
3221	selection.end.col = ncol;	3253	selection.end.col = ncol;
3222
3223	}	3254	}
3224	else if (selection.clicks == 2)	3255	else if (selection.clicks == 2)
3225	{	3256	{
3226	if (ROWCOL_IS_AFTER (selection.end, selection.beg))	3257	if (ROWCOL_IS_AFTER (selection.end, selection.beg))
3227	selection.end.col--;	3258	selection.end.col--;
		3259
3228	selection_delimit_word (UP, & (selection.beg),	3260	selection_delimit_word (UP, & (selection.beg), & (selection.beg));
3229	& (selection.beg));
3230	selection_delimit_word (DN, & (selection.end),	3261	selection_delimit_word (DN, & (selection.end), & (selection.end));
3231	& (selection.end));
3232	}	3262	}
3233	else if (selection.clicks == 3)	3263	else if (selection.clicks == 3)
3234	{	3264	{
3235	#ifndef NO_FRILLS	3265	#ifndef NO_FRILLS
3236	if ((Options & Opt_tripleclickwords))	3266	if ((Options & Opt_tripleclickwords))
3237	{	3267	{
3238	int end_row;	3268	int end_row;
3239		3269
3240	selection_delimit_word (UP, & (selection.beg),	3270	selection_delimit_word (UP, & (selection.beg), & (selection.beg));
3241	& (selection.beg));
3242	end_row = screen.tlen[selection.mark.row	3271	end_row = screen.tlen[selection.mark.row + TermWin.saveLines];
3243	+ TermWin.saveLines];	3272
3244	for (end_row = selection.mark.row; end_row < TermWin.nrow;	3273	for (end_row = selection.mark.row; end_row < TermWin.nrow; end_row++)
3245	end_row++)
3246	{	3274	{
3247	end_col = screen.tlen[end_row + TermWin.saveLines];	3275	end_col = screen.tlen[end_row + TermWin.saveLines];
		3276
3248	if (end_col != -1)	3277	if (end_col != -1)
3249	{	3278	{
3250	selection.end.row = end_row;	3279	selection.end.row = end_row;
3251	selection.end.col = end_col;	3280	selection.end.col = end_col;
3252	selection_remove_trailing_spaces ();	3281	selection_remove_trailing_spaces ();
…		…
3254	}	3283	}
3255	}	3284	}
3256	}	3285	}
3257	else	3286	else
3258	#endif	3287	#endif
3259
3260	{	3288	{
3261	if (ROWCOL_IS_AFTER (selection.mark, selection.beg))	3289	if (ROWCOL_IS_AFTER (selection.mark, selection.beg))
3262	selection.mark.col++;	3290	selection.mark.col++;
3263	selection.beg.col = 0;	3291	selection.beg.col = 0;
3264	selection.end.col = ncol;	3292	selection.end.col = ncol;
3265	}	3293	}
3266	}	3294	}
		3295
3267	if (button3 && buttonpress)	3296	if (button3 && buttonpress)
3268	{ /* mark may need to be changed */	3297	{ /* mark may need to be changed */
3269	if (closeto == LEFT)	3298	if (closeto == LEFT)
3270	{	3299	{
3271	selection.mark.row = selection.end.row;	3300	selection.mark.row = selection.end.row;
3272	selection.mark.col = selection.end.col	3301	selection.mark.col = selection.end.col
3273	- (selection.clicks == 2);	3302	- (selection.clicks == 2);
…		…
3277	selection.mark.row = selection.beg.row;	3306	selection.mark.row = selection.beg.row;
3278	selection.mark.col = selection.beg.col;	3307	selection.mark.col = selection.beg.col;
3279	}	3308	}
3280	}	3309	}
3281	D_SELECT ((stderr, "rxvt_selection_extend_colrow () EXIT b: (r:%d,c:%d) m: (r:%d,c:%d), e: (r:%d,c:%d)", selection.beg.row, selection.beg.col, selection.mark.row, selection.mark.col, selection.end.row, selection.end.col));	3310	D_SELECT ((stderr, "rxvt_selection_extend_colrow () EXIT b: (r:%d,c:%d) m: (r:%d,c:%d), e: (r:%d,c:%d)", selection.beg.row, selection.beg.col, selection.mark.row, selection.mark.col, selection.end.row, selection.end.col));
3282	#endif /* ! NO_NEW_SELECTION */
3283	}	3311	}
3284		3312
3285	#ifndef NO_FRILLS	3313	#ifndef NO_FRILLS
3286	void	3314	void
3287	rxvt_term::selection_remove_trailing_spaces ()	3315	rxvt_term::selection_remove_trailing_spaces ()
…		…
3361	ev.target = rq.target;	3389	ev.target = rq.target;
3362	ev.time = rq.time;	3390	ev.time = rq.time;
3363		3391
3364	if (rq.target == xa[XA_TARGETS])	3392	if (rq.target == xa[XA_TARGETS])
3365	{	3393	{
3366	Atom32 target_list[5];	3394	Atom32 target_list[6];
3367	Atom32 *target = target_list;	3395	Atom32 *target = target_list;
3368		3396
3369	*target++ = (Atom32) xa[XA_TARGETS];	3397	*target++ = (Atom32) xa[XA_TARGETS];
		3398	*target++ = (Atom32) xa[XA_TIMESTAMP];
3370	*target++ = (Atom32) XA_STRING;	3399	*target++ = (Atom32) XA_STRING;
3371	*target++ = (Atom32) xa[XA_TEXT];	3400	*target++ = (Atom32) xa[XA_TEXT];
3372	*target++ = (Atom32) xa[XA_COMPOUND_TEXT];	3401	*target++ = (Atom32) xa[XA_COMPOUND_TEXT];
3373	#if X_HAVE_UTF8_STRING	3402	#if X_HAVE_UTF8_STRING
3374	*target++ = (Atom32) xa[XA_UTF8_STRING];	3403	*target++ = (Atom32) xa[XA_UTF8_STRING];
3375	#endif	3404	#endif
		3405
3376	XChangeProperty (display->display, rq.requestor, rq.property, XA_ATOM,	3406	XChangeProperty (display->display, rq.requestor, rq.property, XA_ATOM,
3377	(8 * sizeof (target_list[0])), PropModeReplace,	3407	(8 * sizeof (target_list[0])), PropModeReplace,
3378	(unsigned char *)target_list,	3408	(unsigned char *)target_list,
3379	target - target_list);	3409	target - target_list);
3380	ev.property = rq.property;	3410	ev.property = rq.property;
3381	}	3411	}
3382	else if (rq.target == xa[XA_MULTIPLE])	3412	else if (rq.target == xa[XA_MULTIPLE])
3383	{	3413	{
3384	/* TODO: Handle MULTIPLE */	3414	/* TODO: Handle MULTIPLE */
3385	}	3415	}
3386	else if (rq.target == xa[XA_TIMESTAMP] && selection.text)	3416	else if (rq.target == xa[XA_TIMESTAMP] && selection.text)
3387	{	3417	{
3388	XChangeProperty (display->display, rq.requestor, rq.property, XA_INTEGER,	3418	XChangeProperty (display->display, rq.requestor, rq.property, XA_INTEGER,
3389	(8 * sizeof (Time)), PropModeReplace,	3419	(8 * sizeof (Time)), PropModeReplace,
3390	(unsigned char *)&selection_time, 1);	3420	(unsigned char *)&selection_time, 1);
3391	ev.property = rq.property;	3421	ev.property = rq.property;
3392	}	3422	}
3393	else if (rq.target == XA_STRING	3423	else if (rq.target == XA_STRING
3394	|| rq.target == xa[XA_TEXT]	3424	|| rq.target == xa[XA_TEXT]
3395	|| rq.target == xa[XA_COMPOUND_TEXT]	3425	|| rq.target == xa[XA_COMPOUND_TEXT]
3396	|| rq.target == xa[XA_UTF8_STRING]	3426	|| rq.target == xa[XA_UTF8_STRING]
3397	)	3427	)
3398	{	3428	{
3399	short freect = 0;	3429	short freect = 0;
3400	int selectlen;	3430	int selectlen;
3401	char *cl;	3431	wchar_t *cl;
3402		3432
3403	target = rq.target;	3433	target = rq.target;
3404		3434
3405	if (target == XA_STRING)	3435	if (target == XA_STRING)
3406	// we actually don't do XA_STRING, but who cares, as i18n clients	3436	// we actually don't do XA_STRING, but who cares, as i18n clients
3407	// will ask for another format anyways.	3437	// will ask for another format anyways.
3408	style = XStringStyle;	3438	style = XStringStyle;
3409	else if (target == xa[XA_TEXT])	3439	else if (target == xa[XA_TEXT])
3410	style = XTextStyle;	3440	style = XStdICCTextStyle;
3411	else if (target == xa[XA_COMPOUND_TEXT])	3441	else if (target == xa[XA_COMPOUND_TEXT])
3412	style = XCompoundTextStyle;	3442	style = XCompoundTextStyle;
3413	#if X_HAVE_UTF8_STRING	3443	#if X_HAVE_UTF8_STRING
3414	else if (target == xa[XA_UTF8_STRING])	3444	else if (target == xa[XA_UTF8_STRING])
3415	style = XUTF8StringStyle;	3445	style = XUTF8StringStyle;
…		…
3420	style = XCompoundTextStyle;	3450	style = XCompoundTextStyle;
3421	}	3451	}
3422		3452
3423	if (selection.text)	3453	if (selection.text)
3424	{	3454	{
3425	cl = (char *)selection.text;	3455	cl = selection.text;
3426	selectlen = selection.len;	3456	selectlen = selection.len;
3427	}	3457	}
3428	else	3458	else
3429	{	3459	{
3430	cl = "";	3460	cl = L"";
3431	selectlen = 0;	3461	selectlen = 0;
3432	}	3462	}
3433		3463
		3464	// Xwc doesn't handle iso-10646 in wchar_t gracefully, so maybe recode it
		3465	// manually for XUTF8StringStyle.
3434	if (XmbTextListToTextProperty (display->display, &cl, 1, style, &ct) >= 0)	3466	if (XwcTextListToTextProperty (display->display, &cl, 1, style, &ct) >= 0)
3435	freect = 1;	3467	freect = 1;
3436	else	3468	else
3437	{	3469	{
3438	/* if we failed to convert then send it raw */	3470	/* if we failed to convert then send it raw */
3439	ct.value = (unsigned char *)cl;	3471	ct.value = (unsigned char *)cl;
…		…
3446	ev.property = rq.property;	3478	ev.property = rq.property;
3447		3479
3448	if (freect)	3480	if (freect)
3449	XFree (ct.value);	3481	XFree (ct.value);
3450	}	3482	}
		3483
3451	XSendEvent (display->display, rq.requestor, False, 0L, (XEvent *)&ev);	3484	XSendEvent (display->display, rq.requestor, False, 0L, (XEvent *)&ev);
3452	}	3485	}
3453		3486
3454	/* ------------------------------------------------------------------------- *	3487	/* ------------------------------------------------------------------------- *
3455	* MOUSE ROUTINES *	3488	* MOUSE ROUTINES *

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines