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.99 by root, Sat Feb 11 02:28:19 2006 UTC vs.
Revision 1.259 by sf-exg, Sun Mar 5 06:11:32 2023 UTC

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

Diff Legend

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