static gboolean panel_show_caja_search_uri(GdkScreen* screen, const gchar* uri, guint32 timestamp, GError** error)
{
char* desktopfile = NULL;
GDesktopAppInfo* appinfo = NULL;
gboolean ret;
desktopfile = panel_g_lookup_in_applications_dirs("caja-folder-handler.desktop");
if (desktopfile)
{
appinfo = g_desktop_app_info_new_from_filename(desktopfile);
g_free(desktopfile);
}
if (!appinfo)
{
_panel_show_error_dialog (uri, screen, _("No application to handle search folders is installed."));
return FALSE;
}
ret = panel_app_info_launch_uri(appinfo, uri, screen, timestamp, error);
g_object_unref(appinfo);
return ret;
}
/* Allocator function */
static void stored_item_add(pqi inst, int id, int uses, const char* file, int tsec, int tusec)
{
psi ret;
GDesktopAppInfo* dai = g_desktop_app_info_new_from_filename(file);
if (!dai)
return;
ret = (psi)malloc(sizeof(stored_item));
ret->id = id;
ret->uses = uses;
ret->file = file;
ret->lastaccess = make_timestamp();
if (inst->items)
ret->prev = inst->lastitem,
inst->lastitem->next = ret,
inst->lastitem = ret;
else
inst->items = inst->lastitem = ret,
ret->prev = NULL;
ret->dfile = dai;
ret->next = NULL;
ret->lastaccess = (((long long)tsec << 32) | (long long)tusec);
ret->parent = inst;
}
void
LauncherApplication::setDesktopFile(const QString& desktop_file)
{
QString oldDesktopFile = this->desktop_file();
QByteArray byte_array = desktop_file.toUtf8();
gchar *file = byte_array.data();
if(desktop_file.startsWith("/")) {
/* It looks like a full path to a desktop file */
m_appInfo.reset((GAppInfo*)g_desktop_app_info_new_from_filename(file));
} else {
/* It might just be a desktop file name; let GIO look for the actual
desktop file for us */
/* The docs for g_desktop_app_info_new() says it respects "-" to "/"
substitution as per XDG Menu Spec, but it only seems to work for
exactly 1 substitution where as Wine programs often require many.
Bottom line: We must do some manual trial and error to find desktop
files in deeply nested directories.
Same workaround is implemented in Unity: plugins/unityshell/src/PlacesView.cpp:731
References:
https://bugzilla.gnome.org/show_bug.cgi?id=654566
https://bugs.launchpad.net/unity-2d/+bug/794471
*/
int slash_index;
do {
m_appInfo.reset((GAppInfo*)g_desktop_app_info_new(file));
slash_index = byte_array.indexOf("-");
if (slash_index == -1) {
break;
}
byte_array.replace(slash_index, 1, "/");
file = byte_array.data();
} while (m_appInfo.isNull());
}
/* setDesktopFile(…) may be called with the same desktop file, when e.g. the
contents of the file have changed. Some properties may have changed. */
QString newDesktopFile = this->desktop_file();
if (newDesktopFile != oldDesktopFile) {
Q_EMIT desktopFileChanged(newDesktopFile);
}
/* Emit the Changed signal on all properties that can depend on m_appInfo
m_application's properties take precedence over m_appInfo's
*/
if (m_appInfo != NULL) {
if (m_application == NULL) {
Q_EMIT nameChanged(name());
Q_EMIT iconChanged(icon());
}
Q_EMIT executableChanged(executable());
}
/* Update the list of static shortcuts
(quicklist entries defined in the desktop file). */
m_staticShortcuts.reset(indicator_desktop_shortcuts_new(newDesktopFile.toUtf8().constData(), "Unity"));
monitorDesktopFile(newDesktopFile);
}
/**
* pk_plugin_sqlite_add_filename_details:
**/
static gint
pk_plugin_sqlite_add_filename_details (PkPlugin *plugin,
const gchar *filename,
const gchar *package,
const gchar *md5)
{
gchar *statement;
gchar *error_msg = NULL;
sqlite3_stmt *sql_statement = NULL;
gint rc = -1;
gint show;
GDesktopAppInfo *info;
/* find out if we should show desktop file in menus */
info = g_desktop_app_info_new_from_filename (filename);
if (info == NULL) {
g_warning ("could not load desktop file %s", filename);
goto out;
}
show = g_app_info_should_show (G_APP_INFO (info));
g_object_unref (info);
g_debug ("add filename %s from %s with md5: %s (show: %i)",
filename, package, md5, show);
/* the row might already exist */
statement = g_strdup_printf ("DELETE FROM cache WHERE filename = '%s'",
filename);
sqlite3_exec (plugin->priv->db, statement, NULL, NULL, NULL);
g_free (statement);
/* prepare the query, as we don't escape it */
rc = sqlite3_prepare_v2 (plugin->priv->db,
"INSERT INTO cache (filename, package, show, md5) "
"VALUES (?, ?, ?, ?)",
-1, &sql_statement, NULL);
if (rc != SQLITE_OK) {
g_warning ("SQL failed to prepare: %s",
sqlite3_errmsg (plugin->priv->db));
goto out;
}
/* add data */
sqlite3_bind_text (sql_statement, 1, filename, -1, SQLITE_STATIC);
sqlite3_bind_text (sql_statement, 2, package, -1, SQLITE_STATIC);
sqlite3_bind_int (sql_statement, 3, show);
sqlite3_bind_text (sql_statement, 4, md5, -1, SQLITE_STATIC);
/* save this */
sqlite3_step (sql_statement);
rc = sqlite3_finalize (sql_statement);
if (rc != SQLITE_OK) {
g_warning ("SQL error: %s\n", error_msg);
sqlite3_free (error_msg);
goto out;
}
out:
return rc;
}
EphyWebApplication *
ephy_web_application_for_profile_directory (const char *profile_dir)
{
EphyWebApplication *app;
char *desktop_file_path;
const char *id;
GDesktopAppInfo *desktop_info;
const char *exec;
int argc;
char **argv;
GFile *file;
GFileInfo *file_info;
guint64 created;
GDate *date;
id = get_app_id_from_profile_directory (profile_dir);
if (!id)
return NULL;
app = g_new0 (EphyWebApplication, 1);
app->id = g_strdup (id);
app->desktop_file = get_app_desktop_filename (id);
desktop_file_path = g_build_filename (profile_dir, app->desktop_file, NULL);
desktop_info = g_desktop_app_info_new_from_filename (desktop_file_path);
if (!desktop_info) {
ephy_web_application_free (app);
g_free (desktop_file_path);
return NULL;
}
app->name = g_strdup (g_app_info_get_name (G_APP_INFO (desktop_info)));
app->icon_url = g_desktop_app_info_get_string (desktop_info, "Icon");
exec = g_app_info_get_commandline (G_APP_INFO (desktop_info));
if (g_shell_parse_argv (exec, &argc, &argv, NULL)) {
app->url = g_strdup (argv[argc - 1]);
g_strfreev (argv);
}
g_object_unref (desktop_info);
file = g_file_new_for_path (desktop_file_path);
/* FIXME: this should use TIME_CREATED but it does not seem to be working. */
file_info = g_file_query_info (file, G_FILE_ATTRIBUTE_TIME_MODIFIED, 0, NULL, NULL);
created = g_file_info_get_attribute_uint64 (file_info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
date = g_date_new ();
g_date_set_time_t (date, (time_t)created);
g_date_strftime (app->install_date, 127, "%x", date);
g_date_free (date);
g_object_unref (file);
g_object_unref (file_info);
g_free (desktop_file_path);
return app;
}
static GList*
fill_list_from_desktop_file (GList* app_list, const gchar *desktop_id)
{
GList* list = app_list;
GDesktopAppInfo* appinfo;
appinfo = g_desktop_app_info_new_from_filename (desktop_id);
if (appinfo != NULL) {
list = g_list_prepend (list, appinfo);
}
return list;
}
gboolean
panel_launch_desktop_file (const char *desktop_file,
GdkScreen *screen,
GError **error)
{
GDesktopAppInfo *appinfo;
gboolean retval;
g_return_val_if_fail (desktop_file != NULL, FALSE);
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
appinfo = NULL;
if (g_path_is_absolute (desktop_file))
appinfo = g_desktop_app_info_new_from_filename (desktop_file);
else {
char *full;
full = panel_g_lookup_in_applications_dirs (desktop_file);
if (full) {
appinfo = g_desktop_app_info_new_from_filename (full);
g_free (full);
}
}
if (appinfo == NULL)
return FALSE;
retval = panel_app_info_launch_uris (G_APP_INFO (appinfo), NULL, screen,
gtk_get_current_event_time (),
error);
g_object_unref (appinfo);
return retval;
}
void
ephy_web_application_setup_from_profile_directory (const char *profile_directory)
{
const char *program_name;
const char *id;
char *app_icon;
char *desktop_basename;
char *desktop_filename;
GDesktopAppInfo *desktop_info;
g_assert (profile_directory != NULL);
program_name = ephy_web_application_get_program_name_from_profile_directory (profile_directory);
if (!program_name)
exit (1);
g_set_prgname (program_name);
id = get_app_id_from_program_name (program_name);
if (!id)
exit (1);
/* Get display name from desktop file */
desktop_basename = get_app_desktop_filename (id);
desktop_filename = g_build_filename (profile_directory, desktop_basename, NULL);
desktop_info = g_desktop_app_info_new_from_filename (desktop_filename);
if (!desktop_info) {
g_warning ("Required desktop file not present at %s", desktop_filename);
exit (1);
}
g_set_application_name (g_app_info_get_name (G_APP_INFO (desktop_info)));
app_icon = g_build_filename (profile_directory, EPHY_WEB_APP_ICON_NAME, NULL);
gtk_window_set_default_icon_from_file (app_icon, NULL);
/* We need to re-set this because we have already parsed the
* options, which inits GTK+ and sets this as a side effect.
*/
gdk_set_program_class (program_name);
g_free (app_icon);
g_free (desktop_basename);
g_free (desktop_filename);
g_object_unref (desktop_info);
}
gboolean
dawati_netbook_launch_application_from_desktop_file (const gchar *desktop,
GList *files,
gint workspace,
gboolean no_chooser)
{
GAppInfo *app;
GAppLaunchContext *ctx;
GError *error = NULL;
gboolean retval = TRUE;
g_return_val_if_fail (desktop, FALSE);
app = G_APP_INFO (g_desktop_app_info_new_from_filename (desktop));
if (!app)
{
g_warning ("Failed to create GAppInfo for file %s", desktop);
return FALSE;
}
ctx = G_APP_LAUNCH_CONTEXT (gdk_app_launch_context_new ());
retval = g_app_info_launch (app, files, ctx, &error);
if (error)
{
g_warning ("Failed to lauch %s (%s)",
#if GLIB_CHECK_VERSION(2,20,0)
g_app_info_get_commandline (app),
#else
g_app_info_get_name (app),
#endif
error->message);
g_error_free (error);
}
g_object_unref (ctx);
g_object_unref (app);
return retval;
}
gboolean
gs_plugin_launch (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
const gchar *launch_name;
const gchar *launch_desktop;
g_autoptr(GAppInfo) info = NULL;
/* We can only launch apps we know of */
if (g_strcmp0 (gs_app_get_management_plugin (app), "snap") != 0)
return TRUE;
launch_name = gs_app_get_metadata_item (app, "snap::launch-name");
launch_desktop = gs_app_get_metadata_item (app, "snap::launch-desktop");
if (!launch_name)
return TRUE;
if (launch_desktop) {
info = (GAppInfo *)g_desktop_app_info_new_from_filename (launch_desktop);
} else {
g_autofree gchar *commandline = NULL;
GAppInfoCreateFlags flags = G_APP_INFO_CREATE_NONE;
if (g_strcmp0 (launch_name, gs_app_get_metadata_item (app, "snap::name")) == 0)
commandline = g_strdup_printf ("snap run %s", launch_name);
else
commandline = g_strdup_printf ("snap run %s.%s", gs_app_get_metadata_item (app, "snap::name"), launch_name);
if (!is_graphical (plugin, app, cancellable))
flags |= G_APP_INFO_CREATE_NEEDS_TERMINAL;
info = g_app_info_create_from_commandline (commandline, NULL, flags, error);
}
if (info == NULL)
return FALSE;
return g_app_info_launch (info, NULL, NULL, error);
}
GAppInfo *
problem_create_app_from_env (const char **envp,
pid_t pid)
{
GDesktopAppInfo *app;
guint i;
const char *desktop, *epid;
if (envp == NULL)
return NULL;
if (pid < 0)
return NULL;
desktop = epid = NULL;
for (i = 0; envp[i] != NULL; i++)
{
if (g_str_has_prefix (envp[i], GIO_LAUNCHED_DESKTOP_FILE_PREFIX))
desktop = envp[i] + strlen (GIO_LAUNCHED_DESKTOP_FILE_PREFIX);
else if (g_str_has_prefix (envp[i], GIO_LAUNCHED_DESKTOP_FILE_PID_PREFIX))
epid = envp[i] + strlen (GIO_LAUNCHED_DESKTOP_FILE_PID_PREFIX);
if (desktop && epid)
break;
}
if (!desktop || !epid)
return NULL;
/* Verify PID */
if (atoi (epid) != pid)
return NULL;
if (*desktop == '/')
app = g_desktop_app_info_new_from_filename (desktop);
else
app = g_desktop_app_info_new (desktop);
return (GAppInfo *) app;
}
/**
* fm_launch_desktop_entry
* @ctx: (allow-none): a launch context
* @file_or_id: a desktop entry to launch
* @uris: (element-type char *): files to use in run substitutions
* @launcher: #FmFileLauncher with callbacks
* @user_data: data supplied for callbacks
*
* Launches a desktop entry with optional files.
*
* Returns: %TRUE in case of success.
*
* Since: 0.1.0
*/
gboolean fm_launch_desktop_entry(GAppLaunchContext* ctx, const char* file_or_id, GList* uris, FmFileLauncher* launcher, gpointer user_data)
{
gboolean ret = FALSE;
GAppInfo* app;
gboolean is_absolute_path = g_path_is_absolute(file_or_id);
GList* _uris = NULL;
GError* err = NULL;
/* Let GDesktopAppInfo try first. */
if(is_absolute_path)
app = (GAppInfo*)g_desktop_app_info_new_from_filename(file_or_id);
else
app = (GAppInfo*)g_desktop_app_info_new(file_or_id);
/* we handle Type=Link in FmFileInfo so if GIO failed then
it cannot be launched in fact */
if(app) {
ret = fm_app_info_launch_uris(app, uris, ctx, &err);
g_object_unref(app);
}
else if (launcher->error)
g_set_error(&err, G_IO_ERROR, G_IO_ERROR_FAILED,
_("Invalid desktop entry file: '%s'"), file_or_id);
if(err)
{
if(launcher->error)
launcher->error(ctx, err, NULL, user_data);
g_error_free(err);
}
if(_uris)
{
g_list_foreach(_uris, (GFunc)g_free, NULL);
g_list_free(_uris);
}
return ret;
}
static VALUE
rg_s_new_from_filename(G_GNUC_UNUSED VALUE self, VALUE filename)
{
return GOBJ2RVAL_UNREF(g_desktop_app_info_new_from_filename(RVAL2CSTR(filename)));
}
void
caja_launch_desktop_file (GdkScreen *screen,
const char *desktop_file_uri,
const GList *parameter_uris,
GtkWindow *parent_window)
{
GError *error;
char *message, *desktop_file_path;
const GList *p;
GList *files;
int total, count;
GFile *file, *desktop_file;
GDesktopAppInfo *app_info;
GdkAppLaunchContext *context;
/* Don't allow command execution from remote locations
* to partially mitigate the security
* risk of executing arbitrary commands.
*/
desktop_file = g_file_new_for_uri (desktop_file_uri);
desktop_file_path = g_file_get_path (desktop_file);
if (!g_file_is_native (desktop_file))
{
g_free (desktop_file_path);
g_object_unref (desktop_file);
eel_show_error_dialog
(_("Sorry, but you cannot execute commands from "
"a remote site."),
_("This is disabled due to security considerations."),
parent_window);
return;
}
g_object_unref (desktop_file);
app_info = g_desktop_app_info_new_from_filename (desktop_file_path);
g_free (desktop_file_path);
if (app_info == NULL)
{
eel_show_error_dialog
(_("There was an error launching the application."),
NULL,
parent_window);
return;
}
/* count the number of uris with local paths */
count = 0;
total = g_list_length ((GList *) parameter_uris);
files = NULL;
for (p = parameter_uris; p != NULL; p = p->next)
{
file = g_file_new_for_uri ((const char *) p->data);
if (g_file_is_native (file))
{
count++;
}
files = g_list_prepend (files, file);
}
/* check if this app only supports local files */
if (g_app_info_supports_files (G_APP_INFO (app_info)) &&
!g_app_info_supports_uris (G_APP_INFO (app_info)) &&
parameter_uris != NULL)
{
if (count == 0)
{
/* all files are non-local */
eel_show_error_dialog
(_("This drop target only supports local files."),
_("To open non-local files copy them to a local folder and then"
" drop them again."),
parent_window);
g_list_free_full (files, g_object_unref);
g_object_unref (app_info);
return;
}
else if (count != total)
{
/* some files are non-local */
eel_show_warning_dialog
(_("This drop target only supports local files."),
_("To open non-local files copy them to a local folder and then"
" drop them again. The local files you dropped have already been opened."),
parent_window);
}
}
error = NULL;
context = gdk_app_launch_context_new ();
/* TODO: Ideally we should accept a timestamp here instead of using GDK_CURRENT_TIME */
gdk_app_launch_context_set_timestamp (context, GDK_CURRENT_TIME);
gdk_app_launch_context_set_screen (context,
gtk_window_get_screen (parent_window));
if (count == total)
{
/* All files are local, so we can use g_app_info_launch () with
* the file list we constructed before.
*/
g_app_info_launch (G_APP_INFO (app_info),
files,
G_APP_LAUNCH_CONTEXT (context),
&error);
}
else
{
/* Some files are non local, better use g_app_info_launch_uris ().
*/
g_app_info_launch_uris (G_APP_INFO (app_info),
(GList *) parameter_uris,
G_APP_LAUNCH_CONTEXT (context),
&error);
}
if (error != NULL)
{
message = g_strconcat (_("Details: "), error->message, NULL);
eel_show_error_dialog
(_("There was an error launching the application."),
message,
parent_window);
g_error_free (error);
g_free (message);
}
g_list_free_full (files, g_object_unref);
g_object_unref (context);
g_object_unref (app_info);
}
/* Builds up the menu for us */
static void
rebuild_items (DbusmenuMenuitem *root,
UsersServiceDbus *service)
{
DbusmenuMenuitem *mi = NULL;
DbusmenuMenuitem * guest_mi = NULL;
GList *u;
UserData *user;
gboolean can_activate;
gboolean can_lockscreen;
GList *children;
/* Make sure we have a valid GConf client, and build one
if needed */
ensure_gconf_client ();
/* Check to see which menu items we're allowed to have */
can_activate = users_service_dbus_can_activate_session (service) &&
!gconf_client_get_bool (gconf_client, LOCKDOWN_KEY_USER, NULL);
can_lockscreen = !gconf_client_get_bool (gconf_client, LOCKDOWN_KEY_SCREENSAVER, NULL);
/* Remove the old menu items if that makes sense */
children = dbusmenu_menuitem_take_children (root);
g_list_foreach (children, (GFunc)g_object_unref, NULL);
g_list_free (children);
/* Lock screen item */
if (can_lockscreen) {
lock_menuitem = dbusmenu_menuitem_new();
dbusmenu_menuitem_property_set(lock_menuitem, DBUSMENU_MENUITEM_PROP_LABEL, _("Lock Screen"));
gchar * shortcut = gconf_client_get_string(gconf_client, KEY_LOCK_SCREEN, NULL);
if (shortcut != NULL) {
g_debug("Lock screen shortcut: %s", shortcut);
dbusmenu_menuitem_property_set_shortcut_string(lock_menuitem, shortcut);
g_free(shortcut);
} else {
g_debug("Unable to get lock screen shortcut.");
}
g_signal_connect(G_OBJECT(lock_menuitem), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK(lock_screen), NULL);
dbusmenu_menuitem_child_append(root, lock_menuitem);
}
/* Set to NULL just incase we don't end up building one */
users_service_dbus_set_guest_item(service, NULL);
/* Build all of the user switching items */
if (can_activate == TRUE)
{
if (can_lockscreen) {
DbusmenuMenuitem * separator1 = dbusmenu_menuitem_new();
dbusmenu_menuitem_property_set(separator1, DBUSMENU_MENUITEM_PROP_TYPE, DBUSMENU_CLIENT_TYPES_SEPARATOR);
dbusmenu_menuitem_child_append(root, separator1);
}
if (check_guest_session ())
{
guest_mi = dbusmenu_menuitem_new ();
dbusmenu_menuitem_property_set (guest_mi, DBUSMENU_MENUITEM_PROP_TYPE, USER_ITEM_TYPE);
dbusmenu_menuitem_property_set (guest_mi, USER_ITEM_PROP_NAME, _("Guest Session"));
dbusmenu_menuitem_property_set_bool (guest_mi, USER_ITEM_PROP_LOGGED_IN, FALSE);
dbusmenu_menuitem_child_append (root, guest_mi);
g_signal_connect (G_OBJECT (guest_mi), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK (activate_guest_session), service);
users_service_dbus_set_guest_item(service, guest_mi);
}
if (check_new_session ())
{
switch_menuitem = dbusmenu_menuitem_new ();
dbusmenu_menuitem_property_set (switch_menuitem, DBUSMENU_MENUITEM_PROP_TYPE, MENU_SWITCH_TYPE);
dbusmenu_menuitem_property_set (switch_menuitem, MENU_SWITCH_USER, g_get_user_name());
dbusmenu_menuitem_child_append (root, switch_menuitem);
g_signal_connect (G_OBJECT (switch_menuitem), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK (activate_new_session), NULL);
}
GList * users = NULL;
users = users_service_dbus_get_user_list (service);
guint user_count = g_list_length(users);
if (user_count > MINIMUM_USERS && user_count < MAXIMUM_USERS) {
users = g_list_sort (users, (GCompareFunc)compare_users_by_username);
}
for (u = users; u != NULL; u = g_list_next (u)) {
user = u->data;
user->service = service;
if (user->uid == getuid()) {
/* Hide me from the list */
continue;
}
if (g_strcmp0(user->user_name, "guest") == 0) {
/* Check to see if the guest has sessions and so therefore should
get a check mark. */
if (user->sessions != NULL) {
dbusmenu_menuitem_property_set_bool (guest_mi, USER_ITEM_PROP_LOGGED_IN, TRUE);
}
/* If we're showing user accounts, keep going through the list */
if (user_count > MINIMUM_USERS && user_count < MAXIMUM_USERS) {
continue;
}
/* If not, we can stop here */
break;
}
if (user_count > MINIMUM_USERS && user_count < MAXIMUM_USERS) {
mi = dbusmenu_menuitem_new ();
dbusmenu_menuitem_property_set (mi, DBUSMENU_MENUITEM_PROP_TYPE, USER_ITEM_TYPE);
if (user->real_name_conflict) {
gchar * conflictedname = g_strdup_printf("%s (%s)", user->real_name, user->user_name);
dbusmenu_menuitem_property_set (mi, USER_ITEM_PROP_NAME, conflictedname);
g_free(conflictedname);
} else {
dbusmenu_menuitem_property_set (mi, USER_ITEM_PROP_NAME, user->real_name);
}
dbusmenu_menuitem_property_set_bool (mi, USER_ITEM_PROP_LOGGED_IN, user->sessions != NULL);
if (user->icon_url != NULL && user->icon_url[0] != '\0' && g_str_has_prefix(user->icon_url, "file://")) {
dbusmenu_menuitem_property_set(mi, USER_ITEM_PROP_ICON, user->icon_url + strlen("file://"));
} else {
dbusmenu_menuitem_property_set(mi, USER_ITEM_PROP_ICON, USER_ITEM_ICON_DEFAULT);
}
dbusmenu_menuitem_child_append (root, mi);
g_signal_connect (G_OBJECT (mi), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK (activate_user_session), user);
user->menuitem = mi;
}
}
g_list_free(users);
}
/* If there were a bunch of items before us, we need a
separator. */
if (can_lockscreen || can_activate) {
DbusmenuMenuitem * separator = dbusmenu_menuitem_new();
dbusmenu_menuitem_property_set(separator, DBUSMENU_MENUITEM_PROP_TYPE, DBUSMENU_CLIENT_TYPES_SEPARATOR);
dbusmenu_menuitem_child_append(root, separator);
}
/* Start going through the session based items. */
logout_mi = dbusmenu_menuitem_new();
if (supress_confirmations()) {
dbusmenu_menuitem_property_set(logout_mi, DBUSMENU_MENUITEM_PROP_LABEL, _("Log Out"));
} else {
dbusmenu_menuitem_property_set(logout_mi, DBUSMENU_MENUITEM_PROP_LABEL, _("Log Out\342\200\246"));
}
dbusmenu_menuitem_property_set_bool(logout_mi, DBUSMENU_MENUITEM_PROP_VISIBLE, show_logout());
dbusmenu_menuitem_child_append(root, logout_mi);
g_signal_connect(G_OBJECT(logout_mi), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK(show_dialog), "logout");
if (can_suspend && allow_suspend) {
suspend_mi = dbusmenu_menuitem_new();
dbusmenu_menuitem_property_set(suspend_mi, DBUSMENU_MENUITEM_PROP_LABEL, _("Suspend"));
dbusmenu_menuitem_child_append(root, suspend_mi);
g_signal_connect(G_OBJECT(suspend_mi), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK(machine_sleep), "Suspend");
}
if (can_hibernate && allow_hibernate) {
hibernate_mi = dbusmenu_menuitem_new();
dbusmenu_menuitem_property_set(hibernate_mi, DBUSMENU_MENUITEM_PROP_LABEL, _("Hibernate"));
dbusmenu_menuitem_child_append(root, hibernate_mi);
g_signal_connect(G_OBJECT(hibernate_mi), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK(machine_sleep), "Hibernate");
}
restart_mi = dbusmenu_menuitem_new();
dbusmenu_menuitem_property_set(restart_mi, DBUSMENU_MENUITEM_PROP_TYPE, RESTART_ITEM_TYPE);
if (supress_confirmations()) {
dbusmenu_menuitem_property_set(restart_mi, RESTART_ITEM_LABEL, _("Restart"));
} else {
dbusmenu_menuitem_property_set(restart_mi, RESTART_ITEM_LABEL, _("Restart\342\200\246"));
}
dbusmenu_menuitem_property_set_bool(restart_mi, DBUSMENU_MENUITEM_PROP_VISIBLE, show_restart());
dbusmenu_menuitem_child_append(root, restart_mi);
g_signal_connect(G_OBJECT(restart_mi), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK(show_dialog), "restart");
shutdown_mi = dbusmenu_menuitem_new();
if (supress_confirmations()) {
dbusmenu_menuitem_property_set(shutdown_mi, DBUSMENU_MENUITEM_PROP_LABEL, _("Shut Down"));
} else {
dbusmenu_menuitem_property_set(shutdown_mi, DBUSMENU_MENUITEM_PROP_LABEL, _("Shut Down\342\200\246"));
}
dbusmenu_menuitem_property_set_bool(shutdown_mi, DBUSMENU_MENUITEM_PROP_VISIBLE, show_shutdown());
dbusmenu_menuitem_child_append(root, shutdown_mi);
g_signal_connect(G_OBJECT(shutdown_mi), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK(show_dialog), "shutdown");
RestartShutdownLogoutMenuItems * restart_shutdown_logout_mi = g_new0 (RestartShutdownLogoutMenuItems, 1);
restart_shutdown_logout_mi->logout_mi = logout_mi;
restart_shutdown_logout_mi->restart_mi = restart_mi;
restart_shutdown_logout_mi->shutdown_mi = shutdown_mi;
update_menu_entries(restart_shutdown_logout_mi);
/* now add extra launchers */
GDir *extra_launchers_dir;
extra_launchers_dir = g_dir_open (EXTRA_LAUNCHER_DIR, 0, NULL);
if (extra_launchers_dir != NULL) {
GList * launchers = NULL;
/* Find all the desktop files we want to use */
for (;;) {
const gchar *extra_launcher_file;
extra_launcher_file = g_dir_read_name (extra_launchers_dir);
if (extra_launcher_file == NULL)
break;
if (!g_str_has_suffix (extra_launcher_file, ".desktop"))
continue;
gchar *full_path = g_build_filename (EXTRA_LAUNCHER_DIR, extra_launcher_file, NULL);
GAppInfo * appinfo = G_APP_INFO(g_desktop_app_info_new_from_filename (full_path));
g_free (full_path);
launchers = g_list_prepend(launchers, appinfo);
}
g_dir_close(extra_launchers_dir);
/* Sort the desktop files based on their names */
launchers = g_list_sort(launchers, sort_app_infos);
/* Turn each one into a separate menu item */
GList * launcher = NULL;
gboolean sepadded = FALSE;
for (launcher = launchers; launcher != NULL; launcher = g_list_next(launcher)) {
GAppInfo * appinfo = G_APP_INFO(launcher->data);
/* Make sure we have a separator */
if (!sepadded) {
DbusmenuMenuitem * separator = dbusmenu_menuitem_new();
dbusmenu_menuitem_property_set(separator, DBUSMENU_MENUITEM_PROP_TYPE, DBUSMENU_CLIENT_TYPES_SEPARATOR);
dbusmenu_menuitem_child_append(root, separator);
g_object_unref(separator);
sepadded = TRUE;
}
/* Build the item */
DbusmenuMenuitem * desktop_mi = dbusmenu_menuitem_new();
dbusmenu_menuitem_property_set(desktop_mi, DBUSMENU_MENUITEM_PROP_LABEL, g_app_info_get_name(appinfo));
g_signal_connect(G_OBJECT(desktop_mi), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED, G_CALLBACK(desktop_activate_cb), appinfo);
g_object_weak_ref(G_OBJECT(desktop_mi), (GWeakNotify)g_object_unref, appinfo);
/* Put into the menu */
dbusmenu_menuitem_child_append(root, desktop_mi);
}
g_list_free(launchers);
}
return;
}
static gboolean
activate_panel (GnomeControlCenter *shell,
const gchar *id,
const gchar **argv,
const gchar *desktop_file,
const gchar *name,
GIcon *gicon)
{
GDesktopAppInfo *appinfo;
GdkAppLaunchContext *context;
GdkScreen *screen;
GdkDisplay *display;
GError *error;
appinfo = g_desktop_app_info_new_from_filename (desktop_file);
screen = gtk_widget_get_screen (shell->priv->window);
display = gdk_screen_get_display (screen);
context = gdk_display_get_app_launch_context (display);
gdk_app_launch_context_set_screen (context, screen);
gdk_app_launch_context_set_timestamp (context, gtk_get_current_event_time ());
error = NULL;
g_app_info_launch_uris (G_APP_INFO (appinfo), NULL,
(GAppLaunchContext *) context,
&error);
if (error) {
g_printerr ("Could not launch '%s': %s\n", id, error->message);
g_clear_error (&error);
}
g_object_unref (context);
g_object_unref (appinfo);
#if 0
GnomeControlCenterPrivate *priv = shell->priv;
GType panel_type = G_TYPE_INVALID;
GList *panels, *l;
GtkWidget *box;
const gchar *icon_name;
/* check if there is an plugin that implements this panel */
panels = g_io_extension_point_get_extensions (priv->extension_point);
if (!desktop_file)
return FALSE;
if (!id)
return FALSE;
for (l = panels; l != NULL; l = l->next)
{
GIOExtension *extension;
const gchar *name;
extension = l->data;
name = g_io_extension_get_name (extension);
if (!g_strcmp0 (name, id))
{
panel_type = g_io_extension_get_type (extension);
break;
}
}
if (panel_type == G_TYPE_INVALID)
{
g_warning ("Could not find the loadable module for panel '%s'", id);
return FALSE;
}
/* create the panel plugin */
priv->current_panel = g_object_new (panel_type, "shell", shell, "argv", argv, NULL);
cc_shell_set_active_panel (CC_SHELL (shell), CC_PANEL (priv->current_panel));
gtk_widget_show (priv->current_panel);
gtk_lock_button_set_permission (GTK_LOCK_BUTTON (priv->lock_button),
cc_panel_get_permission (CC_PANEL (priv->current_panel)));
box = gtk_alignment_new (0, 0, 1, 1);
gtk_alignment_set_padding (GTK_ALIGNMENT (box), 6, 6, 6, 6);
gtk_container_add (GTK_CONTAINER (box), priv->current_panel);
gtk_widget_set_name (box, id);
notebook_add_page (priv->notebook, box);
/* switch to the new panel */
gtk_widget_show (box);
notebook_select_page (priv->notebook, box);
/* set the title of the window */
icon_name = get_icon_name_from_g_icon (gicon);
gtk_window_set_role (GTK_WINDOW (priv->window), id);
gtk_window_set_title (GTK_WINDOW (priv->window), name);
gtk_window_set_default_icon_name (icon_name);
gtk_window_set_icon_name (GTK_WINDOW (priv->window), icon_name);
priv->current_panel_box = box;
#endif
return TRUE;
}
static void
penge_app_tile_constructed (GObject *object)
{
PengeAppTilePrivate *priv = GET_PRIVATE (object);
GKeyFile *kf;
gchar *path;
GError *error = NULL;
gchar *name = NULL;
g_return_if_fail (priv->bookmark);
if (!priv->bookmark)
return;
priv->icon_theme = gtk_icon_theme_get_default ();
g_signal_connect (priv->icon_theme,
"changed",
(GCallback)_icon_theme_changed_cb,
object);
path = g_filename_from_uri (priv->bookmark, NULL, &error);
if (path)
{
priv->app_info = G_APP_INFO (g_desktop_app_info_new_from_filename (path));
kf = g_key_file_new ();
if (!g_key_file_load_from_file (kf,
path,
G_KEY_FILE_NONE,
&error))
{
g_warning (G_STRLOC ": Error getting a key file for path: %s",
error->message);
g_clear_error (&error);
} else {
name = g_key_file_get_locale_string (kf,
G_KEY_FILE_DESKTOP_GROUP,
"X-GNOME-FullName",
NULL,
NULL);
if (!name)
{
name = g_key_file_get_locale_string (kf,
G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_NAME,
NULL,
NULL);
}
mx_widget_set_tooltip_text (MX_WIDGET (object),
name);
g_free (name);
}
g_key_file_free (kf);
g_free (path);
}
if (error)
{
g_warning (G_STRLOC ": Error getting info from bookmark: %s",
error->message);
g_clear_error (&error);
}
_update_icon_from_icon_theme ((PengeAppTile *)object);
}
static DesktopEntryResultCode
desktop_entry_load (DesktopEntry *entry)
{
if (strstr (entry->path, "/menu-xdg/"))
return DESKTOP_ENTRY_LOAD_FAIL_OTHER;
if (entry->type == DESKTOP_ENTRY_DESKTOP)
{
GKeyFile *key_file = NULL;
DesktopEntryDesktop *entry_desktop = (DesktopEntryDesktop*)entry;
const char *categories_str;
entry_desktop->appinfo = g_desktop_app_info_new_from_filename (entry->path);
if (!G_IS_DESKTOP_APP_INFO (((DesktopEntryDesktop*)entry)->appinfo))
{
menu_verbose ("Failed to load \"%s\"\n", entry->path);
return DESKTOP_ENTRY_LOAD_FAIL_APPINFO;
}
categories_str = g_desktop_app_info_get_categories (entry_desktop->appinfo);
if (categories_str)
{
char **categories;
int i;
categories = g_strsplit (categories_str, ";", -1);
entry_desktop->categories = g_new0 (GQuark, g_strv_length (categories) + 1);
for (i = 0; categories[i]; i++)
entry_desktop->categories[i] = g_quark_from_string (categories[i]);
g_strfreev (categories);
}
key_file = g_key_file_new ();
if (!g_key_file_load_from_file (key_file, entry->path, 0, NULL))
entry_desktop->showin = TRUE;
else
entry_desktop->showin = key_file_get_show_in (key_file);
g_key_file_free (key_file);
return DESKTOP_ENTRY_LOAD_SUCCESS;
}
else if (entry->type == DESKTOP_ENTRY_DIRECTORY)
{
GKeyFile *key_file = NULL;
GError *error = NULL;
DesktopEntryResultCode rescode = DESKTOP_ENTRY_LOAD_SUCCESS;
key_file = g_key_file_new ();
if (!g_key_file_load_from_file (key_file, entry->path, 0, &error))
{
rescode = DESKTOP_ENTRY_LOAD_FAIL_OTHER;
goto out;
}
if (!desktop_entry_load_directory (entry, key_file, &error))
{
rescode = DESKTOP_ENTRY_LOAD_FAIL_OTHER;
goto out;
}
rescode = DESKTOP_ENTRY_LOAD_SUCCESS;
out:
g_key_file_free (key_file);
if (rescode == DESKTOP_ENTRY_LOAD_FAIL_OTHER)
{
if (error)
{
menu_verbose ("Failed to load \"%s\": %s\n", entry->path, error->message);
g_error_free (error);
}
else
menu_verbose ("Failed to load \"%s\"\n", entry->path);
}
return rescode;
}
else
g_assert_not_reached ();
return DESKTOP_ENTRY_LOAD_FAIL_OTHER;
}
/**
* shell_app_info_launch_full:
* @timestamp: Event timestamp, or 0 for current event timestamp
* @uris: List of uris to pass to application
* @workspace: Start on this workspace, or -1 for default
* @startup_id: (out): Returned startup notification ID, or %NULL if none
* @error: A #GError
*/
gboolean
shell_app_info_launch_full (ShellAppInfo *info,
guint timestamp,
GList *uris,
int workspace,
char **startup_id,
GError **error)
{
ShellApp *shell_app;
GDesktopAppInfo *gapp;
GdkAppLaunchContext *context;
gboolean ret;
ShellGlobal *global;
MetaScreen *screen;
if (startup_id)
*startup_id = NULL;
if (info->type == SHELL_APP_INFO_TYPE_WINDOW)
{
/* We can't pass URIs into a window; shouldn't hit this
* code path. If we do, fix the caller to disallow it.
*/
g_return_val_if_fail (uris == NULL, TRUE);
meta_window_activate (info->window, timestamp);
return TRUE;
}
else if (info->type == SHELL_APP_INFO_TYPE_ENTRY)
{
/* Can't use g_desktop_app_info_new, see bug 614879 */
const char *filename = gmenu_tree_entry_get_desktop_file_path ((GMenuTreeEntry *)info->entry);
gapp = g_desktop_app_info_new_from_filename (filename);
}
else
{
char *filename = shell_app_info_get_desktop_file_path (info);
gapp = g_desktop_app_info_new_from_filename (filename);
g_free (filename);
}
if (!gapp)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, "Not found");
return FALSE;
}
global = shell_global_get ();
screen = shell_global_get_screen (global);
if (timestamp == 0)
timestamp = clutter_get_current_event_time ();
if (workspace < 0)
workspace = meta_screen_get_active_workspace_index (screen);
context = gdk_app_launch_context_new ();
gdk_app_launch_context_set_timestamp (context, timestamp);
gdk_app_launch_context_set_desktop (context, workspace);
shell_app = shell_app_system_get_app (shell_app_system_get_default (),
shell_app_info_get_id (info));
/* In the case where we know an app, we handle reaping the child internally,
* in the window tracker.
*/
if (shell_app != NULL)
ret = g_desktop_app_info_launch_uris_as_manager (gapp, uris,
G_APP_LAUNCH_CONTEXT (context),
G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
NULL, NULL,
_gather_pid_callback, shell_app,
error);
else
ret = g_desktop_app_info_launch_uris_as_manager (gapp, uris,
G_APP_LAUNCH_CONTEXT (context),
G_SPAWN_SEARCH_PATH,
NULL, NULL,
NULL, NULL,
error);
g_object_unref (G_OBJECT (gapp));
return ret;
}
/**
* shell_app_info_launch_full:
* @timestamp: Event timestamp, or 0 for current event timestamp
* @uris: List of uris to pass to application
* @workspace: Start on this workspace, or -1 for default
* @startup_id: (out): Returned startup notification ID, or %NULL if none
* @error: A #GError
*/
gboolean
shell_app_info_launch_full (ShellAppInfo *info,
guint timestamp,
GList *uris,
int workspace,
char **startup_id,
GError **error)
{
GDesktopAppInfo *gapp;
char *filename;
GdkAppLaunchContext *context;
gboolean ret;
ShellGlobal *global;
MetaScreen *screen;
MetaDisplay *display;
if (startup_id)
*startup_id = NULL;
if (info->type == SHELL_APP_INFO_TYPE_WINDOW)
{
/* We can't pass URIs into a window; shouldn't hit this
* code path. If we do, fix the caller to disallow it.
*/
g_return_val_if_fail (uris == NULL, TRUE);
meta_window_activate (info->window, timestamp);
return TRUE;
}
else if (info->type == SHELL_APP_INFO_TYPE_ENTRY)
{
gapp = g_desktop_app_info_new (shell_app_info_get_id (info));
}
else
{
filename = shell_app_info_get_desktop_file_path (info);
gapp = g_desktop_app_info_new_from_filename (filename);
g_free (filename);
}
if (!gapp)
{
g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, "Not found");
return FALSE;
}
global = shell_global_get ();
screen = shell_global_get_screen (global);
display = meta_screen_get_display (screen);
if (timestamp == 0)
timestamp = clutter_get_current_event_time ();
if (workspace < 0)
workspace = meta_screen_get_active_workspace_index (screen);
context = gdk_app_launch_context_new ();
gdk_app_launch_context_set_timestamp (context, timestamp);
gdk_app_launch_context_set_desktop (context, workspace);
ret = g_app_info_launch (G_APP_INFO (gapp), uris, (GAppLaunchContext*) context, error);
g_object_unref (G_OBJECT (gapp));
return ret;
}
