application.hpp

/*
 * Copyright 2019-2024 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, 
 * Sebastian Lievano Arzayus and Vaughn Betz
 */
 
#ifndef EZGL_APPLICATION_HPP
#define EZGL_APPLICATION_HPP
 
#include "ezgl/canvas.hpp"
#include "ezgl/control.hpp"
#include "ezgl/callback.hpp"
#include "ezgl/graphics.hpp"
#include "ezgl/color.hpp"
 
#include <map>
#include <memory>
#include <string>
#include <ctime>
#include <vector>
 
#include <gtk/gtk.h>
 
namespace ezgl {
 
// A flag to specify whether the GUI is built from an XML file or an XML resource
#ifndef ECE297
const bool build_ui_from_file = false;
#else
const bool build_ui_from_file = true;
#endif
 
class application;
 
using connect_g_objects_fn = void (*)(application *app);
 
using setup_callback_fn = void (*)(application *app, bool new_window);
 
using button_callback_fn = void (*)(GtkWidget *widget, application *app);
 
using mouse_callback_fn = void (*)(application *app, GdkEventButton *event, double x, double y);
 
using key_callback_fn = void (*)(application *app, GdkEventKey *event, char *key_name);
 
using combo_box_callback_fn = void (*)(GtkComboBoxText* self, application* app);
 
using dialog_callback_fn = void (*)(GtkDialog* self, gint response_id, application* app);
 
class application {
public:
  struct settings {
    std::string main_ui_resource;
 
    std::string window_identifier;
 
    std::string canvas_identifier;
 
    std::string application_identifier;
 
    connect_g_objects_fn setup_callbacks;
 
    settings()
    : main_ui_resource(build_ui_from_file ? "main_ui" : "/ezgl/main.ui"), window_identifier("MainWindow"), canvas_identifier("MainCanvas"), application_identifier("ezgl.app"),
      setup_callbacks(nullptr)
    {
      // Uniquify the application_identifier by appending a time stamp,
      // so that each instance of the same program has a different application ID.
      // This allows multiple instances of the program to run independelty.
      application_identifier += ".t" + std::to_string(std::time(nullptr));
    }
 
    settings(std::string m_resource, std::string w_identifier, std::string c_identifier, std::string a_identifier = "ezgl.app",
        connect_g_objects_fn s_callbacks = nullptr)
    : main_ui_resource(m_resource), window_identifier(w_identifier), canvas_identifier(c_identifier), application_identifier(a_identifier),
      setup_callbacks(s_callbacks)
    {
      // Uniquify the application_identifier by appending a time stamp,
      // so that each instance of the same program has a different application ID.
      // This allows multiple instance of the program to run independelty.
      application_identifier += ".t" + std::to_string(std::time(nullptr));
    }
  };
 
public:
  explicit application(application::settings s);
 
  canvas *add_canvas(std::string const &canvas_id,
      draw_canvas_fn draw_callback,
      rectangle coordinate_system,
      color background_color = WHITE);
 
  void create_button(const char *button_text,
      int left,
      int top,
      int width,
      int height,
      button_callback_fn button_func);
 
  void create_button(const char *button_text, int insert_row, button_callback_fn button_func);
 
  bool destroy_button(const char *button_text_to_destroy);
 
 
  void change_button_text(const char *button_text, const char *new_button_text);
 
 
  void create_label(int insert_row, const char *label_text);
 
  void create_label(
    int left,
    int top,
    int width,
    int height,
    const char *label_text
  );
 
  void create_combo_box_text(
    const char* id_string,
    int insert_row, 
    combo_box_callback_fn combo_box_fn, 
    std::vector<std::string> options);
 
  void create_combo_box_text(
    const char* id_string,
    int left,
    int top,
    int width,
    int height,
    combo_box_callback_fn combo_box_fn, 
    std::vector<std::string> options);
 
  void change_combo_box_text_options(const char* name, std::vector<std::string> new_options);
 
  void create_dialog_window(dialog_callback_fn cbk_fn, const char* dialog_title, const char *window_text);
 
  void create_popup_message(const char* title, const char *message);
 
  void create_popup_message_with_callback(dialog_callback_fn cbk_fn, const char* title, const char *message);
 
  bool destroy_widget(const char* widget_name);
 
  GtkWidget* find_widget(const char* widget_name);
 
  void update_message(std::string const &message);
 
  void change_canvas_world_coordinates(std::string const &canvas_id, rectangle coordinate_system);
 
  void refresh_drawing();
 
  renderer *get_renderer();
 
  void flush_drawing();
 
  int run(setup_callback_fn initial_setup_user_callback,
      mouse_callback_fn mouse_press_user_callback,
      mouse_callback_fn mouse_move_user_callback,
      key_callback_fn key_press_user_callback);
 
  ~application();
 
  application(application const &) = delete;
 
  application &operator=(application const &) = delete;
 
  application(application &&) = default;
 
  application &operator=(application &&) = default;
 
  canvas *get_canvas(std::string const &canvas_id) const;
 
  GObject *get_object(gchar const *name) const;
 
  std::string get_main_window_id() const
  {
    return m_window_id;
  }
 
  std::string get_main_canvas_id() const
  {
    return m_canvas_id;
  }
 
  void quit();
 
private:
  // The package path to the XML file that describes the UI.
  std::string m_main_ui;
 
  // The ID of the main window to add to our GTK application.
  std::string m_window_id;
 
  // The ID of the main canvas. This canvas is where ezgl renderer calls (e.g. draw_line) display
  std::string m_canvas_id;
 
  // The ID of the GTK application
  std::string m_application_id;
 
  // The GTK application.
  GtkApplication *m_application;
 
  // The GUI builder that parses an XML user interface.
  GtkBuilder *m_builder;
 
  // The function to call when the application is starting up.
  connect_g_objects_fn m_register_callbacks;
 
  // The collection of canvases added to the application.
  std::map<std::string, std::unique_ptr<canvas>> m_canvases;
 
  // A flag that indicates if the run() was called before or not to allow multiple reruns
  bool first_run;
 
  // A flag that indicates if we are resuming an older run to allow proper quitting
  bool resume_run;
 
private:
  // Called when our GtkApplication is initialized for the first time.
  static void startup(GtkApplication *gtk_app, gpointer user_data);
 
  // Called when GTK activates our application for the first time.
  static void activate(GtkApplication *gtk_app, gpointer user_data);
 
  // Called during application activation to setup the default callbacks for the prebuilt buttons
  static void register_default_buttons_callbacks(application *application);
 
  // Called during application activation to setup the default callbacks for the mouse and key events
  static void register_default_events_callbacks(application *application);
 
public:
  // The user-defined initial setup callback function
  setup_callback_fn initial_setup_callback;
 
  // The user-defined callback function for handling mouse press
  mouse_callback_fn mouse_press_callback;
 
  // The user-defined callback function for handling mouse move
  mouse_callback_fn mouse_move_callback;
 
  // The user-defined callback function for handling keyboard press
  key_callback_fn key_press_callback;
};
 
void set_disable_event_loop(bool new_setting);
}
 
#endif //EZGL_APPLICATION_HPP