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.518 by sf-exg, Wed Jun 6 22:00:20 2012 UTC vs.
Revision 1.591 by sf-exg, Thu May 13 19:40:19 2021 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,2015 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
…		…
210		210
211	max_it (width, strlen (attr));	211	max_it (width, strlen (attr));
212		212
213	if (y >= 0)	213	if (y >= 0)
214	{	214	{
215	y = (y >= nrow - len - 4 && x < width + 2) ? 0 : -1;	215	y = (y >= nrow - len - 5 && x < width + 2) ? 0 : -1;
216	x = 0;	216	x = 0;
217	}	217	}
218		218
219	scr_overlay_new (x, y, width, len * 2 + 2);	219	scr_overlay_new (x, y, width, len * 2 + 2);
220		220
…		…
315	XK_KP_7, // XK_KP_Home	315	XK_KP_7, // XK_KP_Home
316	XK_KP_4, // XK_KP_Left	316	XK_KP_4, // XK_KP_Left
317	XK_KP_8, // XK_KP_Up	317	XK_KP_8, // XK_KP_Up
318	XK_KP_6, // XK_KP_Right	318	XK_KP_6, // XK_KP_Right
319	XK_KP_2, // XK_KP_Down	319	XK_KP_2, // XK_KP_Down
320	# ifndef UNSHIFTED_SCROLLKEYS
321	XK_KP_9, // XK_KP_Prior	320	XK_KP_9, // XK_KP_Prior
322	XK_KP_3, // XK_KP_Next	321	XK_KP_3, // XK_KP_Next
323	# else
324	XK_Prior,
325	XK_Next,
326	# endif
327	XK_KP_1, // XK_KP_End	322	XK_KP_1, // XK_KP_End
328	XK_KP_5, // XK_KP_Begin	323	XK_KP_5, // XK_KP_Begin
329	};	324	};
330		325
331	if (IN_RANGE_INC (keysym, XK_KP_Home, XK_KP_Begin))	326	if (IN_RANGE_INC (keysym, XK_KP_Home, XK_KP_Begin))
…		…
376	param = 3;	371	param = 3;
377	break;	372	break;
378	case XK_Select:	373	case XK_Select:
379	param = 4;	374	param = 4;
380	break;	375	break;
381	#ifndef UNSHIFTED_SCROLLKEYS
382	case XK_Prior:	376	case XK_Prior:
383	param = 5;	377	param = 5;
384	break;	378	break;
385	case XK_Next:	379	case XK_Next:
386	param = 6;	380	param = 6;
…		…
389	param = 7;	383	param = 7;
390	break;	384	break;
391	case XK_End:	385	case XK_End:
392	param = 8;	386	param = 8;
393	break;	387	break;
394	#endif
395	case XK_Help:	388	case XK_Help:
396	param = 28;	389	param = 28;
397	break;	390	break;
398	case XK_Menu:	391	case XK_Menu:
399	param = 29;	392	param = 29;
400	break;	393	break;
401	}	394	}
402	return param;	395	return param;
403	}	396	}
404		397
		398	static inline wchar_t *
		399	rxvt_wcsdup (const wchar_t *str, int len)
		400	{
		401	wchar_t *r = (wchar_t *)rxvt_malloc ((len + 1) * sizeof (wchar_t));
		402	memcpy (r, str, len * sizeof (wchar_t));
		403	r[len] = 0;
		404	return r;
		405	}
		406
405	void ecb_cold	407	void ecb_cold
406	rxvt_term::key_press (XKeyEvent &ev)	408	rxvt_term::key_press (XKeyEvent &ev)
407	{	409	{
408	int ctrl, meta, shft, len;	410	int ctrl, meta, shft, len;
409	KeySym keysym;	411	KeySym keysym = NoSymbol;
410	int valid_keysym;
411	char kbuf[KBUFSZ];	412	char rkbuf[KBUFSZ + 1];
		413	char *kbuf = rkbuf + 1;
412		414
413	#if ISO_14755	415	#if ISO_14755
414	if (iso14755buf & ISO_14755_52)	416	if (iso14755buf & ISO_14755_52)
415	return;	417	return;
416	#endif	418	#endif
…		…
473	}	475	}
474	}	476	}
475	else	477	else
476	len = 0;	478	len = 0;
477	}	479	}
478
479	valid_keysym = status_return == XLookupKeySym
480	|| status_return == XLookupBoth;
481	}	480	}
482	else	481	else
483	#endif	482	#endif
484	{	483	{
485	len = XLookupString (&ev, kbuf, KBUFSZ, &keysym, &compose);	484	len = XLookupString (&ev, kbuf, KBUFSZ, &keysym, &compose);
486	valid_keysym = keysym != NoSymbol;	485	}
		486
		487	if (keysym != NoSymbol)
487	}	488	{
		489	KeySym orig_keysym = keysym;
488		490
489	if (valid_keysym)	491	/* Shift + F1 - F10 generates F11 - F20 */
		492	if (shft && keysym >= XK_F1 && keysym <= XK_F10)
		493	{
		494	keysym += (XK_F11 - XK_F1);
		495	shft = 0; /* turn off Shift */
		496	}
		497
		498	if (keysym >= 0xFF00 && keysym <= 0xFFFF)
		499	{
		500	bool kp = priv_modes & PrivMode_aplKP ? !shft : shft;
		501	unsigned int newlen = 1;
		502
		503	if (ev.state & ModNumLockMask)
		504	kp = false;
		505
		506	keysym = translate_keypad (keysym, kp);
		507
		508	switch (keysym)
		509	{
		510	#ifndef NO_BACKSPACE_KEY
		511	case XK_BackSpace:
		512	if (priv_modes & PrivMode_HaveBackSpace)
		513	{
		514	kbuf[0] = (!! (priv_modes & PrivMode_BackSpace)
		515	^ !!ctrl) ? '\b' : '\177';
		516	kbuf[1] = '\0';
		517	}
		518	else
		519	strcpy (kbuf, rs[Rs_backspace_key]);
		520	break;
		521	#endif
		522	#ifndef NO_DELETE_KEY
		523	case XK_Delete:
		524	strcpy (kbuf, rs[Rs_delete_key]);
		525	break;
		526	#endif
		527	case XK_Tab:
		528	if (shft)
		529	strcpy (kbuf, "\033[Z");
		530	else
		531	{
		532	#ifdef CTRL_TAB_MAKES_META
		533	if (ctrl)
		534	meta = 1;
		535	#endif
		536	#ifdef MOD4_TAB_MAKES_META
		537	if (ev.state & Mod4Mask)
		538	meta = 1;
		539	#endif
		540	newlen = 0;
		541	}
		542	break;
		543
		544	case XK_Up: /* "\033[A" */
		545	case XK_Down: /* "\033[B" */
		546	case XK_Right: /* "\033[C" */
		547	case XK_Left: /* "\033[D" */
		548	strcpy (kbuf, "\033[Z");
		549	kbuf[2] = "DACB"[keysym - XK_Left];
		550	/* do Shift first */
		551	if (shft)
		552	kbuf[2] = "dacb"[keysym - XK_Left];
		553	else if (ctrl)
		554	{
		555	kbuf[1] = 'O';
		556	kbuf[2] = "dacb"[keysym - XK_Left];
		557	}
		558	else if (priv_modes & PrivMode_aplCUR)
		559	kbuf[1] = 'O';
		560	break;
		561
		562	case XK_KP_Enter:
		563	/* allow shift to override */
		564	if (kp)
		565	{
		566	strcpy (kbuf, "\033OM");
		567	break;
		568	}
		569
		570	/* FALLTHROUGH */
		571
		572	case XK_Return:
		573	if (priv_modes & PrivMode_LFNL)
		574	{
		575	kbuf[0] = '\015';
		576	kbuf[1] = '\012';
		577	kbuf[2] = '\0';
		578	}
		579	else
		580	{
		581	kbuf[0] = '\015';
		582	kbuf[1] = '\0';
		583	}
		584	break;
		585
		586	case XK_KP_F1: /* "\033OP" */
		587	case XK_KP_F2: /* "\033OQ" */
		588	case XK_KP_F3: /* "\033OR" */
		589	case XK_KP_F4: /* "\033OS" */
		590	strcpy (kbuf, "\033OP");
		591	kbuf[2] += (keysym - XK_KP_F1);
		592	break;
		593
		594	case XK_KP_Multiply: /* "\033Oj" : "*" */
		595	case XK_KP_Add: /* "\033Ok" : "+" */
		596	case XK_KP_Separator: /* "\033Ol" : "," */
		597	case XK_KP_Subtract: /* "\033Om" : "-" */
		598	case XK_KP_Decimal: /* "\033On" : "." */
		599	case XK_KP_Divide: /* "\033Oo" : "/" */
		600	case XK_KP_0: /* "\033Op" : "0" */
		601	case XK_KP_1: /* "\033Oq" : "1" */
		602	case XK_KP_2: /* "\033Or" : "2" */
		603	case XK_KP_3: /* "\033Os" : "3" */
		604	case XK_KP_4: /* "\033Ot" : "4" */
		605	case XK_KP_5: /* "\033Ou" : "5" */
		606	case XK_KP_6: /* "\033Ov" : "6" */
		607	case XK_KP_7: /* "\033Ow" : "7" */
		608	case XK_KP_8: /* "\033Ox" : "8" */
		609	case XK_KP_9: /* "\033Oy" : "9" */
		610	/* allow shift to override */
		611	if (kp)
		612	{
		613	strcpy (kbuf, "\033Oj");
		614	kbuf[2] += (keysym - XK_KP_Multiply);
		615	}
		616	else
		617	{
		618	kbuf[0] = ('*' + (keysym - XK_KP_Multiply));
		619	kbuf[1] = '\0';
		620	}
		621	break;
		622
		623	default:
		624	{
		625	int param = map_function_key (keysym);
		626	if (param > 0)
		627	sprintf (kbuf,"\033[%d~", param);
		628	else
		629	newlen = 0;
		630	}
		631	break;
		632	}
		633
		634	if (newlen)
		635	len = strlen (kbuf);
		636
		637	if (len > 0)
		638	{
		639	/*
		640	* pass Shift/Control indicators for function keys ending with `~'
		641	*
		642	* eg,
		643	* Prior = "ESC[5~"
		644	* Shift+Prior = "ESC[5$"
		645	* Ctrl+Prior = "ESC[5^"
		646	* Ctrl+Shift+Prior = "ESC[5@"
		647	*/
		648	if (kbuf[0] == C0_ESC && kbuf[1] == '[' && kbuf[len - 1] == '~')
		649	kbuf[len - 1] = (shft ? (ctrl ? '@' : '$') : (ctrl ? '^' : '~'));
		650
		651	/*
		652	* Pass meta for all function keys, if 'meta' option set
		653	*/
		654	#ifdef META8_OPTION
		655	if (meta && (meta_char == 0x80))
		656	kbuf[len - 1] |= 0x80;
		657	#endif
		658	}
		659
		660	}
		661	else if (ctrl && keysym == XK_minus)
		662	{
		663	len = 1;
		664	kbuf[0] = '\037'; /* Ctrl-Minus generates ^_ (31) */
		665	}
		666	else if (keysym == XK_ISO_Left_Tab)
		667	{
		668	strcpy (kbuf, "\033[Z");
		669	len = 3;
		670	}
		671	else
		672	{
		673	#ifdef META8_OPTION
		674	/* set 8-bit on */
		675	if (meta && (meta_char == 0x80))
		676	{
		677	char *ch;
		678
		679	for (ch = kbuf; ch < kbuf + len; ch++)
		680	*ch |= 0x80;
		681	}
		682	#endif
		683	/* nil */ ;
		684	}
		685
		686	keysym = orig_keysym;
		687	}
		688
		689	/* escape prefix */
		690	if (len && meta
		691	#ifdef META8_OPTION
		692	&& meta_char == C0_ESC
		693	#endif
		694	)
		695	{
		696	*--kbuf = C0_ESC;
		697	len++;
		698	}
		699
		700	if (HOOK_INVOKE ((this, HOOK_KEY_PRESS, DT_XEVENT, &ev, DT_INT, keysym, DT_STR_LEN, kbuf, len, DT_END)))
		701	return;
		702
		703	if (keysym != NoSymbol)
490	{	704	{
491	#ifdef KEYSYM_RESOURCE	705	#ifdef KEYSYM_RESOURCE
492	if (keyboard->dispatch (this, keysym, ev.state))	706	if (keyboard->dispatch (this, keysym, ev.state, kbuf, len))
493	return;	707	return;
494	#endif	708	#endif
495		709
496	if (saveLines)	710	if (saveLines)
497	{	711	{
…		…
510	#endif	724	#endif
511	max_it (lnsppg, 1);	725	max_it (lnsppg, 1);
512		726
513	if (keysym == XK_Prior)	727	if (keysym == XK_Prior)
514	{	728	{
515	scr_page (UP, lnsppg);	729	scr_page (lnsppg);
516	return;	730	return;
517	}	731	}
518	else if (keysym == XK_Next)	732	else if (keysym == XK_Next)
519	{	733	{
520	scr_page (DN, lnsppg);	734	scr_page (-lnsppg);
521	return;	735	return;
522	}	736	}
523	}	737	}
524	#ifdef SCROLL_ON_UPDOWN_KEYS	738	#ifdef SCROLL_ON_UPDOWN_KEYS
525	if (IS_SCROLL_MOD)	739	if (IS_SCROLL_MOD)
526	{	740	{
527	if (keysym == XK_Up)	741	if (keysym == XK_Up)
528	{	742	{
529	scr_page (UP, 1);	743	scr_page (1);
530	return;	744	return;
531	}	745	}
532	else if (keysym == XK_Down)	746	else if (keysym == XK_Down)
533	{	747	{
534	scr_page (DN, 1);	748	scr_page (-1);
535	return;	749	return;
536	}	750	}
537	}	751	}
538	#endif	752	#endif
539	#ifdef SCROLL_ON_HOMEEND_KEYS	753	#ifdef SCROLL_ON_HOMEEND_KEYS
540	if (IS_SCROLL_MOD)	754	if (IS_SCROLL_MOD)
541	{	755	{
542	if (keysym == XK_Home)	756	if (keysym == XK_Home)
543	{	757	{
544	scr_move_to (0, 1);	758	scr_changeview (top_row);
545	return;	759	return;
546	}	760	}
547	else if (keysym == XK_End)	761	else if (keysym == XK_End)
548	{	762	{
549	scr_move_to (1, 1);	763	scr_changeview (0);
550	return;	764	return;
551	}	765	}
552	}	766	}
553	#endif	767	#endif
554	}	768	}
555		769
556	if (shft)	770	if (shft)
557	{	771	{
558	/* Shift + F1 - F10 generates F11 - F20 */
559	if (keysym >= XK_F1 && keysym <= XK_F10)
560	{
561	keysym += (XK_F11 - XK_F1);
562	shft = 0; /* turn off Shift */
563	}
564	else if (!ctrl && !meta && (priv_modes & PrivMode_ShiftKeys))	772	if (!ctrl && !meta && (priv_modes & PrivMode_ShiftKeys))
565	{	773	{
566	switch (keysym)	774	switch (keysym)
567	{	775	{
568	/* normal XTerm key bindings */	776	/* normal XTerm key bindings */
569	case XK_Insert: /* Shift+Insert = paste mouse selection */	777	case XK_Insert: /* Shift+Insert = paste mouse selection */
…		…
576	case XK_KP_Subtract: /* Shift+KP_Subtract = smaller font */	784	case XK_KP_Subtract: /* Shift+KP_Subtract = smaller font */
577	return;	785	return;
578	#endif	786	#endif
579	}	787	}
580	}	788	}
		789	}
		790
		791	if (ctrl && meta && (keysym == XK_c || keysym == XK_v))
		792	{
		793	if (keysym == XK_v)
		794	selection_request (ev.time, Sel_Clipboard);
		795	else if (selection.len > 0)
		796	{
		797	free (selection.clip_text);
		798	selection.clip_text = rxvt_wcsdup (selection.text, selection.len);
		799	selection.clip_len = selection.len;
		800	selection_grab (CurrentTime, true);
		801	}
		802
		803	return;
581	}	804	}
582		805
583	#if ENABLE_FRILLS || ISO_14755	806	#if ENABLE_FRILLS || ISO_14755
584	// ISO 14755 support	807	// ISO 14755 support
585	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_51))	808	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_51))
…		…
640	{	863	{
641	scr_printscreen (ctrl | shft);	864	scr_printscreen (ctrl | shft);
642	return;	865	return;
643	}	866	}
644	#endif	867	#endif
645
646	if (keysym >= 0xFF00 && keysym <= 0xFFFF)
647	{
648	bool kp = priv_modes & PrivMode_aplKP ? !shft : shft;
649	unsigned int newlen = 1;
650
651	if (ev.state & ModNumLockMask)
652	kp = false;
653
654	keysym = translate_keypad (keysym, kp);
655
656	switch (keysym)
657	{
658	#ifndef NO_BACKSPACE_KEY
659	case XK_BackSpace:
660	if (priv_modes & PrivMode_HaveBackSpace)
661	{
662	kbuf[0] = (!! (priv_modes & PrivMode_BackSpace)
663	^ !!ctrl) ? '\b' : '\177';
664	kbuf[1] = '\0';
665	}
666	else
667	strcpy (kbuf, rs[Rs_backspace_key]);
668	break;
669	#endif
670	#ifndef NO_DELETE_KEY
671	case XK_Delete:
672	strcpy (kbuf, rs[Rs_delete_key]);
673	break;
674	#endif
675	case XK_Tab:
676	if (shft)
677	strcpy (kbuf, "\033[Z");
678	else
679	{
680	#ifdef CTRL_TAB_MAKES_META
681	if (ctrl)
682	meta = 1;
683	#endif
684	#ifdef MOD4_TAB_MAKES_META
685	if (ev.state & Mod4Mask)
686	meta = 1;
687	#endif
688	newlen = 0;
689	}
690	break;
691
692	case XK_Up: /* "\033[A" */
693	case XK_Down: /* "\033[B" */
694	case XK_Right: /* "\033[C" */
695	case XK_Left: /* "\033[D" */
696	strcpy (kbuf, "\033[Z");
697	kbuf[2] = "DACB"[keysym - XK_Left];
698	/* do Shift first */
699	if (shft)
700	kbuf[2] = "dacb"[keysym - XK_Left];
701	else if (ctrl)
702	{
703	kbuf[1] = 'O';
704	kbuf[2] = "dacb"[keysym - XK_Left];
705	}
706	else if (priv_modes & PrivMode_aplCUR)
707	kbuf[1] = 'O';
708	break;
709
710	case XK_KP_Enter:
711	/* allow shift to override */
712	if (kp)
713	{
714	strcpy (kbuf, "\033OM");
715	break;
716	}
717
718	/* FALLTHROUGH */
719
720	case XK_Return:
721	if (priv_modes & PrivMode_LFNL)
722	{
723	kbuf[0] = '\015';
724	kbuf[1] = '\012';
725	kbuf[2] = '\0';
726	}
727	else
728	{
729	kbuf[0] = '\015';
730	kbuf[1] = '\0';
731	}
732	break;
733
734	case XK_KP_F1: /* "\033OP" */
735	case XK_KP_F2: /* "\033OQ" */
736	case XK_KP_F3: /* "\033OR" */
737	case XK_KP_F4: /* "\033OS" */
738	strcpy (kbuf, "\033OP");
739	kbuf[2] += (keysym - XK_KP_F1);
740	break;
741
742	case XK_KP_Multiply: /* "\033Oj" : "*" */
743	case XK_KP_Add: /* "\033Ok" : "+" */
744	case XK_KP_Separator: /* "\033Ol" : "," */
745	case XK_KP_Subtract: /* "\033Om" : "-" */
746	case XK_KP_Decimal: /* "\033On" : "." */
747	case XK_KP_Divide: /* "\033Oo" : "/" */
748	case XK_KP_0: /* "\033Op" : "0" */
749	case XK_KP_1: /* "\033Oq" : "1" */
750	case XK_KP_2: /* "\033Or" : "2" */
751	case XK_KP_3: /* "\033Os" : "3" */
752	case XK_KP_4: /* "\033Ot" : "4" */
753	case XK_KP_5: /* "\033Ou" : "5" */
754	case XK_KP_6: /* "\033Ov" : "6" */
755	case XK_KP_7: /* "\033Ow" : "7" */
756	case XK_KP_8: /* "\033Ox" : "8" */
757	case XK_KP_9: /* "\033Oy" : "9" */
758	/* allow shift to override */
759	if (kp)
760	{
761	strcpy (kbuf, "\033Oj");
762	kbuf[2] += (keysym - XK_KP_Multiply);
763	}
764	else
765	{
766	kbuf[0] = ('*' + (keysym - XK_KP_Multiply));
767	kbuf[1] = '\0';
768	}
769	break;
770
771	default:
772	{
773	int param = map_function_key (keysym);
774	if (param > 0)
775	sprintf (kbuf,"\033[%d~", param);
776	else
777	newlen = 0;
778	}
779	break;
780	}
781
782	if (newlen)
783	len = strlen (kbuf);
784
785	if (len > 0)
786	{
787	/*
788	* pass Shift/Control indicators for function keys ending with `~'
789	*
790	* eg,
791	* Prior = "ESC[5~"
792	* Shift+Prior = "ESC[5$"
793	* Ctrl+Prior = "ESC[5^"
794	* Ctrl+Shift+Prior = "ESC[5@"
795	*/
796	if (kbuf[0] == C0_ESC && kbuf[1] == '[' && kbuf[len - 1] == '~')
797	kbuf[len - 1] = (shft ? (ctrl ? '@' : '$') : (ctrl ? '^' : '~'));
798
799	/*
800	* Pass meta for all function keys, if 'meta' option set
801	*/
802	#ifdef META8_OPTION
803	if (meta && (meta_char == 0x80))
804	kbuf[len - 1] |= 0x80;
805	#endif
806	}
807
808	}
809	else if (ctrl && keysym == XK_minus)
810	{
811	len = 1;
812	kbuf[0] = '\037'; /* Ctrl-Minus generates ^_ (31) */
813	}
814	else if (keysym == XK_ISO_Left_Tab)
815	{
816	strcpy (kbuf, "\033[Z");
817	len = 3;
818	}
819	else
820	{
821	#ifdef META8_OPTION
822	/* set 8-bit on */
823	if (meta && (meta_char == 0x80))
824	{
825	char *ch;
826
827	for (ch = kbuf; ch < kbuf + len; ch++)
828	*ch |= 0x80;
829
830	meta = 0;
831	}
832	#endif
833	/* nil */ ;
834	}
835	}	868	}
836
837	if (HOOK_INVOKE ((this, HOOK_KEY_PRESS, DT_XEVENT, &ev, DT_INT, keysym, DT_STR_LEN, kbuf, len, DT_END)))
838	return;
839		869
840	if (len <= 0)	870	if (len <= 0)
841	return; /* not mapped */	871	return; /* not mapped */
842		872
843	if (option (Opt_scrollTtyKeypress))
844	if (view_start)
845	{
846	view_start = 0;
847	want_refresh = 1;
848	}
849
850	/* escape prefix */
851	if (meta
852	#ifdef META8_OPTION
853	&& meta_char == C0_ESC
854	#endif
855	)
856	{
857	const char ch = C0_ESC;
858	tt_write (&ch, 1);
859	}
860
861	tt_write (kbuf, (unsigned int)len);	873	tt_write_user_input (kbuf, (unsigned int)len);
862	}	874	}
863		875
864	void ecb_cold	876	void ecb_cold
865	rxvt_term::key_release (XKeyEvent &ev)	877	rxvt_term::key_release (XKeyEvent &ev)
866	{	878	{
…		…
941	void	953	void
942	rxvt_term::flush ()	954	rxvt_term::flush ()
943	{	955	{
944	flush_ev.stop ();	956	flush_ev.stop ();
945		957
946	#ifdef HAVE_BG_PIXMAP	958	#ifdef HAVE_IMG
947	if (bg_flags & BG_NEEDS_REFRESH)	959	if (bg_flags & BG_NEEDS_REFRESH)
948	{	960	{
949	bg_flags &= ~BG_NEEDS_REFRESH;	961	bg_flags &= ~BG_NEEDS_REFRESH;
950	scr_touch (false);	962	scr_touch (false);
951	}	963	}
…		…
1022		1034
1023	#ifdef CURSOR_BLINK	1035	#ifdef CURSOR_BLINK
1024	void	1036	void
1025	rxvt_term::cursor_blink_reset ()	1037	rxvt_term::cursor_blink_reset ()
1026	{	1038	{
		1039	if (!focus)
		1040	return;
		1041
1027	if (hidden_cursor)	1042	if (hidden_cursor)
1028	{	1043	{
1029	hidden_cursor = 0;	1044	hidden_cursor = 0;
1030	want_refresh = 1;	1045	want_refresh = 1;
1031	}	1046	}
1032		1047
1033	if (option (Opt_cursorBlink))	1048	if (option (Opt_cursorBlink) || (priv_modes & PrivMode_BlinkingCursor))
1034	cursor_blink_ev.again ();	1049	cursor_blink_ev.again ();
1035	else	1050	else
1036	cursor_blink_ev.stop ();	1051	cursor_blink_ev.stop ();
1037	}	1052	}
1038		1053
…		…
1077		1092
1078	#ifdef SELECTION_SCROLLING	1093	#ifdef SELECTION_SCROLLING
1079	void	1094	void
1080	rxvt_term::sel_scroll_cb (ev::timer &w, int revents)	1095	rxvt_term::sel_scroll_cb (ev::timer &w, int revents)
1081	{	1096	{
1082	if (scr_page (scroll_selection_dir, scroll_selection_lines))	1097	if (scr_page (scroll_selection_lines))
1083	{	1098	{
1084	selection_extend (selection_save_x, selection_save_y, selection_save_state);	1099	selection_extend (selection_save_x, selection_save_y, selection_save_state);
1085	want_refresh = 1;	1100	want_refresh = 1;
1086	refresh_check ();	1101	refresh_check ();
1087	}	1102	}
…		…
1092		1107
1093	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)	1108	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
1094	void	1109	void
1095	rxvt_term::slip_wheel_cb (ev::timer &w, int revents)	1110	rxvt_term::slip_wheel_cb (ev::timer &w, int revents)
1096	{	1111	{
1097	if (scr_changeview (view_start - mouse_slip_wheel_speed))	1112	if (scr_page (mouse_slip_wheel_speed))
1098	{	1113	{
1099	want_refresh = 1;	1114	want_refresh = 1;
1100	refresh_check ();	1115	refresh_check ();
1101	}	1116	}
1102		1117
…		…
1227		1242
1228	void ecb_cold	1243	void ecb_cold
1229	rxvt_term::pointer_unblank ()	1244	rxvt_term::pointer_unblank ()
1230	{	1245	{
1231	XDefineCursor (dpy, vt, TermWin_cursor);	1246	XDefineCursor (dpy, vt, TermWin_cursor);
1232	recolour_cursor ();	1247	recolor_cursor ();
1233		1248
1234	#ifdef POINTER_BLANK	1249	#ifdef POINTER_BLANK
1235	hidden_pointer = 0;	1250	hidden_pointer = 0;
1236		1251
1237	if (option (Opt_pointerBlank))	1252	if (option (Opt_pointerBlank))
…		…
1262	#endif	1277	#endif
1263		1278
1264	void	1279	void
1265	rxvt_term::mouse_report (XButtonEvent &ev)	1280	rxvt_term::mouse_report (XButtonEvent &ev)
1266	{	1281	{
1267	int button_number, key_state = 0;	1282	int button_number, state = 0;
1268	int x, y;	1283	int x, y;
1269	int code = 32;	1284	bool release = ev.type == ButtonRelease;
1270		1285
1271	x = Pixel2Col (ev.x) + 1;	1286	x = Pixel2Col (ev.x) + 1;
1272	y = Pixel2Row (ev.y) + 1;	1287	y = Pixel2Row (ev.y) + 1;
1273		1288
1274	if (ev.type == MotionNotify)	1289	if (ev.type == MotionNotify)
…		…
1276	if (x == mouse_row && y == mouse_col)	1291	if (x == mouse_row && y == mouse_col)
1277	return;	1292	return;
1278		1293
1279	mouse_row = x;	1294	mouse_row = x;
1280	mouse_col = y;	1295	mouse_col = y;
1281	code += 32;	1296	state += 32;
1282	}
1283
1284	if (MEvent.button == AnyButton)
1285	button_number = 3;
1286	else
1287	{	1297	}
		1298
1288	button_number = MEvent.button - Button1;	1299	button_number = MEvent.button - Button1;
1289	/* add 0x3D for wheel events, like xterm does */	1300	/* add 0x3D for wheel events, like xterm does */
1290	if (button_number >= 3)	1301	if (button_number >= 3)
1291	button_number += 64 - 3;	1302	button_number += 64 - 3;
1292	}
1293		1303
1294	if (priv_modes & PrivMode_MouseX10)	1304	if (priv_modes & PrivMode_MouseX10)
1295	{	1305	{
1296	/*	1306	/*
1297	* do not report ButtonRelease	1307	* do not report ButtonRelease
1298	* no state info allowed	1308	* no state info allowed
1299	*/	1309	*/
1300	key_state = 0;	1310	if (release)
1301	if (button_number == 3)
1302	return;	1311	return;
1303	}	1312	}
1304	else	1313	else
1305	{	1314	{
1306	/* XTerm mouse reporting needs these values:	1315	/* XTerm mouse reporting needs these values:
…		…
1308	* 8 = Meta	1317	* 8 = Meta
1309	* 16 = Control	1318	* 16 = Control
1310	* plus will add in our own Double-Click reporting	1319	* plus will add in our own Double-Click reporting
1311	* 32 = Double Click	1320	* 32 = Double Click
1312	*/	1321	*/
1313	key_state = ((MEvent.state & ShiftMask) ? 4 : 0)	1322	state += ((MEvent.state & ShiftMask) ? 4 : 0)
1314	+ ((MEvent.state & ModMetaMask) ? 8 : 0)	1323	+ ((MEvent.state & ModMetaMask) ? 8 : 0)
1315	+ ((MEvent.state & ControlMask) ? 16 : 0);	1324	+ ((MEvent.state & ControlMask) ? 16 : 0);
1316	#ifdef MOUSE_REPORT_DOUBLECLICK	1325	#ifdef MOUSE_REPORT_DOUBLECLICK
1317	key_state += ((MEvent.clicks > 1) ? 32 : 0);	1326	state += ((MEvent.clicks > 1) ? 32 : 0);
1318	#endif	1327	#endif
1319	}	1328	}
		1329
		1330	int code = 32 + (release ? 3 : button_number) + state;
1320		1331
1321	#if DEBUG_MOUSEREPORT	1332	#if DEBUG_MOUSEREPORT
1322	fprintf (stderr, "Mouse [");	1333	fprintf (stderr, "Mouse [");
1323	if (key_state & 16)	1334	if (state & 16)
1324	fputc ('C', stderr);	1335	fputc ('C', stderr);
1325	if (key_state & 4)	1336	if (state & 4)
1326	fputc ('S', stderr);	1337	fputc ('S', stderr);
1327	if (key_state & 8)	1338	if (state & 8)
1328	fputc ('A', stderr);	1339	fputc ('A', stderr);
1329	if (key_state & 32)	1340	if (state & 32)
1330	fputc ('2', stderr);	1341	fputc ('2', stderr);
1331	fprintf (stderr, "]: <%d>, %d/%d\n",	1342	fprintf (stderr, "]: <%d>, %d/%d\n",
1332	button_number,	1343	button_number,
1333	x,	1344	x,
1334	y);	1345	y);
1335	#endif	1346	#endif
1336		1347
1337	#if ENABLE_FRILLS	1348	#if ENABLE_FRILLS
1338	if (priv_modes & PrivMode_ExtMouseRight)	1349	if (priv_modes & PrivMode_ExtMouseSGR)
		1350	tt_printf ("\033[<%d;%d;%d%c",
		1351	button_number + state,
		1352	x,
		1353	y,
		1354	release ? 'm' : 'M');
		1355	else if (priv_modes & PrivMode_ExtMouseUrxvt)
1339	tt_printf ("\033[%d;%d;%dM",	1356	tt_printf ("\033[%d;%d;%dM",
1340	code + button_number + key_state,	1357	code,
1341	x,	1358	x,
1342	y);	1359	y);
1343	else if (priv_modes & PrivMode_ExtModeMouse)	1360	else if (priv_modes & PrivMode_ExtMouseUTF8)
1344	tt_printf ("\033[M%c%lc%lc",	1361	tt_printf ("\033[M%c%lc%lc",
1345	code + button_number + key_state,	1362	code,
1346	wint_t (32 + x),	1363	wint_t (32 + x),
1347	wint_t (32 + y));	1364	wint_t (32 + y));
1348	else	1365	else
1349	#endif	1366	#endif
1350	tt_printf ("\033[M%c%c%c",	1367	tt_printf ("\033[M%c%c%c",
1351	code + button_number + key_state,	1368	code,
1352	32 + x,	1369	32 + x,
1353	32 + y);	1370	32 + y);
1354	}	1371	}
1355		1372
1356	/*{{{ process an X event */	1373	/*{{{ process an X event */
…		…
1467	while (XCheckTypedWindowEvent (dpy, ev.xconfigure.window, ConfigureNotify, &ev))	1484	while (XCheckTypedWindowEvent (dpy, ev.xconfigure.window, ConfigureNotify, &ev))
1468	;	1485	;
1469		1486
1470	bool want_position_change = SHOULD_INVOKE (HOOK_POSITION_CHANGE);	1487	bool want_position_change = SHOULD_INVOKE (HOOK_POSITION_CHANGE);
1471		1488
1472	#ifdef HAVE_BG_PIXMAP
1473	if (bg_window_position_sensitive ())
1474	want_position_change = true;
1475	#endif
1476
1477	bool moved = false;
1478
1479	if (want_position_change)	1489	if (want_position_change)
1480	{	1490	{
1481	int x, y;	1491	int x, y;
1482		1492
1483	if (ev.xconfigure.send_event)	1493	if (ev.xconfigure.send_event)
…		…
1488	else	1498	else
1489	get_window_origin (x, y);	1499	get_window_origin (x, y);
1490		1500
1491	if (x != parent_x || y != parent_y)	1501	if (x != parent_x || y != parent_y)
1492	{	1502	{
1493	HOOK_INVOKE ((this, HOOK_POSITION_CHANGE, DT_INT, x, DT_INT, y, DT_END));
1494	parent_x = x;	1503	parent_x = x;
1495	parent_y = y;	1504	parent_y = y;
		1505	HOOK_INVOKE ((this, HOOK_POSITION_CHANGE, DT_INT, x, DT_INT, y, DT_END));
1496	}	1506	}
1497
1498	if (bg_set_position (x, y)
1499	|| !(bg_flags & BG_IS_VALID))
1500	moved = true;
1501	}	1507	}
1502		1508
1503	if (szHint.width != ev.xconfigure.width || szHint.height != ev.xconfigure.height)	1509	if (szHint.width != ev.xconfigure.width || szHint.height != ev.xconfigure.height)
1504	{	1510	{
1505	seen_resize = 1;	1511	seen_resize = 1;
1506	resize_all_windows (ev.xconfigure.width, ev.xconfigure.height, 1);	1512	resize_all_windows (ev.xconfigure.width, ev.xconfigure.height, 1);
1507	}	1513	}
1508	else
1509	{
1510	#ifdef HAVE_BG_PIXMAP
1511	if (moved)
1512	update_background ();
1513	#endif
1514	}
1515		1514
1516	HOOK_INVOKE ((this, HOOK_CONFIGURE_NOTIFY, DT_XEVENT, &ev, DT_END));	1515	HOOK_INVOKE ((this, HOOK_CONFIGURE_NOTIFY, DT_XEVENT, &ev, DT_END));
1517	}	1516	}
1518	break;	1517	break;
1519		1518
…		…
1528	case SelectionRequest:	1527	case SelectionRequest:
1529	selection_send (ev.xselectionrequest);	1528	selection_send (ev.xselectionrequest);
1530	break;	1529	break;
1531		1530
1532	case MapNotify:	1531	case MapNotify:
1533	#ifdef HAVE_BG_PIXMAP
1534	/* This is needed specifically to fix the case of no window manager or a
1535	* non-reparenting window manager. In those cases we never get first
1536	* ConfigureNotify. Also that speeds startup under normal WM, by taking
1537	* care of multiplicity of ConfigureNotify events arriving while WM does
1538	* reparenting.
1539	* We should not render background immediately, as there could be several
1540	* ConfigureNotify's to follow. Lets take care of all of them in one scoop
1541	* by scheduling background redraw as soon as we can, but giving a short
1542	* bit of time for ConfigureNotifies to arrive.
1543	* We should render background PRIOR to drawing any text, but AFTER all
1544	* of ConfigureNotifys for the best results.
1545	*/
1546	if (!(bg_flags & BG_IS_VALID))
1547	update_background_ev.start (0.025);
1548	#endif
1549	mapped = 1;	1532	mapped = 1;
1550	#ifdef TEXT_BLINK	1533	#ifdef TEXT_BLINK
1551	text_blink_ev.start ();	1534	text_blink_ev.start ();
1552	#endif	1535	#endif
1553	HOOK_INVOKE ((this, HOOK_MAP_NOTIFY, DT_XEVENT, &ev, DT_END));	1536	HOOK_INVOKE ((this, HOOK_MAP_NOTIFY, DT_XEVENT, &ev, DT_END));
…		…
1602	case MotionNotify:	1585	case MotionNotify:
1603	#ifdef POINTER_BLANK	1586	#ifdef POINTER_BLANK
1604	if (hidden_pointer)	1587	if (hidden_pointer)
1605	pointer_unblank ();	1588	pointer_unblank ();
1606	#endif	1589	#endif
		1590	if (!bypass_keystate
1607	if ((priv_modes & PrivMode_MouseBtnEvent && ev.xbutton.state & (Button1Mask|Button2Mask|Button3Mask))	1591	&& ((priv_modes & PrivMode_MouseBtnEvent && ev.xbutton.state & (Button1Mask|Button2Mask|Button3Mask))
1608	|| priv_modes & PrivMode_MouseAnyEvent)	1592	|| priv_modes & PrivMode_MouseAnyEvent))
1609	mouse_report (ev.xbutton);	1593	mouse_report (ev.xbutton);
1610	if ((priv_modes & PrivMode_mouse_report) && !bypass_keystate)	1594	if ((priv_modes & PrivMode_mouse_report) && !bypass_keystate)
1611	break;	1595	break;
1612		1596
1613	if (ev.xany.window == vt)	1597	if (ev.xany.window == vt)
…		…
1625	&unused_root_x, &unused_root_y,	1609	&unused_root_x, &unused_root_y,
1626	&ev.xbutton.x, &ev.xbutton.y,	1610	&ev.xbutton.x, &ev.xbutton.y,
1627	&ev.xbutton.state);	1611	&ev.xbutton.state);
1628	#ifdef MOUSE_THRESHOLD	1612	#ifdef MOUSE_THRESHOLD
1629	/* deal with a `jumpy' mouse */	1613	/* deal with a `jumpy' mouse */
1630	if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)	1614	if (ev.xmotion.time - MEvent.time > MOUSE_THRESHOLD)
		1615	#endif
1631	{	1616	{
1632	#endif
1633	#if ISO_14755	1617	#if ISO_14755
1634	// 5.4	1618	// 5.4
1635	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))	1619	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
1636	{	1620	{
1637	iso14755_54 (ev.xbutton.x, ev.xbutton.y);	1621	iso14755_54 (ev.xbutton.x, ev.xbutton.y);
…		…
1643		1627
1644	#ifdef SELECTION_SCROLLING	1628	#ifdef SELECTION_SCROLLING
1645	if (ev.xbutton.y < int_bwidth	1629	if (ev.xbutton.y < int_bwidth
1646	|| Pixel2Row (ev.xbutton.y) > (nrow-1))	1630	|| Pixel2Row (ev.xbutton.y) > (nrow-1))
1647	{	1631	{
		1632	page_dirn scroll_selection_dir;
1648	int dist;	1633	int dist;
1649		1634
1650	/* don't clobber the current delay if we are	1635	/* don't clobber the current delay if we are
1651	* already in the middle of scrolling.	1636	* already in the middle of scrolling.
1652	*/	1637	*/
…		…
1675	scroll_selection_lines = Pixel2Height (dist)	1660	scroll_selection_lines = Pixel2Height (dist)
1676	/ SELECTION_SCROLL_LINE_SPEEDUP	1661	/ SELECTION_SCROLL_LINE_SPEEDUP
1677	+ 1;	1662	+ 1;
1678	min_it (scroll_selection_lines,	1663	min_it (scroll_selection_lines,
1679	SELECTION_SCROLL_MAX_LINES);	1664	SELECTION_SCROLL_MAX_LINES);
		1665	scroll_selection_lines *= scroll_selection_dir;
1680	}	1666	}
1681	else	1667	else
1682	{	1668	{
1683	/* we are within the text window, so we	1669	/* we are within the text window, so we
1684	* shouldn't be scrolling	1670	* shouldn't be scrolling
1685	*/	1671	*/
1686	sel_scroll_ev.stop();	1672	sel_scroll_ev.stop();
1687	}	1673	}
1688	#endif	1674	#endif
1689	#ifdef MOUSE_THRESHOLD
1690	}	1675	}
1691	#endif
1692	}	1676	}
1693	}	1677	}
1694	else if (scrollBar.state == SB_STATE_MOTION && ev.xany.window == scrollBar.win)	1678	else if (scrollBar.state == SB_STATE_MOTION && ev.xany.window == scrollBar.win)
1695	{	1679	{
1696	while (XCheckTypedWindowEvent (dpy, scrollBar.win,	1680	while (XCheckTypedWindowEvent (dpy, scrollBar.win,
…		…
1770	#endif	1754	#endif
1771	#if OFF_FOCUS_FADING	1755	#if OFF_FOCUS_FADING
1772	if (rs[Rs_fade])	1756	if (rs[Rs_fade])
1773	{	1757	{
1774	pix_colors = pix_colors_focused;	1758	pix_colors = pix_colors_focused;
1775	scr_recolour ();	1759	scr_recolor ();
1776	}	1760	}
1777	#endif	1761	#endif
1778	#if ENABLE_FRILLS	1762	#if ENABLE_FRILLS
1779	if (option (Opt_urgentOnBell))	1763	if (option (Opt_urgentOnBell))
1780	set_urgency (0);	1764	set_urgency (0);
		1765
		1766	if (priv_modes & PrivMode_FocusEvent)
		1767	tt_printf ("\x1b[I");
1781	#endif	1768	#endif
1782		1769
1783	HOOK_INVOKE ((this, HOOK_FOCUS_IN, DT_END));	1770	HOOK_INVOKE ((this, HOOK_FOCUS_IN, DT_END));
1784	}	1771	}
1785	}	1772	}
…		…
1793	want_refresh = 1;	1780	want_refresh = 1;
1794		1781
1795	#if ENABLE_FRILLS	1782	#if ENABLE_FRILLS
1796	if (option (Opt_urgentOnBell))	1783	if (option (Opt_urgentOnBell))
1797	set_urgency (0);	1784	set_urgency (0);
		1785
		1786	if (priv_modes & PrivMode_FocusEvent)
		1787	tt_printf ("\x1b[O");
1798	#endif	1788	#endif
1799	#if ENABLE_FRILLS || ISO_14755	1789	#if ENABLE_FRILLS || ISO_14755
1800	if (iso14755buf)	1790	if (iso14755buf)
1801	{	1791	{
1802	iso14755buf = 0;	1792	iso14755buf = 0;
…		…
1817	#endif	1807	#endif
1818	#if OFF_FOCUS_FADING	1808	#if OFF_FOCUS_FADING
1819	if (rs[Rs_fade])	1809	if (rs[Rs_fade])
1820	{	1810	{
1821	pix_colors = pix_colors_unfocused;	1811	pix_colors = pix_colors_unfocused;
1822	scr_recolour ();	1812	scr_recolor ();
1823	}	1813	}
1824	#endif	1814	#endif
1825		1815
1826	HOOK_INVOKE ((this, HOOK_FOCUS_OUT, DT_END));	1816	HOOK_INVOKE ((this, HOOK_FOCUS_OUT, DT_END));
1827	}	1817	}
1828	}	1818	}
1829		1819
1830	void ecb_cold	1820	void ecb_cold
1831	rxvt_term::update_fade_color (unsigned int idx)	1821	rxvt_term::update_fade_color (unsigned int idx, bool first_time)
1832	{	1822	{
1833	#if OFF_FOCUS_FADING	1823	#if OFF_FOCUS_FADING
1834	if (rs[Rs_fade])	1824	if (rs[Rs_fade])
1835	{	1825	{
		1826	if (!first_time)
		1827	pix_colors_focused [idx].free (this);
		1828
1836	rgba c;	1829	rgba c;
1837	pix_colors [Color_fade].get (c);	1830	pix_colors [Color_fade].get (c);
1838	pix_colors_focused [idx].fade (this, atoi (rs[Rs_fade]), pix_colors_unfocused [idx], c);	1831	pix_colors_focused [idx].fade (this, atoi (rs[Rs_fade]), pix_colors_unfocused [idx], c);
1839	}	1832	}
1840	#endif	1833	#endif
1841	}	1834	}
1842		1835
1843	#if ENABLE_TRANSPARENCY || ENABLE_PERL	1836	#if ENABLE_PERL
1844	void ecb_hot	1837	void ecb_hot
1845	rxvt_term::rootwin_cb (XEvent &ev)	1838	rxvt_term::rootwin_cb (XEvent &ev)
1846	{	1839	{
1847	make_current ();	1840	make_current ();
1848		1841
…		…
1858	* use the property to determine the pixmap. We use it later on.	1851	* use the property to determine the pixmap. We use it later on.
1859	*/	1852	*/
1860	if (ev.xproperty.atom == xa[XA_XROOTPMAP_ID]	1853	if (ev.xproperty.atom == xa[XA_XROOTPMAP_ID]
1861	|| ev.xproperty.atom == xa[XA_ESETROOT_PMAP_ID])	1854	|| ev.xproperty.atom == xa[XA_ESETROOT_PMAP_ID])
1862	{	1855	{
1863	# if ENABLE_TRANSPARENCY
1864	bg_set_root_pixmap ();
1865	update_background ();
1866	#endif
1867	#if ENABLE_PERL
1868	HOOK_INVOKE ((this, HOOK_ROOTPMAP_CHANGE, DT_END));	1856	HOOK_INVOKE ((this, HOOK_ROOTPMAP_CHANGE, DT_END));
1869	#endif
1870	}	1857	}
1871		1858
1872	break;	1859	break;
1873	}	1860	}
1874		1861
…		…
1901	iso14755_54 (ev.x, ev.y);	1888	iso14755_54 (ev.x, ev.y);
1902	return;	1889	return;
1903	}	1890	}
1904	#endif	1891	#endif
1905		1892
1906	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;	1893	clickintime = ev.time - MEvent.time < multiClickTime;
1907		1894
1908	if (reportmode)	1895	if (reportmode)
1909	{	1896	{
1910	/* mouse report from vt window */	1897	/* mouse report from vt window */
1911	/* save the xbutton state (for ButtonRelease) */	1898	/* save the xbutton state (for ButtonRelease) */
…		…
2161	#ifdef MOUSE_REPORT_DOUBLECLICK	2148	#ifdef MOUSE_REPORT_DOUBLECLICK
2162	/* only report the release of 'slow' single clicks */	2149	/* only report the release of 'slow' single clicks */
2163	if (MEvent.button != AnyButton	2150	if (MEvent.button != AnyButton
2164	&& (ev.button != MEvent.button	2151	&& (ev.button != MEvent.button
2165	|| (ev.time - MEvent.time	2152	|| (ev.time - MEvent.time
2166	> MULTICLICK_TIME / 2)))	2153	> multiClickTime / 2)))
2167	{	2154	{
2168	MEvent.clicks = 0;	2155	MEvent.clicks = 0;
2169	MEvent.button = AnyButton;	2156	MEvent.button = ev.button;
2170	mouse_report (ev);	2157	mouse_report (ev);
2171	}	2158	}
2172	#else /* MOUSE_REPORT_DOUBLECLICK */	2159	#else /* MOUSE_REPORT_DOUBLECLICK */
2173	MEvent.button = AnyButton;	2160	MEvent.button = ev.button;
2174	mouse_report (ev);	2161	mouse_report (ev);
2175	#endif /* MOUSE_REPORT_DOUBLECLICK */	2162	#endif /* MOUSE_REPORT_DOUBLECLICK */
2176	return;	2163	return;
2177	}	2164	}
2178		2165
…		…
2199		2186
2200	#ifdef MOUSE_WHEEL	2187	#ifdef MOUSE_WHEEL
2201	case Button4:	2188	case Button4:
2202	case Button5:	2189	case Button5:
2203	{	2190	{
2204	int i;	2191	int lines;
2205	page_dirn v;	2192	page_dirn dirn;
2206		2193
2207	v = ev.button == Button4 ? UP : DN;	2194	dirn = ev.button == Button4 ? UP : DN;
2208		2195
2209	if (ev.state & ShiftMask)	2196	if (ev.state & ShiftMask)
2210	i = 1;	2197	lines = 1;
2211	else if (option (Opt_mouseWheelScrollPage))	2198	else if (option (Opt_mouseWheelScrollPage))
2212	i = nrow - 1;	2199	lines = nrow - 1;
2213	else	2200	else
2214	i = 5;	2201	lines = 5;
2215		2202
2216	# ifdef MOUSE_SLIP_WHEELING	2203	# ifdef MOUSE_SLIP_WHEELING
2217	if (ev.state & ControlMask)	2204	if (ev.state & ControlMask)
2218	{	2205	{
2219	mouse_slip_wheel_speed += v ? -1 : 1;	2206	mouse_slip_wheel_speed += dirn;
2220	if (mouse_slip_wheel_speed < -nrow) mouse_slip_wheel_speed = -nrow;	2207	clamp_it (mouse_slip_wheel_speed, -nrow, nrow);
2221	if (mouse_slip_wheel_speed > +nrow) mouse_slip_wheel_speed = +nrow;
2222		2208
2223	if (!slip_wheel_ev.is_active ())	2209	if (!slip_wheel_ev.is_active ())
2224	slip_wheel_ev.start (SCROLLBAR_CONTINUOUS_DELAY, SCROLLBAR_CONTINUOUS_DELAY);	2210	slip_wheel_ev.start (SCROLLBAR_CONTINUOUS_DELAY, SCROLLBAR_CONTINUOUS_DELAY);
2225	}	2211	}
2226	else	2212	else
2227	# endif	2213	# endif
2228	{	2214	{
2229	scr_page (v, i);	2215	scr_page (dirn, lines);
2230	scrollBar.show (1);	2216	scrollBar.show (1);
2231	}	2217	}
2232	}	2218	}
2233	break;	2219	break;
2234	#endif	2220	#endif
…		…
2366	}	2352	}
2367	}	2353	}
2368		2354
2369	// read the next character	2355	// read the next character
2370	wchar_t ecb_hot	2356	wchar_t ecb_hot
2371	rxvt_term::next_char () NOTHROW	2357	rxvt_term::next_char () noexcept
2372	{	2358	{
2373	while (cmdbuf_ptr < cmdbuf_endp)	2359	while (cmdbuf_ptr < cmdbuf_endp)
2374	{	2360	{
2375	// assume 7-bit to be ascii ALWAYS	2361	// assume 7-bit to be ascii ALWAYS (always true in POSIX)
2376	if (ecb_likely ((unsigned char)*cmdbuf_ptr <= 0x7f && *cmdbuf_ptr != 0x1b))	2362	if (ecb_likely ((unsigned char)*cmdbuf_ptr <= 0x7f))
2377	return *cmdbuf_ptr++;	2363	return *cmdbuf_ptr++;
2378		2364
2379	wchar_t wc;	2365	wchar_t wc;
2380	size_t len = mbrtowc (&wc, cmdbuf_ptr, cmdbuf_endp - cmdbuf_ptr, mbstate);	2366	size_t len = mbrtowc (&wc, cmdbuf_ptr, cmdbuf_endp - cmdbuf_ptr, mbstate);
2381		2367
…		…
2387	}	2373	}
2388		2374
2389	if (len == (size_t)-1)	2375	if (len == (size_t)-1)
2390	{	2376	{
2391	mbstate.reset (); // reset now undefined conversion state	2377	mbstate.reset (); // reset now undefined conversion state
		2378	// a -1 might indicate that a previous incomplete char is invalid (previous return -2)
		2379	// in which case we "erroneously" return the next byte which might be valid.
2392	return (unsigned char)*cmdbuf_ptr++; // the _occasional_ latin1 character is allowed to slip through	2380	return (unsigned char)*cmdbuf_ptr++; // the _occasional_ latin1 character is allowed to slip through
2393	}	2381	}
2394		2382
2395	// assume wchar == unicode	2383	// assume wchar == unicode
2396	cmdbuf_ptr += len;	2384	cmdbuf_ptr += len;
…		…
2400	return NOCHAR;	2388	return NOCHAR;
2401	}	2389	}
2402		2390
2403	// read the next octet	2391	// read the next octet
2404	uint32_t ecb_hot	2392	uint32_t ecb_hot
2405	rxvt_term::next_octet () NOTHROW	2393	rxvt_term::next_octet () noexcept
2406	{	2394	{
2407	return cmdbuf_ptr < cmdbuf_endp	2395	return cmdbuf_ptr < cmdbuf_endp
2408	? (unsigned char)*cmdbuf_ptr++	2396	? (unsigned char)*cmdbuf_ptr++
2409	: NOCHAR;	2397	: NOCHAR;
2410	}	2398	}
2411		2399
2412	static class out_of_input out_of_input;	2400	static class out_of_input out_of_input;
2413		2401
2414	wchar_t ecb_hot	2402	wchar_t ecb_hot
2415	rxvt_term::cmd_getc () THROW ((class out_of_input))	2403	rxvt_term::cmd_getc ()
2416	{	2404	{
2417	wchar_t c = next_char ();	2405	wchar_t c = next_char ();
2418		2406
2419	if (c == NOCHAR)	2407	if (c == NOCHAR)
2420	throw out_of_input;	2408	throw out_of_input;
2421		2409
2422	return c;	2410	return c;
2423	}	2411	}
2424		2412
2425	uint32_t ecb_hot	2413	uint32_t ecb_hot
2426	rxvt_term::cmd_get8 () THROW ((class out_of_input))	2414	rxvt_term::cmd_get8 ()
2427	{	2415	{
2428	uint32_t c = next_octet ();	2416	uint32_t c = next_octet ();
2429		2417
2430	if (c == NOCHAR)	2418	if (c == NOCHAR)
2431	throw out_of_input;	2419	throw out_of_input;
…		…
2560	scr_charset_choose (0);	2548	scr_charset_choose (0);
2561	break;	2549	break;
2562		2550
2563	#ifdef EIGHT_BIT_CONTROLS	2551	#ifdef EIGHT_BIT_CONTROLS
2564	// 8-bit controls	2552	// 8-bit controls
2565	case 0x90: /* DCS */	2553	case 0x90: /* DCS */
2566	process_dcs_seq ();	2554	process_dcs_seq ();
2567	break;	2555	break;
2568	case 0x9b: /* CSI */	2556	case 0x9b: /* CSI */
2569	process_csi_seq ();	2557	process_csi_seq ();
2570	break;	2558	break;
2571	case 0x9d: /* OSC */	2559	case 0x9d: /* OSC */
2572	process_osc_seq ();	2560	process_osc_seq ();
2573	break;	2561	break;
2574	#endif	2562	#endif
2575	}	2563	}
2576	}	2564	}
…		…
2704	wchar_t nlcr[] = { C0_LF, C0_CR };	2692	wchar_t nlcr[] = { C0_LF, C0_CR };
2705	scr_add_lines (nlcr, ecb_array_length (nlcr), 1);	2693	scr_add_lines (nlcr, ecb_array_length (nlcr), 1);
2706	}	2694	}
2707	break;	2695	break;
2708		2696
		2697	#if 0 // disabled because embedded newlines can make exploits easier
2709	/* kidnapped escape sequence: Should be 8.3.48 */	2698	/* kidnapped escape sequence: Should be 8.3.48 */
2710	case C1_ESA: /* ESC G */	2699	case C1_ESA: /* ESC G */
2711	// used by original rxvt for rob nations own graphics mode	2700	// used by original rxvt for rob nations own graphics mode
2712	if (cmd_getc () == 'Q')	2701	if (cmd_getc () == 'Q' && option (Opt_insecure))
2713	tt_printf ("\033G0\012"); /* query graphics - no graphics */	2702	tt_printf ("\033G0\012"); /* query graphics - no graphics */
2714	break;	2703	break;
		2704	#endif
2715		2705
2716	/* 8.3.63: CHARACTER TABULATION SET */	2706	/* 8.3.63: CHARACTER TABULATION SET */
2717	case C1_HTS: /* ESC H */	2707	case C1_HTS: /* ESC H */
2718	scr_set_tab (1);	2708	scr_set_tab (1);
2719	break;	2709	break;
…		…
2801	};	2791	};
2802		2792
2803	void ecb_hot	2793	void ecb_hot
2804	rxvt_term::process_csi_seq ()	2794	rxvt_term::process_csi_seq ()
2805	{	2795	{
2806	unicode_t ch, priv, i;	2796	unicode_t ch, priv, prev_ch, i;
2807	unsigned int nargs, p;	2797	unsigned int nargs, p;
2808	int n, ndef;	2798	int n, ndef;
2809	int arg[ESC_ARGS] = { };	2799	int arg[ESC_ARGS] = { };
2810		2800
2811	nargs = 0;	2801	nargs = 0;
…		…
2817	/* '<' '=' '>' '?' '!' */	2807	/* '<' '=' '>' '?' '!' */
2818	priv = ch;	2808	priv = ch;
2819	ch = cmd_getc ();	2809	ch = cmd_getc ();
2820	}	2810	}
2821		2811
		2812	prev_ch = 0;
2822	/* read any numerical arguments */	2813	/* read any numerical arguments */
2823	for (n = -1; ch < CSI_ICH; )	2814	for (n = -1; ch < CSI_ICH; )
2824	{	2815	{
2825	if (isdigit (ch))	2816	if (isdigit (ch))
2826	{	2817	{
…		…
2836	n = -1;	2827	n = -1;
2837	}	2828	}
2838	else if (IS_CONTROL (ch))	2829	else if (IS_CONTROL (ch))
2839	process_nonprinting (ch);	2830	process_nonprinting (ch);
2840		2831
		2832	prev_ch = ch;
2841	ch = cmd_getc ();	2833	ch = cmd_getc ();
2842	}	2834	}
2843		2835
2844	if (ch > CSI_7F)	2836	if (ch > CSI_7F)
2845	return;	2837	return;
…		…
2875	break;	2867	break;
2876		2868
2877	case '?':	2869	case '?':
2878	if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')	2870	if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')
2879	process_terminal_mode (ch, priv, nargs, arg);	2871	process_terminal_mode (ch, priv, nargs, arg);
		2872	if (prev_ch == '$' && ch == 'p')
		2873	process_terminal_mode (ch, priv, nargs, arg);
2880	break;	2874	break;
2881		2875
2882	case '!':	2876	case '!':
2883	if (ch == CSI_70)	2877	if (ch == CSI_70)
2884	{	2878	{
2885	/* DECSTR: soft terminal reset, used by our terminfo since 9.06 */	2879	/* DECSTR: soft terminal reset, used by our terminfo since 9.06 */
2886	scr_soft_reset ();	2880	scr_soft_reset ();
2887		2881
2888	static const int pm_h[] = { 7, 25 };	2882	static const int pm_h[] = { 7, 25 };
2889	static const int pm_l[] = { 1, 3, 4, 5, 6, 9, 66, 1000, 1001, 1005, 1015, 1049 };	2883	static const int pm_l[] = { 1, 3, 4, 5, 6, 9, 66, 1000, 1001, 1005, 1006, 1015, 1049 };
2890		2884
2891	process_terminal_mode ('h', 0, ecb_array_length (pm_h), pm_h);	2885	process_terminal_mode ('h', 0, ecb_array_length (pm_h), pm_h);
2892	process_terminal_mode ('l', 0, ecb_array_length (pm_l), pm_l);	2886	process_terminal_mode ('l', 0, ecb_array_length (pm_l), pm_l);
2893	}	2887	}
2894	break;	2888	break;
…		…
2924	case CSI_VPR: /* 8.3.161: (1) LINE POSITION FORWARD */	2918	case CSI_VPR: /* 8.3.161: (1) LINE POSITION FORWARD */
2925	scr_gotorc (arg[0], 0, RELATIVE);	2919	scr_gotorc (arg[0], 0, RELATIVE);
2926	break;	2920	break;
2927		2921
2928	case CSI_CUB: /* 8.3.18: (1) CURSOR LEFT */	2922	case CSI_CUB: /* 8.3.18: (1) CURSOR LEFT */
2929	case CSI_HPB: /* 8.3.59: (1) CHARACTER POSITION BACKWARD */	2923	case CSI_HPB: /* 8.3.59: (1) CHARACTER POSITION BACKWARD */
2930	#ifdef ISO6429	2924	#ifdef ISO6429
2931	arg[0] = -arg[0];	2925	arg[0] = -arg[0];
2932	#else /* emulate common DEC VTs */	2926	#else /* emulate common DEC VTs */
2933	arg[0] = arg[0] ? -arg[0] : -1;	2927	arg[0] = arg[0] ? -arg[0] : -1;
2934	#endif	2928	#endif
…		…
3079	scr_insert_mode (1);	3073	scr_insert_mode (1);
3080	else if (arg[0] == 20)	3074	else if (arg[0] == 20)
3081	priv_modes |= PrivMode_LFNL;	3075	priv_modes |= PrivMode_LFNL;
3082	break;	3076	break;
3083		3077
		3078	case CSI_71: // DECSCUSR: set cursor style
		3079	if (prev_ch == ' ')
		3080	set_cursor_style (arg[0]);
		3081	break;
		3082
3084	/*	3083	/*
3085	* PRIVATE USE beyond this point. All CSI_7? sequences here	3084	* PRIVATE USE beyond this point. All CSI_7? sequences here
3086	*/	3085	*/
3087	case CSI_72: /* DECSTBM: set top and bottom margins */	3086	case CSI_72: /* DECSTBM: set top and bottom margins */
3088	if (nargs == 1)	3087	if (nargs == 1)
…		…
3221	rxvt_term::get_to_st (unicode_t &ends_how)	3220	rxvt_term::get_to_st (unicode_t &ends_how)
3222	{	3221	{
3223	unicode_t ch;	3222	unicode_t ch;
3224	bool seen_esc = false;	3223	bool seen_esc = false;
3225	unsigned int n = 0;	3224	unsigned int n = 0;
3226	wchar_t string[STRING_MAX];	3225	wchar_t string[CBUFSIZ];
3227		3226
3228	while ((ch = cmd_getc ()) != NOCHAR)	3227	while ((ch = cmd_getc ()) != NOCHAR)
3229	{	3228	{
3230	if (seen_esc)	3229	if (seen_esc)
3231	{	3230	{
…		…
3246	else if (ch < 0x20)	3245	else if (ch < 0x20)
3247	return NULL; /* other control character - exit */	3246	return NULL; /* other control character - exit */
3248		3247
3249	seen_esc = false;	3248	seen_esc = false;
3250		3249
3251	if (n >= STRING_MAX - 1)	3250	if (n >= sizeof (string) - 1)
3252	// stop at some sane length	3251	// stop at some sane length
3253	return NULL;	3252	return NULL;
3254		3253
3255	string[n++] = ch;	3254	string[n++] = ch;
3256	}	3255	}
…		…
3305	free (s);	3304	free (s);
3306	}	3305	}
3307	}	3306	}
3308	}	3307	}
3309		3308
		3309	static unsigned int
		3310	colorcube_index (unsigned int idx_r,
		3311	unsigned int idx_g,
		3312	unsigned int idx_b)
		3313	{
		3314	assert (idx_r < Red_levels);
		3315	assert (idx_g < Green_levels);
		3316	assert (idx_b < Blue_levels);
		3317
		3318	return idx_r * Blue_levels * Green_levels +
		3319	idx_g * Blue_levels +
		3320	idx_b;
		3321	}
		3322
		3323	/*
		3324	* Find the nearest color slot in the hidden color cube,
		3325	* adapt its value to the 32bit RGBA color.
		3326	*/
		3327	unsigned int
		3328	rxvt_term::map_rgb24_color (unsigned int r, unsigned int g, unsigned int b, unsigned int a)
		3329	{
		3330	r &= 0xff;
		3331	g &= 0xff;
		3332	b &= 0xff;
		3333	a &= 0xff;
		3334
		3335	uint32_t color = (a << 24) | (r << 16) | (g << 8) | b;
		3336
		3337	/* we allow one of the 6 closest neighbouring colours */
		3338	/* to replace the current color, if they not used recently */
		3339	static const signed char dxyz[][3] = {
		3340	0, 0, 0,
		3341	0, 0, 4,
		3342	0, 4, 0,
		3343	4, 0, 0,
		3344	0, 4, 4,
		3345	4, 4, 0,
		3346	4, 0, 4,
		3347	};
		3348
		3349	static const unsigned char color_level[8][32] = {
		3350	// neighbour index
		3351	{0, 0, 1, 0, 0, 1, 1, 2, 2, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3},
		3352	{0, 1, 0, 1, 1, 2, 1, 1, 2, 2, 3, 3, 2, 2, 2, 3, 3, 3, 4, 4, 4, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4},
		3353	{0, 0, 1, 2, 1, 1, 2, 3, 3, 2, 2, 3, 3, 4, 4, 3, 3, 3, 4, 4, 5, 5, 5, 4, 4, 4, 5, 5, 5, 5, 5, 5},
		3354	{0, 0, 2, 1, 2, 3, 2, 2, 3, 4, 4, 3, 3, 4, 4, 5, 5, 4, 4, 5, 5, 5, 6, 6, 5, 5, 5, 6, 6, 6, 6, 6},
		3355	// Red_levels/Green_levels/Blue_levels index
		3356	{0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3},
		3357	{0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4},
		3358	{0, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5},
		3359	{0, 1, 1, 2, 2, 2, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6},
		3360	};
		3361
		3362	unsigned int idx;
		3363
		3364	for (int n = 0; n < ecb_array_length (dxyz); ++n)
		3365	{
		3366	unsigned int idx_r = color_level[ Red_levels - dxyz[n][0]][r / 8];
		3367	unsigned int idx_g = color_level[Green_levels - dxyz[n][1]][g / 8];
		3368	unsigned int idx_b = color_level[ Blue_levels - dxyz[n][2]][b / 8];
		3369	unsigned int index = colorcube_index (idx_r, idx_g, idx_b);
		3370
		3371	if (n == 0)
		3372	idx = index;
		3373
		3374	if (rgb24_color[index] == color)
		3375	{
		3376	rgb24_seqno[index] = ++rgb24_sequence;
		3377	return index + minTermCOLOR24;
		3378	}
		3379
		3380	// minor issue: could update index 0 few more times
		3381	if ((rgb24_seqno[index] | rgb24_color[index]) == 0)
		3382	{
		3383	idx = index;
		3384	goto update;
		3385	}
		3386
		3387	// like (rgb24_seqno[idx] > rgb24_seqno[index])
		3388	// but also handles wrap around values good enough
		3389	if ((uint16_t)(rgb24_seqno[idx] - rgb24_seqno[index]) < 0x7fff)
		3390	idx = index;
		3391	}
		3392
		3393	update:
		3394	rgb24_color[idx] = color;
		3395	rgb24_seqno[idx] = ++rgb24_sequence;
		3396
		3397	idx += minTermCOLOR24;
		3398	pix_colors_focused [idx].free (this);
		3399	pix_colors_focused [idx].set (this, rgba (r * 0x0101, g * 0x0101, b * 0x0101, a * 0x0101));
		3400	update_fade_color (idx, false);
		3401
		3402	return idx;
		3403	}
		3404
3310	void	3405	void
3311	rxvt_term::process_color_seq (int report, int color, const char *str, char resp)	3406	rxvt_term::process_color_seq (int report, int color, const char *str, char resp)
3312	{	3407	{
3313	if (str[0] == '?' && !str[1])	3408	if (str[0] == '?' && !str[1])
3314	{	3409	{
		3410	if (!IN_RANGE_INC (color, minCOLOR, maxTermCOLOR))
		3411	return;
		3412
3315	rgba c;	3413	rgba c;
3316	pix_colors_focused[color].get (c);	3414	pix_colors_focused[color].get (c);
		3415	color -= minCOLOR;
3317		3416
3318	#if XFT	3417	#if XFT
3319	if (c.a != rgba::MAX_CC)	3418	if (c.a != rgba::MAX_CC)
3320	tt_printf ("\033]%d;rgba:%04x/%04x/%04x/%04x%c", report, c.a, c.r, c.g, c.b, resp);	3419	tt_printf ("\033]%d;%d;rgba:%04x/%04x/%04x/%04x%c", report, color, c.r, c.g, c.b, c.a, resp);
3321	else	3420	else
3322	#endif	3421	#endif
3323	tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, c.r, c.g, c.b, resp);	3422	tt_printf ("\033]%d;%d;rgb:%04x/%04x/%04x%c", report, color, c.r, c.g, c.b, resp);
3324	}	3423	}
3325	else	3424	else
3326	set_window_color (color, str);	3425	set_window_color (color, str);
3327	}	3426	}
3328		3427
…		…
3373	&nitems, &bytes_after, &value) == Success	3472	&nitems, &bytes_after, &value) == Success
3374	&& actual_type != None	3473	&& actual_type != None
3375	&& actual_format == 8)	3474	&& actual_format == 8)
3376	str = (const char *)(value);	3475	str = (const char *)(value);
3377		3476
3378	tt_printf ("\033]%d;%s%c", op, str, resp);	3477	tt_printf ("\033]%d;%s%c", op, option (Opt_insecure) ? str : "", resp);
3379		3478
3380	XFree (value);	3479	XFree (value);
3381	}	3480	}
3382	else	3481	else
3383	{	3482	{
…		…
3451	break;	3550	break;
3452	#endif	3551	#endif
3453	case URxvt_Color_border:	3552	case URxvt_Color_border:
3454	process_color_seq (op, Color_border, str, resp);	3553	process_color_seq (op, Color_border, str, resp);
3455	break;	3554	break;
3456	#if ENABLE_TRANSPARENCY
3457	case URxvt_Color_tint:
3458	process_color_seq (op, Color_tint, str, resp);
3459	{
3460	bool changed = false;
3461
3462	if (ISSET_PIXCOLOR (Color_tint))
3463	changed = root_effects.set_tint (pix_colors_focused [Color_tint]);
3464
3465	if (changed)
3466	update_background ();
3467	}
3468
3469	break;
3470	#endif
3471
3472	#if BG_IMAGE_FROM_FILE
3473	case Rxvt_Pixmap:
3474	if (!strcmp (str, "?"))
3475	{
3476	char str[256];
3477	int h_scale = fimage.h_scale;
3478	int v_scale = fimage.v_scale;
3479	int h_align = fimage.h_align;
3480	int v_align = fimage.v_align;
3481
3482	sprintf (str, "[%dx%d+%d+%d]",
3483	h_scale, v_scale,
3484	h_align, v_align);
3485	process_xterm_seq (XTerm_title, str, CHAR_ST);
3486	}
3487	else
3488	{
3489	bool changed = false;
3490
3491	if (*str != ';')
3492	{
3493	if (fimage.set_file_geometry (str))
3494	changed = true;
3495	}
3496	else
3497	{
3498	str++;
3499	if (fimage.set_geometry (str, true))
3500	changed = true;
3501	}
3502
3503	if (changed)
3504	{
3505	if (bg_window_position_sensitive ())
3506	{
3507	int x, y;
3508	get_window_origin (x, y);
3509	bg_set_position (x, y);
3510	}
3511	update_background ();
3512	}
3513	}
3514	break;
3515	#endif
3516		3555
3517	case XTerm_logfile:	3556	case XTerm_logfile:
3518	// TODO, when secure mode?	3557	// TODO, when secure mode?
3519	break;	3558	break;
3520		3559
…		…
3654	{ 5, PrivMode_rVideo }, // DECSCNM	3693	{ 5, PrivMode_rVideo }, // DECSCNM
3655	{ 6, PrivMode_relOrigin }, // DECOM	3694	{ 6, PrivMode_relOrigin }, // DECOM
3656	{ 7, PrivMode_Autowrap }, // DECAWM	3695	{ 7, PrivMode_Autowrap }, // DECAWM
3657	// 8, auto-repeat keys // DECARM	3696	// 8, auto-repeat keys // DECARM
3658	{ 9, PrivMode_MouseX10 },	3697	{ 9, PrivMode_MouseX10 },
		3698	{ 12, PrivMode_BlinkingCursor },
3659	// 18 end FF to printer after print screen	3699	// 18 end FF to printer after print screen
3660	// 19 Print screen prints full screen/scroll region	3700	// 19 Print screen prints full screen/scroll region
3661	{ 25, PrivMode_VisibleCursor }, // DECTCEM cnorm/cvvis/civis	3701	{ 25, PrivMode_VisibleCursor }, // DECTCEM cnorm/cvvis/civis
3662	#ifdef scrollBar_esc	3702	#ifdef scrollBar_esc
3663	{ scrollBar_esc, PrivMode_scrollBar },	3703	{ scrollBar_esc, PrivMode_scrollBar },
…		…
3675	#endif	3715	#endif
3676	{ 1000, PrivMode_MouseX11 },	3716	{ 1000, PrivMode_MouseX11 },
3677	{ 1002, PrivMode_MouseBtnEvent },	3717	{ 1002, PrivMode_MouseBtnEvent },
3678	{ 1003, PrivMode_MouseAnyEvent },	3718	{ 1003, PrivMode_MouseAnyEvent },
3679	#if ENABLE_FRILLS	3719	#if ENABLE_FRILLS
		3720	{ 1004, PrivMode_FocusEvent },
3680	{ 1005, PrivMode_ExtModeMouse },	3721	{ 1005, PrivMode_ExtMouseUTF8 },
		3722	{ 1006, PrivMode_ExtMouseSGR },
3681	#endif	3723	#endif
3682	{ 1010, PrivMode_TtyOutputInh }, // rxvt extension	3724	{ 1010, PrivMode_TtyOutputInh }, // rxvt extension
3683	{ 1011, PrivMode_Keypress }, // rxvt extension	3725	{ 1011, PrivMode_Keypress }, // rxvt extension
3684	#if ENABLE_FRILLS	3726	#if ENABLE_FRILLS
3685	{ 1015, PrivMode_ExtMouseRight }, // urxvt extension of 1005	3727	{ 1015, PrivMode_ExtMouseUrxvt }, // urxvt extension of 1005
3686	#endif	3728	#endif
3687	// 1035 enable modifiers for alt, numlock NYI	3729	// 1035 enable modifiers for alt, numlock NYI
3688	// 1036 send ESC for meta keys NYI	3730	// 1036 send ESC for meta keys NYI
3689	// 1037 send DEL for keypad delete NYI	3731	// 1037 send DEL for keypad delete NYI
3690	{ 1047, PrivMode_Screen },	3732	{ 1047, PrivMode_Screen },
…		…
3694	{ 2004, PrivMode_BracketPaste },	3736	{ 2004, PrivMode_BracketPaste },
3695	};	3737	};
3696		3738
3697	if (nargs == 0)	3739	if (nargs == 0)
3698	return;	3740	return;
		3741
		3742	// DECRQM
		3743	if (mode == 'p')
		3744	{
		3745	int status = 0;
		3746	if (nargs != 1)
		3747	return;
		3748
		3749	for (j = 0; j < ecb_array_length (argtopriv); j++)
		3750	if (argtopriv[j].argval == arg[0])
		3751	{
		3752	status = (priv_modes & argtopriv[j].bit) ? 1 : 2;
		3753	break;
		3754	}
		3755
		3756	tt_printf ("\33[?%d;%d$y", arg[0], status);
		3757	return;
		3758	}
3699		3759
3700	/* make lo/hi boolean */	3760	/* make lo/hi boolean */
3701	if (mode == 'l')	3761	if (mode == 'l')
3702	mode = 0; /* reset */	3762	mode = 0; /* reset */
3703	else if (mode == 'h')	3763	else if (mode == 'h')
…		…
3772	scrollBar.map (state);	3832	scrollBar.map (state);
3773	resize_all_windows (0, 0, 0);	3833	resize_all_windows (0, 0, 0);
3774	scr_touch (true);	3834	scr_touch (true);
3775	break;	3835	break;
3776	#endif	3836	#endif
		3837	#ifdef CURSOR_BLINK
		3838	case 12:
		3839	cursor_blink_reset ();
		3840	break;
		3841	#endif
3777	case 25: /* visible/invisible cursor */	3842	case 25: /* visible/invisible cursor */
3778	scr_cursor_visible (state);	3843	scr_cursor_visible (state);
3779	break;	3844	break;
3780	/* case 35: - shift keys */	3845	/* case 35: - shift keys */
3781	/* case 40: - 80 <--> 132 mode */	3846	/* case 40: - 80 <--> 132 mode */
…		…
3886	//case 19: // ninth alt font	3951	//case 19: // ninth alt font
3887	//case 20: // gothic	3952	//case 20: // gothic
3888	case 21: // disable bold, faint, sometimes doubly underlined (iso 8613)	3953	case 21: // disable bold, faint, sometimes doubly underlined (iso 8613)
3889	rendset = 0, rendstyle = RS_Bold;	3954	rendset = 0, rendstyle = RS_Bold;
3890	break;	3955	break;
3891	case 22: // normal intensity	3956	case 22: // bold off (vt220)
3892	rendset = 0, rendstyle = RS_Bold;	3957	rendset = 0, rendstyle = RS_Bold;
3893	break;	3958	break;
3894	case 23: // disable italic	3959	case 23: // disable italic
3895	rendset = 0, rendstyle = RS_Italic;	3960	rendset = 0, rendstyle = RS_Italic;
3896	break;	3961	break;
3897	case 24:	3962	case 24: // underline off (vt220)
3898	rendset = 0, rendstyle = RS_Uline;	3963	rendset = 0, rendstyle = RS_Uline;
3899	break;	3964	break;
3900	case 25:	3965	case 25: // blink off (vt220)
3901	rendset = 0, rendstyle = RS_Blink;	3966	rendset = 0, rendstyle = RS_Blink;
3902	break;	3967	break;
3903	case 26: // variable spacing (iso 8613)	3968	case 26: // variable spacing (iso 8613)
3904	rendset = 0, rendstyle = RS_Blink;	3969	rendset = 0, rendstyle = RS_Blink;
3905	break;	3970	break;
3906	case 27:	3971	case 27: // reverse off (vt220)
3907	rendset = 0, rendstyle = RS_RVid;	3972	rendset = 0, rendstyle = RS_RVid;
3908	break;	3973	break;
3909	//case 28: // visible. NYI	3974	//case 28: // visible. NYI
3910	//case 29: // not crossed-out	3975	//case 29: // not crossed-out
3911	}	3976	}
…		…
3926	case 35:	3991	case 35:
3927	case 36:	3992	case 36:
3928	case 37:	3993	case 37:
3929	scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);	3994	scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);
3930	break;	3995	break;
3931	case 38: // set fg color, ISO 8613-6
3932	if (nargs > i + 2 && arg[i + 1] == 5)
3933	{
3934	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg);
3935	i += 2;
3936	}
3937	break;
3938	case 39: /* default fg */	3996	case 39: /* default fg */
3939	scr_color (Color_fg, Color_fg);	3997	scr_color (Color_fg, Color_fg);
3940	break;	3998	break;
3941		3999
3942	case 40:	4000	case 40:
…		…
3947	case 45:	4005	case 45:
3948	case 46:	4006	case 46:
3949	case 47:	4007	case 47:
3950	scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);	4008	scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);
3951	break;	4009	break;
3952	case 48: // set bg color, ISO 8613-6
3953	if (nargs > i + 2 && arg[i + 1] == 5)
3954	{
3955	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg);
3956	i += 2;
3957	}
3958	break;
3959	case 49: /* default bg */	4010	case 49: /* default bg */
3960	scr_color (Color_bg, Color_bg);	4011	scr_color (Color_bg, Color_bg);
		4012	break;
		4013
		4014	case 38: // set fg color, ISO 8613-6
		4015	case 48: // set bg color, ISO 8613-6
		4016	{
		4017	unsigned int fgbg = arg[i] == 38 ? Color_fg : Color_bg;
		4018	unsigned int idx;
		4019
		4020	if (nargs > i + 2 && arg[i + 1] == 5)
		4021	{
		4022	idx = minCOLOR + arg[i + 2];
		4023	i += 2;
		4024
		4025	scr_color (idx, fgbg);
		4026	}
		4027	else if (nargs > i + 4 && arg[i + 1] == 2)
		4028	{
		4029	unsigned int r = arg[i + 2];
		4030	unsigned int g = arg[i + 3];
		4031	unsigned int b = arg[i + 4];
		4032	unsigned int a = 0xff;
		4033
		4034	idx = map_rgb24_color (r, g, b, a);
		4035
		4036	i += 4;
		4037
		4038	scr_color (idx, fgbg);
		4039	}
		4040	}
3961	break;	4041	break;
3962		4042
3963	//case 50: // not variable spacing	4043	//case 50: // not variable spacing
3964		4044
3965	#if !ENABLE_MINIMAL	4045	#if !ENABLE_MINIMAL
…		…
3985	break;	4065	break;
3986	#endif	4066	#endif
3987	}	4067	}
3988	}	4068	}
3989	}	4069	}
		4070
		4071	void
		4072	rxvt_term::set_cursor_style (int style)
		4073	{
		4074	if (!IN_RANGE_INC (style, 0, 6))
		4075	return;
		4076
		4077	if (style == 0)
		4078	style = 1;
		4079
		4080	cursor_type = (style - 1) / 2;
		4081	set_option (Opt_cursorUnderline, cursor_type == 1);
		4082
		4083	#ifdef CURSOR_BLINK
		4084	set_option (Opt_cursorBlink, style & 1);
		4085	cursor_blink_reset ();
		4086	#endif
		4087
		4088	want_refresh = 1;
		4089	}
3990	/*}}} */	4090	/*}}} */
3991		4091
3992	/* ------------------------------------------------------------------------- */	4092	/* ---------------------------------------------------------------------- */
		4093	/* Write data to the pty as typed by the user, pasted with the mouse,
		4094	* or generated by us in response to a query ESC sequence.
		4095	*/
3993		4096
3994	/*	4097	/*
3995	* Send printf () formatted output to the command.	4098	* Send printf () formatted output to the command.
3996	* Only use for small amounts of data.	4099	* Only use for small amounts of data.
3997	*/	4100	*/
…		…
4005	vsnprintf ((char *)buf, 256, fmt, arg_ptr);	4108	vsnprintf ((char *)buf, 256, fmt, arg_ptr);
4006	va_end (arg_ptr);	4109	va_end (arg_ptr);
4007	tt_write (buf, strlen (buf));	4110	tt_write (buf, strlen (buf));
4008	}	4111	}
4009		4112
4010	/* ---------------------------------------------------------------------- */
4011	/* Write data to the pty as typed by the user, pasted with the mouse,	4113	/* Write data to the pty as typed by the user. */
4012	* or generated by us in response to a query ESC sequence.	4114	void
4013	*/	4115	rxvt_term::tt_write_user_input (const char *data, unsigned int len)
4014	static const unsigned int MAX_PTY_WRITE = 255; // minimum MAX_INPUT	4116	{
		4117	if (HOOK_INVOKE ((this, HOOK_TT_WRITE, DT_STR_LEN, data, len, DT_END)))
		4118	return;
		4119
		4120	if (option (Opt_scrollTtyKeypress))
		4121	if (view_start)
		4122	{
		4123	view_start = 0;
		4124	want_refresh = 1;
		4125	}
		4126
		4127	tt_write_ (data, len);
		4128	}
4015		4129
4016	void	4130	void
4017	rxvt_term::tt_write (const char *data, unsigned int len)	4131	rxvt_term::tt_write (const char *data, unsigned int len)
4018	{	4132	{
4019	if (HOOK_INVOKE ((this, HOOK_TT_WRITE, DT_STR_LEN, data, len, DT_END)))	4133	if (HOOK_INVOKE ((this, HOOK_TT_WRITE, DT_STR_LEN, data, len, DT_END)))
4020	return;	4134	return;
4021		4135
		4136	tt_write_ (data, len);
		4137	}
		4138
		4139	static const unsigned int MAX_PTY_WRITE = 255; // minimum MAX_INPUT
		4140
		4141	void
		4142	rxvt_term::tt_write_ (const char *data, unsigned int len)
		4143	{
4022	if (pty->pty < 0)	4144	if (pty->pty < 0)
4023	return;	4145	return;
4024		4146
4025	if (v_buflen == 0)	4147	if (v_buflen == 0)
4026	{	4148	{

Diff Legend

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