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

Comparing rxvt-unicode/src/screen.C (file contents):
Revision 1.407 by sf-exg, Wed Nov 16 18:52:17 2011 UTC vs.
Revision 1.416 by root, Mon May 28 14:26:11 2012 UTC

…		…
28	#include "rxvt.h" /* NECESSARY */	28	#include "rxvt.h" /* NECESSARY */
29	#include "rxvtperl.h" /* NECESSARY */	29	#include "rxvtperl.h" /* NECESSARY */
30		30
31	#include <inttypes.h>	31	#include <inttypes.h>
32		32
33	#include "salloc.C" // HACK, should be a separate compile!
34
35	static inline void	33	static inline void
36	fill_text (text_t *start, text_t value, int len)	34	fill_text (text_t *start, text_t value, int len)
37	{	35	{
38	while (len--)	36	while (len--)
39	*start++ = value;	37	*start++ = value;
…		…
98		96
99	/* Fill part/all of a line with blanks. */	97	/* Fill part/all of a line with blanks. */
100	void	98	void
101	rxvt_term::scr_blank_line (line_t &l, unsigned int col, unsigned int width, rend_t efs) const NOTHROW	99	rxvt_term::scr_blank_line (line_t &l, unsigned int col, unsigned int width, rend_t efs) const NOTHROW
102	{	100	{
103	if (!l.t)	101	if (!l.valid ())
104	{	102	{
105	lalloc (l);	103	l.alloc ();
106	col = 0;	104	col = 0;
107	width = ncol;	105	width = ncol;
108	}	106	}
109		107
110	l.touch ();	108	l.touch ();
…		…
157	/* ------------------------------------------------------------------------- *	155	/* ------------------------------------------------------------------------- *
158	* SCREEN INITIALISATION *	156	* SCREEN INITIALISATION *
159	* ------------------------------------------------------------------------- */	157	* ------------------------------------------------------------------------- */
160		158
161	void	159	void
		160	rxvt_term::scr_alloc ()
		161	{
		162	int tsize = sizeof (text_t) * ncol;
		163	int rsize = sizeof (rend_t) * ncol;
		164
		165	// we assume that rend_t size is a sufficient alignment
		166	// factor for tetx_t and line_t values, and we only
		167	// need to adjust tsize.
		168	tsize = (tsize + sizeof (rend_t) - 1);
		169	tsize -= tsize % sizeof (rend_t);
		170
		171	int all_rows = total_rows + nrow + nrow;
		172
		173	chunk_size = (sizeof (line_t) + rsize + tsize) * all_rows;
		174	chunk = rxvt_malloc (chunk_size);
		175
		176	char base = (char )chunk + sizeof (line_t) * all_rows;
		177
		178	for (int row = 0; row < all_rows; ++row)
		179	{
		180	line_t &l = ((line_t *)chunk) [row];
		181
		182	l.t = (text_t *)base; base += tsize;
		183	l.r = (rend_t *)base; base += rsize;
		184	l.l = -1;
		185	l.f = 0;
		186	}
		187
		188	drawn_buf = (line_t *)chunk;
		189	swap_buf = drawn_buf + nrow;
		190	row_buf = swap_buf + nrow;
		191	}
		192
		193	void
162	rxvt_term::scr_reset ()	194	rxvt_term::scr_reset ()
163	{	195	{
164	#if ENABLE_OVERLAY	196	#if ENABLE_OVERLAY
165	scr_overlay_off ();	197	scr_overlay_off ();
166	#endif	198	#endif
…		…
192	total_rows = nrow + saveLines;	224	total_rows = nrow + saveLines;
193		225
194	screen.tscroll = 0;	226	screen.tscroll = 0;
195	screen.bscroll = nrow - 1;	227	screen.bscroll = nrow - 1;
196		228
		229	void *prev_chunk = chunk;
		230	line_t *prev_drawn_buf = drawn_buf;
		231	line_t *prev_swap_buf = swap_buf;
		232	line_t *prev_row_buf = row_buf;
		233
		234	int common_col = min (prev_ncol, ncol);
		235
		236	scr_alloc ();
		237
197	if (!row_buf)	238	if (!prev_row_buf)
198	{	239	{
199	/*	240	/*
200	* first time called so just malloc everything: don't rely on realloc	241	* first time called so just malloc everything: don't rely on realloc
201	*/	242	*/
202	top_row = 0;	243	top_row = 0;
203	term_start = 0;	244	term_start = 0;
204
205	talloc = new rxvt_salloc (ncol * sizeof (text_t));
206	ralloc = new rxvt_salloc (ncol * sizeof (rend_t));
207
208	row_buf = (line_t *)rxvt_calloc (total_rows , sizeof (line_t));
209	drawn_buf = (line_t *)rxvt_calloc (nrow , sizeof (line_t));
210	swap_buf = (line_t *)rxvt_calloc (nrow , sizeof (line_t));
211
212	for (int row = nrow; row--; )
213	{
214	scr_blank_screen_mem (ROW (row), DEFAULT_RSTYLE);
215	scr_blank_screen_mem (swap_buf [row], DEFAULT_RSTYLE);
216	scr_blank_screen_mem (drawn_buf[row], DEFAULT_RSTYLE);
217	}
218		245
219	memset (charsets, 'B', sizeof (charsets));	246	memset (charsets, 'B', sizeof (charsets));
220	rstyle = DEFAULT_RSTYLE;	247	rstyle = DEFAULT_RSTYLE;
221	screen.flags = Screen_DefaultFlags;	248	screen.flags = Screen_DefaultFlags;
222	screen.cur.row = screen.cur.col = 0;	249	screen.cur.row = screen.cur.col = 0;
…		…
245	{	272	{
246	/*	273	/*
247	* add or delete rows as appropriate	274	* add or delete rows as appropriate
248	*/	275	*/
249		276
250	rxvt_salloc old_ta = talloc; talloc = new rxvt_salloc (ncol sizeof (text_t));
251	rxvt_salloc old_ra = ralloc; ralloc = new rxvt_salloc (ncol sizeof (rend_t));
252
253	#if 0
254	if (nrow < prev_nrow)
255	{
256	for (int row = nrow; row < prev_nrow; row++)
257	{
258	lfree (swap_buf [row]);
259	lfree (drawn_buf[row]);
260	}
261	}
262	#endif
263
264	drawn_buf = (line_t )rxvt_realloc (drawn_buf, nrow sizeof (line_t));
265	swap_buf = (line_t )rxvt_realloc (swap_buf , nrow sizeof (line_t));
266
267	for (int row = min (nrow, prev_nrow); row--; )	277	for (int row = min (nrow, prev_nrow); row--; )
268	{	278	{
269	lresize (drawn_buf[row]);	279	scr_blank_screen_mem (drawn_buf [row], DEFAULT_RSTYLE);
270	lresize (swap_buf [row]);	280	scr_blank_screen_mem (swap_buf [row], DEFAULT_RSTYLE);
271	}
272		281
273	for (int row = prev_nrow; row < nrow; row++)	282	memcpy (drawn_buf [row].t, prev_drawn_buf [row].t, sizeof (text_t) * common_col);
		283	memcpy (drawn_buf [row].r, prev_drawn_buf [row].r, sizeof (rend_t) * common_col);
		284	memcpy (swap_buf [row].t, prev_swap_buf [row].t, sizeof (text_t) * common_col);
		285	memcpy (swap_buf [row].r, prev_swap_buf [row].r, sizeof (rend_t) * common_col);
274	{	286	}
275	swap_buf [row].clear (); scr_blank_screen_mem (swap_buf [row], DEFAULT_RSTYLE);
276	drawn_buf[row].clear (); scr_blank_screen_mem (drawn_buf[row], DEFAULT_RSTYLE);
277	}
278
279	line_t *old_buf = row_buf;
280	row_buf = (line_t *)rxvt_calloc (total_rows, sizeof (line_t));
281		287
282	int p = MOD (term_start + prev_nrow, prev_total_rows); // previous row	288	int p = MOD (term_start + prev_nrow, prev_total_rows); // previous row
283	int pend = MOD (term_start + top_row , prev_total_rows);	289	int pend = MOD (term_start + top_row , prev_total_rows);
284	int q = total_rows; // rewrapped row	290	int q = total_rows; // rewrapped row
285		291
…		…
293	ocur.row = MOD (term_start + ocur.row, prev_total_rows);	299	ocur.row = MOD (term_start + ocur.row, prev_total_rows);
294		300
295	do	301	do
296	{	302	{
297	p = MOD (p - 1, prev_total_rows);	303	p = MOD (p - 1, prev_total_rows);
298	assert (old_buf [MOD (p, prev_total_rows)].t);	304	assert (prev_row_buf [MOD (p, prev_total_rows)].t);
299	int plines = 1;	305	int plines = 1;
300	int llen = old_buf [MOD (p, prev_total_rows)].l;	306	int llen = prev_row_buf [MOD (p, prev_total_rows)].l;
301		307
302	while (p != pend && old_buf [MOD (p - 1, prev_total_rows)].is_longer ())	308	while (p != pend && prev_row_buf [MOD (p - 1, prev_total_rows)].is_longer ())
303	{	309	{
304	p = MOD (p - 1, prev_total_rows);	310	p = MOD (p - 1, prev_total_rows);
305		311
306	plines++;	312	plines++;
307	llen += prev_ncol;	313	llen += prev_ncol;
…		…
320		326
321	// re-assemble the full line by destination lines	327	// re-assemble the full line by destination lines
322	for (int qrow = q; qlines--; qrow++)	328	for (int qrow = q; qlines--; qrow++)
323	{	329	{
324	qline = row_buf + qrow;	330	qline = row_buf + qrow;
325	lalloc (*qline);	331	qline->alloc (); // redundant with next line
326	qline->l = ncol;	332	qline->l = ncol;
327	qline->is_longer (1);	333	qline->is_longer (1);
328		334
329	int qcol = 0;	335	int qcol = 0;
330		336
…		…
345	// this seems to upset applications/shells/readline	351	// this seems to upset applications/shells/readline
346	// least.	352	// least.
347	if (prow == ocur.row)	353	if (prow == ocur.row)
348	screen.cur.row = q - (total_rows - nrow);	354	screen.cur.row = q - (total_rows - nrow);
349		355
350	line_t &pline = old_buf [prow];	356	line_t &pline = prev_row_buf [prow];
351		357
352	int len = min (min (prev_ncol - pcol, ncol - qcol), llen - lofs);	358	int len = min (min (prev_ncol - pcol, ncol - qcol), llen - lofs);
353		359
354	memcpy (qline->t + qcol, pline.t + pcol, len * sizeof (text_t));	360	memcpy (qline->t + qcol, pline.t + pcol, len * sizeof (text_t));
355	memcpy (qline->r + qcol, pline.r + pcol, len * sizeof (rend_t));	361	memcpy (qline->r + qcol, pline.r + pcol, len * sizeof (rend_t));
…		…
376	{	382	{
377	// if no scrollback exists (yet), wing, instead of wrap	383	// if no scrollback exists (yet), wing, instead of wrap
378		384
379	for (int row = min (nrow, prev_nrow); row--; )	385	for (int row = min (nrow, prev_nrow); row--; )
380	{	386	{
381	line_t &pline = old_buf [MOD (term_start + row, prev_total_rows)];	387	line_t &src = prev_row_buf [MOD (term_start + row, prev_total_rows)];
382	line_t &qline = row_buf [row];	388	line_t &dst = row_buf [row];
383		389
384	qline = pline;	390	scr_blank_screen_mem (dst, DEFAULT_RSTYLE);
385	lresize (qline);	391
		392	memcpy (dst.t, src.t, sizeof (text_t) * common_col);
		393	memcpy (dst.r, src.r, sizeof (rend_t) * common_col);
386	}	394	}
387		395
388	for (int row = prev_nrow; row < nrow; row++)	396	for (int row = prev_nrow; row < nrow; row++)
389	{
390	row_buf [row].clear (); scr_blank_screen_mem (row_buf [row], DEFAULT_RSTYLE);	397	scr_blank_screen_mem (row_buf [row], DEFAULT_RSTYLE);
391	}
392		398
393	term_start = 0;	399	term_start = 0;
394	}	400	}
395
396	free (old_buf);
397	delete old_ta;
398	delete old_ra;
399		401
400	clamp_it (screen.cur.row, 0, nrow - 1);	402	clamp_it (screen.cur.row, 0, nrow - 1);
401	clamp_it (screen.cur.col, 0, ncol - 1);	403	clamp_it (screen.cur.col, 0, ncol - 1);
402	}	404	}
403		405
		406	for (int row = nrow; row--; )
		407	{
		408	if (!ROW (row).valid ()) scr_blank_screen_mem (ROW (row), DEFAULT_RSTYLE);
		409	if (!swap_buf [row].valid ()) scr_blank_screen_mem (swap_buf [row], DEFAULT_RSTYLE);
		410	if (!drawn_buf [row].valid ()) scr_blank_screen_mem (drawn_buf [row], DEFAULT_RSTYLE);
		411	}
		412
		413	free (prev_chunk);
		414
404	free (tabs);	415	free (tabs);
405	tabs = (char *)rxvt_malloc (ncol);	416	tabs = (char *)rxvt_malloc (ncol);
406		417
407	for (int col = ncol; col--; )	418	for (int col = ncol; col--; )
408	tabs [col] = col % TABSIZE == 0;	419	tabs [col] = col % TABSIZE == 0;
…		…
422	* Free everything. That way malloc debugging can find leakage.	433	* Free everything. That way malloc debugging can find leakage.
423	*/	434	*/
424	void	435	void
425	rxvt_term::scr_release () NOTHROW	436	rxvt_term::scr_release () NOTHROW
426	{	437	{
427	if (row_buf)	438	free (chunk);
428	{
429	delete talloc; talloc = 0;
430	delete ralloc; ralloc = 0;
431
432	free (row_buf);
433	free (swap_buf);
434	free (drawn_buf);
435	row_buf = 0; // signal that we freed all the arrays above
436
437	free (tabs);	439	free (tabs);
438	tabs = 0;
439	}
440	}	440	}
441		441
442	/* ------------------------------------------------------------------------- */	442	/* ------------------------------------------------------------------------- */
443	/*	443	/*
444	* Hard/Soft reset	444	* Hard/Soft reset
445	*/	445	*/
446	void	446	void
447	rxvt_term::scr_poweron ()	447	rxvt_term::scr_poweron ()
448	{	448	{
449	scr_release ();	449	scr_release ();
		450
		451	row_buf = 0;
		452	tabs = 0;
450	prev_nrow = prev_ncol = 0;	453	prev_nrow = prev_ncol = 0;
451	rvideo_mode = false;	454	rvideo_mode = false;
452	scr_soft_reset ();	455	scr_soft_reset ();
453	scr_reset ();	456	scr_reset ();
454		457
455	scr_clear (true);	458	scr_clear (true);
456	scr_refresh ();	459	scr_refresh ();
457	}	460	}
458		461
459	void	462	void
460	rxvt_term::scr_soft_reset ()	463	rxvt_term::scr_soft_reset () NOTHROW
461	{	464	{
462	/* only affects modes, nothing drastic such as clearing the screen */	465	/* only affects modes, nothing drastic such as clearing the screen */
463	#if ENABLE_OVERLAY	466	#if ENABLE_OVERLAY
464	scr_overlay_off ();	467	scr_overlay_off ();
465	#endif	468	#endif
…		…
520	assert (s->cur.row >= 0);	523	assert (s->cur.row >= 0);
521	assert (s->cur.col >= 0);	524	assert (s->cur.col >= 0);
522	}	525	}
523		526
524	void	527	void
525	rxvt_term::scr_swap_screen ()	528	rxvt_term::scr_swap_screen () NOTHROW
526	{	529	{
527	if (!option (Opt_secondaryScreen))	530	if (!option (Opt_secondaryScreen))
528	return;	531	return;
529		532
530	for (int i = prev_nrow; i--; )	533	for (int i = prev_nrow; i--; )
…		…
1312	scr_blank_line (line, col, num, rstyle);	1315	scr_blank_line (line, col, num, rstyle);
1313	}	1316	}
1314		1317
1315	/* ------------------------------------------------------------------------- */	1318	/* ------------------------------------------------------------------------- */
1316	/*	1319	/*
1317	* Erase part of whole of the screen	1320	* Erase part or whole of the screen
1318	* XTERM_SEQ: Clear screen after cursor : ESC [ 0 J	1321	* XTERM_SEQ: Clear screen after cursor : ESC [ 0 J
1319	* XTERM_SEQ: Clear screen before cursor: ESC [ 1 J	1322	* XTERM_SEQ: Clear screen before cursor: ESC [ 1 J
1320	* XTERM_SEQ: Clear whole screen : ESC [ 2 J	1323	* XTERM_SEQ: Clear whole screen : ESC [ 2 J
1321	*/	1324	*/
1322	void	1325	void
…		…
1367	{	1370	{
1368	ren = DEFAULT_RSTYLE;	1371	ren = DEFAULT_RSTYLE;
1369		1372
1370	if (mapped)	1373	if (mapped)
1371	XClearArea (dpy, vt, 0,	1374	XClearArea (dpy, vt, 0,
1372	Row2Pixel (row - view_start), (unsigned int)width,	1375	Row2Pixel (row - view_start), (unsigned int)vt_width,
1373	(unsigned int)Height2Pixel (num), False);	1376	(unsigned int)Height2Pixel (num), False);
1374	}	1377	}
1375	else	1378	else
1376	{	1379	{
1377	ren = rstyle & (RS_fgMask \| RS_bgMask);	1380	ren = rstyle & (RS_fgMask \| RS_bgMask);
…		…
1380	{	1383	{
1381	gcvalue.foreground = pix_colors[bgcolor_of (rstyle)];	1384	gcvalue.foreground = pix_colors[bgcolor_of (rstyle)];
1382	XChangeGC (dpy, gc, GCForeground, &gcvalue);	1385	XChangeGC (dpy, gc, GCForeground, &gcvalue);
1383	XFillRectangle (dpy, vt, gc,	1386	XFillRectangle (dpy, vt, gc,
1384	0, Row2Pixel (row - view_start),	1387	0, Row2Pixel (row - view_start),
1385	(unsigned int)width,	1388	(unsigned int)vt_width,
1386	(unsigned int)Height2Pixel (num));	1389	(unsigned int)Height2Pixel (num));
1387	gcvalue.foreground = pix_colors[Color_fg];	1390	gcvalue.foreground = pix_colors[Color_fg];
1388	XChangeGC (dpy, gc, GCForeground, &gcvalue);	1391	XChangeGC (dpy, gc, GCForeground, &gcvalue);
1389	}	1392	}
1390	}	1393	}
…		…
1876	* Refresh the entire screen	1879	* Refresh the entire screen
1877	*/	1880	*/
1878	void	1881	void
1879	rxvt_term::scr_touch (bool refresh) NOTHROW	1882	rxvt_term::scr_touch (bool refresh) NOTHROW
1880	{	1883	{
1881	scr_expose (0, 0, width, height, refresh);	1884	scr_expose (0, 0, vt_width, vt_height, refresh);
1882	}	1885	}
1883		1886
1884	/* ------------------------------------------------------------------------- */	1887	/* ------------------------------------------------------------------------- */
1885	/*	1888	/*
1886	* Move the display so that the line represented by scrollbar value Y is at	1889	* Move the display so that the line represented by scrollbar value Y is at
…		…
2167	{	2170	{
2168	int16_t nits;	2171	int16_t nits;
2169	int i = num_scr;	2172	int i = num_scr;
2170	int j;	2173	int j;
2171	int len, wlen;	2174	int len, wlen;
2172	dLocal (int, num_scr);
2173		2175
2174	j = nrow;	2176	j = nrow;
2175	wlen = len = -1;	2177	wlen = len = -1;
2176	row = i > 0 ? 0 : j - 1;	2178	row = i > 0 ? 0 : j - 1;
2177		2179
…		…
2482		2484
2483	XDrawRectangle (dpy, vt, gc,	2485	XDrawRectangle (dpy, vt, gc,
2484	Col2Pixel (col),	2486	Col2Pixel (col),
2485	Row2Pixel (oldcursor.row),	2487	Row2Pixel (oldcursor.row),
2486	(unsigned int) (Width2Pixel (cursorwidth) - 1),	2488	(unsigned int) (Width2Pixel (cursorwidth) - 1),
2487	(unsigned int) (Height2Pixel (1) - lineSpace - 1));	2489	(unsigned int) (Height2Pixel (1) - 1));
2488	}	2490	}
2489	}	2491	}
2490		2492
2491	/*	2493	/*
2492	* H: cleanup selection	2494	* H: cleanup selection
…		…
2504	}	2506	}
2505		2507
2506	void	2508	void
2507	rxvt_term::scr_remap_chars (line_t &l) NOTHROW	2509	rxvt_term::scr_remap_chars (line_t &l) NOTHROW
2508	{	2510	{
2509	if (!l.t)	2511	if (!l.valid ())
2510	return;	2512	return;
2511		2513
2512	l.touch (); // maybe a bit of an overkill, but it's not performance-relevant	2514	l.touch (); // maybe a bit of an overkill, but it's not performance-relevant
2513		2515
2514	for (int i = ncol; i--; )	2516	for (int i = ncol; i--; )
…		…
2668	*/	2670	*/
2669	#if 0	2671	#if 0
2670	void	2672	void
2671	rxvt_term::scr_dump (int fd) NOTHROW	2673	rxvt_term::scr_dump (int fd) NOTHROW
2672	{	2674	{
2673	int row, wrote;	2675	// if this method is needed, it can be implemented by factoring the
2674	unsigned int width, towrite;	2676	// relevant code in scr_printscreen
2675	const char r1[] = "\n";
2676
2677	for (row = saveLines + top_row;
2678	row < saveLines + nrow - 1; row++)
2679	{
2680	width = row_buf[row].l >= 0 ? row_buf[row].l
2681	: ncol;
2682	for (towrite = width; towrite; towrite -= wrote)
2683	{
2684	wrote = write (fd, & (row_buf[row].t[width - towrite]),
2685	towrite);
2686	if (wrote < 0)
2687	return; /* XXX: death, no report */
2688	}
2689	if (row_buf[row].l >= 0)
2690	if (write (fd, r1, 1) <= 0)
2691	return; /* XXX: death, no report */
2692	}
2693	}	2677	}
2694	#endif	2678	#endif
2695		2679
2696	/* ------------------------------------------------------------------------- *	2680	/* ------------------------------------------------------------------------- *
2697	* CHARACTER SELECTION *	2681	* CHARACTER SELECTION *
…		…
2723	for (unsigned int i = 0; i < len; i++)	2707	for (unsigned int i = 0; i < len; i++)
2724	if (data[i] == C0_LF)	2708	if (data[i] == C0_LF)
2725	data[i] = C0_CR;	2709	data[i] = C0_CR;
2726		2710
2727	if (priv_modes & PrivMode_BracketPaste)	2711	if (priv_modes & PrivMode_BracketPaste)
2728	tt_printf ("\e[200~");	2712	tt_printf ("\x1b[200~");
2729		2713
2730	tt_write (data, len);	2714	tt_write (data, len);
2731		2715
2732	if (priv_modes & PrivMode_BracketPaste)	2716	if (priv_modes & PrivMode_BracketPaste)
2733	tt_printf ("\e[201~");	2717	tt_printf ("\x1b[201~");
2734	}	2718	}
2735		2719
2736	void	2720	void
2737	rxvt_term::paste (char *data, unsigned int len) NOTHROW	2721	rxvt_term::paste (char *data, unsigned int len) NOTHROW
2738	{	2722	{

Diff Legend

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

Comparing rxvt-unicode/src/screen.C (file contents): Revision 1.407 by sf-exg, Wed Nov 16 18:52:17 2011 UTC vs. Revision 1.416 by root, Mon May 28 14:26:11 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/screen.C (file contents):
Revision 1.407 by sf-exg, Wed Nov 16 18:52:17 2011 UTC vs.
Revision 1.416 by root, Mon May 28 14:26:11 2012 UTC