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.30 by pcg, Fri Feb 13 12:16:21 2004 UTC vs.
Revision 1.59 by pcg, Mon Mar 15 00:08:11 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;
…		…
485	prev_nrow = prev_ncol = 0;	487	prev_nrow = prev_ncol = 0;
486	scr_reset ();	488	scr_reset ();
487		489
488	scr_clear ();	490	scr_clear ();
489	scr_refresh (SLOW_REFRESH);	491	scr_refresh (SLOW_REFRESH);
490	#ifdef RXVT_GRAPHICS
491	Gr_reset ();
492	#endif
493	}	492	}
494		493
495	/* ------------------------------------------------------------------------- *	494	/* ------------------------------------------------------------------------- *
496	* PROCESS SCREEN COMMANDS *	495	* PROCESS SCREEN COMMANDS *
497	* ------------------------------------------------------------------------- */	496	* ------------------------------------------------------------------------- */
…		…
593	# endif	592	# endif
594	SWAP_IT (screen.charset, swap.charset, int16_t);	593	SWAP_IT (screen.charset, swap.charset, int16_t);
595	SWAP_IT (screen.flags, swap.flags, int);	594	SWAP_IT (screen.flags, swap.flags, int);
596	screen.flags |= Screen_VisibleCursor;	595	screen.flags |= Screen_VisibleCursor;
597	swap.flags |= Screen_VisibleCursor;	596	swap.flags |= Screen_VisibleCursor;
598
599	# ifdef RXVT_GRAPHICS
600
601	if (Gr_Displayed ())
602	{
603	Gr_scroll (0);
604	Gr_ChangeScreen ();
605	}
606	# endif
607	#else	597	#else
608	# ifdef SCROLL_ON_NO_SECONDARY	598	# ifdef SCROLL_ON_NO_SECONDARY
609	# ifdef RXVT_GRAPHICS
610	if (Gr_Displayed ())
611	Gr_ClearScreen ();
612	# endif
613	if (current_screen == PRIMARY	599	if (current_screen == PRIMARY)
614	# ifdef RXVT_GRAPHICS
615	&& !Gr_Displayed ()
616	# endif
617	)
618	scr_scroll_text (0, (prev_nrow - 1), prev_nrow, 0);	600	scr_scroll_text (0, (prev_nrow - 1), prev_nrow, 0);
619	# endif	601	# endif
620	#endif	602	#endif
621	return scrn;	603	return scrn;
622	}	604	}
…		…
772	if (!spec) /* line length may not equal TermWin.ncol */	754	if (!spec) /* line length may not equal TermWin.ncol */
773	scr_blank_screen_mem (screen.text, screen.rend,	755	scr_blank_screen_mem (screen.text, screen.rend,
774	(unsigned int)j, rstyle);	756	(unsigned int)j, rstyle);
775	}	757	}
776		758
777	#ifdef RXVT_GRAPHICS
778	if (Gr_Displayed ())
779	Gr_scroll (count);
780	#endif
781
782	return count;	759	return count;
783	}	760	}
784		761
785	/* ------------------------------------------------------------------------- */	762	/* ------------------------------------------------------------------------- */
786	/*	763	/*
787	* Add text given in <str> of length <len> to screen struct	764	* Add text given in <str> of length <len> to screen struct
788	*/	765	*/
789	void	766	void
790	rxvt_term::scr_add_lines (const uint32_t *str, int nlines, int len)	767	rxvt_term::scr_add_lines (const unicode_t *str, int nlines, int len)
791	{	768	{
792	unsigned char checksel, clearsel;	769	unsigned char checksel, clearsel;
793	uint32_t c;	770	unicode_t c;
794	int i, row, last_col;	771	int i, row, last_col;
795	text_t *stp;	772	text_t *stp;
796	rend_t *srp;	773	rend_t *srp;
797		774
798	if (len <= 0) /* sanity */	775	if (len <= 0) /* sanity */
799	return;	776	return;
800		777
801	want_refresh = 1;	778	want_refresh = 1;
…		…
869	&& ROWCOL_IS_BEFORE (screen.cur, selection.end))	846	&& ROWCOL_IS_BEFORE (screen.cur, selection.end))
870	{	847	{
871	checksel = 0;	848	checksel = 0;
872	clearsel = 1;	849	clearsel = 1;
873	}	850	}
		851
874	if (screen.flags & Screen_WrapNext)	852	if (screen.flags & Screen_WrapNext)
875	{	853	{
876	screen.tlen[row] = -1;	854	screen.tlen[row] = -1;
877	if (screen.cur.row == screen.bscroll)	855	if (screen.cur.row == screen.bscroll)
878	scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);	856	scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);
879	else if (screen.cur.row < (TermWin.nrow - 1))	857	else if (screen.cur.row < (TermWin.nrow - 1))
880	row = (++screen.cur.row) + TermWin.saveLines;	858	row = (++screen.cur.row) + TermWin.saveLines;
		859
881	stp = screen.text[row]; /* _must_ refresh */	860	stp = screen.text[row]; /* _must_ refresh */
882	srp = screen.rend[row]; /* _must_ refresh */	861	srp = screen.rend[row]; /* _must_ refresh */
883	screen.cur.col = 0;	862	screen.cur.col = 0;
884	screen.flags &= ~Screen_WrapNext;	863	screen.flags &= ~Screen_WrapNext;
885	}	864	}
		865
886	if (screen.flags & Screen_Insert)	866	if (screen.flags & Screen_Insert)
887	scr_insdel_chars (1, INSERT);	867	scr_insdel_chars (1, INSERT);
		868
		869	// rely on wcwidth to tell us the character width, at least for non-latin1
		870	// do wcwidth before further replacements, as wcwidth says that line-drawing
		871	// characters have width -1 (DOH!) on gnu/linux sometimes.
		872	int width = c < 256 ? 1 : wcwidth (c);
888		873
889	if (charsets[screen.charset] == '0') // DEC SPECIAL	874	if (charsets[screen.charset] == '0') // DEC SPECIAL
890	switch (c)	875	switch (c)
891	{	876	{
892	case '+': c = 0x2192; break; case ',': c = 0x2190; break; case '-': c = 0x2191; break;	877	// vt100 special graphics and line drawing
893	case '.': c = 0x2193; break; case '0': c = 0x25ae; break; case '`': c = 0x25c6; break;	878	case '`': c = 0x25c6; break; case '_': c = 0x0020; break;
894	case 'a': c = 0x2592; break; case 'f': c = 0x00b0; break; case 'g': c = 0x00b1; break;	879	case 'a': c = 0x2592; break; case 'b': c = 0x2409; break; case 'c': c = 0x240c; break;
895	case 'h': c = 0x2592; break; case 'i': c = 0x2603; break; case 'j': c = 0x2518; break;
896	case 'k': c = 0x2510; break; case 'l': c = 0x250c; break; case 'm': c = 0x2514; break;	880	case 'd': c = 0x240d; break; case 'e': c = 0x240a; break; case 'f': c = 0x00b0; break;
		881	case 'g': c = 0x00b1; break; case 'h': c = 0x2424; break; case 'i': c = 0x240b; break;
897	case 'n': c = 0x253c; break; case 'o': c = 0x23ba; break; case 'p': c = 0x23bb; break;	882	case 'j': c = 0x2518; break; case 'k': c = 0x2510; break; case 'l': c = 0x250c; break;
898	case 'q': c = 0x2500; break; case 'r': c = 0x23bc; break; case 's': c = 0x23bd; break;	883	case 'm': c = 0x2514; break; case 'n': c = 0x253c; break; case 'o': c = 0x23ba; break;
899	case 't': c = 0x251c; break; case 'u': c = 0x2524; break; case 'v': c = 0x2534; break;	884	case 'p': c = 0x23bb; break; case 'q': c = 0x2500; break; case 'r': c = 0x23bc; break;
900	case 'w': c = 0x252c; break; case 'x': c = 0x2502; break; case 'y': c = 0x2264; break;	885	case 's': c = 0x23bd; break; case 't': c = 0x251c; break; case 'u': c = 0x2524; break;
901	case 'z': c = 0x2265; break; case '{': c = 0x03c0; break; case '|': c = 0x2260; break;	886	case 'v': c = 0x2534; break; case 'w': c = 0x252c; break; case 'x': c = 0x2502; break;
		887	case 'y': c = 0x2264; break; case 'z': c = 0x2265; break; case '{': c = 0x03c0; break;
902	case '}': c = 0x00a3; break; case '~': c = 0x00b7; break;	888	case '|': c = 0x2260; break; case '}': c = 0x00a3; break; case '~': c = 0x00b7; break;
903	}	889	}
904		890
905	rend_t rend = SET_FONT (rstyle, TermWin.fontset->find_font (c));
906	// rely on wcwidth to tell us the character width, at least for non-ascii
907	int width = c <= 128 ? 1 : wcwidth (c);
908
909	// width -1 characters (e.g. combining chars) are ignored currently.
910	if (width > 0)	891	if (width > 0)
		892	{
		893	#if !UNICODE_3 && ENABLE_COMBINING
		894	// trim characters we can't store directly :(
		895	if (c >= 0x10000)
		896	c = rxvt_composite.compose (c); // map to lower 16 bits
		897	#endif
		898	rend_t rend = SET_FONT (rstyle, TermWin.fontset->find_font (c));
		899
911	do	900	do
912	{	901	{
913	stp[screen.cur.col] = c;	902	stp[screen.cur.col] = c;
914	srp[screen.cur.col] = rend;	903	srp[screen.cur.col] = rend;
915		904
916	if (screen.cur.col < last_col - 1)	905	if (screen.cur.col < last_col - 1)
917	screen.cur.col++;	906	screen.cur.col++;
918	else	907	else
919	{	908	{
920	screen.tlen[row] = last_col;	909	screen.tlen[row] = last_col;
921	if (screen.flags & Screen_Autowrap)	910	if (screen.flags & Screen_Autowrap)
922	screen.flags |= Screen_WrapNext;	911	screen.flags |= Screen_WrapNext;
923	break;	912	break;
924	}	913	}
925		914
926	c = NOCHAR;	915	c = NOCHAR;
927	}	916	}
928	while (--width > 0);	917	while (--width > 0);
		918
		919	// pad with spaces when overwriting wide character with smaller one
		920	for (int c = screen.cur.col; c < last_col && stp[c] == NOCHAR; c++)
		921	{
		922	stp[c] = ' ';
		923	srp[c] = rend;
		924	}
		925	}
		926	else if (width == 0)
		927	{
		928	#if ENABLE_COMBINING
		929	// handle combining characters
		930	// we just tag the accent on the previous on-screen character.
		931	// this is arguably not correct, but also arguably not wrong.
		932	// we don't handle double-width characters nicely yet.
		933
		934	text_t *tp;
		935	rend_t *rp;
		936
		937	if (screen.cur.col > 0)
		938	{
		939	tp = stp + screen.cur.col - 1;
		940	rp = srp + screen.cur.col - 1;
		941	}
		942	else if (screen.cur.row > 0
		943	&& screen.tlen [screen.cur.row - 1 + TermWin.saveLines] == -1)
		944	{
		945	tp = screen.text[screen.cur.row - 1 + TermWin.saveLines] + last_col - 1;
		946	rp = screen.rend[screen.cur.row - 1 + TermWin.saveLines] + last_col - 1;
		947	}
929	else	948	else
930	(void)0; /* handle combining character etc. here. */	949	continue;
		950
		951	// handle double-width-chars by making them look extremely ugly
		952	if (*tp == NOCHAR)
		953	*tp = ' '; // hack //D //TODO //--tp, --rp;
		954
		955	// first try to find a precomposed character
		956	unicode_t n = rxvt_compose (*tp, c);
		957	if (n == NOCHAR)
		958	n = rxvt_composite.compose (*tp, c);
		959
		960	*tp = n;
		961	*rp = SET_FONT (*rp, TermWin.fontset->find_font (*tp));
		962	#endif
		963	}
931	}	964	}
932		965
933	if (screen.tlen[row] != -1) /* XXX: think about this */	966	if (screen.tlen[row] != -1) /* XXX: think about this */
934	MAX_IT (screen.tlen[row], screen.cur.col);	967	MAX_IT (screen.tlen[row], screen.cur.col);
935		968
…		…
1075	void	1108	void
1076	rxvt_term::scr_gotorc (int row, int col, int relative)	1109	rxvt_term::scr_gotorc (int row, int col, int relative)
1077	{	1110	{
1078	want_refresh = 1;	1111	want_refresh = 1;
1079	ZERO_SCROLLBACK ();	1112	ZERO_SCROLLBACK ();
1080	#ifdef RXVT_GRAPHICS
1081	if (Gr_Displayed ())
1082	Gr_scroll (0);
1083	#endif
1084		1113
1085	D_SCREEN ((stderr, "rxvt_scr_gotorc (r:%s%d,c:%s%d): from (r:%d,c:%d)", (relative & R_RELATIVE ? "+" : ""), row, (relative & C_RELATIVE ? "+" : ""), col, screen.cur.row, screen.cur.col));	1114	D_SCREEN ((stderr, "rxvt_scr_gotorc (r:%s%d,c:%s%d): from (r:%d,c:%d)", (relative & R_RELATIVE ? "+" : ""), row, (relative & C_RELATIVE ? "+" : ""), col, screen.cur.row, screen.cur.col));
1086		1115
1087	screen.cur.col = ((relative & C_RELATIVE) ? (screen.cur.col + col)	1116	screen.cur.col = ((relative & C_RELATIVE) ? (screen.cur.col + col)
1088	: col);	1117	: col);
…		…
1119	else	1148	else
1120	screen.cur.row = row;	1149	screen.cur.row = row;
1121	}	1150	}
1122	MAX_IT (screen.cur.row, 0);	1151	MAX_IT (screen.cur.row, 0);
1123	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--;
1124	}	1157	}
1125		1158
1126	/* ------------------------------------------------------------------------- */	1159	/* ------------------------------------------------------------------------- */
1127	/*	1160	/*
1128	* direction should be UP or DN	1161	* direction should be UP or DN
…		…
1135	want_refresh = 1;	1168	want_refresh = 1;
1136	dirn = ((direction == UP) ? 1 : -1);	1169	dirn = ((direction == UP) ? 1 : -1);
1137	D_SCREEN ((stderr, "rxvt_scr_index (%d)", dirn));	1170	D_SCREEN ((stderr, "rxvt_scr_index (%d)", dirn));
1138		1171
1139	ZERO_SCROLLBACK ();	1172	ZERO_SCROLLBACK ();
1140
1141	#ifdef RXVT_GRAPHICS
1142	if (Gr_Displayed ())
1143	Gr_scroll (0);
1144	#endif
1145		1173
1146	screen.flags &= ~Screen_WrapNext;	1174	screen.flags &= ~Screen_WrapNext;
1147	if ((screen.cur.row == screen.bscroll && direction == UP)	1175	if ((screen.cur.row == screen.bscroll && direction == UP)
1148	|| (screen.cur.row == screen.tscroll && direction == DN))	1176	|| (screen.cur.row == screen.tscroll && direction == DN))
1149	scr_scroll_text (screen.tscroll, screen.bscroll, dirn, 0);	1177	scr_scroll_text (screen.tscroll, screen.bscroll, dirn, 0);
…		…
1167	unsigned int row, col, num;	1195	unsigned int row, col, num;
1168		1196
1169	want_refresh = 1;	1197	want_refresh = 1;
1170	D_SCREEN ((stderr, "rxvt_scr_erase_line (%d) at screen row: %d", mode, screen.cur.row));	1198	D_SCREEN ((stderr, "rxvt_scr_erase_line (%d) at screen row: %d", mode, screen.cur.row));
1171	ZERO_SCROLLBACK ();	1199	ZERO_SCROLLBACK ();
1172
1173	#ifdef RXVT_GRAPHICS
1174	if (Gr_Displayed ())
1175	Gr_scroll (0);
1176	#endif
1177		1200
1178	selection_check (1);	1201	selection_check (1);
1179		1202
1180	screen.flags &= ~Screen_WrapNext;	1203	screen.flags &= ~Screen_WrapNext;
1181		1204
…		…
1250	row = 0;	1273	row = 0;
1251	num = screen.cur.row;	1274	num = screen.cur.row;
1252	break;	1275	break;
1253	case 2: /* erase whole screen */	1276	case 2: /* erase whole screen */
1254	selection_check (3);	1277	selection_check (3);
1255	#ifdef RXVT_GRAPHICS
1256	Gr_ClearScreen ();
1257	#endif
1258	row = 0;	1278	row = 0;
1259	num = TermWin.nrow;	1279	num = TermWin.nrow;
1260	break;	1280	break;
1261	default:	1281	default:
1262	return;	1282	return;
…		…
1331	{	1351	{
1332	int end;	1352	int end;
1333		1353
1334	ZERO_SCROLLBACK ();	1354	ZERO_SCROLLBACK ();
1335		1355
1336	#ifdef RXVT_GRAPHICS
1337	if (Gr_Displayed ())
1338	Gr_scroll (0);
1339	#endif
1340
1341	selection_check (1);	1356	selection_check (1);
1342		1357
1343	if (screen.cur.row > screen.bscroll)	1358	if (screen.cur.row > screen.bscroll)
1344	return;	1359	return;
1345		1360
…		…
1369	rend_t *srp;	1384	rend_t *srp;
1370	int16_t *slp;	1385	int16_t *slp;
1371		1386
1372	want_refresh = 1;	1387	want_refresh = 1;
1373	ZERO_SCROLLBACK ();	1388	ZERO_SCROLLBACK ();
1374
1375	#ifdef RXVT_GRAPHICS
1376	if (Gr_Displayed ())
1377	Gr_scroll (0);
1378	#endif
1379		1389
1380	if (count <= 0)	1390	if (count <= 0)
1381	return;	1391	return;
1382		1392
1383	selection_check (1);	1393	selection_check (1);
…		…
1808	rxvt_term::scr_changeview (uint16_t oldviewstart)	1818	rxvt_term::scr_changeview (uint16_t oldviewstart)
1809	{	1819	{
1810	if (TermWin.view_start != oldviewstart)	1820	if (TermWin.view_start != oldviewstart)
1811	{	1821	{
1812	want_refresh = 1;	1822	want_refresh = 1;
1813	#ifdef RXVT_GRAPHICS
1814	if (Gr_Displayed ())
1815	Gr_scroll (0);
1816	#endif
1817	num_scr -= (TermWin.view_start - oldviewstart);	1823	num_scr -= (TermWin.view_start - oldviewstart);
1818	}	1824	}
1819	return (int) (TermWin.view_start - oldviewstart);	1825	return (int) (TermWin.view_start - oldviewstart);
1820	}	1826	}
1821		1827
…		…
1891	((Y) >= (X)->min_char_or_byte2 && (Y) <= (X)->max_char_or_byte2)	1897	((Y) >= (X)->min_char_or_byte2 && (Y) <= (X)->max_char_or_byte2)
1892		1898
1893	void	1899	void
1894	rxvt_term::scr_refresh (unsigned char refresh_type)	1900	rxvt_term::scr_refresh (unsigned char refresh_type)
1895	{	1901	{
1896	unsigned char clearfirst, /* first character writes before cell */	1902	unsigned char clearfirst, /* first character writes before cell */
1897	clearlast, /* last character writes beyond cell */	1903	clearlast, /* last character writes beyond cell */
1898	must_clear, /* use draw_string not draw_image_string */	1904	must_clear, /* use draw_string not draw_image_string */
1899	rvid, /* reverse video this position */	1905	rvid, /* reverse video this position */
1900	showcursor; /* show the cursor */	1906	showcursor; /* show the cursor */
1901	int16_t col, row, /* column/row we're processing */	1907	int16_t col, row, /* column/row we're processing */
1902	ocrow; /* old cursor row */	1908	ocrow; /* old cursor row */
1903	int cursorwidth;
1904	int i, /* tmp */	1909	int i, /* tmp */
1905	row_offset; /* basic offset in screen structure */	1910	row_offset; /* basic offset in screen structure */
1906	#ifndef NO_CURSORCOLOR	1911	#ifndef NO_CURSORCOLOR
1907	rend_t cc1; /* store colours at cursor position (s) */	1912	rend_t cc1; /* store colours at cursor position (s) */
1908	#endif	1913	#endif
1909	rend_t *drp, *srp; /* drawn-rend-pointer, screen-rend-pointer */	1914	rend_t *drp, *srp; /* drawn-rend-pointer, screen-rend-pointer */
1910	text_t *dtp, *stp; /* drawn-text-pointer, screen-text-pointer */	1915	text_t *dtp, *stp; /* drawn-text-pointer, screen-text-pointer */
1911		1916
1912	if (refresh_type == NO_REFRESH || !TermWin.mapped)	1917	if (refresh_type == NO_REFRESH || !TermWin.mapped)
1913	return;	1918	return;
1914		1919
1915	/*	1920	/*
…		…
1947	unsigned char setoldcursor;	1952	unsigned char setoldcursor;
1948	rend_t ccol1, /* Cursor colour */	1953	rend_t ccol1, /* Cursor colour */
1949	ccol2; /* Cursor colour2 */	1954	ccol2; /* Cursor colour2 */
1950		1955
1951	showcursor = (screen.flags & Screen_VisibleCursor);	1956	showcursor = (screen.flags & Screen_VisibleCursor);
1952	cursorwidth = 0;
1953	#ifdef CURSOR_BLINK	1957	#ifdef CURSOR_BLINK
1954	if (hidden_cursor)	1958	if (hidden_cursor)
1955	showcursor = 0;	1959	showcursor = 0;
1956	#endif	1960	#endif
1957		1961
1958	cursorwidth = 0;
1959
1960	if (showcursor)	1962	if (showcursor)
1961	{	1963	{
1962	cursorwidth++;
1963
1964	srp = & (screen.rend[screen.cur.row + TermWin.saveLines]	1964	srp = & (screen.rend[screen.cur.row + TermWin.saveLines]
1965	[screen.cur.col]);	1965	[screen.cur.col]);
1966		1966
1967	if (showcursor && TermWin.focus)	1967	if (showcursor && TermWin.focus)
1968	{	1968	{
…		…
1986	ccol2 = Color_bg;	1986	ccol2 = Color_bg;
1987	#endif	1987	#endif
1988	*srp = SET_FGCOLOR (*srp, ccol1);	1988	*srp = SET_FGCOLOR (*srp, ccol1);
1989	*srp = SET_BGCOLOR (*srp, ccol2);	1989	*srp = SET_BGCOLOR (*srp, ccol2);
1990	#endif	1990	#endif
1991
1992	}	1991	}
1993	}	1992	}
1994		1993
1995	/* make sure no outline cursor is left around */	1994	/* make sure no outline cursor is left around */
1996	setoldcursor = 0;	1995	setoldcursor = 0;
…		…
2109	int ypixel = (int)Row2Pixel (row);	2108	int ypixel = (int)Row2Pixel (row);
2110		2109
2111	for (col = 0; col < TermWin.ncol; col++)	2110	for (col = 0; col < TermWin.ncol; col++)
2112	{	2111	{
2113	/* compare new text with old - if exactly the same then continue */	2112	/* compare new text with old - if exactly the same then continue */
		2113	if (stp[col] == dtp[col] /* Must match characters to skip. */
		2114	&& (srp[col] == drp[col] /* Either rendition the same or */
		2115	|| (stp[col] == ' ' /* space w/ no background change */
		2116	&& GET_BGATTR (srp[col]) == GET_BGATTR (drp[col]))))
		2117	continue;
		2118
		2119	// redraw one or more characters
		2120
		2121	// seek to the beginning if wide characters
		2122	while (stp[col] == NOCHAR && col > 0)
		2123	--col;
		2124
2114	rend_t rend = srp[col]; /* screen rendition (target rendtion) */	2125	rend_t rend = srp[col]; /* screen rendition (target rendtion) */
2115
2116	if (stp[col] == dtp[col] /* Must match characters to skip. */
2117	&& (rend == drp[col] /* Either rendition the same or */
2118	|| (stp[col] == ' ' /* space w/ no background change */
2119	&& GET_BGATTR (rend) == GET_BGATTR (drp[col]))))
2120	continue;
2121
2122	text_t *text = stp + col;	2126	text_t *text = stp + col;
2123	int count = 1;	2127	int count = 1;
2124		2128
2125	/* redraw one or more characters */
2126
2127	dtp[col] = stp[col];	2129	dtp[col] = stp[col];
2128	drp[col] = rend;	2130	drp[col] = rend;
2129
2130	if (*text == NOCHAR) // never start redrawing at invisible characters. */
2131	continue;
2132		2131
2133	int xpixel = Col2Pixel (col);	2132	int xpixel = Col2Pixel (col);
2134		2133
2135	// this loop looks very messy, it can probably be optimized	2134	// this loop looks very messy, it can probably be optimized
2136	// and cleaned a bit by you?	2135	// and cleaned a bit by you?
…		…
2177	int fore = GET_FGCOLOR (rend); // desired foreground	2176	int fore = GET_FGCOLOR (rend); // desired foreground
2178	int back = GET_BGCOLOR (rend); // desired background	2177	int back = GET_BGCOLOR (rend); // desired background
2179		2178
2180	rend = GET_ATTR (rend);	2179	rend = GET_ATTR (rend);
2181		2180
2182	rvid = !! (rend & RS_RVid);	2181	rvid = !!(rend & RS_RVid);
		2182
		2183	#ifndef NO_BOLD_UNDERLINE_REVERSE
		2184	if (rend & RS_Bold && fore == Color_fg)
		2185	{
		2186	if (ISSET_PIXCOLOR (Color_BD))
		2187	fore = Color_BD;
		2188	else
		2189	rvid = !rvid;
		2190	}
		2191
		2192	if (rend & RS_Uline)
		2193	if (ISSET_PIXCOLOR (Color_UL))
		2194	fore = Color_UL;
		2195	#endif
		2196
2183	if (rvid)	2197	if (rvid)
2184	{	2198	{
2185	SWAP_IT (fore, back, int);	2199	SWAP_IT (fore, back, int);
2186		2200
2187	#ifndef NO_BOLD_UNDERLINE_REVERSE	2201	#ifndef NO_BOLD_UNDERLINE_REVERSE
…		…
2190	&& !ISSET_PIXCOLOR (Color_cursor)	2204	&& !ISSET_PIXCOLOR (Color_cursor)
2191	# endif	2205	# endif
2192	)	2206	)
2193	back = Color_RV;	2207	back = Color_RV;
2194	#endif	2208	#endif
2195
2196	}	2209	}
		2210
2197	#ifdef TEXT_BLINK	2211	#ifdef TEXT_BLINK
2198	if (rend & RS_Blink)	2212	if (rend & RS_Blink && back == Color_bg)
2199	{	2213	{
2200	if (!text_blink_ev.active)	2214	if (!text_blink_ev.active)
2201	{	2215	{
2202	text_blink_ev.start (NOW + TEXT_BLINK_INTERVAL);	2216	text_blink_ev.start (NOW + TEXT_BLINK_INTERVAL);
2203	hidden_text = 0;	2217	hidden_text = 0;
2204	}	2218	}
2205	else if (hidden_text)	2219	else if (hidden_text)
2206	fore = back;	2220	fore = back;
2207	}	2221	}
2208	#endif	2222	#endif
2209	#ifndef NO_BOLD_UNDERLINE_REVERSE
2210	else if (rend & RS_Bold)
2211	{
2212	if (ISSET_PIXCOLOR (Color_BD))
2213	fore = Color_BD;
2214	else if (fore == Color_fg)
2215	fore = Color_White;
2216	}
2217	else if (rend & RS_Uline)
2218	{
2219	if (ISSET_PIXCOLOR (Color_UL))
2220	fore = Color_UL;
2221	}
2222	#endif
2223		2223
2224	/*	2224	/*
2225	* Actually do the drawing of the string here	2225	* Actually do the drawing of the string here
2226	*/	2226	*/
2227	rxvt_font *font = (*TermWin.fontset)[fid];	2227	rxvt_font *font = (*TermWin.fontset)[fid];
2228		2228
2229	if (back == fore)	2229	if (back == fore)
2230	font->clear_rect (xpixel, ypixel,	2230	font->clear_rect (*TermWin.drawable, xpixel, ypixel,
2231	TermWin.fwidth * count, TermWin.fheight,	2231	TermWin.fwidth * count, TermWin.fheight,
2232	back);	2232	back);
2233	else if (back == Color_bg)	2233	else if (back == Color_bg)
2234	{	2234	{
2235	if (must_clear)	2235	if (must_clear)
…		…
2237	CLEAR_CHARS (xpixel, ypixel, count);	2237	CLEAR_CHARS (xpixel, ypixel, count);
2238		2238
2239	for (i = 0; i < count; i++) /* don't draw empty strings */	2239	for (i = 0; i < count; i++) /* don't draw empty strings */
2240	if (text[i] != ' ')	2240	if (text[i] != ' ')
2241	{	2241	{
2242	font->draw (xpixel, ypixel, text, count, fore, -1);	2242	font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, -1);
2243	break;	2243	break;
2244	}	2244	}
2245	}	2245	}
2246	else	2246	else
2247	font->draw (xpixel, ypixel, text, count, fore, Color_bg);	2247	font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, Color_bg);
2248	}	2248	}
2249	else	2249	else
2250	font->draw (xpixel, ypixel, text, count, fore, back);	2250	font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, back);
2251		2251
2252	if ((rend & RS_Uline) && (font->descent > 1))	2252	if ((rend & RS_Uline) && (font->descent > 1))
2253	XDrawLine (display->display, drawBuffer, TermWin.gc,	2253	XDrawLine (display->display, drawBuffer, TermWin.gc,
2254	xpixel, ypixel + font->ascent + 1,	2254	xpixel, ypixel + font->ascent + 1,
2255	xpixel + Width2Pixel (count) - 1, ypixel + font->ascent + 1);	2255	xpixel + Width2Pixel (count) - 1, ypixel + font->ascent + 1);
2256	} /* for (col....) */	2256	} /* for (col....) */
2257	} /* for (row....) */	2257	} /* for (row....) */
2258		2258
2259	/*	2259	/*
2260	* G: cleanup cursor and display outline cursor if necessary	2260	* G: cleanup cursor and display outline cursor if necessary
…		…
2267	[screen.cur.col]);	2267	[screen.cur.col]);
2268	*srp ^= RS_RVid;	2268	*srp ^= RS_RVid;
2269	#ifndef NO_CURSORCOLOR	2269	#ifndef NO_CURSORCOLOR
2270	*srp = (*srp & ~ (RS_fgMask | RS_bgMask)) | cc1;	2270	*srp = (*srp & ~ (RS_fgMask | RS_bgMask)) | cc1;
2271	#endif	2271	#endif
2272
2273	}	2272	}
2274	else if (oldcursor.row >= 0)	2273	else if (oldcursor.row >= 0)
2275	{	2274	{
2276	#ifndef NO_CURSORCOLOR	2275	#ifndef NO_CURSORCOLOR
2277	if (ISSET_PIXCOLOR (Color_cursor))	2276	if (ISSET_PIXCOLOR (Color_cursor))
2278	XSetForeground (display->display, TermWin.gc, PixColors[Color_cursor]);	2277	XSetForeground (display->display, TermWin.gc, PixColors[Color_cursor]);
2279	#endif	2278	#endif
		2279	int cursorwidth = 1;
		2280	while (oldcursor.col + cursorwidth < TermWin.ncol
		2281	&& drawn_text[oldcursor.row][oldcursor.col + cursorwidth] == NOCHAR)
		2282	cursorwidth++;
		2283
2280	XDrawRectangle (display->display, drawBuffer, TermWin.gc,	2284	XDrawRectangle (display->display, drawBuffer, TermWin.gc,
2281	Col2Pixel (oldcursor.col),	2285	Col2Pixel (oldcursor.col),
2282	Row2Pixel (oldcursor.row),	2286	Row2Pixel (oldcursor.row),
2283	(unsigned int) (Width2Pixel (cursorwidth) - 1),	2287	(unsigned int) (Width2Pixel (cursorwidth) - 1),
2284	(unsigned int) (Height2Pixel (1) - TermWin.lineSpace - 1));	2288	(unsigned int) (Height2Pixel (1) - TermWin.lineSpace - 1));
2285	}	2289	}
2286	}	2290	}
2287		2291
2288	/*	2292	/*
2289	* H: cleanup selection	2293	* H: cleanup selection
…		…
2297	/*	2301	/*
2298	* clear the whole screen height, note that width == 0 is treated	2302	* clear the whole screen height, note that width == 0 is treated
2299	* specially by XClearArea	2303	* specially by XClearArea
2300	*/	2304	*/
2301	XClearArea (display->display, TermWin.vt, 0, 0,	2305	XClearArea (display->display, TermWin.vt, 0, 0,
2302	(unsigned int)TermWin.int_bwidth,	2306	(unsigned int)TermWin.int_bwidth,
2303	(unsigned int)TermWin_TotalHeight (), False);	2307	(unsigned int)TermWin_TotalHeight (), False);
		2308
2304	if (clearlast && TermWin.int_bwidth)	2309	if (clearlast && TermWin.int_bwidth)
2305	/*	2310	/*
2306	* clear the whole screen height, note that width == 0 is treated	2311	* clear the whole screen height, note that width == 0 is treated
2307	* specially by XClearArea	2312	* specially by XClearArea
2308	*/	2313	*/
2309	XClearArea (display->display, TermWin.vt,	2314	XClearArea (display->display, TermWin.vt,
2310	TermWin.width + TermWin.int_bwidth, 0,	2315	TermWin.width + TermWin.int_bwidth, 0,
2311	(unsigned int)TermWin.int_bwidth,	2316	(unsigned int)TermWin.int_bwidth,
2312	(unsigned int)TermWin_TotalHeight (), False);	2317	(unsigned int)TermWin_TotalHeight (), False);
		2318
2313	if (refresh_type & SMOOTH_REFRESH)	2319	if (refresh_type & SMOOTH_REFRESH)
2314	XSync (display->display, False);	2320	XSync (display->display, False);
2315		2321
2316	num_scr = 0;	2322	num_scr = 0;
2317	num_scr_allow = 1;	2323	num_scr_allow = 1;
2318	want_refresh = 0; /* screen is current */	2324	want_refresh = 0; /* screen is current */
2319	}	2325	}
2320		2326
2321	/* ------------------------------------------------------------------------- */
2322	void	2327	void
		2328	rxvt_term::scr_remap_chars (text_t *tp, rend_t *rp)
		2329	{
		2330	if (!rp || !tp)
		2331	return;
		2332
		2333	for (int i = TermWin.ncol; i; i--, rp++, tp++)
		2334	*rp = SET_FONT (*rp, TermWin.fontset->find_font (*tp));
		2335	}
		2336
		2337	void
2323	rxvt_term::scr_clear ()	2338	rxvt_term::scr_remap_chars ()
		2339	{
		2340	for (int i = TermWin.nrow + TermWin.saveLines; i--; )
		2341	scr_remap_chars (screen.text[i], screen.rend[i]);
		2342
		2343	for (int i = TermWin.nrow; i--; )
		2344	{
		2345	scr_remap_chars (drawn_text[i], drawn_rend[i]);
		2346	scr_remap_chars (swap.text[i], swap.rend[i]);
		2347	}
		2348	}
		2349
		2350	/* ------------------------------------------------------------------------- */
		2351	void
		2352	rxvt_term::scr_clear (bool really)
2324	{	2353	{
2325	if (!TermWin.mapped)	2354	if (!TermWin.mapped)
2326	return;	2355	return;
2327		2356
2328	num_scr_allow = 0;	2357	num_scr_allow = 0;
2329	want_refresh = 1;	2358	want_refresh = 1;
		2359
2330	#ifdef TRANSPARENT	2360	#ifdef TRANSPARENT
2331	if ((Options & Opt_transparent) && (am_pixmap_trans == 0))	2361	if ((Options & Opt_transparent) && (am_pixmap_trans == 0))
2332	{	2362	{
2333	int i;	2363	int i;
2334		2364
…		…
2341	if (TermWin.parent[i] != None)	2371	if (TermWin.parent[i] != None)
2342	XClearWindow (display->display, TermWin.parent[i]);	2372	XClearWindow (display->display, TermWin.parent[i]);
2343	}	2373	}
2344	#endif	2374	#endif
2345		2375
		2376	if (really)
2346	XClearWindow (display->display, TermWin.vt);	2377	XClearWindow (display->display, TermWin.vt);
2347	}	2378	}
2348		2379
2349	/* ------------------------------------------------------------------------- */	2380	/* ------------------------------------------------------------------------- */
2350	void	2381	void
2351	rxvt_term::scr_reverse_selection ()	2382	rxvt_term::scr_reverse_selection ()
2352	{	2383	{
2353	int i, col, row, end_row;
2354	rend_t *srp;
2355
2356	if (selection.op && current_screen == selection.screen)	2384	if (selection.op && current_screen == selection.screen)
2357	{	2385	{
2358	end_row = TermWin.saveLines - TermWin.view_start;	2386	int end_row = TermWin.saveLines - TermWin.view_start;
2359	i = selection.beg.row + TermWin.saveLines;	2387	int i = selection.beg.row + TermWin.saveLines;
2360	row = selection.end.row + TermWin.saveLines;	2388	int col, row = selection.end.row + TermWin.saveLines;
		2389	rend_t *srp;
		2390
2361	if (i >= end_row)	2391	if (i >= end_row)
2362	col = selection.beg.col;	2392	col = selection.beg.col;
2363	else	2393	else
2364	{	2394	{
2365	col = 0;	2395	col = 0;
2366	i = end_row;	2396	i = end_row;
2367	}	2397	}
		2398
2368	end_row += TermWin.nrow;	2399	end_row += TermWin.nrow;
2369	for (; i < row && i < end_row; i++, col = 0)	2400	for (; i < row && i < end_row; i++, col = 0)
2370	for (srp = screen.rend[i]; col < TermWin.ncol; col++)	2401	for (srp = screen.rend[i]; col < TermWin.ncol; col++)
2371	srp[col] ^= RS_RVid;	2402	srp[col] ^= RS_RVid;
		2403
2372	if (i == row && i < end_row)	2404	if (i == row && i < end_row)
2373	for (srp = screen.rend[i]; col < selection.end.col; col++)	2405	for (srp = screen.rend[i]; col < selection.end.col; col++)
2374	srp[col] ^= RS_RVid;	2406	srp[col] ^= RS_RVid;
2375	}	2407	}
2376	}	2408	}
…		…
2515	}	2547	}
2516		2548
2517	for (;;)	2549	for (;;)
2518	{	2550	{
2519	if (XGetWindowProperty (display->display, win, prop, (long) (nread / 4),	2551	if (XGetWindowProperty (display->display, win, prop, (long) (nread / 4),
2520	(long) (PROP_SIZE / 4), delete_prop,	2552	(long) (PROP_SIZE / 4), delete_prop,
2521	AnyPropertyType, &ct.encoding, &ct.format,	2553	AnyPropertyType, &ct.encoding, &ct.format,
2522	&ct.nitems, &bytes_after,	2554	&ct.nitems, &bytes_after,
2523	&ct.value) != Success)	2555	&ct.value) != Success)
2524	break;	2556	break;
2525		2557
2526	if (ct.encoding == 0)	2558	if (ct.encoding == 0)
2527	{	2559	{
2528	D_SELECT ((stderr, "rxvt_selection_paste: property didn't exist!"));	2560	D_SELECT ((stderr, "rxvt_selection_paste: property didn't exist!"));
…		…
2536	}	2568	}
2537		2569
2538	if (ct.nitems == 0)	2570	if (ct.nitems == 0)
2539	{	2571	{
2540	D_SELECT ((stderr, "rxvt_selection_paste: property empty - also INCR end"));	2572	D_SELECT ((stderr, "rxvt_selection_paste: property empty - also INCR end"));
		2573
2541	if (selection_wait == Sel_normal && nread == 0)	2574	if (selection_wait == Sel_normal && nread == 0
		2575	&& (win != display->root || prop != XA_CUT_BUFFER0)) // avoid recursion
2542	{	2576	{
2543	/*	2577	/*
2544	* pass through again trying CUT_BUFFER0 if we've come from	2578	* pass through again trying CUT_BUFFER0 if we've come from
2545	* XConvertSelection () but nothing was presented	2579	* XConvertSelection () but nothing was presented
2546	*/	2580	*/
…		…
2599	{	2633	{
2600	int reget_time = 0;	2634	int reget_time = 0;
2601		2635
2602	if (prop == None)	2636	if (prop == None)
2603	return;	2637	return;
		2638
2604	D_SELECT ((stderr, "rxvt_selection_property (%08lx, %lu)", win, (unsigned long)prop));	2639	D_SELECT ((stderr, "rxvt_selection_property (%08lx, %lu)", win, (unsigned long)prop));
2605	if (selection_wait == Sel_normal)	2640	if (selection_wait == Sel_normal)
2606	{	2641	{
2607	int a, afmt;	2642	int a, afmt;
2608	Atom atype;	2643	Atom atype;
2609	unsigned long bytes_after, nitems;	2644	unsigned long bytes_after, nitems;
2610	unsigned char *s = NULL;	2645	unsigned char *s = NULL;
2611		2646
2612	a = XGetWindowProperty (display->display, win, prop, 0L, 1L, False,	2647	a = XGetWindowProperty (display->display, win, prop, 0L, 1L, False,
2613	xa[XA_INCR], &atype, &afmt, &nitems,	2648	xa[XA_INCR], &atype, &afmt, &nitems,
2614	&bytes_after, &s);	2649	&bytes_after, &s);
2615	if (s)	2650	if (s)
2616	XFree (s);	2651	XFree (s);
2617	if (a != Success)	2652	if (a != Success)
2618	return;	2653	return;
		2654
2619	#ifndef __CYGWIN32__	2655	#ifndef __CYGWIN32__
2620	if (atype == xa[XA_INCR])	2656	if (atype == xa[XA_INCR])
2621	{ /* start an INCR transfer */	2657	{ /* start an INCR transfer */
2622	D_SELECT ((stderr, "rxvt_selection_property: INCR: starting transfer"));	2658	D_SELECT ((stderr, "rxvt_selection_property: INCR: starting transfer"));
2623	XDeleteProperty (display->display, win, prop);	2659	XDeleteProperty (display->display, win, prop);
…		…
2629		2665
2630	}	2666	}
2631	else if (selection_wait == Sel_incr)	2667	else if (selection_wait == Sel_incr)
2632	{	2668	{
2633	reget_time = 1;	2669	reget_time = 1;
		2670
2634	if (selection_paste (win, prop, True) == -1)	2671	if (selection_paste (win, prop, True) == -1)
2635	{	2672	{
2636	D_SELECT ((stderr, "rxvt_selection_property: INCR: clean end"));	2673	D_SELECT ((stderr, "rxvt_selection_property: INCR: clean end"));
2637	selection_wait = Sel_none;	2674	selection_wait = Sel_none;
2638	incr_ev.stop ();	2675	incr_ev.stop ();
2639	}	2676	}
2640	}	2677	}
2641	if (reget_time) /* received more data so reget time */	2678	if (reget_time) /* received more data so reget time */
2642	incr_ev.start (NOW + 10);	2679	incr_ev.start (NOW + 10);
2643	}	2680	}
		2681
2644	/* ------------------------------------------------------------------------- */	2682	/* ------------------------------------------------------------------------- */
2645	/*	2683	/*
2646	* Request the current selection:	2684	* Request the current selection:
2647	* Order: > internal selection if available	2685	* Order: > internal selection if available
2648	* > PRIMARY, SECONDARY, CLIPBOARD if ownership is claimed (+)	2686	* > PRIMARY, SECONDARY, CLIPBOARD if ownership is claimed (+)
…		…
2653	*/	2691	*/
2654	void	2692	void
2655	rxvt_term::selection_request (Time tm, int x, int y)	2693	rxvt_term::selection_request (Time tm, int x, int y)
2656	{	2694	{
2657	D_SELECT ((stderr, "rxvt_selection_request (%lu, %d, %d)", tm, x, y));	2695	D_SELECT ((stderr, "rxvt_selection_request (%lu, %d, %d)", tm, x, y));
		2696
2658	if (x < 0 || x >= TermWin.width || y < 0 || y >= TermWin.height)	2697	if (x < 0 || x >= TermWin.width || y < 0 || y >= TermWin.height)
2659	return; /* outside window */	2698	return; /* outside window */
2660		2699
2661	if (selection.text != NULL)	2700	if (selection.text)
2662	{ /* internal selection */	2701	{ /* internal selection */
2663	D_SELECT ((stderr, "rxvt_selection_request: pasting internal"));	2702	D_SELECT ((stderr, "rxvt_selection_request: pasting internal"));
2664	paste (selection.text, selection.len);	2703	char *str = rxvt_wcstombs (selection.text, selection.len);
		2704	paste ((unsigned char *)str, strlen (str));
		2705	free (str);
2665	return;	2706	return;
2666	}	2707	}
2667	else	2708	else
2668	{	2709	{
2669	int i;	2710	int i;
2670		2711
2671	selection_request_time = tm;	2712	selection_request_time = tm;
2672	selection_wait = Sel_normal;	2713	selection_wait = Sel_normal;
2673	for (i = Sel_Primary; i <= Sel_Clipboard; i++)	2714	for (i = Sel_Primary; i <= Sel_Clipboard; i++)
2674	{	2715	{
…		…
2682	return;	2723	return;
2683	#endif	2724	#endif
2684		2725
2685	}	2726	}
2686	}	2727	}
		2728
2687	selection_wait = Sel_none; /* don't loop in rxvt_selection_paste () */	2729	selection_wait = Sel_none; /* don't loop in rxvt_selection_paste () */
2688	D_SELECT ((stderr, "rxvt_selection_request: pasting CUT_BUFFER0"));	2730	D_SELECT ((stderr, "rxvt_selection_request: pasting CUT_BUFFER0"));
2689	selection_paste (display->root, XA_CUT_BUFFER0, False);	2731	selection_paste (display->root, XA_CUT_BUFFER0, False);
2690	}	2732	}
2691		2733
2692	int	2734	int
2693	rxvt_term::selection_request_other (Atom target, int selnum)	2735	rxvt_term::selection_request_other (Atom target, int selnum)
2694	{	2736	{
2695	Atom sel;	2737	Atom sel;
2696	#ifdef DEBUG_SELECT	2738	#ifdef DEBUG_SELECT
2697	char *debug_xa_names[] = { "PRIMARY", "SECONDARY", "CLIPBOARD" };	2739	char *debug_xa_names[] = { "PRIMARY", "SECONDARY", "CLIPBOARD" };
2698	#endif	2740	#endif
2699		2741
2700	selection_type |= selnum;	2742	selection_type |= selnum;
		2743
2701	if (selnum == Sel_Primary)	2744	if (selnum == Sel_Primary)
2702	sel = XA_PRIMARY;	2745	sel = XA_PRIMARY;
2703	else if (selnum == Sel_Secondary)	2746	else if (selnum == Sel_Secondary)
2704	sel = XA_SECONDARY;	2747	sel = XA_SECONDARY;
2705	else	2748	else
2706	sel = xa[XA_CLIPBOARD];	2749	sel = xa[XA_CLIPBOARD];
		2750
2707	if (XGetSelectionOwner (display->display, sel) != None)	2751	if (XGetSelectionOwner (display->display, sel) != None)
2708	{	2752	{
2709	D_SELECT ((stderr, "rxvt_selection_request_other: pasting %s", debug_xa_names[selnum]));	2753	D_SELECT ((stderr, "rxvt_selection_request_other: pasting %s", debug_xa_names[selnum]));
2710	XConvertSelection (display->display, sel, target, xa[XA_VT_SELECTION],	2754	XConvertSelection (display->display, sel, target, xa[XA_VT_SELECTION],
2711	TermWin.vt, selection_request_time);	2755	TermWin.vt, selection_request_time);
2712	return 1;	2756	return 1;
2713	}	2757	}
		2758
2714	return 0;	2759	return 0;
2715	}	2760	}
2716		2761
2717	/* ------------------------------------------------------------------------- */	2762	/* ------------------------------------------------------------------------- */
2718	/*	2763	/*
…		…
2723	rxvt_term::selection_clear ()	2768	rxvt_term::selection_clear ()
2724	{	2769	{
2725	D_SELECT ((stderr, "rxvt_selection_clear ()"));	2770	D_SELECT ((stderr, "rxvt_selection_clear ()"));
2726		2771
2727	want_refresh = 1;	2772	want_refresh = 1;
2728	if (selection.text)
2729	free (selection.text);	2773	free (selection.text);
2730	selection.text = NULL;	2774	selection.text = NULL;
2731	selection.len = 0;	2775	selection.len = 0;
2732	CLEAR_SELECTION ();	2776	CLEAR_SELECTION ();
2733	}	2777	}
2734		2778
…		…
2738	* EXT: button 1 or 3 release	2782	* EXT: button 1 or 3 release
2739	*/	2783	*/
2740	void	2784	void
2741	rxvt_term::selection_make (Time tm)	2785	rxvt_term::selection_make (Time tm)
2742	{	2786	{
2743	int i, col, end_col, row, end_row;	2787	int i, col, end_col, row, end_row;
2744	unsigned char *new_selection_text;	2788	wchar_t *new_selection_text;
2745	char *str;
2746	text_t *t;	2789	text_t *t;
2747	#ifdef ACS_ASCII
2748	rend_t *re;
2749	#endif
2750		2790
2751	D_SELECT ((stderr, "rxvt_selection_make (): selection.op=%d, selection.clicks=%d", selection.op, selection.clicks));	2791	D_SELECT ((stderr, "rxvt_selection_make (): selection.op=%d, selection.clicks=%d", selection.op, selection.clicks));
2752	switch (selection.op)	2792	switch (selection.op)
2753	{	2793	{
2754	case SELECTION_CONT:	2794	case SELECTION_CONT:
…		…
2760	selection.op = SELECTION_DONE;	2800	selection.op = SELECTION_DONE;
2761	/* FALLTHROUGH */	2801	/* FALLTHROUGH */
2762	default:	2802	default:
2763	return;	2803	return;
2764	}	2804	}
		2805
2765	selection.op = SELECTION_DONE;	2806	selection.op = SELECTION_DONE;
2766		2807
2767	if (selection.clicks == 4)	2808	if (selection.clicks == 4)
2768	return; /* nothing selected, go away */	2809	return; /* nothing selected, go away */
2769		2810
2770	i = (selection.end.row - selection.beg.row + 1) * (TermWin.ncol + 1) + 1;	2811	i = (selection.end.row - selection.beg.row + 1) * (TermWin.ncol + 1);
2771	str = (char *)rxvt_malloc (i * MB_CUR_MAX + 1);	2812	new_selection_text = (wchar_t *)rxvt_malloc ((i + 4) * sizeof (wchar_t));
2772
2773	new_selection_text = (unsigned char *)str;
2774		2813
2775	col = selection.beg.col;	2814	col = selection.beg.col;
2776	MAX_IT (col, 0);	2815	MAX_IT (col, 0);
2777	row = selection.beg.row + TermWin.saveLines;	2816	row = selection.beg.row + TermWin.saveLines;
2778	end_row = selection.end.row + TermWin.saveLines;	2817	end_row = selection.end.row + TermWin.saveLines;
		2818	int ofs = 0;
		2819	int extra = 0;
2779		2820
2780	for (; row <= end_row; row++, col = 0)	2821	for (; row <= end_row; row++, col = 0)
2781	{	2822	{
2782	t = & (screen.text[row][col]);	2823	t = &(screen.text[row][col]);
2783		2824
2784	end_col = screen.tlen[row];	2825	end_col = screen.tlen[row];
2785		2826
2786	if (end_col == -1)	2827	if (end_col == -1)
2787	end_col = TermWin.ncol;	2828	end_col = TermWin.ncol;
2788		2829
2789	if (row == end_row)	2830	if (row == end_row)
2790	MIN_IT (end_col, selection.end.col);	2831	MIN_IT (end_col, selection.end.col);
2791		2832
2792	for (; col < end_col; col++)	2833	for (; col < end_col; col++)
		2834	{
2793	if (*t == NOCHAR)	2835	if (*t == NOCHAR)
2794	t++;	2836	t++;
		2837	#if ENABLE_COMBINING
		2838	else if (IS_COMPOSE (*t))
		2839	{
		2840	int len = rxvt_composite.expand (*t, 0);
		2841
		2842	extra -= (len - 1);
		2843
		2844	if (extra < 0)
		2845	{
		2846	extra += i;
		2847	i += i;
		2848	new_selection_text = (wchar_t *)rxvt_realloc (new_selection_text, (i + 4) * sizeof (wchar_t));
		2849	}
		2850
		2851	ofs += rxvt_composite.expand (*t++, new_selection_text + ofs);
		2852	}
		2853	#endif
2795	else	2854	else
2796	{	2855	new_selection_text[ofs++] = *t++;
2797	int len = wctomb (str, *t++);
2798	if (len > 0)
2799	str += len;
2800	}	2856	}
2801		2857
2802	if (screen.tlen[row] != -1 && row != end_row)	2858	if (screen.tlen[row] != -1 && row != end_row)
2803	*str++ = '\n';	2859	new_selection_text[ofs++] = L'\n';
2804	}	2860	}
2805		2861
2806	#ifndef NO_OLD_SELECTION
2807	if (selection_style == OLD_SELECT)
2808	if (end_col == TermWin.ncol)
2809	*str++ = '\n';
2810	#endif
2811	#ifndef NO_NEW_SELECTION
2812	if (selection_style != OLD_SELECT)
2813	if (end_col != selection.end.col)	2862	if (end_col != selection.end.col)
2814	*str++ = '\n';	2863	new_selection_text[ofs++] = L'\n';
2815	#endif
2816	*str = '\0';
2817		2864
2818	i = str - (char *)new_selection_text;	2865	new_selection_text[ofs] = 0;
		2866
2819	if (i == 0)	2867	if (ofs == 0)
2820	{	2868	{
2821	free (new_selection_text);	2869	free (new_selection_text);
2822	return;	2870	return;
2823	}	2871	}
2824		2872
2825	// due to MB_MAX_CUR, selection wastage is usually high, so realloc
2826	if (str - (char *)new_selection_text > 1024)
2827	new_selection_text = (unsigned char *)rxvt_realloc (new_selection_text, i + 1);
2828
2829	selection.len = i;
2830
2831	if (selection.text)
2832	free (selection.text);	2873	free (selection.text);
2833		2874
2834	selection.text = new_selection_text;	2875	// we usually allocate much more than necessary, so realloc it smaller again
		2876	selection.len = ofs;
		2877	selection.text = (wchar_t *)rxvt_realloc (new_selection_text, (ofs + 1) * sizeof (wchar_t));
2835		2878
2836	XSetSelectionOwner (display->display, XA_PRIMARY, TermWin.vt, tm);	2879	XSetSelectionOwner (display->display, XA_PRIMARY, TermWin.vt, tm);
2837	if (XGetSelectionOwner (display->display, XA_PRIMARY) == TermWin.vt)	2880	if (XGetSelectionOwner (display->display, XA_PRIMARY) == TermWin.vt)
2838	display->set_selection_owner (this);	2881	display->set_selection_owner (this);
2839	else	2882	else
2840	rxvt_print_error ("can't get primary selection");	2883	rxvt_print_error ("can't get primary selection");
2841		2884
2842	{	2885	#if 0
2843	XTextProperty ct;	2886	XTextProperty ct;
2844	char *cl = (char *)selection.text;
2845		2887
2846	if (XmbTextListToTextProperty (display->display, &cl, 1, XStringStyle, &ct) >= 0)	2888	if (XwcTextListToTextProperty (display->display, &selection.text, 1, XStringStyle, &ct) >= 0)
2847	{	2889	{
2848	XChangeProperty (display->display, display->root, XA_CUT_BUFFER0, XA_STRING, 8,
2849	PropModeReplace, ct.value, ct.nitems);
2850	XFree (ct.value);
2851	}
2852	else
2853	XChangeProperty (display->display, display->root, XA_CUT_BUFFER0, XA_STRING, 8,	2890	XChangeProperty (display->display, display->root, XA_CUT_BUFFER0, XA_STRING, 8,
2854	PropModeReplace, selection.text, (int)selection.len);	2891	PropModeReplace, ct.value, ct.nitems);
		2892	XFree (ct.value);
2855	}	2893	}
		2894	#endif
2856		2895
2857	selection_time = tm;	2896	selection_time = tm;
2858	D_SELECT ((stderr, "rxvt_selection_make (): selection.len=%d", selection.len));	2897	D_SELECT ((stderr, "rxvt_selection_make (): selection.len=%d", selection.len));
2859	}	2898	}
2860		2899
…		…
2889	rxvt_term::selection_start_colrow (int col, int row)	2928	rxvt_term::selection_start_colrow (int col, int row)
2890	{	2929	{
2891	want_refresh = 1;	2930	want_refresh = 1;
2892	selection.mark.col = col;	2931	selection.mark.col = col;
2893	selection.mark.row = row - TermWin.view_start;	2932	selection.mark.row = row - TermWin.view_start;
		2933
2894	MAX_IT (selection.mark.row, - (int32_t)TermWin.nscrolled);	2934	MAX_IT (selection.mark.row, - (int32_t)TermWin.nscrolled);
2895	MIN_IT (selection.mark.row, (int32_t)TermWin.nrow - 1);	2935	MIN_IT (selection.mark.row, (int32_t)TermWin.nrow - 1);
2896	MAX_IT (selection.mark.col, 0);	2936	MAX_IT (selection.mark.col, 0);
2897	MIN_IT (selection.mark.col, (int32_t)TermWin.ncol - 1);	2937	MIN_IT (selection.mark.col, (int32_t)TermWin.ncol - 1);
2898		2938
		2939	while (selection.mark.col > 0
		2940	&& screen.text[selection.mark.row + TermWin.saveLines][selection.mark.col] == NOCHAR)
		2941	--selection.mark.col;
		2942
2899	if (selection.op)	2943	if (selection.op)
2900	{ /* clear the old selection */	2944	{ /* clear the old selection */
2901	selection.beg.row = selection.end.row = selection.mark.row;	2945	selection.beg.row = selection.end.row = selection.mark.row;
2902	selection.beg.col = selection.end.col = selection.mark.col;	2946	selection.beg.col = selection.end.col = selection.mark.col;
2903	}	2947	}
		2948
2904	selection.op = SELECTION_INIT;	2949	selection.op = SELECTION_INIT;
2905	selection.screen = current_screen;	2950	selection.screen = current_screen;
2906	}	2951	}
2907		2952
2908	/* ------------------------------------------------------------------------- */	2953	/* ------------------------------------------------------------------------- */
…		…
2910	* Word select: select text for 2 clicks	2955	* Word select: select text for 2 clicks
2911	* We now only find out the boundary in one direction	2956	* We now only find out the boundary in one direction
2912	*/	2957	*/
2913		2958
2914	/* what do we want: spaces/tabs are delimiters or cutchars or non-cutchars */	2959	/* what do we want: spaces/tabs are delimiters or cutchars or non-cutchars */
2915	#define DELIMIT_TEXT(x) \	2960	#define DELIMIT_TEXT(x) \
2916	(((x) == ' ' || (x) == '\t') ? 2 : (STRCHR (rs[Rs_cutchars], (x)) != NULL))	2961	(unicode::is_space (x) ? 2 : (x) <= 0xff && !!STRCHR (rs[Rs_cutchars], (x)))
2917	#define DELIMIT_REND(x) 1	2962	#define DELIMIT_REND(x) 1
2918		2963
2919	void	2964	void
2920	rxvt_term::selection_delimit_word (enum page_dirn dirn, const row_col_t *mark, row_col_t *ret)	2965	rxvt_term::selection_delimit_word (enum page_dirn dirn, const row_col_t *mark, row_col_t *ret)
2921	{	2966	{
2922	int col, row, dirnadd, tcol, trow, w1, w2;	2967	int col, row, dirnadd, tcol, trow, w1, w2;
2923	row_col_t bound;	2968	row_col_t bound;
2924	text_t *stp;	2969	text_t *stp;
2925	rend_t *srp;	2970	rend_t *srp;
2926		2971
2927	if (dirn == UP)	2972	if (dirn == UP)
2928	{	2973	{
2929	bound.row = TermWin.saveLines - TermWin.nscrolled - 1;	2974	bound.row = TermWin.saveLines - TermWin.nscrolled - 1;
2930	bound.col = 0;	2975	bound.col = 0;
…		…
2934	{	2979	{
2935	bound.row = TermWin.saveLines + TermWin.nrow;	2980	bound.row = TermWin.saveLines + TermWin.nrow;
2936	bound.col = TermWin.ncol - 1;	2981	bound.col = TermWin.ncol - 1;
2937	dirnadd = 1;	2982	dirnadd = 1;
2938	}	2983	}
		2984
2939	row = mark->row + TermWin.saveLines;	2985	row = mark->row + TermWin.saveLines;
2940	col = mark->col;	2986	col = mark->col;
2941	MAX_IT (col, 0);	2987	MAX_IT (col, 0);
2942	/* find the edge of a word */	2988	/* find the edge of a word */
2943	stp = & (screen.text[row][col]);	2989	stp = & (screen.text[row][col]);
2944	w1 = DELIMIT_TEXT (*stp);	2990	w1 = DELIMIT_TEXT (*stp);
2945		2991
2946	if (selection_style != NEW_SELECT)
2947	{
2948	if (w1 == 1)
2949	{
2950	stp += dirnadd;
2951	if (DELIMIT_TEXT (*stp) == 1)
2952	goto Old_Word_Selection_You_Die;
2953	col += dirnadd;
2954	}
2955	w1 = 0;
2956	}
2957	srp = (&screen.rend[row][col]);	2992	srp = (&screen.rend[row][col]);
2958	w2 = DELIMIT_REND (*srp);	2993	w2 = DELIMIT_REND (*srp);
2959		2994
2960	for (;;)	2995	for (;;)
2961	{	2996	{
2962	for (; col != bound.col; col += dirnadd)	2997	for (; col != bound.col; col += dirnadd)
2963	{	2998	{
2964	stp += dirnadd;	2999	stp += dirnadd;
		3000	srp += dirnadd;
		3001
		3002	if (*stp == NOCHAR)
		3003	continue;
		3004
2965	if (DELIMIT_TEXT (*stp) != w1)	3005	if (DELIMIT_TEXT (*stp) != w1)
2966	break;	3006	break;
2967	srp += dirnadd;
2968	if (DELIMIT_REND (*srp) != w2)	3007	if (DELIMIT_REND (*srp) != w2)
2969	break;	3008	break;
2970	}	3009	}
		3010
2971	if ((col == bound.col) && (row != bound.row))	3011	if ((col == bound.col) && (row != bound.row))
2972	{	3012	{
2973	if (screen.tlen[ (row - (dirn == UP ? 1 : 0))] == -1)	3013	if (screen.tlen[ (row - (dirn == UP ? 1 : 0))] == -1)
2974	{	3014	{
2975	trow = row + dirnadd;	3015	trow = row + dirnadd;
2976	tcol = dirn == UP ? TermWin.ncol - 1 : 0;	3016	tcol = dirn == UP ? TermWin.ncol - 1 : 0;
		3017
2977	if (screen.text[trow] == NULL)	3018	if (screen.text[trow] == NULL)
2978	break;	3019	break;
		3020
2979	stp = & (screen.text[trow][tcol]);	3021	stp = & (screen.text[trow][tcol]);
2980	srp = & (screen.rend[trow][tcol]);	3022	srp = & (screen.rend[trow][tcol]);
		3023
2981	if (DELIMIT_TEXT (*stp) != w1 || DELIMIT_REND (*srp) != w2)	3024	if (DELIMIT_TEXT (*stp) != w1 || DELIMIT_REND (*srp) != w2)
2982	break;	3025	break;
		3026
2983	row = trow;	3027	row = trow;
2984	col = tcol;	3028	col = tcol;
2985	continue;	3029	continue;
2986	}	3030	}
2987	}	3031	}
2988	break;	3032	break;
2989	}	3033	}
		3034
2990	Old_Word_Selection_You_Die:	3035	Old_Word_Selection_You_Die:
2991	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));	3036	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));
2992		3037
2993	if (dirn == DN)	3038	if (dirn == DN)
2994	col++; /* put us on one past the end */	3039	col++; /* put us on one past the end */
…		…
3016	MAX_IT (row, 0);	3061	MAX_IT (row, 0);
3017	MIN_IT (row, (int)TermWin.nrow - 1);	3062	MIN_IT (row, (int)TermWin.nrow - 1);
3018	MAX_IT (col, 0);	3063	MAX_IT (col, 0);
3019	MIN_IT (col, (int)TermWin.ncol);	3064	MIN_IT (col, (int)TermWin.ncol);
3020		3065
3021	#ifndef NO_NEW_SELECTION
3022	/*	3066	/*
3023	* If we're selecting characters (single click) then we must check first	3067	* If we're selecting characters (single click) then we must check first
3024	* if we are at the same place as the original mark. If we are then	3068	* if we are at the same place as the original mark. If we are then
3025	* select nothing. Otherwise, if we're to the right of the mark, you have to	3069	* select nothing. Otherwise, if we're to the right of the mark, you have to
3026	* be _past_ a character for it to be selected.	3070	* be _past_ a character for it to be selected.
3027	*/	3071	*/
3028	if (selection_style != OLD_SELECT)
3029	{
3030	if (((selection.clicks % 3) == 1) && !flag	3072	if (((selection.clicks % 3) == 1) && !flag
3031	&& (col == selection.mark.col	3073	&& (col == selection.mark.col
3032	&& (row == selection.mark.row + TermWin.view_start)))	3074	&& (row == selection.mark.row + TermWin.view_start)))
3033	{	3075	{
3034	/* select nothing */	3076	/* select nothing */
3035	selection.beg.row = selection.end.row = 0;	3077	selection.beg.row = selection.end.row = 0;
3036	selection.beg.col = selection.end.col = 0;	3078	selection.beg.col = selection.end.col = 0;
3037	selection.clicks = 4;	3079	selection.clicks = 4;
3038	want_refresh = 1;	3080	want_refresh = 1;
3039	D_SELECT ((stderr, "rxvt_selection_extend () selection.clicks = 4"));	3081	D_SELECT ((stderr, "rxvt_selection_extend () selection.clicks = 4"));
3040	return;	3082	return;
3041	}
3042	}	3083	}
3043	#endif	3084
3044	if (selection.clicks == 4)	3085	if (selection.clicks == 4)
3045	selection.clicks = 1;	3086	selection.clicks = 1;
3046		3087
3047	selection_extend_colrow (col, row, !!flag, /* ? button 3 */	3088	selection_extend_colrow (col, row, !!flag, /* ? button 3 */
3048	flag == 1 ? 1 : 0, /* ? button press */	3089	flag == 1 ? 1 : 0, /* ? button press */
…		…
3102	pos.col = col;	3143	pos.col = col;
3103	pos.row = row;	3144	pos.row = row;
3104		3145
3105	pos.row -= TermWin.view_start; /* adjust for scroll */	3146	pos.row -= TermWin.view_start; /* adjust for scroll */
3106		3147
3107	#ifndef NO_OLD_SELECTION
3108	/*
3109	* This mimics some of the selection behaviour of version 2.20 and before.
3110	* There are no ``selection modes'', button3 is always character extension.
3111	* Note: button3 drag is always available, c.f. v2.20
3112	* Selection always terminates (left or right as appropriate) at the mark.
3113	*/
3114	if (selection_style == OLD_SELECT)
3115	{
3116	if (selection.clicks == 1 || button3)
3117	{
3118	if (hate_those_clicks)
3119	{
3120	hate_those_clicks = 0;
3121	if (selection.clicks == 1)
3122	{
3123	selection.beg.row = selection.mark.row;
3124	selection.beg.col = selection.mark.col;
3125	}
3126	else
3127	{
3128	selection.mark.row = selection.beg.row;
3129	selection.mark.col = selection.beg.col;
3130	}
3131	}
3132	if (ROWCOL_IS_BEFORE (pos, selection.mark))
3133	{
3134	selection.end.row = selection.mark.row;
3135	selection.end.col = selection.mark.col + 1;
3136	selection.beg.row = pos.row;
3137	selection.beg.col = pos.col;
3138	}
3139	else
3140	{
3141	selection.beg.row = selection.mark.row;
3142	selection.beg.col = selection.mark.col;
3143	selection.end.row = pos.row;
3144	selection.end.col = pos.col + 1;
3145	}
3146	}
3147	else if (selection.clicks == 2)
3148	{
3149	selection_delimit_word (UP, & (selection.mark),
3150	& (selection.beg));
3151	selection_delimit_word (DN, & (selection.mark),
3152	& (selection.end));
3153	hate_those_clicks = 1;
3154	}
3155	else if (selection.clicks == 3)
3156	{
3157	selection.beg.row = selection.end.row = selection.mark.row;
3158	selection.beg.col = 0;
3159	selection.end.col = ncol;
3160	hate_those_clicks = 1;
3161	}
3162	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));
3163	return;
3164	}
3165	#endif /* ! NO_OLD_SELECTION */
3166	#ifndef NO_NEW_SELECTION
3167	/* selection_style must not be OLD_SELECT to get here */
3168	/*	3148	/*
3169	* This is mainly xterm style selection with a couple of differences, mainly	3149	* This is mainly xterm style selection with a couple of differences, mainly
3170	* in the way button3 drag extension works.	3150	* in the way button3 drag extension works.
3171	* We're either doing: button1 drag; button3 press; or button3 drag	3151	* We're either doing: button1 drag; button3 press; or button3 drag
3172	* a) button1 drag : select around a midpoint/word/line - that point/word/line	3152	* a) button1 drag : select around a midpoint/word/line - that point/word/line
…		…
3177	* a point/word/line which is either the start or end of the selection	3157	* a point/word/line which is either the start or end of the selection
3178	* and it was decided by whichever point/word/line was `fixed' at the	3158	* and it was decided by whichever point/word/line was `fixed' at the
3179	* time of the most recent button3 press	3159	* time of the most recent button3 press
3180	*/	3160	*/
3181	if (button3 && buttonpress)	3161	if (button3 && buttonpress)
3182	{ /* button3 press */	3162	{ /* button3 press */
3183	/*	3163	/*
3184	* first determine which edge of the selection we are closest to	3164	* first determine which edge of the selection we are closest to
3185	*/	3165	*/
3186	if (ROWCOL_IS_BEFORE (pos, selection.beg)	3166	if (ROWCOL_IS_BEFORE (pos, selection.beg)
3187	|| (!ROWCOL_IS_AFTER (pos, selection.end)	3167	|| (!ROWCOL_IS_AFTER (pos, selection.end)
3188	&& (((pos.col - selection.beg.col)	3168	&& (((pos.col - selection.beg.col)
3189	+ ((pos.row - selection.beg.row) * ncol))	3169	+ ((pos.row - selection.beg.row) * ncol))
3190	< ((selection.end.col - pos.col)	3170	< ((selection.end.col - pos.col)
3191	+ ((selection.end.row - pos.row) * ncol)))))	3171	+ ((selection.end.row - pos.row) * ncol)))))
3192	closeto = LEFT;	3172	closeto = LEFT;
		3173
3193	if (closeto == LEFT)	3174	if (closeto == LEFT)
3194	{	3175	{
3195	selection.beg.row = pos.row;	3176	selection.beg.row = pos.row;
3196	selection.beg.col = pos.col;	3177	selection.beg.col = pos.col;
3197	selection.mark.row = selection.end.row;	3178	selection.mark.row = selection.end.row;
3198	selection.mark.col = selection.end.col	3179	selection.mark.col = selection.end.col - (selection.clicks == 2);
3199	- (selection.clicks == 2);
3200	}	3180	}
3201	else	3181	else
3202	{	3182	{
3203	selection.end.row = pos.row;	3183	selection.end.row = pos.row;
3204	selection.end.col = pos.col;	3184	selection.end.col = pos.col;
3205	selection.mark.row = selection.beg.row;	3185	selection.mark.row = selection.beg.row;
3206	selection.mark.col = selection.beg.col;	3186	selection.mark.col = selection.beg.col;
3207	}	3187	}
3208	}	3188	}
3209	else	3189	else
3210	{ /* button1 drag or button3 drag */	3190	{ /* button1 drag or button3 drag */
3211	if (ROWCOL_IS_AFTER (selection.mark, pos))	3191	if (ROWCOL_IS_AFTER (selection.mark, pos))
3212	{	3192	{
3213	if ((selection.mark.row == selection.end.row)	3193	if ((selection.mark.row == selection.end.row)
3214	&& (selection.mark.col == selection.end.col)	3194	&& (selection.mark.col == selection.end.col)
3215	&& clickchange && selection.clicks == 2)	3195	&& clickchange && selection.clicks == 2)
3216	selection.mark.col--;	3196	selection.mark.col--;
		3197
3217	selection.beg.row = pos.row;	3198	selection.beg.row = pos.row;
3218	selection.beg.col = pos.col;	3199	selection.beg.col = pos.col;
3219	selection.end.row = selection.mark.row;	3200	selection.end.row = selection.mark.row;
3220	selection.end.col = selection.mark.col	3201	selection.end.col = selection.mark.col + (selection.clicks == 2);
3221	+ (selection.clicks == 2);
3222	}	3202	}
3223	else	3203	else
3224	{	3204	{
3225	selection.beg.row = selection.mark.row;	3205	selection.beg.row = selection.mark.row;
3226	selection.beg.col = selection.mark.col;	3206	selection.beg.col = selection.mark.col;
…		…
3230	}	3210	}
3231		3211
3232	if (selection.clicks == 1)	3212	if (selection.clicks == 1)
3233	{	3213	{
3234	end_col = screen.tlen[selection.beg.row + TermWin.saveLines];	3214	end_col = screen.tlen[selection.beg.row + TermWin.saveLines];
		3215
3235	if (end_col != -1 && selection.beg.col > end_col)	3216	if (end_col != -1 && selection.beg.col > end_col)
3236	{	3217	{
3237	#if 1	3218	#if 1
3238	selection.beg.col = ncol;	3219	selection.beg.col = ncol;
3239	#else	3220	#else
3240	if (selection.beg.row != selection.end.row)	3221	if (selection.beg.row != selection.end.row)
3241	selection.beg.col = ncol;	3222	selection.beg.col = ncol;
3242	else	3223	else
3243	selection.beg.col = selection.mark.col;	3224	selection.beg.col = selection.mark.col;
3244	#endif	3225	#endif
3245
3246	}	3226	}
		3227
3247	end_col = screen.tlen[selection.end.row + TermWin.saveLines];	3228	end_col = screen.tlen[selection.end.row + TermWin.saveLines];
		3229
3248	if (end_col != -1 && selection.end.col > end_col)	3230	if (end_col != -1 && selection.end.col > end_col)
3249	selection.end.col = ncol;	3231	selection.end.col = ncol;
3250
3251	}	3232	}
3252	else if (selection.clicks == 2)	3233	else if (selection.clicks == 2)
3253	{	3234	{
3254	if (ROWCOL_IS_AFTER (selection.end, selection.beg))	3235	if (ROWCOL_IS_AFTER (selection.end, selection.beg))
3255	selection.end.col--;	3236	selection.end.col--;
		3237
3256	selection_delimit_word (UP, & (selection.beg),	3238	selection_delimit_word (UP, & (selection.beg), & (selection.beg));
3257	& (selection.beg));
3258	selection_delimit_word (DN, & (selection.end),	3239	selection_delimit_word (DN, & (selection.end), & (selection.end));
3259	& (selection.end));
3260	}	3240	}
3261	else if (selection.clicks == 3)	3241	else if (selection.clicks == 3)
3262	{	3242	{
3263	#ifndef NO_FRILLS	3243	#ifndef NO_FRILLS
3264	if ((Options & Opt_tripleclickwords))	3244	if ((Options & Opt_tripleclickwords))
3265	{	3245	{
3266	int end_row;	3246	int end_row;
3267		3247
3268	selection_delimit_word (UP, & (selection.beg),	3248	selection_delimit_word (UP, & (selection.beg), & (selection.beg));
3269	& (selection.beg));
3270	end_row = screen.tlen[selection.mark.row	3249	end_row = screen.tlen[selection.mark.row + TermWin.saveLines];
3271	+ TermWin.saveLines];	3250
3272	for (end_row = selection.mark.row; end_row < TermWin.nrow;	3251	for (end_row = selection.mark.row; end_row < TermWin.nrow; end_row++)
3273	end_row++)
3274	{	3252	{
3275	end_col = screen.tlen[end_row + TermWin.saveLines];	3253	end_col = screen.tlen[end_row + TermWin.saveLines];
		3254
3276	if (end_col != -1)	3255	if (end_col != -1)
3277	{	3256	{
3278	selection.end.row = end_row;	3257	selection.end.row = end_row;
3279	selection.end.col = end_col;	3258	selection.end.col = end_col;
3280	selection_remove_trailing_spaces ();	3259	selection_remove_trailing_spaces ();
…		…
3282	}	3261	}
3283	}	3262	}
3284	}	3263	}
3285	else	3264	else
3286	#endif	3265	#endif
3287
3288	{	3266	{
3289	if (ROWCOL_IS_AFTER (selection.mark, selection.beg))	3267	if (ROWCOL_IS_AFTER (selection.mark, selection.beg))
3290	selection.mark.col++;	3268	selection.mark.col++;
3291	selection.beg.col = 0;	3269	selection.beg.col = 0;
3292	selection.end.col = ncol;	3270	selection.end.col = ncol;
3293	}	3271	}
3294	}	3272	}
		3273
3295	if (button3 && buttonpress)	3274	if (button3 && buttonpress)
3296	{ /* mark may need to be changed */	3275	{ /* mark may need to be changed */
3297	if (closeto == LEFT)	3276	if (closeto == LEFT)
3298	{	3277	{
3299	selection.mark.row = selection.end.row;	3278	selection.mark.row = selection.end.row;
3300	selection.mark.col = selection.end.col	3279	selection.mark.col = selection.end.col
3301	- (selection.clicks == 2);	3280	- (selection.clicks == 2);
…		…
3305	selection.mark.row = selection.beg.row;	3284	selection.mark.row = selection.beg.row;
3306	selection.mark.col = selection.beg.col;	3285	selection.mark.col = selection.beg.col;
3307	}	3286	}
3308	}	3287	}
3309	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));	3288	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	#endif /* ! NO_NEW_SELECTION */
3311	}	3289	}
3312		3290
3313	#ifndef NO_FRILLS	3291	#ifndef NO_FRILLS
3314	void	3292	void
3315	rxvt_term::selection_remove_trailing_spaces ()	3293	rxvt_term::selection_remove_trailing_spaces ()
…		…
3389	ev.target = rq.target;	3367	ev.target = rq.target;
3390	ev.time = rq.time;	3368	ev.time = rq.time;
3391		3369
3392	if (rq.target == xa[XA_TARGETS])	3370	if (rq.target == xa[XA_TARGETS])
3393	{	3371	{
3394	Atom32 target_list[5];	3372	Atom32 target_list[6];
3395	Atom32 *target = target_list;	3373	Atom32 *target = target_list;
3396		3374
3397	*target++ = (Atom32) xa[XA_TARGETS];	3375	*target++ = (Atom32) xa[XA_TARGETS];
		3376	*target++ = (Atom32) xa[XA_TIMESTAMP];
3398	*target++ = (Atom32) XA_STRING;	3377	*target++ = (Atom32) XA_STRING;
3399	*target++ = (Atom32) xa[XA_TEXT];	3378	*target++ = (Atom32) xa[XA_TEXT];
3400	*target++ = (Atom32) xa[XA_COMPOUND_TEXT];	3379	*target++ = (Atom32) xa[XA_COMPOUND_TEXT];
3401	#if X_HAVE_UTF8_STRING	3380	#if X_HAVE_UTF8_STRING
3402	*target++ = (Atom32) xa[XA_UTF8_STRING];	3381	*target++ = (Atom32) xa[XA_UTF8_STRING];
3403	#endif	3382	#endif
		3383
3404	XChangeProperty (display->display, rq.requestor, rq.property, XA_ATOM,	3384	XChangeProperty (display->display, rq.requestor, rq.property, XA_ATOM,
3405	(8 * sizeof (target_list[0])), PropModeReplace,	3385	(8 * sizeof (target_list[0])), PropModeReplace,
3406	(unsigned char *)target_list,	3386	(unsigned char *)target_list,
3407	target - target_list);	3387	target - target_list);
3408	ev.property = rq.property;	3388	ev.property = rq.property;
3409	}	3389	}
3410	else if (rq.target == xa[XA_MULTIPLE])	3390	else if (rq.target == xa[XA_MULTIPLE])
3411	{	3391	{
3412	/* TODO: Handle MULTIPLE */	3392	/* TODO: Handle MULTIPLE */
…		…
3424	|| rq.target == xa[XA_UTF8_STRING]	3404	|| rq.target == xa[XA_UTF8_STRING]
3425	)	3405	)
3426	{	3406	{
3427	short freect = 0;	3407	short freect = 0;
3428	int selectlen;	3408	int selectlen;
3429	char *cl;	3409	wchar_t *cl;
3430		3410
3431	target = rq.target;	3411	target = rq.target;
3432		3412
3433	if (target == XA_STRING)	3413	if (target == XA_STRING)
3434	// we actually don't do XA_STRING, but who cares, as i18n clients	3414	// we actually don't do XA_STRING, but who cares, as i18n clients
3435	// will ask for another format anyways.	3415	// will ask for another format anyways.
3436	style = XStringStyle;	3416	style = XStringStyle;
3437	else if (target == xa[XA_TEXT])	3417	else if (target == xa[XA_TEXT])
3438	style = XTextStyle;	3418	style = XStdICCTextStyle;
3439	else if (target == xa[XA_COMPOUND_TEXT])	3419	else if (target == xa[XA_COMPOUND_TEXT])
3440	style = XCompoundTextStyle;	3420	style = XCompoundTextStyle;
3441	#if X_HAVE_UTF8_STRING	3421	#if X_HAVE_UTF8_STRING
3442	else if (target == xa[XA_UTF8_STRING])	3422	else if (target == xa[XA_UTF8_STRING])
3443	style = XUTF8StringStyle;	3423	style = XUTF8StringStyle;
…		…
3448	style = XCompoundTextStyle;	3428	style = XCompoundTextStyle;
3449	}	3429	}
3450		3430
3451	if (selection.text)	3431	if (selection.text)
3452	{	3432	{
3453	cl = (char *)selection.text;	3433	cl = selection.text;
3454	selectlen = selection.len;	3434	selectlen = selection.len;
3455	}	3435	}
3456	else	3436	else
3457	{	3437	{
3458	cl = "";	3438	cl = L"";
3459	selectlen = 0;	3439	selectlen = 0;
3460	}	3440	}
3461		3441
		3442	// Xwc doesn't handle iso-10646 in wchar_t gracefully, so maybe recode it
		3443	// manually for XUTF8StringStyle.
3462	if (XmbTextListToTextProperty (display->display, &cl, 1, style, &ct) >= 0)	3444	if (XwcTextListToTextProperty (display->display, &cl, 1, style, &ct) >= 0)
3463	freect = 1;	3445	freect = 1;
3464	else	3446	else
3465	{	3447	{
3466	/* if we failed to convert then send it raw */	3448	/* if we failed to convert then send it raw */
3467	ct.value = (unsigned char *)cl;	3449	ct.value = (unsigned char *)cl;
…		…
3474	ev.property = rq.property;	3456	ev.property = rq.property;
3475		3457
3476	if (freect)	3458	if (freect)
3477	XFree (ct.value);	3459	XFree (ct.value);
3478	}	3460	}
		3461
3479	XSendEvent (display->display, rq.requestor, False, 0L, (XEvent *)&ev);	3462	XSendEvent (display->display, rq.requestor, False, 0L, (XEvent *)&ev);
3480	}	3463	}
3481		3464
3482	/* ------------------------------------------------------------------------- *	3465	/* ------------------------------------------------------------------------- *
3483	* MOUSE ROUTINES *	3466	* MOUSE ROUTINES *

Diff Legend

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