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.51 by root, Mon Jan 9 23:00:07 2006 UTC vs.
Revision 1.63 by root, Fri Jan 13 05:06:44 2006 UTC

… …
29#include "../config.h" 29#include "../config.h"
30 30
31#include <cstddef> 31#include <cstddef>
32#include <cstdarg> 32#include <cstdarg>
33 33
34#include "unistd.h"
35
34#include "iom.h" 36#include "iom.h"
35#include "rxvt.h" 37#include "rxvt.h"
36#include "keyboard.h" 38#include "keyboard.h"
37#include "rxvtutil.h" 39#include "rxvtutil.h"
38#include "rxvtperl.h" 40#include "rxvtperl.h"
… …
393 395
394struct rxvt_perl_interp rxvt_perl; 396struct rxvt_perl_interp rxvt_perl;
395 397
396static PerlInterpreter *perl; 398static PerlInterpreter *perl;
397 399
398rxvt_perl_interp::rxvt_perl_interp ()
399{
400}
401
402rxvt_perl_interp::~rxvt_perl_interp () 400rxvt_perl_interp::~rxvt_perl_interp ()
403{ 401{
404 if (perl) 402 if (perl)
405 { 403 {
406 perl_destruct (perl); 404 perl_destruct (perl);
… …
411void 409void
412rxvt_perl_interp::init () 410rxvt_perl_interp::init ()
413{ 411{
414 if (!perl) 412 if (!perl)
415 { 413 {
414 perl_environ = rxvt_environ;
415 swap (perl_environ, environ);
416
416 char *argv[] = { 417 char *argv[] = {
417 "", 418 "",
418 "-T", 419 "-T",
419 "-edo '" LIBDIR "/urxvt.pm' or ($@ and die $@) or exit 1", 420 "-edo '" LIBDIR "/urxvt.pm' or ($@ and die $@) or exit 1",
420 }; 421 };
… …
429 430
430 perl_destruct (perl); 431 perl_destruct (perl);
431 perl_free (perl); 432 perl_free (perl);
432 perl = 0; 433 perl = 0;
433 } 434 }
435
436 swap (perl_environ, environ);
434 } 437 }
435} 438}
436 439
437static void 440static void
438ungrab (rxvt_term *THIS) 441ungrab (rxvt_term *THIS)
… …
476 ((overlay *)SvIV (hv_iterval (hv, he)))->swap (); 479 ((overlay *)SvIV (hv_iterval (hv, he)))->swap ();
477 } 480 }
478 481
479 } 482 }
480 483
481 if (!should_invoke [htype]) 484 if (!term->perl.should_invoke [htype])
482 return false; 485 return false;
483 } 486 }
484 487
488 swap (perl_environ, environ);
489
490 try
491 {
485 dSP; 492 dSP;
486 va_list ap; 493 va_list ap;
487 494
488 va_start (ap, htype); 495 va_start (ap, htype);
489 496
490 ENTER; 497 ENTER;
491 SAVETMPS; 498 SAVETMPS;
492 499
493 PUSHMARK (SP); 500 PUSHMARK (SP);
494 501
495 XPUSHs (sv_2mortal (newSVterm (term))); 502 XPUSHs (sv_2mortal (newSVterm (term)));
496 XPUSHs (sv_2mortal (newSViv (htype))); 503 XPUSHs (sv_2mortal (newSViv (htype)));
497 504
498 for (;;) { 505 for (;;) {
499 data_type dt = (data_type)va_arg (ap, int); 506 data_type dt = (data_type)va_arg (ap, int);
500 507
501 switch (dt) 508 switch (dt)
502 { 509 {
503 case DT_INT: 510 case DT_INT:
504 XPUSHs (sv_2mortal (newSViv (va_arg (ap, int)))); 511 XPUSHs (sv_2mortal (newSViv (va_arg (ap, int))));
505 break; 512 break;
506 513
507 case DT_LONG: 514 case DT_LONG:
508 XPUSHs (sv_2mortal (newSViv (va_arg (ap, long)))); 515 XPUSHs (sv_2mortal (newSViv (va_arg (ap, long))));
509 break; 516 break;
510 517
511 case DT_STR: 518 case DT_STR:
512 XPUSHs (taint (sv_2mortal (newSVpv (va_arg (ap, char *), 0)))); 519 XPUSHs (taint (sv_2mortal (newSVpv (va_arg (ap, char *), 0))));
513 break; 520 break;
514 521
515 case DT_STR_LEN: 522 case DT_STR_LEN:
516 { 523 {
517 char *str = va_arg (ap, char *); 524 char *str = va_arg (ap, char *);
518 int len = va_arg (ap, int); 525 int len = va_arg (ap, int);
519 526
520 XPUSHs (taint (sv_2mortal (newSVpvn (str, len)))); 527 XPUSHs (taint (sv_2mortal (newSVpvn (str, len))));
521 } 528 }
522 break; 529 break;
523 530
524 case DT_WCS_LEN: 531 case DT_WCS_LEN:
525 { 532 {
526 wchar_t *wstr = va_arg (ap, wchar_t *); 533 wchar_t *wstr = va_arg (ap, wchar_t *);
527 int wlen = va_arg (ap, int); 534 int wlen = va_arg (ap, int);
528 535
529 XPUSHs (taint (sv_2mortal (wcs2sv (wstr, wlen)))); 536 XPUSHs (taint (sv_2mortal (wcs2sv (wstr, wlen))));
530 } 537 }
531 break; 538 break;
532 539
533 case DT_XEVENT: 540 case DT_XEVENT:
534 { 541 {
535 XEvent *xe = va_arg (ap, XEvent *); 542 XEvent *xe = va_arg (ap, XEvent *);
536 HV *hv = newHV (); 543 HV *hv = newHV ();
537 544
538# define set(name, sv) hv_store (hv, # name, sizeof (# name) - 1, sv, 0) 545# define set(name, sv) hv_store (hv, # name, sizeof (# name) - 1, sv, 0)
539# define setiv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSViv (val), 0) 546# define setiv(name, val) hv_store (hv, # name, sizeof (# name) - 1, newSViv (val), 0)
540# undef set 547# undef set
541 548
542 setiv (type, xe->type); 549 setiv (type, xe->type);
543 setiv (send_event, xe->xany.send_event); 550 setiv (send_event, xe->xany.send_event);
544 setiv (serial, xe->xany.serial); 551 setiv (serial, xe->xany.serial);
545 552
546 switch (xe->type) 553 switch (xe->type)
554 {
555 case KeyPress:
556 case KeyRelease:
557 case ButtonPress:
558 case ButtonRelease:
559 case MotionNotify:
560 setiv (time, xe->xmotion.time);
561 setiv (x, xe->xmotion.x);
562 setiv (y, xe->xmotion.y);
563 setiv (row, xe->xmotion.y / term->fheight);
564 setiv (col, xe->xmotion.x / term->fwidth);
565 setiv (x_root, xe->xmotion.x_root);
566 setiv (y_root, xe->xmotion.y_root);
567 setiv (state, xe->xmotion.state);
568 break;
569 }
570
571 switch (xe->type)
572 {
573 case KeyPress:
574 case KeyRelease:
575 setiv (keycode, xe->xkey.keycode);
576 break;
577
578 case ButtonPress:
579 case ButtonRelease:
580 setiv (button, xe->xbutton.button);
581 break;
582
583 case MotionNotify:
584 setiv (is_hint, xe->xmotion.is_hint);
585 break;
586 }
587
588 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
589 }
590 break;
591
592 case DT_END:
547 { 593 {
548 case KeyPress: 594 va_end (ap);
549 case KeyRelease: 595
550 case ButtonPress: 596 PUTBACK;
551 case ButtonRelease: 597 int count = call_pv ("urxvt::invoke", G_ARRAY | G_EVAL);
552 case MotionNotify: 598 SPAGAIN;
553 setiv (time, xe->xmotion.time); 599
554 setiv (x, xe->xmotion.x); 600 if (count)
555 setiv (y, xe->xmotion.y);
556 setiv (row, xe->xmotion.y / term->fheight);
557 setiv (col, xe->xmotion.x / term->fwidth);
558 setiv (x_root, xe->xmotion.x_root);
559 setiv (y_root, xe->xmotion.y_root);
560 setiv (state, xe->xmotion.state);
561 break; 601 {
602 SV *status = POPs;
603 count = SvTRUE (status);
604 }
605
606 PUTBACK;
607 FREETMPS;
608 LEAVE;
609
610 if (SvTRUE (ERRSV))
611 {
612 rxvt_warn ("perl hook %d evaluation error: %s", htype, SvPV_nolen (ERRSV));
613 ungrab (term); // better lose the grab than the session
614 }
615
616 if (htype == HOOK_DESTROY)
617 {
618 clearSVptr ((SV *)term->perl.self);
619 SvREFCNT_dec ((SV *)term->perl.self);
620 }
621
622 swap (perl_environ, environ);
623 return count;
562 } 624 }
563 625
564 switch (xe->type)
565 {
566 case KeyPress:
567 case KeyRelease:
568 setiv (keycode, xe->xkey.keycode);
569 break;
570
571 case ButtonPress:
572 case ButtonRelease:
573 setiv (button, xe->xbutton.button);
574 break;
575
576 case MotionNotify:
577 setiv (is_hint, xe->xmotion.is_hint);
578 break;
579 }
580
581 XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
582 }
583 break;
584
585 case DT_END:
586 {
587 va_end (ap);
588
589 PUTBACK;
590 int count = call_pv ("urxvt::invoke", G_ARRAY | G_EVAL);
591 SPAGAIN;
592
593 if (count)
594 {
595 SV *status = POPs;
596 count = SvTRUE (status);
597 }
598
599 PUTBACK;
600 FREETMPS;
601 LEAVE;
602
603 if (SvTRUE (ERRSV))
604 {
605 rxvt_warn ("perl hook %d evaluation error: %s", htype, SvPV_nolen (ERRSV));
606 ungrab (term); // better lose the grab than the session
607 }
608
609 if (htype == HOOK_DESTROY)
610 {
611 clearSVptr ((SV *)term->perl.self);
612 SvREFCNT_dec ((SV *)term->perl.self);
613 }
614
615 return count;
616 }
617
618 default: 626 default:
619 rxvt_fatal ("FATAL: unable to pass data type %d\n", dt); 627 rxvt_fatal ("FATAL: unable to pass data type %d\n", dt);
628 }
620 } 629 }
621 } 630 }
631 catch (...)
632 {
633 swap (perl_environ, environ);
634 throw;
635 }
622} 636}
623 637
624///////////////////////////////////////////////////////////////////////////// 638/////////////////////////////////////////////////////////////////////////////
625 639
626MODULE = urxvt PACKAGE = urxvt 640MODULE = urxvt PACKAGE = urxvt
627 641
628PROTOTYPES: ENABLE 642PROTOTYPES: ENABLE
629 643
630BOOT: 644BOOT:
631{ 645{
632 sv_setsv (get_sv ("urxvt::LIBDIR", 1), newSVpvn (LIBDIR, sizeof (LIBDIR) - 1)); 646 sv_setsv (get_sv ("urxvt::LIBDIR", 1), newSVpvn (LIBDIR, sizeof (LIBDIR) - 1));
647 sv_setsv (get_sv ("urxvt::RESNAME", 1), newSVpvn (RESNAME, sizeof (RESNAME) - 1));
648 sv_setsv (get_sv ("urxvt::RESCLASS", 1), newSVpvn (RESCLASS, sizeof (RESCLASS) - 1));
649 sv_setsv (get_sv ("urxvt::RXVTNAME", 1), newSVpvn (RXVTNAME, sizeof (RXVTNAME) - 1));
633 650
634 AV *hookname = get_av ("urxvt::HOOKNAME", 1); 651 AV *hookname = get_av ("urxvt::HOOKNAME", 1);
635# define def(sym) av_store (hookname, HOOK_ ## sym, newSVpv (# sym, 0)); 652# define def(sym) av_store (hookname, HOOK_ ## sym, newSVpv (# sym, 0));
636# include "hookinc.h" 653# include "hookinc.h"
637# undef def 654# undef def
… …
642# include "optinc.h" 659# include "optinc.h"
643# undef nodef 660# undef nodef
644# undef def 661# undef def
645 662
646 HV *stash = gv_stashpv ("urxvt", 1); 663 HV *stash = gv_stashpv ("urxvt", 1);
647# define export_const_iv(name) newCONSTSUB (stash, # name, newSViv (name)); 664 struct {
665 const char *name;
666 IV iv;
667 } *civ, const_iv[] = {
668# define const_iv(name) { # name, (IV)name }
648 export_const_iv (DEFAULT_RSTYLE); 669 const_iv (DEFAULT_RSTYLE),
649 export_const_iv (OVERLAY_RSTYLE); 670 const_iv (OVERLAY_RSTYLE),
650 export_const_iv (RS_Bold); 671 const_iv (RS_Bold),
651 export_const_iv (RS_Italic); 672 const_iv (RS_Italic),
652 export_const_iv (RS_Blink); 673 const_iv (RS_Blink),
653 export_const_iv (RS_RVid); 674 const_iv (RS_RVid),
654 export_const_iv (RS_Uline); 675 const_iv (RS_Uline),
655 676
656 export_const_iv (CurrentTime); 677 const_iv (CurrentTime),
657 export_const_iv (ShiftMask); 678 const_iv (ShiftMask),
658 export_const_iv (LockMask); 679 const_iv (LockMask),
659 export_const_iv (ControlMask); 680 const_iv (ControlMask),
660 export_const_iv (Mod1Mask); 681 const_iv (Mod1Mask),
661 export_const_iv (Mod2Mask); 682 const_iv (Mod2Mask),
662 export_const_iv (Mod3Mask); 683 const_iv (Mod3Mask),
663 export_const_iv (Mod4Mask); 684 const_iv (Mod4Mask),
664 export_const_iv (Mod5Mask); 685 const_iv (Mod5Mask),
665 export_const_iv (Button1Mask); 686 const_iv (Button1Mask),
666 export_const_iv (Button2Mask); 687 const_iv (Button2Mask),
667 export_const_iv (Button3Mask); 688 const_iv (Button3Mask),
668 export_const_iv (Button4Mask); 689 const_iv (Button4Mask),
669 export_const_iv (Button5Mask); 690 const_iv (Button5Mask),
670 export_const_iv (AnyModifier); 691 const_iv (AnyModifier),
671 692
672 export_const_iv (EVENT_NONE); 693 const_iv (EVENT_NONE),
673 export_const_iv (EVENT_READ); 694 const_iv (EVENT_READ),
674 export_const_iv (EVENT_WRITE); 695 const_iv (EVENT_WRITE),
675}
676 696
677SV * 697 const_iv (NoEventMask),
678new (...) 698 const_iv (KeyPressMask),
679 CODE: 699 const_iv (KeyReleaseMask),
680{ 700 const_iv (ButtonPressMask),
681 stringvec *argv = new stringvec; 701 const_iv (ButtonReleaseMask),
682 bool success; 702 const_iv (EnterWindowMask),
703 const_iv (LeaveWindowMask),
704 const_iv (PointerMotionMask),
705 const_iv (PointerMotionHintMask),
706 const_iv (Button1MotionMask),
707 const_iv (Button2MotionMask),
708 const_iv (Button3MotionMask),
709 const_iv (Button4MotionMask),
710 const_iv (Button5MotionMask),
711 const_iv (ButtonMotionMask),
712 const_iv (KeymapStateMask),
713 const_iv (ExposureMask),
714 const_iv (VisibilityChangeMask),
715 const_iv (StructureNotifyMask),
716 const_iv (ResizeRedirectMask),
717 const_iv (SubstructureNotifyMask),
718 const_iv (SubstructureRedirectMask),
719 const_iv (FocusChangeMask),
720 const_iv (PropertyChangeMask),
721 const_iv (ColormapChangeMask),
722 const_iv (OwnerGrabButtonMask),
683 723
684 for (int i = 0; i < items ;i++) 724 const_iv (KeyPress),
685 argv->push_back (strdup (SvPVbyte_nolen (ST (i)))); 725 const_iv (KeyRelease),
726 const_iv (ButtonPress),
727 const_iv (ButtonRelease),
728 const_iv (MotionNotify),
729 const_iv (EnterNotify),
730 const_iv (LeaveNotify),
731 const_iv (FocusIn),
732 const_iv (FocusOut),
733 const_iv (KeymapNotify),
734 const_iv (Expose),
735 const_iv (GraphicsExpose),
736 const_iv (NoExpose),
737 const_iv (VisibilityNotify),
738 const_iv (CreateNotify),
739 const_iv (DestroyNotify),
740 const_iv (UnmapNotify),
741 const_iv (MapNotify),
742 const_iv (MapRequest),
743 const_iv (ReparentNotify),
744 const_iv (ConfigureNotify),
745 const_iv (ConfigureRequest),
746 const_iv (GravityNotify),
747 const_iv (ResizeRequest),
748 const_iv (CirculateNotify),
749 const_iv (CirculateRequest),
750 const_iv (PropertyNotify),
751 const_iv (SelectionClear),
752 const_iv (SelectionRequest),
753 const_iv (SelectionNotify),
754 const_iv (ColormapNotify),
755 const_iv (ClientMessage),
756 const_iv (MappingNotify),
757 };
686 758
687 rxvt_term *term = new rxvt_term; 759 for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]);
688 760 civ-- > const_iv; )
689 term->argv = argv; 761 newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
690
691 try
692 {
693 if (!term->init (argv->size (), argv->begin ()))
694 term = 0;
695 }
696 catch (const class rxvt_failure_exception &e)
697 {
698 term->destroy ();
699 croak ("exception caught while initializing new terminal instance");
700 }
701
702 RETVAL = term && term->perl.self ? newSVterm (term) : &PL_sv_undef;
703} 762}
704 OUTPUT:
705 RETVAL
706
707void
708set_should_invoke (int htype, int value)
709 CODE:
710 rxvt_perl.should_invoke [htype] = value;
711 763
712void 764void
713warn (const char *msg) 765warn (const char *msg)
714 CODE: 766 CODE:
715 rxvt_warn ("%s", msg); 767 rxvt_warn ("%s", msg);
… …
725 RETVAL = newSVsv (sv); 777 RETVAL = newSVsv (sv);
726 SvTAINTED_off (RETVAL); 778 SvTAINTED_off (RETVAL);
727 OUTPUT: 779 OUTPUT:
728 RETVAL 780 RETVAL
729 781
782void
783_exit (int status)
784
730bool 785bool
731safe () 786safe ()
732 CODE: 787 CODE:
733 RETVAL = !rxvt_tainted (); 788 RETVAL = !rxvt_tainted ();
734 OUTPUT: 789 OUTPUT:
… …
789 OUTPUT: 844 OUTPUT:
790 RETVAL 845 RETVAL
791 846
792MODULE = urxvt PACKAGE = urxvt::term 847MODULE = urxvt PACKAGE = urxvt::term
793 848
849SV *
850_new (...)
851 CODE:
852{
853 if (items < 1 || !SvROK (ST (0)) || SvTYPE (SvRV (ST (0))) != SVt_PVAV)
854 croak ("first argument to urxvt::term->_new must be arrayref");
855
856 rxvt_term *term = new rxvt_term;
857
858 term->argv = new stringvec;
859 term->envv = new stringvec;
860
861 for (int i = 1; i < items; i++)
862 term->argv->push_back (strdup (SvPVbyte_nolen (ST (i))));
863
864 AV *envv = (AV *)SvRV (ST (0));
865 for (int i = av_len (envv) + 1; i--; )
866 term->envv->push_back (strdup (SvPVbyte_nolen (*av_fetch (envv, i, 1))));
867
868 term->envv->push_back (0);
869
870 bool success;
871
872 try
873 {
874 success = term->init (term->argv->size (), term->argv->begin ());
875 }
876 catch (const class rxvt_failure_exception &e)
877 {
878 success = false;
879 }
880
881 if (!success)
882 {
883 term->destroy ();
884 croak ("error while initializing new terminal instance");
885 }
886
887 RETVAL = term && term->perl.self
888 ? newSVterm (term) : &PL_sv_undef;
889}
890 OUTPUT:
891 RETVAL
892
794void 893void
795rxvt_term::destroy () 894rxvt_term::destroy ()
895
896void
897rxvt_term::set_should_invoke (int htype, int inc)
898 CODE:
899 THIS->perl.should_invoke [htype] += inc;
796 900
797void 901void
798rxvt_term::grab_button (int button, U32 modifiers) 902rxvt_term::grab_button (int button, U32 modifiers)
799 CODE: 903 CODE:
800 XGrabButton (THIS->display->display, button, modifiers, THIS->vt, 1, 904 XGrabButton (THIS->display->display, button, modifiers, THIS->vt, 1,
… …
956 case 1: RETVAL = THIS->locale; break; 1060 case 1: RETVAL = THIS->locale; break;
957 } 1061 }
958 OUTPUT: 1062 OUTPUT:
959 RETVAL 1063 RETVAL
960 1064
1065SV *
1066rxvt_term::_env ()
1067 CODE:
1068{
1069 if (THIS->envv)
1070 {
1071 AV *av = newAV ();
1072
1073 for (char **i = THIS->envv->begin (); i != THIS->envv->end (); ++i)
1074 if (*i)
1075 av_push (av, newSVpv (*i, 0));
1076
1077 RETVAL = newRV_noinc ((SV *)av);
1078 }
1079 else
1080 RETVAL = &PL_sv_undef;
1081}
1082 OUTPUT:
1083 RETVAL
1084
961int 1085int
962rxvt_term::pty_ev_events (int events = EVENT_UNDEF) 1086rxvt_term::pty_ev_events (int events = EVENT_UNDEF)
963 CODE: 1087 CODE:
964 RETVAL = THIS->pty_ev.events; 1088 RETVAL = THIS->pty_ev.events;
965 if (events != EVENT_UNDEF) 1089 if (events != EVENT_UNDEF)
… …
979 CODE: 1103 CODE:
980 RETVAL = (U32)THIS->vt; 1104 RETVAL = (U32)THIS->vt;
981 OUTPUT: 1105 OUTPUT:
982 RETVAL 1106 RETVAL
983 1107
1108void
1109rxvt_term::vt_emask_add (U32 emask)
1110 CODE:
1111 THIS->vt_emask_perl |= emask;
1112 THIS->vt_select_input ();
1113
984U32 1114U32
985rxvt_term::rstyle (U32 new_rstyle = THIS->rstyle) 1115rxvt_term::rstyle (U32 new_rstyle = THIS->rstyle)
986 CODE: 1116 CODE:
987{
988 RETVAL = THIS->rstyle; 1117 RETVAL = THIS->rstyle;
989 THIS->rstyle = new_rstyle; 1118 THIS->rstyle = new_rstyle;
990}
991 OUTPUT: 1119 OUTPUT:
992 RETVAL 1120 RETVAL
993 1121
994int 1122int
995rxvt_term::view_start (int newval = -1) 1123rxvt_term::view_start (int newval = -1)
1124 PROTOTYPE: $;$
996 CODE: 1125 CODE:
997{ 1126{
998 RETVAL = THIS->view_start; 1127 RETVAL = THIS->view_start;
999 1128
1000 if (newval >= 0) 1129 if (newval >= 0)
… …
1239 else 1368 else
1240 THIS->rs [index] = 0; 1369 THIS->rs [index] = 0;
1241 } 1370 }
1242} 1371}
1243 1372
1373const char *
1374rxvt_term::x_resource (const char *name)
1375 CLEANUP:
1376 SvTAINTED_on (ST (0));
1377
1244bool 1378bool
1245rxvt_term::option (U32 optval, int set = -1) 1379rxvt_term::option (U32 optval, int set = -1)
1246 CODE: 1380 CODE:
1247{ 1381{
1248 RETVAL = THIS->options & optval; 1382 RETVAL = THIS->options & optval;
… …
1315 if (ix) 1449 if (ix)
1316 THIS->want_refresh = 1; 1450 THIS->want_refresh = 1;
1317 } 1451 }
1318} 1452}
1319 1453
1454char
1455rxvt_term::cur_charset ()
1456 CODE:
1457 RETVAL = THIS->charsets [THIS->screen.charset];
1458 OUTPUT:
1459 RETVAL
1460
1461#void
1462#rxvt_term::selection_clear ()
1463
1464void
1465rxvt_term::selection_make (U32 eventtime, bool rect = false)
1466 CODE:
1467 THIS->selection.op = SELECTION_CONT;
1468 THIS->selection.rect = rect;
1469 THIS->selection_make (eventtime);
1470
1320int 1471int
1321rxvt_term::selection_grab (U32 eventtime) 1472rxvt_term::selection_grab (U32 eventtime)
1322 1473
1323void 1474void
1324rxvt_term::selection (SV *newtext = 0) 1475rxvt_term::selection (SV *newtext = 0)

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines