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.129 by root, Wed Aug 25 03:52:09 2004 UTC vs.
Revision 1.167 by root, Fri Aug 5 16:42:44 2005 UTC

…		…
28	#include "rxvt.h" /* NECESSARY */	28	#include "rxvt.h" /* NECESSARY */
29		29
30	#include <X11/Xmd.h> /* get the typedef for CARD32 */	30	#include <X11/Xmd.h> /* get the typedef for CARD32 */
31		31
32	#include <inttypes.h>	32	#include <inttypes.h>
33	#include <wchar.h>
34		33
35	#include "salloc.C" // HACK, should be a seperate compile!	34	#include "salloc.C" // HACK, should be a seperate compile!
36		35
37	inline void fill_text (text_t *start, text_t value, int len)	36	inline void fill_text (text_t *start, text_t value, int len)
38	{	37	{
39	while (len--)	38	while (len--)
40	*start++ = value;	39	*start++ = value;
41	}	40	}
42		41
43	/* ------------------------------------------------------------------------- */	42	/* ------------------------------------------------------------------------- */
44	#define PROP_SIZE 16384	43	#define PROP_SIZE 256*1024
		44	#define PASTE_SIZE 32768
45	#define TABSIZE 8 /* default tab size */	45	#define TABSIZE 8 /* default tab size */
46		46
47	/* ------------------------------------------------------------------------- *	47	/* ------------------------------------------------------------------------- *
48	* GENERAL SCREEN AND SELECTION UPDATE ROUTINES *	48	* GENERAL SCREEN AND SELECTION UPDATE ROUTINES *
49	* ------------------------------------------------------------------------- */	49	* ------------------------------------------------------------------------- */
…		…
202	/*	202	/*
203	* 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
204	* 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
205	*/	205	*/
206	screen.text = (text_t **)rxvt_calloc (total_rows, sizeof (text_t *));	206	screen.text = (text_t **)rxvt_calloc (total_rows, sizeof (text_t *));
207	buf_text = (text_t **)rxvt_calloc (total_rows, sizeof (text_t *));	207	buf_text = (text_t **)rxvt_calloc (total_rows, sizeof (text_t *));
208	drawn_text = (text_t **)rxvt_calloc (nrow, sizeof (text_t *));	208	drawn_text = (text_t **)rxvt_calloc (nrow, sizeof (text_t *));
209	swap.text = (text_t **)rxvt_calloc (nrow, sizeof (text_t *));	209	swap.text = (text_t **)rxvt_calloc (nrow, sizeof (text_t *));
210		210
211	screen.tlen = (int16_t *)rxvt_calloc (total_rows, sizeof (int16_t));	211	screen.tlen = (int16_t *)rxvt_calloc (total_rows, sizeof (int16_t));
212	swap.tlen = (int16_t *)rxvt_calloc (nrow, sizeof (int16_t));	212	swap.tlen = (int16_t *)rxvt_calloc (nrow, sizeof (int16_t));
213		213
214	screen.rend = (rend_t **)rxvt_calloc (total_rows, sizeof (rend_t *));	214	screen.rend = (rend_t **)rxvt_calloc (total_rows, sizeof (rend_t *));
215	buf_rend = (rend_t **)rxvt_calloc (total_rows, sizeof (rend_t *));	215	buf_rend = (rend_t **)rxvt_calloc (total_rows, sizeof (rend_t *));
216	drawn_rend = (rend_t **)rxvt_calloc (nrow, sizeof (rend_t *));	216	drawn_rend = (rend_t **)rxvt_calloc (nrow, sizeof (rend_t *));
217	swap.rend = (rend_t **)rxvt_calloc (nrow, sizeof (rend_t *));	217	swap.rend = (rend_t **)rxvt_calloc (nrow, sizeof (rend_t *));
218		218
219	for (p = 0; p < nrow; p++)	219	for (p = 0; p < nrow; p++)
220	{	220	{
221	q = p + TermWin.saveLines;	221	q = p + TermWin.saveLines;
222	scr_blank_screen_mem (screen.text, screen.rend, q, DEFAULT_RSTYLE);	222	scr_blank_screen_mem (screen.text, screen.rend, q, DEFAULT_RSTYLE);
…		…
293	ralloc->free (drawn_rend[p]);	293	ralloc->free (drawn_rend[p]);
294	}	294	}
295		295
296	/* we have fewer rows so fix up cursor position */	296	/* we have fewer rows so fix up cursor position */
297	MIN_IT (screen.cur.row, (int32_t)nrow - 1);	297	MIN_IT (screen.cur.row, (int32_t)nrow - 1);
298	MIN_IT (swap.cur.row, (int32_t)nrow - 1);
299		298
300	scr_reset_realloc (); /* realloc _last_ */	299	scr_reset_realloc (); /* realloc _last_ */
301	}	300	}
302	else if (nrow > prev_nrow)	301	else if (nrow > prev_nrow)
303	{	302	{
…		…
334	scr_scroll_text (0, (int)nrow - 1, -k, 1);	333	scr_scroll_text (0, (int)nrow - 1, -k, 1);
335	screen.cur.row += k;	334	screen.cur.row += k;
336	screen.s_cur.row += k;	335	screen.s_cur.row += k;
337	TermWin.nscrolled -= k;	336	TermWin.nscrolled -= k;
338	}	337	}
		338
339	#ifdef DEBUG_STRICT	339	#ifdef DEBUG_STRICT
340	assert (screen.cur.row < TermWin.nrow);	340	assert (screen.cur.row < TermWin.nrow);
341	assert (swap.cur.row < TermWin.nrow);
342	#else /* drive with your eyes closed */	341	#else /* drive with your eyes closed */
343
344	MIN_IT (screen.cur.row, nrow - 1);	342	MIN_IT (screen.cur.row, nrow - 1);
345	MIN_IT (swap.cur.row, nrow - 1);
346	#endif	343	#endif
347	TermWin.ncol = ncol; // save b/c scr_blank_screen_mem uses this	344	TermWin.ncol = ncol; // save b/c scr_blank_screen_mem uses this
348	}	345	}
349		346
350	/* resize columns */	347	/* resize columns */
…		…
393	}	390	}
394		391
395	}	392	}
396		393
397	MIN_IT (screen.cur.col, (int16_t)ncol - 1);	394	MIN_IT (screen.cur.col, (int16_t)ncol - 1);
398	MIN_IT (swap.cur.col, (int16_t)ncol - 1);
399		395
400	delete talloc; talloc = ta;	396	delete talloc; talloc = ta;
401	delete ralloc; ralloc = ra;	397	delete ralloc; ralloc = ra;
402	}	398	}
403		399
…		…
565	if (current_screen == scrn)	561	if (current_screen == scrn)
566	return scrn;	562	return scrn;
567		563
568	selection_check (2); /* check for boundary cross */	564	selection_check (2); /* check for boundary cross */
569		565
570	SWAP_IT (current_screen, scrn, int);	566	i = current_screen; current_screen = scrn; scrn = i;
		567
		568	SWAP_IT (screen.cur.row, swap.cur.row, int16_t);
		569	SWAP_IT (screen.cur.col, swap.cur.col, int16_t);
		570	MAX_IT (screen.cur.row, 0);
		571	MIN_IT (screen.cur.row, (int32_t)prev_nrow - 1);
		572	MAX_IT (screen.cur.col, 0);
		573	MIN_IT (screen.cur.col, (int32_t)prev_ncol - 1);
		574
571	#if NSCREENS	575	#if NSCREENS
572	if (options & Opt_secondaryScreen)	576	if (options & Opt_secondaryScreen)
573	{	577	{
574	num_scr = 0;	578	num_scr = 0;
575	offset = TermWin.saveLines;	579	offset = TermWin.saveLines;
		580
576	for (i = prev_nrow; i--;)	581	for (i = prev_nrow; i--;)
577	{	582	{
578	SWAP_IT (screen.text[i + offset], swap.text[i], text_t *);	583	SWAP_IT (screen.text[i + offset], swap.text[i], text_t *);
579	SWAP_IT (screen.tlen[i + offset], swap.tlen[i], int16_t);	584	SWAP_IT (screen.tlen[i + offset], swap.tlen[i], int16_t);
580	SWAP_IT (screen.rend[i + offset], swap.rend[i], rend_t *);	585	SWAP_IT (screen.rend[i + offset], swap.rend[i], rend_t *);
581	}	586	}
582	SWAP_IT (screen.cur.row, swap.cur.row, int16_t);	587
583	SWAP_IT (screen.cur.col, swap.cur.col, int16_t);
584	# ifdef DEBUG_STRICT
585	assert ((screen.cur.row >= 0) && (screen.cur.row < prev_nrow));
586	assert ((screen.cur.col >= 0) && (screen.cur.col < prev_ncol));
587	# else /* drive with your eyes closed */
588	MAX_IT (screen.cur.row, 0);
589	MIN_IT (screen.cur.row, (int32_t)prev_nrow - 1);
590	MAX_IT (screen.cur.col, 0);
591	MIN_IT (screen.cur.col, (int32_t)prev_ncol - 1);
592	# 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	}	592	}
598	else	593	else
599	#endif	594	#endif
600	if (options & Opt_secondaryScroll)	595	if (options & Opt_secondaryScroll)
601	//if (current_screen == PRIMARY)
602	scr_scroll_text (0, (prev_nrow - 1), prev_nrow, 0);	596	scr_scroll_text (0, prev_nrow - 1, prev_nrow, 0);
		597
603	return scrn;	598	return scrn;
604	}	599	}
605		600
606	// clear WrapNext indicator, solidifying position on next line	601	// clear WrapNext indicator, solidifying position on next line
607	void	602	void
…		…
704	selection.op = SELECTION_CLEAR; /* XXX: too aggressive? */	699	selection.op = SELECTION_CLEAR; /* XXX: too aggressive? */
705	}	700	}
706	else if (j >= row1 && j <= row2)	701	else if (j >= row1 && j <= row2)
707	{	702	{
708	/* move selected region too */	703	/* move selected region too */
709	selection.beg.row -= count;	704	selection.beg.row -= count;
710	selection.end.row -= count;	705	selection.end.row -= count;
711	selection.mark.row -= count;	706	selection.mark.row -= count;
712	}	707	}
713	}	708	}
714		709
715	selection_check (0); /* _after_ TermWin.nscrolled update */	710	selection_check (0); /* _after_ TermWin.nscrolled update */
…		…
723	i = row2 - row1 + 1;	718	i = row2 - row1 + 1;
724	MIN_IT (count, i);	719	MIN_IT (count, i);
725		720
726	if (j > 0)	721	if (j > 0)
727	{	722	{
728	/* A: scroll up */	723	/* scroll up */
729		724
730	/* A1: Copy lines that will get clobbered by the rotation */	725	/* Copy lines that will get clobbered by the rotation */
731	memcpy (buf_text, screen.text + row1, count * sizeof (text_t *));	726	memcpy (buf_text, screen.text + row1, count * sizeof (text_t *));
732	memcpy (buf_rend, screen.rend + row1, count * sizeof (rend_t *));	727	memcpy (buf_rend, screen.rend + row1, count * sizeof (rend_t *));
733		728
734	/* A2: Rotate lines */	729	/* Rotate lines */
735	i = row2 - row1 - count + 1;	730	i = row2 - row1 - count + 1;
736	memmove (screen.tlen + row1, screen.tlen + row1 + count, i * sizeof (int16_t));	731	memmove (screen.tlen + row1, screen.tlen + row1 + count, i * sizeof (int16_t));
737	memmove (screen.text + row1, screen.text + row1 + count, i * sizeof (text_t *));	732	memmove (screen.text + row1, screen.text + row1 + count, i * sizeof (text_t *));
738	memmove (screen.rend + row1, screen.rend + row1 + count, i * sizeof (rend_t *));	733	memmove (screen.rend + row1, screen.rend + row1 + count, i * sizeof (rend_t *));
739		734
740	j = row2 - count + 1, i = count;	735	j = row2 - count + 1, i = count;
741	}	736	}
742	else /* if (j < 0) */	737	else /* if (j < 0) */
743	{	738	{
744	/* B: scroll down */	739	/* scroll down */
745		740
746	/* B1: Copy lines that will get clobbered by the rotation */	741	/* Copy lines that will get clobbered by the rotation */
747	for (i = 0, j = row2; i < count; i++, j--)	742	for (i = 0, j = row2; i < count; i++, j--)
748	{	743	{
749	buf_text[i] = screen.text[j];	744	buf_text[i] = screen.text[j];
750	buf_rend[i] = screen.rend[j];	745	buf_rend[i] = screen.rend[j];
751	}	746	}
752		747
753	/* B2: Rotate lines */	748	/* Rotate lines */
754	for (j = row2, i = j - count; i >= row1; i--, j--)	749	for (j = row2, i = j - count; i >= row1; i--, j--)
755	{	750	{
756	screen.tlen[j] = screen.tlen[i];	751	screen.tlen[j] = screen.tlen[i];
757	screen.text[j] = screen.text[i];	752	screen.text[j] = screen.text[i];
758	screen.rend[j] = screen.rend[i];	753	screen.rend[j] = screen.rend[i];
…		…
760		755
761	j = row1, i = count;	756	j = row1, i = count;
762	count = -count;	757	count = -count;
763	}	758	}
764		759
765	/* C: Resurrect lines */	760	/* Resurrect lines */
766	memset (screen.tlen + j, 0, i * sizeof (int16_t));	761	memset (screen.tlen + j, 0, i * sizeof (int16_t));
767	memcpy (screen.text + j, buf_text, i * sizeof (text_t *));	762	memcpy (screen.text + j, buf_text, i * sizeof (text_t *));
768	memcpy (screen.rend + j, buf_rend, i * sizeof (text_t *));	763	memcpy (screen.rend + j, buf_rend, i * sizeof (text_t *));
769	if (!spec) /* line length may not equal TermWin.ncol */	764	if (!spec) /* line length may not equal TermWin.ncol */
770	for (; i--; j++)	765	for (; i--; j++)
…		…
778	* Add text given in <str> of length <len> to screen struct	773	* Add text given in <str> of length <len> to screen struct
779	*/	774	*/
780	void	775	void
781	rxvt_term::scr_add_lines (const unicode_t *str, int nlines, int len)	776	rxvt_term::scr_add_lines (const unicode_t *str, int nlines, int len)
782	{	777	{
		778	if (len <= 0) /* sanity */
		779	return;
		780
783	unsigned char checksel;	781	unsigned char checksel;
784	unicode_t c;	782	unicode_t c;
785	int i, row, last_col;	783	int i, row, last_col;
786	text_t *stp;	784	text_t *stp;
787	rend_t *srp;	785	rend_t *srp;
788		786	const unicode_t *strend = str + len;
789	if (len <= 0) /* sanity */
790	return;
791		787
792	want_refresh = 1;	788	want_refresh = 1;
793	ZERO_SCROLLBACK ();	789	ZERO_SCROLLBACK ();
794	last_col = TermWin.ncol;	790	last_col = TermWin.ncol;
795		791
…		…
820	checksel = selection.op && current_screen == selection.screen ? 1 : 0;	816	checksel = selection.op && current_screen == selection.screen ? 1 : 0;
821		817
822	stp = screen.text[row];	818	stp = screen.text[row];
823	srp = screen.rend[row];	819	srp = screen.rend[row];
824		820
825	while (len--)	821	while (str < strend)
826	{	822	{
827	c = *str++;	823	c = *str++;
828		824
829	if (c < 0x20)	825	if (c < 0x20)
830	switch (c)	826	if (c == C0_LF)
		827	{
		828	if (screen.tlen[row] != -1) /* XXX: think about this */
		829	MAX_IT (screen.tlen[row], screen.cur.col);
		830
		831	screen.flags &= ~Screen_WrapNext;
		832
		833	if (screen.cur.row == screen.bscroll)
		834	scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);
		835	else if (screen.cur.row < (TermWin.nrow - 1))
		836	row = (++screen.cur.row) + TermWin.saveLines;
		837
		838	stp = screen.text[row]; /* _must_ refresh */
		839	srp = screen.rend[row]; /* _must_ refresh */
		840	continue;
		841	}
		842	else if (c == C0_CR)
831	{	843	{
832	case C0_HT:
833	scr_tab (1, true);
834	continue;
835
836	case C0_LF:
837	if (screen.tlen[row] != -1) /* XXX: think about this */	844	if (screen.tlen[row] != -1) /* XXX: think about this */
838	MAX_IT (screen.tlen[row], screen.cur.col);	845	MAX_IT (screen.tlen[row], screen.cur.col);
839		846
840	screen.flags &= ~Screen_WrapNext;	847	screen.flags &= ~Screen_WrapNext;
841
842	if (screen.cur.row == screen.bscroll)
843	scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);
844	else if (screen.cur.row < (TermWin.nrow - 1))
845	row = (++screen.cur.row) + TermWin.saveLines;
846
847	stp = screen.text[row]; /* _must_ refresh */
848	srp = screen.rend[row]; /* _must_ refresh */
849	continue;
850
851	case C0_CR:
852	if (screen.tlen[row] != -1) /* XXX: think about this */
853	MAX_IT (screen.tlen[row], screen.cur.col);
854
855	screen.flags &= ~Screen_WrapNext;
856	screen.cur.col = 0;	848	screen.cur.col = 0;
857	continue;	849	continue;
		850	}
		851	else if (c == C0_HT)
		852	{
		853	scr_tab (1, true);
		854	continue;
858	}	855	}
859		856
860	if (checksel /* see if we're writing within selection */	857	if (checksel /* see if we're writing within selection */
861	&& !ROWCOL_IS_BEFORE (screen.cur, selection.beg)	858	&& !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
862	&& ROWCOL_IS_BEFORE (screen.cur, selection.end))	859	&& ROWCOL_IS_BEFORE (screen.cur, selection.end))
…		…
872		869
873	if (screen.flags & Screen_WrapNext)	870	if (screen.flags & Screen_WrapNext)
874	{	871	{
875	screen.tlen[row] = -1;	872	screen.tlen[row] = -1;
876		873
		874	scr_do_wrap ();
		875
877	scr_do_wrap (); row = screen.cur.row + TermWin.saveLines;	876	row = screen.cur.row + TermWin.saveLines;
878
879	stp = screen.text[row]; /* _must_ refresh */	877	stp = screen.text[row]; /* _must_ refresh */
880	srp = screen.rend[row]; /* _must_ refresh */	878	srp = screen.rend[row]; /* _must_ refresh */
881	}	879	}
882		880
883	if (screen.flags & Screen_Insert)	881	// some utf-8 decoders "decode" surrogate characters: let's fix this.
884	scr_insdel_chars (1, INSERT);	882	if (IN_RANGE (c, 0xd800, 0xdfff))
		883	c = 0xfffd;
885		884
886	// rely on wcwidth to tell us the character width, at least for non-latin1	885	// rely on wcwidth to tell us the character width, at least for non-latin1
887	// do wcwidth before further replacements, as wcwidth says that line-drawing	886	// do wcwidth before further replacements, as wcwidth might return -1
888	// characters have width -1 (DOH!) on GNU/Linux sometimes.	887	// for the line drawing characters below as they might be invalid in the current
		888	// locale.
889	int width = c < 0x100 ? 1 : wcwidth (c);	889	int width = c < 0x100 ? 1 : wcwidth (c);
890		890
891	if (charsets[screen.charset] == '0') // DEC SPECIAL	891	if (charsets[screen.charset] == '0') // DEC SPECIAL
892	{	892	{
893	// vt100 special graphics and line drawing	893	// vt100 special graphics and line drawing
894	// 5f-7e standard vt100	894	// 5f-7e standard vt100
895	// 40-5e rxvt extension for extra curses acs chars	895	// 40-5e rxvt extension for extra curses acs chars
896	static uint16_t vt100_0[63] = { // 5f .. 7e	896	static uint16_t vt100_0[62] = { // 41 .. 7e
897	0x0000, 0x2191, 0x2193, 0x2192, 0x2190, 0x2588, 0x259a, 0x2603, // 40-47 hi mr. snowman!	897	0x2191, 0x2193, 0x2192, 0x2190, 0x2588, 0x259a, 0x2603, // 41-47 hi mr. snowman!
898	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 48-4f	898	0, 0, 0, 0, 0, 0, 0, 0, // 48-4f
899	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 50-57	899	0, 0, 0, 0, 0, 0, 0, 0, // 50-57
900	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, // 58-5f	900	0, 0, 0, 0, 0, 0, 0, 0x0020, // 58-5f
901	0x25c6, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0, 0x00b1, // 60-67	901	0x25c6, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0, 0x00b1, // 60-67
902	0x2424, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c, 0x23ba, // 68-6f	902	0x2424, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c, 0x23ba, // 68-6f
903	0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534, 0x252c, // 70-77	903	0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534, 0x252c, // 70-77
904	0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7, // 78-7e	904	0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7, // 78-7e
905	};	905	};
906		906
907	if (c >= 0x40 && c <= 0x7e && vt100_0[c - 0x40])	907	if (c >= 0x41 && c <= 0x7e && vt100_0[c - 0x41])
908	{	908	{
909	c = vt100_0[c - 0x40];	909	c = vt100_0[c - 0x41];
910	width = 1;	910	width = 1; // vt100 line drawing characters are always single-width
911	}	911	}
912	}	912	}
913		913
		914	if (screen.flags & Screen_Insert)
		915	scr_insdel_chars (width, INSERT);
		916
914	if (width != 0)	917	if (width != 0)
915	{	918	{
916	// some utf-8 decoders decode surrogate characters.
917	if (0xd800 <= c && c <= 0xdfff)
918	c = 0xfffd;
919
920	#if !UNICODE_3	919	#if !UNICODE_3
921	// trim characters we can't store directly :(	920	// trim characters we can't store directly :(
922	if (c >= 0x10000)	921	if (c >= 0x10000)
923	# if ENABLE_COMBINING	922	# if ENABLE_COMBINING
924	c = rxvt_composite.compose (c); // map to lower 16 bits	923	c = rxvt_composite.compose (c); // map to lower 16 bits
…		…
947	col++;	946	col++;
948	} while (col < TermWin.ncol && stp[col] == NOCHAR);	947	} while (col < TermWin.ncol && stp[col] == NOCHAR);
949	}	948	}
950		949
951	rend_t rend = SET_FONT (rstyle, FONTSET (rstyle)->find_font (c));	950	rend_t rend = SET_FONT (rstyle, FONTSET (rstyle)->find_font (c));
		951
		952	// if the character doesn't fit into the remaining columns...
		953	if (screen.cur.col > last_col - width && last_col >= width)
		954	{
		955	// ...output spaces
		956	c = ' ';
		957	// and try the same character next loop iteration
		958	--str;
		959	}
952		960
953	do	961	do
954	{	962	{
955	stp[screen.cur.col] = c;	963	stp[screen.cur.col] = c;
956	srp[screen.cur.col] = rend;	964	srp[screen.cur.col] = rend;
…		…
968	c = NOCHAR;	976	c = NOCHAR;
969	}	977	}
970	while (--width > 0);	978	while (--width > 0);
971		979
972	// pad with spaces when overwriting wide character with smaller one	980	// pad with spaces when overwriting wide character with smaller one
		981	if (!width)
973	for (int c = screen.cur.col; c < last_col && stp[c] == NOCHAR; c++)	982	for (int c = screen.cur.col; c < last_col && stp[c] == NOCHAR; c++)
974	{	983	{
975	stp[c] = ' ';	984	stp[c] = ' ';
976	srp[c] = rend;	985	srp[c] = rend;
977	}	986	}
978	}	987	}
979	else if (width == 0)	988	else // width == 0
980	{	989	{
981	#if ENABLE_COMBINING	990	#if ENABLE_COMBINING
982	// handle combining characters	991	// handle combining characters
983	// we just tag the accent on the previous on-screen character.	992	// we just tag the accent on the previous on-screen character.
984	// this is arguably not correct, but also arguably not wrong.	993	// this is arguably not correct, but also arguably not wrong.
985	// we don't handle double-width characters nicely yet.	994	// we don't handle double-width characters nicely yet.
986
987	text_t *tp;	995	text_t *tp;
988	rend_t *rp;	996	rend_t *rp;
989		997
990	if (screen.cur.col > 0)	998	if (screen.cur.col > 0)
991	{	999	{
992	tp = stp + screen.cur.col - 1;	1000	tp = stp + screen.cur.col - 1;
993	rp = srp + screen.cur.col - 1;	1001	rp = srp + screen.cur.col - 1;
		1002
		1003	while (*tp == NOCHAR && tp > stp)
		1004	tp--, rp--;
994	}	1005	}
995	else if (screen.cur.row > 0	1006	else if (screen.cur.row > 0
996	&& screen.tlen [screen.cur.row - 1 + TermWin.saveLines] == -1)	1007	&& screen.tlen [screen.cur.row - 1 + TermWin.saveLines] == -1)
997	{	1008	{
998	tp = screen.text[screen.cur.row - 1 + TermWin.saveLines] + last_col - 1;	1009	int line = screen.cur.row - 1 + TermWin.saveLines;
999	rp = screen.rend[screen.cur.row - 1 + TermWin.saveLines] + last_col - 1;	1010
		1011	tp = screen.text[line] + last_col - 1;
		1012	rp = screen.rend[line] + last_col - 1;
		1013
		1014	while (*tp == NOCHAR && tp > screen.text[line])
		1015	tp--, rp--;
1000	}	1016	}
1001	else	1017	else
1002	continue;	1018	continue;
1003
1004	// handle double-width-chars by making them look extremely ugly
1005	if (*tp == NOCHAR)
1006	{
1007	// hack //D //TODO //--tp, --rp;
1008	*tp = ' ';
1009	*rp &= ~RS_baseattrMask;
1010	*rp = SET_FONT (*rp, FONTSET (*rp)->find_font (*tp));
1011	}
1012		1019
1013	// first try to find a precomposed character	1020	// first try to find a precomposed character
1014	unicode_t n = rxvt_compose (*tp, c);	1021	unicode_t n = rxvt_compose (*tp, c);
1015	if (n == NOCHAR)	1022	if (n == NOCHAR)
1016	n = rxvt_composite.compose (*tp, c);	1023	n = rxvt_composite.compose (*tp, c);
…		…
1096	if (count)	1103	if (count)
1097	x = TermWin.ncol - 1;	1104	x = TermWin.ncol - 1;
1098		1105
1099	// store horizontal tab commands as characters inside the text	1106	// store horizontal tab commands as characters inside the text
1100	// buffer so they can be selected and pasted.	1107	// buffer so they can be selected and pasted.
1101	if (ht)	1108	if (ht && options & Opt_pastableTabs)
1102	{	1109	{
1103	base_rend = SET_FONT (base_rend, 0);	1110	base_rend = SET_FONT (base_rend, 0);
1104		1111
1105	if (screen.tlen[row] != -1) /* XXX: think about this */	1112	if (screen.tlen[row] != -1) /* XXX: think about this */
1106	MAX_IT (screen.tlen[row], x);	1113	MAX_IT (screen.tlen[row], x);
…		…
1166	*/	1173	*/
1167	#if ENABLE_FRILLS	1174	#if ENABLE_FRILLS
1168	void	1175	void
1169	rxvt_term::scr_forwardindex ()	1176	rxvt_term::scr_forwardindex ()
1170	{	1177	{
1171	int row;	1178	int row;
1172		1179
1173	if (screen.cur.col < TermWin.ncol - 1)	1180	if (screen.cur.col < TermWin.ncol - 1)
1174	scr_gotorc (0, 1, R_RELATIVE | C_RELATIVE);	1181	scr_gotorc (0, 1, R_RELATIVE | C_RELATIVE);
1175	else	1182	else
1176	{	1183	{
…		…
1379	ren = DEFAULT_RSTYLE;	1386	ren = DEFAULT_RSTYLE;
1380	CLEAR_ROWS (row, num);	1387	CLEAR_ROWS (row, num);
1381	}	1388	}
1382	else	1389	else
1383	{	1390	{
1384	ren = (rstyle & (RS_fgMask | RS_bgMask));	1391	ren = rstyle & (RS_fgMask | RS_bgMask);
1385	gcvalue.foreground = pix_colors[GET_BGCOLOR (rstyle)];	1392	gcvalue.foreground = pix_colors[GET_BGCOLOR (rstyle)];
1386	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);	1393	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);
1387	ERASE_ROWS (row, num);	1394	ERASE_ROWS (row, num);
1388	gcvalue.foreground = pix_colors[Color_fg];	1395	gcvalue.foreground = pix_colors[Color_fg];
1389	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);	1396	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);
1390	}	1397	}
1391		1398
1392	for (; num--; row++)	1399	for (; num--; row++)
1393	{	1400	{
1394	scr_blank_screen_mem (screen.text, screen.rend,	1401	scr_blank_screen_mem (screen.text, screen.rend, (unsigned int) (row + row_offset), rstyle);
1395	(unsigned int) (row + row_offset), rstyle);
1396	screen.tlen[row + row_offset] = 0;	1402	screen.tlen[row + row_offset] = 0;
1397	scr_blank_line (drawn_text[row], drawn_rend[row],	1403	scr_blank_line (drawn_text[row], drawn_rend[row], (unsigned int)TermWin.ncol, ren);
1398	(unsigned int)TermWin.ncol, ren);
1399	}	1404	}
1400	}	1405	}
		1406
		1407	#if ENABLE_FRILLS
		1408	void
		1409	rxvt_term::scr_erase_savelines ()
		1410	{
		1411	want_refresh = 1;
		1412	ZERO_SCROLLBACK ();
		1413
		1414	TermWin.nscrolled = 0;
		1415	}
		1416	#endif
1401		1417
1402	/* ------------------------------------------------------------------------- */	1418	/* ------------------------------------------------------------------------- */
1403	/*	1419	/*
1404	* Fill the screen with `E's	1420	* Fill the screen with `E's
1405	* XTERM_SEQ: Screen Alignment Test: ESC # 8	1421	* XTERM_SEQ: Screen Alignment Test: ESC # 8
1406	*/	1422	*/
1407	void	1423	void
1408	rxvt_term::scr_E ()	1424	rxvt_term::scr_E ()
1409	{	1425	{
1410	int i, j, k;	1426	int i, j, k;
1411	rend_t *r1, fs;	1427	rend_t *r1, fs;
1412		1428
1413	want_refresh = 1;	1429	want_refresh = 1;
1414	ZERO_SCROLLBACK ();	1430	ZERO_SCROLLBACK ();
1415		1431
1416	num_scr_allow = 0;	1432	num_scr_allow = 0;
…		…
1487	slp = &screen.tlen[row];	1503	slp = &screen.tlen[row];
1488		1504
1489	switch (insdel)	1505	switch (insdel)
1490	{	1506	{
1491	case INSERT:	1507	case INSERT:
1492	for (col = TermWin.ncol - 1; (col - count) >= screen.cur.col;	1508	for (col = TermWin.ncol - 1; (col - count) >= screen.cur.col; col--)
1493	col--)
1494	{	1509	{
1495	stp[col] = stp[col - count];	1510	stp[col] = stp[col - count];
1496	srp[col] = srp[col - count];	1511	srp[col] = srp[col - count];
1497	}	1512	}
1498		1513
…		…
1508	if (selection.end.row != screen.cur.row	1523	if (selection.end.row != screen.cur.row
1509	|| (selection.end.col + count >= TermWin.ncol))	1524	|| (selection.end.col + count >= TermWin.ncol))
1510	CLEAR_SELECTION ();	1525	CLEAR_SELECTION ();
1511	else	1526	else
1512	{ /* shift selection */	1527	{ /* shift selection */
1513	selection.beg.col += count;	1528	selection.beg.col += count;
1514	selection.mark.col += count; /* XXX: yes? */	1529	selection.mark.col += count; /* XXX: yes? */
1515	selection.end.col += count;	1530	selection.end.col += count;
1516	}	1531	}
1517	}	1532	}
1518		1533
1519	scr_blank_line (& (stp[screen.cur.col]), & (srp[screen.cur.col]),	1534	scr_blank_line (&stp[screen.cur.col], &srp[screen.cur.col],
1520	(unsigned int)count, rstyle);	1535	(unsigned int)count, rstyle);
1521	break;	1536	break;
1522		1537
1523	case ERASE:	1538	case ERASE:
1524	screen.cur.col += count; /* don't worry if > TermWin.ncol */	1539	screen.cur.col += count; /* don't worry if > TermWin.ncol */
1525	selection_check (1);	1540	selection_check (1);
1526	screen.cur.col -= count;	1541	screen.cur.col -= count;
1527	scr_blank_line (& (stp[screen.cur.col]), & (srp[screen.cur.col]),	1542	scr_blank_line (&stp[screen.cur.col], &srp[screen.cur.col],
1528	(unsigned int)count, rstyle);	1543	(unsigned int)count, rstyle);
1529	break;	1544	break;
1530		1545
1531	case DELETE:	1546	case DELETE:
1532	tr = srp[TermWin.ncol - 1] & (RS_fgMask | RS_bgMask | RS_baseattrMask);	1547	tr = srp[TermWin.ncol - 1] & (RS_fgMask | RS_bgMask | RS_baseattrMask);
…		…
1535	{	1550	{
1536	stp[col] = stp[col + count];	1551	stp[col] = stp[col + count];
1537	srp[col] = srp[col + count];	1552	srp[col] = srp[col + count];
1538	}	1553	}
1539		1554
1540	scr_blank_line (& (stp[TermWin.ncol - count]),	1555	scr_blank_line (&stp[TermWin.ncol - count], &srp[TermWin.ncol - count],
1541	& (srp[TermWin.ncol - count]),
1542	(unsigned int)count, tr);	1556	(unsigned int)count, tr);
1543		1557
1544	if (*slp == -1) /* break line continuation */	1558	if (*slp == -1) /* break line continuation */
1545	*slp = TermWin.ncol;	1559	*slp = TermWin.ncol;
1546		1560
…		…
1555	|| selection.end.col >= TermWin.ncol)	1569	|| selection.end.col >= TermWin.ncol)
1556	CLEAR_SELECTION ();	1570	CLEAR_SELECTION ();
1557	else	1571	else
1558	{	1572	{
1559	/* shift selection */	1573	/* shift selection */
1560	selection.beg.col -= count;	1574	selection.beg.col -= count;
1561	selection.mark.col -= count; /* XXX: yes? */	1575	selection.mark.col -= count; /* XXX: yes? */
1562	selection.end.col -= count;	1576	selection.end.col -= count;
1563	}	1577	}
1564	}	1578	}
1565		1579
1566	break;	1580	break;
1567	}	1581	}
…		…
1751	* XTERM_SEQ: Invoke G2 character set: ESC N	1765	* XTERM_SEQ: Invoke G2 character set: ESC N
1752	* XTERM_SEQ: Invoke G3 character set: ESC O	1766	* XTERM_SEQ: Invoke G3 character set: ESC O
1753	*/	1767	*/
1754	void	1768	void
1755	rxvt_term::scr_charset_choose (int set)	1769	rxvt_term::scr_charset_choose (int set)
1756	{	1770	{
1757	screen.charset = set;	1771	screen.charset = set;
1758	set_font_style ();	1772	set_font_style ();
1759	}	1773	}
1760		1774
1761	/* ------------------------------------------------------------------------- */	1775	/* ------------------------------------------------------------------------- */
1762	/*	1776	/*
1763	* Set a font	1777	* Set a font
1764	* XTERM_SEQ: Set G0 character set: ESC ( <C>	1778	* XTERM_SEQ: Set G0 character set: ESC ( <C>
…		…
1767	* XTERM_SEQ: Set G3 character set: ESC + <C>	1781	* XTERM_SEQ: Set G3 character set: ESC + <C>
1768	* See set_font_style for possible values for <C>	1782	* See set_font_style for possible values for <C>
1769	*/	1783	*/
1770	void	1784	void
1771	rxvt_term::scr_charset_set (int set, unsigned int ch)	1785	rxvt_term::scr_charset_set (int set, unsigned int ch)
1772	{	1786	{
1773	charsets[set] = (unsigned char)ch;	1787	charsets[set] = (unsigned char)ch;
1774	set_font_style ();	1788	set_font_style ();
1775	}	1789	}
1776		1790
1777		1791
1778	/* ------------------------------------------------------------------------- *	1792	/* ------------------------------------------------------------------------- *
1779	* MAJOR SCREEN MANIPULATION *	1793	* MAJOR SCREEN MANIPULATION *
1780	* ------------------------------------------------------------------------- */	1794	* ------------------------------------------------------------------------- */
…		…
1901	rxvt_term::scr_page (enum page_dirn direction, int nlines)	1915	rxvt_term::scr_page (enum page_dirn direction, int nlines)
1902	{	1916	{
1903	int n;	1917	int n;
1904	unsigned int oldviewstart;	1918	unsigned int oldviewstart;
1905		1919
1906	#ifdef DEBUG_STRICT
1907	assert ((nlines >= 0) && (nlines <= TermWin.nrow));
1908	#endif
1909	oldviewstart = TermWin.view_start;	1920	oldviewstart = TermWin.view_start;
		1921
1910	if (direction == UP)	1922	if (direction == UP)
1911	{	1923	{
1912	n = TermWin.view_start + nlines;	1924	n = TermWin.view_start + nlines;
1913	TermWin.view_start = min (n, TermWin.nscrolled);	1925	TermWin.view_start = min (n, TermWin.nscrolled);
1914	}	1926	}
1915	else	1927	else
1916	{	1928	{
1917	n = TermWin.view_start - nlines;	1929	n = TermWin.view_start - nlines;
1918	TermWin.view_start = max (n, 0);	1930	TermWin.view_start = max (n, 0);
1919	}	1931	}
		1932
1920	return scr_changeview (oldviewstart);	1933	return scr_changeview (oldviewstart);
1921	}	1934	}
1922		1935
1923	int	1936	int
1924	rxvt_term::scr_changeview (unsigned int oldviewstart)	1937	rxvt_term::scr_changeview (unsigned int oldviewstart)
…		…
1935	/* ------------------------------------------------------------------------- */	1948	/* ------------------------------------------------------------------------- */
1936	void	1949	void
1937	rxvt_term::scr_bell ()	1950	rxvt_term::scr_bell ()
1938	{	1951	{
1939	#ifndef NO_BELL	1952	#ifndef NO_BELL
		1953
1940	# ifndef NO_MAPALERT	1954	# ifndef NO_MAPALERT
1941	# ifdef MAPALERT_OPTION	1955	# ifdef MAPALERT_OPTION
1942	if (options & Opt_mapAlert)	1956	if (options & Opt_mapAlert)
1943	# endif	1957	# endif
1944	XMapWindow (display->display, TermWin.parent[0]);	1958	XMapWindow (display->display, TermWin.parent[0]);
1945	# endif	1959	# endif
		1960
1946	if (options & Opt_visualBell)	1961	if (options & Opt_visualBell)
1947	{	1962	{
1948	scr_rvideo_mode (!rvideo); /* refresh also done */	1963	scr_rvideo_mode (!rvideo); /* refresh also done */
		1964	rxvt_usleep (VISUAL_BELL_DURATION);
1949	scr_rvideo_mode (!rvideo); /* refresh also done */	1965	scr_rvideo_mode (!rvideo); /* refresh also done */
1950	}	1966	}
1951	else	1967	else
1952	XBell (display->display, 0);	1968	XBell (display->display, 0);
		1969
1953	#endif	1970	#endif
1954	}	1971	}
1955		1972
1956	/* ------------------------------------------------------------------------- */	1973	/* ------------------------------------------------------------------------- */
1957	/* ARGSUSED */	1974	/* ARGSUSED */
…		…
2012	/*	2029	/*
2013	* Refresh the screen	2030	* Refresh the screen
2014	* drawn_text/drawn_rend contain the screen information before the update.	2031	* drawn_text/drawn_rend contain the screen information before the update.
2015	* screen.text/screen.rend contain what the screen will change to.	2032	* screen.text/screen.rend contain what the screen will change to.
2016	*/	2033	*/
2017
2018	#define FONT_WIDTH(X, Y) \
2019	(X)->per_char[ (Y) - (X)->min_char_or_byte2].width
2020	#define FONT_RBEAR(X, Y) \
2021	(X)->per_char[ (Y) - (X)->min_char_or_byte2].rbearing
2022	#define FONT_LBEAR(X, Y) \
2023	(X)->per_char[ (Y) - (X)->min_char_or_byte2].lbearing
2024	#define IS_FONT_CHAR(X, Y) \
2025	((Y) >= (X)->min_char_or_byte2 && (Y) <= (X)->max_char_or_byte2)
2026
2027	void	2034	void
2028	rxvt_term::scr_refresh (unsigned char refresh_type)	2035	rxvt_term::scr_refresh (unsigned char refresh_type)
2029	{	2036	{
2030	unsigned char must_clear, /* use draw_string not draw_image_string */	2037	unsigned char must_clear, /* use draw_string not draw_image_string */
2031	showcursor; /* show the cursor */	2038	showcursor; /* show the cursor */
…		…
2036	#ifndef NO_CURSORCOLOR	2043	#ifndef NO_CURSORCOLOR
2037	rend_t cc1; /* store colours at cursor position (s) */	2044	rend_t cc1; /* store colours at cursor position (s) */
2038	#endif	2045	#endif
2039	rend_t *crp; // cursor rendition pointer	2046	rend_t *crp; // cursor rendition pointer
2040		2047
		2048	want_refresh = 0; /* screen is current */
		2049
2041	if (refresh_type == NO_REFRESH || !TermWin.mapped)	2050	if (refresh_type == NO_REFRESH || !TermWin.mapped)
2042	return;	2051	return;
2043		2052
2044	/*	2053	/*
2045	* A: set up vars	2054	* A: set up vars
…		…
2048	refresh_count = 0;	2057	refresh_count = 0;
2049		2058
2050	row_offset = TermWin.saveLines - TermWin.view_start;	2059	row_offset = TermWin.saveLines - TermWin.view_start;
2051		2060
2052	#if XPM_BACKGROUND	2061	#if XPM_BACKGROUND
2053	must_clear |= (bgPixmap.pixmap != None);	2062	must_clear |= bgPixmap.pixmap != None;
2054	#endif	2063	#endif
2055	#if TRANSPARENT	2064	#if TRANSPARENT
2056	must_clear |= ((options & Opt_transparent) && am_transparent);	2065	must_clear |= (options & Opt_transparent) && am_transparent;
2057	#endif	2066	#endif
2058	ocrow = oldcursor.row; /* is there an old outline cursor on screen? */	2067	ocrow = oldcursor.row; /* is there an old outline cursor on screen? */
2059		2068
2060	/*	2069	/*
2061	* B: reverse any characters which are selected	2070	* B: reverse any characters which are selected
…		…
2085		2094
2086	crp = &screen.rend[screen.cur.row + TermWin.saveLines][col];	2095	crp = &screen.rend[screen.cur.row + TermWin.saveLines][col];
2087		2096
2088	if (showcursor && TermWin.focus)	2097	if (showcursor && TermWin.focus)
2089	{	2098	{
		2099	if (options & Opt_cursorUnderline)
		2100	*crp ^= RS_Uline;
		2101	else
		2102	{
2090	*crp ^= RS_RVid;	2103	*crp ^= RS_RVid;
		2104
2091	#ifndef NO_CURSORCOLOR	2105	#ifndef NO_CURSORCOLOR
2092	cc1 = *crp & (RS_fgMask | RS_bgMask);	2106	cc1 = *crp & (RS_fgMask | RS_bgMask);
2093	if (ISSET_PIXCOLOR (Color_cursor))	2107	if (ISSET_PIXCOLOR (Color_cursor))
2094	ccol1 = Color_cursor;	2108	ccol1 = Color_cursor;
2095	else	2109	else
2096	#ifdef CURSOR_COLOR_IS_RENDITION_COLOR	2110	#ifdef CURSOR_COLOR_IS_RENDITION_COLOR
2097	ccol1 = GET_FGCOLOR (rstyle);	2111	ccol1 = GET_FGCOLOR (rstyle);
2098	#else	2112	#else
2099	ccol1 = Color_fg;	2113	ccol1 = Color_fg;
2100	#endif	2114	#endif
2101	if (ISSET_PIXCOLOR (Color_cursor2))	2115	if (ISSET_PIXCOLOR (Color_cursor2))
2102	ccol2 = Color_cursor2;	2116	ccol2 = Color_cursor2;
2103	else	2117	else
2104	#ifdef CURSOR_COLOR_IS_RENDITION_COLOR	2118	#ifdef CURSOR_COLOR_IS_RENDITION_COLOR
2105	ccol2 = GET_BGCOLOR (rstyle);	2119	ccol2 = GET_BGCOLOR (rstyle);
2106	#else	2120	#else
2107	ccol2 = Color_bg;	2121	ccol2 = Color_bg;
2108	#endif	2122	#endif
2109	*crp = SET_FGCOLOR (*crp, ccol1);	2123	*crp = SET_FGCOLOR (*crp, ccol1);
2110	*crp = SET_BGCOLOR (*crp, ccol2);	2124	*crp = SET_BGCOLOR (*crp, ccol2);
2111	#endif	2125	#endif
		2126	}
2112	}	2127	}
2113	}	2128	}
2114		2129
2115	/* make sure no outline cursor is left around */	2130	/* make sure no outline cursor is left around */
2116	setoldcursor = 0;	2131	setoldcursor = 0;
…		…
2242	&& GET_BGATTR (srp[col]) == GET_BGATTR (drp[col]))))	2257	&& GET_BGATTR (srp[col]) == GET_BGATTR (drp[col]))))
2243	continue;	2258	continue;
2244		2259
2245	// redraw one or more characters	2260	// redraw one or more characters
2246		2261
2247	// seek to the beginning if wide characters	2262	// seek to the beginning of wide characters
2248	while (stp[col] == NOCHAR && col > 0)	2263	while (stp[col] == NOCHAR && col > 0)
2249	--col;	2264	--col;
2250		2265
2251	rend_t rend = srp[col]; /* screen rendition (target rendtion) */	2266	rend_t rend = srp[col]; /* screen rendition (target rendtion) */
2252	text_t *text = stp + col;	2267	text_t *text = stp + col;
…		…
2396	}	2411	}
2397	else	2412	else
2398	font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, back);	2413	font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, back);
2399		2414
2400	if (rend & RS_Uline && font->descent > 1 && fore != back)	2415	if (rend & RS_Uline && font->descent > 1 && fore != back)
		2416	{
		2417	#if ENABLE_FRILLS
		2418	if (ISSET_PIXCOLOR (Color_underline))
		2419	XSetForeground (display->display, TermWin.gc, pix_colors[Color_underline]);
		2420	else
		2421	#endif
		2422	XSetForeground (display->display, TermWin.gc, pix_colors[fore]);
		2423
2401	XDrawLine (display->display, drawBuffer, TermWin.gc,	2424	XDrawLine (display->display, drawBuffer, TermWin.gc,
2402	xpixel, ypixel + font->ascent + 1,	2425	xpixel, ypixel + font->ascent + 1,
2403	xpixel + Width2Pixel (count) - 1, ypixel + font->ascent + 1);	2426	xpixel + Width2Pixel (count) - 1, ypixel + font->ascent + 1);
		2427	}
2404	} /* for (col....) */	2428	} /* for (col....) */
2405	} /* for (row....) */	2429	} /* for (row....) */
2406		2430
2407	#if ENABLE_OVERLAY	2431	#if ENABLE_OVERLAY
2408	scr_swap_overlay ();	2432	scr_swap_overlay ();
…		…
2413	*/	2437	*/
2414	if (showcursor)	2438	if (showcursor)
2415	{	2439	{
2416	if (TermWin.focus)	2440	if (TermWin.focus)
2417	{	2441	{
		2442	if (options & Opt_cursorUnderline)
		2443	*crp ^= RS_Uline;
		2444	else
		2445	{
2418	*crp ^= RS_RVid;	2446	*crp ^= RS_RVid;
2419	#ifndef NO_CURSORCOLOR	2447	#ifndef NO_CURSORCOLOR
2420	*crp = (*crp & ~ (RS_fgMask | RS_bgMask)) | cc1;	2448	*crp = (*crp & ~ (RS_fgMask | RS_bgMask)) | cc1;
2421	#endif	2449	#endif
		2450	}
2422	}	2451	}
2423	else if (oldcursor.row >= 0)	2452	else if (oldcursor.row >= 0)
2424	{	2453	{
		2454	int cursorwidth = 1;
		2455	int col = oldcursor.col;
		2456
		2457	while (col && screen.text[screen.cur.row + TermWin.saveLines][col] == NOCHAR)
		2458	col--;
		2459
		2460	while (col + cursorwidth < TermWin.ncol
		2461	&& drawn_text[oldcursor.row][col + cursorwidth] == NOCHAR)
		2462	cursorwidth++;
		2463
2425	#ifndef NO_CURSORCOLOR	2464	#ifndef NO_CURSORCOLOR
2426	if (ISSET_PIXCOLOR (Color_cursor))	2465	if (ISSET_PIXCOLOR (Color_cursor))
2427	XSetForeground (display->display, TermWin.gc, pix_colors[Color_cursor]);	2466	XSetForeground (display->display, TermWin.gc, pix_colors[Color_cursor]);
2428	#endif	2467	#endif
2429	int cursorwidth = 1;
2430	while (oldcursor.col + cursorwidth < TermWin.ncol
2431	&& drawn_text[oldcursor.row][oldcursor.col + cursorwidth] == NOCHAR)
2432	cursorwidth++;
2433		2468
2434	XDrawRectangle (display->display, drawBuffer, TermWin.gc,	2469	XDrawRectangle (display->display, drawBuffer, TermWin.gc,
2435	Col2Pixel (oldcursor.col),	2470	Col2Pixel (col),
2436	Row2Pixel (oldcursor.row),	2471	Row2Pixel (oldcursor.row),
2437	(unsigned int) (Width2Pixel (cursorwidth) - 1),	2472	(unsigned int) (Width2Pixel (cursorwidth) - 1),
2438	(unsigned int) (Height2Pixel (1) - TermWin.lineSpace - 1));	2473	(unsigned int) (Height2Pixel (1) - TermWin.lineSpace - 1));
2439	}	2474	}
2440	}	2475	}
…		…
2447	if (refresh_type & SMOOTH_REFRESH)	2482	if (refresh_type & SMOOTH_REFRESH)
2448	XFlush (display->display);	2483	XFlush (display->display);
2449		2484
2450	num_scr = 0;	2485	num_scr = 0;
2451	num_scr_allow = 1;	2486	num_scr_allow = 1;
2452	want_refresh = 0; /* screen is current */
2453	}	2487	}
2454		2488
2455	void	2489	void
2456	rxvt_term::scr_remap_chars (text_t *tp, rend_t *rp)	2490	rxvt_term::scr_remap_chars (text_t *tp, rend_t *rp)
2457	{	2491	{
…		…
2544	int end_row = TermWin.saveLines - TermWin.view_start;	2578	int end_row = TermWin.saveLines - TermWin.view_start;
2545	int i = selection.beg.row + TermWin.saveLines;	2579	int i = selection.beg.row + TermWin.saveLines;
2546	int col, row = selection.end.row + TermWin.saveLines;	2580	int col, row = selection.end.row + TermWin.saveLines;
2547	rend_t *srp;	2581	rend_t *srp;
2548		2582
2549	if (i >= end_row)	2583	#if ENABLE_FRILLS
2550	col = selection.beg.col;	2584	if (selection.rect)
		2585	{
		2586	end_row += TermWin.nrow;
		2587
		2588	for (; i <= row && i <= end_row; i++)
		2589	for (srp = screen.rend[i], col = selection.beg.col; col < selection.end.col; col++)
		2590	srp[col] ^= RS_RVid;
		2591	}
2551	else	2592	else
		2593	#endif
		2594	{
		2595	if (i >= end_row)
		2596	col = selection.beg.col;
		2597	else
2552	{	2598	{
2553	col = 0;	2599	col = 0;
2554	i = end_row;	2600	i = end_row;
2555	}	2601	}
2556		2602
2557	end_row += TermWin.nrow;	2603	end_row += TermWin.nrow;
		2604
2558	for (; i < row && i < end_row; i++, col = 0)	2605	for (; i < row && i < end_row; i++, col = 0)
2559	for (srp = screen.rend[i]; col < TermWin.ncol; col++)	2606	for (srp = screen.rend[i]; col < TermWin.ncol; col++)
2560	srp[col] ^= RS_RVid;	2607	srp[col] ^= RS_RVid;
2561		2608
2562	if (i == row && i < end_row)	2609	if (i == row && i < end_row)
2563	for (srp = screen.rend[i]; col < selection.end.col; col++)	2610	for (srp = screen.rend[i]; col < selection.end.col; col++)
2564	srp[col] ^= RS_RVid;	2611	srp[col] ^= RS_RVid;
		2612	}
2565	}	2613	}
2566	}	2614	}
2567		2615
2568	/* ------------------------------------------------------------------------- */	2616	/* ------------------------------------------------------------------------- */
2569	/*	2617	/*
…		…
2637	/* ------------------------------------------------------------------------- */	2685	/* ------------------------------------------------------------------------- */
2638	/*	2686	/*
2639	* Paste a selection direct to the command fd	2687	* Paste a selection direct to the command fd
2640	*/	2688	*/
2641	void	2689	void
2642	rxvt_term::paste (const unsigned char *data, unsigned int len)	2690	rxvt_term::paste (unsigned char *data, unsigned int len)
2643	{	2691	{
2644	unsigned int i, j, n;
2645	unsigned char *ds = (unsigned char *)rxvt_malloc (PROP_SIZE);
2646
2647	/* convert normal newline chars into common keyboard Return key sequence */	2692	/* convert normal newline chars into common keyboard Return key sequence */
2648	for (i = 0; i < len; i += PROP_SIZE)	2693	for (unsigned int i = 0; i < len; i++)
2649	{
2650	n = min (len - i, PROP_SIZE);
2651	memcpy (ds, data + i, n);
2652
2653	for (j = 0; j < n; j++)
2654	if (ds[j] == C0_LF)	2694	if (data[i] == C0_LF)
2655	ds[j] = C0_CR;	2695	data[i] = C0_CR;
2656		2696
2657	tt_write (ds, (int)n);	2697	tt_write (data, len);
2658	}
2659
2660	free (ds);
2661	}	2698	}
2662		2699
2663	/* ------------------------------------------------------------------------- */	2700	/* ------------------------------------------------------------------------- */
2664	/*	2701	/*
2665	* Respond to a notification that a primary selection has been sent	2702	* Respond to a notification that a primary selection has been sent
2666	* EXT: SelectionNotify	2703	* EXT: SelectionNotify
2667	*/	2704	*/
2668	int	2705	void
2669	rxvt_term::selection_paste (Window win, Atom prop, bool delete_prop)	2706	rxvt_term::selection_paste (Window win, Atom prop, bool delete_prop)
2670	{	2707	{
2671	long nread = 0;
2672	unsigned long bytes_after;
2673	XTextProperty ct;
2674
2675	if (prop == None) /* check for failed XConvertSelection */	2708	if (prop == None) /* check for failed XConvertSelection */
2676	{	2709	{
2677	if ((selection_type & Sel_CompoundText))	2710	if ((selection_type & Sel_CompoundText))
2678	{	2711	{
2679	int selnum = selection_type & Sel_whereMask;	2712	int selnum = selection_type & Sel_whereMask;
…		…
2692	selection_request_other (xa[XA_COMPOUND_TEXT], selnum);	2725	selection_request_other (xa[XA_COMPOUND_TEXT], selnum);
2693	else	2726	else
2694	selection_type = 0;	2727	selection_type = 0;
2695	}	2728	}
2696		2729
2697	return 0;	2730	return;
2698	}
2699
2700	for (;;)
2701	{	2731	}
		2732
		2733	unsigned long bytes_after;
		2734	XTextProperty ct;
		2735
		2736	if (XGetWindowProperty (display->display, win, prop,
		2737	0, PROP_SIZE / 4,
		2738	delete_prop, AnyPropertyType,
		2739	&ct.encoding, &ct.format,
		2740	&ct.nitems, &bytes_after,
		2741	&ct.value) != Success)
		2742	{
		2743	ct.value = 0;
		2744	goto bailout;
		2745	}
		2746
		2747	if (ct.encoding == None)
		2748	goto bailout;
		2749
		2750	if (bytes_after)
		2751	{
		2752	// fetch and append remaining data
		2753	XTextProperty ct2;
		2754
2702	if (XGetWindowProperty (display->display, win, prop, (long) (nread / 4),	2755	if (XGetWindowProperty (display->display, win, prop,
2703	(long) (PROP_SIZE / 4), delete_prop,	2756	ct.nitems / 4, (bytes_after + 3) / 4,
		2757	delete_prop, AnyPropertyType,
2704	AnyPropertyType, &ct.encoding, &ct.format,	2758	&ct2.encoding, &ct2.format,
2705	&ct.nitems, &bytes_after,	2759	&ct2.nitems, &bytes_after,
2706	&ct.value) != Success)	2760	&ct2.value) != Success)
2707	break;	2761	goto bailout;
2708		2762
2709	if (ct.encoding == 0)	2763	// realloc should be compatible to XFree, here, and elsewhere, too
2710	break;	2764	ct.value = (unsigned char *)realloc (ct.value, ct.nitems + ct2.nitems + 1);
		2765	memcpy (ct.value + ct.nitems, ct2.value, ct2.nitems + 1);
		2766	ct.nitems += ct2.nitems;
2711		2767
		2768	XFree (ct2.value);
		2769	}
		2770
		2771	if (ct.value == 0)
		2772	goto bailout;
		2773
2712	if (ct.encoding == xa[XA_INCR])	2774	if (ct.encoding == xa[XA_INCR])
2713	{	2775	{
2714	// INCR selection, start handshake	2776	// INCR selection, start handshake
		2777	if (!delete_prop)
2715	XDeleteProperty (display->display, win, prop);	2778	XDeleteProperty (display->display, win, prop);
		2779
2716	selection_wait = Sel_incr;	2780	selection_wait = Sel_incr;
		2781	incr_buf_fill = 0;
2717	incr_ev.start (NOW + 10);	2782	incr_ev.start (NOW + 10);
2718	break;
2719	}
2720		2783
2721	if (ct.value == NULL)	2784	goto bailout;
2722	continue;	2785	}
2723		2786
2724	if (ct.nitems == 0)	2787	if (ct.nitems == 0)
		2788	{
		2789	if (selection_wait == Sel_incr)
		2790	{
		2791	XFree (ct.value);
		2792
		2793	// finally complete, now paste the whole thing
		2794	selection_wait = Sel_normal;
		2795	ct.value = (unsigned char *)incr_buf;
		2796	ct.nitems = incr_buf_fill;
		2797	incr_buf = 0;
		2798	incr_buf_size = 0;
		2799	incr_ev.stop ();
2725	{	2800	}
		2801	else
		2802	{
2726	if (selection_wait == Sel_normal && nread == 0	2803	if (selection_wait == Sel_normal
2727	&& (win != display->root || prop != XA_CUT_BUFFER0)) // avoid recursion	2804	&& (win != display->root || prop != XA_CUT_BUFFER0)) // avoid recursion
2728	{	2805	{
2729	/*	2806	/*
2730	* pass through again trying CUT_BUFFER0 if we've come from	2807	* pass through again trying CUT_BUFFER0 if we've come from
2731	* XConvertSelection () but nothing was presented	2808	* XConvertSelection () but nothing was presented
2732	*/	2809	*/
2733	selection_paste (display->root, XA_CUT_BUFFER0, False);	2810	selection_paste (display->root, XA_CUT_BUFFER0, False);
2734	}	2811	}
2735		2812
2736	nread = -1; /* discount any previous stuff */	2813	goto bailout;
2737	break;	2814	}
		2815	}
		2816	else if (selection_wait == Sel_incr)
		2817	{
		2818	incr_ev.start (NOW + 10);
		2819
		2820	while (incr_buf_fill + ct.nitems > incr_buf_size)
2738	}	2821	{
		2822	incr_buf_size = incr_buf_size ? incr_buf_size * 2 : 128*1024;
		2823	incr_buf = (char *)realloc (incr_buf, incr_buf_size);
		2824	}
2739		2825
		2826	memcpy (incr_buf + incr_buf_fill, ct.value, ct.nitems);
2740	nread += ct.nitems;	2827	incr_buf_fill += ct.nitems;
2741		2828
		2829	goto bailout;
		2830	}
		2831
2742	char **cl;	2832	char **cl;
2743	int cr;	2833	int cr;
		2834
		2835	#if ENABLE_FRILLS
		2836	// xlib is horribly broken with respect to UTF8_STRING, and nobody cares to fix it
		2837	// so recode it manually
		2838	if (ct.encoding == xa[XA_UTF8_STRING])
		2839	{
		2840	wchar_t *w = rxvt_utf8towcs ((const char *)ct.value, ct.nitems);
		2841	char *s = rxvt_wcstombs (w);
		2842	free (w);
		2843	// TODO: strlen == only the first element will be converted. well...
		2844	paste ((unsigned char *)s, strlen (s));
		2845	free (s);
		2846	}
		2847	else
		2848	#endif
2744	if (XmbTextPropertyToTextList (display->display, &ct, &cl, &cr) >= 0 && cl)	2849	if (XmbTextPropertyToTextList (display->display, &ct, &cl, &cr) >= 0
2745	{	2850	&& cl)
		2851	{
2746	for (int i = 0; i < cr; i++)	2852	for (int i = 0; i < cr; i++)
2747	paste ((unsigned char *)cl[i], strlen (cl[i]));	2853	paste ((unsigned char *)cl[i], strlen (cl[i]));
2748		2854
2749	XFreeStringList (cl);	2855	XFreeStringList (cl);
2750	}	2856	}
2751	else	2857	else
2752	paste (ct.value, ct.nitems);	2858	paste (ct.value, ct.nitems); // paste raw
2753		2859
2754	if (bytes_after == 0)	2860	bailout:
2755	break;
2756
2757	XFree (ct.value);
2758	}
2759
2760	if (ct.value)
2761	XFree (ct.value);	2861	XFree (ct.value);
2762		2862
2763	if (selection_wait == Sel_normal)	2863	if (selection_wait == Sel_normal)
2764	selection_wait = Sel_none;	2864	selection_wait = Sel_none;
2765
2766	return (int)nread;
2767	}	2865	}
2768		2866
2769	void	2867	void
2770	rxvt_term::incr_cb (time_watcher &w)	2868	rxvt_term::incr_cb (time_watcher &w)
2771	{	2869	{
2772	selection_wait = Sel_none;	2870	selection_wait = Sel_none;
2773		2871
		2872	incr_buf_size = 0;
		2873	free (incr_buf);
		2874
2774	rxvt_warn ("data loss: timeout on INCR selection paste, ignoring.\n");	2875	rxvt_warn ("data loss: timeout on INCR selection paste, ignoring.\n");
2775	}	2876	}
2776		2877
2777	/*
2778	* INCR support originally provided by Paul Sheer <psheer@obsidian.co.za>
2779	*/
2780	void	2878	void
2781	rxvt_term::selection_property (Window win, Atom prop)	2879	rxvt_term::selection_property (Window win, Atom prop)
2782	{	2880	{
2783	if (prop == None || selection_wait != Sel_incr)	2881	if (prop == None || selection_wait != Sel_incr)
2784	return;	2882	return;
2785		2883
2786	if (selection_paste (win, prop, 1) > 0)	2884	selection_paste (win, prop, true);
2787	incr_ev.start (NOW + 10);
2788	else
2789	{
2790	selection_wait = Sel_none;
2791	incr_ev.stop ();
2792	}
2793	}	2885	}
2794		2886
2795	/* ------------------------------------------------------------------------- */	2887	/* ------------------------------------------------------------------------- */
2796	/*	2888	/*
2797	* Request the current selection:	2889	* Request the current selection:
…		…
2831	#else	2923	#else
2832	selection_type = Sel_CompoundText;	2924	selection_type = Sel_CompoundText;
2833	if (selection_request_other (xa[XA_COMPOUND_TEXT], i))	2925	if (selection_request_other (xa[XA_COMPOUND_TEXT], i))
2834	return;	2926	return;
2835	#endif	2927	#endif
2836
2837	}	2928	}
2838	}	2929	}
2839		2930
2840	selection_wait = Sel_none; /* don't loop in rxvt_selection_paste () */	2931	selection_wait = Sel_none; /* don't loop in selection_paste () */
2841	selection_paste (display->root, XA_CUT_BUFFER0, False);	2932	selection_paste (display->root, XA_CUT_BUFFER0, false);
2842	}	2933	}
2843		2934
2844	int	2935	int
2845	rxvt_term::selection_request_other (Atom target, int selnum)	2936	rxvt_term::selection_request_other (Atom target, int selnum)
2846	{	2937	{
2847	Atom sel;	2938	Atom sel;
2848	#ifdef DEBUG_SELECT
2849	char *debug_xa_names[] = { "PRIMARY", "SECONDARY", "CLIPBOARD" };
2850	#endif
2851		2939
2852	selection_type |= selnum;	2940	selection_type |= selnum;
2853		2941
2854	if (selnum == Sel_Primary)	2942	if (selnum == Sel_Primary)
2855	sel = XA_PRIMARY;	2943	sel = XA_PRIMARY;
…		…
2919		3007
2920	i = (selection.end.row - selection.beg.row + 1) * (TermWin.ncol + 1);	3008	i = (selection.end.row - selection.beg.row + 1) * (TermWin.ncol + 1);
2921	new_selection_text = (wchar_t *)rxvt_malloc ((i + 4) * sizeof (wchar_t));	3009	new_selection_text = (wchar_t *)rxvt_malloc ((i + 4) * sizeof (wchar_t));
2922		3010
2923	col = selection.beg.col;	3011	col = selection.beg.col;
2924	MAX_IT (col, 0);
2925	row = selection.beg.row + TermWin.saveLines;	3012	row = selection.beg.row + TermWin.saveLines;
2926	end_row = selection.end.row + TermWin.saveLines;	3013	end_row = selection.end.row + TermWin.saveLines;
2927	int ofs = 0;	3014	int ofs = 0;
2928	int extra = 0;	3015	int extra = 0;
2929		3016
2930	for (; row <= end_row; row++, col = 0)	3017	for (; row <= end_row; row++, col = 0)
2931	{	3018	{
2932	t = &screen.text[row][col];
2933
2934	end_col = screen.tlen[row];	3019	end_col = screen.tlen[row];
		3020
		3021	#if ENABLE_FRILLS
		3022	if (selection.rect)
		3023	{
		3024	col = selection.beg.col;
		3025	end_col = TermWin.ncol + 1;
		3026	}
		3027	#endif
		3028
		3029	MAX_IT (col, 0);
2935		3030
2936	if (end_col == -1)	3031	if (end_col == -1)
2937	end_col = TermWin.ncol;	3032	end_col = TermWin.ncol;
2938		3033
2939	if (row == end_row)	3034	if (row == end_row || selection.rect)
2940	MIN_IT (end_col, selection.end.col);	3035	MIN_IT (end_col, selection.end.col);
2941		3036
		3037	t = &screen.text[row][col];
2942	for (; col < end_col; col++)	3038	for (; col < end_col; col++)
2943	{	3039	{
2944	if (*t == NOCHAR)	3040	if (*t == NOCHAR)
2945	t++;	3041	t++;
2946	#if ENABLE_COMBINING	3042	#if ENABLE_COMBINING
…		…
2994	#if 0	3090	#if 0
2995	XTextProperty ct;	3091	XTextProperty ct;
2996		3092
2997	if (XwcTextListToTextProperty (display->display, &selection.text, 1, XStringStyle, &ct) >= 0)	3093	if (XwcTextListToTextProperty (display->display, &selection.text, 1, XStringStyle, &ct) >= 0)
2998	{	3094	{
2999	XChangeProperty (display->display, display->root, XA_CUT_BUFFER0, XA_STRING, 8,	3095	set_string_property (XA_CUT_BUFFER0, ct.value, ct.nitems);
3000	PropModeReplace, ct.value, ct.nitems);
3001	XFree (ct.value);	3096	XFree (ct.value);
3002	}	3097	}
3003	#endif	3098	#endif
3004		3099
3005	selection_time = tm;	3100	selection_time = tm;
…		…
3206	enum {	3301	enum {
3207	LEFT, RIGHT	3302	LEFT, RIGHT
3208	} closeto = RIGHT;	3303	} closeto = RIGHT;
3209		3304
3210	want_refresh = 1;	3305	want_refresh = 1;
		3306
3211	switch (selection.op)	3307	switch (selection.op)
3212	{	3308	{
3213	case SELECTION_INIT:	3309	case SELECTION_INIT:
3214	CLEAR_SELECTION ();	3310	CLEAR_SELECTION ();
3215	selection.op = SELECTION_BEGIN;	3311	selection.op = SELECTION_BEGIN;
…		…
3228	selection_start_colrow (col, row);	3324	selection_start_colrow (col, row);
3229	/* FALLTHROUGH */	3325	/* FALLTHROUGH */
3230	default:	3326	default:
3231	return;	3327	return;
3232	}	3328	}
		3329
3233	if (selection.beg.col == selection.end.col	3330	if (selection.beg.col == selection.end.col
3234	&& selection.beg.col != selection.mark.col	3331	&& selection.beg.col != selection.mark.col
3235	&& selection.beg.row == selection.end.row	3332	&& selection.beg.row == selection.end.row
3236	&& selection.beg.row != selection.mark.row)	3333	&& selection.beg.row != selection.mark.row)
3237	{	3334	{
…		…
3287	}	3384	}
3288	else	3385	else
3289	{ /* button1 drag or button3 drag */	3386	{ /* button1 drag or button3 drag */
3290	if (ROWCOL_IS_AFTER (selection.mark, pos))	3387	if (ROWCOL_IS_AFTER (selection.mark, pos))
3291	{	3388	{
3292	if ((selection.mark.row == selection.end.row)	3389	if (selection.mark.row == selection.end.row
3293	&& (selection.mark.col == selection.end.col)	3390	&& selection.mark.col == selection.end.col
		3391	&& clickchange
3294	&& clickchange && selection.clicks == 2)	3392	&& selection.clicks == 2)
3295	selection.mark.col--;	3393	selection.mark.col--;
3296		3394
3297	selection.beg.row = pos.row;	3395	selection.beg.row = pos.row;
3298	selection.beg.col = pos.col;	3396	selection.beg.col = pos.col;
3299	selection.end.row = selection.mark.row;	3397	selection.end.row = selection.mark.row;
…		…
3310		3408
3311	if (selection.clicks == 1)	3409	if (selection.clicks == 1)
3312	{	3410	{
3313	end_col = screen.tlen[selection.beg.row + TermWin.saveLines];	3411	end_col = screen.tlen[selection.beg.row + TermWin.saveLines];
3314		3412
3315	if (end_col != -1 && selection.beg.col > end_col)	3413	if (selection.beg.col > end_col
		3414	&& end_col != -1
		3415	#if ENABLE_FRILLS
		3416	&& !selection.rect
		3417	#endif
3316	{	3418	)
3317	#if 1
3318	selection.beg.col = ncol;	3419	selection.beg.col = ncol;
3319	#else
3320	if (selection.beg.row != selection.end.row)
3321	selection.beg.col = ncol;
3322	else
3323	selection.beg.col = selection.mark.col;
3324	#endif
3325	}
3326		3420
3327	end_col = screen.tlen[selection.end.row + TermWin.saveLines];	3421	end_col = screen.tlen[selection.end.row + TermWin.saveLines];
3328		3422
3329	if (end_col != -1 && selection.end.col > end_col)	3423	if (
		3424	selection.end.col > end_col
		3425	&& end_col != -1
		3426	#if ENABLE_FRILLS
		3427	&& !selection.rect
		3428	#endif
		3429	)
3330	selection.end.col = ncol;	3430	selection.end.col = ncol;
3331	}	3431	}
3332	else if (selection.clicks == 2)	3432	else if (selection.clicks == 2)
3333	{	3433	{
3334	if (ROWCOL_IS_AFTER (selection.end, selection.beg))	3434	if (ROWCOL_IS_AFTER (selection.end, selection.beg))
3335	selection.end.col--;	3435	selection.end.col--;
3336		3436
3337	selection_delimit_word (UP, & (selection.beg), & (selection.beg));
3338	selection_delimit_word (DN, & (selection.end), & (selection.end));	3437	selection_delimit_word (UP, &selection.beg, &selection.beg);
		3438	selection_delimit_word (DN, &selection.end, &selection.end);
3339	}	3439	}
3340	else if (selection.clicks == 3)	3440	else if (selection.clicks == 3)
3341	{	3441	{
3342	#if ENABLE_FRILLS	3442	#if ENABLE_FRILLS
3343	if ((options & Opt_tripleclickwords))	3443	if (options & Opt_tripleclickwords)
3344	{	3444	{
3345	int end_row;	3445	int end_row;
3346		3446
3347	selection_delimit_word (UP, & (selection.beg), & (selection.beg));	3447	selection_delimit_word (UP, &selection.beg, &selection.beg);
3348	end_row = screen.tlen[selection.mark.row + TermWin.saveLines];	3448	end_row = screen.tlen[selection.mark.row + TermWin.saveLines];
3349		3449
3350	for (end_row = selection.mark.row; end_row < TermWin.nrow; end_row++)	3450	for (end_row = selection.mark.row; end_row < TermWin.nrow; end_row++)
3351	{	3451	{
3352	end_col = screen.tlen[end_row + TermWin.saveLines];	3452	end_col = screen.tlen[end_row + TermWin.saveLines];
…		…
3363	else	3463	else
3364	#endif	3464	#endif
3365	{	3465	{
3366	if (ROWCOL_IS_AFTER (selection.mark, selection.beg))	3466	if (ROWCOL_IS_AFTER (selection.mark, selection.beg))
3367	selection.mark.col++;	3467	selection.mark.col++;
		3468
3368	selection.beg.col = 0;	3469	selection.beg.col = 0;
3369	selection.end.col = ncol;	3470	selection.end.col = ncol;
		3471
		3472	// select a complete logical line
		3473	while (selection.beg.row > -TermWin.saveLines
		3474	&& screen.tlen[selection.beg.row - 1 + TermWin.saveLines] == -1)
		3475	selection.beg.row--;
		3476
		3477	while (selection.end.row < TermWin.nrow
		3478	&& screen.tlen[selection.end.row + TermWin.saveLines] == -1)
		3479	selection.end.row++;
3370	}	3480	}
3371	}	3481	}
3372		3482
3373	if (button3 && buttonpress)	3483	if (button3 && buttonpress)
3374	{ /* mark may need to be changed */	3484	{ /* mark may need to be changed */
…		…
3381	{	3491	{
3382	selection.mark.row = selection.beg.row;	3492	selection.mark.row = selection.beg.row;
3383	selection.mark.col = selection.beg.col;	3493	selection.mark.col = selection.beg.col;
3384	}	3494	}
3385	}	3495	}
3386	}
3387		3496
3388	#if ENABLE_FRILLS	3497	#if ENABLE_FRILLS
		3498	if (selection.rect && selection.beg.col > selection.end.col)
		3499	SWAP_IT (selection.beg.col, selection.end.col, int);
		3500	#endif
		3501	}
		3502
		3503	#if ENABLE_FRILLS
3389	void	3504	void
3390	rxvt_term::selection_remove_trailing_spaces ()	3505	rxvt_term::selection_remove_trailing_spaces ()
3391	{	3506	{
3392	int32_t end_col, end_row;	3507	int32_t end_col, end_row;
3393	text_t *stp;	3508	text_t *stp;
3394		3509
3395	end_col = selection.end.col;	3510	end_col = selection.end.col;
3396	end_row = selection.end.row;	3511	end_row = selection.end.row;
		3512
3397	for ( ; end_row >= selection.beg.row; )	3513	for ( ; end_row >= selection.beg.row; )
3398	{	3514	{
3399	stp = screen.text[end_row + TermWin.saveLines];	3515	stp = screen.text[end_row + TermWin.saveLines];
		3516
3400	while (--end_col >= 0)	3517	while (--end_col >= 0)
3401	{	3518	{
3402	if (stp[end_col] != ' ' && stp[end_col] != '\t')	3519	if (stp[end_col] != ' '
		3520	&& stp[end_col] != '\t'
		3521	&& stp[end_col] != NOCHAR)
3403	break;	3522	break;
3404	}	3523	}
		3524
3405	if (end_col >= 0	3525	if (end_col >= 0
3406	|| screen.tlen[end_row - 1 + TermWin.saveLines] != -1)	3526	|| screen.tlen[end_row - 1 + TermWin.saveLines] != -1)
3407	{	3527	{
3408	selection.end.col = end_col + 1;	3528	selection.end.col = end_col + 1;
3409	selection.end.row = end_row;	3529	selection.end.row = end_row;
3410	break;	3530	break;
3411	}	3531	}
		3532
3412	end_row--;	3533	end_row--;
3413	end_col = TermWin.ncol;	3534	end_col = TermWin.ncol;
3414	}	3535	}
		3536
3415	if (selection.mark.row > selection.end.row)	3537	if (selection.mark.row > selection.end.row)
3416	{	3538	{
3417	selection.mark.row = selection.end.row;	3539	selection.mark.row = selection.end.row;
3418	selection.mark.col = selection.end.col;	3540	selection.mark.col = selection.end.col;
3419	}	3541	}
…		…
3435	selection_extend_colrow (Pixel2Col (x), Pixel2Row (y), 1, 0, 1);	3557	selection_extend_colrow (Pixel2Col (x), Pixel2Row (y), 1, 0, 1);
3436	}	3558	}
3437		3559
3438	/* ------------------------------------------------------------------------- */	3560	/* ------------------------------------------------------------------------- */
3439	/*	3561	/*
3440	* On some systems, the Atom typedef is 64 bits wide. We need to have a type
3441	* that is exactly 32 bits wide, because a format of 64 is not allowed by
3442	* the X11 protocol.
3443	*/
3444	typedef CARD32 Atom32;
3445
3446	/* ------------------------------------------------------------------------- */
3447	/*
3448	* Respond to a request for our current selection	3562	* Respond to a request for our current selection
3449	* EXT: SelectionRequest	3563	* EXT: SelectionRequest
3450	*/	3564	*/
3451	void	3565	void
3452	rxvt_term::selection_send (const XSelectionRequestEvent &rq)	3566	rxvt_term::selection_send (const XSelectionRequestEvent &rq)
3453	{	3567	{
3454	XSelectionEvent ev;	3568	XSelectionEvent ev;
3455	XTextProperty ct;	3569	dDisp;
3456	XICCEncodingStyle style;
3457	Atom target;
3458		3570
3459	ev.type = SelectionNotify;	3571	ev.type = SelectionNotify;
3460	ev.property = None;	3572	ev.property = None;
3461	ev.display = rq.display;	3573	ev.display = rq.display;
3462	ev.requestor = rq.requestor;	3574	ev.requestor = rq.requestor;
…		…
3464	ev.target = rq.target;	3576	ev.target = rq.target;
3465	ev.time = rq.time;	3577	ev.time = rq.time;
3466		3578
3467	if (rq.target == xa[XA_TARGETS])	3579	if (rq.target == xa[XA_TARGETS])
3468	{	3580	{
3469	Atom32 target_list[6];	3581	Atom target_list[6];
3470	Atom32 *target = target_list;	3582	Atom *target = target_list;
3471		3583
3472	*target++ = (Atom32) xa[XA_TARGETS];	3584	*target++ = xa[XA_TARGETS];
3473	*target++ = (Atom32) xa[XA_TIMESTAMP];	3585	*target++ = xa[XA_TIMESTAMP];
3474	*target++ = (Atom32) XA_STRING;	3586	*target++ = XA_STRING;
3475	*target++ = (Atom32) xa[XA_TEXT];	3587	*target++ = xa[XA_TEXT];
3476	*target++ = (Atom32) xa[XA_COMPOUND_TEXT];	3588	*target++ = xa[XA_COMPOUND_TEXT];
3477	#if X_HAVE_UTF8_STRING	3589	#if X_HAVE_UTF8_STRING
3478	*target++ = (Atom32) xa[XA_UTF8_STRING];	3590	*target++ = xa[XA_UTF8_STRING];
3479	#endif	3591	#endif
3480		3592
3481	XChangeProperty (display->display, rq.requestor, rq.property, XA_ATOM,	3593	XChangeProperty (disp, rq.requestor, rq.property, XA_ATOM,
3482	(8 * sizeof (target_list[0])), PropModeReplace,	3594	32, PropModeReplace,
3483	(unsigned char *)target_list,	3595	(unsigned char *)target_list, target - target_list);
3484	target - target_list);
3485	ev.property = rq.property;	3596	ev.property = rq.property;
3486	}	3597	}
3487	#if TODO // TODO	3598	#if TODO // TODO
3488	else if (rq.target == xa[XA_MULTIPLE])	3599	else if (rq.target == xa[XA_MULTIPLE])
3489	{	3600	{
3490	/* TODO: Handle MULTIPLE */	3601	/* TODO: Handle MULTIPLE */
3491	}	3602	}
3492	#endif	3603	#endif
3493	else if (rq.target == xa[XA_TIMESTAMP] && selection.text)	3604	else if (rq.target == xa[XA_TIMESTAMP] && selection.text)
3494	{	3605	{
3495	XChangeProperty (display->display, rq.requestor, rq.property, XA_INTEGER,	3606	XChangeProperty (disp, rq.requestor, rq.property, rq.target,
3496	(8 * sizeof (Time)), PropModeReplace,
3497	(unsigned char *)&selection_time, 1);	3607	32, PropModeReplace, (unsigned char *)&selection_time, 1);
3498	ev.property = rq.property;	3608	ev.property = rq.property;
3499	}	3609	}
3500	else if (rq.target == XA_STRING	3610	else if (rq.target == XA_STRING
3501	|| rq.target == xa[XA_TEXT]	3611	|| rq.target == xa[XA_TEXT]
3502	|| rq.target == xa[XA_COMPOUND_TEXT]	3612	|| rq.target == xa[XA_COMPOUND_TEXT]
3503	|| rq.target == xa[XA_UTF8_STRING]	3613	|| rq.target == xa[XA_UTF8_STRING]
3504	)	3614	)
3505	{	3615	{
		3616	XTextProperty ct;
		3617	Atom target = rq.target;
3506	short freect = 0;	3618	short freect = 0;
3507	int selectlen;	3619	int selectlen;
3508	wchar_t *cl;	3620	wchar_t *cl;
3509		3621	enum {
3510	target = rq.target;	3622	enc_string = XStringStyle,
		3623	enc_text = XStdICCTextStyle,
		3624	enc_compound_text = XCompoundTextStyle,
		3625	#ifdef X_HAVE_UTF8_STRING
		3626	enc_utf8 = XUTF8StringStyle,
		3627	#else
		3628	enc_utf8 = -1,
		3629	#endif
		3630	} style;
3511		3631
3512	if (target == XA_STRING)	3632	if (target == XA_STRING)
3513	// we actually don't do XA_STRING, but who cares, as i18n clients	3633	// we actually don't do XA_STRING, but who cares, as i18n clients
3514	// will ask for another format anyways.	3634	// will ask for another format anyways.
3515	style = XStringStyle;	3635	style = enc_string;
3516	else if (target == xa[XA_TEXT])	3636	else if (target == xa[XA_TEXT])
3517	style = XStdICCTextStyle;	3637	style = enc_text;
3518	else if (target == xa[XA_COMPOUND_TEXT])	3638	else if (target == xa[XA_COMPOUND_TEXT])
3519	style = XCompoundTextStyle;	3639	style = enc_compound_text;
3520	#if X_HAVE_UTF8_STRING	3640	#if ENABLE_FRILLS
3521	else if (target == xa[XA_UTF8_STRING])	3641	else if (target == xa[XA_UTF8_STRING])
3522	style = XUTF8StringStyle;	3642	style = enc_utf8;
3523	#endif	3643	#endif
3524	else	3644	else
3525	{	3645	{
3526	target = xa[XA_COMPOUND_TEXT];	3646	target = xa[XA_COMPOUND_TEXT];
3527	style = XCompoundTextStyle;	3647	style = enc_compound_text;
3528	}	3648	}
3529		3649
3530	if (selection.text)	3650	if (selection.text)
3531	{	3651	{
3532	cl = selection.text;	3652	cl = selection.text;
…		…
3536	{	3656	{
3537	cl = L"";	3657	cl = L"";
3538	selectlen = 0;	3658	selectlen = 0;
3539	}	3659	}
3540		3660
3541	// Xwc doesn't handle iso-10646 in wchar_t gracefully, so maybe recode it	3661	#if ENABLE_FRILLS
3542	// manually for XUTF8StringStyle.	3662	// xlib is horribly broken with respect to UTF8_STRING, and nobody cares to fix it
		3663	// so recode it manually
		3664	if (style == enc_utf8)
		3665	{
		3666	freect = 1;
		3667	ct.encoding = target;
		3668	ct.format = 8;
		3669	ct.value = (unsigned char *)rxvt_wcstoutf8 (cl, selectlen);
		3670	ct.nitems = strlen ((char *)ct.value);
		3671	}
		3672	else
		3673	#endif
3543	if (XwcTextListToTextProperty (display->display, &cl, 1, style, &ct) >= 0)	3674	if (XwcTextListToTextProperty (disp, &cl, 1, (XICCEncodingStyle) style, &ct) >= 0)
3544	freect = 1;	3675	freect = 1;
3545	else	3676	else
3546	{	3677	{
3547	/* if we failed to convert then send it raw */	3678	/* if we failed to convert then send it raw */
3548	ct.value = (unsigned char *)cl;	3679	ct.value = (unsigned char *)cl;
3549	ct.nitems = selectlen;	3680	ct.nitems = selectlen;
		3681	ct.encoding = target;
3550	}	3682	}
3551		3683
3552	XChangeProperty (display->display, rq.requestor, rq.property,	3684	XChangeProperty (disp, rq.requestor, rq.property,
3553	target, 8, PropModeReplace,	3685	ct.encoding, 8, PropModeReplace,
3554	ct.value, (int)ct.nitems);	3686	ct.value, (int)ct.nitems);
3555	ev.property = rq.property;	3687	ev.property = rq.property;
3556		3688
3557	if (freect)	3689	if (freect)
3558	XFree (ct.value);	3690	XFree (ct.value);
3559	}	3691	}
3560		3692
3561	XSendEvent (display->display, rq.requestor, False, 0L, (XEvent *)&ev);	3693	XSendEvent (disp, rq.requestor, False, 0L, (XEvent *)&ev);
3562	}	3694	}
3563		3695
3564	/* ------------------------------------------------------------------------- *	3696	/* ------------------------------------------------------------------------- *
3565	* MOUSE ROUTINES *	3697	* MOUSE ROUTINES *
3566	* ------------------------------------------------------------------------- */	3698	* ------------------------------------------------------------------------- */
…		…
3686	while (*s)	3818	while (*s)
3687	scr_overlay_set (x++, y, *s++);	3819	scr_overlay_set (x++, y, *s++);
3688	}	3820	}
3689		3821
3690	void	3822	void
		3823	rxvt_term::scr_overlay_set (int x, int y, const wchar_t *s)
		3824	{
		3825	while (*s)
		3826	{
		3827	text_t t = *s++;
		3828	int width = wcwidth (t);
		3829
		3830	while (width--)
		3831	{
		3832	scr_overlay_set (x++, y, t);
		3833	t = NOCHAR;
		3834	}
		3835	}
		3836	}
		3837
		3838	void
3691	rxvt_term::scr_swap_overlay ()	3839	rxvt_term::scr_swap_overlay ()
3692	{	3840	{
3693	if (!ov_text)	3841	if (!ov_text)
3694	return;	3842	return;
3695		3843

Diff Legend

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