void
ol_player_chooser_set_info_by_state (OlPlayerChooser *window,
enum OlPlayerChooserState state)
{
ol_assert (OL_IS_PLAYER_CHOOSER (window));
OlPlayerChooserPrivate *priv = OL_PLAYER_CHOOSER_GET_PRIVATE (window);
_set_sensitive (window, TRUE);
switch (state)
{
case OL_PLAYER_CHOOSER_STATE_NO_PLAYER:
ol_player_chooser_set_info (window,
_("There is no supported player running"),
_("Please choose a player below to launch"));
ol_player_chooser_set_image_by_name (window, GTK_STOCK_DIALOG_INFO);
break;
case OL_PLAYER_CHOOSER_STATE_LAUNCH_FAIL: {
gchar *title = g_strdup_printf (_("Failed to connect to %s"),
g_app_info_get_name (priv->launch_app));
gchar *desc = g_strdup_printf (_("%s is not supported by OSD Lyrics, or not running. Please launch another player"),
g_app_info_get_name (priv->launch_app));
ol_player_chooser_set_info (window, title, desc);
ol_player_chooser_set_image_by_name (window, GTK_STOCK_DIALOG_ERROR);
g_free (title);
g_free (desc);
_set_launch_app (window, NULL);
break;
}
case OL_PLAYER_CHOOSER_STATE_CONNECTED:
gtk_widget_hide (GTK_WIDGET (window));
break;
default:
ol_errorf ("Unknown player chooser state %d\n", (int) state);
}
}
static int
sort_apps (gconstpointer one,
gconstpointer two,
gpointer user_data)
{
Application *a1, *a2;
a1 = g_object_get_qdata (G_OBJECT (one), application_quark ());
a2 = g_object_get_qdata (G_OBJECT (two), application_quark ());
return g_utf8_collate (g_app_info_get_name (a1->app_info),
g_app_info_get_name (a2->app_info));
}
static void
gtk_app_chooser_add_default (GtkAppChooserWidget *self,
GAppInfo *app)
{
GtkTreeIter iter;
GIcon *icon;
gchar *string;
gboolean unref_icon;
unref_icon = FALSE;
string = g_strdup_printf ("<b>%s</b>", _("Default Application"));
gtk_list_store_append (self->priv->program_list_store, &iter);
gtk_list_store_set (self->priv->program_list_store, &iter,
COLUMN_HEADING_TEXT, string,
COLUMN_HEADING, TRUE,
COLUMN_DEFAULT, TRUE,
-1);
g_free (string);
string = g_markup_printf_escaped ("%s",
g_app_info_get_name (app) != NULL ?
g_app_info_get_name (app) : "");
icon = g_app_info_get_icon (app);
if (icon == NULL)
{
icon = g_themed_icon_new ("application-x-executable");
unref_icon = TRUE;
}
gtk_list_store_append (self->priv->program_list_store, &iter);
gtk_list_store_set (self->priv->program_list_store, &iter,
COLUMN_APP_INFO, app,
COLUMN_GICON, icon,
COLUMN_NAME, g_app_info_get_name (app),
COLUMN_DESC, string,
COLUMN_EXEC, g_app_info_get_executable (app),
COLUMN_HEADING, FALSE,
COLUMN_DEFAULT, TRUE,
-1);
g_free (string);
if (unref_icon)
g_object_unref (icon);
}
/**
* fm_choose_app_for_mime_type
* @parent: (allow-none): a parent window
* @mime_type: (allow-none): MIME type for list creation
* @can_set_default: %TRUE if widget can set selected item as default for @mime_type
*
* Creates a dialog to choose application for @mime_type, lets user to
* choose then returns the chosen application.
*
* If user creates custom application and @mime_type isn't %NULL then this
* custom application will be added to list of supporting the @mime_type.
* Otherwise that custom application file will be deleted after usage.
*
* Returns: user choise.
*
* Since: 0.1.0
*/
GAppInfo* fm_choose_app_for_mime_type(GtkWindow* parent, FmMimeType* mime_type, gboolean can_set_default)
{
GAppInfo* app = NULL;
GtkDialog* dlg = fm_app_chooser_dlg_new(mime_type, can_set_default);
if(parent)
gtk_window_set_transient_for(GTK_WINDOW(dlg), parent);
if(gtk_dialog_run(dlg) == GTK_RESPONSE_OK)
{
gboolean set_default;
app = fm_app_chooser_dlg_dup_selected_app(dlg, &set_default);
if(app && mime_type && fm_mime_type_get_type(mime_type) &&
g_app_info_get_name(app)[0]) /* don't add empty name */
{
GError* err = NULL;
/* add this app to the mime-type */
#if GLIB_CHECK_VERSION(2, 27, 6)
if(!g_app_info_set_as_last_used_for_type(app,
#else
if(!g_app_info_add_supports_type(app,
#endif
fm_mime_type_get_type(mime_type), &err))
{
g_debug("error: %s", err->message);
g_error_free(err);
}
/* if need to set default */
if(set_default)
g_app_info_set_as_default_for_type(app,
fm_mime_type_get_type(mime_type), NULL);
}
void
cc_shell_model_add_item (CcShellModel *model,
CcPanelCategory category,
GAppInfo *appinfo,
const char *id)
{
GIcon *icon = g_app_info_get_icon (appinfo);
const gchar *name = g_app_info_get_name (appinfo);
const gchar *comment = g_app_info_get_description (appinfo);
char **keywords;
char *casefolded_name, *casefolded_description;
casefolded_name = cc_util_normalize_casefold_and_unaccent (name);
casefolded_description = cc_util_normalize_casefold_and_unaccent (comment);
keywords = get_casefolded_keywords (appinfo);
gtk_list_store_insert_with_values (GTK_LIST_STORE (model), NULL, 0,
COL_NAME, name,
COL_CASEFOLDED_NAME, casefolded_name,
COL_APP, appinfo,
COL_ID, id,
COL_CATEGORY, category,
COL_DESCRIPTION, comment,
COL_CASEFOLDED_DESCRIPTION, casefolded_description,
COL_GICON, icon,
COL_KEYWORDS, keywords,
-1);
g_free (casefolded_name);
g_free (casefolded_description);
g_strfreev (keywords);
}
gboolean
panel_app_info_launch_uris (GAppInfo *appinfo,
GList *uris,
GdkScreen *screen,
guint32 timestamp,
GError **error)
{
GdkAppLaunchContext *context;
GError *local_error;
gboolean retval;
g_return_val_if_fail (G_IS_DESKTOP_APP_INFO (appinfo), FALSE);
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
GdkDisplay *display = gdk_display_get_default ();
context = gdk_display_get_app_launch_context (display);
gdk_app_launch_context_set_screen (context, screen);
gdk_app_launch_context_set_timestamp (context, timestamp);
local_error = NULL;
retval = g_desktop_app_info_launch_uris_as_manager ((GDesktopAppInfo*)appinfo, uris,
(GAppLaunchContext *) context,
G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD,
NULL, NULL, gather_pid_callback, appinfo,
&local_error);
g_object_unref (context);
if ((local_error == NULL) && (retval == TRUE))
return TRUE;
return _panel_launch_handle_error (g_app_info_get_name ((GAppInfo*) appinfo),
screen, local_error, error);
}
static void
dialog_response (GtkDialog *d,
gint response_id,
gpointer user_data)
{
GAppInfo *app_info;
const gchar *name;
g_print ("Response: %d\n", response_id);
if (response_id == GTK_RESPONSE_OK)
{
app_info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (d));
if (app_info)
{
name = g_app_info_get_name (app_info);
g_print ("Application selected: %s\n", name);
g_object_unref (app_info);
}
else
g_print ("No application selected\n");
}
gtk_widget_destroy (GTK_WIDGET (d));
dialog = NULL;
}
gboolean
panel_app_info_launch_uris (GAppInfo *appinfo,
GList *uris,
GdkScreen *screen,
guint32 timestamp,
GError **error)
{
GdkAppLaunchContext *context;
GError *local_error;
gboolean retval;
g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE);
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
context = gdk_app_launch_context_new ();
gdk_app_launch_context_set_screen (context, screen);
gdk_app_launch_context_set_timestamp (context, timestamp);
local_error = NULL;
retval = g_app_info_launch_uris (appinfo, uris,
(GAppLaunchContext *) context,
&local_error);
g_object_unref (context);
if ((local_error == NULL) && (retval == TRUE))
return TRUE;
return _panel_launch_handle_error (g_app_info_get_name (appinfo),
screen, local_error, error);
}
static gboolean
panel_app_info_launch_uris (GAppInfo *appinfo,
GList *uris,
GdkScreen *screen,
guint32 timestamp,
GError **error)
{
GdkAppLaunchContext *context;
GError *local_error;
GdkDisplay *display;
g_return_val_if_fail (G_IS_APP_INFO (appinfo), FALSE);
g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
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, timestamp);
local_error = NULL;
g_app_info_launch_uris (appinfo, uris,
(GAppLaunchContext *) context,
&local_error);
g_object_unref (context);
return _panel_launch_handle_error (g_app_info_get_name (appinfo),
screen, local_error, error);
}
static gchar *
gtk_application_window_get_app_desktop_name (void)
{
gchar *retval = NULL;
#ifdef HAVE_GIO_UNIX
GDesktopAppInfo *app_info;
const gchar *app_name = NULL;
gchar *desktop_file;
desktop_file = g_strconcat (g_get_prgname (), ".desktop", NULL);
app_info = g_desktop_app_info_new (desktop_file);
g_free (desktop_file);
if (app_info != NULL)
app_name = g_app_info_get_name (G_APP_INFO (app_info));
if (app_name != NULL)
retval = g_strdup (app_name);
g_clear_object (&app_info);
#endif /* HAVE_GIO_UNIX */
return retval;
}
static MxAction *
_action_new_from_desktop_file (const gchar *desktop_file_id)
{
GDesktopAppInfo *dai;
dai = g_desktop_app_info_new (desktop_file_id);
if (dai)
{
MxAction *action;
GAppInfo *ai;
GIcon *icon;
ai = G_APP_INFO (dai);
action = mx_action_new_full (g_app_info_get_name (ai),
g_app_info_get_display_name (ai),
G_CALLBACK (_app_launcher_cb),
(gpointer)g_app_info_get_commandline (ai));
icon = g_app_info_get_icon (ai);
if (icon)
{
gchar *icon_name;
icon_name = g_icon_to_string (icon);
mx_action_set_icon (action, icon_name);
g_free (icon_name);
}
return action;
}
return NULL;
}
QString App_info::name() {
if (!object) {
qWarning("unitialized App_info used");
return QString();
}
const char* b = g_app_info_get_name(object);
return QString::fromLocal8Bit(b);
}
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 void on_content_type_finished(GObject* src_obj, GAsyncResult* res, gpointer user_data)
{
AutoRun* data = (AutoRun*)user_data;
GMount* mount = G_MOUNT(src_obj);
char** types;
char* desc = NULL;
types = g_mount_guess_content_type_finish(mount, res, NULL);
if(types)
{
GtkTreeIter it;
GList* apps = NULL, *l;
char** type;
if(types[0])
{
for(type=types;*type;++type)
{
l = g_app_info_get_all_for_type(*type);
if(l)
apps = g_list_concat(apps, l);
}
desc = g_content_type_get_description(types[0]);
}
g_strfreev(types);
if(apps)
{
int pos = 0;
GtkTreePath* tp;
for(l = apps; l; l=l->next, ++pos)
{
GAppInfo* app = G_APP_INFO(l->data);
gtk_list_store_insert_with_values(data->store, &it, pos,
0, g_app_info_get_icon(app),
1, g_app_info_get_name(app),
2, app, -1);
g_object_unref(app);
}
g_list_free(apps);
gtk_tree_model_get_iter_first(GTK_TREE_MODEL(data->store), &it);
gtk_tree_selection_select_iter(gtk_tree_view_get_selection(data->view), &it);
tp = gtk_tree_path_new_first();
gtk_tree_view_set_cursor(data->view, tp, NULL, FALSE);
gtk_tree_path_free(tp);
}
}
if(desc)
{
gtk_label_set_text(data->type, desc);
g_free(desc);
}
else
gtk_label_set_text(data->type, _("Removable Disk"));
}
static gint
list_sort_func (gconstpointer a,
gconstpointer b,
gpointer user_data)
{
CcSearchPanel *self = user_data;
GAppInfo *app_a, *app_b;
const gchar *id_a, *id_b;
gint idx_a, idx_b;
gpointer lookup;
app_a = g_object_get_data (G_OBJECT (a), "app-info");
app_b = g_object_get_data (G_OBJECT (b), "app-info");
id_a = g_app_info_get_id (app_a);
id_b = g_app_info_get_id (app_b);
/* find the index of the application in the GSettings preferences */
idx_a = -1;
idx_b = -1;
lookup = g_hash_table_lookup (self->priv->sort_order, id_a);
if (lookup)
idx_a = GPOINTER_TO_INT (lookup) - 1;
lookup = g_hash_table_lookup (self->priv->sort_order, id_b);
if (lookup)
idx_b = GPOINTER_TO_INT (lookup) - 1;
/* if neither app is found, use alphabetical order */
if ((idx_a == -1) && (idx_b == -1))
return g_utf8_collate (g_app_info_get_name (app_a), g_app_info_get_name (app_b));
/* if app_a isn't found, it's sorted after app_b */
if (idx_a == -1)
return 1;
/* if app_b isn't found, it's sorted after app_a */
if (idx_b == -1)
return -1;
/* finally, if both apps are found, return their order in the list */
return (idx_a - idx_b);
}
static GList *
xde_entry(MenuContext *ctx, GMenuTreeEntry *ent)
{
GDesktopAppInfo *info;
GList *text = NULL, *acts;
const char *name;
char *esc1, *esc2, *cmd, *p;
char *s, *icon = NULL;
GIcon *gicon = NULL;
char *appid;
if (!(info = gmenu_tree_entry_get_app_info(ent)) || g_desktop_app_info_get_is_hidden(info)
|| g_desktop_app_info_get_nodisplay(info) || !g_desktop_app_info_get_show_in(info, NULL)
|| !g_app_info_should_show(G_APP_INFO(info)))
return (text);
name = g_app_info_get_name(G_APP_INFO(info));
esc1 = xde_character_escape(name, ')');
if ((appid = strdup(gmenu_tree_entry_get_desktop_file_id(ent)))
&& (p = strstr(appid, ".desktop")))
*p = '\0';
if (ctx->stack)
gicon = gmenu_tree_directory_get_icon(ctx->stack->data);
icon = xde_get_app_icon(ctx, info, gicon, "exec", "unknown",
GET_ENTRY_ICON_FLAG_XPM | GET_ENTRY_ICON_FLAG_PNG |
GET_ENTRY_ICON_FLAG_JPG | GET_ENTRY_ICON_FLAG_SVG);
if (options.launch) {
cmd = g_strdup_printf("xdg-launch --pointer %s", appid);
} else {
cmd = xde_get_command(info, appid, icon);
}
esc2 = xde_character_escape(cmd, '}');
icon = ctx->wmm.wrap(ctx, icon);
if (options.actions && (acts = ctx->wmm.ops.actions(ctx, ent, info))) {
xde_increase_indent(ctx);
s = g_strdup_printf("%s[exec] (%s) {%s}%s\n", ctx->indent, esc1, esc2, icon);
xde_decrease_indent(ctx);
acts = g_list_prepend(acts, s);
s = g_strdup_printf("%s[submenu] (%s) {%s}%s\n", ctx->indent, esc1, esc1, icon);
acts = g_list_prepend(acts, s);
s = g_strdup_printf("%s[end]\n", ctx->indent);
acts = g_list_append(acts, s);
text = g_list_concat(text, acts);
} else {
s = g_strdup_printf("%s[exec] (%s) {%s}%s\n", ctx->indent, esc1, esc2, icon);
text = g_list_append(text, s);
}
free(icon);
free(appid);
free(esc1);
free(esc2);
free(cmd);
return (text);
}
/* Look at the GAppInfo structures and sort based on
the application names */
static gint
sort_app_infos (gconstpointer a, gconstpointer b)
{
GAppInfo * appa = G_APP_INFO(a);
GAppInfo * appb = G_APP_INFO(b);
const gchar * namea = NULL;
const gchar * nameb = NULL;
if (appa != NULL) {
namea = g_app_info_get_name(appa);
}
if (appb != NULL) {
nameb = g_app_info_get_name(appb);
}
return g_strcmp0(namea, nameb);
}
const char *
desktop_entry_get_name (DesktopEntry *entry)
{
if (entry->type == DESKTOP_ENTRY_DESKTOP)
{
g_return_val_if_fail (G_IS_DESKTOP_APP_INFO (((DesktopEntryDesktop*)entry)->appinfo), NULL);
return g_app_info_get_name (G_APP_INFO (((DesktopEntryDesktop*)entry)->appinfo));
}
return ((DesktopEntryDirectory*)entry)->name;
}
static void
gtk_app_chooser_button_populate (GtkAppChooserButton *self)
{
GList *recommended_apps = NULL, *l;
GAppInfo *app;
GtkTreeIter iter, iter2;
GIcon *icon;
gboolean cycled_recommended;
#ifndef G_OS_WIN32
if (self->priv->content_type)
recommended_apps = g_app_info_get_recommended_for_type (self->priv->content_type);
#endif
cycled_recommended = FALSE;
for (l = recommended_apps; l != NULL; l = l->next)
{
app = l->data;
icon = g_app_info_get_icon (app);
if (icon == NULL)
icon = g_themed_icon_new ("application-x-executable");
else
g_object_ref (icon);
if (cycled_recommended)
{
gtk_list_store_insert_after (self->priv->store, &iter2, &iter);
iter = iter2;
}
else
{
get_first_iter (self->priv->store, &iter);
cycled_recommended = TRUE;
}
gtk_list_store_set (self->priv->store, &iter,
COLUMN_APP_INFO, app,
COLUMN_LABEL, g_app_info_get_name (app),
COLUMN_ICON, icon,
COLUMN_CUSTOM, FALSE,
-1);
g_object_unref (icon);
}
if (!cycled_recommended)
gtk_app_chooser_button_ensure_dialog_item (self, NULL);
else
gtk_app_chooser_button_ensure_dialog_item (self, &iter);
gtk_combo_box_set_active (GTK_COMBO_BOX (self), 0);
}
JS_EXPORT_API
char* dcore_get_name_by_appid(const char* id)
{
GDesktopAppInfo* a = guess_desktop_file(id);
if (a != NULL) {
char* name = g_strdup(g_app_info_get_name(G_APP_INFO(a)));
g_object_unref(a);
return name;
}
return g_strdup("");
}
static ClutterActor *
_make_messenger_launcher_tile (MnbPeoplePanel *panel)
{
ClutterActor *table;
ClutterActor *icon_tex;
ClutterActor *button;
GAppInfo *app_info;
gchar *button_str;
ClutterActor *bin;
bin = mx_frame_new ();
clutter_actor_set_name (bin, "people-panel-messenger-launcher-tile");
table = mx_table_new ();
mx_bin_set_child (MX_BIN (bin), table);
mx_table_set_column_spacing (MX_TABLE (table), 16);
app_info = (GAppInfo *)g_desktop_app_info_new ("empathy.desktop");
icon_tex = g_object_new (MX_TYPE_ICON,
"icon-name", "netbook-empathy",
NULL);
mx_table_add_actor_with_properties (MX_TABLE (table),
icon_tex,
0, 0,
"x-expand", FALSE,
"y-expand", TRUE,
"x-fill", FALSE,
"y-fill", FALSE,
NULL);
button_str = g_strdup_printf (_("Open %s"),
g_app_info_get_name (app_info));
button = mx_button_new_with_label (button_str);
g_free (button_str);
g_signal_connect (button,
"clicked",
(GCallback)_messenger_launcher_button_clicked_cb,
panel);
mx_table_add_actor_with_properties (MX_TABLE (table),
button,
0, 1,
"x-expand", FALSE,
"y-expand", TRUE,
"x-fill", FALSE,
"y-fill", FALSE,
NULL);
g_object_unref (app_info);
return bin;
}
ClutterActor *
_make_settings_launcher (MnbPeoplePanel *people_panel)
{
ClutterActor *table;
ClutterActor *icon_tex;
ClutterActor *button;
GAppInfo *app_info;
gchar *button_str;
app_info = (GAppInfo *)g_desktop_app_info_new ("empathy-accounts.desktop");
table = mx_table_new ();
mx_table_set_column_spacing (MX_TABLE (table), 16);
app_info = (GAppInfo *)g_desktop_app_info_new ("empathy-accounts.desktop");
icon_tex = g_object_new (MX_TYPE_ICON,
"icon-name", "netbook-empathy-accounts",
NULL);
mx_table_insert_actor_with_properties (MX_TABLE (table),
icon_tex,
0, 0,
"x-expand", FALSE,
"y-expand", TRUE,
"x-fill", FALSE,
"y-fill", FALSE,
NULL);
button_str = g_strdup_printf (_("Open %s"),
g_app_info_get_name (app_info));
button = mx_button_new_with_label (button_str);
g_free (button_str);
g_signal_connect (button,
"clicked",
(GCallback)_settings_launcher_button_clicked_cb,
people_panel);
mx_table_insert_actor_with_properties (MX_TABLE (table),
button,
0, 1,
"x-expand", FALSE,
"y-expand", TRUE,
"x-fill", FALSE,
"y-fill", FALSE,
NULL);
g_object_unref (app_info);
return table;
}
QString
LauncherApplication::name() const
{
if (sticky() && (m_appInfo != NULL)) {
return QString::fromUtf8(g_app_info_get_name(m_appInfo.data()));
}
if (m_application != NULL) {
return m_application->name();
}
if (m_appInfo != NULL) {
return QString::fromUtf8(g_app_info_get_name(m_appInfo.data()));
}
if (m_snStartupSequence != NULL) {
return QString::fromUtf8(sn_startup_sequence_get_name(m_snStartupSequence.data()));
}
return QString("");
}
static void
_launch_app (OlPlayerChooser *window,
GAppInfo *app_info)
{
GError *err = NULL;
if (!g_app_info_launch (app_info, NULL, NULL, &err))
{
ol_errorf ("Cannot launch %s: %s",
g_app_info_get_commandline (app_info),
err->message);
gchar *title = g_strdup_printf (_("Failed to launch %s"),
g_app_info_get_name (app_info));
ol_player_chooser_set_info (window, title, err->message);
ol_player_chooser_set_image_by_name (window, GTK_STOCK_DIALOG_ERROR);
g_free (title);
g_error_free (err);
}
else
{
_set_launch_app (window, app_info);
gchar *title = g_strdup_printf (_("Launching %s"),
g_app_info_get_name (app_info));
gchar *desc = g_strdup_printf (_("OSD Lyrics is trying to launch and connect to %s. Please wait for a second."),
g_app_info_get_name (app_info));
ol_player_chooser_set_info (window, title, desc);
g_free (title);
g_free (desc);
ol_player_chooser_set_image_by_gicon (window, g_app_info_get_icon (app_info));
_set_sensitive (window, FALSE);
if (OL_IS_PLAYER_CHOOSER (window))
{
_remember_cmd_if_needed (window, g_app_info_get_commandline (app_info));
gtk_dialog_response (GTK_DIALOG (window), OL_PLAYER_CHOOSER_RESPONSE_LAUNCH);
}
}
}
JS_EXPORT_API
double launcher_weight(GDesktopAppInfo* info, const char* key)
{
double weight = 0.0;
/* desktop file information */
const char* path = g_desktop_app_info_get_filename(info);
char* basename = g_path_get_basename(path);
*strchr(basename, '.') = '\0';
weight += _get_weight(basename, key, _pred, FILENAME_WEIGHT);
g_free(basename);
const char* gname = g_desktop_app_info_get_generic_name(info);
weight += _get_weight(gname, key, _pred, GENERIC_NAME_WEIGHT);
const char* const* keys = g_desktop_app_info_get_keywords(info);
if (keys != NULL) {
size_t n = g_strv_length((char**)keys);
for (size_t i=0; i<n; i++) {
weight += _get_weight(keys[i], key, _pred, KEYWORD_WEIGHT);
}
}
const char* categories = g_desktop_app_info_get_categories(info);
if (categories) {
gchar** category_names = g_strsplit(categories, ";", -1);
gsize len = g_strv_length(category_names) - 1;
for (gsize i = 0; i < len; ++i) {
weight += _get_weight(category_names[i], key, _pred, CATEGORY_WEIGHT);
}
g_strfreev(category_names);
}
/* application information */
const char* name = g_app_info_get_name((GAppInfo*)info);
weight += _get_weight(name, key, _pred, NAME_WEIGHT);
const char* dname = g_app_info_get_display_name((GAppInfo*)info);
weight += _get_weight(dname, key, _pred, DISPLAY_NAME_WEIGHT);
const char* desc = g_app_info_get_description((GAppInfo*)info);
weight += _get_weight(desc, key, _pred, DESCRIPTION_WEIGHT);
const char* exec = g_app_info_get_executable((GAppInfo*)info);
weight += _get_weight(exec, key, _pred, EXECUTABLE_WEIGHT);
return weight;
}
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);
}
static void on_browse_btn_clicked(GtkButton* btn, AppChooserData* data)
{
FmPath* file;
GtkFileFilter* filter = gtk_file_filter_new();
char* binary;
gtk_file_filter_add_custom(filter,
GTK_FILE_FILTER_FILENAME|GTK_FILE_FILTER_MIME_TYPE, exec_filter_func, NULL, NULL);
/* gtk_file_filter_set_name(filter, _("Executable files")); */
file = fm_select_file(GTK_WINDOW(data->dlg), NULL, "/usr/bin", TRUE, FALSE, filter, NULL);
if (file == NULL)
return;
binary = fm_path_to_str(file);
if (g_str_has_suffix(fm_path_get_basename(file), ".desktop"))
{
GKeyFile *kf = g_key_file_new();
GDesktopAppInfo *info;
if (g_key_file_load_from_file(kf, binary, 0, NULL) &&
(info = g_desktop_app_info_new_from_keyfile(kf)) != NULL)
/* it is a valid desktop entry */
{
/* FIXME: it will duplicate the file, how to avoid that? */
gtk_entry_set_text(data->cmdline,
g_app_info_get_commandline(G_APP_INFO(info)));
gtk_entry_set_text(data->app_name,
g_app_info_get_name(G_APP_INFO(info)));
gtk_toggle_button_set_active(data->use_terminal,
g_key_file_get_boolean(kf, G_KEY_FILE_DESKTOP_GROUP,
G_KEY_FILE_DESKTOP_KEY_TERMINAL,
NULL));
gtk_toggle_button_set_active(data->keep_open,
g_key_file_get_boolean(kf, G_KEY_FILE_DESKTOP_GROUP,
"X-KeepTerminal",
NULL));
g_object_unref(info);
g_key_file_free(kf);
fm_path_unref(file);
return;
}
g_key_file_free(kf);
}
gtk_entry_set_text(data->cmdline, binary);
g_free(binary);
fm_path_unref(file);
}
static GList *
xde_entry(MenuContext *ctx, GMenuTreeEntry *ent)
{
GDesktopAppInfo *info;
GList *text = NULL;
const char *name;
char *esc1, *qname, *esc2, *cmd, *p;
char *s, *icon = NULL;
GIcon *gicon = NULL;
char *appid;
if (!(info = gmenu_tree_entry_get_app_info(ent)) || g_desktop_app_info_get_is_hidden(info)
|| g_desktop_app_info_get_nodisplay(info) || !g_desktop_app_info_get_show_in(info, NULL)
|| !g_app_info_should_show(G_APP_INFO(info)))
return (text);
name = g_app_info_get_name(G_APP_INFO(info));
esc1 = xde_character_escape(name, '"');
qname = g_strdup_printf("\"%s\"", esc1);
if ((appid = strdup(gmenu_tree_entry_get_desktop_file_id(ent)))
&& (p = strstr(appid, ".desktop")))
*p = '\0';
if (ctx->stack)
gicon = gmenu_tree_directory_get_icon(ctx->stack->data);
icon = xde_get_app_icon(ctx, info, gicon, "exec", "unknown",
GET_ENTRY_ICON_FLAG_XPM | GET_ENTRY_ICON_FLAG_PNG |
GET_ENTRY_ICON_FLAG_JPG | GET_ENTRY_ICON_FLAG_SVG);
if (options.launch) {
cmd = g_strdup_printf("xdg-launch --pointer %s", appid);
} else {
cmd = xde_get_command(info, appid, icon);
}
esc2 = xde_character_escape(cmd, '"');
s = g_strdup_printf(" %-32s f.exec \"exec %s &\"\n", qname, esc2);
text = g_list_append(text, s);
free(icon);
free(appid);
g_free(qname);
free(esc1);
free(esc2);
free(cmd);
return (text);
}
const char *
cinnamon_app_get_name (CinnamonApp *app)
{
if (app->entry)
return g_app_info_get_name (G_APP_INFO (gmenu_tree_entry_get_app_info (app->entry)));
else if (app->running_state == NULL)
return _("Unknown");
else
{
MetaWindow *window = window_backed_app_get_window (app);
const char *name;
name = meta_window_get_wm_class (window);
if (!name)
name = _("Unknown");
return name;
}
}
static void
add_application (CcNotificationsPanel *panel,
Application *app)
{
GtkWidget *box, *w;
GIcon *icon;
icon = g_app_info_get_icon (app->app_info);
if (icon == NULL)
icon = g_themed_icon_new ("application-x-executable");
else
g_object_ref (icon);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
g_object_set_qdata_full (G_OBJECT (box), application_quark (),
app, (GDestroyNotify) application_free);
gtk_container_add (GTK_CONTAINER (panel->list_box), box);
w = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG);
gtk_widget_set_margin_left (w, 12);
gtk_container_add (GTK_CONTAINER (box), w);
g_object_unref (icon);
w = gtk_label_new (g_app_info_get_name (app->app_info));
gtk_container_add (GTK_CONTAINER (box), w);
w = gtk_label_new ("");
g_settings_bind_with_mapping (app->settings, "enable",
w, "label",
G_SETTINGS_BIND_GET |
G_SETTINGS_BIND_NO_SENSITIVITY,
on_off_label_mapping_get,
NULL,
NULL,
NULL);
gtk_widget_set_margin_right (w, 12);
gtk_widget_set_valign (w, GTK_ALIGN_CENTER);
gtk_box_pack_end (GTK_BOX (box), w, FALSE, FALSE, 0);
gtk_widget_show_all (box);
g_hash_table_add (panel->known_applications, g_strdup (app->canonical_app_id));
}
