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.460 by sf-exg, Fri Nov 19 23:29:30 2010 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-2007 Marc Lehmann <pcg@goof.com>
		31	* Copyright (c) 2007 Emanuele Giaquinta <e.giaquinta@glauco.it>
31	*	32	*
32	* This program is free software; you can redistribute it and/or modify	33	* This program is free software; you can redistribute it and/or modify
33	* it under the terms of the GNU General Public License as published by	34	* it under the terms of the GNU General Public License as published by
34	* the Free Software Foundation; either version 2 of the License, or	35	* the Free Software Foundation; either version 2 of the License, or
35	* (at your option) any later version.	36	* (at your option) any later version.
…		…
43	* along with this program; if not, write to the Free Software	44	* along with this program; if not, write to the Free Software
44	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	45	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
45	*----------------------------------------------------------------------*/	46	*----------------------------------------------------------------------*/
46		47
47	/*{{{ includes: */	48	/*{{{ includes: */
48	#include "../config.h" /* NECESSARY */	49	#include "../config.h"
49	#include "rxvt.h" /* NECESSARY */	50	#include "rxvt.h"
		51	#include "rxvtperl.h"
50	#include "version.h"	52	#include "version.h"
51	#include "command.h"	53	#include "command.h"
52		54
53	#include <wchar.h>	55	#ifdef KEYSYM_RESOURCE
		56	# include "keyboard.h"
		57	#endif
		58
		59	#include <csignal>
		60
		61	#if LINUX_YIELD_HACK
		62	# include <ctime>
		63	#endif
54		64
55	/*----------------------------------------------------------------------*/	65	/*----------------------------------------------------------------------*/
56		66
57	#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 (bgPixmap.flags & bgPixmap_t::hasChanged)
662	{	981	{
663	want_full_refresh = 0;	982	bgPixmap.flags &= ~bgPixmap_t::hasChanged;
664	scr_clear ();	983	// scr_clear (true); This needs to be researched further!
665	scr_touch (false);	984	scr_touch (false);
666	want_refresh = 1;
667	}	985	}
668	#endif	986	#endif
669		987
670	if (want_refresh)	988	if (want_refresh)
671	{	989	{
		990	if (SHOULD_INVOKE (HOOK_LINE_UPDATE))
		991	{
		992	int row = view_start;
		993	int end_row = row + nrow;
		994
		995	while (row > top_row && ROW (row - 1).is_longer ())
		996	--row;
		997
		998	do
		999	{
		1000	int start_row = row;
		1001	line_t *l;
		1002
		1003	do
		1004	{
		1005	l = &ROW (row++);
		1006
		1007	if (!(l->f & LINE_FILTERED))
		1008	{
		1009	// line not filtered, mark it as filtered
		1010	l->f |= LINE_FILTERED;
		1011	while (l->is_longer ())
		1012	{
		1013	l = &ROW (row++);
		1014	l->f |= LINE_FILTERED;
		1015	}
		1016
		1017	// and filter it
		1018	HOOK_INVOKE ((this, HOOK_LINE_UPDATE, DT_INT, start_row, DT_END));
		1019
		1020	break;
		1021	}
		1022	}
		1023	while (l->is_longer () && row < end_row);
		1024	}
		1025	while (row < end_row);
		1026	}
		1027
672	scr_refresh (refresh_type);	1028	scr_refresh ();
673	scrollbar_show (1);	1029	scrollBar.show (1);
674	#ifdef USE_XIM	1030	#ifdef USE_XIM
675	IMSendSpot ();	1031	IMSendSpot ();
676	#endif	1032	#endif
677	}	1033	}
678		1034
679	display->flush ();	1035	display->flush ();
680	}	1036	}
681		1037
		1038	/* checks whether a refresh is requested and starts the refresh timer */
682	void	1039	void
683	rxvt_term::check_cb (check_watcher &w)	1040	rxvt_term::refresh_check ()
684	{	1041	{
685	SET_R (this);	1042	if (want_refresh && !flush_ev.is_active ())
686	SET_LOCALE (locale);	1043	flush_ev.start (1. / 60.); // refresh at max. 60 Hz normally
687		1044
		1045	display->flush ();
		1046	}
		1047
		1048	void
		1049	rxvt_term::flush_cb (ev::timer &w, int revents)
		1050	{
		1051	make_current ();
		1052
		1053	refresh_count = 0;
688	flush ();	1054	flush ();
689	}	1055	}
690		1056
691	#ifdef CURSOR_BLINK	1057	#ifdef CURSOR_BLINK
692	void	1058	void
693	rxvt_term::cursor_blink_cb (time_watcher &w)	1059	rxvt_term::cursor_blink_cb (ev::timer &w, int revents)
694	{	1060	{
695	hidden_cursor = !hidden_cursor;	1061	hidden_cursor = !hidden_cursor;
696	want_refresh = 1;	1062	want_refresh = 1;
697		1063	refresh_check ();
698	w.start (w.at + BLINK_INTERVAL);
699	}	1064	}
700	#endif	1065	#endif
701		1066
702	#ifdef TEXT_BLINK	1067	#ifdef TEXT_BLINK
703	void	1068	void
704	rxvt_term::text_blink_cb (time_watcher &w)	1069	rxvt_term::text_blink_cb (ev::timer &w, int revents)
705	{	1070	{
706	if (scr_refresh_rend (RS_Blink, RS_Blink))	1071	if (scr_refresh_rend (RS_Blink, RS_Blink))
707	{	1072	{
708	hidden_text = !hidden_text;	1073	hidden_text = !hidden_text;
709	want_refresh = 1;	1074	want_refresh = 1;
710	w.start (w.at + TEXT_BLINK_INTERVAL);	1075	refresh_check ();
711	}	1076	}
		1077	else
		1078	w.stop ();
712	}	1079	}
713	#endif	1080	#endif
714		1081
715	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING	1082	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
716	void	1083	void
717	rxvt_term::cont_scroll_cb (time_watcher &w)	1084	rxvt_term::cont_scroll_cb (ev::timer &w, int revents)
718	{	1085	{
719	if ((scrollbar_isUp() || scrollbar_isDn()) &&	1086	if ((scrollBar.state == STATE_UP || scrollBar.state == STATE_DOWN)
720	scr_page (scrollbar_isUp() ? UP : DN, 1))	1087	&& scr_page (scrollBar.state == STATE_UP ? UP : DN, 1))
721	{	1088	{
722	refresh_type |= SMOOTH_REFRESH;
723	want_refresh = 1;	1089	want_refresh = 1;
724	w.start (w.at + SCROLLBAR_CONTINUOUS_DELAY);	1090	refresh_check ();
725	}	1091	}
		1092	else
		1093	w.stop ();
726	}	1094	}
727	#endif	1095	#endif
728		1096
729	#ifdef SELECTION_SCROLLING	1097	#ifdef SELECTION_SCROLLING
730	void	1098	void
731	rxvt_term::sel_scroll_cb (time_watcher &w)	1099	rxvt_term::sel_scroll_cb (ev::timer &w, int revents)
732	{	1100	{
733	if (scr_page (scroll_selection_dir, scroll_selection_lines))	1101	if (scr_page (scroll_selection_dir, scroll_selection_lines))
734	{	1102	{
735	selection_extend (selection_save_x, selection_save_y, selection_save_state);	1103	selection_extend (selection_save_x, selection_save_y, selection_save_state);
736	refresh_type |= SMOOTH_REFRESH;
737	want_refresh = 1;	1104	want_refresh = 1;
738	w.start (w.at + SCROLLBAR_CONTINUOUS_DELAY);	1105	refresh_check ();
739	}	1106	}
		1107	else
		1108	w.stop ();
740	}	1109	}
741	#endif	1110	#endif
742		1111
743	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)	1112	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
744	void	1113	void
745	rxvt_term::slip_wheel_cb (time_watcher &w)	1114	rxvt_term::slip_wheel_cb (ev::timer &w, int revents)
746	{	1115	{
747	if (mouse_slip_wheel_speed == 0	1116	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	{	1117	{
751	refresh_type |= SMOOTH_REFRESH;
752	want_refresh = 1;	1118	want_refresh = 1;
753	w.start (w.at + SCROLLBAR_CONTINUOUS_DELAY);	1119	refresh_check ();
		1120	}
		1121
		1122	if (view_start == top_row || view_start == 0 || mouse_slip_wheel_speed == 0)
754	}	1123	{
		1124	mouse_slip_wheel_speed = 0;
		1125	w.stop ();
		1126	}
755	}	1127	}
		1128	#endif
		1129
		1130	#if LINUX_YIELD_HACK
		1131	static struct event_handler
		1132	{
		1133	ev::prepare yield_ev;
		1134
		1135	void yield_cb (ev::prepare &w, int revents)
		1136	{
		1137	// this should really be sched_yield(), but the linux guys thought
		1138	// that giving a process calling sched_yield () less cpu time than
		1139	// ones with high nice levels is a useful thing to do. It surely is is
		1140	// allowed by the sus... as is returning ENOSYS.
		1141	// since the linux guys additionally thought that breaking the only
		1142	// known workaround against their unusable sched_yield hack is cool,
		1143	// we just nanosleep a bit and hope for the best.
		1144
		1145	struct timespec ts = { 0, 1000 };
		1146	nanosleep (&ts, 0);
		1147
		1148	w.stop ();
		1149	}
		1150
		1151	event_handler ()
		1152	: yield_ev (this, &event_handler::yield_cb)
		1153	{
		1154	}
		1155	} event_handler;
756	#endif	1156	#endif
757		1157
758	bool	1158	bool
759	rxvt_term::pty_fill ()	1159	rxvt_term::pty_fill ()
760	{	1160	{
761	ssize_t n = cmdbuf_endp - cmdbuf_ptr;	1161	ssize_t n = cmdbuf_endp - cmdbuf_ptr;
762		1162
763	if (CBUFSIZ == n)	1163	if (CBUFSIZ == n)
764	{	1164	{
765	rxvt_warn ("pty_fill on full buffer, draining input, continuing.\n");	1165	rxvt_warn ("PLEASE REPORT: pty_fill on full buffer, draining input, continuing.\n");
766	n = 0;	1166	n = 0;
767	}	1167	}
768		1168
769	memmove (cmdbuf_base, cmdbuf_ptr, n);	1169	memmove (cmdbuf_base, cmdbuf_ptr, n);
770	cmdbuf_ptr = cmdbuf_base;	1170	cmdbuf_ptr = cmdbuf_base;
771	cmdbuf_endp = cmdbuf_ptr + n;	1171	cmdbuf_endp = cmdbuf_ptr + n;
772		1172
773	n = read (cmd_fd, cmdbuf_endp, CBUFSIZ - n);	1173	ssize_t r = read (pty->pty, cmdbuf_endp, CBUFSIZ - n);
774		1174
775	if (n > 0)	1175	if (r > 0)
776	{	1176	{
777	cmdbuf_endp += n;	1177	cmdbuf_endp += r;
778	return true;	1178	return true;
779	}	1179	}
780	else if (n < 0 && errno != EAGAIN)	1180	else if (r < 0 && (errno == EAGAIN || errno == EINTR))
		1181	{
		1182	#if LINUX_YIELD_HACK
		1183	if (display->is_local)
		1184	event_handler.yield_ev.start ();
		1185	#endif
		1186	}
		1187	else
		1188	{
		1189	pty_ev.stop ();
		1190
		1191	if (!option (Opt_hold))
781	destroy ();	1192	destroy ();
782		1193	}
		1194
783	return false;	1195	return false;
784	}	1196	}
785		1197
786	void	1198	void
787	rxvt_term::pty_cb (io_watcher &w, short revents)	1199	rxvt_term::pty_cb (ev::io &w, int revents)
788	{	1200	{
789	SET_R (this);	1201	make_current ();
790	SET_LOCALE (locale);
791		1202
792	if (revents & EVENT_WRITE)	1203	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	1204	// loop, but don't allow a single term to monopolize us
796	while (pty_fill ())	1205	for (int i = CBUFCNT; i-- && pty_fill (); )
797	if (cmd_parse ())	1206	cmd_parse ();
798	break;	1207
		1208	if (revents & ev::WRITE)
		1209	pty_write ();
		1210
		1211	refresh_check ();
799	}	1212	}
800		1213
801	void	1214	void
802	rxvt_term::pointer_unblank ()	1215	rxvt_term::pointer_unblank ()
803	{	1216	{
804	XDefineCursor (display->display, TermWin.vt, TermWin_cursor);	1217	XDefineCursor (dpy, vt, TermWin_cursor);
805	recolour_cursor ();	1218	recolour_cursor ();
806		1219
807	#ifdef POINTER_BLANK	1220	#ifdef POINTER_BLANK
808	hidden_pointer = 0;	1221	hidden_pointer = 0;
809		1222
810	if (Options & Opt_pointerBlank)	1223	if (option (Opt_pointerBlank))
811	pointer_ev.start (NOW + pointerBlankDelay);	1224	pointer_ev.start (pointerBlankDelay);
812	#endif	1225	#endif
813	}	1226	}
814		1227
815	#ifdef POINTER_BLANK	1228	#ifdef POINTER_BLANK
816	void	1229	void
817	rxvt_term::pointer_blank ()	1230	rxvt_term::pointer_blank ()
818	{	1231	{
819	if (! (Options & Opt_pointerBlank))	1232	if (!option (Opt_pointerBlank))
820	return;	1233	return;
821		1234
822	XDefineCursor (display->display, TermWin.vt, blank_cursor);	1235	XDefineCursor (dpy, vt, display->blank_cursor);
823	XFlush (display->display);	1236	XFlush (dpy);
824		1237
825	hidden_pointer = 1;	1238	hidden_pointer = 1;
826	}	1239	}
827		1240
828	void	1241	void
829	rxvt_term::pointer_cb (time_watcher &w)	1242	rxvt_term::pointer_cb (ev::timer &w, int revents)
830	{	1243	{
831	SET_R (this);	1244	make_current ();
832	SET_LOCALE (locale);
833		1245
834	pointer_blank ();	1246	pointer_blank ();
835	}	1247	}
836	#endif	1248	#endif
837		1249
838	void	1250	void
839	rxvt_term::mouse_report (XButtonEvent &ev)	1251	rxvt_term::mouse_report (XButtonEvent &ev)
840	{	1252	{
841	int button_number, key_state = 0;	1253	int button_number, key_state = 0;
842	int x, y;	1254	int x, y;
		1255	int code = 32;
843		1256
844	x = ev.x;	1257	x = Pixel2Col (ev.x);
845	y = ev.y;	1258	y = Pixel2Row (ev.y);
846	pixel_position (&x, &y);	1259	if (ev.type == MotionNotify)
		1260	{
		1261	if (x == mouse_row && y == mouse_col)
		1262	return;
		1263	mouse_row = x;
		1264	mouse_col = y;
		1265	code += 32;
		1266	}
847		1267
848	if (MEvent.button == AnyButton)	1268	if (MEvent.button == AnyButton)
849	{
850	button_number = 3;	1269	button_number = 3;
851	}
852	else	1270	else
853	{	1271	{
854	button_number = MEvent.button - Button1;	1272	button_number = MEvent.button - Button1;
855	/* add 0x3D for wheel events, like xterm does */	1273	/* add 0x3D for wheel events, like xterm does */
856	if (button_number >= 3)	1274	if (button_number >= 3)
857	button_number += (64 - 3);	1275	button_number += (64 - 3);
858	}	1276	}
859		1277
860	if (PrivateModes & PrivMode_MouseX10)	1278	if (priv_modes & PrivMode_MouseX10)
861	{	1279	{
862	/*	1280	/*
863	* do not report ButtonRelease	1281	* do not report ButtonRelease
864	* no state info allowed	1282	* no state info allowed
865	*/	1283	*/
…		…
880	+ ((MEvent.state & ModMetaMask) ? 8 : 0)	1298	+ ((MEvent.state & ModMetaMask) ? 8 : 0)
881	+ ((MEvent.state & ControlMask) ? 16 : 0);	1299	+ ((MEvent.state & ControlMask) ? 16 : 0);
882	#ifdef MOUSE_REPORT_DOUBLECLICK	1300	#ifdef MOUSE_REPORT_DOUBLECLICK
883	key_state += ((MEvent.clicks > 1) ? 32 : 0);	1301	key_state += ((MEvent.clicks > 1) ? 32 : 0);
884	#endif	1302	#endif
885
886	}	1303	}
887		1304
888	#ifdef DEBUG_MOUSEREPORT	1305	#if DEBUG_MOUSEREPORT
889	fprintf (stderr, "Mouse [");	1306	fprintf (stderr, "Mouse [");
890	if (key_state & 16)	1307	if (key_state & 16)
891	fputc ('C', stderr);	1308	fputc ('C', stderr);
892	if (key_state & 4)	1309	if (key_state & 4)
893	fputc ('S', stderr);	1310	fputc ('S', stderr);
…		…
897	fputc ('2', stderr);	1314	fputc ('2', stderr);
898	fprintf (stderr, "]: <%d>, %d/%d\n",	1315	fprintf (stderr, "]: <%d>, %d/%d\n",
899	button_number,	1316	button_number,
900	x + 1,	1317	x + 1,
901	y + 1);	1318	y + 1);
902	#else	1319	#endif
		1320
903	tt_printf ("\033[M%c%c%c",	1321	tt_printf ("\033[M%c%c%c",
904	(32 + button_number + key_state),	1322	(code + button_number + key_state),
905	(32 + x + 1),	1323	(32 + x + 1),
906	(32 + y + 1));	1324	(32 + y + 1));
907	#endif
908	}	1325	}
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		1326
920	/*{{{ process an X event */	1327	/*{{{ process an X event */
921	void	1328	void
922	rxvt_term::x_cb (XEvent &ev)	1329	rxvt_term::x_cb (XEvent &ev)
923	{	1330	{
924	SET_R (this);	1331	make_current ();
925	SET_LOCALE (locale);
926		1332
927	#if defined(CURSOR_BLINK)	1333	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		1334
936	cursor_blink_ev.start (NOW + BLINK_INTERVAL);	1335	if (ev.xany.window == vt
937	}	1336	&& SHOULD_INVOKE (HOOK_X_EVENT)
938	#endif	1337	&& 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;	1338	return;
957	#endif
958		1339
		1340	// for XQueryPointer
959	Window unused_root, unused_child;	1341	Window unused_root, unused_child;
960	int unused_root_x, unused_root_y;	1342	int unused_root_x, unused_root_y;
961	unsigned int unused_mask;	1343	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		1344
1012	switch (ev.type)	1345	switch (ev.type)
1013	{	1346	{
1014	case KeyPress:	1347	case KeyPress:
1015	lookup_key (ev.xkey);	1348	key_press (ev.xkey);
1016	break;	1349	break;
1017		1350
1018	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
1019	case KeyRelease:	1351	case KeyRelease:
1020	{	1352	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;	1353	break;
1032	}
1033	#endif
1034		1354
1035	case ButtonPress:	1355	case ButtonPress:
1036	button_press (ev.xbutton);	1356	button_press (ev.xbutton);
1037	break;	1357	break;
1038		1358
…		…
1040	button_release (ev.xbutton);	1360	button_release (ev.xbutton);
1041	break;	1361	break;
1042		1362
1043	case ClientMessage:	1363	case ClientMessage:
1044	if (ev.xclient.format == 32	1364	if (ev.xclient.format == 32
1045	&& (Atom)ev.xclient.data.l[0] == xa[XA_WMDELETEWINDOW])	1365	&& !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	{	1366	{
1054	/* Get Dnd data */	1367	if (ev.xclient.message_type == xa[XA_WM_PROTOCOLS])
1055	Atom ActualType;	1368	{
1056	int ActualFormat;	1369	if (!HOOK_INVOKE ((this, HOOK_WM_PROTOCOLS, DT_XEVENT, &ev, DT_END)))
1057	unsigned char *data;	1370	{
1058	unsigned long Size, RemainingBytes;	1371	if (ev.xclient.data.l[0] == xa[XA_WM_DELETE_WINDOW])
1059		1372	{
1060	XGetWindowProperty (display->display, display->root,	1373	if (!HOOK_INVOKE ((this, HOOK_WM_DELETE_WINDOW, DT_XEVENT, &ev, DT_END)))
1061	xa[XA_DNDSELECTION],	1374	destroy ();
1062	0L, 1000000L,	1375	}
1063	False, AnyPropertyType,	1376	#if ENABLE_EWMH
1064	&ActualType, &ActualFormat,	1377	else if (ev.xclient.data.l[0] == xa[XA_NET_WM_PING])
1065	&Size, &RemainingBytes,	1378	XSendEvent (dpy, ev.xclient.window = display->root,
		1379	False, SubstructureRedirectMask | SubstructureNotifyMask,
1066	&data);	1380	&ev);
1067	XChangeProperty (display->display, display->root,	1381	#endif
1068	XA_CUT_BUFFER0, XA_STRING,	1382	}
1069	8, PropModeReplace,	1383	}
1070	data, STRLEN (data));	1384	#if ENABLE_XEMBED
1071	XFree (data);	1385	else if (ev.xclient.format == 32 && ev.xclient.message_type == xa[XA_XEMBED])
1072	selection_paste (display->root, XA_CUT_BUFFER0, True);	1386	{
1073	XSetInputFocus (display->display, display->root, RevertToNone, CurrentTime);	1387	if (ev.xclient.data.l[1] == XEMBED_FOCUS_IN)
		1388	focus_in ();
		1389	else if (ev.xclient.data.l[1] == XEMBED_FOCUS_OUT)
		1390	focus_out ();
		1391	}
		1392	#endif
1074	}	1393	}
1075	#endif /* OFFIX_DND */
1076	break;
1077
1078	case MappingNotify:
1079	XRefreshKeyboardMapping (& (ev.xmapping));
1080	break;	1394	break;
1081		1395
1082	/*	1396	/*
1083	* XXX: this is not the _current_ arrangement	1397	* XXX: this is not the _current_ arrangement
1084	* Here's my conclusion:	1398	* Here's my conclusion:
…		…
1103	break;	1417	break;
1104	}	1418	}
1105	break;	1419	break;
1106		1420
1107	case FocusIn:	1421	case FocusIn:
1108	if (!TermWin.focus)	1422	if (ev.xfocus.detail != NotifyInferior
		1423	&& ev.xfocus.detail != NotifyPointer
		1424	&& ev.xfocus.mode != NotifyGrab)
		1425	focus_in ();
		1426	break;
		1427
		1428	case FocusOut:
		1429	if (ev.xfocus.detail != NotifyInferior
		1430	&& ev.xfocus.detail != NotifyPointer
		1431	&& ev.xfocus.mode != NotifyGrab)
		1432	focus_out ();
		1433	break;
		1434
		1435	case ConfigureNotify:
		1436	if (ev.xconfigure.window == parent[0])
1109	{	1437	{
1110	TermWin.focus = 1;	1438	while (XCheckTypedWindowEvent (dpy, ev.xconfigure.window, ConfigureNotify, &ev))
1111	want_refresh = 1;	1439	;
1112	#ifdef USE_XIM	1440
1113	if (Input_Context != NULL)	1441	#ifdef HAVE_BG_PIXMAP
1114	XSetICFocus (Input_Context);	1442	bool moved = false;
1115	#endif	1443	if (bgPixmap.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	{	1444	{
1123	PixColors = PixColorsFocused;	1445	int x, y;
1124	set_colorfgbg ();	1446	if (ev.xconfigure.send_event)
1125	scr_clear ();	1447	{
1126	scr_touch (true);	1448	x = ev.xconfigure.x;
		1449	y = ev.xconfigure.y;
		1450	}
		1451	else
		1452	get_window_origin (x, y);
		1453
		1454	if (bgPixmap.set_position (x, y)
		1455	|| (bgPixmap.flags & bgPixmap_t::isInvalid))
		1456	moved = true;
1127	}	1457	}
1128	#endif	1458	#endif
1129		1459
1130	}	1460	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	{	1461	{
1150	PixColors = PixColorsUnFocused;	1462	seen_resize = 1;
1151	set_colorfgbg ();	1463	resize_all_windows (ev.xconfigure.width, ev.xconfigure.height, 1);
1152	scr_clear ();
1153	scr_touch (true);
1154	}	1464	}
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	1465	else
1180	{	1466	{
1181	D_SIZE ((stderr, "Size: Not resizing"));	1467	#ifdef HAVE_BG_PIXMAP
		1468	if (moved)
		1469	{
		1470	if (mapped)
		1471	update_background ();
		1472	else
		1473	bgPixmap.invalidate ();
		1474	}
		1475	#endif
1182	}	1476	}
1183	#endif	1477
1184	#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */	1478	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	}	1479	}
1193	break;	1480	break;
1194		1481
		1482	case PropertyNotify:
		1483	if (!HOOK_INVOKE ((this, HOOK_PROPERTY_NOTIFY, DT_XEVENT, &ev, DT_END)))
		1484	if (ev.xproperty.atom == xa[XA_VT_SELECTION]
		1485	&& ev.xproperty.state == PropertyNewValue)
		1486	selection_property (ev.xproperty.window, ev.xproperty.atom);
		1487
		1488	break;
		1489
1195	case SelectionClear:	1490	case SelectionClear:
1196	selection_clear ();	1491	selection_clear (ev.xselectionclear.selection == xa[XA_CLIPBOARD]);
1197	break;	1492	break;
1198		1493
1199	case SelectionNotify:	1494	case SelectionNotify:
1200	if (selection_wait == Sel_normal)	1495	if (selection_wait == Sel_normal)
1201	selection_paste (ev.xselection.requestor,	1496	selection_paste (ev.xselection.requestor, ev.xselection.property, true);
1202	ev.xselection.property, True);
1203	break;	1497	break;
1204		1498
1205	case SelectionRequest:	1499	case SelectionRequest:
1206	selection_send (ev.xselectionrequest);	1500	selection_send (ev.xselectionrequest);
1207	break;	1501	break;
1208		1502
		1503	case MapNotify:
		1504	#ifdef HAVE_BG_PIXMAP
		1505	/* This is needed specifically to fix the case of no window manager or a
		1506	* non-reparenting window manager. In those cases we never get first
		1507	* ConfigureNotify. Also that speeds startup under normal WM, by taking
		1508	* care of multiplicity of ConfigureNotify events arriving while WM does
		1509	* reparenting.
		1510	* We should not render background immediately, as there could be several
		1511	* ConfigureNotify's to follow. Lets take care of all of them in one scoop
		1512	* by scheduling background redraw as soon as we can, but giving a short
		1513	* bit of time for ConfigureNotifies to arrive.
		1514	* We should render background PRIOR to drawing any text, but AFTER all
		1515	* of ConfigureNotifys for the best results.
		1516	*/
		1517	if (bgPixmap.flags & bgPixmap_t::isInvalid)
		1518	update_background_ev.start (0.025);
		1519	#endif
		1520	mapped = 1;
		1521	#ifdef TEXT_BLINK
		1522	text_blink_ev.start ();
		1523	#endif
		1524	HOOK_INVOKE ((this, HOOK_MAP_NOTIFY, DT_XEVENT, &ev, DT_END));
		1525	break;
		1526
1209	case UnmapNotify:	1527	case UnmapNotify:
1210	TermWin.mapped = 0;	1528	mapped = 0;
1211	#ifdef TEXT_BLINK	1529	#ifdef TEXT_BLINK
1212	text_blink_ev.stop ();	1530	text_blink_ev.stop ();
1213	#endif	1531	#endif
		1532	HOOK_INVOKE ((this, HOOK_UNMAP_NOTIFY, DT_XEVENT, &ev, DT_END));
1214	break;	1533	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		1534
1229	case GraphicsExpose:	1535	case GraphicsExpose:
1230	case Expose:	1536	case Expose:
1231	if (ev.xany.window == TermWin.vt)	1537	if (ev.xany.window == vt)
1232	{	1538	{
1233	#ifdef NO_SLOW_LINK_SUPPORT	1539	do
		1540	{
1234	scr_expose (ev.xexpose.x, ev.xexpose.y,	1541	scr_expose (ev.xexpose.x, ev.xexpose.y,
1235	ev.xexpose.width, ev.xexpose.height, False);	1542	ev.xexpose.width, ev.xexpose.height, False);
1236	#else	1543	}
1237	// I don't understand this, so I changed it :)	1544	while (XCheckTypedWindowEvent (dpy, vt, ev.xany.type, &ev));
		1545
		1546	ev.xany.type = ev.xany.type == Expose ? GraphicsExpose : Expose;
		1547
		1548	while (XCheckTypedWindowEvent (dpy, vt, ev.xany.type, &ev))
		1549	{
1238	scr_expose (ev.xexpose.x, ev.xexpose.y,	1550	scr_expose (ev.xexpose.x, ev.xexpose.y,
1239	ev.xexpose.width, ev.xexpose.height, False);	1551	ev.xexpose.width, ev.xexpose.height, False);
1240	//scr_expose (ev.xexpose.x, 0,	1552	}
1241	// ev.xexpose.width, TermWin.height, False);	1553
1242	#endif
1243	want_refresh = 1;	1554	want_refresh = 1;
1244	}	1555	}
1245	else	1556	else
1246	{	1557	{
1247	XEvent unused_event;	1558	XEvent unused_event;
1248		1559
1249	while (XCheckTypedWindowEvent (display->display, ev.xany.window, Expose, &unused_event))	1560	while (XCheckTypedWindowEvent (dpy, ev.xany.window, Expose, &unused_event))
1250	;	1561	;
1251	while (XCheckTypedWindowEvent (display->display, ev.xany.window, GraphicsExpose, &unused_event))	1562	while (XCheckTypedWindowEvent (dpy, ev.xany.window, GraphicsExpose, &unused_event))
1252	;	1563	;
1253		1564
1254	if (isScrollbarWindow (ev.xany.window))	1565	if (scrollBar.state && ev.xany.window == scrollBar.win)
1255	{	1566	{
1256	scrollBar.setIdle ();	1567	scrollBar.state = STATE_IDLE;
1257	scrollbar_show (0);	1568	scrollBar.show (0);
1258	}	1569	}
1259	#ifdef MENUBAR
1260	if (menubar_visible () && isMenuBarWindow (ev.xany.window))
1261	menubar_expose ();
1262	#endif
1263	}	1570	}
1264	break;	1571	break;
1265		1572
1266	case MotionNotify:	1573	case MotionNotify:
1267	#ifdef POINTER_BLANK	1574	#ifdef POINTER_BLANK
1268	if (hidden_pointer)	1575	if (hidden_pointer)
1269	pointer_unblank ();	1576	pointer_unblank ();
1270	#endif	1577	#endif
1271	#if MENUBAR	1578	if ((priv_modes & PrivMode_MouseBtnEvent && ev.xbutton.state & (Button1Mask|Button2Mask|Button3Mask))
1272	if (isMenuBarWindow (ev.xany.window))	1579	|| priv_modes & PrivMode_MouseAnyEvent)
		1580	mouse_report (ev.xbutton);
		1581	if ((priv_modes & PrivMode_mouse_report) && !bypass_keystate)
		1582	break;
		1583
		1584	if (ev.xany.window == vt)
1273	{	1585	{
1274	menubar_control (ev.xbutton);	1586	if (SHOULD_INVOKE (HOOK_MOTION_NOTIFY)
1275	break;	1587	&& HOOK_INVOKE ((this, HOOK_MOTION_NOTIFY, DT_XEVENT, &ev, DT_END)))
1276	}	1588	; // 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)))	1589	else if (ev.xbutton.state & (Button1Mask | Button3Mask))
1284	{	1590	{
1285	while (XCheckTypedWindowEvent (display->display, TermWin.vt, MotionNotify, &ev))	1591	while (XCheckTypedWindowEvent (dpy, vt, MotionNotify, &ev))
1286	;	1592	;
1287		1593
1288	XQueryPointer (display->display, TermWin.vt,	1594	XQueryPointer (dpy, vt,
1289	&unused_root, &unused_child,	1595	&unused_root, &unused_child,
1290	&unused_root_x, &unused_root_y,	1596	&unused_root_x, &unused_root_y,
1291	& (ev.xbutton.x), & (ev.xbutton.y),	1597	&ev.xbutton.x, &ev.xbutton.y,
1292	&unused_mask);	1598	&ev.xbutton.state);
1293	#ifdef MOUSE_THRESHOLD	1599	#ifdef MOUSE_THRESHOLD
1294	/* deal with a `jumpy' mouse */	1600	/* deal with a `jumpy' mouse */
1295	if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)	1601	if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)
1296	{	1602	{
1297	#endif	1603	#endif
		1604	#if ISO_14755
		1605	// 5.4
		1606	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
		1607	{
		1608	iso14755_54 (ev.xbutton.x, ev.xbutton.y);
		1609	break;
		1610	}
		1611	#endif
1298	selection_extend ((ev.xbutton.x), (ev.xbutton.y),	1612	selection_extend (ev.xbutton.x, ev.xbutton.y,
1299	(ev.xbutton.state & Button3Mask) ? 2 : 0);	1613	ev.xbutton.state & Button3Mask ? 2 : 0);
		1614
1300	#ifdef SELECTION_SCROLLING	1615	#ifdef SELECTION_SCROLLING
1301	if (ev.xbutton.y < TermWin.int_bwidth	1616	if (ev.xbutton.y < int_bwidth
1302	|| Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))	1617	|| Pixel2Row (ev.xbutton.y) > (nrow-1))
1303	{	1618	{
1304	int dist;	1619	int dist;
1305		1620
1306	/* don't clobber the current delay if we are	1621	/* don't clobber the current delay if we are
1307	* already in the middle of scrolling.	1622	* already in the middle of scrolling.
1308	*/	1623	*/
1309	if (!sel_scroll_ev.active)	1624	if (!sel_scroll_ev.is_active ())
1310	sel_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);	1625	sel_scroll_ev.start (SCROLLBAR_INITIAL_DELAY, SCROLLBAR_CONTINUOUS_DELAY);
1311		1626
1312	/* save the event params so we can highlight	1627	/* save the event params so we can highlight
1313	* the selection in the pending-scroll loop	1628	* the selection in the pending-scroll loop
1314	*/	1629	*/
1315	selection_save_x=ev.xbutton.x;	1630	selection_save_x = ev.xbutton.x;
1316	selection_save_y=ev.xbutton.y;	1631	selection_save_y = ev.xbutton.y;
1317	selection_save_state=
1318	(ev.xbutton.state & Button3Mask) ? 2 : 0;	1632	selection_save_state = (ev.xbutton.state & Button3Mask) ? 2 : 0;
1319		1633
1320	/* calc number of lines to scroll */	1634	/* calc number of lines to scroll */
1321	if (ev.xbutton.y<TermWin.int_bwidth)	1635	if (ev.xbutton.y < int_bwidth)
1322	{	1636	{
1323	scroll_selection_dir = UP;	1637	scroll_selection_dir = UP;
1324	dist = TermWin.int_bwidth - ev.xbutton.y;	1638	dist = int_bwidth - ev.xbutton.y;
1325	}	1639	}
1326	else	1640	else
1327	{	1641	{
1328	scroll_selection_dir = DN;	1642	scroll_selection_dir = DN;
1329	dist = ev.xbutton.y -	1643	dist = ev.xbutton.y - (int_bwidth + height);
1330	(TermWin.int_bwidth + TermWin.height);
1331	}	1644	}
		1645
1332	scroll_selection_lines= (Pixel2Height (dist)/	1646	scroll_selection_lines = Pixel2Height (dist)
1333	SELECTION_SCROLL_LINE_SPEEDUP)+1;	1647	/ SELECTION_SCROLL_LINE_SPEEDUP
		1648	+ 1;
1334	MIN_IT (scroll_selection_lines,	1649	min_it (scroll_selection_lines,
1335	SELECTION_SCROLL_MAX_LINES);	1650	SELECTION_SCROLL_MAX_LINES);
1336	}	1651	}
1337	else	1652	else
1338	{	1653	{
1339	/* we are within the text window, so we	1654	/* we are within the text window, so we
1340	* shouldn't be scrolling	1655	* shouldn't be scrolling
1341	*/	1656	*/
1342	if (sel_scroll_ev.active)
1343	sel_scroll_ev.stop();	1657	sel_scroll_ev.stop();
1344	}	1658	}
1345	#endif	1659	#endif
1346	#ifdef MOUSE_THRESHOLD	1660	#ifdef MOUSE_THRESHOLD
1347
1348	}	1661	}
1349	#endif	1662	#endif
1350
1351	}	1663	}
1352	}	1664	}
1353	else if (isScrollbarWindow (ev.xany.window) && scrollbar_isMotion ())	1665	else if (scrollBar.state == STATE_MOTION && ev.xany.window == scrollBar.win)
1354	{	1666	{
1355	while (XCheckTypedWindowEvent (display->display, scrollBar.win,	1667	while (XCheckTypedWindowEvent (dpy, scrollBar.win,
1356	MotionNotify, &ev)) ;	1668	MotionNotify, &ev))
		1669	;
		1670
1357	XQueryPointer (display->display, scrollBar.win,	1671	XQueryPointer (dpy, scrollBar.win,
1358	&unused_root, &unused_child,	1672	&unused_root, &unused_child,
1359	&unused_root_x, &unused_root_y,	1673	&unused_root_x, &unused_root_y,
1360	& (ev.xbutton.x), & (ev.xbutton.y),	1674	&ev.xbutton.x, &ev.xbutton.y,
1361	&unused_mask);	1675	&unused_mask);
1362	scr_move_to (scrollbar_position (ev.xbutton.y) - csrO,	1676	scr_move_to (scrollbar_position (ev.xbutton.y) - csrO,
1363	scrollbar_size ());	1677	scrollBar.size ());
1364	scr_refresh (refresh_type);
1365	refresh_limit = 0;	1678	want_refresh = 1;
1366	scrollbar_show (1);	1679	scrollBar.show (1);
1367	}	1680	}
1368	break;	1681	break;
1369	}	1682	}
1370	}
1371		1683
		1684	#if defined(CURSOR_BLINK)
		1685	if (option (Opt_cursorBlink) && ev.type == KeyPress)
		1686	{
		1687	if (hidden_cursor)
		1688	{
		1689	hidden_cursor = 0;
		1690	want_refresh = 1;
		1691	}
		1692
		1693	cursor_blink_ev.again ();
		1694	}
		1695	#endif
		1696
		1697	#if defined(POINTER_BLANK)
		1698	if (option (Opt_pointerBlank) && pointerBlankDelay > 0)
		1699	{
		1700	if (ev.type == MotionNotify
		1701	|| ev.type == ButtonPress
		1702	|| ev.type == ButtonRelease)
		1703	if (hidden_pointer)
		1704	pointer_unblank ();
		1705
		1706	if (ev.type == KeyPress && hidden_pointer == 0)
		1707	pointer_blank ();
		1708	}
		1709	#endif
		1710
		1711	refresh_check ();
		1712	}
		1713
		1714	#if ENABLE_FRILLS
		1715	void
		1716	rxvt_term::set_urgency (bool enable)
		1717	{
		1718	if (enable == urgency_hint)
		1719	return;
		1720
		1721	if (XWMHints *h = XGetWMHints (dpy, parent[0]))
		1722	{
		1723	h->flags = h->flags & ~XUrgencyHint | (enable ? XUrgencyHint : 0);
		1724	XSetWMHints (dpy, parent[0], h);
		1725	urgency_hint = enable;
		1726	}
		1727	}
		1728	#endif
		1729
		1730	void
		1731	rxvt_term::focus_in ()
		1732	{
		1733	if (!focus)
		1734	{
		1735	focus = 1;
		1736	want_refresh = 1;
		1737
		1738	#if USE_XIM
		1739	if (Input_Context != NULL)
		1740	{
		1741	IMSetPosition ();
		1742	XSetICFocus (Input_Context);
		1743	}
		1744	#endif
		1745	#if CURSOR_BLINK
		1746	if (option (Opt_cursorBlink))
		1747	cursor_blink_ev.again ();
		1748	#endif
		1749	#if OFF_FOCUS_FADING
		1750	if (rs[Rs_fade])
		1751	{
		1752	pix_colors = pix_colors_focused;
		1753	scr_recolour ();
		1754	}
		1755	#endif
		1756	#if ENABLE_FRILLS
		1757	if (option (Opt_urgentOnBell))
		1758	set_urgency (0);
		1759	#endif
		1760
		1761	HOOK_INVOKE ((this, HOOK_FOCUS_IN, DT_END));
		1762	}
		1763	}
		1764
		1765	void
		1766	rxvt_term::focus_out ()
		1767	{
		1768	if (focus)
		1769	{
		1770	focus = 0;
		1771	want_refresh = 1;
		1772
		1773	#if ENABLE_FRILLS
		1774	if (option (Opt_urgentOnBell))
		1775	set_urgency (0);
		1776	#endif
		1777	#if ENABLE_FRILLS || ISO_14755
		1778	if (iso14755buf)
		1779	{
		1780	iso14755buf = 0;
		1781	# if ISO_14755
		1782	scr_overlay_off ();
		1783	# endif
		1784	}
		1785	#endif
		1786	#if USE_XIM
		1787	if (Input_Context != NULL)
		1788	XUnsetICFocus (Input_Context);
		1789	#endif
		1790	#if CURSOR_BLINK
		1791	if (option (Opt_cursorBlink))
		1792	cursor_blink_ev.stop ();
		1793
		1794	hidden_cursor = 0;
		1795	#endif
		1796	#if OFF_FOCUS_FADING
		1797	if (rs[Rs_fade])
		1798	{
		1799	pix_colors = pix_colors_unfocused;
		1800	scr_recolour ();
		1801	}
		1802	#endif
		1803
		1804	HOOK_INVOKE ((this, HOOK_FOCUS_OUT, DT_END));
		1805	}
		1806	}
		1807
		1808	void
		1809	rxvt_term::update_fade_color (unsigned int idx)
		1810	{
		1811	#if OFF_FOCUS_FADING
		1812	if (rs[Rs_fade])
		1813	{
		1814	rgba c;
		1815	pix_colors [Color_fade].get (c);
		1816	pix_colors_focused [idx].fade (this, atoi (rs[Rs_fade]), pix_colors_unfocused [idx], c);
		1817	}
		1818	#endif
		1819	}
		1820
		1821	#if ENABLE_TRANSPARENCY || ENABLE_PERL
1372	void	1822	void
1373	rxvt_term::rootwin_cb (XEvent &ev)	1823	rxvt_term::rootwin_cb (XEvent &ev)
1374	{	1824	{
1375	SET_R (this);	1825	make_current ();
1376	SET_LOCALE (locale);
1377		1826
		1827	if (SHOULD_INVOKE (HOOK_ROOT_EVENT)
		1828	&& HOOK_INVOKE ((this, HOOK_ROOT_EVENT, DT_XEVENT, &ev, DT_END)))
		1829	return;
		1830
		1831	# if ENABLE_TRANSPARENCY
1378	switch (ev.type)	1832	switch (ev.type)
1379	{	1833	{
1380	case PropertyNotify:	1834	case PropertyNotify:
		1835	/*
		1836	* if user used some Esetroot compatible prog to set the root bg,
		1837	* use the property to determine the pixmap. We use it later on.
		1838	*/
1381	if (ev.xproperty.atom == xa[XA_VT_SELECTION])	1839	if (ev.xproperty.atom == xa[XA_XROOTPMAP_ID]
		1840	|| ev.xproperty.atom == xa[XA_ESETROOT_PMAP_ID])
1382	{	1841	{
1383	if (ev.xproperty.state == PropertyNewValue)	1842	bgPixmap.set_root_pixmap ();
1384	selection_property (ev.xproperty.window, ev.xproperty.atom);	1843	update_background ();
1385	break;
1386	}	1844	}
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		1845
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;	1846	break;
		1847	}
1406	#endif	1848	# endif
1407	}	1849
		1850	refresh_check ();
1408	}	1851	}
		1852	#endif
1409		1853
1410	void	1854	void
1411	rxvt_term::button_press (XButtonEvent &ev)	1855	rxvt_term::button_press (XButtonEvent &ev)
1412	{	1856	{
1413	int reportmode = 0, clickintime;	1857	int reportmode = 0, clickintime;
1414		1858
1415	bypass_keystate = ev.state & (ModMetaMask | ShiftMask);	1859	bypass_keystate = ev.state & (ModMetaMask | ShiftMask);
		1860
1416	if (!bypass_keystate)	1861	if (!bypass_keystate)
1417	reportmode = !! (PrivateModes & PrivMode_mouse_report);	1862	reportmode = !! (priv_modes & PrivMode_mouse_report);
		1863
1418	/*	1864	/*
1419	* VT window processing of button press	1865	* VT window processing of button press
1420	*/	1866	*/
1421	if (ev.window == TermWin.vt)	1867	if (ev.window == vt)
1422	{	1868	{
		1869	if (HOOK_INVOKE ((this, HOOK_BUTTON_PRESS, DT_XEVENT, &ev, DT_END)))
		1870	return;
		1871
		1872	#if ISO_14755
		1873	// 5.4
		1874	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
		1875	{
		1876	iso14755_54 (ev.x, ev.y);
		1877	return;
		1878	}
		1879	#endif
		1880
1423	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;	1881	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;
		1882
1424	if (reportmode)	1883	if (reportmode)
1425	{	1884	{
1426	/* mouse report from vt window */	1885	/* mouse report from vt window */
1427	/* save the xbutton state (for ButtonRelease) */	1886	/* save the xbutton state (for ButtonRelease) */
1428	MEvent.state = ev.state;	1887	MEvent.state = ev.state;
1429	#ifdef MOUSE_REPORT_DOUBLECLICK	1888	#ifdef MOUSE_REPORT_DOUBLECLICK
1430	if (ev.button == MEvent.button && clickintime)	1889	if (ev.button == MEvent.button && clickintime)
1431	{	1890	{
1432	/* same button, within alloted time */	1891	/* same button, within allowed time */
1433	MEvent.clicks++;	1892	MEvent.clicks++;
		1893
1434	if (MEvent.clicks > 1)	1894	if (MEvent.clicks > 1)
1435	{	1895	{
1436	/* only report double clicks */	1896	/* only report double clicks */
1437	MEvent.clicks = 2;	1897	MEvent.clicks = 2;
1438	mouse_report (ev);	1898	mouse_report (ev);
…		…
1450	mouse_report (ev);	1910	mouse_report (ev);
1451	}	1911	}
1452	#else	1912	#else
1453	MEvent.button = ev.button;	1913	MEvent.button = ev.button;
1454	mouse_report (ev);	1914	mouse_report (ev);
1455	#endif /* MOUSE_REPORT_DOUBLECLICK */	1915	#endif /* MOUSE_REPORT_DOUBLECLICK */
1456		1916
1457	}	1917	}
1458	else	1918	else
1459	{	1919	{
1460	if (ev.button != MEvent.button)	1920	if (ev.button != MEvent.button)
1461	MEvent.clicks = 0;	1921	MEvent.clicks = 0;
		1922
1462	switch (ev.button)	1923	switch (ev.button)
1463	{	1924	{
1464	case Button1:	1925	case Button1:
		1926	/* allow meta + click to select rectangular areas */
		1927	/* should be done in screen.C */
		1928	#if ENABLE_FRILLS
		1929	selection.rect = !!(ev.state & ModMetaMask);
		1930	#else
		1931	selection.rect = false;
		1932	#endif
		1933
1465	/* allow shift+left click to extend selection */	1934	/* allow shift+left click to extend selection */
1466	if (ev.state & ShiftMask && ! (PrivateModes & PrivMode_mouse_report))	1935	if (ev.state & ShiftMask && !(priv_modes & PrivMode_mouse_report))
1467	{	1936	{
1468	if (MEvent.button == Button1 && clickintime)	1937	if (MEvent.button == Button1 && clickintime)
1469	selection_rotate (ev.x, ev.y);	1938	selection_rotate (ev.x, ev.y);
1470	else	1939	else
1471	selection_extend (ev.x, ev.y, 1);	1940	selection_extend (ev.x, ev.y, 1);
…		…
1486	case Button3:	1955	case Button3:
1487	if (MEvent.button == Button3 && clickintime)	1956	if (MEvent.button == Button3 && clickintime)
1488	selection_rotate (ev.x, ev.y);	1957	selection_rotate (ev.x, ev.y);
1489	else	1958	else
1490	selection_extend (ev.x, ev.y, 1);	1959	selection_extend (ev.x, ev.y, 1);
		1960
1491	MEvent.button = Button3;	1961	MEvent.button = Button3;
1492	break;	1962	break;
1493	}	1963	}
1494	}	1964	}
		1965
1495	MEvent.time = ev.time;	1966	MEvent.time = ev.time;
1496	return;	1967	return;
1497	}	1968	}
1498		1969
1499	/*	1970	/*
1500	* Scrollbar window processing of button press	1971	* Scrollbar window processing of button press
1501	*/	1972	*/
1502	if (isScrollbarWindow (ev.window))	1973	if (scrollBar.state && ev.window == scrollBar.win)
1503	{	1974	{
1504	scrollBar.setIdle ();	1975	page_dirn direction = NO_DIR;
		1976
		1977	if (scrollBar.upButton (ev.y))
		1978	direction = UP; /* up */
		1979	else if (scrollBar.dnButton (ev.y))
		1980	direction = DN; /* down */
		1981
		1982	scrollBar.state = STATE_IDLE;
1505	/*	1983	/*
1506	* Rxvt-style scrollbar:	1984	* Rxvt-style scrollbar:
1507	* move up if mouse is above slider	1985	* move up if mouse is above slider
1508	* move dn if mouse is below slider	1986	* move dn if mouse is below slider
1509	*	1987	*
…		…
1518	/*	1996	/*
1519	* Mouse report disabled scrollbar:	1997	* Mouse report disabled scrollbar:
1520	* arrow buttons - send up/down	1998	* arrow buttons - send up/down
1521	* click on scrollbar - send pageup/down	1999	* click on scrollbar - send pageup/down
1522	*/	2000	*/
1523	if ((scrollBar.style == R_SB_NEXT	2001	if (direction == UP)
1524	&& scrollbarnext_upButton (ev.y))
1525	|| (scrollBar.style == R_SB_RXVT
1526	&& scrollbarrxvt_upButton (ev.y)))
1527	tt_printf ("\033[A");	2002	tt_printf ("\033[A");
1528	else if ((scrollBar.style == R_SB_NEXT	2003	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");	2004	tt_printf ("\033[B");
1533	else	2005	else
1534	switch (ev.button)	2006	switch (ev.button)
1535	{	2007	{
1536	case Button2:	2008	case Button2:
…		…
1543	tt_printf ("\033[5~");	2015	tt_printf ("\033[5~");
1544	break;	2016	break;
1545	}	2017	}
1546	}	2018	}
1547	else	2019	else
1548	#endif /* NO_SCROLLBAR_REPORT */	2020	#endif /* NO_SCROLLBAR_REPORT */
1549
1550	{
1551	char upordown = 0;
1552
1553	if (scrollBar.style == R_SB_NEXT)
1554	{	2021	{
1555	if (scrollbarnext_upButton (ev.y))	2022	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	{	2023	{
1569	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING	2024	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
		2025	if (!cont_scroll_ev.is_active ())
1570	cont_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);	2026	cont_scroll_ev.start (SCROLLBAR_INITIAL_DELAY, SCROLLBAR_CONTINUOUS_DELAY);
1571	#endif	2027	#endif
1572	if (scr_page (upordown < 0 ? UP : DN, 1))	2028	if (scr_page (direction, 1))
1573	{	2029	{
1574	if (upordown < 0)	2030	if (direction == UP)
1575	scrollBar.setUp ();	2031	scrollBar.state = STATE_UP;
1576	else	2032	else
1577	scrollBar.setDn ();	2033	scrollBar.state = STATE_DOWN;
1578	}	2034	}
1579	}	2035	}
1580	else	2036	else
1581	switch (ev.button)	2037	switch (ev.button)
1582	{	2038	{
1583	case Button2:	2039	case Button2:
1584	switch (scrollbar_align)	2040	switch (scrollBar.align)
1585	{	2041	{
1586	case R_SB_ALIGN_TOP:	2042	case R_SB_ALIGN_TOP:
1587	csrO = 0;	2043	csrO = 0;
1588	break;	2044	break;
1589	case R_SB_ALIGN_CENTRE:	2045	case R_SB_ALIGN_CENTRE:
…		…
1591	break;	2047	break;
1592	case R_SB_ALIGN_BOTTOM:	2048	case R_SB_ALIGN_BOTTOM:
1593	csrO = scrollBar.bot - scrollBar.top;	2049	csrO = scrollBar.bot - scrollBar.top;
1594	break;	2050	break;
1595	}	2051	}
		2052
1596	if (scrollBar.style == R_SB_XTERM	2053	if (scrollBar.style == R_SB_XTERM
1597	|| scrollbar_above_slider (ev.y)	2054	|| scrollbar_above_slider (ev.y)
1598	|| scrollbar_below_slider (ev.y))	2055	|| scrollbar_below_slider (ev.y))
1599	scr_move_to ( scrollbar_position (ev.y) - csrO,	2056	scr_move_to (scrollbar_position (ev.y) - csrO, scrollBar.size ());
1600	scrollbar_size ());	2057
1601	scrollBar.setMotion ();	2058	scrollBar.state = STATE_MOTION;
1602	break;	2059	break;
1603		2060
1604	case Button1:	2061	case Button1:
1605	if (scrollbar_align == R_SB_ALIGN_CENTRE)	2062	if (scrollBar.align == R_SB_ALIGN_CENTRE)
1606	csrO = ev.y - scrollBar.top;	2063	csrO = ev.y - scrollBar.top;
1607	/* FALLTHROUGH */	2064	/* FALLTHROUGH */
1608		2065
1609	case Button3:	2066	case Button3:
1610	if (scrollBar.style != R_SB_XTERM)	2067	if (scrollBar.style != R_SB_XTERM)
1611	{	2068	{
1612	if (scrollbar_above_slider (ev.y))	2069	if (scrollbar_above_slider (ev.y))
1613	# ifdef RXVT_SCROLL_FULL	2070	# ifdef RXVT_SCROLL_FULL
1614	scr_page (UP, TermWin.nrow - 1);	2071	scr_page (UP, nrow - 1);
1615	# else	2072	# else
1616	scr_page (UP, TermWin.nrow / 4);	2073	scr_page (UP, nrow / 4);
1617	# endif	2074	# endif
1618	else if (scrollbar_below_slider (ev.y))	2075	else if (scrollbar_below_slider (ev.y))
1619	# ifdef RXVT_SCROLL_FULL	2076	# ifdef RXVT_SCROLL_FULL
1620	scr_page (DN, TermWin.nrow - 1);	2077	scr_page (DN, nrow - 1);
1621	# else	2078	# else
1622	scr_page (DN, TermWin.nrow / 4);	2079	scr_page (DN, nrow / 4);
1623	# endif	2080	# endif
1624	else	2081	else
1625	scrollBar.setMotion ();	2082	scrollBar.state = STATE_MOTION;
1626	}	2083	}
1627	else	2084	else
1628	{	2085	{
1629	scr_page ((ev.button == Button1 ? DN : UP),	2086	scr_page ((ev.button == Button1 ? DN : UP),
1630	(TermWin.nrow	2087	(nrow
1631	* scrollbar_position (ev.y)	2088	* scrollbar_position (ev.y)
1632	/ scrollbar_size ()));	2089	/ scrollBar.size ()));
1633	}	2090	}
		2091
1634	break;	2092	break;
1635	}	2093	}
1636	}	2094	}
		2095
1637	return;	2096	return;
1638	}	2097	}
1639	#if MENUBAR
1640	/*
1641	* Menubar window processing of button press
1642	*/
1643	if (isMenuBarWindow (ev.window))
1644	menubar_control (ev);
1645	#endif
1646	}	2098	}
1647		2099
1648	void	2100	void
1649	rxvt_term::button_release (XButtonEvent &ev)	2101	rxvt_term::button_release (XButtonEvent &ev)
1650	{	2102	{
1651	int reportmode = 0;	2103	int reportmode = 0;
1652		2104
1653	csrO = 0; /* reset csr Offset */	2105	csrO = 0; /* reset csr Offset */
1654	if (!bypass_keystate)	2106	if (!bypass_keystate)
1655	reportmode = !! (PrivateModes & PrivMode_mouse_report);	2107	reportmode = !! (priv_modes & PrivMode_mouse_report);
1656		2108
1657	if (scrollbar_isUpDn ())	2109	if (scrollBar.state == STATE_UP || scrollBar.state == STATE_DOWN)
1658	{	2110	{
1659	scrollBar.setIdle ();	2111	scrollBar.state = STATE_IDLE;
1660	scrollbar_show (0);	2112	scrollBar.show (0);
1661	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1662	refresh_type &= ~SMOOTH_REFRESH;
1663	#endif
1664
1665	}	2113	}
		2114
1666	#ifdef SELECTION_SCROLLING	2115	#ifdef SELECTION_SCROLLING
1667	if (sel_scroll_ev.active)
1668	sel_scroll_ev.stop();	2116	sel_scroll_ev.stop();
1669	#endif	2117	#endif
		2118
1670	if (ev.window == TermWin.vt)	2119	if (ev.window == vt)
1671	{	2120	{
		2121	if (HOOK_INVOKE ((this, HOOK_BUTTON_RELEASE, DT_XEVENT, &ev, DT_END)))
		2122	return;
		2123
		2124	#if ISO_14755
		2125	// 5.4
		2126	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
		2127	return;
		2128	#endif
		2129
1672	if (reportmode)	2130	if (reportmode)
1673	{	2131	{
1674	/* mouse report from vt window */	2132	/* mouse report from vt window */
1675	/* don't report release of wheel "buttons" */	2133	/* don't report release of wheel "buttons" */
1676	if (ev.button >= 4)	2134	if (ev.button >= 4)
…		…
1687	mouse_report (ev);	2145	mouse_report (ev);
1688	}	2146	}
1689	#else /* MOUSE_REPORT_DOUBLECLICK */	2147	#else /* MOUSE_REPORT_DOUBLECLICK */
1690	MEvent.button = AnyButton;	2148	MEvent.button = AnyButton;
1691	mouse_report (ev);	2149	mouse_report (ev);
1692	#endif /* MOUSE_REPORT_DOUBLECLICK */	2150	#endif /* MOUSE_REPORT_DOUBLECLICK */
1693	return;	2151	return;
1694	}	2152	}
		2153
1695	/*	2154	/*
1696	* dumb hack to compensate for the failure of click-and-drag	2155	* dumb hack to compensate for the failure of click-and-drag
1697	* when overriding mouse reporting	2156	* when overriding mouse reporting
1698	*/	2157	*/
1699	if (PrivateModes & PrivMode_mouse_report	2158	if (priv_modes & PrivMode_mouse_report
1700	&& bypass_keystate	2159	&& bypass_keystate
1701	&& ev.button == Button1 && MEvent.clicks <= 1)	2160	&& ev.button == Button1 && MEvent.clicks <= 1)
1702	selection_extend (ev.x, ev.y, 0);	2161	selection_extend (ev.x, ev.y, 0);
1703		2162
1704	switch (ev.button)	2163	switch (ev.button)
1705	{	2164	{
1706	case Button1:	2165	case Button1:
1707	case Button3:	2166	case Button3:
1708	selection_make (ev.time);	2167	selection_make (ev.time);
1709	break;	2168	break;
		2169
1710	case Button2:	2170	case Button2:
1711	selection_request (ev.time, ev.x, ev.y);	2171	if (IN_RANGE_EXC (ev.x, 0, width) && IN_RANGE_EXC (ev.y, 0, height)) // inside window?
		2172	selection_request (ev.time, ev.state & ModMetaMask ? Sel_Clipboard : Sel_Primary);
1712	break;	2173	break;
		2174
1713	#ifdef MOUSE_WHEEL	2175	#ifdef MOUSE_WHEEL
1714	case Button4:	2176	case Button4:
1715	case Button5:	2177	case Button5:
1716	{	2178	{
1717	int i;	2179	int i;
…		…
1719		2181
1720	v = ev.button == Button4 ? UP : DN;	2182	v = ev.button == Button4 ? UP : DN;
1721		2183
1722	if (ev.state & ShiftMask)	2184	if (ev.state & ShiftMask)
1723	i = 1;	2185	i = 1;
1724	else if (Options & Opt_mouseWheelScrollPage)	2186	else if (option (Opt_mouseWheelScrollPage))
1725	i = TermWin.nrow - 1;	2187	i = nrow - 1;
1726	else	2188	else
1727	i = 5;	2189	i = 5;
1728		2190
1729	# ifdef MOUSE_SLIP_WHEELING	2191	# ifdef MOUSE_SLIP_WHEELING
1730	if (ev.state & ControlMask)	2192	if (ev.state & ControlMask)
1731	{	2193	{
1732	mouse_slip_wheel_speed += v ? -1 : 1;	2194	mouse_slip_wheel_speed += v ? -1 : 1;
1733	if (mouse_slip_wheel_speed < -TermWin.nrow) mouse_slip_wheel_speed = -TermWin.nrow;	2195	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;	2196	if (mouse_slip_wheel_speed > +nrow) mouse_slip_wheel_speed = +nrow;
1735		2197
1736	if (slip_wheel_ev.at < NOW)	2198	if (!slip_wheel_ev.is_active ())
1737	slip_wheel_ev.at = NOW + SCROLLBAR_CONTINUOUS_DELAY;	2199	slip_wheel_ev.start (SCROLLBAR_CONTINUOUS_DELAY, SCROLLBAR_CONTINUOUS_DELAY);
1738
1739	slip_wheel_ev.start ();
1740	}	2200	}
1741	else	2201	else
		2202	# endif
1742	{	2203	{
1743	# endif
1744	# ifdef JUMP_MOUSE_WHEEL
1745	scr_page (v, i);	2204	scr_page (v, i);
1746	scr_refresh (SMOOTH_REFRESH);
1747	scrollbar_show (1);	2205	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	}	2206	}
1758	#endif
1759	}	2207	}
1760	break;	2208	break;
1761	#endif	2209	#endif
1762	}	2210	}
1763	}	2211	}
1764	#ifdef MENUBAR
1765	else if (isMenuBarWindow (ev.window))
1766	menubar_control (ev);
1767	#endif
1768	}	2212	}
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		2213
2243	/*}}} */	2214	/*}}} */
2244		2215
2245	bool	2216	void
2246	rxvt_term::cmd_parse ()	2217	rxvt_term::cmd_parse ()
2247	{	2218	{
2248	bool flag = false;
2249	unicode_t ch = NOCHAR;	2219	wchar_t ch = NOCHAR;
2250	unsigned char *seq_begin; // remember start of esc-sequence here	2220	char *seq_begin; // remember start of esc-sequence here
2251		2221
2252	for (;;)	2222	for (;;)
2253	{	2223	{
2254	if (ch == NOCHAR)	2224	if (expect_false (ch == NOCHAR))
2255	{	2225	{
2256	seq_begin = cmdbuf_ptr;	2226	seq_begin = cmdbuf_ptr;
2257	ch = next_char ();	2227	ch = next_char ();
2258	}
2259		2228
2260	if (ch == NOCHAR) // TODO: improve	2229	if (ch == NOCHAR)
2261	break;	2230	break;
		2231	}
2262		2232
2263	if (!IS_CONTROL (ch) || ch == C0_LF || ch == C0_CR || ch == C0_HT)	2233	if (expect_true (!IS_CONTROL (ch) || ch == C0_LF || ch == C0_CR || ch == C0_HT))
		2234	{
		2235	if (expect_false (!seen_input))
2264	{	2236	{
		2237	seen_input = 1;
		2238	// many badly-written programs (e.g. jed) contain a race condition:
		2239	// they first read the screensize and then install a SIGWINCH handler.
		2240	// some window managers resize the window early, and these programs
		2241	// then sometimes get the size wrong.
		2242	// unfortunately other programs are even more buggy and dislike
		2243	// being sent SIGWINCH, so only do it when we were in fact being
		2244	// resized.
		2245	if (seen_resize && cmd_pid)
		2246	kill (-cmd_pid, SIGWINCH);
		2247	}
		2248
2265	/* Read a text string from the input buffer */	2249	/* Read a text string from the input buffer */
2266	unicode_t buf[UBUFSIZ];	2250	wchar_t buf[UBUFSIZ];
2267	bool refreshnow = false;	2251	bool refreshnow = false;
2268	int nlines = 0;	2252	int nlines = 0;
2269	unicode_t *str = buf;	2253	wchar_t *str = buf;
2270		2254	wchar_t *eol = str + min (ncol, UBUFSIZ);
2271	*str++ = ch;
2272		2255
2273	for (;;)	2256	for (;;)
2274	{	2257	{
		2258	if (expect_false (ch == NOCHAR || (IS_CONTROL (ch) && ch != C0_LF && ch != C0_CR && ch != C0_HT)))
		2259	break;
		2260
		2261	*str++ = ch;
		2262
		2263	if (expect_false (ch == C0_LF || str >= eol))
		2264	{
		2265	if (ch == C0_LF)
		2266	nlines++;
		2267
		2268	refresh_count++;
		2269
		2270	if (!option (Opt_jumpScroll) || refresh_count >= nrow - 1)
		2271	{
		2272	refresh_count = 0;
		2273
		2274	if (!option (Opt_skipScroll) || ev_time () > ev::now () + 1. / 60.)
		2275	{
		2276	refreshnow = true;
		2277	ch = NOCHAR;
		2278	break;
		2279	}
		2280	}
		2281
		2282	// scr_add_lines only works for nlines <= nrow - 1.
		2283	if (nlines >= nrow - 1)
		2284	{
		2285	if (!(SHOULD_INVOKE (HOOK_ADD_LINES)
		2286	&& HOOK_INVOKE ((this, HOOK_ADD_LINES, DT_WCS_LEN, buf, str - buf, DT_END))))
		2287	scr_add_lines (buf, str - buf, nlines);
		2288
		2289	nlines = 0;
		2290	str = buf;
		2291	eol = str + min (ncol, UBUFSIZ);
		2292	}
		2293
		2294	if (str >= eol)
		2295	{
		2296	if (eol >= buf + UBUFSIZ)
		2297	{
		2298	ch = NOCHAR;
		2299	break;
		2300	}
		2301	else
		2302	eol = min (eol + ncol, buf + UBUFSIZ);
		2303	}
		2304
		2305	}
		2306
2275	seq_begin = cmdbuf_ptr;	2307	seq_begin = cmdbuf_ptr;
2276	ch = next_char ();	2308	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	}	2309	}
2312		2310
		2311	if (!(SHOULD_INVOKE (HOOK_ADD_LINES)
		2312	&& HOOK_INVOKE ((this, HOOK_ADD_LINES, DT_WCS_LEN, buf, str - buf, DT_END))))
2313	scr_add_lines (buf, nlines, str - buf);	2313	scr_add_lines (buf, str - buf, nlines);
2314		2314
2315	/*	2315	/*
2316	* If there have been a lot of new lines, then update the screen	2316	* 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.	2317	* 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	2318	* 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	*/	2319	*/
2324	if (refreshnow)	2320	if (refreshnow)
2325	{	2321	{
2326	if ((Options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)
2327	refresh_limit++;
2328	else
2329	scr_refresh (refresh_type);	2322	scr_refresh ();
		2323	want_refresh = 1;
2330	}	2324	}
2331
2332	}	2325	}
2333	else	2326	else
2334	{	2327	{
2335	try	2328	try
2336	{	2329	{
…		…
2344	}	2337	}
2345		2338
2346	ch = NOCHAR;	2339	ch = NOCHAR;
2347	}	2340	}
2348	}	2341	}
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	}	2342	}
2361		2343
2362	// read the next character	2344	// read the next character
2363	unicode_t	2345	wchar_t
2364	rxvt_term::next_char ()	2346	rxvt_term::next_char () NOTHROW
2365	{	2347	{
2366	while (cmdbuf_ptr < cmdbuf_endp)	2348	while (cmdbuf_ptr < cmdbuf_endp)
2367	{	2349	{
2368	// assume 7-bit to be ascii ALWAYS	2350	// assume 7-bit to be ascii ALWAYS
2369	if (*cmdbuf_ptr <= 0x7f && *cmdbuf_ptr != 0x1b)	2351	if (expect_true ((unsigned char)*cmdbuf_ptr <= 0x7f && *cmdbuf_ptr != 0x1b))
2370	return *cmdbuf_ptr++;	2352	return *cmdbuf_ptr++;
2371		2353
2372	wchar_t wc;	2354	wchar_t wc;
2373	size_t len = mbrtowc (&wc, (char *)cmdbuf_ptr, cmdbuf_endp - cmdbuf_ptr, mbstate);	2355	size_t len = mbrtowc (&wc, cmdbuf_ptr, cmdbuf_endp - cmdbuf_ptr, mbstate);
2374		2356
2375	if (len == (size_t)-2)	2357	if (len == (size_t)-2)
2376	{	2358	{
2377	// the mbstate stores incomplete sequences. didn't know this :/	2359	// the mbstate stores incomplete sequences. didn't know this :/
2378	cmdbuf_ptr = cmdbuf_endp;	2360	cmdbuf_ptr = cmdbuf_endp;
2379	break;	2361	break;
2380	}	2362	}
2381		2363
2382	if (len == (size_t)-1)	2364	if (len == (size_t)-1)
		2365	{
		2366	mbstate.reset (); // reset now undefined conversion state
2383	return *cmdbuf_ptr++; // the _occasional_ latin1 character is allowed to slip through	2367	return (unsigned char)*cmdbuf_ptr++; // the _occasional_ latin1 character is allowed to slip through
		2368	}
2384		2369
2385	// assume wchar == unicode	2370	// assume wchar == unicode
2386	cmdbuf_ptr += len;	2371	cmdbuf_ptr += len;
2387	return wc;	2372	return wc & UNICODE_MASK;
2388	}	2373	}
2389		2374
2390	return NOCHAR;	2375	return NOCHAR;
2391	}	2376	}
		2377
		2378	// read the next octet
		2379	uint32_t
		2380	rxvt_term::next_octet () NOTHROW
		2381	{
		2382	return cmdbuf_ptr < cmdbuf_endp
		2383	? (unsigned char)*cmdbuf_ptr++
		2384	: NOCHAR;
		2385	}
		2386
		2387	static class out_of_input out_of_input;
2392		2388
2393	/* rxvt_cmd_getc () - Return next input character */	2389	/* rxvt_cmd_getc () - Return next input character */
2394	/*	2390	/*
2395	* Return the next input character after first passing any keyboard input	2391	* Return the next input character after first passing any keyboard input
2396	* to the command.	2392	* to the command.
2397	*/	2393	*/
2398	unicode_t	2394	wchar_t
2399	rxvt_term::cmd_getc ()	2395	rxvt_term::cmd_getc () THROW ((class out_of_input))
2400	{	2396	{
2401	unicode_t c = next_char ();	2397	wchar_t c = next_char ();
2402		2398
2403	if (c == NOCHAR)	2399	if (c == NOCHAR)
2404	throw out_of_input;	2400	throw out_of_input;
2405		2401
2406	return c;	2402	return c;
2407	}	2403	}
2408		2404
2409	unicode_t	2405	uint32_t
2410	rxvt_term::cmd_get8 ()	2406	rxvt_term::cmd_get8 () THROW ((class out_of_input))
2411	{	2407	{
2412	unicode_t c = next_octet ();	2408	uint32_t c = next_octet ();
2413		2409
2414	if (c == NOCHAR)	2410	if (c == NOCHAR)
2415	throw out_of_input;	2411	throw out_of_input;
2416		2412
2417	return c;	2413	return c;
…		…
2421	/*----------------------------------------------------------------------*/	2417	/*----------------------------------------------------------------------*/
2422	#ifdef PRINTPIPE	2418	#ifdef PRINTPIPE
2423	FILE *	2419	FILE *
2424	rxvt_term::popen_printer ()	2420	rxvt_term::popen_printer ()
2425	{	2421	{
2426	FILE *stream = popen (rs[Rs_print_pipe], "w");	2422	FILE *stream = popen (rs[Rs_print_pipe] ? rs[Rs_print_pipe] : PRINTPIPE, "w");
2427		2423
2428	if (stream == NULL)	2424	if (stream == NULL)
2429	rxvt_warn ("can't open printer pipe, not printing.\n");	2425	rxvt_warn ("can't open printer pipe, not printing.\n");
2430		2426
2431	return stream;	2427	return stream;
…		…
2442	* simulate attached vt100 printer	2438	* simulate attached vt100 printer
2443	*/	2439	*/
2444	void	2440	void
2445	rxvt_term::process_print_pipe ()	2441	rxvt_term::process_print_pipe ()
2446	{	2442	{
2447	int done;	2443	FILE *fd = popen_printer ();
2448	FILE *fd;
2449		2444
2450	if ((fd = popen_printer ()) == NULL)	2445	if (!fd)
2451	return;	2446	return;
2452		2447
2453	/*	2448	/*
2454	* Send all input to the printer until either ESC[4i or ESC[?4i	2449	* Send all input to the printer until either ESC[4i or ESC[?4i
2455	* is received.	2450	* is received.
2456	*/	2451	*/
2457	for (done = 0; !done;)	2452	for (int done = 0; !done; )
2458	{	2453	{
2459	unsigned char buf[8];	2454	unsigned char buf[8];
2460	unicode_t ch;	2455	unicode_t ch;
2461	unsigned int i, len;	2456	unsigned int i, len;
2462		2457
…		…
2481	{	2476	{
2482	if ((buf[len++] = cmd_getc ()) == 'i')	2477	if ((buf[len++] = cmd_getc ()) == 'i')
2483	break; /* done = 1 */	2478	break; /* done = 1 */
2484	}	2479	}
2485	}	2480	}
2486		2481
2487	for (i = 0; i < len; i++)	2482	for (i = 0; i < len; i++)
2488	if (putc (buf[i], fd) == EOF)	2483	if (putc (buf[i], fd) == EOF)
2489	{	2484	{
2490	done = 1;	2485	done = 1;
2491	break;	2486	break;
…		…
2493	}	2488	}
2494	}	2489	}
2495		2490
2496	pclose_printer (fd);	2491	pclose_printer (fd);
2497	}	2492	}
2498	#endif /* PRINTPIPE */	2493	#endif /* PRINTPIPE */
2499	/*}}} */	2494	/*}}} */
2500		2495
2501	/* *INDENT-OFF* */	2496	/* *INDENT-OFF* */
2502	enum {	2497	enum {
2503	C1_40 = 0x40,	2498	C1_40 = 0x40,
…		…
2517	case C0_ESC:	2512	case C0_ESC:
2518	process_escape_seq ();	2513	process_escape_seq ();
2519	break;	2514	break;
2520	case C0_ENQ: /* terminal Status */	2515	case C0_ENQ: /* terminal Status */
2521	if (rs[Rs_answerbackstring])	2516	if (rs[Rs_answerbackstring])
2522	tt_write ((const unsigned char *)rs[Rs_answerbackstring],	2517	tt_write (rs [Rs_answerbackstring], strlen (rs [Rs_answerbackstring]));
2523	(unsigned int)STRLEN (rs[Rs_answerbackstring]));
2524	else	2518	else
2525	tt_write ((unsigned char *)VT100_ANS,	2519	tt_write (VT100_ANS, strlen (VT100_ANS));
2526	(unsigned int)STRLEN (VT100_ANS));
2527	break;	2520	break;
2528	case C0_BEL: /* bell */	2521	case C0_BEL: /* bell */
2529	scr_bell ();	2522	scr_bell ();
2530	break;	2523	break;
2531	case C0_BS: /* backspace */	2524	case C0_BS: /* backspace */
…		…
2555	process_dcs_seq ();	2548	process_dcs_seq ();
2556	break;	2549	break;
2557	case 0x9b: /* CSI */	2550	case 0x9b: /* CSI */
2558	process_csi_seq ();	2551	process_csi_seq ();
2559	break;	2552	break;
2560	case 0x9d: /* CSI */	2553	case 0x9d: /* OSC */
2561	process_osc_seq ();	2554	process_osc_seq ();
2562	break;	2555	break;
2563	#endif	2556	#endif
2564	}	2557	}
2565	}	2558	}
…		…
2609	break;	2602	break;
2610	case 'Z': /* identify the terminal type */	2603	case 'Z': /* identify the terminal type */
2611	tt_printf ("\033/Z"); /* I am a VT100 emulating a VT52 */	2604	tt_printf ("\033/Z"); /* I am a VT100 emulating a VT52 */
2612	break;	2605	break;
2613	case '<': /* turn off VT52 mode */	2606	case '<': /* turn off VT52 mode */
2614	PrivMode (0, PrivMode_vt52);	2607	set_privmode (PrivMode_vt52, 0);
2615	break;	2608	break;
2616	case 'F': /* use special graphics character set */	2609	case 'F': /* use special graphics character set */
2617	case 'G': /* use regular character set */	2610	case 'G': /* use regular character set */
2618	/* unimplemented */	2611	/* unimplemented */
2619	break;	2612	break;
…		…
2630	void	2623	void
2631	rxvt_term::process_escape_seq ()	2624	rxvt_term::process_escape_seq ()
2632	{	2625	{
2633	unicode_t ch = cmd_getc ();	2626	unicode_t ch = cmd_getc ();
2634		2627
2635	if (PrivateModes & PrivMode_vt52)	2628	if (priv_modes & PrivMode_vt52)
2636	{	2629	{
2637	process_escape_vt52 (ch);	2630	process_escape_vt52 (ch);
2638	return;	2631	return;
2639	}	2632	}
2640		2633
…		…
2655	scr_charset_set (2, (unsigned int)cmd_getc ());	2648	scr_charset_set (2, (unsigned int)cmd_getc ());
2656	break;	2649	break;
2657	case '+':	2650	case '+':
2658	scr_charset_set (3, (unsigned int)cmd_getc ());	2651	scr_charset_set (3, (unsigned int)cmd_getc ());
2659	break;	2652	break;
2660	#ifndef NO_FRILLS	2653	#if !ENABLE_MINIMAL
2661	case '6':	2654	case '6':
2662	scr_backindex ();	2655	scr_backindex ();
2663	break;	2656	break;
2664	#endif	2657	#endif
2665	case '7':	2658	case '7':
2666	scr_cursor (SAVE);	2659	scr_cursor (SAVE);
2667	break;	2660	break;
2668	case '8':	2661	case '8':
2669	scr_cursor (RESTORE);	2662	scr_cursor (RESTORE);
2670	break;	2663	break;
2671	#ifndef NO_FRILLS	2664	#if !ENABLE_MINIMAL
2672	case '9':	2665	case '9':
2673	scr_forwardindex ();	2666	scr_forwardindex ();
2674	break;	2667	break;
2675	#endif	2668	#endif
2676	case '=':	2669	case '=':
2677	case '>':	2670	case '>':
2678	PrivMode ((ch == '='), PrivMode_aplKP);	2671	set_privmode (PrivMode_aplKP, ch == '=');
2679	break;	2672	break;
2680		2673
2681	case C1_40:	2674	case C1_40:
2682	cmd_getc ();	2675	cmd_getc ();
2683	break;	2676	break;
…		…
2686	break;	2679	break;
2687		2680
2688	/* 8.3.87: NEXT LINE */	2681	/* 8.3.87: NEXT LINE */
2689	case C1_NEL: /* ESC E */	2682	case C1_NEL: /* ESC E */
2690	{	2683	{
2691	unicode_t nlcr[] = { C0_LF, C0_CR };	2684	wchar_t nlcr[] = { C0_LF, C0_CR };
2692	scr_add_lines (nlcr, 1, 2);	2685	scr_add_lines (nlcr, sizeof (nlcr) / sizeof (nlcr [0]), 1);
2693	}	2686	}
2694	break;	2687	break;
2695		2688
2696	/* kidnapped escape sequence: Should be 8.3.48 */	2689	/* kidnapped escape sequence: Should be 8.3.48 */
2697	case C1_ESA: /* ESC G */	2690	case C1_ESA: /* ESC G */
…		…
2719	process_dcs_seq ();	2712	process_dcs_seq ();
2720	break;	2713	break;
2721		2714
2722	/* 8.3.110: SINGLE CHARACTER INTRODUCER */	2715	/* 8.3.110: SINGLE CHARACTER INTRODUCER */
2723	case C1_SCI: /* ESC Z */	2716	case C1_SCI: /* ESC Z */
2724	tt_write ((const unsigned char *)ESCZ_ANSWER,	2717	tt_write (ESCZ_ANSWER, sizeof (ESCZ_ANSWER) - 1);
2725	(unsigned int) (sizeof (ESCZ_ANSWER) - 1));
2726	break; /* steal obsolete ESC [ c */	2718	break; /* steal obsolete ESC [ c */
2727		2719
2728	/* 8.3.16: CONTROL SEQUENCE INTRODUCER */	2720	/* 8.3.16: CONTROL SEQUENCE INTRODUCER (CSI) */
2729	case C1_CSI: /* ESC [ */	2721	case C1_CSI: /* ESC [ */
2730	process_csi_seq ();	2722	process_csi_seq ();
2731	break;	2723	break;
2732		2724
2733	/* 8.3.90: OPERATING SYSTEM COMMAND */	2725	/* 8.3.90: OPERATING SYSTEM COMMAND (OSC) */
2734	case C1_OSC: /* ESC ] */	2726	case C1_OSC: /* ESC ] */
2735	process_osc_seq ();	2727	process_osc_seq ();
2736	break;	2728	break;
2737		2729
2738	/* 8.3.106: RESET TO INITIAL STATE */	2730	/* 8.3.106: RESET TO INITIAL STATE (RIS) */
2739	case 'c':	2731	case 'c':
2740	mbstate.reset ();	2732	mbstate.reset ();
2741	scr_poweron ();	2733	scr_poweron ();
2742	scrollbar_show (1);	2734	scrollBar.show (1);
2743	break;	2735	break;
2744		2736
2745	/* 8.3.79: LOCKING-SHIFT TWO (see ISO2022) */	2737	/* 8.3.79: LOCKING-SHIFT TWO (see ISO2022) */
2746	case 'n':	2738	case 'n':
2747	scr_charset_choose (2);	2739	scr_charset_choose (2);
…		…
2792	rxvt_term::process_csi_seq ()	2784	rxvt_term::process_csi_seq ()
2793	{	2785	{
2794	unicode_t ch, priv, i;	2786	unicode_t ch, priv, i;
2795	unsigned int nargs, p;	2787	unsigned int nargs, p;
2796	int n, ndef;	2788	int n, ndef;
2797	int arg[ESC_ARGS];	2789	int arg[ESC_ARGS] = { };
2798		2790
2799	for (nargs = ESC_ARGS; nargs > 0;)	2791	nargs = 0;
2800	arg[--nargs] = 0;
2801		2792
2802	priv = 0;	2793	priv = 0;
2803	ch = cmd_getc ();	2794	ch = cmd_getc ();
2804	if (ch >= '<' && ch <= '?')	2795	if ((ch >= '<' && ch <= '?') || ch == '!')
		2796	{
2805	{ /* '<' '=' '>' '?' */	2797	/* '<' '=' '>' '?' '!' */
2806	priv = ch;	2798	priv = ch;
2807	ch = cmd_getc ();	2799	ch = cmd_getc ();
2808	}	2800	}
2809		2801
2810	/* read any numerical arguments */	2802	/* read any numerical arguments */
…		…
2839	ndef = get_byte_array_bit (csi_defaults, i);	2831	ndef = get_byte_array_bit (csi_defaults, i);
2840	for (p = 0; p < nargs; p++)	2832	for (p = 0; p < nargs; p++)
2841	if (arg[p] == -1)	2833	if (arg[p] == -1)
2842	arg[p] = ndef;	2834	arg[p] = ndef;
2843		2835
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	/*	2836	/*
2852	* private mode handling	2837	* private mode handling
2853	*/	2838	*/
2854	if (priv)	2839	if (priv)
2855	{	2840	{
2856	switch (priv)	2841	switch (priv)
2857	{	2842	{
2858	case '>':	2843	case '>':
2859	if (ch == CSI_DA) /* secondary device attributes */	2844	if (ch == CSI_DA) /* secondary device attributes */
		2845	{
		2846	// first parameter is normally 0 for vt100, 1 for vt220, 'R' for rxvt,
		2847	// 'U' for rxvt-unicode != 7.[34] (where it was broken).
		2848	//
		2849	// second parameter is xterm patch level for xterm, MMmmpp (e.g. 20703) for rxvt
		2850	// and Mm (e.g. 72 for 7.2) for urxvt <= 7.2, 94 for urxvt <= 8.3, and 95 for later
		2851	// versions.
		2852	//
2860	tt_printf ("\033[>%d;%-.8s;0c", 'R', VSTRING);	2853	tt_printf ("\033[>%d;95;0c", 'U');
		2854	}
2861	break;	2855	break;
		2856
2862	case '?':	2857	case '?':
2863	if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')	2858	if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')
2864	process_terminal_mode (ch, priv, nargs, arg);	2859	process_terminal_mode (ch, priv, nargs, arg);
2865	break;	2860	break;
		2861
		2862	case '!':
		2863	if (ch == CSI_70)
		2864	{
		2865	/* DECSTR: soft terminal reset, used by our terminfo since 9.06 */
		2866	scr_soft_reset ();
		2867
		2868	static const int pm_h[] = { 7, 25 };
		2869	static const int pm_l[] = { 1, 3, 4, 5, 6, 9, 66, 1000, 1001, 1049 };
		2870
		2871	process_terminal_mode ('h', 0, sizeof (pm_h) / sizeof (pm_h[0]), pm_h);
		2872	process_terminal_mode ('l', 0, sizeof (pm_l) / sizeof (pm_l[0]), pm_l);
2866	}	2873	}
		2874	break;
		2875	}
		2876
2867	return;	2877	return;
2868	}	2878	}
2869		2879
2870	switch (ch)	2880	switch (ch)
2871	{	2881	{
…		…
2970		2980
2971	case CSI_SD: /* 8.3.114: (1) SCROLL DOWN */	2981	case CSI_SD: /* 8.3.114: (1) SCROLL DOWN */
2972	arg[0] = -arg[0];	2982	arg[0] = -arg[0];
2973	/* FALLTHROUGH */	2983	/* FALLTHROUGH */
2974	case CSI_SU: /* 8.3.148: (1) SCROLL UP */	2984	case CSI_SU: /* 8.3.148: (1) SCROLL UP */
2975	scr_scroll_text (screen.tscroll, screen.bscroll, arg[0], 0);	2985	scr_scroll_text (screen.tscroll, screen.bscroll, arg[0]);
2976	break;	2986	break;
2977		2987
2978	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */	2988	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */
2979	tt_write ((const unsigned char *)VT100_ANS,	2989	tt_write (VT100_ANS, sizeof (VT100_ANS) - 1);
2980	(unsigned int) (sizeof (VT100_ANS) - 1));
2981	break;	2990	break;
2982		2991
2983	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */	2992	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */
2984	process_sgr_mode (nargs, arg);	2993	process_sgr_mode (nargs, arg);
2985	break;	2994	break;
…		…
2992	break;	3001	break;
2993	case 6: /* CPR requested */	3002	case 6: /* CPR requested */
2994	scr_report_position ();	3003	scr_report_position ();
2995	break;	3004	break;
2996	case 7: /* unofficial extension */	3005	case 7: /* unofficial extension */
2997	if (Options & Opt_insecure)	3006	if (option (Opt_insecure))
2998	tt_printf ("%-.250s\n", rs[Rs_display_name]);	3007	tt_printf ("%-.250s\012", rs[Rs_display_name]);
2999	break;	3008	break;
3000	case 8: /* unofficial extension */	3009	case 8: /* unofficial extension */
3001	process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);	3010	process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);
3002	break;	3011	break;
3003	}	3012	}
…		…
3039	break;	3048	break;
3040		3049
3041	case CSI_RM: /* 8.3.107: RESET MODE */	3050	case CSI_RM: /* 8.3.107: RESET MODE */
3042	if (arg[0] == 4)	3051	if (arg[0] == 4)
3043	scr_insert_mode (0);	3052	scr_insert_mode (0);
		3053	else if (arg[0] == 20)
		3054	priv_modes &= ~PrivMode_LFNL;
3044	break;	3055	break;
3045		3056
3046	case CSI_SM: /* 8.3.126: SET MODE */	3057	case CSI_SM: /* 8.3.126: SET MODE */
3047	if (arg[0] == 4)	3058	if (arg[0] == 4)
3048	scr_insert_mode (1);	3059	scr_insert_mode (1);
		3060	else if (arg[0] == 20)
		3061	priv_modes |= PrivMode_LFNL;
3049	break;	3062	break;
3050		3063
3051	/*	3064	/*
3052	* PRIVATE USE beyond this point. All CSI_7? sequences here	3065	* PRIVATE USE beyond this point. All CSI_7? sequences here
3053	*/	3066	*/
…		…
3065	break;	3078	break;
3066	case CSI_75:	3079	case CSI_75:
3067	scr_cursor (RESTORE);	3080	scr_cursor (RESTORE);
3068	break;	3081	break;
3069		3082
3070	#ifndef NO_FRILLS	3083	#if !ENABLE_MINIMAL
3071	case CSI_74:	3084	case CSI_74:
3072	process_window_ops (arg, nargs);	3085	process_window_ops (arg, nargs);
3073	break;	3086	break;
3074	#endif	3087	#endif
3075		3088
…		…
3082	break;	3095	break;
3083	}	3096	}
3084	}	3097	}
3085	/*}}} */	3098	/*}}} */
3086		3099
3087	#ifndef NO_FRILLS	3100	#if !ENABLE_MINIMAL
3088	/* ARGSUSED */	3101	/* ARGSUSED */
3089	void	3102	void
3090	rxvt_term::process_window_ops (const int *args, unsigned int nargs)	3103	rxvt_term::process_window_ops (const int *args, unsigned int nargs)
3091	{	3104	{
3092	int x, y;	3105	int x, y;
3093	XWindowAttributes wattr;	3106	XWindowAttributes wattr;
3094	Window wdummy;	3107	Window wdummy;
		3108
		3109	dLocal (Display *, dpy);
3095		3110
3096	if (nargs == 0)	3111	if (nargs == 0)
3097	return;	3112	return;
3098		3113
3099	switch (args[0])	3114	switch (args[0])
3100	{	3115	{
3101	/*	3116	/*
3102	* commands	3117	* commands
3103	*/	3118	*/
3104	case 1: /* deiconify window */	3119	case 1: /* deiconify window */
3105	XMapWindow (display->display, TermWin.parent[0]);	3120	XMapWindow (dpy, parent[0]);
3106	break;	3121	break;
3107	case 2: /* iconify window */	3122	case 2: /* iconify window */
3108	XIconifyWindow (display->display, TermWin.parent[0],	3123	XIconifyWindow (dpy, parent[0], display->screen);
3109	DefaultScreen (display->display));
3110	break;	3124	break;
3111	case 3: /* set position (pixels) */	3125	case 3: /* set position (pixels) */
3112	XMoveWindow (display->display, TermWin.parent[0], args[1], args[2]);	3126	XMoveWindow (dpy, parent[0], args[1], args[2]);
3113	break;	3127	break;
3114	case 4: /* set size (pixels) */	3128	case 4: /* set size (pixels) */
3115	set_widthheight ((unsigned int)args[2], (unsigned int)args[1]);	3129	set_widthheight ((unsigned int)args[2], (unsigned int)args[1]);
3116	break;	3130	break;
3117	case 5: /* raise window */	3131	case 5: /* raise window */
3118	XRaiseWindow (display->display, TermWin.parent[0]);	3132	XRaiseWindow (dpy, parent[0]);
3119	break;	3133	break;
3120	case 6: /* lower window */	3134	case 6: /* lower window */
3121	XLowerWindow (display->display, TermWin.parent[0]);	3135	XLowerWindow (dpy, parent[0]);
3122	break;	3136	break;
3123	case 7: /* refresh window */	3137	case 7: /* refresh window */
3124	scr_touch (true);	3138	scr_touch (true);
3125	break;	3139	break;
3126	case 8: /* set size (chars) */	3140	case 8: /* set size (chars) */
3127	set_widthheight ((unsigned int) (args[2] * TermWin.fwidth),	3141	set_widthheight ((unsigned int) (args[2] * fwidth),
3128	(unsigned int) (args[1] * TermWin.fheight));	3142	(unsigned int) (args[1] * fheight));
3129	break;	3143	break;
3130		3144
3131	//case 9: NYI, TODO, restore maximized window or maximize window	3145	//case 9: NYI, TODO, restore maximized window or maximize window
3132	default:	3146	default:
3133	if (args[0] >= 24) /* set height (chars) */	3147	if (args[0] >= 24) /* set height (chars) */
3134	set_widthheight ((unsigned int)TermWin.width,	3148	set_widthheight ((unsigned int)width,
3135	(unsigned int) (args[1] * TermWin.fheight));	3149	(unsigned int) (args[1] * fheight));
3136	break;	3150	break;
3137
3138		3151
3139	/*	3152	/*
3140	* reports - some output format copied from XTerm	3153	* reports - some output format copied from XTerm
3141	*/	3154	*/
3142	case 11: /* report window state */	3155	case 11: /* report window state */
3143	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);	3156	XGetWindowAttributes (dpy, parent[0], &wattr);
3144	tt_printf ("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);	3157	tt_printf ("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);
3145	break;	3158	break;
3146	case 13: /* report window position */	3159	case 13: /* report window position */
3147	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);	3160	XGetWindowAttributes (dpy, parent[0], &wattr);
3148	XTranslateCoordinates (display->display, TermWin.parent[0], wattr.root,	3161	XTranslateCoordinates (dpy, parent[0], wattr.root,
3149	-wattr.border_width, -wattr.border_width,	3162	-wattr.border_width, -wattr.border_width,
3150	&x, &y, &wdummy);	3163	&x, &y, &wdummy);
3151	tt_printf ("\033[3;%d;%dt", x, y);	3164	tt_printf ("\033[3;%d;%dt", x, y);
3152	break;	3165	break;
3153	case 14: /* report window size (pixels) */	3166	case 14: /* report window size (pixels) */
3154	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);	3167	XGetWindowAttributes (dpy, parent[0], &wattr);
3155	tt_printf ("\033[4;%d;%dt", wattr.height, wattr.width);	3168	tt_printf ("\033[4;%d;%dt", wattr.height, wattr.width);
3156	break;	3169	break;
3157	case 18: /* report text area size (chars) */	3170	case 18: /* report text area size (chars) */
3158	tt_printf ("\033[8;%d;%dt", TermWin.nrow, TermWin.ncol);	3171	tt_printf ("\033[8;%d;%dt", nrow, ncol);
3159	break;	3172	break;
3160	case 19: /* report window size (chars) */	3173	case 19: /* report window size (chars) */
3161	tt_printf ("\033[9;%d;%dt", TermWin.nrow, TermWin.ncol);	3174	tt_printf ("\033[9;%d;%dt", nrow, ncol);
3162	break;	3175	break;
3163	case 20: /* report icon label */	3176	case 20: /* report icon label */
3164	if (Options & Opt_insecure)
3165	{	3177	{
3166	char *s;	3178	char *s;
3167	XGetIconName (display->display, TermWin.parent[0], &s);	3179	XGetIconName (dpy, parent[0], &s);
3168	tt_printf ("\033]L%-.200s\234", s ? s : ""); /* 8bit ST */	3180	tt_printf ("\033]L%-.250s\234", option (Opt_insecure) && s ? s : ""); /* 8bit ST */
		3181	XFree (s);
3169	}	3182	}
3170	break;	3183	break;
3171	case 21: /* report window title */	3184	case 21: /* report window title */
3172	if (Options & Opt_insecure)
3173	{	3185	{
3174	char *s;	3186	char *s;
3175	XFetchName (display->display, TermWin.parent[0], &s);	3187	XFetchName (dpy, parent[0], &s);
3176	tt_printf ("\033]l%-.200s\234", s ? s : ""); /* 8bit ST */	3188	tt_printf ("\033]l%-.250s\234", option (Opt_insecure) && s ? s : ""); /* 8bit ST */
		3189	XFree (s);
3177	}	3190	}
3178	break;	3191	break;
3179	}	3192	}
3180	}	3193	}
3181	#endif	3194	#endif
3182		3195
3183	/*----------------------------------------------------------------------*/	3196	/*----------------------------------------------------------------------*/
3184	/*	3197	/*
3185	* get input up until STRING TERMINATOR (or BEL)	3198	* get input up until STRING TERMINATOR (or BEL)
3186	* ends_how is terminator used. returned input must be free()'d	3199	* ends_how is terminator used. returned input must be free()'d
3187	*/	3200	*/
3188	unsigned char *	3201	char *
3189	rxvt_term::get_to_st (unicode_t &ends_how)	3202	rxvt_term::get_to_st (unicode_t &ends_how)
3190	{	3203	{
3191	unicode_t prev = 0, ch;	3204	unicode_t ch;
		3205	bool seen_esc = false;
3192	unsigned int n = 0;	3206	unsigned int n = 0;
3193	unsigned char *s;
3194	unsigned char string[STRING_MAX];	3207	wchar_t string[STRING_MAX];
3195		3208
3196	while ((ch = cmd_getc ()) != NOCHAR)	3209	while ((ch = cmd_getc ()) != NOCHAR)
3197	{	3210	{
3198	if (prev == C0_ESC)	3211	if (seen_esc)
3199	{	3212	{
3200	if (ch == 0x5c) /* 7bit ST */	3213	if (ch == 0x5c) /* 7bit ST */
3201	break;	3214	break;
3202	else	3215	else
3203	return NULL;	3216	return NULL;
3204	}	3217	}
		3218	else if (ch == C0_ESC)
		3219	{
		3220	seen_esc = true;
		3221	continue;
		3222	}
3205	else if (ch == C0_BEL || ch == CHAR_ST)	3223	else if (ch == C0_BEL || ch == CHAR_ST)
3206	break;	3224	break;
		3225	else if (ch == C0_SYN)
		3226	ch = cmd_get8 ();
3207	else if (ch < 0x20)	3227	else if (ch < 0x20)
3208	return NULL; /* other control character - exit */	3228	return NULL; /* other control character - exit */
3209		3229
3210	if (n >= sizeof (string) - 1)	3230	seen_esc = false;
		3231
		3232	if (n >= STRING_MAX - 1)
3211	// stop at some sane length	3233	// stop at some sane length
3212	return NULL;	3234	return NULL;
3213		3235
3214	if (ch == C0_SYN)
3215	{
3216	string[n++] = cmd_get8 ();
3217	prev = 0;
3218	}
3219	else
3220	string[n++] = prev = ch;	3236	string[n++] = ch;
3221	}	3237	}
3222		3238
3223	string[n++] = '\0';	3239	string[n++] = '\0';
3224		3240
3225	if ((s = (unsigned char *)rxvt_malloc (n)) == NULL)
3226	return NULL;
3227
3228	ends_how = (ch == 0x5c ? C0_ESC : ch);	3241	ends_how = (ch == 0x5c ? C0_ESC : ch);
3229	STRNCPY (s, string, n);	3242
3230	return s;	3243	return rxvt_wcstombs (string);
3231	}	3244	}
3232		3245
3233	/*----------------------------------------------------------------------*/	3246	/*----------------------------------------------------------------------*/
3234	/*	3247	/*
3235	* process DEVICE CONTROL STRING `ESC P ... (ST|BEL)' or `0x90 ... (ST|BEL)'	3248	* process DEVICE CONTROL STRING `ESC P ... (ST|BEL)' or `0x90 ... (ST|BEL)'
3236	*/	3249	*/
3237	void	3250	void
3238	rxvt_term::process_dcs_seq ()	3251	rxvt_term::process_dcs_seq ()
3239	{	3252	{
3240	unsigned char *s;
3241	unicode_t eh;
3242
3243	/*	3253	/*
3244	* Not handled yet	3254	* Not handled yet
3245	*/	3255	*/
		3256
		3257	unicode_t eh;
3246	s = get_to_st (eh);	3258	char *s = get_to_st (eh);
3247	if (s)	3259	if (s)
3248	free (s);	3260	free (s);
3249		3261
3250	return;	3262	return;
3251	}	3263	}
…		…
3255	* process OPERATING SYSTEM COMMAND sequence `ESC ] Ps ; Pt (ST|BEL)'	3267	* process OPERATING SYSTEM COMMAND sequence `ESC ] Ps ; Pt (ST|BEL)'
3256	*/	3268	*/
3257	void	3269	void
3258	rxvt_term::process_osc_seq ()	3270	rxvt_term::process_osc_seq ()
3259	{	3271	{
3260	unicode_t ch, eh;
3261	int arg;	3272	int arg;
3262		3273
3263	ch = cmd_getc ();	3274	unicode_t ch = cmd_getc ();
3264	for (arg = 0; isdigit (ch); ch = cmd_getc ())	3275	for (arg = 0; isdigit (ch); ch = cmd_getc ())
3265	arg = arg * 10 + (ch - '0');	3276	arg = arg * 10 + (ch - '0');
3266		3277
3267	if (ch == ';')	3278	if (ch == ';')
3268	{	3279	{
		3280	unicode_t eh;
3269	unsigned char *s = get_to_st (eh);	3281	char *s = get_to_st (eh);
3270		3282
3271	if (s)	3283	if (s)
3272	{	3284	{
3273	process_xterm_seq (arg, (char *)s, eh);	3285	process_xterm_seq (arg, s, eh);
3274	free (s);	3286	free (s);
3275	}	3287	}
3276	}	3288	}
3277	}	3289	}
3278		3290
3279	void	3291	void
3280	rxvt_term::process_color_seq (int report, int color, const char *str, unsigned char resp)	3292	rxvt_term::process_color_seq (int report, int color, const char *str, char resp)
3281	{	3293	{
3282	if (str[0] == '?' && !str[1])	3294	if (str[0] == '?' && !str[1])
3283	{	3295	{
3284	if (Options & Opt_insecure)	3296	rgba c;
3285	{	3297	pix_colors_focused[color].get (c);
3286	unsigned short r, g, b;	3298
3287	PixColorsFocused[color].get (display, r, g, b);	3299	#if XFT
		3300	if (c.a != rgba::MAX_CC)
		3301	tt_printf ("\033]%d;rgba:%04x/%04x/%04x/%04x%c", report, c.a, c.r, c.g, c.b, resp);
		3302	else
		3303	#endif
3288	tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, r, g, b, resp);	3304	tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, c.r, c.g, c.b, resp);
3289	}
3290	}	3305	}
3291	else	3306	else
3292	set_window_color (color, str);	3307	set_window_color (color, str);
3293	}	3308	}
3294		3309
3295	/*	3310	/*
3296	* XTerm escape sequences: ESC ] Ps;Pt (ST|BEL)	3311	* 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	*/	3312	*/
3320	void	3313	void
3321	rxvt_term::process_xterm_seq (int op, const char *str, unsigned char resp)	3314	rxvt_term::process_xterm_seq (int op, char *str, char resp)
3322	{	3315	{
3323	int changed = 0;
3324	int color;	3316	int color;
3325	char *buf, *name;	3317	char *buf, *name;
3326	bool query = str[0] == '?' && !str[1];	3318	bool query = str[0] == '?' && !str[1];
		3319	int saveop = op;
		3320
		3321	dLocal (Display *, dpy);
3327		3322
3328	assert (str != NULL);	3323	assert (str != NULL);
		3324
		3325	if (HOOK_INVOKE ((this, HOOK_OSC_SEQ, DT_INT, op, DT_STR, str, DT_END)))
		3326	return;
		3327
3329	switch (op)	3328	switch (op)
3330	{	3329	{
3331	case XTerm_name:	3330	case XTerm_name:
3332	set_title (str);	3331	set_title (str);
3333	/* FALLTHROUGH */	3332	/* FALLTHROUGH */
…		…
3338	set_title (str);	3337	set_title (str);
3339	break;	3338	break;
3340	case XTerm_property:	3339	case XTerm_property:
3341	if (str[0] == '?')	3340	if (str[0] == '?')
3342	{	3341	{
3343	Atom prop = XInternAtom (display->display, str + 1, True);	3342	Atom prop = display->atom (str + 1);
3344	Atom actual_type;	3343	Atom actual_type;
3345	int actual_format;	3344	int actual_format;
3346	unsigned long nitems;	3345	unsigned long nitems;
3347	unsigned long bytes_after;	3346	unsigned long bytes_after;
3348	unsigned char *value = 0;	3347	unsigned char *value = 0;
3349	const char *str = "";	3348	const char *str = "";
3350		3349
3351	if (prop	3350	if (prop
3352	&& XGetWindowProperty (display->display, TermWin.parent[0],	3351	&& XGetWindowProperty (dpy, parent[0],
3353	prop, 0, 1<<16, 0, AnyPropertyType,	3352	prop, 0, 1<<16, 0, AnyPropertyType,
3354	&actual_type, &actual_format,	3353	&actual_type, &actual_format,
3355	&nitems, &bytes_after, &value) == Success	3354	&nitems, &bytes_after, &value) == Success
3356	&& actual_type != None	3355	&& actual_type != None
3357	&& actual_format == 8)	3356	&& actual_format == 8)
3358	str = (const char *)(value);	3357	str = (const char *)(value);
3359		3358
3360	tt_printf ("\033]%d;%s%c", XTerm_property, str, resp);	3359	tt_printf ("\033]%d;%s%c", op, str, resp);
3361		3360
3362	XFree (value);	3361	XFree (value);
3363	}	3362	}
3364	else	3363	else
3365	{	3364	{
3366	char *eq = strchr (str, '='); // constness lost, but verified to be ok	3365	char *eq = strchr (str, '=');
3367		3366
3368	if (eq)	3367	if (eq)
3369	{	3368	{
3370	*eq = 0;	3369	*eq = 0;
3371	XChangeProperty (display->display, TermWin.parent[0],	3370	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	}	3371	}
3376	else	3372	else
3377	XDeleteProperty (display->display, TermWin.parent[0],	3373	XDeleteProperty (dpy, parent[0],
3378	display->atom (str));	3374	display->atom (str));
3379	}	3375	}
3380	break;	3376	break;
3381		3377
3382	case XTerm_Color:	3378	case XTerm_Color:
3383	for (buf = (char *)str; buf && *buf;)	3379	for (buf = (char *)str; buf && *buf;)
3384	{	3380	{
3385	if ((name = STRCHR (buf, ';')) == NULL)	3381	if ((name = strchr (buf, ';')) == NULL)
3386	break;	3382	break;
3387		3383
3388	*name++ = '\0';	3384	*name++ = '\0';
3389	color = atoi (buf);	3385	color = atoi (buf) + minCOLOR;
3390		3386
3391	if (color < 0 || color >= TOTAL_COLORS)	3387	if (!IN_RANGE_INC (color, minCOLOR, maxTermCOLOR))
3392	break;	3388	break;
3393		3389
3394	if ((buf = STRCHR (name, ';')) != NULL)	3390	if ((buf = strchr (name, ';')) != NULL)
3395	*buf++ = '\0';	3391	*buf++ = '\0';
3396		3392
3397	if (name[0] == '?' && !name[1])	3393	process_color_seq (op, color, name, resp);
		3394	}
		3395	break;
		3396	case Rxvt_restoreFG:
		3397	case XTerm_Color00:
		3398	process_color_seq (op, Color_fg, str, resp);
		3399	break;
		3400	case Rxvt_restoreBG:
		3401	case XTerm_Color01:
		3402	process_color_seq (op, Color_bg, str, resp);
		3403	break;
		3404	#ifndef NO_CURSORCOLOR
		3405	case XTerm_Color_cursor:
		3406	process_color_seq (op, Color_cursor, str, resp);
		3407	break;
		3408	#endif
		3409	case XTerm_Color_pointer_fg:
		3410	process_color_seq (op, Color_pointer_fg, str, resp);
		3411	break;
		3412	case XTerm_Color_pointer_bg:
		3413	process_color_seq (op, Color_pointer_bg, str, resp);
		3414	break;
		3415	#ifdef OPTION_HC
		3416	case XTerm_Color_HC:
		3417	process_color_seq (op, Color_HC, str, resp);
		3418	break;
		3419	case XTerm_Color_HTC:
		3420	process_color_seq (op, Color_HTC, str, resp);
		3421	break;
		3422	#endif
		3423	#ifndef NO_BOLD_UNDERLINE_REVERSE
		3424	case URxvt_Color_BD:
		3425	process_color_seq (op, Color_BD, str, resp);
		3426	break;
		3427	case URxvt_Color_UL:
		3428	process_color_seq (op, Color_UL, str, resp);
		3429	break;
		3430	case URxvt_Color_IT:
		3431	process_color_seq (op, Color_IT, str, resp);
		3432	break;
		3433	#endif
		3434	case URxvt_Color_border:
		3435	process_color_seq (op, Color_border, str, resp);
		3436	break;
		3437	#if ENABLE_TRANSPARENCY
		3438	case URxvt_Color_tint:
		3439	process_color_seq (op, Color_tint, str, resp);
		3440	{
		3441	bool changed = false;
		3442
		3443	if (ISSET_PIXCOLOR (Color_tint))
		3444	changed = bgPixmap.set_tint (pix_colors_focused [Color_tint]);
		3445	else
		3446	changed = bgPixmap.unset_tint ();
		3447
		3448	if (changed)
		3449	update_background ();
		3450	}
		3451
		3452	break;
		3453	#endif
		3454
		3455	#if BG_IMAGE_FROM_FILE
		3456	case Rxvt_Pixmap:
		3457	if (!strcmp (str, "?"))
		3458	{
		3459	char str[256];
		3460
		3461	sprintf (str, "[%dx%d+%d+%d]",
		3462	min (bgPixmap.h_scale, 32767), min (bgPixmap.v_scale, 32767),
		3463	min (bgPixmap.h_align, 32767), min (bgPixmap.v_align, 32767));
		3464	process_xterm_seq (XTerm_title, str, CHAR_ST);
		3465	}
		3466	else
		3467	{
		3468	int changed = 0;
		3469
		3470	if (*str != ';')
3398	{	3471	{
3399	if (Options & Opt_insecure)	3472	if (bgPixmap.set_file (str)) /* change pixmap */
3400	{	3473	{
3401	unsigned short r, g, b;	3474	changed++;
3402	PixColorsFocused[color + minCOLOR].get (display, r, g, b);	3475	str = strchr (str, ';');
3403	tt_printf ("\033]%d;%d;rgb:%04x/%04x/%04x%c", XTerm_Color, color, r, g, b, resp);	3476	if (str == NULL)
		3477	bgPixmap.set_defaultGeometry ();
		3478	else
		3479	bgPixmap.set_geometry (str+1);
3404	}	3480	}
3405	}	3481	}
3406	else	3482	else
3407	set_window_color (color + minCOLOR, name);	3483	{
		3484	str++;
		3485	if (bgPixmap.set_geometry (str, true))
		3486	changed++;
		3487	}
		3488
		3489	if (changed)
		3490	{
		3491	if (bgPixmap.window_position_sensitive ())
		3492	{
		3493	int x, y;
		3494	get_window_origin (x, y);
		3495	bgPixmap.set_position (x, y);
		3496	}
		3497	update_background ();
		3498	}
3408	}	3499	}
3409	break;	3500	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	3501	#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		3502
3472	case XTerm_logfile:	3503	case XTerm_logfile:
3473	// TODO, when secure mode?	3504	// TODO, when secure mode?
3474	break;	3505	break;
3475		3506
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	3507	#if 0
3523	case XTerm_dumpscreen: /* no error notices */	3508	case Rxvt_dumpscreen: /* no error notices */
3524	{	3509	{
3525	int fd;	3510	int fd;
3526	if ((fd = open (str, O_RDWR | O_CREAT | O_EXCL, 0600)) >= 0)	3511	if ((fd = open (str, O_RDWR | O_CREAT | O_EXCL, 0600)) >= 0)
3527	{	3512	{
3528	scr_dump (fd);	3513	scr_dump (fd);
3529	close (fd);	3514	close (fd);
3530	}	3515	}
3531	}	3516	}
		3517	break;
		3518	#endif
		3519	case XTerm_font:
		3520	op = URxvt_font;
		3521	case URxvt_font:
		3522	#if ENABLE_STYLES
		3523	case URxvt_boldFont:
		3524	case URxvt_italicFont:
		3525	case URxvt_boldItalicFont:
		3526	#endif
		3527	if (query)
		3528	tt_printf ("\33]%d;%-.250s%c", saveop,
		3529	option (Opt_insecure) && fontset[op - URxvt_font]->fontdesc
		3530	? fontset[op - URxvt_font]->fontdesc : "",
		3531	resp);
		3532	else
		3533	{
		3534	const char *&res = rs[Rs_font + (op - URxvt_font)];
		3535
		3536	res = strdup (str);
		3537	allocated.push_back ((void *)res);
		3538	set_fonts ();
		3539	}
		3540	break;
		3541
		3542	case URxvt_version:
		3543	if (query)
		3544	tt_printf ("\33]%d;rxvt-unicode;%-.20s;%c;%c%c",
		3545	op,
		3546	rs[Rs_name], VERSION[0], VERSION[2],
		3547	resp);
		3548	break;
		3549
		3550	#if !ENABLE_MINIMAL
		3551	case URxvt_locale:
		3552	if (query)
		3553	tt_printf ("\33]%d;%-.250s%c", op, option (Opt_insecure) ? locale : "", resp);
		3554	else
		3555	{
		3556	set_locale (str);
		3557	pty->set_utf8_mode (enc_utf8);
		3558	init_xlocale ();
		3559	}
		3560	break;
		3561
		3562	case URxvt_view_up:
		3563	case URxvt_view_down:
		3564	{
		3565	int lines = atoi (str);
		3566
		3567	if (lines)
		3568	scr_page (op == URxvt_view_up ? UP : DN, lines);
		3569	else
		3570	scr_erase_savelines ();
		3571	}
		3572
		3573	break;
		3574	#endif
		3575
		3576	#if ENABLE_PERL
		3577	case URxvt_perl:
		3578	HOOK_INVOKE ((this, HOOK_OSC_SEQ_PERL, DT_STR, str, DT_STR_LEN, &resp, 1, DT_END));
3532	break;	3579	break;
3533	#endif	3580	#endif
3534	}	3581	}
3535	}	3582	}
3536	/*----------------------------------------------------------------------*/	3583	/*----------------------------------------------------------------------*/
…		…
3550	{	3597	{
3551	int state;	3598	int state;
3552		3599
3553	if (mode == 's')	3600	if (mode == 's')
3554	{	3601	{
3555	SavedModes |= (PrivateModes & bit);	3602	SavedModes |= (priv_modes & bit);
3556	return -1;	3603	return -1;
3557	}	3604	}
3558	else	3605	else
3559	{	3606	{
3560	if (mode == 'r')	3607	if (mode == 'r')
3561	state = (SavedModes & bit) ? 1 : 0; /* no overlapping */	3608	state = (SavedModes & bit) ? 1 : 0; /* no overlapping */
3562	else	3609	else
3563	state = (mode == 't') ? ! (PrivateModes & bit) : mode;	3610	state = (mode == 't') ? ! (priv_modes & bit) : mode;
3564	PrivMode (state, bit);	3611
		3612	set_privmode (bit, state);
3565	}	3613	}
3566		3614
3567	return state;	3615	return state;
3568	}	3616	}
3569		3617
3570	/* we're not using priv _yet_ */	3618	/* we're not using priv _yet_ */
3571	void	3619	void
3572	rxvt_term::process_terminal_mode (int mode, int priv __attribute__ ((unused)), unsigned int nargs, const int *arg)	3620	rxvt_term::process_terminal_mode (int mode, int priv UNUSED, unsigned int nargs, const int *arg)
3573	{	3621	{
3574	unsigned int i, j;	3622	unsigned int i, j;
3575	int state;	3623	int state;
3576		3624
3577	static const struct	3625	static const struct
3578	{	3626	{
3579	const int argval;	3627	const int argval;
3580	const unsigned long bit;	3628	const unsigned long bit;
3581	}
3582
3583	argtopriv[] = {	3629	} argtopriv[] = {
3584	{ 1, PrivMode_aplCUR },	3630	{ 1, PrivMode_aplCUR }, // DECCKM
3585	{ 2, PrivMode_vt52 },	3631	{ 2, PrivMode_vt52 },
3586	{ 3, PrivMode_132 },	3632	{ 3, PrivMode_132 }, // DECCOLM
3587	{ 4, PrivMode_smoothScroll },	3633	{ 4, PrivMode_smoothScroll }, // DECSCLM
3588	{ 5, PrivMode_rVideo },	3634	{ 5, PrivMode_rVideo }, // DECSCNM
3589	{ 6, PrivMode_relOrigin },	3635	{ 6, PrivMode_relOrigin }, // DECOM
3590	{ 7, PrivMode_Autowrap },	3636	{ 7, PrivMode_Autowrap }, // DECAWM
		3637	// 8, auto-repeat keys // DECARM
3591	{ 9, PrivMode_MouseX10 },	3638	{ 9, PrivMode_MouseX10 },
3592	#ifdef menuBar_esc	3639	// 18 end FF to printer after print screen
3593	{ menuBar_esc, PrivMode_menuBar },	3640	// 19 Print screen prints full screen/scroll region
3594	#endif	3641	{ 25, PrivMode_VisibleCursor }, // cnorm/cvvis/civis
3595	#ifdef scrollBar_esc	3642	#ifdef scrollBar_esc
3596	{ scrollBar_esc, PrivMode_scrollBar },	3643	{ scrollBar_esc, PrivMode_scrollBar },
3597	#endif	3644	#endif
3598	// 18, 19 printing-related
3599	{ 25, PrivMode_VisibleCursor },
3600	// 30 show scrollbar rxvt. extension
3601	{ 35, PrivMode_ShiftKeys }, // rxvt extension	3645	{ 35, PrivMode_ShiftKeys }, // rxvt extension
		3646	// 38, tektronix mode // DECTEK
3602	{ 40, PrivMode_132OK },	3647	{ 40, PrivMode_132OK },
3603	// 41 xterm more fixes NYI	3648	// 41 xterm more fixes NYI
3604	// 45 margin bell NYI	3649	// 45 margin bell NYI
3605	// 46 start logging	3650	// 46 start logging
3606	{ 47, PrivMode_Screen },	3651	{ 47, PrivMode_Screen },
3607	{ 66, PrivMode_aplKP },	3652	{ 66, PrivMode_aplKP }, // DECPAM/DECPNM
3608	#ifndef NO_BACKSPACE_KEY	3653	#ifndef NO_BACKSPACE_KEY
3609	{ 67, PrivMode_BackSpace },	3654	{ 67, PrivMode_BackSpace }, // DECBKM
3610	#endif	3655	#endif
3611	{ 1000, PrivMode_MouseX11 },	3656	{ 1000, PrivMode_MouseX11 },
3612	// 1001 Use Hilite Mouse Tracking. NYI, TODO	3657	{ 1002, PrivMode_MouseBtnEvent },
3613	// 1002 Use Cell Motion Mouse Tracking. NYI, TODO	3658	{ 1003, PrivMode_MouseAnyEvent },
3614	// 1003 Use All Motion Mouse Tracking. NYI, TODO
3615	{ 1010, PrivMode_TtyOutputInh }, // rxvt extension	3659	{ 1010, PrivMode_TtyOutputInh }, // rxvt extension
3616	{ 1011, PrivMode_Keypress }, // rxvt extension	3660	{ 1011, PrivMode_Keypress }, // rxvt extension
3617	// 1035 enable modifiers for alt, numlock NYI	3661	// 1035 enable modifiers for alt, numlock NYI
3618	// 1036 send ESC for meta keys NYI	3662	// 1036 send ESC for meta keys NYI
3619	// 1037 send DEL for keypad delete NYI	3663	// 1037 send DEL for keypad delete NYI
3620	{ 1047, PrivMode_Screen },	3664	{ 1047, PrivMode_Screen },
3621	// 1048 save and restore cursor	3665	// 1048 save and restore cursor
3622	{ 1049, PrivMode_Screen }, /* xterm extension, clear screen on ti rather than te */	3666	{ 1049, PrivMode_Screen }, /* xterm extension, clear screen on ti rather than te */
3623	// 1051, 1052, 1060, 1061 keyboard emulation NYI	3667	// 1051, 1052, 1060, 1061 keyboard emulation NYI
		3668	{ 2004, PrivMode_BracketPaste },
3624	};	3669	};
3625		3670
3626	if (nargs == 0)	3671	if (nargs == 0)
3627	return;	3672	return;
3628		3673
…		…
3645	}	3690	}
3646		3691
3647	/* extra handling for values with state unkept */	3692	/* extra handling for values with state unkept */
3648	switch (arg[i])	3693	switch (arg[i])
3649	{	3694	{
		3695	#if ENABLE_STYLES
		3696	case 1021:
		3697	set_option (Opt_intensityStyles, mode);
		3698
		3699	scr_touch (true);
		3700	break;
		3701	#endif
3650	case 1048: /* alternative cursor save */	3702	case 1048: /* alternative cursor save */
3651	if (Options & Opt_secondaryScreen)	3703	if (option (Opt_secondaryScreen))
3652	if (mode == 0)	3704	if (mode == 0)
3653	scr_cursor (RESTORE);	3705	scr_cursor (RESTORE);
3654	else if (mode == 1)	3706	else if (mode == 1)
3655	scr_cursor (SAVE);	3707	scr_cursor (SAVE);
3656	break;	3708	break;
…		…
3664	case 2: /* VT52 mode */	3716	case 2: /* VT52 mode */
3665	/* oddball mode. should be set regardless of set/reset	3717	/* oddball mode. should be set regardless of set/reset
3666	* parameter. Return from VT52 mode with an ESC < from	3718	* parameter. Return from VT52 mode with an ESC < from
3667	* within VT52 mode	3719	* within VT52 mode
3668	*/	3720	*/
3669	PrivMode (1, PrivMode_vt52);	3721	set_privmode (PrivMode_vt52, 1);
3670	break;	3722	break;
3671	case 3: /* 80/132 */	3723	case 3: /* 80/132 */
3672	if (PrivateModes & PrivMode_132OK)	3724	if (priv_modes & PrivMode_132OK)
3673	set_widthheight (((state ? 132 : 80) * TermWin.fwidth), TermWin.height);	3725	set_widthheight ((state ? 132 : 80) * fwidth, 24 * fheight);
3674	break;	3726	break;
3675	case 4: /* smooth scrolling */	3727	case 4: /* smooth scrolling */
3676	if (state)	3728	set_option (Opt_jumpScroll, !state);
3677	Options &= ~Opt_jumpScroll;
3678	else
3679	Options |= Opt_jumpScroll;
3680	break;	3729	break;
3681	case 5: /* reverse video */	3730	case 5: /* reverse video */
3682	scr_rvideo_mode (state);	3731	scr_rvideo_mode (state);
3683	break;	3732	break;
3684	case 6: /* relative/absolute origins */	3733	case 6: /* relative/absolute origins */
…		…
3688	scr_autowrap (state);	3737	scr_autowrap (state);
3689	break;	3738	break;
3690	/* case 8: - auto repeat, can't do on a per window basis */	3739	/* case 8: - auto repeat, can't do on a per window basis */
3691	case 9: /* X10 mouse reporting */	3740	case 9: /* X10 mouse reporting */
3692	if (state) /* orthogonal */	3741	if (state) /* orthogonal */
3693	PrivateModes &= ~PrivMode_MouseX11;	3742	priv_modes &= ~(PrivMode_MouseX11|PrivMode_MouseBtnEvent|PrivMode_MouseAnyEvent);
3694	break;	3743	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	3744	#ifdef scrollBar_esc
3703	case scrollBar_esc:	3745	case scrollBar_esc:
3704	if (scrollbar_mapping (state))	3746	if (scrollBar.map (state))
3705	{	3747	{
3706	resize_all_windows (0, 0, 0);	3748	resize_all_windows (0, 0, 0);
3707	scr_touch (true);	3749	scr_touch (true);
3708	}	3750	}
3709	break;	3751	break;
…		…
3718	break;	3760	break;
3719	/* case 66: - application key pad */	3761	/* case 66: - application key pad */
3720	/* case 67: - backspace key */	3762	/* case 67: - backspace key */
3721	case 1000: /* X11 mouse reporting */	3763	case 1000: /* X11 mouse reporting */
3722	if (state) /* orthogonal */	3764	if (state) /* orthogonal */
3723	PrivateModes &= ~PrivMode_MouseX10;	3765	priv_modes &= ~(PrivMode_MouseX10|PrivMode_MouseBtnEvent|PrivMode_MouseAnyEvent);
3724	break;	3766	break;
3725	#if 0
3726	case 1001:	3767	case 1002:
3727	break; /* X11 mouse highlighting */	3768	case 1003:
3728	#endif	3769	if (state)
		3770	{
		3771	priv_modes &= ~(PrivMode_MouseX10|PrivMode_MouseX11);
		3772	priv_modes &= arg[i] == 1003 ? ~PrivMode_MouseBtnEvent : ~PrivMode_MouseAnyEvent;
		3773	vt_emask_mouse = PointerMotionMask;
		3774	}
		3775	else
		3776	vt_emask_mouse = NoEventMask;
		3777
		3778	vt_select_input ();
		3779	break;
3729	case 1010: /* scroll to bottom on TTY output inhibit */	3780	case 1010: /* scroll to bottom on TTY output inhibit */
3730	if (state)
3731	Options &= ~Opt_scrollTtyOutput;
3732	else
3733	Options |= Opt_scrollTtyOutput;	3781	set_option (Opt_scrollTtyOutput, !state);
3734	break;	3782	break;
3735	case 1011: /* scroll to bottom on key press */	3783	case 1011: /* scroll to bottom on key press */
3736	if (state)
3737	Options |= Opt_scrollTtyKeypress;	3784	set_option (Opt_scrollTtyKeypress, state);
3738	else
3739	Options &= ~Opt_scrollTtyKeypress;
3740	break;	3785	break;
3741	case 1047: /* secondary screen w/ clearing last */	3786	case 1047: /* secondary screen w/ clearing last */
3742	if (Options & Opt_secondaryScreen)	3787	if (option (Opt_secondaryScreen))
3743	if (current_screen != PRIMARY)	3788	if (!state)
3744	scr_erase_screen (2);	3789	scr_erase_screen (2);
		3790
3745	scr_change_screen (state);	3791	scr_change_screen (state);
3746	break;	3792	break;
3747	case 1049: /* secondary screen w/ clearing first */	3793	case 1049: /* secondary screen w/ clearing first */
		3794	if (option (Opt_secondaryScreen))
		3795	if (state)
		3796	scr_cursor (SAVE);
		3797
3748	scr_change_screen (state);	3798	scr_change_screen (state);
		3799
3749	if (Options & Opt_secondaryScreen)	3800	if (option (Opt_secondaryScreen))
3750	if (current_screen != PRIMARY)	3801	if (state)
3751	scr_erase_screen (2);	3802	scr_erase_screen (2);
		3803	else
		3804	scr_cursor (RESTORE);
3752	break;	3805	break;
3753	default:	3806	default:
3754	break;	3807	break;
3755	}	3808	}
3756	}	3809	}
…		…
3780	rendset = 0, rendstyle = ~RS_None;	3833	rendset = 0, rendstyle = ~RS_None;
3781	break;	3834	break;
3782	case 1:	3835	case 1:
3783	rendset = 1, rendstyle = RS_Bold;	3836	rendset = 1, rendstyle = RS_Bold;
3784	break;	3837	break;
3785	//case 2: // faint or second colour	3838	//case 2: // low intensity
		3839	case 3:
		3840	rendset = 1, rendstyle = RS_Italic;
		3841	break;
3786	case 4:	3842	case 4:
3787	rendset = 1, rendstyle = RS_Uline;	3843	rendset = 1, rendstyle = RS_Uline;
3788	break;	3844	break;
3789	case 5: // slowly blinking	3845	case 5: // slowly blinking
3790	case 6: // rapidly blinking	3846	case 6: // rapidly blinking
…		…
3802	//case 11: // scoansi acs on, first alt font	3858	//case 11: // scoansi acs on, first alt font
3803	//case 12: // scoansi acs on, |0x80, second alt font	3859	//case 12: // scoansi acs on, |0x80, second alt font
3804	//...	3860	//...
3805	//case 19: // ninth alt font	3861	//case 19: // ninth alt font
3806	//case 20: // gothic	3862	//case 20: // gothic
3807	case 21: // disable bold, faint	3863	case 21: // disable bold, faint, sometimes doubly underlined (iso 8613)
3808	rendset = 0, rendstyle = RS_Bold;	3864	rendset = 0, rendstyle = RS_Bold;
3809	break;	3865	break;
3810	case 22:	3866	case 22: // normal intensity
3811	rendset = 0, rendstyle = RS_Bold;	3867	rendset = 0, rendstyle = RS_Bold;
3812	break;	3868	break;
3813	//case 23: disable italic	3869	case 23: // disable italic
		3870	rendset = 0, rendstyle = RS_Italic;
		3871	break;
3814	case 24:	3872	case 24:
3815	rendset = 0, rendstyle = RS_Uline;	3873	rendset = 0, rendstyle = RS_Uline;
3816	break;	3874	break;
3817	case 25:	3875	case 25:
		3876	rendset = 0, rendstyle = RS_Blink;
		3877	break;
		3878	case 26: // variable spacing (iso 8613)
3818	rendset = 0, rendstyle = RS_Blink;	3879	rendset = 0, rendstyle = RS_Blink;
3819	break;	3880	break;
3820	case 27:	3881	case 27:
3821	rendset = 0, rendstyle = RS_RVid;	3882	rendset = 0, rendstyle = RS_RVid;
3822	break;	3883	break;
…		…
3840	case 35:	3901	case 35:
3841	case 36:	3902	case 36:
3842	case 37:	3903	case 37:
3843	scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);	3904	scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);
3844	break;	3905	break;
3845	#ifdef TTY_256COLOR	3906	case 38: // set fg color, ISO 8613-6
3846	case 38:
3847	if (nargs > i + 2 && arg[i + 1] == 5)	3907	if (nargs > i + 2 && arg[i + 1] == 5)
3848	{	3908	{
3849	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg);	3909	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg);
3850	i += 2;	3910	i += 2;
3851	}	3911	}
3852	break;	3912	break;
3853	#endif
3854	case 39: /* default fg */	3913	case 39: /* default fg */
3855	scr_color (Color_fg, Color_fg);	3914	scr_color (Color_fg, Color_fg);
3856	break;	3915	break;
3857		3916
3858	case 40:	3917	case 40:
…		…
3863	case 45:	3922	case 45:
3864	case 46:	3923	case 46:
3865	case 47:	3924	case 47:
3866	scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);	3925	scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);
3867	break;	3926	break;
3868	#ifdef TTY_256COLOR	3927	case 48: // set bg color, ISO 8613-6
3869	case 48:
3870	if (nargs > i + 2 && arg[i + 1] == 5)	3928	if (nargs > i + 2 && arg[i + 1] == 5)
3871	{	3929	{
3872	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg);	3930	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg);
3873	i += 2;	3931	i += 2;
3874	}	3932	}
3875	break;	3933	break;
3876	#endif
3877	case 49: /* default bg */	3934	case 49: /* default bg */
3878	scr_color (Color_bg, Color_bg);	3935	scr_color (Color_bg, Color_bg);
3879	break;	3936	break;
3880		3937
3881	#ifndef NO_BRIGHTCOLOR	3938	//case 50: // not variable spacing
		3939
		3940	#if !ENABLE_MINIMAL
3882	case 90:	3941	case 90:
3883	case 91: /* set bright fg color */	3942	case 91: /* set bright fg color */
3884	case 92:	3943	case 92:
3885	case 93:	3944	case 93:
3886	case 94:	3945	case 94:
3887	case 95:	3946	case 95:
3888	case 96:	3947	case 96:
3889	case 97:	3948	case 97:
3890	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 90)),	3949	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 90)), Color_fg);
3891	Color_fg);
3892	break;	3950	break;
3893	case 100:	3951	case 100:
3894	case 101: /* set bright bg color */	3952	case 101: /* set bright bg color */
3895	case 102:	3953	case 102:
3896	case 103:	3954	case 103:
3897	case 104:	3955	case 104:
3898	case 105:	3956	case 105:
3899	case 106:	3957	case 106:
3900	case 107:	3958	case 107:
3901	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 100)),	3959	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 100)), Color_bg);
3902	Color_bg);
3903	break;	3960	break;
3904	#endif	3961	#endif
3905
3906	}	3962	}
3907	}	3963	}
3908	}	3964	}
3909	/*}}} */	3965	/*}}} */
3910		3966
…		…
3913	rxvt_term::process_graphics ()	3969	rxvt_term::process_graphics ()
3914	{	3970	{
3915	unicode_t ch, cmd = cmd_getc ();	3971	unicode_t ch, cmd = cmd_getc ();
3916		3972
3917	if (cmd == 'Q')	3973	if (cmd == 'Q')
		3974	{
3918	{ /* query graphics */	3975	/* query graphics */
3919	tt_printf ("\033G0\n"); /* no graphics */	3976	tt_printf ("\033G0\012"); /* no graphics */
3920	return;	3977	return;
3921	}	3978	}
3922	/* swallow other graphics sequences until terminating ':' */	3979	/* swallow other graphics sequences until terminating ':' */
3923	do	3980	do
3924	ch = cmd_getc ();	3981	ch = cmd_getc ();
…		…
3934	*/	3991	*/
3935	void	3992	void
3936	rxvt_term::tt_printf (const char *fmt,...)	3993	rxvt_term::tt_printf (const char *fmt,...)
3937	{	3994	{
3938	va_list arg_ptr;	3995	va_list arg_ptr;
3939	unsigned char buf[256];	3996	char buf[256];
3940		3997
3941	va_start (arg_ptr, fmt);	3998	va_start (arg_ptr, fmt);
3942	vsnprintf ((char *)buf, 256, fmt, arg_ptr);	3999	vsnprintf ((char *)buf, 256, fmt, arg_ptr);
3943	va_end (arg_ptr);	4000	va_end (arg_ptr);
3944	tt_write (buf, STRLEN (buf));	4001	tt_write (buf, strlen (buf));
3945	}	4002	}
3946		4003
3947	/* ---------------------------------------------------------------------- */	4004	/* ---------------------------------------------------------------------- */
3948	/* Write data to the pty as typed by the user, pasted with the mouse,	4005	/* 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.	4006	* or generated by us in response to a query ESC sequence.
3950	*/	4007	*/
3951	void
3952	rxvt_term::tt_write (const unsigned char *data, unsigned int len)
3953	{
3954	enum { MAX_PTY_WRITE = 255 }; // minimum MAX_INPUT	4008	const unsigned int MAX_PTY_WRITE = 255; // minimum MAX_INPUT
3955		4009
3956	if (len)	4010	void
		4011	rxvt_term::tt_write (const char *data, unsigned int len)
		4012	{
		4013	if (HOOK_INVOKE ((this, HOOK_TT_WRITE, DT_STR_LEN, data, len, DT_END)))
		4014	return;
		4015
		4016	if (pty->pty < 0)
		4017	return;
		4018
		4019	if (v_buflen == 0)
		4020	{
		4021	ssize_t written = write (pty->pty, data, min (len, MAX_PTY_WRITE));
		4022
		4023	if ((unsigned int)written == len)
		4024	return;
		4025
		4026	data += written;
		4027	len -= written;
3957	{	4028	}
		4029
		4030	v_buffer = (char *)realloc (v_buffer, v_buflen + len);
		4031
		4032	memcpy (v_buffer + v_buflen, data, len);
		4033	v_buflen += len;
		4034
		4035	pty_ev.set (ev::READ | ev::WRITE);
		4036	}
		4037
		4038	void rxvt_term::pty_write ()
		4039	{
		4040	int written = write (pty->pty, v_buffer, min (v_buflen, MAX_PTY_WRITE));
		4041
		4042	if (written > 0)
		4043	{
		4044	v_buflen -= written;
		4045
3958	if (v_buflen == 0)	4046	if (v_buflen == 0)
3959	{	4047	{
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);	4048	free (v_buffer);
3987	v_buffer = 0;	4049	v_buffer = 0;
3988	v_buflen = 0;
3989		4050
3990	pty_ev.set (EVENT_READ);	4051	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;	4052	return;
4003	}	4053	}
		4054
		4055	memmove (v_buffer, v_buffer + written, v_buflen);
4004	}	4056	}
		4057	else if (written != -1 || (errno != EAGAIN && errno != EINTR))
		4058	pty_ev.set (ev::READ);
4005	}	4059	}
4006		4060
4007	/*----------------------- end-of-file (C source) -----------------------*/	4061	/*----------------------- end-of-file (C source) -----------------------*/
4008		4062

Diff Legend

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