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.38 by pcg, Wed Feb 25 10:26:50 2004 UTC vs.
Revision 1.66 by pcg, Sun Mar 28 02:07:08 2004 UTC

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

Diff Legend

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