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.116 by root, Wed Aug 4 03:29:28 2004 UTC vs.
Revision 1.145 by root, Mon Aug 16 12:04:57 2004 UTC

…		…
57	#define IS_CONTROL(ch) !((ch) & 0xffffff60UL)	57	#define IS_CONTROL(ch) !((ch) & 0xffffff60UL)
58		58
59	// exception thrown when the command parser runs out of input data	59	// exception thrown when the command parser runs out of input data
60	class out_of_input { } out_of_input;	60	class out_of_input { } out_of_input;
61		61
		62	#if ENABLE_FRILLS || ISO_14755
		63
		64	#define ISO_14755_STARTED 0x80000000UL
		65	#define ISO_14755_51 0x40000000UL // basic (section 5.1)
		66	#define ISO_14755_52 0x20000000UL // keycap (section 5.2)
		67	#define ISO_14755_54 0x10000000UL // code feedback (section 5.4)
		68	#define ISO_14755_MASK 0x0fffffffUL
		69
		70	#if ISO_14755
		71	static unsigned short iso14755_symtab[] = {
		72	// keysym, unicode
		73	XK_Left, 0x2190,
		74	XK_KP_Left, 0x2190,
		75	XK_Up, 0x2191,
		76	XK_KP_Up, 0x2191,
		77	XK_Right, 0x2192,
		78	XK_KP_Right, 0x2192,
		79	XK_Down, 0x2193,
		80	XK_KP_Down, 0x2193,
		81	XK_Linefeed, 0x21b4,
		82	XK_Return, 0x21b5,
		83	XK_KP_Enter, 0x21b5,
		84
		85	XK_Prior, 0x21de,
		86	XK_Next, 0x21df,
		87	XK_Tab, 0x21e5,
		88	XK_ISO_Left_Tab, 0x21e6,
		89	XK_Shift_L, 0x21e7,
		90	XK_Shift_R, 0x21e7,
		91
		92	XK_Shift_Lock, 0x21eb,
		93	XK_ISO_Lock, 0x21eb,
		94	XK_ISO_Lock, 0x21eb,
		95	XK_Caps_Lock, 0x21ec,
		96	XK_Num_Lock, 0x21ed,
		97	XK_ISO_Level3_Shift, 0x21ee,
		98	XK_ISO_Level3_Lock, 0x21ef,
		99	XK_ISO_Group_Lock, 0x21f0,
		100	XK_Home, 0x21f1,
		101	XK_End, 0x21f2,
		102
		103	XK_Execute, 0x2318,
		104	XK_Begin, 0x2320,
		105	XK_Delete, 0x2326,
		106	XK_Clear, 0x2327,
		107	XK_BackSpace, 0x232b,
		108	XK_Insert, 0x2380,
		109	XK_Control_L, 0x2388,
		110	XK_Control_R, 0x2388,
		111	XK_Pause, 0x2389,
		112	XK_Break, 0x238a,
		113	XK_Escape, 0x238b,
		114	XK_Undo, 0x238c,
		115	XK_Print, 0x2399,
		116
		117	XK_space, 0x2423,
		118	XK_KP_Space, 0x2422,
		119	0,
		120	};
		121
		122	void
		123	rxvt_term::iso14755_54 (int x, int y)
		124	{
		125	x = Pixel2Col (x);
		126	y = Pixel2Row (y);
		127
		128	if (x < 0 || x >= TermWin.ncol
		129	|| y < 0 || y >= TermWin.nrow)
		130	return;
		131
		132	for (;;)
		133	{
		134	text_t t = screen.text[y + TermWin.saveLines - TermWin.view_start][x];
		135
		136	if (t != NOCHAR || !x)
		137	{
		138	iso14755_51 (screen.text[y + TermWin.saveLines - TermWin.view_start][x]);
		139	iso14755buf = ISO_14755_54;
		140	break;
		141	}
		142
		143	x--;
		144	}
		145
		146	}
		147	#endif
		148
		149	#if ENABLE_OVERLAY
		150	void
		151	rxvt_term::iso14755_51 (wchar_t ch)
		152	{
		153	wchar_t *chr, *alloc;
		154	int len;
		155
		156	#if ENABLE_COMBINING
		157	if (IS_COMPOSE (ch))
		158	{
		159	len = rxvt_composite.expand (ch, 0);
		160	alloc = chr = new wchar_t[len];
		161	rxvt_composite.expand (ch, chr);
		162	}
		163	else
		164	#endif
		165	{
		166	alloc = 0;
		167	chr = &ch;
		168	len = 1;
		169	}
		170
		171	scr_overlay_new (0, -1, 8 + 5, len);
		172
		173	for (int y = 0; y < len; y++)
		174	{
		175	char buf[9];
		176
		177	ch = *chr++;
		178
		179	sprintf (buf, "%8x", ch);
		180	scr_overlay_set (0, y, buf);
		181	scr_overlay_set (9, y, '=');
		182	#if !UNICODE3
		183	if (ch >= 0x10000)
		184	ch = 0xfffd;
		185	#endif
		186	scr_overlay_set (11, y, ch);
		187	scr_overlay_set (12, y, NOCHAR);
		188	}
		189
		190	#if ENABLE_COMBINING
		191	if (alloc)
		192	delete [] alloc;
		193	#endif
		194	}
		195	#endif
		196
		197	void
		198	rxvt_term::commit_iso14755 ()
		199	{
		200	wchar_t ch[2];
		201
		202	ch[0] = iso14755buf & ISO_14755_MASK;
		203	ch[1] = 0;
		204
		205	if (iso14755buf & ISO_14755_51)
		206	{
		207	char mb[16];
		208	int len;
		209
		210	// allow verbatim 0-bytes and control-bytes to be entered
		211	if (ch[0] >= 0x20)
		212	len = wcstombs (mb, ch, 16);
		213	else
		214	{
		215	mb[0] = ch[0];
		216	len = 1;
		217	}
		218
		219	if (len > 0)
		220	tt_write ((unsigned char *)mb, len);
		221	else
		222	scr_bell ();
		223	}
		224
		225	iso14755buf = 0;
		226	}
		227
		228	int
		229	rxvt_term::hex_keyval (XKeyEvent &ev)
		230	{
		231	// check wether this event corresponds to a hex digit
		232	// if the modifiers had not been pressed.
		233	for (int index = 0; index < 8; index++)
		234	{
		235	KeySym k = XLookupKeysym (&ev, index);
		236
		237	if (k >= XK_KP_0 && k <= XK_KP_9) return k - XK_KP_0;
		238	else if (k >= XK_0 && k <= XK_9) return k - XK_0;
		239	else if (k >= XK_a && k <= XK_f) return k - XK_a + 10;
		240	else if (k >= XK_A && k <= XK_F) return k - XK_A + 10;
		241	}
		242
		243	return -1;
		244	}
		245	#endif
		246
62	/*{{{ Convert the keypress event into a string */	247	/*{{{ Convert the keypress event into a string */
63	void	248	void
64	rxvt_term::lookup_key (XKeyEvent &ev)	249	rxvt_term::lookup_key (XKeyEvent &ev)
65	{	250	{
66	int ctrl, meta, shft, len;	251	int ctrl, meta, shft, len;
…		…
151	{	336	{
152	if (TermWin.saveLines)	337	if (TermWin.saveLines)
153	{	338	{
154	#ifdef UNSHIFTED_SCROLLKEYS	339	#ifdef UNSHIFTED_SCROLLKEYS
155	if (!ctrl && !meta)	340	if (!ctrl && !meta)
156	{
157	#else	341	#else
158	if (IS_SCROLL_MOD)	342	if (IS_SCROLL_MOD)
		343	#endif
159	{	344	{
160	#endif
161	int lnsppg;	345	int lnsppg;
162		346
163	#ifdef PAGING_CONTEXT_LINES	347	#ifdef PAGING_CONTEXT_LINES
164	lnsppg = TermWin.nrow - PAGING_CONTEXT_LINES;	348	lnsppg = TermWin.nrow - PAGING_CONTEXT_LINES;
165	#else	349	#else
…		…
214	if (keysym >= XK_F1 && keysym <= XK_F10)	398	if (keysym >= XK_F1 && keysym <= XK_F10)
215	{	399	{
216	keysym += (XK_F11 - XK_F1);	400	keysym += (XK_F11 - XK_F1);
217	shft = 0; /* turn off Shift */	401	shft = 0; /* turn off Shift */
218	}	402	}
219	else if (!ctrl && !meta && (PrivateModes & PrivMode_ShiftKeys))	403	else if (!ctrl && !meta && (priv_modes & PrivMode_ShiftKeys))
220	{	404	{
221	switch (keysym)	405	switch (keysym)
222	{	406	{
223	/* normal XTerm key bindings */	407	/* normal XTerm key bindings */
224	case XK_Insert: /* Shift+Insert = paste mouse selection */	408	case XK_Insert: /* Shift+Insert = paste mouse selection */
225	selection_request (ev.time, 0, 0);	409	selection_request (ev.time, 0, 0);
226	return;	410	return;
		411	#if TODO // TODO
227	/* rxvt extras */	412	/* rxvt extras */
228	case XK_KP_Add: /* Shift+KP_Add = bigger font */	413	case XK_KP_Add: /* Shift+KP_Add = bigger font */
229	change_font (FONT_UP);	414	change_font (FONT_UP);
230	return;	415	return;
231	case XK_KP_Subtract: /* Shift+KP_Subtract = smaller font */	416	case XK_KP_Subtract: /* Shift+KP_Subtract = smaller font */
232	change_font (FONT_DN);	417	change_font (FONT_DN);
233	return;	418	return;
		419	#endif
234	}	420	}
235	}	421	}
236	}	422	}
		423
		424	#if ENABLE_FRILLS || ISO_14755
		425	// ISO 14755 support
		426	if (shft && ctrl)
		427	{
		428	int hv;
		429
		430	if (iso14755buf & ISO_14755_51
		431	&& (keysym == XK_space || keysym == XK_KP_Space
		432	|| keysym == XK_Return || keysym == XK_KP_Enter))
		433	{
		434	commit_iso14755 ();
		435	iso14755buf = ISO_14755_51;
		436	# if ISO_14755
		437	iso14755_51 (0);
		438	# endif
		439	return;
		440	}
		441	else if ((hv = hex_keyval (ev)) >= 0)
		442	{
		443	iso14755buf = ((iso14755buf << 4) & ISO_14755_MASK)
		444	| hv | ISO_14755_51;
		445	# if ISO_14755
		446	iso14755_51 (iso14755buf & ISO_14755_MASK);
		447	# endif
		448	return;
		449	}
		450	else
		451	{
		452	# if ENABLE_OVERLAY
		453	scr_overlay_off ();
		454	# endif
		455	iso14755buf = 0;
		456	}
		457	}
		458	else if ((ctrl && (keysym == XK_Shift_L || keysym == XK_Shift_R))
		459	|| (shft && (keysym == XK_Control_L || keysym == XK_Control_R)))
		460	if (!(iso14755buf & ISO_14755_STARTED))
		461	{
		462	iso14755buf |= ISO_14755_STARTED;
		463	# if ENABLE_OVERLAY
		464	scr_overlay_new (0, -1, sizeof ("ISO 14755 mode") - 1, 1);
		465	scr_overlay_set (0, 0, "ISO 14755 mode");
		466	# endif
		467	}
		468	#endif
		469
237	#ifdef PRINTPIPE	470	#ifdef PRINTPIPE
238	if (keysym == XK_Print)	471	if (keysym == XK_Print)
239	{	472	{
240	scr_printscreen (ctrl | shft);	473	scr_printscreen (ctrl | shft);
241	return;	474	return;
…		…
273	newlen = 1;	506	newlen = 1;
274	switch (keysym)	507	switch (keysym)
275	{	508	{
276	#ifndef NO_BACKSPACE_KEY	509	#ifndef NO_BACKSPACE_KEY
277	case XK_BackSpace:	510	case XK_BackSpace:
278	if (PrivateModes & PrivMode_HaveBackSpace)	511	if (priv_modes & PrivMode_HaveBackSpace)
279	{	512	{
280	kbuf[0] = (!! (PrivateModes & PrivMode_BackSpace)	513	kbuf[0] = (!! (priv_modes & PrivMode_BackSpace)
281	^ !!ctrl) ? '\b' : '\177';	514	^ !!ctrl) ? '\b' : '\177';
282	kbuf[1] = '\0';	515	kbuf[1] = '\0';
283	}	516	}
284	else	517	else
285	STRCPY (kbuf, key_backspace);	518	strcpy (kbuf, key_backspace);
286	break;	519	break;
287	#endif	520	#endif
288	#ifndef NO_DELETE_KEY	521	#ifndef NO_DELETE_KEY
289	case XK_Delete:	522	case XK_Delete:
290	STRCPY (kbuf, key_delete);	523	strcpy (kbuf, key_delete);
291	break;	524	break;
292	#endif	525	#endif
293	case XK_Tab:	526	case XK_Tab:
294	if (shft)	527	if (shft)
295	STRCPY (kbuf, "\033[Z");	528	strcpy (kbuf, "\033[Z");
296	else	529	else
297	{	530	{
298	#ifdef CTRL_TAB_MAKES_META	531	#ifdef CTRL_TAB_MAKES_META
299	if (ctrl)	532	if (ctrl)
300	meta = 1;	533	meta = 1;
…		…
306	newlen = 0;	539	newlen = 0;
307	}	540	}
308	break;	541	break;
309		542
310	#ifdef XK_KP_Left	543	#ifdef XK_KP_Left
311	case XK_KP_Up: /* \033Ox or standard */	544	case XK_KP_Up: /* \033Ox or standard */
312	case XK_KP_Down: /* \033Or or standard */	545	case XK_KP_Down: /* \033Or or standard */
313	case XK_KP_Right: /* \033Ov or standard */	546	case XK_KP_Right: /* \033Ov or standard */
314	case XK_KP_Left: /* \033Ot or standard */	547	case XK_KP_Left: /* \033Ot or standard */
315	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	548	if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
316	{	549	{
317	STRCPY (kbuf, "\033OZ");	550	strcpy (kbuf, "\033OZ");
318	kbuf[2] = "txvr"[keysym - XK_KP_Left];	551	kbuf[2] = "txvr"[keysym - XK_KP_Left];
319	break;	552	break;
320	}	553	}
321	else	554	else
322	/* translate to std. cursor key */	555	/* translate to std. cursor key */
…		…
325	#endif	558	#endif
326	case XK_Up: /* "\033[A" */	559	case XK_Up: /* "\033[A" */
327	case XK_Down: /* "\033[B" */	560	case XK_Down: /* "\033[B" */
328	case XK_Right: /* "\033[C" */	561	case XK_Right: /* "\033[C" */
329	case XK_Left: /* "\033[D" */	562	case XK_Left: /* "\033[D" */
330	STRCPY (kbuf, "\033[Z");	563	strcpy (kbuf, "\033[Z");
331	kbuf[2] = "DACB"[keysym - XK_Left];	564	kbuf[2] = "DACB"[keysym - XK_Left];
332	/* do Shift first */	565	/* do Shift first */
333	if (shft)	566	if (shft)
334	kbuf[2] = "dacb"[keysym - XK_Left];	567	kbuf[2] = "dacb"[keysym - XK_Left];
335	else if (ctrl)	568	else if (ctrl)
336	{	569	{
337	kbuf[1] = 'O';	570	kbuf[1] = 'O';
338	kbuf[2] = "dacb"[keysym - XK_Left];	571	kbuf[2] = "dacb"[keysym - XK_Left];
339	}	572	}
340	else if (PrivateModes & PrivMode_aplCUR)	573	else if (priv_modes & PrivMode_aplCUR)
341	kbuf[1] = 'O';	574	kbuf[1] = 'O';
342	break;	575	break;
343		576
344	#ifndef UNSHIFTED_SCROLLKEYS	577	#ifndef UNSHIFTED_SCROLLKEYS
345	# ifdef XK_KP_Prior	578	# ifdef XK_KP_Prior
346	case XK_KP_Prior:	579	case XK_KP_Prior:
347	/* allow shift to override */	580	/* allow shift to override */
348	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	581	if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
349	{	582	{
350	STRCPY (kbuf, "\033Oy");	583	strcpy (kbuf, "\033Oy");
351	break;	584	break;
352	}	585	}
353	/* FALLTHROUGH */	586	/* FALLTHROUGH */
354	# endif	587	# endif
355	case XK_Prior:	588	case XK_Prior:
356	STRCPY (kbuf, "\033[5~");	589	strcpy (kbuf, "\033[5~");
357	break;	590	break;
358	# ifdef XK_KP_Next	591	# ifdef XK_KP_Next
359	case XK_KP_Next:	592	case XK_KP_Next:
360	/* allow shift to override */	593	/* allow shift to override */
361	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	594	if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
362	{	595	{
363	STRCPY (kbuf, "\033Os");	596	strcpy (kbuf, "\033Os");
364	break;	597	break;
365	}	598	}
366	/* FALLTHROUGH */	599	/* FALLTHROUGH */
367	# endif	600	# endif
368	case XK_Next:	601	case XK_Next:
369	STRCPY (kbuf, "\033[6~");	602	strcpy (kbuf, "\033[6~");
370	break;	603	break;
371	#endif	604	#endif
372	case XK_KP_Enter:	605	case XK_KP_Enter:
373	/* allow shift to override */	606	/* allow shift to override */
374	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	607	if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
375	{	608	{
376	STRCPY (kbuf, "\033OM");	609	strcpy (kbuf, "\033OM");
		610	break;
		611	}
		612
		613	/* FALLTHROUGH */
		614
		615	case XK_Return:
		616	if (priv_modes & PrivMode_LFNL)
		617	{
		618	kbuf[0] = '\015';
		619	kbuf[1] = '\012';
		620	kbuf[2] = '\0';
377	}	621	}
378	else	622	else
379	{	623	{
380	kbuf[0] = '\r';	624	kbuf[0] = '\015';
381	kbuf[1] = '\0';	625	kbuf[1] = '\0';
382	}	626	}
383	break;	627	break;
384		628
385	#ifdef XK_KP_Begin	629	#ifdef XK_KP_Begin
386	case XK_KP_Begin:	630	case XK_KP_Begin:
387	STRCPY (kbuf, "\033Ou");	631	strcpy (kbuf, "\033Ou");
388	break;	632	break;
389		633
390	case XK_KP_Insert:	634	case XK_KP_Insert:
391	STRCPY (kbuf, "\033Op");	635	strcpy (kbuf, "\033Op");
392	break;	636	break;
393		637
394	case XK_KP_Delete:	638	case XK_KP_Delete:
395	STRCPY (kbuf, "\033On");	639	strcpy (kbuf, "\033On");
396	break;	640	break;
397	#endif	641	#endif
398	case XK_KP_F1: /* "\033OP" */	642	case XK_KP_F1: /* "\033OP" */
399	case XK_KP_F2: /* "\033OQ" */	643	case XK_KP_F2: /* "\033OQ" */
400	case XK_KP_F3: /* "\033OR" */	644	case XK_KP_F3: /* "\033OR" */
401	case XK_KP_F4: /* "\033OS" */	645	case XK_KP_F4: /* "\033OS" */
402	STRCPY (kbuf, "\033OP");	646	strcpy (kbuf, "\033OP");
403	kbuf[2] += (keysym - XK_KP_F1);	647	kbuf[2] += (keysym - XK_KP_F1);
404	break;	648	break;
405		649
406	case XK_KP_Multiply: /* "\033Oj" : "*" */	650	case XK_KP_Multiply: /* "\033Oj" : "*" */
407	case XK_KP_Add: /* "\033Ok" : "+" */	651	case XK_KP_Add: /* "\033Ok" : "+" */
…		…
418	case XK_KP_6: /* "\033Ov" : "6" */	662	case XK_KP_6: /* "\033Ov" : "6" */
419	case XK_KP_7: /* "\033Ow" : "7" */	663	case XK_KP_7: /* "\033Ow" : "7" */
420	case XK_KP_8: /* "\033Ox" : "8" */	664	case XK_KP_8: /* "\033Ox" : "8" */
421	case XK_KP_9: /* "\033Oy" : "9" */	665	case XK_KP_9: /* "\033Oy" : "9" */
422	/* allow shift to override */	666	/* allow shift to override */
423	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	667	if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
424	{	668	{
425	STRCPY (kbuf, "\033Oj");	669	strcpy (kbuf, "\033Oj");
426	kbuf[2] += (keysym - XK_KP_Multiply);	670	kbuf[2] += (keysym - XK_KP_Multiply);
427	}	671	}
428	else	672	else
429	{	673	{
430	kbuf[0] = ('*' + (keysym - XK_KP_Multiply));	674	kbuf[0] = ('*' + (keysym - XK_KP_Multiply));
431	kbuf[1] = '\0';	675	kbuf[1] = '\0';
432	}	676	}
433	break;	677	break;
434		678
435	case XK_Find:	679	case XK_Find:
436	STRCPY (kbuf, "\033[1~");	680	strcpy (kbuf, "\033[1~");
437	break;	681	break;
438	case XK_Insert:	682	case XK_Insert:
439	STRCPY (kbuf, "\033[2~");	683	strcpy (kbuf, "\033[2~");
440	break;	684	break;
441	#ifdef DXK_Remove /* support for DEC remove like key */	685	#ifdef DXK_Remove /* support for DEC remove like key */
442	case DXK_Remove:	686	case DXK_Remove:
443	/* FALLTHROUGH */	687	/* FALLTHROUGH */
444	#endif	688	#endif
445	case XK_Execute:	689	case XK_Execute:
446	STRCPY (kbuf, "\033[3~");	690	strcpy (kbuf, "\033[3~");
447	break;	691	break;
448	case XK_Select:	692	case XK_Select:
449	STRCPY (kbuf, "\033[4~");	693	strcpy (kbuf, "\033[4~");
450	break;	694	break;
451	#ifdef XK_KP_End	695	#ifdef XK_KP_End
452	case XK_KP_End:	696	case XK_KP_End:
453	/* allow shift to override */	697	/* allow shift to override */
454	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	698	if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
455	{	699	{
456	STRCPY (kbuf, "\033Oq");	700	strcpy (kbuf, "\033Oq");
457	break;	701	break;
458	}	702	}
459	/* FALLTHROUGH */	703	/* FALLTHROUGH */
460	#endif	704	#endif
461	case XK_End:	705	case XK_End:
462	STRCPY (kbuf, KS_END);	706	strcpy (kbuf, KS_END);
463	break;	707	break;
464	#ifdef XK_KP_Home	708	#ifdef XK_KP_Home
465	case XK_KP_Home:	709	case XK_KP_Home:
466	/* allow shift to override */	710	/* allow shift to override */
467	if ((PrivateModes & PrivMode_aplKP) ? !shft : shft)	711	if ((priv_modes & PrivMode_aplKP) ? !shft : shft)
468	{	712	{
469	STRCPY (kbuf, "\033Ow");	713	strcpy (kbuf, "\033Ow");
470	break;	714	break;
471	}	715	}
472	/* FALLTHROUGH */	716	/* FALLTHROUGH */
473	#endif	717	#endif
474	case XK_Home:	718	case XK_Home:
475	STRCPY (kbuf, KS_HOME);	719	strcpy (kbuf, KS_HOME);
476	break;	720	break;
477		721
478	#define FKEY(n, fkey) \	722	#define FKEY(n, fkey) \
479	sprintf ((char *)kbuf,"\033[%2d~", (int) ((n) + (keysym - fkey)))	723	sprintf ((char *)kbuf,"\033[%2d~", (int) ((n) + (keysym - fkey)))
480		724
…		…
533	default:	777	default:
534	newlen = 0;	778	newlen = 0;
535	break;	779	break;
536	}	780	}
537	if (newlen)	781	if (newlen)
538	len = STRLEN (kbuf);	782	len = strlen (kbuf);
539	}	783	}
540		784
541	/*	785	/*
542	* Pass meta for all function keys, if 'meta' option set	786	* Pass meta for all function keys, if 'meta' option set
543	*/	787	*/
…		…
571	}	815	}
572		816
573	if (len <= 0)	817	if (len <= 0)
574	return; /* not mapped */	818	return; /* not mapped */
575		819
576	if (Options & Opt_scrollTtyKeypress)	820	if (options & Opt_scrollTtyKeypress)
577	if (TermWin.view_start)	821	if (TermWin.view_start)
578	{	822	{
579	TermWin.view_start = 0;	823	TermWin.view_start = 0;
580	want_refresh = 1;	824	want_refresh = 1;
581	}	825	}
…		…
630	n = cmdbuf_ptr - cmdbuf_base;	874	n = cmdbuf_ptr - cmdbuf_base;
631	s = cmdbuf_base + CBUFSIZ - 1 - cmdbuf_endp;	875	s = cmdbuf_base + CBUFSIZ - 1 - cmdbuf_endp;
632		876
633	if (n > 0 && s < count)	877	if (n > 0 && s < count)
634	{	878	{
635	MEMMOVE (cmdbuf_base, cmdbuf_ptr,	879	memmove (cmdbuf_base, cmdbuf_ptr,
636	(unsigned int) (cmdbuf_endp - cmdbuf_ptr));	880	(unsigned int) (cmdbuf_endp - cmdbuf_ptr));
637	cmdbuf_ptr = cmdbuf_base;	881	cmdbuf_ptr = cmdbuf_base;
638	cmdbuf_endp -= n;	882	cmdbuf_endp -= n;
639	s += n;	883	s += n;
640	}	884	}
…		…
661	if (want_full_refresh)	905	if (want_full_refresh)
662	{	906	{
663	want_full_refresh = 0;	907	want_full_refresh = 0;
664	scr_clear ();	908	scr_clear ();
665	scr_touch (false);	909	scr_touch (false);
666	want_refresh = 1;
667	}	910	}
668	#endif	911	#endif
669		912
670	if (want_refresh)	913	if (want_refresh)
671	{	914	{
…		…
687	SET_R (this);	930	SET_R (this);
688	SET_LOCALE (locale);	931	SET_LOCALE (locale);
689		932
690	display->flush ();	933	display->flush ();
691		934
692	if (!flush_ev.active)	935	if (want_refresh && !flush_ev.active)
693	flush_ev.start (NOW + 0.01);	936	flush_ev.start (NOW + 0.01);
694	}	937	}
695		938
696	void	939	void
697	rxvt_term::flush_cb (time_watcher &w)	940	rxvt_term::flush_cb (time_watcher &w)
…		…
784		1027
785	memmove (cmdbuf_base, cmdbuf_ptr, n);	1028	memmove (cmdbuf_base, cmdbuf_ptr, n);
786	cmdbuf_ptr = cmdbuf_base;	1029	cmdbuf_ptr = cmdbuf_base;
787	cmdbuf_endp = cmdbuf_ptr + n;	1030	cmdbuf_endp = cmdbuf_ptr + n;
788		1031
789	n = read (cmd_fd, cmdbuf_endp, CBUFSIZ - n);	1032	n = read (pty.pty, cmdbuf_endp, CBUFSIZ - n);
790		1033
791	if (n > 0)	1034	if (n > 0)
792	{	1035	{
793	cmdbuf_endp += n;	1036	cmdbuf_endp += n;
794	return true;	1037	return true;
…		…
821	recolour_cursor ();	1064	recolour_cursor ();
822		1065
823	#ifdef POINTER_BLANK	1066	#ifdef POINTER_BLANK
824	hidden_pointer = 0;	1067	hidden_pointer = 0;
825		1068
826	if (Options & Opt_pointerBlank)	1069	if (options & Opt_pointerBlank)
827	pointer_ev.start (NOW + pointerBlankDelay);	1070	pointer_ev.start (NOW + pointerBlankDelay);
828	#endif	1071	#endif
829	}	1072	}
830		1073
831	#ifdef POINTER_BLANK	1074	#ifdef POINTER_BLANK
832	void	1075	void
833	rxvt_term::pointer_blank ()	1076	rxvt_term::pointer_blank ()
834	{	1077	{
835	if (! (Options & Opt_pointerBlank))	1078	if (! (options & Opt_pointerBlank))
836	return;	1079	return;
837		1080
838	XDefineCursor (display->display, TermWin.vt, blank_cursor);	1081	XDefineCursor (display->display, TermWin.vt, blank_cursor);
839	XFlush (display->display);	1082	XFlush (display->display);
840		1083
…		…
860	x = ev.x;	1103	x = ev.x;
861	y = ev.y;	1104	y = ev.y;
862	pixel_position (&x, &y);	1105	pixel_position (&x, &y);
863		1106
864	if (MEvent.button == AnyButton)	1107	if (MEvent.button == AnyButton)
865	{
866	button_number = 3;	1108	button_number = 3;
867	}
868	else	1109	else
869	{	1110	{
870	button_number = MEvent.button - Button1;	1111	button_number = MEvent.button - Button1;
871	/* add 0x3D for wheel events, like xterm does */	1112	/* add 0x3D for wheel events, like xterm does */
872	if (button_number >= 3)	1113	if (button_number >= 3)
873	button_number += (64 - 3);	1114	button_number += (64 - 3);
874	}	1115	}
875		1116
876	if (PrivateModes & PrivMode_MouseX10)	1117	if (priv_modes & PrivMode_MouseX10)
877	{	1118	{
878	/*	1119	/*
879	* do not report ButtonRelease	1120	* do not report ButtonRelease
880	* no state info allowed	1121	* no state info allowed
881	*/	1122	*/
…		…
939	{	1180	{
940	SET_R (this);	1181	SET_R (this);
941	SET_LOCALE (locale);	1182	SET_LOCALE (locale);
942		1183
943	#if defined(CURSOR_BLINK)	1184	#if defined(CURSOR_BLINK)
944	if ((Options & Opt_cursorBlink) && ev.type == KeyPress)	1185	if ((options & Opt_cursorBlink) && ev.type == KeyPress)
945	{	1186	{
946	if (hidden_cursor)	1187	if (hidden_cursor)
947	{	1188	{
948	hidden_cursor = 0;	1189	hidden_cursor = 0;
949	want_refresh = 1;	1190	want_refresh = 1;
…		…
952	cursor_blink_ev.start (NOW + BLINK_INTERVAL);	1193	cursor_blink_ev.start (NOW + BLINK_INTERVAL);
953	}	1194	}
954	#endif	1195	#endif
955		1196
956	#if defined(POINTER_BLANK)	1197	#if defined(POINTER_BLANK)
957	if ((Options & Opt_pointerBlank) && pointerBlankDelay > 0)	1198	if ((options & Opt_pointerBlank) && pointerBlankDelay > 0)
958	{	1199	{
959	if (ev.type == MotionNotify	1200	if (ev.type == MotionNotify
960	|| ev.type == ButtonPress	1201	|| ev.type == ButtonPress
961	|| ev.type == ButtonRelease)	1202	|| ev.type == ButtonRelease)
962	if (hidden_pointer)	1203	if (hidden_pointer)
…		…
974		1215
975	Window unused_root, unused_child;	1216	Window unused_root, unused_child;
976	int unused_root_x, unused_root_y;	1217	int unused_root_x, unused_root_y;
977	unsigned int unused_mask;	1218	unsigned int unused_mask;
978		1219
979	#ifdef DEBUG_X
980	const char *const eventnames[] =
981	{ /* mason - this matches my system */
982	"",
983	"",
984	"KeyPress",
985	"KeyRelease",
986	"ButtonPress",
987	"ButtonRelease",
988	"MotionNotify",
989	"EnterNotify",
990	"LeaveNotify",
991	"FocusIn",
992	"FocusOut",
993	"KeymapNotify",
994	"Expose",
995	"GraphicsExpose",
996	"NoExpose",
997	"VisibilityNotify",
998	"CreateNotify",
999	"DestroyNotify",
1000	"UnmapNotify",
1001	"MapNotify",
1002	"MapRequest",
1003	"ReparentNotify",
1004	"ConfigureNotify",
1005	"ConfigureRequest",
1006	"GravityNotify",
1007	"ResizeRequest",
1008	"CirculateNotify",
1009	"CirculateRequest",
1010	"PropertyNotify",
1011	"SelectionClear",
1012	"SelectionRequest",
1013	"SelectionNotify",
1014	"ColormapNotify",
1015	"ClientMessage",
1016	"MappingNotify"
1017	};
1018	#endif
1019
1020	#ifdef DEBUG_X
1021	struct timeval tp;
1022	struct tm *ltt;
1023	(void)gettimeofday (&tp, NULL);
1024	ltt = localtime (& (tp.tv_sec));
1025	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));
1026	#endif
1027
1028	switch (ev.type)	1220	switch (ev.type)
1029	{	1221	{
1030	case KeyPress:	1222	case KeyPress:
		1223	#if ISO_14755
		1224	if (!(iso14755buf & ISO_14755_52))
		1225	#endif
1031	lookup_key (ev.xkey);	1226	lookup_key (ev.xkey);
		1227
		1228	break;
		1229
		1230	case KeyRelease:
		1231	{
		1232	#if (defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)) || defined (ENABLE_FRILLS)
		1233	KeySym ks;
		1234
		1235	ks = XLookupKeysym (&ev.xkey, ev.xkey.state & ShiftMask ? 1 : 0); // sorry, only shift supported :/
		1236	#endif
		1237
		1238	#if ENABLE_FRILLS || ISO_14755
		1239	// ISO 14755 support
		1240	if (iso14755buf)
		1241	if (iso14755buf & ISO_14755_52)
		1242	{
		1243	# if ENABLE_OVERLAY
		1244	scr_overlay_off ();
		1245	# endif
		1246	# if ISO_14755
		1247	// iso14755 part 5.2 handling: release time
		1248	// first: controls
		1249	if ((ev.xkey.state & ControlMask)
		1250	&& ((ks >= 0x40 && ks <= 0x5f)
		1251	|| (ks >= 0x61 && ks <= 0x7f)))
		1252	{
		1253	iso14755buf = ISO_14755_51 | 0x2400 | (ks & 0x1f);
		1254	commit_iso14755 ();
		1255	return; // case-break;
		1256	}
		1257
		1258	for (unsigned short *i = iso14755_symtab; i[0]; i+= 2)
		1259	if (i[0] == ks)
		1260	{
		1261	iso14755buf = ISO_14755_51 | i[1];
		1262	commit_iso14755 ();
		1263	return; // case-break;
		1264	}
		1265
		1266	scr_bell ();
		1267	# endif
		1268	iso14755buf = 0;
1032	break;	1269	break;
		1270	}
		1271	else if ((ev.xkey.state & (ShiftMask | ControlMask)) != (ShiftMask | ControlMask))
		1272	{
		1273	# if ENABLE_OVERLAY
		1274	scr_overlay_off ();
		1275	# endif
		1276	if (iso14755buf & ISO_14755_51)
		1277	commit_iso14755 ();
		1278	#if ISO_14755
		1279	else if (iso14755buf & ISO_14755_STARTED)
		1280	{
		1281	iso14755buf = ISO_14755_52; // iso14755 part 5.2: remember empty begin/end pair
		1282
		1283	scr_overlay_new (0, -1, sizeof ("KEYCAP PICTURE INSERT MODE") - 1, 1);
		1284	scr_overlay_set (0, 0, "KEYCAP PICTURE INSERT MODE");
		1285	}
		1286	# endif
		1287	else
		1288	iso14755buf = 0;
		1289	}
		1290	#endif
1033		1291
1034	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)	1292	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
1035	case KeyRelease:
1036	{
1037	if (!(ev.xkey.state & ControlMask))	1293	if (!(ev.xkey.state & ControlMask))
1038	slip_wheel_ev.stop ();	1294	slip_wheel_ev.stop ();
1039	else
1040	{
1041	KeySym ks;
1042
1043	ks = XKeycodeToKeysym (display->display, ev.xkey.keycode, 0);
1044	if (ks == XK_Control_L || ks == XK_Control_R)	1295	else if (ks == XK_Control_L || ks == XK_Control_R)
1045	mouse_slip_wheel_speed = 0;	1296	mouse_slip_wheel_speed = 0;
1046	}	1297	#endif
1047	break;	1298	break;
1048	}	1299	}
1049	#endif
1050		1300
1051	case ButtonPress:	1301	case ButtonPress:
1052	button_press (ev.xbutton);	1302	button_press (ev.xbutton);
1053	break;	1303	break;
1054		1304
…		…
1081	&Size, &RemainingBytes,	1331	&Size, &RemainingBytes,
1082	&data);	1332	&data);
1083	XChangeProperty (display->display, display->root,	1333	XChangeProperty (display->display, display->root,
1084	XA_CUT_BUFFER0, XA_STRING,	1334	XA_CUT_BUFFER0, XA_STRING,
1085	8, PropModeReplace,	1335	8, PropModeReplace,
1086	data, STRLEN (data));	1336	data, strlen (data));
1087	XFree (data);	1337	XFree (data);
1088	selection_paste (display->root, XA_CUT_BUFFER0, True);	1338	selection_paste (display->root, XA_CUT_BUFFER0, True);
1089	XSetInputFocus (display->display, display->root, RevertToNone, CurrentTime);	1339	XSetInputFocus (display->display, display->root, RevertToNone, CurrentTime);
1090	}	1340	}
1091	#endif /* OFFIX_DND */	1341	#endif /* OFFIX_DND */
…		…
1125	{	1375	{
1126	TermWin.focus = 1;	1376	TermWin.focus = 1;
1127	want_refresh = 1;	1377	want_refresh = 1;
1128	#ifdef USE_XIM	1378	#ifdef USE_XIM
1129	if (Input_Context != NULL)	1379	if (Input_Context != NULL)
		1380	{
		1381	IMSetStatusPosition ();
1130	XSetICFocus (Input_Context);	1382	XSetICFocus (Input_Context);
		1383	}
1131	#endif	1384	#endif
1132	#ifdef CURSOR_BLINK	1385	#ifdef CURSOR_BLINK
1133	if (Options & Opt_cursorBlink)	1386	if (options & Opt_cursorBlink)
1134	cursor_blink_ev.start (NOW + BLINK_INTERVAL);	1387	cursor_blink_ev.start (NOW + BLINK_INTERVAL);
1135	#endif	1388	#endif
1136	#ifdef OFF_FOCUS_FADING	1389	#ifdef OFF_FOCUS_FADING
1137	if (rs[Rs_fade])	1390	if (rs[Rs_fade])
1138	{	1391	{
1139	PixColors = PixColorsFocused;	1392	pix_colors = pix_colors_focused;
1140	set_colorfgbg ();	1393	set_colorfgbg ();
1141	scr_clear ();	1394	scr_clear ();
1142	scr_touch (true);	1395	scr_touch (true);
1143	}	1396	}
1144	#endif	1397	#endif
…		…
1154	#ifdef USE_XIM	1407	#ifdef USE_XIM
1155	if (Input_Context != NULL)	1408	if (Input_Context != NULL)
1156	XUnsetICFocus (Input_Context);	1409	XUnsetICFocus (Input_Context);
1157	#endif	1410	#endif
1158	#ifdef CURSOR_BLINK	1411	#ifdef CURSOR_BLINK
1159	if (Options & Opt_cursorBlink)	1412	if (options & Opt_cursorBlink)
1160	cursor_blink_ev.stop ();	1413	cursor_blink_ev.stop ();
1161	hidden_cursor = 0;	1414	hidden_cursor = 0;
1162	#endif	1415	#endif
1163	#ifdef OFF_FOCUS_FADING	1416	#ifdef OFF_FOCUS_FADING
1164	if (rs[Rs_fade])	1417	if (rs[Rs_fade])
1165	{	1418	{
1166	PixColors = PixColorsUnFocused;	1419	pix_colors = pix_colors_unfocused;
1167	set_colorfgbg ();	1420	set_colorfgbg ();
1168	scr_clear ();	1421	scr_clear ();
1169	scr_touch (true);	1422	scr_touch (true);
1170	}	1423	}
1171	#endif	1424	#endif
…		…
1188		1441
1189	if (szHint.width != width || szHint.height != height)	1442	if (szHint.width != width || szHint.height != height)
1190	resize_all_windows (width, height, 1);	1443	resize_all_windows (width, height, 1);
1191		1444
1192	#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */	1445	#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */
1193	if (Options & Opt_transparent)	1446	if (options & Opt_transparent)
1194	{	1447	{
1195	check_our_parents ();	1448	check_our_parents ();
1196	if (am_transparent)	1449	if (am_transparent)
1197	want_full_refresh = 1;	1450	want_refresh = want_full_refresh = 1;
1198	}	1451	}
1199	#endif	1452	#endif
1200	}	1453	}
		1454	break;
		1455
		1456	case PropertyNotify:
		1457	if (ev.xproperty.atom == xa[XA_VT_SELECTION]
		1458	&& ev.xproperty.state == PropertyNewValue)
		1459	selection_property (ev.xproperty.window, ev.xproperty.atom);
		1460
1201	break;	1461	break;
1202		1462
1203	case SelectionClear:	1463	case SelectionClear:
1204	selection_clear ();	1464	selection_clear ();
1205	break;	1465	break;
…		…
1287	{	1547	{
1288	menubar_control (ev.xbutton);	1548	menubar_control (ev.xbutton);
1289	break;	1549	break;
1290	}	1550	}
1291	#endif	1551	#endif
1292	if ((PrivateModes & PrivMode_mouse_report) && ! (bypass_keystate))	1552	if ((priv_modes & PrivMode_mouse_report) && ! (bypass_keystate))
1293	break;	1553	break;
1294		1554
1295	if (ev.xany.window == TermWin.vt)	1555	if (ev.xany.window == TermWin.vt)
1296	{	1556	{
1297	if ((ev.xbutton.state & (Button1Mask | Button3Mask)))	1557	if (ev.xbutton.state & (Button1Mask | Button3Mask))
1298	{	1558	{
1299	while (XCheckTypedWindowEvent (display->display, TermWin.vt, MotionNotify, &ev))	1559	while (XCheckTypedWindowEvent (display->display, TermWin.vt, MotionNotify, &ev))
1300	;	1560	;
1301		1561
1302	XQueryPointer (display->display, TermWin.vt,	1562	XQueryPointer (display->display, TermWin.vt,
1303	&unused_root, &unused_child,	1563	&unused_root, &unused_child,
1304	&unused_root_x, &unused_root_y,	1564	&unused_root_x, &unused_root_y,
1305	& (ev.xbutton.x), & (ev.xbutton.y),	1565	& (ev.xbutton.x), & (ev.xbutton.y),
1306	&unused_mask);	1566	&unused_mask);
1307	#ifdef MOUSE_THRESHOLD	1567	#ifdef MOUSE_THRESHOLD
1308	/* deal with a `jumpy' mouse */	1568	/* deal with a `jumpy' mouse */
1309	if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)	1569	if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)
1310	{	1570	{
1311	#endif	1571	#endif
		1572	#if ISO_14755
		1573	// 5.4
		1574	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
		1575	{
		1576	iso14755_54 (ev.xbutton.x, ev.xbutton.y);
		1577	break;
		1578	}
		1579	#endif
1312	selection_extend ((ev.xbutton.x), (ev.xbutton.y),	1580	selection_extend (ev.xbutton.x, ev.xbutton.y,
1313	(ev.xbutton.state & Button3Mask) ? 2 : 0);	1581	(ev.xbutton.state & Button3Mask) ? 2 : 0);
1314	#ifdef SELECTION_SCROLLING	1582	#ifdef SELECTION_SCROLLING
1315	if (ev.xbutton.y < TermWin.int_bwidth	1583	if (ev.xbutton.y < TermWin.int_bwidth
1316	|| Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))	1584	|| Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))
1317	{	1585	{
…		…
1324	sel_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);	1592	sel_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);
1325		1593
1326	/* save the event params so we can highlight	1594	/* save the event params so we can highlight
1327	* the selection in the pending-scroll loop	1595	* the selection in the pending-scroll loop
1328	*/	1596	*/
1329	selection_save_x=ev.xbutton.x;	1597	selection_save_x = ev.xbutton.x;
1330	selection_save_y=ev.xbutton.y;	1598	selection_save_y = ev.xbutton.y;
1331	selection_save_state=
1332	(ev.xbutton.state & Button3Mask) ? 2 : 0;	1599	selection_save_state = (ev.xbutton.state & Button3Mask) ? 2 : 0;
1333		1600
1334	/* calc number of lines to scroll */	1601	/* calc number of lines to scroll */
1335	if (ev.xbutton.y<TermWin.int_bwidth)	1602	if (ev.xbutton.y<TermWin.int_bwidth)
1336	{	1603	{
1337	scroll_selection_dir = UP;	1604	scroll_selection_dir = UP;
1338	dist = TermWin.int_bwidth - ev.xbutton.y;	1605	dist = TermWin.int_bwidth - ev.xbutton.y;
1339	}	1606	}
1340	else	1607	else
1341	{	1608	{
1342	scroll_selection_dir = DN;	1609	scroll_selection_dir = DN;
1343	dist = ev.xbutton.y -
1344	(TermWin.int_bwidth + TermWin.height);	1610	dist = ev.xbutton.y - (TermWin.int_bwidth + TermWin.height);
1345	}	1611	}
		1612
1346	scroll_selection_lines= (Pixel2Height (dist)/	1613	scroll_selection_lines = Pixel2Height (dist)
1347	SELECTION_SCROLL_LINE_SPEEDUP)+1;	1614	/ SELECTION_SCROLL_LINE_SPEEDUP
		1615	+ 1;
1348	MIN_IT (scroll_selection_lines,	1616	MIN_IT (scroll_selection_lines,
1349	SELECTION_SCROLL_MAX_LINES);	1617	SELECTION_SCROLL_MAX_LINES);
1350	}	1618	}
1351	else	1619	else
1352	{	1620	{
1353	/* we are within the text window, so we	1621	/* we are within the text window, so we
1354	* shouldn't be scrolling	1622	* shouldn't be scrolling
…		…
1356	if (sel_scroll_ev.active)	1624	if (sel_scroll_ev.active)
1357	sel_scroll_ev.stop();	1625	sel_scroll_ev.stop();
1358	}	1626	}
1359	#endif	1627	#endif
1360	#ifdef MOUSE_THRESHOLD	1628	#ifdef MOUSE_THRESHOLD
1361
1362	}	1629	}
1363	#endif	1630	#endif
1364
1365	}	1631	}
1366	}	1632	}
1367	else if (isScrollbarWindow (ev.xany.window) && scrollbar_isMotion ())	1633	else if (isScrollbarWindow (ev.xany.window) && scrollbar_isMotion ())
1368	{	1634	{
1369	while (XCheckTypedWindowEvent (display->display, scrollBar.win,	1635	while (XCheckTypedWindowEvent (display->display, scrollBar.win,
1370	MotionNotify, &ev)) ;	1636	MotionNotify, &ev)) ;
1371	XQueryPointer (display->display, scrollBar.win,	1637	XQueryPointer (display->display, scrollBar.win,
1372	&unused_root, &unused_child,	1638	&unused_root, &unused_child,
1373	&unused_root_x, &unused_root_y,	1639	&unused_root_x, &unused_root_y,
1374	& (ev.xbutton.x), & (ev.xbutton.y),	1640	& (ev.xbutton.x), & (ev.xbutton.y),
1375	&unused_mask);	1641	&unused_mask);
…		…
1381	}	1647	}
1382	break;	1648	break;
1383	}	1649	}
1384	}	1650	}
1385		1651
		1652	#if TRANSPARENT
1386	void	1653	void
1387	rxvt_term::rootwin_cb (XEvent &ev)	1654	rxvt_term::rootwin_cb (XEvent &ev)
1388	{	1655	{
1389	SET_R (this);	1656	SET_R (this);
1390	SET_LOCALE (locale);	1657	SET_LOCALE (locale);
1391		1658
1392	switch (ev.type)	1659	switch (ev.type)
1393	{	1660	{
1394	case PropertyNotify:	1661	case PropertyNotify:
1395	if (ev.xproperty.atom == xa[XA_VT_SELECTION])
1396	{
1397	if (ev.xproperty.state == PropertyNewValue)
1398	selection_property (ev.xproperty.window, ev.xproperty.atom);
1399	break;
1400	}
1401	#ifdef TRANSPARENT
1402	else
1403	{
1404	/*	1662	/*
1405	* if user used some Esetroot compatible prog to set the root bg,	1663	* if user used some Esetroot compatible prog to set the root bg,
1406	* use the property to determine the pixmap. We use it later on.	1664	* use the property to determine the pixmap. We use it later on.
1407	*/	1665	*/
1408	if (xa[XA_XROOTPMAPID] == 0)	1666	if (xa[XA_XROOTPMAPID] == 0)
1409	xa[XA_XROOTPMAPID] = XInternAtom (display->display, "_XROOTPMAP_ID", False);	1667	xa[XA_XROOTPMAPID] = XInternAtom (display->display, "_XROOTPMAP_ID", False);
1410		1668
1411	if (ev.xproperty.atom != xa[XA_XROOTPMAPID])	1669	if (ev.xproperty.atom != xa[XA_XROOTPMAPID])
1412	return;	1670	return;
1413	}
1414		1671
1415	/* FALLTHROUGH */	1672	/* FALLTHROUGH */
1416	case ReparentNotify:	1673	case ReparentNotify:
1417	if ((Options & Opt_transparent) && check_our_parents () && am_transparent)	1674	if ((options & Opt_transparent) && check_our_parents () && am_transparent)
1418	want_full_refresh = 1;	1675	want_refresh = want_full_refresh = 1;
1419	break;	1676	break;
1420	#endif
1421	}	1677	}
1422	}	1678	}
		1679	#endif
1423		1680
1424	void	1681	void
1425	rxvt_term::button_press (XButtonEvent &ev)	1682	rxvt_term::button_press (XButtonEvent &ev)
1426	{	1683	{
1427	int reportmode = 0, clickintime;	1684	int reportmode = 0, clickintime;
1428		1685
1429	bypass_keystate = ev.state & (ModMetaMask | ShiftMask);	1686	bypass_keystate = ev.state & (ModMetaMask | ShiftMask);
1430	if (!bypass_keystate)	1687	if (!bypass_keystate)
1431	reportmode = !! (PrivateModes & PrivMode_mouse_report);	1688	reportmode = !! (priv_modes & PrivMode_mouse_report);
		1689
1432	/*	1690	/*
1433	* VT window processing of button press	1691	* VT window processing of button press
1434	*/	1692	*/
1435	if (ev.window == TermWin.vt)	1693	if (ev.window == TermWin.vt)
1436	{	1694	{
		1695	#if ISO_14755
		1696	// 5.4
		1697	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
		1698	{
		1699	iso14755_54 (ev.x, ev.y);
		1700	return;
		1701	}
		1702	#endif
		1703
1437	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;	1704	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;
1438	if (reportmode)	1705	if (reportmode)
1439	{	1706	{
1440	/* mouse report from vt window */	1707	/* mouse report from vt window */
1441	/* save the xbutton state (for ButtonRelease) */	1708	/* save the xbutton state (for ButtonRelease) */
…		…
1475	MEvent.clicks = 0;	1742	MEvent.clicks = 0;
1476	switch (ev.button)	1743	switch (ev.button)
1477	{	1744	{
1478	case Button1:	1745	case Button1:
1479	/* allow shift+left click to extend selection */	1746	/* allow shift+left click to extend selection */
1480	if (ev.state & ShiftMask && ! (PrivateModes & PrivMode_mouse_report))	1747	if (ev.state & ShiftMask && ! (priv_modes & PrivMode_mouse_report))
1481	{	1748	{
1482	if (MEvent.button == Button1 && clickintime)	1749	if (MEvent.button == Button1 && clickintime)
1483	selection_rotate (ev.x, ev.y);	1750	selection_rotate (ev.x, ev.y);
1484	else	1751	else
1485	selection_extend (ev.x, ev.y, 1);	1752	selection_extend (ev.x, ev.y, 1);
…		…
1500	case Button3:	1767	case Button3:
1501	if (MEvent.button == Button3 && clickintime)	1768	if (MEvent.button == Button3 && clickintime)
1502	selection_rotate (ev.x, ev.y);	1769	selection_rotate (ev.x, ev.y);
1503	else	1770	else
1504	selection_extend (ev.x, ev.y, 1);	1771	selection_extend (ev.x, ev.y, 1);
		1772
1505	MEvent.button = Button3;	1773	MEvent.button = Button3;
1506	break;	1774	break;
1507	}	1775	}
1508	}	1776	}
		1777
1509	MEvent.time = ev.time;	1778	MEvent.time = ev.time;
1510	return;	1779	return;
1511	}	1780	}
1512		1781
1513	/*	1782	/*
…		…
1605	break;	1874	break;
1606	case R_SB_ALIGN_BOTTOM:	1875	case R_SB_ALIGN_BOTTOM:
1607	csrO = scrollBar.bot - scrollBar.top;	1876	csrO = scrollBar.bot - scrollBar.top;
1608	break;	1877	break;
1609	}	1878	}
		1879
1610	if (scrollBar.style == R_SB_XTERM	1880	if (scrollBar.style == R_SB_XTERM
1611	|| scrollbar_above_slider (ev.y)	1881	|| scrollbar_above_slider (ev.y)
1612	|| scrollbar_below_slider (ev.y))	1882	|| scrollbar_below_slider (ev.y))
1613	scr_move_to ( scrollbar_position (ev.y) - csrO,	1883	scr_move_to (scrollbar_position (ev.y) - csrO, scrollbar_size ());
1614	scrollbar_size ());	1884
1615	scrollBar.setMotion ();	1885	scrollBar.setMotion ();
1616	break;	1886	break;
1617		1887
1618	case Button1:	1888	case Button1:
1619	if (scrollbar_align == R_SB_ALIGN_CENTRE)	1889	if (scrollbar_align == R_SB_ALIGN_CENTRE)
…		…
1643	scr_page ((ev.button == Button1 ? DN : UP),	1913	scr_page ((ev.button == Button1 ? DN : UP),
1644	(TermWin.nrow	1914	(TermWin.nrow
1645	* scrollbar_position (ev.y)	1915	* scrollbar_position (ev.y)
1646	/ scrollbar_size ()));	1916	/ scrollbar_size ()));
1647	}	1917	}
		1918
1648	break;	1919	break;
1649	}	1920	}
1650	}	1921	}
1651	return;	1922	return;
1652	}	1923	}
…		…
1664	{	1935	{
1665	int reportmode = 0;	1936	int reportmode = 0;
1666		1937
1667	csrO = 0; /* reset csr Offset */	1938	csrO = 0; /* reset csr Offset */
1668	if (!bypass_keystate)	1939	if (!bypass_keystate)
1669	reportmode = !! (PrivateModes & PrivMode_mouse_report);	1940	reportmode = !! (priv_modes & PrivMode_mouse_report);
1670		1941
1671	if (scrollbar_isUpDn ())	1942	if (scrollbar_isUpDn ())
1672	{	1943	{
1673	scrollBar.setIdle ();	1944	scrollBar.setIdle ();
1674	scrollbar_show (0);	1945	scrollbar_show (0);
1675	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING	1946	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1676	refresh_type &= ~SMOOTH_REFRESH;	1947	refresh_type &= ~SMOOTH_REFRESH;
1677	#endif	1948	#endif
1678
1679	}	1949	}
		1950
1680	#ifdef SELECTION_SCROLLING	1951	#ifdef SELECTION_SCROLLING
1681	if (sel_scroll_ev.active)	1952	if (sel_scroll_ev.active)
1682	sel_scroll_ev.stop();	1953	sel_scroll_ev.stop();
1683	#endif	1954	#endif
		1955
1684	if (ev.window == TermWin.vt)	1956	if (ev.window == TermWin.vt)
1685	{	1957	{
		1958	#if ISO_14755
		1959	// 5.4
		1960	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
		1961	return;
		1962	#endif
1686	if (reportmode)	1963	if (reportmode)
1687	{	1964	{
1688	/* mouse report from vt window */	1965	/* mouse report from vt window */
1689	/* don't report release of wheel "buttons" */	1966	/* don't report release of wheel "buttons" */
1690	if (ev.button >= 4)	1967	if (ev.button >= 4)
…		…
1704	MEvent.button = AnyButton;	1981	MEvent.button = AnyButton;
1705	mouse_report (ev);	1982	mouse_report (ev);
1706	#endif /* MOUSE_REPORT_DOUBLECLICK */	1983	#endif /* MOUSE_REPORT_DOUBLECLICK */
1707	return;	1984	return;
1708	}	1985	}
		1986
1709	/*	1987	/*
1710	* dumb hack to compensate for the failure of click-and-drag	1988	* dumb hack to compensate for the failure of click-and-drag
1711	* when overriding mouse reporting	1989	* when overriding mouse reporting
1712	*/	1990	*/
1713	if (PrivateModes & PrivMode_mouse_report	1991	if (priv_modes & PrivMode_mouse_report
1714	&& bypass_keystate	1992	&& bypass_keystate
1715	&& ev.button == Button1 && MEvent.clicks <= 1)	1993	&& ev.button == Button1 && MEvent.clicks <= 1)
1716	selection_extend (ev.x, ev.y, 0);	1994	selection_extend (ev.x, ev.y, 0);
1717		1995
1718	switch (ev.button)	1996	switch (ev.button)
…		…
1733		2011
1734	v = ev.button == Button4 ? UP : DN;	2012	v = ev.button == Button4 ? UP : DN;
1735		2013
1736	if (ev.state & ShiftMask)	2014	if (ev.state & ShiftMask)
1737	i = 1;	2015	i = 1;
1738	else if (Options & Opt_mouseWheelScrollPage)	2016	else if (options & Opt_mouseWheelScrollPage)
1739	i = TermWin.nrow - 1;	2017	i = TermWin.nrow - 1;
1740	else	2018	else
1741	i = 5;	2019	i = 5;
1742		2020
1743	# ifdef MOUSE_SLIP_WHEELING	2021	# ifdef MOUSE_SLIP_WHEELING
…		…
2028	Pixmap rootpixmap = None;	2306	Pixmap rootpixmap = None;
2029	XWindowAttributes wattr, wrootattr;	2307	XWindowAttributes wattr, wrootattr;
2030		2308
2031	pchanged = 0;	2309	pchanged = 0;
2032		2310
2033	if (!(Options & Opt_transparent))	2311	if (!(options & Opt_transparent))
2034	return pchanged; /* Don't try any more */	2312	return pchanged; /* Don't try any more */
2035		2313
2036	XGetWindowAttributes (display->display, display->root, &wrootattr);	2314	XGetWindowAttributes (display->display, display->root, &wrootattr);
2037	rootdepth = wrootattr.depth;	2315	rootdepth = wrootattr.depth;
2038		2316
…		…
2041	if (rootdepth != wattr.depth)	2319	if (rootdepth != wattr.depth)
2042	{	2320	{
2043	if (am_transparent)	2321	if (am_transparent)
2044	{	2322	{
2045	pchanged = 1;	2323	pchanged = 1;
2046	XSetWindowBackground (display->display, TermWin.vt, PixColorsFocused[Color_bg]);	2324	XSetWindowBackground (display->display, TermWin.vt, pix_colors_focused[Color_bg]);
2047	am_transparent = am_pixmap_trans = 0;	2325	am_transparent = am_pixmap_trans = 0;
2048	}	2326	}
2049		2327
2050	return pchanged; /* Don't try any more */	2328	return pchanged; /* Don't try any more */
2051	}	2329	}
…		…
2146	if (ISSET_PIXCOLOR (Color_tint))	2424	if (ISSET_PIXCOLOR (Color_tint))
2147	{	2425	{
2148	unsigned short rm, gm, bm;	2426	unsigned short rm, gm, bm;
2149	int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;	2427	int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;
2150		2428
2151	PixColorsFocused[Color_tint].get (display, rm, gm, bm);	2429	pix_colors_focused[Color_tint].get (display, rm, gm, bm);
2152		2430
2153	ShadeXImage (display, image, shade, rm, gm, bm);	2431	ShadeXImage (display, image, shade, rm, gm, bm);
2154	}	2432	}
2155	#endif	2433	#endif
2156		2434
…		…
2175	{	2453	{
2176	unsigned int n;	2454	unsigned int n;
2177	/*	2455	/*
2178	* InheritPixmap transparency	2456	* InheritPixmap transparency
2179	*/	2457	*/
2180	D_X ((stderr, "InheritPixmap Seeking to %08lx", display->root));
2181	for (i = 1; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)	2458	for (i = 1; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
2182	{	2459	{
2183	oldp = TermWin.parent[i];	2460	oldp = TermWin.parent[i];
2184	XQueryTree (display->display, TermWin.parent[i - 1], &root,	2461	XQueryTree (display->display, TermWin.parent[i - 1], &root,
2185	&TermWin.parent[i], &list, &n);	2462	&TermWin.parent[i], &list, &n);
2186	XFree (list);	2463	XFree (list);
2187	D_X ((stderr, "InheritPixmap Parent[%d] = %08lx", i, TermWin.parent[i]));
2188		2464
2189	if (TermWin.parent[i] == display->root)	2465	if (TermWin.parent[i] == display->root)
2190	{	2466	{
2191	if (oldp != None)	2467	if (oldp != None)
2192	pchanged = 1;	2468	pchanged = 1;
…		…
2203	if (pchanged)	2479	if (pchanged)
2204	{	2480	{
2205	for (; n < (unsigned int)i; n++)	2481	for (; n < (unsigned int)i; n++)
2206	{	2482	{
2207	XGetWindowAttributes (display->display, TermWin.parent[n], &wattr);	2483	XGetWindowAttributes (display->display, TermWin.parent[n], &wattr);
2208	D_X ((stderr, "InheritPixmap Checking Parent[%d]: %s", n, (wattr.depth == rootdepth && wattr.class != InputOnly) ? "OK" : "FAIL"));
2209	if (wattr.depth != rootdepth || wattr.c_class == InputOnly)	2484	if (wattr.depth != rootdepth || wattr.c_class == InputOnly)
2210	{	2485	{
2211	n = (int) (sizeof (TermWin.parent) / sizeof (Window)) + 1;	2486	n = (int) (sizeof (TermWin.parent) / sizeof (Window)) + 1;
2212	break;	2487	break;
2213	}	2488	}
2214	}	2489	}
2215	}	2490	}
2216		2491
2217	if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0])))	2492	if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0])))
2218	{	2493	{
2219	D_X ((stderr, "InheritPixmap Turning off"));
2220	XSetWindowBackground (display->display, TermWin.parent[0], PixColorsFocused[Color_fg]);	2494	XSetWindowBackground (display->display, TermWin.parent[0], pix_colors_focused[Color_fg]);
2221	XSetWindowBackground (display->display, TermWin.vt, PixColorsFocused[Color_bg]);	2495	XSetWindowBackground (display->display, TermWin.vt, pix_colors_focused[Color_bg]);
2222	am_transparent = 0;	2496	am_transparent = 0;
2223	/* XXX: also turn off Opt_transparent? */	2497	/* XXX: also turn off Opt_transparent? */
2224	}	2498	}
2225	else	2499	else
2226	{	2500	{
2227	#if WAIT_FOR_WM	2501	#if WAIT_FOR_WM
2228	/* wait (an arbitrary period) for the WM to do its thing	2502	/* wait (an arbitrary period) for the WM to do its thing
2229	* needed for fvwm2.2.2 (and before?) */	2503	* needed for fvwm2.2.2 (and before?) */
2230	sleep (1);	2504	sleep (1);
2231	#endif	2505	#endif
2232	D_X ((stderr, "InheritPixmap Turning on (%d parents)", i - 1));
2233	for (n = 0; n < (unsigned int)i; n++)	2506	for (n = 0; n < (unsigned int)i; n++)
2234	{	2507	{
2235	XSetWindowBackgroundPixmap (display->display, TermWin.parent[n], ParentRelative);	2508	XSetWindowBackgroundPixmap (display->display, TermWin.parent[n], ParentRelative);
2236	XClearWindow (display->display, TermWin.parent[n]);	2509	XClearWindow (display->display, TermWin.parent[n]);
2237	}	2510	}
…		…
2277	if (ch == NOCHAR) // TODO: improve	2550	if (ch == NOCHAR) // TODO: improve
2278	break;	2551	break;
2279		2552
2280	if (!IS_CONTROL (ch) || ch == C0_LF || ch == C0_CR || ch == C0_HT)	2553	if (!IS_CONTROL (ch) || ch == C0_LF || ch == C0_CR || ch == C0_HT)
2281	{	2554	{
		2555	if (!seen_input)
		2556	{
		2557	seen_input = 1;
		2558	// many badly-written programs (e.g. jed) contain a race condition:
		2559	// they first read the screensize and then install a SIGWINCH handler.
		2560	// some window managers resize the window early, and these programs
		2561	// then sometimes get the size wrong.
		2562	kill (-cmd_pid, SIGWINCH);
		2563	}
		2564
2282	/* Read a text string from the input buffer */	2565	/* Read a text string from the input buffer */
2283	unicode_t buf[UBUFSIZ];	2566	unicode_t buf[UBUFSIZ];
2284	bool refreshnow = false;	2567	bool refreshnow = false;
2285	int nlines = 0;	2568	int nlines = 0;
2286	unicode_t *str = buf;	2569	unicode_t *str = buf;
2287		2570
2288	*str++ = ch;
2289
2290	for (;;)	2571	for (;;)
2291	{	2572	{
2292	seq_begin = cmdbuf_ptr;
2293	ch = next_char ();
2294
2295	if (ch == NOCHAR || (IS_CONTROL (ch) && ch != C0_LF && ch != C0_CR && ch != C0_HT))	2573	if (ch == NOCHAR || (IS_CONTROL (ch) && ch != C0_LF && ch != C0_CR && ch != C0_HT))
2296	break;	2574	break;
2297		2575
2298	*str++ = ch;	2576	*str++ = ch;
2299		2577
2300	if (ch == C0_LF)	2578	if (ch == C0_LF)
2301	{	2579	{
2302	nlines++;	2580	nlines++;
2303	refresh_count++;	2581	refresh_count++;
2304		2582
2305	if (! (Options & Opt_jumpScroll)	2583	if (!(options & Opt_jumpScroll)
2306	|| (refresh_count >= refresh_limit * (TermWin.nrow - 1)))	2584	|| (refresh_count >= refresh_limit * (TermWin.nrow - 1)))
2307	{	2585	{
2308	refreshnow = true;	2586	refreshnow = true;
2309	ch = NOCHAR;	2587	ch = NOCHAR;
2310	break;	2588	break;
2311	}	2589	}
2312		2590
2313	// scr_add_lines only works for nlines < TermWin.nrow - 1.	2591	// scr_add_lines only works for nlines <= TermWin.nrow - 1.
2314	if (nlines >= TermWin.nrow - 1)	2592	if (nlines >= TermWin.nrow - 1)
2315	{	2593	{
2316	scr_add_lines (buf, nlines, str - buf);	2594	scr_add_lines (buf, nlines, str - buf);
2317	nlines = 0;	2595	nlines = 0;
2318	str = buf;	2596	str = buf;
…		…
2322	if (str >= buf + UBUFSIZ)	2600	if (str >= buf + UBUFSIZ)
2323	{	2601	{
2324	ch = NOCHAR;	2602	ch = NOCHAR;
2325	break;	2603	break;
2326	}	2604	}
		2605
		2606	seq_begin = cmdbuf_ptr;
		2607	ch = next_char ();
2327	}	2608	}
2328		2609
2329	scr_add_lines (buf, nlines, str - buf);	2610	scr_add_lines (buf, nlines, str - buf);
2330		2611
2331	/*	2612	/*
…		…
2334	* the number of pages between refreshes is refresh_limit, which	2615	* the number of pages between refreshes is refresh_limit, which
2335	* is incremented here because we must be doing flat-out scrolling.	2616	* is incremented here because we must be doing flat-out scrolling.
2336	*/	2617	*/
2337	if (refreshnow)	2618	if (refreshnow)
2338	{	2619	{
2339	if ((Options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)	2620	if ((options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)
2340	refresh_limit++;	2621	refresh_limit++;
2341	else	2622	else
2342	{	2623	{
2343	flag = true;	2624	flag = true;
2344	scr_refresh (refresh_type);	2625	scr_refresh (refresh_type);
…		…
2534	process_escape_seq ();	2815	process_escape_seq ();
2535	break;	2816	break;
2536	case C0_ENQ: /* terminal Status */	2817	case C0_ENQ: /* terminal Status */
2537	if (rs[Rs_answerbackstring])	2818	if (rs[Rs_answerbackstring])
2538	tt_write ((const unsigned char *)rs[Rs_answerbackstring],	2819	tt_write ((const unsigned char *)rs[Rs_answerbackstring],
2539	(unsigned int)STRLEN (rs[Rs_answerbackstring]));	2820	(unsigned int)strlen (rs[Rs_answerbackstring]));
2540	else	2821	else
2541	tt_write ((unsigned char *)VT100_ANS,	2822	tt_write ((unsigned char *)VT100_ANS,
2542	(unsigned int)STRLEN (VT100_ANS));	2823	(unsigned int)strlen (VT100_ANS));
2543	break;	2824	break;
2544	case C0_BEL: /* bell */	2825	case C0_BEL: /* bell */
2545	scr_bell ();	2826	scr_bell ();
2546	break;	2827	break;
2547	case C0_BS: /* backspace */	2828	case C0_BS: /* backspace */
…		…
2646	void	2927	void
2647	rxvt_term::process_escape_seq ()	2928	rxvt_term::process_escape_seq ()
2648	{	2929	{
2649	unicode_t ch = cmd_getc ();	2930	unicode_t ch = cmd_getc ();
2650		2931
2651	if (PrivateModes & PrivMode_vt52)	2932	if (priv_modes & PrivMode_vt52)
2652	{	2933	{
2653	process_escape_vt52 (ch);	2934	process_escape_vt52 (ch);
2654	return;	2935	return;
2655	}	2936	}
2656		2937
…		…
2671	scr_charset_set (2, (unsigned int)cmd_getc ());	2952	scr_charset_set (2, (unsigned int)cmd_getc ());
2672	break;	2953	break;
2673	case '+':	2954	case '+':
2674	scr_charset_set (3, (unsigned int)cmd_getc ());	2955	scr_charset_set (3, (unsigned int)cmd_getc ());
2675	break;	2956	break;
2676	#ifndef NO_FRILLS	2957	#if ENABLE_FRILLS
2677	case '6':	2958	case '6':
2678	scr_backindex ();	2959	scr_backindex ();
2679	break;	2960	break;
2680	#endif	2961	#endif
2681	case '7':	2962	case '7':
2682	scr_cursor (SAVE);	2963	scr_cursor (SAVE);
2683	break;	2964	break;
2684	case '8':	2965	case '8':
2685	scr_cursor (RESTORE);	2966	scr_cursor (RESTORE);
2686	break;	2967	break;
2687	#ifndef NO_FRILLS	2968	#if ENABLE_FRILLS
2688	case '9':	2969	case '9':
2689	scr_forwardindex ();	2970	scr_forwardindex ();
2690	break;	2971	break;
2691	#endif	2972	#endif
2692	case '=':	2973	case '=':
…		…
2991	scr_scroll_text (screen.tscroll, screen.bscroll, arg[0], 0);	3272	scr_scroll_text (screen.tscroll, screen.bscroll, arg[0], 0);
2992	break;	3273	break;
2993		3274
2994	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */	3275	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */
2995	tt_write ((const unsigned char *)VT100_ANS,	3276	tt_write ((const unsigned char *)VT100_ANS,
2996	(unsigned int) (sizeof (VT100_ANS) - 1));	3277	(unsigned int) (sizeof (VT100_ANS) - 1));
2997	break;	3278	break;
2998		3279
2999	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */	3280	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */
3000	process_sgr_mode (nargs, arg);	3281	process_sgr_mode (nargs, arg);
3001	break;	3282	break;
…		…
3008	break;	3289	break;
3009	case 6: /* CPR requested */	3290	case 6: /* CPR requested */
3010	scr_report_position ();	3291	scr_report_position ();
3011	break;	3292	break;
3012	case 7: /* unofficial extension */	3293	case 7: /* unofficial extension */
3013	if (Options & Opt_insecure)	3294	if (options & Opt_insecure)
3014	tt_printf ("%-.250s\n", rs[Rs_display_name]);	3295	tt_printf ("%-.250s\012", rs[Rs_display_name]);
3015	break;	3296	break;
3016	case 8: /* unofficial extension */	3297	case 8: /* unofficial extension */
3017	process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);	3298	process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);
3018	break;	3299	break;
3019	}	3300	}
…		…
3055	break;	3336	break;
3056		3337
3057	case CSI_RM: /* 8.3.107: RESET MODE */	3338	case CSI_RM: /* 8.3.107: RESET MODE */
3058	if (arg[0] == 4)	3339	if (arg[0] == 4)
3059	scr_insert_mode (0);	3340	scr_insert_mode (0);
		3341	else if (arg[0] == 20)
		3342	priv_modes &= ~PrivMode_LFNL;
3060	break;	3343	break;
3061		3344
3062	case CSI_SM: /* 8.3.126: SET MODE */	3345	case CSI_SM: /* 8.3.126: SET MODE */
3063	if (arg[0] == 4)	3346	if (arg[0] == 4)
3064	scr_insert_mode (1);	3347	scr_insert_mode (1);
		3348	else if (arg[0] == 20)
		3349	priv_modes |= PrivMode_LFNL;
3065	break;	3350	break;
3066		3351
3067	/*	3352	/*
3068	* PRIVATE USE beyond this point. All CSI_7? sequences here	3353	* PRIVATE USE beyond this point. All CSI_7? sequences here
3069	*/	3354	*/
…		…
3081	break;	3366	break;
3082	case CSI_75:	3367	case CSI_75:
3083	scr_cursor (RESTORE);	3368	scr_cursor (RESTORE);
3084	break;	3369	break;
3085		3370
3086	#ifndef NO_FRILLS	3371	#if ENABLE_FRILLS
3087	case CSI_74:	3372	case CSI_74:
3088	process_window_ops (arg, nargs);	3373	process_window_ops (arg, nargs);
3089	break;	3374	break;
3090	#endif	3375	#endif
3091		3376
…		…
3098	break;	3383	break;
3099	}	3384	}
3100	}	3385	}
3101	/*}}} */	3386	/*}}} */
3102		3387
3103	#ifndef NO_FRILLS	3388	#if ENABLE_FRILLS
3104	/* ARGSUSED */	3389	/* ARGSUSED */
3105	void	3390	void
3106	rxvt_term::process_window_ops (const int *args, unsigned int nargs)	3391	rxvt_term::process_window_ops (const int *args, unsigned int nargs)
3107	{	3392	{
3108	int x, y;	3393	int x, y;
…		…
3175	break;	3460	break;
3176	case 19: /* report window size (chars) */	3461	case 19: /* report window size (chars) */
3177	tt_printf ("\033[9;%d;%dt", TermWin.nrow, TermWin.ncol);	3462	tt_printf ("\033[9;%d;%dt", TermWin.nrow, TermWin.ncol);
3178	break;	3463	break;
3179	case 20: /* report icon label */	3464	case 20: /* report icon label */
3180	if (Options & Opt_insecure)
3181	{	3465	{
3182	char *s;	3466	char *s;
3183	XGetIconName (display->display, TermWin.parent[0], &s);	3467	XGetIconName (display->display, TermWin.parent[0], &s);
3184	tt_printf ("\033]L%-.200s\234", s ? s : ""); /* 8bit ST */	3468	tt_printf ("\033]L%-.250s\234", (options & Opt_insecure) && s ? s : ""); /* 8bit ST */
		3469	XFree (s);
3185	}	3470	}
3186	break;	3471	break;
3187	case 21: /* report window title */	3472	case 21: /* report window title */
3188	if (Options & Opt_insecure)
3189	{	3473	{
3190	char *s;	3474	char *s;
3191	XFetchName (display->display, TermWin.parent[0], &s);	3475	XFetchName (display->display, TermWin.parent[0], &s);
3192	tt_printf ("\033]l%-.200s\234", s ? s : ""); /* 8bit ST */	3476	tt_printf ("\033]l%-.250s\234", (options & Opt_insecure) && s ? s : ""); /* 8bit ST */
		3477	XFree (s);
3193	}	3478	}
3194	break;	3479	break;
3195	}	3480	}
3196	}	3481	}
3197	#endif	3482	#endif
3198		3483
…		…
3240		3525
3241	if ((s = (unsigned char *)rxvt_malloc (n)) == NULL)	3526	if ((s = (unsigned char *)rxvt_malloc (n)) == NULL)
3242	return NULL;	3527	return NULL;
3243		3528
3244	ends_how = (ch == 0x5c ? C0_ESC : ch);	3529	ends_how = (ch == 0x5c ? C0_ESC : ch);
3245	STRNCPY (s, string, n);	3530	strncpy (s, string, n);
3246	return s;	3531	return s;
3247	}	3532	}
3248		3533
3249	/*----------------------------------------------------------------------*/	3534	/*----------------------------------------------------------------------*/
3250	/*	3535	/*
…		…
3295	void	3580	void
3296	rxvt_term::process_color_seq (int report, int color, const char *str, unsigned char resp)	3581	rxvt_term::process_color_seq (int report, int color, const char *str, unsigned char resp)
3297	{	3582	{
3298	if (str[0] == '?' && !str[1])	3583	if (str[0] == '?' && !str[1])
3299	{	3584	{
3300	if (Options & Opt_insecure)
3301	{
3302	unsigned short r, g, b;	3585	unsigned short r, g, b;
3303	PixColorsFocused[color].get (display, r, g, b);	3586	pix_colors_focused[color].get (display, r, g, b);
3304	tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, r, g, b, resp);	3587	tt_printf ("\033]%d;rgb:%04x/%04x/%04x%c", report, r, g, b, resp);
3305	}
3306	}	3588	}
3307	else	3589	else
3308	set_window_color (color, str);	3590	set_window_color (color, str);
3309	}	3591	}
3310		3592
…		…
3396	break;	3678	break;
3397		3679
3398	case XTerm_Color:	3680	case XTerm_Color:
3399	for (buf = (char *)str; buf && *buf;)	3681	for (buf = (char *)str; buf && *buf;)
3400	{	3682	{
3401	if ((name = STRCHR (buf, ';')) == NULL)	3683	if ((name = strchr (buf, ';')) == NULL)
3402	break;	3684	break;
3403		3685
3404	*name++ = '\0';	3686	*name++ = '\0';
3405	color = atoi (buf);	3687	color = atoi (buf);
3406		3688
3407	if (color < 0 || color >= TOTAL_COLORS)	3689	if (color < 0 || color >= TOTAL_COLORS)
3408	break;	3690	break;
3409		3691
3410	if ((buf = STRCHR (name, ';')) != NULL)	3692	if ((buf = strchr (name, ';')) != NULL)
3411	*buf++ = '\0';	3693	*buf++ = '\0';
3412		3694
3413	if (name[0] == '?' && !name[1])	3695	if (name[0] == '?' && !name[1])
3414	{	3696	{
3415	if (Options & Opt_insecure)
3416	{
3417	unsigned short r, g, b;	3697	unsigned short r, g, b;
3418	PixColorsFocused[color + minCOLOR].get (display, r, g, b);	3698	pix_colors_focused[color + minCOLOR].get (display, r, g, b);
3419	tt_printf ("\033]%d;%d;rgb:%04x/%04x/%04x%c", XTerm_Color, color, r, g, b, resp);	3699	tt_printf ("\033]%d;%d;rgb:%04x/%04x/%04x%c", XTerm_Color, color, r, g, b, resp);
3420	}
3421	}	3700	}
3422	else	3701	else
3423	set_window_color (color + minCOLOR, name);	3702	set_window_color (color + minCOLOR, name);
3424	}	3703	}
3425	break;	3704	break;
…		…
3459	scale_pixmap (""); /* reset to default scaling */	3738	scale_pixmap (""); /* reset to default scaling */
3460	set_bgPixmap (str); /* change pixmap */	3739	set_bgPixmap (str); /* change pixmap */
3461	#endif	3740	#endif
3462	scr_touch (true);	3741	scr_touch (true);
3463	}	3742	}
3464	while ((str = STRCHR (str, ';')) != NULL)	3743	while ((str = strchr (str, ';')) != NULL)
3465	{	3744	{
3466	str++;	3745	str++;
3467	#if XPM_BACKGROUND	3746	#if XPM_BACKGROUND
3468	changed += scale_pixmap (str);	3747	changed += scale_pixmap (str);
3469	#endif	3748	#endif
…		…
3489	// TODO, when secure mode?	3768	// TODO, when secure mode?
3490	break;	3769	break;
3491		3770
3492	case XTerm_font:	3771	case XTerm_font:
3493	if (query)	3772	if (query)
3494	{
3495	if (Options & Opt_insecure)
3496	tt_printf ("\33]%d;%-.250s%c", XTerm_font,	3773	tt_printf ("\33]%d;%-.250s%c", XTerm_font,
		3774	(options & Opt_insecure) && TermWin.fontset->fontdesc
3497	TermWin.fontset->fontdesc	3775	? TermWin.fontset->fontdesc : "",
3498	? TermWin.fontset->fontdesc
3499	: "",
3500	resp);	3776	resp);
3501	}
3502	else	3777	else
3503	change_font (str);	3778	change_font (str);
3504	break;	3779	break;
3505		3780
3506	#ifndef NO_FRILLS	3781	#if ENABLE_FRILLS
3507	case XTerm_locale:	3782	case XTerm_locale:
3508	if (query)	3783	if (query)
3509	{
3510	if (Options & Opt_insecure)
3511	tt_printf ("\33]%d;%-.250s%c", XTerm_locale, locale, resp);	3784	tt_printf ("\33]%d;%-.250s%c", XTerm_locale, (options & Opt_insecure) ? locale : "", resp);
3512	}
3513	else	3785	else
3514	{	3786	{
3515	set_locale (str);	3787	set_locale (str);
3516	# ifdef USE_XIM	3788	# ifdef USE_XIM
3517	im_cb ();	3789	im_cb ();
3518	# endif	3790	# endif
3519	}	3791	}
3520	break;	3792	break;
3521		3793
3522	case XTerm_findfont:	3794	case XTerm_findfont:
3523	if (Options & Opt_insecure)
3524	{	3795	{
3525	int fid = TermWin.fontset->find_font (atoi (str));	3796	int fid = TermWin.fontset->find_font (atoi (str));
3526	tt_printf ("\33]%d;%d;%-.250s%c", XTerm_findfont,	3797	tt_printf ("\33]%d;%d;%-.250s%c", XTerm_findfont,
3527	fid, (*TermWin.fontset)[fid]->name, resp);	3798	fid,
		3799	(options & Opt_insecure) ? (*TermWin.fontset)[fid]->name : "",
		3800	resp);
3528	}	3801	}
3529	break;	3802	break;
3530	#endif	3803	#endif
3531		3804
3532	#ifdef MENUBAR	3805	#ifdef MENUBAR
3533	case XTerm_Menu:	3806	case XTerm_Menu:
3534	if (Options & Opt_insecure)	3807	if (options & Opt_insecure)
3535	menubar_dispatch (const_cast<char *>(str)); // casting away constness is checked	3808	menubar_dispatch (const_cast<char *>(str)); // casting away constness is checked
3536	break;	3809	break;
3537	#endif	3810	#endif
3538	#if 0	3811	#if 0
3539	case XTerm_dumpscreen: /* no error notices */	3812	case XTerm_dumpscreen: /* no error notices */
…		…
3566	{	3839	{
3567	int state;	3840	int state;
3568		3841
3569	if (mode == 's')	3842	if (mode == 's')
3570	{	3843	{
3571	SavedModes |= (PrivateModes & bit);	3844	SavedModes |= (priv_modes & bit);
3572	return -1;	3845	return -1;
3573	}	3846	}
3574	else	3847	else
3575	{	3848	{
3576	if (mode == 'r')	3849	if (mode == 'r')
3577	state = (SavedModes & bit) ? 1 : 0; /* no overlapping */	3850	state = (SavedModes & bit) ? 1 : 0; /* no overlapping */
3578	else	3851	else
3579	state = (mode == 't') ? ! (PrivateModes & bit) : mode;	3852	state = (mode == 't') ? ! (priv_modes & bit) : mode;
3580	PrivMode (state, bit);	3853	PrivMode (state, bit);
3581	}	3854	}
3582		3855
3583	return state;	3856	return state;
3584	}	3857	}
…		…
3602	{ 3, PrivMode_132 },	3875	{ 3, PrivMode_132 },
3603	{ 4, PrivMode_smoothScroll },	3876	{ 4, PrivMode_smoothScroll },
3604	{ 5, PrivMode_rVideo },	3877	{ 5, PrivMode_rVideo },
3605	{ 6, PrivMode_relOrigin },	3878	{ 6, PrivMode_relOrigin },
3606	{ 7, PrivMode_Autowrap },	3879	{ 7, PrivMode_Autowrap },
		3880	// 8, bi-directional support mode
3607	{ 9, PrivMode_MouseX10 },	3881	{ 9, PrivMode_MouseX10 },
3608	#ifdef menuBar_esc	3882	#ifdef menuBar_esc
3609	{ menuBar_esc, PrivMode_menuBar },	3883	{ menuBar_esc, PrivMode_menuBar },
3610	#endif	3884	#endif
		3885	// 18, 19 printing-related
		3886	{ 25, PrivMode_VisibleCursor },
3611	#ifdef scrollBar_esc	3887	#ifdef scrollBar_esc
3612	{ scrollBar_esc, PrivMode_scrollBar },	3888	{ scrollBar_esc, PrivMode_scrollBar },
3613	#endif	3889	#endif
3614	// 18, 19 printing-related
3615	{ 25, PrivMode_VisibleCursor },
3616	// 30 show scrollbar rxvt. extension
3617	{ 35, PrivMode_ShiftKeys }, // rxvt extension	3890	{ 35, PrivMode_ShiftKeys }, // rxvt extension
3618	{ 40, PrivMode_132OK },	3891	{ 40, PrivMode_132OK },
3619	// 41 xterm more fixes NYI	3892	// 41 xterm more fixes NYI
3620	// 45 margin bell NYI	3893	// 45 margin bell NYI
3621	// 46 start logging	3894	// 46 start logging
…		…
3662		3935
3663	/* extra handling for values with state unkept */	3936	/* extra handling for values with state unkept */
3664	switch (arg[i])	3937	switch (arg[i])
3665	{	3938	{
3666	case 1048: /* alternative cursor save */	3939	case 1048: /* alternative cursor save */
3667	if (Options & Opt_secondaryScreen)	3940	if (options & Opt_secondaryScreen)
3668	if (mode == 0)	3941	if (mode == 0)
3669	scr_cursor (RESTORE);	3942	scr_cursor (RESTORE);
3670	else if (mode == 1)	3943	else if (mode == 1)
3671	scr_cursor (SAVE);	3944	scr_cursor (SAVE);
3672	break;	3945	break;
…		…
3683	* within VT52 mode	3956	* within VT52 mode
3684	*/	3957	*/
3685	PrivMode (1, PrivMode_vt52);	3958	PrivMode (1, PrivMode_vt52);
3686	break;	3959	break;
3687	case 3: /* 80/132 */	3960	case 3: /* 80/132 */
3688	if (PrivateModes & PrivMode_132OK)	3961	if (priv_modes & PrivMode_132OK)
3689	set_widthheight (((state ? 132 : 80) * TermWin.fwidth), TermWin.height);	3962	set_widthheight (((state ? 132 : 80) * TermWin.fwidth), TermWin.height);
3690	break;	3963	break;
3691	case 4: /* smooth scrolling */	3964	case 4: /* smooth scrolling */
3692	if (state)	3965	if (state)
3693	Options &= ~Opt_jumpScroll;	3966	options &= ~Opt_jumpScroll;
3694	else	3967	else
3695	Options |= Opt_jumpScroll;	3968	options |= Opt_jumpScroll;
3696	break;	3969	break;
3697	case 5: /* reverse video */	3970	case 5: /* reverse video */
3698	scr_rvideo_mode (state);	3971	scr_rvideo_mode (state);
3699	break;	3972	break;
3700	case 6: /* relative/absolute origins */	3973	case 6: /* relative/absolute origins */
…		…
3704	scr_autowrap (state);	3977	scr_autowrap (state);
3705	break;	3978	break;
3706	/* case 8: - auto repeat, can't do on a per window basis */	3979	/* case 8: - auto repeat, can't do on a per window basis */
3707	case 9: /* X10 mouse reporting */	3980	case 9: /* X10 mouse reporting */
3708	if (state) /* orthogonal */	3981	if (state) /* orthogonal */
3709	PrivateModes &= ~PrivMode_MouseX11;	3982	priv_modes &= ~PrivMode_MouseX11;
3710	break;	3983	break;
3711	#ifdef menuBar_esc	3984	#ifdef menuBar_esc
3712	case menuBar_esc:	3985	case menuBar_esc:
3713	#ifdef MENUBAR	3986	#ifdef MENUBAR
3714	map_menuBar (state);	3987	map_menuBar (state);
…		…
3734	break;	4007	break;
3735	/* case 66: - application key pad */	4008	/* case 66: - application key pad */
3736	/* case 67: - backspace key */	4009	/* case 67: - backspace key */
3737	case 1000: /* X11 mouse reporting */	4010	case 1000: /* X11 mouse reporting */
3738	if (state) /* orthogonal */	4011	if (state) /* orthogonal */
3739	PrivateModes &= ~PrivMode_MouseX10;	4012	priv_modes &= ~PrivMode_MouseX10;
3740	break;	4013	break;
3741	#if 0	4014	#if 0
3742	case 1001:	4015	case 1001:
3743	break; /* X11 mouse highlighting */	4016	break; /* X11 mouse highlighting */
3744	#endif	4017	#endif
3745	case 1010: /* scroll to bottom on TTY output inhibit */	4018	case 1010: /* scroll to bottom on TTY output inhibit */
3746	if (state)	4019	if (state)
3747	Options &= ~Opt_scrollTtyOutput;	4020	options &= ~Opt_scrollTtyOutput;
3748	else	4021	else
3749	Options |= Opt_scrollTtyOutput;	4022	options |= Opt_scrollTtyOutput;
3750	break;	4023	break;
3751	case 1011: /* scroll to bottom on key press */	4024	case 1011: /* scroll to bottom on key press */
3752	if (state)	4025	if (state)
3753	Options |= Opt_scrollTtyKeypress;	4026	options |= Opt_scrollTtyKeypress;
3754	else	4027	else
3755	Options &= ~Opt_scrollTtyKeypress;	4028	options &= ~Opt_scrollTtyKeypress;
3756	break;	4029	break;
3757	case 1047: /* secondary screen w/ clearing last */	4030	case 1047: /* secondary screen w/ clearing last */
3758	if (Options & Opt_secondaryScreen)	4031	if (options & Opt_secondaryScreen)
3759	if (current_screen != PRIMARY)	4032	if (current_screen != PRIMARY)
3760	scr_erase_screen (2);	4033	scr_erase_screen (2);
3761	scr_change_screen (state);	4034	scr_change_screen (state);
3762	break;	4035	break;
3763	case 1049: /* secondary screen w/ clearing first */	4036	case 1049: /* secondary screen w/ clearing first */
3764	scr_change_screen (state);	4037	scr_change_screen (state);
3765	if (Options & Opt_secondaryScreen)	4038	if (options & Opt_secondaryScreen)
3766	if (current_screen != PRIMARY)	4039	if (current_screen != PRIMARY)
3767	scr_erase_screen (2);	4040	scr_erase_screen (2);
3768	break;	4041	break;
3769	default:	4042	default:
3770	break;	4043	break;
…		…
3797	break;	4070	break;
3798	case 1:	4071	case 1:
3799	rendset = 1, rendstyle = RS_Bold;	4072	rendset = 1, rendstyle = RS_Bold;
3800	break;	4073	break;
3801	//case 2: // faint or second colour	4074	//case 2: // faint or second colour
		4075	//case 3: // italic
3802	case 4:	4076	case 4:
3803	rendset = 1, rendstyle = RS_Uline;	4077	rendset = 1, rendstyle = RS_Uline;
3804	break;	4078	break;
3805	case 5: // slowly blinking	4079	case 5: // slowly blinking
3806	case 6: // rapidly blinking	4080	case 6: // rapidly blinking
…		…
3831	rendset = 0, rendstyle = RS_Uline;	4105	rendset = 0, rendstyle = RS_Uline;
3832	break;	4106	break;
3833	case 25:	4107	case 25:
3834	rendset = 0, rendstyle = RS_Blink;	4108	rendset = 0, rendstyle = RS_Blink;
3835	break;	4109	break;
		4110	case 26:
		4111	rendset = 0, rendstyle = RS_Blink;
		4112	break;
3836	case 27:	4113	case 27:
3837	rendset = 0, rendstyle = RS_RVid;	4114	rendset = 0, rendstyle = RS_RVid;
3838	break;	4115	break;
3839	//case 28: // visible. NYI	4116	//case 28: // visible. NYI
3840	//case 29: // not crossed-out	4117	//case 29: // not crossed-out
…		…
3930	{	4207	{
3931	unicode_t ch, cmd = cmd_getc ();	4208	unicode_t ch, cmd = cmd_getc ();
3932		4209
3933	if (cmd == 'Q')	4210	if (cmd == 'Q')
3934	{ /* query graphics */	4211	{ /* query graphics */
3935	tt_printf ("\033G0\n"); /* no graphics */	4212	tt_printf ("\033G0\012"); /* no graphics */
3936	return;	4213	return;
3937	}	4214	}
3938	/* swallow other graphics sequences until terminating ':' */	4215	/* swallow other graphics sequences until terminating ':' */
3939	do	4216	do
3940	ch = cmd_getc ();	4217	ch = cmd_getc ();
…		…
3955	unsigned char buf[256];	4232	unsigned char buf[256];
3956		4233
3957	va_start (arg_ptr, fmt);	4234	va_start (arg_ptr, fmt);
3958	vsnprintf ((char *)buf, 256, fmt, arg_ptr);	4235	vsnprintf ((char *)buf, 256, fmt, arg_ptr);
3959	va_end (arg_ptr);	4236	va_end (arg_ptr);
3960	tt_write (buf, STRLEN (buf));	4237	tt_write (buf, strlen (buf));
3961	}	4238	}
3962		4239
3963	/* ---------------------------------------------------------------------- */	4240	/* ---------------------------------------------------------------------- */
3964	/* Write data to the pty as typed by the user, pasted with the mouse,	4241	/* Write data to the pty as typed by the user, pasted with the mouse,
3965	* or generated by us in response to a query ESC sequence.	4242	* or generated by us in response to a query ESC sequence.
…		…
3971		4248
3972	if (len)	4249	if (len)
3973	{	4250	{
3974	if (v_buflen == 0)	4251	if (v_buflen == 0)
3975	{	4252	{
3976	ssize_t written = write (cmd_fd, data, min (MAX_PTY_WRITE, len));	4253	ssize_t written = write (pty.pty, data, min (len, MAX_PTY_WRITE));
3977		4254
3978	if ((unsigned int)written == len)	4255	if ((unsigned int)written == len)
3979	return;	4256	return;
3980		4257
3981	data += written;	4258	data += written;
…		…
3989	v_buflen += len;	4266	v_buflen += len;
3990	}	4267	}
3991		4268
3992	for (;;)	4269	for (;;)
3993	{	4270	{
3994	int written = write (cmd_fd, v_buffer, min (MAX_PTY_WRITE, v_buflen));	4271	int written = write (pty.pty, v_buffer, min (MAX_PTY_WRITE, v_buflen));
3995		4272
3996	if (written > 0)	4273	if (written > 0)
3997	{	4274	{
3998	v_buflen -= written;	4275	v_buflen -= written;
3999		4276

Diff Legend

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