XdgCachedMenu::XdgCachedMenu(MenuCache* menuCache, QWidget* parent): QMenu(parent)
{
// qDebug() << "CREATE MENU FROM CACHE" << menuCache;
connect(this, SIGNAL(hovered(QAction*)), SLOT(onItemHovered(QAction*)));
MenuCacheDir* dir = menu_cache_get_root_dir(menuCache);
addMenuItems(this, dir);
}
XdgCachedMenu::XdgCachedMenu(MenuCache* menuCache, QWidget* parent): QMenu(parent)
{
// qDebug() << "CREATE MENU FROM CACHE" << menuCache;
MenuCacheDir* dir = menu_cache_get_root_dir(menuCache);
addMenuItems(this, dir);
connect(this, SIGNAL(aboutToShow()), SLOT(onAboutToShow()));
}
static void on_menu_cache_reload(MenuCache* mc, gpointer user_data)
{
g_return_if_fail(store);
gtk_tree_store_clear(store);
MenuCacheDir* dir = menu_cache_get_root_dir(menu_cache);
/* FIXME: preserve original selection */
if(dir)
add_menu_items(NULL, dir);
}
GtkWidget *fm_app_menu_view_new(void)
{
GtkWidget* view;
GtkTreeViewColumn* col;
GtkCellRenderer* render;
if(!store)
{
static GType menu_cache_item_type = 0;
if(G_UNLIKELY(!menu_cache_item_type))
menu_cache_item_type = g_boxed_type_register_static("MenuCacheItem",
(GBoxedCopyFunc)menu_cache_item_ref,
(GBoxedFreeFunc)menu_cache_item_unref);
store = gtk_tree_store_new(N_COLS, G_TYPE_ICON, /*GDK_TYPE_PIXBUF, */G_TYPE_STRING, menu_cache_item_type);
g_object_weak_ref(G_OBJECT(store), (GWeakNotify)destroy_store, NULL);
menu_cache = menu_cache_lookup("applications.menu");
if(menu_cache)
{
MenuCacheDir* dir = menu_cache_get_root_dir(menu_cache);
menu_cache_reload_notify = menu_cache_add_reload_notify(menu_cache, on_menu_cache_reload, NULL);
if(dir) /* content of menu is already loaded */
add_menu_items(NULL, dir);
}
}
else
g_object_ref(store);
view = gtk_tree_view_new_with_model((GtkTreeModel*)store);
render = gtk_cell_renderer_pixbuf_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, _("Installed Applications"));
gtk_tree_view_column_pack_start(col, render, FALSE);
gtk_tree_view_column_set_attributes(col, render, "gicon", COL_ICON, NULL);
render = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, render, TRUE);
gtk_tree_view_column_set_attributes(col, render, "text", COL_TITLE, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);
g_object_unref(store);
return view;
}
static void on_menu_cache_reload(gpointer mc, gpointer user_data)
#endif
{
g_return_if_fail(store);
gtk_tree_store_clear(store);
#if MENU_CACHE_CHECK_VERSION(0, 4, 0)
MenuCacheDir* dir = menu_cache_dup_root_dir(mc);
#else
MenuCacheDir* dir = menu_cache_get_root_dir(menu_cache);
#endif
/* FIXME: preserve original selection */
if(dir)
{
add_menu_items(NULL, dir);
#if MENU_CACHE_CHECK_VERSION(0, 4, 0)
menu_cache_item_unref(MENU_CACHE_ITEM(dir));
#endif
}
}
/****f* pekwm-menu/display_menu
* FUNCTION
* it begins and closes the menu content, write it into a file or
* display it.
*
* INPUTS
* * menu
* * file, the filename where the menu content should be written to.
* If file is 'NULL' then the menu content is displayed.
*
* RETURNS
* 1 if error, 0 otherwise
*
* NOTES
* A 16 KiB GString is allocated for the content of the pipemenu.
* This should be enough prevent too many allocations while building
* the XML.
*
* The size of the XML file created is around 8 KB in my computer but
* I don't have a lot of applications installed.
****/
gint
display_menu (MenuCache *menu, OB_Menu *context)
{
MenuCacheDir *dir = menu_cache_get_root_dir (menu);
if (G_UNLIKELY(dir == NULL))
{
g_warning ("Can't get menu root dir");
return 1;
}
GSList *l = menu_cache_dir_get_children (dir);
if (g_slist_length (l) != 0) {
context->builder = g_string_sized_new (16 * 1024);
g_string_append (context->builder,
"Dynamic {\n");
generate_pekwm_menu(dir, context);
g_string_append (context->builder, "}\n");
gchar *buff = g_string_free (context->builder, FALSE);
/* Has menu content to be saved in a file ? */
if (context->output)
{
if (!g_file_set_contents (context->output, buff, -1, NULL))
g_warning ("Can't write to %s\n", context->output);
else
g_message ("wrote to %s", context->output);
}
else /* No, so it's displayed on screen */
g_print ("%s", buff);
g_free (buff);
return 0;
}
else
{
g_warning ("Cannot create menu, check if the .menu file is correct");
return 1;
}
}
/**
* fm_app_menu_view_new
*
* Creates new application tree widget.
*
* Returns: (transfer full): a new widget.
*
* Since: 0.1.0
*/
GtkTreeView *fm_app_menu_view_new(void)
{
GtkTreeView* view;
GtkTreeViewColumn* col;
GtkCellRenderer* render;
if(!store)
{
static GType menu_cache_item_type = 0;
char* oldenv;
if(G_UNLIKELY(!menu_cache_item_type))
menu_cache_item_type = g_boxed_type_register_static("MenuCacheItem",
(GBoxedCopyFunc)menu_cache_item_ref,
(GBoxedFreeFunc)menu_cache_item_unref);
store = gtk_tree_store_new(N_COLS, G_TYPE_ICON, /*GDK_TYPE_PIXBUF, */G_TYPE_STRING, menu_cache_item_type);
g_object_weak_ref(G_OBJECT(store), destroy_store, NULL);
/* ensure that we're using lxmenu-data */
oldenv = g_strdup(g_getenv("XDG_MENU_PREFIX"));
g_setenv("XDG_MENU_PREFIX", "lxde-", TRUE);
menu_cache = menu_cache_lookup("applications.menu");
if(oldenv)
{
g_setenv("XDG_MENU_PREFIX", oldenv, TRUE);
g_free(oldenv);
}
else
g_unsetenv("XDG_MENU_PREFIX");
if(menu_cache)
{
#if MENU_CACHE_CHECK_VERSION(0, 4, 0)
MenuCacheDir* dir = menu_cache_dup_root_dir(menu_cache);
#else
MenuCacheDir* dir = menu_cache_get_root_dir(menu_cache);
#endif
menu_cache_reload_notify = menu_cache_add_reload_notify(menu_cache, on_menu_cache_reload, NULL);
if(dir) /* content of menu is already loaded */
{
add_menu_items(NULL, dir);
#if MENU_CACHE_CHECK_VERSION(0, 4, 0)
menu_cache_item_unref(MENU_CACHE_ITEM(dir));
#endif
}
}
}
else
g_object_ref(store);
view = (GtkTreeView*)gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
render = gtk_cell_renderer_pixbuf_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, _("Installed Applications"));
gtk_tree_view_column_pack_start(col, render, FALSE);
gtk_tree_view_column_set_attributes(col, render, "gicon", COL_ICON, NULL);
render = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(col, render, TRUE);
gtk_tree_view_column_set_attributes(col, render, "text", COL_TITLE, NULL);
gtk_tree_view_append_column(view, col);
g_object_unref(store);
return view;
}
/**
* fm_app_chooser_dlg_dup_selected_app
* @dlg: a widget
* @set_default: location to get value that was used for fm_app_chooser_dlg_new()
*
* Retrieves a currently selected application from @dlg.
*
* Before 1.0.0 this call had name fm_app_chooser_dlg_get_selected_app.
*
* Returns: (transfer full): selected application.
*
* Since: 0.1.0
*/
GAppInfo* fm_app_chooser_dlg_dup_selected_app(GtkDialog* dlg, gboolean* set_default)
{
GAppInfo* app = NULL;
AppChooserData* data = (AppChooserData*)g_object_get_qdata(G_OBJECT(dlg), fm_qdata_id);
switch( gtk_notebook_get_current_page(data->notebook) )
{
case 0: /* all applications */
app = fm_app_menu_view_dup_selected_app(data->apps_view);
break;
case 1: /* custom cmd line */
{
const char* cmdline = gtk_entry_get_text(data->cmdline);
const char* app_name = gtk_entry_get_text(data->app_name);
if(cmdline && cmdline[0])
{
char* _cmdline = NULL;
gboolean arg_found = FALSE;
char* bin1 = get_binary(cmdline, &arg_found);
g_debug("bin1 = %s", bin1);
/* see if command line contains %f, %F, %u, or %U. */
if(!arg_found) /* append %f if no %f, %F, %u, or %U was found. */
cmdline = _cmdline = g_strconcat(cmdline, " %f", NULL);
/* FIXME: is there any better way to do this? */
/* We need to ensure that no duplicated items are added */
if(data->mime_type)
{
MenuCache* menu_cache;
/* see if the command is already in the list of known apps for this mime-type */
GList* apps = g_app_info_get_all_for_type(fm_mime_type_get_type(data->mime_type));
GList* l;
for(l=apps;l;l=l->next)
{
GAppInfo* app2 = G_APP_INFO(l->data);
const char* cmd = g_app_info_get_commandline(app2);
char* bin2 = get_binary(cmd, NULL);
if(g_strcmp0(bin1, bin2) == 0)
{
app = G_APP_INFO(g_object_ref(app2));
g_debug("found in app list");
g_free(bin2);
break;
}
g_free(bin2);
}
g_list_foreach(apps, (GFunc)g_object_unref, NULL);
g_list_free(apps);
if(app)
goto _out;
/* see if this command can be found in menu cache */
menu_cache = menu_cache_lookup("applications.menu");
if(menu_cache)
{
#if MENU_CACHE_CHECK_VERSION(0, 4, 0)
MenuCacheDir *root_dir = menu_cache_dup_root_dir(menu_cache);
if(root_dir)
#else
if(menu_cache_get_root_dir(menu_cache))
#endif
{
GSList* all_apps = menu_cache_list_all_apps(menu_cache);
GSList* l;
for(l=all_apps;l;l=l->next)
{
MenuCacheApp* ma = MENU_CACHE_APP(l->data);
const char *exec = menu_cache_app_get_exec(ma);
char* bin2;
if (exec == NULL)
{
g_warning("application %s has no Exec statement", menu_cache_item_get_id(MENU_CACHE_ITEM(ma)));
continue;
}
bin2 = get_binary(exec, NULL);
if(g_strcmp0(bin1, bin2) == 0)
{
app = G_APP_INFO(g_desktop_app_info_new(menu_cache_item_get_id(MENU_CACHE_ITEM(ma))));
g_debug("found in menu cache");
menu_cache_item_unref(MENU_CACHE_ITEM(ma));
g_free(bin2);
break;
}
menu_cache_item_unref(MENU_CACHE_ITEM(ma));
g_free(bin2);
}
g_slist_free(all_apps);
#if MENU_CACHE_CHECK_VERSION(0, 4, 0)
menu_cache_item_unref(MENU_CACHE_ITEM(root_dir));
#endif
}
menu_cache_unref(menu_cache);
}
if(app)
goto _out;
}
/* FIXME: g_app_info_create_from_commandline force the use of %f or %u, so this is not we need */
app = app_info_create_from_commandline(cmdline,
app_name ? app_name : "", bin1,
data->mime_type ? fm_mime_type_get_type(data->mime_type) : NULL,
gtk_toggle_button_get_active(data->use_terminal),
data->keep_open && gtk_toggle_button_get_active(data->keep_open));
_out:
g_free(bin1);
g_free(_cmdline);
}
}
break;
}
if(set_default)
*set_default = gtk_toggle_button_get_active(data->set_default);
return app;
}
/*********************************************************************
* ...
*
*
********************************************************************/
gboolean fm_file_info_job_run (FmJob *fmjob)
{
FmFileInfoJob *job = (FmFileInfoJob*) fmjob;
GError *err = NULL;
GList *l;
for (l = fm_list_peek_head_link (job->file_infos); !fm_job_is_cancelled (fmjob) && l; )
{
FmFileInfo *file_info = (FmFileInfo*) l->data;
GList *next = l->next;
job->current = file_info->path;
if (fm_path_is_native (file_info->path))
{
char *path_str = fm_path_to_str (file_info->path);
// FileInfo rework: new function for testing...
// this one is not cancellable and doesn't handle errors...
// if (!fm_file_info_job_get_info_for_native_file (FM_JOB (job), file_info, path_str, &err))
if (!fm_file_info_set_for_native_file (file_info, path_str))
{
//~ FmJobErrorAction act = fm_job_emit_error (FM_JOB(job), err, FM_JOB_ERROR_MILD);
//~
//~ g_error_free (err);
//~ err = NULL;
//~
//~ if (act == FM_JOB_RETRY)
//~ continue;
DEBUG ("fm_file_info_set_for_native_file: error reading %s\n", path_str);
next = l->next;
fm_list_delete_link (job->file_infos, l); // Also calls unref...
}
g_free (path_str);
}
else
{
GFile *gf;
if (fm_path_is_virtual (file_info->path))
{
// This is a xdg menu
if (fm_path_is_xdg_menu (file_info->path))
{
MenuCache *mc;
MenuCacheDir *dir;
char *path_str = fm_path_to_str (file_info->path);
char *menu_name = path_str + 5, ch;
char *dir_name;
while (*menu_name == '/')
++menu_name;
dir_name = menu_name;
while (*dir_name && *dir_name != '/')
++dir_name;
ch = *dir_name;
*dir_name = '\0';
menu_name = g_strconcat (menu_name, ".menu", NULL);
mc = menu_cache_lookup_sync (menu_name);
g_free (menu_name);
if (*dir_name && !(*dir_name == '/' && dir_name[1] == '\0'))
{
char *tmp = g_strconcat ("/",
menu_cache_item_get_id (MENU_CACHE_ITEM(menu_cache_get_root_dir (mc))),
dir_name, NULL);
dir = menu_cache_get_dir_from_path (mc, tmp);
g_free (tmp);
}
else
{
dir = menu_cache_get_root_dir (mc);
}
if (dir)
{
fm_file_info_set_from_menu_cache_item (file_info, (MenuCacheItem*) dir);
}
else
{
next = l->next;
fm_list_delete_link (job->file_infos, l); // Also calls unref...
}
g_free (path_str);
menu_cache_unref (mc);
l = l->next;
continue;
}
}
gf = fm_path_to_gfile (file_info->path);
if (!fm_file_info_job_get_info_for_gfile (FM_JOB (job), file_info, gf, &err))
{
FmJobErrorAction act = fm_job_emit_error (FM_JOB (job), err, FM_JOB_ERROR_MILD);
g_error_free (err);
err = NULL;
if (act == FM_JOB_RETRY)
continue;
next = l->next;
fm_list_delete_link (job->file_infos, l); // Also calls unref...
}
g_object_unref (gf);
}
l = next;
}
return TRUE;
}
