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

Diff Legend

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