gtk_status.c

Go to the documentation of this file.

/*
 
  $Id: gtk_status.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
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <unistd.h>
#include <sys/time.h>
#include <sys/resource.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 "ri.h"
#include "database.h"
 
#include "misc.h"
#include "ri-util.h"
#include "pipsdbm.h"
 
#include "gpips.h"
 
enum {
        DECALAGE_STATUS = 100
};
 
/* Max number of digits displayed in the status panel: */
enum {
        CPU_USAGE_LENGTH = 8
};
 
typedef struct {
        GtkWidget * label;
        GtkWidget * entry;
        GtkWidget * button;
} LabelEntryAndButton;
 
GtkWidget *directory_name_entry, *directory_name_entry_button;
GtkWidget *workspace_name_entry, *memory_name, *gmessage, *window_number;
GtkWidget *module_name_entry;
GtkWidget *cpu_usage_item;
 
//Server_image status_window_pips_image;
 
/* Strange, "man end" says that end is a function! */
extern char etext, edata, end;
 
void display_memory_usage() {
        char memory_string[17];
        char cpu_string[CPU_USAGE_LENGTH + 1];
        struct rusage an_rusage;
 
        /* etext, edata and end are only address symbols... */
        debug(6, "display_memory_usage",
                        "_text %#x, _data %#x, _end %#x, _brk %#x\n", &etext, &edata, &end,
                        sbrk(0));
 
        sprintf(memory_string, "%10.3f", ((intptr_t) sbrk(0) - (intptr_t) &etext)
                        / (double) (1 << 20));
 
        gtk_label_set_text(GTK_LABEL(memory_name), memory_string);
 
        if (getrusage(RUSAGE_SELF, &an_rusage) == 0) {
                double the_cpu_time = an_rusage.ru_utime.tv_sec
                                + an_rusage.ru_stime.tv_sec + (an_rusage.ru_utime.tv_usec
                                + an_rusage.ru_stime.tv_usec) * 1e-6;
                sprintf(cpu_string, "%*.*g", CPU_USAGE_LENGTH, CPU_USAGE_LENGTH - 2,
                                the_cpu_time);
        } else
                /* getrusage() failed: */
                sprintf(cpu_string, "%*s", CPU_USAGE_LENGTH, "?");
 
        gtk_label_set_text(GTK_LABEL(cpu_usage_item), cpu_string);
}
 
//void window_number_notify(Panel_item item, int value, Event *event) {
//      number_of_gpips_windows = (int) xv_get(item, PANEL_VALUE);
//
//      display_memory_usage();
//}
 
void show_directory() {
        gtk_entry_set_text(GTK_ENTRY(directory_name_entry), get_cwd());
        display_memory_usage();
}
 
void show_workspace() {
        static char *none = "(* none *)";
        char *name = db_get_current_workspace_name();
 
        if (name == NULL)
                name = none;
        //
        //      xv_set(workspace_name_entry, PANEL_VALUE, name, 0);
        display_memory_usage();
}
 
void show_module() {
        static char *none = "(* none *)";
        char *module_name_content = db_get_current_module_name();
 
        if (module_name_content == NULL)
                module_name_content = none;
        //
        //      xv_set(module_name_entry, PANEL_VALUE, module_name_content, 0);
        display_memory_usage();
}
 
void gpips_interrupt_button_blink() {
        //      if ((Server_image) xv_get(status_window_pips_image, PANEL_LABEL_IMAGE)
        //                      == gpips_negative_server_image)
        //              xv_set(status_window_pips_image, PANEL_LABEL_IMAGE,
        //                              gpips_positive_server_image, NULL);
        //      else
        //              xv_set(status_window_pips_image, PANEL_LABEL_IMAGE,
        //                              gpips_negative_server_image, NULL);
 
}
 
void gpips_interrupt_button_restore() {
        //      xv_set(status_window_pips_image, PANEL_LABEL_IMAGE,
        //                      gpips_positive_server_image, NULL);
}
 
void show_message(string message_buffer /*, ...*/) {
        /* va_list some_arguments;
         static char message_buffer[SMALL_BUFFER_LENGTH]; */
 
        /* va_start(some_arguments, a_printf_format); */
 
        /* (void) vsprintf(message_buffer, a_printf_format, some_arguments);*/
 
        //      xv_set(message, PANEL_VALUE, message_buffer, 0);
        display_memory_usage();
}
 
static void end_directory_notify_callback(GtkWidget * w, gpointer data __attribute__((unused))) {
        if (GTK_IS_ENTRY(w))
                end_directory_notify(gtk_entry_get_text(GTK_ENTRY(w)));
}
 
static void choose_dir_callback(GtkWidget * w __attribute__((unused)), gpointer data) {
        GtkWidget * file_chooser_dialog;
 
        file_chooser_dialog = gtk_file_chooser_dialog_new("Choose Directory",
                        GTK_WINDOW(main_window), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
                        GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN,
                        GTK_RESPONSE_ACCEPT, NULL);
 
        if (gtk_dialog_run(GTK_DIALOG(file_chooser_dialog)) == GTK_RESPONSE_ACCEPT) {
                char * dirname = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(
                                file_chooser_dialog));
                gtk_entry_set_text(GTK_ENTRY(directory_name_entry), dirname);
                g_free(dirname);
        }
        g_signal_emit_by_name(data, "activate");
        //end_directory_notify_callback((GtkWidget *) data, NULL);
 
        gtk_widget_destroy(file_chooser_dialog);
}
 
void open_or_create_workspace_callback(GtkWidget * w, gpointer data __attribute__((unused))) {
        //gtk_entry_set_text(GTK_ENTRY(workspace_name_entry), gtk_entry_get_text(query_entry)); TODO: FIX ICI pour transferer le workspace name du query_entry au workspace_enamer_entry
        open_or_create_workspace(gtk_entry_get_text(GTK_ENTRY(w)));
        return;
}
// crée dans la fenetre principale (dans la vbox en fait) un bloc
// Label : Entry [bouton] pour choisir un répertoire
// et quand un répertoire est choisi on applique "end_directory_notify" dessus
static GtkWidget * create_dir_choose_entry(GtkWidget * vbox) {
        GtkWidget * hbox = gtk_hbox_new(FALSE, 0);
 
        GtkWidget * label;
        GtkWidget * entry;
        GtkWidget * cd_button;
 
        label = gtk_label_new("Directory: ");
        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
 
        entry = gtk_entry_new();
        gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 5);
        g_signal_connect(GTK_OBJECT(entry), "activate",
                        G_CALLBACK(end_directory_notify_callback), NULL);
        gtk_widget_set_sensitive(entry, FALSE);
 
        cd_button = gtk_button_new_with_label("CD");
        gtk_box_pack_start(GTK_BOX(hbox), cd_button, FALSE, FALSE, 5);
        g_signal_connect(GTK_OBJECT(cd_button), "clicked", G_CALLBACK(choose_dir_callback),
                        entry);
 
        gtk_widget_show_all(hbox);
        gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, FALSE, 5);
        return entry;
}
 
static gboolean regenerate_workspace_menu_callback(GtkWidget * w,
                GdkEventButton * ev, gpointer data) {
        //GtkWidget * new_menu;
        GtkWidget * menu = (GtkWidget *) data;
 
        if (menu != NULL)
                gtk_menu_item_remove_submenu(GTK_MENU_ITEM(w));
 
        menu = generate_workspace_menu();
        gtk_menu_item_set_submenu(GTK_MENU_ITEM(w), menu);
 
        return FALSE;
}
 
static gboolean regenerate_module_menu_callback(GtkWidget * w,
                GdkEventButton * ev, gpointer data) {
        //GtkWidget * new_menu;
        GtkWidget * menu = (GtkWidget *) data;
 
        if (menu != NULL)
                gtk_menu_item_remove_submenu(GTK_MENU_ITEM(w));
 
        menu = generate_module_menu();
        gtk_menu_item_set_submenu(GTK_MENU_ITEM(w), menu);
 
        return FALSE;
}
 
// un bloc label / entry / menu, dans le menu la liste des actions possibles
// sur les workspace + la liste des workspace selon un algo a explorer
// entry "intelligente" (création ou ouverture de workspace)
static GtkWidget * create_workspace_entry(GtkWidget * vbox) {
        GtkWidget * hbox = gtk_hbox_new(FALSE, 0);
 
        GtkWidget * label;
        GtkWidget * entry;
        GtkWidget * menu;
        GtkWidget * menu_item;
        GtkWidget * menu_bar;
 
        label = gtk_label_new("Workspace: ");
        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
 
        entry = gtk_entry_new();
        gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 5);
        g_signal_connect(GTK_OBJECT(entry), "activate",
                        G_CALLBACK(open_or_create_workspace_callback), NULL);
 
        menu_item = gtk_menu_item_new_with_label("Workspace list");
        // regenerating the menu every time we try to access it
        menu = NULL; // (necessary initialization for the callback)
        g_signal_connect(G_OBJECT(menu_item), "button-press-event",
                        G_CALLBACK(regenerate_workspace_menu_callback), menu);
        gtk_widget_show(menu_item);
 
        menu_bar = gtk_menu_bar_new();
        gtk_box_pack_start(GTK_BOX(hbox), menu_bar, FALSE, FALSE, 0);
        gtk_menu_bar_append(GTK_MENU_BAR(menu_bar), menu_item);
        gtk_widget_show(menu_bar);
 
        gtk_widget_show_all(hbox);
        gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, FALSE, 5);
        return entry;
}
 
static GtkWidget * create_module_entry(GtkWidget * vbox) {
        GtkWidget * hbox = gtk_hbox_new(FALSE, 0);
 
        GtkWidget * label;
        GtkWidget * entry;
        GtkWidget * menu;
        GtkWidget * menu_item;
        GtkWidget * menu_bar;
 
        label = gtk_label_new("Module: ");
        gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
 
        entry = gtk_entry_new();
        gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 5);
        g_signal_connect(GTK_OBJECT(entry), "activate",
                        G_CALLBACK(end_select_module_callback), NULL);
 
        menu_item = gtk_menu_item_new_with_label("Select module");
        // regenerating the menu every time we try to access it
        menu = NULL; // (necessary initialization for the callback)
        g_signal_connect(G_OBJECT(menu_item), "button-press-event",
                        G_CALLBACK(regenerate_module_menu_callback), menu);
        gtk_widget_show(menu_item);
 
        menu_bar = gtk_menu_bar_new();
        gtk_box_pack_start(GTK_BOX(hbox), menu_bar, FALSE, FALSE, 0);
        gtk_menu_bar_append(GTK_MENU_BAR(menu_bar), menu_item);
        gtk_widget_show(menu_bar);
 
        gtk_widget_show_all(hbox);
        gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, FALSE, 5);
        return entry;
}
 
void create_status_subwindow() {
        //Server_image pips_icon_server_image;
        status_frame = gtk_frame_new(NULL);
        gtk_box_pack_start(GTK_BOX(main_window_vbox), status_frame, FALSE, FALSE, 5);
 
        GtkWidget * status_frame_vbox = gtk_vbox_new(FALSE, 0);
        gtk_container_add(GTK_CONTAINER(status_frame), status_frame_vbox);
 
        gmessage = gtk_label_new("Message:");
        gtk_box_pack_start(GTK_BOX(status_frame_vbox), gmessage, FALSE, FALSE, 5);
 
        directory_name_entry = create_dir_choose_entry(status_frame_vbox);
 
        workspace_name_entry = create_workspace_entry(status_frame_vbox);
 
        module_name_entry = create_module_entry(status_frame_vbox);
 
        GtkWidget * data_hbox = gtk_hbox_new(FALSE, 0);
        gtk_box_pack_start(GTK_BOX(status_frame_vbox), data_hbox, FALSE, FALSE, 5);
        gtk_box_pack_start(GTK_BOX(data_hbox), gtk_label_new("Memory (MB):"),
                        FALSE, FALSE, 5);
        memory_name = gtk_label_new("");
        gtk_box_pack_start(GTK_BOX(data_hbox), memory_name, FALSE, FALSE, 5);
        gtk_box_pack_start(GTK_BOX(data_hbox), gtk_label_new("CPU (s):"), FALSE,
                        FALSE, 5);
        cpu_usage_item = gtk_label_new("");
        gtk_box_pack_start(GTK_BOX(data_hbox), cpu_usage_item, FALSE, FALSE, 5);
        gtk_widget_show_all(data_hbox);
 
        //      window_number = xv_create(main_panel, PANEL_NUMERIC_TEXT,
        //      /*PANEL_ITEM_X_GAP, DECALAGE_STATUS,
        //       PANEL_VALUE_Y, xv_rows(main_panel, 4),*/
        //      PANEL_VALUE_X, xv_col(main_panel, 50), PANEL_VALUE_Y,
        //                      xv_rows(main_panel, 4), PANEL_LABEL_STRING, "# windows:",
        //                      PANEL_MIN_VALUE, 1, PANEL_MAX_VALUE, MAX_NUMBER_OF_GPIPS_WINDOWS,
        //                      PANEL_VALUE, number_of_gpips_windows, PANEL_VALUE_DISPLAY_LENGTH,
        //                      2, PANEL_NOTIFY_PROC, window_number_notify, NULL);
 
        //      pips_icon_server_image = create_status_window_pips_image();
 
        //      status_window_pips_image = xv_create(main_panel, PANEL_BUTTON,
        //                      PANEL_LABEL_IMAGE, pips_icon_server_image, PANEL_NOTIFY_PROC,
        //                      gpips_interrupt_pipsmake,
        //                      /* Put the Pixmap above the Help button: */
        //                      // quit_button a été remplacé par quit_menu_item
        //                      XV_X, xv_get(quit_button, XV_X) + (xv_get(quit_button, XV_WIDTH)
        //                                      - xv_get(pips_icon_server_image, XV_WIDTH)) / 2, XV_Y,
        //                      xv_rows(main_panel, 3) + 20, NULL);
 
        show_directory();
        show_workspace();
        show_module();
        display_memory_usage();
 
        gtk_widget_show_all(status_frame);
}