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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines