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.35 by pcg, Sat Jan 31 03:27:45 2004 UTC vs.
Revision 1.36 by pcg, Sun Feb 1 01:34:41 2004 UTC

…		…
55		55
56	/*{{{ Convert the keypress event into a string */	56	/*{{{ Convert the keypress event into a string */
57	void	57	void
58	rxvt_term::lookup_key (XKeyEvent *ev)	58	rxvt_term::lookup_key (XKeyEvent *ev)
59	{	59	{
60	int ctrl, meta, shft, len;	60	int ctrl, meta, shft, len;
61	unsigned int newlen;	61	unsigned int newlen;
62	KeySym keysym;	62	KeySym keysym;
63	#ifdef DEBUG_CMD	63	#ifdef DEBUG_CMD
64	static int debug_key = 1; /* accessible by a debugger only */	64	static int debug_key = 1; /* accessible by a debugger only */
65	#endif	65	#endif
66	int valid_keysym;	66	int valid_keysym;
67	unsigned char kbuf[KBUFSZ];	67	unsigned char kbuf[KBUFSZ];
68		68
69	/*	69	/*
70	* use Num_Lock to toggle Keypad on/off. If Num_Lock is off, allow an	70	* use Num_Lock to toggle Keypad on/off. If Num_Lock is off, allow an
71	* escape sequence to toggle the Keypad.	71	* escape sequence to toggle the Keypad.
72	*	72	*
73	* Always permit `shift' to override the current setting	73	* Always permit `shift' to override the current setting
74	*/	74	*/
75	shft = (ev->state & ShiftMask);	75	shft = (ev->state & ShiftMask);
76	ctrl = (ev->state & ControlMask);	76	ctrl = (ev->state & ControlMask);
77	meta = (ev->state & ModMetaMask);	77	meta = (ev->state & ModMetaMask);
78		78
79	if (numlock_state || (ev->state & ModNumLockMask))	79	if (numlock_state || (ev->state & ModNumLockMask))
80	{	80	{
81	numlock_state = (ev->state & ModNumLockMask);	81	numlock_state = (ev->state & ModNumLockMask);
82	PrivMode((!numlock_state), PrivMode_aplKP);	82	PrivMode((!numlock_state), PrivMode_aplKP);
83	}	83	}
84		84
85	kbuf[0] = 0;	85	kbuf[0] = 0;
86		86
87	#ifdef USE_XIM	87	#ifdef USE_XIM
88	if (Input_Context)	88	if (Input_Context)
89	{	89	{
90	Status status_return;	90	Status status_return;
91		91
92	#ifdef X_HAVE_UTF8_STRING	92	#ifdef X_HAVE_UTF8_STRING
93	if (enc_utf8 && 0)	93	if (enc_utf8 && 0)
94	len = Xutf8LookupString (Input_Context, ev, (char *)kbuf,	94	len = Xutf8LookupString (Input_Context, ev, (char *)kbuf,
95	KBUFSZ, &keysym, &status_return);	95	KBUFSZ, &keysym, &status_return);
96	else	96	else
97	#endif	97	#endif
		98
98	{	99	{
99	wchar_t wkbuf[KBUFSZ + 1];	100	wchar_t wkbuf[KBUFSZ + 1];
100		101
101	// the XOpenIM manpage lies about hardcoding the locale	102	// the XOpenIM manpage lies about hardcoding the locale
102	// at the point of XOpenIM, so temporarily switch locales	103	// at the point of XOpenIM, so temporarily switch locales
103	if (rs[Rs_imLocale])	104	if (rs[Rs_imLocale])
104	SET_LOCALE (rs[Rs_imLocale]);	105	SET_LOCALE (rs[Rs_imLocale]);
105	// assume wchar_t == unicode or better	106	// assume wchar_t == unicode or better
106	len = XwcLookupString (Input_Context, ev, wkbuf,	107	len = XwcLookupString (Input_Context, ev, wkbuf,
107	KBUFSZ, &keysym, &status_return);	108	KBUFSZ, &keysym, &status_return);
108	if (rs[Rs_imLocale])	109	if (rs[Rs_imLocale])
109	SET_LOCALE (locale);	110	SET_LOCALE (locale);
110		111
111	if (status_return == XLookupChars	112	if (status_return == XLookupChars
112	|| status_return == XLookupBoth)	113	|| status_return == XLookupBoth)
113	{	114	{
114	wkbuf[len] = 0;	115	wkbuf[len] = 0;
115	len = wcstombs ((char *)kbuf, wkbuf, KBUFSZ);	116	len = wcstombs ((char *)kbuf, wkbuf, KBUFSZ);
116	if (len < 0)	117	if (len < 0)
117	len = 0;	118	len = 0;
118	}	119	}
119	else	120	else
120	len = 0;	121	len = 0;
121	}	122	}
122		123
123	valid_keysym = status_return == XLookupKeySym	124	valid_keysym = status_return == XLookupKeySym
124	|| status_return == XLookupBoth;	125	|| status_return == XLookupBoth;
125	}	126	}
126	else	127	else
127	#endif	128	#endif
		129
128	{	130	{
129	len = XLookupString (ev, (char *)kbuf, KBUFSZ, &keysym, &compose);	131	len = XLookupString (ev, (char *)kbuf, KBUFSZ, &keysym, &compose);
130	valid_keysym = !len;	132	valid_keysym = !len;
131	}	133	}
132		134
133	if (valid_keysym)	135	if (valid_keysym)
134	{	136	{
135	/* for some backwards compatibility */	137	/* for some backwards compatibility */
136	#if defined(HOTKEY_CTRL) || defined(HOTKEY_META)	138	#if defined(HOTKEY_CTRL) || defined(HOTKEY_META)
137	# ifdef HOTKEY_CTRL	139	# ifdef HOTKEY_CTRL
138	if (ctrl)	140	if (ctrl)
139	# else	141	# else
140	if (meta)	142	if (meta)
141	# endif	143	# endif
142	{	144	{
143	if (keysym == ks_bigfont)	145	if (keysym == ks_bigfont)
144	{	146	{
145	change_font (0, FONT_UP);	147	change_font (0, FONT_UP);
146	return;	148	return;
147	}	149	}
148	else if (keysym == ks_smallfont)	150	else if (keysym == ks_smallfont)
149	{	151	{
150	change_font (0, FONT_DN);	152	change_font (0, FONT_DN);
151	return;	153	return;
		154	}
152	}	155	}
153	}
154	#endif	156	#endif
155		157
156	if (TermWin.saveLines) {	158	if (TermWin.saveLines)
		159	{
157	#ifdef UNSHIFTED_SCROLLKEYS	160	#ifdef UNSHIFTED_SCROLLKEYS
158	if (!ctrl && !meta) {	161	if (!ctrl && !meta)
		162	{
159	#else	163	#else
160	if (IS_SCROLL_MOD) {	164	if (IS_SCROLL_MOD)
		165	{
161	#endif	166	#endif
162	int lnsppg;	167	int lnsppg;
163		168
164	#ifdef PAGING_CONTEXT_LINES	169	#ifdef PAGING_CONTEXT_LINES
165	lnsppg = TermWin.nrow - PAGING_CONTEXT_LINES;	170	lnsppg = TermWin.nrow - PAGING_CONTEXT_LINES;
166	#else	171	#else
167	lnsppg = TermWin.nrow * 4 / 5;	172	lnsppg = TermWin.nrow * 4 / 5;
168	#endif	173	#endif
169	if (keysym == XK_Prior) {	174	if (keysym == XK_Prior)
		175	{
170	scr_page (UP, lnsppg);	176	scr_page (UP, lnsppg);
171	return;	177	return;
		178	}
172	} else if (keysym == XK_Next) {	179	else if (keysym == XK_Next)
		180	{
173	scr_page (DN, lnsppg);	181	scr_page (DN, lnsppg);
174	return;	182	return;
175	}	183	}
176	}	184	}
177	#ifdef SCROLL_ON_UPDOWN_KEYS	185	#ifdef SCROLL_ON_UPDOWN_KEYS
178	if (IS_SCROLL_MOD) {	186	if (IS_SCROLL_MOD)
179	if (keysym == XK_Up) {	187	{
180	scr_page (UP, 1);	188	if (keysym == XK_Up)
181	return;	189	{
		190	scr_page (UP, 1);
		191	return;
		192	}
182	} else if (keysym == XK_Down) {	193	else if (keysym == XK_Down)
183	scr_page (DN, 1);	194	{
184	return;	195	scr_page (DN, 1);
185	}	196	return;
186	}	197	}
		198	}
187	#endif	199	#endif
188	#ifdef SCROLL_ON_HOMEEND_KEYS	200	#ifdef SCROLL_ON_HOMEEND_KEYS
189	if (IS_SCROLL_MOD) {	201	if (IS_SCROLL_MOD)
190	if (keysym == XK_Home) {	202	{
191	scr_move_to (0, 1);	203	if (keysym == XK_Home)
192	return;	204	{
		205	scr_move_to (0, 1);
		206	return;
		207	}
193	} else if (keysym == XK_End) {	208	else if (keysym == XK_End)
194	scr_move_to (1, 0);	209	{
195	return;	210	scr_move_to (1, 0);
196	}	211	return;
197	}	212	}
		213	}
198	#endif	214	#endif
199	}
200		215
201	if (shft) {	216	}
		217
		218	if (shft)
		219	{
202	/* Shift + F1 - F10 generates F11 - F20 */	220	/* Shift + F1 - F10 generates F11 - F20 */
203	if (keysym >= XK_F1 && keysym <= XK_F10) {	221	if (keysym >= XK_F1 && keysym <= XK_F10)
		222	{
204	keysym += (XK_F11 - XK_F1);	223	keysym += (XK_F11 - XK_F1);
205	shft = 0; /* turn off Shift */	224	shft = 0; /* turn off Shift */
		225	}
206	} else if (!ctrl && !meta && (PrivateModes & PrivMode_ShiftKeys)) {	226	else if (!ctrl && !meta && (PrivateModes & PrivMode_ShiftKeys))
207	switch (keysym) {	227	{
208	/* normal XTerm key bindings */	228	switch (keysym)
		229	{
		230	/* normal XTerm key bindings */
209	case XK_Insert: /* Shift+Insert = paste mouse selection */	231	case XK_Insert: /* Shift+Insert = paste mouse selection */
210	selection_request (ev->time, 0, 0);	232	selection_request (ev->time, 0, 0);
211	return;	233	return;
212	/* rxvt extras */	234	/* rxvt extras */
213	case XK_KP_Add: /* Shift+KP_Add = bigger font */	235	case XK_KP_Add: /* Shift+KP_Add = bigger font */
214	change_font (0, FONT_UP);	236	change_font (0, FONT_UP);
215	return;	237	return;
216	case XK_KP_Subtract: /* Shift+KP_Subtract = smaller font */	238	case XK_KP_Subtract: /* Shift+KP_Subtract = smaller font */
217	change_font (0, FONT_DN);	239	change_font (0, FONT_DN);
218	return;	240	return;
219	}	241	}
220	}	242	}
221	}	243	}
222	#ifdef PRINTPIPE	244	#ifdef PRINTPIPE
223	if (keysym == XK_Print) {	245	if (keysym == XK_Print)
		246	{
224	scr_printscreen (ctrl | shft);	247	scr_printscreen (ctrl | shft);
225	return;	248	return;
226	}	249	}
227	#endif	250	#endif
228	#ifdef GREEK_SUPPORT	251	#ifdef GREEK_SUPPORT
229	if (keysym == ks_greekmodeswith) {	252	if (keysym == ks_greekmodeswith)
		253	{
230	greek_mode = !greek_mode;	254	greek_mode = !greek_mode;
231	if (greek_mode) {	255	if (greek_mode)
232	xterm_seq (XTerm_title,	256	{
		257	xterm_seq (XTerm_title,
233	(greek_getmode() == GREEK_ELOT928	258	(greek_getmode() == GREEK_ELOT928
234	? "[Greek: iso]" : "[Greek: ibm]"), CHAR_ST);	259	? "[Greek: iso]" : "[Greek: ibm]"), CHAR_ST);
235	greek_reset();	260	greek_reset();
236	} else	261	}
		262	else
237	xterm_seq (XTerm_title, APL_NAME "-" VERSION, CHAR_ST);	263	xterm_seq (XTerm_title, APL_NAME "-" VERSION, CHAR_ST);
238	return;	264	return;
239	}	265	}
240	#endif	266	#endif
241		267
242	if (keysym >= 0xFF00 && keysym <= 0xFFFF) {	268	if (keysym >= 0xFF00 && keysym <= 0xFFFF)
		269	{
243	#ifdef KEYSYM_RESOURCE	270	#ifdef KEYSYM_RESOURCE
244	if (!(shft | ctrl) && Keysym_map[keysym & 0xFF] != NULL) {	271	if (!(shft | ctrl) && Keysym_map[keysym & 0xFF] != NULL)
245	unsigned int l;	272	{
		273	unsigned int l;
246	const unsigned char *kbuf0;	274	const unsigned char *kbuf0;
247	const unsigned char ch = C0_ESC;	275	const unsigned char ch = C0_ESC;
248		276
249	kbuf0 = (Keysym_map[keysym & 0xFF]);	277	kbuf0 = (Keysym_map[keysym & 0xFF]);
250	l = (unsigned int)*kbuf0++;	278	l = (unsigned int)*kbuf0++;
251		279
252	/* escape prefix */	280	/* escape prefix */
253	if (meta)	281	if (meta)
254	# ifdef META8_OPTION	282	# ifdef META8_OPTION
255	if (meta_char == C0_ESC)	283	if (meta_char == C0_ESC)
256	# endif	284	# endif
257	tt_write (&ch, 1);	285	tt_write (&ch, 1);
258	tt_write (kbuf0, l);	286	tt_write (kbuf0, l);
259	return;	287	return;
260	} else	288	}
		289	else
261	#endif	290	#endif
262	{	291
263	newlen = 1;	292	{
264	switch (keysym) {	293	newlen = 1;
		294	switch (keysym)
		295	{
265	#ifndef NO_BACKSPACE_KEY	296	#ifndef NO_BACKSPACE_KEY
266	case XK_BackSpace:	297	case XK_BackSpace:
267	if (PrivateModes & PrivMode_HaveBackSpace) {	298	if (PrivateModes & PrivMode_HaveBackSpace)
		299	{
268	kbuf[0] = (!!(PrivateModes & PrivMode_BackSpace)	300	kbuf[0] = (!!(PrivateModes & PrivMode_BackSpace)
269	^ !!ctrl) ? '\b' : '\177';	301	^ !!ctrl) ? '\b' : '\177';
270	kbuf[1] = '\0';	302	kbuf[1] = '\0';
271	} else	303	}
272	STRCPY(kbuf, key_backspace);	304	else
		305	STRCPY(kbuf, key_backspace);
273	# ifdef MULTICHAR_SET	306	# ifdef MULTICHAR_SET
274	if ((Options & Opt_mc_hack) && screen.cur.col > 0) {	307	if ((Options & Opt_mc_hack) && screen.cur.col > 0)
275	int col, row;	308	{
		309	int col, row;
276		310
277	newlen = STRLEN(kbuf);	311	newlen = STRLEN(kbuf);
278	col = screen.cur.col - 1;	312	col = screen.cur.col - 1;
279	row = screen.cur.row + TermWin.saveLines;	313	row = screen.cur.row + TermWin.saveLines;
280	if (IS_MULTI2(screen.rend[row][col]))	314	if (IS_MULTI2(screen.rend[row][col]))
281	MEMMOVE(kbuf + newlen, kbuf, newlen + 1);	315	MEMMOVE(kbuf + newlen, kbuf, newlen + 1);
282	}	316	}
283	# endif	317	# endif
284	break;	318	break;
285	#endif	319	#endif
286	#ifndef NO_DELETE_KEY	320	#ifndef NO_DELETE_KEY
287	case XK_Delete:	321	case XK_Delete:
288	STRCPY(kbuf, key_delete);	322	STRCPY(kbuf, key_delete);
289	# ifdef MULTICHAR_SET	323	# ifdef MULTICHAR_SET
290	if (Options & Opt_mc_hack) {	324	if (Options & Opt_mc_hack)
291	int col, row;	325	{
292		326	int col, row;
293	newlen = STRLEN(kbuf);	327
294	col = screen.cur.col;	328	newlen = STRLEN(kbuf);
		329	col = screen.cur.col;
295	row = screen.cur.row + TermWin.saveLines;	330	row = screen.cur.row + TermWin.saveLines;
296	if (IS_MULTI1(screen.rend[row][col]))	331	if (IS_MULTI1(screen.rend[row][col]))
297	MEMMOVE(kbuf + newlen, kbuf, newlen + 1);	332	MEMMOVE(kbuf + newlen, kbuf, newlen + 1);
298	}	333	}
299	# endif	334	# endif
300	break;	335	break;
301	#endif	336	#endif
302	case XK_Tab:	337	case XK_Tab:
303	if (shft)	338	if (shft)
304	STRCPY(kbuf, "\033[Z");	339	STRCPY(kbuf, "\033[Z");
305	else {	340	else
		341	{
306	#ifdef CTRL_TAB_MAKES_META	342	#ifdef CTRL_TAB_MAKES_META
307	if (ctrl)	343	if (ctrl)
308	meta = 1;	344	meta = 1;
309	#endif	345	#endif
310	#ifdef MOD4_TAB_MAKES_META	346	#ifdef MOD4_TAB_MAKES_META
311	if (ev->state & Mod4Mask)	347	if (ev->state & Mod4Mask)
312	meta = 1;	348	meta = 1;
313	#endif	349	#endif
314	newlen = 0;	350	newlen = 0;
315	}	351	}
316	break;	352	break;
317		353
318		354
319	#ifdef XK_KP_Left	355	#ifdef XK_KP_Left
320	case XK_KP_Up: /* \033Ox or standard */	356	case XK_KP_Up: /* \033Ox or standard */
321	case XK_KP_Down: /* \033Or or standard */	357	case XK_KP_Down: /* \033Or or standard */
322	case XK_KP_Right: /* \033Ov or standard */	358	case XK_KP_Right: /* \033Ov or standard */
323	case XK_KP_Left: /* \033Ot or standard */	359	case XK_KP_Left: /* \033Ot or standard */
324	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {	360	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
325	STRCPY(kbuf, "\033OZ");	361	{
326	kbuf[2] = ("txvr"[keysym - XK_KP_Left]);	362	STRCPY(kbuf, "\033OZ");
327	break;	363	kbuf[2] = ("txvr"[keysym - XK_KP_Left]);
328	} else	364	break;
		365	}
		366	else
329	/* translate to std. cursor key */	367	/* translate to std. cursor key */
330	keysym = XK_Left + (keysym - XK_KP_Left);	368	keysym = XK_Left + (keysym - XK_KP_Left);
331	/* FALLTHROUGH */	369	/* FALLTHROUGH */
332	#endif	370	#endif
333	case XK_Up: /* "\033[A" */	371	case XK_Up: /* "\033[A" */
334	case XK_Down: /* "\033[B" */	372	case XK_Down: /* "\033[B" */
335	case XK_Right: /* "\033[C" */	373	case XK_Right: /* "\033[C" */
336	case XK_Left: /* "\033[D" */	374	case XK_Left: /* "\033[D" */
337	STRCPY(kbuf, "\033[Z");	375	STRCPY(kbuf, "\033[Z");
338	kbuf[2] = ("DACB"[keysym - XK_Left]);	376	kbuf[2] = ("DACB"[keysym - XK_Left]);
339	/* do Shift first */	377	/* do Shift first */
340	if (shft)	378	if (shft)
341	kbuf[2] = ("dacb"[keysym - XK_Left]);	379	kbuf[2] = ("dacb"[keysym - XK_Left]);
342	else if (ctrl) {	380	else if (ctrl)
343	kbuf[1] = 'O';	381	{
344	kbuf[2] = ("dacb"[keysym - XK_Left]);	382	kbuf[1] = 'O';
		383	kbuf[2] = ("dacb"[keysym - XK_Left]);
		384	}
345	} else if (PrivateModes & PrivMode_aplCUR)	385	else if (PrivateModes & PrivMode_aplCUR)
346	kbuf[1] = 'O';	386	kbuf[1] = 'O';
347	#ifdef MULTICHAR_SET	387	#ifdef MULTICHAR_SET
348	//TODO: ??	388	//TODO: ??
349	if (Options & Opt_mc_hack) {	389	if (Options & Opt_mc_hack)
350	int col, row, m;	390	{
		391	int col, row, m;
351		392
352	col = screen.cur.col;	393	col = screen.cur.col;
353	row = screen.cur.row + TermWin.saveLines;	394	row = screen.cur.row + TermWin.saveLines;
354	m = 0;	395	m = 0;
355	if (keysym == XK_Right	396	if (keysym == XK_Right
356	&& IS_MULTI1(screen.rend[row][col]))	397	&& IS_MULTI1(screen.rend[row][col]))
357	m = 1;	398	m = 1;
358	else if (keysym == XK_Left) {	399	else if (keysym == XK_Left)
359	if (col > 0) {	400	{
360	if (IS_MULTI2(screen.rend[row][col - 1]))	401	if (col > 0)
361	m = 1;	402	{
362	} else if (screen.cur.row > 0) {	403	if (IS_MULTI2(screen.rend[row][col - 1]))
363	col = screen.tlen[--row];	404	m = 1;
364	if (col == -1)	405	}
365	col = TermWin.ncol - 1;	406	else if (screen.cur.row > 0)
366	else	407	{
367	col--;	408	col = screen.tlen[--row];
368	if (col > 0	409	if (col == -1)
369	&& IS_MULTI2(screen.rend[row][col]))	410	col = TermWin.ncol - 1;
370	m = 1;	411	else
371	}	412	col--;
372	}	413	if (col > 0
373	if (m)	414	&& IS_MULTI2(screen.rend[row][col]))
374	MEMMOVE(kbuf + 3, kbuf, 3 + 1);	415	m = 1;
375	}	416	}
		417	}
		418	if (m)
		419	MEMMOVE(kbuf + 3, kbuf, 3 + 1);
		420	}
376	#endif	421	#endif
377	break;	422	break;
378		423
379	#ifndef UNSHIFTED_SCROLLKEYS	424	#ifndef UNSHIFTED_SCROLLKEYS
380	# ifdef XK_KP_Prior	425	# ifdef XK_KP_Prior
381	case XK_KP_Prior:	426	case XK_KP_Prior:
382	/* allow shift to override */	427	/* allow shift to override */
383	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {	428	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
384	STRCPY(kbuf, "\033Oy");	429	{
385	break;	430	STRCPY(kbuf, "\033Oy");
386	}	431	break;
387	/* FALLTHROUGH */	432	}
		433	/* FALLTHROUGH */
388	# endif	434	# endif
389	case XK_Prior:	435	case XK_Prior:
390	STRCPY(kbuf, "\033[5~");	436	STRCPY(kbuf, "\033[5~");
391	break;	437	break;
392	# ifdef XK_KP_Next	438	# ifdef XK_KP_Next
393	case XK_KP_Next:	439	case XK_KP_Next:
394	/* allow shift to override */	440	/* allow shift to override */
395	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {	441	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
396	STRCPY(kbuf, "\033Os");	442	{
397	break;	443	STRCPY(kbuf, "\033Os");
398	}	444	break;
399	/* FALLTHROUGH */	445	}
		446	/* FALLTHROUGH */
400	# endif	447	# endif
401	case XK_Next:	448	case XK_Next:
402	STRCPY(kbuf, "\033[6~");	449	STRCPY(kbuf, "\033[6~");
403	break;	450	break;
404	#endif	451	#endif
405	case XK_KP_Enter:	452	case XK_KP_Enter:
406	/* allow shift to override */	453	/* allow shift to override */
407	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {	454	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
408	STRCPY(kbuf, "\033OM");	455	{
409	} else {	456	STRCPY(kbuf, "\033OM");
410	kbuf[0] = '\r';	457	}
411	kbuf[1] = '\0';	458	else
412	}	459	{
413	break;	460	kbuf[0] = '\r';
		461	kbuf[1] = '\0';
		462	}
		463	break;
414		464
415	#ifdef XK_KP_Begin	465	#ifdef XK_KP_Begin
416	case XK_KP_Begin:	466	case XK_KP_Begin:
417	STRCPY(kbuf, "\033Ou");	467	STRCPY(kbuf, "\033Ou");
418	break;	468	break;
419		469
420	case XK_KP_Insert:	470	case XK_KP_Insert:
421	STRCPY(kbuf, "\033Op");	471	STRCPY(kbuf, "\033Op");
422	break;	472	break;
423		473
424	case XK_KP_Delete:	474	case XK_KP_Delete:
425	STRCPY(kbuf, "\033On");	475	STRCPY(kbuf, "\033On");
426	break;	476	break;
427	#endif	477	#endif
428	case XK_KP_F1: /* "\033OP" */	478	case XK_KP_F1: /* "\033OP" */
429	case XK_KP_F2: /* "\033OQ" */	479	case XK_KP_F2: /* "\033OQ" */
430	case XK_KP_F3: /* "\033OR" */	480	case XK_KP_F3: /* "\033OR" */
431	case XK_KP_F4: /* "\033OS" */	481	case XK_KP_F4: /* "\033OS" */
432	STRCPY(kbuf, "\033OP");	482	STRCPY(kbuf, "\033OP");
433	kbuf[2] += (keysym - XK_KP_F1);	483	kbuf[2] += (keysym - XK_KP_F1);
434	break;	484	break;
435		485
436	case XK_KP_Multiply: /* "\033Oj" : "*" */	486	case XK_KP_Multiply: /* "\033Oj" : "*" */
437	case XK_KP_Add: /* "\033Ok" : "+" */	487	case XK_KP_Add: /* "\033Ok" : "+" */
438	case XK_KP_Separator: /* "\033Ol" : "," */	488	case XK_KP_Separator: /* "\033Ol" : "," */
439	case XK_KP_Subtract: /* "\033Om" : "-" */	489	case XK_KP_Subtract: /* "\033Om" : "-" */
440	case XK_KP_Decimal: /* "\033On" : "." */	490	case XK_KP_Decimal: /* "\033On" : "." */
441	case XK_KP_Divide: /* "\033Oo" : "/" */	491	case XK_KP_Divide: /* "\033Oo" : "/" */
442	case XK_KP_0: /* "\033Op" : "0" */	492	case XK_KP_0: /* "\033Op" : "0" */
443	case XK_KP_1: /* "\033Oq" : "1" */	493	case XK_KP_1: /* "\033Oq" : "1" */
444	case XK_KP_2: /* "\033Or" : "2" */	494	case XK_KP_2: /* "\033Or" : "2" */
445	case XK_KP_3: /* "\033Os" : "3" */	495	case XK_KP_3: /* "\033Os" : "3" */
446	case XK_KP_4: /* "\033Ot" : "4" */	496	case XK_KP_4: /* "\033Ot" : "4" */
447	case XK_KP_5: /* "\033Ou" : "5" */	497	case XK_KP_5: /* "\033Ou" : "5" */
448	case XK_KP_6: /* "\033Ov" : "6" */	498	case XK_KP_6: /* "\033Ov" : "6" */
449	case XK_KP_7: /* "\033Ow" : "7" */	499	case XK_KP_7: /* "\033Ow" : "7" */
450	case XK_KP_8: /* "\033Ox" : "8" */	500	case XK_KP_8: /* "\033Ox" : "8" */
451	case XK_KP_9: /* "\033Oy" : "9" */	501	case XK_KP_9: /* "\033Oy" : "9" */
452	/* allow shift to override */	502	/* allow shift to override */
453	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {	503	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
454	STRCPY(kbuf, "\033Oj");	504	{
455	kbuf[2] += (keysym - XK_KP_Multiply);	505	STRCPY(kbuf, "\033Oj");
456	} else {	506	kbuf[2] += (keysym - XK_KP_Multiply);
		507	}
		508	else
		509	{
457	kbuf[0] = ('*' + (keysym - XK_KP_Multiply));	510	kbuf[0] = ('*' + (keysym - XK_KP_Multiply));
458	kbuf[1] = '\0';	511	kbuf[1] = '\0';
459	}	512	}
460	break;	513	break;
461		514
462	case XK_Find:	515	case XK_Find:
463	STRCPY(kbuf, "\033[1~");	516	STRCPY(kbuf, "\033[1~");
464	break;	517	break;
465	case XK_Insert:	518	case XK_Insert:
466	STRCPY(kbuf, "\033[2~");	519	STRCPY(kbuf, "\033[2~");
467	break;	520	break;
468	#ifdef DXK_Remove /* support for DEC remove like key */	521	#ifdef DXK_Remove /* support for DEC remove like key */
469	case DXK_Remove:	522	case DXK_Remove:
470	/* FALLTHROUGH */	523	/* FALLTHROUGH */
471	#endif	524	#endif
472	case XK_Execute:	525	case XK_Execute:
473	STRCPY(kbuf, "\033[3~");	526	STRCPY(kbuf, "\033[3~");
474	break;	527	break;
475	case XK_Select:	528	case XK_Select:
476	STRCPY(kbuf, "\033[4~");	529	STRCPY(kbuf, "\033[4~");
477	break;	530	break;
478	#ifdef XK_KP_End	531	#ifdef XK_KP_End
479	case XK_KP_End:	532	case XK_KP_End:
480	/* allow shift to override */	533	/* allow shift to override */
481	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {	534	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
482	STRCPY(kbuf, "\033Oq");	535	{
483	break;	536	STRCPY(kbuf, "\033Oq");
484	}	537	break;
485	/* FALLTHROUGH */	538	}
		539	/* FALLTHROUGH */
486	#endif	540	#endif
487	case XK_End:	541	case XK_End:
488	STRCPY(kbuf, KS_END);	542	STRCPY(kbuf, KS_END);
489	break;	543	break;
490	#ifdef XK_KP_Home	544	#ifdef XK_KP_Home
491	case XK_KP_Home:	545	case XK_KP_Home:
492	/* allow shift to override */	546	/* allow shift to override */
493	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft) {	547	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
494	STRCPY(kbuf, "\033Ow");	548	{
495	break;	549	STRCPY(kbuf, "\033Ow");
496	}	550	break;
497	/* FALLTHROUGH */	551	}
		552	/* FALLTHROUGH */
498	#endif	553	#endif
499	case XK_Home:	554	case XK_Home:
500	STRCPY(kbuf, KS_HOME);	555	STRCPY(kbuf, KS_HOME);
501	break;	556	break;
502		557
503	#define FKEY(n, fkey) \	558	#define FKEY(n, fkey) \
504	sprintf((char *)kbuf,"\033[%2d~", (int)((n) + (keysym - fkey)))	559	sprintf((char *)kbuf,"\033[%2d~", (int)((n) + (keysym - fkey)))
505		560
506	case XK_F1: /* "\033[11~" */	561	case XK_F1: /* "\033[11~" */
507	case XK_F2: /* "\033[12~" */	562	case XK_F2: /* "\033[12~" */
508	case XK_F3: /* "\033[13~" */	563	case XK_F3: /* "\033[13~" */
509	case XK_F4: /* "\033[14~" */	564	case XK_F4: /* "\033[14~" */
510	case XK_F5: /* "\033[15~" */	565	case XK_F5: /* "\033[15~" */
511	FKEY(11, XK_F1);	566	FKEY(11, XK_F1);
512	break;	567	break;
513	case XK_F6: /* "\033[17~" */	568	case XK_F6: /* "\033[17~" */
514	case XK_F7: /* "\033[18~" */	569	case XK_F7: /* "\033[18~" */
515	case XK_F8: /* "\033[19~" */	570	case XK_F8: /* "\033[19~" */
516	case XK_F9: /* "\033[20~" */	571	case XK_F9: /* "\033[20~" */
517	case XK_F10: /* "\033[21~" */	572	case XK_F10: /* "\033[21~" */
518	FKEY(17, XK_F6);	573	FKEY(17, XK_F6);
519	break;	574	break;
520	case XK_F11: /* "\033[23~" */	575	case XK_F11: /* "\033[23~" */
521	case XK_F12: /* "\033[24~" */	576	case XK_F12: /* "\033[24~" */
522	case XK_F13: /* "\033[25~" */	577	case XK_F13: /* "\033[25~" */
523	case XK_F14: /* "\033[26~" */	578	case XK_F14: /* "\033[26~" */
524	FKEY(23, XK_F11);	579	FKEY(23, XK_F11);
525	break;	580	break;
526	case XK_F15: /* "\033[28~" */	581	case XK_F15: /* "\033[28~" */
527	case XK_F16: /* "\033[29~" */	582	case XK_F16: /* "\033[29~" */
528	FKEY(28, XK_F15);	583	FKEY(28, XK_F15);
529	break;	584	break;
530	case XK_Help: /* "\033[28~" */	585	case XK_Help: /* "\033[28~" */
531	FKEY(28, XK_Help);	586	FKEY(28, XK_Help);
532	break;	587	break;
533	case XK_Menu: /* "\033[29~" */	588	case XK_Menu: /* "\033[29~" */
534	FKEY(29, XK_Menu);	589	FKEY(29, XK_Menu);
535	break;	590	break;
536	case XK_F17: /* "\033[31~" */	591	case XK_F17: /* "\033[31~" */
537	case XK_F18: /* "\033[32~" */	592	case XK_F18: /* "\033[32~" */
538	case XK_F19: /* "\033[33~" */	593	case XK_F19: /* "\033[33~" */
539	case XK_F20: /* "\033[34~" */	594	case XK_F20: /* "\033[34~" */
540	case XK_F21: /* "\033[35~" */	595	case XK_F21: /* "\033[35~" */
541	case XK_F22: /* "\033[36~" */	596	case XK_F22: /* "\033[36~" */
542	case XK_F23: /* "\033[37~" */	597	case XK_F23: /* "\033[37~" */
543	case XK_F24: /* "\033[38~" */	598	case XK_F24: /* "\033[38~" */
544	case XK_F25: /* "\033[39~" */	599	case XK_F25: /* "\033[39~" */
545	case XK_F26: /* "\033[40~" */	600	case XK_F26: /* "\033[40~" */
546	case XK_F27: /* "\033[41~" */	601	case XK_F27: /* "\033[41~" */
547	case XK_F28: /* "\033[42~" */	602	case XK_F28: /* "\033[42~" */
548	case XK_F29: /* "\033[43~" */	603	case XK_F29: /* "\033[43~" */
549	case XK_F30: /* "\033[44~" */	604	case XK_F30: /* "\033[44~" */
550	case XK_F31: /* "\033[45~" */	605	case XK_F31: /* "\033[45~" */
551	case XK_F32: /* "\033[46~" */	606	case XK_F32: /* "\033[46~" */
552	case XK_F33: /* "\033[47~" */	607	case XK_F33: /* "\033[47~" */
553	case XK_F34: /* "\033[48~" */	608	case XK_F34: /* "\033[48~" */
554	case XK_F35: /* "\033[49~" */	609	case XK_F35: /* "\033[49~" */
555	FKEY(31, XK_F17);	610	FKEY(31, XK_F17);
556	break;	611	break;
557	#undef FKEY	612	#undef FKEY
558	default:	613	default:
559	newlen = 0;	614	newlen = 0;
560	break;	615	break;
561	}	616	}
562	if (newlen)	617	if (newlen)
563	len = STRLEN(kbuf);	618	len = STRLEN(kbuf);
564	}	619	}
565	/*	620	/*
566	* Pass meta for all function keys, if 'meta' option set	621	* Pass meta for all function keys, if 'meta' option set
567	*/	622	*/
568	#ifdef META8_OPTION	623	#ifdef META8_OPTION
569	if (meta && (meta_char == 0x80) && len > 0)	624	if (meta && (meta_char == 0x80) && len > 0)
570	kbuf[len - 1] |= 0x80;	625	kbuf[len - 1] |= 0x80;
571	#endif	626	#endif
		627
		628	}
572	} else if (ctrl && keysym == XK_minus) {	629	else if (ctrl && keysym == XK_minus)
		630	{
573	len = 1;	631	len = 1;
574	kbuf[0] = '\037'; /* Ctrl-Minus generates ^_ (31) */	632	kbuf[0] = '\037'; /* Ctrl-Minus generates ^_ (31) */
575	} else {	633	}
		634	else
		635	{
576	#ifdef META8_OPTION	636	#ifdef META8_OPTION
577	/* set 8-bit on */	637	/* set 8-bit on */
578	if (meta && (meta_char == 0x80)) {	638	if (meta && (meta_char == 0x80))
579	unsigned char *ch;	639	{
		640	unsigned char *ch;
580		641
581	for (ch = kbuf; ch < kbuf + len; ch++)	642	for (ch = kbuf; ch < kbuf + len; ch++)
582	*ch |= 0x80;	643	*ch |= 0x80;
583	meta = 0;	644	meta = 0;
584	}	645	}
585	#endif	646	#endif
586	#ifdef GREEK_SUPPORT	647	#ifdef GREEK_SUPPORT
587	if (greek_mode)	648	if (greek_mode)
588	len = greek_xlat(kbuf, len);	649	len = greek_xlat(kbuf, len);
589	#endif	650	#endif
590	/* nil */ ;	651	/* nil */ ;
591	}	652	}
		653	}
		654
		655	if (len <= 0)
		656	return; /* not mapped */
		657
		658	if (Options & Opt_scrollTtyKeypress)
		659	if (TermWin.view_start)
		660	{
		661	TermWin.view_start = 0;
		662	want_refresh = 1;
592	}	663	}
593		664
594	if (len <= 0)	665	/*
595	return; /* not mapped */
596
597	if (Options & Opt_scrollTtyKeypress)
598	if (TermWin.view_start) {
599	TermWin.view_start = 0;
600	want_refresh = 1;
601	}
602
603	/*
604	* these modifications only affect the static keybuffer	666	* these modifications only affect the static keybuffer
605	* pass Shift/Control indicators for function keys ending with `~'	667	* pass Shift/Control indicators for function keys ending with `~'
606	*	668	*
607	* eg,	669	* eg,
608	* Prior = "ESC[5~"	670	* Prior = "ESC[5~"
609	* Shift+Prior = "ESC[5$"	671	* Shift+Prior = "ESC[5$"
610	* Ctrl+Prior = "ESC[5^"	672	* Ctrl+Prior = "ESC[5^"
611	* Ctrl+Shift+Prior = "ESC[5@"	673	* Ctrl+Shift+Prior = "ESC[5@"
612	* Meta adds an Escape prefix (with META8_OPTION, if meta == <escape>).	674	* Meta adds an Escape prefix (with META8_OPTION, if meta == <escape>).
613	*/	675	*/
614	if (kbuf[0] == C0_ESC && kbuf[1] == '[' && kbuf[len - 1] == '~')	676	if (kbuf[0] == C0_ESC && kbuf[1] == '[' && kbuf[len - 1] == '~')
615	kbuf[len - 1] = (shft ? (ctrl ? '@' : '$') : (ctrl ? '^' : '~'));	677	kbuf[len - 1] = (shft ? (ctrl ? '@' : '$') : (ctrl ? '^' : '~'));
616		678
617	/* escape prefix */	679	/* escape prefix */
618	if (meta	680	if (meta
619	#ifdef META8_OPTION	681	#ifdef META8_OPTION
620	&& (meta_char == C0_ESC)	682	&& (meta_char == C0_ESC)
621	#endif	683	#endif
622	) {	684	)
		685	{
623	const unsigned char ch = C0_ESC;	686	const unsigned char ch = C0_ESC;
624		687
625	tt_write(&ch, 1);	688	tt_write(&ch, 1);
626	}	689	}
627	#ifdef DEBUG_CMD	690	#ifdef DEBUG_CMD
		691	if (debug_key)
628	if (debug_key) { /* Display keyboard buffer contents */	692	{ /* Display keyboard buffer contents */
629	char *p;	693	char *p;
630	int i;	694	int i;
631		695
632	fprintf(stderr, "key 0x%04X [%d]: `", (unsigned int)keysym, len);	696	fprintf(stderr, "key 0x%04X [%d]: `", (unsigned int)keysym, len);
633	for (i = 0, p = kbuf; i < len; i++, p++)	697	for (i = 0, p = kbuf; i < len; i++, p++)
634	fprintf(stderr, (*p >= ' ' && *p < '\177' ? "%c" : "\\%03o"), *p);	698	fprintf(stderr, (*p >= ' ' && *p < '\177' ? "%c" : "\\%03o"), *p);
635	fprintf(stderr, "'\n");	699	fprintf(stderr, "'\n");
636	}	700	}
637	#endif /* DEBUG_CMD */	701	#endif /* DEBUG_CMD */
638	tt_write (kbuf, (unsigned int)len);	702	tt_write (kbuf, (unsigned int)len);
639	}	703	}
640	/*}}} */	704	/*}}} */
641		705
642	#if (MENUBAR_MAX)	706	#if (MENUBAR_MAX)
643	/*{{{ rxvt_cmd_write(), rxvt_cmd_getc() */	707	/*{{{ rxvt_cmd_write(), rxvt_cmd_getc() */
644	/* attempt to `write' count to the input buffer */	708	/* attempt to `write' count to the input buffer */
645	unsigned int	709	unsigned int
646	rxvt_term::cmd_write (const unsigned char *str, unsigned int count)	710	rxvt_term::cmd_write (const unsigned char *str, unsigned int count)
647	{	711	{
648	unsigned int n, s;	712	unsigned int n, s;
649		713
650	n = cmdbuf_ptr - cmdbuf_base;	714	n = cmdbuf_ptr - cmdbuf_base;
651	s = cmdbuf_base + BUFSIZ - 1 - cmdbuf_endp;	715	s = cmdbuf_base + BUFSIZ - 1 - cmdbuf_endp;
652	if (n > 0 && s < count) {	716	if (n > 0 && s < count)
		717	{
653	MEMMOVE(cmdbuf_base, cmdbuf_ptr,	718	MEMMOVE(cmdbuf_base, cmdbuf_ptr,
654	(unsigned int)(cmdbuf_endp - cmdbuf_ptr));	719	(unsigned int)(cmdbuf_endp - cmdbuf_ptr));
655	cmdbuf_ptr = cmdbuf_base;	720	cmdbuf_ptr = cmdbuf_base;
656	cmdbuf_endp -= n;	721	cmdbuf_endp -= n;
657	s += n;	722	s += n;
658	}	723	}
659	if (count > s) {	724	if (count > s)
		725	{
660	rxvt_print_error("data loss: cmd_write too large");	726	rxvt_print_error("data loss: cmd_write too large");
661	count = s;	727	count = s;
662	}	728	}
663	for (; count--;)	729	for (; count--;)
664	*cmdbuf_endp++ = *str++;	730	*cmdbuf_endp++ = *str++;
665	return 0;	731	return 0;
666	}	732	}
667	#endif /* MENUBAR_MAX */	733	#endif /* MENUBAR_MAX */
668		734
669	void	735	void
670	rxvt_term::flush ()	736	rxvt_term::flush ()
…		…
684	scr_refresh (refresh_type);	750	scr_refresh (refresh_type);
685	scrollbar_show (1);	751	scrollbar_show (1);
686	#ifdef USE_XIM	752	#ifdef USE_XIM
687	IMSendSpot ();	753	IMSendSpot ();
688	#endif	754	#endif
		755
689	}	756	}
690		757
691	XFlush (Xdisplay);	758	XFlush (Xdisplay);
692	}	759	}
693		760
…		…
783	ssize_t n = cmdbuf_endp - cmdbuf_ptr;	850	ssize_t n = cmdbuf_endp - cmdbuf_ptr;
784		851
785	memmove (cmdbuf_base, cmdbuf_ptr, n);	852	memmove (cmdbuf_base, cmdbuf_ptr, n);
786	cmdbuf_ptr = cmdbuf_base;	853	cmdbuf_ptr = cmdbuf_base;
787	cmdbuf_endp = cmdbuf_ptr + n;	854	cmdbuf_endp = cmdbuf_ptr + n;
788		855
789	n = read (cmd_fd, cmdbuf_endp, BUFSIZ - n);	856	n = read (cmd_fd, cmdbuf_endp, BUFSIZ - n);
790		857
791	if (n > 0)	858	if (n > 0)
792	{	859	{
793	cmdbuf_endp += n;	860	cmdbuf_endp += n;
…		…
903	process_nonprinting (ch);	970	process_nonprinting (ch);
904	break;	971	break;
905	case C0_ESC: /* escape char */	972	case C0_ESC: /* escape char */
906	process_escape_seq ();	973	process_escape_seq ();
907	break;	974	break;
908	/*case 0x9b: */ /* CSI */	975	/*case 0x9b: */ /* CSI */
909	/* process_csi_seq (); */	976	/* process_csi_seq (); */
910	}	977	}
911		978
912	ch = NOCHAR;	979	ch = NOCHAR;
913	}	980	}
914	}	981	}
…		…
961	// would be preferred. either setjmp/longjmp or better design.	1028	// would be preferred. either setjmp/longjmp or better design.
962	fcntl (cmd_fd, F_SETFL, 0);	1029	fcntl (cmd_fd, F_SETFL, 0);
963	pty_fill ();	1030	pty_fill ();
964	fcntl (cmd_fd, F_SETFL, O_NONBLOCK);	1031	fcntl (cmd_fd, F_SETFL, O_NONBLOCK);
965	}	1032	}
966
967	#if 0
968	#define TIMEOUT_USEC 5000
969	fd_set readfds;
970	int quick_timeout, select_res;
971	int want_motion_time, want_keypress_time;
972	struct timeval value;
973	#if defined(POINTER_BLANK) || defined(CURSOR_BLINK)
974	struct timeval tp;
975	#endif
976
977	for (;;) {
978	/* loop until we can return something */
979
980	if (v_bufstr < v_bufptr) /* output any pending chars */
981	tt_write(NULL, 0);
982
983	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
984	if (mouse_slip_wheel_speed) {
985	quick_timeout = 1;
986	if (!mouse_slip_wheel_delay--
987	&& scr_page (mouse_slip_wheel_speed > 0 ? UP : DN,
988	abs(mouse_slip_wheel_speed))) {
989	mouse_slip_wheel_delay = SCROLLBAR_CONTINUOUS_DELAY;
990	refresh_type |= SMOOTH_REFRESH;
991	want_refresh = 1;
992	}
993	}
994	#endif /* MOUSE_WHEEL && MOUSE_SLIP_WHEELING */
995	#ifdef SELECTION_SCROLLING
996	if (pending_scroll_selection) {
997	quick_timeout = 1;
998	if (!scroll_selection_delay--
999	&& scr_page (scroll_selection_dir,
1000	scroll_selection_lines)) {
1001	selection_extend (selection_save_x,
1002	selection_save_y, selection_save_state);
1003	scroll_selection_delay = SCROLLBAR_CONTINUOUS_DELAY;
1004	refresh_type |= SMOOTH_REFRESH;
1005	want_refresh = 1;
1006	}
1007	}
1008	#endif
1009	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1010	if (scrollbar_isUp() || scrollbar_isDn()) {
1011	quick_timeout = 1;
1012	if (!scroll_arrow_delay--
1013	&& scr_page (scrollbar_isUp() ? UP : DN, 1)) {
1014	scroll_arrow_delay = SCROLLBAR_CONTINUOUS_DELAY;
1015	refresh_type |= SMOOTH_REFRESH;
1016	want_refresh = 1;
1017	}
1018	}
1019	#endif /* NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING */
1020
1021	#ifdef TRANSPARENT
1022	quick_timeout |= want_full_refresh;
1023	#endif
1024	#endif
1025	}	1033	}
1026		1034
1027	#ifdef POINTER_BLANK	1035	#ifdef POINTER_BLANK
1028	void	1036	void
1029	rxvt_term::pointer_unblank ()	1037	rxvt_term::pointer_unblank ()
…		…
1060	#endif	1068	#endif
1061		1069
1062	void	1070	void
1063	rxvt_term::mouse_report (const XButtonEvent *ev)	1071	rxvt_term::mouse_report (const XButtonEvent *ev)
1064	{	1072	{
1065	int button_number, key_state = 0;	1073	int button_number, key_state = 0;
1066	int x, y;	1074	int x, y;
1067		1075
1068	x = ev->x;	1076	x = ev->x;
1069	y = ev->y;	1077	y = ev->y;
1070	pixel_position (&x, &y);	1078	pixel_position (&x, &y);
1071		1079
1072	if (MEvent.button == AnyButton) {	1080	if (MEvent.button == AnyButton)
		1081	{
1073	button_number = 3;	1082	button_number = 3;
1074	} else {	1083	}
		1084	else
		1085	{
1075	button_number = MEvent.button - Button1;	1086	button_number = MEvent.button - Button1;
1076	/* add 0x3D for wheel events, like xterm does */	1087	/* add 0x3D for wheel events, like xterm does */
1077	if (button_number >= 3)	1088	if (button_number >= 3)
1078	button_number += (64 - 3);	1089	button_number += (64 - 3);
1079	}	1090	}
1080		1091
1081	if (PrivateModes & PrivMode_MouseX10) {	1092	if (PrivateModes & PrivMode_MouseX10)
		1093	{
1082	/*	1094	/*
1083	* do not report ButtonRelease	1095	* do not report ButtonRelease
1084	* no state info allowed	1096	* no state info allowed
1085	*/	1097	*/
1086	key_state = 0;	1098	key_state = 0;
1087	if (button_number == 3)	1099	if (button_number == 3)
1088	return;	1100	return;
1089	} else {	1101	}
		1102	else
		1103	{
1090	/* XTerm mouse reporting needs these values:	1104	/* XTerm mouse reporting needs these values:
1091	* 4 = Shift	1105	* 4 = Shift
1092	* 8 = Meta	1106	* 8 = Meta
1093	* 16 = Control	1107	* 16 = Control
1094	* plus will add in our own Double-Click reporting	1108	* plus will add in our own Double-Click reporting
1095	* 32 = Double Click	1109	* 32 = Double Click
1096	*/	1110	*/
1097	key_state = ((MEvent.state & ShiftMask) ? 4 : 0)	1111	key_state = ((MEvent.state & ShiftMask) ? 4 : 0)
1098	+ ((MEvent.state & ModMetaMask) ? 8 : 0)	1112	+ ((MEvent.state & ModMetaMask) ? 8 : 0)
1099	+ ((MEvent.state & ControlMask) ? 16 : 0);	1113	+ ((MEvent.state & ControlMask) ? 16 : 0);
1100	#ifdef MOUSE_REPORT_DOUBLECLICK	1114	#ifdef MOUSE_REPORT_DOUBLECLICK
1101	key_state += ((MEvent.clicks > 1) ? 32 : 0);	1115	key_state += ((MEvent.clicks > 1) ? 32 : 0);
1102	#endif	1116	#endif
		1117
1103	}	1118	}
1104		1119
1105	#ifdef DEBUG_MOUSEREPORT	1120	#ifdef DEBUG_MOUSEREPORT
1106	fprintf(stderr, "Mouse [");	1121	fprintf(stderr, "Mouse [");
1107	if (key_state & 16)	1122	if (key_state & 16)
1108	fputc('C', stderr);	1123	fputc('C', stderr);
1109	if (key_state & 4)	1124	if (key_state & 4)
1110	fputc('S', stderr);	1125	fputc('S', stderr);
1111	if (key_state & 8)	1126	if (key_state & 8)
1112	fputc('A', stderr);	1127	fputc('A', stderr);
1113	if (key_state & 32)	1128	if (key_state & 32)
1114	fputc('2', stderr);	1129	fputc('2', stderr);
1115	fprintf(stderr, "]: <%d>, %d/%d\n",	1130	fprintf(stderr, "]: <%d>, %d/%d\n",
1116	button_number,	1131	button_number,
1117	x + 1,	1132	x + 1,
1118	y + 1);	1133	y + 1);
1119	#else	1134	#else
1120	tt_printf("\033[M%c%c%c",	1135	tt_printf("\033[M%c%c%c",
1121	(32 + button_number + key_state),	1136	(32 + button_number + key_state),
1122	(32 + x + 1),	1137	(32 + x + 1),
1123	(32 + y + 1));	1138	(32 + y + 1));
1124	#endif	1139	#endif
1125	}	1140	}
1126		1141
1127	#ifdef USING_W11LIB	1142	#ifdef USING_W11LIB
1128	void	1143	void
1129	rxvt_W11_process_x_event(XEvent *ev)	1144	rxvt_W11_process_x_event(XEvent *ev)
1130	{	1145	{
1131	rxvt_t *r = rxvt_get_r();	1146	rxvt_t *r = rxvt_get_r();
1132		1147
1133	process_x_event (ev);	1148	process_x_event (ev);
1134	}	1149	}
1135	#endif	1150	#endif
1136		1151
1137	/*{{{ process an X event */	1152	/*{{{ process an X event */
1138	void	1153	void
1139	rxvt_term::process_x_event (XEvent *ev)	1154	rxvt_term::process_x_event (XEvent *ev)
1140	{	1155	{
1141	Window unused_root, unused_child;	1156	Window unused_root, unused_child;
1142	int unused_root_x, unused_root_y;	1157	int unused_root_x, unused_root_y;
1143	unsigned int unused_mask;	1158	unsigned int unused_mask;
1144		1159
1145	#ifdef DEBUG_X	1160	#ifdef DEBUG_X
1146	const char *const eventnames[] =	1161	const char *const eventnames[] =
1147	{ /* mason - this matches my system */	1162	{ /* mason - this matches my system */
1148	"",	1163	"",
1149	"",	1164	"",
1150	"KeyPress",	1165	"KeyPress",
1151	"KeyRelease",	1166	"KeyRelease",
1152	"ButtonPress",	1167	"ButtonPress",
1153	"ButtonRelease",	1168	"ButtonRelease",
1154	"MotionNotify",	1169	"MotionNotify",
1155	"EnterNotify",	1170	"EnterNotify",
1156	"LeaveNotify",	1171	"LeaveNotify",
1157	"FocusIn",	1172	"FocusIn",
1158	"FocusOut",	1173	"FocusOut",
1159	"KeymapNotify",	1174	"KeymapNotify",
1160	"Expose",	1175	"Expose",
1161	"GraphicsExpose",	1176	"GraphicsExpose",
1162	"NoExpose",	1177	"NoExpose",
1163	"VisibilityNotify",	1178	"VisibilityNotify",
1164	"CreateNotify",	1179	"CreateNotify",
1165	"DestroyNotify",	1180	"DestroyNotify",
1166	"UnmapNotify",	1181	"UnmapNotify",
1167	"MapNotify",	1182	"MapNotify",
1168	"MapRequest",	1183	"MapRequest",
1169	"ReparentNotify",	1184	"ReparentNotify",
1170	"ConfigureNotify",	1185	"ConfigureNotify",
1171	"ConfigureRequest",	1186	"ConfigureRequest",
1172	"GravityNotify",	1187	"GravityNotify",
1173	"ResizeRequest",	1188	"ResizeRequest",
1174	"CirculateNotify",	1189	"CirculateNotify",
1175	"CirculateRequest",	1190	"CirculateRequest",
1176	"PropertyNotify",	1191	"PropertyNotify",
1177	"SelectionClear",	1192	"SelectionClear",
1178	"SelectionRequest",	1193	"SelectionRequest",
1179	"SelectionNotify",	1194	"SelectionNotify",
1180	"ColormapNotify",	1195	"ColormapNotify",
1181	"ClientMessage",	1196	"ClientMessage",
1182	"MappingNotify"	1197	"MappingNotify"
1183	};	1198	};
1184	#endif	1199	#endif
1185		1200
1186	#ifdef DEBUG_X	1201	#ifdef DEBUG_X
1187	struct timeval tp;	1202	struct timeval tp;
1188	struct tm *ltt;	1203	struct tm *ltt;
1189	(void)gettimeofday(&tp, NULL);	1204	(void)gettimeofday(&tp, NULL);
1190	ltt = localtime(&(tp.tv_sec));	1205	ltt = localtime(&(tp.tv_sec));
1191	D_X((stderr, "Event: %-16s %-7s %08lx (%4d-%02d-%02d %02d:%02d:%02d.%.6ld) %s %lu", eventnames[ev->type], (ev->xany.window == TermWin.parent[0] ? "parent" : (ev->xany.window == TermWin.vt ? "vt" : (ev->xany.window == scrollBar.win ? "scroll" : (ev->xany.window == menuBar.win ? "menubar" : "UNKNOWN")))), (ev->xany.window == TermWin.parent[0] ? TermWin.parent[0] : (ev->xany.window == TermWin.vt ? TermWin.vt : (ev->xany.window == scrollBar.win ? scrollBar.win : (ev->xany.window == menuBar.win ? menuBar.win : 0)))), ltt->tm_year + 1900, ltt->tm_mon + 1, ltt->tm_mday, ltt->tm_hour, ltt->tm_min, ltt->tm_sec, tp.tv_usec, ev->xany.send_event ? "S" : " ", ev->xany.serial));	1206	D_X((stderr, "Event: %-16s %-7s %08lx (%4d-%02d-%02d %02d:%02d:%02d.%.6ld) %s %lu", eventnames[ev->type], (ev->xany.window == TermWin.parent[0] ? "parent" : (ev->xany.window == TermWin.vt ? "vt" : (ev->xany.window == scrollBar.win ? "scroll" : (ev->xany.window == menuBar.win ? "menubar" : "UNKNOWN")))), (ev->xany.window == TermWin.parent[0] ? TermWin.parent[0] : (ev->xany.window == TermWin.vt ? TermWin.vt : (ev->xany.window == scrollBar.win ? scrollBar.win : (ev->xany.window == menuBar.win ? menuBar.win : 0)))), ltt->tm_year + 1900, ltt->tm_mon + 1, ltt->tm_mday, ltt->tm_hour, ltt->tm_min, ltt->tm_sec, tp.tv_usec, ev->xany.send_event ? "S" : " ", ev->xany.serial));
1192	#endif	1207	#endif
1193		1208
1194	switch (ev->type) {	1209	switch (ev->type)
		1210	{
1195	case KeyPress:	1211	case KeyPress:
1196	lookup_key ((XKeyEvent *)ev);	1212	lookup_key ((XKeyEvent *)ev);
1197	break;	1213	break;
1198		1214
1199	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)	1215	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
1200	case KeyRelease:	1216	case KeyRelease:
1201	{	1217	{
1202	if (!(ev->xkey.state & ControlMask))	1218	if (!(ev->xkey.state & ControlMask))
1203	mouse_slip_wheel_speed = 0;	1219	mouse_slip_wheel_speed = 0;
1204	else {	1220	else
1205	KeySym ks;	1221	{
1206		1222	KeySym ks;
		1223
1207	ks = XKeycodeToKeysym(Xdisplay, ev->xkey.keycode, 0);	1224	ks = XKeycodeToKeysym(Xdisplay, ev->xkey.keycode, 0);
1208	if (ks == XK_Control_L || ks == XK_Control_R)	1225	if (ks == XK_Control_L || ks == XK_Control_R)
1209	mouse_slip_wheel_speed = 0;	1226	mouse_slip_wheel_speed = 0;
1210	}	1227	}
1211	break;	1228	break;
1212	}	1229	}
1213	#endif	1230	#endif
1214		1231
1215	case ButtonPress:	1232	case ButtonPress:
1216	button_press ((XButtonEvent *)ev);	1233	button_press ((XButtonEvent *)ev);
1217	break;	1234	break;
1218		1235
1219	case ButtonRelease:	1236	case ButtonRelease:
1220	button_release ((XButtonEvent *)ev);	1237	button_release ((XButtonEvent *)ev);
1221	break;	1238	break;
1222		1239
1223	case ClientMessage:	1240	case ClientMessage:
1224	if (ev->xclient.format == 32	1241	if (ev->xclient.format == 32
1225	&& (Atom)ev->xclient.data.l[0] == xa[XA_WMDELETEWINDOW])	1242	&& (Atom)ev->xclient.data.l[0] == xa[XA_WMDELETEWINDOW])
1226	destroy ();	1243	destroy ();
1227	#ifdef OFFIX_DND	1244	#ifdef OFFIX_DND
1228	/* OffiX Dnd (drag 'n' drop) protocol */	1245	/* OffiX Dnd (drag 'n' drop) protocol */
1229	else if (ev->xclient.message_type == xa[XA_DNDPROTOCOL]	1246	else if (ev->xclient.message_type == xa[XA_DNDPROTOCOL]
1230	&& (ev->xclient.data.l[0] == DndFile	1247	&& (ev->xclient.data.l[0] == DndFile
1231	|| ev->xclient.data.l[0] == DndDir	1248	|| ev->xclient.data.l[0] == DndDir
1232	|| ev->xclient.data.l[0] == DndLink)) {	1249	|| ev->xclient.data.l[0] == DndLink))
1233	/* Get Dnd data */	1250	{
		1251	/* Get Dnd data */
1234	Atom ActualType;	1252	Atom ActualType;
1235	int ActualFormat;	1253	int ActualFormat;
1236	unsigned char *data;	1254	unsigned char *data;
1237	unsigned long Size, RemainingBytes;	1255	unsigned long Size, RemainingBytes;
1238		1256
1239	XGetWindowProperty(Xdisplay, Xroot,	1257	XGetWindowProperty(Xdisplay, Xroot,
1240	xa[XA_DNDSELECTION],	1258	xa[XA_DNDSELECTION],
1241	0L, 1000000L,	1259	0L, 1000000L,
1242	False, AnyPropertyType,	1260	False, AnyPropertyType,
1243	&ActualType, &ActualFormat,	1261	&ActualType, &ActualFormat,
1244	&Size, &RemainingBytes,	1262	&Size, &RemainingBytes,
1245	&data);	1263	&data);
1246	XChangeProperty(Xdisplay, Xroot,	1264	XChangeProperty(Xdisplay, Xroot,
1247	XA_CUT_BUFFER0, XA_STRING,	1265	XA_CUT_BUFFER0, XA_STRING,
1248	8, PropModeReplace,	1266	8, PropModeReplace,
1249	data, STRLEN(data));	1267	data, STRLEN(data));
1250	selection_paste (Xroot, XA_CUT_BUFFER0, True);	1268	selection_paste (Xroot, XA_CUT_BUFFER0, True);
1251	XSetInputFocus(Xdisplay, Xroot, RevertToNone, CurrentTime);	1269	XSetInputFocus(Xdisplay, Xroot, RevertToNone, CurrentTime);
1252	}	1270	}
1253	#endif /* OFFIX_DND */	1271	#endif /* OFFIX_DND */
1254	break;	1272	break;
1255		1273
1256	case MappingNotify:	1274	case MappingNotify:
1257	XRefreshKeyboardMapping(&(ev->xmapping));	1275	XRefreshKeyboardMapping(&(ev->xmapping));
1258	break;	1276	break;
1259		1277
1260	/*	1278	/*
1261	* XXX: this is not the _current_ arrangement	1279	* XXX: this is not the _current_ arrangement
1262	* Here's my conclusion:	1280	* Here's my conclusion:
1263	* If the window is completely unobscured, use bitblt's	1281	* If the window is completely unobscured, use bitblt's
1264	* to scroll. Even then, they're only used when doing partial	1282	* to scroll. Even then, they're only used when doing partial
1265	* screen scrolling. When partially obscured, we have to fill	1283	* screen scrolling. When partially obscured, we have to fill
1266	* in the GraphicsExpose parts, which means that after each refresh,	1284	* in the GraphicsExpose parts, which means that after each refresh,
1267	* we need to wait for the graphics expose or Noexpose events,	1285	* we need to wait for the graphics expose or Noexpose events,
1268	* which ought to make things real slow!	1286	* which ought to make things real slow!
1269	*/	1287	*/
1270	case VisibilityNotify:	1288	case VisibilityNotify:
1271	switch (ev->xvisibility.state)	1289	switch (ev->xvisibility.state)
1272	{	1290	{
1273	case VisibilityUnobscured:	1291	case VisibilityUnobscured:
1274	refresh_type = FAST_REFRESH;	1292	refresh_type = FAST_REFRESH;
1275	break;	1293	break;
1276	case VisibilityPartiallyObscured:	1294	case VisibilityPartiallyObscured:
…		…
1278	break;	1296	break;
1279	default:	1297	default:
1280	refresh_type = NO_REFRESH;	1298	refresh_type = NO_REFRESH;
1281	break;	1299	break;
1282	}	1300	}
1283	break;	1301	break;
1284		1302
1285	case FocusIn:	1303	case FocusIn:
1286	if (!TermWin.focus) {	1304	if (!TermWin.focus)
		1305	{
1287	TermWin.focus = 1;	1306	TermWin.focus = 1;
1288	want_refresh = 1;	1307	want_refresh = 1;
1289	#ifdef USE_XIM	1308	#ifdef USE_XIM
1290	if (Input_Context != NULL)	1309	if (Input_Context != NULL)
1291	XSetICFocus(Input_Context);	1310	XSetICFocus(Input_Context);
1292	#endif	1311	#endif
1293	#ifdef CURSOR_BLINK	1312	#ifdef CURSOR_BLINK
1294	if (Options & Opt_cursorBlink)	1313	if (Options & Opt_cursorBlink)
1295	cursor_blink_ev.start (NOW + BLINK_INTERVAL);	1314	cursor_blink_ev.start (NOW + BLINK_INTERVAL);
1296	#endif	1315	#endif
1297	}
1298	break;
1299		1316
		1317	}
		1318	break;
		1319
1300	case FocusOut:	1320	case FocusOut:
1301	if (TermWin.focus) {	1321	if (TermWin.focus)
		1322	{
1302	TermWin.focus = 0;	1323	TermWin.focus = 0;
1303	want_refresh = 1;	1324	want_refresh = 1;
1304	#ifdef USE_XIM	1325	#ifdef USE_XIM
1305	if (Input_Context != NULL)	1326	if (Input_Context != NULL)
1306	XUnsetICFocus(Input_Context);	1327	XUnsetICFocus(Input_Context);
1307	#endif	1328	#endif
1308	#ifdef CURSOR_BLINK	1329	#ifdef CURSOR_BLINK
1309	if (Options & Opt_cursorBlink)	1330	if (Options & Opt_cursorBlink)
1310	cursor_blink_ev.stop ();	1331	cursor_blink_ev.stop ();
1311	hidden_cursor = 0;	1332	hidden_cursor = 0;
1312	#endif	1333	#endif
1313	}
1314	break;
1315		1334
		1335	}
		1336	break;
		1337
1316	case ConfigureNotify:	1338	case ConfigureNotify:
1317	if (ev->xconfigure.window == TermWin.parent[0]) {	1339	if (ev->xconfigure.window == TermWin.parent[0])
		1340	{
1318	int height, width;	1341	int height, width;
1319		1342
		1343	do
1320	do { /* Wrap lots of configures into one */	1344	{ /* Wrap lots of configures into one */
1321	width = ev->xconfigure.width;	1345	width = ev->xconfigure.width;
1322	height = ev->xconfigure.height;	1346	height = ev->xconfigure.height;
1323	D_SIZE((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));	1347	D_SIZE((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));
		1348	}
1324	} while (XCheckTypedWindowEvent(Xdisplay, ev->xconfigure.window,	1349	while (XCheckTypedWindowEvent(Xdisplay, ev->xconfigure.window,
1325	ConfigureNotify, ev));	1350	ConfigureNotify, ev));
1326	if (szHint.width != width || szHint.height != height) {	1351	if (szHint.width != width || szHint.height != height)
		1352	{
1327	D_SIZE((stderr, "Size: Resizing from: %4d x %4d", szHint.width, szHint.height));	1353	D_SIZE((stderr, "Size: Resizing from: %4d x %4d", szHint.width, szHint.height));
1328	resize_all_windows (width, height, 1);	1354	resize_all_windows (width, height, 1);
1329	}	1355	}
1330	#ifdef DEBUG_SIZE	1356	#ifdef DEBUG_SIZE
1331	else {	1357	else
		1358	{
1332	D_SIZE((stderr, "Size: Not resizing"));	1359	D_SIZE((stderr, "Size: Not resizing"));
1333	}	1360	}
1334	#endif	1361	#endif
1335	#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */	1362	#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */
1336	if (Options & Opt_transparent) {	1363	if (Options & Opt_transparent)
1337	check_our_parents ();	1364	{
1338	if (am_transparent)	1365	check_our_parents ();
		1366	if (am_transparent)
1339	want_full_refresh = 1;	1367	want_full_refresh = 1;
1340	}	1368	}
1341	#endif	1369	#endif
1342	}
1343	break;
1344		1370
		1371	}
		1372	break;
		1373
1345	case SelectionClear:	1374	case SelectionClear:
1346	selection_clear ();	1375	selection_clear ();
1347	break;	1376	break;
1348		1377
1349	case SelectionNotify:	1378	case SelectionNotify:
1350	if (selection_wait == Sel_normal)	1379	if (selection_wait == Sel_normal)
1351	selection_paste (ev->xselection.requestor,	1380	selection_paste (ev->xselection.requestor,
1352	ev->xselection.property, True);	1381	ev->xselection.property, True);
1353	break;	1382	break;
1354		1383
1355	case SelectionRequest:	1384	case SelectionRequest:
1356	selection_send (&(ev->xselectionrequest));	1385	selection_send (&(ev->xselectionrequest));
1357	break;	1386	break;
1358		1387
1359	case UnmapNotify:	1388	case UnmapNotify:
1360	TermWin.mapped = 0;	1389	TermWin.mapped = 0;
1361	#ifdef TEXT_BLINK	1390	#ifdef TEXT_BLINK
1362	text_blink_ev.stop ();	1391	text_blink_ev.stop ();
1363	#endif	1392	#endif
1364	break;	1393	break;
1365		1394
1366	case MapNotify:	1395	case MapNotify:
1367	TermWin.mapped = 1;	1396	TermWin.mapped = 1;
1368	#ifdef TEXT_BLINK	1397	#ifdef TEXT_BLINK
1369	text_blink_ev.start (NOW + TEXT_BLINK_INTERVAL);	1398	text_blink_ev.start (NOW + TEXT_BLINK_INTERVAL);
1370	#endif	1399	#endif
1371	break;	1400	break;
1372		1401
1373	case PropertyNotify:	1402	case PropertyNotify:
1374	if (ev->xproperty.atom == xa[XA_VT_SELECTION]) {	1403	if (ev->xproperty.atom == xa[XA_VT_SELECTION])
		1404	{
1375	if (ev->xproperty.state == PropertyNewValue)	1405	if (ev->xproperty.state == PropertyNewValue)
1376	selection_property (ev->xproperty.window,	1406	selection_property (ev->xproperty.window,
1377	ev->xproperty.atom);	1407	ev->xproperty.atom);
1378	break;	1408	break;
1379	}	1409	}
1380	#ifdef TRANSPARENT	1410	#ifdef TRANSPARENT
1381	/*	1411	/*
1382	* if user used some Esetroot compatible prog to set the root bg,	1412	* if user used some Esetroot compatible prog to set the root bg,
1383	* use the property to determine the pixmap. We use it later on.	1413	* use the property to determine the pixmap. We use it later on.
1384	*/	1414	*/
1385	if (xa[XA_XROOTPMAPID] == 0)	1415	if (xa[XA_XROOTPMAPID] == 0)
1386	xa[XA_XROOTPMAPID] = XInternAtom(Xdisplay,	1416	xa[XA_XROOTPMAPID] = XInternAtom(Xdisplay,
1387	"_XROOTPMAP_ID", False);	1417	"_XROOTPMAP_ID", False);
1388	if (ev->xproperty.atom != xa[XA_XROOTPMAPID])	1418	if (ev->xproperty.atom != xa[XA_XROOTPMAPID])
1389	break;	1419	break;
1390	/* FALLTHROUGH */	1420	/* FALLTHROUGH */
1391	case ReparentNotify:	1421	case ReparentNotify:
1392	if ((Options & Opt_transparent) && check_our_parents ()) {	1422	if ((Options & Opt_transparent) && check_our_parents ())
		1423	{
1393	if (am_transparent)	1424	if (am_transparent)
1394	want_full_refresh = 1;	1425	want_full_refresh = 1;
1395	}	1426	}
1396	#endif /* TRANSPARENT */	1427	#endif /* TRANSPARENT */
1397	break;	1428	break;
1398		1429
1399	case GraphicsExpose:	1430	case GraphicsExpose:
1400	case Expose:	1431	case Expose:
1401	if (ev->xany.window == TermWin.vt) {	1432	if (ev->xany.window == TermWin.vt)
		1433	{
1402	#ifdef NO_SLOW_LINK_SUPPORT	1434	#ifdef NO_SLOW_LINK_SUPPORT
1403	scr_expose (ev->xexpose.x, ev->xexpose.y,	1435	scr_expose (ev->xexpose.x, ev->xexpose.y,
1404	ev->xexpose.width, ev->xexpose.height, False);	1436	ev->xexpose.width, ev->xexpose.height, False);
1405	#else	1437	#else
1406	// don't understand this, so commented it out	1438	// don't understand this, so commented it out
1407	scr_expose (ev->xexpose.x, ev->xexpose.y,	1439	scr_expose (ev->xexpose.x, ev->xexpose.y,
1408	ev->xexpose.width, ev->xexpose.height, False);	1440	ev->xexpose.width, ev->xexpose.height, False);
1409	//scr_expose (ev->xexpose.x, 0,	1441	//scr_expose (ev->xexpose.x, 0,
1410	// ev->xexpose.width, TermWin.height, False);	1442	// ev->xexpose.width, TermWin.height, False);
1411	#endif	1443	#endif
1412	want_refresh = 1;	1444	want_refresh = 1;
1413	} else {	1445	}
		1446	else
		1447	{
1414	XEvent unused_xevent;	1448	XEvent unused_xevent;
1415		1449
1416	while (XCheckTypedWindowEvent(Xdisplay, ev->xany.window,	1450	while (XCheckTypedWindowEvent(Xdisplay, ev->xany.window,
1417	Expose,	1451	Expose,
1418	&unused_xevent)) ;	1452	&unused_xevent)) ;
1419	while (XCheckTypedWindowEvent(Xdisplay, ev->xany.window,	1453	while (XCheckTypedWindowEvent(Xdisplay, ev->xany.window,
1420	GraphicsExpose,	1454	GraphicsExpose,
1421	&unused_xevent)) ;	1455	&unused_xevent)) ;
1422	if (isScrollbarWindow(ev->xany.window)) {	1456	if (isScrollbarWindow(ev->xany.window))
1423	scrollBar.setIdle();	1457	{
1424	scrollbar_show (0);	1458	scrollBar.setIdle();
1425	}	1459	scrollbar_show (0);
		1460	}
1426	#ifdef MENUBAR	1461	#ifdef MENUBAR
1427	if (menubar_visible () && isMenuBarWindow(ev->xany.window))	1462	if (menubar_visible () && isMenuBarWindow(ev->xany.window))
1428	menubar_expose ();	1463	menubar_expose ();
1429	#endif	1464	#endif
1430	#ifdef RXVT_GRAPHICS	1465	#ifdef RXVT_GRAPHICS
1431	Gr_expose (ev->xany.window);	1466	Gr_expose (ev->xany.window);
1432	#endif	1467	#endif
1433	}
1434	break;
1435		1468
		1469	}
		1470	break;
		1471
1436	case MotionNotify:	1472	case MotionNotify:
1437	#ifdef POINTER_BLANK	1473	#ifdef POINTER_BLANK
1438	if (hidden_pointer)	1474	if (hidden_pointer)
1439	pointer_unblank ();	1475	pointer_unblank ();
1440	#endif	1476	#endif
1441	#if MENUBAR	1477	#if MENUBAR
1442	if (isMenuBarWindow(ev->xany.window)) {	1478	if (isMenuBarWindow(ev->xany.window))
		1479	{
1443	menubar_control (&(ev->xbutton));	1480	menubar_control (&(ev->xbutton));
1444	break;	1481	break;
1445	}	1482	}
1446	#endif	1483	#endif
1447	if ((PrivateModes & PrivMode_mouse_report) && !(bypass_keystate))	1484	if ((PrivateModes & PrivMode_mouse_report) && !(bypass_keystate))
1448	break;	1485	break;
1449		1486
1450	if (ev->xany.window == TermWin.vt) {	1487	if (ev->xany.window == TermWin.vt)
		1488	{
1451	if ((ev->xbutton.state & (Button1Mask | Button3Mask))) {	1489	if ((ev->xbutton.state & (Button1Mask | Button3Mask)))
		1490	{
1452	while (XCheckTypedWindowEvent(Xdisplay, TermWin.vt,	1491	while (XCheckTypedWindowEvent(Xdisplay, TermWin.vt,
1453	MotionNotify, ev)) ;	1492	MotionNotify, ev)) ;
1454	XQueryPointer(Xdisplay, TermWin.vt,	1493	XQueryPointer(Xdisplay, TermWin.vt,
1455	&unused_root, &unused_child,	1494	&unused_root, &unused_child,
1456	&unused_root_x, &unused_root_y,	1495	&unused_root_x, &unused_root_y,
1457	&(ev->xbutton.x), &(ev->xbutton.y),	1496	&(ev->xbutton.x), &(ev->xbutton.y),
1458	&unused_mask);	1497	&unused_mask);
1459	#ifdef MOUSE_THRESHOLD	1498	#ifdef MOUSE_THRESHOLD
1460	/* deal with a `jumpy' mouse */	1499	/* deal with a `jumpy' mouse */
1461	if ((ev->xmotion.time - MEvent.time) > MOUSE_THRESHOLD) {	1500	if ((ev->xmotion.time - MEvent.time) > MOUSE_THRESHOLD)
		1501	{
1462	#endif	1502	#endif
1463	selection_extend ((ev->xbutton.x), (ev->xbutton.y),	1503	selection_extend ((ev->xbutton.x), (ev->xbutton.y),
1464	(ev->xbutton.state & Button3Mask) ? 2 : 0);	1504	(ev->xbutton.state & Button3Mask) ? 2 : 0);
1465	#ifdef SELECTION_SCROLLING	1505	#ifdef SELECTION_SCROLLING
1466	if (ev->xbutton.y < TermWin.int_bwidth	1506	if (ev->xbutton.y < TermWin.int_bwidth
1467	|| Pixel2Row(ev->xbutton.y) > (TermWin.nrow-1)) {	1507	|| Pixel2Row(ev->xbutton.y) > (TermWin.nrow-1))
1468	int dist;
1469
1470	pending_scroll_selection=1;
1471
1472	/* don't clobber the current delay if we are
1473	* already in the middle of scrolling.
1474	*/
1475	if (scroll_selection_delay<=0)
1476	scroll_selection_delay=SCROLLBAR_CONTINUOUS_DELAY;
1477
1478	/* save the event params so we can highlight
1479	* the selection in the pending-scroll loop
1480	*/
1481	selection_save_x=ev->xbutton.x;
1482	selection_save_y=ev->xbutton.y;
1483	selection_save_state=
1484	(ev->xbutton.state & Button3Mask) ? 2 : 0;
1485
1486	/* calc number of lines to scroll */
1487	if (ev->xbutton.y<TermWin.int_bwidth) {
1488	scroll_selection_dir = UP;
1489	dist = TermWin.int_bwidth - ev->xbutton.y;
1490	}
1491	else {
1492	scroll_selection_dir = DN;
1493	dist = ev->xbutton.y -
1494	(TermWin.int_bwidth + TermWin.height);
1495	}
1496	scroll_selection_lines=(Pixel2Height(dist)/
1497	SELECTION_SCROLL_LINE_SPEEDUP)+1;
1498	MIN_IT(scroll_selection_lines,
1499	SELECTION_SCROLL_MAX_LINES);
1500	}
1501	else {
1502	/* we are within the text window, so we
1503	* shouldn't be scrolling
1504	*/
1505	pending_scroll_selection = 0;
1506	}
1507	#endif
1508	#ifdef MOUSE_THRESHOLD
1509	}
1510	#endif
1511	}
1512	} else if (isScrollbarWindow(ev->xany.window) && scrollbar_isMotion()) {
1513	while (XCheckTypedWindowEvent(Xdisplay, scrollBar.win,
1514	MotionNotify, ev)) ;
1515	XQueryPointer(Xdisplay, scrollBar.win,
1516	&unused_root, &unused_child,
1517	&unused_root_x, &unused_root_y,
1518	&(ev->xbutton.x), &(ev->xbutton.y),
1519	&unused_mask);
1520	scr_move_to (scrollbar_position(ev->xbutton.y) - csrO,
1521	scrollbar_size());
1522	scr_refresh (refresh_type);
1523	refresh_limit = 0;
1524	scrollbar_show (1);
1525	}
1526	break;
1527	}
1528	}
1529
1530	void
1531	rxvt_term::button_press (XButtonEvent *ev)
1532	{
1533	int reportmode = 0, clickintime;
1534
1535	bypass_keystate = ev->state & (ModMetaMask | ShiftMask);
1536	if (!bypass_keystate)
1537	reportmode = !!(PrivateModes & PrivMode_mouse_report);
1538	/*
1539	* VT window processing of button press
1540	*/
1541	if (ev->window == TermWin.vt)
1542	{
1543	#if RXVT_GRAPHICS
1544	if (ev->subwindow != None)
1545	rxvt_Gr_ButtonPress (ev->x, ev->y);
1546	else
1547	#endif
1548	{
1549	clickintime = ev->time - MEvent.time < MULTICLICK_TIME;
1550	if (reportmode)
1551	{
1552	/* mouse report from vt window */
1553	/* save the xbutton state (for ButtonRelease) */
1554	MEvent.state = ev->state;
1555	#ifdef MOUSE_REPORT_DOUBLECLICK
1556	if (ev->button == MEvent.button && clickintime)
1557	{
1558	/* same button, within alloted time */
1559	MEvent.clicks++;
1560	if (MEvent.clicks > 1)
1561	{	1508	{
1562	/* only report double clicks */	1509	int dist;
1563	MEvent.clicks = 2;
1564	mouse_report (ev);
1565		1510
1566	/* don't report the release */	1511	pending_scroll_selection=1;
1567	MEvent.clicks = 0;	1512
1568	MEvent.button = AnyButton;	1513	/* don't clobber the current delay if we are
1569	}	1514	* already in the middle of scrolling.
1570	}
1571	else
1572	{	1515	*/
1573	/* different button, or time expired */	1516	if (scroll_selection_delay<=0)
1574	MEvent.clicks = 1;	1517	scroll_selection_delay=SCROLLBAR_CONTINUOUS_DELAY;
1575	MEvent.button = ev->button;	1518
1576	mouse_report (ev);	1519	/* save the event params so we can highlight
1577	}	1520	* the selection in the pending-scroll loop
1578	#else
1579	MEvent.button = ev->button;
1580	mouse_report (ev);
1581	#endif /* MOUSE_REPORT_DOUBLECLICK */
1582	}
1583	else
1584	{
1585	if (ev->button != MEvent.button)
1586	MEvent.clicks = 0;
1587	switch (ev->button)
1588	{	1521	*/
1589	case Button1:	1522	selection_save_x=ev->xbutton.x;
1590	/* allow shift+left click to extend selection */	1523	selection_save_y=ev->xbutton.y;
1591	if (ev->state & ShiftMask && !(PrivateModes & PrivMode_mouse_report))	1524	selection_save_state=
		1525	(ev->xbutton.state & Button3Mask) ? 2 : 0;
		1526
		1527	/* calc number of lines to scroll */
		1528	if (ev->xbutton.y<TermWin.int_bwidth)
1592	{	1529	{
1593	if (MEvent.button == Button1 && clickintime)	1530	scroll_selection_dir = UP;
1594	selection_rotate (ev->x, ev->y);	1531	dist = TermWin.int_bwidth - ev->xbutton.y;
1595	else
1596	selection_extend (ev->x, ev->y, 1);
1597	}	1532	}
1598	else	1533	else
1599	{	1534	{
1600	if (MEvent.button == Button1 && clickintime)	1535	scroll_selection_dir = DN;
1601	MEvent.clicks++;	1536	dist = ev->xbutton.y -
1602	else	1537	(TermWin.int_bwidth + TermWin.height);
1603	MEvent.clicks = 1;
1604
1605	selection_click (MEvent.clicks, ev->x, ev->y);
1606	}	1538	}
		1539	scroll_selection_lines=(Pixel2Height(dist)/
		1540	SELECTION_SCROLL_LINE_SPEEDUP)+1;
		1541	MIN_IT(scroll_selection_lines,
		1542	SELECTION_SCROLL_MAX_LINES);
		1543	}
		1544	else
		1545	{
		1546	/* we are within the text window, so we
		1547	* shouldn't be scrolling
		1548	*/
		1549	pending_scroll_selection = 0;
		1550	}
		1551	#endif
		1552	#ifdef MOUSE_THRESHOLD
1607		1553
		1554	}
		1555	#endif
		1556
		1557	}
		1558	}
		1559	else if (isScrollbarWindow(ev->xany.window) && scrollbar_isMotion())
		1560	{
		1561	while (XCheckTypedWindowEvent(Xdisplay, scrollBar.win,
		1562	MotionNotify, ev)) ;
		1563	XQueryPointer(Xdisplay, scrollBar.win,
		1564	&unused_root, &unused_child,
		1565	&unused_root_x, &unused_root_y,
		1566	&(ev->xbutton.x), &(ev->xbutton.y),
		1567	&unused_mask);
		1568	scr_move_to (scrollbar_position(ev->xbutton.y) - csrO,
		1569	scrollbar_size());
		1570	scr_refresh (refresh_type);
		1571	refresh_limit = 0;
		1572	scrollbar_show (1);
		1573	}
		1574	break;
		1575	}
		1576	}
		1577
		1578	void
		1579	rxvt_term::button_press (XButtonEvent *ev)
		1580	{
		1581	int reportmode = 0, clickintime;
		1582
		1583	bypass_keystate = ev->state & (ModMetaMask | ShiftMask);
		1584	if (!bypass_keystate)
		1585	reportmode = !!(PrivateModes & PrivMode_mouse_report);
		1586	/*
		1587	* VT window processing of button press
		1588	*/
		1589	if (ev->window == TermWin.vt)
		1590	{
		1591	#if RXVT_GRAPHICS
		1592	if (ev->subwindow != None)
		1593	rxvt_Gr_ButtonPress (ev->x, ev->y);
		1594	else
		1595	#endif
		1596
		1597	{
		1598	clickintime = ev->time - MEvent.time < MULTICLICK_TIME;
		1599	if (reportmode)
		1600	{
		1601	/* mouse report from vt window */
		1602	/* save the xbutton state (for ButtonRelease) */
		1603	MEvent.state = ev->state;
		1604	#ifdef MOUSE_REPORT_DOUBLECLICK
		1605	if (ev->button == MEvent.button && clickintime)
		1606	{
		1607	/* same button, within alloted time */
		1608	MEvent.clicks++;
		1609	if (MEvent.clicks > 1)
		1610	{
		1611	/* only report double clicks */
		1612	MEvent.clicks = 2;
		1613	mouse_report (ev);
		1614
		1615	/* don't report the release */
		1616	MEvent.clicks = 0;
1608	MEvent.button = Button1;	1617	MEvent.button = AnyButton;
1609	break;	1618	}
		1619	}
		1620	else
		1621	{
		1622	/* different button, or time expired */
		1623	MEvent.clicks = 1;
		1624	MEvent.button = ev->button;
		1625	mouse_report (ev);
		1626	}
		1627	#else
		1628	MEvent.button = ev->button;
		1629	mouse_report (ev);
		1630	#endif /* MOUSE_REPORT_DOUBLECLICK */
1610		1631
		1632	}
		1633	else
		1634	{
		1635	if (ev->button != MEvent.button)
		1636	MEvent.clicks = 0;
		1637	switch (ev->button)
		1638	{
1611	case Button3:	1639	case Button1:
		1640	/* allow shift+left click to extend selection */
		1641	if (ev->state & ShiftMask && !(PrivateModes & PrivMode_mouse_report))
		1642	{
1612	if (MEvent.button == Button3 && clickintime)	1643	if (MEvent.button == Button1 && clickintime)
1613	selection_rotate (ev->x, ev->y);	1644	selection_rotate (ev->x, ev->y);
1614	else	1645	else
1615	selection_extend (ev->x, ev->y, 1);	1646	selection_extend (ev->x, ev->y, 1);
		1647	}
		1648	else
		1649	{
		1650	if (MEvent.button == Button1 && clickintime)
		1651	MEvent.clicks++;
		1652	else
		1653	MEvent.clicks = 1;
		1654
		1655	selection_click (MEvent.clicks, ev->x, ev->y);
		1656	}
		1657
		1658	MEvent.button = Button1;
		1659	break;
		1660
		1661	case Button3:
		1662	if (MEvent.button == Button3 && clickintime)
		1663	selection_rotate (ev->x, ev->y);
		1664	else
		1665	selection_extend (ev->x, ev->y, 1);
1616	MEvent.button = Button3;	1666	MEvent.button = Button3;
		1667	break;
		1668	}
		1669	}
		1670	MEvent.time = ev->time;
		1671	return;
		1672	}
		1673	}
		1674
		1675	/*
		1676	* Scrollbar window processing of button press
		1677	*/
		1678	if (isScrollbarWindow(ev->window))
		1679	{
		1680	scrollBar.setIdle ();
		1681	/*
		1682	* Rxvt-style scrollbar:
		1683	* move up if mouse is above slider
		1684	* move dn if mouse is below slider
		1685	*
		1686	* XTerm-style scrollbar:
		1687	* Move display proportional to pointer location
		1688	* pointer near top -> scroll one line
		1689	* pointer near bot -> scroll full page
		1690	*/
		1691	#ifndef NO_SCROLLBAR_REPORT
		1692	if (reportmode)
		1693	{
		1694	/*
		1695	* Mouse report disabled scrollbar:
		1696	* arrow buttons - send up/down
		1697	* click on scrollbar - send pageup/down
		1698	*/
		1699	if ((scrollBar.style == R_SB_NEXT
		1700	&& scrollbarnext_upButton(ev->y))
		1701	|| (scrollBar.style == R_SB_RXVT
		1702	&& scrollbarrxvt_upButton(ev->y)))
		1703	tt_printf("\033[A");
		1704	else if ((scrollBar.style == R_SB_NEXT
		1705	&& scrollbarnext_dnButton(ev->y))
		1706	|| (scrollBar.style == R_SB_RXVT
		1707	&& scrollbarrxvt_dnButton(ev->y)))
		1708	tt_printf("\033[B");
		1709	else
		1710	switch (ev->button)
		1711	{
		1712	case Button2:
		1713	tt_printf("\014");
		1714	break;
		1715	case Button1:
		1716	tt_printf("\033[6~");
		1717	break;
		1718	case Button3:
		1719	tt_printf("\033[5~");
		1720	break;
		1721	}
		1722	}
		1723	else
		1724	#endif /* NO_SCROLLBAR_REPORT */
		1725
		1726	{
		1727	char upordown = 0;
		1728
		1729	if (scrollBar.style == R_SB_NEXT)
		1730	{
		1731	if (scrollbarnext_upButton(ev->y))
		1732	upordown = -1; /* up */
		1733	else if (scrollbarnext_dnButton(ev->y))
		1734	upordown = 1; /* down */
		1735	}
		1736	else if (scrollBar.style == R_SB_RXVT)
		1737	{
		1738	if (scrollbarrxvt_upButton(ev->y))
		1739	upordown = -1; /* up */
		1740	else if (scrollbarrxvt_dnButton(ev->y))
		1741	upordown = 1; /* down */
		1742	}
		1743	if (upordown)
		1744	{
		1745	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
		1746	scroll_arrow_delay = SCROLLBAR_INITIAL_DELAY;
		1747	#endif
		1748	if (scr_page (upordown < 0 ? UP : DN, 1))
		1749	{
		1750	if (upordown < 0)
		1751	scrollBar.setUp ();
		1752	else
		1753	scrollBar.setDn ();
		1754	}
		1755	}
		1756	else
		1757	switch (ev->button)
		1758	{
		1759	case Button2:
		1760	switch (scrollbar_align)
		1761	{
		1762	case R_SB_ALIGN_TOP:
		1763	csrO = 0;
1617	break;	1764	break;
1618	}	1765	case R_SB_ALIGN_CENTRE:
1619	}
1620	MEvent.time = ev->time;
1621	return;
1622	}
1623	}
1624
1625	/*
1626	* Scrollbar window processing of button press
1627	*/
1628	if (isScrollbarWindow(ev->window))
1629	{
1630	scrollBar.setIdle ();
1631	/*
1632	* Rxvt-style scrollbar:
1633	* move up if mouse is above slider
1634	* move dn if mouse is below slider
1635	*
1636	* XTerm-style scrollbar:
1637	* Move display proportional to pointer location
1638	* pointer near top -> scroll one line
1639	* pointer near bot -> scroll full page
1640	*/
1641	#ifndef NO_SCROLLBAR_REPORT
1642	if (reportmode) {
1643	/*
1644	* Mouse report disabled scrollbar:
1645	* arrow buttons - send up/down
1646	* click on scrollbar - send pageup/down
1647	*/
1648	if ((scrollBar.style == R_SB_NEXT
1649	&& scrollbarnext_upButton(ev->y))
1650	|| (scrollBar.style == R_SB_RXVT
1651	&& scrollbarrxvt_upButton(ev->y)))
1652	tt_printf("\033[A");
1653	else if ((scrollBar.style == R_SB_NEXT
1654	&& scrollbarnext_dnButton(ev->y))
1655	|| (scrollBar.style == R_SB_RXVT
1656	&& scrollbarrxvt_dnButton(ev->y)))
1657	tt_printf("\033[B");
1658	else
1659	switch (ev->button) {
1660	case Button2:
1661	tt_printf("\014");
1662	break;
1663	case Button1:
1664	tt_printf("\033[6~");
1665	break;
1666	case Button3:
1667	tt_printf("\033[5~");
1668	break;
1669	}
1670	}
1671	else
1672	#endif /* NO_SCROLLBAR_REPORT */
1673	{
1674	char upordown = 0;
1675
1676	if (scrollBar.style == R_SB_NEXT) {
1677	if (scrollbarnext_upButton(ev->y))
1678	upordown = -1; /* up */
1679	else if (scrollbarnext_dnButton(ev->y))
1680	upordown = 1; /* down */
1681	} else if (scrollBar.style == R_SB_RXVT) {
1682	if (scrollbarrxvt_upButton(ev->y))
1683	upordown = -1; /* up */
1684	else if (scrollbarrxvt_dnButton(ev->y))
1685	upordown = 1; /* down */
1686	}
1687	if (upordown) {
1688	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1689	scroll_arrow_delay = SCROLLBAR_INITIAL_DELAY;
1690	#endif
1691	if (scr_page (upordown < 0 ? UP : DN, 1)) {
1692	if (upordown < 0)
1693	scrollBar.setUp ();
1694	else
1695	scrollBar.setDn ();
1696	}
1697	} else
1698	switch (ev->button) {
1699	case Button2:
1700	switch (scrollbar_align) {
1701	case R_SB_ALIGN_TOP:
1702	csrO = 0;
1703	break;
1704	case R_SB_ALIGN_CENTRE:
1705	csrO = (scrollBar.bot - scrollBar.top) / 2;	1766	csrO = (scrollBar.bot - scrollBar.top) / 2;
1706	break;	1767	break;
1707	case R_SB_ALIGN_BOTTOM:	1768	case R_SB_ALIGN_BOTTOM:
1708	csrO = scrollBar.bot - scrollBar.top;	1769	csrO = scrollBar.bot - scrollBar.top;
1709	break;	1770	break;
1710	}	1771	}
1711	if (scrollBar.style == R_SB_XTERM	1772	if (scrollBar.style == R_SB_XTERM
1712	|| scrollbar_above_slider(ev->y)	1773	|| scrollbar_above_slider(ev->y)
1713	|| scrollbar_below_slider(ev->y))	1774	|| scrollbar_below_slider(ev->y))
1714	scr_move_to ( scrollbar_position(ev->y) - csrO,	1775	scr_move_to ( scrollbar_position(ev->y) - csrO,
1715	scrollbar_size());	1776	scrollbar_size());
1716	scrollBar.setMotion ();	1777	scrollBar.setMotion ();
1717	break;	1778	break;
1718		1779
1719	case Button1:	1780	case Button1:
1720	if (scrollbar_align == R_SB_ALIGN_CENTRE)	1781	if (scrollbar_align == R_SB_ALIGN_CENTRE)
1721	csrO = ev->y - scrollBar.top;	1782	csrO = ev->y - scrollBar.top;
1722	/* FALLTHROUGH */	1783	/* FALLTHROUGH */
1723		1784
1724	case Button3:	1785	case Button3:
1725	if (scrollBar.style != R_SB_XTERM) {	1786	if (scrollBar.style != R_SB_XTERM)
1726	if (scrollbar_above_slider(ev->y))	1787	{
		1788	if (scrollbar_above_slider(ev->y))
1727	# ifdef RXVT_SCROLL_FULL	1789	# ifdef RXVT_SCROLL_FULL
1728	scr_page (UP, TermWin.nrow - 1);	1790	scr_page (UP, TermWin.nrow - 1);
1729	# else	1791	# else
1730	scr_page (UP, TermWin.nrow / 4);	1792	scr_page (UP, TermWin.nrow / 4);
1731	# endif	1793	# endif
1732	else if (scrollbar_below_slider(ev->y))	1794	else if (scrollbar_below_slider(ev->y))
1733	# ifdef RXVT_SCROLL_FULL	1795	# ifdef RXVT_SCROLL_FULL
1734	scr_page (DN, TermWin.nrow - 1);	1796	scr_page (DN, TermWin.nrow - 1);
1735	# else	1797	# else
1736	scr_page (DN, TermWin.nrow / 4);	1798	scr_page (DN, TermWin.nrow / 4);
1737	# endif	1799	# endif
1738	else	1800	else
1739	scrollBar.setMotion ();	1801	scrollBar.setMotion ();
1740	} else {	1802	}
		1803	else
		1804	{
1741	scr_page ((ev->button == Button1 ? DN : UP),	1805	scr_page ((ev->button == Button1 ? DN : UP),
1742	(TermWin.nrow	1806	(TermWin.nrow
1743	* scrollbar_position(ev->y)	1807	* scrollbar_position(ev->y)
1744	/ scrollbar_size()));	1808	/ scrollbar_size()));
1745	}	1809	}
1746	break;	1810	break;
1747	}	1811	}
1748	}	1812	}
1749	return;	1813	return;
1750	}	1814	}
1751	#if MENUBAR	1815	#if MENUBAR
1752	/*	1816	/*
1753	* Menubar window processing of button press	1817	* Menubar window processing of button press
1754	*/	1818	*/
1755	if (isMenuBarWindow(ev->window))	1819	if (isMenuBarWindow(ev->window))
1756	menubar_control (ev);	1820	menubar_control (ev);
1757	#endif	1821	#endif
1758	}	1822	}
1759		1823
1760	void	1824	void
1761	rxvt_term::button_release (XButtonEvent *ev)	1825	rxvt_term::button_release (XButtonEvent *ev)
1762	{	1826	{
1763	int reportmode = 0;	1827	int reportmode = 0;
1764		1828
1765	csrO = 0; /* reset csr Offset */	1829	csrO = 0; /* reset csr Offset */
1766	if (!bypass_keystate)	1830	if (!bypass_keystate)
1767	reportmode = !!(PrivateModes & PrivMode_mouse_report);	1831	reportmode = !!(PrivateModes & PrivMode_mouse_report);
1768		1832
1769	if (scrollbar_isUpDn()) {	1833	if (scrollbar_isUpDn())
		1834	{
1770	scrollBar.setIdle ();	1835	scrollBar.setIdle ();
1771	scrollbar_show (0);	1836	scrollbar_show (0);
1772	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING	1837	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1773	refresh_type &= ~SMOOTH_REFRESH;	1838	refresh_type &= ~SMOOTH_REFRESH;
1774	#endif	1839	#endif
		1840
1775	}	1841	}
1776	#ifdef SELECTION_SCROLLING	1842	#ifdef SELECTION_SCROLLING
1777	pending_scroll_selection=0;	1843	pending_scroll_selection=0;
1778	#endif	1844	#endif
1779	if (ev->window == TermWin.vt)	1845	if (ev->window == TermWin.vt)
1780	{	1846	{
1781	#ifdef RXVT_GRAPHICS	1847	#ifdef RXVT_GRAPHICS
1782	if (ev->subwindow != None)	1848	if (ev->subwindow != None)
1783	rxvt_Gr_ButtonRelease(ev->x, ev->y);	1849	rxvt_Gr_ButtonRelease(ev->x, ev->y);
1784	else	1850	else
1785	#endif	1851	#endif
		1852
1786	{	1853	{
1787	if (reportmode)	1854	if (reportmode)
1788	{	1855	{
1789	/* mouse report from vt window */	1856	/* mouse report from vt window */
1790	/* don't report release of wheel "buttons" */	1857	/* don't report release of wheel "buttons" */
1791	if (ev->button >= 4)	1858	if (ev->button >= 4)
1792	return;	1859	return;
1793	#ifdef MOUSE_REPORT_DOUBLECLICK	1860	#ifdef MOUSE_REPORT_DOUBLECLICK
1794	/* only report the release of 'slow' single clicks */	1861	/* only report the release of 'slow' single clicks */
1795	if (MEvent.button != AnyButton	1862	if (MEvent.button != AnyButton
1796	&& (ev->button != MEvent.button	1863	&& (ev->button != MEvent.button
1797	|| (ev->time - MEvent.time	1864	|| (ev->time - MEvent.time
1798	> MULTICLICK_TIME / 2)))	1865	> MULTICLICK_TIME / 2)))
1799	{	1866	{
1800	MEvent.clicks = 0;	1867	MEvent.clicks = 0;
1801	MEvent.button = AnyButton;	1868	MEvent.button = AnyButton;
1802	mouse_report (ev);	1869	mouse_report (ev);
1803	}	1870	}
1804	#else /* MOUSE_REPORT_DOUBLECLICK */	1871	#else /* MOUSE_REPORT_DOUBLECLICK */
1805	MEvent.button = AnyButton;	1872	MEvent.button = AnyButton;
1806	mouse_report (ev);	1873	mouse_report (ev);
1807	#endif /* MOUSE_REPORT_DOUBLECLICK */	1874	#endif /* MOUSE_REPORT_DOUBLECLICK */
1808	return;	1875	return;
1809	}	1876	}
1810	/*	1877	/*
1811	* dumb hack to compensate for the failure of click-and-drag	1878	* dumb hack to compensate for the failure of click-and-drag
1812	* when overriding mouse reporting	1879	* when overriding mouse reporting
1813	*/	1880	*/
1814	if (PrivateModes & PrivMode_mouse_report	1881	if (PrivateModes & PrivMode_mouse_report
1815	&& bypass_keystate	1882	&& bypass_keystate
1816	&& ev->button == Button1 && MEvent.clicks <= 1)	1883	&& ev->button == Button1 && MEvent.clicks <= 1)
1817	selection_extend (ev->x, ev->y, 0);	1884	selection_extend (ev->x, ev->y, 0);
1818		1885
1819	switch (ev->button) {	1886	switch (ev->button)
		1887	{
1820	case Button1:	1888	case Button1:
1821	case Button3:	1889	case Button3:
1822	selection_make (ev->time);	1890	selection_make (ev->time);
1823	break;	1891	break;
1824	case Button2:	1892	case Button2:
1825	selection_request (ev->time, ev->x, ev->y);	1893	selection_request (ev->time, ev->x, ev->y);
1826	break;	1894	break;
1827	#ifdef MOUSE_WHEEL	1895	#ifdef MOUSE_WHEEL
1828	case Button4:	1896	case Button4:
1829	case Button5:	1897	case Button5:
1830	{	1898	{
1831	int i;	1899	int i;
1832	page_dirn v;	1900	page_dirn v;
1833		1901
1834	v = (ev->button == Button4) ? UP : DN;	1902	v = (ev->button == Button4) ? UP : DN;
1835	if (ev->state & ShiftMask)	1903	if (ev->state & ShiftMask)
1836	i = 1;	1904	i = 1;
1837	else if ((Options & Opt_mouseWheelScrollPage))	1905	else if ((Options & Opt_mouseWheelScrollPage))
1838	i = TermWin.nrow - 1;	1906	i = TermWin.nrow - 1;
1839	else	1907	else
1840	i = 5;	1908	i = 5;
1841	# ifdef MOUSE_SLIP_WHEELING	1909	# ifdef MOUSE_SLIP_WHEELING
1842	if (ev->state & ControlMask)	1910	if (ev->state & ControlMask)
1843	{	1911	{
1844	mouse_slip_wheel_speed += (v ? -1 : 1);	1912	mouse_slip_wheel_speed += (v ? -1 : 1);
1845	mouse_slip_wheel_delay = SCROLLBAR_CONTINUOUS_DELAY;	1913	mouse_slip_wheel_delay = SCROLLBAR_CONTINUOUS_DELAY;
1846	}	1914	}
1847	# endif	1915	# endif
1848	# ifdef JUMP_MOUSE_WHEEL	1916	# ifdef JUMP_MOUSE_WHEEL
1849	scr_page (v, i);	1917	scr_page (v, i);
1850	scr_refresh (SMOOTH_REFRESH);	1918	scr_refresh (SMOOTH_REFRESH);
1851	scrollbar_show (1);	1919	scrollbar_show (1);
1852	# else	1920	# else
1853	while (i--)	1921	while (i--)
1854	{	1922	{
1855	scr_page (v, 1);	1923	scr_page (v, 1);
1856	scr_refresh (SMOOTH_REFRESH);	1924	scr_refresh (SMOOTH_REFRESH);
1857	scrollbar_show (1);	1925	scrollbar_show (1);
1858	}	1926	}
1859	# endif	1927	# endif
1860	}	1928
1861	break;	1929	}
		1930	break;
1862	#endif	1931	#endif
1863	}	1932
1864	}	1933	}
1865	}	1934	}
		1935	}
1866	#ifdef MENUBAR	1936	#ifdef MENUBAR
1867	else if (isMenuBarWindow(ev->window))	1937	else if (isMenuBarWindow(ev->window))
1868	menubar_control (ev);	1938	menubar_control (ev);
1869	#endif	1939	#endif
1870	}	1940	}
1871		1941
1872		1942
1873	#ifdef TRANSPARENT	1943	#ifdef TRANSPARENT
…		…
1876	* Do transparency updates if required	1946	* Do transparency updates if required
1877	*/	1947	*/
1878	int	1948	int
1879	rxvt_term::check_our_parents ()	1949	rxvt_term::check_our_parents ()
1880	{	1950	{
1881	int i, pchanged, aformat, have_pixmap, rootdepth;	1951	int i, pchanged, aformat, have_pixmap, rootdepth;
1882	unsigned long nitems, bytes_after;	1952	unsigned long nitems, bytes_after;
1883	Atom atype;	1953	Atom atype;
1884	unsigned char *prop = NULL;	1954	unsigned char *prop = NULL;
1885	Window root, oldp, *list;	1955	Window root, oldp, *list;
1886	Pixmap rootpixmap = None;	1956	Pixmap rootpixmap = None;
1887	XWindowAttributes wattr, wrootattr;	1957	XWindowAttributes wattr, wrootattr;
1888		1958
1889	pchanged = 0;	1959	pchanged = 0;
1890		1960
1891	if (!(Options & Opt_transparent))	1961	if (!(Options & Opt_transparent))
1892	return pchanged; /* Don't try any more */	1962	return pchanged; /* Don't try any more */
1893		1963
1894	XGetWindowAttributes(Xdisplay, Xroot, &wrootattr);	1964	XGetWindowAttributes(Xdisplay, Xroot, &wrootattr);
1895	rootdepth = wrootattr.depth;	1965	rootdepth = wrootattr.depth;
1896		1966
1897	XGetWindowAttributes(Xdisplay, TermWin.parent[0], &wattr);	1967	XGetWindowAttributes(Xdisplay, TermWin.parent[0], &wattr);
1898	if (rootdepth != wattr.depth) {	1968	if (rootdepth != wattr.depth)
		1969	{
1899	if (am_transparent) {	1970	if (am_transparent)
		1971	{
1900	pchanged = 1;	1972	pchanged = 1;
1901	XSetWindowBackground(Xdisplay, TermWin.vt,	1973	XSetWindowBackground(Xdisplay, TermWin.vt,
1902	PixColors[Color_bg]);	1974	PixColors[Color_bg]);
1903	am_transparent = am_pixmap_trans = 0;	1975	am_transparent = am_pixmap_trans = 0;
1904	}	1976	}
1905	return pchanged; /* Don't try any more */	1977	return pchanged; /* Don't try any more */
1906	}	1978	}
1907		1979
1908	/* Get all X ops out of the queue so that our information is up-to-date. */	1980	/* Get all X ops out of the queue so that our information is up-to-date. */
1909	XSync(Xdisplay, False);	1981	XSync(Xdisplay, False);
1910		1982
1911	/*	1983	/*
1912	* Make the frame window set by the window manager have	1984	* Make the frame window set by the window manager have
1913	* the root background. Some window managers put multiple nested frame	1985	* the root background. Some window managers put multiple nested frame
1914	* windows for each client, so we have to take care about that.	1986	* windows for each client, so we have to take care about that.
1915	*/	1987	*/
1916	i = (xa[XA_XROOTPMAPID] != 0	1988	i = (xa[XA_XROOTPMAPID] != 0
1917	&& (XGetWindowProperty(Xdisplay, Xroot, xa[XA_XROOTPMAPID],	1989	&& (XGetWindowProperty(Xdisplay, Xroot, xa[XA_XROOTPMAPID],
1918	0L, 1L, False, XA_PIXMAP, &atype, &aformat,	1990	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
1919	&nitems, &bytes_after, &prop) == Success));	1991	&nitems, &bytes_after, &prop) == Success));
1920	if (!i || prop == NULL)	1992	if (!i || prop == NULL)
1921	have_pixmap = 0;	1993	have_pixmap = 0;
1922	else {	1994	else
		1995	{
1923	have_pixmap = 1;	1996	have_pixmap = 1;
1924	rootpixmap = *((Pixmap *)prop);	1997	rootpixmap = *((Pixmap *)prop);
1925	XFree(prop);	1998	XFree(prop);
1926	}	1999	}
1927	if (have_pixmap) {	2000	if (have_pixmap)
1928	/*	2001	{
		2002	/*
1929	* Copy Xroot pixmap transparency	2003	* Copy Xroot pixmap transparency
1930	*/	2004	*/
1931	int sx, sy, nx, ny;	2005	int sx, sy, nx, ny;
1932	unsigned int nw, nh;	2006	unsigned int nw, nh;
1933	Window cr;	2007	Window cr;
1934	XImage *image;	2008	XImage *image;
1935	GC gc;	2009	GC gc;
1936	XGCValues gcvalue;	2010	XGCValues gcvalue;
1937		2011
1938	XTranslateCoordinates(Xdisplay, TermWin.parent[0], Xroot,	2012	XTranslateCoordinates(Xdisplay, TermWin.parent[0], Xroot,
1939	0, 0, &sx, &sy, &cr);	2013	0, 0, &sx, &sy, &cr);
1940	nw = (unsigned int)szHint.width;	2014	nw = (unsigned int)szHint.width;
1941	nh = (unsigned int)szHint.height;	2015	nh = (unsigned int)szHint.height;
1942	nx = ny = 0;	2016	nx = ny = 0;
1943	if (sx < 0) {	2017	if (sx < 0)
		2018	{
1944	nw += sx;	2019	nw += sx;
1945	nx = -sx;	2020	nx = -sx;
1946	sx = 0;	2021	sx = 0;
1947	}	2022	}
1948	if (sy < 0) {	2023	if (sy < 0)
		2024	{
1949	nh += sy;	2025	nh += sy;
1950	ny = -sy;	2026	ny = -sy;
1951	sy = 0;	2027	sy = 0;
1952	}	2028	}
1953	MIN_IT(nw, (unsigned int)(wrootattr.width - sx));	2029	MIN_IT(nw, (unsigned int)(wrootattr.width - sx));
1954	MIN_IT(nh, (unsigned int)(wrootattr.height - sy));	2030	MIN_IT(nh, (unsigned int)(wrootattr.height - sy));
1955	allowedxerror = -1;	2031	allowedxerror = -1;
1956	image = XGetImage(Xdisplay, rootpixmap, sx, sy, nw, nh, AllPlanes,	2032	image = XGetImage(Xdisplay, rootpixmap, sx, sy, nw, nh, AllPlanes,
1957	ZPixmap);	2033	ZPixmap);
1958	/* XXX: handle BadMatch - usually because we're outside the pixmap */	2034	/* XXX: handle BadMatch - usually because we're outside the pixmap */
1959	/* XXX: may need a delay here? */	2035	/* XXX: may need a delay here? */
1960	allowedxerror = 0;	2036	allowedxerror = 0;
1961	if (image == NULL) {	2037	if (image == NULL)
		2038	{
1962	if (am_transparent && am_pixmap_trans) {	2039	if (am_transparent && am_pixmap_trans)
1963	pchanged = 1;	2040	{
		2041	pchanged = 1;
1964	if (TermWin.pixmap != None) {	2042	if (TermWin.pixmap != None)
		2043	{
1965	XFreePixmap(Xdisplay, TermWin.pixmap);	2044	XFreePixmap(Xdisplay, TermWin.pixmap);
1966	TermWin.pixmap = None;	2045	TermWin.pixmap = None;
1967	}	2046	}
1968	}	2047	}
1969	am_pixmap_trans = 0;	2048	am_pixmap_trans = 0;
1970	} else {	2049	}
		2050	else
		2051	{
1971	if (TermWin.pixmap != None)	2052	if (TermWin.pixmap != None)
1972	XFreePixmap(Xdisplay, TermWin.pixmap);	2053	XFreePixmap(Xdisplay, TermWin.pixmap);
1973	TermWin.pixmap = XCreatePixmap(Xdisplay, TermWin.vt,	2054	TermWin.pixmap = XCreatePixmap(Xdisplay, TermWin.vt,
1974	(unsigned int)szHint.width,	2055	(unsigned int)szHint.width,
1975	(unsigned int)szHint.height,	2056	(unsigned int)szHint.height,
1976	(unsigned int)image->depth);	2057	(unsigned int)image->depth);
1977	gc = XCreateGC(Xdisplay, TermWin.vt, 0UL, &gcvalue);	2058	gc = XCreateGC(Xdisplay, TermWin.vt, 0UL, &gcvalue);
1978	XPutImage(Xdisplay, TermWin.pixmap, gc, image, 0, 0,	2059	XPutImage(Xdisplay, TermWin.pixmap, gc, image, 0, 0,
1979	nx, ny, (unsigned int)image->width,	2060	nx, ny, (unsigned int)image->width,
1980	(unsigned int)image->height);	2061	(unsigned int)image->height);
1981	XFreeGC(Xdisplay, gc);	2062	XFreeGC(Xdisplay, gc);
1982	XDestroyImage(image);	2063	XDestroyImage(image);
1983	XSetWindowBackgroundPixmap(Xdisplay, TermWin.vt,	2064	XSetWindowBackgroundPixmap(Xdisplay, TermWin.vt,
1984	TermWin.pixmap);	2065	TermWin.pixmap);
1985	if (!am_transparent || !am_pixmap_trans)	2066	if (!am_transparent || !am_pixmap_trans)
1986	pchanged = 1;	2067	pchanged = 1;
1987	am_transparent = am_pixmap_trans = 1;	2068	am_transparent = am_pixmap_trans = 1;
1988	}	2069	}
1989	}	2070	}
1990	if (!am_pixmap_trans) {	2071	if (!am_pixmap_trans)
		2072	{
1991	unsigned int n;	2073	unsigned int n;
1992	/*	2074	/*
1993	* InheritPixmap transparency	2075	* InheritPixmap transparency
1994	*/	2076	*/
1995	D_X((stderr, "InheritPixmap Seeking to %08lx", Xroot));	2077	D_X((stderr, "InheritPixmap Seeking to %08lx", Xroot));
1996	for (i = 1; i < (int)(sizeof(TermWin.parent) / sizeof(Window));	2078	for (i = 1; i < (int)(sizeof(TermWin.parent) / sizeof(Window));
1997	i++) {	2079	i++)
		2080	{
1998	oldp = TermWin.parent[i];	2081	oldp = TermWin.parent[i];
1999	XQueryTree(Xdisplay, TermWin.parent[i - 1], &root,	2082	XQueryTree(Xdisplay, TermWin.parent[i - 1], &root,
2000	&TermWin.parent[i], &list, &n);	2083	&TermWin.parent[i], &list, &n);
2001	XFree(list);	2084	XFree(list);
2002	D_X((stderr, "InheritPixmap Parent[%d] = %08lx", i, TermWin.parent[i]));	2085	D_X((stderr, "InheritPixmap Parent[%d] = %08lx", i, TermWin.parent[i]));
2003	if (TermWin.parent[i] == Xroot) {	2086	if (TermWin.parent[i] == Xroot)
2004	if (oldp != None)	2087	{
2005	pchanged = 1;	2088	if (oldp != None)
2006	break;	2089	pchanged = 1;
2007	}	2090	break;
		2091	}
2008	if (oldp != TermWin.parent[i])	2092	if (oldp != TermWin.parent[i])
2009	pchanged = 1;	2093	pchanged = 1;
2010	}	2094	}
2011	n = 0;	2095	n = 0;
2012	if (pchanged) {	2096	if (pchanged)
		2097	{
2013	for (; n < (unsigned int)i; n++) {	2098	for (; n < (unsigned int)i; n++)
		2099	{
2014	XGetWindowAttributes(Xdisplay, TermWin.parent[n], &wattr);	2100	XGetWindowAttributes(Xdisplay, TermWin.parent[n], &wattr);
2015	D_X((stderr, "InheritPixmap Checking Parent[%d]: %s", n, (wattr.depth == rootdepth && wattr.class != InputOnly) ? "OK" : "FAIL"));	2101	D_X((stderr, "InheritPixmap Checking Parent[%d]: %s", n, (wattr.depth == rootdepth && wattr.class != InputOnly) ? "OK" : "FAIL"));
2016	if (wattr.depth != rootdepth || wattr.c_class == InputOnly) {	2102	if (wattr.depth != rootdepth || wattr.c_class == InputOnly)
		2103	{
2017	n = (int)(sizeof(TermWin.parent) / sizeof(Window)) + 1;	2104	n = (int)(sizeof(TermWin.parent) / sizeof(Window)) + 1;
2018	break;	2105	break;
2019	}	2106	}
2020	}	2107	}
2021	}	2108	}
2022	if (n > (int)(sizeof(TermWin.parent)	2109	if (n > (int)(sizeof(TermWin.parent)
2023	/ sizeof(TermWin.parent[0]))) {	2110	/ sizeof(TermWin.parent[0])))
		2111	{
2024	D_X((stderr, "InheritPixmap Turning off"));	2112	D_X((stderr, "InheritPixmap Turning off"));
2025	XSetWindowBackground(Xdisplay, TermWin.parent[0],	2113	XSetWindowBackground(Xdisplay, TermWin.parent[0],
2026	PixColors[Color_fg]);	2114	PixColors[Color_fg]);
2027	XSetWindowBackground(Xdisplay, TermWin.vt,	2115	XSetWindowBackground(Xdisplay, TermWin.vt,
2028	PixColors[Color_bg]);	2116	PixColors[Color_bg]);
2029	am_transparent = 0;	2117	am_transparent = 0;
2030	/* XXX: also turn off Opt_transparent? */	2118	/* XXX: also turn off Opt_transparent? */
2031	} else {	2119	}
		2120	else
		2121	{
2032	/* wait (an arbitrary period) for the WM to do its thing	2122	/* wait (an arbitrary period) for the WM to do its thing
2033	* needed for fvwm2.2.2 (and before?) */	2123	* needed for fvwm2.2.2 (and before?) */
2034	# ifdef HAVE_NANOSLEEP	2124	# ifdef HAVE_NANOSLEEP
2035	struct timespec rqt;	2125	struct timespec rqt;
2036		2126
2037	rqt.tv_sec = 1;	2127	rqt.tv_sec = 1;
2038	rqt.tv_nsec = 0;	2128	rqt.tv_nsec = 0;
2039	nanosleep(&rqt, NULL);	2129	nanosleep(&rqt, NULL);
2040	# else	2130	# else
2041	sleep(1);	2131	sleep(1);
2042	# endif	2132	# endif
2043	D_X((stderr, "InheritPixmap Turning on (%d parents)", i - 1));	2133	D_X((stderr, "InheritPixmap Turning on (%d parents)", i - 1));
2044	for (n = 0; n < (unsigned int)i; n++)	2134	for (n = 0; n < (unsigned int)i; n++)
2045	XSetWindowBackgroundPixmap(Xdisplay, TermWin.parent[n],	2135	XSetWindowBackgroundPixmap(Xdisplay, TermWin.parent[n],
2046	ParentRelative);	2136	ParentRelative);
2047	XSetWindowBackgroundPixmap(Xdisplay, TermWin.vt,	2137	XSetWindowBackgroundPixmap(Xdisplay, TermWin.vt,
2048	ParentRelative);	2138	ParentRelative);
2049	am_transparent = 1;	2139	am_transparent = 1;
2050	}	2140	}
2051	for (; i < (int)(sizeof(TermWin.parent) / sizeof(Window)); i++)	2141	for (; i < (int)(sizeof(TermWin.parent) / sizeof(Window)); i++)
2052	TermWin.parent[i] = None;	2142	TermWin.parent[i] = None;
2053	}	2143	}
2054	return pchanged;	2144	return pchanged;
2055	}	2145	}
2056	#endif	2146	#endif
2057		2147
2058	/*}}} */	2148	/*}}} */
2059		2149
…		…
2061	/*----------------------------------------------------------------------*/	2151	/*----------------------------------------------------------------------*/
2062	#ifdef PRINTPIPE	2152	#ifdef PRINTPIPE
2063	FILE *	2153	FILE *
2064	rxvt_term::popen_printer ()	2154	rxvt_term::popen_printer ()
2065	{	2155	{
2066	FILE *stream = popen(rs[Rs_print_pipe], "w");	2156	FILE *stream = popen(rs[Rs_print_pipe], "w");
2067		2157
2068	if (stream == NULL)	2158	if (stream == NULL)
2069	rxvt_print_error("can't open printer pipe");	2159	rxvt_print_error("can't open printer pipe");
2070	return stream;	2160	return stream;
2071	}	2161	}
2072		2162
2073	int	2163	int
2074	rxvt_term::pclose_printer (FILE *stream)	2164	rxvt_term::pclose_printer (FILE *stream)
2075	{	2165	{
2076	fflush (stream);	2166	fflush (stream);
2077	/* pclose() reported not to work on SunOS 4.1.3 */	2167	/* pclose() reported not to work on SunOS 4.1.3 */
2078	# if defined (__sun__) /* TODO: RESOLVE THIS */	2168	# if defined (__sun__) /* TODO: RESOLVE THIS */
2079	/* pclose works provided SIGCHLD handler uses waitpid */	2169	/* pclose works provided SIGCHLD handler uses waitpid */
2080	return pclose (stream); /* return fclose (stream); */	2170	return pclose (stream); /* return fclose (stream); */
2081	# else	2171	# else
2082	return pclose (stream);	2172	return pclose (stream);
2083	# endif	2173	# endif
2084	}	2174	}
…		…
2087	* simulate attached vt100 printer	2177	* simulate attached vt100 printer
2088	*/	2178	*/
2089	void	2179	void
2090	rxvt_term::process_print_pipe ()	2180	rxvt_term::process_print_pipe ()
2091	{	2181	{
2092	int done;	2182	int done;
2093	FILE *fd;	2183	FILE *fd;
2094		2184
2095	if ((fd = popen_printer ()) == NULL)	2185	if ((fd = popen_printer ()) == NULL)
2096	return;	2186	return;
2097		2187
2098	/*	2188	/*
2099	* Send all input to the printer until either ESC[4i or ESC[?4i	2189	* Send all input to the printer until either ESC[4i or ESC[?4i
2100	* is received.	2190	* is received.
2101	*/	2191	*/
2102	for (done = 0; !done;) {	2192	for (done = 0; !done;)
		2193	{
2103	unsigned char buf[8];	2194	unsigned char buf[8];
2104	unsigned char ch;	2195	unsigned char ch;
2105	unsigned int i, len;	2196	unsigned int i, len;
2106		2197
2107	if ((ch = cmd_getc ()) != C0_ESC) {	2198	if ((ch = cmd_getc ()) != C0_ESC)
		2199	{
2108	if (putc(ch, fd) == EOF)	2200	if (putc(ch, fd) == EOF)
2109	break; /* done = 1 */	2201	break; /* done = 1 */
2110	} else {	2202	}
		2203	else
		2204	{
2111	len = 0;	2205	len = 0;
2112	buf[len++] = ch;	2206	buf[len++] = ch;
2113		2207
2114	if ((buf[len++] = cmd_getc ()) == '[') {	2208	if ((buf[len++] = cmd_getc ()) == '[')
		2209	{
2115	if ((ch = cmd_getc ()) == '?') {	2210	if ((ch = cmd_getc ()) == '?')
2116	buf[len++] = '?';	2211	{
2117	ch = cmd_getc ();	2212	buf[len++] = '?';
2118	}	2213	ch = cmd_getc ();
		2214	}
2119	if ((buf[len++] = ch) == '4') {	2215	if ((buf[len++] = ch) == '4')
		2216	{
2120	if ((buf[len++] = cmd_getc ()) == 'i')	2217	if ((buf[len++] = cmd_getc ()) == 'i')
2121	break; /* done = 1 */	2218	break; /* done = 1 */
2122	}	2219	}
		2220	}
		2221	for (i = 0; i < len; i++)
		2222	if (putc(buf[i], fd) == EOF)
		2223	{
		2224	done = 1;
		2225	break;
		2226	}
		2227	}
2123	}	2228	}
2124	for (i = 0; i < len; i++)
2125	if (putc(buf[i], fd) == EOF) {
2126	done = 1;
2127	break;
2128	}
2129	}
2130	}
2131	pclose_printer (fd);	2229	pclose_printer (fd);
2132	}	2230	}
2133	#endif /* PRINTPIPE */	2231	#endif /* PRINTPIPE */
2134	/*}}} */	2232	/*}}} */
2135		2233
2136	/* *INDENT-OFF* */	2234	/* *INDENT-OFF* */
2137	enum {	2235	enum {
2138	C1_40 = 0x40,	2236	C1_40 = 0x40,
2139	C1_41 , C1_BPH, C1_NBH, C1_44 , C1_NEL, C1_SSA, C1_ESA,	2237	C1_41 , C1_BPH, C1_NBH, C1_44 , C1_NEL, C1_SSA, C1_ESA,
2140	C1_HTS, C1_HTJ, C1_VTS, C1_PLD, C1_PLU, C1_RI , C1_SS2, C1_SS3,	2238	C1_HTS, C1_HTJ, C1_VTS, C1_PLD, C1_PLU, C1_RI , C1_SS2, C1_SS3,
2141	C1_DCS, C1_PU1, C1_PU2, C1_STS, C1_CCH, C1_MW , C1_SPA, C1_EPA,	2239	C1_DCS, C1_PU1, C1_PU2, C1_STS, C1_CCH, C1_MW , C1_SPA, C1_EPA,
2142	C1_SOS, C1_59 , C1_SCI, C1_CSI, CS_ST , C1_OSC, C1_PM , C1_APC	2240	C1_SOS, C1_59 , C1_SCI, C1_CSI, CS_ST , C1_OSC, C1_PM , C1_APC
2143	};	2241	};
2144	/* *INDENT-ON* */	2242	/* *INDENT-ON* */
2145		2243
2146	/*{{{ process non-printing single characters */	2244	/*{{{ process non-printing single characters */
2147	void	2245	void
2148	rxvt_term::process_nonprinting (unsigned char ch)	2246	rxvt_term::process_nonprinting (unsigned char ch)
2149	{	2247	{
2150	switch (ch) {	2248	switch (ch)
		2249	{
2151	case C0_ENQ: /* terminal Status */	2250	case C0_ENQ: /* terminal Status */
2152	if (rs[Rs_answerbackstring])	2251	if (rs[Rs_answerbackstring])
2153	tt_write(	2252	tt_write(
2154	(const unsigned char *)rs[Rs_answerbackstring],	2253	(const unsigned char *)rs[Rs_answerbackstring],
2155	(unsigned int)STRLEN(rs[Rs_answerbackstring]));	2254	(unsigned int)STRLEN(rs[Rs_answerbackstring]));
2156	else	2255	else
2157	tt_write((unsigned char *)VT100_ANS,	2256	tt_write((unsigned char *)VT100_ANS,
2158	(unsigned int)STRLEN(VT100_ANS));	2257	(unsigned int)STRLEN(VT100_ANS));
2159	break;	2258	break;
2160	case C0_BEL: /* bell */	2259	case C0_BEL: /* bell */
2161	scr_bell ();	2260	scr_bell ();
2162	break;	2261	break;
2163	case C0_BS: /* backspace */	2262	case C0_BS: /* backspace */
2164	scr_backspace ();	2263	scr_backspace ();
2165	break;	2264	break;
2166	case C0_HT: /* tab */	2265	case C0_HT: /* tab */
2167	scr_tab (1);	2266	scr_tab (1);
2168	break;	2267	break;
2169	case C0_CR: /* carriage return */	2268	case C0_CR: /* carriage return */
2170	scr_gotorc (0, 0, R_RELATIVE);	2269	scr_gotorc (0, 0, R_RELATIVE);
2171	break;	2270	break;
2172	case C0_VT: /* vertical tab, form feed */	2271	case C0_VT: /* vertical tab, form feed */
2173	case C0_FF:	2272	case C0_FF:
2174	case C0_LF: /* line feed */	2273	case C0_LF: /* line feed */
2175	scr_index (UP);	2274	scr_index (UP);
2176	break;	2275	break;
2177	case C0_SO: /* shift out - acs */	2276	case C0_SO: /* shift out - acs */
2178	scr_charset_choose (1);	2277	scr_charset_choose (1);
2179	break;	2278	break;
2180	case C0_SI: /* shift in - acs */	2279	case C0_SI: /* shift in - acs */
2181	scr_charset_choose (0);	2280	scr_charset_choose (0);
2182	break;	2281	break;
2183	}	2282	}
2184	}	2283	}
2185	/*}}} */	2284	/*}}} */
2186		2285
2187		2286
2188	/*{{{ process VT52 escape sequences */	2287	/*{{{ process VT52 escape sequences */
2189	void	2288	void
2190	rxvt_term::process_escape_vt52 (unsigned char ch)	2289	rxvt_term::process_escape_vt52 (unsigned char ch)
2191	{	2290	{
2192	int row, col;	2291	int row, col;
		2292
		2293	switch (ch)
2193		2294	{
2194	switch (ch) {
2195	case 'A': /* cursor up */	2295	case 'A': /* cursor up */
2196	scr_gotorc (-1, 0, R_RELATIVE | C_RELATIVE);	2296	scr_gotorc (-1, 0, R_RELATIVE | C_RELATIVE);
2197	break;	2297	break;
2198	case 'B': /* cursor down */	2298	case 'B': /* cursor down */
2199	scr_gotorc (1, 0, R_RELATIVE | C_RELATIVE);	2299	scr_gotorc (1, 0, R_RELATIVE | C_RELATIVE);
2200	break;	2300	break;
2201	case 'C': /* cursor right */	2301	case 'C': /* cursor right */
2202	scr_gotorc (0, 1, R_RELATIVE | C_RELATIVE);	2302	scr_gotorc (0, 1, R_RELATIVE | C_RELATIVE);
2203	break;	2303	break;
2204	case 'D': /* cursor left */	2304	case 'D': /* cursor left */
2205	scr_gotorc (0, -1, R_RELATIVE | C_RELATIVE);	2305	scr_gotorc (0, -1, R_RELATIVE | C_RELATIVE);
2206	break;	2306	break;
2207	case 'H': /* cursor home */	2307	case 'H': /* cursor home */
2208	scr_gotorc (0, 0, 0);	2308	scr_gotorc (0, 0, 0);
2209	break;	2309	break;
2210	case 'I': /* cursor up and scroll down if needed */	2310	case 'I': /* cursor up and scroll down if needed */
2211	scr_index (DN);	2311	scr_index (DN);
2212	break;	2312	break;
2213	case 'J': /* erase to end of screen */	2313	case 'J': /* erase to end of screen */
2214	scr_erase_screen (0);	2314	scr_erase_screen (0);
2215	break;	2315	break;
2216	case 'K': /* erase to end of line */	2316	case 'K': /* erase to end of line */
2217	scr_erase_line (0);	2317	scr_erase_line (0);
2218	break;	2318	break;
2219	case 'Y': /* move to specified row and col */	2319	case 'Y': /* move to specified row and col */
2220	/* full command is 'ESC Y row col' where row and col	2320	/* full command is 'ESC Y row col' where row and col
2221	* are encoded by adding 32 and sending the ascii	2321	* are encoded by adding 32 and sending the ascii
2222	* character. eg. SPACE = 0, '+' = 13, '0' = 18,	2322	* character. eg. SPACE = 0, '+' = 13, '0' = 18,
2223	* etc. */	2323	* etc. */
2224	row = cmd_getc () - ' ';	2324	row = cmd_getc () - ' ';
2225	col = cmd_getc () - ' ';	2325	col = cmd_getc () - ' ';
2226	scr_gotorc (row, col, 0);	2326	scr_gotorc (row, col, 0);
2227	break;	2327	break;
2228	case 'Z': /* identify the terminal type */	2328	case 'Z': /* identify the terminal type */
2229	tt_printf("\033/Z"); /* I am a VT100 emulating a VT52 */	2329	tt_printf("\033/Z"); /* I am a VT100 emulating a VT52 */
2230	break;	2330	break;
2231	case '<': /* turn off VT52 mode */	2331	case '<': /* turn off VT52 mode */
2232	PrivMode(0, PrivMode_vt52);	2332	PrivMode(0, PrivMode_vt52);
2233	break;	2333	break;
2234	case 'F': /* use special graphics character set */	2334	case 'F': /* use special graphics character set */
2235	case 'G': /* use regular character set */	2335	case 'G': /* use regular character set */
2236	/* unimplemented */	2336	/* unimplemented */
2237	break;	2337	break;
2238	case '=': /* use alternate keypad mode */	2338	case '=': /* use alternate keypad mode */
2239	case '>': /* use regular keypad mode */	2339	case '>': /* use regular keypad mode */
2240	/* unimplemented */	2340	/* unimplemented */
2241	break;	2341	break;
2242	}	2342	}
2243	}	2343	}
2244	/*}}} */	2344	/*}}} */
2245		2345
2246		2346
2247	/*{{{ process escape sequences */	2347	/*{{{ process escape sequences */
2248	void	2348	void
2249	rxvt_term::process_escape_seq ()	2349	rxvt_term::process_escape_seq ()
2250	{	2350	{
2251	unsigned char ch = cmd_getc ();	2351	unsigned char ch = cmd_getc ();
2252		2352
2253	if (PrivateModes & PrivMode_vt52) {	2353	if (PrivateModes & PrivMode_vt52)
2254	process_escape_vt52 (ch);
2255	return;
2256	}
2257		2354	{
		2355	process_escape_vt52 (ch);
		2356	return;
		2357	}
		2358
2258	switch (ch) {	2359	switch (ch)
		2360	{
2259	/* case 1: do_tek_mode (); break; */	2361	/* case 1: do_tek_mode (); break; */
2260	case '#':	2362	case '#':
2261	if (cmd_getc () == '8')	2363	if (cmd_getc () == '8')
2262	scr_E ();	2364	scr_E ();
2263	break;	2365	break;
2264	case '(':	2366	case '(':
2265	scr_charset_set (0, (unsigned int)cmd_getc ());	2367	scr_charset_set (0, (unsigned int)cmd_getc ());
2266	break;	2368	break;
2267	case ')':	2369	case ')':
2268	scr_charset_set (1, (unsigned int)cmd_getc ());	2370	scr_charset_set (1, (unsigned int)cmd_getc ());
2269	break;	2371	break;
2270	case '*':	2372	case '*':
2271	scr_charset_set (2, (unsigned int)cmd_getc ());	2373	scr_charset_set (2, (unsigned int)cmd_getc ());
2272	break;	2374	break;
2273	case '+':	2375	case '+':
2274	scr_charset_set (3, (unsigned int)cmd_getc ());	2376	scr_charset_set (3, (unsigned int)cmd_getc ());
2275	break;	2377	break;
2276	#ifdef MULTICHAR_SET	2378	#ifdef MULTICHAR_SET
2277	case '$':	2379	case '$':
2278	scr_charset_set (-2, (unsigned int)cmd_getc ());	2380	scr_charset_set (-2, (unsigned int)cmd_getc ());
2279	break;	2381	break;
2280	#endif	2382	#endif
2281	#ifndef NO_FRILLS	2383	#ifndef NO_FRILLS
2282	case '6':	2384	case '6':
2283	scr_backindex ();	2385	scr_backindex ();
2284	break;	2386	break;
2285	#endif	2387	#endif
2286	case '7':	2388	case '7':
2287	scr_cursor (SAVE);	2389	scr_cursor (SAVE);
2288	break;	2390	break;
2289	case '8':	2391	case '8':
2290	scr_cursor (RESTORE);	2392	scr_cursor (RESTORE);
2291	break;	2393	break;
2292	#ifndef NO_FRILLS	2394	#ifndef NO_FRILLS
2293	case '9':	2395	case '9':
2294	scr_forwardindex ();	2396	scr_forwardindex ();
2295	break;	2397	break;
2296	#endif	2398	#endif
2297	case '=':	2399	case '=':
2298	case '>':	2400	case '>':
2299	PrivMode((ch == '='), PrivMode_aplKP);	2401	PrivMode((ch == '='), PrivMode_aplKP);
2300	break;	2402	break;
2301		2403
2302	case C1_40:	2404	case C1_40:
2303	cmd_getc ();	2405	cmd_getc ();
2304	break;	2406	break;
2305	case C1_44:	2407	case C1_44:
2306	scr_index (UP);	2408	scr_index (UP);
2307	break;	2409	break;
2308		2410
2309	/* 8.3.87: NEXT LINE */	2411	/* 8.3.87: NEXT LINE */
2310	case C1_NEL: /* ESC E */	2412	case C1_NEL: /* ESC E */
2311	{	2413	{
2312	uint32_t nlcr[] = { '\n', '\r' };	2414	uint32_t nlcr[] = { '\n', '\r' };
2313	scr_add_lines (nlcr, 1, 2);	2415	scr_add_lines (nlcr, 1, 2);
2314	}	2416	}
2315	break;	2417	break;
2316		2418
2317	/* kidnapped escape sequence: Should be 8.3.48 */	2419	/* kidnapped escape sequence: Should be 8.3.48 */
2318	case C1_ESA: /* ESC G */	2420	case C1_ESA: /* ESC G */
2319	process_graphics ();	2421	process_graphics ();
2320	break;	2422	break;
2321		2423
2322	/* 8.3.63: CHARACTER TABULATION SET */	2424	/* 8.3.63: CHARACTER TABULATION SET */
2323	case C1_HTS: /* ESC H */	2425	case C1_HTS: /* ESC H */
2324	scr_set_tab (1);	2426	scr_set_tab (1);
2325	break;	2427	break;
2326		2428
2327	/* 8.3.105: REVERSE LINE FEED */	2429	/* 8.3.105: REVERSE LINE FEED */
2328	case C1_RI: /* ESC M */	2430	case C1_RI: /* ESC M */
2329	scr_index (DN);	2431	scr_index (DN);
2330	break;	2432	break;
2331		2433
2332	/* 8.3.142: SINGLE-SHIFT TWO */	2434	/* 8.3.142: SINGLE-SHIFT TWO */
2333	/*case C1_SS2: scr_single_shift (2); break; */	2435	/*case C1_SS2: scr_single_shift (2); break; */
2334		2436
2335	/* 8.3.143: SINGLE-SHIFT THREE */	2437	/* 8.3.143: SINGLE-SHIFT THREE */
2336	/*case C1_SS3: scr_single_shift (3); break; */	2438	/*case C1_SS3: scr_single_shift (3); break; */
2337		2439
2338	/* 8.3.27: DEVICE CONTROL STRING */	2440	/* 8.3.27: DEVICE CONTROL STRING */
2339	case C1_DCS: /* ESC P */	2441	case C1_DCS: /* ESC P */
2340	process_dcs_seq ();	2442	process_dcs_seq ();
2341	break;	2443	break;
2342		2444
2343	/* 8.3.110: SINGLE CHARACTER INTRODUCER */	2445	/* 8.3.110: SINGLE CHARACTER INTRODUCER */
2344	case C1_SCI: /* ESC Z */	2446	case C1_SCI: /* ESC Z */
2345	tt_write((const unsigned char *)ESCZ_ANSWER,	2447	tt_write((const unsigned char *)ESCZ_ANSWER,
2346	(unsigned int)(sizeof(ESCZ_ANSWER) - 1));	2448	(unsigned int)(sizeof(ESCZ_ANSWER) - 1));
2347	break; /* steal obsolete ESC [ c */	2449	break; /* steal obsolete ESC [ c */
2348		2450
2349	/* 8.3.16: CONTROL SEQUENCE INTRODUCER */	2451	/* 8.3.16: CONTROL SEQUENCE INTRODUCER */
2350	case C1_CSI: /* ESC [ */	2452	case C1_CSI: /* ESC [ */
2351	process_csi_seq ();	2453	process_csi_seq ();
2352	break;	2454	break;
2353		2455
2354	/* 8.3.90: OPERATING SYSTEM COMMAND */	2456	/* 8.3.90: OPERATING SYSTEM COMMAND */
2355	case C1_OSC: /* ESC ] */	2457	case C1_OSC: /* ESC ] */
2356	process_osc_seq ();	2458	process_osc_seq ();
2357	break;	2459	break;
2358		2460
2359	/* 8.3.106: RESET TO INITIAL STATE */	2461	/* 8.3.106: RESET TO INITIAL STATE */
2360	case 'c':	2462	case 'c':
2361	scr_poweron ();	2463	scr_poweron ();
2362	scrollbar_show (1);	2464	scrollbar_show (1);
2363	break;	2465	break;
2364		2466
2365	/* 8.3.79: LOCKING-SHIFT TWO (see ISO2022) */	2467	/* 8.3.79: LOCKING-SHIFT TWO (see ISO2022) */
2366	case 'n':	2468	case 'n':
2367	scr_charset_choose (2);	2469	scr_charset_choose (2);
2368	break;	2470	break;
2369		2471
2370	/* 8.3.81: LOCKING-SHIFT THREE (see ISO2022) */	2472	/* 8.3.81: LOCKING-SHIFT THREE (see ISO2022) */
2371	case 'o':	2473	case 'o':
2372	scr_charset_choose (3);	2474	scr_charset_choose (3);
2373	break;	2475	break;
2374	}	2476	}
2375	}	2477	}
2376	/*}}} */	2478	/*}}} */
2377		2479
2378	/*{{{ process CONTROL SEQUENCE INTRODUCER (CSI) sequences `ESC[' */	2480	/*{{{ process CONTROL SEQUENCE INTRODUCER (CSI) sequences `ESC[' */
2379	/* *INDENT-OFF* */	2481	/* *INDENT-OFF* */
2380	enum {	2482	enum {
2381	CSI_ICH = 0x40,	2483	CSI_ICH = 0x40,
2382	CSI_CUU, CSI_CUD, CSI_CUF, CSI_CUB, CSI_CNL, CSI_CPL, CSI_CHA,	2484	CSI_CUU, CSI_CUD, CSI_CUF, CSI_CUB, CSI_CNL, CSI_CPL, CSI_CHA,
2383	CSI_CUP, CSI_CHT, CSI_ED , CSI_EL , CSI_IL , CSI_DL , CSI_EF , CSI_EA ,	2485	CSI_CUP, CSI_CHT, CSI_ED , CSI_EL , CSI_IL , CSI_DL , CSI_EF , CSI_EA ,
2384	CSI_DCH, CSI_SEE, CSI_CPR, CSI_SU , CSI_SD , CSI_NP , CSI_PP , CSI_CTC,	2486	CSI_DCH, CSI_SEE, CSI_CPR, CSI_SU , CSI_SD , CSI_NP , CSI_PP , CSI_CTC,
2385	CSI_ECH, CSI_CVT, CSI_CBT, CSI_SRS, CSI_PTX, CSI_SDS, CSI_SIMD, CSI_5F,	2487	CSI_ECH, CSI_CVT, CSI_CBT, CSI_SRS, CSI_PTX, CSI_SDS, CSI_SIMD, CSI_5F,
2386	CSI_HPA, CSI_HPR, CSI_REP, CSI_DA , CSI_VPA, CSI_VPR, CSI_HVP, CSI_TBC,	2488	CSI_HPA, CSI_HPR, CSI_REP, CSI_DA , CSI_VPA, CSI_VPR, CSI_HVP, CSI_TBC,
2387	CSI_SM , CSI_MC , CSI_HPB, CSI_VPB, CSI_RM , CSI_SGR, CSI_DSR, CSI_DAQ,	2489	CSI_SM , CSI_MC , CSI_HPB, CSI_VPB, CSI_RM , CSI_SGR, CSI_DSR, CSI_DAQ,
2388	CSI_70 , CSI_71 , CSI_72 , CSI_73 , CSI_74 , CSI_75 , CSI_76 , CSI_77 ,	2490	CSI_70 , CSI_71 , CSI_72 , CSI_73 , CSI_74 , CSI_75 , CSI_76 , CSI_77 ,
2389	CSI_78 , CSI_79 , CSI_7A , CSI_7B , CSI_7C , CSI_7D , CSI_7E , CSI_7F	2491	CSI_78 , CSI_79 , CSI_7A , CSI_7B , CSI_7C , CSI_7D , CSI_7E , CSI_7F
2390	};	2492	};
2391		2493
2392	#define make_byte(b7,b6,b5,b4,b3,b2,b1,b0) \	2494	#define make_byte(b7,b6,b5,b4,b3,b2,b1,b0) \
2393	(((b7) << 7) | ((b6) << 6) | ((b5) << 5) | ((b4) << 4) \	2495	(((b7) << 7) | ((b6) << 6) | ((b5) << 5) | ((b4) << 4) \
2394	| ((b3) << 3) | ((b2) << 2) | ((b1) << 1) | (b0))	2496	| ((b3) << 3) | ((b2) << 2) | ((b1) << 1) | (b0))
2395	#define get_byte_array_bit(array, bit) \	2497	#define get_byte_array_bit(array, bit) \
2396	(!!((array)[(bit) / 8] & (128 >> ((bit) & 7))))	2498	(!!((array)[(bit) / 8] & (128 >> ((bit) & 7))))
2397		2499
2398	const unsigned char csi_defaults[] = {	2500	const unsigned char csi_defaults[] =
		2501	{
2399	make_byte(1,1,1,1,1,1,1,1), /* @, A, B, C, D, E, F, G, */	2502	make_byte(1,1,1,1,1,1,1,1), /* @, A, B, C, D, E, F, G, */
2400	make_byte(1,1,0,0,1,1,0,0), /* H, I, J, K, L, M, N, O, */	2503	make_byte(1,1,0,0,1,1,0,0), /* H, I, J, K, L, M, N, O, */
2401	make_byte(1,0,1,1,1,1,1,0), /* P, Q, R, S, T, U, V, W, */	2504	make_byte(1,0,1,1,1,1,1,0), /* P, Q, R, S, T, U, V, W, */
2402	make_byte(1,1,1,0,0,0,1,0), /* X, Y, Z, [, \, ], ^, _, */	2505	make_byte(1,1,1,0,0,0,1,0), /* X, Y, Z, [, \, ], ^, _, */
2403	make_byte(1,1,1,0,1,1,1,0), /* `, a, b, c, d, e, f, g, */	2506	make_byte(1,1,1,0,1,1,1,0), /* `, a, b, c, d, e, f, g, */
2404	make_byte(0,0,1,1,0,0,0,0), /* h, i, j, k, l, m, n, o, */	2507	make_byte(0,0,1,1,0,0,0,0), /* h, i, j, k, l, m, n, o, */
2405	make_byte(0,0,0,0,0,0,0,0), /* p, q, r, s, t, u, v, w, */	2508	make_byte(0,0,0,0,0,0,0,0), /* p, q, r, s, t, u, v, w, */
2406	make_byte(0,0,0,0,0,0,0,0) /* x, y, z, {, |, }, ~, */	2509	make_byte(0,0,0,0,0,0,0,0) /* x, y, z, {, |, }, ~, */
2407	};	2510	};
2408	/* *INDENT-ON* */	2511	/* *INDENT-ON* */
2409		2512
2410	void	2513	void
2411	rxvt_term::process_csi_seq ()	2514	rxvt_term::process_csi_seq ()
2412	{	2515	{
2413	unsigned char ch, priv, i;	2516	unsigned char ch, priv, i;
2414	unsigned int nargs, p;	2517	unsigned int nargs, p;
2415	int n, ndef;	2518	int n, ndef;
2416	int arg[ESC_ARGS];	2519	int arg[ESC_ARGS];
2417		2520
2418	for (nargs = ESC_ARGS; nargs > 0;)	2521	for (nargs = ESC_ARGS; nargs > 0;)
2419	arg[--nargs] = 0;	2522	arg[--nargs] = 0;
2420		2523
2421	priv = 0;	2524	priv = 0;
		2525	ch = cmd_getc ();
		2526	if (ch >= '<' && ch <= '?')
		2527	{ /* '<' '=' '>' '?' */
		2528	priv = ch;
2422	ch = cmd_getc ();	2529	ch = cmd_getc ();
2423	if (ch >= '<' && ch <= '?') { /* '<' '=' '>' '?' */
2424	priv = ch;
2425	ch = cmd_getc ();
2426	}	2530	}
2427	/* read any numerical arguments */	2531	/* read any numerical arguments */
2428	for (n = -1; ch < CSI_ICH; ) {	2532	for (n = -1; ch < CSI_ICH; )
		2533	{
2429	if (isdigit(ch)) {	2534	if (isdigit(ch))
		2535	{
2430	if (n < 0)	2536	if (n < 0)
2431	n = ch - '0';	2537	n = ch - '0';
2432	else	2538	else
2433	n = n * 10 + ch - '0';	2539	n = n * 10 + ch - '0';
		2540	}
2434	} else if (ch == ';') {	2541	else if (ch == ';')
		2542	{
2435	if (nargs < ESC_ARGS)	2543	if (nargs < ESC_ARGS)
2436	arg[nargs++] = n;	2544	arg[nargs++] = n;
2437	n = -1;	2545	n = -1;
		2546	}
2438	} else if (ch == '\b') {	2547	else if (ch == '\b')
		2548	{
2439	scr_backspace ();	2549	scr_backspace ();
		2550	}
2440	} else if (ch == C0_ESC) {	2551	else if (ch == C0_ESC)
		2552	{
2441	process_escape_seq ();	2553	process_escape_seq ();
		2554	return;
		2555	}
		2556	else if (ch < ' ')
		2557	{
		2558	process_nonprinting (ch);
		2559	}
		2560	ch = cmd_getc ();
		2561	}
		2562
		2563	if (ch > CSI_7F)
2442	return;	2564	return;
2443	} else if (ch < ' ') {
2444	process_nonprinting (ch);
2445	}
2446	ch = cmd_getc ();
2447	}
2448		2565
2449	if (ch > CSI_7F)
2450	return;
2451
2452	if (nargs < ESC_ARGS)	2566	if (nargs < ESC_ARGS)
2453	arg[nargs++] = n;	2567	arg[nargs++] = n;
2454		2568
2455	i = ch - CSI_ICH;	2569	i = ch - CSI_ICH;
2456	ndef = get_byte_array_bit(csi_defaults, i);	2570	ndef = get_byte_array_bit(csi_defaults, i);
2457	for (p = 0; p < nargs; p++)	2571	for (p = 0; p < nargs; p++)
2458	if (arg[p] == -1)	2572	if (arg[p] == -1)
2459	arg[p] = ndef;	2573	arg[p] = ndef;
2460		2574
2461	#ifdef DEBUG_CMD	2575	#ifdef DEBUG_CMD
2462	fprintf(stderr, "CSI ");	2576	fprintf(stderr, "CSI ");
2463	for (p = 0; p < nargs; p++)	2577	for (p = 0; p < nargs; p++)
2464	fprintf(stderr, "%d%s", arg[p], p < nargs - 1 ? ";" : "");	2578	fprintf(stderr, "%d%s", arg[p], p < nargs - 1 ? ";" : "");
2465	fprintf(stderr, "%c\n", ch);	2579	fprintf(stderr, "%c\n", ch);
2466	#endif	2580	#endif
2467		2581
2468	/*	2582	/*
2469	* private mode handling	2583	* private mode handling
2470	*/	2584	*/
2471	if (priv) {	2585	if (priv)
2472	switch (priv) {	2586	{
2473	case '>':	2587	switch (priv)
		2588	{
		2589	case '>':
2474	if (ch == CSI_DA) /* secondary device attributes */	2590	if (ch == CSI_DA) /* secondary device attributes */
2475	tt_printf("\033[>%d;%-.8s;0c", 'R', VSTRING);	2591	tt_printf("\033[>%d;%-.8s;0c", 'R', VSTRING);
2476	break;	2592	break;
2477	case '?':	2593	case '?':
2478	if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')	2594	if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')
2479	process_terminal_mode (ch, priv, nargs, arg);	2595	process_terminal_mode (ch, priv, nargs, arg);
2480	break;	2596	break;
2481	}	2597	}
2482	return;	2598	return;
2483	}	2599	}
2484		2600
2485	switch (ch) {	2601	switch (ch)
2486	/*	2602	{
		2603	/*
2487	* ISO/IEC 6429:1992(E) CSI sequences (defaults in parentheses)	2604	* ISO/IEC 6429:1992(E) CSI sequences (defaults in parentheses)
2488	*/	2605	*/
2489	#ifdef PRINTPIPE	2606	#ifdef PRINTPIPE
2490	case CSI_MC: /* 8.3.83: (0) MEDIA COPY */	2607	case CSI_MC: /* 8.3.83: (0) MEDIA COPY */
2491	switch (arg[0]) {	2608	switch (arg[0])
		2609	{
2492	case 0: /* initiate transfer to primary aux device */	2610	case 0: /* initiate transfer to primary aux device */
2493	scr_printscreen (0);	2611	scr_printscreen (0);
2494	break;	2612	break;
2495	case 5: /* start relay to primary aux device */	2613	case 5: /* start relay to primary aux device */
2496	process_print_pipe ();	2614	process_print_pipe ();
		2615	break;
		2616	}
2497	break;	2617	break;
2498	}
2499	break;
2500	#endif	2618	#endif
2501		2619
2502	case CSI_CUU: /* 8.3.22: (1) CURSOR UP */	2620	case CSI_CUU: /* 8.3.22: (1) CURSOR UP */
2503	case CSI_VPR: /* 8.3.161: (1) LINE POSITION FORWARD */	2621	case CSI_VPR: /* 8.3.161: (1) LINE POSITION FORWARD */
2504	arg[0] = -arg[0];	2622	arg[0] = -arg[0];
2505	/* FALLTHROUGH */	2623	/* FALLTHROUGH */
2506	case CSI_CUD: /* 8.3.19: (1) CURSOR DOWN */	2624	case CSI_CUD: /* 8.3.19: (1) CURSOR DOWN */
2507	case CSI_VPB: /* 8.3.160: (1) LINE POSITION BACKWARD */	2625	case CSI_VPB: /* 8.3.160: (1) LINE POSITION BACKWARD */
2508	scr_gotorc (arg[0], 0, RELATIVE);	2626	scr_gotorc (arg[0], 0, RELATIVE);
2509	break;	2627	break;
2510		2628
2511	case CSI_CUB: /* 8.3.18: (1) CURSOR LEFT */	2629	case CSI_CUB: /* 8.3.18: (1) CURSOR LEFT */
2512	case CSI_HPB: /* 8.3.59: (1) CHARACTER POSITION BACKWARD */	2630	case CSI_HPB: /* 8.3.59: (1) CHARACTER POSITION BACKWARD */
2513	#ifdef ISO6429	2631	#ifdef ISO6429
2514	arg[0] = -arg[0];	2632	arg[0] = -arg[0];
2515	#else /* emulate common DEC VTs */	2633	#else /* emulate common DEC VTs */
2516	arg[0] = arg[0] ? -arg[0] : -1;	2634	arg[0] = arg[0] ? -arg[0] : -1;
2517	#endif	2635	#endif
2518	/* FALLTHROUGH */	2636	/* FALLTHROUGH */
2519	case CSI_CUF: /* 8.3.20: (1) CURSOR RIGHT */	2637	case CSI_CUF: /* 8.3.20: (1) CURSOR RIGHT */
2520	case CSI_HPR: /* 8.3.60: (1) CHARACTER POSITION FORWARD */	2638	case CSI_HPR: /* 8.3.60: (1) CHARACTER POSITION FORWARD */
2521	#ifdef ISO6429	2639	#ifdef ISO6429
2522	scr_gotorc (0, arg[0], RELATIVE);	2640	scr_gotorc (0, arg[0], RELATIVE);
2523	#else /* emulate common DEC VTs */	2641	#else /* emulate common DEC VTs */
2524	scr_gotorc (0, arg[0] ? arg[0] : 1, RELATIVE);	2642	scr_gotorc (0, arg[0] ? arg[0] : 1, RELATIVE);
2525	#endif	2643	#endif
2526	break;	2644	break;
2527		2645
2528	case CSI_CPL: /* 8.3.13: (1) CURSOR PRECEDING LINE */	2646	case CSI_CPL: /* 8.3.13: (1) CURSOR PRECEDING LINE */
2529	arg[0] = -arg[0];	2647	arg[0] = -arg[0];
2530	/* FALLTHROUGH */	2648	/* FALLTHROUGH */
2531	case CSI_CNL: /* 8.3.12: (1) CURSOR NEXT LINE */	2649	case CSI_CNL: /* 8.3.12: (1) CURSOR NEXT LINE */
2532	scr_gotorc (arg[0], 0, R_RELATIVE);	2650	scr_gotorc (arg[0], 0, R_RELATIVE);
2533	break;	2651	break;
2534		2652
2535	case CSI_CHA: /* 8.3.9: (1) CURSOR CHARACTER ABSOLUTE */	2653	case CSI_CHA: /* 8.3.9: (1) CURSOR CHARACTER ABSOLUTE */
2536	case CSI_HPA: /* 8.3.58: (1) CURSOR POSITION ABSOLUTE */	2654	case CSI_HPA: /* 8.3.58: (1) CURSOR POSITION ABSOLUTE */
2537	scr_gotorc (0, arg[0] - 1, R_RELATIVE);	2655	scr_gotorc (0, arg[0] - 1, R_RELATIVE);
2538	break;	2656	break;
2539		2657
2540	case CSI_VPA: /* 8.3.159: (1) LINE POSITION ABSOLUTE */	2658	case CSI_VPA: /* 8.3.159: (1) LINE POSITION ABSOLUTE */
2541	scr_gotorc (arg[0] - 1, 0, C_RELATIVE);	2659	scr_gotorc (arg[0] - 1, 0, C_RELATIVE);
2542	break;	2660	break;
2543		2661
2544	case CSI_CUP: /* 8.3.21: (1,1) CURSOR POSITION */	2662	case CSI_CUP: /* 8.3.21: (1,1) CURSOR POSITION */
2545	case CSI_HVP: /* 8.3.64: (1,1) CHARACTER AND LINE POSITION */	2663	case CSI_HVP: /* 8.3.64: (1,1) CHARACTER AND LINE POSITION */
2546	scr_gotorc (arg[0] - 1, nargs < 2 ? 0 : (arg[1] - 1), 0);	2664	scr_gotorc (arg[0] - 1, nargs < 2 ? 0 : (arg[1] - 1), 0);
2547	break;	2665	break;
2548		2666
2549	case CSI_CBT: /* 8.3.7: (1) CURSOR BACKWARD TABULATION */	2667	case CSI_CBT: /* 8.3.7: (1) CURSOR BACKWARD TABULATION */
2550	arg[0] = -arg[0];	2668	arg[0] = -arg[0];
2551	/* FALLTHROUGH */	2669	/* FALLTHROUGH */
2552	case CSI_CHT: /* 8.3.10: (1) CURSOR FORWARD TABULATION */	2670	case CSI_CHT: /* 8.3.10: (1) CURSOR FORWARD TABULATION */
2553	scr_tab (arg[0]);	2671	scr_tab (arg[0]);
2554	break;	2672	break;
2555		2673
2556	case CSI_ED: /* 8.3.40: (0) ERASE IN PAGE */	2674	case CSI_ED: /* 8.3.40: (0) ERASE IN PAGE */
2557	scr_erase_screen (arg[0]);	2675	scr_erase_screen (arg[0]);
2558	break;	2676	break;
2559		2677
2560	case CSI_EL: /* 8.3.42: (0) ERASE IN LINE */	2678	case CSI_EL: /* 8.3.42: (0) ERASE IN LINE */
2561	scr_erase_line (arg[0]);	2679	scr_erase_line (arg[0]);
2562	break;	2680	break;
2563		2681
2564	case CSI_ICH: /* 8.3.65: (1) INSERT CHARACTER */	2682	case CSI_ICH: /* 8.3.65: (1) INSERT CHARACTER */
2565	scr_insdel_chars (arg[0], INSERT);	2683	scr_insdel_chars (arg[0], INSERT);
2566	break;	2684	break;
2567		2685
2568	case CSI_IL: /* 8.3.68: (1) INSERT LINE */	2686	case CSI_IL: /* 8.3.68: (1) INSERT LINE */
2569	scr_insdel_lines (arg[0], INSERT);	2687	scr_insdel_lines (arg[0], INSERT);
2570	break;	2688	break;
2571		2689
2572	case CSI_DL: /* 8.3.33: (1) DELETE LINE */	2690	case CSI_DL: /* 8.3.33: (1) DELETE LINE */
2573	scr_insdel_lines (arg[0], DELETE);	2691	scr_insdel_lines (arg[0], DELETE);
2574	break;	2692	break;
2575		2693
2576	case CSI_ECH: /* 8.3.39: (1) ERASE CHARACTER */	2694	case CSI_ECH: /* 8.3.39: (1) ERASE CHARACTER */
2577	scr_insdel_chars (arg[0], ERASE);	2695	scr_insdel_chars (arg[0], ERASE);
2578	break;	2696	break;
2579		2697
2580	case CSI_DCH: /* 8.3.26: (1) DELETE CHARACTER */	2698	case CSI_DCH: /* 8.3.26: (1) DELETE CHARACTER */
2581	scr_insdel_chars (arg[0], DELETE);	2699	scr_insdel_chars (arg[0], DELETE);
2582	break;	2700	break;
2583		2701
2584	case CSI_SD: /* 8.3.114: (1) SCROLL DOWN */	2702	case CSI_SD: /* 8.3.114: (1) SCROLL DOWN */
2585	arg[0] = -arg[0];	2703	arg[0] = -arg[0];
2586	/* FALLTHROUGH */	2704	/* FALLTHROUGH */
2587	case CSI_SU: /* 8.3.148: (1) SCROLL UP */	2705	case CSI_SU: /* 8.3.148: (1) SCROLL UP */
2588	scr_scroll_text (screen.tscroll, screen.bscroll, arg[0], 0);	2706	scr_scroll_text (screen.tscroll, screen.bscroll, arg[0], 0);
2589	break;	2707	break;
2590		2708
2591	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */	2709	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */
2592	tt_write((const unsigned char *)VT100_ANS,	2710	tt_write((const unsigned char *)VT100_ANS,
2593	(unsigned int)(sizeof(VT100_ANS) - 1));	2711	(unsigned int)(sizeof(VT100_ANS) - 1));
2594	break;	2712	break;
2595		2713
2596	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */	2714	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */
2597	process_sgr_mode (nargs, arg);	2715	process_sgr_mode (nargs, arg);
2598	break;	2716	break;
2599		2717
2600	case CSI_DSR: /* 8.3.36: (0) DEVICE STATUS REPORT */	2718	case CSI_DSR: /* 8.3.36: (0) DEVICE STATUS REPORT */
2601	switch (arg[0]) {	2719	switch (arg[0])
		2720	{
2602	case 5: /* DSR requested */	2721	case 5: /* DSR requested */
2603	tt_printf("\033[0n");	2722	tt_printf("\033[0n");
2604	break;	2723	break;
2605	case 6: /* CPR requested */	2724	case 6: /* CPR requested */
2606	scr_report_position ();	2725	scr_report_position ();
2607	break;	2726	break;
2608	#if defined (ENABLE_DISPLAY_ANSWER)	2727	#if defined (ENABLE_DISPLAY_ANSWER)
2609	case 7: /* unofficial extension */	2728	case 7: /* unofficial extension */
2610	tt_printf("%-.250s\n", rs[Rs_display_name]);	2729	tt_printf("%-.250s\n", rs[Rs_display_name]);
2611	break;	2730	break;
2612	#endif	2731	#endif
2613	case 8: /* unofficial extension */	2732	case 8: /* unofficial extension */
2614	xterm_seq (XTerm_title, APL_NAME "-" VERSION, CHAR_ST);	2733	xterm_seq (XTerm_title, APL_NAME "-" VERSION, CHAR_ST);
		2734	break;
		2735	}
2615	break;	2736	break;
2616	}
2617	break;
2618		2737
2619	case CSI_TBC: /* 8.3.155: (0) TABULATION CLEAR */	2738	case CSI_TBC: /* 8.3.155: (0) TABULATION CLEAR */
2620	switch (arg[0]) {	2739	switch (arg[0])
		2740	{
2621	case 0: /* char tab stop cleared at active position */	2741	case 0: /* char tab stop cleared at active position */
2622	scr_set_tab (0);	2742	scr_set_tab (0);
2623	break;	2743	break;
2624	/* case 1: */ /* line tab stop cleared in active line */	2744	/* case 1: */ /* line tab stop cleared in active line */
2625	/* case 2: */ /* char tab stops cleared in active line */	2745	/* case 2: */ /* char tab stops cleared in active line */
2626	case 3: /* all char tab stops are cleared */	2746	case 3: /* all char tab stops are cleared */
2627	/* case 4: */ /* all line tab stops are cleared */	2747	/* case 4: */ /* all line tab stops are cleared */
2628	case 5: /* all tab stops are cleared */	2748	case 5: /* all tab stops are cleared */
2629	scr_set_tab (-1);	2749	scr_set_tab (-1);
		2750	break;
		2751	}
2630	break;	2752	break;
2631	}
2632	break;
2633		2753
2634	case CSI_CTC: /* 8.3.17: (0) CURSOR TABULATION CONTROL */	2754	case CSI_CTC: /* 8.3.17: (0) CURSOR TABULATION CONTROL */
2635	switch (arg[0]) {	2755	switch (arg[0])
		2756	{
2636	case 0: /* char tab stop set at active position */	2757	case 0: /* char tab stop set at active position */
2637	scr_set_tab (1);	2758	scr_set_tab (1);
2638	break; /* = ESC H */	2759	break; /* = ESC H */
2639	/* case 1: */ /* line tab stop set at active line */	2760	/* case 1: */ /* line tab stop set at active line */
2640	case 2: /* char tab stop cleared at active position */	2761	case 2: /* char tab stop cleared at active position */
2641	scr_set_tab (0);	2762	scr_set_tab (0);
2642	break; /* = ESC [ 0 g */	2763	break; /* = ESC [ 0 g */
2643	/* case 3: */ /* line tab stop cleared at active line */	2764	/* case 3: */ /* line tab stop cleared at active line */
2644	/* case 4: */ /* char tab stops cleared at active line */	2765	/* case 4: */ /* char tab stops cleared at active line */
2645	case 5: /* all char tab stops are cleared */	2766	case 5: /* all char tab stops are cleared */
2646	scr_set_tab (-1);	2767	scr_set_tab (-1);
2647	break; /* = ESC [ 3 g */	2768	break; /* = ESC [ 3 g */
2648	/* case 6: */ /* all line tab stops are cleared */	2769	/* case 6: */ /* all line tab stops are cleared */
2649	}	2770	}
2650	break;	2771	break;
2651		2772
2652	case CSI_RM: /* 8.3.107: RESET MODE */	2773	case CSI_RM: /* 8.3.107: RESET MODE */
2653	if (arg[0] == 4)	2774	if (arg[0] == 4)
2654	scr_insert_mode (0);	2775	scr_insert_mode (0);
2655	break;	2776	break;
2656		2777
2657	case CSI_SM: /* 8.3.126: SET MODE */	2778	case CSI_SM: /* 8.3.126: SET MODE */
2658	if (arg[0] == 4)	2779	if (arg[0] == 4)
2659	scr_insert_mode (1);	2780	scr_insert_mode (1);
2660	break;	2781	break;
2661		2782
2662	/*	2783	/*
2663	* PRIVATE USE beyond this point. All CSI_7? sequences here	2784	* PRIVATE USE beyond this point. All CSI_7? sequences here
2664	*/	2785	*/
2665	case CSI_72: /* DECSTBM: set top and bottom margins */	2786	case CSI_72: /* DECSTBM: set top and bottom margins */
2666	if (nargs == 1)	2787	if (nargs == 1)
2667	scr_scroll_region (arg[0] - 1, MAX_ROWS - 1);	2788	scr_scroll_region (arg[0] - 1, MAX_ROWS - 1);
2668	else if (nargs == 0 || arg[0] >= arg[1])	2789	else if (nargs == 0 || arg[0] >= arg[1])
2669	scr_scroll_region (0, MAX_ROWS - 1);	2790	scr_scroll_region (0, MAX_ROWS - 1);
2670	else	2791	else
2671	scr_scroll_region (arg[0] - 1, arg[1] - 1);	2792	scr_scroll_region (arg[0] - 1, arg[1] - 1);
2672	break;	2793	break;
2673		2794
2674	case CSI_73:	2795	case CSI_73:
2675	scr_cursor (SAVE);	2796	scr_cursor (SAVE);
2676	break;	2797	break;
2677	case CSI_75:	2798	case CSI_75:
2678	scr_cursor (RESTORE);	2799	scr_cursor (RESTORE);
2679	break;	2800	break;
2680		2801
2681	#ifndef NO_FRILLS	2802	#ifndef NO_FRILLS
2682	case CSI_74:	2803	case CSI_74:
2683	process_window_ops (arg, nargs);	2804	process_window_ops (arg, nargs);
2684	break;	2805	break;
2685	#endif	2806	#endif
2686		2807
2687	case CSI_78: /* DECREQTPARM */	2808	case CSI_78: /* DECREQTPARM */
2688	if (arg[0] == 0 || arg[0] == 1)	2809	if (arg[0] == 0 || arg[0] == 1)
2689	tt_printf("\033[%d;1;1;128;128;1;0x", arg[0] + 2);	2810	tt_printf("\033[%d;1;1;128;128;1;0x", arg[0] + 2);
2690	/* FALLTHROUGH */	2811	/* FALLTHROUGH */
2691		2812
2692	default:	2813	default:
2693	break;	2814	break;
2694	}	2815	}
2695	}	2816	}
2696	/*}}} */	2817	/*}}} */
2697		2818
2698	#ifndef NO_FRILLS	2819	#ifndef NO_FRILLS
2699	/* ARGSUSED */	2820	/* ARGSUSED */
2700	void	2821	void
2701	rxvt_term::process_window_ops (const int *args, unsigned int nargs)	2822	rxvt_term::process_window_ops (const int *args, unsigned int nargs)
2702	{	2823	{
2703	int x, y;	2824	int x, y;
2704	#if 0	2825	#if 0
2705	char *s;	2826	char *s;
2706	#endif	2827	#endif
2707	XWindowAttributes wattr;	2828	XWindowAttributes wattr;
2708	Window wdummy;	2829	Window wdummy;
2709		2830
2710	if (nargs == 0)	2831	if (nargs == 0)
2711	return;	2832	return;
2712	switch (args[0]) {	2833	switch (args[0])
		2834	{
2713	/*	2835	/*
2714	* commands	2836	* commands
2715	*/	2837	*/
2716	case 1: /* deiconify window */	2838	case 1: /* deiconify window */
2717	XMapWindow(Xdisplay, TermWin.parent[0]);	2839	XMapWindow(Xdisplay, TermWin.parent[0]);
2718	break;	2840	break;
2719	case 2: /* iconify window */	2841	case 2: /* iconify window */
2720	XIconifyWindow(Xdisplay, TermWin.parent[0],	2842	XIconifyWindow(Xdisplay, TermWin.parent[0],
2721	DefaultScreen(Xdisplay));	2843	DefaultScreen(Xdisplay));
2722	break;	2844	break;
2723	case 3: /* set position (pixels) */	2845	case 3: /* set position (pixels) */
2724	XMoveWindow(Xdisplay, TermWin.parent[0], args[1], args[2]);	2846	XMoveWindow(Xdisplay, TermWin.parent[0], args[1], args[2]);
2725	break;	2847	break;
2726	case 4: /* set size (pixels) */	2848	case 4: /* set size (pixels) */
2727	set_widthheight ((unsigned int)args[2], (unsigned int)args[1]);	2849	set_widthheight ((unsigned int)args[2], (unsigned int)args[1]);
2728	break;	2850	break;
2729	case 5: /* raise window */	2851	case 5: /* raise window */
2730	XRaiseWindow(Xdisplay, TermWin.parent[0]);	2852	XRaiseWindow(Xdisplay, TermWin.parent[0]);
2731	break;	2853	break;
2732	case 6: /* lower window */	2854	case 6: /* lower window */
2733	XLowerWindow(Xdisplay, TermWin.parent[0]);	2855	XLowerWindow(Xdisplay, TermWin.parent[0]);
2734	break;	2856	break;
2735	case 7: /* refresh window */	2857	case 7: /* refresh window */
2736	scr_touch (true);	2858	scr_touch (true);
2737	break;	2859	break;
2738	case 8: /* set size (chars) */	2860	case 8: /* set size (chars) */
2739	set_widthheight ((unsigned int)(args[2] * TermWin.fwidth),	2861	set_widthheight ((unsigned int)(args[2] * TermWin.fwidth),
2740	(unsigned int)(args[1] * TermWin.fheight));	2862	(unsigned int)(args[1] * TermWin.fheight));
2741	break;	2863	break;
2742	default:	2864	default:
2743	if (args[0] >= 24) /* set height (chars) */	2865	if (args[0] >= 24) /* set height (chars) */
2744	set_widthheight ((unsigned int)TermWin.width,	2866	set_widthheight ((unsigned int)TermWin.width,
2745	(unsigned int)(args[1] * TermWin.fheight));	2867	(unsigned int)(args[1] * TermWin.fheight));
2746	break;	2868	break;
2747	/*	2869	/*
2748	* reports - some output format copied from XTerm	2870	* reports - some output format copied from XTerm
2749	*/	2871	*/
2750	case 11: /* report window state */	2872	case 11: /* report window state */
2751	XGetWindowAttributes(Xdisplay, TermWin.parent[0], &wattr);	2873	XGetWindowAttributes(Xdisplay, TermWin.parent[0], &wattr);
2752	tt_printf("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);	2874	tt_printf("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);
2753	break;	2875	break;
2754	case 13: /* report window position */	2876	case 13: /* report window position */
2755	XGetWindowAttributes(Xdisplay, TermWin.parent[0], &wattr);	2877	XGetWindowAttributes(Xdisplay, TermWin.parent[0], &wattr);
2756	XTranslateCoordinates(Xdisplay, TermWin.parent[0], wattr.root,	2878	XTranslateCoordinates(Xdisplay, TermWin.parent[0], wattr.root,
2757	-wattr.border_width, -wattr.border_width,	2879	-wattr.border_width, -wattr.border_width,
2758	&x, &y, &wdummy);	2880	&x, &y, &wdummy);
2759	tt_printf("\033[3;%d;%dt", x, y);	2881	tt_printf("\033[3;%d;%dt", x, y);
2760	break;	2882	break;
2761	case 14: /* report window size (pixels) */	2883	case 14: /* report window size (pixels) */
2762	XGetWindowAttributes(Xdisplay, TermWin.parent[0], &wattr);	2884	XGetWindowAttributes(Xdisplay, TermWin.parent[0], &wattr);
2763	tt_printf("\033[4;%d;%dt", wattr.height, wattr.width);	2885	tt_printf("\033[4;%d;%dt", wattr.height, wattr.width);
2764	break;	2886	break;
2765	case 18: /* report window size (chars) */	2887	case 18: /* report window size (chars) */
2766	tt_printf("\033[8;%d;%dt", TermWin.nrow, TermWin.ncol);	2888	tt_printf("\033[8;%d;%dt", TermWin.nrow, TermWin.ncol);
2767	break;	2889	break;
2768	#if 0 /* XXX: currently disabled due to security concerns */	2890	#if 0 /* XXX: currently disabled due to security concerns */
2769	case 20: /* report icon label */	2891	case 20: /* report icon label */
2770	XGetIconName(Xdisplay, TermWin.parent[0], &s);	2892	XGetIconName(Xdisplay, TermWin.parent[0], &s);
2771	tt_printf("\033]L%-.200s\234", s ? s : ""); /* 8bit ST */	2893	tt_printf("\033]L%-.200s\234", s ? s : ""); /* 8bit ST */
2772	break;	2894	break;
2773	case 21: /* report window title */	2895	case 21: /* report window title */
2774	XFetchName(Xdisplay, TermWin.parent[0], &s);	2896	XFetchName(Xdisplay, TermWin.parent[0], &s);
2775	tt_printf("\033]l%-.200s\234", s ? s : ""); /* 8bit ST */	2897	tt_printf("\033]l%-.200s\234", s ? s : ""); /* 8bit ST */
2776	break;	2898	break;
2777	#endif	2899	#endif
		2900
2778	}	2901	}
2779	}	2902	}
2780	#endif	2903	#endif
2781		2904
2782	/*----------------------------------------------------------------------*/	2905	/*----------------------------------------------------------------------*/
…		…
2785	* ends_how is terminator used. returned input must be free()d	2908	* ends_how is terminator used. returned input must be free()d
2786	*/	2909	*/
2787	unsigned char *	2910	unsigned char *
2788	rxvt_term::get_to_st (unsigned char *ends_how)	2911	rxvt_term::get_to_st (unsigned char *ends_how)
2789	{	2912	{
2790	int seen_esc = 0; /* seen escape? */	2913	int seen_esc = 0; /* seen escape? */
2791	unsigned int n = 0;	2914	unsigned int n = 0;
2792	unsigned char *s;	2915	unsigned char *s;
2793	unsigned char ch, string[STRING_MAX];	2916	unsigned char ch, string[STRING_MAX];
2794		2917
2795	for (; (ch = cmd_getc ());) {	2918	for (; (ch = cmd_getc ());)
		2919	{
2796	if (ch == C0_BEL	2920	if (ch == C0_BEL
2797	|| ch == CHAR_ST	2921	|| ch == CHAR_ST
2798	|| (ch == 0x5c && seen_esc)) /* 7bit ST */	2922	|| (ch == 0x5c && seen_esc)) /* 7bit ST */
2799	break;	2923	break;
2800	if (ch == C0_ESC) {	2924	if (ch == C0_ESC)
		2925	{
2801	seen_esc = 1;	2926	seen_esc = 1;
2802	continue;	2927	continue;
		2928	}
2803	} else if (ch == '\t')	2929	else if (ch == '\t')
2804	ch = ' '; /* translate '\t' to space */	2930	ch = ' '; /* translate '\t' to space */
2805	else if (ch < 0x08 || (ch > 0x0d && ch < 0x20))	2931	else if (ch < 0x08 || (ch > 0x0d && ch < 0x20))
2806	return NULL; /* other control character - exit */	2932	return NULL; /* other control character - exit */
2807	if (n < sizeof(string) - 1)	2933	if (n < sizeof(string) - 1)
2808	string[n++] = ch;	2934	string[n++] = ch;
2809	seen_esc = 0;	2935	seen_esc = 0;
2810	}	2936	}
2811	string[n++] = '\0';	2937	string[n++] = '\0';
2812	if ((s = (unsigned char *)rxvt_malloc(n)) == NULL)	2938	if ((s = (unsigned char *)rxvt_malloc(n)) == NULL)
2813	return NULL;	2939	return NULL;
2814	*ends_how = (ch == 0x5c ? C0_ESC : ch);	2940	*ends_how = (ch == 0x5c ? C0_ESC : ch);
2815	STRNCPY(s, string, n);	2941	STRNCPY(s, string, n);
2816	return s;	2942	return s;
2817	}	2943	}
2818		2944
2819	/*----------------------------------------------------------------------*/	2945	/*----------------------------------------------------------------------*/
2820	/*	2946	/*
2821	* process DEVICE CONTROL STRING `ESC P ... (ST|BEL)' or `0x90 ... (ST|BEL)'	2947	* process DEVICE CONTROL STRING `ESC P ... (ST|BEL)' or `0x90 ... (ST|BEL)'
2822	*/	2948	*/
2823	void	2949	void
2824	rxvt_term::process_dcs_seq ()	2950	rxvt_term::process_dcs_seq ()
2825	{	2951	{
2826	unsigned char eh, *s;	2952	unsigned char eh, *s;
2827	/*	2953	/*
2828	* Not handled yet	2954	* Not handled yet
2829	*/	2955	*/
2830	s = get_to_st (&eh);	2956	s = get_to_st (&eh);
2831	if (s)	2957	if (s)
2832	free(s);	2958	free(s);
2833	return;	2959	return;
2834	}	2960	}
2835		2961
2836	/*----------------------------------------------------------------------*/	2962	/*----------------------------------------------------------------------*/
2837	/*	2963	/*
2838	* process OPERATING SYSTEM COMMAND sequence `ESC ] Ps ; Pt (ST|BEL)'	2964	* process OPERATING SYSTEM COMMAND sequence `ESC ] Ps ; Pt (ST|BEL)'
2839	*/	2965	*/
2840	void	2966	void
2841	rxvt_term::process_osc_seq ()	2967	rxvt_term::process_osc_seq ()
2842	{	2968	{
2843	unsigned char ch, eh, *s;	2969	unsigned char ch, eh, *s;
2844	int arg;	2970	int arg;
2845		2971
2846	ch = cmd_getc ();	2972	ch = cmd_getc ();
2847	for (arg = 0; isdigit(ch); ch = cmd_getc ())	2973	for (arg = 0; isdigit(ch); ch = cmd_getc ())
2848	arg = arg * 10 + (ch - '0');	2974	arg = arg * 10 + (ch - '0');
2849		2975
2850	if (ch == ';') {	2976	if (ch == ';')
		2977	{
2851	s = get_to_st (&eh);	2978	s = get_to_st (&eh);
2852	if (s) {	2979	if (s)
2853	/*	2980	{
		2981	/*
2854	* rxvt_menubar_dispatch() violates the constness of the string,	2982	* rxvt_menubar_dispatch() violates the constness of the string,
2855	* so do it here	2983	* so do it here
2856	*/	2984	*/
2857	if (arg == XTerm_Menu)	2985	if (arg == XTerm_Menu)
2858	#if 0 /* XXX: currently disabled due to security concerns */	2986	#if 0 /* XXX: currently disabled due to security concerns */
2859	menubar_dispatch ((char *)s);	2987	menubar_dispatch ((char *)s);
2860	#else	2988	#else
2861	(void)0;	2989	(void)0;
2862	#endif	2990	#endif
2863	else	2991	else
2864	xterm_seq (arg, (char *)s, eh);	2992	xterm_seq (arg, (char *)s, eh);
2865	free(s);	2993	free(s);
2866	}	2994	}
2867	}	2995	}
2868	}	2996	}
2869	/*	2997	/*
2870	* XTerm escape sequences: ESC ] Ps;Pt (ST|BEL)	2998	* XTerm escape sequences: ESC ] Ps;Pt (ST|BEL)
2871	* 0 = change iconName/title	2999	* 0 = change iconName/title
…		…
2888	* 55 = dump scrollback buffer and all of screen	3016	* 55 = dump scrollback buffer and all of screen
2889	*/	3017	*/
2890	void	3018	void
2891	rxvt_term::xterm_seq (int op, const char *str, unsigned char resp __attribute__((unused)))	3019	rxvt_term::xterm_seq (int op, const char *str, unsigned char resp __attribute__((unused)))
2892	{	3020	{
2893	int changed = 0;	3021	int changed = 0;
2894	int color;	3022	int color;
2895	char *buf, *name;	3023	char *buf, *name;
2896		3024
2897	assert(str != NULL);	3025	assert(str != NULL);
2898	switch (op) {	3026	switch (op)
		3027	{
2899	case XTerm_name:	3028	case XTerm_name:
2900	set_title (str);	3029	set_title (str);
2901	/* FALLTHROUGH */	3030	/* FALLTHROUGH */
2902	case XTerm_iconName:	3031	case XTerm_iconName:
2903	set_iconName (str);	3032	set_iconName (str);
2904	break;	3033	break;
2905	case XTerm_title:	3034	case XTerm_title:
2906	set_title (str);	3035	set_title (str);
2907	break;	3036	break;
2908	case XTerm_Color:	3037	case XTerm_Color:
2909	for (buf = (char *)str; buf && *buf;) {	3038	for (buf = (char *)str; buf && *buf;)
		3039	{
2910	if ((name = STRCHR(buf, ';')) == NULL)	3040	if ((name = STRCHR(buf, ';')) == NULL)
2911	break;	3041	break;
2912	*name++ = '\0';	3042	*name++ = '\0';
2913	color = atoi(buf);	3043	color = atoi(buf);
2914	if (color < 0 || color >= TOTAL_COLORS)	3044	if (color < 0 || color >= TOTAL_COLORS)
2915	break;	3045	break;
2916	if ((buf = STRCHR(name, ';')) != NULL)	3046	if ((buf = STRCHR(name, ';')) != NULL)
2917	*buf++ = '\0';	3047	*buf++ = '\0';
2918	set_window_color (color + minCOLOR, name);	3048	set_window_color (color + minCOLOR, name);
2919	}	3049	}
2920	break;	3050	break;
2921	#ifndef NO_CURSORCOLOR	3051	#ifndef NO_CURSORCOLOR
2922	case XTerm_Color_cursor:	3052	case XTerm_Color_cursor:
2923	set_window_color (Color_cursor, str);	3053	set_window_color (Color_cursor, str);
2924	break;	3054	break;
2925	#endif	3055	#endif
2926	case XTerm_Color_pointer:	3056	case XTerm_Color_pointer:
2927	set_window_color (Color_pointer, str);	3057	set_window_color (Color_pointer, str);
2928	break;	3058	break;
2929	#ifndef NO_BOLD_UNDERLINE_REVERSE	3059	#ifndef NO_BOLD_UNDERLINE_REVERSE
2930	case XTerm_Color_BD:	3060	case XTerm_Color_BD:
2931	set_window_color (Color_BD, str);	3061	set_window_color (Color_BD, str);
2932	break;	3062	break;
2933	case XTerm_Color_UL:	3063	case XTerm_Color_UL:
2934	set_window_color (Color_UL, str);	3064	set_window_color (Color_UL, str);
2935	break;	3065	break;
2936	case XTerm_Color_RV:	3066	case XTerm_Color_RV:
2937	set_window_color (Color_RV, str);	3067	set_window_color (Color_RV, str);
2938	break;	3068	break;
2939	#endif	3069	#endif
2940		3070
2941	case XTerm_Menu:	3071	case XTerm_Menu:
2942	/*	3072	/*
2943	* rxvt_menubar_dispatch() violates the constness of the string,	3073	* rxvt_menubar_dispatch() violates the constness of the string,
2944	* so DON'T do it here	3074	* so DON'T do it here
2945	*/	3075	*/
2946	break;	3076	break;
2947	case XTerm_Pixmap:	3077	case XTerm_Pixmap:
2948	if (*str != ';') {	3078	if (*str != ';')
		3079	{
2949	#if XPM_BACKGROUND	3080	#if XPM_BACKGROUND
2950	scale_pixmap (""); /* reset to default scaling */	3081	scale_pixmap (""); /* reset to default scaling */
2951	set_bgPixmap (str); /* change pixmap */	3082	set_bgPixmap (str); /* change pixmap */
2952	#endif	3083	#endif
2953	scr_touch (true);	3084	scr_touch (true);
2954	}	3085	}
2955	while ((str = STRCHR(str, ';')) != NULL) {	3086	while ((str = STRCHR(str, ';')) != NULL)
2956	str++;	3087	{
		3088	str++;
2957	#if XPM_BACKGROUND	3089	#if XPM_BACKGROUND
2958	changed += scale_pixmap (str);	3090	changed += scale_pixmap (str);
2959	#endif	3091	#endif
2960	}	3092
2961	if (changed) {	3093	}
		3094	if (changed)
		3095	{
2962	#ifdef XPM_BACKGROUND	3096	#ifdef XPM_BACKGROUND
2963	resize_pixmap ();	3097	resize_pixmap ();
2964	#endif	3098	#endif
2965	scr_touch (true);	3099	scr_touch (true);
2966	}	3100	}
2967	break;	3101	break;
2968		3102
2969	case XTerm_restoreFG:	3103	case XTerm_restoreFG:
2970	set_window_color (Color_fg, str);	3104	set_window_color (Color_fg, str);
2971	break;	3105	break;
2972	case XTerm_restoreBG:	3106	case XTerm_restoreBG:
2973	set_window_color (Color_bg, str);	3107	set_window_color (Color_bg, str);
2974	break;	3108	break;
2975	case XTerm_logfile:	3109	case XTerm_logfile:
2976	break;	3110	break;
2977	case XTerm_font:	3111	case XTerm_font:
2978	change_font (0, str);	3112	change_font (0, str);
2979	break;	3113	break;
2980	#if 0	3114	#if 0
2981	case XTerm_dumpscreen: /* no error notices */	3115	case XTerm_dumpscreen: /* no error notices */
2982	{	3116	{
2983	int fd;	3117	int fd;
2984	if ((fd = open(str, O_RDWR | O_CREAT | O_EXCL, 0600)) >= 0) {	3118	if ((fd = open(str, O_RDWR | O_CREAT | O_EXCL, 0600)) >= 0)
2985	scr_dump (fd);	3119	{
2986	close(fd);	3120	scr_dump (fd);
2987	}	3121	close(fd);
2988	}	3122	}
2989	break;	3123	}
		3124	break;
2990	#endif	3125	#endif
		3126
2991	}	3127	}
2992	}	3128	}
2993	/*----------------------------------------------------------------------*/	3129	/*----------------------------------------------------------------------*/
2994		3130
2995	/*{{{ process DEC private mode sequences `ESC [ ? Ps mode' */	3131	/*{{{ process DEC private mode sequences `ESC [ ? Ps mode' */
…		…
3003	* so no need for fancy checking	3139	* so no need for fancy checking
3004	*/	3140	*/
3005	int	3141	int
3006	rxvt_term::privcases (int mode, unsigned long bit)	3142	rxvt_term::privcases (int mode, unsigned long bit)
3007	{	3143	{
3008	int state;	3144	int state;
3009		3145
3010	if (mode == 's') {	3146	if (mode == 's')
		3147	{
3011	SavedModes |= (PrivateModes & bit);	3148	SavedModes |= (PrivateModes & bit);
3012	return -1;	3149	return -1;
3013	} else {	3150	}
		3151	else
		3152	{
3014	if (mode == 'r')	3153	if (mode == 'r')
3015	state = (SavedModes & bit) ? 1 : 0; /* no overlapping */	3154	state = (SavedModes & bit) ? 1 : 0; /* no overlapping */
3016	else	3155	else
3017	state = (mode == 't') ? !(PrivateModes & bit) : mode;	3156	state = (mode == 't') ? !(PrivateModes & bit) : mode;
3018	PrivMode(state, bit);	3157	PrivMode(state, bit);
3019	}	3158	}
3020	return state;	3159	return state;
3021	}	3160	}
3022		3161
3023	/* we're not using priv _yet_ */	3162	/* we're not using priv _yet_ */
3024	void	3163	void
3025	rxvt_term::process_terminal_mode (int mode, int priv __attribute__((unused)), unsigned int nargs, const int *arg)	3164	rxvt_term::process_terminal_mode (int mode, int priv __attribute__((unused)), unsigned int nargs, const int *arg)
3026	{	3165	{
3027	unsigned int i, j;	3166	unsigned int i, j;
3028	int state;	3167	int state;
3029	static const struct {	3168	static const struct
		3169	{
3030	const int argval;	3170	const int argval;
3031	const unsigned long bit;	3171	const unsigned long bit;
		3172	}
3032	} argtopriv[] = {	3173	argtopriv[] = {
3033	{ 1, PrivMode_aplCUR },	3174	{ 1, PrivMode_aplCUR },
3034	{ 2, PrivMode_vt52 },	3175	{ 2, PrivMode_vt52 },
3035	{ 3, PrivMode_132 },	3176	{ 3, PrivMode_132 },
3036	{ 4, PrivMode_smoothScroll },	3177	{ 4, PrivMode_smoothScroll },
3037	{ 5, PrivMode_rVideo },	3178	{ 5, PrivMode_rVideo },
3038	{ 6, PrivMode_relOrigin },	3179	{ 6, PrivMode_relOrigin },
3039	{ 7, PrivMode_Autowrap },	3180	{ 7, PrivMode_Autowrap },
3040	{ 9, PrivMode_MouseX10 },	3181	{ 9, PrivMode_MouseX10 },
3041	#ifdef menuBar_esc	3182	#ifdef menuBar_esc
3042	{ menuBar_esc, PrivMode_menuBar },	3183	{ menuBar_esc, PrivMode_menuBar },
3043	#endif	3184	#endif
3044	#ifdef scrollBar_esc	3185	#ifdef scrollBar_esc
3045	{ scrollBar_esc, PrivMode_scrollBar },	3186	{ scrollBar_esc, PrivMode_scrollBar },
3046	#endif	3187	#endif
3047	{ 25, PrivMode_VisibleCursor },	3188	{ 25, PrivMode_VisibleCursor },
3048	{ 35, PrivMode_ShiftKeys },	3189	{ 35, PrivMode_ShiftKeys },
3049	{ 40, PrivMode_132OK },	3190	{ 40, PrivMode_132OK },
3050	{ 47, PrivMode_Screen },	3191	{ 47, PrivMode_Screen },
3051	{ 66, PrivMode_aplKP },	3192	{ 66, PrivMode_aplKP },
3052	#ifndef NO_BACKSPACE_KEY	3193	#ifndef NO_BACKSPACE_KEY
3053	{ 67, PrivMode_BackSpace },	3194	{ 67, PrivMode_BackSpace },
3054	#endif	3195	#endif
3055	{ 1000, PrivMode_MouseX11 },	3196	{ 1000, PrivMode_MouseX11 },
3056	{ 1010, PrivMode_TtyOutputInh },	3197	{ 1010, PrivMode_TtyOutputInh },
3057	{ 1011, PrivMode_Keypress },	3198	{ 1011, PrivMode_Keypress },
3058	{ 1047, PrivMode_Screen },	3199	{ 1047, PrivMode_Screen },
3059	{ 1049, PrivMode_Screen }, /* xterm extension, not fully implemented */	3200	{ 1049, PrivMode_Screen }, /* xterm extension, not fully implemented */
3060	};	3201	};
3061		3202
3062	if (nargs == 0)	3203	if (nargs == 0)
3063	return;	3204	return;
3064		3205
3065	/* make lo/hi boolean */	3206	/* make lo/hi boolean */
3066	if (mode == 'l')	3207	if (mode == 'l')
3067	mode = 0; /* reset */	3208	mode = 0; /* reset */
3068	else if (mode == 'h')	3209	else if (mode == 'h')
3069	mode = 1; /* set */	3210	mode = 1; /* set */
3070		3211
3071	for (i = 0; i < nargs; i++) {	3212	for (i = 0; i < nargs; i++)
		3213	{
3072	state = -1;	3214	state = -1;
3073		3215
3074	/* basic handling */	3216	/* basic handling */
3075	for (j = 0; j < (sizeof(argtopriv)/sizeof(argtopriv[0])); j++)	3217	for (j = 0; j < (sizeof(argtopriv)/sizeof(argtopriv[0])); j++)
3076	if (argtopriv[j].argval == arg[i]) {	3218	if (argtopriv[j].argval == arg[i])
		3219	{
3077	state = privcases (mode, argtopriv[j].bit);	3220	state = privcases (mode, argtopriv[j].bit);
3078	break;	3221	break;
3079	}	3222	}
3080		3223
3081	/* extra handling for values with state unkept */	3224	/* extra handling for values with state unkept */
3082	if (state == -1)	3225	if (state == -1)
3083	switch (arg[i]) {	3226	switch (arg[i])
		3227	{
3084	case 1048: /* alternative cursor save */	3228	case 1048: /* alternative cursor save */
3085	if (mode == 0)	3229	if (mode == 0)
3086	scr_cursor (RESTORE);	3230	scr_cursor (RESTORE);
3087	else if (mode == 1)	3231	else if (mode == 1)
3088	scr_cursor (SAVE);	3232	scr_cursor (SAVE);
3089	/* FALLTHROUGH */	3233	/* FALLTHROUGH */
3090	default:	3234	default:
3091	continue; /* for(;i;) */	3235	continue; /* for(;i;) */
3092	}	3236	}
3093		3237
3094	/* extra handling for values with valid 0 or 1 state */	3238	/* extra handling for values with valid 0 or 1 state */
3095	switch (arg[i]) {	3239	switch (arg[i])
		3240	{
3096	/* case 1: - application cursor keys */	3241	/* case 1: - application cursor keys */
3097	case 2: /* VT52 mode */	3242	case 2: /* VT52 mode */
3098	/* oddball mode. should be set regardless of set/reset	3243	/* oddball mode. should be set regardless of set/reset
3099	* parameter. Return from VT52 mode with an ESC < from	3244	* parameter. Return from VT52 mode with an ESC < from
3100	* within VT52 mode	3245	* within VT52 mode
3101	*/	3246	*/
3102	PrivMode(1, PrivMode_vt52);	3247	PrivMode(1, PrivMode_vt52);
3103	break;	3248	break;
3104	case 3: /* 80/132 */	3249	case 3: /* 80/132 */
3105	if (PrivateModes & PrivMode_132OK)	3250	if (PrivateModes & PrivMode_132OK)
3106	set_widthheight ( (unsigned int)((state ? 132 : 80) * TermWin.fwidth),	3251	set_widthheight ( (unsigned int)((state ? 132 : 80) * TermWin.fwidth),
3107	(unsigned int)TermWin.height);	3252	(unsigned int)TermWin.height);
3108	break;	3253	break;
3109	case 4: /* smooth scrolling */	3254	case 4: /* smooth scrolling */
3110	if (state)	3255	if (state)
3111	Options &= ~Opt_jumpScroll;	3256	Options &= ~Opt_jumpScroll;
3112	else	3257	else
3113	Options |= Opt_jumpScroll;	3258	Options |= Opt_jumpScroll;
3114	break;	3259	break;
3115	case 5: /* reverse video */	3260	case 5: /* reverse video */
3116	scr_rvideo_mode (state);	3261	scr_rvideo_mode (state);
3117	break;	3262	break;
3118	case 6: /* relative/absolute origins */	3263	case 6: /* relative/absolute origins */
3119	scr_relative_origin (state);	3264	scr_relative_origin (state);
3120	break;	3265	break;
3121	case 7: /* autowrap */	3266	case 7: /* autowrap */
3122	scr_autowrap (state);	3267	scr_autowrap (state);
3123	break;	3268	break;
3124	/* case 8: - auto repeat, can't do on a per window basis */	3269	/* case 8: - auto repeat, can't do on a per window basis */
3125	case 9: /* X10 mouse reporting */	3270	case 9: /* X10 mouse reporting */
3126	if (state) /* orthogonal */	3271	if (state) /* orthogonal */
3127	PrivateModes &= ~(PrivMode_MouseX11);	3272	PrivateModes &= ~(PrivMode_MouseX11);
3128	break;	3273	break;
3129	#ifdef menuBar_esc	3274	#ifdef menuBar_esc
3130	case menuBar_esc:	3275	case menuBar_esc:
3131	#ifdef MENUBAR	3276	#ifdef MENUBAR
3132	map_menuBar (state);	3277	map_menuBar (state);
3133	#endif	3278	#endif
3134	break;	3279	break;
3135	#endif	3280	#endif
3136	#ifdef scrollBar_esc	3281	#ifdef scrollBar_esc
3137	case scrollBar_esc:	3282	case scrollBar_esc:
3138	if (scrollbar_mapping (state)) {	3283	if (scrollbar_mapping (state))
		3284	{
3139	resize_all_windows (0, 0, 0);	3285	resize_all_windows (0, 0, 0);
3140	scr_touch (true);	3286	scr_touch (true);
3141	}	3287	}
3142	break;	3288	break;
3143	#endif	3289	#endif
3144	case 25: /* visible/invisible cursor */	3290	case 25: /* visible/invisible cursor */
3145	scr_cursor_visible (state);	3291	scr_cursor_visible (state);
3146	break;	3292	break;
3147	/* case 35: - shift keys */	3293	/* case 35: - shift keys */
3148	/* case 40: - 80 <--> 132 mode */	3294	/* case 40: - 80 <--> 132 mode */
3149	case 47: /* secondary screen */	3295	case 47: /* secondary screen */
3150	scr_change_screen (state);	3296	scr_change_screen (state);
3151	break;	3297	break;
3152	/* case 66: - application key pad */	3298	/* case 66: - application key pad */
3153	/* case 67: - backspace key */	3299	/* case 67: - backspace key */
3154	case 1000: /* X11 mouse reporting */	3300	case 1000: /* X11 mouse reporting */
3155	if (state) /* orthogonal */	3301	if (state) /* orthogonal */
3156	PrivateModes &= ~(PrivMode_MouseX10);	3302	PrivateModes &= ~(PrivMode_MouseX10);
3157	break;	3303	break;
3158	#if 0	3304	#if 0
3159	case 1001:	3305	case 1001:
3160	break; /* X11 mouse highlighting */	3306	break; /* X11 mouse highlighting */
3161	#endif	3307	#endif
3162	case 1010: /* scroll to bottom on TTY output inhibit */	3308	case 1010: /* scroll to bottom on TTY output inhibit */
3163	if (state)	3309	if (state)
3164	Options &= ~Opt_scrollTtyOutput;	3310	Options &= ~Opt_scrollTtyOutput;
3165	else	3311	else
3166	Options |= Opt_scrollTtyOutput;	3312	Options |= Opt_scrollTtyOutput;
3167	break;	3313	break;
3168	case 1011: /* scroll to bottom on key press */	3314	case 1011: /* scroll to bottom on key press */
3169	if (state)	3315	if (state)
3170	Options |= Opt_scrollTtyKeypress;	3316	Options |= Opt_scrollTtyKeypress;
3171	else	3317	else
3172	Options &= ~Opt_scrollTtyKeypress;	3318	Options &= ~Opt_scrollTtyKeypress;
3173	break;	3319	break;
3174	case 1047: /* secondary screen w/ clearing */	3320	case 1047: /* secondary screen w/ clearing */
3175	case 1049: /* better secondary screen w/ clearing, but not fully implemented */	3321	case 1049: /* better secondary screen w/ clearing, but not fully implemented */
3176	if (current_screen != PRIMARY)	3322	if (current_screen != PRIMARY)
3177	scr_erase_screen (2);	3323	scr_erase_screen (2);
3178	scr_change_screen (state);	3324	scr_change_screen (state);
3179	/* FALLTHROUGH */	3325	/* FALLTHROUGH */
3180	default:	3326	default:
3181	break;	3327	break;
3182	}	3328	}
3183	}	3329	}
3184	}	3330	}
3185	/*}}} */	3331	/*}}} */
3186		3332
3187	/*{{{ process sgr sequences */	3333	/*{{{ process sgr sequences */
3188	void	3334	void
3189	rxvt_term::process_sgr_mode (unsigned int nargs, const int *arg)	3335	rxvt_term::process_sgr_mode (unsigned int nargs, const int *arg)
3190	{	3336	{
3191	unsigned int i;	3337	unsigned int i;
3192	short rendset;	3338	short rendset;
3193	int rendstyle;	3339	int rendstyle;
3194		3340
3195	if (nargs == 0) {	3341	if (nargs == 0)
		3342	{
3196	scr_rendition (0, ~RS_None);	3343	scr_rendition (0, ~RS_None);
3197	return;	3344	return;
3198	}	3345	}
3199	for (i = 0; i < nargs; i++) {	3346	for (i = 0; i < nargs; i++)
		3347	{
3200	rendset = -1;	3348	rendset = -1;
3201	switch (arg[i]) {	3349	switch (arg[i])
3202	case 0:	3350	{
		3351	case 0:
3203	rendset = 0, rendstyle = ~RS_None;	3352	rendset = 0, rendstyle = ~RS_None;
3204	break;	3353	break;
3205	case 1:	3354	case 1:
3206	rendset = 1, rendstyle = RS_Bold;	3355	rendset = 1, rendstyle = RS_Bold;
3207	break;	3356	break;
3208	case 4:	3357	case 4:
3209	rendset = 1, rendstyle = RS_Uline;	3358	rendset = 1, rendstyle = RS_Uline;
3210	break;	3359	break;
3211	case 5:	3360	case 5:
3212	rendset = 1, rendstyle = RS_Blink;	3361	rendset = 1, rendstyle = RS_Blink;
3213	break;	3362	break;
3214	case 7:	3363	case 7:
3215	rendset = 1, rendstyle = RS_RVid;	3364	rendset = 1, rendstyle = RS_RVid;
3216	break;	3365	break;
3217	case 22:	3366	case 22:
3218	rendset = 0, rendstyle = RS_Bold;	3367	rendset = 0, rendstyle = RS_Bold;
3219	break;	3368	break;
3220	case 24:	3369	case 24:
3221	rendset = 0, rendstyle = RS_Uline;	3370	rendset = 0, rendstyle = RS_Uline;
3222	break;	3371	break;
3223	case 25:	3372	case 25:
3224	rendset = 0, rendstyle = RS_Blink;	3373	rendset = 0, rendstyle = RS_Blink;
3225	break;	3374	break;
3226	case 27:	3375	case 27:
3227	rendset = 0, rendstyle = RS_RVid;	3376	rendset = 0, rendstyle = RS_RVid;
3228	break;	3377	break;
3229	}	3378	}
3230	if (rendset != -1) {	3379	if (rendset != -1)
		3380	{
3231	scr_rendition (rendset, rendstyle);	3381	scr_rendition (rendset, rendstyle);
3232	continue; /* for(;i;) */	3382	continue; /* for(;i;) */
3233	}	3383	}
3234		3384
3235	switch (arg[i]) {	3385	switch (arg[i])
3236	case 30:	3386	{
		3387	case 30:
3237	case 31: /* set fg color */	3388	case 31: /* set fg color */
3238	case 32:	3389	case 32:
3239	case 33:	3390	case 33:
3240	case 34:	3391	case 34:
3241	case 35:	3392	case 35:
3242	case 36:	3393	case 36:
3243	case 37:	3394	case 37:
3244	scr_color ((unsigned int)(minCOLOR + (arg[i] - 30)),	3395	scr_color ((unsigned int)(minCOLOR + (arg[i] - 30)),
3245	Color_fg);	3396	Color_fg);
3246	break;	3397	break;
3247	#ifdef TTY_256COLOR	3398	#ifdef TTY_256COLOR
3248	case 38:	3399	case 38:
3249	if (nargs > i + 2 && arg[i + 1] == 5) {	3400	if (nargs > i + 2 && arg[i + 1] == 5)
		3401	{
3250	scr_color ((unsigned int)(minCOLOR + arg[i + 2]),	3402	scr_color ((unsigned int)(minCOLOR + arg[i + 2]),
3251	Color_fg);	3403	Color_fg);
3252	i += 2;	3404	i += 2;
3253	}	3405	}
3254	break;	3406	break;
3255	#endif	3407	#endif
3256	case 39: /* default fg */	3408	case 39: /* default fg */
3257	scr_color (Color_fg, Color_fg);	3409	scr_color (Color_fg, Color_fg);
3258	break;	3410	break;
3259		3411
3260	case 40:	3412	case 40:
3261	case 41: /* set bg color */	3413	case 41: /* set bg color */
3262	case 42:	3414	case 42:
3263	case 43:	3415	case 43:
3264	case 44:	3416	case 44:
3265	case 45:	3417	case 45:
3266	case 46:	3418	case 46:
3267	case 47:	3419	case 47:
3268	scr_color ((unsigned int)(minCOLOR + (arg[i] - 40)),	3420	scr_color ((unsigned int)(minCOLOR + (arg[i] - 40)),
3269	Color_bg);	3421	Color_bg);
3270	break;	3422	break;
3271	#ifdef TTY_256COLOR	3423	#ifdef TTY_256COLOR
3272	case 48:	3424	case 48:
3273	if (nargs > i + 2 && arg[i + 1] == 5) {	3425	if (nargs > i + 2 && arg[i + 1] == 5)
		3426	{
3274	scr_color ((unsigned int)(minCOLOR + arg[i + 2]),	3427	scr_color ((unsigned int)(minCOLOR + arg[i + 2]),
3275	Color_bg);	3428	Color_bg);
3276	i += 2;	3429	i += 2;
3277	}	3430	}
3278	break;	3431	break;
3279	#endif	3432	#endif
3280	case 49: /* default bg */	3433	case 49: /* default bg */
3281	scr_color (Color_bg, Color_bg);	3434	scr_color (Color_bg, Color_bg);
3282	break;	3435	break;
3283		3436
3284	#ifndef NO_BRIGHTCOLOR	3437	#ifndef NO_BRIGHTCOLOR
3285	case 90:	3438	case 90:
3286	case 91: /* set bright fg color */	3439	case 91: /* set bright fg color */
3287	case 92:	3440	case 92:
3288	case 93:	3441	case 93:
3289	case 94:	3442	case 94:
3290	case 95:	3443	case 95:
3291	case 96:	3444	case 96:
3292	case 97:	3445	case 97:
3293	scr_color ((unsigned int)(minBrightCOLOR + (arg[i] - 90)),	3446	scr_color ((unsigned int)(minBrightCOLOR + (arg[i] - 90)),
3294	Color_fg);	3447	Color_fg);
3295	break;	3448	break;
3296	case 100:	3449	case 100:
3297	case 101: /* set bright bg color */	3450	case 101: /* set bright bg color */
3298	case 102:	3451	case 102:
3299	case 103:	3452	case 103:
3300	case 104:	3453	case 104:
3301	case 105:	3454	case 105:
3302	case 106:	3455	case 106:
3303	case 107:	3456	case 107:
3304	scr_color ((unsigned int)(minBrightCOLOR + (arg[i] - 100)),	3457	scr_color ((unsigned int)(minBrightCOLOR + (arg[i] - 100)),
3305	Color_bg);	3458	Color_bg);
3306	break;	3459	break;
3307	#endif	3460	#endif
3308	}	3461
		3462	}
3309	}	3463	}
3310	}	3464	}
3311	/*}}} */	3465	/*}}} */
3312		3466
3313	/*{{{ process Rob Nation's own graphics mode sequences */	3467	/*{{{ process Rob Nation's own graphics mode sequences */
3314	void	3468	void
3315	rxvt_term::process_graphics ()	3469	rxvt_term::process_graphics ()
3316	{	3470	{
3317	unsigned char ch, cmd = cmd_getc ();	3471	unsigned char ch, cmd = cmd_getc ();
3318		3472
3319	#ifndef RXVT_GRAPHICS	3473	#ifndef RXVT_GRAPHICS
		3474	if (cmd == 'Q')
3320	if (cmd == 'Q') { /* query graphics */	3475	{ /* query graphics */
3321	tt_printf("\033G0\n"); /* no graphics */	3476	tt_printf("\033G0\n"); /* no graphics */
3322	return;	3477	return;
3323	}	3478	}
3324	/* swallow other graphics sequences until terminating ':' */	3479	/* swallow other graphics sequences until terminating ':' */
3325	do	3480	do
3326	ch = cmd_getc ();	3481	ch = cmd_getc ();
3327	while (ch != ':');	3482	while (ch != ':');
3328	#else	3483	#else
3329	unsigned int nargs;	3484	unsigned int nargs;
3330	int args[NGRX_PTS];	3485	int args[NGRX_PTS];
3331	unsigned char *text = NULL;	3486	unsigned char *text = NULL;
3332		3487
		3488	if (cmd == 'Q')
3333	if (cmd == 'Q') { /* query graphics */	3489	{ /* query graphics */
3334	tt_printf("\033G1\n"); /* yes, graphics (color) */	3490	tt_printf("\033G1\n"); /* yes, graphics (color) */
3335	return;	3491	return;
3336	}	3492	}
3337	for (nargs = 0; nargs < (sizeof(args) / sizeof(args[0])) - 1;) {	3493	for (nargs = 0; nargs < (sizeof(args) / sizeof(args[0])) - 1;)
		3494	{
3338	int neg;	3495	int neg;
3339		3496
3340	ch = cmd_getc ();
3341	neg = (ch == '-');
3342	if (neg || ch == '+')
3343	ch = cmd_getc ();	3497	ch = cmd_getc ();
		3498	neg = (ch == '-');
		3499	if (neg || ch == '+')
		3500	ch = cmd_getc ();
3344		3501
3345	for (args[nargs] = 0; isdigit(ch); ch = cmd_getc ())	3502	for (args[nargs] = 0; isdigit(ch); ch = cmd_getc ())
3346	args[nargs] = args[nargs] * 10 + (ch - '0');	3503	args[nargs] = args[nargs] * 10 + (ch - '0');
3347	if (neg)	3504	if (neg)
3348	args[nargs] = -args[nargs];	3505	args[nargs] = -args[nargs];
3349		3506
3350	nargs++;	3507	nargs++;
3351	args[nargs] = 0;	3508	args[nargs] = 0;
3352	if (ch != ';')	3509	if (ch != ';')
3353	break;	3510	break;
3354	}	3511	}
3355		3512
3356	if ((cmd == 'T') && (nargs >= 5)) {	3513	if ((cmd == 'T') && (nargs >= 5))
		3514	{
3357	int i, len = args[4];	3515	int i, len = args[4];
3358		3516
3359	text = (unsigned char *)rxvt_malloc((len + 1) * sizeof(char));	3517	text = (unsigned char *)rxvt_malloc((len + 1) * sizeof(char));
3360		3518
3361	if (text != NULL) {	3519	if (text != NULL)
		3520	{
3362	for (i = 0; i < len; i++)	3521	for (i = 0; i < len; i++)
3363	text[i] = cmd_getc ();	3522	text[i] = cmd_getc ();
3364	text[len] = '\0';	3523	text[len] = '\0';
3365	}	3524	}
3366	}	3525	}
3367	Gr_do_graphics (cmd, nargs, args, text);	3526	Gr_do_graphics (cmd, nargs, args, text);
3368	#endif	3527	#endif
3369	}	3528	}
3370	/*}}} */	3529	/*}}} */
3371		3530
3372	/* ------------------------------------------------------------------------- */	3531	/* ------------------------------------------------------------------------- */

Diff Legend

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