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.120 by root, Tue Aug 10 22:36:30 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;
…		…
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	}
…		…
783		1027
784	memmove (cmdbuf_base, cmdbuf_ptr, n);	1028	memmove (cmdbuf_base, cmdbuf_ptr, n);
785	cmdbuf_ptr = cmdbuf_base;	1029	cmdbuf_ptr = cmdbuf_base;
786	cmdbuf_endp = cmdbuf_ptr + n;	1030	cmdbuf_endp = cmdbuf_ptr + n;
787		1031
788	n = read (cmd_fd, cmdbuf_endp, CBUFSIZ - n);	1032	n = read (pty.pty, cmdbuf_endp, CBUFSIZ - n);
789		1033
790	if (n > 0)	1034	if (n > 0)
791	{	1035	{
792	cmdbuf_endp += n;	1036	cmdbuf_endp += n;
793	return true;	1037	return true;
…		…
820	recolour_cursor ();	1064	recolour_cursor ();
821		1065
822	#ifdef POINTER_BLANK	1066	#ifdef POINTER_BLANK
823	hidden_pointer = 0;	1067	hidden_pointer = 0;
824		1068
825	if (Options & Opt_pointerBlank)	1069	if (options & Opt_pointerBlank)
826	pointer_ev.start (NOW + pointerBlankDelay);	1070	pointer_ev.start (NOW + pointerBlankDelay);
827	#endif	1071	#endif
828	}	1072	}
829		1073
830	#ifdef POINTER_BLANK	1074	#ifdef POINTER_BLANK
831	void	1075	void
832	rxvt_term::pointer_blank ()	1076	rxvt_term::pointer_blank ()
833	{	1077	{
834	if (! (Options & Opt_pointerBlank))	1078	if (! (options & Opt_pointerBlank))
835	return;	1079	return;
836		1080
837	XDefineCursor (display->display, TermWin.vt, blank_cursor);	1081	XDefineCursor (display->display, TermWin.vt, blank_cursor);
838	XFlush (display->display);	1082	XFlush (display->display);
839		1083
…		…
859	x = ev.x;	1103	x = ev.x;
860	y = ev.y;	1104	y = ev.y;
861	pixel_position (&x, &y);	1105	pixel_position (&x, &y);
862		1106
863	if (MEvent.button == AnyButton)	1107	if (MEvent.button == AnyButton)
864	{
865	button_number = 3;	1108	button_number = 3;
866	}
867	else	1109	else
868	{	1110	{
869	button_number = MEvent.button - Button1;	1111	button_number = MEvent.button - Button1;
870	/* add 0x3D for wheel events, like xterm does */	1112	/* add 0x3D for wheel events, like xterm does */
871	if (button_number >= 3)	1113	if (button_number >= 3)
872	button_number += (64 - 3);	1114	button_number += (64 - 3);
873	}	1115	}
874		1116
875	if (PrivateModes & PrivMode_MouseX10)	1117	if (priv_modes & PrivMode_MouseX10)
876	{	1118	{
877	/*	1119	/*
878	* do not report ButtonRelease	1120	* do not report ButtonRelease
879	* no state info allowed	1121	* no state info allowed
880	*/	1122	*/
…		…
938	{	1180	{
939	SET_R (this);	1181	SET_R (this);
940	SET_LOCALE (locale);	1182	SET_LOCALE (locale);
941		1183
942	#if defined(CURSOR_BLINK)	1184	#if defined(CURSOR_BLINK)
943	if ((Options & Opt_cursorBlink) && ev.type == KeyPress)	1185	if ((options & Opt_cursorBlink) && ev.type == KeyPress)
944	{	1186	{
945	if (hidden_cursor)	1187	if (hidden_cursor)
946	{	1188	{
947	hidden_cursor = 0;	1189	hidden_cursor = 0;
948	want_refresh = 1;	1190	want_refresh = 1;
…		…
951	cursor_blink_ev.start (NOW + BLINK_INTERVAL);	1193	cursor_blink_ev.start (NOW + BLINK_INTERVAL);
952	}	1194	}
953	#endif	1195	#endif
954		1196
955	#if defined(POINTER_BLANK)	1197	#if defined(POINTER_BLANK)
956	if ((Options & Opt_pointerBlank) && pointerBlankDelay > 0)	1198	if ((options & Opt_pointerBlank) && pointerBlankDelay > 0)
957	{	1199	{
958	if (ev.type == MotionNotify	1200	if (ev.type == MotionNotify
959	|| ev.type == ButtonPress	1201	|| ev.type == ButtonPress
960	|| ev.type == ButtonRelease)	1202	|| ev.type == ButtonRelease)
961	if (hidden_pointer)	1203	if (hidden_pointer)
…		…
973		1215
974	Window unused_root, unused_child;	1216	Window unused_root, unused_child;
975	int unused_root_x, unused_root_y;	1217	int unused_root_x, unused_root_y;
976	unsigned int unused_mask;	1218	unsigned int unused_mask;
977		1219
978	#ifdef DEBUG_X
979	const char *const eventnames[] =
980	{ /* mason - this matches my system */
981	"",
982	"",
983	"KeyPress",
984	"KeyRelease",
985	"ButtonPress",
986	"ButtonRelease",
987	"MotionNotify",
988	"EnterNotify",
989	"LeaveNotify",
990	"FocusIn",
991	"FocusOut",
992	"KeymapNotify",
993	"Expose",
994	"GraphicsExpose",
995	"NoExpose",
996	"VisibilityNotify",
997	"CreateNotify",
998	"DestroyNotify",
999	"UnmapNotify",
1000	"MapNotify",
1001	"MapRequest",
1002	"ReparentNotify",
1003	"ConfigureNotify",
1004	"ConfigureRequest",
1005	"GravityNotify",
1006	"ResizeRequest",
1007	"CirculateNotify",
1008	"CirculateRequest",
1009	"PropertyNotify",
1010	"SelectionClear",
1011	"SelectionRequest",
1012	"SelectionNotify",
1013	"ColormapNotify",
1014	"ClientMessage",
1015	"MappingNotify"
1016	};
1017	#endif
1018
1019	#ifdef DEBUG_X
1020	struct timeval tp;
1021	struct tm *ltt;
1022	(void)gettimeofday (&tp, NULL);
1023	ltt = localtime (& (tp.tv_sec));
1024	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));
1025	#endif
1026
1027	switch (ev.type)	1220	switch (ev.type)
1028	{	1221	{
1029	case KeyPress:	1222	case KeyPress:
		1223	#if ISO_14755
		1224	if (!(iso14755buf & ISO_14755_52))
		1225	#endif
1030	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;
1031	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
1032		1291
1033	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)	1292	#if defined(MOUSE_WHEEL) && defined(MOUSE_SLIP_WHEELING)
1034	case KeyRelease:
1035	{
1036	if (!(ev.xkey.state & ControlMask))	1293	if (!(ev.xkey.state & ControlMask))
1037	slip_wheel_ev.stop ();	1294	slip_wheel_ev.stop ();
1038	else
1039	{
1040	KeySym ks;
1041
1042	ks = XKeycodeToKeysym (display->display, ev.xkey.keycode, 0);
1043	if (ks == XK_Control_L || ks == XK_Control_R)	1295	else if (ks == XK_Control_L || ks == XK_Control_R)
1044	mouse_slip_wheel_speed = 0;	1296	mouse_slip_wheel_speed = 0;
1045	}	1297	#endif
1046	break;	1298	break;
1047	}	1299	}
1048	#endif
1049		1300
1050	case ButtonPress:	1301	case ButtonPress:
1051	button_press (ev.xbutton);	1302	button_press (ev.xbutton);
1052	break;	1303	break;
1053		1304
…		…
1080	&Size, &RemainingBytes,	1331	&Size, &RemainingBytes,
1081	&data);	1332	&data);
1082	XChangeProperty (display->display, display->root,	1333	XChangeProperty (display->display, display->root,
1083	XA_CUT_BUFFER0, XA_STRING,	1334	XA_CUT_BUFFER0, XA_STRING,
1084	8, PropModeReplace,	1335	8, PropModeReplace,
1085	data, STRLEN (data));	1336	data, strlen (data));
1086	XFree (data);	1337	XFree (data);
1087	selection_paste (display->root, XA_CUT_BUFFER0, True);	1338	selection_paste (display->root, XA_CUT_BUFFER0, True);
1088	XSetInputFocus (display->display, display->root, RevertToNone, CurrentTime);	1339	XSetInputFocus (display->display, display->root, RevertToNone, CurrentTime);
1089	}	1340	}
1090	#endif /* OFFIX_DND */	1341	#endif /* OFFIX_DND */
…		…
1124	{	1375	{
1125	TermWin.focus = 1;	1376	TermWin.focus = 1;
1126	want_refresh = 1;	1377	want_refresh = 1;
1127	#ifdef USE_XIM	1378	#ifdef USE_XIM
1128	if (Input_Context != NULL)	1379	if (Input_Context != NULL)
		1380	{
		1381	IMSetStatusPosition ();
1129	XSetICFocus (Input_Context);	1382	XSetICFocus (Input_Context);
		1383	}
1130	#endif	1384	#endif
1131	#ifdef CURSOR_BLINK	1385	#ifdef CURSOR_BLINK
1132	if (Options & Opt_cursorBlink)	1386	if (options & Opt_cursorBlink)
1133	cursor_blink_ev.start (NOW + BLINK_INTERVAL);	1387	cursor_blink_ev.start (NOW + BLINK_INTERVAL);
1134	#endif	1388	#endif
1135	#ifdef OFF_FOCUS_FADING	1389	#ifdef OFF_FOCUS_FADING
1136	if (rs[Rs_fade])	1390	if (rs[Rs_fade])
1137	{	1391	{
1138	PixColors = PixColorsFocused;	1392	pix_colors = pix_colors_focused;
1139	set_colorfgbg ();	1393	set_colorfgbg ();
1140	scr_clear ();	1394	scr_clear ();
1141	scr_touch (true);	1395	scr_touch (true);
1142	}	1396	}
1143	#endif	1397	#endif
…		…
1153	#ifdef USE_XIM	1407	#ifdef USE_XIM
1154	if (Input_Context != NULL)	1408	if (Input_Context != NULL)
1155	XUnsetICFocus (Input_Context);	1409	XUnsetICFocus (Input_Context);
1156	#endif	1410	#endif
1157	#ifdef CURSOR_BLINK	1411	#ifdef CURSOR_BLINK
1158	if (Options & Opt_cursorBlink)	1412	if (options & Opt_cursorBlink)
1159	cursor_blink_ev.stop ();	1413	cursor_blink_ev.stop ();
1160	hidden_cursor = 0;	1414	hidden_cursor = 0;
1161	#endif	1415	#endif
1162	#ifdef OFF_FOCUS_FADING	1416	#ifdef OFF_FOCUS_FADING
1163	if (rs[Rs_fade])	1417	if (rs[Rs_fade])
1164	{	1418	{
1165	PixColors = PixColorsUnFocused;	1419	pix_colors = pix_colors_unfocused;
1166	set_colorfgbg ();	1420	set_colorfgbg ();
1167	scr_clear ();	1421	scr_clear ();
1168	scr_touch (true);	1422	scr_touch (true);
1169	}	1423	}
1170	#endif	1424	#endif
…		…
1187		1441
1188	if (szHint.width != width || szHint.height != height)	1442	if (szHint.width != width || szHint.height != height)
1189	resize_all_windows (width, height, 1);	1443	resize_all_windows (width, height, 1);
1190		1444
1191	#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */	1445	#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */
1192	if (Options & Opt_transparent)	1446	if (options & Opt_transparent)
1193	{	1447	{
1194	check_our_parents ();	1448	check_our_parents ();
1195	if (am_transparent)	1449	if (am_transparent)
1196	want_refresh = want_full_refresh = 1;	1450	want_refresh = want_full_refresh = 1;
1197	}	1451	}
1198	#endif	1452	#endif
1199	}	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
1200	break;	1461	break;
1201		1462
1202	case SelectionClear:	1463	case SelectionClear:
1203	selection_clear ();	1464	selection_clear ();
1204	break;	1465	break;
…		…
1286	{	1547	{
1287	menubar_control (ev.xbutton);	1548	menubar_control (ev.xbutton);
1288	break;	1549	break;
1289	}	1550	}
1290	#endif	1551	#endif
1291	if ((PrivateModes & PrivMode_mouse_report) && ! (bypass_keystate))	1552	if ((priv_modes & PrivMode_mouse_report) && ! (bypass_keystate))
1292	break;	1553	break;
1293		1554
1294	if (ev.xany.window == TermWin.vt)	1555	if (ev.xany.window == TermWin.vt)
1295	{	1556	{
1296	if ((ev.xbutton.state & (Button1Mask | Button3Mask)))	1557	if (ev.xbutton.state & (Button1Mask | Button3Mask))
1297	{	1558	{
1298	while (XCheckTypedWindowEvent (display->display, TermWin.vt, MotionNotify, &ev))	1559	while (XCheckTypedWindowEvent (display->display, TermWin.vt, MotionNotify, &ev))
1299	;	1560	;
1300		1561
1301	XQueryPointer (display->display, TermWin.vt,	1562	XQueryPointer (display->display, TermWin.vt,
1302	&unused_root, &unused_child,	1563	&unused_root, &unused_child,
1303	&unused_root_x, &unused_root_y,	1564	&unused_root_x, &unused_root_y,
1304	& (ev.xbutton.x), & (ev.xbutton.y),	1565	& (ev.xbutton.x), & (ev.xbutton.y),
1305	&unused_mask);	1566	&unused_mask);
1306	#ifdef MOUSE_THRESHOLD	1567	#ifdef MOUSE_THRESHOLD
1307	/* deal with a `jumpy' mouse */	1568	/* deal with a `jumpy' mouse */
1308	if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)	1569	if ((ev.xmotion.time - MEvent.time) > MOUSE_THRESHOLD)
1309	{	1570	{
1310	#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
1311	selection_extend ((ev.xbutton.x), (ev.xbutton.y),	1580	selection_extend (ev.xbutton.x, ev.xbutton.y,
1312	(ev.xbutton.state & Button3Mask) ? 2 : 0);	1581	(ev.xbutton.state & Button3Mask) ? 2 : 0);
1313	#ifdef SELECTION_SCROLLING	1582	#ifdef SELECTION_SCROLLING
1314	if (ev.xbutton.y < TermWin.int_bwidth	1583	if (ev.xbutton.y < TermWin.int_bwidth
1315	|| Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))	1584	|| Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))
1316	{	1585	{
…		…
1323	sel_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);	1592	sel_scroll_ev.start (NOW + SCROLLBAR_INITIAL_DELAY);
1324		1593
1325	/* save the event params so we can highlight	1594	/* save the event params so we can highlight
1326	* the selection in the pending-scroll loop	1595	* the selection in the pending-scroll loop
1327	*/	1596	*/
1328	selection_save_x=ev.xbutton.x;	1597	selection_save_x = ev.xbutton.x;
1329	selection_save_y=ev.xbutton.y;	1598	selection_save_y = ev.xbutton.y;
1330	selection_save_state=
1331	(ev.xbutton.state & Button3Mask) ? 2 : 0;	1599	selection_save_state = (ev.xbutton.state & Button3Mask) ? 2 : 0;
1332		1600
1333	/* calc number of lines to scroll */	1601	/* calc number of lines to scroll */
1334	if (ev.xbutton.y<TermWin.int_bwidth)	1602	if (ev.xbutton.y<TermWin.int_bwidth)
1335	{	1603	{
1336	scroll_selection_dir = UP;	1604	scroll_selection_dir = UP;
1337	dist = TermWin.int_bwidth - ev.xbutton.y;	1605	dist = TermWin.int_bwidth - ev.xbutton.y;
1338	}	1606	}
1339	else	1607	else
1340	{	1608	{
1341	scroll_selection_dir = DN;	1609	scroll_selection_dir = DN;
1342	dist = ev.xbutton.y -
1343	(TermWin.int_bwidth + TermWin.height);	1610	dist = ev.xbutton.y - (TermWin.int_bwidth + TermWin.height);
1344	}	1611	}
		1612
1345	scroll_selection_lines= (Pixel2Height (dist)/	1613	scroll_selection_lines = Pixel2Height (dist)
1346	SELECTION_SCROLL_LINE_SPEEDUP)+1;	1614	/ SELECTION_SCROLL_LINE_SPEEDUP
		1615	+ 1;
1347	MIN_IT (scroll_selection_lines,	1616	MIN_IT (scroll_selection_lines,
1348	SELECTION_SCROLL_MAX_LINES);	1617	SELECTION_SCROLL_MAX_LINES);
1349	}	1618	}
1350	else	1619	else
1351	{	1620	{
1352	/* we are within the text window, so we	1621	/* we are within the text window, so we
1353	* shouldn't be scrolling	1622	* shouldn't be scrolling
…		…
1355	if (sel_scroll_ev.active)	1624	if (sel_scroll_ev.active)
1356	sel_scroll_ev.stop();	1625	sel_scroll_ev.stop();
1357	}	1626	}
1358	#endif	1627	#endif
1359	#ifdef MOUSE_THRESHOLD	1628	#ifdef MOUSE_THRESHOLD
1360
1361	}	1629	}
1362	#endif	1630	#endif
1363
1364	}	1631	}
1365	}	1632	}
1366	else if (isScrollbarWindow (ev.xany.window) && scrollbar_isMotion ())	1633	else if (isScrollbarWindow (ev.xany.window) && scrollbar_isMotion ())
1367	{	1634	{
1368	while (XCheckTypedWindowEvent (display->display, scrollBar.win,	1635	while (XCheckTypedWindowEvent (display->display, scrollBar.win,
1369	MotionNotify, &ev)) ;	1636	MotionNotify, &ev)) ;
1370	XQueryPointer (display->display, scrollBar.win,	1637	XQueryPointer (display->display, scrollBar.win,
1371	&unused_root, &unused_child,	1638	&unused_root, &unused_child,
1372	&unused_root_x, &unused_root_y,	1639	&unused_root_x, &unused_root_y,
1373	& (ev.xbutton.x), & (ev.xbutton.y),	1640	& (ev.xbutton.x), & (ev.xbutton.y),
1374	&unused_mask);	1641	&unused_mask);
…		…
1380	}	1647	}
1381	break;	1648	break;
1382	}	1649	}
1383	}	1650	}
1384		1651
		1652	#if TRANSPARENT
1385	void	1653	void
1386	rxvt_term::rootwin_cb (XEvent &ev)	1654	rxvt_term::rootwin_cb (XEvent &ev)
1387	{	1655	{
1388	SET_R (this);	1656	SET_R (this);
1389	SET_LOCALE (locale);	1657	SET_LOCALE (locale);
1390		1658
1391	switch (ev.type)	1659	switch (ev.type)
1392	{	1660	{
1393	case PropertyNotify:	1661	case PropertyNotify:
1394	if (ev.xproperty.atom == xa[XA_VT_SELECTION])
1395	{
1396	if (ev.xproperty.state == PropertyNewValue)
1397	selection_property (ev.xproperty.window, ev.xproperty.atom);
1398	break;
1399	}
1400	#ifdef TRANSPARENT
1401	else
1402	{
1403	/*	1662	/*
1404	* 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,
1405	* 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.
1406	*/	1665	*/
1407	if (xa[XA_XROOTPMAPID] == 0)	1666	if (xa[XA_XROOTPMAPID] == 0)
1408	xa[XA_XROOTPMAPID] = XInternAtom (display->display, "_XROOTPMAP_ID", False);	1667	xa[XA_XROOTPMAPID] = XInternAtom (display->display, "_XROOTPMAP_ID", False);
1409		1668
1410	if (ev.xproperty.atom != xa[XA_XROOTPMAPID])	1669	if (ev.xproperty.atom != xa[XA_XROOTPMAPID])
1411	return;	1670	return;
1412	}
1413		1671
1414	/* FALLTHROUGH */	1672	/* FALLTHROUGH */
1415	case ReparentNotify:	1673	case ReparentNotify:
1416	if ((Options & Opt_transparent) && check_our_parents () && am_transparent)	1674	if ((options & Opt_transparent) && check_our_parents () && am_transparent)
1417	want_refresh = want_full_refresh = 1;	1675	want_refresh = want_full_refresh = 1;
1418	break;	1676	break;
1419	#endif
1420	}	1677	}
1421	}	1678	}
		1679	#endif
1422		1680
1423	void	1681	void
1424	rxvt_term::button_press (XButtonEvent &ev)	1682	rxvt_term::button_press (XButtonEvent &ev)
1425	{	1683	{
1426	int reportmode = 0, clickintime;	1684	int reportmode = 0, clickintime;
1427		1685
1428	bypass_keystate = ev.state & (ModMetaMask | ShiftMask);	1686	bypass_keystate = ev.state & (ModMetaMask | ShiftMask);
1429	if (!bypass_keystate)	1687	if (!bypass_keystate)
1430	reportmode = !! (PrivateModes & PrivMode_mouse_report);	1688	reportmode = !! (priv_modes & PrivMode_mouse_report);
		1689
1431	/*	1690	/*
1432	* VT window processing of button press	1691	* VT window processing of button press
1433	*/	1692	*/
1434	if (ev.window == TermWin.vt)	1693	if (ev.window == TermWin.vt)
1435	{	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
1436	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;	1704	clickintime = ev.time - MEvent.time < MULTICLICK_TIME;
1437	if (reportmode)	1705	if (reportmode)
1438	{	1706	{
1439	/* mouse report from vt window */	1707	/* mouse report from vt window */
1440	/* save the xbutton state (for ButtonRelease) */	1708	/* save the xbutton state (for ButtonRelease) */
…		…
1474	MEvent.clicks = 0;	1742	MEvent.clicks = 0;
1475	switch (ev.button)	1743	switch (ev.button)
1476	{	1744	{
1477	case Button1:	1745	case Button1:
1478	/* allow shift+left click to extend selection */	1746	/* allow shift+left click to extend selection */
1479	if (ev.state & ShiftMask && ! (PrivateModes & PrivMode_mouse_report))	1747	if (ev.state & ShiftMask && ! (priv_modes & PrivMode_mouse_report))
1480	{	1748	{
1481	if (MEvent.button == Button1 && clickintime)	1749	if (MEvent.button == Button1 && clickintime)
1482	selection_rotate (ev.x, ev.y);	1750	selection_rotate (ev.x, ev.y);
1483	else	1751	else
1484	selection_extend (ev.x, ev.y, 1);	1752	selection_extend (ev.x, ev.y, 1);
…		…
1499	case Button3:	1767	case Button3:
1500	if (MEvent.button == Button3 && clickintime)	1768	if (MEvent.button == Button3 && clickintime)
1501	selection_rotate (ev.x, ev.y);	1769	selection_rotate (ev.x, ev.y);
1502	else	1770	else
1503	selection_extend (ev.x, ev.y, 1);	1771	selection_extend (ev.x, ev.y, 1);
		1772
1504	MEvent.button = Button3;	1773	MEvent.button = Button3;
1505	break;	1774	break;
1506	}	1775	}
1507	}	1776	}
		1777
1508	MEvent.time = ev.time;	1778	MEvent.time = ev.time;
1509	return;	1779	return;
1510	}	1780	}
1511		1781
1512	/*	1782	/*
…		…
1665	{	1935	{
1666	int reportmode = 0;	1936	int reportmode = 0;
1667		1937
1668	csrO = 0; /* reset csr Offset */	1938	csrO = 0; /* reset csr Offset */
1669	if (!bypass_keystate)	1939	if (!bypass_keystate)
1670	reportmode = !! (PrivateModes & PrivMode_mouse_report);	1940	reportmode = !! (priv_modes & PrivMode_mouse_report);
1671		1941
1672	if (scrollbar_isUpDn ())	1942	if (scrollbar_isUpDn ())
1673	{	1943	{
1674	scrollBar.setIdle ();	1944	scrollBar.setIdle ();
1675	scrollbar_show (0);	1945	scrollbar_show (0);
1676	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING	1946	#ifndef NO_SCROLLBAR_BUTTON_CONTINUAL_SCROLLING
1677	refresh_type &= ~SMOOTH_REFRESH;	1947	refresh_type &= ~SMOOTH_REFRESH;
1678	#endif	1948	#endif
1679
1680	}	1949	}
		1950
1681	#ifdef SELECTION_SCROLLING	1951	#ifdef SELECTION_SCROLLING
1682	if (sel_scroll_ev.active)	1952	if (sel_scroll_ev.active)
1683	sel_scroll_ev.stop();	1953	sel_scroll_ev.stop();
1684	#endif	1954	#endif
		1955
1685	if (ev.window == TermWin.vt)	1956	if (ev.window == TermWin.vt)
1686	{	1957	{
		1958	#if ISO_14755
		1959	// 5.4
		1960	if (iso14755buf & (ISO_14755_STARTED | ISO_14755_54))
		1961	return;
		1962	#endif
1687	if (reportmode)	1963	if (reportmode)
1688	{	1964	{
1689	/* mouse report from vt window */	1965	/* mouse report from vt window */
1690	/* don't report release of wheel "buttons" */	1966	/* don't report release of wheel "buttons" */
1691	if (ev.button >= 4)	1967	if (ev.button >= 4)
…		…
1705	MEvent.button = AnyButton;	1981	MEvent.button = AnyButton;
1706	mouse_report (ev);	1982	mouse_report (ev);
1707	#endif /* MOUSE_REPORT_DOUBLECLICK */	1983	#endif /* MOUSE_REPORT_DOUBLECLICK */
1708	return;	1984	return;
1709	}	1985	}
		1986
1710	/*	1987	/*
1711	* dumb hack to compensate for the failure of click-and-drag	1988	* dumb hack to compensate for the failure of click-and-drag
1712	* when overriding mouse reporting	1989	* when overriding mouse reporting
1713	*/	1990	*/
1714	if (PrivateModes & PrivMode_mouse_report	1991	if (priv_modes & PrivMode_mouse_report
1715	&& bypass_keystate	1992	&& bypass_keystate
1716	&& ev.button == Button1 && MEvent.clicks <= 1)	1993	&& ev.button == Button1 && MEvent.clicks <= 1)
1717	selection_extend (ev.x, ev.y, 0);	1994	selection_extend (ev.x, ev.y, 0);
1718		1995
1719	switch (ev.button)	1996	switch (ev.button)
…		…
1734		2011
1735	v = ev.button == Button4 ? UP : DN;	2012	v = ev.button == Button4 ? UP : DN;
1736		2013
1737	if (ev.state & ShiftMask)	2014	if (ev.state & ShiftMask)
1738	i = 1;	2015	i = 1;
1739	else if (Options & Opt_mouseWheelScrollPage)	2016	else if (options & Opt_mouseWheelScrollPage)
1740	i = TermWin.nrow - 1;	2017	i = TermWin.nrow - 1;
1741	else	2018	else
1742	i = 5;	2019	i = 5;
1743		2020
1744	# ifdef MOUSE_SLIP_WHEELING	2021	# ifdef MOUSE_SLIP_WHEELING
…		…
2029	Pixmap rootpixmap = None;	2306	Pixmap rootpixmap = None;
2030	XWindowAttributes wattr, wrootattr;	2307	XWindowAttributes wattr, wrootattr;
2031		2308
2032	pchanged = 0;	2309	pchanged = 0;
2033		2310
2034	if (!(Options & Opt_transparent))	2311	if (!(options & Opt_transparent))
2035	return pchanged; /* Don't try any more */	2312	return pchanged; /* Don't try any more */
2036		2313
2037	XGetWindowAttributes (display->display, display->root, &wrootattr);	2314	XGetWindowAttributes (display->display, display->root, &wrootattr);
2038	rootdepth = wrootattr.depth;	2315	rootdepth = wrootattr.depth;
2039		2316
…		…
2042	if (rootdepth != wattr.depth)	2319	if (rootdepth != wattr.depth)
2043	{	2320	{
2044	if (am_transparent)	2321	if (am_transparent)
2045	{	2322	{
2046	pchanged = 1;	2323	pchanged = 1;
2047	XSetWindowBackground (display->display, TermWin.vt, PixColorsFocused[Color_bg]);	2324	XSetWindowBackground (display->display, TermWin.vt, pix_colors_focused[Color_bg]);
2048	am_transparent = am_pixmap_trans = 0;	2325	am_transparent = am_pixmap_trans = 0;
2049	}	2326	}
2050		2327
2051	return pchanged; /* Don't try any more */	2328	return pchanged; /* Don't try any more */
2052	}	2329	}
…		…
2147	if (ISSET_PIXCOLOR (Color_tint))	2424	if (ISSET_PIXCOLOR (Color_tint))
2148	{	2425	{
2149	unsigned short rm, gm, bm;	2426	unsigned short rm, gm, bm;
2150	int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;	2427	int shade = rs[Rs_shade] ? atoi (rs[Rs_shade]) : 100;
2151		2428
2152	PixColorsFocused[Color_tint].get (display, rm, gm, bm);	2429	pix_colors_focused[Color_tint].get (display, rm, gm, bm);
2153		2430
2154	ShadeXImage (display, image, shade, rm, gm, bm);	2431	ShadeXImage (display, image, shade, rm, gm, bm);
2155	}	2432	}
2156	#endif	2433	#endif
2157		2434
…		…
2176	{	2453	{
2177	unsigned int n;	2454	unsigned int n;
2178	/*	2455	/*
2179	* InheritPixmap transparency	2456	* InheritPixmap transparency
2180	*/	2457	*/
2181	D_X ((stderr, "InheritPixmap Seeking to %08lx", display->root));
2182	for (i = 1; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)	2458	for (i = 1; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
2183	{	2459	{
2184	oldp = TermWin.parent[i];	2460	oldp = TermWin.parent[i];
2185	XQueryTree (display->display, TermWin.parent[i - 1], &root,	2461	XQueryTree (display->display, TermWin.parent[i - 1], &root,
2186	&TermWin.parent[i], &list, &n);	2462	&TermWin.parent[i], &list, &n);
2187	XFree (list);	2463	XFree (list);
2188	D_X ((stderr, "InheritPixmap Parent[%d] = %08lx", i, TermWin.parent[i]));
2189		2464
2190	if (TermWin.parent[i] == display->root)	2465	if (TermWin.parent[i] == display->root)
2191	{	2466	{
2192	if (oldp != None)	2467	if (oldp != None)
2193	pchanged = 1;	2468	pchanged = 1;
…		…
2204	if (pchanged)	2479	if (pchanged)
2205	{	2480	{
2206	for (; n < (unsigned int)i; n++)	2481	for (; n < (unsigned int)i; n++)
2207	{	2482	{
2208	XGetWindowAttributes (display->display, TermWin.parent[n], &wattr);	2483	XGetWindowAttributes (display->display, TermWin.parent[n], &wattr);
2209	D_X ((stderr, "InheritPixmap Checking Parent[%d]: %s", n, (wattr.depth == rootdepth && wattr.class != InputOnly) ? "OK" : "FAIL"));
2210	if (wattr.depth != rootdepth || wattr.c_class == InputOnly)	2484	if (wattr.depth != rootdepth || wattr.c_class == InputOnly)
2211	{	2485	{
2212	n = (int) (sizeof (TermWin.parent) / sizeof (Window)) + 1;	2486	n = (int) (sizeof (TermWin.parent) / sizeof (Window)) + 1;
2213	break;	2487	break;
2214	}	2488	}
2215	}	2489	}
2216	}	2490	}
2217		2491
2218	if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0])))	2492	if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0])))
2219	{	2493	{
2220	D_X ((stderr, "InheritPixmap Turning off"));
2221	XSetWindowBackground (display->display, TermWin.parent[0], PixColorsFocused[Color_fg]);	2494	XSetWindowBackground (display->display, TermWin.parent[0], pix_colors_focused[Color_fg]);
2222	XSetWindowBackground (display->display, TermWin.vt, PixColorsFocused[Color_bg]);	2495	XSetWindowBackground (display->display, TermWin.vt, pix_colors_focused[Color_bg]);
2223	am_transparent = 0;	2496	am_transparent = 0;
2224	/* XXX: also turn off Opt_transparent? */	2497	/* XXX: also turn off Opt_transparent? */
2225	}	2498	}
2226	else	2499	else
2227	{	2500	{
2228	#if WAIT_FOR_WM	2501	#if WAIT_FOR_WM
2229	/* wait (an arbitrary period) for the WM to do its thing	2502	/* wait (an arbitrary period) for the WM to do its thing
2230	* needed for fvwm2.2.2 (and before?) */	2503	* needed for fvwm2.2.2 (and before?) */
2231	sleep (1);	2504	sleep (1);
2232	#endif	2505	#endif
2233	D_X ((stderr, "InheritPixmap Turning on (%d parents)", i - 1));
2234	for (n = 0; n < (unsigned int)i; n++)	2506	for (n = 0; n < (unsigned int)i; n++)
2235	{	2507	{
2236	XSetWindowBackgroundPixmap (display->display, TermWin.parent[n], ParentRelative);	2508	XSetWindowBackgroundPixmap (display->display, TermWin.parent[n], ParentRelative);
2237	XClearWindow (display->display, TermWin.parent[n]);	2509	XClearWindow (display->display, TermWin.parent[n]);
2238	}	2510	}
…		…
2278	if (ch == NOCHAR) // TODO: improve	2550	if (ch == NOCHAR) // TODO: improve
2279	break;	2551	break;
2280		2552
2281	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)
2282	{	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
2283	/* Read a text string from the input buffer */	2565	/* Read a text string from the input buffer */
2284	unicode_t buf[UBUFSIZ];	2566	unicode_t buf[UBUFSIZ];
2285	bool refreshnow = false;	2567	bool refreshnow = false;
2286	int nlines = 0;	2568	int nlines = 0;
2287	unicode_t *str = buf;	2569	unicode_t *str = buf;
…		…
2296	if (ch == C0_LF)	2578	if (ch == C0_LF)
2297	{	2579	{
2298	nlines++;	2580	nlines++;
2299	refresh_count++;	2581	refresh_count++;
2300		2582
2301	if (!(Options & Opt_jumpScroll)	2583	if (!(options & Opt_jumpScroll)
2302	|| (refresh_count >= refresh_limit * (TermWin.nrow - 1)))	2584	|| (refresh_count >= refresh_limit * (TermWin.nrow - 1)))
2303	{	2585	{
2304	refreshnow = true;	2586	refreshnow = true;
2305	ch = NOCHAR;	2587	ch = NOCHAR;
2306	break;	2588	break;
…		…
2333	* the number of pages between refreshes is refresh_limit, which	2615	* the number of pages between refreshes is refresh_limit, which
2334	* is incremented here because we must be doing flat-out scrolling.	2616	* is incremented here because we must be doing flat-out scrolling.
2335	*/	2617	*/
2336	if (refreshnow)	2618	if (refreshnow)
2337	{	2619	{
2338	if ((Options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)	2620	if ((options & Opt_jumpScroll) && refresh_limit < REFRESH_PERIOD)
2339	refresh_limit++;	2621	refresh_limit++;
2340	else	2622	else
2341	{	2623	{
2342	flag = true;	2624	flag = true;
2343	scr_refresh (refresh_type);	2625	scr_refresh (refresh_type);
…		…
2533	process_escape_seq ();	2815	process_escape_seq ();
2534	break;	2816	break;
2535	case C0_ENQ: /* terminal Status */	2817	case C0_ENQ: /* terminal Status */
2536	if (rs[Rs_answerbackstring])	2818	if (rs[Rs_answerbackstring])
2537	tt_write ((const unsigned char *)rs[Rs_answerbackstring],	2819	tt_write ((const unsigned char *)rs[Rs_answerbackstring],
2538	(unsigned int)STRLEN (rs[Rs_answerbackstring]));	2820	(unsigned int)strlen (rs[Rs_answerbackstring]));
2539	else	2821	else
2540	tt_write ((unsigned char *)VT100_ANS,	2822	tt_write ((unsigned char *)VT100_ANS,
2541	(unsigned int)STRLEN (VT100_ANS));	2823	(unsigned int)strlen (VT100_ANS));
2542	break;	2824	break;
2543	case C0_BEL: /* bell */	2825	case C0_BEL: /* bell */
2544	scr_bell ();	2826	scr_bell ();
2545	break;	2827	break;
2546	case C0_BS: /* backspace */	2828	case C0_BS: /* backspace */
…		…
2645	void	2927	void
2646	rxvt_term::process_escape_seq ()	2928	rxvt_term::process_escape_seq ()
2647	{	2929	{
2648	unicode_t ch = cmd_getc ();	2930	unicode_t ch = cmd_getc ();
2649		2931
2650	if (PrivateModes & PrivMode_vt52)	2932	if (priv_modes & PrivMode_vt52)
2651	{	2933	{
2652	process_escape_vt52 (ch);	2934	process_escape_vt52 (ch);
2653	return;	2935	return;
2654	}	2936	}
2655		2937
…		…
2670	scr_charset_set (2, (unsigned int)cmd_getc ());	2952	scr_charset_set (2, (unsigned int)cmd_getc ());
2671	break;	2953	break;
2672	case '+':	2954	case '+':
2673	scr_charset_set (3, (unsigned int)cmd_getc ());	2955	scr_charset_set (3, (unsigned int)cmd_getc ());
2674	break;	2956	break;
2675	#ifndef NO_FRILLS	2957	#if ENABLE_FRILLS
2676	case '6':	2958	case '6':
2677	scr_backindex ();	2959	scr_backindex ();
2678	break;	2960	break;
2679	#endif	2961	#endif
2680	case '7':	2962	case '7':
2681	scr_cursor (SAVE);	2963	scr_cursor (SAVE);
2682	break;	2964	break;
2683	case '8':	2965	case '8':
2684	scr_cursor (RESTORE);	2966	scr_cursor (RESTORE);
2685	break;	2967	break;
2686	#ifndef NO_FRILLS	2968	#if ENABLE_FRILLS
2687	case '9':	2969	case '9':
2688	scr_forwardindex ();	2970	scr_forwardindex ();
2689	break;	2971	break;
2690	#endif	2972	#endif
2691	case '=':	2973	case '=':
…		…
2990	scr_scroll_text (screen.tscroll, screen.bscroll, arg[0], 0);	3272	scr_scroll_text (screen.tscroll, screen.bscroll, arg[0], 0);
2991	break;	3273	break;
2992		3274
2993	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */	3275	case CSI_DA: /* 8.3.24: (0) DEVICE ATTRIBUTES */
2994	tt_write ((const unsigned char *)VT100_ANS,	3276	tt_write ((const unsigned char *)VT100_ANS,
2995	(unsigned int) (sizeof (VT100_ANS) - 1));	3277	(unsigned int) (sizeof (VT100_ANS) - 1));
2996	break;	3278	break;
2997		3279
2998	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */	3280	case CSI_SGR: /* 8.3.118: (0) SELECT GRAPHIC RENDITION */
2999	process_sgr_mode (nargs, arg);	3281	process_sgr_mode (nargs, arg);
3000	break;	3282	break;
…		…
3007	break;	3289	break;
3008	case 6: /* CPR requested */	3290	case 6: /* CPR requested */
3009	scr_report_position ();	3291	scr_report_position ();
3010	break;	3292	break;
3011	case 7: /* unofficial extension */	3293	case 7: /* unofficial extension */
3012	if (Options & Opt_insecure)	3294	if (options & Opt_insecure)
3013	tt_printf ("%-.250s\n", rs[Rs_display_name]);	3295	tt_printf ("%-.250s\012", rs[Rs_display_name]);
3014	break;	3296	break;
3015	case 8: /* unofficial extension */	3297	case 8: /* unofficial extension */
3016	process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);	3298	process_xterm_seq (XTerm_title, RESNAME "-" VERSION, CHAR_ST);
3017	break;	3299	break;
3018	}	3300	}
…		…
3054	break;	3336	break;
3055		3337
3056	case CSI_RM: /* 8.3.107: RESET MODE */	3338	case CSI_RM: /* 8.3.107: RESET MODE */
3057	if (arg[0] == 4)	3339	if (arg[0] == 4)
3058	scr_insert_mode (0);	3340	scr_insert_mode (0);
		3341	else if (arg[0] == 20)
		3342	priv_modes &= ~PrivMode_LFNL;
3059	break;	3343	break;
3060		3344
3061	case CSI_SM: /* 8.3.126: SET MODE */	3345	case CSI_SM: /* 8.3.126: SET MODE */
3062	if (arg[0] == 4)	3346	if (arg[0] == 4)
3063	scr_insert_mode (1);	3347	scr_insert_mode (1);
		3348	else if (arg[0] == 20)
		3349	priv_modes |= PrivMode_LFNL;
3064	break;	3350	break;
3065		3351
3066	/*	3352	/*
3067	* PRIVATE USE beyond this point. All CSI_7? sequences here	3353	* PRIVATE USE beyond this point. All CSI_7? sequences here
3068	*/	3354	*/
…		…
3080	break;	3366	break;
3081	case CSI_75:	3367	case CSI_75:
3082	scr_cursor (RESTORE);	3368	scr_cursor (RESTORE);
3083	break;	3369	break;
3084		3370
3085	#ifndef NO_FRILLS	3371	#if ENABLE_FRILLS
3086	case CSI_74:	3372	case CSI_74:
3087	process_window_ops (arg, nargs);	3373	process_window_ops (arg, nargs);
3088	break;	3374	break;
3089	#endif	3375	#endif
3090		3376
…		…
3097	break;	3383	break;
3098	}	3384	}
3099	}	3385	}
3100	/*}}} */	3386	/*}}} */
3101		3387
3102	#ifndef NO_FRILLS	3388	#if ENABLE_FRILLS
3103	/* ARGSUSED */	3389	/* ARGSUSED */
3104	void	3390	void
3105	rxvt_term::process_window_ops (const int *args, unsigned int nargs)	3391	rxvt_term::process_window_ops (const int *args, unsigned int nargs)
3106	{	3392	{
3107	int x, y;	3393	int x, y;
…		…
3174	break;	3460	break;
3175	case 19: /* report window size (chars) */	3461	case 19: /* report window size (chars) */
3176	tt_printf ("\033[9;%d;%dt", TermWin.nrow, TermWin.ncol);	3462	tt_printf ("\033[9;%d;%dt", TermWin.nrow, TermWin.ncol);
3177	break;	3463	break;
3178	case 20: /* report icon label */	3464	case 20: /* report icon label */
3179	if (Options & Opt_insecure)
3180	{	3465	{
3181	char *s;	3466	char *s;
3182	XGetIconName (display->display, TermWin.parent[0], &s);	3467	XGetIconName (display->display, TermWin.parent[0], &s);
3183	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);
3184	}	3470	}
3185	break;	3471	break;
3186	case 21: /* report window title */	3472	case 21: /* report window title */
3187	if (Options & Opt_insecure)
3188	{	3473	{
3189	char *s;	3474	char *s;
3190	XFetchName (display->display, TermWin.parent[0], &s);	3475	XFetchName (display->display, TermWin.parent[0], &s);
3191	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);
3192	}	3478	}
3193	break;	3479	break;
3194	}	3480	}
3195	}	3481	}
3196	#endif	3482	#endif
3197		3483
…		…
3239		3525
3240	if ((s = (unsigned char *)rxvt_malloc (n)) == NULL)	3526	if ((s = (unsigned char *)rxvt_malloc (n)) == NULL)
3241	return NULL;	3527	return NULL;
3242		3528
3243	ends_how = (ch == 0x5c ? C0_ESC : ch);	3529	ends_how = (ch == 0x5c ? C0_ESC : ch);
3244	STRNCPY (s, string, n);	3530	strncpy (s, string, n);
3245	return s;	3531	return s;
3246	}	3532	}
3247		3533
3248	/*----------------------------------------------------------------------*/	3534	/*----------------------------------------------------------------------*/
3249	/*	3535	/*
…		…
3294	void	3580	void
3295	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)
3296	{	3582	{
3297	if (str[0] == '?' && !str[1])	3583	if (str[0] == '?' && !str[1])
3298	{	3584	{
3299	if (Options & Opt_insecure)
3300	{
3301	unsigned short r, g, b;	3585	unsigned short r, g, b;
3302	PixColorsFocused[color].get (display, r, g, b);	3586	pix_colors_focused[color].get (display, r, g, b);
3303	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);
3304	}
3305	}	3588	}
3306	else	3589	else
3307	set_window_color (color, str);	3590	set_window_color (color, str);
3308	}	3591	}
3309		3592
…		…
3395	break;	3678	break;
3396		3679
3397	case XTerm_Color:	3680	case XTerm_Color:
3398	for (buf = (char *)str; buf && *buf;)	3681	for (buf = (char *)str; buf && *buf;)
3399	{	3682	{
3400	if ((name = STRCHR (buf, ';')) == NULL)	3683	if ((name = strchr (buf, ';')) == NULL)
3401	break;	3684	break;
3402		3685
3403	*name++ = '\0';	3686	*name++ = '\0';
3404	color = atoi (buf);	3687	color = atoi (buf);
3405		3688
3406	if (color < 0 || color >= TOTAL_COLORS)	3689	if (color < 0 || color >= TOTAL_COLORS)
3407	break;	3690	break;
3408		3691
3409	if ((buf = STRCHR (name, ';')) != NULL)	3692	if ((buf = strchr (name, ';')) != NULL)
3410	*buf++ = '\0';	3693	*buf++ = '\0';
3411		3694
3412	if (name[0] == '?' && !name[1])	3695	if (name[0] == '?' && !name[1])
3413	{	3696	{
3414	if (Options & Opt_insecure)
3415	{
3416	unsigned short r, g, b;	3697	unsigned short r, g, b;
3417	PixColorsFocused[color + minCOLOR].get (display, r, g, b);	3698	pix_colors_focused[color + minCOLOR].get (display, r, g, b);
3418	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);
3419	}
3420	}	3700	}
3421	else	3701	else
3422	set_window_color (color + minCOLOR, name);	3702	set_window_color (color + minCOLOR, name);
3423	}	3703	}
3424	break;	3704	break;
…		…
3458	scale_pixmap (""); /* reset to default scaling */	3738	scale_pixmap (""); /* reset to default scaling */
3459	set_bgPixmap (str); /* change pixmap */	3739	set_bgPixmap (str); /* change pixmap */
3460	#endif	3740	#endif
3461	scr_touch (true);	3741	scr_touch (true);
3462	}	3742	}
3463	while ((str = STRCHR (str, ';')) != NULL)	3743	while ((str = strchr (str, ';')) != NULL)
3464	{	3744	{
3465	str++;	3745	str++;
3466	#if XPM_BACKGROUND	3746	#if XPM_BACKGROUND
3467	changed += scale_pixmap (str);	3747	changed += scale_pixmap (str);
3468	#endif	3748	#endif
…		…
3488	// TODO, when secure mode?	3768	// TODO, when secure mode?
3489	break;	3769	break;
3490		3770
3491	case XTerm_font:	3771	case XTerm_font:
3492	if (query)	3772	if (query)
3493	{
3494	if (Options & Opt_insecure)
3495	tt_printf ("\33]%d;%-.250s%c", XTerm_font,	3773	tt_printf ("\33]%d;%-.250s%c", XTerm_font,
		3774	(options & Opt_insecure) && TermWin.fontset->fontdesc
3496	TermWin.fontset->fontdesc	3775	? TermWin.fontset->fontdesc : "",
3497	? TermWin.fontset->fontdesc
3498	: "",
3499	resp);	3776	resp);
3500	}
3501	else	3777	else
3502	change_font (str);	3778	change_font (str);
3503	break;	3779	break;
3504		3780
3505	#ifndef NO_FRILLS	3781	#if ENABLE_FRILLS
3506	case XTerm_locale:	3782	case XTerm_locale:
3507	if (query)	3783	if (query)
3508	{
3509	if (Options & Opt_insecure)
3510	tt_printf ("\33]%d;%-.250s%c", XTerm_locale, locale, resp);	3784	tt_printf ("\33]%d;%-.250s%c", XTerm_locale, (options & Opt_insecure) ? locale : "", resp);
3511	}
3512	else	3785	else
3513	{	3786	{
3514	set_locale (str);	3787	set_locale (str);
3515	# ifdef USE_XIM	3788	# ifdef USE_XIM
3516	im_cb ();	3789	im_cb ();
3517	# endif	3790	# endif
3518	}	3791	}
3519	break;	3792	break;
3520		3793
3521	case XTerm_findfont:	3794	case XTerm_findfont:
3522	if (Options & Opt_insecure)
3523	{	3795	{
3524	int fid = TermWin.fontset->find_font (atoi (str));	3796	int fid = TermWin.fontset->find_font (atoi (str));
3525	tt_printf ("\33]%d;%d;%-.250s%c", XTerm_findfont,	3797	tt_printf ("\33]%d;%d;%-.250s%c", XTerm_findfont,
3526	fid, (*TermWin.fontset)[fid]->name, resp);	3798	fid,
		3799	(options & Opt_insecure) ? (*TermWin.fontset)[fid]->name : "",
		3800	resp);
3527	}	3801	}
3528	break;	3802	break;
3529	#endif	3803	#endif
3530		3804
3531	#ifdef MENUBAR	3805	#ifdef MENUBAR
3532	case XTerm_Menu:	3806	case XTerm_Menu:
3533	if (Options & Opt_insecure)	3807	if (options & Opt_insecure)
3534	menubar_dispatch (const_cast<char *>(str)); // casting away constness is checked	3808	menubar_dispatch (const_cast<char *>(str)); // casting away constness is checked
3535	break;	3809	break;
3536	#endif	3810	#endif
3537	#if 0	3811	#if 0
3538	case XTerm_dumpscreen: /* no error notices */	3812	case XTerm_dumpscreen: /* no error notices */
…		…
3565	{	3839	{
3566	int state;	3840	int state;
3567		3841
3568	if (mode == 's')	3842	if (mode == 's')
3569	{	3843	{
3570	SavedModes |= (PrivateModes & bit);	3844	SavedModes |= (priv_modes & bit);
3571	return -1;	3845	return -1;
3572	}	3846	}
3573	else	3847	else
3574	{	3848	{
3575	if (mode == 'r')	3849	if (mode == 'r')
3576	state = (SavedModes & bit) ? 1 : 0; /* no overlapping */	3850	state = (SavedModes & bit) ? 1 : 0; /* no overlapping */
3577	else	3851	else
3578	state = (mode == 't') ? ! (PrivateModes & bit) : mode;	3852	state = (mode == 't') ? ! (priv_modes & bit) : mode;
3579	PrivMode (state, bit);	3853	PrivMode (state, bit);
3580	}	3854	}
3581		3855
3582	return state;	3856	return state;
3583	}	3857	}
…		…
3601	{ 3, PrivMode_132 },	3875	{ 3, PrivMode_132 },
3602	{ 4, PrivMode_smoothScroll },	3876	{ 4, PrivMode_smoothScroll },
3603	{ 5, PrivMode_rVideo },	3877	{ 5, PrivMode_rVideo },
3604	{ 6, PrivMode_relOrigin },	3878	{ 6, PrivMode_relOrigin },
3605	{ 7, PrivMode_Autowrap },	3879	{ 7, PrivMode_Autowrap },
		3880	// 8, bi-directional support mode
3606	{ 9, PrivMode_MouseX10 },	3881	{ 9, PrivMode_MouseX10 },
3607	#ifdef menuBar_esc	3882	#ifdef menuBar_esc
3608	{ menuBar_esc, PrivMode_menuBar },	3883	{ menuBar_esc, PrivMode_menuBar },
3609	#endif	3884	#endif
		3885	// 18, 19 printing-related
		3886	{ 25, PrivMode_VisibleCursor },
3610	#ifdef scrollBar_esc	3887	#ifdef scrollBar_esc
3611	{ scrollBar_esc, PrivMode_scrollBar },	3888	{ scrollBar_esc, PrivMode_scrollBar },
3612	#endif	3889	#endif
3613	// 18, 19 printing-related
3614	{ 25, PrivMode_VisibleCursor },
3615	// 30 show scrollbar rxvt. extension
3616	{ 35, PrivMode_ShiftKeys }, // rxvt extension	3890	{ 35, PrivMode_ShiftKeys }, // rxvt extension
3617	{ 40, PrivMode_132OK },	3891	{ 40, PrivMode_132OK },
3618	// 41 xterm more fixes NYI	3892	// 41 xterm more fixes NYI
3619	// 45 margin bell NYI	3893	// 45 margin bell NYI
3620	// 46 start logging	3894	// 46 start logging
…		…
3661		3935
3662	/* extra handling for values with state unkept */	3936	/* extra handling for values with state unkept */
3663	switch (arg[i])	3937	switch (arg[i])
3664	{	3938	{
3665	case 1048: /* alternative cursor save */	3939	case 1048: /* alternative cursor save */
3666	if (Options & Opt_secondaryScreen)	3940	if (options & Opt_secondaryScreen)
3667	if (mode == 0)	3941	if (mode == 0)
3668	scr_cursor (RESTORE);	3942	scr_cursor (RESTORE);
3669	else if (mode == 1)	3943	else if (mode == 1)
3670	scr_cursor (SAVE);	3944	scr_cursor (SAVE);
3671	break;	3945	break;
…		…
3682	* within VT52 mode	3956	* within VT52 mode
3683	*/	3957	*/
3684	PrivMode (1, PrivMode_vt52);	3958	PrivMode (1, PrivMode_vt52);
3685	break;	3959	break;
3686	case 3: /* 80/132 */	3960	case 3: /* 80/132 */
3687	if (PrivateModes & PrivMode_132OK)	3961	if (priv_modes & PrivMode_132OK)
3688	set_widthheight (((state ? 132 : 80) * TermWin.fwidth), TermWin.height);	3962	set_widthheight (((state ? 132 : 80) * TermWin.fwidth), TermWin.height);
3689	break;	3963	break;
3690	case 4: /* smooth scrolling */	3964	case 4: /* smooth scrolling */
3691	if (state)	3965	if (state)
3692	Options &= ~Opt_jumpScroll;	3966	options &= ~Opt_jumpScroll;
3693	else	3967	else
3694	Options |= Opt_jumpScroll;	3968	options |= Opt_jumpScroll;
3695	break;	3969	break;
3696	case 5: /* reverse video */	3970	case 5: /* reverse video */
3697	scr_rvideo_mode (state);	3971	scr_rvideo_mode (state);
3698	break;	3972	break;
3699	case 6: /* relative/absolute origins */	3973	case 6: /* relative/absolute origins */
…		…
3703	scr_autowrap (state);	3977	scr_autowrap (state);
3704	break;	3978	break;
3705	/* 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 */
3706	case 9: /* X10 mouse reporting */	3980	case 9: /* X10 mouse reporting */
3707	if (state) /* orthogonal */	3981	if (state) /* orthogonal */
3708	PrivateModes &= ~PrivMode_MouseX11;	3982	priv_modes &= ~PrivMode_MouseX11;
3709	break;	3983	break;
3710	#ifdef menuBar_esc	3984	#ifdef menuBar_esc
3711	case menuBar_esc:	3985	case menuBar_esc:
3712	#ifdef MENUBAR	3986	#ifdef MENUBAR
3713	map_menuBar (state);	3987	map_menuBar (state);
…		…
3733	break;	4007	break;
3734	/* case 66: - application key pad */	4008	/* case 66: - application key pad */
3735	/* case 67: - backspace key */	4009	/* case 67: - backspace key */
3736	case 1000: /* X11 mouse reporting */	4010	case 1000: /* X11 mouse reporting */
3737	if (state) /* orthogonal */	4011	if (state) /* orthogonal */
3738	PrivateModes &= ~PrivMode_MouseX10;	4012	priv_modes &= ~PrivMode_MouseX10;
3739	break;	4013	break;
3740	#if 0	4014	#if 0
3741	case 1001:	4015	case 1001:
3742	break; /* X11 mouse highlighting */	4016	break; /* X11 mouse highlighting */
3743	#endif	4017	#endif
3744	case 1010: /* scroll to bottom on TTY output inhibit */	4018	case 1010: /* scroll to bottom on TTY output inhibit */
3745	if (state)	4019	if (state)
3746	Options &= ~Opt_scrollTtyOutput;	4020	options &= ~Opt_scrollTtyOutput;
3747	else	4021	else
3748	Options |= Opt_scrollTtyOutput;	4022	options |= Opt_scrollTtyOutput;
3749	break;	4023	break;
3750	case 1011: /* scroll to bottom on key press */	4024	case 1011: /* scroll to bottom on key press */
3751	if (state)	4025	if (state)
3752	Options |= Opt_scrollTtyKeypress;	4026	options |= Opt_scrollTtyKeypress;
3753	else	4027	else
3754	Options &= ~Opt_scrollTtyKeypress;	4028	options &= ~Opt_scrollTtyKeypress;
3755	break;	4029	break;
3756	case 1047: /* secondary screen w/ clearing last */	4030	case 1047: /* secondary screen w/ clearing last */
3757	if (Options & Opt_secondaryScreen)	4031	if (options & Opt_secondaryScreen)
3758	if (current_screen != PRIMARY)	4032	if (current_screen != PRIMARY)
3759	scr_erase_screen (2);	4033	scr_erase_screen (2);
3760	scr_change_screen (state);	4034	scr_change_screen (state);
3761	break;	4035	break;
3762	case 1049: /* secondary screen w/ clearing first */	4036	case 1049: /* secondary screen w/ clearing first */
3763	scr_change_screen (state);	4037	scr_change_screen (state);
3764	if (Options & Opt_secondaryScreen)	4038	if (options & Opt_secondaryScreen)
3765	if (current_screen != PRIMARY)	4039	if (current_screen != PRIMARY)
3766	scr_erase_screen (2);	4040	scr_erase_screen (2);
3767	break;	4041	break;
3768	default:	4042	default:
3769	break;	4043	break;
…		…
3796	break;	4070	break;
3797	case 1:	4071	case 1:
3798	rendset = 1, rendstyle = RS_Bold;	4072	rendset = 1, rendstyle = RS_Bold;
3799	break;	4073	break;
3800	//case 2: // faint or second colour	4074	//case 2: // faint or second colour
		4075	//case 3: // italic
3801	case 4:	4076	case 4:
3802	rendset = 1, rendstyle = RS_Uline;	4077	rendset = 1, rendstyle = RS_Uline;
3803	break;	4078	break;
3804	case 5: // slowly blinking	4079	case 5: // slowly blinking
3805	case 6: // rapidly blinking	4080	case 6: // rapidly blinking
…		…
3830	rendset = 0, rendstyle = RS_Uline;	4105	rendset = 0, rendstyle = RS_Uline;
3831	break;	4106	break;
3832	case 25:	4107	case 25:
3833	rendset = 0, rendstyle = RS_Blink;	4108	rendset = 0, rendstyle = RS_Blink;
3834	break;	4109	break;
		4110	case 26:
		4111	rendset = 0, rendstyle = RS_Blink;
		4112	break;
3835	case 27:	4113	case 27:
3836	rendset = 0, rendstyle = RS_RVid;	4114	rendset = 0, rendstyle = RS_RVid;
3837	break;	4115	break;
3838	//case 28: // visible. NYI	4116	//case 28: // visible. NYI
3839	//case 29: // not crossed-out	4117	//case 29: // not crossed-out
…		…
3929	{	4207	{
3930	unicode_t ch, cmd = cmd_getc ();	4208	unicode_t ch, cmd = cmd_getc ();
3931		4209
3932	if (cmd == 'Q')	4210	if (cmd == 'Q')
3933	{ /* query graphics */	4211	{ /* query graphics */
3934	tt_printf ("\033G0\n"); /* no graphics */	4212	tt_printf ("\033G0\012"); /* no graphics */
3935	return;	4213	return;
3936	}	4214	}
3937	/* swallow other graphics sequences until terminating ':' */	4215	/* swallow other graphics sequences until terminating ':' */
3938	do	4216	do
3939	ch = cmd_getc ();	4217	ch = cmd_getc ();
…		…
3954	unsigned char buf[256];	4232	unsigned char buf[256];
3955		4233
3956	va_start (arg_ptr, fmt);	4234	va_start (arg_ptr, fmt);
3957	vsnprintf ((char *)buf, 256, fmt, arg_ptr);	4235	vsnprintf ((char *)buf, 256, fmt, arg_ptr);
3958	va_end (arg_ptr);	4236	va_end (arg_ptr);
3959	tt_write (buf, STRLEN (buf));	4237	tt_write (buf, strlen (buf));
3960	}	4238	}
3961		4239
3962	/* ---------------------------------------------------------------------- */	4240	/* ---------------------------------------------------------------------- */
3963	/* 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,
3964	* or generated by us in response to a query ESC sequence.	4242	* or generated by us in response to a query ESC sequence.
…		…
3970		4248
3971	if (len)	4249	if (len)
3972	{	4250	{
3973	if (v_buflen == 0)	4251	if (v_buflen == 0)
3974	{	4252	{
3975	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));
3976		4254
3977	if ((unsigned int)written == len)	4255	if ((unsigned int)written == len)
3978	return;	4256	return;
3979		4257
3980	data += written;	4258	data += written;
…		…
3988	v_buflen += len;	4266	v_buflen += len;
3989	}	4267	}
3990		4268
3991	for (;;)	4269	for (;;)
3992	{	4270	{
3993	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));
3994		4272
3995	if (written > 0)	4273	if (written > 0)
3996	{	4274	{
3997	v_buflen -= written;	4275	v_buflen -= written;
3998		4276

Diff Legend

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