ViewVC Help

View File | Revision Log | Show Annotations | Download File

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

Comparing rxvt-unicode/src/command.C (file contents):
Revision 1.97 by root, Mon Jul 26 18:01:19 2004 UTC vs.
Revision 1.487 by sf-exg, Sat Apr 30 13:11:34 2011 UTC

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

Diff Legend

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