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.87 by root, Sat Jan 21 08:07:38 2006 UTC vs.
Revision 1.207 by sf-exg, Fri Dec 28 21:19:21 2012 UTC

1/*----------------------------------------------------------------------* 1/*----------------------------------------------------------------------*
2 * File: rxvtperl.xs 2 * File: rxvtperl.xs
3 *----------------------------------------------------------------------* 3 *----------------------------------------------------------------------*
4 * 4 *
5 * All portions of code are copyright by their respective author/s. 5 * All portions of code are copyright by their respective author/s.
6 * Copyright (c) 2005-2006 Marc Lehmann <pcg@goof.com> 6 * Copyright (c) 2005-2008,2011 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 2 of the License, or
11 * (at your option) any later version. 11 * (at your option) any later version.
… …
23#define line_t perl_line_t 23#define line_t perl_line_t
24#include <EXTERN.h> 24#include <EXTERN.h>
25#include <perl.h> 25#include <perl.h>
26#include <XSUB.h> 26#include <XSUB.h>
27#undef line_t 27#undef line_t
28#undef bool // perl defines it's own bool type, except with g++... what a trap
28 29
29#include "../config.h" 30#include "../config.h"
30 31
31#include <cstddef> 32#include <stddef.h>
32#include <cstdarg> 33#include <stdarg.h>
33 34
34#include "unistd.h" 35#include "unistd.h"
35 36
36#include "iom.h" 37#include "ev_cpp.h"
37#include "rxvt.h" 38#include "rxvt.h"
38#include "keyboard.h" 39#include "keyboard.h"
39#include "rxvtutil.h" 40#include "rxvtutil.h"
40#include "rxvtperl.h" 41#include "rxvtperl.h"
41 42
42#include "perlxsi.c" 43#include "perlxsi.c"
43 44
44#ifdef HAVE_SCROLLBARS
45# define GRAB_CURSOR THIS->leftptr_cursor 45#define GRAB_CURSOR THIS->scrollBar.leftptr_cursor
46#else
47# define GRAB_CURSOR None
48#endif
49 46
50#undef LINENO 47#undef LINENO
51#define LINENO(n) MOD (THIS->term_start + int(n), THIS->total_rows) 48#define LINENO(n) MOD (THIS->term_start + int(n), THIS->total_rows)
52#undef ROW 49#undef ROW
53#define ROW(n) THIS->row_buf [LINENO (n)] 50#define ROW(n) THIS->row_buf [LINENO (n)]
54 51
55typedef int CHAINED UNUSED;
56
57///////////////////////////////////////////////////////////////////////////// 52/////////////////////////////////////////////////////////////////////////////
53
54typedef char * octet_string;
55typedef char * utf8_string;
56
57typedef int render_repeat_mode;
58
59#if HAVE_PIXBUF
60typedef GdkPixbuf * urxvt__pixbuf;
61#endif
62#if HAVE_IMG
63typedef rxvt_img * urxvt__img;
64typedef rxvt_img::nv rxvt_img__nv;
65
66/////////////////////////////////////////////////////////////////////////////
67
68static rgba
69parse_rgba (SV *sv, rxvt_screen *s = 0)
70{
71 rgba c;
72
73 if (SvROK (sv))
74 {
75 AV *av = (AV *)SvRV (sv);
76
77 if (SvTYPE ((SV *)av) != SVt_PVAV)
78 croak ("colour must be either a colour string, or an array,");
79
80 int len = av_len (av) + 1;
81
82 if (len != 1 && len != 3 && len != 4)
83 croak ("component colour array must have 1, 3 or 4 components,");
84
85 c.a = rgba::MAX_CC;
86
87 c.r = c.g = c.b = float_to_component (SvIV (*av_fetch (av, 0, 0)));
88
89 if (len >= 3)
90 {
91 c.g = float_to_component (SvIV (*av_fetch (av, 1, 0)));
92 c.b = float_to_component (SvIV (*av_fetch (av, 2, 0)));
93
94 if (len >= 4)
95 c.a = float_to_component (SvIV (*av_fetch (av, 3, 0)));
96 }
97 }
98 else if (s)
99 {
100 rxvt_color rc;
101 rc.set (s, SvPVbyte_nolen (sv));
102 rc.get (c);
103 }
104 else
105 croak ("unable to parse colour,");
106
107 return c;
108}
109
110/////////////////////////////////////////////////////////////////////////////
111#endif
58 112
59static wchar_t * 113static wchar_t *
60sv2wcs (SV *sv) 114sv2wcs (SV *sv)
61{ 115{
62 STRLEN len; 116 STRLEN len;
… …
75 129
76 return sv; 130 return sv;
77} 131}
78 132
79static SV * 133static SV *
80new_ref (HV *hv, const char *klass)
81{
82 return sv_bless (newRV ((SV *)hv), gv_stashpv (klass, 1));
83}
84
85//TODO: use magic
86static SV *
87newSVptr (void *ptr, const char *klass) 134newSVptr (void *ptr, const char *klass)
88{ 135{
89 HV *hv = newHV (); 136 HV *hv = newHV ();
90 sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0); 137 sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);
91 return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1)); 138 return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
… …
113 croak ("perl code used %s object, but C++ object is already destroyed, caught", klass); 160 croak ("perl code used %s object, but C++ object is already destroyed, caught", klass);
114 161
115 return (long)mg->mg_ptr; 162 return (long)mg->mg_ptr;
116} 163}
117 164
118#define newSVterm(term) SvREFCNT_inc ((SV *)term->perl.self) 165#define newSVterm(term) SvREFCNT_inc ((SV *)(term)->perl.self)
119#define SvTERM(sv) (rxvt_term *)SvPTR (sv, "urxvt::term") 166#define SvTERM(sv) (rxvt_term *)SvPTR ((sv), "urxvt::term")
120 167
121///////////////////////////////////////////////////////////////////////////// 168/////////////////////////////////////////////////////////////////////////////
122 169
123#define SvWATCHER(sv) (perl_watcher *)SvPTR (sv, "urxvt::watcher") 170#define SvOVERLAY(sv) (overlay *)SvPTR (sv, "urxvt::overlay")
124 171
125struct perl_watcher 172class overlay : overlay_base
126{ 173{
127 SV *cbsv; 174 rxvt_term *THIS;
175 AV *overlay_av;
176 int border;
177
178public:
128 HV *self; 179 HV *self;
129
130 perl_watcher ()
131 : cbsv (0)
132 {
133 }
134
135 ~perl_watcher ()
136 {
137 SvREFCNT_dec (cbsv);
138 }
139
140 void cb (SV *cb)
141 {
142 SvREFCNT_dec (cbsv);
143 cbsv = newSVsv (cb);
144 }
145
146 void invoke (const char *type, SV *self, int arg = -1);
147};
148
149void
150perl_watcher::invoke (const char *type, SV *self, int arg)
151{
152 dSP;
153
154 ENTER;
155 SAVETMPS;
156
157 PUSHMARK (SP);
158
159 XPUSHs (sv_2mortal (self));
160
161 if (arg >= 0)
162 XPUSHs (sv_2mortal (newSViv (arg)));
163
164 PUTBACK;
165 call_sv (cbsv, G_VOID | G_EVAL | G_DISCARD);
166 SPAGAIN;
167
168 PUTBACK;
169 FREETMPS;
170 LEAVE;
171
172 if (SvTRUE (ERRSV))
173 rxvt_warn ("%s callback evaluation error: %s", type, SvPV_nolen (ERRSV));
174}
175
176#define newSVtimer(timer) new_ref (timer->self, "urxvt::timer")
177#define SvTIMER(sv) (timer *)(perl_watcher *)SvPTR (sv, "urxvt::timer")
178
179struct timer : perl_watcher, time_watcher
180{
181 tstamp interval;
182
183 timer ()
184 : time_watcher (this, &timer::execute)
185 {
186 }
187
188 void execute (time_watcher &w)
189 {
190 if (interval)
191 start (at + interval);
192
193 invoke ("urxvt::timer", newSVtimer (this));
194 }
195};
196
197#define newSViow(iow) new_ref (iow->self, "urxvt::iow")
198#define SvIOW(sv) (iow *)(perl_watcher *)SvPTR (sv, "urxvt::iow")
199
200struct iow : perl_watcher, io_watcher
201{
202 iow ()
203 : io_watcher (this, &iow::execute)
204 {
205 }
206
207 void execute (io_watcher &w, short revents)
208 {
209 invoke ("urxvt::iow", newSViow (this), revents);
210 }
211};
212
213#define newSViw(iw) new_ref (iw->self, "urxvt::iw")
214#define SvIW(sv) (iw *)(perl_watcher *)SvPTR (sv, "urxvt::iw")
215
216struct iw : perl_watcher, idle_watcher
217{
218 iw ()
219 : idle_watcher (this, &iw::execute)
220 {
221 }
222
223 void execute (idle_watcher &w)
224 {
225 invoke ("urxvt::iw", newSViw (this));
226 }
227};
228
229#define newSVpw(pw) new_ref (pw->self, "urxvt::pw")
230#define SvPW(sv) (pw *)(perl_watcher *)SvPTR (sv, "urxvt::pw")
231
232struct pw : perl_watcher, child_watcher
233{
234 pw ()
235 : child_watcher (this, &pw::execute)
236 {
237 }
238
239 void execute (child_watcher &w, int status)
240 {
241 invoke ("urxvt::pw", newSVpw (this), status);
242 }
243};
244
245/////////////////////////////////////////////////////////////////////////////
246
247#define SvOVERLAY(sv) (overlay *)SvPTR (sv, "urxvt::overlay")
248
249struct overlay {
250 HV *self;
251 bool visible;
252 rxvt_term *THIS;
253 int x, y, w, h;
254 int border;
255 text_t **text;
256 rend_t **rend;
257 180
258 overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border); 181 overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border);
259 ~overlay (); 182 ~overlay ();
260 183
261 void show (); 184 void show ();
… …
265 188
266 void set (int x, int y, SV *str, SV *rend); 189 void set (int x, int y, SV *str, SV *rend);
267}; 190};
268 191
269overlay::overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border) 192overlay::overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border)
270: THIS(THIS), x(x_), y(y_), w(w_), h(h_), border(border == 2), visible(false) 193: THIS(THIS), border(border == 2), overlay_av (0)
271{ 194{
195 x = x_;
196 y = y_;
197 w = w_;
198 h = h_;
199
200 if (w < 0) w = 0;
201 if (h < 0) h = 0;
202
272 if (border == 2) 203 if (border == 2)
273 { 204 {
274 w += 2; 205 w += 2;
275 h += 2; 206 h += 2;
276 } 207 }
… …
314 *rp++ = r; 245 *rp++ = r;
315 } 246 }
316 } 247 }
317 248
318 show (); 249 show ();
319 THIS->want_refresh = 1;
320} 250}
321 251
322overlay::~overlay () 252overlay::~overlay ()
323{ 253{
324 hide (); 254 hide ();
… …
329 delete [] rend[y]; 259 delete [] rend[y];
330 } 260 }
331 261
332 delete [] text; 262 delete [] text;
333 delete [] rend; 263 delete [] rend;
264}
265
266void
267overlay::show ()
268{
269 if (overlay_av)
270 return;
271
272 overlay_av = (AV *)SvREFCNT_inc (SvRV (
273 *hv_fetch ((HV *)SvRV ((SV *)THIS->perl.self), "_overlay", 8, 0)
274 ));
275 av_push (overlay_av, newSViv ((long)this));
334 276
335 THIS->want_refresh = 1; 277 THIS->want_refresh = 1;
278 THIS->refresh_check ();
336} 279}
337 280
338void 281void
339overlay::show () 282overlay::hide ()
340{ 283{
341 if (visible) 284 if (!overlay_av)
342 return; 285 return;
343 286
344 visible = true;
345
346 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)THIS->perl.self), "_overlay", 8, 0));
347 av_push (av, newSViv ((long)this));
348}
349
350void
351overlay::hide ()
352{
353 if (!visible)
354 return;
355
356 visible = false;
357
358 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)THIS->perl.self), "_overlay", 8, 0));
359
360 int i; 287 int i;
361 288
362 for (i = AvFILL (av); i >= 0; i--) 289 for (i = AvFILL (overlay_av); i >= 0; i--)
363 if (SvIV (*av_fetch (av, i, 1)) == (long)this) 290 if (SvIV (*av_fetch (overlay_av, i, 1)) == (long)this)
364 {
365 av_delete (av, i, G_DISCARD);
366 break; 291 break;
367 }
368 292
369 for (; i < AvFILL (av); i++) 293 for (; i < AvFILL (overlay_av); i++)
370 av_store (av, i, SvREFCNT_inc (*av_fetch (av, i + 1, 0))); 294 av_store (overlay_av, i, SvREFCNT_inc (*av_fetch (overlay_av, i + 1, 0)));
371 295
372 av_pop (av); 296 av_pop (overlay_av);
297
298 SvREFCNT_dec (overlay_av);
299 overlay_av = 0;
300
301 THIS->want_refresh = 1;
302 THIS->refresh_check ();
373} 303}
374 304
375void overlay::swap () 305void overlay::swap ()
376{ 306{
377 int ov_x = max (0, min (MOD (x, THIS->ncol), THIS->ncol - w)); 307 int ov_x = max (0, min (MOD (x, THIS->ncol), THIS->ncol - w));
378 int ov_y = max (0, min (MOD (y, THIS->nrow), THIS->nrow - h)); 308 int ov_y = max (0, min (MOD (y, THIS->nrow), THIS->nrow - h));
379 309
380 int ov_w = min (w, THIS->ncol - ov_x); 310 int ov_w = min (w, THIS->ncol - ov_x);
381 int ov_h = min (h, THIS->nrow - ov_y); 311 int ov_h = min (h, THIS->nrow - ov_y);
312
313 // hide cursor if it is within the overlay area
314 if (IN_RANGE_EXC (THIS->screen.cur.col - ov_x, 0, ov_w)
315 && IN_RANGE_EXC (THIS->screen.cur.row - ov_y, 0, ov_h))
316 THIS->screen.flags &= ~Screen_VisibleCursor;
382 317
383 for (int y = ov_h; y--; ) 318 for (int y = ov_h; y--; )
384 { 319 {
385 text_t *t1 = text [y]; 320 text_t *t1 = text [y];
386 rend_t *r1 = rend [y]; 321 rend_t *r1 = rend [y];
… …
422 for (int col = min (AvFILL (av) + 1, w - x - border); col--; ) 357 for (int col = min (AvFILL (av) + 1, w - x - border); col--; )
423 this->rend [y][x + col] = SvIV (*av_fetch (av, col, 1)); 358 this->rend [y][x + col] = SvIV (*av_fetch (av, col, 1));
424 } 359 }
425 360
426 THIS->want_refresh = 1; 361 THIS->want_refresh = 1;
362 THIS->refresh_check ();
427} 363}
428 364
365/////////////////////////////////////////////////////////////////////////////
366
367#include "iom_perl.h"
429 368
430///////////////////////////////////////////////////////////////////////////// 369/////////////////////////////////////////////////////////////////////////////
431 370
432struct rxvt_perl_interp rxvt_perl; 371struct rxvt_perl_interp rxvt_perl;
433 372
… …
437{ 376{
438 if (perl) 377 if (perl)
439 { 378 {
440 perl_destruct (perl); 379 perl_destruct (perl);
441 perl_free (perl); 380 perl_free (perl);
381 PERL_SYS_TERM ();
442 } 382 }
443} 383}
444 384
445void 385void
446rxvt_perl_interp::init (rxvt_term *term) 386rxvt_perl_interp::init ()
447{ 387{
448 if (!perl) 388 if (!perl)
449 { 389 {
450 rxvt_push_locale (""); // perl init destroys current locale 390 rxvt_push_locale (""); // perl init destroys current locale
451 391
392 {
452 perl_environ = rxvt_environ; 393 perl_environ = rxvt_environ;
453 swap (perl_environ, environ); 394 localise_env set_environ (perl_environ);
454 395
455 char *argv[] = { 396 char *args[] = {
456 "", 397 "",
457 "-e" 398 "-e"
458 "BEGIN {" 399 "BEGIN {"
459 " urxvt->bootstrap;" 400 " urxvt->bootstrap;"
460 " unshift @INC, '" LIBDIR "';" 401 " unshift @INC, '" LIBDIR "';"
461 "}" 402 "}"
462 "" 403 ""
463 "use urxvt;" 404 "use urxvt;"
464 }; 405 };
406 int argc = ecb_array_length (args);
407 char **argv = args;
465 408
409 PERL_SYS_INIT3 (&argc, &argv, &environ);
466 perl = perl_alloc (); 410 perl = perl_alloc ();
467 perl_construct (perl); 411 perl_construct (perl);
468 412
469 if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) 413 if (perl_parse (perl, xs_init, argc, argv, (char **)NULL)
470 || perl_run (perl)) 414 || perl_run (perl))
471 { 415 {
472 rxvt_warn ("unable to initialize perl-interpreter, continuing without.\n"); 416 rxvt_warn ("unable to initialize perl-interpreter, continuing without.\n");
473 417
474 perl_destruct (perl); 418 perl_destruct (perl);
475 perl_free (perl); 419 perl_free (perl);
476 perl = 0; 420 perl = 0;
477 } 421 }
478 422 }
479 swap (perl_environ, environ);
480 423
481 rxvt_pop_locale (); 424 rxvt_pop_locale ();
482 } 425 }
426}
483 427
484 if (perl) 428void
429rxvt_perl_interp::init (rxvt_term *term)
430{
431 init ();
432
433 if (perl && !term->perl.self)
485 { 434 {
486 // runs outside of perls ENV 435 // runs outside of perls ENV
487 term->perl.self = (void *)newSVptr ((void *)term, "urxvt::term"); 436 term->perl.self = (void *)newSVptr ((void *)term, "urxvt::term");
488 hv_store ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, newRV_noinc ((SV *)newAV ()), 0); 437 hv_store ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, newRV_noinc ((SV *)newAV ()), 0);
438 hv_store ((HV *)SvRV ((SV *)term->perl.self), "_selection", 10, newRV_noinc ((SV *)newAV ()), 0);
489 } 439 }
440}
441
442void
443rxvt_perl_interp::eval (const char *str)
444{
445 eval_pv (str, 1);
446}
447
448void
449rxvt_perl_interp::usage (rxvt_term *term, int type)
450{
451 localise_env set_environ (perl_environ);
452
453 ENTER;
454 SAVETMPS;
455
456 dSP;
457 PUSHMARK (SP);
458 EXTEND (SP, 2);
459 PUSHs (sv_2mortal (newSVterm (term)));
460 PUSHs (sv_2mortal (newSViv (type)));
461 PUTBACK;
462 call_pv ("urxvt::usage", G_VOID | G_DISCARD);
463
464 FREETMPS;
465 LEAVE;
466}
467
468uint8_t
469rxvt_perl_interp::parse_resource (rxvt_term *term, const char *name, bool arg, bool longopt, bool flag, const char *value)
470{
471 localise_env set_environ (perl_environ);
472
473 ENTER;
474 SAVETMPS;
475
476 dSP;
477 PUSHMARK (SP);
478 EXTEND (SP, 6);
479 PUSHs (sv_2mortal (newSVterm (term)));
480 PUSHs (sv_2mortal (newSVpv (name, 0)));
481 PUSHs (arg ? &PL_sv_yes : &PL_sv_no);
482 PUSHs (longopt ? &PL_sv_yes : &PL_sv_no);
483 PUSHs (flag ? &PL_sv_yes : &PL_sv_no);
484 PUSHs (value ? sv_2mortal (newSVpv (value, 0)) : &PL_sv_undef);
485 PUTBACK;
486 call_pv ("urxvt::parse_resource", G_SCALAR);
487 SPAGAIN;
488
489 uint8_t ret = POPi;
490
491 FREETMPS;
492 LEAVE;
493
494 return ret;
490} 495}
491 496
492static void 497static void
493ungrab (rxvt_term *THIS) 498ungrab (rxvt_term *THIS)
494{ 499{
495 if (THIS->perl.grabtime) 500 if (THIS->perl.grabtime)
496 { 501 {
497 XUngrabKeyboard (THIS->display->display, THIS->perl.grabtime); 502 XUngrabKeyboard (THIS->dpy, THIS->perl.grabtime);
498 XUngrabPointer (THIS->display->display, THIS->perl.grabtime); 503 XUngrabPointer (THIS->dpy, THIS->perl.grabtime);
499 THIS->perl.grabtime = 0; 504 THIS->perl.grabtime = 0;
500 } 505 }
501} 506}
502 507
503bool 508bool
504rxvt_perl_interp::invoke (rxvt_term *term, hook_type htype, ...) 509rxvt_perl_interp::invoke (rxvt_term *term, hook_type htype, ...)
505{ 510{
506 if (!perl || !term->perl.self) 511 if (!perl || !term->perl.self)
507 return false; 512 return false;
513
514 localise_env set_environ (perl_environ);
508 515
509 // pre-handling of some events 516 // pre-handling of some events
510 if (htype == HOOK_REFRESH_END) 517 if (htype == HOOK_REFRESH_END)
511 { 518 {
512 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, 0)); 519 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, 0));
513 520
514 for (int i = 0; i <= AvFILL (av); i++) 521 for (int i = 0; i <= AvFILL (av); i++)
515 ((overlay *)SvIV (*av_fetch (av, i, 0)))->swap (); 522 ((overlay *)SvIV (*av_fetch (av, i, 0)))->swap ();
516 } 523 }
524 else if (htype == HOOK_DESTROY)
525 {
526 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_selection", 10, 0));
517 527
518 swap (perl_environ, environ); 528 for (int i = AvFILL (av); i >= 0; i--)
529 {
530 rxvt_selection *req = (rxvt_selection *)SvIV (*av_fetch (av, i, 0));
531 delete req;
532 }
533 }
519 534
520 bool event_consumed; 535 bool event_consumed;
521 536
522 if (htype == HOOK_INIT || htype == HOOK_DESTROY // must be called always
523 || term->perl.should_invoke [htype]) 537 if (term->perl.should_invoke [htype])
524 try
525 { 538 {
526 dSP; 539 dSP;
527 va_list ap; 540 va_list ap;
528 541
529 va_start (ap, htype); 542 va_start (ap, htype);
530 543
531 ENTER; 544 ENTER;
532 SAVETMPS; 545 SAVETMPS;
533 546
534 PUSHMARK (SP); 547 PUSHMARK (SP);
535 548
549 EXTEND (SP, 2);
536 XPUSHs (sv_2mortal (newSVterm (term))); 550 PUSHs (sv_2mortal (newSVterm (term)));
537 XPUSHs (sv_2mortal (newSViv (htype))); 551 PUSHs (sv_2mortal (newSViv (htype)));
538 552
539 for (;;) { 553 for (;;) {
540 data_type dt = (data_type)va_arg (ap, int); 554 data_type dt = (data_type)va_arg (ap, int);
541 555
542 switch (dt) 556 switch (dt)
543 { 557 {
544 case DT_INT: 558 case DT_INT:
545 XPUSHs (sv_2mortal (newSViv (va_arg (ap, int)))); 559 XPUSHs (sv_2mortal (newSViv (va_arg (ap, int))));
546 break; 560 break;
547 561
548 case DT_LONG: 562 case DT_LONG:
549 XPUSHs (sv_2mortal (newSViv (va_arg (ap, long)))); 563 XPUSHs (sv_2mortal (newSViv (va_arg (ap, long))));
550 break; 564 break;
551 565
552 case DT_STR: 566 case DT_STR:
553 XPUSHs (sv_2mortal (newSVpv (va_arg (ap, char *), 0))); 567 XPUSHs (sv_2mortal (newSVpv (va_arg (ap, char *), 0)));
554 break; 568 break;
555 569
556 case DT_STR_LEN: 570 case DT_STR_LEN:
557 { 571 {
558 char *str = va_arg (ap, char *); 572 char *str = va_arg (ap, char *);
559 int len = va_arg (ap, int); 573 int len = va_arg (ap, int);
560 574
561 XPUSHs (sv_2mortal (newSVpvn (str, len))); 575 XPUSHs (sv_2mortal (newSVpvn (str, len)));
562 } 576 }
563 break; 577 break;
564 578
565 case DT_WCS_LEN: 579 case DT_WCS_LEN:
566 { 580 {
567 wchar_t *wstr = va_arg (ap, wchar_t *); 581 wchar_t *wstr = va_arg (ap, wchar_t *);
568 int wlen = va_arg (ap, int); 582 int wlen = va_arg (ap, int);
569 583
570 XPUSHs (sv_2mortal (wcs2sv (wstr, wlen))); 584 XPUSHs (sv_2mortal (wcs2sv (wstr, wlen)));
571 } 585 }
572 break; 586 break;
573 587
588 case DT_LCS_LEN:
589 {
590 long *lstr = va_arg (ap, long *);
591 int llen = va_arg (ap, int);
592
593 XPUSHs (sv_2mortal (newSVpvn ((char *)lstr, llen * sizeof (long))));
594 }
595 break;
596
574 case DT_XEVENT: 597 case DT_XEVENT:
575 { 598 {
576 XEvent *xe = va_arg (ap, XEvent *); 599 XEvent *xe = va_arg (ap, XEvent *);
577 HV *hv = newHV (); 600 HV *hv = newHV ();
578 601
579# define set(name, sv) hv_store (hv, # name, sizeof (# name) - 1, sv, 0) 602# define set(name, sv) hv_store (hv, # name, sizeof (# name) - 1, sv, 0)
580# define setiv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSViv (val), 0) 603# define setiv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSViv (val), 0)
581# define setuv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSVuv (val), 0) 604# define setuv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSVuv (val), 0)
582# undef set 605# undef set
583 606
584 setiv (type, xe->type); 607 setiv (type, xe->type);
585 setiv (send_event, xe->xany.send_event); 608 setiv (send_event, xe->xany.send_event);
586 setiv (serial, xe->xany.serial); 609 setiv (serial, xe->xany.serial);
587 610
588 switch (xe->type) 611 switch (xe->type)
589 { 612 {
590 case KeyPress: 613 case KeyPress:
591 case KeyRelease: 614 case KeyRelease:
592 case ButtonPress: 615 case ButtonPress:
593 case ButtonRelease: 616 case ButtonRelease:
594 case MotionNotify: 617 case MotionNotify:
595 setuv (window, xe->xmotion.window); 618 setuv (window, xe->xmotion.window);
596 setuv (root, xe->xmotion.root); 619 setuv (root, xe->xmotion.root);
597 setuv (subwindow, xe->xmotion.subwindow); 620 setuv (subwindow, xe->xmotion.subwindow);
598 setuv (time, xe->xmotion.time); 621 setuv (time, xe->xmotion.time);
599 setiv (x, xe->xmotion.x); 622 setiv (x, xe->xmotion.x);
600 setiv (y, xe->xmotion.y); 623 setiv (y, xe->xmotion.y);
601 setiv (row, xe->xmotion.y / term->fheight + term->view_start); 624 setiv (row, xe->xmotion.y / term->fheight + term->view_start);
602 setiv (col, xe->xmotion.x / term->fwidth); 625 setiv (col, xe->xmotion.x / term->fwidth);
603 setiv (x_root, xe->xmotion.x_root); 626 setiv (x_root, xe->xmotion.x_root);
604 setiv (y_root, xe->xmotion.y_root); 627 setiv (y_root, xe->xmotion.y_root);
605 setuv (state, xe->xmotion.state); 628 setuv (state, xe->xmotion.state);
606 629
607 switch (xe->type) 630 switch (xe->type)
608 { 631 {
609 case KeyPress: 632 case KeyPress:
610 case KeyRelease: 633 case KeyRelease:
611 setuv (keycode, xe->xkey.keycode); 634 setuv (keycode, xe->xkey.keycode);
612 break; 635 break;
613 636
614 case ButtonPress: 637 case ButtonPress:
615 case ButtonRelease: 638 case ButtonRelease:
616 setuv (button, xe->xbutton.button); 639 setuv (button, xe->xbutton.button);
617 break; 640 break;
618 641
619 case MotionNotify: 642 case MotionNotify:
620 setiv (is_hint, xe->xmotion.is_hint); 643 setiv (is_hint, xe->xmotion.is_hint);
621 break; 644 break;
622 } 645 }
623 646
624 break; 647 break;
625 648
626 case MapNotify: 649 case MapNotify:
627 case UnmapNotify: 650 case UnmapNotify:
628 case ConfigureNotify: 651 case ConfigureNotify:
629 setuv (event, xe->xconfigure.event); 652 setuv (event, xe->xconfigure.event);
630 setuv (window, xe->xconfigure.window); 653 setuv (window, xe->xconfigure.window);
631 654
632 switch (xe->type) 655 switch (xe->type)
633 { 656 {
634 case ConfigureNotify: 657 case ConfigureNotify:
635 setiv (x, xe->xconfigure.x); 658 setiv (x, xe->xconfigure.x);
636 setiv (y, xe->xconfigure.y); 659 setiv (y, xe->xconfigure.y);
637 setiv (width, xe->xconfigure.width); 660 setiv (width, xe->xconfigure.width);
638 setiv (height, xe->xconfigure.height); 661 setiv (height, xe->xconfigure.height);
639 setuv (above, xe->xconfigure.above); 662 setuv (above, xe->xconfigure.above);
640 break; 663 break;
641 } 664 }
642 665
643 break; 666 break;
644 667
645 case PropertyNotify: 668 case PropertyNotify:
646 setuv (window, xe->xproperty.window); 669 setuv (window, xe->xproperty.window);
647 setuv (atom, xe->xproperty.atom); 670 setuv (atom, xe->xproperty.atom);
648 setuv (time, xe->xproperty.time); 671 setuv (time, xe->xproperty.time);
649 setiv (state, xe->xproperty.state); 672 setiv (state, xe->xproperty.state);
650 break; 673 break;
651 674
652 case ClientMessage: 675 case ClientMessage:
653 setuv (window, xe->xclient.window); 676 setuv (window, xe->xclient.window);
654 setuv (message_type, xe->xclient.message_type); 677 setuv (message_type, xe->xclient.message_type);
655 setuv (format, xe->xclient.format); 678 setuv (format, xe->xclient.format);
656 setuv (l0, xe->xclient.data.l[0]); 679 setuv (l0, xe->xclient.data.l[0]);
657 setuv (l1, xe->xclient.data.l[1]); 680 setuv (l1, xe->xclient.data.l[1]);
658 setuv (l2, xe->xclient.data.l[2]); 681 setuv (l2, xe->xclient.data.l[2]);
659 setuv (l3, xe->xclient.data.l[3]); 682 setuv (l3, xe->xclient.data.l[3]);
660 setuv (l4, xe->xclient.data.l[4]); 683 setuv (l4, xe->xclient.data.l[4]);
661 break; 684 break;
662 } 685 }
663 686
664 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv))); 687 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
665 } 688 }
666 break; 689 break;
667 690
668 case DT_END: 691 case DT_END:
669 goto call; 692 goto call;
670 693
671 default: 694 default:
672 rxvt_fatal ("FATAL: unable to pass data type %d\n", dt); 695 rxvt_fatal ("FATAL: unable to pass data type %d\n", dt);
673 } 696 }
697 }
698
699 call:
700 va_end (ap);
701
702 PUTBACK;
703 int count = call_pv ("urxvt::invoke", G_ARRAY | G_EVAL);
704 SPAGAIN;
705
706 if (count)
707 {
708 SV *status = POPs;
709 count = SvTRUE (status);
674 } 710 }
675 711
676 call:
677 va_end (ap);
678
679 PUTBACK; 712 PUTBACK;
680 int count = call_pv ("urxvt::invoke", G_ARRAY | G_EVAL);
681 SPAGAIN;
682
683 if (count)
684 {
685 SV *status = POPs;
686 count = SvTRUE (status);
687 }
688
689 PUTBACK;
690 FREETMPS; 713 FREETMPS;
691 LEAVE; 714 LEAVE;
692 715
693 if (SvTRUE (ERRSV)) 716 if (SvTRUE (ERRSV))
694 { 717 {
695 rxvt_warn ("perl hook %d evaluation error: %s", htype, SvPV_nolen (ERRSV)); 718 rxvt_warn ("perl hook %d evaluation error: %s", htype, SvPVbyte_nolen (ERRSV));
696 ungrab (term); // better lose the grab than the session 719 ungrab (term); // better lose the grab than the session
697 } 720 }
698 721
699 event_consumed = !!count; 722 event_consumed = !!count;
700 } 723 }
701 catch (...)
702 {
703 swap (perl_environ, environ);
704 throw;
705 }
706 else 724 else
707 event_consumed = false; 725 event_consumed = false;
708 726
709 // post-handling of some events 727 // post-handling of some events
710 if (htype == HOOK_REFRESH_BEGIN) 728 if (htype == HOOK_REFRESH_BEGIN)
711 { 729 {
712 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, 0)); 730 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, 0));
713 731
714 for (int i = AvFILL (av); i >= 0; i--) 732 for (int i = AvFILL (av); i >= 0; i--)
715 ((overlay *)SvIV (*av_fetch (av, i, 0)))->swap (); 733 ((overlay *)SvIV (*av_fetch (av, i, 0)))->swap ();
716 } 734 }
717 else if (htype == HOOK_DESTROY) 735 else if (htype == HOOK_DESTROY)
718 { 736 {
719 clearSVptr ((SV *)term->perl.self); 737 clearSVptr ((SV *)term->perl.self);
720 SvREFCNT_dec ((SV *)term->perl.self); 738 SvREFCNT_dec ((SV *)term->perl.self);
739
740 // don't allow further calls
741 term->perl.self = 0;
721 } 742 }
722 743
723 swap (perl_environ, environ);
724
725 return event_consumed; 744 return event_consumed;
745}
746
747void
748rxvt_perl_interp::selection_finish (rxvt_selection *sel, char *data, unsigned int len)
749{
750 localise_env set_environ (perl_environ);
751
752 ENTER;
753 SAVETMPS;
754
755 dSP;
756 XPUSHs (sv_2mortal (newSVpvn (data, len)));
757 PUTBACK;
758 call_sv ((SV *)sel->cb_sv, G_VOID | G_DISCARD | G_EVAL);
759
760 if (SvTRUE (ERRSV))
761 rxvt_warn ("perl selection callback evaluation error: %s", SvPVbyte_nolen (ERRSV));
762
763 FREETMPS;
764 LEAVE;
726} 765}
727 766
728///////////////////////////////////////////////////////////////////////////// 767/////////////////////////////////////////////////////////////////////////////
729 768
730MODULE = urxvt PACKAGE = urxvt 769MODULE = urxvt PACKAGE = urxvt
… …
742# define def(sym) av_store (hookname, HOOK_ ## sym, newSVpv (# sym, 0)); 781# define def(sym) av_store (hookname, HOOK_ ## sym, newSVpv (# sym, 0));
743# include "hookinc.h" 782# include "hookinc.h"
744# undef def 783# undef def
745 784
746 HV *option = get_hv ("urxvt::OPTION", 1); 785 HV *option = get_hv ("urxvt::OPTION", 1);
747# define def(name,val) hv_store (option, # name, sizeof (# name) - 1, newSVuv (Opt_ ## name), 0); 786# define def(name) hv_store (option, # name, sizeof (# name) - 1, newSVuv (Opt_ ## name), 0);
748# define nodef(name) 787# define nodef(name)
749# include "optinc.h" 788# include "optinc.h"
750# undef nodef 789# undef nodef
751# undef def 790# undef def
752 791
753 HV *stash = gv_stashpv ("urxvt", 1); 792 HV *stash = gv_stashpv ("urxvt", 1);
754 struct { 793 static const struct {
755 const char *name; 794 const char *name;
756 IV iv; 795 IV iv;
757 } *civ, const_iv[] = { 796 } *civ, const_iv[] = {
758# define const_iv(name) { # name, (IV)name } 797# define const_iv(name) { # name, (IV)name }
798 const_iv (NUM_RESOURCES),
759 const_iv (DEFAULT_RSTYLE), 799 const_iv (DEFAULT_RSTYLE),
760 const_iv (OVERLAY_RSTYLE), 800 const_iv (OVERLAY_RSTYLE),
801 const_iv (Color_Bits),
802 const_iv (RS_bgShift), const_iv (RS_bgMask),
803 const_iv (RS_fgShift), const_iv (RS_fgMask),
804 const_iv (RS_Careful),
805 const_iv (RS_fontCount),
806 const_iv (RS_fontShift),
807 const_iv (RS_fontMask),
808 const_iv (RS_baseattrMask),
809 const_iv (RS_attrMask),
810 const_iv (RS_redraw),
811 const_iv (RS_Sel),
761 const_iv (RS_Bold), 812 const_iv (RS_Bold),
762 const_iv (RS_Italic), 813 const_iv (RS_Italic),
763 const_iv (RS_Blink), 814 const_iv (RS_Blink),
764 const_iv (RS_RVid), 815 const_iv (RS_RVid),
765 const_iv (RS_Uline), 816 const_iv (RS_Uline),
… …
778 const_iv (Button3Mask), 829 const_iv (Button3Mask),
779 const_iv (Button4Mask), 830 const_iv (Button4Mask),
780 const_iv (Button5Mask), 831 const_iv (Button5Mask),
781 const_iv (AnyModifier), 832 const_iv (AnyModifier),
782 833
783 const_iv (EVENT_NONE), 834 const_iv (NoSymbol),
784 const_iv (EVENT_READ), 835 const_iv (GrabModeSync),
785 const_iv (EVENT_WRITE), 836 const_iv (GrabModeAsync),
786 837
787 const_iv (NoEventMask), 838 const_iv (NoEventMask),
788 const_iv (KeyPressMask), 839 const_iv (KeyPressMask),
789 const_iv (KeyReleaseMask), 840 const_iv (KeyReleaseMask),
790 const_iv (ButtonPressMask), 841 const_iv (ButtonPressMask),
… …
842 const_iv (SelectionRequest), 893 const_iv (SelectionRequest),
843 const_iv (SelectionNotify), 894 const_iv (SelectionNotify),
844 const_iv (ColormapNotify), 895 const_iv (ColormapNotify),
845 const_iv (ClientMessage), 896 const_iv (ClientMessage),
846 const_iv (MappingNotify), 897 const_iv (MappingNotify),
898# if ENABLE_XIM_ONTHESPOT
899 const_iv (XIMReverse),
900 const_iv (XIMUnderline),
901 const_iv (XIMHighlight),
902 const_iv (XIMPrimary),
903 const_iv (XIMSecondary),
904 const_iv (XIMTertiary),
905 const_iv (XIMVisibleToForward),
906 const_iv (XIMVisibleToBackword),
907 const_iv (XIMVisibleToCenter),
908#if XRENDER
909 const_iv (PictStandardARGB32),
910 const_iv (PictStandardRGB24),
911 const_iv (PictStandardA8),
912 const_iv (PictStandardA4),
913 const_iv (PictStandardA1),
914 const_iv (RepeatNone),
915 const_iv (RepeatNormal),
916 const_iv (RepeatPad),
917 const_iv (RepeatReflect),
918 // all versions
919 const_iv (PictOpClear),
920 const_iv (PictOpSrc),
921 const_iv (PictOpDst),
922 const_iv (PictOpOver),
923 const_iv (PictOpOverReverse),
924 const_iv (PictOpIn),
925 const_iv (PictOpInReverse),
926 const_iv (PictOpOut),
927 const_iv (PictOpOutReverse),
928 const_iv (PictOpAtop),
929 const_iv (PictOpAtopReverse),
930 const_iv (PictOpXor),
931 const_iv (PictOpAdd),
932 const_iv (PictOpSaturate),
933 // 0.2+
934 const_iv (PictOpDisjointClear),
935 const_iv (PictOpDisjointSrc),
936 const_iv (PictOpDisjointDst),
937 const_iv (PictOpDisjointOver),
938 const_iv (PictOpDisjointOverReverse),
939 const_iv (PictOpDisjointIn),
940 const_iv (PictOpDisjointInReverse),
941 const_iv (PictOpDisjointOut),
942 const_iv (PictOpDisjointOutReverse),
943 const_iv (PictOpDisjointAtop),
944 const_iv (PictOpDisjointAtopReverse),
945 const_iv (PictOpDisjointXor),
946 const_iv (PictOpConjointClear),
947 const_iv (PictOpConjointSrc),
948 const_iv (PictOpConjointDst),
949 const_iv (PictOpConjointOver),
950 const_iv (PictOpConjointOverReverse),
951 const_iv (PictOpConjointIn),
952 const_iv (PictOpConjointInReverse),
953 const_iv (PictOpConjointOut),
954 const_iv (PictOpConjointOutReverse),
955 const_iv (PictOpConjointAtop),
956 const_iv (PictOpConjointAtopReverse),
957 const_iv (PictOpConjointXor),
958 // 0.11+
959 const_iv (PictOpMultiply),
960 const_iv (PictOpScreen),
961 const_iv (PictOpOverlay),
962 const_iv (PictOpDarken),
963 const_iv (PictOpLighten),
964 const_iv (PictOpColorDodge),
965 const_iv (PictOpColorBurn),
966 const_iv (PictOpHardLight),
967 const_iv (PictOpSoftLight),
968 const_iv (PictOpDifference),
969 const_iv (PictOpExclusion),
970 const_iv (PictOpHSLHue),
971 const_iv (PictOpHSLSaturation),
972 const_iv (PictOpHSLColor),
973 const_iv (PictOpHSLLuminosity),
974#endif
975# if 0
976 const_iv (XIMForwardChar),
977 const_iv (XIMBackwardChar),
978 const_iv (XIMForwardWord),
979 const_iv (XIMBackwardWord),
980 const_iv (XIMCaretUp),
981 const_iv (XIMCaretDown),
982 const_iv (XIMNextLine),
983 const_iv (XIMPreviousLine),
984 const_iv (XIMLineStart),
985 const_iv (XIMLineEnd),
986 const_iv (XIMAbsolutePosition),
987 const_iv (XIMDontChange),
988# endif
989# endif
847 }; 990 };
848 991
849 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); 992 for (civ = const_iv + ecb_array_length (const_iv); civ > const_iv; civ--)
850 civ-- > const_iv; )
851 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv)); 993 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
852} 994}
995
996void
997log (const char *msg)
998 CODE:
999 rxvt_log ("%s", msg);
853 1000
854void 1001void
855warn (const char *msg) 1002warn (const char *msg)
856 CODE: 1003 CODE:
857 rxvt_warn ("%s", msg); 1004 rxvt_warn ("%s", msg);
… …
861 CODE: 1008 CODE:
862 rxvt_fatal ("%s", msg); 1009 rxvt_fatal ("%s", msg);
863 1010
864void 1011void
865_exit (int status) 1012_exit (int status)
1013
1014void
1015catch_fatal (SV *block)
1016 PROTOTYPE: &
1017 CODE:
1018 try
1019 {
1020 PUSHMARK (SP);
1021 PUTBACK;
1022 call_sv (block, G_VOID | G_DISCARD);
1023 SPAGAIN;
1024 }
1025 catch (const rxvt_failure_exception &e)
1026 {
1027 croak ("rxvt_fatal exception caught, trying to continue.");
1028 }
866 1029
867NV 1030NV
868NOW () 1031NOW ()
869 CODE: 1032 CODE:
870 RETVAL = NOW; 1033 RETVAL = ev::now ();
871 OUTPUT: 1034 OUTPUT:
872 RETVAL 1035 RETVAL
873 1036
874int 1037int
875GET_BASEFG (int rend) 1038GET_BASEFG (int rend)
… …
886 RETVAL 1049 RETVAL
887 1050
888int 1051int
889SET_FGCOLOR (int rend, int new_color) 1052SET_FGCOLOR (int rend, int new_color)
890 CODE: 1053 CODE:
891 RETVAL = SET_FGCOLOR (rend, new_color); 1054 RETVAL = SET_FGCOLOR (rend, clamp (new_color, 0, TOTAL_COLORS - 1));
892 OUTPUT: 1055 OUTPUT:
893 RETVAL 1056 RETVAL
894 1057
895int 1058int
896SET_BGCOLOR (int rend, int new_color) 1059SET_BGCOLOR (int rend, int new_color)
897 CODE: 1060 CODE:
898 RETVAL = SET_BGCOLOR (rend, new_color); 1061 RETVAL = SET_BGCOLOR (rend, clamp (new_color, 0, TOTAL_COLORS - 1));
899 OUTPUT: 1062 OUTPUT:
900 RETVAL 1063 RETVAL
901 1064
902int 1065int
903GET_CUSTOM (int rend) 1066GET_CUSTOM (int rend)
904 CODE: 1067 CODE:
905 RETVAL = (rend && RS_customMask) >> RS_customShift; 1068 RETVAL = (rend & RS_customMask) >> RS_customShift;
906 OUTPUT: 1069 OUTPUT:
907 RETVAL 1070 RETVAL
908 1071
909int 1072int
910SET_CUSTOM (int rend, int new_value) 1073SET_CUSTOM (int rend, int new_value)
… …
917 | ((new_value << RS_customShift) & RS_customMask); 1080 | ((new_value << RS_customShift) & RS_customMask);
918} 1081}
919 OUTPUT: 1082 OUTPUT:
920 RETVAL 1083 RETVAL
921 1084
1085void
1086termlist ()
1087 PPCODE:
1088{
1089 EXTEND (SP, rxvt_term::termlist.size ());
1090
1091 for (rxvt_term **t = rxvt_term::termlist.begin (); t < rxvt_term::termlist.end (); t++)
1092 if ((*t)->perl.self)
1093 PUSHs (sv_2mortal (newSVterm (*t)));
1094}
1095
1096IV
1097_new_selection_request (rxvt_term *term, int selnum, Time tm, Window win, Atom prop, SV *cb)
1098 CODE:
1099 rxvt_selection *req = new rxvt_selection (term->display, selnum, tm, win, prop, term);
1100 req->cb_sv = newSVsv (cb);
1101 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_selection", 10, 0));
1102 av_push (av, newSViv ((IV)req));
1103 RETVAL = (IV)req;
1104 OUTPUT:
1105 RETVAL
1106
1107void
1108_delete_selection_request (IV req_)
1109 CODE:
1110 rxvt_selection *req = (rxvt_selection *)req_;
1111 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)req->term->perl.self), "_selection", 10, 0));
1112 int i;
1113
1114 for (i = AvFILL (av); i >= 0; i--)
1115 if (SvIV (*av_fetch (av, i, 1)) == req_)
1116 break;
1117
1118 for (; i < AvFILL (av); i++)
1119 av_store (av, i, SvREFCNT_inc (*av_fetch (av, i + 1, 0)));
1120
1121 av_pop (av);
1122
1123 delete req;
1124
922MODULE = urxvt PACKAGE = urxvt::term 1125MODULE = urxvt PACKAGE = urxvt::term
923 1126
924SV * 1127SV *
925_new (...) 1128_new (AV *env, AV *arg)
926 CODE: 1129 CODE:
927{ 1130{
928 if (items < 1 || !SvROK (ST (0)) || SvTYPE (SvRV (ST (0))) != SVt_PVAV)
929 croak ("first argument to urxvt::term->_new must be arrayref");
930
931 rxvt_term *term = new rxvt_term; 1131 rxvt_term *term = new rxvt_term;
932 1132
933 term->argv = new stringvec; 1133 stringvec *argv = new stringvec;
934 term->envv = new stringvec; 1134 for (int i = 0; i <= AvFILL (arg); i++)
935
936 for (int i = 1; i < items; i++)
937 term->argv->push_back (strdup (SvPVbyte_nolen (ST (i)))); 1135 argv->push_back (strdup (SvPVbyte_nolen (*av_fetch (arg, i, 1))));
938 1136
939 AV *envv = (AV *)SvRV (ST (0)); 1137 stringvec *envv = new stringvec;
940 for (int i = AvFILL (envv) + 1; i--; ) 1138 for (int i = AvFILL (env) + 1; i--; )
941 term->envv->push_back (strdup (SvPVbyte_nolen (*av_fetch (envv, i, 1)))); 1139 envv->push_back (strdup (SvPVbyte_nolen (*av_fetch (env, i, 1))));
942
943 term->envv->push_back (0);
944
945 bool success;
946 1140
947 try 1141 try
948 { 1142 {
949 success = term->init (term->argv->size (), term->argv->begin ()); 1143 term->init (argv, envv);
950 } 1144 }
951 catch (const class rxvt_failure_exception &e) 1145 catch (const class rxvt_failure_exception &e)
952 {
953 success = false;
954 }
955
956 if (!success)
957 { 1146 {
958 term->destroy (); 1147 term->destroy ();
959 croak ("error while initializing new terminal instance"); 1148 croak ("error while initializing new terminal instance");
960 } 1149 }
961 1150
… …
969rxvt_term::destroy () 1158rxvt_term::destroy ()
970 1159
971void 1160void
972rxvt_term::set_should_invoke (int htype, int inc) 1161rxvt_term::set_should_invoke (int htype, int inc)
973 CODE: 1162 CODE:
974 THIS->perl.should_invoke [htype] += inc; 1163 uint8_t &count = THIS->perl.should_invoke [htype];
1164 uint8_t prev = count;
1165 count += inc;
1166 if (!prev != !count)
1167 {
1168 // hook status changed, react
1169 switch (htype)
1170 {
1171 case HOOK_POSITION_CHANGE:
1172 if (count)
1173 THIS->get_window_origin (THIS->parent_x, THIS->parent_y);
1174 }
1175 }
975 1176
976void 1177void
1178rxvt_term::put_option_db (octet_string specifier, octet_string value)
1179 CODE:
1180 XrmPutStringResource (&THIS->option_db, specifier, value);
1181
1182int
977rxvt_term::grab_button (int button, U32 modifiers) 1183rxvt_term::grab_button (int button, U32 modifiers, Window window = THIS->vt)
978 CODE: 1184 CODE:
979 XGrabButton (THIS->display->display, button, modifiers, THIS->vt, 1, 1185 RETVAL = XGrabButton (THIS->dpy, button, modifiers, window, 1,
980 ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask, 1186 ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
981 GrabModeSync, GrabModeSync, None, GRAB_CURSOR); 1187 GrabModeSync, GrabModeSync, None, GRAB_CURSOR);
1188 OUTPUT: RETVAL
1189
1190int
1191rxvt_term::ungrab_button (int button, U32 modifiers, Window window = THIS->vt)
1192 CODE:
1193 RETVAL = XUngrabButton (THIS->dpy, button, modifiers, window);
1194 OUTPUT: RETVAL
1195
1196void
1197rxvt_term::XGrabKey (int keycode, U32 modifiers, Window window = THIS->vt, \
1198 int owner_events = 1, int pointer_mode = GrabModeAsync, int keyboard_mode = GrabModeAsync)
1199 CODE:
1200 XGrabKey (THIS->dpy, keycode, modifiers, window, owner_events, pointer_mode, keyboard_mode);
1201
1202void
1203rxvt_term::XUngrabKey (int keycode, U32 modifiers, Window window = THIS->vt)
1204 CODE:
1205 XUngrabKey (THIS->dpy, keycode, modifiers, window);
982 1206
983bool 1207bool
984rxvt_term::grab (Time eventtime, int sync = 0) 1208rxvt_term::grab (Time eventtime, int sync = 0)
985 CODE: 1209 CODE:
986{ 1210{
987 int mode = sync ? GrabModeSync : GrabModeAsync; 1211 int mode = sync ? GrabModeSync : GrabModeAsync;
988 1212
989 THIS->perl.grabtime = 0; 1213 THIS->perl.grabtime = 0;
990 1214
991 if (!XGrabPointer (THIS->display->display, THIS->vt, 0, 1215 if (!XGrabPointer (THIS->dpy, THIS->vt, 0,
992 ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask, 1216 ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
993 mode, mode, None, GRAB_CURSOR, eventtime)) 1217 mode, mode, None, GRAB_CURSOR, eventtime))
994 if (!XGrabKeyboard (THIS->display->display, THIS->vt, 0, mode, mode, eventtime)) 1218 if (!XGrabKeyboard (THIS->dpy, THIS->vt, 0, mode, mode, eventtime))
995 THIS->perl.grabtime = eventtime; 1219 THIS->perl.grabtime = eventtime;
996 else 1220 else
997 XUngrabPointer (THIS->display->display, eventtime); 1221 XUngrabPointer (THIS->dpy, eventtime);
998 1222
999 RETVAL = !!THIS->perl.grabtime; 1223 RETVAL = !!THIS->perl.grabtime;
1000} 1224}
1001 OUTPUT: 1225 OUTPUT:
1002 RETVAL 1226 RETVAL
1003 1227
1004void 1228void
1005rxvt_term::allow_events_async () 1229rxvt_term::allow_events_async ()
1006 CODE: 1230 CODE:
1007 XAllowEvents (THIS->display->display, AsyncBoth, THIS->perl.grabtime); 1231 XAllowEvents (THIS->dpy, AsyncBoth, THIS->perl.grabtime);
1008 1232
1009void 1233void
1010rxvt_term::allow_events_sync () 1234rxvt_term::allow_events_sync ()
1011 CODE: 1235 CODE:
1012 XAllowEvents (THIS->display->display, SyncBoth, THIS->perl.grabtime); 1236 XAllowEvents (THIS->dpy, SyncBoth, THIS->perl.grabtime);
1013 1237
1014void 1238void
1015rxvt_term::allow_events_replay () 1239rxvt_term::allow_events_replay ()
1016 CODE: 1240 CODE:
1017 XAllowEvents (THIS->display->display, ReplayPointer, THIS->perl.grabtime); 1241 XAllowEvents (THIS->dpy, ReplayPointer, THIS->perl.grabtime);
1018 XAllowEvents (THIS->display->display, ReplayKeyboard, THIS->perl.grabtime); 1242 XAllowEvents (THIS->dpy, ReplayKeyboard, THIS->perl.grabtime);
1019 1243
1020void 1244void
1021rxvt_term::ungrab () 1245rxvt_term::ungrab ()
1022 CODE: 1246 CODE:
1023 ungrab (THIS); 1247 ungrab (THIS);
1248
1249int
1250rxvt_term::XStringToKeysym (char *string)
1251 CODE:
1252 RETVAL = XStringToKeysym (string);
1253 OUTPUT: RETVAL
1254
1255char *
1256rxvt_term::XKeysymToString (int sym)
1257 CODE:
1258 RETVAL = XKeysymToString (sym);
1259 OUTPUT: RETVAL
1260
1261int
1262rxvt_term::XKeysymToKeycode (int sym)
1263 CODE:
1264 RETVAL = XKeysymToKeycode (THIS->dpy, sym);
1265 OUTPUT: RETVAL
1266
1267int
1268rxvt_term::XKeycodeToKeysym (int code, int index)
1269 CODE:
1270 RETVAL = XKeycodeToKeysym (THIS->dpy, code, index);
1271 OUTPUT: RETVAL
1024 1272
1025int 1273int
1026rxvt_term::strwidth (SV *str) 1274rxvt_term::strwidth (SV *str)
1027 CODE: 1275 CODE:
1028{ 1276{
1029 wchar_t *wstr = sv2wcs (str); 1277 wchar_t *wstr = sv2wcs (str);
1030 1278
1031 rxvt_push_locale (THIS->locale); 1279 rxvt_push_locale (THIS->locale);
1032 RETVAL = wcswidth (wstr, wcslen (wstr)); 1280 RETVAL = 0;
1281 for (wchar_t *wc = wstr; *wc; wc++)
1282 {
1283 int w = WCWIDTH (*wc);
1284
1285 if (w)
1286 RETVAL += max (w, 1);
1287 }
1033 rxvt_pop_locale (); 1288 rxvt_pop_locale ();
1034 1289
1035 free (wstr); 1290 free (wstr);
1036} 1291}
1037 OUTPUT: 1292 OUTPUT:
… …
1072 OUTPUT: 1327 OUTPUT:
1073 RETVAL 1328 RETVAL
1074 1329
1075#define TERM_OFFSET(sym) offsetof (TermWin_t, sym) 1330#define TERM_OFFSET(sym) offsetof (TermWin_t, sym)
1076 1331
1077#define TERM_OFFSET_width TERM_OFFSET(width) 1332#define TERM_OFFSET_width TERM_OFFSET(width)
1078#define TERM_OFFSET_height TERM_OFFSET(height) 1333#define TERM_OFFSET_height TERM_OFFSET(height)
1079#define TERM_OFFSET_fwidth TERM_OFFSET(fwidth) 1334#define TERM_OFFSET_fwidth TERM_OFFSET(fwidth)
1080#define TERM_OFFSET_fheight TERM_OFFSET(fheight) 1335#define TERM_OFFSET_fheight TERM_OFFSET(fheight)
1081#define TERM_OFFSET_fbase TERM_OFFSET(fbase) 1336#define TERM_OFFSET_fbase TERM_OFFSET(fbase)
1082#define TERM_OFFSET_nrow TERM_OFFSET(nrow) 1337#define TERM_OFFSET_nrow TERM_OFFSET(nrow)
1083#define TERM_OFFSET_ncol TERM_OFFSET(ncol) 1338#define TERM_OFFSET_ncol TERM_OFFSET(ncol)
1084#define TERM_OFFSET_focus TERM_OFFSET(focus) 1339#define TERM_OFFSET_focus TERM_OFFSET(focus)
1085#define TERM_OFFSET_mapped TERM_OFFSET(mapped) 1340#define TERM_OFFSET_mapped TERM_OFFSET(mapped)
1086#define TERM_OFFSET_int_bwidth TERM_OFFSET(int_bwidth) 1341#define TERM_OFFSET_int_bwidth TERM_OFFSET(int_bwidth)
1087#define TERM_OFFSET_ext_bwidth TERM_OFFSET(ext_bwidth) 1342#define TERM_OFFSET_ext_bwidth TERM_OFFSET(ext_bwidth)
1088#define TERM_OFFSET_lineSpace TERM_OFFSET(lineSpace) 1343#define TERM_OFFSET_lineSpace TERM_OFFSET(lineSpace)
1344#define TERM_OFFSET_letterSpace TERM_OFFSET(letterSpace)
1089#define TERM_OFFSET_saveLines TERM_OFFSET(saveLines) 1345#define TERM_OFFSET_saveLines TERM_OFFSET(saveLines)
1090#define TERM_OFFSET_total_rows TERM_OFFSET(total_rows) 1346#define TERM_OFFSET_total_rows TERM_OFFSET(total_rows)
1091#define TERM_OFFSET_top_row TERM_OFFSET(top_row) 1347#define TERM_OFFSET_top_row TERM_OFFSET(top_row)
1092 1348
1093int 1349int
1094rxvt_term::width () 1350rxvt_term::width ()
1095 ALIAS: 1351 ALIAS:
1096 width = TERM_OFFSET_width 1352 width = TERM_OFFSET_width
1097 height = TERM_OFFSET_height 1353 height = TERM_OFFSET_height
1098 fwidth = TERM_OFFSET_fwidth 1354 fwidth = TERM_OFFSET_fwidth
1099 fheight = TERM_OFFSET_fheight 1355 fheight = TERM_OFFSET_fheight
1100 fbase = TERM_OFFSET_fbase 1356 fbase = TERM_OFFSET_fbase
1101 nrow = TERM_OFFSET_nrow 1357 nrow = TERM_OFFSET_nrow
1102 ncol = TERM_OFFSET_ncol 1358 ncol = TERM_OFFSET_ncol
1103 focus = TERM_OFFSET_focus 1359 focus = TERM_OFFSET_focus
1104 mapped = TERM_OFFSET_mapped 1360 mapped = TERM_OFFSET_mapped
1105 int_bwidth = TERM_OFFSET_int_bwidth 1361 int_bwidth = TERM_OFFSET_int_bwidth
1106 ext_bwidth = TERM_OFFSET_ext_bwidth 1362 ext_bwidth = TERM_OFFSET_ext_bwidth
1107 lineSpace = TERM_OFFSET_lineSpace 1363 lineSpace = TERM_OFFSET_lineSpace
1364 letterSpace = TERM_OFFSET_letterSpace
1108 saveLines = TERM_OFFSET_saveLines 1365 saveLines = TERM_OFFSET_saveLines
1109 total_rows = TERM_OFFSET_total_rows 1366 total_rows = TERM_OFFSET_total_rows
1110 top_row = TERM_OFFSET_top_row 1367 top_row = TERM_OFFSET_top_row
1111 CODE: 1368 CODE:
1112 RETVAL = *(int *)((char *)THIS + ix); 1369 RETVAL = *(int *)((char *)THIS + ix);
1113 OUTPUT: 1370 OUTPUT:
1114 RETVAL 1371 RETVAL
1115 1372
… …
1126 { 1383 {
1127 case 0: RETVAL = THIS->ModLevel3Mask; break; 1384 case 0: RETVAL = THIS->ModLevel3Mask; break;
1128 case 1: RETVAL = THIS->ModMetaMask; break; 1385 case 1: RETVAL = THIS->ModMetaMask; break;
1129 case 2: RETVAL = THIS->ModNumLockMask; break; 1386 case 2: RETVAL = THIS->ModNumLockMask; break;
1130 case 3: RETVAL = THIS->current_screen; break; 1387 case 3: RETVAL = THIS->current_screen; break;
1388#ifdef CURSOR_BLINK
1131 case 4: RETVAL = THIS->hidden_cursor; break; 1389 case 4: RETVAL = THIS->hidden_cursor; break;
1390#endif
1132 } 1391 }
1133 OUTPUT: 1392 OUTPUT:
1134 RETVAL 1393 RETVAL
1135 1394
1136char * 1395char *
… …
1146 } 1405 }
1147 OUTPUT: 1406 OUTPUT:
1148 RETVAL 1407 RETVAL
1149 1408
1150SV * 1409SV *
1151rxvt_term::_env () 1410rxvt_term::envv ()
1411 ALIAS:
1412 argv = 1
1152 CODE: 1413 PPCODE:
1153{ 1414{
1154 if (THIS->envv) 1415 stringvec *vec = ix ? THIS->argv : THIS->envv;
1155 {
1156 AV *av = newAV ();
1157 1416
1417 EXTEND (SP, vec->size ());
1418
1158 for (char **i = THIS->envv->begin (); i != THIS->envv->end (); ++i) 1419 for (char **i = vec->begin (); i != vec->end (); ++i)
1159 if (*i) 1420 if (*i)
1160 av_push (av, newSVpv (*i, 0)); 1421 PUSHs (sv_2mortal (newSVpv (*i, 0)));
1161
1162 RETVAL = newRV_noinc ((SV *)av);
1163 }
1164 else
1165 RETVAL = &PL_sv_undef;
1166} 1422}
1167 OUTPUT:
1168 RETVAL
1169 1423
1170int 1424int
1171rxvt_term::pty_ev_events (int events = EVENT_UNDEF) 1425rxvt_term::pty_ev_events (int events = ev::UNDEF)
1172 CODE: 1426 CODE:
1173 RETVAL = THIS->pty_ev.events; 1427 RETVAL = THIS->pty_ev.events;
1174 if (events != EVENT_UNDEF) 1428 if (events != ev::UNDEF)
1175 THIS->pty_ev.set (events); 1429 THIS->pty_ev.set (events);
1430 OUTPUT:
1431 RETVAL
1432
1433int
1434rxvt_term::pty_fd ()
1435 CODE:
1436 RETVAL = THIS->pty->pty;
1176 OUTPUT: 1437 OUTPUT:
1177 RETVAL 1438 RETVAL
1178 1439
1179Window 1440Window
1180rxvt_term::parent () 1441rxvt_term::parent ()
1181 CODE: 1442 CODE:
1182 RETVAL = THIS->parent [0]; 1443 RETVAL = THIS->parent;
1444 OUTPUT:
1445 RETVAL
1446
1447int
1448rxvt_term::parent_x ()
1449 CODE:
1450 RETVAL = THIS->parent_x;
1451 OUTPUT:
1452 RETVAL
1453
1454int
1455rxvt_term::parent_y ()
1456 CODE:
1457 RETVAL = THIS->parent_y;
1183 OUTPUT: 1458 OUTPUT:
1184 RETVAL 1459 RETVAL
1185 1460
1186Window 1461Window
1187rxvt_term::vt () 1462rxvt_term::vt ()
… …
1216} 1491}
1217 OUTPUT: 1492 OUTPUT:
1218 RETVAL 1493 RETVAL
1219 1494
1220void 1495void
1496rxvt_term::set_urgency (bool enable)
1497
1498void
1221rxvt_term::focus_in () 1499rxvt_term::focus_in ()
1222 1500
1223void 1501void
1224rxvt_term::focus_out () 1502rxvt_term::focus_out ()
1225 1503
1226void 1504void
1505rxvt_term::key_press (unsigned int state, unsigned int keycode, Time time = CurrentTime)
1506 ALIAS:
1507 key_release = 1
1508 CODE:
1509{
1510 XKeyEvent xkey;
1511
1512 memset (&xkey, 0, sizeof (xkey));
1513
1514 xkey.time = time;
1515 xkey.state = state;
1516 xkey.keycode = keycode;
1517
1518 xkey.type = ix ? KeyRelease : KeyPress;
1519 xkey.display = THIS->dpy;
1520 xkey.window = THIS->vt;
1521 xkey.root = THIS->display->root;
1522 xkey.subwindow = THIS->vt;
1523
1524 if (ix)
1525 THIS->key_release (xkey);
1526 else
1527 THIS->key_press (xkey);
1528}
1529
1530void
1227rxvt_term::want_refresh () 1531rxvt_term::want_refresh ()
1228 CODE: 1532 CODE:
1229 THIS->want_refresh = 1; 1533 THIS->want_refresh = 1;
1534 THIS->refresh_check ();
1230 1535
1231void 1536void
1232rxvt_term::ROW_t (int row_number, SV *new_text = 0, int start_col = 0, int start_ofs = 0, int max_len = MAX_COLS) 1537rxvt_term::ROW_t (int row_number, SV *new_text = 0, int start_col = 0, int start_ofs = 0, int max_len = MAX_COLS)
1233 PPCODE: 1538 PPCODE:
1234{ 1539{
… …
1237 1542
1238 line_t &l = ROW(row_number); 1543 line_t &l = ROW(row_number);
1239 1544
1240 if (GIMME_V != G_VOID) 1545 if (GIMME_V != G_VOID)
1241 { 1546 {
1242 wchar_t *wstr = new wchar_t [THIS->ncol]; 1547 wchar_t *wstr = rxvt_temp_buf<wchar_t> (THIS->ncol);
1243 1548
1244 for (int col = 0; col < THIS->ncol; col++) 1549 for (int col = 0; col < THIS->ncol; col++)
1245 wstr [col] = l.t [col]; 1550 wstr [col] = l.t [col];
1246 1551
1247 XPUSHs (sv_2mortal (wcs2sv (wstr, THIS->ncol))); 1552 XPUSHs (sv_2mortal (wcs2sv (wstr, THIS->ncol)));
1248
1249 delete [] wstr;
1250 } 1553 }
1251 1554
1252 if (new_text) 1555 if (new_text)
1253 { 1556 {
1254 wchar_t *wstr = sv2wcs (new_text); 1557 wchar_t *wstr = sv2wcs (new_text);
… …
1347rxvt_term::special_encode (SV *string) 1650rxvt_term::special_encode (SV *string)
1348 CODE: 1651 CODE:
1349{ 1652{
1350 wchar_t *wstr = sv2wcs (string); 1653 wchar_t *wstr = sv2wcs (string);
1351 int wlen = wcslen (wstr); 1654 int wlen = wcslen (wstr);
1352 wchar_t *rstr = new wchar_t [wlen]; // cannot become longer 1655 wchar_t *rstr = rxvt_temp_buf<wchar_t> (wlen * 2); // cannot become longer
1353 1656
1354 rxvt_push_locale (THIS->locale); 1657 rxvt_push_locale (THIS->locale);
1355 1658
1356 wchar_t *r = rstr; 1659 wchar_t *r = rstr;
1357 for (wchar_t *s = wstr; *s; s++) 1660 for (wchar_t *s = wstr; *s; s++)
1661 {
1662 int w = WCWIDTH (*s);
1663
1358 if (wcwidth (*s) == 0) 1664 if (w == 0)
1359 { 1665 {
1360 if (r == rstr) 1666 if (r == rstr)
1361 croak ("leading combining character unencodable"); 1667 croak ("leading combining character unencodable");
1362 1668
1363 unicode_t n = rxvt_compose (r[-1], *s); 1669 unicode_t n = rxvt_compose (r[-1], *s);
1364 if (n == NOCHAR) 1670 if (n == NOCHAR)
1365 n = rxvt_composite.compose (r[-1], *s); 1671 n = rxvt_composite.compose (r[-1], *s);
1366 1672
1367 r[-1] = n; 1673 r[-1] = n;
1368 } 1674 }
1369#if !UNICODE_3 1675#if !UNICODE_3
1370 else if (*s >= 0x10000) 1676 else if (*s >= 0x10000)
1371 *r++ = rxvt_composite.compose (*s); 1677 *r++ = rxvt_composite.compose (*s);
1372#endif 1678#endif
1373 else 1679 else
1374 *r++ = *s; 1680 *r++ = *s;
1681
1682 // the *2 above only allows wcwidth <= 2
1683 if (w > 1)
1684 *r++ = NOCHAR;
1685 }
1375 1686
1376 rxvt_pop_locale (); 1687 rxvt_pop_locale ();
1377 1688
1378 RETVAL = wcs2sv (rstr, r - rstr); 1689 RETVAL = wcs2sv (rstr, r - rstr);
1379
1380 delete [] rstr;
1381} 1690}
1382 OUTPUT: 1691 OUTPUT:
1383 RETVAL 1692 RETVAL
1384 1693
1385SV * 1694SV *
1386rxvt_term::special_decode (SV *text) 1695rxvt_term::special_decode (SV *text)
1387 CODE: 1696 CODE:
1388{ 1697{
1389 wchar_t *wstr = sv2wcs (text); 1698 wchar_t *wstr = sv2wcs (text);
1390 int wlen = wcslen (wstr);
1391 int dlen = 0; 1699 int dlen = 0;
1392 1700
1393 // find length 1701 // find length
1394 for (wchar_t *s = wstr; *s; s++) 1702 for (wchar_t *s = wstr; *s; s++)
1395 if (*s == NOCHAR) 1703 if (*s == NOCHAR)
… …
1397 else if (IS_COMPOSE (*s)) 1705 else if (IS_COMPOSE (*s))
1398 dlen += rxvt_composite.expand (*s, 0); 1706 dlen += rxvt_composite.expand (*s, 0);
1399 else 1707 else
1400 dlen++; 1708 dlen++;
1401 1709
1402 wchar_t *rstr = new wchar_t [dlen]; 1710 wchar_t *rstr = rxvt_temp_buf<wchar_t> (dlen);
1403 1711
1404 // decode 1712 // decode
1405 wchar_t *r = rstr; 1713 wchar_t *r = rstr;
1406 for (wchar_t *s = wstr; *s; s++) 1714 for (wchar_t *s = wstr; *s; s++)
1407 if (*s == NOCHAR) 1715 if (*s == NOCHAR)
… …
1410 r += rxvt_composite.expand (*s, r); 1718 r += rxvt_composite.expand (*s, r);
1411 else 1719 else
1412 *r++ = *s; 1720 *r++ = *s;
1413 1721
1414 RETVAL = wcs2sv (rstr, r - rstr); 1722 RETVAL = wcs2sv (rstr, r - rstr);
1415
1416 delete [] rstr;
1417} 1723}
1418 OUTPUT: 1724 OUTPUT:
1419 RETVAL 1725 RETVAL
1420 1726
1421void 1727void
1422rxvt_term::_resource (char *name, int index, SV *newval = 0) 1728rxvt_term::_resource (char *name, int index, SV *newval = 0)
1423 PPCODE: 1729 PPCODE:
1424{ 1730{
1425 struct resval { const char *name; int value; } rslist [] = { 1731 static const struct resval { const char *name; int value; } *rs, rslist [] = {
1426# define def(name) { # name, Rs_ ## name }, 1732# define def(name) { # name, Rs_ ## name },
1427# define reserve(name,count) 1733# define reserve(name,count)
1428# include "rsinc.h" 1734# include "rsinc.h"
1429# undef def 1735# undef def
1430# undef reserve 1736# undef reserve
1431 }; 1737 };
1432 1738
1433 struct resval *rs = rslist + sizeof (rslist) / sizeof (rslist [0]); 1739 rs = rslist + ecb_array_length (rslist);
1434 1740
1741 if (*name)
1435 do { 1742 {
1743 do {
1436 if (rs-- == rslist) 1744 if (rs-- == rslist)
1437 croak ("no such resource '%s', requested", name); 1745 croak ("no such resource '%s', requested", name);
1438 } while (strcmp (name, rs->name)); 1746 } while (strcmp (name, rs->name));
1439 1747
1440 index += rs->value; 1748 index += rs->value;
1749 }
1750 else
1751 {
1752 --rs;
1753 name = "";
1754 }
1441 1755
1442 if (!IN_RANGE_EXC (index, 0, NUM_RESOURCES)) 1756 if (!IN_RANGE_EXC (index, 0, NUM_RESOURCES))
1443 croak ("requested out-of-bound resource %s+%d,", name, index - rs->value); 1757 croak ("requested out-of-bound resource %s+%d,", name, index - rs->value);
1444 1758
1445 if (GIMME_V != G_VOID) 1759 if (GIMME_V != G_VOID)
… …
1460 1774
1461const char * 1775const char *
1462rxvt_term::x_resource (const char *name) 1776rxvt_term::x_resource (const char *name)
1463 1777
1464bool 1778bool
1465rxvt_term::option (U32 optval, int set = -1) 1779rxvt_term::option (U8 optval, int set = -1)
1466 CODE: 1780 CODE:
1467{ 1781{
1468 RETVAL = THIS->options & optval; 1782 RETVAL = THIS->option (optval);
1469 1783
1470 if (set >= 0) 1784 if (set >= 0)
1471 { 1785 {
1472 if (set)
1473 THIS->options |= optval; 1786 THIS->set_option (optval, set);
1474 else
1475 THIS->options &= ~optval;
1476 1787
1477 if (THIS->check_ev.is_active ()) // avoid doing this before START 1788 if (THIS->init_done) // avoid doing this before START
1478 switch (optval) 1789 switch (optval)
1479 { 1790 {
1480 case Opt_skipBuiltinGlyphs: 1791 case Opt_skipBuiltinGlyphs:
1481 THIS->set_fonts (); 1792 THIS->set_fonts ();
1482 THIS->scr_remap_chars (); 1793 THIS->scr_remap_chars ();
1483 THIS->scr_touch (true); 1794 THIS->scr_touch (true);
1484 THIS->want_refresh = 1; 1795 THIS->want_refresh = 1;
1796 THIS->refresh_check ();
1485 break; 1797 break;
1798#ifdef CURSOR_BLINK
1799 case Opt_cursorBlink:
1800 THIS->cursor_blink_reset ();
1801 break;
1802#endif
1486 1803
1487 case Opt_cursorUnderline: 1804 case Opt_cursorUnderline:
1488 THIS->want_refresh = 1; 1805 THIS->want_refresh = 1;
1806 THIS->refresh_check ();
1489 break; 1807 break;
1490 1808
1491# case Opt_scrollBar_floating: 1809# case Opt_scrollBar_floating:
1492# case Opt_scrollBar_right: 1810# case Opt_scrollBar_right:
1493# THIS->resize_all_windows (THIS->width, THIS->height, 1); 1811# THIS->resize_all_windows (THIS->width, THIS->height, 1);
… …
1503 CODE: 1821 CODE:
1504 RETVAL = 0 < THIS->parse_keysym (keysym, str); 1822 RETVAL = 0 < THIS->parse_keysym (keysym, str);
1505 THIS->keyboard->register_done (); 1823 THIS->keyboard->register_done ();
1506 OUTPUT: 1824 OUTPUT:
1507 RETVAL 1825 RETVAL
1826
1827void
1828rxvt_term::register_command (int keysym, unsigned int state, SV *str)
1829 CODE:
1830 wchar_t *wstr = sv2wcs (str);
1831 THIS->keyboard->register_user_translation (keysym, state, wstr);
1832 free (wstr);
1508 1833
1509void 1834void
1510rxvt_term::screen_cur (...) 1835rxvt_term::screen_cur (...)
1511 PROTOTYPE: $;$$ 1836 PROTOTYPE: $;$$
1512 ALIAS: 1837 ALIAS:
… …
1526 EXTEND (SP, 2); 1851 EXTEND (SP, 2);
1527 PUSHs (sv_2mortal (newSViv (rc.row))); 1852 PUSHs (sv_2mortal (newSViv (rc.row)));
1528 PUSHs (sv_2mortal (newSViv (rc.col))); 1853 PUSHs (sv_2mortal (newSViv (rc.col)));
1529 } 1854 }
1530 1855
1531 if (items == 3) 1856 if (items >= 3)
1532 { 1857 {
1533 rc.row = SvIV (ST (1)); 1858 rc.row = SvIV (ST (1));
1534 rc.col = SvIV (ST (2)); 1859 rc.col = SvIV (ST (2));
1535 1860
1536 if (ix == 2 && rc.col == 0) 1861 if (ix == 2)
1537 { 1862 {
1863 if (rc.col == 0)
1864 {
1865 // col == 0 means end of previous line
1538 rc.row--; 1866 rc.row--;
1539 rc.col = THIS->ncol; 1867 rc.col = THIS->ncol;
1868 }
1869 else if (IN_RANGE_EXC (rc.row, THIS->top_row, THIS->nrow)
1870 && rc.col > ROW(rc.row).l)
1871 {
1872 // col >= length means while line and add newline
1873 rc.col = THIS->ncol;
1874 }
1540 } 1875 }
1541 1876
1542 clamp_it (rc.col, 0, THIS->ncol); 1877 clamp_it (rc.col, 0, THIS->ncol);
1543 clamp_it (rc.row, THIS->top_row, THIS->nrow - 1); 1878 clamp_it (rc.row, THIS->top_row, THIS->nrow - 1);
1544 1879
1545 if (ix) 1880 if (ix)
1881 {
1882 THIS->selection.screen = THIS->current_screen;
1883
1546 THIS->want_refresh = 1; 1884 THIS->want_refresh = 1;
1885 THIS->refresh_check ();
1547 } 1886 }
1887 }
1548} 1888}
1549 1889
1550char 1890int
1551rxvt_term::cur_charset () 1891rxvt_term::selection_screen (int screen = -1)
1552 CODE: 1892 CODE:
1553 RETVAL = THIS->charsets [THIS->screen.charset]; 1893 RETVAL = THIS->selection.screen;
1554 OUTPUT: 1894 if (screen >= 0)
1895 THIS->selection.screen = screen;
1896 OUTPUT:
1555 RETVAL 1897 RETVAL
1556 1898
1557#void 1899void
1558#rxvt_term::selection_clear () 1900rxvt_term::selection_clear (bool clipboard = false)
1559 1901
1560void 1902void
1561rxvt_term::selection_make (Time eventtime, bool rect = false) 1903rxvt_term::selection_make (Time eventtime, bool rect = false)
1562 CODE: 1904 CODE:
1563 THIS->selection.op = SELECTION_CONT; 1905 THIS->selection.op = SELECTION_CONT;
1564 THIS->selection.rect = rect; 1906 THIS->selection.rect = rect;
1565 THIS->selection_make (eventtime); 1907 THIS->selection_make (eventtime);
1566 1908
1567int 1909int
1568rxvt_term::selection_grab (Time eventtime) 1910rxvt_term::selection_grab (Time eventtime, bool clipboard = false)
1569 1911
1570void 1912void
1571rxvt_term::selection (SV *newtext = 0) 1913rxvt_term::selection (SV *newtext = 0, bool clipboard = false)
1572 PPCODE: 1914 PPCODE:
1573{ 1915{
1916 wchar_t * &text = clipboard ? THIS->selection.clip_text : THIS->selection.text;
1917 unsigned int &len = clipboard ? THIS->selection.clip_len : THIS->selection.len;
1918
1574 if (GIMME_V != G_VOID) 1919 if (GIMME_V != G_VOID)
1575 XPUSHs (THIS->selection.text 1920 XPUSHs (text
1576 ? sv_2mortal (wcs2sv (THIS->selection.text, THIS->selection.len)) 1921 ? sv_2mortal (wcs2sv (text, len))
1577 : &PL_sv_undef); 1922 : &PL_sv_undef);
1578 1923
1579 if (newtext) 1924 if (newtext)
1580 { 1925 {
1581 free (THIS->selection.text); 1926 free (text);
1582 1927
1583 THIS->selection.text = sv2wcs (newtext); 1928 text = sv2wcs (newtext);
1584 THIS->selection.len = wcslen (THIS->selection.text); 1929 len = wcslen (text);
1585 } 1930 }
1586} 1931}
1932
1933char
1934rxvt_term::cur_charset ()
1935 CODE:
1936 RETVAL = THIS->charsets [THIS->screen.charset];
1937 OUTPUT:
1938 RETVAL
1587 1939
1588void 1940void
1589rxvt_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) 1941rxvt_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)
1590 1942
1591void 1943void
1592rxvt_term::scr_xor_span (int beg_row, int beg_col, int end_row, int end_col, U32 rstyle = RS_RVid) 1944rxvt_term::scr_xor_span (int beg_row, int beg_col, int end_row, int end_col, U32 rstyle = RS_RVid)
1593 1945
1594void 1946void
1595rxvt_term::scr_bell () 1947rxvt_term::scr_bell ()
1948
1949void
1950rxvt_term::scr_recolour (bool refresh = true);
1596 1951
1597void 1952void
1598rxvt_term::scr_change_screen (int screen) 1953rxvt_term::scr_change_screen (int screen)
1599 1954
1600void 1955void
… …
1613 char *str = SvPVbyte (octets, len); 1968 char *str = SvPVbyte (octets, len);
1614 C_ARGS: 1969 C_ARGS:
1615 str, len 1970 str, len
1616 1971
1617void 1972void
1973rxvt_term::tt_paste (SV *octets)
1974 INIT:
1975 STRLEN len;
1976 char *str = SvPVbyte (octets, len);
1977 C_ARGS:
1978 str, len
1979
1980void
1618rxvt_term::cmd_parse (SV *octets) 1981rxvt_term::cmd_parse (SV *octets)
1619 CODE: 1982 CODE:
1620{ 1983{
1621 STRLEN len; 1984 STRLEN len;
1622 char *str = SvPVbyte (octets, len); 1985 char *str = SvPVbyte (octets, len);
… …
1653void 2016void
1654rxvt_term::XListProperties (Window window) 2017rxvt_term::XListProperties (Window window)
1655 PPCODE: 2018 PPCODE:
1656{ 2019{
1657 int count; 2020 int count;
1658 Atom *props = XListProperties (THIS->display->display, window, &count); 2021 Atom *props = XListProperties (THIS->dpy, window, &count);
1659 2022
1660 EXTEND (SP, count); 2023 EXTEND (SP, count);
1661 while (count--) 2024 while (count--)
1662 PUSHs (newSVuv ((U32)props [count])); 2025 PUSHs (newSVuv ((U32)props [count]));
1663 2026
1664 XFree (props); 2027 XFree (props);
1665} 2028}
1666 2029
1667void 2030void
1668rxvt_term::XGetWindowProperty (Window window, Atom property) 2031rxvt_term::XGetWindowProperty (Window window, Atom property)
… …
1672 int format; 2035 int format;
1673 unsigned long nitems; 2036 unsigned long nitems;
1674 unsigned long bytes_after; 2037 unsigned long bytes_after;
1675 unsigned char *prop; 2038 unsigned char *prop;
1676 2039
1677 XGetWindowProperty (THIS->display->display, window, property, 2040 XGetWindowProperty (THIS->dpy, window, property,
1678 0, 1<<24, 0, AnyPropertyType, 2041 0, 1<<24, 0, AnyPropertyType,
1679 &type, &format, &nitems, &bytes_after, &prop); 2042 &type, &format, &nitems, &bytes_after, &prop);
1680 2043
1681 if (type != None) 2044 if (type != None)
1682 { 2045 {
… …
1691 XFree (prop); 2054 XFree (prop);
1692 } 2055 }
1693} 2056}
1694 2057
1695void 2058void
1696rxvt_term::XChangeWindowProperty (Window window, Atom property, Atom type, int format, SV *data) 2059rxvt_term::XChangeProperty (Window window, Atom property, Atom type, int format, SV *data)
1697 CODE: 2060 CODE:
1698{ 2061{
1699 STRLEN len; 2062 STRLEN len;
1700 char *data_ = SvPVbyte (data, len); 2063 char *data_ = SvPVbyte (data, len);
1701 2064
1702 int elemsize = format == 16 ? sizeof (short) 2065 int elemsize = format == 16 ? sizeof (short)
1703 : format == 32 ? sizeof (long) 2066 : format == 32 ? sizeof (long)
1704 : 1; 2067 : 1;
1705 2068
1706 XChangeProperty (THIS->display->display, window, property, 2069 XChangeProperty (THIS->dpy, window, property,
1707 type, format, PropModeReplace, 2070 type, format, PropModeReplace,
1708 (unsigned char *)data_, len / elemsize); 2071 (unsigned char *)data_, len / elemsize);
1709 XSync (THIS->display->display, 0);
1710} 2072}
1711 2073
1712Atom 2074Atom
1713XInternAtom (rxvt_term *term, char *atom_name, int only_if_exists = FALSE) 2075XInternAtom (rxvt_term *term, octet_string atom_name, int only_if_exists = FALSE)
1714 C_ARGS: term->display->display, atom_name, only_if_exists 2076 C_ARGS: term->dpy, atom_name, only_if_exists
1715 2077
1716char * 2078char *
1717XGetAtomName (rxvt_term *term, Atom atom) 2079XGetAtomName (rxvt_term *term, Atom atom)
1718 C_ARGS: term->display->display, atom 2080 C_ARGS: term->dpy, atom
1719 CLEANUP: 2081 CLEANUP:
1720 XFree (RETVAL); 2082 XFree (RETVAL);
1721 2083
1722void 2084void
1723XDeleteProperty (rxvt_term *term, Window window, Atom property) 2085XDeleteProperty (rxvt_term *term, Window window, Atom property)
1724 C_ARGS: term->display->display, window, property 2086 C_ARGS: term->dpy, window, property
1725 2087
1726Window 2088Window
1727rxvt_term::DefaultRootWindow () 2089rxvt_term::DefaultRootWindow ()
1728 CODE: 2090 CODE:
1729 RETVAL = THIS->display->root; 2091 RETVAL = THIS->display->root;
… …
1732 2094
1733#if 0 2095#if 0
1734 2096
1735Window 2097Window
1736XCreateSimpleWindow (rxvt_term *term, Window parent, int x, int y, unsigned int width, unsigned int height) 2098XCreateSimpleWindow (rxvt_term *term, Window parent, int x, int y, unsigned int width, unsigned int height)
1737 C_ARGS: term->display->display, (Window)parent, 2099 C_ARGS: term->dpy, (Window)parent,
1738 x, y, width, height, 0, 2100 x, y, width, height, 0,
1739 term->pix_colors_focused[Color_border], 2101 term->pix_colors_focused[Color_border],
1740 term->pix_colors_focused[Color_border] 2102 term->pix_colors_focused[Color_border]
1741 2103
1742#endif 2104#endif
1743 2105
1744void 2106void
1745XReparentWindow (rxvt_term *term, Window window, Window parent, int x = 0, int y = 0) 2107XReparentWindow (rxvt_term *term, Window window, Window parent, int x = 0, int y = 0)
1746 C_ARGS: term->display->display, window, parent, x, y 2108 C_ARGS: term->dpy, window, parent, x, y
1747 2109
1748void 2110void
1749XMapWindow (rxvt_term *term, Window window) 2111XMapWindow (rxvt_term *term, Window window)
1750 C_ARGS: term->display->display, window 2112 C_ARGS: term->dpy, window
1751 2113
1752void 2114void
1753XUnmapWindow (rxvt_term *term, Window window) 2115XUnmapWindow (rxvt_term *term, Window window)
1754 C_ARGS: term->display->display, window 2116 C_ARGS: term->dpy, window
1755 2117
1756void 2118void
1757XMoveResizeWindow (rxvt_term *term, Window window, int x, int y, unsigned int width, unsigned int height) 2119XMoveResizeWindow (rxvt_term *term, Window window, int x, int y, unsigned int width, unsigned int height)
1758 C_ARGS: term->display->display, window, x, y, width, height 2120 C_ARGS: term->dpy, window, x, y, width, height
1759 2121
1760void 2122void
1761rxvt_term::XChangeInput (Window window, U32 add_events, U32 del_events = 0) 2123rxvt_term::XChangeInput (Window window, U32 add_events, U32 del_events = 0)
1762 CODE: 2124 CODE:
1763{ 2125{
1764 XWindowAttributes attr; 2126 XWindowAttributes attr;
1765 XGetWindowAttributes (THIS->display->display, window, &attr); 2127 XGetWindowAttributes (THIS->dpy, window, &attr);
1766 XSelectInput (THIS->display->display, window, attr.your_event_mask | add_events & ~del_events); 2128 XSelectInput (THIS->dpy, window, attr.your_event_mask | add_events & ~del_events);
1767} 2129}
1768 2130
1769void 2131void
1770rxvt_term::XTranslateCoordinates (Window src, Window dst, int x, int y) 2132rxvt_term::XTranslateCoordinates (Window src, Window dst, int x, int y)
1771 PPCODE: 2133 PPCODE:
1772{ 2134{
1773 int dx, dy; 2135 int dx, dy;
1774 Window child; 2136 Window child;
1775 2137
1776 if (XTranslateCoordinates (THIS->display->display, src, dst, x, y, &dx, &dy, &child)) 2138 if (XTranslateCoordinates (THIS->dpy, src, dst, x, y, &dx, &dy, &child))
1777 { 2139 {
1778 EXTEND (SP, 3); 2140 EXTEND (SP, 3);
1779 PUSHs (newSViv (dx)); 2141 PUSHs (newSViv (dx));
1780 PUSHs (newSViv (dy)); 2142 PUSHs (newSViv (dy));
1781 PUSHs (newSVuv (child)); 2143 PUSHs (newSVuv (child));
1782 } 2144 }
1783} 2145}
1784 2146
1785############################################################################# 2147#############################################################################
2148# fancy bg bloatstuff (TODO: should be moved up somewhere)
2149
2150bool
2151rxvt_term::has_render ()
2152 CODE:
2153 RETVAL = THIS->display->flags & DISPLAY_HAS_RENDER;
2154 OUTPUT:
2155 RETVAL
2156
2157void
2158rxvt_term::background_geometry (bool border = false)
2159 PPCODE:
2160 EXTEND (SP, 4);
2161 PUSHs (sv_2mortal (newSViv (THIS->parent_x + (border ? THIS->window_vt_x : 0))));
2162 PUSHs (sv_2mortal (newSViv (THIS->parent_y + (border ? THIS->window_vt_y : 0))));
2163 PUSHs (sv_2mortal (newSViv (border ? THIS->vt_width : THIS->szHint.width )));
2164 PUSHs (sv_2mortal (newSViv (border ? THIS->vt_height : THIS->szHint.height)));
2165
2166#if HAVE_IMG
2167
2168rxvt_img *
2169rxvt_term::new_img (SV *format = &PL_sv_undef, int x = 0, int y = 0, int width = 1, int height = 1)
2170 CODE:
2171 XRenderPictFormat *f = SvOK (format)
2172 ? XRenderFindStandardFormat (THIS->dpy, SvIV (format))
2173 : XRenderFindVisualFormat (THIS->dpy, THIS->visual);
2174 RETVAL = new rxvt_img (THIS, f, x, y, width, height);
2175 RETVAL->alloc ();
2176 OUTPUT:
2177 RETVAL
2178
2179#if ENABLE_TRANSPARENCY
2180
2181rxvt_img *
2182rxvt_term::new_img_from_root ()
2183 CODE:
2184 RETVAL = rxvt_img::new_from_root (THIS);
2185 OUTPUT:
2186 RETVAL
2187
2188#endif
2189
2190#if HAVE_PIXBUF
2191
2192rxvt_img *
2193rxvt_term::new_img_from_file (octet_string filename)
2194 CODE:
2195 try
2196 {
2197 RETVAL = rxvt_img::new_from_file (THIS, filename);
2198 }
2199 catch (const class rxvt_failure_exception &e)
2200 {
2201 croak ("new_img_from_file failed");
2202 }
2203 OUTPUT:
2204 RETVAL
2205
2206#endif
2207
2208#if HAVE_BG_PIXMAP
2209
2210void
2211rxvt_term::set_background (rxvt_img *img, bool border = false)
2212 CODE:
2213 THIS->bg_destroy ();
2214 THIS->bg_flags &= ~(rxvt_term::BG_NEEDS_REFRESH | rxvt_term::BG_INHIBIT_RENDER | rxvt_term::BG_IS_TRANSPARENT);
2215
2216 if (img) // TODO: cannot be false
2217 {
2218 img = img->clone (); // own the img
2219
2220 if (img->repeat != RepeatNormal) // X11 only supports RepeatNormal as bg pixmap
2221 img->sub_rect (0, 0,
2222 border ? THIS->vt_width : THIS->szHint.width,
2223 border ? THIS->vt_height : THIS->szHint.height)
2224 ->replace (img);
2225
2226 // just in case, should usually be a nop
2227 img->reify ()
2228 ->replace (img);
2229
2230 img->convert_format (XRenderFindVisualFormat (THIS->dpy, THIS->visual), THIS->pix_colors [Color_bg])
2231 ->replace (img);
2232
2233 THIS->bg_img = img;
2234 THIS->bg_flags |= rxvt_term::BG_NEEDS_REFRESH | rxvt_term::BG_INHIBIT_RENDER;
2235
2236 if (!border)
2237 THIS->bg_flags |= rxvt_term::BG_IS_TRANSPARENT;
2238 }
2239
2240#endif
2241
2242#endif
2243
2244#############################################################################
1786# urxvt::overlay 2245# urxvt::overlay
1787############################################################################# 2246#############################################################################
1788 2247
1789MODULE = urxvt PACKAGE = urxvt::overlay 2248MODULE = urxvt PACKAGE = urxvt::overlay
1790 2249
… …
1798overlay::hide () 2257overlay::hide ()
1799 2258
1800void 2259void
1801overlay::DESTROY () 2260overlay::DESTROY ()
1802 2261
1803############################################################################# 2262INCLUDE: $PERL <iom_perl.xs -pe s/IOM_MODULE/urxvt/g,s/IOM_CLASS/urxvt/g |
1804# urxvt::watcher
1805#############################################################################
1806 2263
1807MODULE = urxvt PACKAGE = urxvt::watcher
1808
1809CHAINED
1810perl_watcher::cb (SV *cb)
1811 CODE:
1812 THIS->cb (cb);
1813 OUTPUT:
1814 RETVAL
1815
1816#############################################################################
1817# urxvt::timer
1818#############################################################################
1819
1820MODULE = urxvt PACKAGE = urxvt::timer
1821
1822SV *
1823timer::new ()
1824 CODE:
1825 timer *w = new timer;
1826 w->start (NOW);
1827 RETVAL = newSVptr ((void *)(perl_watcher *)w, "urxvt::timer");
1828 w->self = (HV *)SvRV (RETVAL);
1829 OUTPUT:
1830 RETVAL
1831
1832NV
1833timer::at ()
1834 CODE:
1835 RETVAL = THIS->at;
1836 OUTPUT:
1837 RETVAL
1838
1839CHAINED
1840timer::interval (NV interval)
1841 CODE:
1842 THIS->interval = interval;
1843 OUTPUT:
1844 RETVAL
1845
1846CHAINED
1847timer::set (NV tstamp)
1848 CODE:
1849 THIS->set (tstamp);
1850 OUTPUT:
1851 RETVAL
1852
1853CHAINED
1854timer::start (NV tstamp = THIS->at)
1855 CODE:
1856 THIS->start (tstamp);
1857 OUTPUT:
1858 RETVAL
1859
1860CHAINED
1861timer::after (NV delay)
1862 CODE:
1863 THIS->start (NOW + delay);
1864 OUTPUT:
1865 RETVAL
1866
1867CHAINED
1868timer::stop ()
1869 CODE:
1870 THIS->stop ();
1871 OUTPUT:
1872 RETVAL
1873
1874void
1875timer::DESTROY ()
1876
1877#############################################################################
1878# urxvt::iow
1879#############################################################################
1880
1881MODULE = urxvt PACKAGE = urxvt::iow 2264MODULE = urxvt PACKAGE = urxvt::pixbuf PREFIX = gdk_pixbuf_
1882 2265
1883SV * 2266#if HAVE_PIXBUF
1884iow::new ()
1885 CODE:
1886 iow *w = new iow;
1887 RETVAL = newSVptr ((void *)(perl_watcher *)w, "urxvt::iow");
1888 w->self = (HV *)SvRV (RETVAL);
1889 OUTPUT:
1890 RETVAL
1891 2267
1892CHAINED 2268urxvt::pixbuf gdk_pixbuf_new_from_file (SV *klass, octet_string filename)
1893iow::fd (int fd) 2269 C_ARGS: filename, 0
1894 CODE:
1895 THIS->fd = fd;
1896 OUTPUT:
1897 RETVAL
1898 2270
1899CHAINED
1900iow::events (short events)
1901 CODE:
1902 THIS->events = events;
1903 OUTPUT:
1904 RETVAL
1905
1906CHAINED
1907iow::start ()
1908 CODE:
1909 THIS->start ();
1910 OUTPUT:
1911 RETVAL
1912
1913CHAINED
1914iow::stop ()
1915 CODE:
1916 THIS->stop ();
1917 OUTPUT:
1918 RETVAL
1919
1920void 2271void
1921iow::DESTROY () 2272DESTROY (urxvt::pixbuf self)
2273 CODE:
2274 g_object_unref (self);
1922 2275
1923############################################################################# 2276#endif
1924# urxvt::iw
1925#############################################################################
1926 2277
1927MODULE = urxvt PACKAGE = urxvt::iw 2278MODULE = urxvt PACKAGE = urxvt::img
1928 2279
1929SV * 2280#if HAVE_IMG
1930iw::new () 2281
2282# rxvt_img *new (rxvt_screen *screen, XRenderPictFormat *format, int width, int height)
2283# rxvt_img *rxvt_img (rxvt_screen *screen, XRenderPictFormat *format, int width, int height, Pixmap pixmap);
2284
2285void
2286rxvt_img::geometry ()
1931 CODE: 2287 PPCODE:
1932 iw *w = new iw; 2288 EXTEND (SP, 4);
1933 RETVAL = newSVptr ((void *)(perl_watcher *)w, "urxvt::iw"); 2289 PUSHs (sv_2mortal (newSViv (THIS->x)));
1934 w->self = (HV *)SvRV (RETVAL); 2290 PUSHs (sv_2mortal (newSViv (THIS->y)));
1935 OUTPUT: 2291 PUSHs (sv_2mortal (newSViv (THIS->w)));
1936 RETVAL 2292 PUSHs (sv_2mortal (newSViv (THIS->h)));
1937 2293
1938CHAINED 2294int
1939iw::start () 2295rxvt_img::x ()
2296 ALIAS:
2297 x = 0
2298 y = 1
2299 w = 2
2300 h = 3
2301 CODE:
2302 switch (ix)
2303 {
2304 case 0: RETVAL = THIS->x; break;
2305 case 1: RETVAL = THIS->y; break;
2306 case 2: RETVAL = THIS->w; break;
2307 case 3: RETVAL = THIS->h; break;
2308 }
2309 OUTPUT:
2310 RETVAL
2311
2312Pixmap
2313rxvt_img::pm ()
2314 CODE:
2315 RETVAL = THIS->pm;
2316 OUTPUT:
2317 RETVAL
2318
2319void
2320rxvt_img::fill (SV *c, int x = 0, int y = 0, int w = THIS->w, int h = THIS->h)
2321 PROTOTYPE: $;$$$$
2322 INIT:
2323 rgba cc = parse_rgba (c, THIS->s);
2324 C_ARGS: cc, x, y, w, h
2325
2326void
2327rxvt_img::DESTROY ()
2328 CODE:
2329 delete THIS;
2330
2331void
2332rxvt_img::add_alpha ()
2333
2334void
2335rxvt_img::unshare ()
2336
2337void
2338rxvt_img::repeat_mode (render_repeat_mode repeat = 0)
1940 CODE: 2339 PPCODE:
1941 THIS->start (); 2340 if (items >= 2)
1942 OUTPUT: 2341 THIS->repeat_mode (repeat);
1943 RETVAL 2342 if (GIMME_V != G_VOID)
2343 XPUSHs (sv_2mortal (newSViv (THIS->repeat)));
1944 2344
1945CHAINED
1946iw::stop ()
1947 CODE:
1948 THIS->stop ();
1949 OUTPUT:
1950 RETVAL
1951
1952void 2345void
1953iw::DESTROY () 2346rxvt_img::move (int dx, int dy)
1954 2347
1955#############################################################################
1956# urxvt::pw
1957#############################################################################
1958
1959MODULE = urxvt PACKAGE = urxvt::pw
1960
1961SV *
1962pw::new ()
1963 CODE:
1964 pw *w = new pw;
1965 RETVAL = newSVptr ((void *)(perl_watcher *)w, "urxvt::pw");
1966 w->self = (HV *)SvRV (RETVAL);
1967 OUTPUT:
1968 RETVAL
1969
1970CHAINED
1971pw::start (int pid)
1972 CODE:
1973 THIS->start (pid);
1974 OUTPUT:
1975 RETVAL
1976
1977CHAINED
1978pw::stop ()
1979 CODE:
1980 THIS->stop ();
1981 OUTPUT:
1982 RETVAL
1983
1984void 2348void
1985pw::DESTROY () 2349rxvt_img::brightness (rxvt_img::nv r, rxvt_img::nv g, rxvt_img::nv b, rxvt_img::nv a = 1.)
1986 2350
2351void
2352rxvt_img::contrast (rxvt_img::nv r, rxvt_img::nv g, rxvt_img::nv b, rxvt_img::nv a = 1.)
1987 2353
2354void
2355rxvt_img::draw (rxvt_img *img, int op = PictOpOver, rxvt_img::nv mask = 1.);
2356
2357rxvt_img *
2358rxvt_img::clone ()
2359
2360rxvt_img *
2361rxvt_img::reify ()
2362
2363rxvt_img *
2364rxvt_img::sub_rect (int x, int y, int width, int height)
2365
2366rxvt_img *
2367rxvt_img::blur (int rh, int rv)
2368
2369rxvt_img *
2370rxvt_img::muladd (rxvt_img::nv mul, rxvt_img::nv add)
2371
2372rxvt_img *
2373rxvt_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)
2374 INIT:
2375 rxvt_img::nv matrix[3][3] = {
2376 { p11, p12, p13 },
2377 { p21, p22, p23 },
2378 { p31, p32, p33 }
2379 };
2380 C_ARGS: matrix
2381
2382rxvt_img *
2383rxvt_img::scale (int new_width, int new_height)
2384
2385rxvt_img *
2386rxvt_img::rotate (int x, int y, rxvt_img::nv phi)
2387
2388rxvt_img *
2389rxvt_img::tint (SV *c)
2390 INIT:
2391 rgba cc = parse_rgba (c, THIS->s);
2392 C_ARGS: cc
2393
2394rxvt_img *
2395rxvt_img::filter (octet_string name, SV *params = &PL_sv_undef)
2396 CODE:
2397 rxvt_img::nv *vparams = 0;
2398 int nparams = 0;
2399
2400 if (SvOK (params))
2401 {
2402 // we overlay rxvt_temp_buf, what a hack
2403 assert (sizeof (rxvt_img::nv) >= sizeof (int));
2404
2405 if (!SvROK (params) || SvTYPE (SvRV (params)) != SVt_PVAV)
2406 croak ("rxvt_img::filter: params must be an array reference with parameter values");
2407
2408 nparams = av_len ((AV *)SvRV (params)) + 1;
2409 vparams = rxvt_temp_buf<rxvt_img::nv> (nparams);
2410
2411 for (int i = 0; i < nparams; ++i)
2412 vparams [i] = SvNV (*av_fetch ((AV *)SvRV (params), i, 1));
2413 }
2414
2415 RETVAL = THIS->filter (name, nparams, vparams);
2416 OUTPUT:
2417 RETVAL
2418
2419#endif
2420

Diff Legend

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