GTK4_GG_hack/callback.c

#include <stdio.h>
#include <gtk-4.0/gtk/gtk.h>

#include "callback.h"
#include "tree.h"
#include "contain.h"
#include "dialog.h"
#include "texts.h"
#include "automaton.h"
#include "parsing.h"
#include "graph_area.h"

/******************************************************************************/
/*                    W I N D O W S    A C T I V A T I O N                    */
/******************************************************************************/

static GtkWindow *main_window, *dialog_window;

void on_main_window_activation (GtkApplication *app, gpointer no_user_data)
{
  main_window = GTK_WINDOW (gtk_application_window_new (app));
  main_window_design (main_window);
  g_signal_connect (app, "activate", G_CALLBACK (on_dialog_window_activation), main_window);
}

void on_dialog_window_activation (GtkApplication *app, gpointer no_user_data)
{
  dialog_window = GTK_WINDOW (gtk_application_window_new (app));
  dialog_window_design (main_window, dialog_window);
}


void on_auto_notification (const char *message)
{
  /*  Ignored  (2024-06-06)  because I don't know how to get "main_window" easily

    if (window->toast_revealer == NULL) {
        g_printerr("Can't find app->toast_overlay !\n");
        return;
    }

    if (window->toast_text == NULL) {
        g_printerr("Can't find app->toast_overlay !\n");
        return;
    }

    gtk_label_set_label(window->toast_text, message);
    gtk_revealer_set_reveal_child(window->toast_revealer, true);
  */
    g_printerr("%s\n", message);
}

/******************************************************************************/
/*                                T R E E                                     */
/******************************************************************************/
void on_user_tree_expander_toggled (GtkExpander *expander, gpointer user_data)
{
  GtkTreeListRow *row = GTK_TREE_LIST_ROW (user_data);
  gboolean is_expanded = gtk_tree_list_row_get_expanded(row);
  gtk_tree_list_row_set_expanded (row, !is_expanded);
}

void on_bind_user_tree_factory (GtkSignalListItemFactory *factory, GObject* object, gpointer user_data)
{
  GtkListItem *list_item = GTK_LIST_ITEM (object); assert (list_item);
  GtkTreeListRow *row = gtk_list_item_get_item (list_item); assert (row); // if (row != NULL) {...} ?
  const gchar *text = gtk_string_object_get_string (GTK_STRING_OBJECT (gtk_tree_list_row_get_item (row)));
  GtkWidget *expander = gtk_list_item_get_child (list_item);
  gtk_expander_set_label (GTK_EXPANDER (expander), text);
  g_signal_handlers_disconnect_by_func(expander, G_CALLBACK (on_user_tree_expander_toggled), row);
  g_signal_connect(expander, "activate", G_CALLBACK (on_user_tree_expander_toggled), row);
  gtk_widget_set_margin_start(expander, gtk_tree_list_row_get_depth(row) * 20);
}

/******************************************************************************/
/*                              G L  A R E A                                  */
/******************************************************************************/
gboolean on_glarea_render(GtkGLArea *area, GdkGLContext *context)
{
    // Check if the widget is a glarea
    if(gtk_gl_area_get_error(area) != NULL) {
//////////////////////////        on_auto_notification("An OpenGL error occured !");
        return false;
    }

//////////////////////////    if (ui_render_stack(gtk_widget_get_parent(GTK_WIDGET(area))) == false) {
//////////////////////////        on_auto_notification("Failed to render corresponding graphic stack !");
//////////////////////////        return false;
//////////////////////////    }

    return true;
}


/* We need to set up our state when we realize the GtkGLArea widget */
void on_glarea_realize(GtkWidget *widget)
{
    GError *internal_error = NULL;

    // Make the GL context current to be able to call the GL API
    gtk_gl_area_make_current(GTK_GL_AREA(widget));

    // Check if the widget is a glarea
    if(gtk_gl_area_get_error(GTK_GL_AREA(widget)) != NULL) {
        on_auto_notification("An OpenGL error occured !");
        return;
    }

    // Link graphical stack to widget
    if (ui_init_graphic_stack(gtk_widget_get_parent(widget),
                              internal_error) == false) {
        on_auto_notification(
            "Failed to link the graphic stack to widgets !");
        return;
    }

    gtk_gl_area_set_auto_render(GTK_GL_AREA(widget), true);
}

/* We should tear down the state when unrealizing */
void on_glarea_unrealize(GtkWidget *widget)
{
    GError *internal_error = NULL;

    // Make the GL context current to be able to call the GL API
    gtk_gl_area_make_current(GTK_GL_AREA(widget));

    // Check if the widget is a glarea
    if(gtk_gl_area_get_error(GTK_GL_AREA(widget)) != NULL) {
        on_auto_notification("An OpenGL error occured !");
        return;
    }

    // Destroy graphic stack
    if (ui_shutdown_graphic_stack(gtk_widget_get_parent(widget),
                                  internal_error) == false) {
        on_auto_notification(
            "Failed to shutdown the graphic stack !");
        return;
    }
}

void on_axis_value_change(GtkAdjustment *adjustment, gpointer data)
{

    GtkWidget *slider = gtk_widget_get_parent(GTK_WIDGET(data));
    GtkWidget *container_widget = gtk_widget_get_parent(GTK_WIDGET(slider));

    const gchar *label_text = gtk_label_get_label(GTK_LABEL(data));

    // THANKS ASCIIIII/Unicode/Whateverrr !
    int axis = label_text[0] - 'X';

    g_assert(axis >= 0 && axis < N_AXIS);

    /* Update the rotation angle */
    ui_update_axis_stack(container_widget,
                         axis,
                         gtk_adjustment_get_value(adjustment));

    /* Update the contents of the GL drawing area */
}



/******************************************************************************/
/*                             B U T T O N S                                  */
/******************************************************************************/
void on_toggle_model_exec (GtkWidget *btt_run_stop_model_exec, gpointer data) {}
void on_toggle_observ_interpret (GtkWidget *btt_toggle_observ_interpret, gpointer data) {}
void on_toggle_exec_edit (GtkWidget *btt_exec_xor_edit, GtkWidget *btt_run_stop_model_exec) {
//    gtk_button_set_icon_name (GTK_BUTTON (btt_exec_xor_edit), "power-profile-balanced-rtl-symbolic");
//    gtk_button_set_label (GTK_BUTTON (btt_run_stop_model_exec), " run ");
//    gtk_widget_set_sensitive (GTK_WIDGET (btt_run_stop_model_exec), TRUE);
}


void on_toggle_STATE_RULES_DATA (GtkButton *btt_toggle_STATE_RULES_DATA,
                                 GtkButton *btt_toggle_STATE_DATA_RULES)
{
  const char* current_label = gtk_button_get_label (GTK_BUTTON (btt_toggle_STATE_RULES_DATA));
  if (0) printf ("callback.c (line 182)  -  current_label = %s\n", current_label);

  if      (! strcmp (current_label, "analyse")) {
    gtk_button_set_label (btt_toggle_STATE_RULES_DATA, " state ");
    gtk_button_set_label (GTK_BUTTON (btt_toggle_STATE_DATA_RULES), " state ");
    window_main_child (main_window, 0);
  }
  else if (! strcmp (current_label, " state ")) {
    gtk_button_set_label (btt_toggle_STATE_RULES_DATA, " rules ");
    gtk_button_set_label (GTK_BUTTON (btt_toggle_STATE_DATA_RULES), " rules ");
    window_main_child (main_window, 1);
  }
       else {
    gtk_button_set_label (btt_toggle_STATE_RULES_DATA, "analyse");
    gtk_button_set_label (GTK_BUTTON (btt_toggle_STATE_DATA_RULES), "analyse");
    window_main_child (main_window, 2);
  }
}

void on_toggle_STATE_DATA_RULES (GtkButton *btt_toggle_STATE_RULES_DATA,
                                 GtkButton *btt_toggle_STATE_DATA_RULES)
{
  const char* current_label = gtk_button_get_label (GTK_BUTTON (btt_toggle_STATE_RULES_DATA));
  if (0) printf ("callback.c (line 205)  -  current_label = %s\n", current_label);

  if      (! strcmp (current_label, "analyse")) {
    gtk_button_set_label (btt_toggle_STATE_RULES_DATA, " state ");
    gtk_button_set_label (btt_toggle_STATE_DATA_RULES, " state ");
    window_main_child (main_window, 0);
  }
  else if (! strcmp (current_label, " rules ")) {
    gtk_button_set_label (btt_toggle_STATE_RULES_DATA, "analyse");
    gtk_button_set_label (btt_toggle_STATE_DATA_RULES, "analyse");
    window_main_child (main_window, 1);
  }
       else {
    gtk_button_set_label (btt_toggle_STATE_RULES_DATA, " rules ");
    gtk_button_set_label (btt_toggle_STATE_DATA_RULES, " rules ");
    window_main_child (main_window, 2);
  }
}

void on_SAVE_CURRENT_MODEL_BEFORE_EDITING (GtkWidget *btt_SAVE_CURRENT_MODEL, gpointer data) {
  gtk_widget_set_sensitive (GTK_WIDGET (data), TRUE);
  printf ("callback.c (line 201)  -  SAVE_CURRENT_MODEL_BEFORE_EDITING\n");
  SWITCH_TO (INTER);
}

void on_DISCARD_CURRENT_MODEL_AND_START_EDITING (GtkWidget *btt_SAVE_CURRENT_MODEL, gpointer data) {
  gtk_window_close (GTK_WINDOW (data));
  printf ("callback.c (line 206)  -  DISCARD_CURRENT_MODEL_AND_START_EDITING\n");
  SWITCH_TO (RULES);
}

void on_WRITE_CURRENT_MODEL (GtkWidget *btt_WRITE_CURRENT_MODEL, gpointer data) {
  gtk_window_close (GTK_WINDOW (data));
  printf ("callback.c (line 211)  -  WRITE_CURRENT_MODEL\n");
}