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.41 by pcg, Tue Feb 10 00:40:39 2004 UTC vs.
Revision 1.479 by root, Fri Feb 25 07:07:41 2011 UTC

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

Diff Legend

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