gtk_schoose2.c

Go to the documentation of this file.

/*
 
  $Id: gtk_schoose2.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
/* Single choice handling */
 
/* Difference with previous release:
 1/ schoose_close() must be called in order to close the schoose window.
 2/ schoose() has one more argument, because cancel button is created.
 bb 04.06.91
 */
/*
 * forked to gtk_schoose2.c
 * Edited by Johan GALL
 *
 */
 
#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 *choice_label, *choices_list, *ok_button, *help,
                *cancel_button;
static GtkListStore *choices;
 
enum {
        SC2_AVAILABLE_CHOICES_COLUMN_ID, SC2_COLUMNS_NUMBER
};
 
static void (* apply_on_choice)(const char *);
static void (* apply_on_cancel)(void);
 
#if 0
static void schoose_help_notify(GtkWidget * widget, gpointer data) {
        display_help("SingleChoice");
}
#endif
 
/* called when the "ok button" is clicked to validate an entry or when you select
 * something with the menu associated to the beforementionned entry. */
static void schoose_ok_notify(GtkWidget * widget, gpointer data) {
        GtkTreeIter iter;
        GtkTreeModel ** model = NULL;
        gchar * gc_choice;
 
        GtkTreeSelection * selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(
                        choices_list));
 
        if (!gtk_tree_selection_get_selected(selection, model, &iter)) {
                prompt_user("Choose one item or cancel");
                return;
        }
 
        //      gtk_tree_model_get(GTK_TREE_MODEL(*model), &iter,
        //                      SC2_AVAILABLE_CHOICES_COLUMN_ID, &gc_choice, -1);
 
        gc_choice = strdup(gtk_label_get_text(GTK_LABEL(choice_label)));
        // ----
 
        //      curchoice = strdup((char *) xv_get(choice, PANEL_VALUE, 0));
        //
        //      /* Modified to verify that an correct item is selected.
        //       RK, 21/05/1993. */
        //      nchoices = (int) xv_get(choices, PANEL_LIST_NROWS, 0);
        //      item_is_in_the_list = FALSE;
        //      for (i = 0; i < nchoices; i++)
        //              if (strcmp((char *) xv_get(choices, PANEL_LIST_STRING, i), curchoice)
        //                              == 0) {
        //                      item_is_in_the_list = TRUE;
        //                      break;
        //              }
        //      if (item_is_in_the_list == FALSE)
        //              prompt_user("You have to choose one item of the list!");
        //      else {
        //              /* Normal case : */
        (*apply_on_choice)(gc_choice);
        g_free(gc_choice);
        schoose_close();
}
 
/* schoose_close() can be called even when schoose window is already closed.
 */
void schoose_close() {
        hide_window(schoose_window, NULL, NULL);
        gtk_list_store_clear(choices);
        gtk_label_set_text(GTK_LABEL(choice_label), "");
}
 
void schoose_cancel_notify(GtkWidget * widget, gpointer data) {
        schoose_close();
        (*apply_on_cancel)();
}
 
/* Function used to update the text panel according to the list panel: */
static void schoose_choice_callback(GtkTreeSelection * selection, gpointer data) {
        GtkTreeIter iter;
        GtkTreeModel * model;
        gchar * gc_choice;
 
        //      if (!gtk_tree_selection_get_selected(selection, &model, &iter)) {
        //              pips_assert("schoose_choice_notify: no item selected !", 0);
        //              return;
        //      }
 
        if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
                gtk_tree_model_get(GTK_TREE_MODEL(model), &iter,
                                SC2_AVAILABLE_CHOICES_COLUMN_ID, &gc_choice, -1);
                gtk_label_set_text(GTK_LABEL(choice_label), gc_choice);
                g_free(gc_choice);
        }
}
 
/* Avoid the schoose_frame destruction and act as cancel: */
static void schoose_window_done_callback(GtkWidget * window, GdkEvent * ev,
                gpointer data) {
        (*apply_on_cancel)();
        hide_window(window, NULL, NULL);
}
 
void schoose(char * title, gen_array_t array, char * initial_choice,
                void(*function_for_ok)(const char *), void(*function_for_cancel)(void)) {
        guint i;
        string name;
        GtkTreeIter iter;
        GtkTreeSelection * selection;
        bool do_select = FALSE;
        int argc = gen_array_nitems(array);
 
        apply_on_choice = function_for_ok;
        apply_on_cancel = function_for_cancel;
 
        gtk_window_set_title(GTK_WINDOW(schoose_window), title);
        gtk_list_store_clear(choices);
 
        if (initial_choice != NULL) {
                do_select = TRUE;
                selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(choices_list));
        }
 
        for (i = 0; i < argc; i++) {
                name = gen_array_item(array, i);
                gtk_list_store_append(GTK_LIST_STORE(choices), &iter);
                gtk_list_store_set(choices, &iter, SC2_AVAILABLE_CHOICES_COLUMN_ID,
                                name, -1);
                if (do_select) // Initialise au choix initial ou default le premier
                        if (i == 0 || strcmp(initial_choice, name) == 0)
                                gtk_tree_selection_select_iter(GTK_TREE_SELECTION(selection),
                                                &iter);
        }
        gtk_widget_show(schoose_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(schoose_frame);
}
 
void create_schoose_window() {
        guint i;
        GtkWidget *window_vbox, *buttons_hbox, *current_choice_hbox;
        GtkTreeIter iter;
        GtkTreeSelection * selection;
 
        window_vbox = gtk_vbox_new(FALSE, 0);
        buttons_hbox = gtk_hbox_new(FALSE, 0);
        current_choice_hbox = gtk_hbox_new(FALSE, 0);
        gtk_box_pack_start(GTK_BOX(window_vbox), current_choice_hbox, FALSE, FALSE,
                        0);
        gtk_container_add(GTK_CONTAINER(schoose_window), window_vbox);
 
        gtk_box_pack_start(GTK_BOX(current_choice_hbox), gtk_label_new(
                        "Current choice : "), FALSE, FALSE, 0);
        choice_label = gtk_label_new("");
        gtk_box_pack_start(GTK_BOX(current_choice_hbox), choice_label, FALSE,
                        FALSE, 0);
 
        choices = gtk_list_store_new(SC2_COLUMNS_NUMBER, G_TYPE_STRING);
        for (i = 0; i < 5; i++) {
                gtk_list_store_append(GTK_LIST_STORE(choices), &iter);
                gtk_list_store_set(GTK_LIST_STORE(choices), &iter,
                                SC2_AVAILABLE_CHOICES_COLUMN_ID, "", -1);
                //gtk_tree_store_set(GTK_TREE_STORE(choices), &iter, SC2_AVAILABLE_CHOICES, "");
        }
 
        // the "graphical" choice component is the GtkTreeView * choices_list
        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", SC2_AVAILABLE_CHOICES_COLUMN_ID, NULL);
        gtk_tree_view_append_column(GTK_TREE_VIEW(choices_list), column);
 
        selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(choices_list));
        gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection),
                        GTK_SELECTION_SINGLE);
        g_signal_connect(selection, "changed", G_CALLBACK(schoose_choice_callback),
                        NULL);
 
        gtk_box_pack_start(GTK_BOX(window_vbox), choices_list, TRUE, FALSE, 0);
        gtk_widget_show(choices_list);
 
        ok_button = gtk_button_new_with_label("OK");
        g_signal_connect(GTK_OBJECT(ok_button), "clicked", G_CALLBACK(
                        schoose_ok_notify), NULL);
        gtk_box_pack_start(GTK_BOX(buttons_hbox), ok_button, FALSE, FALSE, 5);
 
        cancel_button = gtk_button_new_with_label("Cancel");
        g_signal_connect(GTK_OBJECT(cancel_button), "clicked", G_CALLBACK(
                        schoose_cancel_notify), NULL);
        gtk_box_pack_start(GTK_BOX(buttons_hbox), cancel_button, FALSE, FALSE, 5);
 
        help = gtk_button_new_with_label("Help");
        g_signal_connect(GTK_OBJECT(help), "clicked",
                        G_CALLBACK(schoose_ok_notify), NULL);
        gtk_box_pack_start(GTK_BOX(buttons_hbox), help, FALSE, FALSE, 5);
 
        gtk_box_pack_start(GTK_BOX(window_vbox), buttons_hbox, FALSE, FALSE, 5);
 
        gtk_window_set_default(GTK_WINDOW(schoose_window), ok_button);
 
        g_signal_connect(GTK_OBJECT(schoose_window), "delete_event", G_CALLBACK(
                        schoose_window_done_callback), NULL);
 
        gtk_widget_show_all(window_vbox);
}