package CGI::Widget::HList::Node;

use Tree::DAG_Node;
use vars qw(@ISA $VERSION);
use strict;

@ISA = qw(Tree::DAG_Node);
$VERSION = '0.51';

sub close {
  my $self = shift;
  $self->{state} = 0;
  return $self->{state};

sub open {
  my $self = shift;
  $self->{state} = 1;
  return $self->{state};

sub pregnant {
  my($self,$val) = @_;
  return $self->{pregnant} unless defined $val;
  $self->{pregnant} = $val;
  return $self->{pregnant};

sub state {
  my $self = shift;
  $self->{state} = 1 unless defined $self->{state}; #open by default
  $self->pregnant(0) if $self->{state};
  return $self->{state};

sub state_link {
  my($self,$val) = @_;
  return $self->{state_link} unless defined $val;
  $self->{state_link} = $val;
  return $self->{state_link};

sub link {
  my($self,$val) = @_;
  $self->{link} ||= sub {my $this = shift; return ($this->name) || $this};
  return $self->{link} unless defined $val;
  $self->{link} = $val;
  return $self->{link};

#overriding dump_names to use a more sensible output format
sub dump_names {
  my($it, %o) = @_;

  my @out = ();
  $o{_depth} ||= 0;
  $o{spacer}   ||= sub {return "z"};
  $o{trunk}    ||= sub {return "|"};
  $o{branch}   ||= sub {return "="};
  $o{node}     ||= sub {return "O "};
  $o{break}    ||= "\n";
  $o{callback}   = sub {
      my($this, $o) = @_[0,1];

			unless($this->state){                      #unless shows daughters
					$this->pregnant(1) if $this->descendants; #preserve the motherliness
					$this->clear_daughters;                #but kill the girls

      my @spacer;
			my @ancestors = reverse $this->ancestors;

			my $index = 0;
			foreach my $ancestor (@ancestors){

					#last column is special (branches)
					if($ancestor->ancestors == $this->ancestors -1){
							push @spacer, $o->{branch}->($this);

					#other columns
					else {
							push @spacer, $ancestors[$index+1]->right_sister ? 
								$o->{trunk}->() : 


      return 1;
  return @out;

# Below is stub documentation for your module. You better edit it!

=head1 NAME

CGI::Widget::HList::Node - Tree::DAG_Node extension for representing
Hierarchical List (HList) Nodes.


  use CGI::Widget::HList::Node;
  my $node1 = CGI::Widget::HList::Node->new;
  my $node2 = CGI::Widget::HList::Node->new;


CGI::Widget::HList::Node is a subclass of Tree::DAG_Node,
with a few overridden and extra methods that help it be more
specific to representation of DAGs in an HTML/CGI context.
See L<Tree::DAG_Node> for more details.

=head2 Constuctors

CGI::Widget::Series has multiple constructors.  See

=head2 Methods

open() - set the value returned by state() to 1.  An open() node
is one which allows its daughters to be exposed.

close() - set the value returned by state() to 0.  A close() node
does not expose its daughter nodes.

state() - returns the open/close state of a node.

pregnant() - a node that has the potential to have daughter nodes,
but currently does not have them can be tagged by calling pregnant
with a non-zero,defined value.  Calling with zero or undef terminates
the pregnancy, as does calling open() on the node.

link() - holds a subroutine used to render the text label of the node.
Returns name() or an object reference by default.  Override this with
a callback.

dump_names() - overridden to produce a highly flexible hierarchical
list, optionally with CGI parameters and HTML tags.

Many, many methods are provided by Tree::DAG_Node, and are
available within this class.  I have only outlined here overridden/
additional methods.  For complete documentation, also consult

=head1 AUTHOR

 Allen Day <>
 Copyright (c) 2001.

=head1 SEE ALSO