/**
* 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;
}
static GList *
xde_directory(MenuContext *ctx, GMenuTreeDirectory *dir)
{
GList *text = NULL;
const char *name, *path;
char *esc1, *esc2;
GIcon *gicon = NULL;
char *icon = NULL;
name = gmenu_tree_directory_get_name(dir);
esc1 = xde_character_escape(name, ')');
esc2 = xde_character_escape(name, '}');
if (ctx->stack)
gicon = gmenu_tree_directory_get_icon(ctx->stack->data);
if ((path = gmenu_tree_directory_get_desktop_file_path(dir))) {
GKeyFile *file = g_key_file_new();
g_key_file_load_from_file(file, path, G_KEY_FILE_NONE, NULL);
icon = xde_get_entry_icon(ctx, file, gicon, "folder", "unknown",
GET_ENTRY_ICON_FLAG_XPM | GET_ENTRY_ICON_FLAG_PNG);
g_key_file_unref(file);
} else
icon = xde_get_icon2(ctx, "folder", "unknown");
icon = ctx->wmm.wrap(ctx, icon);
text = g_list_append(text, g_strdup_printf("%s%s (%s) {%s Menu}%s\n", ctx->indent, "[submenu]", esc1, esc2, icon));
text = g_list_concat(text, ctx->wmm.ops.menu(ctx, dir));
text = g_list_append(text, g_strdup_printf("%s[end]\n", ctx->indent));
free(icon);
free(esc1);
free(esc2);
return (text);
}
static GList *
xde_directory(MenuContext *ctx, GMenuTreeDirectory *dir)
{
GList *text = NULL;
const char *name;
char *esc1, *qname, *s;
name = gmenu_tree_directory_get_name(dir);
esc1 = xde_character_escape(name, '"');
qname = g_strdup_printf("\"%s\"", esc1);
s = g_strdup_printf("\nMenu \"%s\" twm_MenuColor\n{\n", esc1);
text = g_list_append(text, s);
s = g_strdup_printf(" %-32s %s\n", qname, "f.title");
text = g_list_append(text, s);
text = g_list_concat(text, ctx->wmm.ops.menu(ctx, dir));
s = g_strdup_printf("}\n");
text = g_list_append(text, s);
ctx->wmm.output = g_list_concat(ctx->wmm.output, text);
text = NULL;
s = g_strdup_printf(" %-32s f.menu \"%s\"\n", qname, esc1);
text = g_list_append(text, s);
g_free(qname);
free(esc1);
return (text);
}
static GList *
xde_appmenu(MenuContext *ctx, GList *entries, const char *name)
{
GMenuTreeDirectory *dir;
GList *text = NULL;
char *s, *esc, *qname;
if (!(dir = gmenu_tree_get_root_directory(ctx->tree))) {
EPRINTF("could not get root directory\n");
return (text);
}
if (!name)
name = gmenu_tree_directory_get_name(dir);
esc = xde_character_escape(name, '"');
s = g_strdup_printf("\nMenu \"%s\" twm_MenuColor\n", esc);
text = g_list_append(text, s);
s = strdup("{\n");
text = g_list_append(text, s);
qname = g_strdup_printf("\"%s\"", esc);
s = g_strdup_printf(" %-32s %s\n", qname, "f.title");
text = g_list_append(text, s);
text = g_list_concat(text, entries);
s = strdup("}\n");
text = g_list_append(text, s);
g_free(qname);
free(esc);
return (text);
}
static GtkWidget *
create_submenu_entry (GtkWidget *menu,
GMenuTreeDirectory *directory)
{
GtkWidget *menuitem;
gboolean force_categories_icon;
force_categories_icon = g_object_get_data (G_OBJECT (menu),
"panel-menu-force-icon-for-categories") != NULL;
if (force_categories_icon)
menuitem = panel_image_menu_item_new2 ();
else
menuitem = panel_image_menu_item_new ();
panel_load_menu_image_deferred (menuitem,
panel_menu_icon_get_size (),
gmenu_tree_directory_get_icon (directory),
NULL,
PANEL_ICON_FOLDER);
setup_menuitem (menuitem,
panel_menu_icon_get_size (),
NULL,
gmenu_tree_directory_get_name (directory));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
return menuitem;
}
/**
* 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 GList *
xde_create(MenuContext *ctx, Style style, const char *name)
{
GMenuTreeDirectory *dir;
GList *text = NULL;
GList *entries = NULL;
char *qname = NULL;
char *s;
ctx->wmm.output = NULL;
s = g_strdup_printf("%s\n", "changequote(`[[[',`]]]')dnl");
ctx->wmm.output = g_list_append(ctx->wmm.output, s);
if (!(dir = gmenu_tree_get_root_directory(ctx->tree))) {
EPRINTF("could not get root directory\n");
return (text);
}
xde_reset_indent(ctx, 0);
xde_increase_indent(ctx);
entries = ctx->wmm.ops.menu(ctx, dir);
xde_decrease_indent(ctx);
if (!name)
name = gmenu_tree_directory_get_name(dir);
if (style == StyleFullmenu) {
text = ctx->wmm.wmmenu(ctx);
ctx->wmm.output = g_list_concat(ctx->wmm.output, text);
text = ctx->wmm.wmspec(ctx);
ctx->wmm.output = g_list_concat(ctx->wmm.output, text);
}
if (style == StyleAppmenu || style == StyleSubmenu) {
text = ctx->wmm.appmenu(ctx, entries, name);
}
if (style == StyleEntries) {
return (entries);
}
if (style == StyleSubmenu) {
qname = g_strdup_printf("\"%s\"", name);
s = g_strdup_printf(" %-32s f.menu \"%s\"\n", qname, name);
g_free(qname);
/* FIXME: free other entries */
entries = g_list_append(NULL, s);
}
if (style != StyleAppmenu) {
text = ctx->wmm.rootmenu(ctx, entries);
ctx->wmm.output = g_list_concat(ctx->wmm.output, text);
}
s = g_strdup_printf("\n%s\n", "changequote(`,)dnl");
text = g_list_append(ctx->wmm.output, s);
ctx->wmm.output = NULL;
return (text);
}
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);
}
void walk_tree(GMenuTreeDirectory *root)
{
GSList *list = gmenu_tree_directory_get_contents(root);
while (list)
{
const char *category;
const char *application;
const char *exec;
switch (gmenu_tree_item_get_type (list->data))
{
case GMENU_TREE_ITEM_DIRECTORY:
category = gmenu_tree_directory_get_name (list->data);
if (category)
{
printf("<menu name=\"%s\">\n", category);
free((void *)category);
}
GMenuTreeDirectory *dir = (GMenuTreeDirectory*)list->data;
walk_tree(dir);
printf("</menu>\n");
break;
case GMENU_TREE_ITEM_ENTRY:
if (!gmenu_tree_entry_get_is_excluded(list->data) &&
!gmenu_tree_entry_get_is_nodisplay(list->data))
{
application = gmenu_tree_entry_get_name(list->data);
if (application)
{
exec = filter(gmenu_tree_entry_get_exec(list->data));
if (exec)
{
if (gmenu_tree_entry_get_launch_in_terminal(list->data))
{
printf("<command name=\"%s\" execute=\"xterm -title '%s' -e '%s' &\" />\n", application, application, exec);
}
else
{
printf("<command name=\"%s\" execute=\"menuorg-execute-wrapper %s '%s'\" />\n", application, application, exec);
}
free((void *)application);
}
}
}
break;
default:
break;
}
list = g_slist_next(list);
}
}
static void write_dir( FILE* of, GMenuTreeDirectory* dir )
{
GSList* l;
const char* cstr;
char* str;
fprintf( of, "+%s\n", gmenu_tree_directory_get_menu_id( dir ) );
fprintf( of, "%s\n", gmenu_tree_directory_get_name( dir ) );
cstr = gmenu_tree_directory_get_comment( dir );
fprintf( of, "%s\n", cstr ? cstr : "" );
cstr = gmenu_tree_directory_get_icon( dir );
fprintf( of, "%s\n", cstr ? cstr : "" );
if( gmenu_tree_directory_get_desktop_file_path( dir ) )
{
/* get basename of its desktop file. */
str = g_path_get_basename( gmenu_tree_directory_get_desktop_file_path( dir ) );
fprintf( of, "%s\n", str );
g_free( str );
/* get the location of its desktop file. */
str = g_path_get_dirname( gmenu_tree_directory_get_desktop_file_path( dir ) );
fprintf( of, "%d\n", dirname_index( str ) );
g_free( str );
}
else
{
fprintf( of, "\n-1\n" );
}
// fprintf( of, "\n" ); /* end of item info */
for( l = gmenu_tree_directory_get_contents(dir); l; l = l->next )
{
GMenuTreeItem* item = (GMenuTreeItem*)l->data;
GMenuTreeItemType type = gmenu_tree_item_get_type(item);
if( type == GMENU_TREE_ITEM_DIRECTORY )
{
write_dir( of, (GMenuTreeDirectory*)item );
}
else if( type == GMENU_TREE_ITEM_ENTRY )
{
write_entry( of, (GMenuTreeEntry*)item );
}
else if( type == GMENU_TREE_ITEM_SEPARATOR )
fputs( "-\n", of );
}
fputs( "\n", of );
}
static GList *
xde_directory(MenuContext *ctx, GMenuTreeDirectory *dir)
{
GList *text = NULL;
const char *name, *path;
char *icon = NULL, *s;
GIcon *gicon = NULL;
char *esc;
int level;
name = gmenu_tree_directory_get_name(dir);
esc = g_markup_escape_text(name, -1);
if (ctx->stack)
gicon = gmenu_tree_directory_get_icon(ctx->stack->data);
if ((path = gmenu_tree_directory_get_desktop_file_path(dir))) {
GKeyFile *file = g_key_file_new();
g_key_file_load_from_file(file, path, G_KEY_FILE_NONE, NULL);
icon = xde_get_entry_icon(ctx, file, gicon, "folder", "unknown",
GET_ENTRY_ICON_FLAG_XPM | GET_ENTRY_ICON_FLAG_PNG |
GET_ENTRY_ICON_FLAG_JPG | GET_ENTRY_ICON_FLAG_SVG);
g_key_file_unref(file);
} else
icon = xde_get_icon2(ctx, "folder", "unknown");
icon = ctx->wmm.wrap(ctx, icon);
level = xde_reset_indent(ctx, 0);
s = g_strdup_printf("%s<menu id=\"%s Menu\" label=\"%s\"%s>\n", ctx->indent, esc, esc,
icon);
text = g_list_append(text, s);
text = g_list_concat(text, ctx->wmm.ops.menu(ctx, dir));
s = g_strdup_printf("%s</menu> <!-- %s Menu -->\n\n", ctx->indent, esc);
text = g_list_append(text, s);
level = xde_reset_indent(ctx, level);
ctx->wmm.output = g_list_concat(ctx->wmm.output, text);
s = g_strdup_printf("%s<menu id=\"%s Menu\" label=\"%s\"%s />\n", ctx->indent, esc, esc,
icon);
text = g_list_append(NULL, s);
free(icon);
g_free(esc);
return (text);
}
static GList *
xde_directory(MenuContext *ctx, GMenuTreeDirectory *dir)
{
GList *text = NULL;
const char *name;
char *esc1, *s;
name = gmenu_tree_directory_get_name(dir);
esc1 = xde_character_escape(name, '"');
s = g_strdup_printf("%s\"● %s\" MENU\n", ctx->indent, esc1);
text = g_list_append(text, s);
text = g_list_concat(text, ctx->wmm.ops.menu(ctx, dir));
s = g_strdup_printf("%s\"● %s\" END\n", ctx->indent, esc1);
text = g_list_append(text, s);
free(esc1);
return (text);
}
static GList *
xde_create(MenuContext *ctx, Style style, const char *name)
{
GMenuTreeDirectory *dir;
GList *text = NULL;
GList *entries = NULL;
char *s;
ctx->wmm.output = NULL;
s = g_strdup_printf("%s\n\n", "<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
ctx->wmm.output = g_list_append(ctx->wmm.output, s);
s = g_strdup_printf("%s\n\n", "<openbox_menu xmlns=\"http://openbox.org/3.4/menu\">");
ctx->wmm.output = g_list_append(ctx->wmm.output, s);
if (!(dir = gmenu_tree_get_root_directory(ctx->tree))) {
EPRINTF("could not get root directory\n");
return (text);
}
xde_reset_indent(ctx, 0);
xde_increase_indent(ctx);
entries = ctx->wmm.ops.menu(ctx, dir);
xde_decrease_indent(ctx);
switch(style) {
case StyleFullmenu:
default:
text = ctx->wmm.rootmenu(ctx, entries);
break;
case StyleAppmenu:
if (!name)
name = gmenu_tree_directory_get_name(dir);
text = ctx->wmm.appmenu(ctx, entries, name);
break;
case StyleEntries:
break;
}
text = g_list_concat(ctx->wmm.output, text);
ctx->wmm.output = NULL;
s = g_strdup_printf("\n%s\n", "</openbox_menu>");
text = g_list_append(text, s);
return (text);
}
/*! \fn gboolean CDesktopAppChooser::m_AddAppsMenuTopLevelNode(GMenuTreeDirectory *appsDir)
\brief To create top-level(Directory) nodes.
\param[in] appsDir.
\return TRUE or FALSE
*/
gboolean CDesktopAppChooser::m_AddAppsMenuTopLevelNode(GMenuTreeDirectory *appsDir)
{
GdkPixbuf *pixbuf = NULL;
/* To get PixelBuffer of the Directory icon. */
pixbuf = m_LoadIcon(gmenu_tree_directory_get_icon(appsDir), IMG_SIZE, TRUE );
/* To set the columns' content. */
gtk_tree_store_append(m_TreeStore, &m_TopLevelNodeIter, NULL);
gtk_tree_store_set(m_TreeStore, &m_TopLevelNodeIter,
COLUMN_ICON, pixbuf,
COLUMN_TEXT, gmenu_tree_directory_get_name(appsDir),
COLUMN_NODEDATA, NULL,
-1);
/* pixbuf has a referece count of "1" now, as the tree store has added its own reference.
So to decrease the reference count of pixbuf. */
g_object_unref(pixbuf);
return true;
}
static GList *
xde_header(MenuContext *ctx, GMenuTreeHeader *hdr)
{
GMenuTreeDirectory *dir;
GList *text = NULL;
char *s, *qname, *esc;
const char *name;
if (!(dir = gmenu_tree_header_get_directory(hdr)))
return (text);
name = gmenu_tree_directory_get_name(dir);
esc = xde_character_escape(name, '"');
qname = g_strdup_printf("\"%s\"", esc);
s = g_strdup_printf(" %-32s %s\n", qname, "f.title");
text = g_list_append(text, s);
text = g_list_concat(text, ctx->wmm.ops.directory(ctx, dir));
g_free(qname);
g_free(esc);
return (text);
}
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 GList *
xde_header(MenuContext *ctx, GMenuTreeHeader *hdr)
{
GMenuTreeDirectory *dir;
GList *text = NULL;
const char *name, *path;
GIcon *gicon = NULL;
char *icon = NULL, *s;
char *esc;
if (!(dir = gmenu_tree_header_get_directory(hdr)))
return (text);
name = gmenu_tree_directory_get_name(dir);
esc = g_markup_escape_text(name, -1);
if (ctx->stack)
gicon = gmenu_tree_directory_get_icon(ctx->stack->data);
if ((path = gmenu_tree_directory_get_desktop_file_path(dir))) {
GKeyFile *file = g_key_file_new();
g_key_file_load_from_file(file, path, G_KEY_FILE_NONE, NULL);
icon = xde_get_entry_icon(ctx, file, gicon, "folder", "unknown",
GET_ENTRY_ICON_FLAG_XPM | GET_ENTRY_ICON_FLAG_PNG |
GET_ENTRY_ICON_FLAG_JPG | GET_ENTRY_ICON_FLAG_SVG);
g_key_file_unref(file);
} else
icon = xde_get_icon2(ctx, "folder", "unknown");
icon = ctx->wmm.wrap(ctx, icon);
s = g_strdup_printf("%s<separator label=\"%s\"%s />\n", ctx->indent, esc, icon);
text = g_list_append(text, s);
free(icon);
g_free(esc);
text = g_list_concat(text, ctx->wmm.ops.directory(ctx, dir));
return (text);
}
/*
* 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;
}
}
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;
}
/*=============================================================================
* 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);
}
static void
create_menuitem (GtkWidget *menu,
GMenuTreeEntry *entry,
GMenuTreeDirectory *alias_directory)
{
GtkWidget *menuitem;
menuitem = panel_image_menu_item_new2 ();
if (alias_directory)
panel_load_menu_image_deferred (menuitem,
panel_menu_icon_get_size (),
gmenu_tree_directory_get_icon (alias_directory),
NULL,
NULL);
else
panel_load_menu_image_deferred (menuitem,
panel_menu_icon_get_size (),
g_app_info_get_icon (G_APP_INFO (gmenu_tree_entry_get_app_info (entry))),
NULL, NULL);
setup_menuitem (menuitem,
panel_menu_icon_get_size (),
NULL,
alias_directory ? gmenu_tree_directory_get_name (alias_directory) :
g_app_info_get_display_name (G_APP_INFO (gmenu_tree_entry_get_app_info (entry))));
if (alias_directory &&
gmenu_tree_directory_get_comment (alias_directory))
panel_util_set_tooltip_text (menuitem,
gmenu_tree_directory_get_comment (alias_directory));
else if (!alias_directory) {
const char *description = g_app_info_get_description (G_APP_INFO (gmenu_tree_entry_get_app_info (entry)));
if (!description)
description = g_desktop_app_info_get_generic_name (gmenu_tree_entry_get_app_info (entry));
if (description)
panel_util_set_tooltip_text (menuitem,
description);
}
g_signal_connect_after (menuitem, "button_press_event",
G_CALLBACK (menu_dummy_button_press_event), NULL);
if (!panel_lockdown_get_panels_locked_down_s ()) {
GIcon *icon;
static GtkTargetEntry menu_item_targets[] = {
{ "text/uri-list", 0, 0 }
};
gtk_drag_source_set (menuitem,
GDK_BUTTON1_MASK | GDK_BUTTON2_MASK,
menu_item_targets, 1,
GDK_ACTION_COPY);
icon = g_app_info_get_icon (G_APP_INFO (gmenu_tree_entry_get_app_info (entry)));
if (icon != NULL)
gtk_drag_source_set_icon_gicon (menuitem, icon);
g_signal_connect (G_OBJECT (menuitem), "drag_begin",
G_CALLBACK (drag_begin_menu_cb), NULL);
g_signal_connect (menuitem, "drag_data_get",
G_CALLBACK (drag_data_get_menu_cb), entry);
g_signal_connect (menuitem, "drag_end",
G_CALLBACK (drag_end_menu_cb), NULL);
}
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (activate_app_def), entry);
gtk_widget_show (menuitem);
}
int main() {
auto tree=gmenu_tree_new(menu_name, GMENU_TREE_FLAGS_NONE); //no need flags, defaults is good enough
{
char lang[locale_size]; //here we get system locale string
strcpy(lang,getenv("LANG"));
char* country=0; //and parse it to 3 strings - lang, country, modifier
char* modifier=0;
//char* enc=0; //it could be useful somewhere else. let it be commented
for(int i=0;lang[i];++i){
switch(lang[i]){
case '_':
lang[i]=0;
country=lang+i+1;
break;
case '@':
lang[i]=0;
modifier=lang+i+1;
break;
case '.':
lang[i]=0;
//enc=lang+i+1;
break;
}
}
{
int loc_i=0; //current locale index
if(*lang&&country&&modifier){
strcpy(locales[loc_i++]+4,(std::string("[")+lang+"_"+country+"@"+modifier+"]").c_str());
}
if(*lang&&country){
strcpy(locales[loc_i++]+4,(std::string("[")+lang+"_"+country+"]").c_str());
}
if(*lang&&modifier){
strcpy(locales[loc_i++]+4,(std::string("[")+lang+"@"+modifier+"]").c_str());
}
if(*lang){
strcpy(locales[loc_i++]+4,(std::string("[")+lang+"]").c_str());
}
locales[loc_i+1][0]=0; //barier to stop in case of buggy .desktop entry
}
}
while(!gmenu_tree_load_sync(tree,NULL)){ //wait for load
usleep(sync_wait_time);
}
qu.push(gmenu_tree_get_root_directory(tree)); //push root menu dir in queue
while(!qu.empty()){ //while queue not empty, create menu for first dir
auto& dir=qu.front();
{
const char* name=gmenu_tree_directory_get_menu_id(dir); //menu id used as unique fvwm menu suffix
printf("DestroyMenu \"FvwmMenu%s\"\n",name);
printf("AddToMenu \"FvwmMenu%s\"\n",name);
}
auto it=gmenu_tree_directory_iter(dir); //iterator
decltype(gmenu_tree_iter_next(it)) next_type; //iterator type
while ((next_type=gmenu_tree_iter_next(it))!=GMENU_TREE_ITEM_INVALID){
switch (next_type){
case GMENU_TREE_ITEM_DIRECTORY:{ //add directory function popup and queue it
auto cur=gmenu_tree_iter_get_directory(it);
printf("+ \"%s\" Popup \"FvwmMenu%s\"\n",
gmenu_tree_directory_get_name(cur),
gmenu_tree_directory_get_menu_id(cur));
qu.push(cur);
break;
}
case GMENU_TREE_ITEM_ENTRY:{
auto cur=gmenu_tree_iter_get_entry(it);
auto inf=gmenu_tree_entry_get_app_info(cur);
std::string exec=g_desktop_app_info_get_string(inf,"Exec"); //get exec command
int index;
while((index=exec.find('%'))!=-1){ //delete all % params
exec.erase(index,2);
}
int loc_i=0;
char* name=0;
do{ //find localised name in standard specified order
name=g_desktop_app_info_get_string(inf,locales[loc_i]);
++loc_i;
}while(!name&&locales[loc_i][0]);
if(name){ //if name not empty
printf("+ \"%s\" Exec exec %s\n",name,exec.c_str()); //add menu entry
}
break;
}
case GMENU_TREE_ITEM_SEPARATOR:{ //add empty menu entry
printf("+ \"\" Nop");
}
default:{ //TODO: add other types if needed
}
}
}
gmenu_tree_iter_unref(it); //unref iterator (dunno why, but why not?)
printf("\n"); //just for better readability
qu.pop();
}
return 0;
}
