HTML::Widget::Element::NullContainer - Null Container Element

    my $e = $widget->element( 'NullContainer');
    $e->element('Textfield', 'bar');

package HTML::Widget::Element::NullContainer;

use warnings;
use strict;
use base 'HTML::Widget::Element';
use NEXT;
use Carp qw/croak/;

__PACKAGE__->mk_accessors(qw/content/);

*elem = \&element;

sub new {
    my $self = shift->NEXT::new(@_);

    $self->allow_filter(0)->allow_constraint(0)->content( [] );

    return $self;
}

sub element {
    my ( $self, $type, $name, $attrs ) = @_;

    my $abs = $type =~ s/^\+//;
    $type = "HTML::Widget::Element::$type" unless $abs;

    my $element = HTML::Widget->_instantiate( $type, { name => $name } );

    $element->{_anonymous} = 1 if !defined $name;

    $self->push_content($element);

    if ( defined $attrs ) {
        eval { $element->attributes->{$_} = $attrs->{$_} for keys %$attrs; };
        croak "attributes argument must be a hash-reference: $@" if $@;
    }

    return $element;
}

sub push_content {
    push @{ shift->content }, @_;
}

sub unshift_content {
    unshift @{ shift->content }, @_;
}

sub containerize {
    my ( $self, $w, $value, $error, $args ) = @_;

    local $w->{attributes}->{id} = $self->id($w);

    my @content = $w->_containerize_elements( $self->content, $args );

    return HTML::Widget::NullContainer->new( {
            passive => $self->passive,
            element => 1,
            content => \@content,
            name    => $self->name,
        } );
}

sub id {
    my ( $self, $w ) = @_;
    return $w->name if $self->{_anonymous};
    my $name = $self->name();
    if ( $name =~ s/^_implicit_// ) {

        # $name is left set to the name of the
        # original parent widget of this element, as set by
        # H::W::_setup_implicit_subcontainer.
    }
    return $w->name . '_' . $name;
}

sub get_elements {
    my ( $self, %opt ) = @_;

    return $self->_match_elements( $self->content, \%opt );
}

sub get_element {
    my ( $self, %opt ) = @_;

    return ( $self->get_elements(%opt) )[0];
}

sub find_elements {
    my ( $self, %opt ) = @_;

    my @elements = ($self);
    push @elements, map { $_->find_elements(%opt) } @{ $self->content };

    return $self->_match_elements( \@elements, \%opt );
}

sub _match_elements {
    my ( $self, $elements, $opt ) = @_;

    if ( exists $opt->{type} ) {
        my $type = "HTML::Widget::Element::$opt->{type}";

        return grep { $_->isa($type) } @$elements;
    }
    elsif ( exists $opt->{name} ) {
        my $name = $opt->{name};

        return grep { $_->name and $_->name eq $name } @$elements;
    }

    return @$elements;
}

sub prepare {
    my ( $self, $w ) = @_;
    map { $_->prepare($w) } @{ $self->content };
}

sub init {
    my ( $self, $w ) = @_;
    for my $element ( @{ $self->content } ) {
        $element->init($w) unless $element->{_initialized};
        $element->{_initialized}++;
    }
}

sub process {
    my ( $self, $params, $uploads ) = @_;
    my $errors;
    for my $element ( @{ $self->content } ) {
        my $er = $element->process( $params, $uploads );
        push @$errors, @$er if $er;
    }
    return $errors;
}

package HTML::Widget::NullContainer;

use warnings;
use strict;
use base 'HTML::Widget::Container';

__PACKAGE__->mk_accessors(qw/content/);

sub _build_element {
    my $self = shift;
    return ( map { $_->as_list } @{ $self->content } );
}

1;