ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/rxvt-unicode/src/command.C

Comparing rxvt-unicode/src/command.C (file contents):
Revision 1.93 by pcg, Thu Apr 8 20:31:45 2004 UTC vs.
Revision 1.507 by sf-exg, Wed Apr 11 13:39:51 2012 UTC

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

Diff Legend

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