/**
* gs_plugin_refine_item_commit:
*/
static gboolean
gs_plugin_refine_item_commit (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
g_autoptr(AsProfileTask) ptask = NULL;
g_autoptr(XdgAppRemoteRef) xref_remote = NULL;
if (gs_app_get_xdgapp_commit (app) != NULL)
return TRUE;
if (gs_app_get_origin (app) == NULL) {
g_debug ("no origin got commit, so refining origin first");
if (!gs_plugin_refine_item_origin (plugin, app, cancellable, error))
return FALSE;
}
ptask = as_profile_start_literal (gs_plugin_get_profile (plugin),
"xdg-app::fetch-remote-ref");
xref_remote = xdg_app_installation_fetch_remote_ref_sync (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),
cancellable,
error);
if (xref_remote == NULL)
return FALSE;
gs_app_set_xdgapp_commit (app, xdg_app_ref_get_commit (XDG_APP_REF (xref_remote)));
return TRUE;
}
gboolean
gs_plugin_refine_app (GsPlugin *plugin,
GsApp *app,
GsPluginRefineFlags flags,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
const gchar *tmp;
/* not required */
if ((flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_ORIGIN_HOSTNAME) == 0)
return TRUE;
if (gs_app_get_origin_hostname (app) != NULL)
return TRUE;
/* ensure valid */
if (!gs_plugin_repos_setup (plugin, cancellable, error))
return FALSE;
/* find hostname */
if (gs_app_get_origin (app) == NULL)
return TRUE;
tmp = g_hash_table_lookup (priv->urls, gs_app_get_origin (app));
if (tmp != NULL)
gs_app_set_origin_hostname (app, tmp);
return TRUE;
}
/**
* gs_plugin_refine_item_state:
*/
static gboolean
gs_plugin_refine_item_state (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
guint i;
g_autoptr(GPtrArray) xrefs = NULL;
g_autoptr(AsProfileTask) ptask = NULL;
/* already found */
if (gs_app_get_state (app) != AS_APP_STATE_UNKNOWN)
return TRUE;
/* need broken out metadata */
if (!gs_plugin_refine_item_metadata (plugin, app, cancellable, error))
return FALSE;
/* get apps and runtimes */
ptask = as_profile_start_literal (gs_plugin_get_profile (plugin),
"xdg-app::refine-action");
xrefs = xdg_app_installation_list_installed_refs (priv->installation,
cancellable, error);
if (xrefs == NULL)
return FALSE;
for (i = 0; i < xrefs->len; i++) {
XdgAppInstalledRef *xref = g_ptr_array_index (xrefs, i);
/* check xref is app */
if (!gs_plugin_xdg_app_is_xref (app, XDG_APP_REF(xref)))
continue;
/* mark as installed */
g_debug ("marking %s as installed with xdg-app",
gs_app_get_id (app));
gs_plugin_xdg_app_set_metadata_installed (app, xref);
if (gs_app_get_state (app) == AS_APP_STATE_UNKNOWN)
gs_app_set_state (app, AS_APP_STATE_INSTALLED);
}
/* anything not installed just check the remote is still present */
if (gs_app_get_state (app) == AS_APP_STATE_UNKNOWN &&
gs_app_get_origin (app) != NULL) {
g_autoptr(XdgAppRemote) xremote = NULL;
xremote = xdg_app_installation_get_remote_by_name (priv->installation,
gs_app_get_origin (app),
cancellable, NULL);
if (xremote != NULL) {
g_debug ("marking %s as available with xdg-app",
gs_app_get_id (app));
gs_app_set_state (app, AS_APP_STATE_AVAILABLE);
}
}
/* success */
return TRUE;
}
gboolean
gs_plugin_refine_app (GsPlugin *plugin,
GsApp *app,
GsPluginRefineFlags flags,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
const gchar *origin;
/* not required */
if ((flags & GS_PLUGIN_REFINE_FLAGS_REQUIRE_LICENSE) == 0)
return TRUE;
/* no provenance */
if (!gs_app_has_quirk (app, AS_APP_QUIRK_PROVENANCE))
return TRUE;
/* nothing to search */
if (priv->sources == NULL || priv->sources[0] == NULL)
return TRUE;
/* simple case */
origin = gs_app_get_origin (app);
if (origin != NULL && gs_utils_strv_fnmatch (priv->sources, origin))
gs_app_set_license (app, GS_APP_QUALITY_NORMAL, priv->license_id);
return TRUE;
}
static gboolean
gs_plugin_app_source_enable (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
ProgressData data;
g_autoptr(PkResults) results = NULL;
data.app = app;
data.plugin = plugin;
data.ptask = NULL;
/* do sync call */
gs_plugin_status_update (plugin, app, GS_PLUGIN_STATUS_WAITING);
results = pk_client_repo_enable (PK_CLIENT (priv->task),
gs_app_get_origin (app),
TRUE,
cancellable,
gs_plugin_packagekit_progress_cb, &data,
error);
if (!gs_plugin_packagekit_results_valid (results, error)) {
gs_utils_error_add_unique_id (error, app);
return FALSE;
}
return TRUE;
}
/**
* gs_plugin_refine_item_origin:
*/
static gboolean
gs_plugin_refine_item_origin (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
guint i;
g_autoptr(GPtrArray) xremotes = NULL;
g_autoptr(AsProfileTask) ptask = NULL;
/* already set */
if (gs_app_get_origin (app) != NULL)
return TRUE;
/* ensure metadata exists */
ptask = as_profile_start_literal (gs_plugin_get_profile (plugin),
"xdg-app::refine-origin");
if (!gs_plugin_refine_item_metadata (plugin, app, cancellable, error))
return FALSE;
/* find list of remotes */
g_debug ("looking for a remote for %s/%s/%s",
gs_app_get_xdgapp_name (app),
gs_app_get_xdgapp_arch (app),
gs_app_get_xdgapp_branch (app));
xremotes = xdg_app_installation_list_remotes (priv->installation,
cancellable,
error);
if (xremotes == NULL)
return FALSE;
for (i = 0; i < xremotes->len; i++) {
const gchar *remote_name;
XdgAppRemote *xremote = g_ptr_array_index (xremotes, i);
g_autoptr(XdgAppRemoteRef) xref = NULL;
remote_name = xdg_app_remote_get_name (xremote);
g_debug ("looking at remote %s", remote_name);
xref = xdg_app_installation_fetch_remote_ref_sync (priv->installation,
remote_name,
gs_app_get_xdgapp_kind (app),
gs_app_get_xdgapp_name (app),
gs_app_get_xdgapp_arch (app),
gs_app_get_xdgapp_branch (app),
cancellable,
NULL);
if (xref != NULL) {
g_debug ("found remote %s", remote_name);
gs_app_set_origin (app, remote_name);
return TRUE;
}
}
g_set_error (error,
GS_PLUGIN_ERROR,
GS_PLUGIN_ERROR_NOT_SUPPORTED,
"Not found %s/%s/%s",
gs_app_get_xdgapp_name (app),
gs_app_get_xdgapp_arch (app),
gs_app_get_xdgapp_branch (app));
return FALSE;
}
/**
* gs_plugin_refine_item_origin_ui:
*/
static gboolean
gs_plugin_refine_item_origin_ui (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
const gchar *origin;
guint i;
g_autoptr(GPtrArray) xremotes = NULL;
g_autoptr(AsProfileTask) ptask = NULL;
/* already set */
origin = gs_app_get_origin_ui (app);
if (origin != NULL)
return TRUE;
/* find list of remotes */
ptask = as_profile_start_literal (gs_plugin_get_profile (plugin),
"xdg-app::refine-origin-ui");
xremotes = xdg_app_installation_list_remotes (priv->installation,
cancellable,
error);
if (xremotes == NULL)
return FALSE;
for (i = 0; i < xremotes->len; i++) {
XdgAppRemote *xremote = g_ptr_array_index (xremotes, i);
if (g_strcmp0 (gs_app_get_origin (app),
xdg_app_remote_get_name (xremote)) == 0) {
gs_app_set_origin_ui (app, xdg_app_remote_get_title (xremote));
break;
}
}
return TRUE;
}
/**
* 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;
}
/**
* gs_plugin_refine_item_runtime:
*/
static gboolean
gs_plugin_refine_item_runtime (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
const gchar *commit;
const gchar *str;
gsize len = -1;
g_autofree gchar *contents = NULL;
g_autofree gchar *installation_path_str = NULL;
g_autofree gchar *install_path = NULL;
g_autoptr(GBytes) data = NULL;
g_autoptr(GFile) installation_path = NULL;
g_autoptr(XdgAppInstalledRef) xref = NULL;
/* not applicable */
if (gs_app_get_xdgapp_kind (app) != XDG_APP_REF_KIND_APP)
return TRUE;
/* already exists */
if (gs_app_get_runtime (app) != NULL)
return TRUE;
/* this is quicker than doing network IO */
installation_path = xdg_app_installation_get_path (priv->installation);
installation_path_str = g_file_get_path (installation_path);
install_path = g_build_filename (installation_path_str,
gs_app_get_xdgapp_kind_as_str (app),
gs_app_get_xdgapp_name (app),
gs_app_get_xdgapp_arch (app),
gs_app_get_xdgapp_branch (app),
"active",
"metadata",
NULL);
if (g_file_test (install_path, G_FILE_TEST_EXISTS)) {
if (!g_file_get_contents (install_path, &contents, &len, error))
return FALSE;
str = contents;
} else {
/* need commit */
if (!gs_plugin_refine_item_commit (plugin, app, cancellable, error))
return FALSE;
/* fetch from the server */
commit = gs_app_get_xdgapp_commit (app);
data = xdg_app_installation_fetch_remote_metadata_sync (priv->installation,
gs_app_get_origin (app),
commit,
cancellable,
error);
if (data == NULL)
return FALSE;
str = g_bytes_get_data (data, &len);
}
/* parse key file */
if (!gs_plugin_xdg_app_set_app_metadata (app, str, len, error))
return FALSE;
return TRUE;
}
/**
* 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;
}
/**
* gs_plugin_refine_item_size:
*/
static gboolean
gs_plugin_refine_item_size (GsPlugin *plugin,
GsApp *app,
GCancellable *cancellable,
GError **error)
{
GsPluginData *priv = gs_plugin_get_data (plugin);
gboolean ret;
guint64 download_size;
guint64 installed_size;
g_autoptr(AsProfileTask) ptask = NULL;
g_autoptr(GError) error_local = NULL;
/* already set */
if (gs_app_get_size_installed (app) > 0 &&
gs_app_get_size_download (app) > 0)
return TRUE;
/* need commit */
if (!gs_plugin_refine_item_commit (plugin, app, cancellable, error))
return FALSE;
/* need runtime */
if (!gs_plugin_refine_item_runtime (plugin, app, cancellable, error))
return FALSE;
/* calculate the platform size too if the app is not installed */
if (gs_app_get_state (app) == AS_APP_STATE_AVAILABLE &&
gs_app_get_xdgapp_kind (app) == XDG_APP_REF_KIND_APP) {
GsApp *app_runtime;
/* find out what runtime the application depends on */
if (!gs_plugin_refine_item_runtime (plugin,
app,
cancellable,
error))
return FALSE;
/* is the app_runtime already installed? */
app_runtime = gs_app_get_runtime (app);
if (!gs_plugin_refine_item_state (plugin,
app_runtime,
cancellable,
error))
return FALSE;
if (gs_app_get_state (app_runtime) == AS_APP_STATE_INSTALLED) {
g_debug ("runtime %s is already installed, so not adding size",
gs_app_get_id (app_runtime));
} else {
if (!gs_plugin_refine_item_size (plugin,
app_runtime,
cancellable,
error))
return FALSE;
}
}
/* just get the size of the runtime */
ptask = as_profile_start_literal (gs_plugin_get_profile (plugin),
"xdg-app::refine-size");
ret = xdg_app_installation_fetch_remote_size_sync (priv->installation,
gs_app_get_origin (app),
gs_app_get_xdgapp_commit (app),
&download_size,
&installed_size,
cancellable, &error_local);
if (!ret) {
g_warning ("libxdgapp failed to return application size: %s",
error_local->message);
gs_app_set_size_installed (app, GS_APP_SIZE_UNKNOWABLE);
gs_app_set_size_download (app, GS_APP_SIZE_UNKNOWABLE);
} else {
gs_app_set_size_installed (app, installed_size);
gs_app_set_size_download (app, download_size);
}
return TRUE;
}
/**
* gs_app_notify_unavailable:
**/
GtkResponseType
gs_app_notify_unavailable (GsApp *app, GtkWindow *parent)
{
GsAppLicenceHint hint = GS_APP_LICENCE_FREE;
GtkResponseType response;
GtkWidget *dialog;
const gchar *licence;
gboolean already_enabled = FALSE; /* FIXME */
guint i;
struct {
const gchar *str;
GsAppLicenceHint hint;
} keywords[] = {
{ "NonFree", GS_APP_LICENCE_NONFREE },
{ "PatentConcern", GS_APP_LICENCE_PATENT_CONCERN },
{ "Proprietary", GS_APP_LICENCE_NONFREE },
{ NULL, 0 }
};
_cleanup_free_ gchar *origin_url = NULL;
_cleanup_object_unref_ GSettings *settings = NULL;
_cleanup_string_free_ GString *body = NULL;
_cleanup_string_free_ GString *title = NULL;
/* this is very crude */
licence = gs_app_get_licence (app);
if (licence != NULL) {
for (i = 0; keywords[i].str != NULL; i++) {
if (g_strstr_len (licence, -1, keywords[i].str) != NULL)
hint |= keywords[i].hint;
}
} else {
/* use the worst-case assumption */
hint = GS_APP_LICENCE_NONFREE | GS_APP_LICENCE_PATENT_CONCERN;
}
/* check if the user has already dismissed */
settings = g_settings_new ("org.gnome.software");
if (!g_settings_get_boolean (settings, "prompt-for-nonfree"))
return GTK_RESPONSE_OK;
title = g_string_new ("");
if (already_enabled) {
g_string_append_printf (title, "<b>%s</b>",
/* TRANSLATORS: window title */
_("Install Third-Party Software?"));
} else {
g_string_append_printf (title, "<b>%s</b>",
/* TRANSLATORS: window title */
_("Enable Third-Party Software Source?"));
}
dialog = gtk_message_dialog_new (parent,
GTK_DIALOG_MODAL,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_CANCEL,
NULL);
gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (dialog), title->str);
/* FIXME: get the URL somehow... */
origin_url = g_strdup_printf ("<a href=\"\">%s>/a>", gs_app_get_origin (app));
body = g_string_new ("");
if (hint & GS_APP_LICENCE_NONFREE) {
g_string_append_printf (body,
/* TRANSLATORS: the replacements are as follows:
* 1. Application name, e.g. "Firefox"
* 2. Software source name, e.g. fedora-optional
*/
_("%s is not <a href=\"https://en.wikipedia.org/wiki/Free_and_open-source_software\">"
"free and open source software</a>, "
"and is provided by “%s”."),
gs_app_get_name (app),
origin_url);
} else {
g_string_append_printf (body,
/* TRANSLATORS: the replacements are as follows:
* 1. Application name, e.g. "Firefox"
* 2. Software source name, e.g. fedora-optional */
_("%s is provided by “%s”."),
gs_app_get_name (app),
origin_url);
}
/* tell the use what needs to be done */
if (!already_enabled) {
g_string_append (body, " ");
g_string_append (body,
/* TRANSLATORS: a software source is a repo */
_("This software source must be "
"enabled to continue installation."));
}
/* be aware of patent clauses */
if (hint & GS_APP_LICENCE_PATENT_CONCERN) {
g_string_append (body, "\n\n");
if (gs_app_get_id_kind (app) != AS_ID_KIND_CODEC) {
g_string_append_printf (body,
/* TRANSLATORS: Laws are geographical, urgh... */
_("It may be illegal to install "
"or use %s in some countries."),
gs_app_get_name (app));
} else {
g_string_append (body,
/* TRANSLATORS: Laws are geographical, urgh... */
_("It may be illegal to install or use "
"this codec in some countries."));
}
}
gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog), "%s", body->str);
/* TRANSLATORS: this is button text to not ask about non-free content again */
if (0) gtk_dialog_add_button (GTK_DIALOG (dialog), _("Don't Warn Again"), GTK_RESPONSE_YES);
if (already_enabled) {
gtk_dialog_add_button (GTK_DIALOG (dialog),
/* TRANSLATORS: button text */
_("Install"),
GTK_RESPONSE_OK);
} else {
gtk_dialog_add_button (GTK_DIALOG (dialog),
/* TRANSLATORS: button text */
_("Enable and Install"),
GTK_RESPONSE_OK);
}
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response == GTK_RESPONSE_YES) {
response = GTK_RESPONSE_OK;
g_settings_set_boolean (settings, "prompt-for-nonfree", FALSE);
}
gtk_widget_destroy (dialog);
return response;
}
