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.86 by root, Fri Jan 20 22:49:34 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 "unistd.h"	35	#include <unistd.h>
35		36
36	#include "iom.h"	37	#include <X11/extensions/shape.h>
		38
		39	// support old includes (https://bugs.freedesktop.org/show_bug.cgi?id=2799, https://lists.x.org/archives/xorg-arch/2005-March/000004.html)
		40	#ifndef ShapeInput
		41	# define ShapeInput 2
		42	#endif
		43
		44	#include "ev_cpp.h"
37	#include "rxvt.h"	45	#include "rxvt.h"
38	#include "keyboard.h"	46	#include "keyboard.h"
39	#include "rxvtutil.h"	47	#include "rxvtutil.h"
40	#include "rxvtperl.h"	48	#include "rxvtperl.h"
41		49
42	#include "perlxsi.c"	50	#include "perlxsi.c"
43		51
44	#ifdef HAVE_SCROLLBARS
45	# define GRAB_CURSOR THIS->leftptr_cursor	52	#define GRAB_CURSOR THIS->scrollBar.leftptr_cursor
46	#else
47	# define GRAB_CURSOR None
48	#endif
49		53
50	#undef LINENO	54	#undef LINENO
51	#define LINENO(n) MOD (THIS->term_start + int(n), THIS->total_rows)	55	#define LINENO(n) MOD (THIS->term_start + int(n), THIS->total_rows)
52	#undef ROW	56	#undef ROW
53	#define ROW(n) THIS->row_buf [LINENO (n)]	57	#define ROW(n) THIS->row_buf [LINENO (n)]
54		58
55	typedef int CHAINED UNUSED;
56
57	/////////////////////////////////////////////////////////////////////////////	59	/////////////////////////////////////////////////////////////////////////////
		60
		61	typedef char * octet_string;
		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)
		77	{
		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
		114	return c;
		115	}
		116
		117	/////////////////////////////////////////////////////////////////////////////
		118	#endif
58		119
59	static wchar_t *	120	static wchar_t *
60	sv2wcs (SV *sv)	121	sv2wcs (SV *sv)
61	{	122	{
62	STRLEN len;	123	STRLEN len;
…		…
75		136
76	return sv;	137	return sv;
77	}	138	}
78		139
79	static SV *	140	static SV *
80	new_ref (HV *hv, const char *klass)
81	{
82	return sv_bless (newRV ((SV *)hv), gv_stashpv (klass, 1));
83	}
84
85	//TODO: use magic
86	static SV *
87	newSVptr (void *ptr, const char *klass)	141	newSVptr (void *ptr, const char *klass)
88	{	142	{
89	HV *hv = newHV ();	143	HV *hv = newHV ();
90	sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);	144	sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);
91	return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));	145	return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
…		…
113	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);
114		168
115	return (long)mg->mg_ptr;	169	return (long)mg->mg_ptr;
116	}	170	}
117		171
118	#define newSVterm(term) SvREFCNT_inc ((SV *)term->perl.self)	172	#define newSVterm(term) SvREFCNT_inc ((SV *)(term)->perl.self)
119	#define SvTERM(sv) (rxvt_term *)SvPTR (sv, "urxvt::term")	173	#define SvTERM(sv) (rxvt_term *)SvPTR ((sv), "urxvt::term")
120		174
121	/////////////////////////////////////////////////////////////////////////////	175	/////////////////////////////////////////////////////////////////////////////
122		176
123	#define SvWATCHER(sv) (perl_watcher *)SvPTR (sv, "urxvt::watcher")	177	#define SvOVERLAY(sv) (overlay *)SvPTR (sv, "urxvt::overlay")
124		178
125	struct perl_watcher	179	class overlay : overlay_base
126	{	180	{
127	SV *cbsv;	181	rxvt_term *THIS;
		182	AV *overlay_av;
		183	int border;
		184
		185	public:
128	HV *self;	186	HV *self;
129
130	perl_watcher ()
131	: cbsv (0)
132	{
133	}
134
135	~perl_watcher ()
136	{
137	SvREFCNT_dec (cbsv);
138	}
139
140	void cb (SV *cb)
141	{
142	SvREFCNT_dec (cbsv);
143	cbsv = newSVsv (cb);
144	}
145
146	void invoke (const char *type, SV *self, int arg = -1);
147	};
148
149	void
150	perl_watcher::invoke (const char *type, SV *self, int arg)
151	{
152	dSP;
153
154	ENTER;
155	SAVETMPS;
156
157	PUSHMARK (SP);
158
159	XPUSHs (sv_2mortal (self));
160
161	if (arg >= 0)
162	XPUSHs (sv_2mortal (newSViv (arg)));
163
164	PUTBACK;
165	call_sv (cbsv, G_VOID | G_EVAL | G_DISCARD);
166	SPAGAIN;
167
168	PUTBACK;
169	FREETMPS;
170	LEAVE;
171
172	if (SvTRUE (ERRSV))
173	rxvt_warn ("%s callback evaluation error: %s", type, SvPV_nolen (ERRSV));
174	}
175
176	#define newSVtimer(timer) new_ref (timer->self, "urxvt::timer")
177	#define SvTIMER(sv) (timer *)(perl_watcher *)SvPTR (sv, "urxvt::timer")
178
179	struct timer : perl_watcher, time_watcher
180	{
181	tstamp interval;
182
183	timer ()
184	: time_watcher (this, &timer::execute)
185	{
186	}
187
188	void execute (time_watcher &w)
189	{
190	if (interval)
191	start (at + interval);
192
193	invoke ("urxvt::timer", newSVtimer (this));
194	}
195	};
196
197	#define newSViow(iow) new_ref (iow->self, "urxvt::iow")
198	#define SvIOW(sv) (iow *)(perl_watcher *)SvPTR (sv, "urxvt::iow")
199
200	struct iow : perl_watcher, io_watcher
201	{
202	iow ()
203	: io_watcher (this, &iow::execute)
204	{
205	}
206
207	void execute (io_watcher &w, short revents)
208	{
209	invoke ("urxvt::iow", newSViow (this), revents);
210	}
211	};
212
213	#define newSViw(iw) new_ref (iw->self, "urxvt::iw")
214	#define SvIW(sv) (iw *)(perl_watcher *)SvPTR (sv, "urxvt::iw")
215
216	struct iw : perl_watcher, idle_watcher
217	{
218	iw ()
219	: idle_watcher (this, &iw::execute)
220	{
221	}
222
223	void execute (idle_watcher &w)
224	{
225	invoke ("urxvt::iw", newSViw (this));
226	}
227	};
228
229	#define newSVpw(pw) new_ref (pw->self, "urxvt::pw")
230	#define SvPW(sv) (pw *)(perl_watcher *)SvPTR (sv, "urxvt::pw")
231
232	struct pw : perl_watcher, child_watcher
233	{
234	pw ()
235	: child_watcher (this, &pw::execute)
236	{
237	}
238
239	void execute (child_watcher &w, int status)
240	{
241	invoke ("urxvt::pw", newSVpw (this), status);
242	}
243	};
244
245	/////////////////////////////////////////////////////////////////////////////
246
247	#define SvOVERLAY(sv) (overlay *)SvPTR (sv, "urxvt::overlay")
248
249	struct overlay {
250	HV *self;
251	bool visible;
252	rxvt_term *THIS;
253	int x, y, w, h;
254	int border;
255	text_t **text;
256	rend_t **rend;
257		187
258	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);
259	~overlay ();	189	~overlay ();
260		190
261	void show ();	191	void show ();
…		…
265		195
266	void set (int x, int y, SV *str, SV *rend);	196	void set (int x, int y, SV *str, SV *rend);
267	};	197	};
268		198
269	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)
270	: THIS(THIS), x(x_), y(y_), w(w_), h(h_), border(border == 2), visible(false)	200	: THIS(THIS), border(border == 2), overlay_av (0)
271	{	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
272	if (border == 2)	210	if (border == 2)
273	{	211	{
274	w += 2;	212	w += 2;
275	h += 2;	213	h += 2;
276	}	214	}
…		…
314	*rp++ = r;	252	*rp++ = r;
315	}	253	}
316	}	254	}
317		255
318	show ();	256	show ();
319	THIS->want_refresh = 1;
320	}	257	}
321		258
322	overlay::~overlay ()	259	overlay::~overlay ()
323	{	260	{
324	hide ();	261	hide ();
…		…
329	delete [] rend[y];	266	delete [] rend[y];
330	}	267	}
331		268
332	delete [] text;	269	delete [] text;
333	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));
334		283
335	THIS->want_refresh = 1;	284	THIS->want_refresh = 1;
		285	THIS->refresh_check ();
336	}	286	}
337		287
338	void	288	void
339	overlay::show ()	289	overlay::hide ()
340	{	290	{
341	if (visible)	291	if (!overlay_av)
342	return;	292	return;
343		293
344	visible = true;
345
346	AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)THIS->perl.self), "_overlay", 8, 0));
347	av_push (av, newSViv ((long)this));
348	}
349
350	void
351	overlay::hide ()
352	{
353	if (!visible)
354	return;
355
356	visible = false;
357
358	AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)THIS->perl.self), "_overlay", 8, 0));
359
360	int i;	294	int i;
361		295
362	for (i = AvFILL (av); i >= 0; i--)	296	for (i = AvFILL (overlay_av); i >= 0; i--)
363	if (SvIV (*av_fetch (av, i, 1)) == (long)this)	297	if (SvIV (*av_fetch (overlay_av, i, 1)) == (long)this)
364	{
365	av_delete (av, i, G_DISCARD);
366	break;	298	break;
367	}
368		299
369	for (; i < AvFILL (av); i++)	300	for (; i < AvFILL (overlay_av); i++)
370	av_store (av, i, SvREFCNT_inc (*av_fetch (av, i + 1, 0)));	301	av_store (overlay_av, i, SvREFCNT_inc (*av_fetch (overlay_av, i + 1, 0)));
371		302
372	av_pop (av);	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 ();
373	}	310	}
374		311
375	void overlay::swap ()	312	void overlay::swap ()
376	{	313	{
377	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));
378	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));
379		316
380	int ov_w = min (w, THIS->ncol - ov_x);	317	int ov_w = min (w, THIS->ncol - ov_x);
381	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;
382		324
383	for (int y = ov_h; y--; )	325	for (int y = ov_h; y--; )
384	{	326	{
385	text_t *t1 = text [y];	327	text_t *t1 = text [y];
386	rend_t *r1 = rend [y];	328	rend_t *r1 = rend [y];
…		…
422	for (int col = min (AvFILL (av) + 1, w - x - border); col--; )	364	for (int col = min (AvFILL (av) + 1, w - x - border); col--; )
423	this->rend [y][x + col] = SvIV (*av_fetch (av, col, 1));	365	this->rend [y][x + col] = SvIV (*av_fetch (av, col, 1));
424	}	366	}
425		367
426	THIS->want_refresh = 1;	368	THIS->want_refresh = 1;
		369	THIS->refresh_check ();
427	}	370	}
428
429		371
430	/////////////////////////////////////////////////////////////////////////////	372	/////////////////////////////////////////////////////////////////////////////
431		373
		374	#include "iom_perl.h"
		375
		376	/////////////////////////////////////////////////////////////////////////////
		377
432	struct rxvt_perl_interp rxvt_perl;	378	struct rxvt_perl_interp rxvt_perl;
433		379
434	static PerlInterpreter *perl;	380	static PerlInterpreter *perl;
435		381
		382	#if 0 /* we are not a library anymore, so doing this is just not worth it */
		383	/*THINK/TODO: this has the side effect of, of course, not calling destructors. */
		384	/* but therse are not guaranteed anyway... */
436	rxvt_perl_interp::~rxvt_perl_interp ()	385	rxvt_perl_interp::~rxvt_perl_interp ()
437	{	386	{
438	if (perl)	387	if (perl)
439	{	388	{
		389	localise_env set_environ (perl_environ);
440	perl_destruct (perl);	390	perl_destruct (perl);
441	perl_free (perl);	391	perl_free (perl);
		392	PERL_SYS_TERM ();
442	}	393	}
443	}	394	}
		395	#endif
444		396
445	void	397	void
446	rxvt_perl_interp::init (rxvt_term *term)	398	rxvt_perl_interp::init ()
447	{	399	{
448	if (!perl)	400	if (!perl)
449	{	401	{
450	rxvt_push_locale (""); // perl init destroys current locale	402	rxvt_push_locale (""); // perl init destroys current locale
451		403
		404	{
452	perl_environ = rxvt_environ;	405	perl_environ = rxvt_environ;
453	swap (perl_environ, environ);	406	localise_env set_environ (perl_environ);
454		407
455	char *argv[] = {	408	const char *args[] = {
456	"",	409	"",
457	"-e"	410	"-e"
458	"BEGIN {"	411	"BEGIN {"
459	" urxvt->bootstrap;"	412	" urxvt->bootstrap;"
460	" unshift @INC, '" LIBDIR "';"	413	" unshift @INC, '" LIBDIR "';"
461	"}"	414	"}"
462	""	415	""
463	"use urxvt;"	416	"use urxvt;",
		417	0
464	};	418	};
		419	int argc = ecb_array_length (args) - 1;
		420	char **argv = (char **)args;
465		421
		422	PERL_SYS_INIT3 (&argc, &argv, &environ);
466	perl = perl_alloc ();	423	perl = perl_alloc ();
467	perl_construct (perl);	424	perl_construct (perl);
468		425
469	if (perl_parse (perl, xs_init, 2, argv, (char **)NULL)	426	if (perl_parse (perl, xs_init, argc, argv, (char **)NULL)
470	|| perl_run (perl))	427	|| perl_run (perl))
471	{	428	{
472	rxvt_warn ("unable to initialize perl-interpreter, continuing without.\n");	429	rxvt_warn ("unable to initialize perl-interpreter, continuing without.\n");
473		430
474	perl_destruct (perl);	431	perl_destruct (perl);
475	perl_free (perl);	432	perl_free (perl);
476	perl = 0;	433	perl = 0;
477	}	434	}
478		435	}
479	swap (perl_environ, environ);
480		436
481	rxvt_pop_locale ();	437	rxvt_pop_locale ();
482	}	438	}
		439	}
483		440
484	if (perl)	441	void
		442	rxvt_perl_interp::init (rxvt_term *term)
		443	{
		444	init ();
		445
		446	if (perl && !term->perl.self)
485	{	447	{
486	// runs outside of perls ENV	448	// runs outside of perls ENV
487	term->perl.self = (void *)newSVptr ((void *)term, "urxvt::term");	449	term->perl.self = (void *)newSVptr ((void *)term, "urxvt::term");
488	hv_store ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, newRV_noinc ((SV *)newAV ()), 0);	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);
489	}	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);
490	}	527	}
491		528
492	static void	529	static void
493	ungrab (rxvt_term *THIS)	530	ungrab (rxvt_term *THIS)
494	{	531	{
495	if (THIS->perl.grabtime)	532	if (THIS->perl.grabtime)
496	{	533	{
497	XUngrabKeyboard (THIS->display->display, THIS->perl.grabtime);	534	XUngrabKeyboard (THIS->dpy, THIS->perl.grabtime);
498	XUngrabPointer (THIS->display->display, THIS->perl.grabtime);	535	XUngrabPointer (THIS->dpy, THIS->perl.grabtime);
499	THIS->perl.grabtime = 0;	536	THIS->perl.grabtime = 0;
500	}	537	}
501	}	538	}
502		539
503	bool	540	bool
504	rxvt_perl_interp::invoke (rxvt_term *term, hook_type htype, ...)	541	rxvt_perl_interp::invoke (rxvt_term *term, int htype, ...)
505	{	542	{
506	if (!perl || !term->perl.self)	543	if (!perl || !term->perl.self)
507	return false;	544	return false;
		545
		546	localise_env set_environ (perl_environ);
508		547
509	// pre-handling of some events	548	// pre-handling of some events
510	if (htype == HOOK_REFRESH_END)	549	if (htype == HOOK_REFRESH_END)
511	{	550	{
512	AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, 0));	551	AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, 0));
513		552
514	for (int i = 0; i <= AvFILL (av); i++)	553	for (int i = 0; i <= AvFILL (av); i++)
515	((overlay *)SvIV (*av_fetch (av, i, 0)))->swap ();	554	((overlay *)SvIV (*av_fetch (av, i, 0)))->swap ();
516	}	555	}
		556	else if (htype == HOOK_DESTROY)
		557	{
		558	AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_selection", 10, 0));
517		559
518	swap (perl_environ, environ);	560	for (int i = AvFILL (av); i >= 0; i--)
		561	{
		562	rxvt_selection *req = (rxvt_selection *)SvIV (*av_fetch (av, i, 0));
		563	delete req;
		564	}
		565	}
519		566
520	bool event_consumed;	567	bool event_consumed;
521		568
522	if (htype == HOOK_INIT || htype == HOOK_DESTROY // must be called always
523	|| term->perl.should_invoke [htype])	569	if (term->perl.should_invoke [htype])
524	try
525	{	570	{
526	dSP;	571	dSP;
527	va_list ap;	572	va_list ap;
528		573
529	va_start (ap, htype);	574	va_start (ap, htype);
530		575
531	ENTER;	576	ENTER;
532	SAVETMPS;	577	SAVETMPS;
533		578
534	PUSHMARK (SP);	579	PUSHMARK (SP);
535		580
		581	EXTEND (SP, 2);
536	XPUSHs (sv_2mortal (newSVterm (term)));	582	PUSHs (sv_2mortal (newSVterm (term)));
537	XPUSHs (sv_2mortal (newSViv (htype)));	583	PUSHs (sv_2mortal (newSViv (htype)));
538		584
539	for (;;) {	585	for (;;) {
540	data_type dt = (data_type)va_arg (ap, int);	586	data_type dt = (data_type)va_arg (ap, int);
541		587
542	switch (dt)	588	switch (dt)
543	{	589	{
544	case DT_INT:	590	case DT_INT:
545	XPUSHs (sv_2mortal (newSViv (va_arg (ap, int))));	591	XPUSHs (sv_2mortal (newSViv (va_arg (ap, int))));
546	break;	592	break;
547		593
548	case DT_LONG:	594	case DT_LONG:
549	XPUSHs (sv_2mortal (newSViv (va_arg (ap, long))));	595	XPUSHs (sv_2mortal (newSViv (va_arg (ap, long))));
550	break;	596	break;
551		597
552	case DT_STR:	598	case DT_STR:
553	XPUSHs (sv_2mortal (newSVpv (va_arg (ap, char *), 0)));	599	XPUSHs (sv_2mortal (newSVpv (va_arg (ap, char *), 0)));
554	break;	600	break;
555		601
556	case DT_STR_LEN:	602	case DT_STR_LEN:
557	{	603	{
558	char *str = va_arg (ap, char *);	604	char *str = va_arg (ap, char *);
559	int len = va_arg (ap, int);	605	int len = va_arg (ap, int);
560		606
561	XPUSHs (sv_2mortal (newSVpvn (str, len)));	607	XPUSHs (sv_2mortal (newSVpvn (str, len)));
562	}	608	}
563	break;	609	break;
564		610
565	case DT_WCS_LEN:	611	case DT_WCS_LEN:
566	{	612	{
567	wchar_t *wstr = va_arg (ap, wchar_t *);	613	wchar_t *wstr = va_arg (ap, wchar_t *);
568	int wlen = va_arg (ap, int);	614	int wlen = va_arg (ap, int);
569		615
570	XPUSHs (sv_2mortal (wcs2sv (wstr, wlen)));	616	XPUSHs (sv_2mortal (wcs2sv (wstr, wlen)));
571	}	617	}
572	break;	618	break;
573		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
574	case DT_XEVENT:	629	case DT_XEVENT:
575	{	630	{
576	XEvent *xe = va_arg (ap, XEvent *);	631	XEvent *xe = va_arg (ap, XEvent *);
577	HV *hv = newHV ();	632	HV *hv = newHV ();
578		633
579	# define set(name, sv) hv_store (hv, # name, sizeof (# name) - 1, sv, 0)	634	# define set(name, sv) hv_store (hv, # name, sizeof (# name) - 1, sv, 0)
580	# define setiv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSViv (val), 0)	635	# define setiv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSViv (val), 0)
581	# define setuv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSVuv (val), 0)	636	# define setuv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSVuv (val), 0)
582	# undef set	637	# undef set
583		638
584	setiv (type, xe->type);	639	setiv (type, xe->type);
585	setiv (send_event, xe->xany.send_event);	640	setiv (send_event, xe->xany.send_event);
586	setiv (serial, xe->xany.serial);	641	setiv (serial, xe->xany.serial);
587		642
588	switch (xe->type)	643	switch (xe->type)
589	{	644	{
590	case KeyPress:	645	case KeyPress:
591	case KeyRelease:	646	case KeyRelease:
592	case ButtonPress:	647	case ButtonPress:
593	case ButtonRelease:	648	case ButtonRelease:
594	case MotionNotify:	649	case MotionNotify:
595	setuv (window, xe->xmotion.window);	650	setuv (window, xe->xmotion.window);
596	setuv (root, xe->xmotion.root);	651	setuv (root, xe->xmotion.root);
597	setuv (subwindow, xe->xmotion.subwindow);	652	setuv (subwindow, xe->xmotion.subwindow);
598	setuv (time, xe->xmotion.time);	653	setuv (time, xe->xmotion.time);
599	setiv (x, xe->xmotion.x);	654	setiv (x, xe->xmotion.x);
600	setiv (y, xe->xmotion.y);	655	setiv (y, xe->xmotion.y);
601	setiv (row, xe->xmotion.y / term->fheight + term->view_start);	656	setiv (row, xe->xmotion.y / term->fheight + term->view_start);
602	setiv (col, xe->xmotion.x / term->fwidth);	657	setiv (col, xe->xmotion.x / term->fwidth);
603	setiv (x_root, xe->xmotion.x_root);	658	setiv (x_root, xe->xmotion.x_root);
604	setiv (y_root, xe->xmotion.y_root);	659	setiv (y_root, xe->xmotion.y_root);
605	setuv (state, xe->xmotion.state);	660	setuv (state, xe->xmotion.state);
606		661
607	switch (xe->type)	662	switch (xe->type)
608	{	663	{
609	case KeyPress:	664	case KeyPress:
610	case KeyRelease:	665	case KeyRelease:
611	setuv (keycode, xe->xkey.keycode);	666	setuv (keycode, xe->xkey.keycode);
612	break;	667	break;
613		668
614	case ButtonPress:	669	case ButtonPress:
615	case ButtonRelease:	670	case ButtonRelease:
616	setuv (button, xe->xbutton.button);	671	setuv (button, xe->xbutton.button);
617	break;	672	break;
618		673
619	case MotionNotify:	674	case MotionNotify:
620	setiv (is_hint, xe->xmotion.is_hint);	675	setiv (is_hint, xe->xmotion.is_hint);
621	break;	676	break;
622	}	677	}
623		678
624	break;	679	break;
625		680
626	case MapNotify:	681	case MapNotify:
627	case UnmapNotify:	682	case UnmapNotify:
628	case ConfigureNotify:	683	case ConfigureNotify:
629	setuv (event, xe->xconfigure.event);	684	setuv (event, xe->xconfigure.event);
630	setuv (window, xe->xconfigure.window);	685	setuv (window, xe->xconfigure.window);
631		686
632	switch (xe->type)	687	switch (xe->type)
633	{	688	{
634	case ConfigureNotify:	689	case ConfigureNotify:
635	setiv (x, xe->xconfigure.x);	690	setiv (x, xe->xconfigure.x);
636	setiv (y, xe->xconfigure.y);	691	setiv (y, xe->xconfigure.y);
637	setiv (width, xe->xconfigure.width);	692	setiv (width, xe->xconfigure.width);
638	setiv (height, xe->xconfigure.height);	693	setiv (height, xe->xconfigure.height);
639	setuv (above, xe->xconfigure.above);	694	setuv (above, xe->xconfigure.above);
640	break;	695	break;
641	}	696	}
642		697
643	break;	698	break;
644		699
645	case PropertyNotify:	700	case PropertyNotify:
646	setuv (window, xe->xproperty.window);	701	setuv (window, xe->xproperty.window);
647	setuv (atom, xe->xproperty.atom);	702	setuv (atom, xe->xproperty.atom);
648	setuv (time, xe->xproperty.time);	703	setuv (time, xe->xproperty.time);
649	setiv (state, xe->xproperty.state);	704	setiv (state, xe->xproperty.state);
650	break;	705	break;
651		706
652	case ClientMessage:	707	case ClientMessage:
653	setuv (window, xe->xclient.window);	708	setuv (window, xe->xclient.window);
654	setuv (message_type, xe->xclient.message_type);	709	setuv (message_type, xe->xclient.message_type);
655	setuv (format, xe->xclient.format);	710	setuv (format, xe->xclient.format);
656	setuv (l0, xe->xclient.data.l[0]);	711	setuv (l0, xe->xclient.data.l[0]);
657	setuv (l1, xe->xclient.data.l[1]);	712	setuv (l1, xe->xclient.data.l[1]);
658	setuv (l2, xe->xclient.data.l[2]);	713	setuv (l2, xe->xclient.data.l[2]);
659	setuv (l3, xe->xclient.data.l[3]);	714	setuv (l3, xe->xclient.data.l[3]);
660	setuv (l4, xe->xclient.data.l[4]);	715	setuv (l4, xe->xclient.data.l[4]);
661	break;	716	break;
662	}	717	}
663		718
664	XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));	719	XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
665	}	720	}
666	break;	721	break;
667		722
668	case DT_END:	723	case DT_END:
669	goto call;	724	goto call;
670		725
671	default:	726	default:
672	rxvt_fatal ("FATAL: unable to pass data type %d\n", dt);	727	rxvt_fatal ("FATAL: unable to pass data type %d\n", dt);
673	}	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);
674	}	742	}
675		743
676	call:
677	va_end (ap);
678
679	PUTBACK;	744	PUTBACK;
680	int count = call_pv ("urxvt::invoke", G_ARRAY | G_EVAL);
681	SPAGAIN;
682
683	if (count)
684	{
685	SV *status = POPs;
686	count = SvTRUE (status);
687	}
688
689	PUTBACK;
690	FREETMPS;	745	FREETMPS;
691	LEAVE;	746	LEAVE;
692		747
693	if (SvTRUE (ERRSV))	748	if (SvTRUE (ERRSV))
694	{	749	{
695	rxvt_warn ("perl hook %d evaluation error: %s", htype, SvPV_nolen (ERRSV));	750	rxvt_warn ("perl hook %d evaluation error: %s", htype, SvPVbyte_nolen (ERRSV));
696	ungrab (term); // better lose the grab than the session	751	ungrab (term); // better lose the grab than the session
697	}	752	}
698		753
699	event_consumed = !!count;	754	event_consumed = !!count;
700	}	755	}
701	catch (...)
702	{
703	swap (perl_environ, environ);
704	throw;
705	}
706	else	756	else
707	event_consumed = false;	757	event_consumed = false;
708		758
709	// post-handling of some events	759	// post-handling of some events
710	if (htype == HOOK_REFRESH_BEGIN)	760	if (htype == HOOK_REFRESH_BEGIN)
711	{	761	{
712	AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, 0));	762	AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, 0));
713		763
714	for (int i = AvFILL (av); i >= 0; i--)	764	for (int i = AvFILL (av); i >= 0; i--)
715	((overlay *)SvIV (*av_fetch (av, i, 0)))->swap ();	765	((overlay *)SvIV (*av_fetch (av, i, 0)))->swap ();
716	}	766	}
717	else if (htype == HOOK_DESTROY)	767	else if (htype == HOOK_DESTROY)
718	{	768	{
719	clearSVptr ((SV *)term->perl.self);	769	clearSVptr ((SV *)term->perl.self);
720	SvREFCNT_dec ((SV *)term->perl.self);	770	SvREFCNT_dec ((SV *)term->perl.self);
		771
		772	// don't allow further calls
		773	term->perl.self = 0;
721	}	774	}
722		775
723	swap (perl_environ, environ);
724
725	return event_consumed;	776	return event_consumed;
		777	}
		778
		779	void
		780	rxvt_perl_interp::selection_finish (rxvt_selection *sel, char *data, unsigned int len)
		781	{
		782	localise_env set_environ (perl_environ);
		783
		784	ENTER;
		785	SAVETMPS;
		786
		787	dSP;
		788	XPUSHs (sv_2mortal (newSVpvn (data, len)));
		789	PUTBACK;
		790	call_sv ((SV *)sel->cb_sv, G_VOID | G_DISCARD | G_EVAL);
		791
		792	if (SvTRUE (ERRSV))
		793	rxvt_warn ("perl selection callback evaluation error: %s", SvPVbyte_nolen (ERRSV));
		794
		795	FREETMPS;
		796	LEAVE;
726	}	797	}
727		798
728	/////////////////////////////////////////////////////////////////////////////	799	/////////////////////////////////////////////////////////////////////////////
729		800
730	MODULE = urxvt PACKAGE = urxvt	801	MODULE = urxvt PACKAGE = urxvt
…		…
742	# define def(sym) av_store (hookname, HOOK_ ## sym, newSVpv (# sym, 0));	813	# define def(sym) av_store (hookname, HOOK_ ## sym, newSVpv (# sym, 0));
743	# include "hookinc.h"	814	# include "hookinc.h"
744	# undef def	815	# undef def
745		816
746	HV *option = get_hv ("urxvt::OPTION", 1);	817	HV *option = get_hv ("urxvt::OPTION", 1);
747	# 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);
748	# define nodef(name)	819	# define nodef(name)
749	# include "optinc.h"	820	# include "optinc.h"
750	# undef nodef	821	# undef nodef
751	# undef def	822	# undef def
752		823
753	HV *stash = gv_stashpv ("urxvt", 1);	824	HV *stash = gv_stashpv ("urxvt", 1);
754	struct {	825	static const struct {
755	const char *name;	826	const char *name;
756	IV iv;	827	IV iv;
757	} *civ, const_iv[] = {	828	} *civ, const_iv[] = {
758	# define const_iv(name) { # name, (IV)name }	829	# define const_iv(name) { # name, (IV)name }
		830	const_iv (HOOK_INIT),
		831	const_iv (HOOK_DESTROY),
		832	const_iv (HOOK_ACTION),
		833	const_iv (HOOK_OSC_SEQ),
		834	const_iv (HOOK_OSC_SEQ_PERL),
		835
		836	const_iv (NUM_RESOURCES),
759	const_iv (DEFAULT_RSTYLE),	837	const_iv (DEFAULT_RSTYLE),
760	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),
761	const_iv (RS_Bold),	850	const_iv (RS_Bold),
762	const_iv (RS_Italic),	851	const_iv (RS_Italic),
763	const_iv (RS_Blink),	852	const_iv (RS_Blink),
764	const_iv (RS_RVid),	853	const_iv (RS_RVid),
765	const_iv (RS_Uline),	854	const_iv (RS_Uline),
		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),
766		867
767	const_iv (CurrentTime),	868	const_iv (CurrentTime),
768	const_iv (ShiftMask),	869	const_iv (ShiftMask),
769	const_iv (LockMask),	870	const_iv (LockMask),
770	const_iv (ControlMask),	871	const_iv (ControlMask),
…		…
778	const_iv (Button3Mask),	879	const_iv (Button3Mask),
779	const_iv (Button4Mask),	880	const_iv (Button4Mask),
780	const_iv (Button5Mask),	881	const_iv (Button5Mask),
781	const_iv (AnyModifier),	882	const_iv (AnyModifier),
782		883
783	const_iv (EVENT_NONE),	884	const_iv (NoSymbol),
784	const_iv (EVENT_READ),	885	const_iv (GrabModeSync),
785	const_iv (EVENT_WRITE),	886	const_iv (GrabModeAsync),
786		887
787	const_iv (NoEventMask),	888	const_iv (NoEventMask),
788	const_iv (KeyPressMask),	889	const_iv (KeyPressMask),
789	const_iv (KeyReleaseMask),	890	const_iv (KeyReleaseMask),
790	const_iv (ButtonPressMask),	891	const_iv (ButtonPressMask),
…		…
842	const_iv (SelectionRequest),	943	const_iv (SelectionRequest),
843	const_iv (SelectionNotify),	944	const_iv (SelectionNotify),
844	const_iv (ColormapNotify),	945	const_iv (ColormapNotify),
845	const_iv (ClientMessage),	946	const_iv (ClientMessage),
846	const_iv (MappingNotify),	947	const_iv (MappingNotify),
		948
		949	// shape extension
		950	const_iv (ShapeSet),
		951	const_iv (ShapeUnion),
		952	const_iv (ShapeIntersect),
		953	const_iv (ShapeSubtract),
		954	const_iv (ShapeInvert),
		955
		956	const_iv (ShapeBounding),
		957	const_iv (ShapeClip),
		958	const_iv (ShapeInput),
		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),
847	};	1083	};
848		1084
849	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]);	1085	for (civ = const_iv + ecb_array_length (const_iv); civ > const_iv; civ--)
850	civ-- > const_iv; )
851	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	1086	newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
852	}	1087	}
853		1088
854	void	1089	void
855	warn (const char *msg)	1090	log (utf8_string msg)
		1091	CODE:
		1092	rxvt_log ("%s", msg);
		1093
		1094	void
		1095	warn (utf8_string msg)
856	CODE:	1096	CODE:
857	rxvt_warn ("%s", msg);	1097	rxvt_warn ("%s", msg);
858		1098
859	void	1099	void
860	fatal (const char *msg)	1100	fatal (utf8_string msg)
861	CODE:	1101	CODE:
862	rxvt_fatal ("%s", msg);	1102	rxvt_fatal ("%s", msg);
863		1103
864	void	1104	void
865	_exit (int status)	1105	_exit (int status)
		1106
		1107	void
		1108	catch_fatal (SV *block)
		1109	PROTOTYPE: &
		1110	CODE:
		1111	try
		1112	{
		1113	PUSHMARK (SP);
		1114	PUTBACK;
		1115	call_sv (block, G_VOID | G_DISCARD);
		1116	SPAGAIN;
		1117	}
		1118	catch (const rxvt_failure_exception &e)
		1119	{
		1120	croak ("rxvt_fatal exception caught, trying to continue.");
		1121	}
866		1122
867	NV	1123	NV
868	NOW ()	1124	NOW ()
869	CODE:	1125	CODE:
870	RETVAL = NOW;	1126	RETVAL = ev::now ();
871	OUTPUT:	1127	OUTPUT:
872	RETVAL	1128	RETVAL
873		1129
874	int	1130	int
875	GET_BASEFG (int rend)	1131	GET_BASEFG (int rend)
…		…
886	RETVAL	1142	RETVAL
887		1143
888	int	1144	int
889	SET_FGCOLOR (int rend, int new_color)	1145	SET_FGCOLOR (int rend, int new_color)
890	CODE:	1146	CODE:
891	RETVAL = SET_FGCOLOR (rend, new_color);	1147	RETVAL = SET_FGCOLOR (rend, clamp (new_color, 0, TOTAL_COLORS - 1));
892	OUTPUT:	1148	OUTPUT:
893	RETVAL	1149	RETVAL
894		1150
895	int	1151	int
896	SET_BGCOLOR (int rend, int new_color)	1152	SET_BGCOLOR (int rend, int new_color)
897	CODE:	1153	CODE:
898	RETVAL = SET_BGCOLOR (rend, new_color);	1154	RETVAL = SET_BGCOLOR (rend, clamp (new_color, 0, TOTAL_COLORS - 1));
899	OUTPUT:	1155	OUTPUT:
900	RETVAL	1156	RETVAL
901		1157
902	int	1158	int
903	GET_CUSTOM (int rend)	1159	GET_CUSTOM (int rend)
904	CODE:	1160	CODE:
905	RETVAL = (rend && RS_customMask) >> RS_customShift;	1161	RETVAL = (rend & RS_customMask) >> RS_customShift;
906	OUTPUT:	1162	OUTPUT:
907	RETVAL	1163	RETVAL
908		1164
909	int	1165	int
910	SET_CUSTOM (int rend, int new_value)	1166	SET_CUSTOM (int rend, int new_value)
911	CODE:	1167	CODE:
912	{	1168	{
913	if (!IN_RANGE_EXC (new_value, 0, RS_customCount))	1169	if (!IN_RANGE_EXC (new_value, 0, RS_customCount))
914	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);
915		1171
916	RETVAL = (rend & ~RS_customMask)	1172	RETVAL = (rend & ~RS_customMask)
917	| ((new_value << RS_customShift) & RS_customMask);	1173	| ((new_value << RS_customShift) & RS_customMask);
918	}	1174	}
919	OUTPUT:	1175	OUTPUT:
920	RETVAL	1176	RETVAL
921		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
922	MODULE = urxvt PACKAGE = urxvt::term	1218	MODULE = urxvt PACKAGE = urxvt::term
923		1219
924	SV *	1220	SV *
925	_new (...)	1221	_new (AV *env, AV *arg)
926	CODE:	1222	CODE:
927	{	1223	{
928	if (items < 1 || !SvROK (ST (0)) || SvTYPE (SvRV (ST (0))) != SVt_PVAV)
929	croak ("first argument to urxvt::term->_new must be arrayref");
930
931	rxvt_term *term = new rxvt_term;	1224	rxvt_term *term = new rxvt_term;
932		1225
933	term->argv = new stringvec;	1226	stringvec *argv = new stringvec;
934	term->envv = new stringvec;	1227	for (int i = 0; i <= AvFILL (arg); i++)
935
936	for (int i = 1; i < items; i++)
937	term->argv->push_back (strdup (SvPVbyte_nolen (ST (i))));	1228	argv->push_back (strdup (SvPVbyte_nolen (*av_fetch (arg, i, 1))));
938		1229
939	AV *envv = (AV *)SvRV (ST (0));	1230	stringvec *envv = new stringvec;
940	for (int i = AvFILL (envv) + 1; i--; )	1231	for (int i = AvFILL (env) + 1; i--; )
941	term->envv->push_back (strdup (SvPVbyte_nolen (*av_fetch (envv, i, 1))));	1232	envv->push_back (strdup (SvPVbyte_nolen (*av_fetch (env, i, 1))));
942
943	term->envv->push_back (0);
944
945	bool success;
946		1233
947	try	1234	try
948	{	1235	{
949	success = term->init (term->argv->size (), term->argv->begin ());	1236	term->init (argv, envv);
950	}	1237	}
951	catch (const class rxvt_failure_exception &e)	1238	catch (const class rxvt_failure_exception &e)
952	{
953	success = false;
954	}
955
956	if (!success)
957	{	1239	{
958	term->destroy ();	1240	term->destroy ();
959	croak ("error while initializing new terminal instance");	1241	croak ("error while initializing new terminal instance");
960	}	1242	}
961		1243
…		…
969	rxvt_term::destroy ()	1251	rxvt_term::destroy ()
970		1252
971	void	1253	void
972	rxvt_term::set_should_invoke (int htype, int inc)	1254	rxvt_term::set_should_invoke (int htype, int inc)
973	CODE:	1255	CODE:
974	THIS->perl.should_invoke [htype] += inc;	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	}
975		1269
976	void	1270	void
977	rxvt_term::grab_button (int button, U32 modifiers)	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 ()
978	CODE:	1277	PPCODE:
979	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,
980	ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,	1286	ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
981	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);
982		1306
983	bool	1307	bool
984	rxvt_term::grab (Time eventtime, int sync = 0)	1308	rxvt_term::grab (Time eventtime, int sync = 0)
985	CODE:	1309	CODE:
986	{	1310	{
987	int mode = sync ? GrabModeSync : GrabModeAsync;	1311	int mode = sync ? GrabModeSync : GrabModeAsync;
988		1312
989	THIS->perl.grabtime = 0;	1313	THIS->perl.grabtime = 0;
990		1314
991	if (!XGrabPointer (THIS->display->display, THIS->vt, 0,	1315	if (!XGrabPointer (THIS->dpy, THIS->vt, 0,
992	ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,	1316	ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
993	mode, mode, None, GRAB_CURSOR, eventtime))	1317	mode, mode, None, GRAB_CURSOR, eventtime))
994	if (!XGrabKeyboard (THIS->display->display, THIS->vt, 0, mode, mode, eventtime))	1318	if (!XGrabKeyboard (THIS->dpy, THIS->vt, 0, mode, mode, eventtime))
995	THIS->perl.grabtime = eventtime;	1319	THIS->perl.grabtime = eventtime;
996	else	1320	else
997	XUngrabPointer (THIS->display->display, eventtime);	1321	XUngrabPointer (THIS->dpy, eventtime);
998		1322
999	RETVAL = !!THIS->perl.grabtime;	1323	RETVAL = !!THIS->perl.grabtime;
1000	}	1324	}
1001	OUTPUT:	1325	OUTPUT:
1002	RETVAL	1326	RETVAL
1003		1327
1004	void	1328	void
1005	rxvt_term::allow_events_async ()	1329	rxvt_term::allow_events_async ()
1006	CODE:	1330	CODE:
1007	XAllowEvents (THIS->display->display, AsyncBoth, THIS->perl.grabtime);	1331	XAllowEvents (THIS->dpy, AsyncBoth, THIS->perl.grabtime);
1008		1332
1009	void	1333	void
1010	rxvt_term::allow_events_sync ()	1334	rxvt_term::allow_events_sync ()
1011	CODE:	1335	CODE:
1012	XAllowEvents (THIS->display->display, SyncBoth, THIS->perl.grabtime);	1336	XAllowEvents (THIS->dpy, SyncBoth, THIS->perl.grabtime);
1013		1337
1014	void	1338	void
1015	rxvt_term::allow_events_replay ()	1339	rxvt_term::allow_events_replay ()
1016	CODE:	1340	CODE:
1017	XAllowEvents (THIS->display->display, ReplayPointer, THIS->perl.grabtime);	1341	XAllowEvents (THIS->dpy, ReplayPointer, THIS->perl.grabtime);
1018	XAllowEvents (THIS->display->display, ReplayKeyboard, THIS->perl.grabtime);	1342	XAllowEvents (THIS->dpy, ReplayKeyboard, THIS->perl.grabtime);
1019		1343
1020	void	1344	void
1021	rxvt_term::ungrab ()	1345	rxvt_term::ungrab ()
1022	CODE:	1346	CODE:
1023	ungrab (THIS);	1347	ungrab (THIS);
1024		1348
1025	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
1026	rxvt_term::strwidth (SV *str)	1374	rxvt_term::strwidth (SV *str)
1027	CODE:	1375	CODE:
1028	{	1376	{
1029	wchar_t *wstr = sv2wcs (str);	1377	wchar_t *wstr = sv2wcs (str);
1030		1378
1031	rxvt_push_locale (THIS->locale);	1379	rxvt_push_locale (THIS->locale);
1032	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	}
1033	rxvt_pop_locale ();	1388	rxvt_pop_locale ();
1034		1389
1035	free (wstr);	1390	free (wstr);
1036	}	1391	}
1037	OUTPUT:	1392	OUTPUT:
…		…
1039		1394
1040	SV *	1395	SV *
1041	rxvt_term::locale_encode (SV *str)	1396	rxvt_term::locale_encode (SV *str)
1042	CODE:	1397	CODE:
1043	{	1398	{
		1399	if (!SvOK (str))
		1400	XSRETURN_UNDEF;
		1401
1044	wchar_t *wstr = sv2wcs (str);	1402	wchar_t *wstr = sv2wcs (str);
1045		1403
1046	rxvt_push_locale (THIS->locale);	1404	rxvt_push_locale (THIS->locale);
1047	char *mbstr = rxvt_wcstombs (wstr);	1405	char *mbstr = rxvt_wcstombs (wstr);
1048	rxvt_pop_locale ();	1406	rxvt_pop_locale ();
…		…
1057		1415
1058	SV *	1416	SV *
1059	rxvt_term::locale_decode (SV *octets)	1417	rxvt_term::locale_decode (SV *octets)
1060	CODE:	1418	CODE:
1061	{	1419	{
		1420	if (!SvOK (octets))
		1421	XSRETURN_UNDEF;
		1422
1062	STRLEN len;	1423	STRLEN len;
1063	char *data = SvPVbyte (octets, len);	1424	char *data = SvPVbyte (octets, len);
1064		1425
1065	rxvt_push_locale (THIS->locale);	1426	rxvt_push_locale (THIS->locale);
1066	wchar_t *wstr = rxvt_mbstowcs (data, len);	1427	wchar_t *wstr = rxvt_mbstowcs (data, len);
…		…
1072	OUTPUT:	1433	OUTPUT:
1073	RETVAL	1434	RETVAL
1074		1435
1075	#define TERM_OFFSET(sym) offsetof (TermWin_t, sym)	1436	#define TERM_OFFSET(sym) offsetof (TermWin_t, sym)
1076		1437
1077	#define TERM_OFFSET_width TERM_OFFSET(width)	1438	#define TERM_OFFSET_width TERM_OFFSET(width)
1078	#define TERM_OFFSET_height TERM_OFFSET(height)	1439	#define TERM_OFFSET_height TERM_OFFSET(height)
1079	#define TERM_OFFSET_fwidth TERM_OFFSET(fwidth)	1440	#define TERM_OFFSET_fwidth TERM_OFFSET(fwidth)
1080	#define TERM_OFFSET_fheight TERM_OFFSET(fheight)	1441	#define TERM_OFFSET_fheight TERM_OFFSET(fheight)
1081	#define TERM_OFFSET_fbase TERM_OFFSET(fbase)	1442	#define TERM_OFFSET_fbase TERM_OFFSET(fbase)
1082	#define TERM_OFFSET_nrow TERM_OFFSET(nrow)	1443	#define TERM_OFFSET_nrow TERM_OFFSET(nrow)
1083	#define TERM_OFFSET_ncol TERM_OFFSET(ncol)	1444	#define TERM_OFFSET_ncol TERM_OFFSET(ncol)
1084	#define TERM_OFFSET_focus TERM_OFFSET(focus)	1445	#define TERM_OFFSET_focus TERM_OFFSET(focus)
1085	#define TERM_OFFSET_mapped TERM_OFFSET(mapped)	1446	#define TERM_OFFSET_mapped TERM_OFFSET(mapped)
1086	#define TERM_OFFSET_int_bwidth TERM_OFFSET(int_bwidth)	1447	#define TERM_OFFSET_int_bwidth TERM_OFFSET(int_bwidth)
1087	#define TERM_OFFSET_ext_bwidth TERM_OFFSET(ext_bwidth)	1448	#define TERM_OFFSET_ext_bwidth TERM_OFFSET(ext_bwidth)
1088	#define TERM_OFFSET_lineSpace TERM_OFFSET(lineSpace)	1449	#define TERM_OFFSET_lineSpace TERM_OFFSET(lineSpace)
		1450	#define TERM_OFFSET_letterSpace TERM_OFFSET(letterSpace)
1089	#define TERM_OFFSET_saveLines TERM_OFFSET(saveLines)	1451	#define TERM_OFFSET_saveLines TERM_OFFSET(saveLines)
1090	#define TERM_OFFSET_total_rows TERM_OFFSET(total_rows)	1452	#define TERM_OFFSET_total_rows TERM_OFFSET(total_rows)
1091	#define TERM_OFFSET_top_row TERM_OFFSET(top_row)	1453	#define TERM_OFFSET_top_row TERM_OFFSET(top_row)
1092		1454
1093	int	1455	int
1094	rxvt_term::width ()	1456	rxvt_term::width (int new_value = NO_INIT)
1095	ALIAS:	1457	ALIAS:
1096	width = TERM_OFFSET_width	1458	width = TERM_OFFSET_width
1097	height = TERM_OFFSET_height	1459	height = TERM_OFFSET_height
1098	fwidth = TERM_OFFSET_fwidth	1460	fwidth = TERM_OFFSET_fwidth
1099	fheight = TERM_OFFSET_fheight	1461	fheight = TERM_OFFSET_fheight
1100	fbase = TERM_OFFSET_fbase	1462	fbase = TERM_OFFSET_fbase
1101	nrow = TERM_OFFSET_nrow	1463	nrow = TERM_OFFSET_nrow
1102	ncol = TERM_OFFSET_ncol	1464	ncol = TERM_OFFSET_ncol
1103	focus = TERM_OFFSET_focus	1465	focus = TERM_OFFSET_focus
1104	mapped = TERM_OFFSET_mapped	1466	mapped = TERM_OFFSET_mapped
1105	int_bwidth = TERM_OFFSET_int_bwidth	1467	int_bwidth = TERM_OFFSET_int_bwidth
1106	ext_bwidth = TERM_OFFSET_ext_bwidth	1468	ext_bwidth = TERM_OFFSET_ext_bwidth
1107	lineSpace = TERM_OFFSET_lineSpace	1469	lineSpace = TERM_OFFSET_lineSpace
		1470	letterSpace = TERM_OFFSET_letterSpace
1108	saveLines = TERM_OFFSET_saveLines	1471	saveLines = TERM_OFFSET_saveLines
1109	total_rows = TERM_OFFSET_total_rows	1472	total_rows = TERM_OFFSET_total_rows
1110	top_row = TERM_OFFSET_top_row	1473	top_row = TERM_OFFSET_top_row
1111	CODE:	1474	CODE:
1112	RETVAL = *(int *)((char *)THIS + ix);	1475	RETVAL = *(int *)((char *)THIS + ix);
		1476	if (items > 1)
		1477	*(int *)((char *)THIS + ix) = new_value;
1113	OUTPUT:	1478	OUTPUT:
1114	RETVAL	1479	RETVAL
1115		1480
1116	unsigned int	1481	unsigned int
1117	rxvt_term::ModLevel3Mask ()	1482	rxvt_term::ModLevel3Mask ()
1118	ALIAS:	1483	ALIAS:
1119	ModLevel3Mask = 0	1484	ModLevel3Mask = 0
1120	ModMetaMask = 1	1485	ModMetaMask = 1
1121	ModNumLockMask = 2	1486	ModNumLockMask = 2
1122	current_screen = 3	1487	current_screen = 3
		1488	hidden_cursor = 4
		1489	priv_modes = 5
1123	CODE:	1490	CODE:
1124	switch (ix)	1491	switch (ix)
1125	{	1492	{
1126	case 0: RETVAL = THIS->ModLevel3Mask; break;	1493	case 0: RETVAL = THIS->ModLevel3Mask; break;
1127	case 1: RETVAL = THIS->ModMetaMask; break;	1494	case 1: RETVAL = THIS->ModMetaMask; break;
1128	case 2: RETVAL = THIS->ModNumLockMask; break;	1495	case 2: RETVAL = THIS->ModNumLockMask; break;
1129	case 3: RETVAL = THIS->current_screen; 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;
1130	}	1503	}
1131	OUTPUT:	1504	OUTPUT:
1132	RETVAL	1505	RETVAL
1133		1506
1134	char *	1507	char *
…		…
1144	}	1517	}
1145	OUTPUT:	1518	OUTPUT:
1146	RETVAL	1519	RETVAL
1147		1520
1148	SV *	1521	SV *
1149	rxvt_term::_env ()	1522	rxvt_term::envv ()
		1523	ALIAS:
		1524	argv = 1
1150	CODE:	1525	PPCODE:
1151	{	1526	{
1152	if (THIS->envv)	1527	stringvec *vec = ix ? THIS->argv : THIS->envv;
1153	{
1154	AV *av = newAV ();
1155		1528
		1529	EXTEND (SP, vec->size ());
		1530
1156	for (char **i = THIS->envv->begin (); i != THIS->envv->end (); ++i)	1531	for (char **i = vec->begin (); i != vec->end (); ++i)
1157	if (*i)	1532	if (*i)
1158	av_push (av, newSVpv (*i, 0));	1533	PUSHs (sv_2mortal (newSVpv (*i, 0)));
1159
1160	RETVAL = newRV_noinc ((SV *)av);
1161	}
1162	else
1163	RETVAL = &PL_sv_undef;
1164	}	1534	}
1165	OUTPUT:
1166	RETVAL
1167		1535
1168	int	1536	int
1169	rxvt_term::pty_ev_events (int events = EVENT_UNDEF)	1537	rxvt_term::pty_ev_events (int events = ev::UNDEF)
1170	CODE:	1538	CODE:
1171	RETVAL = THIS->pty_ev.events;	1539	RETVAL = THIS->pty_ev.events;
1172	if (events != EVENT_UNDEF)	1540	if (events != ev::UNDEF)
1173	THIS->pty_ev.set (events);	1541	THIS->pty_ev.set (events);
1174	OUTPUT:	1542	OUTPUT:
1175	RETVAL	1543	RETVAL
1176		1544
		1545	int
		1546	rxvt_term::pty_fd ()
		1547	CODE:
		1548	RETVAL = THIS->pty->pty;
		1549	OUTPUT:
		1550	RETVAL
		1551
1177	Window	1552	Window
1178	rxvt_term::parent ()	1553	rxvt_term::parent ()
1179	CODE:	1554	CODE:
1180	RETVAL = THIS->parent [0];	1555	RETVAL = THIS->parent;
		1556	OUTPUT:
		1557	RETVAL
		1558
		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;
1181	OUTPUT:	1570	OUTPUT:
1182	RETVAL	1571	RETVAL
1183		1572
1184	Window	1573	Window
1185	rxvt_term::vt ()	1574	rxvt_term::vt ()
…		…
1201	THIS->rstyle = new_rstyle;	1590	THIS->rstyle = new_rstyle;
1202	OUTPUT:	1591	OUTPUT:
1203	RETVAL	1592	RETVAL
1204		1593
1205	int	1594	int
1206	rxvt_term::view_start (int newval = 1)	1595	rxvt_term::view_start (int newval = 0)
1207	PROTOTYPE: $;$	1596	PROTOTYPE: $;$
1208	CODE:	1597	CODE:
1209	{	1598	{
1210	RETVAL = THIS->view_start;	1599	RETVAL = THIS->view_start;
1211		1600	if (items > 1)
1212	if (newval <= 0)
1213	THIS->scr_changeview (max (newval, THIS->top_row));	1601	THIS->scr_changeview (newval);
1214	}	1602	}
1215	OUTPUT:	1603	OUTPUT:
1216	RETVAL	1604	RETVAL
1217		1605
1218	void	1606	void
		1607	rxvt_term::set_urgency (bool enable)
		1608
		1609	void
1219	rxvt_term::focus_in ()	1610	rxvt_term::focus_in ()
1220		1611
1221	void	1612	void
1222	rxvt_term::focus_out ()	1613	rxvt_term::focus_out ()
1223		1614
1224	void	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
1225	rxvt_term::want_refresh ()	1642	rxvt_term::want_refresh ()
1226	CODE:	1643	CODE:
1227	THIS->want_refresh = 1;	1644	THIS->want_refresh = 1;
		1645	THIS->refresh_check ();
		1646
		1647	void
		1648	rxvt_term::refresh_check ()
1228		1649
1229	void	1650	void
1230	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)
1231	PPCODE:	1652	PPCODE:
1232	{	1653	{
…		…
1235		1656
1236	line_t &l = ROW(row_number);	1657	line_t &l = ROW(row_number);
1237		1658
1238	if (GIMME_V != G_VOID)	1659	if (GIMME_V != G_VOID)
1239	{	1660	{
1240	wchar_t *wstr = new wchar_t [THIS->ncol];	1661	wchar_t *wstr = rxvt_temp_buf<wchar_t> (THIS->ncol);
1241		1662
1242	for (int col = 0; col < THIS->ncol; col++)	1663	for (int col = 0; col < THIS->ncol; col++)
1243	wstr [col] = l.t [col];	1664	wstr [col] = l.t [col];
1244		1665
1245	XPUSHs (sv_2mortal (wcs2sv (wstr, THIS->ncol)));	1666	XPUSHs (sv_2mortal (wcs2sv (wstr, THIS->ncol)));
1246
1247	delete [] wstr;
1248	}	1667	}
1249		1668
1250	if (new_text)	1669	if (new_text)
1251	{	1670	{
1252	wchar_t *wstr = sv2wcs (new_text);	1671	wchar_t *wstr = sv2wcs (new_text);
…		…
1345	rxvt_term::special_encode (SV *string)	1764	rxvt_term::special_encode (SV *string)
1346	CODE:	1765	CODE:
1347	{	1766	{
1348	wchar_t *wstr = sv2wcs (string);	1767	wchar_t *wstr = sv2wcs (string);
1349	int wlen = wcslen (wstr);	1768	int wlen = wcslen (wstr);
1350	wchar_t *rstr = new wchar_t [wlen]; // cannot become longer	1769	wchar_t *rstr = rxvt_temp_buf<wchar_t> (wlen * 2); // cannot become longer
1351		1770
1352	rxvt_push_locale (THIS->locale);	1771	rxvt_push_locale (THIS->locale);
1353		1772
1354	wchar_t *r = rstr;	1773	wchar_t *r = rstr;
1355	for (wchar_t *s = wstr; *s; s++)	1774	for (wchar_t *s = wstr; *s; s++)
		1775	{
		1776	int w = WCWIDTH (*s);
		1777
1356	if (wcwidth (*s) == 0)	1778	if (w == 0)
1357	{	1779	{
1358	if (r == rstr)	1780	if (r == rstr)
1359	croak ("leading combining character unencodable");	1781	croak ("leading combining character unencodable");
1360		1782
1361	unicode_t n = rxvt_compose (r[-1], *s);	1783	unicode_t n = rxvt_compose (r[-1], *s);
1362	if (n == NOCHAR)	1784	if (n == NOCHAR)
1363	n = rxvt_composite.compose (r[-1], *s);	1785	n = rxvt_composite.compose (r[-1], *s);
1364		1786
1365	r[-1] = n;	1787	r[-1] = n;
1366	}	1788	}
1367	#if !UNICODE_3	1789	#if !UNICODE_3
1368	else if (*s >= 0x10000)	1790	else if (*s >= 0x10000)
1369	*r++ = rxvt_composite.compose (*s);	1791	*r++ = rxvt_composite.compose (*s);
1370	#endif	1792	#endif
1371	else	1793	else
1372	*r++ = *s;	1794	*r++ = *s;
		1795
		1796	// the *2 above only allows wcwidth <= 2
		1797	if (w > 1)
		1798	*r++ = NOCHAR;
		1799	}
1373		1800
1374	rxvt_pop_locale ();	1801	rxvt_pop_locale ();
1375		1802
		1803	free (wstr);
1376	RETVAL = wcs2sv (rstr, r - rstr);	1804	RETVAL = wcs2sv (rstr, r - rstr);
1377
1378	delete [] rstr;
1379	}	1805	}
1380	OUTPUT:	1806	OUTPUT:
1381	RETVAL	1807	RETVAL
1382		1808
1383	SV *	1809	SV *
1384	rxvt_term::special_decode (SV *text)	1810	rxvt_term::special_decode (SV *text)
1385	CODE:	1811	CODE:
1386	{	1812	{
1387	wchar_t *wstr = sv2wcs (text);	1813	wchar_t *wstr = sv2wcs (text);
1388	int wlen = wcslen (wstr);
1389	int dlen = 0;	1814	int dlen = 0;
1390		1815
1391	// find length	1816	// find length
1392	for (wchar_t *s = wstr; *s; s++)	1817	for (wchar_t *s = wstr; *s; s++)
1393	if (*s == NOCHAR)	1818	if (*s == NOCHAR)
1394	;	1819	;
1395	else if (IS_COMPOSE (*s))	1820	else if (IS_COMPOSE (*s))
1396	dlen += rxvt_composite.expand (*s, 0);	1821	dlen += rxvt_composite.expand (*s);
1397	else	1822	else
1398	dlen++;	1823	dlen++;
1399		1824
1400	wchar_t *rstr = new wchar_t [dlen];	1825	wchar_t *rstr = rxvt_temp_buf<wchar_t> (dlen);
1401		1826
1402	// decode	1827	// decode
1403	wchar_t *r = rstr;	1828	wchar_t *r = rstr;
1404	for (wchar_t *s = wstr; *s; s++)	1829	for (wchar_t *s = wstr; *s; s++)
1405	if (*s == NOCHAR)	1830	if (*s == NOCHAR)
…		…
1407	else if (IS_COMPOSE (*s))	1832	else if (IS_COMPOSE (*s))
1408	r += rxvt_composite.expand (*s, r);	1833	r += rxvt_composite.expand (*s, r);
1409	else	1834	else
1410	*r++ = *s;	1835	*r++ = *s;
1411		1836
		1837	free (wstr);
1412	RETVAL = wcs2sv (rstr, r - rstr);	1838	RETVAL = wcs2sv (rstr, r - rstr);
1413
1414	delete [] rstr;
1415	}	1839	}
1416	OUTPUT:	1840	OUTPUT:
1417	RETVAL	1841	RETVAL
1418		1842
1419	void	1843	void
1420	rxvt_term::_resource (char *name, int index, SV *newval = 0)	1844	rxvt_term::_resource (octet_string name, int index, SV *newval = 0)
1421	PPCODE:	1845	PPCODE:
1422	{	1846	{
1423	struct resval { const char *name; int value; } rslist [] = {	1847	static const struct resval { const char *name; int value; } *rs, rslist [] = {
1424	# define def(name) { # name, Rs_ ## name },	1848	# define def(name) { # name, Rs_ ## name },
1425	# define reserve(name,count)	1849	# define reserve(name,count)
1426	# include "rsinc.h"	1850	# include "rsinc.h"
1427	# undef def	1851	# undef def
1428	# undef reserve	1852	# undef reserve
1429	};	1853	};
1430		1854
1431	struct resval *rs = rslist + sizeof (rslist) / sizeof (rslist [0]);	1855	rs = rslist + ecb_array_length (rslist);
1432		1856
		1857	if (*name)
1433	do {	1858	{
		1859	do {
1434	if (rs-- == rslist)	1860	if (rs-- == rslist)
1435	croak ("no such resource '%s', requested", name);	1861	croak ("no such resource '%s', requested", name);
1436	} while (strcmp (name, rs->name));	1862	} while (strcmp (name, rs->name));
1437		1863
1438	index += rs->value;	1864	index += rs->value;
		1865	}
		1866	else
		1867	{
		1868	--rs;
		1869	name = (octet_string)"";
		1870	}
1439		1871
1440	if (!IN_RANGE_EXC (index, 0, NUM_RESOURCES))	1872	if (!IN_RANGE_EXC (index, 0, NUM_RESOURCES))
1441	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);
1442		1874
1443	if (GIMME_V != G_VOID)	1875	if (GIMME_V != G_VOID)
…		…
1455	THIS->rs [index] = 0;	1887	THIS->rs [index] = 0;
1456	}	1888	}
1457	}	1889	}
1458		1890
1459	const char *	1891	const char *
1460	rxvt_term::x_resource (const char *name)	1892	rxvt_term::x_resource (octet_string name)
1461		1893
1462	bool	1894	bool
1463	rxvt_term::option (U32 optval, int set = -1)	1895	rxvt_term::option (U8 optval, int set = -1)
1464	CODE:	1896	CODE:
1465	{	1897	{
1466	RETVAL = THIS->options & optval;	1898	RETVAL = THIS->option (optval);
1467		1899
1468	if (set >= 0)	1900	if (set >= 0)
1469	{	1901	{
1470	if (set)
1471	THIS->options |= optval;	1902	THIS->set_option (optval, set);
1472	else
1473	THIS->options &= ~optval;
1474		1903
1475	if (THIS->check_ev.is_active ()) // avoid doing this before START	1904	if (THIS->init_done) // avoid doing this before START
1476	switch (optval)	1905	switch (optval)
1477	{	1906	{
1478	case Opt_skipBuiltinGlyphs:	1907	case Opt_skipBuiltinGlyphs:
1479	THIS->set_fonts ();	1908	THIS->set_fonts ();
1480	THIS->scr_remap_chars ();	1909	THIS->scr_remap_chars ();
1481	THIS->scr_touch (true);	1910	THIS->scr_touch (true);
1482	THIS->want_refresh = 1;	1911	THIS->want_refresh = 1;
		1912	THIS->refresh_check ();
1483	break;	1913	break;
		1914	#ifdef CURSOR_BLINK
		1915	case Opt_cursorBlink:
		1916	THIS->cursor_blink_reset ();
		1917	break;
		1918	#endif
1484		1919
1485	case Opt_cursorUnderline:	1920	case Opt_cursorUnderline:
		1921	THIS->cursor_type = set ? 1 : 0;
1486	THIS->want_refresh = 1;	1922	THIS->want_refresh = 1;
		1923	THIS->refresh_check ();
1487	break;	1924	break;
1488		1925
1489	# case Opt_scrollBar_floating:	1926	# case Opt_scrollBar_floating:
1490	# case Opt_scrollBar_right:	1927	# case Opt_scrollBar_right:
1491	# THIS->resize_all_windows (THIS->width, THIS->height, 1);	1928	# THIS->resize_all_windows (THIS->width, THIS->height, 1);
…		…
1494	}	1931	}
1495	}	1932	}
1496	OUTPUT:	1933	OUTPUT:
1497	RETVAL	1934	RETVAL
1498		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
1499	bool	1946	bool
1500	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
1501	CODE:	1950	CODE:
1502	RETVAL = 0 < THIS->parse_keysym (keysym, str);	1951	RETVAL = 0 < THIS->bind_action (keysym, action);
1503	THIS->keyboard->register_done ();	1952	THIS->keyboard->register_done ();
1504	OUTPUT:	1953	OUTPUT:
1505	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);
1506		1962
1507	void	1963	void
1508	rxvt_term::screen_cur (...)	1964	rxvt_term::screen_cur (...)
1509	PROTOTYPE: $;$$	1965	PROTOTYPE: $;$$
1510	ALIAS:	1966	ALIAS:
…		…
1524	EXTEND (SP, 2);	1980	EXTEND (SP, 2);
1525	PUSHs (sv_2mortal (newSViv (rc.row)));	1981	PUSHs (sv_2mortal (newSViv (rc.row)));
1526	PUSHs (sv_2mortal (newSViv (rc.col)));	1982	PUSHs (sv_2mortal (newSViv (rc.col)));
1527	}	1983	}
1528		1984
1529	if (items == 3)	1985	if (items >= 3)
1530	{	1986	{
1531	rc.row = SvIV (ST (1));	1987	rc.row = SvIV (ST (1));
1532	rc.col = SvIV (ST (2));	1988	rc.col = SvIV (ST (2));
1533		1989
1534	if (ix == 2 && rc.col == 0)	1990	if (ix == 2)
1535	{	1991	{
		1992	if (rc.col == 0)
		1993	{
		1994	// col == 0 means end of previous line
1536	rc.row--;	1995	rc.row--;
1537	rc.col = THIS->ncol;	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	}
1538	}	2004	}
1539		2005
1540	clamp_it (rc.col, 0, THIS->ncol);	2006	clamp_it (rc.col, 0, THIS->ncol);
1541	clamp_it (rc.row, THIS->top_row, THIS->nrow - 1);	2007	clamp_it (rc.row, THIS->top_row, THIS->nrow - 1);
1542		2008
1543	if (ix)	2009	if (ix)
1544	THIS->want_refresh = 1;	2010	{
		2011	THIS->selection.screen = THIS->current_screen;
		2012
		2013	THIS->selection_changed ();
		2014	THIS->refresh_check ();
1545	}	2015	}
		2016	}
1546	}	2017	}
1547		2018
1548	char	2019	int
1549	rxvt_term::cur_charset ()	2020	rxvt_term::selection_screen (int screen = -1)
1550	CODE:	2021	CODE:
1551	RETVAL = THIS->charsets [THIS->screen.charset];	2022	RETVAL = THIS->selection.screen;
1552	OUTPUT:	2023	if (screen >= 0)
		2024	THIS->selection.screen = screen;
		2025	OUTPUT:
1553	RETVAL	2026	RETVAL
1554		2027
1555	#void	2028	void
1556	#rxvt_term::selection_clear ()	2029	rxvt_term::selection_request (Time tm, int selnum)
		2030
		2031	void
		2032	rxvt_term::selection_clear (bool clipboard = false)
1557		2033
1558	void	2034	void
1559	rxvt_term::selection_make (Time eventtime, bool rect = false)	2035	rxvt_term::selection_make (Time eventtime, bool rect = false)
1560	CODE:	2036	CODE:
1561	THIS->selection.op = SELECTION_CONT;	2037	THIS->selection.op = SELECTION_CONT;
1562	THIS->selection.rect = rect;	2038	THIS->selection.rect = rect;
1563	THIS->selection_make (eventtime);	2039	THIS->selection_make (eventtime);
1564		2040
1565	int	2041	int
1566	rxvt_term::selection_grab (Time eventtime)	2042	rxvt_term::selection_grab (Time eventtime, bool clipboard = false)
1567		2043
1568	void	2044	void
1569	rxvt_term::selection (SV *newtext = 0)	2045	rxvt_term::selection (SV *newtext = 0, bool clipboard = false)
1570	PPCODE:	2046	PPCODE:
1571	{	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
1572	if (GIMME_V != G_VOID)	2051	if (GIMME_V != G_VOID)
1573	XPUSHs (THIS->selection.text	2052	XPUSHs (text
1574	? sv_2mortal (wcs2sv (THIS->selection.text, THIS->selection.len))	2053	? sv_2mortal (wcs2sv (text, len))
1575	: &PL_sv_undef);	2054	: &PL_sv_undef);
1576		2055
1577	if (newtext)	2056	if (newtext)
1578	{	2057	{
1579	free (THIS->selection.text);	2058	free (text);
1580		2059
1581	THIS->selection.text = sv2wcs (newtext);	2060	text = sv2wcs (newtext);
1582	THIS->selection.len = wcslen (THIS->selection.text);	2061	len = wcslen (text);
1583	}	2062	}
1584	}	2063	}
		2064
		2065	char
		2066	rxvt_term::cur_charset ()
		2067	CODE:
		2068	RETVAL = THIS->charsets [THIS->screen.charset];
		2069	OUTPUT:
		2070	RETVAL
1585		2071
1586	void	2072	void
1587	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)
1588		2074
1589	void	2075	void
1590	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)
1591		2077
1592	void	2078	void
1593	rxvt_term::scr_bell ()	2079	rxvt_term::scr_bell ()
		2080
		2081	void
		2082	rxvt_term::scr_recolor (bool refresh = true);
1594		2083
1595	void	2084	void
1596	rxvt_term::scr_change_screen (int screen)	2085	rxvt_term::scr_change_screen (int screen)
1597		2086
1598	void	2087	void
…		…
1601	{	2090	{
1602	wchar_t *wstr = sv2wcs (string);	2091	wchar_t *wstr = sv2wcs (string);
1603	THIS->scr_add_lines (wstr, wcslen (wstr));	2092	THIS->scr_add_lines (wstr, wcslen (wstr));
1604	free (wstr);	2093	free (wstr);
1605	}	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
1606		2103
1607	void	2104	void
1608	rxvt_term::tt_write (SV *octets)	2105	rxvt_term::tt_write (SV *octets)
1609	INIT:	2106	INIT:
1610	STRLEN len;	2107	STRLEN len;
1611	char *str = SvPVbyte (octets, len);	2108	char *str = SvPVbyte (octets, len);
1612	C_ARGS:	2109	C_ARGS:
1613	str, len	2110	str, len
1614		2111
1615	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
1616	rxvt_term::cmd_parse (SV *octets)	2121	rxvt_term::cmd_parse (SV *octets)
1617	CODE:	2122	CODE:
1618	{	2123	{
1619	STRLEN len;	2124	STRLEN len;
1620	char *str = SvPVbyte (octets, len);	2125	char *str = SvPVbyte (octets, len);
…		…
1651	void	2156	void
1652	rxvt_term::XListProperties (Window window)	2157	rxvt_term::XListProperties (Window window)
1653	PPCODE:	2158	PPCODE:
1654	{	2159	{
1655	int count;	2160	int count;
1656	Atom *props = XListProperties (THIS->display->display, window, &count);	2161	Atom *props = XListProperties (THIS->dpy, window, &count);
1657		2162
1658	EXTEND (SP, count);	2163	EXTEND (SP, count);
1659	while (count--)	2164	while (count--)
1660	PUSHs (newSVuv ((U32)props [count]));	2165	PUSHs (newSVuv ((U32)props [count]));
1661		2166
1662	XFree (props);	2167	XFree (props);
1663	}	2168	}
1664		2169
1665	void	2170	void
1666	rxvt_term::XGetWindowProperty (Window window, Atom property)	2171	rxvt_term::XGetWindowProperty (Window window, Atom property)
…		…
1670	int format;	2175	int format;
1671	unsigned long nitems;	2176	unsigned long nitems;
1672	unsigned long bytes_after;	2177	unsigned long bytes_after;
1673	unsigned char *prop;	2178	unsigned char *prop;
1674		2179
1675	XGetWindowProperty (THIS->display->display, window, property,	2180	XGetWindowProperty (THIS->dpy, window, property,
1676	0, 1<<24, 0, AnyPropertyType,	2181	0, 1<<24, 0, AnyPropertyType,
1677	&type, &format, &nitems, &bytes_after, &prop);	2182	&type, &format, &nitems, &bytes_after, &prop);
1678		2183
1679	if (type != None)	2184	if (type != None)
1680	{	2185	{
…		…
1689	XFree (prop);	2194	XFree (prop);
1690	}	2195	}
1691	}	2196	}
1692		2197
1693	void	2198	void
1694	rxvt_term::XChangeWindowProperty (Window window, Atom property, Atom type, int format, SV *data)	2199	rxvt_term::XChangeProperty (Window window, Atom property, Atom type, int format, SV *data)
1695	CODE:	2200	CODE:
1696	{	2201	{
1697	STRLEN len;	2202	STRLEN len;
1698	char *data_ = SvPVbyte (data, len);	2203	char *data_ = SvPVbyte (data, len);
1699		2204
1700	int elemsize = format == 16 ? sizeof (short)	2205	int elemsize = format == 16 ? sizeof (short)
1701	: format == 32 ? sizeof (long)	2206	: format == 32 ? sizeof (long)
1702	: 1;	2207	: 1;
1703		2208
1704	XChangeProperty (THIS->display->display, window, property,	2209	XChangeProperty (THIS->dpy, window, property,
1705	type, format, PropModeReplace,	2210	type, format, PropModeReplace,
1706	(unsigned char *)data_, len / elemsize);	2211	(unsigned char *)data_, len / elemsize);
1707	XSync (THIS->display->display, 0);
1708	}	2212	}
1709		2213
1710	Atom	2214	Atom
1711	XInternAtom (rxvt_term *term, char *atom_name, int only_if_exists = FALSE)	2215	XInternAtom (rxvt_term *term, octet_string atom_name, int only_if_exists = FALSE)
1712	C_ARGS: term->display->display, atom_name, only_if_exists	2216	C_ARGS: term->dpy, atom_name, only_if_exists
1713		2217
1714	char *	2218	char *
1715	XGetAtomName (rxvt_term *term, Atom atom)	2219	XGetAtomName (rxvt_term *term, Atom atom)
1716	C_ARGS: term->display->display, atom	2220	C_ARGS: term->dpy, atom
1717	CLEANUP:	2221	CLEANUP:
1718	XFree (RETVAL);	2222	XFree (RETVAL);
1719		2223
1720	void	2224	void
1721	XDeleteProperty (rxvt_term *term, Window window, Atom property)	2225	XDeleteProperty (rxvt_term *term, Window window, Atom property)
1722	C_ARGS: term->display->display, window, 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
1723		2285
1724	Window	2286	Window
1725	rxvt_term::DefaultRootWindow ()	2287	rxvt_term::DefaultRootWindow ()
1726	CODE:	2288	CODE:
1727	RETVAL = THIS->display->root;	2289	RETVAL = THIS->display->root;
…		…
1730		2292
1731	#if 0	2293	#if 0
1732		2294
1733	Window	2295	Window
1734	XCreateSimpleWindow (rxvt_term *term, Window parent, int x, int y, unsigned int width, unsigned int height)	2296	XCreateSimpleWindow (rxvt_term *term, Window parent, int x, int y, unsigned int width, unsigned int height)
1735	C_ARGS: term->display->display, (Window)parent,	2297	C_ARGS: term->dpy, (Window)parent,
1736	x, y, width, height, 0,	2298	x, y, width, height, 0,
1737	term->pix_colors_focused[Color_border],	2299	term->pix_colors_focused[Color_border],
1738	term->pix_colors_focused[Color_border]	2300	term->pix_colors_focused[Color_border]
1739		2301
1740	#endif	2302	#endif
1741		2303
1742	void	2304	void
1743	XReparentWindow (rxvt_term *term, Window window, Window parent, int x = 0, int y = 0)	2305	XReparentWindow (rxvt_term *term, Window window, Window parent, int x = 0, int y = 0)
1744	C_ARGS: term->display->display, window, parent, x, y	2306	C_ARGS: term->dpy, window, parent, x, y
1745		2307
1746	void	2308	void
1747	XMapWindow (rxvt_term *term, Window window)	2309	XMapWindow (rxvt_term *term, Window window)
1748	C_ARGS: term->display->display, window	2310	C_ARGS: term->dpy, window
1749		2311
1750	void	2312	void
1751	XUnmapWindow (rxvt_term *term, Window window)	2313	XUnmapWindow (rxvt_term *term, Window window)
1752	C_ARGS: term->display->display, window	2314	C_ARGS: term->dpy, window
1753		2315
1754	void	2316	void
1755	XMoveResizeWindow (rxvt_term *term, Window window, int x, int y, unsigned int width, unsigned int height)	2317	XMoveResizeWindow (rxvt_term *term, Window window, int x, int y, unsigned int width, unsigned int height)
1756	C_ARGS: term->display->display, window, x, y, width, height	2318	C_ARGS: term->dpy, window, x, y, width, height
1757		2319
1758	void	2320	void
1759	rxvt_term::XChangeInput (Window window, U32 add_events, U32 del_events = 0)	2321	rxvt_term::XChangeInput (Window window, U32 add_events, U32 del_events = 0)
1760	CODE:	2322	CODE:
1761	{	2323	{
1762	XWindowAttributes attr;	2324	XWindowAttributes attr;
1763	XGetWindowAttributes (THIS->display->display, window, &attr);	2325	XGetWindowAttributes (THIS->dpy, window, &attr);
1764	XSelectInput (THIS->display->display, window, attr.your_event_mask | add_events & ~del_events);	2326	XSelectInput (THIS->dpy, window, attr.your_event_mask | add_events & ~del_events);
1765	}	2327	}
1766		2328
1767	void	2329	void
1768	rxvt_term::XTranslateCoordinates (Window src, Window dst, int x, int y)	2330	rxvt_term::XTranslateCoordinates (Window src, Window dst, int x, int y)
1769	PPCODE:	2331	PPCODE:
1770	{	2332	{
1771	int dx, dy;	2333	int dx, dy;
1772	Window child;	2334	Window child;
1773		2335
1774	if (XTranslateCoordinates (THIS->display->display, src, dst, x, y, &dx, &dy, &child))	2336	if (XTranslateCoordinates (THIS->dpy, src, dst, x, y, &dx, &dy, &child))
1775	{	2337	{
1776	EXTEND (SP, 3);	2338	EXTEND (SP, 3);
1777	PUSHs (newSViv (dx));	2339	PUSHs (newSViv (dx));
1778	PUSHs (newSViv (dy));	2340	PUSHs (newSViv (dy));
1779	PUSHs (newSVuv (child));	2341	PUSHs (newSVuv (child));
1780	}	2342	}
1781	}	2343	}
1782		2344
1783	#############################################################################	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	#############################################################################
1784	# urxvt::overlay	2446	# urxvt::overlay
1785	#############################################################################	2447	#############################################################################
1786		2448
1787	MODULE = urxvt PACKAGE = urxvt::overlay	2449	MODULE = urxvt PACKAGE = urxvt::overlay
1788		2450
…		…
1796	overlay::hide ()	2458	overlay::hide ()
1797		2459
1798	void	2460	void
1799	overlay::DESTROY ()	2461	overlay::DESTROY ()
1800		2462
1801	#############################################################################	2463	INCLUDE: $PERL <iom_perl.xs -pe s/IOM_MODULE/urxvt/g,s/IOM_CLASS/urxvt/g |
1802	# urxvt::watcher
1803	#############################################################################
1804		2464
1805	MODULE = urxvt PACKAGE = urxvt::watcher
1806
1807	CHAINED
1808	perl_watcher::cb (SV *cb)
1809	CODE:
1810	THIS->cb (cb);
1811	OUTPUT:
1812	RETVAL
1813
1814	#############################################################################
1815	# urxvt::timer
1816	#############################################################################
1817
1818	MODULE = urxvt PACKAGE = urxvt::timer
1819
1820	SV *
1821	timer::new ()
1822	CODE:
1823	timer *w = new timer;
1824	w->start (NOW);
1825	RETVAL = newSVptr ((void *)(perl_watcher *)w, "urxvt::timer");
1826	w->self = (HV *)SvRV (RETVAL);
1827	OUTPUT:
1828	RETVAL
1829
1830	NV
1831	timer::at ()
1832	CODE:
1833	RETVAL = THIS->at;
1834	OUTPUT:
1835	RETVAL
1836
1837	CHAINED
1838	timer::interval (NV interval)
1839	CODE:
1840	THIS->interval = interval;
1841	OUTPUT:
1842	RETVAL
1843
1844	CHAINED
1845	timer::set (NV tstamp)
1846	CODE:
1847	THIS->set (tstamp);
1848	OUTPUT:
1849	RETVAL
1850
1851	CHAINED
1852	timer::start (NV tstamp = THIS->at)
1853	CODE:
1854	THIS->start (tstamp);
1855	OUTPUT:
1856	RETVAL
1857
1858	CHAINED
1859	timer::after (NV delay)
1860	CODE:
1861	THIS->start (NOW + delay);
1862	OUTPUT:
1863	RETVAL
1864
1865	CHAINED
1866	timer::stop ()
1867	CODE:
1868	THIS->stop ();
1869	OUTPUT:
1870	RETVAL
1871
1872	void
1873	timer::DESTROY ()
1874
1875	#############################################################################
1876	# urxvt::iow
1877	#############################################################################
1878
1879	MODULE = urxvt PACKAGE = urxvt::iow	2465	MODULE = urxvt PACKAGE = urxvt::pixbuf PREFIX = gdk_pixbuf_
1880		2466
1881	SV *	2467	#if HAVE_PIXBUF
1882	iow::new ()
1883	CODE:
1884	iow *w = new iow;
1885	RETVAL = newSVptr ((void *)(perl_watcher *)w, "urxvt::iow");
1886	w->self = (HV *)SvRV (RETVAL);
1887	OUTPUT:
1888	RETVAL
1889		2468
1890	CHAINED	2469	urxvt::pixbuf gdk_pixbuf_new_from_file (SV *klass, octet_string filename)
1891	iow::fd (int fd)	2470	C_ARGS: filename, 0
1892	CODE:
1893	THIS->fd = fd;
1894	OUTPUT:
1895	RETVAL
1896		2471
1897	CHAINED
1898	iow::events (short events)
1899	CODE:
1900	THIS->events = events;
1901	OUTPUT:
1902	RETVAL
1903
1904	CHAINED
1905	iow::start ()
1906	CODE:
1907	THIS->start ();
1908	OUTPUT:
1909	RETVAL
1910
1911	CHAINED
1912	iow::stop ()
1913	CODE:
1914	THIS->stop ();
1915	OUTPUT:
1916	RETVAL
1917
1918	void	2472	void
1919	iow::DESTROY ()	2473	DESTROY (urxvt::pixbuf self)
		2474	CODE:
		2475	g_object_unref (self);
1920		2476
1921	#############################################################################	2477	#endif
1922	# urxvt::iw
1923	#############################################################################
1924		2478
1925	MODULE = urxvt PACKAGE = urxvt::iw	2479	MODULE = urxvt PACKAGE = urxvt::img
1926		2480
1927	SV *	2481	#if HAVE_IMG
1928	iw::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 ()
1929	CODE:	2488	PPCODE:
1930	iw *w = new iw;	2489	EXTEND (SP, 4);
1931	RETVAL = newSVptr ((void *)(perl_watcher *)w, "urxvt::iw");	2490	PUSHs (sv_2mortal (newSViv (THIS->x)));
1932	w->self = (HV *)SvRV (RETVAL);	2491	PUSHs (sv_2mortal (newSViv (THIS->y)));
1933	OUTPUT:	2492	PUSHs (sv_2mortal (newSViv (THIS->w)));
1934	RETVAL	2493	PUSHs (sv_2mortal (newSViv (THIS->h)));
1935		2494
1936	CHAINED	2495	int
1937	iw::start ()	2496	rxvt_img::x ()
		2497	ALIAS:
		2498	x = 0
		2499	y = 1
		2500	w = 2
		2501	h = 3
		2502	CODE:
		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:
		2511	RETVAL
		2512
		2513	Pixmap
		2514	rxvt_img::pm ()
		2515	CODE:
		2516	RETVAL = THIS->pm;
		2517	OUTPUT:
		2518	RETVAL
		2519
		2520	void
		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)
1938	CODE:	2542	PPCODE:
1939	THIS->start ();	2543	if (items >= 2)
1940	OUTPUT:	2544	THIS->repeat_mode (repeat);
1941	RETVAL	2545	if (GIMME_V != G_VOID)
		2546	XPUSHs (sv_2mortal (newSViv (THIS->repeat)));
1942		2547
1943	CHAINED
1944	iw::stop ()
1945	CODE:
1946	THIS->stop ();
1947	OUTPUT:
1948	RETVAL
1949
1950	void	2548	void
1951	iw::DESTROY ()	2549	rxvt_img::move (int dx, int dy)
1952		2550
1953	#############################################################################
1954	# urxvt::pw
1955	#############################################################################
1956
1957	MODULE = urxvt PACKAGE = urxvt::pw
1958
1959	SV *
1960	pw::new ()
1961	CODE:
1962	pw *w = new pw;
1963	RETVAL = newSVptr ((void *)(perl_watcher *)w, "urxvt::pw");
1964	w->self = (HV *)SvRV (RETVAL);
1965	OUTPUT:
1966	RETVAL
1967
1968	CHAINED
1969	pw::start (int pid)
1970	CODE:
1971	THIS->start (pid);
1972	OUTPUT:
1973	RETVAL
1974
1975	CHAINED
1976	pw::stop ()
1977	CODE:
1978	THIS->stop ();
1979	OUTPUT:
1980	RETVAL
1981
1982	void	2551	void
1983	pw::DESTROY ()	2552	rxvt_img::brightness (rxvt_img::nv r, rxvt_img::nv g, rxvt_img::nv b, rxvt_img::nv a = 1.)
1984		2553
		2554	void
		2555	rxvt_img::contrast (rxvt_img::nv r, rxvt_img::nv g, rxvt_img::nv b, rxvt_img::nv a = 1.)
1985		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:
		2623	RETVAL
		2624
		2625	#endif
		2626

Diff Legend

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