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.81 by pcg, Sun Mar 28 02:07:08 2004 UTC vs.
Revision 1.120 by root, Tue Aug 10 22:36:30 2004 UTC

1	/*--------------------------------*-C-*---------------------------------*	1	/*--------------------------------*-C-*---------------------------------*
2	* File: command.c	2	* File: command.C
3	*----------------------------------------------------------------------*	3	*----------------------------------------------------------------------*
4	*	4	*
5	* All portions of code are copyright by their respective author/s.	5	* All portions of code are copyright by their respective author/s.
6	* Copyright (c) 1992 John Bovey, University of Kent at Canterbury <jdb@ukc.ac.uk>	6	* Copyright (c) 1992 John Bovey, University of Kent at Canterbury <jdb@ukc.ac.uk>
7	* - original version	7	* - original version
…		…
306	newlen = 0;	306	newlen = 0;
307	}	307	}
308	break;	308	break;
309		309
310	#ifdef XK_KP_Left	310	#ifdef XK_KP_Left
311	case XK_KP_Up: /* \033Ox or standard */	311	case XK_KP_Up: /* \033Ox or standard */
312	case XK_KP_Down: /* \033Or or standard */	312	case XK_KP_Down: /* \033Or or standard */
313	case XK_KP_Right: /* \033Ov or standard */	313	case XK_KP_Right: /* \033Ov or standard */
314	case XK_KP_Left: /* \033Ot or standard */	314	case XK_KP_Left: /* \033Ot or standard */
315	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	315	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
316	{	316	{
…		…
661	if (want_full_refresh)	661	if (want_full_refresh)
662	{	662	{
663	want_full_refresh = 0;	663	want_full_refresh = 0;
664	scr_clear ();	664	scr_clear ();
665	scr_touch (false);	665	scr_touch (false);
666	want_refresh = 1;
667	}	666	}
668	#endif	667	#endif
669		668
670	if (want_refresh)	669	if (want_refresh)
671	{	670	{
672	scr_refresh (refresh_type);	671	scr_refresh (refresh_type);
673	scrollbar_show (1);	672	scrollbar_show (1);
674	#ifdef USE_XIM	673	#ifdef USE_XIM
675	IMSendSpot ();	674	IMSendSpot ();
676	#endif	675	#endif
677
678	}	676	}
679		677
680	display->flush ();	678	display->flush ();
		679
		680	flush_ev.stop ();
681	}	681	}
682		682
683	void	683	void
684	rxvt_term::check_cb (check_watcher &w)	684	rxvt_term::check_cb (check_watcher &w)
685	{	685	{
686	SET_R (this);	686	SET_R (this);
687	SET_LOCALE (locale);	687	SET_LOCALE (locale);
688		688
		689	display->flush ();
		690
		691	if (want_refresh && !flush_ev.active)
		692	flush_ev.start (NOW + 0.01);
		693	}
		694
		695	void
		696	rxvt_term::flush_cb (time_watcher &w)
		697	{
		698	SET_R (this);
		699	SET_LOCALE (locale);
		700
		701	refresh_limit = 1;
		702	refresh_count = 0;
689	flush ();	703	flush ();
690	}	704	}
691		705
692	#ifdef CURSOR_BLINK	706	#ifdef CURSOR_BLINK
693	void	707	void
…		…
711	w.start (w.at + TEXT_BLINK_INTERVAL);	725	w.start (w.at + TEXT_BLINK_INTERVAL);
712	}	726	}
713	}	727	}
714	#endif	728	#endif
715		729
		730	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
		731	void
		732	rxvt_term::cont_scroll_cb (time_watcher &w)
		733	{
		734	if ((scrollbar_isUp() || scrollbar_isDn()) &&
		735	scr_page (scrollbar_isUp() ? UP : DN, 1))
		736	{
		737	refresh_type |= SMOOTH_REFRESH;
		738	want_refresh = 1;
		739	w.start (w.at + SCROLLBAR_CONTINUOUS_DELAY);
		740	}
		741	}
		742	#endif
		743
		744	#ifdef SELECTION_SCROLLING
		745	void
		746	rxvt_term::sel_scroll_cb (time_watcher &w)
		747	{
		748	if (scr_page (scroll_selection_dir, scroll_selection_lines))
		749	{
		750	selection_extend (selection_save_x, selection_save_y, selection_save_state);
		751	refresh_type |= SMOOTH_REFRESH;
		752	want_refresh = 1;
		753	w.start (w.at + SCROLLBAR_CONTINUOUS_DELAY);
		754	}
		755	}
		756	#endif
		757
		758	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
		759	void
		760	rxvt_term::slip_wheel_cb (time_watcher &w)
		761	{
		762	if (mouse_slip_wheel_speed == 0
		763	|| mouse_slip_wheel_speed < 0 ? scr_page (DN, -mouse_slip_wheel_speed)
		764	: scr_page (UP, mouse_slip_wheel_speed))
		765	{
		766	refresh_type |= SMOOTH_REFRESH;
		767	want_refresh = 1;
		768	w.start (w.at + SCROLLBAR_CONTINUOUS_DELAY);
		769	}
		770	}
		771	#endif
		772
716	bool	773	bool
717	rxvt_term::pty_fill ()	774	rxvt_term::pty_fill ()
718	{	775	{
719	ssize_t n = cmdbuf_endp - cmdbuf_ptr;	776	ssize_t n = cmdbuf_endp - cmdbuf_ptr;
		777
		778	if (CBUFSIZ == n)
		779	{
		780	rxvt_warn ("pty_fill on full buffer, draining input, continuing.\n");
		781	n = 0;
		782	}
720		783
721	memmove (cmdbuf_base, cmdbuf_ptr, n);	784	memmove (cmdbuf_base, cmdbuf_ptr, n);
722	cmdbuf_ptr = cmdbuf_base;	785	cmdbuf_ptr = cmdbuf_base;
723	cmdbuf_endp = cmdbuf_ptr + n;	786	cmdbuf_endp = cmdbuf_ptr + n;
724		787
…		…
742	SET_LOCALE (locale);	805	SET_LOCALE (locale);
743		806
744	if (revents & EVENT_WRITE)	807	if (revents & EVENT_WRITE)
745	tt_write (0, 0);	808	tt_write (0, 0);
746	else if (revents & EVENT_READ)	809	else if (revents & EVENT_READ)
747	{
748	// loop, but don't allow a single term to monopolize us	810	// loop, but don't allow a single term to monopolize us
749	// the number of loops is fully arbitrary, and thus wrong
750	while (pty_fill ())	811	while (pty_fill ())
751	{
752	if (!seen_input)
753	{
754	seen_input = 1;
755	/* once we know the shell is running, send the screen size. Again! */
756	// I don't know why, btw.
757	tt_winch ();
758	}
759
760	if (cmd_parse ())	812	if (cmd_parse ())
761	break;	813	break;
762	}
763	}
764	}	814	}
765		815
766	#ifdef POINTER_BLANK
767	void	816	void
768	rxvt_term::pointer_unblank ()	817	rxvt_term::pointer_unblank ()
769	{	818	{
770	XDefineCursor (display->display, TermWin.vt, TermWin_cursor);	819	XDefineCursor (display->display, TermWin.vt, TermWin_cursor);
771	recolour_cursor ();	820	recolour_cursor ();
772		821
		822	#ifdef POINTER_BLANK
773	hidden_pointer = 0;	823	hidden_pointer = 0;
774		824
775	if (Options & Opt_pointerBlank)	825	if (Options & Opt_pointerBlank)
776	pointer_ev.start (NOW + pointerBlankDelay);	826	pointer_ev.start (NOW + pointerBlankDelay);
		827	#endif
777	}	828	}
778		829
		830	#ifdef POINTER_BLANK
779	void	831	void
780	rxvt_term::pointer_blank ()	832	rxvt_term::pointer_blank ()
781	{	833	{
782	if (! (Options & Opt_pointerBlank))	834	if (! (Options & Opt_pointerBlank))
783	return;	835	return;
…		…
979	break;	1031	break;
980		1032
981	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)	1033	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
982	case KeyRelease:	1034	case KeyRelease:
983	{	1035	{
984	if (! (ev.xkey.state & ControlMask))	1036	if (!(ev.xkey.state & ControlMask))
985	mouse_slip_wheel_speed = 0;	1037	slip_wheel_ev.stop ();
986	else	1038	else
987	{	1039	{
988	KeySym ks;	1040	KeySym ks;
989		1041
990	ks = XKeycodeToKeysym (display->display, ev.xkey.keycode, 0);	1042	ks = XKeycodeToKeysym (display->display, ev.xkey.keycode, 0);
991	if (ks == XK_Control_L || ks == XK_Control_R)	1043	if (ks == XK_Control_L || ks == XK_Control_R)
992	mouse_slip_wheel_speed = 0;	1044	mouse_slip_wheel_speed = 0;
993	}	1045	}
…		…
1013	&& (ev.xclient.data.l[0] == DndFile	1065	&& (ev.xclient.data.l[0] == DndFile
1014	|| ev.xclient.data.l[0] == DndDir	1066	|| ev.xclient.data.l[0] == DndDir
1015	|| ev.xclient.data.l[0] == DndLink))	1067	|| ev.xclient.data.l[0] == DndLink))
1016	{	1068	{
1017	/* Get Dnd data */	1069	/* Get Dnd data */
1018	Atom ActualType;	1070	Atom ActualType;
1019	int ActualFormat;	1071	int ActualFormat;
1020	unsigned char *data;	1072	unsigned char *data;
1021	unsigned long Size, RemainingBytes;	1073	unsigned long Size, RemainingBytes;
1022		1074
1023	XGetWindowProperty (display->display, display->root,	1075	XGetWindowProperty (display->display, display->root,
1024	xa[XA_DNDSELECTION],	1076	xa[XA_DNDSELECTION],
1025	0L, 1000000L,	1077	0L, 1000000L,
1026	False, AnyPropertyType,	1078	False, AnyPropertyType,
…		…
1029	&data);	1081	&data);
1030	XChangeProperty (display->display, display->root,	1082	XChangeProperty (display->display, display->root,
1031	XA_CUT_BUFFER0, XA_STRING,	1083	XA_CUT_BUFFER0, XA_STRING,
1032	8, PropModeReplace,	1084	8, PropModeReplace,
1033	data, STRLEN (data));	1085	data, STRLEN (data));
		1086	XFree (data);
1034	selection_paste (display->root, XA_CUT_BUFFER0, True);	1087	selection_paste (display->root, XA_CUT_BUFFER0, True);
1035	XSetInputFocus (display->display, display->root, RevertToNone, CurrentTime);	1088	XSetInputFocus (display->display, display->root, RevertToNone, CurrentTime);
1036	}	1089	}
1037	#endif /* OFFIX_DND */	1090	#endif /* OFFIX_DND */
1038	break;	1091	break;
1039		1092
1040	case MappingNotify:	1093	case MappingNotify:
1041	XRefreshKeyboardMapping (& (ev.xmapping));	1094	XRefreshKeyboardMapping (&ev.xmapping);
1042	break;	1095	break;
1043		1096
1044	/*	1097	/*
1045	* XXX: this is not the _current_ arrangement	1098	* XXX: this is not the _current_ arrangement
1046	* Here's my conclusion:	1099	* Here's my conclusion:
…		…
1077	#endif	1130	#endif
1078	#ifdef CURSOR_BLINK	1131	#ifdef CURSOR_BLINK
1079	if (Options & Opt_cursorBlink)	1132	if (Options & Opt_cursorBlink)
1080	cursor_blink_ev.start (NOW + BLINK_INTERVAL);	1133	cursor_blink_ev.start (NOW + BLINK_INTERVAL);
1081	#endif	1134	#endif
		1135	#ifdef OFF_FOCUS_FADING
		1136	if (rs[Rs_fade])
		1137	{
		1138	PixColors = PixColorsFocused;
		1139	set_colorfgbg ();
		1140	scr_clear ();
		1141	scr_touch (true);
		1142	}
		1143	#endif
1082		1144
1083	}	1145	}
1084	break;	1146	break;
1085		1147
1086	case FocusOut:	1148	case FocusOut:
…		…
1095	#ifdef CURSOR_BLINK	1157	#ifdef CURSOR_BLINK
1096	if (Options & Opt_cursorBlink)	1158	if (Options & Opt_cursorBlink)
1097	cursor_blink_ev.stop ();	1159	cursor_blink_ev.stop ();
1098	hidden_cursor = 0;	1160	hidden_cursor = 0;
1099	#endif	1161	#endif
		1162	#ifdef OFF_FOCUS_FADING
		1163	if (rs[Rs_fade])
		1164	{
		1165	PixColors = PixColorsUnFocused;
		1166	set_colorfgbg ();
		1167	scr_clear ();
		1168	scr_touch (true);
		1169	}
		1170	#endif
1100		1171
1101	}	1172	}
1102	break;	1173	break;
1103		1174
1104	case ConfigureNotify:	1175	case ConfigureNotify:
…		…
1113	D_SIZE ((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));	1184	D_SIZE ((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));
1114	}	1185	}
1115	while (XCheckTypedWindowEvent (display->display, ev.xconfigure.window, ConfigureNotify, &ev));	1186	while (XCheckTypedWindowEvent (display->display, ev.xconfigure.window, ConfigureNotify, &ev));
1116		1187
1117	if (szHint.width != width || szHint.height != height)	1188	if (szHint.width != width || szHint.height != height)
1118	{
1119	D_SIZE ((stderr, "Size: Resizing from: %4d x %4d", szHint.width, szHint.height));
1120	resize_all_windows (width, height, 1);	1189	resize_all_windows (width, height, 1);
1121	}	1190
1122	#ifdef DEBUG_SIZE
1123	else
1124	{
1125	D_SIZE ((stderr, "Size: Not resizing"));
1126	}
1127	#endif
1128	#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */	1191	#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */
1129	if (Options & Opt_transparent)	1192	if (Options & Opt_transparent)
1130	{	1193	{
1131	check_our_parents ();	1194	check_our_parents ();
1132	if (am_transparent)	1195	if (am_transparent)
1133	want_full_refresh = 1;	1196	want_refresh = want_full_refresh = 1;
1134	}	1197	}
1135	#endif	1198	#endif
1136
1137	}	1199	}
1138	break;	1200	break;
1139		1201
1140	case SelectionClear:	1202	case SelectionClear:
1141	selection_clear ();	1203	selection_clear ();
…		…
1173		1235
1174	case GraphicsExpose:	1236	case GraphicsExpose:
1175	case Expose:	1237	case Expose:
1176	if (ev.xany.window == TermWin.vt)	1238	if (ev.xany.window == TermWin.vt)
1177	{	1239	{
1178	#ifdef NO_SLOW_LINK_SUPPORT	1240	do
1179	scr_expose (ev.xexpose.x, ev.xexpose.y,	1241	scr_expose (ev.xexpose.x, ev.xexpose.y,
1180	ev.xexpose.width, ev.xexpose.height, False);	1242	ev.xexpose.width, ev.xexpose.height, False);
1181	#else	1243	while (XCheckTypedWindowEvent (display->display, TermWin.vt, ev.xany.type, &ev));
1182	// don't understand this, so commented it out	1244
		1245	ev.xany.type = ev.xany.type == Expose ? GraphicsExpose : Expose;
		1246
		1247	while (XCheckTypedWindowEvent (display->display, TermWin.vt, ev.xany.type, &ev))
1183	scr_expose (ev.xexpose.x, ev.xexpose.y,	1248	scr_expose (ev.xexpose.x, ev.xexpose.y,
1184	ev.xexpose.width, ev.xexpose.height, False);	1249	ev.xexpose.width, ev.xexpose.height, False);
1185	//scr_expose (ev.xexpose.x, 0,	1250
1186	// ev.xexpose.width, TermWin.height, False);	1251	scr_refresh (refresh_type);
1187	#endif
1188	want_refresh = 1;
1189	}	1252	}
1190	else	1253	else
1191	{	1254	{
1192	XEvent unused_event;	1255	XEvent unused_event;
1193		1256
1194	while (XCheckTypedWindowEvent (display->display, ev.xany.window,	1257	while (XCheckTypedWindowEvent (display->display, ev.xany.window, Expose, &unused_event))
1195	Expose,	1258	;
1196	&unused_event)) ;
1197	while (XCheckTypedWindowEvent (display->display, ev.xany.window,	1259	while (XCheckTypedWindowEvent (display->display, ev.xany.window, GraphicsExpose, &unused_event))
1198	GraphicsExpose,	1260	;
1199	&unused_event)) ;	1261
1200	if (isScrollbarWindow (ev.xany.window))	1262	if (isScrollbarWindow (ev.xany.window))
1201	{	1263	{
1202	scrollBar.setIdle ();	1264	scrollBar.setIdle ();
1203	scrollbar_show (0);	1265	scrollbar_show (0);
1204	}	1266	}
1205	#ifdef MENUBAR	1267	#ifdef MENUBAR
1206	if (menubar_visible () && isMenuBarWindow (ev.xany.window))	1268	if (menubar_visible () && isMenuBarWindow (ev.xany.window))
1207	menubar_expose ();	1269	menubar_expose ();
		1270	#endif
		1271
		1272	#ifdef TRANSPARENT
		1273	if (am_transparent && ev.xany.window == TermWin.parent[0])
		1274	XClearWindow (display->display, ev.xany.window);
1208	#endif	1275	#endif
1209	}	1276	}
1210	break;	1277	break;
1211		1278
1212	case MotionNotify:	1279	case MotionNotify:
…		…
1247	if (ev.xbutton.y < TermWin.int_bwidth	1314	if (ev.xbutton.y < TermWin.int_bwidth
1248	|| Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))	1315	|| Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))
1249	{	1316	{
1250	int dist;	1317	int dist;
1251		1318
1252	pending_scroll_selection=1;
1253
1254	/* don't clobber the current delay if we are	1319	/* don't clobber the current delay if we are
1255	* already in the middle of scrolling.	1320	* already in the middle of scrolling.
1256	*/	1321	*/
1257	if (scroll_selection_delay<=0)	1322	if (!sel_scroll_ev.active)
1258	scroll_selection_delay=SCROLLBAR_CONTINUOUS_DELAY;	1323	sel_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);
1259		1324
1260	/* save the event params so we can highlight	1325	/* save the event params so we can highlight
1261	* the selection in the pending-scroll loop	1326	* the selection in the pending-scroll loop
1262	*/	1327	*/
1263	selection_save_x=ev.xbutton.x;	1328	selection_save_x=ev.xbutton.x;
…		…
1285	else	1350	else
1286	{	1351	{
1287	/* we are within the text window, so we	1352	/* we are within the text window, so we
1288	* shouldn't be scrolling	1353	* shouldn't be scrolling
1289	*/	1354	*/
1290	pending_scroll_selection = 0;	1355	if (sel_scroll_ev.active)
		1356	sel_scroll_ev.stop();
1291	}	1357	}
1292	#endif	1358	#endif
1293	#ifdef MOUSE_THRESHOLD	1359	#ifdef MOUSE_THRESHOLD
1294		1360
1295	}	1361	}
…		…
1345	return;	1411	return;
1346	}	1412	}
1347		1413
1348	/* FALLTHROUGH */	1414	/* FALLTHROUGH */
1349	case ReparentNotify:	1415	case ReparentNotify:
1350	if ((Options & Opt_transparent) && check_our_parents ())	1416	if ((Options & Opt_transparent) && check_our_parents () && am_transparent)
1351	if (am_transparent)
1352	want_full_refresh = 1;	1417	want_refresh = want_full_refresh = 1;
1353	break;	1418	break;
1354	#endif	1419	#endif
1355	}	1420	}
1356	}	1421	}
1357		1422
…		…
1513	upordown = 1; /* down */	1578	upordown = 1; /* down */
1514	}	1579	}
1515	if (upordown)	1580	if (upordown)
1516	{	1581	{
1517	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING	1582	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1518	scroll_arrow_delay = SCROLLBAR_INITIAL_DELAY;	1583	cont_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);
1519	#endif	1584	#endif
1520	if (scr_page (upordown < 0 ? UP : DN, 1))	1585	if (scr_page (upordown < 0 ? UP : DN, 1))
1521	{	1586	{
1522	if (upordown < 0)	1587	if (upordown < 0)
1523	scrollBar.setUp ();	1588	scrollBar.setUp ();
…		…
1539	break;	1604	break;
1540	case R_SB_ALIGN_BOTTOM:	1605	case R_SB_ALIGN_BOTTOM:
1541	csrO = scrollBar.bot - scrollBar.top;	1606	csrO = scrollBar.bot - scrollBar.top;
1542	break;	1607	break;
1543	}	1608	}
		1609
1544	if (scrollBar.style == R_SB_XTERM	1610	if (scrollBar.style == R_SB_XTERM
1545	|| scrollbar_above_slider (ev.y)	1611	|| scrollbar_above_slider (ev.y)
1546	|| scrollbar_below_slider (ev.y))	1612	|| scrollbar_below_slider (ev.y))
1547	scr_move_to ( scrollbar_position (ev.y) - csrO,	1613	scr_move_to (scrollbar_position (ev.y) - csrO, scrollbar_size ());
1548	scrollbar_size ());	1614
1549	scrollBar.setMotion ();	1615	scrollBar.setMotion ();
1550	break;	1616	break;
1551		1617
1552	case Button1:	1618	case Button1:
1553	if (scrollbar_align == R_SB_ALIGN_CENTRE)	1619	if (scrollbar_align == R_SB_ALIGN_CENTRE)
…		…
1577	scr_page ((ev.button == Button1 ? DN : UP),	1643	scr_page ((ev.button == Button1 ? DN : UP),
1578	(TermWin.nrow	1644	(TermWin.nrow
1579	* scrollbar_position (ev.y)	1645	* scrollbar_position (ev.y)
1580	/ scrollbar_size ()));	1646	/ scrollbar_size ()));
1581	}	1647	}
		1648
1582	break;	1649	break;
1583	}	1650	}
1584	}	1651	}
1585	return;	1652	return;
1586	}	1653	}
…		…
1610	refresh_type &= ~SMOOTH_REFRESH;	1677	refresh_type &= ~SMOOTH_REFRESH;
1611	#endif	1678	#endif
1612		1679
1613	}	1680	}
1614	#ifdef SELECTION_SCROLLING	1681	#ifdef SELECTION_SCROLLING
1615	pending_scroll_selection=0;	1682	if (sel_scroll_ev.active)
		1683	sel_scroll_ev.stop();
1616	#endif	1684	#endif
1617	if (ev.window == TermWin.vt)	1685	if (ev.window == TermWin.vt)
1618	{	1686	{
1619	if (reportmode)	1687	if (reportmode)
1620	{	1688	{
…		…
1662	case Button5:	1730	case Button5:
1663	{	1731	{
1664	int i;	1732	int i;
1665	page_dirn v;	1733	page_dirn v;
1666		1734
1667	v = (ev.button == Button4) ? UP : DN;	1735	v = ev.button == Button4 ? UP : DN;
		1736
1668	if (ev.state & ShiftMask)	1737	if (ev.state & ShiftMask)
1669	i = 1;	1738	i = 1;
1670	else if ((Options & Opt_mouseWheelScrollPage))	1739	else if (Options & Opt_mouseWheelScrollPage)
1671	i = TermWin.nrow - 1;	1740	i = TermWin.nrow - 1;
1672	else	1741	else
1673	i = 5;	1742	i = 5;
		1743
1674	# ifdef MOUSE_SLIP_WHEELING	1744	# ifdef MOUSE_SLIP_WHEELING
1675	if (ev.state & ControlMask)	1745	if (ev.state & ControlMask)
1676	{	1746	{
1677	mouse_slip_wheel_speed += (v ? -1 : 1);	1747	mouse_slip_wheel_speed += v ? -1 : 1;
		1748	if (mouse_slip_wheel_speed < -TermWin.nrow) mouse_slip_wheel_speed = -TermWin.nrow;
		1749	if (mouse_slip_wheel_speed > +TermWin.nrow) mouse_slip_wheel_speed = +TermWin.nrow;
		1750
		1751	if (slip_wheel_ev.at < NOW)
1678	mouse_slip_wheel_delay = SCROLLBAR_CONTINUOUS_DELAY;	1752	slip_wheel_ev.at = NOW + SCROLLBAR_CONTINUOUS_DELAY;
		1753
		1754	slip_wheel_ev.start ();
1679	}	1755	}
		1756	else
		1757	{
1680	# endif	1758	# endif
1681	# ifdef JUMP_MOUSE_WHEEL	1759	# ifdef JUMP_MOUSE_WHEEL
1682	scr_page (v, i);
1683	scr_refresh (SMOOTH_REFRESH);
1684	scrollbar_show (1);
1685	# else
1686	while (i--)
1687	{
1688	scr_page (v, 1);	1760	scr_page (v, i);
1689	scr_refresh (SMOOTH_REFRESH);	1761	scr_refresh (SMOOTH_REFRESH);
1690	scrollbar_show (1);	1762	scrollbar_show (1);
		1763	# else
		1764	while (i--)
		1765	{
		1766	scr_page (v, 1);
		1767	scr_refresh (SMOOTH_REFRESH);
		1768	scrollbar_show (1);
		1769	}
		1770	# endif
		1771	# ifdef MOUSE_SLIP_WHEELING
1691	}	1772	}
1692	# endif	1773	#endif
1693
1694	}	1774	}
1695	break;	1775	break;
1696	#endif	1776	#endif
1697
1698	}	1777	}
1699	}	1778	}
1700	#ifdef MENUBAR	1779	#ifdef MENUBAR
1701	else if (isMenuBarWindow (ev.window))	1780	else if (isMenuBarWindow (ev.window))
1702	menubar_control (ev);	1781	menubar_control (ev);
1703	#endif	1782	#endif
1704	}	1783	}
1705		1784
1706
1707	#ifdef TRANSPARENT	1785	#ifdef TRANSPARENT
		1786	#if TINTING
		1787	/* taken from aterm-0.4.2 */
		1788
		1789	typedef uint32_t RUINT32T;
		1790
		1791	void ShadeXImage(rxvt_display *display, XImage* srcImage, int shade, int rm, int gm, int bm)
		1792	{
		1793	int sh_r, sh_g, sh_b;
		1794	RUINT32T mask_r, mask_g, mask_b;
		1795	RUINT32T *lookup, *lookup_r, *lookup_g, *lookup_b;
		1796	unsigned int lower_lim_r, lower_lim_g, lower_lim_b;
		1797	unsigned int upper_lim_r, upper_lim_g, upper_lim_b;
		1798	int i;
		1799
		1800	Visual* visual = display->visual;
		1801
		1802	if( visual->c_class != TrueColor || srcImage->format != ZPixmap ) return ;
		1803
		1804	/* for convenience */
		1805	mask_r = visual->red_mask;
		1806	mask_g = visual->green_mask;
		1807	mask_b = visual->blue_mask;
		1808
		1809	/* boring lookup table pre-initialization */
		1810	switch (srcImage->bits_per_pixel) {
		1811	case 15:
		1812	if ((mask_r != 0x7c00) ||
		1813	(mask_g != 0x03e0) ||
		1814	(mask_b != 0x001f))
		1815	return;
		1816	lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+32+32));
		1817	lookup_r = lookup;
		1818	lookup_g = lookup+32;
		1819	lookup_b = lookup+32+32;
		1820	sh_r = 10;
		1821	sh_g = 5;
		1822	sh_b = 0;
		1823	break;
		1824	case 16:
		1825	if ((mask_r != 0xf800) ||
		1826	(mask_g != 0x07e0) ||
		1827	(mask_b != 0x001f))
		1828	return;
		1829	lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+64+32));
		1830	lookup_r = lookup;
		1831	lookup_g = lookup+32;
		1832	lookup_b = lookup+32+64;
		1833	sh_r = 11;
		1834	sh_g = 5;
		1835	sh_b = 0;
		1836	break;
		1837	case 24:
		1838	if ((mask_r != 0xff0000) ||
		1839	(mask_g != 0x00ff00) ||
		1840	(mask_b != 0x0000ff))
		1841	return;
		1842	lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256));
		1843	lookup_r = lookup;
		1844	lookup_g = lookup+256;
		1845	lookup_b = lookup+256+256;
		1846	sh_r = 16;
		1847	sh_g = 8;
		1848	sh_b = 0;
		1849	break;
		1850	case 32:
		1851	if ((mask_r != 0xff0000) ||
		1852	(mask_g != 0x00ff00) ||
		1853	(mask_b != 0x0000ff))
		1854	return;
		1855	lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256));
		1856	lookup_r = lookup;
		1857	lookup_g = lookup+256;
		1858	lookup_b = lookup+256+256;
		1859	sh_r = 16;
		1860	sh_g = 8;
		1861	sh_b = 0;
		1862	break;
		1863	default:
		1864	return; /* we do not support this color depth */
		1865	}
		1866
		1867	/* prepare limits for color transformation (each channel is handled separately) */
		1868	if (shade < 0) {
		1869	shade = -shade;
		1870	if (shade < 0) shade = 0;
		1871	if (shade > 100) shade = 100;
		1872
		1873	lower_lim_r = 65535-rm;
		1874	lower_lim_g = 65535-gm;
		1875	lower_lim_b = 65535-bm;
		1876
		1877	lower_lim_r = 65535-(unsigned int)(((RUINT32T)lower_lim_r)*((RUINT32T)shade)/100);
		1878	lower_lim_g = 65535-(unsigned int)(((RUINT32T)lower_lim_g)*((RUINT32T)shade)/100);
		1879	lower_lim_b = 65535-(unsigned int)(((RUINT32T)lower_lim_b)*((RUINT32T)shade)/100);
		1880
		1881	upper_lim_r = upper_lim_g = upper_lim_b = 65535;
		1882	} else {
		1883	if (shade < 0) shade = 0;
		1884	if (shade > 100) shade = 100;
		1885
		1886	lower_lim_r = lower_lim_g = lower_lim_b = 0;
		1887
		1888	upper_lim_r = (unsigned int)((((RUINT32T)rm)*((RUINT32T)shade))/100);
		1889	upper_lim_g = (unsigned int)((((RUINT32T)gm)*((RUINT32T)shade))/100);
		1890	upper_lim_b = (unsigned int)((((RUINT32T)bm)*((RUINT32T)shade))/100);
		1891	}
		1892
		1893	/* switch red and blue bytes if necessary, we need it for some weird XServers like XFree86 3.3.3.1 */
		1894	if ((srcImage->bits_per_pixel == 24) && (mask_r >= 0xFF0000 ))
		1895	{
		1896	unsigned int tmp;
		1897
		1898	tmp = lower_lim_r;
		1899	lower_lim_r = lower_lim_b;
		1900	lower_lim_b = tmp;
		1901
		1902	tmp = upper_lim_r;
		1903	upper_lim_r = upper_lim_b;
		1904	upper_lim_b = tmp;
		1905	}
		1906
		1907	/* fill our lookup tables */
		1908	for (i = 0; i <= mask_r>>sh_r; i++)
		1909	{
		1910	RUINT32T tmp;
		1911	tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_r-lower_lim_r));
		1912	tmp += ((RUINT32T)(mask_r>>sh_r))*((RUINT32T)lower_lim_r);
		1913	lookup_r[i] = (tmp/65535)<<sh_r;
		1914	}
		1915	for (i = 0; i <= mask_g>>sh_g; i++)
		1916	{
		1917	RUINT32T tmp;
		1918	tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_g-lower_lim_g));
		1919	tmp += ((RUINT32T)(mask_g>>sh_g))*((RUINT32T)lower_lim_g);
		1920	lookup_g[i] = (tmp/65535)<<sh_g;
		1921	}
		1922	for (i = 0; i <= mask_b>>sh_b; i++)
		1923	{
		1924	RUINT32T tmp;
		1925	tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_b-lower_lim_b));
		1926	tmp += ((RUINT32T)(mask_b>>sh_b))*((RUINT32T)lower_lim_b);
		1927	lookup_b[i] = (tmp/65535)<<sh_b;
		1928	}
		1929
		1930	/* apply table to input image (replacing colors by newly calculated ones) */
		1931	switch (srcImage->bits_per_pixel)
		1932	{
		1933	case 15:
		1934	{
		1935	unsigned short *p1, *pf, *p, *pl;
		1936	p1 = (unsigned short *) srcImage->data;
		1937	pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
		1938	while (p1 < pf)
		1939	{
		1940	p = p1;
		1941	pl = p1 + srcImage->width;
		1942	for (; p < pl; p++)
		1943	{
		1944	*p = lookup_r[(*p & 0x7c00)>>10] |
		1945	lookup_g[(*p & 0x03e0)>> 5] |
		1946	lookup_b[(*p & 0x001f)];
		1947	}
		1948	p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
		1949	}
		1950	break;
		1951	}
		1952	case 16:
		1953	{
		1954	unsigned short *p1, *pf, *p, *pl;
		1955	p1 = (unsigned short *) srcImage->data;
		1956	pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
		1957	while (p1 < pf)
		1958	{
		1959	p = p1;
		1960	pl = p1 + srcImage->width;
		1961	for (; p < pl; p++)
		1962	{
		1963	*p = lookup_r[(*p & 0xf800)>>11] |
		1964	lookup_g[(*p & 0x07e0)>> 5] |
		1965	lookup_b[(*p & 0x001f)];
		1966	}
		1967	p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
		1968	}
		1969	break;
		1970	}
		1971	case 24:
		1972	{
		1973	unsigned char *p1, *pf, *p, *pl;
		1974	p1 = (unsigned char *) srcImage->data;
		1975	pf = (unsigned char *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
		1976	while (p1 < pf)
		1977	{
		1978	p = p1;
		1979	pl = p1 + srcImage->width * 3;
		1980	for (; p < pl; p += 3)
		1981	{
		1982	p[0] = lookup_r[(p[0] & 0xff0000)>>16];
		1983	p[1] = lookup_r[(p[1] & 0x00ff00)>> 8];
		1984	p[2] = lookup_r[(p[2] & 0x0000ff)];
		1985	}
		1986	p1 = (unsigned char *) ((char *) p1 + srcImage->bytes_per_line);
		1987	}
		1988	break;
		1989	}
		1990	case 32:
		1991	{
		1992	RUINT32T *p1, *pf, *p, *pl;
		1993	p1 = (RUINT32T *) srcImage->data;
		1994	pf = (RUINT32T *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
		1995
		1996	while (p1 < pf)
		1997	{
		1998	p = p1;
		1999	pl = p1 + srcImage->width;
		2000	for (; p < pl; p++)
		2001	{
		2002	*p = lookup_r[(*p & 0xff0000)>>16] |
		2003	lookup_g[(*p & 0x00ff00)>> 8] |
		2004	lookup_b[(*p & 0x0000ff)] |
		2005	(*p & ~0xffffff);
		2006	}
		2007	p1 = (RUINT32T *) ((char *) p1 + srcImage->bytes_per_line);
		2008	}
		2009	break;
		2010	}
		2011	}
		2012
		2013	free (lookup);
		2014	}
		2015	#endif
		2016
1708	/*	2017	/*
1709	* Check our parents are still who we think they are.	2018	* Check our parents are still who we think they are.
1710	* Do transparency updates if required	2019	* Do transparency updates if required
1711	*/	2020	*/
1712	int	2021	int
1713	rxvt_term::check_our_parents ()	2022	rxvt_term::check_our_parents ()
1714	{	2023	{
1715	int i, pchanged, aformat, have_pixmap, rootdepth;	2024	int i, pchanged, aformat, have_pixmap, rootdepth;
1716	unsigned long nitems, bytes_after;	2025	unsigned long nitems, bytes_after;
1717	Atom atype;	2026	Atom atype;
1718	unsigned char *prop = NULL;	2027	unsigned char *prop = NULL;
1719	Window root, oldp, *list;	2028	Window root, oldp, *list;
1720	Pixmap rootpixmap = None;	2029	Pixmap rootpixmap = None;
1721	XWindowAttributes wattr, wrootattr;	2030	XWindowAttributes wattr, wrootattr;
1722		2031
1723	pchanged = 0;	2032	pchanged = 0;
1724		2033
1725	if (! (Options & Opt_transparent))	2034	if (!(Options & Opt_transparent))
1726	return pchanged; /* Don't try any more */	2035	return pchanged; /* Don't try any more */
1727		2036
1728	XGetWindowAttributes (display->display, display->root, &wrootattr);	2037	XGetWindowAttributes (display->display, display->root, &wrootattr);
1729	rootdepth = wrootattr.depth;	2038	rootdepth = wrootattr.depth;
1730		2039
1731	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);	2040	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);
		2041
1732	if (rootdepth != wattr.depth)	2042	if (rootdepth != wattr.depth)
1733	{	2043	{
1734	if (am_transparent)	2044	if (am_transparent)
1735	{	2045	{
1736	pchanged = 1;	2046	pchanged = 1;
1737	XSetWindowBackground (display->display, TermWin.vt,	2047	XSetWindowBackground (display->display, TermWin.vt, PixColorsFocused[Color_bg]);
1738	PixColors[Color_bg]);
1739	am_transparent = am_pixmap_trans = 0;	2048	am_transparent = am_pixmap_trans = 0;
1740	}	2049	}
		2050
1741	return pchanged; /* Don't try any more */	2051	return pchanged; /* Don't try any more */
1742	}	2052	}
1743		2053
1744	/* Get all X ops out of the queue so that our information is up-to-date. */	2054	/* Get all X ops out of the queue so that our information is up-to-date. */
1745	XSync (display->display, False);	2055	XSync (display->display, False);
…		…
1747	/*	2057	/*
1748	* Make the frame window set by the window manager have	2058	* Make the frame window set by the window manager have
1749	* the root background. Some window managers put multiple nested frame	2059	* the root background. Some window managers put multiple nested frame
1750	* windows for each client, so we have to take care about that.	2060	* windows for each client, so we have to take care about that.
1751	*/	2061	*/
1752	i = (xa[XA_XROOTPMAPID] != 0	2062	i = (xa[XA_XROOTPMAPID]
1753	&& (XGetWindowProperty (display->display, display->root, xa[XA_XROOTPMAPID],	2063	&& XGetWindowProperty (display->display, display->root, xa[XA_XROOTPMAPID],
1754	0L, 1L, False, XA_PIXMAP, &atype, &aformat,	2064	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
1755	&nitems, &bytes_after, &prop) == Success));	2065	&nitems, &bytes_after, &prop) == Success);
		2066
1756	if (!i || prop == NULL)	2067	if (!i || prop == NULL)
		2068	i = (xa[XA_XSETROOTID]
		2069	&& XGetWindowProperty (display->display, display->root, xa[XA_XSETROOTID],
		2070	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
		2071	&nitems, &bytes_after, &prop) == Success);
		2072
		2073	if (!i || prop == NULL
		2074	#if TINTING
		2075	|| !rs[Rs_color + Color_tint]
		2076	#endif
		2077	)
1757	have_pixmap = 0;	2078	have_pixmap = 0;
1758	else	2079	else
1759	{	2080	{
1760	have_pixmap = 1;	2081	have_pixmap = 1;
1761	rootpixmap = * ((Pixmap *)prop);	2082	rootpixmap = *(Pixmap *)prop;
1762	XFree (prop);	2083	XFree (prop);
1763	}	2084	}
		2085
1764	if (have_pixmap)	2086	if (have_pixmap)
1765	{	2087	{
1766	/*	2088	/*
1767	* Copy display->root pixmap transparency	2089	* Copy display->root pixmap transparency
1768	*/	2090	*/
…		…
1772	XImage *image;	2094	XImage *image;
1773	GC gc;	2095	GC gc;
1774	XGCValues gcvalue;	2096	XGCValues gcvalue;
1775		2097
1776	XTranslateCoordinates (display->display, TermWin.parent[0], display->root,	2098	XTranslateCoordinates (display->display, TermWin.parent[0], display->root,
1777	0, 0, &sx, &sy, &cr);	2099	0, 0, &sx, &sy, &cr);
1778	nw = (unsigned int)szHint.width;	2100	nw = (unsigned int)szHint.width;
1779	nh = (unsigned int)szHint.height;	2101	nh = (unsigned int)szHint.height;
1780	nx = ny = 0;	2102	nx = ny = 0;
1781		2103
1782	if (sx < 0)	2104	if (sx < 0)
…		…
1794	}	2116	}
1795		2117
1796	MIN_IT (nw, (unsigned int) (wrootattr.width - sx));	2118	MIN_IT (nw, (unsigned int) (wrootattr.width - sx));
1797	MIN_IT (nh, (unsigned int) (wrootattr.height - sy));	2119	MIN_IT (nh, (unsigned int) (wrootattr.height - sy));
1798	allowedxerror = -1;	2120	allowedxerror = -1;
1799	image = XGetImage (display->display, rootpixmap, sx, sy, nw, nh, AllPlanes,	2121	image = XGetImage (display->display, rootpixmap, sx, sy, nw, nh, AllPlanes, ZPixmap);
1800	ZPixmap);	2122
1801	/* XXX: handle BadMatch - usually because we're outside the pixmap */	2123	/* XXX: handle BadMatch - usually because we're outside the pixmap */
1802	/* XXX: may need a delay here? */	2124	/* XXX: may need a delay here? */
1803	allowedxerror = 0;	2125	allowedxerror = 0;
		2126
1804	if (image == NULL)	2127	if (image == NULL)
1805	{	2128	{
1806	if (am_transparent && am_pixmap_trans)	2129	if (am_transparent && am_pixmap_trans)
1807	{	2130	{
1808	pchanged = 1;	2131	pchanged = 1;
…		…
1810	{	2133	{
1811	XFreePixmap (display->display, TermWin.pixmap);	2134	XFreePixmap (display->display, TermWin.pixmap);
1812	TermWin.pixmap = None;	2135	TermWin.pixmap = None;
1813	}	2136	}
1814	}	2137	}
		2138
1815	am_pixmap_trans = 0;	2139	am_pixmap_trans = 0;
1816	}	2140	}
1817	else	2141	else
1818	{	2142	{
1819	if (TermWin.pixmap != None)	2143	if (TermWin.pixmap != None)
1820	XFreePixmap (display->display, TermWin.pixmap);	2144	XFreePixmap (display->display, TermWin.pixmap);
		2145
		2146	#if TINTING
		2147	if (ISSET_PIXCOLOR (Color_tint))
		2148	{
		2149	unsigned short rm, gm, bm;
		2150	int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;
		2151
		2152	PixColorsFocused[Color_tint].get (display, rm, gm, bm);
		2153
		2154	ShadeXImage (display, image, shade, rm, gm, bm);
		2155	}
		2156	#endif
		2157
1821	TermWin.pixmap = XCreatePixmap (display->display, TermWin.vt,	2158	TermWin.pixmap = XCreatePixmap (display->display, TermWin.vt,
1822	(unsigned int)szHint.width,
1823	(unsigned int)szHint.height,	2159	szHint.width, szHint.height, image->depth);
1824	(unsigned int)image->depth);
1825	gc = XCreateGC (display->display, TermWin.vt, 0UL, &gcvalue);	2160	gc = XCreateGC (display->display, TermWin.vt, 0UL, &gcvalue);
1826	XPutImage (display->display, TermWin.pixmap, gc, image, 0, 0,	2161	XPutImage (display->display, TermWin.pixmap, gc, image, 0, 0,
1827	nx, ny, (unsigned int)image->width,
1828	(unsigned int)image->height);	2162	nx, ny, image->width, image->height);
1829	XFreeGC (display->display, gc);	2163	XFreeGC (display->display, gc);
1830	XDestroyImage (image);	2164	XDestroyImage (image);
1831	XSetWindowBackgroundPixmap (display->display, TermWin.vt,	2165	XSetWindowBackgroundPixmap (display->display, TermWin.parent[0], TermWin.pixmap);
1832	TermWin.pixmap);	2166	XClearWindow (display->display, TermWin.parent[0]);
		2167
1833	if (!am_transparent || !am_pixmap_trans)	2168	if (!am_transparent || !am_pixmap_trans)
1834	pchanged = 1;	2169	pchanged = 1;
		2170
1835	am_transparent = am_pixmap_trans = 1;	2171	am_transparent = am_pixmap_trans = 1;
1836	}	2172	}
1837	}	2173	}
1838		2174
1839	if (!am_pixmap_trans)	2175	if (!am_pixmap_trans)
1840	{	2176	{
1841	unsigned int n;	2177	unsigned int n;
1842	/*	2178	/*
1843	* InheritPixmap transparency	2179	* InheritPixmap transparency
1844	*/	2180	*/
1845	D_X ((stderr, "InheritPixmap Seeking to %08lx", display->root));	2181	D_X ((stderr, "InheritPixmap Seeking to %08lx", display->root));
1846	for (i = 1; i < (int) (sizeof (TermWin.parent) / sizeof (Window));	2182	for (i = 1; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
1847	i++)
1848	{	2183	{
1849	oldp = TermWin.parent[i];	2184	oldp = TermWin.parent[i];
1850	XQueryTree (display->display, TermWin.parent[i - 1], &root,	2185	XQueryTree (display->display, TermWin.parent[i - 1], &root,
1851	&TermWin.parent[i], &list, &n);	2186	&TermWin.parent[i], &list, &n);
1852	XFree (list);	2187	XFree (list);
1853	D_X ((stderr, "InheritPixmap Parent[%d] = %08lx", i, TermWin.parent[i]));	2188	D_X ((stderr, "InheritPixmap Parent[%d] = %08lx", i, TermWin.parent[i]));
		2189
1854	if (TermWin.parent[i] == display->root)	2190	if (TermWin.parent[i] == display->root)
1855	{	2191	{
1856	if (oldp != None)	2192	if (oldp != None)
1857	pchanged = 1;	2193	pchanged = 1;
		2194
1858	break;	2195	break;
1859	}	2196	}
		2197
1860	if (oldp != TermWin.parent[i])	2198	if (oldp != TermWin.parent[i])
1861	pchanged = 1;	2199	pchanged = 1;
1862	}	2200	}
1863		2201
1864	n = 0;	2202	n = 0;
…		…
1875	break;	2213	break;
1876	}	2214	}
1877	}	2215	}
1878	}	2216	}
1879		2217
1880	if (n > (int) (sizeof (TermWin.parent)	2218	if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0])))
1881	/ sizeof (TermWin.parent[0])))
1882	{	2219	{
1883	D_X ((stderr, "InheritPixmap Turning off"));	2220	D_X ((stderr, "InheritPixmap Turning off"));
1884	XSetWindowBackground (display->display, TermWin.parent[0],	2221	XSetWindowBackground (display->display, TermWin.parent[0], PixColorsFocused[Color_fg]);
1885	PixColors[Color_fg]);
1886	XSetWindowBackground (display->display, TermWin.vt,	2222	XSetWindowBackground (display->display, TermWin.vt, PixColorsFocused[Color_bg]);
1887	PixColors[Color_bg]);
1888	am_transparent = 0;	2223	am_transparent = 0;
1889	/* XXX: also turn off Opt_transparent? */	2224	/* XXX: also turn off Opt_transparent? */
1890	}	2225	}
1891	else	2226	else
1892	{	2227	{
		2228	#if WAIT_FOR_WM
1893	/* wait (an arbitrary period) for the WM to do its thing	2229	/* wait (an arbitrary period) for the WM to do its thing
1894	* needed for fvwm2.2.2 (and before?) */	2230	* needed for fvwm2.2.2 (and before?) */
1895	# ifdef HAVE_NANOSLEEP
1896	struct timespec rqt;
1897
1898	rqt.tv_sec = 1;
1899	rqt.tv_nsec = 0;
1900	nanosleep (&rqt, NULL);
1901	# else
1902	sleep (1);	2231	sleep (1);
1903	# endif	2232	#endif
1904	D_X ((stderr, "InheritPixmap Turning on (%d parents)", i - 1));	2233	D_X ((stderr, "InheritPixmap Turning on (%d parents)", i - 1));
1905	for (n = 0; n < (unsigned int)i; n++)	2234	for (n = 0; n < (unsigned int)i; n++)
		2235	{
1906	XSetWindowBackgroundPixmap (display->display, TermWin.parent[n],	2236	XSetWindowBackgroundPixmap (display->display, TermWin.parent[n], ParentRelative);
1907	ParentRelative);	2237	XClearWindow (display->display, TermWin.parent[n]);
		2238	}
		2239
1908	XSetWindowBackgroundPixmap (display->display, TermWin.vt,	2240	XSetWindowBackgroundPixmap (display->display, TermWin.vt, ParentRelative);
1909	ParentRelative);
1910	am_transparent = 1;	2241	am_transparent = 1;
1911	}	2242	}
1912		2243
1913	for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)	2244	for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
1914	TermWin.parent[i] = None;	2245	TermWin.parent[i] = None;
1915	}	2246	}
		2247
		2248	// this is experimental
		2249	if (scrollBar.win)
		2250	{
		2251	XSetWindowBackgroundPixmap (display->display, scrollBar.win, ParentRelative);
		2252	XClearWindow (display->display, scrollBar.win);
		2253	scrollBar.setIdle ();
		2254	scrollbar_show (0);
		2255	}
		2256
1916	return pchanged;	2257	return pchanged;
1917	}	2258	}
1918	#endif	2259	#endif
1919		2260
1920	/*}}} */	2261	/*}}} */
…		…
1935	}	2276	}
1936		2277
1937	if (ch == NOCHAR) // TODO: improve	2278	if (ch == NOCHAR) // TODO: improve
1938	break;	2279	break;
1939		2280
1940	if (!IS_CONTROL (ch) || ch == '\t' || ch == '\n' || ch == '\r')	2281	if (!IS_CONTROL (ch) || ch == C0_LF || ch == C0_CR || ch == C0_HT)
1941	{	2282	{
1942	/* Read a text string from the input buffer */	2283	/* Read a text string from the input buffer */
1943	unicode_t buf[UBUFSIZ];	2284	unicode_t buf[UBUFSIZ];
1944	bool refreshnow = false;	2285	bool refreshnow = false;
1945	int nlines = 0;	2286	int nlines = 0;
1946	unicode_t *str = buf;	2287	unicode_t *str = buf;
1947		2288
1948	*str++ = ch;
1949
1950	for (;;)	2289	for (;;)
1951	{	2290	{
1952	seq_begin = cmdbuf_ptr;
1953	ch = next_char ();
1954
1955	if (ch == NOCHAR || (IS_CONTROL (ch) && ch != '\t' && ch != '\n' && ch != '\r'))	2291	if (ch == NOCHAR || (IS_CONTROL (ch) && ch != C0_LF && ch != C0_CR && ch != C0_HT))
1956	break;	2292	break;
1957		2293
1958	*str++ = ch;	2294	*str++ = ch;
1959		2295
1960	if (ch == '\n')	2296	if (ch == C0_LF)
1961	{	2297	{
1962	nlines++;	2298	nlines++;
1963	refresh_count++;	2299	refresh_count++;
1964		2300
1965	if (! (Options & Opt_jumpScroll)	2301	if (!(Options & Opt_jumpScroll)
1966	|| (refresh_count >= (refresh_limit * (TermWin.nrow - 1))))	2302	|| (refresh_count >= refresh_limit * (TermWin.nrow - 1)))
1967	{	2303	{
1968	refreshnow = true;	2304	refreshnow = true;
1969	flag = true;
1970	ch = NOCHAR;	2305	ch = NOCHAR;
1971	break;	2306	break;
1972	}	2307	}
1973		2308
1974	// scr_add_lines only works for nlines < TermWin.nrow - 1.	2309	// scr_add_lines only works for nlines <= TermWin.nrow - 1.
1975	if (nlines >= TermWin.nrow - 1)	2310	if (nlines >= TermWin.nrow - 1)
1976	{	2311	{
1977	scr_add_lines (buf, nlines, str - buf);	2312	scr_add_lines (buf, nlines, str - buf);
1978	nlines = 0;	2313	nlines = 0;
1979	str = buf;	2314	str = buf;
…		…
1983	if (str >= buf + UBUFSIZ)	2318	if (str >= buf + UBUFSIZ)
1984	{	2319	{
1985	ch = NOCHAR;	2320	ch = NOCHAR;
1986	break;	2321	break;
1987	}	2322	}
		2323
		2324	seq_begin = cmdbuf_ptr;
		2325	ch = next_char ();
1988	}	2326	}
1989		2327
1990	scr_add_lines (buf, nlines, str - buf);	2328	scr_add_lines (buf, nlines, str - buf);
1991		2329
1992	/*	2330	/*
1993	* If there have been a lot of new lines, then update the screen	2331	* If there have been a lot of new lines, then update the screen
1994	* What the heck I'll cheat and only refresh less than every page-full.	2332	* What the heck I'll cheat and only refresh less than every page-full.
1995	* the number of pages between refreshes is refresh_limit, which	2333	* the number of pages between refreshes is refresh_limit, which
1996	* is incremented here because we must be doing flat-out scrolling.	2334	* is incremented here because we must be doing flat-out scrolling.
1997	*
1998	* refreshing should be correct for small scrolls, because of the
1999	* time-out
2000	*/	2335	*/
2001	if (refreshnow)	2336	if (refreshnow)
2002	{	2337	{
2003	if ((Options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)	2338	if ((Options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)
2004	refresh_limit++;	2339	refresh_limit++;
2005		2340	else
		2341	{
		2342	flag = true;
2006	scr_refresh (refresh_type);	2343	scr_refresh (refresh_type);
		2344	}
2007	}	2345	}
2008		2346
2009	}	2347	}
2010	else	2348	else
2011	{	2349	{
…		…
2025	}	2363	}
2026		2364
2027	return flag;	2365	return flag;
2028	}	2366	}
2029		2367
		2368	// read the next octet
		2369	unicode_t
		2370	rxvt_term::next_octet ()
		2371	{
		2372	return cmdbuf_ptr < cmdbuf_endp
		2373	? *cmdbuf_ptr++
		2374	: NOCHAR;
		2375	}
		2376
2030	// read the next character	2377	// read the next character
2031	unicode_t	2378	unicode_t
2032	rxvt_term::next_char ()	2379	rxvt_term::next_char ()
2033	{	2380	{
2034	while (cmdbuf_ptr < cmdbuf_endp)	2381	while (cmdbuf_ptr < cmdbuf_endp)
…		…
2065	*/	2412	*/
2066	unicode_t	2413	unicode_t
2067	rxvt_term::cmd_getc ()	2414	rxvt_term::cmd_getc ()
2068	{	2415	{
2069	unicode_t c = next_char ();	2416	unicode_t c = next_char ();
		2417
		2418	if (c == NOCHAR)
		2419	throw out_of_input;
		2420
		2421	return c;
		2422	}
		2423
		2424	unicode_t
		2425	rxvt_term::cmd_get8 ()
		2426	{
		2427	unicode_t c = next_octet ();
2070		2428
2071	if (c == NOCHAR)	2429	if (c == NOCHAR)
2072	throw out_of_input;	2430	throw out_of_input;
2073		2431
2074	return c;	2432	return c;
…		…
2156	/*}}} */	2514	/*}}} */
2157		2515
2158	/* *INDENT-OFF* */	2516	/* *INDENT-OFF* */
2159	enum {	2517	enum {
2160	C1_40 = 0x40,	2518	C1_40 = 0x40,
2161	C1_41 , C1_BPH, C1_NBH, C1_44 , C1_NEL, C1_SSA, C1_ESA,	2519	C1_41 , C1_BPH, C1_NBH, C1_44 , C1_NEL, C1_SSA, C1_ESA,
2162	C1_HTS, C1_HTJ, C1_VTS, C1_PLD, C1_PLU, C1_RI , C1_SS2, C1_SS3,	2520	C1_HTS, C1_HTJ, C1_VTS, C1_PLD, C1_PLU, C1_RI , C1_SS2, C1_SS3,
2163	C1_DCS, C1_PU1, C1_PU2, C1_STS, C1_CCH, C1_MW , C1_SPA, C1_EPA,	2521	C1_DCS, C1_PU1, C1_PU2, C1_STS, C1_CCH, C1_MW , C1_SPA, C1_EPA,
2164	C1_SOS, C1_59 , C1_SCI, C1_CSI, CS_ST , C1_OSC, C1_PM , C1_APC	2522	C1_SOS, C1_59 , C1_SCI, C1_CSI, CS_ST , C1_OSC, C1_PM , C1_APC,
2165	};	2523	};
2166	/* *INDENT-ON* */	2524	/* *INDENT-ON* */
2167		2525
2168	/*{{{ process non-printing single characters */	2526	/*{{{ process non-printing single characters */
2169	void	2527	void
…		…
2174	case C0_ESC:	2532	case C0_ESC:
2175	process_escape_seq ();	2533	process_escape_seq ();
2176	break;	2534	break;
2177	case C0_ENQ: /* terminal Status */	2535	case C0_ENQ: /* terminal Status */
2178	if (rs[Rs_answerbackstring])	2536	if (rs[Rs_answerbackstring])
2179	tt_write (
2180	(const unsigned char *)rs[Rs_answerbackstring],	2537	tt_write ((const unsigned char *)rs[Rs_answerbackstring],
2181	(unsigned int)STRLEN (rs[Rs_answerbackstring]));	2538	(unsigned int)STRLEN (rs[Rs_answerbackstring]));
2182	else	2539	else
2183	tt_write ((unsigned char *)VT100_ANS,	2540	tt_write ((unsigned char *)VT100_ANS,
2184	(unsigned int)STRLEN (VT100_ANS));	2541	(unsigned int)STRLEN (VT100_ANS));
2185	break;	2542	break;
2186	case C0_BEL: /* bell */	2543	case C0_BEL: /* bell */
2187	scr_bell ();	2544	scr_bell ();
2188	break;	2545	break;
2189	case C0_BS: /* backspace */	2546	case C0_BS: /* backspace */
…		…
2205	break;	2562	break;
2206	case C0_SI: /* shift in - acs */	2563	case C0_SI: /* shift in - acs */
2207	scr_charset_choose (0);	2564	scr_charset_choose (0);
2208	break;	2565	break;
2209		2566
		2567	#ifdef EIGHT_BIT_CONTROLS
2210	// 8-bit controls	2568	// 8-bit controls
2211	case 0x90: /* DCS */	2569	case 0x90: /* DCS */
2212	process_dcs_seq ();	2570	process_dcs_seq ();
2213	break;	2571	break;
2214	case 0x9b: /* CSI */	2572	case 0x9b: /* CSI */
2215	process_csi_seq ();	2573	process_csi_seq ();
2216	break;	2574	break;
2217	case 0x9d: /* CSI */	2575	case 0x9d: /* CSI */
2218	process_osc_seq ();	2576	process_osc_seq ();
2219	break;	2577	break;
		2578	#endif
2220	}	2579	}
2221	}	2580	}
2222	/*}}} */	2581	/*}}} */
2223		2582
2224		2583
…		…
2342	break;	2701	break;
2343		2702
2344	/* 8.3.87: NEXT LINE */	2703	/* 8.3.87: NEXT LINE */
2345	case C1_NEL: /* ESC E */	2704	case C1_NEL: /* ESC E */
2346	{	2705	{
2347	unicode_t nlcr[] = { L'\n', L'\r' };	2706	unicode_t nlcr[] = { C0_LF, C0_CR };
2348	scr_add_lines (nlcr, 1, 2);	2707	scr_add_lines (nlcr, 1, 2);
2349	}	2708	}
2350	break;	2709	break;
2351		2710
2352	/* kidnapped escape sequence: Should be 8.3.48 */	2711	/* kidnapped escape sequence: Should be 8.3.48 */
…		…
2363	case C1_RI: /* ESC M */	2722	case C1_RI: /* ESC M */
2364	scr_index (DN);	2723	scr_index (DN);
2365	break;	2724	break;
2366		2725
2367	/* 8.3.142: SINGLE-SHIFT TWO */	2726	/* 8.3.142: SINGLE-SHIFT TWO */
2368	/*case C1_SS2: scr_single_shift (2); break; */	2727	/*case C1_SS2: scr_single_shift (2); break; */
2369		2728
2370	/* 8.3.143: SINGLE-SHIFT THREE */	2729	/* 8.3.143: SINGLE-SHIFT THREE */
2371	/*case C1_SS3: scr_single_shift (3); break; */	2730	/*case C1_SS3: scr_single_shift (3); break; */
2372		2731
2373	/* 8.3.27: DEVICE CONTROL STRING */	2732	/* 8.3.27: DEVICE CONTROL STRING */
2374	case C1_DCS: /* ESC P */	2733	case C1_DCS: /* ESC P */
2375	process_dcs_seq ();	2734	process_dcs_seq ();
2376	break;	2735	break;
…		…
2391	process_osc_seq ();	2750	process_osc_seq ();
2392	break;	2751	break;
2393		2752
2394	/* 8.3.106: RESET TO INITIAL STATE */	2753	/* 8.3.106: RESET TO INITIAL STATE */
2395	case 'c':	2754	case 'c':
		2755	mbstate.reset ();
2396	scr_poweron ();	2756	scr_poweron ();
2397	scrollbar_show (1);	2757	scrollbar_show (1);
2398	break;	2758	break;
2399		2759
2400	/* 8.3.79: LOCKING-SHIFT TWO (see ISO2022) */	2760	/* 8.3.79: LOCKING-SHIFT TWO (see ISO2022) */
…		…
2412		2772
2413	/*{{{ process CONTROL SEQUENCE INTRODUCER (CSI) sequences `ESC[' */	2773	/*{{{ process CONTROL SEQUENCE INTRODUCER (CSI) sequences `ESC[' */
2414	/* *INDENT-OFF* */	2774	/* *INDENT-OFF* */
2415	enum {	2775	enum {
2416	CSI_ICH = 0x40,	2776	CSI_ICH = 0x40,
2417	CSI_CUU, CSI_CUD, CSI_CUF, CSI_CUB, CSI_CNL, CSI_CPL, CSI_CHA,	2777	CSI_CUU, CSI_CUD, CSI_CUF, CSI_CUB, CSI_CNL, CSI_CPL, CSI_CHA,
2418	CSI_CUP, CSI_CHT, CSI_ED , CSI_EL , CSI_IL , CSI_DL , CSI_EF , CSI_EA ,	2778	CSI_CUP, CSI_CHT, CSI_ED , CSI_EL , CSI_IL , CSI_DL , CSI_EF , CSI_EA ,
2419	CSI_DCH, CSI_SEE, CSI_CPR, CSI_SU , CSI_SD , CSI_NP , CSI_PP , CSI_CTC,	2779	CSI_DCH, CSI_SEE, CSI_CPR, CSI_SU , CSI_SD , CSI_NP , CSI_PP , CSI_CTC,
2420	CSI_ECH, CSI_CVT, CSI_CBT, CSI_SRS, CSI_PTX, CSI_SDS, CSI_SIMD, CSI_5F,	2780	CSI_ECH, CSI_CVT, CSI_CBT, CSI_SRS, CSI_PTX, CSI_SDS, CSI_SIMD, CSI_5F,
2421	CSI_HPA, CSI_HPR, CSI_REP, CSI_DA , CSI_VPA, CSI_VPR, CSI_HVP, CSI_TBC,	2781	CSI_HPA, CSI_HPR, CSI_REP, CSI_DA , CSI_VPA, CSI_VPR, CSI_HVP, CSI_TBC,
2422	CSI_SM , CSI_MC , CSI_HPB, CSI_VPB, CSI_RM , CSI_SGR, CSI_DSR, CSI_DAQ,	2782	CSI_SM , CSI_MC , CSI_HPB, CSI_VPB, CSI_RM , CSI_SGR, CSI_DSR, CSI_DAQ,
…		…
2437	make_byte (1,0,1,1,1,1,1,0), /* P, Q, R, S, T, U, V, W, */	2797	make_byte (1,0,1,1,1,1,1,0), /* P, Q, R, S, T, U, V, W, */
2438	make_byte (1,1,1,0,0,0,1,0), /* X, Y, Z, [, \, ], ^, _, */	2798	make_byte (1,1,1,0,0,0,1,0), /* X, Y, Z, [, \, ], ^, _, */
2439	make_byte (1,1,1,0,1,1,1,0), /* `, a, b, c, d, e, f, g, */	2799	make_byte (1,1,1,0,1,1,1,0), /* `, a, b, c, d, e, f, g, */
2440	make_byte (0,0,1,1,0,0,0,0), /* h, i, j, k, l, m, n, o, */	2800	make_byte (0,0,1,1,0,0,0,0), /* h, i, j, k, l, m, n, o, */
2441	make_byte (0,0,0,0,0,0,0,0), /* p, q, r, s, t, u, v, w, */	2801	make_byte (0,0,0,0,0,0,0,0), /* p, q, r, s, t, u, v, w, */
2442	make_byte (0,0,0,0,0,0,0,0) /* x, y, z, {, |, }, ~, */	2802	make_byte (0,0,0,0,0,0,0,0), /* x, y, z, {, |, }, ~, */
2443	};	2803	};
2444	/* *INDENT-ON* */	2804	/* *INDENT-ON* */
2445		2805
2446	void	2806	void
2447	rxvt_term::process_csi_seq ()	2807	rxvt_term::process_csi_seq ()
…		…
2646	tt_printf ("\033[0n");	3006	tt_printf ("\033[0n");
2647	break;	3007	break;
2648	case 6: /* CPR requested */	3008	case 6: /* CPR requested */
2649	scr_report_position ();	3009	scr_report_position ();
2650	break;	3010	break;
2651	#if defined (ENABLE_DISPLAY_ANSWER)
2652	case 7: /* unofficial extension */	3011	case 7: /* unofficial extension */
		3012	if (Options & Opt_insecure)
2653	tt_printf ("%-.250s\n", rs[Rs_display_name]);	3013	tt_printf ("%-.250s\n", rs[Rs_display_name]);
2654	break;	3014	break;
2655	#endif
2656	case 8: /* unofficial extension */	3015	case 8: /* unofficial extension */
2657	xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);	3016	process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);
2658	break;	3017	break;
2659	}	3018	}
2660	break;	3019	break;
2661		3020
2662	case CSI_TBC: /* 8.3.155: (0) TABULATION CLEAR */	3021	case CSI_TBC: /* 8.3.155: (0) TABULATION CLEAR */
…		…
2800	tt_printf ("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);	3159	tt_printf ("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);
2801	break;	3160	break;
2802	case 13: /* report window position */	3161	case 13: /* report window position */
2803	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);	3162	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);
2804	XTranslateCoordinates (display->display, TermWin.parent[0], wattr.root,	3163	XTranslateCoordinates (display->display, TermWin.parent[0], wattr.root,
2805	-wattr.border_width, -wattr.border_width,	3164	-wattr.border_width, -wattr.border_width,
2806	&x, &y, &wdummy);	3165	&x, &y, &wdummy);
2807	tt_printf ("\033[3;%d;%dt", x, y);	3166	tt_printf ("\033[3;%d;%dt", x, y);
2808	break;	3167	break;
2809	case 14: /* report window size (pixels) */	3168	case 14: /* report window size (pixels) */
2810	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);	3169	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);
2811	tt_printf ("\033[4;%d;%dt", wattr.height, wattr.width);	3170	tt_printf ("\033[4;%d;%dt", wattr.height, wattr.width);
…		…
2814	tt_printf ("\033[8;%d;%dt", TermWin.nrow, TermWin.ncol);	3173	tt_printf ("\033[8;%d;%dt", TermWin.nrow, TermWin.ncol);
2815	break;	3174	break;
2816	case 19: /* report window size (chars) */	3175	case 19: /* report window size (chars) */
2817	tt_printf ("\033[9;%d;%dt", TermWin.nrow, TermWin.ncol);	3176	tt_printf ("\033[9;%d;%dt", TermWin.nrow, TermWin.ncol);
2818	break;	3177	break;
2819	#if 0 /* XXX: currently disabled due to security concerns */
2820	case 20: /* report icon label */	3178	case 20: /* report icon label */
		3179	if (Options & Opt_insecure)
		3180	{
		3181	char *s;
2821	XGetIconName (display->display, TermWin.parent[0], &s);	3182	XGetIconName (display->display, TermWin.parent[0], &s);
2822	tt_printf ("\033]L%-.200s\234", s ? s : ""); /* 8bit ST */	3183	tt_printf ("\033]L%-.200s\234", s ? s : ""); /* 8bit ST */
		3184	}
2823	break;	3185	break;
2824	case 21: /* report window title */	3186	case 21: /* report window title */
		3187	if (Options & Opt_insecure)
		3188	{
		3189	char *s;
2825	XFetchName (display->display, TermWin.parent[0], &s);	3190	XFetchName (display->display, TermWin.parent[0], &s);
2826	tt_printf ("\033]l%-.200s\234", s ? s : ""); /* 8bit ST */	3191	tt_printf ("\033]l%-.200s\234", s ? s : ""); /* 8bit ST */
		3192	}
2827	break;	3193	break;
2828	#endif
2829	}	3194	}
2830	}	3195	}
2831	#endif	3196	#endif
2832		3197
2833	/*----------------------------------------------------------------------*/	3198	/*----------------------------------------------------------------------*/
2834	/*	3199	/*
2835	* get input up until STRING TERMINATOR (or BEL)	3200	* get input up until STRING TERMINATOR (or BEL)
2836	* ends_how is terminator used. returned input must be free ()d	3201	* ends_how is terminator used. returned input must be free()'d
2837	*/	3202	*/
2838	unsigned char *	3203	unsigned char *
2839	rxvt_term::get_to_st (unicode_t &ends_how)	3204	rxvt_term::get_to_st (unicode_t &ends_how)
2840	{	3205	{
2841	int seen_esc = 0; /* seen escape? */	3206	unicode_t prev = 0, ch;
2842	unsigned int n = 0;	3207	unsigned int n = 0;
2843	unsigned char *s;	3208	unsigned char *s;
2844	unicode_t ch;
2845	unsigned char string[STRING_MAX];	3209	unsigned char string[STRING_MAX];
2846		3210
2847	while ((ch = cmd_getc ()))	3211	while ((ch = cmd_getc ()) != NOCHAR)
2848	{	3212	{
2849	if (ch == C0_BEL
2850	|| ch == CHAR_ST
2851	|| (ch == 0x5c && seen_esc)) /* 7bit ST */
2852	break;
2853
2854	if (ch == C0_ESC)	3213	if (prev == C0_ESC)
2855	{
2856	seen_esc = 1;
2857	continue;
2858	}	3214	{
2859	else if (ch == '\t')	3215	if (ch == 0x5c) /* 7bit ST */
2860	ch = ' '; /* translate '\t' to space */	3216	break;
2861	else if (ch < 0x08 || (ch > 0x0d && ch < 0x20))	3217	else
		3218	return NULL;
		3219	}
		3220	else if (ch == C0_BEL || ch == CHAR_ST)
		3221	break;
		3222	else if (ch < 0x20)
2862	return NULL; /* other control character - exit */	3223	return NULL; /* other control character - exit */
2863		3224
2864	if (n < sizeof (string) - 1)	3225	if (n >= sizeof (string) - 1)
		3226	// stop at some sane length
		3227	return NULL;
		3228
		3229	if (ch == C0_SYN)
		3230	{
		3231	string[n++] = cmd_get8 ();
		3232	prev = 0;
		3233	}
		3234	else
2865	string[n++] = ch;	3235	string[n++] = prev = ch;
2866
2867	seen_esc = 0;
2868	}	3236	}
2869		3237
2870	string[n++] = '\0';	3238	string[n++] = '\0';
2871		3239
2872	if ((s = (unsigned char *)rxvt_malloc (n)) == NULL)	3240	if ((s = (unsigned char *)rxvt_malloc (n)) == NULL)
…		…
2915	{	3283	{
2916	unsigned char *s = get_to_st (eh);	3284	unsigned char *s = get_to_st (eh);
2917		3285
2918	if (s)	3286	if (s)
2919	{	3287	{
2920	/*
2921	* rxvt_menubar_dispatch () violates the constness of the string,
2922	* so do it here
2923	*/
2924	if (arg == XTerm_Menu)
2925	#if 0 /* XXX: currently disabled due to security concerns */
2926	menubar_dispatch ((char *)s);
2927	#else
2928	(void)0;
2929	#endif
2930	else
2931	xterm_seq (arg, (char *)s, eh);	3288	process_xterm_seq (arg, (char *)s, eh);
2932
2933	free (s);	3289	free (s);
2934	}	3290	}
2935	}	3291	}
2936	}	3292	}
		3293
		3294	void
		3295	rxvt_term::process_color_seq (int report, int color, const char *str, unsigned char resp)
		3296	{
		3297	if (str[0] == '?' && !str[1])
		3298	{
		3299	if (Options & Opt_insecure)
		3300	{
		3301	unsigned short r, g, b;
		3302	PixColorsFocused[color].get (display, r, g, b);
		3303	tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, r, g, b, resp);
		3304	}
		3305	}
		3306	else
		3307	set_window_color (color, str);
		3308	}
		3309
2937	/*	3310	/*
2938	* XTerm escape sequences: ESC ] Ps;Pt (ST|BEL)	3311	* XTerm escape sequences: ESC ] Ps;Pt (ST|BEL)
2939	* 0 = change iconName/title	3312	* 0 = change iconName/title
2940	* 1 = change iconName	3313	* 1 = change iconName
2941	* 2 = change title	3314	* 2 = change title
2942	* 4 = change color	3315	* 4 = change color
		3316	* 10 = change fg color
		3317	* 11 = change bg color
2943	* 12 = change text color	3318	* 12 = change text color
2944	* 13 = change mouse foreground color	3319	* 13 = change mouse foreground color
2945	* 17 = change highlight character colour	3320	* 17 = change highlight character colour
2946	* 18 = change bold character color	3321	* 18 = change bold character color
2947	* 19 = change underlined character color	3322	* 19 = change underlined character color
2948	* 46 = change logfile (not implemented)	3323	* 46 = change logfile (not implemented)
2949	* 50 = change font	3324	* 50 = change font
2950	*	3325	*
2951	* rxvt extensions:	3326	* rxvt extensions:
2952	* 10 = menu (may change in future)
2953	* 20 = bg pixmap	3327	* 20 = bg pixmap
2954	* 39 = change default fg color	3328	* 39 = change default fg color
2955	* 49 = change default bg color	3329	* 49 = change default bg color
2956	* 55 = dump scrollback buffer and all of screen	3330	* 55 = dump scrollback buffer and all of screen
2957	* 701 = change locale	3331	* 701 = change locale
2958	* 702 = find font	3332	* 702 = find font
		3333	* 703 = menu
2959	*/	3334	*/
2960	void	3335	void
2961	rxvt_term::xterm_seq (int op, const char *str, unsigned char resp __attribute__ ((unused)))	3336	rxvt_term::process_xterm_seq (int op, const char *str, unsigned char resp)
2962	{	3337	{
2963	int changed = 0;	3338	int changed = 0;
2964	int color;	3339	int color;
2965	char *buf, *name;	3340	char *buf, *name;
		3341	bool query = str[0] == '?' && !str[1];
2966		3342
2967	assert (str != NULL);	3343	assert (str != NULL);
2968	switch (op)	3344	switch (op)
2969	{	3345	{
2970	case XTerm_name:	3346	case XTerm_name:
…		…
2974	set_icon_name (str);	3350	set_icon_name (str);
2975	break;	3351	break;
2976	case XTerm_title:	3352	case XTerm_title:
2977	set_title (str);	3353	set_title (str);
2978	break;	3354	break;
		3355	case XTerm_property:
		3356	if (str[0] == '?')
		3357	{
		3358	Atom prop = XInternAtom (display->display, str + 1, True);
		3359	Atom actual_type;
		3360	int actual_format;
		3361	unsigned long nitems;
		3362	unsigned long bytes_after;
		3363	unsigned char *value = 0;
		3364	const char *str = "";
		3365
		3366	if (prop
		3367	&& XGetWindowProperty (display->display, TermWin.parent[0],
		3368	prop, 0, 1<<16, 0, AnyPropertyType,
		3369	&actual_type, &actual_format,
		3370	&nitems, &bytes_after, &value) == Success
		3371	&& actual_type != None
		3372	&& actual_format == 8)
		3373	str = (const char *)(value);
		3374
		3375	tt_printf ("\033]%d;%s%c", XTerm_property, str, resp);
		3376
		3377	XFree (value);
		3378	}
		3379	else
		3380	{
		3381	char *eq = strchr (str, '='); // constness lost, but verified to be ok
		3382
		3383	if (eq)
		3384	{
		3385	*eq = 0;
		3386	XChangeProperty (display->display, TermWin.parent[0],
		3387	display->atom (str), XA_STRING, 8,
		3388	PropModeReplace, (unsigned char *)eq + 1,
		3389	strlen (eq + 1));
		3390	}
		3391	else
		3392	XDeleteProperty (display->display, TermWin.parent[0],
		3393	display->atom (str));
		3394	}
		3395	break;
		3396
2979	case XTerm_Color:	3397	case XTerm_Color:
2980	for (buf = (char *)str; buf && *buf;)	3398	for (buf = (char *)str; buf && *buf;)
2981	{	3399	{
2982	if ((name = STRCHR (buf, ';')) == NULL)	3400	if ((name = STRCHR (buf, ';')) == NULL)
2983	break;	3401	break;
…		…
2989	break;	3407	break;
2990		3408
2991	if ((buf = STRCHR (name, ';')) != NULL)	3409	if ((buf = STRCHR (name, ';')) != NULL)
2992	*buf++ = '\0';	3410	*buf++ = '\0';
2993		3411
		3412	if (name[0] == '?' && !name[1])
		3413	{
		3414	if (Options & Opt_insecure)
		3415	{
		3416	unsigned short r, g, b;
		3417	PixColorsFocused[color + minCOLOR].get (display, r, g, b);
		3418	tt_printf ("\033]%d;%d;rgb:%04x/%04x/%04x%c", XTerm_Color, color, r, g, b, resp);
		3419	}
		3420	}
		3421	else
2994	set_window_color (color + minCOLOR, name);	3422	set_window_color (color + minCOLOR, name);
2995	}	3423	}
		3424	break;
		3425	case XTerm_Color00:
		3426	process_color_seq (XTerm_Color00, Color_fg, str, resp);
		3427	break;
		3428	case XTerm_Color01:
		3429	process_color_seq (XTerm_Color00, Color_bg, str, resp);
2996	break;	3430	break;
2997	#ifndef NO_CURSORCOLOR	3431	#ifndef NO_CURSORCOLOR
2998	case XTerm_Color_cursor:	3432	case XTerm_Color_cursor:
2999	set_window_color (Color_cursor, str);	3433	process_color_seq (XTerm_Color_cursor, Color_cursor, str, resp);
3000	break;	3434	break;
3001	#endif	3435	#endif
3002	case XTerm_Color_pointer:	3436	case XTerm_Color_pointer_fg:
3003	set_window_color (Color_pointer, str);	3437	process_color_seq (XTerm_Color_pointer_fg, Color_pointer_fg, str, resp);
		3438	break;
		3439	case XTerm_Color_pointer_bg:
		3440	process_color_seq (XTerm_Color_pointer_bg, Color_pointer_bg, str, resp);
3004	break;	3441	break;
3005	#ifndef NO_BOLD_UNDERLINE_REVERSE	3442	#ifndef NO_BOLD_UNDERLINE_REVERSE
3006	case XTerm_Color_BD:	3443	case XTerm_Color_BD:
3007	set_window_color (Color_BD, str);	3444	process_color_seq (XTerm_Color_BD, Color_BD, str, resp);
3008	break;	3445	break;
3009	case XTerm_Color_UL:	3446	case XTerm_Color_UL:
3010	set_window_color (Color_UL, str);	3447	process_color_seq (XTerm_Color_UL, Color_UL, str, resp);
3011	break;	3448	break;
3012	case XTerm_Color_RV:	3449	case XTerm_Color_RV:
3013	set_window_color (Color_RV, str);	3450	process_color_seq (XTerm_Color_RV, Color_RV, str, resp);
3014	break;	3451	break;
3015	#endif	3452	#endif
3016		3453
3017	case XTerm_Menu:
3018	/*
3019	* rxvt_menubar_dispatch () violates the constness of the string,
3020	* so DON'T do it here
3021	*/
3022	break;
3023	case XTerm_Pixmap:	3454	case XTerm_Pixmap:
3024	if (*str != ';')	3455	if (*str != ';')
3025	{	3456	{
3026	#if XPM_BACKGROUND	3457	#if XPM_BACKGROUND
3027	scale_pixmap (""); /* reset to default scaling */	3458	scale_pixmap (""); /* reset to default scaling */
…		…
3050	set_window_color (Color_fg, str);	3481	set_window_color (Color_fg, str);
3051	break;	3482	break;
3052	case XTerm_restoreBG:	3483	case XTerm_restoreBG:
3053	set_window_color (Color_bg, str);	3484	set_window_color (Color_bg, str);
3054	break;	3485	break;
		3486
3055	case XTerm_logfile:	3487	case XTerm_logfile:
3056	// TODO, when secure mode?	3488	// TODO, when secure mode?
3057	break;	3489	break;
		3490
3058	case XTerm_font:	3491	case XTerm_font:
		3492	if (query)
		3493	{
		3494	if (Options & Opt_insecure)
		3495	tt_printf ("\33]%d;%-.250s%c", XTerm_font,
		3496	TermWin.fontset->fontdesc
		3497	? TermWin.fontset->fontdesc
		3498	: "",
		3499	resp);
		3500	}
		3501	else
3059	change_font (str);	3502	change_font (str);
3060	break;	3503	break;
		3504
3061	#ifndef NO_FRILLS	3505	#ifndef NO_FRILLS
3062	case XTerm_locale:	3506	case XTerm_locale:
3063	if (str[0] == '?' && !str[1])	3507	if (query)
3064	tt_printf ("%-.250s\n", locale);	3508	{
		3509	if (Options & Opt_insecure)
		3510	tt_printf ("\33]%d;%-.250s%c", XTerm_locale, locale, resp);
		3511	}
3065	else	3512	else
3066	{	3513	{
3067	set_locale (str);	3514	set_locale (str);
3068	# ifdef USE_XIM	3515	# ifdef USE_XIM
3069	im_cb ();	3516	im_cb ();
3070	# endif	3517	# endif
3071	}	3518	}
3072	break;	3519	break;
		3520
3073	case XTerm_findfont:	3521	case XTerm_findfont:
		3522	if (Options & Opt_insecure)
3074	{	3523	{
3075	int fid = TermWin.fontset->find_font (atoi (str));	3524	int fid = TermWin.fontset->find_font (atoi (str));
3076	tt_printf ("%d %-.250s\n", fid, (*TermWin.fontset)[fid]->name);	3525	tt_printf ("\33]%d;%d;%-.250s%c", XTerm_findfont,
		3526	fid, (*TermWin.fontset)[fid]->name, resp);
3077	}	3527	}
		3528	break;
		3529	#endif
		3530
		3531	#ifdef MENUBAR
		3532	case XTerm_Menu:
		3533	if (Options & Opt_insecure)
		3534	menubar_dispatch (const_cast<char *>(str)); // casting away constness is checked
3078	break;	3535	break;
3079	#endif	3536	#endif
3080	#if 0	3537	#if 0
3081	case XTerm_dumpscreen: /* no error notices */	3538	case XTerm_dumpscreen: /* no error notices */
3082	{	3539	{
3083	int fd;	3540	int fd;
3084	if ((fd = open (str, O_RDWR | O_CREAT | O_EXCL, 0600)) >= 0)	3541	if ((fd = open (str, O_RDWR | O_CREAT | O_EXCL, 0600)) >= 0)
3085	{	3542	{
3086	scr_dump (fd);	3543	scr_dump (fd);
3087	close (fd);	3544	close (fd);
3088	}	3545	}
…		…
3175	// 1035 enable modifiers for alt, numlock NYI	3632	// 1035 enable modifiers for alt, numlock NYI
3176	// 1036 send ESC for meta keys NYI	3633	// 1036 send ESC for meta keys NYI
3177	// 1037 send DEL for keypad delete NYI	3634	// 1037 send DEL for keypad delete NYI
3178	{ 1047, PrivMode_Screen },	3635	{ 1047, PrivMode_Screen },
3179	// 1048 save and restore cursor	3636	// 1048 save and restore cursor
3180	{ 1049, PrivMode_Screen }, /* xterm extension, not fully implemented */	3637	{ 1049, PrivMode_Screen }, /* xterm extension, clear screen on ti rather than te */
3181	// 1051, 1052, 1060, 1061 keyboard emulation NYI	3638	// 1051, 1052, 1060, 1061 keyboard emulation NYI
3182	};	3639	};
3183		3640
3184	if (nargs == 0)	3641	if (nargs == 0)
3185	return;	3642	return;
…		…
3204		3661
3205	/* extra handling for values with state unkept */	3662	/* extra handling for values with state unkept */
3206	switch (arg[i])	3663	switch (arg[i])
3207	{	3664	{
3208	case 1048: /* alternative cursor save */	3665	case 1048: /* alternative cursor save */
3209	case 1049:	3666	if (Options & Opt_secondaryScreen)
3210	if (mode == 0)	3667	if (mode == 0)
3211	scr_cursor (RESTORE);	3668	scr_cursor (RESTORE);
3212	else if (mode == 1)	3669	else if (mode == 1)
3213	scr_cursor (SAVE);	3670	scr_cursor (SAVE);
3214	/* FALLTHROUGH */	3671	break;
3215	}	3672	}
3216		3673
3217	if (state >= 0)	3674	if (state >= 0)
3218	/* extra handling for values with valid 0 or 1 state */	3675	/* extra handling for values with valid 0 or 1 state */
3219	switch (arg[i])	3676	switch (arg[i])
…		…
3243	scr_relative_origin (state);	3700	scr_relative_origin (state);
3244	break;	3701	break;
3245	case 7: /* autowrap */	3702	case 7: /* autowrap */
3246	scr_autowrap (state);	3703	scr_autowrap (state);
3247	break;	3704	break;
3248	/* case 8: - auto repeat, can't do on a per window basis */	3705	/* case 8: - auto repeat, can't do on a per window basis */
3249	case 9: /* X10 mouse reporting */	3706	case 9: /* X10 mouse reporting */
3250	if (state) /* orthogonal */	3707	if (state) /* orthogonal */
3251	PrivateModes &= ~PrivMode_MouseX11;	3708	PrivateModes &= ~PrivMode_MouseX11;
3252	break;	3709	break;
3253	#ifdef menuBar_esc	3710	#ifdef menuBar_esc
…		…
3267	break;	3724	break;
3268	#endif	3725	#endif
3269	case 25: /* visible/invisible cursor */	3726	case 25: /* visible/invisible cursor */
3270	scr_cursor_visible (state);	3727	scr_cursor_visible (state);
3271	break;	3728	break;
3272	/* case 35: - shift keys */	3729	/* case 35: - shift keys */
3273	/* case 40: - 80 <--> 132 mode */	3730	/* case 40: - 80 <--> 132 mode */
3274	case 47: /* secondary screen */	3731	case 47: /* secondary screen */
3275	scr_change_screen (state);	3732	scr_change_screen (state);
3276	break;	3733	break;
3277	/* case 66: - application key pad */	3734	/* case 66: - application key pad */
3278	/* case 67: - backspace key */	3735	/* case 67: - backspace key */
3279	case 1000: /* X11 mouse reporting */	3736	case 1000: /* X11 mouse reporting */
3280	if (state) /* orthogonal */	3737	if (state) /* orthogonal */
3281	PrivateModes &= ~PrivMode_MouseX10;	3738	PrivateModes &= ~PrivMode_MouseX10;
3282	break;	3739	break;
3283	#if 0	3740	#if 0
…		…
3294	if (state)	3751	if (state)
3295	Options |= Opt_scrollTtyKeypress;	3752	Options |= Opt_scrollTtyKeypress;
3296	else	3753	else
3297	Options &= ~Opt_scrollTtyKeypress;	3754	Options &= ~Opt_scrollTtyKeypress;
3298	break;	3755	break;
3299	case 1047: /* secondary screen w/ clearing */	3756	case 1047: /* secondary screen w/ clearing last */
3300	case 1049: /* better secondary screen w/ clearing, but not fully implemented */	3757	if (Options & Opt_secondaryScreen)
3301	if (current_screen != PRIMARY)	3758	if (current_screen != PRIMARY)
3302	scr_erase_screen (2);	3759	scr_erase_screen (2);
3303
3304	scr_change_screen (state);	3760	scr_change_screen (state);
3305	/* FALLTHROUGH */	3761	break;
		3762	case 1049: /* secondary screen w/ clearing first */
		3763	scr_change_screen (state);
		3764	if (Options & Opt_secondaryScreen)
		3765	if (current_screen != PRIMARY)
		3766	scr_erase_screen (2);
		3767	break;
3306	default:	3768	default:
3307	break;	3769	break;
3308	}	3770	}
3309	}	3771	}
3310	}	3772	}
…		…
3333	rendset = 0, rendstyle = ~RS_None;	3795	rendset = 0, rendstyle = ~RS_None;
3334	break;	3796	break;
3335	case 1:	3797	case 1:
3336	rendset = 1, rendstyle = RS_Bold;	3798	rendset = 1, rendstyle = RS_Bold;
3337	break;	3799	break;
		3800	//case 2: // faint or second colour
3338	case 4:	3801	case 4:
3339	rendset = 1, rendstyle = RS_Uline;	3802	rendset = 1, rendstyle = RS_Uline;
3340	break;	3803	break;
3341	case 5:	3804	case 5: // slowly blinking
		3805	case 6: // rapidly blinking
3342	rendset = 1, rendstyle = RS_Blink;	3806	rendset = 1, rendstyle = RS_Blink;
3343	break;	3807	break;
		3808	//case 6: // scoansi light background
3344	case 7:	3809	case 7:
3345	rendset = 1, rendstyle = RS_RVid;	3810	rendset = 1, rendstyle = RS_RVid;
3346	break;	3811	break;
3347	case 8:	3812	case 8:
3348	// invisible. NYI	3813	// invisible. NYI
3349	break;	3814	break;
		3815	//case 9: // crossed out
		3816	//case 10: // scoansi acs off, primary font
		3817	//case 11: // scoansi acs on, first alt font
		3818	//case 12: // scoansi acs on, |0x80, second alt font
		3819	//...
		3820	//case 19: // ninth alt font
		3821	//case 20: // gothic
		3822	case 21: // disable bold, faint
		3823	rendset = 0, rendstyle = RS_Bold;
		3824	break;
3350	case 22:	3825	case 22:
3351	rendset = 0, rendstyle = RS_Bold;	3826	rendset = 0, rendstyle = RS_Bold;
3352	break;	3827	break;
		3828	//case 23: disable italic
3353	case 24:	3829	case 24:
3354	rendset = 0, rendstyle = RS_Uline;	3830	rendset = 0, rendstyle = RS_Uline;
3355	break;	3831	break;
3356	case 25:	3832	case 25:
3357	rendset = 0, rendstyle = RS_Blink;	3833	rendset = 0, rendstyle = RS_Blink;
3358	break;	3834	break;
3359	case 27:	3835	case 27:
3360	rendset = 0, rendstyle = RS_RVid;	3836	rendset = 0, rendstyle = RS_RVid;
3361	break;	3837	break;
3362	case 28:
3363	// visible. NYI	3838	//case 28: // visible. NYI
3364	break;	3839	//case 29: // not crossed-out
3365	}	3840	}
3366		3841
3367	if (rendset != -1)	3842	if (rendset != -1)
3368	{	3843	{
3369	scr_rendition (rendset, rendstyle);	3844	scr_rendition (rendset, rendstyle);
…		…
3446	}	3921	}
3447	}	3922	}
3448	}	3923	}
3449	/*}}} */	3924	/*}}} */
3450		3925
3451	/*{{{ process Rob Nation's own graphics mode sequences */	3926	/*{{{ (do not) process Rob Nation's own graphics mode sequences */
3452	void	3927	void
3453	rxvt_term::process_graphics ()	3928	rxvt_term::process_graphics ()
3454	{	3929	{
3455	unicode_t ch, cmd = cmd_getc ();	3930	unicode_t ch, cmd = cmd_getc ();
3456		3931

Diff Legend

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