svgdevicecontext.h

// Name:        svgdevicecontext.h
// Author:      Laurent Pugin
// Created:     2011
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_SVG_DC_H__
#define __VRV_SVG_DC_H__
 
#include <fstream>
#include <list>
#include <set>
#include <string>
#include <vector>
 
//----------------------------------------------------------------------------
 
#include "devicecontext.h"
#include "object.h"
#include "options.h"
 
//----------------------------------------------------------------------------
 
class Glyph;
class Resources;
 
namespace vrv {
 
//----------------------------------------------------------------------------
// SvgDeviceContext
//----------------------------------------------------------------------------
 
class SvgDeviceContext : public DeviceContext {
public:
    SvgDeviceContext(const std::string &docId);
    virtual ~SvgDeviceContext();
 
    void SetBackground(int color, int style = PEN_SOLID) override;
    void SetBackgroundImage(void *image, double opacity = 1.0) override;
    void SetBackgroundMode(int mode) override;
    void SetTextForeground(int color) override;
    void SetTextBackground(int color) override;
    void SetLogicalOrigin(int x, int y) override;
 
    Point GetLogicalOrigin() override;
 
    std::string GetStringSVG(bool xml_declaration = false);
 
    void DrawQuadBezierPath(Point bezier[3]) override;
    void DrawCubicBezierPath(Point bezier[4]) override;
    void DrawCubicBezierPathFilled(Point bezier1[4], Point bezier2[4]) override;
    void DrawBentParallelogramFilled(Point side[4], int height) override;
    void DrawCircle(int x, int y, int radius) override;
    void DrawEllipse(int x, int y, int width, int height) override;
    void DrawEllipticArc(int x, int y, int width, int height, double start, double end) override;
    void DrawLine(int x1, int y1, int x2, int y2) override;
    void DrawPolyline(int n, Point points[], bool close) override;
    void DrawPolygon(int n, Point points[]) override;
    void DrawRectangle(int x, int y, int width, int height) override;
    void DrawRotatedText(const std::string &text, int x, int y, double angle) override;
    void DrawRoundedRectangle(int x, int y, int width, int height, int radius) override;
    void DrawText(const std::string &text, const std::u32string &wtext = U"", int x = VRV_UNSET, int y = VRV_UNSET,
        int width = VRV_UNSET, int height = VRV_UNSET) override;
    void DrawMusicText(const std::u32string &text, int x, int y, bool setSmuflGlyph = false) override;
    void DrawSpline(int n, Point points[]) override;
    void DrawGraphicUri(int x, int y, int width, int height, const std::string &uri) override;
    void DrawSvgShape(int x, int y, int width, int height, double scale, pugi::xml_node svg) override;
    void DrawBackgroundImage(int x = 0, int y = 0) override;
 
    void StartText(int x, int y, data_HORIZONTALALIGNMENT alignment = HORIZONTALALIGNMENT_left) override;
    void EndText() override;
 
    void MoveTextTo(int x, int y, data_HORIZONTALALIGNMENT alignment) override;
    void MoveTextVerticallyTo(int y) override;
 
    bool ApplyOffset() override { return true; }
 
    void StartGraphic(Object *object, const std::string &gClass, const std::string &gId, GraphicID graphicID = PRIMARY,
        bool prepend = false) override;
    void EndGraphic(Object *object, View *view) override;
 
    void StartCustomGraphic(const std::string &name, std::string gClass = "", std::string gId = "") override;
    void EndCustomGraphic() override;
 
    void SetCustomGraphicColor(const std::string &color) override;
 
    void SetCustomGraphicAttributes(const std::string &data, const std::string &value) override;
 
    void ResumeGraphic(Object *object, std::string gId) override;
    void EndResumedGraphic(Object *object, View *view) override;
 
    void StartTextGraphic(Object *object, const std::string &gClass, const std::string &gId) override;
    void EndTextGraphic(Object *object, View *view) override;
 
    void RotateGraphic(Point const &orig, double angle) override;
 
    void StartPage() override;
    void EndPage() override;
 
    void AddDescription(const std::string &text) override;
 
    void AppendIdAndClass(const std::string &gId, const std::string &baseClass, const std::string &addedClasses,
        GraphicID graphicID = PRIMARY);
 
    void AppendAdditionalAttributes(Object *object);
 
    bool UseGlobalStyling() override { return !m_mmOutput; }
 
    void SetMMOutput(bool mmOutput) { m_mmOutput = mmOutput; }
 
    void SetFacsimile(bool facsimile) { m_facsimile = facsimile; }
    bool GetFacsimile() { return m_facsimile; }
 
    void SetUseLiberation(bool useLiberation) { m_useLiberation = useLiberation; }
 
    void SetSvgBoundingBoxes(bool svgBoundingBoxes) { m_svgBoundingBoxes = svgBoundingBoxes; }
 
    void SetSvgContentBoundingBoxes(bool svgContentBoundingBoxes)
    {
        m_svgContentBoundingBoxes = svgContentBoundingBoxes;
    }
 
    void SetSvgViewBox(bool svgViewBox) { m_svgViewBox = svgViewBox; }
 
    void SetHtml5(bool html5) { m_html5 = html5; }
 
    void SetIndent(int indent) { m_indent = indent; }
 
    void SetFormatRaw(bool rawFormat) { m_formatRaw = rawFormat; }
 
    void SetRemoveXlink(bool removeXlink) { m_removeXlink = removeXlink; }
 
    void SetCss(const std::string &css)
    {
        m_css = css;
        this->PrefixCssRules(m_css);
    }
 
    void SetAdditionalAttributes(const std::vector<std::string> &additionalAttributes)
    {
        for (std::string s : additionalAttributes) {
            std::string className = s.substr(0, s.find("@")); // parse <element@attribute>, e.g., "note@pname"
            std::string attributeName = s.substr(s.find("@") + 1);
            ClassId classId = ObjectFactory::GetInstance()->GetClassId(className);
            m_svgAdditionalAttributes.insert({ classId, attributeName });
        }
    }
 
    void SetSmuflTextFont(option_SMUFLTEXTFONT smuflTextFont) { m_smuflTextFont = smuflTextFont; }
 
private:
    bool CopyFileToStream(const std::string &filename, std::ostream &dest);
 
    void DrawSvgBoundingBox(Object *object, View *view);
 
    void DrawSvgBoundingBoxRectangle(int x, int y, int width, int height);
 
    void VrvTextFont() { m_vrvTextFont = true; }
 
    void VrvTextFontFallback() { m_vrvTextFontFallback = true; }
 
    void IncludeTextFont(const std::string &fontname, const Resources *resources);
 
    void Commit(bool xml_declaration);
 
    void WriteLine(std::string);
 
    std::string GetColor(int color) const;
 
    pugi::xml_node AddChild(std::string name);
 
    void AppendStrokeLineCap(pugi::xml_node node, const Pen &pen);
    void AppendStrokeLineJoin(pugi::xml_node node, const Pen &pen);
    void AppendStrokeDashArray(pugi::xml_node node, const Pen &pen);
 
    void PrefixCssRules(std::string &rules);
 
public:
    //
private:
    bool m_vrvTextFont;
 
    bool m_vrvTextFontFallback;
 
    // we use a std::stringstream because we want to prepend the <defs> which will know only when we reach the end of
    // the page
    // some viewer seem to support to have the <defs> at the end, but some do not (pdf2svg, for example)
    // for this reason, the full svg is finally written a string from the destructor or when Flush() is called
    std::ostringstream m_outdata;
 
    bool m_committed; // did we flushed the file?
    int m_originX, m_originY;
 
    // Here we hold references to all different glyphs used so far,
    // including any glyph for the same code but from different fonts.
    // They will be added at the end of the file as <defs>.
    // With multiple font support we need to keep track of:
    //  a) the glyph (to check if is has been already added)
    //  b) the id assigned to glyphs on the (that is has been consumed by the already rendered elements)
    // To keep things as similar as possible to previous versions we generate ids with as uuuu-ss (where uuuu is the
    // Smulf code for the glyph and ss the per-session suffix) for most of the cases (single font usage). When the same
    // glyph has been used from several fonts we use uuuu-n-ss where n indicates the collision count.
    class GlyphRef {
    public:
        GlyphRef(const Glyph *glyph, int count, const std::string &postfix);
        const Glyph *GetGlyph() const { return m_glyph; };
        const std::string &GetRefId() const { return m_refId; };
 
    private:
        const Glyph *m_glyph;
        std::string m_refId;
    };
    const std::string InsertGlyphRef(const Glyph *glyph);
    std::vector<std::pair<const Glyph *, GlyphRef>> m_smuflGlyphs;
    std::map<std::string, int> m_glyphCodeFontCounter;
 
    // pugixml data
    pugi::xml_document m_svgDoc;
    pugi::xml_node m_svgNode;
    pugi::xml_node m_pageNode;
    pugi::xml_node m_currentNode;
    std::list<pugi::xml_node> m_svgNodeStack;
 
    // output as mm (for pdf generation with a 72 dpi)
    bool m_mmOutput;
    bool m_facsimile;
    // use LiberationTextFont
    bool m_useLiberation;
    // add bouding boxes in svg output
    bool m_svgBoundingBoxes;
    // add content bounding boxes in svg output
    bool m_svgContentBoundingBoxes;
    // use viewbox on svg root element
    bool m_svgViewBox;
    // output HTML5 data-* attributes
    bool m_html5;
    // additional CSS
    std::string m_css;
    // copy additional attributes of given elements to the SVG, in the form "note@pname; layer@n"
    std::multimap<ClassId, std::string> m_svgAdditionalAttributes;
    // format output as raw, stripping extraneous whitespace and non-content newlines
    bool m_formatRaw;
    // remove xlink from href attributes
    bool m_removeXlink;
    // indentation value (-1 for tabs)
    int m_indent;
    // postfix to be added to font glyphs
    std::string m_glyphPostfixId;
    // embedding of the smufl text font
    option_SMUFLTEXTFONT m_smuflTextFont;
    // the document id
    std::string m_docId;
};
 
} // namespace vrv
 
#endif // __VRV_SVG_DC_H__