Daizu::Plugin::DisplayPicture - display scaled-down versions of images in articles

    <daizu:display-picture filename="photo.jpg"/>

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

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

package Daizu::Plugin::DisplayPicture;
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_row_id 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_html_dom_filter($path, $self => 'filter_article');
}

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

    my @extra_url;

    for my $elem ($doc->findnodes(qq{
                //*[namespace-uri() = '$Daizu::HTML_EXTENSION_NS' and
                        local-name() = 'display-picture']
        }))
    {
        my $filename = $elem->getAttribute('filename');
        croak "<daizu:display-picture> requires 'filename' attribute"
            unless defined $filename;
        my $pic_file = $file->file_at_path($filename);

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

        my $pic_url = $pic_file->permalink;
        croak "display-picture image file has no URL"
            unless defined $pic_url;

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

        # Does the thumbnail exist in the repository, and if so how big is it.
# TODO - this won't work, because URL updating hasn't been done by the time the article is loaded.  This needs to be based on filename not URL, then it can generate the URL from that once it has found the image file.
        my ($thm_guid_id) = db_select($db, 'url',
            { url => $thm_url, status => 'A' },
            'guid_id',
        );
        $thm_guid_id = undef
            if defined $thm_guid_id && $thm_guid_id == $file->{guid_id};
        my ($thm_exists, $thm_wd, $thm_ht);
        if (defined $thm_guid_id) {
            ($thm_exists, $thm_wd, $thm_ht) = db_select($db, wc_file => {
                wc_id => $file->{wc_id},
                guid_id => $thm_guid_id,
            }, qw( 1 image_width image_height ));
            croak "thumbnail '$thm_url' 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_url,
                type => $pic_file->{content_type},
                generator => 'Daizu::Gen',
                method => 'scaled_image',
                argument => "$thm_wd $thm_ht $pic_file->{guid_id}",
            };
            $thm_exists = 1;
        }

        # Create the article content.
        my $img = XML::LibXML::Element->new('img');
        $img->setAttribute(src => ($thm_exists ? $thm_url : $pic_url));

        my $alt = $elem->getAttribute('alt');
        $alt = $pic_file->property('daizu:alt')
            unless defined $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 = $doc->createElementNS('http://www.w3.org/1999/xhtml',
                                              'div');
        $img_block->setAttribute(class => 'display-picture');

        if ($thm_exists) {
            add_xml_elem($img_block, 'a', $img, href => $pic_url);
            add_xml_elem($img_block, '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 = "full size: $pic_wd\xD7$pic_ht, " .
                       display_byte_size($pic_file->{data_len});
            $desc = encode('UTF-8', $desc, Encode::FB_CROAK);
            add_xml_elem($img_block, 'a', $desc, href => $pic_url);
        }
        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);
        }

        $elem->replaceNode($img_block);
    }

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

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