HTML::TagCloud::Extended - HTML::TagCloud extension

    use HTML::TagCloud::Extended;

    my $cloud = HTML::TagCloud::Extended->new();
    $cloud->add($tag1, $url1, $count1, $timestamp1);
    $cloud->add($tag2, $url2, $count2, $timestamp2);
    $cloud->add($tag3, $url3, $count3, $timestamp3);

    my $html = $cloud->html_and_css( {
        order_by => 'count_desc',
        limit    => 20,
    } );

    print $html;

    $cloud->add('perl','http://www.perl.org/', 20, '2005-07-15 00:00:00');

    my $cloud = HTML::TagCloud::Extended->new;

    $cloud->colors->set(
        earliest => '#000000',
    );

    $cloud->colors->set(
        earlier => '#333333',
        later   => '#999999',
        latest  => '#cccccc',
   );

    # or, you can set color for each attribute
    $cloud->colors->set(
        earliest => {
            link    => '#000000',
            hover   => '#CCCCCC',
            visited => '#333333',
            active  => '#666666',
        },
    );

    $cloud->html_and_css( { order_by => 'timestamp_desc' , limit => 20 } );

package HTML::TagCloud::Extended;
use strict;
use warnings;
use base qw/Class::Data::Inheritable Class::Accessor::Fast/;
use Readonly;
use HTML::TagCloud::Extended::TagColors;
use HTML::TagCloud::Extended::TagList;
use HTML::TagCloud::Extended::Tag;
use HTML::TagCloud::Extended::Factor;
use HTML::TagCloud::Extended::Exception;

our $VERSION = '0.10';

Readonly my $DEFAULT_BASE_FONT_SIZE  => 24;
Readonly my $DEFAULT_FONT_SIZE_RANGE => 12;
Readonly my $DEFAULT_CSS_CLASS       => "tagcloud";
Readonly my $DEFAULT_SIZE_SUFFIX     => "px";

__PACKAGE__->mk_classdata('_epoch_level');
__PACKAGE__->_epoch_level([qw/earliest earlier later latest/]);

__PACKAGE__->mk_accessors(qw/
    colors
    tags
    base_font_size
    font_size_range
    css_class
    use_hot_color
    hot_tags_size
    _size_suffix
    _hot_tags_name
/);

sub new {
    my $class = shift;
    my $self  = bless { }, $class;
    $self->_init(@_);
    return $self;
}

sub _init {
    my $self = shift;
    $self->_set_default_parameters();
    $self->_set_custom_parameters(@_);
    $self->colors ( HTML::TagCloud::Extended::TagColors->new );
    $self->tags   ( HTML::TagCloud::Extended::TagList->new   );
}

sub hot_tags_name {
    my $self = shift;
    if($_[0]) {
        my $tags = ref $_[0] ? $_[0] : [@_];
        $self->_hot_tags_name($tags);
    }
    return $self->_hot_tags_name;
}

sub _check_hot_tag_name {
    my ($self, $name) = @_;
    foreach my $tag_name ( @{ $self->hot_tags_name } ) {
        return 1 if $name eq $tag_name;
    }
    return 0;
}

sub _set_default_parameters {
    my $self  = shift;
    $self->base_font_size  ( $DEFAULT_BASE_FONT_SIZE  );
    $self->font_size_range ( $DEFAULT_FONT_SIZE_RANGE );
    $self->css_class       ( $DEFAULT_CSS_CLASS       );
    $self->_size_suffix    ( $DEFAULT_SIZE_SUFFIX     );
}

sub _set_custom_parameters {
    my ($self, %args) = @_;

    if ( exists $args{base_font_size} ) {
        $self->base_font_size($args{base_font_size});
    }
    if ( exists $args{font_size_range} ) {
        $self->font_size_range($args{font_size_range});
    }
    if ( exists $args{css_class} ) {
        $self->css_class($args{css_class});
    }
    if ( exists $args{hot_tags_size} ) {
        $self->hot_tags_size($args{hot_tags_size});
    }
    else {
        my $size = $self->base_font_size + ($self->font_size_range / 2);
        $self->hot_tags_size($size);
    }
    if ( exists $args{size_suffix} ) {
        $self->size_suffix($args{size_suffix});
    }
    $self->_hot_tags_name( exists $args{hot_tags_name} ? $args{hot_tags_name} : []     );
    $self->use_hot_color ( exists $args{use_hot_color} ? $args{use_hot_color} : undef  );
}

sub size_suffix {
    my ($self, $suffix) = @_;
    if ($suffix) {
        my $correct_suffix;
        foreach my $registered ( qw/mm cm in pt pc px/ ) {
            $correct_suffix = $suffix if $suffix eq $registered;
        }
        if ($correct_suffix) {
            $self->_size_suffix($correct_suffix);
        }
        else {
            HTML::TagCloud::Extended::Exception->throw(
            qq/You should correct suffix for text-size [ mm cm in pt pc px ]. /
            );            
        }
    }
    $self->_size_suffix;
}

sub add {
    my($self, $tag_name, $url, $count, $timestamp) = @_;
    my $tag = HTML::TagCloud::Extended::Tag->new(
        name      => $tag_name  || '',
        url       => $url       || '',
        count     => $count     || 0,
        timestamp => $timestamp,
    );
    $self->tags->add($tag);
}

sub max_font_size {
    my $self = shift;
    return $self->base_font_size + $self->font_size_range;
}

sub min_font_size {
    my $self = shift;
    my $num  = $self->base_font_size - $self->font_size_range;
    return $num > 0 ? $num : 0;
}

sub html_and_css {
    my ($self, $conf) = @_;
    my $html = qq|<style type="text/css">\n|.$self->css.qq|</style>\n|;
    $html .= $self->html($conf);
    return $html;
}

sub css {
    my $self = shift;
    my $css  = '';
    foreach my $type ( keys %{ $self->colors } ) {
        my $color = $self->colors->{$type};
        my $class = $self->css_class;
        foreach my $attr ( keys %$color ) {
            my $code = $color->{$attr};
            $css .= ".${class} .${type} a:${attr} {text-decoration: none; color: #${code};}\n";
        }
    }
    return $css;
}

sub html {
    my ($self, $conf) = @_;
    my $html_tags = $self->html_tags($conf);
    my $html = join "", @$html_tags;
    return $self->wrap_div($html);
}

sub wrap_span {
    my($self, $html) = @_;
    return "" unless $html;
    return sprintf qq|<span class="%s">\n%s</span>\n|, $self->css_class, $html;
}

sub wrap_div {
    my($self, $html) = @_;
    return "" unless $html;
    return sprintf qq|<div class="%s">\n%s</div>\n|, $self->css_class, $html;
}

sub html_tags {
    my($self, $conf) = @_;
    
    my $tags_amount = $self->tags->count;
    if ($tags_amount == 0) {
        return [];
    } elsif ($tags_amount == 1) {
        my $ite  = $self->tags->iterator;
        my $tag  = $ite->first;
        my $html = $self->create_html_tag($tag, 'latest', $self->max_font_size);
        return [$html];
    }

    $conf ||= {};
    my $order_by = $conf->{order_by} || 'name';
    $self->tags->sort($order_by);
    my $limit = $conf->{limit};
    my $tags  = $limit ? $self->tags->splice(0, $limit) : $self->tags;
    
    my $count_factor = HTML::TagCloud::Extended::Factor->new(
        min   => $tags->min_count,
        max   => $tags->max_count,
        range => $self->max_font_size - $self->min_font_size,
    );

    my $epoch_factor = HTML::TagCloud::Extended::Factor->new(
        min   => $tags->min_epoch,
        max   => $tags->max_epoch,
        range => 3,
    );

    my @html_tags = ();
    my $ite = $tags->iterator;
    while( my $tag = $ite->next ) {
        my $count_lv   = $count_factor->get_level($tag->count);
        my $epoch_lv   = $epoch_factor->get_level($tag->epoch);
        my $color_type = $self->_epoch_level->[$epoch_lv];
        my $font_size  = $self->min_font_size + $count_lv;
        if (  ( $self->use_hot_color eq 'name' && $self->_check_hot_tag_name($tag->name) )
           || ( $self->use_hot_color eq 'size' && $font_size >= $self->hot_tags_size     ) ) {
            $color_type = 'hot';
        }
        my $html_tag   = $self->create_html_tag($tag, $color_type, $font_size);
        push @html_tags, $html_tag;
    }
    return \@html_tags;
}

sub create_html_tag {
    my($self, $tag, $type, $size) = @_;
    return sprintf qq|<span class="%s" style="font-size: %d%s"><a href="%s">%s</a></span>\n|,
        $type,
        $size,
        $self->size_suffix,
        $tag->url,
        $tag->name;
}

1;
__END__