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