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

Diff Legend

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