[ViewVC] Diff of: cvs/rxvt-unicode/src/rxvtperl.xs

Comparing rxvt-unicode/src/rxvtperl.xs (file contents):
Revision 1.67 by root, Sun Jan 15 06:02:41 2006 UTC vs.
Revision 1.261 by root, Tue Jul 25 18:06:07 2023 UTC

…		…
1	/----------------------------------------------------------------------	1	/----------------------------------------------------------------------
2	* File: rxvtperl.xs	2	* File: rxvtperl.xs
3	----------------------------------------------------------------------	3	----------------------------------------------------------------------
4	*	4	*
5	* All portions of code are copyright by their respective author/s.	5	* All portions of code are copyright by their respective author/s.
6	* Copyright (c) 2005-2006 Marc Lehmann <pcg@goof.com>	6	* Copyright (c) 2005-2014 Marc Lehmann <schmorp@schmorp.de>
7	*	7	*
8	* This program is free software; you can redistribute it and/or modify	8	* This program is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation; either version 3 of the License, or
11	* (at your option) any later version.	11	* (at your option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23	#define line_t perl_line_t	23	#define line_t perl_line_t
24	#include <EXTERN.h>	24	#include <EXTERN.h>
25	#include <perl.h>	25	#include <perl.h>
26	#include <XSUB.h>	26	#include <XSUB.h>
27	#undef line_t	27	#undef line_t
		28	#undef bool // perl defines it's own bool type, except with g++... what a trap
28		29
29	#include "../config.h"	30	#include "../config.h"
30		31
31	#include <cstddef>	32	#include <stddef.h>
32	#include <cstdarg>	33	#include <stdarg.h>
33		34
34	#include "unistd.h"	35	#include <unistd.h>
35		36
36	#include "iom.h"	37	#include <X11/extensions/shape.h>
		38
		39	// support old includes (https://bugs.freedesktop.org/show_bug.cgi?id=2799, https://lists.x.org/archives/xorg-arch/2005-March/000004.html)
		40	#ifndef ShapeInput
		41	# define ShapeInput 2
		42	#endif
		43
		44	#include "ev_cpp.h"
37	#include "rxvt.h"	45	#include "rxvt.h"
38	#include "keyboard.h"	46	#include "keyboard.h"
39	#include "rxvtutil.h"	47	#include "rxvtutil.h"
40	#include "rxvtperl.h"	48	#include "rxvtperl.h"
41		49
42	#include "perlxsi.c"	50	#include "perlxsi.c"
43		51
44	#if defined(HAVE_SCROLLBARS) \|\| defined(MENUBAR)
45	# define GRAB_CURSOR THIS->leftptr_cursor	52	#define GRAB_CURSOR THIS->scrollBar.leftptr_cursor
46	#else
47	# define GRAB_CURSOR None
48	#endif
49		53
50	#undef LINENO	54	#undef LINENO
51	#define LINENO(n) MOD (THIS->term_start + int(n), THIS->total_rows)	55	#define LINENO(n) MOD (THIS->term_start + int(n), THIS->total_rows)
52	#undef ROW	56	#undef ROW
53	#define ROW(n) THIS->row_buf [LINENO (n)]	57	#define ROW(n) THIS->row_buf [LINENO (n)]
54		58
55	#define ENABLE_PERL_FRILLS 1
56
57	/////////////////////////////////////////////////////////////////////////////	59	/////////////////////////////////////////////////////////////////////////////
58		60
59	static SV *	61	typedef char * octet_string;
60	taint (SV *sv)	62	typedef char * utf8_string;
		63
		64	typedef int render_repeat_mode;
		65
		66	#if HAVE_PIXBUF
		67	typedef GdkPixbuf * urxvt__pixbuf;
		68	#endif
		69	#if HAVE_IMG
		70	typedef rxvt_img * urxvt__img;
		71	typedef rxvt_img::nv rxvt_img__nv;
		72
		73	/////////////////////////////////////////////////////////////////////////////
		74
		75	static rgba
		76	parse_rgba (SV sv, rxvt_screen s = 0)
61	{	77	{
62	SvTAINT (sv);	78	rgba c;
		79
		80	if (SvROK (sv))
		81	{
		82	AV av = (AV )SvRV (sv);
		83
		84	if (SvTYPE ((SV *)av) != SVt_PVAV)
		85	croak ("colour must be either a colour string, or an array,");
		86
		87	int len = av_len (av) + 1;
		88
		89	if (len != 1 && len != 3 && len != 4)
		90	croak ("component colour array must have 1, 3 or 4 components,");
		91
		92	c.a = rgba::MAX_CC;
		93
		94	c.r = c.g = c.b = float_to_component (SvNV (*av_fetch (av, 0, 0)));
		95
		96	if (len >= 3)
		97	{
		98	c.g = float_to_component (SvNV (*av_fetch (av, 1, 0)));
		99	c.b = float_to_component (SvNV (*av_fetch (av, 2, 0)));
		100
		101	if (len >= 4)
		102	c.a = float_to_component (SvNV (*av_fetch (av, 3, 0)));
		103	}
		104	}
		105	else if (s)
		106	{
		107	rxvt_color rc;
		108	rc.set (s, SvPVbyte_nolen (sv));
		109	rc.get (c);
		110	}
		111	else
		112	croak ("unable to parse colour,");
		113
63	return sv;	114	return c;
64	}	115	}
65		116
66	static SV *	117	/////////////////////////////////////////////////////////////////////////////
67	taint_if (SV sv, SV src)	118	#endif
68	{
69	if (SvTAINTED (src))
70	SvTAINT (sv);
71
72	return sv;
73	}
74		119
75	static wchar_t *	120	static wchar_t *
76	sv2wcs (SV *sv)	121	sv2wcs (SV *sv)
77	{	122	{
78	STRLEN len;	123	STRLEN len;
…		…
91		136
92	return sv;	137	return sv;
93	}	138	}
94		139
95	static SV *	140	static SV *
96	new_ref (HV hv, const char klass)
97	{
98	return sv_bless (newRV ((SV *)hv), gv_stashpv (klass, 1));
99	}
100
101	//TODO: use magic
102	static SV *
103	newSVptr (void ptr, const char klass)	141	newSVptr (void ptr, const char klass)
104	{	142	{
105	HV *hv = newHV ();	143	HV *hv = newHV ();
106	sv_magic ((SV )hv, 0, PERL_MAGIC_ext, (char )ptr, 0);	144	sv_magic ((SV )hv, 0, PERL_MAGIC_ext, (char )ptr, 0);
107	return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));	145	return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
…		…
129	croak ("perl code used %s object, but C++ object is already destroyed, caught", klass);	167	croak ("perl code used %s object, but C++ object is already destroyed, caught", klass);
130		168
131	return (long)mg->mg_ptr;	169	return (long)mg->mg_ptr;
132	}	170	}
133		171
134	#define newSVterm(term) SvREFCNT_inc ((SV *)term->perl.self)	172	#define newSVterm(term) SvREFCNT_inc ((SV *)(term)->perl.self)
135	#define SvTERM(sv) (rxvt_term *)SvPTR (sv, "urxvt::term")	173	#define SvTERM(sv) (rxvt_term *)SvPTR ((sv), "urxvt::term")
136		174
137	/////////////////////////////////////////////////////////////////////////////	175	/////////////////////////////////////////////////////////////////////////////
138		176
139	struct perl_watcher	177	#define SvOVERLAY(sv) (overlay *)SvPTR (sv, "urxvt::overlay")
		178
		179	class overlay : overlay_base
140	{	180	{
141	SV *cbsv;	181	rxvt_term *THIS;
		182	AV *overlay_av;
		183	int border;
		184
		185	public:
142	HV *self;	186	HV *self;
143
144	perl_watcher ()
145	: cbsv (newSV (0))
146	{
147	}
148
149	~perl_watcher ()
150	{
151	SvREFCNT_dec (cbsv);
152	}
153
154	void cb (SV *cb)
155	{
156	sv_setsv (cbsv, cb);
157	}
158
159	void invoke (const char type, SV self, int arg = -1);
160	};
161
162	void
163	perl_watcher::invoke (const char type, SV self, int arg)
164	{
165	dSP;
166
167	ENTER;
168	SAVETMPS;
169
170	PUSHMARK (SP);
171
172	XPUSHs (sv_2mortal (self));
173
174	if (arg >= 0)
175	XPUSHs (sv_2mortal (newSViv (arg)));
176
177	PUTBACK;
178	call_sv (cbsv, G_VOID \| G_EVAL \| G_DISCARD);
179	SPAGAIN;
180
181	PUTBACK;
182	FREETMPS;
183	LEAVE;
184
185	if (SvTRUE (ERRSV))
186	rxvt_warn ("%s callback evaluation error: %s", type, SvPV_nolen (ERRSV));
187	}
188
189	#define newSVtimer(timer) new_ref (timer->self, "urxvt::timer")
190	#define SvTIMER(sv) (timer *)SvPTR (sv, "urxvt::timer")
191
192	struct timer : time_watcher, perl_watcher
193	{
194	tstamp interval;
195
196	timer ()
197	: time_watcher (this, &timer::execute)
198	{
199	}
200
201	void execute (time_watcher &w)
202	{
203	if (interval)
204	start (at + interval);
205
206	invoke ("urxvt::timer", newSVtimer (this));
207	}
208	};
209
210	#define newSViow(iow) new_ref (iow->self, "urxvt::iow")
211	#define SvIOW(sv) (iow *)SvPTR (sv, "urxvt::iow")
212
213	struct iow : io_watcher, perl_watcher
214	{
215	iow ()
216	: io_watcher (this, &iow::execute)
217	{
218	}
219
220	void execute (io_watcher &w, short revents)
221	{
222	invoke ("urxvt::iow", newSViow (this), revents);
223	}
224	};
225
226	/////////////////////////////////////////////////////////////////////////////
227
228	#define SvOVERLAY(sv) (overlay *)SvPTR (sv, "urxvt::overlay")
229
230	struct overlay {
231	HV *self;
232	rxvt_term *THIS;
233	int x, y, w, h;
234	int border;
235	text_t **text;
236	rend_t **rend;
237		187
238	overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border);	188	overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border);
239	~overlay ();	189	~overlay ();
240		190
241	void show ();	191	void show ();
…		…
245		195
246	void set (int x, int y, SV str, SV rend);	196	void set (int x, int y, SV str, SV rend);
247	};	197	};
248		198
249	overlay::overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border)	199	overlay::overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border)
250	: THIS(THIS), x(x_), y(y_), w(w_), h(h_), border(border == 2)	200	: THIS(THIS), border(border == 2), overlay_av (0)
251	{	201	{
		202	x = x_;
		203	y = y_;
		204	w = w_;
		205	h = h_;
		206
		207	if (w < 0) w = 0;
		208	if (h < 0) h = 0;
		209
252	if (border == 2)	210	if (border == 2)
253	{	211	{
254	w += 2;	212	w += 2;
255	h += 2;	213	h += 2;
256	}	214	}
…		…
294	*rp++ = r;	252	*rp++ = r;
295	}	253	}
296	}	254	}
297		255
298	show ();	256	show ();
299	THIS->want_refresh = 1;
300	}	257	}
301		258
302	overlay::~overlay ()	259	overlay::~overlay ()
303	{	260	{
304	hide ();	261	hide ();
…		…
309	delete [] rend[y];	266	delete [] rend[y];
310	}	267	}
311		268
312	delete [] text;	269	delete [] text;
313	delete [] rend;	270	delete [] rend;
		271	}
		272
		273	void
		274	overlay::show ()
		275	{
		276	if (overlay_av)
		277	return;
		278
		279	overlay_av = (AV *)SvREFCNT_inc (SvRV (
		280	hv_fetch ((HV )SvRV ((SV *)THIS->perl.self), "_overlay", 8, 0)
		281	));
		282	av_push (overlay_av, newSViv ((long)this));
314		283
315	THIS->want_refresh = 1;	284	THIS->want_refresh = 1;
316	}	285	THIS->refresh_check ();
317
318	void
319	overlay::show ()
320	{
321	char key[33]; sprintf (key, "%32lx", (long)this);
322
323	HV hv = (HV )SvRV (hv_fetch ((HV )SvRV ((SV *)THIS->perl.self), "_overlay", 8, 0));
324	hv_store (hv, key, 32, newSViv ((long)this), 0);
325	}	286	}
326		287
327	void	288	void
328	overlay::hide ()	289	overlay::hide ()
329	{	290	{
330	SV *ovs = hv_fetch ((HV )SvRV ((SV *)THIS->perl.self), "_overlay", 8, 0);	291	if (!overlay_av)
		292	return;
331		293
332	if (ovs)	294	int i;
333	{
334	char key[33]; sprintf (key, "%32lx", (long)this);
335		295
336	HV hv = (HV )SvRV (*ovs);	296	for (i = AvFILL (overlay_av); i >= 0; i--)
337	hv_delete (hv, key, 32, G_DISCARD);	297	if (SvIV (*av_fetch (overlay_av, i, 1)) == (long)this)
338	}	298	break;
		299
		300	for (; i < AvFILL (overlay_av); i++)
		301	av_store (overlay_av, i, SvREFCNT_inc (*av_fetch (overlay_av, i + 1, 0)));
		302
		303	SvREFCNT_dec (av_pop (overlay_av));
		304
		305	SvREFCNT_dec (overlay_av);
		306	overlay_av = 0;
		307
		308	THIS->want_refresh = 1;
		309	THIS->refresh_check ();
339	}	310	}
340		311
341	void overlay::swap ()	312	void overlay::swap ()
342	{	313	{
343	int ov_x = max (0, min (MOD (x, THIS->ncol), THIS->ncol - w));	314	int ov_x = max (0, min (MOD (x, THIS->ncol), THIS->ncol - w));
344	int ov_y = max (0, min (MOD (y, THIS->nrow), THIS->nrow - h));	315	int ov_y = max (0, min (MOD (y, THIS->nrow), THIS->nrow - h));
345		316
346	int ov_w = min (w, THIS->ncol - ov_x);	317	int ov_w = min (w, THIS->ncol - ov_x);
347	int ov_h = min (h, THIS->nrow - ov_y);	318	int ov_h = min (h, THIS->nrow - ov_y);
		319
		320	// hide cursor if it is within the overlay area
		321	if (IN_RANGE_EXC (THIS->screen.cur.col - ov_x, 0, ov_w)
		322	&& IN_RANGE_EXC (THIS->screen.cur.row - ov_y, 0, ov_h))
		323	THIS->screen.flags &= ~Screen_VisibleCursor;
348		324
349	for (int y = ov_h; y--; )	325	for (int y = ov_h; y--; )
350	{	326	{
351	text_t *t1 = text [y];	327	text_t *t1 = text [y];
352	rend_t *r1 = rend [y];	328	rend_t *r1 = rend [y];
…		…
383	if (!SvROK (rend) \|\| SvTYPE (SvRV (rend)) != SVt_PVAV)	359	if (!SvROK (rend) \|\| SvTYPE (SvRV (rend)) != SVt_PVAV)
384	croak ("rend must be arrayref");	360	croak ("rend must be arrayref");
385		361
386	AV av = (AV )SvRV (rend);	362	AV av = (AV )SvRV (rend);
387		363
388	for (int col = min (av_len (av) + 1, w - x - border); col--; )	364	for (int col = min (AvFILL (av) + 1, w - x - border); col--; )
389	this->rend [y][x + col] = SvIV (*av_fetch (av, col, 1));	365	this->rend [y][x + col] = SvIV (*av_fetch (av, col, 1));
390	}	366	}
391		367
392	THIS->want_refresh = 1;	368	THIS->want_refresh = 1;
		369	THIS->refresh_check ();
393	}	370	}
394
395		371
396	/////////////////////////////////////////////////////////////////////////////	372	/////////////////////////////////////////////////////////////////////////////
397		373
		374	#include "iom_perl.h"
		375
		376	/////////////////////////////////////////////////////////////////////////////
		377
398	struct rxvt_perl_interp rxvt_perl;	378	struct rxvt_perl_interp rxvt_perl;
399		379
400	static PerlInterpreter *perl;	380	static PerlInterpreter *perl;
401		381
		382	#if 0 /* we are not a library anymore, so doing this is just not worth it */
		383	/THINK/TODO: this has the side effect of, of course, not calling destructors. /
		384	/* but these are not guaranteed anyway... */
402	rxvt_perl_interp::~rxvt_perl_interp ()	385	rxvt_perl_interp::~rxvt_perl_interp ()
403	{	386	{
404	if (perl)	387	if (perl)
405	{	388	{
		389	localise_env set_environ (perl_environ);
406	perl_destruct (perl);	390	perl_destruct (perl);
407	perl_free (perl);	391	perl_free (perl);
		392	PERL_SYS_TERM ();
408	}	393	}
409	}	394	}
		395	#endif
410		396
411	void	397	void
412	rxvt_perl_interp::init ()	398	rxvt_perl_interp::init ()
413	{	399	{
414	if (!perl)	400	if (!perl)
415	{	401	{
		402	rxvt_push_locale ("C"); // perl init destroys current locale
		403
		404	{
416	perl_environ = rxvt_environ;	405	perl_environ = rxvt_environ;
417	swap (perl_environ, environ);	406	localise_env set_environ (perl_environ);
418		407
419	char *argv[] = {	408	const char *args[] = {
420	"",	409	"",
421	"-T",	410	"-e"
422	"-edo '" LIBDIR "/urxvt.pm' or ($@ and die $@) or exit 1",	411	"BEGIN {"
		412	" urxvt->bootstrap;"
		413	" unshift @INC, '" LIBDIR "';"
		414	"}"
		415	""
		416	"use urxvt;",
		417	0
423	};	418	};
		419	int argc = ecb_array_length (args) - 1;
		420	char argv = (char )args;
424		421
		422	PERL_SYS_INIT3 (&argc, &argv, &environ);
425	perl = perl_alloc ();	423	perl = perl_alloc ();
426	perl_construct (perl);	424	perl_construct (perl);
427		425
428	if (perl_parse (perl, xs_init, 3, argv, (char **)NULL)	426	if (perl_parse (perl, xs_init, argc, argv, (char **)NULL)
429	\|\| perl_run (perl))	427	\|\| perl_run (perl))
430	{	428	{
431	rxvt_warn ("unable to initialize perl-interpreter, continuing without.\n");	429	rxvt_warn ("unable to initialize perl-interpreter, continuing without.\n");
432		430
433	perl_destruct (perl);	431	perl_destruct (perl);
434	perl_free (perl);	432	perl_free (perl);
435	perl = 0;	433	perl = 0;
436	}	434	}
		435	}
437		436
438	swap (perl_environ, environ);	437	rxvt_pop_locale ();
439	}	438	}
		439	}
		440
		441	void
		442	rxvt_perl_interp::init (rxvt_term *term)
		443	{
		444	init ();
		445
		446	if (perl && !term->perl.self)
		447	{
		448	// runs outside of perls ENV
		449	term->perl.self = (void )newSVptr ((void )term, "urxvt::term");
		450	hv_store ((HV )SvRV ((SV )term->perl.self), "_overlay", 8, newRV_noinc ((SV *)newAV ()), 0);
		451	hv_store ((HV )SvRV ((SV )term->perl.self), "_selection", 10, newRV_noinc ((SV *)newAV ()), 0);
		452	}
		453	}
		454
		455	void
		456	rxvt_perl_interp::eval (const char *str)
		457	{
		458	eval_pv (str, 1);
		459	}
		460
		461	void
		462	rxvt_perl_interp::usage (rxvt_term *term, int type)
		463	{
		464	localise_env set_environ (perl_environ);
		465
		466	ENTER;
		467	SAVETMPS;
		468
		469	dSP;
		470	PUSHMARK (SP);
		471	EXTEND (SP, 2);
		472	PUSHs (sv_2mortal (newSVterm (term)));
		473	PUSHs (sv_2mortal (newSViv (type)));
		474	PUTBACK;
		475	call_pv ("urxvt::usage", G_VOID \| G_DISCARD);
		476
		477	FREETMPS;
		478	LEAVE;
		479	}
		480
		481	uint8_t
		482	rxvt_perl_interp::parse_resource (rxvt_term term, const char name, bool arg, bool longopt, bool flag, const char *value)
		483	{
		484	localise_env set_environ (perl_environ);
		485
		486	ENTER;
		487	SAVETMPS;
		488
		489	dSP;
		490	PUSHMARK (SP);
		491	EXTEND (SP, 6);
		492	PUSHs (sv_2mortal (newSVterm (term)));
		493	PUSHs (sv_2mortal (newSVpv (name, 0)));
		494	PUSHs (arg ? &PL_sv_yes : &PL_sv_no);
		495	PUSHs (longopt ? &PL_sv_yes : &PL_sv_no);
		496	PUSHs (flag ? &PL_sv_yes : &PL_sv_no);
		497	PUSHs (value ? sv_2mortal (newSVpv (value, 0)) : &PL_sv_undef);
		498	PUTBACK;
		499	call_pv ("urxvt::parse_resource", G_SCALAR);
		500	SPAGAIN;
		501
		502	uint8_t ret = POPi;
		503
		504	FREETMPS;
		505	LEAVE;
		506
		507	return ret;
		508	}
		509
		510	static void
		511	_keysym_resource_push (rxvt_term term, const char k, const char *v)
		512	{
		513	unsigned int state;
		514
		515	if (term->parse_keysym (k, state) == -1)
		516	return;
		517
		518	dSP;
		519	XPUSHs (sv_2mortal (newSVpv (v, 0)));
		520	PUTBACK;
		521	}
		522
		523	static void
		524	_keysym_resources (rxvt_term *term)
		525	{
		526	term->enumerate_keysym_resources (_keysym_resource_push);
440	}	527	}
441		528
442	static void	529	static void
443	ungrab (rxvt_term *THIS)	530	ungrab (rxvt_term *THIS)
444	{	531	{
445	if (THIS->perl.grabtime)	532	if (THIS->perl.grabtime)
446	{	533	{
447	XUngrabKeyboard (THIS->display->display, THIS->perl.grabtime);	534	XUngrabKeyboard (THIS->dpy, THIS->perl.grabtime);
448	XUngrabPointer (THIS->display->display, THIS->perl.grabtime);	535	XUngrabPointer (THIS->dpy, THIS->perl.grabtime);
449	THIS->perl.grabtime = 0;	536	THIS->perl.grabtime = 0;
450	}	537	}
451	}	538	}
452		539
453	static void	540	bool
454	swap_overlays (rxvt_term *term)	541	rxvt_perl_interp::invoke (rxvt_term *term, int htype, ...)
455	{	542	{
456	HV hv = (HV )SvRV (hv_fetch ((HV )SvRV ((SV *)term->perl.self), "_overlay", 8, 0));	543	if (!perl \|\| !term->perl.self)
		544	return false;
457		545
458	if (HvKEYS (hv))	546	localise_env set_environ (perl_environ);
		547
		548	// pre-handling of some events
		549	if (htype == HOOK_REFRESH_END)
459	{	550	{
460	hv_iterinit (hv);	551	AV av = (AV )SvRV (hv_fetch ((HV )SvRV ((SV *)term->perl.self), "_overlay", 8, 0));
461		552
462	while (HE *he = hv_iternext (hv))	553	for (int i = 0; i <= AvFILL (av); i++)
463	((overlay *)SvIV (hv_iterval (hv, he)))->swap ();	554	((overlay )SvIV (av_fetch (av, i, 0)))->swap ();
464	}	555	}
465	}
466
467	bool
468	rxvt_perl_interp::invoke (rxvt_term *term, hook_type htype, ...)
469	{
470	if (!perl)
471	return false;
472
473	if (htype == HOOK_INIT) // first hook ever called
474	{
475	term->perl.self = (void )newSVptr ((void )term, "urxvt::term");
476	hv_store ((HV )SvRV ((SV )term->perl.self), "_overlay", 8, newRV_noinc ((SV *)newHV ()), 0);
477	}
478	else if (!term->perl.self)
479	return false; // perl not initialized for this instance
480	else if (htype == HOOK_DESTROY)	556	else if (htype == HOOK_DESTROY)
481	{	557	{
482	// handled later	558	AV av = (AV )SvRV (hv_fetch ((HV )SvRV ((SV *)term->perl.self), "_selection", 10, 0));
483	}
484	else
485	{
486	if (htype == HOOK_REFRESH_END)
487	swap_overlays (term);
488		559
489	if (!term->perl.should_invoke [htype])	560	for (int i = AvFILL (av); i >= 0; i--)
490	{	561	{
491	if (htype == HOOK_REFRESH_BEGIN)	562	rxvt_selection req = (rxvt_selection )SvIV (*av_fetch (av, i, 0));
492	swap_overlays (term);	563	delete req;
493
494	return false;
495	}	564	}
496	}	565	}
497		566
498	swap (perl_environ, environ);	567	bool event_consumed;
499		568
500	try	569	if (term->perl.should_invoke [htype])
501	{	570	{
502	dSP;	571	dSP;
503	va_list ap;	572	va_list ap;
504		573
505	va_start (ap, htype);	574	va_start (ap, htype);
…		…
507	ENTER;	576	ENTER;
508	SAVETMPS;	577	SAVETMPS;
509		578
510	PUSHMARK (SP);	579	PUSHMARK (SP);
511		580
		581	EXTEND (SP, 2);
512	XPUSHs (sv_2mortal (newSVterm (term)));	582	PUSHs (sv_2mortal (newSVterm (term)));
513	XPUSHs (sv_2mortal (newSViv (htype)));	583	PUSHs (sv_2mortal (newSViv (htype)));
514		584
515	for (;;) {	585	for (;;) {
516	data_type dt = (data_type)va_arg (ap, int);	586	data_type dt = (data_type)va_arg (ap, int);
517		587
518	switch (dt)	588	switch (dt)
…		…
524	case DT_LONG:	594	case DT_LONG:
525	XPUSHs (sv_2mortal (newSViv (va_arg (ap, long))));	595	XPUSHs (sv_2mortal (newSViv (va_arg (ap, long))));
526	break;	596	break;
527		597
528	case DT_STR:	598	case DT_STR:
529	XPUSHs (taint (sv_2mortal (newSVpv (va_arg (ap, char *), 0))));	599	XPUSHs (sv_2mortal (newSVpv (va_arg (ap, char *), 0)));
530	break;	600	break;
531		601
532	case DT_STR_LEN:	602	case DT_STR_LEN:
533	{	603	{
534	char str = va_arg (ap, char );	604	char str = va_arg (ap, char );
535	int len = va_arg (ap, int);	605	int len = va_arg (ap, int);
536		606
537	XPUSHs (taint (sv_2mortal (newSVpvn (str, len))));	607	XPUSHs (sv_2mortal (newSVpvn (str, len)));
538	}	608	}
539	break;	609	break;
540		610
541	case DT_WCS_LEN:	611	case DT_WCS_LEN:
542	{	612	{
543	wchar_t wstr = va_arg (ap, wchar_t );	613	wchar_t wstr = va_arg (ap, wchar_t );
		614	int wlen = va_arg (ap, int);
		615
		616	XPUSHs (sv_2mortal (wcs2sv (wstr, wlen)));
		617	}
		618	break;
		619
		620	case DT_LCS_LEN:
		621	{
		622	long lstr = va_arg (ap, long );
544	int wlen = va_arg (ap, int);	623	int llen = va_arg (ap, int);
545		624
546	XPUSHs (taint (sv_2mortal (wcs2sv (wstr, wlen))));	625	XPUSHs (sv_2mortal (newSVpvn ((char )lstr, llen sizeof (long))));
547	}	626	}
548	break;	627	break;
549		628
550	case DT_XEVENT:	629	case DT_XEVENT:
551	{	630	{
552	XEvent xe = va_arg (ap, XEvent );	631	XEvent xe = va_arg (ap, XEvent );
553	HV *hv = newHV ();	632	HV *hv = newHV ();
554		633
555	# define set(name, sv) hv_store (hv, # name, sizeof (# name) - 1, sv, 0)	634	# define set(name, sv) hv_store (hv, # name, sizeof (# name) - 1, sv, 0)
556	# define setiv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSViv (val), 0)	635	# define setiv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSViv (val), 0)
		636	# define setuv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSVuv (val), 0)
557	# undef set	637	# undef set
558		638
559	setiv (type, xe->type);	639	setiv (type, xe->type);
560	setiv (send_event, xe->xany.send_event);	640	setiv (send_event, xe->xany.send_event);
561	setiv (serial, xe->xany.serial);	641	setiv (serial, xe->xany.serial);
562		642
…		…
565	case KeyPress:	645	case KeyPress:
566	case KeyRelease:	646	case KeyRelease:
567	case ButtonPress:	647	case ButtonPress:
568	case ButtonRelease:	648	case ButtonRelease:
569	case MotionNotify:	649	case MotionNotify:
		650	setuv (window, xe->xmotion.window);
		651	setuv (root, xe->xmotion.root);
		652	setuv (subwindow, xe->xmotion.subwindow);
570	setiv (time, xe->xmotion.time);	653	setuv (time, xe->xmotion.time);
571	setiv (x, xe->xmotion.x);	654	setiv (x, xe->xmotion.x);
572	setiv (y, xe->xmotion.y);	655	setiv (y, xe->xmotion.y);
573	setiv (row, xe->xmotion.y / term->fheight);	656	setiv (row, xe->xmotion.y / term->fheight + term->view_start);
574	setiv (col, xe->xmotion.x / term->fwidth);	657	setiv (col, xe->xmotion.x / term->fwidth);
575	setiv (x_root, xe->xmotion.x_root);	658	setiv (x_root, xe->xmotion.x_root);
576	setiv (y_root, xe->xmotion.y_root);	659	setiv (y_root, xe->xmotion.y_root);
577	setiv (state, xe->xmotion.state);	660	setuv (state, xe->xmotion.state);
		661
		662	switch (xe->type)
		663	{
		664	case KeyPress:
		665	case KeyRelease:
		666	setuv (keycode, xe->xkey.keycode);
		667	break;
		668
		669	case ButtonPress:
		670	case ButtonRelease:
		671	setuv (button, xe->xbutton.button);
		672	break;
		673
		674	case MotionNotify:
		675	setiv (is_hint, xe->xmotion.is_hint);
		676	break;
		677	}
		678
578	break;	679	break;
579	}
580		680
		681	case MapNotify:
		682	case UnmapNotify:
		683	case ConfigureNotify:
		684	setuv (event, xe->xconfigure.event);
		685	setuv (window, xe->xconfigure.window);
		686
581	switch (xe->type)	687	switch (xe->type)
582	{	688	{
583	case KeyPress:	689	case ConfigureNotify:
584	case KeyRelease:	690	setiv (x, xe->xconfigure.x);
585	setiv (keycode, xe->xkey.keycode);	691	setiv (y, xe->xconfigure.y);
		692	setiv (width, xe->xconfigure.width);
		693	setiv (height, xe->xconfigure.height);
		694	setuv (above, xe->xconfigure.above);
		695	break;
		696	}
		697
586	break;	698	break;
587		699
588	case ButtonPress:	700	case PropertyNotify:
589	case ButtonRelease:	701	setuv (window, xe->xproperty.window);
590	setiv (button, xe->xbutton.button);	702	setuv (atom, xe->xproperty.atom);
		703	setuv (time, xe->xproperty.time);
		704	setiv (state, xe->xproperty.state);
591	break;	705	break;
592		706
593	case MotionNotify:	707	case ClientMessage:
594	setiv (is_hint, xe->xmotion.is_hint);	708	setuv (window, xe->xclient.window);
		709	setuv (message_type, xe->xclient.message_type);
		710	setuv (format, xe->xclient.format);
		711	setuv (l0, xe->xclient.data.l[0]);
		712	setuv (l1, xe->xclient.data.l[1]);
		713	setuv (l2, xe->xclient.data.l[2]);
		714	setuv (l3, xe->xclient.data.l[3]);
		715	setuv (l4, xe->xclient.data.l[4]);
595	break;	716	break;
596	}	717	}
597		718
598	XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));	719	XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
599	}	720	}
600	break;	721	break;
601		722
602	case DT_END:	723	case DT_END:
603	{	724	goto call;
604	va_end (ap);
605
606	PUTBACK;
607	int count = call_pv ("urxvt::invoke", G_ARRAY \| G_EVAL);
608	SPAGAIN;
609
610	if (count)
611	{
612	SV *status = POPs;
613	count = SvTRUE (status);
614	}
615
616	PUTBACK;
617	FREETMPS;
618	LEAVE;
619
620	if (SvTRUE (ERRSV))
621	{
622	rxvt_warn ("perl hook %d evaluation error: %s", htype, SvPV_nolen (ERRSV));
623	ungrab (term); // better lose the grab than the session
624	}
625
626	if (htype == HOOK_REFRESH_BEGIN)
627	swap_overlays (term);
628	else if (htype == HOOK_DESTROY)
629	{
630	clearSVptr ((SV *)term->perl.self);
631	SvREFCNT_dec ((SV *)term->perl.self);
632	}
633
634	swap (perl_environ, environ);
635	return count;
636	}
637		725
638	default:	726	default:
639	rxvt_fatal ("FATAL: unable to pass data type %d\n", dt);	727	rxvt_fatal ("FATAL: unable to pass data type %d\n", dt);
640	}	728	}
641	}	729	}
		730
		731	call:
		732	va_end (ap);
		733
		734	PUTBACK;
		735	int count = call_pv ("urxvt::invoke", G_ARRAY \| G_EVAL);
		736	SPAGAIN;
		737
		738	if (count)
		739	{
		740	SV *status = POPs;
		741	count = SvTRUE (status);
		742	}
		743
		744	PUTBACK;
		745	FREETMPS;
		746	LEAVE;
		747
		748	if (SvTRUE (ERRSV))
		749	{
		750	rxvt_warn ("perl hook %d evaluation error: %s", htype, SvPVbyte_nolen (ERRSV));
		751	ungrab (term); // better lose the grab than the session
		752	}
		753
		754	event_consumed = !!count;
642	}	755	}
643	catch (...)	756	else
		757	event_consumed = false;
		758
		759	// post-handling of some events
		760	if (htype == HOOK_REFRESH_BEGIN)
644	{	761	{
645	swap (perl_environ, environ);	762	AV av = (AV )SvRV (hv_fetch ((HV )SvRV ((SV *)term->perl.self), "_overlay", 8, 0));
646	throw;	763
		764	for (int i = AvFILL (av); i >= 0; i--)
		765	((overlay )SvIV (av_fetch (av, i, 0)))->swap ();
647	}	766	}
		767	else if (htype == HOOK_DESTROY)
		768	{
		769	clearSVptr ((SV *)term->perl.self);
		770	SvREFCNT_dec ((SV *)term->perl.self);
		771
		772	// don't allow further calls
		773	term->perl.self = 0;
		774	}
		775
		776	return event_consumed;
		777	}
		778
		779	void
		780	rxvt_perl_interp::selection_finish (rxvt_selection sel, char data, unsigned int len)
		781	{
		782	localise_env set_environ (perl_environ);
		783
		784	ENTER;
		785	SAVETMPS;
		786
		787	dSP;
		788	XPUSHs (sv_2mortal (newSVpvn (data, len)));
		789	PUTBACK;
		790	call_sv ((SV *)sel->cb_sv, G_VOID \| G_DISCARD \| G_EVAL);
		791
		792	if (SvTRUE (ERRSV))
		793	rxvt_warn ("perl selection callback evaluation error: %s", SvPVbyte_nolen (ERRSV));
		794
		795	FREETMPS;
		796	LEAVE;
648	}	797	}
649		798
650	/////////////////////////////////////////////////////////////////////////////	799	/////////////////////////////////////////////////////////////////////////////
651		800
652	MODULE = urxvt PACKAGE = urxvt	801	MODULE = urxvt PACKAGE = urxvt
…		…
664	# define def(sym) av_store (hookname, HOOK_ ## sym, newSVpv (# sym, 0));	813	# define def(sym) av_store (hookname, HOOK_ ## sym, newSVpv (# sym, 0));
665	# include "hookinc.h"	814	# include "hookinc.h"
666	# undef def	815	# undef def
667		816
668	HV *option = get_hv ("urxvt::OPTION", 1);	817	HV *option = get_hv ("urxvt::OPTION", 1);
669	# define def(name,val) hv_store (option, # name, sizeof (# name) - 1, newSVuv (Opt_ ## name), 0);	818	# define def(name) hv_store (option, # name, sizeof (# name) - 1, newSVuv (Opt_ ## name), 0);
670	# define nodef(name)	819	# define nodef(name)
671	# include "optinc.h"	820	# include "optinc.h"
672	# undef nodef	821	# undef nodef
673	# undef def	822	# undef def
674		823
675	HV *stash = gv_stashpv ("urxvt", 1);	824	HV *stash = gv_stashpv ("urxvt", 1);
676	struct {	825	static const struct {
677	const char *name;	826	const char *name;
678	IV iv;	827	IV iv;
679	} *civ, const_iv[] = {	828	} *civ, const_iv[] = {
680	# define const_iv(name) { # name, (IV)name }	829	# define const_iv(name) { # name, (IV)name }
		830	const_iv (HOOK_INIT),
		831	const_iv (HOOK_DESTROY),
		832	const_iv (HOOK_ACTION),
		833	const_iv (HOOK_OSC_SEQ),
		834	const_iv (HOOK_OSC_SEQ_PERL),
		835
		836	const_iv (NUM_RESOURCES),
681	const_iv (DEFAULT_RSTYLE),	837	const_iv (DEFAULT_RSTYLE),
682	const_iv (OVERLAY_RSTYLE),	838	const_iv (OVERLAY_RSTYLE),
		839	const_iv (Color_Bits),
		840	const_iv (RS_bgShift), const_iv (RS_bgMask),
		841	const_iv (RS_fgShift), const_iv (RS_fgMask),
		842	const_iv (RS_Careful),
		843	const_iv (RS_fontCount),
		844	const_iv (RS_fontShift),
		845	const_iv (RS_fontMask),
		846	const_iv (RS_baseattrMask),
		847	const_iv (RS_attrMask),
		848	const_iv (RS_redraw),
		849	const_iv (RS_Sel),
683	const_iv (RS_Bold),	850	const_iv (RS_Bold),
684	const_iv (RS_Italic),	851	const_iv (RS_Italic),
685	const_iv (RS_Blink),	852	const_iv (RS_Blink),
686	const_iv (RS_RVid),	853	const_iv (RS_RVid),
687	const_iv (RS_Uline),	854	const_iv (RS_Uline),
688		855
		856	// TODO: should support all colour constants, create colorinc.h &c
		857	const_iv (Color_fg),
		858	const_iv (Color_bg),
		859	# if OFF_FOCUS_FADING
		860	const_iv (Color_fade),
		861	# endif
		862	const_iv (Color_pointer_fg),
		863	const_iv (Color_pointer_bg),
		864	const_iv (Color_border),
		865	const_iv (NRS_COLORS),
		866	const_iv (TOTAL_COLORS),
		867
		868	const_iv (None),
689	const_iv (CurrentTime),	869	const_iv (CurrentTime),
690	const_iv (ShiftMask),	870	const_iv (ShiftMask),
691	const_iv (LockMask),	871	const_iv (LockMask),
692	const_iv (ControlMask),	872	const_iv (ControlMask),
693	const_iv (Mod1Mask),	873	const_iv (Mod1Mask),
…		…
700	const_iv (Button3Mask),	880	const_iv (Button3Mask),
701	const_iv (Button4Mask),	881	const_iv (Button4Mask),
702	const_iv (Button5Mask),	882	const_iv (Button5Mask),
703	const_iv (AnyModifier),	883	const_iv (AnyModifier),
704		884
705	const_iv (EVENT_NONE),	885	const_iv (NoSymbol),
706	const_iv (EVENT_READ),	886	const_iv (GrabModeSync),
707	const_iv (EVENT_WRITE),	887	const_iv (GrabModeAsync),
708		888
709	const_iv (NoEventMask),	889	const_iv (NoEventMask),
710	const_iv (KeyPressMask),	890	const_iv (KeyPressMask),
711	const_iv (KeyReleaseMask),	891	const_iv (KeyReleaseMask),
712	const_iv (ButtonPressMask),	892	const_iv (ButtonPressMask),
…		…
764	const_iv (SelectionRequest),	944	const_iv (SelectionRequest),
765	const_iv (SelectionNotify),	945	const_iv (SelectionNotify),
766	const_iv (ColormapNotify),	946	const_iv (ColormapNotify),
767	const_iv (ClientMessage),	947	const_iv (ClientMessage),
768	const_iv (MappingNotify),	948	const_iv (MappingNotify),
		949
		950	// shape extension
		951	const_iv (ShapeSet),
		952	const_iv (ShapeUnion),
		953	const_iv (ShapeIntersect),
		954	const_iv (ShapeSubtract),
		955	const_iv (ShapeInvert),
		956
		957	const_iv (ShapeBounding),
		958	const_iv (ShapeClip),
		959	const_iv (ShapeInput),
		960
		961	// XIM
		962	# if ENABLE_XIM_ONTHESPOT
		963	const_iv (XIMReverse),
		964	const_iv (XIMUnderline),
		965	const_iv (XIMHighlight),
		966	const_iv (XIMPrimary),
		967	const_iv (XIMSecondary),
		968	const_iv (XIMTertiary),
		969	const_iv (XIMVisibleToForward),
		970	const_iv (XIMVisibleToBackword),
		971	const_iv (XIMVisibleToCenter),
		972	# endif
		973	# if XRENDER
		974	const_iv (PictStandardARGB32),
		975	const_iv (PictStandardRGB24),
		976	const_iv (PictStandardA8),
		977	const_iv (PictStandardA4),
		978	const_iv (PictStandardA1),
		979	const_iv (RepeatNone),
		980	const_iv (RepeatNormal),
		981	const_iv (RepeatPad),
		982	const_iv (RepeatReflect),
		983	// all versions
		984	const_iv (PictOpClear),
		985	const_iv (PictOpSrc),
		986	const_iv (PictOpDst),
		987	const_iv (PictOpOver),
		988	const_iv (PictOpOverReverse),
		989	const_iv (PictOpIn),
		990	const_iv (PictOpInReverse),
		991	const_iv (PictOpOut),
		992	const_iv (PictOpOutReverse),
		993	const_iv (PictOpAtop),
		994	const_iv (PictOpAtopReverse),
		995	const_iv (PictOpXor),
		996	const_iv (PictOpAdd),
		997	const_iv (PictOpSaturate),
		998	// 0.2+
		999	const_iv (PictOpDisjointClear),
		1000	const_iv (PictOpDisjointSrc),
		1001	const_iv (PictOpDisjointDst),
		1002	const_iv (PictOpDisjointOver),
		1003	const_iv (PictOpDisjointOverReverse),
		1004	const_iv (PictOpDisjointIn),
		1005	const_iv (PictOpDisjointInReverse),
		1006	const_iv (PictOpDisjointOut),
		1007	const_iv (PictOpDisjointOutReverse),
		1008	const_iv (PictOpDisjointAtop),
		1009	const_iv (PictOpDisjointAtopReverse),
		1010	const_iv (PictOpDisjointXor),
		1011	const_iv (PictOpConjointClear),
		1012	const_iv (PictOpConjointSrc),
		1013	const_iv (PictOpConjointDst),
		1014	const_iv (PictOpConjointOver),
		1015	const_iv (PictOpConjointOverReverse),
		1016	const_iv (PictOpConjointIn),
		1017	const_iv (PictOpConjointInReverse),
		1018	const_iv (PictOpConjointOut),
		1019	const_iv (PictOpConjointOutReverse),
		1020	const_iv (PictOpConjointAtop),
		1021	const_iv (PictOpConjointAtopReverse),
		1022	const_iv (PictOpConjointXor),
		1023	// 0.11+
		1024	const_iv (PictOpMultiply),
		1025	const_iv (PictOpScreen),
		1026	const_iv (PictOpOverlay),
		1027	const_iv (PictOpDarken),
		1028	const_iv (PictOpLighten),
		1029	const_iv (PictOpColorDodge),
		1030	const_iv (PictOpColorBurn),
		1031	const_iv (PictOpHardLight),
		1032	const_iv (PictOpSoftLight),
		1033	const_iv (PictOpDifference),
		1034	const_iv (PictOpExclusion),
		1035	const_iv (PictOpHSLHue),
		1036	const_iv (PictOpHSLSaturation),
		1037	const_iv (PictOpHSLColor),
		1038	const_iv (PictOpHSLLuminosity),
		1039	# endif
		1040	# if 0
		1041	const_iv (XIMForwardChar),
		1042	const_iv (XIMBackwardChar),
		1043	const_iv (XIMForwardWord),
		1044	const_iv (XIMBackwardWord),
		1045	const_iv (XIMCaretUp),
		1046	const_iv (XIMCaretDown),
		1047	const_iv (XIMNextLine),
		1048	const_iv (XIMPreviousLine),
		1049	const_iv (XIMLineStart),
		1050	const_iv (XIMLineEnd),
		1051	const_iv (XIMAbsolutePosition),
		1052	const_iv (XIMDontChange),
		1053	# endif
		1054
		1055	/* DEC private modes */
		1056	const_iv (PrivMode_132),
		1057	const_iv (PrivMode_132OK),
		1058	const_iv (PrivMode_rVideo),
		1059	const_iv (PrivMode_relOrigin),
		1060	const_iv (PrivMode_Screen),
		1061	const_iv (PrivMode_Autowrap),
		1062	const_iv (PrivMode_aplCUR),
		1063	const_iv (PrivMode_aplKP),
		1064	const_iv (PrivMode_HaveBackSpace),
		1065	const_iv (PrivMode_BackSpace),
		1066	const_iv (PrivMode_ShiftKeys),
		1067	const_iv (PrivMode_VisibleCursor),
		1068	const_iv (PrivMode_MouseX10),
		1069	const_iv (PrivMode_MouseX11),
		1070	const_iv (PrivMode_scrollBar),
		1071	const_iv (PrivMode_TtyOutputInh),
		1072	const_iv (PrivMode_Keypress),
		1073	const_iv (PrivMode_smoothScroll),
		1074	const_iv (PrivMode_vt52),
		1075	const_iv (PrivMode_LFNL),
		1076	const_iv (PrivMode_MouseBtnEvent),
		1077	const_iv (PrivMode_MouseAnyEvent),
		1078	const_iv (PrivMode_BracketPaste),
		1079	const_iv (PrivMode_ExtMouseUTF8),
		1080	const_iv (PrivMode_ExtMouseUrxvt),
		1081	const_iv (PrivMode_BlinkingCursor),
		1082	const_iv (PrivMode_mouse_report),
		1083	const_iv (PrivMode_Default),
769	};	1084	};
770		1085
771	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]);	1086	for (civ = const_iv + ecb_array_length (const_iv); civ > const_iv; civ--)
772	civ-- > const_iv; )
773	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	1087	newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
774	}	1088	}
775		1089
776	void	1090	void
777	warn (const char *msg)	1091	log (utf8_string msg)
		1092	CODE:
		1093	rxvt_log ("%s", msg);
		1094
		1095	void
		1096	warn (utf8_string msg)
778	CODE:	1097	CODE:
779	rxvt_warn ("%s", msg);	1098	rxvt_warn ("%s", msg);
780		1099
781	void	1100	void
782	fatal (const char *msg)	1101	fatal (utf8_string msg)
783	CODE:	1102	CODE:
784	rxvt_fatal ("%s", msg);	1103	rxvt_fatal ("%s", msg);
785		1104
786	SV *
787	untaint (SV *sv)
788	CODE:
789	RETVAL = newSVsv (sv);
790	SvTAINTED_off (RETVAL);
791	OUTPUT:
792	RETVAL
793
794	void	1105	void
795	_exit (int status)	1106	_exit (int status)
796		1107
797	bool	1108	void
798	safe ()	1109	catch_fatal (SV *block)
799	CODE:	1110	PROTOTYPE: &
800	RETVAL = !rxvt_tainted ();	1111	CODE:
801	OUTPUT:	1112	try
802	RETVAL	1113	{
		1114	PUSHMARK (SP);
		1115	PUTBACK;
		1116	call_sv (block, G_VOID \| G_DISCARD);
		1117	SPAGAIN;
		1118	}
		1119	catch (const rxvt_failure_exception &e)
		1120	{
		1121	croak ("rxvt_fatal exception caught, trying to continue.");
		1122	}
803		1123
804	NV	1124	NV
805	NOW ()	1125	NOW ()
806	CODE:	1126	CODE:
807	RETVAL = NOW;	1127	RETVAL = ev::now ();
808	OUTPUT:	1128	OUTPUT:
809	RETVAL	1129	RETVAL
810		1130
811	int	1131	int
812	GET_BASEFG (int rend)	1132	GET_BASEFG (int rend)
…		…
823	RETVAL	1143	RETVAL
824		1144
825	int	1145	int
826	SET_FGCOLOR (int rend, int new_color)	1146	SET_FGCOLOR (int rend, int new_color)
827	CODE:	1147	CODE:
828	RETVAL = SET_FGCOLOR (rend, new_color);	1148	RETVAL = SET_FGCOLOR (rend, clamp (new_color, 0, TOTAL_COLORS - 1));
829	OUTPUT:	1149	OUTPUT:
830	RETVAL	1150	RETVAL
831		1151
832	int	1152	int
833	SET_BGCOLOR (int rend, int new_color)	1153	SET_BGCOLOR (int rend, int new_color)
834	CODE:	1154	CODE:
835	RETVAL = SET_BGCOLOR (rend, new_color);	1155	RETVAL = SET_BGCOLOR (rend, clamp (new_color, 0, TOTAL_COLORS - 1));
836	OUTPUT:	1156	OUTPUT:
837	RETVAL	1157	RETVAL
838		1158
839	int	1159	int
840	GET_CUSTOM (int rend)	1160	GET_CUSTOM (int rend)
841	CODE:	1161	CODE:
842	RETVAL = (rend && RS_customMask) >> RS_customShift;	1162	RETVAL = (rend & RS_customMask) >> RS_customShift;
843	OUTPUT:	1163	OUTPUT:
844	RETVAL	1164	RETVAL
845		1165
846	int	1166	int
847	SET_CUSTOM (int rend, int new_value)	1167	SET_CUSTOM (int rend, int new_value)
848	CODE:	1168	CODE:
849	{	1169	{
850	if (!IN_RANGE_EXC (new_value, 0, RS_customCount))	1170	if (!IN_RANGE_EXC (new_value, 0, RS_customCount))
851	croak ("custom value out of range, must be 0..%d", RS_customCount - 1);	1171	croak ("custom value out of range, must be 0..%lu", RS_customCount - 1);
852		1172
853	RETVAL = (rend & ~RS_customMask)	1173	RETVAL = (rend & ~RS_customMask)
854	\| ((new_value << RS_customShift) & RS_customMask);	1174	\| ((new_value << RS_customShift) & RS_customMask);
855	}	1175	}
856	OUTPUT:	1176	OUTPUT:
857	RETVAL	1177	RETVAL
858		1178
		1179	void
		1180	termlist ()
		1181	PPCODE:
		1182	{
		1183	EXTEND (SP, rxvt_term::termlist.size ());
		1184
		1185	for (rxvt_term **t = rxvt_term::termlist.begin (); t < rxvt_term::termlist.end (); t++)
		1186	if ((*t)->perl.self)
		1187	PUSHs (sv_2mortal (newSVterm (*t)));
		1188	}
		1189
		1190	IV
		1191	_new_selection_request (rxvt_term term, int selnum, Time tm, Window win, Atom prop, SV cb)
		1192	CODE:
		1193	rxvt_selection *req = new rxvt_selection (term->display, selnum, tm, win, prop, term);
		1194	req->cb_sv = newSVsv (cb);
		1195	AV av = (AV )SvRV (hv_fetch ((HV )SvRV ((SV *)term->perl.self), "_selection", 10, 0));
		1196	av_push (av, newSViv ((IV)req));
		1197	RETVAL = (IV)req;
		1198	OUTPUT:
		1199	RETVAL
		1200
		1201	void
		1202	_delete_selection_request (IV req_)
		1203	CODE:
		1204	rxvt_selection req = (rxvt_selection )req_;
		1205	AV av = (AV )SvRV (hv_fetch ((HV )SvRV ((SV *)req->term->perl.self), "_selection", 10, 0));
		1206	int i;
		1207
		1208	for (i = AvFILL (av); i >= 0; i--)
		1209	if (SvIV (*av_fetch (av, i, 1)) == req_)
		1210	break;
		1211
		1212	for (; i < AvFILL (av); i++)
		1213	av_store (av, i, SvREFCNT_inc (*av_fetch (av, i + 1, 0)));
		1214
		1215	av_pop (av);
		1216
		1217	delete req;
		1218
		1219	Region
		1220	XCreateRegion ()
		1221
		1222	int
		1223	XUnionRectWithRegion (int x, int y, int w, int h, Region src, Region dst)
		1224	CODE:
		1225	XRectangle rect;
		1226	rect.x = x;
		1227	rect.y = y;
		1228	rect.width = w;
		1229	rect.height = h;
		1230	RETVAL = XUnionRectWithRegion (&rect, src, dst);
		1231	OUTPUT: RETVAL
		1232
		1233	int
		1234	XIntersectRegion (Region src1, Region src2, Region res)
		1235
		1236	int
		1237	XUnionRegion (Region src1, Region src2, Region res)
		1238
		1239	int
		1240	XSubtractRegion (Region src1, Region src2, Region res)
		1241
		1242	int
		1243	XXorRegion (Region src1, Region src2, Region res)
		1244
		1245	int
		1246	XOffsetRegion (Region r, int dx, int dy)
		1247
		1248	int
		1249	XShrinkRegion (Region r, int dx, int dy)
		1250
		1251	int
		1252	XDestroyRegion (Region r)
		1253
859	MODULE = urxvt PACKAGE = urxvt::term	1254	MODULE = urxvt PACKAGE = urxvt::term
860		1255
861	SV *	1256	SV *
862	_new (...)	1257	_new (AV env, AV arg)
863	CODE:	1258	CODE:
864	{	1259	{
865	if (items < 1 \|\| !SvROK (ST (0)) \|\| SvTYPE (SvRV (ST (0))) != SVt_PVAV)
866	croak ("first argument to urxvt::term->_new must be arrayref");
867
868	rxvt_term *term = new rxvt_term;	1260	rxvt_term *term = new rxvt_term;
869		1261
870	term->argv = new stringvec;	1262	stringvec *argv = new stringvec;
871	term->envv = new stringvec;	1263	for (int i = 0; i <= AvFILL (arg); i++)
872
873	for (int i = 1; i < items; i++)
874	term->argv->push_back (strdup (SvPVbyte_nolen (ST (i))));	1264	argv->push_back (strdup (SvPVbyte_nolen (*av_fetch (arg, i, 1))));
875		1265
876	AV envv = (AV )SvRV (ST (0));	1266	stringvec *envv = new stringvec;
877	for (int i = av_len (envv) + 1; i--; )	1267	for (int i = AvFILL (env) + 1; i--; )
878	term->envv->push_back (strdup (SvPVbyte_nolen (*av_fetch (envv, i, 1))));	1268	envv->push_back (strdup (SvPVbyte_nolen (*av_fetch (env, i, 1))));
879
880	term->envv->push_back (0);
881
882	bool success;
883		1269
884	try	1270	try
885	{	1271	{
886	success = term->init (term->argv->size (), term->argv->begin ());	1272	term->init (argv, envv);
887	}	1273	}
888	catch (const class rxvt_failure_exception &e)	1274	catch (const class rxvt_failure_exception &e)
889	{
890	success = false;
891	}
892
893	if (!success)
894	{	1275	{
895	term->destroy ();	1276	term->destroy ();
896	croak ("error while initializing new terminal instance");	1277	croak ("error while initializing new terminal instance");
897	}	1278	}
898		1279
…		…
903	RETVAL	1284	RETVAL
904		1285
905	void	1286	void
906	rxvt_term::destroy ()	1287	rxvt_term::destroy ()
907		1288
908	#if ENABLE_PERL_FRILLS
909
910	void	1289	void
911	rxvt_term::XListProperties (U32 window)	1290	rxvt_term::set_should_invoke (int htype, int inc)
		1291	CODE:
		1292	uint8_t &count = THIS->perl.should_invoke [htype];
		1293	uint8_t prev = count;
		1294	count += inc;
		1295	if (!prev != !count)
		1296	{
		1297	// hook status changed, react
		1298	switch (htype)
		1299	{
		1300	case HOOK_POSITION_CHANGE:
		1301	if (count)
		1302	THIS->get_window_origin (THIS->parent_x, THIS->parent_y);
		1303	}
		1304	}
		1305
		1306	void
		1307	rxvt_term::put_option_db (octet_string specifier, octet_string value)
		1308	CODE:
		1309	XrmPutStringResource (&THIS->option_db, specifier, value);
		1310
		1311	void
		1312	rxvt_term::_keysym_resources ()
912	PPCODE:	1313	PPCODE:
913	{	1314	PUTBACK;
914	int count;	1315	_keysym_resources (THIS);
915	Atom *props = XListProperties (THIS->display->display, (Window)window, &count);	1316	SPAGAIN;
916		1317
917	EXTEND (SP, count);	1318	int
918	while (count--)	1319	rxvt_term::grab_button (int button, U32 modifiers, Window window = THIS->vt)
919	PUSHs (newSVuv ((U32)props [count]));
920
921	XFree (props);
922	}
923
924	void
925	rxvt_term::XGetWindowProperty (U32 window, U32 property)
926	PPCODE:	1320	CODE:
927	{	1321	RETVAL = XGrabButton (THIS->dpy, button, modifiers, window, 1,
928	Atom type;
929	int format;
930	unsigned long nitems;
931	unsigned long bytes_after;
932	unsigned char *prop;
933	XGetWindowProperty (THIS->display->display, (Window)window, (Atom)property,
934	0, 1<<30, 0, AnyPropertyType,
935	&type, &format, &nitems, &bytes_after, &prop);
936	if (type != None)
937	{
938	EXTEND (SP, 3);
939	PUSHs (newSVuv ((U32)type));
940	PUSHs (newSViv (format));
941	PUSHs (newSVpvn ((char )prop, nitems format / 8));
942	XFree (prop);
943	}
944	}
945
946	void
947	rxvt_term::XChangeWindowProperty (U32 window, U32 property, U32 type, int format, SV *data)
948	CODE:
949	{
950	STRLEN len;
951	char *data_ = SvPVbyte (data, len);
952
953	XChangeProperty (THIS->display->display, (Window)window, (Atom)property,
954	type, format, PropModeReplace,
955	(unsigned char )data, len 8 / format);
956	}
957
958	void
959	rxvt_term::XDeleteProperty (U32 window, U32 property)
960	CODE:
961	XDeleteProperty (THIS->display->display, (Window)window, (Atom)property);
962
963	U32
964	rxvt_term::DefaultRootWindow ()
965	CODE:
966	RETVAL = (U32)THIS->display->root;
967	OUTPUT:
968	RETVAL
969
970	U32
971	rxvt_term::XCreateSimpleWindow (U32 parent, int x, int y, unsigned int width, unsigned int height)
972	CODE:
973	RETVAL = XCreateSimpleWindow (THIS->display->display, (Window)parent,
974	x, y, width, height, 0,
975	THIS->pix_colors_focused[Color_border],
976	THIS->pix_colors_focused[Color_border]);
977	OUTPUT:
978	RETVAL
979
980	void
981	rxvt_term::XReparentWindow (U32 window, U32 parent, int x = 0, int y = 0)
982	CODE:
983	XReparentWindow (THIS->display->display, (Window)window, (Window)parent, x, y);
984
985	void
986	rxvt_term::XMapWindow (U32 window)
987	CODE:
988	XMapWindow (THIS->display->display, (Window)window);
989
990	void
991	rxvt_term::XUnmapWindow (U32 window)
992	CODE:
993	XUnmapWindow (THIS->display->display, (Window)window);
994
995	#endif
996
997	void
998	rxvt_term::set_should_invoke (int htype, int inc)
999	CODE:
1000	THIS->perl.should_invoke [htype] += inc;
1001
1002	void
1003	rxvt_term::grab_button (int button, U32 modifiers)
1004	CODE:
1005	XGrabButton (THIS->display->display, button, modifiers, THIS->vt, 1,
1006	ButtonPressMask \| ButtonReleaseMask \| EnterWindowMask \| LeaveWindowMask \| PointerMotionMask,	1322	ButtonPressMask \| ButtonReleaseMask \| EnterWindowMask \| LeaveWindowMask \| PointerMotionMask,
1007	GrabModeSync, GrabModeSync, None, GRAB_CURSOR);	1323	GrabModeSync, GrabModeSync, None, GRAB_CURSOR);
		1324	OUTPUT: RETVAL
		1325
		1326	int
		1327	rxvt_term::ungrab_button (int button, U32 modifiers, Window window = THIS->vt)
		1328	CODE:
		1329	RETVAL = XUngrabButton (THIS->dpy, button, modifiers, window);
		1330	OUTPUT: RETVAL
		1331
		1332	void
		1333	rxvt_term::XGrabKey (int keycode, U32 modifiers, Window window = THIS->vt, \
		1334	int owner_events = 1, int pointer_mode = GrabModeAsync, int keyboard_mode = GrabModeAsync)
		1335	CODE:
		1336	XGrabKey (THIS->dpy, keycode, modifiers, window, owner_events, pointer_mode, keyboard_mode);
		1337
		1338	void
		1339	rxvt_term::XUngrabKey (int keycode, U32 modifiers, Window window = THIS->vt)
		1340	CODE:
		1341	XUngrabKey (THIS->dpy, keycode, modifiers, window);
1008		1342
1009	bool	1343	bool
1010	rxvt_term::grab (U32 eventtime, int sync = 0)	1344	rxvt_term::grab (Time eventtime, int sync = 0)
1011	CODE:	1345	CODE:
1012	{	1346	{
1013	int mode = sync ? GrabModeSync : GrabModeAsync;	1347	int mode = sync ? GrabModeSync : GrabModeAsync;
1014		1348
1015	THIS->perl.grabtime = 0;	1349	THIS->perl.grabtime = 0;
1016		1350
1017	if (!XGrabPointer (THIS->display->display, THIS->vt, 0,	1351	if (!XGrabPointer (THIS->dpy, THIS->vt, 0,
1018	ButtonPressMask \| ButtonReleaseMask \| EnterWindowMask \| LeaveWindowMask \| PointerMotionMask,	1352	ButtonPressMask \| ButtonReleaseMask \| EnterWindowMask \| LeaveWindowMask \| PointerMotionMask,
1019	mode, mode, None, GRAB_CURSOR, eventtime))	1353	mode, mode, None, GRAB_CURSOR, eventtime))
1020	if (!XGrabKeyboard (THIS->display->display, THIS->vt, 0, mode, mode, eventtime))	1354	if (!XGrabKeyboard (THIS->dpy, THIS->vt, 0, mode, mode, eventtime))
1021	THIS->perl.grabtime = eventtime;	1355	THIS->perl.grabtime = eventtime;
1022	else	1356	else
1023	XUngrabPointer (THIS->display->display, eventtime);	1357	XUngrabPointer (THIS->dpy, eventtime);
1024		1358
1025	RETVAL = !!THIS->perl.grabtime;	1359	RETVAL = !!THIS->perl.grabtime;
1026	}	1360	}
1027	OUTPUT:	1361	OUTPUT:
1028	RETVAL	1362	RETVAL
1029		1363
1030	void	1364	void
1031	rxvt_term::allow_events_async ()	1365	rxvt_term::allow_events_async ()
1032	CODE:	1366	CODE:
1033	XAllowEvents (THIS->display->display, AsyncBoth, THIS->perl.grabtime);	1367	XAllowEvents (THIS->dpy, AsyncBoth, THIS->perl.grabtime);
1034		1368
1035	void	1369	void
1036	rxvt_term::allow_events_sync ()	1370	rxvt_term::allow_events_sync ()
1037	CODE:	1371	CODE:
1038	XAllowEvents (THIS->display->display, SyncBoth, THIS->perl.grabtime);	1372	XAllowEvents (THIS->dpy, SyncBoth, THIS->perl.grabtime);
1039		1373
1040	void	1374	void
1041	rxvt_term::allow_events_replay ()	1375	rxvt_term::allow_events_replay ()
1042	CODE:	1376	CODE:
1043	XAllowEvents (THIS->display->display, ReplayPointer, THIS->perl.grabtime);	1377	XAllowEvents (THIS->dpy, ReplayPointer, THIS->perl.grabtime);
1044	XAllowEvents (THIS->display->display, ReplayKeyboard, THIS->perl.grabtime);	1378	XAllowEvents (THIS->dpy, ReplayKeyboard, THIS->perl.grabtime);
1045		1379
1046	void	1380	void
1047	rxvt_term::ungrab ()	1381	rxvt_term::ungrab ()
1048	CODE:	1382	CODE:
1049	ungrab (THIS);	1383	ungrab (THIS);
1050		1384
1051	int	1385	int
		1386	rxvt_term::XStringToKeysym (octet_string string)
		1387	CODE:
		1388	RETVAL = XStringToKeysym (string);
		1389	OUTPUT: RETVAL
		1390
		1391	char *
		1392	rxvt_term::XKeysymToString (int sym)
		1393	CODE:
		1394	RETVAL = XKeysymToString (sym);
		1395	OUTPUT: RETVAL
		1396
		1397	int
		1398	rxvt_term::XKeysymToKeycode (int sym)
		1399	CODE:
		1400	RETVAL = XKeysymToKeycode (THIS->dpy, sym);
		1401	OUTPUT: RETVAL
		1402
		1403	int
		1404	rxvt_term::XKeycodeToKeysym (int code, int index)
		1405	CODE:
		1406	RETVAL = rxvt_XKeycodeToKeysym (THIS->dpy, code, index);
		1407	OUTPUT: RETVAL
		1408
		1409	int
1052	rxvt_term::strwidth (SV *str)	1410	rxvt_term::strwidth (SV *str)
1053	CODE:	1411	CODE:
1054	{	1412	{
1055	wchar_t *wstr = sv2wcs (str);	1413	wchar_t *wstr = sv2wcs (str);
1056		1414
1057	rxvt_push_locale (THIS->locale);	1415	rxvt_push_locale (THIS->locale);
1058	RETVAL = wcswidth (wstr, wcslen (wstr));	1416	RETVAL = 0;
		1417	for (wchar_t wc = wstr; wc; wc++)
		1418	{
		1419	int w = WCWIDTH (*wc);
		1420
		1421	if (w)
		1422	RETVAL += max (w, 1);
		1423	}
1059	rxvt_pop_locale ();	1424	rxvt_pop_locale ();
1060		1425
1061	free (wstr);	1426	free (wstr);
1062	}	1427	}
1063	OUTPUT:	1428	OUTPUT:
…		…
1065		1430
1066	SV *	1431	SV *
1067	rxvt_term::locale_encode (SV *str)	1432	rxvt_term::locale_encode (SV *str)
1068	CODE:	1433	CODE:
1069	{	1434	{
		1435	if (!SvOK (str))
		1436	XSRETURN_UNDEF;
		1437
1070	wchar_t *wstr = sv2wcs (str);	1438	wchar_t *wstr = sv2wcs (str);
1071		1439
1072	rxvt_push_locale (THIS->locale);	1440	rxvt_push_locale (THIS->locale);
1073	char *mbstr = rxvt_wcstombs (wstr);	1441	char *mbstr = rxvt_wcstombs (wstr);
1074	rxvt_pop_locale ();	1442	rxvt_pop_locale ();
1075		1443
1076	free (wstr);	1444	free (wstr);
1077		1445
1078	RETVAL = taint_if (newSVpv (mbstr, 0), str);	1446	RETVAL = newSVpv (mbstr, 0);
1079	free (mbstr);	1447	free (mbstr);
1080	}	1448	}
1081	OUTPUT:	1449	OUTPUT:
1082	RETVAL	1450	RETVAL
1083		1451
1084	SV *	1452	SV *
1085	rxvt_term::locale_decode (SV *octets)	1453	rxvt_term::locale_decode (SV *octets)
1086	CODE:	1454	CODE:
1087	{	1455	{
		1456	if (!SvOK (octets))
		1457	XSRETURN_UNDEF;
		1458
1088	STRLEN len;	1459	STRLEN len;
1089	char *data = SvPVbyte (octets, len);	1460	char *data = SvPVbyte (octets, len);
1090		1461
1091	rxvt_push_locale (THIS->locale);	1462	rxvt_push_locale (THIS->locale);
1092	wchar_t *wstr = rxvt_mbstowcs (data, len);	1463	wchar_t *wstr = rxvt_mbstowcs (data, len);
1093	rxvt_pop_locale ();	1464	rxvt_pop_locale ();
1094		1465
1095	RETVAL = taint_if (wcs2sv (wstr), octets);	1466	RETVAL = wcs2sv (wstr);
1096	free (wstr);	1467	free (wstr);
1097	}	1468	}
1098	OUTPUT:	1469	OUTPUT:
1099	RETVAL	1470	RETVAL
1100		1471
1101	#define TERM_OFFSET(sym) offsetof (TermWin_t, sym)	1472	#define TERM_OFFSET(sym) offsetof (TermWin_t, sym)
1102		1473
1103	#define TERM_OFFSET_width TERM_OFFSET(width)	1474	#define TERM_OFFSET_width TERM_OFFSET(width)
1104	#define TERM_OFFSET_height TERM_OFFSET(height)	1475	#define TERM_OFFSET_height TERM_OFFSET(height)
1105	#define TERM_OFFSET_fwidth TERM_OFFSET(fwidth)	1476	#define TERM_OFFSET_fwidth TERM_OFFSET(fwidth)
1106	#define TERM_OFFSET_fheight TERM_OFFSET(fheight)	1477	#define TERM_OFFSET_fheight TERM_OFFSET(fheight)
1107	#define TERM_OFFSET_fbase TERM_OFFSET(fbase)	1478	#define TERM_OFFSET_fbase TERM_OFFSET(fbase)
1108	#define TERM_OFFSET_nrow TERM_OFFSET(nrow)	1479	#define TERM_OFFSET_nrow TERM_OFFSET(nrow)
1109	#define TERM_OFFSET_ncol TERM_OFFSET(ncol)	1480	#define TERM_OFFSET_ncol TERM_OFFSET(ncol)
1110	#define TERM_OFFSET_focus TERM_OFFSET(focus)	1481	#define TERM_OFFSET_focus TERM_OFFSET(focus)
1111	#define TERM_OFFSET_mapped TERM_OFFSET(mapped)	1482	#define TERM_OFFSET_mapped TERM_OFFSET(mapped)
		1483	#define TERM_OFFSET_int_bwidth TERM_OFFSET(int_bwidth)
		1484	#define TERM_OFFSET_ext_bwidth TERM_OFFSET(ext_bwidth)
		1485	#define TERM_OFFSET_lineSpace TERM_OFFSET(lineSpace)
		1486	#define TERM_OFFSET_letterSpace TERM_OFFSET(letterSpace)
1112	#define TERM_OFFSET_saveLines TERM_OFFSET(saveLines)	1487	#define TERM_OFFSET_saveLines TERM_OFFSET(saveLines)
1113	#define TERM_OFFSET_total_rows TERM_OFFSET(total_rows)	1488	#define TERM_OFFSET_total_rows TERM_OFFSET(total_rows)
1114	#define TERM_OFFSET_top_row TERM_OFFSET(top_row)	1489	#define TERM_OFFSET_top_row TERM_OFFSET(top_row)
1115		1490
1116	int	1491	int
1117	rxvt_term::width ()	1492	rxvt_term::width (int new_value = NO_INIT)
1118	ALIAS:	1493	ALIAS:
1119	width = TERM_OFFSET_width	1494	width = TERM_OFFSET_width
1120	height = TERM_OFFSET_height	1495	height = TERM_OFFSET_height
1121	fwidth = TERM_OFFSET_fwidth	1496	fwidth = TERM_OFFSET_fwidth
1122	fheight = TERM_OFFSET_fheight	1497	fheight = TERM_OFFSET_fheight
1123	fbase = TERM_OFFSET_fbase	1498	fbase = TERM_OFFSET_fbase
1124	nrow = TERM_OFFSET_nrow	1499	nrow = TERM_OFFSET_nrow
1125	ncol = TERM_OFFSET_ncol	1500	ncol = TERM_OFFSET_ncol
1126	focus = TERM_OFFSET_focus	1501	focus = TERM_OFFSET_focus
1127	mapped = TERM_OFFSET_mapped	1502	mapped = TERM_OFFSET_mapped
		1503	int_bwidth = TERM_OFFSET_int_bwidth
		1504	ext_bwidth = TERM_OFFSET_ext_bwidth
		1505	lineSpace = TERM_OFFSET_lineSpace
		1506	letterSpace = TERM_OFFSET_letterSpace
1128	saveLines = TERM_OFFSET_saveLines	1507	saveLines = TERM_OFFSET_saveLines
1129	total_rows = TERM_OFFSET_total_rows	1508	total_rows = TERM_OFFSET_total_rows
1130	top_row = TERM_OFFSET_top_row	1509	top_row = TERM_OFFSET_top_row
1131	CODE:	1510	CODE:
1132	RETVAL = (int )((char *)THIS + ix);	1511	RETVAL = (int )((char *)THIS + ix);
		1512	if (items > 1)
		1513	(int )((char *)THIS + ix) = new_value;
1133	OUTPUT:	1514	OUTPUT:
1134	RETVAL	1515	RETVAL
1135		1516
1136	unsigned int	1517	unsigned int
1137	rxvt_term::ModLevel3Mask ()	1518	rxvt_term::ModLevel3Mask ()
1138	ALIAS:	1519	ALIAS:
1139	ModLevel3Mask = 0	1520	ModLevel3Mask = 0
1140	ModMetaMask = 1	1521	ModMetaMask = 1
1141	ModNumLockMask = 2	1522	ModNumLockMask = 2
		1523	current_screen = 3
		1524	hidden_cursor = 4
		1525	priv_modes = 5
1142	CODE:	1526	CODE:
1143	switch (ix)	1527	switch (ix)
1144	{	1528	{
1145	case 0: RETVAL = THIS->ModLevel3Mask; break;	1529	case 0: RETVAL = THIS->ModLevel3Mask; break;
1146	case 1: RETVAL = THIS->ModMetaMask; break;	1530	case 1: RETVAL = THIS->ModMetaMask; break;
1147	case 2: RETVAL = THIS->ModNumLockMask; break;	1531	case 2: RETVAL = THIS->ModNumLockMask; break;
		1532	case 3: RETVAL = THIS->current_screen; break;
		1533	#ifdef CURSOR_BLINK
		1534	case 4: RETVAL = THIS->hidden_cursor; break;
		1535	#else
		1536	case 4: RETVAL = 0; break;
		1537	#endif
		1538	case 5: RETVAL = THIS->priv_modes; break;
1148	}	1539	}
1149	OUTPUT:	1540	OUTPUT:
1150	RETVAL	1541	RETVAL
1151		1542
1152	char *	1543	char *
…		…
1162	}	1553	}
1163	OUTPUT:	1554	OUTPUT:
1164	RETVAL	1555	RETVAL
1165		1556
1166	SV *	1557	SV *
1167	rxvt_term::_env ()	1558	rxvt_term::envv ()
		1559	ALIAS:
		1560	argv = 1
1168	CODE:	1561	PPCODE:
1169	{	1562	{
1170	if (THIS->envv)	1563	stringvec *vec = ix ? THIS->argv : THIS->envv;
1171	{
1172	AV *av = newAV ();
1173		1564
		1565	EXTEND (SP, vec->size ());
		1566
1174	for (char **i = THIS->envv->begin (); i != THIS->envv->end (); ++i)	1567	for (char **i = vec->begin (); i != vec->end (); ++i)
1175	if (*i)	1568	if (*i)
1176	av_push (av, newSVpv (*i, 0));	1569	PUSHs (sv_2mortal (newSVpv (*i, 0)));
1177
1178	RETVAL = newRV_noinc ((SV *)av);
1179	}
1180	else
1181	RETVAL = &PL_sv_undef;
1182	}	1570	}
1183	OUTPUT:
1184	RETVAL
1185		1571
1186	int	1572	int
1187	rxvt_term::pty_ev_events (int events = EVENT_UNDEF)	1573	rxvt_term::pty_ev_events (int events = ev::UNDEF)
1188	CODE:	1574	CODE:
1189	RETVAL = THIS->pty_ev.events;	1575	RETVAL = THIS->pty_ev.events;
1190	if (events != EVENT_UNDEF)	1576	if (events != ev::UNDEF)
1191	THIS->pty_ev.set (events);	1577	THIS->pty_ev.set (events);
1192	OUTPUT:	1578	OUTPUT:
1193	RETVAL	1579	RETVAL
1194		1580
1195	U32	1581	int
		1582	rxvt_term::pty_fd ()
		1583	CODE:
		1584	RETVAL = THIS->pty->pty;
		1585	OUTPUT:
		1586	RETVAL
		1587
		1588	Window
1196	rxvt_term::parent ()	1589	rxvt_term::parent ()
1197	CODE:	1590	CODE:
1198	RETVAL = (U32)THIS->parent [0];	1591	RETVAL = THIS->parent;
1199	OUTPUT:	1592	OUTPUT:
1200	RETVAL	1593	RETVAL
1201		1594
1202	U32	1595	int
		1596	rxvt_term::parent_x ()
		1597	CODE:
		1598	RETVAL = THIS->parent_x;
		1599	OUTPUT:
		1600	RETVAL
		1601
		1602	int
		1603	rxvt_term::parent_y ()
		1604	CODE:
		1605	RETVAL = THIS->parent_y;
		1606	OUTPUT:
		1607	RETVAL
		1608
		1609	Window
1203	rxvt_term::vt ()	1610	rxvt_term::vt ()
1204	CODE:	1611	CODE:
1205	RETVAL = (U32)THIS->vt;	1612	RETVAL = THIS->vt;
1206	OUTPUT:	1613	OUTPUT:
1207	RETVAL	1614	RETVAL
1208		1615
1209	void	1616	void
1210	rxvt_term::vt_emask_add (U32 emask)	1617	rxvt_term::vt_emask_add (U32 emask)
…		…
1219	THIS->rstyle = new_rstyle;	1626	THIS->rstyle = new_rstyle;
1220	OUTPUT:	1627	OUTPUT:
1221	RETVAL	1628	RETVAL
1222		1629
1223	int	1630	int
1224	rxvt_term::view_start (int newval = 1)	1631	rxvt_term::view_start (int newval = 0)
1225	PROTOTYPE: $;$	1632	PROTOTYPE: $;$
1226	CODE:	1633	CODE:
1227	{	1634	{
1228	RETVAL = THIS->view_start;	1635	RETVAL = THIS->view_start;
1229		1636	if (items > 1)
1230	if (newval <= 0)
1231	THIS->scr_changeview (max (newval, THIS->top_row));	1637	THIS->scr_changeview (newval);
1232	}	1638	}
1233	OUTPUT:	1639	OUTPUT:
1234	RETVAL	1640	RETVAL
1235		1641
1236	void	1642	void
		1643	rxvt_term::set_urgency (bool enable)
		1644
		1645	void
		1646	rxvt_term::focus_in ()
		1647
		1648	void
		1649	rxvt_term::focus_out ()
		1650
		1651	void
		1652	rxvt_term::key_press (unsigned int state, unsigned int keycode, Time time = CurrentTime)
		1653	ALIAS:
		1654	key_release = 1
		1655	CODE:
		1656	{
		1657	XKeyEvent xkey;
		1658
		1659	memset (&xkey, 0, sizeof (xkey));
		1660
		1661	xkey.time = time;
		1662	xkey.state = state;
		1663	xkey.keycode = keycode;
		1664
		1665	xkey.type = ix ? KeyRelease : KeyPress;
		1666	xkey.display = THIS->dpy;
		1667	xkey.window = THIS->vt;
		1668	xkey.root = THIS->display->root;
		1669	xkey.subwindow = THIS->vt;
		1670
		1671	if (ix)
		1672	THIS->key_release (xkey);
		1673	else
		1674	THIS->key_press (xkey);
		1675	}
		1676
		1677	void
1237	rxvt_term::want_refresh ()	1678	rxvt_term::want_refresh ()
1238	CODE:	1679	CODE:
1239	THIS->want_refresh = 1;	1680	THIS->want_refresh = 1;
		1681	THIS->refresh_check ();
		1682
		1683	void
		1684	rxvt_term::refresh_check ()
1240		1685
1241	void	1686	void
1242	rxvt_term::ROW_t (int row_number, SV *new_text = 0, int start_col = 0, int start_ofs = 0, int max_len = MAX_COLS)	1687	rxvt_term::ROW_t (int row_number, SV *new_text = 0, int start_col = 0, int start_ofs = 0, int max_len = MAX_COLS)
1243	PPCODE:	1688	PPCODE:
1244	{	1689	{
…		…
1247		1692
1248	line_t &l = ROW(row_number);	1693	line_t &l = ROW(row_number);
1249		1694
1250	if (GIMME_V != G_VOID)	1695	if (GIMME_V != G_VOID)
1251	{	1696	{
1252	wchar_t *wstr = new wchar_t [THIS->ncol];	1697	wchar_t *wstr = rxvt_temp_buf<wchar_t> (THIS->ncol);
1253		1698
1254	for (int col = 0; col < THIS->ncol; col++)	1699	for (int col = 0; col < THIS->ncol; col++)
1255	wstr [col] = l.t [col];	1700	wstr [col] = l.t [col];
1256		1701
1257	XPUSHs (taint (sv_2mortal (wcs2sv (wstr, THIS->ncol))));	1702	XPUSHs (sv_2mortal (wcs2sv (wstr, THIS->ncol)));
1258
1259	delete [] wstr;
1260	}	1703	}
1261		1704
1262	if (new_text)	1705	if (new_text)
1263	{	1706	{
1264	wchar_t *wstr = sv2wcs (new_text);	1707	wchar_t *wstr = sv2wcs (new_text);
1265		1708
1266	int len = min (wcslen (wstr) - start_ofs, max_len);	1709	int len = min (wcslen (wstr) - start_ofs, max_len);
1267		1710
1268	if (!IN_RANGE_INC (start_col, 0, THIS->ncol - len))	1711	if (start_col < 0 \|\| start_col + len > THIS->ncol)
1269	{	1712	{
1270	free (wstr);	1713	free (wstr);
1271	croak ("new_text extends beyond horizontal margins");	1714	croak ("new_text extends beyond horizontal margins");
1272	}	1715	}
1273		1716
…		…
1305	{	1748	{
1306	if (!SvROK (new_rend) \|\| SvTYPE (SvRV (new_rend)) != SVt_PVAV)	1749	if (!SvROK (new_rend) \|\| SvTYPE (SvRV (new_rend)) != SVt_PVAV)
1307	croak ("new_rend must be arrayref");	1750	croak ("new_rend must be arrayref");
1308		1751
1309	AV av = (AV )SvRV (new_rend);	1752	AV av = (AV )SvRV (new_rend);
1310	int len = min (av_len (av) + 1 - start_ofs, max_len);	1753	int len = min (AvFILL (av) + 1 - start_ofs, max_len);
1311		1754
1312	if (!IN_RANGE_INC (start_col, 0, THIS->ncol - len))	1755	if (start_col < 0 \|\| start_col + len > THIS->ncol)
1313	croak ("new_rend array extends beyond horizontal margins");	1756	croak ("new_rend array extends beyond horizontal margins");
1314		1757
1315	for (int col = start_col; col < start_col + len; col++)	1758	for (int col = start_col; col < start_col + len; col++)
1316	{	1759	{
1317	rend_t r = SvIV (*av_fetch (av, start_ofs + col - start_col, 1)) & ~RS_fontMask;	1760	rend_t r = SvIV (*av_fetch (av, start_ofs + col - start_col, 1)) & ~RS_fontMask;
…		…
1357	rxvt_term::special_encode (SV *string)	1800	rxvt_term::special_encode (SV *string)
1358	CODE:	1801	CODE:
1359	{	1802	{
1360	wchar_t *wstr = sv2wcs (string);	1803	wchar_t *wstr = sv2wcs (string);
1361	int wlen = wcslen (wstr);	1804	int wlen = wcslen (wstr);
1362	wchar_t *rstr = new wchar_t [wlen]; // cannot become longer	1805	wchar_t rstr = rxvt_temp_buf<wchar_t> (wlen 2); // cannot become longer
1363		1806
1364	rxvt_push_locale (THIS->locale);	1807	rxvt_push_locale (THIS->locale);
1365		1808
1366	wchar_t *r = rstr;	1809	wchar_t *r = rstr;
1367	for (wchar_t s = wstr; s; s++)	1810	for (wchar_t s = wstr; s; s++)
		1811	{
		1812	int w = WCWIDTH (*s);
		1813
1368	if (wcwidth (*s) == 0)	1814	if (w == 0)
1369	{	1815	{
1370	if (r == rstr)	1816	if (r == rstr)
1371	croak ("leading combining character unencodable");	1817	croak ("leading combining character unencodable");
1372		1818
1373	unicode_t n = rxvt_compose (r[-1], *s);	1819	unicode_t n = rxvt_compose (r[-1], *s);
1374	if (n == NOCHAR)	1820	if (n == NOCHAR)
1375	n = rxvt_composite.compose (r[-1], *s);	1821	n = rxvt_composite.compose (r[-1], *s);
1376		1822
1377	r[-1] = n;	1823	r[-1] = n;
1378	}	1824	}
1379	#if !UNICODE_3	1825	#if !UNICODE_3
1380	else if (*s >= 0x10000)	1826	else if (*s >= 0x10000)
1381	r++ = rxvt_composite.compose (s);	1827	r++ = rxvt_composite.compose (s);
1382	#endif	1828	#endif
1383	else	1829	else
1384	r++ = s;	1830	r++ = s;
		1831
		1832	// the *2 above only allows wcwidth <= 2
		1833	if (w > 1)
		1834	*r++ = NOCHAR;
		1835	}
1385		1836
1386	rxvt_pop_locale ();	1837	rxvt_pop_locale ();
1387		1838
		1839	free (wstr);
1388	RETVAL = taint_if (wcs2sv (rstr, r - rstr), string);	1840	RETVAL = wcs2sv (rstr, r - rstr);
1389
1390	delete [] rstr;
1391	}	1841	}
1392	OUTPUT:	1842	OUTPUT:
1393	RETVAL	1843	RETVAL
1394		1844
1395	SV *	1845	SV *
1396	rxvt_term::special_decode (SV *text)	1846	rxvt_term::special_decode (SV *text)
1397	CODE:	1847	CODE:
1398	{	1848	{
1399	wchar_t *wstr = sv2wcs (text);	1849	wchar_t *wstr = sv2wcs (text);
1400	int wlen = wcslen (wstr);
1401	int dlen = 0;	1850	int dlen = 0;
1402		1851
1403	// find length	1852	// find length
1404	for (wchar_t s = wstr; s; s++)	1853	for (wchar_t s = wstr; s; s++)
1405	if (*s == NOCHAR)	1854	if (*s == NOCHAR)
1406	;	1855	;
1407	else if (IS_COMPOSE (*s))	1856	else if (IS_COMPOSE (*s))
1408	dlen += rxvt_composite.expand (*s, 0);	1857	dlen += rxvt_composite.expand (*s);
1409	else	1858	else
1410	dlen++;	1859	dlen++;
1411		1860
1412	wchar_t *rstr = new wchar_t [dlen];	1861	wchar_t *rstr = rxvt_temp_buf<wchar_t> (dlen);
1413		1862
1414	// decode	1863	// decode
1415	wchar_t *r = rstr;	1864	wchar_t *r = rstr;
1416	for (wchar_t s = wstr; s; s++)	1865	for (wchar_t s = wstr; s; s++)
1417	if (*s == NOCHAR)	1866	if (*s == NOCHAR)
…		…
1419	else if (IS_COMPOSE (*s))	1868	else if (IS_COMPOSE (*s))
1420	r += rxvt_composite.expand (*s, r);	1869	r += rxvt_composite.expand (*s, r);
1421	else	1870	else
1422	r++ = s;	1871	r++ = s;
1423		1872
		1873	free (wstr);
1424	RETVAL = taint_if (wcs2sv (rstr, r - rstr), text);	1874	RETVAL = wcs2sv (rstr, r - rstr);
1425
1426	delete [] rstr;
1427	}	1875	}
1428	OUTPUT:	1876	OUTPUT:
1429	RETVAL	1877	RETVAL
1430		1878
1431	void	1879	void
1432	rxvt_term::_resource (char name, int index, SV newval = 0)	1880	rxvt_term::_resource (octet_string name, int index, SV *newval = 0)
1433	PPCODE:	1881	PPCODE:
1434	{	1882	{
1435	struct resval { const char *name; int value; } rslist [] = {	1883	static const struct resval { const char name; int value; } rs, rslist [] = {
1436	# define def(name) { # name, Rs_ ## name },	1884	# define def(name) { # name, Rs_ ## name },
1437	# define reserve(name,count)	1885	# define reserve(name,count)
1438	# include "rsinc.h"	1886	# include "rsinc.h"
1439	# undef def	1887	# undef def
1440	# undef reserve	1888	# undef reserve
1441	};	1889	};
1442		1890
1443	struct resval *rs = rslist + sizeof (rslist) / sizeof (rslist [0]);	1891	rs = rslist + ecb_array_length (rslist);
1444		1892
		1893	if (*name)
1445	do {	1894	{
		1895	do {
1446	if (rs-- == rslist)	1896	if (rs-- == rslist)
1447	croak ("no such resource '%s', requested", name);	1897	croak ("no such resource '%s', requested", name);
1448	} while (strcmp (name, rs->name));	1898	} while (strcmp (name, rs->name));
1449		1899
1450	index += rs->value;	1900	index += rs->value;
		1901	}
		1902	else
		1903	{
		1904	--rs;
		1905	name = (octet_string)"";
		1906	}
1451		1907
1452	if (!IN_RANGE_EXC (index, 0, NUM_RESOURCES))	1908	if (!IN_RANGE_EXC (index, 0, NUM_RESOURCES))
1453	croak ("requested out-of-bound resource %s+%d,", name, index - rs->value);	1909	croak ("requested out-of-bound resource %s+%d,", name, index - rs->value);
1454		1910
1455	if (GIMME_V != G_VOID)	1911	if (GIMME_V != G_VOID)
1456	XPUSHs (THIS->rs [index] ? sv_2mortal (taint (newSVpv (THIS->rs [index], 0))) : &PL_sv_undef);	1912	XPUSHs (THIS->rs [index] ? sv_2mortal (newSVpv (THIS->rs [index], 0)) : &PL_sv_undef);
1457		1913
1458	if (newval)	1914	if (newval)
1459	{	1915	{
1460	if (SvOK (newval))	1916	if (SvOK (newval))
1461	{	1917	{
…		…
1467	THIS->rs [index] = 0;	1923	THIS->rs [index] = 0;
1468	}	1924	}
1469	}	1925	}
1470		1926
1471	const char *	1927	const char *
1472	rxvt_term::x_resource (const char *name)	1928	rxvt_term::x_resource (octet_string name)
1473	CLEANUP:
1474	SvTAINTED_on (ST (0));
1475		1929
1476	bool	1930	bool
1477	rxvt_term::option (U32 optval, int set = -1)	1931	rxvt_term::option (U8 optval, int set = -1)
1478	CODE:	1932	CODE:
1479	{	1933	{
1480	RETVAL = THIS->options & optval;	1934	RETVAL = THIS->option (optval);
1481		1935
1482	if (set >= 0)	1936	if (set >= 0)
1483	{	1937	{
1484	if (set)
1485	THIS->options \|= optval;	1938	THIS->set_option (optval, set);
1486	else
1487	THIS->options &= ~optval;
1488		1939
		1940	if (THIS->init_done) // avoid doing this before START
1489	switch (optval)	1941	switch (optval)
1490	{	1942	{
1491	case Opt_skipBuiltinGlyphs:	1943	case Opt_skipBuiltinGlyphs:
1492	THIS->set_fonts ();	1944	THIS->set_fonts ();
1493	THIS->scr_remap_chars ();	1945	THIS->scr_remap_chars ();
1494	THIS->scr_touch (true);	1946	THIS->scr_touch (true);
1495	THIS->want_refresh = 1;	1947	THIS->want_refresh = 1;
		1948	THIS->refresh_check ();
1496	break;	1949	break;
		1950	#ifdef CURSOR_BLINK
		1951	case Opt_cursorBlink:
		1952	THIS->cursor_blink_reset ();
		1953	break;
		1954	#endif
1497		1955
1498	case Opt_cursorUnderline:	1956	case Opt_cursorUnderline:
		1957	THIS->cursor_type = set ? 1 : 0;
1499	THIS->want_refresh = 1;	1958	THIS->want_refresh = 1;
		1959	THIS->refresh_check ();
1500	break;	1960	break;
1501		1961
1502	# case Opt_scrollBar_floating:	1962	# case Opt_scrollBar_floating:
1503	# case Opt_scrollBar_right:	1963	# case Opt_scrollBar_right:
1504	# THIS->resize_all_windows (THIS->width, THIS->height, 1);	1964	# THIS->resize_all_windows (THIS->width, THIS->height, 1);
1505	# break;	1965	# break;
1506	}	1966	}
1507	}	1967	}
1508	}	1968	}
1509	OUTPUT:	1969	OUTPUT:
1510	RETVAL	1970	RETVAL
1511		1971
		1972	SV *
		1973	rxvt_term::lookup_keysym (int keysym, unsigned int state)
		1974	CODE:
		1975	{
		1976	keysym_t *key = THIS->keyboard->lookup_keysym (THIS, keysym, state);
		1977	RETVAL = key ? sv_2mortal (newSVpv (key->str, 0)) : &PL_sv_undef;
		1978	}
		1979	OUTPUT:
		1980	RETVAL
		1981
1512	bool	1982	bool
1513	rxvt_term::parse_keysym (char keysym, char str)	1983	rxvt_term::bind_action (octet_string keysym, octet_string action)
		1984	ALIAS:
		1985	parse_keysym = 1
1514	CODE:	1986	CODE:
1515	RETVAL = 0 < THIS->parse_keysym (keysym, str);	1987	RETVAL = 0 < THIS->bind_action (keysym, action);
1516	THIS->keyboard->register_done ();	1988	THIS->keyboard->register_done ();
1517	OUTPUT:	1989	OUTPUT:
1518	RETVAL	1990	RETVAL
		1991
		1992	void
		1993	rxvt_term::register_command (int keysym, unsigned int state, SV *str)
		1994	CODE:
		1995	wchar_t *wstr = sv2wcs (str);
		1996	THIS->keyboard->register_action (keysym, state, wstr);
		1997	free (wstr);
1519		1998
1520	void	1999	void
1521	rxvt_term::screen_cur (...)	2000	rxvt_term::screen_cur (...)
1522	PROTOTYPE: $;$$	2001	PROTOTYPE: $;$$
1523	ALIAS:	2002	ALIAS:
…		…
1537	EXTEND (SP, 2);	2016	EXTEND (SP, 2);
1538	PUSHs (sv_2mortal (newSViv (rc.row)));	2017	PUSHs (sv_2mortal (newSViv (rc.row)));
1539	PUSHs (sv_2mortal (newSViv (rc.col)));	2018	PUSHs (sv_2mortal (newSViv (rc.col)));
1540	}	2019	}
1541		2020
1542	if (items == 3)	2021	if (items >= 3)
		2022	{
		2023	rc.row = SvIV (ST (1));
		2024	rc.col = SvIV (ST (2));
		2025
		2026	if (ix == 2)
1543	{	2027	{
		2028	if (rc.col == 0)
		2029	{
		2030	// col == 0 means end of previous line
		2031	rc.row--;
		2032	rc.col = THIS->ncol;
		2033	}
		2034	else if (IN_RANGE_EXC (rc.row, THIS->top_row, THIS->nrow)
		2035	&& rc.col > ROW(rc.row).l)
		2036	{
		2037	// col >= length means while line and add newline
		2038	rc.col = THIS->ncol;
		2039	}
		2040	}
		2041
		2042	clamp_it (rc.col, 0, THIS->ncol);
1544	rc.row = clamp (SvIV (ST (1)), THIS->top_row, THIS->nrow - 1);	2043	clamp_it (rc.row, THIS->top_row, THIS->nrow - 1);
1545	rc.col = clamp (SvIV (ST (2)), 0, THIS->ncol - 1);
1546		2044
1547	if (ix)	2045	if (ix)
1548	THIS->want_refresh = 1;	2046	{
		2047	THIS->selection.screen = THIS->current_screen;
		2048
		2049	THIS->selection_changed ();
		2050	THIS->refresh_check ();
1549	}	2051	}
		2052	}
1550	}	2053	}
1551		2054
1552	char	2055	int
1553	rxvt_term::cur_charset ()	2056	rxvt_term::selection_screen (int screen = -1)
1554	CODE:	2057	CODE:
1555	RETVAL = THIS->charsets [THIS->screen.charset];	2058	RETVAL = THIS->selection.screen;
1556	OUTPUT:	2059	if (screen >= 0)
		2060	THIS->selection.screen = screen;
		2061	OUTPUT:
1557	RETVAL	2062	RETVAL
1558		2063
1559	#void	2064	void
1560	#rxvt_term::selection_clear ()	2065	rxvt_term::selection_request (Time tm, int selnum)
1561		2066
1562	void	2067	void
		2068	rxvt_term::selection_clear (bool clipboard = false)
		2069
		2070	void
1563	rxvt_term::selection_make (U32 eventtime, bool rect = false)	2071	rxvt_term::selection_make (Time eventtime, bool rect = false)
1564	CODE:	2072	CODE:
1565	THIS->selection.op = SELECTION_CONT;	2073	THIS->selection.op = SELECTION_CONT;
1566	THIS->selection.rect = rect;	2074	THIS->selection.rect = rect;
1567	THIS->selection_make (eventtime);	2075	THIS->selection_make (eventtime);
1568		2076
1569	int	2077	int
1570	rxvt_term::selection_grab (U32 eventtime)	2078	rxvt_term::selection_grab (Time eventtime, bool clipboard = false)
1571		2079
1572	void	2080	void
1573	rxvt_term::selection (SV *newtext = 0)	2081	rxvt_term::selection (SV *newtext = 0, bool clipboard = false)
1574	PPCODE:	2082	PPCODE:
1575	{	2083	{
		2084	wchar_t * &text = clipboard ? THIS->selection.clip_text : THIS->selection.text;
		2085	unsigned int &len = clipboard ? THIS->selection.clip_len : THIS->selection.len;
		2086
1576	if (GIMME_V != G_VOID)	2087	if (GIMME_V != G_VOID)
1577	XPUSHs (THIS->selection.text	2088	XPUSHs (text
1578	? taint (sv_2mortal (wcs2sv (THIS->selection.text, THIS->selection.len)))	2089	? sv_2mortal (wcs2sv (text, len))
1579	: &PL_sv_undef);	2090	: &PL_sv_undef);
1580		2091
1581	if (newtext)	2092	if (newtext)
1582	{	2093	{
1583	free (THIS->selection.text);	2094	free (text);
1584		2095
1585	THIS->selection.text = sv2wcs (newtext);	2096	text = sv2wcs (newtext);
1586	THIS->selection.len = wcslen (THIS->selection.text);	2097	len = wcslen (text);
1587	}	2098	}
1588	}	2099	}
		2100
		2101	char
		2102	rxvt_term::cur_charset ()
		2103	CODE:
		2104	RETVAL = THIS->charsets [THIS->screen.charset];
		2105	OUTPUT:
		2106	RETVAL
1589		2107
1590	void	2108	void
1591	rxvt_term::scr_xor_rect (int beg_row, int beg_col, int end_row, int end_col, U32 rstyle1 = RS_RVid, U32 rstyle2 = RS_RVid \| RS_Uline)	2109	rxvt_term::scr_xor_rect (int beg_row, int beg_col, int end_row, int end_col, U32 rstyle1 = RS_RVid, U32 rstyle2 = RS_RVid \| RS_Uline)
1592		2110
1593	void	2111	void
1594	rxvt_term::scr_xor_span (int beg_row, int beg_col, int end_row, int end_col, U32 rstyle = RS_RVid)	2112	rxvt_term::scr_xor_span (int beg_row, int beg_col, int end_row, int end_col, U32 rstyle = RS_RVid)
1595		2113
1596	void	2114	void
1597	rxvt_term::scr_bell ()	2115	rxvt_term::scr_bell ()
		2116
		2117	void
		2118	rxvt_term::scr_recolor (bool refresh = true);
		2119
		2120	void
		2121	rxvt_term::scr_change_screen (int screen)
1598		2122
1599	void	2123	void
1600	rxvt_term::scr_add_lines (SV *string)	2124	rxvt_term::scr_add_lines (SV *string)
1601	CODE:	2125	CODE:
1602	{	2126	{
1603	wchar_t *wstr = sv2wcs (string);	2127	wchar_t *wstr = sv2wcs (string);
1604	THIS->scr_add_lines (wstr, wcslen (wstr));	2128	THIS->scr_add_lines (wstr, wcslen (wstr));
1605	free (wstr);	2129	free (wstr);
1606	}	2130	}
		2131
		2132	void
		2133	rxvt_term::tt_write_user_input (SV *octets)
		2134	INIT:
		2135	STRLEN len;
		2136	char *str = SvPVbyte (octets, len);
		2137	C_ARGS:
		2138	str, len
1607		2139
1608	void	2140	void
1609	rxvt_term::tt_write (SV *octets)	2141	rxvt_term::tt_write (SV *octets)
1610	INIT:	2142	INIT:
1611	STRLEN len;	2143	STRLEN len;
1612	char *str = SvPVbyte (octets, len);	2144	char *str = SvPVbyte (octets, len);
1613	C_ARGS:	2145	C_ARGS:
1614	str, len	2146	str, len
1615		2147
1616	void	2148	void
		2149	rxvt_term::tt_paste (SV *octets)
		2150	INIT:
		2151	STRLEN len;
		2152	char *str = SvPVbyte (octets, len);
		2153	C_ARGS:
		2154	str, len
		2155
		2156	void
1617	rxvt_term::cmd_parse (SV *octets)	2157	rxvt_term::cmd_parse (SV *octets)
1618	CODE:	2158	CODE:
1619	{	2159	{
1620	STRLEN len;	2160	STRLEN len;
1621	char *str = SvPVbyte (octets, len);	2161	char *str = SvPVbyte (octets, len);
…		…
1643	o->self = (HV *)SvRV (RETVAL);	2183	o->self = (HV *)SvRV (RETVAL);
1644	}	2184	}
1645	OUTPUT:	2185	OUTPUT:
1646	RETVAL	2186	RETVAL
1647		2187
		2188	#############################################################################
		2189	# Various X Utility Functions
		2190	#############################################################################
		2191
		2192	void
		2193	rxvt_term::XListProperties (Window window)
		2194	PPCODE:
		2195	{
		2196	int count;
		2197	Atom *props = XListProperties (THIS->dpy, window, &count);
		2198
		2199	EXTEND (SP, count);
		2200	while (count--)
		2201	PUSHs (sv_2mortal (newSVuv ((U32)props [count])));
		2202
		2203	XFree (props);
		2204	}
		2205
		2206	void
		2207	rxvt_term::XGetWindowProperty (Window window, Atom property)
		2208	PPCODE:
		2209	{
		2210	Atom type;
		2211	int format;
		2212	unsigned long nitems;
		2213	unsigned long bytes_after;
		2214	unsigned char *prop;
		2215
		2216	XGetWindowProperty (THIS->dpy, window, property,
		2217	0, 1<<24, 0, AnyPropertyType,
		2218	&type, &format, &nitems, &bytes_after, &prop);
		2219
		2220	if (type != None)
		2221	{
		2222	int elemsize = format == 16 ? sizeof (short)
		2223	: format == 32 ? sizeof (long)
		2224	: 1;
		2225
		2226	EXTEND (SP, 3);
		2227	PUSHs (sv_2mortal (newSVuv ((U32)type)));
		2228	PUSHs (sv_2mortal (newSViv (format)));
		2229	PUSHs (sv_2mortal (newSVpvn ((char )prop, nitems elemsize)));
		2230	XFree (prop);
		2231	}
		2232	}
		2233
		2234	void
		2235	rxvt_term::XChangeProperty (Window window, Atom property, Atom type, int format, SV *data)
		2236	CODE:
		2237	{
		2238	STRLEN len;
		2239	char *data_ = SvPVbyte (data, len);
		2240
		2241	int elemsize = format == 16 ? sizeof (short)
		2242	: format == 32 ? sizeof (long)
		2243	: 1;
		2244
		2245	XChangeProperty (THIS->dpy, window, property,
		2246	type, format, PropModeReplace,
		2247	(unsigned char *)data_, len / elemsize);
		2248	}
		2249
		2250	Atom
		2251	XInternAtom (rxvt_term *term, octet_string atom_name, int only_if_exists = FALSE)
		2252	C_ARGS: term->dpy, atom_name, only_if_exists
		2253
		2254	char *
		2255	XGetAtomName (rxvt_term *term, Atom atom)
		2256	C_ARGS: term->dpy, atom
		2257	CLEANUP:
		2258	XFree (RETVAL);
		2259
		2260	void
		2261	XDeleteProperty (rxvt_term *term, Window window, Atom property)
		2262	C_ARGS: term->dpy, window, property
		2263
		2264	void
		2265	rxvt_term::XShapeQueryVersion ()
		2266	PPCODE:
		2267	int major, minor;
		2268	EXTEND (SP, 2);
		2269	if (XShapeQueryVersion (THIS->display->dpy, &major, &minor))
		2270	{
		2271	PUSHs (sv_2mortal (newSViv (major)));
		2272	PUSHs (sv_2mortal (newSViv (minor)));
		2273	}
		2274
		2275	void
		2276	XShapeCombineRegion (rxvt_term *term, Window dest, int destKind, int xOff, int yOff, Region r, int op)
		2277	C_ARGS: term->display->dpy, dest, destKind, xOff, yOff, r, op
		2278
		2279	void
		2280	XShapeCombineMask (rxvt_term *term, XID dest, int destKind, int xOff, int yOff, Pixmap src, int op)
		2281	C_ARGS: term->display->dpy, dest, destKind, xOff, yOff, src, op
		2282
		2283	void
		2284	XShapeCombineShape (rxvt_term *term, XID dest, int destKind, int xOff, int yOff, Pixmap src, int srcKind, int op)
		2285	C_ARGS: term->display->dpy, dest, destKind, xOff, yOff, src, srcKind, op
		2286
		2287	Window
		2288	rxvt_term::DefaultRootWindow ()
		2289	CODE:
		2290	RETVAL = THIS->display->root;
		2291	OUTPUT:
		2292	RETVAL
		2293
		2294	#if 0
		2295
		2296	Window
		2297	XCreateSimpleWindow (rxvt_term *term, Window parent, int x, int y, unsigned int width, unsigned int height)
		2298	C_ARGS: term->dpy, (Window)parent,
		2299	x, y, width, height, 0,
		2300	term->pix_colors_focused[Color_border],
		2301	term->pix_colors_focused[Color_border]
		2302
		2303	#endif
		2304
		2305	void
		2306	XReparentWindow (rxvt_term *term, Window window, Window parent, int x = 0, int y = 0)
		2307	C_ARGS: term->dpy, window, parent, x, y
		2308
		2309	void
		2310	XMapWindow (rxvt_term *term, Window window)
		2311	C_ARGS: term->dpy, window
		2312
		2313	void
		2314	XUnmapWindow (rxvt_term *term, Window window)
		2315	C_ARGS: term->dpy, window
		2316
		2317	void
		2318	XMoveResizeWindow (rxvt_term *term, Window window, int x, int y, unsigned int width, unsigned int height)
		2319	C_ARGS: term->dpy, window, x, y, width, height
		2320
		2321	void
		2322	rxvt_term::XChangeInput (Window window, U32 add_events, U32 del_events = 0)
		2323	CODE:
		2324	{
		2325	XWindowAttributes attr;
		2326	XGetWindowAttributes (THIS->dpy, window, &attr);
		2327	XSelectInput (THIS->dpy, window, attr.your_event_mask \| add_events & ~del_events);
		2328	}
		2329
		2330	void
		2331	rxvt_term::XTranslateCoordinates (Window src, Window dst, int x, int y)
		2332	PPCODE:
		2333	{
		2334	int dx, dy;
		2335	Window child;
		2336
		2337	if (XTranslateCoordinates (THIS->dpy, src, dst, x, y, &dx, &dy, &child))
		2338	{
		2339	EXTEND (SP, 3);
		2340	PUSHs (sv_2mortal (newSViv (dx)));
		2341	PUSHs (sv_2mortal (newSViv (dy)));
		2342	PUSHs (sv_2mortal (newSVuv (child)));
		2343	}
		2344	}
		2345
		2346	#############################################################################
		2347	# fancy bg bloatstuff (TODO: should be moved up somewhere)
		2348
		2349	bool
		2350	rxvt_term::has_render ()
		2351	CODE:
		2352	RETVAL = THIS->display->flags & DISPLAY_HAS_RENDER;
		2353	OUTPUT:
		2354	RETVAL
		2355
		2356	void
		2357	rxvt_term::background_geometry (bool border = false)
		2358	PPCODE:
		2359	EXTEND (SP, 4);
		2360	PUSHs (sv_2mortal (newSViv (THIS->parent_x + (border ? THIS->window_vt_x : 0))));
		2361	PUSHs (sv_2mortal (newSViv (THIS->parent_y + (border ? THIS->window_vt_y : 0))));
		2362	PUSHs (sv_2mortal (newSViv (border ? THIS->vt_width : THIS->szHint.width )));
		2363	PUSHs (sv_2mortal (newSViv (border ? THIS->vt_height : THIS->szHint.height)));
		2364
		2365	#if HAVE_IMG
		2366
		2367	rxvt_img *
		2368	rxvt_term::new_img (SV *format = &PL_sv_undef, int x = 0, int y = 0, int width = 1, int height = 1)
		2369	CODE:
		2370	XRenderPictFormat *f = SvOK (format)
		2371	? XRenderFindStandardFormat (THIS->dpy, SvIV (format))
		2372	: XRenderFindVisualFormat (THIS->dpy, THIS->visual);
		2373	RETVAL = new rxvt_img (THIS, f, x, y, width, height);
		2374	RETVAL->alloc ();
		2375	OUTPUT:
		2376	RETVAL
		2377
		2378	#if ENABLE_TRANSPARENCY
		2379
		2380	rxvt_img *
		2381	rxvt_term::new_img_from_root ()
		2382	CODE:
		2383	RETVAL = rxvt_img::new_from_root (THIS);
		2384	OUTPUT:
		2385	RETVAL
		2386
		2387	#endif
		2388
		2389	#if HAVE_PIXBUF
		2390
		2391	rxvt_img *
		2392	rxvt_term::new_img_from_file (octet_string filename)
		2393	CODE:
		2394	try
		2395	{
		2396	RETVAL = rxvt_img::new_from_file (THIS, filename);
		2397	}
		2398	catch (const class rxvt_failure_exception &e)
		2399	{
		2400	croak ("new_img_from_file failed");
		2401	}
		2402	OUTPUT:
		2403	RETVAL
		2404
		2405	#endif
		2406
		2407	void
		2408	rxvt_term::clr_background ()
		2409	CODE:
		2410	delete THIS->bg_img;
		2411	THIS->bg_img = 0;
		2412	THIS->bg_flags = rxvt_term::BG_NEEDS_REFRESH;
		2413
		2414	void
		2415	rxvt_term::set_background (rxvt_img *img, bool border = false)
		2416	CODE:
		2417	delete THIS->bg_img;
		2418	THIS->bg_img = 0;
		2419	THIS->bg_flags = rxvt_term::BG_NEEDS_REFRESH;
		2420
		2421	//if (img) // TODO: cannot be false, maybe allow and get rid of clr_background?
		2422	{
		2423	img = img->clone (); // own the img
		2424
		2425	if (img->repeat != RepeatNormal) // X11 only supports RepeatNormal as bg pixmap
		2426	img->sub_rect (0, 0,
		2427	border ? THIS->vt_width : THIS->szHint.width,
		2428	border ? THIS->vt_height : THIS->szHint.height)
		2429	->replace (img);
		2430
		2431	// just in case, should usually be a nop
		2432	img->reify ()
		2433	->replace (img);
		2434
		2435	img->convert_format (XRenderFindVisualFormat (THIS->dpy, THIS->visual), THIS->pix_colors [Color_bg])
		2436	->replace (img);
		2437
		2438	THIS->bg_img = img;
		2439
		2440	if (!border)
		2441	THIS->bg_flags \|= rxvt_term::BG_IS_TRANSPARENT;
		2442	}
		2443
		2444	#endif
		2445
		2446	#############################################################################
		2447	# urxvt::overlay
		2448	#############################################################################
		2449
1648	MODULE = urxvt PACKAGE = urxvt::overlay	2450	MODULE = urxvt PACKAGE = urxvt::overlay
1649		2451
1650	void	2452	void
1651	overlay::set (int x, int y, SV text, SV rend = 0)	2453	overlay::set (int x, int y, SV text, SV rend = 0)
1652		2454
…		…
1657	overlay::hide ()	2459	overlay::hide ()
1658		2460
1659	void	2461	void
1660	overlay::DESTROY ()	2462	overlay::DESTROY ()
1661		2463
		2464	INCLUDE: $PERL <iom_perl.xs -pe s/IOM_MODULE/urxvt/g,s/IOM_CLASS/urxvt/g \|
		2465
		2466	MODULE = urxvt PACKAGE = urxvt::pixbuf PREFIX = gdk_pixbuf_
		2467
		2468	#if HAVE_PIXBUF
		2469
		2470	urxvt::pixbuf gdk_pixbuf_new_from_file (SV *klass, octet_string filename)
		2471	C_ARGS: filename, 0
		2472
		2473	void
		2474	DESTROY (urxvt::pixbuf self)
		2475	CODE:
		2476	g_object_unref (self);
		2477
		2478	#endif
		2479
1662	MODULE = urxvt PACKAGE = urxvt::timer	2480	MODULE = urxvt PACKAGE = urxvt::img
1663		2481
1664	SV *	2482	#if HAVE_IMG
1665	timer::new ()	2483
		2484	# rxvt_img new (rxvt_screen screen, XRenderPictFormat *format, int width, int height)
		2485	# rxvt_img rxvt_img (rxvt_screen screen, XRenderPictFormat *format, int width, int height, Pixmap pixmap);
		2486
		2487	void
		2488	rxvt_img::geometry ()
1666	CODE:	2489	PPCODE:
1667	timer *w = new timer;	2490	EXTEND (SP, 4);
1668	w->start (NOW);	2491	PUSHs (sv_2mortal (newSViv (THIS->x)));
1669	RETVAL = newSVptr ((void *)w, "urxvt::timer");	2492	PUSHs (sv_2mortal (newSViv (THIS->y)));
1670	w->self = (HV *)SvRV (RETVAL);	2493	PUSHs (sv_2mortal (newSViv (THIS->w)));
1671	OUTPUT:	2494	PUSHs (sv_2mortal (newSViv (THIS->h)));
1672	RETVAL
1673		2495
1674	timer *	2496	int
1675	timer::cb (SV *cb)	2497	rxvt_img::x ()
		2498	ALIAS:
		2499	x = 0
		2500	y = 1
		2501	w = 2
		2502	h = 3
1676	CODE:	2503	CODE:
1677	THIS->cb (cb);	2504	switch (ix)
		2505	{
		2506	case 0: RETVAL = THIS->x; break;
		2507	case 1: RETVAL = THIS->y; break;
		2508	case 2: RETVAL = THIS->w; break;
		2509	case 3: RETVAL = THIS->h; break;
		2510	}
		2511	OUTPUT:
1678	RETVAL = THIS;	2512	RETVAL
1679	OUTPUT:
1680	RETVAL
1681		2513
1682	NV	2514	Pixmap
1683	timer::at ()	2515	rxvt_img::pm ()
1684	CODE:	2516	CODE:
1685	RETVAL = THIS->at;	2517	RETVAL = THIS->pm;
1686	OUTPUT:	2518	OUTPUT:
1687	RETVAL	2519	RETVAL
1688		2520
1689	timer *	2521	void
1690	timer::interval (NV interval)	2522	rxvt_img::fill (SV *c, int x = 0, int y = 0, int w = THIS->w, int h = THIS->h)
		2523	PROTOTYPE: $;$$$$
		2524	INIT:
		2525	rxvt_screen screen;
		2526	screen.set (THIS->d);
		2527	rgba cc = parse_rgba (c, &screen);
		2528	C_ARGS: cc, x, y, w, h
		2529
		2530	void
		2531	rxvt_img::DESTROY ()
		2532	CODE:
		2533	delete THIS;
		2534
		2535	void
		2536	rxvt_img::add_alpha ()
		2537
		2538	void
		2539	rxvt_img::unshare ()
		2540
		2541	void
		2542	rxvt_img::repeat_mode (render_repeat_mode repeat = 0)
1691	CODE:	2543	PPCODE:
1692	THIS->interval = interval;	2544	if (items >= 2)
		2545	THIS->repeat_mode (repeat);
		2546	if (GIMME_V != G_VOID)
		2547	XPUSHs (sv_2mortal (newSViv (THIS->repeat)));
		2548
		2549	void
		2550	rxvt_img::move (int dx, int dy)
		2551
		2552	void
		2553	rxvt_img::brightness (rxvt_img::nv r, rxvt_img::nv g, rxvt_img::nv b, rxvt_img::nv a = 1.)
		2554
		2555	void
		2556	rxvt_img::contrast (rxvt_img::nv r, rxvt_img::nv g, rxvt_img::nv b, rxvt_img::nv a = 1.)
		2557
		2558	void
		2559	rxvt_img::draw (rxvt_img *img, int op = PictOpOver, rxvt_img::nv mask = 1.);
		2560
		2561	rxvt_img *
		2562	rxvt_img::clone ()
		2563
		2564	rxvt_img *
		2565	rxvt_img::reify ()
		2566
		2567	rxvt_img *
		2568	rxvt_img::sub_rect (int x, int y, int width, int height)
		2569
		2570	rxvt_img *
		2571	rxvt_img::blur (int rh, int rv)
		2572
		2573	rxvt_img *
		2574	rxvt_img::muladd (rxvt_img::nv mul, rxvt_img::nv add)
		2575
		2576	rxvt_img *
		2577	rxvt_img::transform (rxvt_img::nv p11, rxvt_img::nv p12, rxvt_img::nv p13, rxvt_img::nv p21, rxvt_img::nv p22, rxvt_img::nv p23, rxvt_img::nv p31, rxvt_img::nv p32, rxvt_img::nv p33)
		2578	INIT:
		2579	rxvt_img::nv matrix[3][3] = {
		2580	{ p11, p12, p13 },
		2581	{ p21, p22, p23 },
		2582	{ p31, p32, p33 }
		2583	};
		2584	C_ARGS: matrix
		2585
		2586	rxvt_img *
		2587	rxvt_img::scale (int new_width, int new_height)
		2588
		2589	rxvt_img *
		2590	rxvt_img::rotate (int x, int y, rxvt_img::nv phi)
		2591
		2592	rxvt_img *
		2593	rxvt_img::tint (SV *c)
		2594	INIT:
		2595	rxvt_screen screen;
		2596	screen.set (THIS->d);
		2597	rgba cc = parse_rgba (c, &screen);
		2598	C_ARGS: cc
		2599
		2600	rxvt_img *
		2601	rxvt_img::shade (rxvt_img::nv factor)
		2602
		2603	rxvt_img *
		2604	rxvt_img::filter (octet_string name, SV *params = &PL_sv_undef)
		2605	CODE:
		2606	rxvt_img::nv *vparams = 0;
		2607	int nparams = 0;
		2608
		2609	if (SvOK (params))
		2610	{
		2611	if (!SvROK (params) \|\| SvTYPE (SvRV (params)) != SVt_PVAV)
		2612	croak ("rxvt_img::filter: params must be an array reference with parameter values");
		2613
		2614	nparams = av_len ((AV *)SvRV (params)) + 1;
		2615	vparams = (rxvt_img::nv )malloc (nparams sizeof (rxvt_img::nv));
		2616
		2617	for (int i = 0; i < nparams; ++i)
		2618	vparams [i] = SvNV (av_fetch ((AV )SvRV (params), i, 1));
		2619	}
		2620
		2621	RETVAL = THIS->filter (name, nparams, vparams);
		2622	free (vparams);
		2623	OUTPUT:
1693	RETVAL = THIS;	2624	RETVAL
1694	OUTPUT:
1695	RETVAL
1696		2625
1697	timer *	2626	#endif
1698	timer::set (NV tstamp)
1699	CODE:
1700	THIS->set (tstamp);
1701	RETVAL = THIS;
1702	OUTPUT:
1703	RETVAL
1704		2627
1705	timer *
1706	timer::start (NV tstamp = THIS->at)
1707	CODE:
1708	THIS->start (tstamp);
1709	RETVAL = THIS;
1710	OUTPUT:
1711	RETVAL
1712
1713	timer *
1714	timer::stop ()
1715	CODE:
1716	THIS->stop ();
1717	RETVAL = THIS;
1718	OUTPUT:
1719	RETVAL
1720
1721	void
1722	timer::DESTROY ()
1723
1724	MODULE = urxvt PACKAGE = urxvt::iow
1725
1726	SV *
1727	iow::new ()
1728	CODE:
1729	iow *w = new iow;
1730	RETVAL = newSVptr ((void *)w, "urxvt::iow");
1731	w->self = (HV *)SvRV (RETVAL);
1732	OUTPUT:
1733	RETVAL
1734
1735	iow *
1736	iow::cb (SV *cb)
1737	CODE:
1738	THIS->cb (cb);
1739	RETVAL = THIS;
1740	OUTPUT:
1741	RETVAL
1742
1743	iow *
1744	iow::fd (int fd)
1745	CODE:
1746	THIS->fd = fd;
1747	RETVAL = THIS;
1748	OUTPUT:
1749	RETVAL
1750
1751	iow *
1752	iow::events (short events)
1753	CODE:
1754	THIS->events = events;
1755	RETVAL = THIS;
1756	OUTPUT:
1757	RETVAL
1758
1759	iow *
1760	iow::start ()
1761	CODE:
1762	THIS->start ();
1763	RETVAL = THIS;
1764	OUTPUT:
1765	RETVAL
1766
1767	iow *
1768	iow::stop ()
1769	CODE:
1770	THIS->stop ();
1771	RETVAL = THIS;
1772	OUTPUT:
1773	RETVAL
1774
1775	void
1776	iow::DESTROY ()
1777
1778

Diff Legend

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

Comparing rxvt-unicode/src/rxvtperl.xs (file contents): Revision 1.67 by root, Sun Jan 15 06:02:41 2006 UTC vs. Revision 1.261 by root, Tue Jul 25 18:06:07 2023 UTC

Diff Legend

Comparing rxvt-unicode/src/rxvtperl.xs (file contents):
Revision 1.67 by root, Sun Jan 15 06:02:41 2006 UTC vs.
Revision 1.261 by root, Tue Jul 25 18:06:07 2023 UTC