[ViewVC] Diff of: cvs/rxvt-unicode/src/screen.C

Comparing rxvt-unicode/src/screen.C (file contents):
Revision 1.136 by root, Tue Sep 7 21:05:41 2004 UTC vs.
Revision 1.161 by root, Tue Feb 22 21:41:50 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++)
…		…
878		873
879	stp = screen.text[row]; /* _must_ refresh */	874	stp = screen.text[row]; /* _must_ refresh */
880	srp = screen.rend[row]; /* _must_ refresh */	875	srp = screen.rend[row]; /* _must_ refresh */
881	}	876	}
882		877
883	if (screen.flags & Screen_Insert)
884	scr_insdel_chars (1, INSERT);
885
886	// rely on wcwidth to tell us the character width, at least for non-latin1	878	// 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	879	// do wcwidth before further replacements, as wcwidth says that line-drawing
888	// characters have width -1 (DOH!) on GNU/Linux sometimes.	880	// characters have width -1 (DOH!) on GNU/Linux sometimes.
889	int width = c < 0x100 ? 1 : wcwidth (c);	881	int width = c < 0x100 ? 1 : wcwidth (c);
890		882
891	if (charsets[screen.charset] == '0') // DEC SPECIAL	883	if (charsets[screen.charset] == '0') // DEC SPECIAL
892	{	884	{
893	// vt100 special graphics and line drawing	885	// vt100 special graphics and line drawing
894	// 5f-7e standard vt100	886	// 5f-7e standard vt100
895	// 40-5e rxvt extension for extra curses acs chars	887	// 40-5e rxvt extension for extra curses acs chars
896	static uint16_t vt100_0[63] = { // 5f .. 7e	888	static uint16_t vt100_0[63] = { // 40 .. 7e
897	0x0000, 0x2191, 0x2193, 0x2192, 0x2190, 0x2588, 0x259a, 0x2603, // 40-47 hi mr. snowman!	889	0x0000, 0x2191, 0x2193, 0x2192, 0x2190, 0x2588, 0x259a, 0x2603, // 40-47 hi mr. snowman!
898	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 48-4f	890	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 48-4f
899	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 50-57	891	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, // 50-57
900	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, // 58-5f	892	0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0020, // 58-5f
901	0x25c6, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0, 0x00b1, // 60-67	893	0x25c6, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0, 0x00b1, // 60-67
…		…
909	c = vt100_0[c - 0x40];	901	c = vt100_0[c - 0x40];
910	width = 1;	902	width = 1;
911	}	903	}
912	}	904	}
913		905
		906	if (screen.flags & Screen_Insert)
		907	scr_insdel_chars (width, INSERT);
		908
914	if (width != 0)	909	if (width != 0)
915	{	910	{
916	// some utf-8 decoders decode surrogate characters.	911	// some utf-8 decoders decode surrogate characters.
917	if (0xd800 <= c && c <= 0xdfff)	912	if (0xd800 <= c && c <= 0xdfff)
918	c = 0xfffd;	913	c = 0xfffd;
…		…
968	c = NOCHAR;	963	c = NOCHAR;
969	}	964	}
970	while (--width > 0);	965	while (--width > 0);
971		966
972	// pad with spaces when overwriting wide character with smaller one	967	// pad with spaces when overwriting wide character with smaller one
		968	if (!width)
973	for (int c = screen.cur.col; c < last_col && stp[c] == NOCHAR; c++)	969	for (int c = screen.cur.col; c < last_col && stp[c] == NOCHAR; c++)
974	{	970	{
975	stp[c] = ' ';	971	stp[c] = ' ';
976	srp[c] = rend;	972	srp[c] = rend;
977	}	973	}
978	}	974	}
979	else if (width == 0)	975	else if (width == 0)
980	{	976	{
981	#if ENABLE_COMBINING	977	#if ENABLE_COMBINING
982	// handle combining characters	978	// handle combining characters
…		…
1095	if (count)	1091	if (count)
1096	x = TermWin.ncol - 1;	1092	x = TermWin.ncol - 1;
1097		1093
1098	// store horizontal tab commands as characters inside the text	1094	// store horizontal tab commands as characters inside the text
1099	// buffer so they can be selected and pasted.	1095	// buffer so they can be selected and pasted.
1100	if (ht)	1096	if (ht && options & Opt_pastableTabs)
1101	{	1097	{
1102	base_rend = SET_FONT (base_rend, 0);	1098	base_rend = SET_FONT (base_rend, 0);
1103		1099
1104	if (screen.tlen[row] != -1) /* XXX: think about this */	1100	if (screen.tlen[row] != -1) /* XXX: think about this */
1105	MAX_IT (screen.tlen[row], x);	1101	MAX_IT (screen.tlen[row], x);
…		…
1165	*/	1161	*/
1166	#if ENABLE_FRILLS	1162	#if ENABLE_FRILLS
1167	void	1163	void
1168	rxvt_term::scr_forwardindex ()	1164	rxvt_term::scr_forwardindex ()
1169	{	1165	{
1170	int row;	1166	int row;
1171		1167
1172	if (screen.cur.col < TermWin.ncol - 1)	1168	if (screen.cur.col < TermWin.ncol - 1)
1173	scr_gotorc (0, 1, R_RELATIVE \| C_RELATIVE);	1169	scr_gotorc (0, 1, R_RELATIVE \| C_RELATIVE);
1174	else	1170	else
1175	{	1171	{
…		…
1378	ren = DEFAULT_RSTYLE;	1374	ren = DEFAULT_RSTYLE;
1379	CLEAR_ROWS (row, num);	1375	CLEAR_ROWS (row, num);
1380	}	1376	}
1381	else	1377	else
1382	{	1378	{
1383	ren = (rstyle & (RS_fgMask \| RS_bgMask));	1379	ren = rstyle & (RS_fgMask \| RS_bgMask);
1384	gcvalue.foreground = pix_colors[GET_BGCOLOR (rstyle)];	1380	gcvalue.foreground = pix_colors[GET_BGCOLOR (rstyle)];
1385	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);	1381	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);
1386	ERASE_ROWS (row, num);	1382	ERASE_ROWS (row, num);
1387	gcvalue.foreground = pix_colors[Color_fg];	1383	gcvalue.foreground = pix_colors[Color_fg];
1388	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);	1384	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);
1389	}	1385	}
1390		1386
1391	for (; num--; row++)	1387	for (; num--; row++)
1392	{	1388	{
1393	scr_blank_screen_mem (screen.text, screen.rend,	1389	scr_blank_screen_mem (screen.text, screen.rend, (unsigned int) (row + row_offset), rstyle);
1394	(unsigned int) (row + row_offset), rstyle);
1395	screen.tlen[row + row_offset] = 0;	1390	screen.tlen[row + row_offset] = 0;
1396	scr_blank_line (drawn_text[row], drawn_rend[row],	1391	scr_blank_line (drawn_text[row], drawn_rend[row], (unsigned int)TermWin.ncol, ren);
1397	(unsigned int)TermWin.ncol, ren);
1398	}	1392	}
1399	}	1393	}
		1394
		1395	#if ENABLE_FRILLS
		1396	void
		1397	rxvt_term::scr_erase_savelines ()
		1398	{
		1399	want_refresh = 1;
		1400	ZERO_SCROLLBACK ();
		1401
		1402	TermWin.nscrolled = 0;
		1403	}
		1404	#endif
1400		1405
1401	/* ------------------------------------------------------------------------- */	1406	/* ------------------------------------------------------------------------- */
1402	/*	1407	/*
1403	* Fill the screen with `E's	1408	* Fill the screen with `E's
1404	* XTERM_SEQ: Screen Alignment Test: ESC # 8	1409	* XTERM_SEQ: Screen Alignment Test: ESC # 8
1405	*/	1410	*/
1406	void	1411	void
1407	rxvt_term::scr_E ()	1412	rxvt_term::scr_E ()
1408	{	1413	{
1409	int i, j, k;	1414	int i, j, k;
1410	rend_t *r1, fs;	1415	rend_t *r1, fs;
1411		1416
1412	want_refresh = 1;	1417	want_refresh = 1;
1413	ZERO_SCROLLBACK ();	1418	ZERO_SCROLLBACK ();
1414		1419
1415	num_scr_allow = 0;	1420	num_scr_allow = 0;
…		…
1898	rxvt_term::scr_page (enum page_dirn direction, int nlines)	1903	rxvt_term::scr_page (enum page_dirn direction, int nlines)
1899	{	1904	{
1900	int n;	1905	int n;
1901	unsigned int oldviewstart;	1906	unsigned int oldviewstart;
1902		1907
1903	#ifdef DEBUG_STRICT
1904	assert ((nlines >= 0) && (nlines <= TermWin.nrow));
1905	#endif
1906	oldviewstart = TermWin.view_start;	1908	oldviewstart = TermWin.view_start;
		1909
1907	if (direction == UP)	1910	if (direction == UP)
1908	{	1911	{
1909	n = TermWin.view_start + nlines;	1912	n = TermWin.view_start + nlines;
1910	TermWin.view_start = min (n, TermWin.nscrolled);	1913	TermWin.view_start = min (n, TermWin.nscrolled);
1911	}	1914	}
1912	else	1915	else
1913	{	1916	{
1914	n = TermWin.view_start - nlines;	1917	n = TermWin.view_start - nlines;
1915	TermWin.view_start = max (n, 0);	1918	TermWin.view_start = max (n, 0);
1916	}	1919	}
		1920
1917	return scr_changeview (oldviewstart);	1921	return scr_changeview (oldviewstart);
1918	}	1922	}
1919		1923
1920	int	1924	int
1921	rxvt_term::scr_changeview (unsigned int oldviewstart)	1925	rxvt_term::scr_changeview (unsigned int oldviewstart)
…		…
2241	&& GET_BGATTR (srp[col]) == GET_BGATTR (drp[col]))))	2245	&& GET_BGATTR (srp[col]) == GET_BGATTR (drp[col]))))
2242	continue;	2246	continue;
2243		2247
2244	// redraw one or more characters	2248	// redraw one or more characters
2245		2249
2246	// seek to the beginning if wide characters	2250	// seek to the beginning of wide characters
2247	while (stp[col] == NOCHAR && col > 0)	2251	while (stp[col] == NOCHAR && col > 0)
2248	--col;	2252	--col;
2249		2253
2250	rend_t rend = srp[col]; /* screen rendition (target rendtion) */	2254	rend_t rend = srp[col]; /* screen rendition (target rendtion) */
2251	text_t *text = stp + col;	2255	text_t *text = stp + col;
…		…
2395	}	2399	}
2396	else	2400	else
2397	font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, back);	2401	font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, back);
2398		2402
2399	if (rend & RS_Uline && font->descent > 1 && fore != back)	2403	if (rend & RS_Uline && font->descent > 1 && fore != back)
		2404	{
		2405	#if ENABLE_FRILLS
		2406	if (ISSET_PIXCOLOR (Color_underline))
		2407	XSetForeground (display->display, TermWin.gc, pix_colors[Color_underline]);
		2408	else
		2409	#endif
		2410	XSetForeground (display->display, TermWin.gc, pix_colors[fore]);
		2411
2400	XDrawLine (display->display, drawBuffer, TermWin.gc,	2412	XDrawLine (display->display, drawBuffer, TermWin.gc,
2401	xpixel, ypixel + font->ascent + 1,	2413	xpixel, ypixel + font->ascent + 1,
2402	xpixel + Width2Pixel (count) - 1, ypixel + font->ascent + 1);	2414	xpixel + Width2Pixel (count) - 1, ypixel + font->ascent + 1);
		2415	}
2403	} /* for (col....) */	2416	} /* for (col....) */
2404	} /* for (row....) */	2417	} /* for (row....) */
2405		2418
2406	#if ENABLE_OVERLAY	2419	#if ENABLE_OVERLAY
2407	scr_swap_overlay ();	2420	scr_swap_overlay ();
…		…
2649	/* ------------------------------------------------------------------------- */	2662	/* ------------------------------------------------------------------------- */
2650	/*	2663	/*
2651	* Paste a selection direct to the command fd	2664	* Paste a selection direct to the command fd
2652	*/	2665	*/
2653	void	2666	void
2654	rxvt_term::paste (const unsigned char *data, unsigned int len)	2667	rxvt_term::paste (unsigned char *data, unsigned int len)
2655	{	2668	{
2656	unsigned int i, j, n;
2657	unsigned char ds = (unsigned char )rxvt_malloc (PROP_SIZE);
2658
2659	/* convert normal newline chars into common keyboard Return key sequence */	2669	/* convert normal newline chars into common keyboard Return key sequence */
2660	for (i = 0; i < len; i += PROP_SIZE)	2670	for (unsigned int i = 0; i < len; i++)
2661	{
2662	n = min (len - i, PROP_SIZE);
2663	memcpy (ds, data + i, n);
2664
2665	for (j = 0; j < n; j++)
2666	if (ds[j] == C0_LF)	2671	if (data[i] == C0_LF)
2667	ds[j] = C0_CR;	2672	data[i] = C0_CR;
2668		2673
2669	tt_write (ds, (int)n);	2674	tt_write (data, len);
2670	}
2671
2672	free (ds);
2673	}	2675	}
2674		2676
2675	/* ------------------------------------------------------------------------- */	2677	/* ------------------------------------------------------------------------- */
2676	/*	2678	/*
2677	* Respond to a notification that a primary selection has been sent	2679	* Respond to a notification that a primary selection has been sent
2678	* EXT: SelectionNotify	2680	* EXT: SelectionNotify
2679	*/	2681	*/
2680	int	2682	void
2681	rxvt_term::selection_paste (Window win, Atom prop, bool delete_prop)	2683	rxvt_term::selection_paste (Window win, Atom prop, bool delete_prop)
2682	{	2684	{
2683	long nread = 0;
2684	unsigned long bytes_after;
2685	XTextProperty ct;
2686
2687	if (prop == None) /* check for failed XConvertSelection */	2685	if (prop == None) /* check for failed XConvertSelection */
2688	{	2686	{
2689	if ((selection_type & Sel_CompoundText))	2687	if ((selection_type & Sel_CompoundText))
2690	{	2688	{
2691	int selnum = selection_type & Sel_whereMask;	2689	int selnum = selection_type & Sel_whereMask;
…		…
2704	selection_request_other (xa[XA_COMPOUND_TEXT], selnum);	2702	selection_request_other (xa[XA_COMPOUND_TEXT], selnum);
2705	else	2703	else
2706	selection_type = 0;	2704	selection_type = 0;
2707	}	2705	}
2708		2706
2709	return 0;	2707	return;
2710	}
2711
2712	for (;;)
2713	{	2708	}
		2709
		2710	unsigned long bytes_after;
		2711	XTextProperty ct;
		2712
		2713	if (XGetWindowProperty (display->display, win, prop,
		2714	0, PROP_SIZE / 4,
		2715	delete_prop, AnyPropertyType,
		2716	&ct.encoding, &ct.format,
		2717	&ct.nitems, &bytes_after,
		2718	&ct.value) != Success)
		2719	{
		2720	ct.value = 0;
		2721	goto bailout;
		2722	}
		2723
		2724	if (ct.encoding == None)
		2725	goto bailout;
		2726
		2727	if (bytes_after)
		2728	{
		2729	// fetch and append remaining data
		2730	XTextProperty ct2;
		2731
2714	if (XGetWindowProperty (display->display, win, prop, (long) (nread / 4),	2732	if (XGetWindowProperty (display->display, win, prop,
2715	(long) (PROP_SIZE / 4), delete_prop,	2733	ct.nitems / 4, (bytes_after + 3) / 4,
		2734	delete_prop, AnyPropertyType,
2716	AnyPropertyType, &ct.encoding, &ct.format,	2735	&ct2.encoding, &ct2.format,
2717	&ct.nitems, &bytes_after,	2736	&ct2.nitems, &bytes_after,
2718	&ct.value) != Success)	2737	&ct2.value) != Success)
2719	break;	2738	goto bailout;
2720		2739
2721	if (ct.encoding == 0)	2740	// realloc should be compatible to XFree, here, and elsewhere, too
2722	break;	2741	ct.value = (unsigned char *)realloc (ct.value, ct.nitems + ct2.nitems + 1);
		2742	memcpy (ct.value + ct.nitems, ct2.value, ct2.nitems + 1);
		2743	ct.nitems += ct2.nitems;
2723		2744
		2745	XFree (ct2.value);
		2746	}
		2747
		2748	if (ct.value == 0)
		2749	goto bailout;
		2750
2724	if (ct.encoding == xa[XA_INCR])	2751	if (ct.encoding == xa[XA_INCR])
2725	{	2752	{
2726	// INCR selection, start handshake	2753	// INCR selection, start handshake
		2754	if (!delete_prop)
2727	XDeleteProperty (display->display, win, prop);	2755	XDeleteProperty (display->display, win, prop);
		2756
2728	selection_wait = Sel_incr;	2757	selection_wait = Sel_incr;
		2758	incr_buf_fill = 0;
2729	incr_ev.start (NOW + 10);	2759	incr_ev.start (NOW + 10);
2730	break;
2731	}
2732		2760
2733	if (ct.value == NULL)	2761	goto bailout;
2734	continue;	2762	}
2735		2763
2736	if (ct.nitems == 0)	2764	if (ct.nitems == 0)
		2765	{
		2766	if (selection_wait == Sel_incr)
		2767	{
		2768	XFree (ct.value);
		2769
		2770	// finally complete, now paste the whole thing
		2771	selection_wait = Sel_normal;
		2772	ct.value = (unsigned char *)incr_buf;
		2773	ct.nitems = incr_buf_fill;
		2774	incr_buf = 0;
		2775	incr_buf_size = 0;
		2776	incr_ev.stop ();
2737	{	2777	}
		2778	else
		2779	{
2738	if (selection_wait == Sel_normal && nread == 0	2780	if (selection_wait == Sel_normal
2739	&& (win != display->root \|\| prop != XA_CUT_BUFFER0)) // avoid recursion	2781	&& (win != display->root \|\| prop != XA_CUT_BUFFER0)) // avoid recursion
2740	{	2782	{
2741	/*	2783	/*
2742	* pass through again trying CUT_BUFFER0 if we've come from	2784	* pass through again trying CUT_BUFFER0 if we've come from
2743	* XConvertSelection () but nothing was presented	2785	* XConvertSelection () but nothing was presented
2744	*/	2786	*/
2745	selection_paste (display->root, XA_CUT_BUFFER0, False);	2787	selection_paste (display->root, XA_CUT_BUFFER0, False);
2746	}	2788	}
2747		2789
2748	nread = -1; /* discount any previous stuff */	2790	goto bailout;
2749	break;	2791	}
		2792	}
		2793	else if (selection_wait == Sel_incr)
		2794	{
		2795	incr_ev.start (NOW + 10);
		2796
		2797	while (incr_buf_fill + ct.nitems > incr_buf_size)
2750	}	2798	{
		2799	incr_buf_size = incr_buf_size ? incr_buf_size * 2 : 128*1024;
		2800	incr_buf = (char *)realloc (incr_buf, incr_buf_size);
		2801	}
2751		2802
		2803	memcpy (incr_buf + incr_buf_fill, ct.value, ct.nitems);
2752	nread += ct.nitems;	2804	incr_buf_fill += ct.nitems;
2753		2805
		2806	goto bailout;
		2807	}
		2808
2754	char **cl;	2809	char **cl;
2755	int cr;	2810	int cr;
		2811
		2812	#if ENABLE_FRILLS
		2813	// xlib is horribly broken with respect to UTF8_STRING, and nobody cares to fix it
		2814	// so recode it manually
		2815	if (ct.encoding == xa[XA_UTF8_STRING])
		2816	{
		2817	wchar_t w = rxvt_utf8towcs ((const char )ct.value, ct.nitems);
		2818	char *s = rxvt_wcstombs (w);
		2819	free (w);
		2820	// TODO: strlen == only the first element will be converted. well...
		2821	paste ((unsigned char *)s, strlen (s));
		2822	free (s);
		2823	}
		2824	else
		2825	#endif
2756	if (XmbTextPropertyToTextList (display->display, &ct, &cl, &cr) >= 0 && cl)	2826	if (XmbTextPropertyToTextList (display->display, &ct, &cl, &cr) >= 0
2757	{	2827	&& cl)
		2828	{
2758	for (int i = 0; i < cr; i++)	2829	for (int i = 0; i < cr; i++)
2759	paste ((unsigned char *)cl[i], strlen (cl[i]));	2830	paste ((unsigned char *)cl[i], strlen (cl[i]));
2760		2831
2761	XFreeStringList (cl);	2832	XFreeStringList (cl);
2762	}	2833	}
2763	else	2834	else
2764	paste (ct.value, ct.nitems);	2835	paste (ct.value, ct.nitems); // paste raw
2765		2836
2766	if (bytes_after == 0)	2837	bailout:
2767	break;
2768
2769	XFree (ct.value);
2770	}
2771
2772	if (ct.value)
2773	XFree (ct.value);	2838	XFree (ct.value);
2774		2839
2775	if (selection_wait == Sel_normal)	2840	if (selection_wait == Sel_normal)
2776	selection_wait = Sel_none;	2841	selection_wait = Sel_none;
2777
2778	return (int)nread;
2779	}	2842	}
2780		2843
2781	void	2844	void
2782	rxvt_term::incr_cb (time_watcher &w)	2845	rxvt_term::incr_cb (time_watcher &w)
2783	{	2846	{
2784	selection_wait = Sel_none;	2847	selection_wait = Sel_none;
2785		2848
		2849	incr_buf_size = 0;
		2850	free (incr_buf);
		2851
2786	rxvt_warn ("data loss: timeout on INCR selection paste, ignoring.\n");	2852	rxvt_warn ("data loss: timeout on INCR selection paste, ignoring.\n");
2787	}	2853	}
2788		2854
2789	/*
2790	* INCR support originally provided by Paul Sheer <psheer@obsidian.co.za>
2791	*/
2792	void	2855	void
2793	rxvt_term::selection_property (Window win, Atom prop)	2856	rxvt_term::selection_property (Window win, Atom prop)
2794	{	2857	{
2795	if (prop == None \|\| selection_wait != Sel_incr)	2858	if (prop == None \|\| selection_wait != Sel_incr)
2796	return;	2859	return;
2797		2860
2798	if (selection_paste (win, prop, 1) > 0)	2861	selection_paste (win, prop, true);
2799	incr_ev.start (NOW + 10);
2800	else
2801	{
2802	selection_wait = Sel_none;
2803	incr_ev.stop ();
2804	}
2805	}	2862	}
2806		2863
2807	/* ------------------------------------------------------------------------- */	2864	/* ------------------------------------------------------------------------- */
2808	/*	2865	/*
2809	* Request the current selection:	2866	* Request the current selection:
…		…
2843	#else	2900	#else
2844	selection_type = Sel_CompoundText;	2901	selection_type = Sel_CompoundText;
2845	if (selection_request_other (xa[XA_COMPOUND_TEXT], i))	2902	if (selection_request_other (xa[XA_COMPOUND_TEXT], i))
2846	return;	2903	return;
2847	#endif	2904	#endif
2848
2849	}	2905	}
2850	}	2906	}
2851		2907
2852	selection_wait = Sel_none; /* don't loop in rxvt_selection_paste () */	2908	selection_wait = Sel_none; /* don't loop in selection_paste () */
2853	selection_paste (display->root, XA_CUT_BUFFER0, False);	2909	selection_paste (display->root, XA_CUT_BUFFER0, false);
2854	}	2910	}
2855		2911
2856	int	2912	int
2857	rxvt_term::selection_request_other (Atom target, int selnum)	2913	rxvt_term::selection_request_other (Atom target, int selnum)
2858	{	2914	{
2859	Atom sel;	2915	Atom sel;
2860	#ifdef DEBUG_SELECT
2861	char *debug_xa_names[] = { "PRIMARY", "SECONDARY", "CLIPBOARD" };
2862	#endif
2863		2916
2864	selection_type \|= selnum;	2917	selection_type \|= selnum;
2865		2918
2866	if (selnum == Sel_Primary)	2919	if (selnum == Sel_Primary)
2867	sel = XA_PRIMARY;	2920	sel = XA_PRIMARY;
…		…
3014	#if 0	3067	#if 0
3015	XTextProperty ct;	3068	XTextProperty ct;
3016		3069
3017	if (XwcTextListToTextProperty (display->display, &selection.text, 1, XStringStyle, &ct) >= 0)	3070	if (XwcTextListToTextProperty (display->display, &selection.text, 1, XStringStyle, &ct) >= 0)
3018	{	3071	{
3019	XChangeProperty (display->display, display->root, XA_CUT_BUFFER0, XA_STRING, 8,	3072	set_string_property (XA_CUT_BUFFER0, ct.value, ct.nitems);
3020	PropModeReplace, ct.value, ct.nitems);
3021	XFree (ct.value);	3073	XFree (ct.value);
3022	}	3074	}
3023	#endif	3075	#endif
3024		3076
3025	selection_time = tm;	3077	selection_time = tm;
…		…
3363	selection_delimit_word (DN, &selection.end, &selection.end);	3415	selection_delimit_word (DN, &selection.end, &selection.end);
3364	}	3416	}
3365	else if (selection.clicks == 3)	3417	else if (selection.clicks == 3)
3366	{	3418	{
3367	#if ENABLE_FRILLS	3419	#if ENABLE_FRILLS
3368	if ((options & Opt_tripleclickwords))	3420	if (options & Opt_tripleclickwords)
3369	{	3421	{
3370	int end_row;	3422	int end_row;
3371		3423
3372	selection_delimit_word (UP, & (selection.beg), & (selection.beg));	3424	selection_delimit_word (UP, &selection.beg, &selection.beg);
3373	end_row = screen.tlen[selection.mark.row + TermWin.saveLines];	3425	end_row = screen.tlen[selection.mark.row + TermWin.saveLines];
3374		3426
3375	for (end_row = selection.mark.row; end_row < TermWin.nrow; end_row++)	3427	for (end_row = selection.mark.row; end_row < TermWin.nrow; end_row++)
3376	{	3428	{
3377	end_col = screen.tlen[end_row + TermWin.saveLines];	3429	end_col = screen.tlen[end_row + TermWin.saveLines];
…		…
3391	if (ROWCOL_IS_AFTER (selection.mark, selection.beg))	3443	if (ROWCOL_IS_AFTER (selection.mark, selection.beg))
3392	selection.mark.col++;	3444	selection.mark.col++;
3393		3445
3394	selection.beg.col = 0;	3446	selection.beg.col = 0;
3395	selection.end.col = ncol;	3447	selection.end.col = ncol;
		3448
		3449	// select a complete logical line
		3450	while (selection.beg.row > -TermWin.saveLines
		3451	&& screen.tlen[selection.beg.row - 1 + TermWin.saveLines] == -1)
		3452	selection.beg.row--;
		3453
		3454	while (selection.end.row < TermWin.nrow
		3455	&& screen.tlen[selection.end.row + TermWin.saveLines] == -1)
		3456	selection.end.row++;
3396	}	3457	}
3397	}	3458	}
3398		3459
3399	if (button3 && buttonpress)	3460	if (button3 && buttonpress)
3400	{ /* mark may need to be changed */	3461	{ /* mark may need to be changed */
…		…
3473	selection_extend_colrow (Pixel2Col (x), Pixel2Row (y), 1, 0, 1);	3534	selection_extend_colrow (Pixel2Col (x), Pixel2Row (y), 1, 0, 1);
3474	}	3535	}
3475		3536
3476	/* ------------------------------------------------------------------------- */	3537	/* ------------------------------------------------------------------------- */
3477	/*	3538	/*
3478	* On some systems, the Atom typedef is 64 bits wide. We need to have a type
3479	* that is exactly 32 bits wide, because a format of 64 is not allowed by
3480	* the X11 protocol.
3481	*/
3482	typedef CARD32 Atom32;
3483
3484	/* ------------------------------------------------------------------------- */
3485	/*
3486	* Respond to a request for our current selection	3539	* Respond to a request for our current selection
3487	* EXT: SelectionRequest	3540	* EXT: SelectionRequest
3488	*/	3541	*/
3489	void	3542	void
3490	rxvt_term::selection_send (const XSelectionRequestEvent &rq)	3543	rxvt_term::selection_send (const XSelectionRequestEvent &rq)
3491	{	3544	{
3492	XSelectionEvent ev;	3545	XSelectionEvent ev;
3493	XTextProperty ct;	3546	dDisp;
3494	XICCEncodingStyle style;
3495	Atom target;
3496		3547
3497	ev.type = SelectionNotify;	3548	ev.type = SelectionNotify;
3498	ev.property = None;	3549	ev.property = None;
3499	ev.display = rq.display;	3550	ev.display = rq.display;
3500	ev.requestor = rq.requestor;	3551	ev.requestor = rq.requestor;
…		…
3502	ev.target = rq.target;	3553	ev.target = rq.target;
3503	ev.time = rq.time;	3554	ev.time = rq.time;
3504		3555
3505	if (rq.target == xa[XA_TARGETS])	3556	if (rq.target == xa[XA_TARGETS])
3506	{	3557	{
3507	Atom32 target_list[6];	3558	Atom target_list[6];
3508	Atom32 *target = target_list;	3559	Atom *target = target_list;
3509		3560
3510	*target++ = (Atom32) xa[XA_TARGETS];	3561	*target++ = xa[XA_TARGETS];
3511	*target++ = (Atom32) xa[XA_TIMESTAMP];	3562	*target++ = xa[XA_TIMESTAMP];
3512	*target++ = (Atom32) XA_STRING;	3563	*target++ = XA_STRING;
3513	*target++ = (Atom32) xa[XA_TEXT];	3564	*target++ = xa[XA_TEXT];
3514	*target++ = (Atom32) xa[XA_COMPOUND_TEXT];	3565	*target++ = xa[XA_COMPOUND_TEXT];
3515	#if X_HAVE_UTF8_STRING	3566	#if X_HAVE_UTF8_STRING
3516	*target++ = (Atom32) xa[XA_UTF8_STRING];	3567	*target++ = xa[XA_UTF8_STRING];
3517	#endif	3568	#endif
3518		3569
3519	XChangeProperty (display->display, rq.requestor, rq.property, XA_ATOM,	3570	XChangeProperty (disp, rq.requestor, rq.property, XA_ATOM,
3520	(8 * sizeof (target_list[0])), PropModeReplace,	3571	32, PropModeReplace,
3521	(unsigned char *)target_list,	3572	(unsigned char *)target_list, target - target_list);
3522	target - target_list);
3523	ev.property = rq.property;	3573	ev.property = rq.property;
3524	}	3574	}
3525	#if TODO // TODO	3575	#if TODO // TODO
3526	else if (rq.target == xa[XA_MULTIPLE])	3576	else if (rq.target == xa[XA_MULTIPLE])
3527	{	3577	{
3528	/* TODO: Handle MULTIPLE */	3578	/* TODO: Handle MULTIPLE */
3529	}	3579	}
3530	#endif	3580	#endif
3531	else if (rq.target == xa[XA_TIMESTAMP] && selection.text)	3581	else if (rq.target == xa[XA_TIMESTAMP] && selection.text)
3532	{	3582	{
3533	XChangeProperty (display->display, rq.requestor, rq.property, XA_INTEGER,	3583	XChangeProperty (disp, rq.requestor, rq.property, rq.target,
3534	(8 * sizeof (Time)), PropModeReplace,
3535	(unsigned char *)&selection_time, 1);	3584	32, PropModeReplace, (unsigned char *)&selection_time, 1);
3536	ev.property = rq.property;	3585	ev.property = rq.property;
3537	}	3586	}
3538	else if (rq.target == XA_STRING	3587	else if (rq.target == XA_STRING
3539	\|\| rq.target == xa[XA_TEXT]	3588	\|\| rq.target == xa[XA_TEXT]
3540	\|\| rq.target == xa[XA_COMPOUND_TEXT]	3589	\|\| rq.target == xa[XA_COMPOUND_TEXT]
3541	\|\| rq.target == xa[XA_UTF8_STRING]	3590	\|\| rq.target == xa[XA_UTF8_STRING]
3542	)	3591	)
3543	{	3592	{
		3593	XTextProperty ct;
		3594	Atom target = rq.target;
3544	short freect = 0;	3595	short freect = 0;
3545	int selectlen;	3596	int selectlen;
3546	wchar_t *cl;	3597	wchar_t *cl;
3547		3598	enum {
3548	target = rq.target;	3599	enc_string = XStringStyle,
		3600	enc_text = XStdICCTextStyle,
		3601	enc_compound_text = XCompoundTextStyle,
		3602	#ifdef X_HAVE_UTF8_STRING
		3603	enc_utf8 = XUTF8StringStyle,
		3604	#else
		3605	enc_utf8 = -1,
		3606	#endif
		3607	} style;
3549		3608
3550	if (target == XA_STRING)	3609	if (target == XA_STRING)
3551	// we actually don't do XA_STRING, but who cares, as i18n clients	3610	// we actually don't do XA_STRING, but who cares, as i18n clients
3552	// will ask for another format anyways.	3611	// will ask for another format anyways.
3553	style = XStringStyle;	3612	style = enc_string;
3554	else if (target == xa[XA_TEXT])	3613	else if (target == xa[XA_TEXT])
3555	style = XStdICCTextStyle;	3614	style = enc_text;
3556	else if (target == xa[XA_COMPOUND_TEXT])	3615	else if (target == xa[XA_COMPOUND_TEXT])
3557	style = XCompoundTextStyle;	3616	style = enc_compound_text;
3558	#if X_HAVE_UTF8_STRING	3617	#if ENABLE_FRILLS
3559	else if (target == xa[XA_UTF8_STRING])	3618	else if (target == xa[XA_UTF8_STRING])
3560	style = XUTF8StringStyle;	3619	style = enc_utf8;
3561	#endif	3620	#endif
3562	else	3621	else
3563	{	3622	{
3564	target = xa[XA_COMPOUND_TEXT];	3623	target = xa[XA_COMPOUND_TEXT];
3565	style = XCompoundTextStyle;	3624	style = enc_compound_text;
3566	}	3625	}
3567		3626
3568	if (selection.text)	3627	if (selection.text)
3569	{	3628	{
3570	cl = selection.text;	3629	cl = selection.text;
…		…
3574	{	3633	{
3575	cl = L"";	3634	cl = L"";
3576	selectlen = 0;	3635	selectlen = 0;
3577	}	3636	}
3578		3637
3579	// Xwc doesn't handle iso-10646 in wchar_t gracefully, so maybe recode it	3638	#if ENABLE_FRILLS
3580	// manually for XUTF8StringStyle.	3639	// xlib is horribly broken with respect to UTF8_STRING, and nobody cares to fix it
		3640	// so recode it manually
		3641	if (style == enc_utf8)
		3642	{
		3643	freect = 1;
		3644	ct.encoding = target;
		3645	ct.format = 8;
		3646	ct.value = (unsigned char *)rxvt_wcstoutf8 (cl, selectlen);
		3647	ct.nitems = strlen ((char *)ct.value);
		3648	}
		3649	else
		3650	#endif
3581	if (XwcTextListToTextProperty (display->display, &cl, 1, style, &ct) >= 0)	3651	if (XwcTextListToTextProperty (disp, &cl, 1, (XICCEncodingStyle) style, &ct) >= 0)
3582	freect = 1;	3652	freect = 1;
3583	else	3653	else
3584	{	3654	{
3585	/* if we failed to convert then send it raw */	3655	/* if we failed to convert then send it raw */
3586	ct.value = (unsigned char *)cl;	3656	ct.value = (unsigned char *)cl;
3587	ct.nitems = selectlen;	3657	ct.nitems = selectlen;
		3658	ct.encoding = target;
3588	}	3659	}
3589		3660
3590	XChangeProperty (display->display, rq.requestor, rq.property,	3661	XChangeProperty (disp, rq.requestor, rq.property,
3591	target, 8, PropModeReplace,	3662	ct.encoding, 8, PropModeReplace,
3592	ct.value, (int)ct.nitems);	3663	ct.value, (int)ct.nitems);
3593	ev.property = rq.property;	3664	ev.property = rq.property;
3594		3665
3595	if (freect)	3666	if (freect)
3596	XFree (ct.value);	3667	XFree (ct.value);
3597	}	3668	}
3598		3669
3599	XSendEvent (display->display, rq.requestor, False, 0L, (XEvent *)&ev);	3670	XSendEvent (disp, rq.requestor, False, 0L, (XEvent *)&ev);
3600	}	3671	}
3601		3672
3602	/* ------------------------------------------------------------------------- *	3673	/* ------------------------------------------------------------------------- *
3603	* MOUSE ROUTINES *	3674	* MOUSE ROUTINES *
3604	* ------------------------------------------------------------------------- */	3675	* ------------------------------------------------------------------------- */

Diff Legend

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

Comparing rxvt-unicode/src/screen.C (file contents): Revision 1.136 by root, Tue Sep 7 21:05:41 2004 UTC vs. Revision 1.161 by root, Tue Feb 22 21:41:50 2005 UTC

Diff Legend

Comparing rxvt-unicode/src/screen.C (file contents):
Revision 1.136 by root, Tue Sep 7 21:05:41 2004 UTC vs.
Revision 1.161 by root, Tue Feb 22 21:41:50 2005 UTC