gem-graph-client/src/calls.c

/*  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *
*                                                                              *
*                             Gem-graph client                                 *
*                                                                              *
*                              Callbacks header                                *
*                                                                              *
*         Copyright © 2021 Libre en Communs <contact@a-lec.org>                *
*         Copyright © 2021 Adrien Bourmault <neox@a-lec.org>                   *
*         Copyright © 2021 Jean Sirmai <jean@a-lec.org>                        *
*                                                                              *
*                        This file is part of Gem-graph.                       *
*                                                                              *
*   This program is free software: you can redistribute it and/or modify it    *
*         under the terms of the GNU Affero General Public License             *
*                as published by the Free Software Foundation,                 *
*                       either version 3 of the License,                       *
*                    or (at your option) any later version.                    *
*                                                                              *
*       This program is distributed in the hope that it will be useful,        *
*                         but WITHOUT ANY WARRANTY;                            *
*            without even the implied warranty of MERCHANTABILITY              *
*                    or FITNESS FOR A PARTICULAR PURPOSE.                      *
*         See the GNU Affero General Public License for more details.          *
*                                                                              *
*   You should have received a copy of the GNU Affero General Public License   *
*     along with this program.  If not, see <http://www.gnu.org/licenses/>.    *
*                                                                              *
*  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  */



#include "../include/automat.h"
#include "../include/calls.h"
#include "../include/widgets.h"
#include "../include/graph.h"


static 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);
}



/******************************************************************************/
/*                                 W I N D O W S                              */
/******************************************************************************/

void on_windows_activation (GtkApplication *app,
                            gpointer no_user_data)
{
  widget_head_set_MAIN_WINDOW (app);
  widget_head_MAIN_WINDOW_design (widget_head_get_MAIN_WINDOW());

  widget_head_set_DIALOG_WINDOW (app);
  widget_head_DIALOG_WINDOW_design (widget_head_get_MAIN_WINDOW(), widget_head_get_DIALOG_WINDOW());

  widget_head_set_TEXT_WINDOW (app);
  widget_head_TEXT_WINDOW_design (widget_head_get_MAIN_WINDOW(), widget_head_get_TEXT_WINDOW());
}


/******************************************************************************/
/*                                T R E E                                     */
/******************************************************************************/

static 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) {...}  do something ?  TODO  Check !

  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);
}

void on_setup_user_tree_factory (GtkSignalListItemFactory *factory,
                                 GObject* object, gpointer user_data){
    GtkWidget* expander = gtk_expander_new (NULL);
    gtk_list_item_set_child (GTK_LIST_ITEM (object), expander);
    if (0) printf("[on_setup_user_tree_factory] here is an expander\n");
}


/******************************************************************************/
/*                              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 (graph_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 (graph_init_graph_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 (graph_shutdown_graph_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 */
    graph_update_axis_stack(container_widget,
                         axis,
                         gtk_adjustment_get_value(adjustment));

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


/******************************************************************************/
/*                       D I A L O G    W I D G E T S                         */
/******************************************************************************/

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  -  SAVE_CURRENT_MODEL_BEFORE_EDITING\n");
}

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

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



/******************************************************************************/
/*                         S T A T E    W I D G E T                           */
/******************************************************************************/

static void switch_STATE_RULES_DATA()
{
    switch (get_STATE_RULES_DATA()) {

    case (STATE) :
      gtk_window_set_child (widget_head_get_MAIN_WINDOW(),
                            GTK_WIDGET (get_STATE_page()));
      break;

    case (RULES) :
      gtk_window_set_child (widget_head_get_MAIN_WINDOW(),
                            GTK_WIDGET (get_RULES_page()));
      break;

    case (DATA)  :
      gtk_window_set_child (widget_head_get_MAIN_WINDOW(),
                            GTK_WIDGET (get_STOCK_page()));
      break;

    default :
      printf("default in callback.on_toggle_STATE_RULES_DATA()\n");
  }
}

void on_toggle_EXEC_EDIT (GtkWidget *toggled_button, gpointer user_data)
{
  if (get_EXEC_EDIT ()) {

    gtk_button_set_icon_name (GTK_BUTTON (toggled_button),
                              "power-profile-balanced-rtl-symbolic");
    set_EXEC_EDIT (EXEC);

  } else {

    gtk_button_set_icon_name (GTK_BUTTON (toggled_button),
                              "text-editor-symbolic");

    //  https://docs.gtk.org/gtk4/class.Window.html    TODO   2024-06-30
    //  gtk_window_present (GTK_WINDOW (widget_head_get_DIALOG_WINDOW()));   //   works once only !

    set_EXEC_EDIT (EDIT);
  }

  switch_STATE_RULES_DATA();
}

void on_toggle_STATE_RULES_DATA (GtkWidget *toggled_button, gpointer user_data)
{
  const char *toggled_button_name
                = gtk_check_button_get_label  (GTK_CHECK_BUTTON (toggled_button));
  int is_active = gtk_check_button_get_active (GTK_CHECK_BUTTON (toggled_button));

  if (! strcmp (toggled_button_name, "state")) {
    set_STATE_RULES_DATA (STATE);
  }

  if (! strcmp (toggled_button_name, "rules")) {
    set_STATE_RULES_DATA (RULES);
  }

  if (! strcmp (toggled_button_name, "data analysis")) {
    set_STATE_RULES_DATA (DATA);
  }

  if (is_active) {
    switch_STATE_RULES_DATA();
  }
}


void on_OBJECTS_box_RESET_VALUE (GtkAdjustment *adjustment, gpointer data)
{
  printf ("callback.on_OBJECTS_box_DO_RESET()   %f\n",\
           gtk_adjustment_get_value (adjustment));
}

void on_SITUATIONS_box_RESET_VALUE (GtkAdjustment *adjustment, gpointer data) {}


void on_OBJECTS_box_DO_RESET (GtkWidget *btt_reset, gpointer data)
{
  printf ("callback.on_OBJECTS_box_DO_RESET()\
   <>   Comment remettre tous les curseurs à une même valeur ?\n\
  NB  Cette valeur sera la valeur choisie au moyen du curseur situé à gauche du bouton 'RESET'\n\
      et elle sera lue par l'un des sous-automates qui déterminent l'état de la page 'ÉTAT'\n\
      et reportée dans le module 'automat'.\n");
  //  utiliser  gpointer data  pour transmettre la valeur choisie  TODO

  set_OBJECTS_box_RESET_VALUE (1);
}

void on_SITUATIONS_box_DO_RESET (GtkWidget *btt_reset, gpointer data)
{
    set_SITUATIONS_box_RESET_VALUE (1);
}


/******************************************************************************/
/*            M A I N   W I N D O W   H E A D E R   W I D G E T S             */
/******************************************************************************/


void on_clicked_search (GtkWidget *btt_menu, gpointer list_box) {
  // next line presents the text_window and works only once.\nIt should present a menu.\n");  //  TODO
  gtk_window_present (GTK_WINDOW (widget_head_get_TEXT_WINDOW()));
}

void on_clicked_HOME (GtkWidget *btt_reset, gpointer data)
{
  printf ("callback.on_clicked_HOME() button presents the dialog_window\
  ( :- )  but it works only once.\n");   //    TODO
  gtk_window_present (GTK_WINDOW (widget_head_get_DIALOG_WINDOW()));
}

























/******************************************************************************/
/*                                M E N U                                     */
/******************************************************************************/

void on_clicked_menu_experiment (GtkWidget *btt_menu, gpointer list_box) {
  printf ("callback.on_clicked_MENU() button  >  %p  < &list_box  >   children nb > 3\n", list_box);

//  gpointer list_box = gtk_popover_get_child (GTK_POPOVER (pop));

/*
  if (gtk_list_box_get_row_at_index (list_box, 3))
       printf ("callback.on_clicked_MENU() button  >  %p  < &list_box  >   children nb > 3\n", list_box);
  else printf ("callback.on_clicked_MENU() button  >   in list_box are the three buttons :  %s, %s, %s\n\
          and now : how to display these three buttons (and make use of them) ?   2024-07-13  (20h)\n",\
          gtk_button_get_label (GTK_BUTTON (gtk_list_box_row_get_child (gtk_list_box_get_row_at_index (list_box, 0)))),
          gtk_button_get_label (GTK_BUTTON (gtk_list_box_row_get_child (gtk_list_box_get_row_at_index (list_box, 1)))),
          gtk_button_get_label (GTK_BUTTON (gtk_list_box_row_get_child (gtk_list_box_get_row_at_index (list_box, 2)))));

  // learning_how_to_create_a_menu (menu_button);
  // https://docs.gtk.org/gtk4/class.ListBox.html
*/
}





































/******************************************************************************/
/*                          M E N U   (from TREE)                             */
/******************************************************************************/

static void on_user_menu_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);
  const gchar *text = gtk_string_object_get_string (
                      GTK_STRING_OBJECT (gtk_tree_list_row_get_item (row)));
  if (1) printf("[on_user_menu_expander_toggled]  >  %s\n", text);
}


void on_bind_user_menu_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) {...}  do something ?  TODO  Check !

  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_menu_expander_toggled),
                                        row);
  g_signal_connect (expander,
                    "activate",
                    G_CALLBACK (on_user_menu_expander_toggled),
                    row);
  gtk_widget_set_margin_start (expander,
                               gtk_tree_list_row_get_depth(row) * 20);
}

void on_setup_user_menu_factory (GtkSignalListItemFactory *factory,
                                 GObject* object, gpointer user_data){
    GtkWidget* expander = gtk_expander_new (NULL);
    gtk_list_item_set_child (GTK_LIST_ITEM (object), expander);
    if (0) printf("[on_setup_user_menu_factory] here is an expander\n");
}