libs/EXTERNAL/libezgl/include/ezgl/graphics.hpp - third_party/vtr-verilog-to-routing - Git at Google

 /*
  * Copyright 2019 University of Toronto
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  * Authors: Mario Badr, Sameh Attia and Tanner Young-Schultz
  */

 #ifndef EZGL_GRAPHICS_HPP
 #define EZGL_GRAPHICS_HPP

 #include "ezgl/color.hpp"
 #include "ezgl/point.hpp"
 #include "ezgl/rectangle.hpp"
 #include "ezgl/camera.hpp"

 #include <cairo.h>
 #include <gdk/gdk.h>

 #ifdef CAIRO_HAS_XLIB_SURFACE
 #ifdef GDK_WINDOWING_X11
 #include <cairo-xlib.h>

 // Speed up draw calls by using X11 instead of cairo wherever possible.
 #define EZGL_USE_X11
 #endif
 #endif

 #include <functional>
 #include <string>
 #include <vector>
 #include <cfloat>
 #include <cmath>
 #include <algorithm>

 namespace ezgl {

 /**
  * define ezgl::surface type used for drawing pngs
  */
 typedef cairo_surface_t surface;

 /**
  * Available coordinate systems
  */
 enum t_coordinate_system {
   /**
    * Default coordinate system
    */
   WORLD,
   /**
    * Screen coordinate system. Screen Coordinates are not transformed so the drawn objects do not pan or zoom.
    */
   SCREEN
 };

 /**
  * Text justification options
  */
 enum class text_just {
   /**
    * Center Justification: used for both vertical and horizontal justification
    */
   center,
   /**
    * Left justification: used for horizontal justification
    */
   left,
   /**
    * Right justification: used for horizontal justification
    */
   right,
   /**
    * Top justification: used for vertical justification
    */
   top,
   /**
    * Bottom justification: used for vertical justification
    */
   bottom
 };

 /**
  * The slant of the font.
  *
  * This enum is setup to match with the cairo graphics library and should not be changed.
  */
 enum class font_slant : int {
   /**
    * No slant.
    */
   normal = CAIRO_FONT_SLANT_NORMAL,

   /**
    * Slant is more calligraphic. Make sure the font you're using has an italic design, otherwise it may look ugly.
    */
   italic = CAIRO_FONT_SLANT_ITALIC,

   /**
    * Slanted to the right.
    */
   oblique = CAIRO_FONT_SLANT_OBLIQUE
 };

 /**
  * The weight of the font.
  */
 enum class font_weight : int {
   /**
    * No additional weight.
    */
   normal = CAIRO_FONT_WEIGHT_NORMAL,

   /**
    * Bold font weight.
    */
   bold = CAIRO_FONT_WEIGHT_BOLD
 };

 /**
  * The shape of a line's start and end point.
  */
 enum class line_cap : int {
   /**
    * Start and stop the line exactly where it begins/ends.
    */
   butt = CAIRO_LINE_CAP_BUTT,

   /**
    * Each end of the line has circles.
    */
   round = CAIRO_LINE_CAP_ROUND
 };

 /**
  * The dash style of a line.
  */
 enum class line_dash : int {
   /**
    * No dashes in the line (i.e., solid).
    */
   none,

   /**
    * Dash to whitespace ratio is 5:3.
    */
   asymmetric_5_3
 };

 /**
  * Provides functions to draw primitives (e.g., lines, shapes) to a rendering context.
  *
  * The renderer modifies a cairo_t context based on draw calls. The renderer uses an ezgl::camera object to convert
  * world coordinates into cairo's expected coordinate system.
  */
 class renderer {
 public:
   /**
    * Change the current coordinate system
    *
    * @param new_coordinate_system The drawing coordinate system SCREEN or WORLD
    */
   void set_coordinate_system(t_coordinate_system new_coordinate_system);

   /**
    * Set the visible bounds of the world
    *
    * The function preserves the aspect ratio of the initial world
    *
    * @param new_world The new visible bounds of the world
    */
   void set_visible_world(rectangle new_world);

   /**
    * Get the current visible bounds of the world
    */
   rectangle get_visible_world();

   /**
    * Get the current visible bounds of the screen
    */
   rectangle get_visible_screen();

   /**
    * Get the screen coordinates (i.e. pixel locations) of the world coordinate rectangle box
    *
    * @param box: a rectangle in world coordinates
    */
   rectangle world_to_screen(const rectangle& box);

   /**** Functions to set graphics attributes (for all subsequent drawing calls). ****/

   /**
    * Change the color for subsequent draw calls.
    *
    * @param new_color The new color to use.
    */
   void set_color(color new_color);

   /**
    * Change the color for subsequent draw calls.
    *
    * @param new_color The new color to use.
    * @param alpha Overwrite the alpha channel in the chosen color.
    */
   void set_color(color new_color, uint_fast8_t alpha);

   /**
    * Change the color for subsequent draw calls.
    *
    * @param red The amount of red to use, between 0 and 255.
    * @param green The amount of green to use, between 0 and 255.
    * @param blue The amount of blue to use, between 0 and 255.
    * @param alpha The transparency level (0 is fully transparent, 255 is opaque).
    */
   void set_color(uint_fast8_t red, uint_fast8_t green, uint_fast8_t blue, uint_fast8_t alpha = 255);

   /**
    * Change how line endpoints will be rendered in subsequent draw calls.
    */
   void set_line_cap(line_cap cap);

   /**
    * Change the dash style of the line.
    */
   void set_line_dash(line_dash dash);

   /**
    * Set the line width.
    *
    * @param width The width in pixels.
    * A value of 0 is still one pixel wide but about 100x faster
    * to draw than other line widths.
    */
   void set_line_width(int width);

   /**
    * Change the font size.
    *
    * @param new_size The new size text should be drawn at.
    */
   void set_font_size(double new_size);

   /**
    * Change the font.
    *
    * @param family The font family to use (e.g., serif)
    * @param slant The slant to use (e.g., italic)
    * @param weight The weight of the font (e.g., bold)
    */
   void format_font(std::string const &family, font_slant slant, font_weight weight);

   /**
    * Change the font.
    *
    * @param family The font family to use (e.g., serif)
    * @param slant The slant to use (e.g., italic)
    * @param weight The weight of the font (e.g., bold)
    * @param new_size The new size text should be drawn at.
    */
   void
   format_font(std::string const &family, font_slant slant, font_weight weight, double new_size);

   /**
    * set the rotation_angle variable that is used in rotating text.
    *
    * @param degrees The angle by which the text should rotate, in degrees.
    */
   void set_text_rotation(double degrees);

   /**
    * set horizontal text justification.
    *
    * @param horiz_just Options: center, left and right justification.
    */
   void set_horiz_text_just(text_just horiz_just);

   /**
    * set vertical text justification.
    *
    * @param vert_just Options: center, top and bottom justification.
    */
   void set_vert_text_just(text_just vert_just);

   /**** Functions to draw various graphics primitives ****/

   /**
    * Draw a line.
    *
    * @param start The start point of the line, in pixels.
    * @param end The end point of the line, in pixels.
    */
   void draw_line(point2d start, point2d end);

   /**
    * Draw the outline a rectangle.
    *
    * @param start The start point of the rectangle, in pixels.
    * @param end The end point of the rectangle, in pixels.
    */
   void draw_rectangle(point2d start, point2d end);

   /**
    * Draw the outline of a rectangle.
    *
    * @param start The start point of the rectangle, in pixels.
    * @param width How wide the rectangle is, in pixels.
    * @param height How high the rectangle is, in pixels.
    */
   void draw_rectangle(point2d start, double width, double height);

   /**
    * Draw the outline of a rectangle.
    */
   void draw_rectangle(rectangle r);

   /**
    * Draw a filled in rectangle.
    *
    * @param start The start point of the rectangle, in pixels.
    * @param end The end point of the rectangle, in pixels.
    */
   void fill_rectangle(point2d start, point2d end);

   /**
    * Draw a filled in rectangle.
    *
    * @param start The start point of the rectangle, in pixels.
    * @param width How wide the rectangle is, in pixels.
    * @param height How high the rectangle is, in pixels.
    */
   void fill_rectangle(point2d start, double width, double height);

   /**
    * Draw a filled in rectangle.
    */
   void fill_rectangle(rectangle r);

   /**
    * Draw a filled polygon.
    *
    * @param points The points to draw. The first and last points are connected to close the polygon.
    */
   void fill_poly(std::vector<point2d> const &points);

   /**
    * Draw the outline of an elliptic arc.
    *
    * @param center The center of the arc, in pixels.
    * @param radius_x The x radius of the elliptic arc, in pixels.
    * @param radius_y The y radius of the elliptic arc, in pixels.
    * @param start_angle The starting angle of the arc, in degrees.
    * @param extent_angle The extent angle of the arc, in degrees.
    */
   void draw_elliptic_arc(point2d center,
       double radius_x,
       double radius_y,
       double start_angle,
       double extent_angle);

   /**
    * Draw the outline of an arc.
    *
    * @param center The center of the arc, in pixels.
    * @param radius The radius of the arc, in pixels.
    * @param start_angle The starting angle of the arc, in degrees.
    * @param extent_angle The extent angle of the arc, in degrees.
    */
   void draw_arc(point2d center, double radius, double start_angle, double extent_angle);

   /**
    * Draw a filled in elliptic arc.
    *
    * @param center The center of the arc, in pixels.
    * @param radius_x The x radius of the elliptic arc, in pixels.
    * @param radius_y The y radius of the elliptic arc, in pixels.
    * @param start_angle The starting angle of the arc, in degrees.
    * @param extent_angle The extent angle of the arc, in degrees.
    */
   void fill_elliptic_arc(point2d center,
       double radius_x,
       double radius_y,
       double start_angle,
       double extent_angle);

   /**
    * Draw a filled in arc.
    *
    * @param center The center of the arc, in pixels.
    * @param radius The radius of the arc, in pixels.
    * @param start_angle The starting angle of the arc, in degrees.
    * @param extent_angle The extent angle of the arc, in degrees.
    */
   void fill_arc(point2d center, double radius, double start_angle, double extent_angle);

   /**
    * Draw text.
    *
    * @param point The point where the text is drawn, in pixels.
    * @param text The text to draw.
    */
   void draw_text(point2d point, std::string const &text);

   /**
    * Draw text with bounds.
    *
    * @param point The point where the text is drawn, in pixels.
    * @param text The text to draw.
    * @param bound_x The maximum allowed width of the text
    * @param bound_y The maximum allowed height of the text
    */
   void draw_text(point2d point, std::string const &text, double bound_x, double bound_y);

   /**
    * Draw a surface
    *
    * @param surface The surface to draw
    * @param top_left The corner point of the drawn surface.
    */
   void draw_surface(surface *surface, point2d top_left);

   /**
    * load a png image
    *
    * @param file_path The path to the png image.
    *
    * @return a pointer to the created surface. Should be freed using free_surface()
    */
   static surface *load_png(const char *file_path);

   /**
    * Free a surface
    *
    * @param surface The surface to destroy
    */
   static void free_surface(surface *surface);

   /**
    * Destructor.
    */
   ~renderer();

 protected:
   // Only the canvas class can create a renderer.
   friend class canvas;

   /**
    * A callback for transforming points from one coordinate system to another.
    */
   using transform_fn = std::function<point2d(point2d)>;

   /**
    * Constructor.
    *
    * @param cairo The cairo graphics state.
    * @param transform The function to use to transform points to cairo's coordinate system.
    */
   renderer(cairo_t *cairo, transform_fn transform, camera *m_camera, cairo_surface_t *m_surface);

   /**
    * Update the renderer when the cairo surface/context changes
    *
    * @param cairo The new cairo graphics state
    * @param m_surface The new cairo surface
    */
   void update_renderer(cairo_t *cairo, cairo_surface_t *m_surface);

 private:
   void draw_rectangle_path(point2d start, point2d end, bool fill_flag);

   void draw_arc_path(point2d center,
       double radius,
       double start_angle,
       double extent_angle,
       double stretch_factor,
       bool fill_flag);

   // Pre-clipping function
   bool rectangle_off_screen(rectangle rect);

   // Current coordinate system (World is the default)
   t_coordinate_system current_coordinate_system = WORLD;

   // A non-owning pointer to a cairo graphics context.
   cairo_t *m_cairo;

 #ifdef EZGL_USE_X11
   // The x11 drawable
   Drawable x11_drawable;

   // The x11 display
   Display *x11_display = nullptr;

   // The x11 context
   GC x11_context;

   // Transparency flag, if set, cairo will be used
   bool transparency_flag = false;
 #endif

   transform_fn m_transform;

   //A non-owning pointer to camera object
   camera *m_camera;

   // the rotation angle variable used in rotating text
   double rotation_angle;

   // Current horizontal text justification
   text_just horiz_text_just = text_just::center;

   // Current vertical text justification
   text_just vert_text_just = text_just::center;

   // Current line width
   int current_line_width = 1;

   // Current line cap
   line_cap current_line_cap = line_cap::butt;

   // Current line dash
   line_dash current_line_dash = line_dash::none;

   // Current color
   color current_color = {0, 0, 0, 255};
 };
 }

 #endif //EZGL_GRAPHICS_HPP
	/*
	* Copyright 2019 University of Toronto
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	* Authors: Mario Badr, Sameh Attia and Tanner Young-Schultz
	*/

	#ifndef EZGL_GRAPHICS_HPP
	#define EZGL_GRAPHICS_HPP

	#include "ezgl/color.hpp"
	#include "ezgl/point.hpp"
	#include "ezgl/rectangle.hpp"
	#include "ezgl/camera.hpp"

	#include <cairo.h>
	#include <gdk/gdk.h>

	#ifdef CAIRO_HAS_XLIB_SURFACE
	#ifdef GDK_WINDOWING_X11
	#include <cairo-xlib.h>

	// Speed up draw calls by using X11 instead of cairo wherever possible.
	#define EZGL_USE_X11
	#endif
	#endif

	#include <functional>
	#include <string>
	#include <vector>
	#include <cfloat>
	#include <cmath>
	#include <algorithm>

	namespace ezgl {

	/**
	* define ezgl::surface type used for drawing pngs
	*/
	typedef cairo_surface_t surface;

	/**
	* Available coordinate systems
	*/
	enum t_coordinate_system {
	/**
	* Default coordinate system
	*/
	WORLD,
	/**
	* Screen coordinate system. Screen Coordinates are not transformed so the drawn objects do not pan or zoom.
	*/
	SCREEN
	};

	/**
	* Text justification options
	*/
	enum class text_just {
	/**
	* Center Justification: used for both vertical and horizontal justification
	*/
	center,
	/**
	* Left justification: used for horizontal justification
	*/
	left,
	/**
	* Right justification: used for horizontal justification
	*/
	right,
	/**
	* Top justification: used for vertical justification
	*/
	top,
	/**
	* Bottom justification: used for vertical justification
	*/
	bottom
	};

	/**
	* The slant of the font.
	*
	* This enum is setup to match with the cairo graphics library and should not be changed.
	*/
	enum class font_slant : int {
	/**
	* No slant.
	*/
	normal = CAIRO_FONT_SLANT_NORMAL,

	/**
	* Slant is more calligraphic. Make sure the font you're using has an italic design, otherwise it may look ugly.
	*/
	italic = CAIRO_FONT_SLANT_ITALIC,

	/**
	* Slanted to the right.
	*/
	oblique = CAIRO_FONT_SLANT_OBLIQUE
	};

	/**
	* The weight of the font.
	*/
	enum class font_weight : int {
	/**
	* No additional weight.
	*/
	normal = CAIRO_FONT_WEIGHT_NORMAL,

	/**
	* Bold font weight.
	*/
	bold = CAIRO_FONT_WEIGHT_BOLD
	};

	/**
	* The shape of a line's start and end point.
	*/
	enum class line_cap : int {
	/**
	* Start and stop the line exactly where it begins/ends.
	*/
	butt = CAIRO_LINE_CAP_BUTT,

	/**
	* Each end of the line has circles.
	*/
	round = CAIRO_LINE_CAP_ROUND
	};

	/**
	* The dash style of a line.
	*/
	enum class line_dash : int {
	/**
	* No dashes in the line (i.e., solid).
	*/
	none,

	/**
	* Dash to whitespace ratio is 5:3.
	*/
	asymmetric_5_3
	};

	/**
	* Provides functions to draw primitives (e.g., lines, shapes) to a rendering context.
	*
	* The renderer modifies a cairo_t context based on draw calls. The renderer uses an ezgl::camera object to convert
	* world coordinates into cairo's expected coordinate system.
	*/
	class renderer {
	public:
	/**
	* Change the current coordinate system
	*
	* @param new_coordinate_system The drawing coordinate system SCREEN or WORLD
	*/
	void set_coordinate_system(t_coordinate_system new_coordinate_system);

	/**
	* Set the visible bounds of the world
	*
	* The function preserves the aspect ratio of the initial world
	*
	* @param new_world The new visible bounds of the world
	*/
	void set_visible_world(rectangle new_world);

	/**
	* Get the current visible bounds of the world
	*/
	rectangle get_visible_world();

	/**
	* Get the current visible bounds of the screen
	*/
	rectangle get_visible_screen();

	/**
	* Get the screen coordinates (i.e. pixel locations) of the world coordinate rectangle box
	*
	* @param box: a rectangle in world coordinates
	*/
	rectangle world_to_screen(const rectangle& box);

	/** Functions to set graphics attributes (for all subsequent drawing calls). **/

	/**
	* Change the color for subsequent draw calls.
	*
	* @param new_color The new color to use.
	*/
	void set_color(color new_color);

	/**
	* Change the color for subsequent draw calls.
	*
	* @param new_color The new color to use.
	* @param alpha Overwrite the alpha channel in the chosen color.
	*/
	void set_color(color new_color, uint_fast8_t alpha);

	/**
	* Change the color for subsequent draw calls.
	*
	* @param red The amount of red to use, between 0 and 255.
	* @param green The amount of green to use, between 0 and 255.
	* @param blue The amount of blue to use, between 0 and 255.
	* @param alpha The transparency level (0 is fully transparent, 255 is opaque).
	*/
	void set_color(uint_fast8_t red, uint_fast8_t green, uint_fast8_t blue, uint_fast8_t alpha = 255);

	/**
	* Change how line endpoints will be rendered in subsequent draw calls.
	*/
	void set_line_cap(line_cap cap);

	/**
	* Change the dash style of the line.
	*/
	void set_line_dash(line_dash dash);

	/**
	* Set the line width.
	*
	* @param width The width in pixels.
	* A value of 0 is still one pixel wide but about 100x faster
	* to draw than other line widths.
	*/
	void set_line_width(int width);

	/**
	* Change the font size.
	*
	* @param new_size The new size text should be drawn at.
	*/
	void set_font_size(double new_size);

	/**
	* Change the font.
	*
	* @param family The font family to use (e.g., serif)
	* @param slant The slant to use (e.g., italic)
	* @param weight The weight of the font (e.g., bold)
	*/
	void format_font(std::string const &family, font_slant slant, font_weight weight);

	/**
	* Change the font.
	*
	* @param family The font family to use (e.g., serif)
	* @param slant The slant to use (e.g., italic)
	* @param weight The weight of the font (e.g., bold)
	* @param new_size The new size text should be drawn at.
	*/
	void
	format_font(std::string const &family, font_slant slant, font_weight weight, double new_size);

	/**
	* set the rotation_angle variable that is used in rotating text.
	*
	* @param degrees The angle by which the text should rotate, in degrees.
	*/
	void set_text_rotation(double degrees);

	/**
	* set horizontal text justification.
	*
	* @param horiz_just Options: center, left and right justification.
	*/
	void set_horiz_text_just(text_just horiz_just);

	/**
	* set vertical text justification.
	*
	* @param vert_just Options: center, top and bottom justification.
	*/
	void set_vert_text_just(text_just vert_just);

	/** Functions to draw various graphics primitives **/

	/**
	* Draw a line.
	*
	* @param start The start point of the line, in pixels.
	* @param end The end point of the line, in pixels.
	*/
	void draw_line(point2d start, point2d end);

	/**
	* Draw the outline a rectangle.
	*
	* @param start The start point of the rectangle, in pixels.
	* @param end The end point of the rectangle, in pixels.
	*/
	void draw_rectangle(point2d start, point2d end);

	/**
	* Draw the outline of a rectangle.
	*
	* @param start The start point of the rectangle, in pixels.
	* @param width How wide the rectangle is, in pixels.
	* @param height How high the rectangle is, in pixels.
	*/
	void draw_rectangle(point2d start, double width, double height);

	/**
	* Draw the outline of a rectangle.
	*/
	void draw_rectangle(rectangle r);

	/**
	* Draw a filled in rectangle.
	*
	* @param start The start point of the rectangle, in pixels.
	* @param end The end point of the rectangle, in pixels.
	*/
	void fill_rectangle(point2d start, point2d end);

	/**
	* Draw a filled in rectangle.
	*
	* @param start The start point of the rectangle, in pixels.
	* @param width How wide the rectangle is, in pixels.
	* @param height How high the rectangle is, in pixels.
	*/
	void fill_rectangle(point2d start, double width, double height);

	/**
	* Draw a filled in rectangle.
	*/
	void fill_rectangle(rectangle r);

	/**
	* Draw a filled polygon.
	*
	* @param points The points to draw. The first and last points are connected to close the polygon.
	*/
	void fill_poly(std::vector<point2d> const &points);

	/**
	* Draw the outline of an elliptic arc.
	*
	* @param center The center of the arc, in pixels.
	* @param radius_x The x radius of the elliptic arc, in pixels.
	* @param radius_y The y radius of the elliptic arc, in pixels.
	* @param start_angle The starting angle of the arc, in degrees.
	* @param extent_angle The extent angle of the arc, in degrees.
	*/
	void draw_elliptic_arc(point2d center,
	double radius_x,
	double radius_y,
	double start_angle,
	double extent_angle);

	/**
	* Draw the outline of an arc.
	*
	* @param center The center of the arc, in pixels.
	* @param radius The radius of the arc, in pixels.
	* @param start_angle The starting angle of the arc, in degrees.
	* @param extent_angle The extent angle of the arc, in degrees.
	*/
	void draw_arc(point2d center, double radius, double start_angle, double extent_angle);

	/**
	* Draw a filled in elliptic arc.
	*
	* @param center The center of the arc, in pixels.
	* @param radius_x The x radius of the elliptic arc, in pixels.
	* @param radius_y The y radius of the elliptic arc, in pixels.
	* @param start_angle The starting angle of the arc, in degrees.
	* @param extent_angle The extent angle of the arc, in degrees.
	*/
	void fill_elliptic_arc(point2d center,
	double radius_x,
	double radius_y,
	double start_angle,
	double extent_angle);

	/**
	* Draw a filled in arc.
	*
	* @param center The center of the arc, in pixels.
	* @param radius The radius of the arc, in pixels.
	* @param start_angle The starting angle of the arc, in degrees.
	* @param extent_angle The extent angle of the arc, in degrees.
	*/
	void fill_arc(point2d center, double radius, double start_angle, double extent_angle);

	/**
	* Draw text.
	*
	* @param point The point where the text is drawn, in pixels.
	* @param text The text to draw.
	*/
	void draw_text(point2d point, std::string const &text);

	/**
	* Draw text with bounds.
	*
	* @param point The point where the text is drawn, in pixels.
	* @param text The text to draw.
	* @param bound_x The maximum allowed width of the text
	* @param bound_y The maximum allowed height of the text
	*/
	void draw_text(point2d point, std::string const &text, double bound_x, double bound_y);

	/**
	* Draw a surface
	*
	* @param surface The surface to draw
	* @param top_left The corner point of the drawn surface.
	*/
	void draw_surface(surface *surface, point2d top_left);

	/**
	* load a png image
	*
	* @param file_path The path to the png image.
	*
	* @return a pointer to the created surface. Should be freed using free_surface()
	*/
	static surface load_png(const char file_path);

	/**
	* Free a surface
	*
	* @param surface The surface to destroy
	*/
	static void free_surface(surface *surface);

	/**
	* Destructor.
	*/
	~renderer();

	protected:
	// Only the canvas class can create a renderer.
	friend class canvas;

	/**
	* A callback for transforming points from one coordinate system to another.
	*/
	using transform_fn = std::function<point2d(point2d)>;

	/**
	* Constructor.
	*
	* @param cairo The cairo graphics state.
	* @param transform The function to use to transform points to cairo's coordinate system.
	*/
	renderer(cairo_t cairo, transform_fn transform, camera m_camera, cairo_surface_t *m_surface);

	/**
	* Update the renderer when the cairo surface/context changes
	*
	* @param cairo The new cairo graphics state
	* @param m_surface The new cairo surface
	*/
	void update_renderer(cairo_t cairo, cairo_surface_t m_surface);

	private:
	void draw_rectangle_path(point2d start, point2d end, bool fill_flag);

	void draw_arc_path(point2d center,
	double radius,
	double start_angle,
	double extent_angle,
	double stretch_factor,
	bool fill_flag);

	// Pre-clipping function
	bool rectangle_off_screen(rectangle rect);

	// Current coordinate system (World is the default)
	t_coordinate_system current_coordinate_system = WORLD;

	// A non-owning pointer to a cairo graphics context.
	cairo_t *m_cairo;

	#ifdef EZGL_USE_X11
	// The x11 drawable
	Drawable x11_drawable;

	// The x11 display
	Display *x11_display = nullptr;

	// The x11 context
	GC x11_context;

	// Transparency flag, if set, cairo will be used
	bool transparency_flag = false;
	#endif

	transform_fn m_transform;

	//A non-owning pointer to camera object
	camera *m_camera;

	// the rotation angle variable used in rotating text
	double rotation_angle;

	// Current horizontal text justification
	text_just horiz_text_just = text_just::center;

	// Current vertical text justification
	text_just vert_text_just = text_just::center;

	// Current line width
	int current_line_width = 1;

	// Current line cap
	line_cap current_line_cap = line_cap::butt;

	// Current line dash
	line_dash current_line_dash = line_dash::none;

	// Current color
	color current_color = {0, 0, 0, 255};
	};
	}

	#endif //EZGL_GRAPHICS_HPP