You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
678 lines
18 KiB
678 lines
18 KiB
#! perl |
|
# This program is free software: you can redistribute it and/or modify |
|
# it under the terms of the GNU General Public License as published by |
|
# the Free Software Foundation, either version 3 of the License, or |
|
# (at your option) any later version. |
|
|
|
# This program is distributed in the hope that it will be useful, |
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
# GNU General Public License for more details. |
|
|
|
# You should have received a copy of the GNU General Public License |
|
# along with this program. If not, see <http://www.gnu.org/licenses/>. |
|
# |
|
## |
|
## Tabbed plugin for rxvt-unicode |
|
## Modified by Michal Nazarewicz (mina86/AT/mina86.com), StephenB |
|
## (mail4stb/AT/gmail.com), Steven Merrill |
|
## <steven dot merrill at gmail.com>, Mark Pustjens |
|
## <pustjens@dds.nl> and more... |
|
## |
|
## The following has been added: |
|
## |
|
## 1. Depending on time of last activity, activity character differs. |
|
## By default, after 4 seconds an asterisk becomes a plus sing, |
|
## after next 4 it becomes a colon, and finally, after another 8 |
|
## seconds it becomes a dot. This can be configured via |
|
## tabbar-timeouts resource. It's format is: |
|
## |
|
## ( <timeout> ":" <character> ":" )* <timeout> ":" <character> ":" |
|
## |
|
## where <timeout> is timeout in seconds and <character> is |
|
## a single activity character. |
|
## |
|
## 2. The "[NEW]" button can be disabled (who on Earth uses mouse to |
|
## create new tab anyways?) by setting new-button resource to yes. |
|
## |
|
## 3. If title resource is true, tab's title is displayed after last |
|
## button. This is handy if you have terminal with no window |
|
## decorations. Colours can be configured via title-fg and |
|
## title-bg. |
|
## |
|
## 4. Incorporated Alexey Semenko <asemenko at gmail.com> patch adding |
|
## autohide resource. If it's true tab bar is hidden if there is |
|
## no more then one tab opened. |
|
## |
|
## 5. Tabs are indexed in starting with zero hex. :] If you're such |
|
## a geek to use urxvt it shouldn't be a problem for you and it |
|
## saves few character when many tabs are opened. |
|
## |
|
## 6. As a minor modification: Final pipe character is removed (unless |
|
## title is displayed). This make tab bar look nicer. |
|
## |
|
## Added by StephenB: |
|
## |
|
## 7. Tabs can be named with Shift+Up (Enter to confirm, Escape to |
|
## cancel). |
|
## |
|
## 8. "[NEW]" button disabled by default. |
|
## |
|
## Added by Steven Merrill <steven dot merrill at gmail.com> |
|
## |
|
## 9. Ability to start a new tab or cycle through tabs via user |
|
## commands: tabbedex:(new|next|prev)_tab . |
|
## e.g. (in .Xdefaults) URxvt.keysym.M-t: perl:tabbedex:new_tab |
|
## (see the urxvt man file for more info about keysym) |
|
## |
|
## 10. Fix an issue whereby on_user_command would not properly get sent |
|
## to other extension packages if the mouse was not over the urxvt |
|
## window. |
|
## |
|
## Added by Thomas Jost: |
|
## |
|
## 11. Add several user commands: tabbedex:rename_tab, |
|
## tabbedex:move_tab_(left|right). |
|
## e.g. (see 9.) URxvt.keysym.C-S-Left: perl:tabbex:move_tab_left |
|
## |
|
## 12. Ability to disable the default keybindings using the |
|
## no-tabbedex-keys resource. |
|
## |
|
## Added by xanf (Illya Klymov): |
|
## |
|
## 13. Ability to display non-latin characters in tab title. |
|
## |
|
## Added by jpkotta: |
|
## |
|
## 14. Tabs inherit command line options. |
|
## |
|
## Added by Mark Pustjens <pustjens@dds.nl> |
|
## |
|
## 15. Resources are now read respecting the -name option. |
|
## |
|
## 16. Ability to prevent the last tab from closing. |
|
## Use the following in your ~/.Xdefaults to enable: |
|
## URXvt.tabbed.reopen-on-close: yes |
|
## |
|
|
|
use Encode qw(decode); |
|
|
|
sub update_autohide { |
|
my ($self, $reconfigure) = @_; |
|
my $oldh = $self->{tabheight}; |
|
if ($self->{autohide} && @{ $self->{tabs} } <= 1 && |
|
! (@{ $self->{tabs} } == 1 && $self->{tabs}[-1]->{name})) { |
|
$self->{tabheight} = 0; |
|
} else { |
|
$self->{tabheight} = $self->{maxtabheight}; |
|
} |
|
if ($reconfigure && $self->{tabheight} != $oldh) { |
|
$self->configure; |
|
$self->copy_properties; |
|
} |
|
} |
|
|
|
|
|
sub tab_activity_mark ($$) { |
|
my ($self, $tab) = @_; |
|
return ' ' unless defined $tab->{lastActivity}; |
|
return ' ' if $tab == $self->{cur}; |
|
if (defined $self->{timeouts}) { |
|
my $diff = int urxvt::NOW - $tab->{lastActivity}; |
|
for my $spec (@{ $self->{timeouts} }) { |
|
return $spec->[1] if $diff > $spec->[0]; |
|
} |
|
} |
|
'*'; |
|
} |
|
|
|
|
|
sub refresh { |
|
my ($self) = @_; |
|
|
|
# autohide makes it zero |
|
return unless $self->{tabheight}; |
|
|
|
my $ncol = $self->ncol; |
|
|
|
my $text = " " x $ncol; |
|
my $rend = [($self->{rs_tabbar}) x $ncol]; |
|
|
|
my ($ofs, $idx, @ofs) = (0, 0); |
|
|
|
if ($self->{new_button}) { |
|
substr $text, 0, 7, "[NEW] |"; |
|
@$rend[0 .. 5] = ($self->{rs_tab}) x 6; |
|
push @ofs, [0, 6, -1 ]; |
|
$ofs = 7; |
|
} |
|
|
|
for my $tab (@{ $self->{tabs} }) { |
|
my $name = $tab->{name} ? $tab->{name} : $idx; |
|
my $act = $self->tab_activity_mark($tab); |
|
my $txt = sprintf "%s%s%s", $act, $name, $act; |
|
my $len = length $txt; |
|
|
|
substr $text, $ofs, $len + 1, "$txt|"; |
|
@$rend[$ofs .. $ofs + $len - 1] = ($self->{rs_tab}) x $len |
|
if $tab == $self->{cur}; |
|
|
|
push @ofs, [ $ofs, $ofs + $len, $idx ]; |
|
++$idx; |
|
$ofs += $len + 1; |
|
} |
|
|
|
substr $text, --$ofs, 1, ' '; # remove last '|' |
|
|
|
if ($self->{tab_title} && $ofs + 3 < $ncol) { |
|
my $term = $self->{term}; |
|
my @str = $term->XGetWindowProperty($term->parent, $self->{tab_title}); |
|
if (@str && $str[2]) { |
|
my $str = '| ' . decode("utf8", $str[2]); |
|
my $len = length $str; |
|
$len = $ncol - $ofs if $ofs + $len > $ncol; |
|
substr $text, $ofs, $len, substr $str, 0, $len; |
|
@$rend[$ofs + 2 .. $ofs + $len - 1] = ($self->{rs_title}) x ($len - 2); |
|
} |
|
} |
|
|
|
$self->{tabofs} = \@ofs; |
|
|
|
$self->ROW_t (0, $text, 0, 0, $ncol); |
|
$self->ROW_r (0, $rend, 0, 0, $ncol); |
|
|
|
$self->want_refresh; |
|
} |
|
|
|
|
|
sub new_tab { |
|
my ($self, @argv) = @_; |
|
|
|
my $offset = $self->fheight; |
|
|
|
$self->{tabheight} = $self->{maxtabheight} |
|
unless $self->{autohide} && !(defined $self->{tabs} && @{ $self->{tabs} }); |
|
|
|
# save a backlink to us, make sure tabbedex is inactive |
|
push @urxvt::TERM_INIT, sub { |
|
my ($term) = @_; |
|
$term->{parent} = $self; |
|
|
|
for (0 .. urxvt::NUM_RESOURCES - 1) { |
|
my $value = $self->{resource}[$_]; |
|
|
|
$term->resource ("+$_" => $value) |
|
if defined $value; |
|
} |
|
|
|
foreach my $opt (keys %urxvt::OPTION) { |
|
my $value = $self->{option}{$opt}; |
|
$term->option($urxvt::OPTION{$opt}, $value); |
|
} |
|
|
|
$term->resource (perl_ext_2 => $term->resource ("perl_ext_2") . ",-tabbedex"); |
|
}; |
|
|
|
push @urxvt::TERM_EXT, urxvt::ext::tabbedex::tab::; |
|
|
|
my $term = new urxvt::term |
|
$self->env, $urxvt::RXVTNAME, |
|
-embed => $self->parent, |
|
@argv; |
|
} |
|
|
|
|
|
sub configure { |
|
my ($self) = @_; |
|
|
|
my $tab = $self->{cur}; |
|
|
|
# this is an extremely dirty way to force a configurenotify, but who cares |
|
$tab->XMoveResizeWindow ( |
|
$tab->parent, |
|
0, $self->{tabheight} + 1, |
|
$self->width, $self->height - $self->{tabheight} |
|
); |
|
$tab->XMoveResizeWindow ( |
|
$tab->parent, |
|
0, $self->{tabheight}, |
|
$self->width, $self->height - $self->{tabheight} |
|
); |
|
} |
|
|
|
|
|
sub copy_properties { |
|
my ($self) = @_; |
|
my $tab = $self->{cur}; |
|
|
|
my $wm_normal_hints = $self->XInternAtom ("WM_NORMAL_HINTS"); |
|
|
|
my $current = delete $self->{current_properties}; |
|
|
|
# pass 1: copy over properties different or nonexisting |
|
for my $atom ($tab->XListProperties ($tab->parent)) { |
|
my ($type, $format, $items) = $self->XGetWindowProperty ($tab->parent, $atom); |
|
|
|
# fix up size hints |
|
if ($atom == $wm_normal_hints) { |
|
my (@hints) = unpack "l!*", $items; |
|
|
|
$hints[$_] += $self->{tabheight} for (4, 6, 16); |
|
|
|
$items = pack "l!*", @hints; |
|
} |
|
|
|
my $cur = delete $current->{$atom}; |
|
|
|
# update if changed, we assume empty items and zero type and format will not happen |
|
$self->XChangeProperty ($self->parent, $atom, $type, $format, $items) |
|
if $cur->[0] != $type or $cur->[1] != $format or $cur->[2] ne $items; |
|
|
|
$self->{current_properties}{$atom} = [$type, $format, $items]; |
|
} |
|
|
|
# pass 2, delete all extraneous properties |
|
$self->XDeleteProperty ($self->parent, $_) for keys %$current; |
|
} |
|
|
|
|
|
sub my_resource { |
|
my $self = shift; |
|
$self->x_resource ("tabbed.$_[0]"); |
|
} |
|
|
|
|
|
sub make_current { |
|
my ($self, $tab) = @_; |
|
|
|
if (my $cur = $self->{cur}) { |
|
delete $cur->{lastActivity}; |
|
$cur->XUnmapWindow ($cur->parent) if $cur->mapped; |
|
$cur->focus_out; |
|
} |
|
|
|
$self->{cur} = $tab; |
|
|
|
$self->configure; |
|
$self->copy_properties; |
|
|
|
$tab->focus_out; # just in case, should be a nop |
|
$tab->focus_in if $self->focus; |
|
|
|
$tab->XMapWindow ($tab->parent); |
|
delete $tab->{lastActivity}; |
|
$self->refresh; |
|
|
|
(); |
|
} |
|
|
|
|
|
sub on_focus_in { |
|
my ($self, $event) = @_; |
|
$self->{cur}->focus_in; |
|
(); |
|
} |
|
|
|
sub on_focus_out { |
|
my ($self, $event) = @_; |
|
$self->{cur}->focus_out; |
|
(); |
|
} |
|
|
|
sub on_key_press { |
|
my ($self, $event) = @_; |
|
$self->{cur}->key_press ($event->{state}, $event->{keycode}, $event->{time}); |
|
1; |
|
} |
|
|
|
sub on_key_release { |
|
my ($self, $event) = @_; |
|
$self->{cur}->key_release ($event->{state}, $event->{keycode}, $event->{time}); |
|
1; |
|
} |
|
|
|
sub on_button_release { |
|
my ($self, $event) = @_; |
|
|
|
if ($event->{row} == 0) { |
|
my $col = $event->{col}; |
|
for my $button (@{ $self->{tabofs} }) { |
|
last if $col < $button->[0]; |
|
next unless $col <= $button->[1]; |
|
if ($button->[2] == -1) { |
|
$self->new_tab; |
|
} else { |
|
$self->make_current($self->{tabs}[$button->[2]]); |
|
} |
|
} |
|
return 1; |
|
} |
|
|
|
(); |
|
} |
|
|
|
sub on_init { |
|
my ($self) = @_; |
|
|
|
$self->{resource} = [map $self->resource ("+$_"), 0 .. urxvt::NUM_RESOURCES - 1]; |
|
|
|
$self->resource (int_bwidth => 0); |
|
$self->resource (pty_fd => -1); |
|
|
|
$self->{option} = {}; |
|
for my $key (keys %urxvt::OPTION) { |
|
$self->{option}{$key} = $self->option($urxvt::OPTION{$key}); |
|
} |
|
|
|
# this is for the tabs terminal; order is important |
|
$self->option ($urxvt::OPTION{scrollBar}, 0); |
|
|
|
my $fg = $self->my_resource ("tabbar-fg"); |
|
my $bg = $self->my_resource ("tabbar-bg"); |
|
my $tabfg = $self->my_resource ("tab-fg"); |
|
my $tabbg = $self->my_resource ("tab-bg"); |
|
my $titfg = $self->my_resource ("title-fg"); |
|
my $titbg = $self->my_resource ("title-bg"); |
|
|
|
defined $fg or $fg = 3; |
|
defined $bg or $bg = 0; |
|
defined $tabfg or $tabfg = 0; |
|
defined $tabbg or $tabbg = 1; |
|
defined $titfg or $titfg = 2; |
|
defined $titbg or $titbg = 0; |
|
|
|
$self->{rs_tabbar} = urxvt::SET_COLOR (urxvt::DEFAULT_RSTYLE, $fg + 2, $bg + 2); |
|
$self->{rs_tab} = urxvt::SET_COLOR (urxvt::DEFAULT_RSTYLE, $tabfg + 2, $tabbg + 2); |
|
$self->{rs_title} = urxvt::SET_COLOR (urxvt::DEFAULT_RSTYLE, $titfg + 2, $titbg + 2); |
|
|
|
|
|
my $timeouts = $self->my_resource ("tabbar-timeouts"); |
|
$timeouts = '16:.:8:::4:+' unless defined $timeouts; |
|
if ($timeouts ne '') { |
|
my @timeouts; |
|
while ($timeouts =~ /^(\d+):(.)(?::(.*))?$/) { |
|
push @timeouts, [ int $1, $2 ]; |
|
$timeouts = defined $3 ? $3 : ''; |
|
} |
|
if (@timeouts) { |
|
$self->{timeouts} = [ sort { $b->[0] <=> $a-> [0] } @timeouts ]; |
|
} |
|
} |
|
|
|
$self->{new_button} = |
|
($self->my_resource ('new-button') or 'false') !~ /^(?:false|0|no)/i; |
|
$self->{tab_title} = |
|
($self->my_resource ('title') or 'true') !~ /^(?:false|0|no)/i; |
|
$self->{autohide} = |
|
($self->my_resource ('autohide') or 'false') !~ /^(?:false|0|no)/i; |
|
$self->{no_default_keys} = |
|
($self->my_resource ('no-tabbedex-keys') or 'false') !~ /^(?:false|0|no)/i; |
|
$self->{reopen_on_close} = |
|
($self->my_resource ('reopen-on-close') or 'false') !~ /^(?:false|0|no)/i; |
|
|
|
(); |
|
} |
|
|
|
|
|
sub on_start { |
|
my ($self) = @_; |
|
|
|
$self->{maxtabheight} = $self->int_bwidth + $self->fheight + $self->lineSpace; |
|
$self->{tabheight} = $self->{autohide} ? 0 : $self->{maxtabheight}; |
|
|
|
$self->{running_user_command} = 0; |
|
|
|
$self->cmd_parse ("\033[?25l"); |
|
|
|
my @argv = $self->argv; |
|
|
|
do { |
|
shift @argv; |
|
} while @argv && $argv[0] ne "-e"; |
|
|
|
if ($self->{tab_title}) { |
|
$self->{tab_title} = $self->{term}->XInternAtom("_NET_WM_NAME", 1); |
|
} |
|
|
|
$self->new_tab (@argv); |
|
|
|
if (defined $self->{timeouts}) { |
|
my $interval = ($self->{timeouts}[@{ $self->{timeouts} } - 1]->[0]); |
|
$interval = int($interval / 4); |
|
$self->{timer} = urxvt::timer->new |
|
->interval($interval < 1 ? 1 : $interval) |
|
->cb ( sub { $self->refresh; } ); |
|
} |
|
|
|
(); |
|
} |
|
|
|
|
|
sub on_configure_notify { |
|
my ($self, $event) = @_; |
|
|
|
$self->configure; |
|
$self->refresh; |
|
|
|
(); |
|
} |
|
|
|
|
|
sub on_user_command { |
|
my ($self, $event) = @_; |
|
|
|
$self->{cur}->{term}->{parent}->tab_user_command($self->{cur}, $event, 1); |
|
|
|
(); |
|
} |
|
|
|
|
|
sub on_wm_delete_window { |
|
my ($self) = @_; |
|
$_->destroy for @{ $self->{tabs} }; |
|
1; |
|
} |
|
|
|
|
|
sub tab_start { |
|
my ($self, $tab) = @_; |
|
|
|
$tab->XChangeInput ($tab->parent, urxvt::PropertyChangeMask); |
|
|
|
push @{ $self->{tabs} }, $tab; |
|
|
|
# $tab->{name} ||= scalar @{ $self->{tabs} }; |
|
$self->make_current ($tab); |
|
|
|
(); |
|
} |
|
|
|
|
|
sub tab_destroy { |
|
my ($self, $tab) = @_; |
|
|
|
if ($self->{reopen_on_close} && $#{ $self->{tabs} } == 0) { |
|
$self->new_tab; |
|
$self->make_current ($self->{tabs}[-1]); |
|
} |
|
|
|
$self->{tabs} = [ grep $_ != $tab, @{ $self->{tabs} } ]; |
|
$self->update_autohide (); |
|
|
|
if (@{ $self->{tabs} }) { |
|
if ($self->{cur} == $tab) { |
|
delete $self->{cur}; |
|
$self->make_current ($self->{tabs}[-1]); |
|
} else { |
|
$self->refresh; |
|
} |
|
} else { |
|
# delay destruction a tiny bit |
|
$self->{destroy} = urxvt::iw->new->start->cb (sub { $self->destroy }); |
|
} |
|
|
|
(); |
|
} |
|
|
|
|
|
sub tab_key_press { |
|
my ($self, $tab, $event, $keysym, $str) = @_; |
|
|
|
if ($tab->{is_inputting_name}) { |
|
if ($keysym == 0xff0d || $keysym == 0xff8d) { # enter |
|
$tab->{name} = $tab->{new_name}; |
|
$tab->{is_inputting_name} = 0; |
|
$self->update_autohide (1); |
|
} elsif ($keysym == 0xff1b) { # escape |
|
$tab->{name} = $tab->{old_name}; |
|
$tab->{is_inputting_name} = 0; |
|
$self->update_autohide (1); |
|
} elsif ($keysym == 0xff08) { # backspace |
|
substr $tab->{new_name}, -1, 1, ""; |
|
$tab->{name} = "$tab->{new_name}█"; |
|
} elsif ($str !~ /[\x00-\x1f\x80-\xaf]/) { |
|
$tab->{new_name} .= $str; |
|
$tab->{name} = "$tab->{new_name}█"; |
|
} |
|
$self->refresh; |
|
return 1; |
|
} |
|
|
|
return () if ($self->{no_default_keys}); |
|
|
|
if ($event->{state} & urxvt::ShiftMask) { |
|
if ($keysym == 0xff51 || $keysym == 0xff53) { |
|
if (@{ $self->{tabs} } > 1) { |
|
$self->change_tab($tab, $keysym - 0xff52); |
|
} |
|
return 1; |
|
|
|
} elsif ($keysym == 0xff54) { |
|
$self->new_tab; |
|
return 1; |
|
|
|
} elsif ($keysym == 0xff52) { |
|
$self->rename_tab($tab); |
|
return 1; |
|
} |
|
} elsif ($event->{state} & urxvt::ControlMask) { |
|
if ($keysym == 0xff51 || $keysym == 0xff53) { |
|
$self->move_tab($tab, $keysym - 0xff52); |
|
return 1; |
|
} |
|
} |
|
|
|
(); |
|
} |
|
|
|
|
|
sub tab_property_notify { |
|
my ($self, $tab, $event) = @_; |
|
|
|
$self->copy_properties |
|
if $event->{window} == $tab->parent; |
|
|
|
(); |
|
} |
|
|
|
|
|
sub tab_add_lines { |
|
my ($self, $tab) = @_; |
|
my $mark = $self->tab_activity_mark($tab); |
|
$tab->{lastActivity} = int urxvt::NOW; |
|
$self->refresh if $mark ne $self->tab_activity_mark($tab); |
|
(); |
|
} |
|
|
|
|
|
sub tab_user_command { |
|
my ($self, $tab, $cmd, $proxy_events) = @_; |
|
|
|
if ($cmd eq 'tabbedex:new_tab') { |
|
$self->new_tab; |
|
} |
|
elsif ($cmd eq 'tabbedex:next_tab') { |
|
$self->change_tab($tab, 1); |
|
} |
|
elsif ($cmd eq 'tabbedex:prev_tab') { |
|
$self->change_tab($tab, -1); |
|
} |
|
elsif ($cmd eq 'tabbedex:move_tab_left') { |
|
$self->move_tab($tab, -1); |
|
} |
|
elsif ($cmd eq 'tabbedex:move_tab_right') { |
|
$self->move_tab($tab, 1); |
|
} |
|
elsif ($cmd eq 'tabbedex:rename_tab') { |
|
$self->rename_tab($tab); |
|
} |
|
else { |
|
# Proxy the user command through to the tab's term, while taking care not |
|
# to get caught in an infinite loop. |
|
if ($proxy_events && $self->{running_user_command} == 0) { |
|
$self->{running_user_command} = 1; |
|
urxvt::invoke($tab->{term}, 20, $cmd); |
|
$self->{running_user_command} = 0; |
|
} |
|
} |
|
|
|
(); |
|
} |
|
|
|
sub change_tab { |
|
my ($self, $tab, $direction) = @_; |
|
|
|
my $idx = 0; |
|
++$idx while $self->{tabs}[$idx] != $tab; |
|
$idx += $direction; |
|
$self->make_current ($self->{tabs}[$idx % @{ $self->{tabs}}]); |
|
|
|
(); |
|
} |
|
|
|
sub move_tab { |
|
my ($self, $tab, $direction) = @_; |
|
|
|
if (@{ $self->{tabs} } > 1) { |
|
my $idx1 = 0; |
|
++$idx1 while $self->{tabs}[$idx1] != $tab; |
|
my $idx2 = ($idx1 + $direction) % @{ $self->{tabs} }; |
|
|
|
($self->{tabs}[$idx1], $self->{tabs}[$idx2]) = |
|
($self->{tabs}[$idx2], $self->{tabs}[$idx1]); |
|
$self->make_current ($self->{tabs}[$idx2]); |
|
} |
|
|
|
(); |
|
} |
|
|
|
sub rename_tab { |
|
my ($self, $tab) = @_; |
|
|
|
$tab->{is_inputting_name} = 1; |
|
$tab->{old_name} = $tab->{name} ? $tab->{name} : ""; |
|
$tab->{new_name} = ""; |
|
$tab->{name} = "█"; |
|
$self->update_autohide (1); |
|
$self->refresh; |
|
|
|
(); |
|
} |
|
|
|
package urxvt::ext::tabbedex::tab; |
|
|
|
# helper extension implementing the subwindows of a tabbed terminal. |
|
# simply proxies all interesting calls back to the tabbedex class. |
|
|
|
{ |
|
for my $hook (qw(start destroy user_command key_press property_notify add_lines)) { |
|
eval qq{ |
|
sub on_$hook { |
|
my \$parent = \$_[0]{term}{parent} |
|
or return; |
|
\$parent->tab_$hook (\@_) |
|
} |
|
}; |
|
die if $@; |
|
} |
|
}
|
|
|