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.101 by root, Wed Jul 5 23:34:14 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	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	{
…		…
360	break;	298	break;
361		299
362	for (; i < AvFILL (overlay_av); i++)	300	for (; i < AvFILL (overlay_av); i++)
363	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)));
364		302
365	av_pop (overlay_av);	303	SvREFCNT_dec (av_pop (overlay_av));
366		304
367	SvREFCNT_dec (overlay_av);	305	SvREFCNT_dec (overlay_av);
368	overlay_av = 0;	306	overlay_av = 0;
369		307
370	THIS->want_refresh = 1;	308	THIS->want_refresh = 1;
		309	THIS->refresh_check ();
371	}	310	}
372		311
373	void overlay::swap ()	312	void overlay::swap ()
374	{	313	{
375	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));
376	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));
377		316
378	int ov_w = min (w, THIS->ncol - ov_x);	317	int ov_w = min (w, THIS->ncol - ov_x);
379	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;
380		324
381	for (int y = ov_h; y--; )	325	for (int y = ov_h; y--; )
382	{	326	{
383	text_t *t1 = text [y];	327	text_t *t1 = text [y];
384	rend_t *r1 = rend [y];	328	rend_t *r1 = rend [y];
…		…
420	for (int col = min (AvFILL (av) + 1, w - x - border); col--; )	364	for (int col = min (AvFILL (av) + 1, w - x - border); col--; )
421	this->rend [y][x + col] = SvIV (*av_fetch (av, col, 1));	365	this->rend [y][x + col] = SvIV (*av_fetch (av, col, 1));
422	}	366	}
423		367
424	THIS->want_refresh = 1;	368	THIS->want_refresh = 1;
		369	THIS->refresh_check ();
425	}	370	}
426
427		371
428	/////////////////////////////////////////////////////////////////////////////	372	/////////////////////////////////////////////////////////////////////////////
429		373
		374	#include "iom_perl.h"
		375
		376	/////////////////////////////////////////////////////////////////////////////
		377
430	struct rxvt_perl_interp rxvt_perl;	378	struct rxvt_perl_interp rxvt_perl;
431		379
432	static PerlInterpreter *perl;	380	static PerlInterpreter *perl;
433		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... */
434	rxvt_perl_interp::~rxvt_perl_interp ()	385	rxvt_perl_interp::~rxvt_perl_interp ()
435	{	386	{
436	if (perl)	387	if (perl)
437	{	388	{
		389	localise_env set_environ (perl_environ);
438	perl_destruct (perl);	390	perl_destruct (perl);
439	perl_free (perl);	391	perl_free (perl);
		392	PERL_SYS_TERM ();
440	}	393	}
441	}	394	}
		395	#endif
442		396
443	void	397	void
444	rxvt_perl_interp::init (rxvt_term *term)	398	rxvt_perl_interp::init ()
445	{	399	{
446	if (!perl)	400	if (!perl)
447	{	401	{
448	rxvt_push_locale (""); // perl init destroys current locale	402	rxvt_push_locale (""); // perl init destroys current locale
449		403
		404	{
450	perl_environ = rxvt_environ;	405	perl_environ = rxvt_environ;
451	swap (perl_environ, environ);	406	localise_env set_environ (perl_environ);
452		407
453	char *argv[] = {	408	const char *args[] = {
454	"",	409	"",
455	"-e"	410	"-e"
456	"BEGIN {"	411	"BEGIN {"
457	" urxvt->bootstrap;"	412	" urxvt->bootstrap;"
458	" unshift @INC, '" LIBDIR "';"	413	" unshift @INC, '" LIBDIR "';"
459	"}"	414	"}"
460	""	415	""
461	"use urxvt;"	416	"use urxvt;",
		417	0
462	};	418	};
		419	int argc = ecb_array_length (args) - 1;
		420	char **argv = (char **)args;
463		421
		422	PERL_SYS_INIT3 (&argc, &argv, &environ);
464	perl = perl_alloc ();	423	perl = perl_alloc ();
465	perl_construct (perl);	424	perl_construct (perl);
466		425
467	if (perl_parse (perl, xs_init, 2, argv, (char **)NULL)	426	if (perl_parse (perl, xs_init, argc, argv, (char **)NULL)
468	|| perl_run (perl))	427	|| perl_run (perl))
469	{	428	{
470	rxvt_warn ("unable to initialize perl-interpreter, continuing without.\n");	429	rxvt_warn ("unable to initialize perl-interpreter, continuing without.\n");
471		430
472	perl_destruct (perl);	431	perl_destruct (perl);
473	perl_free (perl);	432	perl_free (perl);
474	perl = 0;	433	perl = 0;
475	}	434	}
476		435	}
477	swap (perl_environ, environ);
478		436
479	rxvt_pop_locale ();	437	rxvt_pop_locale ();
480	}	438	}
		439	}
481		440
482	if (perl)	441	void
		442	rxvt_perl_interp::init (rxvt_term *term)
		443	{
		444	init ();
		445
		446	if (perl && !term->perl.self)
483	{	447	{
484	// runs outside of perls ENV	448	// runs outside of perls ENV
485	term->perl.self = (void *)newSVptr ((void *)term, "urxvt::term");	449	term->perl.self = (void *)newSVptr ((void *)term, "urxvt::term");
486	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);
487	}	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);
488	}	527	}
489		528
490	static void	529	static void
491	ungrab (rxvt_term *THIS)	530	ungrab (rxvt_term *THIS)
492	{	531	{
…		…
497	THIS->perl.grabtime = 0;	536	THIS->perl.grabtime = 0;
498	}	537	}
499	}	538	}
500		539
501	bool	540	bool
502	rxvt_perl_interp::invoke (rxvt_term *term, hook_type htype, ...)	541	rxvt_perl_interp::invoke (rxvt_term *term, int htype, ...)
503	{	542	{
504	if (!perl || !term->perl.self)	543	if (!perl || !term->perl.self)
505	return false;	544	return false;
		545
		546	localise_env set_environ (perl_environ);
506		547
507	// pre-handling of some events	548	// pre-handling of some events
508	if (htype == HOOK_REFRESH_END)	549	if (htype == HOOK_REFRESH_END)
509	{	550	{
510	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));
511		552
512	for (int i = 0; i <= AvFILL (av); i++)	553	for (int i = 0; i <= AvFILL (av); i++)
513	((overlay *)SvIV (*av_fetch (av, i, 0)))->swap ();	554	((overlay *)SvIV (*av_fetch (av, i, 0)))->swap ();
514	}	555	}
		556	else if (htype == HOOK_DESTROY)
		557	{
		558	AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_selection", 10, 0));
515		559
516	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	}
517		566
518	bool event_consumed;	567	bool event_consumed;
519		568
520	if (htype == HOOK_INIT || htype == HOOK_DESTROY // must be called always
521	|| term->perl.should_invoke [htype])	569	if (term->perl.should_invoke [htype])
522	try
523	{	570	{
524	dSP;	571	dSP;
525	va_list ap;	572	va_list ap;
526		573
527	va_start (ap, htype);	574	va_start (ap, htype);
528		575
529	ENTER;	576	ENTER;
530	SAVETMPS;	577	SAVETMPS;
531		578
532	PUSHMARK (SP);	579	PUSHMARK (SP);
533		580
		581	EXTEND (SP, 2);
534	XPUSHs (sv_2mortal (newSVterm (term)));	582	PUSHs (sv_2mortal (newSVterm (term)));
535	XPUSHs (sv_2mortal (newSViv (htype)));	583	PUSHs (sv_2mortal (newSViv (htype)));
536		584
537	for (;;) {	585	for (;;) {
538	data_type dt = (data_type)va_arg (ap, int);	586	data_type dt = (data_type)va_arg (ap, int);
539		587
540	switch (dt)	588	switch (dt)
541	{	589	{
542	case DT_INT:	590	case DT_INT:
543	XPUSHs (sv_2mortal (newSViv (va_arg (ap, int))));	591	XPUSHs (sv_2mortal (newSViv (va_arg (ap, int))));
544	break;	592	break;
545		593
546	case DT_LONG:	594	case DT_LONG:
547	XPUSHs (sv_2mortal (newSViv (va_arg (ap, long))));	595	XPUSHs (sv_2mortal (newSViv (va_arg (ap, long))));
548	break;	596	break;
549		597
550	case DT_STR:	598	case DT_STR:
551	XPUSHs (sv_2mortal (newSVpv (va_arg (ap, char *), 0)));	599	XPUSHs (sv_2mortal (newSVpv (va_arg (ap, char *), 0)));
552	break;	600	break;
553		601
554	case DT_STR_LEN:	602	case DT_STR_LEN:
555	{	603	{
556	char *str = va_arg (ap, char *);	604	char *str = va_arg (ap, char *);
557	int len = va_arg (ap, int);	605	int len = va_arg (ap, int);
558		606
559	XPUSHs (sv_2mortal (newSVpvn (str, len)));	607	XPUSHs (sv_2mortal (newSVpvn (str, len)));
560	}	608	}
561	break;	609	break;
562		610
563	case DT_WCS_LEN:	611	case DT_WCS_LEN:
564	{	612	{
565	wchar_t *wstr = va_arg (ap, wchar_t *);	613	wchar_t *wstr = va_arg (ap, wchar_t *);
566	int wlen = va_arg (ap, int);	614	int wlen = va_arg (ap, int);
567		615
568	XPUSHs (sv_2mortal (wcs2sv (wstr, wlen)));	616	XPUSHs (sv_2mortal (wcs2sv (wstr, wlen)));
569	}	617	}
570	break;	618	break;
571		619
572	case DT_LCS_LEN:	620	case DT_LCS_LEN:
573	{	621	{
574	long *lstr = va_arg (ap, long *);	622	long *lstr = va_arg (ap, long *);
575	int llen = va_arg (ap, int);	623	int llen = va_arg (ap, int);
576		624
577	XPUSHs (sv_2mortal (newSVpvn ((char *)lstr, llen * sizeof (long))));	625	XPUSHs (sv_2mortal (newSVpvn ((char *)lstr, llen * sizeof (long))));
578	}	626	}
579	break;	627	break;
580		628
581	case DT_XEVENT:	629	case DT_XEVENT:
582	{	630	{
583	XEvent *xe = va_arg (ap, XEvent *);	631	XEvent *xe = va_arg (ap, XEvent *);
584	HV *hv = newHV ();	632	HV *hv = newHV ();
585		633
586	# 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)
587	# 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)
588	# 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)
589	# undef set	637	# undef set
590		638
591	setiv (type, xe->type);	639	setiv (type, xe->type);
592	setiv (send_event, xe->xany.send_event);	640	setiv (send_event, xe->xany.send_event);
593	setiv (serial, xe->xany.serial);	641	setiv (serial, xe->xany.serial);
594		642
595	switch (xe->type)	643	switch (xe->type)
596	{	644	{
597	case KeyPress:	645	case KeyPress:
598	case KeyRelease:	646	case KeyRelease:
599	case ButtonPress:	647	case ButtonPress:
600	case ButtonRelease:	648	case ButtonRelease:
601	case MotionNotify:	649	case MotionNotify:
602	setuv (window, xe->xmotion.window);	650	setuv (window, xe->xmotion.window);
603	setuv (root, xe->xmotion.root);	651	setuv (root, xe->xmotion.root);
604	setuv (subwindow, xe->xmotion.subwindow);	652	setuv (subwindow, xe->xmotion.subwindow);
605	setuv (time, xe->xmotion.time);	653	setuv (time, xe->xmotion.time);
606	setiv (x, xe->xmotion.x);	654	setiv (x, xe->xmotion.x);
607	setiv (y, xe->xmotion.y);	655	setiv (y, xe->xmotion.y);
608	setiv (row, xe->xmotion.y / term->fheight + term->view_start);	656	setiv (row, xe->xmotion.y / term->fheight + term->view_start);
609	setiv (col, xe->xmotion.x / term->fwidth);	657	setiv (col, xe->xmotion.x / term->fwidth);
610	setiv (x_root, xe->xmotion.x_root);	658	setiv (x_root, xe->xmotion.x_root);
611	setiv (y_root, xe->xmotion.y_root);	659	setiv (y_root, xe->xmotion.y_root);
612	setuv (state, xe->xmotion.state);	660	setuv (state, xe->xmotion.state);
613		661
614	switch (xe->type)	662	switch (xe->type)
615	{	663	{
616	case KeyPress:	664	case KeyPress:
617	case KeyRelease:	665	case KeyRelease:
618	setuv (keycode, xe->xkey.keycode);	666	setuv (keycode, xe->xkey.keycode);
619	break;	667	break;
620		668
621	case ButtonPress:	669	case ButtonPress:
622	case ButtonRelease:	670	case ButtonRelease:
623	setuv (button, xe->xbutton.button);	671	setuv (button, xe->xbutton.button);
624	break;	672	break;
625		673
626	case MotionNotify:	674	case MotionNotify:
627	setiv (is_hint, xe->xmotion.is_hint);	675	setiv (is_hint, xe->xmotion.is_hint);
628	break;	676	break;
629	}	677	}
630		678
631	break;	679	break;
632		680
633	case MapNotify:	681	case MapNotify:
634	case UnmapNotify:	682	case UnmapNotify:
635	case ConfigureNotify:	683	case ConfigureNotify:
636	setuv (event, xe->xconfigure.event);	684	setuv (event, xe->xconfigure.event);
637	setuv (window, xe->xconfigure.window);	685	setuv (window, xe->xconfigure.window);
638		686
639	switch (xe->type)	687	switch (xe->type)
640	{	688	{
641	case ConfigureNotify:	689	case ConfigureNotify:
642	setiv (x, xe->xconfigure.x);	690	setiv (x, xe->xconfigure.x);
643	setiv (y, xe->xconfigure.y);	691	setiv (y, xe->xconfigure.y);
644	setiv (width, xe->xconfigure.width);	692	setiv (width, xe->xconfigure.width);
645	setiv (height, xe->xconfigure.height);	693	setiv (height, xe->xconfigure.height);
646	setuv (above, xe->xconfigure.above);	694	setuv (above, xe->xconfigure.above);
647	break;	695	break;
648	}	696	}
649		697
650	break;	698	break;
651		699
652	case PropertyNotify:	700	case PropertyNotify:
653	setuv (window, xe->xproperty.window);	701	setuv (window, xe->xproperty.window);
654	setuv (atom, xe->xproperty.atom);	702	setuv (atom, xe->xproperty.atom);
655	setuv (time, xe->xproperty.time);	703	setuv (time, xe->xproperty.time);
656	setiv (state, xe->xproperty.state);	704	setiv (state, xe->xproperty.state);
657	break;	705	break;
658		706
659	case ClientMessage:	707	case ClientMessage:
660	setuv (window, xe->xclient.window);	708	setuv (window, xe->xclient.window);
661	setuv (message_type, xe->xclient.message_type);	709	setuv (message_type, xe->xclient.message_type);
662	setuv (format, xe->xclient.format);	710	setuv (format, xe->xclient.format);
663	setuv (l0, xe->xclient.data.l[0]);	711	setuv (l0, xe->xclient.data.l[0]);
664	setuv (l1, xe->xclient.data.l[1]);	712	setuv (l1, xe->xclient.data.l[1]);
665	setuv (l2, xe->xclient.data.l[2]);	713	setuv (l2, xe->xclient.data.l[2]);
666	setuv (l3, xe->xclient.data.l[3]);	714	setuv (l3, xe->xclient.data.l[3]);
667	setuv (l4, xe->xclient.data.l[4]);	715	setuv (l4, xe->xclient.data.l[4]);
668	break;	716	break;
669	}	717	}
670		718
671	XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));	719	XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
672	}	720	}
673	break;	721	break;
674		722
675	case DT_END:	723	case DT_END:
676	goto call;	724	goto call;
677		725
678	default:	726	default:
679	rxvt_fatal ("FATAL: unable to pass data type %d\n", dt);	727	rxvt_fatal ("FATAL: unable to pass data type %d\n", dt);
680	}	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);
681	}	742	}
682		743
683	call:
684	va_end (ap);
685
686	PUTBACK;	744	PUTBACK;
687	int count = call_pv ("urxvt::invoke", G_ARRAY | G_EVAL);
688	SPAGAIN;
689
690	if (count)
691	{
692	SV *status = POPs;
693	count = SvTRUE (status);
694	}
695
696	PUTBACK;
697	FREETMPS;	745	FREETMPS;
698	LEAVE;	746	LEAVE;
699		747
700	if (SvTRUE (ERRSV))	748	if (SvTRUE (ERRSV))
701	{	749	{
702	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));
703	ungrab (term); // better lose the grab than the session	751	ungrab (term); // better lose the grab than the session
704	}	752	}
705		753
706	event_consumed = !!count;	754	event_consumed = !!count;
707	}	755	}
708	catch (...)
709	{
710	swap (perl_environ, environ);
711	throw;
712	}
713	else	756	else
714	event_consumed = false;	757	event_consumed = false;
715		758
716	// post-handling of some events	759	// post-handling of some events
717	if (htype == HOOK_REFRESH_BEGIN)	760	if (htype == HOOK_REFRESH_BEGIN)
718	{	761	{
719	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));
720		763
721	for (int i = AvFILL (av); i >= 0; i--)	764	for (int i = AvFILL (av); i >= 0; i--)
722	((overlay *)SvIV (*av_fetch (av, i, 0)))->swap ();	765	((overlay *)SvIV (*av_fetch (av, i, 0)))->swap ();
723	}	766	}
724	else if (htype == HOOK_DESTROY)	767	else if (htype == HOOK_DESTROY)
725	{	768	{
726	clearSVptr ((SV *)term->perl.self);	769	clearSVptr ((SV *)term->perl.self);
727	SvREFCNT_dec ((SV *)term->perl.self);	770	SvREFCNT_dec ((SV *)term->perl.self);
728		771
729	// don't allow further calls	772	// don't allow further calls
730	term->perl.self = 0;	773	term->perl.self = 0;
731	}	774	}
732		775
733	swap (perl_environ, environ);
734
735	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;
736	}	797	}
737		798
738	/////////////////////////////////////////////////////////////////////////////	799	/////////////////////////////////////////////////////////////////////////////
739		800
740	MODULE = urxvt PACKAGE = urxvt	801	MODULE = urxvt PACKAGE = urxvt
…		…
752	# define def(sym) av_store (hookname, HOOK_ ## sym, newSVpv (# sym, 0));	813	# define def(sym) av_store (hookname, HOOK_ ## sym, newSVpv (# sym, 0));
753	# include "hookinc.h"	814	# include "hookinc.h"
754	# undef def	815	# undef def
755		816
756	HV *option = get_hv ("urxvt::OPTION", 1);	817	HV *option = get_hv ("urxvt::OPTION", 1);
757	# 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);
758	# define nodef(name)	819	# define nodef(name)
759	# include "optinc.h"	820	# include "optinc.h"
760	# undef nodef	821	# undef nodef
761	# undef def	822	# undef def
762		823
…		…
764	static const struct {	825	static const struct {
765	const char *name;	826	const char *name;
766	IV iv;	827	IV iv;
767	} *civ, const_iv[] = {	828	} *civ, const_iv[] = {
768	# 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),
769	const_iv (DEFAULT_RSTYLE),	837	const_iv (DEFAULT_RSTYLE),
770	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),
771	const_iv (RS_Bold),	850	const_iv (RS_Bold),
772	const_iv (RS_Italic),	851	const_iv (RS_Italic),
773	const_iv (RS_Blink),	852	const_iv (RS_Blink),
774	const_iv (RS_RVid),	853	const_iv (RS_RVid),
775	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),
776		867
777	const_iv (CurrentTime),	868	const_iv (CurrentTime),
778	const_iv (ShiftMask),	869	const_iv (ShiftMask),
779	const_iv (LockMask),	870	const_iv (LockMask),
780	const_iv (ControlMask),	871	const_iv (ControlMask),
…		…
788	const_iv (Button3Mask),	879	const_iv (Button3Mask),
789	const_iv (Button4Mask),	880	const_iv (Button4Mask),
790	const_iv (Button5Mask),	881	const_iv (Button5Mask),
791	const_iv (AnyModifier),	882	const_iv (AnyModifier),
792		883
793	const_iv (EVENT_NONE),	884	const_iv (NoSymbol),
794	const_iv (EVENT_READ),	885	const_iv (GrabModeSync),
795	const_iv (EVENT_WRITE),	886	const_iv (GrabModeAsync),
796		887
797	const_iv (NoEventMask),	888	const_iv (NoEventMask),
798	const_iv (KeyPressMask),	889	const_iv (KeyPressMask),
799	const_iv (KeyReleaseMask),	890	const_iv (KeyReleaseMask),
800	const_iv (ButtonPressMask),	891	const_iv (ButtonPressMask),
…		…
852	const_iv (SelectionRequest),	943	const_iv (SelectionRequest),
853	const_iv (SelectionNotify),	944	const_iv (SelectionNotify),
854	const_iv (ColormapNotify),	945	const_iv (ColormapNotify),
855	const_iv (ClientMessage),	946	const_iv (ClientMessage),
856	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
857	# if ENABLE_XIM_ONTHESPOT	961	# if ENABLE_XIM_ONTHESPOT
858	const_iv (XIMReverse),	962	const_iv (XIMReverse),
859	const_iv (XIMUnderline),	963	const_iv (XIMUnderline),
860	const_iv (XIMHighlight),	964	const_iv (XIMHighlight),
861	const_iv (XIMPrimary),	965	const_iv (XIMPrimary),
862	const_iv (XIMSecondary),	966	const_iv (XIMSecondary),
863	const_iv (XIMTertiary),	967	const_iv (XIMTertiary),
864	const_iv (XIMVisibleToForward),	968	const_iv (XIMVisibleToForward),
865	const_iv (XIMVisibleToBackword),	969	const_iv (XIMVisibleToBackword),
866	const_iv (XIMVisibleToCenter),	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
867	# if 0	1039	# if 0
868	const_iv (XIMForwardChar),	1040	const_iv (XIMForwardChar),
869	const_iv (XIMBackwardChar),	1041	const_iv (XIMBackwardChar),
870	const_iv (XIMForwardWord),	1042	const_iv (XIMForwardWord),
871	const_iv (XIMBackwardWord),	1043	const_iv (XIMBackwardWord),
…		…
876	const_iv (XIMLineStart),	1048	const_iv (XIMLineStart),
877	const_iv (XIMLineEnd),	1049	const_iv (XIMLineEnd),
878	const_iv (XIMAbsolutePosition),	1050	const_iv (XIMAbsolutePosition),
879	const_iv (XIMDontChange),	1051	const_iv (XIMDontChange),
880	# endif	1052	# endif
881	# 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),
882	};	1083	};
883		1084
884	for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )	1085	for (civ = const_iv + ecb_array_length (const_iv); civ > const_iv; civ--)
885	newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));	1086	newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
886	}	1087	}
887		1088
888	void	1089	void
889	warn (const char *msg)	1090	log (utf8_string msg)
		1091	CODE:
		1092	rxvt_log ("%s", msg);
		1093
		1094	void
		1095	warn (utf8_string msg)
890	CODE:	1096	CODE:
891	rxvt_warn ("%s", msg);	1097	rxvt_warn ("%s", msg);
892		1098
893	void	1099	void
894	fatal (const char *msg)	1100	fatal (utf8_string msg)
895	CODE:	1101	CODE:
896	rxvt_fatal ("%s", msg);	1102	rxvt_fatal ("%s", msg);
897		1103
898	void	1104	void
899	_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	}
900		1122
901	NV	1123	NV
902	NOW ()	1124	NOW ()
903	CODE:	1125	CODE:
904	RETVAL = NOW;	1126	RETVAL = ev::now ();
905	OUTPUT:	1127	OUTPUT:
906	RETVAL	1128	RETVAL
907		1129
908	int	1130	int
909	GET_BASEFG (int rend)	1131	GET_BASEFG (int rend)
…		…
934	RETVAL	1156	RETVAL
935		1157
936	int	1158	int
937	GET_CUSTOM (int rend)	1159	GET_CUSTOM (int rend)
938	CODE:	1160	CODE:
939	RETVAL = (rend && RS_customMask) >> RS_customShift;	1161	RETVAL = (rend & RS_customMask) >> RS_customShift;
940	OUTPUT:	1162	OUTPUT:
941	RETVAL	1163	RETVAL
942		1164
943	int	1165	int
944	SET_CUSTOM (int rend, int new_value)	1166	SET_CUSTOM (int rend, int new_value)
945	CODE:	1167	CODE:
946	{	1168	{
947	if (!IN_RANGE_EXC (new_value, 0, RS_customCount))	1169	if (!IN_RANGE_EXC (new_value, 0, RS_customCount))
948	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);
949		1171
950	RETVAL = (rend & ~RS_customMask)	1172	RETVAL = (rend & ~RS_customMask)
951	| ((new_value << RS_customShift) & RS_customMask);	1173	| ((new_value << RS_customShift) & RS_customMask);
952	}	1174	}
953	OUTPUT:	1175	OUTPUT:
…		…
962	for (rxvt_term **t = rxvt_term::termlist.begin (); t < rxvt_term::termlist.end (); t++)	1184	for (rxvt_term **t = rxvt_term::termlist.begin (); t < rxvt_term::termlist.end (); t++)
963	if ((*t)->perl.self)	1185	if ((*t)->perl.self)
964	PUSHs (sv_2mortal (newSVterm (*t)));	1186	PUSHs (sv_2mortal (newSVterm (*t)));
965	}	1187	}
966		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
967	MODULE = urxvt PACKAGE = urxvt::term	1218	MODULE = urxvt PACKAGE = urxvt::term
968		1219
969	SV *	1220	SV *
970	_new (AV *env, AV *arg)	1221	_new (AV *env, AV *arg)
971	CODE:	1222	CODE:
972	{	1223	{
973	rxvt_term *term = new rxvt_term;	1224	rxvt_term *term = new rxvt_term;
974		1225
975	stringvec *argv = new stringvec;	1226	stringvec *argv = new stringvec;
976	stringvec *envv = new stringvec;
977
978	for (int i = 0; i <= AvFILL (arg); i++)	1227	for (int i = 0; i <= AvFILL (arg); i++)
979	argv->push_back (strdup (SvPVbyte_nolen (*av_fetch (arg, i, 1))));	1228	argv->push_back (strdup (SvPVbyte_nolen (*av_fetch (arg, i, 1))));
980		1229
		1230	stringvec *envv = new stringvec;
981	for (int i = AvFILL (env) + 1; i--; )	1231	for (int i = AvFILL (env) + 1; i--; )
982	envv->push_back (strdup (SvPVbyte_nolen (*av_fetch (env, i, 1))));	1232	envv->push_back (strdup (SvPVbyte_nolen (*av_fetch (env, i, 1))));
983		1233
984	envv->push_back (0);
985
986	bool success;
987
988	try	1234	try
989	{	1235	{
990	success = term->init (argv, envv);	1236	term->init (argv, envv);
991	}	1237	}
992	catch (const class rxvt_failure_exception &e)	1238	catch (const class rxvt_failure_exception &e)
993	{
994	success = false;
995	}
996
997	if (!success)
998	{	1239	{
999	term->destroy ();	1240	term->destroy ();
1000	croak ("error while initializing new terminal instance");	1241	croak ("error while initializing new terminal instance");
1001	}	1242	}
1002		1243
…		…
1010	rxvt_term::destroy ()	1251	rxvt_term::destroy ()
1011		1252
1012	void	1253	void
1013	rxvt_term::set_should_invoke (int htype, int inc)	1254	rxvt_term::set_should_invoke (int htype, int inc)
1014	CODE:	1255	CODE:
1015	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	}
1016		1269
1017	void	1270	void
		1271	rxvt_term::put_option_db (octet_string specifier, octet_string value)
		1272	CODE:
		1273	XrmPutStringResource (&THIS->option_db, specifier, value);
		1274
		1275	void
		1276	rxvt_term::_keysym_resources ()
		1277	PPCODE:
		1278	PUTBACK;
		1279	_keysym_resources (THIS);
		1280	SPAGAIN;
		1281
		1282	int
1018	rxvt_term::grab_button (int button, U32 modifiers, Window window = THIS->vt)	1283	rxvt_term::grab_button (int button, U32 modifiers, Window window = THIS->vt)
1019	CODE:	1284	CODE:
1020	XGrabButton (THIS->dpy, button, modifiers, window, 1,	1285	RETVAL = XGrabButton (THIS->dpy, button, modifiers, window, 1,
1021	ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,	1286	ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
1022	GrabModeSync, GrabModeSync, None, GRAB_CURSOR);	1287	GrabModeSync, GrabModeSync, None, GRAB_CURSOR);
		1288	OUTPUT: RETVAL
1023		1289
1024	void	1290	int
1025	rxvt_term::ungrab_button (int button, U32 modifiers, Window window = THIS->vt)	1291	rxvt_term::ungrab_button (int button, U32 modifiers, Window window = THIS->vt)
1026	CODE:	1292	CODE:
1027	XUngrabButton (THIS->dpy, button, modifiers, window);	1293	RETVAL = XUngrabButton (THIS->dpy, button, modifiers, window);
		1294	OUTPUT: RETVAL
1028		1295
1029	#if 0
1030
1031	void	1296	void
1032	XGrabKey (rxvt_term *THIS, int keycode, U32 modifiers, Window window = THIS->vt)	1297	rxvt_term::XGrabKey (int keycode, U32 modifiers, Window window = THIS->vt, \
1033	C_ARGS:	1298	int owner_events = 1, int pointer_mode = GrabModeAsync, int keyboard_mode = GrabModeAsync)
1034	THIS->dpy, keycode, modifiers, window, 1,	1299	CODE:
1035	GrabModeSync, GrabModeSync	1300	XGrabKey (THIS->dpy, keycode, modifiers, window, owner_events, pointer_mode, keyboard_mode);
1036		1301
1037	void	1302	void
1038	XUngrabKey (rxvt_term *THIS, int keycode, U32 modifiers, Window window = THIS->vt)	1303	rxvt_term::XUngrabKey (int keycode, U32 modifiers, Window window = THIS->vt)
		1304	CODE:
1039	C_ARGS: THIS->dpy, keycode, modifiers, window	1305	XUngrabKey (THIS->dpy, keycode, modifiers, window);
1040
1041	#endif
1042		1306
1043	bool	1307	bool
1044	rxvt_term::grab (Time eventtime, int sync = 0)	1308	rxvt_term::grab (Time eventtime, int sync = 0)
1045	CODE:	1309	CODE:
1046	{	1310	{
…		…
1081	rxvt_term::ungrab ()	1345	rxvt_term::ungrab ()
1082	CODE:	1346	CODE:
1083	ungrab (THIS);	1347	ungrab (THIS);
1084		1348
1085	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
1086	rxvt_term::strwidth (SV *str)	1374	rxvt_term::strwidth (SV *str)
1087	CODE:	1375	CODE:
1088	{	1376	{
1089	wchar_t *wstr = sv2wcs (str);	1377	wchar_t *wstr = sv2wcs (str);
1090		1378
1091	rxvt_push_locale (THIS->locale);	1379	rxvt_push_locale (THIS->locale);
1092	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	}
1093	rxvt_pop_locale ();	1388	rxvt_pop_locale ();
1094		1389
1095	free (wstr);	1390	free (wstr);
1096	}	1391	}
1097	OUTPUT:	1392	OUTPUT:
…		…
1099		1394
1100	SV *	1395	SV *
1101	rxvt_term::locale_encode (SV *str)	1396	rxvt_term::locale_encode (SV *str)
1102	CODE:	1397	CODE:
1103	{	1398	{
		1399	if (!SvOK (str))
		1400	XSRETURN_UNDEF;
		1401
1104	wchar_t *wstr = sv2wcs (str);	1402	wchar_t *wstr = sv2wcs (str);
1105		1403
1106	rxvt_push_locale (THIS->locale);	1404	rxvt_push_locale (THIS->locale);
1107	char *mbstr = rxvt_wcstombs (wstr);	1405	char *mbstr = rxvt_wcstombs (wstr);
1108	rxvt_pop_locale ();	1406	rxvt_pop_locale ();
…		…
1117		1415
1118	SV *	1416	SV *
1119	rxvt_term::locale_decode (SV *octets)	1417	rxvt_term::locale_decode (SV *octets)
1120	CODE:	1418	CODE:
1121	{	1419	{
		1420	if (!SvOK (octets))
		1421	XSRETURN_UNDEF;
		1422
1122	STRLEN len;	1423	STRLEN len;
1123	char *data = SvPVbyte (octets, len);	1424	char *data = SvPVbyte (octets, len);
1124		1425
1125	rxvt_push_locale (THIS->locale);	1426	rxvt_push_locale (THIS->locale);
1126	wchar_t *wstr = rxvt_mbstowcs (data, len);	1427	wchar_t *wstr = rxvt_mbstowcs (data, len);
…		…
1132	OUTPUT:	1433	OUTPUT:
1133	RETVAL	1434	RETVAL
1134		1435
1135	#define TERM_OFFSET(sym) offsetof (TermWin_t, sym)	1436	#define TERM_OFFSET(sym) offsetof (TermWin_t, sym)
1136		1437
1137	#define TERM_OFFSET_width TERM_OFFSET(width)	1438	#define TERM_OFFSET_width TERM_OFFSET(width)
1138	#define TERM_OFFSET_height TERM_OFFSET(height)	1439	#define TERM_OFFSET_height TERM_OFFSET(height)
1139	#define TERM_OFFSET_fwidth TERM_OFFSET(fwidth)	1440	#define TERM_OFFSET_fwidth TERM_OFFSET(fwidth)
1140	#define TERM_OFFSET_fheight TERM_OFFSET(fheight)	1441	#define TERM_OFFSET_fheight TERM_OFFSET(fheight)
1141	#define TERM_OFFSET_fbase TERM_OFFSET(fbase)	1442	#define TERM_OFFSET_fbase TERM_OFFSET(fbase)
1142	#define TERM_OFFSET_nrow TERM_OFFSET(nrow)	1443	#define TERM_OFFSET_nrow TERM_OFFSET(nrow)
1143	#define TERM_OFFSET_ncol TERM_OFFSET(ncol)	1444	#define TERM_OFFSET_ncol TERM_OFFSET(ncol)
1144	#define TERM_OFFSET_focus TERM_OFFSET(focus)	1445	#define TERM_OFFSET_focus TERM_OFFSET(focus)
1145	#define TERM_OFFSET_mapped TERM_OFFSET(mapped)	1446	#define TERM_OFFSET_mapped TERM_OFFSET(mapped)
1146	#define TERM_OFFSET_int_bwidth TERM_OFFSET(int_bwidth)	1447	#define TERM_OFFSET_int_bwidth TERM_OFFSET(int_bwidth)
1147	#define TERM_OFFSET_ext_bwidth TERM_OFFSET(ext_bwidth)	1448	#define TERM_OFFSET_ext_bwidth TERM_OFFSET(ext_bwidth)
1148	#define TERM_OFFSET_lineSpace TERM_OFFSET(lineSpace)	1449	#define TERM_OFFSET_lineSpace TERM_OFFSET(lineSpace)
		1450	#define TERM_OFFSET_letterSpace TERM_OFFSET(letterSpace)
1149	#define TERM_OFFSET_saveLines TERM_OFFSET(saveLines)	1451	#define TERM_OFFSET_saveLines TERM_OFFSET(saveLines)
1150	#define TERM_OFFSET_total_rows TERM_OFFSET(total_rows)	1452	#define TERM_OFFSET_total_rows TERM_OFFSET(total_rows)
1151	#define TERM_OFFSET_top_row TERM_OFFSET(top_row)	1453	#define TERM_OFFSET_top_row TERM_OFFSET(top_row)
1152		1454
1153	int	1455	int
1154	rxvt_term::width ()	1456	rxvt_term::width (int new_value = NO_INIT)
1155	ALIAS:	1457	ALIAS:
1156	width = TERM_OFFSET_width	1458	width = TERM_OFFSET_width
1157	height = TERM_OFFSET_height	1459	height = TERM_OFFSET_height
1158	fwidth = TERM_OFFSET_fwidth	1460	fwidth = TERM_OFFSET_fwidth
1159	fheight = TERM_OFFSET_fheight	1461	fheight = TERM_OFFSET_fheight
1160	fbase = TERM_OFFSET_fbase	1462	fbase = TERM_OFFSET_fbase
1161	nrow = TERM_OFFSET_nrow	1463	nrow = TERM_OFFSET_nrow
1162	ncol = TERM_OFFSET_ncol	1464	ncol = TERM_OFFSET_ncol
1163	focus = TERM_OFFSET_focus	1465	focus = TERM_OFFSET_focus
1164	mapped = TERM_OFFSET_mapped	1466	mapped = TERM_OFFSET_mapped
1165	int_bwidth = TERM_OFFSET_int_bwidth	1467	int_bwidth = TERM_OFFSET_int_bwidth
1166	ext_bwidth = TERM_OFFSET_ext_bwidth	1468	ext_bwidth = TERM_OFFSET_ext_bwidth
1167	lineSpace = TERM_OFFSET_lineSpace	1469	lineSpace = TERM_OFFSET_lineSpace
		1470	letterSpace = TERM_OFFSET_letterSpace
1168	saveLines = TERM_OFFSET_saveLines	1471	saveLines = TERM_OFFSET_saveLines
1169	total_rows = TERM_OFFSET_total_rows	1472	total_rows = TERM_OFFSET_total_rows
1170	top_row = TERM_OFFSET_top_row	1473	top_row = TERM_OFFSET_top_row
1171	CODE:	1474	CODE:
1172	RETVAL = *(int *)((char *)THIS + ix);	1475	RETVAL = *(int *)((char *)THIS + ix);
		1476	if (items > 1)
		1477	*(int *)((char *)THIS + ix) = new_value;
1173	OUTPUT:	1478	OUTPUT:
1174	RETVAL	1479	RETVAL
1175		1480
1176	unsigned int	1481	unsigned int
1177	rxvt_term::ModLevel3Mask ()	1482	rxvt_term::ModLevel3Mask ()
…		…
1179	ModLevel3Mask = 0	1484	ModLevel3Mask = 0
1180	ModMetaMask = 1	1485	ModMetaMask = 1
1181	ModNumLockMask = 2	1486	ModNumLockMask = 2
1182	current_screen = 3	1487	current_screen = 3
1183	hidden_cursor = 4	1488	hidden_cursor = 4
		1489	priv_modes = 5
1184	CODE:	1490	CODE:
1185	switch (ix)	1491	switch (ix)
1186	{	1492	{
1187	case 0: RETVAL = THIS->ModLevel3Mask; break;	1493	case 0: RETVAL = THIS->ModLevel3Mask; break;
1188	case 1: RETVAL = THIS->ModMetaMask; break;	1494	case 1: RETVAL = THIS->ModMetaMask; break;
1189	case 2: RETVAL = THIS->ModNumLockMask; break;	1495	case 2: RETVAL = THIS->ModNumLockMask; break;
1190	case 3: RETVAL = THIS->current_screen; break;	1496	case 3: RETVAL = THIS->current_screen; break;
		1497	#ifdef CURSOR_BLINK
1191	case 4: RETVAL = THIS->hidden_cursor; break;	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;
1192	}	1503	}
1193	OUTPUT:	1504	OUTPUT:
1194	RETVAL	1505	RETVAL
1195		1506
1196	char *	1507	char *
…		…
1221	if (*i)	1532	if (*i)
1222	PUSHs (sv_2mortal (newSVpv (*i, 0)));	1533	PUSHs (sv_2mortal (newSVpv (*i, 0)));
1223	}	1534	}
1224		1535
1225	int	1536	int
1226	rxvt_term::pty_ev_events (int events = EVENT_UNDEF)	1537	rxvt_term::pty_ev_events (int events = ev::UNDEF)
1227	CODE:	1538	CODE:
1228	RETVAL = THIS->pty_ev.events;	1539	RETVAL = THIS->pty_ev.events;
1229	if (events != EVENT_UNDEF)	1540	if (events != ev::UNDEF)
1230	THIS->pty_ev.set (events);	1541	THIS->pty_ev.set (events);
1231	OUTPUT:	1542	OUTPUT:
1232	RETVAL	1543	RETVAL
1233		1544
1234	int	1545	int
…		…
1239	RETVAL	1550	RETVAL
1240		1551
1241	Window	1552	Window
1242	rxvt_term::parent ()	1553	rxvt_term::parent ()
1243	CODE:	1554	CODE:
1244	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;
1245	OUTPUT:	1570	OUTPUT:
1246	RETVAL	1571	RETVAL
1247		1572
1248	Window	1573	Window
1249	rxvt_term::vt ()	1574	rxvt_term::vt ()
…		…
1265	THIS->rstyle = new_rstyle;	1590	THIS->rstyle = new_rstyle;
1266	OUTPUT:	1591	OUTPUT:
1267	RETVAL	1592	RETVAL
1268		1593
1269	int	1594	int
1270	rxvt_term::view_start (int newval = 1)	1595	rxvt_term::view_start (int newval = 0)
1271	PROTOTYPE: $;$	1596	PROTOTYPE: $;$
1272	CODE:	1597	CODE:
1273	{	1598	{
1274	RETVAL = THIS->view_start;	1599	RETVAL = THIS->view_start;
1275		1600	if (items > 1)
1276	if (newval <= 0)
1277	THIS->scr_changeview (max (newval, THIS->top_row));	1601	THIS->scr_changeview (newval);
1278	}	1602	}
1279	OUTPUT:	1603	OUTPUT:
1280	RETVAL	1604	RETVAL
		1605
		1606	void
		1607	rxvt_term::set_urgency (bool enable)
1281		1608
1282	void	1609	void
1283	rxvt_term::focus_in ()	1610	rxvt_term::focus_in ()
1284		1611
1285	void	1612	void
…		…
1313		1640
1314	void	1641	void
1315	rxvt_term::want_refresh ()	1642	rxvt_term::want_refresh ()
1316	CODE:	1643	CODE:
1317	THIS->want_refresh = 1;	1644	THIS->want_refresh = 1;
		1645	THIS->refresh_check ();
		1646
		1647	void
		1648	rxvt_term::refresh_check ()
1318		1649
1319	void	1650	void
1320	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)
1321	PPCODE:	1652	PPCODE:
1322	{	1653	{
…		…
1467	*r++ = NOCHAR;	1798	*r++ = NOCHAR;
1468	}	1799	}
1469		1800
1470	rxvt_pop_locale ();	1801	rxvt_pop_locale ();
1471		1802
		1803	free (wstr);
1472	RETVAL = wcs2sv (rstr, r - rstr);	1804	RETVAL = wcs2sv (rstr, r - rstr);
1473	}	1805	}
1474	OUTPUT:	1806	OUTPUT:
1475	RETVAL	1807	RETVAL
1476		1808
1477	SV *	1809	SV *
1478	rxvt_term::special_decode (SV *text)	1810	rxvt_term::special_decode (SV *text)
1479	CODE:	1811	CODE:
1480	{	1812	{
1481	wchar_t *wstr = sv2wcs (text);	1813	wchar_t *wstr = sv2wcs (text);
1482	int wlen = wcslen (wstr);
1483	int dlen = 0;	1814	int dlen = 0;
1484		1815
1485	// find length	1816	// find length
1486	for (wchar_t *s = wstr; *s; s++)	1817	for (wchar_t *s = wstr; *s; s++)
1487	if (*s == NOCHAR)	1818	if (*s == NOCHAR)
1488	;	1819	;
1489	else if (IS_COMPOSE (*s))	1820	else if (IS_COMPOSE (*s))
1490	dlen += rxvt_composite.expand (*s, 0);	1821	dlen += rxvt_composite.expand (*s);
1491	else	1822	else
1492	dlen++;	1823	dlen++;
1493		1824
1494	wchar_t *rstr = rxvt_temp_buf<wchar_t> (dlen);	1825	wchar_t *rstr = rxvt_temp_buf<wchar_t> (dlen);
1495		1826
…		…
1501	else if (IS_COMPOSE (*s))	1832	else if (IS_COMPOSE (*s))
1502	r += rxvt_composite.expand (*s, r);	1833	r += rxvt_composite.expand (*s, r);
1503	else	1834	else
1504	*r++ = *s;	1835	*r++ = *s;
1505		1836
		1837	free (wstr);
1506	RETVAL = wcs2sv (rstr, r - rstr);	1838	RETVAL = wcs2sv (rstr, r - rstr);
1507	}	1839	}
1508	OUTPUT:	1840	OUTPUT:
1509	RETVAL	1841	RETVAL
1510		1842
1511	void	1843	void
1512	rxvt_term::_resource (char *name, int index, SV *newval = 0)	1844	rxvt_term::_resource (octet_string name, int index, SV *newval = 0)
1513	PPCODE:	1845	PPCODE:
1514	{	1846	{
1515	static const struct resval { const char *name; int value; } *rs, rslist [] = {	1847	static const struct resval { const char *name; int value; } *rs, rslist [] = {
1516	# define def(name) { # name, Rs_ ## name },	1848	# define def(name) { # name, Rs_ ## name },
1517	# define reserve(name,count)	1849	# define reserve(name,count)
1518	# include "rsinc.h"	1850	# include "rsinc.h"
1519	# undef def	1851	# undef def
1520	# undef reserve	1852	# undef reserve
1521	};	1853	};
1522		1854
1523	rs = rslist + sizeof (rslist) / sizeof (rslist [0]);	1855	rs = rslist + ecb_array_length (rslist);
1524		1856
		1857	if (*name)
1525	do {	1858	{
		1859	do {
1526	if (rs-- == rslist)	1860	if (rs-- == rslist)
1527	croak ("no such resource '%s', requested", name);	1861	croak ("no such resource '%s', requested", name);
1528	} while (strcmp (name, rs->name));	1862	} while (strcmp (name, rs->name));
1529		1863
1530	index += rs->value;	1864	index += rs->value;
		1865	}
		1866	else
		1867	{
		1868	--rs;
		1869	name = (octet_string)"";
		1870	}
1531		1871
1532	if (!IN_RANGE_EXC (index, 0, NUM_RESOURCES))	1872	if (!IN_RANGE_EXC (index, 0, NUM_RESOURCES))
1533	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);
1534		1874
1535	if (GIMME_V != G_VOID)	1875	if (GIMME_V != G_VOID)
…		…
1547	THIS->rs [index] = 0;	1887	THIS->rs [index] = 0;
1548	}	1888	}
1549	}	1889	}
1550		1890
1551	const char *	1891	const char *
1552	rxvt_term::x_resource (const char *name)	1892	rxvt_term::x_resource (octet_string name)
1553		1893
1554	bool	1894	bool
1555	rxvt_term::option (U32 optval, int set = -1)	1895	rxvt_term::option (U8 optval, int set = -1)
1556	CODE:	1896	CODE:
1557	{	1897	{
1558	RETVAL = THIS->options & optval;	1898	RETVAL = THIS->option (optval);
1559		1899
1560	if (set >= 0)	1900	if (set >= 0)
1561	{	1901	{
1562	if (set)
1563	THIS->options |= optval;	1902	THIS->set_option (optval, set);
1564	else
1565	THIS->options &= ~optval;
1566		1903
1567	if (THIS->check_ev.is_active ()) // avoid doing this before START	1904	if (THIS->init_done) // avoid doing this before START
1568	switch (optval)	1905	switch (optval)
1569	{	1906	{
1570	case Opt_skipBuiltinGlyphs:	1907	case Opt_skipBuiltinGlyphs:
1571	THIS->set_fonts ();	1908	THIS->set_fonts ();
1572	THIS->scr_remap_chars ();	1909	THIS->scr_remap_chars ();
1573	THIS->scr_touch (true);	1910	THIS->scr_touch (true);
1574	THIS->want_refresh = 1;	1911	THIS->want_refresh = 1;
		1912	THIS->refresh_check ();
1575	break;	1913	break;
		1914	#ifdef CURSOR_BLINK
		1915	case Opt_cursorBlink:
		1916	THIS->cursor_blink_reset ();
		1917	break;
		1918	#endif
1576		1919
1577	case Opt_cursorUnderline:	1920	case Opt_cursorUnderline:
		1921	THIS->cursor_type = set ? 1 : 0;
1578	THIS->want_refresh = 1;	1922	THIS->want_refresh = 1;
		1923	THIS->refresh_check ();
1579	break;	1924	break;
1580		1925
1581	# case Opt_scrollBar_floating:	1926	# case Opt_scrollBar_floating:
1582	# case Opt_scrollBar_right:	1927	# case Opt_scrollBar_right:
1583	# THIS->resize_all_windows (THIS->width, THIS->height, 1);	1928	# THIS->resize_all_windows (THIS->width, THIS->height, 1);
…		…
1586	}	1931	}
1587	}	1932	}
1588	OUTPUT:	1933	OUTPUT:
1589	RETVAL	1934	RETVAL
1590		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
1591	bool	1946	bool
1592	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
1593	CODE:	1950	CODE:
1594	RETVAL = 0 < THIS->parse_keysym (keysym, str);	1951	RETVAL = 0 < THIS->bind_action (keysym, action);
1595	THIS->keyboard->register_done ();	1952	THIS->keyboard->register_done ();
1596	OUTPUT:	1953	OUTPUT:
1597	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);
1598		1962
1599	void	1963	void
1600	rxvt_term::screen_cur (...)	1964	rxvt_term::screen_cur (...)
1601	PROTOTYPE: $;$$	1965	PROTOTYPE: $;$$
1602	ALIAS:	1966	ALIAS:
…		…
1616	EXTEND (SP, 2);	1980	EXTEND (SP, 2);
1617	PUSHs (sv_2mortal (newSViv (rc.row)));	1981	PUSHs (sv_2mortal (newSViv (rc.row)));
1618	PUSHs (sv_2mortal (newSViv (rc.col)));	1982	PUSHs (sv_2mortal (newSViv (rc.col)));
1619	}	1983	}
1620		1984
1621	if (items == 3)	1985	if (items >= 3)
1622	{	1986	{
1623	rc.row = SvIV (ST (1));	1987	rc.row = SvIV (ST (1));
1624	rc.col = SvIV (ST (2));	1988	rc.col = SvIV (ST (2));
1625		1989
1626	if (ix == 2)	1990	if (ix == 2)
…		…
1641		2005
1642	clamp_it (rc.col, 0, THIS->ncol);	2006	clamp_it (rc.col, 0, THIS->ncol);
1643	clamp_it (rc.row, THIS->top_row, THIS->nrow - 1);	2007	clamp_it (rc.row, THIS->top_row, THIS->nrow - 1);
1644		2008
1645	if (ix)	2009	if (ix)
1646	THIS->want_refresh = 1;	2010	{
		2011	THIS->selection.screen = THIS->current_screen;
		2012
		2013	THIS->selection_changed ();
		2014	THIS->refresh_check ();
1647	}	2015	}
		2016	}
1648	}	2017	}
1649		2018
1650	char	2019	int
1651	rxvt_term::cur_charset ()	2020	rxvt_term::selection_screen (int screen = -1)
1652	CODE:	2021	CODE:
1653	RETVAL = THIS->charsets [THIS->screen.charset];	2022	RETVAL = THIS->selection.screen;
1654	OUTPUT:	2023	if (screen >= 0)
		2024	THIS->selection.screen = screen;
		2025	OUTPUT:
1655	RETVAL	2026	RETVAL
1656		2027
1657	void	2028	void
1658	rxvt_term::selection_clear ()	2029	rxvt_term::selection_request (Time tm, int selnum)
		2030
		2031	void
		2032	rxvt_term::selection_clear (bool clipboard = false)
1659		2033
1660	void	2034	void
1661	rxvt_term::selection_make (Time eventtime, bool rect = false)	2035	rxvt_term::selection_make (Time eventtime, bool rect = false)
1662	CODE:	2036	CODE:
1663	THIS->selection.op = SELECTION_CONT;	2037	THIS->selection.op = SELECTION_CONT;
1664	THIS->selection.rect = rect;	2038	THIS->selection.rect = rect;
1665	THIS->selection_make (eventtime);	2039	THIS->selection_make (eventtime);
1666		2040
1667	int	2041	int
1668	rxvt_term::selection_grab (Time eventtime)	2042	rxvt_term::selection_grab (Time eventtime, bool clipboard = false)
1669		2043
1670	void	2044	void
1671	rxvt_term::selection (SV *newtext = 0)	2045	rxvt_term::selection (SV *newtext = 0, bool clipboard = false)
1672	PPCODE:	2046	PPCODE:
1673	{	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
1674	if (GIMME_V != G_VOID)	2051	if (GIMME_V != G_VOID)
1675	XPUSHs (THIS->selection.text	2052	XPUSHs (text
1676	? sv_2mortal (wcs2sv (THIS->selection.text, THIS->selection.len))	2053	? sv_2mortal (wcs2sv (text, len))
1677	: &PL_sv_undef);	2054	: &PL_sv_undef);
1678		2055
1679	if (newtext)	2056	if (newtext)
1680	{	2057	{
1681	free (THIS->selection.text);	2058	free (text);
1682		2059
1683	THIS->selection.text = sv2wcs (newtext);	2060	text = sv2wcs (newtext);
1684	THIS->selection.len = wcslen (THIS->selection.text);	2061	len = wcslen (text);
1685	}	2062	}
1686	}	2063	}
		2064
		2065	char
		2066	rxvt_term::cur_charset ()
		2067	CODE:
		2068	RETVAL = THIS->charsets [THIS->screen.charset];
		2069	OUTPUT:
		2070	RETVAL
1687		2071
1688	void	2072	void
1689	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)
1690		2074
1691	void	2075	void
1692	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)
1693		2077
1694	void	2078	void
1695	rxvt_term::scr_bell ()	2079	rxvt_term::scr_bell ()
		2080
		2081	void
		2082	rxvt_term::scr_recolor (bool refresh = true);
1696		2083
1697	void	2084	void
1698	rxvt_term::scr_change_screen (int screen)	2085	rxvt_term::scr_change_screen (int screen)
1699		2086
1700	void	2087	void
…		…
1703	{	2090	{
1704	wchar_t *wstr = sv2wcs (string);	2091	wchar_t *wstr = sv2wcs (string);
1705	THIS->scr_add_lines (wstr, wcslen (wstr));	2092	THIS->scr_add_lines (wstr, wcslen (wstr));
1706	free (wstr);	2093	free (wstr);
1707	}	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
1708		2103
1709	void	2104	void
1710	rxvt_term::tt_write (SV *octets)	2105	rxvt_term::tt_write (SV *octets)
1711	INIT:	2106	INIT:
1712	STRLEN len;	2107	STRLEN len;
1713	char *str = SvPVbyte (octets, len);	2108	char *str = SvPVbyte (octets, len);
1714	C_ARGS:	2109	C_ARGS:
1715	str, len	2110	str, len
1716		2111
1717	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
1718	rxvt_term::cmd_parse (SV *octets)	2121	rxvt_term::cmd_parse (SV *octets)
1719	CODE:	2122	CODE:
1720	{	2123	{
1721	STRLEN len;	2124	STRLEN len;
1722	char *str = SvPVbyte (octets, len);	2125	char *str = SvPVbyte (octets, len);
…		…
1758	Atom *props = XListProperties (THIS->dpy, window, &count);	2161	Atom *props = XListProperties (THIS->dpy, window, &count);
1759		2162
1760	EXTEND (SP, count);	2163	EXTEND (SP, count);
1761	while (count--)	2164	while (count--)
1762	PUSHs (newSVuv ((U32)props [count]));	2165	PUSHs (newSVuv ((U32)props [count]));
1763		2166
1764	XFree (props);	2167	XFree (props);
1765	}	2168	}
1766		2169
1767	void	2170	void
1768	rxvt_term::XGetWindowProperty (Window window, Atom property)	2171	rxvt_term::XGetWindowProperty (Window window, Atom property)
…		…
1791	XFree (prop);	2194	XFree (prop);
1792	}	2195	}
1793	}	2196	}
1794		2197
1795	void	2198	void
1796	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)
1797	CODE:	2200	CODE:
1798	{	2201	{
1799	STRLEN len;	2202	STRLEN len;
1800	char *data_ = SvPVbyte (data, len);	2203	char *data_ = SvPVbyte (data, len);
1801		2204
…		…
1807	type, format, PropModeReplace,	2210	type, format, PropModeReplace,
1808	(unsigned char *)data_, len / elemsize);	2211	(unsigned char *)data_, len / elemsize);
1809	}	2212	}
1810		2213
1811	Atom	2214	Atom
1812	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)
1813	C_ARGS: term->dpy, atom_name, only_if_exists	2216	C_ARGS: term->dpy, atom_name, only_if_exists
1814		2217
1815	char *	2218	char *
1816	XGetAtomName (rxvt_term *term, Atom atom)	2219	XGetAtomName (rxvt_term *term, Atom atom)
1817	C_ARGS: term->dpy, atom	2220	C_ARGS: term->dpy, atom
1818	CLEANUP:	2221	CLEANUP:
1819	XFree (RETVAL);	2222	XFree (RETVAL);
1820		2223
1821	void	2224	void
1822	XDeleteProperty (rxvt_term *term, Window window, Atom property)	2225	XDeleteProperty (rxvt_term *term, Window window, Atom property)
1823	C_ARGS: term->dpy, 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
1824		2285
1825	Window	2286	Window
1826	rxvt_term::DefaultRootWindow ()	2287	rxvt_term::DefaultRootWindow ()
1827	CODE:	2288	CODE:
1828	RETVAL = THIS->display->root;	2289	RETVAL = THIS->display->root;
…		…
1880	PUSHs (newSVuv (child));	2341	PUSHs (newSVuv (child));
1881	}	2342	}
1882	}	2343	}
1883		2344
1884	#############################################################################	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	#############################################################################
1885	# urxvt::overlay	2446	# urxvt::overlay
1886	#############################################################################	2447	#############################################################################
1887		2448
1888	MODULE = urxvt PACKAGE = urxvt::overlay	2449	MODULE = urxvt PACKAGE = urxvt::overlay
1889		2450
…		…
1897	overlay::hide ()	2458	overlay::hide ()
1898		2459
1899	void	2460	void
1900	overlay::DESTROY ()	2461	overlay::DESTROY ()
1901		2462
1902	#############################################################################	2463	INCLUDE: $PERL <iom_perl.xs -pe s/IOM_MODULE/urxvt/g,s/IOM_CLASS/urxvt/g |
1903	# urxvt::watcher
1904	#############################################################################
1905		2464
1906	MODULE = urxvt PACKAGE = urxvt::watcher
1907
1908	CHAINED
1909	perl_watcher::cb (SV *cb)
1910	CODE:
1911	THIS->cb (cb);
1912	OUTPUT:
1913	RETVAL
1914
1915	#############################################################################
1916	# urxvt::timer
1917	#############################################################################
1918
1919	MODULE = urxvt PACKAGE = urxvt::timer
1920
1921	SV *
1922	timer::new ()
1923	CODE:
1924	timer *w = new timer;
1925	w->start (NOW);
1926	RETVAL = newSVptr ((void *)(perl_watcher *)w, "urxvt::timer");
1927	w->self = (HV *)SvRV (RETVAL);
1928	OUTPUT:
1929	RETVAL
1930
1931	NV
1932	timer::at ()
1933	CODE:
1934	RETVAL = THIS->at;
1935	OUTPUT:
1936	RETVAL
1937
1938	CHAINED
1939	timer::interval (NV interval)
1940	CODE:
1941	THIS->interval = interval;
1942	OUTPUT:
1943	RETVAL
1944
1945	CHAINED
1946	timer::set (NV tstamp)
1947	CODE:
1948	THIS->set (tstamp);
1949	OUTPUT:
1950	RETVAL
1951
1952	CHAINED
1953	timer::start (NV tstamp = THIS->at)
1954	CODE:
1955	THIS->start (tstamp);
1956	OUTPUT:
1957	RETVAL
1958
1959	CHAINED
1960	timer::after (NV delay)
1961	CODE:
1962	THIS->start (NOW + delay);
1963	OUTPUT:
1964	RETVAL
1965
1966	CHAINED
1967	timer::stop ()
1968	CODE:
1969	THIS->stop ();
1970	OUTPUT:
1971	RETVAL
1972
1973	void
1974	timer::DESTROY ()
1975
1976	#############################################################################
1977	# urxvt::iow
1978	#############################################################################
1979
1980	MODULE = urxvt PACKAGE = urxvt::iow	2465	MODULE = urxvt PACKAGE = urxvt::pixbuf PREFIX = gdk_pixbuf_
1981		2466
1982	SV *	2467	#if HAVE_PIXBUF
1983	iow::new ()
1984	CODE:
1985	iow *w = new iow;
1986	RETVAL = newSVptr ((void *)(perl_watcher *)w, "urxvt::iow");
1987	w->self = (HV *)SvRV (RETVAL);
1988	OUTPUT:
1989	RETVAL
1990		2468
1991	CHAINED	2469	urxvt::pixbuf gdk_pixbuf_new_from_file (SV *klass, octet_string filename)
1992	iow::fd (int fd)	2470	C_ARGS: filename, 0
1993	CODE:
1994	THIS->fd = fd;
1995	OUTPUT:
1996	RETVAL
1997		2471
1998	CHAINED
1999	iow::events (short events)
2000	CODE:
2001	THIS->events = events;
2002	OUTPUT:
2003	RETVAL
2004
2005	CHAINED
2006	iow::start ()
2007	CODE:
2008	THIS->start ();
2009	OUTPUT:
2010	RETVAL
2011
2012	CHAINED
2013	iow::stop ()
2014	CODE:
2015	THIS->stop ();
2016	OUTPUT:
2017	RETVAL
2018
2019	void	2472	void
2020	iow::DESTROY ()	2473	DESTROY (urxvt::pixbuf self)
		2474	CODE:
		2475	g_object_unref (self);
2021		2476
2022	#############################################################################	2477	#endif
2023	# urxvt::iw
2024	#############################################################################
2025		2478
2026	MODULE = urxvt PACKAGE = urxvt::iw	2479	MODULE = urxvt PACKAGE = urxvt::img
2027		2480
2028	SV *	2481	#if HAVE_IMG
2029	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 ()
2030	CODE:	2488	PPCODE:
2031	iw *w = new iw;	2489	EXTEND (SP, 4);
2032	RETVAL = newSVptr ((void *)(perl_watcher *)w, "urxvt::iw");	2490	PUSHs (sv_2mortal (newSViv (THIS->x)));
2033	w->self = (HV *)SvRV (RETVAL);	2491	PUSHs (sv_2mortal (newSViv (THIS->y)));
2034	OUTPUT:	2492	PUSHs (sv_2mortal (newSViv (THIS->w)));
2035	RETVAL	2493	PUSHs (sv_2mortal (newSViv (THIS->h)));
2036		2494
2037	CHAINED	2495	int
2038	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)
2039	CODE:	2542	PPCODE:
2040	THIS->start ();	2543	if (items >= 2)
2041	OUTPUT:	2544	THIS->repeat_mode (repeat);
2042	RETVAL	2545	if (GIMME_V != G_VOID)
		2546	XPUSHs (sv_2mortal (newSViv (THIS->repeat)));
2043		2547
2044	CHAINED
2045	iw::stop ()
2046	CODE:
2047	THIS->stop ();
2048	OUTPUT:
2049	RETVAL
2050
2051	void	2548	void
2052	iw::DESTROY ()	2549	rxvt_img::move (int dx, int dy)
2053		2550
2054	#############################################################################
2055	# urxvt::pw
2056	#############################################################################
2057
2058	MODULE = urxvt PACKAGE = urxvt::pw
2059
2060	SV *
2061	pw::new ()
2062	CODE:
2063	pw *w = new pw;
2064	RETVAL = newSVptr ((void *)(perl_watcher *)w, "urxvt::pw");
2065	w->self = (HV *)SvRV (RETVAL);
2066	OUTPUT:
2067	RETVAL
2068
2069	CHAINED
2070	pw::start (int pid)
2071	CODE:
2072	THIS->start (pid);
2073	OUTPUT:
2074	RETVAL
2075
2076	CHAINED
2077	pw::stop ()
2078	CODE:
2079	THIS->stop ();
2080	OUTPUT:
2081	RETVAL
2082
2083	void	2551	void
2084	pw::DESTROY ()	2552	rxvt_img::brightness (rxvt_img::nv r, rxvt_img::nv g, rxvt_img::nv b, rxvt_img::nv a = 1.)
2085		2553
		2554	void
		2555	rxvt_img::contrast (rxvt_img::nv r, rxvt_img::nv g, rxvt_img::nv b, rxvt_img::nv a = 1.)
2086		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