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.33 by root, Fri Jan 6 20:50:58 2006 UTC vs.
Revision 1.215 by sf-exg, Sat Apr 13 09:10:21 2013 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
32#include <stddef.h>
31#include <cstdarg> 33#include <stdarg.h>
32 34
35#include "unistd.h"
36
37#include "ev_cpp.h"
33#include "rxvt.h" 38#include "rxvt.h"
34#include "iom.h" 39#include "keyboard.h"
35#include "rxvtutil.h" 40#include "rxvtutil.h"
36#include "rxvtperl.h" 41#include "rxvtperl.h"
37 42
38#include "perlxsi.c" 43#include "perlxsi.c"
44
45#define GRAB_CURSOR THIS->scrollBar.leftptr_cursor
39 46
40#undef LINENO 47#undef LINENO
41#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)
42#undef ROW 49#undef ROW
43#define ROW(n) THIS->row_buf [LINENO (n)] 50#define ROW(n) THIS->row_buf [LINENO (n)]
44 51
45///////////////////////////////////////////////////////////////////////////// 52/////////////////////////////////////////////////////////////////////////////
46 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
112
47static wchar_t * 113static wchar_t *
48sv2wcs (SV *sv) 114sv2wcs (SV *sv)
49{ 115{
50 STRLEN len; 116 STRLEN len;
51 char *str = SvPVutf8 (sv, len); 117 char *str = SvPVutf8 (sv, len);
… …
63 129
64 return sv; 130 return sv;
65} 131}
66 132
67static SV * 133static SV *
68new_ref (HV *hv, const char *klass)
69{
70 return sv_bless (newRV ((SV *)hv), gv_stashpv (klass, 1));
71}
72
73//TODO: use magic
74static SV *
75newSVptr (void *ptr, const char *klass) 134newSVptr (void *ptr, const char *klass)
76{ 135{
77 HV *hv = newHV (); 136 HV *hv = newHV ();
78 sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0); 137 sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);
79 return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1)); 138 return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
… …
101 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);
102 161
103 return (long)mg->mg_ptr; 162 return (long)mg->mg_ptr;
104} 163}
105 164
106#define newSVterm(term) SvREFCNT_inc ((SV *)term->self) 165#define newSVterm(term) SvREFCNT_inc ((SV *)(term)->perl.self)
107#define SvTERM(sv) (rxvt_term *)SvPTR (sv, "urxvt::term") 166#define SvTERM(sv) (rxvt_term *)SvPTR ((sv), "urxvt::term")
108 167
109///////////////////////////////////////////////////////////////////////////// 168/////////////////////////////////////////////////////////////////////////////
110 169
111struct perl_watcher 170#define SvOVERLAY(sv) (overlay *)SvPTR (sv, "urxvt::overlay")
171
172class overlay : overlay_base
112{ 173{
113 SV *cbsv; 174 rxvt_term *THIS;
175 AV *overlay_av;
176 int border;
177
178public:
114 HV *self; 179 HV *self;
115
116 perl_watcher ()
117 : cbsv (newSV (0))
118 {
119 }
120
121 ~perl_watcher ()
122 {
123 SvREFCNT_dec (cbsv);
124 }
125
126 void cb (SV *cb)
127 {
128 sv_setsv (cbsv, cb);
129 }
130
131 void invoke (const char *type, SV *self, int arg = -1);
132};
133
134void
135perl_watcher::invoke (const char *type, SV *self, int arg)
136{
137 dSP;
138
139 ENTER;
140 SAVETMPS;
141
142 PUSHMARK (SP);
143
144 XPUSHs (sv_2mortal (self));
145
146 if (arg >= 0)
147 XPUSHs (sv_2mortal (newSViv (arg)));
148
149 PUTBACK;
150 call_sv (cbsv, G_VOID | G_EVAL | G_DISCARD);
151 SPAGAIN;
152
153 PUTBACK;
154 FREETMPS;
155 LEAVE;
156
157 if (SvTRUE (ERRSV))
158 rxvt_warn ("%s callback evaluation error: %s", type, SvPV_nolen (ERRSV));
159}
160
161#define newSVtimer(timer) new_ref (timer->self, "urxvt::timer")
162#define SvTIMER(sv) (timer *)SvPTR (sv, "urxvt::timer")
163
164struct timer : time_watcher, perl_watcher
165{
166 tstamp interval;
167
168 timer ()
169 : time_watcher (this, &timer::execute)
170 {
171 }
172
173 void execute (time_watcher &w)
174 {
175 if (interval)
176 start (at + interval);
177
178 invoke ("urxvt::timer", newSVtimer (this));
179 }
180};
181
182#define newSViow(iow) new_ref (iow->self, "urxvt::iow")
183#define SvIOW(sv) (iow *)SvPTR (sv, "urxvt::iow")
184
185struct iow : io_watcher, perl_watcher
186{
187 iow ()
188 : io_watcher (this, &iow::execute)
189 {
190 }
191
192 void execute (io_watcher &w, short revents)
193 {
194 invoke ("urxvt::iow", newSViow (this), revents);
195 }
196};
197
198/////////////////////////////////////////////////////////////////////////////
199
200#define SvOVERLAY(sv) (overlay *)SvPTR (sv, "urxvt::overlay")
201
202struct overlay {
203 HV *self;
204 rxvt_term *THIS;
205 int x, y, w, h;
206 int border;
207 text_t **text;
208 rend_t **rend;
209 180
210 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);
211 ~overlay (); 182 ~overlay ();
212 183
213 void show (); 184 void show ();
… …
217 188
218 void set (int x, int y, SV *str, SV *rend); 189 void set (int x, int y, SV *str, SV *rend);
219}; 190};
220 191
221overlay::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)
222: THIS(THIS), x(x_), y(y_), w(w_), h(h_), border(border == 2) 193: THIS(THIS), border(border == 2), overlay_av (0)
223{ 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
224 if (border == 2) 203 if (border == 2)
225 { 204 {
226 w += 2; 205 w += 2;
227 h += 2; 206 h += 2;
228 } 207 }
… …
266 *rp++ = r; 245 *rp++ = r;
267 } 246 }
268 } 247 }
269 248
270 show (); 249 show ();
271 THIS->want_refresh = 1;
272} 250}
273 251
274overlay::~overlay () 252overlay::~overlay ()
275{ 253{
276 hide (); 254 hide ();
… …
281 delete [] rend[y]; 259 delete [] rend[y];
282 } 260 }
283 261
284 delete [] text; 262 delete [] text;
285 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));
286 276
287 THIS->want_refresh = 1; 277 THIS->want_refresh = 1;
288} 278 THIS->refresh_check ();
289
290void
291overlay::show ()
292{
293 char key[33]; sprintf (key, "%32lx", (long)this);
294
295 HV *hv = (HV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)THIS->self), "_overlay", 8, 0));
296 hv_store (hv, key, 32, newSViv ((long)this), 0);
297} 279}
298 280
299void 281void
300overlay::hide () 282overlay::hide ()
301{ 283{
302 SV **ovs = hv_fetch ((HV *)SvRV ((SV *)THIS->self), "_overlay", 8, 0); 284 if (!overlay_av)
285 return;
303 286
304 if (ovs) 287 int i;
305 {
306 char key[33]; sprintf (key, "%32lx", (long)this);
307 288
308 HV *hv = (HV *)SvRV (*ovs); 289 for (i = AvFILL (overlay_av); i >= 0; i--)
309 hv_delete (hv, key, 32, G_DISCARD); 290 if (SvIV (*av_fetch (overlay_av, i, 1)) == (long)this)
310 } 291 break;
292
293 for (; i < AvFILL (overlay_av); i++)
294 av_store (overlay_av, i, SvREFCNT_inc (*av_fetch (overlay_av, i + 1, 0)));
295
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 ();
311} 303}
312 304
313void overlay::swap () 305void overlay::swap ()
314{ 306{
315 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));
316 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));
317 309
318 int ov_w = min (w, THIS->ncol - ov_x); 310 int ov_w = min (w, THIS->ncol - ov_x);
319 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;
320 317
321 for (int y = ov_h; y--; ) 318 for (int y = ov_h; y--; )
322 { 319 {
323 text_t *t1 = text [y]; 320 text_t *t1 = text [y];
324 rend_t *r1 = rend [y]; 321 rend_t *r1 = rend [y];
325 322
326 text_t *t2 = ROW(y + ov_y - THIS->view_start).t + ov_x; 323 text_t *t2 = ROW(y + ov_y + THIS->view_start).t + ov_x;
327 rend_t *r2 = ROW(y + ov_y - THIS->view_start).r + ov_x; 324 rend_t *r2 = ROW(y + ov_y + THIS->view_start).r + ov_x;
328 325
329 for (int x = ov_w; x--; ) 326 for (int x = ov_w; x--; )
330 { 327 {
331 text_t t = *t1; *t1++ = *t2; *t2++ = t; 328 text_t t = *t1; *t1++ = *t2; *t2++ = t;
332 rend_t r = *r1; *r1++ = *r2; *r2++ = SET_FONT (r, THIS->fontset [GET_STYLE (r)]->find_font (t)); 329 rend_t r = *r1; *r1++ = *r2; *r2++ = SET_FONT (r, THIS->fontset [GET_STYLE (r)]->find_font (t));
… …
355 if (!SvROK (rend) || SvTYPE (SvRV (rend)) != SVt_PVAV) 352 if (!SvROK (rend) || SvTYPE (SvRV (rend)) != SVt_PVAV)
356 croak ("rend must be arrayref"); 353 croak ("rend must be arrayref");
357 354
358 AV *av = (AV *)SvRV (rend); 355 AV *av = (AV *)SvRV (rend);
359 356
360 for (int col = min (av_len (av) + 1, w - x - border); col--; ) 357 for (int col = min (AvFILL (av) + 1, w - x - border); col--; )
361 this->rend [y][x + col] = SvIV (*av_fetch (av, col, 1)); 358 this->rend [y][x + col] = SvIV (*av_fetch (av, col, 1));
362 } 359 }
363 360
364 THIS->want_refresh = 1; 361 THIS->want_refresh = 1;
362 THIS->refresh_check ();
365} 363}
366
367 364
368///////////////////////////////////////////////////////////////////////////// 365/////////////////////////////////////////////////////////////////////////////
369 366
367#include "iom_perl.h"
368
369/////////////////////////////////////////////////////////////////////////////
370
370struct rxvt_perl_interp rxvt_perl; 371struct rxvt_perl_interp rxvt_perl;
371 372
372static PerlInterpreter *perl; 373static PerlInterpreter *perl;
373
374rxvt_perl_interp::rxvt_perl_interp ()
375{
376}
377 374
378rxvt_perl_interp::~rxvt_perl_interp () 375rxvt_perl_interp::~rxvt_perl_interp ()
379{ 376{
380 if (perl) 377 if (perl)
381 { 378 {
382 perl_destruct (perl); 379 perl_destruct (perl);
383 perl_free (perl); 380 perl_free (perl);
381 PERL_SYS_TERM ();
384 } 382 }
385} 383}
386 384
387void 385void
388rxvt_perl_interp::init () 386rxvt_perl_interp::init ()
389{ 387{
390 if (!perl) 388 if (!perl)
391 { 389 {
390 rxvt_push_locale (""); // perl init destroys current locale
391
392 {
393 perl_environ = rxvt_environ;
394 localise_env set_environ (perl_environ);
395
392 char *argv[] = { 396 char *args[] = {
393 "", 397 "",
394 "-edo '" LIBDIR "/urxvt.pm' or ($@ and die $@) or exit 1", 398 "-e"
399 "BEGIN {"
400 " urxvt->bootstrap;"
401 " unshift @INC, '" LIBDIR "';"
402 "}"
403 ""
404 "use urxvt;"
395 }; 405 };
406 int argc = ecb_array_length (args);
407 char **argv = args;
396 408
409 PERL_SYS_INIT3 (&argc, &argv, &environ);
397 perl = perl_alloc (); 410 perl = perl_alloc ();
398 perl_construct (perl); 411 perl_construct (perl);
399 412
400 if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) 413 if (perl_parse (perl, xs_init, argc, argv, (char **)NULL)
401 || perl_run (perl)) 414 || perl_run (perl))
415 {
416 rxvt_warn ("unable to initialize perl-interpreter, continuing without.\n");
417
418 perl_destruct (perl);
419 perl_free (perl);
420 perl = 0;
421 }
422 }
423
424 rxvt_pop_locale ();
425 }
426}
427
428void
429rxvt_perl_interp::init (rxvt_term *term)
430{
431 init ();
432
433 if (perl && !term->perl.self)
434 {
435 // runs outside of perls ENV
436 term->perl.self = (void *)newSVptr ((void *)term, "urxvt::term");
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);
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;
495}
496
497static void
498ungrab (rxvt_term *THIS)
499{
500 if (THIS->perl.grabtime)
501 {
502 XUngrabKeyboard (THIS->dpy, THIS->perl.grabtime);
503 XUngrabPointer (THIS->dpy, THIS->perl.grabtime);
504 THIS->perl.grabtime = 0;
505 }
506}
507
508bool
509rxvt_perl_interp::invoke (rxvt_term *term, hook_type htype, ...)
510{
511 if (!perl || !term->perl.self)
512 return false;
513
514 localise_env set_environ (perl_environ);
515
516 // pre-handling of some events
517 if (htype == HOOK_REFRESH_END)
518 {
519 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, 0));
520
521 for (int i = 0; i <= AvFILL (av); i++)
522 ((overlay *)SvIV (*av_fetch (av, i, 0)))->swap ();
523 }
524 else if (htype == HOOK_DESTROY)
525 {
526 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_selection", 10, 0));
527
528 for (int i = AvFILL (av); i >= 0; i--)
402 { 529 {
403 rxvt_warn ("unable to initialize perl-interpreter, continuing without.\n"); 530 rxvt_selection *req = (rxvt_selection *)SvIV (*av_fetch (av, i, 0));
404 531 delete req;
405 perl_destruct (perl);
406 perl_free (perl);
407 perl = 0;
408 } 532 }
409 } 533 }
410}
411 534
412bool 535 bool event_consumed;
413rxvt_perl_interp::invoke (rxvt_term *term, hook_type htype, ...)
414{
415 if (!perl)
416 return false;
417 536
418 if (htype == HOOK_INIT) // first hook ever called 537 if (term->perl.should_invoke [htype])
419 { 538 {
420 term->self = (void *)newSVptr ((void *)term, "urxvt::term"); 539 dSP;
421 hv_store ((HV *)SvRV ((SV *)term->self), "_overlay", 8, newRV_noinc ((SV *)newHV ()), 0); 540 va_list ap;
541
542 va_start (ap, htype);
543
544 ENTER;
545 SAVETMPS;
546
547 PUSHMARK (SP);
548
549 EXTEND (SP, 2);
550 PUSHs (sv_2mortal (newSVterm (term)));
551 PUSHs (sv_2mortal (newSViv (htype)));
552
553 for (;;) {
554 data_type dt = (data_type)va_arg (ap, int);
555
556 switch (dt)
557 {
558 case DT_INT:
559 XPUSHs (sv_2mortal (newSViv (va_arg (ap, int))));
560 break;
561
562 case DT_LONG:
563 XPUSHs (sv_2mortal (newSViv (va_arg (ap, long))));
564 break;
565
566 case DT_STR:
567 XPUSHs (sv_2mortal (newSVpv (va_arg (ap, char *), 0)));
568 break;
569
570 case DT_STR_LEN:
571 {
572 char *str = va_arg (ap, char *);
573 int len = va_arg (ap, int);
574
575 XPUSHs (sv_2mortal (newSVpvn (str, len)));
576 }
577 break;
578
579 case DT_WCS_LEN:
580 {
581 wchar_t *wstr = va_arg (ap, wchar_t *);
582 int wlen = va_arg (ap, int);
583
584 XPUSHs (sv_2mortal (wcs2sv (wstr, wlen)));
585 }
586 break;
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
597 case DT_XEVENT:
598 {
599 XEvent *xe = va_arg (ap, XEvent *);
600 HV *hv = newHV ();
601
602# define set(name, sv) hv_store (hv, # name, sizeof (# name) - 1, sv, 0)
603# define setiv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSViv (val), 0)
604# define setuv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSVuv (val), 0)
605# undef set
606
607 setiv (type, xe->type);
608 setiv (send_event, xe->xany.send_event);
609 setiv (serial, xe->xany.serial);
610
611 switch (xe->type)
612 {
613 case KeyPress:
614 case KeyRelease:
615 case ButtonPress:
616 case ButtonRelease:
617 case MotionNotify:
618 setuv (window, xe->xmotion.window);
619 setuv (root, xe->xmotion.root);
620 setuv (subwindow, xe->xmotion.subwindow);
621 setuv (time, xe->xmotion.time);
622 setiv (x, xe->xmotion.x);
623 setiv (y, xe->xmotion.y);
624 setiv (row, xe->xmotion.y / term->fheight + term->view_start);
625 setiv (col, xe->xmotion.x / term->fwidth);
626 setiv (x_root, xe->xmotion.x_root);
627 setiv (y_root, xe->xmotion.y_root);
628 setuv (state, xe->xmotion.state);
629
630 switch (xe->type)
631 {
632 case KeyPress:
633 case KeyRelease:
634 setuv (keycode, xe->xkey.keycode);
635 break;
636
637 case ButtonPress:
638 case ButtonRelease:
639 setuv (button, xe->xbutton.button);
640 break;
641
642 case MotionNotify:
643 setiv (is_hint, xe->xmotion.is_hint);
644 break;
645 }
646
647 break;
648
649 case MapNotify:
650 case UnmapNotify:
651 case ConfigureNotify:
652 setuv (event, xe->xconfigure.event);
653 setuv (window, xe->xconfigure.window);
654
655 switch (xe->type)
656 {
657 case ConfigureNotify:
658 setiv (x, xe->xconfigure.x);
659 setiv (y, xe->xconfigure.y);
660 setiv (width, xe->xconfigure.width);
661 setiv (height, xe->xconfigure.height);
662 setuv (above, xe->xconfigure.above);
663 break;
664 }
665
666 break;
667
668 case PropertyNotify:
669 setuv (window, xe->xproperty.window);
670 setuv (atom, xe->xproperty.atom);
671 setuv (time, xe->xproperty.time);
672 setiv (state, xe->xproperty.state);
673 break;
674
675 case ClientMessage:
676 setuv (window, xe->xclient.window);
677 setuv (message_type, xe->xclient.message_type);
678 setuv (format, xe->xclient.format);
679 setuv (l0, xe->xclient.data.l[0]);
680 setuv (l1, xe->xclient.data.l[1]);
681 setuv (l2, xe->xclient.data.l[2]);
682 setuv (l3, xe->xclient.data.l[3]);
683 setuv (l4, xe->xclient.data.l[4]);
684 break;
685 }
686
687 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
688 }
689 break;
690
691 case DT_END:
692 goto call;
693
694 default:
695 rxvt_fatal ("FATAL: unable to pass data type %d\n", dt);
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);
710 }
711
712 PUTBACK;
713 FREETMPS;
714 LEAVE;
715
716 if (SvTRUE (ERRSV))
717 {
718 rxvt_warn ("perl hook %d evaluation error: %s", htype, SvPVbyte_nolen (ERRSV));
719 ungrab (term); // better lose the grab than the session
720 }
721
722 event_consumed = !!count;
422 } 723 }
423 else if (!term->self) 724 else
424 return false; // perl not initialized for this instance 725 event_consumed = false;
726
727 // post-handling of some events
728 if (htype == HOOK_REFRESH_BEGIN)
729 {
730 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, 0));
731
732 for (int i = AvFILL (av); i >= 0; i--)
733 ((overlay *)SvIV (*av_fetch (av, i, 0)))->swap ();
734 }
425 else if (htype == HOOK_DESTROY) 735 else if (htype == HOOK_DESTROY)
426 { 736 {
427 // handled later 737 clearSVptr ((SV *)term->perl.self);
738 SvREFCNT_dec ((SV *)term->perl.self);
739
740 // don't allow further calls
741 term->perl.self = 0;
428 } 742 }
429 else if (htype == HOOK_REFRESH_BEGIN || htype == HOOK_REFRESH_END)
430 {
431 HV *hv = (HV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->self), "_overlay", 8, 0));
432 743
433 if (HvKEYS (hv)) 744 return event_consumed;
434 { 745}
435 hv_iterinit (hv);
436 746
437 while (HE *he = hv_iternext (hv)) 747void
438 ((overlay *)SvIV (hv_iterval (hv, he)))->swap (); 748rxvt_perl_interp::selection_finish (rxvt_selection *sel, char *data, unsigned int len)
439 } 749{
440 } 750 localise_env set_environ (perl_environ);
441 else if (!should_invoke [htype])
442 return false;
443
444 dSP;
445 va_list ap;
446
447 va_start (ap, htype);
448 751
449 ENTER; 752 ENTER;
450 SAVETMPS; 753 SAVETMPS;
451 754
452 PUSHMARK (SP); 755 dSP;
453
454 XPUSHs (sv_2mortal (newSVterm (term)));
455 XPUSHs (sv_2mortal (newSViv (htype)));
456
457 for (;;) {
458 data_type dt = (data_type)va_arg (ap, int);
459
460 switch (dt)
461 {
462 case DT_INT:
463 XPUSHs (sv_2mortal (newSViv (va_arg (ap, int))));
464 break;
465
466 case DT_LONG:
467 XPUSHs (sv_2mortal (newSViv (va_arg (ap, long))));
468 break;
469
470 case DT_STR:
471 XPUSHs (sv_2mortal (newSVpv (va_arg (ap, char *), 0)));
472 break;
473
474 case DT_STR_LEN:
475 {
476 char *str = va_arg (ap, char *);
477 int len = va_arg (ap, int);
478
479 XPUSHs (sv_2mortal (newSVpvn (str, len))); 756 XPUSHs (sv_2mortal (newSVpvn (data, len)));
480 } 757 PUTBACK;
481 break; 758 call_sv ((SV *)sel->cb_sv, G_VOID | G_DISCARD | G_EVAL);
482 759
483 case DT_WCS_LEN:
484 {
485 wchar_t *wstr = va_arg (ap, wchar_t *);
486 int wlen = va_arg (ap, int);
487
488 XPUSHs (sv_2mortal (wcs2sv (wstr, wlen)));
489 }
490
491 case DT_XEVENT:
492 {
493 XEvent *xe = va_arg (ap, XEvent *);
494 HV *hv = newHV ();
495
496# define set(name, sv) hv_store (hv, # name, sizeof (# name) - 1, sv, 0)
497# define setiv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSViv (val), 0)
498# undef set
499
500 setiv (type, xe->type);
501 setiv (send_event, xe->xany.send_event);
502 setiv (serial, xe->xany.serial);
503
504 switch (xe->type)
505 {
506 case KeyPress:
507 case KeyRelease:
508 case ButtonPress:
509 case ButtonRelease:
510 case MotionNotify:
511 setiv (time, xe->xmotion.time);
512 setiv (x, xe->xmotion.x);
513 setiv (y, xe->xmotion.y);
514 setiv (row, xe->xmotion.y / term->fheight);
515 setiv (col, xe->xmotion.x / term->fwidth);
516 setiv (x_root, xe->xmotion.x_root);
517 setiv (y_root, xe->xmotion.y_root);
518 setiv (state, xe->xmotion.state);
519 break;
520 }
521
522 switch (xe->type)
523 {
524 case KeyPress:
525 case KeyRelease:
526 setiv (keycode, xe->xkey.keycode);
527 break;
528
529 case ButtonPress:
530 case ButtonRelease:
531 setiv (button, xe->xbutton.button);
532 break;
533
534 case MotionNotify:
535 setiv (is_hint, xe->xmotion.is_hint);
536 break;
537 }
538
539 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
540 }
541 break;
542
543 case DT_END:
544 {
545 va_end (ap);
546
547 PUTBACK;
548 int count = call_pv ("urxvt::invoke", G_ARRAY | G_EVAL);
549 SPAGAIN;
550
551 if (count)
552 {
553 SV *status = POPs;
554 count = SvTRUE (status);
555 }
556
557 PUTBACK;
558 FREETMPS;
559 LEAVE;
560
561 if (SvTRUE (ERRSV)) 760 if (SvTRUE (ERRSV))
562 rxvt_warn ("perl hook %d evaluation error: %s", htype, SvPV_nolen (ERRSV)); 761 rxvt_warn ("perl selection callback evaluation error: %s", SvPVbyte_nolen (ERRSV));
563 762
564 if (htype == HOOK_DESTROY) 763 FREETMPS;
565 { 764 LEAVE;
566 clearSVptr ((SV *)term->self);
567 SvREFCNT_dec ((SV *)term->self);
568 }
569
570 return count;
571 }
572
573 default:
574 rxvt_fatal ("FATAL: unable to pass data type %d\n", dt);
575 }
576 }
577} 765}
578 766
579///////////////////////////////////////////////////////////////////////////// 767/////////////////////////////////////////////////////////////////////////////
580 768
581MODULE = urxvt PACKAGE = urxvt 769MODULE = urxvt PACKAGE = urxvt
582 770
583PROTOTYPES: ENABLE 771PROTOTYPES: ENABLE
584 772
585BOOT: 773BOOT:
586{ 774{
587# define export_const(name) newCONSTSUB (gv_stashpv ("urxvt", 1), # name, newSViv (name)); 775 sv_setsv (get_sv ("urxvt::LIBDIR", 1), newSVpvn (LIBDIR, sizeof (LIBDIR) - 1));
776 sv_setsv (get_sv ("urxvt::RESNAME", 1), newSVpvn (RESNAME, sizeof (RESNAME) - 1));
777 sv_setsv (get_sv ("urxvt::RESCLASS", 1), newSVpvn (RESCLASS, sizeof (RESCLASS) - 1));
778 sv_setsv (get_sv ("urxvt::RXVTNAME", 1), newSVpvn (RXVTNAME, sizeof (RXVTNAME) - 1));
779
588 AV *hookname = get_av ("urxvt::HOOKNAME", 1); 780 AV *hookname = get_av ("urxvt::HOOKNAME", 1);
589# define def(sym) av_store (hookname, HOOK_ ## sym, newSVpv (# sym, 0)); 781# define def(sym) av_store (hookname, HOOK_ ## sym, newSVpv (# sym, 0));
590# include "hookinc.h" 782# include "hookinc.h"
591# undef def 783# undef def
592 784
785 HV *option = get_hv ("urxvt::OPTION", 1);
786# define def(name) hv_store (option, # name, sizeof (# name) - 1, newSVuv (Opt_ ## name), 0);
787# define nodef(name)
788# include "optinc.h"
789# undef nodef
790# undef def
791
792 HV *stash = gv_stashpv ("urxvt", 1);
793 static const struct {
794 const char *name;
795 IV iv;
796 } *civ, const_iv[] = {
797# define const_iv(name) { # name, (IV)name }
798 const_iv (NUM_RESOURCES),
593 export_const (DEFAULT_RSTYLE); 799 const_iv (DEFAULT_RSTYLE),
594 export_const (OVERLAY_RSTYLE); 800 const_iv (OVERLAY_RSTYLE),
595 export_const (RS_Bold); 801 const_iv (Color_Bits),
596 export_const (RS_Italic); 802 const_iv (RS_bgShift), const_iv (RS_bgMask),
597 export_const (RS_Blink); 803 const_iv (RS_fgShift), const_iv (RS_fgMask),
598 export_const (RS_RVid); 804 const_iv (RS_Careful),
599 export_const (RS_Uline); 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),
812 const_iv (RS_Bold),
813 const_iv (RS_Italic),
814 const_iv (RS_Blink),
815 const_iv (RS_RVid),
816 const_iv (RS_Uline),
600 817
601 sv_setpv (get_sv ("urxvt::LIBDIR", 1), LIBDIR); 818 const_iv (CurrentTime),
602} 819 const_iv (ShiftMask),
820 const_iv (LockMask),
821 const_iv (ControlMask),
822 const_iv (Mod1Mask),
823 const_iv (Mod2Mask),
824 const_iv (Mod3Mask),
825 const_iv (Mod4Mask),
826 const_iv (Mod5Mask),
827 const_iv (Button1Mask),
828 const_iv (Button2Mask),
829 const_iv (Button3Mask),
830 const_iv (Button4Mask),
831 const_iv (Button5Mask),
832 const_iv (AnyModifier),
603 833
604SV * 834 const_iv (NoSymbol),
605new (...) 835 const_iv (GrabModeSync),
606 CODE: 836 const_iv (GrabModeAsync),
607{
608 stringvec *argv = new stringvec;
609 bool success;
610 837
611 for (int i = 0; i < items ;i++) 838 const_iv (NoEventMask),
612 argv->push_back (strdup (SvPVbyte_nolen (ST (i)))); 839 const_iv (KeyPressMask),
840 const_iv (KeyReleaseMask),
841 const_iv (ButtonPressMask),
842 const_iv (ButtonReleaseMask),
843 const_iv (EnterWindowMask),
844 const_iv (LeaveWindowMask),
845 const_iv (PointerMotionMask),
846 const_iv (PointerMotionHintMask),
847 const_iv (Button1MotionMask),
848 const_iv (Button2MotionMask),
849 const_iv (Button3MotionMask),
850 const_iv (Button4MotionMask),
851 const_iv (Button5MotionMask),
852 const_iv (ButtonMotionMask),
853 const_iv (KeymapStateMask),
854 const_iv (ExposureMask),
855 const_iv (VisibilityChangeMask),
856 const_iv (StructureNotifyMask),
857 const_iv (ResizeRedirectMask),
858 const_iv (SubstructureNotifyMask),
859 const_iv (SubstructureRedirectMask),
860 const_iv (FocusChangeMask),
861 const_iv (PropertyChangeMask),
862 const_iv (ColormapChangeMask),
863 const_iv (OwnerGrabButtonMask),
613 864
614 rxvt_term *term = new rxvt_term; 865 const_iv (KeyPress),
866 const_iv (KeyRelease),
867 const_iv (ButtonPress),
868 const_iv (ButtonRelease),
869 const_iv (MotionNotify),
870 const_iv (EnterNotify),
871 const_iv (LeaveNotify),
872 const_iv (FocusIn),
873 const_iv (FocusOut),
874 const_iv (KeymapNotify),
875 const_iv (Expose),
876 const_iv (GraphicsExpose),
877 const_iv (NoExpose),
878 const_iv (VisibilityNotify),
879 const_iv (CreateNotify),
880 const_iv (DestroyNotify),
881 const_iv (UnmapNotify),
882 const_iv (MapNotify),
883 const_iv (MapRequest),
884 const_iv (ReparentNotify),
885 const_iv (ConfigureNotify),
886 const_iv (ConfigureRequest),
887 const_iv (GravityNotify),
888 const_iv (ResizeRequest),
889 const_iv (CirculateNotify),
890 const_iv (CirculateRequest),
891 const_iv (PropertyNotify),
892 const_iv (SelectionClear),
893 const_iv (SelectionRequest),
894 const_iv (SelectionNotify),
895 const_iv (ColormapNotify),
896 const_iv (ClientMessage),
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
990 };
615 991
616 term->argv = argv; 992 for (civ = const_iv + ecb_array_length (const_iv); civ > const_iv; civ--)
993 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
994}
617 995
996void
997log (const char *msg)
998 CODE:
999 rxvt_log ("%s", msg);
1000
1001void
1002warn (const char *msg)
1003 CODE:
1004 rxvt_warn ("%s", msg);
1005
1006void
1007fatal (const char *msg)
1008 CODE:
1009 rxvt_fatal ("%s", msg);
1010
1011void
1012_exit (int status)
1013
1014void
1015catch_fatal (SV *block)
1016 PROTOTYPE: &
1017 CODE:
618 try 1018 try
619 { 1019 {
620 if (!term->init (argv->size (), argv->begin ())) 1020 PUSHMARK (SP);
621 term = 0; 1021 PUTBACK;
1022 call_sv (block, G_VOID | G_DISCARD);
1023 SPAGAIN;
622 } 1024 }
623 catch (const class rxvt_failure_exception &e) 1025 catch (const rxvt_failure_exception &e)
624 {
625 term->destroy ();
626 croak ("exception caught while initializing new terminal instance");
627 } 1026 {
628 1027 croak ("rxvt_fatal exception caught, trying to continue.");
629 RETVAL = term && term->self ? newSVterm (term) : &PL_sv_undef; 1028 }
630}
631 OUTPUT:
632 RETVAL
633
634void
635set_should_invoke (int htype, int value)
636 CODE:
637 rxvt_perl.should_invoke [htype] = value;
638
639void
640warn (const char *msg)
641 CODE:
642 rxvt_warn ("%s", msg);
643
644void
645fatal (const char *msg)
646 CODE:
647 rxvt_fatal ("%s", msg);
648 1029
649NV 1030NV
650NOW () 1031NOW ()
651 CODE: 1032 CODE:
652 RETVAL = NOW; 1033 RETVAL = ev::now ();
653 OUTPUT: 1034 OUTPUT:
654 RETVAL 1035 RETVAL
655 1036
656int 1037int
657GET_BASEFG (int rend) 1038GET_BASEFG (int rend)
… …
668 RETVAL 1049 RETVAL
669 1050
670int 1051int
671SET_FGCOLOR (int rend, int new_color) 1052SET_FGCOLOR (int rend, int new_color)
672 CODE: 1053 CODE:
673 RETVAL = SET_FGCOLOR (rend, new_color); 1054 RETVAL = SET_FGCOLOR (rend, clamp (new_color, 0, TOTAL_COLORS - 1));
674 OUTPUT: 1055 OUTPUT:
675 RETVAL 1056 RETVAL
676 1057
677int 1058int
678SET_BGCOLOR (int rend, int new_color) 1059SET_BGCOLOR (int rend, int new_color)
679 CODE: 1060 CODE:
680 RETVAL = SET_BGCOLOR (rend, new_color); 1061 RETVAL = SET_BGCOLOR (rend, clamp (new_color, 0, TOTAL_COLORS - 1));
681 OUTPUT: 1062 OUTPUT:
682 RETVAL 1063 RETVAL
683 1064
684int 1065int
685GET_CUSTOM (int rend) 1066GET_CUSTOM (int rend)
686 CODE: 1067 CODE:
687 RETVAL = (rend && RS_customMask) >> RS_customShift; 1068 RETVAL = (rend & RS_customMask) >> RS_customShift;
688 OUTPUT: 1069 OUTPUT:
689 RETVAL 1070 RETVAL
690 1071
691int 1072int
692SET_CUSTOM (int rend, int new_value) 1073SET_CUSTOM (int rend, int new_value)
… …
699 | ((new_value << RS_customShift) & RS_customMask); 1080 | ((new_value << RS_customShift) & RS_customMask);
700} 1081}
701 OUTPUT: 1082 OUTPUT:
702 RETVAL 1083 RETVAL
703 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
704MODULE = urxvt PACKAGE = urxvt::term 1125MODULE = urxvt PACKAGE = urxvt::term
705 1126
1127SV *
1128_new (AV *env, AV *arg)
1129 CODE:
1130{
1131 rxvt_term *term = new rxvt_term;
1132
1133 stringvec *argv = new stringvec;
1134 for (int i = 0; i <= AvFILL (arg); i++)
1135 argv->push_back (strdup (SvPVbyte_nolen (*av_fetch (arg, i, 1))));
1136
1137 stringvec *envv = new stringvec;
1138 for (int i = AvFILL (env) + 1; i--; )
1139 envv->push_back (strdup (SvPVbyte_nolen (*av_fetch (env, i, 1))));
1140
1141 try
1142 {
1143 term->init (argv, envv);
1144 }
1145 catch (const class rxvt_failure_exception &e)
1146 {
1147 term->destroy ();
1148 croak ("error while initializing new terminal instance");
1149 }
1150
1151 RETVAL = term && term->perl.self
1152 ? newSVterm (term) : &PL_sv_undef;
1153}
1154 OUTPUT:
1155 RETVAL
1156
706void 1157void
707rxvt_term::destroy () 1158rxvt_term::destroy ()
1159
1160void
1161rxvt_term::set_should_invoke (int htype, int inc)
1162 CODE:
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 }
1176
1177void
1178rxvt_term::put_option_db (octet_string specifier, octet_string value)
1179 CODE:
1180 XrmPutStringResource (&THIS->option_db, specifier, value);
1181
1182int
1183rxvt_term::grab_button (int button, U32 modifiers, Window window = THIS->vt)
1184 CODE:
1185 RETVAL = XGrabButton (THIS->dpy, button, modifiers, window, 1,
1186 ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
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);
1206
1207bool
1208rxvt_term::grab (Time eventtime, int sync = 0)
1209 CODE:
1210{
1211 int mode = sync ? GrabModeSync : GrabModeAsync;
1212
1213 THIS->perl.grabtime = 0;
1214
1215 if (!XGrabPointer (THIS->dpy, THIS->vt, 0,
1216 ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
1217 mode, mode, None, GRAB_CURSOR, eventtime))
1218 if (!XGrabKeyboard (THIS->dpy, THIS->vt, 0, mode, mode, eventtime))
1219 THIS->perl.grabtime = eventtime;
1220 else
1221 XUngrabPointer (THIS->dpy, eventtime);
1222
1223 RETVAL = !!THIS->perl.grabtime;
1224}
1225 OUTPUT:
1226 RETVAL
1227
1228void
1229rxvt_term::allow_events_async ()
1230 CODE:
1231 XAllowEvents (THIS->dpy, AsyncBoth, THIS->perl.grabtime);
1232
1233void
1234rxvt_term::allow_events_sync ()
1235 CODE:
1236 XAllowEvents (THIS->dpy, SyncBoth, THIS->perl.grabtime);
1237
1238void
1239rxvt_term::allow_events_replay ()
1240 CODE:
1241 XAllowEvents (THIS->dpy, ReplayPointer, THIS->perl.grabtime);
1242 XAllowEvents (THIS->dpy, ReplayKeyboard, THIS->perl.grabtime);
1243
1244void
1245rxvt_term::ungrab ()
1246 CODE:
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
708 1272
709int 1273int
710rxvt_term::strwidth (SV *str) 1274rxvt_term::strwidth (SV *str)
711 CODE: 1275 CODE:
712{ 1276{
713 wchar_t *wstr = sv2wcs (str); 1277 wchar_t *wstr = sv2wcs (str);
714 1278
715 rxvt_push_locale (THIS->locale); 1279 rxvt_push_locale (THIS->locale);
716 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 }
717 rxvt_pop_locale (); 1288 rxvt_pop_locale ();
718 1289
719 free (wstr); 1290 free (wstr);
720} 1291}
721 OUTPUT: 1292 OUTPUT:
… …
754 free (wstr); 1325 free (wstr);
755} 1326}
756 OUTPUT: 1327 OUTPUT:
757 RETVAL 1328 RETVAL
758 1329
759# very portable, especially on objects as opposed to pods 1330#define TERM_OFFSET(sym) offsetof (TermWin_t, sym)
760#define TERM_OFFSET(sym) (((char *)&((TermWin_t *)0)->sym) - (char *)(TermWin_t *)0)
761 1331
762#define TERM_OFFSET_width TERM_OFFSET(width) 1332#define TERM_OFFSET_width TERM_OFFSET(width)
763#define TERM_OFFSET_height TERM_OFFSET(height) 1333#define TERM_OFFSET_height TERM_OFFSET(height)
764#define TERM_OFFSET_fwidth TERM_OFFSET(fwidth) 1334#define TERM_OFFSET_fwidth TERM_OFFSET(fwidth)
765#define TERM_OFFSET_fheight TERM_OFFSET(fheight) 1335#define TERM_OFFSET_fheight TERM_OFFSET(fheight)
766#define TERM_OFFSET_fbase TERM_OFFSET(fbase) 1336#define TERM_OFFSET_fbase TERM_OFFSET(fbase)
767#define TERM_OFFSET_nrow TERM_OFFSET(nrow) 1337#define TERM_OFFSET_nrow TERM_OFFSET(nrow)
768#define TERM_OFFSET_ncol TERM_OFFSET(ncol) 1338#define TERM_OFFSET_ncol TERM_OFFSET(ncol)
769#define TERM_OFFSET_focus TERM_OFFSET(focus) 1339#define TERM_OFFSET_focus TERM_OFFSET(focus)
770#define TERM_OFFSET_mapped TERM_OFFSET(mapped) 1340#define TERM_OFFSET_mapped TERM_OFFSET(mapped)
1341#define TERM_OFFSET_int_bwidth TERM_OFFSET(int_bwidth)
1342#define TERM_OFFSET_ext_bwidth TERM_OFFSET(ext_bwidth)
1343#define TERM_OFFSET_lineSpace TERM_OFFSET(lineSpace)
1344#define TERM_OFFSET_letterSpace TERM_OFFSET(letterSpace)
771#define TERM_OFFSET_saveLines TERM_OFFSET(saveLines) 1345#define TERM_OFFSET_saveLines TERM_OFFSET(saveLines)
772#define TERM_OFFSET_total_rows TERM_OFFSET(total_rows) 1346#define TERM_OFFSET_total_rows TERM_OFFSET(total_rows)
773#define TERM_OFFSET_nsaved TERM_OFFSET(nsaved) 1347#define TERM_OFFSET_top_row TERM_OFFSET(top_row)
774 1348
775int 1349int
776rxvt_term::width () 1350rxvt_term::width ()
777 ALIAS: 1351 ALIAS:
778 width = TERM_OFFSET_width 1352 width = TERM_OFFSET_width
779 height = TERM_OFFSET_height 1353 height = TERM_OFFSET_height
780 fwidth = TERM_OFFSET_fwidth 1354 fwidth = TERM_OFFSET_fwidth
781 fheight = TERM_OFFSET_fheight 1355 fheight = TERM_OFFSET_fheight
782 fbase = TERM_OFFSET_fbase 1356 fbase = TERM_OFFSET_fbase
783 nrow = TERM_OFFSET_nrow 1357 nrow = TERM_OFFSET_nrow
784 ncol = TERM_OFFSET_ncol 1358 ncol = TERM_OFFSET_ncol
785 focus = TERM_OFFSET_focus 1359 focus = TERM_OFFSET_focus
786 mapped = TERM_OFFSET_mapped 1360 mapped = TERM_OFFSET_mapped
1361 int_bwidth = TERM_OFFSET_int_bwidth
1362 ext_bwidth = TERM_OFFSET_ext_bwidth
1363 lineSpace = TERM_OFFSET_lineSpace
1364 letterSpace = TERM_OFFSET_letterSpace
787 saveLines = TERM_OFFSET_saveLines 1365 saveLines = TERM_OFFSET_saveLines
788 total_rows = TERM_OFFSET_total_rows 1366 total_rows = TERM_OFFSET_total_rows
789 nsaved = TERM_OFFSET_nsaved 1367 top_row = TERM_OFFSET_top_row
790 CODE: 1368 CODE:
791 RETVAL = *(int *)((char *)THIS + ix); 1369 RETVAL = *(int *)((char *)THIS + ix);
792 OUTPUT: 1370 OUTPUT:
793 RETVAL 1371 RETVAL
794 1372
795U32 1373unsigned int
1374rxvt_term::ModLevel3Mask ()
1375 ALIAS:
1376 ModLevel3Mask = 0
1377 ModMetaMask = 1
1378 ModNumLockMask = 2
1379 current_screen = 3
1380 hidden_cursor = 4
1381 CODE:
1382 switch (ix)
1383 {
1384 case 0: RETVAL = THIS->ModLevel3Mask; break;
1385 case 1: RETVAL = THIS->ModMetaMask; break;
1386 case 2: RETVAL = THIS->ModNumLockMask; break;
1387 case 3: RETVAL = THIS->current_screen; break;
1388#ifdef CURSOR_BLINK
1389 case 4: RETVAL = THIS->hidden_cursor; break;
1390#endif
1391 }
1392 OUTPUT:
1393 RETVAL
1394
1395char *
1396rxvt_term::display_id ()
1397 ALIAS:
1398 display_id = 0
1399 locale = 1
1400 CODE:
1401 switch (ix)
1402 {
1403 case 0: RETVAL = THIS->display->id; break;
1404 case 1: RETVAL = THIS->locale; break;
1405 }
1406 OUTPUT:
1407 RETVAL
1408
1409SV *
1410rxvt_term::envv ()
1411 ALIAS:
1412 argv = 1
1413 PPCODE:
1414{
1415 stringvec *vec = ix ? THIS->argv : THIS->envv;
1416
1417 EXTEND (SP, vec->size ());
1418
1419 for (char **i = vec->begin (); i != vec->end (); ++i)
1420 if (*i)
1421 PUSHs (sv_2mortal (newSVpv (*i, 0)));
1422}
1423
1424int
1425rxvt_term::pty_ev_events (int events = ev::UNDEF)
1426 CODE:
1427 RETVAL = THIS->pty_ev.events;
1428 if (events != ev::UNDEF)
1429 THIS->pty_ev.set (events);
1430 OUTPUT:
1431 RETVAL
1432
1433int
1434rxvt_term::pty_fd ()
1435 CODE:
1436 RETVAL = THIS->pty->pty;
1437 OUTPUT:
1438 RETVAL
1439
1440Window
796rxvt_term::parent () 1441rxvt_term::parent ()
797 CODE: 1442 CODE:
798 RETVAL = (U32)THIS->parent [0]; 1443 RETVAL = THIS->parent;
799 OUTPUT: 1444 OUTPUT:
800 RETVAL 1445 RETVAL
801 1446
802U32 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;
1458 OUTPUT:
1459 RETVAL
1460
1461Window
803rxvt_term::vt () 1462rxvt_term::vt ()
804 CODE: 1463 CODE:
805 RETVAL = (U32)THIS->vt; 1464 RETVAL = THIS->vt;
806 OUTPUT: 1465 OUTPUT:
807 RETVAL 1466 RETVAL
1467
1468void
1469rxvt_term::vt_emask_add (U32 emask)
1470 CODE:
1471 THIS->vt_emask_perl |= emask;
1472 THIS->vt_select_input ();
808 1473
809U32 1474U32
810rxvt_term::rstyle (U32 new_rstyle = THIS->rstyle) 1475rxvt_term::rstyle (U32 new_rstyle = THIS->rstyle)
811 CODE: 1476 CODE:
812{
813 RETVAL = THIS->rstyle; 1477 RETVAL = THIS->rstyle;
814 THIS->rstyle = new_rstyle; 1478 THIS->rstyle = new_rstyle;
815}
816 OUTPUT: 1479 OUTPUT:
817 RETVAL 1480 RETVAL
818 1481
819int 1482int
820rxvt_term::view_start (int newval = -1) 1483rxvt_term::view_start (int newval = 1)
1484 PROTOTYPE: $;$
821 CODE: 1485 CODE:
822{ 1486{
823 RETVAL = THIS->view_start; 1487 RETVAL = THIS->view_start;
824 1488
825 if (newval >= 0) 1489 if (newval <= 0)
826 { 1490 THIS->scr_changeview (max (newval, THIS->top_row));
827 THIS->view_start = min (newval, THIS->nsaved);
828 THIS->scr_changeview (RETVAL);
829 }
830} 1491}
831 OUTPUT: 1492 OUTPUT:
832 RETVAL 1493 RETVAL
833 1494
834void 1495void
1496rxvt_term::set_urgency (bool enable)
1497
1498void
1499rxvt_term::focus_in ()
1500
1501void
1502rxvt_term::focus_out ()
1503
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
835rxvt_term::want_refresh () 1531rxvt_term::want_refresh ()
836 CODE: 1532 CODE:
837 THIS->want_refresh = 1; 1533 THIS->want_refresh = 1;
1534 THIS->refresh_check ();
838 1535
839void 1536void
840rxvt_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)
841 PPCODE: 1538 PPCODE:
842{ 1539{
843 if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow)) 1540 if (!IN_RANGE_EXC (row_number, THIS->top_row, THIS->nrow))
844 XSRETURN_EMPTY; 1541 XSRETURN_EMPTY;
845 1542
846 line_t &l = ROW(row_number); 1543 line_t &l = ROW(row_number);
847 1544
848 if (GIMME_V != G_VOID) 1545 if (GIMME_V != G_VOID)
849 { 1546 {
850 wchar_t *wstr = new wchar_t [THIS->ncol]; 1547 wchar_t *wstr = rxvt_temp_buf<wchar_t> (THIS->ncol);
851 1548
852 for (int col = 0; col < THIS->ncol; col++) 1549 for (int col = 0; col < THIS->ncol; col++)
853 wstr [col] = l.t [col]; 1550 wstr [col] = l.t [col];
854 1551
855 XPUSHs (sv_2mortal (wcs2sv (wstr, THIS->ncol))); 1552 XPUSHs (sv_2mortal (wcs2sv (wstr, THIS->ncol)));
856
857 delete [] wstr;
858 } 1553 }
859 1554
860 if (new_text) 1555 if (new_text)
861 { 1556 {
862 wchar_t *wstr = sv2wcs (new_text); 1557 wchar_t *wstr = sv2wcs (new_text);
863 1558
864 int len = min (wcslen (wstr) - start_ofs, max_len); 1559 int len = min (wcslen (wstr) - start_ofs, max_len);
865 1560
866 if (!IN_RANGE_INC (start_col, 0, THIS->ncol - len)) 1561 if (start_col < 0 || start_col + len > THIS->ncol)
867 { 1562 {
868 free (wstr); 1563 free (wstr);
869 croak ("new_text extends beyond horizontal margins"); 1564 croak ("new_text extends beyond horizontal margins");
870 } 1565 }
871 1566
… …
881 1576
882void 1577void
883rxvt_term::ROW_r (int row_number, SV *new_rend = 0, int start_col = 0, int start_ofs = 0, int max_len = MAX_COLS) 1578rxvt_term::ROW_r (int row_number, SV *new_rend = 0, int start_col = 0, int start_ofs = 0, int max_len = MAX_COLS)
884 PPCODE: 1579 PPCODE:
885{ 1580{
886 if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow)) 1581 if (!IN_RANGE_EXC (row_number, THIS->top_row, THIS->nrow))
887 XSRETURN_EMPTY; 1582 XSRETURN_EMPTY;
888 1583
889 line_t &l = ROW(row_number); 1584 line_t &l = ROW(row_number);
890 1585
891 if (GIMME_V != G_VOID) 1586 if (GIMME_V != G_VOID)
… …
903 { 1598 {
904 if (!SvROK (new_rend) || SvTYPE (SvRV (new_rend)) != SVt_PVAV) 1599 if (!SvROK (new_rend) || SvTYPE (SvRV (new_rend)) != SVt_PVAV)
905 croak ("new_rend must be arrayref"); 1600 croak ("new_rend must be arrayref");
906 1601
907 AV *av = (AV *)SvRV (new_rend); 1602 AV *av = (AV *)SvRV (new_rend);
908 int len = min (av_len (av) + 1 - start_ofs, max_len); 1603 int len = min (AvFILL (av) + 1 - start_ofs, max_len);
909 1604
910 if (!IN_RANGE_INC (start_col, 0, THIS->ncol - len)) 1605 if (start_col < 0 || start_col + len > THIS->ncol)
911 croak ("new_rend array extends beyond horizontal margins"); 1606 croak ("new_rend array extends beyond horizontal margins");
912 1607
913 for (int col = start_col; col < start_col + len; col++) 1608 for (int col = start_col; col < start_col + len; col++)
914 { 1609 {
915 rend_t r = SvIV (*av_fetch (av, start_ofs + col - start_col, 1)) & ~RS_fontMask; 1610 rend_t r = SvIV (*av_fetch (av, start_ofs + col - start_col, 1)) & ~RS_fontMask;
… …
921 1616
922int 1617int
923rxvt_term::ROW_l (int row_number, int new_length = -1) 1618rxvt_term::ROW_l (int row_number, int new_length = -1)
924 CODE: 1619 CODE:
925{ 1620{
926 if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow)) 1621 if (!IN_RANGE_EXC (row_number, THIS->top_row, THIS->nrow))
927 XSRETURN_EMPTY; 1622 XSRETURN_EMPTY;
928 1623
929 line_t &l = ROW(row_number); 1624 line_t &l = ROW(row_number);
930 RETVAL = l.l; 1625 RETVAL = l.l;
931 1626
… …
937 1632
938bool 1633bool
939rxvt_term::ROW_is_longer (int row_number, int new_is_longer = -1) 1634rxvt_term::ROW_is_longer (int row_number, int new_is_longer = -1)
940 CODE: 1635 CODE:
941{ 1636{
942 if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow)) 1637 if (!IN_RANGE_EXC (row_number, THIS->top_row, THIS->nrow))
943 XSRETURN_EMPTY; 1638 XSRETURN_EMPTY;
944 1639
945 line_t &l = ROW(row_number); 1640 line_t &l = ROW(row_number);
946 RETVAL = l.is_longer (); 1641 RETVAL = l.is_longer ();
947 1642
… …
955rxvt_term::special_encode (SV *string) 1650rxvt_term::special_encode (SV *string)
956 CODE: 1651 CODE:
957{ 1652{
958 wchar_t *wstr = sv2wcs (string); 1653 wchar_t *wstr = sv2wcs (string);
959 int wlen = wcslen (wstr); 1654 int wlen = wcslen (wstr);
960 wchar_t *rstr = new wchar_t [wlen]; // cannot become longer 1655 wchar_t *rstr = rxvt_temp_buf<wchar_t> (wlen * 2); // cannot become longer
961 1656
962 rxvt_push_locale (THIS->locale); 1657 rxvt_push_locale (THIS->locale);
963 1658
964 wchar_t *r = rstr; 1659 wchar_t *r = rstr;
965 for (wchar_t *s = wstr; *s; s++) 1660 for (wchar_t *s = wstr; *s; s++)
1661 {
1662 int w = WCWIDTH (*s);
1663
966 if (wcwidth (*s) == 0) 1664 if (w == 0)
967 { 1665 {
968 if (r == rstr) 1666 if (r == rstr)
969 croak ("leading combining character unencodable"); 1667 croak ("leading combining character unencodable");
970 1668
971 unicode_t n = rxvt_compose (r[-1], *s); 1669 unicode_t n = rxvt_compose (r[-1], *s);
972 if (n == NOCHAR) 1670 if (n == NOCHAR)
973 n = rxvt_composite.compose (r[-1], *s); 1671 n = rxvt_composite.compose (r[-1], *s);
974 1672
975 r[-1] = n; 1673 r[-1] = n;
976 } 1674 }
977#if !UNICODE_3 1675#if !UNICODE_3
978 else if (*s >= 0x10000) 1676 else if (*s >= 0x10000)
979 *r++ = rxvt_composite.compose (*s); 1677 *r++ = rxvt_composite.compose (*s);
980#endif 1678#endif
981 else 1679 else
982 *r++ = *s; 1680 *r++ = *s;
1681
1682 // the *2 above only allows wcwidth <= 2
1683 if (w > 1)
1684 *r++ = NOCHAR;
1685 }
983 1686
984 rxvt_pop_locale (); 1687 rxvt_pop_locale ();
985 1688
986 RETVAL = wcs2sv (rstr, r - rstr); 1689 RETVAL = wcs2sv (rstr, r - rstr);
987
988 delete [] rstr;
989} 1690}
990 OUTPUT: 1691 OUTPUT:
991 RETVAL 1692 RETVAL
992 1693
993SV * 1694SV *
994rxvt_term::special_decode (SV *text) 1695rxvt_term::special_decode (SV *text)
995 CODE: 1696 CODE:
996{ 1697{
997 wchar_t *wstr = sv2wcs (text); 1698 wchar_t *wstr = sv2wcs (text);
998 int wlen = wcslen (wstr);
999 int dlen = 0; 1699 int dlen = 0;
1000 1700
1001 // find length 1701 // find length
1002 for (wchar_t *s = wstr; *s; s++) 1702 for (wchar_t *s = wstr; *s; s++)
1003 if (*s == NOCHAR) 1703 if (*s == NOCHAR)
… …
1005 else if (IS_COMPOSE (*s)) 1705 else if (IS_COMPOSE (*s))
1006 dlen += rxvt_composite.expand (*s, 0); 1706 dlen += rxvt_composite.expand (*s, 0);
1007 else 1707 else
1008 dlen++; 1708 dlen++;
1009 1709
1010 wchar_t *rstr = new wchar_t [dlen]; 1710 wchar_t *rstr = rxvt_temp_buf<wchar_t> (dlen);
1011 1711
1012 // decode 1712 // decode
1013 wchar_t *r = rstr; 1713 wchar_t *r = rstr;
1014 for (wchar_t *s = wstr; *s; s++) 1714 for (wchar_t *s = wstr; *s; s++)
1015 if (*s == NOCHAR) 1715 if (*s == NOCHAR)
… …
1018 r += rxvt_composite.expand (*s, r); 1718 r += rxvt_composite.expand (*s, r);
1019 else 1719 else
1020 *r++ = *s; 1720 *r++ = *s;
1021 1721
1022 RETVAL = wcs2sv (rstr, r - rstr); 1722 RETVAL = wcs2sv (rstr, r - rstr);
1023
1024 delete [] rstr;
1025} 1723}
1026 OUTPUT: 1724 OUTPUT:
1027 RETVAL 1725 RETVAL
1028 1726
1029void 1727void
1030rxvt_term::_resource (char *name, int index, SV *newval = 0) 1728rxvt_term::_resource (char *name, int index, SV *newval = 0)
1031 PPCODE: 1729 PPCODE:
1032{ 1730{
1033 struct resval { const char *name; int value; } rslist [] = { 1731 static const struct resval { const char *name; int value; } *rs, rslist [] = {
1034# define def(name) { # name, Rs_ ## name }, 1732# define def(name) { # name, Rs_ ## name },
1035# define reserve(name,count) 1733# define reserve(name,count)
1036# include "rsinc.h" 1734# include "rsinc.h"
1037# undef def 1735# undef def
1038# undef reserve 1736# undef reserve
1039 }; 1737 };
1040 1738
1041 struct resval *rs = rslist + sizeof (rslist) / sizeof (rslist [0]); 1739 rs = rslist + ecb_array_length (rslist);
1042 1740
1741 if (*name)
1043 do { 1742 {
1743 do {
1044 if (rs-- == rslist) 1744 if (rs-- == rslist)
1045 croak ("no such resource '%s', requested", name); 1745 croak ("no such resource '%s', requested", name);
1046 } while (strcmp (name, rs->name)); 1746 } while (strcmp (name, rs->name));
1047 1747
1048 index += rs->value; 1748 index += rs->value;
1749 }
1750 else
1751 {
1752 --rs;
1753 name = "";
1754 }
1049 1755
1050 if (!IN_RANGE_EXC (index, 0, NUM_RESOURCES)) 1756 if (!IN_RANGE_EXC (index, 0, NUM_RESOURCES))
1051 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);
1052 1758
1053 if (GIMME_V != G_VOID) 1759 if (GIMME_V != G_VOID)
… …
1064 else 1770 else
1065 THIS->rs [index] = 0; 1771 THIS->rs [index] = 0;
1066 } 1772 }
1067} 1773}
1068 1774
1775const char *
1776rxvt_term::x_resource (const char *name)
1777
1778bool
1779rxvt_term::option (U8 optval, int set = -1)
1780 CODE:
1781{
1782 RETVAL = THIS->option (optval);
1783
1784 if (set >= 0)
1785 {
1786 THIS->set_option (optval, set);
1787
1788 if (THIS->init_done) // avoid doing this before START
1789 switch (optval)
1790 {
1791 case Opt_skipBuiltinGlyphs:
1792 THIS->set_fonts ();
1793 THIS->scr_remap_chars ();
1794 THIS->scr_touch (true);
1795 THIS->want_refresh = 1;
1796 THIS->refresh_check ();
1797 break;
1798#ifdef CURSOR_BLINK
1799 case Opt_cursorBlink:
1800 THIS->cursor_blink_reset ();
1801 break;
1802#endif
1803
1804 case Opt_cursorUnderline:
1805 THIS->want_refresh = 1;
1806 THIS->refresh_check ();
1807 break;
1808
1809# case Opt_scrollBar_floating:
1810# case Opt_scrollBar_right:
1811# THIS->resize_all_windows (THIS->width, THIS->height, 1);
1812# break;
1813 }
1814 }
1815}
1816 OUTPUT:
1817 RETVAL
1818
1819bool
1820rxvt_term::parse_keysym (char *keysym, char *str)
1821 CODE:
1822 RETVAL = 0 < THIS->parse_keysym (keysym, str);
1823 THIS->keyboard->register_done ();
1824 OUTPUT:
1825 RETVAL
1826
1069void 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);
1833
1834void
1070rxvt_term::cur (...) 1835rxvt_term::screen_cur (...)
1071 PROTOTYPE: $;$$ 1836 PROTOTYPE: $;$$
1072 ALIAS: 1837 ALIAS:
1073 screen_cur = 0 1838 screen_cur = 0
1074 selection_beg = 1 1839 selection_beg = 1
1075 selection_end = 2 1840 selection_end = 2
… …
1086 EXTEND (SP, 2); 1851 EXTEND (SP, 2);
1087 PUSHs (sv_2mortal (newSViv (rc.row))); 1852 PUSHs (sv_2mortal (newSViv (rc.row)));
1088 PUSHs (sv_2mortal (newSViv (rc.col))); 1853 PUSHs (sv_2mortal (newSViv (rc.col)));
1089 } 1854 }
1090 1855
1091 if (items == 3) 1856 if (items >= 3)
1857 {
1858 rc.row = SvIV (ST (1));
1859 rc.col = SvIV (ST (2));
1860
1861 if (ix == 2)
1092 { 1862 {
1093 rc.row = clamp (SvIV (ST (1)), -THIS->nsaved, THIS->nrow - 1); 1863 if (rc.col == 0)
1094 rc.col = clamp (SvIV (ST (2)), 0, THIS->ncol - 1); 1864 {
1865 // col == 0 means end of previous line
1866 rc.row--;
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 }
1875 }
1876
1877 clamp_it (rc.col, 0, THIS->ncol);
1878 clamp_it (rc.row, THIS->top_row, THIS->nrow - 1);
1095 1879
1096 if (ix) 1880 if (ix)
1097 THIS->want_refresh = 1; 1881 {
1882 THIS->selection.screen = THIS->current_screen;
1883
1884 THIS->selection_changed ();
1885 THIS->refresh_check ();
1886 }
1098 } 1887 }
1099} 1888}
1100 1889
1101int 1890int
1102rxvt_term::selection_grab (int eventtime = CurrentTime) 1891rxvt_term::selection_screen (int screen = -1)
1892 CODE:
1893 RETVAL = THIS->selection.screen;
1894 if (screen >= 0)
1895 THIS->selection.screen = screen;
1896 OUTPUT:
1897 RETVAL
1103 1898
1104void 1899void
1900rxvt_term::selection_request (Time tm, int selnum)
1901
1902void
1903rxvt_term::selection_clear (bool clipboard = false)
1904
1905void
1906rxvt_term::selection_make (Time eventtime, bool rect = false)
1907 CODE:
1908 THIS->selection.op = SELECTION_CONT;
1909 THIS->selection.rect = rect;
1910 THIS->selection_make (eventtime);
1911
1912int
1913rxvt_term::selection_grab (Time eventtime, bool clipboard = false)
1914
1915void
1105rxvt_term::selection (SV *newtext = 0) 1916rxvt_term::selection (SV *newtext = 0, bool clipboard = false)
1106 PPCODE: 1917 PPCODE:
1107{ 1918{
1919 wchar_t * &text = clipboard ? THIS->selection.clip_text : THIS->selection.text;
1920 unsigned int &len = clipboard ? THIS->selection.clip_len : THIS->selection.len;
1921
1108 if (GIMME_V != G_VOID) 1922 if (GIMME_V != G_VOID)
1109 XPUSHs (sv_2mortal (wcs2sv (THIS->selection.text, THIS->selection.len))); 1923 XPUSHs (text
1924 ? sv_2mortal (wcs2sv (text, len))
1925 : &PL_sv_undef);
1110 1926
1111 if (newtext) 1927 if (newtext)
1112 { 1928 {
1113 free (THIS->selection.text); 1929 free (text);
1114 1930
1115 THIS->selection.text = sv2wcs (newtext); 1931 text = sv2wcs (newtext);
1116 THIS->selection.len = wcslen (THIS->selection.text); 1932 len = wcslen (text);
1117 } 1933 }
1118} 1934}
1935
1936char
1937rxvt_term::cur_charset ()
1938 CODE:
1939 RETVAL = THIS->charsets [THIS->screen.charset];
1940 OUTPUT:
1941 RETVAL
1942
1943void
1944rxvt_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)
1945
1946void
1947rxvt_term::scr_xor_span (int beg_row, int beg_col, int end_row, int end_col, U32 rstyle = RS_RVid)
1948
1949void
1950rxvt_term::scr_bell ()
1951
1952void
1953rxvt_term::scr_recolour (bool refresh = true);
1954
1955void
1956rxvt_term::scr_change_screen (int screen)
1119 1957
1120void 1958void
1121rxvt_term::scr_add_lines (SV *string) 1959rxvt_term::scr_add_lines (SV *string)
1122 CODE: 1960 CODE:
1123{ 1961{
… …
1133 char *str = SvPVbyte (octets, len); 1971 char *str = SvPVbyte (octets, len);
1134 C_ARGS: 1972 C_ARGS:
1135 str, len 1973 str, len
1136 1974
1137void 1975void
1976rxvt_term::tt_paste (SV *octets)
1977 INIT:
1978 STRLEN len;
1979 char *str = SvPVbyte (octets, len);
1980 C_ARGS:
1981 str, len
1982
1983void
1138rxvt_term::cmd_parse (SV *octets) 1984rxvt_term::cmd_parse (SV *octets)
1139 CODE: 1985 CODE:
1140{ 1986{
1141 STRLEN len; 1987 STRLEN len;
1142 char *str = SvPVbyte (octets, len); 1988 char *str = SvPVbyte (octets, len);
… …
1145 char *old_cmdbuf_endp = THIS->cmdbuf_endp; 1991 char *old_cmdbuf_endp = THIS->cmdbuf_endp;
1146 1992
1147 THIS->cmdbuf_ptr = str; 1993 THIS->cmdbuf_ptr = str;
1148 THIS->cmdbuf_endp = str + len; 1994 THIS->cmdbuf_endp = str + len;
1149 1995
1996 rxvt_push_locale (THIS->locale);
1150 THIS->cmd_parse (); 1997 THIS->cmd_parse ();
1998 rxvt_pop_locale ();
1151 1999
1152 THIS->cmdbuf_ptr = old_cmdbuf_ptr; 2000 THIS->cmdbuf_ptr = old_cmdbuf_ptr;
1153 THIS->cmdbuf_endp = old_cmdbuf_endp; 2001 THIS->cmdbuf_endp = old_cmdbuf_endp;
1154} 2002}
1155 2003
… …
1162 o->self = (HV *)SvRV (RETVAL); 2010 o->self = (HV *)SvRV (RETVAL);
1163} 2011}
1164 OUTPUT: 2012 OUTPUT:
1165 RETVAL 2013 RETVAL
1166 2014
2015#############################################################################
2016# Various X Utility Functions
2017#############################################################################
2018
2019void
2020rxvt_term::XListProperties (Window window)
2021 PPCODE:
2022{
2023 int count;
2024 Atom *props = XListProperties (THIS->dpy, window, &count);
2025
2026 EXTEND (SP, count);
2027 while (count--)
2028 PUSHs (newSVuv ((U32)props [count]));
2029
2030 XFree (props);
2031}
2032
2033void
2034rxvt_term::XGetWindowProperty (Window window, Atom property)
2035 PPCODE:
2036{
2037 Atom type;
2038 int format;
2039 unsigned long nitems;
2040 unsigned long bytes_after;
2041 unsigned char *prop;
2042
2043 XGetWindowProperty (THIS->dpy, window, property,
2044 0, 1<<24, 0, AnyPropertyType,
2045 &type, &format, &nitems, &bytes_after, &prop);
2046
2047 if (type != None)
2048 {
2049 int elemsize = format == 16 ? sizeof (short)
2050 : format == 32 ? sizeof (long)
2051 : 1;
2052
2053 EXTEND (SP, 3);
2054 PUSHs (newSVuv ((U32)type));
2055 PUSHs (newSViv (format));
2056 PUSHs (newSVpvn ((char *)prop, nitems * elemsize));
2057 XFree (prop);
2058 }
2059}
2060
2061void
2062rxvt_term::XChangeProperty (Window window, Atom property, Atom type, int format, SV *data)
2063 CODE:
2064{
2065 STRLEN len;
2066 char *data_ = SvPVbyte (data, len);
2067
2068 int elemsize = format == 16 ? sizeof (short)
2069 : format == 32 ? sizeof (long)
2070 : 1;
2071
2072 XChangeProperty (THIS->dpy, window, property,
2073 type, format, PropModeReplace,
2074 (unsigned char *)data_, len / elemsize);
2075}
2076
2077Atom
2078XInternAtom (rxvt_term *term, octet_string atom_name, int only_if_exists = FALSE)
2079 C_ARGS: term->dpy, atom_name, only_if_exists
2080
2081char *
2082XGetAtomName (rxvt_term *term, Atom atom)
2083 C_ARGS: term->dpy, atom
2084 CLEANUP:
2085 XFree (RETVAL);
2086
2087void
2088XDeleteProperty (rxvt_term *term, Window window, Atom property)
2089 C_ARGS: term->dpy, window, property
2090
2091Window
2092rxvt_term::DefaultRootWindow ()
2093 CODE:
2094 RETVAL = THIS->display->root;
2095 OUTPUT:
2096 RETVAL
2097
2098#if 0
2099
2100Window
2101XCreateSimpleWindow (rxvt_term *term, Window parent, int x, int y, unsigned int width, unsigned int height)
2102 C_ARGS: term->dpy, (Window)parent,
2103 x, y, width, height, 0,
2104 term->pix_colors_focused[Color_border],
2105 term->pix_colors_focused[Color_border]
2106
2107#endif
2108
2109void
2110XReparentWindow (rxvt_term *term, Window window, Window parent, int x = 0, int y = 0)
2111 C_ARGS: term->dpy, window, parent, x, y
2112
2113void
2114XMapWindow (rxvt_term *term, Window window)
2115 C_ARGS: term->dpy, window
2116
2117void
2118XUnmapWindow (rxvt_term *term, Window window)
2119 C_ARGS: term->dpy, window
2120
2121void
2122XMoveResizeWindow (rxvt_term *term, Window window, int x, int y, unsigned int width, unsigned int height)
2123 C_ARGS: term->dpy, window, x, y, width, height
2124
2125void
2126rxvt_term::XChangeInput (Window window, U32 add_events, U32 del_events = 0)
2127 CODE:
2128{
2129 XWindowAttributes attr;
2130 XGetWindowAttributes (THIS->dpy, window, &attr);
2131 XSelectInput (THIS->dpy, window, attr.your_event_mask | add_events & ~del_events);
2132}
2133
2134void
2135rxvt_term::XTranslateCoordinates (Window src, Window dst, int x, int y)
2136 PPCODE:
2137{
2138 int dx, dy;
2139 Window child;
2140
2141 if (XTranslateCoordinates (THIS->dpy, src, dst, x, y, &dx, &dy, &child))
2142 {
2143 EXTEND (SP, 3);
2144 PUSHs (newSViv (dx));
2145 PUSHs (newSViv (dy));
2146 PUSHs (newSVuv (child));
2147 }
2148}
2149
2150#############################################################################
2151# fancy bg bloatstuff (TODO: should be moved up somewhere)
2152
2153bool
2154rxvt_term::has_render ()
2155 CODE:
2156 RETVAL = THIS->display->flags & DISPLAY_HAS_RENDER;
2157 OUTPUT:
2158 RETVAL
2159
2160void
2161rxvt_term::background_geometry (bool border = false)
2162 PPCODE:
2163 EXTEND (SP, 4);
2164 PUSHs (sv_2mortal (newSViv (THIS->parent_x + (border ? THIS->window_vt_x : 0))));
2165 PUSHs (sv_2mortal (newSViv (THIS->parent_y + (border ? THIS->window_vt_y : 0))));
2166 PUSHs (sv_2mortal (newSViv (border ? THIS->vt_width : THIS->szHint.width )));
2167 PUSHs (sv_2mortal (newSViv (border ? THIS->vt_height : THIS->szHint.height)));
2168
2169#if HAVE_IMG
2170
2171rxvt_img *
2172rxvt_term::new_img (SV *format = &PL_sv_undef, int x = 0, int y = 0, int width = 1, int height = 1)
2173 CODE:
2174 XRenderPictFormat *f = SvOK (format)
2175 ? XRenderFindStandardFormat (THIS->dpy, SvIV (format))
2176 : XRenderFindVisualFormat (THIS->dpy, THIS->visual);
2177 RETVAL = new rxvt_img (THIS, f, x, y, width, height);
2178 RETVAL->alloc ();
2179 OUTPUT:
2180 RETVAL
2181
2182#if ENABLE_TRANSPARENCY
2183
2184rxvt_img *
2185rxvt_term::new_img_from_root ()
2186 CODE:
2187 RETVAL = rxvt_img::new_from_root (THIS);
2188 OUTPUT:
2189 RETVAL
2190
2191#endif
2192
2193#if HAVE_PIXBUF
2194
2195rxvt_img *
2196rxvt_term::new_img_from_file (octet_string filename)
2197 CODE:
2198 try
2199 {
2200 RETVAL = rxvt_img::new_from_file (THIS, filename);
2201 }
2202 catch (const class rxvt_failure_exception &e)
2203 {
2204 croak ("new_img_from_file failed");
2205 }
2206 OUTPUT:
2207 RETVAL
2208
2209#endif
2210
2211void
2212rxvt_term::set_background (rxvt_img *img, bool border = false)
2213 CODE:
2214 delete THIS->bg_img;
2215 THIS->bg_img = 0;
2216 THIS->bg_flags = 0;
2217
2218 if (img) // TODO: cannot be false
2219 {
2220 img = img->clone (); // own the img
2221
2222 if (img->repeat != RepeatNormal) // X11 only supports RepeatNormal as bg pixmap
2223 img->sub_rect (0, 0,
2224 border ? THIS->vt_width : THIS->szHint.width,
2225 border ? THIS->vt_height : THIS->szHint.height)
2226 ->replace (img);
2227
2228 // just in case, should usually be a nop
2229 img->reify ()
2230 ->replace (img);
2231
2232 img->convert_format (XRenderFindVisualFormat (THIS->dpy, THIS->visual), THIS->pix_colors [Color_bg])
2233 ->replace (img);
2234
2235 THIS->bg_img = img;
2236 THIS->bg_flags |= rxvt_term::BG_NEEDS_REFRESH | rxvt_term::BG_INHIBIT_RENDER;
2237
2238 if (!border)
2239 THIS->bg_flags |= rxvt_term::BG_IS_TRANSPARENT;
2240 }
2241
2242#endif
2243
2244#############################################################################
2245# urxvt::overlay
2246#############################################################################
2247
1167MODULE = urxvt PACKAGE = urxvt::overlay 2248MODULE = urxvt PACKAGE = urxvt::overlay
1168 2249
1169void 2250void
1170overlay::set (int x, int y, SV *text, SV *rend = 0) 2251overlay::set (int x, int y, SV *text, SV *rend = 0)
1171 2252
… …
1176overlay::hide () 2257overlay::hide ()
1177 2258
1178void 2259void
1179overlay::DESTROY () 2260overlay::DESTROY ()
1180 2261
2262INCLUDE: $PERL <iom_perl.xs -pe s/IOM_MODULE/urxvt/g,s/IOM_CLASS/urxvt/g |
2263
2264MODULE = urxvt PACKAGE = urxvt::pixbuf PREFIX = gdk_pixbuf_
2265
2266#if HAVE_PIXBUF
2267
2268urxvt::pixbuf gdk_pixbuf_new_from_file (SV *klass, octet_string filename)
2269 C_ARGS: filename, 0
2270
2271void
2272DESTROY (urxvt::pixbuf self)
2273 CODE:
2274 g_object_unref (self);
2275
2276#endif
2277
1181MODULE = urxvt PACKAGE = urxvt::timer 2278MODULE = urxvt PACKAGE = urxvt::img
1182 2279
1183SV * 2280#if HAVE_IMG
1184timer::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 ()
1185 CODE: 2287 PPCODE:
1186 timer *w = new timer; 2288 EXTEND (SP, 4);
1187 w->start (NOW); 2289 PUSHs (sv_2mortal (newSViv (THIS->x)));
1188 RETVAL = newSVptr ((void *)w, "urxvt::timer"); 2290 PUSHs (sv_2mortal (newSViv (THIS->y)));
1189 w->self = (HV *)SvRV (RETVAL); 2291 PUSHs (sv_2mortal (newSViv (THIS->w)));
1190 OUTPUT: 2292 PUSHs (sv_2mortal (newSViv (THIS->h)));
1191 RETVAL
1192 2293
1193timer * 2294int
1194timer::cb (SV *cb) 2295rxvt_img::x ()
2296 ALIAS:
2297 x = 0
2298 y = 1
2299 w = 2
2300 h = 3
1195 CODE: 2301 CODE:
1196 THIS->cb (cb); 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:
1197 RETVAL = THIS; 2310 RETVAL
1198 OUTPUT:
1199 RETVAL
1200 2311
1201NV 2312Pixmap
1202timer::at () 2313rxvt_img::pm ()
1203 CODE: 2314 CODE:
1204 RETVAL = THIS->at; 2315 RETVAL = THIS->pm;
1205 OUTPUT: 2316 OUTPUT:
1206 RETVAL 2317 RETVAL
1207 2318
1208timer * 2319void
1209timer::interval (NV interval) 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)
1210 CODE: 2339 PPCODE:
1211 THIS->interval = interval; 2340 if (items >= 2)
2341 THIS->repeat_mode (repeat);
2342 if (GIMME_V != G_VOID)
2343 XPUSHs (sv_2mortal (newSViv (THIS->repeat)));
2344
2345void
2346rxvt_img::move (int dx, int dy)
2347
2348void
2349rxvt_img::brightness (rxvt_img::nv r, rxvt_img::nv g, rxvt_img::nv b, rxvt_img::nv a = 1.)
2350
2351void
2352rxvt_img::contrast (rxvt_img::nv r, rxvt_img::nv g, rxvt_img::nv b, rxvt_img::nv a = 1.)
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::shade (rxvt_img::nv factor)
2396
2397rxvt_img *
2398rxvt_img::filter (octet_string name, SV *params = &PL_sv_undef)
2399 CODE:
2400 rxvt_img::nv *vparams = 0;
2401 int nparams = 0;
2402
2403 if (SvOK (params))
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_img::nv *)malloc (nparams * sizeof (rxvt_img::nv));
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 free (vparams);
2417 OUTPUT:
1212 RETVAL = THIS; 2418 RETVAL
1213 OUTPUT:
1214 RETVAL
1215 2419
1216timer * 2420#endif
1217timer::set (NV tstamp)
1218 CODE:
1219 THIS->set (tstamp);
1220 RETVAL = THIS;
1221 OUTPUT:
1222 RETVAL
1223 2421
1224timer *
1225timer::start (NV tstamp = THIS->at)
1226 CODE:
1227 THIS->start (tstamp);
1228 RETVAL = THIS;
1229 OUTPUT:
1230 RETVAL
1231
1232timer *
1233timer::stop ()
1234 CODE:
1235 THIS->stop ();
1236 RETVAL = THIS;
1237 OUTPUT:
1238 RETVAL
1239
1240void
1241timer::DESTROY ()
1242
1243MODULE = urxvt PACKAGE = urxvt::iow
1244
1245SV *
1246iow::new ()
1247 CODE:
1248 iow *w = new iow;
1249 RETVAL = newSVptr ((void *)w, "urxvt::iow");
1250 w->self = (HV *)SvRV (RETVAL);
1251 OUTPUT:
1252 RETVAL
1253
1254iow *
1255iow::cb (SV *cb)
1256 CODE:
1257 THIS->cb (cb);
1258 RETVAL = THIS;
1259 OUTPUT:
1260 RETVAL
1261
1262iow *
1263iow::fd (int fd)
1264 CODE:
1265 THIS->fd = fd;
1266 RETVAL = THIS;
1267 OUTPUT:
1268 RETVAL
1269
1270iow *
1271iow::events (short events)
1272 CODE:
1273 THIS->events = events;
1274 RETVAL = THIS;
1275 OUTPUT:
1276 RETVAL
1277
1278iow *
1279iow::start ()
1280 CODE:
1281 THIS->start ();
1282 RETVAL = THIS;
1283 OUTPUT:
1284 RETVAL
1285
1286iow *
1287iow::stop ()
1288 CODE:
1289 THIS->stop ();
1290 RETVAL = THIS;
1291 OUTPUT:
1292 RETVAL
1293
1294void
1295iow::DESTROY ()
1296
1297

Diff Legend

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