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.49 by pcg, Sat Feb 21 22:14:00 2004 UTC vs.
Revision 1.418 by root, Fri Oct 10 00:11:44 2008 UTC

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

Diff Legend

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