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

Diff Legend

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