Provided by: libhtml-element-extended-perl_1.18-1_all bug


       HTML::ElementSuper - Perl extension for HTML::Element(3)


         use HTML::ElementSuper;

         ### Positional extension
         $e = new HTML::ElementSuper 'font';
         $sibling_number = $e->addr();
         $e2 = new HTML::ElementSuper 'p';
         @coords = $e->position();
         $depth_in_pos_tree = $e->depth();

         ### Replacer extension
         $er = new HTML::ElementSuper 'font';
         # Tree beneath $er, if present, is dropped.
         $er->replace_content(new HTML::Element 'p');

         ### Wrapper extension
         $ew = new HTML::ElementSuper;
         $ew->push_content("Tickle me, baby");
         $ew->wrap_content(new HTML::Element 'font', color => 'pink');
         print $ew->as_HTML();

         ### Maskable extension
         $em = new HTML::ElementSuper 'td';
         print $em->as_HTML; # nada
         print $em->as_HTML; # $e and its children are visible

         ### Cloning of own tree or another element's tree
         ### (is this the correct clomenature?  :-)
         $a = new HTML::ElementSuper 'font', size => 2;
         $b = new HTML::ElementSuper 'font', color => 'red';
         $a_clone  = $a->clone;
         $b_clone = $a->clone($b);
         # Multiple elements can be cloned
         @clone_clones = $a_clone->clone($a_clone, $b_clone);


       HTML::ElementSuper is an extension for HTML::Element(3) that provides several new methods
       to assist in element manipulation. An HTML::ElementSuper has the following additional

          * report is coordinate position in a tree of its peers
          * replace its contents
          * wrap its contents in a new element
          * mask itself so that it and its descendants are invisible to
          * clone itself and other HTML::Element based object trees
          * handle multiple values for attributes

       Note that these extensions were originally developed to assist in implementing the
       HTML::ElementTable(3) class, but were thought to be of general enough utility to warrant
       their own package.


       new('tag', attr => 'value', ...)
           Return a new HTML::ElementSuper object. Exactly like the constructor for
           HTML::Element(3), takes a tag type and optional attributes.

       push_attr(attr => @values)
           Extend the value string for a particular attribute. An example of this might be when
           you'd like to assign multiple CSS classes to a single element. The attribute value is
           extended using white space as a separator.

           Returns the position of this element in relation to its siblings based on the content
           of the parent, starting with 0. Returns undef if this element has no parent. In other
           words, this returns the index of this element in the content array of the parent.

           Returns the coordinates of this element in the tree it inhabits. This is accomplished
           by succesively calling addr() on ancestor elements until either a) an element that
           does not support these methods is found, or b) there are no more parents. The
           resulting list is the n-dimensional coordinates of the element in the tree.

           Simple shortcut method that deletes the current contents of the element before adding
           the new.

           Wraps the existing content in the provided element. If the provided element happens to
           be a non-element, a push_content is performed instead.

           Toggles whether or not this element is visible to parental methods that visit the
           element tree using traverse(), such as as_HTML(). Valid arguments for mask() are 0 and
           1. Returns the current setting without an argument.

           This might seem like a strange method to have, but it helps in managing dynamic tree
           structures. For example, in HTML::ElementTable(3), when you expand a table cell you
           simply mask what it covers rather than destroy it. Shrinking the table cell reveals
           that content to as_HTML() once again.

           Returns a clone of elements and all of their descendants. Without arguments, the
           element clones itself, otherwise it clones the elements provided as arguments. Any
           element can be cloned as long as it is HTML::Element(3) based. This method is very
           handy for duplicating tree structures since an HTML::Element cannot have more than one
           parent at any given time...hence "tree".


       HTML::Element(3), Data::Dumper(3)


       Matthew P. Sisk, <>


       Copyright (c) 1998-2010 Matthew P. Sisk. All rights reserved. All wrongs revenged. This
       program is free software; you can redistribute it and/or modify it under the same terms as
       Perl itself.


       HTML::Element(3), HTML::ElementGlob(3), HTML::ElementRaw(3), HTML::ElementTable(3),