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.42 by pcg, Thu Feb 12 01:42:03 2004 UTC vs.
Revision 1.53 by pcg, Sun Feb 22 12:34:53 2004 UTC

…		…
25	* - extensive modifications	25	* - extensive modifications
26	* Copyright (c) 1998 Alfredo K. Kojima <kojima@windowmaker.org>	26	* Copyright (c) 1998 Alfredo K. Kojima <kojima@windowmaker.org>
27	* Copyright (c) 2001 Marius Gedminas	27	* Copyright (c) 2001 Marius Gedminas
28	* - Ctrl/Mod4+Tab works like Meta+Tab (options)	28	* - Ctrl/Mod4+Tab works like Meta+Tab (options)
29	* Copyright (c) 2003 Rob McMullen <robm@flipturn.org>	29	* Copyright (c) 2003 Rob McMullen <robm@flipturn.org>
		30	* Copyright (c) 2003-2004 Marc Lehmann <pcg@goof.com>
30	*	31	*
31	* This program is free software; you can redistribute it and/or modify	32	* This program is free software; you can redistribute it and/or modify
32	* it under the terms of the GNU General Public License as published by	33	* it under the terms of the GNU General Public License as published by
33	* the Free Software Foundation; either version 2 of the License, or	34	* the Free Software Foundation; either version 2 of the License, or
34	* (at your option) any later version.	35	* (at your option) any later version.
…		…
55		56
56	/*{{{ Convert the keypress event into a string */	57	/*{{{ Convert the keypress event into a string */
57	void	58	void
58	rxvt_term::lookup_key (XKeyEvent &ev)	59	rxvt_term::lookup_key (XKeyEvent &ev)
59	{	60	{
60	int ctrl, meta, shft, len;	61	int ctrl, meta, shft, len;
61	unsigned int newlen;	62	unsigned int newlen;
62	KeySym keysym;	63	KeySym keysym;
63	#ifdef DEBUG_CMD	64	#ifdef DEBUG_CMD
64	static int debug_key = 1; /* accessible by a debugger only */	65	static int debug_key = 1; /* accessible by a debugger only */
65	#endif	66	#endif
66	int valid_keysym;	67	int valid_keysym;
67	unsigned char kbuf[KBUFSZ];	68	unsigned char kbuf[KBUFSZ];
68		69
69	/*	70	/*
70	* use Num_Lock to toggle Keypad on/off. If Num_Lock is off, allow an	71	* use Num_Lock to toggle Keypad on/off. If Num_Lock is off, allow an
71	* escape sequence to toggle the Keypad.	72	* escape sequence to toggle the Keypad.
…		…
77	meta = (ev.state & ModMetaMask);	78	meta = (ev.state & ModMetaMask);
78		79
79	if (numlock_state || (ev.state & ModNumLockMask))	80	if (numlock_state || (ev.state & ModNumLockMask))
80	{	81	{
81	numlock_state = (ev.state & ModNumLockMask);	82	numlock_state = (ev.state & ModNumLockMask);
82	PrivMode((!numlock_state), PrivMode_aplKP);	83	PrivMode ((!numlock_state), PrivMode_aplKP);
83	}	84	}
84		85
85	kbuf[0] = 0;	86	kbuf[0] = 0;
86		87
87	#ifdef USE_XIM	88	#ifdef USE_XIM
88	if (Input_Context)	89	if (Input_Context)
89	{	90	{
90	Status status_return;	91	Status status_return;
91		92
92	#ifdef X_HAVE_UTF8_STRING	93	#ifdef X_HAVE_UTF8_STRING
93	if (enc_utf8 && 0)	94	if (enc_utf8 && 0) // currently disabled, doesn't seem to work, nor is useful
94	len = Xutf8LookupString (Input_Context, &ev, (char *)kbuf,	95	len = Xutf8LookupString (Input_Context, &ev, (char *)kbuf,
95	KBUFSZ, &keysym, &status_return);	96	KBUFSZ, &keysym, &status_return);
96	else	97	else
97	#endif	98	#endif
98
99	{	99	{
100	wchar_t wkbuf[KBUFSZ + 1];	100	wchar_t wkbuf[KBUFSZ + 1];
101		101
102	// the XOpenIM manpage lies about hardcoding the locale	102	// the XOpenIM manpage lies about hardcoding the locale
103	// at the point of XOpenIM, so temporarily switch locales	103	// at the point of XOpenIM, so temporarily switch locales
…		…
108	KBUFSZ, &keysym, &status_return);	108	KBUFSZ, &keysym, &status_return);
109	if (rs[Rs_imLocale])	109	if (rs[Rs_imLocale])
110	SET_LOCALE (locale);	110	SET_LOCALE (locale);
111		111
112	if (status_return == XLookupChars	112	if (status_return == XLookupChars
113	|| status_return == XLookupBoth)	113	|| status_return == XLookupBoth)
114	{	114	{
115	wkbuf[len] = 0;	115	wkbuf[len] = 0;
116	len = wcstombs ((char *)kbuf, wkbuf, KBUFSZ);	116	len = wcstombs ((char *)kbuf, wkbuf, KBUFSZ);
117	if (len < 0)	117	if (len < 0)
118	len = 0;	118	len = 0;
…		…
120	else	120	else
121	len = 0;	121	len = 0;
122	}	122	}
123		123
124	valid_keysym = status_return == XLookupKeySym	124	valid_keysym = status_return == XLookupKeySym
125	|| status_return == XLookupBoth;	125	|| status_return == XLookupBoth;
126	}	126	}
127	else	127	else
128	#endif	128	#endif
129
130	{	129	{
131	len = XLookupString (&ev, (char *)kbuf, KBUFSZ, &keysym, &compose);	130	len = XLookupString (&ev, (char *)kbuf, KBUFSZ, &keysym, &compose);
132	valid_keysym = !len;	131	valid_keysym = keysym != NoSymbol;
133	}	132	}
134		133
135	if (valid_keysym)	134	if (valid_keysym)
136	{	135	{
137	/* for some backwards compatibility */	136	/* for some backwards compatibility */
…		…
142	if (meta)	141	if (meta)
143	# endif	142	# endif
144	{	143	{
145	if (keysym == ks_bigfont)	144	if (keysym == ks_bigfont)
146	{	145	{
147	change_font (0, FONT_UP);	146	change_font (FONT_UP);
148	return;	147	return;
149	}	148	}
150	else if (keysym == ks_smallfont)	149	else if (keysym == ks_smallfont)
151	{	150	{
152	change_font (0, FONT_DN);	151	change_font (FONT_DN);
153	return;	152	return;
154	}	153	}
155	}	154	}
156	#endif	155	#endif
157		156
…		…
162	{	161	{
163	#else	162	#else
164	if (IS_SCROLL_MOD)	163	if (IS_SCROLL_MOD)
165	{	164	{
166	#endif	165	#endif
167	int lnsppg;	166	int lnsppg;
168		167
169	#ifdef PAGING_CONTEXT_LINES	168	#ifdef PAGING_CONTEXT_LINES
170	lnsppg = TermWin.nrow - PAGING_CONTEXT_LINES;	169	lnsppg = TermWin.nrow - PAGING_CONTEXT_LINES;
171	#else	170	#else
172	lnsppg = TermWin.nrow * 4 / 5;	171	lnsppg = TermWin.nrow * 4 / 5;
…		…
210	scr_move_to (1, 0);	209	scr_move_to (1, 0);
211	return;	210	return;
212	}	211	}
213	}	212	}
214	#endif	213	#endif
215
216	}	214	}
217		215
218	if (shft)	216	if (shft)
219	{	217	{
220	/* Shift + F1 - F10 generates F11 - F20 */	218	/* Shift + F1 - F10 generates F11 - F20 */
…		…
231	case XK_Insert: /* Shift+Insert = paste mouse selection */	229	case XK_Insert: /* Shift+Insert = paste mouse selection */
232	selection_request (ev.time, 0, 0);	230	selection_request (ev.time, 0, 0);
233	return;	231	return;
234	/* rxvt extras */	232	/* rxvt extras */
235	case XK_KP_Add: /* Shift+KP_Add = bigger font */	233	case XK_KP_Add: /* Shift+KP_Add = bigger font */
236	change_font (0, FONT_UP);	234	change_font (FONT_UP);
237	return;	235	return;
238	case XK_KP_Subtract: /* Shift+KP_Subtract = smaller font */	236	case XK_KP_Subtract: /* Shift+KP_Subtract = smaller font */
239	change_font (0, FONT_DN);	237	change_font (FONT_DN);
240	return;	238	return;
241	}	239	}
242	}	240	}
243	}	241	}
244	#ifdef PRINTPIPE	242	#ifdef PRINTPIPE
…		…
246	{	244	{
247	scr_printscreen (ctrl | shft);	245	scr_printscreen (ctrl | shft);
248	return;	246	return;
249	}	247	}
250	#endif	248	#endif
251	#ifdef GREEK_SUPPORT
252	if (keysym == ks_greekmodeswith)
253	{
254	greek_mode = !greek_mode;
255	if (greek_mode)
256	{
257	xterm_seq (XTerm_title,
258	(greek_getmode() == GREEK_ELOT928
259	? "[Greek: iso]" : "[Greek: ibm]"), CHAR_ST);
260	greek_reset();
261	}
262	else
263	xterm_seq (XTerm_title, APL_NAME "-" VERSION, CHAR_ST);
264	return;
265	}
266	#endif
267		249
268	if (keysym >= 0xFF00 && keysym <= 0xFFFF)	250	if (keysym >= 0xFF00 && keysym <= 0xFFFF)
269	{	251	{
270	#ifdef KEYSYM_RESOURCE	252	#ifdef KEYSYM_RESOURCE
271	if (!(shft | ctrl) && Keysym_map[keysym & 0xFF] != NULL)	253	if (! (shft | ctrl) && Keysym_map[keysym & 0xFF] != NULL)
272	{	254	{
273	unsigned int l;	255	unsigned int l;
274	const unsigned char *kbuf0;	256	const unsigned char *kbuf0;
275	const unsigned char ch = C0_ESC;	257	const unsigned char ch = C0_ESC;
276		258
…		…
286	tt_write (kbuf0, l);	268	tt_write (kbuf0, l);
287	return;	269	return;
288	}	270	}
289	else	271	else
290	#endif	272	#endif
291
292	{	273	{
293	newlen = 1;	274	newlen = 1;
294	switch (keysym)	275	switch (keysym)
295	{	276	{
296	#ifndef NO_BACKSPACE_KEY	277	#ifndef NO_BACKSPACE_KEY
297	case XK_BackSpace:	278	case XK_BackSpace:
298	if (PrivateModes & PrivMode_HaveBackSpace)	279	if (PrivateModes & PrivMode_HaveBackSpace)
299	{	280	{
300	kbuf[0] = (!!(PrivateModes & PrivMode_BackSpace)	281	kbuf[0] = (!! (PrivateModes & PrivMode_BackSpace)
301	^ !!ctrl) ? '\b' : '\177';	282	^ !!ctrl) ? '\b' : '\177';
302	kbuf[1] = '\0';	283	kbuf[1] = '\0';
303	}	284	}
304	else	285	else
305	STRCPY(kbuf, key_backspace);	286	STRCPY (kbuf, key_backspace);
306	# ifdef MULTICHAR_SET	287	# ifdef MULTICHAR_SET
307	if ((Options & Opt_mc_hack) && screen.cur.col > 0)	288	if ((Options & Opt_mc_hack) && screen.cur.col > 0)
308	{	289	{
309	int col, row;	290	int col, row;
310		291
311	newlen = STRLEN(kbuf);	292	newlen = STRLEN (kbuf);
312	col = screen.cur.col - 1;	293	col = screen.cur.col - 1;
313	row = screen.cur.row + TermWin.saveLines;	294	row = screen.cur.row + TermWin.saveLines;
314	if (IS_MULTI2(screen.rend[row][col]))	295	if (IS_MULTI2 (screen.rend[row][col]))
315	MEMMOVE(kbuf + newlen, kbuf, newlen + 1);	296	MEMMOVE (kbuf + newlen, kbuf, newlen + 1);
316	}	297	}
317	# endif	298	# endif
318	break;	299	break;
319	#endif	300	#endif
320	#ifndef NO_DELETE_KEY	301	#ifndef NO_DELETE_KEY
321	case XK_Delete:	302	case XK_Delete:
322	STRCPY(kbuf, key_delete);	303	STRCPY (kbuf, key_delete);
323	# ifdef MULTICHAR_SET	304	# ifdef MULTICHAR_SET
324	if (Options & Opt_mc_hack)	305	if (Options & Opt_mc_hack)
325	{	306	{
326	int col, row;	307	int col, row;
327		308
328	newlen = STRLEN(kbuf);	309	newlen = STRLEN (kbuf);
329	col = screen.cur.col;	310	col = screen.cur.col;
330	row = screen.cur.row + TermWin.saveLines;	311	row = screen.cur.row + TermWin.saveLines;
331	if (IS_MULTI1(screen.rend[row][col]))	312	if (IS_MULTI1 (screen.rend[row][col]))
332	MEMMOVE(kbuf + newlen, kbuf, newlen + 1);	313	MEMMOVE (kbuf + newlen, kbuf, newlen + 1);
333	}	314	}
334	# endif	315	# endif
335	break;	316	break;
336	#endif	317	#endif
337	case XK_Tab:	318	case XK_Tab:
338	if (shft)	319	if (shft)
339	STRCPY(kbuf, "\033[Z");	320	STRCPY (kbuf, "\033[Z");
340	else	321	else
341	{	322	{
342	#ifdef CTRL_TAB_MAKES_META	323	#ifdef CTRL_TAB_MAKES_META
343	if (ctrl)	324	if (ctrl)
344	meta = 1;	325	meta = 1;
…		…
348	meta = 1;	329	meta = 1;
349	#endif	330	#endif
350	newlen = 0;	331	newlen = 0;
351	}	332	}
352	break;	333	break;
353
354		334
355	#ifdef XK_KP_Left	335	#ifdef XK_KP_Left
356	case XK_KP_Up: /* \033Ox or standard */	336	case XK_KP_Up: /* \033Ox or standard */
357	case XK_KP_Down: /* \033Or or standard */	337	case XK_KP_Down: /* \033Or or standard */
358	case XK_KP_Right: /* \033Ov or standard */	338	case XK_KP_Right: /* \033Ov or standard */
359	case XK_KP_Left: /* \033Ot or standard */	339	case XK_KP_Left: /* \033Ot or standard */
360	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	340	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
361	{	341	{
362	STRCPY(kbuf, "\033OZ");	342	STRCPY (kbuf, "\033OZ");
363	kbuf[2] = ("txvr"[keysym - XK_KP_Left]);	343	kbuf[2] = "txvr"[keysym - XK_KP_Left];
364	break;	344	break;
365	}	345	}
366	else	346	else
367	/* translate to std. cursor key */	347	/* translate to std. cursor key */
368	keysym = XK_Left + (keysym - XK_KP_Left);	348	keysym = XK_Left + (keysym - XK_KP_Left);
…		…
370	#endif	350	#endif
371	case XK_Up: /* "\033[A" */	351	case XK_Up: /* "\033[A" */
372	case XK_Down: /* "\033[B" */	352	case XK_Down: /* "\033[B" */
373	case XK_Right: /* "\033[C" */	353	case XK_Right: /* "\033[C" */
374	case XK_Left: /* "\033[D" */	354	case XK_Left: /* "\033[D" */
375	STRCPY(kbuf, "\033[Z");	355	STRCPY (kbuf, "\033[Z");
376	kbuf[2] = ("DACB"[keysym - XK_Left]);	356	kbuf[2] = "DACB"[keysym - XK_Left];
377	/* do Shift first */	357	/* do Shift first */
378	if (shft)	358	if (shft)
379	kbuf[2] = ("dacb"[keysym - XK_Left]);	359	kbuf[2] = "dacb"[keysym - XK_Left];
380	else if (ctrl)	360	else if (ctrl)
381	{	361	{
382	kbuf[1] = 'O';	362	kbuf[1] = 'O';
383	kbuf[2] = ("dacb"[keysym - XK_Left]);	363	kbuf[2] = "dacb"[keysym - XK_Left];
384	}	364	}
385	else if (PrivateModes & PrivMode_aplCUR)	365	else if (PrivateModes & PrivMode_aplCUR)
386	kbuf[1] = 'O';	366	kbuf[1] = 'O';
387	#ifdef MULTICHAR_SET	367	#ifdef MULTICHAR_SET
388	//TODO: ??	368	//TODO: ??
…		…
392		372
393	col = screen.cur.col;	373	col = screen.cur.col;
394	row = screen.cur.row + TermWin.saveLines;	374	row = screen.cur.row + TermWin.saveLines;
395	m = 0;	375	m = 0;
396	if (keysym == XK_Right	376	if (keysym == XK_Right
397	&& IS_MULTI1(screen.rend[row][col]))	377	&& IS_MULTI1 (screen.rend[row][col]))
398	m = 1;	378	m = 1;
399	else if (keysym == XK_Left)	379	else if (keysym == XK_Left)
400	{	380	{
401	if (col > 0)	381	if (col > 0)
402	{	382	{
403	if (IS_MULTI2(screen.rend[row][col - 1]))	383	if (IS_MULTI2 (screen.rend[row][col - 1]))
404	m = 1;	384	m = 1;
405	}	385	}
406	else if (screen.cur.row > 0)	386	else if (screen.cur.row > 0)
407	{	387	{
408	col = screen.tlen[--row];	388	col = screen.tlen[--row];
409	if (col == -1)	389	if (col == -1)
410	col = TermWin.ncol - 1;	390	col = TermWin.ncol - 1;
411	else	391	else
412	col--;	392	col--;
413	if (col > 0	393	if (col > 0
414	&& IS_MULTI2(screen.rend[row][col]))	394	&& IS_MULTI2 (screen.rend[row][col]))
415	m = 1;	395	m = 1;
416	}	396	}
417	}	397	}
418	if (m)	398	if (m)
419	MEMMOVE(kbuf + 3, kbuf, 3 + 1);	399	MEMMOVE (kbuf + 3, kbuf, 3 + 1);
420	}	400	}
421	#endif	401	#endif
422	break;	402	break;
423		403
424	#ifndef UNSHIFTED_SCROLLKEYS	404	#ifndef UNSHIFTED_SCROLLKEYS
425	# ifdef XK_KP_Prior	405	# ifdef XK_KP_Prior
426	case XK_KP_Prior:	406	case XK_KP_Prior:
427	/* allow shift to override */	407	/* allow shift to override */
428	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	408	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
429	{	409	{
430	STRCPY(kbuf, "\033Oy");	410	STRCPY (kbuf, "\033Oy");
431	break;	411	break;
432	}	412	}
433	/* FALLTHROUGH */	413	/* FALLTHROUGH */
434	# endif	414	# endif
435	case XK_Prior:	415	case XK_Prior:
436	STRCPY(kbuf, "\033[5~");	416	STRCPY (kbuf, "\033[5~");
437	break;	417	break;
438	# ifdef XK_KP_Next	418	# ifdef XK_KP_Next
439	case XK_KP_Next:	419	case XK_KP_Next:
440	/* allow shift to override */	420	/* allow shift to override */
441	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	421	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
442	{	422	{
443	STRCPY(kbuf, "\033Os");	423	STRCPY (kbuf, "\033Os");
444	break;	424	break;
445	}	425	}
446	/* FALLTHROUGH */	426	/* FALLTHROUGH */
447	# endif	427	# endif
448	case XK_Next:	428	case XK_Next:
449	STRCPY(kbuf, "\033[6~");	429	STRCPY (kbuf, "\033[6~");
450	break;	430	break;
451	#endif	431	#endif
452	case XK_KP_Enter:	432	case XK_KP_Enter:
453	/* allow shift to override */	433	/* allow shift to override */
454	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	434	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
455	{	435	{
456	STRCPY(kbuf, "\033OM");	436	STRCPY (kbuf, "\033OM");
457	}	437	}
458	else	438	else
459	{	439	{
460	kbuf[0] = '\r';	440	kbuf[0] = '\r';
461	kbuf[1] = '\0';	441	kbuf[1] = '\0';
462	}	442	}
463	break;	443	break;
464		444
465	#ifdef XK_KP_Begin	445	#ifdef XK_KP_Begin
466	case XK_KP_Begin:	446	case XK_KP_Begin:
467	STRCPY(kbuf, "\033Ou");	447	STRCPY (kbuf, "\033Ou");
468	break;	448	break;
469		449
470	case XK_KP_Insert:	450	case XK_KP_Insert:
471	STRCPY(kbuf, "\033Op");	451	STRCPY (kbuf, "\033Op");
472	break;	452	break;
473		453
474	case XK_KP_Delete:	454	case XK_KP_Delete:
475	STRCPY(kbuf, "\033On");	455	STRCPY (kbuf, "\033On");
476	break;	456	break;
477	#endif	457	#endif
478	case XK_KP_F1: /* "\033OP" */	458	case XK_KP_F1: /* "\033OP" */
479	case XK_KP_F2: /* "\033OQ" */	459	case XK_KP_F2: /* "\033OQ" */
480	case XK_KP_F3: /* "\033OR" */	460	case XK_KP_F3: /* "\033OR" */
481	case XK_KP_F4: /* "\033OS" */	461	case XK_KP_F4: /* "\033OS" */
482	STRCPY(kbuf, "\033OP");	462	STRCPY (kbuf, "\033OP");
483	kbuf[2] += (keysym - XK_KP_F1);	463	kbuf[2] += (keysym - XK_KP_F1);
484	break;	464	break;
485		465
486	case XK_KP_Multiply: /* "\033Oj" : "*" */	466	case XK_KP_Multiply: /* "\033Oj" : "*" */
487	case XK_KP_Add: /* "\033Ok" : "+" */	467	case XK_KP_Add: /* "\033Ok" : "+" */
488	case XK_KP_Separator: /* "\033Ol" : "," */	468	case XK_KP_Separator: /* "\033Ol" : "," */
489	case XK_KP_Subtract: /* "\033Om" : "-" */	469	case XK_KP_Subtract: /* "\033Om" : "-" */
490	case XK_KP_Decimal: /* "\033On" : "." */	470	case XK_KP_Decimal: /* "\033On" : "." */
491	case XK_KP_Divide: /* "\033Oo" : "/" */	471	case XK_KP_Divide: /* "\033Oo" : "/" */
492	case XK_KP_0: /* "\033Op" : "0" */	472	case XK_KP_0: /* "\033Op" : "0" */
…		…
500	case XK_KP_8: /* "\033Ox" : "8" */	480	case XK_KP_8: /* "\033Ox" : "8" */
501	case XK_KP_9: /* "\033Oy" : "9" */	481	case XK_KP_9: /* "\033Oy" : "9" */
502	/* allow shift to override */	482	/* allow shift to override */
503	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	483	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
504	{	484	{
505	STRCPY(kbuf, "\033Oj");	485	STRCPY (kbuf, "\033Oj");
506	kbuf[2] += (keysym - XK_KP_Multiply);	486	kbuf[2] += (keysym - XK_KP_Multiply);
507	}	487	}
508	else	488	else
509	{	489	{
510	kbuf[0] = ('*' + (keysym - XK_KP_Multiply));	490	kbuf[0] = ('*' + (keysym - XK_KP_Multiply));
511	kbuf[1] = '\0';	491	kbuf[1] = '\0';
512	}	492	}
513	break;	493	break;
514		494
515	case XK_Find:	495	case XK_Find:
516	STRCPY(kbuf, "\033[1~");	496	STRCPY (kbuf, "\033[1~");
517	break;	497	break;
518	case XK_Insert:	498	case XK_Insert:
519	STRCPY(kbuf, "\033[2~");	499	STRCPY (kbuf, "\033[2~");
520	break;	500	break;
521	#ifdef DXK_Remove /* support for DEC remove like key */	501	#ifdef DXK_Remove /* support for DEC remove like key */
522	case DXK_Remove:	502	case DXK_Remove:
523	/* FALLTHROUGH */	503	/* FALLTHROUGH */
524	#endif	504	#endif
525	case XK_Execute:	505	case XK_Execute:
526	STRCPY(kbuf, "\033[3~");	506	STRCPY (kbuf, "\033[3~");
527	break;	507	break;
528	case XK_Select:	508	case XK_Select:
529	STRCPY(kbuf, "\033[4~");	509	STRCPY (kbuf, "\033[4~");
530	break;	510	break;
531	#ifdef XK_KP_End	511	#ifdef XK_KP_End
532	case XK_KP_End:	512	case XK_KP_End:
533	/* allow shift to override */	513	/* allow shift to override */
534	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	514	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
535	{	515	{
536	STRCPY(kbuf, "\033Oq");	516	STRCPY (kbuf, "\033Oq");
537	break;	517	break;
538	}	518	}
539	/* FALLTHROUGH */	519	/* FALLTHROUGH */
540	#endif	520	#endif
541	case XK_End:	521	case XK_End:
542	STRCPY(kbuf, KS_END);	522	STRCPY (kbuf, KS_END);
543	break;	523	break;
544	#ifdef XK_KP_Home	524	#ifdef XK_KP_Home
545	case XK_KP_Home:	525	case XK_KP_Home:
546	/* allow shift to override */	526	/* allow shift to override */
547	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	527	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
548	{	528	{
549	STRCPY(kbuf, "\033Ow");	529	STRCPY (kbuf, "\033Ow");
550	break;	530	break;
551	}	531	}
552	/* FALLTHROUGH */	532	/* FALLTHROUGH */
553	#endif	533	#endif
554	case XK_Home:	534	case XK_Home:
555	STRCPY(kbuf, KS_HOME);	535	STRCPY (kbuf, KS_HOME);
556	break;	536	break;
557		537
558	#define FKEY(n, fkey) \	538	#define FKEY(n, fkey) \
559	sprintf((char *)kbuf,"\033[%2d~", (int)((n) + (keysym - fkey)))	539	sprintf ((char *)kbuf,"\033[%2d~", (int) ((n) + (keysym - fkey)))
560		540
561	case XK_F1: /* "\033[11~" */	541	case XK_F1: /* "\033[11~" */
562	case XK_F2: /* "\033[12~" */	542	case XK_F2: /* "\033[12~" */
563	case XK_F3: /* "\033[13~" */	543	case XK_F3: /* "\033[13~" */
564	case XK_F4: /* "\033[14~" */	544	case XK_F4: /* "\033[14~" */
565	case XK_F5: /* "\033[15~" */	545	case XK_F5: /* "\033[15~" */
566	FKEY(11, XK_F1);	546	FKEY (11, XK_F1);
567	break;	547	break;
568	case XK_F6: /* "\033[17~" */	548	case XK_F6: /* "\033[17~" */
569	case XK_F7: /* "\033[18~" */	549	case XK_F7: /* "\033[18~" */
570	case XK_F8: /* "\033[19~" */	550	case XK_F8: /* "\033[19~" */
571	case XK_F9: /* "\033[20~" */	551	case XK_F9: /* "\033[20~" */
572	case XK_F10: /* "\033[21~" */	552	case XK_F10: /* "\033[21~" */
573	FKEY(17, XK_F6);	553	FKEY (17, XK_F6);
574	break;	554	break;
575	case XK_F11: /* "\033[23~" */	555	case XK_F11: /* "\033[23~" */
576	case XK_F12: /* "\033[24~" */	556	case XK_F12: /* "\033[24~" */
577	case XK_F13: /* "\033[25~" */	557	case XK_F13: /* "\033[25~" */
578	case XK_F14: /* "\033[26~" */	558	case XK_F14: /* "\033[26~" */
579	FKEY(23, XK_F11);	559	FKEY (23, XK_F11);
580	break;	560	break;
581	case XK_F15: /* "\033[28~" */	561	case XK_F15: /* "\033[28~" */
582	case XK_F16: /* "\033[29~" */	562	case XK_F16: /* "\033[29~" */
583	FKEY(28, XK_F15);	563	FKEY (28, XK_F15);
584	break;	564	break;
585	case XK_Help: /* "\033[28~" */	565	case XK_Help: /* "\033[28~" */
586	FKEY(28, XK_Help);	566	FKEY (28, XK_Help);
587	break;	567	break;
588	case XK_Menu: /* "\033[29~" */	568	case XK_Menu: /* "\033[29~" */
589	FKEY(29, XK_Menu);	569	FKEY (29, XK_Menu);
590	break;	570	break;
591	case XK_F17: /* "\033[31~" */	571	case XK_F17: /* "\033[31~" */
592	case XK_F18: /* "\033[32~" */	572	case XK_F18: /* "\033[32~" */
593	case XK_F19: /* "\033[33~" */	573	case XK_F19: /* "\033[33~" */
594	case XK_F20: /* "\033[34~" */	574	case XK_F20: /* "\033[34~" */
…		…
605	case XK_F31: /* "\033[45~" */	585	case XK_F31: /* "\033[45~" */
606	case XK_F32: /* "\033[46~" */	586	case XK_F32: /* "\033[46~" */
607	case XK_F33: /* "\033[47~" */	587	case XK_F33: /* "\033[47~" */
608	case XK_F34: /* "\033[48~" */	588	case XK_F34: /* "\033[48~" */
609	case XK_F35: /* "\033[49~" */	589	case XK_F35: /* "\033[49~" */
610	FKEY(31, XK_F17);	590	FKEY (31, XK_F17);
611	break;	591	break;
612	#undef FKEY	592	#undef FKEY
613	default:	593	default:
614	newlen = 0;	594	newlen = 0;
615	break;	595	break;
616	}	596	}
617	if (newlen)	597	if (newlen)
618	len = STRLEN(kbuf);	598	len = STRLEN (kbuf);
619	}	599	}
620	/*	600	/*
621	* Pass meta for all function keys, if 'meta' option set	601	* Pass meta for all function keys, if 'meta' option set
622	*/	602	*/
623	#ifdef META8_OPTION	603	#ifdef META8_OPTION
…		…
641		621
642	for (ch = kbuf; ch < kbuf + len; ch++)	622	for (ch = kbuf; ch < kbuf + len; ch++)
643	*ch |= 0x80;	623	*ch |= 0x80;
644	meta = 0;	624	meta = 0;
645	}	625	}
646	#endif
647	#ifdef GREEK_SUPPORT
648	if (greek_mode)
649	len = greek_xlat(kbuf, len);
650	#endif	626	#endif
651	/* nil */ ;	627	/* nil */ ;
652	}	628	}
653	}	629	}
654		630
…		…
683	#endif	659	#endif
684	)	660	)
685	{	661	{
686	const unsigned char ch = C0_ESC;	662	const unsigned char ch = C0_ESC;
687		663
688	tt_write(&ch, 1);	664	tt_write (&ch, 1);
689	}	665	}
690	#ifdef DEBUG_CMD	666	#ifdef DEBUG_CMD
691	if (debug_key)	667	if (debug_key)
692	{ /* Display keyboard buffer contents */	668	{ /* Display keyboard buffer contents */
693	char *p;	669	char *p;
694	int i;	670	int i;
695		671
696	fprintf(stderr, "key 0x%04X [%d]: `", (unsigned int)keysym, len);	672	fprintf (stderr, "key 0x%04X [%d]: `", (unsigned int)keysym, len);
697	for (i = 0, p = kbuf; i < len; i++, p++)	673	for (i = 0, p = kbuf; i < len; i++, p++)
698	fprintf(stderr, (*p >= ' ' && *p < '\177' ? "%c" : "\\%03o"), *p);	674	fprintf (stderr, (*p >= ' ' && *p < '\177' ? "%c" : "\\%03o"), *p);
699	fprintf(stderr, "'\n");	675	fprintf (stderr, "'\n");
700	}	676	}
701	#endif /* DEBUG_CMD */	677	#endif /* DEBUG_CMD */
702	tt_write (kbuf, (unsigned int)len);	678	tt_write (kbuf, (unsigned int)len);
703	}	679	}
704	/*}}} */	680	/*}}} */
705		681
706	#if (MENUBAR_MAX)	682	#if (MENUBAR_MAX)
707	/*{{{ rxvt_cmd_write(), rxvt_cmd_getc() */	683	/*{{{ rxvt_cmd_write (), rxvt_cmd_getc () */
708	/* attempt to `write' count to the input buffer */	684	/* attempt to `write' count to the input buffer */
709	unsigned int	685	unsigned int
710	rxvt_term::cmd_write (const unsigned char *str, unsigned int count)	686	rxvt_term::cmd_write (const unsigned char *str, unsigned int count)
711	{	687	{
712	unsigned int n, s;	688	unsigned int n, s;
713		689
714	n = cmdbuf_ptr - cmdbuf_base;	690	n = cmdbuf_ptr - cmdbuf_base;
715	s = cmdbuf_base + BUFSIZ - 1 - cmdbuf_endp;	691	s = cmdbuf_base + BUFSIZ - 1 - cmdbuf_endp;
716	if (n > 0 && s < count)	692	if (n > 0 && s < count)
717	{	693	{
718	MEMMOVE(cmdbuf_base, cmdbuf_ptr,	694	MEMMOVE (cmdbuf_base, cmdbuf_ptr,
719	(unsigned int)(cmdbuf_endp - cmdbuf_ptr));	695	(unsigned int) (cmdbuf_endp - cmdbuf_ptr));
720	cmdbuf_ptr = cmdbuf_base;	696	cmdbuf_ptr = cmdbuf_base;
721	cmdbuf_endp -= n;	697	cmdbuf_endp -= n;
722	s += n;	698	s += n;
723	}	699	}
724	if (count > s)	700	if (count > s)
725	{	701	{
726	rxvt_print_error("data loss: cmd_write too large");	702	rxvt_print_error ("data loss: cmd_write too large");
727	count = s;	703	count = s;
728	}	704	}
729	for (; count--;)	705	for (; count--;)
730	*cmdbuf_endp++ = *str++;	706	*cmdbuf_endp++ = *str++;
731	return 0;	707	return 0;
…		…
869	if (ch == '\n')	845	if (ch == '\n')
870	{	846	{
871	nlines++;	847	nlines++;
872	refresh_count++;	848	refresh_count++;
873		849
874	if (!(Options & Opt_jumpScroll)	850	if (! (Options & Opt_jumpScroll)
875	|| (refresh_count >= (refresh_limit * (TermWin.nrow - 1))))	851	|| (refresh_count >= (refresh_limit * (TermWin.nrow - 1))))
876	{	852	{
877	refreshnow = true;	853	refreshnow = true;
878	flag = false;	854	flag = false;
879	ch = NOCHAR;	855	ch = NOCHAR;
…		…
947	{	923	{
948	if (*cmdbuf_ptr < 0x80) // assume < 0x80 to be ascii ALWAYS (all shift-states etc.) uh-oh	924	if (*cmdbuf_ptr < 0x80) // assume < 0x80 to be ascii ALWAYS (all shift-states etc.) uh-oh
949	return *cmdbuf_ptr++;	925	return *cmdbuf_ptr++;
950		926
951	wchar_t wc;	927	wchar_t wc;
952	size_t len = mbrtowc (&wc, (char *)cmdbuf_ptr, cmdbuf_endp - cmdbuf_ptr, &mbstate.mbs);	928	size_t len = mbrtowc (&wc, (char *)cmdbuf_ptr, cmdbuf_endp - cmdbuf_ptr, mbstate);
953		929
954	if (len == (size_t)-2)	930	if (len == (size_t)-2)
955	return NOCHAR;	931	return NOCHAR;
956		932
957	if (len == (size_t)-1)	933	if (len == (size_t)-1)
…		…
963	}	939	}
964		940
965	return NOCHAR;	941	return NOCHAR;
966	}	942	}
967		943
968	/* rxvt_cmd_getc() - Return next input character */	944	/* rxvt_cmd_getc () - Return next input character */
969	/*	945	/*
970	* Return the next input character after first passing any keyboard input	946	* Return the next input character after first passing any keyboard input
971	* to the command.	947	* to the command.
972	*/	948	*/
973	uint32_t	949	uint32_t
…		…
1001	}	977	}
1002		978
1003	void	979	void
1004	rxvt_term::pointer_blank ()	980	rxvt_term::pointer_blank ()
1005	{	981	{
1006	if (!(Options & Opt_pointerBlank))	982	if (! (Options & Opt_pointerBlank))
1007	return;	983	return;
1008		984
1009	XDefineCursor (display->display, TermWin.vt, blank_cursor);	985	XDefineCursor (display->display, TermWin.vt, blank_cursor);
1010	XFlush (display->display);	986	XFlush (display->display);
1011		987
…		…
1071	#endif	1047	#endif
1072		1048
1073	}	1049	}
1074		1050
1075	#ifdef DEBUG_MOUSEREPORT	1051	#ifdef DEBUG_MOUSEREPORT
1076	fprintf(stderr, "Mouse [");	1052	fprintf (stderr, "Mouse [");
1077	if (key_state & 16)	1053	if (key_state & 16)
1078	fputc('C', stderr);	1054	fputc ('C', stderr);
1079	if (key_state & 4)	1055	if (key_state & 4)
1080	fputc('S', stderr);	1056	fputc ('S', stderr);
1081	if (key_state & 8)	1057	if (key_state & 8)
1082	fputc('A', stderr);	1058	fputc ('A', stderr);
1083	if (key_state & 32)	1059	if (key_state & 32)
1084	fputc('2', stderr);	1060	fputc ('2', stderr);
1085	fprintf(stderr, "]: <%d>, %d/%d\n",	1061	fprintf (stderr, "]: <%d>, %d/%d\n",
1086	button_number,	1062	button_number,
1087	x + 1,	1063	x + 1,
1088	y + 1);	1064	y + 1);
1089	#else	1065	#else
1090	tt_printf("\033[M%c%c%c",	1066	tt_printf ("\033[M%c%c%c",
1091	(32 + button_number + key_state),	1067	(32 + button_number + key_state),
1092	(32 + x + 1),	1068	(32 + x + 1),
1093	(32 + y + 1));	1069	(32 + y + 1));
1094	#endif	1070	#endif
1095	}	1071	}
1096		1072
1097	#ifdef USING_W11LIB	1073	#ifdef USING_W11LIB
1098	void	1074	void
1099	rxvt_W11_process_x_event(XEvent *ev)	1075	rxvt_W11_process_x_event (XEvent *ev)
1100	{	1076	{
1101	rxvt_t *r = rxvt_get_r();	1077	rxvt_t *r = rxvt_get_r ();
1102		1078
1103	x_cb (*ev);	1079	x_cb (*ev);
1104	}	1080	}
1105	#endif	1081	#endif
1106		1082
…		…
1189	#endif	1165	#endif
1190		1166
1191	#ifdef DEBUG_X	1167	#ifdef DEBUG_X
1192	struct timeval tp;	1168	struct timeval tp;
1193	struct tm *ltt;	1169	struct tm *ltt;
1194	(void)gettimeofday(&tp, NULL);	1170	(void)gettimeofday (&tp, NULL);
1195	ltt = localtime(&(tp.tv_sec));	1171	ltt = localtime (& (tp.tv_sec));
1196	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));	1172	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));
1197	#endif	1173	#endif
1198		1174
1199	switch (ev.type)	1175	switch (ev.type)
1200	{	1176	{
1201	case KeyPress:	1177	case KeyPress:
…		…
1203	break;	1179	break;
1204		1180
1205	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)	1181	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
1206	case KeyRelease:	1182	case KeyRelease:
1207	{	1183	{
1208	if (!(ev.xkey.state & ControlMask))	1184	if (! (ev.xkey.state & ControlMask))
1209	mouse_slip_wheel_speed = 0;	1185	mouse_slip_wheel_speed = 0;
1210	else	1186	else
1211	{	1187	{
1212	KeySym ks;	1188	KeySym ks;
1213		1189
1214	ks = XKeycodeToKeysym(display->display, ev.xkey.keycode, 0);	1190	ks = XKeycodeToKeysym (display->display, ev.xkey.keycode, 0);
1215	if (ks == XK_Control_L || ks == XK_Control_R)	1191	if (ks == XK_Control_L || ks == XK_Control_R)
1216	mouse_slip_wheel_speed = 0;	1192	mouse_slip_wheel_speed = 0;
1217	}	1193	}
1218	break;	1194	break;
1219	}	1195	}
…		…
1242	Atom ActualType;	1218	Atom ActualType;
1243	int ActualFormat;	1219	int ActualFormat;
1244	unsigned char *data;	1220	unsigned char *data;
1245	unsigned long Size, RemainingBytes;	1221	unsigned long Size, RemainingBytes;
1246		1222
1247	XGetWindowProperty(display->display, display->root,	1223	XGetWindowProperty (display->display, display->root,
1248	xa[XA_DNDSELECTION],	1224	xa[XA_DNDSELECTION],
1249	0L, 1000000L,	1225	0L, 1000000L,
1250	False, AnyPropertyType,	1226	False, AnyPropertyType,
1251	&ActualType, &ActualFormat,	1227	&ActualType, &ActualFormat,
1252	&Size, &RemainingBytes,	1228	&Size, &RemainingBytes,
1253	&data);	1229	&data);
1254	XChangeProperty(display->display, display->root,	1230	XChangeProperty (display->display, display->root,
1255	XA_CUT_BUFFER0, XA_STRING,	1231	XA_CUT_BUFFER0, XA_STRING,
1256	8, PropModeReplace,	1232	8, PropModeReplace,
1257	data, STRLEN(data));	1233	data, STRLEN (data));
1258	selection_paste (display->root, XA_CUT_BUFFER0, True);	1234	selection_paste (display->root, XA_CUT_BUFFER0, True);
1259	XSetInputFocus(display->display, display->root, RevertToNone, CurrentTime);	1235	XSetInputFocus (display->display, display->root, RevertToNone, CurrentTime);
1260	}	1236	}
1261	#endif /* OFFIX_DND */	1237	#endif /* OFFIX_DND */
1262	break;	1238	break;
1263		1239
1264	case MappingNotify:	1240	case MappingNotify:
1265	XRefreshKeyboardMapping(&(ev.xmapping));	1241	XRefreshKeyboardMapping (& (ev.xmapping));
1266	break;	1242	break;
1267		1243
1268	/*	1244	/*
1269	* XXX: this is not the _current_ arrangement	1245	* XXX: this is not the _current_ arrangement
1270	* Here's my conclusion:	1246	* Here's my conclusion:
…		…
1295	{	1271	{
1296	TermWin.focus = 1;	1272	TermWin.focus = 1;
1297	want_refresh = 1;	1273	want_refresh = 1;
1298	#ifdef USE_XIM	1274	#ifdef USE_XIM
1299	if (Input_Context != NULL)	1275	if (Input_Context != NULL)
1300	XSetICFocus(Input_Context);	1276	XSetICFocus (Input_Context);
1301	#endif	1277	#endif
1302	#ifdef CURSOR_BLINK	1278	#ifdef CURSOR_BLINK
1303	if (Options & Opt_cursorBlink)	1279	if (Options & Opt_cursorBlink)
1304	cursor_blink_ev.start (NOW + BLINK_INTERVAL);	1280	cursor_blink_ev.start (NOW + BLINK_INTERVAL);
1305	#endif	1281	#endif
…		…
1312	{	1288	{
1313	TermWin.focus = 0;	1289	TermWin.focus = 0;
1314	want_refresh = 1;	1290	want_refresh = 1;
1315	#ifdef USE_XIM	1291	#ifdef USE_XIM
1316	if (Input_Context != NULL)	1292	if (Input_Context != NULL)
1317	XUnsetICFocus(Input_Context);	1293	XUnsetICFocus (Input_Context);
1318	#endif	1294	#endif
1319	#ifdef CURSOR_BLINK	1295	#ifdef CURSOR_BLINK
1320	if (Options & Opt_cursorBlink)	1296	if (Options & Opt_cursorBlink)
1321	cursor_blink_ev.stop ();	1297	cursor_blink_ev.stop ();
1322	hidden_cursor = 0;	1298	hidden_cursor = 0;
…		…
1332		1308
1333	do	1309	do
1334	{ /* Wrap lots of configures into one */	1310	{ /* Wrap lots of configures into one */
1335	width = ev.xconfigure.width;	1311	width = ev.xconfigure.width;
1336	height = ev.xconfigure.height;	1312	height = ev.xconfigure.height;
1337	D_SIZE((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));	1313	D_SIZE ((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));
1338	}	1314	}
1339	while (XCheckTypedWindowEvent(display->display, ev.xconfigure.window, ConfigureNotify, &ev));	1315	while (XCheckTypedWindowEvent (display->display, ev.xconfigure.window, ConfigureNotify, &ev));
1340		1316
1341	if (szHint.width != width || szHint.height != height)	1317	if (szHint.width != width || szHint.height != height)
1342	{	1318	{
1343	D_SIZE((stderr, "Size: Resizing from: %4d x %4d", szHint.width, szHint.height));	1319	D_SIZE ((stderr, "Size: Resizing from: %4d x %4d", szHint.width, szHint.height));
1344	resize_all_windows (width, height, 1);	1320	resize_all_windows (width, height, 1);
1345	}	1321	}
1346	#ifdef DEBUG_SIZE	1322	#ifdef DEBUG_SIZE
1347	else	1323	else
1348	{	1324	{
1349	D_SIZE((stderr, "Size: Not resizing"));	1325	D_SIZE ((stderr, "Size: Not resizing"));
1350	}	1326	}
1351	#endif	1327	#endif
1352	#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */	1328	#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */
1353	if (Options & Opt_transparent)	1329	if (Options & Opt_transparent)
1354	{	1330	{
…		…
1413	}	1389	}
1414	else	1390	else
1415	{	1391	{
1416	XEvent unused_event;	1392	XEvent unused_event;
1417		1393
1418	while (XCheckTypedWindowEvent(display->display, ev.xany.window,	1394	while (XCheckTypedWindowEvent (display->display, ev.xany.window,
1419	Expose,	1395	Expose,
1420	&unused_event)) ;	1396	&unused_event)) ;
1421	while (XCheckTypedWindowEvent(display->display, ev.xany.window,	1397	while (XCheckTypedWindowEvent (display->display, ev.xany.window,
1422	GraphicsExpose,	1398	GraphicsExpose,
1423	&unused_event)) ;	1399	&unused_event)) ;
1424	if (isScrollbarWindow(ev.xany.window))	1400	if (isScrollbarWindow (ev.xany.window))
1425	{	1401	{
1426	scrollBar.setIdle();	1402	scrollBar.setIdle ();
1427	scrollbar_show (0);	1403	scrollbar_show (0);
1428	}	1404	}
1429	#ifdef MENUBAR	1405	#ifdef MENUBAR
1430	if (menubar_visible () && isMenuBarWindow(ev.xany.window))	1406	if (menubar_visible () && isMenuBarWindow (ev.xany.window))
1431	menubar_expose ();	1407	menubar_expose ();
1432	#endif	1408	#endif
1433	#ifdef RXVT_GRAPHICS
1434	Gr_expose (ev.xany.window);
1435	#endif
1436
1437	}	1409	}
1438	break;	1410	break;
1439		1411
1440	case MotionNotify:	1412	case MotionNotify:
1441	#ifdef POINTER_BLANK	1413	#ifdef POINTER_BLANK
1442	if (hidden_pointer)	1414	if (hidden_pointer)
1443	pointer_unblank ();	1415	pointer_unblank ();
1444	#endif	1416	#endif
1445	#if MENUBAR	1417	#if MENUBAR
1446	if (isMenuBarWindow(ev.xany.window))	1418	if (isMenuBarWindow (ev.xany.window))
1447	{	1419	{
1448	menubar_control (&(ev.xbutton));	1420	menubar_control (& (ev.xbutton));
1449	break;	1421	break;
1450	}	1422	}
1451	#endif	1423	#endif
1452	if ((PrivateModes & PrivMode_mouse_report) && !(bypass_keystate))	1424	if ((PrivateModes & PrivMode_mouse_report) && ! (bypass_keystate))
1453	break;	1425	break;
1454		1426
1455	if (ev.xany.window == TermWin.vt)	1427	if (ev.xany.window == TermWin.vt)
1456	{	1428	{
1457	if ((ev.xbutton.state & (Button1Mask | Button3Mask)))	1429	if ((ev.xbutton.state & (Button1Mask | Button3Mask)))
1458	{	1430	{
1459	while (XCheckTypedWindowEvent (display->display, TermWin.vt, MotionNotify, &ev))	1431	while (XCheckTypedWindowEvent (display->display, TermWin.vt, MotionNotify, &ev))
1460	;	1432	;
1461		1433
1462	XQueryPointer(display->display, TermWin.vt,	1434	XQueryPointer (display->display, TermWin.vt,
1463	&unused_root, &unused_child,	1435	&unused_root, &unused_child,
1464	&unused_root_x, &unused_root_y,	1436	&unused_root_x, &unused_root_y,
1465	&(ev.xbutton.x), &(ev.xbutton.y),	1437	& (ev.xbutton.x), & (ev.xbutton.y),
1466	&unused_mask);	1438	&unused_mask);
1467	#ifdef MOUSE_THRESHOLD	1439	#ifdef MOUSE_THRESHOLD
1468	/* deal with a `jumpy' mouse */	1440	/* deal with a `jumpy' mouse */
1469	if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)	1441	if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)
1470	{	1442	{
1471	#endif	1443	#endif
1472	selection_extend ((ev.xbutton.x), (ev.xbutton.y),	1444	selection_extend ((ev.xbutton.x), (ev.xbutton.y),
1473	(ev.xbutton.state & Button3Mask) ? 2 : 0);	1445	(ev.xbutton.state & Button3Mask) ? 2 : 0);
1474	#ifdef SELECTION_SCROLLING	1446	#ifdef SELECTION_SCROLLING
1475	if (ev.xbutton.y < TermWin.int_bwidth	1447	if (ev.xbutton.y < TermWin.int_bwidth
1476	|| Pixel2Row(ev.xbutton.y) > (TermWin.nrow-1))	1448	|| Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))
1477	{	1449	{
1478	int dist;	1450	int dist;
1479		1451
1480	pending_scroll_selection=1;	1452	pending_scroll_selection=1;
1481		1453
…		…
1503	{	1475	{
1504	scroll_selection_dir = DN;	1476	scroll_selection_dir = DN;
1505	dist = ev.xbutton.y -	1477	dist = ev.xbutton.y -
1506	(TermWin.int_bwidth + TermWin.height);	1478	(TermWin.int_bwidth + TermWin.height);
1507	}	1479	}
1508	scroll_selection_lines=(Pixel2Height(dist)/	1480	scroll_selection_lines= (Pixel2Height (dist)/
1509	SELECTION_SCROLL_LINE_SPEEDUP)+1;	1481	SELECTION_SCROLL_LINE_SPEEDUP)+1;
1510	MIN_IT(scroll_selection_lines,	1482	MIN_IT (scroll_selection_lines,
1511	SELECTION_SCROLL_MAX_LINES);	1483	SELECTION_SCROLL_MAX_LINES);
1512	}	1484	}
1513	else	1485	else
1514	{	1486	{
1515	/* we are within the text window, so we	1487	/* we are within the text window, so we
…		…
1523	}	1495	}
1524	#endif	1496	#endif
1525		1497
1526	}	1498	}
1527	}	1499	}
1528	else if (isScrollbarWindow(ev.xany.window) && scrollbar_isMotion())	1500	else if (isScrollbarWindow (ev.xany.window) && scrollbar_isMotion ())
1529	{	1501	{
1530	while (XCheckTypedWindowEvent(display->display, scrollBar.win,	1502	while (XCheckTypedWindowEvent (display->display, scrollBar.win,
1531	MotionNotify, &ev)) ;	1503	MotionNotify, &ev)) ;
1532	XQueryPointer(display->display, scrollBar.win,	1504	XQueryPointer (display->display, scrollBar.win,
1533	&unused_root, &unused_child,	1505	&unused_root, &unused_child,
1534	&unused_root_x, &unused_root_y,	1506	&unused_root_x, &unused_root_y,
1535	&(ev.xbutton.x), &(ev.xbutton.y),	1507	& (ev.xbutton.x), & (ev.xbutton.y),
1536	&unused_mask);	1508	&unused_mask);
1537	scr_move_to (scrollbar_position(ev.xbutton.y) - csrO,	1509	scr_move_to (scrollbar_position (ev.xbutton.y) - csrO,
1538	scrollbar_size());	1510	scrollbar_size ());
1539	scr_refresh (refresh_type);	1511	scr_refresh (refresh_type);
1540	refresh_limit = 0;	1512	refresh_limit = 0;
1541	scrollbar_show (1);	1513	scrollbar_show (1);
1542	}	1514	}
1543	break;	1515	break;
…		…
1565	/*	1537	/*
1566	* if user used some Esetroot compatible prog to set the root bg,	1538	* if user used some Esetroot compatible prog to set the root bg,
1567	* use the property to determine the pixmap. We use it later on.	1539	* use the property to determine the pixmap. We use it later on.
1568	*/	1540	*/
1569	if (xa[XA_XROOTPMAPID] == 0)	1541	if (xa[XA_XROOTPMAPID] == 0)
1570	xa[XA_XROOTPMAPID] = XInternAtom(display->display, "_XROOTPMAP_ID", False);	1542	xa[XA_XROOTPMAPID] = XInternAtom (display->display, "_XROOTPMAP_ID", False);
1571		1543
1572	if (ev.xproperty.atom != xa[XA_XROOTPMAPID])	1544	if (ev.xproperty.atom != xa[XA_XROOTPMAPID])
1573	return;	1545	return;
1574	}	1546	}
1575		1547
…		…
1588	{	1560	{
1589	int reportmode = 0, clickintime;	1561	int reportmode = 0, clickintime;
1590		1562
1591	bypass_keystate = ev.state & (ModMetaMask | ShiftMask);	1563	bypass_keystate = ev.state & (ModMetaMask | ShiftMask);
1592	if (!bypass_keystate)	1564	if (!bypass_keystate)
1593	reportmode = !!(PrivateModes & PrivMode_mouse_report);	1565	reportmode = !! (PrivateModes & PrivMode_mouse_report);
1594	/*	1566	/*
1595	* VT window processing of button press	1567	* VT window processing of button press
1596	*/	1568	*/
1597	if (ev.window == TermWin.vt)	1569	if (ev.window == TermWin.vt)
1598	{	1570	{
1599	#if RXVT_GRAPHICS
1600	if (ev.subwindow != None)
1601	rxvt_Gr_ButtonPress (ev.x, ev.y);
1602	else
1603	#endif
1604
1605	{
1606	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;	1571	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;
1607	if (reportmode)	1572	if (reportmode)
		1573	{
		1574	/* mouse report from vt window */
		1575	/* save the xbutton state (for ButtonRelease) */
		1576	MEvent.state = ev.state;
		1577	#ifdef MOUSE_REPORT_DOUBLECLICK
		1578	if (ev.button == MEvent.button && clickintime)
1608	{	1579	{
1609	/* mouse report from vt window */	1580	/* same button, within alloted time */
1610	/* save the xbutton state (for ButtonRelease) */	1581	MEvent.clicks++;
1611	MEvent.state = ev.state;	1582	if (MEvent.clicks > 1)
1612	#ifdef MOUSE_REPORT_DOUBLECLICK
1613	if (ev.button == MEvent.button && clickintime)
1614	{	1583	{
1615	/* same button, within alloted time */
1616	MEvent.clicks++;
1617	if (MEvent.clicks > 1)
1618	{
1619	/* only report double clicks */	1584	/* only report double clicks */
1620	MEvent.clicks = 2;	1585	MEvent.clicks = 2;
1621	mouse_report (ev);	1586	mouse_report (ev);
1622		1587
1623	/* don't report the release */	1588	/* don't report the release */
1624	MEvent.clicks = 0;	1589	MEvent.clicks = 0;
1625	MEvent.button = AnyButton;	1590	MEvent.button = AnyButton;
1626	}
1627	}	1591	}
1628	else
1629	{
1630	/* different button, or time expired */
1631	MEvent.clicks = 1;
1632	MEvent.button = ev.button;
1633	mouse_report (ev);
1634	}
1635	#else
1636	MEvent.button = ev.button;
1637	mouse_report (ev);
1638	#endif /* MOUSE_REPORT_DOUBLECLICK */
1639
1640	}	1592	}
1641	else	1593	else
1642	{	1594	{
		1595	/* different button, or time expired */
		1596	MEvent.clicks = 1;
		1597	MEvent.button = ev.button;
		1598	mouse_report (ev);
		1599	}
		1600	#else
		1601	MEvent.button = ev.button;
		1602	mouse_report (ev);
		1603	#endif /* MOUSE_REPORT_DOUBLECLICK */
		1604
		1605	}
		1606	else
		1607	{
1643	if (ev.button != MEvent.button)	1608	if (ev.button != MEvent.button)
1644	MEvent.clicks = 0;	1609	MEvent.clicks = 0;
1645	switch (ev.button)	1610	switch (ev.button)
1646	{	1611	{
1647	case Button1:	1612	case Button1:
1648	/* allow shift+left click to extend selection */	1613	/* allow shift+left click to extend selection */
1649	if (ev.state & ShiftMask && !(PrivateModes & PrivMode_mouse_report))	1614	if (ev.state & ShiftMask && ! (PrivateModes & PrivMode_mouse_report))
1650	{	1615	{
1651	if (MEvent.button == Button1 && clickintime)
1652	selection_rotate (ev.x, ev.y);
1653	else
1654	selection_extend (ev.x, ev.y, 1);
1655	}
1656	else
1657	{
1658	if (MEvent.button == Button1 && clickintime)
1659	MEvent.clicks++;
1660	else
1661	MEvent.clicks = 1;
1662
1663	selection_click (MEvent.clicks, ev.x, ev.y);
1664	}
1665
1666	MEvent.button = Button1;
1667	break;
1668
1669	case Button3:
1670	if (MEvent.button == Button3 && clickintime)	1616	if (MEvent.button == Button1 && clickintime)
1671	selection_rotate (ev.x, ev.y);	1617	selection_rotate (ev.x, ev.y);
1672	else	1618	else
1673	selection_extend (ev.x, ev.y, 1);	1619	selection_extend (ev.x, ev.y, 1);
		1620	}
		1621	else
		1622	{
		1623	if (MEvent.button == Button1 && clickintime)
		1624	MEvent.clicks++;
		1625	else
		1626	MEvent.clicks = 1;
		1627
		1628	selection_click (MEvent.clicks, ev.x, ev.y);
		1629	}
		1630
		1631	MEvent.button = Button1;
		1632	break;
		1633
		1634	case Button3:
		1635	if (MEvent.button == Button3 && clickintime)
		1636	selection_rotate (ev.x, ev.y);
		1637	else
		1638	selection_extend (ev.x, ev.y, 1);
1674	MEvent.button = Button3;	1639	MEvent.button = Button3;
1675	break;	1640	break;
1676	}
1677	}	1641	}
		1642	}
1678	MEvent.time = ev.time;	1643	MEvent.time = ev.time;
1679	return;	1644	return;
1680	}
1681	}	1645	}
1682		1646
1683	/*	1647	/*
1684	* Scrollbar window processing of button press	1648	* Scrollbar window processing of button press
1685	*/	1649	*/
1686	if (isScrollbarWindow(ev.window))	1650	if (isScrollbarWindow (ev.window))
1687	{	1651	{
1688	scrollBar.setIdle ();	1652	scrollBar.setIdle ();
1689	/*	1653	/*
1690	* Rxvt-style scrollbar:	1654	* Rxvt-style scrollbar:
1691	* move up if mouse is above slider	1655	* move up if mouse is above slider
…		…
1703	* Mouse report disabled scrollbar:	1667	* Mouse report disabled scrollbar:
1704	* arrow buttons - send up/down	1668	* arrow buttons - send up/down
1705	* click on scrollbar - send pageup/down	1669	* click on scrollbar - send pageup/down
1706	*/	1670	*/
1707	if ((scrollBar.style == R_SB_NEXT	1671	if ((scrollBar.style == R_SB_NEXT
1708	&& scrollbarnext_upButton(ev.y))	1672	&& scrollbarnext_upButton (ev.y))
1709	|| (scrollBar.style == R_SB_RXVT	1673	|| (scrollBar.style == R_SB_RXVT
1710	&& scrollbarrxvt_upButton(ev.y)))	1674	&& scrollbarrxvt_upButton (ev.y)))
1711	tt_printf("\033[A");	1675	tt_printf ("\033[A");
1712	else if ((scrollBar.style == R_SB_NEXT	1676	else if ((scrollBar.style == R_SB_NEXT
1713	&& scrollbarnext_dnButton(ev.y))	1677	&& scrollbarnext_dnButton (ev.y))
1714	|| (scrollBar.style == R_SB_RXVT	1678	|| (scrollBar.style == R_SB_RXVT
1715	&& scrollbarrxvt_dnButton(ev.y)))	1679	&& scrollbarrxvt_dnButton (ev.y)))
1716	tt_printf("\033[B");	1680	tt_printf ("\033[B");
1717	else	1681	else
1718	switch (ev.button)	1682	switch (ev.button)
1719	{	1683	{
1720	case Button2:	1684	case Button2:
1721	tt_printf("\014");	1685	tt_printf ("\014");
1722	break;	1686	break;
1723	case Button1:	1687	case Button1:
1724	tt_printf("\033[6~");	1688	tt_printf ("\033[6~");
1725	break;	1689	break;
1726	case Button3:	1690	case Button3:
1727	tt_printf("\033[5~");	1691	tt_printf ("\033[5~");
1728	break;	1692	break;
1729	}	1693	}
1730	}	1694	}
1731	else	1695	else
1732	#endif /* NO_SCROLLBAR_REPORT */	1696	#endif /* NO_SCROLLBAR_REPORT */
…		…
1734	{	1698	{
1735	char upordown = 0;	1699	char upordown = 0;
1736		1700
1737	if (scrollBar.style == R_SB_NEXT)	1701	if (scrollBar.style == R_SB_NEXT)
1738	{	1702	{
1739	if (scrollbarnext_upButton(ev.y))	1703	if (scrollbarnext_upButton (ev.y))
1740	upordown = -1; /* up */	1704	upordown = -1; /* up */
1741	else if (scrollbarnext_dnButton(ev.y))	1705	else if (scrollbarnext_dnButton (ev.y))
1742	upordown = 1; /* down */	1706	upordown = 1; /* down */
1743	}	1707	}
1744	else if (scrollBar.style == R_SB_RXVT)	1708	else if (scrollBar.style == R_SB_RXVT)
1745	{	1709	{
1746	if (scrollbarrxvt_upButton(ev.y))	1710	if (scrollbarrxvt_upButton (ev.y))
1747	upordown = -1; /* up */	1711	upordown = -1; /* up */
1748	else if (scrollbarrxvt_dnButton(ev.y))	1712	else if (scrollbarrxvt_dnButton (ev.y))
1749	upordown = 1; /* down */	1713	upordown = 1; /* down */
1750	}	1714	}
1751	if (upordown)	1715	if (upordown)
1752	{	1716	{
1753	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING	1717	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
…		…
1776	case R_SB_ALIGN_BOTTOM:	1740	case R_SB_ALIGN_BOTTOM:
1777	csrO = scrollBar.bot - scrollBar.top;	1741	csrO = scrollBar.bot - scrollBar.top;
1778	break;	1742	break;
1779	}	1743	}
1780	if (scrollBar.style == R_SB_XTERM	1744	if (scrollBar.style == R_SB_XTERM
1781	|| scrollbar_above_slider(ev.y)	1745	|| scrollbar_above_slider (ev.y)
1782	|| scrollbar_below_slider(ev.y))	1746	|| scrollbar_below_slider (ev.y))
1783	scr_move_to ( scrollbar_position(ev.y) - csrO,	1747	scr_move_to ( scrollbar_position (ev.y) - csrO,
1784	scrollbar_size());	1748	scrollbar_size ());
1785	scrollBar.setMotion ();	1749	scrollBar.setMotion ();
1786	break;	1750	break;
1787		1751
1788	case Button1:	1752	case Button1:
1789	if (scrollbar_align == R_SB_ALIGN_CENTRE)	1753	if (scrollbar_align == R_SB_ALIGN_CENTRE)
…		…
1791	/* FALLTHROUGH */	1755	/* FALLTHROUGH */
1792		1756
1793	case Button3:	1757	case Button3:
1794	if (scrollBar.style != R_SB_XTERM)	1758	if (scrollBar.style != R_SB_XTERM)
1795	{	1759	{
1796	if (scrollbar_above_slider(ev.y))	1760	if (scrollbar_above_slider (ev.y))
1797	# ifdef RXVT_SCROLL_FULL	1761	# ifdef RXVT_SCROLL_FULL
1798	scr_page (UP, TermWin.nrow - 1);	1762	scr_page (UP, TermWin.nrow - 1);
1799	# else	1763	# else
1800	scr_page (UP, TermWin.nrow / 4);	1764	scr_page (UP, TermWin.nrow / 4);
1801	# endif	1765	# endif
1802	else if (scrollbar_below_slider(ev.y))	1766	else if (scrollbar_below_slider (ev.y))
1803	# ifdef RXVT_SCROLL_FULL	1767	# ifdef RXVT_SCROLL_FULL
1804	scr_page (DN, TermWin.nrow - 1);	1768	scr_page (DN, TermWin.nrow - 1);
1805	# else	1769	# else
1806	scr_page (DN, TermWin.nrow / 4);	1770	scr_page (DN, TermWin.nrow / 4);
1807	# endif	1771	# endif
…		…
1810	}	1774	}
1811	else	1775	else
1812	{	1776	{
1813	scr_page ((ev.button == Button1 ? DN : UP),	1777	scr_page ((ev.button == Button1 ? DN : UP),
1814	(TermWin.nrow	1778	(TermWin.nrow
1815	* scrollbar_position(ev.y)	1779	* scrollbar_position (ev.y)
1816	/ scrollbar_size()));	1780	/ scrollbar_size ()));
1817	}	1781	}
1818	break;	1782	break;
1819	}	1783	}
1820	}	1784	}
1821	return;	1785	return;
1822	}	1786	}
1823	#if MENUBAR	1787	#if MENUBAR
1824	/*	1788	/*
1825	* Menubar window processing of button press	1789	* Menubar window processing of button press
1826	*/	1790	*/
1827	if (isMenuBarWindow(ev.window))	1791	if (isMenuBarWindow (ev.window))
1828	menubar_control (ev);	1792	menubar_control (ev);
1829	#endif	1793	#endif
1830	}	1794	}
1831		1795
1832	void	1796	void
…		…
1834	{	1798	{
1835	int reportmode = 0;	1799	int reportmode = 0;
1836		1800
1837	csrO = 0; /* reset csr Offset */	1801	csrO = 0; /* reset csr Offset */
1838	if (!bypass_keystate)	1802	if (!bypass_keystate)
1839	reportmode = !!(PrivateModes & PrivMode_mouse_report);	1803	reportmode = !! (PrivateModes & PrivMode_mouse_report);
1840		1804
1841	if (scrollbar_isUpDn())	1805	if (scrollbar_isUpDn ())
1842	{	1806	{
1843	scrollBar.setIdle ();	1807	scrollBar.setIdle ();
1844	scrollbar_show (0);	1808	scrollbar_show (0);
1845	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING	1809	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1846	refresh_type &= ~SMOOTH_REFRESH;	1810	refresh_type &= ~SMOOTH_REFRESH;
…		…
1850	#ifdef SELECTION_SCROLLING	1814	#ifdef SELECTION_SCROLLING
1851	pending_scroll_selection=0;	1815	pending_scroll_selection=0;
1852	#endif	1816	#endif
1853	if (ev.window == TermWin.vt)	1817	if (ev.window == TermWin.vt)
1854	{	1818	{
1855	#ifdef RXVT_GRAPHICS
1856	if (ev.subwindow != None)
1857	rxvt_Gr_ButtonRelease(ev.x, ev.y);
1858	else
1859	#endif
1860
1861	{
1862	if (reportmode)	1819	if (reportmode)
		1820	{
		1821	/* mouse report from vt window */
		1822	/* don't report release of wheel "buttons" */
		1823	if (ev.button >= 4)
		1824	return;
		1825	#ifdef MOUSE_REPORT_DOUBLECLICK
		1826	/* only report the release of 'slow' single clicks */
		1827	if (MEvent.button != AnyButton
		1828	&& (ev.button != MEvent.button
		1829	|| (ev.time - MEvent.time
		1830	> MULTICLICK_TIME / 2)))
1863	{	1831	{
1864	/* mouse report from vt window */
1865	/* don't report release of wheel "buttons" */
1866	if (ev.button >= 4)
1867	return;
1868	#ifdef MOUSE_REPORT_DOUBLECLICK
1869	/* only report the release of 'slow' single clicks */
1870	if (MEvent.button != AnyButton
1871	&& (ev.button != MEvent.button
1872	|| (ev.time - MEvent.time
1873	> MULTICLICK_TIME / 2)))
1874	{
1875	MEvent.clicks = 0;	1832	MEvent.clicks = 0;
1876	MEvent.button = AnyButton;
1877	mouse_report (ev);
1878	}
1879	#else /* MOUSE_REPORT_DOUBLECLICK */
1880	MEvent.button = AnyButton;	1833	MEvent.button = AnyButton;
1881	mouse_report (ev);	1834	mouse_report (ev);
		1835	}
		1836	#else /* MOUSE_REPORT_DOUBLECLICK */
		1837	MEvent.button = AnyButton;
		1838	mouse_report (ev);
1882	#endif /* MOUSE_REPORT_DOUBLECLICK */	1839	#endif /* MOUSE_REPORT_DOUBLECLICK */
1883	return;	1840	return;
1884	}	1841	}
1885	/*	1842	/*
1886	* dumb hack to compensate for the failure of click-and-drag	1843	* dumb hack to compensate for the failure of click-and-drag
1887	* when overriding mouse reporting	1844	* when overriding mouse reporting
1888	*/	1845	*/
1889	if (PrivateModes & PrivMode_mouse_report	1846	if (PrivateModes & PrivMode_mouse_report
1890	&& bypass_keystate	1847	&& bypass_keystate
1891	&& ev.button == Button1 && MEvent.clicks <= 1)	1848	&& ev.button == Button1 && MEvent.clicks <= 1)
1892	selection_extend (ev.x, ev.y, 0);	1849	selection_extend (ev.x, ev.y, 0);
1893		1850
1894	switch (ev.button)	1851	switch (ev.button)
		1852	{
		1853	case Button1:
		1854	case Button3:
		1855	selection_make (ev.time);
		1856	break;
		1857	case Button2:
		1858	selection_request (ev.time, ev.x, ev.y);
		1859	break;
		1860	#ifdef MOUSE_WHEEL
		1861	case Button4:
		1862	case Button5:
1895	{	1863	{
1896	case Button1:	1864	int i;
1897	case Button3:	1865	page_dirn v;
1898	selection_make (ev.time);	1866
		1867	v = (ev.button == Button4) ? UP : DN;
		1868	if (ev.state & ShiftMask)
1899	break;	1869	i = 1;
1900	case Button2:	1870	else if ((Options & Opt_mouseWheelScrollPage))
1901	selection_request (ev.time, ev.x, ev.y);	1871	i = TermWin.nrow - 1;
		1872	else
1902	break;	1873	i = 5;
1903	#ifdef MOUSE_WHEEL	1874	# ifdef MOUSE_SLIP_WHEELING
1904	case Button4:	1875	if (ev.state & ControlMask)
1905	case Button5:
1906	{	1876	{
1907	int i;
1908	page_dirn v;
1909
1910	v = (ev.button == Button4) ? UP : DN;
1911	if (ev.state & ShiftMask)
1912	i = 1;
1913	else if ((Options & Opt_mouseWheelScrollPage))
1914	i = TermWin.nrow - 1;
1915	else
1916	i = 5;
1917	# ifdef MOUSE_SLIP_WHEELING
1918	if (ev.state & ControlMask)
1919	{
1920	mouse_slip_wheel_speed += (v ? -1 : 1);	1877	mouse_slip_wheel_speed += (v ? -1 : 1);
1921	mouse_slip_wheel_delay = SCROLLBAR_CONTINUOUS_DELAY;	1878	mouse_slip_wheel_delay = SCROLLBAR_CONTINUOUS_DELAY;
1922	}	1879	}
1923	# endif	1880	# endif
1924	# ifdef JUMP_MOUSE_WHEEL	1881	# ifdef JUMP_MOUSE_WHEEL
		1882	scr_page (v, i);
		1883	scr_refresh (SMOOTH_REFRESH);
		1884	scrollbar_show (1);
		1885	# else
		1886	while (i--)
		1887	{
1925	scr_page (v, i);	1888	scr_page (v, 1);
1926	scr_refresh (SMOOTH_REFRESH);	1889	scr_refresh (SMOOTH_REFRESH);
1927	scrollbar_show (1);	1890	scrollbar_show (1);
1928	# else
1929	while (i--)
1930	{
1931	scr_page (v, 1);
1932	scr_refresh (SMOOTH_REFRESH);
1933	scrollbar_show (1);
1934	}	1891	}
1935	# endif	1892	# endif
1936		1893
1937	}
1938	break;
1939	#endif
1940
1941	}	1894	}
		1895	break;
		1896	#endif
		1897
1942	}	1898	}
1943	}	1899	}
1944	#ifdef MENUBAR	1900	#ifdef MENUBAR
1945	else if (isMenuBarWindow(ev.window))	1901	else if (isMenuBarWindow (ev.window))
1946	menubar_control (ev);	1902	menubar_control (ev);
1947	#endif	1903	#endif
1948	}	1904	}
1949		1905
1950		1906
…		…
1964	Pixmap rootpixmap = None;	1920	Pixmap rootpixmap = None;
1965	XWindowAttributes wattr, wrootattr;	1921	XWindowAttributes wattr, wrootattr;
1966		1922
1967	pchanged = 0;	1923	pchanged = 0;
1968		1924
1969	if (!(Options & Opt_transparent))	1925	if (! (Options & Opt_transparent))
1970	return pchanged; /* Don't try any more */	1926	return pchanged; /* Don't try any more */
1971		1927
1972	XGetWindowAttributes(display->display, display->root, &wrootattr);	1928	XGetWindowAttributes (display->display, display->root, &wrootattr);
1973	rootdepth = wrootattr.depth;	1929	rootdepth = wrootattr.depth;
1974		1930
1975	XGetWindowAttributes(display->display, TermWin.parent[0], &wattr);	1931	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);
1976	if (rootdepth != wattr.depth)	1932	if (rootdepth != wattr.depth)
1977	{	1933	{
1978	if (am_transparent)	1934	if (am_transparent)
1979	{	1935	{
1980	pchanged = 1;	1936	pchanged = 1;
1981	XSetWindowBackground(display->display, TermWin.vt,	1937	XSetWindowBackground (display->display, TermWin.vt,
1982	PixColors[Color_bg]);	1938	PixColors[Color_bg]);
1983	am_transparent = am_pixmap_trans = 0;	1939	am_transparent = am_pixmap_trans = 0;
1984	}	1940	}
1985	return pchanged; /* Don't try any more */	1941	return pchanged; /* Don't try any more */
1986	}	1942	}
1987		1943
1988	/* Get all X ops out of the queue so that our information is up-to-date. */	1944	/* Get all X ops out of the queue so that our information is up-to-date. */
1989	XSync(display->display, False);	1945	XSync (display->display, False);
1990		1946
1991	/*	1947	/*
1992	* Make the frame window set by the window manager have	1948	* Make the frame window set by the window manager have
1993	* the root background. Some window managers put multiple nested frame	1949	* the root background. Some window managers put multiple nested frame
1994	* windows for each client, so we have to take care about that.	1950	* windows for each client, so we have to take care about that.
1995	*/	1951	*/
1996	i = (xa[XA_XROOTPMAPID] != 0	1952	i = (xa[XA_XROOTPMAPID] != 0
1997	&& (XGetWindowProperty(display->display, display->root, xa[XA_XROOTPMAPID],	1953	&& (XGetWindowProperty (display->display, display->root, xa[XA_XROOTPMAPID],
1998	0L, 1L, False, XA_PIXMAP, &atype, &aformat,	1954	0L, 1L, False, XA_PIXMAP, &atype, &aformat,
1999	&nitems, &bytes_after, &prop) == Success));	1955	&nitems, &bytes_after, &prop) == Success));
2000	if (!i || prop == NULL)	1956	if (!i || prop == NULL)
2001	have_pixmap = 0;	1957	have_pixmap = 0;
2002	else	1958	else
2003	{	1959	{
2004	have_pixmap = 1;	1960	have_pixmap = 1;
2005	rootpixmap = *((Pixmap *)prop);	1961	rootpixmap = * ((Pixmap *)prop);
2006	XFree(prop);	1962	XFree (prop);
2007	}	1963	}
2008	if (have_pixmap)	1964	if (have_pixmap)
2009	{	1965	{
2010	/*	1966	/*
2011	* Copy display->root pixmap transparency	1967	* Copy display->root pixmap transparency
…		…
2015	Window cr;	1971	Window cr;
2016	XImage *image;	1972	XImage *image;
2017	GC gc;	1973	GC gc;
2018	XGCValues gcvalue;	1974	XGCValues gcvalue;
2019		1975
2020	XTranslateCoordinates(display->display, TermWin.parent[0], display->root,	1976	XTranslateCoordinates (display->display, TermWin.parent[0], display->root,
2021	0, 0, &sx, &sy, &cr);	1977	0, 0, &sx, &sy, &cr);
2022	nw = (unsigned int)szHint.width;	1978	nw = (unsigned int)szHint.width;
2023	nh = (unsigned int)szHint.height;	1979	nh = (unsigned int)szHint.height;
2024	nx = ny = 0;	1980	nx = ny = 0;
2025	if (sx < 0)	1981	if (sx < 0)
…		…
2032	{	1988	{
2033	nh += sy;	1989	nh += sy;
2034	ny = -sy;	1990	ny = -sy;
2035	sy = 0;	1991	sy = 0;
2036	}	1992	}
2037	MIN_IT(nw, (unsigned int)(wrootattr.width - sx));	1993	MIN_IT (nw, (unsigned int) (wrootattr.width - sx));
2038	MIN_IT(nh, (unsigned int)(wrootattr.height - sy));	1994	MIN_IT (nh, (unsigned int) (wrootattr.height - sy));
2039	allowedxerror = -1;	1995	allowedxerror = -1;
2040	image = XGetImage(display->display, rootpixmap, sx, sy, nw, nh, AllPlanes,	1996	image = XGetImage (display->display, rootpixmap, sx, sy, nw, nh, AllPlanes,
2041	ZPixmap);	1997	ZPixmap);
2042	/* XXX: handle BadMatch - usually because we're outside the pixmap */	1998	/* XXX: handle BadMatch - usually because we're outside the pixmap */
2043	/* XXX: may need a delay here? */	1999	/* XXX: may need a delay here? */
2044	allowedxerror = 0;	2000	allowedxerror = 0;
2045	if (image == NULL)	2001	if (image == NULL)
…		…
2047	if (am_transparent && am_pixmap_trans)	2003	if (am_transparent && am_pixmap_trans)
2048	{	2004	{
2049	pchanged = 1;	2005	pchanged = 1;
2050	if (TermWin.pixmap != None)	2006	if (TermWin.pixmap != None)
2051	{	2007	{
2052	XFreePixmap(display->display, TermWin.pixmap);	2008	XFreePixmap (display->display, TermWin.pixmap);
2053	TermWin.pixmap = None;	2009	TermWin.pixmap = None;
2054	}	2010	}
2055	}	2011	}
2056	am_pixmap_trans = 0;	2012	am_pixmap_trans = 0;
2057	}	2013	}
2058	else	2014	else
2059	{	2015	{
2060	if (TermWin.pixmap != None)	2016	if (TermWin.pixmap != None)
2061	XFreePixmap(display->display, TermWin.pixmap);	2017	XFreePixmap (display->display, TermWin.pixmap);
2062	TermWin.pixmap = XCreatePixmap(display->display, TermWin.vt,	2018	TermWin.pixmap = XCreatePixmap (display->display, TermWin.vt,
2063	(unsigned int)szHint.width,	2019	(unsigned int)szHint.width,
2064	(unsigned int)szHint.height,	2020	(unsigned int)szHint.height,
2065	(unsigned int)image->depth);	2021	(unsigned int)image->depth);
2066	gc = XCreateGC(display->display, TermWin.vt, 0UL, &gcvalue);	2022	gc = XCreateGC (display->display, TermWin.vt, 0UL, &gcvalue);
2067	XPutImage(display->display, TermWin.pixmap, gc, image, 0, 0,	2023	XPutImage (display->display, TermWin.pixmap, gc, image, 0, 0,
2068	nx, ny, (unsigned int)image->width,	2024	nx, ny, (unsigned int)image->width,
2069	(unsigned int)image->height);	2025	(unsigned int)image->height);
2070	XFreeGC(display->display, gc);	2026	XFreeGC (display->display, gc);
2071	XDestroyImage(image);	2027	XDestroyImage (image);
2072	XSetWindowBackgroundPixmap(display->display, TermWin.vt,	2028	XSetWindowBackgroundPixmap (display->display, TermWin.vt,
2073	TermWin.pixmap);	2029	TermWin.pixmap);
2074	if (!am_transparent || !am_pixmap_trans)	2030	if (!am_transparent || !am_pixmap_trans)
2075	pchanged = 1;	2031	pchanged = 1;
2076	am_transparent = am_pixmap_trans = 1;	2032	am_transparent = am_pixmap_trans = 1;
2077	}	2033	}
…		…
2080	{	2036	{
2081	unsigned int n;	2037	unsigned int n;
2082	/*	2038	/*
2083	* InheritPixmap transparency	2039	* InheritPixmap transparency
2084	*/	2040	*/
2085	D_X((stderr, "InheritPixmap Seeking to %08lx", display->root));	2041	D_X ((stderr, "InheritPixmap Seeking to %08lx", display->root));
2086	for (i = 1; i < (int)(sizeof(TermWin.parent) / sizeof(Window));	2042	for (i = 1; i < (int) (sizeof (TermWin.parent) / sizeof (Window));
2087	i++)	2043	i++)
2088	{	2044	{
2089	oldp = TermWin.parent[i];	2045	oldp = TermWin.parent[i];
2090	XQueryTree(display->display, TermWin.parent[i - 1], &root,	2046	XQueryTree (display->display, TermWin.parent[i - 1], &root,
2091	&TermWin.parent[i], &list, &n);	2047	&TermWin.parent[i], &list, &n);
2092	XFree(list);	2048	XFree (list);
2093	D_X((stderr, "InheritPixmap Parent[%d] = %08lx", i, TermWin.parent[i]));	2049	D_X ((stderr, "InheritPixmap Parent[%d] = %08lx", i, TermWin.parent[i]));
2094	if (TermWin.parent[i] == display->root)	2050	if (TermWin.parent[i] == display->root)
2095	{	2051	{
2096	if (oldp != None)	2052	if (oldp != None)
2097	pchanged = 1;	2053	pchanged = 1;
2098	break;	2054	break;
…		…
2103	n = 0;	2059	n = 0;
2104	if (pchanged)	2060	if (pchanged)
2105	{	2061	{
2106	for (; n < (unsigned int)i; n++)	2062	for (; n < (unsigned int)i; n++)
2107	{	2063	{
2108	XGetWindowAttributes(display->display, TermWin.parent[n], &wattr);	2064	XGetWindowAttributes (display->display, TermWin.parent[n], &wattr);
2109	D_X((stderr, "InheritPixmap Checking Parent[%d]: %s", n, (wattr.depth == rootdepth && wattr.class != InputOnly) ? "OK" : "FAIL"));	2065	D_X ((stderr, "InheritPixmap Checking Parent[%d]: %s", n, (wattr.depth == rootdepth && wattr.class != InputOnly) ? "OK" : "FAIL"));
2110	if (wattr.depth != rootdepth || wattr.c_class == InputOnly)	2066	if (wattr.depth != rootdepth || wattr.c_class == InputOnly)
2111	{	2067	{
2112	n = (int)(sizeof(TermWin.parent) / sizeof(Window)) + 1;	2068	n = (int) (sizeof (TermWin.parent) / sizeof (Window)) + 1;
2113	break;	2069	break;
2114	}	2070	}
2115	}	2071	}
2116	}	2072	}
2117	if (n > (int)(sizeof(TermWin.parent)	2073	if (n > (int) (sizeof (TermWin.parent)
2118	/ sizeof(TermWin.parent[0])))	2074	/ sizeof (TermWin.parent[0])))
2119	{	2075	{
2120	D_X((stderr, "InheritPixmap Turning off"));	2076	D_X ((stderr, "InheritPixmap Turning off"));
2121	XSetWindowBackground(display->display, TermWin.parent[0],	2077	XSetWindowBackground (display->display, TermWin.parent[0],
2122	PixColors[Color_fg]);	2078	PixColors[Color_fg]);
2123	XSetWindowBackground(display->display, TermWin.vt,	2079	XSetWindowBackground (display->display, TermWin.vt,
2124	PixColors[Color_bg]);	2080	PixColors[Color_bg]);
2125	am_transparent = 0;	2081	am_transparent = 0;
2126	/* XXX: also turn off Opt_transparent? */	2082	/* XXX: also turn off Opt_transparent? */
2127	}	2083	}
2128	else	2084	else
…		…
2132	# ifdef HAVE_NANOSLEEP	2088	# ifdef HAVE_NANOSLEEP
2133	struct timespec rqt;	2089	struct timespec rqt;
2134		2090
2135	rqt.tv_sec = 1;	2091	rqt.tv_sec = 1;
2136	rqt.tv_nsec = 0;	2092	rqt.tv_nsec = 0;
2137	nanosleep(&rqt, NULL);	2093	nanosleep (&rqt, NULL);
2138	# else	2094	# else
2139	sleep(1);	2095	sleep (1);
2140	# endif	2096	# endif
2141	D_X((stderr, "InheritPixmap Turning on (%d parents)", i - 1));	2097	D_X ((stderr, "InheritPixmap Turning on (%d parents)", i - 1));
2142	for (n = 0; n < (unsigned int)i; n++)	2098	for (n = 0; n < (unsigned int)i; n++)
2143	XSetWindowBackgroundPixmap(display->display, TermWin.parent[n],	2099	XSetWindowBackgroundPixmap (display->display, TermWin.parent[n],
2144	ParentRelative);	2100	ParentRelative);
2145	XSetWindowBackgroundPixmap(display->display, TermWin.vt,	2101	XSetWindowBackgroundPixmap (display->display, TermWin.vt,
2146	ParentRelative);	2102	ParentRelative);
2147	am_transparent = 1;	2103	am_transparent = 1;
2148	}	2104	}
2149	for (; i < (int)(sizeof(TermWin.parent) / sizeof(Window)); i++)	2105	for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
2150	TermWin.parent[i] = None;	2106	TermWin.parent[i] = None;
2151	}	2107	}
2152	return pchanged;	2108	return pchanged;
2153	}	2109	}
2154	#endif	2110	#endif
…		…
2159	/*----------------------------------------------------------------------*/	2115	/*----------------------------------------------------------------------*/
2160	#ifdef PRINTPIPE	2116	#ifdef PRINTPIPE
2161	FILE *	2117	FILE *
2162	rxvt_term::popen_printer ()	2118	rxvt_term::popen_printer ()
2163	{	2119	{
2164	FILE *stream = popen(rs[Rs_print_pipe], "w");	2120	FILE *stream = popen (rs[Rs_print_pipe], "w");
2165		2121
2166	if (stream == NULL)	2122	if (stream == NULL)
2167	rxvt_print_error("can't open printer pipe");	2123	rxvt_print_error ("can't open printer pipe");
2168	return stream;	2124	return stream;
2169	}	2125	}
2170		2126
2171	int	2127	int
2172	rxvt_term::pclose_printer (FILE *stream)	2128	rxvt_term::pclose_printer (FILE *stream)
2173	{	2129	{
2174	fflush (stream);	2130	fflush (stream);
2175	/* pclose() reported not to work on SunOS 4.1.3 */	2131	/* pclose () reported not to work on SunOS 4.1.3 */
2176	# if defined (__sun__) /* TODO: RESOLVE THIS */	2132	# if defined (__sun__) /* TODO: RESOLVE THIS */
2177	/* pclose works provided SIGCHLD handler uses waitpid */	2133	/* pclose works provided SIGCHLD handler uses waitpid */
2178	return pclose (stream); /* return fclose (stream); */	2134	return pclose (stream); /* return fclose (stream); */
2179	# else	2135	# else
2180	return pclose (stream);	2136	return pclose (stream);
…		…
2203	unsigned char ch;	2159	unsigned char ch;
2204	unsigned int i, len;	2160	unsigned int i, len;
2205		2161
2206	if ((ch = cmd_getc ()) != C0_ESC)	2162	if ((ch = cmd_getc ()) != C0_ESC)
2207	{	2163	{
2208	if (putc(ch, fd) == EOF)	2164	if (putc (ch, fd) == EOF)
2209	break; /* done = 1 */	2165	break; /* done = 1 */
2210	}	2166	}
2211	else	2167	else
2212	{	2168	{
2213	len = 0;	2169	len = 0;
…		…
2225	if ((buf[len++] = cmd_getc ()) == 'i')	2181	if ((buf[len++] = cmd_getc ()) == 'i')
2226	break; /* done = 1 */	2182	break; /* done = 1 */
2227	}	2183	}
2228	}	2184	}
2229	for (i = 0; i < len; i++)	2185	for (i = 0; i < len; i++)
2230	if (putc(buf[i], fd) == EOF)	2186	if (putc (buf[i], fd) == EOF)
2231	{	2187	{
2232	done = 1;	2188	done = 1;
2233	break;	2189	break;
2234	}	2190	}
2235	}	2191	}
…		…
2255	{	2211	{
2256	switch (ch)	2212	switch (ch)
2257	{	2213	{
2258	case C0_ENQ: /* terminal Status */	2214	case C0_ENQ: /* terminal Status */
2259	if (rs[Rs_answerbackstring])	2215	if (rs[Rs_answerbackstring])
2260	tt_write(	2216	tt_write (
2261	(const unsigned char *)rs[Rs_answerbackstring],	2217	(const unsigned char *)rs[Rs_answerbackstring],
2262	(unsigned int)STRLEN(rs[Rs_answerbackstring]));	2218	(unsigned int)STRLEN (rs[Rs_answerbackstring]));
2263	else	2219	else
2264	tt_write((unsigned char *)VT100_ANS,	2220	tt_write ((unsigned char *)VT100_ANS,
2265	(unsigned int)STRLEN(VT100_ANS));	2221	(unsigned int)STRLEN (VT100_ANS));
2266	break;	2222	break;
2267	case C0_BEL: /* bell */	2223	case C0_BEL: /* bell */
2268	scr_bell ();	2224	scr_bell ();
2269	break;	2225	break;
2270	case C0_BS: /* backspace */	2226	case C0_BS: /* backspace */
…		…
2332	row = cmd_getc () - ' ';	2288	row = cmd_getc () - ' ';
2333	col = cmd_getc () - ' ';	2289	col = cmd_getc () - ' ';
2334	scr_gotorc (row, col, 0);	2290	scr_gotorc (row, col, 0);
2335	break;	2291	break;
2336	case 'Z': /* identify the terminal type */	2292	case 'Z': /* identify the terminal type */
2337	tt_printf("\033/Z"); /* I am a VT100 emulating a VT52 */	2293	tt_printf ("\033/Z"); /* I am a VT100 emulating a VT52 */
2338	break;	2294	break;
2339	case '<': /* turn off VT52 mode */	2295	case '<': /* turn off VT52 mode */
2340	PrivMode(0, PrivMode_vt52);	2296	PrivMode (0, PrivMode_vt52);
2341	break;	2297	break;
2342	case 'F': /* use special graphics character set */	2298	case 'F': /* use special graphics character set */
2343	case 'G': /* use regular character set */	2299	case 'G': /* use regular character set */
2344	/* unimplemented */	2300	/* unimplemented */
2345	break;	2301	break;
…		…
2404	scr_forwardindex ();	2360	scr_forwardindex ();
2405	break;	2361	break;
2406	#endif	2362	#endif
2407	case '=':	2363	case '=':
2408	case '>':	2364	case '>':
2409	PrivMode((ch == '='), PrivMode_aplKP);	2365	PrivMode ((ch == '='), PrivMode_aplKP);
2410	break;	2366	break;
2411		2367
2412	case C1_40:	2368	case C1_40:
2413	cmd_getc ();	2369	cmd_getc ();
2414	break;	2370	break;
…		…
2450	process_dcs_seq ();	2406	process_dcs_seq ();
2451	break;	2407	break;
2452		2408
2453	/* 8.3.110: SINGLE CHARACTER INTRODUCER */	2409	/* 8.3.110: SINGLE CHARACTER INTRODUCER */
2454	case C1_SCI: /* ESC Z */	2410	case C1_SCI: /* ESC Z */
2455	tt_write((const unsigned char *)ESCZ_ANSWER,	2411	tt_write ((const unsigned char *)ESCZ_ANSWER,
2456	(unsigned int)(sizeof(ESCZ_ANSWER) - 1));	2412	(unsigned int) (sizeof (ESCZ_ANSWER) - 1));
2457	break; /* steal obsolete ESC [ c */	2413	break; /* steal obsolete ESC [ c */
2458		2414
2459	/* 8.3.16: CONTROL SEQUENCE INTRODUCER */	2415	/* 8.3.16: CONTROL SEQUENCE INTRODUCER */
2460	case C1_CSI: /* ESC [ */	2416	case C1_CSI: /* ESC [ */
2461	process_csi_seq ();	2417	process_csi_seq ();
…		…
2501		2457
2502	#define make_byte(b7,b6,b5,b4,b3,b2,b1,b0) \	2458	#define make_byte(b7,b6,b5,b4,b3,b2,b1,b0) \
2503	(((b7) << 7) | ((b6) << 6) | ((b5) << 5) | ((b4) << 4) \	2459	(((b7) << 7) | ((b6) << 6) | ((b5) << 5) | ((b4) << 4) \
2504	| ((b3) << 3) | ((b2) << 2) | ((b1) << 1) | (b0))	2460	| ((b3) << 3) | ((b2) << 2) | ((b1) << 1) | (b0))
2505	#define get_byte_array_bit(array, bit) \	2461	#define get_byte_array_bit(array, bit) \
2506	(!!((array)[(bit) / 8] & (128 >> ((bit) & 7))))	2462	(!! ((array)[ (bit) / 8] & (128 >> ((bit) & 7))))
2507		2463
2508	const unsigned char csi_defaults[] =	2464	const unsigned char csi_defaults[] =
2509	{	2465	{
2510	make_byte(1,1,1,1,1,1,1,1), /* @, A, B, C, D, E, F, G, */	2466	make_byte (1,1,1,1,1,1,1,1), /* @, A, B, C, D, E, F, G, */
2511	make_byte(1,1,0,0,1,1,0,0), /* H, I, J, K, L, M, N, O, */	2467	make_byte (1,1,0,0,1,1,0,0), /* H, I, J, K, L, M, N, O, */
2512	make_byte(1,0,1,1,1,1,1,0), /* P, Q, R, S, T, U, V, W, */	2468	make_byte (1,0,1,1,1,1,1,0), /* P, Q, R, S, T, U, V, W, */
2513	make_byte(1,1,1,0,0,0,1,0), /* X, Y, Z, [, \, ], ^, _, */	2469	make_byte (1,1,1,0,0,0,1,0), /* X, Y, Z, [, \, ], ^, _, */
2514	make_byte(1,1,1,0,1,1,1,0), /* `, a, b, c, d, e, f, g, */	2470	make_byte (1,1,1,0,1,1,1,0), /* `, a, b, c, d, e, f, g, */
2515	make_byte(0,0,1,1,0,0,0,0), /* h, i, j, k, l, m, n, o, */	2471	make_byte (0,0,1,1,0,0,0,0), /* h, i, j, k, l, m, n, o, */
2516	make_byte(0,0,0,0,0,0,0,0), /* p, q, r, s, t, u, v, w, */	2472	make_byte (0,0,0,0,0,0,0,0), /* p, q, r, s, t, u, v, w, */
2517	make_byte(0,0,0,0,0,0,0,0) /* x, y, z, {, |, }, ~, */	2473	make_byte (0,0,0,0,0,0,0,0) /* x, y, z, {, |, }, ~, */
2518	};	2474	};
2519	/* *INDENT-ON* */	2475	/* *INDENT-ON* */
2520		2476
2521	void	2477	void
2522	rxvt_term::process_csi_seq ()	2478	rxvt_term::process_csi_seq ()
…		…
2537	ch = cmd_getc ();	2493	ch = cmd_getc ();
2538	}	2494	}
2539	/* read any numerical arguments */	2495	/* read any numerical arguments */
2540	for (n = -1; ch < CSI_ICH; )	2496	for (n = -1; ch < CSI_ICH; )
2541	{	2497	{
2542	if (isdigit(ch))	2498	if (isdigit (ch))
2543	{	2499	{
2544	if (n < 0)	2500	if (n < 0)
2545	n = ch - '0';	2501	n = ch - '0';
2546	else	2502	else
2547	n = n * 10 + ch - '0';	2503	n = n * 10 + ch - '0';
…		…
2573		2529
2574	if (nargs < ESC_ARGS)	2530	if (nargs < ESC_ARGS)
2575	arg[nargs++] = n;	2531	arg[nargs++] = n;
2576		2532
2577	i = ch - CSI_ICH;	2533	i = ch - CSI_ICH;
2578	ndef = get_byte_array_bit(csi_defaults, i);	2534	ndef = get_byte_array_bit (csi_defaults, i);
2579	for (p = 0; p < nargs; p++)	2535	for (p = 0; p < nargs; p++)
2580	if (arg[p] == -1)	2536	if (arg[p] == -1)
2581	arg[p] = ndef;	2537	arg[p] = ndef;
2582		2538
2583	#ifdef DEBUG_CMD	2539	#ifdef DEBUG_CMD
2584	fprintf(stderr, "CSI ");	2540	fprintf (stderr, "CSI ");
2585	for (p = 0; p < nargs; p++)	2541	for (p = 0; p < nargs; p++)
2586	fprintf(stderr, "%d%s", arg[p], p < nargs - 1 ? ";" : "");	2542	fprintf (stderr, "%d%s", arg[p], p < nargs - 1 ? ";" : "");
2587	fprintf(stderr, "%c\n", ch);	2543	fprintf (stderr, "%c\n", ch);
2588	#endif	2544	#endif
2589		2545
2590	/*	2546	/*
2591	* private mode handling	2547	* private mode handling
2592	*/	2548	*/
…		…
2594	{	2550	{
2595	switch (priv)	2551	switch (priv)
2596	{	2552	{
2597	case '>':	2553	case '>':
2598	if (ch == CSI_DA) /* secondary device attributes */	2554	if (ch == CSI_DA) /* secondary device attributes */
2599	tt_printf("\033[>%d;%-.8s;0c", 'R', VSTRING);	2555	tt_printf ("\033[>%d;%-.8s;0c", 'R', VSTRING);
2600	break;	2556	break;
2601	case '?':	2557	case '?':
2602	if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')	2558	if (ch == 'h' || ch == 'l' || ch == 'r' || ch == 's' || ch == 't')
2603	process_terminal_mode (ch, priv, nargs, arg);	2559	process_terminal_mode (ch, priv, nargs, arg);
2604	break;	2560	break;
…		…
2607	}	2563	}
2608		2564
2609	switch (ch)	2565	switch (ch)
2610	{	2566	{
2611	/*	2567	/*
2612	* ISO/IEC 6429:1992(E) CSI sequences (defaults in parentheses)	2568	* ISO/IEC 6429:1992 (E) CSI sequences (defaults in parentheses)
2613	*/	2569	*/
2614	#ifdef PRINTPIPE	2570	#ifdef PRINTPIPE
2615	case CSI_MC: /* 8.3.83: (0) MEDIA COPY */	2571	case CSI_MC: /* 8.3.83: (0) MEDIA COPY */
2616	switch (arg[0])	2572	switch (arg[0])
2617	{	2573	{
…		…
2713	case CSI_SU: /* 8.3.148: (1) SCROLL UP */	2669	case CSI_SU: /* 8.3.148: (1) SCROLL UP */
2714	scr_scroll_text (screen.tscroll, screen.bscroll, arg[0], 0);	2670	scr_scroll_text (screen.tscroll, screen.bscroll, arg[0], 0);
2715	break;	2671	break;
2716		2672
2717	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */	2673	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */
2718	tt_write((const unsigned char *)VT100_ANS,	2674	tt_write ((const unsigned char *)VT100_ANS,
2719	(unsigned int)(sizeof(VT100_ANS) - 1));	2675	(unsigned int) (sizeof (VT100_ANS) - 1));
2720	break;	2676	break;
2721		2677
2722	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */	2678	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */
2723	process_sgr_mode (nargs, arg);	2679	process_sgr_mode (nargs, arg);
2724	break;	2680	break;
2725		2681
2726	case CSI_DSR: /* 8.3.36: (0) DEVICE STATUS REPORT */	2682	case CSI_DSR: /* 8.3.36: (0) DEVICE STATUS REPORT */
2727	switch (arg[0])	2683	switch (arg[0])
2728	{	2684	{
2729	case 5: /* DSR requested */	2685	case 5: /* DSR requested */
2730	tt_printf("\033[0n");	2686	tt_printf ("\033[0n");
2731	break;	2687	break;
2732	case 6: /* CPR requested */	2688	case 6: /* CPR requested */
2733	scr_report_position ();	2689	scr_report_position ();
2734	break;	2690	break;
2735	#if defined (ENABLE_DISPLAY_ANSWER)	2691	#if defined (ENABLE_DISPLAY_ANSWER)
2736	case 7: /* unofficial extension */	2692	case 7: /* unofficial extension */
2737	tt_printf("%-.250s\n", rs[Rs_display_name]);	2693	tt_printf ("%-.250s\n", rs[Rs_display_name]);
2738	break;	2694	break;
2739	#endif	2695	#endif
2740	case 8: /* unofficial extension */	2696	case 8: /* unofficial extension */
2741	xterm_seq (XTerm_title, APL_NAME "-" VERSION, CHAR_ST);	2697	xterm_seq (XTerm_title, APL_NAME "-" VERSION, CHAR_ST);
		2698	break;
		2699
		2700	case XTerm_locale: /* unofficial extension */
		2701	tt_printf ("%-.250s\n", locale);
2742	break;	2702	break;
2743	}	2703	}
2744	break;	2704	break;
2745		2705
2746	case CSI_TBC: /* 8.3.155: (0) TABULATION CLEAR */	2706	case CSI_TBC: /* 8.3.155: (0) TABULATION CLEAR */
…		…
2813	break;	2773	break;
2814	#endif	2774	#endif
2815		2775
2816	case CSI_78: /* DECREQTPARM */	2776	case CSI_78: /* DECREQTPARM */
2817	if (arg[0] == 0 || arg[0] == 1)	2777	if (arg[0] == 0 || arg[0] == 1)
2818	tt_printf("\033[%d;1;1;128;128;1;0x", arg[0] + 2);	2778	tt_printf ("\033[%d;1;1;128;128;1;0x", arg[0] + 2);
2819	/* FALLTHROUGH */	2779	/* FALLTHROUGH */
2820		2780
2821	default:	2781	default:
2822	break;	2782	break;
2823	}	2783	}
…		…
2842	{	2802	{
2843	/*	2803	/*
2844	* commands	2804	* commands
2845	*/	2805	*/
2846	case 1: /* deiconify window */	2806	case 1: /* deiconify window */
2847	XMapWindow(display->display, TermWin.parent[0]);	2807	XMapWindow (display->display, TermWin.parent[0]);
2848	break;	2808	break;
2849	case 2: /* iconify window */	2809	case 2: /* iconify window */
2850	XIconifyWindow(display->display, TermWin.parent[0],	2810	XIconifyWindow (display->display, TermWin.parent[0],
2851	DefaultScreen(display->display));	2811	DefaultScreen (display->display));
2852	break;	2812	break;
2853	case 3: /* set position (pixels) */	2813	case 3: /* set position (pixels) */
2854	XMoveWindow(display->display, TermWin.parent[0], args[1], args[2]);	2814	XMoveWindow (display->display, TermWin.parent[0], args[1], args[2]);
2855	break;	2815	break;
2856	case 4: /* set size (pixels) */	2816	case 4: /* set size (pixels) */
2857	set_widthheight ((unsigned int)args[2], (unsigned int)args[1]);	2817	set_widthheight ((unsigned int)args[2], (unsigned int)args[1]);
2858	break;	2818	break;
2859	case 5: /* raise window */	2819	case 5: /* raise window */
2860	XRaiseWindow(display->display, TermWin.parent[0]);	2820	XRaiseWindow (display->display, TermWin.parent[0]);
2861	break;	2821	break;
2862	case 6: /* lower window */	2822	case 6: /* lower window */
2863	XLowerWindow(display->display, TermWin.parent[0]);	2823	XLowerWindow (display->display, TermWin.parent[0]);
2864	break;	2824	break;
2865	case 7: /* refresh window */	2825	case 7: /* refresh window */
2866	scr_touch (true);	2826	scr_touch (true);
2867	break;	2827	break;
2868	case 8: /* set size (chars) */	2828	case 8: /* set size (chars) */
2869	set_widthheight ((unsigned int)(args[2] * TermWin.fwidth),	2829	set_widthheight ((unsigned int) (args[2] * TermWin.fwidth),
2870	(unsigned int)(args[1] * TermWin.fheight));	2830	(unsigned int) (args[1] * TermWin.fheight));
2871	break;	2831	break;
2872	default:	2832	default:
2873	if (args[0] >= 24) /* set height (chars) */	2833	if (args[0] >= 24) /* set height (chars) */
2874	set_widthheight ((unsigned int)TermWin.width,	2834	set_widthheight ((unsigned int)TermWin.width,
2875	(unsigned int)(args[1] * TermWin.fheight));	2835	(unsigned int) (args[1] * TermWin.fheight));
2876	break;	2836	break;
2877	/*	2837	/*
2878	* reports - some output format copied from XTerm	2838	* reports - some output format copied from XTerm
2879	*/	2839	*/
2880	case 11: /* report window state */	2840	case 11: /* report window state */
2881	XGetWindowAttributes(display->display, TermWin.parent[0], &wattr);	2841	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);
2882	tt_printf("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);	2842	tt_printf ("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);
2883	break;	2843	break;
2884	case 13: /* report window position */	2844	case 13: /* report window position */
2885	XGetWindowAttributes(display->display, TermWin.parent[0], &wattr);	2845	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);
2886	XTranslateCoordinates(display->display, TermWin.parent[0], wattr.root,	2846	XTranslateCoordinates (display->display, TermWin.parent[0], wattr.root,
2887	-wattr.border_width, -wattr.border_width,	2847	-wattr.border_width, -wattr.border_width,
2888	&x, &y, &wdummy);	2848	&x, &y, &wdummy);
2889	tt_printf("\033[3;%d;%dt", x, y);	2849	tt_printf ("\033[3;%d;%dt", x, y);
2890	break;	2850	break;
2891	case 14: /* report window size (pixels) */	2851	case 14: /* report window size (pixels) */
2892	XGetWindowAttributes(display->display, TermWin.parent[0], &wattr);	2852	XGetWindowAttributes (display->display, TermWin.parent[0], &wattr);
2893	tt_printf("\033[4;%d;%dt", wattr.height, wattr.width);	2853	tt_printf ("\033[4;%d;%dt", wattr.height, wattr.width);
2894	break;	2854	break;
2895	case 18: /* report window size (chars) */	2855	case 18: /* report window size (chars) */
2896	tt_printf("\033[8;%d;%dt", TermWin.nrow, TermWin.ncol);	2856	tt_printf ("\033[8;%d;%dt", TermWin.nrow, TermWin.ncol);
2897	break;	2857	break;
2898	#if 0 /* XXX: currently disabled due to security concerns */	2858	#if 0 /* XXX: currently disabled due to security concerns */
2899	case 20: /* report icon label */	2859	case 20: /* report icon label */
2900	XGetIconName(display->display, TermWin.parent[0], &s);	2860	XGetIconName (display->display, TermWin.parent[0], &s);
2901	tt_printf("\033]L%-.200s\234", s ? s : ""); /* 8bit ST */	2861	tt_printf ("\033]L%-.200s\234", s ? s : ""); /* 8bit ST */
2902	break;	2862	break;
2903	case 21: /* report window title */	2863	case 21: /* report window title */
2904	XFetchName(display->display, TermWin.parent[0], &s);	2864	XFetchName (display->display, TermWin.parent[0], &s);
2905	tt_printf("\033]l%-.200s\234", s ? s : ""); /* 8bit ST */	2865	tt_printf ("\033]l%-.200s\234", s ? s : ""); /* 8bit ST */
2906	break;	2866	break;
2907	#endif	2867	#endif
2908		2868
2909	}	2869	}
2910	}	2870	}
2911	#endif	2871	#endif
2912		2872
2913	/*----------------------------------------------------------------------*/	2873	/*----------------------------------------------------------------------*/
2914	/*	2874	/*
2915	* get input up until STRING TERMINATOR (or BEL)	2875	* get input up until STRING TERMINATOR (or BEL)
2916	* ends_how is terminator used. returned input must be free()d	2876	* ends_how is terminator used. returned input must be free ()d
2917	*/	2877	*/
2918	unsigned char *	2878	unsigned char *
2919	rxvt_term::get_to_st (unsigned char *ends_how)	2879	rxvt_term::get_to_st (unsigned char *ends_how)
2920	{	2880	{
2921	int seen_esc = 0; /* seen escape? */	2881	int seen_esc = 0; /* seen escape? */
…		…
2936	}	2896	}
2937	else if (ch == '\t')	2897	else if (ch == '\t')
2938	ch = ' '; /* translate '\t' to space */	2898	ch = ' '; /* translate '\t' to space */
2939	else if (ch < 0x08 || (ch > 0x0d && ch < 0x20))	2899	else if (ch < 0x08 || (ch > 0x0d && ch < 0x20))
2940	return NULL; /* other control character - exit */	2900	return NULL; /* other control character - exit */
2941	if (n < sizeof(string) - 1)	2901	if (n < sizeof (string) - 1)
2942	string[n++] = ch;	2902	string[n++] = ch;
2943	seen_esc = 0;	2903	seen_esc = 0;
2944	}	2904	}
2945	string[n++] = '\0';	2905	string[n++] = '\0';
2946	if ((s = (unsigned char *)rxvt_malloc(n)) == NULL)	2906	if ((s = (unsigned char *)rxvt_malloc (n)) == NULL)
2947	return NULL;	2907	return NULL;
2948	*ends_how = (ch == 0x5c ? C0_ESC : ch);	2908	*ends_how = (ch == 0x5c ? C0_ESC : ch);
2949	STRNCPY(s, string, n);	2909	STRNCPY (s, string, n);
2950	return s;	2910	return s;
2951	}	2911	}
2952		2912
2953	/*----------------------------------------------------------------------*/	2913	/*----------------------------------------------------------------------*/
2954	/*	2914	/*
…		…
2961	/*	2921	/*
2962	* Not handled yet	2922	* Not handled yet
2963	*/	2923	*/
2964	s = get_to_st (&eh);	2924	s = get_to_st (&eh);
2965	if (s)	2925	if (s)
2966	free(s);	2926	free (s);
2967	return;	2927	return;
2968	}	2928	}
2969		2929
2970	/*----------------------------------------------------------------------*/	2930	/*----------------------------------------------------------------------*/
2971	/*	2931	/*
…		…
2976	{	2936	{
2977	unsigned char ch, eh, *s;	2937	unsigned char ch, eh, *s;
2978	int arg;	2938	int arg;
2979		2939
2980	ch = cmd_getc ();	2940	ch = cmd_getc ();
2981	for (arg = 0; isdigit(ch); ch = cmd_getc ())	2941	for (arg = 0; isdigit (ch); ch = cmd_getc ())
2982	arg = arg * 10 + (ch - '0');	2942	arg = arg * 10 + (ch - '0');
2983		2943
2984	if (ch == ';')	2944	if (ch == ';')
2985	{	2945	{
2986	s = get_to_st (&eh);	2946	s = get_to_st (&eh);
2987	if (s)	2947	if (s)
2988	{	2948	{
2989	/*	2949	/*
2990	* rxvt_menubar_dispatch() violates the constness of the string,	2950	* rxvt_menubar_dispatch () violates the constness of the string,
2991	* so do it here	2951	* so do it here
2992	*/	2952	*/
2993	if (arg == XTerm_Menu)	2953	if (arg == XTerm_Menu)
2994	#if 0 /* XXX: currently disabled due to security concerns */	2954	#if 0 /* XXX: currently disabled due to security concerns */
2995	menubar_dispatch ((char *)s);	2955	menubar_dispatch ((char *)s);
2996	#else	2956	#else
2997	(void)0;	2957	(void)0;
2998	#endif	2958	#endif
2999	else	2959	else
3000	xterm_seq (arg, (char *)s, eh);	2960	xterm_seq (arg, (char *)s, eh);
3001	free(s);	2961	free (s);
3002	}	2962	}
3003	}	2963	}
3004	}	2964	}
3005	/*	2965	/*
3006	* XTerm escape sequences: ESC ] Ps;Pt (ST|BEL)	2966	* XTerm escape sequences: ESC ] Ps;Pt (ST|BEL)
…		…
3015	* 19 = change underlined character color	2975	* 19 = change underlined character color
3016	* 46 = change logfile (not implemented)	2976	* 46 = change logfile (not implemented)
3017	* 50 = change font	2977	* 50 = change font
3018	*	2978	*
3019	* rxvt extensions:	2979	* rxvt extensions:
		2980	* 9 = change locale (NYI)
3020	* 10 = menu (may change in future)	2981	* 10 = menu (may change in future)
3021	* 20 = bg pixmap	2982	* 20 = bg pixmap
3022	* 39 = change default fg color	2983	* 39 = change default fg color
3023	* 49 = change default bg color	2984	* 49 = change default bg color
3024	* 55 = dump scrollback buffer and all of screen	2985	* 55 = dump scrollback buffer and all of screen
3025	*/	2986	*/
3026	void	2987	void
3027	rxvt_term::xterm_seq (int op, const char *str, unsigned char resp __attribute__((unused)))	2988	rxvt_term::xterm_seq (int op, const char *str, unsigned char resp __attribute__ ((unused)))
3028	{	2989	{
3029	int changed = 0;	2990	int changed = 0;
3030	int color;	2991	int color;
3031	char *buf, *name;	2992	char *buf, *name;
3032		2993
3033	assert(str != NULL);	2994	assert (str != NULL);
3034	switch (op)	2995	switch (op)
3035	{	2996	{
3036	case XTerm_name:	2997	case XTerm_name:
3037	set_title (str);	2998	set_title (str);
3038	/* FALLTHROUGH */	2999	/* FALLTHROUGH */
…		…
3043	set_title (str);	3004	set_title (str);
3044	break;	3005	break;
3045	case XTerm_Color:	3006	case XTerm_Color:
3046	for (buf = (char *)str; buf && *buf;)	3007	for (buf = (char *)str; buf && *buf;)
3047	{	3008	{
3048	if ((name = STRCHR(buf, ';')) == NULL)	3009	if ((name = STRCHR (buf, ';')) == NULL)
3049	break;	3010	break;
3050	*name++ = '\0';	3011	*name++ = '\0';
3051	color = atoi(buf);	3012	color = atoi (buf);
3052	if (color < 0 || color >= TOTAL_COLORS)	3013	if (color < 0 || color >= TOTAL_COLORS)
3053	break;	3014	break;
3054	if ((buf = STRCHR(name, ';')) != NULL)	3015	if ((buf = STRCHR (name, ';')) != NULL)
3055	*buf++ = '\0';	3016	*buf++ = '\0';
3056	set_window_color (color + minCOLOR, name);	3017	set_window_color (color + minCOLOR, name);
3057	}	3018	}
3058	break;	3019	break;
3059	#ifndef NO_CURSORCOLOR	3020	#ifndef NO_CURSORCOLOR
…		…
3076	break;	3037	break;
3077	#endif	3038	#endif
3078		3039
3079	case XTerm_Menu:	3040	case XTerm_Menu:
3080	/*	3041	/*
3081	* rxvt_menubar_dispatch() violates the constness of the string,	3042	* rxvt_menubar_dispatch () violates the constness of the string,
3082	* so DON'T do it here	3043	* so DON'T do it here
3083	*/	3044	*/
3084	break;	3045	break;
3085	case XTerm_Pixmap:	3046	case XTerm_Pixmap:
3086	if (*str != ';')	3047	if (*str != ';')
…		…
3089	scale_pixmap (""); /* reset to default scaling */	3050	scale_pixmap (""); /* reset to default scaling */
3090	set_bgPixmap (str); /* change pixmap */	3051	set_bgPixmap (str); /* change pixmap */
3091	#endif	3052	#endif
3092	scr_touch (true);	3053	scr_touch (true);
3093	}	3054	}
3094	while ((str = STRCHR(str, ';')) != NULL)	3055	while ((str = STRCHR (str, ';')) != NULL)
3095	{	3056	{
3096	str++;	3057	str++;
3097	#if XPM_BACKGROUND	3058	#if XPM_BACKGROUND
3098	changed += scale_pixmap (str);	3059	changed += scale_pixmap (str);
3099	#endif	3060	#endif
…		…
3115	set_window_color (Color_bg, str);	3076	set_window_color (Color_bg, str);
3116	break;	3077	break;
3117	case XTerm_logfile:	3078	case XTerm_logfile:
3118	break;	3079	break;
3119	case XTerm_font:	3080	case XTerm_font:
3120	change_font (0, str);	3081	change_font (str);
		3082	break;
		3083	case XTerm_locale:
		3084	set_locale (str);
		3085	im_cb ();
3121	break;	3086	break;
3122	#if 0	3087	#if 0
3123	case XTerm_dumpscreen: /* no error notices */	3088	case XTerm_dumpscreen: /* no error notices */
3124	{	3089	{
3125	int fd;	3090	int fd;
3126	if ((fd = open(str, O_RDWR | O_CREAT | O_EXCL, 0600)) >= 0)	3091	if ((fd = open (str, O_RDWR | O_CREAT | O_EXCL, 0600)) >= 0)
3127	{	3092	{
3128	scr_dump (fd);	3093	scr_dump (fd);
3129	close(fd);	3094	close (fd);
3130	}	3095	}
3131	}	3096	}
3132	break;	3097	break;
3133	#endif	3098	#endif
3134		3099
…		…
3159	else	3124	else
3160	{	3125	{
3161	if (mode == 'r')	3126	if (mode == 'r')
3162	state = (SavedModes & bit) ? 1 : 0; /* no overlapping */	3127	state = (SavedModes & bit) ? 1 : 0; /* no overlapping */
3163	else	3128	else
3164	state = (mode == 't') ? !(PrivateModes & bit) : mode;	3129	state = (mode == 't') ? ! (PrivateModes & bit) : mode;
3165	PrivMode(state, bit);	3130	PrivMode (state, bit);
3166	}	3131	}
3167	return state;	3132	return state;
3168	}	3133	}
3169		3134
3170	/* we're not using priv _yet_ */	3135	/* we're not using priv _yet_ */
3171	void	3136	void
3172	rxvt_term::process_terminal_mode (int mode, int priv __attribute__((unused)), unsigned int nargs, const int *arg)	3137	rxvt_term::process_terminal_mode (int mode, int priv __attribute__ ((unused)), unsigned int nargs, const int *arg)
3173	{	3138	{
3174	unsigned int i, j;	3139	unsigned int i, j;
3175	int state;	3140	int state;
3176	static const struct	3141	static const struct
3177	{	3142	{
…		…
3220	for (i = 0; i < nargs; i++)	3185	for (i = 0; i < nargs; i++)
3221	{	3186	{
3222	state = -1;	3187	state = -1;
3223		3188
3224	/* basic handling */	3189	/* basic handling */
3225	for (j = 0; j < (sizeof(argtopriv)/sizeof(argtopriv[0])); j++)	3190	for (j = 0; j < (sizeof (argtopriv)/sizeof (argtopriv[0])); j++)
3226	if (argtopriv[j].argval == arg[i])	3191	if (argtopriv[j].argval == arg[i])
3227	{	3192	{
3228	state = privcases (mode, argtopriv[j].bit);	3193	state = privcases (mode, argtopriv[j].bit);
3229	break;	3194	break;
3230	}	3195	}
…		…
3238	scr_cursor (RESTORE);	3203	scr_cursor (RESTORE);
3239	else if (mode == 1)	3204	else if (mode == 1)
3240	scr_cursor (SAVE);	3205	scr_cursor (SAVE);
3241	/* FALLTHROUGH */	3206	/* FALLTHROUGH */
3242	default:	3207	default:
3243	continue; /* for(;i;) */	3208	continue; /* for (;i;) */
3244	}	3209	}
3245		3210
3246	/* extra handling for values with valid 0 or 1 state */	3211	/* extra handling for values with valid 0 or 1 state */
3247	switch (arg[i])	3212	switch (arg[i])
3248	{	3213	{
…		…
3250	case 2: /* VT52 mode */	3215	case 2: /* VT52 mode */
3251	/* oddball mode. should be set regardless of set/reset	3216	/* oddball mode. should be set regardless of set/reset
3252	* parameter. Return from VT52 mode with an ESC < from	3217	* parameter. Return from VT52 mode with an ESC < from
3253	* within VT52 mode	3218	* within VT52 mode
3254	*/	3219	*/
3255	PrivMode(1, PrivMode_vt52);	3220	PrivMode (1, PrivMode_vt52);
3256	break;	3221	break;
3257	case 3: /* 80/132 */	3222	case 3: /* 80/132 */
3258	if (PrivateModes & PrivMode_132OK)	3223	if (PrivateModes & PrivMode_132OK)
3259	set_widthheight ( (unsigned int)((state ? 132 : 80) * TermWin.fwidth),	3224	set_widthheight ( (unsigned int) ((state ? 132 : 80) * TermWin.fwidth),
3260	(unsigned int)TermWin.height);	3225	(unsigned int)TermWin.height);
3261	break;	3226	break;
3262	case 4: /* smooth scrolling */	3227	case 4: /* smooth scrolling */
3263	if (state)	3228	if (state)
3264	Options &= ~Opt_jumpScroll;	3229	Options &= ~Opt_jumpScroll;
…		…
3275	scr_autowrap (state);	3240	scr_autowrap (state);
3276	break;	3241	break;
3277	/* case 8: - auto repeat, can't do on a per window basis */	3242	/* case 8: - auto repeat, can't do on a per window basis */
3278	case 9: /* X10 mouse reporting */	3243	case 9: /* X10 mouse reporting */
3279	if (state) /* orthogonal */	3244	if (state) /* orthogonal */
3280	PrivateModes &= ~(PrivMode_MouseX11);	3245	PrivateModes &= ~ (PrivMode_MouseX11);
3281	break;	3246	break;
3282	#ifdef menuBar_esc	3247	#ifdef menuBar_esc
3283	case menuBar_esc:	3248	case menuBar_esc:
3284	#ifdef MENUBAR	3249	#ifdef MENUBAR
3285	map_menuBar (state);	3250	map_menuBar (state);
…		…
3305	break;	3270	break;
3306	/* case 66: - application key pad */	3271	/* case 66: - application key pad */
3307	/* case 67: - backspace key */	3272	/* case 67: - backspace key */
3308	case 1000: /* X11 mouse reporting */	3273	case 1000: /* X11 mouse reporting */
3309	if (state) /* orthogonal */	3274	if (state) /* orthogonal */
3310	PrivateModes &= ~(PrivMode_MouseX10);	3275	PrivateModes &= ~ (PrivMode_MouseX10);
3311	break;	3276	break;
3312	#if 0	3277	#if 0
3313	case 1001:	3278	case 1001:
3314	break; /* X11 mouse highlighting */	3279	break; /* X11 mouse highlighting */
3315	#endif	3280	#endif
…		…
3385	break;	3350	break;
3386	}	3351	}
3387	if (rendset != -1)	3352	if (rendset != -1)
3388	{	3353	{
3389	scr_rendition (rendset, rendstyle);	3354	scr_rendition (rendset, rendstyle);
3390	continue; /* for(;i;) */	3355	continue; /* for (;i;) */
3391	}	3356	}
3392		3357
3393	switch (arg[i])	3358	switch (arg[i])
3394	{	3359	{
3395	case 30:	3360	case 30:
…		…
3398	case 33:	3363	case 33:
3399	case 34:	3364	case 34:
3400	case 35:	3365	case 35:
3401	case 36:	3366	case 36:
3402	case 37:	3367	case 37:
3403	scr_color ((unsigned int)(minCOLOR + (arg[i] - 30)),	3368	scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)),
3404	Color_fg);	3369	Color_fg);
3405	break;	3370	break;
3406	#ifdef TTY_256COLOR	3371	#ifdef TTY_256COLOR
3407	case 38:	3372	case 38:
3408	if (nargs > i + 2 && arg[i + 1] == 5)	3373	if (nargs > i + 2 && arg[i + 1] == 5)
3409	{	3374	{
3410	scr_color ((unsigned int)(minCOLOR + arg[i + 2]),	3375	scr_color ((unsigned int) (minCOLOR + arg[i + 2]),
3411	Color_fg);	3376	Color_fg);
3412	i += 2;	3377	i += 2;
3413	}	3378	}
3414	break;	3379	break;
3415	#endif	3380	#endif
…		…
3423	case 43:	3388	case 43:
3424	case 44:	3389	case 44:
3425	case 45:	3390	case 45:
3426	case 46:	3391	case 46:
3427	case 47:	3392	case 47:
3428	scr_color ((unsigned int)(minCOLOR + (arg[i] - 40)),	3393	scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)),
3429	Color_bg);	3394	Color_bg);
3430	break;	3395	break;
3431	#ifdef TTY_256COLOR	3396	#ifdef TTY_256COLOR
3432	case 48:	3397	case 48:
3433	if (nargs > i + 2 && arg[i + 1] == 5)	3398	if (nargs > i + 2 && arg[i + 1] == 5)
3434	{	3399	{
3435	scr_color ((unsigned int)(minCOLOR + arg[i + 2]),	3400	scr_color ((unsigned int) (minCOLOR + arg[i + 2]),
3436	Color_bg);	3401	Color_bg);
3437	i += 2;	3402	i += 2;
3438	}	3403	}
3439	break;	3404	break;
3440	#endif	3405	#endif
…		…
3449	case 93:	3414	case 93:
3450	case 94:	3415	case 94:
3451	case 95:	3416	case 95:
3452	case 96:	3417	case 96:
3453	case 97:	3418	case 97:
3454	scr_color ((unsigned int)(minBrightCOLOR + (arg[i] - 90)),	3419	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 90)),
3455	Color_fg);	3420	Color_fg);
3456	break;	3421	break;
3457	case 100:	3422	case 100:
3458	case 101: /* set bright bg color */	3423	case 101: /* set bright bg color */
3459	case 102:	3424	case 102:
3460	case 103:	3425	case 103:
3461	case 104:	3426	case 104:
3462	case 105:	3427	case 105:
3463	case 106:	3428	case 106:
3464	case 107:	3429	case 107:
3465	scr_color ((unsigned int)(minBrightCOLOR + (arg[i] - 100)),	3430	scr_color ((unsigned int) (minBrightCOLOR + (arg[i] - 100)),
3466	Color_bg);	3431	Color_bg);
3467	break;	3432	break;
3468	#endif	3433	#endif
3469		3434
3470	}	3435	}
…		…
3476	void	3441	void
3477	rxvt_term::process_graphics ()	3442	rxvt_term::process_graphics ()
3478	{	3443	{
3479	unsigned char ch, cmd = cmd_getc ();	3444	unsigned char ch, cmd = cmd_getc ();
3480		3445
3481	#ifndef RXVT_GRAPHICS
3482	if (cmd == 'Q')	3446	if (cmd == 'Q')
3483	{ /* query graphics */	3447	{ /* query graphics */
3484	tt_printf("\033G0\n"); /* no graphics */	3448	tt_printf ("\033G0\n"); /* no graphics */
3485	return;	3449	return;
3486	}	3450	}
3487	/* swallow other graphics sequences until terminating ':' */	3451	/* swallow other graphics sequences until terminating ':' */
3488	do	3452	do
3489	ch = cmd_getc ();	3453	ch = cmd_getc ();
3490	while (ch != ':');	3454	while (ch != ':');
3491	#else
3492	unsigned int nargs;
3493	int args[NGRX_PTS];
3494	unsigned char *text = NULL;
3495
3496	if (cmd == 'Q')
3497	{ /* query graphics */
3498	tt_printf("\033G1\n"); /* yes, graphics (color) */
3499	return;
3500	}
3501	for (nargs = 0; nargs < (sizeof(args) / sizeof(args[0])) - 1;)
3502	{
3503	int neg;
3504
3505	ch = cmd_getc ();
3506	neg = (ch == '-');
3507	if (neg || ch == '+')
3508	ch = cmd_getc ();
3509
3510	for (args[nargs] = 0; isdigit(ch); ch = cmd_getc ())
3511	args[nargs] = args[nargs] * 10 + (ch - '0');
3512	if (neg)
3513	args[nargs] = -args[nargs];
3514
3515	nargs++;
3516	args[nargs] = 0;
3517	if (ch != ';')
3518	break;
3519	}
3520
3521	if ((cmd == 'T') && (nargs >= 5))
3522	{
3523	int i, len = args[4];
3524
3525	text = (unsigned char *)rxvt_malloc((len + 1) * sizeof(char));
3526
3527	if (text != NULL)
3528	{
3529	for (i = 0; i < len; i++)
3530	text[i] = cmd_getc ();
3531	text[len] = '\0';
3532	}
3533	}
3534	Gr_do_graphics (cmd, nargs, args, text);
3535	#endif
3536	}	3455	}
3537	/*}}} */	3456	/*}}} */
3538		3457
3539	/* ------------------------------------------------------------------------- */	3458	/* ------------------------------------------------------------------------- */
3540		3459
3541	/*	3460	/*
3542	* Send printf() formatted output to the command.	3461	* Send printf () formatted output to the command.
3543	* Only use for small amounts of data.	3462	* Only use for small amounts of data.
3544	*/	3463	*/
3545	void	3464	void
3546	rxvt_term::tt_printf (const char *fmt,...)	3465	rxvt_term::tt_printf (const char *fmt,...)
3547	{	3466	{

Diff Legend

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