gtk_mchoose.c

Go to the documentation of this file.

/*
 
  $Id: gtk_mchoose.c 23065 2016-03-02 09:05:50Z coelho $
 
  Copyright 1989-2016 MINES ParisTech
 
  This file is part of PIPS.
 
  PIPS is free software: you can redistribute it and/or modify it
  under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  any later version.
 
  PIPS 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 General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with PIPS.  If not, see <http://www.gnu.org/licenses/>.
 
*/
#ifdef HAVE_CONFIG_H
    #include "pips_config.h"
#endif
 
/* Multiple choices handling */
 
#include <stdio.h>
 
#include <sys/time.h>
#include <sys/resource.h>
 
#include "genC.h"
#include "misc.h"
 
#undef test_undefined // also defined in glib included from gtk
#include <gtk/gtk.h>
 
#include "gpips.h"
 
static GtkWidget *mchoices_label, *choices_list, *ok_button, *cancel_button,
                *help_button;
static GtkListStore *choices;
 
enum {
        M_AVAILABLE_CHOICES_COLUMN_ID, M_COLUMNS_NUMBER
};
 
static void (*apply_on_mchoices)( gen_array_t) = NULL;
static void (*cancel_on_mchoices)(void) = NULL;
 
#if 0
static void mchoose_help_notify(GtkWidget * widget __attribute__((unused)), gpointer data  __attribute__((unused))) {
        display_help("MultipleChoice");
}
#endif
 
static void mchoose_ok_notify(GtkWidget * widget  __attribute__((unused)), gpointer data  __attribute__((unused))) {
        gen_array_t mchoices_args = gen_array_make(0);
 
        GtkTreeSelection * selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(
                        choices_list));
 
        gchar *buffer, *mchoices_notify_buffer;
        int mchoices_length = 0;
//      int nchoices;
        int len;
//      int item_is_in_the_list = FALSE;
        char * p;
 
//      nchoices = (int) xv_get(choices, PANEL_LIST_NROWS, NULL);
 
        mchoices_notify_buffer = strdup(gtk_label_get_text(GTK_LABEL(mchoices_label)));
        /* Upperbound size for the scanf buffer: */
        buffer = (char *) malloc(strlen(mchoices_notify_buffer) + 1);
 
        p = mchoices_notify_buffer;
        while (sscanf(p, "%s%n", buffer, &len) == 1) {
                gen_array_dupaddto(mchoices_args, mchoices_length++, buffer);
//              item_is_in_the_list = FALSE;
//              for (int i = 0; i < nchoices; i++)
//                      if (strcmp((char *) xv_get(choices, PANEL_LIST_STRING, i), buffer)
//                                      == 0) {
//                              item_is_in_the_list = TRUE;
//                              break;
//                      }
//              if (item_is_in_the_list == FALSE)
//                      break;
                p += len;
        }
 
        g_free(mchoices_notify_buffer);
        g_free(buffer);
        //
        //      /*      At least on item selected, and in the list.
        //       RK, 21/05/1993.
        //       */
        //      if (mchoices_length == 0 || item_is_in_the_list == FALSE) {
        //              char *s;
        //              s = mchoices_length == 0 ? "You have to select at least 1 item!"
        //                              : "You have selected an item not in the choice list!";
        //              gen_array_full_free(mchoices_args);
        //              prompt_user(s);
        //              return;
        //      }
        if (gtk_tree_selection_count_selected_rows(selection) == 0) {
                prompt_user("You have to select at least 1 item !");
                return;
        }
 
        hide_window(mchoose_window, NULL, NULL);
 
        // ?
        //      xv_set(mchoices, PANEL_NOTIFY_PROC, NULL);
 
        (*apply_on_mchoices)(mchoices_args);
        gen_array_full_free(mchoices_args);
 
        /* Delay the graphics transformations. RK, 21/05/1993. */
 
        gtk_list_store_clear(choices);
 
        gtk_label_set_text(GTK_LABEL(mchoices_label), "");
}
 
static void mchoose_cancel_notify(GtkWidget * widget  __attribute__((unused)), gpointer data  __attribute__((unused))) {
        hide_window(mchoose_window, NULL, NULL);
 
        // The OK button becomes inactive through RETURN:
        gtk_window_set_default(GTK_WINDOW(mchoose_window), NULL);
 
        // ?
        //xv_set(mchoices, PANEL_NOTIFY_PROC, NULL);
 
        (*cancel_on_mchoices)();
 
        gtk_list_store_clear(choices);
 
        gtk_label_set_text(GTK_LABEL(mchoices_label), "");
}
 
/* Avoid the mchoose_frame destruction and act as cancel: */
static void mchoose_window_done_proc(GtkWidget * window  __attribute__((unused)), gpointer data  __attribute__((unused))) {
        mchoose_cancel_notify(NULL, NULL);
}
 
static void concat_labels(gpointer _row, gpointer _label) {
        GtkTreePath * path = (GtkTreePath *) _row;
        gchar ** label = (gchar **) _label;
        gchar * new_label;
 
        GValue path_associated_value = { 0, };
        GtkTreeIter iter;
        gtk_tree_model_get_iter(GTK_TREE_MODEL(choices), &iter, path);
        gtk_tree_model_get_value(GTK_TREE_MODEL(choices), &iter,
                        M_AVAILABLE_CHOICES_COLUMN_ID, &path_associated_value);
        gchar * path_associated_value_string = (gchar *) g_value_get_string(
                        &path_associated_value);
 
        new_label = strdup(concatenate(*label, path_associated_value_string, " ",
                        NULL));
        g_free(*label);
        *label = new_label;
}
 
/* Function used to update the text panel according to the list panel: */
//int static mchoose_notify(Panel_item item, char * item_string,
//              Xv_opaque client_data, Panel_list_op op, Event * event, int row) {
static void mchoose_callback(GtkTreeSelection * selection, gpointer data  __attribute__((unused))) {
        GList * selected_rows;
        gchar * new_mchoices_label;
 
        selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(choices_list));
        new_mchoices_label = strdup("");
 
        /* Make the PANEL_VALUE of mchoices a string that is all the
         names of the selected files: */
        selected_rows = gtk_tree_selection_get_selected_rows(GTK_TREE_SELECTION(
                        selection), (GtkTreeModel**)&choices);
 
        g_list_foreach(selected_rows, concat_labels, &new_mchoices_label);
        g_list_free(selected_rows);
 
        gtk_label_set_text(GTK_LABEL(mchoices_label), new_mchoices_label);
        g_free(new_mchoices_label);
}
 
/* When we press on the "(De)Select" all button, select or deselect
 all the items. */
static void mchoose_de_select_all_notify(GtkWidget * widget  __attribute__((unused)), gpointer data  __attribute__((unused))) {
        GtkTreeSelection * selection;
 
        selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(choices_list));
 
        static bool select_all_when_press_this_button = TRUE;
 
        if (select_all_when_press_this_button) {
                gtk_tree_selection_select_all(GTK_TREE_SELECTION(selection));
        } else {
                gtk_tree_selection_unselect_all(GTK_TREE_SELECTION(selection));
        }
 
        /* Update the "Current choices": */
        mchoose_callback(selection, NULL);
 
        /* Next time we press this button, do the opposite: */
        select_all_when_press_this_button = !select_all_when_press_this_button;
}
 
void mchoose(char * title, gen_array_t array, void(*function_ok)( gen_array_t),
                void(*function_cancel)(void)) {
        int i, argc = gen_array_nitems(array);
 
        GtkTreeIter iter;
        gen_array_nitems(array);
 
        apply_on_mchoices = function_ok;
        cancel_on_mchoices = function_cancel;
 
        gtk_window_set_title(GTK_WINDOW(mchoose_window), title);
        gtk_list_store_clear(choices);
 
        for (i = 0; i < argc; i++) {
                string name = gen_array_item(array, i);
                gtk_list_store_append(GTK_LIST_STORE(choices), &iter);
                gtk_list_store_set(choices, &iter, M_AVAILABLE_CHOICES_COLUMN_ID, name,
                                -1);
        }
        gtk_widget_show(mchoose_window);
 
        /* move the pointer to the center of the query window */
        // Sans vouloir remettre en question le design de la chose
        // A priori je ne traduirai pas ça à moins qu'on ne le
        // demande expressément...
        //pointer_in_center_of_frame(mchoose_frame);
        //?
        //      xv_set(mchoices, PANEL_NOTIFY_PROC, mchoose_ok_notify, NULL);
}
 
void create_mchoose_window() {
        guint i;
        GtkWidget *vbox, *buttons_hbox;
        GtkTreeIter iter;
        GtkTreeSelection * _select;
        GtkWidget *deselect_button;
 
        GtkWidget * scrolled_window;
        scrolled_window = gtk_scrolled_window_new(NULL, NULL);
        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
                        GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
 
        vbox = gtk_vbox_new(FALSE, 0);
        buttons_hbox = gtk_hbox_new(FALSE, 0);
        gtk_container_add(GTK_CONTAINER(mchoose_window), vbox);
 
        //      mchoose_panel = xv_create(mchoose_frame, PANEL, NULL);
 
 
        //      mchoices = xv_create(mchoose_panel, PANEL_TEXT, PANEL_LABEL_STRING,
        //                      "Current choices", PANEL_VALUE_DISPLAY_LENGTH, 30,
        //                      PANEL_VALUE_STORED_LENGTH, 12800,
        //                      /* PANEL_NOTIFY_PROC, mchoose_ok_notify, */
        //                      XV_X, xv_col(mchoose_panel, 0), NULL);
        gtk_box_pack_start(GTK_BOX(vbox), gtk_label_new("Current choices : "),
                        FALSE, FALSE, 0);
        mchoices_label = gtk_label_new("");
        gtk_box_pack_start(GTK_BOX(vbox), mchoices_label, FALSE, FALSE, 0);
        gtk_widget_show(mchoices_label);
 
        mchoose_frame = gtk_frame_new("test");
 
        //      choices = xv_create(mchoose_panel, PANEL_LIST, PANEL_LABEL_STRING,
        //                      "Available choices", PANEL_LIST_DISPLAY_ROWS, 5, PANEL_NOTIFY_PROC,
        //                      mchoose_notify, PANEL_CHOOSE_ONE, FALSE, XV_X, xv_col(
        //                                      mchoose_panel, 0), XV_Y, xv_rows(mchoose_panel, 1), NULL);
        choices = gtk_list_store_new(M_COLUMNS_NUMBER, G_TYPE_STRING);
        for (i = 0; i < 5; i++) {
                gtk_list_store_append(GTK_LIST_STORE(choices), &iter);
                gtk_list_store_set(choices, &iter, M_AVAILABLE_CHOICES_COLUMN_ID, "",
                                -1);
        }
 
        choices_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(choices));
        GtkCellRenderer * renderer = gtk_cell_renderer_text_new();
        GtkTreeViewColumn * column;
        column = gtk_tree_view_column_new_with_attributes("Available choices",
                        renderer, "text", M_AVAILABLE_CHOICES_COLUMN_ID, NULL);
        gtk_tree_view_append_column(GTK_TREE_VIEW(choices_list), column);
 
        _select = gtk_tree_view_get_selection(GTK_TREE_VIEW(choices_list));
        gtk_tree_selection_set_mode(GTK_TREE_SELECTION(_select),
                        GTK_SELECTION_MULTIPLE);
        g_signal_connect(_select, "changed", G_CALLBACK(mchoose_callback), NULL);
 
        gtk_container_add(GTK_CONTAINER(scrolled_window), choices_list);
        gtk_container_add(GTK_CONTAINER(mchoose_frame), scrolled_window);
        gtk_box_pack_start(GTK_BOX(vbox), mchoose_frame, TRUE, TRUE, 5);
        //      gtk_box_pack_start(GTK_BOX(window_vbox), choices_list, FALSE, FALSE, 0);
        gtk_widget_show(choices_list);
 
        //      ok = xv_create(mchoose_panel, PANEL_BUTTON, PANEL_LABEL_STRING, "OK",
        //                      PANEL_NOTIFY_PROC, mchoose_ok_notify, XV_X,
        //                      xv_col(mchoose_panel, 5), XV_Y, xv_rows(mchoose_panel, 5), NULL);
        ok_button = gtk_button_new_with_label("OK");
        gtk_signal_connect(GTK_OBJECT(ok_button), "clicked", GTK_SIGNAL_FUNC(
                        mchoose_ok_notify), NULL);
        gtk_box_pack_start(GTK_BOX(buttons_hbox), ok_button, FALSE, FALSE, 5);
 
        //      (void) xv_create(mchoose_panel, PANEL_BUTTON, PANEL_LABEL_STRING,
        //                      "(De)Select all", PANEL_NOTIFY_PROC, mchoose_de_select_all_notify,
        //                      NULL);
        deselect_button = gtk_button_new_with_label("(De)Select all");
        gtk_signal_connect(GTK_OBJECT(deselect_button), "clicked", GTK_SIGNAL_FUNC(
                        mchoose_de_select_all_notify), NULL);
        gtk_box_pack_start(GTK_BOX(buttons_hbox), deselect_button, FALSE, FALSE, 5);
 
        //      cancel = xv_create(mchoose_panel, PANEL_BUTTON, PANEL_LABEL_STRING,
        //                      "Cancel", PANEL_NOTIFY_PROC, mchoose_cancel_notify, NULL);
        cancel_button = gtk_button_new_with_label("Cancel");
        gtk_signal_connect(GTK_OBJECT(cancel_button), "clicked", GTK_SIGNAL_FUNC(
                        mchoose_cancel_notify), NULL);
        gtk_box_pack_start(GTK_BOX(buttons_hbox), cancel_button, FALSE, FALSE, 5);
 
        //      help = xv_create(mchoose_panel, PANEL_BUTTON, PANEL_LABEL_STRING, "Help",
        //                      PANEL_NOTIFY_PROC, mchoose_help_notify, NULL);
        help_button = gtk_button_new_with_label("Help");
        gtk_signal_connect(GTK_OBJECT(help_button), "clicked", GTK_SIGNAL_FUNC(
                        mchoose_ok_notify), NULL);
        gtk_box_pack_start(GTK_BOX(buttons_hbox), help_button, FALSE, FALSE, 5);
 
        gtk_box_pack_start(GTK_BOX(vbox), buttons_hbox, FALSE, FALSE, 5);
        //      xv_set(mchoose_frame, FRAME_DONE_PROC, mchoose_frame_done_proc, NULL);
        gtk_window_set_default(GTK_WINDOW(mchoose_window), ok_button);
 
        gtk_signal_connect(GTK_OBJECT(mchoose_window), "delete-event",
                        GTK_SIGNAL_FUNC(mchoose_window_done_proc), NULL);
 
        gtk_widget_show_all(vbox);
}