static gboolean
gs_plugin_generic_updates_merge_os_update (GsApp *app)
{
if (gs_app_get_kind (app) == AS_APP_KIND_GENERIC)
return TRUE;
if (gs_app_get_kind (app) == AS_APP_KIND_SOURCE)
return TRUE;
return FALSE;
}
static GsUpdateListSection
gs_update_list_get_app_section (GsApp *app)
{
if (gs_app_get_state (app) == AS_APP_STATE_UPDATABLE_LIVE) {
if (gs_app_get_kind (app) == AS_APP_KIND_FIRMWARE)
return GS_UPDATE_LIST_SECTION_ONLINE_FIRMWARE;
return GS_UPDATE_LIST_SECTION_ONLINE;
}
if (gs_app_get_kind (app) == AS_APP_KIND_FIRMWARE)
return GS_UPDATE_LIST_SECTION_OFFLINE_FIRMWARE;
return GS_UPDATE_LIST_SECTION_OFFLINE;
}
static gboolean
gs_plugin_generic_updates_merge_os_update (GsApp *app)
{
/* this is only for grouping system-installed packages */
if (gs_app_get_bundle_kind (app) != AS_BUNDLE_KIND_PACKAGE ||
gs_app_get_scope (app) != AS_APP_SCOPE_SYSTEM)
return FALSE;
if (gs_app_get_kind (app) == AS_APP_KIND_GENERIC)
return TRUE;
if (gs_app_get_kind (app) == AS_APP_KIND_SOURCE)
return TRUE;
return FALSE;
}
void
gs_page_update_app (GsPage *page, GsApp *app, GCancellable *cancellable)
{
GsPagePrivate *priv = gs_page_get_instance_private (page);
GsPageHelper *helper;
/* non-firmware applications do not have to be prepared */
helper = g_slice_new0 (GsPageHelper);
helper->action = GS_PLUGIN_ACTION_UPDATE;
helper->app = g_object_ref (app);
helper->page = g_object_ref (page);
helper->cancellable = g_object_ref (cancellable);
/* tell the user what they have to do */
if (gs_app_get_kind (app) == AS_APP_KIND_FIRMWARE &&
gs_app_has_quirk (app, AS_APP_QUIRK_NEEDS_USER_ACTION)) {
GPtrArray *screenshots = gs_app_get_screenshots (app);
if (screenshots->len > 0) {
AsScreenshot *ss = g_ptr_array_index (screenshots, 0);
if (as_screenshot_get_caption (ss, NULL) != NULL) {
gs_page_needs_user_action (helper, ss);
return;
}
}
}
/* generic fallback */
gs_plugin_loader_app_action_async (priv->plugin_loader,
helper->app,
helper->action,
GS_PLUGIN_FAILURE_FLAGS_FATAL_ANY,
helper->cancellable,
gs_page_app_installed_cb,
helper);
}
gboolean
gs_plugin_refine_app (GsPlugin *plugin,
GsApp *app,
GsPluginRefineFlags flags,
GCancellable *cancellable,
GError **error)
{
GPtrArray *provides;
guint i;
/* not required */
if (gs_app_get_icons(app)->len > 0)
return TRUE;
if (gs_app_get_kind (app) != AS_APP_KIND_DRIVER)
return TRUE;
/* do any of the modaliases match any installed hardware */
provides = gs_app_get_provides (app);
for (i = 0 ; i < provides->len; i++) {
AsProvide *prov = g_ptr_array_index (provides, i);
if (as_provide_get_kind (prov) != AS_PROVIDE_KIND_MODALIAS)
continue;
if (gs_plugin_modalias_matches (plugin, as_provide_get_value (prov))) {
g_autoptr(AsIcon) ic = NULL;
ic = as_icon_new ();
as_icon_set_kind (ic, AS_ICON_KIND_STOCK);
as_icon_set_name (ic, "emblem-system-symbolic");
gs_app_add_icon (app, ic);
gs_app_add_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE);
break;
}
}
return TRUE;
}
gboolean
gs_plugin_refine_app (GsPlugin *plugin,
GsApp *app,
GsPluginRefineFlags flags,
GCancellable *cancellable,
GError **error)
{
/* not valid */
if (gs_app_get_kind (app) == AS_APP_KIND_ADDON)
return TRUE;
if (gs_app_get_id (app) == NULL)
return TRUE;
/* add reviews if possible */
if (flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_REVIEWS) {
if (gs_app_get_reviews(app)->len > 0)
return TRUE;
if (!gs_plugin_odrs_refine_reviews (plugin, app,
cancellable, error))
return FALSE;
}
/* add ratings if possible */
if (flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_REVIEW_RATINGS ||
flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_RATING) {
if (gs_app_get_review_ratings(app) != NULL)
return TRUE;
if (!gs_plugin_odrs_refine_ratings (plugin, app,
cancellable, error))
return FALSE;
}
return TRUE;
}
static GsApp *
snap_to_app (GsPlugin *plugin, SnapdSnap *snap)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
GStrv common_ids;
g_autofree gchar *appstream_id = NULL;
g_autofree gchar *unique_id = NULL;
g_autoptr(GsApp) app = NULL;
SnapdConfinement confinement;
/* Get the AppStream ID from the snap, or generate a fallback one */
common_ids = snapd_snap_get_common_ids (snap);
if (g_strv_length (common_ids) == 1)
appstream_id = g_strdup (common_ids[0]);
else
appstream_id = g_strdup_printf ("io.snapcraft.%s-%s", snapd_snap_get_name (snap), snapd_snap_get_id (snap));
switch (snapd_snap_get_snap_type (snap)) {
case SNAPD_SNAP_TYPE_APP:
unique_id = g_strdup_printf ("system/snap/*/desktop/%s/*", appstream_id);
break;
case SNAPD_SNAP_TYPE_KERNEL:
case SNAPD_SNAP_TYPE_GADGET:
case SNAPD_SNAP_TYPE_OS:
unique_id = g_strdup_printf ("system/snap/*/runtime/%s/*", appstream_id);
break;
default:
case SNAPD_SNAP_TYPE_UNKNOWN:
unique_id = g_strdup_printf ("system/snap/*/*/%s/*", appstream_id);
break;
}
app = gs_plugin_cache_lookup (plugin, unique_id);
if (app == NULL) {
app = gs_app_new (NULL);
gs_app_set_from_unique_id (app, unique_id);
gs_app_set_bundle_kind (app, AS_BUNDLE_KIND_SNAP);
gs_app_set_metadata (app, "snap::name", snapd_snap_get_name (snap));
gs_plugin_cache_add (plugin, unique_id, app);
}
gs_app_set_management_plugin (app, "snap");
if (gs_app_get_kind (app) != AS_APP_KIND_DESKTOP)
gs_app_add_quirk (app, GS_APP_QUIRK_NOT_LAUNCHABLE);
if (gs_plugin_check_distro_id (plugin, "ubuntu"))
gs_app_add_quirk (app, GS_APP_QUIRK_PROVENANCE);
confinement = snapd_snap_get_confinement (snap);
if (confinement != SNAPD_CONFINEMENT_UNKNOWN) {
GEnumClass *enum_class = g_type_class_ref (SNAPD_TYPE_CONFINEMENT);
gs_app_set_metadata (app, "snap::confinement", g_enum_get_value (enum_class, confinement)->value_nick);
g_type_class_unref (enum_class);
}
if (priv->system_confinement == SNAPD_SYSTEM_CONFINEMENT_STRICT && confinement == SNAPD_CONFINEMENT_STRICT)
gs_app_add_kudo (app, GS_APP_KUDO_SANDBOXED);
return g_steal_pointer (&app);
}
static gchar *
get_app_sort_key (GsApp *app)
{
GString *key;
key = g_string_sized_new (64);
/* Sections:
* 1. offline integrated firmware
* 2. offline os updates (OS-update, apps, runtimes, addons, other)
* 3. online apps (apps, runtimes, addons, other)
* 4. online device firmware */
g_string_append_printf (key, "%u:", gs_update_list_get_app_section (app));
/* sort apps by kind */
switch (gs_app_get_kind (app)) {
case AS_APP_KIND_OS_UPDATE:
g_string_append (key, "1:");
break;
case AS_APP_KIND_DESKTOP:
g_string_append (key, "2:");
break;
case AS_APP_KIND_WEB_APP:
g_string_append (key, "3:");
break;
case AS_APP_KIND_RUNTIME:
g_string_append (key, "4:");
break;
case AS_APP_KIND_ADDON:
g_string_append (key, "5:");
break;
case AS_APP_KIND_CODEC:
g_string_append (key, "6:");
break;
case AS_APP_KIND_FONT:
g_string_append (key, "6:");
break;
case AS_APP_KIND_INPUT_METHOD:
g_string_append (key, "7:");
break;
case AS_APP_KIND_SHELL_EXTENSION:
g_string_append (key, "8:");
break;
default:
g_string_append (key, "9:");
break;
}
/* finally, sort by short name */
g_string_append (key, gs_app_get_name (app));
return g_string_free (key, FALSE);
}
static gchar *
get_app_sort_key (GsApp *app)
{
GString *key;
key = g_string_sized_new (64);
/* sort by kind */
switch (gs_app_get_kind (app)) {
case AS_APP_KIND_OS_UPDATE:
g_string_append (key, "1:");
break;
default:
g_string_append (key, "2:");
break;
}
/* sort desktop files, then addons */
switch (gs_app_get_kind (app)) {
case AS_APP_KIND_FIRMWARE:
g_string_append (key, "1:");
break;
case AS_APP_KIND_DESKTOP:
g_string_append (key, "2:");
break;
default:
g_string_append (key, "3:");
break;
}
/* sort by install date */
g_string_append_printf (key, "%09" G_GUINT64_FORMAT ":",
G_MAXUINT64 - gs_app_get_install_date (app));
/* finally, sort by short name */
g_string_append (key, gs_app_get_name (app));
return g_string_free (key, FALSE);
}
static gboolean
is_addon_id_kind (GsApp *app)
{
AsAppKind id_kind;
id_kind = gs_app_get_kind (app);
if (id_kind == AS_APP_KIND_DESKTOP)
return FALSE;
if (id_kind == AS_APP_KIND_WEB_APP)
return FALSE;
if (id_kind == AS_APP_KIND_FIRMWARE)
return FALSE;
if (id_kind == AS_APP_KIND_RUNTIME)
return FALSE;
return TRUE;
}
/**
* gs_plugin_app_upgrade_download:
*/
gboolean
gs_plugin_app_upgrade_download (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
ProgressData data;
g_autoptr(PkResults) results = NULL;
/* only process this app if was created by this plugin */
if (g_strcmp0 (gs_app_get_management_plugin (app), "packagekit") != 0)
return TRUE;
data.app = app;
data.plugin = plugin;
/* check is distro-upgrade */
if (gs_app_get_kind (app) != AS_APP_KIND_OS_UPGRADE) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_FAILED,
"app %s is not a distro upgrade",
gs_app_get_id (app));
return FALSE;
}
/* ask PK to download enough packages to upgrade the system */
gs_app_set_state (app, AS_APP_STATE_INSTALLING);
results = pk_task_upgrade_system_sync (priv->task,
gs_app_get_version (app),
PK_UPGRADE_KIND_ENUM_COMPLETE,
cancellable,
gs_plugin_packagekit_progress_cb, &data,
error);
if (!gs_plugin_packagekit_results_valid (results, error)) {
gs_app_set_state_recover (app);
return FALSE;
}
/* state is known */
gs_app_set_state (app, AS_APP_STATE_UPDATABLE);
return TRUE;
}
gboolean
gs_plugin_app_install (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
/* only process this app if was created by this plugin */
if (g_strcmp0 (gs_app_get_management_plugin (app),
gs_plugin_get_name (plugin)) != 0)
return TRUE;
/* source -> remote */
if (gs_app_get_kind (app) == AS_APP_KIND_SOURCE) {
return gs_plugin_fwupd_modify_source (plugin, app, TRUE,
cancellable, error);
}
/* firmware */
return gs_plugin_fwupd_install (plugin, app, cancellable, error);
}
/**
* gs_plugin_app_install:
*/
gboolean
gs_plugin_app_install (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autoptr(XdgAppInstalledRef) xref = NULL;
/* only process this app if was created by this plugin */
if (g_strcmp0 (gs_app_get_management_plugin (app),
gs_plugin_get_name (plugin)) != 0)
return TRUE;
/* ensure we have metadata and state */
if (!gs_plugin_xdg_app_refine_app (plugin, app, 0, cancellable, error))
return FALSE;
/* install */
gs_app_set_state (app, AS_APP_STATE_INSTALLING);
/* install required runtime if not already installed */
if (gs_app_get_kind (app) == AS_APP_KIND_DESKTOP) {
GsApp *runtime;
runtime = gs_app_get_runtime (app);
/* the runtime could come from a different remote to the app */
if (!gs_plugin_refine_item_metadata (plugin, runtime, cancellable, error))
return FALSE;
if (!gs_plugin_refine_item_origin (plugin, runtime, cancellable, error))
return FALSE;
if (!gs_plugin_refine_item_state (plugin, runtime, cancellable, error))
return FALSE;
if (gs_app_get_state (runtime) == AS_APP_STATE_UNKNOWN) {
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_NOT_SUPPORTED,
"Failed to find runtime %s",
gs_app_get_source_default (runtime));
return FALSE;
}
/* not installed */
if (gs_app_get_state (runtime) == AS_APP_STATE_AVAILABLE) {
g_debug ("%s is not already installed, so installing",
gs_app_get_id (runtime));
gs_app_set_state (runtime, AS_APP_STATE_INSTALLING);
xref = xdg_app_installation_install (priv->installation,
gs_app_get_origin (runtime),
gs_app_get_xdgapp_kind (runtime),
gs_app_get_xdgapp_name (runtime),
gs_app_get_xdgapp_arch (runtime),
gs_app_get_xdgapp_branch (runtime),
gs_plugin_xdg_app_progress_cb, app,
cancellable, error);
if (xref == NULL) {
gs_app_set_state_recover (runtime);
return FALSE;
}
gs_app_set_state (runtime, AS_APP_STATE_INSTALLED);
} else {
g_debug ("%s is already installed, so skipping",
gs_app_get_id (runtime));
}
}
/* use the source for local apps */
if (gs_app_get_state (app) == AS_APP_STATE_AVAILABLE_LOCAL) {
xref = xdg_app_installation_install_bundle (priv->installation,
gs_app_get_local_file (app),
gs_plugin_xdg_app_progress_cb,
app,
cancellable, error);
} else {
g_debug ("installing %s", gs_app_get_id (app));
xref = xdg_app_installation_install (priv->installation,
gs_app_get_origin (app),
gs_app_get_xdgapp_kind (app),
gs_app_get_xdgapp_name (app),
gs_app_get_xdgapp_arch (app),
gs_app_get_xdgapp_branch (app),
gs_plugin_xdg_app_progress_cb, app,
cancellable, error);
}
if (xref == NULL) {
gs_app_set_state_recover (app);
return FALSE;
}
/* state is known */
gs_app_set_state (app, AS_APP_STATE_INSTALLED);
return TRUE;
}
void
gs_plugin_adopt_app (GsPlugin *plugin, GsApp *app)
{
if (gs_app_get_kind (app) == AS_APP_KIND_FIRMWARE)
gs_app_set_management_plugin (app, gs_plugin_get_name (plugin));
}
void
gs_app_row_refresh (GsAppRow *app_row)
{
GsAppRowPrivate *priv = gs_app_row_get_instance_private (app_row);
GtkStyleContext *context;
GString *str = NULL;
const gchar *tmp;
gboolean missing_search_result;
guint64 installed_size;
if (priv->app == NULL)
return;
/* is this a missing search result from the extras page? */
missing_search_result = (gs_app_get_state (priv->app) == AS_APP_STATE_UNAVAILABLE &&
gs_app_get_url (priv->app, AS_URL_KIND_MISSING) != NULL);
/* do a fill bar for the current progress */
switch (gs_app_get_state (priv->app)) {
case AS_APP_STATE_INSTALLING:
gs_progress_button_set_progress (GS_PROGRESS_BUTTON (priv->button),
gs_app_get_progress (priv->app));
gs_progress_button_set_show_progress (GS_PROGRESS_BUTTON (priv->button), TRUE);
break;
default:
gs_progress_button_set_show_progress (GS_PROGRESS_BUTTON (priv->button), FALSE);
break;
}
/* join the description lines */
str = gs_app_row_get_description (app_row);
if (str != NULL) {
as_utils_string_replace (str, "\n", " ");
gtk_label_set_label (GTK_LABEL (priv->description_label), str->str);
g_string_free (str, TRUE);
} else {
gtk_label_set_text (GTK_LABEL (priv->description_label), NULL);
}
/* add warning */
if (gs_app_has_quirk (priv->app, AS_APP_QUIRK_REMOVABLE_HARDWARE)) {
gtk_label_set_text (GTK_LABEL (priv->label_warning),
/* TRANSLATORS: during the update the device
* will restart into a special update-only mode */
_("Device cannot be used during update."));
gtk_widget_show (priv->label_warning);
}
/* where did this app come from */
if (priv->show_source) {
tmp = gs_app_get_origin_hostname (priv->app);
if (tmp != NULL) {
g_autofree gchar *origin_tmp = NULL;
/* TRANSLATORS: this refers to where the app came from */
origin_tmp = g_strdup_printf ("%s: %s", _("Source"), tmp);
gtk_label_set_label (GTK_LABEL (priv->label_origin), origin_tmp);
}
gtk_widget_set_visible (priv->label_origin, tmp != NULL);
} else {
gtk_widget_set_visible (priv->label_origin, FALSE);
}
/* installed tag */
if (!priv->show_buttons) {
switch (gs_app_get_state (priv->app)) {
case AS_APP_STATE_UPDATABLE:
case AS_APP_STATE_UPDATABLE_LIVE:
case AS_APP_STATE_INSTALLED:
gtk_widget_set_visible (priv->label_installed, TRUE);
break;
default:
gtk_widget_set_visible (priv->label_installed, FALSE);
break;
}
} else {
gtk_widget_set_visible (priv->label_installed, FALSE);
}
/* name */
if (g_strcmp0 (gs_app_get_branch (priv->app), "master") == 0) {
g_autofree gchar *name = NULL;
/* TRANSLATORS: not translated to match what flatpak does */
name = g_strdup_printf ("%s (Nightly)",
gs_app_get_name (priv->app));
gtk_label_set_label (GTK_LABEL (priv->name_label), name);
} else {
gtk_label_set_label (GTK_LABEL (priv->name_label),
gs_app_get_name (priv->app));
}
if (priv->show_update &&
(gs_app_get_state (priv->app) == AS_APP_STATE_UPDATABLE ||
gs_app_get_state (priv->app) == AS_APP_STATE_UPDATABLE_LIVE)) {
g_autofree gchar *verstr = NULL;
verstr = gs_app_row_format_version_update (priv->app);
gtk_label_set_label (GTK_LABEL (priv->version_label), verstr);
gtk_widget_set_visible (priv->version_label, verstr != NULL);
gtk_widget_hide (priv->star);
} else {
gtk_widget_hide (priv->version_label);
if (missing_search_result || gs_app_get_rating (priv->app) <= 0) {
gtk_widget_hide (priv->star);
} else {
gtk_widget_show (priv->star);
gtk_widget_set_sensitive (priv->star, FALSE);
gs_star_widget_set_rating (GS_STAR_WIDGET (priv->star),
gs_app_get_rating (priv->app));
}
gtk_label_set_label (GTK_LABEL (priv->version_label),
gs_app_get_version_ui (priv->app));
}
/* folders */
if (priv->show_folders &&
gs_utils_is_current_desktop ("GNOME") &&
g_settings_get_boolean (priv->settings, "show-folder-management")) {
g_autoptr(GsFolders) folders = NULL;
const gchar *folder;
folders = gs_folders_get ();
folder = gs_folders_get_app_folder (folders,
gs_app_get_id (priv->app),
gs_app_get_categories (priv->app));
if (folder != NULL)
folder = gs_folders_get_folder_name (folders, folder);
gtk_label_set_label (GTK_LABEL (priv->folder_label), folder);
gtk_widget_set_visible (priv->folder_label, folder != NULL);
} else {
gtk_widget_hide (priv->folder_label);
}
/* pixbuf */
if (gs_app_get_pixbuf (priv->app) != NULL)
gs_image_set_from_pixbuf (GTK_IMAGE (priv->image),
gs_app_get_pixbuf (priv->app));
context = gtk_widget_get_style_context (priv->image);
if (missing_search_result)
gtk_style_context_add_class (context, "dimmer-label");
else
gtk_style_context_remove_class (context, "dimmer-label");
/* pending label */
switch (gs_app_get_state (priv->app)) {
case AS_APP_STATE_QUEUED_FOR_INSTALL:
gtk_widget_set_visible (priv->label, TRUE);
gtk_label_set_label (GTK_LABEL (priv->label), _("Pending"));
break;
default:
gtk_widget_set_visible (priv->label, FALSE);
break;
}
/* spinner */
switch (gs_app_get_state (priv->app)) {
case AS_APP_STATE_REMOVING:
gtk_spinner_start (GTK_SPINNER (priv->spinner));
gtk_widget_set_visible (priv->spinner, TRUE);
break;
default:
gtk_widget_set_visible (priv->spinner, FALSE);
break;
}
/* button */
gs_app_row_refresh_button (app_row, missing_search_result);
/* hide buttons in the update list, unless the app is live updatable */
switch (gs_app_get_state (priv->app)) {
case AS_APP_STATE_UPDATABLE_LIVE:
case AS_APP_STATE_INSTALLING:
gtk_widget_set_visible (priv->button_box, TRUE);
break;
default:
gtk_widget_set_visible (priv->button_box, !priv->show_update);
break;
}
/* checkbox */
if (priv->selectable) {
if (gs_app_get_kind (priv->app) == AS_APP_KIND_DESKTOP ||
gs_app_get_kind (priv->app) == AS_APP_KIND_RUNTIME ||
gs_app_get_kind (priv->app) == AS_APP_KIND_WEB_APP)
gtk_widget_set_visible (priv->checkbox, TRUE);
} else {
gtk_widget_set_visible (priv->checkbox, FALSE);
}
installed_size = gs_app_get_size_installed (priv->app);
if (priv->show_installed_size &&
installed_size != GS_APP_SIZE_UNKNOWABLE && installed_size != 0) {
g_autofree gchar *size = NULL;
size = g_format_size (installed_size);
gtk_label_set_label (GTK_LABEL (priv->label_app_size), size);
gtk_widget_show (priv->label_app_size);
} else {
gtk_widget_hide (priv->label_app_size);
}
}
void
gs_page_remove_app (GsPage *page, GsApp *app, GCancellable *cancellable)
{
GsPagePrivate *priv = gs_page_get_instance_private (page);
GsPageHelper *helper;
GtkWidget *dialog;
g_autofree gchar *message = NULL;
g_autofree gchar *title = NULL;
/* pending install */
helper = g_slice_new0 (GsPageHelper);
helper->action = GS_PLUGIN_ACTION_REMOVE;
helper->app = g_object_ref (app);
helper->page = g_object_ref (page);
helper->cancellable = g_object_ref (cancellable);
if (gs_app_get_state (app) == AS_APP_STATE_QUEUED_FOR_INSTALL) {
g_debug ("remove %s", gs_app_get_id (app));
gs_plugin_loader_app_action_async (priv->plugin_loader,
app,
GS_PLUGIN_ACTION_REMOVE,
GS_PLUGIN_FAILURE_FLAGS_FATAL_ANY,
helper->cancellable,
gs_page_app_removed_cb,
helper);
return;
}
/* use different name and summary */
switch (gs_app_get_kind (app)) {
case AS_APP_KIND_SOURCE:
/* TRANSLATORS: this is a prompt message, and '%s' is an
* source name, e.g. 'GNOME Nightly' */
title = g_strdup_printf (_("Are you sure you want to remove "
"the %s source?"),
gs_app_get_name (app));
/* TRANSLATORS: longer dialog text */
message = g_strdup_printf (_("All applications from %s will be "
"removed, and you will have to "
"re-install the source to use them again."),
gs_app_get_name (app));
break;
default:
/* TRANSLATORS: this is a prompt message, and '%s' is an
* application summary, e.g. 'GNOME Clocks' */
title = g_strdup_printf (_("Are you sure you want to remove %s?"),
gs_app_get_name (app));
/* TRANSLATORS: longer dialog text */
message = g_strdup_printf (_("%s will be removed, and you will "
"have to install it to use it again."),
gs_app_get_name (app));
break;
}
/* ask for confirmation */
dialog = gtk_message_dialog_new (gs_shell_get_window (priv->shell),
GTK_DIALOG_MODAL,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_CANCEL,
"%s", title);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
"%s", message);
/* TRANSLATORS: this is button text to remove the application */
gtk_dialog_add_button (GTK_DIALOG (dialog), _("Remove"), GTK_RESPONSE_OK);
/* handle this async */
g_signal_connect (dialog, "response",
G_CALLBACK (gs_page_remove_app_response_cb), helper);
gs_shell_modal_dialog_present (priv->shell, GTK_DIALOG (dialog));
}
/**
* gs_appstream_refine_app:
*/
gboolean
gs_appstream_refine_app (GsPlugin *plugin,
GsApp *app,
AsApp *item,
GError **error)
{
AsRelease *rel;
GHashTable *urls;
GPtrArray *pkgnames;
GPtrArray *kudos;
const gchar *tmp;
guint i;
/* set the kind to be more precise */
if (gs_app_get_kind (app) == AS_APP_KIND_UNKNOWN ||
gs_app_get_kind (app) == AS_APP_KIND_GENERIC) {
gs_app_set_kind (app, as_app_get_kind (item));
}
/* is installed already */
if (gs_app_get_state (app) == AS_APP_STATE_UNKNOWN) {
switch (as_app_get_source_kind (item)) {
case AS_APP_SOURCE_KIND_APPDATA:
case AS_APP_SOURCE_KIND_DESKTOP:
gs_app_set_kind (app, AS_APP_KIND_DESKTOP);
gs_app_set_state (app, AS_APP_STATE_INSTALLED);
break;
case AS_APP_SOURCE_KIND_METAINFO:
gs_app_set_state (app, AS_APP_STATE_INSTALLED);
break;
case AS_APP_SOURCE_KIND_APPSTREAM:
gs_app_set_state (app, as_app_get_state (item));
break;
default:
break;
}
}
/* set management plugin automatically */
gs_refine_item_management_plugin (app, item);
/* set id */
if (as_app_get_id (item) != NULL && gs_app_get_id (app) == NULL)
gs_app_set_id (app, as_app_get_id (item));
/* set name */
tmp = as_app_get_name (item, NULL);
if (tmp != NULL) {
if (g_str_has_prefix (tmp, "(Nightly) ")) {
tmp += 10;
if (gs_app_get_metadata_item (app, "X-XdgApp-Tags") == NULL)
gs_app_set_metadata (app, "X-XdgApp-Tags", "nightly");
}
gs_app_set_name (app, GS_APP_QUALITY_HIGHEST, tmp);
}
/* set summary */
tmp = as_app_get_comment (item, NULL);
if (tmp != NULL) {
gs_app_set_summary (app, GS_APP_QUALITY_HIGHEST, tmp);
}
/* add urls */
urls = as_app_get_urls (item);
if (g_hash_table_size (urls) > 0 &&
gs_app_get_url (app, AS_URL_KIND_HOMEPAGE) == NULL) {
GList *l;
g_autoptr(GList) keys = NULL;
keys = g_hash_table_get_keys (urls);
for (l = keys; l != NULL; l = l->next) {
gs_app_set_url (app,
as_url_kind_from_string (l->data),
g_hash_table_lookup (urls, l->data));
}
}
/* set licence */
if (as_app_get_project_license (item) != NULL && gs_app_get_license (app) == NULL)
gs_app_set_license (app,
GS_APP_QUALITY_HIGHEST,
as_app_get_project_license (item));
/* set keywords */
if (as_app_get_keywords (item, NULL) != NULL &&
gs_app_get_keywords (app) == NULL) {
gs_app_set_keywords (app, as_app_get_keywords (item, NULL));
gs_app_add_kudo (app, GS_APP_KUDO_HAS_KEYWORDS);
}
/* set origin */
if (as_app_get_origin (item) != NULL &&
gs_app_get_origin (app) == NULL) {
gs_app_set_origin (app, as_app_get_origin (item));
}
/* set description */
tmp = as_app_get_description (item, NULL);
if (tmp != NULL) {
g_autofree gchar *from_xml = NULL;
from_xml = as_markup_convert_simple (tmp, error);
if (from_xml == NULL) {
g_prefix_error (error, "trying to parse '%s': ", tmp);
return FALSE;
}
gs_app_set_description (app, GS_APP_QUALITY_HIGHEST, from_xml);
}
/* set icon */
if (as_app_get_icon_default (item) != NULL && gs_app_get_pixbuf (app) == NULL)
gs_refine_item_pixbuf (plugin, app, item);
/* set categories */
if (as_app_get_categories (item) != NULL &&
gs_app_get_categories (app)->len == 0)
gs_app_set_categories (app, as_app_get_categories (item));
/* set project group */
if (as_app_get_project_group (item) != NULL &&
gs_app_get_project_group (app) == NULL)
gs_app_set_project_group (app, as_app_get_project_group (item));
/* this is a core application for the desktop and cannot be removed */
if (_as_app_has_compulsory_for_desktop (item, "GNOME") &&
gs_app_get_kind (app) == AS_APP_KIND_DESKTOP)
gs_app_add_quirk (app, AS_APP_QUIRK_COMPULSORY);
/* set id kind */
if (gs_app_get_kind (app) == AS_APP_KIND_UNKNOWN)
gs_app_set_kind (app, as_app_get_kind (item));
/* copy all the metadata */
gs_appstream_copy_metadata (app, item);
/* set package names */
pkgnames = as_app_get_pkgnames (item);
if (pkgnames->len > 0 && gs_app_get_sources(app)->len == 0)
gs_app_set_sources (app, pkgnames);
/* set addons */
gs_appstream_refine_add_addons (plugin, app, item);
/* set screenshots */
gs_appstream_refine_add_screenshots (app, item);
/* are the screenshots perfect */
if (gs_appstream_are_screenshots_perfect (item))
gs_app_add_kudo (app, GS_APP_KUDO_PERFECT_SCREENSHOTS);
/* was this application released recently */
if (gs_appstream_is_recent_release (item))
gs_app_add_kudo (app, GS_APP_KUDO_RECENT_RELEASE);
/* add kudos */
if (as_app_get_language (item, plugin->locale) > 50)
gs_app_add_kudo (app, GS_APP_KUDO_MY_LANGUAGE);
/* add new-style kudos */
kudos = as_app_get_kudos (item);
for (i = 0; i < kudos->len; i++) {
tmp = g_ptr_array_index (kudos, i);
switch (as_kudo_kind_from_string (tmp)) {
case AS_KUDO_KIND_SEARCH_PROVIDER:
gs_app_add_kudo (app, GS_APP_KUDO_SEARCH_PROVIDER);
break;
case AS_KUDO_KIND_USER_DOCS:
gs_app_add_kudo (app, GS_APP_KUDO_INSTALLS_USER_DOCS);
break;
case AS_KUDO_KIND_APP_MENU:
gs_app_add_kudo (app, GS_APP_KUDO_USES_APP_MENU);
break;
case AS_KUDO_KIND_MODERN_TOOLKIT:
gs_app_add_kudo (app, GS_APP_KUDO_MODERN_TOOLKIT);
break;
case AS_KUDO_KIND_NOTIFICATIONS:
gs_app_add_kudo (app, GS_APP_KUDO_USES_NOTIFICATIONS);
break;
case AS_KUDO_KIND_HIGH_CONTRAST:
gs_app_add_kudo (app, GS_APP_KUDO_HIGH_CONTRAST);
break;
case AS_KUDO_KIND_HI_DPI_ICON:
gs_app_add_kudo (app, GS_APP_KUDO_HI_DPI_ICON);
break;
default:
g_debug ("no idea how to handle kudo '%s'", tmp);
break;
}
}
/* is there any update information */
rel = as_app_get_release_default (item);
if (rel != NULL) {
tmp = as_release_get_description (rel, NULL);
if (tmp != NULL) {
g_autofree gchar *desc = NULL;
desc = as_markup_convert (tmp,
AS_MARKUP_CONVERT_FORMAT_MARKDOWN,
error);
if (desc == NULL)
return FALSE;
gs_app_set_update_details (app, desc);
}
gs_app_set_update_urgency (app, as_release_get_urgency (rel));
gs_app_set_update_version (app, as_release_get_version (rel));
}
return TRUE;
}
