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

Diff Legend

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