AppMenuView::AppMenuView(QWidget* parent):
model_(new QStandardItemModel()),
menu_cache(NULL),
menu_cache_reload_notify(NULL),
QTreeView(parent) {
setHeaderHidden(true);
setSelectionMode(SingleSelection);
// initialize model
// TODO: share one model among all app menu view widgets
// ensure that we're using lxmenu-data (FIXME: should we do this?)
QByteArray oldenv = qgetenv("XDG_MENU_PREFIX");
qputenv("XDG_MENU_PREFIX", "lxde-");
menu_cache = menu_cache_lookup("applications.menu");
// if(!oldenv.isEmpty())
qputenv("XDG_MENU_PREFIX", oldenv); // restore the original value if needed
if(menu_cache) {
MenuCacheDir* dir = menu_cache_dup_root_dir(menu_cache);
menu_cache_reload_notify = menu_cache_add_reload_notify(menu_cache, _onMenuCacheReload, this);
if(dir) { /* content of menu is already loaded */
addMenuItems(NULL, dir);
menu_cache_item_unref(MENU_CACHE_ITEM(dir));
}
}
setModel(model_);
connect(selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)), SIGNAL(selectionChanged()));
selectionModel()->select(model_->index(0, 0), QItemSelectionModel::SelectCurrent);
}
void AppLinkProvider::update()
{
emit aboutToBeChanged();
QHash<QString, AppLinkItem*> newItems;
#ifdef HAVE_MENU_CACHE
// libmenu-cache is available, use it to get cached app list
GSList* apps = menu_cache_list_all_apps(mMenuCache);
for(GSList* l = apps; l; l = l->next)
{
MenuCacheApp* app = MENU_CACHE_APP(l->data);
AppLinkItem *item = new AppLinkItem(app);
AppLinkItem *prevItem = newItems[item->command()];
if(prevItem)
delete prevItem; // delete previous item;
newItems.insert(item->command(), item);
menu_cache_item_unref(MENU_CACHE_ITEM(app));
}
g_slist_free(apps);
#else
// use libqtxdg XdgMenu to get installed apps
doUpdate(mXdgMenu->xml().documentElement(), newItems);
#endif
{
QMutableListIterator<CommandProviderItem*> i(*this);
while (i.hasNext()) {
AppLinkItem *item = static_cast<AppLinkItem*>(i.next());
AppLinkItem *newItem = newItems.take(item->command());
if (newItem)
{
*(item) = *newItem; // Copy by value, not pointer!
// After the item is copied, the original "updateIcon" call queued
// on the newItem object is never called since the object iss going to
// be deleted. Hence we need to call it on the copied item manually.
// Otherwise the copied item will have no icon.
// FIXME: this is a dirty hack and it should be made cleaner later.
if(item->icon().isNull())
QMetaObject::invokeMethod(item, "updateIcon", Qt::QueuedConnection);
delete newItem;
}
else
{
i.remove();
delete item;
}
}
}
{
QHashIterator<QString, AppLinkItem*> i(newItems);
while (i.hasNext())
{
append(i.next().value());
}
}
emit changed();
}
void AppMenuView::onMenuCacheReload(MenuCache* mc) {
MenuCacheDir* dir = menu_cache_dup_root_dir(mc);
model_->clear();
/* FIXME: preserve original selection */
if(dir) {
addMenuItems(NULL, dir);
menu_cache_item_unref(MENU_CACHE_ITEM(dir));
selectionModel()->select(model_->index(0, 0), QItemSelectionModel::SelectCurrent);
}
}
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
}
}
/**
* 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;
}
XdgCachedMenuAction::~XdgCachedMenuAction()
{
if(item_)
menu_cache_item_unref(item_);
}