CRNDocument.cpp

Go to the documentation of this file.

/* Copyright 2006-2016 Yann LEYDIER, INSA-Lyon, ENS-Lyon
 * 
 * This file is part of libcrn.
 * 
 * libcrn is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * libcrn is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with libcrn.  If not, see <http://www.gnu.org/licenses/>.
 * 
 * file: CRNDocument.cpp
 * \author Yann LEYDIER
 */

#include <CRNi18n.h>
#include <CRNDocument.h>
#include <CRNException.h>
#include <CRNConfig.h>
#include <CRNUtils/CRNAtScopeExit.h>
#include <CRNUtils/CRNProgress.h>
#include <CRNXml/CRNXml.h>
#include <CRNIO/CRNIO.h>
#ifdef CRN_USING_HARU
#   include <CRNUtils/CRNPDF.h>
#endif

using namespace crn;
using namespace crn::literals;

const Path Document::thumbdir("/thumbs/");
size_t Document::thumbWidth = 70; // almost A4
size_t Document::thumbHeight = 100;

/*****************************************************************************/
Document::Document():Savable(U""),
    basename(""),
    author(U""),
    date(U"")
{
}

/*****************************************************************************/
Document::~Document()
{
}

/*****************************************************************************/
String Document::AddView(const Path &fname)
{
    if (!fname)
        throw ExceptionInvalidArgument(StringUTF8("void Document::AddView(const Path &fname): ") + _("null filename."));
    String id(createNewId());
    addView(fname, id);
    return id;
}

/*****************************************************************************/
void Document::addView(const Path &fname, const String &id)
{
    views.push_back(view(fname, id));
}

/*****************************************************************************/
String Document::InsertView(const Path &fname, size_t pos)
{
    if (!fname)
        throw ExceptionInvalidArgument(StringUTF8("void Document::InsertView(const Path &fname, size_t pos): ") + _("null filename."));
    if (pos > views.size())
        throw ExceptionDomain(StringUTF8("void Document::InsertView(const Path &fname, size_t pos): ") + _("index out of bounds."));
        
    if (pos == views.size())
        return AddView(fname);
    else
    {
        String id(createNewId());
        views.insert(views.begin() + pos, view(fname, id));
        return id;
    }
}

/*****************************************************************************/
void Document::RemoveView(const Path &fname)
{
    view v(fname);
    auto it(std::find(views.begin(), views.end(), v));
    if (it == views.end())
        throw ExceptionNotFound(StringUTF8("void Document::RemoveView(const Path &fname): ") + _("filename not found."));
    RemoveView(it - views.begin());
}

/*****************************************************************************/
void Document::RemoveView(size_t num)
{
    if (num >= views.size())
        throw ExceptionDomain(StringUTF8("void Document::RemoveView(size_t num): ") + _("index out of bounds."));
    // remove thumbnail
    Path thumbname(basename + thumbdir + views[num].id);
    try
    {
        IO::Rm(thumbname);
    } catch (...) { }
    // remove xml
    Path xmlname(basename + "/" + views[num].id + ".xml");
    try
    {
        IO::Rm(xmlname);
    } catch (...) { }
    // remove block
    views.erase(views.begin() + num);
}
        
/*****************************************************************************/
void Document::RemoveView(const String &id)
{
    RemoveView(GetViewIndex(id));
}
        
/*****************************************************************************/
SBlock Document::GetView(size_t num) const
{
    if (num >= views.size())
    {
        throw ExceptionDomain(StringUTF8("SBlock Document::GetView(size_t num) const: ") + _("Index out of bounds."));
    }
    if (views[num].ptr.expired())
    {
        Path s;
        if (basename.IsNotEmpty())
        {
            s += basename + Path::Separator();
            s += Path(views[num].id) + ".xml";
        }
        SBlock b(Block::New(views[num].filename, s, views[num].filename));
        views[num].ptr = b;
        return b;
    }
    return views[num].ptr.lock();
}

SBlock Document::GetView(const String &id) const
{
    return GetView(GetViewIndex(id));
}

SBlock Document::GetView(const Path &fname) const
{
    return GetView(GetViewIndex(fname));
}

size_t Document::GetViewIndex(const String &id) const
{
    for (size_t tmp = 0; tmp < views.size(); ++tmp)
    {
        if (views[tmp].id == id)
            return tmp;
    }
    throw ExceptionNotFound(StringUTF8("size_t Document::GetViewIndex(const String &id) const: ") + _("id not found."));
}

size_t Document::GetViewIndex(const Path &fname) const
{
    for (size_t tmp = 0; tmp < views.size(); ++tmp)
    {
        if (views[tmp].filename == fname)
            return tmp;
    }
    throw ExceptionNotFound(StringUTF8("size_t Document::GetViewIndex(const Path &fname) const: ") + _("filename not found."));
}

String Document::GetViewId(size_t num) const
{
    if (num >= views.size())
        throw ExceptionDomain(StringUTF8("const String Document::GetViewId(size_t num) const: ") + _("index out of bounds."));
        
    return views[num].id;
}

String Document::GetViewId(const Path &fname) const
{
    for (auto & elem : views)
    {
        if (elem.filename == fname)
            return elem.id;
    }
    throw ExceptionNotFound(StringUTF8("const String Document::GetViewId(const Path &fname) const: ") + _("filename not found."));
}

Path Document::GetViewFilename(size_t num) const
{
    if (num >= views.size())
        throw ExceptionDomain(StringUTF8("const Path Document::GetViewFilename(size_t num) const: ") + _("index out of bounds."));

    return views[num].filename;
}

Path Document::GetViewFilename(const String &id) const
{
    return GetViewFilename(GetViewIndex(id));
}

void Document::ReorderViewsFrom(const std::vector<size_t> &from)
{
    if (from.size() != views.size())
    {
        throw ExceptionDimension(StringUTF8("bool Document::ReorderViewsFrom(const std::vector<size_t> &from): ") + 
                _("bad changeset size."));
    }
    std::set<size_t> cont;
    for (size_t i : from)
    {
        cont.insert(i);
    }
    if (cont.size() != views.size())
    {
        throw ExceptionLogic(StringUTF8("bool Document::ReorderViewsFrom(const std::vector<size_t> &from): ") + 
                _("changeset contains duplicates."));
    }
    if ((*cont.begin() != 0) || (*cont.rbegin() != views.size() - 1))
    {
        throw ExceptionDomain(StringUTF8("bool Document::ReorderViewsFrom(const std::vector<size_t> &from): ") + 
                _("changeset contains values out of bounds."));
    }
    std::vector<view> newviews;
    for (size_t i : from)
    {
        newviews.push_back(views[i]);
    }
    views.swap(newviews);
}

void Document::ReorderViewsTo(const std::vector<size_t> &to)
{
    if (to.size() != views.size())
    {
        throw ExceptionDimension(StringUTF8("bool Document::ReorderViewsTo(const std::vector<size_t> &to): ") + 
                _("bad changeset size."));
    }
    std::set<size_t> cont;
    for (size_t i : to)
    {
        cont.insert(i);
    }
    if (cont.size() != views.size())
    {
        throw ExceptionLogic(StringUTF8("bool Document::ReorderViewsTo(const std::vector<size_t> &to): ") + 
                _("changeset contains duplicates."));
    }
    if ((*cont.begin() != 0) || (*cont.rbegin() != views.size() - 1))
    {
        throw ExceptionDomain(StringUTF8("bool Document::ReorderViewsTo(const std::vector<size_t> &to): ") + 
                _("changeset contains values out of bounds."));
    }
    std::vector<view> newviews(views.size());
    for (size_t tmp = 0; tmp < to.size(); ++tmp)
    {
        newviews[to[tmp]] = views[tmp];
    }
    views.swap(newviews);
}

void Document::Clear()
{
    views.clear();
    SetName(U"");
    SetAuthor(U"");
    SetDate(U"");
    ClearUserData();
}

/*****************************************************************************/
void Document::load(const Path &fname)
{
    xml::Document doc(fname); // may throw
    xml::Element root(doc.GetRoot()); // may throw
    if (root.GetName() != "Document")
    {
        throw ExceptionRuntime(StringUTF8("bool Document::load(const String &fname): ") + 
                _("Not a Document file."));
    }

    std::multimap<int, std::pair<Path, String> > xmlviews;
    xml::Element vi(root.GetFirstChildElement("View"));
    while (vi)
    {
        Path fname(vi.GetAttribute<StringUTF8>("fname", false)); // may throw
        int num ;
        try { num = vi.GetAttribute<int>("num", false); } catch (...) { num = int(xmlviews.size()); } // if no index found, push back
        String id = vi.GetAttribute<StringUTF8>("id");
        if (id.IsEmpty()) // if no id found, use index
            id = num;
        xmlviews.insert(std::make_pair(num, std::make_pair(fname, id)));
        vi = vi.GetNextSiblingElement("View");
    }

    StringUTF8 bn = root.GetAttribute<StringUTF8>("basename", false); // may throw
    if (bn.IsNotEmpty())
    {
        basename = bn;
        if (!IO::Access(bn, IO::EXISTS))
        {
            IO::Mkdir(bn); // may throw
        }
    }
    bn = root.GetAttribute<StringUTF8>("author");
    if (bn.IsNotEmpty())
        author = bn;
    bn = root.GetAttribute<StringUTF8>("date");
    if (bn.IsNotEmpty())
        date = bn;

    views.clear();
    for (auto & xmlview : xmlviews)
    {
        addView(xmlview.second.first, xmlview.second.second);
    }
    /*
    xml::Element vi(root.GetFirstChildElement("View"));
    int cnt = 0;
    while (vi)
    {
        bn = vi.GetAttribute<StringUTF8>("fname");
        if (bn.IsNotEmpty())
        {
            const StringUTF8 id = vi.GetAttribute<StringUTF8>("id");
            if (id.IsNotEmpty())
                addView(bn, id);
            else // if no id was found, create one using the index
                addView(bn, String(cnt));
        }
        cnt += 1;
        vi = vi.GetNextSiblingElement("View");
    }
    */
    deserialize_internal_data(root);
}

Path Document::GetThumbnailPath() const
{
    return basename + thumbdir;
}

UImage Document::createThumbnail(const Path &imagename) const
{
    UImage img = NewImageFromFile(imagename);
    // scale the image
    size_t nw, nh;
    nh = img->GetHeight() * thumbWidth / img->GetWidth();
    if (nh <= thumbHeight)
    {
        nw = thumbWidth;
    }
    else
    {
        nw = img->GetWidth() * thumbHeight / img->GetHeight();
        nh = thumbHeight;
    }
    img->ScaleToSize(nw, nh);
    return std::forward<UImage>(img);
}

UImage Document::GetThumbnail(size_t index, bool refresh) const
{
    Path thumbname(GetThumbnailFilename(index, refresh));
    return NewImageFromFile(thumbname);
}

UImage Document::GetThumbnail(const String &id, bool refresh) const
{
    return GetThumbnail(GetViewIndex(id), refresh);
}

Path Document::GetThumbnailFilename(size_t index, bool refresh) const
{
    if (index >= GetNbViews())
        throw ExceptionDomain(StringUTF8("const Path Document::GetThumbnailFilename(size_t index, bool refresh) const: ") + _("index out of bounds."));

    if (!basename)
    { // the document was never saved, so no thumbnail can be cached
        throw ExceptionUninitialized(StringUTF8("const Path Document::GetThumbnailFilename(size_t index, bool refresh) const: ") + _("the document was never saved."));
    }

    if (!IO::Access(basename + thumbdir, IO::EXISTS))
    { // if the thumb directory does not exist, create it
        IO::Mkdir(basename + thumbdir);
    }

    Path thumbname(basename + thumbdir + GetViewId(index));
    if (!IO::Access(thumbname, IO::EXISTS) || refresh)
    { // compute the thumbnail
        UImage img(createThumbnail(GetViewFilename(index)));
        // scale the image
        img->SavePNG(thumbname);
    }
    return thumbname;
}

Path Document::GetThumbnailFilename(const String &id, bool refresh) const
{
    return GetThumbnailFilename(GetViewIndex(id), refresh);
}

/*****************************************************************************/
void Document::save(const Path &fname)
{
    size_t namepos = fname.BackwardFindAnyOf("."); // strip extension if any
    if (namepos == String::NPos())
        namepos = 0;
    basename = Path(fname.SubString(0, namepos)) + "_data"; // append "_data"
    if (!IO::Access(basename, IO::EXISTS))
    {
        IO::Mkdir(basename); // may throw
    }

    xml::Document doc;
    doc.PushBackComment("libcrn Document file");
    xml::Element root(doc.PushBackElement("Document"));
    root.SetAttribute("basename", basename.CStr());
    root.SetAttribute("author", author.CStr());
    root.SetAttribute("date", date.CStr());

    // save views
    for (size_t tmp = 0; tmp < views.size(); tmp++)
    {
        xml::Element el(root.PushBackElement("View"));
        el.SetAttribute("fname", views[tmp].filename.CStr());
        el.SetAttribute("id", views[tmp].id.CStr());
        el.SetAttribute("num", int(tmp));
    }

    serialize_internal_data(root);

    doc.Save(fname); // may throw
}

Path Document::GetDefaultDirName()
{
    const auto dirname = Config::GetTopDataPath() / "documents";
    if (!IO::Access(dirname, IO::EXISTS))
    {
        try { IO::Mkdir(dirname); }
        catch (...) {}
    }
    return dirname;
}

/*****************************************************************************/
Path Document::completeFilename(const Path &fn) const
{
    return GetDefaultDirName() / fn;
}

std::vector<Path> Document::GetFilenames() const
{
    std::vector<Path> flist;
    for (const view &v : views)
        flist.push_back(v.filename);
    return flist;
}

std::vector<String> Document::GetViewIds() const
{
    std::vector<String> flist;
    for (const view &v : views)
        flist.push_back(v.id);
    return flist;
}

String Document::createNewId() const
{
    // create a temporary file name (in std C)
    String id(String::CreateUniqueId());
    // check if the id is unique
    for (const view &v : views)
    {
        if (v.id == id)
            return createNewId();
    }
    return id;
}

#ifdef CRN_USING_HARU

void Document::ExportPDF(const Path &fname, const PDF::Attributes &attr, Progress *prog) const
{
    PDF::Doc pdf(attr);
    std::vector<Path> images;
    Path tmpimg(tmpnam(nullptr));
    if (prog)
        prog->SetMaxCount((int)GetNbViews());
    for (const view &v : views)
    {
        PDF::Page page = pdf.AddPage();
        PDF::Image image;
        if (attr.lossy_compression)
        { // jpeg
            auto img = NewImageFromFile(v.filename);
            img->SaveJPEG(tmpimg, attr.jpeg_qual);
            image   = pdf.AddJPEG(tmpimg);
        }
        else
        { // png
            auto img = NewImageFromFile(v.filename);
            img->SavePNG(images.back());
            images.push_back(tmpnam(nullptr));
            image   = pdf.AddPNG(images.back());
        }
        page.SetWidth((double)image.GetWidth());
        page.SetHeight((double)image.GetHeight());
        page.DrawImage(image, {0, 0, (int)image.GetWidth() - 1, (int)image.GetHeight() - 1});
        if (prog)
            prog->Advance();
    }
    // save
    pdf.Save(fname);

    if (attr.lossy_compression)
    {
        try
        {
            IO::Rm(tmpimg);
        } catch (...) { }
    }
    else
    {
        for (const Path &fname : images)
        {
            try
            {
                IO::Rm(fname);
            } catch (...) { }
        }
    }
}
#endif

size_t Document::GetThumbWidth() noexcept
{
    return thumbWidth;
}
size_t Document::GetThumbHeight() noexcept
{
    return thumbHeight;
}
void Document::SetThumbWidth(size_t w)
{
    if (w == 0)
        throw ExceptionDomain{ "Document::SetThumbWidth()"_s + _("Null width.") };
    thumbWidth = w;
}
void Document::SetThumbHeight(size_t h)
{
    if (h == 0)
        throw ExceptionDomain{ "Document::SetThumbHeight()"_s + _("Null height.") };
    thumbHeight = h;
}