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.25 by pcg, Fri Dec 19 09:41:09 2003 UTC vs.
Revision 1.415 by root, Sat Apr 26 03:37:18 2008 UTC

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

Diff Legend

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