ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/rxvt-unicode/src/rxvtperl.xs
(Generate patch)

Comparing rxvt-unicode/src/rxvtperl.xs (file contents):
Revision 1.11 by root, Tue Jan 3 02:01:27 2006 UTC vs.
Revision 1.261 by root, Tue Jul 25 18:06:07 2023 UTC

1/*----------------------------------------------------------------------* 1/*----------------------------------------------------------------------*
2 * File: rxvtperl.xs 2 * File: rxvtperl.xs
3 *----------------------------------------------------------------------* 3 *----------------------------------------------------------------------*
4 * 4 *
5 * All portions of code are copyright by their respective author/s. 5 * All portions of code are copyright by their respective author/s.
6 * Copyright (c) 2005-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
61typedef char * octet_string;
62typedef char * utf8_string;
63
64typedef int render_repeat_mode;
65
66#if HAVE_PIXBUF
67typedef GdkPixbuf * urxvt__pixbuf;
68#endif
69#if HAVE_IMG
70typedef rxvt_img * urxvt__img;
71typedef rxvt_img::nv rxvt_img__nv;
72
73/////////////////////////////////////////////////////////////////////////////
74
75static rgba
76parse_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
47static wchar_t * 120static wchar_t *
48sv2wcs (SV *sv) 121sv2wcs (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
55static SV * 128static SV *
56new_ref (HV *hv, const char *klass) 129wcs2sv (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
62static SV * 140static SV *
63newSVptr (void *ptr, const char *klass) 141newSVptr (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
148static void
149clearSVptr (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
70static long 158static long
71SvPTR (SV *sv, const char *klass) 159SvPTR (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
89struct perl_watcher 177#define SvOVERLAY(sv) (overlay *)SvPTR (sv, "urxvt::overlay")
178
179class overlay : overlay_base
90{ 180{
91 SV *cbsv; 181 rxvt_term *THIS;
182 AV *overlay_av;
183 int border;
184
185public:
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
112void 199overlay::overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border)
113perl_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
259overlay::~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
273void
274overlay::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
288void
289overlay::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
312void 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
342void 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
378struct rxvt_perl_interp rxvt_perl;
379
380static 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 these are not guaranteed anyway... */
385rxvt_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
397void
398rxvt_perl_interp::init ()
399{
400 if (!perl)
401 {
402 rxvt_push_locale ("C"); // 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
441void
442rxvt_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
455void
456rxvt_perl_interp::eval (const char *str)
457{
458 eval_pv (str, 1);
459}
460
461void
462rxvt_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") 481uint8_t
140#define SvTIMER(sv) (timer *)SvPTR (sv, "urxvt::timer") 482rxvt_perl_interp::parse_resource (rxvt_term *term, const char *name, bool arg, bool longopt, bool flag, const char *value)
141
142struct 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
158struct 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
173struct rxvt_perl_interp rxvt_perl;
174
175static PerlInterpreter *perl;
176
177rxvt_perl_interp::rxvt_perl_interp ()
178{
179} 508}
180 509
181rxvt_perl_interp::~rxvt_perl_interp () 510static 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
523static void
524_keysym_resources (rxvt_term *term)
525{
526 term->enumerate_keysym_resources (_keysym_resource_push);
527}
528
529static void
530ungrab (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
190void 540bool
191rxvt_perl_interp::init () 541rxvt_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
215bool 567 bool event_consumed;
216rxvt_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
779void
780rxvt_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
801MODULE = urxvt PACKAGE = urxvt
802
803PROTOTYPES: ENABLE
804
805BOOT:
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
1090void
1091log (utf8_string msg)
1092 CODE:
1093 rxvt_log ("%s", msg);
1094
1095void
1096warn (utf8_string msg)
1097 CODE:
1098 rxvt_warn ("%s", msg);
1099
1100void
1101fatal (utf8_string msg)
1102 CODE:
1103 rxvt_fatal ("%s", msg);
1104
1105void
1106_exit (int status)
1107
1108void
1109catch_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
294MODULE = urxvt PACKAGE = urxvt
295
296PROTOTYPES: ENABLE
297
298BOOT:
299{
300# define set_hookname(sym) av_store (hookname, PP_CONCAT(HOOK_, sym), newSVpv (PP_STRINGIFY(sym), 0))
301# define export_const(name) newCONSTSUB (gv_stashpv ("urxvt", 1), #name, newSViv (name));
302 AV *hookname = get_av ("urxvt::HOOKNAME", 1);
303 set_hookname (INIT);
304 set_hookname (RESET);
305 set_hookname (START);
306 set_hookname (DESTROY);
307 set_hookname (SEL_BEGIN);
308 set_hookname (SEL_EXTEND);
309 set_hookname (SEL_MAKE);
310 set_hookname (SEL_GRAB);
311 set_hookname (FOCUS_IN);
312 set_hookname (FOCUS_OUT);
313 set_hookname (VIEW_CHANGE);
314 set_hookname (SCROLL_BACK);
315 set_hookname (TTY_ACTIVITY);
316 set_hookname (REFRESH_BEGIN);
317 set_hookname (REFRESH_END);
318 set_hookname (KEYBOARD_COMMAND);
319
320 export_const (DEFAULT_RSTYLE);
321 export_const (OVERLAY_RSTYLE);
322 export_const (RS_Bold);
323 export_const (RS_Italic);
324 export_const (RS_Blink);
325 export_const (RS_RVid);
326 export_const (RS_Uline);
327
328 sv_setpv (get_sv ("urxvt::LIBDIR", 1), LIBDIR);
329}
330
331void
332set_should_invoke (int htype, int value)
333 CODE:
334 rxvt_perl.should_invoke [htype] = value;
335
336void
337warn (const char *msg)
338 CODE:
339 rxvt_warn ("%s", msg);
340
341void
342fatal (const char *msg)
343 CODE:
344 rxvt_fatal ("%s", msg);
345 1123
346NV 1124NV
347NOW () 1125NOW ()
348 CODE: 1126 CODE:
349 RETVAL = NOW; 1127 RETVAL = ev::now ();
350 OUTPUT: 1128 OUTPUT:
351 RETVAL 1129 RETVAL
352 1130
353int 1131int
354GET_BASEFG (int rend) 1132GET_BASEFG (int rend)
… …
363 RETVAL = GET_BASEBG (rend); 1141 RETVAL = GET_BASEBG (rend);
364 OUTPUT: 1142 OUTPUT:
365 RETVAL 1143 RETVAL
366 1144
367int 1145int
368SET_FGCOLOR (int rend, int color) 1146SET_FGCOLOR (int rend, int new_color)
369 CODE: 1147 CODE:
370 RETVAL = SET_FGCOLOR (rend, color); 1148 RETVAL = SET_FGCOLOR (rend, clamp (new_color, 0, TOTAL_COLORS - 1));
371 OUTPUT: 1149 OUTPUT:
372 RETVAL 1150 RETVAL
373 1151
374int 1152int
375SET_BGCOLOR (int rend, int color) 1153SET_BGCOLOR (int rend, int new_color)
376 CODE: 1154 CODE:
377 RETVAL = SET_BGCOLOR (rend, color); 1155 RETVAL = SET_BGCOLOR (rend, clamp (new_color, 0, TOTAL_COLORS - 1));
378 OUTPUT: 1156 OUTPUT:
379 RETVAL 1157 RETVAL
380 1158
1159int
1160GET_CUSTOM (int rend)
1161 CODE:
1162 RETVAL = (rend & RS_customMask) >> RS_customShift;
1163 OUTPUT:
1164 RETVAL
1165
1166int
1167SET_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
1179void
1180termlist ()
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
1190IV
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
1201void
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
1219Region
1220XCreateRegion ()
1221
1222int
1223XUnionRectWithRegion (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
1233int
1234XIntersectRegion (Region src1, Region src2, Region res)
1235
1236int
1237XUnionRegion (Region src1, Region src2, Region res)
1238
1239int
1240XSubtractRegion (Region src1, Region src2, Region res)
1241
1242int
1243XXorRegion (Region src1, Region src2, Region res)
1244
1245int
1246XOffsetRegion (Region r, int dx, int dy)
1247
1248int
1249XShrinkRegion (Region r, int dx, int dy)
1250
1251int
1252XDestroyRegion (Region r)
1253
381MODULE = urxvt PACKAGE = urxvt::term 1254MODULE = urxvt PACKAGE = urxvt::term
382 1255
1256SV *
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
1286void
1287rxvt_term::destroy ()
1288
1289void
1290rxvt_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
1306void
1307rxvt_term::put_option_db (octet_string specifier, octet_string value)
1308 CODE:
1309 XrmPutStringResource (&THIS->option_db, specifier, value);
1310
1311void
1312rxvt_term::_keysym_resources ()
1313 PPCODE:
1314 PUTBACK;
1315 _keysym_resources (THIS);
1316 SPAGAIN;
1317
1318int
1319rxvt_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
1326int
1327rxvt_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
1332void
1333rxvt_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
1338void
1339rxvt_term::XUngrabKey (int keycode, U32 modifiers, Window window = THIS->vt)
1340 CODE:
1341 XUngrabKey (THIS->dpy, keycode, modifiers, window);
1342
1343bool
1344rxvt_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
1364void
1365rxvt_term::allow_events_async ()
1366 CODE:
1367 XAllowEvents (THIS->dpy, AsyncBoth, THIS->perl.grabtime);
1368
1369void
1370rxvt_term::allow_events_sync ()
1371 CODE:
1372 XAllowEvents (THIS->dpy, SyncBoth, THIS->perl.grabtime);
1373
1374void
1375rxvt_term::allow_events_replay ()
1376 CODE:
1377 XAllowEvents (THIS->dpy, ReplayPointer, THIS->perl.grabtime);
1378 XAllowEvents (THIS->dpy, ReplayKeyboard, THIS->perl.grabtime);
1379
1380void
1381rxvt_term::ungrab ()
1382 CODE:
1383 ungrab (THIS);
1384
1385int
1386rxvt_term::XStringToKeysym (octet_string string)
1387 CODE:
1388 RETVAL = XStringToKeysym (string);
1389 OUTPUT: RETVAL
1390
1391char *
1392rxvt_term::XKeysymToString (int sym)
1393 CODE:
1394 RETVAL = XKeysymToString (sym);
1395 OUTPUT: RETVAL
1396
1397int
1398rxvt_term::XKeysymToKeycode (int sym)
1399 CODE:
1400 RETVAL = XKeysymToKeycode (THIS->dpy, sym);
1401 OUTPUT: RETVAL
1402
1403int
1404rxvt_term::XKeycodeToKeysym (int code, int index)
1405 CODE:
1406 RETVAL = rxvt_XKeycodeToKeysym (THIS->dpy, code, index);
1407 OUTPUT: RETVAL
1408
383int 1409int
384rxvt_term::strwidth (SV *str) 1410rxvt_term::strwidth (SV *str)
385 CODE: 1411 CODE:
386{ 1412{
387 wchar_t *wstr = sv2wcs (str); 1413 wchar_t *wstr = sv2wcs (str);
388 1414
389 rxvt_push_locale (THIS->locale); 1415 rxvt_push_locale (THIS->locale);
390 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 }
391 rxvt_pop_locale (); 1424 rxvt_pop_locale ();
392 1425
393 free (wstr); 1426 free (wstr);
394} 1427}
395 OUTPUT: 1428 OUTPUT:
… …
397 1430
398SV * 1431SV *
399rxvt_term::locale_encode (SV *str) 1432rxvt_term::locale_encode (SV *str)
400 CODE: 1433 CODE:
401{ 1434{
1435 if (!SvOK (str))
1436 XSRETURN_UNDEF;
1437
402 wchar_t *wstr = sv2wcs (str); 1438 wchar_t *wstr = sv2wcs (str);
403 1439
404 rxvt_push_locale (THIS->locale); 1440 rxvt_push_locale (THIS->locale);
405 char *mbstr = rxvt_wcstombs (wstr); 1441 char *mbstr = rxvt_wcstombs (wstr);
406 rxvt_pop_locale (); 1442 rxvt_pop_locale ();
… …
415 1451
416SV * 1452SV *
417rxvt_term::locale_decode (SV *octets) 1453rxvt_term::locale_decode (SV *octets)
418 CODE: 1454 CODE:
419{ 1455{
1456 if (!SvOK (octets))
1457 XSRETURN_UNDEF;
1458
420 STRLEN len; 1459 STRLEN len;
421 char *data = SvPVbyte (octets, len); 1460 char *data = SvPVbyte (octets, len);
422 1461
423 rxvt_push_locale (THIS->locale); 1462 rxvt_push_locale (THIS->locale);
424 wchar_t *wstr = rxvt_mbstowcs (data, len); 1463 wchar_t *wstr = rxvt_mbstowcs (data, len);
425 rxvt_pop_locale (); 1464 rxvt_pop_locale ();
426 1465
427 char *str = rxvt_wcstoutf8 (wstr); 1466 RETVAL = wcs2sv (wstr);
428 free (wstr); 1467 free (wstr);
429
430 RETVAL = newSVpv (str, 0);
431 SvUTF8_on (RETVAL);
432 free (str);
433} 1468}
434 OUTPUT: 1469 OUTPUT:
435 RETVAL 1470 RETVAL
436 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
437int 1491int
438rxvt_term::nsaved () 1492rxvt_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
439 CODE: 1510 CODE:
440 RETVAL = THIS->nsaved; 1511 RETVAL = *(int *)((char *)THIS + ix);
1512 if (items > 1)
1513 *(int *)((char *)THIS + ix) = new_value;
441 OUTPUT: 1514 OUTPUT:
442 RETVAL 1515 RETVAL
443 1516
444int 1517unsigned int
445rxvt_term::view_start (int newval = -1) 1518rxvt_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
446 CODE: 1526 CODE:
447{ 1527 switch (ix)
448 RETVAL = THIS->view_start;
449
450 if (newval >= 0)
451 {
452 THIS->view_start = min (newval, THIS->nsaved);
453 THIS->scr_changeview (RETVAL);
454 } 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
1543char *
1544rxvt_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
1557SV *
1558rxvt_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)));
455} 1570}
1571
1572int
1573rxvt_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
1581int
1582rxvt_term::pty_fd ()
1583 CODE:
1584 RETVAL = THIS->pty->pty;
1585 OUTPUT:
1586 RETVAL
1587
1588Window
1589rxvt_term::parent ()
1590 CODE:
1591 RETVAL = THIS->parent;
1592 OUTPUT:
1593 RETVAL
1594
1595int
1596rxvt_term::parent_x ()
1597 CODE:
1598 RETVAL = THIS->parent_x;
1599 OUTPUT:
1600 RETVAL
1601
1602int
1603rxvt_term::parent_y ()
1604 CODE:
1605 RETVAL = THIS->parent_y;
1606 OUTPUT:
1607 RETVAL
1608
1609Window
1610rxvt_term::vt ()
1611 CODE:
1612 RETVAL = THIS->vt;
1613 OUTPUT:
1614 RETVAL
1615
1616void
1617rxvt_term::vt_emask_add (U32 emask)
1618 CODE:
1619 THIS->vt_emask_perl |= emask;
1620 THIS->vt_select_input ();
1621
1622U32
1623rxvt_term::rstyle (U32 new_rstyle = THIS->rstyle)
1624 CODE:
1625 RETVAL = THIS->rstyle;
1626 THIS->rstyle = new_rstyle;
456 OUTPUT: 1627 OUTPUT:
457 RETVAL 1628 RETVAL
458 1629
459int 1630int
460rxvt_term::nrow () 1631rxvt_term::view_start (int newval = 0)
1632 PROTOTYPE: $;$
461 CODE: 1633 CODE:
1634{
462 RETVAL = THIS->nrow; 1635 RETVAL = THIS->view_start;
1636 if (items > 1)
1637 THIS->scr_changeview (newval);
1638}
463 OUTPUT: 1639 OUTPUT:
464 RETVAL 1640 RETVAL
465 1641
466int 1642void
1643rxvt_term::set_urgency (bool enable)
1644
1645void
1646rxvt_term::focus_in ()
1647
1648void
467rxvt_term::ncol () 1649rxvt_term::focus_out ()
1650
1651void
1652rxvt_term::key_press (unsigned int state, unsigned int keycode, Time time = CurrentTime)
1653 ALIAS:
1654 key_release = 1
468 CODE: 1655 CODE:
469 RETVAL = THIS->ncol; 1656{
470 OUTPUT: 1657 XKeyEvent xkey;
471 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}
472 1676
473void 1677void
474rxvt_term::want_refresh () 1678rxvt_term::want_refresh ()
475 CODE: 1679 CODE:
476 THIS->want_refresh = 1; 1680 THIS->want_refresh = 1;
1681 THIS->refresh_check ();
477 1682
478void 1683void
1684rxvt_term::refresh_check ()
1685
1686void
479rxvt_term::ROW_t (int row_number, SV *new_text = 0, int start_col = 0) 1687rxvt_term::ROW_t (int row_number, SV *new_text = 0, int start_col = 0, int start_ofs = 0, int max_len = MAX_COLS)
480 PPCODE: 1688 PPCODE:
481{ 1689{
482 if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow)) 1690 if (!IN_RANGE_EXC (row_number, THIS->top_row, THIS->nrow))
483 croak ("row_number number of out range"); 1691 XSRETURN_EMPTY;
484 1692
485 line_t &l = ROW(row_number); 1693 line_t &l = ROW(row_number);
486 1694
487 if (GIMME_V != G_VOID) 1695 if (GIMME_V != G_VOID)
488 { 1696 {
489 wchar_t *wstr = new wchar_t [THIS->ncol]; 1697 wchar_t *wstr = rxvt_temp_buf<wchar_t> (THIS->ncol);
490 1698
491 for (int col = 0; col <THIS->ncol; col++) 1699 for (int col = 0; col < THIS->ncol; col++)
492 wstr [col] = l.t [col]; 1700 wstr [col] = l.t [col];
493 1701
494 char *str = rxvt_wcstoutf8 (wstr, THIS->ncol);
495 free (wstr);
496
497 SV *sv = newSVpv (str, 0);
498 SvUTF8_on (sv);
499 XPUSHs (sv_2mortal (sv)); 1702 XPUSHs (sv_2mortal (wcs2sv (wstr, THIS->ncol)));
500 free (str);
501 } 1703 }
502 1704
503 if (new_text) 1705 if (new_text)
504 { 1706 {
505 STRLEN slen;
506 char *str = SvPVutf8 (new_text, slen); 1707 wchar_t *wstr = sv2wcs (new_text);
507 wchar_t *wstr = rxvt_utf8towcs (str, slen);
508 1708
509 int len = wcslen (wstr); 1709 int len = min (wcslen (wstr) - start_ofs, max_len);
510 1710
511 if (!IN_RANGE_INC (start_col, 0, THIS->ncol - len)) 1711 if (start_col < 0 || start_col + len > THIS->ncol)
512 { 1712 {
513 free (wstr); 1713 free (wstr);
514 croak ("new_text extends beyond horizontal margins"); 1714 croak ("new_text extends beyond horizontal margins");
515 } 1715 }
516 1716
517 for (int col = start_col; col < start_col + len; col++) 1717 for (int col = start_col; col < start_col + len; col++)
518 { 1718 {
519 l.t [col] = wstr [col - start_col]; 1719 l.t [col] = wstr [start_ofs + col - start_col];
520 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]));
521 } 1721 }
522 1722
523 free (wstr); 1723 free (wstr);
524 } 1724 }
525} 1725}
526 1726
527void 1727void
528rxvt_term::ROW_r (int row_number, SV *new_rend = 0, int start_col = 0) 1728rxvt_term::ROW_r (int row_number, SV *new_rend = 0, int start_col = 0, int start_ofs = 0, int max_len = MAX_COLS)
529 PPCODE: 1729 PPCODE:
530{ 1730{
531 if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow)) 1731 if (!IN_RANGE_EXC (row_number, THIS->top_row, THIS->nrow))
532 croak ("row_number number of out range"); 1732 XSRETURN_EMPTY;
533 1733
534 line_t &l = ROW(row_number); 1734 line_t &l = ROW(row_number);
535 1735
536 if (GIMME_V != G_VOID) 1736 if (GIMME_V != G_VOID)
537 { 1737 {
… …
548 { 1748 {
549 if (!SvROK (new_rend) || SvTYPE (SvRV (new_rend)) != SVt_PVAV) 1749 if (!SvROK (new_rend) || SvTYPE (SvRV (new_rend)) != SVt_PVAV)
550 croak ("new_rend must be arrayref"); 1750 croak ("new_rend must be arrayref");
551 1751
552 AV *av = (AV *)SvRV (new_rend); 1752 AV *av = (AV *)SvRV (new_rend);
553 int len = av_len (av) + 1; 1753 int len = min (AvFILL (av) + 1 - start_ofs, max_len);
554 1754
555 if (!IN_RANGE_INC (start_col, 0, THIS->ncol - len)) 1755 if (start_col < 0 || start_col + len > THIS->ncol)
556 croak ("new_rend array extends beyond horizontal margins"); 1756 croak ("new_rend array extends beyond horizontal margins");
557 1757
558 for (int col = start_col; col < start_col + len; col++) 1758 for (int col = start_col; col < start_col + len; col++)
559 { 1759 {
560 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;
561 1761
562 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]));
563 } 1763 }
564 } 1764 }
565} 1765}
566 1766
567int 1767int
568rxvt_term::ROW_l (int row_number, int new_length = -2) 1768rxvt_term::ROW_l (int row_number, int new_length = -1)
569 CODE: 1769 CODE:
570{ 1770{
571 if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow)) 1771 if (!IN_RANGE_EXC (row_number, THIS->top_row, THIS->nrow))
572 croak ("row_number number of out range"); 1772 XSRETURN_EMPTY;
573 1773
574 line_t &l = ROW(row_number); 1774 line_t &l = ROW(row_number);
575 RETVAL = l.l; 1775 RETVAL = l.l;
576 1776
577 if (new_length >= -1) 1777 if (new_length >= 0)
578 l.l = new_length; 1778 l.l = new_length;
579} 1779}
580 OUTPUT: 1780 OUTPUT:
581 RETVAL 1781 RETVAL
582 1782
1783bool
1784rxvt_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
583SV * 1799SV *
584rxvt_term::special_encode (SV *str) 1800rxvt_term::special_encode (SV *string)
585 CODE: 1801 CODE:
586 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
587 1844
588SV * 1845SV *
589rxvt_term::special_decode (SV *str) 1846rxvt_term::special_decode (SV *text)
590 CODE: 1847 CODE:
591 abort ();//TODO 1848{
1849 wchar_t *wstr = sv2wcs (text);
1850 int dlen = 0;
592 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
593void 1879void
594rxvt_term::_resource (char *name, int index, SV *newval = 0) 1880rxvt_term::_resource (octet_string name, int index, SV *newval = 0)
595 PPCODE: 1881 PPCODE:
596{ 1882{
597 struct resval { const char *name; int value; } rslist [] = { 1883 static const struct resval { const char *name; int value; } *rs, rslist [] = {
598# define Rs_def(name) { # name, Rs_ ## name }, 1884# define def(name) { # name, Rs_ ## name },
599# define Rs_reserve(name,count) 1885# define reserve(name,count)
600# include "rsinc.h" 1886# include "rsinc.h"
601# undef Rs_def 1887# undef def
602# undef Rs_reserve 1888# undef reserve
603 }; 1889 };
604 1890
605 struct resval *rs = rslist + sizeof (rslist) / sizeof (rslist [0]); 1891 rs = rslist + ecb_array_length (rslist);
606 1892
1893 if (*name)
607 do { 1894 {
1895 do {
608 if (rs-- == rslist) 1896 if (rs-- == rslist)
609 croak ("no such resource '%s', requested", name); 1897 croak ("no such resource '%s', requested", name);
610 } while (strcmp (name, rs->name)); 1898 } while (strcmp (name, rs->name));
611 1899
612 index += rs->value; 1900 index += rs->value;
1901 }
1902 else
1903 {
1904 --rs;
1905 name = (octet_string)"";
1906 }
613 1907
614 if (!IN_RANGE_EXC (index, 0, NUM_RESOURCES)) 1908 if (!IN_RANGE_EXC (index, 0, NUM_RESOURCES))
615 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);
616 1910
617 if (GIMME_V != G_VOID) 1911 if (GIMME_V != G_VOID)
… …
628 else 1922 else
629 THIS->rs [index] = 0; 1923 THIS->rs [index] = 0;
630 } 1924 }
631} 1925}
632 1926
1927const char *
1928rxvt_term::x_resource (octet_string name)
1929
1930bool
1931rxvt_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
1972SV *
1973rxvt_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
1982bool
1983rxvt_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
633void 1992void
1993rxvt_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
1999void
634rxvt_term::selection_mark (...) 2000rxvt_term::screen_cur (...)
635 PROTOTYPE: $;$$ 2001 PROTOTYPE: $;$$
636 ALIAS: 2002 ALIAS:
2003 screen_cur = 0
637 selection_beg = 1 2004 selection_beg = 1
638 selection_end = 2 2005 selection_end = 2
2006 selection_mark = 3
639 PPCODE: 2007 PPCODE:
640{ 2008{
641 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
642 : ix == 2 ? THIS->selection.end 2011 : ix == 2 ? THIS->selection.end
643 : THIS->selection.mark; 2012 : THIS->selection.mark;
644 2013
645 if (GIMME_V != G_VOID) 2014 if (GIMME_V != G_VOID)
646 { 2015 {
647 EXTEND (SP, 2); 2016 EXTEND (SP, 2);
648 PUSHs (sv_2mortal (newSViv (sel.row))); 2017 PUSHs (sv_2mortal (newSViv (rc.row)));
649 PUSHs (sv_2mortal (newSViv (sel.col))); 2018 PUSHs (sv_2mortal (newSViv (rc.col)));
650 } 2019 }
651 2020
652 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)
653 { 2027 {
654 sel.row = clamp (SvIV (ST (1)), -THIS->nsaved, THIS->nrow - 1); 2028 if (rc.col == 0)
655 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);
656 2044
657 if (ix) 2045 if (ix)
658 THIS->want_refresh = 1; 2046 {
2047 THIS->selection.screen = THIS->current_screen;
2048
2049 THIS->selection_changed ();
2050 THIS->refresh_check ();
659 } 2051 }
2052 }
660} 2053}
661 2054
662int 2055int
663rxvt_term::selection_grab (int eventtime) 2056rxvt_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
664 2063
665void 2064void
2065rxvt_term::selection_request (Time tm, int selnum)
2066
2067void
2068rxvt_term::selection_clear (bool clipboard = false)
2069
2070void
2071rxvt_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
2077int
2078rxvt_term::selection_grab (Time eventtime, bool clipboard = false)
2079
2080void
666rxvt_term::selection (SV *newtext = 0) 2081rxvt_term::selection (SV *newtext = 0, bool clipboard = false)
667 PPCODE: 2082 PPCODE:
668{ 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
669 if (GIMME_V != G_VOID) 2087 if (GIMME_V != G_VOID)
670 { 2088 XPUSHs (text
671 char *sel = rxvt_wcstoutf8 (THIS->selection.text, THIS->selection.len); 2089 ? sv_2mortal (wcs2sv (text, len))
672 SV *sv = newSVpv (sel, 0); 2090 : &PL_sv_undef);
673 SvUTF8_on (sv);
674 free (sel);
675 XPUSHs (sv_2mortal (sv));
676 }
677 2091
678 if (newtext) 2092 if (newtext)
679 { 2093 {
680 free (THIS->selection.text);
681
682 THIS->selection.text = sv2wcs (newtext);
683 THIS->selection.len = wcslen (THIS->selection.text);
684 }
685}
686
687void
688rxvt_term::scr_overlay_new (int x, int y, int w, int h)
689
690void
691rxvt_term::scr_overlay_off ()
692
693void
694rxvt_term::scr_overlay_set_char (int x, int y, U32 text, U32 rend = OVERLAY_RSTYLE)
695 CODE:
696 THIS->scr_overlay_set (x, y, text, rend);
697
698void
699rxvt_term::scr_overlay_set (int x, int y, SV *text)
700 CODE:
701{
702 wchar_t *wtext = sv2wcs (text);
703 THIS->scr_overlay_set (x, y, wtext);
704 free (wtext); 2094 free (text);
2095
2096 text = sv2wcs (newtext);
2097 len = wcslen (text);
2098 }
705} 2099}
2100
2101char
2102rxvt_term::cur_charset ()
2103 CODE:
2104 RETVAL = THIS->charsets [THIS->screen.charset];
2105 OUTPUT:
2106 RETVAL
2107
2108void
2109rxvt_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
2111void
2112rxvt_term::scr_xor_span (int beg_row, int beg_col, int end_row, int end_col, U32 rstyle = RS_RVid)
2113
2114void
2115rxvt_term::scr_bell ()
2116
2117void
2118rxvt_term::scr_recolor (bool refresh = true);
2119
2120void
2121rxvt_term::scr_change_screen (int screen)
2122
2123void
2124rxvt_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
2132void
2133rxvt_term::tt_write_user_input (SV *octets)
2134 INIT:
2135 STRLEN len;
2136 char *str = SvPVbyte (octets, len);
2137 C_ARGS:
2138 str, len
706 2139
707void 2140void
708rxvt_term::tt_write (SV *octets) 2141rxvt_term::tt_write (SV *octets)
709 INIT: 2142 INIT:
710 STRLEN len; 2143 STRLEN len;
711 char *str = SvPVbyte (octets, len); 2144 char *str = SvPVbyte (octets, len);
712 C_ARGS: 2145 C_ARGS:
713 (unsigned char *)str, len 2146 str, len
714 2147
715MODULE = urxvt PACKAGE = urxvt::timer 2148void
2149rxvt_term::tt_paste (SV *octets)
2150 INIT:
2151 STRLEN len;
2152 char *str = SvPVbyte (octets, len);
2153 C_ARGS:
2154 str, len
2155
2156void
2157rxvt_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}
716 2176
717SV * 2177SV *
718timer::new () 2178rxvt_term::overlay (int x, int y, int w, int h, int rstyle = OVERLAY_RSTYLE, int border = 2)
719 CODE: 2179 CODE:
720 timer *w = new timer; 2180{
2181 overlay *o = new overlay (THIS, x, y, w, h, rstyle, border);
721 RETVAL = newSVptr ((void *)w, "urxvt::timer"); 2182 RETVAL = newSVptr ((void *)o, "urxvt::overlay");
722 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
2192void
2193rxvt_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 (sv_2mortal (newSVuv ((U32)props [count])));
2202
2203 XFree (props);
2204}
2205
2206void
2207rxvt_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 (sv_2mortal (newSVuv ((U32)type)));
2228 PUSHs (sv_2mortal (newSViv (format)));
2229 PUSHs (sv_2mortal (newSVpvn ((char *)prop, nitems * elemsize)));
2230 XFree (prop);
2231 }
2232}
2233
2234void
2235rxvt_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
2250Atom
2251XInternAtom (rxvt_term *term, octet_string atom_name, int only_if_exists = FALSE)
2252 C_ARGS: term->dpy, atom_name, only_if_exists
2253
2254char *
2255XGetAtomName (rxvt_term *term, Atom atom)
2256 C_ARGS: term->dpy, atom
2257 CLEANUP:
2258 XFree (RETVAL);
2259
2260void
2261XDeleteProperty (rxvt_term *term, Window window, Atom property)
2262 C_ARGS: term->dpy, window, property
2263
2264void
2265rxvt_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
2275void
2276XShapeCombineRegion (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
2279void
2280XShapeCombineMask (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
2283void
2284XShapeCombineShape (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
2287Window
2288rxvt_term::DefaultRootWindow ()
2289 CODE:
2290 RETVAL = THIS->display->root;
723 OUTPUT: 2291 OUTPUT:
724 RETVAL 2292 RETVAL
725 2293
726timer * 2294#if 0
727timer::cb (SV *cb) 2295
2296Window
2297XCreateSimpleWindow (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
2305void
2306XReparentWindow (rxvt_term *term, Window window, Window parent, int x = 0, int y = 0)
2307 C_ARGS: term->dpy, window, parent, x, y
2308
2309void
2310XMapWindow (rxvt_term *term, Window window)
2311 C_ARGS: term->dpy, window
2312
2313void
2314XUnmapWindow (rxvt_term *term, Window window)
2315 C_ARGS: term->dpy, window
2316
2317void
2318XMoveResizeWindow (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
2321void
2322rxvt_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
2330void
2331rxvt_term::XTranslateCoordinates (Window src, Window dst, int x, int y)
728 CODE: 2332 PPCODE:
729 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 (sv_2mortal (newSViv (dx)));
2341 PUSHs (sv_2mortal (newSViv (dy)));
2342 PUSHs (sv_2mortal (newSVuv (child)));
2343 }
2344}
2345
2346#############################################################################
2347# fancy bg bloatstuff (TODO: should be moved up somewhere)
2348
2349bool
2350rxvt_term::has_render ()
2351 CODE:
2352 RETVAL = THIS->display->flags & DISPLAY_HAS_RENDER;
2353 OUTPUT:
730 RETVAL = THIS; 2354 RETVAL
731 OUTPUT:
732 RETVAL
733 2355
734NV 2356void
735timer::at () 2357rxvt_term::background_geometry (bool border = false)
736 CODE: 2358 PPCODE:
737 RETVAL = THIS->at; 2359 EXTEND (SP, 4);
738 OUTPUT: 2360 PUSHs (sv_2mortal (newSViv (THIS->parent_x + (border ? THIS->window_vt_x : 0))));
739 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)));
740 2364
741timer * 2365#if HAVE_IMG
742timer::set (NV tstamp) 2366
2367rxvt_img *
2368rxvt_term::new_img (SV *format = &PL_sv_undef, int x = 0, int y = 0, int width = 1, int height = 1)
743 CODE: 2369 CODE:
744 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:
745 RETVAL = THIS; 2376 RETVAL
746 OUTPUT:
747 RETVAL
748 2377
749timer * 2378#if ENABLE_TRANSPARENCY
750timer::start (NV tstamp = THIS->at) 2379
751 CODE: 2380rxvt_img *
752 THIS->start (tstamp); 2381rxvt_term::new_img_from_root ()
2382 CODE:
2383 RETVAL = rxvt_img::new_from_root (THIS);
2384 OUTPUT:
753 RETVAL = THIS; 2385 RETVAL
754 OUTPUT:
755 RETVAL
756 2386
757timer * 2387#endif
758timer::stop () 2388
2389#if HAVE_PIXBUF
2390
2391rxvt_img *
2392rxvt_term::new_img_from_file (octet_string filename)
759 CODE: 2393 CODE:
760 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:
761 RETVAL = THIS; 2403 RETVAL
762 OUTPUT:
763 RETVAL
764 2404
2405#endif
2406
765void 2407void
2408rxvt_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
2414void
2415rxvt_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
2450MODULE = urxvt PACKAGE = urxvt::overlay
2451
2452void
2453overlay::set (int x, int y, SV *text, SV *rend = 0)
2454
2455void
2456overlay::show ()
2457
2458void
2459overlay::hide ()
2460
2461void
766timer::DESTROY () 2462overlay::DESTROY ()
767 2463
2464INCLUDE: $PERL <iom_perl.xs -pe s/IOM_MODULE/urxvt/g,s/IOM_CLASS/urxvt/g |
2465
2466MODULE = urxvt PACKAGE = urxvt::pixbuf PREFIX = gdk_pixbuf_
2467
2468#if HAVE_PIXBUF
2469
2470urxvt::pixbuf gdk_pixbuf_new_from_file (SV *klass, octet_string filename)
2471 C_ARGS: filename, 0
2472
2473void
2474DESTROY (urxvt::pixbuf self)
2475 CODE:
2476 g_object_unref (self);
2477
2478#endif
2479
768MODULE = urxvt PACKAGE = urxvt::iow 2480MODULE = urxvt PACKAGE = urxvt::img
769 2481
770SV * 2482#if HAVE_IMG
771iow::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
2487void
2488rxvt_img::geometry ()
772 CODE: 2489 PPCODE:
773 iow *w = new iow; 2490 EXTEND (SP, 4);
774 RETVAL = newSVptr ((void *)w, "urxvt::iow"); 2491 PUSHs (sv_2mortal (newSViv (THIS->x)));
775 w->self = (HV *)SvRV (RETVAL); 2492 PUSHs (sv_2mortal (newSViv (THIS->y)));
776 OUTPUT: 2493 PUSHs (sv_2mortal (newSViv (THIS->w)));
777 RETVAL 2494 PUSHs (sv_2mortal (newSViv (THIS->h)));
778 2495
779iow * 2496int
780iow::cb (SV *cb) 2497rxvt_img::x ()
2498 ALIAS:
2499 x = 0
2500 y = 1
2501 w = 2
2502 h = 3
781 CODE: 2503 CODE:
782 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
2514Pixmap
2515rxvt_img::pm ()
2516 CODE:
783 RETVAL = THIS; 2517 RETVAL = THIS->pm;
784 OUTPUT: 2518 OUTPUT:
785 RETVAL 2519 RETVAL
786 2520
787iow * 2521void
788iow::fd (int fd) 2522rxvt_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
2530void
2531rxvt_img::DESTROY ()
2532 CODE:
2533 delete THIS;
2534
2535void
2536rxvt_img::add_alpha ()
2537
2538void
2539rxvt_img::unshare ()
2540
2541void
2542rxvt_img::repeat_mode (render_repeat_mode repeat = 0)
789 CODE: 2543 PPCODE:
790 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
2549void
2550rxvt_img::move (int dx, int dy)
2551
2552void
2553rxvt_img::brightness (rxvt_img::nv r, rxvt_img::nv g, rxvt_img::nv b, rxvt_img::nv a = 1.)
2554
2555void
2556rxvt_img::contrast (rxvt_img::nv r, rxvt_img::nv g, rxvt_img::nv b, rxvt_img::nv a = 1.)
2557
2558void
2559rxvt_img::draw (rxvt_img *img, int op = PictOpOver, rxvt_img::nv mask = 1.);
2560
2561rxvt_img *
2562rxvt_img::clone ()
2563
2564rxvt_img *
2565rxvt_img::reify ()
2566
2567rxvt_img *
2568rxvt_img::sub_rect (int x, int y, int width, int height)
2569
2570rxvt_img *
2571rxvt_img::blur (int rh, int rv)
2572
2573rxvt_img *
2574rxvt_img::muladd (rxvt_img::nv mul, rxvt_img::nv add)
2575
2576rxvt_img *
2577rxvt_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
2586rxvt_img *
2587rxvt_img::scale (int new_width, int new_height)
2588
2589rxvt_img *
2590rxvt_img::rotate (int x, int y, rxvt_img::nv phi)
2591
2592rxvt_img *
2593rxvt_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
2600rxvt_img *
2601rxvt_img::shade (rxvt_img::nv factor)
2602
2603rxvt_img *
2604rxvt_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:
791 RETVAL = THIS; 2624 RETVAL
792 OUTPUT:
793 RETVAL
794 2625
795iow * 2626#endif
796iow::events (short events)
797 CODE:
798 THIS->events = events;
799 RETVAL = THIS;
800 OUTPUT:
801 RETVAL
802 2627
803iow *
804iow::start ()
805 CODE:
806 THIS->start ();
807 RETVAL = THIS;
808 OUTPUT:
809 RETVAL
810
811iow *
812iow::stop ()
813 CODE:
814 THIS->stop ();
815 RETVAL = THIS;
816 OUTPUT:
817 RETVAL
818
819void
820iow::DESTROY ()
821
822

Diff Legend

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