gtk_edit2.c

Go to the documentation of this file.

/*
 
  $Id: gtk_edit2.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
/*      %A% ($Date: 1998/04/16 14:45:19 $, ) version $Revision: 12279 $, got on %D%, %T% [%P%].\n Copyright (c) ï¿œcole des Mines de Paris Proprietary.  */
 
#ifndef lint
char
                vcid_xv_edit2[] =
                                "%A% ($Date: 1998/04/16 14:45:19 $, ) version $Revision: 12279 $, got on %D%, %T% [%P%].\n ï¿œcole des Mines de Paris Proprietary.";
#endif /* lint */
 
#include <stdlib.h>
#include <stdio.h>
#include <sys/param.h>
 
#include <sys/time.h>
#include <sys/resource.h>
 
#undef test_undefined // also defined in glib included from gtk
#include <gtk/gtk.h>
 
#if (defined(TEXT))
#undef TEXT
#endif
 
#if (defined(TEXT_TYPE))
#undef TEXT_TYPE
#endif
 
#include "genC.h"
#include "linear.h"
 
#include "misc.h"
#include "pipsdbm.h"
 
#include "ri-util.h"
 
#include "database.h"
#include "pipsmake.h"
 
#include "resources.h"
#include "constants.h"
#include "top-level.h"
 
#include "gpips.h"
 
/* Include the label names: */
#include "gpips-labels.h"
 
static gpips_view_menu_layout_line gpips_view_menu_layout[] = {
#include "gpips_view_menu_layout.h"
                /* No more views */
                { NULL, NULL, NULL } };
 
typedef struct {
        GtkTextView * view;
        GtkButton * save_button;
        GtkWidget * check_button;
        char * filename;
} EditedFile;
 
static EditedFile edited_file[MAX_NUMBER_OF_GPIPS_WINDOWS];
int number_of_gpips_windows = INITIAL_NUMBER_OF_GPIPS_WINDOWS;
 
static GtkWidget *current_selection_menu_item, *close_menu_item,
                *sequential_view_menu_item;
GtkWidget *edit_menu_item;
 
/* The menu "View" on the main panel: */
GtkWidget *view_menu, *view_menu_item;
 
/* To pass the view name to
 execute_gpips_execute_and_display_something_outside_the_notifyer(): */
static gpips_view_menu_layout_line
                * execute_gpips_execute_and_display_something_outside_the_notifyer_menu_line =
                                NULL;
 
void edit_notify(GtkWidget * widget, gpointer data) {
        char string_filename[SMALL_BUFFER_LENGTH],
                        string_modulename[SMALL_BUFFER_LENGTH];
        char file_name_in_database[MAXPATHLEN * 2];
        char * modulename = db_get_current_module_name();
        char * file_name;
        int win_nb;
        char * alternate_gpips_editor;
 
        if (modulename == NULL) {
                prompt_user("No module selected");
                return;
        }
 
        file_name = db_get_file_resource(DBR_SOURCE_FILE, modulename, TRUE);
        sprintf(file_name_in_database, "%s/%s", build_pgmwd(
                        db_get_current_workspace_name()), file_name);
 
        if ((alternate_gpips_editor = getenv("PIPS_GPIPS_EDITOR")) != NULL) {
                char editor_command[MAXPATHLEN * 2];
                sprintf(editor_command, "%s %s &", alternate_gpips_editor,
                                file_name_in_database);
                safe_system(editor_command);
        } else {
                /* Is there an available edit_textsw ? */
                if ((win_nb = alloc_first_initialized_window(FALSE))
                                == NO_TEXTSW_AVAILABLE) {
                        prompt_user("None of the text-windows is available");
                        return;
                }
 
                sprintf(string_filename, "File: %s", file_name);
                sprintf(string_modulename, "Module: %s", modulename);
 
                /* Display the file name and the module name. RK, 2/06/1993 : */
                gtk_window_set_title(GTK_WINDOW(edit_window[win_nb]), concatenate(
                                "gpips edit facility - ", string_filename, " - ",
                                string_modulename, NULL));
 
                // Charge le fichier file_name_in_database dans le text_view dispo
                gchar * file_in_mem;
                int size;
                GtkTextBuffer * txt_buff;
                GtkTextIter iter;
 
                edited_file[win_nb].filename = file_name_in_database;
                size = load_file(file_name_in_database, &file_in_mem);
                txt_buff = gtk_text_view_get_buffer(GTK_TEXT_VIEW(
                                edited_file[win_nb].view));
                gtk_text_buffer_set_text(GTK_TEXT_BUFFER(txt_buff), file_in_mem, size);
 
                gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER(txt_buff), &iter);
                gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(edited_file[win_nb].view),
                                &iter, 0.0, FALSE, 0.0, 0.0);
                gtk_widget_show_all(edit_window[win_nb]);
 
                g_free(file_in_mem);
 
                gtk_widget_set_sensitive(GTK_WIDGET(edited_file[win_nb].save_button),
                                TRUE);
 
                gpips_gtk_menu_item_set_label(
                                GTK_WIDGET(GTK_MENU_ITEM(current_selection_menu_item)), "Lasts");
                gtk_widget_set_sensitive(GTK_WIDGET(current_selection_menu_item), TRUE);
 
                gtk_widget_set_sensitive(GTK_WIDGET(close_menu_item), TRUE);
        }
}
 
void buffer_changed_callback(GtkWidget * widget, gpointer data) {
        EditedFile * f = (EditedFile *) data;
        // if the buffer changes, it means the document has been edited
        if ((!GTK_WIDGET_SENSITIVE(f->save_button)) && f->filename != NULL)
                gtk_widget_set_sensitive(GTK_WIDGET(f->save_button), TRUE);
}
 
static void save_edited_file(GtkWidget * widget, gpointer file) {
        EditedFile * f = (EditedFile *) file;
        char * filename = f->filename;
        GtkTextView * view = f->view;
        GtkTextBuffer * buff = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
 
        GtkTextIter start, end;
        gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER(buff), &start);
        gtk_text_buffer_get_end_iter(GTK_TEXT_BUFFER(buff), &end);
 
        gchar * txt = gtk_text_buffer_get_text(GTK_TEXT_BUFFER(buff), &start, &end,
                        TRUE);
 
        FILE * fd = fopen(filename, "w+");
        fprintf(fd, "%s", txt);
        fclose(fd);
 
        gtk_widget_set_sensitive(GTK_WIDGET(current_selection_menu_item), FALSE);
}
 
void current_selection_notify(GtkWidget * widget, gpointer data) {
        guint i;
        for (i = 0; i < number_of_gpips_windows; i++)
                gtk_widget_show(edit_window[i]);
}
 
char * compute_title_string(int window_number) {
        char title_string_beginning[] = "gpips display facility # ";
        static char title_string[sizeof(title_string_beginning) + 4];
 
        (void) sprintf(title_string, "%s%d", title_string_beginning, window_number
                        + 1);
 
        return title_string;
}
 
/* Find the first free window if any. If called with TRUE, give the
 same as the previous chosen one. */
int alloc_first_initialized_window(bool the_same_as_previous) {
        static int next = 0;
        static int candidate = 0;
        int i;
 
        if (the_same_as_previous)
                return candidate;
 
        for (i = next; i < next + number_of_gpips_windows; i++) {
                candidate = i % number_of_gpips_windows;
                /* Skip windows with modified text inside : */
                if (gpips_gtk_widget_get_sensitive(GTK_WIDGET(edited_file[candidate].save_button)))
                        continue;
                /* Skip windows with a retain attribute : */
                if ((bool) gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(
                                edited_file[candidate].check_button)))
                        continue;
 
                next = candidate + 1;
                return candidate;
        }
        candidate = NO_TEXTSW_AVAILABLE;
 
        return candidate;
}
 
/* Mark a gpips window as busy: */
bool gpips_view_marked_busy(char * title_module_name, /* The module name for example */
char * title_label, /* "Sequential View" for exemple */
char * icon_name, char * icon_title) {
        char busy_label[SMALL_BUFFER_LENGTH];
 
        int window_number;
        /* Is there an available edit_textsw ? */
        if ((window_number = alloc_first_initialized_window(FALSE))
                        == NO_TEXTSW_AVAILABLE) {
                prompt_user("None of the text-windows is available");
                return FALSE;
        }
        (void) sprintf(busy_label, "*Computing %s * ...", title_label);
        /* Display the file name and the module name. RK, 2/06/1993 : */
        gtk_window_set_title(GTK_WINDOW(edit_window[window_number]), concatenate(
                        "gpips edit facility - ", busy_label, " - ", title_module_name,
                        NULL));
 
        //set_pips_icon(edit_frame[window_number], icon_name, icon_title);
 
        //      unhide_window(edit_frame[window_number]);
        gtk_widget_show(edit_window[window_number]);
 
        display_memory_usage();
 
        return TRUE;
}
 
/* Display a file in a gpips window: */
void gpips_file_view(char * file_name, const char * title_module_name, /* The module name for example */
char * title_label, /* "Sequential View" for exemple */
char * icon_name, char * icon_title) {
        if (file_name == NULL) {
                /* Well, something got wrong... */
                prompt_user("Nothing available to display...");
                return;
        }
 
        int window_number;
 
        /* Is there an available edit_textsw ? Ask for the same one
         allocated for gpips_view_marked_busy() */
        if ((window_number = alloc_first_initialized_window(TRUE))
                        == NO_TEXTSW_AVAILABLE) {
                prompt_user("None of the text-windows is available");
                return;
        }
        /* Display the file name and the module name. RK, 2/06/1993 : */
        gtk_window_set_title(GTK_WINDOW(edit_window[window_number]), concatenate(
                        compute_title_string(window_number), " - ", title_label, " - ",
                        title_module_name, NULL));
 
        //      set_pips_icon(edit_window[window_number], icon_name, icon_title); TODO: Fix icones!
 
        // Charge le fichier file_name dans edited_file[window_number]
        gchar * file_in_mem;
        int size;
        GtkTextBuffer * txt_buff;
        GtkTextIter iter;
 
        edited_file[window_number].filename = file_name;
        size = load_file(file_name, &file_in_mem);
        txt_buff = gtk_text_view_get_buffer(GTK_TEXT_VIEW(
                        edited_file[window_number].view));
        gtk_text_buffer_set_text(GTK_TEXT_BUFFER(txt_buff), file_in_mem, size);
 
        gtk_text_buffer_get_start_iter(GTK_TEXT_BUFFER(txt_buff), &iter);
        gtk_text_view_scroll_to_iter(
                        GTK_TEXT_VIEW(edited_file[window_number].view), &iter, 0.0, FALSE,
                        0.0, 0.0);
        gtk_widget_show_all(edit_window[window_number]);
 
        g_free(file_in_mem);
 
        gtk_widget_set_sensitive(
                        GTK_WIDGET(edited_file[window_number].save_button), TRUE);
 
        gtk_widget_show(edit_window[window_number]);
 
        gpips_gtk_menu_item_set_label(current_selection_menu_item, "Lasts");
        gtk_widget_set_sensitive(current_selection_menu_item, TRUE);
 
        gtk_widget_set_sensitive(close_menu_item, TRUE);
        display_memory_usage();
}
 
/* Use daVinci to display a graph information: */
void gpips_display_graph_file_display(gpips_view_menu_layout_line * menu_line) {
        char * file_name;
        char a_buffer[SMALL_BUFFER_LENGTH];
 
        file_name = build_view_file(menu_line->resource_name_to_view);
 
        user_log("Displaying in a \"daVinci\" window...\n");
 
        /* Preprocess the graph to be understandable by daVinci : */
 
        (void) sprintf(a_buffer, "pips_graph2daVinci -launch_daVinci %s", file_name);
        safe_system(a_buffer);
 
        free(file_name);
}
 
/* Use some text viewer to display the resource: */
void gpips_display_plain_file(gpips_view_menu_layout_line * menu_line) {
        char title_module_name[SMALL_BUFFER_LENGTH];
 
        char * print_type = menu_line->resource_name_to_view;
        char * icon_name = menu_line->icon_name;
        char * label = menu_line->menu_entry_string;
 
        (void) sprintf(title_module_name, "Module: %s",
                        db_get_current_module_name());
        if (gpips_view_marked_busy(title_module_name, label, icon_name,
                        db_get_current_module_name())) {
                char * file_name = build_view_file(print_type);
 
                gpips_file_view(file_name, title_module_name, label, icon_name,
                                db_get_current_module_name());
 
                free(file_name);
        }
}
 
/* To execute something and display some Pips output with gpips, called outside the notifyer: */
void execute_gpips_execute_and_display_something_outside_the_notifier() {
        gpips_view_menu_layout_line * menu_line =
                        execute_gpips_execute_and_display_something_outside_the_notifyer_menu_line;
 
        /* Execute the needed method: */
        menu_line->method_function_to_use(menu_line);
 
        display_memory_usage();
}
 
void gpips_execute_and_display_something_outside_the_notifyer(
                gpips_view_menu_layout_line * menu_line) {
        execute_gpips_execute_and_display_something_outside_the_notifyer_menu_line
                        = menu_line;
        /* Ask to execute the
         execute_gpips_execute_and_display_something_outside_the_notifyer(): */
        execute_main_loop_command(GPIPS_EXECUTE_AND_DISPLAY);
        /* I guess the function above does not return... */
}
 
/* To execute something and display some Pips output with gpips */
void gpips_execute_and_display_something(char * resource_name) {
        char * module_name = db_get_current_module_name();
        gpips_view_menu_layout_line * current_view;
 
        if (module_name == NULL) {
                prompt_user("No module selected");
                return;
        }
 
        /* Translate the resource name in a menu entry descriptor: */
        for (current_view = &gpips_view_menu_layout[0]; current_view->menu_entry_string
                        != NULL; current_view++)
                if (strcmp(resource_name, current_view->resource_name_to_view) == 0)
                        break;
 
        pips_assert("Resource related to the menu entry not found",
                        current_view->menu_entry_string != NULL);
 
        gpips_execute_and_display_something_outside_the_notifyer(current_view);
}
 
/* To execute something and display some Pips output with gpips by knowing its alias: */
void gpips_execute_and_display_something_from_alias(const char * alias_name) {
        char * module_name = db_get_current_module_name();
        gpips_view_menu_layout_line * current_view;
 
        if (module_name == NULL) {
                prompt_user("No module selected");
                return;
        }
 
        for (current_view = &gpips_view_menu_layout[0]; current_view->menu_entry_string
                        != NULL; current_view++)
                if (strcmp(alias_name, current_view->menu_entry_string) == 0)
                        break;
 
        pips_assert("Resource related to the menu entry not found",
                        current_view->menu_entry_string != NULL);
 
        gpips_execute_and_display_something_outside_the_notifyer(current_view);
}
 
void view_notify(GtkWidget * menu_item, gpointer data) {
        /* Translate the menu string in a resource name: */
        const char * label = gpips_gtk_menu_item_get_label(menu_item);
        gpips_execute_and_display_something_from_alias(label);
}
 
void edit_close_notify(GtkWidget * widget, gpointer data) {
        int i;
 
        for (i = 0; i < MAX_NUMBER_OF_GPIPS_WINDOWS; i++)
                if (!gpips_gtk_widget_get_sensitive(GTK_WIDGET(edited_file[i].save_button)))
                        hide_window(edit_window[i], NULL, NULL);
 
        for (i = 0; i < MAX_NUMBER_OF_GPIPS_WINDOWS; i++)
                if (gpips_gtk_widget_get_sensitive(GTK_WIDGET(edited_file[i].save_button))) {
                        gtk_widget_show(edit_window[i]);
                        prompt_user("File not saved in editor");
                        return;
                }
 
        for (i = 0; i < MAX_NUMBER_OF_GPIPS_WINDOWS; i++)
                hide_window(edit_window[i], NULL, NULL);
 
        gpips_gtk_menu_item_set_label(current_selection_menu_item, "No Selection");
        gtk_widget_set_sensitive(GTK_WIDGET(current_selection_menu_item), FALSE);
 
        gtk_widget_set_sensitive(GTK_WIDGET(close_menu_item), FALSE);
 
        display_memory_usage();
}
 
void disable_item(GtkWidget * item) {
        gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
}
 
void enable_item(GtkWidget * item) {
        gtk_widget_set_sensitive(GTK_WIDGET(item), TRUE);
}
 
void apply_on_each_view_menu_item(GtkWidget * widget, gpointer _func) {
        void (*func)(GtkWidget *);
        func = (void(*)(GtkWidget *)) _func;
        if (widget != current_selection_menu_item && widget != close_menu_item)
                func(widget);
}
 
void apply_on_each_options_frame_button(GtkWidget * widget, gpointer _func) {
        void (*func)(GtkWidget *);
        func = (void(*)(GtkWidget *)) _func;
        if (GTK_IS_BUTTON(widget))
                func(widget);
}
 
void apply_on_each_view_item(void(* function_to_apply_on_each_menu_item)(
                GtkWidget *), void(* function_to_apply_on_each_panel_item)(GtkWidget *)) {
        //int i;
 
        /* Skip the "current_selection_mi" and "close" Menu_items: */
        gtk_container_foreach(GTK_CONTAINER(view_menu), (GtkCallback)
                        apply_on_each_view_menu_item, function_to_apply_on_each_menu_item);
        //      for (i = (int) xv_get(view_menu, MENU_NITEMS); i > 0; i--) {
        //              Menu_item menu_item = (Menu_item) xv_get(view_menu, MENU_NTH_ITEM, i);
        //              /* Skip the title item: */
        //              if (!(bool) xv_get(menu_item, MENU_TITLE) && menu_item
        //                              != current_selection_menu_item && menu_item != close_menu_item
        //                              && xv_get(menu_item, MENU_NOTIFY_PROC) != NULL)
        //                      function_to_apply_on_each_menu_item(menu_item);
        //      }
 
        /* Now walk through the options frame: */
        gtk_container_foreach(GTK_CONTAINER(options_frame), (GtkCallback)
                        apply_on_each_options_frame_button,
                        function_to_apply_on_each_panel_item);
}
 
void disable_view_selection() {
        apply_on_each_view_item(disable_item, disable_item);
}
 
void enable_view_selection() {
        apply_on_each_view_item(enable_item, enable_item);
}
 
void create_edit_window() {
        guint i;
 
        GtkWidget * frame;
        GtkWidget * text_buffer;
        GtkWidget * vbox;
        //GtkWidget * buttons_hbox;
        for (i = 0; i < MAX_NUMBER_OF_GPIPS_WINDOWS; i++) {
 
                vbox = gtk_vbox_new(FALSE, 0);
                //buttons_hbox = gtk_hbox_new(FALSE, 0);
 
                gtk_container_add(GTK_CONTAINER(edit_window[i]), vbox);
 
                edited_file[i].view = GTK_TEXT_VIEW(gtk_text_view_new());
                text_buffer = GTK_WIDGET(gtk_text_buffer_new(NULL));
                gtk_text_view_set_buffer(GTK_TEXT_VIEW(edited_file[i].view),
                                GTK_TEXT_BUFFER(text_buffer));
                gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(edited_file[i].view), TRUE, FALSE, 0);
 
                g_signal_connect(G_OBJECT(text_buffer), "changed", G_CALLBACK(
                                buffer_changed_callback), &edited_file[i]);
 
                edited_file[i].save_button = GTK_BUTTON(gtk_button_new_with_label("Save"));
                gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(edited_file[i].save_button), FALSE,
                                FALSE, 0);
                gtk_widget_set_sensitive(GTK_WIDGET(edited_file[i].save_button), FALSE);
                g_signal_connect(G_OBJECT(edited_file[i].save_button), "clicked",
                                G_CALLBACK(save_edited_file), &edited_file[i]);
 
                //gtk_box_pack_start(GTK_BOX(vbox), buttons_hbox, FALSE, FALSE, 0);
                frame = gtk_frame_new(NULL);
                gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 0);
 
                // A quoi sert ce check_button
                // TODO: trouver à quoi il sert
                edited_file[i].check_button = gtk_check_button_new_with_label(
                                "Retain this window");
                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(
                                edited_file[i].check_button), FALSE);
                gtk_container_add(GTK_CONTAINER(frame), edited_file[i].check_button);
                //              gtk_box_pack_start(GTK_BOX(frame), edited_file[i].check_button,
                //                              FALSE, FALSE, 0);
 
                edited_file[i].filename = NULL;
 
                gtk_widget_show_all(vbox);
        }
}
 
void create_edit_menu() {
        GtkWidget *menu_item;
        gpips_view_menu_layout_line * current_view;
 
        current_selection_menu_item = gtk_menu_item_new_with_label("No Selection");
        g_signal_connect(G_OBJECT(current_selection_menu_item), "activate",
                        G_CALLBACK(current_selection_notify), NULL);
        gtk_widget_set_sensitive(GTK_WIDGET(current_selection_menu_item), FALSE);
 
        close_menu_item = gtk_menu_item_new_with_label("Close");
        g_signal_connect(G_OBJECT(close_menu_item), "activate", G_CALLBACK(
                        edit_close_notify), NULL);
        gtk_widget_set_sensitive(GTK_WIDGET(close_menu_item), FALSE);
 
        sequential_view_menu_item = gtk_menu_item_new_with_label(SEQUENTIAL_VIEW);
        g_signal_connect(G_OBJECT(sequential_view_menu_item), "activate",
                        G_CALLBACK(view_notify), NULL);
 
        view_menu = gtk_menu_new();
        gtk_menu_append(GTK_MENU(view_menu), current_selection_menu_item);
 
        /* Now add all the view entries: */
        for (current_view = &gpips_view_menu_layout[0]; current_view->menu_entry_string
                        != NULL; current_view++) {
                if (strcmp(current_view->menu_entry_string, GPIPS_MENU_SEPARATOR_ID)
                                == 0) {
                        gtk_menu_append(GTK_MENU(view_menu), gtk_separator_menu_item_new());
                } else {
                        menu_item = gtk_menu_item_new_with_label(
                                        current_view->menu_entry_string);
                        g_signal_connect(G_OBJECT(menu_item), "activate", G_CALLBACK(
                                        view_notify), NULL);
                        gtk_menu_append(GTK_MENU(view_menu), menu_item);
                }
        }
        gtk_menu_append(GTK_MENU(view_menu), gtk_separator_menu_item_new());
        gtk_menu_append(GTK_MENU(view_menu), close_menu_item);
 
        view_menu_item = gtk_menu_item_new_with_label("View & Edit Menu");
        gtk_menu_item_set_submenu(GTK_MENU_ITEM(view_menu_item), view_menu);
 
        gtk_widget_show_all(view_menu);
        gtk_widget_show(view_menu_item);
        gtk_menu_bar_append(GTK_MENU_BAR(main_window_menu_bar), view_menu_item);
}