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.17 by pcg, Thu Dec 18 00:29:29 2003 UTC vs.
Revision 1.492 by sf-exg, Sun Aug 21 20:13:58 2011 UTC

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

Diff Legend

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