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.506 by sf-exg, Wed Apr 11 10:20:00 2012 UTC vs.
Revision 1.551 by sf-exg, Wed Jul 16 14:29:23 2014 UTC

…		…
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>
7	* - original version	7	* - original version
8	* Copyright (c) 1994 Robert Nation <nation@rocket.sanders.lockheed.com>	8	* Copyright (c) 1994 Robert Nation <nation@rocket.sanders.lockheed.com>
9	* - extensive modifications	9	* - extensive modifications
10	* Copyright (c) 1995 Garrett D'Amore <garrett@netcom.com>	10	* Copyright (c) 1995 Garrett D'Amore <garrett@netcom.com>
11	* - vt100 printing	11	* - vt100 printing
12	* Copyright (c) 1995 Steven Hirsch <hirsch@emba.uvm.edu>	12	* Copyright (c) 1995 Steven Hirsch <hirsch@emba.uvm.edu>
13	* - X11 mouse report mode and support for	13	* - X11 mouse report mode and support for
14	* DEC "private mode" save/restore functions.	14	* DEC "private mode" save/restore functions.
…		…
20	* Copyright (c) 1997 Raul Garcia Garcia <rgg@tid.es>	20	* Copyright (c) 1997 Raul Garcia Garcia <rgg@tid.es>
21	* - modification and cleanups for Solaris 2.x	21	* - modification and cleanups for Solaris 2.x
22	* and Linux 1.2.x	22	* and Linux 1.2.x
23	* Copyright (c) 1997,1998 Oezguer Kesim <kesim@math.fu-berlin.de>	23	* Copyright (c) 1997,1998 Oezguer Kesim <kesim@math.fu-berlin.de>
24	* Copyright (c) 1998-2001 Geoff Wing <gcw@pobox.com>	24	* Copyright (c) 1998-2001 Geoff Wing <gcw@pobox.com>
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-2011 Marc Lehmann <schmorp@schmorp.de>	30	* Copyright (c) 2003-2014 Marc Lehmann <schmorp@schmorp.de>
31	* Copyright (c) 2007 Emanuele Giaquinta <e.giaquinta@glauco.it>	31	* Copyright (c) 2007 Emanuele Giaquinta <e.giaquinta@glauco.it>
32	*	32	*
33	* 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
34	* 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
35	* the Free Software Foundation; either version 2 of the License, or	35	* the Free Software Foundation; either version 3 of the License, or
36	* (at your option) any later version.	36	* (at your option) any later version.
37	*	37	*
38	* This program is distributed in the hope that it will be useful,	38	* This program is distributed in the hope that it will be useful,
39	* but WITHOUT ANY WARRANTY; without even the implied warranty of	39	* but WITHOUT ANY WARRANTY; without even the implied warranty of
40	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	40	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
…		…
131	XK_KP_Space, 0x2422,	131	XK_KP_Space, 0x2422,
132	#endif	132	#endif
133	0,	133	0,
134	};	134	};
135		135
136	void	136	void ecb_cold
137	rxvt_term::iso14755_54 (int x, int y)	137	rxvt_term::iso14755_54 (int x, int y)
138	{	138	{
139	x = Pixel2Col (x);	139	x = Pixel2Col (x);
140	y = Pixel2Row (y);	140	y = Pixel2Row (y);
141		141
…		…
149		149
150	text_t t = l.t[x];	150	text_t t = l.t[x];
151		151
152	if (t != NOCHAR || !x)	152	if (t != NOCHAR || !x)
153	{	153	{
154	iso14755_51 (l.t[x], l.r[x], x, y);	154	iso14755_51 (l.t[x], l.r[x], x, y, view_start);
155	iso14755buf = ISO_14755_54;	155	iso14755buf = ISO_14755_54;
156	break;	156	break;
157	}	157	}
158		158
159	x--;	159	x--;
160	}	160	}
161	}	161	}
162		162
163	void	163	void ecb_cold
164	rxvt_term::iso14755_51 (unicode_t ch, rend_t r, int x, int y)	164	rxvt_term::iso14755_51 (unicode_t ch, rend_t r, int x, int y, int y2)
165	{	165	{
166	rxvt_fontset *fs = FONTSET (r);	166	rxvt_fontset *fs = FONTSET (r);
167	wchar_t *chr, *alloc, ch2, **fname;	167	wchar_t *chr, *alloc, ch2, **fname;
168	int len;	168	int len;
169		169
…		…
181		181
182	alloc = 0;	182	alloc = 0;
183	chr = &ch2;	183	chr = &ch2;
184	len = 1;	184	len = 1;
185	}	185	}
		186
		187	char rowcol[40];
		188	snprintf (rowcol, sizeof rowcol, "col %d row %d @%d", x, y, y2);
186		189
187	char attr[80]; // plenty	190	char attr[80]; // plenty
188		191
189	sprintf (attr, "%08x = fg %d bg %d%s%s%s%s%s%s",	192	sprintf (attr, "%08x = fg %d bg %d%s%s%s%s%s%s",
190	(int)r,	193	(int)r,
…		…
203	rxvt_font *f = (*fs)[fs->find_font_idx (chr[i])];	206	rxvt_font *f = (*fs)[fs->find_font_idx (chr[i])];
204	fname[i] = rxvt_utf8towcs (f->name);	207	fname[i] = rxvt_utf8towcs (f->name);
205	max_it (width, wcswidth (fname[i], wcslen (fname[i])));	208	max_it (width, wcswidth (fname[i], wcslen (fname[i])));
206	}	209	}
207		210
208	max_it (width, 8+5); // for char + hex
209	max_it (width, strlen (attr));	211	max_it (width, strlen (attr));
210		212
211	if (y >= 0)	213	if (y >= 0)
212	{	214	{
213	y = (y >= nrow - len - 4 && x < width + 2) ? 0 : -1;	215	y = (y >= nrow - len - 4 && x < width + 2) ? 0 : -1;
214	x = 0;	216	x = 0;
215	}	217	}
216		218
217	scr_overlay_new (x, y, width, len * 2 + 1);	219	scr_overlay_new (x, y, width, len * 2 + 2);
		220
		221	scr_overlay_set (0, 0, rowcol);
218		222
219	r = SET_STYLE (OVERLAY_RSTYLE, GET_STYLE (r));	223	r = SET_STYLE (OVERLAY_RSTYLE, GET_STYLE (r));
220		224
221	for (int y = 0; y < len; y++)	225	for (int y = 0; y < len; y++)
222	{	226	{
223	char buf[9];	227	char buf[9];
224		228
225	ch = *chr++;	229	ch = *chr++;
226		230
227	sprintf (buf, "%8x", ch);	231	sprintf (buf, "%8x", ch);
228	scr_overlay_set (0, y, buf);	232	scr_overlay_set (0, y + 1, buf);
229	scr_overlay_set (9, y, '=');	233	scr_overlay_set (9, y + 1, '=');
230	# if !UNICODE_3	234	# if !UNICODE_3
231	if (ch >= 0x10000)	235	if (ch >= 0x10000)
232	ch = 0xfffd;	236	ch = 0xfffd;
233	# endif	237	# endif
234	scr_overlay_set (11, y, ch, r);	238	scr_overlay_set (11, y + 1, ch, r);
235		239
236	if (WCWIDTH (ch) >= 2)	240	if (WCWIDTH (ch) >= 2)
237	scr_overlay_set (12, y, NOCHAR, r);	241	scr_overlay_set (12, y + 1, NOCHAR, r);
238	}	242	}
239		243
240	// {	244	// {
241	// char buf[4+4+3+1];	245	// char buf[4+4+3+1];
242	// snprintf (buf, sizeof (buf), "(%.4d|%.4d)", x, y);	246	// snprintf (buf, sizeof (buf), "(%.4d|%.4d)", x, y);
243	// scr_overlay_set (0, 0, buf);	247	// scr_overlay_set (0, 0, buf);
244	// }	248	// }
245	scr_overlay_set (0, len , attr);	249	scr_overlay_set (0, len + 1, attr);
246	for (int i = 0; i < len; i++)	250	for (int i = 0; i < len; i++)
247	{	251	{
248	scr_overlay_set (0, len + 1 + i, fname[i]);	252	scr_overlay_set (0, len + 2 + i, fname[i]);
249	free (fname[i]);	253	free (fname[i]);
250	}	254	}
251		255
252	# if ENABLE_COMBINING	256	# if ENABLE_COMBINING
253	if (alloc)	257	if (alloc)
254	delete [] alloc;	258	delete [] alloc;
255	# endif	259	# endif
256	}	260	}
257	#endif	261	#endif
258		262
259	void	263	void ecb_cold
260	rxvt_term::commit_iso14755 ()	264	rxvt_term::commit_iso14755 ()
261	{	265	{
262	wchar_t ch = iso14755buf & ISO_14755_MASK;	266	wchar_t ch = iso14755buf & ISO_14755_MASK;
263		267
264	if (iso14755buf & ISO_14755_51)	268	if (iso14755buf & ISO_14755_51)
…		…
282	}	286	}
283		287
284	iso14755buf = 0;	288	iso14755buf = 0;
285	}	289	}
286		290
287	static int	291	static int ecb_cold
288	hex_keyval (XKeyEvent &ev)	292	hex_keyval (XKeyEvent &ev)
289	{	293	{
290	// check whether this event corresponds to a hex digit	294	// check whether this event corresponds to a hex digit
291	// if the modifiers had not been pressed.	295	// if the modifiers had not been pressed.
292	for (int index = 0; index < 8; index++)	296	for (int index = 0; index < 8; index++)
…		…
301		305
302	return -1;	306	return -1;
303	}	307	}
304	#endif	308	#endif
305		309
306	static inline KeySym	310	static inline KeySym ecb_cold
307	translate_keypad (KeySym keysym, bool kp)	311	translate_keypad (KeySym keysym, bool kp)
308	{	312	{
309	#ifdef XK_KP_Home	313	#ifdef XK_KP_Home
310	static const KeySym keypadtrans[] = {	314	static const KeySym keypadtrans[] = {
311	XK_KP_7, // XK_KP_Home	315	XK_KP_7, // XK_KP_Home
…		…
337	# endif	341	# endif
338	#endif	342	#endif
339	return keysym;	343	return keysym;
340	}	344	}
341		345
342	static inline int	346	static inline int ecb_cold
343	map_function_key (KeySym keysym)	347	map_function_key (KeySym keysym)
344	{	348	{
345	int param = 0;	349	int param = 0;
346		350
347	if (IN_RANGE_INC (keysym, XK_F1, XK_F35))	351	if (IN_RANGE_INC (keysym, XK_F1, XK_F35))
…		…
396	break;	400	break;
397	}	401	}
398	return param;	402	return param;
399	}	403	}
400		404
401	void	405	static inline wchar_t *
		406	rxvt_wcsdup (const wchar_t *str, int len)
		407	{
		408	wchar_t *r = (wchar_t *)rxvt_malloc ((len + 1) * sizeof (wchar_t));
		409	memcpy (r, str, len * sizeof (wchar_t));
		410	r[len] = 0;
		411	return r;
		412	}
		413
		414	void ecb_cold
402	rxvt_term::key_press (XKeyEvent &ev)	415	rxvt_term::key_press (XKeyEvent &ev)
403	{	416	{
404	int ctrl, meta, shft, len;	417	int ctrl, meta, shft, len;
405	KeySym keysym;	418	KeySym keysym;
406	int valid_keysym;	419	int valid_keysym;
407	char kbuf[KBUFSZ];	420	char rkbuf[KBUFSZ + 1];
		421	char *kbuf = rkbuf + 1;
408		422
409	#if ISO_14755	423	#if ISO_14755
410	if (iso14755buf & ISO_14755_52)	424	if (iso14755buf & ISO_14755_52)
411	return;	425	return;
412	#endif	426	#endif
…		…
421	ctrl = ev.state & ControlMask;	435	ctrl = ev.state & ControlMask;
422	meta = ev.state & ModMetaMask;	436	meta = ev.state & ModMetaMask;
423		437
424	kbuf[0] = 0;	438	kbuf[0] = 0;
425		439
426	#ifdef USE_XIM	440	#if USE_XIM
427	if (Input_Context)	441	if (Input_Context)
428	{	442	{
429	Status status_return;	443	Status status_return;
430		444
431	#if 0	445	#if 0
…		…
482	valid_keysym = keysym != NoSymbol;	496	valid_keysym = keysym != NoSymbol;
483	}	497	}
484		498
485	if (valid_keysym)	499	if (valid_keysym)
486	{	500	{
		501	KeySym orig_keysym = keysym;
		502
		503	/* Shift + F1 - F10 generates F11 - F20 */
		504	if (shft && keysym >= XK_F1 && keysym <= XK_F10)
		505	{
		506	keysym += (XK_F11 - XK_F1);
		507	shft = 0; /* turn off Shift */
		508	}
		509
		510	if (keysym >= 0xFF00 && keysym <= 0xFFFF)
		511	{
		512	bool kp = priv_modes & PrivMode_aplKP ? !shft : shft;
		513	unsigned int newlen = 1;
		514
		515	if (ev.state & ModNumLockMask)
		516	kp = false;
		517
		518	keysym = translate_keypad (keysym, kp);
		519
		520	switch (keysym)
		521	{
		522	#ifndef NO_BACKSPACE_KEY
		523	case XK_BackSpace:
		524	if (priv_modes & PrivMode_HaveBackSpace)
		525	{
		526	kbuf[0] = (!! (priv_modes & PrivMode_BackSpace)
		527	^ !!ctrl) ? '\b' : '\177';
		528	kbuf[1] = '\0';
		529	}
		530	else
		531	strcpy (kbuf, rs[Rs_backspace_key]);
		532	break;
		533	#endif
		534	#ifndef NO_DELETE_KEY
		535	case XK_Delete:
		536	strcpy (kbuf, rs[Rs_delete_key]);
		537	break;
		538	#endif
		539	case XK_Tab:
		540	if (shft)
		541	strcpy (kbuf, "\033[Z");
		542	else
		543	{
		544	#ifdef CTRL_TAB_MAKES_META
		545	if (ctrl)
		546	meta = 1;
		547	#endif
		548	#ifdef MOD4_TAB_MAKES_META
		549	if (ev.state & Mod4Mask)
		550	meta = 1;
		551	#endif
		552	newlen = 0;
		553	}
		554	break;
		555
		556	case XK_Up: /* "\033[A" */
		557	case XK_Down: /* "\033[B" */
		558	case XK_Right: /* "\033[C" */
		559	case XK_Left: /* "\033[D" */
		560	strcpy (kbuf, "\033[Z");
		561	kbuf[2] = "DACB"[keysym - XK_Left];
		562	/* do Shift first */
		563	if (shft)
		564	kbuf[2] = "dacb"[keysym - XK_Left];
		565	else if (ctrl)
		566	{
		567	kbuf[1] = 'O';
		568	kbuf[2] = "dacb"[keysym - XK_Left];
		569	}
		570	else if (priv_modes & PrivMode_aplCUR)
		571	kbuf[1] = 'O';
		572	break;
		573
		574	case XK_KP_Enter:
		575	/* allow shift to override */
		576	if (kp)
		577	{
		578	strcpy (kbuf, "\033OM");
		579	break;
		580	}
		581
		582	/* FALLTHROUGH */
		583
		584	case XK_Return:
		585	if (priv_modes & PrivMode_LFNL)
		586	{
		587	kbuf[0] = '\015';
		588	kbuf[1] = '\012';
		589	kbuf[2] = '\0';
		590	}
		591	else
		592	{
		593	kbuf[0] = '\015';
		594	kbuf[1] = '\0';
		595	}
		596	break;
		597
		598	case XK_KP_F1: /* "\033OP" */
		599	case XK_KP_F2: /* "\033OQ" */
		600	case XK_KP_F3: /* "\033OR" */
		601	case XK_KP_F4: /* "\033OS" */
		602	strcpy (kbuf, "\033OP");
		603	kbuf[2] += (keysym - XK_KP_F1);
		604	break;
		605
		606	case XK_KP_Multiply: /* "\033Oj" : "*" */
		607	case XK_KP_Add: /* "\033Ok" : "+" */
		608	case XK_KP_Separator: /* "\033Ol" : "," */
		609	case XK_KP_Subtract: /* "\033Om" : "-" */
		610	case XK_KP_Decimal: /* "\033On" : "." */
		611	case XK_KP_Divide: /* "\033Oo" : "/" */
		612	case XK_KP_0: /* "\033Op" : "0" */
		613	case XK_KP_1: /* "\033Oq" : "1" */
		614	case XK_KP_2: /* "\033Or" : "2" */
		615	case XK_KP_3: /* "\033Os" : "3" */
		616	case XK_KP_4: /* "\033Ot" : "4" */
		617	case XK_KP_5: /* "\033Ou" : "5" */
		618	case XK_KP_6: /* "\033Ov" : "6" */
		619	case XK_KP_7: /* "\033Ow" : "7" */
		620	case XK_KP_8: /* "\033Ox" : "8" */
		621	case XK_KP_9: /* "\033Oy" : "9" */
		622	/* allow shift to override */
		623	if (kp)
		624	{
		625	strcpy (kbuf, "\033Oj");
		626	kbuf[2] += (keysym - XK_KP_Multiply);
		627	}
		628	else
		629	{
		630	kbuf[0] = ('*' + (keysym - XK_KP_Multiply));
		631	kbuf[1] = '\0';
		632	}
		633	break;
		634
		635	default:
		636	{
		637	int param = map_function_key (keysym);
		638	if (param > 0)
		639	sprintf (kbuf,"\033[%d~", param);
		640	else
		641	newlen = 0;
		642	}
		643	break;
		644	}
		645
		646	if (newlen)
		647	len = strlen (kbuf);
		648
		649	if (len > 0)
		650	{
		651	/*
		652	* pass Shift/Control indicators for function keys ending with `~'
		653	*
		654	* eg,
		655	* Prior = "ESC[5~"
		656	* Shift+Prior = "ESC[5$"
		657	* Ctrl+Prior = "ESC[5^"
		658	* Ctrl+Shift+Prior = "ESC[5@"
		659	*/
		660	if (kbuf[0] == C0_ESC && kbuf[1] == '[' && kbuf[len - 1] == '~')
		661	kbuf[len - 1] = (shft ? (ctrl ? '@' : '$') : (ctrl ? '^' : '~'));
		662
		663	/*
		664	* Pass meta for all function keys, if 'meta' option set
		665	*/
		666	#ifdef META8_OPTION
		667	if (meta && (meta_char == 0x80))
		668	kbuf[len - 1] |= 0x80;
		669	#endif
		670	}
		671
		672	}
		673	else if (ctrl && keysym == XK_minus)
		674	{
		675	len = 1;
		676	kbuf[0] = '\037'; /* Ctrl-Minus generates ^_ (31) */
		677	}
		678	else if (keysym == XK_ISO_Left_Tab)
		679	{
		680	strcpy (kbuf, "\033[Z");
		681	len = 3;
		682	}
		683	else
		684	{
		685	#ifdef META8_OPTION
		686	/* set 8-bit on */
		687	if (meta && (meta_char == 0x80))
		688	{
		689	char *ch;
		690
		691	for (ch = kbuf; ch < kbuf + len; ch++)
		692	*ch |= 0x80;
		693
		694	meta = 0;
		695	}
		696	#endif
		697	/* nil */ ;
		698	}
		699
		700	keysym = orig_keysym;
		701	}
		702
		703	/* escape prefix */
		704	if (len && meta
		705	#ifdef META8_OPTION
		706	&& meta_char == C0_ESC
		707	#endif
		708	)
		709	{
		710	*--kbuf = C0_ESC;
		711	len++;
		712	}
		713
		714	if (HOOK_INVOKE ((this, HOOK_KEY_PRESS, DT_XEVENT, &ev, DT_INT, keysym, DT_STR_LEN, kbuf, len, DT_END)))
		715	return;
		716
		717	if (valid_keysym)
		718	{
487	#ifdef KEYSYM_RESOURCE	719	#ifdef KEYSYM_RESOURCE
488	if (keyboard->dispatch (this, keysym, ev.state))	720	if (keyboard->dispatch (this, keysym, ev.state, kbuf, len))
489	return;	721	return;
490	#endif	722	#endif
491		723
492	if (saveLines)	724	if (saveLines)
493	{	725	{
…		…
506	#endif	738	#endif
507	max_it (lnsppg, 1);	739	max_it (lnsppg, 1);
508		740
509	if (keysym == XK_Prior)	741	if (keysym == XK_Prior)
510	{	742	{
511	scr_page (UP, lnsppg);	743	scr_page (lnsppg);
512	return;	744	return;
513	}	745	}
514	else if (keysym == XK_Next)	746	else if (keysym == XK_Next)
515	{	747	{
516	scr_page (DN, lnsppg);	748	scr_page (-lnsppg);
517	return;	749	return;
518	}	750	}
519	}	751	}
520	#ifdef SCROLL_ON_UPDOWN_KEYS	752	#ifdef SCROLL_ON_UPDOWN_KEYS
521	if (IS_SCROLL_MOD)	753	if (IS_SCROLL_MOD)
522	{	754	{
523	if (keysym == XK_Up)	755	if (keysym == XK_Up)
524	{	756	{
525	scr_page (UP, 1);	757	scr_page (1);
526	return;	758	return;
527	}	759	}
528	else if (keysym == XK_Down)	760	else if (keysym == XK_Down)
529	{	761	{
530	scr_page (DN, 1);	762	scr_page (-1);
531	return;	763	return;
532	}	764	}
533	}	765	}
534	#endif	766	#endif
535	#ifdef SCROLL_ON_HOMEEND_KEYS	767	#ifdef SCROLL_ON_HOMEEND_KEYS
536	if (IS_SCROLL_MOD)	768	if (IS_SCROLL_MOD)
537	{	769	{
538	if (keysym == XK_Home)	770	if (keysym == XK_Home)
539	{	771	{
540	scr_move_to (0, 1);	772	scr_changeview (top_row);
541	return;	773	return;
542	}	774	}
543	else if (keysym == XK_End)	775	else if (keysym == XK_End)
544	{	776	{
545	scr_move_to (1, 1);	777	scr_changeview (0);
546	return;	778	return;
547	}	779	}
548	}	780	}
549	#endif	781	#endif
550	}	782	}
551		783
552	if (shft)	784	if (shft)
553	{	785	{
554	/* Shift + F1 - F10 generates F11 - F20 */
555	if (keysym >= XK_F1 && keysym <= XK_F10)
556	{
557	keysym += (XK_F11 - XK_F1);
558	shft = 0; /* turn off Shift */
559	}
560	else if (!ctrl && !meta && (priv_modes & PrivMode_ShiftKeys))	786	if (!ctrl && !meta && (priv_modes & PrivMode_ShiftKeys))
561	{	787	{
562	switch (keysym)	788	switch (keysym)
563	{	789	{
564	/* normal XTerm key bindings */	790	/* normal XTerm key bindings */
565	case XK_Insert: /* Shift+Insert = paste mouse selection */	791	case XK_Insert: /* Shift+Insert = paste mouse selection */
…		…
572	case XK_KP_Subtract: /* Shift+KP_Subtract = smaller font */	798	case XK_KP_Subtract: /* Shift+KP_Subtract = smaller font */
573	return;	799	return;
574	#endif	800	#endif
575	}	801	}
576	}	802	}
		803	}
		804
		805	if (ctrl && meta && (keysym == XK_c || keysym == XK_v))
		806	{
		807	if (keysym == XK_v)
		808	selection_request (ev.time, Sel_Clipboard);
		809	else if (selection.len > 0)
		810	{
		811	free (selection.clip_text);
		812	selection.clip_text = rxvt_wcsdup (selection.text, selection.len);
		813	selection.clip_len = selection.len;
		814	selection_grab (CurrentTime, true);
		815	}
		816
		817	return;
577	}	818	}
578		819
579	#if ENABLE_FRILLS || ISO_14755	820	#if ENABLE_FRILLS || ISO_14755
580	// ISO 14755 support	821	// ISO 14755 support
581	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_51))	822	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_51))
…		…
636	{	877	{
637	scr_printscreen (ctrl | shft);	878	scr_printscreen (ctrl | shft);
638	return;	879	return;
639	}	880	}
640	#endif	881	#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
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:
768	{
769	int param = map_function_key (keysym);
770	if (param > 0)
771	sprintf (kbuf,"\033[%d~", param);
772	else
773	newlen = 0;
774	}
775	break;
776	}
777
778	if (newlen)
779	len = strlen (kbuf);
780
781	if (len > 0)
782	{
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	/*
796	* Pass meta for all function keys, if 'meta' option set
797	*/
798	#ifdef META8_OPTION
799	if (meta && (meta_char == 0x80))
800	kbuf[len - 1] |= 0x80;
801	#endif
802	}
803
804	}
805	else if (ctrl && keysym == XK_minus)
806	{
807	len = 1;
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;
814	}
815	else
816	{
817	#ifdef META8_OPTION
818	/* set 8-bit on */
819	if (meta && (meta_char == 0x80))
820	{
821	char *ch;
822
823	for (ch = kbuf; ch < kbuf + len; ch++)
824	*ch |= 0x80;
825
826	meta = 0;
827	}
828	#endif
829	/* nil */ ;
830	}
831	}	882	}
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		883
836	if (len <= 0)	884	if (len <= 0)
837	return; /* not mapped */	885	return; /* not mapped */
838		886
839	if (option (Opt_scrollTtyKeypress))
840	if (view_start)
841	{
842	view_start = 0;
843	want_refresh = 1;
844	}
845
846	/* escape prefix */
847	if (meta
848	#ifdef META8_OPTION
849	&& meta_char == C0_ESC
850	#endif
851	)
852	{
853	const char ch = C0_ESC;
854	tt_write (&ch, 1);
855	}
856
857	tt_write (kbuf, (unsigned int)len);	887	tt_write_user_input (kbuf, (unsigned int)len);
858	}	888	}
859		889
860	void	890	void ecb_cold
861	rxvt_term::key_release (XKeyEvent &ev)	891	rxvt_term::key_release (XKeyEvent &ev)
862	{	892	{
863	#if (MOUSE_WHEEL && MOUSE_SLIP_WHEELING) || ISO_14755 || ENABLE_PERL	893	#if (MOUSE_WHEEL && MOUSE_SLIP_WHEELING) || ISO_14755 || ENABLE_PERL
864	KeySym keysym;	894	KeySym keysym;
865		895
…		…
937	void	967	void
938	rxvt_term::flush ()	968	rxvt_term::flush ()
939	{	969	{
940	flush_ev.stop ();	970	flush_ev.stop ();
941		971
942	#ifdef HAVE_BG_PIXMAP	972	#ifdef HAVE_IMG
943	if (bg_flags & BG_NEEDS_REFRESH)	973	if (bg_flags & BG_NEEDS_REFRESH)
944	{	974	{
945	bg_flags &= ~BG_NEEDS_REFRESH;	975	bg_flags &= ~BG_NEEDS_REFRESH;
946	scr_touch (false);	976	scr_touch (false);
947	}	977	}
…		…
987	while (row < end_row);	1017	while (row < end_row);
988	}	1018	}
989		1019
990	scr_refresh ();	1020	scr_refresh ();
991	scrollBar.show (1);	1021	scrollBar.show (1);
992	#ifdef USE_XIM	1022	#if USE_XIM
993	im_send_spot ();	1023	im_send_spot ();
994	#endif	1024	#endif
995	}	1025	}
996		1026
997	display->flush ();	1027	display->flush ();
…		…
1018		1048
1019	#ifdef CURSOR_BLINK	1049	#ifdef CURSOR_BLINK
1020	void	1050	void
1021	rxvt_term::cursor_blink_reset ()	1051	rxvt_term::cursor_blink_reset ()
1022	{	1052	{
1023	if (hidden_cursor)	1053	if (hidden_cursor)
1024	{	1054	{
1025	hidden_cursor = 0;	1055	hidden_cursor = 0;
1026	want_refresh = 1;	1056	want_refresh = 1;
1027	}	1057	}
1028		1058
1029	if (option (Opt_cursorBlink))	1059	if (option (Opt_cursorBlink))
1030	cursor_blink_ev.again ();	1060	cursor_blink_ev.again ();
1031	else	1061	else
1032	cursor_blink_ev.stop ();	1062	cursor_blink_ev.stop ();
1033	}	1063	}
1034		1064
1035	void	1065	void
1036	rxvt_term::cursor_blink_cb (ev::timer &w, int revents)	1066	rxvt_term::cursor_blink_cb (ev::timer &w, int revents)
1037	{	1067	{
…		…
1073		1103
1074	#ifdef SELECTION_SCROLLING	1104	#ifdef SELECTION_SCROLLING
1075	void	1105	void
1076	rxvt_term::sel_scroll_cb (ev::timer &w, int revents)	1106	rxvt_term::sel_scroll_cb (ev::timer &w, int revents)
1077	{	1107	{
1078	if (scr_page (scroll_selection_dir, scroll_selection_lines))	1108	if (scr_page (scroll_selection_lines))
1079	{	1109	{
1080	selection_extend (selection_save_x, selection_save_y, selection_save_state);	1110	selection_extend (selection_save_x, selection_save_y, selection_save_state);
1081	want_refresh = 1;	1111	want_refresh = 1;
1082	refresh_check ();	1112	refresh_check ();
1083	}	1113	}
…		…
1088		1118
1089	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)	1119	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
1090	void	1120	void
1091	rxvt_term::slip_wheel_cb (ev::timer &w, int revents)	1121	rxvt_term::slip_wheel_cb (ev::timer &w, int revents)
1092	{	1122	{
1093	if (scr_changeview (view_start - mouse_slip_wheel_speed))	1123	if (scr_page (mouse_slip_wheel_speed))
1094	{	1124	{
1095	want_refresh = 1;	1125	want_refresh = 1;
1096	refresh_check ();	1126	refresh_check ();
1097	}	1127	}
1098		1128
…		…
1219	pty_write ();	1249	pty_write ();
1220		1250
1221	refresh_check ();	1251	refresh_check ();
1222	}	1252	}
1223		1253
1224	void	1254	void ecb_cold
1225	rxvt_term::pointer_unblank ()	1255	rxvt_term::pointer_unblank ()
1226	{	1256	{
1227	XDefineCursor (dpy, vt, TermWin_cursor);	1257	XDefineCursor (dpy, vt, TermWin_cursor);
1228	recolour_cursor ();	1258	recolour_cursor ();
1229		1259
…		…
1234	pointer_ev.start (pointerBlankDelay);	1264	pointer_ev.start (pointerBlankDelay);
1235	#endif	1265	#endif
1236	}	1266	}
1237		1267
1238	#ifdef POINTER_BLANK	1268	#ifdef POINTER_BLANK
1239	void	1269	void ecb_cold
1240	rxvt_term::pointer_blank ()	1270	rxvt_term::pointer_blank ()
1241	{	1271	{
1242	if (!option (Opt_pointerBlank))	1272	if (!option (Opt_pointerBlank))
1243	return;	1273	return;
1244		1274
…		…
1246	XFlush (dpy);	1276	XFlush (dpy);
1247		1277
1248	hidden_pointer = 1;	1278	hidden_pointer = 1;
1249	}	1279	}
1250		1280
1251	void	1281	void ecb_cold
1252	rxvt_term::pointer_cb (ev::timer &w, int revents)	1282	rxvt_term::pointer_cb (ev::timer &w, int revents)
1253	{	1283	{
1254	make_current ();	1284	make_current ();
1255		1285
1256	pointer_blank ();	1286	pointer_blank ();
…		…
1348	32 + x,	1378	32 + x,
1349	32 + y);	1379	32 + y);
1350	}	1380	}
1351		1381
1352	/*{{{ process an X event */	1382	/*{{{ process an X event */
1353	void	1383	void ecb_hot
1354	rxvt_term::x_cb (XEvent &ev)	1384	rxvt_term::x_cb (XEvent &ev)
1355	{	1385	{
1356	make_current ();	1386	make_current ();
1357		1387
1358	dLocal (Display *, dpy);	1388	dLocal (Display *, dpy);
…		…
1461	if (ev.xconfigure.window == parent)	1491	if (ev.xconfigure.window == parent)
1462	{	1492	{
1463	while (XCheckTypedWindowEvent (dpy, ev.xconfigure.window, ConfigureNotify, &ev))	1493	while (XCheckTypedWindowEvent (dpy, ev.xconfigure.window, ConfigureNotify, &ev))
1464	;	1494	;
1465		1495
		1496	bool want_position_change = SHOULD_INVOKE (HOOK_POSITION_CHANGE);
		1497
		1498	bool moved = false;
1466	#ifdef HAVE_BG_PIXMAP	1499	#ifdef HAVE_BG_PIXMAP
1467	bool moved = false;
1468	if (bg_window_position_sensitive ())	1500	if (bg_window_position_sensitive ())
1469	{	1501	{
		1502	want_position_change = true;
		1503	if (bg_img == 0)
		1504	moved = true;
		1505	}
		1506	#endif
		1507
		1508	if (want_position_change)
		1509	{
1470	int x, y;	1510	int x, y;
		1511
1471	if (ev.xconfigure.send_event)	1512	if (ev.xconfigure.send_event)
1472	{	1513	{
1473	x = ev.xconfigure.x;	1514	x = ev.xconfigure.x;
1474	y = ev.xconfigure.y;	1515	y = ev.xconfigure.y;
1475	}	1516	}
1476	else	1517	else
1477	get_window_origin (x, y);	1518	get_window_origin (x, y);
1478		1519
1479	if (bg_set_position (x, y)	1520	if (x != parent_x || y != parent_y)
1480	|| !(bg_flags & BG_IS_VALID))	1521	{
		1522	parent_x = x;
		1523	parent_y = y;
		1524	HOOK_INVOKE ((this, HOOK_POSITION_CHANGE, DT_INT, x, DT_INT, y, DT_END));
1481	moved = true;	1525	moved = true;
		1526	}
1482	}	1527	}
1483	#endif
1484		1528
1485	if (szHint.width != ev.xconfigure.width || szHint.height != ev.xconfigure.height)	1529	if (szHint.width != ev.xconfigure.width || szHint.height != ev.xconfigure.height)
1486	{	1530	{
1487	seen_resize = 1;	1531	seen_resize = 1;
1488	resize_all_windows (ev.xconfigure.width, ev.xconfigure.height, 1);	1532	resize_all_windows (ev.xconfigure.width, ev.xconfigure.height, 1);
…		…
1511	selection_send (ev.xselectionrequest);	1555	selection_send (ev.xselectionrequest);
1512	break;	1556	break;
1513		1557
1514	case MapNotify:	1558	case MapNotify:
1515	#ifdef HAVE_BG_PIXMAP	1559	#ifdef HAVE_BG_PIXMAP
1516	/* This is needed specifically to fix the case of no window manager or a	1560	// This is needed at startup for the case of no window manager
1517	* non-reparenting window manager. In those cases we never get first	1561	// or a non-reparenting window manager and also because we
1518	* ConfigureNotify. Also that speeds startup under normal WM, by taking	1562	// defer bg image updates if the window is not mapped. The
1519	* care of multiplicity of ConfigureNotify events arriving while WM does	1563	// short delay is to optimize for multiple ConfigureNotify
1520	* reparenting.	1564	// events at startup when the window manager reparents the
1521	* We should not render background immediately, as there could be several	1565	// window, so as to perform the computation after we have
1522	* ConfigureNotify's to follow. Lets take care of all of them in one scoop	1566	// received all of them.
1523	* by scheduling background redraw as soon as we can, but giving a short	1567	if (bg_img == 0)
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);	1568	update_background_ev.start (0.025);
1530	#endif	1569	#endif
1531	mapped = 1;	1570	mapped = 1;
1532	#ifdef TEXT_BLINK	1571	#ifdef TEXT_BLINK
1533	text_blink_ev.start ();	1572	text_blink_ev.start ();
…		…
1625		1664
1626	#ifdef SELECTION_SCROLLING	1665	#ifdef SELECTION_SCROLLING
1627	if (ev.xbutton.y < int_bwidth	1666	if (ev.xbutton.y < int_bwidth
1628	|| Pixel2Row (ev.xbutton.y) > (nrow-1))	1667	|| Pixel2Row (ev.xbutton.y) > (nrow-1))
1629	{	1668	{
		1669	page_dirn scroll_selection_dir;
1630	int dist;	1670	int dist;
1631		1671
1632	/* don't clobber the current delay if we are	1672	/* don't clobber the current delay if we are
1633	* already in the middle of scrolling.	1673	* already in the middle of scrolling.
1634	*/	1674	*/
…		…
1657	scroll_selection_lines = Pixel2Height (dist)	1697	scroll_selection_lines = Pixel2Height (dist)
1658	/ SELECTION_SCROLL_LINE_SPEEDUP	1698	/ SELECTION_SCROLL_LINE_SPEEDUP
1659	+ 1;	1699	+ 1;
1660	min_it (scroll_selection_lines,	1700	min_it (scroll_selection_lines,
1661	SELECTION_SCROLL_MAX_LINES);	1701	SELECTION_SCROLL_MAX_LINES);
		1702	scroll_selection_lines *= scroll_selection_dir;
1662	}	1703	}
1663	else	1704	else
1664	{	1705	{
1665	/* we are within the text window, so we	1706	/* we are within the text window, so we
1666	* shouldn't be scrolling	1707	* shouldn't be scrolling
…		…
1713		1754
1714	refresh_check ();	1755	refresh_check ();
1715	}	1756	}
1716		1757
1717	#if ENABLE_FRILLS	1758	#if ENABLE_FRILLS
1718	void	1759	void ecb_cold
1719	rxvt_term::set_urgency (bool enable)	1760	rxvt_term::set_urgency (bool enable)
1720	{	1761	{
1721	if (enable == urgency_hint)	1762	if (enable == urgency_hint)
1722	return;	1763	return;
1723		1764
…		…
1729	XFree (h);	1770	XFree (h);
1730	}	1771	}
1731	}	1772	}
1732	#endif	1773	#endif
1733		1774
1734	void	1775	void ecb_cold
1735	rxvt_term::focus_in ()	1776	rxvt_term::focus_in ()
1736	{	1777	{
1737	if (!focus)	1778	if (!focus)
1738	{	1779	{
1739	focus = 1;	1780	focus = 1;
…		…
1764		1805
1765	HOOK_INVOKE ((this, HOOK_FOCUS_IN, DT_END));	1806	HOOK_INVOKE ((this, HOOK_FOCUS_IN, DT_END));
1766	}	1807	}
1767	}	1808	}
1768		1809
1769	void	1810	void ecb_cold
1770	rxvt_term::focus_out ()	1811	rxvt_term::focus_out ()
1771	{	1812	{
1772	if (focus)	1813	if (focus)
1773	{	1814	{
1774	focus = 0;	1815	focus = 0;
…		…
1807		1848
1808	HOOK_INVOKE ((this, HOOK_FOCUS_OUT, DT_END));	1849	HOOK_INVOKE ((this, HOOK_FOCUS_OUT, DT_END));
1809	}	1850	}
1810	}	1851	}
1811		1852
1812	void	1853	void ecb_cold
1813	rxvt_term::update_fade_color (unsigned int idx)	1854	rxvt_term::update_fade_color (unsigned int idx)
1814	{	1855	{
1815	#if OFF_FOCUS_FADING	1856	#if OFF_FOCUS_FADING
1816	if (rs[Rs_fade])	1857	if (rs[Rs_fade])
1817	{	1858	{
…		…
1820	pix_colors_focused [idx].fade (this, atoi (rs[Rs_fade]), pix_colors_unfocused [idx], c);	1861	pix_colors_focused [idx].fade (this, atoi (rs[Rs_fade]), pix_colors_unfocused [idx], c);
1821	}	1862	}
1822	#endif	1863	#endif
1823	}	1864	}
1824		1865
1825	#if ENABLE_TRANSPARENCY || ENABLE_PERL	1866	#if BG_IMAGE_FROM_ROOT || ENABLE_PERL
1826	void	1867	void ecb_hot
1827	rxvt_term::rootwin_cb (XEvent &ev)	1868	rxvt_term::rootwin_cb (XEvent &ev)
1828	{	1869	{
1829	make_current ();	1870	make_current ();
1830		1871
1831	if (SHOULD_INVOKE (HOOK_ROOT_EVENT)	1872	if (SHOULD_INVOKE (HOOK_ROOT_EVENT)
1832	&& HOOK_INVOKE ((this, HOOK_ROOT_EVENT, DT_XEVENT, &ev, DT_END)))	1873	&& HOOK_INVOKE ((this, HOOK_ROOT_EVENT, DT_XEVENT, &ev, DT_END)))
1833	return;	1874	return;
1834		1875
1835	# if ENABLE_TRANSPARENCY
1836	switch (ev.type)	1876	switch (ev.type)
1837	{	1877	{
1838	case PropertyNotify:	1878	case PropertyNotify:
1839	/*	1879	/*
1840	* if user used some Esetroot compatible prog to set the root bg,	1880	* 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.	1881	* use the property to determine the pixmap. We use it later on.
1842	*/	1882	*/
1843	if (ev.xproperty.atom == xa[XA_XROOTPMAP_ID]	1883	if (ev.xproperty.atom == xa[XA_XROOTPMAP_ID]
1844	|| ev.xproperty.atom == xa[XA_ESETROOT_PMAP_ID])	1884	|| ev.xproperty.atom == xa[XA_ESETROOT_PMAP_ID])
1845	{	1885	{
1846	bg_set_root_pixmap ();	1886	#if BG_IMAGE_FROM_ROOT
		1887	if (option (Opt_transparent))
		1888	{
		1889	rxvt_img::new_from_root (this)->replace (root_img);
1847	update_background ();	1890	update_background ();
		1891	}
		1892	#endif
		1893	HOOK_INVOKE ((this, HOOK_ROOTPMAP_CHANGE, DT_END));
1848	}	1894	}
1849		1895
1850	break;	1896	break;
1851	}	1897	}
1852	# endif
1853		1898
1854	refresh_check ();	1899	refresh_check ();
1855	}	1900	}
1856	#endif	1901	#endif
1857		1902
…		…
2178		2223
2179	#ifdef MOUSE_WHEEL	2224	#ifdef MOUSE_WHEEL
2180	case Button4:	2225	case Button4:
2181	case Button5:	2226	case Button5:
2182	{	2227	{
2183	int i;	2228	int lines;
2184	page_dirn v;	2229	page_dirn dirn;
2185		2230
2186	v = ev.button == Button4 ? UP : DN;	2231	dirn = ev.button == Button4 ? UP : DN;
2187		2232
2188	if (ev.state & ShiftMask)	2233	if (ev.state & ShiftMask)
2189	i = 1;	2234	lines = 1;
2190	else if (option (Opt_mouseWheelScrollPage))	2235	else if (option (Opt_mouseWheelScrollPage))
2191	i = nrow - 1;	2236	lines = nrow - 1;
2192	else	2237	else
2193	i = 5;	2238	lines = 5;
2194		2239
2195	# ifdef MOUSE_SLIP_WHEELING	2240	# ifdef MOUSE_SLIP_WHEELING
2196	if (ev.state & ControlMask)	2241	if (ev.state & ControlMask)
2197	{	2242	{
2198	mouse_slip_wheel_speed += v ? -1 : 1;	2243	mouse_slip_wheel_speed += dirn;
2199	if (mouse_slip_wheel_speed < -nrow) mouse_slip_wheel_speed = -nrow;	2244	clamp_it (mouse_slip_wheel_speed, -nrow, nrow);
2200	if (mouse_slip_wheel_speed > +nrow) mouse_slip_wheel_speed = +nrow;
2201		2245
2202	if (!slip_wheel_ev.is_active ())	2246	if (!slip_wheel_ev.is_active ())
2203	slip_wheel_ev.start (SCROLLBAR_CONTINUOUS_DELAY, SCROLLBAR_CONTINUOUS_DELAY);	2247	slip_wheel_ev.start (SCROLLBAR_CONTINUOUS_DELAY, SCROLLBAR_CONTINUOUS_DELAY);
2204	}	2248	}
2205	else	2249	else
2206	# endif	2250	# endif
2207	{	2251	{
2208	scr_page (v, i);	2252	scr_page (dirn, lines);
2209	scrollBar.show (1);	2253	scrollBar.show (1);
2210	}	2254	}
2211	}	2255	}
2212	break;	2256	break;
2213	#endif	2257	#endif
…		…
2215	}	2259	}
2216	}	2260	}
2217		2261
2218	/*}}} */	2262	/*}}} */
2219		2263
2220	void	2264	void ecb_hot
2221	rxvt_term::cmd_parse ()	2265	rxvt_term::cmd_parse ()
2222	{	2266	{
2223	wchar_t ch = NOCHAR;	2267	wchar_t ch = NOCHAR;
2224	char *seq_begin; // remember start of esc-sequence here	2268	char *seq_begin; // remember start of esc-sequence here
2225		2269
…		…
2344	}	2388	}
2345	}	2389	}
2346	}	2390	}
2347		2391
2348	// read the next character	2392	// read the next character
2349	wchar_t	2393	wchar_t ecb_hot
2350	rxvt_term::next_char () NOTHROW	2394	rxvt_term::next_char () NOTHROW
2351	{	2395	{
2352	while (cmdbuf_ptr < cmdbuf_endp)	2396	while (cmdbuf_ptr < cmdbuf_endp)
2353	{	2397	{
2354	// assume 7-bit to be ascii ALWAYS	2398	// assume 7-bit to be ascii ALWAYS
…		…
2366	}	2410	}
2367		2411
2368	if (len == (size_t)-1)	2412	if (len == (size_t)-1)
2369	{	2413	{
2370	mbstate.reset (); // reset now undefined conversion state	2414	mbstate.reset (); // reset now undefined conversion state
		2415	// a -1 might indicate that a previous incomplete char is invalid (previous return -2)
		2416	// in which case we "erroneously" return the next byte which might be valid.
2371	return (unsigned char)*cmdbuf_ptr++; // the _occasional_ latin1 character is allowed to slip through	2417	return (unsigned char)*cmdbuf_ptr++; // the _occasional_ latin1 character is allowed to slip through
2372	}	2418	}
2373		2419
2374	// assume wchar == unicode	2420	// assume wchar == unicode
2375	cmdbuf_ptr += len;	2421	cmdbuf_ptr += len;
…		…
2378		2424
2379	return NOCHAR;	2425	return NOCHAR;
2380	}	2426	}
2381		2427
2382	// read the next octet	2428	// read the next octet
2383	uint32_t	2429	uint32_t ecb_hot
2384	rxvt_term::next_octet () NOTHROW	2430	rxvt_term::next_octet () NOTHROW
2385	{	2431	{
2386	return cmdbuf_ptr < cmdbuf_endp	2432	return cmdbuf_ptr < cmdbuf_endp
2387	? (unsigned char)*cmdbuf_ptr++	2433	? (unsigned char)*cmdbuf_ptr++
2388	: NOCHAR;	2434	: NOCHAR;
2389	}	2435	}
2390		2436
2391	static class out_of_input out_of_input;	2437	static class out_of_input out_of_input;
2392		2438
2393	wchar_t	2439	wchar_t ecb_hot
2394	rxvt_term::cmd_getc () THROW ((class out_of_input))	2440	rxvt_term::cmd_getc () THROW ((class out_of_input))
2395	{	2441	{
2396	wchar_t c = next_char ();	2442	wchar_t c = next_char ();
2397		2443
2398	if (c == NOCHAR)	2444	if (c == NOCHAR)
2399	throw out_of_input;	2445	throw out_of_input;
2400		2446
2401	return c;	2447	return c;
2402	}	2448	}
2403		2449
2404	uint32_t	2450	uint32_t ecb_hot
2405	rxvt_term::cmd_get8 () THROW ((class out_of_input))	2451	rxvt_term::cmd_get8 () THROW ((class out_of_input))
2406	{	2452	{
2407	uint32_t c = next_octet ();	2453	uint32_t c = next_octet ();
2408		2454
2409	if (c == NOCHAR)	2455	if (c == NOCHAR)
…		…
2413	}	2459	}
2414		2460
2415	/*{{{ print pipe */	2461	/*{{{ print pipe */
2416	/*----------------------------------------------------------------------*/	2462	/*----------------------------------------------------------------------*/
2417	#ifdef PRINTPIPE	2463	#ifdef PRINTPIPE
2418	FILE *	2464	FILE * ecb_cold
2419	rxvt_term::popen_printer ()	2465	rxvt_term::popen_printer ()
2420	{	2466	{
2421	FILE *stream = popen (rs[Rs_print_pipe] ? rs[Rs_print_pipe] : PRINTPIPE, "w");	2467	FILE *stream = popen (rs[Rs_print_pipe] ? rs[Rs_print_pipe] : PRINTPIPE, "w");
2422		2468
2423	if (stream == NULL)	2469	if (stream == NULL)
2424	rxvt_warn ("can't open printer pipe, not printing.\n");	2470	rxvt_warn ("can't open printer pipe, not printing.\n");
2425		2471
2426	return stream;	2472	return stream;
2427	}	2473	}
2428		2474
2429	int	2475	int ecb_cold
2430	rxvt_term::pclose_printer (FILE *stream)	2476	rxvt_term::pclose_printer (FILE *stream)
2431	{	2477	{
2432	fflush (stream);	2478	fflush (stream);
2433	return pclose (stream);	2479	return pclose (stream);
2434	}	2480	}
2435		2481
2436	/*	2482	/*
2437	* simulate attached vt100 printer	2483	* simulate attached vt100 printer
2438	*/	2484	*/
2439	void	2485	void ecb_cold
2440	rxvt_term::process_print_pipe ()	2486	rxvt_term::process_print_pipe ()
2441	{	2487	{
2442	FILE *fd = popen_printer ();	2488	FILE *fd = popen_printer ();
2443		2489
2444	if (!fd)	2490	if (!fd)
…		…
2499	C1_DCS, C1_PU1, C1_PU2, C1_STS, C1_CCH, C1_MW , C1_SPA, C1_EPA,	2545	C1_DCS, C1_PU1, C1_PU2, C1_STS, C1_CCH, C1_MW , C1_SPA, C1_EPA,
2500	C1_SOS, C1_59 , C1_SCI, C1_CSI, CS_ST , C1_OSC, C1_PM , C1_APC,	2546	C1_SOS, C1_59 , C1_SCI, C1_CSI, CS_ST , C1_OSC, C1_PM , C1_APC,
2501	};	2547	};
2502		2548
2503	/*{{{ process non-printing single characters */	2549	/*{{{ process non-printing single characters */
2504	void	2550	void ecb_hot
2505	rxvt_term::process_nonprinting (unicode_t ch)	2551	rxvt_term::process_nonprinting (unicode_t ch)
2506	{	2552	{
2507	switch (ch)	2553	switch (ch)
2508	{	2554	{
2509	case C0_ESC:	2555	case C0_ESC:
…		…
2555	}	2601	}
2556	/*}}} */	2602	/*}}} */
2557		2603
2558		2604
2559	/*{{{ process VT52 escape sequences */	2605	/*{{{ process VT52 escape sequences */
2560	void	2606	void ecb_cold
2561	rxvt_term::process_escape_vt52 (unicode_t ch)	2607	rxvt_term::process_escape_vt52 (unicode_t ch)
2562	{	2608	{
2563	int row, col;	2609	int row, col;
2564		2610
2565	switch (ch)	2611	switch (ch)
…		…
2615	}	2661	}
2616	/*}}} */	2662	/*}}} */
2617		2663
2618		2664
2619	/*{{{ process escape sequences */	2665	/*{{{ process escape sequences */
2620	void	2666	void ecb_hot
2621	rxvt_term::process_escape_seq ()	2667	rxvt_term::process_escape_seq ()
2622	{	2668	{
2623	unicode_t ch = cmd_getc ();	2669	unicode_t ch = cmd_getc ();
2624		2670
2625	if (priv_modes & PrivMode_vt52)	2671	if (priv_modes & PrivMode_vt52)
…		…
2777	make_byte (0,0,1,1,0,0,0,0), /* h, i, j, k, l, m, n, o, */	2823	make_byte (0,0,1,1,0,0,0,0), /* h, i, j, k, l, m, n, o, */
2778	make_byte (0,0,0,0,0,0,0,0), /* p, q, r, s, t, u, v, w, */	2824	make_byte (0,0,0,0,0,0,0,0), /* p, q, r, s, t, u, v, w, */
2779	make_byte (0,0,0,0,0,0,0,0), /* x, y, z, {, |, }, ~, */	2825	make_byte (0,0,0,0,0,0,0,0), /* x, y, z, {, |, }, ~, */
2780	};	2826	};
2781		2827
2782	void	2828	void ecb_hot
2783	rxvt_term::process_csi_seq ()	2829	rxvt_term::process_csi_seq ()
2784	{	2830	{
2785	unicode_t ch, priv, i;	2831	unicode_t ch, priv, prev_ch, i;
2786	unsigned int nargs, p;	2832	unsigned int nargs, p;
2787	int n, ndef;	2833	int n, ndef;
2788	int arg[ESC_ARGS] = { };	2834	int arg[ESC_ARGS] = { };
2789		2835
2790	nargs = 0;	2836	nargs = 0;
…		…
2796	/* '<' '=' '>' '?' '!' */	2842	/* '<' '=' '>' '?' '!' */
2797	priv = ch;	2843	priv = ch;
2798	ch = cmd_getc ();	2844	ch = cmd_getc ();
2799	}	2845	}
2800		2846
		2847	prev_ch = 0;
2801	/* read any numerical arguments */	2848	/* read any numerical arguments */
2802	for (n = -1; ch < CSI_ICH; )	2849	for (n = -1; ch < CSI_ICH; )
2803	{	2850	{
2804	if (isdigit (ch))	2851	if (isdigit (ch))
2805	{	2852	{
…		…
2815	n = -1;	2862	n = -1;
2816	}	2863	}
2817	else if (IS_CONTROL (ch))	2864	else if (IS_CONTROL (ch))
2818	process_nonprinting (ch);	2865	process_nonprinting (ch);
2819		2866
		2867	prev_ch = ch;
2820	ch = cmd_getc ();	2868	ch = cmd_getc ();
2821	}	2869	}
2822		2870
2823	if (ch > CSI_7F)	2871	if (ch > CSI_7F)
2824	return;	2872	return;
…		…
3058	scr_insert_mode (1);	3106	scr_insert_mode (1);
3059	else if (arg[0] == 20)	3107	else if (arg[0] == 20)
3060	priv_modes |= PrivMode_LFNL;	3108	priv_modes |= PrivMode_LFNL;
3061	break;	3109	break;
3062		3110
		3111	case CSI_71: // DESCUSR: set cursor style
		3112	if (prev_ch == ' ')
		3113	set_cursor_style (arg[0]);
		3114	break;
		3115
3063	/*	3116	/*
3064	* PRIVATE USE beyond this point. All CSI_7? sequences here	3117	* PRIVATE USE beyond this point. All CSI_7? sequences here
3065	*/	3118	*/
3066	case CSI_72: /* DECSTBM: set top and bottom margins */	3119	case CSI_72: /* DECSTBM: set top and bottom margins */
3067	if (nargs == 1)	3120	if (nargs == 1)
…		…
3200	rxvt_term::get_to_st (unicode_t &ends_how)	3253	rxvt_term::get_to_st (unicode_t &ends_how)
3201	{	3254	{
3202	unicode_t ch;	3255	unicode_t ch;
3203	bool seen_esc = false;	3256	bool seen_esc = false;
3204	unsigned int n = 0;	3257	unsigned int n = 0;
3205	wchar_t string[STRING_MAX];	3258	wchar_t string[CBUFSIZ];
3206		3259
3207	while ((ch = cmd_getc ()) != NOCHAR)	3260	while ((ch = cmd_getc ()) != NOCHAR)
3208	{	3261	{
3209	if (seen_esc)	3262	if (seen_esc)
3210	{	3263	{
…		…
3225	else if (ch < 0x20)	3278	else if (ch < 0x20)
3226	return NULL; /* other control character - exit */	3279	return NULL; /* other control character - exit */
3227		3280
3228	seen_esc = false;	3281	seen_esc = false;
3229		3282
3230	if (n >= STRING_MAX - 1)	3283	if (n >= sizeof (string) - 1)
3231	// stop at some sane length	3284	// stop at some sane length
3232	return NULL;	3285	return NULL;
3233		3286
3234	string[n++] = ch;	3287	string[n++] = ch;
3235	}	3288	}
…		…
3352	&nitems, &bytes_after, &value) == Success	3405	&nitems, &bytes_after, &value) == Success
3353	&& actual_type != None	3406	&& actual_type != None
3354	&& actual_format == 8)	3407	&& actual_format == 8)
3355	str = (const char *)(value);	3408	str = (const char *)(value);
3356		3409
3357	tt_printf ("\033]%d;%s%c", op, str, resp);	3410	tt_printf ("\033]%d;%s%c", op, option (Opt_insecure) ? str : "", resp);
3358		3411
3359	XFree (value);	3412	XFree (value);
3360	}	3413	}
3361	else	3414	else
3362	{	3415	{
…		…
3430	break;	3483	break;
3431	#endif	3484	#endif
3432	case URxvt_Color_border:	3485	case URxvt_Color_border:
3433	process_color_seq (op, Color_border, str, resp);	3486	process_color_seq (op, Color_border, str, resp);
3434	break;	3487	break;
3435	#if ENABLE_TRANSPARENCY	3488
		3489	#if BG_IMAGE_FROM_ROOT
3436	case URxvt_Color_tint:	3490	case URxvt_Color_tint:
3437	process_color_seq (op, Color_tint, str, resp);	3491	process_color_seq (op, Color_tint, str, resp);
3438	{	3492	{
3439	bool changed = false;	3493	bool changed = false;
3440		3494
3441	if (ISSET_PIXCOLOR (Color_tint))	3495	if (ISSET_PIXCOLOR (Color_tint))
3442	changed = bg_set_tint (pix_colors_focused [Color_tint]);	3496	changed = root_effects.set_tint (pix_colors_focused [Color_tint]);
3443		3497
3444	if (changed)	3498	if (changed)
3445	update_background ();	3499	update_background ();
3446	}	3500	}
3447		3501
…		…
3451	#if BG_IMAGE_FROM_FILE	3505	#if BG_IMAGE_FROM_FILE
3452	case Rxvt_Pixmap:	3506	case Rxvt_Pixmap:
3453	if (!strcmp (str, "?"))	3507	if (!strcmp (str, "?"))
3454	{	3508	{
3455	char str[256];	3509	char str[256];
		3510	int h_scale = fimage.h_scale;
		3511	int v_scale = fimage.v_scale;
		3512	int h_align = fimage.h_align;
		3513	int v_align = fimage.v_align;
3456		3514
3457	sprintf (str, "[%dx%d+%d+%d]",	3515	sprintf (str, "[%dx%d+%d+%d]",
3458	min (h_scale, 32767), min (v_scale, 32767),	3516	h_scale, v_scale,
3459	min (h_align, 32767), min (v_align, 32767));	3517	h_align, v_align);
3460	process_xterm_seq (XTerm_title, str, CHAR_ST);	3518	process_xterm_seq (XTerm_title, str, CHAR_ST);
3461	}	3519	}
3462	else	3520	else
3463	{	3521	{
3464	bool changed = false;	3522	bool changed = false;
3465		3523
3466	if (*str != ';')	3524	if (*str != ';')
3467	{	3525	{
3468	if (bg_set_file (str)) /* change pixmap */	3526	try
		3527	{
		3528	fimage.set_file_geometry (this, str);
3469	changed = true;	3529	changed = true;
		3530	}
		3531	catch (const class rxvt_failure_exception &e)
		3532	{
		3533	}
3470	}	3534	}
3471	else	3535	else
3472	{	3536	{
3473	str++;	3537	str++;
3474	if (bg_set_geometry (str, true))	3538	if (fimage.set_geometry (str, true))
3475	changed = true;	3539	changed = true;
3476	}	3540	}
3477		3541
3478	if (changed)	3542	if (changed)
3479	{	3543	{
3480	if (bg_window_position_sensitive ())	3544	if (bg_window_position_sensitive ())
3481	{	3545	{
3482	int x, y;	3546	int x, y;
3483	get_window_origin (x, y);	3547	get_window_origin (x, y);
3484	bg_set_position (x, y);	3548	parent_x = x;
		3549	parent_y = y;
3485	}	3550	}
3486	update_background ();	3551	update_background ();
3487	}	3552	}
3488	}	3553	}
3489	break;	3554	break;
…		…
3579	* 's' = save	3644	* 's' = save
3580	* 'r' = restore	3645	* 'r' = restore
3581	* 't' = toggle	3646	* 't' = toggle
3582	* so no need for fancy checking	3647	* so no need for fancy checking
3583	*/	3648	*/
3584	int	3649	int ecb_cold
3585	rxvt_term::privcases (int mode, unsigned long bit)	3650	rxvt_term::privcases (int mode, unsigned long bit)
3586	{	3651	{
3587	int state;	3652	int state;
3588		3653
3589	if (mode == 's')	3654	if (mode == 's')
3590	{	3655	{
3591	SavedModes |= (priv_modes & bit);	3656	if (priv_modes & bit)
		3657	SavedModes |= bit;
		3658	else
		3659	SavedModes &= ~bit;
3592	return -1;	3660	return -1;
3593	}	3661	}
3594	else	3662	else
3595	{	3663	{
3596	if (mode == 'r')	3664	if (mode == 'r')
…		…
3806	}	3874	}
3807	}	3875	}
3808	/*}}} */	3876	/*}}} */
3809		3877
3810	/*{{{ process sgr sequences */	3878	/*{{{ process sgr sequences */
3811	void	3879	void ecb_hot
3812	rxvt_term::process_sgr_mode (unsigned int nargs, const int *arg)	3880	rxvt_term::process_sgr_mode (unsigned int nargs, const int *arg)
3813	{	3881	{
3814	unsigned int i;	3882	unsigned int i;
3815	short rendset;	3883	short rendset;
3816	int rendstyle;	3884	int rendstyle;
…		…
3957	break;	4025	break;
3958	#endif	4026	#endif
3959	}	4027	}
3960	}	4028	}
3961	}	4029	}
		4030
		4031	void
		4032	rxvt_term::set_cursor_style (int style)
		4033	{
		4034	if (!IN_RANGE_INC (style, 0, 4))
		4035	return;
		4036
		4037	set_option (Opt_cursorUnderline, style >= 3);
		4038
		4039	#ifdef CURSOR_BLINK
		4040	set_option (Opt_cursorBlink, !style || (style & 1));
		4041	cursor_blink_reset ();
		4042	#endif
		4043
		4044	want_refresh = 1;
		4045	}
3962	/*}}} */	4046	/*}}} */
3963		4047
3964	/* ------------------------------------------------------------------------- */	4048	/* ---------------------------------------------------------------------- */
		4049	/* Write data to the pty as typed by the user, pasted with the mouse,
		4050	* or generated by us in response to a query ESC sequence.
		4051	*/
3965		4052
3966	/*	4053	/*
3967	* Send printf () formatted output to the command.	4054	* Send printf () formatted output to the command.
3968	* Only use for small amounts of data.	4055	* Only use for small amounts of data.
3969	*/	4056	*/
…		…
3977	vsnprintf ((char *)buf, 256, fmt, arg_ptr);	4064	vsnprintf ((char *)buf, 256, fmt, arg_ptr);
3978	va_end (arg_ptr);	4065	va_end (arg_ptr);
3979	tt_write (buf, strlen (buf));	4066	tt_write (buf, strlen (buf));
3980	}	4067	}
3981		4068
3982	/* ---------------------------------------------------------------------- */
3983	/* Write data to the pty as typed by the user, pasted with the mouse,	4069	/* Write data to the pty as typed by the user. */
3984	* or generated by us in response to a query ESC sequence.	4070	void
3985	*/	4071	rxvt_term::tt_write_user_input (const char *data, unsigned int len)
3986	static const unsigned int MAX_PTY_WRITE = 255; // minimum MAX_INPUT	4072	{
		4073	if (HOOK_INVOKE ((this, HOOK_TT_WRITE, DT_STR_LEN, data, len, DT_END)))
		4074	return;
		4075
		4076	if (option (Opt_scrollTtyKeypress))
		4077	if (view_start)
		4078	{
		4079	view_start = 0;
		4080	want_refresh = 1;
		4081	}
		4082
		4083	tt_write_ (data, len);
		4084	}
3987		4085
3988	void	4086	void
3989	rxvt_term::tt_write (const char *data, unsigned int len)	4087	rxvt_term::tt_write (const char *data, unsigned int len)
3990	{	4088	{
3991	if (HOOK_INVOKE ((this, HOOK_TT_WRITE, DT_STR_LEN, data, len, DT_END)))	4089	if (HOOK_INVOKE ((this, HOOK_TT_WRITE, DT_STR_LEN, data, len, DT_END)))
3992	return;	4090	return;
3993		4091
		4092	tt_write_ (data, len);
		4093	}
		4094
		4095	static const unsigned int MAX_PTY_WRITE = 255; // minimum MAX_INPUT
		4096
		4097	void
		4098	rxvt_term::tt_write_ (const char *data, unsigned int len)
		4099	{
3994	if (pty->pty < 0)	4100	if (pty->pty < 0)
3995	return;	4101	return;
3996		4102
3997	if (v_buflen == 0)	4103	if (v_buflen == 0)
3998	{	4104	{

Diff Legend

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