#include <stdlib.h>
#include <stdio.h>
#include <sys/param.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <gtk/gtk.h>
#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 "gpips-labels.h"
#include "gpips_view_menu_layout.h"

Include dependency graph for gtk_edit2.c:

Data Structures
struct	EditedFile

Functions
void	edit_notify (GtkWidget *widget, gpointer data)

void	buffer_changed_callback (GtkWidget *widget, gpointer data)

static void	save_edited_file (GtkWidget *widget, gpointer file)

void	current_selection_notify (GtkWidget *widget, gpointer data)

char *	compute_title_string (int window_number)

int	alloc_first_initialized_window (bool the_same_as_previous)
	Find the first free window if any. More...

bool	gpips_view_marked_busy (char title_module_name, char title_label, char icon_name, char icon_title)
	Mark a gpips window as busy: More...

void	gpips_file_view (char file_name, const char title_module_name, char title_label, char icon_name, char *icon_title)
	Display a file in a gpips window: More...

void	gpips_display_graph_file_display (gpips_view_menu_layout_line *menu_line)
	Use daVinci to display a graph information: More...

void	gpips_display_plain_file (gpips_view_menu_layout_line *menu_line)
	Use some text viewer to display the resource: More...

void	execute_gpips_execute_and_display_something_outside_the_notifier ()
	To execute something and display some Pips output with gpips, called outside the notifyer: More...

void	gpips_execute_and_display_something_outside_the_notifyer (gpips_view_menu_layout_line *menu_line)

void	gpips_execute_and_display_something (char *resource_name)
	To execute something and display some Pips output with gpips. More...

void	gpips_execute_and_display_something_from_alias (const char *alias_name)
	To execute something and display some Pips output with gpips by knowing its alias: More...

void	view_notify (GtkWidget *menu_item, gpointer data)

void	edit_close_notify (GtkWidget *widget, gpointer data)

void	disable_item (GtkWidget *item)

void	enable_item (GtkWidget *item)

void	apply_on_each_view_menu_item (GtkWidget *widget, gpointer _func)

void	apply_on_each_options_frame_button (GtkWidget *widget, gpointer _func)

void	apply_on_each_view_item (void(function_to_apply_on_each_menu_item)(GtkWidget ), void(function_to_apply_on_each_panel_item)(GtkWidget ))

void	disable_view_selection ()

void	enable_view_selection ()

void	create_edit_window ()

void	create_edit_menu ()

Variables
char	vcid_xv_edit2 []
	A% ( More...

static gpips_view_menu_layout_line	gpips_view_menu_layout []
	lint More...

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

static GtkWidget *	close_menu_item

static GtkWidget *	sequential_view_menu_item

GtkWidget *	edit_menu_item

GtkWidget *	view_menu
	The menu "View" on the main panel: More...

GtkWidget *	view_menu_item

static gpips_view_menu_layout_line *	execute_gpips_execute_and_display_something_outside_the_notifyer_menu_line
	To pass the view name to execute_gpips_execute_and_display_something_outside_the_notifyer(): More...

Function Documentation

◆ alloc_first_initialized_window()

int alloc_first_initialized_window ( bool the_same_as_previous )

Find the first free window if any.

If called with TRUE, give the same as the previous chosen one.

Skip windows with modified text inside :

Skip windows with a retain attribute :

Definition at line 215 of file gtk_edit2.c.

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

References edited_file, gpips_gtk_widget_get_sensitive(), NO_TEXTSW_AVAILABLE, and number_of_gpips_windows.

Referenced by edit_notify(), gpips_file_view(), gpips_view_marked_busy(), and notify_hpfc_file_view().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_on_each_options_frame_button()

void apply_on_each_options_frame_button	(	GtkWidget *	widget,
		gpointer	_func
	)

Definition at line 476 of file gtk_edit2.c.

                                                                             {
         void (*func)(GtkWidget *);
         func = (void(*)(GtkWidget *)) _func;
         if (GTK_IS_BUTTON(widget))
                 func(widget);
 }

Referenced by apply_on_each_view_item().

Here is the caller graph for this function:

◆ apply_on_each_view_item()

void apply_on_each_view_item	(	void()(GtkWidget )	function_to_apply_on_each_menu_item,
		void()(GtkWidget )	function_to_apply_on_each_panel_item
	)

Skip the "current_selection_mi" and "close" Menu_items:

Now walk through the options frame:

Definition at line 483 of file gtk_edit2.c.

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

References apply_on_each_options_frame_button(), apply_on_each_view_menu_item(), options_frame, and view_menu.

Referenced by disable_view_selection(), and enable_view_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ apply_on_each_view_menu_item()

void apply_on_each_view_menu_item	(	GtkWidget *	widget,
		gpointer	_func
	)

Definition at line 469 of file gtk_edit2.c.

                                                                       {
         void (*func)(GtkWidget *);
         func = (void(*)(GtkWidget *)) _func;
         if (widget != current_selection_menu_item && widget != close_menu_item)
                 func(widget);
 }

References close_menu_item, and current_selection_menu_item.

Referenced by apply_on_each_view_item().

Here is the caller graph for this function:

◆ buffer_changed_callback()

void buffer_changed_callback	(	GtkWidget *	widget,
		gpointer	data
	)

Definition at line 170 of file gtk_edit2.c.

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

References f().

Referenced by create_edit_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compute_title_string()

char* compute_title_string ( int window_number )

Definition at line 203 of file gtk_edit2.c.

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

References window_number.

Referenced by gpips_file_view().

Here is the caller graph for this function:

◆ create_edit_menu()

void create_edit_menu ( )

Now add all the view entries:

Definition at line 563 of file gtk_edit2.c.

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

References close_menu_item, current_selection_menu_item, current_selection_notify(), edit_close_notify(), GPIPS_MENU_SEPARATOR_ID, gpips_view_menu_layout, main_window_menu_bar, gpips_view_menu_layout_line_s::menu_entry_string, SEQUENTIAL_VIEW, sequential_view_menu_item, view_menu, view_menu_item, and view_notify().

Referenced by create_menus().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create_edit_window()

void create_edit_window ( )

Definition at line 513 of file gtk_edit2.c.

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

References buffer_changed_callback(), EditedFile::check_button, edit_window, edited_file, EditedFile::filename, MAX_NUMBER_OF_GPIPS_WINDOWS, EditedFile::save_button, save_edited_file(), and EditedFile::view.

Referenced by gpips_main(), and wpips_main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ current_selection_notify()

void current_selection_notify	(	GtkWidget *	widget,
		gpointer	data
	)

Definition at line 197 of file gtk_edit2.c.

                                                                  {
         guint i;
         for (i = 0; i < number_of_gpips_windows; i++)
                 gtk_widget_show(edit_window[i]);
 }

References edit_window, and number_of_gpips_windows.

Referenced by create_edit_menu().

Here is the caller graph for this function:

◆ disable_item()

void disable_item ( GtkWidget * item )

Definition at line 461 of file gtk_edit2.c.

                                     {
         gtk_widget_set_sensitive(GTK_WIDGET(item), FALSE);
 }

Referenced by disable_compile_selection(), disable_option_selection(), disable_transform_selection(), and disable_view_selection().

Here is the caller graph for this function:

◆ disable_view_selection()

void disable_view_selection ( )

Definition at line 505 of file gtk_edit2.c.

                               {
         apply_on_each_view_item(disable_item, disable_item);
 }

References apply_on_each_view_item(), and disable_item().

Referenced by disable_module_selection(), gpips_main(), and wpips_main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edit_close_notify()

void edit_close_notify	(	GtkWidget *	widget,
		gpointer	data
	)

Definition at line 436 of file gtk_edit2.c.

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

References close_menu_item, current_selection_menu_item, display_memory_usage(), edit_window, edited_file, gpips_gtk_menu_item_set_label(), gpips_gtk_widget_get_sensitive(), hide_window(), MAX_NUMBER_OF_GPIPS_WINDOWS, and prompt_user().

Referenced by close_workspace_notify(), and create_edit_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edit_notify()

void edit_notify	(	GtkWidget *	widget,
		gpointer	data
	)

Is there an available edit_textsw ?

Display the file name and the module name. RK, 2/06/1993 :

Definition at line 101 of file gtk_edit2.c.

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

References alloc_first_initialized_window(), build_pgmwd, close_menu_item, concatenate(), current_selection_menu_item, db_get_current_module_name(), db_get_current_workspace_name(), db_get_file_resource, edit_window, edited_file, file_name, EditedFile::filename, gpips_gtk_menu_item_set_label(), load_file(), MAXPATHLEN, NO_TEXTSW_AVAILABLE, prompt_user(), safe_system(), and SMALL_BUFFER_LENGTH.

Referenced by create_transform_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ enable_item()

void enable_item ( GtkWidget * item )

Definition at line 465 of file gtk_edit2.c.

                                    {
         gtk_widget_set_sensitive(GTK_WIDGET(item), TRUE);
 }

Referenced by enable_compile_selection(), enable_option_selection(), enable_transform_selection(), and enable_view_selection().

Here is the caller graph for this function:

◆ enable_view_selection()

void enable_view_selection ( )

Definition at line 509 of file gtk_edit2.c.

                              {
         apply_on_each_view_item(enable_item, enable_item);
 }

References apply_on_each_view_item(), and enable_item().

Referenced by enable_module_selection().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ execute_gpips_execute_and_display_something_outside_the_notifier()

void execute_gpips_execute_and_display_something_outside_the_notifier ( )

To execute something and display some Pips output with gpips, called outside the notifyer:

Execute the needed method:

Definition at line 367 of file gtk_edit2.c.

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

References display_memory_usage(), execute_gpips_execute_and_display_something_outside_the_notifyer_menu_line, and gpips_view_menu_layout_line_s::method_function_to_use.

Referenced by gpips_main_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gpips_display_graph_file_display()

void gpips_display_graph_file_display ( gpips_view_menu_layout_line * menu_line )

Use daVinci to display a graph information:

Preprocess the graph to be understandable by daVinci :

Definition at line 329 of file gtk_edit2.c.

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

References build_view_file(), file_name, free(), gpips_view_menu_layout_line_s::resource_name_to_view, safe_system(), SMALL_BUFFER_LENGTH, and user_log().

Here is the call graph for this function:

◆ gpips_display_plain_file()

void gpips_display_plain_file ( gpips_view_menu_layout_line * menu_line )

Use some text viewer to display the resource:

Definition at line 346 of file gtk_edit2.c.

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

References build_view_file(), db_get_current_module_name(), file_name, free(), gpips_file_view(), gpips_view_marked_busy(), gpips_view_menu_layout_line_s::icon_name, gpips_view_menu_layout_line_s::menu_entry_string, print_type(), gpips_view_menu_layout_line_s::resource_name_to_view, and SMALL_BUFFER_LENGTH.

Here is the call graph for this function:

◆ gpips_execute_and_display_something()

void gpips_execute_and_display_something ( char * resource_name )

To execute something and display some Pips output with gpips.

Translate the resource name in a menu entry descriptor:

Definition at line 388 of file gtk_edit2.c.

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

References db_get_current_module_name(), gpips_execute_and_display_something_outside_the_notifyer(), gpips_view_menu_layout, gpips_view_menu_layout_line_s::menu_entry_string, module_name(), pips_assert, prompt_user(), resource_name, and gpips_view_menu_layout_line_s::resource_name_to_view.

Here is the call graph for this function:

◆ gpips_execute_and_display_something_from_alias()

void gpips_execute_and_display_something_from_alias ( const char * alias_name )

To execute something and display some Pips output with gpips by knowing its alias:

Definition at line 410 of file gtk_edit2.c.

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

References db_get_current_module_name(), gpips_execute_and_display_something_outside_the_notifyer(), gpips_view_menu_layout, gpips_view_menu_layout_line_s::menu_entry_string, module_name(), pips_assert, and prompt_user().

Referenced by options_frame_to_view_menu_gateway(), and view_notify().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gpips_execute_and_display_something_outside_the_notifyer()

void gpips_execute_and_display_something_outside_the_notifyer ( gpips_view_menu_layout_line * menu_line )

Ask to execute the execute_gpips_execute_and_display_something_outside_the_notifyer():

I guess the function above does not return...

Definition at line 377 of file gtk_edit2.c.

                                                          {
         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... */
 }

References execute_gpips_execute_and_display_something_outside_the_notifyer_menu_line, execute_main_loop_command(), and GPIPS_EXECUTE_AND_DISPLAY.

Referenced by gpips_execute_and_display_something(), and gpips_execute_and_display_something_from_alias().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gpips_file_view()

void gpips_file_view	(	char *	file_name,
		const char *	title_module_name,
		char *	title_label,
		char *	icon_name,
		char *	icon_title
	)

Display a file in a gpips window:

Well, something got wrong...

Is there an available edit_textsw ? Ask for the same one allocated for gpips_view_marked_busy()

Display the file name and the module name. RK, 2/06/1993 :

Parameters

title_label	The module name for example
icon_name	"Sequential View" for exemple

Definition at line 271 of file gtk_edit2.c.

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

References alloc_first_initialized_window(), close_menu_item, compute_title_string(), concatenate(), current_selection_menu_item, display_memory_usage(), edit_window, edited_file, file_name, EditedFile::filename, gpips_gtk_menu_item_set_label(), load_file(), NO_TEXTSW_AVAILABLE, prompt_user(), and window_number.

Referenced by gpips_display_plain_file(), and notify_hpfc_file_view().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ gpips_view_marked_busy()

bool gpips_view_marked_busy	(	char *	title_module_name,
		char *	title_label,
		char *	icon_name,
		char *	icon_title
	)

Mark a gpips window as busy:

Is there an available edit_textsw ?

Display the file name and the module name. RK, 2/06/1993 :

Parameters

title_label	The module name for example
icon_name	"Sequential View" for exemple

Definition at line 242 of file gtk_edit2.c.

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

References alloc_first_initialized_window(), concatenate(), display_memory_usage(), edit_window, NO_TEXTSW_AVAILABLE, prompt_user(), SMALL_BUFFER_LENGTH, and window_number.

Referenced by gpips_display_plain_file().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ save_edited_file()

static void save_edited_file	(	GtkWidget *	widget,
		gpointer	file
	)

static

Definition at line 177 of file gtk_edit2.c.

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

References current_selection_menu_item, end, f(), fprintf(), and start.

Referenced by create_edit_window().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ view_notify()

void view_notify	(	GtkWidget *	menu_item,
		gpointer	data
	)

Translate the menu string in a resource name:

Definition at line 430 of file gtk_edit2.c.

                                                        {
         /* 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);
 }

References gpips_execute_and_display_something_from_alias(), and gpips_gtk_menu_item_get_label().

Referenced by create_edit_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ close_menu_item

GtkWidget * close_menu_item

static

Definition at line 88 of file gtk_edit2.c.

Referenced by apply_on_each_view_menu_item(), create_edit_menu(), edit_close_notify(), edit_notify(), and gpips_file_view().

◆ current_selection_menu_item

GtkWidget* current_selection_menu_item

static

Definition at line 88 of file gtk_edit2.c.

Referenced by apply_on_each_view_menu_item(), create_edit_menu(), edit_close_notify(), edit_notify(), gpips_file_view(), and save_edited_file().

◆ edit_menu_item

GtkWidget* edit_menu_item

Definition at line 90 of file gtk_edit2.c.

Referenced by create_transform_menu().

◆ edited_file

EditedFile edited_file[MAX_NUMBER_OF_GPIPS_WINDOWS]

static

Definition at line 85 of file gtk_edit2.c.

Referenced by alloc_first_initialized_window(), create_edit_window(), edit_close_notify(), edit_notify(), and gpips_file_view().

◆ execute_gpips_execute_and_display_something_outside_the_notifyer_menu_line

gpips_view_menu_layout_line* execute_gpips_execute_and_display_something_outside_the_notifyer_menu_line

static

Initial value:

=

NULL

To pass the view name to execute_gpips_execute_and_display_something_outside_the_notifyer():

Definition at line 98 of file gtk_edit2.c.

Referenced by execute_gpips_execute_and_display_something_outside_the_notifier(), and gpips_execute_and_display_something_outside_the_notifyer().

◆ gpips_view_menu_layout

gpips_view_menu_layout_line gpips_view_menu_layout[]

static

Initial value:

= {
                
                { NULL, NULL, NULL } }

lint

Include the label names:

Definition at line 73 of file gtk_edit2.c.

Referenced by create_edit_menu(), gpips_execute_and_display_something(), and gpips_execute_and_display_something_from_alias().

◆ number_of_gpips_windows

int number_of_gpips_windows = INITIAL_NUMBER_OF_GPIPS_WINDOWS

Definition at line 86 of file gtk_edit2.c.

Referenced by alloc_first_initialized_window(), current_selection_notify(), and quit_notify().

◆ sequential_view_menu_item

GtkWidget * sequential_view_menu_item

static

Definition at line 89 of file gtk_edit2.c.

Referenced by create_edit_menu().

◆ vcid_xv_edit2

char vcid_xv_edit2[]

Initial value:

=

"%A% ($Date: 1998/04/16 14:45:19 $, ) version $Revision: 12279 $, got on %D%, %T% [%P%].\n ï¿œcole des Mines de Paris Proprietary."

A% (

Date: 1998/04/16 14:45:19

, ) version

Revision: 12279

, got on D%, T% [P%].
Copyright (c) ï¿œcole des Mines de Paris Proprietary.

Definition at line 31 of file gtk_edit2.c.

◆ view_menu

GtkWidget* view_menu

The menu "View" on the main panel:

Definition at line 93 of file gtk_edit2.c.

Referenced by apply_on_each_view_item(), build_options_menu_and_panel(), create_edit_menu(), and synch_viewmenu_and_opframe().

◆ view_menu_item

GtkWidget * view_menu_item

Definition at line 93 of file gtk_edit2.c.

Referenced by build_options_menu_and_panel(), and create_edit_menu().

Data Structures

Functions

Variables

Function Documentation

◆ alloc_first_initialized_window()

◆ apply_on_each_options_frame_button()

◆ apply_on_each_view_item()

◆ apply_on_each_view_menu_item()

◆ buffer_changed_callback()

◆ compute_title_string()

◆ create_edit_menu()

◆ create_edit_window()

◆ current_selection_notify()

◆ disable_item()

◆ disable_view_selection()

◆ edit_close_notify()

◆ edit_notify()

◆ enable_item()

◆ enable_view_selection()

◆ execute_gpips_execute_and_display_something_outside_the_notifier()

◆ gpips_display_graph_file_display()

◆ gpips_display_plain_file()

◆ gpips_execute_and_display_something()

◆ gpips_execute_and_display_something_from_alias()

◆ gpips_execute_and_display_something_outside_the_notifyer()

◆ gpips_file_view()

◆ gpips_view_marked_busy()

◆ save_edited_file()

◆ view_notify()

Variable Documentation

◆ close_menu_item

◆ current_selection_menu_item

◆ edit_menu_item

◆ edited_file

◆ execute_gpips_execute_and_display_something_outside_the_notifyer_menu_line

◆ gpips_view_menu_layout

◆ number_of_gpips_windows

◆ sequential_view_menu_item

◆ vcid_xv_edit2

◆ view_menu

◆ view_menu_item