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.78 by root, Thu Jan 19 20:30:36 2006 UTC vs.
Revision 1.260 by root, Fri Jul 7 06:10:37 2023 UTC

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

Diff Legend

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