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.60 by root, Thu Jan 12 05:22:47 2006 UTC vs.
Revision 1.158 by root, Sun Jun 3 18:04:44 2012 UTC

1/*----------------------------------------------------------------------* 1/*----------------------------------------------------------------------*
2 * File: rxvtperl.xs 2 * File: rxvtperl.xs
3 *----------------------------------------------------------------------* 3 *----------------------------------------------------------------------*
4 * 4 *
5 * All portions of code are copyright by their respective author/s. 5 * All portions of code are copyright by their respective author/s.
6 * Copyright (c) 2005-2006 Marc Lehmann <pcg@goof.com> 6 * Copyright (c) 2005-2008,2011 Marc Lehmann <schmorp@schmorp.de>
7 * 7 *
8 * This program is free software; you can redistribute it and/or modify 8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version. 11 * (at your option) any later version.
23#define line_t perl_line_t 23#define line_t perl_line_t
24#include <EXTERN.h> 24#include <EXTERN.h>
25#include <perl.h> 25#include <perl.h>
26#include <XSUB.h> 26#include <XSUB.h>
27#undef line_t 27#undef line_t
28#undef bool // perl defines it's own bool type, except with g++... what a trap
28 29
29#include "../config.h" 30#include "../config.h"
30 31
31#include <cstddef> 32#include <stddef.h>
32#include <cstdarg> 33#include <stdarg.h>
33 34
34#include "unistd.h" 35#include "unistd.h"
35 36
36#include "iom.h" 37#include "ev_cpp.h"
37#include "rxvt.h" 38#include "rxvt.h"
38#include "keyboard.h" 39#include "keyboard.h"
39#include "rxvtutil.h" 40#include "rxvtutil.h"
40#include "rxvtperl.h" 41#include "rxvtperl.h"
41 42
42#include "perlxsi.c" 43#include "perlxsi.c"
43 44
44#if defined(HAVE_SCROLLBARS) || defined(MENUBAR)
45# define GRAB_CURSOR THIS->leftptr_cursor 45#define GRAB_CURSOR THIS->scrollBar.leftptr_cursor
46#else
47# define GRAB_CURSOR None
48#endif
49 46
50#undef LINENO 47#undef LINENO
51#define LINENO(n) MOD (THIS->term_start + int(n), THIS->total_rows) 48#define LINENO(n) MOD (THIS->term_start + int(n), THIS->total_rows)
52#undef ROW 49#undef ROW
53#define ROW(n) THIS->row_buf [LINENO (n)] 50#define ROW(n) THIS->row_buf [LINENO (n)]
54 51
55///////////////////////////////////////////////////////////////////////////// 52/////////////////////////////////////////////////////////////////////////////
56 53
57static SV * 54typedef char * octet_string;
58taint (SV *sv) 55typedef char * utf8_string;
59{
60 SvTAINT (sv);
61 return sv;
62}
63 56
64static SV * 57typedef GdkPixbuf * urxvt__pixbuf;
65taint_if (SV *sv, SV *src) 58typedef rxvt_img * urxvt__img;
66{
67 if (SvTAINTED (src))
68 SvTAINT (sv);
69 59
70 return sv; 60/////////////////////////////////////////////////////////////////////////////
61
62static void
63parse_color (rxvt_screen *s, rxvt_color &c, SV *sv)
64{
65 //TODO: support component stuff
66 c.set (s, SvPVbyte_nolen (sv));
71} 67}
68
69/////////////////////////////////////////////////////////////////////////////
72 70
73static wchar_t * 71static wchar_t *
74sv2wcs (SV *sv) 72sv2wcs (SV *sv)
75{ 73{
76 STRLEN len; 74 STRLEN len;
89 87
90 return sv; 88 return sv;
91} 89}
92 90
93static SV * 91static SV *
94new_ref (HV *hv, const char *klass)
95{
96 return sv_bless (newRV ((SV *)hv), gv_stashpv (klass, 1));
97}
98
99//TODO: use magic
100static SV *
101newSVptr (void *ptr, const char *klass) 92newSVptr (void *ptr, const char *klass)
102{ 93{
103 HV *hv = newHV (); 94 HV *hv = newHV ();
104 sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0); 95 sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);
105 return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1)); 96 return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
127 croak ("perl code used %s object, but C++ object is already destroyed, caught", klass); 118 croak ("perl code used %s object, but C++ object is already destroyed, caught", klass);
128 119
129 return (long)mg->mg_ptr; 120 return (long)mg->mg_ptr;
130} 121}
131 122
132#define newSVterm(term) SvREFCNT_inc ((SV *)term->perl.self) 123#define newSVterm(term) SvREFCNT_inc ((SV *)(term)->perl.self)
133#define SvTERM(sv) (rxvt_term *)SvPTR (sv, "urxvt::term") 124#define SvTERM(sv) (rxvt_term *)SvPTR ((sv), "urxvt::term")
134 125
135///////////////////////////////////////////////////////////////////////////// 126/////////////////////////////////////////////////////////////////////////////
136 127
137struct perl_watcher 128#define SvOVERLAY(sv) (overlay *)SvPTR (sv, "urxvt::overlay")
129
130class overlay : overlay_base
138{ 131{
139 SV *cbsv; 132 rxvt_term *THIS;
133 AV *overlay_av;
134 int border;
135
136public:
140 HV *self; 137 HV *self;
141
142 perl_watcher ()
143 : cbsv (newSV (0))
144 {
145 }
146
147 ~perl_watcher ()
148 {
149 SvREFCNT_dec (cbsv);
150 }
151
152 void cb (SV *cb)
153 {
154 sv_setsv (cbsv, cb);
155 }
156
157 void invoke (const char *type, SV *self, int arg = -1);
158};
159
160void
161perl_watcher::invoke (const char *type, SV *self, int arg)
162{
163 dSP;
164
165 ENTER;
166 SAVETMPS;
167
168 PUSHMARK (SP);
169
170 XPUSHs (sv_2mortal (self));
171
172 if (arg >= 0)
173 XPUSHs (sv_2mortal (newSViv (arg)));
174
175 PUTBACK;
176 call_sv (cbsv, G_VOID | G_EVAL | G_DISCARD);
177 SPAGAIN;
178
179 PUTBACK;
180 FREETMPS;
181 LEAVE;
182
183 if (SvTRUE (ERRSV))
184 rxvt_warn ("%s callback evaluation error: %s", type, SvPV_nolen (ERRSV));
185}
186
187#define newSVtimer(timer) new_ref (timer->self, "urxvt::timer")
188#define SvTIMER(sv) (timer *)SvPTR (sv, "urxvt::timer")
189
190struct timer : time_watcher, perl_watcher
191{
192 tstamp interval;
193
194 timer ()
195 : time_watcher (this, &timer::execute)
196 {
197 }
198
199 void execute (time_watcher &w)
200 {
201 if (interval)
202 start (at + interval);
203
204 invoke ("urxvt::timer", newSVtimer (this));
205 }
206};
207
208#define newSViow(iow) new_ref (iow->self, "urxvt::iow")
209#define SvIOW(sv) (iow *)SvPTR (sv, "urxvt::iow")
210
211struct iow : io_watcher, perl_watcher
212{
213 iow ()
214 : io_watcher (this, &iow::execute)
215 {
216 }
217
218 void execute (io_watcher &w, short revents)
219 {
220 invoke ("urxvt::iow", newSViow (this), revents);
221 }
222};
223
224/////////////////////////////////////////////////////////////////////////////
225
226#define SvOVERLAY(sv) (overlay *)SvPTR (sv, "urxvt::overlay")
227
228struct overlay {
229 HV *self;
230 rxvt_term *THIS;
231 int x, y, w, h;
232 int border;
233 text_t **text;
234 rend_t **rend;
235 138
236 overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border); 139 overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border);
237 ~overlay (); 140 ~overlay ();
238 141
239 void show (); 142 void show ();
243 146
244 void set (int x, int y, SV *str, SV *rend); 147 void set (int x, int y, SV *str, SV *rend);
245}; 148};
246 149
247overlay::overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border) 150overlay::overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border)
248: THIS(THIS), x(x_), y(y_), w(w_), h(h_), border(border == 2) 151: THIS(THIS), border(border == 2), overlay_av (0)
249{ 152{
153 x = x_;
154 y = y_;
155 w = w_;
156 h = h_;
157
158 if (w < 0) w = 0;
159 if (h < 0) h = 0;
160
250 if (border == 2) 161 if (border == 2)
251 { 162 {
252 w += 2; 163 w += 2;
253 h += 2; 164 h += 2;
254 } 165 }
292 *rp++ = r; 203 *rp++ = r;
293 } 204 }
294 } 205 }
295 206
296 show (); 207 show ();
297 THIS->want_refresh = 1;
298} 208}
299 209
300overlay::~overlay () 210overlay::~overlay ()
301{ 211{
302 hide (); 212 hide ();
307 delete [] rend[y]; 217 delete [] rend[y];
308 } 218 }
309 219
310 delete [] text; 220 delete [] text;
311 delete [] rend; 221 delete [] rend;
222}
223
224void
225overlay::show ()
226{
227 if (overlay_av)
228 return;
229
230 overlay_av = (AV *)SvREFCNT_inc (SvRV (
231 *hv_fetch ((HV *)SvRV ((SV *)THIS->perl.self), "_overlay", 8, 0)
232 ));
233 av_push (overlay_av, newSViv ((long)this));
312 234
313 THIS->want_refresh = 1; 235 THIS->want_refresh = 1;
314} 236 THIS->refresh_check ();
315
316void
317overlay::show ()
318{
319 char key[33]; sprintf (key, "%32lx", (long)this);
320
321 HV *hv = (HV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)THIS->perl.self), "_overlay", 8, 0));
322 hv_store (hv, key, 32, newSViv ((long)this), 0);
323} 237}
324 238
325void 239void
326overlay::hide () 240overlay::hide ()
327{ 241{
328 SV **ovs = hv_fetch ((HV *)SvRV ((SV *)THIS->perl.self), "_overlay", 8, 0); 242 if (!overlay_av)
243 return;
329 244
330 if (ovs) 245 int i;
331 {
332 char key[33]; sprintf (key, "%32lx", (long)this);
333 246
334 HV *hv = (HV *)SvRV (*ovs); 247 for (i = AvFILL (overlay_av); i >= 0; i--)
335 hv_delete (hv, key, 32, G_DISCARD); 248 if (SvIV (*av_fetch (overlay_av, i, 1)) == (long)this)
336 } 249 break;
250
251 for (; i < AvFILL (overlay_av); i++)
252 av_store (overlay_av, i, SvREFCNT_inc (*av_fetch (overlay_av, i + 1, 0)));
253
254 av_pop (overlay_av);
255
256 SvREFCNT_dec (overlay_av);
257 overlay_av = 0;
258
259 THIS->want_refresh = 1;
260 THIS->refresh_check ();
337} 261}
338 262
339void overlay::swap () 263void overlay::swap ()
340{ 264{
341 int ov_x = max (0, min (MOD (x, THIS->ncol), THIS->ncol - w)); 265 int ov_x = max (0, min (MOD (x, THIS->ncol), THIS->ncol - w));
342 int ov_y = max (0, min (MOD (y, THIS->nrow), THIS->nrow - h)); 266 int ov_y = max (0, min (MOD (y, THIS->nrow), THIS->nrow - h));
343 267
344 int ov_w = min (w, THIS->ncol - ov_x); 268 int ov_w = min (w, THIS->ncol - ov_x);
345 int ov_h = min (h, THIS->nrow - ov_y); 269 int ov_h = min (h, THIS->nrow - ov_y);
270
271 // hide cursor if it is within the overlay area
272 if (IN_RANGE_EXC (THIS->screen.cur.col - ov_x, 0, ov_w)
273 && IN_RANGE_EXC (THIS->screen.cur.row - ov_y, 0, ov_h))
274 THIS->screen.flags &= ~Screen_VisibleCursor;
346 275
347 for (int y = ov_h; y--; ) 276 for (int y = ov_h; y--; )
348 { 277 {
349 text_t *t1 = text [y]; 278 text_t *t1 = text [y];
350 rend_t *r1 = rend [y]; 279 rend_t *r1 = rend [y];
351 280
352 text_t *t2 = ROW(y + ov_y - THIS->view_start).t + ov_x; 281 text_t *t2 = ROW(y + ov_y + THIS->view_start).t + ov_x;
353 rend_t *r2 = ROW(y + ov_y - THIS->view_start).r + ov_x; 282 rend_t *r2 = ROW(y + ov_y + THIS->view_start).r + ov_x;
354 283
355 for (int x = ov_w; x--; ) 284 for (int x = ov_w; x--; )
356 { 285 {
357 text_t t = *t1; *t1++ = *t2; *t2++ = t; 286 text_t t = *t1; *t1++ = *t2; *t2++ = t;
358 rend_t r = *r1; *r1++ = *r2; *r2++ = SET_FONT (r, THIS->fontset [GET_STYLE (r)]->find_font (t)); 287 rend_t r = *r1; *r1++ = *r2; *r2++ = SET_FONT (r, THIS->fontset [GET_STYLE (r)]->find_font (t));
381 if (!SvROK (rend) || SvTYPE (SvRV (rend)) != SVt_PVAV) 310 if (!SvROK (rend) || SvTYPE (SvRV (rend)) != SVt_PVAV)
382 croak ("rend must be arrayref"); 311 croak ("rend must be arrayref");
383 312
384 AV *av = (AV *)SvRV (rend); 313 AV *av = (AV *)SvRV (rend);
385 314
386 for (int col = min (av_len (av) + 1, w - x - border); col--; ) 315 for (int col = min (AvFILL (av) + 1, w - x - border); col--; )
387 this->rend [y][x + col] = SvIV (*av_fetch (av, col, 1)); 316 this->rend [y][x + col] = SvIV (*av_fetch (av, col, 1));
388 } 317 }
389 318
390 THIS->want_refresh = 1; 319 THIS->want_refresh = 1;
320 THIS->refresh_check ();
391} 321}
392 322
323/////////////////////////////////////////////////////////////////////////////
324
325#include "iom_perl.h"
393 326
394///////////////////////////////////////////////////////////////////////////// 327/////////////////////////////////////////////////////////////////////////////
395 328
396struct rxvt_perl_interp rxvt_perl; 329struct rxvt_perl_interp rxvt_perl;
397 330
401{ 334{
402 if (perl) 335 if (perl)
403 { 336 {
404 perl_destruct (perl); 337 perl_destruct (perl);
405 perl_free (perl); 338 perl_free (perl);
339 PERL_SYS_TERM ();
406 } 340 }
407} 341}
408 342
409void 343void
410rxvt_perl_interp::init () 344rxvt_perl_interp::init (rxvt_term *term)
411{ 345{
412 if (!perl) 346 if (!perl)
413 { 347 {
348 rxvt_push_locale (""); // perl init destroys current locale
349
350 {
414 perl_environ = rxvt_environ; 351 perl_environ = rxvt_environ;
415 swap (perl_environ, environ); 352 localise_env set_environ (perl_environ);
416 353
417 char *argv[] = { 354 char *args[] = {
418 "", 355 "",
419 "-T", 356 "-e"
420 "-edo '" LIBDIR "/urxvt.pm' or ($@ and die $@) or exit 1", 357 "BEGIN {"
358 " urxvt->bootstrap;"
359 " unshift @INC, '" LIBDIR "';"
360 "}"
361 ""
362 "use urxvt;"
421 }; 363 };
364 int argc = ecb_array_length (args);
365 char **argv = args;
422 366
367 PERL_SYS_INIT3 (&argc, &argv, &environ);
423 perl = perl_alloc (); 368 perl = perl_alloc ();
424 perl_construct (perl); 369 perl_construct (perl);
425 370
426 if (perl_parse (perl, xs_init, 3, argv, (char **)NULL) 371 if (perl_parse (perl, xs_init, argc, argv, (char **)NULL)
427 || perl_run (perl)) 372 || perl_run (perl))
428 { 373 {
429 rxvt_warn ("unable to initialize perl-interpreter, continuing without.\n"); 374 rxvt_warn ("unable to initialize perl-interpreter, continuing without.\n");
430 375
431 perl_destruct (perl); 376 perl_destruct (perl);
432 perl_free (perl); 377 perl_free (perl);
433 perl = 0; 378 perl = 0;
434 } 379 }
380 }
435 381
436 swap (perl_environ, environ); 382 rxvt_pop_locale ();
383 }
384
385 if (perl)
386 {
387 // runs outside of perls ENV
388 term->perl.self = (void *)newSVptr ((void *)term, "urxvt::term");
389 hv_store ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, newRV_noinc ((SV *)newAV ()), 0);
390 hv_store ((HV *)SvRV ((SV *)term->perl.self), "_selection", 10, newRV_noinc ((SV *)newAV ()), 0);
437 } 391 }
438} 392}
439 393
440static void 394static void
441ungrab (rxvt_term *THIS) 395ungrab (rxvt_term *THIS)
442{ 396{
443 if (THIS->perl.grabtime) 397 if (THIS->perl.grabtime)
444 { 398 {
445 XUngrabKeyboard (THIS->display->display, THIS->perl.grabtime); 399 XUngrabKeyboard (THIS->dpy, THIS->perl.grabtime);
446 XUngrabPointer (THIS->display->display, THIS->perl.grabtime); 400 XUngrabPointer (THIS->dpy, THIS->perl.grabtime);
447 THIS->perl.grabtime = 0; 401 THIS->perl.grabtime = 0;
448 } 402 }
449} 403}
450 404
451bool 405bool
452rxvt_perl_interp::invoke (rxvt_term *term, hook_type htype, ...) 406rxvt_perl_interp::invoke (rxvt_term *term, hook_type htype, ...)
453{ 407{
454 if (!perl) 408 if (!perl || !term->perl.self)
455 return false; 409 return false;
456 410
457 if (htype == HOOK_INIT) // first hook ever called 411 localise_env set_environ (perl_environ);
412
413 // pre-handling of some events
414 if (htype == HOOK_REFRESH_END)
458 { 415 {
459 term->perl.self = (void *)newSVptr ((void *)term, "urxvt::term"); 416 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, 0));
460 hv_store ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, newRV_noinc ((SV *)newHV ()), 0); 417
418 for (int i = 0; i <= AvFILL (av); i++)
419 ((overlay *)SvIV (*av_fetch (av, i, 0)))->swap ();
461 } 420 }
462 else if (!term->perl.self)
463 return false; // perl not initialized for this instance
464 else if (htype == HOOK_DESTROY) 421 else if (htype == HOOK_DESTROY)
465 { 422 {
466 // handled later 423 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_selection", 10, 0));
424
425 for (int i = AvFILL (av); i >= 0; i--)
426 {
427 rxvt_selection *req = (rxvt_selection *)SvIV (*av_fetch (av, i, 0));
428 delete req;
429 }
467 } 430 }
468 else
469 {
470 if (htype == HOOK_REFRESH_BEGIN || htype == HOOK_REFRESH_END)
471 {
472 HV *hv = (HV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, 0));
473 431
474 if (HvKEYS (hv)) 432 bool event_consumed;
475 {
476 hv_iterinit (hv);
477 433
478 while (HE *he = hv_iternext (hv)) 434 if (htype == HOOK_INIT || htype == HOOK_DESTROY // must be called always
479 ((overlay *)SvIV (hv_iterval (hv, he)))->swap (); 435 || term->perl.should_invoke [htype])
480 }
481
482 }
483
484 if (!should_invoke [htype])
485 return false;
486 }
487
488 swap (perl_environ, environ);
489
490 try
491 { 436 {
492 dSP; 437 dSP;
493 va_list ap; 438 va_list ap;
494 439
495 va_start (ap, htype); 440 va_start (ap, htype);
497 ENTER; 442 ENTER;
498 SAVETMPS; 443 SAVETMPS;
499 444
500 PUSHMARK (SP); 445 PUSHMARK (SP);
501 446
447 EXTEND (SP, 2);
502 XPUSHs (sv_2mortal (newSVterm (term))); 448 PUSHs (sv_2mortal (newSVterm (term)));
503 XPUSHs (sv_2mortal (newSViv (htype))); 449 PUSHs (sv_2mortal (newSViv (htype)));
504 450
505 for (;;) { 451 for (;;) {
506 data_type dt = (data_type)va_arg (ap, int); 452 data_type dt = (data_type)va_arg (ap, int);
507 453
508 switch (dt) 454 switch (dt)
514 case DT_LONG: 460 case DT_LONG:
515 XPUSHs (sv_2mortal (newSViv (va_arg (ap, long)))); 461 XPUSHs (sv_2mortal (newSViv (va_arg (ap, long))));
516 break; 462 break;
517 463
518 case DT_STR: 464 case DT_STR:
519 XPUSHs (taint (sv_2mortal (newSVpv (va_arg (ap, char *), 0)))); 465 XPUSHs (sv_2mortal (newSVpv (va_arg (ap, char *), 0)));
520 break; 466 break;
521 467
522 case DT_STR_LEN: 468 case DT_STR_LEN:
523 { 469 {
524 char *str = va_arg (ap, char *); 470 char *str = va_arg (ap, char *);
525 int len = va_arg (ap, int); 471 int len = va_arg (ap, int);
526 472
527 XPUSHs (taint (sv_2mortal (newSVpvn (str, len)))); 473 XPUSHs (sv_2mortal (newSVpvn (str, len)));
528 } 474 }
529 break; 475 break;
530 476
531 case DT_WCS_LEN: 477 case DT_WCS_LEN:
532 { 478 {
533 wchar_t *wstr = va_arg (ap, wchar_t *); 479 wchar_t *wstr = va_arg (ap, wchar_t *);
480 int wlen = va_arg (ap, int);
481
482 XPUSHs (sv_2mortal (wcs2sv (wstr, wlen)));
483 }
484 break;
485
486 case DT_LCS_LEN:
487 {
488 long *lstr = va_arg (ap, long *);
534 int wlen = va_arg (ap, int); 489 int llen = va_arg (ap, int);
535 490
536 XPUSHs (taint (sv_2mortal (wcs2sv (wstr, wlen)))); 491 XPUSHs (sv_2mortal (newSVpvn ((char *)lstr, llen * sizeof (long))));
537 } 492 }
538 break; 493 break;
539 494
540 case DT_XEVENT: 495 case DT_XEVENT:
541 { 496 {
542 XEvent *xe = va_arg (ap, XEvent *); 497 XEvent *xe = va_arg (ap, XEvent *);
543 HV *hv = newHV (); 498 HV *hv = newHV ();
544 499
545# define set(name, sv) hv_store (hv, # name, sizeof (# name) - 1, sv, 0) 500# define set(name, sv) hv_store (hv, # name, sizeof (# name) - 1, sv, 0)
546# define setiv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSViv (val), 0) 501# define setiv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSViv (val), 0)
502# define setuv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSVuv (val), 0)
547# undef set 503# undef set
548 504
549 setiv (type, xe->type); 505 setiv (type, xe->type);
550 setiv (send_event, xe->xany.send_event); 506 setiv (send_event, xe->xany.send_event);
551 setiv (serial, xe->xany.serial); 507 setiv (serial, xe->xany.serial);
552 508
555 case KeyPress: 511 case KeyPress:
556 case KeyRelease: 512 case KeyRelease:
557 case ButtonPress: 513 case ButtonPress:
558 case ButtonRelease: 514 case ButtonRelease:
559 case MotionNotify: 515 case MotionNotify:
516 setuv (window, xe->xmotion.window);
517 setuv (root, xe->xmotion.root);
518 setuv (subwindow, xe->xmotion.subwindow);
560 setiv (time, xe->xmotion.time); 519 setuv (time, xe->xmotion.time);
561 setiv (x, xe->xmotion.x); 520 setiv (x, xe->xmotion.x);
562 setiv (y, xe->xmotion.y); 521 setiv (y, xe->xmotion.y);
563 setiv (row, xe->xmotion.y / term->fheight); 522 setiv (row, xe->xmotion.y / term->fheight + term->view_start);
564 setiv (col, xe->xmotion.x / term->fwidth); 523 setiv (col, xe->xmotion.x / term->fwidth);
565 setiv (x_root, xe->xmotion.x_root); 524 setiv (x_root, xe->xmotion.x_root);
566 setiv (y_root, xe->xmotion.y_root); 525 setiv (y_root, xe->xmotion.y_root);
567 setiv (state, xe->xmotion.state); 526 setuv (state, xe->xmotion.state);
527
528 switch (xe->type)
529 {
530 case KeyPress:
531 case KeyRelease:
532 setuv (keycode, xe->xkey.keycode);
533 break;
534
535 case ButtonPress:
536 case ButtonRelease:
537 setuv (button, xe->xbutton.button);
538 break;
539
540 case MotionNotify:
541 setiv (is_hint, xe->xmotion.is_hint);
542 break;
543 }
544
568 break; 545 break;
569 }
570 546
547 case MapNotify:
548 case UnmapNotify:
549 case ConfigureNotify:
550 setuv (event, xe->xconfigure.event);
551 setuv (window, xe->xconfigure.window);
552
571 switch (xe->type) 553 switch (xe->type)
572 { 554 {
573 case KeyPress: 555 case ConfigureNotify:
574 case KeyRelease: 556 setiv (x, xe->xconfigure.x);
575 setiv (keycode, xe->xkey.keycode); 557 setiv (y, xe->xconfigure.y);
558 setiv (width, xe->xconfigure.width);
559 setiv (height, xe->xconfigure.height);
560 setuv (above, xe->xconfigure.above);
561 break;
562 }
563
576 break; 564 break;
577 565
578 case ButtonPress: 566 case PropertyNotify:
579 case ButtonRelease: 567 setuv (window, xe->xproperty.window);
580 setiv (button, xe->xbutton.button); 568 setuv (atom, xe->xproperty.atom);
569 setuv (time, xe->xproperty.time);
570 setiv (state, xe->xproperty.state);
581 break; 571 break;
582 572
583 case MotionNotify: 573 case ClientMessage:
584 setiv (is_hint, xe->xmotion.is_hint); 574 setuv (window, xe->xclient.window);
575 setuv (message_type, xe->xclient.message_type);
576 setuv (format, xe->xclient.format);
577 setuv (l0, xe->xclient.data.l[0]);
578 setuv (l1, xe->xclient.data.l[1]);
579 setuv (l2, xe->xclient.data.l[2]);
580 setuv (l3, xe->xclient.data.l[3]);
581 setuv (l4, xe->xclient.data.l[4]);
585 break; 582 break;
586 } 583 }
587 584
588 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv))); 585 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
589 } 586 }
590 break; 587 break;
591 588
592 case DT_END: 589 case DT_END:
593 { 590 goto call;
594 va_end (ap);
595
596 PUTBACK;
597 int count = call_pv ("urxvt::invoke", G_ARRAY | G_EVAL);
598 SPAGAIN;
599
600 if (count)
601 {
602 SV *status = POPs;
603 count = SvTRUE (status);
604 }
605
606 PUTBACK;
607 FREETMPS;
608 LEAVE;
609
610 if (SvTRUE (ERRSV))
611 {
612 rxvt_warn ("perl hook %d evaluation error: %s", htype, SvPV_nolen (ERRSV));
613 ungrab (term); // better lose the grab than the session
614 }
615
616 if (htype == HOOK_DESTROY)
617 {
618 clearSVptr ((SV *)term->perl.self);
619 SvREFCNT_dec ((SV *)term->perl.self);
620 }
621
622 swap (perl_environ, environ);
623 return count;
624 }
625 591
626 default: 592 default:
627 rxvt_fatal ("FATAL: unable to pass data type %d\n", dt); 593 rxvt_fatal ("FATAL: unable to pass data type %d\n", dt);
628 } 594 }
629 } 595 }
596
597 call:
598 va_end (ap);
599
600 PUTBACK;
601 int count = call_pv ("urxvt::invoke", G_ARRAY | G_EVAL);
602 SPAGAIN;
603
604 if (count)
605 {
606 SV *status = POPs;
607 count = SvTRUE (status);
608 }
609
610 PUTBACK;
611 FREETMPS;
612 LEAVE;
613
614 if (SvTRUE (ERRSV))
615 {
616 rxvt_warn ("perl hook %d evaluation error: %s", htype, SvPVbyte_nolen (ERRSV));
617 ungrab (term); // better lose the grab than the session
618 }
619
620 event_consumed = !!count;
630 } 621 }
631 catch (...) 622 else
623 event_consumed = false;
624
625 // post-handling of some events
626 if (htype == HOOK_REFRESH_BEGIN)
632 { 627 {
633 swap (perl_environ, environ); 628 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, 0));
634 throw; 629
630 for (int i = AvFILL (av); i >= 0; i--)
631 ((overlay *)SvIV (*av_fetch (av, i, 0)))->swap ();
635 } 632 }
633 else if (htype == HOOK_DESTROY)
634 {
635 clearSVptr ((SV *)term->perl.self);
636 SvREFCNT_dec ((SV *)term->perl.self);
637
638 // don't allow further calls
639 term->perl.self = 0;
640 }
641
642 return event_consumed;
643}
644
645void
646rxvt_perl_interp::selection_finish (rxvt_selection *sel, char *data, unsigned int len)
647{
648 localise_env set_environ (perl_environ);
649
650 ENTER;
651 SAVETMPS;
652
653 dSP;
654 XPUSHs (sv_2mortal (newSVpvn (data, len)));
655 call_sv ((SV *)sel->cb_sv, G_VOID | G_DISCARD | G_EVAL);
656
657 if (SvTRUE (ERRSV))
658 rxvt_warn ("perl selection callback evaluation error: %s", SvPVbyte_nolen (ERRSV));
659
660 FREETMPS;
661 LEAVE;
636} 662}
637 663
638///////////////////////////////////////////////////////////////////////////// 664/////////////////////////////////////////////////////////////////////////////
639 665
640MODULE = urxvt PACKAGE = urxvt 666MODULE = urxvt PACKAGE = urxvt
652# define def(sym) av_store (hookname, HOOK_ ## sym, newSVpv (# sym, 0)); 678# define def(sym) av_store (hookname, HOOK_ ## sym, newSVpv (# sym, 0));
653# include "hookinc.h" 679# include "hookinc.h"
654# undef def 680# undef def
655 681
656 HV *option = get_hv ("urxvt::OPTION", 1); 682 HV *option = get_hv ("urxvt::OPTION", 1);
657# define def(name,val) hv_store (option, # name, sizeof (# name) - 1, newSVuv (Opt_ ## name), 0); 683# define def(name) hv_store (option, # name, sizeof (# name) - 1, newSVuv (Opt_ ## name), 0);
658# define nodef(name) 684# define nodef(name)
659# include "optinc.h" 685# include "optinc.h"
660# undef nodef 686# undef nodef
661# undef def 687# undef def
662 688
663 HV *stash = gv_stashpv ("urxvt", 1); 689 HV *stash = gv_stashpv ("urxvt", 1);
664# define export_const_iv(name) newCONSTSUB (stash, # name, newSViv (name)); 690 static const struct {
691 const char *name;
692 IV iv;
693 } *civ, const_iv[] = {
694# define const_iv(name) { # name, (IV)name }
695 const_iv (NUM_RESOURCES),
665 export_const_iv (DEFAULT_RSTYLE); 696 const_iv (DEFAULT_RSTYLE),
666 export_const_iv (OVERLAY_RSTYLE); 697 const_iv (OVERLAY_RSTYLE),
698 const_iv (Color_Bits),
699 const_iv (RS_bgShift), const_iv (RS_bgMask),
700 const_iv (RS_fgShift), const_iv (RS_fgMask),
701 const_iv (RS_Careful),
702 const_iv (RS_fontCount),
703 const_iv (RS_fontShift),
704 const_iv (RS_fontMask),
705 const_iv (RS_baseattrMask),
706 const_iv (RS_attrMask),
707 const_iv (RS_redraw),
708 const_iv (RS_Sel),
667 export_const_iv (RS_Bold); 709 const_iv (RS_Bold),
668 export_const_iv (RS_Italic); 710 const_iv (RS_Italic),
669 export_const_iv (RS_Blink); 711 const_iv (RS_Blink),
670 export_const_iv (RS_RVid); 712 const_iv (RS_RVid),
671 export_const_iv (RS_Uline); 713 const_iv (RS_Uline),
672 714
673 export_const_iv (CurrentTime); 715 const_iv (CurrentTime),
674 export_const_iv (ShiftMask); 716 const_iv (ShiftMask),
675 export_const_iv (LockMask); 717 const_iv (LockMask),
676 export_const_iv (ControlMask); 718 const_iv (ControlMask),
677 export_const_iv (Mod1Mask); 719 const_iv (Mod1Mask),
678 export_const_iv (Mod2Mask); 720 const_iv (Mod2Mask),
679 export_const_iv (Mod3Mask); 721 const_iv (Mod3Mask),
680 export_const_iv (Mod4Mask); 722 const_iv (Mod4Mask),
681 export_const_iv (Mod5Mask); 723 const_iv (Mod5Mask),
682 export_const_iv (Button1Mask); 724 const_iv (Button1Mask),
683 export_const_iv (Button2Mask); 725 const_iv (Button2Mask),
684 export_const_iv (Button3Mask); 726 const_iv (Button3Mask),
685 export_const_iv (Button4Mask); 727 const_iv (Button4Mask),
686 export_const_iv (Button5Mask); 728 const_iv (Button5Mask),
687 export_const_iv (AnyModifier); 729 const_iv (AnyModifier),
688 730
689 export_const_iv (EVENT_NONE); 731 const_iv (NoSymbol),
690 export_const_iv (EVENT_READ); 732 const_iv (GrabModeSync),
691 export_const_iv (EVENT_WRITE); 733 const_iv (GrabModeAsync),
692}
693 734
694void 735 const_iv (NoEventMask),
695set_should_invoke (int htype, int value) 736 const_iv (KeyPressMask),
696 CODE: 737 const_iv (KeyReleaseMask),
697 rxvt_perl.should_invoke [htype] = value; 738 const_iv (ButtonPressMask),
739 const_iv (ButtonReleaseMask),
740 const_iv (EnterWindowMask),
741 const_iv (LeaveWindowMask),
742 const_iv (PointerMotionMask),
743 const_iv (PointerMotionHintMask),
744 const_iv (Button1MotionMask),
745 const_iv (Button2MotionMask),
746 const_iv (Button3MotionMask),
747 const_iv (Button4MotionMask),
748 const_iv (Button5MotionMask),
749 const_iv (ButtonMotionMask),
750 const_iv (KeymapStateMask),
751 const_iv (ExposureMask),
752 const_iv (VisibilityChangeMask),
753 const_iv (StructureNotifyMask),
754 const_iv (ResizeRedirectMask),
755 const_iv (SubstructureNotifyMask),
756 const_iv (SubstructureRedirectMask),
757 const_iv (FocusChangeMask),
758 const_iv (PropertyChangeMask),
759 const_iv (ColormapChangeMask),
760 const_iv (OwnerGrabButtonMask),
761
762 const_iv (KeyPress),
763 const_iv (KeyRelease),
764 const_iv (ButtonPress),
765 const_iv (ButtonRelease),
766 const_iv (MotionNotify),
767 const_iv (EnterNotify),
768 const_iv (LeaveNotify),
769 const_iv (FocusIn),
770 const_iv (FocusOut),
771 const_iv (KeymapNotify),
772 const_iv (Expose),
773 const_iv (GraphicsExpose),
774 const_iv (NoExpose),
775 const_iv (VisibilityNotify),
776 const_iv (CreateNotify),
777 const_iv (DestroyNotify),
778 const_iv (UnmapNotify),
779 const_iv (MapNotify),
780 const_iv (MapRequest),
781 const_iv (ReparentNotify),
782 const_iv (ConfigureNotify),
783 const_iv (ConfigureRequest),
784 const_iv (GravityNotify),
785 const_iv (ResizeRequest),
786 const_iv (CirculateNotify),
787 const_iv (CirculateRequest),
788 const_iv (PropertyNotify),
789 const_iv (SelectionClear),
790 const_iv (SelectionRequest),
791 const_iv (SelectionNotify),
792 const_iv (ColormapNotify),
793 const_iv (ClientMessage),
794 const_iv (MappingNotify),
795# if ENABLE_XIM_ONTHESPOT
796 const_iv (XIMReverse),
797 const_iv (XIMUnderline),
798 const_iv (XIMHighlight),
799 const_iv (XIMPrimary),
800 const_iv (XIMSecondary),
801 const_iv (XIMTertiary),
802 const_iv (XIMVisibleToForward),
803 const_iv (XIMVisibleToBackword),
804 const_iv (XIMVisibleToCenter),
805#if HAVE_XRENDER
806 const_iv (PictStandardARGB32),
807 const_iv (PictStandardRGB24),
808 const_iv (PictStandardA8),
809 const_iv (PictStandardA4),
810 const_iv (PictStandardA1),
811#endif
812# if 0
813 const_iv (XIMForwardChar),
814 const_iv (XIMBackwardChar),
815 const_iv (XIMForwardWord),
816 const_iv (XIMBackwardWord),
817 const_iv (XIMCaretUp),
818 const_iv (XIMCaretDown),
819 const_iv (XIMNextLine),
820 const_iv (XIMPreviousLine),
821 const_iv (XIMLineStart),
822 const_iv (XIMLineEnd),
823 const_iv (XIMAbsolutePosition),
824 const_iv (XIMDontChange),
825# endif
826# endif
827 };
828
829 for (civ = const_iv + ecb_array_length (const_iv); civ > const_iv; civ--)
830 newCONSTSUB (stash, (char *)civ[-1].name, newSViv (civ[-1].iv));
831}
698 832
699void 833void
700warn (const char *msg) 834warn (const char *msg)
701 CODE: 835 CODE:
702 rxvt_warn ("%s", msg); 836 rxvt_warn ("%s", msg);
704void 838void
705fatal (const char *msg) 839fatal (const char *msg)
706 CODE: 840 CODE:
707 rxvt_fatal ("%s", msg); 841 rxvt_fatal ("%s", msg);
708 842
709SV *
710untaint (SV *sv)
711 CODE:
712 RETVAL = newSVsv (sv);
713 SvTAINTED_off (RETVAL);
714 OUTPUT:
715 RETVAL
716
717void 843void
718_exit (int status) 844_exit (int status)
719
720bool
721safe ()
722 CODE:
723 RETVAL = !rxvt_tainted ();
724 OUTPUT:
725 RETVAL
726 845
727NV 846NV
728NOW () 847NOW ()
729 CODE: 848 CODE:
730 RETVAL = NOW; 849 RETVAL = ev::now ();
731 OUTPUT: 850 OUTPUT:
732 RETVAL 851 RETVAL
733 852
734int 853int
735GET_BASEFG (int rend) 854GET_BASEFG (int rend)
746 RETVAL 865 RETVAL
747 866
748int 867int
749SET_FGCOLOR (int rend, int new_color) 868SET_FGCOLOR (int rend, int new_color)
750 CODE: 869 CODE:
751 RETVAL = SET_FGCOLOR (rend, new_color); 870 RETVAL = SET_FGCOLOR (rend, clamp (new_color, 0, TOTAL_COLORS - 1));
752 OUTPUT: 871 OUTPUT:
753 RETVAL 872 RETVAL
754 873
755int 874int
756SET_BGCOLOR (int rend, int new_color) 875SET_BGCOLOR (int rend, int new_color)
757 CODE: 876 CODE:
758 RETVAL = SET_BGCOLOR (rend, new_color); 877 RETVAL = SET_BGCOLOR (rend, clamp (new_color, 0, TOTAL_COLORS - 1));
759 OUTPUT: 878 OUTPUT:
760 RETVAL 879 RETVAL
761 880
762int 881int
763GET_CUSTOM (int rend) 882GET_CUSTOM (int rend)
764 CODE: 883 CODE:
765 RETVAL = (rend && RS_customMask) >> RS_customShift; 884 RETVAL = (rend & RS_customMask) >> RS_customShift;
766 OUTPUT: 885 OUTPUT:
767 RETVAL 886 RETVAL
768 887
769int 888int
770SET_CUSTOM (int rend, int new_value) 889SET_CUSTOM (int rend, int new_value)
777 | ((new_value << RS_customShift) & RS_customMask); 896 | ((new_value << RS_customShift) & RS_customMask);
778} 897}
779 OUTPUT: 898 OUTPUT:
780 RETVAL 899 RETVAL
781 900
901void
902termlist ()
903 PPCODE:
904{
905 EXTEND (SP, rxvt_term::termlist.size ());
906
907 for (rxvt_term **t = rxvt_term::termlist.begin (); t < rxvt_term::termlist.end (); t++)
908 if ((*t)->perl.self)
909 PUSHs (sv_2mortal (newSVterm (*t)));
910}
911
912IV
913_new_selection_request (rxvt_term *term, int selnum, Time tm, Window win, Atom prop, SV *cb)
914 CODE:
915 rxvt_selection *req = new rxvt_selection (term->display, selnum, tm, win, prop, term);
916 req->cb_sv = newSVsv (cb);
917 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_selection", 10, 0));
918 av_push (av, newSViv ((IV)req));
919 RETVAL = (IV)req;
920 OUTPUT:
921 RETVAL
922
923void
924_delete_selection_request (IV req_)
925 CODE:
926 rxvt_selection *req = (rxvt_selection *)req_;
927 AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)req->term->perl.self), "_selection", 10, 0));
928 int i;
929
930 for (i = AvFILL (av); i >= 0; i--)
931 if (SvIV (*av_fetch (av, i, 1)) == req_)
932 break;
933
934 for (; i < AvFILL (av); i++)
935 av_store (av, i, SvREFCNT_inc (*av_fetch (av, i + 1, 0)));
936
937 av_pop (av);
938
939 delete req;
940
782MODULE = urxvt PACKAGE = urxvt::term 941MODULE = urxvt PACKAGE = urxvt::term
783 942
784SV * 943SV *
785_new (...) 944_new (AV *env, AV *arg)
786 CODE: 945 CODE:
787{ 946{
788 if (items < 1 || !SvROK (ST (0)) || SvTYPE (SvRV (ST (0))) != SVt_PVAV)
789 croak ("first argument to urxvt::term->_new must be arrayref");
790
791 rxvt_term *term = new rxvt_term; 947 rxvt_term *term = new rxvt_term;
792 948
793 term->argv = new stringvec; 949 stringvec *argv = new stringvec;
794 term->envv = new stringvec; 950 for (int i = 0; i <= AvFILL (arg); i++)
795
796 for (int i = 1; i < items; i++)
797 term->argv->push_back (strdup (SvPVbyte_nolen (ST (i)))); 951 argv->push_back (strdup (SvPVbyte_nolen (*av_fetch (arg, i, 1))));
798 952
799 AV *envv = (AV *)SvRV (ST (0)); 953 stringvec *envv = new stringvec;
800 for (int i = av_len (envv) + 1; i--; ) 954 for (int i = AvFILL (env) + 1; i--; )
801 term->envv->push_back (strdup (SvPVbyte_nolen (*av_fetch (envv, i, 1)))); 955 envv->push_back (strdup (SvPVbyte_nolen (*av_fetch (env, i, 1))));
802
803 term->envv->push_back (0);
804
805 bool success;
806 956
807 try 957 try
808 { 958 {
809 success = term->init (term->argv->size (), term->argv->begin ()); 959 term->init (argv, envv);
810 } 960 }
811 catch (const class rxvt_failure_exception &e) 961 catch (const class rxvt_failure_exception &e)
812 {
813 success = false;
814 }
815
816 if (!success)
817 { 962 {
818 term->destroy (); 963 term->destroy ();
819 croak ("error while initializing new terminal instance"); 964 croak ("error while initializing new terminal instance");
820 } 965 }
821 966
827 972
828void 973void
829rxvt_term::destroy () 974rxvt_term::destroy ()
830 975
831void 976void
977rxvt_term::set_should_invoke (int htype, int inc)
978 CODE:
979 THIS->perl.should_invoke [htype] += inc;
980
981int
832rxvt_term::grab_button (int button, U32 modifiers) 982rxvt_term::grab_button (int button, U32 modifiers, Window window = THIS->vt)
833 CODE: 983 CODE:
834 XGrabButton (THIS->display->display, button, modifiers, THIS->vt, 1, 984 RETVAL = XGrabButton (THIS->dpy, button, modifiers, window, 1,
835 ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask, 985 ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
836 GrabModeSync, GrabModeSync, None, GRAB_CURSOR); 986 GrabModeSync, GrabModeSync, None, GRAB_CURSOR);
987 OUTPUT: RETVAL
988
989int
990rxvt_term::ungrab_button (int button, U32 modifiers, Window window = THIS->vt)
991 CODE:
992 RETVAL = XUngrabButton (THIS->dpy, button, modifiers, window);
993 OUTPUT: RETVAL
994
995void
996rxvt_term::XGrabKey (int keycode, U32 modifiers, Window window = THIS->vt, \
997 int owner_events = 1, int pointer_mode = GrabModeAsync, int keyboard_mode = GrabModeAsync)
998 CODE:
999 XGrabKey (THIS->dpy, keycode, modifiers, window, owner_events, pointer_mode, keyboard_mode);
1000
1001void
1002rxvt_term::XUngrabKey (int keycode, U32 modifiers, Window window = THIS->vt)
1003 CODE:
1004 XUngrabKey (THIS->dpy, keycode, modifiers, window);
837 1005
838bool 1006bool
839rxvt_term::grab (U32 eventtime, int sync = 0) 1007rxvt_term::grab (Time eventtime, int sync = 0)
840 CODE: 1008 CODE:
841{ 1009{
842 int mode = sync ? GrabModeSync : GrabModeAsync; 1010 int mode = sync ? GrabModeSync : GrabModeAsync;
843 1011
844 THIS->perl.grabtime = 0; 1012 THIS->perl.grabtime = 0;
845 1013
846 if (!XGrabPointer (THIS->display->display, THIS->vt, 0, 1014 if (!XGrabPointer (THIS->dpy, THIS->vt, 0,
847 ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask, 1015 ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
848 mode, mode, None, GRAB_CURSOR, eventtime)) 1016 mode, mode, None, GRAB_CURSOR, eventtime))
849 if (!XGrabKeyboard (THIS->display->display, THIS->vt, 0, mode, mode, eventtime)) 1017 if (!XGrabKeyboard (THIS->dpy, THIS->vt, 0, mode, mode, eventtime))
850 THIS->perl.grabtime = eventtime; 1018 THIS->perl.grabtime = eventtime;
851 else 1019 else
852 XUngrabPointer (THIS->display->display, eventtime); 1020 XUngrabPointer (THIS->dpy, eventtime);
853 1021
854 RETVAL = !!THIS->perl.grabtime; 1022 RETVAL = !!THIS->perl.grabtime;
855} 1023}
856 OUTPUT: 1024 OUTPUT:
857 RETVAL 1025 RETVAL
858 1026
859void 1027void
860rxvt_term::allow_events_async () 1028rxvt_term::allow_events_async ()
861 CODE: 1029 CODE:
862 XAllowEvents (THIS->display->display, AsyncBoth, THIS->perl.grabtime); 1030 XAllowEvents (THIS->dpy, AsyncBoth, THIS->perl.grabtime);
863 1031
864void 1032void
865rxvt_term::allow_events_sync () 1033rxvt_term::allow_events_sync ()
866 CODE: 1034 CODE:
867 XAllowEvents (THIS->display->display, SyncBoth, THIS->perl.grabtime); 1035 XAllowEvents (THIS->dpy, SyncBoth, THIS->perl.grabtime);
868 1036
869void 1037void
870rxvt_term::allow_events_replay () 1038rxvt_term::allow_events_replay ()
871 CODE: 1039 CODE:
872 XAllowEvents (THIS->display->display, ReplayPointer, THIS->perl.grabtime); 1040 XAllowEvents (THIS->dpy, ReplayPointer, THIS->perl.grabtime);
873 XAllowEvents (THIS->display->display, ReplayKeyboard, THIS->perl.grabtime); 1041 XAllowEvents (THIS->dpy, ReplayKeyboard, THIS->perl.grabtime);
874 1042
875void 1043void
876rxvt_term::ungrab () 1044rxvt_term::ungrab ()
877 CODE: 1045 CODE:
878 ungrab (THIS); 1046 ungrab (THIS);
1047
1048int
1049rxvt_term::XStringToKeysym (char *string)
1050 CODE:
1051 RETVAL = XStringToKeysym (string);
1052 OUTPUT: RETVAL
1053
1054char *
1055rxvt_term::XKeysymToString (int sym)
1056 CODE:
1057 RETVAL = XKeysymToString (sym);
1058 OUTPUT: RETVAL
1059
1060int
1061rxvt_term::XKeysymToKeycode (int sym)
1062 CODE:
1063 RETVAL = XKeysymToKeycode (THIS->dpy, sym);
1064 OUTPUT: RETVAL
1065
1066int
1067rxvt_term::XKeycodeToKeysym (int code, int index)
1068 CODE:
1069 RETVAL = XKeycodeToKeysym (THIS->dpy, code, index);
1070 OUTPUT: RETVAL
879 1071
880int 1072int
881rxvt_term::strwidth (SV *str) 1073rxvt_term::strwidth (SV *str)
882 CODE: 1074 CODE:
883{ 1075{
884 wchar_t *wstr = sv2wcs (str); 1076 wchar_t *wstr = sv2wcs (str);
885 1077
886 rxvt_push_locale (THIS->locale); 1078 rxvt_push_locale (THIS->locale);
887 RETVAL = wcswidth (wstr, wcslen (wstr)); 1079 RETVAL = 0;
1080 for (wchar_t *wc = wstr; *wc; wc++)
1081 {
1082 int w = WCWIDTH (*wc);
1083
1084 if (w)
1085 RETVAL += max (w, 1);
1086 }
888 rxvt_pop_locale (); 1087 rxvt_pop_locale ();
889 1088
890 free (wstr); 1089 free (wstr);
891} 1090}
892 OUTPUT: 1091 OUTPUT:
902 char *mbstr = rxvt_wcstombs (wstr); 1101 char *mbstr = rxvt_wcstombs (wstr);
903 rxvt_pop_locale (); 1102 rxvt_pop_locale ();
904 1103
905 free (wstr); 1104 free (wstr);
906 1105
907 RETVAL = taint_if (newSVpv (mbstr, 0), str); 1106 RETVAL = newSVpv (mbstr, 0);
908 free (mbstr); 1107 free (mbstr);
909} 1108}
910 OUTPUT: 1109 OUTPUT:
911 RETVAL 1110 RETVAL
912 1111
919 1118
920 rxvt_push_locale (THIS->locale); 1119 rxvt_push_locale (THIS->locale);
921 wchar_t *wstr = rxvt_mbstowcs (data, len); 1120 wchar_t *wstr = rxvt_mbstowcs (data, len);
922 rxvt_pop_locale (); 1121 rxvt_pop_locale ();
923 1122
924 RETVAL = taint_if (wcs2sv (wstr), octets); 1123 RETVAL = wcs2sv (wstr);
925 free (wstr); 1124 free (wstr);
926} 1125}
927 OUTPUT: 1126 OUTPUT:
928 RETVAL 1127 RETVAL
929 1128
930#define TERM_OFFSET(sym) offsetof (TermWin_t, sym) 1129#define TERM_OFFSET(sym) offsetof (TermWin_t, sym)
931 1130
932#define TERM_OFFSET_width TERM_OFFSET(width) 1131#define TERM_OFFSET_width TERM_OFFSET(width)
933#define TERM_OFFSET_height TERM_OFFSET(height) 1132#define TERM_OFFSET_height TERM_OFFSET(height)
934#define TERM_OFFSET_fwidth TERM_OFFSET(fwidth) 1133#define TERM_OFFSET_fwidth TERM_OFFSET(fwidth)
935#define TERM_OFFSET_fheight TERM_OFFSET(fheight) 1134#define TERM_OFFSET_fheight TERM_OFFSET(fheight)
936#define TERM_OFFSET_fbase TERM_OFFSET(fbase) 1135#define TERM_OFFSET_fbase TERM_OFFSET(fbase)
937#define TERM_OFFSET_nrow TERM_OFFSET(nrow) 1136#define TERM_OFFSET_nrow TERM_OFFSET(nrow)
938#define TERM_OFFSET_ncol TERM_OFFSET(ncol) 1137#define TERM_OFFSET_ncol TERM_OFFSET(ncol)
939#define TERM_OFFSET_focus TERM_OFFSET(focus) 1138#define TERM_OFFSET_focus TERM_OFFSET(focus)
940#define TERM_OFFSET_mapped TERM_OFFSET(mapped) 1139#define TERM_OFFSET_mapped TERM_OFFSET(mapped)
1140#define TERM_OFFSET_int_bwidth TERM_OFFSET(int_bwidth)
1141#define TERM_OFFSET_ext_bwidth TERM_OFFSET(ext_bwidth)
1142#define TERM_OFFSET_lineSpace TERM_OFFSET(lineSpace)
1143#define TERM_OFFSET_letterSpace TERM_OFFSET(letterSpace)
941#define TERM_OFFSET_saveLines TERM_OFFSET(saveLines) 1144#define TERM_OFFSET_saveLines TERM_OFFSET(saveLines)
942#define TERM_OFFSET_total_rows TERM_OFFSET(total_rows) 1145#define TERM_OFFSET_total_rows TERM_OFFSET(total_rows)
943#define TERM_OFFSET_nsaved TERM_OFFSET(nsaved) 1146#define TERM_OFFSET_top_row TERM_OFFSET(top_row)
944 1147
945int 1148int
946rxvt_term::width () 1149rxvt_term::width ()
947 ALIAS: 1150 ALIAS:
948 width = TERM_OFFSET_width 1151 width = TERM_OFFSET_width
949 height = TERM_OFFSET_height 1152 height = TERM_OFFSET_height
950 fwidth = TERM_OFFSET_fwidth 1153 fwidth = TERM_OFFSET_fwidth
951 fheight = TERM_OFFSET_fheight 1154 fheight = TERM_OFFSET_fheight
952 fbase = TERM_OFFSET_fbase 1155 fbase = TERM_OFFSET_fbase
953 nrow = TERM_OFFSET_nrow 1156 nrow = TERM_OFFSET_nrow
954 ncol = TERM_OFFSET_ncol 1157 ncol = TERM_OFFSET_ncol
955 focus = TERM_OFFSET_focus 1158 focus = TERM_OFFSET_focus
956 mapped = TERM_OFFSET_mapped 1159 mapped = TERM_OFFSET_mapped
1160 int_bwidth = TERM_OFFSET_int_bwidth
1161 ext_bwidth = TERM_OFFSET_ext_bwidth
1162 lineSpace = TERM_OFFSET_lineSpace
1163 letterSpace = TERM_OFFSET_letterSpace
957 saveLines = TERM_OFFSET_saveLines 1164 saveLines = TERM_OFFSET_saveLines
958 total_rows = TERM_OFFSET_total_rows 1165 total_rows = TERM_OFFSET_total_rows
959 nsaved = TERM_OFFSET_nsaved 1166 top_row = TERM_OFFSET_top_row
960 CODE: 1167 CODE:
961 RETVAL = *(int *)((char *)THIS + ix); 1168 RETVAL = *(int *)((char *)THIS + ix);
962 OUTPUT: 1169 OUTPUT:
963 RETVAL 1170 RETVAL
964 1171
966rxvt_term::ModLevel3Mask () 1173rxvt_term::ModLevel3Mask ()
967 ALIAS: 1174 ALIAS:
968 ModLevel3Mask = 0 1175 ModLevel3Mask = 0
969 ModMetaMask = 1 1176 ModMetaMask = 1
970 ModNumLockMask = 2 1177 ModNumLockMask = 2
1178 current_screen = 3
1179 hidden_cursor = 4
971 CODE: 1180 CODE:
972 switch (ix) 1181 switch (ix)
973 { 1182 {
974 case 0: RETVAL = THIS->ModLevel3Mask; break; 1183 case 0: RETVAL = THIS->ModLevel3Mask; break;
975 case 1: RETVAL = THIS->ModMetaMask; break; 1184 case 1: RETVAL = THIS->ModMetaMask; break;
976 case 2: RETVAL = THIS->ModNumLockMask; break; 1185 case 2: RETVAL = THIS->ModNumLockMask; break;
1186 case 3: RETVAL = THIS->current_screen; break;
1187#ifdef CURSOR_BLINK
1188 case 4: RETVAL = THIS->hidden_cursor; break;
1189#endif
977 } 1190 }
978 OUTPUT: 1191 OUTPUT:
979 RETVAL 1192 RETVAL
980 1193
981char * 1194char *
991 } 1204 }
992 OUTPUT: 1205 OUTPUT:
993 RETVAL 1206 RETVAL
994 1207
995SV * 1208SV *
996rxvt_term::_env () 1209rxvt_term::envv ()
1210 ALIAS:
1211 argv = 1
997 CODE: 1212 PPCODE:
998{ 1213{
999 if (THIS->envv) 1214 stringvec *vec = ix ? THIS->argv : THIS->envv;
1000 {
1001 AV *av = newAV ();
1002 1215
1216 EXTEND (SP, vec->size ());
1217
1003 for (char **i = THIS->envv->begin (); i != THIS->envv->end (); ++i) 1218 for (char **i = vec->begin (); i != vec->end (); ++i)
1004 if (*i) 1219 if (*i)
1005 av_push (av, newSVpv (*i, 0)); 1220 PUSHs (sv_2mortal (newSVpv (*i, 0)));
1006
1007 RETVAL = newRV_noinc ((SV *)av);
1008 }
1009 else
1010 RETVAL = &PL_sv_undef;
1011} 1221}
1012 OUTPUT:
1013 RETVAL
1014 1222
1015int 1223int
1016rxvt_term::pty_ev_events (int events = EVENT_UNDEF) 1224rxvt_term::pty_ev_events (int events = ev::UNDEF)
1017 CODE: 1225 CODE:
1018 RETVAL = THIS->pty_ev.events; 1226 RETVAL = THIS->pty_ev.events;
1019 if (events != EVENT_UNDEF) 1227 if (events != ev::UNDEF)
1020 THIS->pty_ev.set (events); 1228 THIS->pty_ev.set (events);
1021 OUTPUT: 1229 OUTPUT:
1022 RETVAL 1230 RETVAL
1023 1231
1024U32 1232int
1233rxvt_term::pty_fd ()
1234 CODE:
1235 RETVAL = THIS->pty->pty;
1236 OUTPUT:
1237 RETVAL
1238
1239Window
1025rxvt_term::parent () 1240rxvt_term::parent ()
1026 CODE: 1241 CODE:
1027 RETVAL = (U32)THIS->parent [0]; 1242 RETVAL = THIS->parent;
1028 OUTPUT: 1243 OUTPUT:
1029 RETVAL 1244 RETVAL
1030 1245
1031U32 1246Window
1032rxvt_term::vt () 1247rxvt_term::vt ()
1033 CODE: 1248 CODE:
1034 RETVAL = (U32)THIS->vt; 1249 RETVAL = THIS->vt;
1035 OUTPUT: 1250 OUTPUT:
1036 RETVAL 1251 RETVAL
1252
1253void
1254rxvt_term::vt_emask_add (U32 emask)
1255 CODE:
1256 THIS->vt_emask_perl |= emask;
1257 THIS->vt_select_input ();
1037 1258
1038U32 1259U32
1039rxvt_term::rstyle (U32 new_rstyle = THIS->rstyle) 1260rxvt_term::rstyle (U32 new_rstyle = THIS->rstyle)
1040 CODE: 1261 CODE:
1041{
1042 RETVAL = THIS->rstyle; 1262 RETVAL = THIS->rstyle;
1043 THIS->rstyle = new_rstyle; 1263 THIS->rstyle = new_rstyle;
1044}
1045 OUTPUT: 1264 OUTPUT:
1046 RETVAL 1265 RETVAL
1047 1266
1048int 1267int
1049rxvt_term::view_start (int newval = -1) 1268rxvt_term::view_start (int newval = 1)
1269 PROTOTYPE: $;$
1050 CODE: 1270 CODE:
1051{ 1271{
1052 RETVAL = THIS->view_start; 1272 RETVAL = THIS->view_start;
1053 1273
1054 if (newval >= 0) 1274 if (newval <= 0)
1055 { 1275 THIS->scr_changeview (max (newval, THIS->top_row));
1056 THIS->view_start = min (newval, THIS->nsaved);
1057 THIS->scr_changeview (RETVAL);
1058 }
1059} 1276}
1060 OUTPUT: 1277 OUTPUT:
1061 RETVAL 1278 RETVAL
1062 1279
1063void 1280void
1281rxvt_term::set_urgency (bool enable)
1282
1283void
1284rxvt_term::focus_in ()
1285
1286void
1287rxvt_term::focus_out ()
1288
1289void
1290rxvt_term::key_press (unsigned int state, unsigned int keycode, Time time = CurrentTime)
1291 ALIAS:
1292 key_release = 1
1293 CODE:
1294{
1295 XKeyEvent xkey;
1296
1297 memset (&xkey, 0, sizeof (xkey));
1298
1299 xkey.time = time;
1300 xkey.state = state;
1301 xkey.keycode = keycode;
1302
1303 xkey.type = ix ? KeyRelease : KeyPress;
1304 xkey.display = THIS->dpy;
1305 xkey.window = THIS->vt;
1306 xkey.root = THIS->display->root;
1307 xkey.subwindow = THIS->vt;
1308
1309 if (ix)
1310 THIS->key_release (xkey);
1311 else
1312 THIS->key_press (xkey);
1313}
1314
1315void
1064rxvt_term::want_refresh () 1316rxvt_term::want_refresh ()
1065 CODE: 1317 CODE:
1066 THIS->want_refresh = 1; 1318 THIS->want_refresh = 1;
1319 THIS->refresh_check ();
1067 1320
1068void 1321void
1069rxvt_term::ROW_t (int row_number, SV *new_text = 0, int start_col = 0, int start_ofs = 0, int max_len = MAX_COLS) 1322rxvt_term::ROW_t (int row_number, SV *new_text = 0, int start_col = 0, int start_ofs = 0, int max_len = MAX_COLS)
1070 PPCODE: 1323 PPCODE:
1071{ 1324{
1072 if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow)) 1325 if (!IN_RANGE_EXC (row_number, THIS->top_row, THIS->nrow))
1073 XSRETURN_EMPTY; 1326 XSRETURN_EMPTY;
1074 1327
1075 line_t &l = ROW(row_number); 1328 line_t &l = ROW(row_number);
1076 1329
1077 if (GIMME_V != G_VOID) 1330 if (GIMME_V != G_VOID)
1078 { 1331 {
1079 wchar_t *wstr = new wchar_t [THIS->ncol]; 1332 wchar_t *wstr = rxvt_temp_buf<wchar_t> (THIS->ncol);
1080 1333
1081 for (int col = 0; col < THIS->ncol; col++) 1334 for (int col = 0; col < THIS->ncol; col++)
1082 wstr [col] = l.t [col]; 1335 wstr [col] = l.t [col];
1083 1336
1084 XPUSHs (taint (sv_2mortal (wcs2sv (wstr, THIS->ncol)))); 1337 XPUSHs (sv_2mortal (wcs2sv (wstr, THIS->ncol)));
1085
1086 delete [] wstr;
1087 } 1338 }
1088 1339
1089 if (new_text) 1340 if (new_text)
1090 { 1341 {
1091 wchar_t *wstr = sv2wcs (new_text); 1342 wchar_t *wstr = sv2wcs (new_text);
1092 1343
1093 int len = min (wcslen (wstr) - start_ofs, max_len); 1344 int len = min (wcslen (wstr) - start_ofs, max_len);
1094 1345
1095 if (!IN_RANGE_INC (start_col, 0, THIS->ncol - len)) 1346 if (start_col < 0 || start_col + len > THIS->ncol)
1096 { 1347 {
1097 free (wstr); 1348 free (wstr);
1098 croak ("new_text extends beyond horizontal margins"); 1349 croak ("new_text extends beyond horizontal margins");
1099 } 1350 }
1100 1351
1110 1361
1111void 1362void
1112rxvt_term::ROW_r (int row_number, SV *new_rend = 0, int start_col = 0, int start_ofs = 0, int max_len = MAX_COLS) 1363rxvt_term::ROW_r (int row_number, SV *new_rend = 0, int start_col = 0, int start_ofs = 0, int max_len = MAX_COLS)
1113 PPCODE: 1364 PPCODE:
1114{ 1365{
1115 if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow)) 1366 if (!IN_RANGE_EXC (row_number, THIS->top_row, THIS->nrow))
1116 XSRETURN_EMPTY; 1367 XSRETURN_EMPTY;
1117 1368
1118 line_t &l = ROW(row_number); 1369 line_t &l = ROW(row_number);
1119 1370
1120 if (GIMME_V != G_VOID) 1371 if (GIMME_V != G_VOID)
1132 { 1383 {
1133 if (!SvROK (new_rend) || SvTYPE (SvRV (new_rend)) != SVt_PVAV) 1384 if (!SvROK (new_rend) || SvTYPE (SvRV (new_rend)) != SVt_PVAV)
1134 croak ("new_rend must be arrayref"); 1385 croak ("new_rend must be arrayref");
1135 1386
1136 AV *av = (AV *)SvRV (new_rend); 1387 AV *av = (AV *)SvRV (new_rend);
1137 int len = min (av_len (av) + 1 - start_ofs, max_len); 1388 int len = min (AvFILL (av) + 1 - start_ofs, max_len);
1138 1389
1139 if (!IN_RANGE_INC (start_col, 0, THIS->ncol - len)) 1390 if (start_col < 0 || start_col + len > THIS->ncol)
1140 croak ("new_rend array extends beyond horizontal margins"); 1391 croak ("new_rend array extends beyond horizontal margins");
1141 1392
1142 for (int col = start_col; col < start_col + len; col++) 1393 for (int col = start_col; col < start_col + len; col++)
1143 { 1394 {
1144 rend_t r = SvIV (*av_fetch (av, start_ofs + col - start_col, 1)) & ~RS_fontMask; 1395 rend_t r = SvIV (*av_fetch (av, start_ofs + col - start_col, 1)) & ~RS_fontMask;
1150 1401
1151int 1402int
1152rxvt_term::ROW_l (int row_number, int new_length = -1) 1403rxvt_term::ROW_l (int row_number, int new_length = -1)
1153 CODE: 1404 CODE:
1154{ 1405{
1155 if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow)) 1406 if (!IN_RANGE_EXC (row_number, THIS->top_row, THIS->nrow))
1156 XSRETURN_EMPTY; 1407 XSRETURN_EMPTY;
1157 1408
1158 line_t &l = ROW(row_number); 1409 line_t &l = ROW(row_number);
1159 RETVAL = l.l; 1410 RETVAL = l.l;
1160 1411
1166 1417
1167bool 1418bool
1168rxvt_term::ROW_is_longer (int row_number, int new_is_longer = -1) 1419rxvt_term::ROW_is_longer (int row_number, int new_is_longer = -1)
1169 CODE: 1420 CODE:
1170{ 1421{
1171 if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow)) 1422 if (!IN_RANGE_EXC (row_number, THIS->top_row, THIS->nrow))
1172 XSRETURN_EMPTY; 1423 XSRETURN_EMPTY;
1173 1424
1174 line_t &l = ROW(row_number); 1425 line_t &l = ROW(row_number);
1175 RETVAL = l.is_longer (); 1426 RETVAL = l.is_longer ();
1176 1427
1184rxvt_term::special_encode (SV *string) 1435rxvt_term::special_encode (SV *string)
1185 CODE: 1436 CODE:
1186{ 1437{
1187 wchar_t *wstr = sv2wcs (string); 1438 wchar_t *wstr = sv2wcs (string);
1188 int wlen = wcslen (wstr); 1439 int wlen = wcslen (wstr);
1189 wchar_t *rstr = new wchar_t [wlen]; // cannot become longer 1440 wchar_t *rstr = rxvt_temp_buf<wchar_t> (wlen * 2); // cannot become longer
1190 1441
1191 rxvt_push_locale (THIS->locale); 1442 rxvt_push_locale (THIS->locale);
1192 1443
1193 wchar_t *r = rstr; 1444 wchar_t *r = rstr;
1194 for (wchar_t *s = wstr; *s; s++) 1445 for (wchar_t *s = wstr; *s; s++)
1446 {
1447 int w = WCWIDTH (*s);
1448
1195 if (wcwidth (*s) == 0) 1449 if (w == 0)
1196 { 1450 {
1197 if (r == rstr) 1451 if (r == rstr)
1198 croak ("leading combining character unencodable"); 1452 croak ("leading combining character unencodable");
1199 1453
1200 unicode_t n = rxvt_compose (r[-1], *s); 1454 unicode_t n = rxvt_compose (r[-1], *s);
1201 if (n == NOCHAR) 1455 if (n == NOCHAR)
1202 n = rxvt_composite.compose (r[-1], *s); 1456 n = rxvt_composite.compose (r[-1], *s);
1203 1457
1204 r[-1] = n; 1458 r[-1] = n;
1205 } 1459 }
1206#if !UNICODE_3 1460#if !UNICODE_3
1207 else if (*s >= 0x10000) 1461 else if (*s >= 0x10000)
1208 *r++ = rxvt_composite.compose (*s); 1462 *r++ = rxvt_composite.compose (*s);
1209#endif 1463#endif
1210 else 1464 else
1211 *r++ = *s; 1465 *r++ = *s;
1466
1467 // the *2 above only allows wcwidth <= 2
1468 if (w > 1)
1469 *r++ = NOCHAR;
1470 }
1212 1471
1213 rxvt_pop_locale (); 1472 rxvt_pop_locale ();
1214 1473
1215 RETVAL = taint_if (wcs2sv (rstr, r - rstr), string); 1474 RETVAL = wcs2sv (rstr, r - rstr);
1216
1217 delete [] rstr;
1218} 1475}
1219 OUTPUT: 1476 OUTPUT:
1220 RETVAL 1477 RETVAL
1221 1478
1222SV * 1479SV *
1223rxvt_term::special_decode (SV *text) 1480rxvt_term::special_decode (SV *text)
1224 CODE: 1481 CODE:
1225{ 1482{
1226 wchar_t *wstr = sv2wcs (text); 1483 wchar_t *wstr = sv2wcs (text);
1227 int wlen = wcslen (wstr);
1228 int dlen = 0; 1484 int dlen = 0;
1229 1485
1230 // find length 1486 // find length
1231 for (wchar_t *s = wstr; *s; s++) 1487 for (wchar_t *s = wstr; *s; s++)
1232 if (*s == NOCHAR) 1488 if (*s == NOCHAR)
1234 else if (IS_COMPOSE (*s)) 1490 else if (IS_COMPOSE (*s))
1235 dlen += rxvt_composite.expand (*s, 0); 1491 dlen += rxvt_composite.expand (*s, 0);
1236 else 1492 else
1237 dlen++; 1493 dlen++;
1238 1494
1239 wchar_t *rstr = new wchar_t [dlen]; 1495 wchar_t *rstr = rxvt_temp_buf<wchar_t> (dlen);
1240 1496
1241 // decode 1497 // decode
1242 wchar_t *r = rstr; 1498 wchar_t *r = rstr;
1243 for (wchar_t *s = wstr; *s; s++) 1499 for (wchar_t *s = wstr; *s; s++)
1244 if (*s == NOCHAR) 1500 if (*s == NOCHAR)
1246 else if (IS_COMPOSE (*s)) 1502 else if (IS_COMPOSE (*s))
1247 r += rxvt_composite.expand (*s, r); 1503 r += rxvt_composite.expand (*s, r);
1248 else 1504 else
1249 *r++ = *s; 1505 *r++ = *s;
1250 1506
1251 RETVAL = taint_if (wcs2sv (rstr, r - rstr), text); 1507 RETVAL = wcs2sv (rstr, r - rstr);
1252
1253 delete [] rstr;
1254} 1508}
1255 OUTPUT: 1509 OUTPUT:
1256 RETVAL 1510 RETVAL
1257 1511
1258void 1512void
1259rxvt_term::_resource (char *name, int index, SV *newval = 0) 1513rxvt_term::_resource (char *name, int index, SV *newval = 0)
1260 PPCODE: 1514 PPCODE:
1261{ 1515{
1262 struct resval { const char *name; int value; } rslist [] = { 1516 static const struct resval { const char *name; int value; } *rs, rslist [] = {
1263# define def(name) { # name, Rs_ ## name }, 1517# define def(name) { # name, Rs_ ## name },
1264# define reserve(name,count) 1518# define reserve(name,count)
1265# include "rsinc.h" 1519# include "rsinc.h"
1266# undef def 1520# undef def
1267# undef reserve 1521# undef reserve
1268 }; 1522 };
1269 1523
1270 struct resval *rs = rslist + sizeof (rslist) / sizeof (rslist [0]); 1524 rs = rslist + ecb_array_length (rslist);
1271 1525
1526 if (*name)
1272 do { 1527 {
1528 do {
1273 if (rs-- == rslist) 1529 if (rs-- == rslist)
1274 croak ("no such resource '%s', requested", name); 1530 croak ("no such resource '%s', requested", name);
1275 } while (strcmp (name, rs->name)); 1531 } while (strcmp (name, rs->name));
1276 1532
1277 index += rs->value; 1533 index += rs->value;
1534 }
1535 else
1536 {
1537 --rs;
1538 name = "";
1539 }
1278 1540
1279 if (!IN_RANGE_EXC (index, 0, NUM_RESOURCES)) 1541 if (!IN_RANGE_EXC (index, 0, NUM_RESOURCES))
1280 croak ("requested out-of-bound resource %s+%d,", name, index - rs->value); 1542 croak ("requested out-of-bound resource %s+%d,", name, index - rs->value);
1281 1543
1282 if (GIMME_V != G_VOID) 1544 if (GIMME_V != G_VOID)
1283 XPUSHs (THIS->rs [index] ? sv_2mortal (taint (newSVpv (THIS->rs [index], 0))) : &PL_sv_undef); 1545 XPUSHs (THIS->rs [index] ? sv_2mortal (newSVpv (THIS->rs [index], 0)) : &PL_sv_undef);
1284 1546
1285 if (newval) 1547 if (newval)
1286 { 1548 {
1287 if (SvOK (newval)) 1549 if (SvOK (newval))
1288 { 1550 {
1295 } 1557 }
1296} 1558}
1297 1559
1298const char * 1560const char *
1299rxvt_term::x_resource (const char *name) 1561rxvt_term::x_resource (const char *name)
1300 CLEANUP:
1301 SvTAINTED_on (ST (0));
1302 1562
1303bool 1563bool
1304rxvt_term::option (U32 optval, int set = -1) 1564rxvt_term::option (U8 optval, int set = -1)
1305 CODE: 1565 CODE:
1306{ 1566{
1307 RETVAL = THIS->options & optval; 1567 RETVAL = THIS->option (optval);
1308 1568
1309 if (set >= 0) 1569 if (set >= 0)
1310 { 1570 {
1311 if (set)
1312 THIS->options |= optval; 1571 THIS->set_option (optval, set);
1313 else
1314 THIS->options &= ~optval;
1315 1572
1573 if (THIS->init_done) // avoid doing this before START
1316 switch (optval) 1574 switch (optval)
1317 { 1575 {
1318 case Opt_skipBuiltinGlyphs: 1576 case Opt_skipBuiltinGlyphs:
1319 THIS->set_fonts (); 1577 THIS->set_fonts ();
1320 THIS->scr_remap_chars (); 1578 THIS->scr_remap_chars ();
1321 THIS->scr_touch (true); 1579 THIS->scr_touch (true);
1322 THIS->want_refresh = 1; 1580 THIS->want_refresh = 1;
1581 THIS->refresh_check ();
1323 break; 1582 break;
1583#ifdef CURSOR_BLINK
1584 case Opt_cursorBlink:
1585 THIS->cursor_blink_reset ();
1586 break;
1587#endif
1324 1588
1325 case Opt_cursorUnderline: 1589 case Opt_cursorUnderline:
1326 THIS->want_refresh = 1; 1590 THIS->want_refresh = 1;
1591 THIS->refresh_check ();
1327 break; 1592 break;
1328 1593
1329# case Opt_scrollBar_floating: 1594# case Opt_scrollBar_floating:
1330# case Opt_scrollBar_right: 1595# case Opt_scrollBar_right:
1331# THIS->resize_all_windows (THIS->width, THIS->height, 1); 1596# THIS->resize_all_windows (THIS->width, THIS->height, 1);
1332# break; 1597# break;
1333 } 1598 }
1334 } 1599 }
1335} 1600}
1336 OUTPUT: 1601 OUTPUT:
1337 RETVAL 1602 RETVAL
1338 1603
1341 CODE: 1606 CODE:
1342 RETVAL = 0 < THIS->parse_keysym (keysym, str); 1607 RETVAL = 0 < THIS->parse_keysym (keysym, str);
1343 THIS->keyboard->register_done (); 1608 THIS->keyboard->register_done ();
1344 OUTPUT: 1609 OUTPUT:
1345 RETVAL 1610 RETVAL
1611
1612void
1613rxvt_term::register_command (int keysym, unsigned int state, SV *str)
1614 CODE:
1615 wchar_t *wstr = sv2wcs (str);
1616 THIS->keyboard->register_user_translation (keysym, state, wstr);
1617 free (wstr);
1346 1618
1347void 1619void
1348rxvt_term::screen_cur (...) 1620rxvt_term::screen_cur (...)
1349 PROTOTYPE: $;$$ 1621 PROTOTYPE: $;$$
1350 ALIAS: 1622 ALIAS:
1364 EXTEND (SP, 2); 1636 EXTEND (SP, 2);
1365 PUSHs (sv_2mortal (newSViv (rc.row))); 1637 PUSHs (sv_2mortal (newSViv (rc.row)));
1366 PUSHs (sv_2mortal (newSViv (rc.col))); 1638 PUSHs (sv_2mortal (newSViv (rc.col)));
1367 } 1639 }
1368 1640
1369 if (items == 3) 1641 if (items >= 3)
1642 {
1643 rc.row = SvIV (ST (1));
1644 rc.col = SvIV (ST (2));
1645
1646 if (ix == 2)
1370 { 1647 {
1371 rc.row = clamp (SvIV (ST (1)), -THIS->nsaved, THIS->nrow - 1); 1648 if (rc.col == 0)
1372 rc.col = clamp (SvIV (ST (2)), 0, THIS->ncol - 1); 1649 {
1650 // col == 0 means end of previous line
1651 rc.row--;
1652 rc.col = THIS->ncol;
1653 }
1654 else if (IN_RANGE_EXC (rc.row, THIS->top_row, THIS->nrow)
1655 && rc.col > ROW(rc.row).l)
1656 {
1657 // col >= length means while line and add newline
1658 rc.col = THIS->ncol;
1659 }
1660 }
1661
1662 clamp_it (rc.col, 0, THIS->ncol);
1663 clamp_it (rc.row, THIS->top_row, THIS->nrow - 1);
1373 1664
1374 if (ix) 1665 if (ix)
1666 {
1667 THIS->selection.screen = THIS->current_screen;
1668
1375 THIS->want_refresh = 1; 1669 THIS->want_refresh = 1;
1670 THIS->refresh_check ();
1376 } 1671 }
1672 }
1377} 1673}
1378 1674
1379char 1675int
1380rxvt_term::cur_charset () 1676rxvt_term::selection_screen (int screen = -1)
1381 CODE: 1677 CODE:
1382 RETVAL = THIS->charsets [THIS->screen.charset]; 1678 RETVAL = THIS->selection.screen;
1383 OUTPUT: 1679 if (screen >= 0)
1680 THIS->selection.screen = screen;
1681 OUTPUT:
1384 RETVAL 1682 RETVAL
1385 1683
1386#void 1684void
1387#rxvt_term::selection_clear () 1685rxvt_term::selection_clear (bool clipboard = false)
1388 1686
1389void 1687void
1390rxvt_term::selection_make (U32 eventtime, bool rect = false) 1688rxvt_term::selection_make (Time eventtime, bool rect = false)
1391 CODE: 1689 CODE:
1392 THIS->selection.op = SELECTION_CONT; 1690 THIS->selection.op = SELECTION_CONT;
1393 THIS->selection.rect = rect; 1691 THIS->selection.rect = rect;
1394 THIS->selection_make (eventtime); 1692 THIS->selection_make (eventtime);
1395 1693
1396int 1694int
1397rxvt_term::selection_grab (U32 eventtime) 1695rxvt_term::selection_grab (Time eventtime, bool clipboard = false)
1398 1696
1399void 1697void
1400rxvt_term::selection (SV *newtext = 0) 1698rxvt_term::selection (SV *newtext = 0, bool clipboard = false)
1401 PPCODE: 1699 PPCODE:
1402{ 1700{
1701 wchar_t * &text = clipboard ? THIS->selection.clip_text : THIS->selection.text;
1702 unsigned int &len = clipboard ? THIS->selection.clip_len : THIS->selection.len;
1703
1403 if (GIMME_V != G_VOID) 1704 if (GIMME_V != G_VOID)
1404 XPUSHs (THIS->selection.text 1705 XPUSHs (text
1405 ? taint (sv_2mortal (wcs2sv (THIS->selection.text, THIS->selection.len))) 1706 ? sv_2mortal (wcs2sv (text, len))
1406 : &PL_sv_undef); 1707 : &PL_sv_undef);
1407 1708
1408 if (newtext) 1709 if (newtext)
1409 { 1710 {
1410 free (THIS->selection.text); 1711 free (text);
1411 1712
1412 THIS->selection.text = sv2wcs (newtext); 1713 text = sv2wcs (newtext);
1413 THIS->selection.len = wcslen (THIS->selection.text); 1714 len = wcslen (text);
1414 } 1715 }
1415} 1716}
1717
1718char
1719rxvt_term::cur_charset ()
1720 CODE:
1721 RETVAL = THIS->charsets [THIS->screen.charset];
1722 OUTPUT:
1723 RETVAL
1416 1724
1417void 1725void
1418rxvt_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) 1726rxvt_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)
1419 1727
1420void 1728void
1421rxvt_term::scr_xor_span (int beg_row, int beg_col, int end_row, int end_col, U32 rstyle = RS_RVid) 1729rxvt_term::scr_xor_span (int beg_row, int beg_col, int end_row, int end_col, U32 rstyle = RS_RVid)
1422 1730
1423void 1731void
1424rxvt_term::scr_bell () 1732rxvt_term::scr_bell ()
1733
1734void
1735rxvt_term::scr_change_screen (int screen)
1425 1736
1426void 1737void
1427rxvt_term::scr_add_lines (SV *string) 1738rxvt_term::scr_add_lines (SV *string)
1428 CODE: 1739 CODE:
1429{ 1740{
1439 char *str = SvPVbyte (octets, len); 1750 char *str = SvPVbyte (octets, len);
1440 C_ARGS: 1751 C_ARGS:
1441 str, len 1752 str, len
1442 1753
1443void 1754void
1755rxvt_term::tt_paste (SV *octets)
1756 INIT:
1757 STRLEN len;
1758 char *str = SvPVbyte (octets, len);
1759 C_ARGS:
1760 str, len
1761
1762void
1444rxvt_term::cmd_parse (SV *octets) 1763rxvt_term::cmd_parse (SV *octets)
1445 CODE: 1764 CODE:
1446{ 1765{
1447 STRLEN len; 1766 STRLEN len;
1448 char *str = SvPVbyte (octets, len); 1767 char *str = SvPVbyte (octets, len);
1470 o->self = (HV *)SvRV (RETVAL); 1789 o->self = (HV *)SvRV (RETVAL);
1471} 1790}
1472 OUTPUT: 1791 OUTPUT:
1473 RETVAL 1792 RETVAL
1474 1793
1794#############################################################################
1795# Various X Utility Functions
1796#############################################################################
1797
1798void
1799rxvt_term::XListProperties (Window window)
1800 PPCODE:
1801{
1802 int count;
1803 Atom *props = XListProperties (THIS->dpy, window, &count);
1804
1805 EXTEND (SP, count);
1806 while (count--)
1807 PUSHs (newSVuv ((U32)props [count]));
1808
1809 XFree (props);
1810}
1811
1812void
1813rxvt_term::XGetWindowProperty (Window window, Atom property)
1814 PPCODE:
1815{
1816 Atom type;
1817 int format;
1818 unsigned long nitems;
1819 unsigned long bytes_after;
1820 unsigned char *prop;
1821
1822 XGetWindowProperty (THIS->dpy, window, property,
1823 0, 1<<24, 0, AnyPropertyType,
1824 &type, &format, &nitems, &bytes_after, &prop);
1825
1826 if (type != None)
1827 {
1828 int elemsize = format == 16 ? sizeof (short)
1829 : format == 32 ? sizeof (long)
1830 : 1;
1831
1832 EXTEND (SP, 3);
1833 PUSHs (newSVuv ((U32)type));
1834 PUSHs (newSViv (format));
1835 PUSHs (newSVpvn ((char *)prop, nitems * elemsize));
1836 XFree (prop);
1837 }
1838}
1839
1840void
1841rxvt_term::XChangeProperty (Window window, Atom property, Atom type, int format, SV *data)
1842 CODE:
1843{
1844 STRLEN len;
1845 char *data_ = SvPVbyte (data, len);
1846
1847 int elemsize = format == 16 ? sizeof (short)
1848 : format == 32 ? sizeof (long)
1849 : 1;
1850
1851 XChangeProperty (THIS->dpy, window, property,
1852 type, format, PropModeReplace,
1853 (unsigned char *)data_, len / elemsize);
1854}
1855
1856Atom
1857XInternAtom (rxvt_term *term, char *atom_name, int only_if_exists = FALSE)
1858 C_ARGS: term->dpy, atom_name, only_if_exists
1859
1860char *
1861XGetAtomName (rxvt_term *term, Atom atom)
1862 C_ARGS: term->dpy, atom
1863 CLEANUP:
1864 XFree (RETVAL);
1865
1866void
1867XDeleteProperty (rxvt_term *term, Window window, Atom property)
1868 C_ARGS: term->dpy, window, property
1869
1870Window
1871rxvt_term::DefaultRootWindow ()
1872 CODE:
1873 RETVAL = THIS->display->root;
1874 OUTPUT:
1875 RETVAL
1876
1877#if 0
1878
1879Window
1880XCreateSimpleWindow (rxvt_term *term, Window parent, int x, int y, unsigned int width, unsigned int height)
1881 C_ARGS: term->dpy, (Window)parent,
1882 x, y, width, height, 0,
1883 term->pix_colors_focused[Color_border],
1884 term->pix_colors_focused[Color_border]
1885
1886#endif
1887
1888void
1889XReparentWindow (rxvt_term *term, Window window, Window parent, int x = 0, int y = 0)
1890 C_ARGS: term->dpy, window, parent, x, y
1891
1892void
1893XMapWindow (rxvt_term *term, Window window)
1894 C_ARGS: term->dpy, window
1895
1896void
1897XUnmapWindow (rxvt_term *term, Window window)
1898 C_ARGS: term->dpy, window
1899
1900void
1901XMoveResizeWindow (rxvt_term *term, Window window, int x, int y, unsigned int width, unsigned int height)
1902 C_ARGS: term->dpy, window, x, y, width, height
1903
1904void
1905rxvt_term::XChangeInput (Window window, U32 add_events, U32 del_events = 0)
1906 CODE:
1907{
1908 XWindowAttributes attr;
1909 XGetWindowAttributes (THIS->dpy, window, &attr);
1910 XSelectInput (THIS->dpy, window, attr.your_event_mask | add_events & ~del_events);
1911}
1912
1913void
1914rxvt_term::XTranslateCoordinates (Window src, Window dst, int x, int y)
1915 PPCODE:
1916{
1917 int dx, dy;
1918 Window child;
1919
1920 if (XTranslateCoordinates (THIS->dpy, src, dst, x, y, &dx, &dy, &child))
1921 {
1922 EXTEND (SP, 3);
1923 PUSHs (newSViv (dx));
1924 PUSHs (newSViv (dy));
1925 PUSHs (newSVuv (child));
1926 }
1927}
1928
1929#############################################################################
1930# fancy bg bloatstuff (TODO: should be moved up somewhere)
1931
1932#ifdef ENABLE_TRANSPARENCY
1933
1934# rxvt_img *
1935# rxvt_term::new_root_img ()
1936# CODE:
1937# RETVAL = rxvt_img::new_from_root (THIS);
1938# OUTPUT:
1939# RETVAL
1940
1941#endif
1942
1943#if HAVE_PIXBUF
1944
1945#endif
1946
1947#############################################################################
1948# urxvt::overlay
1949#############################################################################
1950
1475MODULE = urxvt PACKAGE = urxvt::overlay 1951MODULE = urxvt PACKAGE = urxvt::overlay
1476 1952
1477void 1953void
1478overlay::set (int x, int y, SV *text, SV *rend = 0) 1954overlay::set (int x, int y, SV *text, SV *rend = 0)
1479 1955
1484overlay::hide () 1960overlay::hide ()
1485 1961
1486void 1962void
1487overlay::DESTROY () 1963overlay::DESTROY ()
1488 1964
1965INCLUDE: $PERL <iom_perl.xs -pe s/IOM_MODULE/urxvt/g,s/IOM_CLASS/urxvt/g |
1966
1967MODULE = urxvt PACKAGE = urxvt::pixbuf PREFIX = gdk_pixbuf_
1968
1969#if HAVE_PIXBUF
1970
1971urxvt::pixbuf gdk_pixbuf_new_from_file (SV *klass, octet_string filename)
1972 C_ARGS: filename, 0
1973
1974void
1975DESTROY (urxvt::pixbuf self)
1976 CODE:
1977 gdk_pixbuf_unref (self);
1978
1979#endif
1980
1489MODULE = urxvt PACKAGE = urxvt::timer 1981MODULE = urxvt PACKAGE = urxvt::img
1490 1982
1491SV * 1983#if HAVE_IMG
1492timer::new ()
1493 CODE:
1494 timer *w = new timer;
1495 w->start (NOW);
1496 RETVAL = newSVptr ((void *)w, "urxvt::timer");
1497 w->self = (HV *)SvRV (RETVAL);
1498 OUTPUT:
1499 RETVAL
1500 1984
1501timer * 1985# rxvt_img *new (rxvt_screen *screen, XRenderPictFormat *format, int width, int height)
1502timer::cb (SV *cb) 1986# rxvt_img *rxvt_img (rxvt_screen *screen, XRenderPictFormat *format, int width, int height, Pixmap pixmap);
1503 CODE:
1504 THIS->cb (cb);
1505 RETVAL = THIS;
1506 OUTPUT:
1507 RETVAL
1508 1987
1509NV
1510timer::at ()
1511 CODE:
1512 RETVAL = THIS->at;
1513 OUTPUT:
1514 RETVAL
1515
1516timer *
1517timer::interval (NV interval)
1518 CODE:
1519 THIS->interval = interval;
1520 RETVAL = THIS;
1521 OUTPUT:
1522 RETVAL
1523
1524timer *
1525timer::set (NV tstamp)
1526 CODE:
1527 THIS->set (tstamp);
1528 RETVAL = THIS;
1529 OUTPUT:
1530 RETVAL
1531
1532timer *
1533timer::start (NV tstamp = THIS->at)
1534 CODE:
1535 THIS->start (tstamp);
1536 RETVAL = THIS;
1537 OUTPUT:
1538 RETVAL
1539
1540timer *
1541timer::stop ()
1542 CODE:
1543 THIS->stop ();
1544 RETVAL = THIS;
1545 OUTPUT:
1546 RETVAL
1547
1548void 1988void
1549timer::DESTROY () 1989rxvt_img::fill (SV *c)
1990 INIT:
1991 rxvt_color rc;
1992 parse_color (THIS->s, rc, c);
1993 C_ARGS: rc
1550 1994
1551MODULE = urxvt PACKAGE = urxvt::iow
1552
1553SV *
1554iow::new ()
1555 CODE:
1556 iow *w = new iow;
1557 RETVAL = newSVptr ((void *)w, "urxvt::iow");
1558 w->self = (HV *)SvRV (RETVAL);
1559 OUTPUT:
1560 RETVAL
1561
1562iow *
1563iow::cb (SV *cb)
1564 CODE:
1565 THIS->cb (cb);
1566 RETVAL = THIS;
1567 OUTPUT:
1568 RETVAL
1569
1570iow *
1571iow::fd (int fd)
1572 CODE:
1573 THIS->fd = fd;
1574 RETVAL = THIS;
1575 OUTPUT:
1576 RETVAL
1577
1578iow *
1579iow::events (short events)
1580 CODE:
1581 THIS->events = events;
1582 RETVAL = THIS;
1583 OUTPUT:
1584 RETVAL
1585
1586iow *
1587iow::start ()
1588 CODE:
1589 THIS->start ();
1590 RETVAL = THIS;
1591 OUTPUT:
1592 RETVAL
1593
1594iow *
1595iow::stop ()
1596 CODE:
1597 THIS->stop ();
1598 RETVAL = THIS;
1599 OUTPUT:
1600 RETVAL
1601
1602void 1995void
1603iow::DESTROY () 1996rxvt_img::blur (int rh, int rv)
1604 1997
1998void
1999rxvt_img::brightness (double r, double g, double b, double a = 1.)
1605 2000
2001void
2002rxvt_img::contrast (double r, double g, double b, double a = 1.)
2003
2004rxvt_img *
2005rxvt_img::copy ()
2006
2007rxvt_img *
2008rxvt_img::scale (int new_width, int new_height)
2009
2010# rxvt_img *
2011# rxvt_img::transform (int new_width, int new_height, double matrix[16]);
2012
2013#endif
2014

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines