ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/rxvt-unicode/src/command.C

Comparing rxvt-unicode/src/command.C (file contents):
Revision 1.97 by root, Mon Jul 26 18:01:19 2004 UTC vs.
Revision 1.473 by sf-exg, Thu Jan 27 17:37:19 2011 UTC

1	/*--------------------------------*-C-*---------------------------------*	1	/*----------------------------------------------------------------------*
2	* File: command.C	2	* File: command.C
3	*----------------------------------------------------------------------*	3	*----------------------------------------------------------------------*
4	*	4	*
5	* All portions of code are copyright by their respective author/s.	5	* All portions of code are copyright by their respective author/s.
6	* Copyright (c) 1992 John Bovey, University of Kent at Canterbury <jdb@ukc.ac.uk>	6	* Copyright (c) 1992 John Bovey, University of Kent at Canterbury <jdb@ukc.ac.uk>
…		…
25	* - extensive modifications	25	* - extensive modifications
26	* Copyright (c) 1998 Alfredo K. Kojima <kojima@windowmaker.org>	26	* Copyright (c) 1998 Alfredo K. Kojima <kojima@windowmaker.org>
27	* Copyright (c) 2001 Marius Gedminas	27	* Copyright (c) 2001 Marius Gedminas
28	* - Ctrl/Mod4+Tab works like Meta+Tab (options)	28	* - Ctrl/Mod4+Tab works like Meta+Tab (options)
29	* Copyright (c) 2003 Rob McMullen <robm@flipturn.org>	29	* Copyright (c) 2003 Rob McMullen <robm@flipturn.org>
30	* Copyright (c) 2003-2004 Marc Lehmann <pcg@goof.com>	30	* Copyright (c) 2003-2007 Marc Lehmann <pcg@goof.com>
		31	* Copyright (c) 2007 Emanuele Giaquinta <e.giaquinta@glauco.it>
31	*	32	*
32	* This program is free software; you can redistribute it and/or modify	33	* This program is free software; you can redistribute it and/or modify
33	* it under the terms of the GNU General Public License as published by	34	* it under the terms of the GNU General Public License as published by
34	* the Free Software Foundation; either version 2 of the License, or	35	* the Free Software Foundation; either version 2 of the License, or
35	* (at your option) any later version.	36	* (at your option) any later version.
…		…
43	* along with this program; if not, write to the Free Software	44	* along with this program; if not, write to the Free Software
44	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	45	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
45	*----------------------------------------------------------------------*/	46	*----------------------------------------------------------------------*/
46		47
47	/*{{{ includes: */	48	/*{{{ includes: */
48	#include "../config.h" /* NECESSARY */	49	#include "../config.h"
49	#include "rxvt.h" /* NECESSARY */	50	#include "rxvt.h"
		51	#include "rxvtperl.h"
50	#include "version.h"	52	#include "version.h"
51	#include "command.h"	53	#include "command.h"
52		54
53	#include <wchar.h>	55	#ifdef KEYSYM_RESOURCE
		56	# include "keyboard.h"
		57	#endif
		58
		59	#include <csignal>
		60
		61	#if LINUX_YIELD_HACK
		62	# include <ctime>
		63	#endif
54		64
55	/*----------------------------------------------------------------------*/	65	/*----------------------------------------------------------------------*/
56		66
57	#define IS_CONTROL(ch) !((ch) & 0xffffff60UL)	67	#define IS_CONTROL(ch) !((ch) & 0xffffff60UL)
58		68
59	// exception thrown when the command parser runs out of input data	69	#if ENABLE_FRILLS || ISO_14755
60	class out_of_input { } out_of_input;
61		70
62	/*{{{ Convert the keypress event into a string */	71	#define ISO_14755_STARTED 0x80000000UL
		72	#define ISO_14755_51 0x40000000UL // basic (section 5.1)
		73	#define ISO_14755_52 0x20000000UL // keycap (section 5.2)
		74	#define ISO_14755_54 0x10000000UL // code feedback (section 5.4)
		75	#define ISO_14755_MASK 0x0fffffffUL
		76
		77	#if ISO_14755
		78	static unsigned short iso14755_symtab[] = {
		79	// keysym, unicode
		80	XK_Left, 0x2190,
		81	XK_KP_Left, 0x2190,
		82	XK_Up, 0x2191,
		83	XK_KP_Up, 0x2191,
		84	XK_Right, 0x2192,
		85	XK_KP_Right, 0x2192,
		86	XK_Down, 0x2193,
		87	XK_KP_Down, 0x2193,
		88	XK_Linefeed, 0x21b4,
		89	XK_Return, 0x21b5,
		90	XK_KP_Enter, 0x21b5,
		91
		92	XK_Prior, 0x21de,
		93	XK_Next, 0x21df,
		94	XK_Tab, 0x21e5,
		95	XK_ISO_Left_Tab, 0x21e6,
		96	XK_Shift_L, 0x21e7,
		97	XK_Shift_R, 0x21e7,
		98
		99	XK_Shift_Lock, 0x21eb,
		100	XK_ISO_Lock, 0x21eb,
		101	XK_Caps_Lock, 0x21ec,
		102	XK_Num_Lock, 0x21ed,
		103	XK_ISO_Level3_Shift, 0x21ee,
		104	XK_ISO_Level3_Lock, 0x21ef,
		105	XK_ISO_Group_Lock, 0x21f0,
		106	XK_Home, 0x21f1,
		107	XK_End, 0x21f2,
		108
		109	XK_Execute, 0x2318,
		110	XK_Begin, 0x2320,
		111	XK_Delete, 0x2326,
		112	XK_Clear, 0x2327,
		113	XK_BackSpace, 0x232b,
		114	XK_Insert, 0x2380,
		115	XK_Control_L, 0x2388,
		116	XK_Control_R, 0x2388,
		117	XK_Pause, 0x2389,
		118	XK_Break, 0x238a,
		119	XK_Escape, 0x238b,
		120	XK_Undo, 0x238c,
		121	XK_Print, 0x2399,
		122
		123	XK_space, 0x2423,
		124
		125	#ifdef XK_KP_Begin
		126	XK_KP_Prior, 0x21de,
		127	XK_KP_Next, 0x21df,
		128	XK_KP_Begin, 0x2320,
		129	XK_KP_Insert, 0x2380,
		130	XK_KP_Delete, 0x2326,
		131	XK_KP_Space, 0x2422,
		132	#endif
		133	0,
		134	};
		135
63	void	136	void
		137	rxvt_term::iso14755_54 (int x, int y)
		138	{
		139	x = Pixel2Col (x);
		140	y = Pixel2Row (y);
		141
		142	if (!IN_RANGE_EXC (x, 0, ncol)
		143	|| !IN_RANGE_EXC (y, 0, nrow))
		144	return;
		145
		146	for (;;)
		147	{
		148	const line_t &l = ROW(y + view_start);
		149
		150	text_t t = l.t[x];
		151
		152	if (t != NOCHAR || !x)
		153	{
		154	iso14755_51 (l.t[x], l.r[x], x, y);
		155	iso14755buf = ISO_14755_54;
		156	break;
		157	}
		158
		159	x--;
		160	}
		161	}
		162
		163	void
		164	rxvt_term::iso14755_51 (unicode_t ch, rend_t r, int x, int y)
		165	{
		166	rxvt_fontset *fs = FONTSET (r);
		167	wchar_t *chr, *alloc, ch2, **fname;
		168	int len;
		169
		170	# if ENABLE_COMBINING
		171	if (IS_COMPOSE (ch))
		172	{
		173	len = rxvt_composite.expand (ch, 0);
		174	alloc = chr = new wchar_t[len];
		175	rxvt_composite.expand (ch, chr);
		176	}
		177	else
		178	# endif
		179	{
		180	ch2 = ch;
		181
		182	alloc = 0;
		183	chr = &ch2;
		184	len = 1;
		185	}
		186
		187	char attr[80]; // plenty
		188
		189	sprintf (attr, "%08x = fg %d bg %d%s%s%s%s%s%s",
		190	(int)r,
		191	fgcolor_of (r), bgcolor_of (r),
		192	r & RS_Bold ? " bold" : "",
		193	r & RS_Italic ? " italic" : "",
		194	r & RS_Blink ? " blink" : "",
		195	r & RS_RVid ? " rvid" : "",
		196	r & RS_Uline ? " uline" : "",
		197	r & RS_Careful ? " careful" : "");
		198
		199	int width = 0;
		200	fname = rxvt_temp_buf<wchar_t *> (len);
		201	for (int i = 0; i < len; i++)
		202	{
		203	rxvt_font *f = (*fs)[fs->find_font_idx (chr[i])];
		204	fname[i] = rxvt_utf8towcs (f->name);
		205	max_it (width, wcswidth (fname[i], wcslen (fname[i])));
		206	}
		207
		208	max_it (width, 8+5); // for char + hex
		209	max_it (width, strlen (attr));
		210
		211	if (y >= 0)
		212	{
		213	y = (y >= nrow - len - 4 && x < width + 2) ? 0 : -1;
		214	x = 0;
		215	}
		216
		217	scr_overlay_new (x, y, width, len * 2 + 1);
		218
		219	r = SET_STYLE (OVERLAY_RSTYLE, GET_STYLE (r));
		220
		221	for (int y = 0; y < len; y++)
		222	{
		223	char buf[9];
		224
		225	ch = *chr++;
		226
		227	sprintf (buf, "%8x", ch);
		228	scr_overlay_set (0, y, buf);
		229	scr_overlay_set (9, y, '=');
		230	# if !UNICODE_3
		231	if (ch >= 0x10000)
		232	ch = 0xfffd;
		233	# endif
		234	scr_overlay_set (11, y, ch, r);
		235
		236	if (WCWIDTH (ch) >= 2)
		237	scr_overlay_set (12, y, NOCHAR, r);
		238	}
		239
		240	// {
		241	// char buf[4+4+3+1];
		242	// snprintf (buf, sizeof (buf), "(%.4d|%.4d)", x, y);
		243	// scr_overlay_set (0, 0, buf);
		244	// }
		245	scr_overlay_set (0, len , attr);
		246	for (int i = 0; i < len; i++)
		247	{
		248	scr_overlay_set (0, len + 1 + i, fname[i]);
		249	free (fname[i]);
		250	}
		251
		252	# if ENABLE_COMBINING
		253	if (alloc)
		254	delete [] alloc;
		255	# endif
		256	}
		257	#endif
		258
		259	void
		260	rxvt_term::commit_iso14755 ()
		261	{
		262	wchar_t ch[2];
		263
		264	ch[0] = iso14755buf & ISO_14755_MASK;
		265	ch[1] = 0;
		266
		267	if (iso14755buf & ISO_14755_51)
		268	{
		269	char mb[16];
		270	int len;
		271
		272	// allow verbatim 0-bytes and control-bytes to be entered
		273	if (ch[0] >= 0x20)
		274	len = wcstombs (mb, ch, 16);
		275	else
		276	{
		277	mb[0] = ch[0];
		278	len = 1;
		279	}
		280
		281	if (len > 0)
		282	tt_write (mb, len);
		283	else
		284	scr_bell ();
		285	}
		286
		287	iso14755buf = 0;
		288	}
		289
		290	static int
		291	hex_keyval (XKeyEvent &ev)
		292	{
		293	// check whether this event corresponds to a hex digit
		294	// if the modifiers had not been pressed.
		295	for (int index = 0; index < 8; index++)
		296	{
		297	KeySym k = XLookupKeysym (&ev, index);
		298
		299	if (k >= XK_KP_0 && k <= XK_KP_9) return k - XK_KP_0;
		300	else if (k >= XK_0 && k <= XK_9) return k - XK_0;
		301	else if (k >= XK_a && k <= XK_f) return k - XK_a + 10;
		302	else if (k >= XK_A && k <= XK_F) return k - XK_A + 10;
		303	}
		304
		305	return -1;
		306	}
		307	#endif
		308
		309	static inline KeySym
		310	translate_keypad (KeySym keysym, bool kp)
		311	{
		312	#ifdef XK_KP_Home
		313	static const KeySym keypadtrans[] = {
		314	XK_KP_7, // XK_KP_Home
		315	XK_KP_4, // XK_KP_Left
		316	XK_KP_8, // XK_KP_Up
		317	XK_KP_6, // XK_KP_Right
		318	XK_KP_2, // XK_KP_Down
		319	# ifndef UNSHIFTED_SCROLLKEYS
		320	XK_KP_9, // XK_KP_Prior
		321	XK_KP_3, // XK_KP_Next
		322	# else
		323	XK_Prior,
		324	XK_Next,
		325	# endif
		326	XK_KP_1, // XK_KP_End
		327	XK_KP_5, // XK_KP_Begin
		328	};
		329
		330	if (IN_RANGE_INC (keysym, XK_KP_Home, XK_KP_Begin))
		331	{
		332	unsigned int index = keysym - XK_KP_Home;
		333	keysym = kp ? keypadtrans[index] : XK_Home + index;
		334	}
		335	else if (keysym == XK_KP_Insert)
		336	keysym = kp ? XK_KP_0 : XK_Insert;
		337	# ifndef NO_DELETE_KEY
		338	else if (keysym == XK_KP_Delete)
		339	keysym = kp ? XK_KP_Decimal : XK_Delete;
		340	# endif
		341	#endif
		342	return keysym;
		343	}
		344
		345	static inline int
		346	map_function_key (KeySym keysym)
		347	{
		348	int param = 0;
		349
		350	if (IN_RANGE_INC (keysym, XK_F1, XK_F35))
		351	{
		352	param = 11 + keysym - XK_F1;
		353	if (keysym >= XK_F17)
		354	param += 4;
		355	else if (keysym >= XK_F15)
		356	param += 3;
		357	else if (keysym >= XK_F11)
		358	param += 2;
		359	else if (keysym >= XK_F6)
		360	param += 1;
		361	}
		362	else
		363	switch (keysym)
		364	{
		365	case XK_Find:
		366	param = 1;
		367	break;
		368	case XK_Insert:
		369	param = 2;
		370	break;
		371	#ifdef DXK_Remove
		372	case DXK_Remove:
		373	#endif
		374	case XK_Execute:
		375	param = 3;
		376	break;
		377	case XK_Select:
		378	param = 4;
		379	break;
		380	#ifndef UNSHIFTED_SCROLLKEYS
		381	case XK_Prior:
		382	param = 5;
		383	break;
		384	case XK_Next:
		385	param = 6;
		386	break;
		387	case XK_Home:
		388	param = 7;
		389	break;
		390	case XK_End:
		391	param = 8;
		392	break;
		393	#endif
		394	case XK_Help:
		395	param = 28;
		396	break;
		397	case XK_Menu:
		398	param = 29;
		399	break;
		400	}
		401	return param;
		402	}
		403
		404	void
64	rxvt_term::lookup_key (XKeyEvent &ev)	405	rxvt_term::key_press (XKeyEvent &ev)
65	{	406	{
66	int ctrl, meta, shft, len;	407	int ctrl, meta, shft, len;
67	unsigned int newlen;
68	KeySym keysym;	408	KeySym keysym;
69	#ifdef DEBUG_CMD
70	static int debug_key = 1; /* accessible by a debugger only */
71	#endif
72	int valid_keysym;	409	int valid_keysym;
73	unsigned char kbuf[KBUFSZ];	410	char kbuf[KBUFSZ];
		411
		412	#if ISO_14755
		413	if (iso14755buf & ISO_14755_52)
		414	return;
		415	#endif
74		416
75	/*	417	/*
76	* use Num_Lock to toggle Keypad on/off. If Num_Lock is off, allow an	418	* use Num_Lock to toggle Keypad on/off. If Num_Lock is off, allow an
77	* escape sequence to toggle the Keypad.	419	* escape sequence to toggle the Keypad.
78	*	420	*
79	* Always permit `shift' to override the current setting	421	* Always permit `shift' to override the current setting
80	*/	422	*/
81	shft = (ev.state & ShiftMask);	423	shft = ev.state & ShiftMask;
82	ctrl = (ev.state & ControlMask);	424	ctrl = ev.state & ControlMask;
83	meta = (ev.state & ModMetaMask);	425	meta = ev.state & ModMetaMask;
84
85	if (numlock_state || (ev.state & ModNumLockMask))
86	{
87	numlock_state = (ev.state & ModNumLockMask);
88	PrivMode ((!numlock_state), PrivMode_aplKP);
89	}
90		426
91	kbuf[0] = 0;	427	kbuf[0] = 0;
92		428
93	#ifdef USE_XIM	429	#ifdef USE_XIM
94	if (Input_Context)	430	if (Input_Context)
…		…
96	Status status_return;	432	Status status_return;
97		433
98	#if 0	434	#if 0
99	#ifdef X_HAVE_UTF8_STRING	435	#ifdef X_HAVE_UTF8_STRING
100	if (enc_utf8 && 0) // currently disabled, doesn't seem to work, nor is useful	436	if (enc_utf8 && 0) // currently disabled, doesn't seem to work, nor is useful
101	len = Xutf8LookupString (Input_Context, &ev, (char *)kbuf,	437	len = Xutf8LookupString (Input_Context, &ev, kbuf,
102	KBUFSZ, &keysym, &status_return);	438	KBUFSZ, &keysym, &status_return);
103	else	439	else
104	#endif	440	#endif
105	#endif	441	#endif
106	{	442	{
…		…
108		444
109	// the XOpenIM manpage lies about hardcoding the locale	445	// the XOpenIM manpage lies about hardcoding the locale
110	// at the point of XOpenIM, so temporarily switch locales	446	// at the point of XOpenIM, so temporarily switch locales
111	if (rs[Rs_imLocale])	447	if (rs[Rs_imLocale])
112	SET_LOCALE (rs[Rs_imLocale]);	448	SET_LOCALE (rs[Rs_imLocale]);
		449
113	// assume wchar_t == unicode or better	450	// assume wchar_t == unicode or better
114	len = XwcLookupString (Input_Context, &ev, wkbuf,	451	len = XwcLookupString (Input_Context, &ev, wkbuf,
115	KBUFSZ, &keysym, &status_return);	452	KBUFSZ, &keysym, &status_return);
		453
116	if (rs[Rs_imLocale])	454	if (rs[Rs_imLocale])
117	SET_LOCALE (locale);	455	SET_LOCALE (locale);
118		456
119	if (status_return == XLookupChars	457	if (status_return == XLookupChars
120	|| status_return == XLookupBoth)	458	|| status_return == XLookupBoth)
…		…
141	|| status_return == XLookupBoth;	479	|| status_return == XLookupBoth;
142	}	480	}
143	else	481	else
144	#endif	482	#endif
145	{	483	{
146	len = XLookupString (&ev, (char *)kbuf, KBUFSZ, &keysym, &compose);	484	len = XLookupString (&ev, kbuf, KBUFSZ, &keysym, &compose);
147	valid_keysym = keysym != NoSymbol;	485	valid_keysym = keysym != NoSymbol;
148	}	486	}
149		487
150	if (valid_keysym)	488	if (valid_keysym)
151	{	489	{
		490	#ifdef KEYSYM_RESOURCE
		491	if (keyboard->dispatch (this, keysym, ev.state))
		492	return;
		493	#endif
		494
152	if (TermWin.saveLines)	495	if (saveLines)
153	{	496	{
154	#ifdef UNSHIFTED_SCROLLKEYS	497	#ifdef UNSHIFTED_SCROLLKEYS
155	if (!ctrl && !meta)	498	if (!ctrl && !meta)
156	{
157	#else	499	#else
158	if (IS_SCROLL_MOD)	500	if (IS_SCROLL_MOD)
		501	#endif
159	{	502	{
160	#endif
161	int lnsppg;	503	int lnsppg;
162		504
163	#ifdef PAGING_CONTEXT_LINES	505	#ifdef PAGING_CONTEXT_LINES
164	lnsppg = TermWin.nrow - PAGING_CONTEXT_LINES;	506	lnsppg = nrow - PAGING_CONTEXT_LINES;
165	#else	507	#else
166	lnsppg = TermWin.nrow * 4 / 5;	508	lnsppg = nrow * 4 / 5;
167	#endif	509	#endif
		510	max_it (lnsppg, 1);
		511
168	if (keysym == XK_Prior)	512	if (keysym == XK_Prior)
169	{	513	{
170	scr_page (UP, lnsppg);	514	scr_page (UP, lnsppg);
171	return;	515	return;
172	}	516	}
…		…
199	scr_move_to (0, 1);	543	scr_move_to (0, 1);
200	return;	544	return;
201	}	545	}
202	else if (keysym == XK_End)	546	else if (keysym == XK_End)
203	{	547	{
204	scr_move_to (1, 0);	548	scr_move_to (1, 1);
205	return;	549	return;
206	}	550	}
207	}	551	}
208	#endif	552	#endif
209	}	553	}
…		…
214	if (keysym >= XK_F1 && keysym <= XK_F10)	558	if (keysym >= XK_F1 && keysym <= XK_F10)
215	{	559	{
216	keysym += (XK_F11 - XK_F1);	560	keysym += (XK_F11 - XK_F1);
217	shft = 0; /* turn off Shift */	561	shft = 0; /* turn off Shift */
218	}	562	}
219	else if (!ctrl && !meta && (PrivateModes & PrivMode_ShiftKeys))	563	else if (!ctrl && !meta && (priv_modes & PrivMode_ShiftKeys))
220	{	564	{
221	switch (keysym)	565	switch (keysym)
222	{	566	{
223	/* normal XTerm key bindings */	567	/* normal XTerm key bindings */
224	case XK_Insert: /* Shift+Insert = paste mouse selection */	568	case XK_Insert: /* Shift+Insert = paste mouse selection */
225	selection_request (ev.time, 0, 0);	569	selection_request (ev.time);
226	return;	570	return;
		571	#if TODO
227	/* rxvt extras */	572	/* rxvt extras */
228	case XK_KP_Add: /* Shift+KP_Add = bigger font */	573	case XK_KP_Add: /* Shift+KP_Add = bigger font */
229	change_font (FONT_UP);	574	change_font (FONT_UP);
230	return;	575	return;
231	case XK_KP_Subtract: /* Shift+KP_Subtract = smaller font */	576	case XK_KP_Subtract: /* Shift+KP_Subtract = smaller font */
232	change_font (FONT_DN);	577	change_font (FONT_DN);
233	return;	578	return;
		579	#endif
234	}	580	}
235	}	581	}
236	}	582	}
237	#ifdef PRINTPIPE	583
238	if (keysym == XK_Print)	584	#if ENABLE_FRILLS || ISO_14755
239	{	585	// ISO 14755 support
240	scr_printscreen (ctrl | shft);	586	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_51))
241	return;
242	}	587	{
243	#endif	588	int hv;
244		589
245	if (keysym >= 0xFF00 && keysym <= 0xFFFF)	590	if (iso14755buf & ISO_14755_51
246	{	591	&& (keysym == XK_space || keysym == XK_KP_Space
247	#ifdef KEYSYM_RESOURCE	592	|| keysym == XK_Return || keysym == XK_KP_Enter))
248	if (! (shft | ctrl) && Keysym_map[keysym & 0xFF] != NULL)
249	{	593	{
250	unsigned int l;	594	commit_iso14755 ();
251	const unsigned char *kbuf0;	595	iso14755buf = ISO_14755_51;
252		596	# if ISO_14755
253	kbuf0 = (Keysym_map[keysym & 0xFF]);	597	iso14755_51 (0);
254	l = (unsigned int)*kbuf0++;
255
256	/* escape prefix */
257	if (meta
258	# ifdef META8_OPTION
259	&& meta_char == C0_ESC
260	# endif	598	# endif
261	)	599	return;
262	{
263	const unsigned char ch = C0_ESC;
264	tt_write (&ch, 1);
265	}	600	}
266		601	else if (keysym == XK_BackSpace)
267	tt_write (kbuf0, l);	602	{
		603	iso14755buf = ((iso14755buf & ISO_14755_MASK) >> 4) | ISO_14755_51;
		604	# if ISO_14755
		605	iso14755_51 (iso14755buf & ISO_14755_MASK);
		606	# endif
		607	return;
		608	}
		609	else if ((hv = hex_keyval (ev)) >= 0)
		610	{
		611	iso14755buf = ((iso14755buf << 4) & ISO_14755_MASK)
		612	| hv | ISO_14755_51;
		613	# if ISO_14755
		614	iso14755_51 (iso14755buf & ISO_14755_MASK);
		615	# endif
268	return;	616	return;
269	}	617	}
270	else	618	else
271	#endif
272	{	619	{
273	newlen = 1;	620	# if ISO_14755
		621	scr_overlay_off ();
		622	# endif
		623	iso14755buf = 0;
		624	}
		625	}
		626	else if (option (Opt_iso14755) &&
		627	((ctrl && (keysym == XK_Shift_L || keysym == XK_Shift_R))
		628	|| (shft && (keysym == XK_Control_L || keysym == XK_Control_R))))
		629	if (!(iso14755buf & ISO_14755_STARTED))
		630	{
		631	iso14755buf |= ISO_14755_STARTED;
		632	# if ISO_14755
		633	scr_overlay_new (0, -1, sizeof ("ISO 14755 mode") - 1, 1);
		634	scr_overlay_set (0, 0, "ISO 14755 mode");
		635	# endif
		636	}
		637	#endif
		638
		639	#ifdef PRINTPIPE
		640	if (keysym == XK_Print)
		641	{
		642	scr_printscreen (ctrl | shft);
		643	return;
		644	}
		645	#endif
		646
		647	if (keysym >= 0xFF00 && keysym <= 0xFFFF)
		648	{
		649	bool kp = priv_modes & PrivMode_aplKP ? !shft : shft;
		650	unsigned int newlen = 1;
		651
		652	if (ev.state & ModNumLockMask)
		653	kp = false;
		654
		655	keysym = translate_keypad (keysym, kp);
		656
274	switch (keysym)	657	switch (keysym)
		658	{
		659	#ifndef NO_BACKSPACE_KEY
		660	case XK_BackSpace:
		661	if (priv_modes & PrivMode_HaveBackSpace)
		662	{
		663	kbuf[0] = (!! (priv_modes & PrivMode_BackSpace)
		664	^ !!ctrl) ? '\b' : '\177';
		665	kbuf[1] = '\0';
		666	}
		667	else
		668	strcpy (kbuf, rs[Rs_backspace_key]);
		669	break;
		670	#endif
		671	#ifndef NO_DELETE_KEY
		672	case XK_Delete:
		673	strcpy (kbuf, rs[Rs_delete_key]);
		674	break;
		675	#endif
		676	case XK_Tab:
		677	if (shft)
		678	strcpy (kbuf, "\033[Z");
		679	else
		680	{
		681	#ifdef CTRL_TAB_MAKES_META
		682	if (ctrl)
		683	meta = 1;
		684	#endif
		685	#ifdef MOD4_TAB_MAKES_META
		686	if (ev.state & Mod4Mask)
		687	meta = 1;
		688	#endif
		689	newlen = 0;
		690	}
		691	break;
		692
		693	case XK_Up: /* "\033[A" */
		694	case XK_Down: /* "\033[B" */
		695	case XK_Right: /* "\033[C" */
		696	case XK_Left: /* "\033[D" */
		697	strcpy (kbuf, "\033[Z");
		698	kbuf[2] = "DACB"[keysym - XK_Left];
		699	/* do Shift first */
		700	if (shft)
		701	kbuf[2] = "dacb"[keysym - XK_Left];
		702	else if (ctrl)
		703	{
		704	kbuf[1] = 'O';
		705	kbuf[2] = "dacb"[keysym - XK_Left];
		706	}
		707	else if (priv_modes & PrivMode_aplCUR)
		708	kbuf[1] = 'O';
		709	break;
		710
		711	case XK_KP_Enter:
		712	/* allow shift to override */
		713	if (kp)
		714	{
		715	strcpy (kbuf, "\033OM");
		716	break;
		717	}
		718
		719	/* FALLTHROUGH */
		720
		721	case XK_Return:
		722	if (priv_modes & PrivMode_LFNL)
		723	{
		724	kbuf[0] = '\015';
		725	kbuf[1] = '\012';
		726	kbuf[2] = '\0';
		727	}
		728	else
		729	{
		730	kbuf[0] = '\015';
		731	kbuf[1] = '\0';
		732	}
		733	break;
		734
		735	case XK_KP_F1: /* "\033OP" */
		736	case XK_KP_F2: /* "\033OQ" */
		737	case XK_KP_F3: /* "\033OR" */
		738	case XK_KP_F4: /* "\033OS" */
		739	strcpy (kbuf, "\033OP");
		740	kbuf[2] += (keysym - XK_KP_F1);
		741	break;
		742
		743	case XK_KP_Multiply: /* "\033Oj" : "*" */
		744	case XK_KP_Add: /* "\033Ok" : "+" */
		745	case XK_KP_Separator: /* "\033Ol" : "," */
		746	case XK_KP_Subtract: /* "\033Om" : "-" */
		747	case XK_KP_Decimal: /* "\033On" : "." */
		748	case XK_KP_Divide: /* "\033Oo" : "/" */
		749	case XK_KP_0: /* "\033Op" : "0" */
		750	case XK_KP_1: /* "\033Oq" : "1" */
		751	case XK_KP_2: /* "\033Or" : "2" */
		752	case XK_KP_3: /* "\033Os" : "3" */
		753	case XK_KP_4: /* "\033Ot" : "4" */
		754	case XK_KP_5: /* "\033Ou" : "5" */
		755	case XK_KP_6: /* "\033Ov" : "6" */
		756	case XK_KP_7: /* "\033Ow" : "7" */
		757	case XK_KP_8: /* "\033Ox" : "8" */
		758	case XK_KP_9: /* "\033Oy" : "9" */
		759	/* allow shift to override */
		760	if (kp)
		761	{
		762	strcpy (kbuf, "\033Oj");
		763	kbuf[2] += (keysym - XK_KP_Multiply);
		764	}
		765	else
		766	{
		767	kbuf[0] = ('*' + (keysym - XK_KP_Multiply));
		768	kbuf[1] = '\0';
		769	}
		770	break;
		771
		772	default:
275	{	773	{
276	#ifndef NO_BACKSPACE_KEY	774	int param = map_function_key (keysym);
277	case XK_BackSpace:	775	if (param > 0)
278	if (PrivateModes & PrivMode_HaveBackSpace)	776	sprintf (kbuf,"\033[%d~", param);
279	{
280	kbuf[0] = (!! (PrivateModes & PrivMode_BackSpace)
281	^ !!ctrl) ? '\b' : '\177';
282	kbuf[1] = '\0';
283	}
284	else	777	else
285	STRCPY (kbuf, key_backspace);
286	break;
287	#endif
288	#ifndef NO_DELETE_KEY
289	case XK_Delete:
290	STRCPY (kbuf, key_delete);
291	break;
292	#endif
293	case XK_Tab:
294	if (shft)
295	STRCPY (kbuf, "\033[Z");
296	else
297	{
298	#ifdef CTRL_TAB_MAKES_META
299	if (ctrl)
300	meta = 1;
301	#endif
302	#ifdef MOD4_TAB_MAKES_META
303	if (ev.state & Mod4Mask)
304	meta = 1;
305	#endif
306	newlen = 0;
307	}
308	break;
309
310	#ifdef XK_KP_Left
311	case XK_KP_Up: /* \033Ox or standard */
312	case XK_KP_Down: /* \033Or or standard */
313	case XK_KP_Right: /* \033Ov or standard */
314	case XK_KP_Left: /* \033Ot or standard */
315	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
316	{
317	STRCPY (kbuf, "\033OZ");
318	kbuf[2] = "txvr"[keysym - XK_KP_Left];
319	break;
320	}
321	else
322	/* translate to std. cursor key */
323	keysym = XK_Left + (keysym - XK_KP_Left);
324	/* FALLTHROUGH */
325	#endif
326	case XK_Up: /* "\033[A" */
327	case XK_Down: /* "\033[B" */
328	case XK_Right: /* "\033[C" */
329	case XK_Left: /* "\033[D" */
330	STRCPY (kbuf, "\033[Z");
331	kbuf[2] = "DACB"[keysym - XK_Left];
332	/* do Shift first */
333	if (shft)
334	kbuf[2] = "dacb"[keysym - XK_Left];
335	else if (ctrl)
336	{
337	kbuf[1] = 'O';
338	kbuf[2] = "dacb"[keysym - XK_Left];
339	}
340	else if (PrivateModes & PrivMode_aplCUR)
341	kbuf[1] = 'O';
342	break;
343
344	#ifndef UNSHIFTED_SCROLLKEYS
345	# ifdef XK_KP_Prior
346	case XK_KP_Prior:
347	/* allow shift to override */
348	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
349	{
350	STRCPY (kbuf, "\033Oy");
351	break;
352	}
353	/* FALLTHROUGH */
354	# endif
355	case XK_Prior:
356	STRCPY (kbuf, "\033[5~");
357	break;
358	# ifdef XK_KP_Next
359	case XK_KP_Next:
360	/* allow shift to override */
361	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
362	{
363	STRCPY (kbuf, "\033Os");
364	break;
365	}
366	/* FALLTHROUGH */
367	# endif
368	case XK_Next:
369	STRCPY (kbuf, "\033[6~");
370	break;
371	#endif
372	case XK_KP_Enter:
373	/* allow shift to override */
374	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
375	{
376	STRCPY (kbuf, "\033OM");
377	}
378	else
379	{
380	kbuf[0] = '\r';
381	kbuf[1] = '\0';
382	}
383	break;
384
385	#ifdef XK_KP_Begin
386	case XK_KP_Begin:
387	STRCPY (kbuf, "\033Ou");
388	break;
389
390	case XK_KP_Insert:
391	STRCPY (kbuf, "\033Op");
392	break;
393
394	case XK_KP_Delete:
395	STRCPY (kbuf, "\033On");
396	break;
397	#endif
398	case XK_KP_F1: /* "\033OP" */
399	case XK_KP_F2: /* "\033OQ" */
400	case XK_KP_F3: /* "\033OR" */
401	case XK_KP_F4: /* "\033OS" */
402	STRCPY (kbuf, "\033OP");
403	kbuf[2] += (keysym - XK_KP_F1);
404	break;
405
406	case XK_KP_Multiply: /* "\033Oj" : "*" */
407	case XK_KP_Add: /* "\033Ok" : "+" */
408	case XK_KP_Separator: /* "\033Ol" : "," */
409	case XK_KP_Subtract: /* "\033Om" : "-" */
410	case XK_KP_Decimal: /* "\033On" : "." */
411	case XK_KP_Divide: /* "\033Oo" : "/" */
412	case XK_KP_0: /* "\033Op" : "0" */
413	case XK_KP_1: /* "\033Oq" : "1" */
414	case XK_KP_2: /* "\033Or" : "2" */
415	case XK_KP_3: /* "\033Os" : "3" */
416	case XK_KP_4: /* "\033Ot" : "4" */
417	case XK_KP_5: /* "\033Ou" : "5" */
418	case XK_KP_6: /* "\033Ov" : "6" */
419	case XK_KP_7: /* "\033Ow" : "7" */
420	case XK_KP_8: /* "\033Ox" : "8" */
421	case XK_KP_9: /* "\033Oy" : "9" */
422	/* allow shift to override */
423	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
424	{
425	STRCPY (kbuf, "\033Oj");
426	kbuf[2] += (keysym - XK_KP_Multiply);
427	}
428	else
429	{
430	kbuf[0] = ('*' + (keysym - XK_KP_Multiply));
431	kbuf[1] = '\0';
432	}
433	break;
434
435	case XK_Find:
436	STRCPY (kbuf, "\033[1~");
437	break;
438	case XK_Insert:
439	STRCPY (kbuf, "\033[2~");
440	break;
441	#ifdef DXK_Remove /* support for DEC remove like key */
442	case DXK_Remove:
443	/* FALLTHROUGH */
444	#endif
445	case XK_Execute:
446	STRCPY (kbuf, "\033[3~");
447	break;
448	case XK_Select:
449	STRCPY (kbuf, "\033[4~");
450	break;
451	#ifdef XK_KP_End
452	case XK_KP_End:
453	/* allow shift to override */
454	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
455	{
456	STRCPY (kbuf, "\033Oq");
457	break;
458	}
459	/* FALLTHROUGH */
460	#endif
461	case XK_End:
462	STRCPY (kbuf, KS_END);
463	break;
464	#ifdef XK_KP_Home
465	case XK_KP_Home:
466	/* allow shift to override */
467	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
468	{
469	STRCPY (kbuf, "\033Ow");
470	break;
471	}
472	/* FALLTHROUGH */
473	#endif
474	case XK_Home:
475	STRCPY (kbuf, KS_HOME);
476	break;
477
478	#define FKEY(n, fkey) \
479	sprintf ((char *)kbuf,"\033[%2d~", (int) ((n) + (keysym - fkey)))
480
481	case XK_F1: /* "\033[11~" */
482	case XK_F2: /* "\033[12~" */
483	case XK_F3: /* "\033[13~" */
484	case XK_F4: /* "\033[14~" */
485	case XK_F5: /* "\033[15~" */
486	FKEY (11, XK_F1);
487	break;
488	case XK_F6: /* "\033[17~" */
489	case XK_F7: /* "\033[18~" */
490	case XK_F8: /* "\033[19~" */
491	case XK_F9: /* "\033[20~" */
492	case XK_F10: /* "\033[21~" */
493	FKEY (17, XK_F6);
494	break;
495	case XK_F11: /* "\033[23~" */
496	case XK_F12: /* "\033[24~" */
497	case XK_F13: /* "\033[25~" */
498	case XK_F14: /* "\033[26~" */
499	FKEY (23, XK_F11);
500	break;
501	case XK_F15: /* "\033[28~" */
502	case XK_F16: /* "\033[29~" */
503	FKEY (28, XK_F15);
504	break;
505	case XK_Help: /* "\033[28~" */
506	FKEY (28, XK_Help);
507	break;
508	case XK_Menu: /* "\033[29~" */
509	FKEY (29, XK_Menu);
510	break;
511	case XK_F17: /* "\033[31~" */
512	case XK_F18: /* "\033[32~" */
513	case XK_F19: /* "\033[33~" */
514	case XK_F20: /* "\033[34~" */
515	case XK_F21: /* "\033[35~" */
516	case XK_F22: /* "\033[36~" */
517	case XK_F23: /* "\033[37~" */
518	case XK_F24: /* "\033[38~" */
519	case XK_F25: /* "\033[39~" */
520	case XK_F26: /* "\033[40~" */
521	case XK_F27: /* "\033[41~" */
522	case XK_F28: /* "\033[42~" */
523	case XK_F29: /* "\033[43~" */
524	case XK_F30: /* "\033[44~" */
525	case XK_F31: /* "\033[45~" */
526	case XK_F32: /* "\033[46~" */
527	case XK_F33: /* "\033[47~" */
528	case XK_F34: /* "\033[48~" */
529	case XK_F35: /* "\033[49~" */
530	FKEY (31, XK_F17);
531	break;
532	#undef FKEY
533	default:
534	newlen = 0;	778	newlen = 0;
535	break;
536	}	779	}
537	if (newlen)	780	break;
538	len = STRLEN (kbuf);
539	}	781	}
		782
		783	if (newlen)
		784	len = strlen (kbuf);
540		785
541	/*	786	/*
542	* Pass meta for all function keys, if 'meta' option set	787	* Pass meta for all function keys, if 'meta' option set
543	*/	788	*/
544	#ifdef META8_OPTION	789	#ifdef META8_OPTION
…		…
550	else if (ctrl && keysym == XK_minus)	795	else if (ctrl && keysym == XK_minus)
551	{	796	{
552	len = 1;	797	len = 1;
553	kbuf[0] = '\037'; /* Ctrl-Minus generates ^_ (31) */	798	kbuf[0] = '\037'; /* Ctrl-Minus generates ^_ (31) */
554	}	799	}
		800	else if (keysym == XK_ISO_Left_Tab)
		801	{
		802	strcpy (kbuf, "\033[Z");
		803	len = 3;
		804	}
555	else	805	else
556	{	806	{
557	#ifdef META8_OPTION	807	#ifdef META8_OPTION
558	/* set 8-bit on */	808	/* set 8-bit on */
559	if (meta && (meta_char == 0x80))	809	if (meta && (meta_char == 0x80))
560	{	810	{
561	unsigned char *ch;	811	char *ch;
562		812
563	for (ch = kbuf; ch < kbuf + len; ch++)	813	for (ch = kbuf; ch < kbuf + len; ch++)
564	*ch |= 0x80;	814	*ch |= 0x80;
565		815
566	meta = 0;	816	meta = 0;
…		…
568	#endif	818	#endif
569	/* nil */ ;	819	/* nil */ ;
570	}	820	}
571	}	821	}
572		822
		823	if (HOOK_INVOKE ((this, HOOK_KEY_PRESS, DT_XEVENT, &ev, DT_INT, keysym, DT_STR_LEN, kbuf, len, DT_END)))
		824	return;
		825
573	if (len <= 0)	826	if (len <= 0)
574	return; /* not mapped */	827	return; /* not mapped */
575		828
576	if (Options & Opt_scrollTtyKeypress)	829	if (option (Opt_scrollTtyKeypress))
577	if (TermWin.view_start)	830	if (view_start)
578	{	831	{
579	TermWin.view_start = 0;	832	view_start = 0;
580	want_refresh = 1;	833	want_refresh = 1;
581	}	834	}
582		835
583	/*	836	/*
584	* these modifications only affect the static keybuffer	837	* these modifications only affect the static keybuffer
…		…
599	#ifdef META8_OPTION	852	#ifdef META8_OPTION
600	&& meta_char == C0_ESC	853	&& meta_char == C0_ESC
601	#endif	854	#endif
602	)	855	)
603	{	856	{
604	const unsigned char ch = C0_ESC;	857	const char ch = C0_ESC;
605	tt_write (&ch, 1);	858	tt_write (&ch, 1);
606	}	859	}
607		860
608	#if defined(DEBUG_CMD)
609	/* Display keyboard buffer contents */
610	unsigned char *p;
611	int i;
612
613	fprintf (stderr, "key 0x%04X [%d]: `", (unsigned int)keysym, len);
614	for (i = 0, p = kbuf; i < len; i++, p++)
615	fprintf (stderr, (*p >= ' ' && *p < '\177' ? "%c" : "\\%03o"), *p);
616	fprintf (stderr, "'\n");
617	#endif /* DEBUG_CMD */
618	tt_write (kbuf, (unsigned int)len);	861	tt_write (kbuf, (unsigned int)len);
619	}	862	}
620	/*}}} */
621		863
622	#if (MENUBAR_MAX)	864	void
623	/*{{{ rxvt_cmd_write (), rxvt_cmd_getc () */	865	rxvt_term::key_release (XKeyEvent &ev)
624	/* attempt to `write' count to the input buffer */	866	{
		867	#if (MOUSE_WHEEL && MOUSE_SLIP_WHEELING) || ISO_14755 || ENABLE_PERL
		868	KeySym keysym;
		869
		870	keysym = XLookupKeysym (&ev, ev.state & ShiftMask ? 1 : 0); // sorry, only shift supported :/
		871	#endif
		872
		873	#if ENABLE_FRILLS || ISO_14755
		874	// ISO 14755 support
		875	if (iso14755buf)
		876	if (iso14755buf & ISO_14755_52)
		877	{
		878	# if ISO_14755
		879	scr_overlay_off ();
		880	# endif
		881	# if ISO_14755
		882	// iso14755 part 5.2 handling: release time
		883	// first: controls
		884	if ((ev.state & ControlMask)
		885	&& ((keysym >= 0x40 && keysym <= 0x5f)
		886	|| (keysym >= 0x61 && keysym <= 0x7f)))
		887	{
		888	iso14755buf = ISO_14755_51 | 0x2400 | (keysym & 0x1f);
		889	commit_iso14755 ();
		890
		891	return;
		892	}
		893
		894	for (unsigned short *i = iso14755_symtab; i[0]; i += 2)
		895	if (i[0] == keysym)
		896	{
		897	iso14755buf = ISO_14755_51 | i[1];
		898	commit_iso14755 ();
		899
		900	return;
		901	}
		902
		903	scr_bell ();
		904	# endif
		905	iso14755buf = 0;
		906
		907	return;
		908	}
		909	else if ((ev.state & (ShiftMask | ControlMask)) != (ShiftMask | ControlMask))
		910	{
		911	# if ISO_14755
		912	scr_overlay_off ();
		913	# endif
		914	if (iso14755buf & ISO_14755_51)
		915	commit_iso14755 ();
		916	#if ISO_14755
		917	else if (option (Opt_iso14755_52) && iso14755buf & ISO_14755_STARTED)
		918	{
		919	iso14755buf = ISO_14755_52; // iso14755 part 5.2: remember empty begin/end pair
		920
		921	scr_overlay_new (0, -1, sizeof ("KEYCAP PICTURE INSERT MODE") - 1, 1);
		922	scr_overlay_set (0, 0, "KEYCAP PICTURE INSERT MODE");
		923	}
		924	# endif
		925	else
		926	iso14755buf = 0;
		927	}
		928	#endif
		929
		930	if (HOOK_INVOKE ((this, HOOK_KEY_RELEASE, DT_XEVENT, &ev, DT_INT, keysym, DT_END)))
		931	return;
		932
		933	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
		934	if (!(ev.state & ControlMask))
		935	slip_wheel_ev.stop ();
		936	else if (keysym == XK_Control_L || keysym == XK_Control_R)
		937	mouse_slip_wheel_speed = 0;
		938	#endif
		939	}
		940
		941	#if defined (KEYSYM_RESOURCE)
625	unsigned int	942	unsigned int
626	rxvt_term::cmd_write (const unsigned char *str, unsigned int count)	943	rxvt_term::cmd_write (const char *str, unsigned int count)
627	{	944	{
628	unsigned int n, s;	945	unsigned int n, s;
629		946
630	n = cmdbuf_ptr - cmdbuf_base;	947	n = cmdbuf_ptr - cmdbuf_base;
631	s = cmdbuf_base + CBUFSIZ - 1 - cmdbuf_endp;	948	s = cmdbuf_base + CBUFSIZ - 1 - cmdbuf_endp;
632		949
633	if (n > 0 && s < count)	950	if (n > 0 && s < count)
634	{	951	{
635	MEMMOVE (cmdbuf_base, cmdbuf_ptr,	952	memmove (cmdbuf_base, cmdbuf_ptr,
636	(unsigned int) (cmdbuf_endp - cmdbuf_ptr));	953	(unsigned int) (cmdbuf_endp - cmdbuf_ptr));
637	cmdbuf_ptr = cmdbuf_base;	954	cmdbuf_ptr = cmdbuf_base;
638	cmdbuf_endp -= n;	955	cmdbuf_endp -= n;
639	s += n;	956	s += n;
640	}	957	}
…		…
650		967
651	cmd_parse ();	968	cmd_parse ();
652		969
653	return 0;	970	return 0;
654	}	971	}
655	#endif /* MENUBAR_MAX */	972	#endif
656		973
657	void	974	void
658	rxvt_term::flush ()	975	rxvt_term::flush ()
659	{	976	{
660	#ifdef TRANSPARENT	977	flush_ev.stop ();
661	if (want_full_refresh)	978
		979	#ifdef HAVE_BG_PIXMAP
		980	if (bg_flags & hasChanged)
662	{	981	{
663	want_full_refresh = 0;	982	bg_flags &= ~hasChanged;
664	scr_clear ();
665	scr_touch (false);	983	scr_touch (false);
666	want_refresh = 1;
667	}	984	}
668	#endif	985	#endif
669		986
670	if (want_refresh)	987	if (want_refresh)
671	{	988	{
		989	if (SHOULD_INVOKE (HOOK_LINE_UPDATE))
		990	{
		991	int row = view_start;
		992	int end_row = row + nrow;
		993
		994	while (row > top_row && ROW (row - 1).is_longer ())
		995	--row;
		996
		997	do
		998	{
		999	int start_row = row;
		1000	line_t *l;
		1001
		1002	do
		1003	{
		1004	l = &ROW (row++);
		1005
		1006	if (!(l->f & LINE_FILTERED))
		1007	{
		1008	// line not filtered, mark it as filtered
		1009	l->f |= LINE_FILTERED;
		1010	while (l->is_longer ())
		1011	{
		1012	l = &ROW (row++);
		1013	l->f |= LINE_FILTERED;
		1014	}
		1015
		1016	// and filter it
		1017	HOOK_INVOKE ((this, HOOK_LINE_UPDATE, DT_INT, start_row, DT_END));
		1018
		1019	break;
		1020	}
		1021	}
		1022	while (l->is_longer () && row < end_row);
		1023	}
		1024	while (row < end_row);
		1025	}
		1026
672	scr_refresh (refresh_type);	1027	scr_refresh ();
673	scrollbar_show (1);	1028	scrollBar.show (1);
674	#ifdef USE_XIM	1029	#ifdef USE_XIM
675	IMSendSpot ();	1030	IMSendSpot ();
676	#endif	1031	#endif
677	}	1032	}
678		1033
679	display->flush ();	1034	display->flush ();
680	}	1035	}
681		1036
		1037	/* checks whether a refresh is requested and starts the refresh timer */
682	void	1038	void
683	rxvt_term::check_cb (check_watcher &w)	1039	rxvt_term::refresh_check ()
684	{	1040	{
685	SET_R (this);	1041	if (want_refresh && !flush_ev.is_active ())
686	SET_LOCALE (locale);	1042	flush_ev.start (1. / 60.); // refresh at max. 60 Hz normally
687		1043
		1044	display->flush ();
		1045	}
		1046
		1047	void
		1048	rxvt_term::flush_cb (ev::timer &w, int revents)
		1049	{
		1050	make_current ();
		1051
		1052	refresh_count = 0;
688	flush ();	1053	flush ();
689	}	1054	}
690		1055
691	#ifdef CURSOR_BLINK	1056	#ifdef CURSOR_BLINK
692	void	1057	void
693	rxvt_term::cursor_blink_cb (time_watcher &w)	1058	rxvt_term::cursor_blink_cb (ev::timer &w, int revents)
694	{	1059	{
695	hidden_cursor = !hidden_cursor;	1060	hidden_cursor = !hidden_cursor;
696	want_refresh = 1;	1061	want_refresh = 1;
697		1062	refresh_check ();
698	w.start (w.at + BLINK_INTERVAL);
699	}	1063	}
700	#endif	1064	#endif
701		1065
702	#ifdef TEXT_BLINK	1066	#ifdef TEXT_BLINK
703	void	1067	void
704	rxvt_term::text_blink_cb (time_watcher &w)	1068	rxvt_term::text_blink_cb (ev::timer &w, int revents)
705	{	1069	{
706	if (scr_refresh_rend (RS_Blink, RS_Blink))	1070	if (scr_refresh_rend (RS_Blink, RS_Blink))
707	{	1071	{
708	hidden_text = !hidden_text;	1072	hidden_text = !hidden_text;
709	want_refresh = 1;	1073	want_refresh = 1;
710	w.start (w.at + TEXT_BLINK_INTERVAL);	1074	refresh_check ();
711	}	1075	}
		1076	else
		1077	w.stop ();
712	}	1078	}
713	#endif	1079	#endif
714		1080
715	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING	1081	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
716	void	1082	void
717	rxvt_term::cont_scroll_cb (time_watcher &w)	1083	rxvt_term::cont_scroll_cb (ev::timer &w, int revents)
718	{	1084	{
719	if ((scrollbar_isUp() || scrollbar_isDn()) &&	1085	if ((scrollBar.state == STATE_UP || scrollBar.state == STATE_DOWN)
720	scr_page (scrollbar_isUp() ? UP : DN, 1))	1086	&& scr_page (scrollBar.state == STATE_UP ? UP : DN, 1))
721	{	1087	{
722	refresh_type |= SMOOTH_REFRESH;
723	want_refresh = 1;	1088	want_refresh = 1;
724	w.start (w.at + SCROLLBAR_CONTINUOUS_DELAY);	1089	refresh_check ();
725	}	1090	}
		1091	else
		1092	w.stop ();
726	}	1093	}
727	#endif	1094	#endif
728		1095
729	#ifdef SELECTION_SCROLLING	1096	#ifdef SELECTION_SCROLLING
730	void	1097	void
731	rxvt_term::sel_scroll_cb (time_watcher &w)	1098	rxvt_term::sel_scroll_cb (ev::timer &w, int revents)
732	{	1099	{
733	if (scr_page (scroll_selection_dir, scroll_selection_lines))	1100	if (scr_page (scroll_selection_dir, scroll_selection_lines))
734	{	1101	{
735	selection_extend (selection_save_x, selection_save_y, selection_save_state);	1102	selection_extend (selection_save_x, selection_save_y, selection_save_state);
736	refresh_type |= SMOOTH_REFRESH;
737	want_refresh = 1;	1103	want_refresh = 1;
738	w.start (w.at + SCROLLBAR_CONTINUOUS_DELAY);	1104	refresh_check ();
739	}	1105	}
		1106	else
		1107	w.stop ();
740	}	1108	}
741	#endif	1109	#endif
742		1110
743	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)	1111	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
744	void	1112	void
745	rxvt_term::slip_wheel_cb (time_watcher &w)	1113	rxvt_term::slip_wheel_cb (ev::timer &w, int revents)
746	{	1114	{
747	if (mouse_slip_wheel_speed == 0	1115	if (scr_changeview (view_start - mouse_slip_wheel_speed))
748	|| mouse_slip_wheel_speed < 0 ? scr_page (DN, -mouse_slip_wheel_speed)
749	: scr_page (UP, mouse_slip_wheel_speed))
750	{	1116	{
751	refresh_type |= SMOOTH_REFRESH;
752	want_refresh = 1;	1117	want_refresh = 1;
753	w.start (w.at + SCROLLBAR_CONTINUOUS_DELAY);	1118	refresh_check ();
		1119	}
		1120
		1121	if (view_start == top_row || view_start == 0 || mouse_slip_wheel_speed == 0)
754	}	1122	{
		1123	mouse_slip_wheel_speed = 0;
		1124	w.stop ();
		1125	}
755	}	1126	}
		1127	#endif
		1128
		1129	#if LINUX_YIELD_HACK
		1130	static struct event_handler
		1131	{
		1132	ev::prepare yield_ev;
		1133
		1134	void yield_cb (ev::prepare &w, int revents)
		1135	{
		1136	// this should really be sched_yield(), but the linux guys thought
		1137	// that giving a process calling sched_yield () less cpu time than
		1138	// ones with high nice levels is a useful thing to do. It surely is is
		1139	// allowed by the sus... as is returning ENOSYS.
		1140	// since the linux guys additionally thought that breaking the only
		1141	// known workaround against their unusable sched_yield hack is cool,
		1142	// we just nanosleep a bit and hope for the best.
		1143
		1144	struct timespec ts = { 0, 1000 };
		1145	nanosleep (&ts, 0);
		1146
		1147	w.stop ();
		1148	}
		1149
		1150	event_handler ()
		1151	: yield_ev (this, &event_handler::yield_cb)
		1152	{
		1153	}
		1154	} event_handler;
756	#endif	1155	#endif
757		1156
758	bool	1157	bool
759	rxvt_term::pty_fill ()	1158	rxvt_term::pty_fill ()
760	{	1159	{
761	ssize_t n = cmdbuf_endp - cmdbuf_ptr;	1160	ssize_t n = cmdbuf_endp - cmdbuf_ptr;
762		1161
763	if (CBUFSIZ == n)	1162	if (CBUFSIZ == n)
764	{	1163	{
765	rxvt_warn ("pty_fill on full buffer, draining input, continuing.\n");	1164	rxvt_warn ("PLEASE REPORT: pty_fill on full buffer, draining input, continuing.\n");
766	n = 0;	1165	n = 0;
767	}	1166	}
768		1167
769	memmove (cmdbuf_base, cmdbuf_ptr, n);	1168	memmove (cmdbuf_base, cmdbuf_ptr, n);
770	cmdbuf_ptr = cmdbuf_base;	1169	cmdbuf_ptr = cmdbuf_base;
771	cmdbuf_endp = cmdbuf_ptr + n;	1170	cmdbuf_endp = cmdbuf_ptr + n;
772		1171
773	n = read (cmd_fd, cmdbuf_endp, CBUFSIZ - n);	1172	ssize_t r = read (pty->pty, cmdbuf_endp, CBUFSIZ - n);
774		1173
775	if (n > 0)	1174	if (r > 0)
776	{	1175	{
777	cmdbuf_endp += n;	1176	cmdbuf_endp += r;
778	return true;	1177	return true;
779	}	1178	}
780	else if (n < 0 && errno != EAGAIN)	1179	else if (r < 0 && (errno == EAGAIN || errno == EINTR))
		1180	{
		1181	#if LINUX_YIELD_HACK
		1182	if (display->is_local)
		1183	event_handler.yield_ev.start ();
		1184	#endif
		1185	}
		1186	else
		1187	{
		1188	pty_ev.stop ();
		1189
		1190	if (!option (Opt_hold))
781	destroy ();	1191	destroy ();
782		1192	}
		1193
783	return false;	1194	return false;
784	}	1195	}
785		1196
786	void	1197	void
787	rxvt_term::pty_cb (io_watcher &w, short revents)	1198	rxvt_term::pty_cb (ev::io &w, int revents)
788	{	1199	{
789	SET_R (this);	1200	make_current ();
790	SET_LOCALE (locale);
791		1201
792	if (revents & EVENT_WRITE)	1202	if (revents & ev::READ)
793	tt_write (0, 0);
794	else if (revents & EVENT_READ)
795	// loop, but don't allow a single term to monopolize us	1203	// loop, but don't allow a single term to monopolize us
796	while (pty_fill ())	1204	for (int i = CBUFCNT; i-- && pty_fill (); )
797	if (cmd_parse ())	1205	cmd_parse ();
798	break;	1206
		1207	if (revents & ev::WRITE)
		1208	pty_write ();
		1209
		1210	refresh_check ();
799	}	1211	}
		1212
		1213	void
		1214	rxvt_term::pointer_unblank ()
		1215	{
		1216	XDefineCursor (dpy, vt, TermWin_cursor);
		1217	recolour_cursor ();
800		1218
801	#ifdef POINTER_BLANK	1219	#ifdef POINTER_BLANK
802	void
803	rxvt_term::pointer_unblank ()
804	{
805	XDefineCursor (display->display, TermWin.vt, TermWin_cursor);
806	recolour_cursor ();
807
808	hidden_pointer = 0;	1220	hidden_pointer = 0;
809		1221
810	if (Options & Opt_pointerBlank)	1222	if (option (Opt_pointerBlank))
811	pointer_ev.start (NOW + pointerBlankDelay);	1223	pointer_ev.start (pointerBlankDelay);
		1224	#endif
812	}	1225	}
813		1226
		1227	#ifdef POINTER_BLANK
814	void	1228	void
815	rxvt_term::pointer_blank ()	1229	rxvt_term::pointer_blank ()
816	{	1230	{
817	if (! (Options & Opt_pointerBlank))	1231	if (!option (Opt_pointerBlank))
818	return;	1232	return;
819		1233
820	XDefineCursor (display->display, TermWin.vt, blank_cursor);	1234	XDefineCursor (dpy, vt, display->blank_cursor);
821	XFlush (display->display);	1235	XFlush (dpy);
822		1236
823	hidden_pointer = 1;	1237	hidden_pointer = 1;
824	}	1238	}
825		1239
826	void	1240	void
827	rxvt_term::pointer_cb (time_watcher &w)	1241	rxvt_term::pointer_cb (ev::timer &w, int revents)
828	{	1242	{
829	SET_R (this);	1243	make_current ();
830	SET_LOCALE (locale);
831		1244
832	pointer_blank ();	1245	pointer_blank ();
833	}	1246	}
834	#endif	1247	#endif
835		1248
836	void	1249	void
837	rxvt_term::mouse_report (XButtonEvent &ev)	1250	rxvt_term::mouse_report (XButtonEvent &ev)
838	{	1251	{
839	int button_number, key_state = 0;	1252	int button_number, key_state = 0;
840	int x, y;	1253	int x, y;
		1254	int code = 32;
841		1255
842	x = ev.x;	1256	x = Pixel2Col (ev.x) + 1;
843	y = ev.y;	1257	y = Pixel2Row (ev.y) + 1;
844	pixel_position (&x, &y);	1258
		1259	if (ev.type == MotionNotify)
		1260	{
		1261	if (x == mouse_row && y == mouse_col)
		1262	return;
		1263
		1264	mouse_row = x;
		1265	mouse_col = y;
		1266	code += 32;
		1267	}
845		1268
846	if (MEvent.button == AnyButton)	1269	if (MEvent.button == AnyButton)
847	{
848	button_number = 3;	1270	button_number = 3;
849	}
850	else	1271	else
851	{	1272	{
852	button_number = MEvent.button - Button1;	1273	button_number = MEvent.button - Button1;
853	/* add 0x3D for wheel events, like xterm does */	1274	/* add 0x3D for wheel events, like xterm does */
854	if (button_number >= 3)	1275	if (button_number >= 3)
855	button_number += (64 - 3);	1276	button_number += 64 - 3;
856	}	1277	}
857		1278
858	if (PrivateModes & PrivMode_MouseX10)	1279	if (priv_modes & PrivMode_MouseX10)
859	{	1280	{
860	/*	1281	/*
861	* do not report ButtonRelease	1282	* do not report ButtonRelease
862	* no state info allowed	1283	* no state info allowed
863	*/	1284	*/
…		…
878	+ ((MEvent.state & ModMetaMask) ? 8 : 0)	1299	+ ((MEvent.state & ModMetaMask) ? 8 : 0)
879	+ ((MEvent.state & ControlMask) ? 16 : 0);	1300	+ ((MEvent.state & ControlMask) ? 16 : 0);
880	#ifdef MOUSE_REPORT_DOUBLECLICK	1301	#ifdef MOUSE_REPORT_DOUBLECLICK
881	key_state += ((MEvent.clicks > 1) ? 32 : 0);	1302	key_state += ((MEvent.clicks > 1) ? 32 : 0);
882	#endif	1303	#endif
883
884	}	1304	}
885		1305
886	#ifdef DEBUG_MOUSEREPORT	1306	#if DEBUG_MOUSEREPORT
887	fprintf (stderr, "Mouse [");	1307	fprintf (stderr, "Mouse [");
888	if (key_state & 16)	1308	if (key_state & 16)
889	fputc ('C', stderr);	1309	fputc ('C', stderr);
890	if (key_state & 4)	1310	if (key_state & 4)
891	fputc ('S', stderr);	1311	fputc ('S', stderr);
…		…
893	fputc ('A', stderr);	1313	fputc ('A', stderr);
894	if (key_state & 32)	1314	if (key_state & 32)
895	fputc ('2', stderr);	1315	fputc ('2', stderr);
896	fprintf (stderr, "]: <%d>, %d/%d\n",	1316	fprintf (stderr, "]: <%d>, %d/%d\n",
897	button_number,	1317	button_number,
898	x + 1,	1318	x,
899	y + 1);	1319	y);
900	#else	1320	#endif
		1321
		1322	#if ENABLE_FRILLS
		1323	if (priv_modes & PrivMode_ExtMouseRight)
		1324	tt_printf ("\033[%d;%d;%dM",
		1325	code + button_number + key_state,
		1326	x,
		1327	y);
		1328	else if (priv_modes & PrivMode_ExtModeMouse)
		1329	tt_printf ("\033[M%c%lc%lc",
		1330	code + button_number + key_state,
		1331	wint_t (32 + x),
		1332	wint_t (32 + y));
		1333	else
		1334	#endif
901	tt_printf ("\033[M%c%c%c",	1335	tt_printf ("\033[M%c%c%c",
902	(32 + button_number + key_state),	1336	code + button_number + key_state,
903	(32 + x + 1),	1337	32 + x,
904	(32 + y + 1));	1338	32 + y);
905	#endif
906	}	1339	}
907
908	#ifdef USING_W11LIB
909	void
910	rxvt_W11_process_x_event (XEvent *ev)
911	{
912	rxvt_t *r = rxvt_get_r ();
913
914	x_cb (*ev);
915	}
916	#endif
917		1340
918	/*{{{ process an X event */	1341	/*{{{ process an X event */
919	void	1342	void
920	rxvt_term::x_cb (XEvent &ev)	1343	rxvt_term::x_cb (XEvent &ev)
921	{	1344	{
922	SET_R (this);	1345	make_current ();
923	SET_LOCALE (locale);
924		1346
925	#if defined(CURSOR_BLINK)	1347	dLocal (Display *, dpy);
926	if ((Options & Opt_cursorBlink) && ev.type == KeyPress)
927	{
928	if (hidden_cursor)
929	{
930	hidden_cursor = 0;
931	want_refresh = 1;
932	}
933		1348
934	cursor_blink_ev.start (NOW + BLINK_INTERVAL);	1349	if (ev.xany.window == vt
935	}	1350	&& SHOULD_INVOKE (HOOK_X_EVENT)
936	#endif	1351	&& HOOK_INVOKE ((this, HOOK_X_EVENT, DT_XEVENT, &ev, DT_END)))
937
938	#if defined(POINTER_BLANK)
939	if ((Options & Opt_pointerBlank) && pointerBlankDelay > 0)
940	{
941	if (ev.type == MotionNotify
942	|| ev.type == ButtonPress
943	|| ev.type == ButtonRelease)
944	if (hidden_pointer)
945	pointer_unblank ();
946
947	if (ev.type == KeyPress && hidden_pointer == 0)
948	pointer_blank ();
949	}
950	#endif
951
952	#ifdef USE_XIM
953	if (XFilterEvent (&ev, None))
954	return;	1352	return;
955	#endif
956		1353
		1354	// for XQueryPointer
957	Window unused_root, unused_child;	1355	Window unused_root, unused_child;
958	int unused_root_x, unused_root_y;	1356	int unused_root_x, unused_root_y;
959	unsigned int unused_mask;	1357	unsigned int unused_mask;
960
961	#ifdef DEBUG_X
962	const char *const eventnames[] =
963	{ /* mason - this matches my system */
964	"",
965	"",
966	"KeyPress",
967	"KeyRelease",
968	"ButtonPress",
969	"ButtonRelease",
970	"MotionNotify",
971	"EnterNotify",
972	"LeaveNotify",
973	"FocusIn",
974	"FocusOut",
975	"KeymapNotify",
976	"Expose",
977	"GraphicsExpose",
978	"NoExpose",
979	"VisibilityNotify",
980	"CreateNotify",
981	"DestroyNotify",
982	"UnmapNotify",
983	"MapNotify",
984	"MapRequest",
985	"ReparentNotify",
986	"ConfigureNotify",
987	"ConfigureRequest",
988	"GravityNotify",
989	"ResizeRequest",
990	"CirculateNotify",
991	"CirculateRequest",
992	"PropertyNotify",
993	"SelectionClear",
994	"SelectionRequest",
995	"SelectionNotify",
996	"ColormapNotify",
997	"ClientMessage",
998	"MappingNotify"
999	};
1000	#endif
1001
1002	#ifdef DEBUG_X
1003	struct timeval tp;
1004	struct tm *ltt;
1005	(void)gettimeofday (&tp, NULL);
1006	ltt = localtime (& (tp.tv_sec));
1007	D_X ((stderr, "Event: %-16s %-7s %08lx (%4d-%02d-%02d %02d:%02d:%02d.%.6ld) %s %lu", eventnames[ev.type], (ev.xany.window == TermWin.parent[0] ? "parent" : (ev.xany.window == TermWin.vt ? "vt" : (ev.xany.window == scrollBar.win ? "scroll" : (ev.xany.window == menuBar.win ? "menubar" : "UNKNOWN")))), (ev.xany.window == TermWin.parent[0] ? TermWin.parent[0] : (ev.xany.window == TermWin.vt ? TermWin.vt : (ev.xany.window == scrollBar.win ? scrollBar.win : (ev.xany.window == menuBar.win ? menuBar.win : 0)))), ltt->tm_year + 1900, ltt->tm_mon + 1, ltt->tm_mday, ltt->tm_hour, ltt->tm_min, ltt->tm_sec, tp.tv_usec, ev.xany.send_event ? "S" : " ", ev.xany.serial));
1008	#endif
1009		1358
1010	switch (ev.type)	1359	switch (ev.type)
1011	{	1360	{
1012	case KeyPress:	1361	case KeyPress:
1013	lookup_key (ev.xkey);	1362	key_press (ev.xkey);
1014	break;	1363	break;
1015		1364
1016	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
1017	case KeyRelease:	1365	case KeyRelease:
1018	{	1366	key_release (ev.xkey);
1019	if (!(ev.xkey.state & ControlMask))
1020	slip_wheel_ev.stop ();
1021	else
1022	{
1023	KeySym ks;
1024
1025	ks = XKeycodeToKeysym (display->display, ev.xkey.keycode, 0);
1026	if (ks == XK_Control_L || ks == XK_Control_R)
1027	mouse_slip_wheel_speed = 0;
1028	}
1029	break;	1367	break;
1030	}
1031	#endif
1032		1368
1033	case ButtonPress:	1369	case ButtonPress:
1034	button_press (ev.xbutton);	1370	button_press (ev.xbutton);
1035	break;	1371	break;
1036		1372
…		…
1038	button_release (ev.xbutton);	1374	button_release (ev.xbutton);
1039	break;	1375	break;
1040		1376
1041	case ClientMessage:	1377	case ClientMessage:
1042	if (ev.xclient.format == 32	1378	if (ev.xclient.format == 32
1043	&& (Atom)ev.xclient.data.l[0] == xa[XA_WMDELETEWINDOW])	1379	&& !HOOK_INVOKE ((this, HOOK_CLIENT_MESSAGE, DT_XEVENT, &ev, DT_END)))
1044	destroy ();
1045	#ifdef OFFIX_DND
1046	/* OffiX Dnd (drag 'n' drop) protocol */
1047	else if (ev.xclient.message_type == xa[XA_DNDPROTOCOL]
1048	&& (ev.xclient.data.l[0] == DndFile
1049	|| ev.xclient.data.l[0] == DndDir
1050	|| ev.xclient.data.l[0] == DndLink))
1051	{	1380	{
1052	/* Get Dnd data */	1381	if (ev.xclient.message_type == xa[XA_WM_PROTOCOLS])
1053	Atom ActualType;	1382	{
1054	int ActualFormat;	1383	if (!HOOK_INVOKE ((this, HOOK_WM_PROTOCOLS, DT_XEVENT, &ev, DT_END)))
1055	unsigned char *data;	1384	{
1056	unsigned long Size, RemainingBytes;	1385	if (ev.xclient.data.l[0] == xa[XA_WM_DELETE_WINDOW])
1057		1386	{
1058	XGetWindowProperty (display->display, display->root,	1387	if (!HOOK_INVOKE ((this, HOOK_WM_DELETE_WINDOW, DT_XEVENT, &ev, DT_END)))
1059	xa[XA_DNDSELECTION],	1388	destroy ();
1060	0L, 1000000L,	1389	}
1061	False, AnyPropertyType,	1390	#if ENABLE_EWMH
1062	&ActualType, &ActualFormat,	1391	else if (ev.xclient.data.l[0] == xa[XA_NET_WM_PING])
1063	&Size, &RemainingBytes,	1392	XSendEvent (dpy, ev.xclient.window = display->root,
		1393	False, SubstructureRedirectMask | SubstructureNotifyMask,
1064	&data);	1394	&ev);
1065	XChangeProperty (display->display, display->root,	1395	#endif
1066	XA_CUT_BUFFER0, XA_STRING,	1396	}
1067	8, PropModeReplace,	1397	}
1068	data, STRLEN (data));	1398	#if ENABLE_XEMBED
1069	XFree (data);	1399	else if (ev.xclient.format == 32 && ev.xclient.message_type == xa[XA_XEMBED])
1070	selection_paste (display->root, XA_CUT_BUFFER0, True);	1400	{
1071	XSetInputFocus (display->display, display->root, RevertToNone, CurrentTime);	1401	if (ev.xclient.data.l[1] == XEMBED_FOCUS_IN)
		1402	focus_in ();
		1403	else if (ev.xclient.data.l[1] == XEMBED_FOCUS_OUT)
		1404	focus_out ();
		1405	}
		1406	#endif
1072	}	1407	}
1073	#endif /* OFFIX_DND */
1074	break;
1075
1076	case MappingNotify:
1077	XRefreshKeyboardMapping (& (ev.xmapping));
1078	break;	1408	break;
1079		1409
1080	/*	1410	/*
1081	* XXX: this is not the _current_ arrangement	1411	* XXX: this is not the _current_ arrangement
1082	* Here's my conclusion:	1412	* Here's my conclusion:
…		…
1101	break;	1431	break;
1102	}	1432	}
1103	break;	1433	break;
1104		1434
1105	case FocusIn:	1435	case FocusIn:
1106	if (!TermWin.focus)	1436	if (ev.xfocus.detail != NotifyInferior
		1437	&& ev.xfocus.detail != NotifyPointer
		1438	&& ev.xfocus.mode != NotifyGrab)
		1439	focus_in ();
		1440	break;
		1441
		1442	case FocusOut:
		1443	if (ev.xfocus.detail != NotifyInferior
		1444	&& ev.xfocus.detail != NotifyPointer
		1445	&& ev.xfocus.mode != NotifyGrab)
		1446	focus_out ();
		1447	break;
		1448
		1449	case ConfigureNotify:
		1450	if (ev.xconfigure.window == parent[0])
1107	{	1451	{
1108	TermWin.focus = 1;	1452	while (XCheckTypedWindowEvent (dpy, ev.xconfigure.window, ConfigureNotify, &ev))
1109	want_refresh = 1;
1110	#ifdef USE_XIM
1111	if (Input_Context != NULL)
1112	XSetICFocus (Input_Context);
1113	#endif
1114	#ifdef CURSOR_BLINK
1115	if (Options & Opt_cursorBlink)
1116	cursor_blink_ev.start (NOW + BLINK_INTERVAL);
1117	#endif
1118
1119	}	1453	;
1120	break;
1121		1454
1122	case FocusOut:	1455	#ifdef HAVE_BG_PIXMAP
1123	if (TermWin.focus)	1456	bool moved = false;
		1457	if (bg_window_position_sensitive ())
1124	{	1458	{
1125	TermWin.focus = 0;	1459	int x, y;
1126	want_refresh = 1;	1460	if (ev.xconfigure.send_event)
1127	#ifdef USE_XIM	1461	{
1128	if (Input_Context != NULL)
1129	XUnsetICFocus (Input_Context);
1130	#endif
1131	#ifdef CURSOR_BLINK
1132	if (Options & Opt_cursorBlink)
1133	cursor_blink_ev.stop ();
1134	hidden_cursor = 0;
1135	#endif
1136
1137	}
1138	break;
1139
1140	case ConfigureNotify:
1141	if (ev.xconfigure.window == TermWin.parent[0])
1142	{
1143	int height, width;
1144
1145	do
1146	{ /* Wrap lots of configures into one */
1147	width = ev.xconfigure.width;	1462	x = ev.xconfigure.x;
1148	height = ev.xconfigure.height;	1463	y = ev.xconfigure.y;
1149	D_SIZE ((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));	1464	}
		1465	else
		1466	get_window_origin (x, y);
		1467
		1468	if (bg_set_position (x, y)
		1469	|| !(bg_flags & isValid))
		1470	moved = true;
1150	}	1471	}
1151	while (XCheckTypedWindowEvent (display->display, ev.xconfigure.window, ConfigureNotify, &ev));	1472	#endif
1152		1473
1153	if (szHint.width != width || szHint.height != height)	1474	if (szHint.width != ev.xconfigure.width || szHint.height != ev.xconfigure.height)
1154	{	1475	{
1155	D_SIZE ((stderr, "Size: Resizing from: %4d x %4d", szHint.width, szHint.height));	1476	seen_resize = 1;
1156	resize_all_windows (width, height, 1);	1477	resize_all_windows (ev.xconfigure.width, ev.xconfigure.height, 1);
1157	}	1478	}
1158	#ifdef DEBUG_SIZE
1159	else	1479	else
1160	{	1480	{
1161	D_SIZE ((stderr, "Size: Not resizing"));	1481	#ifdef HAVE_BG_PIXMAP
		1482	if (moved)
		1483	{
		1484	if (mapped)
		1485	update_background ();
		1486	else
		1487	bg_invalidate ();
		1488	}
		1489	#endif
1162	}	1490	}
1163	#endif	1491
1164	#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */	1492	HOOK_INVOKE ((this, HOOK_CONFIGURE_NOTIFY, DT_XEVENT, &ev, DT_END));
1165	if (Options & Opt_transparent)
1166	{
1167	check_our_parents ();
1168	if (am_transparent)
1169	want_full_refresh = 1;
1170	}
1171	#endif
1172	}	1493	}
1173	break;	1494	break;
1174		1495
		1496	case PropertyNotify:
		1497	if (!HOOK_INVOKE ((this, HOOK_PROPERTY_NOTIFY, DT_XEVENT, &ev, DT_END)))
		1498	if (ev.xproperty.atom == xa[XA_VT_SELECTION]
		1499	&& ev.xproperty.state == PropertyNewValue)
		1500	selection_property (ev.xproperty.window, ev.xproperty.atom);
		1501
		1502	break;
		1503
1175	case SelectionClear:	1504	case SelectionClear:
1176	selection_clear ();	1505	selection_clear (ev.xselectionclear.selection == xa[XA_CLIPBOARD]);
1177	break;	1506	break;
1178		1507
1179	case SelectionNotify:	1508	case SelectionNotify:
1180	if (selection_wait == Sel_normal)	1509	if (selection_wait == Sel_normal)
1181	selection_paste (ev.xselection.requestor,	1510	selection_paste (ev.xselection.requestor, ev.xselection.property, true);
1182	ev.xselection.property, True);
1183	break;	1511	break;
1184		1512
1185	case SelectionRequest:	1513	case SelectionRequest:
1186	selection_send (ev.xselectionrequest);	1514	selection_send (ev.xselectionrequest);
1187	break;	1515	break;
1188		1516
		1517	case MapNotify:
		1518	#ifdef HAVE_BG_PIXMAP
		1519	/* This is needed specifically to fix the case of no window manager or a
		1520	* non-reparenting window manager. In those cases we never get first
		1521	* ConfigureNotify. Also that speeds startup under normal WM, by taking
		1522	* care of multiplicity of ConfigureNotify events arriving while WM does
		1523	* reparenting.
		1524	* We should not render background immediately, as there could be several
		1525	* ConfigureNotify's to follow. Lets take care of all of them in one scoop
		1526	* by scheduling background redraw as soon as we can, but giving a short
		1527	* bit of time for ConfigureNotifies to arrive.
		1528	* We should render background PRIOR to drawing any text, but AFTER all
		1529	* of ConfigureNotifys for the best results.
		1530	*/
		1531	if (!(bg_flags & isValid))
		1532	update_background_ev.start (0.025);
		1533	#endif
		1534	mapped = 1;
		1535	#ifdef TEXT_BLINK
		1536	text_blink_ev.start ();
		1537	#endif
		1538	HOOK_INVOKE ((this, HOOK_MAP_NOTIFY, DT_XEVENT, &ev, DT_END));
		1539	break;
		1540
1189	case UnmapNotify:	1541	case UnmapNotify:
1190	TermWin.mapped = 0;	1542	mapped = 0;
1191	#ifdef TEXT_BLINK	1543	#ifdef TEXT_BLINK
1192	text_blink_ev.stop ();	1544	text_blink_ev.stop ();
1193	#endif	1545	#endif
		1546	HOOK_INVOKE ((this, HOOK_UNMAP_NOTIFY, DT_XEVENT, &ev, DT_END));
1194	break;	1547	break;
1195
1196	case MapNotify:
1197	TermWin.mapped = 1;
1198	#ifdef TEXT_BLINK
1199	text_blink_ev.start (NOW + TEXT_BLINK_INTERVAL);
1200	#endif
1201	break;
1202
1203	#ifdef TRANSPARENT
1204	case ReparentNotify:
1205	rootwin_cb (ev);
1206	break;
1207	#endif /* TRANSPARENT */
1208		1548
1209	case GraphicsExpose:	1549	case GraphicsExpose:
1210	case Expose:	1550	case Expose:
1211	if (ev.xany.window == TermWin.vt)	1551	if (ev.xany.window == vt)
1212	{	1552	{
1213	#ifdef NO_SLOW_LINK_SUPPORT	1553	do
		1554	{
1214	scr_expose (ev.xexpose.x, ev.xexpose.y,	1555	scr_expose (ev.xexpose.x, ev.xexpose.y,
1215	ev.xexpose.width, ev.xexpose.height, False);	1556	ev.xexpose.width, ev.xexpose.height, False);
1216	#else	1557	}
1217	// I don't understand this, so I changed it :)	1558	while (XCheckTypedWindowEvent (dpy, vt, ev.xany.type, &ev));
		1559
		1560	ev.xany.type = ev.xany.type == Expose ? GraphicsExpose : Expose;
		1561
		1562	while (XCheckTypedWindowEvent (dpy, vt, ev.xany.type, &ev))
		1563	{
1218	scr_expose (ev.xexpose.x, ev.xexpose.y,	1564	scr_expose (ev.xexpose.x, ev.xexpose.y,
1219	ev.xexpose.width, ev.xexpose.height, False);	1565	ev.xexpose.width, ev.xexpose.height, False);
1220	//scr_expose (ev.xexpose.x, 0,	1566	}
1221	// ev.xexpose.width, TermWin.height, False);	1567
1222	#endif
1223	want_refresh = 1;	1568	want_refresh = 1;
1224	}	1569	}
1225	else	1570	else
1226	{	1571	{
1227	XEvent unused_event;	1572	XEvent unused_event;
1228		1573
1229	while (XCheckTypedWindowEvent (display->display, ev.xany.window, Expose, &unused_event))	1574	while (XCheckTypedWindowEvent (dpy, ev.xany.window, Expose, &unused_event))
1230	;	1575	;
1231	while (XCheckTypedWindowEvent (display->display, ev.xany.window, GraphicsExpose, &unused_event))	1576	while (XCheckTypedWindowEvent (dpy, ev.xany.window, GraphicsExpose, &unused_event))
1232	;	1577	;
1233		1578
1234	if (isScrollbarWindow (ev.xany.window))	1579	if (scrollBar.state && ev.xany.window == scrollBar.win)
1235	{	1580	{
1236	scrollBar.setIdle ();	1581	scrollBar.state = STATE_IDLE;
1237	scrollbar_show (0);	1582	scrollBar.show (0);
1238	}	1583	}
1239	#ifdef MENUBAR
1240	if (menubar_visible () && isMenuBarWindow (ev.xany.window))
1241	menubar_expose ();
1242	#endif
1243	}	1584	}
1244	break;	1585	break;
1245		1586
1246	case MotionNotify:	1587	case MotionNotify:
1247	#ifdef POINTER_BLANK	1588	#ifdef POINTER_BLANK
1248	if (hidden_pointer)	1589	if (hidden_pointer)
1249	pointer_unblank ();	1590	pointer_unblank ();
1250	#endif	1591	#endif
1251	#if MENUBAR	1592	if ((priv_modes & PrivMode_MouseBtnEvent && ev.xbutton.state & (Button1Mask|Button2Mask|Button3Mask))
1252	if (isMenuBarWindow (ev.xany.window))	1593	|| priv_modes & PrivMode_MouseAnyEvent)
		1594	mouse_report (ev.xbutton);
		1595	if ((priv_modes & PrivMode_mouse_report) && !bypass_keystate)
		1596	break;
		1597
		1598	if (ev.xany.window == vt)
1253	{	1599	{
1254	menubar_control (ev.xbutton);	1600	if (SHOULD_INVOKE (HOOK_MOTION_NOTIFY)
1255	break;	1601	&& HOOK_INVOKE ((this, HOOK_MOTION_NOTIFY, DT_XEVENT, &ev, DT_END)))
1256	}	1602	; // nop
1257	#endif
1258	if ((PrivateModes & PrivMode_mouse_report) && ! (bypass_keystate))
1259	break;
1260
1261	if (ev.xany.window == TermWin.vt)
1262	{
1263	if ((ev.xbutton.state & (Button1Mask | Button3Mask)))	1603	else if (ev.xbutton.state & (Button1Mask | Button3Mask))
1264	{	1604	{
1265	while (XCheckTypedWindowEvent (display->display, TermWin.vt, MotionNotify, &ev))	1605	while (XCheckTypedWindowEvent (dpy, vt, MotionNotify, &ev))
1266	;	1606	;
1267		1607
1268	XQueryPointer (display->display, TermWin.vt,	1608	XQueryPointer (dpy, vt,
1269	&unused_root, &unused_child,	1609	&unused_root, &unused_child,
1270	&unused_root_x, &unused_root_y,	1610	&unused_root_x, &unused_root_y,
1271	& (ev.xbutton.x), & (ev.xbutton.y),	1611	&ev.xbutton.x, &ev.xbutton.y,
1272	&unused_mask);	1612	&ev.xbutton.state);
1273	#ifdef MOUSE_THRESHOLD	1613	#ifdef MOUSE_THRESHOLD
1274	/* deal with a `jumpy' mouse */	1614	/* deal with a `jumpy' mouse */
1275	if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)	1615	if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)
1276	{	1616	{
1277	#endif	1617	#endif
		1618	#if ISO_14755
		1619	// 5.4
		1620	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
		1621	{
		1622	iso14755_54 (ev.xbutton.x, ev.xbutton.y);
		1623	break;
		1624	}
		1625	#endif
1278	selection_extend ((ev.xbutton.x), (ev.xbutton.y),	1626	selection_extend (ev.xbutton.x, ev.xbutton.y,
1279	(ev.xbutton.state & Button3Mask) ? 2 : 0);	1627	ev.xbutton.state & Button3Mask ? 2 : 0);
		1628
1280	#ifdef SELECTION_SCROLLING	1629	#ifdef SELECTION_SCROLLING
1281	if (ev.xbutton.y < TermWin.int_bwidth	1630	if (ev.xbutton.y < int_bwidth
1282	|| Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))	1631	|| Pixel2Row (ev.xbutton.y) > (nrow-1))
1283	{	1632	{
1284	int dist;	1633	int dist;
1285		1634
1286	/* don't clobber the current delay if we are	1635	/* don't clobber the current delay if we are
1287	* already in the middle of scrolling.	1636	* already in the middle of scrolling.
1288	*/	1637	*/
1289	if (!sel_scroll_ev.active)	1638	if (!sel_scroll_ev.is_active ())
1290	sel_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);	1639	sel_scroll_ev.start (SCROLLBAR_INITIAL_DELAY, SCROLLBAR_CONTINUOUS_DELAY);
1291		1640
1292	/* save the event params so we can highlight	1641	/* save the event params so we can highlight
1293	* the selection in the pending-scroll loop	1642	* the selection in the pending-scroll loop
1294	*/	1643	*/
1295	selection_save_x=ev.xbutton.x;	1644	selection_save_x = ev.xbutton.x;
1296	selection_save_y=ev.xbutton.y;	1645	selection_save_y = ev.xbutton.y;
1297	selection_save_state=
1298	(ev.xbutton.state & Button3Mask) ? 2 : 0;	1646	selection_save_state = (ev.xbutton.state & Button3Mask) ? 2 : 0;
1299		1647
1300	/* calc number of lines to scroll */	1648	/* calc number of lines to scroll */
1301	if (ev.xbutton.y<TermWin.int_bwidth)	1649	if (ev.xbutton.y < int_bwidth)
1302	{	1650	{
1303	scroll_selection_dir = UP;	1651	scroll_selection_dir = UP;
1304	dist = TermWin.int_bwidth - ev.xbutton.y;	1652	dist = int_bwidth - ev.xbutton.y;
1305	}	1653	}
1306	else	1654	else
1307	{	1655	{
1308	scroll_selection_dir = DN;	1656	scroll_selection_dir = DN;
1309	dist = ev.xbutton.y -	1657	dist = ev.xbutton.y - (int_bwidth + height);
1310	(TermWin.int_bwidth + TermWin.height);
1311	}	1658	}
		1659
1312	scroll_selection_lines= (Pixel2Height (dist)/	1660	scroll_selection_lines = Pixel2Height (dist)
1313	SELECTION_SCROLL_LINE_SPEEDUP)+1;	1661	/ SELECTION_SCROLL_LINE_SPEEDUP
		1662	+ 1;
1314	MIN_IT (scroll_selection_lines,	1663	min_it (scroll_selection_lines,
1315	SELECTION_SCROLL_MAX_LINES);	1664	SELECTION_SCROLL_MAX_LINES);
1316	}	1665	}
1317	else	1666	else
1318	{	1667	{
1319	/* we are within the text window, so we	1668	/* we are within the text window, so we
1320	* shouldn't be scrolling	1669	* shouldn't be scrolling
1321	*/	1670	*/
1322	if (sel_scroll_ev.active)
1323	sel_scroll_ev.stop();	1671	sel_scroll_ev.stop();
1324	}	1672	}
1325	#endif	1673	#endif
1326	#ifdef MOUSE_THRESHOLD	1674	#ifdef MOUSE_THRESHOLD
1327
1328	}	1675	}
1329	#endif	1676	#endif
1330
1331	}	1677	}
1332	}	1678	}
1333	else if (isScrollbarWindow (ev.xany.window) && scrollbar_isMotion ())	1679	else if (scrollBar.state == STATE_MOTION && ev.xany.window == scrollBar.win)
1334	{	1680	{
1335	while (XCheckTypedWindowEvent (display->display, scrollBar.win,	1681	while (XCheckTypedWindowEvent (dpy, scrollBar.win,
1336	MotionNotify, &ev)) ;	1682	MotionNotify, &ev))
		1683	;
		1684
1337	XQueryPointer (display->display, scrollBar.win,	1685	XQueryPointer (dpy, scrollBar.win,
1338	&unused_root, &unused_child,	1686	&unused_root, &unused_child,
1339	&unused_root_x, &unused_root_y,	1687	&unused_root_x, &unused_root_y,
1340	& (ev.xbutton.x), & (ev.xbutton.y),	1688	&ev.xbutton.x, &ev.xbutton.y,
1341	&unused_mask);	1689	&unused_mask);
1342	scr_move_to (scrollbar_position (ev.xbutton.y) - csrO,	1690	scr_move_to (scrollbar_position (ev.xbutton.y) - csrO,
1343	scrollbar_size ());	1691	scrollBar.size ());
1344	scr_refresh (refresh_type);
1345	refresh_limit = 0;	1692	want_refresh = 1;
1346	scrollbar_show (1);	1693	scrollBar.show (1);
1347	}	1694	}
1348	break;	1695	break;
1349	}	1696	}
1350	}
1351		1697
		1698	#if defined(CURSOR_BLINK)
		1699	if (option (Opt_cursorBlink) && ev.type == KeyPress)
		1700	{
		1701	if (hidden_cursor)
		1702	{
		1703	hidden_cursor = 0;
		1704	want_refresh = 1;
		1705	}
		1706
		1707	cursor_blink_ev.again ();
		1708	}
		1709	#endif
		1710
		1711	#if defined(POINTER_BLANK)
		1712	if (option (Opt_pointerBlank) && pointerBlankDelay > 0)
		1713	{
		1714	if (ev.type == MotionNotify
		1715	|| ev.type == ButtonPress
		1716	|| ev.type == ButtonRelease)
		1717	if (hidden_pointer)
		1718	pointer_unblank ();
		1719
		1720	if (ev.type == KeyPress && hidden_pointer == 0)
		1721	pointer_blank ();
		1722	}
		1723	#endif
		1724
		1725	refresh_check ();
		1726	}
		1727
		1728	#if ENABLE_FRILLS
		1729	void
		1730	rxvt_term::set_urgency (bool enable)
		1731	{
		1732	if (enable == urgency_hint)
		1733	return;
		1734
		1735	if (XWMHints *h = XGetWMHints (dpy, parent[0]))
		1736	{
		1737	h->flags = h->flags & ~XUrgencyHint | (enable ? XUrgencyHint : 0);
		1738	XSetWMHints (dpy, parent[0], h);
		1739	urgency_hint = enable;
		1740	}
		1741	}
		1742	#endif
		1743
		1744	void
		1745	rxvt_term::focus_in ()
		1746	{
		1747	if (!focus)
		1748	{
		1749	focus = 1;
		1750	want_refresh = 1;
		1751
		1752	#if USE_XIM
		1753	if (Input_Context != NULL)
		1754	{
		1755	IMSetPosition ();
		1756	XSetICFocus (Input_Context);
		1757	}
		1758	#endif
		1759	#if CURSOR_BLINK
		1760	if (option (Opt_cursorBlink))
		1761	cursor_blink_ev.again ();
		1762	#endif
		1763	#if OFF_FOCUS_FADING
		1764	if (rs[Rs_fade])
		1765	{
		1766	pix_colors = pix_colors_focused;
		1767	scr_recolour ();
		1768	}
		1769	#endif
		1770	#if ENABLE_FRILLS
		1771	if (option (Opt_urgentOnBell))
		1772	set_urgency (0);
		1773	#endif
		1774
		1775	HOOK_INVOKE ((this, HOOK_FOCUS_IN, DT_END));
		1776	}
		1777	}
		1778
		1779	void
		1780	rxvt_term::focus_out ()
		1781	{
		1782	if (focus)
		1783	{
		1784	focus = 0;
		1785	want_refresh = 1;
		1786
		1787	#if ENABLE_FRILLS
		1788	if (option (Opt_urgentOnBell))
		1789	set_urgency (0);
		1790	#endif
		1791	#if ENABLE_FRILLS || ISO_14755
		1792	if (iso14755buf)
		1793	{
		1794	iso14755buf = 0;
		1795	# if ISO_14755
		1796	scr_overlay_off ();
		1797	# endif
		1798	}
		1799	#endif
		1800	#if USE_XIM
		1801	if (Input_Context != NULL)
		1802	XUnsetICFocus (Input_Context);
		1803	#endif
		1804	#if CURSOR_BLINK
		1805	if (option (Opt_cursorBlink))
		1806	cursor_blink_ev.stop ();
		1807
		1808	hidden_cursor = 0;
		1809	#endif
		1810	#if OFF_FOCUS_FADING
		1811	if (rs[Rs_fade])
		1812	{
		1813	pix_colors = pix_colors_unfocused;
		1814	scr_recolour ();
		1815	}
		1816	#endif
		1817
		1818	HOOK_INVOKE ((this, HOOK_FOCUS_OUT, DT_END));
		1819	}
		1820	}
		1821
		1822	void
		1823	rxvt_term::update_fade_color (unsigned int idx)
		1824	{
		1825	#if OFF_FOCUS_FADING
		1826	if (rs[Rs_fade])
		1827	{
		1828	rgba c;
		1829	pix_colors [Color_fade].get (c);
		1830	pix_colors_focused [idx].fade (this, atoi (rs[Rs_fade]), pix_colors_unfocused [idx], c);
		1831	}
		1832	#endif
		1833	}
		1834
		1835	#if ENABLE_TRANSPARENCY || ENABLE_PERL
1352	void	1836	void
1353	rxvt_term::rootwin_cb (XEvent &ev)	1837	rxvt_term::rootwin_cb (XEvent &ev)
1354	{	1838	{
1355	SET_R (this);	1839	make_current ();
1356	SET_LOCALE (locale);
1357		1840
		1841	if (SHOULD_INVOKE (HOOK_ROOT_EVENT)
		1842	&& HOOK_INVOKE ((this, HOOK_ROOT_EVENT, DT_XEVENT, &ev, DT_END)))
		1843	return;
		1844
		1845	# if ENABLE_TRANSPARENCY
1358	switch (ev.type)	1846	switch (ev.type)
1359	{	1847	{
1360	case PropertyNotify:	1848	case PropertyNotify:
		1849	/*
		1850	* if user used some Esetroot compatible prog to set the root bg,
		1851	* use the property to determine the pixmap. We use it later on.
		1852	*/
1361	if (ev.xproperty.atom == xa[XA_VT_SELECTION])	1853	if (ev.xproperty.atom == xa[XA_XROOTPMAP_ID]
		1854	|| ev.xproperty.atom == xa[XA_ESETROOT_PMAP_ID])
1362	{	1855	{
1363	if (ev.xproperty.state == PropertyNewValue)	1856	bg_set_root_pixmap ();
1364	selection_property (ev.xproperty.window, ev.xproperty.atom);	1857	update_background ();
1365	break;
1366	}	1858	}
1367	#ifdef TRANSPARENT
1368	else
1369	{
1370	/*
1371	* if user used some Esetroot compatible prog to set the root bg,
1372	* use the property to determine the pixmap. We use it later on.
1373	*/
1374	if (xa[XA_XROOTPMAPID] == 0)
1375	xa[XA_XROOTPMAPID] = XInternAtom (display->display, "_XROOTPMAP_ID", False);
1376		1859
1377	if (ev.xproperty.atom != xa[XA_XROOTPMAPID])
1378	return;
1379	}
1380
1381	/* FALLTHROUGH */
1382	case ReparentNotify:
1383	if ((Options & Opt_transparent) && check_our_parents () && am_transparent)
1384	want_full_refresh = 1;
1385	break;	1860	break;
		1861	}
1386	#endif	1862	# endif
1387	}	1863
		1864	refresh_check ();
1388	}	1865	}
		1866	#endif
1389		1867
1390	void	1868	void
1391	rxvt_term::button_press (XButtonEvent &ev)	1869	rxvt_term::button_press (XButtonEvent &ev)
1392	{	1870	{
1393	int reportmode = 0, clickintime;	1871	int reportmode = 0, clickintime;
1394		1872
1395	bypass_keystate = ev.state & (ModMetaMask | ShiftMask);	1873	bypass_keystate = ev.state & (ModMetaMask | ShiftMask);
		1874
1396	if (!bypass_keystate)	1875	if (!bypass_keystate)
1397	reportmode = !! (PrivateModes & PrivMode_mouse_report);	1876	reportmode = !! (priv_modes & PrivMode_mouse_report);
		1877
1398	/*	1878	/*
1399	* VT window processing of button press	1879	* VT window processing of button press
1400	*/	1880	*/
1401	if (ev.window == TermWin.vt)	1881	if (ev.window == vt)
1402	{	1882	{
		1883	if (HOOK_INVOKE ((this, HOOK_BUTTON_PRESS, DT_XEVENT, &ev, DT_END)))
		1884	return;
		1885
		1886	#if ISO_14755
		1887	// 5.4
		1888	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
		1889	{
		1890	iso14755_54 (ev.x, ev.y);
		1891	return;
		1892	}
		1893	#endif
		1894
1403	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;	1895	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;
		1896
1404	if (reportmode)	1897	if (reportmode)
1405	{	1898	{
1406	/* mouse report from vt window */	1899	/* mouse report from vt window */
1407	/* save the xbutton state (for ButtonRelease) */	1900	/* save the xbutton state (for ButtonRelease) */
1408	MEvent.state = ev.state;	1901	MEvent.state = ev.state;
1409	#ifdef MOUSE_REPORT_DOUBLECLICK	1902	#ifdef MOUSE_REPORT_DOUBLECLICK
1410	if (ev.button == MEvent.button && clickintime)	1903	if (ev.button == MEvent.button && clickintime)
1411	{	1904	{
1412	/* same button, within alloted time */	1905	/* same button, within allowed time */
1413	MEvent.clicks++;	1906	MEvent.clicks++;
		1907
1414	if (MEvent.clicks > 1)	1908	if (MEvent.clicks > 1)
1415	{	1909	{
1416	/* only report double clicks */	1910	/* only report double clicks */
1417	MEvent.clicks = 2;	1911	MEvent.clicks = 2;
1418	mouse_report (ev);	1912	mouse_report (ev);
…		…
1430	mouse_report (ev);	1924	mouse_report (ev);
1431	}	1925	}
1432	#else	1926	#else
1433	MEvent.button = ev.button;	1927	MEvent.button = ev.button;
1434	mouse_report (ev);	1928	mouse_report (ev);
1435	#endif /* MOUSE_REPORT_DOUBLECLICK */	1929	#endif /* MOUSE_REPORT_DOUBLECLICK */
1436		1930
1437	}	1931	}
1438	else	1932	else
1439	{	1933	{
1440	if (ev.button != MEvent.button)	1934	if (ev.button != MEvent.button)
1441	MEvent.clicks = 0;	1935	MEvent.clicks = 0;
		1936
1442	switch (ev.button)	1937	switch (ev.button)
1443	{	1938	{
1444	case Button1:	1939	case Button1:
		1940	/* allow meta + click to select rectangular areas */
		1941	/* should be done in screen.C */
		1942	#if ENABLE_FRILLS
		1943	selection.rect = !!(ev.state & ModMetaMask);
		1944	#else
		1945	selection.rect = false;
		1946	#endif
		1947
1445	/* allow shift+left click to extend selection */	1948	/* allow shift+left click to extend selection */
1446	if (ev.state & ShiftMask && ! (PrivateModes & PrivMode_mouse_report))	1949	if (ev.state & ShiftMask && !(priv_modes & PrivMode_mouse_report))
1447	{	1950	{
1448	if (MEvent.button == Button1 && clickintime)	1951	if (MEvent.button == Button1 && clickintime)
1449	selection_rotate (ev.x, ev.y);	1952	selection_rotate (ev.x, ev.y);
1450	else	1953	else
1451	selection_extend (ev.x, ev.y, 1);	1954	selection_extend (ev.x, ev.y, 1);
…		…
1466	case Button3:	1969	case Button3:
1467	if (MEvent.button == Button3 && clickintime)	1970	if (MEvent.button == Button3 && clickintime)
1468	selection_rotate (ev.x, ev.y);	1971	selection_rotate (ev.x, ev.y);
1469	else	1972	else
1470	selection_extend (ev.x, ev.y, 1);	1973	selection_extend (ev.x, ev.y, 1);
		1974
1471	MEvent.button = Button3;	1975	MEvent.button = Button3;
1472	break;	1976	break;
1473	}	1977	}
1474	}	1978	}
		1979
1475	MEvent.time = ev.time;	1980	MEvent.time = ev.time;
1476	return;	1981	return;
1477	}	1982	}
1478		1983
1479	/*	1984	/*
1480	* Scrollbar window processing of button press	1985	* Scrollbar window processing of button press
1481	*/	1986	*/
1482	if (isScrollbarWindow (ev.window))	1987	if (scrollBar.state && ev.window == scrollBar.win)
1483	{	1988	{
1484	scrollBar.setIdle ();	1989	page_dirn direction = NO_DIR;
		1990
		1991	if (scrollBar.upButton (ev.y))
		1992	direction = UP; /* up */
		1993	else if (scrollBar.dnButton (ev.y))
		1994	direction = DN; /* down */
		1995
		1996	scrollBar.state = STATE_IDLE;
1485	/*	1997	/*
1486	* Rxvt-style scrollbar:	1998	* Rxvt-style scrollbar:
1487	* move up if mouse is above slider	1999	* move up if mouse is above slider
1488	* move dn if mouse is below slider	2000	* move dn if mouse is below slider
1489	*	2001	*
…		…
1498	/*	2010	/*
1499	* Mouse report disabled scrollbar:	2011	* Mouse report disabled scrollbar:
1500	* arrow buttons - send up/down	2012	* arrow buttons - send up/down
1501	* click on scrollbar - send pageup/down	2013	* click on scrollbar - send pageup/down
1502	*/	2014	*/
1503	if ((scrollBar.style == R_SB_NEXT	2015	if (direction == UP)
1504	&& scrollbarnext_upButton (ev.y))
1505	|| (scrollBar.style == R_SB_RXVT
1506	&& scrollbarrxvt_upButton (ev.y)))
1507	tt_printf ("\033[A");	2016	tt_printf ("\033[A");
1508	else if ((scrollBar.style == R_SB_NEXT	2017	else if (direction == DN)
1509	&& scrollbarnext_dnButton (ev.y))
1510	|| (scrollBar.style == R_SB_RXVT
1511	&& scrollbarrxvt_dnButton (ev.y)))
1512	tt_printf ("\033[B");	2018	tt_printf ("\033[B");
1513	else	2019	else
1514	switch (ev.button)	2020	switch (ev.button)
1515	{	2021	{
1516	case Button2:	2022	case Button2:
…		…
1523	tt_printf ("\033[5~");	2029	tt_printf ("\033[5~");
1524	break;	2030	break;
1525	}	2031	}
1526	}	2032	}
1527	else	2033	else
1528	#endif /* NO_SCROLLBAR_REPORT */	2034	#endif /* NO_SCROLLBAR_REPORT */
1529
1530	{
1531	char upordown = 0;
1532
1533	if (scrollBar.style == R_SB_NEXT)
1534	{	2035	{
1535	if (scrollbarnext_upButton (ev.y))	2036	if (direction != NO_DIR)
1536	upordown = -1; /* up */
1537	else if (scrollbarnext_dnButton (ev.y))
1538	upordown = 1; /* down */
1539	}
1540	else if (scrollBar.style == R_SB_RXVT)
1541	{
1542	if (scrollbarrxvt_upButton (ev.y))
1543	upordown = -1; /* up */
1544	else if (scrollbarrxvt_dnButton (ev.y))
1545	upordown = 1; /* down */
1546	}
1547	if (upordown)
1548	{	2037	{
1549	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING	2038	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
		2039	if (!cont_scroll_ev.is_active ())
1550	cont_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);	2040	cont_scroll_ev.start (SCROLLBAR_INITIAL_DELAY, SCROLLBAR_CONTINUOUS_DELAY);
1551	#endif	2041	#endif
1552	if (scr_page (upordown < 0 ? UP : DN, 1))	2042	if (scr_page (direction, 1))
1553	{	2043	{
1554	if (upordown < 0)	2044	if (direction == UP)
1555	scrollBar.setUp ();	2045	scrollBar.state = STATE_UP;
1556	else	2046	else
1557	scrollBar.setDn ();	2047	scrollBar.state = STATE_DOWN;
1558	}	2048	}
1559	}	2049	}
1560	else	2050	else
1561	switch (ev.button)	2051	switch (ev.button)
1562	{	2052	{
1563	case Button2:	2053	case Button2:
1564	switch (scrollbar_align)	2054	switch (scrollBar.align)
1565	{	2055	{
1566	case R_SB_ALIGN_TOP:	2056	case R_SB_ALIGN_TOP:
1567	csrO = 0;	2057	csrO = 0;
1568	break;	2058	break;
1569	case R_SB_ALIGN_CENTRE:	2059	case R_SB_ALIGN_CENTRE:
…		…
1571	break;	2061	break;
1572	case R_SB_ALIGN_BOTTOM:	2062	case R_SB_ALIGN_BOTTOM:
1573	csrO = scrollBar.bot - scrollBar.top;	2063	csrO = scrollBar.bot - scrollBar.top;
1574	break;	2064	break;
1575	}	2065	}
		2066
1576	if (scrollBar.style == R_SB_XTERM	2067	if (scrollBar.style == R_SB_XTERM
1577	|| scrollbar_above_slider (ev.y)	2068	|| scrollbar_above_slider (ev.y)
1578	|| scrollbar_below_slider (ev.y))	2069	|| scrollbar_below_slider (ev.y))
1579	scr_move_to ( scrollbar_position (ev.y) - csrO,	2070	scr_move_to (scrollbar_position (ev.y) - csrO, scrollBar.size ());
1580	scrollbar_size ());	2071
1581	scrollBar.setMotion ();	2072	scrollBar.state = STATE_MOTION;
1582	break;	2073	break;
1583		2074
1584	case Button1:	2075	case Button1:
1585	if (scrollbar_align == R_SB_ALIGN_CENTRE)	2076	if (scrollBar.align == R_SB_ALIGN_CENTRE)
1586	csrO = ev.y - scrollBar.top;	2077	csrO = ev.y - scrollBar.top;
1587	/* FALLTHROUGH */	2078	/* FALLTHROUGH */
1588		2079
1589	case Button3:	2080	case Button3:
1590	if (scrollBar.style != R_SB_XTERM)	2081	if (scrollBar.style != R_SB_XTERM)
1591	{	2082	{
1592	if (scrollbar_above_slider (ev.y))	2083	if (scrollbar_above_slider (ev.y))
1593	# ifdef RXVT_SCROLL_FULL	2084	# ifdef RXVT_SCROLL_FULL
1594	scr_page (UP, TermWin.nrow - 1);	2085	scr_page (UP, nrow - 1);
1595	# else	2086	# else
1596	scr_page (UP, TermWin.nrow / 4);	2087	scr_page (UP, nrow / 4);
1597	# endif	2088	# endif
1598	else if (scrollbar_below_slider (ev.y))	2089	else if (scrollbar_below_slider (ev.y))
1599	# ifdef RXVT_SCROLL_FULL	2090	# ifdef RXVT_SCROLL_FULL
1600	scr_page (DN, TermWin.nrow - 1);	2091	scr_page (DN, nrow - 1);
1601	# else	2092	# else
1602	scr_page (DN, TermWin.nrow / 4);	2093	scr_page (DN, nrow / 4);
1603	# endif	2094	# endif
1604	else	2095	else
1605	scrollBar.setMotion ();	2096	scrollBar.state = STATE_MOTION;
1606	}	2097	}
1607	else	2098	else
1608	{	2099	{
1609	scr_page ((ev.button == Button1 ? DN : UP),	2100	scr_page ((ev.button == Button1 ? DN : UP),
1610	(TermWin.nrow	2101	(nrow
1611	* scrollbar_position (ev.y)	2102	* scrollbar_position (ev.y)
1612	/ scrollbar_size ()));	2103	/ scrollBar.size ()));
1613	}	2104	}
		2105
1614	break;	2106	break;
1615	}	2107	}
1616	}	2108	}
		2109
1617	return;	2110	return;
1618	}	2111	}
1619	#if MENUBAR
1620	/*
1621	* Menubar window processing of button press
1622	*/
1623	if (isMenuBarWindow (ev.window))
1624	menubar_control (ev);
1625	#endif
1626	}	2112	}
1627		2113
1628	void	2114	void
1629	rxvt_term::button_release (XButtonEvent &ev)	2115	rxvt_term::button_release (XButtonEvent &ev)
1630	{	2116	{
1631	int reportmode = 0;	2117	int reportmode = 0;
1632		2118
1633	csrO = 0; /* reset csr Offset */	2119	csrO = 0; /* reset csr Offset */
1634	if (!bypass_keystate)	2120	if (!bypass_keystate)
1635	reportmode = !! (PrivateModes & PrivMode_mouse_report);	2121	reportmode = !! (priv_modes & PrivMode_mouse_report);
1636		2122
1637	if (scrollbar_isUpDn ())	2123	if (scrollBar.state == STATE_UP || scrollBar.state == STATE_DOWN)
1638	{	2124	{
1639	scrollBar.setIdle ();	2125	scrollBar.state = STATE_IDLE;
1640	scrollbar_show (0);	2126	scrollBar.show (0);
1641	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1642	refresh_type &= ~SMOOTH_REFRESH;
1643	#endif
1644
1645	}	2127	}
		2128
1646	#ifdef SELECTION_SCROLLING	2129	#ifdef SELECTION_SCROLLING
1647	if (sel_scroll_ev.active)
1648	sel_scroll_ev.stop();	2130	sel_scroll_ev.stop();
1649	#endif	2131	#endif
		2132
1650	if (ev.window == TermWin.vt)	2133	if (ev.window == vt)
1651	{	2134	{
		2135	if (HOOK_INVOKE ((this, HOOK_BUTTON_RELEASE, DT_XEVENT, &ev, DT_END)))
		2136	return;
		2137
		2138	#if ISO_14755
		2139	// 5.4
		2140	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
		2141	return;
		2142	#endif
		2143
1652	if (reportmode)	2144	if (reportmode)
1653	{	2145	{
1654	/* mouse report from vt window */	2146	/* mouse report from vt window */
1655	/* don't report release of wheel "buttons" */	2147	/* don't report release of wheel "buttons" */
1656	if (ev.button >= 4)	2148	if (ev.button >= 4)
…		…
1667	mouse_report (ev);	2159	mouse_report (ev);
1668	}	2160	}
1669	#else /* MOUSE_REPORT_DOUBLECLICK */	2161	#else /* MOUSE_REPORT_DOUBLECLICK */
1670	MEvent.button = AnyButton;	2162	MEvent.button = AnyButton;
1671	mouse_report (ev);	2163	mouse_report (ev);
1672	#endif /* MOUSE_REPORT_DOUBLECLICK */	2164	#endif /* MOUSE_REPORT_DOUBLECLICK */
1673	return;	2165	return;
1674	}	2166	}
		2167
1675	/*	2168	/*
1676	* dumb hack to compensate for the failure of click-and-drag	2169	* dumb hack to compensate for the failure of click-and-drag
1677	* when overriding mouse reporting	2170	* when overriding mouse reporting
1678	*/	2171	*/
1679	if (PrivateModes & PrivMode_mouse_report	2172	if (priv_modes & PrivMode_mouse_report
1680	&& bypass_keystate	2173	&& bypass_keystate
1681	&& ev.button == Button1 && MEvent.clicks <= 1)	2174	&& ev.button == Button1 && MEvent.clicks <= 1)
1682	selection_extend (ev.x, ev.y, 0);	2175	selection_extend (ev.x, ev.y, 0);
1683		2176
1684	switch (ev.button)	2177	switch (ev.button)
1685	{	2178	{
1686	case Button1:	2179	case Button1:
1687	case Button3:	2180	case Button3:
1688	selection_make (ev.time);	2181	selection_make (ev.time);
1689	break;	2182	break;
		2183
1690	case Button2:	2184	case Button2:
1691	selection_request (ev.time, ev.x, ev.y);	2185	if (IN_RANGE_EXC (ev.x, 0, width) && IN_RANGE_EXC (ev.y, 0, height)) // inside window?
		2186	selection_request (ev.time, ev.state & ModMetaMask ? Sel_Clipboard : Sel_Primary);
1692	break;	2187	break;
		2188
1693	#ifdef MOUSE_WHEEL	2189	#ifdef MOUSE_WHEEL
1694	case Button4:	2190	case Button4:
1695	case Button5:	2191	case Button5:
1696	{	2192	{
1697	int i;	2193	int i;
…		…
1699		2195
1700	v = ev.button == Button4 ? UP : DN;	2196	v = ev.button == Button4 ? UP : DN;
1701		2197
1702	if (ev.state & ShiftMask)	2198	if (ev.state & ShiftMask)
1703	i = 1;	2199	i = 1;
1704	else if (Options & Opt_mouseWheelScrollPage)	2200	else if (option (Opt_mouseWheelScrollPage))
1705	i = TermWin.nrow - 1;	2201	i = nrow - 1;
1706	else	2202	else
1707	i = 5;	2203	i = 5;
1708		2204
1709	# ifdef MOUSE_SLIP_WHEELING	2205	# ifdef MOUSE_SLIP_WHEELING
1710	if (ev.state & ControlMask)	2206	if (ev.state & ControlMask)
1711	{	2207	{
1712	mouse_slip_wheel_speed += v ? -1 : 1;	2208	mouse_slip_wheel_speed += v ? -1 : 1;
		2209	if (mouse_slip_wheel_speed < -nrow) mouse_slip_wheel_speed = -nrow;
		2210	if (mouse_slip_wheel_speed > +nrow) mouse_slip_wheel_speed = +nrow;
		2211
		2212	if (!slip_wheel_ev.is_active ())
1713	slip_wheel_ev.start (NOW + SCROLLBAR_CONTINUOUS_DELAY);	2213	slip_wheel_ev.start (SCROLLBAR_CONTINUOUS_DELAY, SCROLLBAR_CONTINUOUS_DELAY);
1714	}	2214	}
		2215	else
1715	# endif	2216	# endif
1716	# ifdef JUMP_MOUSE_WHEEL
1717	scr_page (v, i);
1718	scr_refresh (SMOOTH_REFRESH);
1719	scrollbar_show (1);
1720	# else
1721	while (i--)
1722	{	2217	{
1723	scr_page (v, 1);	2218	scr_page (v, i);
1724	scr_refresh (SMOOTH_REFRESH);
1725	scrollbar_show (1);	2219	scrollBar.show (1);
1726	}	2220	}
1727	# endif
1728
1729	}	2221	}
1730	break;	2222	break;
1731	#endif	2223	#endif
1732
1733	}
1734	}
1735	#ifdef MENUBAR
1736	else if (isMenuBarWindow (ev.window))
1737	menubar_control (ev);
1738	#endif
1739	}
1740
1741	#ifdef TRANSPARENT
1742	#if TINTING
1743	/* shading taken from eterm-0.9.2 */
1744	/* RGB 15 */
1745
1746	static void
1747	shade_ximage_15(void *data, int bpl, int w, int h, int rm, int gm, int bm)
1748	{
1749	unsigned char *ptr;
1750	int x, y;
1751
1752	ptr = (unsigned char *)data + (w * sizeof(uint16_t));
1753	if ((rm <= 256) && (gm <= 256) && (bm <= 256)) {
1754	/* No saturation */
1755	for (y = h; --y >= 0;) {
1756	for (x = -w; x < 0; x++) {
1757	int r, g, b;
1758
1759	b = ((uint16_t *) ptr)[x];
1760	r = (b & 0x7c00) * rm;
1761	g = (b & 0x3e0) * gm;
1762	b = (b & 0x1f) * bm;
1763	((uint16_t *) ptr)[x] = ((r >> 8) & 0x7c00)
1764	| ((g >> 8) & 0x3e0)
1765	| ((b >> 8) & 0x1f);
1766	}
1767	ptr += bpl;
1768	}
1769	} else {
1770	for (y = h; --y >= 0;) {
1771	for (x = -w; x < 0; x++) {
1772	int r, g, b;
1773
1774	b = ((uint16_t *) ptr)[x];
1775	r = (b & 0x7c00) * rm;
1776	g = (b & 0x3e0) * gm;
1777	b = (b & 0x1f) * bm;
1778	r |= (!(r >> 15) - 1);
1779	g |= (!(g >> 10) - 1);
1780	b |= (!(b >> 5) - 1);
1781	((uint16_t *) ptr)[x] = ((r >> 8) & 0x7c00)
1782	| ((g >> 8) & 0x3e0)
1783	| ((b >> 8) & 0x1f);
1784	}
1785	ptr += bpl;
1786	}
1787	}
1788	}
1789
1790	/* RGB 16 */
1791	static void
1792	shade_ximage_16(void *data, int bpl, int w, int h, int rm, int gm, int bm)
1793	{
1794	unsigned char *ptr;
1795	int x, y;
1796
1797	ptr = (unsigned char *)data + (w * sizeof(uint16_t));
1798	if ((rm <= 256) && (gm <= 256) && (bm <= 256)) {
1799	/* No saturation */
1800	for (y = h; --y >= 0;) {
1801	for (x = -w; x < 0; x++) {
1802	int r, g, b;
1803
1804	b = ((uint16_t *) ptr)[x];
1805	r = (b & 0xf800) * rm;
1806	g = (b & 0x7e0) * gm;
1807	b = (b & 0x1f) * bm;
1808	((uint16_t *) ptr)[x] = ((r >> 8) & 0xf800)
1809	| ((g >> 8) & 0x7e0)
1810	| ((b >> 8) & 0x1f);
1811	}
1812	ptr += bpl;
1813	}
1814	} else {
1815	for (y = h; --y >= 0;) {
1816	for (x = -w; x < 0; x++) {
1817	int r, g, b;
1818
1819	b = ((uint16_t *) ptr)[x];
1820	r = (b & 0xf800) * rm;
1821	g = (b & 0x7e0) * gm;
1822	b = (b & 0x1f) * bm;
1823	r |= (!(r >> 16) - 1);
1824	g |= (!(g >> 11) - 1);
1825	b |= (!(b >> 5) - 1);
1826	((uint16_t *) ptr)[x] = ((r >> 8) & 0xf800)
1827	| ((g >> 8) & 0x7e0)
1828	| ((b >> 8) & 0x1f);
1829	}
1830	ptr += bpl;
1831	}
1832	}
1833	}
1834
1835	/* RGB 24 */
1836	static void
1837	shade_ximage_24(void *data, int bpl, int w, int h, int rm, int gm, int bm)
1838	{
1839	unsigned char *ptr;
1840	int x, y;
1841
1842	ptr = (unsigned char *)data + (w * 3);
1843	if ((rm <= 256) && (gm <= 256) && (bm <= 256)) {
1844	/* No saturation */
1845	for (y = h; --y >= 0;) {
1846	for (x = -(w * 3); x < 0; x += 3) {
1847	int r, g, b;
1848
1849	if (byteorder.big_endian()) {
1850	r = (ptr[x + 0] * rm) >> 8;
1851	g = (ptr[x + 1] * gm) >> 8;
1852	b = (ptr[x + 2] * bm) >> 8;
1853	ptr[x + 0] = r;
1854	ptr[x + 1] = g;
1855	ptr[x + 2] = b;
1856	} else {
1857	r = (ptr[x + 2] * rm) >> 8;
1858	g = (ptr[x + 1] * gm) >> 8;
1859	b = (ptr[x + 0] * bm) >> 8;
1860	ptr[x + 2] = r;
1861	ptr[x + 1] = g;
1862	ptr[x + 0] = b;
1863	}
1864	}
1865	ptr += bpl;
1866	}
1867	} else {
1868	for (y = h; --y >= 0;) {
1869	for (x = -(w * 3); x < 0; x += 3) {
1870	int r, g, b;
1871
1872	if (byteorder.big_endian()) {
1873	r = (ptr[x + 0] * rm) >> 8;
1874	g = (ptr[x + 1] * gm) >> 8;
1875	b = (ptr[x + 2] * bm) >> 8;
1876
1877	r |= (!(r >> 8) - 1);
1878	g |= (!(g >> 8) - 1);
1879	b |= (!(b >> 8) - 1);
1880
1881	ptr[x + 0] = r;
1882	ptr[x + 1] = g;
1883	ptr[x + 2] = b;
1884	} else {
1885	r = (ptr[x + 2] * rm) >> 8;
1886	g = (ptr[x + 1] * gm) >> 8;
1887	b = (ptr[x + 0] * bm) >> 8;
1888
1889	r |= (!(r >> 8) - 1);
1890	g |= (!(g >> 8) - 1);
1891	b |= (!(b >> 8) - 1);
1892
1893	ptr[x + 2] = r;
1894	ptr[x + 1] = g;
1895	ptr[x + 0] = b;
1896	}
1897	}
1898	ptr += bpl;
1899	}
1900	}
1901	}
1902
1903	/* RGB 32 */
1904	static void
1905	shade_ximage_32(void *data, int bpl, int w, int h, int rm, int gm, int bm)
1906	{
1907	unsigned char *ptr;
1908	int x, y;
1909
1910	ptr = (unsigned char *)data + (w * 4);
1911	if ((rm <= 256) && (gm <= 256) && (bm <= 256)) {
1912	/* No saturation */
1913	for (y = h; --y >= 0;) {
1914	if (byteorder.big_endian()) {
1915	for (x = -(w * 4); x < 0; x += 4) {
1916	int r, g, b;
1917
1918	r = (ptr[x + 1] * rm) >> 8;
1919	g = (ptr[x + 2] * gm) >> 8;
1920	b = (ptr[x + 3] * bm) >> 8;
1921	ptr[x + 1] = r;
1922	ptr[x + 2] = g;
1923	ptr[x + 3] = b;
1924	}
1925	} else {
1926	for (x = -(w * 4); x < 0; x += 4) {
1927	int r, g, b;
1928
1929	r = (ptr[x + 2] * rm) >> 8;
1930	g = (ptr[x + 1] * gm) >> 8;
1931	b = (ptr[x + 0] * bm) >> 8;
1932	ptr[x + 2] = r;
1933	ptr[x + 1] = g;
1934	ptr[x + 0] = b;
1935	}
1936	}
1937	ptr += bpl;
1938	}
1939	} else {
1940	for (y = h; --y >= 0;) {
1941	for (x = -(w * 4); x < 0; x += 4) {
1942	int r, g, b;
1943
1944	if (byteorder.big_endian()) {
1945	r = (ptr[x + 1] * rm) >> 8;
1946	g = (ptr[x + 2] * gm) >> 8;
1947	b = (ptr[x + 3] * bm) >> 8;
1948
1949	r |= (!(r >> 8) - 1);
1950	g |= (!(g >> 8) - 1);
1951	b |= (!(b >> 8) - 1);
1952
1953	ptr[x + 1] = r;
1954	ptr[x + 2] = g;
1955	ptr[x + 3] = b;
1956	} else {
1957	r = (ptr[x + 2] * rm) >> 8;
1958	g = (ptr[x + 1] * gm) >> 8;
1959	b = (ptr[x + 0] * bm) >> 8;
1960
1961	r |= (!(r >> 8) - 1);
1962	g |= (!(g >> 8) - 1);
1963	b |= (!(b >> 8) - 1);
1964
1965	ptr[x + 2] = r;
1966	ptr[x + 1] = g;
1967	ptr[x + 0] = b;
1968	}
1969	}
1970	ptr += bpl;
1971	}
1972	}
1973	}
1974
1975	#endif
1976
1977	/*
1978	* Check our parents are still who we think they are.
1979	* Do transparency updates if required
1980	*/
1981	int
1982	rxvt_term::check_our_parents ()
1983	{
1984	int i, pchanged, aformat, have_pixmap, rootdepth;
1985	unsigned long nitems, bytes_after;
1986	Atom atype;
1987	unsigned char *prop = NULL;
1988	Window root, oldp, *list;
1989	Pixmap rootpixmap = None;
1990	XWindowAttributes wattr, wrootattr;
1991
1992	pchanged = 0;
1993
1994	if (!(Options & Opt_transparent))
1995	return pchanged; /* Don't try any more */
1996
1997	XGetWindowAttributes (display->display, display->root, &wrootattr);
1998	rootdepth = wrootattr.depth;
1999
2000	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);
2001
2002	if (rootdepth != wattr.depth)
2003	{
2004	if (am_transparent)
2005	{	2224	}
2006	pchanged = 1;
2007	XSetWindowBackground (display->display, TermWin.vt, PixColors[Color_bg]);
2008	am_transparent = am_pixmap_trans = 0;
2009	}
2010
2011	return pchanged; /* Don't try any more */
2012	}
2013
2014	/* Get all X ops out of the queue so that our information is up-to-date. */
2015	XSync (display->display, False);
2016
2017	/*
2018	* Make the frame window set by the window manager have
2019	* the root background. Some window managers put multiple nested frame
2020	* windows for each client, so we have to take care about that.
2021	*/
2022	i = (xa[XA_XROOTPMAPID]
2023	&& XGetWindowProperty (display->display, display->root, xa[XA_XROOTPMAPID],
2024	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
2025	&nitems, &bytes_after, &prop) == Success);
2026
2027	if (!i || prop == NULL)
2028	i = (xa[XA_XSETROOTID]
2029	&& XGetWindowProperty (display->display, display->root, xa[XA_XSETROOTID],
2030	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
2031	&nitems, &bytes_after, &prop) == Success);
2032
2033	if (!i || prop == NULL)
2034	have_pixmap = 0;
2035	else
2036	{	2225	}
2037	have_pixmap = 1;
2038	rootpixmap = *(Pixmap *)prop;
2039	XFree (prop);
2040	}
2041
2042	if (have_pixmap)
2043	{
2044	/*
2045	* Copy display->root pixmap transparency
2046	*/
2047	int sx, sy, nx, ny;
2048	unsigned int nw, nh;
2049	Window cr;
2050	XImage *image;
2051	GC gc;
2052	XGCValues gcvalue;
2053
2054	XTranslateCoordinates (display->display, TermWin.parent[0], display->root,
2055	0, 0, &sx, &sy, &cr);
2056	nw = (unsigned int)szHint.width;
2057	nh = (unsigned int)szHint.height;
2058	nx = ny = 0;
2059
2060	if (sx < 0)
2061	{
2062	nw += sx;
2063	nx = -sx;
2064	sx = 0;
2065	}
2066
2067	if (sy < 0)
2068	{
2069	nh += sy;
2070	ny = -sy;
2071	sy = 0;
2072	}
2073
2074	MIN_IT (nw, (unsigned int) (wrootattr.width - sx));
2075	MIN_IT (nh, (unsigned int) (wrootattr.height - sy));
2076	allowedxerror = -1;
2077	image = XGetImage (display->display, rootpixmap, sx, sy, nw, nh, AllPlanes, ZPixmap);
2078
2079	/* XXX: handle BadMatch - usually because we're outside the pixmap */
2080	/* XXX: may need a delay here? */
2081	allowedxerror = 0;
2082
2083	if (image == NULL)
2084	{
2085	if (am_transparent && am_pixmap_trans)
2086	{
2087	pchanged = 1;
2088	if (TermWin.pixmap != None)
2089	{
2090	XFreePixmap (display->display, TermWin.pixmap);
2091	TermWin.pixmap = None;
2092	}
2093	}
2094
2095	am_pixmap_trans = 0;
2096	}
2097	else
2098	{
2099	if (TermWin.pixmap != None)
2100	XFreePixmap (display->display, TermWin.pixmap);
2101
2102	#if TINTING
2103	if (ISSET_PIXCOLOR (Color_tint))
2104	{
2105	unsigned short shade, rm, gm, bm;
2106
2107	PixColors[Color_tint].get (display, rm, gm, bm);
2108
2109	rm >>= 8; gm >>= 8; bm >>= 8; // not 100% correct, but...
2110
2111	/* Determine bitshift and bitmask values */
2112	switch (image->bits_per_pixel)
2113	{
2114	case 15: shade_ximage_15 (image->data, image->bytes_per_line, image->width, image->height, rm, gm, bm); break;
2115	case 16: shade_ximage_16 (image->data, image->bytes_per_line, image->width, image->height, rm, gm, bm); break;
2116	case 24: shade_ximage_24 (image->data, image->bytes_per_line, image->width, image->height, rm, gm, bm); break;
2117	case 32: shade_ximage_32 (image->data, image->bytes_per_line, image->width, image->height, rm, gm, bm); break;
2118	}
2119	}
2120	#endif
2121
2122	TermWin.pixmap = XCreatePixmap (display->display, TermWin.vt,
2123	szHint.width, szHint.height, image->depth);
2124	gc = XCreateGC (display->display, TermWin.vt, 0UL, &gcvalue);
2125	XPutImage (display->display, TermWin.pixmap, gc, image, 0, 0,
2126	nx, ny, image->width, image->height);
2127	XFreeGC (display->display, gc);
2128	XDestroyImage (image);
2129	XSetWindowBackgroundPixmap (display->display, TermWin.vt,
2130	TermWin.pixmap);
2131
2132	if (!am_transparent || !am_pixmap_trans)
2133	pchanged = 1;
2134
2135	am_transparent = am_pixmap_trans = 1;
2136	}
2137	}
2138
2139	if (!am_pixmap_trans)
2140	{
2141	unsigned int n;
2142	/*
2143	* InheritPixmap transparency
2144	*/
2145	D_X ((stderr, "InheritPixmap Seeking to %08lx", display->root));
2146	for (i = 1; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
2147	{
2148	oldp = TermWin.parent[i];
2149	XQueryTree (display->display, TermWin.parent[i - 1], &root,
2150	&TermWin.parent[i], &list, &n);
2151	XFree (list);
2152	D_X ((stderr, "InheritPixmap Parent[%d] = %08lx", i, TermWin.parent[i]));
2153
2154	if (TermWin.parent[i] == display->root)
2155	{
2156	if (oldp != None)
2157	pchanged = 1;
2158
2159	break;
2160	}
2161
2162	if (oldp != TermWin.parent[i])
2163	pchanged = 1;
2164	}
2165
2166	n = 0;
2167
2168	if (pchanged)
2169	{
2170	for (; n < (unsigned int)i; n++)
2171	{
2172	XGetWindowAttributes (display->display, TermWin.parent[n], &wattr);
2173	D_X ((stderr, "InheritPixmap Checking Parent[%d]: %s", n, (wattr.depth == rootdepth && wattr.class != InputOnly) ? "OK" : "FAIL"));
2174	if (wattr.depth != rootdepth || wattr.c_class == InputOnly)
2175	{
2176	n = (int) (sizeof (TermWin.parent) / sizeof (Window)) + 1;
2177	break;
2178	}
2179	}
2180	}
2181
2182	if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0])))
2183	{
2184	D_X ((stderr, "InheritPixmap Turning off"));
2185	XSetWindowBackground (display->display, TermWin.parent[0], PixColors[Color_fg]);
2186	XSetWindowBackground (display->display, TermWin.vt, PixColors[Color_bg]);
2187	am_transparent = 0;
2188	/* XXX: also turn off Opt_transparent? */
2189	}
2190	else
2191	{
2192	#if WAIT_FOR_WM
2193	/* wait (an arbitrary period) for the WM to do its thing
2194	* needed for fvwm2.2.2 (and before?) */
2195	sleep (1);
2196	#endif
2197	D_X ((stderr, "InheritPixmap Turning on (%d parents)", i - 1));
2198	for (n = 0; n < (unsigned int)i; n++)
2199	XSetWindowBackgroundPixmap (display->display, TermWin.parent[n], ParentRelative);
2200
2201	XSetWindowBackgroundPixmap (display->display, TermWin.vt, ParentRelative);
2202	am_transparent = 1;
2203	}
2204
2205	for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
2206	TermWin.parent[i] = None;
2207	}
2208
2209	return pchanged;
2210	}	2226	}
2211	#endif
2212		2227
2213	/*}}} */	2228	/*}}} */
2214		2229
2215	bool	2230	void
2216	rxvt_term::cmd_parse ()	2231	rxvt_term::cmd_parse ()
2217	{	2232	{
2218	bool flag = false;
2219	unicode_t ch = NOCHAR;	2233	wchar_t ch = NOCHAR;
2220	unsigned char *seq_begin; // remember start of esc-sequence here	2234	char *seq_begin; // remember start of esc-sequence here
2221		2235
2222	for (;;)	2236	for (;;)
2223	{	2237	{
2224	if (ch == NOCHAR)	2238	if (expect_false (ch == NOCHAR))
2225	{	2239	{
2226	seq_begin = cmdbuf_ptr;	2240	seq_begin = cmdbuf_ptr;
2227	ch = next_char ();	2241	ch = next_char ();
2228	}
2229		2242
2230	if (ch == NOCHAR) // TODO: improve	2243	if (ch == NOCHAR)
2231	break;	2244	break;
		2245	}
2232		2246
2233	if (!IS_CONTROL (ch) || ch == C0_LF || ch == C0_CR || ch == C0_HT)	2247	if (expect_true (!IS_CONTROL (ch) || ch == C0_LF || ch == C0_CR || ch == C0_HT))
		2248	{
		2249	if (expect_false (!seen_input))
2234	{	2250	{
		2251	seen_input = 1;
		2252	// many badly-written programs (e.g. jed) contain a race condition:
		2253	// they first read the screensize and then install a SIGWINCH handler.
		2254	// some window managers resize the window early, and these programs
		2255	// then sometimes get the size wrong.
		2256	// unfortunately other programs are even more buggy and dislike
		2257	// being sent SIGWINCH, so only do it when we were in fact being
		2258	// resized.
		2259	if (seen_resize && cmd_pid)
		2260	kill (-cmd_pid, SIGWINCH);
		2261	}
		2262
2235	/* Read a text string from the input buffer */	2263	/* Read a text string from the input buffer */
2236	unicode_t buf[UBUFSIZ];	2264	wchar_t buf[UBUFSIZ];
2237	bool refreshnow = false;	2265	bool refreshnow = false;
2238	int nlines = 0;	2266	int nlines = 0;
2239	unicode_t *str = buf;	2267	wchar_t *str = buf;
2240		2268	wchar_t *eol = str + min (ncol, UBUFSIZ);
2241	*str++ = ch;
2242		2269
2243	for (;;)	2270	for (;;)
2244	{	2271	{
		2272	if (expect_false (ch == NOCHAR || (IS_CONTROL (ch) && ch != C0_LF && ch != C0_CR && ch != C0_HT)))
		2273	break;
		2274
		2275	*str++ = ch;
		2276
		2277	if (expect_false (ch == C0_LF || str >= eol))
		2278	{
		2279	if (ch == C0_LF)
		2280	nlines++;
		2281
		2282	refresh_count++;
		2283
		2284	if (!option (Opt_jumpScroll) || refresh_count >= nrow - 1)
		2285	{
		2286	refresh_count = 0;
		2287
		2288	if (!option (Opt_skipScroll) || ev_time () > ev::now () + 1. / 60.)
		2289	{
		2290	refreshnow = true;
		2291	ch = NOCHAR;
		2292	break;
		2293	}
		2294	}
		2295
		2296	// scr_add_lines only works for nlines <= nrow - 1.
		2297	if (nlines >= nrow - 1)
		2298	{
		2299	if (!(SHOULD_INVOKE (HOOK_ADD_LINES)
		2300	&& HOOK_INVOKE ((this, HOOK_ADD_LINES, DT_WCS_LEN, buf, str - buf, DT_END))))
		2301	scr_add_lines (buf, str - buf, nlines);
		2302
		2303	nlines = 0;
		2304	str = buf;
		2305	eol = str + min (ncol, UBUFSIZ);
		2306	}
		2307
		2308	if (str >= eol)
		2309	{
		2310	if (eol >= buf + UBUFSIZ)
		2311	{
		2312	ch = NOCHAR;
		2313	break;
		2314	}
		2315	else
		2316	eol = min (eol + ncol, buf + UBUFSIZ);
		2317	}
		2318
		2319	}
		2320
2245	seq_begin = cmdbuf_ptr;	2321	seq_begin = cmdbuf_ptr;
2246	ch = next_char ();	2322	ch = next_char ();
2247
2248	if (ch == NOCHAR || (IS_CONTROL (ch) && ch != C0_LF && ch != C0_CR && ch != C0_HT))
2249	break;
2250
2251	*str++ = ch;
2252
2253	if (ch == C0_LF)
2254	{
2255	nlines++;
2256	refresh_count++;
2257
2258	if (! (Options & Opt_jumpScroll)
2259	|| (refresh_count >= (refresh_limit * (TermWin.nrow - 1))))
2260	{
2261	refreshnow = true;
2262	flag = true;
2263	ch = NOCHAR;
2264	break;
2265	}
2266
2267	// scr_add_lines only works for nlines < TermWin.nrow - 1.
2268	if (nlines >= TermWin.nrow - 1)
2269	{
2270	scr_add_lines (buf, nlines, str - buf);
2271	nlines = 0;
2272	str = buf;
2273	}
2274	}
2275
2276	if (str >= buf + UBUFSIZ)
2277	{
2278	ch = NOCHAR;
2279	break;
2280	}
2281	}	2323	}
2282		2324
		2325	if (!(SHOULD_INVOKE (HOOK_ADD_LINES)
		2326	&& HOOK_INVOKE ((this, HOOK_ADD_LINES, DT_WCS_LEN, buf, str - buf, DT_END))))
2283	scr_add_lines (buf, nlines, str - buf);	2327	scr_add_lines (buf, str - buf, nlines);
2284		2328
2285	/*	2329	/*
2286	* If there have been a lot of new lines, then update the screen	2330	* If there have been a lot of new lines, then update the screen
2287	* What the heck I'll cheat and only refresh less than every page-full.	2331	* What the heck we'll cheat and only refresh less than every page-full.
2288	* the number of pages between refreshes is refresh_limit, which	2332	* if skipScroll is enabled.
2289	* is incremented here because we must be doing flat-out scrolling.
2290	*
2291	* refreshing should be correct for small scrolls, because of the
2292	* time-out
2293	*/	2333	*/
2294	if (refreshnow)	2334	if (refreshnow)
2295	{	2335	{
2296	if ((Options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)
2297	refresh_limit++;
2298	else
2299	scr_refresh (refresh_type);	2336	scr_refresh ();
		2337	want_refresh = 1;
2300	}	2338	}
2301
2302	}	2339	}
2303	else	2340	else
2304	{	2341	{
2305	try	2342	try
2306	{	2343	{
…		…
2314	}	2351	}
2315		2352
2316	ch = NOCHAR;	2353	ch = NOCHAR;
2317	}	2354	}
2318	}	2355	}
2319
2320	return flag;
2321	}
2322
2323	// read the next octet
2324	unicode_t
2325	rxvt_term::next_octet ()
2326	{
2327	return cmdbuf_ptr < cmdbuf_endp
2328	? *cmdbuf_ptr++
2329	: NOCHAR;
2330	}	2356	}
2331		2357
2332	// read the next character	2358	// read the next character
2333	unicode_t	2359	wchar_t
2334	rxvt_term::next_char ()	2360	rxvt_term::next_char () NOTHROW
2335	{	2361	{
2336	while (cmdbuf_ptr < cmdbuf_endp)	2362	while (cmdbuf_ptr < cmdbuf_endp)
2337	{	2363	{
2338	// assume 7-bit to be ascii ALWAYS	2364	// assume 7-bit to be ascii ALWAYS
2339	if (*cmdbuf_ptr <= 0x7f && *cmdbuf_ptr != 0x1b)	2365	if (expect_true ((unsigned char)*cmdbuf_ptr <= 0x7f && *cmdbuf_ptr != 0x1b))
2340	return *cmdbuf_ptr++;	2366	return *cmdbuf_ptr++;
2341		2367
2342	wchar_t wc;	2368	wchar_t wc;
2343	size_t len = mbrtowc (&wc, (char *)cmdbuf_ptr, cmdbuf_endp - cmdbuf_ptr, mbstate);	2369	size_t len = mbrtowc (&wc, cmdbuf_ptr, cmdbuf_endp - cmdbuf_ptr, mbstate);
2344		2370
2345	if (len == (size_t)-2)	2371	if (len == (size_t)-2)
2346	{	2372	{
2347	// the mbstate stores incomplete sequences. didn't know this :/	2373	// the mbstate stores incomplete sequences. didn't know this :/
2348	cmdbuf_ptr = cmdbuf_endp;	2374	cmdbuf_ptr = cmdbuf_endp;
2349	break;	2375	break;
2350	}	2376	}
2351		2377
2352	if (len == (size_t)-1)	2378	if (len == (size_t)-1)
		2379	{
		2380	mbstate.reset (); // reset now undefined conversion state
2353	return *cmdbuf_ptr++; // the _occasional_ latin1 character is allowed to slip through	2381	return (unsigned char)*cmdbuf_ptr++; // the _occasional_ latin1 character is allowed to slip through
		2382	}
2354		2383
2355	// assume wchar == unicode	2384	// assume wchar == unicode
2356	cmdbuf_ptr += len;	2385	cmdbuf_ptr += len;
2357	return wc;	2386	return wc & UNICODE_MASK;
2358	}	2387	}
2359		2388
2360	return NOCHAR;	2389	return NOCHAR;
2361	}	2390	}
		2391
		2392	// read the next octet
		2393	uint32_t
		2394	rxvt_term::next_octet () NOTHROW
		2395	{
		2396	return cmdbuf_ptr < cmdbuf_endp
		2397	? (unsigned char)*cmdbuf_ptr++
		2398	: NOCHAR;
		2399	}
		2400
		2401	static class out_of_input out_of_input;
2362		2402
2363	/* rxvt_cmd_getc () - Return next input character */	2403	/* rxvt_cmd_getc () - Return next input character */
2364	/*	2404	/*
2365	* Return the next input character after first passing any keyboard input	2405	* Return the next input character after first passing any keyboard input
2366	* to the command.	2406	* to the command.
2367	*/	2407	*/
2368	unicode_t	2408	wchar_t
2369	rxvt_term::cmd_getc ()	2409	rxvt_term::cmd_getc () THROW ((class out_of_input))
2370	{	2410	{
2371	unicode_t c = next_char ();	2411	wchar_t c = next_char ();
2372		2412
2373	if (c == NOCHAR)	2413	if (c == NOCHAR)
2374	throw out_of_input;	2414	throw out_of_input;
2375		2415
2376	return c;	2416	return c;
2377	}	2417	}
2378		2418
2379	unicode_t	2419	uint32_t
2380	rxvt_term::cmd_get8 ()	2420	rxvt_term::cmd_get8 () THROW ((class out_of_input))
2381	{	2421	{
2382	unicode_t c = next_octet ();	2422	uint32_t c = next_octet ();
2383		2423
2384	if (c == NOCHAR)	2424	if (c == NOCHAR)
2385	throw out_of_input;	2425	throw out_of_input;
2386		2426
2387	return c;	2427	return c;
…		…
2391	/*----------------------------------------------------------------------*/	2431	/*----------------------------------------------------------------------*/
2392	#ifdef PRINTPIPE	2432	#ifdef PRINTPIPE
2393	FILE *	2433	FILE *
2394	rxvt_term::popen_printer ()	2434	rxvt_term::popen_printer ()
2395	{	2435	{
2396	FILE *stream = popen (rs[Rs_print_pipe], "w");	2436	FILE *stream = popen (rs[Rs_print_pipe] ? rs[Rs_print_pipe] : PRINTPIPE, "w");
2397		2437
2398	if (stream == NULL)	2438	if (stream == NULL)
2399	rxvt_warn ("can't open printer pipe, not printing.\n");	2439	rxvt_warn ("can't open printer pipe, not printing.\n");
2400		2440
2401	return stream;	2441	return stream;
…		…
2412	* simulate attached vt100 printer	2452	* simulate attached vt100 printer
2413	*/	2453	*/
2414	void	2454	void
2415	rxvt_term::process_print_pipe ()	2455	rxvt_term::process_print_pipe ()
2416	{	2456	{
2417	int done;	2457	FILE *fd = popen_printer ();
2418	FILE *fd;
2419		2458
2420	if ((fd = popen_printer ()) == NULL)	2459	if (!fd)
2421	return;	2460	return;
2422		2461
2423	/*	2462	/*
2424	* Send all input to the printer until either ESC[4i or ESC[?4i	2463	* Send all input to the printer until either ESC[4i or ESC[?4i
2425	* is received.	2464	* is received.
2426	*/	2465	*/
2427	for (done = 0; !done;)	2466	for (int done = 0; !done; )
2428	{	2467	{
2429	unsigned char buf[8];	2468	unsigned char buf[8];
2430	unicode_t ch;	2469	unicode_t ch;
2431	unsigned int i, len;	2470	unsigned int i, len;
2432		2471
…		…
2451	{	2490	{
2452	if ((buf[len++] = cmd_getc ()) == 'i')	2491	if ((buf[len++] = cmd_getc ()) == 'i')
2453	break; /* done = 1 */	2492	break; /* done = 1 */
2454	}	2493	}
2455	}	2494	}
2456		2495
2457	for (i = 0; i < len; i++)	2496	for (i = 0; i < len; i++)
2458	if (putc (buf[i], fd) == EOF)	2497	if (putc (buf[i], fd) == EOF)
2459	{	2498	{
2460	done = 1;	2499	done = 1;
2461	break;	2500	break;
…		…
2463	}	2502	}
2464	}	2503	}
2465		2504
2466	pclose_printer (fd);	2505	pclose_printer (fd);
2467	}	2506	}
2468	#endif /* PRINTPIPE */	2507	#endif /* PRINTPIPE */
2469	/*}}} */	2508	/*}}} */
2470		2509
2471	/* *INDENT-OFF* */	2510	/* *INDENT-OFF* */
2472	enum {	2511	enum {
2473	C1_40 = 0x40,	2512	C1_40 = 0x40,
…		…
2487	case C0_ESC:	2526	case C0_ESC:
2488	process_escape_seq ();	2527	process_escape_seq ();
2489	break;	2528	break;
2490	case C0_ENQ: /* terminal Status */	2529	case C0_ENQ: /* terminal Status */
2491	if (rs[Rs_answerbackstring])	2530	if (rs[Rs_answerbackstring])
2492	tt_write ((const unsigned char *)rs[Rs_answerbackstring],	2531	tt_write (rs [Rs_answerbackstring], strlen (rs [Rs_answerbackstring]));
2493	(unsigned int)STRLEN (rs[Rs_answerbackstring]));
2494	else	2532	else
2495	tt_write ((unsigned char *)VT100_ANS,	2533	tt_write (VT100_ANS, strlen (VT100_ANS));
2496	(unsigned int)STRLEN (VT100_ANS));
2497	break;	2534	break;
2498	case C0_BEL: /* bell */	2535	case C0_BEL: /* bell */
2499	scr_bell ();	2536	scr_bell ();
2500	break;	2537	break;
2501	case C0_BS: /* backspace */	2538	case C0_BS: /* backspace */
…		…
2525	process_dcs_seq ();	2562	process_dcs_seq ();
2526	break;	2563	break;
2527	case 0x9b: /* CSI */	2564	case 0x9b: /* CSI */
2528	process_csi_seq ();	2565	process_csi_seq ();
2529	break;	2566	break;
2530	case 0x9d: /* CSI */	2567	case 0x9d: /* OSC */
2531	process_osc_seq ();	2568	process_osc_seq ();
2532	break;	2569	break;
2533	#endif	2570	#endif
2534	}	2571	}
2535	}	2572	}
…		…
2579	break;	2616	break;
2580	case 'Z': /* identify the terminal type */	2617	case 'Z': /* identify the terminal type */
2581	tt_printf ("\033/Z"); /* I am a VT100 emulating a VT52 */	2618	tt_printf ("\033/Z"); /* I am a VT100 emulating a VT52 */
2582	break;	2619	break;
2583	case '<': /* turn off VT52 mode */	2620	case '<': /* turn off VT52 mode */
2584	PrivMode (0, PrivMode_vt52);	2621	set_privmode (PrivMode_vt52, 0);
2585	break;	2622	break;
2586	case 'F': /* use special graphics character set */	2623	case 'F': /* use special graphics character set */
2587	case 'G': /* use regular character set */	2624	case 'G': /* use regular character set */
2588	/* unimplemented */	2625	/* unimplemented */
2589	break;	2626	break;
…		…
2600	void	2637	void
2601	rxvt_term::process_escape_seq ()	2638	rxvt_term::process_escape_seq ()
2602	{	2639	{
2603	unicode_t ch = cmd_getc ();	2640	unicode_t ch = cmd_getc ();
2604		2641
2605	if (PrivateModes & PrivMode_vt52)	2642	if (priv_modes & PrivMode_vt52)
2606	{	2643	{
2607	process_escape_vt52 (ch);	2644	process_escape_vt52 (ch);
2608	return;	2645	return;
2609	}	2646	}
2610		2647
…		…
2625	scr_charset_set (2, (unsigned int)cmd_getc ());	2662	scr_charset_set (2, (unsigned int)cmd_getc ());
2626	break;	2663	break;
2627	case '+':	2664	case '+':
2628	scr_charset_set (3, (unsigned int)cmd_getc ());	2665	scr_charset_set (3, (unsigned int)cmd_getc ());
2629	break;	2666	break;
2630	#ifndef NO_FRILLS	2667	#if !ENABLE_MINIMAL
2631	case '6':	2668	case '6':
2632	scr_backindex ();	2669	scr_backindex ();
2633	break;	2670	break;
2634	#endif	2671	#endif
2635	case '7':	2672	case '7':
2636	scr_cursor (SAVE);	2673	scr_cursor (SAVE);
2637	break;	2674	break;
2638	case '8':	2675	case '8':
2639	scr_cursor (RESTORE);	2676	scr_cursor (RESTORE);
2640	break;	2677	break;
2641	#ifndef NO_FRILLS	2678	#if !ENABLE_MINIMAL
2642	case '9':	2679	case '9':
2643	scr_forwardindex ();	2680	scr_forwardindex ();
2644	break;	2681	break;
2645	#endif	2682	#endif
2646	case '=':	2683	case '=':
2647	case '>':	2684	case '>':
2648	PrivMode ((ch == '='), PrivMode_aplKP);	2685	set_privmode (PrivMode_aplKP, ch == '=');
2649	break;	2686	break;
2650		2687
2651	case C1_40:	2688	case C1_40:
2652	cmd_getc ();	2689	cmd_getc ();
2653	break;	2690	break;
…		…
2656	break;	2693	break;
2657		2694
2658	/* 8.3.87: NEXT LINE */	2695	/* 8.3.87: NEXT LINE */
2659	case C1_NEL: /* ESC E */	2696	case C1_NEL: /* ESC E */
2660	{	2697	{
2661	unicode_t nlcr[] = { C0_LF, C0_CR };	2698	wchar_t nlcr[] = { C0_LF, C0_CR };
2662	scr_add_lines (nlcr, 1, 2);	2699	scr_add_lines (nlcr, ARRAY_LENGTH(nlcr), 1);
2663	}	2700	}
2664	break;	2701	break;
2665		2702
2666	/* kidnapped escape sequence: Should be 8.3.48 */	2703	/* kidnapped escape sequence: Should be 8.3.48 */
2667	case C1_ESA: /* ESC G */	2704	case C1_ESA: /* ESC G */
…		…
2689	process_dcs_seq ();	2726	process_dcs_seq ();
2690	break;	2727	break;
2691		2728
2692	/* 8.3.110: SINGLE CHARACTER INTRODUCER */	2729	/* 8.3.110: SINGLE CHARACTER INTRODUCER */
2693	case C1_SCI: /* ESC Z */	2730	case C1_SCI: /* ESC Z */
2694	tt_write ((const unsigned char *)ESCZ_ANSWER,	2731	tt_write (ESCZ_ANSWER, sizeof (ESCZ_ANSWER) - 1);
2695	(unsigned int) (sizeof (ESCZ_ANSWER) - 1));
2696	break; /* steal obsolete ESC [ c */	2732	break; /* steal obsolete ESC [ c */
2697		2733
2698	/* 8.3.16: CONTROL SEQUENCE INTRODUCER */	2734	/* 8.3.16: CONTROL SEQUENCE INTRODUCER (CSI) */
2699	case C1_CSI: /* ESC [ */	2735	case C1_CSI: /* ESC [ */
2700	process_csi_seq ();	2736	process_csi_seq ();
2701	break;	2737	break;
2702		2738
2703	/* 8.3.90: OPERATING SYSTEM COMMAND */	2739	/* 8.3.90: OPERATING SYSTEM COMMAND (OSC) */
2704	case C1_OSC: /* ESC ] */	2740	case C1_OSC: /* ESC ] */
2705	process_osc_seq ();	2741	process_osc_seq ();
2706	break;	2742	break;
2707		2743
2708	/* 8.3.106: RESET TO INITIAL STATE */	2744	/* 8.3.106: RESET TO INITIAL STATE (RIS) */
2709	case 'c':	2745	case 'c':
2710	mbstate.reset ();	2746	mbstate.reset ();
2711	scr_poweron ();	2747	scr_poweron ();
2712	scrollbar_show (1);	2748	scrollBar.show (1);
2713	break;	2749	break;
2714		2750
2715	/* 8.3.79: LOCKING-SHIFT TWO (see ISO2022) */	2751	/* 8.3.79: LOCKING-SHIFT TWO (see ISO2022) */
2716	case 'n':	2752	case 'n':
2717	scr_charset_choose (2);	2753	scr_charset_choose (2);
…		…
2737	CSI_SM , CSI_MC , CSI_HPB, CSI_VPB, CSI_RM , CSI_SGR, CSI_DSR, CSI_DAQ,	2773	CSI_SM , CSI_MC , CSI_HPB, CSI_VPB, CSI_RM , CSI_SGR, CSI_DSR, CSI_DAQ,
2738	CSI_70 , CSI_71 , CSI_72 , CSI_73 , CSI_74 , CSI_75 , CSI_76 , CSI_77 ,	2774	CSI_70 , CSI_71 , CSI_72 , CSI_73 , CSI_74 , CSI_75 , CSI_76 , CSI_77 ,
2739	CSI_78 , CSI_79 , CSI_7A , CSI_7B , CSI_7C , CSI_7D , CSI_7E , CSI_7F	2775	CSI_78 , CSI_79 , CSI_7A , CSI_7B , CSI_7C , CSI_7D , CSI_7E , CSI_7F
2740	};	2776	};
2741		2777
2742	#define make_byte(b7,b6,b5,b4,b3,b2,b1,b0) \	2778	#define make_byte(b0,b1,b2,b3,b4,b5,b6,b7) \
2743	(((b7) << 7) | ((b6) << 6) | ((b5) << 5) | ((b4) << 4) \	2779	(((b7) << 7) | ((b6) << 6) | ((b5) << 5) | ((b4) << 4) \
2744	| ((b3) << 3) | ((b2) << 2) | ((b1) << 1) | (b0))	2780	| ((b3) << 3) | ((b2) << 2) | ((b1) << 1) | (b0))
2745	#define get_byte_array_bit(array, bit) \	2781	#define get_byte_array_bit(array, bit) \
2746	(!! ((array)[ (bit) / 8] & (128 >> ((bit) & 7))))	2782	(!! ((array)[(bit) >> 3] & (1 << ((bit) & 7))))
2747		2783
2748	const unsigned char csi_defaults[] =	2784	static const unsigned char csi_defaults[] =
2749	{	2785	{
2750	make_byte (1,1,1,1,1,1,1,1), /* @, A, B, C, D, E, F, G, */	2786	make_byte (1,1,1,1,1,1,1,1), /* @, A, B, C, D, E, F, G, */
2751	make_byte (1,1,0,0,1,1,0,0), /* H, I, J, K, L, M, N, O, */	2787	make_byte (1,1,0,0,1,1,0,0), /* H, I, J, K, L, M, N, O, */
2752	make_byte (1,0,1,1,1,1,1,0), /* P, Q, R, S, T, U, V, W, */	2788	make_byte (1,0,1,1,1,1,1,0), /* P, Q, R, S, T, U, V, W, */
2753	make_byte (1,1,1,0,0,0,1,0), /* X, Y, Z, [, \, ], ^, _, */	2789	make_byte (1,1,1,0,0,0,1,0), /* X, Y, Z, [, \, ], ^, _, */
…		…
2762	rxvt_term::process_csi_seq ()	2798	rxvt_term::process_csi_seq ()
2763	{	2799	{
2764	unicode_t ch, priv, i;	2800	unicode_t ch, priv, i;
2765	unsigned int nargs, p;	2801	unsigned int nargs, p;
2766	int n, ndef;	2802	int n, ndef;
2767	int arg[ESC_ARGS];	2803	int arg[ESC_ARGS] = { };
2768		2804
2769	for (nargs = ESC_ARGS; nargs > 0;)	2805	nargs = 0;
2770	arg[--nargs] = 0;
2771		2806
2772	priv = 0;	2807	priv = 0;
2773	ch = cmd_getc ();	2808	ch = cmd_getc ();
2774	if (ch >= '<' && ch <= '?')	2809	if ((ch >= '<' && ch <= '?') || ch == '!')
		2810	{
2775	{ /* '<' '=' '>' '?' */	2811	/* '<' '=' '>' '?' '!' */
2776	priv = ch;	2812	priv = ch;
2777	ch = cmd_getc ();	2813	ch = cmd_getc ();
2778	}	2814	}
2779		2815
2780	/* read any numerical arguments */	2816	/* read any numerical arguments */
…		…
2809	ndef = get_byte_array_bit (csi_defaults, i);	2845	ndef = get_byte_array_bit (csi_defaults, i);
2810	for (p = 0; p < nargs; p++)	2846	for (p = 0; p < nargs; p++)
2811	if (arg[p] == -1)	2847	if (arg[p] == -1)
2812	arg[p] = ndef;	2848	arg[p] = ndef;
2813		2849
2814	#ifdef DEBUG_CMD
2815	fprintf (stderr, "CSI ");
2816	for (p = 0; p < nargs; p++)
2817	fprintf (stderr, "%d%s", arg[p], p < nargs - 1 ? ";" : "");
2818	fprintf (stderr, "%c\n", ch);
2819	#endif
2820
2821	/*	2850	/*
2822	* private mode handling	2851	* private mode handling
2823	*/	2852	*/
2824	if (priv)	2853	if (priv)
2825	{	2854	{
2826	switch (priv)	2855	switch (priv)
2827	{	2856	{
2828	case '>':	2857	case '>':
2829	if (ch == CSI_DA) /* secondary device attributes */	2858	if (ch == CSI_DA) /* secondary device attributes */
		2859	{
		2860	// first parameter is normally 0 for vt100, 1 for vt220, 'R' for rxvt,
		2861	// 'U' for rxvt-unicode != 7.[34] (where it was broken).
		2862	//
		2863	// second parameter is xterm patch level for xterm, MMmmpp (e.g. 20703) for rxvt
		2864	// and Mm (e.g. 72 for 7.2) for urxvt <= 7.2, 94 for urxvt <= 8.3, and 95 for later
		2865	// versions.
		2866	//
2830	tt_printf ("\033[>%d;%-.8s;0c", 'R', VSTRING);	2867	tt_printf ("\033[>%d;95;0c", 'U');
		2868	}
2831	break;	2869	break;
		2870
2832	case '?':	2871	case '?':
2833	if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')	2872	if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')
2834	process_terminal_mode (ch, priv, nargs, arg);	2873	process_terminal_mode (ch, priv, nargs, arg);
2835	break;	2874	break;
		2875
		2876	case '!':
		2877	if (ch == CSI_70)
		2878	{
		2879	/* DECSTR: soft terminal reset, used by our terminfo since 9.06 */
		2880	scr_soft_reset ();
		2881
		2882	static const int pm_h[] = { 7, 25 };
		2883	static const int pm_l[] = { 1, 3, 4, 5, 6, 9, 66, 1000, 1001, 1005, 1015, 1049 };
		2884
		2885	process_terminal_mode ('h', 0, ARRAY_LENGTH(pm_h), pm_h);
		2886	process_terminal_mode ('l', 0, ARRAY_LENGTH(pm_l), pm_l);
2836	}	2887	}
		2888	break;
		2889	}
		2890
2837	return;	2891	return;
2838	}	2892	}
2839		2893
2840	switch (ch)	2894	switch (ch)
2841	{	2895	{
…		…
2940		2994
2941	case CSI_SD: /* 8.3.114: (1) SCROLL DOWN */	2995	case CSI_SD: /* 8.3.114: (1) SCROLL DOWN */
2942	arg[0] = -arg[0];	2996	arg[0] = -arg[0];
2943	/* FALLTHROUGH */	2997	/* FALLTHROUGH */
2944	case CSI_SU: /* 8.3.148: (1) SCROLL UP */	2998	case CSI_SU: /* 8.3.148: (1) SCROLL UP */
2945	scr_scroll_text (screen.tscroll, screen.bscroll, arg[0], 0);	2999	scr_scroll_text (screen.tscroll, screen.bscroll, arg[0]);
2946	break;	3000	break;
2947		3001
2948	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */	3002	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */
2949	tt_write ((const unsigned char *)VT100_ANS,	3003	tt_write (VT100_ANS, sizeof (VT100_ANS) - 1);
2950	(unsigned int) (sizeof (VT100_ANS) - 1));
2951	break;	3004	break;
2952		3005
2953	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */	3006	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */
2954	process_sgr_mode (nargs, arg);	3007	process_sgr_mode (nargs, arg);
2955	break;	3008	break;
…		…
2962	break;	3015	break;
2963	case 6: /* CPR requested */	3016	case 6: /* CPR requested */
2964	scr_report_position ();	3017	scr_report_position ();
2965	break;	3018	break;
2966	case 7: /* unofficial extension */	3019	case 7: /* unofficial extension */
2967	if (Options & Opt_insecure)	3020	if (option (Opt_insecure))
2968	tt_printf ("%-.250s\n", rs[Rs_display_name]);	3021	tt_printf ("%-.250s\012", rs[Rs_display_name]);
2969	break;	3022	break;
2970	case 8: /* unofficial extension */	3023	case 8: /* unofficial extension */
2971	process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);	3024	process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);
2972	break;	3025	break;
2973	}	3026	}
…		…
3009	break;	3062	break;
3010		3063
3011	case CSI_RM: /* 8.3.107: RESET MODE */	3064	case CSI_RM: /* 8.3.107: RESET MODE */
3012	if (arg[0] == 4)	3065	if (arg[0] == 4)
3013	scr_insert_mode (0);	3066	scr_insert_mode (0);
		3067	else if (arg[0] == 20)
		3068	priv_modes &= ~PrivMode_LFNL;
3014	break;	3069	break;
3015		3070
3016	case CSI_SM: /* 8.3.126: SET MODE */	3071	case CSI_SM: /* 8.3.126: SET MODE */
3017	if (arg[0] == 4)	3072	if (arg[0] == 4)
3018	scr_insert_mode (1);	3073	scr_insert_mode (1);
		3074	else if (arg[0] == 20)
		3075	priv_modes |= PrivMode_LFNL;
3019	break;	3076	break;
3020		3077
3021	/*	3078	/*
3022	* PRIVATE USE beyond this point. All CSI_7? sequences here	3079	* PRIVATE USE beyond this point. All CSI_7? sequences here
3023	*/	3080	*/
…		…
3035	break;	3092	break;
3036	case CSI_75:	3093	case CSI_75:
3037	scr_cursor (RESTORE);	3094	scr_cursor (RESTORE);
3038	break;	3095	break;
3039		3096
3040	#ifndef NO_FRILLS	3097	#if !ENABLE_MINIMAL
3041	case CSI_74:	3098	case CSI_74:
3042	process_window_ops (arg, nargs);	3099	process_window_ops (arg, nargs);
3043	break;	3100	break;
3044	#endif	3101	#endif
3045		3102
…		…
3052	break;	3109	break;
3053	}	3110	}
3054	}	3111	}
3055	/*}}} */	3112	/*}}} */
3056		3113
3057	#ifndef NO_FRILLS	3114	#if !ENABLE_MINIMAL
3058	/* ARGSUSED */	3115	/* ARGSUSED */
3059	void	3116	void
3060	rxvt_term::process_window_ops (const int *args, unsigned int nargs)	3117	rxvt_term::process_window_ops (const int *args, unsigned int nargs)
3061	{	3118	{
3062	int x, y;	3119	int x, y;
3063	XWindowAttributes wattr;	3120	XWindowAttributes wattr;
3064	Window wdummy;	3121	Window wdummy;
		3122
		3123	dLocal (Display *, dpy);
3065		3124
3066	if (nargs == 0)	3125	if (nargs == 0)
3067	return;	3126	return;
3068		3127
3069	switch (args[0])	3128	switch (args[0])
3070	{	3129	{
3071	/*	3130	/*
3072	* commands	3131	* commands
3073	*/	3132	*/
3074	case 1: /* deiconify window */	3133	case 1: /* deiconify window */
3075	XMapWindow (display->display, TermWin.parent[0]);	3134	XMapWindow (dpy, parent[0]);
3076	break;	3135	break;
3077	case 2: /* iconify window */	3136	case 2: /* iconify window */
3078	XIconifyWindow (display->display, TermWin.parent[0],	3137	XIconifyWindow (dpy, parent[0], display->screen);
3079	DefaultScreen (display->display));
3080	break;	3138	break;
3081	case 3: /* set position (pixels) */	3139	case 3: /* set position (pixels) */
3082	XMoveWindow (display->display, TermWin.parent[0], args[1], args[2]);	3140	XMoveWindow (dpy, parent[0], args[1], args[2]);
3083	break;	3141	break;
3084	case 4: /* set size (pixels) */	3142	case 4: /* set size (pixels) */
3085	set_widthheight ((unsigned int)args[2], (unsigned int)args[1]);	3143	set_widthheight ((unsigned int)args[2], (unsigned int)args[1]);
3086	break;	3144	break;
3087	case 5: /* raise window */	3145	case 5: /* raise window */
3088	XRaiseWindow (display->display, TermWin.parent[0]);	3146	XRaiseWindow (dpy, parent[0]);
3089	break;	3147	break;
3090	case 6: /* lower window */	3148	case 6: /* lower window */
3091	XLowerWindow (display->display, TermWin.parent[0]);	3149	XLowerWindow (dpy, parent[0]);
3092	break;	3150	break;
3093	case 7: /* refresh window */	3151	case 7: /* refresh window */
3094	scr_touch (true);	3152	scr_touch (true);
3095	break;	3153	break;
3096	case 8: /* set size (chars) */	3154	case 8: /* set size (chars) */
3097	set_widthheight ((unsigned int) (args[2] * TermWin.fwidth),	3155	set_widthheight ((unsigned int) (args[2] * fwidth),
3098	(unsigned int) (args[1] * TermWin.fheight));	3156	(unsigned int) (args[1] * fheight));
3099	break;	3157	break;
3100		3158
3101	//case 9: NYI, TODO, restore maximized window or maximize window	3159	//case 9: NYI, TODO, restore maximized window or maximize window
3102	default:	3160	default:
3103	if (args[0] >= 24) /* set height (chars) */	3161	if (args[0] >= 24) /* set height (chars) */
3104	set_widthheight ((unsigned int)TermWin.width,	3162	set_widthheight ((unsigned int)width,
3105	(unsigned int) (args[1] * TermWin.fheight));	3163	(unsigned int) (args[1] * fheight));
3106	break;	3164	break;
3107
3108		3165
3109	/*	3166	/*
3110	* reports - some output format copied from XTerm	3167	* reports - some output format copied from XTerm
3111	*/	3168	*/
3112	case 11: /* report window state */	3169	case 11: /* report window state */
3113	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);	3170	XGetWindowAttributes (dpy, parent[0], &wattr);
3114	tt_printf ("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);	3171	tt_printf ("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);
3115	break;	3172	break;
3116	case 13: /* report window position */	3173	case 13: /* report window position */
3117	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);	3174	XGetWindowAttributes (dpy, parent[0], &wattr);
3118	XTranslateCoordinates (display->display, TermWin.parent[0], wattr.root,	3175	XTranslateCoordinates (dpy, parent[0], wattr.root,
3119	-wattr.border_width, -wattr.border_width,	3176	-wattr.border_width, -wattr.border_width,
3120	&x, &y, &wdummy);	3177	&x, &y, &wdummy);
3121	tt_printf ("\033[3;%d;%dt", x, y);	3178	tt_printf ("\033[3;%d;%dt", x, y);
3122	break;	3179	break;
3123	case 14: /* report window size (pixels) */	3180	case 14: /* report window size (pixels) */
3124	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);	3181	XGetWindowAttributes (dpy, parent[0], &wattr);
3125	tt_printf ("\033[4;%d;%dt", wattr.height, wattr.width);	3182	tt_printf ("\033[4;%d;%dt", wattr.height, wattr.width);
3126	break;	3183	break;
3127	case 18: /* report text area size (chars) */	3184	case 18: /* report text area size (chars) */
3128	tt_printf ("\033[8;%d;%dt", TermWin.nrow, TermWin.ncol);	3185	tt_printf ("\033[8;%d;%dt", nrow, ncol);
3129	break;	3186	break;
3130	case 19: /* report window size (chars) */	3187	case 19: /* report window size (chars) */
3131	tt_printf ("\033[9;%d;%dt", TermWin.nrow, TermWin.ncol);	3188	tt_printf ("\033[9;%d;%dt", nrow, ncol);
3132	break;	3189	break;
3133	case 20: /* report icon label */	3190	case 20: /* report icon label */
3134	if (Options & Opt_insecure)
3135	{	3191	{
3136	char *s;	3192	char *s;
3137	XGetIconName (display->display, TermWin.parent[0], &s);	3193	XGetIconName (dpy, parent[0], &s);
3138	tt_printf ("\033]L%-.200s\234", s ? s : ""); /* 8bit ST */	3194	tt_printf ("\033]L%-.250s\234", option (Opt_insecure) && s ? s : ""); /* 8bit ST */
		3195	XFree (s);
3139	}	3196	}
3140	break;	3197	break;
3141	case 21: /* report window title */	3198	case 21: /* report window title */
3142	if (Options & Opt_insecure)
3143	{	3199	{
3144	char *s;	3200	char *s;
3145	XFetchName (display->display, TermWin.parent[0], &s);	3201	XFetchName (dpy, parent[0], &s);
3146	tt_printf ("\033]l%-.200s\234", s ? s : ""); /* 8bit ST */	3202	tt_printf ("\033]l%-.250s\234", option (Opt_insecure) && s ? s : ""); /* 8bit ST */
		3203	XFree (s);
3147	}	3204	}
3148	break;	3205	break;
3149	}	3206	}
3150	}	3207	}
3151	#endif	3208	#endif
3152		3209
3153	/*----------------------------------------------------------------------*/	3210	/*----------------------------------------------------------------------*/
3154	/*	3211	/*
3155	* get input up until STRING TERMINATOR (or BEL)	3212	* get input up until STRING TERMINATOR (or BEL)
3156	* ends_how is terminator used. returned input must be free()'d	3213	* ends_how is terminator used. returned input must be free()'d
3157	*/	3214	*/
3158	unsigned char *	3215	char *
3159	rxvt_term::get_to_st (unicode_t &ends_how)	3216	rxvt_term::get_to_st (unicode_t &ends_how)
3160	{	3217	{
3161	unicode_t prev = 0, ch;	3218	unicode_t ch;
		3219	bool seen_esc = false;
3162	unsigned int n = 0;	3220	unsigned int n = 0;
3163	unsigned char *s;
3164	unsigned char string[STRING_MAX];	3221	wchar_t string[STRING_MAX];
3165		3222
3166	while ((ch = cmd_getc ()) != NOCHAR)	3223	while ((ch = cmd_getc ()) != NOCHAR)
3167	{	3224	{
3168	if (prev == C0_ESC)	3225	if (seen_esc)
3169	{	3226	{
3170	if (ch == 0x5c) /* 7bit ST */	3227	if (ch == 0x5c) /* 7bit ST */
3171	break;	3228	break;
3172	else	3229	else
3173	return NULL;	3230	return NULL;
3174	}	3231	}
		3232	else if (ch == C0_ESC)
		3233	{
		3234	seen_esc = true;
		3235	continue;
		3236	}
3175	else if (ch == C0_BEL || ch == CHAR_ST)	3237	else if (ch == C0_BEL || ch == CHAR_ST)
3176	break;	3238	break;
		3239	else if (ch == C0_SYN)
		3240	ch = cmd_get8 ();
3177	else if (ch < 0x20)	3241	else if (ch < 0x20)
3178	return NULL; /* other control character - exit */	3242	return NULL; /* other control character - exit */
3179		3243
3180	if (n >= sizeof (string) - 1)	3244	seen_esc = false;
		3245
		3246	if (n >= STRING_MAX - 1)
3181	// stop at some sane length	3247	// stop at some sane length
3182	return NULL;	3248	return NULL;
3183		3249
3184	if (ch == C0_SYN)
3185	{
3186	string[n++] = cmd_get8 ();
3187	prev = 0;
3188	}
3189	else
3190	string[n++] = prev = ch;	3250	string[n++] = ch;
3191	}	3251	}
3192		3252
3193	string[n++] = '\0';	3253	string[n++] = '\0';
3194		3254
3195	if ((s = (unsigned char *)rxvt_malloc (n)) == NULL)
3196	return NULL;
3197
3198	ends_how = (ch == 0x5c ? C0_ESC : ch);	3255	ends_how = (ch == 0x5c ? C0_ESC : ch);
3199	STRNCPY (s, string, n);	3256
3200	return s;	3257	return rxvt_wcstombs (string);
3201	}	3258	}
3202		3259
3203	/*----------------------------------------------------------------------*/	3260	/*----------------------------------------------------------------------*/
3204	/*	3261	/*
3205	* process DEVICE CONTROL STRING `ESC P ... (ST|BEL)' or `0x90 ... (ST|BEL)'	3262	* process DEVICE CONTROL STRING `ESC P ... (ST|BEL)' or `0x90 ... (ST|BEL)'
3206	*/	3263	*/
3207	void	3264	void
3208	rxvt_term::process_dcs_seq ()	3265	rxvt_term::process_dcs_seq ()
3209	{	3266	{
3210	unsigned char *s;
3211	unicode_t eh;
3212
3213	/*	3267	/*
3214	* Not handled yet	3268	* Not handled yet
3215	*/	3269	*/
		3270
		3271	unicode_t eh;
3216	s = get_to_st (eh);	3272	char *s = get_to_st (eh);
3217	if (s)	3273	if (s)
3218	free (s);	3274	free (s);
3219		3275
3220	return;	3276	return;
3221	}	3277	}
…		…
3225	* process OPERATING SYSTEM COMMAND sequence `ESC ] Ps ; Pt (ST|BEL)'	3281	* process OPERATING SYSTEM COMMAND sequence `ESC ] Ps ; Pt (ST|BEL)'
3226	*/	3282	*/
3227	void	3283	void
3228	rxvt_term::process_osc_seq ()	3284	rxvt_term::process_osc_seq ()
3229	{	3285	{
3230	unicode_t ch, eh;
3231	int arg;	3286	int arg;
3232		3287
3233	ch = cmd_getc ();	3288	unicode_t ch = cmd_getc ();
3234	for (arg = 0; isdigit (ch); ch = cmd_getc ())	3289	for (arg = 0; isdigit (ch); ch = cmd_getc ())
3235	arg = arg * 10 + (ch - '0');	3290	arg = arg * 10 + (ch - '0');
3236		3291
3237	if (ch == ';')	3292	if (ch == ';')
3238	{	3293	{
		3294	unicode_t eh;
3239	unsigned char *s = get_to_st (eh);	3295	char *s = get_to_st (eh);
3240		3296
3241	if (s)	3297	if (s)
3242	{	3298	{
3243	process_xterm_seq (arg, (char *)s, eh);	3299	process_xterm_seq (arg, s, eh);
3244	free (s);	3300	free (s);
3245	}	3301	}
3246	}	3302	}
3247	}	3303	}
3248		3304
3249	void	3305	void
3250	rxvt_term::process_color_seq (int report, int color, const char *str, unsigned char resp)	3306	rxvt_term::process_color_seq (int report, int color, const char *str, char resp)
3251	{	3307	{
3252	if (str[0] == '?' && !str[1])	3308	if (str[0] == '?' && !str[1])
3253	{	3309	{
3254	if (Options & Opt_insecure)	3310	rgba c;
3255	{	3311	pix_colors_focused[color].get (c);
3256	unsigned short r, g, b;	3312
3257	PixColors[color].get (display, r, g, b);	3313	#if XFT
		3314	if (c.a != rgba::MAX_CC)
		3315	tt_printf ("\033]%d;rgba:%04x/%04x/%04x/%04x%c", report, c.a, c.r, c.g, c.b, resp);
		3316	else
		3317	#endif
3258	tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, r, g, b, resp);	3318	tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, c.r, c.g, c.b, resp);
3259	}
3260	}	3319	}
3261	else	3320	else
3262	set_window_color (color, str);	3321	set_window_color (color, str);
3263	}	3322	}
3264		3323
3265	/*	3324	/*
3266	* XTerm escape sequences: ESC ] Ps;Pt (ST|BEL)	3325	* XTerm escape sequences: ESC ] Ps;Pt (ST|BEL)
3267	* 0 = change iconName/title
3268	* 1 = change iconName
3269	* 2 = change title
3270	* 4 = change color
3271	* 10 = change fg color
3272	* 11 = change bg color
3273	* 12 = change text color
3274	* 13 = change mouse foreground color
3275	* 17 = change highlight character colour
3276	* 18 = change bold character color
3277	* 19 = change underlined character color
3278	* 46 = change logfile (not implemented)
3279	* 50 = change font
3280	*
3281	* rxvt extensions:
3282	* 20 = bg pixmap
3283	* 39 = change default fg color
3284	* 49 = change default bg color
3285	* 55 = dump scrollback buffer and all of screen
3286	* 701 = change locale
3287	* 702 = find font
3288	* 703 = menu
3289	*/	3326	*/
3290	void	3327	void
3291	rxvt_term::process_xterm_seq (int op, const char *str, unsigned char resp)	3328	rxvt_term::process_xterm_seq (int op, char *str, char resp)
3292	{	3329	{
3293	int changed = 0;
3294	int color;	3330	int color;
3295	char *buf, *name;	3331	char *buf, *name;
3296	bool query = str[0] == '?' && !str[1];	3332	bool query = str[0] == '?' && !str[1];
		3333	int saveop = op;
		3334
		3335	dLocal (Display *, dpy);
3297		3336
3298	assert (str != NULL);	3337	assert (str != NULL);
		3338
		3339	if (HOOK_INVOKE ((this, HOOK_OSC_SEQ, DT_INT, op, DT_STR, str, DT_END)))
		3340	return;
		3341
3299	switch (op)	3342	switch (op)
3300	{	3343	{
3301	case XTerm_name:	3344	case XTerm_name:
3302	set_title (str);	3345	set_title (str);
3303	/* FALLTHROUGH */	3346	/* FALLTHROUGH */
…		…
3308	set_title (str);	3351	set_title (str);
3309	break;	3352	break;
3310	case XTerm_property:	3353	case XTerm_property:
3311	if (str[0] == '?')	3354	if (str[0] == '?')
3312	{	3355	{
3313	Atom prop = XInternAtom (display->display, str + 1, True);	3356	Atom prop = display->atom (str + 1);
3314	Atom actual_type;	3357	Atom actual_type;
3315	int actual_format;	3358	int actual_format;
3316	unsigned long nitems;	3359	unsigned long nitems;
3317	unsigned long bytes_after;	3360	unsigned long bytes_after;
3318	unsigned char *value = 0;	3361	unsigned char *value = 0;
3319	const char *str = "";	3362	const char *str = "";
3320		3363
3321	if (prop	3364	if (prop
3322	&& XGetWindowProperty (display->display, TermWin.parent[0],	3365	&& XGetWindowProperty (dpy, parent[0],
3323	prop, 0, 1<<16, 0, AnyPropertyType,	3366	prop, 0, 1<<16, 0, AnyPropertyType,
3324	&actual_type, &actual_format,	3367	&actual_type, &actual_format,
3325	&nitems, &bytes_after, &value) == Success	3368	&nitems, &bytes_after, &value) == Success
3326	&& actual_type != None	3369	&& actual_type != None
3327	&& actual_format == 8)	3370	&& actual_format == 8)
3328	str = (const char *)(value);	3371	str = (const char *)(value);
3329		3372
3330	tt_printf ("\033]%d;%s%c", XTerm_property, str, resp);	3373	tt_printf ("\033]%d;%s%c", op, str, resp);
3331		3374
3332	XFree (value);	3375	XFree (value);
3333	}	3376	}
3334	else	3377	else
3335	{	3378	{
3336	char *eq = strchr (str, '='); // constness lost, but verified to be ok	3379	char *eq = strchr (str, '=');
3337		3380
3338	if (eq)	3381	if (eq)
3339	{	3382	{
3340	*eq = 0;	3383	*eq = 0;
3341	XChangeProperty (display->display, TermWin.parent[0],	3384	set_utf8_property (display->atom (str), eq + 1);
3342	display->atom (str), XA_STRING, 8,
3343	PropModeReplace, (unsigned char *)eq + 1,
3344	strlen (eq + 1));
3345	}	3385	}
3346	else	3386	else
3347	XDeleteProperty (display->display, TermWin.parent[0],	3387	XDeleteProperty (dpy, parent[0],
3348	display->atom (str));	3388	display->atom (str));
3349	}	3389	}
3350	break;	3390	break;
3351		3391
3352	case XTerm_Color:	3392	case XTerm_Color:
3353	for (buf = (char *)str; buf && *buf;)	3393	for (buf = (char *)str; buf && *buf;)
3354	{	3394	{
3355	if ((name = STRCHR (buf, ';')) == NULL)	3395	if ((name = strchr (buf, ';')) == NULL)
3356	break;	3396	break;
3357		3397
3358	*name++ = '\0';	3398	*name++ = '\0';
3359	color = atoi (buf);	3399	color = atoi (buf) + minCOLOR;
3360		3400
3361	if (color < 0 || color >= TOTAL_COLORS)	3401	if (!IN_RANGE_INC (color, minCOLOR, maxTermCOLOR))
3362	break;	3402	break;
3363		3403
3364	if ((buf = STRCHR (name, ';')) != NULL)	3404	if ((buf = strchr (name, ';')) != NULL)
3365	*buf++ = '\0';	3405	*buf++ = '\0';
3366		3406
3367	if (name[0] == '?' && !name[1])	3407	process_color_seq (op, color, name, resp);
		3408	}
		3409	break;
		3410	case Rxvt_restoreFG:
		3411	case XTerm_Color00:
		3412	process_color_seq (op, Color_fg, str, resp);
		3413	break;
		3414	case Rxvt_restoreBG:
		3415	case XTerm_Color01:
		3416	process_color_seq (op, Color_bg, str, resp);
		3417	break;
		3418	#ifndef NO_CURSORCOLOR
		3419	case XTerm_Color_cursor:
		3420	process_color_seq (op, Color_cursor, str, resp);
		3421	break;
		3422	#endif
		3423	case XTerm_Color_pointer_fg:
		3424	process_color_seq (op, Color_pointer_fg, str, resp);
		3425	break;
		3426	case XTerm_Color_pointer_bg:
		3427	process_color_seq (op, Color_pointer_bg, str, resp);
		3428	break;
		3429	#ifdef OPTION_HC
		3430	case XTerm_Color_HC:
		3431	process_color_seq (op, Color_HC, str, resp);
		3432	break;
		3433	case XTerm_Color_HTC:
		3434	process_color_seq (op, Color_HTC, str, resp);
		3435	break;
		3436	#endif
		3437	#ifndef NO_BOLD_UNDERLINE_REVERSE
		3438	case URxvt_Color_BD:
		3439	process_color_seq (op, Color_BD, str, resp);
		3440	break;
		3441	case URxvt_Color_UL:
		3442	process_color_seq (op, Color_UL, str, resp);
		3443	break;
		3444	case URxvt_Color_IT:
		3445	process_color_seq (op, Color_IT, str, resp);
		3446	break;
		3447	#endif
		3448	case URxvt_Color_border:
		3449	process_color_seq (op, Color_border, str, resp);
		3450	break;
		3451	#if ENABLE_TRANSPARENCY
		3452	case URxvt_Color_tint:
		3453	process_color_seq (op, Color_tint, str, resp);
		3454	{
		3455	bool changed = false;
		3456
		3457	if (ISSET_PIXCOLOR (Color_tint))
		3458	changed = bg_set_tint (pix_colors_focused [Color_tint]);
		3459
		3460	if (changed)
		3461	update_background ();
		3462	}
		3463
		3464	break;
		3465	#endif
		3466
		3467	#if BG_IMAGE_FROM_FILE
		3468	case Rxvt_Pixmap:
		3469	if (!strcmp (str, "?"))
		3470	{
		3471	char str[256];
		3472
		3473	sprintf (str, "[%dx%d+%d+%d]",
		3474	min (h_scale, 32767), min (v_scale, 32767),
		3475	min (h_align, 32767), min (v_align, 32767));
		3476	process_xterm_seq (XTerm_title, str, CHAR_ST);
		3477	}
		3478	else
		3479	{
		3480	int changed = 0;
		3481
		3482	if (*str != ';')
3368	{	3483	{
3369	if (Options & Opt_insecure)	3484	if (bg_set_file (str)) /* change pixmap */
3370	{	3485	{
3371	unsigned short r, g, b;	3486	changed++;
3372	PixColors[color + minCOLOR].get (display, r, g, b);	3487	str = strchr (str, ';');
3373	tt_printf ("\033]%d;%d;rgb:%04x/%04x/%04x%c", XTerm_Color, color, r, g, b, resp);	3488	if (str == NULL)
		3489	bg_set_default_geometry ();
		3490	else
		3491	bg_set_geometry (str+1);
3374	}	3492	}
3375	}	3493	}
3376	else	3494	else
3377	set_window_color (color + minCOLOR, name);	3495	{
		3496	str++;
		3497	if (bg_set_geometry (str, true))
		3498	changed++;
		3499	}
		3500
		3501	if (changed)
		3502	{
		3503	if (bg_window_position_sensitive ())
		3504	{
		3505	int x, y;
		3506	get_window_origin (x, y);
		3507	bg_set_position (x, y);
		3508	}
		3509	update_background ();
		3510	}
3378	}	3511	}
3379	break;	3512	break;
3380	case XTerm_Color00:
3381	process_color_seq (XTerm_Color00, Color_fg, str, resp);
3382	break;
3383	case XTerm_Color01:
3384	process_color_seq (XTerm_Color00, Color_bg, str, resp);
3385	break;
3386	#ifndef NO_CURSORCOLOR
3387	case XTerm_Color_cursor:
3388	process_color_seq (XTerm_Color_cursor, Color_cursor, str, resp);
3389	break;
3390	#endif	3513	#endif
3391	case XTerm_Color_pointer_fg:
3392	process_color_seq (XTerm_Color_pointer_fg, Color_pointer_fg, str, resp);
3393	break;
3394	case XTerm_Color_pointer_bg:
3395	process_color_seq (XTerm_Color_pointer_bg, Color_pointer_bg, str, resp);
3396	break;
3397	#ifndef NO_BOLD_UNDERLINE_REVERSE
3398	case XTerm_Color_BD:
3399	process_color_seq (XTerm_Color_BD, Color_BD, str, resp);
3400	break;
3401	case XTerm_Color_UL:
3402	process_color_seq (XTerm_Color_UL, Color_UL, str, resp);
3403	break;
3404	case XTerm_Color_RV:
3405	process_color_seq (XTerm_Color_RV, Color_RV, str, resp);
3406	break;
3407	#endif
3408
3409	case XTerm_Pixmap:
3410	if (*str != ';')
3411	{
3412	#if XPM_BACKGROUND
3413	scale_pixmap (""); /* reset to default scaling */
3414	set_bgPixmap (str); /* change pixmap */
3415	#endif
3416	scr_touch (true);
3417	}
3418	while ((str = STRCHR (str, ';')) != NULL)
3419	{
3420	str++;
3421	#if XPM_BACKGROUND
3422	changed += scale_pixmap (str);
3423	#endif
3424
3425	}
3426	if (changed)
3427	{
3428	#ifdef XPM_BACKGROUND
3429	resize_pixmap ();
3430	#endif
3431	scr_touch (true);
3432	}
3433	break;
3434
3435	case XTerm_restoreFG:
3436	set_window_color (Color_fg, str);
3437	break;
3438	case XTerm_restoreBG:
3439	set_window_color (Color_bg, str);
3440	break;
3441		3514
3442	case XTerm_logfile:	3515	case XTerm_logfile:
3443	// TODO, when secure mode?	3516	// TODO, when secure mode?
3444	break;	3517	break;
3445		3518
3446	case XTerm_font:
3447	if (query)
3448	{
3449	if (Options & Opt_insecure)
3450	tt_printf ("\33]%d;%-.250s%c", XTerm_font,
3451	TermWin.fontset->fontdesc
3452	? TermWin.fontset->fontdesc
3453	: "",
3454	resp);
3455	}
3456	else
3457	change_font (str);
3458	break;
3459
3460	#ifndef NO_FRILLS
3461	case XTerm_locale:
3462	if (query)
3463	{
3464	if (Options & Opt_insecure)
3465	tt_printf ("\33]%d;%-.250s%c", XTerm_locale, locale, resp);
3466	}
3467	else
3468	{
3469	set_locale (str);
3470	# ifdef USE_XIM
3471	im_cb ();
3472	# endif
3473	}
3474	break;
3475
3476	case XTerm_findfont:
3477	if (Options & Opt_insecure)
3478	{
3479	int fid = TermWin.fontset->find_font (atoi (str));
3480	tt_printf ("\33]%d;%d;%-.250s%c", XTerm_findfont,
3481	fid, (*TermWin.fontset)[fid]->name, resp);
3482	}
3483	break;
3484	#endif
3485
3486	#ifdef MENUBAR
3487	case XTerm_Menu:
3488	if (Options & Opt_insecure)
3489	menubar_dispatch (const_cast<char *>(str)); // casting away constness is checked
3490	break;
3491	#endif
3492	#if 0	3519	#if 0
3493	case XTerm_dumpscreen: /* no error notices */	3520	case Rxvt_dumpscreen: /* no error notices */
3494	{	3521	{
3495	int fd;	3522	int fd;
3496	if ((fd = open (str, O_RDWR | O_CREAT | O_EXCL, 0600)) >= 0)	3523	if ((fd = open (str, O_RDWR | O_CREAT | O_EXCL, 0600)) >= 0)
3497	{	3524	{
3498	scr_dump (fd);	3525	scr_dump (fd);
3499	close (fd);	3526	close (fd);
3500	}	3527	}
3501	}	3528	}
		3529	break;
		3530	#endif
		3531	case XTerm_font:
		3532	op = URxvt_font;
		3533	case URxvt_font:
		3534	#if ENABLE_STYLES
		3535	case URxvt_boldFont:
		3536	case URxvt_italicFont:
		3537	case URxvt_boldItalicFont:
		3538	#endif
		3539	if (query)
		3540	tt_printf ("\33]%d;%-.250s%c", saveop,
		3541	option (Opt_insecure) && fontset[op - URxvt_font]->fontdesc
		3542	? fontset[op - URxvt_font]->fontdesc : "",
		3543	resp);
		3544	else
		3545	{
		3546	const char *&res = rs[Rs_font + (op - URxvt_font)];
		3547
		3548	res = strdup (str);
		3549	allocated.push_back ((void *)res);
		3550	set_fonts ();
		3551	}
		3552	break;
		3553
		3554	case URxvt_version:
		3555	if (query)
		3556	tt_printf ("\33]%d;rxvt-unicode;%-.20s;%c;%c%c",
		3557	op,
		3558	rs[Rs_name], VERSION[0], VERSION[2],
		3559	resp);
		3560	break;
		3561
		3562	#if !ENABLE_MINIMAL
		3563	case URxvt_locale:
		3564	if (query)
		3565	tt_printf ("\33]%d;%-.250s%c", op, option (Opt_insecure) ? locale : "", resp);
		3566	else
		3567	{
		3568	set_locale (str);
		3569	pty->set_utf8_mode (enc_utf8);
		3570	init_xlocale ();
		3571	}
		3572	break;
		3573
		3574	case URxvt_view_up:
		3575	case URxvt_view_down:
		3576	{
		3577	int lines = atoi (str);
		3578
		3579	if (lines)
		3580	scr_page (op == URxvt_view_up ? UP : DN, lines);
		3581	else
		3582	scr_erase_savelines ();
		3583	}
		3584
		3585	break;
		3586	#endif
		3587
		3588	#if ENABLE_PERL
		3589	case URxvt_perl:
		3590	HOOK_INVOKE ((this, HOOK_OSC_SEQ_PERL, DT_STR, str, DT_STR_LEN, &resp, 1, DT_END));
3502	break;	3591	break;
3503	#endif	3592	#endif
3504	}	3593	}
3505	}	3594	}
3506	/*----------------------------------------------------------------------*/	3595	/*----------------------------------------------------------------------*/
…		…
3520	{	3609	{
3521	int state;	3610	int state;
3522		3611
3523	if (mode == 's')	3612	if (mode == 's')
3524	{	3613	{
3525	SavedModes |= (PrivateModes & bit);	3614	SavedModes |= (priv_modes & bit);
3526	return -1;	3615	return -1;
3527	}	3616	}
3528	else	3617	else
3529	{	3618	{
3530	if (mode == 'r')	3619	if (mode == 'r')
3531	state = (SavedModes & bit) ? 1 : 0; /* no overlapping */	3620	state = (SavedModes & bit) ? 1 : 0; /* no overlapping */
3532	else	3621	else
3533	state = (mode == 't') ? ! (PrivateModes & bit) : mode;	3622	state = (mode == 't') ? ! (priv_modes & bit) : mode;
3534	PrivMode (state, bit);	3623
		3624	set_privmode (bit, state);
3535	}	3625	}
3536		3626
3537	return state;	3627	return state;
3538	}	3628	}
3539		3629
3540	/* we're not using priv _yet_ */	3630	/* we're not using priv _yet_ */
3541	void	3631	void
3542	rxvt_term::process_terminal_mode (int mode, int priv __attribute__ ((unused)), unsigned int nargs, const int *arg)	3632	rxvt_term::process_terminal_mode (int mode, int priv UNUSED, unsigned int nargs, const int *arg)
3543	{	3633	{
3544	unsigned int i, j;	3634	unsigned int i, j;
3545	int state;	3635	int state;
3546		3636
3547	static const struct	3637	static const struct
3548	{	3638	{
3549	const int argval;	3639	const int argval;
3550	const unsigned long bit;	3640	const unsigned long bit;
3551	}
3552
3553	argtopriv[] = {	3641	} argtopriv[] = {
3554	{ 1, PrivMode_aplCUR },	3642	{ 1, PrivMode_aplCUR }, // DECCKM
3555	{ 2, PrivMode_vt52 },	3643	{ 2, PrivMode_vt52 },
3556	{ 3, PrivMode_132 },	3644	{ 3, PrivMode_132 }, // DECCOLM
3557	{ 4, PrivMode_smoothScroll },	3645	{ 4, PrivMode_smoothScroll }, // DECSCLM
3558	{ 5, PrivMode_rVideo },	3646	{ 5, PrivMode_rVideo }, // DECSCNM
3559	{ 6, PrivMode_relOrigin },	3647	{ 6, PrivMode_relOrigin }, // DECOM
3560	{ 7, PrivMode_Autowrap },	3648	{ 7, PrivMode_Autowrap }, // DECAWM
		3649	// 8, auto-repeat keys // DECARM
3561	{ 9, PrivMode_MouseX10 },	3650	{ 9, PrivMode_MouseX10 },
3562	#ifdef menuBar_esc	3651	// 18 end FF to printer after print screen
3563	{ menuBar_esc, PrivMode_menuBar },	3652	// 19 Print screen prints full screen/scroll region
3564	#endif	3653	{ 25, PrivMode_VisibleCursor }, // cnorm/cvvis/civis
3565	#ifdef scrollBar_esc	3654	#ifdef scrollBar_esc
3566	{ scrollBar_esc, PrivMode_scrollBar },	3655	{ scrollBar_esc, PrivMode_scrollBar },
3567	#endif	3656	#endif
3568	// 18, 19 printing-related
3569	{ 25, PrivMode_VisibleCursor },
3570	// 30 show scrollbar rxvt. extension
3571	{ 35, PrivMode_ShiftKeys }, // rxvt extension	3657	{ 35, PrivMode_ShiftKeys }, // rxvt extension
		3658	// 38, tektronix mode // DECTEK
3572	{ 40, PrivMode_132OK },	3659	{ 40, PrivMode_132OK },
3573	// 41 xterm more fixes NYI	3660	// 41 xterm more fixes NYI
3574	// 45 margin bell NYI	3661	// 45 margin bell NYI
3575	// 46 start logging	3662	// 46 start logging
3576	{ 47, PrivMode_Screen },	3663	{ 47, PrivMode_Screen },
3577	{ 66, PrivMode_aplKP },	3664	{ 66, PrivMode_aplKP }, // DECPAM/DECPNM
3578	#ifndef NO_BACKSPACE_KEY	3665	#ifndef NO_BACKSPACE_KEY
3579	{ 67, PrivMode_BackSpace },	3666	{ 67, PrivMode_BackSpace }, // DECBKM
3580	#endif	3667	#endif
3581	{ 1000, PrivMode_MouseX11 },	3668	{ 1000, PrivMode_MouseX11 },
3582	// 1001 Use Hilite Mouse Tracking. NYI, TODO	3669	{ 1002, PrivMode_MouseBtnEvent },
3583	// 1002 Use Cell Motion Mouse Tracking. NYI, TODO	3670	{ 1003, PrivMode_MouseAnyEvent },
3584	// 1003 Use All Motion Mouse Tracking. NYI, TODO	3671	#if ENABLE_FRILLS
		3672	{ 1005, PrivMode_ExtModeMouse },
		3673	#endif
3585	{ 1010, PrivMode_TtyOutputInh }, // rxvt extension	3674	{ 1010, PrivMode_TtyOutputInh }, // rxvt extension
3586	{ 1011, PrivMode_Keypress }, // rxvt extension	3675	{ 1011, PrivMode_Keypress }, // rxvt extension
		3676	#if ENABLE_FRILLS
		3677	{ 1015, PrivMode_ExtMouseRight }, // urxvt extension of 1005
		3678	#endif
3587	// 1035 enable modifiers for alt, numlock NYI	3679	// 1035 enable modifiers for alt, numlock NYI
3588	// 1036 send ESC for meta keys NYI	3680	// 1036 send ESC for meta keys NYI
3589	// 1037 send DEL for keypad delete NYI	3681	// 1037 send DEL for keypad delete NYI
3590	{ 1047, PrivMode_Screen },	3682	{ 1047, PrivMode_Screen },
3591	// 1048 save and restore cursor	3683	// 1048 save and restore cursor, implemented in code
3592	{ 1049, PrivMode_Screen }, /* xterm extension, clear screen on ti rather than te */	3684	{ 1049, PrivMode_Screen }, /* xterm extension, clear screen on ti rather than te */
3593	// 1051, 1052, 1060, 1061 keyboard emulation NYI	3685	// 1051, 1052, 1060, 1061 keyboard emulation NYI
		3686	{ 2004, PrivMode_BracketPaste },
3594	};	3687	};
3595		3688
3596	if (nargs == 0)	3689	if (nargs == 0)
3597	return;	3690	return;
3598		3691
…		…
3605	for (i = 0; i < nargs; i++)	3698	for (i = 0; i < nargs; i++)
3606	{	3699	{
3607	state = -1;	3700	state = -1;
3608		3701
3609	/* basic handling */	3702	/* basic handling */
3610	for (j = 0; j < (sizeof (argtopriv)/sizeof (argtopriv[0])); j++)	3703	for (j = 0; j < ARRAY_LENGTH(argtopriv); j++)
3611	if (argtopriv[j].argval == arg[i])	3704	if (argtopriv[j].argval == arg[i])
3612	{	3705	{
3613	state = privcases (mode, argtopriv[j].bit);	3706	state = privcases (mode, argtopriv[j].bit);
3614	break;	3707	break;
3615	}	3708	}
3616		3709
3617	/* extra handling for values with state unkept */	3710	/* extra handling for values with state unkept */
3618	switch (arg[i])	3711	switch (arg[i])
3619	{	3712	{
		3713	#if ENABLE_STYLES
		3714	case 1021:
		3715	set_option (Opt_intensityStyles, mode);
		3716
		3717	scr_touch (true);
		3718	break;
		3719	#endif
3620	case 1048: /* alternative cursor save */	3720	case 1048: /* alternative cursor save */
3621	if (Options & Opt_secondaryScreen)	3721	if (option (Opt_secondaryScreen))
3622	if (mode == 0)	3722	if (mode == 0)
3623	scr_cursor (RESTORE);	3723	scr_cursor (RESTORE);
3624	else if (mode == 1)	3724	else if (mode == 1)
3625	scr_cursor (SAVE);	3725	scr_cursor (SAVE);
3626	break;	3726	break;
…		…
3634	case 2: /* VT52 mode */	3734	case 2: /* VT52 mode */
3635	/* oddball mode. should be set regardless of set/reset	3735	/* oddball mode. should be set regardless of set/reset
3636	* parameter. Return from VT52 mode with an ESC < from	3736	* parameter. Return from VT52 mode with an ESC < from
3637	* within VT52 mode	3737	* within VT52 mode
3638	*/	3738	*/
3639	PrivMode (1, PrivMode_vt52);	3739	set_privmode (PrivMode_vt52, 1);
3640	break;	3740	break;
3641	case 3: /* 80/132 */	3741	case 3: /* 80/132 */
3642	if (PrivateModes & PrivMode_132OK)	3742	if (priv_modes & PrivMode_132OK)
3643	set_widthheight (((state ? 132 : 80) * TermWin.fwidth), TermWin.height);	3743	set_widthheight ((state ? 132 : 80) * fwidth, 24 * fheight);
3644	break;	3744	break;
3645	case 4: /* smooth scrolling */	3745	case 4: /* smooth scrolling */
3646	if (state)	3746	set_option (Opt_jumpScroll, !state);
3647	Options &= ~Opt_jumpScroll;
3648	else
3649	Options |= Opt_jumpScroll;
3650	break;	3747	break;
3651	case 5: /* reverse video */	3748	case 5: /* reverse video */
3652	scr_rvideo_mode (state);	3749	scr_rvideo_mode (state);
3653	break;	3750	break;
3654	case 6: /* relative/absolute origins */	3751	case 6: /* relative/absolute origins */
…		…
3658	scr_autowrap (state);	3755	scr_autowrap (state);
3659	break;	3756	break;
3660	/* case 8: - auto repeat, can't do on a per window basis */	3757	/* case 8: - auto repeat, can't do on a per window basis */
3661	case 9: /* X10 mouse reporting */	3758	case 9: /* X10 mouse reporting */
3662	if (state) /* orthogonal */	3759	if (state) /* orthogonal */
3663	PrivateModes &= ~PrivMode_MouseX11;	3760	priv_modes &= ~(PrivMode_MouseX11|PrivMode_MouseBtnEvent|PrivMode_MouseAnyEvent);
3664	break;	3761	break;
3665	#ifdef menuBar_esc
3666	case menuBar_esc:
3667	#ifdef MENUBAR
3668	map_menuBar (state);
3669	#endif
3670	break;
3671	#endif
3672	#ifdef scrollBar_esc	3762	#ifdef scrollBar_esc
3673	case scrollBar_esc:	3763	case scrollBar_esc:
3674	if (scrollbar_mapping (state))	3764	if (scrollBar.map (state))
3675	{	3765	{
3676	resize_all_windows (0, 0, 0);	3766	resize_all_windows (0, 0, 0);
3677	scr_touch (true);	3767	scr_touch (true);
3678	}	3768	}
3679	break;	3769	break;
…		…
3688	break;	3778	break;
3689	/* case 66: - application key pad */	3779	/* case 66: - application key pad */
3690	/* case 67: - backspace key */	3780	/* case 67: - backspace key */
3691	case 1000: /* X11 mouse reporting */	3781	case 1000: /* X11 mouse reporting */
3692	if (state) /* orthogonal */	3782	if (state) /* orthogonal */
3693	PrivateModes &= ~PrivMode_MouseX10;	3783	priv_modes &= ~(PrivMode_MouseX10|PrivMode_MouseBtnEvent|PrivMode_MouseAnyEvent);
3694	break;	3784	break;
3695	#if 0
3696	case 1001:	3785	case 1002:
3697	break; /* X11 mouse highlighting */	3786	case 1003:
3698	#endif	3787	if (state)
		3788	{
		3789	priv_modes &= ~(PrivMode_MouseX10|PrivMode_MouseX11);
		3790	priv_modes &= arg[i] == 1003 ? ~PrivMode_MouseBtnEvent : ~PrivMode_MouseAnyEvent;
		3791	mouse_row = mouse_col = 0;
		3792	vt_emask_mouse = PointerMotionMask;
		3793	}
		3794	else
		3795	vt_emask_mouse = NoEventMask;
		3796
		3797	vt_select_input ();
		3798	break;
3699	case 1010: /* scroll to bottom on TTY output inhibit */	3799	case 1010: /* scroll to bottom on TTY output inhibit */
3700	if (state)
3701	Options &= ~Opt_scrollTtyOutput;
3702	else
3703	Options |= Opt_scrollTtyOutput;	3800	set_option (Opt_scrollTtyOutput, !state);
3704	break;	3801	break;
3705	case 1011: /* scroll to bottom on key press */	3802	case 1011: /* scroll to bottom on key press */
3706	if (state)
3707	Options |= Opt_scrollTtyKeypress;	3803	set_option (Opt_scrollTtyKeypress, state);
3708	else
3709	Options &= ~Opt_scrollTtyKeypress;
3710	break;	3804	break;
3711	case 1047: /* secondary screen w/ clearing last */	3805	case 1047: /* secondary screen w/ clearing last */
3712	if (Options & Opt_secondaryScreen)	3806	if (option (Opt_secondaryScreen))
3713	if (current_screen != PRIMARY)	3807	if (!state)
3714	scr_erase_screen (2);	3808	scr_erase_screen (2);
		3809
3715	scr_change_screen (state);	3810	scr_change_screen (state);
3716	break;	3811	break;
3717	case 1049: /* secondary screen w/ clearing first */	3812	case 1049: /* secondary screen w/ clearing first */
		3813	if (option (Opt_secondaryScreen))
		3814	if (state)
		3815	scr_cursor (SAVE);
		3816
3718	scr_change_screen (state);	3817	scr_change_screen (state);
		3818
3719	if (Options & Opt_secondaryScreen)	3819	if (option (Opt_secondaryScreen))
3720	if (current_screen != PRIMARY)	3820	if (state)
3721	scr_erase_screen (2);	3821	scr_erase_screen (2);
		3822	else
		3823	scr_cursor (RESTORE);
3722	break;	3824	break;
3723	default:	3825	default:
3724	break;	3826	break;
3725	}	3827	}
3726	}	3828	}
…		…
3750	rendset = 0, rendstyle = ~RS_None;	3852	rendset = 0, rendstyle = ~RS_None;
3751	break;	3853	break;
3752	case 1:	3854	case 1:
3753	rendset = 1, rendstyle = RS_Bold;	3855	rendset = 1, rendstyle = RS_Bold;
3754	break;	3856	break;
		3857	//case 2: // low intensity
		3858	case 3:
		3859	rendset = 1, rendstyle = RS_Italic;
		3860	break;
3755	case 4:	3861	case 4:
3756	rendset = 1, rendstyle = RS_Uline;	3862	rendset = 1, rendstyle = RS_Uline;
3757	break;	3863	break;
3758	case 5:	3864	case 5: // slowly blinking
		3865	case 6: // rapidly blinking
3759	rendset = 1, rendstyle = RS_Blink;	3866	rendset = 1, rendstyle = RS_Blink;
3760	break;	3867	break;
3761	//case 6: // scoansi light background	3868	//case 6: // scoansi light background
3762	case 7:	3869	case 7:
3763	rendset = 1, rendstyle = RS_RVid;	3870	rendset = 1, rendstyle = RS_RVid;
3764	break;	3871	break;
3765	case 8:	3872	case 8:
3766	// invisible. NYI	3873	// invisible. NYI
3767	break;	3874	break;
		3875	//case 9: // crossed out
3768	//case 10: // scoansi acs off	3876	//case 10: // scoansi acs off, primary font
3769	//case 11: // scoansi acs on	3877	//case 11: // scoansi acs on, first alt font
3770	//case 12: // scoansi acs on, |0x80	3878	//case 12: // scoansi acs on, |0x80, second alt font
3771	case 21: // disable bold, blink and invis (some terminals use this)	3879	//...
		3880	//case 19: // ninth alt font
		3881	//case 20: // gothic
		3882	case 21: // disable bold, faint, sometimes doubly underlined (iso 8613)
3772	rendset = 0, rendstyle = RS_Bold | RS_Blink;	3883	rendset = 0, rendstyle = RS_Bold;
3773	break;	3884	break;
3774	case 22:	3885	case 22: // normal intensity
3775	rendset = 0, rendstyle = RS_Bold;	3886	rendset = 0, rendstyle = RS_Bold;
		3887	break;
		3888	case 23: // disable italic
		3889	rendset = 0, rendstyle = RS_Italic;
3776	break;	3890	break;
3777	case 24:	3891	case 24:
3778	rendset = 0, rendstyle = RS_Uline;	3892	rendset = 0, rendstyle = RS_Uline;
3779	break;	3893	break;
3780	case 25:	3894	case 25:
3781	rendset = 0, rendstyle = RS_Blink;	3895	rendset = 0, rendstyle = RS_Blink;
3782	break;	3896	break;
		3897	case 26: // variable spacing (iso 8613)
		3898	rendset = 0, rendstyle = RS_Blink;
		3899	break;
3783	case 27:	3900	case 27:
3784	rendset = 0, rendstyle = RS_RVid;	3901	rendset = 0, rendstyle = RS_RVid;
3785	break;	3902	break;
3786	case 28:
3787	// visible. NYI	3903	//case 28: // visible. NYI
3788	break;	3904	//case 29: // not crossed-out
3789	}	3905	}
3790		3906
3791	if (rendset != -1)	3907	if (rendset != -1)
3792	{	3908	{
3793	scr_rendition (rendset, rendstyle);	3909	scr_rendition (rendset, rendstyle);
…		…
3804	case 35:	3920	case 35:
3805	case 36:	3921	case 36:
3806	case 37:	3922	case 37:
3807	scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);	3923	scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);
3808	break;	3924	break;
3809	#ifdef TTY_256COLOR	3925	case 38: // set fg color, ISO 8613-6
3810	case 38:
3811	if (nargs > i + 2 && arg[i + 1] == 5)	3926	if (nargs > i + 2 && arg[i + 1] == 5)
3812	{	3927	{
3813	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg);	3928	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg);
3814	i += 2;	3929	i += 2;
3815	}	3930	}
3816	break;	3931	break;
3817	#endif
3818	case 39: /* default fg */	3932	case 39: /* default fg */
3819	scr_color (Color_fg, Color_fg);	3933	scr_color (Color_fg, Color_fg);
3820	break;	3934	break;
3821		3935
3822	case 40:	3936	case 40:
…		…
3827	case 45:	3941	case 45:
3828	case 46:	3942	case 46:
3829	case 47:	3943	case 47:
3830	scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);	3944	scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);
3831	break;	3945	break;
3832	#ifdef TTY_256COLOR	3946	case 48: // set bg color, ISO 8613-6
3833	case 48:
3834	if (nargs > i + 2 && arg[i + 1] == 5)	3947	if (nargs > i + 2 && arg[i + 1] == 5)
3835	{	3948	{
3836	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg);	3949	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg);
3837	i += 2;	3950	i += 2;
3838	}	3951	}
3839	break;	3952	break;
3840	#endif
3841	case 49: /* default bg */	3953	case 49: /* default bg */
3842	scr_color (Color_bg, Color_bg);	3954	scr_color (Color_bg, Color_bg);
3843	break;	3955	break;
3844		3956
3845	#ifndef NO_BRIGHTCOLOR	3957	//case 50: // not variable spacing
		3958
		3959	#if !ENABLE_MINIMAL
3846	case 90:	3960	case 90:
3847	case 91: /* set bright fg color */	3961	case 91: /* set bright fg color */
3848	case 92:	3962	case 92:
3849	case 93:	3963	case 93:
3850	case 94:	3964	case 94:
3851	case 95:	3965	case 95:
3852	case 96:	3966	case 96:
3853	case 97:	3967	case 97:
3854	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 90)),	3968	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 90)), Color_fg);
3855	Color_fg);
3856	break;	3969	break;
3857	case 100:	3970	case 100:
3858	case 101: /* set bright bg color */	3971	case 101: /* set bright bg color */
3859	case 102:	3972	case 102:
3860	case 103:	3973	case 103:
3861	case 104:	3974	case 104:
3862	case 105:	3975	case 105:
3863	case 106:	3976	case 106:
3864	case 107:	3977	case 107:
3865	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 100)),	3978	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 100)), Color_bg);
3866	Color_bg);
3867	break;	3979	break;
3868	#endif	3980	#endif
3869
3870	}	3981	}
3871	}	3982	}
3872	}	3983	}
3873	/*}}} */	3984	/*}}} */
3874		3985
…		…
3877	rxvt_term::process_graphics ()	3988	rxvt_term::process_graphics ()
3878	{	3989	{
3879	unicode_t ch, cmd = cmd_getc ();	3990	unicode_t ch, cmd = cmd_getc ();
3880		3991
3881	if (cmd == 'Q')	3992	if (cmd == 'Q')
		3993	{
3882	{ /* query graphics */	3994	/* query graphics */
3883	tt_printf ("\033G0\n"); /* no graphics */	3995	tt_printf ("\033G0\012"); /* no graphics */
3884	return;	3996	return;
3885	}	3997	}
3886	/* swallow other graphics sequences until terminating ':' */	3998	/* swallow other graphics sequences until terminating ':' */
3887	do	3999	do
3888	ch = cmd_getc ();	4000	ch = cmd_getc ();
…		…
3898	*/	4010	*/
3899	void	4011	void
3900	rxvt_term::tt_printf (const char *fmt,...)	4012	rxvt_term::tt_printf (const char *fmt,...)
3901	{	4013	{
3902	va_list arg_ptr;	4014	va_list arg_ptr;
3903	unsigned char buf[256];	4015	char buf[256];
3904		4016
3905	va_start (arg_ptr, fmt);	4017	va_start (arg_ptr, fmt);
3906	vsnprintf ((char *)buf, 256, fmt, arg_ptr);	4018	vsnprintf ((char *)buf, 256, fmt, arg_ptr);
3907	va_end (arg_ptr);	4019	va_end (arg_ptr);
3908	tt_write (buf, STRLEN (buf));	4020	tt_write (buf, strlen (buf));
3909	}	4021	}
3910		4022
3911	/* ---------------------------------------------------------------------- */	4023	/* ---------------------------------------------------------------------- */
3912	/* Write data to the pty as typed by the user, pasted with the mouse,	4024	/* Write data to the pty as typed by the user, pasted with the mouse,
3913	* or generated by us in response to a query ESC sequence.	4025	* or generated by us in response to a query ESC sequence.
3914	*/	4026	*/
3915	void	4027	static const unsigned int MAX_PTY_WRITE = 255; // minimum MAX_INPUT
3916	rxvt_term::tt_write (const unsigned char *data, unsigned int len)
3917	{
3918	enum { MAX_PTY_WRITE = 255 }; // minimum MAX_INPUT
3919		4028
3920	if (len)	4029	void
		4030	rxvt_term::tt_write (const char *data, unsigned int len)
		4031	{
		4032	if (HOOK_INVOKE ((this, HOOK_TT_WRITE, DT_STR_LEN, data, len, DT_END)))
		4033	return;
		4034
		4035	if (pty->pty < 0)
		4036	return;
		4037
		4038	if (v_buflen == 0)
		4039	{
		4040	ssize_t written = write (pty->pty, data, min (len, MAX_PTY_WRITE));
		4041
		4042	if ((unsigned int)written == len)
		4043	return;
		4044
		4045	data += written;
		4046	len -= written;
3921	{	4047	}
		4048
		4049	v_buffer = (char *)rxvt_realloc (v_buffer, v_buflen + len);
		4050
		4051	memcpy (v_buffer + v_buflen, data, len);
		4052	v_buflen += len;
		4053
		4054	pty_ev.set (ev::READ | ev::WRITE);
		4055	}
		4056
		4057	void rxvt_term::pty_write ()
		4058	{
		4059	int written = write (pty->pty, v_buffer, min (v_buflen, MAX_PTY_WRITE));
		4060
		4061	if (written > 0)
		4062	{
		4063	v_buflen -= written;
		4064
3922	if (v_buflen == 0)	4065	if (v_buflen == 0)
3923	{	4066	{
3924	ssize_t written = write (cmd_fd, data, min (MAX_PTY_WRITE, len));
3925
3926	if ((unsigned int)written == len)
3927	return;
3928
3929	data += written;
3930	len -= written;
3931	}
3932
3933
3934	v_buffer = (unsigned char *)realloc (v_buffer, v_buflen + len);
3935
3936	memcpy (v_buffer + v_buflen, data, len);
3937	v_buflen += len;
3938	}
3939
3940	for (;;)
3941	{
3942	int written = write (cmd_fd, v_buffer, min (MAX_PTY_WRITE, v_buflen));
3943
3944	if (written > 0)
3945	{
3946	v_buflen -= written;
3947
3948	if (v_buflen == 0)
3949	{
3950	free (v_buffer);	4067	free (v_buffer);
3951	v_buffer = 0;	4068	v_buffer = 0;
3952	v_buflen = 0;
3953		4069
3954	pty_ev.set (EVENT_READ);	4070	pty_ev.set (ev::READ);
3955	return;
3956	}
3957
3958	memmove (v_buffer, v_buffer + written, v_buflen);
3959	}
3960	else if (written != -1 || (errno != EAGAIN && errno != EINTR))
3961	// original code just ignores this...
3962	destroy ();
3963	else
3964	{
3965	pty_ev.set (EVENT_READ | EVENT_WRITE);
3966	return;	4071	return;
3967	}	4072	}
		4073
		4074	memmove (v_buffer, v_buffer + written, v_buflen);
3968	}	4075	}
		4076	else if (written != -1 || (errno != EAGAIN && errno != EINTR))
		4077	pty_ev.set (ev::READ);
3969	}	4078	}
3970		4079
3971	/*----------------------- end-of-file (C source) -----------------------*/	4080	/*----------------------- end-of-file (C source) -----------------------*/
3972		4081

Diff Legend

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