--- rxvt-unicode/src/urxvt.pm 2006/01/03 04:18:47 1.20 +++ rxvt-unicode/src/urxvt.pm 2006/01/09 23:30:01 1.72 @@ -19,8 +19,8 @@ =head1 DESCRIPTION -Everytime a terminal object gets created, scripts specified via the -C resource are loaded and associated with it. +Everytime a terminal object gets created, extension scripts specified via +the C resource are loaded and associated with it. Scripts are compiled in a 'use strict' and 'use utf8' environment, and thus must be encoded as UTF-8. @@ -39,9 +39,14 @@ =over 4 -=item selection +=item selection (enabled by default) -Miscellaneous selection modifications. +Intelligent selection. This extension tries to be more intelligent when +the user extends selections (double-click). Right now, it tries to select +urls and complete shell-quoted arguments, which is very convenient, too, +if your F supports C<--quoting-style=shell>. + +It also offers the following bindable event: =over 4 @@ -53,10 +58,38 @@ =back +=item option-popup (enabled by default) + +Binds a popup menu to Ctrl-Button2 that lets you toggle (some) options at +runtime. + +=item selection-popup (enabled by default) + +Binds a popup menu to Ctrl-Button3 that lets you convert the selection +text into various other formats/action. + +=item searchable-scrollback (enabled by default) + +Adds regex search functionality to the scrollback buffer, triggered by a +hotkey (default: C). When in search mode, terminal input/output is +suspended, C starts an incremental regex search, C searches further, +C

jumps to the previous match. C leaves search mode at the +current position and C returns to the original position. + =item digital-clock Displays a digital clock using the built-in overlay. +=item mark-urls + +Uses per-line display filtering (C) to underline urls. + +=item block-graphics-to-ascii + +A not very useful example of filtering all text output to the terminal, +by replacing all line-drawing characters (U+2500 .. U+259F) by a +similar-looking ascii character. + =item example-refresh-hooks Displays a very simple digital clock in the upper right corner of the @@ -70,7 +103,7 @@ All objects (such as terminals, time watchers etc.) are typical reference-to-hash objects. The hash can be used to store anything you like. All members starting with an underscore (such as C<_ptr> or -C<_hook>) are reserved for internal uses and must not be accessed or +C<_hook>) are reserved for internal uses and B be accessed or modified). When objects are destroyed on the C++ side, the perl object hashes are @@ -78,23 +111,85 @@ the like inside the terminal object so they get destroyed as soon as the terminal is destroyed. +Argument names also often indicate the type of a parameter. Here are some +hints on what they mean: + +=over 4 + +=item $text + +Rxvt-unicodes special way of encoding text, where one "unicode" character +always represents one screen cell. See L for a discussion of this format. + +=item $string + +A perl text string, with an emphasis on I. It can store all unicode +characters and is to be distinguished with text encoded in a specific +encoding (often locale-specific) and binary data. + +=item $octets + +Either binary data or - more common - a text string encoded in a +locale-specific way. + +=back + +=head2 Extension Objects + +Very perl extension is a perl class. A separate perl object is created +for each terminal and each extension and passed as the first parameter to +hooks. So extensions can use their C<$self> object without having to think +about other extensions, with the exception of methods and members that +begin with an underscore character C<_>: these are reserved for internal +use. + +Although it isn't a C object, you can call all methods of the +C class on this object. + +It has the following methods and data members: + +=over 4 + +=item $urxvt_term = $self->{term} + +Returns the C object associated with this instance of the +extension. This member I be changed in any way. + +=item $self->enable ($hook_name => $cb, [$hook_name => $cb..]) + +Dynamically enable the given hooks (named without the C prefix) for +this extension, replacing any previous hook. This is useful when you want +to overwrite time-critical hooks only temporarily. + +=item $self->disable ($hook_name[, $hook_name..]) + +Dynamically disable the given hooks. + +=back + =head2 Hooks -The following subroutines can be declared in loaded scripts, and will be called -whenever the relevant event happens. +The following subroutines can be declared in extension files, and will be +called whenever the relevant event happens. + +The first argument passed to them is an extension oject as described in +the in the C section. -All of them must return a boolean value. If it is true, then the event -counts as being I, and the invocation of other hooks is skipped, -and the relevant action might not be carried out by the C++ code. +B of these hooks must return a boolean value. If it is true, then the +event counts as being I, and the invocation of other hooks is +skipped, and the relevant action might not be carried out by the C++ code. -When in doubt, return a false value (preferably C<()>). +I<< When in doubt, return a false value (preferably C<()>). >> =over 4 =item on_init $term Called after a new terminal object has been initialized, but before -windows are created or the command gets run. +windows are created or the command gets run. Most methods are unsafe to +call or deliver senseless data, as terminal size and other characteristics +have not yet been determined. You can safely query and change resources, +though. =item on_reset $term @@ -124,15 +219,14 @@ Returning a true value aborts selection grabbing. It will still be hilighted. -=item on_focus_in $term +=item on_sel_extend $term -Called whenever the window gets the keyboard focus, before urxvt does -focus in processing. - -=item on_focus_out $term +Called whenever the user tries to extend the selection (e.g. with a double +click) and is either supposed to return false (normal operation), or +should extend the selection itelf and return true to suppress the built-in +processing. -Called wheneever the window loses keyboard focus, before urxvt does focus -out processing. +See the F example extension. =item on_view_change $term, $offset @@ -150,9 +244,45 @@ $nrow - 1) represent the lines to be scrolled out). C<$saved> is the total number of lines that will be in the scrollback buffer. -=item on_tty_activity $term *NYI* +=item on_osc_seq $term, $string -Called whenever the program(s) running in the urxvt window send output. +Called whenever the B command sequence (OSC = +operating system command) is processed. Cursor position and other state +information is up-to-date when this happens. For interoperability, the +string should start with the extension name and a colon, to distinguish +it from commands for other extensions, and this might be enforced in the +future. + +Be careful not ever to trust (in a security sense) the data you receive, +as its source can not easily be controleld (e-mail content, messages from +other users on the same system etc.). + +=item on_add_lines $term, $string + +Called whenever text is about to be output, with the text as argument. You +can filter/change and output the text yourself by returning a true value +and calling C<< $term->scr_add_lines >> yourself. Please note that this +might be very slow, however, as your hook is called for B text being +output. + +=item on_tt_write $term, $octets + +Called whenever some data is written to the tty/pty and can be used to +suppress or filter tty input. + +=item on_line_update $term, $row + +Called whenever a line was updated or changed. Can be used to filter +screen output (e.g. underline urls or other useless stuff). Only lines +that are being shown will be filtered, and, due to performance reasons, +not always immediately. + +The row number is always the topmost row of the line if the line spans +multiple rows. + +Please note that, if you change the line, then the hook might get called +later with the already-modified line (e.g. if unrelated parts change), so +you cannot just toggle rendition bits, but only set them. =item on_refresh_begin $term @@ -171,12 +301,67 @@ C action bound to it (see description of the B resource in the @@RXVT_NAME@@(1) manpage). +=item on_focus_in $term + +Called whenever the window gets the keyboard focus, before rxvt-unicode +does focus in processing. + +=item on_focus_out $term + +Called wheneever the window loses keyboard focus, before rxvt-unicode does +focus out processing. + +=item on_key_press $term, $event, $keysym, $octets + +=item on_key_release $term, $event, $keysym + +=item on_button_press $term, $event + +=item on_button_release $term, $event + +=item on_motion_notify $term, $event + +=item on_map_notify $term, $event + +=item on_unmap_notify $term, $event + +Called whenever the corresponding X event is received for the terminal If +the hook returns true, then the even will be ignored by rxvt-unicode. + +The event is a hash with most values as named by Xlib (see the XEvent +manpage), with the additional members C and C, which are the row +and column under the mouse cursor. + +C additionally receives the string rxvt-unicode would +output, if any, in locale-specific encoding. + +subwindow. + +=back + +=head2 Variables in the C Package + +=over 4 + +=item $urxvt::TERM + +The current terminal. This variable stores the current C +object, whenever a callback/hook is executing. + =back =head2 Functions in the C Package =over 4 +=item $term = new urxvt [arg...] + +Creates a new terminal, very similar as if you had started it with +C. Croaks (and probably outputs an error message) +if the new instance couldn't be created. Returns C if the new +instance didn't initialise perl, and the terminal object otherwise. The +C and C hooks will be called during the call. + =item urxvt::fatal $errormessage Fatally aborts execution with the given error message. Avoid at all @@ -192,10 +377,26 @@ Using this function has the advantage that its output ends up in the correct place, e.g. on stderr of the connecting urxvtc client. +=item $is_safe = urxvt::safe + +Returns true when it is safe to do potentially unsafe things, such as +evaluating perl code specified by the user. This is true when urxvt was +started setuid or setgid. + =item $time = urxvt::NOW Returns the "current time" (as per the event loop). +=item urxvt::CurrentTime + +=item urxvt::ShiftMask, LockMask, ControlMask, Mod1Mask, Mod2Mask, +Mod3Mask, Mod4Mask, Mod5Mask, Button1Mask, Button2Mask, Button3Mask, +Button4Mask, Button5Mask, AnyModifier + +Various constants for use in X calls and event processing. + +=back + =head2 RENDITION Rendition bitsets contain information about colour, font, font styles and @@ -252,10 +453,17 @@ package urxvt; +use utf8; use strict; +use Carp (); +use Scalar::Util (); +use List::Util (); -our $term; +our $VERSION = 1; +our $TERM; our @HOOKNAME; +our %HOOKTYPE = map +($HOOKNAME[$_] => $_), 0..$#HOOKNAME; +our %OPTION; our $LIBDIR; BEGIN { @@ -268,6 +476,11 @@ unless $msg =~ /\n$/; urxvt::warn ($msg); }; + + delete $ENV{IFS}; + delete $ENV{CDPATH}; + delete $ENV{BASH_ENV}; + $ENV{PATH} = "/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin:/opt/bin:/opt/sbin"; } my @hook_count; @@ -278,95 +491,294 @@ warn "$msg\n" if $level <= $verbosity; } -# find on_xxx subs in the package and register them -# as hooks -sub register_package($) { - my ($pkg) = @_; - - for my $htype (0.. $#HOOKNAME) { - my $name = $HOOKNAME[$htype]; - - my $ref = $pkg->can ("on_" . lc $name) - or next; - - $term->{_hook}[$htype]{$ref*1} = $ref; - $hook_count[$htype]++ - or set_should_invoke $htype, 1; - } -} - -my $script_pkg = "script0000"; -my %script_pkg; +my $extension_pkg = "extension0000"; +my %extension_pkg; # load a single script into its own package, once only -sub script_package($) { +sub extension_package($) { my ($path) = @_; - $script_pkg{$path} ||= do { - my $pkg = "urxvt::" . ($script_pkg++); + $extension_pkg{$path} ||= do { + my $pkg = "urxvt::" . ($extension_pkg++); - verbose 3, "loading script '$path' into package '$pkg'"; + verbose 3, "loading extension '$path' into package '$pkg'"; open my $fh, "<:raw", $path or die "$path: $!"; - my $source = "package $pkg; use strict; use utf8;\n" - . "#line 1 \"$path\"\n{\n" - . (do { local $/; <$fh> }) - . "\n};\n1"; + my $source = untaint + "package $pkg; use strict; use utf8;\n" + . "use base urxvt::term::extension::;\n" + . "#line 1 \"$path\"\n{\n" + . (do { local $/; <$fh> }) + . "\n};\n1"; - eval $source or die "$path: $@"; + eval $source + or die "$path: $@"; $pkg } } +our $retval; # return value for urxvt + # called by the rxvt core sub invoke { - local $term = shift; + local $TERM = shift; my $htype = shift; if ($htype == 0) { # INIT - my @dirs = ((split /:/, $term->resource ("perl_lib")), "$LIBDIR/perl"); + my @dirs = ((split /:/, $TERM->resource ("perl_lib")), "$LIBDIR/perl"); + + my %ext_arg; + + for (map { split /,/, $TERM->resource ("perl_ext_$_") } 1, 2) { + if ($_ eq "default") { + $ext_arg{$_} ||= [] for qw(selection option-popup selection-popup searchable-scrollback); + } elsif (/^-(.*)$/) { + delete $ext_arg{$1}; + } elsif (/^([^<]+)<(.*)>$/) { + push @{ $ext_arg{$1} }, $2; + } else { + $ext_arg{$_} ||= []; + } + } - for my $ext (split /:/, $term->resource ("perl_ext")) { + while (my ($ext, $argv) = each %ext_arg) { my @files = grep -f $_, map "$_/$ext", @dirs; if (@files) { - register_package script_package $files[0]; + $TERM->register_package (extension_package $files[0], $argv); } else { warn "perl extension '$ext' not found in perl library search path\n"; } } - } elsif ($htype == 1) { # DESTROY - if (my $hook = $term->{_hook}) { + eval "#line 1 \"--perl-eval resource/argument\"\n" . $TERM->resource ("perl_eval"); + warn $@ if $@; + } + + $retval = undef; + + if (my $cb = $TERM->{_hook}[$htype]) { + verbose 10, "$HOOKNAME[$htype] (" . (join ", ", $TERM, @_) . ")" + if $verbosity >= 10; + + keys %$cb; + + while (my ($pkg, $cb) = each %$cb) { + $retval = eval { $cb->($TERM->{_pkg}{$pkg}, @_) } + and last; + + if ($@) { + $TERM->ungrab; # better to lose the grab than the session + warn $@; + } + } + } + + if ($htype == 1) { # DESTROY + if (my $hook = delete $TERM->{_hook}) { for my $htype (0..$#$hook) { $hook_count[$htype] -= scalar keys %{ $hook->[$htype] || {} } or set_should_invoke $htype, 0; } } + + # clear package objects + %$_ = () for values %{ $TERM->{_pkg} }; + + # clear package + %$TERM = (); } - my $cb = $term->{_hook}[$htype] - or return; + $retval +} + +# urxvt::term::extension - verbose 10, "$HOOKNAME[$htype] (" . (join ", ", $term, @_) . ")" - if $verbosity >= 10; +package urxvt::term::extension; - while (my ($k, $v) = each %$cb) { - return 1 if $v->($term, @_); +sub enable { + my ($self, %hook) = @_; + my $pkg = $self->{_pkg}; + + while (my ($name, $cb) = each %hook) { + my $htype = $HOOKTYPE{uc $name}; + defined $htype + or Carp::croak "unsupported hook type '$name'"; + + unless (exists $self->{term}{_hook}[$htype]{$pkg}) { + $hook_count[$htype]++ + or urxvt::set_should_invoke $htype, 1; + } + + $self->{term}{_hook}[$htype]{$pkg} = $cb; } +} - 0 +sub disable { + my ($self, @hook) = @_; + my $pkg = $self->{_pkg}; + + for my $name (@hook) { + my $htype = $HOOKTYPE{uc $name}; + defined $htype + or Carp::croak "unsupported hook type '$name'"; + + if (delete $self->{term}{_hook}[$htype]{$pkg}) { + --$hook_count[$htype] + or urxvt::set_should_invoke $htype, 0; + } + } } -=back +our $AUTOLOAD; + +sub AUTOLOAD { + $AUTOLOAD =~ /:([^:]+)$/ + or die "FATAL: \$AUTOLOAD '$AUTOLOAD' unparsable"; + + eval qq{ + sub $AUTOLOAD { + my \$proxy = shift; + \$proxy->{term}->$1 (\@_) + } + 1 + } or die "FATAL: unable to compile method forwarder: $@"; + + goto &$AUTOLOAD; +} + +sub DESTROY { + # nop +} + +# urxvt::destroy_hook + +sub urxvt::destroy_hook::DESTROY { + ${$_[0]}->(); +} + +sub urxvt::destroy_hook(&) { + bless \shift, urxvt::destroy_hook:: +} + +package urxvt::anyevent; + +=head2 The C Class + +The sole purpose of this class is to deliver an interface to the +C module - any module using it will work inside urxvt without +further work. The only exception is that you cannot wait on condition +variables, but non-blocking condvar use is ok. What this means is that you +cannot use blocking APIs, but the non-blocking variant should work. + +=cut + +our $VERSION = 1; + +$INC{"urxvt/anyevent.pm"} = 1; # mark us as there +push @AnyEvent::REGISTRY, [urxvt => urxvt::anyevent::]; + +sub timer { + my ($class, %arg) = @_; + + my $cb = $arg{cb}; + + urxvt::timer + ->new + ->start (urxvt::NOW + $arg{after}) + ->cb (sub { + $_[0]->stop; # need to cancel manually + $cb->(); + }) +} + +sub io { + my ($class, %arg) = @_; + + my $cb = $arg{cb}; + + bless [$arg{fh}, urxvt::iow + ->new + ->fd (fileno $arg{fh}) + ->events (($arg{poll} =~ /r/ ? 1 : 0) + | ($arg{poll} =~ /w/ ? 2 : 0)) + ->start + ->cb (sub { + $cb->(($_[1] & 1 ? 'r' : '') + . ($_[1] & 2 ? 'w' : '')); + })], + urxvt::anyevent:: +} + +sub DESTROY { + $_[0][1]->stop; +} + +sub condvar { + bless \my $flag, urxvt::anyevent::condvar:: +} + +sub urxvt::anyevent::condvar::broadcast { + ${$_[0]}++; +} + +sub urxvt::anyevent::condvar::wait { + unless (${$_[0]}) { + Carp::croak "AnyEvent->condvar blocking wait unsupported in urxvt, use a non-blocking API"; + } +} + +package urxvt::term; =head2 The C Class =over 4 +=cut + +# find on_xxx subs in the package and register them +# as hooks +sub register_package { + my ($self, $pkg, $argv) = @_; + + my $proxy = bless { + _pkg => $pkg, + argv => $argv, + }, $pkg; + Scalar::Util::weaken ($proxy->{term} = $self); + + $self->{_pkg}{$pkg} = $proxy; + + for my $name (@HOOKNAME) { + if (my $ref = $pkg->can ("on_" . lc $name)) { + $proxy->enable ($name => $ref); + } + } +} + +=item $term->destroy + +Destroy the terminal object (close the window, free resources etc.). + +=item $isset = $term->option ($optval[, $set]) + +Returns true if the option specified by C<$optval> is enabled, and +optionally change it. All option values are stored by name in the hash +C<%urxvt::OPTION>. Options not enabled in this binary are not in the hash. + +Here is a a likely non-exhaustive list of option names, please see the +source file F to see the actual list: + + borderLess console cursorBlink cursorUnderline hold iconic insecure + intensityStyles jumpScroll loginShell mapAlert meta8 mouseWheelScrollPage + pastableTabs pointerBlank reverseVideo scrollBar scrollBar_floating + scrollBar_right scrollTtyKeypress scrollTtyOutput scrollWithBuffer + secondaryScreen secondaryScroll skipBuiltinGlyphs transparent + tripleclickwords utmpInhibit visualBell + =item $value = $term->resource ($name[, $newval]) Returns the current resource value associated with a given name and @@ -385,15 +797,15 @@ terminal is destroyed, so changing options frequently will eat memory. Here is a a likely non-exhaustive list of resource names, not all of which -are supported in every build, please see the source to see the actual -list: +are supported in every build, please see the source file F +to see the actual list: answerbackstring backgroundPixmap backspace_key boldFont boldItalicFont borderLess color cursorBlink cursorUnderline cutchars delete_key display_name embed ext_bwidth fade font geometry hold iconName imFont imLocale inputMethod insecure int_bwidth intensityStyles italicFont jumpScroll lineSpace loginShell mapAlert menu meta8 modifier - mouseWheelScrollPage name pastableTabs path perl_eval perl_ext + mouseWheelScrollPage name pastableTabs path perl_eval perl_ext_1 perl_ext_2 perl_lib pointerBlank pointerBlankDelay preeditType print_pipe pty_fd reverseVideo saveLines scrollBar scrollBar_align scrollBar_floating scrollBar_right scrollBar_thickness scrollTtyKeypress scrollTtyOutput @@ -403,12 +815,27 @@ =cut -sub urxvt::term::resource($$;$) { +sub resource($$;$) { my ($self, $name) = (shift, shift); unshift @_, $self, $name, ($name =~ s/\s*\+\s*(\d+)$// ? $1 : 0); - goto &urxvt::term::_resource; + &urxvt::term::_resource } +=item $success = $term->parse_keysym ($keysym_spec, $command_string) + +Adds a keymap translation exactly as specified via a resource. See the +C resource in the @@RXVT_NAME@@(1) manpage. + +=item $rend = $term->rstyle ([$new_rstyle]) + +Return and optionally change the current rendition. Text that is output by +the terminal application will use this style. + +=item ($row, $col) = $term->screen_cur ([$row, $col]) + +Return the current coordinates of the text cursor position and optionally +set it (which is usually bad as applications don't expect that). + =item ($row, $col) = $term->selection_mark ([$row, $col]) =item ($row, $col) = $term->selection_beg ([$row, $col]) @@ -427,25 +854,23 @@ Return the current selection text and optionally replace it by C<$newtext>. -#=item $term->overlay ($x, $y, $text) -# -#Create a simple multi-line overlay box. See the next method for details. -# -#=cut +=item $term->overlay_simple ($x, $y, $text) + +Create a simple multi-line overlay box. See the next method for details. + +=cut -sub urxvt::term::scr_overlay { -die; +sub overlay_simple { my ($self, $x, $y, $text) = @_; my @lines = split /\n/, $text; - my $w = 0; - for (map $self->strwidth ($_), @lines) { - $w = $_ if $w < $_; - } + my $w = List::Util::max map $self->strwidth ($_), @lines; + + my $overlay = $self->overlay ($x, $y, $w, scalar @lines); + $overlay->set (0, $_, $lines[$_]) for 0.. $#lines; - $self->scr_overlay_new ($x, $y, $w, scalar @lines); - $self->scr_overlay_set (0, $_, $lines[$_]) for 0.. $#lines; + $overlay } =item $term->overlay ($x, $y, $width, $height[, $rstyle[, $border]]) @@ -463,7 +888,9 @@ This method returns an urxvt::overlay object. The overlay will be visible as long as the perl object is referenced. -Currently, the only method on the C object is C: +The methods currently supported on C objects are: + +=over 4 =item $overlay->set ($x, $y, $text, $rend) @@ -471,35 +898,153 @@ text in rxvt-unicode's special encoding and an array of rendition values at a specific position inside the overlay. -=item $cellwidth = $term->strwidth $string +=item $overlay->hide + +If visible, hide the overlay, but do not destroy it. + +=item $overlay->show + +If hidden, display the overlay again. + +=back + +=item $popup = $term->popup ($event) + +Creates a new C object that implements a popup menu. The +C<$event> I be the event causing the menu to pop up (a button event, +currently). + +=cut + +sub popup { + my ($self, $event) = @_; + + $self->grab ($event->{time}, 1) + or return; + + my $popup = bless { + term => $self, + event => $event, + }, urxvt::popup::; + + Scalar::Util::weaken $popup->{term}; + + $self->{_destroy}{$popup} = urxvt::destroy_hook { $popup->{popup}->destroy }; + Scalar::Util::weaken $self->{_destroy}{$popup}; + + $popup +} + +=item $cellwidth = $term->strwidth ($string) Returns the number of screen-cells this string would need. Correctly accounts for wide and combining characters. -=item $octets = $term->locale_encode $string +=item $octets = $term->locale_encode ($string) Convert the given text string into the corresponding locale encoding. -=item $string = $term->locale_decode $octets +=item $string = $term->locale_decode ($octets) Convert the given locale-encoded octets into a perl string. +=item $term->scr_xor_span ($beg_row, $beg_col, $end_row, $end_col[, $rstyle]) + +XORs the rendition values in the given span with the provided value +(default: C). Useful in refresh hooks to provide effects similar +to the selection. + +=item $term->scr_xor_rect ($beg_row, $beg_col, $end_row, $end_col[, $rstyle1[, $rstyle2]]) + +Similar to C, but xors a rectangle instead. Trailing +whitespace will additionally be xored with the C<$rstyle2>, which defaults +to C, which removes reverse video again and underlines +it instead. + +=item $term->scr_bell + +Ring the bell! + +=item $term->scr_add_lines ($string) + +Write the given text string to the screen, as if output by the application +running inside the terminal. It may not contain command sequences (escape +codes), but is free to use line feeds, carriage returns and tabs. The +string is a normal text string, not in locale-dependent encoding. + +Normally its not a good idea to use this function, as programs might be +confused by changes in cursor position or scrolling. Its useful inside a +C hook, though. + +=item $term->cmd_parse ($octets) + +Similar to C, but the argument must be in the +locale-specific encoding of the terminal and can contain command sequences +(escape codes) that will be interpreted. + =item $term->tt_write ($octets) Write the octets given in C<$data> to the tty (i.e. as program input). To pass characters instead of octets, you should convert your strings first to the locale-specific encoding using C<< $term->locale_encode >>. -=item $nrow = $term->nrow +=item $old_events = $term->pty_ev_events ([$new_events]) + +Replaces the event mask of the pty watcher by the given event mask. Can +be used to suppress input and output handling to the pty/tty. See the +description of C<< urxvt::timer->events >>. Make sure to always restore +the previous value. + +=item $windowid = $term->parent + +Return the window id of the toplevel window. + +=item $windowid = $term->vt + +Return the window id of the terminal window. + +=item $window_width = $term->width + +=item $window_height = $term->height + +=item $font_width = $term->fwidth + +=item $font_height = $term->fheight + +=item $font_ascent = $term->fbase + +=item $terminal_rows = $term->nrow -=item $ncol = $term->ncol +=item $terminal_columns = $term->ncol -Return the number of rows/columns of the terminal window (i.e. as -specified by C<-geometry>, excluding any scrollback). +=item $has_focus = $term->focus -=item $nsaved = $term->nsaved +=item $is_mapped = $term->mapped -Returns the number of lines in the scrollback buffer. +=item $max_scrollback = $term->saveLines + +=item $nrow_plus_saveLines = $term->total_rows + +=item $lines_in_scrollback = $term->nsaved + +Return various integers describing terminal characteristics. + +=item $lc_ctype = $term->locale + +Returns the LC_CTYPE category string used by this rxvt-unicode. + +=item $x_display = $term->display_id + +Return the DISPLAY used by rxvt-unicode. + +=item $modifiermask = $term->ModLevel3Mask + +=item $modifiermask = $term->ModMetaMask + +=item $modifiermask = $term->ModNumLockMask + +Return the modifier masks corresponding to the "ISO Level 3 Shift" (often +AltGr), the meta key (often Alt) and the num lock key, if applicable. =item $view_start = $term->view_start ([$newvalue]) @@ -520,7 +1065,8 @@ Returns the text of the entire row with number C<$row_number>. Row C<0> is the topmost terminal line, row C<< $term->$ncol-1 >> is the bottommost terminal line. The scrollback buffer starts at line C<-1> and extends to -line C<< -$term->nsaved >>. +line C<< -$term->nsaved >>. Nothing will be returned if a nonexistent line +is requested. If C<$new_text> is specified, it will replace characters in the current line, starting at column C<$start_col> (default C<0>), which is useful @@ -552,9 +1098,129 @@ =item $length = $term->ROW_l ($row_number[, $new_length]) -Returns the number of screen cells that are in use ("the line length"). If -it is C<-1>, then the line is part of a multiple-row logical "line", which -means all characters are in use and it is continued on the next row. +Returns the number of screen cells that are in use ("the line +length"). Unlike the urxvt core, this returns C<< $term->ncol >> if the +line is joined with the following one. + +=item $bool = $term->is_longer ($row_number) + +Returns true if the row is part of a multiple-row logical "line" (i.e. +joined with the following row), which means all characters are in use +and it is continued on the next row (and possibly a continuation of the +previous row(s)). + +=item $line = $term->line ($row_number) + +Create and return a new C object that stores information +about the logical line that row C<$row_number> is part of. It supports the +following methods: + +=over 4 + +=item $text = $line->t ([$new_text]) + +Returns or replaces the full text of the line, similar to C + +=item $rend = $line->r ([$new_rend]) + +Returns or replaces the full rendition array of the line, similar to C + +=item $length = $line->l + +Returns the length of the line in cells, similar to C. + +=item $rownum = $line->beg + +=item $rownum = $line->end + +Return the row number of the first/last row of the line, respectively. + +=item $offset = $line->offset_of ($row, $col) + +Returns the character offset of the given row|col pair within the logical +line. + +=item ($row, $col) = $line->coord_of ($offset) + +Translates a string offset into terminal coordinates again. + +=back + +=cut + +sub line { + my ($self, $row) = @_; + + my $maxrow = $self->nrow - 1; + + my ($beg, $end) = ($row, $row); + + --$beg while $self->ROW_is_longer ($beg - 1); + ++$end while $self->ROW_is_longer ($end) && $end < $maxrow; + + bless { + term => $self, + beg => $beg, + end => $end, + ncol => $self->ncol, + len => ($end - $beg) * $self->ncol + $self->ROW_l ($end), + }, urxvt::line:: +} + +sub urxvt::line::t { + my ($self) = @_; + + if (@_ > 1) + { + $self->{term}->ROW_t ($_, $_[1], 0, ($_ - $self->{beg}) * $self->{ncol}, $self->{ncol}) + for $self->{beg} .. $self->{end}; + } + + defined wantarray && + substr +(join "", map $self->{term}->ROW_t ($_), $self->{beg} .. $self->{end}), + 0, $self->{len} +} + +sub urxvt::line::r { + my ($self) = @_; + + if (@_ > 1) + { + $self->{term}->ROW_r ($_, $_[1], 0, ($_ - $self->{beg}) * $self->{ncol}, $self->{ncol}) + for $self->{beg} .. $self->{end}; + } + + if (defined wantarray) { + my $rend = [ + map @{ $self->{term}->ROW_r ($_) }, $self->{beg} .. $self->{end} + ]; + $#$rend = $self->{len} - 1; + return $rend; + } + + () +} + +sub urxvt::line::beg { $_[0]{beg} } +sub urxvt::line::end { $_[0]{end} } +sub urxvt::line::l { $_[0]{len} } + +sub urxvt::line::offset_of { + my ($self, $row, $col) = @_; + + ($row - $self->{beg}) * $self->{ncol} + $col +} + +sub urxvt::line::coord_of { + my ($self, $offset) = @_; + + use integer; + + ( + $offset / $self->{ncol} + $self->{beg}, + $offset % $self->{ncol} + ) +} =item $text = $term->special_encode $string @@ -567,8 +1233,122 @@ Converts rxvt-unicodes text reprsentation into a perl string. See C<< $term->ROW_t >> for details. +=item $success = $term->grab_button ($button, $modifiermask) + +Registers a synchronous button grab. See the XGrabButton manpage. + +=item $success = $term->grab ($eventtime[, $sync]) + +Calls XGrabPointer and XGrabKeyboard in asynchronous (default) or +synchronous (C<$sync> is true). Also remembers the grab timestampe. + +=item $term->allow_events_async + +Calls XAllowEvents with AsyncBoth for the most recent grab. + +=item $term->allow_events_sync + +Calls XAllowEvents with SyncBoth for the most recent grab. + +=item $term->allow_events_replay + +Calls XAllowEvents with both ReplayPointer and ReplayKeyboard for the most +recent grab. + +=item $term->ungrab + +Calls XUngrab for the most recent grab. Is called automatically on +evaluation errors, as it is better to lose the grab in the error case as +the session. + =back +=cut + +package urxvt::popup; + +=head2 The C Class + +=over 4 + +=cut + +sub add_item { + my ($self, $item) = @_; + + $item->{rend}{normal} = "\x1b[0;30;47m" unless exists $item->{rend}{normal}; + $item->{rend}{hover} = "\x1b[0;30;46m" unless exists $item->{rend}{hover}; + $item->{rend}{active} = "\x1b[m" unless exists $item->{rend}{active}; + + $item->{render} ||= sub { $_[0]{text} }; + + push @{ $self->{item} }, $item; +} + +sub add_separator { + my ($self, $sep) = @_; + + $sep ||= "="; + + $self->add_item ({ + rend => { normal => "\x1b[0;30;47m", hover => "\x1b[0;30;47m", active => "\x1b[0;30;47m" }, + text => "", + render => sub { $sep x $self->{term}->ncol }, + activate => sub { }, + }); +} + +sub add_title { + my ($self, $title) = @_; + + $self->add_item ({ + rend => { normal => "\x1b[38;5;11;44m", hover => "\x1b[38;5;11;44m", active => "\x1b[38;5;11;44m" }, + text => $title, + activate => sub { }, + }); +} + +sub add_button { + my ($self, $text, $cb) = @_; + + $self->add_item ({ type => "button", text => $text, activate => $cb}); +} + +sub add_toggle { + my ($self, $text, $cb, $value) = @_; + + my $item; $item = { + type => "button", + text => " $text", + value => $value, + render => sub { ($_[0]{value} ? "* " : " ") . $text }, + activate => sub { $cb->($_[0]{value} = !$_[0]{value}); }, + }; + + $self->add_item ($item); +} + +sub show { + my ($self) = @_; + + local $urxvt::popup::self = $self; + + local $ENV{LC_ALL} = $self->{term}->locale; + + urxvt->new ("--perl-lib" => "", "--perl-ext-common" => "", "-pty-fd" => -1, "-sl" => 0, "-b" => 0, + "--transient-for" => $self->{term}->parent, + "-display" => $self->{term}->display_id, + "-pe" => "urxvt-popup") + or die "unable to create popup window\n"; +} + +sub DESTROY { + my ($self) = @_; + + delete $self->{term}{_destroy}{$self}; + $self->{term}->ungrab; +} + =head2 The C Class This class implements timer watchers/events. Time is represented as a @@ -630,7 +1410,7 @@ $term->{iow} = urxvt::iow ->new ->fd (fileno $term->{socket}) - ->events (1) # wait for read data + ->events (urxvt::EVENT_READ) ->start ->cb (sub { my ($iow, $revents) = @_; @@ -657,8 +1437,9 @@ =item $iow = $iow->events ($eventmask) -Set the event mask to watch. Bit #0 (value C<1>) enables watching for read -data, Bit #1 (value C<2>) enables watching for write data. +Set the event mask to watch. The only allowed values are +C and C, which might be ORed +together, or C. =item $iow = $iow->start @@ -679,11 +1460,11 @@ =over 4 -=item 0 - only fatal messages +=item == 0 - fatal messages -=item 3 - script loading and management +=item >= 3 - script loading and management -=item 10 - all events received +=item >=10 - all events received =back