src/rxvtperl.xs

   1 /*----------------------------------------------------------------------*
   2  * File:        rxvtperl.xs
   3  *----------------------------------------------------------------------*
   4  *
   5  * All portions of code are copyright by their respective author/s.
   6  * Copyright (c) 2005-2005 Marc Lehmann <pcg@goof.com>
   7  *
   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
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  *----------------------------------------------------------------------*/
  22
  23 #define line_t perl_line_t
  24 #include <EXTERN.h>
  25 #include <perl.h>
  26 #include <XSUB.h>
  27 #undef line_t
  28
  29 #include "../config.h"
  30
  31 #include <cstdarg>
  32
  33 #include "rxvt.h"
  34 #include "iom.h"
  35 #include "rxvtutil.h"
  36 #include "rxvtperl.h"
  37
  38 #include "perlxsi.c"
  39
  40 #undef LINENO
  41 #define LINENO(n) MOD (THIS->term_start + int(n), THIS->total_rows)
  42 #undef ROW
  43 #define ROW(n) THIS->row_buf [LINENO (n)]
  44
  45 /////////////////////////////////////////////////////////////////////////////
  46
  47 static wchar_t *
  48 sv2wcs (SV *sv)
  49 {
  50   STRLEN len;
  51   char *str = SvPVutf8 (sv, len);
  52   return rxvt_utf8towcs (str, len);
  53 }
  54
  55 static SV *
  56 new_ref (HV *hv, const char *klass)
  57 {
  58   return sv_bless (newRV ((SV *)hv), gv_stashpv (klass, 1));
  59 }
  60
  61 //TODO: use magic
  62 static SV *
  63 newSVptr (void *ptr, const char *klass)
  64 {
  65   HV *hv = newHV ();
  66   sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);
  67   return sv_bless (newRV_noinc ((SV *)hv), gv_stashpv (klass, 1));
  68 }
  69
  70 static void
  71 clearSVptr (SV *sv)
  72 {
  73   if (SvROK (sv))
  74     sv = SvRV (sv);
  75
  76   hv_clear ((HV *)sv);
  77   sv_unmagic (sv, PERL_MAGIC_ext);
  78 }
  79
  80 static long
  81 SvPTR (SV *sv, const char *klass)
  82 {
  83   if (!sv_derived_from (sv, klass))
  84     croak ("object of type %s expected", klass);
  85
  86   MAGIC *mg = mg_find (SvRV (sv), PERL_MAGIC_ext);
  87
  88   if (!mg)
  89     croak ("perl code used %s object, but C++ object is already destroyed, caught", klass);
  90
  91   return (long)mg->mg_ptr;
  92 }
  93
  94 #define newSVterm(term) SvREFCNT_inc ((SV *)term->self)
  95 #define SvTERM(sv) (rxvt_term *)SvPTR (sv, "urxvt::term")
  96
  97 /////////////////////////////////////////////////////////////////////////////
  98
  99 struct perl_watcher
 100 {
 101   SV *cbsv;
 102   HV *self;
 103
 104   perl_watcher ()
 105   : cbsv (newSV (0))
 106   {
 107   }
 108
 109   ~perl_watcher ()
 110   {
 111     SvREFCNT_dec (cbsv);
 112   }
 113
 114   void cb (SV *cb)
 115   {
 116     sv_setsv (cbsv, cb);
 117   }
 118
 119   void invoke (const char *type, SV *self, int arg = -1);
 120 };
 121
 122 void
 123 perl_watcher::invoke (const char *type, SV *self, int arg)
 124 {
 125   dSP;
 126
 127   ENTER;
 128   SAVETMPS;
 129
 130   PUSHMARK (SP);
 131
 132   XPUSHs (sv_2mortal (self));
 133
 134   if (arg >= 0)
 135     XPUSHs (sv_2mortal (newSViv (arg)));
 136
 137   PUTBACK;
 138   call_sv (cbsv, G_VOID | G_EVAL | G_DISCARD);
 139   SPAGAIN;
 140
 141   PUTBACK;
 142   FREETMPS;
 143   LEAVE;
 144
 145   if (SvTRUE (ERRSV))
 146     rxvt_warn ("%s callback evaluation error: %s", type, SvPV_nolen (ERRSV));
 147 }
 148
 149 #define newSVtimer(timer) new_ref (timer->self, "urxvt::timer")
 150 #define SvTIMER(sv) (timer *)SvPTR (sv, "urxvt::timer")
 151
 152 struct timer : time_watcher, perl_watcher
 153 {
 154   tstamp interval;
 155
 156   timer ()
 157   : time_watcher (this, &timer::execute)
 158   {
 159   }
 160
 161   void execute (time_watcher &w)
 162   {
 163     if (interval)
 164       start (at + interval);
 165
 166     invoke ("urxvt::timer", newSVtimer (this));
 167   }
 168 };
 169
 170 #define newSViow(iow) new_ref (iow->self, "urxvt::iow")
 171 #define SvIOW(sv) (iow *)SvPTR (sv, "urxvt::iow")
 172
 173 struct iow : io_watcher, perl_watcher
 174 {
 175   iow ()
 176   : io_watcher (this, &iow::execute)
 177   {
 178   }
 179
 180   void execute (io_watcher &w, short revents)
 181   {
 182     invoke ("urxvt::iow", newSViow (this), revents);
 183   }
 184 };
 185
 186 /////////////////////////////////////////////////////////////////////////////
 187
 188 #define SvOVERLAY(sv) (overlay *)SvPTR (sv, "urxvt::overlay")
 189
 190 struct overlay {
 191   HV *self;
 192   rxvt_term *THIS;
 193   int x, y, w, h;
 194   int border;
 195   text_t **text;
 196   rend_t **rend;
 197
 198   overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border);
 199   ~overlay ();
 200
 201   void show ();
 202   void hide ();
 203
 204   void swap ();
 205
 206   void set (int x, int y, SV *str, SV *rend);
 207 };
 208
 209 overlay::overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border)
 210 : THIS(THIS), x(x_), y(y_), w(w_), h(h_), border(border == 2)
 211 {
 212   if (border == 2)
 213     {
 214       w += 2;
 215       h += 2;
 216     }
 217
 218   text = new text_t *[h];
 219   rend = new rend_t *[h];
 220
 221   for (int y = 0; y < h; y++)
 222     {
 223       text_t *tp = text[y] = new text_t[w];
 224       rend_t *rp = rend[y] = new rend_t[w];
 225
 226       text_t t0, t1, t2;
 227       rend_t r = rstyle;
 228
 229       if (border == 2)
 230         {
 231           if (y == 0)
 232             t0 = 0x2554, t1 = 0x2550, t2 = 0x2557;
 233           else if (y < h - 1)
 234             t0 = 0x2551, t1 = 0x0020, t2 = 0x2551;
 235           else
 236             t0 = 0x255a, t1 = 0x2550, t2 = 0x255d;
 237
 238           *tp++ = t0;
 239           *rp++ = r;
 240
 241           for (int x = w - 2; x-- > 0; )
 242             {
 243               *tp++ = t1;
 244               *rp++ = r;
 245             }
 246
 247           *tp = t2;
 248           *rp = r;
 249         }
 250       else
 251         for (int x = w; x-- > 0; )
 252           {
 253             *tp++ = 0x0020;
 254             *rp++ = r;
 255           }
 256     }
 257
 258   show ();
 259   THIS->want_refresh = 1;
 260 }
 261
 262 overlay::~overlay ()
 263 {
 264   hide ();
 265
 266   for (int y = h; y--; )
 267     {
 268       delete [] text[y];
 269       delete [] rend[y];
 270     }
 271
 272   delete [] text;
 273   delete [] rend;
 274
 275   THIS->want_refresh = 1;
 276 }
 277
 278 void
 279 overlay::show ()
 280 {
 281   char key[33]; sprintf (key, "%32lx", (long)this);
 282
 283   HV *hv = (HV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)THIS->self), "_overlay", 8, 0));
 284   hv_store (hv, key, 32, newSViv ((long)this), 0);
 285 }
 286
 287 void
 288 overlay::hide ()
 289 {
 290   SV **ovs = hv_fetch ((HV *)SvRV ((SV *)THIS->self), "_overlay", 8, 0);
 291
 292   if (ovs)
 293     {
 294       char key[33]; sprintf (key, "%32lx", (long)this);
 295
 296       HV *hv = (HV *)SvRV (*ovs);
 297       hv_delete (hv, key, 32, G_DISCARD);
 298     }
 299 }
 300
 301 void overlay::swap ()
 302 {
 303   int ov_x = max (0, min (MOD (x, THIS->ncol), THIS->ncol - w));
 304   int ov_y = max (0, min (MOD (y, THIS->nrow), THIS->nrow - h));
 305
 306   int ov_w = min (w, THIS->ncol - ov_x);
 307   int ov_h = min (h, THIS->nrow - ov_y);
 308
 309   for (int y = ov_h; y--; )
 310     {
 311       text_t *t1 = text [y];
 312       rend_t *r1 = rend [y];
 313
 314       text_t *t2 = ROW(y + ov_y - THIS->view_start).t + ov_x;
 315       rend_t *r2 = ROW(y + ov_y - THIS->view_start).r + ov_x;
 316
 317       for (int x = ov_w; x--; )
 318         {
 319           text_t t = *t1; *t1++ = *t2; *t2++ = t;
 320           rend_t r = *r1; *r1++ = *r2; *r2++ = SET_FONT (r, THIS->fontset [GET_STYLE (r)]->find_font (t));
 321         }
 322     }
 323
 324 }
 325
 326 void overlay::set (int x, int y, SV *text, SV *rend)
 327 {
 328   x += border;
 329   y += border;
 330
 331   if (!IN_RANGE_EXC (y, 0, h - border))
 332     return;
 333
 334   wchar_t *wtext = sv2wcs (text);
 335
 336   for (int col = min (wcslen (wtext), w - x - border); col--; )
 337     this->text [y][x + col] = wtext [col];
 338
 339   free (wtext);
 340
 341   if (rend)
 342     {
 343       if (!SvROK (rend) || SvTYPE (SvRV (rend)) != SVt_PVAV)
 344         croak ("rend must be arrayref");
 345
 346       AV *av = (AV *)SvRV (rend);
 347
 348       for (int col = min (av_len (av) + 1, w - x - border); col--; )
 349         this->rend [y][x + col] = SvIV (*av_fetch (av, col, 1));
 350     }
 351
 352   THIS->want_refresh = 1;
 353 }
 354
 355
 356 /////////////////////////////////////////////////////////////////////////////
 357
 358 struct rxvt_perl_interp rxvt_perl;
 359
 360 static PerlInterpreter *perl;
 361
 362 rxvt_perl_interp::rxvt_perl_interp ()
 363 {
 364 }
 365
 366 rxvt_perl_interp::~rxvt_perl_interp ()
 367 {
 368   if (perl)
 369     {
 370       perl_destruct (perl);
 371       perl_free (perl);
 372     }
 373 }
 374
 375 void
 376 rxvt_perl_interp::init ()
 377 {
 378   if (!perl)
 379     {
 380       char *argv[] = {
 381         "",
 382         "-edo '" LIBDIR "/urxvt.pm' or ($@ and die $@) or exit 1",
 383       };
 384
 385       perl = perl_alloc ();
 386       perl_construct (perl);
 387
 388       if (perl_parse (perl, xs_init, 2, argv, (char **)NULL)
 389           || perl_run (perl))
 390         {
 391           rxvt_warn ("unable to initialize perl-interpreter, continuing without.\n");
 392
 393           perl_destruct (perl);
 394           perl_free (perl);
 395           perl = 0;
 396         }
 397     }
 398 }
 399
 400 bool
 401 rxvt_perl_interp::invoke (rxvt_term *term, hook_type htype, ...)
 402 {
 403   if (!perl)
 404     return false;
 405
 406   if (htype == HOOK_INIT) // first hook ever called
 407     {
 408       term->self = (void *)newSVptr ((void *)term, "urxvt::term");
 409       hv_store ((HV *)SvRV ((SV *)term->self), "_overlay", 8, newRV_noinc ((SV *)newHV ()), 0);
 410     }
 411   else if (!term->self)
 412     return false; // perl not initialized for this instance
 413   else if (htype == HOOK_DESTROY)
 414     {
 415       // handled later
 416     }
 417   else if (htype == HOOK_REFRESH_BEGIN || htype == HOOK_REFRESH_END)
 418     {
 419       HV *hv = (HV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->self), "_overlay", 8, 0));
 420
 421       if (HvKEYS (hv))
 422         {
 423           hv_iterinit (hv);
 424
 425           while (HE *he = hv_iternext (hv))
 426             ((overlay *)SvIV (hv_iterval (hv, he)))->swap ();
 427         }
 428     }
 429   else if (!should_invoke [htype])
 430     return false;
 431
 432   dSP;
 433   va_list ap;
 434
 435   va_start (ap, htype);
 436
 437   ENTER;
 438   SAVETMPS;
 439
 440   PUSHMARK (SP);
 441
 442   XPUSHs (sv_2mortal (newSVterm (term)));
 443   XPUSHs (sv_2mortal (newSViv (htype)));
 444
 445   for (;;) {
 446     data_type dt = (data_type)va_arg (ap, int);
 447
 448     switch (dt)
 449       {
 450         case DT_INT:
 451           XPUSHs (sv_2mortal (newSViv (va_arg (ap, int))));
 452           break;
 453
 454         case DT_LONG:
 455           XPUSHs (sv_2mortal (newSViv (va_arg (ap, long))));
 456           break;
 457
 458         case DT_STRING:
 459           XPUSHs (sv_2mortal (newSVpv (va_arg (ap, char *), 0)));
 460           break;
 461
 462         case DT_END:
 463           {
 464             va_end (ap);
 465
 466             PUTBACK;
 467             int count = call_pv ("urxvt::invoke", G_ARRAY | G_EVAL);
 468             SPAGAIN;
 469
 470             if (count)
 471               {
 472                 SV *status = POPs;
 473                 count = SvTRUE (status);
 474               }
 475
 476             PUTBACK;
 477             FREETMPS;
 478             LEAVE;
 479
 480             if (SvTRUE (ERRSV))
 481               rxvt_warn ("perl hook %d evaluation error: %s", htype, SvPV_nolen (ERRSV));
 482
 483             if (htype == HOOK_DESTROY)
 484               {
 485                 clearSVptr ((SV *)term->self);
 486                 SvREFCNT_dec ((SV *)term->self);
 487               }
 488
 489             return count;
 490           }
 491
 492         default:
 493           rxvt_fatal ("FATAL: unable to pass data type %d\n", dt);
 494       }
 495   }
 496 }
 497
 498 /////////////////////////////////////////////////////////////////////////////
 499
 500 MODULE = urxvt             PACKAGE = urxvt
 501
 502 PROTOTYPES: ENABLE
 503
 504 BOOT:
 505 {
 506 # define set_hookname(sym) av_store (hookname, PP_CONCAT(HOOK_, sym), newSVpv (PP_STRINGIFY(sym), 0))
 507 # define export_const(name) newCONSTSUB (gv_stashpv ("urxvt", 1), #name, newSViv (name));
 508   AV *hookname = get_av ("urxvt::HOOKNAME", 1);
 509   set_hookname (INIT);
 510   set_hookname (RESET);
 511   set_hookname (START);
 512   set_hookname (DESTROY);
 513   set_hookname (SEL_BEGIN);
 514   set_hookname (SEL_EXTEND);
 515   set_hookname (SEL_MAKE);
 516   set_hookname (SEL_GRAB);
 517   set_hookname (FOCUS_IN);
 518   set_hookname (FOCUS_OUT);
 519   set_hookname (VIEW_CHANGE);
 520   set_hookname (SCROLL_BACK);
 521   set_hookname (TTY_ACTIVITY);
 522   set_hookname (REFRESH_BEGIN);
 523   set_hookname (REFRESH_END);
 524   set_hookname (KEYBOARD_COMMAND);
 525
 526   export_const (DEFAULT_RSTYLE);
 527   export_const (OVERLAY_RSTYLE);
 528   export_const (RS_Bold);
 529   export_const (RS_Italic);
 530   export_const (RS_Blink);
 531   export_const (RS_RVid);
 532   export_const (RS_Uline);
 533
 534   sv_setpv (get_sv ("urxvt::LIBDIR", 1), LIBDIR);
 535 }
 536
 537 void
 538 set_should_invoke (int htype, int value)
 539         CODE:
 540         rxvt_perl.should_invoke [htype] = value;
 541
 542 void
 543 warn (const char *msg)
 544         CODE:
 545         rxvt_warn ("%s", msg);
 546
 547 void
 548 fatal (const char *msg)
 549         CODE:
 550         rxvt_fatal ("%s", msg);
 551
 552 NV
 553 NOW ()
 554         CODE:
 555         RETVAL = NOW;
 556         OUTPUT:
 557         RETVAL
 558
 559 int
 560 GET_BASEFG (int rend)
 561         CODE:
 562         RETVAL = GET_BASEFG (rend);
 563         OUTPUT:
 564         RETVAL
 565
 566 int
 567 GET_BASEBG (int rend)
 568         CODE:
 569         RETVAL = GET_BASEBG (rend);
 570         OUTPUT:
 571         RETVAL
 572
 573 int
 574 SET_FGCOLOR (int rend, int new_color)
 575         CODE:
 576         RETVAL = SET_FGCOLOR (rend, new_color);
 577         OUTPUT:
 578         RETVAL
 579
 580 int
 581 SET_BGCOLOR (int rend, int new_color)
 582         CODE:
 583         RETVAL = SET_BGCOLOR (rend, new_color);
 584         OUTPUT:
 585         RETVAL
 586
 587 int
 588 GET_CUSTOM (int rend)
 589         CODE:
 590         RETVAL = (rend && RS_customMask) >> RS_customShift;
 591         OUTPUT:
 592         RETVAL
 593
 594 int
 595 SET_CUSTOM (int rend, int new_value)
 596         CODE:
 597 {
 598         if (!IN_RANGE_EXC (new_value, 0, RS_customCount))
 599           croak ("custom value out of range, must be 0..%d", RS_customCount - 1);
 600
 601         RETVAL = (rend & ~RS_customMask)
 602                | ((new_value << RS_customShift) & RS_customMask);
 603 }
 604         OUTPUT:
 605         RETVAL
 606
 607 MODULE = urxvt             PACKAGE = urxvt::term
 608
 609 int
 610 rxvt_term::strwidth (SV *str)
 611         CODE:
 612 {
 613         wchar_t *wstr = sv2wcs (str);
 614
 615         rxvt_push_locale (THIS->locale);
 616         RETVAL = wcswidth (wstr, wcslen (wstr));
 617         rxvt_pop_locale ();
 618
 619         free (wstr);
 620 }
 621         OUTPUT:
 622         RETVAL
 623
 624 SV *
 625 rxvt_term::locale_encode (SV *str)
 626         CODE:
 627 {
 628         wchar_t *wstr = sv2wcs (str);
 629
 630         rxvt_push_locale (THIS->locale);
 631         char *mbstr = rxvt_wcstombs (wstr);
 632         rxvt_pop_locale ();
 633
 634         free (wstr);
 635
 636         RETVAL = newSVpv (mbstr, 0);
 637         free (mbstr);
 638 }
 639         OUTPUT:
 640         RETVAL
 641
 642 SV *
 643 rxvt_term::locale_decode (SV *octets)
 644         CODE:
 645 {
 646         STRLEN len;
 647         char *data = SvPVbyte (octets, len);
 648
 649         rxvt_push_locale (THIS->locale);
 650         wchar_t *wstr = rxvt_mbstowcs (data, len);
 651         rxvt_pop_locale ();
 652
 653         char *str = rxvt_wcstoutf8 (wstr);
 654         free (wstr);
 655
 656         RETVAL = newSVpv (str, 0);
 657         SvUTF8_on (RETVAL);
 658         free (str);
 659 }
 660         OUTPUT:
 661         RETVAL
 662
 663 int
 664 rxvt_term::nsaved ()
 665         CODE:
 666         RETVAL = THIS->nsaved;
 667         OUTPUT:
 668         RETVAL
 669
 670 int
 671 rxvt_term::view_start (int newval = -1)
 672         CODE:
 673 {
 674         RETVAL = THIS->view_start;
 675
 676         if (newval >= 0)
 677           {
 678             THIS->view_start = min (newval, THIS->nsaved);
 679             THIS->scr_changeview (RETVAL);
 680           }
 681 }
 682         OUTPUT:
 683         RETVAL
 684
 685 int
 686 rxvt_term::nrow ()
 687         CODE:
 688         RETVAL = THIS->nrow;
 689         OUTPUT:
 690         RETVAL
 691
 692 int
 693 rxvt_term::ncol ()
 694         CODE:
 695         RETVAL = THIS->ncol;
 696         OUTPUT:
 697         RETVAL
 698
 699 void
 700 rxvt_term::want_refresh ()
 701         CODE:
 702         THIS->want_refresh = 1;
 703
 704 void
 705 rxvt_term::ROW_t (int row_number, SV *new_text = 0, int start_col = 0)
 706         PPCODE:
 707 {
 708         if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow))
 709           XSRETURN_EMPTY;
 710
 711         line_t &l = ROW(row_number);
 712
 713         if (GIMME_V != G_VOID)
 714           {
 715             wchar_t *wstr = new wchar_t [THIS->ncol];
 716
 717             for (int col = 0; col <THIS->ncol; col++)
 718               wstr [col] = l.t [col];
 719
 720             char *str = rxvt_wcstoutf8 (wstr, THIS->ncol);
 721             free (wstr);
 722
 723             SV *sv = newSVpv (str, 0);
 724             SvUTF8_on (sv);
 725             XPUSHs (sv_2mortal (sv));
 726             free (str);
 727           }
 728
 729         if (new_text)
 730           {
 731             wchar_t *wstr = sv2wcs (new_text);
 732
 733             int len = wcslen (wstr);
 734
 735             if (!IN_RANGE_INC (start_col, 0, THIS->ncol - len))
 736               {
 737                 free (wstr);
 738                 croak ("new_text extends beyond horizontal margins");
 739               }
 740
 741             for (int col = start_col; col < start_col + len; col++)
 742               {
 743                 l.t [col] = wstr [col - start_col];
 744                 l.r [col] = SET_FONT (l.r [col], THIS->fontset [GET_STYLE (l.r [col])]->find_font (l.t [col]));
 745               }
 746
 747             free (wstr);
 748           }
 749 }
 750
 751 void
 752 rxvt_term::ROW_r (int row_number, SV *new_rend = 0, int start_col = 0)
 753         PPCODE:
 754 {
 755         if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow))
 756           XSRETURN_EMPTY;
 757
 758         line_t &l = ROW(row_number);
 759
 760         if (GIMME_V != G_VOID)
 761           {
 762             AV *av = newAV ();
 763
 764             av_extend (av, THIS->ncol - 1);
 765             for (int col = 0; col < THIS->ncol; col++)
 766               av_store (av, col, newSViv (l.r [col]));
 767
 768             XPUSHs (sv_2mortal (newRV_noinc ((SV *)av)));
 769           }
 770
 771         if (new_rend)
 772           {
 773             if (!SvROK (new_rend) || SvTYPE (SvRV (new_rend)) != SVt_PVAV)
 774               croak ("new_rend must be arrayref");
 775
 776             AV *av = (AV *)SvRV (new_rend);
 777             int len = av_len (av) + 1;
 778
 779             if (!IN_RANGE_INC (start_col, 0, THIS->ncol - len))
 780               croak ("new_rend array extends beyond horizontal margins");
 781
 782             for (int col = start_col; col < start_col + len; col++)
 783               {
 784                 rend_t r = SvIV (*av_fetch (av, col - start_col, 1)) & ~RS_fontMask;
 785
 786                 l.r [col] = SET_FONT (r, THIS->fontset [GET_STYLE (r)]->find_font (l.t [col]));
 787               }
 788           }
 789 }
 790
 791 int
 792 rxvt_term::ROW_l (int row_number, int new_length = -2)
 793         CODE:
 794 {
 795         if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow))
 796           XSRETURN_EMPTY;
 797
 798         line_t &l = ROW(row_number);
 799         RETVAL = l.l < 0 ? THIS->ncol : l.l;
 800
 801         if (new_length >= -1)
 802           l.l = new_length;
 803 }
 804         OUTPUT:
 805         RETVAL
 806
 807 bool
 808 rxvt_term::ROW_is_longer (int row_number)
 809         CODE:
 810 {
 811         if (!IN_RANGE_EXC (row_number, -THIS->nsaved, THIS->nrow))
 812           XSRETURN_EMPTY;
 813
 814         line_t &l = ROW(row_number);
 815         RETVAL = l.l < 0;
 816 }
 817         OUTPUT:
 818         RETVAL
 819
 820 SV *
 821 rxvt_term::special_encode (SV *str)
 822         CODE:
 823         abort ();//TODO
 824
 825 SV *
 826 rxvt_term::special_decode (SV *str)
 827         CODE:
 828         abort ();//TODO
 829
 830 void
 831 rxvt_term::_resource (char *name, int index, SV *newval = 0)
 832         PPCODE:
 833 {
 834         struct resval { const char *name; int value; } rslist [] = {
 835 #         define Rs_def(name) { # name, Rs_ ## name },
 836 #         define Rs_reserve(name,count)
 837 #         include "rsinc.h"
 838 #         undef Rs_def
 839 #         undef Rs_reserve
 840         };
 841
 842         struct resval *rs = rslist + sizeof (rslist) / sizeof (rslist [0]);
 843
 844         do {
 845           if (rs-- == rslist)
 846             croak ("no such resource '%s', requested", name);
 847         } while (strcmp (name, rs->name));
 848
 849         index += rs->value;
 850
 851         if (!IN_RANGE_EXC (index, 0, NUM_RESOURCES))
 852           croak ("requested out-of-bound resource %s+%d,", name, index - rs->value);
 853
 854         if (GIMME_V != G_VOID)
 855           XPUSHs (THIS->rs [index] ? sv_2mortal (newSVpv (THIS->rs [index], 0)) : &PL_sv_undef);
 856
 857         if (newval)
 858           {
 859             if (SvOK (newval))
 860               {
 861                 char *str = strdup (SvPVbyte_nolen (newval));
 862                 THIS->rs [index] = str;
 863                 THIS->allocated.push_back (str);
 864               }
 865             else
 866               THIS->rs [index] = 0;
 867           }
 868 }
 869
 870 void
 871 rxvt_term::selection_mark (...)
 872         PROTOTYPE: $;$$
 873         ALIAS:
 874            selection_beg = 1
 875            selection_end = 2
 876         PPCODE:
 877 {
 878         row_col_t &sel = ix == 1 ? THIS->selection.beg
 879                        : ix == 2 ? THIS->selection.end
 880                        :           THIS->selection.mark;
 881
 882         if (GIMME_V != G_VOID)
 883           {
 884             EXTEND (SP, 2);
 885             PUSHs (sv_2mortal (newSViv (sel.row)));
 886             PUSHs (sv_2mortal (newSViv (sel.col)));
 887           }
 888
 889         if (items == 3)
 890           {
 891             sel.row = clamp (SvIV (ST (1)), -THIS->nsaved, THIS->nrow - 1);
 892             sel.col = clamp (SvIV (ST (2)), 0, THIS->ncol - 1);
 893
 894             if (ix)
 895               THIS->want_refresh = 1;
 896           }
 897 }
 898
 899 int
 900 rxvt_term::selection_grab (int eventtime = CurrentTime)
 901
 902 void
 903 rxvt_term::selection (SV *newtext = 0)
 904         PPCODE:
 905 {
 906         if (GIMME_V != G_VOID)
 907           {
 908             char *sel = rxvt_wcstoutf8 (THIS->selection.text, THIS->selection.len);
 909             SV *sv = newSVpv (sel, 0);
 910             SvUTF8_on (sv);
 911             free (sel);
 912             XPUSHs (sv_2mortal (sv));
 913           }
 914
 915         if (newtext)
 916           {
 917             free (THIS->selection.text);
 918
 919             THIS->selection.text = sv2wcs (newtext);
 920             THIS->selection.len = wcslen (THIS->selection.text);
 921           }
 922 }
 923
 924 void
 925 rxvt_term::tt_write (SV *octets)
 926         INIT:
 927           STRLEN len;
 928           char *str = SvPVbyte (octets, len);
 929         C_ARGS:
 930           (unsigned char *)str, len
 931
 932 SV *
 933 rxvt_term::overlay (int x, int y, int w, int h, int rstyle = OVERLAY_RSTYLE, int border = 2)
 934         CODE:
 935 {
 936         overlay *o = new overlay (THIS, x, y, w, h, rstyle, border);
 937         RETVAL = newSVptr ((void *)o, "urxvt::overlay");
 938         o->self = (HV *)SvRV (RETVAL);
 939 }
 940         OUTPUT:
 941         RETVAL
 942
 943 MODULE = urxvt             PACKAGE = urxvt::overlay
 944
 945 void
 946 overlay::set (int x, int y, SV *text, SV *rend = 0)
 947
 948 void
 949 overlay::show ()
 950
 951 void
 952 overlay::hide ()
 953
 954 void
 955 overlay::DESTROY ()
 956
 957 MODULE = urxvt             PACKAGE = urxvt::timer
 958
 959 SV *
 960 timer::new ()
 961         CODE:
 962         timer *w =  new timer;
 963         w->start (NOW);
 964         RETVAL = newSVptr ((void *)w, "urxvt::timer");
 965         w->self = (HV *)SvRV (RETVAL);
 966         OUTPUT:
 967         RETVAL
 968
 969 timer *
 970 timer::cb (SV *cb)
 971         CODE:
 972         THIS->cb (cb);
 973         RETVAL = THIS;
 974         OUTPUT:
 975         RETVAL
 976
 977 NV
 978 timer::at ()
 979         CODE:
 980         RETVAL = THIS->at;
 981         OUTPUT:
 982         RETVAL
 983
 984 timer *
 985 timer::interval (NV interval)
 986         CODE:
 987         THIS->interval = interval;
 988         RETVAL = THIS;
 989         OUTPUT:
 990         RETVAL
 991
 992 timer *
 993 timer::set (NV tstamp)
 994         CODE:
 995         THIS->set (tstamp);
 996         RETVAL = THIS;
 997         OUTPUT:
 998         RETVAL
 999
1000 timer *
1001 timer::start (NV tstamp = THIS->at)
1002         CODE:
1003         THIS->start (tstamp);
1004         RETVAL = THIS;
1005         OUTPUT:
1006         RETVAL
1007
1008 timer *
1009 timer::stop ()
1010         CODE:
1011         THIS->stop ();
1012         RETVAL = THIS;
1013         OUTPUT:
1014         RETVAL
1015
1016 void
1017 timer::DESTROY ()
1018
1019 MODULE = urxvt             PACKAGE = urxvt::iow
1020
1021 SV *
1022 iow::new ()
1023         CODE:
1024         iow *w =  new iow;
1025         RETVAL = newSVptr ((void *)w, "urxvt::iow");
1026         w->self = (HV *)SvRV (RETVAL);
1027         OUTPUT:
1028         RETVAL
1029
1030 iow *
1031 iow::cb (SV *cb)
1032         CODE:
1033         THIS->cb (cb);
1034         RETVAL = THIS;
1035         OUTPUT:
1036         RETVAL
1037
1038 iow *
1039 iow::fd (int fd)
1040         CODE:
1041         THIS->fd = fd;
1042         RETVAL = THIS;
1043         OUTPUT:
1044         RETVAL
1045
1046 iow *
1047 iow::events (short events)
1048         CODE:
1049         THIS->events = events;
1050         RETVAL = THIS;
1051         OUTPUT:
1052         RETVAL
1053
1054 iow *
1055 iow::start ()
1056         CODE:
1057         THIS->start ();
1058         RETVAL = THIS;
1059         OUTPUT:
1060         RETVAL
1061
1062 iow *
1063 iow::stop ()
1064         CODE:
1065         THIS->stop ();
1066         RETVAL = THIS;
1067         OUTPUT:
1068         RETVAL
1069
1070 void
1071 iow::DESTROY ()
1072
1073