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.33 by pcg, Fri Jan 30 18:12:17 2004 UTC vs.
Revision 1.409 by ayin, Sat Feb 16 15:39:20 2008 UTC

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

Diff Legend

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