static void
create_menuitem_from_alias (GtkWidget *menu,
GMenuTreeAlias *alias)
{
GMenuTreeDirectory *src = gmenu_tree_alias_get_directory (alias);
switch (gmenu_tree_alias_get_aliased_item_type (alias)) {
case GMENU_TREE_ITEM_DIRECTORY: {
GMenuTreeDirectory *directory = gmenu_tree_alias_get_aliased_directory (alias);
create_submenu (menu,
directory,
src);
gmenu_tree_item_unref (directory);
break;
}
case GMENU_TREE_ITEM_ENTRY: {
GMenuTreeEntry *entry = gmenu_tree_alias_get_aliased_entry (alias);
create_menuitem (menu,
entry,
src);
gmenu_tree_item_unref (entry);
break;
}
default:
break;
}
gmenu_tree_item_unref (src);
}
/**
* shell_app_info_get_section:
*
* return name of section, that contain this application.
* Returns: (transfer full): section name
*/
char *
shell_app_info_get_section (ShellAppInfo *info)
{
char *name;
GMenuTreeDirectory *dir, *parent;
if (info->type != SHELL_APP_INFO_TYPE_ENTRY)
return NULL;
dir = gmenu_tree_item_get_parent ((GMenuTreeItem*)info->entry);
if (!dir)
return NULL;
parent = gmenu_tree_item_get_parent ((GMenuTreeItem*)dir);
if (!parent)
return NULL;
while (TRUE)
{
GMenuTreeDirectory *pparent = gmenu_tree_item_get_parent ((GMenuTreeItem*)parent);
if (!pparent)
break;
gmenu_tree_item_unref ((GMenuTreeItem*)dir);
dir = parent;
parent = pparent;
}
name = g_strdup (gmenu_tree_directory_get_name (dir));
gmenu_tree_item_unref ((GMenuTreeItem*)dir);
gmenu_tree_item_unref ((GMenuTreeItem*)parent);
return name;
}
static void
reload_menu (GnomeControlCenter *shell)
{
GError *error;
GMenuTreeDirectory *d;
GMenuTreeIter *iter;
GMenuTreeItemType next_type;
error = NULL;
if (!gmenu_tree_load_sync (shell->priv->menu_tree, &error))
{
g_warning ("Could not load control center menu: %s", error->message);
g_clear_error (&error);
return;
}
d = gmenu_tree_get_root_directory (shell->priv->menu_tree);
iter = gmenu_tree_directory_iter (d);
while ((next_type = gmenu_tree_iter_next (iter)) != GMENU_TREE_ITEM_INVALID)
{
if (next_type == GMENU_TREE_ITEM_DIRECTORY)
{
GMenuTreeDirectory *subdir;
const gchar *dir_name;
GMenuTreeIter *sub_iter;
GMenuTreeItemType sub_next_type;
subdir = gmenu_tree_iter_get_directory (iter);
dir_name = gmenu_tree_directory_get_name (subdir);
maybe_add_category_view (shell, dir_name);
/* add the items from this category to the model */
sub_iter = gmenu_tree_directory_iter (subdir);
while ((sub_next_type = gmenu_tree_iter_next (sub_iter)) != GMENU_TREE_ITEM_INVALID)
{
if (sub_next_type == GMENU_TREE_ITEM_ENTRY)
{
GMenuTreeEntry *item = gmenu_tree_iter_get_entry (sub_iter);
cc_shell_model_add_item (CC_SHELL_MODEL (shell->priv->store),
dir_name,
item);
gmenu_tree_item_unref (item);
}
}
gmenu_tree_iter_unref (sub_iter);
gmenu_tree_item_unref (subdir);
}
}
gmenu_tree_iter_unref (iter);
}
/**
* shell_app_system_get_sections:
*
* return names of sections in applications menu.
*
* Returns: (element-type utf8) (transfer full): List of Names
*/
GList *
shell_app_system_get_sections (ShellAppSystem *system)
{
GList *res = NULL;
GSList *i, *contents;
GMenuTreeDirectory *root;
root = gmenu_tree_get_root_directory (system->priv->apps_tree);
if (G_UNLIKELY (!root))
g_error ("applications.menu not found.");
contents = gmenu_tree_directory_get_contents (root);
for (i = contents; i; i = i->next)
{
GMenuTreeItem *item = i->data;
if (gmenu_tree_item_get_type (item) == GMENU_TREE_ITEM_DIRECTORY)
{
char *name = g_strdup (gmenu_tree_directory_get_name ((GMenuTreeDirectory*)item));
g_assert (name);
res = g_list_append (res, name);
}
gmenu_tree_item_unref (item);
}
g_slist_free (contents);
return res;
}
void
shell_app_info_unref (ShellAppInfo *info)
{
if (--info->refcount > 0)
return;
g_free (info->casefolded_name);
g_free (info->name_collation_key);
g_free (info->casefolded_description);
switch (info->type)
{
case SHELL_APP_INFO_TYPE_ENTRY:
gmenu_tree_item_unref (info->entry);
break;
case SHELL_APP_INFO_TYPE_DESKTOP_FILE:
g_key_file_free (info->keyfile);
g_free (info->keyfile_path);
break;
case SHELL_APP_INFO_TYPE_WINDOW:
g_object_unref (info->window);
g_free (info->window_id);
break;
}
g_slice_free (ShellAppInfo, info);
}
/*! \fn gboolean CDesktopAppChooser::m_DoModal(void)
\brief Desktop App Chooser runs in modal mode.
\return TRUE or FALSE
*/
gboolean CDesktopAppChooser::m_DoModal(void)
{
/* Sets a window modal or non-modal. */
gtk_window_set_modal(GTK_WINDOW(m_pWidgets[APPCHOOSER_GtkWindow_Main]), TRUE);
if( m_pwParent != NULL )
{
/* Dialog windows should be set transient for the main application window they were spawned from.
This allows window managers to e.g. keep the dialog on top of the main window, or center the
dialog over the main window. */
gtk_window_set_transient_for(GTK_WINDOW(m_pWidgets[APPCHOOSER_GtkWindow_Main]), GTK_WINDOW(m_pwParent));
/* Creates the GDK (windowing system) resources associated with a widget. */
gtk_widget_realize(m_pWidgets[APPCHOOSER_GtkWindow_Main]);
/* Sets hints about the window management functions to make available via buttons on the window frame. */
gdk_window_set_functions(m_pWidgets[APPCHOOSER_GtkWindow_Main]->window, (GdkWMFunction)(GDK_FUNC_CLOSE|GDK_FUNC_MOVE));
}
/* Show all widgets */
gtk_widget_show_all(m_pWidgets[APPCHOOSER_GtkWindow_Main]);
/* Start to run. */
gtk_main();
//-------------- When the modal is terminated, it must grab the current list store of the tree-view, else it will make a big big trouble!
/* To decrease the reference counter of the menu directory object. */
gmenu_tree_item_unref(m_RootDir);
/* To decrease the reference counter of the menu tree object. */
gmenu_tree_unref(m_MenuTree);
return TRUE;
}
void
_cinnamon_app_set_entry (CinnamonApp *app,
GMenuTreeEntry *entry)
{
if (app->entry != NULL)
gmenu_tree_item_unref (app->entry);
app->entry = gmenu_tree_item_ref (entry);
if (app->name_collation_key != NULL)
g_free (app->name_collation_key);
app->name_collation_key = g_utf8_collate_key (cinnamon_app_get_name (app), -1);
}
static void
create_header (GtkWidget *menu,
GMenuTreeHeader *header)
{
GMenuTreeDirectory *directory;
GtkWidget *menuitem;
directory = gmenu_tree_header_get_directory (header);
menuitem = create_submenu_entry (menu, directory);
gmenu_tree_item_unref (directory);
g_signal_connect (menuitem, "activate",
G_CALLBACK (gtk_false), NULL);
}
static void
reread_entries (ShellAppSystem *self,
GSList **cache,
GHashTable *unique,
GMenuTree *tree)
{
GMenuTreeDirectory *trunk;
trunk = gmenu_tree_get_root_directory (tree);
g_slist_foreach (*cache, (GFunc)shell_app_info_unref, NULL);
g_slist_free (*cache);
*cache = NULL;
*cache = gather_entries_recurse (self, *cache, unique, trunk);
gmenu_tree_item_unref (trunk);
}
static void
cinnamon_app_dispose (GObject *object)
{
CinnamonApp *app = CINNAMON_APP (object);
if (app->entry)
{
gmenu_tree_item_unref (app->entry);
app->entry = NULL;
}
if (app->running_state)
{
while (app->running_state->windows)
_cinnamon_app_remove_window (app, app->running_state->windows->data);
}
G_OBJECT_CLASS(cinnamon_app_parent_class)->dispose (object);
}
static GHashTable *
get_flattened_entries_from_tree (GMenuTree *tree)
{
GHashTable *table;
GMenuTreeDirectory *root;
table = g_hash_table_new_full (g_str_hash, g_str_equal,
(GDestroyNotify) NULL,
(GDestroyNotify) gmenu_tree_item_unref);
root = gmenu_tree_get_root_directory (tree);
if (root != NULL)
get_flattened_entries_recurse (root, table);
gmenu_tree_item_unref (root);
return table;
}
static GSList *
gather_entries_recurse (ShellAppSystem *monitor,
GSList *apps,
GHashTable *unique,
GMenuTreeDirectory *root)
{
GSList *contents;
GSList *iter;
contents = gmenu_tree_directory_get_contents (root);
for (iter = contents; iter; iter = iter->next)
{
GMenuTreeItem *item = iter->data;
switch (gmenu_tree_item_get_type (item))
{
case GMENU_TREE_ITEM_ENTRY:
{
ShellAppInfo *app = shell_app_info_new_from_tree_item (item);
if (!g_hash_table_lookup (unique, shell_app_info_get_id (app)))
{
apps = g_slist_prepend (apps, app);
g_hash_table_insert (unique, (char*)shell_app_info_get_id (app), app);
}
}
break;
case GMENU_TREE_ITEM_DIRECTORY:
{
GMenuTreeDirectory *dir = (GMenuTreeDirectory*)item;
apps = gather_entries_recurse (monitor, apps, unique, dir);
}
break;
default:
break;
}
gmenu_tree_item_unref (item);
}
g_slist_free (contents);
return apps;
}
static void
append_directory_path(GMenuTreeDirectory *directory,
GString *path)
{
GMenuTreeDirectory *parent;
parent = gmenu_tree_item_get_parent(GMENU_TREE_ITEM(directory));
if (!parent)
{
g_string_append_c(path, '/');
return;
}
append_directory_path(parent, path);
g_string_append(path, gmenu_tree_directory_get_name(directory));
g_string_append_c(path, '/');
gmenu_tree_item_unref(parent);
}
static void
get_flattened_entries_recurse (GMenuTreeDirectory *dir,
GHashTable *entry_set)
{
GMenuTreeIter *iter = gmenu_tree_directory_iter (dir);
GMenuTreeItemType next_type;
while ((next_type = gmenu_tree_iter_next (iter)) != GMENU_TREE_ITEM_INVALID)
{
gpointer item = NULL;
switch (next_type)
{
case GMENU_TREE_ITEM_ENTRY:
{
GMenuTreeEntry *entry;
item = entry = gmenu_tree_iter_get_entry (iter);
/* Key is owned by entry */
g_hash_table_replace (entry_set,
(char*)gmenu_tree_entry_get_desktop_file_id (entry),
gmenu_tree_item_ref (entry));
}
break;
case GMENU_TREE_ITEM_DIRECTORY:
{
item = gmenu_tree_iter_get_directory (iter);
get_flattened_entries_recurse ((GMenuTreeDirectory*)item, entry_set);
}
break;
default:
break;
}
if (item != NULL)
gmenu_tree_item_unref (item);
}
gmenu_tree_iter_unref (iter);
}
static void menu_tree_changed(GMenuTree *tree, gpointer user_data)
{
GMenuTreeDirectory *root = NULL;
GtkWidget *menuitem = NULL;
popup = gtk_menu_new();
gmenu_tree_load_sync(tree, NULL);
root = gmenu_tree_get_root_directory(tree);
if (root) {
traverse_directory(root, NULL);
gmenu_tree_item_unref(root);
root = NULL;
}
gtk_menu_shell_append(GTK_MENU_SHELL(popup), gtk_separator_menu_item_new());
menuitem = menu_item_new_with_icon_name_text("logout", _("Logout"));
gtk_menu_shell_append(GTK_MENU_SHELL(popup), menuitem);
g_object_connect(G_OBJECT(menuitem),
"signal::activate", G_CALLBACK(logout), NULL,
NULL);
}
static void
on_apps_tree_changed_cb (GMenuTree *tree,
gpointer user_data)
{
ShellAppSystem *self = SHELL_APP_SYSTEM (user_data);
GError *error = NULL;
GHashTable *new_apps;
GHashTableIter iter;
gpointer key, value;
GSList *removed_apps = NULL;
GSList *removed_node;
g_assert (tree == self->priv->apps_tree);
g_hash_table_remove_all (self->priv->visible_id_to_app);
g_slist_free_full (self->priv->known_vendor_prefixes, g_free);
self->priv->known_vendor_prefixes = NULL;
if (!gmenu_tree_load_sync (self->priv->apps_tree, &error))
{
if (error)
{
g_warning ("Failed to load apps: %s", error->message);
g_error_free (error);
}
else
{
g_warning ("Failed to load apps");
}
return;
}
new_apps = get_flattened_entries_from_tree (self->priv->apps_tree);
g_hash_table_iter_init (&iter, new_apps);
while (g_hash_table_iter_next (&iter, &key, &value))
{
const char *id = key;
GMenuTreeEntry *entry = value;
GMenuTreeEntry *old_entry;
char *prefix;
ShellApp *app;
prefix = get_prefix_for_entry (entry);
if (prefix != NULL
&& !g_slist_find_custom (self->priv->known_vendor_prefixes, prefix,
(GCompareFunc)g_strcmp0))
self->priv->known_vendor_prefixes = g_slist_append (self->priv->known_vendor_prefixes,
prefix);
else
g_free (prefix);
app = g_hash_table_lookup (self->priv->id_to_app, id);
if (app != NULL)
{
/* We hold a reference to the original entry temporarily,
* because otherwise the hash table would be referencing
* potentially free'd memory until we replace it below with
* the new data.
*/
old_entry = shell_app_get_tree_entry (app);
gmenu_tree_item_ref (old_entry);
_shell_app_set_entry (app, entry);
g_object_ref (app); /* Extra ref, removed in _replace below */
}
else
{
old_entry = NULL;
app = _shell_app_new (entry);
}
/* Note that "id" is owned by app->entry. Since we're always
* setting a new entry, even if the app already exists in the
* hash table we need to replace the key so that the new id
* string is pointed to.
*/
g_hash_table_replace (self->priv->id_to_app, (char*)id, app);
if (!gmenu_tree_entry_get_is_nodisplay_recurse (entry))
g_hash_table_replace (self->priv->visible_id_to_app, (char*)id, app);
if (old_entry)
gmenu_tree_item_unref (old_entry);
}
/* Now iterate over the apps again; we need to unreference any apps
* which have been removed. The JS code may still be holding a
* reference; that's fine.
*/
g_hash_table_iter_init (&iter, self->priv->id_to_app);
while (g_hash_table_iter_next (&iter, &key, &value))
{
const char *id = key;
if (!g_hash_table_lookup (new_apps, id))
removed_apps = g_slist_prepend (removed_apps, (char*)id);
}
for (removed_node = removed_apps; removed_node; removed_node = removed_node->next)
{
const char *id = removed_node->data;
g_hash_table_remove (self->priv->id_to_app, id);
}
g_slist_free (removed_apps);
g_hash_table_destroy (new_apps);
g_signal_emit (self, signals[INSTALLED_CHANGED], 0);
}
/*=============================================================================
* Main Function
*/
int main (int argc, char **argv)
{
int i;
char *xdgfile = NULL;
for (i = 1; i < argc; i++)
{
if ((strcmp (argv[i], "-h") == 0) || (strcmp (argv[i], "--help") == 0))
{
show_help ();
g_free (xdgfile);
return 0;
}
else if ((strcmp (argv[i], "--show-amount") == 0) ||
(strcmp (argv[i], "-a") == 0))
{
option_show_amount_of_entries = 1;
}
else if ((strcmp (argv[i], "--plain") == 0) ||
(strcmp (argv[i], "-p") == 0))
{
option_do_not_use_categories = 1;
}
else if (argv[i][0] != '-')
{
if (xdgfile != NULL) {
g_printf ("Unexpected amount of arguments.\n");
g_free (xdgfile);
return 1;
}
xdgfile = g_strdup (argv[i]);
}
else
{
g_printf ("Unknown argument: %s\n", argv[i]);
return 1;
}
}
if (xdgfile == NULL) {
show_help ();
g_free (xdgfile);
return 1;
}
FILE * file;
if (!(file = fopen(xdgfile, "r")))
{
g_printf ("Could not read file \"%s\".\n", xdgfile);
g_free (xdgfile);
return 2;
}
fclose(file);
GMenuTree *menuTree = gmenu_tree_lookup (xdgfile, GMENU_TREE_FLAGS_NONE );
GMenuTreeDirectory *rootDirectory = gmenu_tree_get_root_directory(menuTree);
g_printf ("<openbox_pipe_menu>\n");
g_printf ("<separator label=\"Menu XDG\" />\n");
process_directory(rootDirectory, 1);
gmenu_tree_item_unref (rootDirectory);
g_printf ("</openbox_pipe_menu>\n");
g_free (xdgfile);
return 0;
}
/*=============================================================================
* This function processes a directory entry and all it's child nodes
*/
void process_directory(GMenuTreeDirectory *directory, gboolean isRoot)
{
int hasSeparator = 0;
int hasMenu = 0;
GMenuTreeItemType entryType;
GSList *entryList = gmenu_tree_directory_get_contents (directory);
GSList *l;
if (option_do_not_use_categories == 00 && isRoot == 0 &&
g_slist_length(entryList) > 0)
{
hasMenu = 1;
if (option_show_amount_of_entries == 1)
{
g_printf(
"<menu id=\"xdg-menu-%s\" label=\"%s (%d)\">\n",
gmenu_tree_directory_get_name(directory),
gmenu_tree_directory_get_name(directory),
g_slist_length(entryList));
}
else
{
g_printf(
"<menu id=\"xdg-menu-%s\" label=\"%s\">\n",
gmenu_tree_directory_get_name(directory),
gmenu_tree_directory_get_name(directory));
}
}
for (l = entryList; l; l = l->next)
{
GMenuTreeItem *item = l->data;
entryType = gmenu_tree_item_get_type (GMENU_TREE_ITEM(item));
switch (entryType)
{
case GMENU_TREE_ITEM_DIRECTORY:
if (hasSeparator)
{
process_separator(GMENU_TREE_SEPARATOR(item));
hasSeparator = 0;
}
process_directory(GMENU_TREE_DIRECTORY(item), 0);
break;
case GMENU_TREE_ITEM_ENTRY:
if (hasSeparator)
{
process_separator(GMENU_TREE_SEPARATOR(item));
hasSeparator = 0;
}
process_entry(GMENU_TREE_ENTRY(item));
break;
case GMENU_TREE_ITEM_SEPARATOR:
hasSeparator = 1;
break;
}
gmenu_tree_item_unref (item);
}
if (hasMenu == 1)
{
g_printf("</menu>\n");
}
g_slist_free (entryList);
}
/*
* This function inherit from gnome-menus/util/test-menu-spec.c
*/
static void traverse_directory(GMenuTreeDirectory *dir, GtkWidget *parent)
{
GMenuTreeIter *iter = NULL;
GtkWidget *dir_submenu = parent ? gtk_menu_new() : NULL;
GtkWidget *entry_submenu = gtk_menu_new();
GIcon *icon = NULL;
const char *text = NULL;
GtkWidget *menuitem = NULL;
iter = gmenu_tree_directory_iter(dir);
while (TRUE) {
gpointer item = NULL;
switch (gmenu_tree_iter_next(iter)) {
case GMENU_TREE_ITEM_INVALID:
goto done;
case GMENU_TREE_ITEM_ENTRY:
item = gmenu_tree_iter_get_entry(iter);
GDesktopAppInfo *appinfo = gmenu_tree_entry_get_app_info((GMenuTreeEntry *)item);
icon = g_app_info_get_icon((GAppInfo *)appinfo);
text = g_app_info_get_display_name((GAppInfo *)appinfo);
menuitem = menu_item_new_with_icon_text(icon, text);
gtk_menu_shell_append(GTK_MENU_SHELL(entry_submenu), menuitem);
g_object_connect(G_OBJECT(menuitem),
"signal::activate", G_CALLBACK(menu_item_activate), appinfo,
NULL);
break;
case GMENU_TREE_ITEM_DIRECTORY:
item = gmenu_tree_iter_get_directory(iter);
icon = gmenu_tree_directory_get_icon((GMenuTreeDirectory *)item);
text = gmenu_tree_directory_get_name((GMenuTreeDirectory *)item);
menuitem = menu_item_new_with_icon_text(icon, text);
gtk_menu_shell_append(dir_submenu ?
GTK_MENU_SHELL(dir_submenu) :
GTK_MENU_SHELL(popup),
menuitem);
traverse_directory(item, menuitem);
break;
}
if (item) {
gmenu_tree_item_unref(item);
item = NULL;
}
continue;
done:
break;
}
if (parent) {
if (dir_submenu)
gtk_menu_item_set_submenu(GTK_MENU_ITEM(parent), dir_submenu);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(parent), entry_submenu);
}
if (iter) {
gmenu_tree_iter_unref(iter);
iter = NULL;
}
}
GSList* get_menu_data(gboolean show_search, gboolean show_run, gboolean show_places, gboolean show_logout, char* file_manager, char*logout)
{
/*FIXME... I'm leaking a bit of memory here */
Menu_list_item * dir_item;
GSList* data = NULL;
GMenuTree * menu_tree;
const char * menu_file[] = {"gnomecc.menu", "preferences.menu", "settings.menu", NULL};//
GMenuTreeDirectory *root;
int i;
if (!gnome_vfs_initialized())
gnome_vfs_init();
G_file_manager = file_manager;
menu_tree = gmenu_tree_lookup("applications.menu", GMENU_TREE_FLAGS_NONE);
if (menu_tree)
{
root = gmenu_tree_get_root_directory(menu_tree);
if (root)
{
fill_er_up(root, &data);
gmenu_tree_item_unref(root);
}
}
data = g_slist_prepend(data, get_blank());
data = g_slist_append(data, get_separator());
menu_tree = gmenu_tree_lookup("gnomecc.menu", GMENU_TREE_FLAGS_NONE);
if (menu_tree)
{
root = gmenu_tree_get_root_directory(menu_tree);
if (root)
{
dir_item = g_malloc(sizeof(Menu_list_item));
dir_item->item_type = MENU_ITEM_DIRECTORY;
dir_item->name = g_strdup("Control Centre");
dir_item->comment = g_strdup("Gnome Control Centre");
dir_item->null = NULL;
dir_item->sublist = NULL;
dir_item->icon = g_strdup("gnome-control-center");
data = g_slist_append(data, dir_item);
fill_er_up(root, &dir_item->sublist);
dir_item->sublist = g_slist_prepend(dir_item->sublist, get_blank());
dir_item->sublist = g_slist_append(dir_item->sublist, get_blank());
gmenu_tree_item_unref(root);
}
}
menu_tree = gmenu_tree_lookup("settings.menu", GMENU_TREE_FLAGS_NONE);
if (menu_tree)
{
root = gmenu_tree_get_root_directory(menu_tree);
if (root)
{
dir_item = g_malloc(sizeof(Menu_list_item));
dir_item->item_type = MENU_ITEM_DIRECTORY;
dir_item->name = g_strdup("Settings");
dir_item->comment = g_strdup("System Settings");
dir_item->sublist = NULL;
dir_item->null = NULL;
dir_item->icon = g_strdup("gnome-settings");
data = g_slist_append(data, dir_item);
fill_er_up(root, &dir_item->sublist);
dir_item->sublist = g_slist_prepend(dir_item->sublist, get_blank());
dir_item->sublist = g_slist_append(dir_item->sublist, get_blank());
gmenu_tree_item_unref(root);
}
}
data = g_slist_append(data, get_separator());
if (show_places)
{
dir_item = g_malloc(sizeof(Menu_list_item));
dir_item->item_type = MENU_ITEM_DIRECTORY;
dir_item->name = g_strdup("Places");
dir_item->icon = g_strdup("bookmark");
dir_item->comment = g_strdup("Your special places :-)");
dir_item->sublist = NULL;
dir_item->monitor = monitor_places;
data = g_slist_append(data, dir_item);
update_places(&dir_item->sublist, file_manager);
}
if (show_search)
{
dir_item = g_malloc(sizeof(Menu_list_item));
dir_item->item_type = MENU_ITEM_SEARCH;
dir_item->name = g_strdup("Find:");
dir_item->icon = g_strdup("stock_search");
dir_item->comment = g_strdup("Search");
dir_item->sublist = NULL;
dir_item->search_entry = NULL;
data = g_slist_append(data, dir_item);
}
if (show_run)
{
dir_item = g_malloc(sizeof(Menu_list_item));
dir_item->item_type = MENU_ITEM_RUN;
dir_item->name = g_strdup("Run:");
dir_item->icon = g_strdup("exec");
dir_item->comment = g_strdup("Run a program");
dir_item->sublist = NULL;
dir_item->search_entry = NULL;
data = g_slist_append(data, dir_item);
}
if (show_logout)
{
dir_item = g_malloc(sizeof(Menu_list_item));
dir_item->item_type = MENU_ITEM_ENTRY;
dir_item->name = g_strdup("Logout...");
dir_item->icon = g_strdup("gnome-logout");
dir_item->exec = g_strdup(logout);
dir_item->desktop = g_strdup("");
dir_item->comment = g_strdup("Logout and related activities.");
dir_item->sublist = NULL;
data = g_slist_append(data, dir_item);
}
data = g_slist_append(data, get_blank());
return data;
}
static GtkWidget *
populate_menu_from_directory (GtkWidget *menu,
GMenuTreeDirectory *directory)
{
GList *children;
gboolean add_separator;
GMenuTreeIter *iter;
GMenuTreeItemType next_type;
children = gtk_container_get_children (GTK_CONTAINER (menu));
add_separator = (children != NULL);
g_list_free (children);
iter = gmenu_tree_directory_iter (directory);
while ((next_type = gmenu_tree_iter_next (iter)) != GMENU_TREE_ITEM_INVALID) {
gpointer item = NULL;
if (add_separator ||
next_type == GMENU_TREE_ITEM_SEPARATOR) {
add_menu_separator (menu);
add_separator = FALSE;
}
switch (next_type) {
case GMENU_TREE_ITEM_DIRECTORY:
item = gmenu_tree_iter_get_directory (iter);
create_submenu (menu, item, NULL);
break;
case GMENU_TREE_ITEM_ENTRY:
item = gmenu_tree_iter_get_entry (iter);
create_menuitem (menu, item, NULL);
break;
case GMENU_TREE_ITEM_SEPARATOR :
/* already added */
break;
case GMENU_TREE_ITEM_ALIAS:
item = gmenu_tree_iter_get_alias (iter);
create_menuitem_from_alias (menu, item);
break;
case GMENU_TREE_ITEM_HEADER:
item = gmenu_tree_iter_get_header (iter);
create_header (menu, item);
break;
default:
break;
}
if (item)
gmenu_tree_item_unref (item);
}
gmenu_tree_iter_unref (iter);
return menu;
}
static void
fill_er_up(GMenuTreeDirectory *directory, GSList**p)
{
GSList* data = *p;
GSList *items;
GSList *tmp;
const char *path;
char *freeme;
freeme = make_path(directory);
if (!strcmp(freeme, "/"))
path = freeme;
else
path = freeme + 1;
items = gmenu_tree_directory_get_contents(directory);
tmp = items;
while (tmp != NULL)
{
GMenuTreeItem *item = tmp->data;
switch (gmenu_tree_item_get_type(item))
{
case GMENU_TREE_ITEM_ENTRY:
// print_entry (GMENU_TREE_ENTRY (item), path);
add_entry(GMENU_TREE_ENTRY(item), path, &data);
break;
case GMENU_TREE_ITEM_DIRECTORY:
{
Menu_list_item * dir_item;
dir_item = g_malloc(sizeof(Menu_list_item));
dir_item->item_type = MENU_ITEM_DIRECTORY;
dir_item->name = gmenu_tree_directory_get_name(item);
dir_item->desktop = gmenu_tree_directory_get_desktop_file_path(item);
dir_item->comment = NULL;
dir_item->null = NULL;
dir_item->comment = gmenu_tree_directory_get_comment(item);
dir_item->icon = gmenu_tree_directory_get_icon(item);
dir_item->sublist = NULL;
data = g_slist_append(data, dir_item);
fill_er_up(GMENU_TREE_DIRECTORY(item), &dir_item->sublist);
dir_item->sublist = g_slist_prepend(dir_item->sublist, get_blank());
dir_item->sublist = g_slist_append(dir_item->sublist, get_blank());
}
break;
case GMENU_TREE_ITEM_HEADER:
// printf("GMENU_TREE_ITEM_HEADER\n");
break;
case GMENU_TREE_ITEM_SEPARATOR:
// printf("GMENU_TREE_ITEM_HEADER\n");
break;
case GMENU_TREE_ITEM_ALIAS:
// printf("GMENU_TREE_ITEM_ALIAS\n");
/* {
GMenuTreeItem *aliased_item;
aliased_item = gmenu_tree_alias_get_item (GMENU_TREE_ALIAS (item));
if (gmenu_tree_item_get_type (aliased_item) == GMENU_TREE_ITEM_ENTRY)
print_entry (GMENU_TREE_ENTRY (aliased_item), path);
}*/
break;
default:
g_assert_not_reached();
break;
}
gmenu_tree_item_unref(tmp->data);
tmp = tmp->next;
}
g_slist_free(items);
g_free(freeme);
*p = data;
}
static void
print_directory(GMenuTreeDirectory *directory)
{
GSList *items;
GSList *tmp;
const char *path;
char *freeme;
freeme = make_path(directory);
if (!strcmp(freeme, "/"))
path = freeme;
else
path = freeme + 1;
items = gmenu_tree_directory_get_contents(directory);
tmp = items;
while (tmp != NULL)
{
GMenuTreeItem *item = tmp->data;
switch (gmenu_tree_item_get_type(item))
{
case GMENU_TREE_ITEM_ENTRY:
print_entry(GMENU_TREE_ENTRY(item), path);
break;
case GMENU_TREE_ITEM_DIRECTORY:
print_directory(GMENU_TREE_DIRECTORY(item));
break;
case GMENU_TREE_ITEM_HEADER:
case GMENU_TREE_ITEM_SEPARATOR:
break;
case GMENU_TREE_ITEM_ALIAS:
{
GMenuTreeItem *aliased_item;
aliased_item = gmenu_tree_alias_get_item(GMENU_TREE_ALIAS(item));
if (gmenu_tree_item_get_type(aliased_item) == GMENU_TREE_ITEM_ENTRY)
print_entry(GMENU_TREE_ENTRY(aliased_item), path);
}
break;
default:
g_assert_not_reached();
break;
}
gmenu_tree_item_unref(tmp->data);
tmp = tmp->next;
}
g_slist_free(items);
g_free(freeme);
}
