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.163 by root, Wed Aug 25 03:47:20 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	}
…		…
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)
…		…
1107		1225
1108	Window unused_root, unused_child;	1226	Window unused_root, unused_child;
1109	int unused_root_x, unused_root_y;	1227	int unused_root_x, unused_root_y;
1110	unsigned int unused_mask;	1228	unsigned int unused_mask;
1111		1229
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)	1230	switch (ev.type)
1162	{	1231	{
1163	case KeyPress:	1232	case KeyPress:
		1233	#if ISO_14755
1164	if (!(iso14755buf & ISO_14755_ESCAPE_NEXT))	1234	if (!(iso14755buf & ISO_14755_52))
		1235	#endif
1165	lookup_key (ev.xkey);	1236	lookup_key (ev.xkey);
1166		1237
1167	break;	1238	break;
1168		1239
1169	case KeyRelease:	1240	case KeyRelease:
1170	{	1241	{
1171	#if (defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)) || !defined (NO_FRILLS)	1242	#if (MOUSE_WHEEL && MOUSE_SLIP_WHEELING) || ISO_14755
1172	KeySym ks;	1243	KeySym ks;
1173		1244
1174	ks = XLookupKeysym (&ev.xkey, ev.xkey.state & ShiftMask ? 1 : 0); // sorry, only shift supported :/	1245	ks = XLookupKeysym (&ev.xkey, ev.xkey.state & ShiftMask ? 1 : 0); // sorry, only shift supported :/
1175	#endif	1246	#endif
1176		1247
1177	#ifndef NO_FRILLS	1248	#if ENABLE_FRILLS || ISO_14755
1178	// ISO 14755 support	1249	// ISO 14755 support
1179	if (iso14755buf)	1250	if (iso14755buf)
1180	if (iso14755buf & ISO_14755_ESCAPE_NEXT)	1251	if (iso14755buf & ISO_14755_52)
1181	{	1252	{
		1253	# if ENABLE_OVERLAY
		1254	scr_overlay_off ();
		1255	# endif
		1256	# if ISO_14755
1182	// iso14755 part 5.2 handling: release time	1257	// iso14755 part 5.2 handling: release time
1183	// first: controls	1258	// first: controls
1184	if ((ev.xkey.state & ControlMask)	1259	if ((ev.xkey.state & ControlMask)
1185	&& ((ks >= 0x40 && ks <= 0x5f)	1260	&& ((ks >= 0x40 && ks <= 0x5f)
1186	|| (ks >= 0x61 && ks <= 0x7f)))	1261	|| (ks >= 0x61 && ks <= 0x7f)))
1187	{	1262	{
1188	iso14755buf = ISO_14755_KEYCODE_VALID | 0x2400 | (ks & 0x1f);	1263	iso14755buf = ISO_14755_51 | 0x2400 | (ks & 0x1f);
1189	commit_iso14755 ();	1264	commit_iso14755 ();
1190	return; // case-break;	1265	return; // case-break;
1191	}	1266	}
1192		1267
1193	for (unsigned short *i = iso14755_symtab; i[0]; i+= 2)	1268	for (unsigned short *i = iso14755_symtab; i[0]; i+= 2)
1194	if (i[0] == ks)	1269	if (i[0] == ks)
1195	{	1270	{
1196	iso14755buf = ISO_14755_KEYCODE_VALID | i[1];	1271	iso14755buf = ISO_14755_51 | i[1];
1197	commit_iso14755 ();	1272	commit_iso14755 ();
1198	return; // case-break;	1273	return; // case-break;
1199	}	1274	}
1200		1275
		1276	scr_bell ();
		1277	# endif
1201	iso14755buf = 0;	1278	iso14755buf = 0;
1202	scr_bell ();
1203	break;	1279	break;
1204	}	1280	}
1205	else if ((ev.xkey.state & (ShiftMask | ControlMask)) != (ShiftMask | ControlMask))	1281	else if ((ev.xkey.state & (ShiftMask | ControlMask)) != (ShiftMask | ControlMask))
1206	{	1282	{
		1283	# if ENABLE_OVERLAY
		1284	scr_overlay_off ();
		1285	# endif
1207	if (iso14755buf & ISO_14755_KEYCODE_VALID)	1286	if (iso14755buf & ISO_14755_51)
1208	commit_iso14755 ();	1287	commit_iso14755 ();
		1288	#if ISO_14755
1209	else if (iso14755buf & ISO_14755_ACTIVE)	1289	else if (iso14755buf & ISO_14755_STARTED)
		1290	{
1210	iso14755buf = ISO_14755_ESCAPE_NEXT; // iso14755 part 5.2: remember empty begin/end pair	1291	iso14755buf = ISO_14755_52; // iso14755 part 5.2: remember empty begin/end pair
		1292
		1293	scr_overlay_new (0, -1, sizeof ("KEYCAP PICTURE INSERT MODE") - 1, 1);
		1294	scr_overlay_set (0, 0, "KEYCAP PICTURE INSERT MODE");
		1295	}
		1296	# endif
		1297	else
		1298	iso14755buf = 0;
1211	}	1299	}
1212	#endif	1300	#endif
1213		1301
1214	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)	1302	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
1215	if (!(ev.xkey.state & ControlMask))	1303	if (!(ev.xkey.state & ControlMask))
…		…
1253	&Size, &RemainingBytes,	1341	&Size, &RemainingBytes,
1254	&data);	1342	&data);
1255	XChangeProperty (display->display, display->root,	1343	XChangeProperty (display->display, display->root,
1256	XA_CUT_BUFFER0, XA_STRING,	1344	XA_CUT_BUFFER0, XA_STRING,
1257	8, PropModeReplace,	1345	8, PropModeReplace,
1258	data, STRLEN (data));	1346	data, strlen (data));
1259	XFree (data);	1347	XFree (data);
1260	selection_paste (display->root, XA_CUT_BUFFER0, True);	1348	selection_paste (display->root, XA_CUT_BUFFER0, True);
1261	XSetInputFocus (display->display, display->root, RevertToNone, CurrentTime);	1349	XSetInputFocus (display->display, display->root, RevertToNone, CurrentTime);
1262	}	1350	}
1263	#endif /* OFFIX_DND */	1351	#endif /* OFFIX_DND */
…		…
1297	{	1385	{
1298	TermWin.focus = 1;	1386	TermWin.focus = 1;
1299	want_refresh = 1;	1387	want_refresh = 1;
1300	#ifdef USE_XIM	1388	#ifdef USE_XIM
1301	if (Input_Context != NULL)	1389	if (Input_Context != NULL)
		1390	{
		1391	IMSetStatusPosition ();
1302	XSetICFocus (Input_Context);	1392	XSetICFocus (Input_Context);
		1393	}
1303	#endif	1394	#endif
1304	#ifdef CURSOR_BLINK	1395	#ifdef CURSOR_BLINK
1305	if (Options & Opt_cursorBlink)	1396	if (options & Opt_cursorBlink)
1306	cursor_blink_ev.start (NOW + BLINK_INTERVAL);	1397	cursor_blink_ev.start (NOW + BLINK_INTERVAL);
1307	#endif	1398	#endif
1308	#ifdef OFF_FOCUS_FADING	1399	#ifdef OFF_FOCUS_FADING
1309	if (rs[Rs_fade])	1400	if (rs[Rs_fade])
1310	{	1401	{
1311	PixColors = PixColorsFocused;	1402	pix_colors = pix_colors_focused;
1312	set_colorfgbg ();
1313	scr_clear ();	1403	scr_recolour ();
1314	scr_touch (true);
1315	}	1404	}
1316	#endif	1405	#endif
1317		1406
1318	}	1407	}
1319	break;	1408	break;
…		…
1321	case FocusOut:	1410	case FocusOut:
1322	if (TermWin.focus)	1411	if (TermWin.focus)
1323	{	1412	{
1324	TermWin.focus = 0;	1413	TermWin.focus = 0;
1325	want_refresh = 1;	1414	want_refresh = 1;
		1415
		1416	#if ENABLE_FRILLS || ISO_14755
		1417	iso14755buf = 0;
		1418	#endif
		1419	#if ENABLE_OVERLAY
		1420	scr_overlay_off ();
		1421	#endif
1326	#ifdef USE_XIM	1422	#ifdef USE_XIM
1327	if (Input_Context != NULL)	1423	if (Input_Context != NULL)
1328	XUnsetICFocus (Input_Context);	1424	XUnsetICFocus (Input_Context);
1329	#endif	1425	#endif
1330	#ifdef CURSOR_BLINK	1426	#ifdef CURSOR_BLINK
1331	if (Options & Opt_cursorBlink)	1427	if (options & Opt_cursorBlink)
1332	cursor_blink_ev.stop ();	1428	cursor_blink_ev.stop ();
1333	hidden_cursor = 0;	1429	hidden_cursor = 0;
1334	#endif	1430	#endif
1335	#ifdef OFF_FOCUS_FADING	1431	#ifdef OFF_FOCUS_FADING
1336	if (rs[Rs_fade])	1432	if (rs[Rs_fade])
1337	{	1433	{
1338	PixColors = PixColorsUnFocused;	1434	pix_colors = pix_colors_unfocused;
1339	set_colorfgbg ();
1340	scr_clear ();	1435	scr_recolour ();
1341	scr_touch (true);
1342	}	1436	}
1343	#endif	1437	#endif
1344
1345	}	1438	}
1346	break;	1439	break;
1347		1440
1348	case ConfigureNotify:	1441	case ConfigureNotify:
1349	if (ev.xconfigure.window == TermWin.parent[0])	1442	if (ev.xconfigure.window == TermWin.parent[0])
…		…
1357	D_SIZE ((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));	1450	D_SIZE ((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));
1358	}	1451	}
1359	while (XCheckTypedWindowEvent (display->display, ev.xconfigure.window, ConfigureNotify, &ev));	1452	while (XCheckTypedWindowEvent (display->display, ev.xconfigure.window, ConfigureNotify, &ev));
1360		1453
1361	if (szHint.width != width || szHint.height != height)	1454	if (szHint.width != width || szHint.height != height)
		1455	{
		1456	seen_resize = 1;
1362	resize_all_windows (width, height, 1);	1457	resize_all_windows (width, height, 1);
		1458	}
1363		1459
1364	#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */	1460	#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */
1365	if (Options & Opt_transparent)	1461	if (options & Opt_transparent)
1366	{	1462	{
1367	check_our_parents ();	1463	check_our_parents ();
1368	if (am_transparent)	1464	if (am_transparent)
1369	want_refresh = want_full_refresh = 1;	1465	want_refresh = want_full_refresh = 1;
1370	}	1466	}
…		…
1466	{	1562	{
1467	menubar_control (ev.xbutton);	1563	menubar_control (ev.xbutton);
1468	break;	1564	break;
1469	}	1565	}
1470	#endif	1566	#endif
1471	if ((PrivateModes & PrivMode_mouse_report) && ! (bypass_keystate))	1567	if ((priv_modes & PrivMode_mouse_report) && ! (bypass_keystate))
1472	break;	1568	break;
1473		1569
1474	if (ev.xany.window == TermWin.vt)	1570	if (ev.xany.window == TermWin.vt)
1475	{	1571	{
1476	if ((ev.xbutton.state & (Button1Mask | Button3Mask)))	1572	if (ev.xbutton.state & (Button1Mask | Button3Mask))
1477	{	1573	{
1478	while (XCheckTypedWindowEvent (display->display, TermWin.vt, MotionNotify, &ev))	1574	while (XCheckTypedWindowEvent (display->display, TermWin.vt, MotionNotify, &ev))
1479	;	1575	;
1480		1576
1481	XQueryPointer (display->display, TermWin.vt,	1577	XQueryPointer (display->display, TermWin.vt,
1482	&unused_root, &unused_child,	1578	&unused_root, &unused_child,
1483	&unused_root_x, &unused_root_y,	1579	&unused_root_x, &unused_root_y,
1484	& (ev.xbutton.x), & (ev.xbutton.y),	1580	& (ev.xbutton.x), & (ev.xbutton.y),
1485	&unused_mask);	1581	&unused_mask);
1486	#ifdef MOUSE_THRESHOLD	1582	#ifdef MOUSE_THRESHOLD
1487	/* deal with a `jumpy' mouse */	1583	/* deal with a `jumpy' mouse */
1488	if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)	1584	if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)
1489	{	1585	{
1490	#endif	1586	#endif
		1587	#if ISO_14755
		1588	// 5.4
		1589	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
		1590	{
		1591	iso14755_54 (ev.xbutton.x, ev.xbutton.y);
		1592	break;
		1593	}
		1594	#endif
1491	selection_extend ((ev.xbutton.x), (ev.xbutton.y),	1595	selection_extend (ev.xbutton.x, ev.xbutton.y,
1492	(ev.xbutton.state & Button3Mask) ? 2 : 0);	1596	(ev.xbutton.state & Button3Mask) ? 2 : 0);
1493	#ifdef SELECTION_SCROLLING	1597	#ifdef SELECTION_SCROLLING
1494	if (ev.xbutton.y < TermWin.int_bwidth	1598	if (ev.xbutton.y < TermWin.int_bwidth
1495	|| Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))	1599	|| Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))
1496	{	1600	{
…		…
1503	sel_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);	1607	sel_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);
1504		1608
1505	/* save the event params so we can highlight	1609	/* save the event params so we can highlight
1506	* the selection in the pending-scroll loop	1610	* the selection in the pending-scroll loop
1507	*/	1611	*/
1508	selection_save_x=ev.xbutton.x;	1612	selection_save_x = ev.xbutton.x;
1509	selection_save_y=ev.xbutton.y;	1613	selection_save_y = ev.xbutton.y;
1510	selection_save_state=
1511	(ev.xbutton.state & Button3Mask) ? 2 : 0;	1614	selection_save_state = (ev.xbutton.state & Button3Mask) ? 2 : 0;
1512		1615
1513	/* calc number of lines to scroll */	1616	/* calc number of lines to scroll */
1514	if (ev.xbutton.y<TermWin.int_bwidth)	1617	if (ev.xbutton.y<TermWin.int_bwidth)
1515	{	1618	{
1516	scroll_selection_dir = UP;	1619	scroll_selection_dir = UP;
1517	dist = TermWin.int_bwidth - ev.xbutton.y;	1620	dist = TermWin.int_bwidth - ev.xbutton.y;
1518	}	1621	}
1519	else	1622	else
1520	{	1623	{
1521	scroll_selection_dir = DN;	1624	scroll_selection_dir = DN;
1522	dist = ev.xbutton.y -
1523	(TermWin.int_bwidth + TermWin.height);	1625	dist = ev.xbutton.y - (TermWin.int_bwidth + TermWin.height);
1524	}	1626	}
		1627
1525	scroll_selection_lines= (Pixel2Height (dist)/	1628	scroll_selection_lines = Pixel2Height (dist)
1526	SELECTION_SCROLL_LINE_SPEEDUP)+1;	1629	/ SELECTION_SCROLL_LINE_SPEEDUP
		1630	+ 1;
1527	MIN_IT (scroll_selection_lines,	1631	MIN_IT (scroll_selection_lines,
1528	SELECTION_SCROLL_MAX_LINES);	1632	SELECTION_SCROLL_MAX_LINES);
1529	}	1633	}
1530	else	1634	else
1531	{	1635	{
1532	/* we are within the text window, so we	1636	/* we are within the text window, so we
1533	* shouldn't be scrolling	1637	* shouldn't be scrolling
…		…
1535	if (sel_scroll_ev.active)	1639	if (sel_scroll_ev.active)
1536	sel_scroll_ev.stop();	1640	sel_scroll_ev.stop();
1537	}	1641	}
1538	#endif	1642	#endif
1539	#ifdef MOUSE_THRESHOLD	1643	#ifdef MOUSE_THRESHOLD
1540
1541	}	1644	}
1542	#endif	1645	#endif
1543
1544	}	1646	}
1545	}	1647	}
1546	else if (isScrollbarWindow (ev.xany.window) && scrollbar_isMotion ())	1648	else if (isScrollbarWindow (ev.xany.window) && scrollbar_isMotion ())
1547	{	1649	{
1548	while (XCheckTypedWindowEvent (display->display, scrollBar.win,	1650	while (XCheckTypedWindowEvent (display->display, scrollBar.win,
1549	MotionNotify, &ev)) ;	1651	MotionNotify, &ev)) ;
1550	XQueryPointer (display->display, scrollBar.win,	1652	XQueryPointer (display->display, scrollBar.win,
1551	&unused_root, &unused_child,	1653	&unused_root, &unused_child,
1552	&unused_root_x, &unused_root_y,	1654	&unused_root_x, &unused_root_y,
1553	& (ev.xbutton.x), & (ev.xbutton.y),	1655	& (ev.xbutton.x), & (ev.xbutton.y),
1554	&unused_mask);	1656	&unused_mask);
…		…
1582	if (ev.xproperty.atom != xa[XA_XROOTPMAPID])	1684	if (ev.xproperty.atom != xa[XA_XROOTPMAPID])
1583	return;	1685	return;
1584		1686
1585	/* FALLTHROUGH */	1687	/* FALLTHROUGH */
1586	case ReparentNotify:	1688	case ReparentNotify:
1587	if ((Options & Opt_transparent) && check_our_parents () && am_transparent)	1689	if ((options & Opt_transparent) && check_our_parents () && am_transparent)
1588	want_refresh = want_full_refresh = 1;	1690	want_refresh = want_full_refresh = 1;
1589	break;	1691	break;
1590	}	1692	}
1591	}	1693	}
1592	#endif	1694	#endif
…		…
1596	{	1698	{
1597	int reportmode = 0, clickintime;	1699	int reportmode = 0, clickintime;
1598		1700
1599	bypass_keystate = ev.state & (ModMetaMask | ShiftMask);	1701	bypass_keystate = ev.state & (ModMetaMask | ShiftMask);
1600	if (!bypass_keystate)	1702	if (!bypass_keystate)
1601	reportmode = !! (PrivateModes & PrivMode_mouse_report);	1703	reportmode = !! (priv_modes & PrivMode_mouse_report);
		1704
1602	/*	1705	/*
1603	* VT window processing of button press	1706	* VT window processing of button press
1604	*/	1707	*/
1605	if (ev.window == TermWin.vt)	1708	if (ev.window == TermWin.vt)
1606	{	1709	{
		1710	#if ISO_14755
		1711	// 5.4
		1712	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
		1713	{
		1714	iso14755_54 (ev.x, ev.y);
		1715	return;
		1716	}
		1717	#endif
		1718
1607	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;	1719	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;
1608	if (reportmode)	1720	if (reportmode)
1609	{	1721	{
1610	/* mouse report from vt window */	1722	/* mouse report from vt window */
1611	/* save the xbutton state (for ButtonRelease) */	1723	/* save the xbutton state (for ButtonRelease) */
…		…
1645	MEvent.clicks = 0;	1757	MEvent.clicks = 0;
1646	switch (ev.button)	1758	switch (ev.button)
1647	{	1759	{
1648	case Button1:	1760	case Button1:
1649	/* allow shift+left click to extend selection */	1761	/* allow shift+left click to extend selection */
1650	if (ev.state & ShiftMask && ! (PrivateModes & PrivMode_mouse_report))	1762	if (ev.state & ShiftMask && ! (priv_modes & PrivMode_mouse_report))
1651	{	1763	{
1652	if (MEvent.button == Button1 && clickintime)	1764	if (MEvent.button == Button1 && clickintime)
1653	selection_rotate (ev.x, ev.y);	1765	selection_rotate (ev.x, ev.y);
1654	else	1766	else
1655	selection_extend (ev.x, ev.y, 1);	1767	selection_extend (ev.x, ev.y, 1);
…		…
1670	case Button3:	1782	case Button3:
1671	if (MEvent.button == Button3 && clickintime)	1783	if (MEvent.button == Button3 && clickintime)
1672	selection_rotate (ev.x, ev.y);	1784	selection_rotate (ev.x, ev.y);
1673	else	1785	else
1674	selection_extend (ev.x, ev.y, 1);	1786	selection_extend (ev.x, ev.y, 1);
		1787
1675	MEvent.button = Button3;	1788	MEvent.button = Button3;
1676	break;	1789	break;
1677	}	1790	}
1678	}	1791	}
		1792
1679	MEvent.time = ev.time;	1793	MEvent.time = ev.time;
1680	return;	1794	return;
1681	}	1795	}
1682		1796
1683	/*	1797	/*
…		…
1836	{	1950	{
1837	int reportmode = 0;	1951	int reportmode = 0;
1838		1952
1839	csrO = 0; /* reset csr Offset */	1953	csrO = 0; /* reset csr Offset */
1840	if (!bypass_keystate)	1954	if (!bypass_keystate)
1841	reportmode = !! (PrivateModes & PrivMode_mouse_report);	1955	reportmode = !! (priv_modes & PrivMode_mouse_report);
1842		1956
1843	if (scrollbar_isUpDn ())	1957	if (scrollbar_isUpDn ())
1844	{	1958	{
1845	scrollBar.setIdle ();	1959	scrollBar.setIdle ();
1846	scrollbar_show (0);	1960	scrollbar_show (0);
1847	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING	1961	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1848	refresh_type &= ~SMOOTH_REFRESH;	1962	refresh_type &= ~SMOOTH_REFRESH;
1849	#endif	1963	#endif
1850
1851	}	1964	}
		1965
1852	#ifdef SELECTION_SCROLLING	1966	#ifdef SELECTION_SCROLLING
1853	if (sel_scroll_ev.active)	1967	if (sel_scroll_ev.active)
1854	sel_scroll_ev.stop();	1968	sel_scroll_ev.stop();
1855	#endif	1969	#endif
		1970
1856	if (ev.window == TermWin.vt)	1971	if (ev.window == TermWin.vt)
1857	{	1972	{
		1973	#if ISO_14755
		1974	// 5.4
		1975	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
		1976	return;
		1977	#endif
1858	if (reportmode)	1978	if (reportmode)
1859	{	1979	{
1860	/* mouse report from vt window */	1980	/* mouse report from vt window */
1861	/* don't report release of wheel "buttons" */	1981	/* don't report release of wheel "buttons" */
1862	if (ev.button >= 4)	1982	if (ev.button >= 4)
…		…
1876	MEvent.button = AnyButton;	1996	MEvent.button = AnyButton;
1877	mouse_report (ev);	1997	mouse_report (ev);
1878	#endif /* MOUSE_REPORT_DOUBLECLICK */	1998	#endif /* MOUSE_REPORT_DOUBLECLICK */
1879	return;	1999	return;
1880	}	2000	}
		2001
1881	/*	2002	/*
1882	* dumb hack to compensate for the failure of click-and-drag	2003	* dumb hack to compensate for the failure of click-and-drag
1883	* when overriding mouse reporting	2004	* when overriding mouse reporting
1884	*/	2005	*/
1885	if (PrivateModes & PrivMode_mouse_report	2006	if (priv_modes & PrivMode_mouse_report
1886	&& bypass_keystate	2007	&& bypass_keystate
1887	&& ev.button == Button1 && MEvent.clicks <= 1)	2008	&& ev.button == Button1 && MEvent.clicks <= 1)
1888	selection_extend (ev.x, ev.y, 0);	2009	selection_extend (ev.x, ev.y, 0);
1889		2010
1890	switch (ev.button)	2011	switch (ev.button)
…		…
1905		2026
1906	v = ev.button == Button4 ? UP : DN;	2027	v = ev.button == Button4 ? UP : DN;
1907		2028
1908	if (ev.state & ShiftMask)	2029	if (ev.state & ShiftMask)
1909	i = 1;	2030	i = 1;
1910	else if (Options & Opt_mouseWheelScrollPage)	2031	else if (options & Opt_mouseWheelScrollPage)
1911	i = TermWin.nrow - 1;	2032	i = TermWin.nrow - 1;
1912	else	2033	else
1913	i = 5;	2034	i = 5;
1914		2035
1915	# ifdef MOUSE_SLIP_WHEELING	2036	# ifdef MOUSE_SLIP_WHEELING
…		…
2200	Pixmap rootpixmap = None;	2321	Pixmap rootpixmap = None;
2201	XWindowAttributes wattr, wrootattr;	2322	XWindowAttributes wattr, wrootattr;
2202		2323
2203	pchanged = 0;	2324	pchanged = 0;
2204		2325
2205	if (!(Options & Opt_transparent))	2326	if (!(options & Opt_transparent))
2206	return pchanged; /* Don't try any more */	2327	return pchanged; /* Don't try any more */
2207		2328
2208	XGetWindowAttributes (display->display, display->root, &wrootattr);	2329	XGetWindowAttributes (display->display, display->root, &wrootattr);
2209	rootdepth = wrootattr.depth;	2330	rootdepth = wrootattr.depth;
2210		2331
…		…
2213	if (rootdepth != wattr.depth)	2334	if (rootdepth != wattr.depth)
2214	{	2335	{
2215	if (am_transparent)	2336	if (am_transparent)
2216	{	2337	{
2217	pchanged = 1;	2338	pchanged = 1;
2218	XSetWindowBackground (display->display, TermWin.vt, PixColorsFocused[Color_bg]);	2339	XSetWindowBackground (display->display, TermWin.vt, pix_colors_focused[Color_bg]);
2219	am_transparent = am_pixmap_trans = 0;	2340	am_transparent = am_pixmap_trans = 0;
2220	}	2341	}
2221		2342
2222	return pchanged; /* Don't try any more */	2343	return pchanged; /* Don't try any more */
2223	}	2344	}
…		…
2318	if (ISSET_PIXCOLOR (Color_tint))	2439	if (ISSET_PIXCOLOR (Color_tint))
2319	{	2440	{
2320	unsigned short rm, gm, bm;	2441	unsigned short rm, gm, bm;
2321	int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;	2442	int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;
2322		2443
2323	PixColorsFocused[Color_tint].get (display, rm, gm, bm);	2444	pix_colors_focused[Color_tint].get (display, rm, gm, bm);
2324		2445
2325	ShadeXImage (display, image, shade, rm, gm, bm);	2446	ShadeXImage (display, image, shade, rm, gm, bm);
2326	}	2447	}
2327	#endif	2448	#endif
2328		2449
…		…
2347	{	2468	{
2348	unsigned int n;	2469	unsigned int n;
2349	/*	2470	/*
2350	* InheritPixmap transparency	2471	* InheritPixmap transparency
2351	*/	2472	*/
2352	D_X ((stderr, "InheritPixmap Seeking to %08lx", display->root));
2353	for (i = 1; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)	2473	for (i = 1; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
2354	{	2474	{
2355	oldp = TermWin.parent[i];	2475	oldp = TermWin.parent[i];
2356	XQueryTree (display->display, TermWin.parent[i - 1], &root,	2476	XQueryTree (display->display, TermWin.parent[i - 1], &root,
2357	&TermWin.parent[i], &list, &n);	2477	&TermWin.parent[i], &list, &n);
2358	XFree (list);	2478	XFree (list);
2359	D_X ((stderr, "InheritPixmap Parent[%d] = %08lx", i, TermWin.parent[i]));
2360		2479
2361	if (TermWin.parent[i] == display->root)	2480	if (TermWin.parent[i] == display->root)
2362	{	2481	{
2363	if (oldp != None)	2482	if (oldp != None)
2364	pchanged = 1;	2483	pchanged = 1;
…		…
2375	if (pchanged)	2494	if (pchanged)
2376	{	2495	{
2377	for (; n < (unsigned int)i; n++)	2496	for (; n < (unsigned int)i; n++)
2378	{	2497	{
2379	XGetWindowAttributes (display->display, TermWin.parent[n], &wattr);	2498	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)	2499	if (wattr.depth != rootdepth || wattr.c_class == InputOnly)
2382	{	2500	{
2383	n = (int) (sizeof (TermWin.parent) / sizeof (Window)) + 1;	2501	n = (int) (sizeof (TermWin.parent) / sizeof (Window)) + 1;
2384	break;	2502	break;
2385	}	2503	}
2386	}	2504	}
2387	}	2505	}
2388		2506
2389	if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0])))	2507	if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0])))
2390	{	2508	{
2391	D_X ((stderr, "InheritPixmap Turning off"));
2392	XSetWindowBackground (display->display, TermWin.parent[0], PixColorsFocused[Color_fg]);	2509	XSetWindowBackground (display->display, TermWin.parent[0], pix_colors_focused[Color_fg]);
2393	XSetWindowBackground (display->display, TermWin.vt, PixColorsFocused[Color_bg]);	2510	XSetWindowBackground (display->display, TermWin.vt, pix_colors_focused[Color_bg]);
2394	am_transparent = 0;	2511	am_transparent = 0;
2395	/* XXX: also turn off Opt_transparent? */	2512	/* XXX: also turn off Opt_transparent? */
2396	}	2513	}
2397	else	2514	else
2398	{	2515	{
2399	#if WAIT_FOR_WM	2516	#if WAIT_FOR_WM
2400	/* wait (an arbitrary period) for the WM to do its thing	2517	/* wait (an arbitrary period) for the WM to do its thing
2401	* needed for fvwm2.2.2 (and before?) */	2518	* needed for fvwm2.2.2 (and before?) */
2402	sleep (1);	2519	sleep (1);
2403	#endif	2520	#endif
2404	D_X ((stderr, "InheritPixmap Turning on (%d parents)", i - 1));
2405	for (n = 0; n < (unsigned int)i; n++)	2521	for (n = 0; n < (unsigned int)i; n++)
2406	{	2522	{
2407	XSetWindowBackgroundPixmap (display->display, TermWin.parent[n], ParentRelative);	2523	XSetWindowBackgroundPixmap (display->display, TermWin.parent[n], ParentRelative);
2408	XClearWindow (display->display, TermWin.parent[n]);	2524	XClearWindow (display->display, TermWin.parent[n]);
2409	}	2525	}
…		…
2414		2530
2415	for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)	2531	for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
2416	TermWin.parent[i] = None;	2532	TermWin.parent[i] = None;
2417	}	2533	}
2418		2534
2419	// this is experimental
2420	if (scrollBar.win)	2535	if (scrollBar.win)
2421	{	2536	{
2422	XSetWindowBackgroundPixmap (display->display, scrollBar.win, ParentRelative);	2537	XSetWindowBackgroundPixmap (display->display, scrollBar.win, ParentRelative);
2423	XClearWindow (display->display, scrollBar.win);
2424	scrollBar.setIdle ();	2538	scrollBar.setIdle ();
2425	scrollbar_show (0);	2539	scrollbar_show (0);
2426	}	2540	}
2427		2541
2428	return pchanged;	2542	return pchanged;
…		…
2449	if (ch == NOCHAR) // TODO: improve	2563	if (ch == NOCHAR) // TODO: improve
2450	break;	2564	break;
2451		2565
2452	if (!IS_CONTROL (ch) || ch == C0_LF || ch == C0_CR || ch == C0_HT)	2566	if (!IS_CONTROL (ch) || ch == C0_LF || ch == C0_CR || ch == C0_HT)
2453	{	2567	{
		2568	if (!seen_input)
		2569	{
		2570	seen_input = 1;
		2571	// many badly-written programs (e.g. jed) contain a race condition:
		2572	// they first read the screensize and then install a SIGWINCH handler.
		2573	// some window managers resize the window early, and these programs
		2574	// then sometimes get the size wrong.
		2575	// unfortunately other programs are even more buggy and dislike
		2576	// being sent SIGWINCH, so only do it when we were in fact being
		2577	// resized.
		2578	if (seen_resize)
		2579	kill (-cmd_pid, SIGWINCH);
		2580	}
		2581
2454	/* Read a text string from the input buffer */	2582	/* Read a text string from the input buffer */
2455	unicode_t buf[UBUFSIZ];	2583	unicode_t buf[UBUFSIZ];
2456	bool refreshnow = false;	2584	bool refreshnow = false;
2457	int nlines = 0;	2585	int nlines = 0;
2458	unicode_t *str = buf;	2586	unicode_t *str = buf;
…		…
2467	if (ch == C0_LF)	2595	if (ch == C0_LF)
2468	{	2596	{
2469	nlines++;	2597	nlines++;
2470	refresh_count++;	2598	refresh_count++;
2471		2599
2472	if (!(Options & Opt_jumpScroll)	2600	if (!(options & Opt_jumpScroll)
2473	|| (refresh_count >= refresh_limit * (TermWin.nrow - 1)))	2601	|| (refresh_count >= refresh_limit * (TermWin.nrow - 1)))
2474	{	2602	{
2475	refreshnow = true;	2603	refreshnow = true;
2476	ch = NOCHAR;	2604	ch = NOCHAR;
2477	break;	2605	break;
…		…
2504	* the number of pages between refreshes is refresh_limit, which	2632	* the number of pages between refreshes is refresh_limit, which
2505	* is incremented here because we must be doing flat-out scrolling.	2633	* is incremented here because we must be doing flat-out scrolling.
2506	*/	2634	*/
2507	if (refreshnow)	2635	if (refreshnow)
2508	{	2636	{
2509	if ((Options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)	2637	if ((options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)
2510	refresh_limit++;	2638	refresh_limit++;
2511	else	2639	else
2512	{	2640	{
2513	flag = true;	2641	flag = true;
2514	scr_refresh (refresh_type);	2642	scr_refresh (refresh_type);
…		…
2704	process_escape_seq ();	2832	process_escape_seq ();
2705	break;	2833	break;
2706	case C0_ENQ: /* terminal Status */	2834	case C0_ENQ: /* terminal Status */
2707	if (rs[Rs_answerbackstring])	2835	if (rs[Rs_answerbackstring])
2708	tt_write ((const unsigned char *)rs[Rs_answerbackstring],	2836	tt_write ((const unsigned char *)rs[Rs_answerbackstring],
2709	(unsigned int)STRLEN (rs[Rs_answerbackstring]));	2837	(unsigned int)strlen (rs[Rs_answerbackstring]));
2710	else	2838	else
2711	tt_write ((unsigned char *)VT100_ANS,	2839	tt_write ((unsigned char *)VT100_ANS,
2712	(unsigned int)STRLEN (VT100_ANS));	2840	(unsigned int)strlen (VT100_ANS));
2713	break;	2841	break;
2714	case C0_BEL: /* bell */	2842	case C0_BEL: /* bell */
2715	scr_bell ();	2843	scr_bell ();
2716	break;	2844	break;
2717	case C0_BS: /* backspace */	2845	case C0_BS: /* backspace */
…		…
2816	void	2944	void
2817	rxvt_term::process_escape_seq ()	2945	rxvt_term::process_escape_seq ()
2818	{	2946	{
2819	unicode_t ch = cmd_getc ();	2947	unicode_t ch = cmd_getc ();
2820		2948
2821	if (PrivateModes & PrivMode_vt52)	2949	if (priv_modes & PrivMode_vt52)
2822	{	2950	{
2823	process_escape_vt52 (ch);	2951	process_escape_vt52 (ch);
2824	return;	2952	return;
2825	}	2953	}
2826		2954
…		…
2841	scr_charset_set (2, (unsigned int)cmd_getc ());	2969	scr_charset_set (2, (unsigned int)cmd_getc ());
2842	break;	2970	break;
2843	case '+':	2971	case '+':
2844	scr_charset_set (3, (unsigned int)cmd_getc ());	2972	scr_charset_set (3, (unsigned int)cmd_getc ());
2845	break;	2973	break;
2846	#ifndef NO_FRILLS	2974	#if ENABLE_FRILLS
2847	case '6':	2975	case '6':
2848	scr_backindex ();	2976	scr_backindex ();
2849	break;	2977	break;
2850	#endif	2978	#endif
2851	case '7':	2979	case '7':
2852	scr_cursor (SAVE);	2980	scr_cursor (SAVE);
2853	break;	2981	break;
2854	case '8':	2982	case '8':
2855	scr_cursor (RESTORE);	2983	scr_cursor (RESTORE);
2856	break;	2984	break;
2857	#ifndef NO_FRILLS	2985	#if ENABLE_FRILLS
2858	case '9':	2986	case '9':
2859	scr_forwardindex ();	2987	scr_forwardindex ();
2860	break;	2988	break;
2861	#endif	2989	#endif
2862	case '=':	2990	case '=':
…		…
3161	scr_scroll_text (screen.tscroll, screen.bscroll, arg[0], 0);	3289	scr_scroll_text (screen.tscroll, screen.bscroll, arg[0], 0);
3162	break;	3290	break;
3163		3291
3164	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */	3292	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */
3165	tt_write ((const unsigned char *)VT100_ANS,	3293	tt_write ((const unsigned char *)VT100_ANS,
3166	(unsigned int) (sizeof (VT100_ANS) - 1));	3294	(unsigned int) (sizeof (VT100_ANS) - 1));
3167	break;	3295	break;
3168		3296
3169	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */	3297	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */
3170	process_sgr_mode (nargs, arg);	3298	process_sgr_mode (nargs, arg);
3171	break;	3299	break;
…		…
3178	break;	3306	break;
3179	case 6: /* CPR requested */	3307	case 6: /* CPR requested */
3180	scr_report_position ();	3308	scr_report_position ();
3181	break;	3309	break;
3182	case 7: /* unofficial extension */	3310	case 7: /* unofficial extension */
3183	if (Options & Opt_insecure)	3311	if (options & Opt_insecure)
3184	tt_printf ("%-.250s\n", rs[Rs_display_name]);	3312	tt_printf ("%-.250s\012", rs[Rs_display_name]);
3185	break;	3313	break;
3186	case 8: /* unofficial extension */	3314	case 8: /* unofficial extension */
3187	process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);	3315	process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);
3188	break;	3316	break;
3189	}	3317	}
…		…
3225	break;	3353	break;
3226		3354
3227	case CSI_RM: /* 8.3.107: RESET MODE */	3355	case CSI_RM: /* 8.3.107: RESET MODE */
3228	if (arg[0] == 4)	3356	if (arg[0] == 4)
3229	scr_insert_mode (0);	3357	scr_insert_mode (0);
		3358	else if (arg[0] == 20)
		3359	priv_modes &= ~PrivMode_LFNL;
3230	break;	3360	break;
3231		3361
3232	case CSI_SM: /* 8.3.126: SET MODE */	3362	case CSI_SM: /* 8.3.126: SET MODE */
3233	if (arg[0] == 4)	3363	if (arg[0] == 4)
3234	scr_insert_mode (1);	3364	scr_insert_mode (1);
		3365	else if (arg[0] == 20)
		3366	priv_modes |= PrivMode_LFNL;
3235	break;	3367	break;
3236		3368
3237	/*	3369	/*
3238	* PRIVATE USE beyond this point. All CSI_7? sequences here	3370	* PRIVATE USE beyond this point. All CSI_7? sequences here
3239	*/	3371	*/
…		…
3251	break;	3383	break;
3252	case CSI_75:	3384	case CSI_75:
3253	scr_cursor (RESTORE);	3385	scr_cursor (RESTORE);
3254	break;	3386	break;
3255		3387
3256	#ifndef NO_FRILLS	3388	#if ENABLE_FRILLS
3257	case CSI_74:	3389	case CSI_74:
3258	process_window_ops (arg, nargs);	3390	process_window_ops (arg, nargs);
3259	break;	3391	break;
3260	#endif	3392	#endif
3261		3393
…		…
3268	break;	3400	break;
3269	}	3401	}
3270	}	3402	}
3271	/*}}} */	3403	/*}}} */
3272		3404
3273	#ifndef NO_FRILLS	3405	#if ENABLE_FRILLS
3274	/* ARGSUSED */	3406	/* ARGSUSED */
3275	void	3407	void
3276	rxvt_term::process_window_ops (const int *args, unsigned int nargs)	3408	rxvt_term::process_window_ops (const int *args, unsigned int nargs)
3277	{	3409	{
3278	int x, y;	3410	int x, y;
…		…
3348	break;	3480	break;
3349	case 20: /* report icon label */	3481	case 20: /* report icon label */
3350	{	3482	{
3351	char *s;	3483	char *s;
3352	XGetIconName (display->display, TermWin.parent[0], &s);	3484	XGetIconName (display->display, TermWin.parent[0], &s);
3353	tt_printf ("\033]L%-.250s\234", (Options & Opt_insecure) && s ? s : ""); /* 8bit ST */	3485	tt_printf ("\033]L%-.250s\234", (options & Opt_insecure) && s ? s : ""); /* 8bit ST */
3354	XFree (s);	3486	XFree (s);
3355	}	3487	}
3356	break;	3488	break;
3357	case 21: /* report window title */	3489	case 21: /* report window title */
3358	{	3490	{
3359	char *s;	3491	char *s;
3360	XFetchName (display->display, TermWin.parent[0], &s);	3492	XFetchName (display->display, TermWin.parent[0], &s);
3361	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 */
3362	XFree (s);	3494	XFree (s);
3363	}	3495	}
3364	break;	3496	break;
3365	}	3497	}
3366	}	3498	}
…		…
3372	* ends_how is terminator used. returned input must be free()'d	3504	* ends_how is terminator used. returned input must be free()'d
3373	*/	3505	*/
3374	unsigned char *	3506	unsigned char *
3375	rxvt_term::get_to_st (unicode_t &ends_how)	3507	rxvt_term::get_to_st (unicode_t &ends_how)
3376	{	3508	{
3377	unicode_t prev = 0, ch;	3509	unicode_t seen_esc = 0, ch;
3378	unsigned int n = 0;	3510	unsigned int n = 0;
3379	unsigned char *s;	3511	unsigned char *s;
3380	unsigned char string[STRING_MAX];	3512	unsigned char string[STRING_MAX];
3381		3513
3382	while ((ch = cmd_getc ()) != NOCHAR)	3514	while ((ch = cmd_getc ()) != NOCHAR)
3383	{	3515	{
3384	if (prev == C0_ESC)	3516	if (seen_esc)
3385	{	3517	{
3386	if (ch == 0x5c) /* 7bit ST */	3518	if (ch == 0x5c) /* 7bit ST */
3387	break;	3519	break;
3388	else	3520	else
3389	return NULL;	3521	return NULL;
3390	}	3522	}
		3523	else if (ch == C0_ESC)
		3524	{
		3525	seen_esc = 1;
		3526	continue;
		3527	}
3391	else if (ch == C0_BEL || ch == CHAR_ST)	3528	else if (ch == C0_BEL || ch == CHAR_ST)
3392	break;	3529	break;
3393	else if (ch < 0x20)	3530	else if (ch < 0x20)
3394	return NULL; /* other control character - exit */	3531	return NULL; /* other control character - exit */
		3532
		3533	seen_esc = 0;
3395		3534
3396	if (n >= sizeof (string) - 1)	3535	if (n >= sizeof (string) - 1)
3397	// stop at some sane length	3536	// stop at some sane length
3398	return NULL;	3537	return NULL;
3399		3538
3400	if (ch == C0_SYN)	3539	if (ch == C0_SYN)
3401	{
3402	string[n++] = cmd_get8 ();	3540	string[n++] = cmd_get8 ();
3403	prev = 0;
3404	}
3405	else	3541	else
3406	string[n++] = prev = ch;	3542	string[n++] = ch;
3407	}	3543	}
3408		3544
3409	string[n++] = '\0';	3545	string[n++] = '\0';
3410		3546
3411	if ((s = (unsigned char *)rxvt_malloc (n)) == NULL)	3547	if ((s = (unsigned char *)rxvt_malloc (n)) == NULL)
3412	return NULL;	3548	return NULL;
3413		3549
3414	ends_how = (ch == 0x5c ? C0_ESC : ch);	3550	ends_how = (ch == 0x5c ? C0_ESC : ch);
3415	STRNCPY (s, string, n);	3551	strncpy (s, string, n);
3416	return s;	3552	return s;
3417	}	3553	}
3418		3554
3419	/*----------------------------------------------------------------------*/	3555	/*----------------------------------------------------------------------*/
3420	/*	3556	/*
…		…
3466	rxvt_term::process_color_seq (int report, int color, const char *str, unsigned char resp)	3602	rxvt_term::process_color_seq (int report, int color, const char *str, unsigned char resp)
3467	{	3603	{
3468	if (str[0] == '?' && !str[1])	3604	if (str[0] == '?' && !str[1])
3469	{	3605	{
3470	unsigned short r, g, b;	3606	unsigned short r, g, b;
3471	PixColorsFocused[color].get (display, r, g, b);	3607	pix_colors_focused[color].get (display, r, g, b);
3472	tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, r, g, b, resp);	3608	tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, r, g, b, resp);
3473	}	3609	}
3474	else	3610	else
3475	set_window_color (color, str);	3611	set_window_color (color, str);
3476	}	3612	}
…		…
3505	{	3641	{
3506	int changed = 0;	3642	int changed = 0;
3507	int color;	3643	int color;
3508	char *buf, *name;	3644	char *buf, *name;
3509	bool query = str[0] == '?' && !str[1];	3645	bool query = str[0] == '?' && !str[1];
		3646	int saveop = op;
3510		3647
3511	assert (str != NULL);	3648	assert (str != NULL);
3512	switch (op)	3649	switch (op)
3513	{	3650	{
3514	case XTerm_name:	3651	case XTerm_name:
…		…
3563	break;	3700	break;
3564		3701
3565	case XTerm_Color:	3702	case XTerm_Color:
3566	for (buf = (char *)str; buf && *buf;)	3703	for (buf = (char *)str; buf && *buf;)
3567	{	3704	{
3568	if ((name = STRCHR (buf, ';')) == NULL)	3705	if ((name = strchr (buf, ';')) == NULL)
3569	break;	3706	break;
3570		3707
3571	*name++ = '\0';	3708	*name++ = '\0';
3572	color = atoi (buf);	3709	color = atoi (buf);
3573		3710
3574	if (color < 0 || color >= TOTAL_COLORS)	3711	if (color < 0 || color >= TOTAL_COLORS)
3575	break;	3712	break;
3576		3713
3577	if ((buf = STRCHR (name, ';')) != NULL)	3714	if ((buf = strchr (name, ';')) != NULL)
3578	*buf++ = '\0';	3715	*buf++ = '\0';
3579		3716
3580	if (name[0] == '?' && !name[1])	3717	if (name[0] == '?' && !name[1])
3581	{	3718	{
3582	unsigned short r, g, b;	3719	unsigned short r, g, b;
3583	PixColorsFocused[color + minCOLOR].get (display, r, g, b);	3720	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);	3721	tt_printf ("\033]%d;%d;rgb:%04x/%04x/%04x%c", XTerm_Color, color, r, g, b, resp);
3585	}	3722	}
3586	else	3723	else
3587	set_window_color (color + minCOLOR, name);	3724	set_window_color (color + minCOLOR, name);
3588	}	3725	}
…		…
3606	break;	3743	break;
3607	#ifndef NO_BOLD_UNDERLINE_REVERSE	3744	#ifndef NO_BOLD_UNDERLINE_REVERSE
3608	case XTerm_Color_BD:	3745	case XTerm_Color_BD:
3609	process_color_seq (XTerm_Color_BD, Color_BD, str, resp);	3746	process_color_seq (XTerm_Color_BD, Color_BD, str, resp);
3610	break;	3747	break;
		3748	case XTerm_Color_IT:
		3749	process_color_seq (XTerm_Color_IT, Color_IT, str, resp);
		3750	break;
3611	case XTerm_Color_UL:	3751	case XTerm_Color_UL:
3612	process_color_seq (XTerm_Color_UL, Color_UL, str, resp);	3752	process_color_seq (XTerm_Color_UL, Color_UL, str, resp);
3613	break;	3753	break;
3614	case XTerm_Color_RV:	3754	case XTerm_Color_RV:
3615	process_color_seq (XTerm_Color_RV, Color_RV, str, resp);	3755	process_color_seq (XTerm_Color_RV, Color_RV, str, resp);
		3756	break;
		3757	#endif
		3758	#if TRANSPARENT || TINTING
		3759	case XTerm_Color_tint:
		3760	process_color_seq (XTerm_Color_tint, Color_tint, str, resp);
		3761	check_our_parents ();
		3762	if (am_transparent)
		3763	want_full_refresh = want_refresh = 1;
3616	break;	3764	break;
3617	#endif	3765	#endif
3618		3766
3619	case XTerm_Pixmap:	3767	case XTerm_Pixmap:
3620	if (*str != ';')	3768	if (*str != ';')
…		…
3623	scale_pixmap (""); /* reset to default scaling */	3771	scale_pixmap (""); /* reset to default scaling */
3624	set_bgPixmap (str); /* change pixmap */	3772	set_bgPixmap (str); /* change pixmap */
3625	#endif	3773	#endif
3626	scr_touch (true);	3774	scr_touch (true);
3627	}	3775	}
3628	while ((str = STRCHR (str, ';')) != NULL)	3776	while ((str = strchr (str, ';')) != NULL)
3629	{	3777	{
3630	str++;	3778	str++;
3631	#if XPM_BACKGROUND	3779	#if XPM_BACKGROUND
3632	changed += scale_pixmap (str);	3780	changed += scale_pixmap (str);
3633	#endif	3781	#endif
…		…
3652	case XTerm_logfile:	3800	case XTerm_logfile:
3653	// TODO, when secure mode?	3801	// TODO, when secure mode?
3654	break;	3802	break;
3655		3803
3656	case XTerm_font:	3804	case XTerm_font:
		3805	op = URxvt_font;
		3806	case URxvt_font:
		3807	#if ENABLE_STYLES
		3808	case URxvt_boldFont:
		3809	case URxvt_italicFont:
		3810	case URxvt_boldItalicFont:
		3811	#endif
3657	if (query)	3812	if (query)
3658	tt_printf ("\33]%d;%-.250s%c", XTerm_font,	3813	tt_printf ("\33]%d;%-.250s%c", saveop,
3659	(Options & Opt_insecure) && TermWin.fontset->fontdesc	3814	(options & Opt_insecure) && TermWin.fontset[op - URxvt_font]->fontdesc
3660	? TermWin.fontset->fontdesc : "",	3815	? TermWin.fontset[op - URxvt_font]->fontdesc : "",
3661	resp);	3816	resp);
3662	else	3817	else
		3818	{
		3819	const char *&res = rs[Rs_font + (op - URxvt_font)];
		3820
		3821	res = strdup (str);
		3822	allocated.push_back ((void *)res);
3663	change_font (str);	3823	set_fonts ();
		3824	}
3664	break;	3825	break;
3665		3826
3666	#ifndef NO_FRILLS	3827	#if ENABLE_FRILLS
3667	case XTerm_locale:	3828	case XTerm_locale:
3668	if (query)	3829	if (query)
3669	tt_printf ("\33]%d;%-.250s%c", XTerm_locale, (Options & Opt_insecure) ? locale : "", resp);	3830	tt_printf ("\33]%d;%-.250s%c", XTerm_locale, (options & Opt_insecure) ? locale : "", resp);
3670	else	3831	else
3671	{	3832	{
3672	set_locale (str);	3833	set_locale (str);
3673	# ifdef USE_XIM	3834	# ifdef USE_XIM
3674	im_cb ();	3835	im_cb ();
3675	# endif	3836	# endif
3676	}	3837	}
3677	break;	3838	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	3839	#endif
3689		3840
3690	#ifdef MENUBAR	3841	#ifdef MENUBAR
3691	case XTerm_Menu:	3842	case XTerm_Menu:
3692	if (Options & Opt_insecure)	3843	if (options & Opt_insecure)
3693	menubar_dispatch (const_cast<char *>(str)); // casting away constness is checked	3844	menubar_dispatch (const_cast<char *>(str)); // casting away constness is checked
3694	break;	3845	break;
3695	#endif	3846	#endif
3696	#if 0	3847	#if 0
3697	case XTerm_dumpscreen: /* no error notices */	3848	case XTerm_dumpscreen: /* no error notices */
…		…
3724	{	3875	{
3725	int state;	3876	int state;
3726		3877
3727	if (mode == 's')	3878	if (mode == 's')
3728	{	3879	{
3729	SavedModes |= (PrivateModes & bit);	3880	SavedModes |= (priv_modes & bit);
3730	return -1;	3881	return -1;
3731	}	3882	}
3732	else	3883	else
3733	{	3884	{
3734	if (mode == 'r')	3885	if (mode == 'r')
3735	state = (SavedModes & bit) ? 1 : 0; /* no overlapping */	3886	state = (SavedModes & bit) ? 1 : 0; /* no overlapping */
3736	else	3887	else
3737	state = (mode == 't') ? ! (PrivateModes & bit) : mode;	3888	state = (mode == 't') ? ! (priv_modes & bit) : mode;
3738	PrivMode (state, bit);	3889	PrivMode (state, bit);
3739	}	3890	}
3740		3891
3741	return state;	3892	return state;
3742	}	3893	}
…		…
3760	{ 3, PrivMode_132 },	3911	{ 3, PrivMode_132 },
3761	{ 4, PrivMode_smoothScroll },	3912	{ 4, PrivMode_smoothScroll },
3762	{ 5, PrivMode_rVideo },	3913	{ 5, PrivMode_rVideo },
3763	{ 6, PrivMode_relOrigin },	3914	{ 6, PrivMode_relOrigin },
3764	{ 7, PrivMode_Autowrap },	3915	{ 7, PrivMode_Autowrap },
		3916	// 8, bi-directional support mode
3765	{ 9, PrivMode_MouseX10 },	3917	{ 9, PrivMode_MouseX10 },
3766	#ifdef menuBar_esc	3918	#ifdef menuBar_esc
3767	{ menuBar_esc, PrivMode_menuBar },	3919	{ menuBar_esc, PrivMode_menuBar },
3768	#endif	3920	#endif
		3921	// 18, 19 printing-related
		3922	{ 25, PrivMode_VisibleCursor },
3769	#ifdef scrollBar_esc	3923	#ifdef scrollBar_esc
3770	{ scrollBar_esc, PrivMode_scrollBar },	3924	{ scrollBar_esc, PrivMode_scrollBar },
3771	#endif	3925	#endif
3772	// 18, 19 printing-related
3773	{ 25, PrivMode_VisibleCursor },
3774	// 30 show scrollbar rxvt. extension
3775	{ 35, PrivMode_ShiftKeys }, // rxvt extension	3926	{ 35, PrivMode_ShiftKeys }, // rxvt extension
3776	{ 40, PrivMode_132OK },	3927	{ 40, PrivMode_132OK },
3777	// 41 xterm more fixes NYI	3928	// 41 xterm more fixes NYI
3778	// 45 margin bell NYI	3929	// 45 margin bell NYI
3779	// 46 start logging	3930	// 46 start logging
…		…
3820		3971
3821	/* extra handling for values with state unkept */	3972	/* extra handling for values with state unkept */
3822	switch (arg[i])	3973	switch (arg[i])
3823	{	3974	{
3824	case 1048: /* alternative cursor save */	3975	case 1048: /* alternative cursor save */
		3976	case 1049:
3825	if (Options & Opt_secondaryScreen)	3977	if (options & Opt_secondaryScreen)
3826	if (mode == 0)	3978	if (mode == 0)
3827	scr_cursor (RESTORE);	3979	scr_cursor (RESTORE);
3828	else if (mode == 1)	3980	else if (mode == 1)
3829	scr_cursor (SAVE);	3981	scr_cursor (SAVE);
3830	break;	3982	break;
…		…
3841	* within VT52 mode	3993	* within VT52 mode
3842	*/	3994	*/
3843	PrivMode (1, PrivMode_vt52);	3995	PrivMode (1, PrivMode_vt52);
3844	break;	3996	break;
3845	case 3: /* 80/132 */	3997	case 3: /* 80/132 */
3846	if (PrivateModes & PrivMode_132OK)	3998	if (priv_modes & PrivMode_132OK)
3847	set_widthheight (((state ? 132 : 80) * TermWin.fwidth), TermWin.height);	3999	set_widthheight (((state ? 132 : 80) * TermWin.fwidth), TermWin.height);
3848	break;	4000	break;
3849	case 4: /* smooth scrolling */	4001	case 4: /* smooth scrolling */
3850	if (state)	4002	if (state)
3851	Options &= ~Opt_jumpScroll;	4003	options &= ~Opt_jumpScroll;
3852	else	4004	else
3853	Options |= Opt_jumpScroll;	4005	options |= Opt_jumpScroll;
3854	break;	4006	break;
3855	case 5: /* reverse video */	4007	case 5: /* reverse video */
3856	scr_rvideo_mode (state);	4008	scr_rvideo_mode (state);
3857	break;	4009	break;
3858	case 6: /* relative/absolute origins */	4010	case 6: /* relative/absolute origins */
…		…
3862	scr_autowrap (state);	4014	scr_autowrap (state);
3863	break;	4015	break;
3864	/* case 8: - auto repeat, can't do on a per window basis */	4016	/* case 8: - auto repeat, can't do on a per window basis */
3865	case 9: /* X10 mouse reporting */	4017	case 9: /* X10 mouse reporting */
3866	if (state) /* orthogonal */	4018	if (state) /* orthogonal */
3867	PrivateModes &= ~PrivMode_MouseX11;	4019	priv_modes &= ~PrivMode_MouseX11;
3868	break;	4020	break;
3869	#ifdef menuBar_esc	4021	#ifdef menuBar_esc
3870	case menuBar_esc:	4022	case menuBar_esc:
3871	#ifdef MENUBAR	4023	#ifdef MENUBAR
3872	map_menuBar (state);	4024	map_menuBar (state);
…		…
3892	break;	4044	break;
3893	/* case 66: - application key pad */	4045	/* case 66: - application key pad */
3894	/* case 67: - backspace key */	4046	/* case 67: - backspace key */
3895	case 1000: /* X11 mouse reporting */	4047	case 1000: /* X11 mouse reporting */
3896	if (state) /* orthogonal */	4048	if (state) /* orthogonal */
3897	PrivateModes &= ~PrivMode_MouseX10;	4049	priv_modes &= ~PrivMode_MouseX10;
3898	break;	4050	break;
3899	#if 0	4051	#if 0
3900	case 1001:	4052	case 1001:
3901	break; /* X11 mouse highlighting */	4053	break; /* X11 mouse highlighting */
3902	#endif	4054	#endif
3903	case 1010: /* scroll to bottom on TTY output inhibit */	4055	case 1010: /* scroll to bottom on TTY output inhibit */
3904	if (state)	4056	if (state)
3905	Options &= ~Opt_scrollTtyOutput;	4057	options &= ~Opt_scrollTtyOutput;
3906	else	4058	else
3907	Options |= Opt_scrollTtyOutput;	4059	options |= Opt_scrollTtyOutput;
3908	break;	4060	break;
3909	case 1011: /* scroll to bottom on key press */	4061	case 1011: /* scroll to bottom on key press */
3910	if (state)	4062	if (state)
3911	Options |= Opt_scrollTtyKeypress;	4063	options |= Opt_scrollTtyKeypress;
3912	else	4064	else
3913	Options &= ~Opt_scrollTtyKeypress;	4065	options &= ~Opt_scrollTtyKeypress;
3914	break;	4066	break;
3915	case 1047: /* secondary screen w/ clearing last */	4067	case 1047: /* secondary screen w/ clearing last */
3916	if (Options & Opt_secondaryScreen)	4068	if (options & Opt_secondaryScreen)
3917	if (current_screen != PRIMARY)	4069	if (current_screen != PRIMARY)
3918	scr_erase_screen (2);	4070	scr_erase_screen (2);
3919	scr_change_screen (state);	4071	scr_change_screen (state);
3920	break;	4072	break;
3921	case 1049: /* secondary screen w/ clearing first */	4073	case 1049: /* secondary screen w/ clearing first */
3922	scr_change_screen (state);	4074	scr_change_screen (state);
3923	if (Options & Opt_secondaryScreen)	4075	if (options & Opt_secondaryScreen)
3924	if (current_screen != PRIMARY)	4076	if (current_screen != PRIMARY)
3925	scr_erase_screen (2);	4077	scr_erase_screen (2);
3926	break;	4078	break;
3927	default:	4079	default:
3928	break;	4080	break;
…		…
3954	rendset = 0, rendstyle = ~RS_None;	4106	rendset = 0, rendstyle = ~RS_None;
3955	break;	4107	break;
3956	case 1:	4108	case 1:
3957	rendset = 1, rendstyle = RS_Bold;	4109	rendset = 1, rendstyle = RS_Bold;
3958	break;	4110	break;
3959	//case 2: // faint or second colour	4111	//case 2: // low intensity
		4112	case 3:
		4113	rendset = 1, rendstyle = RS_Italic;
		4114	break;
3960	case 4:	4115	case 4:
3961	rendset = 1, rendstyle = RS_Uline;	4116	rendset = 1, rendstyle = RS_Uline;
3962	break;	4117	break;
3963	case 5: // slowly blinking	4118	case 5: // slowly blinking
3964	case 6: // rapidly blinking	4119	case 6: // rapidly blinking
…		…
3976	//case 11: // scoansi acs on, first alt font	4131	//case 11: // scoansi acs on, first alt font
3977	//case 12: // scoansi acs on, |0x80, second alt font	4132	//case 12: // scoansi acs on, |0x80, second alt font
3978	//...	4133	//...
3979	//case 19: // ninth alt font	4134	//case 19: // ninth alt font
3980	//case 20: // gothic	4135	//case 20: // gothic
3981	case 21: // disable bold, faint	4136	case 21: // disable bold, faint, sometimes doubly underlined (iso 8613)
3982	rendset = 0, rendstyle = RS_Bold;	4137	rendset = 0, rendstyle = RS_Bold;
3983	break;	4138	break;
3984	case 22:	4139	case 22: // normal intensity
3985	rendset = 0, rendstyle = RS_Bold;	4140	rendset = 0, rendstyle = RS_Bold;
3986	break;	4141	break;
3987	//case 23: disable italic	4142	case 23: // disable italic
		4143	rendset = 0, rendstyle = RS_Italic;
		4144	break;
3988	case 24:	4145	case 24:
3989	rendset = 0, rendstyle = RS_Uline;	4146	rendset = 0, rendstyle = RS_Uline;
3990	break;	4147	break;
3991	case 25:	4148	case 25:
		4149	rendset = 0, rendstyle = RS_Blink;
		4150	break;
		4151	case 26: // variable spacing (iso 8613)
3992	rendset = 0, rendstyle = RS_Blink;	4152	rendset = 0, rendstyle = RS_Blink;
3993	break;	4153	break;
3994	case 27:	4154	case 27:
3995	rendset = 0, rendstyle = RS_RVid;	4155	rendset = 0, rendstyle = RS_RVid;
3996	break;	4156	break;
…		…
4014	case 35:	4174	case 35:
4015	case 36:	4175	case 36:
4016	case 37:	4176	case 37:
4017	scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);	4177	scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);
4018	break;	4178	break;
4019	#ifdef TTY_256COLOR	4179	case 38: // set fg color, ISO 8613-6
4020	case 38:
4021	if (nargs > i + 2 && arg[i + 1] == 5)	4180	if (nargs > i + 2 && arg[i + 1] == 5)
4022	{	4181	{
4023	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg);	4182	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg);
4024	i += 2;	4183	i += 2;
4025	}	4184	}
4026	break;	4185	break;
4027	#endif
4028	case 39: /* default fg */	4186	case 39: /* default fg */
4029	scr_color (Color_fg, Color_fg);	4187	scr_color (Color_fg, Color_fg);
4030	break;	4188	break;
4031		4189
4032	case 40:	4190	case 40:
…		…
4037	case 45:	4195	case 45:
4038	case 46:	4196	case 46:
4039	case 47:	4197	case 47:
4040	scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);	4198	scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);
4041	break;	4199	break;
4042	#ifdef TTY_256COLOR	4200	case 48: // set bg color, ISO 8613-6
4043	case 48:
4044	if (nargs > i + 2 && arg[i + 1] == 5)	4201	if (nargs > i + 2 && arg[i + 1] == 5)
4045	{	4202	{
4046	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg);	4203	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg);
4047	i += 2;	4204	i += 2;
4048	}	4205	}
4049	break;	4206	break;
4050	#endif
4051	case 49: /* default bg */	4207	case 49: /* default bg */
4052	scr_color (Color_bg, Color_bg);	4208	scr_color (Color_bg, Color_bg);
4053	break;	4209	break;
		4210
		4211	//case 50: // not variable spacing
4054		4212
4055	#ifndef NO_BRIGHTCOLOR	4213	#ifndef NO_BRIGHTCOLOR
4056	case 90:	4214	case 90:
4057	case 91: /* set bright fg color */	4215	case 91: /* set bright fg color */
4058	case 92:	4216	case 92:
4059	case 93:	4217	case 93:
4060	case 94:	4218	case 94:
4061	case 95:	4219	case 95:
4062	case 96:	4220	case 96:
4063	case 97:	4221	case 97:
4064	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 90)),	4222	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 90)), Color_fg);
4065	Color_fg);
4066	break;	4223	break;
4067	case 100:	4224	case 100:
4068	case 101: /* set bright bg color */	4225	case 101: /* set bright bg color */
4069	case 102:	4226	case 102:
4070	case 103:	4227	case 103:
4071	case 104:	4228	case 104:
4072	case 105:	4229	case 105:
4073	case 106:	4230	case 106:
4074	case 107:	4231	case 107:
4075	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 100)),	4232	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 100)), Color_bg);
4076	Color_bg);
4077	break;	4233	break;
4078	#endif	4234	#endif
4079		4235
4080	}	4236	}
4081	}	4237	}
…		…
4088	{	4244	{
4089	unicode_t ch, cmd = cmd_getc ();	4245	unicode_t ch, cmd = cmd_getc ();
4090		4246
4091	if (cmd == 'Q')	4247	if (cmd == 'Q')
4092	{ /* query graphics */	4248	{ /* query graphics */
4093	tt_printf ("\033G0\n"); /* no graphics */	4249	tt_printf ("\033G0\012"); /* no graphics */
4094	return;	4250	return;
4095	}	4251	}
4096	/* swallow other graphics sequences until terminating ':' */	4252	/* swallow other graphics sequences until terminating ':' */
4097	do	4253	do
4098	ch = cmd_getc ();	4254	ch = cmd_getc ();
…		…
4113	unsigned char buf[256];	4269	unsigned char buf[256];
4114		4270
4115	va_start (arg_ptr, fmt);	4271	va_start (arg_ptr, fmt);
4116	vsnprintf ((char *)buf, 256, fmt, arg_ptr);	4272	vsnprintf ((char *)buf, 256, fmt, arg_ptr);
4117	va_end (arg_ptr);	4273	va_end (arg_ptr);
4118	tt_write (buf, STRLEN (buf));	4274	tt_write (buf, strlen (buf));
4119	}	4275	}
4120		4276
4121	/* ---------------------------------------------------------------------- */	4277	/* ---------------------------------------------------------------------- */
4122	/* Write data to the pty as typed by the user, pasted with the mouse,	4278	/* 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.	4279	* or generated by us in response to a query ESC sequence.
4124	*/	4280	*/
4125	void	4281	void
4126	rxvt_term::tt_write (const unsigned char *data, unsigned int len)	4282	rxvt_term::tt_write (const unsigned char *data, unsigned int len)
4127	{	4283	{
4128	enum { MAX_PTY_WRITE = 255 }; // minimum MAX_INPUT	4284	const unsigned int MAX_PTY_WRITE = 255; // minimum MAX_INPUT
4129		4285
4130	if (len)	4286	if (len)
4131	{	4287	{
4132	if (v_buflen == 0)	4288	if (v_buflen == 0)
4133	{	4289	{
4134	ssize_t written = write (cmd_fd, data, min (MAX_PTY_WRITE, len));	4290	ssize_t written = write (pty.pty, data, min (len, MAX_PTY_WRITE));
4135		4291
4136	if ((unsigned int)written == len)	4292	if ((unsigned int)written == len)
4137	return;	4293	return;
4138		4294
4139	data += written;	4295	data += written;
…		…
4147	v_buflen += len;	4303	v_buflen += len;
4148	}	4304	}
4149		4305
4150	for (;;)	4306	for (;;)
4151	{	4307	{
4152	int written = write (cmd_fd, v_buffer, min (MAX_PTY_WRITE, v_buflen));	4308	int written = write (pty.pty, v_buffer, min (v_buflen, MAX_PTY_WRITE));
4153		4309
4154	if (written > 0)	4310	if (written > 0)
4155	{	4311	{
4156	v_buflen -= written;	4312	v_buflen -= written;
4157		4313

Diff Legend

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