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.93 by pcg, Thu Apr 8 20:31:45 2004 UTC vs.
Revision 1.479 by root, Fri Feb 25 07:07:41 2011 UTC

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

Diff Legend

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