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.57 by root, Thu Jan 12 01:30:53 2006 UTC vs.
Revision 1.257 by root, Fri Dec 30 16:51:59 2022 UTC

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

Diff Legend

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