#include <sys/param.h>
#include <sys/stat.h>
#include "genC.h"
#include "misc.h"
#include "database.h"
#include "linear.h"
#include "ri.h"
#include "ri-util.h"
#include "pipsdbm.h"
#include <gtk/gtk.h>
#include "gpips.h"

Include dependency graph for directory_menu.c:

Macros
#define	MAXNAMELEN MAXNAMLEN
	lint More...

Enumerations
enum	{ MENU_PATH_DATA_HANDLER = 54829 , GPIPS_MAX_DIRECTORY_MENU_SIZE = 80 }

Functions
static GtkWidget *	directory_gen_pullright (GtkWidget *widget)

static void	generate_a_directory_menu_notify (GtkWidget *widget, gpointer data)

GtkWidget *	generate_a_directory_menu (char *directory)

Variables
char	vcid_directory_menu [] = "$Id: directory_menu.c 23065 2016-03-02 09:05:50Z coelho $"
	Generate a menu from the current directory to serve as a directory chooser. More...

Macro Definition Documentation

◆ MAXNAMELEN

#define MAXNAMELEN MAXNAMLEN

lint

To have SunOS 5.5 happy about MAXNAMELEN (in SunOS 4, it is already defined in sys/dirent.h): To have SunOS4 still working:

Definition at line 45 of file directory_menu.c.

Enumeration Type Documentation

◆ anonymous enum

anonymous enum

Enumerator
MENU_PATH_DATA_HANDLER
GPIPS_MAX_DIRECTORY_MENU_SIZE	Maximum size of the directory menu of the main frame:

Definition at line 61 of file directory_menu.c.

      {
         MENU_PATH_DATA_HANDLER = 54829,
         /* Maximum size of the directory menu of the main frame: */
         GPIPS_MAX_DIRECTORY_MENU_SIZE = 80
 };

Function Documentation

◆ directory_gen_pullright()

static GtkWidget* directory_gen_pullright ( GtkWidget * widget )

static

First get the parent directory name that is the title:

Build the new directory name:

Well, there is already a menu... we've been already here. Free it first:

Free the associated directory name:

Then initialize it with a new directory menu:

Definition at line 74 of file directory_menu.c.

                                                                {
         GtkWidget * parent_menu;
  
         parent_menu = gtk_widget_get_parent(widget);
  
         char directory[MAXNAMELEN + 1];
         const char * parent_directory;
  
         debug(2, "directory_gen_pullright", "widget = %#x (%s), parent = %#x\n",
                         widget, gpips_gtk_menu_item_get_label(GTK_WIDGET(GTK_MENU_ITEM(widget))), parent_menu);
  
         /* First get the parent directory name that is the title: */
         parent_directory = gtk_menu_get_title(GTK_MENU(parent_menu));
         debug(2, "directory_gen_pullright", " parent_directory = %s\n",
                         parent_directory);
  
         /* Build the new directory name: */
         (void) sprintf(directory, "%s/%s", parent_directory, gpips_gtk_menu_item_get_label(GTK_WIDGET(GTK_MENU_ITEM(widget))));
  
         if (gtk_menu_item_get_submenu(GTK_MENU_ITEM(widget)) != NULL) {
                 /* Well, there is already a menu... we've been already here.
                  Free it first: */
                 /* Free the associated directory name: */
                 GtkWidget * submenu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(widget));
                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(widget), NULL);
                 gtk_widget_destroy(submenu);
         }
  
         /* Then initialize it with a new directory menu: */
  
         return generate_a_directory_menu(directory);
 }

References debug(), generate_a_directory_menu(), gpips_gtk_menu_item_get_label(), and MAXNAMELEN.

Referenced by generate_a_directory_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_a_directory_menu()

GtkWidget* generate_a_directory_menu ( char * directory )

Get all the files in the directory:

Generate a corresponding entry for each file:

Skip the "." directory:

Since a menu item cannot be selected as an item, add an plain item with the same name. Not beautiful hack... :-(

And disable non-subdirectory entry:

Definition at line 124 of file directory_menu.c.

                                                         {
         gen_array_t file_list;
         int file_list_length;
         int return_code;
         int i;
  
         GtkWidget * menu;
  
         menu = gtk_menu_new();
         gtk_menu_set_title(GTK_MENU(menu), directory);
  
 //      menu = (Menu) xv_create((int) NULL, MENU,
 //      /* The string is *not* copied in MENU_TITLE_ITEM: */
 //      MENU_TITLE_ITEM, strdup(directory),
 //      /* and furthermore MENU_TITLE_ITEM is write
 //       only, so add the info somewhere else: */
 //      XV_KEY_DATA, MENU_PATH_DATA_HANDLER, strdup(directory),
 //      /* Add its own notifying procedure: */
 //      MENU_NOTIFY_PROC, generate_a_directory_menu_notify, NULL);
  
         pips_debug(2, "menu = %p (%s)\n", (void *) menu, directory);
  
         if (db_get_current_workspace_name()) {
                 GtkWidget * please_close = gtk_menu_item_new_with_label(
                                 "* Close the current workspace before changing directory *");
                 gtk_widget_set_sensitive(please_close, FALSE);
                 gtk_menu_append(GTK_MENU(menu), please_close);
                 pips_user_warning("Close the current workspace before changing "
                         "directory.\n");
         } else {
                 GtkWidget * file_item;
                 /* Get all the files in the directory: */
                 file_list = gen_array_make(0);
                 return_code = safe_list_files_in_directory(file_list, directory, ".*",
                                 directory_exists_p);
                 file_list_length = gen_array_nitems(file_list);
  
                 if (return_code == -1 || file_list_length == 0) {
                         file_item = gtk_menu_item_new_with_label(
                                         "* No file in this directory or cannot be open *");
                         gtk_widget_set_sensitive(file_item, FALSE);
                         gtk_menu_append(GTK_MENU(menu), file_item);
                 } else if (file_list_length > GPIPS_MAX_DIRECTORY_MENU_SIZE) {
                         file_item
                                         = gtk_menu_item_new_with_label(
                                                         "* Too many files. Type directly in the Directory line of the main panel *");
                         gtk_widget_set_sensitive(file_item, FALSE);
                         gtk_menu_append(GTK_MENU(menu), file_item);
                         user_warning("generate_a_directory_menu",
                                         "Too many files in the \"%s\" directory.\n", directory);
                 } else
                         /* Generate a corresponding entry for each file: */
                         for (i = 0; i < file_list_length; i++) {
                                 string file_name = gen_array_item(file_list, i);
                                 /* Skip the "." directory: */
                                 if (strcmp(file_name, ".") != 0) {
                                         struct stat buf;
                                         char complete_file_name[MAXNAMELEN + 1];
  
                                         file_item = gtk_menu_item_new_with_label(file_name);
                                         gtk_menu_append(GTK_MENU(menu), file_item);
  
                                         (void) sprintf(complete_file_name, "%s/%s", directory,
                                                         file_name);
                                         if (((stat(complete_file_name, &buf) == 0) && (buf.st_mode
                                                         & S_IFDIR))) {
                                                 /* Since a menu item cannot be selected as an item, add an
                                                  plain item with the same name. Not beautiful
                                                  hack... :-( */
                                                 gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_item),
                                                                 directory_gen_pullright(file_item));
                                                 g_signal_connect(G_OBJECT(file_item), "activate",
                                                                                         G_CALLBACK(generate_a_directory_menu_notify), NULL);
                                                 pips_debug(2, " file_item = %p (%s)\n",
                                                                 (void *) file_item, file_name);
                                         } else {
                                                 gtk_widget_set_sensitive(file_item, FALSE);
                                         }
                                         /* And disable non-subdirectory entry: */
                                 }
                         }
                 gen_array_full_free(file_list);
         }
         gtk_widget_show_all(menu);
         return menu;
 }

References buf, db_get_current_workspace_name(), directory_exists_p(), directory_gen_pullright(), file_name, gen_array_full_free(), gen_array_item(), gen_array_make(), gen_array_nitems(), generate_a_directory_menu_notify(), GPIPS_MAX_DIRECTORY_MENU_SIZE, MAXNAMELEN, pips_debug, pips_user_warning, safe_list_files_in_directory(), and user_warning.

Referenced by directory_gen_pullright(), and generate_directory_menu().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ generate_a_directory_menu_notify()

static void generate_a_directory_menu_notify	(	GtkWidget *	widget,
		gpointer	data
	)

static

Definition at line 107 of file directory_menu.c.

                                                                                 {
         GtkWidget * parent;
         const char * parent_path_name;
         const char * directory_name;
         char full_directory_name[MAXNAMELEN + 1];
         directory_name = gpips_gtk_menu_item_get_label(widget);
         parent = gtk_widget_get_parent(widget);
         if(parent == NULL || ! GTK_IS_MENU(parent))
                 parent_path_name = "";
         else
                 parent_path_name = gtk_menu_get_title(GTK_MENU(parent));
  
         (void) sprintf(full_directory_name, "%s/%s", parent_path_name,
                         directory_name);
         (void) end_directory_notify(full_directory_name);
 }