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.85 by root, Sun Aug 8 16:43:21 2004 UTC vs.
Revision 1.104 by root, Tue Aug 17 01:29:12 2004 UTC

…		…
25	*/	25	*/
26		26
27	#include "../config.h" /* NECESSARY */	27	#include "../config.h" /* NECESSARY */
28	#define INTERN_SCREEN	28	#define INTERN_SCREEN
29	#include "rxvt.h" /* NECESSARY */	29	#include "rxvt.h" /* NECESSARY */
30	#include "screen.intpro" /* PROTOS for internal routines */
31		30
32	#include <X11/Xmd.h> /* get the typedef for CARD32 */	31	#include <X11/Xmd.h> /* get the typedef for CARD32 */
33		32
34	#include <inttypes.h>	33	#include <inttypes.h>
35	#include <wchar.h>	34	#include <wchar.h>
…		…
48		47
49	/* ------------------------------------------------------------------------- *	48	/* ------------------------------------------------------------------------- *
50	* GENERAL SCREEN AND SELECTION UPDATE ROUTINES *	49	* GENERAL SCREEN AND SELECTION UPDATE ROUTINES *
51	* ------------------------------------------------------------------------- */	50	* ------------------------------------------------------------------------- */
52	#define ZERO_SCROLLBACK() \	51	#define ZERO_SCROLLBACK() \
53	if (Options & Opt_scrollTtyOutput) \	52	if (options & Opt_scrollTtyOutput) \
54	TermWin.view_start = 0	53	TermWin.view_start = 0
55	#define CLEAR_SELECTION() \	54	#define CLEAR_SELECTION() \
56	selection.beg.row = selection.beg.col \	55	selection.beg.row = selection.beg.col \
57	= selection.end.row = selection.end.col = 0	56	= selection.end.row = selection.end.col = 0
58	#define CLEAR_ALL_SELECTION() \	57	#define CLEAR_ALL_SELECTION() \
…		…
155	unsigned int ncol, nrow, total_rows, prev_total_rows;	154	unsigned int ncol, nrow, total_rows, prev_total_rows;
156	unsigned int p, q;	155	unsigned int p, q;
157	int k;	156	int k;
158	rend_t setrstyle;	157	rend_t setrstyle;
159		158
160	D_SCREEN ((stderr, "rxvt_scr_reset ()"));	159	#if ENABLE_OVERLAY
		160	scr_overlay_off ();
		161	#endif
161		162
162	TermWin.view_start = 0;	163	TermWin.view_start = 0;
163	num_scr = 0;	164	num_scr = 0;
164		165
165	if (TermWin.ncol == 0)	166	if (TermWin.ncol == 0)
…		…
172	nrow = TermWin.nrow;	173	nrow = TermWin.nrow;
173		174
174	if (ncol == prev_ncol && nrow == prev_nrow)	175	if (ncol == prev_ncol && nrow == prev_nrow)
175	return;	176	return;
176		177
		178	// we need at least two lines for wrapping to work correctly
		179	if (nrow + TermWin.saveLines < 2)
		180	{
		181	TermWin.saveLines++;
		182	prev_nrow--;
		183	TermWin.nscrolled++;
		184	}
		185
177	want_refresh = 1;	186	want_refresh = 1;
178		187
		188	prev_total_rows = prev_nrow + TermWin.saveLines;
179	total_rows = nrow + TermWin.saveLines;	189	total_rows = nrow + TermWin.saveLines;
180	prev_total_rows = prev_nrow + TermWin.saveLines;
181		190
182	screen.tscroll = 0;	191	screen.tscroll = 0;
183	screen.bscroll = nrow - 1;	192	screen.bscroll = nrow - 1;
184		193
185	if (!talloc)	194	if (!talloc)
186	{	195	{
187	talloc = new rxvt_salloc (ncol * sizeof (text_t));	196	talloc = new rxvt_salloc (ncol * sizeof (text_t));
188	ralloc = new rxvt_salloc (ncol * sizeof (rend_t));	197	ralloc = new rxvt_salloc (ncol * sizeof (rend_t));
189	}	198	}
190		199
191	if (prev_nrow == 0)	200	if (!screen.text)
192	{	201	{
193	/*	202	/*
194	* first time called so just malloc everything: don't rely on realloc	203	* first time called so just malloc everything: don't rely on realloc
195	* Note: this is still needed so that all the scrollback lines are NULL	204	* Note: this is still needed so that all the scrollback lines are NULL
196	*/	205	*/
…		…
214	scr_blank_screen_mem (swap.text, swap.rend, p, DEFAULT_RSTYLE);	223	scr_blank_screen_mem (swap.text, swap.rend, p, DEFAULT_RSTYLE);
215	screen.tlen[q] = swap.tlen[p] = 0;	224	screen.tlen[q] = swap.tlen[p] = 0;
216	scr_blank_screen_mem (drawn_text, drawn_rend, p, DEFAULT_RSTYLE);	225	scr_blank_screen_mem (drawn_text, drawn_rend, p, DEFAULT_RSTYLE);
217	}	226	}
218		227
219	MEMSET (charsets, 'B', sizeof (charsets));	228	memset (charsets, 'B', sizeof (charsets));
220	TermWin.nscrolled = 0; /* no saved lines */	229	TermWin.nscrolled = 0; /* no saved lines */
221	rstyle = DEFAULT_RSTYLE;	230	rstyle = DEFAULT_RSTYLE;
222	screen.flags = Screen_DefaultFlags;	231	screen.flags = Screen_DefaultFlags;
223	screen.cur.row = screen.cur.col = 0;	232	screen.cur.row = screen.cur.col = 0;
224	screen.charset = 0;	233	screen.charset = 0;
…		…
471	* Hard reset	480	* Hard reset
472	*/	481	*/
473	void	482	void
474	rxvt_term::scr_poweron ()	483	rxvt_term::scr_poweron ()
475	{	484	{
476	D_SCREEN ((stderr, "rxvt_scr_poweron ()"));
477
478	scr_release ();	485	scr_release ();
479	prev_nrow = prev_ncol = 0;	486	prev_nrow = prev_ncol = 0;
480	scr_reset ();	487	scr_reset ();
481		488
482	scr_clear (true);	489	scr_clear (true);
…		…
493	*/	500	*/
494	void	501	void
495	rxvt_term::scr_cursor (int mode)	502	rxvt_term::scr_cursor (int mode)
496	{	503	{
497	screen_t *s;	504	screen_t *s;
498
499	D_SCREEN ((stderr, "rxvt_scr_cursor (%c)", mode));
500		505
501	#if NSCREENS && !defined(NO_SECONDARY_SCREEN_CURSOR)	506	#if NSCREENS && !defined(NO_SECONDARY_SCREEN_CURSOR)
502	if (current_screen == SECONDARY)	507	if (current_screen == SECONDARY)
503	s = &swap;	508	s = &swap;
504	else	509	else
…		…
553	int offset;	558	int offset;
554	#endif	559	#endif
555		560
556	want_refresh = 1;	561	want_refresh = 1;
557		562
558	D_SCREEN ((stderr, "rxvt_scr_change_screen (%d)", scrn));
559
560	TermWin.view_start = 0;	563	TermWin.view_start = 0;
561		564
562	if (current_screen == scrn)	565	if (current_screen == scrn)
563	return scrn;	566	return scrn;
564		567
565	selection_check (2); /* check for boundary cross */	568	selection_check (2); /* check for boundary cross */
566		569
567	SWAP_IT (current_screen, scrn, int);	570	SWAP_IT (current_screen, scrn, int);
568	#if NSCREENS	571	#if NSCREENS
569	if (Options & Opt_secondaryScreen)	572	if (options & Opt_secondaryScreen)
570	{	573	{
571	num_scr = 0;	574	num_scr = 0;
572	offset = TermWin.saveLines;	575	offset = TermWin.saveLines;
573	for (i = prev_nrow; i--;)	576	for (i = prev_nrow; i--;)
574	{	577	{
…		…
592	screen.flags |= Screen_VisibleCursor;	595	screen.flags |= Screen_VisibleCursor;
593	swap.flags |= Screen_VisibleCursor;	596	swap.flags |= Screen_VisibleCursor;
594	}	597	}
595	else	598	else
596	#endif	599	#endif
597	if (Options & Opt_secondaryScroll)	600	if (options & Opt_secondaryScroll)
598	//if (current_screen == PRIMARY)	601	//if (current_screen == PRIMARY)
599	scr_scroll_text (0, (prev_nrow - 1), prev_nrow, 0);	602	scr_scroll_text (0, (prev_nrow - 1), prev_nrow, 0);
600	return scrn;	603	return scrn;
		604	}
		605
		606	// clear WrapNext indicator, solidifying position on next line
		607	void
		608	rxvt_term::scr_do_wrap ()
		609	{
		610	if (!(screen.flags & Screen_WrapNext))
		611	return;
		612
		613	screen.flags &= ~Screen_WrapNext;
		614
		615	screen.cur.col = 0;
		616
		617	if (screen.cur.row == screen.bscroll)
		618	scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);
		619	else if (screen.cur.row < TermWin.nrow - 1)
		620	screen.cur.row++;
601	}	621	}
602		622
603	/* ------------------------------------------------------------------------- */	623	/* ------------------------------------------------------------------------- */
604	/*	624	/*
605	* Change the colour for following text	625	* Change the colour for following text
…		…
644		664
645	if (count == 0 || (row1 > row2))	665	if (count == 0 || (row1 > row2))
646	return 0;	666	return 0;
647		667
648	want_refresh = 1;	668	want_refresh = 1;
649	D_SCREEN ((stderr, "rxvt_scroll_text (%d,%d,%d,%d): %s", row1, row2, count, spec, (current_screen == PRIMARY) ? "Primary" : "Secondary"));
650		669
651	if (row1 == 0 && count > 0	670	if (row1 == 0 && count > 0
652	&& (current_screen == PRIMARY || Options & Opt_secondaryScroll))	671	&& (current_screen == PRIMARY || options & Opt_secondaryScroll))
653	{	672	{
654	nscrolled = (long)TermWin.nscrolled + (long)count;	673	nscrolled = (long)TermWin.nscrolled + (long)count;
655		674
656	if (nscrolled > (long)TermWin.saveLines)	675	if (nscrolled > (long)TermWin.saveLines)
657	TermWin.nscrolled = TermWin.saveLines;	676	TermWin.nscrolled = TermWin.saveLines;
658	else	677	else
659	TermWin.nscrolled = (uint16_t)nscrolled;	678	TermWin.nscrolled = (uint16_t)nscrolled;
660		679
661	if ((Options & Opt_scrollWithBuffer)	680	if ((options & Opt_scrollWithBuffer)
662	&& TermWin.view_start != 0	681	&& TermWin.view_start != 0
663	&& TermWin.view_start != TermWin.saveLines)	682	&& TermWin.view_start != TermWin.saveLines)
664	scr_page (UP, count);	683	scr_page (UP, count);
665	}	684	}
666	else if (!spec)	685	else if (!spec)
…		…
757	* Add text given in <str> of length <len> to screen struct	776	* Add text given in <str> of length <len> to screen struct
758	*/	777	*/
759	void	778	void
760	rxvt_term::scr_add_lines (const unicode_t *str, int nlines, int len)	779	rxvt_term::scr_add_lines (const unicode_t *str, int nlines, int len)
761	{	780	{
762	unsigned char checksel, clearsel;	781	unsigned char checksel;
763	unicode_t c;	782	unicode_t c;
764	int i, row, last_col;	783	int i, row, last_col;
765	text_t *stp;	784	text_t *stp;
766	rend_t *srp;	785	rend_t *srp;
767		786
768	if (len <= 0) /* sanity */	787	if (len <= 0) /* sanity */
769	return;	788	return;
770		789
771	want_refresh = 1;	790	want_refresh = 1;
		791	ZERO_SCROLLBACK ();
772	last_col = TermWin.ncol;	792	last_col = TermWin.ncol;
773		793
774	D_SCREEN ((stderr, "rxvt_scr_add_lines (%d,%d)", nlines, len));
775	ZERO_SCROLLBACK ();
776	if (nlines > 0)	794	if (nlines > 0)
777	{	795	{
778	nlines += screen.cur.row - screen.bscroll;	796	nlines += screen.cur.row - screen.bscroll;
779	if ((nlines > 0)	797	if ((nlines > 0)
780	&& (screen.tscroll == 0)	798	&& (screen.tscroll == 0)
…		…
783	/* _at least_ this many lines need to be scrolled */	801	/* _at least_ this many lines need to be scrolled */
784	scr_scroll_text (screen.tscroll, screen.bscroll, nlines, 0);	802	scr_scroll_text (screen.tscroll, screen.bscroll, nlines, 0);
785	screen.cur.row -= nlines;	803	screen.cur.row -= nlines;
786	}	804	}
787	}	805	}
		806
788	#ifdef DEBUG_STRICT	807	#ifdef DEBUG_STRICT
789	assert (screen.cur.col < last_col);	808	assert (screen.cur.col < last_col);
790	assert ((screen.cur.row < TermWin.nrow)	809	assert ((screen.cur.row < TermWin.nrow)
791	&& (screen.cur.row >= - (int32_t)TermWin.nscrolled));	810	&& (screen.cur.row >= - (int32_t)TermWin.nscrolled));
792	#else /* drive with your eyes closed */	811	#else /* drive with your eyes closed */
…		…
795	MAX_IT (screen.cur.row, - (int32_t)TermWin.nscrolled);	814	MAX_IT (screen.cur.row, - (int32_t)TermWin.nscrolled);
796	#endif	815	#endif
797	row = screen.cur.row + TermWin.saveLines;	816	row = screen.cur.row + TermWin.saveLines;
798		817
799	checksel = selection.op && current_screen == selection.screen ? 1 : 0;	818	checksel = selection.op && current_screen == selection.screen ? 1 : 0;
800	clearsel = 0;
801		819
802	stp = screen.text[row];	820	stp = screen.text[row];
803	srp = screen.rend[row];	821	srp = screen.rend[row];
804		822
805	while (len--)	823	while (len--)
…		…
840	if (checksel /* see if we're writing within selection */	858	if (checksel /* see if we're writing within selection */
841	&& !ROWCOL_IS_BEFORE (screen.cur, selection.beg)	859	&& !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
842	&& ROWCOL_IS_BEFORE (screen.cur, selection.end))	860	&& ROWCOL_IS_BEFORE (screen.cur, selection.end))
843	{	861	{
844	checksel = 0;	862	checksel = 0;
845	clearsel = 1;	863	/*
		864	* If we wrote anywhere in the selected area, kill the selection
		865	* XXX: should we kill the mark too? Possibly, but maybe that
		866	* should be a similar check.
		867	*/
		868	CLEAR_SELECTION ();
846	}	869	}
847		870
848	if (screen.flags & Screen_WrapNext)	871	if (screen.flags & Screen_WrapNext)
849	{	872	{
850	screen.tlen[row] = -1;	873	screen.tlen[row] = -1;
851	if (screen.cur.row == screen.bscroll)	874
852	scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);
853	else if (screen.cur.row < (TermWin.nrow - 1))
854	row = (++screen.cur.row) + TermWin.saveLines;	875	scr_do_wrap (); row = screen.cur.row + TermWin.saveLines;
855		876
856	stp = screen.text[row]; /* _must_ refresh */	877	stp = screen.text[row]; /* _must_ refresh */
857	srp = screen.rend[row]; /* _must_ refresh */	878	srp = screen.rend[row]; /* _must_ refresh */
858	screen.cur.col = 0;
859	screen.flags &= ~Screen_WrapNext;
860	}	879	}
861		880
862	if (screen.flags & Screen_Insert)	881	if (screen.flags & Screen_Insert)
863	scr_insdel_chars (1, INSERT);	882	scr_insdel_chars (1, INSERT);
864		883
…		…
884	}	903	}
885	}	904	}
886		905
887	if (width != 0)	906	if (width != 0)
888	{	907	{
889	#if !UNICODE_3 && ENABLE_COMBINING	908	#if !UNICODE_3
890	// trim characters we can't store directly :(	909	// trim characters we can't store directly :(
891	if (c >= 0x10000)	910	if (c >= 0x10000)
		911	# if ENABLE_COMBINING
892	c = rxvt_composite.compose (c); // map to lower 16 bits	912	c = rxvt_composite.compose (c); // map to lower 16 bits
		913	# else
		914	c = 0xfffd;
893	#endif	915	# endif
		916	#endif
894	bool bold = (Options & Opt_realBold) && ((rstyle & RS_Bold) != 0);	917	bool bold = (options & Opt_realBold) && ((rstyle & RS_Bold) != 0);
895	rend_t rend = SET_FONT (rstyle,	918	rend_t rend = SET_FONT (rstyle,
896	c > 0x7f || bold || c < 0x20	919	c > 0x7f || bold || c < 0x20
897	? TermWin.fontset->find_font (c, bold)	920	? TermWin.fontset->find_font (c, bold)
898	: TermWin.ascii_map [c - 0x20]);	921	: TermWin.ascii_map [c - 0x20]);
899		922
…		…
964	}	987	}
965		988
966	if (screen.tlen[row] != -1) /* XXX: think about this */	989	if (screen.tlen[row] != -1) /* XXX: think about this */
967	MAX_IT (screen.tlen[row], screen.cur.col);	990	MAX_IT (screen.tlen[row], screen.cur.col);
968		991
969	/*
970	* If we wrote anywhere in the selected area, kill the selection
971	* XXX: should we kill the mark too? Possibly, but maybe that
972	* should be a similar check.
973	*/
974	if (clearsel)
975	CLEAR_SELECTION ();
976
977	#ifdef DEBUG_STRICT	992	#ifdef DEBUG_STRICT
978	assert (screen.cur.row >= 0);	993	assert (screen.cur.row >= 0);
979	#else /* drive with your eyes closed */	994	#else /* drive with your eyes closed */
980	MAX_IT (screen.cur.row, 0);	995	MAX_IT (screen.cur.row, 0);
981	#endif	996	#endif
…		…
998	#ifdef TERMCAP_HAS_BW	1013	#ifdef TERMCAP_HAS_BW
999	screen.cur.col = TermWin.ncol - 1;	1014	screen.cur.col = TermWin.ncol - 1;
1000	screen.cur.row--;	1015	screen.cur.row--;
1001	return;	1016	return;
1002	#endif	1017	#endif
1003
1004	}	1018	}
1005	}	1019	}
1006	else if ((screen.flags & Screen_WrapNext) == 0)	1020	else if (!(screen.flags & Screen_WrapNext))
1007	scr_gotorc (0, -1, RELATIVE);	1021	scr_gotorc (0, -1, RELATIVE);
1008		1022
1009	screen.flags &= ~Screen_WrapNext;	1023	screen.flags &= ~Screen_WrapNext;
1010	}	1024	}
1011		1025
…		…
1018	void	1032	void
1019	rxvt_term::scr_tab (int count)	1033	rxvt_term::scr_tab (int count)
1020	{	1034	{
1021	int i, x;	1035	int i, x;
1022		1036
1023	D_SCREEN ((stderr, "rxvt_scr_tab (%d)", count));
1024	want_refresh = 1;	1037	want_refresh = 1;
1025	i = x = screen.cur.col;	1038	i = x = screen.cur.col;
1026		1039
1027	if (count == 0)	1040	if (count == 0)
1028	return;	1041	return;
…		…
1062	* Process DEC Back Index	1075	* Process DEC Back Index
1063	* XTERM_SEQ: ESC 6	1076	* XTERM_SEQ: ESC 6
1064	* Move cursor left in row. If we're at the left boundary, shift everything	1077	* Move cursor left in row. If we're at the left boundary, shift everything
1065	* in that row right. Clear left column.	1078	* in that row right. Clear left column.
1066	*/	1079	*/
1067	#ifndef NO_FRILLS	1080	#if ENABLE_FRILLS
1068	void	1081	void
1069	rxvt_term::scr_backindex ()	1082	rxvt_term::scr_backindex ()
1070	{	1083	{
1071	if (screen.cur.col > 0)	1084	if (screen.cur.col > 0)
1072	scr_gotorc (0, -1, R_RELATIVE | C_RELATIVE);	1085	scr_gotorc (0, -1, R_RELATIVE | C_RELATIVE);
1073	else	1086	else
1074	{	1087	{
1075	if (screen.tlen[screen.cur.row + TermWin.saveLines] == 0)	1088	if (screen.tlen[screen.cur.row + TermWin.saveLines] == 0)
1076	return; /* um, yeah? */	1089	return; /* um, yeah? */
		1090
1077	scr_insdel_chars (1, INSERT);	1091	scr_insdel_chars (1, INSERT);
1078	}	1092	}
1079	}	1093	}
1080	#endif	1094	#endif
1081	/* ------------------------------------------------------------------------- */	1095	/* ------------------------------------------------------------------------- */
…		…
1083	* Process DEC Forward Index	1097	* Process DEC Forward Index
1084	* XTERM_SEQ: ESC 9	1098	* XTERM_SEQ: ESC 9
1085	* Move cursor right in row. If we're at the right boundary, shift everything	1099	* Move cursor right in row. If we're at the right boundary, shift everything
1086	* in that row left. Clear right column.	1100	* in that row left. Clear right column.
1087	*/	1101	*/
1088	#ifndef NO_FRILLS	1102	#if ENABLE_FRILLS
1089	void	1103	void
1090	rxvt_term::scr_forwardindex ()	1104	rxvt_term::scr_forwardindex ()
1091	{	1105	{
1092	int row;	1106	int row;
1093		1107
1094	if (screen.cur.col < TermWin.ncol - 1)	1108	if (screen.cur.col < TermWin.ncol - 1)
1095	scr_gotorc (0, 1, R_RELATIVE | C_RELATIVE);	1109	scr_gotorc (0, 1, R_RELATIVE | C_RELATIVE);
1096	else	1110	else
1097	{	1111	{
1098	row = screen.cur.row + TermWin.saveLines;	1112	row = screen.cur.row + TermWin.saveLines;
		1113
1099	if (screen.tlen[row] == 0)	1114	if (screen.tlen[row] == 0)
1100	return; /* um, yeah? */	1115	return; /* um, yeah? */
1101	else if (screen.tlen[row] == -1)	1116	else if (screen.tlen[row] == -1)
1102	screen.tlen[row] = TermWin.ncol;	1117	screen.tlen[row] = TermWin.ncol;
		1118
1103	scr_gotorc (0, 0, R_RELATIVE);	1119	scr_gotorc (0, 0, R_RELATIVE);
1104	scr_insdel_chars (1, DELETE);	1120	scr_insdel_chars (1, DELETE);
1105	scr_gotorc (0, TermWin.ncol - 1, R_RELATIVE);	1121	scr_gotorc (0, TermWin.ncol - 1, R_RELATIVE);
1106	}	1122	}
1107	}	1123	}
…		…
1115	rxvt_term::scr_gotorc (int row, int col, int relative)	1131	rxvt_term::scr_gotorc (int row, int col, int relative)
1116	{	1132	{
1117	want_refresh = 1;	1133	want_refresh = 1;
1118	ZERO_SCROLLBACK ();	1134	ZERO_SCROLLBACK ();
1119		1135
1120	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));
1121
1122	screen.cur.col = relative & C_RELATIVE ? screen.cur.col + col : col;	1136	screen.cur.col = relative & C_RELATIVE ? screen.cur.col + col : col;
1123	MAX_IT (screen.cur.col, 0);	1137	MAX_IT (screen.cur.col, 0);
1124	MIN_IT (screen.cur.col, (int32_t)TermWin.ncol - 1);	1138	MIN_IT (screen.cur.col, (int32_t)TermWin.ncol - 1);
1125		1139
1126	screen.flags &= ~Screen_WrapNext;	1140	screen.flags &= ~Screen_WrapNext;
		1141
1127	if (relative & R_RELATIVE)	1142	if (relative & R_RELATIVE)
1128	{	1143	{
1129	if (row > 0)	1144	if (row > 0)
1130	{	1145	{
1131	if (screen.cur.row <= screen.bscroll	1146	if (screen.cur.row <= screen.bscroll
…		…
1151	MIN_IT (screen.cur.row, screen.bscroll);	1166	MIN_IT (screen.cur.row, screen.bscroll);
1152	}	1167	}
1153	else	1168	else
1154	screen.cur.row = row;	1169	screen.cur.row = row;
1155	}	1170	}
		1171
1156	MAX_IT (screen.cur.row, 0);	1172	MAX_IT (screen.cur.row, 0);
1157	MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);	1173	MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);
1158
1159	while (screen.cur.col > 0
1160	&& screen.text[screen.cur.row + TermWin.saveLines][screen.cur.col] == NOCHAR)
1161	screen.cur.col--;
1162	}	1174	}
1163		1175
1164	/* ------------------------------------------------------------------------- */	1176	/* ------------------------------------------------------------------------- */
1165	/*	1177	/*
1166	* direction should be UP or DN	1178	* direction should be UP or DN
1167	*/	1179	*/
1168	void	1180	void
1169	rxvt_term::scr_index (enum page_dirn direction)	1181	rxvt_term::scr_index (enum page_dirn direction)
1170	{	1182	{
1171	int dirn;	1183	int dirn;
1172		1184
1173	want_refresh = 1;	1185	want_refresh = 1;
		1186	ZERO_SCROLLBACK ();
		1187
1174	dirn = ((direction == UP) ? 1 : -1);	1188	dirn = ((direction == UP) ? 1 : -1);
1175	D_SCREEN ((stderr, "rxvt_scr_index (%d)", dirn));
1176
1177	ZERO_SCROLLBACK ();
1178		1189
1179	screen.flags &= ~Screen_WrapNext;	1190	screen.flags &= ~Screen_WrapNext;
		1191
1180	if ((screen.cur.row == screen.bscroll && direction == UP)	1192	if ((screen.cur.row == screen.bscroll && direction == UP)
1181	|| (screen.cur.row == screen.tscroll && direction == DN))	1193	|| (screen.cur.row == screen.tscroll && direction == DN))
1182	scr_scroll_text (screen.tscroll, screen.bscroll, dirn, 0);	1194	scr_scroll_text (screen.tscroll, screen.bscroll, dirn, 0);
1183	else	1195	else
1184	screen.cur.row += dirn;	1196	screen.cur.row += dirn;
		1197
1185	MAX_IT (screen.cur.row, 0);	1198	MAX_IT (screen.cur.row, 0);
1186	MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);	1199	MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);
1187	selection_check (0);	1200	selection_check (0);
1188	}	1201	}
1189		1202
…		…
1198	rxvt_term::scr_erase_line (int mode)	1211	rxvt_term::scr_erase_line (int mode)
1199	{	1212	{
1200	unsigned int row, col, num;	1213	unsigned int row, col, num;
1201		1214
1202	want_refresh = 1;	1215	want_refresh = 1;
1203	D_SCREEN ((stderr, "rxvt_scr_erase_line (%d) at screen row: %d", mode, screen.cur.row));
1204	ZERO_SCROLLBACK ();	1216	ZERO_SCROLLBACK ();
1205		1217
1206	selection_check (1);	1218	selection_check (1);
1207
1208	screen.flags &= ~Screen_WrapNext;
1209		1219
1210	row = TermWin.saveLines + screen.cur.row;	1220	row = TermWin.saveLines + screen.cur.row;
1211	switch (mode)	1221	switch (mode)
1212	{	1222	{
1213	case 0: /* erase to end of line */	1223	case 0: /* erase to end of line */
…		…
1257	int32_t row, row_offset;	1267	int32_t row, row_offset;
1258	rend_t ren;	1268	rend_t ren;
1259	XGCValues gcvalue;	1269	XGCValues gcvalue;
1260		1270
1261	want_refresh = 1;	1271	want_refresh = 1;
1262	D_SCREEN ((stderr, "rxvt_scr_erase_screen (%d) at screen row: %d", mode, screen.cur.row));
1263	ZERO_SCROLLBACK ();	1272	ZERO_SCROLLBACK ();
		1273
1264	row_offset = (int32_t)TermWin.saveLines;	1274	row_offset = (int32_t)TermWin.saveLines;
1265		1275
1266	switch (mode)	1276	switch (mode)
1267	{	1277	{
1268	case 0: /* erase to end of screen */	1278	case 0: /* erase to end of screen */
…		…
1305	CLEAR_ROWS (row, num);	1315	CLEAR_ROWS (row, num);
1306	}	1316	}
1307	else	1317	else
1308	{	1318	{
1309	ren = (rstyle & (RS_fgMask | RS_bgMask));	1319	ren = (rstyle & (RS_fgMask | RS_bgMask));
1310	gcvalue.foreground = PixColors[GET_BGCOLOR (rstyle)];	1320	gcvalue.foreground = pix_colors[GET_BGCOLOR (rstyle)];
1311	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);	1321	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);
1312	ERASE_ROWS (row, num);	1322	ERASE_ROWS (row, num);
1313	gcvalue.foreground = PixColors[Color_fg];	1323	gcvalue.foreground = pix_colors[Color_fg];
1314	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);	1324	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);
1315	}	1325	}
1316		1326
1317	for (; num--; row++)	1327	for (; num--; row++)
1318	{	1328	{
…		…
1334	{	1344	{
1335	int i, j, k;	1345	int i, j, k;
1336	rend_t *r1, fs;	1346	rend_t *r1, fs;
1337		1347
1338	want_refresh = 1;	1348	want_refresh = 1;
		1349	ZERO_SCROLLBACK ();
		1350
1339	num_scr_allow = 0;	1351	num_scr_allow = 0;
1340	ZERO_SCROLLBACK ();
1341	selection_check (3);	1352	selection_check (3);
1342		1353
1343	fs = SET_FONT (rstyle, TermWin.fontset->find_font ('E'));	1354	fs = SET_FONT (rstyle, TermWin.fontset->find_font ('E'));
1344	for (k = TermWin.saveLines, i = TermWin.nrow; i--; k++)	1355	for (k = TermWin.saveLines, i = TermWin.nrow; i--; k++)
1345	{	1356	{
…		…
1372	if (insdel == DELETE)	1383	if (insdel == DELETE)
1373	return;	1384	return;
1374	else if (insdel == INSERT)	1385	else if (insdel == INSERT)
1375	count = end;	1386	count = end;
1376	}	1387	}
1377	screen.flags &= ~Screen_WrapNext;	1388
		1389	scr_do_wrap ();
1378		1390
1379	scr_scroll_text (screen.cur.row, screen.bscroll, insdel * count, 0);	1391	scr_scroll_text (screen.cur.row, screen.bscroll, insdel * count, 0);
1380	}	1392	}
1381		1393
1382	/* ------------------------------------------------------------------------- */	1394	/* ------------------------------------------------------------------------- */
…		…
1396	ZERO_SCROLLBACK ();	1408	ZERO_SCROLLBACK ();
1397		1409
1398	if (count <= 0)	1410	if (count <= 0)
1399	return;	1411	return;
1400		1412
		1413	scr_do_wrap ();
		1414
1401	selection_check (1);	1415	selection_check (1);
1402	MIN_IT (count, (TermWin.ncol - screen.cur.col));	1416	MIN_IT (count, (TermWin.ncol - screen.cur.col));
1403		1417
1404	row = screen.cur.row + TermWin.saveLines;	1418	row = screen.cur.row + TermWin.saveLines;
1405	screen.flags &= ~Screen_WrapNext;
1406		1419
1407	stp = screen.text[row];	1420	stp = screen.text[row];
1408	srp = screen.rend[row];	1421	srp = screen.rend[row];
1409	slp = & (screen.tlen[row]);	1422	slp = &screen.tlen[row];
1410		1423
1411	switch (insdel)	1424	switch (insdel)
1412	{	1425	{
1413	case INSERT:	1426	case INSERT:
1414	for (col = TermWin.ncol - 1; (col - count) >= screen.cur.col;	1427	for (col = TermWin.ncol - 1; (col - count) >= screen.cur.col;
…		…
1535	rxvt_term::scr_autowrap (int mode)	1548	rxvt_term::scr_autowrap (int mode)
1536	{	1549	{
1537	if (mode)	1550	if (mode)
1538	screen.flags |= Screen_Autowrap;	1551	screen.flags |= Screen_Autowrap;
1539	else	1552	else
1540	screen.flags &= ~ (Screen_Autowrap | Screen_WrapNext);	1553	screen.flags &= ~(Screen_Autowrap | Screen_WrapNext);
1541	}	1554	}
1542		1555
1543	/* ------------------------------------------------------------------------- */	1556	/* ------------------------------------------------------------------------- */
1544	/*	1557	/*
1545	* Set/unset margin origin mode	1558	* Set/unset margin origin mode
…		…
1584	*/	1597	*/
1585	void	1598	void
1586	rxvt_term::scr_set_tab (int mode)	1599	rxvt_term::scr_set_tab (int mode)
1587	{	1600	{
1588	if (mode < 0)	1601	if (mode < 0)
1589	MEMSET (tabs, 0, TermWin.ncol * sizeof (char));	1602	memset (tabs, 0, TermWin.ncol * sizeof (char));
1590	else if (screen.cur.col < TermWin.ncol)	1603	else if (screen.cur.col < TermWin.ncol)
1591	tabs[screen.cur.col] = (mode ? 1 : 0);	1604	tabs[screen.cur.col] = (mode ? 1 : 0);
1592	}	1605	}
1593		1606
1594	/* ------------------------------------------------------------------------- */	1607	/* ------------------------------------------------------------------------- */
…		…
1598	* XTERM_SEQ: Normal video : ESC [ ? 5 l	1611	* XTERM_SEQ: Normal video : ESC [ ? 5 l
1599	*/	1612	*/
1600	void	1613	void
1601	rxvt_term::scr_rvideo_mode (int mode)	1614	rxvt_term::scr_rvideo_mode (int mode)
1602	{	1615	{
1603	XGCValues gcvalue;	1616	XGCValues gcvalue;
1604		1617
1605	if (rvideo != mode)	1618	if (rvideo != mode)
1606	{	1619	{
1607	rvideo = mode;	1620	rvideo = mode;
1608	SWAP_IT (PixColors[Color_fg], PixColors[Color_bg], rxvt_color);	1621	SWAP_IT (pix_colors[Color_fg], pix_colors[Color_bg], rxvt_color);
1609	#if defined(XPM_BACKGROUND)	1622	#if defined(XPM_BACKGROUND)
1610	if (bgPixmap.pixmap == None)	1623	if (bgPixmap.pixmap == None)
1611	#endif	1624	#endif
1612	#if defined(TRANSPARENT)	1625	#if defined(TRANSPARENT)
1613	if (! (Options & Opt_transparent) || am_transparent == 0)	1626	if (! (options & Opt_transparent) || am_transparent == 0)
1614	#endif	1627	#endif
1615	XSetWindowBackground (display->display, TermWin.vt,	1628	XSetWindowBackground (display->display, TermWin.vt,
1616	PixColors[Color_bg]);	1629	pix_colors[Color_bg]);
1617		1630
1618	gcvalue.foreground = PixColors[Color_fg];	1631	gcvalue.foreground = pix_colors[Color_fg];
1619	gcvalue.background = PixColors[Color_bg];	1632	gcvalue.background = pix_colors[Color_bg];
1620	XChangeGC (display->display, TermWin.gc, GCBackground | GCForeground,	1633	XChangeGC (display->display, TermWin.gc, GCBackground | GCForeground,
1621	&gcvalue);	1634	&gcvalue);
1622	scr_clear ();	1635	scr_clear ();
1623	scr_touch (true);	1636	scr_touch (true);
1624	}	1637	}
…		…
1769	{	1782	{
1770	MIN_IT (rc[i].col, TermWin.ncol - 1);	1783	MIN_IT (rc[i].col, TermWin.ncol - 1);
1771	MIN_IT (rc[i].row, TermWin.nrow - 1);	1784	MIN_IT (rc[i].row, TermWin.nrow - 1);
1772	}	1785	}
1773		1786
1774	D_SCREEN ((stderr, "rxvt_scr_expose (x:%d, y:%d, w:%d, h:%d) area (c:%d,r:%d)- (c:%d,r:%d)", x, y, width, height, rc[PART_BEG].col, rc[PART_BEG].row, rc[PART_END].col, rc[PART_END].row));
1775
1776	for (i = rc[PART_BEG].row; i <= rc[PART_END].row; i++)	1787	for (i = rc[PART_BEG].row; i <= rc[PART_END].row; i++)
1777	fill_text (&drawn_text[i][rc[PART_BEG].col], 0, rc[PART_END].col - rc[PART_BEG].col + 1);	1788	fill_text (&drawn_text[i][rc[PART_BEG].col], 0, rc[PART_END].col - rc[PART_BEG].col + 1);
1778		1789
1779	if (refresh)	1790	if (refresh)
1780	scr_refresh (SLOW_REFRESH);	1791	scr_refresh (SLOW_REFRESH);
…		…
1800	{	1811	{
1801	long p = 0;	1812	long p = 0;
1802	uint16_t oldviewstart;	1813	uint16_t oldviewstart;
1803		1814
1804	oldviewstart = TermWin.view_start;	1815	oldviewstart = TermWin.view_start;
		1816
1805	if (y < len)	1817	if (y < len)
1806	{	1818	{
1807	p = (TermWin.nrow + TermWin.nscrolled) * (len - y) / len;	1819	p = (TermWin.nrow + TermWin.nscrolled) * (len - y) / len;
1808	p -= (long) (TermWin.nrow - 1);	1820	p -= (long) (TermWin.nrow - 1);
1809	p = max (p, 0);	1821	p = max (p, 0);
1810	}	1822	}
		1823
1811	TermWin.view_start = (uint16_t)min (p, TermWin.nscrolled);	1824	TermWin.view_start = (uint16_t)min (p, TermWin.nscrolled);
1812	D_SCREEN ((stderr, "rxvt_scr_move_to (%d, %d) view_start:%d", y, len, TermWin.view_start));
1813		1825
1814	return scr_changeview (oldviewstart);	1826	return scr_changeview (oldviewstart);
1815	}	1827	}
1816		1828
1817	/* ------------------------------------------------------------------------- */	1829	/* ------------------------------------------------------------------------- */
…		…
1823	rxvt_term::scr_page (enum page_dirn direction, int nlines)	1835	rxvt_term::scr_page (enum page_dirn direction, int nlines)
1824	{	1836	{
1825	int n;	1837	int n;
1826	uint16_t oldviewstart;	1838	uint16_t oldviewstart;
1827		1839
1828	D_SCREEN ((stderr, "rxvt_scr_page (%s, %d) view_start:%d", ((direction == UP) ? "UP" : "DN"), nlines, TermWin.view_start));
1829	#ifdef DEBUG_STRICT	1840	#ifdef DEBUG_STRICT
1830	assert ((nlines >= 0) && (nlines <= TermWin.nrow));	1841	assert ((nlines >= 0) && (nlines <= TermWin.nrow));
1831	#endif	1842	#endif
1832	oldviewstart = TermWin.view_start;	1843	oldviewstart = TermWin.view_start;
1833	if (direction == UP)	1844	if (direction == UP)
…		…
1860	rxvt_term::scr_bell ()	1871	rxvt_term::scr_bell ()
1861	{	1872	{
1862	#ifndef NO_BELL	1873	#ifndef NO_BELL
1863	# ifndef NO_MAPALERT	1874	# ifndef NO_MAPALERT
1864	# ifdef MAPALERT_OPTION	1875	# ifdef MAPALERT_OPTION
1865	if (Options & Opt_mapAlert)	1876	if (options & Opt_mapAlert)
1866	# endif	1877	# endif
1867	XMapWindow (display->display, TermWin.parent[0]);	1878	XMapWindow (display->display, TermWin.parent[0]);
1868	# endif	1879	# endif
1869	if (Options & Opt_visualBell)	1880	if (options & Opt_visualBell)
1870	{	1881	{
1871	scr_rvideo_mode (!rvideo); /* refresh also done */	1882	scr_rvideo_mode (!rvideo); /* refresh also done */
1872	scr_rvideo_mode (!rvideo); /* refresh also done */	1883	scr_rvideo_mode (!rvideo); /* refresh also done */
1873	}	1884	}
1874	else	1885	else
…		…
1880	/* ARGSUSED */	1891	/* ARGSUSED */
1881	void	1892	void
1882	rxvt_term::scr_printscreen (int fullhist)	1893	rxvt_term::scr_printscreen (int fullhist)
1883	{	1894	{
1884	#ifdef PRINTPIPE	1895	#ifdef PRINTPIPE
1885	int i, r1, nrows, row_offset;	1896	int i, r1, nrows, row_offset;
1886	text_t *t;	1897	FILE *fd;
1887	FILE *fd;
1888		1898
1889	if ((fd = popen_printer ()) == NULL)	1899	if ((fd = popen_printer ()) == NULL)
1890	return;	1900	return;
		1901
1891	nrows = TermWin.nrow;	1902	nrows = TermWin.nrow;
1892	row_offset = TermWin.saveLines;	1903	row_offset = TermWin.saveLines;
		1904
1893	if (!fullhist)	1905	if (!fullhist)
1894	row_offset -= TermWin.view_start;	1906	row_offset -= TermWin.view_start;
1895	else	1907	else
1896	{	1908	{
1897	nrows += TermWin.nscrolled;	1909	nrows += TermWin.nscrolled;
1898	row_offset -= TermWin.nscrolled;	1910	row_offset -= TermWin.nscrolled;
1899	}	1911	}
1900		1912
		1913	wctomb (0, 0);
		1914
1901	for (r1 = 0; r1 < nrows; r1++)	1915	for (r1 = 0; r1 < nrows; r1++)
1902	{	1916	{
1903	t = screen.text[r1 + row_offset];	1917	text_t *tp = screen.text[r1 + row_offset];
1904	for (i = TermWin.ncol - 1; i >= 0; i--)	1918	int len = screen.tlen[r1 + row_offset];
1905	if (!isspace (t[i]))	1919
1906	break;	1920	for (i = len >= 0 ? len : TermWin.ncol - 1; i--; )
1907	fprintf (fd, "%.*s\n", (i + 1), t);	1921	{
		1922	char mb[MB_LEN_MAX];
		1923	text_t t = *tp++;
		1924	if (t == NOCHAR)
		1925	continue;
		1926
		1927	len = wctomb (mb, t);
		1928
		1929	if (len <= 0)
		1930	{
		1931	mb[0] = ' ';
		1932	len = 1;
		1933	}
		1934
		1935	fwrite (mb, 1, len, fd);
		1936	}
		1937
		1938	fputc ('\n', fd);
1908	}	1939	}
		1940
1909	pclose_printer (fd);	1941	pclose_printer (fd);
1910	#endif	1942	#endif
1911	}	1943	}
1912		1944
1913	/* ------------------------------------------------------------------------- */	1945	/* ------------------------------------------------------------------------- */
…		…
1937	int i, /* tmp */	1969	int i, /* tmp */
1938	row_offset; /* basic offset in screen structure */	1970	row_offset; /* basic offset in screen structure */
1939	#ifndef NO_CURSORCOLOR	1971	#ifndef NO_CURSORCOLOR
1940	rend_t cc1; /* store colours at cursor position (s) */	1972	rend_t cc1; /* store colours at cursor position (s) */
1941	#endif	1973	#endif
1942	rend_t *drp, *srp; /* drawn-rend-pointer, screen-rend-pointer */	1974	rend_t *crp; // cursor rendition pointer
1943	text_t *dtp, *stp; /* drawn-text-pointer, screen-text-pointer */
1944		1975
1945	if (refresh_type == NO_REFRESH || !TermWin.mapped)	1976	if (refresh_type == NO_REFRESH || !TermWin.mapped)
1946	return;	1977	return;
1947		1978
1948	/*	1979	/*
1949	* A: set up vars	1980	* A: set up vars
1950	*/	1981	*/
1951	must_clear = 0;	1982	must_clear = 0;
1952
1953	refresh_count = 0;	1983	refresh_count = 0;
1954		1984
1955	row_offset = TermWin.saveLines - TermWin.view_start;	1985	row_offset = TermWin.saveLines - TermWin.view_start;
1956		1986
1957	#ifdef XPM_BACKGROUND	1987	#ifdef XPM_BACKGROUND
1958	must_clear |= (bgPixmap.pixmap != None);	1988	must_clear |= (bgPixmap.pixmap != None);
1959	#endif	1989	#endif
1960	#ifdef TRANSPARENT	1990	#ifdef TRANSPARENT
1961	must_clear |= ((Options & Opt_transparent) && am_transparent);	1991	must_clear |= ((options & Opt_transparent) && am_transparent);
1962	#endif	1992	#endif
1963	ocrow = oldcursor.row; /* is there an old outline cursor on screen? */	1993	ocrow = oldcursor.row; /* is there an old outline cursor on screen? */
1964		1994
1965	/*	1995	/*
1966	* B: reverse any characters which are selected	1996	* B: reverse any characters which are selected
1967	*/	1997	*/
1968	scr_reverse_selection ();	1998	scr_reverse_selection ();
		1999	#if ENABLE_OVERLAY
		2000	scr_swap_overlay ();
		2001	#endif
1969		2002
1970	/*	2003	/*
1971	* C: set the cursor character (s)	2004	* C: set the cursor character (s)
1972	*/	2005	*/
1973	{	2006	{
…		…
1981	showcursor = 0;	2014	showcursor = 0;
1982	#endif	2015	#endif
1983		2016
1984	if (showcursor)	2017	if (showcursor)
1985	{	2018	{
		2019	int col = screen.cur.col;
		2020
		2021	while (col && screen.text[screen.cur.row + TermWin.saveLines][col] == NOCHAR)
		2022	col--;
		2023
1986	srp = &(screen.rend[screen.cur.row + TermWin.saveLines][screen.cur.col]);	2024	crp = &screen.rend[screen.cur.row + TermWin.saveLines][col];
1987		2025
1988	if (showcursor && TermWin.focus)	2026	if (showcursor && TermWin.focus)
1989	{	2027	{
1990	*srp ^= RS_RVid;	2028	*crp ^= RS_RVid;
1991	#ifndef NO_CURSORCOLOR	2029	#ifndef NO_CURSORCOLOR
1992	cc1 = *srp & (RS_fgMask | RS_bgMask);	2030	cc1 = *crp & (RS_fgMask | RS_bgMask);
1993	if (ISSET_PIXCOLOR (Color_cursor))	2031	if (ISSET_PIXCOLOR (Color_cursor))
1994	ccol1 = Color_cursor;	2032	ccol1 = Color_cursor;
1995	else	2033	else
1996	#ifdef CURSOR_COLOR_IS_RENDITION_COLOR	2034	#ifdef CURSOR_COLOR_IS_RENDITION_COLOR
1997	ccol1 = GET_FGCOLOR (rstyle);	2035	ccol1 = GET_FGCOLOR (rstyle);
…		…
2004	#ifdef CURSOR_COLOR_IS_RENDITION_COLOR	2042	#ifdef CURSOR_COLOR_IS_RENDITION_COLOR
2005	ccol2 = GET_BGCOLOR (rstyle);	2043	ccol2 = GET_BGCOLOR (rstyle);
2006	#else	2044	#else
2007	ccol2 = Color_bg;	2045	ccol2 = Color_bg;
2008	#endif	2046	#endif
2009	*srp = SET_FGCOLOR (*srp, ccol1);	2047	*crp = SET_FGCOLOR (*crp, ccol1);
2010	*srp = SET_BGCOLOR (*srp, ccol2);	2048	*crp = SET_BGCOLOR (*crp, ccol2);
2011	#endif	2049	#endif
2012	}	2050	}
2013	}	2051	}
2014		2052
2015	/* make sure no outline cursor is left around */	2053	/* make sure no outline cursor is left around */
…		…
2042	oldcursor.col = screen.cur.col;	2080	oldcursor.col = screen.cur.col;
2043	}	2081	}
2044	}	2082	}
2045	}	2083	}
2046		2084
		2085	rend_t *drp, *srp; /* drawn-rend-pointer, screen-rend-pointer */
		2086	text_t *dtp, *stp; /* drawn-text-pointer, screen-text-pointer */
2047	#ifndef NO_SLOW_LINK_SUPPORT	2087	#ifndef NO_SLOW_LINK_SUPPORT
2048	/*	2088	/*
2049	* D: CopyArea pass - very useful for slower links	2089	* D: CopyArea pass - very useful for slower links
2050	* This has been deliberately kept simple.	2090	* This has been deliberately kept simple.
2051	*/	2091	*/
…		…
2054	&& refresh_type == FAST_REFRESH && num_scr_allow && i	2094	&& refresh_type == FAST_REFRESH && num_scr_allow && i
2055	&& abs (i) < TermWin.nrow && !must_clear)	2095	&& abs (i) < TermWin.nrow && !must_clear)
2056	{	2096	{
2057	int16_t nits;	2097	int16_t nits;
2058	int j;	2098	int j;
2059	rend_t *drp2;
2060	text_t *dtp2;
2061	int len, wlen;	2099	int len, wlen;
2062		2100
2063	j = TermWin.nrow;	2101	j = TermWin.nrow;
2064	wlen = len = -1;	2102	wlen = len = -1;
2065	row = i > 0 ? 0 : j - 1;	2103	row = i > 0 ? 0 : j - 1;
2066	for (; j-- >= 0; row += (i > 0 ? 1 : -1))	2104	for (; j-- >= 0; row += (i > 0 ? 1 : -1))
2067	{	2105	{
2068	if (row + i >= 0 && row + i < TermWin.nrow && row + i != ocrow)	2106	if (row + i >= 0 && row + i < TermWin.nrow && row + i != ocrow)
2069	{	2107	{
2070	stp = screen.text[row + row_offset];	2108	text_t *stp = screen.text[row + row_offset];
2071	srp = screen.rend[row + row_offset];	2109	rend_t *srp = screen.rend[row + row_offset];
2072	dtp = drawn_text[row];	2110	text_t *dtp = drawn_text[row];
2073	dtp2 = drawn_text[row + i];	2111	text_t *dtp2 = drawn_text[row + i];
2074	drp = drawn_rend[row];	2112	rend_t *drp = drawn_rend[row];
2075	drp2 = drawn_rend[row + i];	2113	rend_t *drp2 = drawn_rend[row + i];
2076		2114
2077	for (nits = 0, col = TermWin.ncol; col--; )	2115	for (nits = 0, col = TermWin.ncol; col--; )
2078	if (stp[col] != dtp2[col] || srp[col] != drp2[col])	2116	if (stp[col] != dtp2[col] || srp[col] != drp2[col])
2079	nits--;	2117	nits--;
2080	else if (stp[col] != dtp[col] || srp[col] != drp[col])	2118	else if (stp[col] != dtp[col] || srp[col] != drp[col])
…		…
2100	{	2138	{
2101	/* also comes here at end if needed because of >= above */	2139	/* also comes here at end if needed because of >= above */
2102	if (wlen < len)	2140	if (wlen < len)
2103	SWAP_IT (wlen, len, int);	2141	SWAP_IT (wlen, len, int);
2104		2142
2105	D_SCREEN ((stderr, "rxvt_scr_refresh (): XCopyArea: %d -> %d (height: %d)", len + i, len, wlen - len + 1));
2106	XCopyArea (display->display, TermWin.vt, TermWin.vt,	2143	XCopyArea (display->display, TermWin.vt, TermWin.vt,
2107	TermWin.gc, 0, Row2Pixel (len + i),	2144	TermWin.gc, 0, Row2Pixel (len + i),
2108	(unsigned int)TermWin_TotalWidth (),	2145	(unsigned int)TermWin_TotalWidth (),
2109	(unsigned int)Height2Pixel (wlen - len + 1),	2146	(unsigned int)Height2Pixel (wlen - len + 1),
2110	0, Row2Pixel (len));	2147	0, Row2Pixel (len));
…		…
2117	/*	2154	/*
2118	* E: main pass across every character	2155	* E: main pass across every character
2119	*/	2156	*/
2120	for (row = 0; row < TermWin.nrow; row++)	2157	for (row = 0; row < TermWin.nrow; row++)
2121	{	2158	{
2122	stp = screen.text[row + row_offset];	2159	text_t *stp = screen.text[row + row_offset];
2123	srp = screen.rend[row + row_offset];	2160	rend_t *srp = screen.rend[row + row_offset];
2124	dtp = drawn_text[row];	2161	text_t *dtp = drawn_text[row];
2125	drp = drawn_rend[row];	2162	rend_t *drp = drawn_rend[row];
2126		2163
2127	/*	2164	/*
2128	* E2: OK, now the real pass	2165	* E2: OK, now the real pass
2129	*/	2166	*/
2130	int ypixel = (int)Row2Pixel (row);	2167	int ypixel = (int)Row2Pixel (row);
…		…
2160	if (stp[col] == NOCHAR)	2197	if (stp[col] == NOCHAR)
2161	{	2198	{
2162	dtp[col] = stp[col];	2199	dtp[col] = stp[col];
2163	drp[col] = rend;	2200	drp[col] = rend;
2164	count++;	2201	count++;
2165
2166	if (i) // only possible skip if char unchanged
2167	i++;	2202	i++;
2168		2203
2169	continue;	2204	continue;
2170	}	2205	}
2171		2206
2172	if (rend != srp[col])	2207	if (rend != srp[col])
…		…
2175	count++;	2210	count++;
2176		2211
2177	if (stp[col] != dtp[col]	2212	if (stp[col] != dtp[col]
2178	|| srp[col] != drp[col])	2213	|| srp[col] != drp[col])
2179	{	2214	{
2180	if (must_clear && (i++ > (count / 2)))	2215	if (must_clear && (i++ > count / 2))
2181	break;	2216	break;
2182		2217
2183	dtp[col] = stp[col];	2218	dtp[col] = stp[col];
2184	drp[col] = rend;	2219	drp[col] = rend;
2185	i = 0;	2220	i = 0;
2186	}	2221	}
2187	else if (must_clear || (stp[col] != ' ' && ++i >= 32))	2222	else if (must_clear || (stp[col] != ' ' && ++i >= 16))
2188	break;	2223	break;
2189	}	2224	}
2190		2225
2191	col--; /* went one too far. move back */	2226	col--; /* went one too far. move back */
2192	count -= i; /* dump any matching trailing chars */	2227	count -= i; /* dump any matching trailing chars */
		2228
		2229	// sometimes we optimize away the trailing NOCHAR's, add them back
		2230	while (i && text[count] == NOCHAR)
		2231	count++, i--;
2193		2232
2194	/*	2233	/*
2195	* Determine the attributes for the string	2234	* Determine the attributes for the string
2196	*/	2235	*/
2197	int fid = GET_FONT (rend);	2236	int fid = GET_FONT (rend);
…		…
2201	rend = GET_ATTR (rend);	2240	rend = GET_ATTR (rend);
2202		2241
2203	rvid = !!(rend & RS_RVid);	2242	rvid = !!(rend & RS_RVid);
2204		2243
2205	#ifndef NO_BOLD_UNDERLINE_REVERSE	2244	#ifndef NO_BOLD_UNDERLINE_REVERSE
2206	if (rend & RS_Bold && fore == Color_fg && !(Options & Opt_realBold))	2245	if (rend & RS_Bold && fore == Color_fg && !(options & Opt_realBold))
2207	{	2246	{
2208	if (ISSET_PIXCOLOR (Color_BD))	2247	if (ISSET_PIXCOLOR (Color_BD))
2209	fore = Color_BD;	2248	fore = Color_BD;
2210	else	2249	else
2211	rvid = !rvid;	2250	rvid = !rvid;
…		…
2283	*/	2322	*/
2284	if (showcursor)	2323	if (showcursor)
2285	{	2324	{
2286	if (TermWin.focus)	2325	if (TermWin.focus)
2287	{	2326	{
2288	srp = & (screen.rend[screen.cur.row + TermWin.saveLines]
2289	[screen.cur.col]);
2290	*srp ^= RS_RVid;	2327	*crp ^= RS_RVid;
2291	#ifndef NO_CURSORCOLOR	2328	#ifndef NO_CURSORCOLOR
2292	*srp = (*srp & ~ (RS_fgMask | RS_bgMask)) | cc1;	2329	*crp = (*crp & ~ (RS_fgMask | RS_bgMask)) | cc1;
2293	#endif	2330	#endif
2294	}	2331	}
2295	else if (oldcursor.row >= 0)	2332	else if (oldcursor.row >= 0)
2296	{	2333	{
2297	#ifndef NO_CURSORCOLOR	2334	#ifndef NO_CURSORCOLOR
2298	if (ISSET_PIXCOLOR (Color_cursor))	2335	if (ISSET_PIXCOLOR (Color_cursor))
2299	XSetForeground (display->display, TermWin.gc, PixColors[Color_cursor]);	2336	XSetForeground (display->display, TermWin.gc, pix_colors[Color_cursor]);
2300	#endif	2337	#endif
2301	int cursorwidth = 1;	2338	int cursorwidth = 1;
2302	while (oldcursor.col + cursorwidth < TermWin.ncol	2339	while (oldcursor.col + cursorwidth < TermWin.ncol
2303	&& drawn_text[oldcursor.row][oldcursor.col + cursorwidth] == NOCHAR)	2340	&& drawn_text[oldcursor.row][oldcursor.col + cursorwidth] == NOCHAR)
2304	cursorwidth++;	2341	cursorwidth++;
…		…
2312	}	2349	}
2313		2350
2314	/*	2351	/*
2315	* H: cleanup selection	2352	* H: cleanup selection
2316	*/	2353	*/
		2354	#if ENABLE_OVERLAY
		2355	scr_swap_overlay ();
		2356	#endif
2317	scr_reverse_selection ();	2357	scr_reverse_selection ();
2318		2358
2319	if (refresh_type & SMOOTH_REFRESH)	2359	if (refresh_type & SMOOTH_REFRESH)
2320	XFlush (display->display);	2360	XFlush (display->display);
2321		2361
…		…
2356		2396
2357	num_scr_allow = 0;	2397	num_scr_allow = 0;
2358	want_refresh = 1;	2398	want_refresh = 1;
2359		2399
2360	#ifdef TRANSPARENT	2400	#ifdef TRANSPARENT
2361	if ((Options & Opt_transparent) && (am_pixmap_trans == 0))	2401	if ((options & Opt_transparent) && (am_pixmap_trans == 0))
2362	{	2402	{
2363	int i;	2403	int i;
2364		2404
2365	if (! (Options & Opt_transparent_all))	2405	if (! (options & Opt_transparent_all))
2366	i = 0;	2406	i = 0;
2367	else	2407	else
2368	i = (int) (sizeof (TermWin.parent) / sizeof (Window));	2408	i = (int) (sizeof (TermWin.parent) / sizeof (Window));
2369		2409
2370	while (i--)	2410	while (i--)
…		…
2447	* -TermWin.nscrolled <= (selection row) <= TermWin.nrow - 1	2487	* -TermWin.nscrolled <= (selection row) <= TermWin.nrow - 1
2448	*/	2488	*/
2449	void	2489	void
2450	rxvt_term::selection_check (int check_more)	2490	rxvt_term::selection_check (int check_more)
2451	{	2491	{
2452	row_col_t pos;	2492	row_col_t pos;
2453		2493
2454	if (!selection.op)	2494	if (!selection.op)
2455	return;	2495	return;
2456		2496
2457	pos.row = pos.col = 0;	2497	pos.row = pos.col = 0;
…		…
2484	rxvt_term::paste (const unsigned char *data, unsigned int len)	2524	rxvt_term::paste (const unsigned char *data, unsigned int len)
2485	{	2525	{
2486	unsigned int i, j, n;	2526	unsigned int i, j, n;
2487	unsigned char *ds = (unsigned char *)rxvt_malloc (PROP_SIZE);	2527	unsigned char *ds = (unsigned char *)rxvt_malloc (PROP_SIZE);
2488		2528
2489	#if 0
2490	/* a paste should act like the user is typing, so check scrollTtyKeypress */
2491	ZERO_SCROLLBACK (r);
2492	#endif
2493
2494	/* convert normal newline chars into common keyboard Return key sequence */	2529	/* convert normal newline chars into common keyboard Return key sequence */
2495	for (i = 0; i < len; i += PROP_SIZE)	2530	for (i = 0; i < len; i += PROP_SIZE)
2496	{	2531	{
2497	n = min (len - i, PROP_SIZE);	2532	n = min (len - i, PROP_SIZE);
2498	MEMCPY (ds, data + i, n);	2533	memcpy (ds, data + i, n);
2499		2534
2500	for (j = 0; j < n; j++)	2535	for (j = 0; j < n; j++)
2501	if (ds[j] == C0_LF)	2536	if (ds[j] == C0_LF)
2502	ds[j] = C0_CR;	2537	ds[j] = C0_CR;
2503		2538
…		…
2516	rxvt_term::selection_paste (Window win, Atom prop, bool delete_prop)	2551	rxvt_term::selection_paste (Window win, Atom prop, bool delete_prop)
2517	{	2552	{
2518	long nread = 0;	2553	long nread = 0;
2519	unsigned long bytes_after;	2554	unsigned long bytes_after;
2520	XTextProperty ct;	2555	XTextProperty ct;
2521
2522	D_SELECT ((stderr, "rxvt_selection_paste (%08lx, %lu, %d), wait=%2x", win, (unsigned long)prop, (int)delete_prop, selection_wait));
2523		2556
2524	if (prop == None) /* check for failed XConvertSelection */	2557	if (prop == None) /* check for failed XConvertSelection */
2525	{	2558	{
2526	if ((selection_type & Sel_CompoundText))	2559	if ((selection_type & Sel_CompoundText))
2527	{	2560	{
…		…
2554	&ct.nitems, &bytes_after,	2587	&ct.nitems, &bytes_after,
2555	&ct.value) != Success)	2588	&ct.value) != Success)
2556	break;	2589	break;
2557		2590
2558	if (ct.encoding == 0)	2591	if (ct.encoding == 0)
		2592	break;
		2593
		2594	if (ct.encoding == xa[XA_INCR])
2559	{	2595	{
2560	D_SELECT ((stderr, "rxvt_selection_paste: property didn't exist!"));	2596	// INCR selection, start handshake
		2597	XDeleteProperty (display->display, win, prop);
		2598	selection_wait = Sel_incr;
		2599	incr_ev.start (NOW + 10);
2561	break;	2600	break;
2562	}	2601	}
2563		2602
2564	if (ct.value == NULL)	2603	if (ct.value == NULL)
2565	{
2566	D_SELECT ((stderr, "rxvt_selection_paste: property shooting blanks!"));
2567	continue;	2604	continue;
2568	}
2569		2605
2570	if (ct.nitems == 0)	2606	if (ct.nitems == 0)
2571	{	2607	{
2572	D_SELECT ((stderr, "rxvt_selection_paste: property empty - also INCR end"));
2573
2574	if (selection_wait == Sel_normal && nread == 0	2608	if (selection_wait == Sel_normal && nread == 0
2575	&& (win != display->root || prop != XA_CUT_BUFFER0)) // avoid recursion	2609	&& (win != display->root || prop != XA_CUT_BUFFER0)) // avoid recursion
2576	{	2610	{
2577	/*	2611	/*
2578	* pass through again trying CUT_BUFFER0 if we've come from	2612	* pass through again trying CUT_BUFFER0 if we've come from
2579	* XConvertSelection () but nothing was presented	2613	* XConvertSelection () but nothing was presented
2580	*/	2614	*/
2581	D_SELECT ((stderr, "rxvt_selection_request: pasting CUT_BUFFER0"));
2582	selection_paste (display->root, XA_CUT_BUFFER0, False);	2615	selection_paste (display->root, XA_CUT_BUFFER0, False);
2583	}	2616	}
2584		2617
2585	nread = -1; /* discount any previous stuff */	2618	nread = -1; /* discount any previous stuff */
2586	break;	2619	break;
…		…
2591	char **cl;	2624	char **cl;
2592	int cr;	2625	int cr;
2593	if (XmbTextPropertyToTextList (display->display, &ct, &cl, &cr) >= 0 && cl)	2626	if (XmbTextPropertyToTextList (display->display, &ct, &cl, &cr) >= 0 && cl)
2594	{	2627	{
2595	for (int i = 0; i < cr; i++)	2628	for (int i = 0; i < cr; i++)
2596	paste ((unsigned char *)cl[i], STRLEN (cl[i]));	2629	paste ((unsigned char *)cl[i], strlen (cl[i]));
2597		2630
2598	XFreeStringList (cl);	2631	XFreeStringList (cl);
2599	}	2632	}
2600	else	2633	else
2601	paste (ct.value, ct.nitems);	2634	paste (ct.value, ct.nitems);
…		…
2610	XFree (ct.value);	2643	XFree (ct.value);
2611		2644
2612	if (selection_wait == Sel_normal)	2645	if (selection_wait == Sel_normal)
2613	selection_wait = Sel_none;	2646	selection_wait = Sel_none;
2614		2647
2615	D_SELECT ((stderr, "rxvt_selection_paste: bytes written: %ld", nread));
2616	return (int)nread;	2648	return (int)nread;
2617	}	2649	}
2618		2650
2619	void	2651	void
2620	rxvt_term::incr_cb (time_watcher &w)	2652	rxvt_term::incr_cb (time_watcher &w)
…		…
2628	* INCR support originally provided by Paul Sheer <psheer@obsidian.co.za>	2660	* INCR support originally provided by Paul Sheer <psheer@obsidian.co.za>
2629	*/	2661	*/
2630	void	2662	void
2631	rxvt_term::selection_property (Window win, Atom prop)	2663	rxvt_term::selection_property (Window win, Atom prop)
2632	{	2664	{
2633	int reget_time = 0;	2665	if (prop == None || selection_wait != Sel_incr)
2634
2635	if (prop == None)
2636	return;	2666	return;
2637		2667
2638	D_SELECT ((stderr, "rxvt_selection_property (%08lx, %lu)", win, (unsigned long)prop));
2639	if (selection_wait == Sel_normal)
2640	{
2641	int a, afmt;
2642	Atom atype;
2643	unsigned long bytes_after, nitems;
2644	unsigned char *s = NULL;
2645
2646	a = XGetWindowProperty (display->display, win, prop, 0L, 1L, False,
2647	xa[XA_INCR], &atype, &afmt, &nitems,
2648	&bytes_after, &s);
2649	if (s)
2650	XFree (s);
2651	if (a != Success)
2652	return;
2653
2654	#ifndef __CYGWIN32__
2655	if (atype == xa[XA_INCR])
2656	{ /* start an INCR transfer */
2657	D_SELECT ((stderr, "rxvt_selection_property: INCR: starting transfer"));
2658	XDeleteProperty (display->display, win, prop);
2659	XFlush (display->display);
2660	reget_time = 1;
2661	selection_wait = Sel_incr;
2662	}
2663	#endif
2664
2665	}
2666	else if (selection_wait == Sel_incr)
2667	{
2668	reget_time = 1;
2669
2670	if (selection_paste (win, prop, True) == -1)	2668	if (selection_paste (win, prop, 1) > 0)
2671	{
2672	D_SELECT ((stderr, "rxvt_selection_property: INCR: clean end"));
2673	selection_wait = Sel_none;
2674	incr_ev.stop ();
2675	}
2676	}
2677	if (reget_time) /* received more data so reget time */
2678	incr_ev.start (NOW + 10);	2669	incr_ev.start (NOW + 10);
		2670	else
		2671	{
		2672	selection_wait = Sel_none;
		2673	incr_ev.stop ();
		2674	}
2679	}	2675	}
2680		2676
2681	/* ------------------------------------------------------------------------- */	2677	/* ------------------------------------------------------------------------- */
2682	/*	2678	/*
2683	* Request the current selection:	2679	* Request the current selection:
…		…
2689	* EXT: button 2 release	2685	* EXT: button 2 release
2690	*/	2686	*/
2691	void	2687	void
2692	rxvt_term::selection_request (Time tm, int x, int y)	2688	rxvt_term::selection_request (Time tm, int x, int y)
2693	{	2689	{
2694	D_SELECT ((stderr, "rxvt_selection_request (%lu, %d, %d)", tm, x, y));
2695
2696	if (x < 0 || x >= TermWin.width || y < 0 || y >= TermWin.height)	2690	if (x < 0 || x >= TermWin.width || y < 0 || y >= TermWin.height)
2697	return; /* outside window */	2691	return; /* outside window */
2698		2692
2699	if (selection.text)	2693	if (selection.text)
2700	{ /* internal selection */	2694	{ /* internal selection */
2701	D_SELECT ((stderr, "rxvt_selection_request: pasting internal"));
2702	char *str = rxvt_wcstombs (selection.text, selection.len);	2695	char *str = rxvt_wcstombs (selection.text, selection.len);
2703	paste ((unsigned char *)str, strlen (str));	2696	paste ((unsigned char *)str, strlen (str));
2704	free (str);	2697	free (str);
2705	return;	2698	return;
2706	}	2699	}
…		…
2725		2718
2726	}	2719	}
2727	}	2720	}
2728		2721
2729	selection_wait = Sel_none; /* don't loop in rxvt_selection_paste () */	2722	selection_wait = Sel_none; /* don't loop in rxvt_selection_paste () */
2730	D_SELECT ((stderr, "rxvt_selection_request: pasting CUT_BUFFER0"));
2731	selection_paste (display->root, XA_CUT_BUFFER0, False);	2723	selection_paste (display->root, XA_CUT_BUFFER0, False);
2732	}	2724	}
2733		2725
2734	int	2726	int
2735	rxvt_term::selection_request_other (Atom target, int selnum)	2727	rxvt_term::selection_request_other (Atom target, int selnum)
…		…
2748	else	2740	else
2749	sel = xa[XA_CLIPBOARD];	2741	sel = xa[XA_CLIPBOARD];
2750		2742
2751	if (XGetSelectionOwner (display->display, sel) != None)	2743	if (XGetSelectionOwner (display->display, sel) != None)
2752	{	2744	{
2753	D_SELECT ((stderr, "rxvt_selection_request_other: pasting %s", debug_xa_names[selnum]));
2754	XConvertSelection (display->display, sel, target, xa[XA_VT_SELECTION],	2745	XConvertSelection (display->display, sel, target, xa[XA_VT_SELECTION],
2755	TermWin.vt, selection_request_time);	2746	TermWin.vt, selection_request_time);
2756	return 1;	2747	return 1;
2757	}	2748	}
2758		2749
…		…
2765	* EXT: SelectionClear	2756	* EXT: SelectionClear
2766	*/	2757	*/
2767	void	2758	void
2768	rxvt_term::selection_clear ()	2759	rxvt_term::selection_clear ()
2769	{	2760	{
2770	D_SELECT ((stderr, "rxvt_selection_clear ()"));
2771
2772	want_refresh = 1;	2761	want_refresh = 1;
2773	free (selection.text);	2762	free (selection.text);
2774	selection.text = NULL;	2763	selection.text = NULL;
2775	selection.len = 0;	2764	selection.len = 0;
2776	CLEAR_SELECTION ();	2765	CLEAR_SELECTION ();
…		…
2789	{	2778	{
2790	int i, col, end_col, row, end_row;	2779	int i, col, end_col, row, end_row;
2791	wchar_t *new_selection_text;	2780	wchar_t *new_selection_text;
2792	text_t *t;	2781	text_t *t;
2793		2782
2794	D_SELECT ((stderr, "rxvt_selection_make (): selection.op=%d, selection.clicks=%d", selection.op, selection.clicks));
2795	switch (selection.op)	2783	switch (selection.op)
2796	{	2784	{
2797	case SELECTION_CONT:	2785	case SELECTION_CONT:
2798	break;	2786	break;
2799	case SELECTION_INIT:	2787	case SELECTION_INIT:
…		…
2821	int ofs = 0;	2809	int ofs = 0;
2822	int extra = 0;	2810	int extra = 0;
2823		2811
2824	for (; row <= end_row; row++, col = 0)	2812	for (; row <= end_row; row++, col = 0)
2825	{	2813	{
2826	t = &(screen.text[row][col]);	2814	t = &screen.text[row][col];
2827		2815
2828	end_col = screen.tlen[row];	2816	end_col = screen.tlen[row];
2829		2817
2830	if (end_col == -1)	2818	if (end_col == -1)
2831	end_col = TermWin.ncol;	2819	end_col = TermWin.ncol;
…		…
2895	XFree (ct.value);	2883	XFree (ct.value);
2896	}	2884	}
2897	#endif	2885	#endif
2898		2886
2899	selection_time = tm;	2887	selection_time = tm;
2900	D_SELECT ((stderr, "rxvt_selection_make (): selection.len=%d", selection.len));
2901	}	2888	}
2902		2889
2903	/* ------------------------------------------------------------------------- */	2890	/* ------------------------------------------------------------------------- */
2904	/*	2891	/*
2905	* Mark or select text based upon number of clicks: 1, 2, or 3	2892	* Mark or select text based upon number of clicks: 1, 2, or 3
2906	* EXT: button 1 press	2893	* EXT: button 1 press
2907	*/	2894	*/
2908	void	2895	void
2909	rxvt_term::selection_click (int clicks, int x, int y)	2896	rxvt_term::selection_click (int clicks, int x, int y)
2910	{	2897	{
2911	D_SELECT ((stderr, "rxvt_selection_click (%d, %d, %d)", clicks, x, y));
2912
2913	clicks = ((clicks - 1) % 3) + 1;	2898	clicks = ((clicks - 1) % 3) + 1;
2914	selection.clicks = clicks; /* save clicks so extend will work */	2899	selection.clicks = clicks; /* save clicks so extend will work */
2915		2900
2916	selection_start_colrow (Pixel2Col (x), Pixel2Row (y));	2901	selection_start_colrow (Pixel2Col (x), Pixel2Row (y));
2917		2902
…		…
2959	* We now only find out the boundary in one direction	2944	* We now only find out the boundary in one direction
2960	*/	2945	*/
2961		2946
2962	/* what do we want: spaces/tabs are delimiters or cutchars or non-cutchars */	2947	/* what do we want: spaces/tabs are delimiters or cutchars or non-cutchars */
2963	#define DELIMIT_TEXT(x) \	2948	#define DELIMIT_TEXT(x) \
2964	(unicode::is_space (x) ? 2 : (x) <= 0xff && !!STRCHR (rs[Rs_cutchars], (x)))	2949	(unicode::is_space (x) ? 2 : (x) <= 0xff && !!strchr (rs[Rs_cutchars], (x)))
2965	#define DELIMIT_REND(x) 1	2950	#define DELIMIT_REND(x) 1
2966		2951
2967	void	2952	void
2968	rxvt_term::selection_delimit_word (enum page_dirn dirn, const row_col_t *mark, row_col_t *ret)	2953	rxvt_term::selection_delimit_word (enum page_dirn dirn, const row_col_t *mark, row_col_t *ret)
2969	{	2954	{
…		…
2987		2972
2988	row = mark->row + TermWin.saveLines;	2973	row = mark->row + TermWin.saveLines;
2989	col = mark->col;	2974	col = mark->col;
2990	MAX_IT (col, 0);	2975	MAX_IT (col, 0);
2991	/* find the edge of a word */	2976	/* find the edge of a word */
2992	stp = & (screen.text[row][col]);	2977	stp = &screen.text[row][col];
2993	w1 = DELIMIT_TEXT (*stp);	2978	w1 = DELIMIT_TEXT (*stp);
2994		2979
2995	srp = (&screen.rend[row][col]);	2980	srp = &screen.rend[row][col];
2996	w2 = DELIMIT_REND (*srp);	2981	w2 = DELIMIT_REND (*srp);
2997		2982
2998	for (;;)	2983	for (;;)
2999	{	2984	{
3000	for (; col != bound.col; col += dirnadd)	2985	for (; col != bound.col; col += dirnadd)
…		…
3034	}	3019	}
3035	break;	3020	break;
3036	}	3021	}
3037		3022
3038	Old_Word_Selection_You_Die:	3023	Old_Word_Selection_You_Die:
3039	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));
3040
3041	if (dirn == DN)	3024	if (dirn == DN)
3042	col++; /* put us on one past the end */	3025	col++; /* put us on one past the end */
3043		3026
3044	/* Poke the values back in */	3027	/* Poke the values back in */
3045	ret->row = row - TermWin.saveLines;	3028	ret->row = row - TermWin.saveLines;
…		…
3079	/* select nothing */	3062	/* select nothing */
3080	selection.beg.row = selection.end.row = 0;	3063	selection.beg.row = selection.end.row = 0;
3081	selection.beg.col = selection.end.col = 0;	3064	selection.beg.col = selection.end.col = 0;
3082	selection.clicks = 4;	3065	selection.clicks = 4;
3083	want_refresh = 1;	3066	want_refresh = 1;
3084	D_SELECT ((stderr, "rxvt_selection_extend () selection.clicks = 4"));
3085	return;	3067	return;
3086	}	3068	}
3087		3069
3088	if (selection.clicks == 4)	3070	if (selection.clicks == 4)
3089	selection.clicks = 1;	3071	selection.clicks = 1;
…		…
3104	int end_col;	3086	int end_col;
3105	row_col_t pos;	3087	row_col_t pos;
3106	enum {	3088	enum {
3107	LEFT, RIGHT	3089	LEFT, RIGHT
3108	} closeto = RIGHT;	3090	} closeto = RIGHT;
3109
3110	D_SELECT ((stderr, "rxvt_selection_extend_colrow (c:%d, r:%d, %d, %d) clicks:%d, op:%d", col, row, button3, buttonpress, selection.clicks, selection.op));
3111	D_SELECT ((stderr, "rxvt_selection_extend_colrow () ENT 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));
3112		3091
3113	want_refresh = 1;	3092	want_refresh = 1;
3114	switch (selection.op)	3093	switch (selection.op)
3115	{	3094	{
3116	case SELECTION_INIT:	3095	case SELECTION_INIT:
…		…
3138	&& selection.beg.row == selection.end.row	3117	&& selection.beg.row == selection.end.row
3139	&& selection.beg.row != selection.mark.row)	3118	&& selection.beg.row != selection.mark.row)
3140	{	3119	{
3141	selection.beg.col = selection.end.col = selection.mark.col;	3120	selection.beg.col = selection.end.col = selection.mark.col;
3142	selection.beg.row = selection.end.row = selection.mark.row;	3121	selection.beg.row = selection.end.row = selection.mark.row;
3143	D_SELECT ((stderr, "rxvt_selection_extend_colrow () ENT2 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));
3144	}	3122	}
3145		3123
3146	pos.col = col;	3124	pos.col = col;
3147	pos.row = row;	3125	pos.row = row;
3148		3126
…		…
3241	selection_delimit_word (UP, & (selection.beg), & (selection.beg));	3219	selection_delimit_word (UP, & (selection.beg), & (selection.beg));
3242	selection_delimit_word (DN, & (selection.end), & (selection.end));	3220	selection_delimit_word (DN, & (selection.end), & (selection.end));
3243	}	3221	}
3244	else if (selection.clicks == 3)	3222	else if (selection.clicks == 3)
3245	{	3223	{
3246	#ifndef NO_FRILLS	3224	#if ENABLE_FRILLS
3247	if ((Options & Opt_tripleclickwords))	3225	if ((options & Opt_tripleclickwords))
3248	{	3226	{
3249	int end_row;	3227	int end_row;
3250		3228
3251	selection_delimit_word (UP, & (selection.beg), & (selection.beg));	3229	selection_delimit_word (UP, & (selection.beg), & (selection.beg));
3252	end_row = screen.tlen[selection.mark.row + TermWin.saveLines];	3230	end_row = screen.tlen[selection.mark.row + TermWin.saveLines];
…		…
3277	if (button3 && buttonpress)	3255	if (button3 && buttonpress)
3278	{ /* mark may need to be changed */	3256	{ /* mark may need to be changed */
3279	if (closeto == LEFT)	3257	if (closeto == LEFT)
3280	{	3258	{
3281	selection.mark.row = selection.end.row;	3259	selection.mark.row = selection.end.row;
3282	selection.mark.col = selection.end.col	3260	selection.mark.col = selection.end.col - (selection.clicks == 2);
3283	- (selection.clicks == 2);
3284	}	3261	}
3285	else	3262	else
3286	{	3263	{
3287	selection.mark.row = selection.beg.row;	3264	selection.mark.row = selection.beg.row;
3288	selection.mark.col = selection.beg.col;	3265	selection.mark.col = selection.beg.col;
3289	}	3266	}
3290	}	3267	}
3291	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));
3292	}	3268	}
3293		3269
3294	#ifndef NO_FRILLS	3270	#if ENABLE_FRILLS
3295	void	3271	void
3296	rxvt_term::selection_remove_trailing_spaces ()	3272	rxvt_term::selection_remove_trailing_spaces ()
3297	{	3273	{
3298	int32_t end_col, end_row;	3274	int32_t end_col, end_row;
3299	text_t *stp;	3275	text_t *stp;
…		…
3388	(8 * sizeof (target_list[0])), PropModeReplace,	3364	(8 * sizeof (target_list[0])), PropModeReplace,
3389	(unsigned char *)target_list,	3365	(unsigned char *)target_list,
3390	target - target_list);	3366	target - target_list);
3391	ev.property = rq.property;	3367	ev.property = rq.property;
3392	}	3368	}
		3369	#if TODO // TODO
3393	else if (rq.target == xa[XA_MULTIPLE])	3370	else if (rq.target == xa[XA_MULTIPLE])
3394	{	3371	{
3395	/* TODO: Handle MULTIPLE */	3372	/* TODO: Handle MULTIPLE */
3396	}	3373	}
		3374	#endif
3397	else if (rq.target == xa[XA_TIMESTAMP] && selection.text)	3375	else if (rq.target == xa[XA_TIMESTAMP] && selection.text)
3398	{	3376	{
3399	XChangeProperty (display->display, rq.requestor, rq.property, XA_INTEGER,	3377	XChangeProperty (display->display, rq.requestor, rq.property, XA_INTEGER,
3400	(8 * sizeof (Time)), PropModeReplace,	3378	(8 * sizeof (Time)), PropModeReplace,
3401	(unsigned char *)&selection_time, 1);	3379	(unsigned char *)&selection_time, 1);
…		…
3482	}	3460	}
3483		3461
3484	/* ------------------------------------------------------------------------- */	3462	/* ------------------------------------------------------------------------- */
3485	#ifdef USE_XIM	3463	#ifdef USE_XIM
3486	void	3464	void
3487	rxvt_term::im_set_position (XPoint *pos)	3465	rxvt_term::im_set_position (XPoint &pos)
3488	{	3466	{
3489	XWindowAttributes xwa;	3467	XWindowAttributes xwa;
3490		3468
3491	XGetWindowAttributes (display->display, TermWin.vt, &xwa);	3469	XGetWindowAttributes (display->display, TermWin.vt, &xwa);
		3470
3492	pos->x = Col2Pixel (screen.cur.col) + xwa.x;	3471	pos.x = xwa.x + Col2Pixel (screen.cur.col);
3493	pos->y = Height2Pixel ((screen.cur.row + 1)) + xwa.y - TermWin.lineSpace;	3472	pos.y = xwa.y + Height2Pixel (screen.cur.row) + TermWin.fbase;
3494	}	3473	}
3495
3496	#endif	3474	#endif
		3475
		3476	#if ENABLE_OVERLAY
		3477	void
		3478	rxvt_term::scr_overlay_new (int x, int y, int w, int h)
		3479	{
		3480	if (TermWin.nrow < 3 || TermWin.ncol < 3)
		3481	return;
		3482
		3483	want_refresh = 1;
		3484
		3485	scr_overlay_off ();
		3486
		3487	if (x < 0) x = TermWin.ncol - w;
		3488	if (y < 0) y = TermWin.nrow - h;
		3489
		3490	// make space for border
		3491	w += 2; MIN_IT (w, TermWin.ncol);
		3492	h += 2; MIN_IT (h, TermWin.nrow);
		3493
		3494	x -= 1; MAX_IT (x, 0);
		3495	y -= 1; MAX_IT (y, 0);
		3496
		3497	MIN_IT (x, TermWin.ncol - w);
		3498	MIN_IT (y, TermWin.nrow - h);
		3499
		3500	ov_x = x; ov_y = y;
		3501	ov_w = w; ov_h = h;
		3502
		3503	ov_text = new text_t *[h];
		3504	ov_rend = new rend_t *[h];
		3505
		3506	for (y = 0; y < h; y++)
		3507	{
		3508	text_t *tp = ov_text[y] = new text_t[w];
		3509	rend_t *rp = ov_rend[y] = new rend_t[w];
		3510
		3511	text_t t0, t1, t2;
		3512	rend_t r = SET_BGCOLOR (SET_FGCOLOR (RS_None, Color_bg), Color_fg);
		3513
		3514	if (y == 0)
		3515	t0 = 0x2554, t1 = 0x2550, t2 = 0x2557;
		3516	else if (y < h - 1)
		3517	t0 = 0x2551, t1 = 0x0020, t2 = 0x2551;
		3518	else
		3519	t0 = 0x255a, t1 = 0x2550, t2 = 0x255d;
		3520
		3521	*tp++ = t0;
		3522	*rp++ = r;
		3523
		3524	for (x = w - 2; x > 0; --x)
		3525	{
		3526	*tp++ = t1;
		3527	*rp++ = r;
		3528	}
		3529
		3530	*tp = t2;
		3531	*rp = r;
		3532	}
		3533	}
		3534
		3535	void
		3536	rxvt_term::scr_overlay_off ()
		3537	{
		3538	if (!ov_text)
		3539	return;
		3540
		3541	want_refresh = 1;
		3542
		3543	for (int y = 0; y < ov_h; y++)
		3544	{
		3545	delete [] ov_text[y];
		3546	delete [] ov_rend[y];
		3547	}
		3548
		3549	delete [] ov_text; ov_text = 0;
		3550	delete [] ov_rend; ov_rend = 0;
		3551	}
		3552
		3553	void
		3554	rxvt_term::scr_overlay_set (int x, int y, text_t text, rend_t rend)
		3555	{
		3556	if (!ov_text || x >= ov_w - 2 || y >= ov_h)
		3557	return;
		3558
		3559	x++, y++;
		3560
		3561	ov_text[y][x] = text;
		3562	ov_rend[y][x] = rend;
		3563	}
		3564
		3565	void
		3566	rxvt_term::scr_overlay_set (int x, int y, const char *s)
		3567	{
		3568	while (*s)
		3569	scr_overlay_set (x++, y, *s++);
		3570	}
		3571
		3572	void
		3573	rxvt_term::scr_swap_overlay ()
		3574	{
		3575	if (!ov_text)
		3576	return;
		3577
		3578	int row_offset = ov_y + TermWin.saveLines - TermWin.view_start;
		3579
		3580	// swap screen mem with overlay
		3581	for (int y = ov_h; y--; )
		3582	{
		3583	text_t *t1 = ov_text[y];
		3584	rend_t *r1 = ov_rend[y];
		3585
		3586	text_t *t2 = screen.text[y + row_offset] + ov_x;
		3587	rend_t *r2 = screen.rend[y + row_offset] + ov_x;
		3588
		3589	for (int x = ov_w; x--; )
		3590	{
		3591	text_t t = *t1; *t1++ = *t2; *t2++ = t;
		3592	rend_t r = *r1; *r1++ = *r2; *r2++ = SET_FONT (r, TermWin.fontset->find_font (t, false));
		3593	}
		3594	}
		3595	}
		3596
		3597	#endif
3497	/* ------------------------------------------------------------------------- */	3598	/* ------------------------------------------------------------------------- */

Diff Legend

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