canvas.hpp

/*
 * Copyright 2019-2022 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, Tanner Young-Schultz and Vaughn Betz
 */
 
#ifndef EZGL_CANVAS_HPP
#define EZGL_CANVAS_HPP
 
#include "ezgl/camera.hpp"
#include "ezgl/rectangle.hpp"
#include "ezgl/graphics.hpp"
#include "ezgl/color.hpp"
 
#include <cairo.h>
#include <cairo-pdf.h>
#include <cairo-svg.h>
#include <gtk/gtk.h>
 
#include <string>
 
namespace ezgl {
 
/**** Functions in this class are for ezgl internal use; application code doesn't need to call them ****/
 
class renderer;
 
using draw_canvas_fn = void (*)(renderer*);
 
class canvas {
public:
  ~canvas();
 
  char const *id() const
  {
    return m_canvas_id.c_str();
  }
 
  int width() const;
 
  int height() const;
 
  void redraw();
 
  camera const &get_camera() const
  {
    return m_camera;
  }
 
  camera &get_camera()
  {
    return m_camera;
  }
 
  renderer *create_animation_renderer();
  
  bool print_pdf(const char *file_name, int width = 0, int height = 0);
  bool print_svg(const char *file_name, int width = 0, int height = 0);
  bool print_png(const char *file_name, int width = 0, int height = 0);
  
  
protected:
  // Only the ezgl::application can create and initialize a canvas object.
  friend class application;
 
  canvas(std::string canvas_id, draw_canvas_fn draw_callback, rectangle coordinate_system, color background_color);
 
  void initialize(GtkWidget *drawing_area);
 
private:
  // Name of the canvas in XML.
  std::string m_canvas_id;
 
  // The function to call when the widget needs to be redrawn.
  draw_canvas_fn m_draw_callback;
 
  // The transformations between the GUI and the world.
  camera m_camera;
 
  // The background color of the drawing area
  color m_background_color;
 
  // A non-owning pointer to the drawing area inside a GTK window.
  GtkWidget *m_drawing_area = nullptr;
 
  // The off-screen surface that can be drawn to.
  cairo_surface_t *m_surface = nullptr;
 
  // The off-screen cairo context that can be drawn to
  cairo_t *m_context = nullptr;
 
  // The animation renderer
  renderer *m_animation_renderer = nullptr;
 
private:
  // Called each time our drawing area widget has changed (e.g., in size).
  static gboolean configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer data);
 
  // Called each time we need to draw to our drawing area widget.
  static gboolean draw_surface(GtkWidget *widget, cairo_t *context, gpointer data);
};
}
 
#endif //EZGL_CANVAS_HPP