--- rxvt-unicode/src/urxvt.pm	2006/01/03 04:20:37	1.21
+++ rxvt-unicode/src/urxvt.pm	2006/01/07 20:23:52	1.45
@@ -19,8 +19,8 @@
 
 =head1 DESCRIPTION
 
-Everytime a terminal object gets created, scripts specified via the
-C<perl> resource are loaded and associated with it.
+Everytime a terminal object gets created, extension scripts specified via
+the C<perl> 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.
@@ -41,7 +41,12 @@
 
 =item selection
 
-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<ls> supports C<--quoting-style=shell>.
+
+It also offers the following bindable event:
 
 =over 4
 
@@ -57,6 +62,16 @@
 
 Displays a digital clock using the built-in overlay.
 
+=item mark-urls
+
+Uses per-line display filtering (C<on_line_update>) 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 +85,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<MUST NOT> be accessed or
 modified).
 
 When objects are destroyed on the C++ side, the perl object hashes are
@@ -78,10 +93,40 @@
 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<row_t> for a discussion of this format.
+
+=item $string
+
+A perl text string, with an emphasis on I<text>. 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 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 object private to each terminal
+and extension package. You can call all C<urxvt::term> methods on it, but
+its not a real C<urxvt::term> object. Instead, the real C<urxvt::term>
+object that is shared between all packages is stored in the C<term>
+member. It is, however, blessed intot he package of the extension script,
+so for all practical purposes you can treat an extension script as a class.
 
 All of them must return a boolean value. If it is true, then the event
 counts as being I<consumed>, and the invocation of other hooks is skipped,
@@ -94,7 +139,10 @@
 =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 +172,14 @@
 
 Returning a true value aborts selection grabbing. It will still be hilighted.
 
-=item on_focus_in $term
-
-Called whenever the window gets the keyboard focus, before urxvt does
-focus in processing.
+=item on_sel_extend $term
 
-=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<selection> example extension.
 
 =item on_view_change $term, $offset
 
@@ -154,6 +201,41 @@
 
 Called whenever the program(s) running in the urxvt window send output.
 
+=item on_osc_seq $term, $string
+
+Called whenever the B<ESC ] 777 ; string ST> 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<all> text being
+output.
+
+=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
 
 Called just before the screen gets redrawn. Can be used for overlay
@@ -171,12 +253,67 @@
 C<perl:string> action bound to it (see description of the B<keysym>
 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, $octets
+
+=item on_key_release $term, $event
+
+=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<row> and C<col>, which are the row
+and column under the mouse cursor.
+
+C<on_key_press> additionally receives the string rxvt-unicode would
+output, if any, in locale-specific encoding.
+
+subwindow.
+
+=back
+
+=head2 Variables in the C<urxvt> Package
+
+=over 4
+
+=item $urxvt::TERM
+
+The current terminal. This variable stores the current C<urxvt::term>
+object, whenever a callback/hook is executing.
+
 =back
 
 =head2 Functions in the C<urxvt> Package
 
 =over 4
 
+=item $term = new urxvt [arg...]
+
+Creates a new terminal, very similar as if you had started it with
+C<system $binfile, arg...>. Croaks (and probably outputs an error message)
+if the new instance couldn't be created.  Returns C<undef> if the new
+instance didn't initialise perl, and the terminal object otherwise. The
+C<init> and C<start> hooks will be called during the call.
+
 =item urxvt::fatal $errormessage
 
 Fatally aborts execution with the given error message. Avoid at all
@@ -255,8 +392,9 @@
 package urxvt;
 
 use strict;
+use Scalar::Util ();
 
-our $term;
+our $TERM;
 our @HOOKNAME;
 our $LIBDIR;
 
@@ -291,28 +429,29 @@
       my $ref = $pkg->can ("on_" . lc $name)
          or next;
 
-      $term->{_hook}[$htype]{$ref*1} = $ref;
+      $TERM->{_hook}[$htype]{$pkg} = $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"
+                   . "use base urxvt::term::proxy::;\n"
                    . "#line 1 \"$path\"\n{\n"
                    . (do { local $/; <$fh> })
                    . "\n};\n1";
@@ -323,50 +462,100 @@
    }
 }
 
+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");
 
-      for my $ext (split /:/, $term->resource ("perl_ext")) {
+      for my $ext (map { split /,/, $TERM->resource ("perl_ext_$_") } 1, 2) {
          my @files = grep -f $_, map "$_/$ext", @dirs;
 
          if (@files) {
-            register_package script_package $files[0];
+            register_package extension_package $files[0];
          } else {
             warn "perl extension '$ext' not found in perl library search path\n";
          }
       }
+   }
+
+   $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) {
+         eval {
+            $retval = $cb->(
+               $TERM->{_pkg}{$pkg} ||= do {
+                  my $proxy = bless { }, $pkg;
+                  Scalar::Util::weaken ($proxy->{term} = $TERM);
+                  $proxy
+               },
+               @_,
+            ) and last;
+         };
+         warn $@ if $@;#d#
+      }
+   }
 
-   } elsif ($htype == 1) { # DESTROY
-      if (my $hook = $term->{_hook}) {
+   if ($htype == 1) { # DESTROY
+      # remove hooks if unused
+      if (my $hook = $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
+}
+
+sub urxvt::term::proxy::AUTOLOAD {
+   $urxvt::term::proxy::AUTOLOAD =~ /:([^:]+)$/
+      or die "FATAL: \$AUTOLOAD '$urxvt::term::proxy::AUTOLOAD' unparsable";
+
+   eval qq{
+      sub $urxvt::term::proxy::AUTOLOAD {
+         my \$proxy = shift;
+         \$proxy->{term}->$1 (\@_)
+      }
+      1
+   } or die "FATAL: unable to compile method forwarder: $@";
 
-   verbose 10, "$HOOKNAME[$htype] (" . (join ", ", $term, @_) . ")"
-      if $verbosity >= 10;
+   goto &$urxvt::term::proxy::AUTOLOAD;
+}
 
-   while (my ($k, $v) = each %$cb) {
-      return 1 if $v->($term, @_);
-   }
+sub urxvt::destroy_hook::DESTROY {
+   ${$_[0]}->();
+}
 
-   0
+sub urxvt::destroy_hook(&) {
+   bless \shift, urxvt::destroy_hook::
 }
 
 =head2 The C<urxvt::term> Class
 
 =over 4
 
+=item $term->destroy
+
+Destroy the terminal object (close the window, free resources etc.).
+
 =item $value = $term->resource ($name[, $newval])
 
 Returns the current resource value associated with a given name and
@@ -393,7 +582,7 @@
   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
@@ -406,9 +595,19 @@
 sub urxvt::term::resource($$;$) {
    my ($self, $name) = (shift, shift);
    unshift @_, $self, $name, ($name =~ s/\s*\+\s*(\d+)$// ? $1 : 0);
-   goto &urxvt::term::_resource;
+   &urxvt::term::_resource
 }
 
+=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])
@@ -432,21 +631,20 @@
 #Create a simple multi-line overlay box. See the next method for details.
 #
 #=cut
-
-sub urxvt::term::scr_overlay {
-die;
-   my ($self, $x, $y, $text) = @_;
-
-   my @lines = split /\n/, $text;
-
-   my $w = 0;
-   for (map $self->strwidth ($_), @lines) {
-      $w = $_ if $w < $_;
-   }
-
-   $self->scr_overlay_new ($x, $y, $w, scalar @lines);
-   $self->scr_overlay_set (0, $_, $lines[$_]) for 0.. $#lines;
-}
+#
+#sub urxvt::term::scr_overlay {
+#   my ($self, $x, $y, $text) = @_;
+#
+#   my @lines = split /\n/, $text;
+#
+#   my $w = 0;
+#   for (map $self->strwidth ($_), @lines) {
+#      $w = $_ if $w < $_;
+#   }
+#
+#   $self->scr_overlay_new ($x, $y, $w, scalar @lines);
+#   $self->scr_overlay_set (0, $_, $lines[$_]) for 0.. $#lines;
+#}
 
 =item $term->overlay ($x, $y, $width, $height[, $rstyle[, $border]])
 
@@ -463,7 +661,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<urxvt::overlay> object is C<set>:
+The methods currently supported on C<urxvt::overlay> objects are:
+
+=over 4
 
 =item $overlay->set ($x, $y, $text, $rend)
 
@@ -471,35 +671,112 @@
 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<urxvt::popup> object that implements a popup menu. The
+C<$event> I<must> be the event causing the menu to pop up (a button event,
+currently).
+
+=cut
+
+sub urxvt::term::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_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<on_add_lines> hook, though.
+
+=item $term->cmd_parse ($octets)
+
+Similar to C<scr_add_lines>, 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 $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 $ncol = $term->ncol
+=item $terminal_rows = $term->nrow
 
-Return the number of rows/columns of the terminal window (i.e. as
-specified by C<-geometry>, excluding any scrollback).
+=item $terminal_columns = $term->ncol
 
-=item $nsaved = $term->nsaved
+=item $has_focus = $term->focus
 
-Returns the number of lines in the scrollback buffer.
+=item $is_mapped = $term->mapped
+
+=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 $view_start = $term->view_start ([$newvalue])
 
@@ -520,7 +797,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,10 +830,131 @@
 
 =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<urxvt::line> 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<ROW_t>
+
+=item $rend = $line->r ([$new_rend])
+
+Returns or replaces the full rendition array of the line, similar to C<ROW_r>
+
+=item $length = $line->l
+
+Returns the length of the line in cells, similar to C<ROW_l>.
+
+=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 urxvt::term::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 ($row, $col) = $line->coord_of ($offset)
 =item $text = $term->special_encode $string
 
 Converts a perl string into the special encoding used by rxvt-unicode,
@@ -569,6 +968,43 @@
 
 =back
 
+=head2 The C<urxvt::popup> Class
+
+=over 4
+
+=cut
+
+package urxvt::popup;
+
+sub add_item {
+   my ($self, $item) = @_;
+
+   push @{ $self->{item} }, $item;
+}
+
+sub add_button {
+   my ($self, $text, $cb) = @_;
+
+   $self->add_item ({ type => "button", text => "[ $text ]", activate => $cb });
+}
+
+sub show {
+   my ($self) = @_;
+
+   local $urxvt::popup::self = $self;
+
+   urxvt->new ("--perl-lib" => "", "--perl-ext-common" => "", "-pty-fd" => -1, "-sl" => 0, "-b" => 0,
+               "--transient-for" => $self->{term}->parent,
+               "-pe" => "urxvt_popup")
+      or die "unable to create popup window\n";
+}
+
+sub DESTROY {
+   my ($self) = @_;
+
+   $self->{term}->ungrab;
+}
+
 =head2 The C<urxvt::timer> Class
 
 This class implements timer watchers/events. Time is represented as a
@@ -679,11 +1115,11 @@
 
 =over 4
 
-=item 0 - only fatal messages
+=item =0 - only 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