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.45 by pcg, Sat Feb 21 20:33:39 2004 UTC vs.
Revision 1.73 by pcg, Mon Mar 15 00:08:11 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.
…		…
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	/* make sure the user can type ctrl-@, i.e. NUL */
		116	if (len == 1 && *wkbuf == 0)
		117	{
		118	kbuf[0] = 0;
		119	len = 1;
		120	}
		121	else
		122	{
115	wkbuf[len] = 0;	123	wkbuf[len] = 0;
116	len = wcstombs ((char *)kbuf, wkbuf, KBUFSZ);	124	len = wcstombs ((char *)kbuf, wkbuf, KBUFSZ);
117	if (len < 0)	125	if (len < 0)
118	len = 0;	126	len = 0;
		127	}
119	}	128	}
120	else	129	else
121	len = 0;	130	len = 0;
122	}	131	}
123		132
124	valid_keysym = status_return == XLookupKeySym	133	valid_keysym = status_return == XLookupKeySym
125	|| status_return == XLookupBoth;	134	|| status_return == XLookupBoth;
126	}	135	}
127	else	136	else
128	#endif	137	#endif
129
130	{	138	{
131	len = XLookupString (&ev, (char *)kbuf, KBUFSZ, &keysym, &compose);	139	len = XLookupString (&ev, (char *)kbuf, KBUFSZ, &keysym, &compose);
132	valid_keysym = !len;	140	valid_keysym = keysym != NoSymbol;
133	}	141	}
134		142
135	if (valid_keysym)	143	if (valid_keysym)
136	{	144	{
137	/* for some backwards compatibility */
138	#if defined(HOTKEY_CTRL) || defined(HOTKEY_META)
139	# ifdef HOTKEY_CTRL
140	if (ctrl)
141	# else
142	if (meta)
143	# endif
144	{
145	if (keysym == ks_bigfont)
146	{
147	change_font (0, FONT_UP);
148	return;
149	}
150	else if (keysym == ks_smallfont)
151	{
152	change_font (0, FONT_DN);
153	return;
154	}
155	}
156	#endif
157
158	if (TermWin.saveLines)	145	if (TermWin.saveLines)
159	{	146	{
160	#ifdef UNSHIFTED_SCROLLKEYS	147	#ifdef UNSHIFTED_SCROLLKEYS
161	if (!ctrl && !meta)	148	if (!ctrl && !meta)
162	{	149	{
163	#else	150	#else
164	if (IS_SCROLL_MOD)	151	if (IS_SCROLL_MOD)
165	{	152	{
166	#endif	153	#endif
167	int lnsppg;	154	int lnsppg;
168		155
169	#ifdef PAGING_CONTEXT_LINES	156	#ifdef PAGING_CONTEXT_LINES
170	lnsppg = TermWin.nrow - PAGING_CONTEXT_LINES;	157	lnsppg = TermWin.nrow - PAGING_CONTEXT_LINES;
171	#else	158	#else
172	lnsppg = TermWin.nrow * 4 / 5;	159	lnsppg = TermWin.nrow * 4 / 5;
…		…
210	scr_move_to (1, 0);	197	scr_move_to (1, 0);
211	return;	198	return;
212	}	199	}
213	}	200	}
214	#endif	201	#endif
215
216	}	202	}
217		203
218	if (shft)	204	if (shft)
219	{	205	{
220	/* Shift + F1 - F10 generates F11 - F20 */	206	/* Shift + F1 - F10 generates F11 - F20 */
…		…
231	case XK_Insert: /* Shift+Insert = paste mouse selection */	217	case XK_Insert: /* Shift+Insert = paste mouse selection */
232	selection_request (ev.time, 0, 0);	218	selection_request (ev.time, 0, 0);
233	return;	219	return;
234	/* rxvt extras */	220	/* rxvt extras */
235	case XK_KP_Add: /* Shift+KP_Add = bigger font */	221	case XK_KP_Add: /* Shift+KP_Add = bigger font */
236	change_font (0, FONT_UP);	222	change_font (FONT_UP);
237	return;	223	return;
238	case XK_KP_Subtract: /* Shift+KP_Subtract = smaller font */	224	case XK_KP_Subtract: /* Shift+KP_Subtract = smaller font */
239	change_font (0, FONT_DN);	225	change_font (FONT_DN);
240	return;	226	return;
241	}	227	}
242	}	228	}
243	}	229	}
244	#ifdef PRINTPIPE	230	#ifdef PRINTPIPE
245	if (keysym == XK_Print)	231	if (keysym == XK_Print)
246	{	232	{
247	scr_printscreen (ctrl | shft);	233	scr_printscreen (ctrl | shft);
248	return;
249	}
250	#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;	234	return;
265	}	235	}
266	#endif	236	#endif
267		237
268	if (keysym >= 0xFF00 && keysym <= 0xFFFF)	238	if (keysym >= 0xFF00 && keysym <= 0xFFFF)
…		…
270	#ifdef KEYSYM_RESOURCE	240	#ifdef KEYSYM_RESOURCE
271	if (! (shft | ctrl) && Keysym_map[keysym & 0xFF] != NULL)	241	if (! (shft | ctrl) && Keysym_map[keysym & 0xFF] != NULL)
272	{	242	{
273	unsigned int l;	243	unsigned int l;
274	const unsigned char *kbuf0;	244	const unsigned char *kbuf0;
275	const unsigned char ch = C0_ESC;
276		245
277	kbuf0 = (Keysym_map[keysym & 0xFF]);	246	kbuf0 = (Keysym_map[keysym & 0xFF]);
278	l = (unsigned int)*kbuf0++;	247	l = (unsigned int)*kbuf0++;
279		248
280	/* escape prefix */	249	/* escape prefix */
281	if (meta)	250	if (meta
282	# ifdef META8_OPTION	251	# ifdef META8_OPTION
283	if (meta_char == C0_ESC)	252	&& meta_char == C0_ESC
284	# endif	253	# endif
		254	)
		255	{
		256	const unsigned char ch = C0_ESC;
285	tt_write (&ch, 1);	257	tt_write (&ch, 1);
		258	}
		259
286	tt_write (kbuf0, l);	260	tt_write (kbuf0, l);
287	return;	261	return;
288	}	262	}
289	else	263	else
290	#endif	264	#endif
291
292	{	265	{
293	newlen = 1;	266	newlen = 1;
294	switch (keysym)	267	switch (keysym)
295	{	268	{
296	#ifndef NO_BACKSPACE_KEY	269	#ifndef NO_BACKSPACE_KEY
…		…
301	^ !!ctrl) ? '\b' : '\177';	274	^ !!ctrl) ? '\b' : '\177';
302	kbuf[1] = '\0';	275	kbuf[1] = '\0';
303	}	276	}
304	else	277	else
305	STRCPY (kbuf, key_backspace);	278	STRCPY (kbuf, key_backspace);
306	# ifdef MULTICHAR_SET
307	if ((Options & Opt_mc_hack) && screen.cur.col > 0)
308	{
309	int col, row;
310
311	newlen = STRLEN (kbuf);
312	col = screen.cur.col - 1;
313	row = screen.cur.row + TermWin.saveLines;
314	if (IS_MULTI2 (screen.rend[row][col]))
315	MEMMOVE (kbuf + newlen, kbuf, newlen + 1);
316	}
317	# endif
318	break;	279	break;
319	#endif	280	#endif
320	#ifndef NO_DELETE_KEY	281	#ifndef NO_DELETE_KEY
321	case XK_Delete:	282	case XK_Delete:
322	STRCPY (kbuf, key_delete);	283	STRCPY (kbuf, key_delete);
323	# ifdef MULTICHAR_SET
324	if (Options & Opt_mc_hack)
325	{
326	int col, row;
327
328	newlen = STRLEN (kbuf);
329	col = screen.cur.col;
330	row = screen.cur.row + TermWin.saveLines;
331	if (IS_MULTI1 (screen.rend[row][col]))
332	MEMMOVE (kbuf + newlen, kbuf, newlen + 1);
333	}
334	# endif
335	break;	284	break;
336	#endif	285	#endif
337	case XK_Tab:	286	case XK_Tab:
338	if (shft)	287	if (shft)
339	STRCPY (kbuf, "\033[Z");	288	STRCPY (kbuf, "\033[Z");
…		…
349	#endif	298	#endif
350	newlen = 0;	299	newlen = 0;
351	}	300	}
352	break;	301	break;
353		302
354
355	#ifdef XK_KP_Left	303	#ifdef XK_KP_Left
356	case XK_KP_Up: /* \033Ox or standard */	304	case XK_KP_Up: /* \033Ox or standard */
357	case XK_KP_Down: /* \033Or or standard */	305	case XK_KP_Down: /* \033Or or standard */
358	case XK_KP_Right: /* \033Ov or standard */	306	case XK_KP_Right: /* \033Ov or standard */
359	case XK_KP_Left: /* \033Ot or standard */	307	case XK_KP_Left: /* \033Ot or standard */
360	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	308	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)
361	{	309	{
362	STRCPY (kbuf, "\033OZ");	310	STRCPY (kbuf, "\033OZ");
363	kbuf[2] = ("txvr"[keysym - XK_KP_Left]);	311	kbuf[2] = "txvr"[keysym - XK_KP_Left];
364	break;	312	break;
365	}	313	}
366	else	314	else
367	/* translate to std. cursor key */	315	/* translate to std. cursor key */
368	keysym = XK_Left + (keysym - XK_KP_Left);	316	keysym = XK_Left + (keysym - XK_KP_Left);
…		…
371	case XK_Up: /* "\033[A" */	319	case XK_Up: /* "\033[A" */
372	case XK_Down: /* "\033[B" */	320	case XK_Down: /* "\033[B" */
373	case XK_Right: /* "\033[C" */	321	case XK_Right: /* "\033[C" */
374	case XK_Left: /* "\033[D" */	322	case XK_Left: /* "\033[D" */
375	STRCPY (kbuf, "\033[Z");	323	STRCPY (kbuf, "\033[Z");
376	kbuf[2] = ("DACB"[keysym - XK_Left]);	324	kbuf[2] = "DACB"[keysym - XK_Left];
377	/* do Shift first */	325	/* do Shift first */
378	if (shft)	326	if (shft)
379	kbuf[2] = ("dacb"[keysym - XK_Left]);	327	kbuf[2] = "dacb"[keysym - XK_Left];
380	else if (ctrl)	328	else if (ctrl)
381	{	329	{
382	kbuf[1] = 'O';	330	kbuf[1] = 'O';
383	kbuf[2] = ("dacb"[keysym - XK_Left]);	331	kbuf[2] = "dacb"[keysym - XK_Left];
384	}	332	}
385	else if (PrivateModes & PrivMode_aplCUR)	333	else if (PrivateModes & PrivMode_aplCUR)
386	kbuf[1] = 'O';	334	kbuf[1] = 'O';
387	#ifdef MULTICHAR_SET
388	//TODO: ??
389	if (Options & Opt_mc_hack)
390	{
391	int col, row, m;
392
393	col = screen.cur.col;
394	row = screen.cur.row + TermWin.saveLines;
395	m = 0;
396	if (keysym == XK_Right
397	&& IS_MULTI1 (screen.rend[row][col]))
398	m = 1;
399	else if (keysym == XK_Left)
400	{
401	if (col > 0)
402	{
403	if (IS_MULTI2 (screen.rend[row][col - 1]))
404	m = 1;
405	}
406	else if (screen.cur.row > 0)
407	{
408	col = screen.tlen[--row];
409	if (col == -1)
410	col = TermWin.ncol - 1;
411	else
412	col--;
413	if (col > 0
414	&& IS_MULTI2 (screen.rend[row][col]))
415	m = 1;
416	}
417	}
418	if (m)
419	MEMMOVE (kbuf + 3, kbuf, 3 + 1);
420	}
421	#endif
422	break;	335	break;
423		336
424	#ifndef UNSHIFTED_SCROLLKEYS	337	#ifndef UNSHIFTED_SCROLLKEYS
425	# ifdef XK_KP_Prior	338	# ifdef XK_KP_Prior
426	case XK_KP_Prior:	339	case XK_KP_Prior:
…		…
482	STRCPY (kbuf, "\033OP");	395	STRCPY (kbuf, "\033OP");
483	kbuf[2] += (keysym - XK_KP_F1);	396	kbuf[2] += (keysym - XK_KP_F1);
484	break;	397	break;
485		398
486	case XK_KP_Multiply: /* "\033Oj" : "*" */	399	case XK_KP_Multiply: /* "\033Oj" : "*" */
487	case XK_KP_Add: /* "\033Ok" : "+" */	400	case XK_KP_Add: /* "\033Ok" : "+" */
488	case XK_KP_Separator: /* "\033Ol" : "," */	401	case XK_KP_Separator: /* "\033Ol" : "," */
489	case XK_KP_Subtract: /* "\033Om" : "-" */	402	case XK_KP_Subtract: /* "\033Om" : "-" */
490	case XK_KP_Decimal: /* "\033On" : "." */	403	case XK_KP_Decimal: /* "\033On" : "." */
491	case XK_KP_Divide: /* "\033Oo" : "/" */	404	case XK_KP_Divide: /* "\033Oo" : "/" */
492	case XK_KP_0: /* "\033Op" : "0" */	405	case XK_KP_0: /* "\033Op" : "0" */
…		…
615	break;	528	break;
616	}	529	}
617	if (newlen)	530	if (newlen)
618	len = STRLEN (kbuf);	531	len = STRLEN (kbuf);
619	}	532	}
		533
620	/*	534	/*
621	* Pass meta for all function keys, if 'meta' option set	535	* Pass meta for all function keys, if 'meta' option set
622	*/	536	*/
623	#ifdef META8_OPTION	537	#ifdef META8_OPTION
624	if (meta && (meta_char == 0x80) && len > 0)	538	if (meta && (meta_char == 0x80) && len > 0)
…		…
639	{	553	{
640	unsigned char *ch;	554	unsigned char *ch;
641		555
642	for (ch = kbuf; ch < kbuf + len; ch++)	556	for (ch = kbuf; ch < kbuf + len; ch++)
643	*ch |= 0x80;	557	*ch |= 0x80;
		558
644	meta = 0;	559	meta = 0;
645	}	560	}
646	#endif
647	#ifdef GREEK_SUPPORT
648	if (greek_mode)
649	len = greek_xlat (kbuf, len);
650	#endif	561	#endif
651	/* nil */ ;	562	/* nil */ ;
652	}	563	}
653	}	564	}
654		565
…		…
677	kbuf[len - 1] = (shft ? (ctrl ? '@' : '$') : (ctrl ? '^' : '~'));	588	kbuf[len - 1] = (shft ? (ctrl ? '@' : '$') : (ctrl ? '^' : '~'));
678		589
679	/* escape prefix */	590	/* escape prefix */
680	if (meta	591	if (meta
681	#ifdef META8_OPTION	592	#ifdef META8_OPTION
682	&& (meta_char == C0_ESC)	593	&& meta_char == C0_ESC
683	#endif	594	#endif
684	)	595	)
685	{	596	{
686	const unsigned char ch = C0_ESC;	597	const unsigned char ch = C0_ESC;
687
688	tt_write (&ch, 1);	598	tt_write (&ch, 1);
689	}	599	}
		600
690	#ifdef DEBUG_CMD	601	#if defined(DEBUG_CMD)
691	if (debug_key)
692	{ /* Display keyboard buffer contents */	602	/* Display keyboard buffer contents */
693	char *p;	603	unsigned char *p;
694	int i;	604	int i;
695		605
696	fprintf (stderr, "key 0x%04X [%d]: `", (unsigned int)keysym, len);	606	fprintf (stderr, "key 0x%04X [%d]: `", (unsigned int)keysym, len);
697	for (i = 0, p = kbuf; i < len; i++, p++)	607	for (i = 0, p = kbuf; i < len; i++, p++)
698	fprintf (stderr, (*p >= ' ' && *p < '\177' ? "%c" : "\\%03o"), *p);	608	fprintf (stderr, (*p >= ' ' && *p < '\177' ? "%c" : "\\%03o"), *p);
699	fprintf (stderr, "'\n");	609	fprintf (stderr, "'\n");
700	}
701	#endif /* DEBUG_CMD */	610	#endif /* DEBUG_CMD */
702	tt_write (kbuf, (unsigned int)len);	611	tt_write (kbuf, (unsigned int)len);
703	}	612	}
704	/*}}} */	613	/*}}} */
705		614
…		…
711	{	620	{
712	unsigned int n, s;	621	unsigned int n, s;
713		622
714	n = cmdbuf_ptr - cmdbuf_base;	623	n = cmdbuf_ptr - cmdbuf_base;
715	s = cmdbuf_base + BUFSIZ - 1 - cmdbuf_endp;	624	s = cmdbuf_base + BUFSIZ - 1 - cmdbuf_endp;
		625
716	if (n > 0 && s < count)	626	if (n > 0 && s < count)
717	{	627	{
718	MEMMOVE (cmdbuf_base, cmdbuf_ptr,	628	MEMMOVE (cmdbuf_base, cmdbuf_ptr,
719	(unsigned int) (cmdbuf_endp - cmdbuf_ptr));	629	(unsigned int) (cmdbuf_endp - cmdbuf_ptr));
720	cmdbuf_ptr = cmdbuf_base;	630	cmdbuf_ptr = cmdbuf_base;
721	cmdbuf_endp -= n;	631	cmdbuf_endp -= n;
722	s += n;	632	s += n;
723	}	633	}
		634
724	if (count > s)	635	if (count > s)
725	{	636	{
726	rxvt_print_error ("data loss: cmd_write too large");	637	rxvt_print_error ("data loss: cmd_write too large");
727	count = s;	638	count = s;
728	}	639	}
		640
729	for (; count--;)	641	for (; count--;)
730	*cmdbuf_endp++ = *str++;	642	*cmdbuf_endp++ = *str++;
		643
		644	cmd_parse ();
		645
731	return 0;	646	return 0;
732	}	647	}
733	#endif /* MENUBAR_MAX */	648	#endif /* MENUBAR_MAX */
734		649
735	void	650	void
…		…
807	cmdbuf_endp += n;	722	cmdbuf_endp += n;
808	return true;	723	return true;
809	}	724	}
810	else if (n < 0 && errno != EAGAIN)	725	else if (n < 0 && errno != EAGAIN)
811	destroy ();	726	destroy ();
812		727
813	return false;	728	return false;
814	}	729	}
815		730
816	void	731	void
817	rxvt_term::pty_cb (io_watcher &w, short revents)	732	rxvt_term::pty_cb (io_watcher &w, short revents)
…		…
834	seen_input = 1;	749	seen_input = 1;
835	/* once we know the shell is running, send the screen size. Again! */	750	/* once we know the shell is running, send the screen size. Again! */
836	tt_winch ();	751	tt_winch ();
837	}	752	}
838		753
839	uint32_t ch = NOCHAR;	754	if (cmd_parse ())
		755	break;
		756	}
		757	}
		758	}
		759
		760	bool
		761	rxvt_term::cmd_parse ()
		762	{
		763	bool flag = false;
		764	unicode_t ch = NOCHAR;
		765
		766	for (;;)
		767	{
		768	if (ch == NOCHAR)
		769	ch = next_char ();
		770
		771	if (ch == NOCHAR) // TODO: improve
		772	break;
		773
		774	if (ch >= ' ' || ch == '\t' || ch == '\n' || ch == '\r')
		775	{
		776	/* Read a text string from the input buffer */
		777	unicode_t buf[BUFSIZ];
		778	bool refreshnow = false;
		779	int nlines = 0;
		780	unicode_t *str = buf;
		781
		782	*str++ = ch;
840		783
841	for (;;)	784	for (;;)
842	{	785	{
843	if (ch == NOCHAR)
844	ch = next_char ();	786	ch = next_char ();
845		787
846	if (ch == NOCHAR) // TODO: improve	788	if (ch == NOCHAR || (ch < ' ' && ch != '\t' && ch != '\n' && ch != '\r'))
847	break;	789	break;
848		790	else
849	if (ch >= ' ' || ch == '\t' || ch == '\n' || ch == '\r')
850	{	791	{
851	/* Read a text string from the input buffer */
852	uint32_t buf[BUFSIZ];
853	bool refreshnow = false;
854	int nlines = 0;
855	uint32_t *str = buf;
856
857	*str++ = ch;	792	*str++ = ch;
858		793
859	for (;;)	794	if (ch == '\n')
860	{	795	{
861	ch = next_char ();
862
863	if (ch == NOCHAR || (ch < ' ' && ch != '\t' && ch != '\n' && ch != '\r'))
864	break;
865	else	796	nlines++;
		797	refresh_count++;
		798
		799	if (! (Options & Opt_jumpScroll)
		800	|| (refresh_count >= (refresh_limit * (TermWin.nrow - 1))))
866	{	801	{
867	*str++ = ch;
868
869	if (ch == '\n')
870	{
871	nlines++;
872	refresh_count++;
873
874	if (! (Options & Opt_jumpScroll)
875	|| (refresh_count >= (refresh_limit * (TermWin.nrow - 1))))
876	{
877	refreshnow = true;	802	refreshnow = true;
878	flag = false;	803	flag = false;
879	ch = NOCHAR;	804	ch = NOCHAR;
880	break;	805	break;
881	}	806	}
882		807
883	// scr_add_lines only works for nlines < TermWin.nrow - 1.	808	// scr_add_lines only works for nlines < TermWin.nrow - 1.
884	if (nlines >= TermWin.nrow - 1)	809	if (nlines >= TermWin.nrow - 1)
885	{	810	{
886	scr_add_lines (buf, nlines, str - buf);	811	scr_add_lines (buf, nlines, str - buf);
887	nlines = 0;	812	nlines = 0;
888	str = buf;	813	str = buf;
889	}
890	}
891
892	if (str >= buf + BUFSIZ)
893	{
894	ch = NOCHAR;
895	break;
896	}
897	}	814	}
898	}	815	}
899		816
900	scr_add_lines (buf, nlines, str - buf);	817	if (str >= buf + BUFSIZ)
901
902	/*
903	* If there have been a lot of new lines, then update the screen
904	* What the heck I'll cheat and only refresh less than every page-full.
905	* the number of pages between refreshes is refresh_limit, which
906	* is incremented here because we must be doing flat-out scrolling.
907	*
908	* refreshing should be correct for small scrolls, because of the
909	* time-out
910	*/
911	if (refreshnow)
912	{	818	{
913	if ((Options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)	819	ch = NOCHAR;
914	refresh_limit++;	820	break;
915
916	scr_refresh (refresh_type);
917	}	821	}
918
919	}
920	else
921	{
922	switch (ch)
923	{
924	default:
925	process_nonprinting (ch);
926	break;
927	case C0_ESC: /* escape char */
928	process_escape_seq ();
929	break;
930	/*case 0x9b: */ /* CSI */
931	/* process_csi_seq (); */
932	}
933
934	ch = NOCHAR;
935	}	822	}
936	}	823	}
		824
		825	scr_add_lines (buf, nlines, str - buf);
		826
		827	/*
		828	* If there have been a lot of new lines, then update the screen
		829	* What the heck I'll cheat and only refresh less than every page-full.
		830	* the number of pages between refreshes is refresh_limit, which
		831	* is incremented here because we must be doing flat-out scrolling.
		832	*
		833	* refreshing should be correct for small scrolls, because of the
		834	* time-out
		835	*/
		836	if (refreshnow)
		837	{
		838	if ((Options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)
		839	refresh_limit++;
		840
		841	scr_refresh (refresh_type);
		842	}
		843
		844	}
		845	else
937	}	846	{
		847	switch (ch)
		848	{
		849	default:
		850	process_nonprinting (ch);
		851	break;
		852	case C0_ESC: /* escape char */
		853	process_escape_seq ();
		854	break;
		855	/*case 0x9b: */ /* CSI */
		856	/* process_csi_seq (); */
		857	}
		858
		859	ch = NOCHAR;
		860	}
938	}	861	}
		862
		863	return flag;
939	}	864	}
940		865
941	// read the next character, currently handles UTF-8	866	// read the next character, currently handles UTF-8
942	// will probably handle all sorts of other stuff in the future	867	// will probably handle all sorts of other stuff in the future
943	uint32_t	868	unicode_t
944	rxvt_term::next_char ()	869	rxvt_term::next_char ()
945	{	870	{
946	while (cmdbuf_ptr < cmdbuf_endp)	871	while (cmdbuf_ptr < cmdbuf_endp)
947	{	872	{
948	if (*cmdbuf_ptr < 0x80) // assume < 0x80 to be ascii ALWAYS (all shift-states etc.) uh-oh	873	// assume 0x20 .. 0x7f to be ascii ALWAYS (all shift-states etc.) uh-oh
		874	if ((*cmdbuf_ptr <= 0x7f && 0x20 <= *cmdbuf_ptr)
		875	|| !*cmdbuf_ptr)
949	return *cmdbuf_ptr++;	876	return *cmdbuf_ptr++;
950		877
951	wchar_t wc;	878	wchar_t wc;
952	size_t len = mbrtowc (&wc, (char *)cmdbuf_ptr, cmdbuf_endp - cmdbuf_ptr, mbstate);	879	size_t len = mbrtowc (&wc, (char *)cmdbuf_ptr, cmdbuf_endp - cmdbuf_ptr, mbstate);
953		880
954	if (len == (size_t)-2)	881	if (len == (size_t)-2)
955	return NOCHAR;	882	{
		883	// the mbstate stores incomplete sequences. didn't know this :/
		884	cmdbuf_ptr = cmdbuf_endp;
		885	break;
		886	}
956		887
957	if (len == (size_t)-1)	888	if (len == (size_t)-1)
958	return *cmdbuf_ptr++; // the _occasional_ latin1 character is allowed to slip through	889	return *cmdbuf_ptr++; // the _occasional_ latin1 character is allowed to slip through
959		890
960	// assume wchar == unicode	891	// assume wchar == unicode
…		…
968	/* rxvt_cmd_getc () - Return next input character */	899	/* rxvt_cmd_getc () - Return next input character */
969	/*	900	/*
970	* Return the next input character after first passing any keyboard input	901	* Return the next input character after first passing any keyboard input
971	* to the command.	902	* to the command.
972	*/	903	*/
973	uint32_t	904	unicode_t
974	rxvt_term::cmd_getc ()	905	rxvt_term::cmd_getc ()
975	{	906	{
976	for (;;)	907	for (;;)
977	{	908	{
978	uint32_t c = next_char ();	909	unicode_t c = next_char ();
979	if (c != NOCHAR)	910	if (c != NOCHAR)
980	return c;	911	return c;
981		912
982	// incomplete sequences should occur rarely, still, a better solution	913	// incomplete sequences should occur rarely, still, a better solution
983	// would be preferred. either setjmp/longjmp or better design.	914	// would be preferred. either setjmp/longjmp or better design.
…		…
1021	pointer_blank ();	952	pointer_blank ();
1022	}	953	}
1023	#endif	954	#endif
1024		955
1025	void	956	void
1026	rxvt_term::mouse_report (const XButtonEvent &ev)	957	rxvt_term::mouse_report (XButtonEvent &ev)
1027	{	958	{
1028	int button_number, key_state = 0;	959	int button_number, key_state = 0;
1029	int x, y;	960	int x, y;
1030		961
1031	x = ev.x;	962	x = ev.x;
1032	y = ev.y;	963	y = ev.y;
1033	pixel_position (&x, &y);	964	pixel_position (&x, &y);
1034		965
…		…
1428	}	1359	}
1429	#ifdef MENUBAR	1360	#ifdef MENUBAR
1430	if (menubar_visible () && isMenuBarWindow (ev.xany.window))	1361	if (menubar_visible () && isMenuBarWindow (ev.xany.window))
1431	menubar_expose ();	1362	menubar_expose ();
1432	#endif	1363	#endif
1433	#ifdef RXVT_GRAPHICS
1434	Gr_expose (ev.xany.window);
1435	#endif
1436
1437	}	1364	}
1438	break;	1365	break;
1439		1366
1440	case MotionNotify:	1367	case MotionNotify:
1441	#ifdef POINTER_BLANK	1368	#ifdef POINTER_BLANK
…		…
1443	pointer_unblank ();	1370	pointer_unblank ();
1444	#endif	1371	#endif
1445	#if MENUBAR	1372	#if MENUBAR
1446	if (isMenuBarWindow (ev.xany.window))	1373	if (isMenuBarWindow (ev.xany.window))
1447	{	1374	{
1448	menubar_control (& (ev.xbutton));	1375	menubar_control (ev.xbutton);
1449	break;	1376	break;
1450	}	1377	}
1451	#endif	1378	#endif
1452	if ((PrivateModes & PrivMode_mouse_report) && ! (bypass_keystate))	1379	if ((PrivateModes & PrivMode_mouse_report) && ! (bypass_keystate))
1453	break;	1380	break;
…		…
1582	#endif	1509	#endif
1583	}	1510	}
1584	}	1511	}
1585		1512
1586	void	1513	void
1587	rxvt_term::button_press (const XButtonEvent &ev)	1514	rxvt_term::button_press (XButtonEvent &ev)
1588	{	1515	{
1589	int reportmode = 0, clickintime;	1516	int reportmode = 0, clickintime;
1590		1517
1591	bypass_keystate = ev.state & (ModMetaMask | ShiftMask);	1518	bypass_keystate = ev.state & (ModMetaMask | ShiftMask);
1592	if (!bypass_keystate)	1519	if (!bypass_keystate)
…		…
1594	/*	1521	/*
1595	* VT window processing of button press	1522	* VT window processing of button press
1596	*/	1523	*/
1597	if (ev.window == TermWin.vt)	1524	if (ev.window == TermWin.vt)
1598	{	1525	{
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;	1526	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;
1607	if (reportmode)	1527	if (reportmode)
		1528	{
		1529	/* mouse report from vt window */
		1530	/* save the xbutton state (for ButtonRelease) */
		1531	MEvent.state = ev.state;
		1532	#ifdef MOUSE_REPORT_DOUBLECLICK
		1533	if (ev.button == MEvent.button && clickintime)
1608	{	1534	{
1609	/* mouse report from vt window */	1535	/* same button, within alloted time */
1610	/* save the xbutton state (for ButtonRelease) */	1536	MEvent.clicks++;
1611	MEvent.state = ev.state;	1537	if (MEvent.clicks > 1)
1612	#ifdef MOUSE_REPORT_DOUBLECLICK
1613	if (ev.button == MEvent.button && clickintime)
1614	{	1538	{
1615	/* same button, within alloted time */
1616	MEvent.clicks++;
1617	if (MEvent.clicks > 1)
1618	{
1619	/* only report double clicks */	1539	/* only report double clicks */
1620	MEvent.clicks = 2;	1540	MEvent.clicks = 2;
1621	mouse_report (ev);	1541	mouse_report (ev);
1622		1542
1623	/* don't report the release */	1543	/* don't report the release */
1624	MEvent.clicks = 0;	1544	MEvent.clicks = 0;
1625	MEvent.button = AnyButton;	1545	MEvent.button = AnyButton;
1626	}
1627	}	1546	}
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	}	1547	}
1641	else	1548	else
1642	{	1549	{
		1550	/* different button, or time expired */
		1551	MEvent.clicks = 1;
		1552	MEvent.button = ev.button;
		1553	mouse_report (ev);
		1554	}
		1555	#else
		1556	MEvent.button = ev.button;
		1557	mouse_report (ev);
		1558	#endif /* MOUSE_REPORT_DOUBLECLICK */
		1559
		1560	}
		1561	else
		1562	{
1643	if (ev.button != MEvent.button)	1563	if (ev.button != MEvent.button)
1644	MEvent.clicks = 0;	1564	MEvent.clicks = 0;
1645	switch (ev.button)	1565	switch (ev.button)
1646	{	1566	{
1647	case Button1:	1567	case Button1:
1648	/* allow shift+left click to extend selection */	1568	/* allow shift+left click to extend selection */
1649	if (ev.state & ShiftMask && ! (PrivateModes & PrivMode_mouse_report))	1569	if (ev.state & ShiftMask && ! (PrivateModes & PrivMode_mouse_report))
1650	{	1570	{
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)	1571	if (MEvent.button == Button1 && clickintime)
1671	selection_rotate (ev.x, ev.y);	1572	selection_rotate (ev.x, ev.y);
1672	else	1573	else
1673	selection_extend (ev.x, ev.y, 1);	1574	selection_extend (ev.x, ev.y, 1);
		1575	}
		1576	else
		1577	{
		1578	if (MEvent.button == Button1 && clickintime)
		1579	MEvent.clicks++;
		1580	else
		1581	MEvent.clicks = 1;
		1582
		1583	selection_click (MEvent.clicks, ev.x, ev.y);
		1584	}
		1585
		1586	MEvent.button = Button1;
		1587	break;
		1588
		1589	case Button3:
		1590	if (MEvent.button == Button3 && clickintime)
		1591	selection_rotate (ev.x, ev.y);
		1592	else
		1593	selection_extend (ev.x, ev.y, 1);
1674	MEvent.button = Button3;	1594	MEvent.button = Button3;
1675	break;	1595	break;
1676	}
1677	}	1596	}
		1597	}
1678	MEvent.time = ev.time;	1598	MEvent.time = ev.time;
1679	return;	1599	return;
1680	}
1681	}	1600	}
1682		1601
1683	/*	1602	/*
1684	* Scrollbar window processing of button press	1603	* Scrollbar window processing of button press
1685	*/	1604	*/
…		…
1828	menubar_control (ev);	1747	menubar_control (ev);
1829	#endif	1748	#endif
1830	}	1749	}
1831		1750
1832	void	1751	void
1833	rxvt_term::button_release (const XButtonEvent &ev)	1752	rxvt_term::button_release (XButtonEvent &ev)
1834	{	1753	{
1835	int reportmode = 0;	1754	int reportmode = 0;
1836		1755
1837	csrO = 0; /* reset csr Offset */	1756	csrO = 0; /* reset csr Offset */
1838	if (!bypass_keystate)	1757	if (!bypass_keystate)
…		…
1850	#ifdef SELECTION_SCROLLING	1769	#ifdef SELECTION_SCROLLING
1851	pending_scroll_selection=0;	1770	pending_scroll_selection=0;
1852	#endif	1771	#endif
1853	if (ev.window == TermWin.vt)	1772	if (ev.window == TermWin.vt)
1854	{	1773	{
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)	1774	if (reportmode)
		1775	{
		1776	/* mouse report from vt window */
		1777	/* don't report release of wheel "buttons" */
		1778	if (ev.button >= 4)
		1779	return;
		1780	#ifdef MOUSE_REPORT_DOUBLECLICK
		1781	/* only report the release of 'slow' single clicks */
		1782	if (MEvent.button != AnyButton
		1783	&& (ev.button != MEvent.button
		1784	|| (ev.time - MEvent.time
		1785	> MULTICLICK_TIME / 2)))
1863	{	1786	{
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;	1787	MEvent.clicks = 0;
1876	MEvent.button = AnyButton;
1877	mouse_report (ev);
1878	}
1879	#else /* MOUSE_REPORT_DOUBLECLICK */
1880	MEvent.button = AnyButton;	1788	MEvent.button = AnyButton;
1881	mouse_report (ev);	1789	mouse_report (ev);
		1790	}
		1791	#else /* MOUSE_REPORT_DOUBLECLICK */
		1792	MEvent.button = AnyButton;
		1793	mouse_report (ev);
1882	#endif /* MOUSE_REPORT_DOUBLECLICK */	1794	#endif /* MOUSE_REPORT_DOUBLECLICK */
1883	return;	1795	return;
1884	}	1796	}
1885	/*	1797	/*
1886	* dumb hack to compensate for the failure of click-and-drag	1798	* dumb hack to compensate for the failure of click-and-drag
1887	* when overriding mouse reporting	1799	* when overriding mouse reporting
1888	*/	1800	*/
1889	if (PrivateModes & PrivMode_mouse_report	1801	if (PrivateModes & PrivMode_mouse_report
1890	&& bypass_keystate	1802	&& bypass_keystate
1891	&& ev.button == Button1 && MEvent.clicks <= 1)	1803	&& ev.button == Button1 && MEvent.clicks <= 1)
1892	selection_extend (ev.x, ev.y, 0);	1804	selection_extend (ev.x, ev.y, 0);
1893		1805
1894	switch (ev.button)	1806	switch (ev.button)
		1807	{
		1808	case Button1:
		1809	case Button3:
		1810	selection_make (ev.time);
		1811	break;
		1812	case Button2:
		1813	selection_request (ev.time, ev.x, ev.y);
		1814	break;
		1815	#ifdef MOUSE_WHEEL
		1816	case Button4:
		1817	case Button5:
1895	{	1818	{
1896	case Button1:	1819	int i;
1897	case Button3:	1820	page_dirn v;
1898	selection_make (ev.time);	1821
		1822	v = (ev.button == Button4) ? UP : DN;
		1823	if (ev.state & ShiftMask)
1899	break;	1824	i = 1;
1900	case Button2:	1825	else if ((Options & Opt_mouseWheelScrollPage))
1901	selection_request (ev.time, ev.x, ev.y);	1826	i = TermWin.nrow - 1;
		1827	else
1902	break;	1828	i = 5;
1903	#ifdef MOUSE_WHEEL	1829	# ifdef MOUSE_SLIP_WHEELING
1904	case Button4:	1830	if (ev.state & ControlMask)
1905	case Button5:
1906	{	1831	{
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);	1832	mouse_slip_wheel_speed += (v ? -1 : 1);
1921	mouse_slip_wheel_delay = SCROLLBAR_CONTINUOUS_DELAY;	1833	mouse_slip_wheel_delay = SCROLLBAR_CONTINUOUS_DELAY;
1922	}	1834	}
1923	# endif	1835	# endif
1924	# ifdef JUMP_MOUSE_WHEEL	1836	# ifdef JUMP_MOUSE_WHEEL
		1837	scr_page (v, i);
		1838	scr_refresh (SMOOTH_REFRESH);
		1839	scrollbar_show (1);
		1840	# else
		1841	while (i--)
		1842	{
1925	scr_page (v, i);	1843	scr_page (v, 1);
1926	scr_refresh (SMOOTH_REFRESH);	1844	scr_refresh (SMOOTH_REFRESH);
1927	scrollbar_show (1);	1845	scrollbar_show (1);
1928	# else
1929	while (i--)
1930	{
1931	scr_page (v, 1);
1932	scr_refresh (SMOOTH_REFRESH);
1933	scrollbar_show (1);
1934	}	1846	}
1935	# endif	1847	# endif
1936		1848
1937	}
1938	break;
1939	#endif
1940
1941	}	1849	}
		1850	break;
		1851	#endif
		1852
1942	}	1853	}
1943	}	1854	}
1944	#ifdef MENUBAR	1855	#ifdef MENUBAR
1945	else if (isMenuBarWindow (ev.window))	1856	else if (isMenuBarWindow (ev.window))
1946	menubar_control (ev);	1857	menubar_control (ev);
…		…
2008	if (have_pixmap)	1919	if (have_pixmap)
2009	{	1920	{
2010	/*	1921	/*
2011	* Copy display->root pixmap transparency	1922	* Copy display->root pixmap transparency
2012	*/	1923	*/
2013	int sx, sy, nx, ny;	1924	int sx, sy, nx, ny;
2014	unsigned int nw, nh;	1925	unsigned int nw, nh;
2015	Window cr;	1926	Window cr;
2016	XImage *image;	1927	XImage *image;
2017	GC gc;	1928	GC gc;
2018	XGCValues gcvalue;	1929	XGCValues gcvalue;
2019		1930
2020	XTranslateCoordinates (display->display, TermWin.parent[0], display->root,	1931	XTranslateCoordinates (display->display, TermWin.parent[0], display->root,
2021	0, 0, &sx, &sy, &cr);	1932	0, 0, &sx, &sy, &cr);
2022	nw = (unsigned int)szHint.width;	1933	nw = (unsigned int)szHint.width;
2023	nh = (unsigned int)szHint.height;	1934	nh = (unsigned int)szHint.height;
2024	nx = ny = 0;	1935	nx = ny = 0;
		1936
2025	if (sx < 0)	1937	if (sx < 0)
2026	{	1938	{
2027	nw += sx;	1939	nw += sx;
2028	nx = -sx;	1940	nx = -sx;
2029	sx = 0;	1941	sx = 0;
2030	}	1942	}
		1943
2031	if (sy < 0)	1944	if (sy < 0)
2032	{	1945	{
2033	nh += sy;	1946	nh += sy;
2034	ny = -sy;	1947	ny = -sy;
2035	sy = 0;	1948	sy = 0;
2036	}	1949	}
		1950
2037	MIN_IT (nw, (unsigned int) (wrootattr.width - sx));	1951	MIN_IT (nw, (unsigned int) (wrootattr.width - sx));
2038	MIN_IT (nh, (unsigned int) (wrootattr.height - sy));	1952	MIN_IT (nh, (unsigned int) (wrootattr.height - sy));
2039	allowedxerror = -1;	1953	allowedxerror = -1;
2040	image = XGetImage (display->display, rootpixmap, sx, sy, nw, nh, AllPlanes,	1954	image = XGetImage (display->display, rootpixmap, sx, sy, nw, nh, AllPlanes,
2041	ZPixmap);	1955	ZPixmap);
…		…
2074	if (!am_transparent || !am_pixmap_trans)	1988	if (!am_transparent || !am_pixmap_trans)
2075	pchanged = 1;	1989	pchanged = 1;
2076	am_transparent = am_pixmap_trans = 1;	1990	am_transparent = am_pixmap_trans = 1;
2077	}	1991	}
2078	}	1992	}
		1993
2079	if (!am_pixmap_trans)	1994	if (!am_pixmap_trans)
2080	{	1995	{
2081	unsigned int n;	1996	unsigned int n;
2082	/*	1997	/*
2083	* InheritPixmap transparency	1998	* InheritPixmap transparency
…		…
2098	break;	2013	break;
2099	}	2014	}
2100	if (oldp != TermWin.parent[i])	2015	if (oldp != TermWin.parent[i])
2101	pchanged = 1;	2016	pchanged = 1;
2102	}	2017	}
		2018
2103	n = 0;	2019	n = 0;
		2020
2104	if (pchanged)	2021	if (pchanged)
2105	{	2022	{
2106	for (; n < (unsigned int)i; n++)	2023	for (; n < (unsigned int)i; n++)
2107	{	2024	{
2108	XGetWindowAttributes (display->display, TermWin.parent[n], &wattr);	2025	XGetWindowAttributes (display->display, TermWin.parent[n], &wattr);
…		…
2112	n = (int) (sizeof (TermWin.parent) / sizeof (Window)) + 1;	2029	n = (int) (sizeof (TermWin.parent) / sizeof (Window)) + 1;
2113	break;	2030	break;
2114	}	2031	}
2115	}	2032	}
2116	}	2033	}
		2034
2117	if (n > (int) (sizeof (TermWin.parent)	2035	if (n > (int) (sizeof (TermWin.parent)
2118	/ sizeof (TermWin.parent[0])))	2036	/ sizeof (TermWin.parent[0])))
2119	{	2037	{
2120	D_X ((stderr, "InheritPixmap Turning off"));	2038	D_X ((stderr, "InheritPixmap Turning off"));
2121	XSetWindowBackground (display->display, TermWin.parent[0],	2039	XSetWindowBackground (display->display, TermWin.parent[0],
…		…
2144	ParentRelative);	2062	ParentRelative);
2145	XSetWindowBackgroundPixmap (display->display, TermWin.vt,	2063	XSetWindowBackgroundPixmap (display->display, TermWin.vt,
2146	ParentRelative);	2064	ParentRelative);
2147	am_transparent = 1;	2065	am_transparent = 1;
2148	}	2066	}
		2067
2149	for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)	2068	for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
2150	TermWin.parent[i] = None;	2069	TermWin.parent[i] = None;
2151	}	2070	}
2152	return pchanged;	2071	return pchanged;
2153	}	2072	}
…		…
2159	/*----------------------------------------------------------------------*/	2078	/*----------------------------------------------------------------------*/
2160	#ifdef PRINTPIPE	2079	#ifdef PRINTPIPE
2161	FILE *	2080	FILE *
2162	rxvt_term::popen_printer ()	2081	rxvt_term::popen_printer ()
2163	{	2082	{
2164	FILE *stream = popen (rs[Rs_print_pipe], "w");	2083	FILE *stream = popen (rs[Rs_print_pipe], "w");
2165		2084
2166	if (stream == NULL)	2085	if (stream == NULL)
2167	rxvt_print_error ("can't open printer pipe");	2086	rxvt_print_error ("can't open printer pipe");
2168	return stream;	2087	return stream;
2169	}	2088	}
…		…
2381	scr_charset_set (2, (unsigned int)cmd_getc ());	2300	scr_charset_set (2, (unsigned int)cmd_getc ());
2382	break;	2301	break;
2383	case '+':	2302	case '+':
2384	scr_charset_set (3, (unsigned int)cmd_getc ());	2303	scr_charset_set (3, (unsigned int)cmd_getc ());
2385	break;	2304	break;
2386	#ifdef MULTICHAR_SET
2387	case '$':
2388	scr_charset_set (-2, (unsigned int)cmd_getc ());
2389	break;
2390	#endif
2391	#ifndef NO_FRILLS	2305	#ifndef NO_FRILLS
2392	case '6':	2306	case '6':
2393	scr_backindex ();	2307	scr_backindex ();
2394	break;	2308	break;
2395	#endif	2309	#endif
…		…
2417	break;	2331	break;
2418		2332
2419	/* 8.3.87: NEXT LINE */	2333	/* 8.3.87: NEXT LINE */
2420	case C1_NEL: /* ESC E */	2334	case C1_NEL: /* ESC E */
2421	{	2335	{
2422	uint32_t nlcr[] = { '\n', '\r' };	2336	unicode_t nlcr[] = { L'\n', L'\r' };
2423	scr_add_lines (nlcr, 1, 2);	2337	scr_add_lines (nlcr, 1, 2);
2424	}	2338	}
2425	break;	2339	break;
2426		2340
2427	/* kidnapped escape sequence: Should be 8.3.48 */	2341	/* kidnapped escape sequence: Should be 8.3.48 */
…		…
2736	case 7: /* unofficial extension */	2650	case 7: /* unofficial extension */
2737	tt_printf ("%-.250s\n", rs[Rs_display_name]);	2651	tt_printf ("%-.250s\n", rs[Rs_display_name]);
2738	break;	2652	break;
2739	#endif	2653	#endif
2740	case 8: /* unofficial extension */	2654	case 8: /* unofficial extension */
2741	xterm_seq (XTerm_title, APL_NAME "-" VERSION, CHAR_ST);	2655	xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);
2742	break;	2656	break;
2743	}	2657	}
2744	break;	2658	break;
2745		2659
2746	case CSI_TBC: /* 8.3.155: (0) TABULATION CLEAR */	2660	case CSI_TBC: /* 8.3.155: (0) TABULATION CLEAR */
…		…
3020	* 10 = menu (may change in future)	2934	* 10 = menu (may change in future)
3021	* 20 = bg pixmap	2935	* 20 = bg pixmap
3022	* 39 = change default fg color	2936	* 39 = change default fg color
3023	* 49 = change default bg color	2937	* 49 = change default bg color
3024	* 55 = dump scrollback buffer and all of screen	2938	* 55 = dump scrollback buffer and all of screen
		2939	* 701 = change locale
		2940	* 702 = find font
3025	*/	2941	*/
3026	void	2942	void
3027	rxvt_term::xterm_seq (int op, const char *str, unsigned char resp __attribute__ ((unused)))	2943	rxvt_term::xterm_seq (int op, const char *str, unsigned char resp __attribute__ ((unused)))
3028	{	2944	{
3029	int changed = 0;	2945	int changed = 0;
…		…
3115	set_window_color (Color_bg, str);	3031	set_window_color (Color_bg, str);
3116	break;	3032	break;
3117	case XTerm_logfile:	3033	case XTerm_logfile:
3118	break;	3034	break;
3119	case XTerm_font:	3035	case XTerm_font:
3120	change_font (0, str);	3036	change_font (str);
3121	break;	3037	break;
		3038	#ifndef NO_FRILLS
		3039	case XTerm_locale:
		3040	if (str[0] == '?' && !str[1])
		3041	tt_printf ("%-.250s\n", locale);
		3042	else
		3043	{
		3044	set_locale (str);
		3045	# ifdef USE_XIM
		3046	im_cb ();
		3047	# endif
		3048	}
		3049	break;
		3050	case XTerm_findfont:
		3051	{
		3052	int fid = TermWin.fontset->find_font (atoi (str));
		3053	tt_printf ("%d %-.250s\n", fid, (*TermWin.fontset)[fid]->name);
		3054	}
		3055	break;
		3056	#endif
3122	#if 0	3057	#if 0
3123	case XTerm_dumpscreen: /* no error notices */	3058	case XTerm_dumpscreen: /* no error notices */
3124	{	3059	{
3125	int fd;	3060	int fd;
3126	if ((fd = open (str, O_RDWR | O_CREAT | O_EXCL, 0600)) >= 0)	3061	if ((fd = open (str, O_RDWR | O_CREAT | O_EXCL, 0600)) >= 0)
…		…
3191	{ menuBar_esc, PrivMode_menuBar },	3126	{ menuBar_esc, PrivMode_menuBar },
3192	#endif	3127	#endif
3193	#ifdef scrollBar_esc	3128	#ifdef scrollBar_esc
3194	{ scrollBar_esc, PrivMode_scrollBar },	3129	{ scrollBar_esc, PrivMode_scrollBar },
3195	#endif	3130	#endif
		3131	// 18, 19 printing-related
3196	{ 25, PrivMode_VisibleCursor },	3132	{ 25, PrivMode_VisibleCursor },
		3133	// 30 show scrollbar rxvt. extension
3197	{ 35, PrivMode_ShiftKeys },	3134	{ 35, PrivMode_ShiftKeys }, // rxvt extension
3198	{ 40, PrivMode_132OK },	3135	{ 40, PrivMode_132OK },
		3136	// 41 xterm more fixes NYI
		3137	// 45 margin bell NYI
		3138	// 46 start logging
3199	{ 47, PrivMode_Screen },	3139	{ 47, PrivMode_Screen },
3200	{ 66, PrivMode_aplKP },	3140	{ 66, PrivMode_aplKP },
3201	#ifndef NO_BACKSPACE_KEY	3141	#ifndef NO_BACKSPACE_KEY
3202	{ 67, PrivMode_BackSpace },	3142	{ 67, PrivMode_BackSpace },
3203	#endif	3143	#endif
3204	{ 1000, PrivMode_MouseX11 },	3144	{ 1000, PrivMode_MouseX11 },
		3145	// 1001 Use Hilite Mouse Tracking. NYI, TODO
		3146	// 1002 Use Cell Motion Mouse Tracking. NYI, TODO
		3147	// 1003 Use All Motion Mouse Tracking. NYI, TODO
3205	{ 1010, PrivMode_TtyOutputInh },	3148	{ 1010, PrivMode_TtyOutputInh }, // rxvt extension
3206	{ 1011, PrivMode_Keypress },	3149	{ 1011, PrivMode_Keypress }, // rxvt extension
		3150	// 1035 enable modifiers for alt, numlock NYI
		3151	// 1036 send ESC for meta keys NYI
		3152	// 1037 send DEL for keypad delete NYI
3207	{ 1047, PrivMode_Screen },	3153	{ 1047, PrivMode_Screen },
		3154	// 1048 save and restore cursor
3208	{ 1049, PrivMode_Screen }, /* xterm extension, not fully implemented */	3155	{ 1049, PrivMode_Screen }, /* xterm extension, not fully implemented */
		3156	// 1051, 1052, 1060, 1061 keyboard emulation NYI
3209	};	3157	};
3210		3158
3211	if (nargs == 0)	3159	if (nargs == 0)
3212	return;	3160	return;
3213		3161
…		…
3228	state = privcases (mode, argtopriv[j].bit);	3176	state = privcases (mode, argtopriv[j].bit);
3229	break;	3177	break;
3230	}	3178	}
3231		3179
3232	/* extra handling for values with state unkept */	3180	/* extra handling for values with state unkept */
		3181	switch (arg[i])
		3182	{
		3183	case 1048: /* alternative cursor save */
		3184	case 1049:
		3185	if (mode == 0)
		3186	scr_cursor (RESTORE);
		3187	else if (mode == 1)
		3188	scr_cursor (SAVE);
		3189	/* FALLTHROUGH */
		3190	}
		3191
3233	if (state == -1)	3192	if (state >= 0)
		3193	/* extra handling for values with valid 0 or 1 state */
3234	switch (arg[i])	3194	switch (arg[i])
3235	{	3195	{
3236	case 1048: /* alternative cursor save */	3196	/* case 1: - application cursor keys */
		3197	case 2: /* VT52 mode */
		3198	/* oddball mode. should be set regardless of set/reset
		3199	* parameter. Return from VT52 mode with an ESC < from
		3200	* within VT52 mode
		3201	*/
		3202	PrivMode (1, PrivMode_vt52);
		3203	break;
		3204	case 3: /* 80/132 */
		3205	if (PrivateModes & PrivMode_132OK)
		3206	set_widthheight (((state ? 132 : 80) * TermWin.fwidth), TermWin.height);
		3207	break;
		3208	case 4: /* smooth scrolling */
3237	if (mode == 0)	3209	if (state)
3238	scr_cursor (RESTORE);	3210	Options &= ~Opt_jumpScroll;
3239	else if (mode == 1)	3211	else
3240	scr_cursor (SAVE);	3212	Options |= Opt_jumpScroll;
		3213	break;
		3214	case 5: /* reverse video */
		3215	scr_rvideo_mode (state);
		3216	break;
		3217	case 6: /* relative/absolute origins */
		3218	scr_relative_origin (state);
		3219	break;
		3220	case 7: /* autowrap */
		3221	scr_autowrap (state);
		3222	break;
		3223	/* case 8: - auto repeat, can't do on a per window basis */
		3224	case 9: /* X10 mouse reporting */
		3225	if (state) /* orthogonal */
		3226	PrivateModes &= ~ (PrivMode_MouseX11);
		3227	break;
		3228	#ifdef menuBar_esc
		3229	case menuBar_esc:
		3230	#ifdef MENUBAR
		3231	map_menuBar (state);
		3232	#endif
		3233	break;
		3234	#endif
		3235	#ifdef scrollBar_esc
		3236	case scrollBar_esc:
		3237	if (scrollbar_mapping (state))
		3238	{
		3239	resize_all_windows (0, 0, 0);
		3240	scr_touch (true);
		3241	}
		3242	break;
		3243	#endif
		3244	case 25: /* visible/invisible cursor */
		3245	scr_cursor_visible (state);
		3246	break;
		3247	/* case 35: - shift keys */
		3248	/* case 40: - 80 <--> 132 mode */
		3249	case 47: /* secondary screen */
		3250	scr_change_screen (state);
		3251	break;
		3252	/* case 66: - application key pad */
		3253	/* case 67: - backspace key */
		3254	case 1000: /* X11 mouse reporting */
		3255	if (state) /* orthogonal */
		3256	PrivateModes &= ~ (PrivMode_MouseX10);
		3257	break;
		3258	#if 0
		3259	case 1001:
		3260	break; /* X11 mouse highlighting */
		3261	#endif
		3262	case 1010: /* scroll to bottom on TTY output inhibit */
		3263	if (state)
		3264	Options &= ~Opt_scrollTtyOutput;
		3265	else
		3266	Options |= Opt_scrollTtyOutput;
		3267	break;
		3268	case 1011: /* scroll to bottom on key press */
		3269	if (state)
		3270	Options |= Opt_scrollTtyKeypress;
		3271	else
		3272	Options &= ~Opt_scrollTtyKeypress;
		3273	break;
		3274	case 1047: /* secondary screen w/ clearing */
		3275	case 1049: /* better secondary screen w/ clearing, but not fully implemented */
		3276	if (current_screen != PRIMARY)
		3277	scr_erase_screen (2);
		3278	scr_change_screen (state);
3241	/* FALLTHROUGH */	3279	/* FALLTHROUGH */
3242	default:	3280	default:
3243	continue; /* for (;i;) */	3281	break;
3244	}	3282	}
3245
3246	/* extra handling for values with valid 0 or 1 state */
3247	switch (arg[i])
3248	{
3249	/* case 1: - application cursor keys */
3250	case 2: /* VT52 mode */
3251	/* oddball mode. should be set regardless of set/reset
3252	* parameter. Return from VT52 mode with an ESC < from
3253	* within VT52 mode
3254	*/
3255	PrivMode (1, PrivMode_vt52);
3256	break;
3257	case 3: /* 80/132 */
3258	if (PrivateModes & PrivMode_132OK)
3259	set_widthheight ( (unsigned int) ((state ? 132 : 80) * TermWin.fwidth),
3260	(unsigned int)TermWin.height);
3261	break;
3262	case 4: /* smooth scrolling */
3263	if (state)
3264	Options &= ~Opt_jumpScroll;
3265	else
3266	Options |= Opt_jumpScroll;
3267	break;
3268	case 5: /* reverse video */
3269	scr_rvideo_mode (state);
3270	break;
3271	case 6: /* relative/absolute origins */
3272	scr_relative_origin (state);
3273	break;
3274	case 7: /* autowrap */
3275	scr_autowrap (state);
3276	break;
3277	/* case 8: - auto repeat, can't do on a per window basis */
3278	case 9: /* X10 mouse reporting */
3279	if (state) /* orthogonal */
3280	PrivateModes &= ~ (PrivMode_MouseX11);
3281	break;
3282	#ifdef menuBar_esc
3283	case menuBar_esc:
3284	#ifdef MENUBAR
3285	map_menuBar (state);
3286	#endif
3287	break;
3288	#endif
3289	#ifdef scrollBar_esc
3290	case scrollBar_esc:
3291	if (scrollbar_mapping (state))
3292	{
3293	resize_all_windows (0, 0, 0);
3294	scr_touch (true);
3295	}
3296	break;
3297	#endif
3298	case 25: /* visible/invisible cursor */
3299	scr_cursor_visible (state);
3300	break;
3301	/* case 35: - shift keys */
3302	/* case 40: - 80 <--> 132 mode */
3303	case 47: /* secondary screen */
3304	scr_change_screen (state);
3305	break;
3306	/* case 66: - application key pad */
3307	/* case 67: - backspace key */
3308	case 1000: /* X11 mouse reporting */
3309	if (state) /* orthogonal */
3310	PrivateModes &= ~ (PrivMode_MouseX10);
3311	break;
3312	#if 0
3313	case 1001:
3314	break; /* X11 mouse highlighting */
3315	#endif
3316	case 1010: /* scroll to bottom on TTY output inhibit */
3317	if (state)
3318	Options &= ~Opt_scrollTtyOutput;
3319	else
3320	Options |= Opt_scrollTtyOutput;
3321	break;
3322	case 1011: /* scroll to bottom on key press */
3323	if (state)
3324	Options |= Opt_scrollTtyKeypress;
3325	else
3326	Options &= ~Opt_scrollTtyKeypress;
3327	break;
3328	case 1047: /* secondary screen w/ clearing */
3329	case 1049: /* better secondary screen w/ clearing, but not fully implemented */
3330	if (current_screen != PRIMARY)
3331	scr_erase_screen (2);
3332	scr_change_screen (state);
3333	/* FALLTHROUGH */
3334	default:
3335	break;
3336	}
3337	}	3283	}
3338	}	3284	}
3339	/*}}} */	3285	/*}}} */
3340		3286
3341	/*{{{ process sgr sequences */	3287	/*{{{ process sgr sequences */
…		…
3369	rendset = 1, rendstyle = RS_Blink;	3315	rendset = 1, rendstyle = RS_Blink;
3370	break;	3316	break;
3371	case 7:	3317	case 7:
3372	rendset = 1, rendstyle = RS_RVid;	3318	rendset = 1, rendstyle = RS_RVid;
3373	break;	3319	break;
		3320	case 8:
		3321	// invisible. NYI
		3322	break;
3374	case 22:	3323	case 22:
3375	rendset = 0, rendstyle = RS_Bold;	3324	rendset = 0, rendstyle = RS_Bold;
3376	break;	3325	break;
3377	case 24:	3326	case 24:
3378	rendset = 0, rendstyle = RS_Uline;	3327	rendset = 0, rendstyle = RS_Uline;
…		…
3381	rendset = 0, rendstyle = RS_Blink;	3330	rendset = 0, rendstyle = RS_Blink;
3382	break;	3331	break;
3383	case 27:	3332	case 27:
3384	rendset = 0, rendstyle = RS_RVid;	3333	rendset = 0, rendstyle = RS_RVid;
3385	break;	3334	break;
		3335	case 28:
		3336	// visible. NYI
		3337	break;
3386	}	3338	}
		3339
3387	if (rendset != -1)	3340	if (rendset != -1)
3388	{	3341	{
3389	scr_rendition (rendset, rendstyle);	3342	scr_rendition (rendset, rendstyle);
3390	continue; /* for (;i;) */	3343	continue; /* for (;i;) */
3391	}	3344	}
…		…
3398	case 33:	3351	case 33:
3399	case 34:	3352	case 34:
3400	case 35:	3353	case 35:
3401	case 36:	3354	case 36:
3402	case 37:	3355	case 37:
3403	scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)),	3356	scr_color ((unsigned int) (minCOLOR + (arg[i] - 30)), Color_fg);
3404	Color_fg);
3405	break;	3357	break;
3406	#ifdef TTY_256COLOR	3358	#ifdef TTY_256COLOR
3407	case 38:	3359	case 38:
3408	if (nargs > i + 2 && arg[i + 1] == 5)	3360	if (nargs > i + 2 && arg[i + 1] == 5)
3409	{	3361	{
3410	scr_color ((unsigned int) (minCOLOR + arg[i + 2]),	3362	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_fg);
3411	Color_fg);
3412	i += 2;	3363	i += 2;
3413	}	3364	}
3414	break;	3365	break;
3415	#endif	3366	#endif
3416	case 39: /* default fg */	3367	case 39: /* default fg */
…		…
3423	case 43:	3374	case 43:
3424	case 44:	3375	case 44:
3425	case 45:	3376	case 45:
3426	case 46:	3377	case 46:
3427	case 47:	3378	case 47:
3428	scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)),	3379	scr_color ((unsigned int) (minCOLOR + (arg[i] - 40)), Color_bg);
3429	Color_bg);
3430	break;	3380	break;
3431	#ifdef TTY_256COLOR	3381	#ifdef TTY_256COLOR
3432	case 48:	3382	case 48:
3433	if (nargs > i + 2 && arg[i + 1] == 5)	3383	if (nargs > i + 2 && arg[i + 1] == 5)
3434	{	3384	{
3435	scr_color ((unsigned int) (minCOLOR + arg[i + 2]),	3385	scr_color ((unsigned int) (minCOLOR + arg[i + 2]), Color_bg);
3436	Color_bg);
3437	i += 2;	3386	i += 2;
3438	}	3387	}
3439	break;	3388	break;
3440	#endif	3389	#endif
3441	case 49: /* default bg */	3390	case 49: /* default bg */
…		…
3476	void	3425	void
3477	rxvt_term::process_graphics ()	3426	rxvt_term::process_graphics ()
3478	{	3427	{
3479	unsigned char ch, cmd = cmd_getc ();	3428	unsigned char ch, cmd = cmd_getc ();
3480		3429
3481	#ifndef RXVT_GRAPHICS
3482	if (cmd == 'Q')	3430	if (cmd == 'Q')
3483	{ /* query graphics */	3431	{ /* query graphics */
3484	tt_printf ("\033G0\n"); /* no graphics */	3432	tt_printf ("\033G0\n"); /* no graphics */
3485	return;	3433	return;
3486	}	3434	}
3487	/* swallow other graphics sequences until terminating ':' */	3435	/* swallow other graphics sequences until terminating ':' */
3488	do	3436	do
3489	ch = cmd_getc ();	3437	ch = cmd_getc ();
3490	while (ch != ':');	3438	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	}	3439	}
3537	/*}}} */	3440	/*}}} */
3538		3441
3539	/* ------------------------------------------------------------------------- */	3442	/* ------------------------------------------------------------------------- */
3540		3443

Diff Legend

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