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.32 by root, Fri Jan 6 18:33:30 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
32#include <stddef.h>
31#include <cstdarg> 33#include <stdarg.h>
32 34
35#include <unistd.h>
36
37#include <X11/extensions/shape.h>
38
39// support old includes (https://bugs.freedesktop.org/show_bug.cgi?id=2799, https://lists.x.org/archives/xorg-arch/2005-March/000004.html)
40#ifndef ShapeInput
41# define ShapeInput 2
42#endif
43
44#include "ev_cpp.h"
33#include "rxvt.h" 45#include "rxvt.h"
34#include "iom.h" 46#include "keyboard.h"
35#include "rxvtutil.h" 47#include "rxvtutil.h"
36#include "rxvtperl.h" 48#include "rxvtperl.h"
37 49
38#include "perlxsi.c" 50#include "perlxsi.c"
51
52#define GRAB_CURSOR THIS->scrollBar.leftptr_cursor
39 53
40#undef LINENO 54#undef LINENO
41#define LINENO(n) MOD (THIS->term_start + int(n), THIS->total_rows) 55#define LINENO(n) MOD (THIS->term_start + int(n), THIS->total_rows)
42#undef ROW 56#undef ROW
43#define ROW(n) THIS->row_buf [LINENO (n)] 57#define ROW(n) THIS->row_buf [LINENO (n)]
44 58
45///////////////////////////////////////////////////////////////////////////// 59/////////////////////////////////////////////////////////////////////////////
46 60
61typedef char * octet_string;
62typedef char * utf8_string;
63
64typedef int render_repeat_mode;
65
66#if HAVE_PIXBUF
67typedef GdkPixbuf * urxvt__pixbuf;
68#endif
69#if HAVE_IMG
70typedef rxvt_img * urxvt__img;
71typedef rxvt_img::nv rxvt_img__nv;
72
73/////////////////////////////////////////////////////////////////////////////
74
75static rgba
76parse_rgba (SV *sv, rxvt_screen *s = 0)
77{
78 rgba c;
79
80 if (SvROK (sv))
81 {
82 AV *av = (AV *)SvRV (sv);
83
84 if (SvTYPE ((SV *)av) != SVt_PVAV)
85 croak ("colour must be either a colour string, or an array,");
86
87 int len = av_len (av) + 1;
88
89 if (len != 1 && len != 3 && len != 4)
90 croak ("component colour array must have 1, 3 or 4 components,");
91
92 c.a = rgba::MAX_CC;
93
94 c.r = c.g = c.b = float_to_component (SvNV (*av_fetch (av, 0, 0)));
95
96 if (len >= 3)
97 {
98 c.g = float_to_component (SvNV (*av_fetch (av, 1, 0)));
99 c.b = float_to_component (SvNV (*av_fetch (av, 2, 0)));
100
101 if (len >= 4)
102 c.a = float_to_component (SvNV (*av_fetch (av, 3, 0)));
103 }
104 }
105 else if (s)
106 {
107 rxvt_color rc;
108 rc.set (s, SvPVbyte_nolen (sv));
109 rc.get (c);
110 }
111 else
112 croak ("unable to parse colour,");
113
114 return c;
115}
116
117/////////////////////////////////////////////////////////////////////////////
118#endif
119
47static wchar_t * 120static wchar_t *
48sv2wcs (SV *sv) 121sv2wcs (SV *sv)
49{ 122{
50 STRLEN len; 123 STRLEN len;
51 char *str = SvPVutf8 (sv, len); 124 char *str = SvPVutf8 (sv, len);
… …
63 136
64 return sv; 137 return sv;
65} 138}
66 139
67static SV * 140static SV *
68new_ref (HV *hv, const char *klass)
69{
70 return sv_bless (newRV ((SV *)hv), gv_stashpv (klass, 1));
71}
72
73//TODO: use magic
74static SV *
75newSVptr (void *ptr, const char *klass) 141newSVptr (void *ptr, const char *klass)
76{ 142{
77 HV *hv = newHV (); 143 HV *hv = newHV ();
78 sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0); 144 sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);
79 return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1)); 145 return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
… …
101 croak ("perl code used %s object, but C++ object is already destroyed, caught", klass); 167 croak ("perl code used %s object, but C++ object is already destroyed, caught", klass);
102 168
103 return (long)mg->mg_ptr; 169 return (long)mg->mg_ptr;
104} 170}
105 171
106#define newSVterm(term) SvREFCNT_inc ((SV *)term->self) 172#define newSVterm(term) SvREFCNT_inc ((SV *)(term)->perl.self)
107#define SvTERM(sv) (rxvt_term *)SvPTR (sv, "urxvt::term") 173#define SvTERM(sv) (rxvt_term *)SvPTR ((sv), "urxvt::term")
108 174
109///////////////////////////////////////////////////////////////////////////// 175/////////////////////////////////////////////////////////////////////////////
110 176
111struct perl_watcher 177#define SvOVERLAY(sv) (overlay *)SvPTR (sv, "urxvt::overlay")
178
179class overlay : overlay_base
112{ 180{
113 SV *cbsv; 181 rxvt_term *THIS;
182 AV *overlay_av;
183 int border;
184
185public:
114 HV *self; 186 HV *self;
115
116 perl_watcher ()
117 : cbsv (newSV (0))
118 {
119 }
120
121 ~perl_watcher ()
122 {
123 SvREFCNT_dec (cbsv);
124 }
125
126 void cb (SV *cb)
127 {
128 sv_setsv (cbsv, cb);
129 }
130
131 void invoke (const char *type, SV *self, int arg = -1);
132};
133
134void
135perl_watcher::invoke (const char *type, SV *self, int arg)
136{
137 dSP;
138
139 ENTER;
140 SAVETMPS;
141
142 PUSHMARK (SP);
143
144 XPUSHs (sv_2mortal (self));
145
146 if (arg >= 0)
147 XPUSHs (sv_2mortal (newSViv (arg)));
148
149 PUTBACK;
150 call_sv (cbsv, G_VOID | G_EVAL | G_DISCARD);
151 SPAGAIN;
152
153 PUTBACK;
154 FREETMPS;
155 LEAVE;
156
157 if (SvTRUE (ERRSV))
158 rxvt_warn ("%s callback evaluation error: %s", type, SvPV_nolen (ERRSV));
159}
160
161#define newSVtimer(timer) new_ref (timer->self, "urxvt::timer")
162#define SvTIMER(sv) (timer *)SvPTR (sv, "urxvt::timer")
163
164struct timer : time_watcher, perl_watcher
165{
166 tstamp interval;
167
168 timer ()
169 : time_watcher (this, &timer::execute)
170 {
171 }
172
173 void execute (time_watcher &w)
174 {
175 if (interval)
176 start (at + interval);
177
178 invoke ("urxvt::timer", newSVtimer (this));
179 }
180};
181
182#define newSViow(iow) new_ref (iow->self, "urxvt::iow")
183#define SvIOW(sv) (iow *)SvPTR (sv, "urxvt::iow")
184
185struct iow : io_watcher, perl_watcher
186{
187 iow ()
188 : io_watcher (this, &iow::execute)
189 {
190 }
191
192 void execute (io_watcher &w, short revents)
193 {
194 invoke ("urxvt::iow", newSViow (this), revents);
195 }
196};
197
198/////////////////////////////////////////////////////////////////////////////
199
200#define SvOVERLAY(sv) (overlay *)SvPTR (sv, "urxvt::overlay")
201
202struct overlay {
203 HV *self;
204 rxvt_term *THIS;
205 int x, y, w, h;
206 int border;
207 text_t **text;
208 rend_t **rend;
209 187
210 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);
211 ~overlay (); 189 ~overlay ();
212 190
213 void show (); 191 void show ();
… …
217 195
218 void set (int x, int y, SV *str, SV *rend); 196 void set (int x, int y, SV *str, SV *rend);
219}; 197};
220 198
221overlay::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)
222: THIS(THIS), x(x_), y(y_), w(w_), h(h_), border(border == 2) 200: THIS(THIS), border(border == 2), overlay_av (0)
223{ 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
224 if (border == 2) 210 if (border == 2)
225 { 211 {
226 w += 2; 212 w += 2;
227 h += 2; 213 h += 2;
228 } 214 }
… …
266 *rp++ = r; 252 *rp++ = r;
267 } 253 }
268 } 254 }
269 255
270 show (); 256 show ();
271 THIS->want_refresh = 1;
272} 257}
273 258
274overlay::~overlay () 259overlay::~overlay ()
275{ 260{
276 hide (); 261 hide ();
… …
281 delete [] rend[y]; 266 delete [] rend[y];
282 } 267 }
283 268
284 delete [] text; 269 delete [] text;
285 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));
286 283
287 THIS->want_refresh = 1; 284 THIS->want_refresh = 1;
288} 285 THIS->refresh_check ();
289
290void
291overlay::show ()
292{
293 char key[33]; sprintf (key, "%32lx", (long)this);
294
295 HV *hv = (HV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)THIS->self), "_overlay", 8, 0));
296 hv_store (hv, key, 32, newSViv ((long)this), 0);
297} 286}
298 287
299void 288void
300overlay::hide () 289overlay::hide ()
301{ 290{
302 SV **ovs = hv_fetch ((HV *)SvRV ((SV *)THIS->self), "_overlay", 8, 0); 291 if (!overlay_av)
292 return;
303 293
304 if (ovs) 294 int i;
305 {
306 char key[33]; sprintf (key, "%32lx", (long)this);
307 295
308 HV *hv = (HV *)SvRV (*ovs); 296 for (i = AvFILL (overlay_av); i >= 0; i--)
309 hv_delete (hv, key, 32, G_DISCARD); 297 if (SvIV (*av_fetch (overlay_av, i, 1)) == (long)this)
310 } 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 ();
311} 310}
312 311
313void overlay::swap () 312void overlay::swap ()
314{ 313{
315 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));
316 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));
317 316
318 int ov_w = min (w, THIS->ncol - ov_x); 317 int ov_w = min (w, THIS->ncol - ov_x);
319 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;
320 324
321 for (int y = ov_h; y--; ) 325 for (int y = ov_h; y--; )
322 { 326 {
323 text_t *t1 = text [y]; 327 text_t *t1 = text [y];
324 rend_t *r1 = rend [y]; 328 rend_t *r1 = rend [y];
325 329
326 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;
327 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;
328 332
329 for (int x = ov_w; x--; ) 333 for (int x = ov_w; x--; )
330 { 334 {
331 text_t t = *t1; *t1++ = *t2; *t2++ = t; 335 text_t t = *t1; *t1++ = *t2; *t2++ = t;
332 rend_t r = *r1; *r1++ = *r2; *r2++ = SET_FONT (r, THIS->fontset [GET_STYLE (r)]->find_font (t)); 336 rend_t r = *r1; *r1++ = *r2; *r2++ = SET_FONT (r, THIS->fontset [GET_STYLE (r)]->find_font (t));
… …
355 if (!SvROK (rend) || SvTYPE (SvRV (rend)) != SVt_PVAV) 359 if (!SvROK (rend) || SvTYPE (SvRV (rend)) != SVt_PVAV)
356 croak ("rend must be arrayref"); 360 croak ("rend must be arrayref");
357 361
358 AV *av = (AV *)SvRV (rend); 362 AV *av = (AV *)SvRV (rend);
359 363
360 for (int col = min (av_len (av) + 1, w - x - border); col--; ) 364 for (int col = min (AvFILL (av) + 1, w - x - border); col--; )
361 this->rend [y][x + col] = SvIV (*av_fetch (av, col, 1)); 365 this->rend [y][x + col] = SvIV (*av_fetch (av, col, 1));
362 } 366 }
363 367
364 THIS->want_refresh = 1; 368 THIS->want_refresh = 1;
369 THIS->refresh_check ();
365} 370}
366
367 371
368///////////////////////////////////////////////////////////////////////////// 372/////////////////////////////////////////////////////////////////////////////
369 373
374#include "iom_perl.h"
375
376/////////////////////////////////////////////////////////////////////////////
377
370struct rxvt_perl_interp rxvt_perl; 378struct rxvt_perl_interp rxvt_perl;
371 379
372static PerlInterpreter *perl; 380static PerlInterpreter *perl;
373 381
374rxvt_perl_interp::rxvt_perl_interp () 382#if 0 /* we are not a library anymore, so doing this is just not worth it */
375{ 383/*THINK/TODO: this has the side effect of, of course, not calling destructors. */
376} 384/* but therse are not guaranteed anyway... */
377
378rxvt_perl_interp::~rxvt_perl_interp () 385rxvt_perl_interp::~rxvt_perl_interp ()
379{ 386{
380 if (perl) 387 if (perl)
381 { 388 {
389 localise_env set_environ (perl_environ);
382 perl_destruct (perl); 390 perl_destruct (perl);
383 perl_free (perl); 391 perl_free (perl);
392 PERL_SYS_TERM ();
384 } 393 }
385} 394}
395#endif
386 396
387void 397void
388rxvt_perl_interp::init () 398rxvt_perl_interp::init ()
389{ 399{
390 if (!perl) 400 if (!perl)
391 { 401 {
402 rxvt_push_locale (""); // perl init destroys current locale
403
404 {
405 perl_environ = rxvt_environ;
406 localise_env set_environ (perl_environ);
407
392 char *argv[] = { 408 const char *args[] = {
393 "", 409 "",
394 "-edo '" LIBDIR "/urxvt.pm' or ($@ and die $@) or exit 1", 410 "-e"
411 "BEGIN {"
412 " urxvt->bootstrap;"
413 " unshift @INC, '" LIBDIR "';"
414 "}"
415 ""
416 "use urxvt;",
417 0
395 }; 418 };
419 int argc = ecb_array_length (args) - 1;
420 char **argv = (char **)args;
396 421
422 PERL_SYS_INIT3 (&argc, &argv, &environ);
397 perl = perl_alloc (); 423 perl = perl_alloc ();
398 perl_construct (perl); 424 perl_construct (perl);
399 425
400 if (perl_parse (perl, xs_init, 2, argv, (char **)NULL) 426 if (perl_parse (perl, xs_init, argc, argv, (char **)NULL)
401 || perl_run (perl)) 427 || perl_run (perl))
428 {
429 rxvt_warn ("unable to initialize perl-interpreter, continuing without.\n");
430
431 perl_destruct (perl);
432 perl_free (perl);
433 perl = 0;
434 }
435 }
436
437 rxvt_pop_locale ();
438 }
439}
440
441void
442rxvt_perl_interp::init (rxvt_term *term)
443{
444 init ();
445
446 if (perl && !term->perl.self)
447 {
448 // runs outside of perls ENV
449 term->perl.self = (void *)newSVptr ((void *)term, "urxvt::term");
450 hv_store ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, newRV_noinc ((SV *)newAV ()), 0);
451 hv_store ((HV *)SvRV ((SV *)term->perl.self), "_selection", 10, newRV_noinc ((SV *)newAV ()), 0);
452 }
453}
454
455void
456rxvt_perl_interp::eval (const char *str)
457{
458 eval_pv (str, 1);
459}
460
461void
462rxvt_perl_interp::usage (rxvt_term *term, int type)
463{
464 localise_env set_environ (perl_environ);
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);
527}
528
529static void
530ungrab (rxvt_term *THIS)
531{
532 if (THIS->perl.grabtime)
533 {
534 XUngrabKeyboard (THIS->dpy, THIS->perl.grabtime);
535 XUngrabPointer (THIS->dpy, THIS->perl.grabtime);
536 THIS->perl.grabtime = 0;
537 }
538}
539
540bool
541rxvt_perl_interp::invoke (rxvt_term *term, int htype, ...)
542{
543 if (!perl || !term->perl.self)
544 return false;
545
546 localise_env set_environ (perl_environ);
547
548 // pre-handling of some events
549 if (htype == HOOK_REFRESH_END)
550 {
551 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, 0));
552
553 for (int i = 0; i <= AvFILL (av); i++)
554 ((overlay *)SvIV (*av_fetch (av, i, 0)))->swap ();
555 }
556 else if (htype == HOOK_DESTROY)
557 {
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--)
402 { 561 {
403 rxvt_warn ("unable to initialize perl-interpreter, continuing without.\n"); 562 rxvt_selection *req = (rxvt_selection *)SvIV (*av_fetch (av, i, 0));
404 563 delete req;
405 perl_destruct (perl);
406 perl_free (perl);
407 perl = 0;
408 } 564 }
409 } 565 }
410}
411 566
412bool 567 bool event_consumed;
413rxvt_perl_interp::invoke (rxvt_term *term, hook_type htype, ...)
414{
415 if (!perl)
416 return false;
417 568
418 if (htype == HOOK_INIT) // first hook ever called 569 if (term->perl.should_invoke [htype])
419 { 570 {
420 term->self = (void *)newSVptr ((void *)term, "urxvt::term"); 571 dSP;
421 hv_store ((HV *)SvRV ((SV *)term->self), "_overlay", 8, newRV_noinc ((SV *)newHV ()), 0); 572 va_list ap;
573
574 va_start (ap, htype);
575
576 ENTER;
577 SAVETMPS;
578
579 PUSHMARK (SP);
580
581 EXTEND (SP, 2);
582 PUSHs (sv_2mortal (newSVterm (term)));
583 PUSHs (sv_2mortal (newSViv (htype)));
584
585 for (;;) {
586 data_type dt = (data_type)va_arg (ap, int);
587
588 switch (dt)
589 {
590 case DT_INT:
591 XPUSHs (sv_2mortal (newSViv (va_arg (ap, int))));
592 break;
593
594 case DT_LONG:
595 XPUSHs (sv_2mortal (newSViv (va_arg (ap, long))));
596 break;
597
598 case DT_STR:
599 XPUSHs (sv_2mortal (newSVpv (va_arg (ap, char *), 0)));
600 break;
601
602 case DT_STR_LEN:
603 {
604 char *str = va_arg (ap, char *);
605 int len = va_arg (ap, int);
606
607 XPUSHs (sv_2mortal (newSVpvn (str, len)));
608 }
609 break;
610
611 case DT_WCS_LEN:
612 {
613 wchar_t *wstr = va_arg (ap, wchar_t *);
614 int wlen = va_arg (ap, int);
615
616 XPUSHs (sv_2mortal (wcs2sv (wstr, wlen)));
617 }
618 break;
619
620 case DT_LCS_LEN:
621 {
622 long *lstr = va_arg (ap, long *);
623 int llen = va_arg (ap, int);
624
625 XPUSHs (sv_2mortal (newSVpvn ((char *)lstr, llen * sizeof (long))));
626 }
627 break;
628
629 case DT_XEVENT:
630 {
631 XEvent *xe = va_arg (ap, XEvent *);
632 HV *hv = newHV ();
633
634# define set(name, sv) hv_store (hv, # name, sizeof (# name) - 1, sv, 0)
635# define setiv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSViv (val), 0)
636# define setuv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSVuv (val), 0)
637# undef set
638
639 setiv (type, xe->type);
640 setiv (send_event, xe->xany.send_event);
641 setiv (serial, xe->xany.serial);
642
643 switch (xe->type)
644 {
645 case KeyPress:
646 case KeyRelease:
647 case ButtonPress:
648 case ButtonRelease:
649 case MotionNotify:
650 setuv (window, xe->xmotion.window);
651 setuv (root, xe->xmotion.root);
652 setuv (subwindow, xe->xmotion.subwindow);
653 setuv (time, xe->xmotion.time);
654 setiv (x, xe->xmotion.x);
655 setiv (y, xe->xmotion.y);
656 setiv (row, xe->xmotion.y / term->fheight + term->view_start);
657 setiv (col, xe->xmotion.x / term->fwidth);
658 setiv (x_root, xe->xmotion.x_root);
659 setiv (y_root, xe->xmotion.y_root);
660 setuv (state, xe->xmotion.state);
661
662 switch (xe->type)
663 {
664 case KeyPress:
665 case KeyRelease:
666 setuv (keycode, xe->xkey.keycode);
667 break;
668
669 case ButtonPress:
670 case ButtonRelease:
671 setuv (button, xe->xbutton.button);
672 break;
673
674 case MotionNotify:
675 setiv (is_hint, xe->xmotion.is_hint);
676 break;
677 }
678
679 break;
680
681 case MapNotify:
682 case UnmapNotify:
683 case ConfigureNotify:
684 setuv (event, xe->xconfigure.event);
685 setuv (window, xe->xconfigure.window);
686
687 switch (xe->type)
688 {
689 case ConfigureNotify:
690 setiv (x, xe->xconfigure.x);
691 setiv (y, xe->xconfigure.y);
692 setiv (width, xe->xconfigure.width);
693 setiv (height, xe->xconfigure.height);
694 setuv (above, xe->xconfigure.above);
695 break;
696 }
697
698 break;
699
700 case PropertyNotify:
701 setuv (window, xe->xproperty.window);
702 setuv (atom, xe->xproperty.atom);
703 setuv (time, xe->xproperty.time);
704 setiv (state, xe->xproperty.state);
705 break;
706
707 case ClientMessage:
708 setuv (window, xe->xclient.window);
709 setuv (message_type, xe->xclient.message_type);
710 setuv (format, xe->xclient.format);
711 setuv (l0, xe->xclient.data.l[0]);
712 setuv (l1, xe->xclient.data.l[1]);
713 setuv (l2, xe->xclient.data.l[2]);
714 setuv (l3, xe->xclient.data.l[3]);
715 setuv (l4, xe->xclient.data.l[4]);
716 break;
717 }
718
719 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
720 }
721 break;
722
723 case DT_END:
724 goto call;
725
726 default:
727 rxvt_fatal ("FATAL: unable to pass data type %d\n", dt);
728 }
729 }
730
731 call:
732 va_end (ap);
733
734 PUTBACK;
735 int count = call_pv ("urxvt::invoke", G_ARRAY | G_EVAL);
736 SPAGAIN;
737
738 if (count)
739 {
740 SV *status = POPs;
741 count = SvTRUE (status);
742 }
743
744 PUTBACK;
745 FREETMPS;
746 LEAVE;
747
748 if (SvTRUE (ERRSV))
749 {
750 rxvt_warn ("perl hook %d evaluation error: %s", htype, SvPVbyte_nolen (ERRSV));
751 ungrab (term); // better lose the grab than the session
752 }
753
754 event_consumed = !!count;
422 } 755 }
423 else if (!term->self) 756 else
424 return false; // perl not initialized for this instance 757 event_consumed = false;
758
759 // post-handling of some events
760 if (htype == HOOK_REFRESH_BEGIN)
761 {
762 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, 0));
763
764 for (int i = AvFILL (av); i >= 0; i--)
765 ((overlay *)SvIV (*av_fetch (av, i, 0)))->swap ();
766 }
425 else if (htype == HOOK_DESTROY) 767 else if (htype == HOOK_DESTROY)
426 { 768 {
427 // handled later 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;
428 } 774 }
429 else if (htype == HOOK_REFRESH_BEGIN || htype == HOOK_REFRESH_END)
430 {
431 HV *hv = (HV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->self), "_overlay", 8, 0));
432 775
433 if (HvKEYS (hv)) 776 return event_consumed;
434 { 777}
435 hv_iterinit (hv);
436 778
437 while (HE *he = hv_iternext (hv)) 779void
438 ((overlay *)SvIV (hv_iterval (hv, he)))->swap (); 780rxvt_perl_interp::selection_finish (rxvt_selection *sel, char *data, unsigned int len)
439 } 781{
440 } 782 localise_env set_environ (perl_environ);
441 else if (!should_invoke [htype])
442 return false;
443
444 dSP;
445 va_list ap;
446
447 va_start (ap, htype);
448 783
449 ENTER; 784 ENTER;
450 SAVETMPS; 785 SAVETMPS;
451 786
452 PUSHMARK (SP); 787 dSP;
453
454 XPUSHs (sv_2mortal (newSVterm (term)));
455 XPUSHs (sv_2mortal (newSViv (htype)));
456
457 for (;;) {
458 data_type dt = (data_type)va_arg (ap, int);
459
460 switch (dt)
461 {
462 case DT_INT:
463 XPUSHs (sv_2mortal (newSViv (va_arg (ap, int))));
464 break;
465
466 case DT_LONG:
467 XPUSHs (sv_2mortal (newSViv (va_arg (ap, long))));
468 break;
469
470 case DT_STR:
471 XPUSHs (sv_2mortal (newSVpv (va_arg (ap, char *), 0)));
472 break;
473
474 case DT_STR_LEN:
475 {
476 char *str = va_arg (ap, char *);
477 int len = va_arg (ap, int);
478
479 XPUSHs (sv_2mortal (newSVpvn (str, len))); 788 XPUSHs (sv_2mortal (newSVpvn (data, len)));
480 } 789 PUTBACK;
481 break; 790 call_sv ((SV *)sel->cb_sv, G_VOID | G_DISCARD | G_EVAL);
482 791
483 case DT_WCS_LEN:
484 {
485 wchar_t *wstr = va_arg (ap, wchar_t *);
486 int wlen = va_arg (ap, int);
487
488 XPUSHs (sv_2mortal (wcs2sv (wstr, wlen)));
489 }
490
491 case DT_XEVENT:
492 {
493 XEvent *xe = va_arg (ap, XEvent *);
494 HV *hv = newHV ();
495
496# define set(name, sv) hv_store (hv, # name, sizeof (# name) - 1, sv, 0)
497# define setiv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSViv (val), 0)
498# undef set
499
500 setiv (type, xe->type);
501 setiv (send_event, xe->xany.send_event);
502 setiv (serial, xe->xany.serial);
503
504 switch (xe->type)
505 {
506 case KeyPress:
507 case KeyRelease:
508 case ButtonPress:
509 case ButtonRelease:
510 case MotionNotify:
511 setiv (time, xe->xmotion.time);
512 setiv (x, xe->xmotion.x);
513 setiv (y, xe->xmotion.y);
514 setiv (row, xe->xmotion.y / term->fheight);
515 setiv (col, xe->xmotion.x / term->fwidth);
516 setiv (x_root, xe->xmotion.x_root);
517 setiv (y_root, xe->xmotion.y_root);
518 setiv (state, xe->xmotion.state);
519 break;
520 }
521
522 switch (xe->type)
523 {
524 case KeyPress:
525 case KeyRelease:
526 setiv (keycode, xe->xkey.keycode);
527 break;
528
529 case ButtonPress:
530 case ButtonRelease:
531 setiv (button, xe->xbutton.button);
532 break;
533
534 case MotionNotify:
535 setiv (is_hint, xe->xmotion.is_hint);
536 break;
537 }
538
539 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
540 }
541 break;
542
543 case DT_END:
544 {
545 va_end (ap);
546
547 PUTBACK;
548 int count = call_pv ("urxvt::invoke", G_ARRAY | G_EVAL);
549 SPAGAIN;
550
551 if (count)
552 {
553 SV *status = POPs;
554 count = SvTRUE (status);
555 }
556
557 PUTBACK;
558 FREETMPS;
559 LEAVE;
560
561 if (SvTRUE (ERRSV)) 792 if (SvTRUE (ERRSV))
562 rxvt_warn ("perl hook %d evaluation error: %s", htype, SvPV_nolen (ERRSV)); 793 rxvt_warn ("perl selection callback evaluation error: %s", SvPVbyte_nolen (ERRSV));
563 794
564 if (htype == HOOK_DESTROY) 795 FREETMPS;
565 { 796 LEAVE;
566 clearSVptr ((SV *)term->self);
567 SvREFCNT_dec ((SV *)term->self);
568 }
569
570 return count;
571 }
572
573 default:
574 rxvt_fatal ("FATAL: unable to pass data type %d\n", dt);
575 }
576 }
577} 797}
578 798
579///////////////////////////////////////////////////////////////////////////// 799/////////////////////////////////////////////////////////////////////////////
580 800
581MODULE = urxvt PACKAGE = urxvt 801MODULE = urxvt PACKAGE = urxvt
582 802
583PROTOTYPES: ENABLE 803PROTOTYPES: ENABLE
584 804
585BOOT: 805BOOT:
586{ 806{
587# define export_const(name) newCONSTSUB (gv_stashpv ("urxvt", 1), # name, newSViv (name)); 807 sv_setsv (get_sv ("urxvt::LIBDIR", 1), newSVpvn (LIBDIR, sizeof (LIBDIR) - 1));
808 sv_setsv (get_sv ("urxvt::RESNAME", 1), newSVpvn (RESNAME, sizeof (RESNAME) - 1));
809 sv_setsv (get_sv ("urxvt::RESCLASS", 1), newSVpvn (RESCLASS, sizeof (RESCLASS) - 1));
810 sv_setsv (get_sv ("urxvt::RXVTNAME", 1), newSVpvn (RXVTNAME, sizeof (RXVTNAME) - 1));
811
588 AV *hookname = get_av ("urxvt::HOOKNAME", 1); 812 AV *hookname = get_av ("urxvt::HOOKNAME", 1);
589# define def(sym) av_store (hookname, HOOK_ ## sym, newSVpv (# sym, 0)); 813# define def(sym) av_store (hookname, HOOK_ ## sym, newSVpv (# sym, 0));
590# include "hookinc.h" 814# include "hookinc.h"
591# undef def 815# undef def
592 816
817 HV *option = get_hv ("urxvt::OPTION", 1);
818# define def(name) hv_store (option, # name, sizeof (# name) - 1, newSVuv (Opt_ ## name), 0);
819# define nodef(name)
820# include "optinc.h"
821# undef nodef
822# undef def
823
824 HV *stash = gv_stashpv ("urxvt", 1);
825 static const struct {
826 const char *name;
827 IV iv;
828 } *civ, const_iv[] = {
829# define const_iv(name) { # name, (IV)name }
830 const_iv (HOOK_INIT),
831 const_iv (HOOK_DESTROY),
832 const_iv (HOOK_ACTION),
833 const_iv (HOOK_OSC_SEQ),
834 const_iv (HOOK_OSC_SEQ_PERL),
835
836 const_iv (NUM_RESOURCES),
593 export_const (DEFAULT_RSTYLE); 837 const_iv (DEFAULT_RSTYLE),
594 export_const (OVERLAY_RSTYLE); 838 const_iv (OVERLAY_RSTYLE),
595 export_const (RS_Bold); 839 const_iv (Color_Bits),
596 export_const (RS_Italic); 840 const_iv (RS_bgShift), const_iv (RS_bgMask),
597 export_const (RS_Blink); 841 const_iv (RS_fgShift), const_iv (RS_fgMask),
598 export_const (RS_RVid); 842 const_iv (RS_Careful),
599 export_const (RS_Uline); 843 const_iv (RS_fontCount),
844 const_iv (RS_fontShift),
845 const_iv (RS_fontMask),
846 const_iv (RS_baseattrMask),
847 const_iv (RS_attrMask),
848 const_iv (RS_redraw),
849 const_iv (RS_Sel),
850 const_iv (RS_Bold),
851 const_iv (RS_Italic),
852 const_iv (RS_Blink),
853 const_iv (RS_RVid),
854 const_iv (RS_Uline),
600 855
601 sv_setpv (get_sv ("urxvt::LIBDIR", 1), LIBDIR); 856 // TODO: should support all colour constants, create colorinc.h &c
602} 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),
603 867
604SV * 868 const_iv (CurrentTime),
605new (...) 869 const_iv (ShiftMask),
606 CODE: 870 const_iv (LockMask),
607{ 871 const_iv (ControlMask),
608 stringvec *argv = new stringvec; 872 const_iv (Mod1Mask),
609 bool success; 873 const_iv (Mod2Mask),
874 const_iv (Mod3Mask),
875 const_iv (Mod4Mask),
876 const_iv (Mod5Mask),
877 const_iv (Button1Mask),
878 const_iv (Button2Mask),
879 const_iv (Button3Mask),
880 const_iv (Button4Mask),
881 const_iv (Button5Mask),
882 const_iv (AnyModifier),
610 883
611 for (int i = 0; i < items ;i++) 884 const_iv (NoSymbol),
612 argv->push_back (strdup (SvPVbyte_nolen (ST (i)))); 885 const_iv (GrabModeSync),
886 const_iv (GrabModeAsync),
613 887
614 rxvt_term *term = new rxvt_term; 888 const_iv (NoEventMask),
889 const_iv (KeyPressMask),
890 const_iv (KeyReleaseMask),
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),
615 914
616 term->argv = argv; 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),
617 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
1089void
1090log (utf8_string msg)
1091 CODE:
1092 rxvt_log ("%s", msg);
1093
1094void
1095warn (utf8_string msg)
1096 CODE:
1097 rxvt_warn ("%s", msg);
1098
1099void
1100fatal (utf8_string msg)
1101 CODE:
1102 rxvt_fatal ("%s", msg);
1103
1104void
1105_exit (int status)
1106
1107void
1108catch_fatal (SV *block)
1109 PROTOTYPE: &
1110 CODE:
618 try 1111 try
619 { 1112 {
620 if (!term->init (argv->size (), argv->begin ())) 1113 PUSHMARK (SP);
621 term = 0; 1114 PUTBACK;
1115 call_sv (block, G_VOID | G_DISCARD);
1116 SPAGAIN;
622 } 1117 }
623 catch (const class rxvt_failure_exception &e) 1118 catch (const rxvt_failure_exception &e)
624 {
625 term->destroy ();
626 croak ("exception caught while initializing new terminal instance");
627 } 1119 {
628 1120 croak ("rxvt_fatal exception caught, trying to continue.");
629 RETVAL = term && term->self ? newSVterm (term) : &PL_sv_undef; 1121 }
630}
631 OUTPUT:
632 RETVAL
633
634void
635set_should_invoke (int htype, int value)
636 CODE:
637 rxvt_perl.should_invoke [htype] = value;
638
639void
640warn (const char *msg)
641 CODE:
642 rxvt_warn ("%s", msg);
643
644void
645fatal (const char *msg)
646 CODE:
647 rxvt_fatal ("%s", msg);
648 1122
649NV 1123NV
650NOW () 1124NOW ()
651 CODE: 1125 CODE:
652 RETVAL = NOW; 1126 RETVAL = ev::now ();
653 OUTPUT: 1127 OUTPUT:
654 RETVAL 1128 RETVAL
655 1129
656int 1130int
657GET_BASEFG (int rend) 1131GET_BASEFG (int rend)
… …
668 RETVAL 1142 RETVAL
669 1143
670int 1144int
671SET_FGCOLOR (int rend, int new_color) 1145SET_FGCOLOR (int rend, int new_color)
672 CODE: 1146 CODE:
673 RETVAL = SET_FGCOLOR (rend, new_color); 1147 RETVAL = SET_FGCOLOR (rend, clamp (new_color, 0, TOTAL_COLORS - 1));
674 OUTPUT: 1148 OUTPUT:
675 RETVAL 1149 RETVAL
676 1150
677int 1151int
678SET_BGCOLOR (int rend, int new_color) 1152SET_BGCOLOR (int rend, int new_color)
679 CODE: 1153 CODE:
680 RETVAL = SET_BGCOLOR (rend, new_color); 1154 RETVAL = SET_BGCOLOR (rend, clamp (new_color, 0, TOTAL_COLORS - 1));
681 OUTPUT: 1155 OUTPUT:
682 RETVAL 1156 RETVAL
683 1157
684int 1158int
685GET_CUSTOM (int rend) 1159GET_CUSTOM (int rend)
686 CODE: 1160 CODE:
687 RETVAL = (rend && RS_customMask) >> RS_customShift; 1161 RETVAL = (rend & RS_customMask) >> RS_customShift;
688 OUTPUT: 1162 OUTPUT:
689 RETVAL 1163 RETVAL
690 1164
691int 1165int
692SET_CUSTOM (int rend, int new_value) 1166SET_CUSTOM (int rend, int new_value)
693 CODE: 1167 CODE:
694{ 1168{
695 if (!IN_RANGE_EXC (new_value, 0, RS_customCount)) 1169 if (!IN_RANGE_EXC (new_value, 0, RS_customCount))
696 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);
697 1171
698 RETVAL = (rend & ~RS_customMask) 1172 RETVAL = (rend & ~RS_customMask)
699 | ((new_value << RS_customShift) & RS_customMask); 1173 | ((new_value << RS_customShift) & RS_customMask);
700} 1174}
701 OUTPUT: 1175 OUTPUT:
702 RETVAL 1176 RETVAL
703 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
704MODULE = urxvt PACKAGE = urxvt::term 1218MODULE = urxvt PACKAGE = urxvt::term
705 1219
1220SV *
1221_new (AV *env, AV *arg)
1222 CODE:
1223{
1224 rxvt_term *term = new rxvt_term;
1225
1226 stringvec *argv = new stringvec;
1227 for (int i = 0; i <= AvFILL (arg); i++)
1228 argv->push_back (strdup (SvPVbyte_nolen (*av_fetch (arg, i, 1))));
1229
1230 stringvec *envv = new stringvec;
1231 for (int i = AvFILL (env) + 1; i--; )
1232 envv->push_back (strdup (SvPVbyte_nolen (*av_fetch (env, i, 1))));
1233
1234 try
1235 {
1236 term->init (argv, envv);
1237 }
1238 catch (const class rxvt_failure_exception &e)
1239 {
1240 term->destroy ();
1241 croak ("error while initializing new terminal instance");
1242 }
1243
1244 RETVAL = term && term->perl.self
1245 ? newSVterm (term) : &PL_sv_undef;
1246}
1247 OUTPUT:
1248 RETVAL
1249
706void 1250void
707rxvt_term::destroy () 1251rxvt_term::destroy ()
708 1252
1253void
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 ()
1277 PPCODE:
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,
1286 ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
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);
1306
1307bool
1308rxvt_term::grab (Time eventtime, int sync = 0)
1309 CODE:
1310{
1311 int mode = sync ? GrabModeSync : GrabModeAsync;
1312
1313 THIS->perl.grabtime = 0;
1314
1315 if (!XGrabPointer (THIS->dpy, THIS->vt, 0,
1316 ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
1317 mode, mode, None, GRAB_CURSOR, eventtime))
1318 if (!XGrabKeyboard (THIS->dpy, THIS->vt, 0, mode, mode, eventtime))
1319 THIS->perl.grabtime = eventtime;
1320 else
1321 XUngrabPointer (THIS->dpy, eventtime);
1322
1323 RETVAL = !!THIS->perl.grabtime;
1324}
1325 OUTPUT:
1326 RETVAL
1327
1328void
1329rxvt_term::allow_events_async ()
1330 CODE:
1331 XAllowEvents (THIS->dpy, AsyncBoth, THIS->perl.grabtime);
1332
1333void
1334rxvt_term::allow_events_sync ()
1335 CODE:
1336 XAllowEvents (THIS->dpy, SyncBoth, THIS->perl.grabtime);
1337
1338void
1339rxvt_term::allow_events_replay ()
1340 CODE:
1341 XAllowEvents (THIS->dpy, ReplayPointer, THIS->perl.grabtime);
1342 XAllowEvents (THIS->dpy, ReplayKeyboard, THIS->perl.grabtime);
1343
1344void
1345rxvt_term::ungrab ()
1346 CODE:
1347 ungrab (THIS);
1348
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
709int 1373int
710rxvt_term::strwidth (SV *str) 1374rxvt_term::strwidth (SV *str)
711 CODE: 1375 CODE:
712{ 1376{
713 wchar_t *wstr = sv2wcs (str); 1377 wchar_t *wstr = sv2wcs (str);
714 1378
715 rxvt_push_locale (THIS->locale); 1379 rxvt_push_locale (THIS->locale);
716 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 }
717 rxvt_pop_locale (); 1388 rxvt_pop_locale ();
718 1389
719 free (wstr); 1390 free (wstr);
720} 1391}
721 OUTPUT: 1392 OUTPUT:
… …
723 1394
724SV * 1395SV *
725rxvt_term::locale_encode (SV *str) 1396rxvt_term::locale_encode (SV *str)
726 CODE: 1397 CODE:
727{ 1398{
1399 if (!SvOK (str))
1400 XSRETURN_UNDEF;
1401
728 wchar_t *wstr = sv2wcs (str); 1402 wchar_t *wstr = sv2wcs (str);
729 1403
730 rxvt_push_locale (THIS->locale); 1404 rxvt_push_locale (THIS->locale);
731 char *mbstr = rxvt_wcstombs (wstr); 1405 char *mbstr = rxvt_wcstombs (wstr);
732 rxvt_pop_locale (); 1406 rxvt_pop_locale ();
… …
741 1415
742SV * 1416SV *
743rxvt_term::locale_decode (SV *octets) 1417rxvt_term::locale_decode (SV *octets)
744 CODE: 1418 CODE:
745{ 1419{
1420 if (!SvOK (octets))
1421 XSRETURN_UNDEF;
1422
746 STRLEN len; 1423 STRLEN len;
747 char *data = SvPVbyte (octets, len); 1424 char *data = SvPVbyte (octets, len);
748 1425
749 rxvt_push_locale (THIS->locale); 1426 rxvt_push_locale (THIS->locale);
750 wchar_t *wstr = rxvt_mbstowcs (data, len); 1427 wchar_t *wstr = rxvt_mbstowcs (data, len);
… …
754 free (wstr); 1431 free (wstr);
755} 1432}
756 OUTPUT: 1433 OUTPUT:
757 RETVAL 1434 RETVAL
758 1435
759# very portable, especially on objects as opposed to pods 1436#define TERM_OFFSET(sym) offsetof (TermWin_t, sym)
760#define TERM_OFFSET(sym) (((char *)&((TermWin_t *)0)->sym) - (char *)(TermWin_t *)0)
761 1437
762#define TERM_OFFSET_width TERM_OFFSET(width) 1438#define TERM_OFFSET_width TERM_OFFSET(width)
763#define TERM_OFFSET_height TERM_OFFSET(height) 1439#define TERM_OFFSET_height TERM_OFFSET(height)
764#define TERM_OFFSET_fwidth TERM_OFFSET(fwidth) 1440#define TERM_OFFSET_fwidth TERM_OFFSET(fwidth)
765#define TERM_OFFSET_fheight TERM_OFFSET(fheight) 1441#define TERM_OFFSET_fheight TERM_OFFSET(fheight)
766#define TERM_OFFSET_fbase TERM_OFFSET(fbase) 1442#define TERM_OFFSET_fbase TERM_OFFSET(fbase)
767#define TERM_OFFSET_nrow TERM_OFFSET(nrow) 1443#define TERM_OFFSET_nrow TERM_OFFSET(nrow)
768#define TERM_OFFSET_ncol TERM_OFFSET(ncol) 1444#define TERM_OFFSET_ncol TERM_OFFSET(ncol)
769#define TERM_OFFSET_focus TERM_OFFSET(focus) 1445#define TERM_OFFSET_focus TERM_OFFSET(focus)
770#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)
771#define TERM_OFFSET_saveLines TERM_OFFSET(saveLines) 1451#define TERM_OFFSET_saveLines TERM_OFFSET(saveLines)
772#define TERM_OFFSET_total_rows TERM_OFFSET(total_rows) 1452#define TERM_OFFSET_total_rows TERM_OFFSET(total_rows)
773#define TERM_OFFSET_nsaved TERM_OFFSET(nsaved) 1453#define TERM_OFFSET_top_row TERM_OFFSET(top_row)
774 1454
775int 1455int
776rxvt_term::width () 1456rxvt_term::width (int new_value = NO_INIT)
777 ALIAS: 1457 ALIAS:
778 width = TERM_OFFSET_width 1458 width = TERM_OFFSET_width
779 height = TERM_OFFSET_height 1459 height = TERM_OFFSET_height
780 fwidth = TERM_OFFSET_fwidth 1460 fwidth = TERM_OFFSET_fwidth
781 fheight = TERM_OFFSET_fheight 1461 fheight = TERM_OFFSET_fheight
782 fbase = TERM_OFFSET_fbase 1462 fbase = TERM_OFFSET_fbase
783 nrow = TERM_OFFSET_nrow 1463 nrow = TERM_OFFSET_nrow
784 ncol = TERM_OFFSET_ncol 1464 ncol = TERM_OFFSET_ncol
785 focus = TERM_OFFSET_focus 1465 focus = TERM_OFFSET_focus
786 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
787 saveLines = TERM_OFFSET_saveLines 1471 saveLines = TERM_OFFSET_saveLines
788 total_rows = TERM_OFFSET_total_rows 1472 total_rows = TERM_OFFSET_total_rows
789 nsaved = TERM_OFFSET_nsaved 1473 top_row = TERM_OFFSET_top_row
790 CODE: 1474 CODE:
791 RETVAL = *(int *)((char *)THIS + ix); 1475 RETVAL = *(int *)((char *)THIS + ix);
1476 if (items > 1)
1477 *(int *)((char *)THIS + ix) = new_value;
792 OUTPUT: 1478 OUTPUT:
793 RETVAL 1479 RETVAL
794 1480
795U32 1481unsigned int
1482rxvt_term::ModLevel3Mask ()
1483 ALIAS:
1484 ModLevel3Mask = 0
1485 ModMetaMask = 1
1486 ModNumLockMask = 2
1487 current_screen = 3
1488 hidden_cursor = 4
1489 priv_modes = 5
1490 CODE:
1491 switch (ix)
1492 {
1493 case 0: RETVAL = THIS->ModLevel3Mask; break;
1494 case 1: RETVAL = THIS->ModMetaMask; 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;
1503 }
1504 OUTPUT:
1505 RETVAL
1506
1507char *
1508rxvt_term::display_id ()
1509 ALIAS:
1510 display_id = 0
1511 locale = 1
1512 CODE:
1513 switch (ix)
1514 {
1515 case 0: RETVAL = THIS->display->id; break;
1516 case 1: RETVAL = THIS->locale; break;
1517 }
1518 OUTPUT:
1519 RETVAL
1520
1521SV *
1522rxvt_term::envv ()
1523 ALIAS:
1524 argv = 1
1525 PPCODE:
1526{
1527 stringvec *vec = ix ? THIS->argv : THIS->envv;
1528
1529 EXTEND (SP, vec->size ());
1530
1531 for (char **i = vec->begin (); i != vec->end (); ++i)
1532 if (*i)
1533 PUSHs (sv_2mortal (newSVpv (*i, 0)));
1534}
1535
1536int
1537rxvt_term::pty_ev_events (int events = ev::UNDEF)
1538 CODE:
1539 RETVAL = THIS->pty_ev.events;
1540 if (events != ev::UNDEF)
1541 THIS->pty_ev.set (events);
1542 OUTPUT:
1543 RETVAL
1544
1545int
1546rxvt_term::pty_fd ()
1547 CODE:
1548 RETVAL = THIS->pty->pty;
1549 OUTPUT:
1550 RETVAL
1551
1552Window
796rxvt_term::parent () 1553rxvt_term::parent ()
797 CODE: 1554 CODE:
798 RETVAL = (U32)THIS->parent [0]; 1555 RETVAL = THIS->parent;
799 OUTPUT: 1556 OUTPUT:
800 RETVAL 1557 RETVAL
801 1558
802U32 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
803rxvt_term::vt () 1574rxvt_term::vt ()
804 CODE: 1575 CODE:
805 RETVAL = (U32)THIS->vt; 1576 RETVAL = THIS->vt;
806 OUTPUT: 1577 OUTPUT:
807 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 ();
808 1585
809U32 1586U32
810rxvt_term::rstyle (U32 new_rstyle = THIS->rstyle) 1587rxvt_term::rstyle (U32 new_rstyle = THIS->rstyle)
811 CODE: 1588 CODE:
812{
813 RETVAL = THIS->rstyle; 1589 RETVAL = THIS->rstyle;
814 THIS->rstyle = new_rstyle; 1590 THIS->rstyle = new_rstyle;
815}
816 OUTPUT: 1591 OUTPUT:
817 RETVAL 1592 RETVAL
818 1593
819int 1594int
820rxvt_term::view_start (int newval = -1) 1595rxvt_term::view_start (int newval = 0)
1596 PROTOTYPE: $;$
821 CODE: 1597 CODE:
822{ 1598{
823 RETVAL = THIS->view_start; 1599 RETVAL = THIS->view_start;
824 1600 if (items > 1)
825 if (newval >= 0)
826 {
827 THIS->view_start = min (newval, THIS->nsaved);
828 THIS->scr_changeview (RETVAL); 1601 THIS->scr_changeview (newval);
829 }
830} 1602}
831 OUTPUT: 1603 OUTPUT:
832 RETVAL 1604 RETVAL
833 1605
834void 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
835rxvt_term::want_refresh () 1642rxvt_term::want_refresh ()
836 CODE: 1643 CODE:
837 THIS->want_refresh = 1; 1644 THIS->want_refresh = 1;
1645 THIS->refresh_check ();
1646
1647void
1648rxvt_term::refresh_check ()
838 1649
839void 1650void
840rxvt_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)
841 PPCODE: 1652 PPCODE:
842{ 1653{
843 if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow)) 1654 if (!IN_RANGE_EXC (row_number, THIS->top_row, THIS->nrow))
844 XSRETURN_EMPTY; 1655 XSRETURN_EMPTY;
845 1656
846 line_t &l = ROW(row_number); 1657 line_t &l = ROW(row_number);
847 1658
848 if (GIMME_V != G_VOID) 1659 if (GIMME_V != G_VOID)
849 { 1660 {
850 wchar_t *wstr = new wchar_t [THIS->ncol]; 1661 wchar_t *wstr = rxvt_temp_buf<wchar_t> (THIS->ncol);
851 1662
852 for (int col = 0; col <THIS->ncol; col++) 1663 for (int col = 0; col < THIS->ncol; col++)
853 wstr [col] = l.t [col]; 1664 wstr [col] = l.t [col];
854 1665
855 XPUSHs (sv_2mortal (wcs2sv (wstr))); 1666 XPUSHs (sv_2mortal (wcs2sv (wstr, THIS->ncol)));
856
857 delete [] wstr;
858 } 1667 }
859 1668
860 if (new_text) 1669 if (new_text)
861 { 1670 {
862 wchar_t *wstr = sv2wcs (new_text); 1671 wchar_t *wstr = sv2wcs (new_text);
863 1672
864 int len = min (wcslen (wstr) - start_ofs, max_len); 1673 int len = min (wcslen (wstr) - start_ofs, max_len);
865 1674
866 if (!IN_RANGE_INC (start_col, 0, THIS->ncol - len)) 1675 if (start_col < 0 || start_col + len > THIS->ncol)
867 { 1676 {
868 free (wstr); 1677 free (wstr);
869 croak ("new_text extends beyond horizontal margins"); 1678 croak ("new_text extends beyond horizontal margins");
870 } 1679 }
871 1680
… …
881 1690
882void 1691void
883rxvt_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)
884 PPCODE: 1693 PPCODE:
885{ 1694{
886 if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow)) 1695 if (!IN_RANGE_EXC (row_number, THIS->top_row, THIS->nrow))
887 XSRETURN_EMPTY; 1696 XSRETURN_EMPTY;
888 1697
889 line_t &l = ROW(row_number); 1698 line_t &l = ROW(row_number);
890 1699
891 if (GIMME_V != G_VOID) 1700 if (GIMME_V != G_VOID)
… …
903 { 1712 {
904 if (!SvROK (new_rend) || SvTYPE (SvRV (new_rend)) != SVt_PVAV) 1713 if (!SvROK (new_rend) || SvTYPE (SvRV (new_rend)) != SVt_PVAV)
905 croak ("new_rend must be arrayref"); 1714 croak ("new_rend must be arrayref");
906 1715
907 AV *av = (AV *)SvRV (new_rend); 1716 AV *av = (AV *)SvRV (new_rend);
908 int len = min (av_len (av) + 1 - start_ofs, max_len); 1717 int len = min (AvFILL (av) + 1 - start_ofs, max_len);
909 1718
910 if (!IN_RANGE_INC (start_col, 0, THIS->ncol - len)) 1719 if (start_col < 0 || start_col + len > THIS->ncol)
911 croak ("new_rend array extends beyond horizontal margins"); 1720 croak ("new_rend array extends beyond horizontal margins");
912 1721
913 for (int col = start_col; col < start_col + len; col++) 1722 for (int col = start_col; col < start_col + len; col++)
914 { 1723 {
915 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;
… …
921 1730
922int 1731int
923rxvt_term::ROW_l (int row_number, int new_length = -1) 1732rxvt_term::ROW_l (int row_number, int new_length = -1)
924 CODE: 1733 CODE:
925{ 1734{
926 if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow)) 1735 if (!IN_RANGE_EXC (row_number, THIS->top_row, THIS->nrow))
927 XSRETURN_EMPTY; 1736 XSRETURN_EMPTY;
928 1737
929 line_t &l = ROW(row_number); 1738 line_t &l = ROW(row_number);
930 RETVAL = l.l; 1739 RETVAL = l.l;
931 1740
… …
937 1746
938bool 1747bool
939rxvt_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)
940 CODE: 1749 CODE:
941{ 1750{
942 if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow)) 1751 if (!IN_RANGE_EXC (row_number, THIS->top_row, THIS->nrow))
943 XSRETURN_EMPTY; 1752 XSRETURN_EMPTY;
944 1753
945 line_t &l = ROW(row_number); 1754 line_t &l = ROW(row_number);
946 RETVAL = l.is_longer (); 1755 RETVAL = l.is_longer ();
947 1756
… …
950} 1759}
951 OUTPUT: 1760 OUTPUT:
952 RETVAL 1761 RETVAL
953 1762
954SV * 1763SV *
955rxvt_term::special_encode (SV *str) 1764rxvt_term::special_encode (SV *string)
956 CODE: 1765 CODE:
957 abort ();//TODO 1766{
1767 wchar_t *wstr = sv2wcs (string);
1768 int wlen = wcslen (wstr);
1769 wchar_t *rstr = rxvt_temp_buf<wchar_t> (wlen * 2); // cannot become longer
1770
1771 rxvt_push_locale (THIS->locale);
1772
1773 wchar_t *r = rstr;
1774 for (wchar_t *s = wstr; *s; s++)
1775 {
1776 int w = WCWIDTH (*s);
1777
1778 if (w == 0)
1779 {
1780 if (r == rstr)
1781 croak ("leading combining character unencodable");
1782
1783 unicode_t n = rxvt_compose (r[-1], *s);
1784 if (n == NOCHAR)
1785 n = rxvt_composite.compose (r[-1], *s);
1786
1787 r[-1] = n;
1788 }
1789#if !UNICODE_3
1790 else if (*s >= 0x10000)
1791 *r++ = rxvt_composite.compose (*s);
1792#endif
1793 else
1794 *r++ = *s;
1795
1796 // the *2 above only allows wcwidth <= 2
1797 if (w > 1)
1798 *r++ = NOCHAR;
1799 }
1800
1801 rxvt_pop_locale ();
1802
1803 free (wstr);
1804 RETVAL = wcs2sv (rstr, r - rstr);
1805}
1806 OUTPUT:
1807 RETVAL
958 1808
959SV * 1809SV *
960rxvt_term::special_decode (SV *str) 1810rxvt_term::special_decode (SV *text)
961 CODE: 1811 CODE:
962 abort ();//TODO 1812{
1813 wchar_t *wstr = sv2wcs (text);
1814 int dlen = 0;
963 1815
1816 // find length
1817 for (wchar_t *s = wstr; *s; s++)
1818 if (*s == NOCHAR)
1819 ;
1820 else if (IS_COMPOSE (*s))
1821 dlen += rxvt_composite.expand (*s);
1822 else
1823 dlen++;
1824
1825 wchar_t *rstr = rxvt_temp_buf<wchar_t> (dlen);
1826
1827 // decode
1828 wchar_t *r = rstr;
1829 for (wchar_t *s = wstr; *s; s++)
1830 if (*s == NOCHAR)
1831 ;
1832 else if (IS_COMPOSE (*s))
1833 r += rxvt_composite.expand (*s, r);
1834 else
1835 *r++ = *s;
1836
1837 free (wstr);
1838 RETVAL = wcs2sv (rstr, r - rstr);
1839}
1840 OUTPUT:
1841 RETVAL
1842
964void 1843void
965rxvt_term::_resource (char *name, int index, SV *newval = 0) 1844rxvt_term::_resource (octet_string name, int index, SV *newval = 0)
966 PPCODE: 1845 PPCODE:
967{ 1846{
968 struct resval { const char *name; int value; } rslist [] = { 1847 static const struct resval { const char *name; int value; } *rs, rslist [] = {
969# define def(name) { # name, Rs_ ## name }, 1848# define def(name) { # name, Rs_ ## name },
970# define reserve(name,count) 1849# define reserve(name,count)
971# include "rsinc.h" 1850# include "rsinc.h"
972# undef def 1851# undef def
973# undef reserve 1852# undef reserve
974 }; 1853 };
975 1854
976 struct resval *rs = rslist + sizeof (rslist) / sizeof (rslist [0]); 1855 rs = rslist + ecb_array_length (rslist);
977 1856
1857 if (*name)
978 do { 1858 {
1859 do {
979 if (rs-- == rslist) 1860 if (rs-- == rslist)
980 croak ("no such resource '%s', requested", name); 1861 croak ("no such resource '%s', requested", name);
981 } while (strcmp (name, rs->name)); 1862 } while (strcmp (name, rs->name));
982 1863
983 index += rs->value; 1864 index += rs->value;
1865 }
1866 else
1867 {
1868 --rs;
1869 name = (octet_string)"";
1870 }
984 1871
985 if (!IN_RANGE_EXC (index, 0, NUM_RESOURCES)) 1872 if (!IN_RANGE_EXC (index, 0, NUM_RESOURCES))
986 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);
987 1874
988 if (GIMME_V != G_VOID) 1875 if (GIMME_V != G_VOID)
… …
999 else 1886 else
1000 THIS->rs [index] = 0; 1887 THIS->rs [index] = 0;
1001 } 1888 }
1002} 1889}
1003 1890
1891const char *
1892rxvt_term::x_resource (octet_string name)
1893
1894bool
1895rxvt_term::option (U8 optval, int set = -1)
1896 CODE:
1897{
1898 RETVAL = THIS->option (optval);
1899
1900 if (set >= 0)
1901 {
1902 THIS->set_option (optval, set);
1903
1904 if (THIS->init_done) // avoid doing this before START
1905 switch (optval)
1906 {
1907 case Opt_skipBuiltinGlyphs:
1908 THIS->set_fonts ();
1909 THIS->scr_remap_chars ();
1910 THIS->scr_touch (true);
1911 THIS->want_refresh = 1;
1912 THIS->refresh_check ();
1913 break;
1914#ifdef CURSOR_BLINK
1915 case Opt_cursorBlink:
1916 THIS->cursor_blink_reset ();
1917 break;
1918#endif
1919
1920 case Opt_cursorUnderline:
1921 THIS->cursor_type = set ? 1 : 0;
1922 THIS->want_refresh = 1;
1923 THIS->refresh_check ();
1924 break;
1925
1926# case Opt_scrollBar_floating:
1927# case Opt_scrollBar_right:
1928# THIS->resize_all_windows (THIS->width, THIS->height, 1);
1929# break;
1930 }
1931 }
1932}
1933 OUTPUT:
1934 RETVAL
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
1946bool
1947rxvt_term::bind_action (octet_string keysym, octet_string action)
1948 ALIAS:
1949 parse_keysym = 1
1950 CODE:
1951 RETVAL = 0 < THIS->bind_action (keysym, action);
1952 THIS->keyboard->register_done ();
1953 OUTPUT:
1954 RETVAL
1955
1004void 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);
1962
1963void
1005rxvt_term::cur (...) 1964rxvt_term::screen_cur (...)
1006 PROTOTYPE: $;$$ 1965 PROTOTYPE: $;$$
1007 ALIAS: 1966 ALIAS:
1008 screen_cur = 0 1967 screen_cur = 0
1009 selection_beg = 1 1968 selection_beg = 1
1010 selection_end = 2 1969 selection_end = 2
… …
1021 EXTEND (SP, 2); 1980 EXTEND (SP, 2);
1022 PUSHs (sv_2mortal (newSViv (rc.row))); 1981 PUSHs (sv_2mortal (newSViv (rc.row)));
1023 PUSHs (sv_2mortal (newSViv (rc.col))); 1982 PUSHs (sv_2mortal (newSViv (rc.col)));
1024 } 1983 }
1025 1984
1026 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)
1027 { 1991 {
1028 rc.row = clamp (SvIV (ST (1)), -THIS->nsaved, THIS->nrow - 1); 1992 if (rc.col == 0)
1029 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);
1030 2008
1031 if (ix) 2009 if (ix)
1032 THIS->want_refresh = 1; 2010 {
2011 THIS->selection.screen = THIS->current_screen;
2012
2013 THIS->selection_changed ();
2014 THIS->refresh_check ();
1033 } 2015 }
2016 }
1034} 2017}
1035 2018
1036int 2019int
1037rxvt_term::selection_grab (int eventtime = CurrentTime) 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
1038 2027
1039void 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
1040rxvt_term::selection (SV *newtext = 0) 2045rxvt_term::selection (SV *newtext = 0, bool clipboard = false)
1041 PPCODE: 2046 PPCODE:
1042{ 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
1043 if (GIMME_V != G_VOID) 2051 if (GIMME_V != G_VOID)
1044 XPUSHs (sv_2mortal (wcs2sv (THIS->selection.text, THIS->selection.len))); 2052 XPUSHs (text
2053 ? sv_2mortal (wcs2sv (text, len))
2054 : &PL_sv_undef);
1045 2055
1046 if (newtext) 2056 if (newtext)
1047 { 2057 {
1048 free (THIS->selection.text); 2058 free (text);
1049 2059
1050 THIS->selection.text = sv2wcs (newtext); 2060 text = sv2wcs (newtext);
1051 THIS->selection.len = wcslen (THIS->selection.text); 2061 len = wcslen (text);
1052 } 2062 }
1053} 2063}
2064
2065char
2066rxvt_term::cur_charset ()
2067 CODE:
2068 RETVAL = THIS->charsets [THIS->screen.charset];
2069 OUTPUT:
2070 RETVAL
2071
2072void
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)
2074
2075void
2076rxvt_term::scr_xor_span (int beg_row, int beg_col, int end_row, int end_col, U32 rstyle = RS_RVid)
2077
2078void
2079rxvt_term::scr_bell ()
2080
2081void
2082rxvt_term::scr_recolor (bool refresh = true);
2083
2084void
2085rxvt_term::scr_change_screen (int screen)
1054 2086
1055void 2087void
1056rxvt_term::scr_add_lines (SV *string) 2088rxvt_term::scr_add_lines (SV *string)
1057 CODE: 2089 CODE:
1058{ 2090{
1059 wchar_t *wstr = sv2wcs (string); 2091 wchar_t *wstr = sv2wcs (string);
1060 THIS->scr_add_lines (wstr, wcslen (wstr)); 2092 THIS->scr_add_lines (wstr, wcslen (wstr));
1061 free (wstr); 2093 free (wstr);
1062} 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
1063 2103
1064void 2104void
1065rxvt_term::tt_write (SV *octets) 2105rxvt_term::tt_write (SV *octets)
1066 INIT: 2106 INIT:
1067 STRLEN len; 2107 STRLEN len;
1068 char *str = SvPVbyte (octets, len); 2108 char *str = SvPVbyte (octets, len);
1069 C_ARGS: 2109 C_ARGS:
1070 str, len 2110 str, len
1071 2111
1072void 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
1073rxvt_term::cmd_parse (SV *octets) 2121rxvt_term::cmd_parse (SV *octets)
1074 CODE: 2122 CODE:
1075{ 2123{
1076 STRLEN len; 2124 STRLEN len;
1077 char *str = SvPVbyte (octets, len); 2125 char *str = SvPVbyte (octets, len);
… …
1080 char *old_cmdbuf_endp = THIS->cmdbuf_endp; 2128 char *old_cmdbuf_endp = THIS->cmdbuf_endp;
1081 2129
1082 THIS->cmdbuf_ptr = str; 2130 THIS->cmdbuf_ptr = str;
1083 THIS->cmdbuf_endp = str + len; 2131 THIS->cmdbuf_endp = str + len;
1084 2132
2133 rxvt_push_locale (THIS->locale);
1085 THIS->cmd_parse (); 2134 THIS->cmd_parse ();
2135 rxvt_pop_locale ();
1086 2136
1087 THIS->cmdbuf_ptr = old_cmdbuf_ptr; 2137 THIS->cmdbuf_ptr = old_cmdbuf_ptr;
1088 THIS->cmdbuf_endp = old_cmdbuf_endp; 2138 THIS->cmdbuf_endp = old_cmdbuf_endp;
1089} 2139}
1090 2140
… …
1097 o->self = (HV *)SvRV (RETVAL); 2147 o->self = (HV *)SvRV (RETVAL);
1098} 2148}
1099 OUTPUT: 2149 OUTPUT:
1100 RETVAL 2150 RETVAL
1101 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
1102MODULE = urxvt PACKAGE = urxvt::overlay 2449MODULE = urxvt PACKAGE = urxvt::overlay
1103 2450
1104void 2451void
1105overlay::set (int x, int y, SV *text, SV *rend = 0) 2452overlay::set (int x, int y, SV *text, SV *rend = 0)
1106 2453
… …
1111overlay::hide () 2458overlay::hide ()
1112 2459
1113void 2460void
1114overlay::DESTROY () 2461overlay::DESTROY ()
1115 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
1116MODULE = urxvt PACKAGE = urxvt::timer 2479MODULE = urxvt PACKAGE = urxvt::img
1117 2480
1118SV * 2481#if HAVE_IMG
1119timer::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 ()
1120 CODE: 2488 PPCODE:
1121 timer *w = new timer; 2489 EXTEND (SP, 4);
1122 w->start (NOW); 2490 PUSHs (sv_2mortal (newSViv (THIS->x)));
1123 RETVAL = newSVptr ((void *)w, "urxvt::timer"); 2491 PUSHs (sv_2mortal (newSViv (THIS->y)));
1124 w->self = (HV *)SvRV (RETVAL); 2492 PUSHs (sv_2mortal (newSViv (THIS->w)));
1125 OUTPUT: 2493 PUSHs (sv_2mortal (newSViv (THIS->h)));
1126 RETVAL
1127 2494
1128timer * 2495int
1129timer::cb (SV *cb) 2496rxvt_img::x ()
2497 ALIAS:
2498 x = 0
2499 y = 1
2500 w = 2
2501 h = 3
1130 CODE: 2502 CODE:
1131 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:
1132 RETVAL = THIS; 2511 RETVAL
1133 OUTPUT:
1134 RETVAL
1135 2512
1136NV 2513Pixmap
1137timer::at () 2514rxvt_img::pm ()
1138 CODE: 2515 CODE:
1139 RETVAL = THIS->at; 2516 RETVAL = THIS->pm;
1140 OUTPUT: 2517 OUTPUT:
1141 RETVAL 2518 RETVAL
1142 2519
1143timer * 2520void
1144timer::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)
1145 CODE: 2542 PPCODE:
1146 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:
1147 RETVAL = THIS; 2623 RETVAL
1148 OUTPUT:
1149 RETVAL
1150 2624
1151timer * 2625#endif
1152timer::set (NV tstamp)
1153 CODE:
1154 THIS->set (tstamp);
1155 RETVAL = THIS;
1156 OUTPUT:
1157 RETVAL
1158 2626
1159timer *
1160timer::start (NV tstamp = THIS->at)
1161 CODE:
1162 THIS->start (tstamp);
1163 RETVAL = THIS;
1164 OUTPUT:
1165 RETVAL
1166
1167timer *
1168timer::stop ()
1169 CODE:
1170 THIS->stop ();
1171 RETVAL = THIS;
1172 OUTPUT:
1173 RETVAL
1174
1175void
1176timer::DESTROY ()
1177
1178MODULE = urxvt PACKAGE = urxvt::iow
1179
1180SV *
1181iow::new ()
1182 CODE:
1183 iow *w = new iow;
1184 RETVAL = newSVptr ((void *)w, "urxvt::iow");
1185 w->self = (HV *)SvRV (RETVAL);
1186 OUTPUT:
1187 RETVAL
1188
1189iow *
1190iow::cb (SV *cb)
1191 CODE:
1192 THIS->cb (cb);
1193 RETVAL = THIS;
1194 OUTPUT:
1195 RETVAL
1196
1197iow *
1198iow::fd (int fd)
1199 CODE:
1200 THIS->fd = fd;
1201 RETVAL = THIS;
1202 OUTPUT:
1203 RETVAL
1204
1205iow *
1206iow::events (short events)
1207 CODE:
1208 THIS->events = events;
1209 RETVAL = THIS;
1210 OUTPUT:
1211 RETVAL
1212
1213iow *
1214iow::start ()
1215 CODE:
1216 THIS->start ();
1217 RETVAL = THIS;
1218 OUTPUT:
1219 RETVAL
1220
1221iow *
1222iow::stop ()
1223 CODE:
1224 THIS->stop ();
1225 RETVAL = THIS;
1226 OUTPUT:
1227 RETVAL
1228
1229void
1230iow::DESTROY ()
1231
1232

Diff Legend

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