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.90 by pcg, Fri Apr 2 19:09:52 2004 UTC vs.
Revision 1.131 by root, Fri Aug 13 22:38:57 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
…		…
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
		63
		64	#define ISO_14755_KEYCODE_VALID 0x80000000UL
		65	#define ISO_14755_ACTIVE 0x40000000UL
		66	#define ISO_14755_ESCAPE_NEXT 0x20000000UL
		67
		68	static unsigned short iso14755_symtab[] = {
		69	// keysym, unicode
		70	XK_Left, 0x2190,
		71	XK_KP_Left, 0x2190,
		72	XK_Up, 0x2191,
		73	XK_KP_Up, 0x2191,
		74	XK_Right, 0x2192,
		75	XK_KP_Right, 0x2192,
		76	XK_Down, 0x2193,
		77	XK_KP_Down, 0x2193,
		78	XK_Linefeed, 0x21b4,
		79	XK_Return, 0x21b5,
		80	XK_KP_Enter, 0x21b5,
		81
		82	XK_Prior, 0x21de,
		83	XK_Next, 0x21df,
		84	XK_Tab, 0x21e5,
		85	XK_ISO_Left_Tab, 0x21e6,
		86	XK_Shift_L, 0x21e7,
		87	XK_Shift_R, 0x21e7,
		88
		89	XK_Shift_Lock, 0x21eb,
		90	XK_ISO_Lock, 0x21eb,
		91	XK_ISO_Lock, 0x21eb,
		92	XK_Caps_Lock, 0x21ec,
		93	XK_Num_Lock, 0x21ed,
		94	XK_ISO_Level3_Shift, 0x21ee,
		95	XK_ISO_Level3_Lock, 0x21ef,
		96	XK_ISO_Group_Lock, 0x21f0,
		97	XK_Home, 0x21f1,
		98	XK_End, 0x21f2,
		99
		100	XK_Execute, 0x2318,
		101	XK_Begin, 0x2320,
		102	XK_Delete, 0x2326,
		103	XK_Clear, 0x2327,
		104	XK_BackSpace, 0x232b,
		105	XK_Insert, 0x2380,
		106	XK_Control_L, 0x2388,
		107	XK_Control_R, 0x2388,
		108	XK_Pause, 0x2389,
		109	XK_Break, 0x238a,
		110	XK_Escape, 0x238b,
		111	XK_Undo, 0x238c,
		112	XK_Print, 0x2399,
		113
		114	XK_space, 0x2423,
		115	XK_KP_Space, 0x2422,
		116	0,
		117	};
		118
		119	void
		120	rxvt_term::commit_iso14755 ()
		121	{
		122	wchar_t ch[2];
		123
		124	ch[0] = iso14755buf & 0x1fffffffUL; // actually, unicode needs a 0x1fffff mask
		125	ch[1] = 0;
		126
		127	if (iso14755buf & ISO_14755_KEYCODE_VALID)
		128	{
		129	char mb[16];
		130	int len;
		131
		132	// allow verbatim 0-bytes and control-bytes to be entered
		133	if (ch[0] >= 0x20)
		134	len = wcstombs (mb, ch, 16);
		135	else
		136	{
		137	mb[0] = ch[0];
		138	len = 1;
		139	}
		140
		141	if (len > 0)
		142	tt_write ((unsigned char *)mb, len);
		143	else
		144	scr_bell ();
		145	}
		146
		147	iso14755buf = 0;
		148	}
		149
		150	int
		151	rxvt_term::hex_keyval (XKeyEvent &ev)
		152	{
		153	// check wether this event corresponds to a hex digit
		154	// if the modifiers had not been pressed.
		155	for (int index = 0; index < 8; index++)
		156	{
		157	KeySym k = XLookupKeysym (&ev, index);
		158
		159	if (k >= XK_KP_0 && k <= XK_KP_9) return k - XK_KP_0;
		160	else if (k >= XK_0 && k <= XK_9) return k - XK_0;
		161	else if (k >= XK_a && k <= XK_f) return k - XK_a + 10;
		162	else if (k >= XK_A && k <= XK_F) return k - XK_A + 10;
		163	}
		164
		165	return -1;
		166	}
		167	#endif
		168
62	/*{{{ Convert the keypress event into a string */	169	/*{{{ Convert the keypress event into a string */
63	void	170	void
64	rxvt_term::lookup_key (XKeyEvent &ev)	171	rxvt_term::lookup_key (XKeyEvent &ev)
65	{	172	{
66	int ctrl, meta, shft, len;	173	int ctrl, meta, shft, len;
…		…
151	{	258	{
152	if (TermWin.saveLines)	259	if (TermWin.saveLines)
153	{	260	{
154	#ifdef UNSHIFTED_SCROLLKEYS	261	#ifdef UNSHIFTED_SCROLLKEYS
155	if (!ctrl && !meta)	262	if (!ctrl && !meta)
156	{
157	#else	263	#else
158	if (IS_SCROLL_MOD)	264	if (IS_SCROLL_MOD)
		265	#endif
159	{	266	{
160	#endif
161	int lnsppg;	267	int lnsppg;
162		268
163	#ifdef PAGING_CONTEXT_LINES	269	#ifdef PAGING_CONTEXT_LINES
164	lnsppg = TermWin.nrow - PAGING_CONTEXT_LINES;	270	lnsppg = TermWin.nrow - PAGING_CONTEXT_LINES;
165	#else	271	#else
…		…
222	{	328	{
223	/* normal XTerm key bindings */	329	/* normal XTerm key bindings */
224	case XK_Insert: /* Shift+Insert = paste mouse selection */	330	case XK_Insert: /* Shift+Insert = paste mouse selection */
225	selection_request (ev.time, 0, 0);	331	selection_request (ev.time, 0, 0);
226	return;	332	return;
		333	#if TODO // TODO
227	/* rxvt extras */	334	/* rxvt extras */
228	case XK_KP_Add: /* Shift+KP_Add = bigger font */	335	case XK_KP_Add: /* Shift+KP_Add = bigger font */
229	change_font (FONT_UP);	336	change_font (FONT_UP);
230	return;	337	return;
231	case XK_KP_Subtract: /* Shift+KP_Subtract = smaller font */	338	case XK_KP_Subtract: /* Shift+KP_Subtract = smaller font */
232	change_font (FONT_DN);	339	change_font (FONT_DN);
233	return;	340	return;
		341	#endif
234	}	342	}
235	}	343	}
236	}	344	}
		345
		346	#ifndef NO_FRILLS
		347	// ISO 14755 support
		348	if (shft && ctrl)
		349	{
		350	int hv;
		351
		352	if (keysym == XK_space || keysym == XK_KP_Space
		353	|| keysym == XK_Return || keysym == XK_KP_Enter)
		354	{
		355	commit_iso14755 ();
		356	return;
		357	}
		358	else if ((hv = hex_keyval (ev)) >= 0)
		359	{
		360	iso14755buf = (iso14755buf << 4) | hv | ISO_14755_KEYCODE_VALID;
		361	return;
		362	}
		363	else
		364	iso14755buf = 0;
		365	}
		366	else if ((ctrl && (keysym == XK_Shift_L || keysym == XK_Shift_R))
		367	|| (shft && (keysym == XK_Control_L || keysym == XK_Control_R)))
		368	iso14755buf |= ISO_14755_ACTIVE;
		369	#endif
		370
237	#ifdef PRINTPIPE	371	#ifdef PRINTPIPE
238	if (keysym == XK_Print)	372	if (keysym == XK_Print)
239	{	373	{
240	scr_printscreen (ctrl | shft);	374	scr_printscreen (ctrl | shft);
241	return;	375	return;
…		…
306	newlen = 0;	440	newlen = 0;
307	}	441	}
308	break;	442	break;
309		443
310	#ifdef XK_KP_Left	444	#ifdef XK_KP_Left
311	case XK_KP_Up: /* \033Ox or standard */	445	case XK_KP_Up: /* \033Ox or standard */
312	case XK_KP_Down: /* \033Or or standard */	446	case XK_KP_Down: /* \033Or or standard */
313	case XK_KP_Right: /* \033Ov or standard */	447	case XK_KP_Right: /* \033Ov or standard */
314	case XK_KP_Left: /* \033Ot or standard */	448	case XK_KP_Left: /* \033Ot or standard */
315	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	449	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
316	{	450	{
…		…
661	if (want_full_refresh)	795	if (want_full_refresh)
662	{	796	{
663	want_full_refresh = 0;	797	want_full_refresh = 0;
664	scr_clear ();	798	scr_clear ();
665	scr_touch (false);	799	scr_touch (false);
666	want_refresh = 1;
667	}	800	}
668	#endif	801	#endif
669		802
670	if (want_refresh)	803	if (want_refresh)
671	{	804	{
672	scr_refresh (refresh_type);	805	scr_refresh (refresh_type);
673	scrollbar_show (1);	806	scrollbar_show (1);
674	#ifdef USE_XIM	807	#ifdef USE_XIM
675	IMSendSpot ();	808	IMSendSpot ();
676	#endif	809	#endif
677
678	}	810	}
679		811
680	display->flush ();	812	display->flush ();
		813
		814	flush_ev.stop ();
681	}	815	}
682		816
683	void	817	void
684	rxvt_term::check_cb (check_watcher &w)	818	rxvt_term::check_cb (check_watcher &w)
685	{	819	{
686	SET_R (this);	820	SET_R (this);
687	SET_LOCALE (locale);	821	SET_LOCALE (locale);
688		822
		823	display->flush ();
		824
		825	if (want_refresh && !flush_ev.active)
		826	flush_ev.start (NOW + 0.01);
		827	}
		828
		829	void
		830	rxvt_term::flush_cb (time_watcher &w)
		831	{
		832	SET_R (this);
		833	SET_LOCALE (locale);
		834
		835	refresh_limit = 1;
		836	refresh_count = 0;
689	flush ();	837	flush ();
690	}	838	}
691		839
692	#ifdef CURSOR_BLINK	840	#ifdef CURSOR_BLINK
693	void	841	void
…		…
711	w.start (w.at + TEXT_BLINK_INTERVAL);	859	w.start (w.at + TEXT_BLINK_INTERVAL);
712	}	860	}
713	}	861	}
714	#endif	862	#endif
715		863
		864	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
		865	void
		866	rxvt_term::cont_scroll_cb (time_watcher &w)
		867	{
		868	if ((scrollbar_isUp() || scrollbar_isDn()) &&
		869	scr_page (scrollbar_isUp() ? UP : DN, 1))
		870	{
		871	refresh_type |= SMOOTH_REFRESH;
		872	want_refresh = 1;
		873	w.start (w.at + SCROLLBAR_CONTINUOUS_DELAY);
		874	}
		875	}
		876	#endif
		877
		878	#ifdef SELECTION_SCROLLING
		879	void
		880	rxvt_term::sel_scroll_cb (time_watcher &w)
		881	{
		882	if (scr_page (scroll_selection_dir, scroll_selection_lines))
		883	{
		884	selection_extend (selection_save_x, selection_save_y, selection_save_state);
		885	refresh_type |= SMOOTH_REFRESH;
		886	want_refresh = 1;
		887	w.start (w.at + SCROLLBAR_CONTINUOUS_DELAY);
		888	}
		889	}
		890	#endif
		891
		892	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
		893	void
		894	rxvt_term::slip_wheel_cb (time_watcher &w)
		895	{
		896	if (mouse_slip_wheel_speed == 0
		897	|| mouse_slip_wheel_speed < 0 ? scr_page (DN, -mouse_slip_wheel_speed)
		898	: scr_page (UP, mouse_slip_wheel_speed))
		899	{
		900	refresh_type |= SMOOTH_REFRESH;
		901	want_refresh = 1;
		902	w.start (w.at + SCROLLBAR_CONTINUOUS_DELAY);
		903	}
		904	}
		905	#endif
		906
716	bool	907	bool
717	rxvt_term::pty_fill ()	908	rxvt_term::pty_fill ()
718	{	909	{
719	ssize_t n = cmdbuf_endp - cmdbuf_ptr;	910	ssize_t n = cmdbuf_endp - cmdbuf_ptr;
		911
		912	if (CBUFSIZ == n)
		913	{
		914	rxvt_warn ("pty_fill on full buffer, draining input, continuing.\n");
		915	n = 0;
		916	}
720		917
721	memmove (cmdbuf_base, cmdbuf_ptr, n);	918	memmove (cmdbuf_base, cmdbuf_ptr, n);
722	cmdbuf_ptr = cmdbuf_base;	919	cmdbuf_ptr = cmdbuf_base;
723	cmdbuf_endp = cmdbuf_ptr + n;	920	cmdbuf_endp = cmdbuf_ptr + n;
724		921
…		…
742	SET_LOCALE (locale);	939	SET_LOCALE (locale);
743		940
744	if (revents & EVENT_WRITE)	941	if (revents & EVENT_WRITE)
745	tt_write (0, 0);	942	tt_write (0, 0);
746	else if (revents & EVENT_READ)	943	else if (revents & EVENT_READ)
747	{
748	// loop, but don't allow a single term to monopolize us	944	// 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 ())	945	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 ())	946	if (cmd_parse ())
761	break;	947	break;
762	}
763	}
764	}	948	}
765		949
766	#ifdef POINTER_BLANK
767	void	950	void
768	rxvt_term::pointer_unblank ()	951	rxvt_term::pointer_unblank ()
769	{	952	{
770	XDefineCursor (display->display, TermWin.vt, TermWin_cursor);	953	XDefineCursor (display->display, TermWin.vt, TermWin_cursor);
771	recolour_cursor ();	954	recolour_cursor ();
772		955
		956	#ifdef POINTER_BLANK
773	hidden_pointer = 0;	957	hidden_pointer = 0;
774		958
775	if (Options & Opt_pointerBlank)	959	if (Options & Opt_pointerBlank)
776	pointer_ev.start (NOW + pointerBlankDelay);	960	pointer_ev.start (NOW + pointerBlankDelay);
		961	#endif
777	}	962	}
778		963
		964	#ifdef POINTER_BLANK
779	void	965	void
780	rxvt_term::pointer_blank ()	966	rxvt_term::pointer_blank ()
781	{	967	{
782	if (! (Options & Opt_pointerBlank))	968	if (! (Options & Opt_pointerBlank))
783	return;	969	return;
…		…
973	#endif	1159	#endif
974		1160
975	switch (ev.type)	1161	switch (ev.type)
976	{	1162	{
977	case KeyPress:	1163	case KeyPress:
		1164	if (!(iso14755buf & ISO_14755_ESCAPE_NEXT))
978	lookup_key (ev.xkey);	1165	lookup_key (ev.xkey);
		1166
		1167	break;
		1168
		1169	case KeyRelease:
		1170	{
		1171	#if (defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)) || !defined (NO_FRILLS)
		1172	KeySym ks;
		1173
		1174	ks = XLookupKeysym (&ev.xkey, ev.xkey.state & ShiftMask ? 1 : 0); // sorry, only shift supported :/
		1175	#endif
		1176
		1177	#ifndef NO_FRILLS
		1178	// ISO 14755 support
		1179	if (iso14755buf)
		1180	if (iso14755buf & ISO_14755_ESCAPE_NEXT)
		1181	{
		1182	// iso14755 part 5.2 handling: release time
		1183	// first: controls
		1184	if ((ev.xkey.state & ControlMask)
		1185	&& ((ks >= 0x40 && ks <= 0x5f)
		1186	|| (ks >= 0x61 && ks <= 0x7f)))
		1187	{
		1188	iso14755buf = ISO_14755_KEYCODE_VALID | 0x2400 | (ks & 0x1f);
		1189	commit_iso14755 ();
		1190	return; // case-break;
		1191	}
		1192
		1193	for (unsigned short *i = iso14755_symtab; i[0]; i+= 2)
		1194	if (i[0] == ks)
		1195	{
		1196	iso14755buf = ISO_14755_KEYCODE_VALID | i[1];
		1197	commit_iso14755 ();
		1198	return; // case-break;
		1199	}
		1200
		1201	iso14755buf = 0;
		1202	scr_bell ();
979	break;	1203	break;
		1204	}
		1205	else if ((ev.xkey.state & (ShiftMask | ControlMask)) != (ShiftMask | ControlMask))
		1206	{
		1207	if (iso14755buf & ISO_14755_KEYCODE_VALID)
		1208	commit_iso14755 ();
		1209	else if (iso14755buf & ISO_14755_ACTIVE)
		1210	iso14755buf = ISO_14755_ESCAPE_NEXT; // iso14755 part 5.2: remember empty begin/end pair
		1211	}
		1212	#endif
980		1213
981	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)	1214	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
982	case KeyRelease:
983	{
984	if (! (ev.xkey.state & ControlMask))	1215	if (!(ev.xkey.state & ControlMask))
		1216	slip_wheel_ev.stop ();
		1217	else if (ks == XK_Control_L || ks == XK_Control_R)
985	mouse_slip_wheel_speed = 0;	1218	mouse_slip_wheel_speed = 0;
986	else	1219	#endif
987	{
988	KeySym ks;
989
990	ks = XKeycodeToKeysym (display->display, ev.xkey.keycode, 0);
991	if (ks == XK_Control_L || ks == XK_Control_R)
992	mouse_slip_wheel_speed = 0;
993	}
994	break;	1220	break;
995	}	1221	}
996	#endif
997		1222
998	case ButtonPress:	1223	case ButtonPress:
999	button_press (ev.xbutton);	1224	button_press (ev.xbutton);
1000	break;	1225	break;
1001		1226
…		…
1013	&& (ev.xclient.data.l[0] == DndFile	1238	&& (ev.xclient.data.l[0] == DndFile
1014	|| ev.xclient.data.l[0] == DndDir	1239	|| ev.xclient.data.l[0] == DndDir
1015	|| ev.xclient.data.l[0] == DndLink))	1240	|| ev.xclient.data.l[0] == DndLink))
1016	{	1241	{
1017	/* Get Dnd data */	1242	/* Get Dnd data */
1018	Atom ActualType;	1243	Atom ActualType;
1019	int ActualFormat;	1244	int ActualFormat;
1020	unsigned char *data;	1245	unsigned char *data;
1021	unsigned long Size, RemainingBytes;	1246	unsigned long Size, RemainingBytes;
1022		1247
1023	XGetWindowProperty (display->display, display->root,	1248	XGetWindowProperty (display->display, display->root,
1024	xa[XA_DNDSELECTION],	1249	xa[XA_DNDSELECTION],
1025	0L, 1000000L,	1250	0L, 1000000L,
1026	False, AnyPropertyType,	1251	False, AnyPropertyType,
…		…
1029	&data);	1254	&data);
1030	XChangeProperty (display->display, display->root,	1255	XChangeProperty (display->display, display->root,
1031	XA_CUT_BUFFER0, XA_STRING,	1256	XA_CUT_BUFFER0, XA_STRING,
1032	8, PropModeReplace,	1257	8, PropModeReplace,
1033	data, STRLEN (data));	1258	data, STRLEN (data));
		1259	XFree (data);
1034	selection_paste (display->root, XA_CUT_BUFFER0, True);	1260	selection_paste (display->root, XA_CUT_BUFFER0, True);
1035	XSetInputFocus (display->display, display->root, RevertToNone, CurrentTime);	1261	XSetInputFocus (display->display, display->root, RevertToNone, CurrentTime);
1036	}	1262	}
1037	#endif /* OFFIX_DND */	1263	#endif /* OFFIX_DND */
1038	break;	1264	break;
1039		1265
1040	case MappingNotify:	1266	case MappingNotify:
1041	XRefreshKeyboardMapping (& (ev.xmapping));	1267	XRefreshKeyboardMapping (&ev.xmapping);
1042	break;	1268	break;
1043		1269
1044	/*	1270	/*
1045	* XXX: this is not the _current_ arrangement	1271	* XXX: this is not the _current_ arrangement
1046	* Here's my conclusion:	1272	* Here's my conclusion:
…		…
1077	#endif	1303	#endif
1078	#ifdef CURSOR_BLINK	1304	#ifdef CURSOR_BLINK
1079	if (Options & Opt_cursorBlink)	1305	if (Options & Opt_cursorBlink)
1080	cursor_blink_ev.start (NOW + BLINK_INTERVAL);	1306	cursor_blink_ev.start (NOW + BLINK_INTERVAL);
1081	#endif	1307	#endif
		1308	#ifdef OFF_FOCUS_FADING
		1309	if (rs[Rs_fade])
		1310	{
		1311	PixColors = PixColorsFocused;
		1312	set_colorfgbg ();
		1313	scr_clear ();
		1314	scr_touch (true);
		1315	}
		1316	#endif
1082		1317
1083	}	1318	}
1084	break;	1319	break;
1085		1320
1086	case FocusOut:	1321	case FocusOut:
…		…
1095	#ifdef CURSOR_BLINK	1330	#ifdef CURSOR_BLINK
1096	if (Options & Opt_cursorBlink)	1331	if (Options & Opt_cursorBlink)
1097	cursor_blink_ev.stop ();	1332	cursor_blink_ev.stop ();
1098	hidden_cursor = 0;	1333	hidden_cursor = 0;
1099	#endif	1334	#endif
		1335	#ifdef OFF_FOCUS_FADING
		1336	if (rs[Rs_fade])
		1337	{
		1338	PixColors = PixColorsUnFocused;
		1339	set_colorfgbg ();
		1340	scr_clear ();
		1341	scr_touch (true);
		1342	}
		1343	#endif
1100		1344
1101	}	1345	}
1102	break;	1346	break;
1103		1347
1104	case ConfigureNotify:	1348	case ConfigureNotify:
…		…
1113	D_SIZE ((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));	1357	D_SIZE ((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));
1114	}	1358	}
1115	while (XCheckTypedWindowEvent (display->display, ev.xconfigure.window, ConfigureNotify, &ev));	1359	while (XCheckTypedWindowEvent (display->display, ev.xconfigure.window, ConfigureNotify, &ev));
1116		1360
1117	if (szHint.width != width || szHint.height != height)	1361	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);	1362	resize_all_windows (width, height, 1);
1121	}	1363
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 */	1364	#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */
1129	if (Options & Opt_transparent)	1365	if (Options & Opt_transparent)
1130	{	1366	{
1131	check_our_parents ();	1367	check_our_parents ();
1132	if (am_transparent)	1368	if (am_transparent)
1133	want_full_refresh = 1;	1369	want_refresh = want_full_refresh = 1;
1134	}	1370	}
1135	#endif	1371	#endif
1136	}	1372	}
		1373	break;
		1374
		1375	case PropertyNotify:
		1376	if (ev.xproperty.atom == xa[XA_VT_SELECTION]
		1377	&& ev.xproperty.state == PropertyNewValue)
		1378	selection_property (ev.xproperty.window, ev.xproperty.atom);
		1379
1137	break;	1380	break;
1138		1381
1139	case SelectionClear:	1382	case SelectionClear:
1140	selection_clear ();	1383	selection_clear ();
1141	break;	1384	break;
…		…
1172		1415
1173	case GraphicsExpose:	1416	case GraphicsExpose:
1174	case Expose:	1417	case Expose:
1175	if (ev.xany.window == TermWin.vt)	1418	if (ev.xany.window == TermWin.vt)
1176	{	1419	{
1177	#ifdef NO_SLOW_LINK_SUPPORT	1420	do
1178	scr_expose (ev.xexpose.x, ev.xexpose.y,	1421	scr_expose (ev.xexpose.x, ev.xexpose.y,
1179	ev.xexpose.width, ev.xexpose.height, False);	1422	ev.xexpose.width, ev.xexpose.height, False);
1180	#else	1423	while (XCheckTypedWindowEvent (display->display, TermWin.vt, ev.xany.type, &ev));
1181	// don't understand this, so commented it out	1424
		1425	ev.xany.type = ev.xany.type == Expose ? GraphicsExpose : Expose;
		1426
		1427	while (XCheckTypedWindowEvent (display->display, TermWin.vt, ev.xany.type, &ev))
1182	scr_expose (ev.xexpose.x, ev.xexpose.y,	1428	scr_expose (ev.xexpose.x, ev.xexpose.y,
1183	ev.xexpose.width, ev.xexpose.height, False);	1429	ev.xexpose.width, ev.xexpose.height, False);
1184	//scr_expose (ev.xexpose.x, 0,	1430
1185	// ev.xexpose.width, TermWin.height, False);	1431	scr_refresh (refresh_type);
1186	#endif
1187	want_refresh = 1;
1188	}	1432	}
1189	else	1433	else
1190	{	1434	{
1191	XEvent unused_event;	1435	XEvent unused_event;
1192		1436
1193	while (XCheckTypedWindowEvent (display->display, ev.xany.window,	1437	while (XCheckTypedWindowEvent (display->display, ev.xany.window, Expose, &unused_event))
1194	Expose,	1438	;
1195	&unused_event)) ;
1196	while (XCheckTypedWindowEvent (display->display, ev.xany.window,	1439	while (XCheckTypedWindowEvent (display->display, ev.xany.window, GraphicsExpose, &unused_event))
1197	GraphicsExpose,	1440	;
1198	&unused_event)) ;	1441
1199	if (isScrollbarWindow (ev.xany.window))	1442	if (isScrollbarWindow (ev.xany.window))
1200	{	1443	{
1201	scrollBar.setIdle ();	1444	scrollBar.setIdle ();
1202	scrollbar_show (0);	1445	scrollbar_show (0);
1203	}	1446	}
1204	#ifdef MENUBAR	1447	#ifdef MENUBAR
1205	if (menubar_visible () && isMenuBarWindow (ev.xany.window))	1448	if (menubar_visible () && isMenuBarWindow (ev.xany.window))
1206	menubar_expose ();	1449	menubar_expose ();
		1450	#endif
		1451
		1452	#ifdef TRANSPARENT
		1453	if (am_transparent && ev.xany.window == TermWin.parent[0])
		1454	XClearWindow (display->display, ev.xany.window);
1207	#endif	1455	#endif
1208	}	1456	}
1209	break;	1457	break;
1210		1458
1211	case MotionNotify:	1459	case MotionNotify:
…		…
1246	if (ev.xbutton.y < TermWin.int_bwidth	1494	if (ev.xbutton.y < TermWin.int_bwidth
1247	|| Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))	1495	|| Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))
1248	{	1496	{
1249	int dist;	1497	int dist;
1250		1498
1251	pending_scroll_selection=1;
1252
1253	/* don't clobber the current delay if we are	1499	/* don't clobber the current delay if we are
1254	* already in the middle of scrolling.	1500	* already in the middle of scrolling.
1255	*/	1501	*/
1256	if (scroll_selection_delay<=0)	1502	if (!sel_scroll_ev.active)
1257	scroll_selection_delay=SCROLLBAR_CONTINUOUS_DELAY;	1503	sel_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);
1258		1504
1259	/* save the event params so we can highlight	1505	/* save the event params so we can highlight
1260	* the selection in the pending-scroll loop	1506	* the selection in the pending-scroll loop
1261	*/	1507	*/
1262	selection_save_x=ev.xbutton.x;	1508	selection_save_x=ev.xbutton.x;
…		…
1284	else	1530	else
1285	{	1531	{
1286	/* we are within the text window, so we	1532	/* we are within the text window, so we
1287	* shouldn't be scrolling	1533	* shouldn't be scrolling
1288	*/	1534	*/
1289	pending_scroll_selection = 0;	1535	if (sel_scroll_ev.active)
		1536	sel_scroll_ev.stop();
1290	}	1537	}
1291	#endif	1538	#endif
1292	#ifdef MOUSE_THRESHOLD	1539	#ifdef MOUSE_THRESHOLD
1293		1540
1294	}	1541	}
…		…
1313	}	1560	}
1314	break;	1561	break;
1315	}	1562	}
1316	}	1563	}
1317		1564
		1565	#if TRANSPARENT
1318	void	1566	void
1319	rxvt_term::rootwin_cb (XEvent &ev)	1567	rxvt_term::rootwin_cb (XEvent &ev)
1320	{	1568	{
1321	SET_R (this);	1569	SET_R (this);
1322	SET_LOCALE (locale);	1570	SET_LOCALE (locale);
1323		1571
1324	switch (ev.type)	1572	switch (ev.type)
1325	{	1573	{
1326	case PropertyNotify:	1574	case PropertyNotify:
1327	if (ev.xproperty.atom == xa[XA_VT_SELECTION])
1328	{
1329	if (ev.xproperty.state == PropertyNewValue)
1330	selection_property (ev.xproperty.window, ev.xproperty.atom);
1331	break;
1332	}
1333	#ifdef TRANSPARENT
1334	else
1335	{
1336	/*	1575	/*
1337	* if user used some Esetroot compatible prog to set the root bg,	1576	* if user used some Esetroot compatible prog to set the root bg,
1338	* use the property to determine the pixmap. We use it later on.	1577	* use the property to determine the pixmap. We use it later on.
1339	*/	1578	*/
1340	if (xa[XA_XROOTPMAPID] == 0)	1579	if (xa[XA_XROOTPMAPID] == 0)
1341	xa[XA_XROOTPMAPID] = XInternAtom (display->display, "_XROOTPMAP_ID", False);	1580	xa[XA_XROOTPMAPID] = XInternAtom (display->display, "_XROOTPMAP_ID", False);
1342		1581
1343	if (ev.xproperty.atom != xa[XA_XROOTPMAPID])	1582	if (ev.xproperty.atom != xa[XA_XROOTPMAPID])
1344	return;	1583	return;
1345	}
1346		1584
1347	/* FALLTHROUGH */	1585	/* FALLTHROUGH */
1348	case ReparentNotify:	1586	case ReparentNotify:
1349	if ((Options & Opt_transparent) && check_our_parents () && am_transparent)	1587	if ((Options & Opt_transparent) && check_our_parents () && am_transparent)
1350	want_full_refresh = 1;	1588	want_refresh = want_full_refresh = 1;
1351	break;	1589	break;
1352	#endif
1353	}	1590	}
1354	}	1591	}
		1592	#endif
1355		1593
1356	void	1594	void
1357	rxvt_term::button_press (XButtonEvent &ev)	1595	rxvt_term::button_press (XButtonEvent &ev)
1358	{	1596	{
1359	int reportmode = 0, clickintime;	1597	int reportmode = 0, clickintime;
…		…
1511	upordown = 1; /* down */	1749	upordown = 1; /* down */
1512	}	1750	}
1513	if (upordown)	1751	if (upordown)
1514	{	1752	{
1515	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING	1753	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1516	scroll_arrow_delay = SCROLLBAR_INITIAL_DELAY;	1754	cont_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);
1517	#endif	1755	#endif
1518	if (scr_page (upordown < 0 ? UP : DN, 1))	1756	if (scr_page (upordown < 0 ? UP : DN, 1))
1519	{	1757	{
1520	if (upordown < 0)	1758	if (upordown < 0)
1521	scrollBar.setUp ();	1759	scrollBar.setUp ();
…		…
1537	break;	1775	break;
1538	case R_SB_ALIGN_BOTTOM:	1776	case R_SB_ALIGN_BOTTOM:
1539	csrO = scrollBar.bot - scrollBar.top;	1777	csrO = scrollBar.bot - scrollBar.top;
1540	break;	1778	break;
1541	}	1779	}
		1780
1542	if (scrollBar.style == R_SB_XTERM	1781	if (scrollBar.style == R_SB_XTERM
1543	|| scrollbar_above_slider (ev.y)	1782	|| scrollbar_above_slider (ev.y)
1544	|| scrollbar_below_slider (ev.y))	1783	|| scrollbar_below_slider (ev.y))
1545	scr_move_to ( scrollbar_position (ev.y) - csrO,	1784	scr_move_to (scrollbar_position (ev.y) - csrO, scrollbar_size ());
1546	scrollbar_size ());	1785
1547	scrollBar.setMotion ();	1786	scrollBar.setMotion ();
1548	break;	1787	break;
1549		1788
1550	case Button1:	1789	case Button1:
1551	if (scrollbar_align == R_SB_ALIGN_CENTRE)	1790	if (scrollbar_align == R_SB_ALIGN_CENTRE)
…		…
1575	scr_page ((ev.button == Button1 ? DN : UP),	1814	scr_page ((ev.button == Button1 ? DN : UP),
1576	(TermWin.nrow	1815	(TermWin.nrow
1577	* scrollbar_position (ev.y)	1816	* scrollbar_position (ev.y)
1578	/ scrollbar_size ()));	1817	/ scrollbar_size ()));
1579	}	1818	}
		1819
1580	break;	1820	break;
1581	}	1821	}
1582	}	1822	}
1583	return;	1823	return;
1584	}	1824	}
…		…
1608	refresh_type &= ~SMOOTH_REFRESH;	1848	refresh_type &= ~SMOOTH_REFRESH;
1609	#endif	1849	#endif
1610		1850
1611	}	1851	}
1612	#ifdef SELECTION_SCROLLING	1852	#ifdef SELECTION_SCROLLING
1613	pending_scroll_selection=0;	1853	if (sel_scroll_ev.active)
		1854	sel_scroll_ev.stop();
1614	#endif	1855	#endif
1615	if (ev.window == TermWin.vt)	1856	if (ev.window == TermWin.vt)
1616	{	1857	{
1617	if (reportmode)	1858	if (reportmode)
1618	{	1859	{
…		…
1660	case Button5:	1901	case Button5:
1661	{	1902	{
1662	int i;	1903	int i;
1663	page_dirn v;	1904	page_dirn v;
1664		1905
1665	v = (ev.button == Button4) ? UP : DN;	1906	v = ev.button == Button4 ? UP : DN;
		1907
1666	if (ev.state & ShiftMask)	1908	if (ev.state & ShiftMask)
1667	i = 1;	1909	i = 1;
1668	else if ((Options & Opt_mouseWheelScrollPage))	1910	else if (Options & Opt_mouseWheelScrollPage)
1669	i = TermWin.nrow - 1;	1911	i = TermWin.nrow - 1;
1670	else	1912	else
1671	i = 5;	1913	i = 5;
		1914
1672	# ifdef MOUSE_SLIP_WHEELING	1915	# ifdef MOUSE_SLIP_WHEELING
1673	if (ev.state & ControlMask)	1916	if (ev.state & ControlMask)
1674	{	1917	{
1675	mouse_slip_wheel_speed += (v ? -1 : 1);	1918	mouse_slip_wheel_speed += v ? -1 : 1;
		1919	if (mouse_slip_wheel_speed < -TermWin.nrow) mouse_slip_wheel_speed = -TermWin.nrow;
		1920	if (mouse_slip_wheel_speed > +TermWin.nrow) mouse_slip_wheel_speed = +TermWin.nrow;
		1921
		1922	if (slip_wheel_ev.at < NOW)
1676	mouse_slip_wheel_delay = SCROLLBAR_CONTINUOUS_DELAY;	1923	slip_wheel_ev.at = NOW + SCROLLBAR_CONTINUOUS_DELAY;
		1924
		1925	slip_wheel_ev.start ();
1677	}	1926	}
		1927	else
		1928	{
1678	# endif	1929	# endif
1679	# ifdef JUMP_MOUSE_WHEEL	1930	# ifdef JUMP_MOUSE_WHEEL
1680	scr_page (v, i);
1681	scr_refresh (SMOOTH_REFRESH);
1682	scrollbar_show (1);
1683	# else
1684	while (i--)
1685	{
1686	scr_page (v, 1);	1931	scr_page (v, i);
1687	scr_refresh (SMOOTH_REFRESH);	1932	scr_refresh (SMOOTH_REFRESH);
1688	scrollbar_show (1);	1933	scrollbar_show (1);
		1934	# else
		1935	while (i--)
		1936	{
		1937	scr_page (v, 1);
		1938	scr_refresh (SMOOTH_REFRESH);
		1939	scrollbar_show (1);
		1940	}
		1941	# endif
		1942	# ifdef MOUSE_SLIP_WHEELING
1689	}	1943	}
1690	# endif	1944	#endif
1691
1692	}	1945	}
1693	break;	1946	break;
1694	#endif	1947	#endif
1695
1696	}	1948	}
1697	}	1949	}
1698	#ifdef MENUBAR	1950	#ifdef MENUBAR
1699	else if (isMenuBarWindow (ev.window))	1951	else if (isMenuBarWindow (ev.window))
1700	menubar_control (ev);	1952	menubar_control (ev);
1701	#endif	1953	#endif
1702	}	1954	}
1703		1955
1704	#ifdef TRANSPARENT	1956	#ifdef TRANSPARENT
1705	#if TINTING	1957	#if TINTING
1706	/* shading taken from eterm-0.9.2 */	1958	/* taken from aterm-0.4.2 */
1707	/* RGB 15 */
1708		1959
1709	static void	1960	typedef uint32_t RUINT32T;
1710	shade_ximage_15(void *data, int bpl, int w, int h, int rm, int gm, int bm)
1711	{
1712	unsigned char *ptr;
1713	int x, y;
1714		1961
1715	ptr = (unsigned char *)data + (w * sizeof(uint16_t));	1962	void ShadeXImage(rxvt_display *display, XImage* srcImage, int shade, int rm, int gm, int bm)
1716	if ((rm <= 256) && (gm <= 256) && (bm <= 256)) {	1963	{
1717	/* No saturation */	1964	int sh_r, sh_g, sh_b;
1718	for (y = h; --y >= 0;) {	1965	RUINT32T mask_r, mask_g, mask_b;
1719	for (x = -w; x < 0; x++) {	1966	RUINT32T *lookup, *lookup_r, *lookup_g, *lookup_b;
1720	int r, g, b;	1967	unsigned int lower_lim_r, lower_lim_g, lower_lim_b;
		1968	unsigned int upper_lim_r, upper_lim_g, upper_lim_b;
		1969	int i;
1721		1970
1722	b = ((uint16_t *) ptr)[x];	1971	Visual* visual = display->visual;
1723	r = (b & 0x7c00) * rm;	1972
1724	g = (b & 0x3e0) * gm;	1973	if( visual->c_class != TrueColor || srcImage->format != ZPixmap ) return ;
1725	b = (b & 0x1f) * bm;	1974
1726	((uint16_t *) ptr)[x] = ((r >> 8) & 0x7c00)	1975	/* for convenience */
1727	| ((g >> 8) & 0x3e0)	1976	mask_r = visual->red_mask;
1728	| ((b >> 8) & 0x1f);	1977	mask_g = visual->green_mask;
1729	}	1978	mask_b = visual->blue_mask;
1730	ptr += bpl;	1979
1731	}	1980	/* boring lookup table pre-initialization */
		1981	switch (srcImage->bits_per_pixel) {
		1982	case 15:
		1983	if ((mask_r != 0x7c00) ||
		1984	(mask_g != 0x03e0) ||
		1985	(mask_b != 0x001f))
		1986	return;
		1987	lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+32+32));
		1988	lookup_r = lookup;
		1989	lookup_g = lookup+32;
		1990	lookup_b = lookup+32+32;
		1991	sh_r = 10;
		1992	sh_g = 5;
		1993	sh_b = 0;
		1994	break;
		1995	case 16:
		1996	if ((mask_r != 0xf800) ||
		1997	(mask_g != 0x07e0) ||
		1998	(mask_b != 0x001f))
		1999	return;
		2000	lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(32+64+32));
		2001	lookup_r = lookup;
		2002	lookup_g = lookup+32;
		2003	lookup_b = lookup+32+64;
		2004	sh_r = 11;
		2005	sh_g = 5;
		2006	sh_b = 0;
		2007	break;
		2008	case 24:
		2009	if ((mask_r != 0xff0000) ||
		2010	(mask_g != 0x00ff00) ||
		2011	(mask_b != 0x0000ff))
		2012	return;
		2013	lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256));
		2014	lookup_r = lookup;
		2015	lookup_g = lookup+256;
		2016	lookup_b = lookup+256+256;
		2017	sh_r = 16;
		2018	sh_g = 8;
		2019	sh_b = 0;
		2020	break;
		2021	case 32:
		2022	if ((mask_r != 0xff0000) ||
		2023	(mask_g != 0x00ff00) ||
		2024	(mask_b != 0x0000ff))
		2025	return;
		2026	lookup = (RUINT32T *) malloc (sizeof (RUINT32T)*(256+256+256));
		2027	lookup_r = lookup;
		2028	lookup_g = lookup+256;
		2029	lookup_b = lookup+256+256;
		2030	sh_r = 16;
		2031	sh_g = 8;
		2032	sh_b = 0;
		2033	break;
		2034	default:
		2035	return; /* we do not support this color depth */
		2036	}
		2037
		2038	/* prepare limits for color transformation (each channel is handled separately) */
		2039	if (shade < 0) {
		2040	shade = -shade;
		2041	if (shade < 0) shade = 0;
		2042	if (shade > 100) shade = 100;
		2043
		2044	lower_lim_r = 65535-rm;
		2045	lower_lim_g = 65535-gm;
		2046	lower_lim_b = 65535-bm;
		2047
		2048	lower_lim_r = 65535-(unsigned int)(((RUINT32T)lower_lim_r)*((RUINT32T)shade)/100);
		2049	lower_lim_g = 65535-(unsigned int)(((RUINT32T)lower_lim_g)*((RUINT32T)shade)/100);
		2050	lower_lim_b = 65535-(unsigned int)(((RUINT32T)lower_lim_b)*((RUINT32T)shade)/100);
		2051
		2052	upper_lim_r = upper_lim_g = upper_lim_b = 65535;
1732	} else {	2053	} else {
1733	for (y = h; --y >= 0;) {	2054	if (shade < 0) shade = 0;
1734	for (x = -w; x < 0; x++) {	2055	if (shade > 100) shade = 100;
1735	int r, g, b;
1736		2056
1737	b = ((uint16_t *) ptr)[x];	2057	lower_lim_r = lower_lim_g = lower_lim_b = 0;
1738	r = (b & 0x7c00) * rm;	2058
1739	g = (b & 0x3e0) * gm;	2059	upper_lim_r = (unsigned int)((((RUINT32T)rm)*((RUINT32T)shade))/100);
1740	b = (b & 0x1f) * bm;	2060	upper_lim_g = (unsigned int)((((RUINT32T)gm)*((RUINT32T)shade))/100);
1741	r |= (!(r >> 15) - 1);	2061	upper_lim_b = (unsigned int)((((RUINT32T)bm)*((RUINT32T)shade))/100);
1742	g |= (!(g >> 10) - 1);	2062	}
1743	b |= (!(b >> 5) - 1);	2063
1744	((uint16_t *) ptr)[x] = ((r >> 8) & 0x7c00)	2064	/* switch red and blue bytes if necessary, we need it for some weird XServers like XFree86 3.3.3.1 */
1745	| ((g >> 8) & 0x3e0)	2065	if ((srcImage->bits_per_pixel == 24) && (mask_r >= 0xFF0000 ))
1746	| ((b >> 8) & 0x1f);	2066	{
1747	}	2067	unsigned int tmp;
1748	ptr += bpl;	2068
		2069	tmp = lower_lim_r;
		2070	lower_lim_r = lower_lim_b;
		2071	lower_lim_b = tmp;
		2072
		2073	tmp = upper_lim_r;
		2074	upper_lim_r = upper_lim_b;
		2075	upper_lim_b = tmp;
		2076	}
		2077
		2078	/* fill our lookup tables */
		2079	for (i = 0; i <= mask_r>>sh_r; i++)
		2080	{
		2081	RUINT32T tmp;
		2082	tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_r-lower_lim_r));
		2083	tmp += ((RUINT32T)(mask_r>>sh_r))*((RUINT32T)lower_lim_r);
		2084	lookup_r[i] = (tmp/65535)<<sh_r;
		2085	}
		2086	for (i = 0; i <= mask_g>>sh_g; i++)
		2087	{
		2088	RUINT32T tmp;
		2089	tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_g-lower_lim_g));
		2090	tmp += ((RUINT32T)(mask_g>>sh_g))*((RUINT32T)lower_lim_g);
		2091	lookup_g[i] = (tmp/65535)<<sh_g;
		2092	}
		2093	for (i = 0; i <= mask_b>>sh_b; i++)
		2094	{
		2095	RUINT32T tmp;
		2096	tmp = ((RUINT32T)i)*((RUINT32T)(upper_lim_b-lower_lim_b));
		2097	tmp += ((RUINT32T)(mask_b>>sh_b))*((RUINT32T)lower_lim_b);
		2098	lookup_b[i] = (tmp/65535)<<sh_b;
		2099	}
		2100
		2101	/* apply table to input image (replacing colors by newly calculated ones) */
		2102	switch (srcImage->bits_per_pixel)
		2103	{
		2104	case 15:
		2105	{
		2106	unsigned short *p1, *pf, *p, *pl;
		2107	p1 = (unsigned short *) srcImage->data;
		2108	pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
		2109	while (p1 < pf)
		2110	{
		2111	p = p1;
		2112	pl = p1 + srcImage->width;
		2113	for (; p < pl; p++)
1749	}	2114	{
		2115	*p = lookup_r[(*p & 0x7c00)>>10] |
		2116	lookup_g[(*p & 0x03e0)>> 5] |
		2117	lookup_b[(*p & 0x001f)];
		2118	}
		2119	p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
1750	}	2120	}
1751	}	2121	break;
1752		2122	}
1753	/* RGB 16 */	2123	case 16:
1754	static void	2124	{
1755	shade_ximage_16(void *data, int bpl, int w, int h, int rm, int gm, int bm)	2125	unsigned short *p1, *pf, *p, *pl;
1756	{	2126	p1 = (unsigned short *) srcImage->data;
1757	unsigned char *ptr;	2127	pf = (unsigned short *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1758	int x, y;	2128	while (p1 < pf)
1759		2129	{
1760	ptr = (unsigned char *)data + (w * sizeof(uint16_t));	2130	p = p1;
1761	if ((rm <= 256) && (gm <= 256) && (bm <= 256)) {	2131	pl = p1 + srcImage->width;
1762	/* No saturation */	2132	for (; p < pl; p++)
1763	for (y = h; --y >= 0;) {
1764	for (x = -w; x < 0; x++) {
1765	int r, g, b;
1766
1767	b = ((uint16_t *) ptr)[x];
1768	r = (b & 0xf800) * rm;
1769	g = (b & 0x7e0) * gm;
1770	b = (b & 0x1f) * bm;
1771	((uint16_t *) ptr)[x] = ((r >> 8) & 0xf800)
1772	| ((g >> 8) & 0x7e0)
1773	| ((b >> 8) & 0x1f);
1774	}
1775	ptr += bpl;
1776	}	2133	{
1777	} else {	2134	*p = lookup_r[(*p & 0xf800)>>11] |
1778	for (y = h; --y >= 0;) {	2135	lookup_g[(*p & 0x07e0)>> 5] |
1779	for (x = -w; x < 0; x++) {	2136	lookup_b[(*p & 0x001f)];
1780	int r, g, b;
1781
1782	b = ((uint16_t *) ptr)[x];
1783	r = (b & 0xf800) * rm;
1784	g = (b & 0x7e0) * gm;
1785	b = (b & 0x1f) * bm;
1786	r |= (!(r >> 16) - 1);
1787	g |= (!(g >> 11) - 1);
1788	b |= (!(b >> 5) - 1);
1789	((uint16_t *) ptr)[x] = ((r >> 8) & 0xf800)
1790	| ((g >> 8) & 0x7e0)
1791	| ((b >> 8) & 0x1f);
1792	}	2137	}
1793	ptr += bpl;	2138	p1 = (unsigned short *) ((char *) p1 + srcImage->bytes_per_line);
		2139	}
		2140	break;
		2141	}
		2142	case 24:
		2143	{
		2144	unsigned char *p1, *pf, *p, *pl;
		2145	p1 = (unsigned char *) srcImage->data;
		2146	pf = (unsigned char *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
		2147	while (p1 < pf)
		2148	{
		2149	p = p1;
		2150	pl = p1 + srcImage->width * 3;
		2151	for (; p < pl; p += 3)
1794	}	2152	{
		2153	p[0] = lookup_r[(p[0] & 0xff0000)>>16];
		2154	p[1] = lookup_r[(p[1] & 0x00ff00)>> 8];
		2155	p[2] = lookup_r[(p[2] & 0x0000ff)];
		2156	}
		2157	p1 = (unsigned char *) ((char *) p1 + srcImage->bytes_per_line);
1795	}	2158	}
1796	}	2159	break;
		2160	}
		2161	case 32:
		2162	{
		2163	RUINT32T *p1, *pf, *p, *pl;
		2164	p1 = (RUINT32T *) srcImage->data;
		2165	pf = (RUINT32T *) (srcImage->data + srcImage->height * srcImage->bytes_per_line);
1797		2166
1798	/* RGB 24 */	2167	while (p1 < pf)
1799	static void	2168	{
1800	shade_ximage_24(void *data, int bpl, int w, int h, int rm, int gm, int bm)	2169	p = p1;
1801	{	2170	pl = p1 + srcImage->width;
1802	unsigned char *ptr;	2171	for (; p < pl; p++)
1803	int x, y;
1804
1805	ptr = (unsigned char *)data + (w * 3);
1806	if ((rm <= 256) && (gm <= 256) && (bm <= 256)) {
1807	/* No saturation */
1808	for (y = h; --y >= 0;) {
1809	for (x = -(w * 3); x < 0; x += 3) {
1810	int r, g, b;
1811
1812	if (byteorder.big_endian()) {
1813	r = (ptr[x + 0] * rm) >> 8;
1814	g = (ptr[x + 1] * gm) >> 8;
1815	b = (ptr[x + 2] * bm) >> 8;
1816	ptr[x + 0] = r;
1817	ptr[x + 1] = g;
1818	ptr[x + 2] = b;
1819	} else {
1820	r = (ptr[x + 2] * rm) >> 8;
1821	g = (ptr[x + 1] * gm) >> 8;
1822	b = (ptr[x + 0] * bm) >> 8;
1823	ptr[x + 2] = r;
1824	ptr[x + 1] = g;
1825	ptr[x + 0] = b;
1826	}
1827	}
1828	ptr += bpl;
1829	}	2172	{
1830	} else {	2173	*p = lookup_r[(*p & 0xff0000)>>16] |
1831	for (y = h; --y >= 0;) {	2174	lookup_g[(*p & 0x00ff00)>> 8] |
1832	for (x = -(w * 3); x < 0; x += 3) {	2175	lookup_b[(*p & 0x0000ff)] |
1833	int r, g, b;	2176	(*p & ~0xffffff);
1834
1835	if (byteorder.big_endian()) {
1836	r = (ptr[x + 0] * rm) >> 8;
1837	g = (ptr[x + 1] * gm) >> 8;
1838	b = (ptr[x + 2] * bm) >> 8;
1839
1840	r |= (!(r >> 8) - 1);
1841	g |= (!(g >> 8) - 1);
1842	b |= (!(b >> 8) - 1);
1843
1844	ptr[x + 0] = r;
1845	ptr[x + 1] = g;
1846	ptr[x + 2] = b;
1847	} else {
1848	r = (ptr[x + 2] * rm) >> 8;
1849	g = (ptr[x + 1] * gm) >> 8;
1850	b = (ptr[x + 0] * bm) >> 8;
1851
1852	r |= (!(r >> 8) - 1);
1853	g |= (!(g >> 8) - 1);
1854	b |= (!(b >> 8) - 1);
1855
1856	ptr[x + 2] = r;
1857	ptr[x + 1] = g;
1858	ptr[x + 0] = b;
1859	}
1860	}	2177	}
1861	ptr += bpl;	2178	p1 = (RUINT32T *) ((char *) p1 + srcImage->bytes_per_line);
1862	}	2179	}
		2180	break;
		2181	}
1863	}	2182	}
1864	}
1865		2183
1866	/* RGB 32 */	2184	free (lookup);
1867	static void
1868	shade_ximage_32(void *data, int bpl, int w, int h, int rm, int gm, int bm)
1869	{
1870	unsigned char *ptr;
1871	int x, y;
1872
1873	ptr = (unsigned char *)data + (w * 4);
1874	if ((rm <= 256) && (gm <= 256) && (bm <= 256)) {
1875	/* No saturation */
1876	for (y = h; --y >= 0;) {
1877	if (byteorder.big_endian()) {
1878	for (x = -(w * 4); x < 0; x += 4) {
1879	int r, g, b;
1880
1881	r = (ptr[x + 1] * rm) >> 8;
1882	g = (ptr[x + 2] * gm) >> 8;
1883	b = (ptr[x + 3] * bm) >> 8;
1884	ptr[x + 1] = r;
1885	ptr[x + 2] = g;
1886	ptr[x + 3] = b;
1887	}
1888	} else {
1889	for (x = -(w * 4); x < 0; x += 4) {
1890	int r, g, b;
1891
1892	r = (ptr[x + 2] * rm) >> 8;
1893	g = (ptr[x + 1] * gm) >> 8;
1894	b = (ptr[x + 0] * bm) >> 8;
1895	ptr[x + 2] = r;
1896	ptr[x + 1] = g;
1897	ptr[x + 0] = b;
1898	}
1899	}
1900	ptr += bpl;
1901	}
1902	} else {
1903	for (y = h; --y >= 0;) {
1904	for (x = -(w * 4); x < 0; x += 4) {
1905	int r, g, b;
1906
1907	if (byteorder.big_endian()) {
1908	r = (ptr[x + 1] * rm) >> 8;
1909	g = (ptr[x + 2] * gm) >> 8;
1910	b = (ptr[x + 3] * bm) >> 8;
1911
1912	r |= (!(r >> 8) - 1);
1913	g |= (!(g >> 8) - 1);
1914	b |= (!(b >> 8) - 1);
1915
1916	ptr[x + 1] = r;
1917	ptr[x + 2] = g;
1918	ptr[x + 3] = b;
1919	} else {
1920	r = (ptr[x + 2] * rm) >> 8;
1921	g = (ptr[x + 1] * gm) >> 8;
1922	b = (ptr[x + 0] * bm) >> 8;
1923
1924	r |= (!(r >> 8) - 1);
1925	g |= (!(g >> 8) - 1);
1926	b |= (!(b >> 8) - 1);
1927
1928	ptr[x + 2] = r;
1929	ptr[x + 1] = g;
1930	ptr[x + 0] = b;
1931	}
1932	}
1933	ptr += bpl;
1934	}
1935	}
1936	}	2185	}
1937
1938	#endif	2186	#endif
1939		2187
1940	/*	2188	/*
1941	* Check our parents are still who we think they are.	2189	* Check our parents are still who we think they are.
1942	* Do transparency updates if required	2190	* Do transparency updates if required
…		…
1965	if (rootdepth != wattr.depth)	2213	if (rootdepth != wattr.depth)
1966	{	2214	{
1967	if (am_transparent)	2215	if (am_transparent)
1968	{	2216	{
1969	pchanged = 1;	2217	pchanged = 1;
1970	XSetWindowBackground (display->display, TermWin.vt, PixColors[Color_bg]);	2218	XSetWindowBackground (display->display, TermWin.vt, PixColorsFocused[Color_bg]);
1971	am_transparent = am_pixmap_trans = 0;	2219	am_transparent = am_pixmap_trans = 0;
1972	}	2220	}
1973		2221
1974	return pchanged; /* Don't try any more */	2222	return pchanged; /* Don't try any more */
1975	}	2223	}
…		…
1991	i = (xa[XA_XSETROOTID]	2239	i = (xa[XA_XSETROOTID]
1992	&& XGetWindowProperty (display->display, display->root, xa[XA_XSETROOTID],	2240	&& XGetWindowProperty (display->display, display->root, xa[XA_XSETROOTID],
1993	0L, 1L, False, XA_PIXMAP, &atype, &aformat,	2241	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
1994	&nitems, &bytes_after, &prop) == Success);	2242	&nitems, &bytes_after, &prop) == Success);
1995		2243
1996	if (!i || prop == NULL)	2244	if (!i || prop == NULL
		2245	#if TINTING
		2246	|| !rs[Rs_color + Color_tint]
		2247	#endif
		2248	)
1997	have_pixmap = 0;	2249	have_pixmap = 0;
1998	else	2250	else
1999	{	2251	{
2000	have_pixmap = 1;	2252	have_pixmap = 1;
2001	rootpixmap = * ((Pixmap *)prop);	2253	rootpixmap = *(Pixmap *)prop;
2002	XFree (prop);	2254	XFree (prop);
2003	}	2255	}
2004		2256
2005	if (have_pixmap)	2257	if (have_pixmap)
2006	{	2258	{
…		…
2063	XFreePixmap (display->display, TermWin.pixmap);	2315	XFreePixmap (display->display, TermWin.pixmap);
2064		2316
2065	#if TINTING	2317	#if TINTING
2066	if (ISSET_PIXCOLOR (Color_tint))	2318	if (ISSET_PIXCOLOR (Color_tint))
2067	{	2319	{
2068	unsigned short shade, rm, gm, bm;	2320	unsigned short rm, gm, bm;
		2321	int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;
2069		2322
2070	PixColors[Color_tint].get (display, rm, gm, bm);	2323	PixColorsFocused[Color_tint].get (display, rm, gm, bm);
2071		2324
2072	rm >>= 8; gm >>= 8; bm >>= 8; // not 100% correct, but...	2325	ShadeXImage (display, image, shade, rm, gm, bm);
2073
2074	/* Determine bitshift and bitmask values */
2075	switch (image->bits_per_pixel)
2076	{
2077	case 15: shade_ximage_15 (image->data, image->bytes_per_line, image->width, image->height, rm, gm, bm); break;
2078	case 16: shade_ximage_16 (image->data, image->bytes_per_line, image->width, image->height, rm, gm, bm); break;
2079	case 24: shade_ximage_24 (image->data, image->bytes_per_line, image->width, image->height, rm, gm, bm); break;
2080	case 32: shade_ximage_32 (image->data, image->bytes_per_line, image->width, image->height, rm, gm, bm); break;
2081	}
2082	}	2326	}
2083	#endif	2327	#endif
2084		2328
2085	TermWin.pixmap = XCreatePixmap (display->display, TermWin.vt,	2329	TermWin.pixmap = XCreatePixmap (display->display, TermWin.vt,
2086	szHint.width, szHint.height, image->depth);	2330	szHint.width, szHint.height, image->depth);
2087	gc = XCreateGC (display->display, TermWin.vt, 0UL, &gcvalue);	2331	gc = XCreateGC (display->display, TermWin.vt, 0UL, &gcvalue);
2088	XPutImage (display->display, TermWin.pixmap, gc, image, 0, 0,	2332	XPutImage (display->display, TermWin.pixmap, gc, image, 0, 0,
2089	nx, ny, image->width, image->height);	2333	nx, ny, image->width, image->height);
2090	XFreeGC (display->display, gc);	2334	XFreeGC (display->display, gc);
2091	XDestroyImage (image);	2335	XDestroyImage (image);
2092	XSetWindowBackgroundPixmap (display->display, TermWin.vt,	2336	XSetWindowBackgroundPixmap (display->display, TermWin.parent[0], TermWin.pixmap);
2093	TermWin.pixmap);	2337	XClearWindow (display->display, TermWin.parent[0]);
2094		2338
2095	if (!am_transparent || !am_pixmap_trans)	2339	if (!am_transparent || !am_pixmap_trans)
2096	pchanged = 1;	2340	pchanged = 1;
2097		2341
2098	am_transparent = am_pixmap_trans = 1;	2342	am_transparent = am_pixmap_trans = 1;
…		…
2143	}	2387	}
2144		2388
2145	if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0])))	2389	if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0])))
2146	{	2390	{
2147	D_X ((stderr, "InheritPixmap Turning off"));	2391	D_X ((stderr, "InheritPixmap Turning off"));
2148	XSetWindowBackground (display->display, TermWin.parent[0], PixColors[Color_fg]);	2392	XSetWindowBackground (display->display, TermWin.parent[0], PixColorsFocused[Color_fg]);
2149	XSetWindowBackground (display->display, TermWin.vt, PixColors[Color_bg]);	2393	XSetWindowBackground (display->display, TermWin.vt, PixColorsFocused[Color_bg]);
2150	am_transparent = 0;	2394	am_transparent = 0;
2151	/* XXX: also turn off Opt_transparent? */	2395	/* XXX: also turn off Opt_transparent? */
2152	}	2396	}
2153	else	2397	else
2154	{	2398	{
…		…
2157	* needed for fvwm2.2.2 (and before?) */	2401	* needed for fvwm2.2.2 (and before?) */
2158	sleep (1);	2402	sleep (1);
2159	#endif	2403	#endif
2160	D_X ((stderr, "InheritPixmap Turning on (%d parents)", i - 1));	2404	D_X ((stderr, "InheritPixmap Turning on (%d parents)", i - 1));
2161	for (n = 0; n < (unsigned int)i; n++)	2405	for (n = 0; n < (unsigned int)i; n++)
		2406	{
2162	XSetWindowBackgroundPixmap (display->display, TermWin.parent[n], ParentRelative);	2407	XSetWindowBackgroundPixmap (display->display, TermWin.parent[n], ParentRelative);
		2408	XClearWindow (display->display, TermWin.parent[n]);
		2409	}
2163		2410
2164	XSetWindowBackgroundPixmap (display->display, TermWin.vt, ParentRelative);	2411	XSetWindowBackgroundPixmap (display->display, TermWin.vt, ParentRelative);
2165	am_transparent = 1;	2412	am_transparent = 1;
2166	}	2413	}
2167		2414
2168	for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)	2415	for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
2169	TermWin.parent[i] = None;	2416	TermWin.parent[i] = None;
		2417	}
		2418
		2419	// this is experimental
		2420	if (scrollBar.win)
		2421	{
		2422	XSetWindowBackgroundPixmap (display->display, scrollBar.win, ParentRelative);
		2423	XClearWindow (display->display, scrollBar.win);
		2424	scrollBar.setIdle ();
		2425	scrollbar_show (0);
2170	}	2426	}
2171		2427
2172	return pchanged;	2428	return pchanged;
2173	}	2429	}
2174	#endif	2430	#endif
…		…
2191	}	2447	}
2192		2448
2193	if (ch == NOCHAR) // TODO: improve	2449	if (ch == NOCHAR) // TODO: improve
2194	break;	2450	break;
2195		2451
2196	if (!IS_CONTROL (ch) || ch == '\t' || ch == '\n' || ch == '\r')	2452	if (!IS_CONTROL (ch) || ch == C0_LF || ch == C0_CR || ch == C0_HT)
2197	{	2453	{
2198	/* Read a text string from the input buffer */	2454	/* Read a text string from the input buffer */
2199	unicode_t buf[UBUFSIZ];	2455	unicode_t buf[UBUFSIZ];
2200	bool refreshnow = false;	2456	bool refreshnow = false;
2201	int nlines = 0;	2457	int nlines = 0;
2202	unicode_t *str = buf;	2458	unicode_t *str = buf;
2203		2459
2204	*str++ = ch;
2205
2206	for (;;)	2460	for (;;)
2207	{	2461	{
2208	seq_begin = cmdbuf_ptr;
2209	ch = next_char ();
2210
2211	if (ch == NOCHAR || (IS_CONTROL (ch) && ch != '\t' && ch != '\n' && ch != '\r'))	2462	if (ch == NOCHAR || (IS_CONTROL (ch) && ch != C0_LF && ch != C0_CR && ch != C0_HT))
2212	break;	2463	break;
2213		2464
2214	*str++ = ch;	2465	*str++ = ch;
2215		2466
2216	if (ch == '\n')	2467	if (ch == C0_LF)
2217	{	2468	{
2218	nlines++;	2469	nlines++;
2219	refresh_count++;	2470	refresh_count++;
2220		2471
2221	if (! (Options & Opt_jumpScroll)	2472	if (!(Options & Opt_jumpScroll)
2222	|| (refresh_count >= (refresh_limit * (TermWin.nrow - 1))))	2473	|| (refresh_count >= refresh_limit * (TermWin.nrow - 1)))
2223	{	2474	{
2224	refreshnow = true;	2475	refreshnow = true;
2225	flag = true;
2226	ch = NOCHAR;	2476	ch = NOCHAR;
2227	break;	2477	break;
2228	}	2478	}
2229		2479
2230	// scr_add_lines only works for nlines < TermWin.nrow - 1.	2480	// scr_add_lines only works for nlines <= TermWin.nrow - 1.
2231	if (nlines >= TermWin.nrow - 1)	2481	if (nlines >= TermWin.nrow - 1)
2232	{	2482	{
2233	scr_add_lines (buf, nlines, str - buf);	2483	scr_add_lines (buf, nlines, str - buf);
2234	nlines = 0;	2484	nlines = 0;
2235	str = buf;	2485	str = buf;
…		…
2239	if (str >= buf + UBUFSIZ)	2489	if (str >= buf + UBUFSIZ)
2240	{	2490	{
2241	ch = NOCHAR;	2491	ch = NOCHAR;
2242	break;	2492	break;
2243	}	2493	}
		2494
		2495	seq_begin = cmdbuf_ptr;
		2496	ch = next_char ();
2244	}	2497	}
2245		2498
2246	scr_add_lines (buf, nlines, str - buf);	2499	scr_add_lines (buf, nlines, str - buf);
2247		2500
2248	/*	2501	/*
2249	* If there have been a lot of new lines, then update the screen	2502	* If there have been a lot of new lines, then update the screen
2250	* What the heck I'll cheat and only refresh less than every page-full.	2503	* What the heck I'll cheat and only refresh less than every page-full.
2251	* the number of pages between refreshes is refresh_limit, which	2504	* the number of pages between refreshes is refresh_limit, which
2252	* is incremented here because we must be doing flat-out scrolling.	2505	* is incremented here because we must be doing flat-out scrolling.
2253	*
2254	* refreshing should be correct for small scrolls, because of the
2255	* time-out
2256	*/	2506	*/
2257	if (refreshnow)	2507	if (refreshnow)
2258	{	2508	{
2259	if ((Options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)	2509	if ((Options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)
2260	refresh_limit++;	2510	refresh_limit++;
2261		2511	else
		2512	{
		2513	flag = true;
2262	scr_refresh (refresh_type);	2514	scr_refresh (refresh_type);
		2515	}
2263	}	2516	}
2264		2517
2265	}	2518	}
2266	else	2519	else
2267	{	2520	{
…		…
2281	}	2534	}
2282		2535
2283	return flag;	2536	return flag;
2284	}	2537	}
2285		2538
		2539	// read the next octet
		2540	unicode_t
		2541	rxvt_term::next_octet ()
		2542	{
		2543	return cmdbuf_ptr < cmdbuf_endp
		2544	? *cmdbuf_ptr++
		2545	: NOCHAR;
		2546	}
		2547
2286	// read the next character	2548	// read the next character
2287	unicode_t	2549	unicode_t
2288	rxvt_term::next_char ()	2550	rxvt_term::next_char ()
2289	{	2551	{
2290	while (cmdbuf_ptr < cmdbuf_endp)	2552	while (cmdbuf_ptr < cmdbuf_endp)
…		…
2321	*/	2583	*/
2322	unicode_t	2584	unicode_t
2323	rxvt_term::cmd_getc ()	2585	rxvt_term::cmd_getc ()
2324	{	2586	{
2325	unicode_t c = next_char ();	2587	unicode_t c = next_char ();
		2588
		2589	if (c == NOCHAR)
		2590	throw out_of_input;
		2591
		2592	return c;
		2593	}
		2594
		2595	unicode_t
		2596	rxvt_term::cmd_get8 ()
		2597	{
		2598	unicode_t c = next_octet ();
2326		2599
2327	if (c == NOCHAR)	2600	if (c == NOCHAR)
2328	throw out_of_input;	2601	throw out_of_input;
2329		2602
2330	return c;	2603	return c;
…		…
2460	break;	2733	break;
2461	case C0_SI: /* shift in - acs */	2734	case C0_SI: /* shift in - acs */
2462	scr_charset_choose (0);	2735	scr_charset_choose (0);
2463	break;	2736	break;
2464		2737
		2738	#ifdef EIGHT_BIT_CONTROLS
2465	// 8-bit controls	2739	// 8-bit controls
2466	case 0x90: /* DCS */	2740	case 0x90: /* DCS */
2467	process_dcs_seq ();	2741	process_dcs_seq ();
2468	break;	2742	break;
2469	case 0x9b: /* CSI */	2743	case 0x9b: /* CSI */
2470	process_csi_seq ();	2744	process_csi_seq ();
2471	break;	2745	break;
2472	case 0x9d: /* CSI */	2746	case 0x9d: /* CSI */
2473	process_osc_seq ();	2747	process_osc_seq ();
2474	break;	2748	break;
		2749	#endif
2475	}	2750	}
2476	}	2751	}
2477	/*}}} */	2752	/*}}} */
2478		2753
2479		2754
…		…
2597	break;	2872	break;
2598		2873
2599	/* 8.3.87: NEXT LINE */	2874	/* 8.3.87: NEXT LINE */
2600	case C1_NEL: /* ESC E */	2875	case C1_NEL: /* ESC E */
2601	{	2876	{
2602	unicode_t nlcr[] = { L'\n', L'\r' };	2877	unicode_t nlcr[] = { C0_LF, C0_CR };
2603	scr_add_lines (nlcr, 1, 2);	2878	scr_add_lines (nlcr, 1, 2);
2604	}	2879	}
2605	break;	2880	break;
2606		2881
2607	/* kidnapped escape sequence: Should be 8.3.48 */	2882	/* kidnapped escape sequence: Should be 8.3.48 */
…		…
2668		2943
2669	/*{{{ process CONTROL SEQUENCE INTRODUCER (CSI) sequences `ESC[' */	2944	/*{{{ process CONTROL SEQUENCE INTRODUCER (CSI) sequences `ESC[' */
2670	/* *INDENT-OFF* */	2945	/* *INDENT-OFF* */
2671	enum {	2946	enum {
2672	CSI_ICH = 0x40,	2947	CSI_ICH = 0x40,
2673	CSI_CUU, CSI_CUD, CSI_CUF, CSI_CUB, CSI_CNL, CSI_CPL, CSI_CHA,	2948	CSI_CUU, CSI_CUD, CSI_CUF, CSI_CUB, CSI_CNL, CSI_CPL, CSI_CHA,
2674	CSI_CUP, CSI_CHT, CSI_ED , CSI_EL , CSI_IL , CSI_DL , CSI_EF , CSI_EA ,	2949	CSI_CUP, CSI_CHT, CSI_ED , CSI_EL , CSI_IL , CSI_DL , CSI_EF , CSI_EA ,
2675	CSI_DCH, CSI_SEE, CSI_CPR, CSI_SU , CSI_SD , CSI_NP , CSI_PP , CSI_CTC,	2950	CSI_DCH, CSI_SEE, CSI_CPR, CSI_SU , CSI_SD , CSI_NP , CSI_PP , CSI_CTC,
2676	CSI_ECH, CSI_CVT, CSI_CBT, CSI_SRS, CSI_PTX, CSI_SDS, CSI_SIMD, CSI_5F,	2951	CSI_ECH, CSI_CVT, CSI_CBT, CSI_SRS, CSI_PTX, CSI_SDS, CSI_SIMD, CSI_5F,
2677	CSI_HPA, CSI_HPR, CSI_REP, CSI_DA , CSI_VPA, CSI_VPR, CSI_HVP, CSI_TBC,	2952	CSI_HPA, CSI_HPR, CSI_REP, CSI_DA , CSI_VPA, CSI_VPR, CSI_HVP, CSI_TBC,
2678	CSI_SM , CSI_MC , CSI_HPB, CSI_VPB, CSI_RM , CSI_SGR, CSI_DSR, CSI_DAQ,	2953	CSI_SM , CSI_MC , CSI_HPB, CSI_VPB, CSI_RM , CSI_SGR, CSI_DSR, CSI_DAQ,
…		…
3070	break;	3345	break;
3071	case 19: /* report window size (chars) */	3346	case 19: /* report window size (chars) */
3072	tt_printf ("\033[9;%d;%dt", TermWin.nrow, TermWin.ncol);	3347	tt_printf ("\033[9;%d;%dt", TermWin.nrow, TermWin.ncol);
3073	break;	3348	break;
3074	case 20: /* report icon label */	3349	case 20: /* report icon label */
3075	if (Options & Opt_insecure)
3076	{	3350	{
3077	char *s;	3351	char *s;
3078	XGetIconName (display->display, TermWin.parent[0], &s);	3352	XGetIconName (display->display, TermWin.parent[0], &s);
3079	tt_printf ("\033]L%-.200s\234", s ? s : ""); /* 8bit ST */	3353	tt_printf ("\033]L%-.250s\234", (Options & Opt_insecure) && s ? s : ""); /* 8bit ST */
		3354	XFree (s);
3080	}	3355	}
3081	break;	3356	break;
3082	case 21: /* report window title */	3357	case 21: /* report window title */
3083	if (Options & Opt_insecure)
3084	{	3358	{
3085	char *s;	3359	char *s;
3086	XFetchName (display->display, TermWin.parent[0], &s);	3360	XFetchName (display->display, TermWin.parent[0], &s);
3087	tt_printf ("\033]l%-.200s\234", s ? s : ""); /* 8bit ST */	3361	tt_printf ("\033]l%-.250s\234", (Options & Opt_insecure) && s ? s : ""); /* 8bit ST */
		3362	XFree (s);
3088	}	3363	}
3089	break;	3364	break;
3090	}	3365	}
3091	}	3366	}
3092	#endif	3367	#endif
3093		3368
3094	/*----------------------------------------------------------------------*/	3369	/*----------------------------------------------------------------------*/
3095	/*	3370	/*
3096	* get input up until STRING TERMINATOR (or BEL)	3371	* get input up until STRING TERMINATOR (or BEL)
3097	* ends_how is terminator used. returned input must be free ()d	3372	* ends_how is terminator used. returned input must be free()'d
3098	*/	3373	*/
3099	unsigned char *	3374	unsigned char *
3100	rxvt_term::get_to_st (unicode_t &ends_how)	3375	rxvt_term::get_to_st (unicode_t &ends_how)
3101	{	3376	{
3102	int seen_esc = 0; /* seen escape? */	3377	unicode_t prev = 0, ch;
3103	unsigned int n = 0;	3378	unsigned int n = 0;
3104	unsigned char *s;	3379	unsigned char *s;
3105	unicode_t ch;
3106	unsigned char string[STRING_MAX];	3380	unsigned char string[STRING_MAX];
3107		3381
3108	while ((ch = cmd_getc ()))	3382	while ((ch = cmd_getc ()) != NOCHAR)
3109	{	3383	{
3110	if (ch == C0_BEL || ch == CHAR_ST)	3384	if (prev == C0_ESC)
3111	break;	3385	{
3112
3113	if (seen_esc)
3114	if (ch == 0x5c) /* 7bit ST */	3386	if (ch == 0x5c) /* 7bit ST */
3115	break;	3387	break;
3116	else	3388	else
3117	return NULL;	3389	return NULL;
3118
3119	if (ch == C0_ESC)
3120	{	3390	}
3121	seen_esc = 1;	3391	else if (ch == C0_BEL || ch == CHAR_ST)
3122	continue;	3392	break;
3123	}	3393	else if (ch < 0x20)
3124	else if (ch == '\t')
3125	ch = ' '; /* translate '\t' to space */
3126	else if (ch < 0x20 && (ch != 0x0a && ch != 0x0d))
3127	return NULL; /* other control character - exit */	3394	return NULL; /* other control character - exit */
3128		3395
3129	if (n >= sizeof (string) - 1)	3396	if (n >= sizeof (string) - 1)
3130	// stop at some sane length	3397	// stop at some sane length
3131	return NULL;	3398	return NULL;
3132		3399
		3400	if (ch == C0_SYN)
		3401	{
		3402	string[n++] = cmd_get8 ();
		3403	prev = 0;
		3404	}
		3405	else
3133	string[n++] = ch;	3406	string[n++] = prev = ch;
3134	seen_esc = 0;
3135	}	3407	}
3136		3408
3137	string[n++] = '\0';	3409	string[n++] = '\0';
3138		3410
3139	if ((s = (unsigned char *)rxvt_malloc (n)) == NULL)	3411	if ((s = (unsigned char *)rxvt_malloc (n)) == NULL)
…		…
3193	void	3465	void
3194	rxvt_term::process_color_seq (int report, int color, const char *str, unsigned char resp)	3466	rxvt_term::process_color_seq (int report, int color, const char *str, unsigned char resp)
3195	{	3467	{
3196	if (str[0] == '?' && !str[1])	3468	if (str[0] == '?' && !str[1])
3197	{	3469	{
3198	if (Options & Opt_insecure)
3199	{
3200	unsigned short r, g, b;	3470	unsigned short r, g, b;
3201	PixColors[color].get (display, r, g, b);	3471	PixColorsFocused[color].get (display, r, g, b);
3202	tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, r, g, b, resp);	3472	tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, r, g, b, resp);
3203	}
3204	}	3473	}
3205	else	3474	else
3206	set_window_color (color, str);	3475	set_window_color (color, str);
3207	}	3476	}
3208		3477
…		…
3308	if ((buf = STRCHR (name, ';')) != NULL)	3577	if ((buf = STRCHR (name, ';')) != NULL)
3309	*buf++ = '\0';	3578	*buf++ = '\0';
3310		3579
3311	if (name[0] == '?' && !name[1])	3580	if (name[0] == '?' && !name[1])
3312	{	3581	{
3313	if (Options & Opt_insecure)
3314	{
3315	unsigned short r, g, b;	3582	unsigned short r, g, b;
3316	PixColors[color + minCOLOR].get (display, r, g, b);	3583	PixColorsFocused[color + minCOLOR].get (display, r, g, b);
3317	tt_printf ("\033]%d;%d;rgb:%04x/%04x/%04x%c", XTerm_Color, color, r, g, b, resp);	3584	tt_printf ("\033]%d;%d;rgb:%04x/%04x/%04x%c", XTerm_Color, color, r, g, b, resp);
3318	}
3319	}	3585	}
3320	else	3586	else
3321	set_window_color (color + minCOLOR, name);	3587	set_window_color (color + minCOLOR, name);
3322	}	3588	}
3323	break;	3589	break;
…		…
3387	// TODO, when secure mode?	3653	// TODO, when secure mode?
3388	break;	3654	break;
3389		3655
3390	case XTerm_font:	3656	case XTerm_font:
3391	if (query)	3657	if (query)
3392	{
3393	if (Options & Opt_insecure)
3394	tt_printf ("\33]%d;%-.250s%c", XTerm_font,	3658	tt_printf ("\33]%d;%-.250s%c", XTerm_font,
		3659	(Options & Opt_insecure) && TermWin.fontset->fontdesc
3395	TermWin.fontset->fontdesc	3660	? TermWin.fontset->fontdesc : "",
3396	? TermWin.fontset->fontdesc
3397	: "",
3398	resp);	3661	resp);
3399	}
3400	else	3662	else
3401	change_font (str);	3663	change_font (str);
3402	break;	3664	break;
3403		3665
3404	#ifndef NO_FRILLS	3666	#ifndef NO_FRILLS
3405	case XTerm_locale:	3667	case XTerm_locale:
3406	if (query)	3668	if (query)
3407	{
3408	if (Options & Opt_insecure)
3409	tt_printf ("\33]%d;%-.250s%c", XTerm_locale, locale, resp);	3669	tt_printf ("\33]%d;%-.250s%c", XTerm_locale, (Options & Opt_insecure) ? locale : "", resp);
3410	}
3411	else	3670	else
3412	{	3671	{
3413	set_locale (str);	3672	set_locale (str);
3414	# ifdef USE_XIM	3673	# ifdef USE_XIM
3415	im_cb ();	3674	im_cb ();
3416	# endif	3675	# endif
3417	}	3676	}
3418	break;	3677	break;
3419		3678
3420	case XTerm_findfont:	3679	case XTerm_findfont:
3421	if (Options & Opt_insecure)
3422	{	3680	{
3423	int fid = TermWin.fontset->find_font (atoi (str));	3681	int fid = TermWin.fontset->find_font (atoi (str));
3424	tt_printf ("\33]%d;%d;%-.250s%c", XTerm_findfont,	3682	tt_printf ("\33]%d;%d;%-.250s%c", XTerm_findfont,
3425	fid, (*TermWin.fontset)[fid]->name, resp);	3683	fid,
		3684	(Options & Opt_insecure) ? (*TermWin.fontset)[fid]->name : "",
		3685	resp);
3426	}	3686	}
3427	break;	3687	break;
3428	#endif	3688	#endif
3429		3689
3430	#ifdef MENUBAR	3690	#ifdef MENUBAR
3431	case XTerm_Menu:	3691	case XTerm_Menu:
…		…
3694	rendset = 0, rendstyle = ~RS_None;	3954	rendset = 0, rendstyle = ~RS_None;
3695	break;	3955	break;
3696	case 1:	3956	case 1:
3697	rendset = 1, rendstyle = RS_Bold;	3957	rendset = 1, rendstyle = RS_Bold;
3698	break;	3958	break;
		3959	//case 2: // faint or second colour
3699	case 4:	3960	case 4:
3700	rendset = 1, rendstyle = RS_Uline;	3961	rendset = 1, rendstyle = RS_Uline;
3701	break;	3962	break;
3702	case 5:	3963	case 5: // slowly blinking
		3964	case 6: // rapidly blinking
3703	rendset = 1, rendstyle = RS_Blink;	3965	rendset = 1, rendstyle = RS_Blink;
3704	break;	3966	break;
		3967	//case 6: // scoansi light background
3705	case 7:	3968	case 7:
3706	rendset = 1, rendstyle = RS_RVid;	3969	rendset = 1, rendstyle = RS_RVid;
3707	break;	3970	break;
3708	case 8:	3971	case 8:
3709	// invisible. NYI	3972	// invisible. NYI
3710	break;	3973	break;
		3974	//case 9: // crossed out
		3975	//case 10: // scoansi acs off, primary font
		3976	//case 11: // scoansi acs on, first alt font
		3977	//case 12: // scoansi acs on, |0x80, second alt font
		3978	//...
		3979	//case 19: // ninth alt font
		3980	//case 20: // gothic
		3981	case 21: // disable bold, faint
		3982	rendset = 0, rendstyle = RS_Bold;
		3983	break;
3711	case 22:	3984	case 22:
3712	rendset = 0, rendstyle = RS_Bold;	3985	rendset = 0, rendstyle = RS_Bold;
3713	break;	3986	break;
		3987	//case 23: disable italic
3714	case 24:	3988	case 24:
3715	rendset = 0, rendstyle = RS_Uline;	3989	rendset = 0, rendstyle = RS_Uline;
3716	break;	3990	break;
3717	case 25:	3991	case 25:
3718	rendset = 0, rendstyle = RS_Blink;	3992	rendset = 0, rendstyle = RS_Blink;
3719	break;	3993	break;
3720	case 27:	3994	case 27:
3721	rendset = 0, rendstyle = RS_RVid;	3995	rendset = 0, rendstyle = RS_RVid;
3722	break;	3996	break;
3723	case 28:
3724	// visible. NYI	3997	//case 28: // visible. NYI
3725	break;	3998	//case 29: // not crossed-out
3726	}	3999	}
3727		4000
3728	if (rendset != -1)	4001	if (rendset != -1)
3729	{	4002	{
3730	scr_rendition (rendset, rendstyle);	4003	scr_rendition (rendset, rendstyle);
…		…
3807	}	4080	}
3808	}	4081	}
3809	}	4082	}
3810	/*}}} */	4083	/*}}} */
3811		4084
3812	/*{{{ process Rob Nation's own graphics mode sequences */	4085	/*{{{ (do not) process Rob Nation's own graphics mode sequences */
3813	void	4086	void
3814	rxvt_term::process_graphics ()	4087	rxvt_term::process_graphics ()
3815	{	4088	{
3816	unicode_t ch, cmd = cmd_getc ();	4089	unicode_t ch, cmd = cmd_getc ();
3817		4090

Diff Legend

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