Daizu::Plugin::PictureArticle - publish image files as articles

    <plugin class="Daizu::Plugin::PictureArticle" />

    <plugin class="Daizu::Plugin::PictureArticle">
     <thumbnail max-width="400" min-height="400"
                filename-suffix="-small"/>
    </plugin>

package Daizu::Plugin::PictureArticle;
use warnings;
use strict;

use Carp qw( croak );
use Carp::Assert qw( assert DEBUG );
use Encode qw( decode );
use Math::Round qw( round );
use Encode qw( encode );
use Daizu;
use Daizu::Util qw(
    trim display_byte_size
    db_select
    add_xml_elem xml_attr xml_croak
);

our $DEFAULT_THUMBNAIL_MAX_WIDTH = 600;
our $DEFAULT_THUMBNAIL_MAX_HEIGHT = 600;
our $DEFAULT_THUMBNAIL_FILENAME_SUFFIX = '-thm';

# This is done on demand when it's needed.
sub _parse_config
{
    my ($self) = @_;
    return if $self->{config_parsed};

    my $config = $self->{config};
    my $config_filename = $self->{cms}{config_filename};
    my ($elem, $extra) = $config->getChildrenByTagNameNS($Daizu::CONFIG_NS,
                                                         'thumbnail');
    xml_croak($config_filename, $extra, "only one <thumbnail> element allowed")
        if defined $extra;

    if (!defined $elem) {
        # If there's no 'thumbnail' element, fall back to defaults.
        $self->{max_width} = $DEFAULT_THUMBNAIL_MAX_WIDTH;
        $self->{max_height} = $DEFAULT_THUMBNAIL_MAX_HEIGHT;
        $self->{thumbnail_filename_suffix} = $DEFAULT_THUMBNAIL_FILENAME_SUFFIX;
    }
    else {
        # Extract attributes from 'thumbnail' element.
        my $max_wd = trim(xml_attr($config_filename, $elem, 'max-width', ''));
        my $max_ht = trim(xml_attr($config_filename, $elem, 'max-height', ''));
        for ($max_wd, $max_ht) {
            if (!defined $_ || $_ eq '') {
                $_ = undef;
                next;
            }
            xml_croak($config_filename, $elem,
                      "attribute on element <thumbnail> should be a number")
                unless /^\d+$/;
        }

        $self->{max_width} = $max_wd;
        $self->{max_height} = $max_ht;

        $self->{thumbnail_filename_suffix} =
            trim(xml_attr($config_filename, $elem, 'filename-suffix',
                          $DEFAULT_THUMBNAIL_FILENAME_SUFFIX));
        xml_croak($config_filename, $elem, "filename-suffix must not be empty")
            if $self->{thumbnail_filename_suffix} eq '';
    }

    $self->{config_parsed} = 1;
}

sub register
{
    my ($class, $cms, $whole_config, $plugin_config, $path) = @_;
    my $self = bless { config => $plugin_config }, $class;
    $cms->add_article_loader('image/*', '', $self => 'load_article');
}

sub load_article
{
    my ($self, $cms, $file) = @_;
    $self->_parse_config;

    # Size of the article picture itself.
    my ($pic_wd, $pic_ht) = ($file->{image_width}, $file->{image_height});
    croak "size of picture article image file not available in database"
        unless defined $pic_wd && defined $pic_ht;

    my $article_url = '';
    my $base_url = $file->generator->base_url($file);
    if ($base_url !~ m!/$!) {
        $article_url = $file->{name};
        $article_url =~ s!\.[^./]+$!.html!
            or $article_url .= '.html';
    }
    my @extra_url;
    push @extra_url, {
        url => $file->{name},
        type => $file->{content_type},
        generator => 'Daizu::Gen',
        method => 'unprocessed',
    };

    # Filename of the thumbnail image, if any.
    my $thm_filename = $file->{name};
    my $filename_suffix = $self->{thumbnail_filename_suffix};
    $thm_filename =~ s!\.([^/.]+)$!$filename_suffix.$1!
        or $thm_filename .= $filename_suffix;

    # Does the thumbnail exist in the repository, and if so how big is it.
    my ($thm_exists, $thm_wd, $thm_ht) = db_select($cms->db, wc_file => {
        wc_id => $file->{wc_id},
        parent_id => $file->{parent_id},
        name => $thm_filename,
    }, qw( 1 image_width image_height ));
    croak "image to be thumbnailed doesn't have size recorded in database"
        if $thm_exists && (!defined $thm_wd || !defined $thm_ht);

    # How big is the thumbnail allowed to be, if there's a limit.
    my $max_wd = $self->{max_width};
    $max_wd = $pic_wd unless defined $max_wd;
    my $max_ht = $self->{max_height};
    $max_ht = $pic_ht unless defined $max_ht;

    # If there is no thumbnail provided for us, and the article image is too
    # big, then add add our own thumbnail URL.
    if (!$thm_exists && ($pic_wd > $max_wd || $pic_ht > $max_ht)) {
        $thm_wd = $pic_wd unless defined $thm_wd;
        $thm_ht = $pic_ht unless defined $thm_ht;

        my $x_mul = $thm_wd / $max_wd;
        my $y_mul = $thm_ht / $max_ht;
        if ($x_mul > $y_mul) {
            $thm_wd = $max_wd;
            $thm_ht = round($thm_ht / $x_mul);
        }
        else {
            $thm_wd = round($thm_wd / $y_mul);
            $thm_ht = $max_ht;
        }
        assert($thm_wd <= $max_wd && $thm_ht <= $max_ht) if DEBUG;
        assert($thm_wd == $max_wd || $thm_ht == $max_ht) if DEBUG;

        push @extra_url, {
            url => $thm_filename,
            type => $file->{content_type},
            generator => 'Daizu::Gen',
            method => 'scaled_image',
            argument => "$thm_wd $thm_ht",
        };
        $thm_exists = 1;
    }

    # Create the article content.
    my $doc = XML::LibXML::Document->new('1.0', 'UTF-8');
    my $body = $doc->createElementNS('http://www.w3.org/1999/xhtml', 'body');
    $doc->setDocumentElement($body);

    my $img = XML::LibXML::Element->new('img');
    $img->setAttribute(src => ($thm_exists ? $thm_filename : $file->{name}));

    my $alt = $file->property('daizu:alt');
    $img->setAttribute(alt => (defined $alt ? $alt : ''));

    $img->setAttribute(width => $thm_wd) if $thm_wd;
    $img->setAttribute(height => $thm_ht) if $thm_ht;

    my $img_block = add_xml_elem($body, 'div', undef,
        class => 'display-picture',
    );
    if ($thm_exists) {
        my $link = add_xml_elem($img_block, 'a', $img, href => $file->{name});
        add_xml_elem($link, 'br');
        # Since we're linking to the full size image, provide some details
        # about it, mainly as a warning if it's really big.
        my $desc = " ($pic_wd\xD7$pic_ht, " .
                   display_byte_size($file->{data_len}) .
                   ')';
        $link->appendText('Full size image');
        $img_block->appendText(encode('UTF-8', $desc, Encode::FB_CROAK));
    }
    else {
        # Don't provide a link to the image if it's the same file as we're
        # including directly in the page.
        $img_block->appendChild($img);
    }

    return {
        content => $doc,
        pages_url => $article_url,
        extra_urls => \@extra_url,
    };
}

1;
# vi:ts=4 sw=4 expandtab