BackendSVG.hpp

Go to the documentation of this file.

/*
Copyright (c) 2018, University of Oxford.
All rights reserved.

University of Oxford means the Chancellor, Masters and Scholars of the
University of Oxford, having an administrative office at Wellington
Square, Oxford OX1 2JD, UK.

This file is part of trase.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the names of its
  contributors may be used to endorse or promote products derived from
  this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/


#ifndef BACKENDSVG_H_
#define BACKENDSVG_H_

#include "backend/Backend.hpp"
#include "util/BBox.hpp"
#include "util/Colors.hpp"
#include "util/Exception.hpp"
#include "util/Vector.hpp"

#include <iomanip>
#include <ostream>
#include <sstream>

namespace trase {

class AttributeFormatter {
  std::stringstream m_ss;
  int m_precision = 4;

public:
  AttributeFormatter() { m_ss << std::setprecision(m_precision); }

  template <typename T>
  std::string operator()(const std::string &name, const T val) {
    m_ss.str("");
    m_ss << name << "=\"" << val << "\" ";
    return m_ss.str();
  }
};

class BackendSVG : public AnimatedBackend {
  std::ostream &m_out;

  std::string m_linewidth;
  std::string m_line_color;
  std::string m_fill_color;
  std::string m_path;
  std::string m_font_face;
  std::string m_font_size;
  std::string m_font_align;
  std::string m_web_font;
  std::string m_onmouseover_stroke;
  std::string m_onmouseout_stroke;
  std::string m_onmouseover_fill;
  std::string m_onmouseout_fill;
  std::string m_onmouseover_tooltip;
  std::string m_onmouseout_tooltip;
  std::vector<std::string> m_animate_values;
  std::string m_animate_stroke;
  std::string m_animate_stroke_opacity;
  std::string m_animate_fill;
  std::string m_animate_fill_opacity;
  std::string m_animate_times;
  float m_time_span;
  std::string m_font_size_base;
  std::string m_font_face_base;
  TransformMatrix m_transform;
  AttributeFormatter m_att;

  void circle_begin(const vfloat2_t &centre, float r) noexcept;

  void circle_end() noexcept;

  void rect_begin(const bfloat2_t &x, float r) noexcept;

  void rect_end() noexcept;

  bool mouseover() const noexcept;

public:
  explicit BackendSVG(std::ostream &out);

  TRASE_BACKEND_VISITABLE()
  TRASE_ANIMATED_BACKEND_VISITABLE()

  
  void init(const vfloat2_t &pixels, const char *name,
            float time_span = 0.f) noexcept;

  void finalise() noexcept;

  bool is_interactive();

  bool should_close();

  vfloat2_t begin_frame();

  void end_frame();

  vfloat2_t get_mouse_pos();

  float get_time();

  static void set_mouse_down(const vfloat2_t &mouse_pos);

  static void set_mouse_up();

  bool mouse_dragging();

  vfloat2_t mouse_drag_delta();

  void mouse_drag_reset_delta();

  void scissor(const bfloat2_t &x);

  void reset_scissor();

  void rotate(const float angle);

  void reset_transform();

  void translate(const vfloat2_t &v);

  void begin_path();

  void move_to(const vfloat2_t &x);

  void line_to(const vfloat2_t &x);

  void close_path();

  void stroke();

  void fill();

  void begin_animated_path();

  void add_animated_path(const float time);

  void end_animated_path(const float time);

  void rounded_rect(const bfloat2_t &x, float r) noexcept;

  void rect(const bfloat2_t &x, float r = 0.f) noexcept;

  void add_animated_rect(const bfloat2_t &x, float time);

  void add_animated_stroke(const RGBA &color);

  void add_animated_fill(const RGBA &color);

  void end_animated_rect();

  void circle(const vfloat2_t &centre, float r) noexcept;

  void add_animated_circle(const vfloat2_t &centre, float radius, float time);

  void end_animated_circle();

  void circle_with_text(const vfloat2_t &centre, float radius,
                        const char *string);

  void arc(const vfloat2_t &centre, const float radius, const float angle0,
           const float angle1);

  void stroke_color(const RGBA &color);

  void stroke_color(const RGBA &color, const RGBA &color_mouseover);

  void tooltip(const vfloat2_t &x, const char *string);

  void clear_tooltip();

  void stroke_width(const float lw);

  void fill_color(const RGBA &color);

  void fill_color(const RGBA &color, const RGBA &color_mouseover);

  void font_size(float size);

  void font_face(const char *face);

  void import_web_font(const std::string &url);

  void font_blur(const float blur);

  void text_align(const unsigned int align);

  void text(const vfloat2_t &x, const char *string, const char *end);

private:
  void end_animate(std::string &animate, const std::string &name);
  void end_animate_stroke();
  void end_animate_fill();
  void shape_styling();
};

} // namespace trase

#endif // BACKENDSVG_H_