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.131 by root, Fri Aug 13 22:38:57 2004 UTC vs.
Revision 1.168 by root, Sun Sep 5 09:32:59 2004 UTC

…		…
57	#define IS_CONTROL(ch) !((ch) & 0xffffff60UL)	57	#define IS_CONTROL(ch) !((ch) & 0xffffff60UL)
58		58
59	// exception thrown when the command parser runs out of input data	59	// exception thrown when the command parser runs out of input data
60	class out_of_input { } out_of_input;	60	class out_of_input { } out_of_input;
61		61
62	#ifndef NO_FRILLS	62	#if ENABLE_FRILLS || ISO_14755
63		63
64	#define ISO_14755_KEYCODE_VALID 0x80000000UL
65	#define ISO_14755_ACTIVE 0x40000000UL	64	#define ISO_14755_STARTED 0x80000000UL
66	#define ISO_14755_ESCAPE_NEXT 0x20000000UL	65	#define ISO_14755_51 0x40000000UL // basic (section 5.1)
		66	#define ISO_14755_52 0x20000000UL // keycap (section 5.2)
		67	#define ISO_14755_54 0x10000000UL // code feedback (section 5.4)
		68	#define ISO_14755_MASK 0x0fffffffUL
67		69
		70	#if ISO_14755
68	static unsigned short iso14755_symtab[] = {	71	static unsigned short iso14755_symtab[] = {
69	// keysym, unicode	72	// keysym, unicode
70	XK_Left, 0x2190,	73	XK_Left, 0x2190,
71	XK_KP_Left, 0x2190,	74	XK_KP_Left, 0x2190,
72	XK_Up, 0x2191,	75	XK_Up, 0x2191,
…		…
115	XK_KP_Space, 0x2422,	118	XK_KP_Space, 0x2422,
116	0,	119	0,
117	};	120	};
118		121
119	void	122	void
		123	rxvt_term::iso14755_54 (int x, int y)
		124	{
		125	x = Pixel2Col (x);
		126	y = Pixel2Row (y);
		127
		128	if (x < 0 || x >= TermWin.ncol
		129	|| y < 0 || y >= TermWin.nrow)
		130	return;
		131
		132	for (;;)
		133	{
		134	text_t t = screen.text[y + TermWin.saveLines - TermWin.view_start][x];
		135
		136	if (t != NOCHAR || !x)
		137	{
		138	iso14755_51 (screen.text[y + TermWin.saveLines - TermWin.view_start][x],
		139	screen.rend[y + TermWin.saveLines - TermWin.view_start][x]);
		140	iso14755buf = ISO_14755_54;
		141	break;
		142	}
		143
		144	x--;
		145	}
		146
		147	}
		148	#endif
		149
		150	#if ENABLE_OVERLAY
		151	void
		152	rxvt_term::iso14755_51 (unicode_t ch, rend_t r)
		153	{
		154	rxvt_fontset *fs = FONTSET (r);
		155	rxvt_font *f = (*fs)[fs->find_font (ch)];
		156	wchar_t *chr, *alloc, ch2;
		157	int len;
		158
		159	#if ENABLE_COMBINING
		160	if (IS_COMPOSE (ch))
		161	{
		162	len = rxvt_composite.expand (ch, 0);
		163	alloc = chr = new wchar_t[len];
		164	rxvt_composite.expand (ch, chr);
		165	}
		166	else
		167	#endif
		168	{
		169	ch2 = ch;
		170
		171	alloc = 0;
		172	chr = &ch2;
		173	len = 1;
		174	}
		175
		176	int width = strlen (f->name);
		177
		178	scr_overlay_new (0, -1, width < 8+5 ? 8+5 : width, len + 1);
		179
		180	r = SET_STYLE (OVERLAY_RSTYLE, GET_STYLE (r));
		181
		182	for (int y = 0; y < len; y++)
		183	{
		184	char buf[9];
		185
		186	ch = *chr++;
		187
		188	sprintf (buf, "%8x", ch);
		189	scr_overlay_set (0, y, buf);
		190	scr_overlay_set (9, y, '=');
		191	#if !UNICODE3
		192	if (ch >= 0x10000)
		193	ch = 0xfffd;
		194	#endif
		195	scr_overlay_set (11, y, ch, r);
		196	scr_overlay_set (12, y, NOCHAR, r);
		197	}
		198
		199	scr_overlay_set (0, len, f->name);
		200
		201	#if ENABLE_COMBINING
		202	if (alloc)
		203	delete [] alloc;
		204	#endif
		205	}
		206	#endif
		207
		208	void
120	rxvt_term::commit_iso14755 ()	209	rxvt_term::commit_iso14755 ()
121	{	210	{
122	wchar_t ch[2];	211	wchar_t ch[2];
123		212
124	ch[0] = iso14755buf & 0x1fffffffUL; // actually, unicode needs a 0x1fffff mask	213	ch[0] = iso14755buf & ISO_14755_MASK;
125	ch[1] = 0;	214	ch[1] = 0;
126		215
127	if (iso14755buf & ISO_14755_KEYCODE_VALID)	216	if (iso14755buf & ISO_14755_51)
128	{	217	{
129	char mb[16];	218	char mb[16];
130	int len;	219	int len;
131		220
132	// allow verbatim 0-bytes and control-bytes to be entered	221	// allow verbatim 0-bytes and control-bytes to be entered
…		…
320	if (keysym >= XK_F1 && keysym <= XK_F10)	409	if (keysym >= XK_F1 && keysym <= XK_F10)
321	{	410	{
322	keysym += (XK_F11 - XK_F1);	411	keysym += (XK_F11 - XK_F1);
323	shft = 0; /* turn off Shift */	412	shft = 0; /* turn off Shift */
324	}	413	}
325	else if (!ctrl && !meta && (PrivateModes & PrivMode_ShiftKeys))	414	else if (!ctrl && !meta && (priv_modes & PrivMode_ShiftKeys))
326	{	415	{
327	switch (keysym)	416	switch (keysym)
328	{	417	{
329	/* normal XTerm key bindings */	418	/* normal XTerm key bindings */
330	case XK_Insert: /* Shift+Insert = paste mouse selection */	419	case XK_Insert: /* Shift+Insert = paste mouse selection */
…		…
341	#endif	430	#endif
342	}	431	}
343	}	432	}
344	}	433	}
345		434
346	#ifndef NO_FRILLS	435	#if ENABLE_FRILLS || ISO_14755
347	// ISO 14755 support	436	// ISO 14755 support
348	if (shft && ctrl)	437	if (shft && ctrl)
349	{	438	{
350	int hv;	439	int hv;
351		440
		441	if (iso14755buf & ISO_14755_51
352	if (keysym == XK_space || keysym == XK_KP_Space	442	&& (keysym == XK_space || keysym == XK_KP_Space
353	|| keysym == XK_Return || keysym == XK_KP_Enter)	443	|| keysym == XK_Return || keysym == XK_KP_Enter))
354	{	444	{
355	commit_iso14755 ();	445	commit_iso14755 ();
		446	iso14755buf = ISO_14755_51;
		447	# if ISO_14755
		448	iso14755_51 (0);
		449	# endif
356	return;	450	return;
357	}	451	}
358	else if ((hv = hex_keyval (ev)) >= 0)	452	else if ((hv = hex_keyval (ev)) >= 0)
359	{	453	{
360	iso14755buf = (iso14755buf << 4) | hv | ISO_14755_KEYCODE_VALID;	454	iso14755buf = ((iso14755buf << 4) & ISO_14755_MASK)
		455	| hv | ISO_14755_51;
		456	# if ISO_14755
		457	iso14755_51 (iso14755buf & ISO_14755_MASK);
		458	# endif
361	return;	459	return;
362	}	460	}
363	else	461	else
		462	{
		463	# if ENABLE_OVERLAY
		464	scr_overlay_off ();
		465	# endif
364	iso14755buf = 0;	466	iso14755buf = 0;
		467	}
365	}	468	}
366	else if ((ctrl && (keysym == XK_Shift_L || keysym == XK_Shift_R))	469	else if ((ctrl && (keysym == XK_Shift_L || keysym == XK_Shift_R))
367	|| (shft && (keysym == XK_Control_L || keysym == XK_Control_R)))	470	|| (shft && (keysym == XK_Control_L || keysym == XK_Control_R)))
		471	if (!(iso14755buf & ISO_14755_STARTED))
		472	{
368	iso14755buf |= ISO_14755_ACTIVE;	473	iso14755buf |= ISO_14755_STARTED;
		474	# if ENABLE_OVERLAY
		475	scr_overlay_new (0, -1, sizeof ("ISO 14755 mode") - 1, 1);
		476	scr_overlay_set (0, 0, "ISO 14755 mode");
		477	# endif
		478	}
369	#endif	479	#endif
370		480
371	#ifdef PRINTPIPE	481	#ifdef PRINTPIPE
372	if (keysym == XK_Print)	482	if (keysym == XK_Print)
373	{	483	{
…		…
407	newlen = 1;	517	newlen = 1;
408	switch (keysym)	518	switch (keysym)
409	{	519	{
410	#ifndef NO_BACKSPACE_KEY	520	#ifndef NO_BACKSPACE_KEY
411	case XK_BackSpace:	521	case XK_BackSpace:
412	if (PrivateModes & PrivMode_HaveBackSpace)	522	if (priv_modes & PrivMode_HaveBackSpace)
413	{	523	{
414	kbuf[0] = (!! (PrivateModes & PrivMode_BackSpace)	524	kbuf[0] = (!! (priv_modes & PrivMode_BackSpace)
415	^ !!ctrl) ? '\b' : '\177';	525	^ !!ctrl) ? '\b' : '\177';
416	kbuf[1] = '\0';	526	kbuf[1] = '\0';
417	}	527	}
418	else	528	else
419	STRCPY (kbuf, key_backspace);	529	strcpy (kbuf, key_backspace);
420	break;	530	break;
421	#endif	531	#endif
422	#ifndef NO_DELETE_KEY	532	#ifndef NO_DELETE_KEY
423	case XK_Delete:	533	case XK_Delete:
424	STRCPY (kbuf, key_delete);	534	strcpy (kbuf, key_delete);
425	break;	535	break;
426	#endif	536	#endif
427	case XK_Tab:	537	case XK_Tab:
428	if (shft)	538	if (shft)
429	STRCPY (kbuf, "\033[Z");	539	strcpy (kbuf, "\033[Z");
430	else	540	else
431	{	541	{
432	#ifdef CTRL_TAB_MAKES_META	542	#ifdef CTRL_TAB_MAKES_META
433	if (ctrl)	543	if (ctrl)
434	meta = 1;	544	meta = 1;
…		…
444	#ifdef XK_KP_Left	554	#ifdef XK_KP_Left
445	case XK_KP_Up: /* \033Ox or standard */	555	case XK_KP_Up: /* \033Ox or standard */
446	case XK_KP_Down: /* \033Or or standard */	556	case XK_KP_Down: /* \033Or or standard */
447	case XK_KP_Right: /* \033Ov or standard */	557	case XK_KP_Right: /* \033Ov or standard */
448	case XK_KP_Left: /* \033Ot or standard */	558	case XK_KP_Left: /* \033Ot or standard */
449	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	559	if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
450	{	560	{
451	STRCPY (kbuf, "\033OZ");	561	strcpy (kbuf, "\033OZ");
452	kbuf[2] = "txvr"[keysym - XK_KP_Left];	562	kbuf[2] = "txvr"[keysym - XK_KP_Left];
453	break;	563	break;
454	}	564	}
455	else	565	else
456	/* translate to std. cursor key */	566	/* translate to std. cursor key */
…		…
459	#endif	569	#endif
460	case XK_Up: /* "\033[A" */	570	case XK_Up: /* "\033[A" */
461	case XK_Down: /* "\033[B" */	571	case XK_Down: /* "\033[B" */
462	case XK_Right: /* "\033[C" */	572	case XK_Right: /* "\033[C" */
463	case XK_Left: /* "\033[D" */	573	case XK_Left: /* "\033[D" */
464	STRCPY (kbuf, "\033[Z");	574	strcpy (kbuf, "\033[Z");
465	kbuf[2] = "DACB"[keysym - XK_Left];	575	kbuf[2] = "DACB"[keysym - XK_Left];
466	/* do Shift first */	576	/* do Shift first */
467	if (shft)	577	if (shft)
468	kbuf[2] = "dacb"[keysym - XK_Left];	578	kbuf[2] = "dacb"[keysym - XK_Left];
469	else if (ctrl)	579	else if (ctrl)
470	{	580	{
471	kbuf[1] = 'O';	581	kbuf[1] = 'O';
472	kbuf[2] = "dacb"[keysym - XK_Left];	582	kbuf[2] = "dacb"[keysym - XK_Left];
473	}	583	}
474	else if (PrivateModes & PrivMode_aplCUR)	584	else if (priv_modes & PrivMode_aplCUR)
475	kbuf[1] = 'O';	585	kbuf[1] = 'O';
476	break;	586	break;
477		587
478	#ifndef UNSHIFTED_SCROLLKEYS	588	#ifndef UNSHIFTED_SCROLLKEYS
479	# ifdef XK_KP_Prior	589	# ifdef XK_KP_Prior
480	case XK_KP_Prior:	590	case XK_KP_Prior:
481	/* allow shift to override */	591	/* allow shift to override */
482	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	592	if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
483	{	593	{
484	STRCPY (kbuf, "\033Oy");	594	strcpy (kbuf, "\033Oy");
485	break;	595	break;
486	}	596	}
487	/* FALLTHROUGH */	597	/* FALLTHROUGH */
488	# endif	598	# endif
489	case XK_Prior:	599	case XK_Prior:
490	STRCPY (kbuf, "\033[5~");	600	strcpy (kbuf, "\033[5~");
491	break;	601	break;
492	# ifdef XK_KP_Next	602	# ifdef XK_KP_Next
493	case XK_KP_Next:	603	case XK_KP_Next:
494	/* allow shift to override */	604	/* allow shift to override */
495	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	605	if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
496	{	606	{
497	STRCPY (kbuf, "\033Os");	607	strcpy (kbuf, "\033Os");
498	break;	608	break;
499	}	609	}
500	/* FALLTHROUGH */	610	/* FALLTHROUGH */
501	# endif	611	# endif
502	case XK_Next:	612	case XK_Next:
503	STRCPY (kbuf, "\033[6~");	613	strcpy (kbuf, "\033[6~");
504	break;	614	break;
505	#endif	615	#endif
506	case XK_KP_Enter:	616	case XK_KP_Enter:
507	/* allow shift to override */	617	/* allow shift to override */
508	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	618	if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
509	{	619	{
510	STRCPY (kbuf, "\033OM");	620	strcpy (kbuf, "\033OM");
		621	break;
		622	}
		623
		624	/* FALLTHROUGH */
		625
		626	case XK_Return:
		627	if (priv_modes & PrivMode_LFNL)
		628	{
		629	kbuf[0] = '\015';
		630	kbuf[1] = '\012';
		631	kbuf[2] = '\0';
511	}	632	}
512	else	633	else
513	{	634	{
514	kbuf[0] = '\r';	635	kbuf[0] = '\015';
515	kbuf[1] = '\0';	636	kbuf[1] = '\0';
516	}	637	}
517	break;	638	break;
518		639
519	#ifdef XK_KP_Begin	640	#ifdef XK_KP_Begin
520	case XK_KP_Begin:	641	case XK_KP_Begin:
521	STRCPY (kbuf, "\033Ou");	642	strcpy (kbuf, "\033Ou");
522	break;	643	break;
523		644
524	case XK_KP_Insert:	645	case XK_KP_Insert:
525	STRCPY (kbuf, "\033Op");	646	strcpy (kbuf, "\033Op");
526	break;	647	break;
527		648
528	case XK_KP_Delete:	649	case XK_KP_Delete:
529	STRCPY (kbuf, "\033On");	650	strcpy (kbuf, "\033On");
530	break;	651	break;
531	#endif	652	#endif
532	case XK_KP_F1: /* "\033OP" */	653	case XK_KP_F1: /* "\033OP" */
533	case XK_KP_F2: /* "\033OQ" */	654	case XK_KP_F2: /* "\033OQ" */
534	case XK_KP_F3: /* "\033OR" */	655	case XK_KP_F3: /* "\033OR" */
535	case XK_KP_F4: /* "\033OS" */	656	case XK_KP_F4: /* "\033OS" */
536	STRCPY (kbuf, "\033OP");	657	strcpy (kbuf, "\033OP");
537	kbuf[2] += (keysym - XK_KP_F1);	658	kbuf[2] += (keysym - XK_KP_F1);
538	break;	659	break;
539		660
540	case XK_KP_Multiply: /* "\033Oj" : "*" */	661	case XK_KP_Multiply: /* "\033Oj" : "*" */
541	case XK_KP_Add: /* "\033Ok" : "+" */	662	case XK_KP_Add: /* "\033Ok" : "+" */
…		…
552	case XK_KP_6: /* "\033Ov" : "6" */	673	case XK_KP_6: /* "\033Ov" : "6" */
553	case XK_KP_7: /* "\033Ow" : "7" */	674	case XK_KP_7: /* "\033Ow" : "7" */
554	case XK_KP_8: /* "\033Ox" : "8" */	675	case XK_KP_8: /* "\033Ox" : "8" */
555	case XK_KP_9: /* "\033Oy" : "9" */	676	case XK_KP_9: /* "\033Oy" : "9" */
556	/* allow shift to override */	677	/* allow shift to override */
557	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	678	if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
558	{	679	{
559	STRCPY (kbuf, "\033Oj");	680	strcpy (kbuf, "\033Oj");
560	kbuf[2] += (keysym - XK_KP_Multiply);	681	kbuf[2] += (keysym - XK_KP_Multiply);
561	}	682	}
562	else	683	else
563	{	684	{
564	kbuf[0] = ('*' + (keysym - XK_KP_Multiply));	685	kbuf[0] = ('*' + (keysym - XK_KP_Multiply));
565	kbuf[1] = '\0';	686	kbuf[1] = '\0';
566	}	687	}
567	break;	688	break;
568		689
569	case XK_Find:	690	case XK_Find:
570	STRCPY (kbuf, "\033[1~");	691	strcpy (kbuf, "\033[1~");
571	break;	692	break;
572	case XK_Insert:	693	case XK_Insert:
573	STRCPY (kbuf, "\033[2~");	694	strcpy (kbuf, "\033[2~");
574	break;	695	break;
575	#ifdef DXK_Remove /* support for DEC remove like key */	696	#ifdef DXK_Remove /* support for DEC remove like key */
576	case DXK_Remove:	697	case DXK_Remove:
577	/* FALLTHROUGH */	698	/* FALLTHROUGH */
578	#endif	699	#endif
579	case XK_Execute:	700	case XK_Execute:
580	STRCPY (kbuf, "\033[3~");	701	strcpy (kbuf, "\033[3~");
581	break;	702	break;
582	case XK_Select:	703	case XK_Select:
583	STRCPY (kbuf, "\033[4~");	704	strcpy (kbuf, "\033[4~");
584	break;	705	break;
585	#ifdef XK_KP_End	706	#ifdef XK_KP_End
586	case XK_KP_End:	707	case XK_KP_End:
587	/* allow shift to override */	708	/* allow shift to override */
588	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	709	if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
589	{	710	{
590	STRCPY (kbuf, "\033Oq");	711	strcpy (kbuf, "\033Oq");
591	break;	712	break;
592	}	713	}
593	/* FALLTHROUGH */	714	/* FALLTHROUGH */
594	#endif	715	#endif
595	case XK_End:	716	case XK_End:
596	STRCPY (kbuf, KS_END);	717	strcpy (kbuf, KS_END);
597	break;	718	break;
598	#ifdef XK_KP_Home	719	#ifdef XK_KP_Home
599	case XK_KP_Home:	720	case XK_KP_Home:
600	/* allow shift to override */	721	/* allow shift to override */
601	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	722	if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
602	{	723	{
603	STRCPY (kbuf, "\033Ow");	724	strcpy (kbuf, "\033Ow");
604	break;	725	break;
605	}	726	}
606	/* FALLTHROUGH */	727	/* FALLTHROUGH */
607	#endif	728	#endif
608	case XK_Home:	729	case XK_Home:
609	STRCPY (kbuf, KS_HOME);	730	strcpy (kbuf, KS_HOME);
610	break;	731	break;
611		732
612	#define FKEY(n, fkey) \	733	#define FKEY(n, fkey) \
613	sprintf ((char *)kbuf,"\033[%2d~", (int) ((n) + (keysym - fkey)))	734	sprintf ((char *)kbuf,"\033[%2d~", (int) ((n) + (keysym - fkey)))
614		735
…		…
667	default:	788	default:
668	newlen = 0;	789	newlen = 0;
669	break;	790	break;
670	}	791	}
671	if (newlen)	792	if (newlen)
672	len = STRLEN (kbuf);	793	len = strlen (kbuf);
673	}	794	}
674		795
675	/*	796	/*
676	* Pass meta for all function keys, if 'meta' option set	797	* Pass meta for all function keys, if 'meta' option set
677	*/	798	*/
…		…
705	}	826	}
706		827
707	if (len <= 0)	828	if (len <= 0)
708	return; /* not mapped */	829	return; /* not mapped */
709		830
710	if (Options & Opt_scrollTtyKeypress)	831	if (options & Opt_scrollTtyKeypress)
711	if (TermWin.view_start)	832	if (TermWin.view_start)
712	{	833	{
713	TermWin.view_start = 0;	834	TermWin.view_start = 0;
714	want_refresh = 1;	835	want_refresh = 1;
715	}	836	}
…		…
764	n = cmdbuf_ptr - cmdbuf_base;	885	n = cmdbuf_ptr - cmdbuf_base;
765	s = cmdbuf_base + CBUFSIZ - 1 - cmdbuf_endp;	886	s = cmdbuf_base + CBUFSIZ - 1 - cmdbuf_endp;
766		887
767	if (n > 0 && s < count)	888	if (n > 0 && s < count)
768	{	889	{
769	MEMMOVE (cmdbuf_base, cmdbuf_ptr,	890	memmove (cmdbuf_base, cmdbuf_ptr,
770	(unsigned int) (cmdbuf_endp - cmdbuf_ptr));	891	(unsigned int) (cmdbuf_endp - cmdbuf_ptr));
771	cmdbuf_ptr = cmdbuf_base;	892	cmdbuf_ptr = cmdbuf_base;
772	cmdbuf_endp -= n;	893	cmdbuf_endp -= n;
773	s += n;	894	s += n;
774	}	895	}
…		…
789	#endif /* MENUBAR_MAX */	910	#endif /* MENUBAR_MAX */
790		911
791	void	912	void
792	rxvt_term::flush ()	913	rxvt_term::flush ()
793	{	914	{
		915	flush_ev.stop ();
		916
794	#ifdef TRANSPARENT	917	#ifdef TRANSPARENT
795	if (want_full_refresh)	918	if (want_full_refresh)
796	{	919	{
797	want_full_refresh = 0;	920	want_full_refresh = 0;
798	scr_clear ();	921	scr_clear ();
…		…
808	IMSendSpot ();	931	IMSendSpot ();
809	#endif	932	#endif
810	}	933	}
811		934
812	display->flush ();	935	display->flush ();
813
814	flush_ev.stop ();
815	}	936	}
816		937
817	void	938	void
818	rxvt_term::check_cb (check_watcher &w)	939	rxvt_term::check_cb (check_watcher &w)
819	{	940	{
…		…
917		1038
918	memmove (cmdbuf_base, cmdbuf_ptr, n);	1039	memmove (cmdbuf_base, cmdbuf_ptr, n);
919	cmdbuf_ptr = cmdbuf_base;	1040	cmdbuf_ptr = cmdbuf_base;
920	cmdbuf_endp = cmdbuf_ptr + n;	1041	cmdbuf_endp = cmdbuf_ptr + n;
921		1042
922	n = read (cmd_fd, cmdbuf_endp, CBUFSIZ - n);	1043	n = read (pty.pty, cmdbuf_endp, CBUFSIZ - n);
923		1044
924	if (n > 0)	1045	if (n > 0)
925	{	1046	{
926	cmdbuf_endp += n;	1047	cmdbuf_endp += n;
927	return true;	1048	return true;
…		…
954	recolour_cursor ();	1075	recolour_cursor ();
955		1076
956	#ifdef POINTER_BLANK	1077	#ifdef POINTER_BLANK
957	hidden_pointer = 0;	1078	hidden_pointer = 0;
958		1079
959	if (Options & Opt_pointerBlank)	1080	if (options & Opt_pointerBlank)
960	pointer_ev.start (NOW + pointerBlankDelay);	1081	pointer_ev.start (NOW + pointerBlankDelay);
961	#endif	1082	#endif
962	}	1083	}
963		1084
964	#ifdef POINTER_BLANK	1085	#ifdef POINTER_BLANK
965	void	1086	void
966	rxvt_term::pointer_blank ()	1087	rxvt_term::pointer_blank ()
967	{	1088	{
968	if (! (Options & Opt_pointerBlank))	1089	if (! (options & Opt_pointerBlank))
969	return;	1090	return;
970		1091
971	XDefineCursor (display->display, TermWin.vt, blank_cursor);	1092	XDefineCursor (display->display, TermWin.vt, blank_cursor);
972	XFlush (display->display);	1093	XFlush (display->display);
973		1094
…		…
993	x = ev.x;	1114	x = ev.x;
994	y = ev.y;	1115	y = ev.y;
995	pixel_position (&x, &y);	1116	pixel_position (&x, &y);
996		1117
997	if (MEvent.button == AnyButton)	1118	if (MEvent.button == AnyButton)
998	{
999	button_number = 3;	1119	button_number = 3;
1000	}
1001	else	1120	else
1002	{	1121	{
1003	button_number = MEvent.button - Button1;	1122	button_number = MEvent.button - Button1;
1004	/* add 0x3D for wheel events, like xterm does */	1123	/* add 0x3D for wheel events, like xterm does */
1005	if (button_number >= 3)	1124	if (button_number >= 3)
1006	button_number += (64 - 3);	1125	button_number += (64 - 3);
1007	}	1126	}
1008		1127
1009	if (PrivateModes & PrivMode_MouseX10)	1128	if (priv_modes & PrivMode_MouseX10)
1010	{	1129	{
1011	/*	1130	/*
1012	* do not report ButtonRelease	1131	* do not report ButtonRelease
1013	* no state info allowed	1132	* no state info allowed
1014	*/	1133	*/
…		…
1029	+ ((MEvent.state & ModMetaMask) ? 8 : 0)	1148	+ ((MEvent.state & ModMetaMask) ? 8 : 0)
1030	+ ((MEvent.state & ControlMask) ? 16 : 0);	1149	+ ((MEvent.state & ControlMask) ? 16 : 0);
1031	#ifdef MOUSE_REPORT_DOUBLECLICK	1150	#ifdef MOUSE_REPORT_DOUBLECLICK
1032	key_state += ((MEvent.clicks > 1) ? 32 : 0);	1151	key_state += ((MEvent.clicks > 1) ? 32 : 0);
1033	#endif	1152	#endif
1034
1035	}	1153	}
1036		1154
1037	#ifdef DEBUG_MOUSEREPORT	1155	#if DEBUG_MOUSEREPORT
1038	fprintf (stderr, "Mouse [");	1156	fprintf (stderr, "Mouse [");
1039	if (key_state & 16)	1157	if (key_state & 16)
1040	fputc ('C', stderr);	1158	fputc ('C', stderr);
1041	if (key_state & 4)	1159	if (key_state & 4)
1042	fputc ('S', stderr);	1160	fputc ('S', stderr);
…		…
1046	fputc ('2', stderr);	1164	fputc ('2', stderr);
1047	fprintf (stderr, "]: <%d>, %d/%d\n",	1165	fprintf (stderr, "]: <%d>, %d/%d\n",
1048	button_number,	1166	button_number,
1049	x + 1,	1167	x + 1,
1050	y + 1);	1168	y + 1);
1051	#else	1169	#endif
		1170
1052	tt_printf ("\033[M%c%c%c",	1171	tt_printf ("\033[M%c%c%c",
1053	(32 + button_number + key_state),	1172	(32 + button_number + key_state),
1054	(32 + x + 1),	1173	(32 + x + 1),
1055	(32 + y + 1));	1174	(32 + y + 1));
1056	#endif
1057	}	1175	}
1058		1176
1059	#ifdef USING_W11LIB	1177	#ifdef USING_W11LIB
1060	void	1178	void
1061	rxvt_W11_process_x_event (XEvent *ev)	1179	rxvt_W11_process_x_event (XEvent *ev)
…		…
1072	{	1190	{
1073	SET_R (this);	1191	SET_R (this);
1074	SET_LOCALE (locale);	1192	SET_LOCALE (locale);
1075		1193
1076	#if defined(CURSOR_BLINK)	1194	#if defined(CURSOR_BLINK)
1077	if ((Options & Opt_cursorBlink) && ev.type == KeyPress)	1195	if ((options & Opt_cursorBlink) && ev.type == KeyPress)
1078	{	1196	{
1079	if (hidden_cursor)	1197	if (hidden_cursor)
1080	{	1198	{
1081	hidden_cursor = 0;	1199	hidden_cursor = 0;
1082	want_refresh = 1;	1200	want_refresh = 1;
…		…
1085	cursor_blink_ev.start (NOW + BLINK_INTERVAL);	1203	cursor_blink_ev.start (NOW + BLINK_INTERVAL);
1086	}	1204	}
1087	#endif	1205	#endif
1088		1206
1089	#if defined(POINTER_BLANK)	1207	#if defined(POINTER_BLANK)
1090	if ((Options & Opt_pointerBlank) && pointerBlankDelay > 0)	1208	if ((options & Opt_pointerBlank) && pointerBlankDelay > 0)
1091	{	1209	{
1092	if (ev.type == MotionNotify	1210	if (ev.type == MotionNotify
1093	|| ev.type == ButtonPress	1211	|| ev.type == ButtonPress
1094	|| ev.type == ButtonRelease)	1212	|| ev.type == ButtonRelease)
1095	if (hidden_pointer)	1213	if (hidden_pointer)
…		…
1098	if (ev.type == KeyPress && hidden_pointer == 0)	1216	if (ev.type == KeyPress && hidden_pointer == 0)
1099	pointer_blank ();	1217	pointer_blank ();
1100	}	1218	}
1101	#endif	1219	#endif
1102		1220
1103	#ifdef USE_XIM
1104	if (XFilterEvent (&ev, None))
1105	return;
1106	#endif
1107
1108	Window unused_root, unused_child;	1221	Window unused_root, unused_child;
1109	int unused_root_x, unused_root_y;	1222	int unused_root_x, unused_root_y;
1110	unsigned int unused_mask;	1223	unsigned int unused_mask;
1111		1224
1112	#ifdef DEBUG_X
1113	const char *const eventnames[] =
1114	{ /* mason - this matches my system */
1115	"",
1116	"",
1117	"KeyPress",
1118	"KeyRelease",
1119	"ButtonPress",
1120	"ButtonRelease",
1121	"MotionNotify",
1122	"EnterNotify",
1123	"LeaveNotify",
1124	"FocusIn",
1125	"FocusOut",
1126	"KeymapNotify",
1127	"Expose",
1128	"GraphicsExpose",
1129	"NoExpose",
1130	"VisibilityNotify",
1131	"CreateNotify",
1132	"DestroyNotify",
1133	"UnmapNotify",
1134	"MapNotify",
1135	"MapRequest",
1136	"ReparentNotify",
1137	"ConfigureNotify",
1138	"ConfigureRequest",
1139	"GravityNotify",
1140	"ResizeRequest",
1141	"CirculateNotify",
1142	"CirculateRequest",
1143	"PropertyNotify",
1144	"SelectionClear",
1145	"SelectionRequest",
1146	"SelectionNotify",
1147	"ColormapNotify",
1148	"ClientMessage",
1149	"MappingNotify"
1150	};
1151	#endif
1152
1153	#ifdef DEBUG_X
1154	struct timeval tp;
1155	struct tm *ltt;
1156	(void)gettimeofday (&tp, NULL);
1157	ltt = localtime (& (tp.tv_sec));
1158	D_X ((stderr, "Event: %-16s %-7s %08lx (%4d-%02d-%02d %02d:%02d:%02d.%.6ld) %s %lu", eventnames[ev.type], (ev.xany.window == TermWin.parent[0] ? "parent" : (ev.xany.window == TermWin.vt ? "vt" : (ev.xany.window == scrollBar.win ? "scroll" : (ev.xany.window == menuBar.win ? "menubar" : "UNKNOWN")))), (ev.xany.window == TermWin.parent[0] ? TermWin.parent[0] : (ev.xany.window == TermWin.vt ? TermWin.vt : (ev.xany.window == scrollBar.win ? scrollBar.win : (ev.xany.window == menuBar.win ? menuBar.win : 0)))), ltt->tm_year + 1900, ltt->tm_mon + 1, ltt->tm_mday, ltt->tm_hour, ltt->tm_min, ltt->tm_sec, tp.tv_usec, ev.xany.send_event ? "S" : " ", ev.xany.serial));
1159	#endif
1160
1161	switch (ev.type)	1225	switch (ev.type)
1162	{	1226	{
1163	case KeyPress:	1227	case KeyPress:
		1228	#if ISO_14755
1164	if (!(iso14755buf & ISO_14755_ESCAPE_NEXT))	1229	if (!(iso14755buf & ISO_14755_52))
		1230	#endif
1165	lookup_key (ev.xkey);	1231	lookup_key (ev.xkey);
1166		1232
1167	break;	1233	break;
1168		1234
1169	case KeyRelease:	1235	case KeyRelease:
1170	{	1236	{
1171	#if (defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)) || !defined (NO_FRILLS)	1237	#if (MOUSE_WHEEL && MOUSE_SLIP_WHEELING) || ISO_14755
1172	KeySym ks;	1238	KeySym ks;
1173		1239
1174	ks = XLookupKeysym (&ev.xkey, ev.xkey.state & ShiftMask ? 1 : 0); // sorry, only shift supported :/	1240	ks = XLookupKeysym (&ev.xkey, ev.xkey.state & ShiftMask ? 1 : 0); // sorry, only shift supported :/
1175	#endif	1241	#endif
1176		1242
1177	#ifndef NO_FRILLS	1243	#if ENABLE_FRILLS || ISO_14755
1178	// ISO 14755 support	1244	// ISO 14755 support
1179	if (iso14755buf)	1245	if (iso14755buf)
1180	if (iso14755buf & ISO_14755_ESCAPE_NEXT)	1246	if (iso14755buf & ISO_14755_52)
1181	{	1247	{
		1248	# if ENABLE_OVERLAY
		1249	scr_overlay_off ();
		1250	# endif
		1251	# if ISO_14755
1182	// iso14755 part 5.2 handling: release time	1252	// iso14755 part 5.2 handling: release time
1183	// first: controls	1253	// first: controls
1184	if ((ev.xkey.state & ControlMask)	1254	if ((ev.xkey.state & ControlMask)
1185	&& ((ks >= 0x40 && ks <= 0x5f)	1255	&& ((ks >= 0x40 && ks <= 0x5f)
1186	|| (ks >= 0x61 && ks <= 0x7f)))	1256	|| (ks >= 0x61 && ks <= 0x7f)))
1187	{	1257	{
1188	iso14755buf = ISO_14755_KEYCODE_VALID | 0x2400 | (ks & 0x1f);	1258	iso14755buf = ISO_14755_51 | 0x2400 | (ks & 0x1f);
1189	commit_iso14755 ();	1259	commit_iso14755 ();
1190	return; // case-break;	1260	return; // case-break;
1191	}	1261	}
1192		1262
1193	for (unsigned short *i = iso14755_symtab; i[0]; i+= 2)	1263	for (unsigned short *i = iso14755_symtab; i[0]; i+= 2)
1194	if (i[0] == ks)	1264	if (i[0] == ks)
1195	{	1265	{
1196	iso14755buf = ISO_14755_KEYCODE_VALID | i[1];	1266	iso14755buf = ISO_14755_51 | i[1];
1197	commit_iso14755 ();	1267	commit_iso14755 ();
1198	return; // case-break;	1268	return; // case-break;
1199	}	1269	}
1200		1270
		1271	scr_bell ();
		1272	# endif
1201	iso14755buf = 0;	1273	iso14755buf = 0;
1202	scr_bell ();
1203	break;	1274	break;
1204	}	1275	}
1205	else if ((ev.xkey.state & (ShiftMask | ControlMask)) != (ShiftMask | ControlMask))	1276	else if ((ev.xkey.state & (ShiftMask | ControlMask)) != (ShiftMask | ControlMask))
1206	{	1277	{
		1278	# if ENABLE_OVERLAY
		1279	scr_overlay_off ();
		1280	# endif
1207	if (iso14755buf & ISO_14755_KEYCODE_VALID)	1281	if (iso14755buf & ISO_14755_51)
1208	commit_iso14755 ();	1282	commit_iso14755 ();
		1283	#if ISO_14755
1209	else if (iso14755buf & ISO_14755_ACTIVE)	1284	else if (iso14755buf & ISO_14755_STARTED)
		1285	{
1210	iso14755buf = ISO_14755_ESCAPE_NEXT; // iso14755 part 5.2: remember empty begin/end pair	1286	iso14755buf = ISO_14755_52; // iso14755 part 5.2: remember empty begin/end pair
		1287
		1288	scr_overlay_new (0, -1, sizeof ("KEYCAP PICTURE INSERT MODE") - 1, 1);
		1289	scr_overlay_set (0, 0, "KEYCAP PICTURE INSERT MODE");
		1290	}
		1291	# endif
		1292	else
		1293	iso14755buf = 0;
1211	}	1294	}
1212	#endif	1295	#endif
1213		1296
1214	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)	1297	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
1215	if (!(ev.xkey.state & ControlMask))	1298	if (!(ev.xkey.state & ControlMask))
…		…
1253	&Size, &RemainingBytes,	1336	&Size, &RemainingBytes,
1254	&data);	1337	&data);
1255	XChangeProperty (display->display, display->root,	1338	XChangeProperty (display->display, display->root,
1256	XA_CUT_BUFFER0, XA_STRING,	1339	XA_CUT_BUFFER0, XA_STRING,
1257	8, PropModeReplace,	1340	8, PropModeReplace,
1258	data, STRLEN (data));	1341	data, strlen (data));
1259	XFree (data);	1342	XFree (data);
1260	selection_paste (display->root, XA_CUT_BUFFER0, True);	1343	selection_paste (display->root, XA_CUT_BUFFER0, True);
1261	XSetInputFocus (display->display, display->root, RevertToNone, CurrentTime);	1344	XSetInputFocus (display->display, display->root, RevertToNone, CurrentTime);
1262	}	1345	}
1263	#endif /* OFFIX_DND */	1346	#endif /* OFFIX_DND */
…		…
1297	{	1380	{
1298	TermWin.focus = 1;	1381	TermWin.focus = 1;
1299	want_refresh = 1;	1382	want_refresh = 1;
1300	#ifdef USE_XIM	1383	#ifdef USE_XIM
1301	if (Input_Context != NULL)	1384	if (Input_Context != NULL)
		1385	{
		1386	IMSetStatusPosition ();
1302	XSetICFocus (Input_Context);	1387	XSetICFocus (Input_Context);
		1388	}
1303	#endif	1389	#endif
1304	#ifdef CURSOR_BLINK	1390	#ifdef CURSOR_BLINK
1305	if (Options & Opt_cursorBlink)	1391	if (options & Opt_cursorBlink)
1306	cursor_blink_ev.start (NOW + BLINK_INTERVAL);	1392	cursor_blink_ev.start (NOW + BLINK_INTERVAL);
1307	#endif	1393	#endif
1308	#ifdef OFF_FOCUS_FADING	1394	#ifdef OFF_FOCUS_FADING
1309	if (rs[Rs_fade])	1395	if (rs[Rs_fade])
1310	{	1396	{
1311	PixColors = PixColorsFocused;	1397	pix_colors = pix_colors_focused;
1312	set_colorfgbg ();
1313	scr_clear ();	1398	scr_recolour ();
1314	scr_touch (true);
1315	}	1399	}
1316	#endif	1400	#endif
1317		1401
1318	}	1402	}
1319	break;	1403	break;
…		…
1321	case FocusOut:	1405	case FocusOut:
1322	if (TermWin.focus)	1406	if (TermWin.focus)
1323	{	1407	{
1324	TermWin.focus = 0;	1408	TermWin.focus = 0;
1325	want_refresh = 1;	1409	want_refresh = 1;
		1410
		1411	#if ENABLE_FRILLS || ISO_14755
		1412	iso14755buf = 0;
		1413	#endif
		1414	#if ENABLE_OVERLAY
		1415	scr_overlay_off ();
		1416	#endif
1326	#ifdef USE_XIM	1417	#ifdef USE_XIM
1327	if (Input_Context != NULL)	1418	if (Input_Context != NULL)
1328	XUnsetICFocus (Input_Context);	1419	XUnsetICFocus (Input_Context);
1329	#endif	1420	#endif
1330	#ifdef CURSOR_BLINK	1421	#ifdef CURSOR_BLINK
1331	if (Options & Opt_cursorBlink)	1422	if (options & Opt_cursorBlink)
1332	cursor_blink_ev.stop ();	1423	cursor_blink_ev.stop ();
1333	hidden_cursor = 0;	1424	hidden_cursor = 0;
1334	#endif	1425	#endif
1335	#ifdef OFF_FOCUS_FADING	1426	#ifdef OFF_FOCUS_FADING
1336	if (rs[Rs_fade])	1427	if (rs[Rs_fade])
1337	{	1428	{
1338	PixColors = PixColorsUnFocused;	1429	pix_colors = pix_colors_unfocused;
1339	set_colorfgbg ();
1340	scr_clear ();	1430	scr_recolour ();
1341	scr_touch (true);
1342	}	1431	}
1343	#endif	1432	#endif
1344
1345	}	1433	}
1346	break;	1434	break;
1347		1435
1348	case ConfigureNotify:	1436	case ConfigureNotify:
1349	if (ev.xconfigure.window == TermWin.parent[0])	1437	if (ev.xconfigure.window == TermWin.parent[0])
…		…
1357	D_SIZE ((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));	1445	D_SIZE ((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));
1358	}	1446	}
1359	while (XCheckTypedWindowEvent (display->display, ev.xconfigure.window, ConfigureNotify, &ev));	1447	while (XCheckTypedWindowEvent (display->display, ev.xconfigure.window, ConfigureNotify, &ev));
1360		1448
1361	if (szHint.width != width || szHint.height != height)	1449	if (szHint.width != width || szHint.height != height)
		1450	{
		1451	seen_resize = 1;
1362	resize_all_windows (width, height, 1);	1452	resize_all_windows (width, height, 1);
		1453	}
1363		1454
1364	#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */	1455	#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */
1365	if (Options & Opt_transparent)	1456	if (options & Opt_transparent)
1366	{	1457	{
1367	check_our_parents ();	1458	check_our_parents ();
1368	if (am_transparent)	1459	if (am_transparent)
1369	want_refresh = want_full_refresh = 1;	1460	want_refresh = want_full_refresh = 1;
1370	}	1461	}
…		…
1466	{	1557	{
1467	menubar_control (ev.xbutton);	1558	menubar_control (ev.xbutton);
1468	break;	1559	break;
1469	}	1560	}
1470	#endif	1561	#endif
1471	if ((PrivateModes & PrivMode_mouse_report) && ! (bypass_keystate))	1562	if ((priv_modes & PrivMode_mouse_report) && !bypass_keystate)
1472	break;	1563	break;
1473		1564
1474	if (ev.xany.window == TermWin.vt)	1565	if (ev.xany.window == TermWin.vt)
1475	{	1566	{
1476	if ((ev.xbutton.state & (Button1Mask | Button3Mask)))	1567	if (ev.xbutton.state & (Button1Mask | Button3Mask))
1477	{	1568	{
1478	while (XCheckTypedWindowEvent (display->display, TermWin.vt, MotionNotify, &ev))	1569	while (XCheckTypedWindowEvent (display->display, TermWin.vt, MotionNotify, &ev))
1479	;	1570	;
1480		1571
1481	XQueryPointer (display->display, TermWin.vt,	1572	XQueryPointer (display->display, TermWin.vt,
1482	&unused_root, &unused_child,	1573	&unused_root, &unused_child,
1483	&unused_root_x, &unused_root_y,	1574	&unused_root_x, &unused_root_y,
1484	& (ev.xbutton.x), & (ev.xbutton.y),	1575	&ev.xbutton.x, &ev.xbutton.y,
1485	&unused_mask);	1576	&ev.xbutton.state);
1486	#ifdef MOUSE_THRESHOLD	1577	#ifdef MOUSE_THRESHOLD
1487	/* deal with a `jumpy' mouse */	1578	/* deal with a `jumpy' mouse */
1488	if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)	1579	if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)
1489	{	1580	{
1490	#endif	1581	#endif
		1582	#if ISO_14755
		1583	// 5.4
		1584	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
		1585	{
		1586	iso14755_54 (ev.xbutton.x, ev.xbutton.y);
		1587	break;
		1588	}
		1589	#endif
1491	selection_extend ((ev.xbutton.x), (ev.xbutton.y),	1590	selection_extend (ev.xbutton.x, ev.xbutton.y,
1492	(ev.xbutton.state & Button3Mask) ? 2 : 0);	1591	ev.xbutton.state & Button3Mask ? 2 : 0);
		1592
1493	#ifdef SELECTION_SCROLLING	1593	#ifdef SELECTION_SCROLLING
1494	if (ev.xbutton.y < TermWin.int_bwidth	1594	if (ev.xbutton.y < TermWin.int_bwidth
1495	|| Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))	1595	|| Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))
1496	{	1596	{
1497	int dist;	1597	int dist;
…		…
1503	sel_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);	1603	sel_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);
1504		1604
1505	/* save the event params so we can highlight	1605	/* save the event params so we can highlight
1506	* the selection in the pending-scroll loop	1606	* the selection in the pending-scroll loop
1507	*/	1607	*/
1508	selection_save_x=ev.xbutton.x;	1608	selection_save_x = ev.xbutton.x;
1509	selection_save_y=ev.xbutton.y;	1609	selection_save_y = ev.xbutton.y;
1510	selection_save_state=
1511	(ev.xbutton.state & Button3Mask) ? 2 : 0;	1610	selection_save_state = (ev.xbutton.state & Button3Mask) ? 2 : 0;
1512		1611
1513	/* calc number of lines to scroll */	1612	/* calc number of lines to scroll */
1514	if (ev.xbutton.y<TermWin.int_bwidth)	1613	if (ev.xbutton.y < TermWin.int_bwidth)
1515	{	1614	{
1516	scroll_selection_dir = UP;	1615	scroll_selection_dir = UP;
1517	dist = TermWin.int_bwidth - ev.xbutton.y;	1616	dist = TermWin.int_bwidth - ev.xbutton.y;
1518	}	1617	}
1519	else	1618	else
1520	{	1619	{
1521	scroll_selection_dir = DN;	1620	scroll_selection_dir = DN;
1522	dist = ev.xbutton.y -
1523	(TermWin.int_bwidth + TermWin.height);	1621	dist = ev.xbutton.y - (TermWin.int_bwidth + TermWin.height);
1524	}	1622	}
		1623
1525	scroll_selection_lines= (Pixel2Height (dist)/	1624	scroll_selection_lines = Pixel2Height (dist)
1526	SELECTION_SCROLL_LINE_SPEEDUP)+1;	1625	/ SELECTION_SCROLL_LINE_SPEEDUP
		1626	+ 1;
1527	MIN_IT (scroll_selection_lines,	1627	MIN_IT (scroll_selection_lines,
1528	SELECTION_SCROLL_MAX_LINES);	1628	SELECTION_SCROLL_MAX_LINES);
1529	}	1629	}
1530	else	1630	else
1531	{	1631	{
1532	/* we are within the text window, so we	1632	/* we are within the text window, so we
1533	* shouldn't be scrolling	1633	* shouldn't be scrolling
…		…
1535	if (sel_scroll_ev.active)	1635	if (sel_scroll_ev.active)
1536	sel_scroll_ev.stop();	1636	sel_scroll_ev.stop();
1537	}	1637	}
1538	#endif	1638	#endif
1539	#ifdef MOUSE_THRESHOLD	1639	#ifdef MOUSE_THRESHOLD
1540
1541	}	1640	}
1542	#endif	1641	#endif
1543
1544	}	1642	}
1545	}	1643	}
1546	else if (isScrollbarWindow (ev.xany.window) && scrollbar_isMotion ())	1644	else if (isScrollbarWindow (ev.xany.window) && scrollbar_isMotion ())
1547	{	1645	{
1548	while (XCheckTypedWindowEvent (display->display, scrollBar.win,	1646	while (XCheckTypedWindowEvent (display->display, scrollBar.win,
1549	MotionNotify, &ev)) ;	1647	MotionNotify, &ev))
		1648	;
		1649
1550	XQueryPointer (display->display, scrollBar.win,	1650	XQueryPointer (display->display, scrollBar.win,
1551	&unused_root, &unused_child,	1651	&unused_root, &unused_child,
1552	&unused_root_x, &unused_root_y,	1652	&unused_root_x, &unused_root_y,
1553	& (ev.xbutton.x), & (ev.xbutton.y),	1653	&ev.xbutton.x, &ev.xbutton.y,
1554	&unused_mask);	1654	&unused_mask);
1555	scr_move_to (scrollbar_position (ev.xbutton.y) - csrO,	1655	scr_move_to (scrollbar_position (ev.xbutton.y) - csrO,
1556	scrollbar_size ());	1656	scrollbar_size ());
1557	scr_refresh (refresh_type);	1657	scr_refresh (refresh_type);
1558	refresh_limit = 0;	1658	refresh_limit = 0;
…		…
1582	if (ev.xproperty.atom != xa[XA_XROOTPMAPID])	1682	if (ev.xproperty.atom != xa[XA_XROOTPMAPID])
1583	return;	1683	return;
1584		1684
1585	/* FALLTHROUGH */	1685	/* FALLTHROUGH */
1586	case ReparentNotify:	1686	case ReparentNotify:
1587	if ((Options & Opt_transparent) && check_our_parents () && am_transparent)	1687	if ((options & Opt_transparent) && check_our_parents () && am_transparent)
1588	want_refresh = want_full_refresh = 1;	1688	want_refresh = want_full_refresh = 1;
1589	break;	1689	break;
1590	}	1690	}
1591	}	1691	}
1592	#endif	1692	#endif
…		…
1596	{	1696	{
1597	int reportmode = 0, clickintime;	1697	int reportmode = 0, clickintime;
1598		1698
1599	bypass_keystate = ev.state & (ModMetaMask | ShiftMask);	1699	bypass_keystate = ev.state & (ModMetaMask | ShiftMask);
1600	if (!bypass_keystate)	1700	if (!bypass_keystate)
1601	reportmode = !! (PrivateModes & PrivMode_mouse_report);	1701	reportmode = !! (priv_modes & PrivMode_mouse_report);
		1702
1602	/*	1703	/*
1603	* VT window processing of button press	1704	* VT window processing of button press
1604	*/	1705	*/
1605	if (ev.window == TermWin.vt)	1706	if (ev.window == TermWin.vt)
1606	{	1707	{
		1708	#if ISO_14755
		1709	// 5.4
		1710	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
		1711	{
		1712	iso14755_54 (ev.x, ev.y);
		1713	return;
		1714	}
		1715	#endif
		1716
1607	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;	1717	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;
		1718
1608	if (reportmode)	1719	if (reportmode)
1609	{	1720	{
1610	/* mouse report from vt window */	1721	/* mouse report from vt window */
1611	/* save the xbutton state (for ButtonRelease) */	1722	/* save the xbutton state (for ButtonRelease) */
1612	MEvent.state = ev.state;	1723	MEvent.state = ev.state;
…		…
1641	}	1752	}
1642	else	1753	else
1643	{	1754	{
1644	if (ev.button != MEvent.button)	1755	if (ev.button != MEvent.button)
1645	MEvent.clicks = 0;	1756	MEvent.clicks = 0;
		1757
1646	switch (ev.button)	1758	switch (ev.button)
1647	{	1759	{
1648	case Button1:	1760	case Button1:
		1761	/* allow meta + click to select rectangular areas */
		1762	/* should be done in screen.C */
		1763	#if ENABLE_FRILLS
		1764	selection.rect = !! (ev.state & ModMetaMask);
		1765	#else
		1766	selection.rect = false;
		1767	#endif
		1768
1649	/* allow shift+left click to extend selection */	1769	/* allow shift+left click to extend selection */
1650	if (ev.state & ShiftMask && ! (PrivateModes & PrivMode_mouse_report))	1770	if (ev.state & ShiftMask && ! (priv_modes & PrivMode_mouse_report))
1651	{	1771	{
1652	if (MEvent.button == Button1 && clickintime)	1772	if (MEvent.button == Button1 && clickintime)
1653	selection_rotate (ev.x, ev.y);	1773	selection_rotate (ev.x, ev.y);
1654	else	1774	else
1655	selection_extend (ev.x, ev.y, 1);	1775	selection_extend (ev.x, ev.y, 1);
…		…
1670	case Button3:	1790	case Button3:
1671	if (MEvent.button == Button3 && clickintime)	1791	if (MEvent.button == Button3 && clickintime)
1672	selection_rotate (ev.x, ev.y);	1792	selection_rotate (ev.x, ev.y);
1673	else	1793	else
1674	selection_extend (ev.x, ev.y, 1);	1794	selection_extend (ev.x, ev.y, 1);
		1795
1675	MEvent.button = Button3;	1796	MEvent.button = Button3;
1676	break;	1797	break;
1677	}	1798	}
1678	}	1799	}
		1800
1679	MEvent.time = ev.time;	1801	MEvent.time = ev.time;
1680	return;	1802	return;
1681	}	1803	}
1682		1804
1683	/*	1805	/*
…		…
1836	{	1958	{
1837	int reportmode = 0;	1959	int reportmode = 0;
1838		1960
1839	csrO = 0; /* reset csr Offset */	1961	csrO = 0; /* reset csr Offset */
1840	if (!bypass_keystate)	1962	if (!bypass_keystate)
1841	reportmode = !! (PrivateModes & PrivMode_mouse_report);	1963	reportmode = !! (priv_modes & PrivMode_mouse_report);
1842		1964
1843	if (scrollbar_isUpDn ())	1965	if (scrollbar_isUpDn ())
1844	{	1966	{
1845	scrollBar.setIdle ();	1967	scrollBar.setIdle ();
1846	scrollbar_show (0);	1968	scrollbar_show (0);
1847	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING	1969	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1848	refresh_type &= ~SMOOTH_REFRESH;	1970	refresh_type &= ~SMOOTH_REFRESH;
1849	#endif	1971	#endif
1850
1851	}	1972	}
		1973
1852	#ifdef SELECTION_SCROLLING	1974	#ifdef SELECTION_SCROLLING
1853	if (sel_scroll_ev.active)	1975	if (sel_scroll_ev.active)
1854	sel_scroll_ev.stop();	1976	sel_scroll_ev.stop();
1855	#endif	1977	#endif
		1978
1856	if (ev.window == TermWin.vt)	1979	if (ev.window == TermWin.vt)
1857	{	1980	{
		1981	#if ISO_14755
		1982	// 5.4
		1983	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
		1984	return;
		1985	#endif
1858	if (reportmode)	1986	if (reportmode)
1859	{	1987	{
1860	/* mouse report from vt window */	1988	/* mouse report from vt window */
1861	/* don't report release of wheel "buttons" */	1989	/* don't report release of wheel "buttons" */
1862	if (ev.button >= 4)	1990	if (ev.button >= 4)
…		…
1876	MEvent.button = AnyButton;	2004	MEvent.button = AnyButton;
1877	mouse_report (ev);	2005	mouse_report (ev);
1878	#endif /* MOUSE_REPORT_DOUBLECLICK */	2006	#endif /* MOUSE_REPORT_DOUBLECLICK */
1879	return;	2007	return;
1880	}	2008	}
		2009
1881	/*	2010	/*
1882	* dumb hack to compensate for the failure of click-and-drag	2011	* dumb hack to compensate for the failure of click-and-drag
1883	* when overriding mouse reporting	2012	* when overriding mouse reporting
1884	*/	2013	*/
1885	if (PrivateModes & PrivMode_mouse_report	2014	if (priv_modes & PrivMode_mouse_report
1886	&& bypass_keystate	2015	&& bypass_keystate
1887	&& ev.button == Button1 && MEvent.clicks <= 1)	2016	&& ev.button == Button1 && MEvent.clicks <= 1)
1888	selection_extend (ev.x, ev.y, 0);	2017	selection_extend (ev.x, ev.y, 0);
1889		2018
1890	switch (ev.button)	2019	switch (ev.button)
…		…
1905		2034
1906	v = ev.button == Button4 ? UP : DN;	2035	v = ev.button == Button4 ? UP : DN;
1907		2036
1908	if (ev.state & ShiftMask)	2037	if (ev.state & ShiftMask)
1909	i = 1;	2038	i = 1;
1910	else if (Options & Opt_mouseWheelScrollPage)	2039	else if (options & Opt_mouseWheelScrollPage)
1911	i = TermWin.nrow - 1;	2040	i = TermWin.nrow - 1;
1912	else	2041	else
1913	i = 5;	2042	i = 5;
1914		2043
1915	# ifdef MOUSE_SLIP_WHEELING	2044	# ifdef MOUSE_SLIP_WHEELING
…		…
2200	Pixmap rootpixmap = None;	2329	Pixmap rootpixmap = None;
2201	XWindowAttributes wattr, wrootattr;	2330	XWindowAttributes wattr, wrootattr;
2202		2331
2203	pchanged = 0;	2332	pchanged = 0;
2204		2333
2205	if (!(Options & Opt_transparent))	2334	if (!(options & Opt_transparent))
2206	return pchanged; /* Don't try any more */	2335	return pchanged; /* Don't try any more */
2207		2336
2208	XGetWindowAttributes (display->display, display->root, &wrootattr);	2337	XGetWindowAttributes (display->display, display->root, &wrootattr);
2209	rootdepth = wrootattr.depth;	2338	rootdepth = wrootattr.depth;
2210		2339
…		…
2213	if (rootdepth != wattr.depth)	2342	if (rootdepth != wattr.depth)
2214	{	2343	{
2215	if (am_transparent)	2344	if (am_transparent)
2216	{	2345	{
2217	pchanged = 1;	2346	pchanged = 1;
2218	XSetWindowBackground (display->display, TermWin.vt, PixColorsFocused[Color_bg]);	2347	XSetWindowBackground (display->display, TermWin.vt, pix_colors_focused[Color_bg]);
2219	am_transparent = am_pixmap_trans = 0;	2348	am_transparent = am_pixmap_trans = 0;
2220	}	2349	}
2221		2350
2222	return pchanged; /* Don't try any more */	2351	return pchanged; /* Don't try any more */
2223	}	2352	}
…		…
2318	if (ISSET_PIXCOLOR (Color_tint))	2447	if (ISSET_PIXCOLOR (Color_tint))
2319	{	2448	{
2320	unsigned short rm, gm, bm;	2449	unsigned short rm, gm, bm;
2321	int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;	2450	int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;
2322		2451
2323	PixColorsFocused[Color_tint].get (display, rm, gm, bm);	2452	pix_colors_focused[Color_tint].get (display, rm, gm, bm);
2324		2453
2325	ShadeXImage (display, image, shade, rm, gm, bm);	2454	ShadeXImage (display, image, shade, rm, gm, bm);
2326	}	2455	}
2327	#endif	2456	#endif
2328		2457
…		…
2347	{	2476	{
2348	unsigned int n;	2477	unsigned int n;
2349	/*	2478	/*
2350	* InheritPixmap transparency	2479	* InheritPixmap transparency
2351	*/	2480	*/
2352	D_X ((stderr, "InheritPixmap Seeking to %08lx", display->root));
2353	for (i = 1; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)	2481	for (i = 1; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
2354	{	2482	{
2355	oldp = TermWin.parent[i];	2483	oldp = TermWin.parent[i];
2356	XQueryTree (display->display, TermWin.parent[i - 1], &root,	2484	XQueryTree (display->display, TermWin.parent[i - 1], &root,
2357	&TermWin.parent[i], &list, &n);	2485	&TermWin.parent[i], &list, &n);
2358	XFree (list);	2486	XFree (list);
2359	D_X ((stderr, "InheritPixmap Parent[%d] = %08lx", i, TermWin.parent[i]));
2360		2487
2361	if (TermWin.parent[i] == display->root)	2488	if (TermWin.parent[i] == display->root)
2362	{	2489	{
2363	if (oldp != None)	2490	if (oldp != None)
2364	pchanged = 1;	2491	pchanged = 1;
…		…
2375	if (pchanged)	2502	if (pchanged)
2376	{	2503	{
2377	for (; n < (unsigned int)i; n++)	2504	for (; n < (unsigned int)i; n++)
2378	{	2505	{
2379	XGetWindowAttributes (display->display, TermWin.parent[n], &wattr);	2506	XGetWindowAttributes (display->display, TermWin.parent[n], &wattr);
2380	D_X ((stderr, "InheritPixmap Checking Parent[%d]: %s", n, (wattr.depth == rootdepth && wattr.class != InputOnly) ? "OK" : "FAIL"));
2381	if (wattr.depth != rootdepth || wattr.c_class == InputOnly)	2507	if (wattr.depth != rootdepth || wattr.c_class == InputOnly)
2382	{	2508	{
2383	n = (int) (sizeof (TermWin.parent) / sizeof (Window)) + 1;	2509	n = (int) (sizeof (TermWin.parent) / sizeof (Window)) + 1;
2384	break;	2510	break;
2385	}	2511	}
2386	}	2512	}
2387	}	2513	}
2388		2514
2389	if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0])))	2515	if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0])))
2390	{	2516	{
2391	D_X ((stderr, "InheritPixmap Turning off"));
2392	XSetWindowBackground (display->display, TermWin.parent[0], PixColorsFocused[Color_fg]);	2517	XSetWindowBackground (display->display, TermWin.parent[0], pix_colors_focused[Color_fg]);
2393	XSetWindowBackground (display->display, TermWin.vt, PixColorsFocused[Color_bg]);	2518	XSetWindowBackground (display->display, TermWin.vt, pix_colors_focused[Color_bg]);
2394	am_transparent = 0;	2519	am_transparent = 0;
2395	/* XXX: also turn off Opt_transparent? */	2520	/* XXX: also turn off Opt_transparent? */
2396	}	2521	}
2397	else	2522	else
2398	{	2523	{
2399	#if WAIT_FOR_WM	2524	#if WAIT_FOR_WM
2400	/* wait (an arbitrary period) for the WM to do its thing	2525	/* wait (an arbitrary period) for the WM to do its thing
2401	* needed for fvwm2.2.2 (and before?) */	2526	* needed for fvwm2.2.2 (and before?) */
2402	sleep (1);	2527	sleep (1);
2403	#endif	2528	#endif
2404	D_X ((stderr, "InheritPixmap Turning on (%d parents)", i - 1));
2405	for (n = 0; n < (unsigned int)i; n++)	2529	for (n = 0; n < (unsigned int)i; n++)
2406	{	2530	{
2407	XSetWindowBackgroundPixmap (display->display, TermWin.parent[n], ParentRelative);	2531	XSetWindowBackgroundPixmap (display->display, TermWin.parent[n], ParentRelative);
2408	XClearWindow (display->display, TermWin.parent[n]);	2532	XClearWindow (display->display, TermWin.parent[n]);
2409	}	2533	}
…		…
2414		2538
2415	for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)	2539	for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
2416	TermWin.parent[i] = None;	2540	TermWin.parent[i] = None;
2417	}	2541	}
2418		2542
2419	// this is experimental
2420	if (scrollBar.win)	2543	if (scrollBar.win)
2421	{	2544	{
2422	XSetWindowBackgroundPixmap (display->display, scrollBar.win, ParentRelative);	2545	XSetWindowBackgroundPixmap (display->display, scrollBar.win, ParentRelative);
2423	XClearWindow (display->display, scrollBar.win);
2424	scrollBar.setIdle ();	2546	scrollBar.setIdle ();
2425	scrollbar_show (0);	2547	scrollbar_show (0);
2426	}	2548	}
2427		2549
2428	return pchanged;	2550	return pchanged;
…		…
2449	if (ch == NOCHAR) // TODO: improve	2571	if (ch == NOCHAR) // TODO: improve
2450	break;	2572	break;
2451		2573
2452	if (!IS_CONTROL (ch) || ch == C0_LF || ch == C0_CR || ch == C0_HT)	2574	if (!IS_CONTROL (ch) || ch == C0_LF || ch == C0_CR || ch == C0_HT)
2453	{	2575	{
		2576	if (!seen_input)
		2577	{
		2578	seen_input = 1;
		2579	// many badly-written programs (e.g. jed) contain a race condition:
		2580	// they first read the screensize and then install a SIGWINCH handler.
		2581	// some window managers resize the window early, and these programs
		2582	// then sometimes get the size wrong.
		2583	// unfortunately other programs are even more buggy and dislike
		2584	// being sent SIGWINCH, so only do it when we were in fact being
		2585	// resized.
		2586	if (seen_resize)
		2587	kill (-cmd_pid, SIGWINCH);
		2588	}
		2589
2454	/* Read a text string from the input buffer */	2590	/* Read a text string from the input buffer */
2455	unicode_t buf[UBUFSIZ];	2591	unicode_t buf[UBUFSIZ];
2456	bool refreshnow = false;	2592	bool refreshnow = false;
2457	int nlines = 0;	2593	int nlines = 0;
2458	unicode_t *str = buf;	2594	unicode_t *str = buf;
…		…
2467	if (ch == C0_LF)	2603	if (ch == C0_LF)
2468	{	2604	{
2469	nlines++;	2605	nlines++;
2470	refresh_count++;	2606	refresh_count++;
2471		2607
2472	if (!(Options & Opt_jumpScroll)	2608	if (!(options & Opt_jumpScroll)
2473	|| (refresh_count >= refresh_limit * (TermWin.nrow - 1)))	2609	|| (refresh_count >= refresh_limit * (TermWin.nrow - 1)))
2474	{	2610	{
2475	refreshnow = true;	2611	refreshnow = true;
2476	ch = NOCHAR;	2612	ch = NOCHAR;
2477	break;	2613	break;
…		…
2504	* the number of pages between refreshes is refresh_limit, which	2640	* the number of pages between refreshes is refresh_limit, which
2505	* is incremented here because we must be doing flat-out scrolling.	2641	* is incremented here because we must be doing flat-out scrolling.
2506	*/	2642	*/
2507	if (refreshnow)	2643	if (refreshnow)
2508	{	2644	{
2509	if ((Options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)	2645	if ((options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)
2510	refresh_limit++;	2646	refresh_limit++;
2511	else	2647	else
2512	{	2648	{
2513	flag = true;	2649	flag = true;
2514	scr_refresh (refresh_type);	2650	scr_refresh (refresh_type);
…		…
2704	process_escape_seq ();	2840	process_escape_seq ();
2705	break;	2841	break;
2706	case C0_ENQ: /* terminal Status */	2842	case C0_ENQ: /* terminal Status */
2707	if (rs[Rs_answerbackstring])	2843	if (rs[Rs_answerbackstring])
2708	tt_write ((const unsigned char *)rs[Rs_answerbackstring],	2844	tt_write ((const unsigned char *)rs[Rs_answerbackstring],
2709	(unsigned int)STRLEN (rs[Rs_answerbackstring]));	2845	(unsigned int)strlen (rs[Rs_answerbackstring]));
2710	else	2846	else
2711	tt_write ((unsigned char *)VT100_ANS,	2847	tt_write ((unsigned char *)VT100_ANS,
2712	(unsigned int)STRLEN (VT100_ANS));	2848	(unsigned int)strlen (VT100_ANS));
2713	break;	2849	break;
2714	case C0_BEL: /* bell */	2850	case C0_BEL: /* bell */
2715	scr_bell ();	2851	scr_bell ();
2716	break;	2852	break;
2717	case C0_BS: /* backspace */	2853	case C0_BS: /* backspace */
…		…
2816	void	2952	void
2817	rxvt_term::process_escape_seq ()	2953	rxvt_term::process_escape_seq ()
2818	{	2954	{
2819	unicode_t ch = cmd_getc ();	2955	unicode_t ch = cmd_getc ();
2820		2956
2821	if (PrivateModes & PrivMode_vt52)	2957	if (priv_modes & PrivMode_vt52)
2822	{	2958	{
2823	process_escape_vt52 (ch);	2959	process_escape_vt52 (ch);
2824	return;	2960	return;
2825	}	2961	}
2826		2962
…		…
2841	scr_charset_set (2, (unsigned int)cmd_getc ());	2977	scr_charset_set (2, (unsigned int)cmd_getc ());
2842	break;	2978	break;
2843	case '+':	2979	case '+':
2844	scr_charset_set (3, (unsigned int)cmd_getc ());	2980	scr_charset_set (3, (unsigned int)cmd_getc ());
2845	break;	2981	break;
2846	#ifndef NO_FRILLS	2982	#if ENABLE_FRILLS
2847	case '6':	2983	case '6':
2848	scr_backindex ();	2984	scr_backindex ();
2849	break;	2985	break;
2850	#endif	2986	#endif
2851	case '7':	2987	case '7':
2852	scr_cursor (SAVE);	2988	scr_cursor (SAVE);
2853	break;	2989	break;
2854	case '8':	2990	case '8':
2855	scr_cursor (RESTORE);	2991	scr_cursor (RESTORE);
2856	break;	2992	break;
2857	#ifndef NO_FRILLS	2993	#if ENABLE_FRILLS
2858	case '9':	2994	case '9':
2859	scr_forwardindex ();	2995	scr_forwardindex ();
2860	break;	2996	break;
2861	#endif	2997	#endif
2862	case '=':	2998	case '=':
…		…
3161	scr_scroll_text (screen.tscroll, screen.bscroll, arg[0], 0);	3297	scr_scroll_text (screen.tscroll, screen.bscroll, arg[0], 0);
3162	break;	3298	break;
3163		3299
3164	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */	3300	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */
3165	tt_write ((const unsigned char *)VT100_ANS,	3301	tt_write ((const unsigned char *)VT100_ANS,
3166	(unsigned int) (sizeof (VT100_ANS) - 1));	3302	(unsigned int) (sizeof (VT100_ANS) - 1));
3167	break;	3303	break;
3168		3304
3169	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */	3305	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */
3170	process_sgr_mode (nargs, arg);	3306	process_sgr_mode (nargs, arg);
3171	break;	3307	break;
…		…
3178	break;	3314	break;
3179	case 6: /* CPR requested */	3315	case 6: /* CPR requested */
3180	scr_report_position ();	3316	scr_report_position ();
3181	break;	3317	break;
3182	case 7: /* unofficial extension */	3318	case 7: /* unofficial extension */
3183	if (Options & Opt_insecure)	3319	if (options & Opt_insecure)
3184	tt_printf ("%-.250s\n", rs[Rs_display_name]);	3320	tt_printf ("%-.250s\012", rs[Rs_display_name]);
3185	break;	3321	break;
3186	case 8: /* unofficial extension */	3322	case 8: /* unofficial extension */
3187	process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);	3323	process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);
3188	break;	3324	break;
3189	}	3325	}
…		…
3225	break;	3361	break;
3226		3362
3227	case CSI_RM: /* 8.3.107: RESET MODE */	3363	case CSI_RM: /* 8.3.107: RESET MODE */
3228	if (arg[0] == 4)	3364	if (arg[0] == 4)
3229	scr_insert_mode (0);	3365	scr_insert_mode (0);
		3366	else if (arg[0] == 20)
		3367	priv_modes &= ~PrivMode_LFNL;
3230	break;	3368	break;
3231		3369
3232	case CSI_SM: /* 8.3.126: SET MODE */	3370	case CSI_SM: /* 8.3.126: SET MODE */
3233	if (arg[0] == 4)	3371	if (arg[0] == 4)
3234	scr_insert_mode (1);	3372	scr_insert_mode (1);
		3373	else if (arg[0] == 20)
		3374	priv_modes |= PrivMode_LFNL;
3235	break;	3375	break;
3236		3376
3237	/*	3377	/*
3238	* PRIVATE USE beyond this point. All CSI_7? sequences here	3378	* PRIVATE USE beyond this point. All CSI_7? sequences here
3239	*/	3379	*/
…		…
3251	break;	3391	break;
3252	case CSI_75:	3392	case CSI_75:
3253	scr_cursor (RESTORE);	3393	scr_cursor (RESTORE);
3254	break;	3394	break;
3255		3395
3256	#ifndef NO_FRILLS	3396	#if ENABLE_FRILLS
3257	case CSI_74:	3397	case CSI_74:
3258	process_window_ops (arg, nargs);	3398	process_window_ops (arg, nargs);
3259	break;	3399	break;
3260	#endif	3400	#endif
3261		3401
…		…
3268	break;	3408	break;
3269	}	3409	}
3270	}	3410	}
3271	/*}}} */	3411	/*}}} */
3272		3412
3273	#ifndef NO_FRILLS	3413	#if ENABLE_FRILLS
3274	/* ARGSUSED */	3414	/* ARGSUSED */
3275	void	3415	void
3276	rxvt_term::process_window_ops (const int *args, unsigned int nargs)	3416	rxvt_term::process_window_ops (const int *args, unsigned int nargs)
3277	{	3417	{
3278	int x, y;	3418	int x, y;
…		…
3348	break;	3488	break;
3349	case 20: /* report icon label */	3489	case 20: /* report icon label */
3350	{	3490	{
3351	char *s;	3491	char *s;
3352	XGetIconName (display->display, TermWin.parent[0], &s);	3492	XGetIconName (display->display, TermWin.parent[0], &s);
3353	tt_printf ("\033]L%-.250s\234", (Options & Opt_insecure) && s ? s : ""); /* 8bit ST */	3493	tt_printf ("\033]L%-.250s\234", (options & Opt_insecure) && s ? s : ""); /* 8bit ST */
3354	XFree (s);	3494	XFree (s);
3355	}	3495	}
3356	break;	3496	break;
3357	case 21: /* report window title */	3497	case 21: /* report window title */
3358	{	3498	{
3359	char *s;	3499	char *s;
3360	XFetchName (display->display, TermWin.parent[0], &s);	3500	XFetchName (display->display, TermWin.parent[0], &s);
3361	tt_printf ("\033]l%-.250s\234", (Options & Opt_insecure) && s ? s : ""); /* 8bit ST */	3501	tt_printf ("\033]l%-.250s\234", (options & Opt_insecure) && s ? s : ""); /* 8bit ST */
3362	XFree (s);	3502	XFree (s);
3363	}	3503	}
3364	break;	3504	break;
3365	}	3505	}
3366	}	3506	}
…		…
3372	* ends_how is terminator used. returned input must be free()'d	3512	* ends_how is terminator used. returned input must be free()'d
3373	*/	3513	*/
3374	unsigned char *	3514	unsigned char *
3375	rxvt_term::get_to_st (unicode_t &ends_how)	3515	rxvt_term::get_to_st (unicode_t &ends_how)
3376	{	3516	{
3377	unicode_t prev = 0, ch;	3517	unicode_t seen_esc = 0, ch;
3378	unsigned int n = 0;	3518	unsigned int n = 0;
3379	unsigned char *s;	3519	unsigned char *s;
3380	unsigned char string[STRING_MAX];	3520	unsigned char string[STRING_MAX];
3381		3521
3382	while ((ch = cmd_getc ()) != NOCHAR)	3522	while ((ch = cmd_getc ()) != NOCHAR)
3383	{	3523	{
3384	if (prev == C0_ESC)	3524	if (seen_esc)
3385	{	3525	{
3386	if (ch == 0x5c) /* 7bit ST */	3526	if (ch == 0x5c) /* 7bit ST */
3387	break;	3527	break;
3388	else	3528	else
3389	return NULL;	3529	return NULL;
3390	}	3530	}
		3531	else if (ch == C0_ESC)
		3532	{
		3533	seen_esc = 1;
		3534	continue;
		3535	}
3391	else if (ch == C0_BEL || ch == CHAR_ST)	3536	else if (ch == C0_BEL || ch == CHAR_ST)
3392	break;	3537	break;
3393	else if (ch < 0x20)	3538	else if (ch < 0x20)
3394	return NULL; /* other control character - exit */	3539	return NULL; /* other control character - exit */
		3540
		3541	seen_esc = 0;
3395		3542
3396	if (n >= sizeof (string) - 1)	3543	if (n >= sizeof (string) - 1)
3397	// stop at some sane length	3544	// stop at some sane length
3398	return NULL;	3545	return NULL;
3399		3546
3400	if (ch == C0_SYN)	3547	if (ch == C0_SYN)
3401	{
3402	string[n++] = cmd_get8 ();	3548	string[n++] = cmd_get8 ();
3403	prev = 0;
3404	}
3405	else	3549	else
3406	string[n++] = prev = ch;	3550	string[n++] = ch;
3407	}	3551	}
3408		3552
3409	string[n++] = '\0';	3553	string[n++] = '\0';
3410		3554
3411	if ((s = (unsigned char *)rxvt_malloc (n)) == NULL)	3555	if ((s = (unsigned char *)rxvt_malloc (n)) == NULL)
3412	return NULL;	3556	return NULL;
3413		3557
3414	ends_how = (ch == 0x5c ? C0_ESC : ch);	3558	ends_how = (ch == 0x5c ? C0_ESC : ch);
3415	STRNCPY (s, string, n);	3559	strncpy (s, string, n);
3416	return s;	3560	return s;
3417	}	3561	}
3418		3562
3419	/*----------------------------------------------------------------------*/	3563	/*----------------------------------------------------------------------*/
3420	/*	3564	/*
…		…
3466	rxvt_term::process_color_seq (int report, int color, const char *str, unsigned char resp)	3610	rxvt_term::process_color_seq (int report, int color, const char *str, unsigned char resp)
3467	{	3611	{
3468	if (str[0] == '?' && !str[1])	3612	if (str[0] == '?' && !str[1])
3469	{	3613	{
3470	unsigned short r, g, b;	3614	unsigned short r, g, b;
3471	PixColorsFocused[color].get (display, r, g, b);	3615	pix_colors_focused[color].get (display, r, g, b);
3472	tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, r, g, b, resp);	3616	tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, r, g, b, resp);
3473	}	3617	}
3474	else	3618	else
3475	set_window_color (color, str);	3619	set_window_color (color, str);
3476	}	3620	}
…		…
3505	{	3649	{
3506	int changed = 0;	3650	int changed = 0;
3507	int color;	3651	int color;
3508	char *buf, *name;	3652	char *buf, *name;
3509	bool query = str[0] == '?' && !str[1];	3653	bool query = str[0] == '?' && !str[1];
		3654	int saveop = op;
3510		3655
3511	assert (str != NULL);	3656	assert (str != NULL);
3512	switch (op)	3657	switch (op)
3513	{	3658	{
3514	case XTerm_name:	3659	case XTerm_name:
…		…
3563	break;	3708	break;
3564		3709
3565	case XTerm_Color:	3710	case XTerm_Color:
3566	for (buf = (char *)str; buf && *buf;)	3711	for (buf = (char *)str; buf && *buf;)
3567	{	3712	{
3568	if ((name = STRCHR (buf, ';')) == NULL)	3713	if ((name = strchr (buf, ';')) == NULL)
3569	break;	3714	break;
3570		3715
3571	*name++ = '\0';	3716	*name++ = '\0';
3572	color = atoi (buf);	3717	color = atoi (buf);
3573		3718
3574	if (color < 0 || color >= TOTAL_COLORS)	3719	if (color < 0 || color >= TOTAL_COLORS)
3575	break;	3720	break;
3576		3721
3577	if ((buf = STRCHR (name, ';')) != NULL)	3722	if ((buf = strchr (name, ';')) != NULL)
3578	*buf++ = '\0';	3723	*buf++ = '\0';
3579		3724
3580	if (name[0] == '?' && !name[1])	3725	if (name[0] == '?' && !name[1])
3581	{	3726	{
3582	unsigned short r, g, b;	3727	unsigned short r, g, b;
3583	PixColorsFocused[color + minCOLOR].get (display, r, g, b);	3728	pix_colors_focused[color + minCOLOR].get (display, r, g, b);
3584	tt_printf ("\033]%d;%d;rgb:%04x/%04x/%04x%c", XTerm_Color, color, r, g, b, resp);	3729	tt_printf ("\033]%d;%d;rgb:%04x/%04x/%04x%c", XTerm_Color, color, r, g, b, resp);
3585	}	3730	}
3586	else	3731	else
3587	set_window_color (color + minCOLOR, name);	3732	set_window_color (color + minCOLOR, name);
3588	}	3733	}
…		…
3606	break;	3751	break;
3607	#ifndef NO_BOLD_UNDERLINE_REVERSE	3752	#ifndef NO_BOLD_UNDERLINE_REVERSE
3608	case XTerm_Color_BD:	3753	case XTerm_Color_BD:
3609	process_color_seq (XTerm_Color_BD, Color_BD, str, resp);	3754	process_color_seq (XTerm_Color_BD, Color_BD, str, resp);
3610	break;	3755	break;
		3756	case XTerm_Color_IT:
		3757	process_color_seq (XTerm_Color_IT, Color_IT, str, resp);
		3758	break;
3611	case XTerm_Color_UL:	3759	case XTerm_Color_UL:
3612	process_color_seq (XTerm_Color_UL, Color_UL, str, resp);	3760	process_color_seq (XTerm_Color_UL, Color_UL, str, resp);
3613	break;	3761	break;
3614	case XTerm_Color_RV:	3762	case XTerm_Color_RV:
3615	process_color_seq (XTerm_Color_RV, Color_RV, str, resp);	3763	process_color_seq (XTerm_Color_RV, Color_RV, str, resp);
		3764	break;
		3765	#endif
		3766	#if TRANSPARENT || TINTING
		3767	case XTerm_Color_tint:
		3768	process_color_seq (XTerm_Color_tint, Color_tint, str, resp);
		3769	check_our_parents ();
		3770	if (am_transparent)
		3771	want_full_refresh = want_refresh = 1;
3616	break;	3772	break;
3617	#endif	3773	#endif
3618		3774
3619	case XTerm_Pixmap:	3775	case XTerm_Pixmap:
3620	if (*str != ';')	3776	if (*str != ';')
…		…
3623	scale_pixmap (""); /* reset to default scaling */	3779	scale_pixmap (""); /* reset to default scaling */
3624	set_bgPixmap (str); /* change pixmap */	3780	set_bgPixmap (str); /* change pixmap */
3625	#endif	3781	#endif
3626	scr_touch (true);	3782	scr_touch (true);
3627	}	3783	}
3628	while ((str = STRCHR (str, ';')) != NULL)	3784	while ((str = strchr (str, ';')) != NULL)
3629	{	3785	{
3630	str++;	3786	str++;
3631	#if XPM_BACKGROUND	3787	#if XPM_BACKGROUND
3632	changed += scale_pixmap (str);	3788	changed += scale_pixmap (str);
3633	#endif	3789	#endif
…		…
3652	case XTerm_logfile:	3808	case XTerm_logfile:
3653	// TODO, when secure mode?	3809	// TODO, when secure mode?
3654	break;	3810	break;
3655		3811
3656	case XTerm_font:	3812	case XTerm_font:
		3813	op = URxvt_font;
		3814	case URxvt_font:
		3815	#if ENABLE_STYLES
		3816	case URxvt_boldFont:
		3817	case URxvt_italicFont:
		3818	case URxvt_boldItalicFont:
		3819	#endif
3657	if (query)	3820	if (query)
3658	tt_printf ("\33]%d;%-.250s%c", XTerm_font,	3821	tt_printf ("\33]%d;%-.250s%c", saveop,
3659	(Options & Opt_insecure) && TermWin.fontset->fontdesc	3822	(options & Opt_insecure) && TermWin.fontset[op - URxvt_font]->fontdesc
3660	? TermWin.fontset->fontdesc : "",	3823	? TermWin.fontset[op - URxvt_font]->fontdesc : "",
3661	resp);	3824	resp);
3662	else	3825	else
		3826	{
		3827	const char *&res = rs[Rs_font + (op - URxvt_font)];
		3828
		3829	res = strdup (str);
		3830	allocated.push_back ((void *)res);
3663	change_font (str);	3831	set_fonts ();
		3832	}
3664	break;	3833	break;
3665		3834
3666	#ifndef NO_FRILLS	3835	#if ENABLE_FRILLS
3667	case XTerm_locale:	3836	case XTerm_locale:
3668	if (query)	3837	if (query)
3669	tt_printf ("\33]%d;%-.250s%c", XTerm_locale, (Options & Opt_insecure) ? locale : "", resp);	3838	tt_printf ("\33]%d;%-.250s%c", XTerm_locale, (options & Opt_insecure) ? locale : "", resp);
3670	else	3839	else
3671	{	3840	{
3672	set_locale (str);	3841	set_locale (str);
3673	# ifdef USE_XIM	3842	# ifdef USE_XIM
3674	im_cb ();	3843	im_cb ();
3675	# endif	3844	# endif
3676	}	3845	}
3677	break;	3846	break;
3678
3679	case XTerm_findfont:
3680	{
3681	int fid = TermWin.fontset->find_font (atoi (str));
3682	tt_printf ("\33]%d;%d;%-.250s%c", XTerm_findfont,
3683	fid,
3684	(Options & Opt_insecure) ? (*TermWin.fontset)[fid]->name : "",
3685	resp);
3686	}
3687	break;
3688	#endif	3847	#endif
3689		3848
3690	#ifdef MENUBAR	3849	#ifdef MENUBAR
3691	case XTerm_Menu:	3850	case XTerm_Menu:
3692	if (Options & Opt_insecure)	3851	if (options & Opt_insecure)
3693	menubar_dispatch (const_cast<char *>(str)); // casting away constness is checked	3852	menubar_dispatch (const_cast<char *>(str)); // casting away constness is checked
3694	break;	3853	break;
3695	#endif	3854	#endif
3696	#if 0	3855	#if 0
3697	case XTerm_dumpscreen: /* no error notices */	3856	case XTerm_dumpscreen: /* no error notices */
…		…
3724	{	3883	{
3725	int state;	3884	int state;
3726		3885
3727	if (mode == 's')	3886	if (mode == 's')
3728	{	3887	{
3729	SavedModes |= (PrivateModes & bit);	3888	SavedModes |= (priv_modes & bit);
3730	return -1;	3889	return -1;
3731	}	3890	}
3732	else	3891	else
3733	{	3892	{
3734	if (mode == 'r')	3893	if (mode == 'r')
3735	state = (SavedModes & bit) ? 1 : 0; /* no overlapping */	3894	state = (SavedModes & bit) ? 1 : 0; /* no overlapping */
3736	else	3895	else
3737	state = (mode == 't') ? ! (PrivateModes & bit) : mode;	3896	state = (mode == 't') ? ! (priv_modes & bit) : mode;
3738	PrivMode (state, bit);	3897	PrivMode (state, bit);
3739	}	3898	}
3740		3899
3741	return state;	3900	return state;
3742	}	3901	}
…		…
3760	{ 3, PrivMode_132 },	3919	{ 3, PrivMode_132 },
3761	{ 4, PrivMode_smoothScroll },	3920	{ 4, PrivMode_smoothScroll },
3762	{ 5, PrivMode_rVideo },	3921	{ 5, PrivMode_rVideo },
3763	{ 6, PrivMode_relOrigin },	3922	{ 6, PrivMode_relOrigin },
3764	{ 7, PrivMode_Autowrap },	3923	{ 7, PrivMode_Autowrap },
		3924	// 8, bi-directional support mode
3765	{ 9, PrivMode_MouseX10 },	3925	{ 9, PrivMode_MouseX10 },
3766	#ifdef menuBar_esc	3926	#ifdef menuBar_esc
3767	{ menuBar_esc, PrivMode_menuBar },	3927	{ menuBar_esc, PrivMode_menuBar },
3768	#endif	3928	#endif
		3929	// 18, 19 printing-related
		3930	{ 25, PrivMode_VisibleCursor },
3769	#ifdef scrollBar_esc	3931	#ifdef scrollBar_esc
3770	{ scrollBar_esc, PrivMode_scrollBar },	3932	{ scrollBar_esc, PrivMode_scrollBar },
3771	#endif	3933	#endif
3772	// 18, 19 printing-related
3773	{ 25, PrivMode_VisibleCursor },
3774	// 30 show scrollbar rxvt. extension
3775	{ 35, PrivMode_ShiftKeys }, // rxvt extension	3934	{ 35, PrivMode_ShiftKeys }, // rxvt extension
3776	{ 40, PrivMode_132OK },	3935	{ 40, PrivMode_132OK },
3777	// 41 xterm more fixes NYI	3936	// 41 xterm more fixes NYI
3778	// 45 margin bell NYI	3937	// 45 margin bell NYI
3779	// 46 start logging	3938	// 46 start logging
…		…
3820		3979
3821	/* extra handling for values with state unkept */	3980	/* extra handling for values with state unkept */
3822	switch (arg[i])	3981	switch (arg[i])
3823	{	3982	{
3824	case 1048: /* alternative cursor save */	3983	case 1048: /* alternative cursor save */
		3984	case 1049:
3825	if (Options & Opt_secondaryScreen)	3985	if (options & Opt_secondaryScreen)
3826	if (mode == 0)	3986	if (mode == 0)
3827	scr_cursor (RESTORE);	3987	scr_cursor (RESTORE);
3828	else if (mode == 1)	3988	else if (mode == 1)
3829	scr_cursor (SAVE);	3989	scr_cursor (SAVE);
3830	break;	3990	break;
…		…
3841	* within VT52 mode	4001	* within VT52 mode
3842	*/	4002	*/
3843	PrivMode (1, PrivMode_vt52);	4003	PrivMode (1, PrivMode_vt52);
3844	break;	4004	break;
3845	case 3: /* 80/132 */	4005	case 3: /* 80/132 */
3846	if (PrivateModes & PrivMode_132OK)	4006	if (priv_modes & PrivMode_132OK)
3847	set_widthheight (((state ? 132 : 80) * TermWin.fwidth), TermWin.height);	4007	set_widthheight (((state ? 132 : 80) * TermWin.fwidth), TermWin.height);
3848	break;	4008	break;
3849	case 4: /* smooth scrolling */	4009	case 4: /* smooth scrolling */
3850	if (state)	4010	if (state)
3851	Options &= ~Opt_jumpScroll;	4011	options &= ~Opt_jumpScroll;
3852	else	4012	else
3853	Options |= Opt_jumpScroll;	4013	options |= Opt_jumpScroll;
3854	break;	4014	break;
3855	case 5: /* reverse video */	4015	case 5: /* reverse video */
3856	scr_rvideo_mode (state);	4016	scr_rvideo_mode (state);
3857	break;	4017	break;
3858	case 6: /* relative/absolute origins */	4018	case 6: /* relative/absolute origins */
…		…
3862	scr_autowrap (state);	4022	scr_autowrap (state);
3863	break;	4023	break;
3864	/* case 8: - auto repeat, can't do on a per window basis */	4024	/* case 8: - auto repeat, can't do on a per window basis */
3865	case 9: /* X10 mouse reporting */	4025	case 9: /* X10 mouse reporting */
3866	if (state) /* orthogonal */	4026	if (state) /* orthogonal */
3867	PrivateModes &= ~PrivMode_MouseX11;	4027	priv_modes &= ~PrivMode_MouseX11;
3868	break;	4028	break;
3869	#ifdef menuBar_esc	4029	#ifdef menuBar_esc
3870	case menuBar_esc:	4030	case menuBar_esc:
3871	#ifdef MENUBAR	4031	#ifdef MENUBAR
3872	map_menuBar (state);	4032	map_menuBar (state);
…		…
3892	break;	4052	break;
3893	/* case 66: - application key pad */	4053	/* case 66: - application key pad */
3894	/* case 67: - backspace key */	4054	/* case 67: - backspace key */
3895	case 1000: /* X11 mouse reporting */	4055	case 1000: /* X11 mouse reporting */
3896	if (state) /* orthogonal */	4056	if (state) /* orthogonal */
3897	PrivateModes &= ~PrivMode_MouseX10;	4057	priv_modes &= ~PrivMode_MouseX10;
3898	break;	4058	break;
3899	#if 0	4059	#if 0
3900	case 1001:	4060	case 1001:
3901	break; /* X11 mouse highlighting */	4061	break; /* X11 mouse highlighting */
3902	#endif	4062	#endif
3903	case 1010: /* scroll to bottom on TTY output inhibit */	4063	case 1010: /* scroll to bottom on TTY output inhibit */
3904	if (state)	4064	if (state)
3905	Options &= ~Opt_scrollTtyOutput;	4065	options &= ~Opt_scrollTtyOutput;
3906	else	4066	else
3907	Options |= Opt_scrollTtyOutput;	4067	options |= Opt_scrollTtyOutput;
3908	break;	4068	break;
3909	case 1011: /* scroll to bottom on key press */	4069	case 1011: /* scroll to bottom on key press */
3910	if (state)	4070	if (state)
3911	Options |= Opt_scrollTtyKeypress;	4071	options |= Opt_scrollTtyKeypress;
3912	else	4072	else
3913	Options &= ~Opt_scrollTtyKeypress;	4073	options &= ~Opt_scrollTtyKeypress;
3914	break;	4074	break;
3915	case 1047: /* secondary screen w/ clearing last */	4075	case 1047: /* secondary screen w/ clearing last */
3916	if (Options & Opt_secondaryScreen)	4076	if (options & Opt_secondaryScreen)
3917	if (current_screen != PRIMARY)	4077	if (current_screen != PRIMARY)
3918	scr_erase_screen (2);	4078	scr_erase_screen (2);
3919	scr_change_screen (state);	4079	scr_change_screen (state);
3920	break;	4080	break;
3921	case 1049: /* secondary screen w/ clearing first */	4081	case 1049: /* secondary screen w/ clearing first */
3922	scr_change_screen (state);	4082	scr_change_screen (state);
3923	if (Options & Opt_secondaryScreen)	4083	if (options & Opt_secondaryScreen)
3924	if (current_screen != PRIMARY)	4084	if (current_screen != PRIMARY)
3925	scr_erase_screen (2);	4085	scr_erase_screen (2);
3926	break;	4086	break;
3927	default:	4087	default:
3928	break;	4088	break;
…		…
3954	rendset = 0, rendstyle = ~RS_None;	4114	rendset = 0, rendstyle = ~RS_None;
3955	break;	4115	break;
3956	case 1:	4116	case 1:
3957	rendset = 1, rendstyle = RS_Bold;	4117	rendset = 1, rendstyle = RS_Bold;
3958	break;	4118	break;
3959	//case 2: // faint or second colour	4119	//case 2: // low intensity
		4120	case 3:
		4121	rendset = 1, rendstyle = RS_Italic;
		4122	break;
3960	case 4:	4123	case 4:
3961	rendset = 1, rendstyle = RS_Uline;	4124	rendset = 1, rendstyle = RS_Uline;
3962	break;	4125	break;
3963	case 5: // slowly blinking	4126	case 5: // slowly blinking
3964	case 6: // rapidly blinking	4127	case 6: // rapidly blinking
…		…
3976	//case 11: // scoansi acs on, first alt font	4139	//case 11: // scoansi acs on, first alt font
3977	//case 12: // scoansi acs on, |0x80, second alt font	4140	//case 12: // scoansi acs on, |0x80, second alt font
3978	//...	4141	//...
3979	//case 19: // ninth alt font	4142	//case 19: // ninth alt font
3980	//case 20: // gothic	4143	//case 20: // gothic
3981	case 21: // disable bold, faint	4144	case 21: // disable bold, faint, sometimes doubly underlined (iso 8613)
3982	rendset = 0, rendstyle = RS_Bold;	4145	rendset = 0, rendstyle = RS_Bold;
3983	break;	4146	break;
3984	case 22:	4147	case 22: // normal intensity
3985	rendset = 0, rendstyle = RS_Bold;	4148	rendset = 0, rendstyle = RS_Bold;
3986	break;	4149	break;
3987	//case 23: disable italic	4150	case 23: // disable italic
		4151	rendset = 0, rendstyle = RS_Italic;
		4152	break;
3988	case 24:	4153	case 24:
3989	rendset = 0, rendstyle = RS_Uline;	4154	rendset = 0, rendstyle = RS_Uline;
3990	break;	4155	break;
3991	case 25:	4156	case 25:
		4157	rendset = 0, rendstyle = RS_Blink;
		4158	break;
		4159	case 26: // variable spacing (iso 8613)
3992	rendset = 0, rendstyle = RS_Blink;	4160	rendset = 0, rendstyle = RS_Blink;
3993	break;	4161	break;
3994	case 27:	4162	case 27:
3995	rendset = 0, rendstyle = RS_RVid;	4163	rendset = 0, rendstyle = RS_RVid;
3996	break;	4164	break;
…		…
4014	case 35:	4182	case 35:
4015	case 36:	4183	case 36:
4016	case 37:	4184	case 37:
4017	scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);	4185	scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);
4018	break;	4186	break;
4019	#ifdef TTY_256COLOR	4187	case 38: // set fg color, ISO 8613-6
4020	case 38:
4021	if (nargs > i + 2 && arg[i + 1] == 5)	4188	if (nargs > i + 2 && arg[i + 1] == 5)
4022	{	4189	{
4023	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg);	4190	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg);
4024	i += 2;	4191	i += 2;
4025	}	4192	}
4026	break;	4193	break;
4027	#endif
4028	case 39: /* default fg */	4194	case 39: /* default fg */
4029	scr_color (Color_fg, Color_fg);	4195	scr_color (Color_fg, Color_fg);
4030	break;	4196	break;
4031		4197
4032	case 40:	4198	case 40:
…		…
4037	case 45:	4203	case 45:
4038	case 46:	4204	case 46:
4039	case 47:	4205	case 47:
4040	scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);	4206	scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);
4041	break;	4207	break;
4042	#ifdef TTY_256COLOR	4208	case 48: // set bg color, ISO 8613-6
4043	case 48:
4044	if (nargs > i + 2 && arg[i + 1] == 5)	4209	if (nargs > i + 2 && arg[i + 1] == 5)
4045	{	4210	{
4046	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg);	4211	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg);
4047	i += 2;	4212	i += 2;
4048	}	4213	}
4049	break;	4214	break;
4050	#endif
4051	case 49: /* default bg */	4215	case 49: /* default bg */
4052	scr_color (Color_bg, Color_bg);	4216	scr_color (Color_bg, Color_bg);
4053	break;	4217	break;
		4218
		4219	//case 50: // not variable spacing
4054		4220
4055	#ifndef NO_BRIGHTCOLOR	4221	#ifndef NO_BRIGHTCOLOR
4056	case 90:	4222	case 90:
4057	case 91: /* set bright fg color */	4223	case 91: /* set bright fg color */
4058	case 92:	4224	case 92:
4059	case 93:	4225	case 93:
4060	case 94:	4226	case 94:
4061	case 95:	4227	case 95:
4062	case 96:	4228	case 96:
4063	case 97:	4229	case 97:
4064	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 90)),	4230	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 90)), Color_fg);
4065	Color_fg);
4066	break;	4231	break;
4067	case 100:	4232	case 100:
4068	case 101: /* set bright bg color */	4233	case 101: /* set bright bg color */
4069	case 102:	4234	case 102:
4070	case 103:	4235	case 103:
4071	case 104:	4236	case 104:
4072	case 105:	4237	case 105:
4073	case 106:	4238	case 106:
4074	case 107:	4239	case 107:
4075	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 100)),	4240	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 100)), Color_bg);
4076	Color_bg);
4077	break;	4241	break;
4078	#endif	4242	#endif
4079		4243
4080	}	4244	}
4081	}	4245	}
…		…
4088	{	4252	{
4089	unicode_t ch, cmd = cmd_getc ();	4253	unicode_t ch, cmd = cmd_getc ();
4090		4254
4091	if (cmd == 'Q')	4255	if (cmd == 'Q')
4092	{ /* query graphics */	4256	{ /* query graphics */
4093	tt_printf ("\033G0\n"); /* no graphics */	4257	tt_printf ("\033G0\012"); /* no graphics */
4094	return;	4258	return;
4095	}	4259	}
4096	/* swallow other graphics sequences until terminating ':' */	4260	/* swallow other graphics sequences until terminating ':' */
4097	do	4261	do
4098	ch = cmd_getc ();	4262	ch = cmd_getc ();
…		…
4113	unsigned char buf[256];	4277	unsigned char buf[256];
4114		4278
4115	va_start (arg_ptr, fmt);	4279	va_start (arg_ptr, fmt);
4116	vsnprintf ((char *)buf, 256, fmt, arg_ptr);	4280	vsnprintf ((char *)buf, 256, fmt, arg_ptr);
4117	va_end (arg_ptr);	4281	va_end (arg_ptr);
4118	tt_write (buf, STRLEN (buf));	4282	tt_write (buf, strlen (buf));
4119	}	4283	}
4120		4284
4121	/* ---------------------------------------------------------------------- */	4285	/* ---------------------------------------------------------------------- */
4122	/* Write data to the pty as typed by the user, pasted with the mouse,	4286	/* Write data to the pty as typed by the user, pasted with the mouse,
4123	* or generated by us in response to a query ESC sequence.	4287	* or generated by us in response to a query ESC sequence.
4124	*/	4288	*/
4125	void	4289	void
4126	rxvt_term::tt_write (const unsigned char *data, unsigned int len)	4290	rxvt_term::tt_write (const unsigned char *data, unsigned int len)
4127	{	4291	{
4128	enum { MAX_PTY_WRITE = 255 }; // minimum MAX_INPUT	4292	const unsigned int MAX_PTY_WRITE = 255; // minimum MAX_INPUT
4129		4293
4130	if (len)	4294	if (len)
4131	{	4295	{
4132	if (v_buflen == 0)	4296	if (v_buflen == 0)
4133	{	4297	{
4134	ssize_t written = write (cmd_fd, data, min (MAX_PTY_WRITE, len));	4298	ssize_t written = write (pty.pty, data, min (len, MAX_PTY_WRITE));
4135		4299
4136	if ((unsigned int)written == len)	4300	if ((unsigned int)written == len)
4137	return;	4301	return;
4138		4302
4139	data += written;	4303	data += written;
…		…
4147	v_buflen += len;	4311	v_buflen += len;
4148	}	4312	}
4149		4313
4150	for (;;)	4314	for (;;)
4151	{	4315	{
4152	int written = write (cmd_fd, v_buffer, min (MAX_PTY_WRITE, v_buflen));	4316	int written = write (pty.pty, v_buffer, min (v_buflen, MAX_PTY_WRITE));
4153		4317
4154	if (written > 0)	4318	if (written > 0)
4155	{	4319	{
4156	v_buflen -= written;	4320	v_buflen -= written;
4157		4321

Diff Legend

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