gtk_props.c

Go to the documentation of this file.

/*
 
  $Id: gtk_props.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
 
#ifndef lint
char vcid_xv_props[] = "$Id: gtk_props.c 23065 2016-03-02 09:05:50Z coelho $";
#endif /* lint */
 
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#include <sys/time.h>
#include <sys/resource.h>
 
#include "genC.h"
#include "linear.h"
#include "ri.h"
#include "top-level.h"
#include "database.h"
 
#include "misc.h"
#include "ri-util.h"
#include "pipsdbm.h"
#include "pipsmake.h"
#include "complexity_ri.h"
 
#include "constants.h"
#include "resources.h"
#include "properties.h"
 
#undef test_undefined // also defined in glib included from gtk
#include <gtk/gtk.h>
#include "gpips.h"
 
typedef struct {
        char *name;
        list choices;
} option_type;
 
static GtkWidget * smenu_options;
static GtkWidget * options_menu, *options_menu_item;
static GtkWidget * options_frame_menu_item;
GtkWidget * options_frame;
 
static hash_table aliases;
static hash_table menu_item_to_combo_box;
 
static char display_options_panel[] = "Options panel...";
static char hide_options_panel[] = "Hide options panel";
 
enum {
        BSIZE_HERE = 256
};
 
typedef struct {
        const char * label; // label en court de traitement ds le frame option
        int position; // position du dit label dans la vbox du frame option
        GtkWidget * vbox; // Vbox du frame options
} LabelAndVbox;
 
/* Flag allowing update_options also to select a option : */
int verbose_update_options = 1;
 
/* returns the first key which value is svp. when not found, returns NULL */
string hash_get_key_by_value(hash_table htp, string svp) {
        HASH_MAP(kp, vp, {
                                if (strcmp(vp, svp) == 0)
                                return kp;
                        }, htp);
 
        return HASH_UNDEFINED_VALUE;
}
 
void apply_on_each_options_menu_item(GtkWidget * widget, gpointer _func) {
        void (*func)(GtkWidget *);
        func = (void(*)(GtkWidget *)) _func;
        const char * label;
        label = gpips_gtk_menu_item_get_label(widget);
        if (label == NULL || strcmp(label, display_options_panel) == 0 || strcmp(
                        label, hide_options_panel) == 0)
                return;
        func(widget);
}
 
void apply_on_each_options_frame_choice(GtkWidget * widget, gpointer _func) {
        void (*func)(GtkWidget *);
        func = (void(*)(GtkWidget *)) _func;
        if (GTK_IS_COMBO_BOX(widget))
                func(widget);
}
 
void apply_on_each_option_item(void(* function_to_apply_on_each_menu_item)(
                GtkWidget *), void(* function_to_apply_on_each_frame_choice)(
                GtkWidget *)) {
        /* Walk through items of options_menu */
        gtk_container_foreach(GTK_CONTAINER(options_menu), (GtkCallback)
                        apply_on_each_options_menu_item,
                        function_to_apply_on_each_menu_item);
 
        /* Now walk through the options frame: */
        gtk_container_foreach(GTK_CONTAINER(options_frame), (GtkCallback)
                        apply_on_each_options_frame_choice,
                        function_to_apply_on_each_frame_choice);
}
 
void disable_option_selection() {
        apply_on_each_option_item(disable_item, disable_item);
}
 
void enable_option_selection() {
        apply_on_each_option_item(enable_item, enable_item);
}
 
void update_options() {
        gint i, j;
        const char * child_resource_alias;
        const char * phase_alias_n;
        string res_true_n, phase_true_n;
        GtkWidget * menu_options, *special_prop_menu;
        GtkWidget *spm_item;
 
        debug_on("GPIPS_DEBUG_LEVEL");
 
        menu_options = smenu_options;
 
        /* walk through items of menu_options */
        GtkWidget * child;
        GList * menu_options_children = gtk_container_get_children(GTK_CONTAINER(
                        menu_options));
        for (i = 0; i < g_list_length(menu_options_children); i++) {
                child = (GtkWidget *) g_list_nth_data(menu_options_children, i);
                if (!GTK_IS_MENU_ITEM(child))
                        continue;
                if (GTK_IS_SEPARATOR(child))
                        continue;
 
                child_resource_alias = gpips_gtk_menu_item_get_label(child);
                if (child_resource_alias == NULL || strcmp(child_resource_alias,
                                display_options_panel) == 0 || strcmp(child_resource_alias,
                                hide_options_panel) == 0)
                        /* It must be the pin item, or the item controlling the
                         options panel. RK, 4/06/1993. */
                        continue;
 
                if ((res_true_n = (string) hash_get(aliases, child_resource_alias))
                                == HASH_UNDEFINED_VALUE)
                        pips_internal_error("Hash table aliases no more consistent\n");
                // -------------
 
                /* find special prop menu containing item corresponding to active
                 phase*/
                special_prop_menu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(child));
                //                      (Menu) xv_get(child, MENU_PULLRIGHT);
 
                GList * spm_children = gtk_container_get_children(GTK_CONTAINER(
                                special_prop_menu));
                /* find active phase which produces resource res_true_n */
                phase_true_n = rule_phase(find_rule_by_resource(res_true_n));
                if ((phase_alias_n = hash_get_key_by_value(aliases, phase_true_n))
                                == HASH_UNDEFINED_VALUE) {
                        /* There is no alias for currently selected phase: phase_true_n
                         We have to activate another phase
                         */
                        gtk_menu_set_active(GTK_MENU(special_prop_menu), 0);
                        spm_item = (GtkWidget *) g_list_nth_data(spm_children, 0);
                        phase_alias_n = gpips_gtk_menu_item_get_label(spm_item);
                        user_warning(
                                        "update_options",
                                        "No alias available for selected phase `%s'; selecting `%s'\n",
                                        phase_true_n, phase_alias_n);
                        phase_true_n = hash_get(aliases, phase_alias_n);
                        activate(phase_true_n);
                        //                      /* It does not seem to work (the doc does not talk about
                        //                       xv_set for MENU_SELECTED by the way...): */
                        //                      xv_set(special_prop_menu_item, MENU_SELECTED, TRUE, NULL);
                        //                      /* Then, try harder : */
                        //                      xv_set(special_prop_menu, MENU_DEFAULT_ITEM,
                        //                                      special_prop_menu_item, NULL);
                        debug(2, "update_options",
                                        "Rule `%s' selected to produce resource `%s'\n",
                                        phase_alias_n, child_resource_alias);
                } else {
                        /* walk through items of special_prop_m to select the activated
                         one */
                        for (j = g_list_length(spm_children) - 1; j >= 0; j--) {
                                const char * spm_item_label;
                                spm_item = (GtkWidget *) g_list_nth_data(spm_children, j);
                                if (!GTK_IS_MENU_ITEM(spm_item))
                                        continue;
                                if (GTK_IS_SEPARATOR(spm_item))
                                        continue;
                                spm_item_label = gpips_gtk_menu_item_get_label(spm_item);
                                debug(9, "update_options", "Menu item tested:\"%s\"\n",
                                                spm_item_label);
                                if (strcmp(spm_item_label, phase_alias_n) == 0) {
                                        gtk_menu_set_active(GTK_MENU(special_prop_menu), j);
                                        /* Update the dual options panel entry : */
                                        GtkWidget * combobox = hash_get(menu_item_to_combo_box,
                                                        special_prop_menu);
                                        if (GTK_IS_COMBO_BOX(combobox))
                                                gtk_combo_box_set_active(GTK_COMBO_BOX(combobox), j);
 
                                        if (verbose_update_options)
                                                user_log("Options: phase %s set on.\n", phase_alias_n);
                                        debug(2, "update_options",
                                                        "Rule `%s' selected to produce resource `%s'\n",
                                                        phase_alias_n, child_resource_alias);
                                }
                        }
                }
                g_list_free(spm_children);
        }
        g_list_free(menu_options_children);
        display_memory_usage();
 
        debug_off();
}
 
void options_select(const char * aliased_phase) {
        string phase = hash_get(aliases, aliased_phase);
 
        if (phase == (string) HASH_UNDEFINED_VALUE) {
                pips_internal_error("aliases badly managed !!!\n");
        } else {
                if (!db_get_current_workspace_name()) {
                        prompt_user("No workspace opened. Options not accounted.\n");
                } else {
                        debug_on("GPIPS_DEBUG_LEVEL");
                        activate(phase);
                        debug_off();
                        user_log("Options: phase %s (%s) set on.\n", aliased_phase, phase);
                }
        }
        /* To have the options panel consistent with the real phase set :
         RK, 05/07/1993. */
        verbose_update_options = 0;
        update_options();
        verbose_update_options = 1;
}
 
void options_combo_box_change_callback(GtkWidget * item, gpointer data __attribute__((unused)))
/*      "value" is already used for a typedef... :-) RK, 11/06/1993. */
{
        char * aliased_phase = gtk_combo_box_get_active_text(GTK_COMBO_BOX(item));
        options_select(aliased_phase);
}
 
void options_frame_to_view_menu_gateway(GtkWidget * widget, gpointer data __attribute__((unused))) {
        const gchar * label = gtk_button_get_label(GTK_BUTTON(widget));
        gpips_execute_and_display_something_from_alias(label);
}
 
void options_menu_callback(GtkWidget * widget, gpointer data __attribute__((unused))) {
        const char* aliased_phase = gpips_gtk_menu_item_get_label(widget);
        options_select(aliased_phase);
}
 
/* The function used by qsort to compare 2 option_type structures
 according to their name string: */
static int compare_option_type_for_qsort(const void *x, const void *y) {
        return strcmp(((option_type *) x)->name, ((option_type *) y)->name);
}
 
static void synch_viewmenu_and_opframe_search_in_view(GtkWidget * widget,
                gpointer data) {
        LabelAndVbox * lav = (LabelAndVbox *) data;
        GtkWidget * button;
        if (GTK_IS_MENU_ITEM(widget)) {
                // if the currently processed menu_item has got the same label than the currently processed option
                if (strcmp(data, gpips_gtk_menu_item_get_label(widget)) == 0) {
                        button = gtk_button_new_with_label(lav->label); // creating a "link-button" toward View
                        gtk_box_pack_start(GTK_BOX(lav->vbox), button, FALSE, FALSE, 5); // packing
                        gtk_box_reorder_child(GTK_BOX(lav->vbox), button, lav->position + 1); // positioning
                        gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC( // connecting
                                        options_frame_to_view_menu_gateway), NULL);
                }
        }
}
 
static void synch_viewmenu_and_opframe(GtkWidget * widget, gpointer data) {
        const char * label;
        LabelAndVbox * lav = (LabelAndVbox *) data;
 
        if (GTK_IS_LABEL(widget)) {
                label = gtk_label_get_text(GTK_LABEL(widget));
                // on cherche ds le viewmenu un menu_item avec le même label
                // si yen a un on rajoute un bouton
                lav->label = label;
                gtk_container_child_get_property(GTK_CONTAINER(lav->vbox), widget,
                                "position", (GValue*)&(lav->position));
                gtk_container_foreach(GTK_CONTAINER(view_menu), (GtkCallback)
                                synch_viewmenu_and_opframe_search_in_view, lav);
        }
}
 
/* Build the option menu by looking at the pipsmake.rc file and
 searching if there are several way to build a ressource: */
/* The option panel use the definition of the edit menu and so needs
 to be created after it: */
void build_options_menu_and_panel(GtkWidget * menu_options,
                GtkWidget * frame_vbox) {
        int i;
        option_type *all_the_options;
        makefile m = parse_makefile();
        //int max_item_width = 0;
 
        int number_of_options = 0;
        hash_table phase_by_made_htp = hash_table_make(hash_string, 0);
        // attention on libÚre jamais la mémoire de la hash_table ci dessous
        menu_item_to_combo_box = hash_table_make(hash_pointer, 0);
 
        smenu_options = menu_options;
 
        /* walking thru rules */
        MAPL(pr, {
                                rule r = RULE(CAR(pr));
 
                                /* walking thru resources made by this particular rule */
                                MAPL(pvr, {
                                                        virtual_resource vr = VIRTUAL_RESOURCE(CAR(pvr));
                                                        string vrn = virtual_resource_name(vr);
                                                        list p = CONS(STRING, rule_phase(r), NIL);
                                                        list l = (list) hash_get(phase_by_made_htp, vrn);
 
                                                        if ( l == (list) HASH_UNDEFINED_VALUE ) {
                                                                hash_put(phase_by_made_htp, vrn, (char *)p);
                                                        }
                                                        else {
                                                                (void) gen_nconc(l, p);
                                                        }
                                                }, rule_produced(r));
 
                        }, makefile_rules(m));
 
        /* walking thru phase_by_made_htp */
 
        /* First, try to do some measurements on the options item to be
         able to sort and align menu items later: */
        HASH_MAP(k, v, {
                                string alias1 = hash_get_key_by_value(aliases, k);
                                list l = (list) v;
 
                                if ((alias1 != HASH_UNDEFINED_VALUE) && (gen_length(l) >= 2))
                                number_of_options++;
                        }, phase_by_made_htp);
 
        all_the_options = (option_type *) malloc(number_of_options
                        * sizeof(option_type));
 
        /* Now generate an array of the Options: */
        i = 0;
        HASH_MAP(k, v, {
                                string alias1 = hash_get_key_by_value(aliases, k);
                                list l = (list) v;
 
                                if ((alias1 != HASH_UNDEFINED_VALUE) && (gen_length(l) >= 2)) {
                                        all_the_options[i].name = alias1;
                                        all_the_options[i].choices = l;
                                        i++;
                                }
                        }, phase_by_made_htp);
 
        /* Sort the Options: */
        qsort((char *) all_the_options, number_of_options, sizeof(option_type),
                        compare_option_type_for_qsort);
 
        /* Create the Options in the Option menu and option panel: */
        GtkWidget * table = gtk_table_new(number_of_options, 2, TRUE);
        gtk_box_pack_start(GTK_BOX(frame_vbox), table, TRUE, FALSE, 0);
        for (i = 0; i < number_of_options; i++) {
                GtkWidget * sub_menu_option, *sub_menu_option_item;
                //GtkWidget * menu_options_item;
                GtkWidget * choices_combobox;
 
                /* Create the sub-menu entry of an option: */
                sub_menu_option = gtk_menu_new();
                sub_menu_option_item = gtk_menu_item_new_with_label(
                                all_the_options[i].name);
                gtk_menu_item_set_submenu(GTK_MENU_ITEM(sub_menu_option_item),
                                sub_menu_option);
 
//              g_signal_connect(GTK_OBJECT(sub_menu_option_item), "activate",
//                              G_CALLBACK(options_menu_callback), NULL);
                gtk_menu_append(GTK_MENU(menu_options), sub_menu_option_item);
 
                /* PANEL_CLIENT_DATA is used to link the PANEL_CHOICE_STACK
                 to its dual MENU_PULLRIGHT. RK, 11/06/1993. */
                choices_combobox = gtk_combo_box_new_text();
                gtk_signal_connect(GTK_OBJECT(choices_combobox), "changed",
                                GTK_SIGNAL_FUNC(options_combo_box_change_callback), NULL);
                gtk_table_attach_defaults(GTK_TABLE(table), gtk_label_new(
                                all_the_options[i].name), 0, 1, i, i + 1);
                gtk_table_attach_defaults(GTK_TABLE(table), choices_combobox, 1, 2, i,
                                i + 1);
 
                GtkWidget * subsubmenu_option_item;
                MAPL(vrn, {
                                        string alias2 = hash_get_key_by_value(aliases,
                                                        STRING(CAR(vrn)));
 
                                        if (alias2 != HASH_UNDEFINED_VALUE) {
                                                /* Add a sub-option entry in the menu: */
                                                /* Attach the sub-menu to an Option menu: */
                                                subsubmenu_option_item = gtk_menu_item_new_with_label(alias2);
                                                gtk_menu_append(GTK_MENU(sub_menu_option), subsubmenu_option_item);
                                                g_signal_connect(GTK_OBJECT(subsubmenu_option_item), "activate",
                                                                                G_CALLBACK(options_menu_callback), NULL);
 
                                                /* ... And in the Option panel: */
                                                gtk_combo_box_append_text(GTK_COMBO_BOX(choices_combobox), alias2);
                                        }
                                }, all_the_options[i].choices);
 
                // on indique la combobox associée à sub_menu_option menu dans une hash_table dédiée
                hash_put(menu_item_to_combo_box, sub_menu_option, choices_combobox);
 
                gtk_widget_show(sub_menu_option_item);
                gtk_widget_show_all(sub_menu_option);
                gtk_widget_show_all(choices_combobox);
        }
        gtk_widget_show_all(table);
 
        /* According to a suggestion from Guillaume Oget, it should be nice
         to be able to select a view also from the Option panel: */
 
        //char * option_item_label;
 
        LabelAndVbox lav;
        lav.vbox = frame_vbox;
        gtk_container_foreach(GTK_CONTAINER(options_frame), (GtkCallback)
                        synch_viewmenu_and_opframe, &lav);
}
 
/* Construct a table linking PIPS phase name to more human names, the
 aliases defined in pipsmake-rc.tex.
 */
void build_aliases() {
        static int runs = 0;
        runs++;
        char buffer[BSIZE_HERE];
        char true_name[BSIZE_HERE], alias_name[BSIZE_HERE];
        FILE *fd;
 
        aliases = hash_table_make(hash_string, 0);
 
        fd = fopen_config(WPIPS_RC, NULL,NULL);
 
        while (fgets(buffer, BSIZE_HERE, fd) != NULL) {
                if (buffer[0] == '-')
                        continue;
 
                sscanf(buffer, "alias%s '%[^']", true_name, alias_name);
 
                string stored_name;
                if ((stored_name = hash_get(aliases, alias_name))
                                != HASH_UNDEFINED_VALUE) {
                        pips_internal_error("Aliases must not be ambiguous\n"
                                "\talias '%s' seems ambiguous "
                                "because of previous '%s'!\n", true_name, stored_name);
                } else {
                        char * upper = strdup(true_name);
                        hash_put(aliases, strdup(alias_name), strupper(upper, upper));
                }
        }
        safe_fclose(fd, WPIPS_RC);
}
 
void display_or_hide_options_frame(GtkWidget * menu_item, gpointer data) {
        const char *message_string;
 
        /* Should be added : when the options panel is destroyed by the
         window manager, toggle the menu. RK, 7/6/93. */
 
        message_string = gpips_gtk_menu_item_get_label(menu_item);
        if (message_string != NULL && strcmp(message_string, display_options_panel)
                        == 0) {
                gtk_widget_show_all(options_window);
                gpips_gtk_menu_item_set_label(menu_item, hide_options_panel);
        } else {
                hide_window(options_window, NULL, NULL);
                gpips_gtk_menu_item_set_label(menu_item, display_options_panel);
        }
}
 
/* Hide and restore the menu item to reopen the option panel: */
void static options_window_done_procedure(GtkWidget * window, gpointer data) {
        hide_window(options_window, NULL, NULL);
        gpips_gtk_menu_item_set_label(options_frame_menu_item,
                        display_options_panel);
}
 
void create_options_menu_and_window() {
        GtkWidget * vbox;
        options_frame = gtk_frame_new(NULL);
        vbox = gtk_vbox_new(FALSE, 0);
        gtk_container_add(GTK_CONTAINER(options_frame), vbox);
        gtk_container_add(GTK_CONTAINER(options_window), options_frame);
 
        /* Trap the FRAME_DONE event: */
        gtk_signal_connect(GTK_OBJECT(options_window), "delete-event",
                        GTK_SIGNAL_FUNC(options_window_done_procedure), NULL);
 
        options_frame_menu_item = gtk_menu_item_new_with_label(
                        display_options_panel);
        g_signal_connect(G_OBJECT(options_frame_menu_item), "activate", G_CALLBACK(
                        display_or_hide_options_frame), NULL);
 
        options_menu = gtk_menu_new();
        gtk_menu_append(GTK_MENU(options_menu), options_frame_menu_item);
 
        build_aliases();
        build_options_menu_and_panel(options_menu, vbox);
        gtk_widget_show_all(options_frame);
 
        options_menu_item = gtk_menu_item_new_with_label("Options");
        gtk_menu_item_set_submenu(GTK_MENU_ITEM(options_menu_item), options_menu);
 
        gtk_menu_bar_append(GTK_MENU_BAR(main_window_menu_bar), options_menu_item);
}