ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/rxvt-unicode/src/rxvtperl.xs

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

Diff Legend

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