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.57 by pcg, Sun Mar 14 17:33:08 2004 UTC vs.
Revision 1.78 by root, Fri Jul 30 18:35:11 2004 UTC

1	/*--------------------------------*-C-*--------------------------------------*	1	/*--------------------------------*-C-*--------------------------------------*
2	* File: screen.c	2	* File: screen.C
3	*---------------------------------------------------------------------------*	3	*---------------------------------------------------------------------------*
4	*	4	*
5	* Copyright (c) 1997-2001 Geoff Wing <gcw@pobox.com>	5	* Copyright (c) 1997-2001 Geoff Wing <gcw@pobox.com>
6	* Copyright (c) 2003-2004 Marc Lehmann <pcg@goof.com>	6	* Copyright (c) 2003-2004 Marc Lehmann <pcg@goof.com>
7	*	7	*
…		…
29	#include "rxvt.h" /* NECESSARY */	29	#include "rxvt.h" /* NECESSARY */
30	#include "screen.intpro" /* PROTOS for internal routines */	30	#include "screen.intpro" /* PROTOS for internal routines */
31		31
32	#include <X11/Xmd.h> /* get the typedef for CARD32 */	32	#include <X11/Xmd.h> /* get the typedef for CARD32 */
33		33
34	#include <stdint.h>	34	#include <inttypes.h>
35	#include <wchar.h>	35	#include <wchar.h>
36		36
37	#include "salloc.C" // HACK, should be a seperate compile!	37	#include "salloc.C" // HACK, should be a seperate compile!
38		38
39	inline void fill_text (text_t *start, text_t value, int len)	39	inline void fill_text (text_t *start, text_t value, int len)
…		…
48		48
49	/* ------------------------------------------------------------------------- *	49	/* ------------------------------------------------------------------------- *
50	* GENERAL SCREEN AND SELECTION UPDATE ROUTINES *	50	* GENERAL SCREEN AND SELECTION UPDATE ROUTINES *
51	* ------------------------------------------------------------------------- */	51	* ------------------------------------------------------------------------- */
52	#define ZERO_SCROLLBACK() \	52	#define ZERO_SCROLLBACK() \
53	if ((Options & Opt_scrollTtyOutput) == Opt_scrollTtyOutput) \	53	if (Options & Opt_scrollTtyOutput) \
54	TermWin.view_start = 0	54	TermWin.view_start = 0
55	#define CLEAR_SELECTION() \	55	#define CLEAR_SELECTION() \
56	selection.beg.row = selection.beg.col \	56	selection.beg.row = selection.beg.col \
57	= selection.end.row = selection.end.col = 0	57	= selection.end.row = selection.end.col = 0
58	#define CLEAR_ALL_SELECTION() \	58	#define CLEAR_ALL_SELECTION() \
59	selection.beg.row = selection.beg.col \	59	selection.beg.row = selection.beg.col \
60	= selection.mark.row = selection.mark.col \	60	= selection.mark.row = selection.mark.col \
61	= selection.end.row = selection.end.col = 0	61	= selection.end.row = selection.end.col = 0
62		62
63	#define ROW_AND_COL_IS_AFTER(A, B, C, D) \	63	#define ROW_AND_COL_IS_AFTER(A, B, C, D) \
64	(((A) > (C)) || (((A) == (C)) && ((B) > (D))))	64	(((A) > (C)) || (((A) == (C)) && ((B) > (D))))
65	#define ROW_AND_COL_IS_BEFORE(A, B, C, D) \	65	#define ROW_AND_COL_IS_BEFORE(A, B, C, D) \
66	(((A) < (C)) || (((A) == (C)) && ((B) < (D))))	66	(((A) < (C)) || (((A) == (C)) && ((B) < (D))))
67	#define ROW_AND_COL_IN_ROW_AFTER(A, B, C, D) \	67	#define ROW_AND_COL_IN_ROW_AFTER(A, B, C, D) \
68	(((A) == (C)) && ((B) > (D)))	68	(((A) == (C)) && ((B) > (D)))
69	#define ROW_AND_COL_IN_ROW_AT_OR_AFTER(A, B, C, D) \	69	#define ROW_AND_COL_IN_ROW_AT_OR_AFTER(A, B, C, D) \
70	(((A) == (C)) && ((B) >= (D)))	70	(((A) == (C)) && ((B) >= (D)))
71	#define ROW_AND_COL_IN_ROW_BEFORE(A, B, C, D) \	71	#define ROW_AND_COL_IN_ROW_BEFORE(A, B, C, D) \
72	(((A) == (C)) && ((B) < (D)))	72	(((A) == (C)) && ((B) < (D)))
73	#define ROW_AND_COL_IN_ROW_AT_OR_BEFORE(A, B, C, D) \	73	#define ROW_AND_COL_IN_ROW_AT_OR_BEFORE(A, B, C, D) \
74	(((A) == (C)) && ((B) <= (D)))	74	(((A) == (C)) && ((B) <= (D)))
75		75
76	/* these must be row_col_t */	76	/* these must be row_col_t */
77	#define ROWCOL_IS_AFTER(X, Y) \	77	#define ROWCOL_IS_AFTER(X, Y) \
78	ROW_AND_COL_IS_AFTER ((X).row, (X).col, (Y).row, (Y).col)	78	ROW_AND_COL_IS_AFTER ((X).row, (X).col, (Y).row, (Y).col)
79	#define ROWCOL_IS_BEFORE(X, Y) \	79	#define ROWCOL_IS_BEFORE(X, Y) \
80	ROW_AND_COL_IS_BEFORE ((X).row, (X).col, (Y).row, (Y).col)	80	ROW_AND_COL_IS_BEFORE ((X).row, (X).col, (Y).row, (Y).col)
81	#define ROWCOL_IN_ROW_AFTER(X, Y) \	81	#define ROWCOL_IN_ROW_AFTER(X, Y) \
82	ROW_AND_COL_IN_ROW_AFTER ((X).row, (X).col, (Y).row, (Y).col)	82	ROW_AND_COL_IN_ROW_AFTER ((X).row, (X).col, (Y).row, (Y).col)
83	#define ROWCOL_IN_ROW_BEFORE(X, Y) \	83	#define ROWCOL_IN_ROW_BEFORE(X, Y) \
84	ROW_AND_COL_IN_ROW_BEFORE ((X).row, (X).col, (Y).row, (Y).col)	84	ROW_AND_COL_IN_ROW_BEFORE ((X).row, (X).col, (Y).row, (Y).col)
85	#define ROWCOL_IN_ROW_AT_OR_AFTER(X, Y) \	85	#define ROWCOL_IN_ROW_AT_OR_AFTER(X, Y) \
86	ROW_AND_COL_IN_ROW_AT_OR_AFTER ((X).row, (X).col, (Y).row, (Y).col)	86	ROW_AND_COL_IN_ROW_AT_OR_AFTER ((X).row, (X).col, (Y).row, (Y).col)
87	#define ROWCOL_IN_ROW_AT_OR_BEFORE(X, Y) \	87	#define ROWCOL_IN_ROW_AT_OR_BEFORE(X, Y) \
88	ROW_AND_COL_IN_ROW_AT_OR_BEFORE ((X).row, (X).col, (Y).row, (Y).col)	88	ROW_AND_COL_IN_ROW_AT_OR_BEFORE ((X).row, (X).col, (Y).row, (Y).col)
89		89
90	/*	90	/*
91	* CLEAR_ROWS : clear <num> rows starting from row <row>	91	* CLEAR_ROWS : clear <num> rows starting from row <row>
92	* CLEAR_CHARS: clear <num> chars starting from pixel position <x,y>	92	* CLEAR_CHARS: clear <num> chars starting from pixel position <x,y>
93	* ERASE_ROWS : set <num> rows starting from row <row> to the foreground colour	93	* ERASE_ROWS : set <num> rows starting from row <row> to the foreground colour
94	*/	94	*/
95	#define drawBuffer TermWin.vt	95	#define drawBuffer TermWin.vt
96		96
97	#define CLEAR_ROWS(row, num) \	97	#define CLEAR_ROWS(row, num) \
98	if (TermWin.mapped) \	98	if (TermWin.mapped) \
99	XClearArea (display->display, drawBuffer, TermWin.int_bwidth, \	99	XClearArea (display->display, drawBuffer, 0, \
100	Row2Pixel (row), (unsigned int)TermWin.width, \	100	Row2Pixel (row), (unsigned int)TermWin.width, \
101	(unsigned int)Height2Pixel (num), False)	101	(unsigned int)Height2Pixel (num), False)
102		102
103	#define CLEAR_CHARS(x, y, num) \	103	#define CLEAR_CHARS(x, y, num) \
104	if (TermWin.mapped) \	104	if (TermWin.mapped) \
105	XClearArea (display->display, drawBuffer, x, y, \	105	XClearArea (display->display, drawBuffer, x, y, \
106	(unsigned int)Width2Pixel (num), \	106	(unsigned int)Width2Pixel (num), \
107	(unsigned int)Height2Pixel (1), False)	107	(unsigned int)Height2Pixel (1), False)
108		108
109	#define ERASE_ROWS(row, num) \	109	#define ERASE_ROWS(row, num) \
110	XFillRectangle (display->display, drawBuffer, TermWin.gc, \	110	XFillRectangle (display->display, drawBuffer, TermWin.gc, \
111	TermWin.int_bwidth, Row2Pixel (row), \	111	0, Row2Pixel (row), \
112	(unsigned int)TermWin.width, \	112	(unsigned int)TermWin.width, \
113	(unsigned int)Height2Pixel (num))	113	(unsigned int)Height2Pixel (num))
114		114
115	/* ------------------------------------------------------------------------- *	115	/* ------------------------------------------------------------------------- *
116	* SCREEN `COMMON' ROUTINES *	116	* SCREEN `COMMON' ROUTINES *
117	* ------------------------------------------------------------------------- */	117	* ------------------------------------------------------------------------- */
…		…
189	}	189	}
190		190
191	if (prev_nrow == 0)	191	if (prev_nrow == 0)
192	{	192	{
193	/*	193	/*
194	* first time called so just malloc everything : don't rely on realloc	194	* first time called so just malloc everything: don't rely on realloc
195	* Note: this is still needed so that all the scrollback lines are NULL	195	* Note: this is still needed so that all the scrollback lines are NULL
196	*/	196	*/
197	screen.text = (text_t **)rxvt_calloc (total_rows, sizeof (text_t *));	197	screen.text = (text_t **)rxvt_calloc (total_rows, sizeof (text_t *));
198	buf_text = (text_t **)rxvt_calloc (total_rows, sizeof (text_t *));	198	buf_text = (text_t **)rxvt_calloc (total_rows, sizeof (text_t *));
199	drawn_text = (text_t **)rxvt_calloc (nrow, sizeof (text_t *));	199	drawn_text = (text_t **)rxvt_calloc (nrow, sizeof (text_t *));
…		…
256	scr_scroll_text (0, (int)prev_nrow - 1, k, 1);	256	scr_scroll_text (0, (int)prev_nrow - 1, k, 1);
257		257
258	for (p = nrow; p < prev_nrow; p++)	258	for (p = nrow; p < prev_nrow; p++)
259	{	259	{
260	q = p + TermWin.saveLines;	260	q = p + TermWin.saveLines;
		261
261	if (screen.text[q])	262	if (screen.text[q])
262	{	263	{
263	#ifdef DEBUG_STRICT	264	#ifdef DEBUG_STRICT
264	assert (screen.rend[q]);	265	assert (screen.rend[q]);
265	#endif	266	#endif
266	talloc->free (screen.text[q]);	267	talloc->free (screen.text[q]);
267	ralloc->free (screen.rend[q]);	268	ralloc->free (screen.rend[q]);
268	}	269	}
		270
269	if (swap.text[p])	271	if (swap.text[p])
270	{	272	{
271	#ifdef DEBUG_STRICT	273	#ifdef DEBUG_STRICT
272	assert (swap.rend[p]);	274	assert (swap.rend[p]);
273	#endif	275	#endif
274	talloc->free (swap.text[p]);	276	talloc->free (swap.text[p]);
275	ralloc->free (swap.rend[p]);	277	ralloc->free (swap.rend[p]);
276	}	278	}
		279
277	#ifdef DEBUG_STRICT	280	#ifdef DEBUG_STRICT
278	assert (drawn_text[p] && drawn_rend[p]);	281	assert (drawn_text[p] && drawn_rend[p]);
279	#endif	282	#endif
280	talloc->free (drawn_text[p]);	283	talloc->free (drawn_text[p]);
281	ralloc->free (drawn_rend[p]);	284	ralloc->free (drawn_rend[p]);
…		…
311	swap.tlen[p] = 0;	314	swap.tlen[p] = 0;
312	swap.text[p] = NULL;	315	swap.text[p] = NULL;
313	swap.rend[p] = NULL;	316	swap.rend[p] = NULL;
314	drawn_text[p] = NULL;	317	drawn_text[p] = NULL;
315	drawn_rend[p] = NULL;	318	drawn_rend[p] = NULL;
316	scr_blank_screen_mem (swap.text, swap.rend, p, setrstyle);	319	scr_blank_screen_mem (swap.text, swap.rend, p, setrstyle);
317	scr_blank_screen_mem (drawn_text, drawn_rend, p, setrstyle);	320	scr_blank_screen_mem (drawn_text, drawn_rend, p, setrstyle);
318	}	321	}
319		322
320	if (k > 0)	323	if (k > 0)
321	{	324	{
…		…
336	}	339	}
337		340
338	/* resize columns */	341	/* resize columns */
339	if (ncol != prev_ncol)	342	if (ncol != prev_ncol)
340	{	343	{
341	int common = min (prev_ncol, ncol);
342	rxvt_salloc *ta = new rxvt_salloc (ncol * sizeof (text_t));	344	rxvt_salloc *ta = new rxvt_salloc (ncol * sizeof (text_t));
343	rxvt_salloc *ra = new rxvt_salloc (ncol * sizeof (rend_t));	345	rxvt_salloc *ra = new rxvt_salloc (ncol * sizeof (rend_t));
344		346
345	for (p = 0; p < total_rows; p++)	347	for (p = 0; p < total_rows; p++)
346	{	348	{
347	if (screen.text[p])	349	if (screen.text[p])
348	{	350	{
349	text_t *t = (text_t *)ta->alloc (); memcpy (t, screen.text[p], common * sizeof (text_t)); screen.text[p] = t;	351	screen.text[p] = (text_t *)ta->alloc (screen.text[p], prev_ncol * sizeof (text_t));
350	rend_t *r = (rend_t *)ra->alloc (); memcpy (r, screen.rend[p], common * sizeof (rend_t)); screen.rend[p] = r;	352	screen.rend[p] = (rend_t *)ra->alloc (screen.rend[p], prev_ncol * sizeof (rend_t));
351		353
352	MIN_IT (screen.tlen[p], (int16_t)ncol);	354	MIN_IT (screen.tlen[p], (int16_t)ncol);
353		355
354	if (ncol > prev_ncol)	356	if (ncol > prev_ncol)
355	scr_blank_line (& (screen.text[p][prev_ncol]),	357	scr_blank_line (&screen.text[p][prev_ncol],
356	& (screen.rend[p][prev_ncol]),	358	&screen.rend[p][prev_ncol],
357	ncol - prev_ncol,	359	ncol - prev_ncol, setrstyle);
358	setrstyle);
359	}	360	}
360	}	361	}
361		362
362	for (p = 0; p < nrow; p++)	363	for (p = 0; p < nrow; p++)
363	{	364	{
364	text_t *t = (text_t *)ta->alloc (); memcpy (t, drawn_text[p], common * sizeof (text_t)); drawn_text[p] = t;	365	drawn_text[p] = (text_t *)ta->alloc (drawn_text[p], prev_ncol * sizeof (text_t));
365	rend_t *r = (rend_t *)ra->alloc (); memcpy (r, drawn_rend[p], common * sizeof (rend_t)); drawn_rend[p] = r;	366	drawn_rend[p] = (rend_t *)ra->alloc (drawn_rend[p], prev_ncol * sizeof (rend_t));
366		367
367	if (ncol > prev_ncol)	368	if (ncol > prev_ncol)
368	scr_blank_line (& (drawn_text[p][prev_ncol]),	369	scr_blank_line (&drawn_text[p][prev_ncol],
369	& (drawn_rend[p][prev_ncol]),	370	&drawn_rend[p][prev_ncol],
370	ncol - prev_ncol, setrstyle);	371	ncol - prev_ncol, setrstyle);
371		372
372	if (swap.text[p])	373	if (swap.text[p])
373	{	374	{
374	text_t *t = (text_t *)ta->alloc (); memcpy (t, swap.text[p], common * sizeof (text_t)); swap.text[p] = t;	375	swap.text[p] = (text_t *)ta->alloc (swap.text[p], prev_ncol * sizeof (text_t));
375	rend_t *r = (rend_t *)ra->alloc (); memcpy (r, swap.rend[p], common * sizeof (rend_t)); swap.rend[p] = r;	376	swap.rend[p] = (rend_t *)ra->alloc (swap.rend[p], prev_ncol * sizeof (rend_t));
376		377
377	MIN_IT (swap.tlen[p], (int16_t)ncol);	378	MIN_IT (swap.tlen[p], (int16_t)ncol);
378		379
379	if (ncol > prev_ncol)	380	if (ncol > prev_ncol)
380	scr_blank_line (& (swap.text[p][prev_ncol]),	381	scr_blank_line (&swap.text[p][prev_ncol],
381	& (swap.rend[p][prev_ncol]),	382	&swap.rend[p][prev_ncol],
382	ncol - prev_ncol, setrstyle);	383	ncol - prev_ncol, setrstyle);
383	}	384	}
384		385
385	}	386	}
386		387
…		…
438	{	439	{
439	uint16_t total_rows;	440	uint16_t total_rows;
440	int i;	441	int i;
441		442
442	total_rows = TermWin.nrow + TermWin.saveLines;	443	total_rows = TermWin.nrow + TermWin.saveLines;
443
444	#ifdef DEBUG_STRICT
445	for (i = 0; i < total_rows; i++)
446	{
447	if (screen.text[i])
448	/* then so is screen.rend[i] */
449	assert (screen.rend[i]);
450	}
451	#endif
452		444
453	delete talloc; talloc = 0;	445	delete talloc; talloc = 0;
454	delete ralloc; ralloc = 0;	446	delete ralloc; ralloc = 0;
455		447
456	free (screen.text);	448	free (screen.text);
…		…
485		477
486	scr_release ();	478	scr_release ();
487	prev_nrow = prev_ncol = 0;	479	prev_nrow = prev_ncol = 0;
488	scr_reset ();	480	scr_reset ();
489		481
490	scr_clear ();	482	scr_clear (true);
491	scr_refresh (SLOW_REFRESH);	483	scr_refresh (SLOW_REFRESH);
492	}	484	}
493		485
494	/* ------------------------------------------------------------------------- *	486	/* ------------------------------------------------------------------------- *
495	* PROCESS SCREEN COMMANDS *	487	* PROCESS SCREEN COMMANDS *
…		…
500	* XTERM_SEQ: Restore cursor: ESC 8	492	* XTERM_SEQ: Restore cursor: ESC 8
501	*/	493	*/
502	void	494	void
503	rxvt_term::scr_cursor (int mode)	495	rxvt_term::scr_cursor (int mode)
504	{	496	{
505	screen_t *s;	497	screen_t *s;
506		498
507	D_SCREEN ((stderr, "rxvt_scr_cursor (%c)", mode));	499	D_SCREEN ((stderr, "rxvt_scr_cursor (%c)", mode));
508		500
509	#if NSCREENS && !defined(NO_SECONDARY_SCREEN_CURSOR)	501	#if NSCREENS && !defined(NO_SECONDARY_SCREEN_CURSOR)
510	if (current_screen == SECONDARY)	502	if (current_screen == SECONDARY)
511	s = & (swap);	503	s = &swap;
512	else	504	else
513	#endif	505	#endif
514	s = & (screen);	506	s = &screen;
		507
515	switch (mode)	508	switch (mode)
516	{	509	{
517	case SAVE:	510	case SAVE:
518	s->s_cur.row = s->cur.row;	511	s->s_cur.row = s->cur.row;
519	s->s_cur.col = s->cur.col;	512	s->s_cur.col = s->cur.col;
520	s->s_rstyle = rstyle;	513	s->s_rstyle = rstyle;
521	s->s_charset = s->charset;	514	s->s_charset = s->charset;
522	s->s_charset_char = charsets[s->charset];	515	s->s_charset_char = charsets[s->charset];
523	break;	516	break;
		517
524	case RESTORE:	518	case RESTORE:
525	want_refresh = 1;	519	want_refresh = 1;
526	s->cur.row = s->s_cur.row;	520	s->cur.row = s->s_cur.row;
527	s->cur.col = s->s_cur.col;	521	s->cur.col = s->s_cur.col;
528	s->flags &= ~Screen_WrapNext;	522	s->flags &= ~Screen_WrapNext;
…		…
530	s->charset = s->s_charset;	524	s->charset = s->s_charset;
531	charsets[s->charset] = s->s_charset_char;	525	charsets[s->charset] = s->s_charset_char;
532	set_font_style ();	526	set_font_style ();
533	break;	527	break;
534	}	528	}
		529
535	/* boundary check in case screen size changed between SAVE and RESTORE */	530	/* boundary check in case screen size changed between SAVE and RESTORE */
536	MIN_IT (s->cur.row, TermWin.nrow - 1);	531	MIN_IT (s->cur.row, TermWin.nrow - 1);
537	MIN_IT (s->cur.col, TermWin.ncol - 1);	532	MIN_IT (s->cur.col, TermWin.ncol - 1);
538	#ifdef DEBUG_STRICT	533	#ifdef DEBUG_STRICT
539	assert (s->cur.row >= 0);	534	assert (s->cur.row >= 0);
…		…
551	* XTERM_SEQ: Secondary screen: ESC [ ? 4 7 l	546	* XTERM_SEQ: Secondary screen: ESC [ ? 4 7 l
552	*/	547	*/
553	int	548	int
554	rxvt_term::scr_change_screen (int scrn)	549	rxvt_term::scr_change_screen (int scrn)
555	{	550	{
556	int i;	551	int i;
557	#if NSCREENS	552	#if NSCREENS
558	int offset;	553	int offset;
559	#endif	554	#endif
560		555
561	want_refresh = 1;	556	want_refresh = 1;
562		557
563	D_SCREEN ((stderr, "rxvt_scr_change_screen (%d)", scrn));	558	D_SCREEN ((stderr, "rxvt_scr_change_screen (%d)", scrn));
564		559
565	TermWin.view_start = 0;	560	TermWin.view_start = 0;
566		561
567	if (current_screen == scrn)	562	if (current_screen == scrn)
568	return current_screen;	563	return scrn;
569		564
570	selection_check (2); /* check for boundary cross */	565	selection_check (2); /* check for boundary cross */
571		566
572	SWAP_IT (current_screen, scrn, int);	567	SWAP_IT (current_screen, scrn, int);
573	#if NSCREENS	568	#if NSCREENS
		569	if (Options & Opt_secondaryScreen)
		570	{
574	num_scr = 0;	571	num_scr = 0;
575	offset = TermWin.saveLines;	572	offset = TermWin.saveLines;
576	for (i = prev_nrow; i--;)	573	for (i = prev_nrow; i--;)
577	{	574	{
578	SWAP_IT (screen.text[i + offset], swap.text[i], text_t *);	575	SWAP_IT (screen.text[i + offset], swap.text[i], text_t *);
579	SWAP_IT (screen.tlen[i + offset], swap.tlen[i], int16_t);	576	SWAP_IT (screen.tlen[i + offset], swap.tlen[i], int16_t);
580	SWAP_IT (screen.rend[i + offset], swap.rend[i], rend_t *);	577	SWAP_IT (screen.rend[i + offset], swap.rend[i], rend_t *);
581	}	578	}
582	SWAP_IT (screen.cur.row, swap.cur.row, int16_t);	579	SWAP_IT (screen.cur.row, swap.cur.row, int16_t);
583	SWAP_IT (screen.cur.col, swap.cur.col, int16_t);	580	SWAP_IT (screen.cur.col, swap.cur.col, int16_t);
584	# ifdef DEBUG_STRICT	581	# ifdef DEBUG_STRICT
585	assert ((screen.cur.row >= 0) && (screen.cur.row < prev_nrow));	582	assert ((screen.cur.row >= 0) && (screen.cur.row < prev_nrow));
586	assert ((screen.cur.col >= 0) && (screen.cur.col < prev_ncol));	583	assert ((screen.cur.col >= 0) && (screen.cur.col < prev_ncol));
587	# else /* drive with your eyes closed */	584	# else /* drive with your eyes closed */
588	MAX_IT (screen.cur.row, 0);	585	MAX_IT (screen.cur.row, 0);
589	MIN_IT (screen.cur.row, (int32_t)prev_nrow - 1);	586	MIN_IT (screen.cur.row, (int32_t)prev_nrow - 1);
590	MAX_IT (screen.cur.col, 0);	587	MAX_IT (screen.cur.col, 0);
591	MIN_IT (screen.cur.col, (int32_t)prev_ncol - 1);	588	MIN_IT (screen.cur.col, (int32_t)prev_ncol - 1);
592	# endif	589	# endif
593	SWAP_IT (screen.charset, swap.charset, int16_t);	590	SWAP_IT (screen.charset, swap.charset, int16_t);
594	SWAP_IT (screen.flags, swap.flags, int);	591	SWAP_IT (screen.flags, swap.flags, int);
595	screen.flags |= Screen_VisibleCursor;	592	screen.flags |= Screen_VisibleCursor;
596	swap.flags |= Screen_VisibleCursor;	593	swap.flags |= Screen_VisibleCursor;
597	#else	594	}
598	# ifdef SCROLL_ON_NO_SECONDARY	595	else
		596	#endif
		597	if (Options & Opt_secondaryScroll)
599	if (current_screen == PRIMARY)	598	//if (current_screen == PRIMARY)
600	scr_scroll_text (0, (prev_nrow - 1), prev_nrow, 0);	599	scr_scroll_text (0, (prev_nrow - 1), prev_nrow, 0);
601	# endif
602	#endif
603	return scrn;	600	return scrn;
604	}	601	}
605		602
606	/* ------------------------------------------------------------------------- */	603	/* ------------------------------------------------------------------------- */
607	/*	604	/*
…		…
649	return 0;	646	return 0;
650		647
651	want_refresh = 1;	648	want_refresh = 1;
652	D_SCREEN ((stderr, "rxvt_scroll_text (%d,%d,%d,%d): %s", row1, row2, count, spec, (current_screen == PRIMARY) ? "Primary" : "Secondary"));	649	D_SCREEN ((stderr, "rxvt_scroll_text (%d,%d,%d,%d): %s", row1, row2, count, spec, (current_screen == PRIMARY) ? "Primary" : "Secondary"));
653		650
654	if ((count > 0) && (row1 == 0) && (current_screen == PRIMARY))	651	if (row1 == 0 && count > 0
		652	&& (current_screen == PRIMARY || Options & Opt_secondaryScroll))
655	{	653	{
656	nscrolled = (long)TermWin.nscrolled + (long)count;	654	nscrolled = (long)TermWin.nscrolled + (long)count;
657		655
658	if (nscrolled > (long)TermWin.saveLines)	656	if (nscrolled > (long)TermWin.saveLines)
659	TermWin.nscrolled = TermWin.saveLines;	657	TermWin.nscrolled = TermWin.saveLines;
…		…
712	for (i = 0, j = row1; i < count; i++, j++)	710	for (i = 0, j = row1; i < count; i++, j++)
713	{	711	{
714	buf_text[i] = screen.text[j];	712	buf_text[i] = screen.text[j];
715	buf_rend[i] = screen.rend[j];	713	buf_rend[i] = screen.rend[j];
716	}	714	}
		715
717	/* A2: Rotate lines */	716	/* A2: Rotate lines */
718	for (j = row1, i = j + count; i <= row2; i++, j++)	717	for (j = row1, i = j + count; i <= row2; i++, j++)
719	{	718	{
720	screen.tlen[j] = screen.tlen[i];	719	screen.tlen[j] = screen.tlen[i];
721	screen.text[j] = screen.text[i];	720	screen.text[j] = screen.text[i];
722	screen.rend[j] = screen.rend[i];	721	screen.rend[j] = screen.rend[i];
723	}	722	}
		723
724	j = row2 - count + 1, i = count;	724	j = row2 - count + 1, i = count;
725	}	725	}
726	else /* if (j < 0) */	726	else /* if (j < 0) */
727	{	727	{
728	/* B: scroll down */	728	/* B: scroll down */
…		…
731	for (i = 0, j = row2; i < count; i++, j--)	731	for (i = 0, j = row2; i < count; i++, j--)
732	{	732	{
733	buf_text[i] = screen.text[j];	733	buf_text[i] = screen.text[j];
734	buf_rend[i] = screen.rend[j];	734	buf_rend[i] = screen.rend[j];
735	}	735	}
		736
736	/* B2: Rotate lines */	737	/* B2: Rotate lines */
737	for (j = row2, i = j - count; i >= row1; i--, j--)	738	for (j = row2, i = j - count; i >= row1; i--, j--)
738	{	739	{
739	screen.tlen[j] = screen.tlen[i];	740	screen.tlen[j] = screen.tlen[i];
740	screen.text[j] = screen.text[i];	741	screen.text[j] = screen.text[i];
741	screen.rend[j] = screen.rend[i];	742	screen.rend[j] = screen.rend[i];
742	}	743	}
		744
743	j = row1, i = count;	745	j = row1, i = count;
744	count = -count;	746	count = -count;
745	}	747	}
746		748
747	/* C: Resurrect lines */	749	/* C: Resurrect lines */
…		…
750	screen.tlen[j] = 0;	752	screen.tlen[j] = 0;
751	screen.text[j] = buf_text[i];	753	screen.text[j] = buf_text[i];
752	screen.rend[j] = buf_rend[i];	754	screen.rend[j] = buf_rend[i];
753		755
754	if (!spec) /* line length may not equal TermWin.ncol */	756	if (!spec) /* line length may not equal TermWin.ncol */
755	scr_blank_screen_mem (screen.text, screen.rend,	757	scr_blank_screen_mem (screen.text, screen.rend, (unsigned int)j, rstyle);
756	(unsigned int)j, rstyle);
757	}	758	}
758		759
759	return count;	760	return count;
760	}	761	}
761		762
762	/* ------------------------------------------------------------------------- */	763	/* ------------------------------------------------------------------------- */
763	/*	764	/*
764	* Add text given in <str> of length <len> to screen struct	765	* Add text given in <str> of length <len> to screen struct
765	*/	766	*/
766	void	767	void
767	rxvt_term::scr_add_lines (const uint32_t *str, int nlines, int len)	768	rxvt_term::scr_add_lines (const unicode_t *str, int nlines, int len)
768	{	769	{
769	unsigned char checksel, clearsel;	770	unsigned char checksel, clearsel;
770	uint32_t c;	771	unicode_t c;
771	int i, row, last_col;	772	int i, row, last_col;
772	text_t *stp;	773	text_t *stp;
773	rend_t *srp;	774	rend_t *srp;
774		775
775	if (len <= 0) /* sanity */	776	if (len <= 0) /* sanity */
…		…
801	MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);	802	MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);
802	MAX_IT (screen.cur.row, - (int32_t)TermWin.nscrolled);	803	MAX_IT (screen.cur.row, - (int32_t)TermWin.nscrolled);
803	#endif	804	#endif
804	row = screen.cur.row + TermWin.saveLines;	805	row = screen.cur.row + TermWin.saveLines;
805		806
806	checksel = (selection.op	807	checksel = selection.op && current_screen == selection.screen ? 1 : 0;
807	&& current_screen == selection.screen) ? 1 : 0;
808	clearsel = 0;	808	clearsel = 0;
809		809
810	stp = screen.text[row];	810	stp = screen.text[row];
811	srp = screen.rend[row];	811	srp = screen.rend[row];
812		812
813	for (i = 0; i < len;)	813	while (len--)
814	{	814	{
815	c = str[i++];	815	c = *str++;
		816
		817	if (c < 0x20)
816	switch (c)	818	switch (c)
817	{	819	{
818	case '\t':	820	case C0_HT:
819	scr_tab (1);	821	scr_tab (1);
820	continue;	822	continue;
821	case '\n':	823
		824	case C0_LF:
822	if (screen.tlen[row] != -1) /* XXX: think about this */	825	if (screen.tlen[row] != -1) /* XXX: think about this */
823	MAX_IT (screen.tlen[row], screen.cur.col);	826	MAX_IT (screen.tlen[row], screen.cur.col);
		827
824	screen.flags &= ~Screen_WrapNext;	828	screen.flags &= ~Screen_WrapNext;
		829
825	if (screen.cur.row == screen.bscroll)	830	if (screen.cur.row == screen.bscroll)
826	scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);	831	scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);
827	else if (screen.cur.row < (TermWin.nrow - 1))	832	else if (screen.cur.row < (TermWin.nrow - 1))
828	row = (++screen.cur.row) + TermWin.saveLines;	833	row = (++screen.cur.row) + TermWin.saveLines;
		834
829	stp = screen.text[row]; /* _must_ refresh */	835	stp = screen.text[row]; /* _must_ refresh */
830	srp = screen.rend[row]; /* _must_ refresh */	836	srp = screen.rend[row]; /* _must_ refresh */
831	continue;	837	continue;
832	case '\r':	838
		839	case C0_CR:
833	if (screen.tlen[row] != -1) /* XXX: think about this */	840	if (screen.tlen[row] != -1) /* XXX: think about this */
834	MAX_IT (screen.tlen[row], screen.cur.col);	841	MAX_IT (screen.tlen[row], screen.cur.col);
		842
835	screen.flags &= ~Screen_WrapNext;	843	screen.flags &= ~Screen_WrapNext;
836	screen.cur.col = 0;	844	screen.cur.col = 0;
837	continue;	845	continue;
838	default:
839	if (c == 127)
840	continue; /* yummmm..... */
841	break;
842	}	846	}
843		847
844	if (checksel /* see if we're writing within selection */	848	if (checksel /* see if we're writing within selection */
845	&& !ROWCOL_IS_BEFORE (screen.cur, selection.beg)	849	&& !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
846	&& ROWCOL_IS_BEFORE (screen.cur, selection.end))	850	&& ROWCOL_IS_BEFORE (screen.cur, selection.end))
847	{	851	{
…		…
866	if (screen.flags & Screen_Insert)	870	if (screen.flags & Screen_Insert)
867	scr_insdel_chars (1, INSERT);	871	scr_insdel_chars (1, INSERT);
868		872
869	// rely on wcwidth to tell us the character width, at least for non-latin1	873	// rely on wcwidth to tell us the character width, at least for non-latin1
870	// do wcwidth before further replacements, as wcwidth says that line-drawing	874	// do wcwidth before further replacements, as wcwidth says that line-drawing
871	// characters have width -1 (DOH!) on gnu/linux sometimes.	875	// characters have width -1 (DOH!) on GNU/Linux sometimes.
872	int width = c < 256 ? 1 : wcwidth (c);	876	int width = c < 256 ? 1 : wcwidth (c);
873		877
874	if (charsets[screen.charset] == '0') // DEC SPECIAL	878	if (charsets[screen.charset] == '0') // DEC SPECIAL
875	switch (c)
876	{	879	{
877	// vt100 special graphics and line drawing	880	// vt100 special graphics and line drawing
878	case '`': c = 0x25c6; break; case '_': c = 0x0020; break;	881	static uint16_t vt100_0[32] = { // 5f .. 7e
879	case 'a': c = 0x2592; break; case 'b': c = 0x2409; break; case 'c': c = 0x240c; break;	882	0x0020, 0x25c6, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0,
880	case 'd': c = 0x240d; break; case 'e': c = 0x240a; break; case 'f': c = 0x00b0; break;	883	0x00b1, 0x2424, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c,
881	case 'g': c = 0x00b1; break; case 'h': c = 0x2424; break; case 'i': c = 0x240b; break;	884	0x23ba, 0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534,
882	case 'j': c = 0x2518; break; case 'k': c = 0x2510; break; case 'l': c = 0x250c; break;	885	0x252c, 0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7,
883	case 'm': c = 0x2514; break; case 'n': c = 0x253c; break; case 'o': c = 0x23ba; break;
884	case 'p': c = 0x23bb; break; case 'q': c = 0x2500; break; case 'r': c = 0x23bc; break;
885	case 's': c = 0x23bd; break; case 't': c = 0x251c; break; case 'u': c = 0x2524; break;
886	case 'v': c = 0x2534; break; case 'w': c = 0x252c; break; case 'x': c = 0x2502; break;
887	case 'y': c = 0x2264; break; case 'z': c = 0x2265; break; case '{': c = 0x03c0; break;
888	case '|': c = 0x2260; break; case '}': c = 0x00a3; break; case '~': c = 0x00b7; break;
889	}	886	};
890		887
		888	if (c >= 0x5f && c <= 0x7e)
		889	{
		890	c = vt100_0[c - 0x5f];
		891	width = 1;
		892	}
		893	}
		894
891	if (width > 0)	895	if (width != 0)
892	{	896	{
893	#if !UNICODE_3 && ENABLE_COMBINING	897	#if !UNICODE_3 && ENABLE_COMBINING
894	// trim characters we can't store directly :(	898	// trim characters we can't store directly :(
895	if (c >= 0x10000)	899	if (c >= 0x10000)
896	c = rxvt_composite.compose (c); // map to lower 16 bits	900	c = rxvt_composite.compose (c); // map to lower 16 bits
897	#endif	901	#endif
		902	bool bold = (Options & Opt_realBold) && ((rstyle & RS_Bold) != 0);
898	rend_t rend = SET_FONT (rstyle, TermWin.fontset->find_font (c));	903	rend_t rend = SET_FONT (rstyle, TermWin.fontset->find_font (c, bold));
899		904
900	do	905	do
901	{	906	{
902	stp[screen.cur.col] = c;	907	stp[screen.cur.col] = c;
903	srp[screen.cur.col] = rend;	908	srp[screen.cur.col] = rend;
…		…
951	// handle double-width-chars by making them look extremely ugly	956	// handle double-width-chars by making them look extremely ugly
952	if (*tp == NOCHAR)	957	if (*tp == NOCHAR)
953	*tp = ' '; // hack //D //TODO //--tp, --rp;	958	*tp = ' '; // hack //D //TODO //--tp, --rp;
954		959
955	// first try to find a precomposed character	960	// first try to find a precomposed character
956	uint32_t n = rxvt_compose (*tp, c);	961	unicode_t n = rxvt_compose (*tp, c);
957	if (n == NOCHAR)	962	if (n == NOCHAR)
958	n = rxvt_composite.compose (*tp, c);	963	n = rxvt_composite.compose (*tp, c);
959		964
960	*tp = n;	965	*tp = n;
961	*rp = SET_FONT (*rp, TermWin.fontset->find_font (*tp));	966	*rp = SET_FONT (*rp, TermWin.fontset->find_font (*tp));
…		…
988	*/	993	*/
989	void	994	void
990	rxvt_term::scr_backspace ()	995	rxvt_term::scr_backspace ()
991	{	996	{
992	want_refresh = 1;	997	want_refresh = 1;
		998
993	if (screen.cur.col == 0)	999	if (screen.cur.col == 0)
994	{	1000	{
995	if (screen.cur.row > 0)	1001	if (screen.cur.row > 0)
996	{	1002	{
997	#ifdef TERMCAP_HAS_BW	1003	#ifdef TERMCAP_HAS_BW
…		…
1002		1008
1003	}	1009	}
1004	}	1010	}
1005	else if ((screen.flags & Screen_WrapNext) == 0)	1011	else if ((screen.flags & Screen_WrapNext) == 0)
1006	scr_gotorc (0, -1, RELATIVE);	1012	scr_gotorc (0, -1, RELATIVE);
		1013
1007	screen.flags &= ~Screen_WrapNext;	1014	screen.flags &= ~Screen_WrapNext;
1008	}	1015	}
1009		1016
1010	/* ------------------------------------------------------------------------- */	1017	/* ------------------------------------------------------------------------- */
1011	/*	1018	/*
…		…
1014	* XTERM_SEQ: CTRL-I	1021	* XTERM_SEQ: CTRL-I
1015	*/	1022	*/
1016	void	1023	void
1017	rxvt_term::scr_tab (int count)	1024	rxvt_term::scr_tab (int count)
1018	{	1025	{
1019	int i, x;	1026	int i, x;
1020		1027
1021	D_SCREEN ((stderr, "rxvt_scr_tab (%d)", count));	1028	D_SCREEN ((stderr, "rxvt_scr_tab (%d)", count));
1022	want_refresh = 1;	1029	want_refresh = 1;
1023	i = x = screen.cur.col;	1030	i = x = screen.cur.col;
		1031
1024	if (count == 0)	1032	if (count == 0)
1025	return;	1033	return;
1026	else if (count > 0)	1034	else if (count > 0)
1027	{	1035	{
1028	for (; ++i < TermWin.ncol; )	1036	for (; ++i < TermWin.ncol; )
…		…
1030	{	1038	{
1031	x = i;	1039	x = i;
1032	if (!--count)	1040	if (!--count)
1033	break;	1041	break;
1034	}	1042	}
		1043
1035	if (count)	1044	if (count)
1036	x = TermWin.ncol - 1;	1045	x = TermWin.ncol - 1;
1037	}	1046	}
1038	else /* if (count < 0) */	1047	else /* if (count < 0) */
1039	{	1048	{
…		…
1042	{	1051	{
1043	x = i;	1052	x = i;
1044	if (!++count)	1053	if (!++count)
1045	break;	1054	break;
1046	}	1055	}
		1056
1047	if (count)	1057	if (count)
1048	x = 0;	1058	x = 0;
1049	}	1059	}
		1060
1050	if (x != screen.cur.col)	1061	if (x != screen.cur.col)
1051	scr_gotorc (0, x, R_RELATIVE);	1062	scr_gotorc (0, x, R_RELATIVE);
1052	}	1063	}
1053		1064
1054	/* ------------------------------------------------------------------------- */	1065	/* ------------------------------------------------------------------------- */
…		…
1111	want_refresh = 1;	1122	want_refresh = 1;
1112	ZERO_SCROLLBACK ();	1123	ZERO_SCROLLBACK ();
1113		1124
1114	D_SCREEN ((stderr, "rxvt_scr_gotorc (r:%s%d,c:%s%d): from (r:%d,c:%d)", (relative & R_RELATIVE ? "+" : ""), row, (relative & C_RELATIVE ? "+" : ""), col, screen.cur.row, screen.cur.col));	1125	D_SCREEN ((stderr, "rxvt_scr_gotorc (r:%s%d,c:%s%d): from (r:%d,c:%d)", (relative & R_RELATIVE ? "+" : ""), row, (relative & C_RELATIVE ? "+" : ""), col, screen.cur.row, screen.cur.col));
1115		1126
1116	screen.cur.col = ((relative & C_RELATIVE) ? (screen.cur.col + col)	1127	screen.cur.col = relative & C_RELATIVE ? screen.cur.col + col : col;
1117	: col);
1118	MAX_IT (screen.cur.col, 0);	1128	MAX_IT (screen.cur.col, 0);
1119	MIN_IT (screen.cur.col, (int32_t)TermWin.ncol - 1);	1129	MIN_IT (screen.cur.col, (int32_t)TermWin.ncol - 1);
1120		1130
1121	screen.flags &= ~Screen_WrapNext;	1131	screen.flags &= ~Screen_WrapNext;
1122	if (relative & R_RELATIVE)	1132	if (relative & R_RELATIVE)
…		…
1161	* direction should be UP or DN	1171	* direction should be UP or DN
1162	*/	1172	*/
1163	void	1173	void
1164	rxvt_term::scr_index (enum page_dirn direction)	1174	rxvt_term::scr_index (enum page_dirn direction)
1165	{	1175	{
1166	int dirn;	1176	int dirn;
1167		1177
1168	want_refresh = 1;	1178	want_refresh = 1;
1169	dirn = ((direction == UP) ? 1 : -1);	1179	dirn = ((direction == UP) ? 1 : -1);
1170	D_SCREEN ((stderr, "rxvt_scr_index (%d)", dirn));	1180	D_SCREEN ((stderr, "rxvt_scr_index (%d)", dirn));
1171		1181
…		…
1231	default:	1241	default:
1232	return;	1242	return;
1233	}	1243	}
1234		1244
1235	if (screen.text[row])	1245	if (screen.text[row])
1236	scr_blank_line (& (screen.text[row][col]),	1246	scr_blank_line (&screen.text[row][col], &screen.rend[row][col], num, rstyle);
1237	& (screen.rend[row][col]), num, rstyle);
1238	else	1247	else
1239	scr_blank_screen_mem (screen.text, screen.rend, row, rstyle);	1248	scr_blank_screen_mem (screen.text, screen.rend, row, rstyle);
1240	}	1249	}
1241		1250
1242	/* ------------------------------------------------------------------------- */	1251	/* ------------------------------------------------------------------------- */
…		…
1247	* XTERM_SEQ: Clear whole screen : ESC [ 2 J	1256	* XTERM_SEQ: Clear whole screen : ESC [ 2 J
1248	*/	1257	*/
1249	void	1258	void
1250	rxvt_term::scr_erase_screen (int mode)	1259	rxvt_term::scr_erase_screen (int mode)
1251	{	1260	{
1252	int num;	1261	int num;
1253	int32_t row, row_offset;	1262	int32_t row, row_offset;
1254	rend_t ren;	1263	rend_t ren;
1255	XGCValues gcvalue;	1264	XGCValues gcvalue;
1256		1265
1257	want_refresh = 1;	1266	want_refresh = 1;
1258	D_SCREEN ((stderr, "rxvt_scr_erase_screen (%d) at screen row: %d", mode, screen.cur.row));	1267	D_SCREEN ((stderr, "rxvt_scr_erase_screen (%d) at screen row: %d", mode, screen.cur.row));
1259	ZERO_SCROLLBACK ();	1268	ZERO_SCROLLBACK ();
1260	row_offset = (int32_t)TermWin.saveLines;	1269	row_offset = (int32_t)TermWin.saveLines;
…		…
1279	num = TermWin.nrow;	1288	num = TermWin.nrow;
1280	break;	1289	break;
1281	default:	1290	default:
1282	return;	1291	return;
1283	}	1292	}
		1293
1284	refresh_type |= REFRESH_BOUNDS;	1294	refresh_type |= REFRESH_BOUNDS;
		1295
1285	if (selection.op && current_screen == selection.screen	1296	if (selection.op && current_screen == selection.screen
1286	&& ((selection.beg.row >= row && selection.beg.row <= row + num)	1297	&& ((selection.beg.row >= row && selection.beg.row <= row + num)
1287	|| (selection.end.row >= row	1298	|| (selection.end.row >= row
1288	&& selection.end.row <= row + num)))	1299	&& selection.end.row <= row + num)))
1289	CLEAR_SELECTION ();	1300	CLEAR_SELECTION ();
		1301
1290	if (row >= TermWin.nrow) /* Out Of Bounds */	1302	if (row >= TermWin.nrow) /* Out Of Bounds */
1291	return;	1303	return;
		1304
1292	MIN_IT (num, (TermWin.nrow - row));	1305	MIN_IT (num, (TermWin.nrow - row));
		1306
1293	if (rstyle & (RS_RVid | RS_Uline))	1307	if (rstyle & (RS_RVid | RS_Uline))
1294	ren = (rend_t) ~RS_None;	1308	ren = (rend_t) ~RS_None;
1295	else if (GET_BASEBG (rstyle) == Color_bg)	1309	else if (GET_BASEBG (rstyle) == Color_bg)
1296	{	1310	{
1297	ren = DEFAULT_RSTYLE;	1311	ren = DEFAULT_RSTYLE;
…		…
1304	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);	1318	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);
1305	ERASE_ROWS (row, num);	1319	ERASE_ROWS (row, num);
1306	gcvalue.foreground = PixColors[Color_fg];	1320	gcvalue.foreground = PixColors[Color_fg];
1307	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);	1321	XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);
1308	}	1322	}
		1323
1309	for (; num--; row++)	1324	for (; num--; row++)
1310	{	1325	{
1311	scr_blank_screen_mem (screen.text, screen.rend,	1326	scr_blank_screen_mem (screen.text, screen.rend,
1312	(unsigned int) (row + row_offset), rstyle);	1327	(unsigned int) (row + row_offset), rstyle);
1313	screen.tlen[row + row_offset] = 0;	1328	screen.tlen[row + row_offset] = 0;
…		…
1347	* Insert/Delete <count> lines	1362	* Insert/Delete <count> lines
1348	*/	1363	*/
1349	void	1364	void
1350	rxvt_term::scr_insdel_lines (int count, int insdel)	1365	rxvt_term::scr_insdel_lines (int count, int insdel)
1351	{	1366	{
1352	int end;	1367	int end;
1353		1368
1354	ZERO_SCROLLBACK ();	1369	ZERO_SCROLLBACK ();
1355		1370
1356	selection_check (1);	1371	selection_check (1);
1357		1372
…		…
1376	* Insert/Delete <count> characters from the current position	1391	* Insert/Delete <count> characters from the current position
1377	*/	1392	*/
1378	void	1393	void
1379	rxvt_term::scr_insdel_chars (int count, int insdel)	1394	rxvt_term::scr_insdel_chars (int count, int insdel)
1380	{	1395	{
1381	int col, row;	1396	int col, row;
1382	rend_t tr;	1397	rend_t tr;
1383	text_t *stp;	1398	text_t *stp;
1384	rend_t *srp;	1399	rend_t *srp;
1385	int16_t *slp;	1400	int16_t *slp;
1386		1401
1387	want_refresh = 1;	1402	want_refresh = 1;
1388	ZERO_SCROLLBACK ();	1403	ZERO_SCROLLBACK ();
1389		1404
1390	if (count <= 0)	1405	if (count <= 0)
…		…
1397	screen.flags &= ~Screen_WrapNext;	1412	screen.flags &= ~Screen_WrapNext;
1398		1413
1399	stp = screen.text[row];	1414	stp = screen.text[row];
1400	srp = screen.rend[row];	1415	srp = screen.rend[row];
1401	slp = & (screen.tlen[row]);	1416	slp = & (screen.tlen[row]);
		1417
1402	switch (insdel)	1418	switch (insdel)
1403	{	1419	{
1404	case INSERT:	1420	case INSERT:
1405	for (col = TermWin.ncol - 1; (col - count) >= screen.cur.col;	1421	for (col = TermWin.ncol - 1; (col - count) >= screen.cur.col;
1406	col--)	1422	col--)
1407	{	1423	{
1408	stp[col] = stp[col - count];	1424	stp[col] = stp[col - count];
1409	srp[col] = srp[col - count];	1425	srp[col] = srp[col - count];
1410	}	1426	}
		1427
1411	if (*slp != -1)	1428	if (*slp != -1)
1412	{	1429	{
1413	*slp += count;	1430	*slp += count;
1414	MIN_IT (*slp, TermWin.ncol);	1431	MIN_IT (*slp, TermWin.ncol);
1415	}	1432	}
		1433
1416	if (selection.op && current_screen == selection.screen	1434	if (selection.op && current_screen == selection.screen
1417	&& ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))	1435	&& ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
1418	{	1436	{
1419	if (selection.end.row != screen.cur.row	1437	if (selection.end.row != screen.cur.row
1420	|| (selection.end.col + count >= TermWin.ncol))	1438	|| (selection.end.col + count >= TermWin.ncol))
…		…
1424	selection.beg.col += count;	1442	selection.beg.col += count;
1425	selection.mark.col += count; /* XXX: yes? */	1443	selection.mark.col += count; /* XXX: yes? */
1426	selection.end.col += count;	1444	selection.end.col += count;
1427	}	1445	}
1428	}	1446	}
		1447
1429	scr_blank_line (& (stp[screen.cur.col]), & (srp[screen.cur.col]),	1448	scr_blank_line (& (stp[screen.cur.col]), & (srp[screen.cur.col]),
1430	(unsigned int)count, rstyle);	1449	(unsigned int)count, rstyle);
1431	break;	1450	break;
		1451
1432	case ERASE:	1452	case ERASE:
1433	screen.cur.col += count; /* don't worry if > TermWin.ncol */	1453	screen.cur.col += count; /* don't worry if > TermWin.ncol */
1434	selection_check (1);	1454	selection_check (1);
1435	screen.cur.col -= count;	1455	screen.cur.col -= count;
1436	scr_blank_line (& (stp[screen.cur.col]), & (srp[screen.cur.col]),	1456	scr_blank_line (& (stp[screen.cur.col]), & (srp[screen.cur.col]),
1437	(unsigned int)count, rstyle);	1457	(unsigned int)count, rstyle);
1438	break;	1458	break;
		1459
1439	case DELETE:	1460	case DELETE:
1440	tr = srp[TermWin.ncol - 1]
1441	& (RS_fgMask | RS_bgMask | RS_baseattrMask);	1461	tr = srp[TermWin.ncol - 1] & (RS_fgMask | RS_bgMask | RS_baseattrMask);
		1462
1442	for (col = screen.cur.col; (col + count) < TermWin.ncol; col++)	1463	for (col = screen.cur.col; (col + count) < TermWin.ncol; col++)
1443	{	1464	{
1444	stp[col] = stp[col + count];	1465	stp[col] = stp[col + count];
1445	srp[col] = srp[col + count];	1466	srp[col] = srp[col + count];
1446	}	1467	}
		1468
1447	scr_blank_line (& (stp[TermWin.ncol - count]),	1469	scr_blank_line (& (stp[TermWin.ncol - count]),
1448	& (srp[TermWin.ncol - count]),	1470	& (srp[TermWin.ncol - count]),
1449	(unsigned int)count, tr);	1471	(unsigned int)count, tr);
		1472
1450	if (*slp == -1) /* break line continuation */	1473	if (*slp == -1) /* break line continuation */
1451	*slp = TermWin.ncol;	1474	*slp = TermWin.ncol;
		1475
1452	*slp -= count;	1476	*slp -= count;
1453	MAX_IT (*slp, 0);	1477	MAX_IT (*slp, 0);
		1478
1454	if (selection.op && current_screen == selection.screen	1479	if (selection.op && current_screen == selection.screen
1455	&& ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))	1480	&& ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
1456	{	1481	{
1457	if (selection.end.row != screen.cur.row	1482	if (selection.end.row != screen.cur.row
1458	|| (screen.cur.col >= selection.beg.col - count)	1483	|| (screen.cur.col >= selection.beg.col - count)
…		…
1464	selection.beg.col -= count;	1489	selection.beg.col -= count;
1465	selection.mark.col -= count; /* XXX: yes? */	1490	selection.mark.col -= count; /* XXX: yes? */
1466	selection.end.col -= count;	1491	selection.end.col -= count;
1467	}	1492	}
1468	}	1493	}
		1494
1469	break;	1495	break;
1470	}	1496	}
1471	}	1497	}
1472		1498
1473	/* ------------------------------------------------------------------------- */	1499	/* ------------------------------------------------------------------------- */
…		…
1478	void	1504	void
1479	rxvt_term::scr_scroll_region (int top, int bot)	1505	rxvt_term::scr_scroll_region (int top, int bot)
1480	{	1506	{
1481	MAX_IT (top, 0);	1507	MAX_IT (top, 0);
1482	MIN_IT (bot, (int)TermWin.nrow - 1);	1508	MIN_IT (bot, (int)TermWin.nrow - 1);
		1509
1483	if (top > bot)	1510	if (top > bot)
1484	return;	1511	return;
		1512
1485	screen.tscroll = top;	1513	screen.tscroll = top;
1486	screen.bscroll = bot;	1514	screen.bscroll = bot;
1487	scr_gotorc (0, 0, 0);	1515	scr_gotorc (0, 0, 0);
1488	}	1516	}
1489		1517
…		…
1495	*/	1523	*/
1496	void	1524	void
1497	rxvt_term::scr_cursor_visible (int mode)	1525	rxvt_term::scr_cursor_visible (int mode)
1498	{	1526	{
1499	want_refresh = 1;	1527	want_refresh = 1;
		1528
1500	if (mode)	1529	if (mode)
1501	screen.flags |= Screen_VisibleCursor;	1530	screen.flags |= Screen_VisibleCursor;
1502	else	1531	else
1503	screen.flags &= ~Screen_VisibleCursor;	1532	screen.flags &= ~Screen_VisibleCursor;
1504	}	1533	}
…		…
1719		1748
1720	if (drawn_text == NULL) /* sanity check */	1749	if (drawn_text == NULL) /* sanity check */
1721	return;	1750	return;
1722		1751
1723	#ifdef DEBUG_STRICT	1752	#ifdef DEBUG_STRICT
1724	x = max (x, (int)TermWin.int_bwidth);	1753	x = max (x, 0);
1725	x = min (x, (int)TermWin.width);	1754	x = min (x, (int)TermWin.width);
1726	y = max (y, (int)TermWin.int_bwidth);	1755	y = max (y, 0);
1727	y = min (y, (int)TermWin.height);	1756	y = min (y, (int)TermWin.height);
1728	#endif	1757	#endif
1729		1758
1730	/* round down */	1759	/* round down */
1731	rc[PART_BEG].col = Pixel2Col (x);	1760	rc[PART_BEG].col = Pixel2Col (x);
…		…
1742	}	1771	}
1743		1772
1744	D_SCREEN ((stderr, "rxvt_scr_expose (x:%d, y:%d, w:%d, h:%d) area (c:%d,r:%d)- (c:%d,r:%d)", x, y, width, height, rc[PART_BEG].col, rc[PART_BEG].row, rc[PART_END].col, rc[PART_END].row));	1773	D_SCREEN ((stderr, "rxvt_scr_expose (x:%d, y:%d, w:%d, h:%d) area (c:%d,r:%d)- (c:%d,r:%d)", x, y, width, height, rc[PART_BEG].col, rc[PART_BEG].row, rc[PART_END].col, rc[PART_END].row));
1745		1774
1746	for (i = rc[PART_BEG].row; i <= rc[PART_END].row; i++)	1775	for (i = rc[PART_BEG].row; i <= rc[PART_END].row; i++)
1747	fill_text (& (drawn_text[i][rc[PART_BEG].col]), 0,	1776	fill_text (&drawn_text[i][rc[PART_BEG].col], 0, rc[PART_END].col - rc[PART_BEG].col + 1);
1748	(rc[PART_END].col - rc[PART_BEG].col + 1));
1749		1777
1750	if (refresh)	1778	if (refresh)
1751	scr_refresh (SLOW_REFRESH | REFRESH_BOUNDS);	1779	scr_refresh (SLOW_REFRESH | REFRESH_BOUNDS);
1752	}	1780	}
1753		1781
…		…
1820	if (TermWin.view_start != oldviewstart)	1848	if (TermWin.view_start != oldviewstart)
1821	{	1849	{
1822	want_refresh = 1;	1850	want_refresh = 1;
1823	num_scr -= (TermWin.view_start - oldviewstart);	1851	num_scr -= (TermWin.view_start - oldviewstart);
1824	}	1852	}
		1853
1825	return (int) (TermWin.view_start - oldviewstart);	1854	return (int) (TermWin.view_start - oldviewstart);
1826	}	1855	}
1827		1856
1828	/* ------------------------------------------------------------------------- */	1857	/* ------------------------------------------------------------------------- */
1829	void	1858	void
…		…
1947		1976
1948	/*	1977	/*
1949	* C: set the cursor character (s)	1978	* C: set the cursor character (s)
1950	*/	1979	*/
1951	{	1980	{
1952	unsigned char setoldcursor;	1981	unsigned char setoldcursor;
1953	rend_t ccol1, /* Cursor colour */	1982	rend_t ccol1, /* Cursor colour */
1954	ccol2; /* Cursor colour2 */	1983	ccol2; /* Cursor colour2 */
1955		1984
1956	showcursor = (screen.flags & Screen_VisibleCursor);	1985	showcursor = (screen.flags & Screen_VisibleCursor);
1957	#ifdef CURSOR_BLINK	1986	#ifdef CURSOR_BLINK
1958	if (hidden_cursor)	1987	if (hidden_cursor)
1959	showcursor = 0;	1988	showcursor = 0;
1960	#endif	1989	#endif
1961		1990
1962	if (showcursor)	1991	if (showcursor)
1963	{	1992	{
1964	srp = & (screen.rend[screen.cur.row + TermWin.saveLines]	1993	srp = &(screen.rend[screen.cur.row + TermWin.saveLines][screen.cur.col]);
1965	[screen.cur.col]);
1966		1994
1967	if (showcursor && TermWin.focus)	1995	if (showcursor && TermWin.focus)
1968	{	1996	{
1969	*srp ^= RS_RVid;	1997	*srp ^= RS_RVid;
1970	#ifndef NO_CURSORCOLOR	1998	#ifndef NO_CURSORCOLOR
…		…
1998	if (screen.cur.row + TermWin.view_start != ocrow	2026	if (screen.cur.row + TermWin.view_start != ocrow
1999	|| screen.cur.col != oldcursor.col)	2027	|| screen.cur.col != oldcursor.col)
2000	{	2028	{
2001	if (ocrow < TermWin.nrow	2029	if (ocrow < TermWin.nrow
2002	&& oldcursor.col < TermWin.ncol)	2030	&& oldcursor.col < TermWin.ncol)
2003	{
2004	drawn_rend[ocrow][oldcursor.col] ^= (RS_RVid | RS_Uline);	2031	drawn_rend[ocrow][oldcursor.col] ^= (RS_RVid | RS_Uline);
2005	}	2032
2006	if (TermWin.focus || !showcursor)	2033	if (TermWin.focus || !showcursor)
2007	oldcursor.row = -1;	2034	oldcursor.row = -1;
2008	else	2035	else
2009	setoldcursor = 1;	2036	setoldcursor = 1;
2010	}	2037	}
2011	}	2038	}
2012	else if (!TermWin.focus)	2039	else if (!TermWin.focus)
2013	setoldcursor = 1;	2040	setoldcursor = 1;
		2041
2014	if (setoldcursor)	2042	if (setoldcursor)
2015	{	2043	{
2016	if (screen.cur.row + TermWin.view_start >= TermWin.nrow)	2044	if (screen.cur.row + TermWin.view_start >= TermWin.nrow)
2017	oldcursor.row = -1;	2045	oldcursor.row = -1;
2018	else	2046	else
…		…
2030	*/	2058	*/
2031	i = num_scr;	2059	i = num_scr;
2032	if (refresh_type == FAST_REFRESH && num_scr_allow && i	2060	if (refresh_type == FAST_REFRESH && num_scr_allow && i
2033	&& abs (i) < TermWin.nrow && !must_clear)	2061	&& abs (i) < TermWin.nrow && !must_clear)
2034	{	2062	{
2035	int16_t nits;	2063	int16_t nits;
2036	int j;	2064	int j;
2037	rend_t *drp2;	2065	rend_t *drp2;
2038	text_t *dtp2;	2066	text_t *dtp2;
2039	int len, wlen;	2067	int len, wlen;
2040		2068
2041	j = TermWin.nrow;	2069	j = TermWin.nrow;
2042	wlen = len = -1;	2070	wlen = len = -1;
2043	row = i > 0 ? 0 : j - 1;	2071	row = i > 0 ? 0 : j - 1;
2044	for (; j-- >= 0; row += (i > 0 ? 1 : -1))	2072	for (; j-- >= 0; row += (i > 0 ? 1 : -1))
…		…
2179	rend = GET_ATTR (rend);	2207	rend = GET_ATTR (rend);
2180		2208
2181	rvid = !!(rend & RS_RVid);	2209	rvid = !!(rend & RS_RVid);
2182		2210
2183	#ifndef NO_BOLD_UNDERLINE_REVERSE	2211	#ifndef NO_BOLD_UNDERLINE_REVERSE
2184	if (rend & RS_Bold && fore == Color_fg)	2212	if (rend & RS_Bold && fore == Color_fg && !(Options & Opt_realBold))
2185	{	2213	{
2186	if (ISSET_PIXCOLOR (Color_BD))	2214	if (ISSET_PIXCOLOR (Color_BD))
2187	fore = Color_BD;	2215	fore = Color_BD;
2188	else	2216	else
2189	rvid = !rvid;	2217	rvid = !rvid;
…		…
2295	scr_reverse_selection ();	2323	scr_reverse_selection ();
2296		2324
2297	/*	2325	/*
2298	* I: other general cleanup	2326	* I: other general cleanup
2299	*/	2327	*/
		2328	#if 0
2300	if (clearfirst && TermWin.int_bwidth)	2329	if (clearfirst && TermWin.int_bwidth)
2301	/*	2330	/*
2302	* clear the whole screen height, note that width == 0 is treated	2331	* clear the whole screen height, note that width == 0 is treated
2303	* specially by XClearArea	2332	* specially by XClearArea
2304	*/	2333	*/
…		…
2313	*/	2342	*/
2314	XClearArea (display->display, TermWin.vt,	2343	XClearArea (display->display, TermWin.vt,
2315	TermWin.width + TermWin.int_bwidth, 0,	2344	TermWin.width + TermWin.int_bwidth, 0,
2316	(unsigned int)TermWin.int_bwidth,	2345	(unsigned int)TermWin.int_bwidth,
2317	(unsigned int)TermWin_TotalHeight (), False);	2346	(unsigned int)TermWin_TotalHeight (), False);
		2347	#endif
2318		2348
2319	if (refresh_type & SMOOTH_REFRESH)	2349	if (refresh_type & SMOOTH_REFRESH)
2320	XSync (display->display, False);	2350	XSync (display->display, False);
2321		2351
2322	num_scr = 0;	2352	num_scr = 0;
…		…
2496	{	2526	{
2497	n = min (len - i, PROP_SIZE);	2527	n = min (len - i, PROP_SIZE);
2498	MEMCPY (ds, data + i, n);	2528	MEMCPY (ds, data + i, n);
2499		2529
2500	for (j = 0; j < n; j++)	2530	for (j = 0; j < n; j++)
2501	if (ds[j] == '\n')	2531	if (ds[j] == C0_LF)
2502	ds[j] = '\r';	2532	ds[j] = C0_CR;
2503		2533
2504	tt_write (ds, (int)n);	2534	tt_write (ds, (int)n);
2505	}	2535	}
2506		2536
2507	free (ds);	2537	free (ds);
…		…
2588		2618
2589	nread += ct.nitems;	2619	nread += ct.nitems;
2590		2620
2591	char **cl;	2621	char **cl;
2592	int cr;	2622	int cr;
2593	if (XmbTextPropertyToTextList (display->display, &ct, &cl,	2623	if (XmbTextPropertyToTextList (display->display, &ct, &cl, &cr) >= 0 && cl)
2594	&cr) >= 0 && cl)
2595	{	2624	{
2596	for (int i = 0; i < cr; i++)	2625	for (int i = 0; i < cr; i++)
2597	paste ((unsigned char *)cl[i], STRLEN (cl[i]));	2626	paste ((unsigned char *)cl[i], STRLEN (cl[i]));
2598		2627
2599	XFreeStringList (cl);	2628	XFreeStringList (cl);
…		…
2620	void	2649	void
2621	rxvt_term::incr_cb (time_watcher &w)	2650	rxvt_term::incr_cb (time_watcher &w)
2622	{	2651	{
2623	selection_wait = Sel_none;	2652	selection_wait = Sel_none;
2624		2653
2625	rxvt_print_error ("data loss: timeout on INCR selection paste");	2654	rxvt_warn ("data loss: timeout on INCR selection paste, ignoring.\n");
2626	}	2655	}
2627		2656
2628	/*	2657	/*
2629	* INCR support originally provided by Paul Sheer <psheer@obsidian.co.za>	2658	* INCR support originally provided by Paul Sheer <psheer@obsidian.co.za>
2630	*/	2659	*/
…		…
2709	{	2738	{
2710	int i;	2739	int i;
2711		2740
2712	selection_request_time = tm;	2741	selection_request_time = tm;
2713	selection_wait = Sel_normal;	2742	selection_wait = Sel_normal;
		2743
2714	for (i = Sel_Primary; i <= Sel_Clipboard; i++)	2744	for (i = Sel_Primary; i <= Sel_Clipboard; i++)
2715	{	2745	{
2716	#if X_HAVE_UTF8_STRING	2746	#if X_HAVE_UTF8_STRING
2717	selection_type = Sel_UTF8String;	2747	selection_type = Sel_UTF8String;
2718	if (selection_request_other (xa[XA_UTF8_STRING], i))	2748	if (selection_request_other (xa[XA_UTF8_STRING], i))
…		…
2772	want_refresh = 1;	2802	want_refresh = 1;
2773	free (selection.text);	2803	free (selection.text);
2774	selection.text = NULL;	2804	selection.text = NULL;
2775	selection.len = 0;	2805	selection.len = 0;
2776	CLEAR_SELECTION ();	2806	CLEAR_SELECTION ();
		2807
		2808	if (display->selection_owner == this)
		2809	display->selection_owner = 0;
2777	}	2810	}
2778		2811
2779	/* ------------------------------------------------------------------------- */	2812	/* ------------------------------------------------------------------------- */
2780	/*	2813	/*
2781	* Copy a selection into the cut buffer	2814	* Copy a selection into the cut buffer
…		…
2854	else	2887	else
2855	new_selection_text[ofs++] = *t++;	2888	new_selection_text[ofs++] = *t++;
2856	}	2889	}
2857		2890
2858	if (screen.tlen[row] != -1 && row != end_row)	2891	if (screen.tlen[row] != -1 && row != end_row)
2859	new_selection_text[ofs++] = L'\n';	2892	new_selection_text[ofs++] = C0_LF;
2860	}	2893	}
2861		2894
2862	#ifndef NO_OLD_SELECTION
2863	if (selection_style == OLD_SELECT)
2864	if (end_col == TermWin.ncol)
2865	new_selection_text[ofs++] = L'\n';
2866	#endif
2867	#ifndef NO_NEW_SELECTION
2868	if (selection_style != OLD_SELECT)
2869	if (end_col != selection.end.col)	2895	if (end_col != selection.end.col)
2870	new_selection_text[ofs++] = L'\n';	2896	new_selection_text[ofs++] = C0_LF;
2871	#endif	2897
2872	new_selection_text[ofs] = 0;	2898	new_selection_text[ofs] = 0;
2873		2899
2874	if (ofs == 0)	2900	if (ofs == 0)
2875	{	2901	{
2876	free (new_selection_text);	2902	free (new_selection_text);
…		…
2885		2911
2886	XSetSelectionOwner (display->display, XA_PRIMARY, TermWin.vt, tm);	2912	XSetSelectionOwner (display->display, XA_PRIMARY, TermWin.vt, tm);
2887	if (XGetSelectionOwner (display->display, XA_PRIMARY) == TermWin.vt)	2913	if (XGetSelectionOwner (display->display, XA_PRIMARY) == TermWin.vt)
2888	display->set_selection_owner (this);	2914	display->set_selection_owner (this);
2889	else	2915	else
2890	rxvt_print_error ("can't get primary selection");	2916	rxvt_warn ("can't get primary selection, ignoring.\n");
2891		2917
2892	#if 0	2918	#if 0
2893	XTextProperty ct;	2919	XTextProperty ct;
2894		2920
2895	if (XwcTextListToTextProperty (display->display, &selection.text, 1, XStringStyle, &ct) >= 0)	2921	if (XwcTextListToTextProperty (display->display, &selection.text, 1, XStringStyle, &ct) >= 0)
…		…
2935	rxvt_term::selection_start_colrow (int col, int row)	2961	rxvt_term::selection_start_colrow (int col, int row)
2936	{	2962	{
2937	want_refresh = 1;	2963	want_refresh = 1;
2938	selection.mark.col = col;	2964	selection.mark.col = col;
2939	selection.mark.row = row - TermWin.view_start;	2965	selection.mark.row = row - TermWin.view_start;
		2966
2940	MAX_IT (selection.mark.row, - (int32_t)TermWin.nscrolled);	2967	MAX_IT (selection.mark.row, - (int32_t)TermWin.nscrolled);
2941	MIN_IT (selection.mark.row, (int32_t)TermWin.nrow - 1);	2968	MIN_IT (selection.mark.row, (int32_t)TermWin.nrow - 1);
2942	MAX_IT (selection.mark.col, 0);	2969	MAX_IT (selection.mark.col, 0);
2943	MIN_IT (selection.mark.col, (int32_t)TermWin.ncol - 1);	2970	MIN_IT (selection.mark.col, (int32_t)TermWin.ncol - 1);
2944		2971
		2972	while (selection.mark.col > 0
		2973	&& screen.text[selection.mark.row + TermWin.saveLines][selection.mark.col] == NOCHAR)
		2974	--selection.mark.col;
		2975
2945	if (selection.op)	2976	if (selection.op)
2946	{ /* clear the old selection */	2977	{ /* clear the old selection */
2947	selection.beg.row = selection.end.row = selection.mark.row;	2978	selection.beg.row = selection.end.row = selection.mark.row;
2948	selection.beg.col = selection.end.col = selection.mark.col;	2979	selection.beg.col = selection.end.col = selection.mark.col;
2949	}	2980	}
		2981
2950	selection.op = SELECTION_INIT;	2982	selection.op = SELECTION_INIT;
2951	selection.screen = current_screen;	2983	selection.screen = current_screen;
2952	}	2984	}
2953		2985
2954	/* ------------------------------------------------------------------------- */	2986	/* ------------------------------------------------------------------------- */
…		…
2956	* Word select: select text for 2 clicks	2988	* Word select: select text for 2 clicks
2957	* We now only find out the boundary in one direction	2989	* We now only find out the boundary in one direction
2958	*/	2990	*/
2959		2991
2960	/* what do we want: spaces/tabs are delimiters or cutchars or non-cutchars */	2992	/* what do we want: spaces/tabs are delimiters or cutchars or non-cutchars */
2961	#define DELIMIT_TEXT(x) \	2993	#define DELIMIT_TEXT(x) \
2962	(((x) == ' ' || (x) == '\t') ? 2 : (STRCHR (rs[Rs_cutchars], (x)) != NULL))	2994	(unicode::is_space (x) ? 2 : (x) <= 0xff && !!STRCHR (rs[Rs_cutchars], (x)))
2963	#define DELIMIT_REND(x) 1	2995	#define DELIMIT_REND(x) 1
2964		2996
2965	void	2997	void
2966	rxvt_term::selection_delimit_word (enum page_dirn dirn, const row_col_t *mark, row_col_t *ret)	2998	rxvt_term::selection_delimit_word (enum page_dirn dirn, const row_col_t *mark, row_col_t *ret)
2967	{	2999	{
2968	int col, row, dirnadd, tcol, trow, w1, w2;	3000	int col, row, dirnadd, tcol, trow, w1, w2;
2969	row_col_t bound;	3001	row_col_t bound;
2970	text_t *stp;	3002	text_t *stp;
2971	rend_t *srp;	3003	rend_t *srp;
2972		3004
2973	if (dirn == UP)	3005	if (dirn == UP)
2974	{	3006	{
2975	bound.row = TermWin.saveLines - TermWin.nscrolled - 1;	3007	bound.row = TermWin.saveLines - TermWin.nscrolled - 1;
2976	bound.col = 0;	3008	bound.col = 0;
…		…
2980	{	3012	{
2981	bound.row = TermWin.saveLines + TermWin.nrow;	3013	bound.row = TermWin.saveLines + TermWin.nrow;
2982	bound.col = TermWin.ncol - 1;	3014	bound.col = TermWin.ncol - 1;
2983	dirnadd = 1;	3015	dirnadd = 1;
2984	}	3016	}
		3017
2985	row = mark->row + TermWin.saveLines;	3018	row = mark->row + TermWin.saveLines;
2986	col = mark->col;	3019	col = mark->col;
2987	MAX_IT (col, 0);	3020	MAX_IT (col, 0);
2988	/* find the edge of a word */	3021	/* find the edge of a word */
2989	stp = & (screen.text[row][col]);	3022	stp = & (screen.text[row][col]);
2990	w1 = DELIMIT_TEXT (*stp);	3023	w1 = DELIMIT_TEXT (*stp);
2991		3024
2992	if (selection_style != NEW_SELECT)
2993	{
2994	if (w1 == 1)
2995	{
2996	stp += dirnadd;
2997	if (DELIMIT_TEXT (*stp) == 1)
2998	goto Old_Word_Selection_You_Die;
2999	col += dirnadd;
3000	}
3001	w1 = 0;
3002	}
3003	srp = (&screen.rend[row][col]);	3025	srp = (&screen.rend[row][col]);
3004	w2 = DELIMIT_REND (*srp);	3026	w2 = DELIMIT_REND (*srp);
3005		3027
3006	for (;;)	3028	for (;;)
3007	{	3029	{
3008	for (; col != bound.col; col += dirnadd)	3030	for (; col != bound.col; col += dirnadd)
3009	{	3031	{
3010	stp += dirnadd;	3032	stp += dirnadd;
		3033	srp += dirnadd;
		3034
		3035	if (*stp == NOCHAR)
		3036	continue;
		3037
3011	if (DELIMIT_TEXT (*stp) != w1)	3038	if (DELIMIT_TEXT (*stp) != w1)
3012	break;	3039	break;
3013	srp += dirnadd;
3014	if (DELIMIT_REND (*srp) != w2)	3040	if (DELIMIT_REND (*srp) != w2)
3015	break;	3041	break;
3016	}	3042	}
		3043
3017	if ((col == bound.col) && (row != bound.row))	3044	if ((col == bound.col) && (row != bound.row))
3018	{	3045	{
3019	if (screen.tlen[ (row - (dirn == UP ? 1 : 0))] == -1)	3046	if (screen.tlen[ (row - (dirn == UP ? 1 : 0))] == -1)
3020	{	3047	{
3021	trow = row + dirnadd;	3048	trow = row + dirnadd;
3022	tcol = dirn == UP ? TermWin.ncol - 1 : 0;	3049	tcol = dirn == UP ? TermWin.ncol - 1 : 0;
		3050
3023	if (screen.text[trow] == NULL)	3051	if (screen.text[trow] == NULL)
3024	break;	3052	break;
		3053
3025	stp = & (screen.text[trow][tcol]);	3054	stp = & (screen.text[trow][tcol]);
3026	srp = & (screen.rend[trow][tcol]);	3055	srp = & (screen.rend[trow][tcol]);
		3056
3027	if (DELIMIT_TEXT (*stp) != w1 || DELIMIT_REND (*srp) != w2)	3057	if (DELIMIT_TEXT (*stp) != w1 || DELIMIT_REND (*srp) != w2)
3028	break;	3058	break;
		3059
3029	row = trow;	3060	row = trow;
3030	col = tcol;	3061	col = tcol;
3031	continue;	3062	continue;
3032	}	3063	}
3033	}	3064	}
3034	break;	3065	break;
3035	}	3066	}
		3067
3036	Old_Word_Selection_You_Die:	3068	Old_Word_Selection_You_Die:
3037	D_SELECT ((stderr, "rxvt_selection_delimit_word (%s,...) @ (r:%3d, c:%3d) has boundary (r:%3d, c:%3d)", (dirn == UP ? "up " : "down"), mark->row, mark->col, row - TermWin.saveLines, col));	3069	D_SELECT ((stderr, "rxvt_selection_delimit_word (%s,...) @ (r:%3d, c:%3d) has boundary (r:%3d, c:%3d)", (dirn == UP ? "up " : "down"), mark->row, mark->col, row - TermWin.saveLines, col));
3038		3070
3039	if (dirn == DN)	3071	if (dirn == DN)
3040	col++; /* put us on one past the end */	3072	col++; /* put us on one past the end */
…		…
3062	MAX_IT (row, 0);	3094	MAX_IT (row, 0);
3063	MIN_IT (row, (int)TermWin.nrow - 1);	3095	MIN_IT (row, (int)TermWin.nrow - 1);
3064	MAX_IT (col, 0);	3096	MAX_IT (col, 0);
3065	MIN_IT (col, (int)TermWin.ncol);	3097	MIN_IT (col, (int)TermWin.ncol);
3066		3098
3067	#ifndef NO_NEW_SELECTION
3068	/*	3099	/*
3069	* If we're selecting characters (single click) then we must check first	3100	* If we're selecting characters (single click) then we must check first
3070	* if we are at the same place as the original mark. If we are then	3101	* if we are at the same place as the original mark. If we are then
3071	* select nothing. Otherwise, if we're to the right of the mark, you have to	3102	* select nothing. Otherwise, if we're to the right of the mark, you have to
3072	* be _past_ a character for it to be selected.	3103	* be _past_ a character for it to be selected.
3073	*/	3104	*/
3074	if (selection_style != OLD_SELECT)
3075	{
3076	if (((selection.clicks % 3) == 1) && !flag	3105	if (((selection.clicks % 3) == 1) && !flag
3077	&& (col == selection.mark.col	3106	&& (col == selection.mark.col
3078	&& (row == selection.mark.row + TermWin.view_start)))	3107	&& (row == selection.mark.row + TermWin.view_start)))
3079	{	3108	{
3080	/* select nothing */	3109	/* select nothing */
3081	selection.beg.row = selection.end.row = 0;	3110	selection.beg.row = selection.end.row = 0;
3082	selection.beg.col = selection.end.col = 0;	3111	selection.beg.col = selection.end.col = 0;
3083	selection.clicks = 4;	3112	selection.clicks = 4;
3084	want_refresh = 1;	3113	want_refresh = 1;
3085	D_SELECT ((stderr, "rxvt_selection_extend () selection.clicks = 4"));	3114	D_SELECT ((stderr, "rxvt_selection_extend () selection.clicks = 4"));
3086	return;	3115	return;
3087	}
3088	}	3116	}
3089	#endif	3117
3090	if (selection.clicks == 4)	3118	if (selection.clicks == 4)
3091	selection.clicks = 1;	3119	selection.clicks = 1;
3092		3120
3093	selection_extend_colrow (col, row, !!flag, /* ? button 3 */	3121	selection_extend_colrow (col, row, !!flag, /* ? button 3 */
3094	flag == 1 ? 1 : 0, /* ? button press */	3122	flag == 1 ? 1 : 0, /* ? button press */
…		…
3100	* Extend the selection to the specified col/row	3128	* Extend the selection to the specified col/row
3101	*/	3129	*/
3102	void	3130	void
3103	rxvt_term::selection_extend_colrow (int32_t col, int32_t row, int button3, int buttonpress, int clickchange)	3131	rxvt_term::selection_extend_colrow (int32_t col, int32_t row, int button3, int buttonpress, int clickchange)
3104	{	3132	{
3105	int16_t ncol = TermWin.ncol;	3133	int16_t ncol = TermWin.ncol;
3106	int end_col;	3134	int end_col;
3107	row_col_t pos;	3135	row_col_t pos;
3108	enum {	3136	enum {
3109	LEFT, RIGHT	3137	LEFT, RIGHT
3110	} closeto = RIGHT;	3138	} closeto = RIGHT;
3111		3139
3112	D_SELECT ((stderr, "rxvt_selection_extend_colrow (c:%d, r:%d, %d, %d) clicks:%d, op:%d", col, row, button3, buttonpress, selection.clicks, selection.op));	3140	D_SELECT ((stderr, "rxvt_selection_extend_colrow (c:%d, r:%d, %d, %d) clicks:%d, op:%d", col, row, button3, buttonpress, selection.clicks, selection.op));
…		…
3148	pos.col = col;	3176	pos.col = col;
3149	pos.row = row;	3177	pos.row = row;
3150		3178
3151	pos.row -= TermWin.view_start; /* adjust for scroll */	3179	pos.row -= TermWin.view_start; /* adjust for scroll */
3152		3180
3153	#ifndef NO_OLD_SELECTION
3154	/*
3155	* This mimics some of the selection behaviour of version 2.20 and before.
3156	* There are no ``selection modes'', button3 is always character extension.
3157	* Note: button3 drag is always available, c.f. v2.20
3158	* Selection always terminates (left or right as appropriate) at the mark.
3159	*/
3160	if (selection_style == OLD_SELECT)
3161	{
3162	if (selection.clicks == 1 || button3)
3163	{
3164	if (hate_those_clicks)
3165	{
3166	hate_those_clicks = 0;
3167	if (selection.clicks == 1)
3168	{
3169	selection.beg.row = selection.mark.row;
3170	selection.beg.col = selection.mark.col;
3171	}
3172	else
3173	{
3174	selection.mark.row = selection.beg.row;
3175	selection.mark.col = selection.beg.col;
3176	}
3177	}
3178	if (ROWCOL_IS_BEFORE (pos, selection.mark))
3179	{
3180	selection.end.row = selection.mark.row;
3181	selection.end.col = selection.mark.col + 1;
3182	selection.beg.row = pos.row;
3183	selection.beg.col = pos.col;
3184	}
3185	else
3186	{
3187	selection.beg.row = selection.mark.row;
3188	selection.beg.col = selection.mark.col;
3189	selection.end.row = pos.row;
3190	selection.end.col = pos.col + 1;
3191	}
3192	}
3193	else if (selection.clicks == 2)
3194	{
3195	selection_delimit_word (UP, & (selection.mark),
3196	& (selection.beg));
3197	selection_delimit_word (DN, & (selection.mark),
3198	& (selection.end));
3199	hate_those_clicks = 1;
3200	}
3201	else if (selection.clicks == 3)
3202	{
3203	selection.beg.row = selection.end.row = selection.mark.row;
3204	selection.beg.col = 0;
3205	selection.end.col = ncol;
3206	hate_those_clicks = 1;
3207	}
3208	D_SELECT ((stderr, "rxvt_selection_extend_colrow () EXIT b: (r:%d,c:%d) m: (r:%d,c:%d), e: (r:%d,c:%d)", selection.beg.row, selection.beg.col, selection.mark.row, selection.mark.col, selection.end.row, selection.end.col));
3209	return;
3210	}
3211	#endif /* ! NO_OLD_SELECTION */
3212	#ifndef NO_NEW_SELECTION
3213	/* selection_style must not be OLD_SELECT to get here */
3214	/*	3181	/*
3215	* This is mainly xterm style selection with a couple of differences, mainly	3182	* This is mainly xterm style selection with a couple of differences, mainly
3216	* in the way button3 drag extension works.	3183	* in the way button3 drag extension works.
3217	* We're either doing: button1 drag; button3 press; or button3 drag	3184	* We're either doing: button1 drag; button3 press; or button3 drag
3218	* a) button1 drag : select around a midpoint/word/line - that point/word/line	3185	* a) button1 drag : select around a midpoint/word/line - that point/word/line
…		…
3223	* a point/word/line which is either the start or end of the selection	3190	* a point/word/line which is either the start or end of the selection
3224	* and it was decided by whichever point/word/line was `fixed' at the	3191	* and it was decided by whichever point/word/line was `fixed' at the
3225	* time of the most recent button3 press	3192	* time of the most recent button3 press
3226	*/	3193	*/
3227	if (button3 && buttonpress)	3194	if (button3 && buttonpress)
3228	{ /* button3 press */	3195	{ /* button3 press */
3229	/*	3196	/*
3230	* first determine which edge of the selection we are closest to	3197	* first determine which edge of the selection we are closest to
3231	*/	3198	*/
3232	if (ROWCOL_IS_BEFORE (pos, selection.beg)	3199	if (ROWCOL_IS_BEFORE (pos, selection.beg)
3233	|| (!ROWCOL_IS_AFTER (pos, selection.end)	3200	|| (!ROWCOL_IS_AFTER (pos, selection.end)
3234	&& (((pos.col - selection.beg.col)	3201	&& (((pos.col - selection.beg.col)
3235	+ ((pos.row - selection.beg.row) * ncol))	3202	+ ((pos.row - selection.beg.row) * ncol))
3236	< ((selection.end.col - pos.col)	3203	< ((selection.end.col - pos.col)
3237	+ ((selection.end.row - pos.row) * ncol)))))	3204	+ ((selection.end.row - pos.row) * ncol)))))
3238	closeto = LEFT;	3205	closeto = LEFT;
		3206
3239	if (closeto == LEFT)	3207	if (closeto == LEFT)
3240	{	3208	{
3241	selection.beg.row = pos.row;	3209	selection.beg.row = pos.row;
3242	selection.beg.col = pos.col;	3210	selection.beg.col = pos.col;
3243	selection.mark.row = selection.end.row;	3211	selection.mark.row = selection.end.row;
3244	selection.mark.col = selection.end.col	3212	selection.mark.col = selection.end.col - (selection.clicks == 2);
3245	- (selection.clicks == 2);
3246	}	3213	}
3247	else	3214	else
3248	{	3215	{
3249	selection.end.row = pos.row;	3216	selection.end.row = pos.row;
3250	selection.end.col = pos.col;	3217	selection.end.col = pos.col;
3251	selection.mark.row = selection.beg.row;	3218	selection.mark.row = selection.beg.row;
3252	selection.mark.col = selection.beg.col;	3219	selection.mark.col = selection.beg.col;
3253	}	3220	}
3254	}	3221	}
3255	else	3222	else
3256	{ /* button1 drag or button3 drag */	3223	{ /* button1 drag or button3 drag */
3257	if (ROWCOL_IS_AFTER (selection.mark, pos))	3224	if (ROWCOL_IS_AFTER (selection.mark, pos))
3258	{	3225	{
3259	if ((selection.mark.row == selection.end.row)	3226	if ((selection.mark.row == selection.end.row)
3260	&& (selection.mark.col == selection.end.col)	3227	&& (selection.mark.col == selection.end.col)
3261	&& clickchange && selection.clicks == 2)	3228	&& clickchange && selection.clicks == 2)
3262	selection.mark.col--;	3229	selection.mark.col--;
		3230
3263	selection.beg.row = pos.row;	3231	selection.beg.row = pos.row;
3264	selection.beg.col = pos.col;	3232	selection.beg.col = pos.col;
3265	selection.end.row = selection.mark.row;	3233	selection.end.row = selection.mark.row;
3266	selection.end.col = selection.mark.col	3234	selection.end.col = selection.mark.col + (selection.clicks == 2);
3267	+ (selection.clicks == 2);
3268	}	3235	}
3269	else	3236	else
3270	{	3237	{
3271	selection.beg.row = selection.mark.row;	3238	selection.beg.row = selection.mark.row;
3272	selection.beg.col = selection.mark.col;	3239	selection.beg.col = selection.mark.col;
…		…
3276	}	3243	}
3277		3244
3278	if (selection.clicks == 1)	3245	if (selection.clicks == 1)
3279	{	3246	{
3280	end_col = screen.tlen[selection.beg.row + TermWin.saveLines];	3247	end_col = screen.tlen[selection.beg.row + TermWin.saveLines];
		3248
3281	if (end_col != -1 && selection.beg.col > end_col)	3249	if (end_col != -1 && selection.beg.col > end_col)
3282	{	3250	{
3283	#if 1	3251	#if 1
3284	selection.beg.col = ncol;	3252	selection.beg.col = ncol;
3285	#else	3253	#else
3286	if (selection.beg.row != selection.end.row)	3254	if (selection.beg.row != selection.end.row)
3287	selection.beg.col = ncol;	3255	selection.beg.col = ncol;
3288	else	3256	else
3289	selection.beg.col = selection.mark.col;	3257	selection.beg.col = selection.mark.col;
3290	#endif	3258	#endif
3291
3292	}	3259	}
		3260
3293	end_col = screen.tlen[selection.end.row + TermWin.saveLines];	3261	end_col = screen.tlen[selection.end.row + TermWin.saveLines];
		3262
3294	if (end_col != -1 && selection.end.col > end_col)	3263	if (end_col != -1 && selection.end.col > end_col)
3295	selection.end.col = ncol;	3264	selection.end.col = ncol;
3296
3297	}	3265	}
3298	else if (selection.clicks == 2)	3266	else if (selection.clicks == 2)
3299	{	3267	{
3300	if (ROWCOL_IS_AFTER (selection.end, selection.beg))	3268	if (ROWCOL_IS_AFTER (selection.end, selection.beg))
3301	selection.end.col--;	3269	selection.end.col--;
		3270
3302	selection_delimit_word (UP, & (selection.beg),	3271	selection_delimit_word (UP, & (selection.beg), & (selection.beg));
3303	& (selection.beg));
3304	selection_delimit_word (DN, & (selection.end),	3272	selection_delimit_word (DN, & (selection.end), & (selection.end));
3305	& (selection.end));
3306	}	3273	}
3307	else if (selection.clicks == 3)	3274	else if (selection.clicks == 3)
3308	{	3275	{
3309	#ifndef NO_FRILLS	3276	#ifndef NO_FRILLS
3310	if ((Options & Opt_tripleclickwords))	3277	if ((Options & Opt_tripleclickwords))
3311	{	3278	{
3312	int end_row;	3279	int end_row;
3313		3280
3314	selection_delimit_word (UP, & (selection.beg),	3281	selection_delimit_word (UP, & (selection.beg), & (selection.beg));
3315	& (selection.beg));
3316	end_row = screen.tlen[selection.mark.row	3282	end_row = screen.tlen[selection.mark.row + TermWin.saveLines];
3317	+ TermWin.saveLines];	3283
3318	for (end_row = selection.mark.row; end_row < TermWin.nrow;	3284	for (end_row = selection.mark.row; end_row < TermWin.nrow; end_row++)
3319	end_row++)
3320	{	3285	{
3321	end_col = screen.tlen[end_row + TermWin.saveLines];	3286	end_col = screen.tlen[end_row + TermWin.saveLines];
		3287
3322	if (end_col != -1)	3288	if (end_col != -1)
3323	{	3289	{
3324	selection.end.row = end_row;	3290	selection.end.row = end_row;
3325	selection.end.col = end_col;	3291	selection.end.col = end_col;
3326	selection_remove_trailing_spaces ();	3292	selection_remove_trailing_spaces ();
…		…
3328	}	3294	}
3329	}	3295	}
3330	}	3296	}
3331	else	3297	else
3332	#endif	3298	#endif
3333
3334	{	3299	{
3335	if (ROWCOL_IS_AFTER (selection.mark, selection.beg))	3300	if (ROWCOL_IS_AFTER (selection.mark, selection.beg))
3336	selection.mark.col++;	3301	selection.mark.col++;
3337	selection.beg.col = 0;	3302	selection.beg.col = 0;
3338	selection.end.col = ncol;	3303	selection.end.col = ncol;
3339	}	3304	}
3340	}	3305	}
		3306
3341	if (button3 && buttonpress)	3307	if (button3 && buttonpress)
3342	{ /* mark may need to be changed */	3308	{ /* mark may need to be changed */
3343	if (closeto == LEFT)	3309	if (closeto == LEFT)
3344	{	3310	{
3345	selection.mark.row = selection.end.row;	3311	selection.mark.row = selection.end.row;
3346	selection.mark.col = selection.end.col	3312	selection.mark.col = selection.end.col
3347	- (selection.clicks == 2);	3313	- (selection.clicks == 2);
…		…
3351	selection.mark.row = selection.beg.row;	3317	selection.mark.row = selection.beg.row;
3352	selection.mark.col = selection.beg.col;	3318	selection.mark.col = selection.beg.col;
3353	}	3319	}
3354	}	3320	}
3355	D_SELECT ((stderr, "rxvt_selection_extend_colrow () EXIT b: (r:%d,c:%d) m: (r:%d,c:%d), e: (r:%d,c:%d)", selection.beg.row, selection.beg.col, selection.mark.row, selection.mark.col, selection.end.row, selection.end.col));	3321	D_SELECT ((stderr, "rxvt_selection_extend_colrow () EXIT b: (r:%d,c:%d) m: (r:%d,c:%d), e: (r:%d,c:%d)", selection.beg.row, selection.beg.col, selection.mark.row, selection.mark.col, selection.end.row, selection.end.col));
3356	#endif /* ! NO_NEW_SELECTION */
3357	}	3322	}
3358		3323
3359	#ifndef NO_FRILLS	3324	#ifndef NO_FRILLS
3360	void	3325	void
3361	rxvt_term::selection_remove_trailing_spaces ()	3326	rxvt_term::selection_remove_trailing_spaces ()
…		…
3460	/* TODO: Handle MULTIPLE */	3425	/* TODO: Handle MULTIPLE */
3461	}	3426	}
3462	else if (rq.target == xa[XA_TIMESTAMP] && selection.text)	3427	else if (rq.target == xa[XA_TIMESTAMP] && selection.text)
3463	{	3428	{
3464	XChangeProperty (display->display, rq.requestor, rq.property, XA_INTEGER,	3429	XChangeProperty (display->display, rq.requestor, rq.property, XA_INTEGER,
3465	(8 * sizeof (Time)), PropModeReplace,	3430	(8 * sizeof (Time)), PropModeReplace,
3466	(unsigned char *)&selection_time, 1);	3431	(unsigned char *)&selection_time, 1);
3467	ev.property = rq.property;	3432	ev.property = rq.property;
3468	}	3433	}
3469	else if (rq.target == XA_STRING	3434	else if (rq.target == XA_STRING
3470	|| rq.target == xa[XA_TEXT]	3435	|| rq.target == xa[XA_TEXT]
3471	|| rq.target == xa[XA_COMPOUND_TEXT]	3436	|| rq.target == xa[XA_COMPOUND_TEXT]
…		…
3558	pos->y = Height2Pixel ((screen.cur.row + 1)) + xwa.y - TermWin.lineSpace;	3523	pos->y = Height2Pixel ((screen.cur.row + 1)) + xwa.y - TermWin.lineSpace;
3559	}	3524	}
3560		3525
3561	#endif	3526	#endif
3562	/* ------------------------------------------------------------------------- */	3527	/* ------------------------------------------------------------------------- */
3563
3564	/* ------------------------------------------------------------------------- *
3565	* DEBUG ROUTINES *
3566	* ------------------------------------------------------------------------- */
3567	#if 0
3568	void
3569	rxvt_debug_colors (void)
3570	{
3571	int color;
3572	const char *name[] =
3573	{
3574	"fg", "bg",
3575	"black", "red", "green", "yellow", "blue", "magenta", "cyan", "white"
3576	};
3577
3578	fprintf (stderr, "Color ( ");
3579	if (rstyle & RS_RVid)
3580	fprintf (stderr, "rvid ");
3581	if (rstyle & RS_Bold)
3582	fprintf (stderr, "bold ");
3583	if (rstyle & RS_Blink)
3584	fprintf (stderr, "blink ");
3585	if (rstyle & RS_Uline)
3586	fprintf (stderr, "uline ");
3587	fprintf (stderr, "): ");
3588
3589	color = GET_FGCOLOR (rstyle);
3590	#ifndef NO_BRIGHTCOLOR
3591	if (color >= minBrightCOLOR && color <= maxBrightCOLOR)
3592	{
3593	color -= (minBrightCOLOR - minCOLOR);
3594	fprintf (stderr, "bright ");
3595	}
3596	#endif
3597	fprintf (stderr, "%s on ", name[color]);
3598
3599	color = GET_BGCOLOR (rstyle);
3600	#ifndef NO_BRIGHTCOLOR
3601	if (color >= minBrightCOLOR && color <= maxBrightCOLOR)
3602	{
3603	color -= (minBrightCOLOR - minCOLOR);
3604	fprintf (stderr, "bright ");
3605	}
3606	#endif
3607	fprintf (stderr, "%s\n", name[color]);
3608	}
3609	#endif

Diff Legend

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