xmlnode.cpp

Go to the documentation of this file.

/**********************************************************************
 * LeechCraft - modular cross-platform feature rich internet client.
 * Copyright (C) 2006-2014  Georg Rudoy
 *
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 **********************************************************************/

#include "xmlnode.h"
#include <QSize>
#include <QXmlStreamWriter>
#include <util/sll/visitor.h>
#include <util/sll/qtutil.h>

namespace LC::Util
{
    Nodes operator+ (Node&& node, Nodes&& nodes)
    {
        nodes.prepend (std::move (node));
        return nodes;
    }

    Nodes operator+ (Nodes&& nodes, Node&& node)
    {
        nodes.push_back (std::move (node));
        return nodes;
    }

    Nodes operator+ (Node&& n1, Node&& n2)
    {
        return { std::move (n1), std::move (n2) };
    }

    Tag Tag::WithText (const QByteArray& name, const QString& contents)
    {
        return { .Name_ = name, .Children_ = { contents } };
    }

    Node Tag::WithTextNonEmpty (const QByteArray& name, const QString& contents)
    {
        if (contents.isEmpty ())
            return NoNode {};
        return Tag { .Name_ = name, .Children_ = { contents } };
    }

    namespace
    {
        void TagToHtml (const Tag& tag, QXmlStreamWriter& w)
        {
            w.writeStartElement (tag.Name_);

            for (const auto& [name, value] : tag.Attrs_)
                w.writeAttribute (name, value);

            for (const auto& node : tag.Children_)
                Visit (node,
                        [] (NoNode) {},
                        [&w] (const QString& str) { w.writeCharacters (str); },
                        [&w] (const Tag& childTag) { TagToHtml (childTag, w); });

            w.writeEndElement ();
        }
    }

    template<XmlRepr T>
    T Tag::Serialize (const TagSerializeConfig& config) const
    {
        if (Name_.isEmpty ())
            return {};

        T result;

        QXmlStreamWriter w { &result };
        if (config.Indent_)
        {
            w.setAutoFormatting (true);
            w.setAutoFormattingIndent (*config.Indent_);
        }

        if (config.Prolog_)
            w.writeStartDocument ();

        Visit (config.Dtd_,
                [] (NoDtd) {},
                [&w] (Html5Dtd) { w.writeDTD ("html"_qba); },
                [&w] (const CustomDtd& dtd) { w.writeDTD (dtd.Dtd_); });

        TagToHtml (*this, w);

        if (config.Prolog_)
            w.writeEndDocument ();

        return result;
    }

    template QString Tag::Serialize (const TagSerializeConfig&) const;
    template QByteArray Tag::Serialize (const TagSerializeConfig&) const;

    Tag& Tag::WithAttr (QByteArray key, QString value) &&
    {
        Attrs_.push_back ({ std::move (key), std::move (value) });
        return *this;
    }

    namespace Tags
    {
        UTIL_SLL_API const Tag Br { .Name_ = "br"_qba };

        Tag Html (Nodes&& children)
        {
            return
            {
                .Name_ = "html"_qba,
                .Attrs_ = { { "xmlns"_qba, "http://www.w3.org/1999/xhtml"_qs } },
                .Children_ = std::move (children),
            };
        }

        Tag Charset (const QString& charset)
        {
            return { .Name_ = "meta"_qba, .Attrs_ = { { "charset"_qba, charset } } };
        }

        Tag Title (const QString& title)
        {
            return { .Name_ = "title"_qba, .Children_ = { title } };
        }

        Tag Style (const QString& style)
        {
            return { .Name_ = "style"_qba, .Children_ = { style } };
        }

        Tag Body (Nodes&& children)
        {
            return { .Name_ = "body"_qba, .Children_ = std::move (children) };
        }

        Tag Image (const QString& url)
        {
            return { .Name_ = "img"_qba, .Attrs_ = { { "src"_qba, url } } };
        }

        Tag Image (const QString& url, const QSize& size)
        {
            const auto& w = QString::number (size.width ());
            const auto& h = QString::number (size.height ());
            return
            {
                .Name_ = "img"_qba,
                .Attrs_ = { { "src"_qba, url }, { "width"_qba, w }, { "height"_qba, h } },
            };
        }

        Tag Li (Nodes&& children)
        {
            return { .Name_ = "li"_qba, .Children_ = std::move (children) };
        }

        Tag Ul (Nodes&& children)
        {
            return { .Name_ = "ul"_qba, .Children_ = std::move (children) };
        }

        Tag P (Nodes&& children)
        {
            return { .Name_ = "p"_qba, .Children_ = std::move (children) };
        }

        Nodes TableGrid (size_t rows, size_t cols, const std::function<Nodes (size_t, size_t)>& cell)
        {
            Nodes result;
            result.reserve (rows);

            for (size_t r = 0; r < rows; ++r)
            {
                Nodes rowCells;
                rowCells.reserve (cols);
                for (size_t c = 0; c < cols; ++c)
                    rowCells.push_back (Tag { .Name_ = "td"_qba, .Children_ = cell (r, c) });

                result.push_back (Tag { .Name_ = "tr"_qba, .Children_ = std::move (rowCells) });
            }

            return result;
        }
    }
}