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

Comparing rxvt-unicode/src/screen.C (file contents):
Revision 1.147 by root, Sun Dec 12 15:13:37 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;
571		567
572	SWAP_IT (screen.cur.row, swap.cur.row, int16_t);	568	SWAP_IT (screen.cur.row, swap.cur.row, int16_t);
573	SWAP_IT (screen.cur.col, swap.cur.col, int16_t);	569	SWAP_IT (screen.cur.col, swap.cur.col, int16_t);
574	# ifdef DEBUG_STRICT
575	assert (screen.cur.row >= 0 && screen.cur.row < prev_nrow);
576	assert (screen.cur.col >= 0 && screen.cur.col < prev_ncol);
577	# else /* drive with your eyes closed */
578	MAX_IT (screen.cur.row, 0);	570	MAX_IT (screen.cur.row, 0);
579	MIN_IT (screen.cur.row, (int32_t)prev_nrow - 1);	571	MIN_IT (screen.cur.row, (int32_t)prev_nrow - 1);
580	MAX_IT (screen.cur.col, 0);	572	MAX_IT (screen.cur.col, 0);
581	MIN_IT (screen.cur.col, (int32_t)prev_ncol - 1);	573	MIN_IT (screen.cur.col, (int32_t)prev_ncol - 1);
582	# endif
583		574
584	#if NSCREENS	575	#if NSCREENS
585	if (options & Opt_secondaryScreen)	576	if (options & Opt_secondaryScreen)
586	{	577	{
587	num_scr = 0;	578	num_scr = 0;
…		…
600	swap.flags \|= Screen_VisibleCursor;	591	swap.flags \|= Screen_VisibleCursor;
601	}	592	}
602	else	593	else
603	#endif	594	#endif
604	if (options & Opt_secondaryScroll)	595	if (options & Opt_secondaryScroll)
605	//if (current_screen == PRIMARY)
606	scr_scroll_text (0, prev_nrow - 1, prev_nrow, 0);	596	scr_scroll_text (0, prev_nrow - 1, prev_nrow, 0);
607		597
608	return scrn;	598	return scrn;
609	}	599	}
610		600
611	// clear WrapNext indicator, solidifying position on next line	601	// clear WrapNext indicator, solidifying position on next line
…		…
709	selection.op = SELECTION_CLEAR; /* XXX: too aggressive? */	699	selection.op = SELECTION_CLEAR; /* XXX: too aggressive? */
710	}	700	}
711	else if (j >= row1 && j <= row2)	701	else if (j >= row1 && j <= row2)
712	{	702	{
713	/* move selected region too */	703	/* move selected region too */
714	selection.beg.row -= count;	704	selection.beg.row -= count;
715	selection.end.row -= count;	705	selection.end.row -= count;
716	selection.mark.row -= count;	706	selection.mark.row -= count;
717	}	707	}
718	}	708	}
719		709
720	selection_check (0); /* _after_ TermWin.nscrolled update */	710	selection_check (0); /* _after_ TermWin.nscrolled update */
…		…
728	i = row2 - row1 + 1;	718	i = row2 - row1 + 1;
729	MIN_IT (count, i);	719	MIN_IT (count, i);
730		720
731	if (j > 0)	721	if (j > 0)
732	{	722	{
733	/* A: scroll up */	723	/* scroll up */
734		724
735	/* A1: Copy lines that will get clobbered by the rotation */	725	/* Copy lines that will get clobbered by the rotation */
736	memcpy (buf_text, screen.text + row1, count * sizeof (text_t *));	726	memcpy (buf_text, screen.text + row1, count * sizeof (text_t *));
737	memcpy (buf_rend, screen.rend + row1, count * sizeof (rend_t *));	727	memcpy (buf_rend, screen.rend + row1, count * sizeof (rend_t *));
738		728
739	/* A2: Rotate lines */	729	/* Rotate lines */
740	i = row2 - row1 - count + 1;	730	i = row2 - row1 - count + 1;
741	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));
742	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 *));
743	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 *));
744		734
745	j = row2 - count + 1, i = count;	735	j = row2 - count + 1, i = count;
746	}	736	}
747	else /* if (j < 0) */	737	else /* if (j < 0) */
748	{	738	{
749	/* B: scroll down */	739	/* scroll down */
750		740
751	/* B1: Copy lines that will get clobbered by the rotation */	741	/* Copy lines that will get clobbered by the rotation */
752	for (i = 0, j = row2; i < count; i++, j--)	742	for (i = 0, j = row2; i < count; i++, j--)
753	{	743	{
754	buf_text[i] = screen.text[j];	744	buf_text[i] = screen.text[j];
755	buf_rend[i] = screen.rend[j];	745	buf_rend[i] = screen.rend[j];
756	}	746	}
757		747
758	/* B2: Rotate lines */	748	/* Rotate lines */
759	for (j = row2, i = j - count; i >= row1; i--, j--)	749	for (j = row2, i = j - count; i >= row1; i--, j--)
760	{	750	{
761	screen.tlen[j] = screen.tlen[i];	751	screen.tlen[j] = screen.tlen[i];
762	screen.text[j] = screen.text[i];	752	screen.text[j] = screen.text[i];
763	screen.rend[j] = screen.rend[i];	753	screen.rend[j] = screen.rend[i];
…		…
765		755
766	j = row1, i = count;	756	j = row1, i = count;
767	count = -count;	757	count = -count;
768	}	758	}
769		759
770	/* C: Resurrect lines */	760	/* Resurrect lines */
771	memset (screen.tlen + j, 0, i * sizeof (int16_t));	761	memset (screen.tlen + j, 0, i * sizeof (int16_t));
772	memcpy (screen.text + j, buf_text, i * sizeof (text_t *));	762	memcpy (screen.text + j, buf_text, i * sizeof (text_t *));
773	memcpy (screen.rend + j, buf_rend, i * sizeof (text_t *));	763	memcpy (screen.rend + j, buf_rend, i * sizeof (text_t *));
774	if (!spec) /* line length may not equal TermWin.ncol */	764	if (!spec) /* line length may not equal TermWin.ncol */
775	for (; i--; j++)	765	for (; i--; j++)
…		…
1171	*/	1161	*/
1172	#if ENABLE_FRILLS	1162	#if ENABLE_FRILLS
1173	void	1163	void
1174	rxvt_term::scr_forwardindex ()	1164	rxvt_term::scr_forwardindex ()
1175	{	1165	{
1176	int row;	1166	int row;
1177		1167
1178	if (screen.cur.col < TermWin.ncol - 1)	1168	if (screen.cur.col < TermWin.ncol - 1)
1179	scr_gotorc (0, 1, R_RELATIVE \| C_RELATIVE);	1169	scr_gotorc (0, 1, R_RELATIVE \| C_RELATIVE);
1180	else	1170	else
1181	{	1171	{
…		…
1400	screen.tlen[row + row_offset] = 0;	1390	screen.tlen[row + row_offset] = 0;
1401	scr_blank_line (drawn_text[row], drawn_rend[row], (unsigned int)TermWin.ncol, ren);	1391	scr_blank_line (drawn_text[row], drawn_rend[row], (unsigned int)TermWin.ncol, ren);
1402	}	1392	}
1403	}	1393	}
1404		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
		1405
1405	/* ------------------------------------------------------------------------- */	1406	/* ------------------------------------------------------------------------- */
1406	/*	1407	/*
1407	* Fill the screen with `E's	1408	* Fill the screen with `E's
1408	* XTERM_SEQ: Screen Alignment Test: ESC # 8	1409	* XTERM_SEQ: Screen Alignment Test: ESC # 8
1409	*/	1410	*/
1410	void	1411	void
1411	rxvt_term::scr_E ()	1412	rxvt_term::scr_E ()
1412	{	1413	{
1413	int i, j, k;	1414	int i, j, k;
1414	rend_t *r1, fs;	1415	rend_t *r1, fs;
1415		1416
1416	want_refresh = 1;	1417	want_refresh = 1;
1417	ZERO_SCROLLBACK ();	1418	ZERO_SCROLLBACK ();
1418		1419
1419	num_scr_allow = 0;	1420	num_scr_allow = 0;
…		…
1902	rxvt_term::scr_page (enum page_dirn direction, int nlines)	1903	rxvt_term::scr_page (enum page_dirn direction, int nlines)
1903	{	1904	{
1904	int n;	1905	int n;
1905	unsigned int oldviewstart;	1906	unsigned int oldviewstart;
1906		1907
1907	#ifdef DEBUG_STRICT
1908	assert ((nlines >= 0) && (nlines <= TermWin.nrow));
1909	#endif
1910	oldviewstart = TermWin.view_start;	1908	oldviewstart = TermWin.view_start;
		1909
1911	if (direction == UP)	1910	if (direction == UP)
1912	{	1911	{
1913	n = TermWin.view_start + nlines;	1912	n = TermWin.view_start + nlines;
1914	TermWin.view_start = min (n, TermWin.nscrolled);	1913	TermWin.view_start = min (n, TermWin.nscrolled);
1915	}	1914	}
1916	else	1915	else
1917	{	1916	{
1918	n = TermWin.view_start - nlines;	1917	n = TermWin.view_start - nlines;
1919	TermWin.view_start = max (n, 0);	1918	TermWin.view_start = max (n, 0);
1920	}	1919	}
		1920
1921	return scr_changeview (oldviewstart);	1921	return scr_changeview (oldviewstart);
1922	}	1922	}
1923		1923
1924	int	1924	int
1925	rxvt_term::scr_changeview (unsigned int oldviewstart)	1925	rxvt_term::scr_changeview (unsigned int oldviewstart)
…		…
2400	else	2400	else
2401	font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, back);	2401	font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, back);
2402		2402
2403	if (rend & RS_Uline && font->descent > 1 && fore != back)	2403	if (rend & RS_Uline && font->descent > 1 && fore != back)
2404	{	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
2405	XSetForeground (display->display, TermWin.gc, pix_colors[fore]);	2410	XSetForeground (display->display, TermWin.gc, pix_colors[fore]);
		2411
2406	XDrawLine (display->display, drawBuffer, TermWin.gc,	2412	XDrawLine (display->display, drawBuffer, TermWin.gc,
2407	xpixel, ypixel + font->ascent + 1,	2413	xpixel, ypixel + font->ascent + 1,
2408	xpixel + Width2Pixel (count) - 1, ypixel + font->ascent + 1);	2414	xpixel + Width2Pixel (count) - 1, ypixel + font->ascent + 1);
2409	}	2415	}
2410	} /* for (col....) */	2416	} /* for (col....) */
…		…
2656	/* ------------------------------------------------------------------------- */	2662	/* ------------------------------------------------------------------------- */
2657	/*	2663	/*
2658	* Paste a selection direct to the command fd	2664	* Paste a selection direct to the command fd
2659	*/	2665	*/
2660	void	2666	void
2661	rxvt_term::paste (const unsigned char *data, unsigned int len)	2667	rxvt_term::paste (unsigned char *data, unsigned int len)
2662	{	2668	{
2663	unsigned int i, j, n;
2664	unsigned char ds = (unsigned char )rxvt_malloc (PROP_SIZE);
2665
2666	/* convert normal newline chars into common keyboard Return key sequence */	2669	/* convert normal newline chars into common keyboard Return key sequence */
2667	for (i = 0; i < len; i += PROP_SIZE)	2670	for (unsigned int i = 0; i < len; i++)
2668	{
2669	n = min (len - i, PROP_SIZE);
2670	memcpy (ds, data + i, n);
2671
2672	for (j = 0; j < n; j++)
2673	if (ds[j] == C0_LF)	2671	if (data[i] == C0_LF)
2674	ds[j] = C0_CR;	2672	data[i] = C0_CR;
2675		2673
2676	tt_write (ds, (int)n);	2674	tt_write (data, len);
2677	}
2678
2679	free (ds);
2680	}	2675	}
2681		2676
2682	/* ------------------------------------------------------------------------- */	2677	/* ------------------------------------------------------------------------- */
2683	/*	2678	/*
2684	* Respond to a notification that a primary selection has been sent	2679	* Respond to a notification that a primary selection has been sent
2685	* EXT: SelectionNotify	2680	* EXT: SelectionNotify
2686	*/	2681	*/
2687	int	2682	void
2688	rxvt_term::selection_paste (Window win, Atom prop, bool delete_prop)	2683	rxvt_term::selection_paste (Window win, Atom prop, bool delete_prop)
2689	{	2684	{
2690	long nread = 0;
2691	unsigned long bytes_after;
2692	XTextProperty ct;
2693
2694	if (prop == None) /* check for failed XConvertSelection */	2685	if (prop == None) /* check for failed XConvertSelection */
2695	{	2686	{
2696	if ((selection_type & Sel_CompoundText))	2687	if ((selection_type & Sel_CompoundText))
2697	{	2688	{
2698	int selnum = selection_type & Sel_whereMask;	2689	int selnum = selection_type & Sel_whereMask;
…		…
2711	selection_request_other (xa[XA_COMPOUND_TEXT], selnum);	2702	selection_request_other (xa[XA_COMPOUND_TEXT], selnum);
2712	else	2703	else
2713	selection_type = 0;	2704	selection_type = 0;
2714	}	2705	}
2715		2706
2716	return 0;	2707	return;
2717	}
2718
2719	for (;;)
2720	{	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
2721	if (XGetWindowProperty (display->display, win, prop, (long) (nread / 4),	2732	if (XGetWindowProperty (display->display, win, prop,
2722	(long) (PROP_SIZE / 4), delete_prop,	2733	ct.nitems / 4, (bytes_after + 3) / 4,
		2734	delete_prop, AnyPropertyType,
2723	AnyPropertyType, &ct.encoding, &ct.format,	2735	&ct2.encoding, &ct2.format,
2724	&ct.nitems, &bytes_after,	2736	&ct2.nitems, &bytes_after,
2725	&ct.value) != Success)	2737	&ct2.value) != Success)
2726	break;	2738	goto bailout;
2727		2739
2728	if (ct.encoding == 0)	2740	// realloc should be compatible to XFree, here, and elsewhere, too
2729	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;
2730		2744
		2745	XFree (ct2.value);
		2746	}
		2747
		2748	if (ct.value == 0)
		2749	goto bailout;
		2750
2731	if (ct.encoding == xa[XA_INCR])	2751	if (ct.encoding == xa[XA_INCR])
2732	{	2752	{
2733	// INCR selection, start handshake	2753	// INCR selection, start handshake
		2754	if (!delete_prop)
2734	XDeleteProperty (display->display, win, prop);	2755	XDeleteProperty (display->display, win, prop);
		2756
2735	selection_wait = Sel_incr;	2757	selection_wait = Sel_incr;
		2758	incr_buf_fill = 0;
2736	incr_ev.start (NOW + 10);	2759	incr_ev.start (NOW + 10);
2737	break;
2738	}
2739		2760
2740	if (ct.value == NULL)	2761	goto bailout;
2741	continue;	2762	}
2742		2763
2743	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 ();
2744	{	2777	}
		2778	else
		2779	{
2745	if (selection_wait == Sel_normal && nread == 0	2780	if (selection_wait == Sel_normal
2746	&& (win != display->root \|\| prop != XA_CUT_BUFFER0)) // avoid recursion	2781	&& (win != display->root \|\| prop != XA_CUT_BUFFER0)) // avoid recursion
2747	{	2782	{
2748	/*	2783	/*
2749	* pass through again trying CUT_BUFFER0 if we've come from	2784	* pass through again trying CUT_BUFFER0 if we've come from
2750	* XConvertSelection () but nothing was presented	2785	* XConvertSelection () but nothing was presented
2751	*/	2786	*/
2752	selection_paste (display->root, XA_CUT_BUFFER0, False);	2787	selection_paste (display->root, XA_CUT_BUFFER0, False);
2753	}	2788	}
2754		2789
2755	nread = -1; /* discount any previous stuff */	2790	goto bailout;
2756	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)
2757	}	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	}
2758		2802
		2803	memcpy (incr_buf + incr_buf_fill, ct.value, ct.nitems);
2759	nread += ct.nitems;	2804	incr_buf_fill += ct.nitems;
2760		2805
		2806	goto bailout;
		2807	}
		2808
2761	char **cl;	2809	char **cl;
2762	int cr;	2810	int cr;
2763		2811
2764	#if ENABLE_FRILLS	2812	#if ENABLE_FRILLS
2765	// xlib is horribly broken with respect to UTF8_STRING, and nobody cares to fix it	2813	// xlib is horribly broken with respect to UTF8_STRING, and nobody cares to fix it
2766	// so recode it manually	2814	// so recode it manually
2767	if (ct.encoding == xa[XA_UTF8_STRING])	2815	if (ct.encoding == xa[XA_UTF8_STRING])
2768	{	2816	{
2769	wchar_t w = rxvt_utf8towcs ((const char )ct.value, ct.nitems);	2817	wchar_t w = rxvt_utf8towcs ((const char )ct.value, ct.nitems);
2770	char *s = rxvt_wcstombs (w);	2818	char *s = rxvt_wcstombs (w);
2771		2819	free (w);
2772	// TODO: strlen == only the first element will be converted. well...	2820	// TODO: strlen == only the first element will be converted. well...
2773	paste ((unsigned char *)s, strlen (s));	2821	paste ((unsigned char *)s, strlen (s));
2774
2775	free (s);	2822	free (s);
2776	free (w);	2823	}
2777	}
2778	else	2824	else
2779	#endif	2825	#endif
2780	if (XmbTextPropertyToTextList (display->display, &ct, &cl, &cr) >= 0 && cl)	2826	if (XmbTextPropertyToTextList (display->display, &ct, &cl, &cr) >= 0
2781	{	2827	&& cl)
		2828	{
2782	for (int i = 0; i < cr; i++)	2829	for (int i = 0; i < cr; i++)
2783	paste ((unsigned char *)cl[i], strlen (cl[i]));	2830	paste ((unsigned char *)cl[i], strlen (cl[i]));
2784		2831
2785	XFreeStringList (cl);	2832	XFreeStringList (cl);
2786	}	2833	}
2787	else	2834	else
2788	paste (ct.value, ct.nitems);	2835	paste (ct.value, ct.nitems); // paste raw
2789		2836
2790	if (bytes_after == 0)	2837	bailout:
2791	break;
2792
2793	XFree (ct.value);
2794	}
2795
2796	if (ct.value)
2797	XFree (ct.value);	2838	XFree (ct.value);
2798		2839
2799	if (selection_wait == Sel_normal)	2840	if (selection_wait == Sel_normal)
2800	selection_wait = Sel_none;	2841	selection_wait = Sel_none;
2801
2802	return (int)nread;
2803	}	2842	}
2804		2843
2805	void	2844	void
2806	rxvt_term::incr_cb (time_watcher &w)	2845	rxvt_term::incr_cb (time_watcher &w)
2807	{	2846	{
2808	selection_wait = Sel_none;	2847	selection_wait = Sel_none;
2809		2848
		2849	incr_buf_size = 0;
		2850	free (incr_buf);
		2851
2810	rxvt_warn ("data loss: timeout on INCR selection paste, ignoring.\n");	2852	rxvt_warn ("data loss: timeout on INCR selection paste, ignoring.\n");
2811	}	2853	}
2812		2854
2813	/*
2814	* INCR support originally provided by Paul Sheer <psheer@obsidian.co.za>
2815	*/
2816	void	2855	void
2817	rxvt_term::selection_property (Window win, Atom prop)	2856	rxvt_term::selection_property (Window win, Atom prop)
2818	{	2857	{
2819	if (prop == None \|\| selection_wait != Sel_incr)	2858	if (prop == None \|\| selection_wait != Sel_incr)
2820	return;	2859	return;
2821		2860
2822	if (selection_paste (win, prop, 1) > 0)	2861	selection_paste (win, prop, true);
2823	incr_ev.start (NOW + 10);
2824	else
2825	{
2826	selection_wait = Sel_none;
2827	incr_ev.stop ();
2828	}
2829	}	2862	}
2830		2863
2831	/* ------------------------------------------------------------------------- */	2864	/* ------------------------------------------------------------------------- */
2832	/*	2865	/*
2833	* Request the current selection:	2866	* Request the current selection:
…		…
2870	return;	2903	return;
2871	#endif	2904	#endif
2872	}	2905	}
2873	}	2906	}
2874		2907
2875	selection_wait = Sel_none; /* don't loop in rxvt_selection_paste () */	2908	selection_wait = Sel_none; /* don't loop in selection_paste () */
2876	selection_paste (display->root, XA_CUT_BUFFER0, False);	2909	selection_paste (display->root, XA_CUT_BUFFER0, false);
2877	}	2910	}
2878		2911
2879	int	2912	int
2880	rxvt_term::selection_request_other (Atom target, int selnum)	2913	rxvt_term::selection_request_other (Atom target, int selnum)
2881	{	2914	{
2882	Atom sel;	2915	Atom sel;
2883	#ifdef DEBUG_SELECT
2884	char *debug_xa_names[] = { "PRIMARY", "SECONDARY", "CLIPBOARD" };
2885	#endif
2886		2916
2887	selection_type \|= selnum;	2917	selection_type \|= selnum;
2888		2918
2889	if (selnum == Sel_Primary)	2919	if (selnum == Sel_Primary)
2890	sel = XA_PRIMARY;	2920	sel = XA_PRIMARY;
…		…
3385	selection_delimit_word (DN, &selection.end, &selection.end);	3415	selection_delimit_word (DN, &selection.end, &selection.end);
3386	}	3416	}
3387	else if (selection.clicks == 3)	3417	else if (selection.clicks == 3)
3388	{	3418	{
3389	#if ENABLE_FRILLS	3419	#if ENABLE_FRILLS
3390	if ((options & Opt_tripleclickwords))	3420	if (options & Opt_tripleclickwords)
3391	{	3421	{
3392	int end_row;	3422	int end_row;
3393		3423
3394	selection_delimit_word (UP, &selection.beg, &selection.beg);	3424	selection_delimit_word (UP, &selection.beg, &selection.beg);
3395	end_row = screen.tlen[selection.mark.row + TermWin.saveLines];	3425	end_row = screen.tlen[selection.mark.row + TermWin.saveLines];
…		…
3413	if (ROWCOL_IS_AFTER (selection.mark, selection.beg))	3443	if (ROWCOL_IS_AFTER (selection.mark, selection.beg))
3414	selection.mark.col++;	3444	selection.mark.col++;
3415		3445
3416	selection.beg.col = 0;	3446	selection.beg.col = 0;
3417	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++;
3418	}	3457	}
3419	}	3458	}
3420		3459
3421	if (button3 && buttonpress)	3460	if (button3 && buttonpress)
3422	{ /* mark may need to be changed */	3461	{ /* mark may need to be changed */
…		…
3502	*/	3541	*/
3503	void	3542	void
3504	rxvt_term::selection_send (const XSelectionRequestEvent &rq)	3543	rxvt_term::selection_send (const XSelectionRequestEvent &rq)
3505	{	3544	{
3506	XSelectionEvent ev;	3545	XSelectionEvent ev;
		3546	dDisp;
3507		3547
3508	ev.type = SelectionNotify;	3548	ev.type = SelectionNotify;
3509	ev.property = None;	3549	ev.property = None;
3510	ev.display = rq.display;	3550	ev.display = rq.display;
3511	ev.requestor = rq.requestor;	3551	ev.requestor = rq.requestor;
…		…
3525	*target++ = xa[XA_COMPOUND_TEXT];	3565	*target++ = xa[XA_COMPOUND_TEXT];
3526	#if X_HAVE_UTF8_STRING	3566	#if X_HAVE_UTF8_STRING
3527	*target++ = xa[XA_UTF8_STRING];	3567	*target++ = xa[XA_UTF8_STRING];
3528	#endif	3568	#endif
3529		3569
3530	XChangeProperty (display->display, rq.requestor, rq.property, XA_ATOM,	3570	XChangeProperty (disp, rq.requestor, rq.property, XA_ATOM,
3531	32, PropModeReplace,	3571	32, PropModeReplace,
3532	(unsigned char *)target_list, target - target_list);	3572	(unsigned char *)target_list, target - target_list);
3533	ev.property = rq.property;	3573	ev.property = rq.property;
3534	}	3574	}
3535	#if TODO // TODO	3575	#if TODO // TODO
…		…
3538	/* TODO: Handle MULTIPLE */	3578	/* TODO: Handle MULTIPLE */
3539	}	3579	}
3540	#endif	3580	#endif
3541	else if (rq.target == xa[XA_TIMESTAMP] && selection.text)	3581	else if (rq.target == xa[XA_TIMESTAMP] && selection.text)
3542	{	3582	{
3543	XChangeProperty (display->display, rq.requestor, rq.property, rq.target,	3583	XChangeProperty (disp, rq.requestor, rq.property, rq.target,
3544	32, PropModeReplace, (unsigned char *)&selection_time, 1);	3584	32, PropModeReplace, (unsigned char *)&selection_time, 1);
3545	ev.property = rq.property;	3585	ev.property = rq.property;
3546	}	3586	}
3547	else if (rq.target == XA_STRING	3587	else if (rq.target == XA_STRING
3548	\|\| rq.target == xa[XA_TEXT]	3588	\|\| rq.target == xa[XA_TEXT]
…		…
3606	ct.value = (unsigned char *)rxvt_wcstoutf8 (cl, selectlen);	3646	ct.value = (unsigned char *)rxvt_wcstoutf8 (cl, selectlen);
3607	ct.nitems = strlen ((char *)ct.value);	3647	ct.nitems = strlen ((char *)ct.value);
3608	}	3648	}
3609	else	3649	else
3610	#endif	3650	#endif
3611	if (XwcTextListToTextProperty (display->display, &cl, 1, (XICCEncodingStyle) style, &ct) >= 0)	3651	if (XwcTextListToTextProperty (disp, &cl, 1, (XICCEncodingStyle) style, &ct) >= 0)
3612	freect = 1;	3652	freect = 1;
3613	else	3653	else
3614	{	3654	{
3615	/* if we failed to convert then send it raw */	3655	/* if we failed to convert then send it raw */
3616	ct.value = (unsigned char *)cl;	3656	ct.value = (unsigned char *)cl;
3617	ct.nitems = selectlen;	3657	ct.nitems = selectlen;
3618	ct.encoding = target;	3658	ct.encoding = target;
3619	}	3659	}
3620		3660
3621	XChangeProperty (display->display, rq.requestor, rq.property,	3661	XChangeProperty (disp, rq.requestor, rq.property,
3622	ct.encoding, 8, PropModeReplace,	3662	ct.encoding, 8, PropModeReplace,
3623	ct.value, (int)ct.nitems);	3663	ct.value, (int)ct.nitems);
3624	ev.property = rq.property;	3664	ev.property = rq.property;
3625		3665
3626	if (freect)	3666	if (freect)
3627	XFree (ct.value);	3667	XFree (ct.value);
3628	}	3668	}
3629		3669
3630	XSendEvent (display->display, rq.requestor, False, 0L, (XEvent *)&ev);	3670	XSendEvent (disp, rq.requestor, False, 0L, (XEvent *)&ev);
3631	}	3671	}
3632		3672
3633	/* ------------------------------------------------------------------------- *	3673	/* ------------------------------------------------------------------------- *
3634	* MOUSE ROUTINES *	3674	* MOUSE ROUTINES *
3635	* ------------------------------------------------------------------------- */	3675	* ------------------------------------------------------------------------- */

Diff Legend

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

Comparing rxvt-unicode/src/screen.C (file contents): Revision 1.147 by root, Sun Dec 12 15:13:37 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.147 by root, Sun Dec 12 15:13:37 2004 UTC vs.
Revision 1.161 by root, Tue Feb 22 21:41:50 2005 UTC