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.39 by pcg, Mon Feb 9 07:15:46 2004 UTC vs.
Revision 1.453 by sf-exg, Wed Aug 18 17:45:42 2010 UTC

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

Diff Legend

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