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.544 by sf-exg, Sat Apr 26 14:55:58 2014 UTC vs.
Revision 1.594 by root, Sat Jul 3 04:04:12 2021 UTC

…		…
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-2014 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
…		…
168	int len;	168	int len;
169		169
170	# if ENABLE_COMBINING	170	# if ENABLE_COMBINING
171	if (IS_COMPOSE (ch))	171	if (IS_COMPOSE (ch))
172	{	172	{
173	len = rxvt_composite.expand (ch, 0);	173	len = rxvt_composite.expand (ch);
174	alloc = chr = new wchar_t[len];	174	alloc = chr = new wchar_t[len];
175	rxvt_composite.expand (ch, chr);	175	rxvt_composite.expand (ch, chr);
176	}	176	}
177	else	177	else
178	# endif	178	# endif
…		…
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;
…		…
413		406
414	void ecb_cold	407	void ecb_cold
415	rxvt_term::key_press (XKeyEvent &ev)	408	rxvt_term::key_press (XKeyEvent &ev)
416	{	409	{
417	int ctrl, meta, shft, len;	410	int ctrl, meta, shft, len;
418	KeySym keysym;	411	KeySym keysym = NoSymbol;
419	int valid_keysym;
420	char rkbuf[KBUFSZ];	412	char rkbuf[KBUFSZ + 1];
421	char *kbuf = rkbuf + 1;	413	char *kbuf = rkbuf + 1;
422		414
423	#if ISO_14755	415	#if ISO_14755
424	if (iso14755buf & ISO_14755_52)	416	if (iso14755buf & ISO_14755_52)
425	return;	417	return;
…		…
483	}	475	}
484	}	476	}
485	else	477	else
486	len = 0;	478	len = 0;
487	}	479	}
488
489	valid_keysym = status_return == XLookupKeySym
490	|| status_return == XLookupBoth;
491	}	480	}
492	else	481	else
493	#endif	482	#endif
494	{	483	{
495	len = XLookupString (&ev, kbuf, KBUFSZ, &keysym, &compose);	484	len = XLookupString (&ev, kbuf, KBUFSZ, &keysym, &compose);
496	valid_keysym = keysym != NoSymbol;	485	}
		486
		487	if (keysym != NoSymbol)
497	}	488	{
		489	KeySym orig_keysym = keysym;
498		490
499	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)
500	{	704	{
501	#ifdef KEYSYM_RESOURCE	705	#ifdef KEYSYM_RESOURCE
502	if (keyboard->dispatch (this, keysym, ev.state))	706	if (keyboard->dispatch (this, keysym, ev.state, kbuf, len))
503	return;	707	return;
504	#endif	708	#endif
505		709
506	if (saveLines)	710	if (saveLines)
507	{	711	{
…		…
563	#endif	767	#endif
564	}	768	}
565		769
566	if (shft)	770	if (shft)
567	{	771	{
568	/* Shift + F1 - F10 generates F11 - F20 */
569	if (keysym >= XK_F1 && keysym <= XK_F10)
570	{
571	keysym += (XK_F11 - XK_F1);
572	shft = 0; /* turn off Shift */
573	}
574	else if (!ctrl && !meta && (priv_modes & PrivMode_ShiftKeys))	772	if (!ctrl && !meta && (priv_modes & PrivMode_ShiftKeys))
575	{	773	{
576	switch (keysym)	774	switch (keysym)
577	{	775	{
578	/* normal XTerm key bindings */	776	/* normal XTerm key bindings */
579	case XK_Insert: /* Shift+Insert = paste mouse selection */	777	case XK_Insert: /* Shift+Insert = paste mouse selection */
…		…
665	{	863	{
666	scr_printscreen (ctrl | shft);	864	scr_printscreen (ctrl | shft);
667	return;	865	return;
668	}	866	}
669	#endif	867	#endif
670
671	if (keysym >= 0xFF00 && keysym <= 0xFFFF)
672	{
673	bool kp = priv_modes & PrivMode_aplKP ? !shft : shft;
674	unsigned int newlen = 1;
675
676	if (ev.state & ModNumLockMask)
677	kp = false;
678
679	keysym = translate_keypad (keysym, kp);
680
681	switch (keysym)
682	{
683	#ifndef NO_BACKSPACE_KEY
684	case XK_BackSpace:
685	if (priv_modes & PrivMode_HaveBackSpace)
686	{
687	kbuf[0] = (!! (priv_modes & PrivMode_BackSpace)
688	^ !!ctrl) ? '\b' : '\177';
689	kbuf[1] = '\0';
690	}
691	else
692	strcpy (kbuf, rs[Rs_backspace_key]);
693	break;
694	#endif
695	#ifndef NO_DELETE_KEY
696	case XK_Delete:
697	strcpy (kbuf, rs[Rs_delete_key]);
698	break;
699	#endif
700	case XK_Tab:
701	if (shft)
702	strcpy (kbuf, "\033[Z");
703	else
704	{
705	#ifdef CTRL_TAB_MAKES_META
706	if (ctrl)
707	meta = 1;
708	#endif
709	#ifdef MOD4_TAB_MAKES_META
710	if (ev.state & Mod4Mask)
711	meta = 1;
712	#endif
713	newlen = 0;
714	}
715	break;
716
717	case XK_Up: /* "\033[A" */
718	case XK_Down: /* "\033[B" */
719	case XK_Right: /* "\033[C" */
720	case XK_Left: /* "\033[D" */
721	strcpy (kbuf, "\033[Z");
722	kbuf[2] = "DACB"[keysym - XK_Left];
723	/* do Shift first */
724	if (shft)
725	kbuf[2] = "dacb"[keysym - XK_Left];
726	else if (ctrl)
727	{
728	kbuf[1] = 'O';
729	kbuf[2] = "dacb"[keysym - XK_Left];
730	}
731	else if (priv_modes & PrivMode_aplCUR)
732	kbuf[1] = 'O';
733	break;
734
735	case XK_KP_Enter:
736	/* allow shift to override */
737	if (kp)
738	{
739	strcpy (kbuf, "\033OM");
740	break;
741	}
742
743	/* FALLTHROUGH */
744
745	case XK_Return:
746	if (priv_modes & PrivMode_LFNL)
747	{
748	kbuf[0] = '\015';
749	kbuf[1] = '\012';
750	kbuf[2] = '\0';
751	}
752	else
753	{
754	kbuf[0] = '\015';
755	kbuf[1] = '\0';
756	}
757	break;
758
759	case XK_KP_F1: /* "\033OP" */
760	case XK_KP_F2: /* "\033OQ" */
761	case XK_KP_F3: /* "\033OR" */
762	case XK_KP_F4: /* "\033OS" */
763	strcpy (kbuf, "\033OP");
764	kbuf[2] += (keysym - XK_KP_F1);
765	break;
766
767	case XK_KP_Multiply: /* "\033Oj" : "*" */
768	case XK_KP_Add: /* "\033Ok" : "+" */
769	case XK_KP_Separator: /* "\033Ol" : "," */
770	case XK_KP_Subtract: /* "\033Om" : "-" */
771	case XK_KP_Decimal: /* "\033On" : "." */
772	case XK_KP_Divide: /* "\033Oo" : "/" */
773	case XK_KP_0: /* "\033Op" : "0" */
774	case XK_KP_1: /* "\033Oq" : "1" */
775	case XK_KP_2: /* "\033Or" : "2" */
776	case XK_KP_3: /* "\033Os" : "3" */
777	case XK_KP_4: /* "\033Ot" : "4" */
778	case XK_KP_5: /* "\033Ou" : "5" */
779	case XK_KP_6: /* "\033Ov" : "6" */
780	case XK_KP_7: /* "\033Ow" : "7" */
781	case XK_KP_8: /* "\033Ox" : "8" */
782	case XK_KP_9: /* "\033Oy" : "9" */
783	/* allow shift to override */
784	if (kp)
785	{
786	strcpy (kbuf, "\033Oj");
787	kbuf[2] += (keysym - XK_KP_Multiply);
788	}
789	else
790	{
791	kbuf[0] = ('*' + (keysym - XK_KP_Multiply));
792	kbuf[1] = '\0';
793	}
794	break;
795
796	default:
797	{
798	int param = map_function_key (keysym);
799	if (param > 0)
800	sprintf (kbuf,"\033[%d~", param);
801	else
802	newlen = 0;
803	}
804	break;
805	}
806
807	if (newlen)
808	len = strlen (kbuf);
809
810	if (len > 0)
811	{
812	/*
813	* pass Shift/Control indicators for function keys ending with `~'
814	*
815	* eg,
816	* Prior = "ESC[5~"
817	* Shift+Prior = "ESC[5$"
818	* Ctrl+Prior = "ESC[5^"
819	* Ctrl+Shift+Prior = "ESC[5@"
820	*/
821	if (kbuf[0] == C0_ESC && kbuf[1] == '[' && kbuf[len - 1] == '~')
822	kbuf[len - 1] = (shft ? (ctrl ? '@' : '$') : (ctrl ? '^' : '~'));
823
824	/*
825	* Pass meta for all function keys, if 'meta' option set
826	*/
827	#ifdef META8_OPTION
828	if (meta && (meta_char == 0x80))
829	kbuf[len - 1] |= 0x80;
830	#endif
831	}
832
833	}
834	else if (ctrl && keysym == XK_minus)
835	{
836	len = 1;
837	kbuf[0] = '\037'; /* Ctrl-Minus generates ^_ (31) */
838	}
839	else if (keysym == XK_ISO_Left_Tab)
840	{
841	strcpy (kbuf, "\033[Z");
842	len = 3;
843	}
844	else
845	{
846	#ifdef META8_OPTION
847	/* set 8-bit on */
848	if (meta && (meta_char == 0x80))
849	{
850	char *ch;
851
852	for (ch = kbuf; ch < kbuf + len; ch++)
853	*ch |= 0x80;
854
855	meta = 0;
856	}
857	#endif
858	/* nil */ ;
859	}
860	}
861
862	/* escape prefix */
863	if (len && meta
864	#ifdef META8_OPTION
865	&& meta_char == C0_ESC
866	#endif
867	)
868	{	868	}
869	*--kbuf = C0_ESC;
870	len++;
871	}
872
873	if (HOOK_INVOKE ((this, HOOK_KEY_PRESS, DT_XEVENT, &ev, DT_INT, keysym, DT_STR_LEN, kbuf, len, DT_END)))
874	return;
875		869
876	if (len <= 0)	870	if (len <= 0)
877	return; /* not mapped */	871	return; /* not mapped */
878		872
879	if (option (Opt_scrollTtyKeypress))
880	if (view_start)
881	{
882	view_start = 0;
883	want_refresh = 1;
884	}
885
886	tt_write (kbuf, (unsigned int)len);	873	tt_write_user_input (kbuf, (unsigned int)len);
887	}	874	}
888		875
889	void ecb_cold	876	void ecb_cold
890	rxvt_term::key_release (XKeyEvent &ev)	877	rxvt_term::key_release (XKeyEvent &ev)
891	{	878	{
…		…
1047		1034
1048	#ifdef CURSOR_BLINK	1035	#ifdef CURSOR_BLINK
1049	void	1036	void
1050	rxvt_term::cursor_blink_reset ()	1037	rxvt_term::cursor_blink_reset ()
1051	{	1038	{
		1039	if (!focus)
		1040	return;
		1041
1052	if (hidden_cursor)	1042	if (hidden_cursor)
1053	{	1043	{
1054	hidden_cursor = 0;	1044	hidden_cursor = 0;
1055	want_refresh = 1;	1045	want_refresh = 1;
1056	}	1046	}
1057		1047
1058	if (option (Opt_cursorBlink))	1048	if (option (Opt_cursorBlink) || (priv_modes & PrivMode_BlinkingCursor))
1059	cursor_blink_ev.again ();	1049	cursor_blink_ev.again ();
1060	else	1050	else
1061	cursor_blink_ev.stop ();	1051	cursor_blink_ev.stop ();
1062	}	1052	}
1063		1053
…		…
1252		1242
1253	void ecb_cold	1243	void ecb_cold
1254	rxvt_term::pointer_unblank ()	1244	rxvt_term::pointer_unblank ()
1255	{	1245	{
1256	XDefineCursor (dpy, vt, TermWin_cursor);	1246	XDefineCursor (dpy, vt, TermWin_cursor);
1257	recolour_cursor ();	1247	recolor_cursor ();
1258		1248
1259	#ifdef POINTER_BLANK	1249	#ifdef POINTER_BLANK
1260	hidden_pointer = 0;	1250	hidden_pointer = 0;
1261		1251
1262	if (option (Opt_pointerBlank))	1252	if (option (Opt_pointerBlank))
…		…
1287	#endif	1277	#endif
1288		1278
1289	void	1279	void
1290	rxvt_term::mouse_report (XButtonEvent &ev)	1280	rxvt_term::mouse_report (XButtonEvent &ev)
1291	{	1281	{
1292	int button_number, key_state = 0;	1282	int button_number, state = 0;
1293	int x, y;	1283	int x, y;
1294	int code = 32;	1284	bool release = ev.type == ButtonRelease;
1295		1285
1296	x = Pixel2Col (ev.x) + 1;	1286	x = Pixel2Col (ev.x) + 1;
1297	y = Pixel2Row (ev.y) + 1;	1287	y = Pixel2Row (ev.y) + 1;
1298		1288
1299	if (ev.type == MotionNotify)	1289	if (ev.type == MotionNotify)
…		…
1301	if (x == mouse_row && y == mouse_col)	1291	if (x == mouse_row && y == mouse_col)
1302	return;	1292	return;
1303		1293
1304	mouse_row = x;	1294	mouse_row = x;
1305	mouse_col = y;	1295	mouse_col = y;
1306	code += 32;	1296	state += 32;
1307	}
1308
1309	if (MEvent.button == AnyButton)
1310	button_number = 3;
1311	else
1312	{	1297	}
		1298
1313	button_number = MEvent.button - Button1;	1299	button_number = MEvent.button - Button1;
1314	/* add 0x3D for wheel events, like xterm does */	1300	/* add 0x3D for wheel events, like xterm does */
1315	if (button_number >= 3)	1301	if (button_number >= 3)
1316	button_number += 64 - 3;	1302	button_number += 64 - 3;
1317	}
1318		1303
1319	if (priv_modes & PrivMode_MouseX10)	1304	if (priv_modes & PrivMode_MouseX10)
1320	{	1305	{
1321	/*	1306	/*
1322	* do not report ButtonRelease	1307	* do not report ButtonRelease
1323	* no state info allowed	1308	* no state info allowed
1324	*/	1309	*/
1325	key_state = 0;	1310	if (release)
1326	if (button_number == 3)
1327	return;	1311	return;
1328	}	1312	}
1329	else	1313	else
1330	{	1314	{
1331	/* XTerm mouse reporting needs these values:	1315	/* XTerm mouse reporting needs these values:
…		…
1333	* 8 = Meta	1317	* 8 = Meta
1334	* 16 = Control	1318	* 16 = Control
1335	* plus will add in our own Double-Click reporting	1319	* plus will add in our own Double-Click reporting
1336	* 32 = Double Click	1320	* 32 = Double Click
1337	*/	1321	*/
1338	key_state = ((MEvent.state & ShiftMask) ? 4 : 0)	1322	state += ((MEvent.state & ShiftMask) ? 4 : 0)
1339	+ ((MEvent.state & ModMetaMask) ? 8 : 0)	1323	+ ((MEvent.state & ModMetaMask) ? 8 : 0)
1340	+ ((MEvent.state & ControlMask) ? 16 : 0);	1324	+ ((MEvent.state & ControlMask) ? 16 : 0);
1341	#ifdef MOUSE_REPORT_DOUBLECLICK	1325	#ifdef MOUSE_REPORT_DOUBLECLICK
1342	key_state += ((MEvent.clicks > 1) ? 32 : 0);	1326	state += ((MEvent.clicks > 1) ? 32 : 0);
1343	#endif	1327	#endif
1344	}	1328	}
		1329
		1330	int code = 32 + (release ? 3 : button_number) + state;
1345		1331
1346	#if DEBUG_MOUSEREPORT	1332	#if DEBUG_MOUSEREPORT
1347	fprintf (stderr, "Mouse [");	1333	fprintf (stderr, "Mouse [");
1348	if (key_state & 16)	1334	if (state & 16)
1349	fputc ('C', stderr);	1335	fputc ('C', stderr);
1350	if (key_state & 4)	1336	if (state & 4)
1351	fputc ('S', stderr);	1337	fputc ('S', stderr);
1352	if (key_state & 8)	1338	if (state & 8)
1353	fputc ('A', stderr);	1339	fputc ('A', stderr);
1354	if (key_state & 32)	1340	if (state & 32)
1355	fputc ('2', stderr);	1341	fputc ('2', stderr);
1356	fprintf (stderr, "]: <%d>, %d/%d\n",	1342	fprintf (stderr, "]: <%d>, %d/%d\n",
1357	button_number,	1343	button_number,
1358	x,	1344	x,
1359	y);	1345	y);
1360	#endif	1346	#endif
1361		1347
1362	#if ENABLE_FRILLS	1348	#if ENABLE_FRILLS
1363	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)
1364	tt_printf ("\033[%d;%d;%dM",	1356	tt_printf ("\033[%d;%d;%dM",
1365	code + button_number + key_state,	1357	code,
1366	x,	1358	x,
1367	y);	1359	y);
1368	else if (priv_modes & PrivMode_ExtModeMouse)	1360	else if (priv_modes & PrivMode_ExtMouseUTF8)
1369	tt_printf ("\033[M%c%lc%lc",	1361	tt_printf ("\033[M%c%lc%lc",
1370	code + button_number + key_state,	1362	code,
1371	wint_t (32 + x),	1363	wint_t (32 + x),
1372	wint_t (32 + y));	1364	wint_t (32 + y));
1373	else	1365	else
1374	#endif	1366	#endif
1375	tt_printf ("\033[M%c%c%c",	1367	tt_printf ("\033[M%c%c%c",
1376	code + button_number + key_state,	1368	code,
1377	32 + x,	1369	32 + x,
1378	32 + y);	1370	32 + y);
1379	}	1371	}
1380		1372
1381	/*{{{ process an X event */	1373	/*{{{ process an X event */
…		…
1492	while (XCheckTypedWindowEvent (dpy, ev.xconfigure.window, ConfigureNotify, &ev))	1484	while (XCheckTypedWindowEvent (dpy, ev.xconfigure.window, ConfigureNotify, &ev))
1493	;	1485	;
1494		1486
1495	bool want_position_change = SHOULD_INVOKE (HOOK_POSITION_CHANGE);	1487	bool want_position_change = SHOULD_INVOKE (HOOK_POSITION_CHANGE);
1496		1488
1497	bool moved = false;
1498	#ifdef HAVE_BG_PIXMAP
1499	if (bg_window_position_sensitive ())
1500	{
1501	want_position_change = true;
1502	if (bg_img == 0)
1503	moved = true;
1504	}
1505	#endif
1506
1507	if (want_position_change)	1489	if (want_position_change)
1508	{	1490	{
1509	int x, y;	1491	int x, y;
1510		1492
1511	if (ev.xconfigure.send_event)	1493	if (ev.xconfigure.send_event)
…		…
1519	if (x != parent_x || y != parent_y)	1501	if (x != parent_x || y != parent_y)
1520	{	1502	{
1521	parent_x = x;	1503	parent_x = x;
1522	parent_y = y;	1504	parent_y = y;
1523	HOOK_INVOKE ((this, HOOK_POSITION_CHANGE, DT_INT, x, DT_INT, y, DT_END));	1505	HOOK_INVOKE ((this, HOOK_POSITION_CHANGE, DT_INT, x, DT_INT, y, DT_END));
1524	moved = true;
1525	}	1506	}
1526	}	1507	}
1527		1508
1528	if (szHint.width != ev.xconfigure.width || szHint.height != ev.xconfigure.height)	1509	if (szHint.width != ev.xconfigure.width || szHint.height != ev.xconfigure.height)
1529	{	1510	{
1530	seen_resize = 1;	1511	seen_resize = 1;
1531	resize_all_windows (ev.xconfigure.width, ev.xconfigure.height, 1);	1512	resize_all_windows (ev.xconfigure.width, ev.xconfigure.height, 1);
1532	}	1513	}
1533	else
1534	{
1535	#ifdef HAVE_BG_PIXMAP
1536	if (moved)
1537	update_background ();
1538	#endif
1539	}
1540		1514
1541	HOOK_INVOKE ((this, HOOK_CONFIGURE_NOTIFY, DT_XEVENT, &ev, DT_END));	1515	HOOK_INVOKE ((this, HOOK_CONFIGURE_NOTIFY, DT_XEVENT, &ev, DT_END));
1542	}	1516	}
1543	break;	1517	break;
1544		1518
…		…
1553	case SelectionRequest:	1527	case SelectionRequest:
1554	selection_send (ev.xselectionrequest);	1528	selection_send (ev.xselectionrequest);
1555	break;	1529	break;
1556		1530
1557	case MapNotify:	1531	case MapNotify:
1558	#ifdef HAVE_BG_PIXMAP
1559	// This is needed at startup for the case of no window manager
1560	// or a non-reparenting window manager and also because we
1561	// defer bg image updates if the window is not mapped. The
1562	// short delay is to optimize for multiple ConfigureNotify
1563	// events at startup when the window manager reparents the
1564	// window, so as to perform the computation after we have
1565	// received all of them.
1566	if (bg_img == 0)
1567	update_background_ev.start (0.025);
1568	#endif
1569	mapped = 1;	1532	mapped = 1;
1570	#ifdef TEXT_BLINK	1533	#ifdef TEXT_BLINK
1571	text_blink_ev.start ();	1534	text_blink_ev.start ();
1572	#endif	1535	#endif
1573	HOOK_INVOKE ((this, HOOK_MAP_NOTIFY, DT_XEVENT, &ev, DT_END));	1536	HOOK_INVOKE ((this, HOOK_MAP_NOTIFY, DT_XEVENT, &ev, DT_END));
…		…
1622	case MotionNotify:	1585	case MotionNotify:
1623	#ifdef POINTER_BLANK	1586	#ifdef POINTER_BLANK
1624	if (hidden_pointer)	1587	if (hidden_pointer)
1625	pointer_unblank ();	1588	pointer_unblank ();
1626	#endif	1589	#endif
		1590	if (!bypass_keystate
1627	if ((priv_modes & PrivMode_MouseBtnEvent && ev.xbutton.state & (Button1Mask|Button2Mask|Button3Mask))	1591	&& ((priv_modes & PrivMode_MouseBtnEvent && ev.xbutton.state & (Button1Mask|Button2Mask|Button3Mask))
1628	|| priv_modes & PrivMode_MouseAnyEvent)	1592	|| priv_modes & PrivMode_MouseAnyEvent))
1629	mouse_report (ev.xbutton);	1593	mouse_report (ev.xbutton);
1630	if ((priv_modes & PrivMode_mouse_report) && !bypass_keystate)	1594	if ((priv_modes & PrivMode_mouse_report) && !bypass_keystate)
1631	break;	1595	break;
1632		1596
1633	if (ev.xany.window == vt)	1597	if (ev.xany.window == vt)
…		…
1645	&unused_root_x, &unused_root_y,	1609	&unused_root_x, &unused_root_y,
1646	&ev.xbutton.x, &ev.xbutton.y,	1610	&ev.xbutton.x, &ev.xbutton.y,
1647	&ev.xbutton.state);	1611	&ev.xbutton.state);
1648	#ifdef MOUSE_THRESHOLD	1612	#ifdef MOUSE_THRESHOLD
1649	/* deal with a `jumpy' mouse */	1613	/* deal with a `jumpy' mouse */
1650	if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)	1614	if (ev.xmotion.time - MEvent.time > MOUSE_THRESHOLD)
		1615	#endif
1651	{	1616	{
1652	#endif
1653	#if ISO_14755	1617	#if ISO_14755
1654	// 5.4	1618	// 5.4
1655	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))	1619	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
1656	{	1620	{
1657	iso14755_54 (ev.xbutton.x, ev.xbutton.y);	1621	iso14755_54 (ev.xbutton.x, ev.xbutton.y);
…		…
1706	* shouldn't be scrolling	1670	* shouldn't be scrolling
1707	*/	1671	*/
1708	sel_scroll_ev.stop();	1672	sel_scroll_ev.stop();
1709	}	1673	}
1710	#endif	1674	#endif
1711	#ifdef MOUSE_THRESHOLD
1712	}	1675	}
1713	#endif
1714	}	1676	}
1715	}	1677	}
1716	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)
1717	{	1679	{
1718	while (XCheckTypedWindowEvent (dpy, scrollBar.win,	1680	while (XCheckTypedWindowEvent (dpy, scrollBar.win,
…		…
1792	#endif	1754	#endif
1793	#if OFF_FOCUS_FADING	1755	#if OFF_FOCUS_FADING
1794	if (rs[Rs_fade])	1756	if (rs[Rs_fade])
1795	{	1757	{
1796	pix_colors = pix_colors_focused;	1758	pix_colors = pix_colors_focused;
1797	scr_recolour ();	1759	scr_recolor ();
1798	}	1760	}
1799	#endif	1761	#endif
1800	#if ENABLE_FRILLS	1762	#if ENABLE_FRILLS
1801	if (option (Opt_urgentOnBell))	1763	if (option (Opt_urgentOnBell))
1802	set_urgency (0);	1764	set_urgency (0);
		1765
		1766	if (priv_modes & PrivMode_FocusEvent)
		1767	tt_printf ("\x1b[I");
1803	#endif	1768	#endif
1804		1769
1805	HOOK_INVOKE ((this, HOOK_FOCUS_IN, DT_END));	1770	HOOK_INVOKE ((this, HOOK_FOCUS_IN, DT_END));
1806	}	1771	}
1807	}	1772	}
…		…
1815	want_refresh = 1;	1780	want_refresh = 1;
1816		1781
1817	#if ENABLE_FRILLS	1782	#if ENABLE_FRILLS
1818	if (option (Opt_urgentOnBell))	1783	if (option (Opt_urgentOnBell))
1819	set_urgency (0);	1784	set_urgency (0);
		1785
		1786	if (priv_modes & PrivMode_FocusEvent)
		1787	tt_printf ("\x1b[O");
1820	#endif	1788	#endif
1821	#if ENABLE_FRILLS || ISO_14755	1789	#if ENABLE_FRILLS || ISO_14755
1822	if (iso14755buf)	1790	if (iso14755buf)
1823	{	1791	{
1824	iso14755buf = 0;	1792	iso14755buf = 0;
…		…
1839	#endif	1807	#endif
1840	#if OFF_FOCUS_FADING	1808	#if OFF_FOCUS_FADING
1841	if (rs[Rs_fade])	1809	if (rs[Rs_fade])
1842	{	1810	{
1843	pix_colors = pix_colors_unfocused;	1811	pix_colors = pix_colors_unfocused;
1844	scr_recolour ();	1812	scr_recolor ();
1845	}	1813	}
1846	#endif	1814	#endif
1847		1815
1848	HOOK_INVOKE ((this, HOOK_FOCUS_OUT, DT_END));	1816	HOOK_INVOKE ((this, HOOK_FOCUS_OUT, DT_END));
1849	}	1817	}
1850	}	1818	}
1851		1819
1852	void ecb_cold	1820	void ecb_cold
1853	rxvt_term::update_fade_color (unsigned int idx)	1821	rxvt_term::update_fade_color (unsigned int idx, bool first_time)
1854	{	1822	{
1855	#if OFF_FOCUS_FADING	1823	#if OFF_FOCUS_FADING
1856	if (rs[Rs_fade])	1824	if (rs[Rs_fade])
1857	{	1825	{
		1826	if (!first_time)
		1827	pix_colors_focused [idx].free (this);
		1828
1858	rgba c;	1829	rgba c;
1859	pix_colors [Color_fade].get (c);	1830	pix_colors [Color_fade].get (c);
1860	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);
1861	}	1832	}
1862	#endif	1833	#endif
1863	}	1834	}
1864		1835
1865	#if BG_IMAGE_FROM_ROOT || ENABLE_PERL	1836	#if ENABLE_PERL
1866	void ecb_hot	1837	void ecb_hot
1867	rxvt_term::rootwin_cb (XEvent &ev)	1838	rxvt_term::rootwin_cb (XEvent &ev)
1868	{	1839	{
1869	make_current ();	1840	make_current ();
1870		1841
…		…
1880	* 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.
1881	*/	1852	*/
1882	if (ev.xproperty.atom == xa[XA_XROOTPMAP_ID]	1853	if (ev.xproperty.atom == xa[XA_XROOTPMAP_ID]
1883	|| ev.xproperty.atom == xa[XA_ESETROOT_PMAP_ID])	1854	|| ev.xproperty.atom == xa[XA_ESETROOT_PMAP_ID])
1884	{	1855	{
1885	#if BG_IMAGE_FROM_ROOT
1886	if (option (Opt_transparent))
1887	{
1888	rxvt_img::new_from_root (this)->replace (root_img);
1889	update_background ();
1890	}
1891	#endif
1892	HOOK_INVOKE ((this, HOOK_ROOTPMAP_CHANGE, DT_END));	1856	HOOK_INVOKE ((this, HOOK_ROOTPMAP_CHANGE, DT_END));
1893	}	1857	}
1894		1858
1895	break;	1859	break;
1896	}	1860	}
…		…
1924	iso14755_54 (ev.x, ev.y);	1888	iso14755_54 (ev.x, ev.y);
1925	return;	1889	return;
1926	}	1890	}
1927	#endif	1891	#endif
1928		1892
1929	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;	1893	clickintime = ev.time - MEvent.time < multiClickTime;
1930		1894
1931	if (reportmode)	1895	if (reportmode)
1932	{	1896	{
1933	/* mouse report from vt window */	1897	/* mouse report from vt window */
1934	/* save the xbutton state (for ButtonRelease) */	1898	/* save the xbutton state (for ButtonRelease) */
…		…
2184	#ifdef MOUSE_REPORT_DOUBLECLICK	2148	#ifdef MOUSE_REPORT_DOUBLECLICK
2185	/* only report the release of 'slow' single clicks */	2149	/* only report the release of 'slow' single clicks */
2186	if (MEvent.button != AnyButton	2150	if (MEvent.button != AnyButton
2187	&& (ev.button != MEvent.button	2151	&& (ev.button != MEvent.button
2188	|| (ev.time - MEvent.time	2152	|| (ev.time - MEvent.time
2189	> MULTICLICK_TIME / 2)))	2153	> multiClickTime / 2)))
2190	{	2154	{
2191	MEvent.clicks = 0;	2155	MEvent.clicks = 0;
2192	MEvent.button = AnyButton;	2156	MEvent.button = ev.button;
2193	mouse_report (ev);	2157	mouse_report (ev);
2194	}	2158	}
2195	#else /* MOUSE_REPORT_DOUBLECLICK */	2159	#else /* MOUSE_REPORT_DOUBLECLICK */
2196	MEvent.button = AnyButton;	2160	MEvent.button = ev.button;
2197	mouse_report (ev);	2161	mouse_report (ev);
2198	#endif /* MOUSE_REPORT_DOUBLECLICK */	2162	#endif /* MOUSE_REPORT_DOUBLECLICK */
2199	return;	2163	return;
2200	}	2164	}
2201		2165
…		…
2388	}	2352	}
2389	}	2353	}
2390		2354
2391	// read the next character	2355	// read the next character
2392	wchar_t ecb_hot	2356	wchar_t ecb_hot
2393	rxvt_term::next_char () NOTHROW	2357	rxvt_term::next_char () noexcept
2394	{	2358	{
2395	while (cmdbuf_ptr < cmdbuf_endp)	2359	while (cmdbuf_ptr < cmdbuf_endp)
2396	{	2360	{
2397	// assume 7-bit to be ascii ALWAYS	2361	// assume 7-bit to be ascii ALWAYS (always true in POSIX)
2398	if (ecb_likely ((unsigned char)*cmdbuf_ptr <= 0x7f && *cmdbuf_ptr != 0x1b))	2362	if (ecb_likely ((unsigned char)*cmdbuf_ptr <= 0x7f))
2399	return *cmdbuf_ptr++;	2363	return *cmdbuf_ptr++;
2400		2364
2401	wchar_t wc;	2365	wchar_t wc;
2402	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);
2403		2367
…		…
2424	return NOCHAR;	2388	return NOCHAR;
2425	}	2389	}
2426		2390
2427	// read the next octet	2391	// read the next octet
2428	uint32_t ecb_hot	2392	uint32_t ecb_hot
2429	rxvt_term::next_octet () NOTHROW	2393	rxvt_term::next_octet () noexcept
2430	{	2394	{
2431	return cmdbuf_ptr < cmdbuf_endp	2395	return cmdbuf_ptr < cmdbuf_endp
2432	? (unsigned char)*cmdbuf_ptr++	2396	? (unsigned char)*cmdbuf_ptr++
2433	: NOCHAR;	2397	: NOCHAR;
2434	}	2398	}
2435		2399
2436	static class out_of_input out_of_input;	2400	static class out_of_input out_of_input;
2437		2401
2438	wchar_t ecb_hot	2402	wchar_t ecb_hot
2439	rxvt_term::cmd_getc () THROW ((class out_of_input))	2403	rxvt_term::cmd_getc ()
2440	{	2404	{
2441	wchar_t c = next_char ();	2405	wchar_t c = next_char ();
2442		2406
2443	if (c == NOCHAR)	2407	if (c == NOCHAR)
2444	throw out_of_input;	2408	throw out_of_input;
2445		2409
2446	return c;	2410	return c;
2447	}	2411	}
2448		2412
2449	uint32_t ecb_hot	2413	uint32_t ecb_hot
2450	rxvt_term::cmd_get8 () THROW ((class out_of_input))	2414	rxvt_term::cmd_get8 ()
2451	{	2415	{
2452	uint32_t c = next_octet ();	2416	uint32_t c = next_octet ();
2453		2417
2454	if (c == NOCHAR)	2418	if (c == NOCHAR)
2455	throw out_of_input;	2419	throw out_of_input;
…		…
2584	scr_charset_choose (0);	2548	scr_charset_choose (0);
2585	break;	2549	break;
2586		2550
2587	#ifdef EIGHT_BIT_CONTROLS	2551	#ifdef EIGHT_BIT_CONTROLS
2588	// 8-bit controls	2552	// 8-bit controls
2589	case 0x90: /* DCS */	2553	case 0x90: /* DCS */
2590	process_dcs_seq ();	2554	process_dcs_seq ();
2591	break;	2555	break;
2592	case 0x9b: /* CSI */	2556	case 0x9b: /* CSI */
2593	process_csi_seq ();	2557	process_csi_seq ();
2594	break;	2558	break;
2595	case 0x9d: /* OSC */	2559	case 0x9d: /* OSC */
2596	process_osc_seq ();	2560	process_osc_seq ();
2597	break;	2561	break;
2598	#endif	2562	#endif
2599	}	2563	}
2600	}	2564	}
…		…
2728	wchar_t nlcr[] = { C0_LF, C0_CR };	2692	wchar_t nlcr[] = { C0_LF, C0_CR };
2729	scr_add_lines (nlcr, ecb_array_length (nlcr), 1);	2693	scr_add_lines (nlcr, ecb_array_length (nlcr), 1);
2730	}	2694	}
2731	break;	2695	break;
2732		2696
		2697	#if 0 // disabled because embedded newlines can make exploits easier
2733	/* kidnapped escape sequence: Should be 8.3.48 */	2698	/* kidnapped escape sequence: Should be 8.3.48 */
2734	case C1_ESA: /* ESC G */	2699	case C1_ESA: /* ESC G */
2735	// used by original rxvt for rob nations own graphics mode	2700	// used by original rxvt for rob nations own graphics mode
2736	if (cmd_getc () == 'Q')	2701	if (cmd_getc () == 'Q' && option (Opt_insecure))
2737	tt_printf ("\033G0\012"); /* query graphics - no graphics */	2702	tt_printf ("\033G0\012"); /* query graphics - no graphics */
2738	break;	2703	break;
		2704	#endif
2739		2705
2740	/* 8.3.63: CHARACTER TABULATION SET */	2706	/* 8.3.63: CHARACTER TABULATION SET */
2741	case C1_HTS: /* ESC H */	2707	case C1_HTS: /* ESC H */
2742	scr_set_tab (1);	2708	scr_set_tab (1);
2743	break;	2709	break;
…		…
2901	break;	2867	break;
2902		2868
2903	case '?':	2869	case '?':
2904	if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')	2870	if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')
2905	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);
2906	break;	2874	break;
2907		2875
2908	case '!':	2876	case '!':
2909	if (ch == CSI_70)	2877	if (ch == CSI_70)
2910	{	2878	{
2911	/* DECSTR: soft terminal reset, used by our terminfo since 9.06 */	2879	/* DECSTR: soft terminal reset, used by our terminfo since 9.06 */
2912	scr_soft_reset ();	2880	scr_soft_reset ();
2913		2881
2914	static const int pm_h[] = { 7, 25 };	2882	static const int pm_h[] = { 7, 25 };
2915	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 };
2916		2884
2917	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);
2918	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);
2919	}	2887	}
2920	break;	2888	break;
…		…
2950	case CSI_VPR: /* 8.3.161: (1) LINE POSITION FORWARD */	2918	case CSI_VPR: /* 8.3.161: (1) LINE POSITION FORWARD */
2951	scr_gotorc (arg[0], 0, RELATIVE);	2919	scr_gotorc (arg[0], 0, RELATIVE);
2952	break;	2920	break;
2953		2921
2954	case CSI_CUB: /* 8.3.18: (1) CURSOR LEFT */	2922	case CSI_CUB: /* 8.3.18: (1) CURSOR LEFT */
2955	case CSI_HPB: /* 8.3.59: (1) CHARACTER POSITION BACKWARD */	2923	case CSI_HPB: /* 8.3.59: (1) CHARACTER POSITION BACKWARD */
2956	#ifdef ISO6429	2924	#ifdef ISO6429
2957	arg[0] = -arg[0];	2925	arg[0] = -arg[0];
2958	#else /* emulate common DEC VTs */	2926	#else /* emulate common DEC VTs */
2959	arg[0] = arg[0] ? -arg[0] : -1;	2927	arg[0] = arg[0] ? -arg[0] : -1;
2960	#endif	2928	#endif
…		…
3051	case 7: /* unofficial extension */	3019	case 7: /* unofficial extension */
3052	if (option (Opt_insecure))	3020	if (option (Opt_insecure))
3053	tt_printf ("%-.250s\012", rs[Rs_display_name]);	3021	tt_printf ("%-.250s\012", rs[Rs_display_name]);
3054	break;	3022	break;
3055	case 8: /* unofficial extension */	3023	case 8: /* unofficial extension */
3056	process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);	3024	process_xterm_seq (XTerm_title, (char *)RESNAME "-" VERSION, CHAR_ST); // char * cast verified
3057	break;	3025	break;
3058	}	3026	}
3059	break;	3027	break;
3060		3028
3061	case CSI_TBC: /* 8.3.155: (0) TABULATION CLEAR */	3029	case CSI_TBC: /* 8.3.155: (0) TABULATION CLEAR */
…		…
3105	scr_insert_mode (1);	3073	scr_insert_mode (1);
3106	else if (arg[0] == 20)	3074	else if (arg[0] == 20)
3107	priv_modes |= PrivMode_LFNL;	3075	priv_modes |= PrivMode_LFNL;
3108	break;	3076	break;
3109		3077
3110	case CSI_71: // DESCUSR: set cursor style	3078	case CSI_71: // DECSCUSR: set cursor style
3111	if (prev_ch == ' ')	3079	if (prev_ch == ' ')
3112	set_cursor_style (arg[0]);	3080	set_cursor_style (arg[0]);
3113	break;	3081	break;
3114		3082
3115	/*	3083	/*
…		…
3336	free (s);	3304	free (s);
3337	}	3305	}
3338	}	3306	}
3339	}	3307	}
3340		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
3341	void	3405	void
3342	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)
3343	{	3407	{
3344	if (str[0] == '?' && !str[1])	3408	if (str[0] == '?' && !str[1])
3345	{	3409	{
		3410	if (!IN_RANGE_INC (color, minCOLOR, maxTermCOLOR))
		3411	return;
		3412
3346	rgba c;	3413	rgba c;
3347	pix_colors_focused[color].get (c);	3414	pix_colors_focused[color].get (c);
		3415	color -= minCOLOR;
3348		3416
3349	#if XFT	3417	#if XFT
3350	if (c.a != rgba::MAX_CC)	3418	if (c.a != rgba::MAX_CC)
3351	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);
3352	else	3420	else
3353	#endif	3421	#endif
3354	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);
3355	}	3423	}
3356	else	3424	else
3357	set_window_color (color, str);	3425	set_window_color (color, str);
3358	}	3426	}
3359		3427
…		…
3482	break;	3550	break;
3483	#endif	3551	#endif
3484	case URxvt_Color_border:	3552	case URxvt_Color_border:
3485	process_color_seq (op, Color_border, str, resp);	3553	process_color_seq (op, Color_border, str, resp);
3486	break;	3554	break;
3487
3488	#if BG_IMAGE_FROM_ROOT
3489	case URxvt_Color_tint:
3490	process_color_seq (op, Color_tint, str, resp);
3491	{
3492	bool changed = false;
3493
3494	if (ISSET_PIXCOLOR (Color_tint))
3495	changed = root_effects.set_tint (pix_colors_focused [Color_tint]);
3496
3497	if (changed)
3498	update_background ();
3499	}
3500
3501	break;
3502	#endif
3503
3504	#if BG_IMAGE_FROM_FILE
3505	case Rxvt_Pixmap:
3506	if (!strcmp (str, "?"))
3507	{
3508	char str[256];
3509	int h_scale = fimage.h_scale;
3510	int v_scale = fimage.v_scale;
3511	int h_align = fimage.h_align;
3512	int v_align = fimage.v_align;
3513
3514	sprintf (str, "[%dx%d+%d+%d]",
3515	h_scale, v_scale,
3516	h_align, v_align);
3517	process_xterm_seq (XTerm_title, str, CHAR_ST);
3518	}
3519	else
3520	{
3521	bool changed = false;
3522
3523	if (*str != ';')
3524	{
3525	try
3526	{
3527	fimage.set_file_geometry (this, str);
3528	changed = true;
3529	}
3530	catch (const class rxvt_failure_exception &e)
3531	{
3532	}
3533	}
3534	else
3535	{
3536	str++;
3537	if (fimage.set_geometry (str, true))
3538	changed = true;
3539	}
3540
3541	if (changed)
3542	{
3543	if (bg_window_position_sensitive ())
3544	{
3545	int x, y;
3546	get_window_origin (x, y);
3547	parent_x = x;
3548	parent_y = y;
3549	}
3550	update_background ();
3551	}
3552	}
3553	break;
3554	#endif
3555		3555
3556	case XTerm_logfile:	3556	case XTerm_logfile:
3557	// TODO, when secure mode?	3557	// TODO, when secure mode?
3558	break;	3558	break;
3559		3559
…		…
3693	{ 5, PrivMode_rVideo }, // DECSCNM	3693	{ 5, PrivMode_rVideo }, // DECSCNM
3694	{ 6, PrivMode_relOrigin }, // DECOM	3694	{ 6, PrivMode_relOrigin }, // DECOM
3695	{ 7, PrivMode_Autowrap }, // DECAWM	3695	{ 7, PrivMode_Autowrap }, // DECAWM
3696	// 8, auto-repeat keys // DECARM	3696	// 8, auto-repeat keys // DECARM
3697	{ 9, PrivMode_MouseX10 },	3697	{ 9, PrivMode_MouseX10 },
		3698	{ 12, PrivMode_BlinkingCursor },
3698	// 18 end FF to printer after print screen	3699	// 18 end FF to printer after print screen
3699	// 19 Print screen prints full screen/scroll region	3700	// 19 Print screen prints full screen/scroll region
3700	{ 25, PrivMode_VisibleCursor }, // DECTCEM cnorm/cvvis/civis	3701	{ 25, PrivMode_VisibleCursor }, // DECTCEM cnorm/cvvis/civis
3701	#ifdef scrollBar_esc	3702	#ifdef scrollBar_esc
3702	{ scrollBar_esc, PrivMode_scrollBar },	3703	{ scrollBar_esc, PrivMode_scrollBar },
…		…
3714	#endif	3715	#endif
3715	{ 1000, PrivMode_MouseX11 },	3716	{ 1000, PrivMode_MouseX11 },
3716	{ 1002, PrivMode_MouseBtnEvent },	3717	{ 1002, PrivMode_MouseBtnEvent },
3717	{ 1003, PrivMode_MouseAnyEvent },	3718	{ 1003, PrivMode_MouseAnyEvent },
3718	#if ENABLE_FRILLS	3719	#if ENABLE_FRILLS
		3720	{ 1004, PrivMode_FocusEvent },
3719	{ 1005, PrivMode_ExtModeMouse },	3721	{ 1005, PrivMode_ExtMouseUTF8 },
		3722	{ 1006, PrivMode_ExtMouseSGR },
3720	#endif	3723	#endif
3721	{ 1010, PrivMode_TtyOutputInh }, // rxvt extension	3724	{ 1010, PrivMode_TtyOutputInh }, // rxvt extension
3722	{ 1011, PrivMode_Keypress }, // rxvt extension	3725	{ 1011, PrivMode_Keypress }, // rxvt extension
3723	#if ENABLE_FRILLS	3726	#if ENABLE_FRILLS
3724	{ 1015, PrivMode_ExtMouseRight }, // urxvt extension of 1005	3727	{ 1015, PrivMode_ExtMouseUrxvt }, // urxvt extension of 1005
3725	#endif	3728	#endif
3726	// 1035 enable modifiers for alt, numlock NYI	3729	// 1035 enable modifiers for alt, numlock NYI
3727	// 1036 send ESC for meta keys NYI	3730	// 1036 send ESC for meta keys NYI
3728	// 1037 send DEL for keypad delete NYI	3731	// 1037 send DEL for keypad delete NYI
3729	{ 1047, PrivMode_Screen },	3732	{ 1047, PrivMode_Screen },
3730	// 1048 save and restore cursor, implemented in code	3733	// 1048 save and restore cursor, implemented in code
3731	{ 1049, PrivMode_Screen }, /* xterm extension, clear screen on ti rather than te */	3734	{ 1049, PrivMode_Screen }, /* xterm extension, clear screen on ti rather than te */
3732	// 1051, 1052, 1060, 1061 keyboard emulation NYI	3735	// 1051, 1052, 1060, 1061 keyboard emulation NYI
		3736	#if ENABLE_FRILLS
3733	{ 2004, PrivMode_BracketPaste },	3737	{ 2004, PrivMode_BracketPaste },
		3738	#endif
3734	};	3739	};
3735		3740
3736	if (nargs == 0)	3741	if (nargs == 0)
3737	return;	3742	return;
		3743
		3744	// DECRQM
		3745	if (mode == 'p')
		3746	{
		3747	int status = 0;
		3748	if (nargs != 1)
		3749	return;
		3750
		3751	for (j = 0; j < ecb_array_length (argtopriv); j++)
		3752	if (argtopriv[j].argval == arg[0])
		3753	{
		3754	status = (priv_modes & argtopriv[j].bit) ? 1 : 2;
		3755	break;
		3756	}
		3757
		3758	tt_printf ("\33[?%d;%d$y", arg[0], status);
		3759	return;
		3760	}
3738		3761
3739	/* make lo/hi boolean */	3762	/* make lo/hi boolean */
3740	if (mode == 'l')	3763	if (mode == 'l')
3741	mode = 0; /* reset */	3764	mode = 0; /* reset */
3742	else if (mode == 'h')	3765	else if (mode == 'h')
…		…
3811	scrollBar.map (state);	3834	scrollBar.map (state);
3812	resize_all_windows (0, 0, 0);	3835	resize_all_windows (0, 0, 0);
3813	scr_touch (true);	3836	scr_touch (true);
3814	break;	3837	break;
3815	#endif	3838	#endif
		3839	#ifdef CURSOR_BLINK
		3840	case 12:
		3841	cursor_blink_reset ();
		3842	break;
		3843	#endif
3816	case 25: /* visible/invisible cursor */	3844	case 25: /* visible/invisible cursor */
3817	scr_cursor_visible (state);	3845	scr_cursor_visible (state);
3818	break;	3846	break;
3819	/* case 35: - shift keys */	3847	/* case 35: - shift keys */
3820	/* case 40: - 80 <--> 132 mode */	3848	/* case 40: - 80 <--> 132 mode */
…		…
3925	//case 19: // ninth alt font	3953	//case 19: // ninth alt font
3926	//case 20: // gothic	3954	//case 20: // gothic
3927	case 21: // disable bold, faint, sometimes doubly underlined (iso 8613)	3955	case 21: // disable bold, faint, sometimes doubly underlined (iso 8613)
3928	rendset = 0, rendstyle = RS_Bold;	3956	rendset = 0, rendstyle = RS_Bold;
3929	break;	3957	break;
3930	case 22: // normal intensity	3958	case 22: // bold off (vt220)
3931	rendset = 0, rendstyle = RS_Bold;	3959	rendset = 0, rendstyle = RS_Bold;
3932	break;	3960	break;
3933	case 23: // disable italic	3961	case 23: // disable italic
3934	rendset = 0, rendstyle = RS_Italic;	3962	rendset = 0, rendstyle = RS_Italic;
3935	break;	3963	break;
3936	case 24:	3964	case 24: // underline off (vt220)
3937	rendset = 0, rendstyle = RS_Uline;	3965	rendset = 0, rendstyle = RS_Uline;
3938	break;	3966	break;
3939	case 25:	3967	case 25: // blink off (vt220)
3940	rendset = 0, rendstyle = RS_Blink;	3968	rendset = 0, rendstyle = RS_Blink;
3941	break;	3969	break;
3942	case 26: // variable spacing (iso 8613)	3970	case 26: // variable spacing (iso 8613)
3943	rendset = 0, rendstyle = RS_Blink;	3971	rendset = 0, rendstyle = RS_Blink;
3944	break;	3972	break;
3945	case 27:	3973	case 27: // reverse off (vt220)
3946	rendset = 0, rendstyle = RS_RVid;	3974	rendset = 0, rendstyle = RS_RVid;
3947	break;	3975	break;
3948	//case 28: // visible. NYI	3976	//case 28: // visible. NYI
3949	//case 29: // not crossed-out	3977	//case 29: // not crossed-out
3950	}	3978	}
…		…
3965	case 35:	3993	case 35:
3966	case 36:	3994	case 36:
3967	case 37:	3995	case 37:
3968	scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);	3996	scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);
3969	break;	3997	break;
3970	case 38: // set fg color, ISO 8613-6
3971	if (nargs > i + 2 && arg[i + 1] == 5)
3972	{
3973	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg);
3974	i += 2;
3975	}
3976	break;
3977	case 39: /* default fg */	3998	case 39: /* default fg */
3978	scr_color (Color_fg, Color_fg);	3999	scr_color (Color_fg, Color_fg);
3979	break;	4000	break;
3980		4001
3981	case 40:	4002	case 40:
…		…
3986	case 45:	4007	case 45:
3987	case 46:	4008	case 46:
3988	case 47:	4009	case 47:
3989	scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);	4010	scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);
3990	break;	4011	break;
3991	case 48: // set bg color, ISO 8613-6
3992	if (nargs > i + 2 && arg[i + 1] == 5)
3993	{
3994	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg);
3995	i += 2;
3996	}
3997	break;
3998	case 49: /* default bg */	4012	case 49: /* default bg */
3999	scr_color (Color_bg, Color_bg);	4013	scr_color (Color_bg, Color_bg);
		4014	break;
		4015
		4016	case 38: // set fg color, ISO 8613-6
		4017	case 48: // set bg color, ISO 8613-6
		4018	{
		4019	unsigned int fgbg = arg[i] == 38 ? Color_fg : Color_bg;
		4020	unsigned int idx;
		4021
		4022	if (nargs > i + 2 && arg[i + 1] == 5)
		4023	{
		4024	idx = minCOLOR + arg[i + 2];
		4025	i += 2;
		4026
		4027	scr_color (idx, fgbg);
		4028	}
		4029	else if (nargs > i + 4 && arg[i + 1] == 2)
		4030	{
		4031	unsigned int r = arg[i + 2];
		4032	unsigned int g = arg[i + 3];
		4033	unsigned int b = arg[i + 4];
		4034	unsigned int a = 0xff;
		4035
		4036	idx = map_rgb24_color (r, g, b, a);
		4037
		4038	i += 4;
		4039
		4040	scr_color (idx, fgbg);
		4041	}
		4042	}
4000	break;	4043	break;
4001		4044
4002	//case 50: // not variable spacing	4045	//case 50: // not variable spacing
4003		4046
4004	#if !ENABLE_MINIMAL	4047	#if !ENABLE_MINIMAL
…		…
4028	}	4071	}
4029		4072
4030	void	4073	void
4031	rxvt_term::set_cursor_style (int style)	4074	rxvt_term::set_cursor_style (int style)
4032	{	4075	{
4033	if (!IN_RANGE_INC (style, 0, 4))	4076	if (!IN_RANGE_INC (style, 0, 6))
4034	return;	4077	return;
4035		4078
		4079	if (style == 0)
		4080	style = 1;
		4081
		4082	cursor_type = (style - 1) / 2;
4036	set_option (Opt_cursorUnderline, style >= 3);	4083	set_option (Opt_cursorUnderline, cursor_type == 1);
4037		4084
4038	#ifdef CURSOR_BLINK	4085	#ifdef CURSOR_BLINK
4039	set_option (Opt_cursorBlink, !style || (style & 1));	4086	set_option (Opt_cursorBlink, style & 1);
4040	cursor_blink_reset ();	4087	cursor_blink_reset ();
4041	#endif	4088	#endif
4042		4089
4043	want_refresh = 1;	4090	want_refresh = 1;
4044	}	4091	}
4045	/*}}} */	4092	/*}}} */
4046		4093
4047	/* ------------------------------------------------------------------------- */	4094	/* ---------------------------------------------------------------------- */
		4095	/* Write data to the pty as typed by the user, pasted with the mouse,
		4096	* or generated by us in response to a query ESC sequence.
		4097	*/
4048		4098
4049	/*	4099	/*
4050	* Send printf () formatted output to the command.	4100	* Send printf () formatted output to the command.
4051	* Only use for small amounts of data.	4101	* Only use for small amounts of data.
4052	*/	4102	*/
…		…
4060	vsnprintf ((char *)buf, 256, fmt, arg_ptr);	4110	vsnprintf ((char *)buf, 256, fmt, arg_ptr);
4061	va_end (arg_ptr);	4111	va_end (arg_ptr);
4062	tt_write (buf, strlen (buf));	4112	tt_write (buf, strlen (buf));
4063	}	4113	}
4064		4114
4065	/* ---------------------------------------------------------------------- */
4066	/* Write data to the pty as typed by the user, pasted with the mouse,	4115	/* Write data to the pty as typed by the user. */
4067	* or generated by us in response to a query ESC sequence.	4116	void
4068	*/	4117	rxvt_term::tt_write_user_input (const char *data, unsigned int len)
4069	static const unsigned int MAX_PTY_WRITE = 255; // minimum MAX_INPUT	4118	{
		4119	if (HOOK_INVOKE ((this, HOOK_TT_WRITE, DT_STR_LEN, data, len, DT_END)))
		4120	return;
		4121
		4122	if (option (Opt_scrollTtyKeypress))
		4123	if (view_start)
		4124	{
		4125	view_start = 0;
		4126	want_refresh = 1;
		4127	}
		4128
		4129	tt_write_ (data, len);
		4130	}
4070		4131
4071	void	4132	void
4072	rxvt_term::tt_write (const char *data, unsigned int len)	4133	rxvt_term::tt_write (const char *data, unsigned int len)
4073	{	4134	{
4074	if (HOOK_INVOKE ((this, HOOK_TT_WRITE, DT_STR_LEN, data, len, DT_END)))	4135	if (HOOK_INVOKE ((this, HOOK_TT_WRITE, DT_STR_LEN, data, len, DT_END)))
4075	return;	4136	return;
4076		4137
		4138	tt_write_ (data, len);
		4139	}
		4140
		4141	static const unsigned int MAX_PTY_WRITE = 255; // minimum MAX_INPUT
		4142
		4143	void
		4144	rxvt_term::tt_write_ (const char *data, unsigned int len)
		4145	{
4077	if (pty->pty < 0)	4146	if (pty->pty < 0)
4078	return;	4147	return;
4079		4148
4080	if (v_buflen == 0)	4149	if (v_buflen == 0)
4081	{	4150	{

Diff Legend

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