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.107 by root, Sat Jul 31 00:01:12 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 ();
711	}	1075	}
		1076	else
		1077	w.stop ();
712	}	1078	}
713	#endif	1079	#endif
714		1080
715	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING	1081	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
716	void	1082	void
717	rxvt_term::cont_scroll_cb (time_watcher &w)	1083	rxvt_term::cont_scroll_cb (ev::timer &w, int revents)
718	{	1084	{
719	if ((scrollbar_isUp() || scrollbar_isDn()) &&	1085	if ((scrollBar.state == STATE_UP || scrollBar.state == STATE_DOWN)
720	scr_page (scrollbar_isUp() ? UP : DN, 1))	1086	&& scr_page (scrollBar.state == STATE_UP ? UP : DN, 1))
721	{	1087	{
722	refresh_type |= SMOOTH_REFRESH;
723	want_refresh = 1;	1088	want_refresh = 1;
724	w.start (w.at + SCROLLBAR_CONTINUOUS_DELAY);	1089	refresh_check ();
725	}	1090	}
		1091	else
		1092	w.stop ();
726	}	1093	}
727	#endif	1094	#endif
728		1095
729	#ifdef SELECTION_SCROLLING	1096	#ifdef SELECTION_SCROLLING
730	void	1097	void
731	rxvt_term::sel_scroll_cb (time_watcher &w)	1098	rxvt_term::sel_scroll_cb (ev::timer &w, int revents)
732	{	1099	{
733	if (scr_page (scroll_selection_dir, scroll_selection_lines))	1100	if (scr_page (scroll_selection_dir, scroll_selection_lines))
734	{	1101	{
735	selection_extend (selection_save_x, selection_save_y, selection_save_state);	1102	selection_extend (selection_save_x, selection_save_y, selection_save_state);
736	refresh_type |= SMOOTH_REFRESH;
737	want_refresh = 1;	1103	want_refresh = 1;
738	w.start (w.at + SCROLLBAR_CONTINUOUS_DELAY);	1104	refresh_check ();
739	}	1105	}
		1106	else
		1107	w.stop ();
740	}	1108	}
741	#endif	1109	#endif
742		1110
743	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)	1111	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
744	void	1112	void
745	rxvt_term::slip_wheel_cb (time_watcher &w)	1113	rxvt_term::slip_wheel_cb (ev::timer &w, int revents)
746	{	1114	{
747	if (mouse_slip_wheel_speed == 0	1115	if (scr_changeview (view_start - mouse_slip_wheel_speed))
748	|| mouse_slip_wheel_speed < 0 ? scr_page (DN, -mouse_slip_wheel_speed)
749	: scr_page (UP, mouse_slip_wheel_speed))
750	{	1116	{
751	refresh_type |= SMOOTH_REFRESH;
752	want_refresh = 1;	1117	want_refresh = 1;
753	w.start (w.at + SCROLLBAR_CONTINUOUS_DELAY);	1118	refresh_check ();
		1119	}
		1120
		1121	if (view_start == top_row || view_start == 0 || mouse_slip_wheel_speed == 0)
754	}	1122	{
		1123	mouse_slip_wheel_speed = 0;
		1124	w.stop ();
		1125	}
755	}	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;
756	#endif	1155	#endif
757		1156
758	bool	1157	bool
759	rxvt_term::pty_fill ()	1158	rxvt_term::pty_fill ()
760	{	1159	{
761	ssize_t n = cmdbuf_endp - cmdbuf_ptr;	1160	ssize_t n = cmdbuf_endp - cmdbuf_ptr;
762		1161
763	if (CBUFSIZ == n)	1162	if (CBUFSIZ == n)
764	{	1163	n = 0; // normally this indicates a "too long" command sequence - just drop the data we have
765	rxvt_warn ("pty_fill on full buffer, draining input, continuing.\n");
766	n = 0;
767	}
768		1164
769	memmove (cmdbuf_base, cmdbuf_ptr, n);	1165	memmove (cmdbuf_base, cmdbuf_ptr, n);
770	cmdbuf_ptr = cmdbuf_base;	1166	cmdbuf_ptr = cmdbuf_base;
771	cmdbuf_endp = cmdbuf_ptr + n;	1167	cmdbuf_endp = cmdbuf_ptr + n;
772		1168
773	n = read (cmd_fd, cmdbuf_endp, CBUFSIZ - n);	1169	ssize_t r = read (pty->pty, cmdbuf_endp, CBUFSIZ - n);
774		1170
775	if (n > 0)	1171	if (r > 0)
776	{	1172	{
777	cmdbuf_endp += n;	1173	cmdbuf_endp += r;
778	return true;	1174	return true;
779	}	1175	}
780	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))
781	destroy ();	1188	destroy ();
782		1189	}
		1190
783	return false;	1191	return false;
784	}	1192	}
785		1193
786	void	1194	void
787	rxvt_term::pty_cb (io_watcher &w, short revents)	1195	rxvt_term::pty_cb (ev::io &w, int revents)
788	{	1196	{
789	SET_R (this);	1197	make_current ();
790	SET_LOCALE (locale);
791		1198
792	if (revents & EVENT_WRITE)	1199	if (revents & ev::READ)
793	tt_write (0, 0);
794	else if (revents & EVENT_READ)
795	// loop, but don't allow a single term to monopolize us	1200	// loop, but don't allow a single term to monopolize us
796	while (pty_fill ())	1201	for (int i = CBUFCNT; i-- && pty_fill (); )
797	if (cmd_parse ())	1202	cmd_parse ();
798	break;	1203
		1204	if (revents & ev::WRITE)
		1205	pty_write ();
		1206
		1207	refresh_check ();
799	}	1208	}
800		1209
801	void	1210	void
802	rxvt_term::pointer_unblank ()	1211	rxvt_term::pointer_unblank ()
803	{	1212	{
804	XDefineCursor (display->display, TermWin.vt, TermWin_cursor);	1213	XDefineCursor (dpy, vt, TermWin_cursor);
805	recolour_cursor ();	1214	recolour_cursor ();
806		1215
807	#ifdef POINTER_BLANK	1216	#ifdef POINTER_BLANK
808	hidden_pointer = 0;	1217	hidden_pointer = 0;
809		1218
810	if (Options & Opt_pointerBlank)	1219	if (option (Opt_pointerBlank))
811	pointer_ev.start (NOW + pointerBlankDelay);	1220	pointer_ev.start (pointerBlankDelay);
812	#endif	1221	#endif
813	}	1222	}
814		1223
815	#ifdef POINTER_BLANK	1224	#ifdef POINTER_BLANK
816	void	1225	void
817	rxvt_term::pointer_blank ()	1226	rxvt_term::pointer_blank ()
818	{	1227	{
819	if (! (Options & Opt_pointerBlank))	1228	if (!option (Opt_pointerBlank))
820	return;	1229	return;
821		1230
822	XDefineCursor (display->display, TermWin.vt, blank_cursor);	1231	XDefineCursor (dpy, vt, display->blank_cursor);
823	XFlush (display->display);	1232	XFlush (dpy);
824		1233
825	hidden_pointer = 1;	1234	hidden_pointer = 1;
826	}	1235	}
827		1236
828	void	1237	void
829	rxvt_term::pointer_cb (time_watcher &w)	1238	rxvt_term::pointer_cb (ev::timer &w, int revents)
830	{	1239	{
831	SET_R (this);	1240	make_current ();
832	SET_LOCALE (locale);
833		1241
834	pointer_blank ();	1242	pointer_blank ();
835	}	1243	}
836	#endif	1244	#endif
837		1245
838	void	1246	void
839	rxvt_term::mouse_report (XButtonEvent &ev)	1247	rxvt_term::mouse_report (XButtonEvent &ev)
840	{	1248	{
841	int button_number, key_state = 0;	1249	int button_number, key_state = 0;
842	int x, y;	1250	int x, y;
		1251	int code = 32;
843		1252
844	x = ev.x;	1253	x = Pixel2Col (ev.x) + 1;
845	y = ev.y;	1254	y = Pixel2Row (ev.y) + 1;
846	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	}
847		1265
848	if (MEvent.button == AnyButton)	1266	if (MEvent.button == AnyButton)
849	{
850	button_number = 3;	1267	button_number = 3;
851	}
852	else	1268	else
853	{	1269	{
854	button_number = MEvent.button - Button1;	1270	button_number = MEvent.button - Button1;
855	/* add 0x3D for wheel events, like xterm does */	1271	/* add 0x3D for wheel events, like xterm does */
856	if (button_number >= 3)	1272	if (button_number >= 3)
857	button_number += (64 - 3);	1273	button_number += 64 - 3;
858	}	1274	}
859		1275
860	if (PrivateModes & PrivMode_MouseX10)	1276	if (priv_modes & PrivMode_MouseX10)
861	{	1277	{
862	/*	1278	/*
863	* do not report ButtonRelease	1279	* do not report ButtonRelease
864	* no state info allowed	1280	* no state info allowed
865	*/	1281	*/
…		…
880	+ ((MEvent.state & ModMetaMask) ? 8 : 0)	1296	+ ((MEvent.state & ModMetaMask) ? 8 : 0)
881	+ ((MEvent.state & ControlMask) ? 16 : 0);	1297	+ ((MEvent.state & ControlMask) ? 16 : 0);
882	#ifdef MOUSE_REPORT_DOUBLECLICK	1298	#ifdef MOUSE_REPORT_DOUBLECLICK
883	key_state += ((MEvent.clicks > 1) ? 32 : 0);	1299	key_state += ((MEvent.clicks > 1) ? 32 : 0);
884	#endif	1300	#endif
885
886	}	1301	}
887		1302
888	#ifdef DEBUG_MOUSEREPORT	1303	#if DEBUG_MOUSEREPORT
889	fprintf (stderr, "Mouse [");	1304	fprintf (stderr, "Mouse [");
890	if (key_state & 16)	1305	if (key_state & 16)
891	fputc ('C', stderr);	1306	fputc ('C', stderr);
892	if (key_state & 4)	1307	if (key_state & 4)
893	fputc ('S', stderr);	1308	fputc ('S', stderr);
…		…
895	fputc ('A', stderr);	1310	fputc ('A', stderr);
896	if (key_state & 32)	1311	if (key_state & 32)
897	fputc ('2', stderr);	1312	fputc ('2', stderr);
898	fprintf (stderr, "]: <%d>, %d/%d\n",	1313	fprintf (stderr, "]: <%d>, %d/%d\n",
899	button_number,	1314	button_number,
900	x + 1,	1315	x,
901	y + 1);	1316	y);
902	#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
903	tt_printf ("\033[M%c%c%c",	1332	tt_printf ("\033[M%c%c%c",
904	(32 + button_number + key_state),	1333	code + button_number + key_state,
905	(32 + x + 1),	1334	32 + x,
906	(32 + y + 1));	1335	32 + y);
907	#endif
908	}	1336	}
909
910	#ifdef USING_W11LIB
911	void
912	rxvt_W11_process_x_event (XEvent *ev)
913	{
914	rxvt_t *r = rxvt_get_r ();
915
916	x_cb (*ev);
917	}
918	#endif
919		1337
920	/*{{{ process an X event */	1338	/*{{{ process an X event */
921	void	1339	void
922	rxvt_term::x_cb (XEvent &ev)	1340	rxvt_term::x_cb (XEvent &ev)
923	{	1341	{
924	SET_R (this);	1342	make_current ();
925	SET_LOCALE (locale);
926		1343
927	#if defined(CURSOR_BLINK)	1344	dLocal (Display *, dpy);
928	if ((Options & Opt_cursorBlink) && ev.type == KeyPress)
929	{
930	if (hidden_cursor)
931	{
932	hidden_cursor = 0;
933	want_refresh = 1;
934	}
935		1345
936	cursor_blink_ev.start (NOW + BLINK_INTERVAL);	1346	if (ev.xany.window == vt
937	}	1347	&& SHOULD_INVOKE (HOOK_X_EVENT)
938	#endif	1348	&& HOOK_INVOKE ((this, HOOK_X_EVENT, DT_XEVENT, &ev, DT_END)))
939
940	#if defined(POINTER_BLANK)
941	if ((Options & Opt_pointerBlank) && pointerBlankDelay > 0)
942	{
943	if (ev.type == MotionNotify
944	|| ev.type == ButtonPress
945	|| ev.type == ButtonRelease)
946	if (hidden_pointer)
947	pointer_unblank ();
948
949	if (ev.type == KeyPress && hidden_pointer == 0)
950	pointer_blank ();
951	}
952	#endif
953
954	#ifdef USE_XIM
955	if (XFilterEvent (&ev, None))
956	return;	1349	return;
957	#endif
958		1350
		1351	// for XQueryPointer
959	Window unused_root, unused_child;	1352	Window unused_root, unused_child;
960	int unused_root_x, unused_root_y;	1353	int unused_root_x, unused_root_y;
961	unsigned int unused_mask;	1354	unsigned int unused_mask;
962
963	#ifdef DEBUG_X
964	const char *const eventnames[] =
965	{ /* mason - this matches my system */
966	"",
967	"",
968	"KeyPress",
969	"KeyRelease",
970	"ButtonPress",
971	"ButtonRelease",
972	"MotionNotify",
973	"EnterNotify",
974	"LeaveNotify",
975	"FocusIn",
976	"FocusOut",
977	"KeymapNotify",
978	"Expose",
979	"GraphicsExpose",
980	"NoExpose",
981	"VisibilityNotify",
982	"CreateNotify",
983	"DestroyNotify",
984	"UnmapNotify",
985	"MapNotify",
986	"MapRequest",
987	"ReparentNotify",
988	"ConfigureNotify",
989	"ConfigureRequest",
990	"GravityNotify",
991	"ResizeRequest",
992	"CirculateNotify",
993	"CirculateRequest",
994	"PropertyNotify",
995	"SelectionClear",
996	"SelectionRequest",
997	"SelectionNotify",
998	"ColormapNotify",
999	"ClientMessage",
1000	"MappingNotify"
1001	};
1002	#endif
1003
1004	#ifdef DEBUG_X
1005	struct timeval tp;
1006	struct tm *ltt;
1007	(void)gettimeofday (&tp, NULL);
1008	ltt = localtime (& (tp.tv_sec));
1009	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));
1010	#endif
1011		1355
1012	switch (ev.type)	1356	switch (ev.type)
1013	{	1357	{
1014	case KeyPress:	1358	case KeyPress:
1015	lookup_key (ev.xkey);	1359	key_press (ev.xkey);
1016	break;	1360	break;
1017		1361
1018	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
1019	case KeyRelease:	1362	case KeyRelease:
1020	{	1363	key_release (ev.xkey);
1021	if (!(ev.xkey.state & ControlMask))
1022	slip_wheel_ev.stop ();
1023	else
1024	{
1025	KeySym ks;
1026
1027	ks = XKeycodeToKeysym (display->display, ev.xkey.keycode, 0);
1028	if (ks == XK_Control_L || ks == XK_Control_R)
1029	mouse_slip_wheel_speed = 0;
1030	}
1031	break;	1364	break;
1032	}
1033	#endif
1034		1365
1035	case ButtonPress:	1366	case ButtonPress:
1036	button_press (ev.xbutton);	1367	button_press (ev.xbutton);
1037	break;	1368	break;
1038		1369
…		…
1040	button_release (ev.xbutton);	1371	button_release (ev.xbutton);
1041	break;	1372	break;
1042		1373
1043	case ClientMessage:	1374	case ClientMessage:
1044	if (ev.xclient.format == 32	1375	if (ev.xclient.format == 32
1045	&& (Atom)ev.xclient.data.l[0] == xa[XA_WMDELETEWINDOW])	1376	&& !HOOK_INVOKE ((this, HOOK_CLIENT_MESSAGE, DT_XEVENT, &ev, DT_END)))
1046	destroy ();
1047	#ifdef OFFIX_DND
1048	/* OffiX Dnd (drag 'n' drop) protocol */
1049	else if (ev.xclient.message_type == xa[XA_DNDPROTOCOL]
1050	&& (ev.xclient.data.l[0] == DndFile
1051	|| ev.xclient.data.l[0] == DndDir
1052	|| ev.xclient.data.l[0] == DndLink))
1053	{	1377	{
1054	/* Get Dnd data */	1378	if (ev.xclient.message_type == xa[XA_WM_PROTOCOLS])
1055	Atom ActualType;	1379	{
1056	int ActualFormat;	1380	if (!HOOK_INVOKE ((this, HOOK_WM_PROTOCOLS, DT_XEVENT, &ev, DT_END)))
1057	unsigned char *data;	1381	{
1058	unsigned long Size, RemainingBytes;	1382	if (ev.xclient.data.l[0] == xa[XA_WM_DELETE_WINDOW])
1059		1383	{
1060	XGetWindowProperty (display->display, display->root,	1384	if (!HOOK_INVOKE ((this, HOOK_WM_DELETE_WINDOW, DT_XEVENT, &ev, DT_END)))
1061	xa[XA_DNDSELECTION],	1385	destroy ();
1062	0L, 1000000L,	1386	}
1063	False, AnyPropertyType,	1387	#if ENABLE_EWMH
1064	&ActualType, &ActualFormat,	1388	else if (ev.xclient.data.l[0] == xa[XA_NET_WM_PING])
1065	&Size, &RemainingBytes,	1389	XSendEvent (dpy, ev.xclient.window = display->root,
		1390	False, SubstructureRedirectMask | SubstructureNotifyMask,
1066	&data);	1391	&ev);
1067	XChangeProperty (display->display, display->root,	1392	#endif
1068	XA_CUT_BUFFER0, XA_STRING,	1393	}
1069	8, PropModeReplace,	1394	}
1070	data, STRLEN (data));	1395	#if ENABLE_XEMBED
1071	XFree (data);	1396	else if (ev.xclient.format == 32 && ev.xclient.message_type == xa[XA_XEMBED])
1072	selection_paste (display->root, XA_CUT_BUFFER0, True);	1397	{
1073	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
1074	}	1404	}
1075	#endif /* OFFIX_DND */
1076	break;
1077
1078	case MappingNotify:
1079	XRefreshKeyboardMapping (& (ev.xmapping));
1080	break;	1405	break;
1081		1406
1082	/*	1407	/*
1083	* XXX: this is not the _current_ arrangement	1408	* XXX: this is not the _current_ arrangement
1084	* Here's my conclusion:	1409	* Here's my conclusion:
…		…
1103	break;	1428	break;
1104	}	1429	}
1105	break;	1430	break;
1106		1431
1107	case FocusIn:	1432	case FocusIn:
1108	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])
1109	{	1448	{
1110	TermWin.focus = 1;	1449	while (XCheckTypedWindowEvent (dpy, ev.xconfigure.window, ConfigureNotify, &ev))
1111	want_refresh = 1;	1450	;
1112	#ifdef USE_XIM	1451
1113	if (Input_Context != NULL)	1452	#ifdef HAVE_BG_PIXMAP
1114	XSetICFocus (Input_Context);	1453	bool moved = false;
1115	#endif	1454	if (bg_window_position_sensitive ())
1116	#ifdef CURSOR_BLINK
1117	if (Options & Opt_cursorBlink)
1118	cursor_blink_ev.start (NOW + BLINK_INTERVAL);
1119	#endif
1120	#ifdef OFF_FOCUS_FADING
1121	if (rs[Rs_fade])
1122	{	1455	{
1123	PixColors = PixColorsFocused;	1456	int x, y;
1124	set_colorfgbg ();	1457	if (ev.xconfigure.send_event)
1125	scr_clear ();	1458	{
1126	scr_touch (true);	1459	x = ev.xconfigure.x;
		1460	y = ev.xconfigure.y;
		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;
1127	}	1468	}
1128	#endif	1469	#endif
1129		1470
1130	}	1471	if (szHint.width != ev.xconfigure.width || szHint.height != ev.xconfigure.height)
1131	break;
1132
1133	case FocusOut:
1134	if (TermWin.focus)
1135	{
1136	TermWin.focus = 0;
1137	want_refresh = 1;
1138	#ifdef USE_XIM
1139	if (Input_Context != NULL)
1140	XUnsetICFocus (Input_Context);
1141	#endif
1142	#ifdef CURSOR_BLINK
1143	if (Options & Opt_cursorBlink)
1144	cursor_blink_ev.stop ();
1145	hidden_cursor = 0;
1146	#endif
1147	#ifdef OFF_FOCUS_FADING
1148	if (rs[Rs_fade])
1149	{	1472	{
1150	PixColors = PixColorsUnFocused;	1473	seen_resize = 1;
1151	set_colorfgbg ();	1474	resize_all_windows (ev.xconfigure.width, ev.xconfigure.height, 1);
1152	scr_clear ();
1153	scr_touch (true);
1154	}	1475	}
1155	#endif
1156
1157	}
1158	break;
1159
1160	case ConfigureNotify:
1161	if (ev.xconfigure.window == TermWin.parent[0])
1162	{
1163	int height, width;
1164
1165	do
1166	{ /* Wrap lots of configures into one */
1167	width = ev.xconfigure.width;
1168	height = ev.xconfigure.height;
1169	D_SIZE ((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));
1170	}
1171	while (XCheckTypedWindowEvent (display->display, ev.xconfigure.window, ConfigureNotify, &ev));
1172
1173	if (szHint.width != width || szHint.height != height)
1174	{
1175	D_SIZE ((stderr, "Size: Resizing from: %4d x %4d", szHint.width, szHint.height));
1176	resize_all_windows (width, height, 1);
1177	}
1178	#ifdef DEBUG_SIZE
1179	else	1476	else
1180	{	1477	{
1181	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
1182	}	1487	}
1183	#endif	1488
1184	#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */	1489	HOOK_INVOKE ((this, HOOK_CONFIGURE_NOTIFY, DT_XEVENT, &ev, DT_END));
1185	if (Options & Opt_transparent)
1186	{
1187	check_our_parents ();
1188	if (am_transparent)
1189	want_full_refresh = 1;
1190	}
1191	#endif
1192	}	1490	}
1193	break;	1491	break;
1194		1492
		1493	case PropertyNotify:
		1494	HOOK_INVOKE ((this, HOOK_PROPERTY_NOTIFY, DT_XEVENT, &ev, DT_END));
		1495	break;
		1496
1195	case SelectionClear:	1497	case SelectionClear:
1196	selection_clear ();	1498	selection_clear (ev.xselectionclear.selection == xa[XA_CLIPBOARD]);
1197	break;
1198
1199	case SelectionNotify:
1200	if (selection_wait == Sel_normal)
1201	selection_paste (ev.xselection.requestor,
1202	ev.xselection.property, True);
1203	break;	1499	break;
1204		1500
1205	case SelectionRequest:	1501	case SelectionRequest:
1206	selection_send (ev.xselectionrequest);	1502	selection_send (ev.xselectionrequest);
1207	break;	1503	break;
1208		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
1209	case UnmapNotify:	1529	case UnmapNotify:
1210	TermWin.mapped = 0;	1530	mapped = 0;
1211	#ifdef TEXT_BLINK	1531	#ifdef TEXT_BLINK
1212	text_blink_ev.stop ();	1532	text_blink_ev.stop ();
1213	#endif	1533	#endif
		1534	HOOK_INVOKE ((this, HOOK_UNMAP_NOTIFY, DT_XEVENT, &ev, DT_END));
1214	break;	1535	break;
1215
1216	case MapNotify:
1217	TermWin.mapped = 1;
1218	#ifdef TEXT_BLINK
1219	text_blink_ev.start (NOW + TEXT_BLINK_INTERVAL);
1220	#endif
1221	break;
1222
1223	#ifdef TRANSPARENT
1224	case ReparentNotify:
1225	rootwin_cb (ev);
1226	break;
1227	#endif /* TRANSPARENT */
1228		1536
1229	case GraphicsExpose:	1537	case GraphicsExpose:
1230	case Expose:	1538	case Expose:
1231	if (ev.xany.window == TermWin.vt)	1539	if (ev.xany.window == vt)
1232	{	1540	{
1233	#ifdef NO_SLOW_LINK_SUPPORT	1541	do
		1542	{
1234	scr_expose (ev.xexpose.x, ev.xexpose.y,	1543	scr_expose (ev.xexpose.x, ev.xexpose.y,
1235	ev.xexpose.width, ev.xexpose.height, False);	1544	ev.xexpose.width, ev.xexpose.height, false);
1236	#else	1545	}
1237	// I don't understand this, so I changed it :)	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	{
1238	scr_expose (ev.xexpose.x, ev.xexpose.y,	1552	scr_expose (ev.xexpose.x, ev.xexpose.y,
1239	ev.xexpose.width, ev.xexpose.height, False);	1553	ev.xexpose.width, ev.xexpose.height, false);
1240	//scr_expose (ev.xexpose.x, 0,	1554	}
1241	// ev.xexpose.width, TermWin.height, False);	1555
1242	#endif
1243	want_refresh = 1;	1556	want_refresh = 1;
1244	}	1557	}
1245	else	1558	else
1246	{	1559	{
1247	XEvent unused_event;	1560	XEvent unused_event;
1248		1561
1249	while (XCheckTypedWindowEvent (display->display, ev.xany.window, Expose, &unused_event))	1562	while (XCheckTypedWindowEvent (dpy, ev.xany.window, Expose, &unused_event))
1250	;	1563	;
1251	while (XCheckTypedWindowEvent (display->display, ev.xany.window, GraphicsExpose, &unused_event))	1564	while (XCheckTypedWindowEvent (dpy, ev.xany.window, GraphicsExpose, &unused_event))
1252	;	1565	;
1253		1566
1254	if (isScrollbarWindow (ev.xany.window))	1567	if (scrollBar.state && ev.xany.window == scrollBar.win)
1255	{	1568	{
1256	scrollBar.setIdle ();	1569	scrollBar.state = STATE_IDLE;
1257	scrollbar_show (0);	1570	scrollBar.show (0);
1258	}	1571	}
1259	#ifdef MENUBAR
1260	if (menubar_visible () && isMenuBarWindow (ev.xany.window))
1261	menubar_expose ();
1262	#endif
1263	}	1572	}
1264	break;	1573	break;
1265		1574
1266	case MotionNotify:	1575	case MotionNotify:
1267	#ifdef POINTER_BLANK	1576	#ifdef POINTER_BLANK
1268	if (hidden_pointer)	1577	if (hidden_pointer)
1269	pointer_unblank ();	1578	pointer_unblank ();
1270	#endif	1579	#endif
1271	#if MENUBAR	1580	if ((priv_modes & PrivMode_MouseBtnEvent && ev.xbutton.state & (Button1Mask|Button2Mask|Button3Mask))
1272	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)
1273	{	1587	{
1274	menubar_control (ev.xbutton);	1588	if (SHOULD_INVOKE (HOOK_MOTION_NOTIFY)
1275	break;	1589	&& HOOK_INVOKE ((this, HOOK_MOTION_NOTIFY, DT_XEVENT, &ev, DT_END)))
1276	}	1590	; // nop
1277	#endif
1278	if ((PrivateModes & PrivMode_mouse_report) && ! (bypass_keystate))
1279	break;
1280
1281	if (ev.xany.window == TermWin.vt)
1282	{
1283	if ((ev.xbutton.state & (Button1Mask | Button3Mask)))	1591	else if (ev.xbutton.state & (Button1Mask | Button3Mask))
1284	{	1592	{
1285	while (XCheckTypedWindowEvent (display->display, TermWin.vt, MotionNotify, &ev))	1593	while (XCheckTypedWindowEvent (dpy, vt, MotionNotify, &ev))
1286	;	1594	;
1287		1595
1288	XQueryPointer (display->display, TermWin.vt,	1596	XQueryPointer (dpy, vt,
1289	&unused_root, &unused_child,	1597	&unused_root, &unused_child,
1290	&unused_root_x, &unused_root_y,	1598	&unused_root_x, &unused_root_y,
1291	& (ev.xbutton.x), & (ev.xbutton.y),	1599	&ev.xbutton.x, &ev.xbutton.y,
1292	&unused_mask);	1600	&ev.xbutton.state);
1293	#ifdef MOUSE_THRESHOLD	1601	#ifdef MOUSE_THRESHOLD
1294	/* deal with a `jumpy' mouse */	1602	/* deal with a `jumpy' mouse */
1295	if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)	1603	if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)
1296	{	1604	{
1297	#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
1298	selection_extend ((ev.xbutton.x), (ev.xbutton.y),	1614	selection_extend (ev.xbutton.x, ev.xbutton.y,
1299	(ev.xbutton.state & Button3Mask) ? 2 : 0);	1615	ev.xbutton.state & Button3Mask ? 2 : 0);
		1616
1300	#ifdef SELECTION_SCROLLING	1617	#ifdef SELECTION_SCROLLING
1301	if (ev.xbutton.y < TermWin.int_bwidth	1618	if (ev.xbutton.y < int_bwidth
1302	|| Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))	1619	|| Pixel2Row (ev.xbutton.y) > (nrow-1))
1303	{	1620	{
1304	int dist;	1621	int dist;
1305		1622
1306	/* don't clobber the current delay if we are	1623	/* don't clobber the current delay if we are
1307	* already in the middle of scrolling.	1624	* already in the middle of scrolling.
1308	*/	1625	*/
1309	if (!sel_scroll_ev.active)	1626	if (!sel_scroll_ev.is_active ())
1310	sel_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);	1627	sel_scroll_ev.start (SCROLLBAR_INITIAL_DELAY, SCROLLBAR_CONTINUOUS_DELAY);
1311		1628
1312	/* save the event params so we can highlight	1629	/* save the event params so we can highlight
1313	* the selection in the pending-scroll loop	1630	* the selection in the pending-scroll loop
1314	*/	1631	*/
1315	selection_save_x=ev.xbutton.x;	1632	selection_save_x = ev.xbutton.x;
1316	selection_save_y=ev.xbutton.y;	1633	selection_save_y = ev.xbutton.y;
1317	selection_save_state=
1318	(ev.xbutton.state & Button3Mask) ? 2 : 0;	1634	selection_save_state = (ev.xbutton.state & Button3Mask) ? 2 : 0;
1319		1635
1320	/* calc number of lines to scroll */	1636	/* calc number of lines to scroll */
1321	if (ev.xbutton.y<TermWin.int_bwidth)	1637	if (ev.xbutton.y < int_bwidth)
1322	{	1638	{
1323	scroll_selection_dir = UP;	1639	scroll_selection_dir = UP;
1324	dist = TermWin.int_bwidth - ev.xbutton.y;	1640	dist = int_bwidth - ev.xbutton.y;
1325	}	1641	}
1326	else	1642	else
1327	{	1643	{
1328	scroll_selection_dir = DN;	1644	scroll_selection_dir = DN;
1329	dist = ev.xbutton.y -	1645	dist = ev.xbutton.y - (int_bwidth + height);
1330	(TermWin.int_bwidth + TermWin.height);
1331	}	1646	}
		1647
1332	scroll_selection_lines= (Pixel2Height (dist)/	1648	scroll_selection_lines = Pixel2Height (dist)
1333	SELECTION_SCROLL_LINE_SPEEDUP)+1;	1649	/ SELECTION_SCROLL_LINE_SPEEDUP
		1650	+ 1;
1334	MIN_IT (scroll_selection_lines,	1651	min_it (scroll_selection_lines,
1335	SELECTION_SCROLL_MAX_LINES);	1652	SELECTION_SCROLL_MAX_LINES);
1336	}	1653	}
1337	else	1654	else
1338	{	1655	{
1339	/* we are within the text window, so we	1656	/* we are within the text window, so we
1340	* shouldn't be scrolling	1657	* shouldn't be scrolling
1341	*/	1658	*/
1342	if (sel_scroll_ev.active)
1343	sel_scroll_ev.stop();	1659	sel_scroll_ev.stop();
1344	}	1660	}
1345	#endif	1661	#endif
1346	#ifdef MOUSE_THRESHOLD	1662	#ifdef MOUSE_THRESHOLD
1347
1348	}	1663	}
1349	#endif	1664	#endif
1350
1351	}	1665	}
1352	}	1666	}
1353	else if (isScrollbarWindow (ev.xany.window) && scrollbar_isMotion ())	1667	else if (scrollBar.state == STATE_MOTION && ev.xany.window == scrollBar.win)
1354	{	1668	{
1355	while (XCheckTypedWindowEvent (display->display, scrollBar.win,	1669	while (XCheckTypedWindowEvent (dpy, scrollBar.win,
1356	MotionNotify, &ev)) ;	1670	MotionNotify, &ev))
		1671	;
		1672
1357	XQueryPointer (display->display, scrollBar.win,	1673	XQueryPointer (dpy, scrollBar.win,
1358	&unused_root, &unused_child,	1674	&unused_root, &unused_child,
1359	&unused_root_x, &unused_root_y,	1675	&unused_root_x, &unused_root_y,
1360	& (ev.xbutton.x), & (ev.xbutton.y),	1676	&ev.xbutton.x, &ev.xbutton.y,
1361	&unused_mask);	1677	&unused_mask);
1362	scr_move_to (scrollbar_position (ev.xbutton.y) - csrO,	1678	scr_move_to (scrollbar_position (ev.xbutton.y) - csrO,
1363	scrollbar_size ());	1679	scrollBar.size ());
1364	scr_refresh (refresh_type);
1365	refresh_limit = 0;	1680	want_refresh = 1;
1366	scrollbar_show (1);	1681	scrollBar.show (1);
1367	}	1682	}
1368	break;	1683	break;
1369	}	1684	}
1370	}
1371		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
1372	void	1824	void
1373	rxvt_term::rootwin_cb (XEvent &ev)	1825	rxvt_term::rootwin_cb (XEvent &ev)
1374	{	1826	{
1375	SET_R (this);	1827	make_current ();
1376	SET_LOCALE (locale);
1377		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
1378	switch (ev.type)	1834	switch (ev.type)
1379	{	1835	{
1380	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	*/
1381	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])
1382	{	1843	{
1383	if (ev.xproperty.state == PropertyNewValue)	1844	bg_set_root_pixmap ();
1384	selection_property (ev.xproperty.window, ev.xproperty.atom);	1845	update_background ();
1385	break;
1386	}	1846	}
1387	#ifdef TRANSPARENT
1388	else
1389	{
1390	/*
1391	* if user used some Esetroot compatible prog to set the root bg,
1392	* use the property to determine the pixmap. We use it later on.
1393	*/
1394	if (xa[XA_XROOTPMAPID] == 0)
1395	xa[XA_XROOTPMAPID] = XInternAtom (display->display, "_XROOTPMAP_ID", False);
1396		1847
1397	if (ev.xproperty.atom != xa[XA_XROOTPMAPID])
1398	return;
1399	}
1400
1401	/* FALLTHROUGH */
1402	case ReparentNotify:
1403	if ((Options & Opt_transparent) && check_our_parents () && am_transparent)
1404	want_full_refresh = 1;
1405	break;	1848	break;
		1849	}
1406	#endif	1850	# endif
1407	}	1851
		1852	refresh_check ();
1408	}	1853	}
		1854	#endif
1409		1855
1410	void	1856	void
1411	rxvt_term::button_press (XButtonEvent &ev)	1857	rxvt_term::button_press (XButtonEvent &ev)
1412	{	1858	{
1413	int reportmode = 0, clickintime;	1859	int reportmode = 0, clickintime;
1414		1860
1415	bypass_keystate = ev.state & (ModMetaMask | ShiftMask);	1861	bypass_keystate = ev.state & (ModMetaMask | ShiftMask);
		1862
1416	if (!bypass_keystate)	1863	if (!bypass_keystate)
1417	reportmode = !! (PrivateModes & PrivMode_mouse_report);	1864	reportmode = !! (priv_modes & PrivMode_mouse_report);
		1865
1418	/*	1866	/*
1419	* VT window processing of button press	1867	* VT window processing of button press
1420	*/	1868	*/
1421	if (ev.window == TermWin.vt)	1869	if (ev.window == vt)
1422	{	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
1423	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;	1883	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;
		1884
1424	if (reportmode)	1885	if (reportmode)
1425	{	1886	{
1426	/* mouse report from vt window */	1887	/* mouse report from vt window */
1427	/* save the xbutton state (for ButtonRelease) */	1888	/* save the xbutton state (for ButtonRelease) */
1428	MEvent.state = ev.state;	1889	MEvent.state = ev.state;
1429	#ifdef MOUSE_REPORT_DOUBLECLICK	1890	#ifdef MOUSE_REPORT_DOUBLECLICK
1430	if (ev.button == MEvent.button && clickintime)	1891	if (ev.button == MEvent.button && clickintime)
1431	{	1892	{
1432	/* same button, within alloted time */	1893	/* same button, within allowed time */
1433	MEvent.clicks++;	1894	MEvent.clicks++;
		1895
1434	if (MEvent.clicks > 1)	1896	if (MEvent.clicks > 1)
1435	{	1897	{
1436	/* only report double clicks */	1898	/* only report double clicks */
1437	MEvent.clicks = 2;	1899	MEvent.clicks = 2;
1438	mouse_report (ev);	1900	mouse_report (ev);
…		…
1450	mouse_report (ev);	1912	mouse_report (ev);
1451	}	1913	}
1452	#else	1914	#else
1453	MEvent.button = ev.button;	1915	MEvent.button = ev.button;
1454	mouse_report (ev);	1916	mouse_report (ev);
1455	#endif /* MOUSE_REPORT_DOUBLECLICK */	1917	#endif /* MOUSE_REPORT_DOUBLECLICK */
1456		1918
1457	}	1919	}
1458	else	1920	else
1459	{	1921	{
1460	if (ev.button != MEvent.button)	1922	if (ev.button != MEvent.button)
1461	MEvent.clicks = 0;	1923	MEvent.clicks = 0;
		1924
1462	switch (ev.button)	1925	switch (ev.button)
1463	{	1926	{
1464	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
1465	/* allow shift+left click to extend selection */	1936	/* allow shift+left click to extend selection */
1466	if (ev.state & ShiftMask && ! (PrivateModes & PrivMode_mouse_report))	1937	if (ev.state & ShiftMask && !(priv_modes & PrivMode_mouse_report))
1467	{	1938	{
1468	if (MEvent.button == Button1 && clickintime)	1939	if (MEvent.button == Button1 && clickintime)
1469	selection_rotate (ev.x, ev.y);	1940	selection_rotate (ev.x, ev.y);
1470	else	1941	else
1471	selection_extend (ev.x, ev.y, 1);	1942	selection_extend (ev.x, ev.y, 1);
…		…
1486	case Button3:	1957	case Button3:
1487	if (MEvent.button == Button3 && clickintime)	1958	if (MEvent.button == Button3 && clickintime)
1488	selection_rotate (ev.x, ev.y);	1959	selection_rotate (ev.x, ev.y);
1489	else	1960	else
1490	selection_extend (ev.x, ev.y, 1);	1961	selection_extend (ev.x, ev.y, 1);
		1962
1491	MEvent.button = Button3;	1963	MEvent.button = Button3;
1492	break;	1964	break;
1493	}	1965	}
1494	}	1966	}
		1967
1495	MEvent.time = ev.time;	1968	MEvent.time = ev.time;
1496	return;	1969	return;
1497	}	1970	}
1498		1971
1499	/*	1972	/*
1500	* Scrollbar window processing of button press	1973	* Scrollbar window processing of button press
1501	*/	1974	*/
1502	if (isScrollbarWindow (ev.window))	1975	if (scrollBar.state && ev.window == scrollBar.win)
1503	{	1976	{
1504	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;
1505	/*	1985	/*
1506	* Rxvt-style scrollbar:	1986	* Rxvt-style scrollbar:
1507	* move up if mouse is above slider	1987	* move up if mouse is above slider
1508	* move dn if mouse is below slider	1988	* move dn if mouse is below slider
1509	*	1989	*
…		…
1518	/*	1998	/*
1519	* Mouse report disabled scrollbar:	1999	* Mouse report disabled scrollbar:
1520	* arrow buttons - send up/down	2000	* arrow buttons - send up/down
1521	* click on scrollbar - send pageup/down	2001	* click on scrollbar - send pageup/down
1522	*/	2002	*/
1523	if ((scrollBar.style == R_SB_NEXT	2003	if (direction == UP)
1524	&& scrollbarnext_upButton (ev.y))
1525	|| (scrollBar.style == R_SB_RXVT
1526	&& scrollbarrxvt_upButton (ev.y)))
1527	tt_printf ("\033[A");	2004	tt_printf ("\033[A");
1528	else if ((scrollBar.style == R_SB_NEXT	2005	else if (direction == DN)
1529	&& scrollbarnext_dnButton (ev.y))
1530	|| (scrollBar.style == R_SB_RXVT
1531	&& scrollbarrxvt_dnButton (ev.y)))
1532	tt_printf ("\033[B");	2006	tt_printf ("\033[B");
1533	else	2007	else
1534	switch (ev.button)	2008	switch (ev.button)
1535	{	2009	{
1536	case Button2:	2010	case Button2:
…		…
1543	tt_printf ("\033[5~");	2017	tt_printf ("\033[5~");
1544	break;	2018	break;
1545	}	2019	}
1546	}	2020	}
1547	else	2021	else
1548	#endif /* NO_SCROLLBAR_REPORT */	2022	#endif /* NO_SCROLLBAR_REPORT */
1549
1550	{
1551	char upordown = 0;
1552
1553	if (scrollBar.style == R_SB_NEXT)
1554	{	2023	{
1555	if (scrollbarnext_upButton (ev.y))	2024	if (direction != NO_DIR)
1556	upordown = -1; /* up */
1557	else if (scrollbarnext_dnButton (ev.y))
1558	upordown = 1; /* down */
1559	}
1560	else if (scrollBar.style == R_SB_RXVT)
1561	{
1562	if (scrollbarrxvt_upButton (ev.y))
1563	upordown = -1; /* up */
1564	else if (scrollbarrxvt_dnButton (ev.y))
1565	upordown = 1; /* down */
1566	}
1567	if (upordown)
1568	{	2025	{
1569	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING	2026	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
		2027	if (!cont_scroll_ev.is_active ())
1570	cont_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);	2028	cont_scroll_ev.start (SCROLLBAR_INITIAL_DELAY, SCROLLBAR_CONTINUOUS_DELAY);
1571	#endif	2029	#endif
1572	if (scr_page (upordown < 0 ? UP : DN, 1))	2030	if (scr_page (direction, 1))
1573	{	2031	{
1574	if (upordown < 0)	2032	if (direction == UP)
1575	scrollBar.setUp ();	2033	scrollBar.state = STATE_UP;
1576	else	2034	else
1577	scrollBar.setDn ();	2035	scrollBar.state = STATE_DOWN;
1578	}	2036	}
1579	}	2037	}
1580	else	2038	else
1581	switch (ev.button)	2039	switch (ev.button)
1582	{	2040	{
1583	case Button2:	2041	case Button2:
1584	switch (scrollbar_align)	2042	switch (scrollBar.align)
1585	{	2043	{
1586	case R_SB_ALIGN_TOP:	2044	case R_SB_ALIGN_TOP:
1587	csrO = 0;	2045	csrO = 0;
1588	break;	2046	break;
1589	case R_SB_ALIGN_CENTRE:	2047	case R_SB_ALIGN_CENTRE:
…		…
1591	break;	2049	break;
1592	case R_SB_ALIGN_BOTTOM:	2050	case R_SB_ALIGN_BOTTOM:
1593	csrO = scrollBar.bot - scrollBar.top;	2051	csrO = scrollBar.bot - scrollBar.top;
1594	break;	2052	break;
1595	}	2053	}
		2054
1596	if (scrollBar.style == R_SB_XTERM	2055	if (scrollBar.style == R_SB_XTERM
1597	|| scrollbar_above_slider (ev.y)	2056	|| scrollbar_above_slider (ev.y)
1598	|| scrollbar_below_slider (ev.y))	2057	|| scrollbar_below_slider (ev.y))
1599	scr_move_to ( scrollbar_position (ev.y) - csrO,	2058	scr_move_to (scrollbar_position (ev.y) - csrO, scrollBar.size ());
1600	scrollbar_size ());	2059
1601	scrollBar.setMotion ();	2060	scrollBar.state = STATE_MOTION;
1602	break;	2061	break;
1603		2062
1604	case Button1:	2063	case Button1:
1605	if (scrollbar_align == R_SB_ALIGN_CENTRE)	2064	if (scrollBar.align == R_SB_ALIGN_CENTRE)
1606	csrO = ev.y - scrollBar.top;	2065	csrO = ev.y - scrollBar.top;
1607	/* FALLTHROUGH */	2066	/* FALLTHROUGH */
1608		2067
1609	case Button3:	2068	case Button3:
1610	if (scrollBar.style != R_SB_XTERM)	2069	if (scrollBar.style != R_SB_XTERM)
1611	{	2070	{
1612	if (scrollbar_above_slider (ev.y))	2071	if (scrollbar_above_slider (ev.y))
1613	# ifdef RXVT_SCROLL_FULL	2072	# ifdef RXVT_SCROLL_FULL
1614	scr_page (UP, TermWin.nrow - 1);	2073	scr_page (UP, nrow - 1);
1615	# else	2074	# else
1616	scr_page (UP, TermWin.nrow / 4);	2075	scr_page (UP, nrow / 4);
1617	# endif	2076	# endif
1618	else if (scrollbar_below_slider (ev.y))	2077	else if (scrollbar_below_slider (ev.y))
1619	# ifdef RXVT_SCROLL_FULL	2078	# ifdef RXVT_SCROLL_FULL
1620	scr_page (DN, TermWin.nrow - 1);	2079	scr_page (DN, nrow - 1);
1621	# else	2080	# else
1622	scr_page (DN, TermWin.nrow / 4);	2081	scr_page (DN, nrow / 4);
1623	# endif	2082	# endif
1624	else	2083	else
1625	scrollBar.setMotion ();	2084	scrollBar.state = STATE_MOTION;
1626	}	2085	}
1627	else	2086	else
1628	{	2087	{
1629	scr_page ((ev.button == Button1 ? DN : UP),	2088	scr_page ((ev.button == Button1 ? DN : UP),
1630	(TermWin.nrow	2089	(nrow
1631	* scrollbar_position (ev.y)	2090	* scrollbar_position (ev.y)
1632	/ scrollbar_size ()));	2091	/ scrollBar.size ()));
1633	}	2092	}
		2093
1634	break;	2094	break;
1635	}	2095	}
1636	}	2096	}
		2097
1637	return;	2098	return;
1638	}	2099	}
1639	#if MENUBAR
1640	/*
1641	* Menubar window processing of button press
1642	*/
1643	if (isMenuBarWindow (ev.window))
1644	menubar_control (ev);
1645	#endif
1646	}	2100	}
1647		2101
1648	void	2102	void
1649	rxvt_term::button_release (XButtonEvent &ev)	2103	rxvt_term::button_release (XButtonEvent &ev)
1650	{	2104	{
1651	int reportmode = 0;	2105	int reportmode = 0;
1652		2106
1653	csrO = 0; /* reset csr Offset */	2107	csrO = 0; /* reset csr Offset */
1654	if (!bypass_keystate)	2108	if (!bypass_keystate)
1655	reportmode = !! (PrivateModes & PrivMode_mouse_report);	2109	reportmode = !! (priv_modes & PrivMode_mouse_report);
1656		2110
1657	if (scrollbar_isUpDn ())	2111	if (scrollBar.state == STATE_UP || scrollBar.state == STATE_DOWN)
1658	{	2112	{
1659	scrollBar.setIdle ();	2113	scrollBar.state = STATE_IDLE;
1660	scrollbar_show (0);	2114	scrollBar.show (0);
1661	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1662	refresh_type &= ~SMOOTH_REFRESH;
1663	#endif
1664
1665	}	2115	}
		2116
1666	#ifdef SELECTION_SCROLLING	2117	#ifdef SELECTION_SCROLLING
1667	if (sel_scroll_ev.active)
1668	sel_scroll_ev.stop();	2118	sel_scroll_ev.stop();
1669	#endif	2119	#endif
		2120
1670	if (ev.window == TermWin.vt)	2121	if (ev.window == vt)
1671	{	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
1672	if (reportmode)	2132	if (reportmode)
1673	{	2133	{
1674	/* mouse report from vt window */	2134	/* mouse report from vt window */
1675	/* don't report release of wheel "buttons" */	2135	/* don't report release of wheel "buttons" */
1676	if (ev.button >= 4)	2136	if (ev.button >= 4)
…		…
1687	mouse_report (ev);	2147	mouse_report (ev);
1688	}	2148	}
1689	#else /* MOUSE_REPORT_DOUBLECLICK */	2149	#else /* MOUSE_REPORT_DOUBLECLICK */
1690	MEvent.button = AnyButton;	2150	MEvent.button = AnyButton;
1691	mouse_report (ev);	2151	mouse_report (ev);
1692	#endif /* MOUSE_REPORT_DOUBLECLICK */	2152	#endif /* MOUSE_REPORT_DOUBLECLICK */
1693	return;	2153	return;
1694	}	2154	}
		2155
1695	/*	2156	/*
1696	* dumb hack to compensate for the failure of click-and-drag	2157	* dumb hack to compensate for the failure of click-and-drag
1697	* when overriding mouse reporting	2158	* when overriding mouse reporting
1698	*/	2159	*/
1699	if (PrivateModes & PrivMode_mouse_report	2160	if (priv_modes & PrivMode_mouse_report
1700	&& bypass_keystate	2161	&& bypass_keystate
1701	&& ev.button == Button1 && MEvent.clicks <= 1)	2162	&& ev.button == Button1 && MEvent.clicks <= 1)
1702	selection_extend (ev.x, ev.y, 0);	2163	selection_extend (ev.x, ev.y, 0);
1703		2164
1704	switch (ev.button)	2165	switch (ev.button)
1705	{	2166	{
1706	case Button1:	2167	case Button1:
1707	case Button3:	2168	case Button3:
1708	selection_make (ev.time);	2169	selection_make (ev.time);
1709	break;	2170	break;
		2171
1710	case Button2:	2172	case Button2:
1711	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);
1712	break;	2175	break;
		2176
1713	#ifdef MOUSE_WHEEL	2177	#ifdef MOUSE_WHEEL
1714	case Button4:	2178	case Button4:
1715	case Button5:	2179	case Button5:
1716	{	2180	{
1717	int i;	2181	int i;
…		…
1719		2183
1720	v = ev.button == Button4 ? UP : DN;	2184	v = ev.button == Button4 ? UP : DN;
1721		2185
1722	if (ev.state & ShiftMask)	2186	if (ev.state & ShiftMask)
1723	i = 1;	2187	i = 1;
1724	else if (Options & Opt_mouseWheelScrollPage)	2188	else if (option (Opt_mouseWheelScrollPage))
1725	i = TermWin.nrow - 1;	2189	i = nrow - 1;
1726	else	2190	else
1727	i = 5;	2191	i = 5;
1728		2192
1729	# ifdef MOUSE_SLIP_WHEELING	2193	# ifdef MOUSE_SLIP_WHEELING
1730	if (ev.state & ControlMask)	2194	if (ev.state & ControlMask)
1731	{	2195	{
1732	mouse_slip_wheel_speed += v ? -1 : 1;	2196	mouse_slip_wheel_speed += v ? -1 : 1;
1733	if (mouse_slip_wheel_speed < -TermWin.nrow) mouse_slip_wheel_speed = -TermWin.nrow;	2197	if (mouse_slip_wheel_speed < -nrow) mouse_slip_wheel_speed = -nrow;
1734	if (mouse_slip_wheel_speed > +TermWin.nrow) mouse_slip_wheel_speed = +TermWin.nrow;	2198	if (mouse_slip_wheel_speed > +nrow) mouse_slip_wheel_speed = +nrow;
1735		2199
1736	if (slip_wheel_ev.at < NOW)	2200	if (!slip_wheel_ev.is_active ())
1737	slip_wheel_ev.at = NOW + SCROLLBAR_CONTINUOUS_DELAY;	2201	slip_wheel_ev.start (SCROLLBAR_CONTINUOUS_DELAY, SCROLLBAR_CONTINUOUS_DELAY);
1738
1739	slip_wheel_ev.start ();
1740	}	2202	}
1741	else	2203	else
		2204	# endif
1742	{	2205	{
1743	# endif
1744	# ifdef JUMP_MOUSE_WHEEL
1745	scr_page (v, i);	2206	scr_page (v, i);
1746	scr_refresh (SMOOTH_REFRESH);
1747	scrollbar_show (1);	2207	scrollBar.show (1);
1748	# else
1749	while (i--)
1750	{
1751	scr_page (v, 1);
1752	scr_refresh (SMOOTH_REFRESH);
1753	scrollbar_show (1);
1754	}
1755	# endif
1756	# ifdef MOUSE_SLIP_WHEELING
1757	}	2208	}
1758	#endif
1759	}	2209	}
1760	break;	2210	break;
1761	#endif	2211	#endif
1762	}	2212	}
1763	}	2213	}
1764	#ifdef MENUBAR
1765	else if (isMenuBarWindow (ev.window))
1766	menubar_control (ev);
1767	#endif
1768	}	2214	}
1769
1770	#ifdef TRANSPARENT
1771	#if TINTING
1772	/* shading taken from eterm-0.9.2 */
1773	/* RGB 15 */
1774
1775	static void
1776	shade_ximage_15(void *data, int bpl, int w, int h, int rm, int gm, int bm)
1777	{
1778	unsigned char *ptr;
1779	int x, y;
1780
1781	ptr = (unsigned char *)data + (w * sizeof(uint16_t));
1782	if ((rm <= 256) && (gm <= 256) && (bm <= 256)) {
1783	/* No saturation */
1784	for (y = h; --y >= 0;) {
1785	for (x = -w; x < 0; x++) {
1786	int r, g, b;
1787
1788	b = ((uint16_t *) ptr)[x];
1789	r = (b & 0x7c00) * rm;
1790	g = (b & 0x3e0) * gm;
1791	b = (b & 0x1f) * bm;
1792	((uint16_t *) ptr)[x] = ((r >> 8) & 0x7c00)
1793	| ((g >> 8) & 0x3e0)
1794	| ((b >> 8) & 0x1f);
1795	}
1796	ptr += bpl;
1797	}
1798	} else {
1799	for (y = h; --y >= 0;) {
1800	for (x = -w; x < 0; x++) {
1801	int r, g, b;
1802
1803	b = ((uint16_t *) ptr)[x];
1804	r = (b & 0x7c00) * rm;
1805	g = (b & 0x3e0) * gm;
1806	b = (b & 0x1f) * bm;
1807	r |= (!(r >> 15) - 1);
1808	g |= (!(g >> 10) - 1);
1809	b |= (!(b >> 5) - 1);
1810	((uint16_t *) ptr)[x] = ((r >> 8) & 0x7c00)
1811	| ((g >> 8) & 0x3e0)
1812	| ((b >> 8) & 0x1f);
1813	}
1814	ptr += bpl;
1815	}
1816	}
1817	}
1818
1819	/* RGB 16 */
1820	static void
1821	shade_ximage_16(void *data, int bpl, int w, int h, int rm, int gm, int bm)
1822	{
1823	unsigned char *ptr;
1824	int x, y;
1825
1826	ptr = (unsigned char *)data + (w * sizeof(uint16_t));
1827	if ((rm <= 256) && (gm <= 256) && (bm <= 256)) {
1828	/* No saturation */
1829	for (y = h; --y >= 0;) {
1830	for (x = -w; x < 0; x++) {
1831	int r, g, b;
1832
1833	b = ((uint16_t *) ptr)[x];
1834	r = (b & 0xf800) * rm;
1835	g = (b & 0x7e0) * gm;
1836	b = (b & 0x1f) * bm;
1837	((uint16_t *) ptr)[x] = ((r >> 8) & 0xf800)
1838	| ((g >> 8) & 0x7e0)
1839	| ((b >> 8) & 0x1f);
1840	}
1841	ptr += bpl;
1842	}
1843	} else {
1844	for (y = h; --y >= 0;) {
1845	for (x = -w; x < 0; x++) {
1846	int r, g, b;
1847
1848	b = ((uint16_t *) ptr)[x];
1849	r = (b & 0xf800) * rm;
1850	g = (b & 0x7e0) * gm;
1851	b = (b & 0x1f) * bm;
1852	r |= (!(r >> 16) - 1);
1853	g |= (!(g >> 11) - 1);
1854	b |= (!(b >> 5) - 1);
1855	((uint16_t *) ptr)[x] = ((r >> 8) & 0xf800)
1856	| ((g >> 8) & 0x7e0)
1857	| ((b >> 8) & 0x1f);
1858	}
1859	ptr += bpl;
1860	}
1861	}
1862	}
1863
1864	/* RGB 24 */
1865	static void
1866	shade_ximage_24(void *data, int bpl, int w, int h, int rm, int gm, int bm)
1867	{
1868	unsigned char *ptr;
1869	int x, y;
1870
1871	ptr = (unsigned char *)data + (w * 3);
1872	if ((rm <= 256) && (gm <= 256) && (bm <= 256)) {
1873	/* No saturation */
1874	for (y = h; --y >= 0;) {
1875	for (x = -(w * 3); x < 0; x += 3) {
1876	int r, g, b;
1877
1878	if (byteorder.big_endian()) {
1879	r = (ptr[x + 0] * rm) >> 8;
1880	g = (ptr[x + 1] * gm) >> 8;
1881	b = (ptr[x + 2] * bm) >> 8;
1882	ptr[x + 0] = r;
1883	ptr[x + 1] = g;
1884	ptr[x + 2] = b;
1885	} else {
1886	r = (ptr[x + 2] * rm) >> 8;
1887	g = (ptr[x + 1] * gm) >> 8;
1888	b = (ptr[x + 0] * bm) >> 8;
1889	ptr[x + 2] = r;
1890	ptr[x + 1] = g;
1891	ptr[x + 0] = b;
1892	}
1893	}
1894	ptr += bpl;
1895	}
1896	} else {
1897	for (y = h; --y >= 0;) {
1898	for (x = -(w * 3); x < 0; x += 3) {
1899	int r, g, b;
1900
1901	if (byteorder.big_endian()) {
1902	r = (ptr[x + 0] * rm) >> 8;
1903	g = (ptr[x + 1] * gm) >> 8;
1904	b = (ptr[x + 2] * bm) >> 8;
1905
1906	r |= (!(r >> 8) - 1);
1907	g |= (!(g >> 8) - 1);
1908	b |= (!(b >> 8) - 1);
1909
1910	ptr[x + 0] = r;
1911	ptr[x + 1] = g;
1912	ptr[x + 2] = b;
1913	} else {
1914	r = (ptr[x + 2] * rm) >> 8;
1915	g = (ptr[x + 1] * gm) >> 8;
1916	b = (ptr[x + 0] * bm) >> 8;
1917
1918	r |= (!(r >> 8) - 1);
1919	g |= (!(g >> 8) - 1);
1920	b |= (!(b >> 8) - 1);
1921
1922	ptr[x + 2] = r;
1923	ptr[x + 1] = g;
1924	ptr[x + 0] = b;
1925	}
1926	}
1927	ptr += bpl;
1928	}
1929	}
1930	}
1931
1932	/* RGB 32 */
1933	static void
1934	shade_ximage_32(void *data, int bpl, int w, int h, int rm, int gm, int bm)
1935	{
1936	unsigned char *ptr;
1937	int x, y;
1938
1939	ptr = (unsigned char *)data + (w * 4);
1940	if ((rm <= 256) && (gm <= 256) && (bm <= 256)) {
1941	/* No saturation */
1942	for (y = h; --y >= 0;) {
1943	if (byteorder.big_endian()) {
1944	for (x = -(w * 4); x < 0; x += 4) {
1945	int r, g, b;
1946
1947	r = (ptr[x + 1] * rm) >> 8;
1948	g = (ptr[x + 2] * gm) >> 8;
1949	b = (ptr[x + 3] * bm) >> 8;
1950	ptr[x + 1] = r;
1951	ptr[x + 2] = g;
1952	ptr[x + 3] = b;
1953	}
1954	} else {
1955	for (x = -(w * 4); x < 0; x += 4) {
1956	int r, g, b;
1957
1958	r = (ptr[x + 2] * rm) >> 8;
1959	g = (ptr[x + 1] * gm) >> 8;
1960	b = (ptr[x + 0] * bm) >> 8;
1961	ptr[x + 2] = r;
1962	ptr[x + 1] = g;
1963	ptr[x + 0] = b;
1964	}
1965	}
1966	ptr += bpl;
1967	}
1968	} else {
1969	for (y = h; --y >= 0;) {
1970	for (x = -(w * 4); x < 0; x += 4) {
1971	int r, g, b;
1972
1973	if (byteorder.big_endian()) {
1974	r = (ptr[x + 1] * rm) >> 8;
1975	g = (ptr[x + 2] * gm) >> 8;
1976	b = (ptr[x + 3] * bm) >> 8;
1977
1978	r |= (!(r >> 8) - 1);
1979	g |= (!(g >> 8) - 1);
1980	b |= (!(b >> 8) - 1);
1981
1982	ptr[x + 1] = r;
1983	ptr[x + 2] = g;
1984	ptr[x + 3] = b;
1985	} else {
1986	r = (ptr[x + 2] * rm) >> 8;
1987	g = (ptr[x + 1] * gm) >> 8;
1988	b = (ptr[x + 0] * bm) >> 8;
1989
1990	r |= (!(r >> 8) - 1);
1991	g |= (!(g >> 8) - 1);
1992	b |= (!(b >> 8) - 1);
1993
1994	ptr[x + 2] = r;
1995	ptr[x + 1] = g;
1996	ptr[x + 0] = b;
1997	}
1998	}
1999	ptr += bpl;
2000	}
2001	}
2002	}
2003
2004	#endif
2005
2006	/*
2007	* Check our parents are still who we think they are.
2008	* Do transparency updates if required
2009	*/
2010	int
2011	rxvt_term::check_our_parents ()
2012	{
2013	int i, pchanged, aformat, have_pixmap, rootdepth;
2014	unsigned long nitems, bytes_after;
2015	Atom atype;
2016	unsigned char *prop = NULL;
2017	Window root, oldp, *list;
2018	Pixmap rootpixmap = None;
2019	XWindowAttributes wattr, wrootattr;
2020
2021	pchanged = 0;
2022
2023	if (!(Options & Opt_transparent))
2024	return pchanged; /* Don't try any more */
2025
2026	XGetWindowAttributes (display->display, display->root, &wrootattr);
2027	rootdepth = wrootattr.depth;
2028
2029	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);
2030
2031	if (rootdepth != wattr.depth)
2032	{
2033	if (am_transparent)
2034	{
2035	pchanged = 1;
2036	XSetWindowBackground (display->display, TermWin.vt, PixColorsFocused[Color_bg]);
2037	am_transparent = am_pixmap_trans = 0;
2038	}
2039
2040	return pchanged; /* Don't try any more */
2041	}
2042
2043	/* Get all X ops out of the queue so that our information is up-to-date. */
2044	XSync (display->display, False);
2045
2046	/*
2047	* Make the frame window set by the window manager have
2048	* the root background. Some window managers put multiple nested frame
2049	* windows for each client, so we have to take care about that.
2050	*/
2051	i = (xa[XA_XROOTPMAPID]
2052	&& XGetWindowProperty (display->display, display->root, xa[XA_XROOTPMAPID],
2053	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
2054	&nitems, &bytes_after, &prop) == Success);
2055
2056	if (!i || prop == NULL)
2057	i = (xa[XA_XSETROOTID]
2058	&& XGetWindowProperty (display->display, display->root, xa[XA_XSETROOTID],
2059	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
2060	&nitems, &bytes_after, &prop) == Success);
2061
2062	if (!i || prop == NULL || !rs[Rs_color + Color_tint])
2063	have_pixmap = 0;
2064	else
2065	{
2066	have_pixmap = 1;
2067	rootpixmap = *(Pixmap *)prop;
2068	XFree (prop);
2069	}
2070
2071	if (have_pixmap)
2072	{
2073	/*
2074	* Copy display->root pixmap transparency
2075	*/
2076	int sx, sy, nx, ny;
2077	unsigned int nw, nh;
2078	Window cr;
2079	XImage *image;
2080	GC gc;
2081	XGCValues gcvalue;
2082
2083	XTranslateCoordinates (display->display, TermWin.vt, display->root,
2084	0, 0, &sx, &sy, &cr);
2085	nw = (unsigned int)szHint.width;
2086	nh = (unsigned int)szHint.height;
2087	nx = ny = 0;
2088
2089	if (sx < 0)
2090	{
2091	nw += sx;
2092	nx = -sx;
2093	sx = 0;
2094	}
2095
2096	if (sy < 0)
2097	{
2098	nh += sy;
2099	ny = -sy;
2100	sy = 0;
2101	}
2102
2103	MIN_IT (nw, (unsigned int) (wrootattr.width - sx));
2104	MIN_IT (nh, (unsigned int) (wrootattr.height - sy));
2105	allowedxerror = -1;
2106	image = XGetImage (display->display, rootpixmap, sx, sy, nw, nh, AllPlanes, ZPixmap);
2107
2108	/* XXX: handle BadMatch - usually because we're outside the pixmap */
2109	/* XXX: may need a delay here? */
2110	allowedxerror = 0;
2111
2112	if (image == NULL)
2113	{
2114	if (am_transparent && am_pixmap_trans)
2115	{
2116	pchanged = 1;
2117	if (TermWin.pixmap != None)
2118	{
2119	XFreePixmap (display->display, TermWin.pixmap);
2120	TermWin.pixmap = None;
2121	}
2122	}
2123
2124	am_pixmap_trans = 0;
2125	}
2126	else
2127	{
2128	if (TermWin.pixmap != None)
2129	XFreePixmap (display->display, TermWin.pixmap);
2130
2131	#if TINTING
2132	if (ISSET_PIXCOLOR (Color_tint))
2133	{
2134	unsigned short rm, gm, bm;
2135	if (rs[Rs_shade])
2136	PixColorsFocused[Color_tint].fade (display, atoi (rs[Rs_shade])).get (display, rm, gm, bm);
2137	else
2138	PixColorsFocused[Color_tint].get (display, rm, gm, bm);
2139
2140	rm >>= 8; gm >>= 8; bm >>= 8; // not 100% correct, but...
2141
2142	/* Determine bitshift and bitmask values */
2143	switch (image->bits_per_pixel)
2144	{
2145	case 15: shade_ximage_15 (image->data, image->bytes_per_line, image->width, image->height, rm, gm, bm); break;
2146	case 16: shade_ximage_16 (image->data, image->bytes_per_line, image->width, image->height, rm, gm, bm); break;
2147	case 24: shade_ximage_24 (image->data, image->bytes_per_line, image->width, image->height, rm, gm, bm); break;
2148	case 32: shade_ximage_32 (image->data, image->bytes_per_line, image->width, image->height, rm, gm, bm); break;
2149	}
2150	}
2151	#endif
2152
2153	TermWin.pixmap = XCreatePixmap (display->display, TermWin.vt,
2154	szHint.width, szHint.height, image->depth);
2155	gc = XCreateGC (display->display, TermWin.vt, 0UL, &gcvalue);
2156	XPutImage (display->display, TermWin.pixmap, gc, image, 0, 0,
2157	nx, ny, image->width, image->height);
2158	XFreeGC (display->display, gc);
2159	XDestroyImage (image);
2160	XSetWindowBackgroundPixmap (display->display, TermWin.vt, TermWin.pixmap);
2161
2162	if (!am_transparent || !am_pixmap_trans)
2163	pchanged = 1;
2164
2165	am_transparent = am_pixmap_trans = 1;
2166	}
2167	}
2168
2169	if (!am_pixmap_trans)
2170	{
2171	unsigned int n;
2172	/*
2173	* InheritPixmap transparency
2174	*/
2175	D_X ((stderr, "InheritPixmap Seeking to %08lx", display->root));
2176	for (i = 1; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
2177	{
2178	oldp = TermWin.parent[i];
2179	XQueryTree (display->display, TermWin.parent[i - 1], &root,
2180	&TermWin.parent[i], &list, &n);
2181	XFree (list);
2182	D_X ((stderr, "InheritPixmap Parent[%d] = %08lx", i, TermWin.parent[i]));
2183
2184	if (TermWin.parent[i] == display->root)
2185	{
2186	if (oldp != None)
2187	pchanged = 1;
2188
2189	break;
2190	}
2191
2192	if (oldp != TermWin.parent[i])
2193	pchanged = 1;
2194	}
2195
2196	n = 0;
2197
2198	if (pchanged)
2199	{
2200	for (; n < (unsigned int)i; n++)
2201	{
2202	XGetWindowAttributes (display->display, TermWin.parent[n], &wattr);
2203	D_X ((stderr, "InheritPixmap Checking Parent[%d]: %s", n, (wattr.depth == rootdepth && wattr.class != InputOnly) ? "OK" : "FAIL"));
2204	if (wattr.depth != rootdepth || wattr.c_class == InputOnly)
2205	{
2206	n = (int) (sizeof (TermWin.parent) / sizeof (Window)) + 1;
2207	break;
2208	}
2209	}
2210	}
2211
2212	if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0])))
2213	{
2214	D_X ((stderr, "InheritPixmap Turning off")); /* Mikachu? */
2215	XSetWindowBackground (display->display, TermWin.parent[0], PixColorsFocused[Color_fg]);
2216	XSetWindowBackground (display->display, TermWin.vt, PixColorsFocused[Color_bg]);
2217	am_transparent = 0;
2218	/* XXX: also turn off Opt_transparent? */
2219	}
2220	else
2221	{
2222	#if WAIT_FOR_WM
2223	/* wait (an arbitrary period) for the WM to do its thing
2224	* needed for fvwm2.2.2 (and before?) */
2225	sleep (1);
2226	#endif
2227	D_X ((stderr, "InheritPixmap Turning on (%d parents)", i - 1));
2228	for (n = 0; n < (unsigned int)i; n++)
2229	XSetWindowBackgroundPixmap (display->display, TermWin.parent[n], ParentRelative);
2230
2231	XSetWindowBackgroundPixmap (display->display, TermWin.vt, ParentRelative);
2232	am_transparent = 1;
2233	}
2234
2235	for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
2236	TermWin.parent[i] = None;
2237	}
2238
2239	return pchanged;
2240	}
2241	#endif
2242		2215
2243	/*}}} */	2216	/*}}} */
2244		2217
2245	bool	2218	void
2246	rxvt_term::cmd_parse ()	2219	rxvt_term::cmd_parse ()
2247	{	2220	{
2248	bool flag = false;
2249	unicode_t ch = NOCHAR;	2221	wchar_t ch = NOCHAR;
2250	unsigned char *seq_begin; // remember start of esc-sequence here	2222	char *seq_begin; // remember start of esc-sequence here
2251		2223
2252	for (;;)	2224	for (;;)
2253	{	2225	{
2254	if (ch == NOCHAR)	2226	if (expect_false (ch == NOCHAR))
2255	{	2227	{
2256	seq_begin = cmdbuf_ptr;	2228	seq_begin = cmdbuf_ptr;
2257	ch = next_char ();	2229	ch = next_char ();
2258	}
2259		2230
2260	if (ch == NOCHAR) // TODO: improve	2231	if (ch == NOCHAR)
2261	break;	2232	break;
		2233	}
2262		2234
2263	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))
2264	{	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
2265	/* Read a text string from the input buffer */	2251	/* Read a text string from the input buffer */
2266	unicode_t buf[UBUFSIZ];	2252	wchar_t buf[UBUFSIZ];
2267	bool refreshnow = false;	2253	bool refreshnow = false;
2268	int nlines = 0;	2254	int nlines = 0;
2269	unicode_t *str = buf;	2255	wchar_t *str = buf;
2270		2256	wchar_t *eol = str + min (ncol, UBUFSIZ);
2271	*str++ = ch;
2272		2257
2273	for (;;)	2258	for (;;)
2274	{	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
2275	seq_begin = cmdbuf_ptr;	2309	seq_begin = cmdbuf_ptr;
2276	ch = next_char ();	2310	ch = next_char ();
2277
2278	if (ch == NOCHAR || (IS_CONTROL (ch) && ch != C0_LF && ch != C0_CR && ch != C0_HT))
2279	break;
2280
2281	*str++ = ch;
2282
2283	if (ch == C0_LF)
2284	{
2285	nlines++;
2286	refresh_count++;
2287
2288	if (! (Options & Opt_jumpScroll)
2289	|| (refresh_count >= (refresh_limit * (TermWin.nrow - 1))))
2290	{
2291	refreshnow = true;
2292	flag = true;
2293	ch = NOCHAR;
2294	break;
2295	}
2296
2297	// scr_add_lines only works for nlines < TermWin.nrow - 1.
2298	if (nlines >= TermWin.nrow - 1)
2299	{
2300	scr_add_lines (buf, nlines, str - buf);
2301	nlines = 0;
2302	str = buf;
2303	}
2304	}
2305
2306	if (str >= buf + UBUFSIZ)
2307	{
2308	ch = NOCHAR;
2309	break;
2310	}
2311	}	2311	}
2312		2312
		2313	if (!(SHOULD_INVOKE (HOOK_ADD_LINES)
		2314	&& HOOK_INVOKE ((this, HOOK_ADD_LINES, DT_WCS_LEN, buf, str - buf, DT_END))))
2313	scr_add_lines (buf, nlines, str - buf);	2315	scr_add_lines (buf, str - buf, nlines);
2314		2316
2315	/*	2317	/*
2316	* 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
2317	* 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.
2318	* the number of pages between refreshes is refresh_limit, which	2320	* if skipScroll is enabled.
2319	* is incremented here because we must be doing flat-out scrolling.
2320	*
2321	* refreshing should be correct for small scrolls, because of the
2322	* time-out
2323	*/	2321	*/
2324	if (refreshnow)	2322	if (refreshnow)
2325	{	2323	{
2326	if ((Options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)
2327	refresh_limit++;
2328	else
2329	scr_refresh (refresh_type);	2324	scr_refresh ();
		2325	want_refresh = 1;
2330	}	2326	}
2331
2332	}	2327	}
2333	else	2328	else
2334	{	2329	{
2335	try	2330	try
2336	{	2331	{
…		…
2344	}	2339	}
2345		2340
2346	ch = NOCHAR;	2341	ch = NOCHAR;
2347	}	2342	}
2348	}	2343	}
2349
2350	return flag;
2351	}
2352
2353	// read the next octet
2354	unicode_t
2355	rxvt_term::next_octet ()
2356	{
2357	return cmdbuf_ptr < cmdbuf_endp
2358	? *cmdbuf_ptr++
2359	: NOCHAR;
2360	}	2344	}
2361		2345
2362	// read the next character	2346	// read the next character
2363	unicode_t	2347	wchar_t
2364	rxvt_term::next_char ()	2348	rxvt_term::next_char () NOTHROW
2365	{	2349	{
2366	while (cmdbuf_ptr < cmdbuf_endp)	2350	while (cmdbuf_ptr < cmdbuf_endp)
2367	{	2351	{
2368	// assume 7-bit to be ascii ALWAYS	2352	// assume 7-bit to be ascii ALWAYS
2369	if (*cmdbuf_ptr <= 0x7f && *cmdbuf_ptr != 0x1b)	2353	if (expect_true ((unsigned char)*cmdbuf_ptr <= 0x7f && *cmdbuf_ptr != 0x1b))
2370	return *cmdbuf_ptr++;	2354	return *cmdbuf_ptr++;
2371		2355
2372	wchar_t wc;	2356	wchar_t wc;
2373	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);
2374		2358
2375	if (len == (size_t)-2)	2359	if (len == (size_t)-2)
2376	{	2360	{
2377	// the mbstate stores incomplete sequences. didn't know this :/	2361	// the mbstate stores incomplete sequences. didn't know this :/
2378	cmdbuf_ptr = cmdbuf_endp;	2362	cmdbuf_ptr = cmdbuf_endp;
2379	break;	2363	break;
2380	}	2364	}
2381		2365
2382	if (len == (size_t)-1)	2366	if (len == (size_t)-1)
		2367	{
		2368	mbstate.reset (); // reset now undefined conversion state
2383	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	}
2384		2371
2385	// assume wchar == unicode	2372	// assume wchar == unicode
2386	cmdbuf_ptr += len;	2373	cmdbuf_ptr += len;
2387	return wc;	2374	return wc & UNICODE_MASK;
2388	}	2375	}
2389		2376
2390	return NOCHAR;	2377	return NOCHAR;
2391	}	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;
2392		2390
2393	/* rxvt_cmd_getc () - Return next input character */	2391	/* rxvt_cmd_getc () - Return next input character */
2394	/*	2392	/*
2395	* Return the next input character after first passing any keyboard input	2393	* Return the next input character after first passing any keyboard input
2396	* to the command.	2394	* to the command.
2397	*/	2395	*/
2398	unicode_t	2396	wchar_t
2399	rxvt_term::cmd_getc ()	2397	rxvt_term::cmd_getc () THROW ((class out_of_input))
2400	{	2398	{
2401	unicode_t c = next_char ();	2399	wchar_t c = next_char ();
2402		2400
2403	if (c == NOCHAR)	2401	if (c == NOCHAR)
2404	throw out_of_input;	2402	throw out_of_input;
2405		2403
2406	return c;	2404	return c;
2407	}	2405	}
2408		2406
2409	unicode_t	2407	uint32_t
2410	rxvt_term::cmd_get8 ()	2408	rxvt_term::cmd_get8 () THROW ((class out_of_input))
2411	{	2409	{
2412	unicode_t c = next_octet ();	2410	uint32_t c = next_octet ();
2413		2411
2414	if (c == NOCHAR)	2412	if (c == NOCHAR)
2415	throw out_of_input;	2413	throw out_of_input;
2416		2414
2417	return c;	2415	return c;
…		…
2421	/*----------------------------------------------------------------------*/	2419	/*----------------------------------------------------------------------*/
2422	#ifdef PRINTPIPE	2420	#ifdef PRINTPIPE
2423	FILE *	2421	FILE *
2424	rxvt_term::popen_printer ()	2422	rxvt_term::popen_printer ()
2425	{	2423	{
2426	FILE *stream = popen (rs[Rs_print_pipe], "w");	2424	FILE *stream = popen (rs[Rs_print_pipe] ? rs[Rs_print_pipe] : PRINTPIPE, "w");
2427		2425
2428	if (stream == NULL)	2426	if (stream == NULL)
2429	rxvt_warn ("can't open printer pipe, not printing.\n");	2427	rxvt_warn ("can't open printer pipe, not printing.\n");
2430		2428
2431	return stream;	2429	return stream;
…		…
2442	* simulate attached vt100 printer	2440	* simulate attached vt100 printer
2443	*/	2441	*/
2444	void	2442	void
2445	rxvt_term::process_print_pipe ()	2443	rxvt_term::process_print_pipe ()
2446	{	2444	{
2447	int done;	2445	FILE *fd = popen_printer ();
2448	FILE *fd;
2449		2446
2450	if ((fd = popen_printer ()) == NULL)	2447	if (!fd)
2451	return;	2448	return;
2452		2449
2453	/*	2450	/*
2454	* 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
2455	* is received.	2452	* is received.
2456	*/	2453	*/
2457	for (done = 0; !done;)	2454	for (int done = 0; !done; )
2458	{	2455	{
2459	unsigned char buf[8];	2456	unsigned char buf[8];
2460	unicode_t ch;	2457	unicode_t ch;
2461	unsigned int i, len;	2458	unsigned int i, len;
2462		2459
…		…
2481	{	2478	{
2482	if ((buf[len++] = cmd_getc ()) == 'i')	2479	if ((buf[len++] = cmd_getc ()) == 'i')
2483	break; /* done = 1 */	2480	break; /* done = 1 */
2484	}	2481	}
2485	}	2482	}
2486		2483
2487	for (i = 0; i < len; i++)	2484	for (i = 0; i < len; i++)
2488	if (putc (buf[i], fd) == EOF)	2485	if (putc (buf[i], fd) == EOF)
2489	{	2486	{
2490	done = 1;	2487	done = 1;
2491	break;	2488	break;
…		…
2493	}	2490	}
2494	}	2491	}
2495		2492
2496	pclose_printer (fd);	2493	pclose_printer (fd);
2497	}	2494	}
2498	#endif /* PRINTPIPE */	2495	#endif /* PRINTPIPE */
2499	/*}}} */	2496	/*}}} */
2500		2497
2501	/* *INDENT-OFF* */	2498	/* *INDENT-OFF* */
2502	enum {	2499	enum {
2503	C1_40 = 0x40,	2500	C1_40 = 0x40,
…		…
2517	case C0_ESC:	2514	case C0_ESC:
2518	process_escape_seq ();	2515	process_escape_seq ();
2519	break;	2516	break;
2520	case C0_ENQ: /* terminal Status */	2517	case C0_ENQ: /* terminal Status */
2521	if (rs[Rs_answerbackstring])	2518	if (rs[Rs_answerbackstring])
2522	tt_write ((const unsigned char *)rs[Rs_answerbackstring],	2519	tt_write (rs [Rs_answerbackstring], strlen (rs [Rs_answerbackstring]));
2523	(unsigned int)STRLEN (rs[Rs_answerbackstring]));
2524	else	2520	else
2525	tt_write ((unsigned char *)VT100_ANS,	2521	tt_write (VT100_ANS, strlen (VT100_ANS));
2526	(unsigned int)STRLEN (VT100_ANS));
2527	break;	2522	break;
2528	case C0_BEL: /* bell */	2523	case C0_BEL: /* bell */
2529	scr_bell ();	2524	scr_bell ();
2530	break;	2525	break;
2531	case C0_BS: /* backspace */	2526	case C0_BS: /* backspace */
…		…
2555	process_dcs_seq ();	2550	process_dcs_seq ();
2556	break;	2551	break;
2557	case 0x9b: /* CSI */	2552	case 0x9b: /* CSI */
2558	process_csi_seq ();	2553	process_csi_seq ();
2559	break;	2554	break;
2560	case 0x9d: /* CSI */	2555	case 0x9d: /* OSC */
2561	process_osc_seq ();	2556	process_osc_seq ();
2562	break;	2557	break;
2563	#endif	2558	#endif
2564	}	2559	}
2565	}	2560	}
…		…
2609	break;	2604	break;
2610	case 'Z': /* identify the terminal type */	2605	case 'Z': /* identify the terminal type */
2611	tt_printf ("\033/Z"); /* I am a VT100 emulating a VT52 */	2606	tt_printf ("\033/Z"); /* I am a VT100 emulating a VT52 */
2612	break;	2607	break;
2613	case '<': /* turn off VT52 mode */	2608	case '<': /* turn off VT52 mode */
2614	PrivMode (0, PrivMode_vt52);	2609	set_privmode (PrivMode_vt52, 0);
2615	break;	2610	break;
2616	case 'F': /* use special graphics character set */	2611	case 'F': /* use special graphics character set */
2617	case 'G': /* use regular character set */	2612	case 'G': /* use regular character set */
2618	/* unimplemented */	2613	/* unimplemented */
2619	break;	2614	break;
…		…
2630	void	2625	void
2631	rxvt_term::process_escape_seq ()	2626	rxvt_term::process_escape_seq ()
2632	{	2627	{
2633	unicode_t ch = cmd_getc ();	2628	unicode_t ch = cmd_getc ();
2634		2629
2635	if (PrivateModes & PrivMode_vt52)	2630	if (priv_modes & PrivMode_vt52)
2636	{	2631	{
2637	process_escape_vt52 (ch);	2632	process_escape_vt52 (ch);
2638	return;	2633	return;
2639	}	2634	}
2640		2635
…		…
2655	scr_charset_set (2, (unsigned int)cmd_getc ());	2650	scr_charset_set (2, (unsigned int)cmd_getc ());
2656	break;	2651	break;
2657	case '+':	2652	case '+':
2658	scr_charset_set (3, (unsigned int)cmd_getc ());	2653	scr_charset_set (3, (unsigned int)cmd_getc ());
2659	break;	2654	break;
2660	#ifndef NO_FRILLS	2655	#if !ENABLE_MINIMAL
2661	case '6':	2656	case '6':
2662	scr_backindex ();	2657	scr_backindex ();
2663	break;	2658	break;
2664	#endif	2659	#endif
2665	case '7':	2660	case '7':
2666	scr_cursor (SAVE);	2661	scr_cursor (SAVE);
2667	break;	2662	break;
2668	case '8':	2663	case '8':
2669	scr_cursor (RESTORE);	2664	scr_cursor (RESTORE);
2670	break;	2665	break;
2671	#ifndef NO_FRILLS	2666	#if !ENABLE_MINIMAL
2672	case '9':	2667	case '9':
2673	scr_forwardindex ();	2668	scr_forwardindex ();
2674	break;	2669	break;
2675	#endif	2670	#endif
2676	case '=':	2671	case '=':
2677	case '>':	2672	case '>':
2678	PrivMode ((ch == '='), PrivMode_aplKP);	2673	set_privmode (PrivMode_aplKP, ch == '=');
2679	break;	2674	break;
2680		2675
2681	case C1_40:	2676	case C1_40:
2682	cmd_getc ();	2677	cmd_getc ();
2683	break;	2678	break;
…		…
2686	break;	2681	break;
2687		2682
2688	/* 8.3.87: NEXT LINE */	2683	/* 8.3.87: NEXT LINE */
2689	case C1_NEL: /* ESC E */	2684	case C1_NEL: /* ESC E */
2690	{	2685	{
2691	unicode_t nlcr[] = { C0_LF, C0_CR };	2686	wchar_t nlcr[] = { C0_LF, C0_CR };
2692	scr_add_lines (nlcr, 1, 2);	2687	scr_add_lines (nlcr, ARRAY_LENGTH(nlcr), 1);
2693	}	2688	}
2694	break;	2689	break;
2695		2690
2696	/* kidnapped escape sequence: Should be 8.3.48 */	2691	/* kidnapped escape sequence: Should be 8.3.48 */
2697	case C1_ESA: /* ESC G */	2692	case C1_ESA: /* ESC G */
2698	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 */
2699	break;	2696	break;
2700		2697
2701	/* 8.3.63: CHARACTER TABULATION SET */	2698	/* 8.3.63: CHARACTER TABULATION SET */
2702	case C1_HTS: /* ESC H */	2699	case C1_HTS: /* ESC H */
2703	scr_set_tab (1);	2700	scr_set_tab (1);
…		…
2719	process_dcs_seq ();	2716	process_dcs_seq ();
2720	break;	2717	break;
2721		2718
2722	/* 8.3.110: SINGLE CHARACTER INTRODUCER */	2719	/* 8.3.110: SINGLE CHARACTER INTRODUCER */
2723	case C1_SCI: /* ESC Z */	2720	case C1_SCI: /* ESC Z */
2724	tt_write ((const unsigned char *)ESCZ_ANSWER,	2721	tt_write (ESCZ_ANSWER, sizeof (ESCZ_ANSWER) - 1);
2725	(unsigned int) (sizeof (ESCZ_ANSWER) - 1));
2726	break; /* steal obsolete ESC [ c */	2722	break; /* steal obsolete ESC [ c */
2727		2723
2728	/* 8.3.16: CONTROL SEQUENCE INTRODUCER */	2724	/* 8.3.16: CONTROL SEQUENCE INTRODUCER (CSI) */
2729	case C1_CSI: /* ESC [ */	2725	case C1_CSI: /* ESC [ */
2730	process_csi_seq ();	2726	process_csi_seq ();
2731	break;	2727	break;
2732		2728
2733	/* 8.3.90: OPERATING SYSTEM COMMAND */	2729	/* 8.3.90: OPERATING SYSTEM COMMAND (OSC) */
2734	case C1_OSC: /* ESC ] */	2730	case C1_OSC: /* ESC ] */
2735	process_osc_seq ();	2731	process_osc_seq ();
2736	break;	2732	break;
2737		2733
2738	/* 8.3.106: RESET TO INITIAL STATE */	2734	/* 8.3.106: RESET TO INITIAL STATE (RIS) */
2739	case 'c':	2735	case 'c':
2740	mbstate.reset ();	2736	mbstate.reset ();
2741	scr_poweron ();	2737	scr_poweron ();
2742	scrollbar_show (1);	2738	scrollBar.show (1);
2743	break;	2739	break;
2744		2740
2745	/* 8.3.79: LOCKING-SHIFT TWO (see ISO2022) */	2741	/* 8.3.79: LOCKING-SHIFT TWO (see ISO2022) */
2746	case 'n':	2742	case 'n':
2747	scr_charset_choose (2);	2743	scr_charset_choose (2);
…		…
2767	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,
2768	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 ,
2769	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
2770	};	2766	};
2771		2767
2772	#define make_byte(b7,b6,b5,b4,b3,b2,b1,b0) \	2768	#define make_byte(b0,b1,b2,b3,b4,b5,b6,b7) \
2773	(((b7) << 7) | ((b6) << 6) | ((b5) << 5) | ((b4) << 4) \	2769	(((b7) << 7) | ((b6) << 6) | ((b5) << 5) | ((b4) << 4) \
2774	| ((b3) << 3) | ((b2) << 2) | ((b1) << 1) | (b0))	2770	| ((b3) << 3) | ((b2) << 2) | ((b1) << 1) | (b0))
2775	#define get_byte_array_bit(array, bit) \	2771	#define get_byte_array_bit(array, bit) \
2776	(!! ((array)[ (bit) / 8] & (128 >> ((bit) & 7))))	2772	(!! ((array)[(bit) >> 3] & (1 << ((bit) & 7))))
2777		2773
2778	const unsigned char csi_defaults[] =	2774	static const unsigned char csi_defaults[] =
2779	{	2775	{
2780	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, */
2781	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, */
2782	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, */
2783	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, [, \, ], ^, _, */
…		…
2792	rxvt_term::process_csi_seq ()	2788	rxvt_term::process_csi_seq ()
2793	{	2789	{
2794	unicode_t ch, priv, i;	2790	unicode_t ch, priv, i;
2795	unsigned int nargs, p;	2791	unsigned int nargs, p;
2796	int n, ndef;	2792	int n, ndef;
2797	int arg[ESC_ARGS];	2793	int arg[ESC_ARGS] = { };
2798		2794
2799	for (nargs = ESC_ARGS; nargs > 0;)	2795	nargs = 0;
2800	arg[--nargs] = 0;
2801		2796
2802	priv = 0;	2797	priv = 0;
2803	ch = cmd_getc ();	2798	ch = cmd_getc ();
2804	if (ch >= '<' && ch <= '?')	2799	if ((ch >= '<' && ch <= '?') || ch == '!')
		2800	{
2805	{ /* '<' '=' '>' '?' */	2801	/* '<' '=' '>' '?' '!' */
2806	priv = ch;	2802	priv = ch;
2807	ch = cmd_getc ();	2803	ch = cmd_getc ();
2808	}	2804	}
2809		2805
2810	/* read any numerical arguments */	2806	/* read any numerical arguments */
…		…
2839	ndef = get_byte_array_bit (csi_defaults, i);	2835	ndef = get_byte_array_bit (csi_defaults, i);
2840	for (p = 0; p < nargs; p++)	2836	for (p = 0; p < nargs; p++)
2841	if (arg[p] == -1)	2837	if (arg[p] == -1)
2842	arg[p] = ndef;	2838	arg[p] = ndef;
2843		2839
2844	#ifdef DEBUG_CMD
2845	fprintf (stderr, "CSI ");
2846	for (p = 0; p < nargs; p++)
2847	fprintf (stderr, "%d%s", arg[p], p < nargs - 1 ? ";" : "");
2848	fprintf (stderr, "%c\n", ch);
2849	#endif
2850
2851	/*	2840	/*
2852	* private mode handling	2841	* private mode handling
2853	*/	2842	*/
2854	if (priv)	2843	if (priv)
2855	{	2844	{
2856	switch (priv)	2845	switch (priv)
2857	{	2846	{
2858	case '>':	2847	case '>':
2859	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	//
2860	tt_printf ("\033[>%d;%-.8s;0c", 'R', VSTRING);	2857	tt_printf ("\033[>%d;95;0c", 'U');
		2858	}
2861	break;	2859	break;
		2860
2862	case '?':	2861	case '?':
2863	if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')	2862	if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')
2864	process_terminal_mode (ch, priv, nargs, arg);	2863	process_terminal_mode (ch, priv, nargs, arg);
2865	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);
2866	}	2877	}
		2878	break;
		2879	}
		2880
2867	return;	2881	return;
2868	}	2882	}
2869		2883
2870	switch (ch)	2884	switch (ch)
2871	{	2885	{
…		…
2970		2984
2971	case CSI_SD: /* 8.3.114: (1) SCROLL DOWN */	2985	case CSI_SD: /* 8.3.114: (1) SCROLL DOWN */
2972	arg[0] = -arg[0];	2986	arg[0] = -arg[0];
2973	/* FALLTHROUGH */	2987	/* FALLTHROUGH */
2974	case CSI_SU: /* 8.3.148: (1) SCROLL UP */	2988	case CSI_SU: /* 8.3.148: (1) SCROLL UP */
2975	scr_scroll_text (screen.tscroll, screen.bscroll, arg[0], 0);	2989	scr_scroll_text (screen.tscroll, screen.bscroll, arg[0]);
2976	break;	2990	break;
2977		2991
2978	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */	2992	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */
2979	tt_write ((const unsigned char *)VT100_ANS,	2993	tt_write (VT100_ANS, sizeof (VT100_ANS) - 1);
2980	(unsigned int) (sizeof (VT100_ANS) - 1));
2981	break;	2994	break;
2982		2995
2983	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */	2996	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */
2984	process_sgr_mode (nargs, arg);	2997	process_sgr_mode (nargs, arg);
2985	break;	2998	break;
…		…
2992	break;	3005	break;
2993	case 6: /* CPR requested */	3006	case 6: /* CPR requested */
2994	scr_report_position ();	3007	scr_report_position ();
2995	break;	3008	break;
2996	case 7: /* unofficial extension */	3009	case 7: /* unofficial extension */
2997	if (Options & Opt_insecure)	3010	if (option (Opt_insecure))
2998	tt_printf ("%-.250s\n", rs[Rs_display_name]);	3011	tt_printf ("%-.250s\012", rs[Rs_display_name]);
2999	break;	3012	break;
3000	case 8: /* unofficial extension */	3013	case 8: /* unofficial extension */
3001	process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);	3014	process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);
3002	break;	3015	break;
3003	}	3016	}
…		…
3039	break;	3052	break;
3040		3053
3041	case CSI_RM: /* 8.3.107: RESET MODE */	3054	case CSI_RM: /* 8.3.107: RESET MODE */
3042	if (arg[0] == 4)	3055	if (arg[0] == 4)
3043	scr_insert_mode (0);	3056	scr_insert_mode (0);
		3057	else if (arg[0] == 20)
		3058	priv_modes &= ~PrivMode_LFNL;
3044	break;	3059	break;
3045		3060
3046	case CSI_SM: /* 8.3.126: SET MODE */	3061	case CSI_SM: /* 8.3.126: SET MODE */
3047	if (arg[0] == 4)	3062	if (arg[0] == 4)
3048	scr_insert_mode (1);	3063	scr_insert_mode (1);
		3064	else if (arg[0] == 20)
		3065	priv_modes |= PrivMode_LFNL;
3049	break;	3066	break;
3050		3067
3051	/*	3068	/*
3052	* PRIVATE USE beyond this point. All CSI_7? sequences here	3069	* PRIVATE USE beyond this point. All CSI_7? sequences here
3053	*/	3070	*/
…		…
3065	break;	3082	break;
3066	case CSI_75:	3083	case CSI_75:
3067	scr_cursor (RESTORE);	3084	scr_cursor (RESTORE);
3068	break;	3085	break;
3069		3086
3070	#ifndef NO_FRILLS	3087	#if !ENABLE_MINIMAL
3071	case CSI_74:	3088	case CSI_74:
3072	process_window_ops (arg, nargs);	3089	process_window_ops (arg, nargs);
3073	break;	3090	break;
3074	#endif	3091	#endif
3075		3092
…		…
3082	break;	3099	break;
3083	}	3100	}
3084	}	3101	}
3085	/*}}} */	3102	/*}}} */
3086		3103
3087	#ifndef NO_FRILLS	3104	#if !ENABLE_MINIMAL
3088	/* ARGSUSED */	3105	/* ARGSUSED */
3089	void	3106	void
3090	rxvt_term::process_window_ops (const int *args, unsigned int nargs)	3107	rxvt_term::process_window_ops (const int *args, unsigned int nargs)
3091	{	3108	{
3092	int x, y;	3109	int x, y;
3093	XWindowAttributes wattr;	3110	XWindowAttributes wattr;
3094	Window wdummy;	3111	Window wdummy;
		3112
		3113	dLocal (Display *, dpy);
3095		3114
3096	if (nargs == 0)	3115	if (nargs == 0)
3097	return;	3116	return;
3098		3117
3099	switch (args[0])	3118	switch (args[0])
3100	{	3119	{
3101	/*	3120	/*
3102	* commands	3121	* commands
3103	*/	3122	*/
3104	case 1: /* deiconify window */	3123	case 1: /* deiconify window */
3105	XMapWindow (display->display, TermWin.parent[0]);	3124	XMapWindow (dpy, parent[0]);
3106	break;	3125	break;
3107	case 2: /* iconify window */	3126	case 2: /* iconify window */
3108	XIconifyWindow (display->display, TermWin.parent[0],	3127	XIconifyWindow (dpy, parent[0], display->screen);
3109	DefaultScreen (display->display));
3110	break;	3128	break;
3111	case 3: /* set position (pixels) */	3129	case 3: /* set position (pixels) */
3112	XMoveWindow (display->display, TermWin.parent[0], args[1], args[2]);	3130	XMoveWindow (dpy, parent[0], args[1], args[2]);
3113	break;	3131	break;
3114	case 4: /* set size (pixels) */	3132	case 4: /* set size (pixels) */
3115	set_widthheight ((unsigned int)args[2], (unsigned int)args[1]);	3133	set_widthheight ((unsigned int)args[2], (unsigned int)args[1]);
3116	break;	3134	break;
3117	case 5: /* raise window */	3135	case 5: /* raise window */
3118	XRaiseWindow (display->display, TermWin.parent[0]);	3136	XRaiseWindow (dpy, parent[0]);
3119	break;	3137	break;
3120	case 6: /* lower window */	3138	case 6: /* lower window */
3121	XLowerWindow (display->display, TermWin.parent[0]);	3139	XLowerWindow (dpy, parent[0]);
3122	break;	3140	break;
3123	case 7: /* refresh window */	3141	case 7: /* refresh window */
3124	scr_touch (true);	3142	scr_touch (true);
3125	break;	3143	break;
3126	case 8: /* set size (chars) */	3144	case 8: /* set size (chars) */
3127	set_widthheight ((unsigned int) (args[2] * TermWin.fwidth),	3145	set_widthheight ((unsigned int) (args[2] * fwidth),
3128	(unsigned int) (args[1] * TermWin.fheight));	3146	(unsigned int) (args[1] * fheight));
3129	break;	3147	break;
3130		3148
3131	//case 9: NYI, TODO, restore maximized window or maximize window	3149	//case 9: NYI, TODO, restore maximized window or maximize window
3132	default:	3150	default:
3133	if (args[0] >= 24) /* set height (chars) */	3151	if (args[0] >= 24) /* set height (chars) */
3134	set_widthheight ((unsigned int)TermWin.width,	3152	set_widthheight ((unsigned int)width,
3135	(unsigned int) (args[1] * TermWin.fheight));	3153	(unsigned int) (args[1] * fheight));
3136	break;	3154	break;
3137
3138		3155
3139	/*	3156	/*
3140	* reports - some output format copied from XTerm	3157	* reports - some output format copied from XTerm
3141	*/	3158	*/
3142	case 11: /* report window state */	3159	case 11: /* report window state */
3143	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);	3160	XGetWindowAttributes (dpy, parent[0], &wattr);
3144	tt_printf ("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);	3161	tt_printf ("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);
3145	break;	3162	break;
3146	case 13: /* report window position */	3163	case 13: /* report window position */
3147	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);	3164	XGetWindowAttributes (dpy, parent[0], &wattr);
3148	XTranslateCoordinates (display->display, TermWin.parent[0], wattr.root,	3165	XTranslateCoordinates (dpy, parent[0], wattr.root,
3149	-wattr.border_width, -wattr.border_width,	3166	-wattr.border_width, -wattr.border_width,
3150	&x, &y, &wdummy);	3167	&x, &y, &wdummy);
3151	tt_printf ("\033[3;%d;%dt", x, y);	3168	tt_printf ("\033[3;%d;%dt", x, y);
3152	break;	3169	break;
3153	case 14: /* report window size (pixels) */	3170	case 14: /* report window size (pixels) */
3154	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);	3171	XGetWindowAttributes (dpy, parent[0], &wattr);
3155	tt_printf ("\033[4;%d;%dt", wattr.height, wattr.width);	3172	tt_printf ("\033[4;%d;%dt", wattr.height, wattr.width);
3156	break;	3173	break;
3157	case 18: /* report text area size (chars) */	3174	case 18: /* report text area size (chars) */
3158	tt_printf ("\033[8;%d;%dt", TermWin.nrow, TermWin.ncol);	3175	tt_printf ("\033[8;%d;%dt", nrow, ncol);
3159	break;	3176	break;
3160	case 19: /* report window size (chars) */	3177	case 19: /* report window size (chars) */
3161	tt_printf ("\033[9;%d;%dt", TermWin.nrow, TermWin.ncol);	3178	tt_printf ("\033[9;%d;%dt", nrow, ncol);
3162	break;	3179	break;
3163	case 20: /* report icon label */	3180	case 20: /* report icon label */
3164	if (Options & Opt_insecure)
3165	{	3181	{
3166	char *s;	3182	char *s;
3167	XGetIconName (display->display, TermWin.parent[0], &s);	3183	XGetIconName (dpy, parent[0], &s);
3168	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);
3169	}	3186	}
3170	break;	3187	break;
3171	case 21: /* report window title */	3188	case 21: /* report window title */
3172	if (Options & Opt_insecure)
3173	{	3189	{
3174	char *s;	3190	char *s;
3175	XFetchName (display->display, TermWin.parent[0], &s);	3191	XFetchName (dpy, parent[0], &s);
3176	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);
3177	}	3194	}
3178	break;	3195	break;
3179	}	3196	}
3180	}	3197	}
3181	#endif	3198	#endif
3182		3199
3183	/*----------------------------------------------------------------------*/	3200	/*----------------------------------------------------------------------*/
3184	/*	3201	/*
3185	* get input up until STRING TERMINATOR (or BEL)	3202	* get input up until STRING TERMINATOR (or BEL)
3186	* ends_how is terminator used. returned input must be free()'d	3203	* ends_how is terminator used. returned input must be free()'d
3187	*/	3204	*/
3188	unsigned char *	3205	char *
3189	rxvt_term::get_to_st (unicode_t &ends_how)	3206	rxvt_term::get_to_st (unicode_t &ends_how)
3190	{	3207	{
3191	unicode_t prev = 0, ch;	3208	unicode_t ch;
		3209	bool seen_esc = false;
3192	unsigned int n = 0;	3210	unsigned int n = 0;
3193	unsigned char *s;
3194	unsigned char string[STRING_MAX];	3211	wchar_t string[STRING_MAX];
3195		3212
3196	while ((ch = cmd_getc ()) != NOCHAR)	3213	while ((ch = cmd_getc ()) != NOCHAR)
3197	{	3214	{
3198	if (prev == C0_ESC)	3215	if (seen_esc)
3199	{	3216	{
3200	if (ch == 0x5c) /* 7bit ST */	3217	if (ch == 0x5c) /* 7bit ST */
3201	break;	3218	break;
3202	else	3219	else
3203	return NULL;	3220	return NULL;
3204	}	3221	}
		3222	else if (ch == C0_ESC)
		3223	{
		3224	seen_esc = true;
		3225	continue;
		3226	}
3205	else if (ch == C0_BEL || ch == CHAR_ST)	3227	else if (ch == C0_BEL || ch == CHAR_ST)
3206	break;	3228	break;
		3229	else if (ch == C0_SYN)
		3230	ch = cmd_get8 ();
3207	else if (ch < 0x20)	3231	else if (ch < 0x20)
3208	return NULL; /* other control character - exit */	3232	return NULL; /* other control character - exit */
3209		3233
3210	if (n >= sizeof (string) - 1)	3234	seen_esc = false;
		3235
		3236	if (n >= STRING_MAX - 1)
3211	// stop at some sane length	3237	// stop at some sane length
3212	return NULL;	3238	return NULL;
3213		3239
3214	if (ch == C0_SYN)
3215	{
3216	string[n++] = cmd_get8 ();
3217	prev = 0;
3218	}
3219	else
3220	string[n++] = prev = ch;	3240	string[n++] = ch;
3221	}	3241	}
3222		3242
3223	string[n++] = '\0';	3243	string[n++] = '\0';
3224		3244
3225	if ((s = (unsigned char *)rxvt_malloc (n)) == NULL)
3226	return NULL;
3227
3228	ends_how = (ch == 0x5c ? C0_ESC : ch);	3245	ends_how = (ch == 0x5c ? C0_ESC : ch);
3229	STRNCPY (s, string, n);	3246
3230	return s;	3247	return rxvt_wcstombs (string);
3231	}	3248	}
3232		3249
3233	/*----------------------------------------------------------------------*/	3250	/*----------------------------------------------------------------------*/
3234	/*	3251	/*
3235	* 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)'
3236	*/	3253	*/
3237	void	3254	void
3238	rxvt_term::process_dcs_seq ()	3255	rxvt_term::process_dcs_seq ()
3239	{	3256	{
3240	unsigned char *s;
3241	unicode_t eh;
3242
3243	/*	3257	/*
3244	* Not handled yet	3258	* Not handled yet
3245	*/	3259	*/
		3260
		3261	unicode_t eh;
3246	s = get_to_st (eh);	3262	char *s = get_to_st (eh);
3247	if (s)	3263	if (s)
3248	free (s);	3264	free (s);
3249		3265
3250	return;	3266	return;
3251	}	3267	}
…		…
3255	* process OPERATING SYSTEM COMMAND sequence `ESC ] Ps ; Pt (ST|BEL)'	3271	* process OPERATING SYSTEM COMMAND sequence `ESC ] Ps ; Pt (ST|BEL)'
3256	*/	3272	*/
3257	void	3273	void
3258	rxvt_term::process_osc_seq ()	3274	rxvt_term::process_osc_seq ()
3259	{	3275	{
3260	unicode_t ch, eh;
3261	int arg;	3276	int arg;
3262		3277
3263	ch = cmd_getc ();	3278	unicode_t ch = cmd_getc ();
3264	for (arg = 0; isdigit (ch); ch = cmd_getc ())	3279	for (arg = 0; isdigit (ch); ch = cmd_getc ())
3265	arg = arg * 10 + (ch - '0');	3280	arg = arg * 10 + (ch - '0');
3266		3281
3267	if (ch == ';')	3282	if (ch == ';')
3268	{	3283	{
		3284	unicode_t eh;
3269	unsigned char *s = get_to_st (eh);	3285	char *s = get_to_st (eh);
3270		3286
3271	if (s)	3287	if (s)
3272	{	3288	{
3273	process_xterm_seq (arg, (char *)s, eh);	3289	process_xterm_seq (arg, s, eh);
3274	free (s);	3290	free (s);
3275	}	3291	}
3276	}	3292	}
3277	}	3293	}
3278		3294
3279	void	3295	void
3280	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)
3281	{	3297	{
3282	if (str[0] == '?' && !str[1])	3298	if (str[0] == '?' && !str[1])
3283	{	3299	{
3284	if (Options & Opt_insecure)	3300	rgba c;
3285	{	3301	pix_colors_focused[color].get (c);
3286	unsigned short r, g, b;	3302
3287	PixColorsFocused[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
3288	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);
3289	}
3290	}	3309	}
3291	else	3310	else
3292	set_window_color (color, str);	3311	set_window_color (color, str);
3293	}	3312	}
3294		3313
3295	/*	3314	/*
3296	* XTerm escape sequences: ESC ] Ps;Pt (ST|BEL)	3315	* XTerm escape sequences: ESC ] Ps;Pt (ST|BEL)
3297	* 0 = change iconName/title
3298	* 1 = change iconName
3299	* 2 = change title
3300	* 4 = change color
3301	* 10 = change fg color
3302	* 11 = change bg color
3303	* 12 = change text color
3304	* 13 = change mouse foreground color
3305	* 17 = change highlight character colour
3306	* 18 = change bold character color
3307	* 19 = change underlined character color
3308	* 46 = change logfile (not implemented)
3309	* 50 = change font
3310	*
3311	* rxvt extensions:
3312	* 20 = bg pixmap
3313	* 39 = change default fg color
3314	* 49 = change default bg color
3315	* 55 = dump scrollback buffer and all of screen
3316	* 701 = change locale
3317	* 702 = find font
3318	* 703 = menu
3319	*/	3316	*/
3320	void	3317	void
3321	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)
3322	{	3319	{
3323	int changed = 0;
3324	int color;	3320	int color;
3325	char *buf, *name;	3321	char *buf, *name;
3326	bool query = str[0] == '?' && !str[1];	3322	bool query = str[0] == '?' && !str[1];
		3323	int saveop = op;
		3324
		3325	dLocal (Display *, dpy);
3327		3326
3328	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
3329	switch (op)	3332	switch (op)
3330	{	3333	{
3331	case XTerm_name:	3334	case XTerm_name:
3332	set_title (str);	3335	set_title (str);
3333	/* FALLTHROUGH */	3336	/* FALLTHROUGH */
…		…
3338	set_title (str);	3341	set_title (str);
3339	break;	3342	break;
3340	case XTerm_property:	3343	case XTerm_property:
3341	if (str[0] == '?')	3344	if (str[0] == '?')
3342	{	3345	{
3343	Atom prop = XInternAtom (display->display, str + 1, True);	3346	Atom prop = display->atom (str + 1);
3344	Atom actual_type;	3347	Atom actual_type;
3345	int actual_format;	3348	int actual_format;
3346	unsigned long nitems;	3349	unsigned long nitems;
3347	unsigned long bytes_after;	3350	unsigned long bytes_after;
3348	unsigned char *value = 0;	3351	unsigned char *value = 0;
3349	const char *str = "";	3352	const char *str = "";
3350		3353
3351	if (prop	3354	if (prop
3352	&& XGetWindowProperty (display->display, TermWin.parent[0],	3355	&& XGetWindowProperty (dpy, parent[0],
3353	prop, 0, 1<<16, 0, AnyPropertyType,	3356	prop, 0, 1<<16, 0, AnyPropertyType,
3354	&actual_type, &actual_format,	3357	&actual_type, &actual_format,
3355	&nitems, &bytes_after, &value) == Success	3358	&nitems, &bytes_after, &value) == Success
3356	&& actual_type != None	3359	&& actual_type != None
3357	&& actual_format == 8)	3360	&& actual_format == 8)
3358	str = (const char *)(value);	3361	str = (const char *)(value);
3359		3362
3360	tt_printf ("\033]%d;%s%c", XTerm_property, str, resp);	3363	tt_printf ("\033]%d;%s%c", op, str, resp);
3361		3364
3362	XFree (value);	3365	XFree (value);
3363	}	3366	}
3364	else	3367	else
3365	{	3368	{
3366	char *eq = strchr (str, '='); // constness lost, but verified to be ok	3369	char *eq = strchr (str, '=');
3367		3370
3368	if (eq)	3371	if (eq)
3369	{	3372	{
3370	*eq = 0;	3373	*eq = 0;
3371	XChangeProperty (display->display, TermWin.parent[0],	3374	set_utf8_property (display->atom (str), eq + 1);
3372	display->atom (str), XA_STRING, 8,
3373	PropModeReplace, (unsigned char *)eq + 1,
3374	strlen (eq + 1));
3375	}	3375	}
3376	else	3376	else
3377	XDeleteProperty (display->display, TermWin.parent[0],	3377	XDeleteProperty (dpy, parent[0],
3378	display->atom (str));	3378	display->atom (str));
3379	}	3379	}
3380	break;	3380	break;
3381		3381
3382	case XTerm_Color:	3382	case XTerm_Color:
3383	for (buf = (char *)str; buf && *buf;)	3383	for (buf = (char *)str; buf && *buf;)
3384	{	3384	{
3385	if ((name = STRCHR (buf, ';')) == NULL)	3385	if ((name = strchr (buf, ';')) == NULL)
3386	break;	3386	break;
3387		3387
3388	*name++ = '\0';	3388	*name++ = '\0';
3389	color = atoi (buf);	3389	color = atoi (buf) + minCOLOR;
3390		3390
3391	if (color < 0 || color >= TOTAL_COLORS)	3391	if (!IN_RANGE_INC (color, minCOLOR, maxTermCOLOR))
3392	break;	3392	break;
3393		3393
3394	if ((buf = STRCHR (name, ';')) != NULL)	3394	if ((buf = strchr (name, ';')) != NULL)
3395	*buf++ = '\0';	3395	*buf++ = '\0';
3396		3396
3397	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 != ';')
3398	{	3473	{
3399	if (Options & Opt_insecure)	3474	if (bg_set_file (str)) /* change pixmap */
3400	{	3475	{
3401	unsigned short r, g, b;	3476	changed++;
3402	PixColorsFocused[color + minCOLOR].get (display, r, g, b);	3477	str = strchr (str, ';');
3403	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);
3404	}	3482	}
3405	}	3483	}
3406	else	3484	else
3407	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	}
3408	}	3501	}
3409	break;	3502	break;
3410	case XTerm_Color00:
3411	process_color_seq (XTerm_Color00, Color_fg, str, resp);
3412	break;
3413	case XTerm_Color01:
3414	process_color_seq (XTerm_Color00, Color_bg, str, resp);
3415	break;
3416	#ifndef NO_CURSORCOLOR
3417	case XTerm_Color_cursor:
3418	process_color_seq (XTerm_Color_cursor, Color_cursor, str, resp);
3419	break;
3420	#endif	3503	#endif
3421	case XTerm_Color_pointer_fg:
3422	process_color_seq (XTerm_Color_pointer_fg, Color_pointer_fg, str, resp);
3423	break;
3424	case XTerm_Color_pointer_bg:
3425	process_color_seq (XTerm_Color_pointer_bg, Color_pointer_bg, str, resp);
3426	break;
3427	#ifndef NO_BOLD_UNDERLINE_REVERSE
3428	case XTerm_Color_BD:
3429	process_color_seq (XTerm_Color_BD, Color_BD, str, resp);
3430	break;
3431	case XTerm_Color_UL:
3432	process_color_seq (XTerm_Color_UL, Color_UL, str, resp);
3433	break;
3434	case XTerm_Color_RV:
3435	process_color_seq (XTerm_Color_RV, Color_RV, str, resp);
3436	break;
3437	#endif
3438
3439	case XTerm_Pixmap:
3440	if (*str != ';')
3441	{
3442	#if XPM_BACKGROUND
3443	scale_pixmap (""); /* reset to default scaling */
3444	set_bgPixmap (str); /* change pixmap */
3445	#endif
3446	scr_touch (true);
3447	}
3448	while ((str = STRCHR (str, ';')) != NULL)
3449	{
3450	str++;
3451	#if XPM_BACKGROUND
3452	changed += scale_pixmap (str);
3453	#endif
3454
3455	}
3456	if (changed)
3457	{
3458	#ifdef XPM_BACKGROUND
3459	resize_pixmap ();
3460	#endif
3461	scr_touch (true);
3462	}
3463	break;
3464
3465	case XTerm_restoreFG:
3466	set_window_color (Color_fg, str);
3467	break;
3468	case XTerm_restoreBG:
3469	set_window_color (Color_bg, str);
3470	break;
3471		3504
3472	case XTerm_logfile:	3505	case XTerm_logfile:
3473	// TODO, when secure mode?	3506	// TODO, when secure mode?
3474	break;	3507	break;
3475		3508
3476	case XTerm_font:
3477	if (query)
3478	{
3479	if (Options & Opt_insecure)
3480	tt_printf ("\33]%d;%-.250s%c", XTerm_font,
3481	TermWin.fontset->fontdesc
3482	? TermWin.fontset->fontdesc
3483	: "",
3484	resp);
3485	}
3486	else
3487	change_font (str);
3488	break;
3489
3490	#ifndef NO_FRILLS
3491	case XTerm_locale:
3492	if (query)
3493	{
3494	if (Options & Opt_insecure)
3495	tt_printf ("\33]%d;%-.250s%c", XTerm_locale, locale, resp);
3496	}
3497	else
3498	{
3499	set_locale (str);
3500	# ifdef USE_XIM
3501	im_cb ();
3502	# endif
3503	}
3504	break;
3505
3506	case XTerm_findfont:
3507	if (Options & Opt_insecure)
3508	{
3509	int fid = TermWin.fontset->find_font (atoi (str));
3510	tt_printf ("\33]%d;%d;%-.250s%c", XTerm_findfont,
3511	fid, (*TermWin.fontset)[fid]->name, resp);
3512	}
3513	break;
3514	#endif
3515
3516	#ifdef MENUBAR
3517	case XTerm_Menu:
3518	if (Options & Opt_insecure)
3519	menubar_dispatch (const_cast<char *>(str)); // casting away constness is checked
3520	break;
3521	#endif
3522	#if 0	3509	#if 0
3523	case XTerm_dumpscreen: /* no error notices */	3510	case Rxvt_dumpscreen: /* no error notices */
3524	{	3511	{
3525	int fd;	3512	int fd;
3526	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)
3527	{	3514	{
3528	scr_dump (fd);	3515	scr_dump (fd);
3529	close (fd);	3516	close (fd);
3530	}	3517	}
3531	}	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));
3532	break;	3581	break;
3533	#endif	3582	#endif
3534	}	3583	}
3535	}	3584	}
3536	/*----------------------------------------------------------------------*/	3585	/*----------------------------------------------------------------------*/
…		…
3550	{	3599	{
3551	int state;	3600	int state;
3552		3601
3553	if (mode == 's')	3602	if (mode == 's')
3554	{	3603	{
3555	SavedModes |= (PrivateModes & bit);	3604	SavedModes |= (priv_modes & bit);
3556	return -1;	3605	return -1;
3557	}	3606	}
3558	else	3607	else
3559	{	3608	{
3560	if (mode == 'r')	3609	if (mode == 'r')
3561	state = (SavedModes & bit) ? 1 : 0; /* no overlapping */	3610	state = (SavedModes & bit) ? 1 : 0; /* no overlapping */
3562	else	3611	else
3563	state = (mode == 't') ? ! (PrivateModes & bit) : mode;	3612	state = (mode == 't') ? ! (priv_modes & bit) : mode;
3564	PrivMode (state, bit);	3613
		3614	set_privmode (bit, state);
3565	}	3615	}
3566		3616
3567	return state;	3617	return state;
3568	}	3618	}
3569		3619
3570	/* we're not using priv _yet_ */	3620	/* we're not using priv _yet_ */
3571	void	3621	void
3572	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)
3573	{	3623	{
3574	unsigned int i, j;	3624	unsigned int i, j;
3575	int state;	3625	int state;
3576		3626
3577	static const struct	3627	static const struct
3578	{	3628	{
3579	const int argval;	3629	const int argval;
3580	const unsigned long bit;	3630	const unsigned long bit;
3581	}
3582
3583	argtopriv[] = {	3631	} argtopriv[] = {
3584	{ 1, PrivMode_aplCUR },	3632	{ 1, PrivMode_aplCUR }, // DECCKM
3585	{ 2, PrivMode_vt52 },	3633	{ 2, PrivMode_vt52 },
3586	{ 3, PrivMode_132 },	3634	{ 3, PrivMode_132 }, // DECCOLM
3587	{ 4, PrivMode_smoothScroll },	3635	{ 4, PrivMode_smoothScroll }, // DECSCLM
3588	{ 5, PrivMode_rVideo },	3636	{ 5, PrivMode_rVideo }, // DECSCNM
3589	{ 6, PrivMode_relOrigin },	3637	{ 6, PrivMode_relOrigin }, // DECOM
3590	{ 7, PrivMode_Autowrap },	3638	{ 7, PrivMode_Autowrap }, // DECAWM
		3639	// 8, auto-repeat keys // DECARM
3591	{ 9, PrivMode_MouseX10 },	3640	{ 9, PrivMode_MouseX10 },
3592	#ifdef menuBar_esc	3641	// 18 end FF to printer after print screen
3593	{ menuBar_esc, PrivMode_menuBar },	3642	// 19 Print screen prints full screen/scroll region
3594	#endif	3643	{ 25, PrivMode_VisibleCursor }, // cnorm/cvvis/civis
3595	#ifdef scrollBar_esc	3644	#ifdef scrollBar_esc
3596	{ scrollBar_esc, PrivMode_scrollBar },	3645	{ scrollBar_esc, PrivMode_scrollBar },
3597	#endif	3646	#endif
3598	// 18, 19 printing-related
3599	{ 25, PrivMode_VisibleCursor },
3600	// 30 show scrollbar rxvt. extension
3601	{ 35, PrivMode_ShiftKeys }, // rxvt extension	3647	{ 35, PrivMode_ShiftKeys }, // rxvt extension
		3648	// 38, tektronix mode // DECTEK
3602	{ 40, PrivMode_132OK },	3649	{ 40, PrivMode_132OK },
3603	// 41 xterm more fixes NYI	3650	// 41 xterm more fixes NYI
3604	// 45 margin bell NYI	3651	// 45 margin bell NYI
3605	// 46 start logging	3652	// 46 start logging
3606	{ 47, PrivMode_Screen },	3653	{ 47, PrivMode_Screen },
3607	{ 66, PrivMode_aplKP },	3654	{ 66, PrivMode_aplKP }, // DECPAM/DECPNM
3608	#ifndef NO_BACKSPACE_KEY	3655	#ifndef NO_BACKSPACE_KEY
3609	{ 67, PrivMode_BackSpace },	3656	{ 67, PrivMode_BackSpace }, // DECBKM
3610	#endif	3657	#endif
3611	{ 1000, PrivMode_MouseX11 },	3658	{ 1000, PrivMode_MouseX11 },
3612	// 1001 Use Hilite Mouse Tracking. NYI, TODO	3659	{ 1002, PrivMode_MouseBtnEvent },
3613	// 1002 Use Cell Motion Mouse Tracking. NYI, TODO	3660	{ 1003, PrivMode_MouseAnyEvent },
3614	// 1003 Use All Motion Mouse Tracking. NYI, TODO	3661	#if ENABLE_FRILLS
		3662	{ 1005, PrivMode_ExtModeMouse },
		3663	#endif
3615	{ 1010, PrivMode_TtyOutputInh }, // rxvt extension	3664	{ 1010, PrivMode_TtyOutputInh }, // rxvt extension
3616	{ 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
3617	// 1035 enable modifiers for alt, numlock NYI	3669	// 1035 enable modifiers for alt, numlock NYI
3618	// 1036 send ESC for meta keys NYI	3670	// 1036 send ESC for meta keys NYI
3619	// 1037 send DEL for keypad delete NYI	3671	// 1037 send DEL for keypad delete NYI
3620	{ 1047, PrivMode_Screen },	3672	{ 1047, PrivMode_Screen },
3621	// 1048 save and restore cursor	3673	// 1048 save and restore cursor, implemented in code
3622	{ 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 */
3623	// 1051, 1052, 1060, 1061 keyboard emulation NYI	3675	// 1051, 1052, 1060, 1061 keyboard emulation NYI
		3676	{ 2004, PrivMode_BracketPaste },
3624	};	3677	};
3625		3678
3626	if (nargs == 0)	3679	if (nargs == 0)
3627	return;	3680	return;
3628		3681
…		…
3635	for (i = 0; i < nargs; i++)	3688	for (i = 0; i < nargs; i++)
3636	{	3689	{
3637	state = -1;	3690	state = -1;
3638		3691
3639	/* basic handling */	3692	/* basic handling */
3640	for (j = 0; j < (sizeof (argtopriv)/sizeof (argtopriv[0])); j++)	3693	for (j = 0; j < ARRAY_LENGTH(argtopriv); j++)
3641	if (argtopriv[j].argval == arg[i])	3694	if (argtopriv[j].argval == arg[i])
3642	{	3695	{
3643	state = privcases (mode, argtopriv[j].bit);	3696	state = privcases (mode, argtopriv[j].bit);
3644	break;	3697	break;
3645	}	3698	}
3646		3699
3647	/* extra handling for values with state unkept */	3700	/* extra handling for values with state unkept */
3648	switch (arg[i])	3701	switch (arg[i])
3649	{	3702	{
		3703	#if ENABLE_STYLES
		3704	case 1021:
		3705	set_option (Opt_intensityStyles, mode);
		3706
		3707	scr_touch (true);
		3708	break;
		3709	#endif
3650	case 1048: /* alternative cursor save */	3710	case 1048: /* alternative cursor save */
3651	if (Options & Opt_secondaryScreen)	3711	if (option (Opt_secondaryScreen))
3652	if (mode == 0)	3712	if (mode == 0)
3653	scr_cursor (RESTORE);	3713	scr_cursor (RESTORE);
3654	else if (mode == 1)	3714	else if (mode == 1)
3655	scr_cursor (SAVE);	3715	scr_cursor (SAVE);
3656	break;	3716	break;
…		…
3664	case 2: /* VT52 mode */	3724	case 2: /* VT52 mode */
3665	/* oddball mode. should be set regardless of set/reset	3725	/* oddball mode. should be set regardless of set/reset
3666	* parameter. Return from VT52 mode with an ESC < from	3726	* parameter. Return from VT52 mode with an ESC < from
3667	* within VT52 mode	3727	* within VT52 mode
3668	*/	3728	*/
3669	PrivMode (1, PrivMode_vt52);	3729	set_privmode (PrivMode_vt52, 1);
3670	break;	3730	break;
3671	case 3: /* 80/132 */	3731	case 3: /* 80/132 */
3672	if (PrivateModes & PrivMode_132OK)	3732	if (priv_modes & PrivMode_132OK)
3673	set_widthheight (((state ? 132 : 80) * TermWin.fwidth), TermWin.height);	3733	set_widthheight ((state ? 132 : 80) * fwidth, 24 * fheight);
3674	break;	3734	break;
3675	case 4: /* smooth scrolling */	3735	case 4: /* smooth scrolling */
3676	if (state)	3736	set_option (Opt_jumpScroll, !state);
3677	Options &= ~Opt_jumpScroll;
3678	else
3679	Options |= Opt_jumpScroll;
3680	break;	3737	break;
3681	case 5: /* reverse video */	3738	case 5: /* reverse video */
3682	scr_rvideo_mode (state);	3739	scr_rvideo_mode (state);
3683	break;	3740	break;
3684	case 6: /* relative/absolute origins */	3741	case 6: /* relative/absolute origins */
…		…
3688	scr_autowrap (state);	3745	scr_autowrap (state);
3689	break;	3746	break;
3690	/* 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 */
3691	case 9: /* X10 mouse reporting */	3748	case 9: /* X10 mouse reporting */
3692	if (state) /* orthogonal */	3749	if (state) /* orthogonal */
3693	PrivateModes &= ~PrivMode_MouseX11;	3750	priv_modes &= ~(PrivMode_MouseX11|PrivMode_MouseBtnEvent|PrivMode_MouseAnyEvent);
3694	break;	3751	break;
3695	#ifdef menuBar_esc
3696	case menuBar_esc:
3697	#ifdef MENUBAR
3698	map_menuBar (state);
3699	#endif
3700	break;
3701	#endif
3702	#ifdef scrollBar_esc	3752	#ifdef scrollBar_esc
3703	case scrollBar_esc:	3753	case scrollBar_esc:
3704	if (scrollbar_mapping (state))	3754	if (scrollBar.map (state))
3705	{	3755	{
3706	resize_all_windows (0, 0, 0);	3756	resize_all_windows (0, 0, 0);
3707	scr_touch (true);	3757	scr_touch (true);
3708	}	3758	}
3709	break;	3759	break;
…		…
3718	break;	3768	break;
3719	/* case 66: - application key pad */	3769	/* case 66: - application key pad */
3720	/* case 67: - backspace key */	3770	/* case 67: - backspace key */
3721	case 1000: /* X11 mouse reporting */	3771	case 1000: /* X11 mouse reporting */
3722	if (state) /* orthogonal */	3772	if (state) /* orthogonal */
3723	PrivateModes &= ~PrivMode_MouseX10;	3773	priv_modes &= ~(PrivMode_MouseX10|PrivMode_MouseBtnEvent|PrivMode_MouseAnyEvent);
3724	break;	3774	break;
3725	#if 0
3726	case 1001:	3775	case 1002:
3727	break; /* X11 mouse highlighting */	3776	case 1003:
3728	#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;
3729	case 1010: /* scroll to bottom on TTY output inhibit */	3789	case 1010: /* scroll to bottom on TTY output inhibit */
3730	if (state)
3731	Options &= ~Opt_scrollTtyOutput;
3732	else
3733	Options |= Opt_scrollTtyOutput;	3790	set_option (Opt_scrollTtyOutput, !state);
3734	break;	3791	break;
3735	case 1011: /* scroll to bottom on key press */	3792	case 1011: /* scroll to bottom on key press */
3736	if (state)
3737	Options |= Opt_scrollTtyKeypress;	3793	set_option (Opt_scrollTtyKeypress, state);
3738	else
3739	Options &= ~Opt_scrollTtyKeypress;
3740	break;	3794	break;
3741	case 1047: /* secondary screen w/ clearing last */	3795	case 1047: /* secondary screen w/ clearing last */
3742	if (Options & Opt_secondaryScreen)	3796	if (option (Opt_secondaryScreen))
3743	if (current_screen != PRIMARY)	3797	if (!state)
3744	scr_erase_screen (2);	3798	scr_erase_screen (2);
		3799
3745	scr_change_screen (state);	3800	scr_change_screen (state);
3746	break;	3801	break;
3747	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
3748	scr_change_screen (state);	3807	scr_change_screen (state);
		3808
3749	if (Options & Opt_secondaryScreen)	3809	if (option (Opt_secondaryScreen))
3750	if (current_screen != PRIMARY)	3810	if (state)
3751	scr_erase_screen (2);	3811	scr_erase_screen (2);
		3812	else
		3813	scr_cursor (RESTORE);
3752	break;	3814	break;
3753	default:	3815	default:
3754	break;	3816	break;
3755	}	3817	}
3756	}	3818	}
…		…
3780	rendset = 0, rendstyle = ~RS_None;	3842	rendset = 0, rendstyle = ~RS_None;
3781	break;	3843	break;
3782	case 1:	3844	case 1:
3783	rendset = 1, rendstyle = RS_Bold;	3845	rendset = 1, rendstyle = RS_Bold;
3784	break;	3846	break;
3785	//case 2: // faint or second colour	3847	//case 2: // low intensity
		3848	case 3:
		3849	rendset = 1, rendstyle = RS_Italic;
		3850	break;
3786	case 4:	3851	case 4:
3787	rendset = 1, rendstyle = RS_Uline;	3852	rendset = 1, rendstyle = RS_Uline;
3788	break;	3853	break;
3789	case 5: // slowly blinking	3854	case 5: // slowly blinking
3790	case 6: // rapidly blinking	3855	case 6: // rapidly blinking
…		…
3802	//case 11: // scoansi acs on, first alt font	3867	//case 11: // scoansi acs on, first alt font
3803	//case 12: // scoansi acs on, |0x80, second alt font	3868	//case 12: // scoansi acs on, |0x80, second alt font
3804	//...	3869	//...
3805	//case 19: // ninth alt font	3870	//case 19: // ninth alt font
3806	//case 20: // gothic	3871	//case 20: // gothic
3807	case 21: // disable bold, faint	3872	case 21: // disable bold, faint, sometimes doubly underlined (iso 8613)
3808	rendset = 0, rendstyle = RS_Bold;	3873	rendset = 0, rendstyle = RS_Bold;
3809	break;	3874	break;
3810	case 22:	3875	case 22: // normal intensity
3811	rendset = 0, rendstyle = RS_Bold;	3876	rendset = 0, rendstyle = RS_Bold;
3812	break;	3877	break;
3813	//case 23: disable italic	3878	case 23: // disable italic
		3879	rendset = 0, rendstyle = RS_Italic;
		3880	break;
3814	case 24:	3881	case 24:
3815	rendset = 0, rendstyle = RS_Uline;	3882	rendset = 0, rendstyle = RS_Uline;
3816	break;	3883	break;
3817	case 25:	3884	case 25:
		3885	rendset = 0, rendstyle = RS_Blink;
		3886	break;
		3887	case 26: // variable spacing (iso 8613)
3818	rendset = 0, rendstyle = RS_Blink;	3888	rendset = 0, rendstyle = RS_Blink;
3819	break;	3889	break;
3820	case 27:	3890	case 27:
3821	rendset = 0, rendstyle = RS_RVid;	3891	rendset = 0, rendstyle = RS_RVid;
3822	break;	3892	break;
…		…
3840	case 35:	3910	case 35:
3841	case 36:	3911	case 36:
3842	case 37:	3912	case 37:
3843	scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);	3913	scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);
3844	break;	3914	break;
3845	#ifdef TTY_256COLOR	3915	case 38: // set fg color, ISO 8613-6
3846	case 38:
3847	if (nargs > i + 2 && arg[i + 1] == 5)	3916	if (nargs > i + 2 && arg[i + 1] == 5)
3848	{	3917	{
3849	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg);	3918	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg);
3850	i += 2;	3919	i += 2;
3851	}	3920	}
3852	break;	3921	break;
3853	#endif
3854	case 39: /* default fg */	3922	case 39: /* default fg */
3855	scr_color (Color_fg, Color_fg);	3923	scr_color (Color_fg, Color_fg);
3856	break;	3924	break;
3857		3925
3858	case 40:	3926	case 40:
…		…
3863	case 45:	3931	case 45:
3864	case 46:	3932	case 46:
3865	case 47:	3933	case 47:
3866	scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);	3934	scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);
3867	break;	3935	break;
3868	#ifdef TTY_256COLOR	3936	case 48: // set bg color, ISO 8613-6
3869	case 48:
3870	if (nargs > i + 2 && arg[i + 1] == 5)	3937	if (nargs > i + 2 && arg[i + 1] == 5)
3871	{	3938	{
3872	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg);	3939	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg);
3873	i += 2;	3940	i += 2;
3874	}	3941	}
3875	break;	3942	break;
3876	#endif
3877	case 49: /* default bg */	3943	case 49: /* default bg */
3878	scr_color (Color_bg, Color_bg);	3944	scr_color (Color_bg, Color_bg);
3879	break;	3945	break;
3880		3946
3881	#ifndef NO_BRIGHTCOLOR	3947	//case 50: // not variable spacing
		3948
		3949	#if !ENABLE_MINIMAL
3882	case 90:	3950	case 90:
3883	case 91: /* set bright fg color */	3951	case 91: /* set bright fg color */
3884	case 92:	3952	case 92:
3885	case 93:	3953	case 93:
3886	case 94:	3954	case 94:
3887	case 95:	3955	case 95:
3888	case 96:	3956	case 96:
3889	case 97:	3957	case 97:
3890	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 90)),	3958	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 90)), Color_fg);
3891	Color_fg);
3892	break;	3959	break;
3893	case 100:	3960	case 100:
3894	case 101: /* set bright bg color */	3961	case 101: /* set bright bg color */
3895	case 102:	3962	case 102:
3896	case 103:	3963	case 103:
3897	case 104:	3964	case 104:
3898	case 105:	3965	case 105:
3899	case 106:	3966	case 106:
3900	case 107:	3967	case 107:
3901	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 100)),	3968	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 100)), Color_bg);
3902	Color_bg);
3903	break;	3969	break;
3904	#endif	3970	#endif
3905
3906	}	3971	}
3907	}	3972	}
3908	}
3909	/*}}} */
3910
3911	/*{{{ (do not) process Rob Nation's own graphics mode sequences */
3912	void
3913	rxvt_term::process_graphics ()
3914	{
3915	unicode_t ch, cmd = cmd_getc ();
3916
3917	if (cmd == 'Q')
3918	{ /* query graphics */
3919	tt_printf ("\033G0\n"); /* no graphics */
3920	return;
3921	}
3922	/* swallow other graphics sequences until terminating ':' */
3923	do
3924	ch = cmd_getc ();
3925	while (ch != ':');
3926	}	3973	}
3927	/*}}} */	3974	/*}}} */
3928		3975
3929	/* ------------------------------------------------------------------------- */	3976	/* ------------------------------------------------------------------------- */
3930		3977
…		…
3934	*/	3981	*/
3935	void	3982	void
3936	rxvt_term::tt_printf (const char *fmt,...)	3983	rxvt_term::tt_printf (const char *fmt,...)
3937	{	3984	{
3938	va_list arg_ptr;	3985	va_list arg_ptr;
3939	unsigned char buf[256];	3986	char buf[256];
3940		3987
3941	va_start (arg_ptr, fmt);	3988	va_start (arg_ptr, fmt);
3942	vsnprintf ((char *)buf, 256, fmt, arg_ptr);	3989	vsnprintf ((char *)buf, 256, fmt, arg_ptr);
3943	va_end (arg_ptr);	3990	va_end (arg_ptr);
3944	tt_write (buf, STRLEN (buf));	3991	tt_write (buf, strlen (buf));
3945	}	3992	}
3946		3993
3947	/* ---------------------------------------------------------------------- */	3994	/* ---------------------------------------------------------------------- */
3948	/* 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,
3949	* or generated by us in response to a query ESC sequence.	3996	* or generated by us in response to a query ESC sequence.
3950	*/	3997	*/
		3998	static const unsigned int MAX_PTY_WRITE = 255; // minimum MAX_INPUT
		3999
3951	void	4000	void
3952	rxvt_term::tt_write (const unsigned char *data, unsigned int len)	4001	rxvt_term::tt_write (const char *data, unsigned int len)
3953	{	4002	{
3954	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;
3955		4005
3956	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;
3957	{	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
3958	if (v_buflen == 0)	4036	if (v_buflen == 0)
3959	{	4037	{
3960	ssize_t written = write (cmd_fd, data, min (MAX_PTY_WRITE, len));
3961
3962	if ((unsigned int)written == len)
3963	return;
3964
3965	data += written;
3966	len -= written;
3967	}
3968
3969
3970	v_buffer = (unsigned char *)realloc (v_buffer, v_buflen + len);
3971
3972	memcpy (v_buffer + v_buflen, data, len);
3973	v_buflen += len;
3974	}
3975
3976	for (;;)
3977	{
3978	int written = write (cmd_fd, v_buffer, min (MAX_PTY_WRITE, v_buflen));
3979
3980	if (written > 0)
3981	{
3982	v_buflen -= written;
3983
3984	if (v_buflen == 0)
3985	{
3986	free (v_buffer);	4038	free (v_buffer);
3987	v_buffer = 0;	4039	v_buffer = 0;
3988	v_buflen = 0;
3989		4040
3990	pty_ev.set (EVENT_READ);	4041	pty_ev.set (ev::READ);
3991	return;
3992	}
3993
3994	memmove (v_buffer, v_buffer + written, v_buflen);
3995	}
3996	else if (written != -1 || (errno != EAGAIN && errno != EINTR))
3997	// original code just ignores this...
3998	destroy ();
3999	else
4000	{
4001	pty_ev.set (EVENT_READ | EVENT_WRITE);
4002	return;	4042	return;
4003	}	4043	}
		4044
		4045	memmove (v_buffer, v_buffer + written, v_buflen);
4004	}	4046	}
		4047	else if (written != -1 || (errno != EAGAIN && errno != EINTR))
		4048	pty_ev.set (ev::READ);
4005	}	4049	}
4006		4050
4007	/*----------------------- end-of-file (C source) -----------------------*/	4051	/*----------------------- end-of-file (C source) -----------------------*/
4008		4052

Diff Legend

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