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

Diff Legend

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