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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines