diff options
Diffstat (limited to 'panels/common')
34 files changed, 5017 insertions, 0 deletions
diff --git a/panels/common/cc-common-language.c b/panels/common/cc-common-language.c new file mode 100644 index 0000000..9357c3e --- /dev/null +++ b/panels/common/cc-common-language.c @@ -0,0 +1,304 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright 2009-2010 Red Hat, Inc, + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <http://www.gnu.org/licenses/>. + * + * Written by: Matthias Clasen <mclasen@redhat.com> + */ + +#include "config.h" + +#include <stdlib.h> +#include <locale.h> + +#include <glib.h> +#include <glib/gi18n.h> +#include <gtk/gtk.h> + +#include <fontconfig/fontconfig.h> + +#define GNOME_DESKTOP_USE_UNSTABLE_API +#include <libgnome-desktop/gnome-languages.h> + +#include "cc-common-language.h" +#include "shell/cc-object-storage.h" + +static char *get_lang_for_user_object_path (const char *path); + +static gboolean +iter_for_language (GtkTreeModel *model, + const gchar *lang, + GtkTreeIter *iter, + gboolean region) +{ + g_autofree gchar *name = NULL; + + g_assert (gtk_tree_model_get_iter_first (model, iter)); + do { + g_autofree gchar *l = NULL; + gtk_tree_model_get (model, iter, LOCALE_COL, &l, -1); + if (g_strcmp0 (l, lang) == 0) + return TRUE; + } while (gtk_tree_model_iter_next (model, iter)); + + name = gnome_normalize_locale (lang); + if (name != NULL) { + g_autofree gchar *language = NULL; + + if (region) { + language = gnome_get_country_from_locale (name, NULL); + } + else { + language = gnome_get_language_from_locale (name, NULL); + } + + gtk_list_store_insert_with_values (GTK_LIST_STORE (model), + iter, + -1, + LOCALE_COL, name, + DISPLAY_LOCALE_COL, language, + -1); + return TRUE; + } + + return FALSE; +} + +gboolean +cc_common_language_get_iter_for_language (GtkTreeModel *model, + const gchar *lang, + GtkTreeIter *iter) +{ + return iter_for_language (model, lang, iter, FALSE); +} + +gboolean +cc_common_language_has_font (const gchar *locale) +{ + const FcCharSet *charset; + FcPattern *pattern; + FcObjectSet *object_set; + FcFontSet *font_set; + g_autofree gchar *language_code = NULL; + gboolean is_displayable; + + is_displayable = FALSE; + pattern = NULL; + object_set = NULL; + font_set = NULL; + + if (!gnome_parse_locale (locale, &language_code, NULL, NULL, NULL)) + return FALSE; + + charset = FcLangGetCharSet ((FcChar8 *) language_code); + if (!charset) { + /* fontconfig does not know about this language */ + is_displayable = TRUE; + } + else { + /* see if any fonts support rendering it */ + pattern = FcPatternBuild (NULL, FC_LANG, FcTypeString, language_code, NULL); + + if (pattern == NULL) + goto done; + + object_set = FcObjectSetCreate (); + + if (object_set == NULL) + goto done; + + font_set = FcFontList (NULL, pattern, object_set); + + if (font_set == NULL) + goto done; + + is_displayable = (font_set->nfont > 0); + } + + done: + if (font_set != NULL) + FcFontSetDestroy (font_set); + + if (object_set != NULL) + FcObjectSetDestroy (object_set); + + if (pattern != NULL) + FcPatternDestroy (pattern); + + return is_displayable; +} + +gchar * +cc_common_language_get_current_language (void) +{ + gchar *language; + g_autofree gchar *path = NULL; + const gchar *locale; + + path = g_strdup_printf ("/org/freedesktop/Accounts/User%d", getuid ()); + language = get_lang_for_user_object_path (path); + if (language != NULL && *language != '\0') + return language; + + locale = (const gchar *) setlocale (LC_MESSAGES, NULL); + if (locale) + language = gnome_normalize_locale (locale); + else + language = NULL; + + return language; +} + +static char * +get_lang_for_user_object_path (const char *path) +{ + g_autoptr(GError) error = NULL; + g_autoptr(GDBusProxy) user = NULL; + g_autoptr(GVariant) props = NULL; + char *lang; + + user = cc_object_storage_create_dbus_proxy_sync (G_BUS_TYPE_SYSTEM, + G_DBUS_PROXY_FLAGS_NONE, + "org.freedesktop.Accounts", + path, + "org.freedesktop.Accounts.User", + NULL, + &error); + if (user == NULL) { + g_warning ("Failed to get proxy for user '%s': %s", + path, error->message); + return NULL; + } + + props = g_dbus_proxy_get_cached_property (user, "Language"); + if (props == NULL) + return NULL; + lang = g_variant_dup_string (props, NULL); + + return lang; +} + +/* + * Note that @lang needs to be formatted like the locale strings + * returned by gnome_get_all_locales(). + */ +static void +insert_language (GHashTable *ht, + const char *lang) +{ + g_autofree gchar *label_own_lang = NULL; + g_autofree gchar *label_current_lang = NULL; + g_autofree gchar *label_untranslated = NULL; + + label_own_lang = gnome_get_language_from_locale (lang, lang); + label_current_lang = gnome_get_language_from_locale (lang, NULL); + label_untranslated = gnome_get_language_from_locale (lang, "C"); + + /* We don't have a translation for the label in + * its own language? */ + if (g_strcmp0 (label_own_lang, label_untranslated) == 0) { + if (g_strcmp0 (label_current_lang, label_untranslated) == 0) + g_hash_table_insert (ht, g_strdup (lang), g_strdup (label_untranslated)); + else + g_hash_table_insert (ht, g_strdup (lang), g_strdup (label_current_lang)); + } else { + g_hash_table_insert (ht, g_strdup (lang), g_strdup (label_own_lang)); + } +} + +GHashTable * +cc_common_language_get_initial_languages (void) +{ + GHashTable *ht; + + ht = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); + + insert_language (ht, "en_US.UTF-8"); + insert_language (ht, "en_GB.UTF-8"); + insert_language (ht, "de_DE.UTF-8"); + insert_language (ht, "fr_FR.UTF-8"); + insert_language (ht, "es_ES.UTF-8"); + insert_language (ht, "zh_CN.UTF-8"); + insert_language (ht, "ja_JP.UTF-8"); + insert_language (ht, "ru_RU.UTF-8"); + insert_language (ht, "ar_EG.UTF-8"); + + return ht; +} + +static void +foreach_user_lang_cb (gpointer key, + gpointer value, + gpointer user_data) +{ + GtkListStore *store = (GtkListStore *) user_data; + const char *locale = (const char *) key; + const char *display_locale = (const char *) value; + GtkTreeIter iter; + + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, + LOCALE_COL, locale, + DISPLAY_LOCALE_COL, display_locale, + -1); +} + +void +cc_common_language_add_user_languages (GtkTreeModel *model) +{ + g_autofree gchar *name = NULL; + GtkTreeIter iter; + GtkListStore *store = GTK_LIST_STORE (model); + GHashTable *user_langs; + const char *display; + + gtk_list_store_clear (store); + + user_langs = cc_common_language_get_initial_languages (); + + /* Add the current locale first */ + name = cc_common_language_get_current_language (); + display = g_hash_table_lookup (user_langs, name); + if (!display) { + g_autofree gchar *language = NULL; + g_autofree gchar *country = NULL; + g_autofree gchar *codeset = NULL; + + gnome_parse_locale (name, &language, &country, &codeset, NULL); + + if (!codeset || !g_str_equal (codeset, "UTF-8")) + g_warning ("Current user locale codeset isn't UTF-8"); + + g_free (name); + name = g_strdup_printf ("%s_%s.UTF-8", language, country); + + insert_language (user_langs, name); + display = g_hash_table_lookup (user_langs, name); + } + + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, LOCALE_COL, name, DISPLAY_LOCALE_COL, display, -1); + g_hash_table_remove (user_langs, name); + + /* The rest of the languages */ + g_hash_table_foreach (user_langs, (GHFunc) foreach_user_lang_cb, store); + + /* And now the "Other…" selection */ + gtk_list_store_append (store, &iter); + gtk_list_store_set (store, &iter, LOCALE_COL, NULL, DISPLAY_LOCALE_COL, _("Other…"), -1); + + g_hash_table_destroy (user_langs); +} + diff --git a/panels/common/cc-common-language.h b/panels/common/cc-common-language.h new file mode 100644 index 0000000..1f578b7 --- /dev/null +++ b/panels/common/cc-common-language.h @@ -0,0 +1,58 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright 2009-2010 Red Hat, Inc, + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <http://www.gnu.org/licenses/>. + * + * Written by: Matthias Clasen <mclasen@redhat.com> + */ + +#pragma once + +#include <gtk/gtk.h> + +G_BEGIN_DECLS + +enum { + LOCALE_COL, + DISPLAY_LOCALE_COL, + SEPARATOR_COL, + USER_LANGUAGE, + NUM_COLS +}; + +gboolean cc_common_language_get_iter_for_language (GtkTreeModel *model, + const gchar *lang, + GtkTreeIter *iter); +gboolean cc_common_language_get_iter_for_region (GtkTreeModel *model, + const gchar *lang, + GtkTreeIter *iter); +guint cc_common_language_add_available_languages (GtkListStore *store, + gboolean regions, + GHashTable *user_langs); +gboolean cc_common_language_has_font (const gchar *locale); +gchar *cc_common_language_get_current_language (void); + +GHashTable *cc_common_language_get_initial_languages (void); +GHashTable *cc_common_language_get_user_languages (void); +GHashTable *cc_common_language_get_initial_regions (const gchar *lang); + +void cc_common_language_setup_list (GtkWidget *treeview, + GHashTable *users, + GHashTable *initial); +void cc_common_language_select_current_language (GtkTreeView *treeview); + +void cc_common_language_add_user_languages (GtkTreeModel *model); + +G_END_DECLS diff --git a/panels/common/cc-hostname-entry.c b/panels/common/cc-hostname-entry.c new file mode 100644 index 0000000..aff139c --- /dev/null +++ b/panels/common/cc-hostname-entry.c @@ -0,0 +1,263 @@ +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- + * + * Copyright (C) 2013 Intel, Inc + * Copyright (C) 2011,2012 Red Hat, Inc + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <http://www.gnu.org/licenses/>. + * + */ + + +#include "cc-hostname-entry.h" +#include "hostname-helper.h" + +#include <polkit/polkit.h> + +struct _CcHostnameEntry +{ + GtkEntry parent; + + GDBusProxy *hostnamed_proxy; + guint set_hostname_timeout_source_id; +}; + +G_DEFINE_TYPE (CcHostnameEntry, cc_hostname_entry, GTK_TYPE_ENTRY) + +#define SET_HOSTNAME_TIMEOUT 1 + +static void +cc_hostname_entry_set_hostname (CcHostnameEntry *self) +{ + g_autofree gchar *hostname = NULL; + g_autoptr(GVariant) pretty_result = NULL; + g_autoptr(GVariant) static_result = NULL; + g_autoptr(GError) pretty_error = NULL; + g_autoptr(GError) static_error = NULL; + const gchar *text; + + text = gtk_entry_get_text (GTK_ENTRY (self)); + + g_debug ("Setting PrettyHostname to '%s'", text); + pretty_result = g_dbus_proxy_call_sync (self->hostnamed_proxy, + "SetPrettyHostname", + g_variant_new ("(sb)", text, FALSE), + G_DBUS_CALL_FLAGS_NONE, + -1, NULL, &pretty_error); + if (pretty_result == NULL) + g_warning ("Could not set PrettyHostname: %s", pretty_error->message); + + /* Set the static hostname */ + hostname = pretty_hostname_to_static (text, FALSE); + g_assert (hostname); + + g_debug ("Setting StaticHostname to '%s'", hostname); + static_result = g_dbus_proxy_call_sync (self->hostnamed_proxy, + "SetStaticHostname", + g_variant_new ("(sb)", hostname, FALSE), + G_DBUS_CALL_FLAGS_NONE, + -1, NULL, &static_error); + if (static_result == NULL) + g_warning ("Could not set StaticHostname: %s", static_error->message); +} + +static char * +get_hostname_property (CcHostnameEntry *self, + const char *property) +{ + g_autoptr(GVariant) variant = NULL; + + if (!self->hostnamed_proxy) + return g_strdup (""); + + variant = g_dbus_proxy_get_cached_property (self->hostnamed_proxy, + property); + if (!variant) + { + g_autoptr(GError) error = NULL; + g_autoptr(GVariant) inner = NULL; + + /* Work around systemd-hostname not sending us back + * the property value when changing values */ + variant = g_dbus_proxy_call_sync (self->hostnamed_proxy, + "org.freedesktop.DBus.Properties.Get", + g_variant_new ("(ss)", "org.freedesktop.hostname1", property), + G_DBUS_CALL_FLAGS_NONE, + -1, + NULL, + &error); + if (variant == NULL) + { + g_warning ("Failed to get property '%s': %s", property, error->message); + return NULL; + } + + g_variant_get (variant, "(v)", &inner); + return g_variant_dup_string (inner, NULL); + } + else + { + return g_variant_dup_string (variant, NULL); + } +} + +static char * +cc_hostname_entry_get_display_hostname (CcHostnameEntry *self) +{ + g_autofree gchar *str = NULL; + + str = get_hostname_property (self, "PrettyHostname"); + + /* Empty strings means that we need to fallback */ + if (str != NULL && + *str == '\0') + return get_hostname_property (self, "Hostname"); + + return g_steal_pointer (&str); +} + +static gboolean +set_hostname_timeout (CcHostnameEntry *self) +{ + self->set_hostname_timeout_source_id = 0; + + cc_hostname_entry_set_hostname (self); + + return FALSE; +} + +static void +remove_hostname_timeout (CcHostnameEntry *self) +{ + if (self->set_hostname_timeout_source_id) + g_source_remove (self->set_hostname_timeout_source_id); + + self->set_hostname_timeout_source_id = 0; +} + +static void +reset_hostname_timeout (CcHostnameEntry *self) +{ + remove_hostname_timeout (self); + + self->set_hostname_timeout_source_id = g_timeout_add_seconds (SET_HOSTNAME_TIMEOUT, + (GSourceFunc) set_hostname_timeout, + self); +} + +static void +text_changed_cb (CcHostnameEntry *entry) +{ + reset_hostname_timeout (entry); +} + +static void +cc_hostname_entry_dispose (GObject *object) +{ + CcHostnameEntry *self = CC_HOSTNAME_ENTRY (object); + + if (self->set_hostname_timeout_source_id) + { + remove_hostname_timeout (self); + set_hostname_timeout (self); + } + + g_clear_object (&self->hostnamed_proxy); + + G_OBJECT_CLASS (cc_hostname_entry_parent_class)->dispose (object); +} + +static void +cc_hostname_entry_constructed (GObject *object) +{ + CcHostnameEntry *self = CC_HOSTNAME_ENTRY (object); + GPermission *permission; + g_autoptr(GError) error = NULL; + g_autofree gchar *str = NULL; + + permission = polkit_permission_new_sync ("org.freedesktop.hostname1.set-static-hostname", + NULL, NULL, NULL); + + /* Is hostnamed installed? */ + if (permission == NULL) + { + g_debug ("Will not show hostname, hostnamed not installed"); + + gtk_widget_set_sensitive (GTK_WIDGET (self), FALSE); + + return; + } + + if (g_permission_get_allowed (permission)) + gtk_widget_set_sensitive (GTK_WIDGET (self), TRUE); + else + { + g_debug ("Not allowed to change the hostname"); + gtk_widget_set_sensitive (GTK_WIDGET (self), FALSE); + } + + gtk_widget_set_sensitive (GTK_WIDGET (self), + g_permission_get_allowed (permission)); + + self->hostnamed_proxy = g_dbus_proxy_new_for_bus_sync (G_BUS_TYPE_SYSTEM, + G_DBUS_PROXY_FLAGS_NONE, + NULL, + "org.freedesktop.hostname1", + "/org/freedesktop/hostname1", + "org.freedesktop.hostname1", + NULL, + &error); + + /* This could only happen if the policy file was installed + * but not hostnamed, which points to a system bug */ + if (self->hostnamed_proxy == NULL) + { + g_debug ("Couldn't get hostnamed to start, bailing: %s", error->message); + return; + } + + str = cc_hostname_entry_get_display_hostname (CC_HOSTNAME_ENTRY (self)); + + if (str != NULL) + gtk_entry_set_text (GTK_ENTRY (self), str); + else + gtk_entry_set_text (GTK_ENTRY (self), ""); + + g_signal_connect (self, "changed", G_CALLBACK (text_changed_cb), NULL); +} + +static void +cc_hostname_entry_class_init (CcHostnameEntryClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->constructed = cc_hostname_entry_constructed; + object_class->dispose = cc_hostname_entry_dispose; +} + +static void +cc_hostname_entry_init (CcHostnameEntry *self) +{ +} + +CcHostnameEntry * +cc_hostname_entry_new (void) +{ + return g_object_new (CC_TYPE_HOSTNAME_ENTRY, NULL); +} + +gchar* +cc_hostname_entry_get_hostname (CcHostnameEntry *entry) +{ + return get_hostname_property (entry, "Hostname"); +} diff --git a/panels/common/cc-hostname-entry.h b/panels/common/cc-hostname-entry.h new file mode 100644 index 0000000..a481779 --- /dev/null +++ b/panels/common/cc-hostname-entry.h @@ -0,0 +1,33 @@ +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- + * + * Copyright (C) 2013 Intel, Inc + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <http://www.gnu.org/licenses/>. + * + */ + +#pragma once + +#include <gtk/gtk.h> + +G_BEGIN_DECLS + +#define CC_TYPE_HOSTNAME_ENTRY (cc_hostname_entry_get_type()) + +G_DECLARE_FINAL_TYPE (CcHostnameEntry, cc_hostname_entry, CC, HOSTNAME_ENTRY, GtkEntry) + +CcHostnameEntry *cc_hostname_entry_new (void); +gchar* cc_hostname_entry_get_hostname (CcHostnameEntry *entry); + +G_END_DECLS diff --git a/panels/common/cc-language-chooser.c b/panels/common/cc-language-chooser.c new file mode 100644 index 0000000..919cb1c --- /dev/null +++ b/panels/common/cc-language-chooser.c @@ -0,0 +1,479 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2013 Red Hat, Inc + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <http://www.gnu.org/licenses/>. + * + * Written by: Matthias Clasen <mclasen@redhat.com> + */ + +#define _GNU_SOURCE +#include <config.h> +#include "cc-language-chooser.h" +#include "cc-common-resources.h" + +#include <locale.h> +#include <string.h> +#include <glib/gi18n.h> +#include <gio/gio.h> +#include <gtk/gtk.h> + +#include "list-box-helper.h" +#include "cc-common-language.h" +#include "cc-util.h" + +#define GNOME_DESKTOP_USE_UNSTABLE_API +#include <libgnome-desktop/gnome-languages.h> + +struct _CcLanguageChooser { + GtkDialog parent_instance; + + GtkWidget *select_button; + GtkWidget *no_results; + GtkListBoxRow *more_item; + GtkWidget *search_bar; + GtkWidget *language_filter_entry; + GtkWidget *language_listbox; + gboolean showing_extra; + gchar *language; + gchar **filter_words; +}; + +G_DEFINE_TYPE (CcLanguageChooser, cc_language_chooser, GTK_TYPE_DIALOG) + +static GtkWidget * +language_widget_new (const gchar *locale_id, + gboolean is_extra) +{ + g_autofree gchar *language_code = NULL; + g_autofree gchar *country_code = NULL; + g_autofree gchar *language = NULL; + g_autofree gchar *country = NULL; + g_autofree gchar *language_local = NULL; + g_autofree gchar *country_local = NULL; + GtkWidget *row; + GtkWidget *box; + GtkWidget *language_label; + GtkWidget *check; + GtkWidget *country_label; + + gnome_parse_locale (locale_id, &language_code, &country_code, NULL, NULL); + language = gnome_get_language_from_code (language_code, locale_id); + country = gnome_get_country_from_code (country_code, locale_id); + language_local = gnome_get_language_from_code (language_code, NULL); + country_local = gnome_get_country_from_code (country_code, NULL); + + row = gtk_list_box_row_new (); + + box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); + gtk_widget_show (box); + gtk_widget_set_margin_top (box, 12); + gtk_widget_set_margin_bottom (box, 12); + gtk_widget_set_margin_start (box, 18); + gtk_widget_set_margin_end (box, 18); + gtk_container_add (GTK_CONTAINER (row), box); + + language_label = gtk_label_new (language); + gtk_widget_show (language_label); + gtk_label_set_xalign (GTK_LABEL (language_label), 0.0); + gtk_label_set_ellipsize (GTK_LABEL (language_label), PANGO_ELLIPSIZE_END); + gtk_box_pack_start (GTK_BOX (box), language_label, FALSE, TRUE, 0); + + check = gtk_image_new (); + gtk_widget_hide (check); + gtk_image_set_from_icon_name (GTK_IMAGE (check), "object-select-symbolic", GTK_ICON_SIZE_MENU); + g_object_set (check, "icon-size", GTK_ICON_SIZE_MENU, NULL); + gtk_box_pack_start (GTK_BOX (box), check, FALSE, FALSE, 0); + + country_label = gtk_label_new (country); + gtk_widget_show (country_label); + gtk_label_set_xalign (GTK_LABEL (country_label), 1.0); + gtk_label_set_ellipsize (GTK_LABEL (country_label), PANGO_ELLIPSIZE_END); + gtk_style_context_add_class (gtk_widget_get_style_context (country_label), "dim-label"); + gtk_box_pack_start (GTK_BOX (box), country_label, TRUE, TRUE, 0); + + g_object_set_data (G_OBJECT (row), "check", check); + g_object_set_data_full (G_OBJECT (row), "locale-id", g_strdup (locale_id), g_free); + g_object_set_data_full (G_OBJECT (row), "language", g_steal_pointer (&language), g_free); + g_object_set_data_full (G_OBJECT (row), "country", g_steal_pointer (&country), g_free); + g_object_set_data_full (G_OBJECT (row), "language-local", g_steal_pointer (&language_local), g_free); + g_object_set_data_full (G_OBJECT (row), "country-local", g_steal_pointer (&country_local), g_free); + g_object_set_data (G_OBJECT (row), "is-extra", GUINT_TO_POINTER (is_extra)); + + return row; +} + +static GtkListBoxRow * +more_widget_new (void) +{ + GtkWidget *box, *row; + GtkWidget *arrow; + + row = gtk_list_box_row_new (); + box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10); + gtk_widget_show (box); + gtk_container_add (GTK_CONTAINER (row), box); + gtk_widget_set_tooltip_text (box, _("More…")); + + arrow = gtk_image_new_from_icon_name ("view-more-symbolic", GTK_ICON_SIZE_MENU); + gtk_widget_show (arrow); + gtk_style_context_add_class (gtk_widget_get_style_context (arrow), "dim-label"); + gtk_widget_set_margin_top (box, 10); + gtk_widget_set_margin_bottom (box, 10); + gtk_box_pack_start (GTK_BOX (box), arrow, TRUE, TRUE, 0); + + return GTK_LIST_BOX_ROW (row); +} + +static GtkWidget * +no_results_widget_new (void) +{ + GtkWidget *widget; + + widget = gtk_label_new (_("No languages found")); + gtk_widget_set_sensitive (widget, FALSE); + return widget; +} + +static void +add_languages (CcLanguageChooser *chooser, + gchar **locale_ids, + GHashTable *initial) +{ + while (*locale_ids) { + gchar *locale_id; + gboolean is_initial; + GtkWidget *widget; + + locale_id = *locale_ids; + locale_ids ++; + + if (!cc_common_language_has_font (locale_id)) + continue; + + is_initial = (g_hash_table_lookup (initial, locale_id) != NULL); + widget = language_widget_new (locale_id, !is_initial); + gtk_widget_show (widget); + gtk_container_add (GTK_CONTAINER (chooser->language_listbox), widget); + } + + gtk_container_add (GTK_CONTAINER (chooser->language_listbox), GTK_WIDGET (chooser->more_item)); +} + +static void +add_all_languages (CcLanguageChooser *chooser) +{ + gchar **locale_ids; + GHashTable *initial; + + locale_ids = gnome_get_all_locales (); + initial = cc_common_language_get_initial_languages (); + add_languages (chooser, locale_ids, initial); + g_hash_table_destroy (initial); + g_strfreev (locale_ids); +} + +static gboolean +match_all (gchar **words, + const gchar *str) +{ + gchar **w; + + if (str == NULL) + return FALSE; + + for (w = words; *w; ++w) + if (!strstr (str, *w)) + return FALSE; + + return TRUE; +} + +static gboolean +language_visible (GtkListBoxRow *row, + gpointer user_data) +{ + CcLanguageChooser *chooser = user_data; + g_autofree gchar *language = NULL; + g_autofree gchar *country = NULL; + g_autofree gchar *language_local = NULL; + g_autofree gchar *country_local = NULL; + gboolean is_extra; + gboolean visible; + + if (row == chooser->more_item) + return !chooser->showing_extra; + + is_extra = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (row), "is-extra")); + + if (!chooser->showing_extra && is_extra) + return FALSE; + + if (!chooser->filter_words) + return TRUE; + + language = + cc_util_normalize_casefold_and_unaccent (g_object_get_data (G_OBJECT (row), "language")); + visible = match_all (chooser->filter_words, language); + if (visible) + return TRUE; + + country = + cc_util_normalize_casefold_and_unaccent (g_object_get_data (G_OBJECT (row), "country")); + visible = match_all (chooser->filter_words, country); + if (visible) + return TRUE; + + language_local = + cc_util_normalize_casefold_and_unaccent (g_object_get_data (G_OBJECT (row), "language-local")); + visible = match_all (chooser->filter_words, language_local); + if (visible) + return TRUE; + + country_local = + cc_util_normalize_casefold_and_unaccent (g_object_get_data (G_OBJECT (row), "country-local")); + return match_all (chooser->filter_words, country_local); +} + +static gint +sort_languages (GtkListBoxRow *a, + GtkListBoxRow *b, + gpointer data) +{ + const gchar *la, *lb, *ca, *cb; + int d; + + if (g_object_get_data (G_OBJECT (a), "locale-id") == NULL) + return 1; + if (g_object_get_data (G_OBJECT (b), "locale-id") == NULL) + return -1; + + la = g_object_get_data (G_OBJECT (a), "language"); + lb = g_object_get_data (G_OBJECT (b), "language"); + d = g_strcmp0 (la, lb); + if (d != 0) + return d; + + ca = g_object_get_data (G_OBJECT (a), "country"); + cb = g_object_get_data (G_OBJECT (b), "country"); + return g_strcmp0 (ca, cb); +} + +static void +filter_changed (CcLanguageChooser *chooser) +{ + g_autofree gchar *filter_contents = NULL; + + g_clear_pointer (&chooser->filter_words, g_strfreev); + + filter_contents = + cc_util_normalize_casefold_and_unaccent (gtk_entry_get_text (GTK_ENTRY (chooser->language_filter_entry))); + if (!filter_contents) { + gtk_list_box_invalidate_filter (GTK_LIST_BOX (chooser->language_listbox)); + gtk_list_box_set_placeholder (GTK_LIST_BOX (chooser->language_listbox), NULL); + return; + } + chooser->filter_words = g_strsplit_set (g_strstrip (filter_contents), " ", 0); + gtk_list_box_set_placeholder (GTK_LIST_BOX (chooser->language_listbox), chooser->no_results); + gtk_list_box_invalidate_filter (GTK_LIST_BOX (chooser->language_listbox)); +} + +static void +show_more (CcLanguageChooser *chooser, gboolean visible) +{ + gint width, height; + + gtk_window_get_size (GTK_WINDOW (chooser), &width, &height); + gtk_widget_set_size_request (GTK_WIDGET (chooser), width, height); + + gtk_search_bar_set_search_mode (GTK_SEARCH_BAR (chooser->search_bar), visible); + gtk_widget_grab_focus (visible ? chooser->language_filter_entry : chooser->language_listbox); + + chooser->showing_extra = visible; + + gtk_list_box_invalidate_filter (GTK_LIST_BOX (chooser->language_listbox)); +} + +static void +set_locale_id (CcLanguageChooser *chooser, + const gchar *locale_id) +{ + g_autoptr(GList) children = NULL; + GList *l; + + gtk_widget_set_sensitive (chooser->select_button, FALSE); + + children = gtk_container_get_children (GTK_CONTAINER (chooser->language_listbox)); + for (l = children; l; l = l->next) { + GtkWidget *row = l->data; + GtkWidget *check = g_object_get_data (G_OBJECT (row), "check"); + const gchar *language = g_object_get_data (G_OBJECT (row), "locale-id"); + if (check == NULL || language == NULL) + continue; + + if (g_strcmp0 (locale_id, language) == 0) { + gboolean is_extra; + + gtk_widget_show (check); + gtk_widget_set_sensitive (chooser->select_button, TRUE); + + /* make sure the selected language is shown */ + is_extra = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (row), "is-extra")); + if (!chooser->showing_extra && is_extra) { + g_object_set_data (G_OBJECT (row), "is-extra", GINT_TO_POINTER (FALSE)); + gtk_list_box_invalidate_filter (GTK_LIST_BOX (chooser->language_listbox)); + } + } else { + gtk_widget_hide (check); + } + } + + g_free (chooser->language); + chooser->language = g_strdup (locale_id); +} + +static void +row_activated (CcLanguageChooser *chooser, + GtkListBoxRow *row) +{ + gchar *new_locale_id; + + if (row == NULL) + return; + + if (row == chooser->more_item) { + show_more (chooser, TRUE); + return; + } + new_locale_id = g_object_get_data (G_OBJECT (row), "locale-id"); + if (g_strcmp0 (new_locale_id, chooser->language) == 0) { + gtk_dialog_response (GTK_DIALOG (chooser), + gtk_dialog_get_response_for_widget (GTK_DIALOG (chooser), + chooser->select_button)); + } else { + set_locale_id (chooser, new_locale_id); + } +} + +static void +activate_default (CcLanguageChooser *chooser) +{ + GtkWidget *focus; + gchar *locale_id; + + focus = gtk_window_get_focus (GTK_WINDOW (chooser)); + if (!focus) + return; + + locale_id = g_object_get_data (G_OBJECT (focus), "locale-id"); + if (g_strcmp0 (locale_id, chooser->language) == 0) + return; + + g_signal_stop_emission_by_name (GTK_WINDOW (chooser), "activate-default"); + gtk_widget_activate (focus); +} + +void +cc_language_chooser_init (CcLanguageChooser *chooser) +{ + g_resources_register (cc_common_get_resource ()); + + gtk_widget_init_template (GTK_WIDGET (chooser)); + + chooser->more_item = more_widget_new (); + gtk_widget_show (GTK_WIDGET (chooser->more_item)); + /* We ref-sink here so we can reuse this widget multiple times */ + chooser->no_results = g_object_ref_sink (no_results_widget_new ()); + gtk_widget_show (chooser->no_results); + + gtk_list_box_set_sort_func (GTK_LIST_BOX (chooser->language_listbox), + sort_languages, chooser, NULL); + gtk_list_box_set_filter_func (GTK_LIST_BOX (chooser->language_listbox), + language_visible, chooser, NULL); + gtk_list_box_set_selection_mode (GTK_LIST_BOX (chooser->language_listbox), + GTK_SELECTION_NONE); + gtk_list_box_set_header_func (GTK_LIST_BOX (chooser->language_listbox), + cc_list_box_update_header_func, NULL, NULL); + add_all_languages (chooser); + + g_signal_connect_object (chooser->language_filter_entry, "search-changed", + G_CALLBACK (filter_changed), chooser, G_CONNECT_SWAPPED); + + g_signal_connect_object (chooser->language_listbox, "row-activated", + G_CALLBACK (row_activated), chooser, G_CONNECT_SWAPPED); + + gtk_list_box_invalidate_filter (GTK_LIST_BOX (chooser->language_listbox)); + + g_signal_connect (chooser, "activate-default", + G_CALLBACK (activate_default), NULL); +} + +static void +cc_language_chooser_dispose (GObject *object) +{ + CcLanguageChooser *chooser = CC_LANGUAGE_CHOOSER (object); + + g_clear_object (&chooser->no_results); + g_clear_pointer (&chooser->filter_words, g_strfreev); + g_clear_pointer (&chooser->language, g_free); + + G_OBJECT_CLASS (cc_language_chooser_parent_class)->dispose (object); +} + +void +cc_language_chooser_class_init (CcLanguageChooserClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + + object_class->dispose = cc_language_chooser_dispose; + + gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/control-center/common/cc-language-chooser.ui"); + + gtk_widget_class_bind_template_child (widget_class, CcLanguageChooser, select_button); + gtk_widget_class_bind_template_child (widget_class, CcLanguageChooser, search_bar); + gtk_widget_class_bind_template_child (widget_class, CcLanguageChooser, language_filter_entry); + gtk_widget_class_bind_template_child (widget_class, CcLanguageChooser, language_listbox); +} + +CcLanguageChooser * +cc_language_chooser_new (void) +{ + return CC_LANGUAGE_CHOOSER (g_object_new (CC_TYPE_LANGUAGE_CHOOSER, + "use-header-bar", 1, + NULL)); +} + +void +cc_language_chooser_clear_filter (CcLanguageChooser *chooser) +{ + g_return_if_fail (CC_IS_LANGUAGE_CHOOSER (chooser)); + gtk_entry_set_text (GTK_ENTRY (chooser->language_filter_entry), ""); + show_more (chooser, FALSE); +} + +const gchar * +cc_language_chooser_get_language (CcLanguageChooser *chooser) +{ + g_return_val_if_fail (CC_IS_LANGUAGE_CHOOSER (chooser), NULL); + return chooser->language; +} + +void +cc_language_chooser_set_language (CcLanguageChooser *chooser, + const gchar *language) +{ + g_return_if_fail (CC_IS_LANGUAGE_CHOOSER (chooser)); + set_locale_id (chooser, language); +} diff --git a/panels/common/cc-language-chooser.h b/panels/common/cc-language-chooser.h new file mode 100644 index 0000000..8e050ee --- /dev/null +++ b/panels/common/cc-language-chooser.h @@ -0,0 +1,37 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2013 Red Hat, Inc + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <http://www.gnu.org/licenses/>. + * + * Written by: Matthias Clasen <mclasen@redhat.com> + */ + +#pragma once + +#include <gtk/gtk.h> +#include <glib-object.h> + +G_BEGIN_DECLS + +#define CC_TYPE_LANGUAGE_CHOOSER (cc_language_chooser_get_type ()) +G_DECLARE_FINAL_TYPE (CcLanguageChooser, cc_language_chooser, CC, LANGUAGE_CHOOSER, GtkDialog) + +CcLanguageChooser *cc_language_chooser_new (void); +void cc_language_chooser_clear_filter (CcLanguageChooser *chooser); +const gchar *cc_language_chooser_get_language (CcLanguageChooser *chooser); +void cc_language_chooser_set_language (CcLanguageChooser *chooser, + const gchar *language); + +G_END_DECLS diff --git a/panels/common/cc-language-chooser.ui b/panels/common/cc-language-chooser.ui new file mode 100644 index 0000000..6b61d55 --- /dev/null +++ b/panels/common/cc-language-chooser.ui @@ -0,0 +1,74 @@ +<?xml version="1.0" encoding="UTF-8"?> +<interface> + <!-- interface-requires gtk+ 3.0 --> + <template class="CcLanguageChooser" parent="GtkDialog"> + <property name="title" translatable="yes">Select Language</property> + <property name="modal">True</property> + <property name="destroy_with_parent">True</property> + <property name="default_width">340</property> + <property name="default_height">475</property> + <child type="action"> + <object class="GtkButton" id="select_button"> + <property name="label" translatable="yes">_Select</property> + <property name="visible">True</property> + <property name="sensitive">False</property> + <property name="can_focus">True</property> + <property name="can_default">True</property> + <property name="receives_default">True</property> + <property name="use_underline">True</property> + <property name="valign">center</property> + </object> + </child> + <child type="action"> + <object class="GtkButton" id="cancel_button"> + <property name="label" translatable="yes">_Cancel</property> + <property name="visible">True</property> + <property name="can_focus">True</property> + <property name="use_underline">True</property> + <property name="valign">center</property> + </object> + </child> + <child internal-child="vbox"> + <object class="GtkBox"> + <property name="visible">True</property> + <property name="orientation">vertical</property> + <property name="spacing">0</property> + <property name="border-width">0</property> + <child> + <object class="GtkSearchBar" id="search_bar"> + <property name="visible">True</property> + <property name="hexpand">True</property> + <child> + <object class="GtkSearchEntry" id="language_filter_entry"> + <property name="visible">True</property> + <property name="width_chars">30</property> + </object> + </child> + </object> + </child> + <child> + <object class="GtkScrolledWindow"> + <property name="visible">True</property> + <property name="hscrollbar-policy">never</property> + <property name="vscrollbar-policy">automatic</property> + <property name="propagate-natural-height">True</property> + <property name="min-content-height">200</property> + <child> + <object class="GtkListBox" id="language_listbox"> + <property name="visible">True</property> + <property name="can-focus">True</property> + <property name="vexpand">True</property> + <property name="halign">fill</property> + <property name="valign">fill</property> + </object> + </child> + </object> + </child> + </object> + </child> + <action-widgets> + <action-widget response="-5" default="true">select_button</action-widget> + <action-widget response="-6">cancel_button</action-widget> + </action-widgets> + </template> +</interface> diff --git a/panels/common/cc-list-row.c b/panels/common/cc-list-row.c new file mode 100644 index 0000000..20ee002 --- /dev/null +++ b/panels/common/cc-list-row.c @@ -0,0 +1,362 @@ +/* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* cc-list-row.c + * + * Copyright 2019 Purism SPC + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + * + * Author(s): + * Mohammed Sadiq <sadiq@sadiqpk.org> + * + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +#undef G_LOG_DOMAIN +#define G_LOG_DOMAIN "cc-list-row" + +#ifdef HAVE_CONFIG_H +# include <config.h> +#endif + +#include "cc-list-row.h" + +struct _CcListRow +{ + GtkListBoxRow parent_instance; + + GtkBox *box; + GtkLabel *title; + GtkLabel *subtitle; + GtkLabel *secondary_label; + GtkImage *icon; + + GtkSwitch *enable_switch; + gboolean show_switch; + + gboolean switch_active; +}; + +G_DEFINE_TYPE (CcListRow, cc_list_row, GTK_TYPE_LIST_BOX_ROW) + + +enum { + PROP_0, + PROP_TITLE, + PROP_SUBTITLE, + PROP_SECONDARY_LABEL, + PROP_ICON_NAME, + PROP_SHOW_SWITCH, + PROP_ACTIVE, + PROP_USE_UNDERLINE, + N_PROPS +}; + +static GParamSpec *properties[N_PROPS]; + +static void +cc_list_row_activated_cb (CcListRow *self, + GtkListBoxRow *row) +{ + g_assert (CC_IS_LIST_ROW (self)); + + if (!self->show_switch || row != GTK_LIST_BOX_ROW (self)) + return; + + cc_list_row_activate (self); +} + +static void +cc_list_row_parent_changed_cb (CcListRow *self) +{ + GtkWidget *parent; + + g_assert (CC_IS_LIST_ROW (self)); + + parent = gtk_widget_get_parent (GTK_WIDGET (self)); + + if (!parent) + return; + + g_return_if_fail (GTK_IS_LIST_BOX (parent)); + g_signal_connect_object (parent, "row-activated", + G_CALLBACK (cc_list_row_activated_cb), + self, G_CONNECT_SWAPPED); +} + +static void +cc_list_row_switch_active_cb (CcListRow *self) +{ + gboolean switch_active; + + g_assert (CC_IS_LIST_ROW (self)); + g_assert (self->show_switch); + + switch_active = gtk_switch_get_active (self->enable_switch); + + if (switch_active == self->switch_active) + return; + + self->switch_active = switch_active; + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ACTIVE]); +} + +static void +cc_list_row_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + CcListRow *self = (CcListRow *)object; + + switch (prop_id) + { + case PROP_SECONDARY_LABEL: + g_value_set_string (value, gtk_label_get_label (self->secondary_label)); + break; + + case PROP_ACTIVE: + g_value_set_boolean (value, self->switch_active); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +cc_list_row_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + CcListRow *self = (CcListRow *)object; + gint margin; + + switch (prop_id) + { + case PROP_TITLE: + gtk_label_set_label (self->title, g_value_get_string (value)); + break; + + case PROP_SUBTITLE: + gtk_widget_set_visible (GTK_WIDGET (self->subtitle), + g_value_get_string (value) != NULL); + gtk_label_set_label (self->subtitle, g_value_get_string (value)); + if (g_value_get_string (value) != NULL) + margin = 6; + else + margin = 12; + g_object_set (self->box, + "margin-top", margin, + "margin-bottom", margin, + NULL); + break; + + case PROP_SECONDARY_LABEL: + gtk_label_set_label (self->secondary_label, g_value_get_string (value)); + break; + + case PROP_ICON_NAME: + cc_list_row_set_icon_name (self, g_value_get_string (value)); + break; + + case PROP_SHOW_SWITCH: + cc_list_row_set_show_switch (self, g_value_get_boolean (value)); + break; + + case PROP_USE_UNDERLINE: + gtk_label_set_use_underline (self->title, g_value_get_boolean (value)); + gtk_label_set_use_underline (self->subtitle, g_value_get_boolean (value)); + gtk_label_set_mnemonic_widget (self->title, GTK_WIDGET (self)); + gtk_label_set_mnemonic_widget (self->subtitle, GTK_WIDGET (self)); + break; + + case PROP_ACTIVE: + g_signal_handlers_block_by_func (self->enable_switch, + cc_list_row_switch_active_cb, self); + gtk_switch_set_active (self->enable_switch, + g_value_get_boolean (value)); + self->switch_active = g_value_get_boolean (value); + g_signal_handlers_unblock_by_func (self->enable_switch, + cc_list_row_switch_active_cb, self); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +cc_list_row_class_init (CcListRowClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + + object_class->get_property = cc_list_row_get_property; + object_class->set_property = cc_list_row_set_property; + + properties[PROP_TITLE] = + g_param_spec_string ("title", + "Title", + "List row primary title", + NULL, + G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS); + + properties[PROP_SUBTITLE] = + g_param_spec_string ("subtitle", + "Subtitle", + "List row primary subtitle", + NULL, + G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS); + + properties[PROP_SECONDARY_LABEL] = + g_param_spec_string ("secondary-label", + "Secondary Label", + "Set Secondary Label", + NULL, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + + properties[PROP_ICON_NAME] = + g_param_spec_string ("icon-name", + "Icon Name", + "Secondary Icon name", + NULL, + G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS); + + properties[PROP_SHOW_SWITCH] = + g_param_spec_boolean ("show-switch", + "Show Switch", + "Whether to show a switch at the end of row", + FALSE, + G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS); + + properties[PROP_ACTIVE] = + g_param_spec_boolean ("active", + "Active", + "The active state of the switch", + FALSE, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); + + properties[PROP_USE_UNDERLINE] = + g_param_spec_boolean ("use-underline", + "Use underline", + "If set, text prefixed with underline shall be used as mnemonic", + FALSE, + G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS); + + g_object_class_install_properties (object_class, N_PROPS, properties); + + gtk_widget_class_set_template_from_resource (widget_class, + "/org/gnome/control-center/" + "common/cc-list-row.ui"); + + gtk_widget_class_bind_template_child (widget_class, CcListRow, box); + gtk_widget_class_bind_template_child (widget_class, CcListRow, title); + gtk_widget_class_bind_template_child (widget_class, CcListRow, subtitle); + gtk_widget_class_bind_template_child (widget_class, CcListRow, secondary_label); + gtk_widget_class_bind_template_child (widget_class, CcListRow, icon); + gtk_widget_class_bind_template_child (widget_class, CcListRow, enable_switch); + + gtk_widget_class_bind_template_callback (widget_class, cc_list_row_switch_active_cb); +} + +static void +cc_list_row_init (CcListRow *self) +{ + gtk_widget_init_template (GTK_WIDGET (self)); + g_signal_connect_object (self, "notify::parent", + G_CALLBACK (cc_list_row_parent_changed_cb), + self, G_CONNECT_SWAPPED); +} + +void +cc_list_row_set_icon_name (CcListRow *self, + const gchar *icon_name) +{ + g_return_if_fail (CC_IS_LIST_ROW (self)); + g_return_if_fail (!self->show_switch); + + if (icon_name) + g_object_set (self->icon, "icon-name", icon_name, NULL); + + gtk_widget_set_visible (GTK_WIDGET (self->icon), icon_name != NULL); +} + +void +cc_list_row_set_show_switch (CcListRow *self, + gboolean show_switch) +{ + g_return_if_fail (CC_IS_LIST_ROW (self)); + + self->show_switch = !!show_switch; + + gtk_widget_set_visible (GTK_WIDGET (self->enable_switch), self->show_switch); + gtk_widget_set_visible (GTK_WIDGET (self->icon), !self->show_switch); + gtk_widget_set_visible (GTK_WIDGET (self->secondary_label), !self->show_switch); +} + +gboolean +cc_list_row_get_active (CcListRow *self) +{ + g_return_val_if_fail (CC_IS_LIST_ROW (self), FALSE); + g_return_val_if_fail (self->show_switch, FALSE); + + return self->switch_active; +} + +void +cc_list_row_activate (CcListRow *self) +{ + g_return_if_fail (CC_IS_LIST_ROW (self)); + g_return_if_fail (self->show_switch); + + self->switch_active = !self->switch_active; + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_ACTIVE]); + + gtk_widget_activate (GTK_WIDGET (self->enable_switch)); +} + +void +cc_list_row_set_secondary_label (CcListRow *self, + const gchar *label) +{ + g_return_if_fail (CC_IS_LIST_ROW (self)); + g_return_if_fail (!self->show_switch); + + if (!label) + label = ""; + + if (g_str_equal (label, gtk_label_get_label (self->secondary_label))) + return; + + gtk_label_set_text (self->secondary_label, label); + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SECONDARY_LABEL]); +} + +void +cc_list_row_set_secondary_markup (CcListRow *self, + const gchar *markup) +{ + g_return_if_fail (CC_IS_LIST_ROW (self)); + g_return_if_fail (!self->show_switch); + + if (!markup) + markup = ""; + + if (g_str_equal (markup, gtk_label_get_label (self->secondary_label))) + return; + + gtk_label_set_markup (self->secondary_label, markup); + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SECONDARY_LABEL]); +} diff --git a/panels/common/cc-list-row.h b/panels/common/cc-list-row.h new file mode 100644 index 0000000..43997fa --- /dev/null +++ b/panels/common/cc-list-row.h @@ -0,0 +1,45 @@ +/* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* cc-list-row.h + * + * Copyright 2019 Purism SPC + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + * + * Author(s): + * Mohammed Sadiq <sadiq@sadiqpk.org> + * + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +#pragma once + +#include <gtk/gtk.h> + +G_BEGIN_DECLS + +#define CC_TYPE_LIST_ROW (cc_list_row_get_type()) +G_DECLARE_FINAL_TYPE (CcListRow, cc_list_row, CC, LIST_ROW, GtkListBoxRow) + +void cc_list_row_set_icon_name (CcListRow *self, + const gchar *icon_name); +void cc_list_row_set_show_switch (CcListRow *self, + gboolean show_switch); +gboolean cc_list_row_get_active (CcListRow *self); +void cc_list_row_activate (CcListRow *self); +void cc_list_row_set_secondary_label (CcListRow *self, + const gchar *label); +void cc_list_row_set_secondary_markup (CcListRow *self, + const gchar *markup); + +G_END_DECLS diff --git a/panels/common/cc-list-row.ui b/panels/common/cc-list-row.ui new file mode 100644 index 0000000..730b8d9 --- /dev/null +++ b/panels/common/cc-list-row.ui @@ -0,0 +1,84 @@ +<?xml version="1.0" encoding="UTF-8"?> +<interface> + <template class="CcListRow" parent="GtkListBoxRow"> + <property name="visible">1</property> + <child> + <object class="GtkBox" id="box"> + <property name="visible">1</property> + <property name="margin">12</property> + <property name="spacing">12</property> + + <child> + <object class="GtkBox"> + <property name="visible">1</property> + <property name="valign">center</property> + <property name="orientation">vertical</property> + + <!-- Title --> + <child> + <object class="GtkLabel" id="title"> + <property name="visible">1</property> + <property name="hexpand">1</property> + <property name="xalign">0.0</property> + <property name="ellipsize">end</property> + </object> + </child> + + <!-- Subtitle --> + <child> + <object class="GtkLabel" id="subtitle"> + <property name="visible">0</property> + <property name="hexpand">1</property> + <property name="xalign">0.0</property> + <property name="wrap-mode">word</property> + <property name="max-width-chars">42</property> + <style> + <class name="dim-label"/> + </style> + <attributes> + <attribute name="scale" value="0.83"/> + </attributes> + </object> + </child> + + </object> + </child> + + <!-- Secondary Label --> + <child> + <object class="GtkLabel" id="secondary_label"> + <property name="visible">1</property> + <property name="valign">center</property> + <property name="ellipsize">end</property> + <property name="selectable" bind-source="CcListRow" bind-property="activatable" bind-flags="sync-create|invert-boolean" /> + <style> + <class name="dim-label"/> + </style> + </object> + </child> + + <!-- Icon --> + <child> + <object class="GtkImage" id="icon"> + <property name="visible">0</property> + <property name="valign">center</property> + <style> + <class name="dim-label"/> + </style> + </object> + </child> + + <!-- Switch --> + <child> + <object class="GtkSwitch" id="enable_switch"> + <property name="visible">0</property> + <property name="can-focus">0</property> + <property name="valign">center</property> + <signal name="notify::active" handler="cc_list_row_switch_active_cb" swapped="yes"/> + </object> + </child> + + </object> + </child> + </template> +</interface> diff --git a/panels/common/cc-os-release.c b/panels/common/cc-os-release.c new file mode 100644 index 0000000..4f04da9 --- /dev/null +++ b/panels/common/cc-os-release.c @@ -0,0 +1,84 @@ +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- + * + * Copyright (C) 2019 Canonical Ltd. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <http://www.gnu.org/licenses/>. + * + */ + +#include "cc-os-release.h" + +gchar * +cc_os_release_get_value (const gchar *key) +{ + g_autoptr(GHashTable) values = NULL; + + values = cc_os_release_get_values (); + if (values == NULL) + return NULL; + + return g_strdup (g_hash_table_lookup (values, key)); +} + +GHashTable * +cc_os_release_get_values (void) +{ + g_autoptr(GHashTable) values = NULL; + g_autofree gchar *buffer = NULL; + g_auto(GStrv) lines = NULL; + int i; + g_autoptr(GError) error = NULL; + + values = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free); + + if (!g_file_get_contents ("/etc/os-release", &buffer, NULL, &error)) + { + if (!g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT)) + return NULL; + + if (!g_file_get_contents ("/usr/lib/os-release", &buffer, NULL, NULL)) + return NULL; + } + + /* Default values in spec */ + g_hash_table_insert (values, g_strdup ("NAME"), g_strdup ("Linux")); + g_hash_table_insert (values, g_strdup ("ID"), g_strdup ("Linux")); + g_hash_table_insert (values, g_strdup ("PRETTY_NAME"), g_strdup ("Linux")); + + lines = g_strsplit (buffer, "\n", -1); + for (i = 0; lines[i] != NULL; i++) + { + gchar *line = lines[i]; + g_auto(GStrv) tokens = NULL; + const gchar *key, *value; + g_autofree gchar *unquoted_value = NULL; + + /* Skip comments */ + if (g_str_has_prefix (line, "#")) + continue; + + tokens = g_strsplit (line, "=", 2); + if (g_strv_length (tokens) < 2) + continue; + key = tokens[0]; + value = tokens[1]; + unquoted_value = g_shell_unquote (value, NULL); + if (unquoted_value != NULL) + value = unquoted_value; + + g_hash_table_insert (values, g_strdup (key), g_strdup (value)); + } + + return g_steal_pointer (&values); +} diff --git a/panels/common/cc-os-release.h b/panels/common/cc-os-release.h new file mode 100644 index 0000000..3213d85 --- /dev/null +++ b/panels/common/cc-os-release.h @@ -0,0 +1,30 @@ +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- + * + * Copyright (C) 2019 Canonical Ltd. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <http://www.gnu.org/licenses/>. + * + */ + +#pragma once + +#include <glib.h> + +G_BEGIN_DECLS + +gchar *cc_os_release_get_value (const gchar *key); + +GHashTable *cc_os_release_get_values (void); + +G_END_DECLS diff --git a/panels/common/cc-permission-infobar.c b/panels/common/cc-permission-infobar.c new file mode 100644 index 0000000..31329ad --- /dev/null +++ b/panels/common/cc-permission-infobar.c @@ -0,0 +1,84 @@ +/* cc-permission-infobar.c + * + * Copyright (C) 2020 Red Hat, Inc + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + * + * Author(s): + * Felipe Borges <felipeborges@gnome.org> + * + */ + +#undef G_LOG_DOMAIN +#define G_LOG_DOMAIN "cc-permission-infobar" + +#ifdef HAVE_CONFIG_H +# include <config.h> +#endif + +#include "cc-permission-infobar.h" + +struct _CcPermissionInfobar +{ + GtkRevealer parent_instance; + + GtkLockButton *lock_button; +}; + +G_DEFINE_TYPE (CcPermissionInfobar, cc_permission_infobar, GTK_TYPE_REVEALER) + +static void +on_permission_changed (CcPermissionInfobar *self) +{ + GPermission *permission; + gboolean is_authorized; + + permission = gtk_lock_button_get_permission (self->lock_button); + is_authorized = g_permission_get_allowed (permission); + + gtk_revealer_set_reveal_child (GTK_REVEALER (self), !is_authorized); +} + +static void +cc_permission_infobar_class_init (CcPermissionInfobarClass *klass) +{ + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + + gtk_widget_class_set_template_from_resource (widget_class, + "/org/gnome/control-center/" + "common/cc-permission-infobar.ui"); + + gtk_widget_class_bind_template_child (widget_class, CcPermissionInfobar, lock_button); +} + +static void +cc_permission_infobar_init (CcPermissionInfobar *self) +{ + gtk_widget_init_template (GTK_WIDGET (self)); +} + +void +cc_permission_infobar_set_permission (CcPermissionInfobar *self, + GPermission *permission) +{ + g_return_if_fail (CC_IS_PERMISSION_INFOBAR (self)); + + gtk_lock_button_set_permission (self->lock_button, permission); + + g_signal_connect_object (permission, "notify", + G_CALLBACK (on_permission_changed), + self, + G_CONNECT_SWAPPED); + on_permission_changed (self); +} diff --git a/panels/common/cc-permission-infobar.h b/panels/common/cc-permission-infobar.h new file mode 100644 index 0000000..4595a8b --- /dev/null +++ b/panels/common/cc-permission-infobar.h @@ -0,0 +1,34 @@ +/* cc-permission-infobar.h + * + * Copyright (C) 2020 Red Hat, Inc + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + * + * Author(s): + * Felipe Borges <felipeborges@gnome.org> + * + */ +#pragma once + +#include <gtk/gtk.h> + +G_BEGIN_DECLS + +#define CC_TYPE_PERMISSION_INFOBAR (cc_permission_infobar_get_type()) +G_DECLARE_FINAL_TYPE (CcPermissionInfobar, cc_permission_infobar, CC, PERMISSION_INFOBAR, GtkRevealer) + +void cc_permission_infobar_set_permission (CcPermissionInfobar *self, + GPermission *permission); + +G_END_DECLS diff --git a/panels/common/cc-permission-infobar.ui b/panels/common/cc-permission-infobar.ui new file mode 100644 index 0000000..12eea75 --- /dev/null +++ b/panels/common/cc-permission-infobar.ui @@ -0,0 +1,65 @@ +<?xml version="1.0" encoding="UTF-8"?> +<interface> + <template class="CcPermissionInfobar" parent="GtkRevealer"> + <property name="reveal-child">True</property> + <property name="valign">start</property> + <child> + <object class="GtkInfoBar"> + <property name="visible">True</property> + <property name="can-focus">False</property> + <child internal-child="action_area"> + <object class="GtkButtonBox"> + <property name="can-focus">False</property> + <property name="layout-style">end</property> + <property name="border-width">10</property> + <child> + <object class="GtkLockButton" id="lock_button"> + <property name="visible">True</property> + <property name="can-focus">True</property> + <property name="receives-default">True</property> + <property name="label" translatable="yes">Unlock…</property> + </object> + </child> + </object> + </child> + <child internal-child="content_area"> + <object class="GtkBox"> + <property name="visible">True</property> + <property name="border-width">10</property> + <property name="spacing">10</property> + <child> + <object class="GtkImage"> + <property name="visible">True</property> + <property name="icon-name">system-lock-screen-symbolic</property> + </object> + </child> + <child> + <object class="GtkBox"> + <property name="visible">True</property> + <property name="hexpand">True</property> + <property name="orientation">vertical</property> + <child> + <object class="GtkLabel"> + <property name="visible">True</property> + <property name="halign">start</property> + <property name="label" translatable="yes">Unlock to Change Settings</property> + <attributes> + <attribute name="weight" value="bold"/> + </attributes> + </object> + </child> + <child> + <object class="GtkLabel"> + <property name="visible">True</property> + <property name="halign">start</property> + <property name="label" translatable="yes">Some settings must be unlocked before they can be changed.</property> + </object> + </child> + </object> + </child> + </object> + </child> + </object> + </child> + </template> +</interface> diff --git a/panels/common/cc-time-editor.c b/panels/common/cc-time-editor.c new file mode 100644 index 0000000..684a9cd --- /dev/null +++ b/panels/common/cc-time-editor.c @@ -0,0 +1,368 @@ +/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*- */ +/* cc-time-editor.c + * + * Copyright 2020 Purism SPC + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + * + * Author(s): + * Mohammed Sadiq <sadiq@sadiqpk.org> + * + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +#undef G_LOG_DOMAIN +#define G_LOG_DOMAIN "cc-time-editor" + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#define GNOME_DESKTOP_USE_UNSTABLE_API +#include <libgnome-desktop/gnome-wall-clock.h> +#include <gtk/gtk.h> +#include <glib/gi18n.h> + +#include "cc-time-entry.h" +#include "cc-time-editor.h" + + +#define TIMEOUT_INITIAL 500 +#define TIMEOUT_REPEAT 50 + +#define FILECHOOSER_SCHEMA "org.gtk.Settings.FileChooser" +#define CLOCK_SCHEMA "org.gnome.desktop.interface" +#define CLOCK_FORMAT_KEY "clock-format" +#define SECONDS_PER_MINUTE (60) +#define SECONDS_PER_HOUR (60 * 60) +#define SECONDS_PER_DAY (60 * 60 * 24) + + +struct _CcTimeEditor +{ + GtkBin parent_instance; + + GtkButton *am_pm_button; + GtkStack *am_pm_stack; + GtkLabel *am_label; + GtkLabel *pm_label; + GtkButton *hour_up_button; + GtkButton *hour_down_button; + GtkButton *minute_up_button; + GtkButton *minute_down_button; + CcTimeEntry *time_entry; + + GtkButton *clicked_button; /* The button currently being clicked */ + GSettings *clock_settings; + GSettings *filechooser_settings; + + guint timer_id; +}; + +G_DEFINE_TYPE (CcTimeEditor, cc_time_editor, GTK_TYPE_BIN) + + +enum { + TIME_CHANGED, + N_SIGNALS +}; + +static guint signals[N_SIGNALS]; + +static void +time_editor_clock_changed_cb (CcTimeEditor *self) +{ + GDesktopClockFormat value; + gboolean is_am_pm; + + g_assert (CC_IS_TIME_EDITOR (self)); + + value = g_settings_get_enum (self->clock_settings, CLOCK_FORMAT_KEY); + + is_am_pm = value == G_DESKTOP_CLOCK_FORMAT_12H; + cc_time_entry_set_am_pm (self->time_entry, is_am_pm); + gtk_widget_set_visible (GTK_WIDGET (self->am_pm_button), is_am_pm); + + if (is_am_pm) + { + if (cc_time_entry_get_is_am (self->time_entry)) + gtk_stack_set_visible_child (self->am_pm_stack, GTK_WIDGET (self->am_label)); + else + gtk_stack_set_visible_child (self->am_pm_stack, GTK_WIDGET (self->pm_label)); + } +} + +static void +time_editor_time_changed_cb (CcTimeEditor *self) +{ + g_assert (CC_IS_TIME_EDITOR (self)); + + g_signal_emit (self, signals[TIME_CHANGED], 0); +} + +static void +editor_change_time_clicked_cb (CcTimeEditor *self, + GtkButton *button) +{ + g_assert (CC_IS_TIME_EDITOR (self)); + + if (button == NULL) + return; + + if (button == self->hour_up_button) + { + gtk_editable_set_position (GTK_EDITABLE (self->time_entry), 0); + g_signal_emit_by_name (self->time_entry, "change-value", GTK_SCROLL_STEP_UP); + } + else if (button == self->hour_down_button) + { + gtk_editable_set_position (GTK_EDITABLE (self->time_entry), 0); + g_signal_emit_by_name (self->time_entry, "change-value", GTK_SCROLL_STEP_DOWN); + } + else if (button == self->minute_up_button) + { + gtk_editable_set_position (GTK_EDITABLE (self->time_entry), 3); + g_signal_emit_by_name (self->time_entry, "change-value", GTK_SCROLL_STEP_UP); + } + else if (button == self->minute_down_button) + { + gtk_editable_set_position (GTK_EDITABLE (self->time_entry), 3); + g_signal_emit_by_name (self->time_entry, "change-value", GTK_SCROLL_STEP_DOWN); + } +} + +static gboolean +editor_change_time_repeat (CcTimeEditor *self) +{ + if (self->clicked_button == NULL) + { + self->timer_id = 0; + + return G_SOURCE_REMOVE; + } + + editor_change_time_clicked_cb (self, self->clicked_button); + + return G_SOURCE_CONTINUE; +} + +static gboolean +editor_change_time_cb (CcTimeEditor *self) +{ + g_assert (CC_IS_TIME_EDITOR (self)); + g_clear_handle_id (&self->timer_id, g_source_remove); + + editor_change_time_clicked_cb (self, self->clicked_button); + self->timer_id = g_timeout_add (TIMEOUT_REPEAT, + (GSourceFunc)editor_change_time_repeat, + self); + return G_SOURCE_REMOVE; +} + +static gboolean +editor_change_time_pressed_cb (CcTimeEditor *self, + GdkEvent *event, + GtkButton *button) +{ + g_assert (CC_IS_TIME_EDITOR (self)); + + self->clicked_button = button; + /* Keep changing time until the press is released */ + self->timer_id = g_timeout_add (TIMEOUT_INITIAL, + (GSourceFunc)editor_change_time_cb, + self); + editor_change_time_clicked_cb (self, button); + return FALSE; +} + +static gboolean +editor_change_time_released_cb (CcTimeEditor *self) +{ + self->clicked_button = NULL; + g_clear_handle_id (&self->timer_id, g_source_remove); + + return FALSE; +} + +static void +editor_am_pm_button_clicked_cb (CcTimeEditor *self) +{ + gboolean is_am; + + g_assert (CC_IS_TIME_EDITOR (self)); + g_assert (cc_time_entry_get_am_pm (self->time_entry)); + + is_am = cc_time_entry_get_is_am (self->time_entry); + /* Toggle AM PM */ + cc_time_entry_set_is_am (self->time_entry, !is_am); + time_editor_clock_changed_cb (self); +} + +static void +editor_am_pm_stack_changed_cb (CcTimeEditor *self) +{ + AtkObject *accessible; + GtkWidget *label; + const gchar *text; + + g_assert (CC_IS_TIME_EDITOR (self)); + + accessible = gtk_widget_get_accessible (GTK_WIDGET (self->am_pm_button)); + if (accessible == NULL) + return; + + label = gtk_stack_get_visible_child (self->am_pm_stack); + text = gtk_label_get_text (GTK_LABEL (label)); + atk_object_set_name (accessible, text); +} + +static void +cc_time_editor_constructed (GObject *object) +{ + CcTimeEditor *self = (CcTimeEditor *)object; + GDateTime *date; + char *label; + + G_OBJECT_CLASS (cc_time_editor_parent_class)->constructed (object); + + /* Set localized identifier for AM */ + date = g_date_time_new_utc (1, 1, 1, 0, 0, 0); + label = g_date_time_format (date, "%p"); + gtk_label_set_label (self->am_label, label); + g_date_time_unref (date); + g_free (label); + + /* Set localized identifier for PM */ + date = g_date_time_new_utc (1, 1, 1, 12, 0, 0); + label = g_date_time_format (date, "%p"); + gtk_label_set_label (self->pm_label, label); + g_date_time_unref (date); + g_free (label); +} + +static void +cc_time_editor_finalize (GObject *object) +{ + CcTimeEditor *self = (CcTimeEditor *)object; + + g_clear_handle_id (&self->timer_id, g_source_remove); + g_clear_object (&self->clock_settings); + g_clear_object (&self->filechooser_settings); + + G_OBJECT_CLASS (cc_time_editor_parent_class)->finalize (object); +} + +static void +cc_time_editor_class_init (CcTimeEditorClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + + object_class->constructed = cc_time_editor_constructed; + object_class->finalize = cc_time_editor_finalize; + + signals[TIME_CHANGED] = + g_signal_new ("time-changed", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_FIRST, + 0, NULL, NULL, + NULL, + G_TYPE_NONE, 0); + + gtk_widget_class_set_template_from_resource (widget_class, + "/org/gnome/control-center/" + "common/cc-time-editor.ui"); + + gtk_widget_class_bind_template_child (widget_class, CcTimeEditor, am_pm_button); + gtk_widget_class_bind_template_child (widget_class, CcTimeEditor, am_pm_stack); + gtk_widget_class_bind_template_child (widget_class, CcTimeEditor, am_label); + gtk_widget_class_bind_template_child (widget_class, CcTimeEditor, pm_label); + gtk_widget_class_bind_template_child (widget_class, CcTimeEditor, hour_up_button); + gtk_widget_class_bind_template_child (widget_class, CcTimeEditor, hour_down_button); + gtk_widget_class_bind_template_child (widget_class, CcTimeEditor, minute_up_button); + gtk_widget_class_bind_template_child (widget_class, CcTimeEditor, minute_down_button); + gtk_widget_class_bind_template_child (widget_class, CcTimeEditor, time_entry); + + gtk_widget_class_bind_template_callback (widget_class, editor_change_time_pressed_cb); + gtk_widget_class_bind_template_callback (widget_class, editor_change_time_released_cb); + gtk_widget_class_bind_template_callback (widget_class, editor_am_pm_button_clicked_cb); + gtk_widget_class_bind_template_callback (widget_class, editor_am_pm_stack_changed_cb); + + g_type_ensure (CC_TYPE_TIME_ENTRY); +} + +static void +cc_time_editor_init (CcTimeEditor *self) +{ + gtk_widget_init_template (GTK_WIDGET (self)); + + self->clock_settings = g_settings_new (CLOCK_SCHEMA); + self->filechooser_settings = g_settings_new (FILECHOOSER_SCHEMA); + + g_signal_connect_object (self->clock_settings, "changed::" CLOCK_FORMAT_KEY, + G_CALLBACK (time_editor_clock_changed_cb), self, + G_CONNECT_SWAPPED); + g_signal_connect_swapped (self->time_entry, "time-changed", + G_CALLBACK (time_editor_time_changed_cb), self); + time_editor_clock_changed_cb (self); +} + +CcTimeEditor * +cc_time_editor_new (void) +{ + return g_object_new (CC_TYPE_TIME_EDITOR, NULL); +} + +void +cc_time_editor_set_time (CcTimeEditor *self, + guint hour, + guint minute) +{ + g_return_if_fail (CC_IS_TIME_EDITOR (self)); + + cc_time_entry_set_time (self->time_entry, hour, minute); +} + +guint +cc_time_editor_get_hour (CcTimeEditor *self) +{ + g_return_val_if_fail (CC_IS_TIME_EDITOR (self), 0); + + return cc_time_entry_get_hour (self->time_entry); +} + +guint +cc_time_editor_get_minute (CcTimeEditor *self) +{ + g_return_val_if_fail (CC_IS_TIME_EDITOR (self), 0); + + return cc_time_entry_get_minute (self->time_entry); +} + +gboolean +cc_time_editor_get_am_pm (CcTimeEditor *self) +{ + g_return_val_if_fail (CC_IS_TIME_EDITOR (self), TRUE); + + return TRUE; +} + +void +cc_time_editor_set_am_pm (CcTimeEditor *self, + gboolean is_am_pm) +{ + g_return_if_fail (CC_IS_TIME_EDITOR (self)); + + cc_time_entry_set_am_pm (self->time_entry, is_am_pm); +} diff --git a/panels/common/cc-time-editor.h b/panels/common/cc-time-editor.h new file mode 100644 index 0000000..48c4534 --- /dev/null +++ b/panels/common/cc-time-editor.h @@ -0,0 +1,45 @@ +/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*- */ +/* cc-time-editor.h + * + * Copyright 2020 Purism SPC + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + * + * Author(s): + * Mohammed Sadiq <sadiq@sadiqpk.org> + * + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +#pragma once + +#include <gtk/gtk.h> + +G_BEGIN_DECLS + +#define CC_TYPE_TIME_EDITOR (cc_time_editor_get_type ()) + +G_DECLARE_FINAL_TYPE (CcTimeEditor, cc_time_editor, CC, TIME_EDITOR, GtkBin) + +CcTimeEditor *cc_time_editor_new (void); +void cc_time_editor_set_time (CcTimeEditor *self, + guint hour, + guint minute); +guint cc_time_editor_get_hour (CcTimeEditor *self); +guint cc_time_editor_get_minute (CcTimeEditor *self); +gboolean cc_time_editor_get_am_pm (CcTimeEditor *self); +void cc_time_editor_set_am_pm (CcTimeEditor *self, + gboolean is_am_pm); + +G_END_DECLS diff --git a/panels/common/cc-time-editor.ui b/panels/common/cc-time-editor.ui new file mode 100644 index 0000000..1732fcd --- /dev/null +++ b/panels/common/cc-time-editor.ui @@ -0,0 +1,193 @@ +<?xml version="1.0" encoding="UTF-8"?> +<interface> + <template class="CcTimeEditor" parent="GtkBin"> + <property name="visible">True</property> + <child> + <object class="GtkGrid"> + <property name="visible">True</property> + <property name="row-spacing">6</property> + <property name="column-spacing">6</property> + + <!-- Increment Hour Button --> + <child> + <object class="GtkButton" id="hour_up_button"> + <property name="visible">True</property> + <property name="can-focus">False</property> + <property name="valign">center</property> + <property name="halign">center</property> + <signal name="button-press-event" handler="editor_change_time_pressed_cb" swapped="yes"/> + <signal name="button-release-event" handler="editor_change_time_released_cb" swapped="yes"/> + <style> + <class name="titlebutton"/> + <class name="circular"/> + <class name="flat"/> + </style> + <child> + <object class="GtkImage"> + <property name="visible">True</property> + <property name="icon-name">go-up-symbolic</property> + </object> + </child> + <child internal-child="accessible"> + <object class="AtkObject"> + <property name="AtkObject::accessible-name" translatable="yes">Increment Hour</property> + </object> + </child> + </object> + <packing> + <property name="left-attach">0</property> + <property name="top-attach">0</property> + </packing> + </child> + + <!-- Increment Minute Button --> + <child> + <object class="GtkButton" id="minute_up_button"> + <property name="visible">True</property> + <property name="can-focus">False</property> + <property name="valign">center</property> + <property name="halign">center</property> + <signal name="button-press-event" handler="editor_change_time_pressed_cb" swapped="yes"/> + <signal name="button-release-event" handler="editor_change_time_released_cb" swapped="yes"/> + <style> + <class name="titlebutton"/> + <class name="circular"/> + <class name="flat"/> + </style> + <child> + <object class="GtkImage"> + <property name="visible">True</property> + <property name="icon-name">go-up-symbolic</property> + </object> + </child> + <child internal-child="accessible"> + <object class="AtkObject"> + <property name="AtkObject::accessible-name" translatable="yes">Increment Minute</property> + </object> + </child> + </object> + <packing> + <property name="left-attach">1</property> + <property name="top-attach">0</property> + </packing> + </child> + + <child> + <object class="CcTimeEntry" id="time_entry"> + <property name="visible">True</property> + <child internal-child="accessible"> + <object class="AtkObject"> + <property name="AtkObject::accessible-description" translatable="yes">Time</property> + </object> + </child> + </object> + <packing> + <property name="left-attach">0</property> + <property name="top-attach">1</property> + <property name="width">2</property> + </packing> + </child> + + <!-- Decrement Hour Button --> + <child> + <object class="GtkButton" id="hour_down_button"> + <property name="visible">True</property> + <property name="can-focus">False</property> + <property name="valign">center</property> + <property name="halign">center</property> + <signal name="button-press-event" handler="editor_change_time_pressed_cb" swapped="yes"/> + <signal name="button-release-event" handler="editor_change_time_released_cb" swapped="yes"/> + <style> + <class name="titlebutton"/> + <class name="circular"/> + <class name="flat"/> + </style> + <child> + <object class="GtkImage"> + <property name="visible">True</property> + <property name="icon-name">go-down-symbolic</property> + </object> + </child> + <child internal-child="accessible"> + <object class="AtkObject"> + <property name="AtkObject::accessible-name" translatable="yes">Decrement Hour</property> + </object> + </child> + </object> + <packing> + <property name="left-attach">0</property> + <property name="top-attach">2</property> + </packing> + </child> + + <!-- Decrement Minute Button --> + <child> + <object class="GtkButton" id="minute_down_button"> + <property name="visible">True</property> + <property name="can-focus">False</property> + <property name="valign">center</property> + <property name="halign">center</property> + <signal name="button-press-event" handler="editor_change_time_pressed_cb" swapped="yes"/> + <signal name="button-release-event" handler="editor_change_time_released_cb" swapped="yes"/> + <style> + <class name="titlebutton"/> + <class name="circular"/> + <class name="flat"/> + </style> + <child> + <object class="GtkImage"> + <property name="visible">True</property> + <property name="icon-name">go-down-symbolic</property> + </object> + </child> + <child internal-child="accessible"> + <object class="AtkObject"> + <property name="AtkObject::accessible-name" translatable="yes">Decrement Minute</property> + </object> + </child> + </object> + <packing> + <property name="left-attach">1</property> + <property name="top-attach">2</property> + </packing> + </child> + + <!-- AM/PM Button --> + <child> + <object class="GtkButton" id="am_pm_button"> + <property name="visible">True</property> + <property name="valign">center</property> + <signal name="clicked" handler="editor_am_pm_button_clicked_cb" swapped="yes"/> + <child> + <object class="GtkStack" id="am_pm_stack"> + <property name="visible">True</property> + <signal name="notify::visible-child" handler="editor_am_pm_stack_changed_cb" swapped="yes"/> + <child> + <object class="GtkLabel" id="am_label"> + <property name="visible">True</property> + <attributes> + <attribute name="scale" value="1.4"/> + </attributes> + </object> + </child> + <child> + <object class="GtkLabel" id="pm_label"> + <property name="visible">True</property> + <attributes> + <attribute name="scale" value="1.4"/> + </attributes> + </object> + </child> + </object> + </child> + </object> + <packing> + <property name="left-attach">2</property> + <property name="top-attach">1</property> + </packing> + </child> + + </object> + </child> + </template> +</interface> diff --git a/panels/common/cc-time-entry.c b/panels/common/cc-time-entry.c new file mode 100644 index 0000000..d989935 --- /dev/null +++ b/panels/common/cc-time-entry.c @@ -0,0 +1,600 @@ +/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*- */ +/* cc-time-entry.c + * + * Copyright 2020 Purism SPC + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + * + * Author(s): + * Mohammed Sadiq <sadiq@sadiqpk.org> + * + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +#undef G_LOG_DOMAIN +#define G_LOG_DOMAIN "cc-time-entry" + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <gtk/gtk.h> +#include <glib/gi18n.h> + +#include "cc-time-entry.h" + +#define SEPARATOR_INDEX 2 +#define END_INDEX 4 +#define EMIT_CHANGED_TIMEOUT 100 + + +struct _CcTimeEntry +{ + GtkEntry parent_instance; + + guint insert_text_id; + guint time_changed_id; + int hour; /* Range: 0-23 in 24H and 1-12 in 12H with is_am set/unset */ + int minute; + gboolean is_am_pm; + gboolean is_am; /* AM if TRUE. PM if FALSE. valid iff is_am_pm set */ +}; + +G_DEFINE_TYPE (CcTimeEntry, cc_time_entry, GTK_TYPE_ENTRY) + +enum { + CHANGE_VALUE, + TIME_CHANGED, + N_SIGNALS +}; + +static guint signals[N_SIGNALS]; + +static gboolean +emit_time_changed (CcTimeEntry *self) +{ + self->time_changed_id = 0; + + g_signal_emit (self, signals[TIME_CHANGED], 0); + + return G_SOURCE_REMOVE; +} + +static void +time_entry_fill_time (CcTimeEntry *self) +{ + g_autofree gchar *str = NULL; + + g_assert (CC_IS_TIME_ENTRY (self)); + + str = g_strdup_printf ("%02d∶%02d", self->hour, self->minute); + + g_signal_handler_block (self, self->insert_text_id); + gtk_entry_set_text (GTK_ENTRY (self), str); + g_signal_handler_unblock (self, self->insert_text_id); +} + +static void +cursor_position_changed_cb (CcTimeEntry *self) +{ + int current_pos; + + g_assert (CC_IS_TIME_ENTRY (self)); + + current_pos = gtk_editable_get_position (GTK_EDITABLE (self)); + + g_signal_handlers_block_by_func (self, cursor_position_changed_cb, self); + + /* If cursor is on ‘:’ move to the next field */ + if (current_pos == SEPARATOR_INDEX) + gtk_editable_set_position (GTK_EDITABLE (self), current_pos + 1); + + /* If cursor is after the last digit and without selection, move to last digit */ + if (current_pos > END_INDEX && + !gtk_editable_get_selection_bounds (GTK_EDITABLE (self), NULL, NULL)) + gtk_editable_set_position (GTK_EDITABLE (self), END_INDEX); + + g_signal_handlers_unblock_by_func (self, cursor_position_changed_cb, self); +} + +static void +entry_selection_changed_cb (CcTimeEntry *self) +{ + GtkEditable *editable; + + g_assert (CC_IS_TIME_ENTRY (self)); + + editable = GTK_EDITABLE (self); + + g_signal_handlers_block_by_func (self, cursor_position_changed_cb, self); + + /* If cursor is after the last digit and without selection, move to last digit */ + if (gtk_editable_get_position (editable) > END_INDEX && + !gtk_editable_get_selection_bounds (editable, NULL, NULL)) + gtk_editable_set_position (editable, END_INDEX); + + g_signal_handlers_unblock_by_func (self, cursor_position_changed_cb, self); +} + +static void +editable_insert_text_cb (CcTimeEntry *self, + char *new_text, + gint new_text_length, + gint *position) +{ + g_assert (CC_IS_TIME_ENTRY (self)); + + if (new_text_length == -1) + new_text_length = strlen (new_text); + + if (new_text_length == 5) + { + guint16 text_length; + + text_length = gtk_entry_get_text_length (GTK_ENTRY (self)); + + /* Return if the text matches XX:XX template (where X is a number) */ + if (text_length == 0 && + strstr (new_text, "0123456789:") == new_text + new_text_length && + strchr (new_text, ':') == strrchr (new_text, ':')) + return; + } + + /* Insert text if single digit number */ + if (new_text_length == 1 && + strspn (new_text, "0123456789")) + { + int pos, number; + + pos = *position; + number = *new_text - '0'; + + if (pos == 0) + self->hour = self->hour % 10 + number * 10; + else if (pos == 1) + self->hour = self->hour / 10 * 10 + number; + else if (pos == 3) + self->minute = self->minute % 10 + number * 10; + else if (pos == 4) + self->minute = self->minute / 10 * 10 + number; + + if (self->is_am_pm) + self->hour = CLAMP (self->hour, 1, 12); + else + self->hour = CLAMP (self->hour, 0, 23); + + self->minute = CLAMP (self->minute, 0, 59); + + g_signal_stop_emission_by_name (self, "insert-text"); + time_entry_fill_time (self); + *position = pos + 1; + + g_clear_handle_id (&self->time_changed_id, g_source_remove); + self->time_changed_id = g_timeout_add (EMIT_CHANGED_TIMEOUT, + (GSourceFunc)emit_time_changed, self); + return; + } + + /* Warn otherwise */ + g_signal_stop_emission_by_name (self, "insert-text"); + gtk_widget_error_bell (GTK_WIDGET (self)); +} + + +static void +entry_select_all (CcTimeEntry *self) +{ + gtk_editable_select_region (GTK_EDITABLE (self), 0, -1); +} + +static void +entry_populate_popup_cb (CcTimeEntry *self, + GtkWidget *widget) +{ + GList *children; + + if (!GTK_IS_CONTAINER (widget)) + return; + + children = gtk_container_get_children (GTK_CONTAINER (widget)); + + if (GTK_IS_MENU (widget)) + { + GtkWidget *menu_item; + + for (GList *child = children; child; child = child->next) + gtk_container_remove (GTK_CONTAINER (widget), child->data); + + menu_item = gtk_menu_item_new_with_mnemonic (_("_Copy")); + gtk_widget_set_sensitive (menu_item, gtk_editable_get_selection_bounds (GTK_EDITABLE (self), NULL, NULL)); + g_signal_connect_swapped (menu_item, "activate", G_CALLBACK (gtk_editable_copy_clipboard), self); + gtk_widget_show (menu_item); + gtk_menu_shell_append (GTK_MENU_SHELL (widget), menu_item); + + menu_item = gtk_menu_item_new_with_mnemonic (_("Select _All")); + gtk_widget_set_sensitive (menu_item, gtk_entry_get_text_length (GTK_ENTRY (self)) > 0); + g_signal_connect_swapped (menu_item, "activate", G_CALLBACK (entry_select_all), self); + gtk_widget_show (menu_item); + gtk_menu_shell_append (GTK_MENU_SHELL (widget), menu_item); + } +} + +static void +time_entry_change_value_cb (CcTimeEntry *self, + GtkScrollType type) +{ + int position; + g_assert (CC_IS_TIME_ENTRY (self)); + + position = gtk_editable_get_position (GTK_EDITABLE (self)); + + if (position > SEPARATOR_INDEX) + { + if (type == GTK_SCROLL_STEP_UP) + self->minute++; + else + self->minute--; + + if (self->minute >= 60) + self->minute = 0; + else if (self->minute <= -1) + self->minute = 59; + } + else + { + if (type == GTK_SCROLL_STEP_UP) + self->hour++; + else + self->hour--; + + if (self->is_am_pm) + { + if (self->hour > 12) + self->hour = 1; + else if (self->hour < 1) + self->hour = 12; + } + else + { + if (self->hour >= 24) + self->hour = 0; + else if (self->hour <= -1) + self->hour = 23; + } + } + + time_entry_fill_time (self); + gtk_editable_set_position (GTK_EDITABLE (self), position); + + g_clear_handle_id (&self->time_changed_id, g_source_remove); + self->time_changed_id = g_timeout_add (EMIT_CHANGED_TIMEOUT, + (GSourceFunc)emit_time_changed, self); +} + +static void +cc_entry_move_cursor (GtkEntry *entry, + GtkMovementStep step, + gint count, + gboolean extend_selection) +{ + int current_pos; + + current_pos = gtk_editable_get_position (GTK_EDITABLE (entry)); + + /* If cursor is on ‘:’ move backward/forward depending on the current movement */ + if ((step == GTK_MOVEMENT_LOGICAL_POSITIONS || + step == GTK_MOVEMENT_VISUAL_POSITIONS) && + current_pos + count == SEPARATOR_INDEX) + count > 0 ? count++ : count--; + + GTK_ENTRY_CLASS (cc_time_entry_parent_class)->move_cursor (entry, step, count, extend_selection); +} + +static void +cc_time_entry_error_bell (GtkEntry *entry) +{ + gtk_widget_error_bell (GTK_WIDGET (entry)); +} + +static void +cc_time_entry_delete_from_cursor (GtkEntry *entry, + GtkDeleteType type, + gint count) +{ + gtk_widget_error_bell (GTK_WIDGET (entry)); +} + +static gboolean +cc_time_entry_drag_motion (GtkWidget *widget, + GdkDragContext *context, + gint x, + gint y, + guint time) +{ + return TRUE; +} + +static gboolean +cc_time_entry_key_press (GtkWidget *widget, + GdkEventKey *event) +{ + CcTimeEntry *self = (CcTimeEntry *)widget; + + /* Allow entering numbers */ + if (!(event->state & GDK_SHIFT_MASK) && + ((event->keyval >= GDK_KEY_KP_0 && + event->keyval <= GDK_KEY_KP_9) || + (event->keyval >= GDK_KEY_0 && + event->keyval <= GDK_KEY_9))) + return GTK_WIDGET_CLASS (cc_time_entry_parent_class)->key_press_event (widget, event); + + /* Allow navigation keys */ + if ((event->keyval >= GDK_KEY_Left && + event->keyval <= GDK_KEY_Down) || + (event->keyval >= GDK_KEY_KP_Left && + event->keyval <= GDK_KEY_KP_Down) || + event->keyval == GDK_KEY_Home || + event->keyval == GDK_KEY_End || + event->keyval == GDK_KEY_Menu) + return GTK_WIDGET_CLASS (cc_time_entry_parent_class)->key_press_event (widget, event); + + if (event->state & (GDK_CONTROL_MASK | GDK_MOD1_MASK)) + return GTK_WIDGET_CLASS (cc_time_entry_parent_class)->key_press_event (widget, event); + + if (event->keyval == GDK_KEY_Tab) + { + /* If focus is on Hour field skip to minute field */ + if (gtk_editable_get_position (GTK_EDITABLE (self)) <= 1) + { + gtk_editable_set_position (GTK_EDITABLE (self), SEPARATOR_INDEX + 1); + + return GDK_EVENT_STOP; + } + + return GTK_WIDGET_CLASS (cc_time_entry_parent_class)->key_press_event (widget, event); + } + + /* Shift-Tab */ + if (event->keyval == GDK_KEY_ISO_Left_Tab) + { + /* If focus is on Minute field skip back to Hour field */ + if (gtk_editable_get_position (GTK_EDITABLE (self)) >= 2) + { + gtk_editable_set_position (GTK_EDITABLE (self), 0); + + return GDK_EVENT_STOP; + } + + return GTK_WIDGET_CLASS (cc_time_entry_parent_class)->key_press_event (widget, event); + } + + return GDK_EVENT_STOP; +} + +static void +cc_time_entry_constructed (GObject *object) +{ + PangoAttrList *list; + PangoAttribute *attribute; + + G_OBJECT_CLASS (cc_time_entry_parent_class)->constructed (object); + + g_object_set (object, + "input-purpose", GTK_INPUT_PURPOSE_DIGITS, + "input-hints", GTK_INPUT_HINT_NO_EMOJI, + "overwrite-mode", TRUE, + "xalign", 0.5, + "max-length", 5, + NULL); + + time_entry_fill_time (CC_TIME_ENTRY (object)); + + list = pango_attr_list_new (); + + attribute = pango_attr_size_new (PANGO_SCALE * 32); + pango_attr_list_insert (list, attribute); + + attribute = pango_attr_weight_new (PANGO_WEIGHT_LIGHT); + pango_attr_list_insert (list, attribute); + + /* Use tabular(monospace) letters */ + attribute = pango_attr_font_features_new ("tnum"); + pango_attr_list_insert (list, attribute); + + gtk_entry_set_attributes (GTK_ENTRY (object), list); +} + +static void +cc_time_entry_class_init (CcTimeEntryClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + GtkEntryClass *entry_class = GTK_ENTRY_CLASS (klass); + GtkBindingSet *binding_set; + + object_class->constructed = cc_time_entry_constructed; + + widget_class->drag_motion = cc_time_entry_drag_motion; + widget_class->key_press_event = cc_time_entry_key_press; + + entry_class->delete_from_cursor = cc_time_entry_delete_from_cursor; + entry_class->move_cursor = cc_entry_move_cursor; + entry_class->toggle_overwrite = cc_time_entry_error_bell; + entry_class->backspace = cc_time_entry_error_bell; + entry_class->cut_clipboard = cc_time_entry_error_bell; + entry_class->paste_clipboard = cc_time_entry_error_bell; + + signals[CHANGE_VALUE] = + g_signal_new ("change-value", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_ACTION, + 0, NULL, NULL, + NULL, + G_TYPE_NONE, 1, + GTK_TYPE_SCROLL_TYPE); + + signals[TIME_CHANGED] = + g_signal_new ("time-changed", + G_TYPE_FROM_CLASS (klass), + G_SIGNAL_RUN_FIRST, + 0, NULL, NULL, + NULL, + G_TYPE_NONE, 0); + + binding_set = gtk_binding_set_by_class (klass); + + gtk_binding_entry_add_signal (binding_set, GDK_KEY_Up, 0, + "change-value", 1, + GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_UP); + gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Up, 0, + "change-value", 1, + GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_UP); + + gtk_binding_entry_add_signal (binding_set, GDK_KEY_Down, 0, + "change-value", 1, + GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_DOWN); + gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Down, 0, + "change-value", 1, + GTK_TYPE_SCROLL_TYPE, GTK_SCROLL_STEP_DOWN); +} + +static void +cc_time_entry_init (CcTimeEntry *self) +{ + g_signal_connect_after (self, "notify::cursor-position", + G_CALLBACK (cursor_position_changed_cb), NULL); + g_signal_connect_after (self, "notify::selection-bound", + G_CALLBACK (entry_selection_changed_cb), NULL); + self->insert_text_id = g_signal_connect (self, "insert-text", + G_CALLBACK (editable_insert_text_cb), NULL); + g_signal_connect_after (self, "populate-popup", + G_CALLBACK (entry_populate_popup_cb), NULL); + g_signal_connect (self, "change-value", + G_CALLBACK (time_entry_change_value_cb), NULL); +} + +GtkWidget * +cc_time_entry_new (void) +{ + return g_object_new (CC_TYPE_TIME_ENTRY, NULL); +} + +void +cc_time_entry_set_time (CcTimeEntry *self, + guint hour, + guint minute) +{ + gboolean is_am_pm; + + g_return_if_fail (CC_IS_TIME_ENTRY (self)); + + if (cc_time_entry_get_hour (self) == hour && + cc_time_entry_get_minute (self) == minute) + return; + + is_am_pm = cc_time_entry_get_am_pm (self); + cc_time_entry_set_am_pm (self, FALSE); + + self->hour = CLAMP (hour, 0, 23); + self->minute = CLAMP (minute, 0, 59); + + cc_time_entry_set_am_pm (self, is_am_pm); + time_entry_fill_time (self); +} + +guint +cc_time_entry_get_hour (CcTimeEntry *self) +{ + g_return_val_if_fail (CC_IS_TIME_ENTRY (self), 0); + + if (!self->is_am_pm) + return self->hour; + + if (self->is_am && self->hour == 12) + return 0; + else if (self->is_am || self->hour == 12) + return self->hour; + else + return self->hour + 12; +} + +guint +cc_time_entry_get_minute (CcTimeEntry *self) +{ + g_return_val_if_fail (CC_IS_TIME_ENTRY (self), 0); + + return self->minute; +} + +gboolean +cc_time_entry_get_is_am (CcTimeEntry *self) +{ + g_return_val_if_fail (CC_IS_TIME_ENTRY (self), FALSE); + + if (self->is_am_pm) + return self->is_am; + + return self->hour < 12; +} + +void +cc_time_entry_set_is_am (CcTimeEntry *self, + gboolean is_am) +{ + g_return_if_fail (CC_IS_TIME_ENTRY (self)); + + self->is_am = !!is_am; + g_signal_emit (self, signals[TIME_CHANGED], 0); +} + +gboolean +cc_time_entry_get_am_pm (CcTimeEntry *self) +{ + g_return_val_if_fail (CC_IS_TIME_ENTRY (self), FALSE); + + return self->is_am_pm; +} + +void +cc_time_entry_set_am_pm (CcTimeEntry *self, + gboolean is_am_pm) +{ + g_return_if_fail (CC_IS_TIME_ENTRY (self)); + + if (self->is_am_pm == !!is_am_pm) + return; + + if (self->hour < 12) + self->is_am = TRUE; + else + self->is_am = FALSE; + + if (is_am_pm) + { + if (self->hour == 0) + self->hour = 12; + else if (self->hour > 12) + self->hour = self->hour - 12; + } + else + { + if (self->hour == 12 && self->is_am) + self->hour = 0; + else if (!self->is_am) + self->hour = self->hour + 12; + } + + self->is_am_pm = !!is_am_pm; + time_entry_fill_time (self); +} diff --git a/panels/common/cc-time-entry.h b/panels/common/cc-time-entry.h new file mode 100644 index 0000000..f3ddb88 --- /dev/null +++ b/panels/common/cc-time-entry.h @@ -0,0 +1,48 @@ +/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*- */ +/* cc-time-entry.h + * + * Copyright 2020 Purism SPC + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see <http://www.gnu.org/licenses/>. + * + * Author(s): + * Mohammed Sadiq <sadiq@sadiqpk.org> + * + * SPDX-License-Identifier: GPL-3.0-or-later + */ + +#pragma once + +#include <gtk/gtk.h> + +G_BEGIN_DECLS + +#define CC_TYPE_TIME_ENTRY (cc_time_entry_get_type ()) + +G_DECLARE_FINAL_TYPE (CcTimeEntry, cc_time_entry, CC, TIME_ENTRY, GtkEntry) + +GtkWidget *cc_time_entry_new (void); +void cc_time_entry_set_time (CcTimeEntry *self, + guint hour, + guint minute); +guint cc_time_entry_get_minute (CcTimeEntry *self); +guint cc_time_entry_get_hour (CcTimeEntry *self); +gboolean cc_time_entry_get_is_am (CcTimeEntry *self); +void cc_time_entry_set_is_am (CcTimeEntry *self, + gboolean is_am); +gboolean cc_time_entry_get_am_pm (CcTimeEntry *self); +void cc_time_entry_set_am_pm (CcTimeEntry *self, + gboolean is_am_pm); + +G_END_DECLS diff --git a/panels/common/cc-util.c b/panels/common/cc-util.c new file mode 100644 index 0000000..9418d56 --- /dev/null +++ b/panels/common/cc-util.c @@ -0,0 +1,210 @@ +/* + * Copyright (c) 2012 Giovanni Campagna <scampa.giovanni@gmail.com> + * + * The Control Center is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * The Control Center is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + * + * You should have received a copy of the GNU General Public License along + * with the Control Center; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + +#include "config.h" + +#include <string.h> +#include <glib/gi18n.h> + + +#include "cc-util.h" + +/* Combining diacritical mark? + * Basic range: [0x0300,0x036F] + * Supplement: [0x1DC0,0x1DFF] + * For Symbols: [0x20D0,0x20FF] + * Half marks: [0xFE20,0xFE2F] + */ +#define IS_CDM_UCS4(c) (((c) >= 0x0300 && (c) <= 0x036F) || \ + ((c) >= 0x1DC0 && (c) <= 0x1DFF) || \ + ((c) >= 0x20D0 && (c) <= 0x20FF) || \ + ((c) >= 0xFE20 && (c) <= 0xFE2F)) + +#define IS_SOFT_HYPHEN(c) ((c) == 0x00AD) + +/* Copied from tracker/src/libtracker-fts/tracker-parser-glib.c under the GPL + * And then from gnome-shell/src/shell-util.c + * + * Originally written by Aleksander Morgado <aleksander@gnu.org> + */ +char * +cc_util_normalize_casefold_and_unaccent (const char *str) +{ + g_autofree gchar *normalized = NULL; + gchar *tmp; + int i = 0, j = 0, ilen; + + if (str == NULL) + return NULL; + + normalized = g_utf8_normalize (str, -1, G_NORMALIZE_NFKD); + tmp = g_utf8_casefold (normalized, -1); + + ilen = strlen (tmp); + + while (i < ilen) + { + gunichar unichar; + gchar *next_utf8; + gint utf8_len; + + /* Get next character of the word as UCS4 */ + unichar = g_utf8_get_char_validated (&tmp[i], -1); + + /* Invalid UTF-8 character or end of original string. */ + if (unichar == (gunichar) -1 || + unichar == (gunichar) -2) + { + break; + } + + /* Find next UTF-8 character */ + next_utf8 = g_utf8_next_char (&tmp[i]); + utf8_len = next_utf8 - &tmp[i]; + + if (IS_CDM_UCS4 (unichar) || IS_SOFT_HYPHEN (unichar)) + { + /* If the given unichar is a combining diacritical mark, + * just update the original index, not the output one */ + i += utf8_len; + continue; + } + + /* If already found a previous combining + * diacritical mark, indexes are different so + * need to copy characters. As output and input + * buffers may overlap, need to use memmove + * instead of memcpy */ + if (i != j) + { + memmove (&tmp[j], &tmp[i], utf8_len); + } + + /* Update both indexes */ + i += utf8_len; + j += utf8_len; + } + + /* Force proper string end */ + tmp[j] = '\0'; + + return tmp; +} + +char * +cc_util_get_smart_date (GDateTime *date) +{ + g_autoptr(GDateTime) today = NULL; + g_autoptr(GDateTime) local = NULL; + GTimeSpan span; + + /* Set today date */ + local = g_date_time_new_now_local (); + today = g_date_time_new_local (g_date_time_get_year (local), + g_date_time_get_month (local), + g_date_time_get_day_of_month (local), + 0, 0, 0); + + span = g_date_time_difference (today, date); + if (span <= 0) + { + return g_strdup (_("Today")); + } + else if (span <= G_TIME_SPAN_DAY) + { + return g_strdup (_("Yesterday")); + } + else + { + if (g_date_time_get_year (date) == g_date_time_get_year (today)) + { + /* Translators: This is a date format string in the style of "Feb 24". */ + return g_date_time_format (date, _("%b %e")); + } + else + { + /* Translators: This is a date format string in the style of "Feb 24, 2013". */ + return g_date_time_format (date, _("%b %e, %Y")); + } + } +} + +/* Copied from src/plugins/properties/bacon-video-widget-properties.c + * in totem */ +char * +cc_util_time_to_string_text (gint64 msecs) +{ + g_autofree gchar *hours = NULL; + g_autofree gchar *mins = NULL; + g_autofree gchar *secs = NULL; + gint sec, min, hour, _time; + + _time = (int) (msecs / 1000); + sec = _time % 60; + _time = _time - sec; + min = (_time % (60*60)) / 60; + _time = _time - (min * 60); + hour = _time / (60*60); + + hours = g_strdup_printf (g_dngettext (GETTEXT_PACKAGE, "%d hour", "%d hours", hour), hour); + mins = g_strdup_printf (g_dngettext (GETTEXT_PACKAGE, "%d minute", "%d minutes", min), min); + secs = g_strdup_printf (g_dngettext (GETTEXT_PACKAGE, "%d second", "%d seconds", sec), sec); + + if (hour > 0) + { + if (min > 0 && sec > 0) + { + /* 5 hours 2 minutes 12 seconds */ + return g_strdup_printf (C_("hours minutes seconds", "%s %s %s"), hours, mins, secs); + } + else if (min > 0) + { + /* 5 hours 2 minutes */ + return g_strdup_printf (C_("hours minutes", "%s %s"), hours, mins); + } + else + { + /* 5 hours */ + return g_strdup_printf (C_("hours", "%s"), hours); + } + } + else if (min > 0) + { + if (sec > 0) + { + /* 2 minutes 12 seconds */ + return g_strdup_printf (C_("minutes seconds", "%s %s"), mins, secs); + } + else + { + /* 2 minutes */ + return g_strdup_printf (C_("minutes", "%s"), mins); + } + } + else if (sec > 0) + { + /* 10 seconds */ + return g_strdup (secs); + } + else + { + /* 0 seconds */ + return g_strdup (_("0 seconds")); + } +} diff --git a/panels/common/cc-util.h b/panels/common/cc-util.h new file mode 100644 index 0000000..131c2af --- /dev/null +++ b/panels/common/cc-util.h @@ -0,0 +1,27 @@ +/* + * Copyright (c) 2012 Giovanni Campagna <scampa.giovanni@gmail.com> + * + * The Control Center is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by the + * Free Software Foundation; either version 2 of the License, or (at your + * option) any later version. + * + * The Control Center is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. + * + * You should have received a copy of the GNU General Public License along + * with the Control Center; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + * + */ + + +#pragma once + +#include <glib.h> + +char * cc_util_normalize_casefold_and_unaccent (const char *str); +char * cc_util_get_smart_date (GDateTime *date); +char * cc_util_time_to_string_text (gint64 msecs); diff --git a/panels/common/common.gresource.xml b/panels/common/common.gresource.xml new file mode 100644 index 0000000..9620dc1 --- /dev/null +++ b/panels/common/common.gresource.xml @@ -0,0 +1,9 @@ +<?xml version="1.0" encoding="UTF-8"?> +<gresources> + <gresource prefix="/org/gnome/control-center/common"> + <file preprocess="xml-stripblanks">cc-language-chooser.ui</file> + <file preprocess="xml-stripblanks">cc-list-row.ui</file> + <file preprocess="xml-stripblanks">cc-time-editor.ui</file> + <file preprocess="xml-stripblanks">cc-permission-infobar.ui</file> + </gresource> +</gresources> diff --git a/panels/common/gnome-control-center.rules.in b/panels/common/gnome-control-center.rules.in new file mode 100644 index 0000000..971ffac --- /dev/null +++ b/panels/common/gnome-control-center.rules.in @@ -0,0 +1,12 @@ +polkit.addRule(function(action, subject) { + if ((action.id == "org.freedesktop.locale1.set-locale" || + action.id == "org.freedesktop.locale1.set-keyboard" || + action.id == "org.freedesktop.hostname1.set-static-hostname" || + action.id == "org.freedesktop.hostname1.set-hostname" || + action.id == "org.gnome.controlcenter.datetime.configure") && + subject.local && + subject.active && + subject.isInGroup ("@PRIVILEGED_GROUP@")) { + return polkit.Result.YES; + } +}); diff --git a/panels/common/gnome-settings-bus.h b/panels/common/gnome-settings-bus.h new file mode 100644 index 0000000..763a9cc --- /dev/null +++ b/panels/common/gnome-settings-bus.h @@ -0,0 +1,14 @@ +/* Stub to replace gnome-settings-daemon's + * gnome-settings-bus.h helpers */ + +#include <gdk/gdkx.h> + +#ifdef GDK_WINDOWING_WAYLAND + +static inline gboolean +gnome_settings_is_wayland (void) +{ + return !GDK_IS_X11_DISPLAY (gdk_display_get_default ()); +} + +#endif /* GDK_WINDOWING_WAYLAND */ diff --git a/panels/common/gsd-device-manager.c b/panels/common/gsd-device-manager.c new file mode 100644 index 0000000..9509b3f --- /dev/null +++ b/panels/common/gsd-device-manager.c @@ -0,0 +1,692 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2014 Red Hat + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * Author: Carlos Garnacho <carlosg@gnome.org> + */ + +#include "config.h" + +#include <string.h> +#include <gudev/gudev.h> + +#include "gsd-device-manager.h" +#include "gsd-common-enums.h" +#include "gnome-settings-bus.h" +#include "gsd-input-helper.h" + +#ifdef GDK_WINDOWING_X11 +#include <gdk/gdkx.h> +#endif +#ifdef GDK_WINDOWING_WAYLAND +#include <gdk/gdkwayland.h> +#endif + +typedef struct +{ + gchar *name; + gchar *device_file; + gchar *vendor_id; + gchar *product_id; + gchar *group; + GsdDeviceType type; + guint width; + guint height; +} GsdDevicePrivate; + +G_DEFINE_TYPE_WITH_PRIVATE (GsdDevice, gsd_device, G_TYPE_OBJECT) + +typedef struct +{ + GObject parent_instance; + GHashTable *devices; + GUdevClient *udev_client; +} GsdDeviceManagerPrivate; + +enum { + PROP_NAME = 1, + PROP_DEVICE_FILE, + PROP_VENDOR_ID, + PROP_PRODUCT_ID, + PROP_TYPE, + PROP_WIDTH, + PROP_HEIGHT, + PROP_GROUP +}; + +enum { + DEVICE_ADDED, + DEVICE_REMOVED, + DEVICE_CHANGED, + N_SIGNALS +}; + +/* Index matches GsdDeviceType */ +const gchar *udev_ids[] = { + "ID_INPUT_MOUSE", + "ID_INPUT_KEYBOARD", + "ID_INPUT_TOUCHPAD", + "ID_INPUT_TABLET", + "ID_INPUT_TOUCHSCREEN", + "ID_INPUT_TABLET_PAD", +}; + +static guint signals[N_SIGNALS] = { 0 }; + +G_DEFINE_TYPE_WITH_PRIVATE (GsdDeviceManager, gsd_device_manager, G_TYPE_OBJECT) + +static void +gsd_device_init (GsdDevice *device) +{ +} + +static void +gsd_device_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + GsdDevicePrivate *priv; + + priv = gsd_device_get_instance_private (GSD_DEVICE (object)); + + switch (prop_id) { + case PROP_NAME: + priv->name = g_value_dup_string (value); + break; + case PROP_DEVICE_FILE: + priv->device_file = g_value_dup_string (value); + break; + case PROP_VENDOR_ID: + priv->vendor_id = g_value_dup_string (value); + break; + case PROP_PRODUCT_ID: + priv->product_id = g_value_dup_string (value); + break; + case PROP_TYPE: + priv->type = g_value_get_flags (value); + break; + case PROP_WIDTH: + priv->width = g_value_get_uint (value); + break; + case PROP_HEIGHT: + priv->height = g_value_get_uint (value); + break; + case PROP_GROUP: + priv->group = g_value_dup_string (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gsd_device_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + GsdDevicePrivate *priv; + + priv = gsd_device_get_instance_private (GSD_DEVICE (object)); + + switch (prop_id) { + case PROP_NAME: + g_value_set_string (value, priv->name); + break; + case PROP_DEVICE_FILE: + g_value_set_string (value, priv->device_file); + break; + case PROP_VENDOR_ID: + g_value_set_string (value, priv->vendor_id); + break; + case PROP_PRODUCT_ID: + g_value_set_string (value, priv->product_id); + break; + case PROP_TYPE: + g_value_set_flags (value, priv->type); + break; + case PROP_WIDTH: + g_value_set_uint (value, priv->width); + break; + case PROP_HEIGHT: + g_value_set_uint (value, priv->height); + break; + case PROP_GROUP: + g_value_set_string (value, priv->group); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +gsd_device_finalize (GObject *object) +{ + GsdDevicePrivate *priv; + + priv = gsd_device_get_instance_private (GSD_DEVICE (object)); + + g_free (priv->name); + g_free (priv->vendor_id); + g_free (priv->product_id); + g_free (priv->device_file); + g_free (priv->group); + + G_OBJECT_CLASS (gsd_device_parent_class)->finalize (object); +} + +static void +gsd_device_class_init (GsdDeviceClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->set_property = gsd_device_set_property; + object_class->get_property = gsd_device_get_property; + object_class->finalize = gsd_device_finalize; + + g_object_class_install_property (object_class, + PROP_NAME, + g_param_spec_string ("name", + "Name", + "Name", + NULL, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property (object_class, + PROP_DEVICE_FILE, + g_param_spec_string ("device-file", + "Device file", + "Device file", + NULL, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property (object_class, + PROP_VENDOR_ID, + g_param_spec_string ("vendor-id", + "Vendor ID", + "Vendor ID", + NULL, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property (object_class, + PROP_PRODUCT_ID, + g_param_spec_string ("product-id", + "Product ID", + "Product ID", + NULL, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property (object_class, + PROP_TYPE, + g_param_spec_flags ("type", + "Device type", + "Device type", + GSD_TYPE_DEVICE_TYPE, 0, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property (object_class, + PROP_WIDTH, + g_param_spec_uint ("width", + "Width", + "Width", + 0, G_MAXUINT, 0, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property (object_class, + PROP_HEIGHT, + g_param_spec_uint ("height", + "Height", + "Height", + 0, G_MAXUINT, 0, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); + g_object_class_install_property (object_class, + PROP_GROUP, + g_param_spec_string ("group", + "Group", + "Group", + NULL, + G_PARAM_READWRITE | + G_PARAM_CONSTRUCT_ONLY)); +} + +static void +gsd_device_manager_finalize (GObject *object) +{ + GsdDeviceManager *manager = GSD_DEVICE_MANAGER (object); + GsdDeviceManagerPrivate *priv = gsd_device_manager_get_instance_private (manager); + + g_hash_table_destroy (priv->devices); + g_object_unref (priv->udev_client); + + G_OBJECT_CLASS (gsd_device_manager_parent_class)->finalize (object); +} + +static GList * +gsd_device_manager_real_list_devices (GsdDeviceManager *manager, + GsdDeviceType type) +{ + GsdDeviceManagerPrivate *priv = gsd_device_manager_get_instance_private (manager); + GsdDeviceType device_type; + GList *devices = NULL; + GHashTableIter iter; + GsdDevice *device; + + g_hash_table_iter_init (&iter, priv->devices); + + while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &device)) { + device_type = gsd_device_get_device_type (device); + + if ((device_type & type) == type) + devices = g_list_prepend (devices, device); + } + + return devices; +} + +static GsdDevice * +gsd_device_manager_real_lookup_device (GsdDeviceManager *manager, + GdkDevice *gdk_device) +{ + GsdDeviceManagerPrivate *priv = gsd_device_manager_get_instance_private (manager); + GdkDisplay *display = gdk_device_get_display (gdk_device); + const gchar *node_path = NULL; + GHashTableIter iter; + GsdDevice *device; + +#ifdef GDK_WINDOWING_X11 + if (GDK_IS_X11_DISPLAY (display)) + node_path = xdevice_get_device_node (gdk_x11_device_get_id (gdk_device)); +#endif +#ifdef GDK_WINDOWING_WAYLAND + if (GDK_IS_WAYLAND_DISPLAY (display)) + node_path = g_strdup (gdk_wayland_device_get_node_path (gdk_device)); +#endif + if (!node_path) + return NULL; + + g_hash_table_iter_init (&iter, priv->devices); + + while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &device)) { + if (g_strcmp0 (node_path, + gsd_device_get_device_file (device)) == 0) { + return device; + } + } + + return NULL; +} + +static void +gsd_device_manager_class_init (GsdDeviceManagerClass *klass) +{ + GsdDeviceManagerClass *manager_class = GSD_DEVICE_MANAGER_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = gsd_device_manager_finalize; + manager_class->list_devices = gsd_device_manager_real_list_devices; + manager_class->lookup_device = gsd_device_manager_real_lookup_device; + + signals[DEVICE_ADDED] = + g_signal_new ("device-added", + GSD_TYPE_DEVICE_MANAGER, + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GsdDeviceManagerClass, device_added), + NULL, NULL, NULL, + G_TYPE_NONE, 1, + GSD_TYPE_DEVICE | G_SIGNAL_TYPE_STATIC_SCOPE); + + signals[DEVICE_REMOVED] = + g_signal_new ("device-removed", + GSD_TYPE_DEVICE_MANAGER, + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GsdDeviceManagerClass, device_removed), + NULL, NULL, NULL, + G_TYPE_NONE, 1, + GSD_TYPE_DEVICE | G_SIGNAL_TYPE_STATIC_SCOPE); + + signals[DEVICE_CHANGED] = + g_signal_new ("device-changed", + GSD_TYPE_DEVICE_MANAGER, + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GsdDeviceManagerClass, device_changed), + NULL, NULL, NULL, + G_TYPE_NONE, 1, + GSD_TYPE_DEVICE | G_SIGNAL_TYPE_STATIC_SCOPE); +} + +static GsdDeviceType +udev_device_get_device_type (GUdevDevice *device) +{ + GsdDeviceType type = 0; + gint i; + + for (i = 0; i < G_N_ELEMENTS (udev_ids); i++) { + if (g_udev_device_get_property_as_boolean (device, udev_ids[i])) + type |= (1 << i); + } + + return type; +} + +static gboolean +device_is_evdev (GUdevDevice *device) +{ + const gchar *device_file; + + device_file = g_udev_device_get_device_file (device); + + if (!device_file || strstr (device_file, "/event") == NULL) + return FALSE; + + return g_udev_device_get_property_as_boolean (device, "ID_INPUT"); +} + +static GsdDevice * +create_device (GUdevDevice *udev_device) +{ + const gchar *vendor, *product, *name, *group; + guint width, height; + g_autoptr(GUdevDevice) parent = NULL; + + parent = g_udev_device_get_parent (udev_device); + g_assert (parent != NULL); + + name = g_udev_device_get_sysfs_attr (parent, "name"); + vendor = g_udev_device_get_property (udev_device, "ID_VENDOR_ID"); + product = g_udev_device_get_property (udev_device, "ID_MODEL_ID"); + + if (!vendor || !product) { + vendor = g_udev_device_get_sysfs_attr (udev_device, "device/id/vendor"); + product = g_udev_device_get_sysfs_attr (udev_device, "device/id/product"); + } + + width = g_udev_device_get_property_as_int (udev_device, "ID_INPUT_WIDTH_MM"); + height = g_udev_device_get_property_as_int (udev_device, "ID_INPUT_HEIGHT_MM"); + + group = g_udev_device_get_property (udev_device, "LIBINPUT_DEVICE_GROUP"); + + return g_object_new (GSD_TYPE_DEVICE, + "name", name, + "device-file", g_udev_device_get_device_file (udev_device), + "type", udev_device_get_device_type (udev_device), + "vendor-id", vendor, + "product-id", product, + "width", width, + "height", height, + "group", group, + NULL); +} + +static void +add_device (GsdDeviceManager *manager, + GUdevDevice *udev_device) +{ + GsdDeviceManagerPrivate *priv = gsd_device_manager_get_instance_private (manager); + GUdevDevice *parent; + GsdDevice *device; + const gchar *syspath; + + parent = g_udev_device_get_parent (udev_device); + + if (!parent) + return; + + device = create_device (udev_device); + syspath = g_udev_device_get_sysfs_path (udev_device); + g_hash_table_insert (priv->devices, g_strdup (syspath), device); + g_signal_emit_by_name (manager, "device-added", device); +} + +static void +remove_device (GsdDeviceManager *manager, + GUdevDevice *udev_device) +{ + GsdDeviceManagerPrivate *priv = gsd_device_manager_get_instance_private (manager); + GsdDevice *device; + const gchar *syspath; + + syspath = g_udev_device_get_sysfs_path (udev_device); + device = g_hash_table_lookup (priv->devices, syspath); + + if (!device) + return; + + g_hash_table_steal (priv->devices, syspath); + g_signal_emit_by_name (manager, "device-removed", device); + + g_object_unref (device); +} + +static void +udev_event_cb (GUdevClient *client, + gchar *action, + GUdevDevice *device, + GsdDeviceManager *manager) +{ + if (!device_is_evdev (device)) + return; + + if (g_strcmp0 (action, "add") == 0) { + add_device (manager, device); + } else if (g_strcmp0 (action, "remove") == 0) { + remove_device (manager, device); + } +} + +static void +gsd_device_manager_init (GsdDeviceManager *manager) +{ + GsdDeviceManagerPrivate *priv = gsd_device_manager_get_instance_private (manager); + const gchar *subsystems[] = { "input", NULL }; + g_autoptr(GList) devices = NULL; + GList *l; + + priv->devices = g_hash_table_new_full (g_str_hash, g_str_equal, + (GDestroyNotify) g_free, + (GDestroyNotify) g_object_unref); + + priv->udev_client = g_udev_client_new (subsystems); + g_signal_connect (priv->udev_client, "uevent", + G_CALLBACK (udev_event_cb), manager); + + devices = g_udev_client_query_by_subsystem (priv->udev_client, + subsystems[0]); + + for (l = devices; l; l = l->next) { + g_autoptr(GUdevDevice) device = l->data; + + if (device_is_evdev (device)) + add_device (manager, device); + } +} + +GsdDeviceManager * +gsd_device_manager_get (void) +{ + GsdDeviceManager *manager; + GdkScreen *screen; + + screen = gdk_screen_get_default (); + g_return_val_if_fail (screen != NULL, NULL); + + manager = g_object_get_data (G_OBJECT (screen), "gsd-device-manager-data"); + + if (!manager) { + manager = g_object_new (GSD_TYPE_DEVICE_MANAGER, + NULL); + + g_object_set_data_full (G_OBJECT (screen), "gsd-device-manager-data", + manager, (GDestroyNotify) g_object_unref); + } + + return manager; +} + +GList * +gsd_device_manager_list_devices (GsdDeviceManager *manager, + GsdDeviceType type) +{ + g_return_val_if_fail (GSD_IS_DEVICE_MANAGER (manager), NULL); + + return GSD_DEVICE_MANAGER_GET_CLASS (manager)->list_devices (manager, type); +} + +GsdDeviceType +gsd_device_get_device_type (GsdDevice *device) +{ + GsdDevicePrivate *priv; + + g_return_val_if_fail (GSD_IS_DEVICE (device), 0); + + priv = gsd_device_get_instance_private (device); + + return priv->type; +} + +void +gsd_device_get_device_ids (GsdDevice *device, + const gchar **vendor, + const gchar **product) +{ + GsdDevicePrivate *priv; + + g_return_if_fail (GSD_IS_DEVICE (device)); + + priv = gsd_device_get_instance_private (device); + + if (vendor) + *vendor = priv->vendor_id; + if (product) + *product = priv->product_id; +} + +GSettings * +gsd_device_get_settings (GsdDevice *device) +{ + const gchar *schema = NULL, *vendor, *product; + GsdDeviceType type; + g_autofree gchar *path = NULL; + + g_return_val_if_fail (GSD_IS_DEVICE (device), NULL); + + type = gsd_device_get_device_type (device); + + if (type & (GSD_DEVICE_TYPE_TOUCHSCREEN | GSD_DEVICE_TYPE_TABLET)) { + gsd_device_get_device_ids (device, &vendor, &product); + + if (type & GSD_DEVICE_TYPE_TOUCHSCREEN) { + schema = "org.gnome.desktop.peripherals.touchscreen"; + path = g_strdup_printf ("/org/gnome/desktop/peripherals/touchscreens/%s:%s/", + vendor, product); + } else if (type & GSD_DEVICE_TYPE_TABLET) { + schema = "org.gnome.desktop.peripherals.tablet"; + path = g_strdup_printf ("/org/gnome/desktop/peripherals/tablets/%s:%s/", + vendor, product); + } + } else if (type & (GSD_DEVICE_TYPE_MOUSE | GSD_DEVICE_TYPE_TOUCHPAD)) { + schema = "org.gnome.desktop.peripherals.mouse"; + } else if (type & GSD_DEVICE_TYPE_KEYBOARD) { + schema = "org.gnome.desktop.peripherals.keyboard"; + } else { + return NULL; + } + + if (path) { + return g_settings_new_with_path (schema, path); + } else { + return g_settings_new (schema); + } +} + +const gchar * +gsd_device_get_name (GsdDevice *device) +{ + GsdDevicePrivate *priv; + + g_return_val_if_fail (GSD_IS_DEVICE (device), NULL); + + priv = gsd_device_get_instance_private (device); + + return priv->name; +} + +const gchar * +gsd_device_get_device_file (GsdDevice *device) +{ + GsdDevicePrivate *priv; + + g_return_val_if_fail (GSD_IS_DEVICE (device), NULL); + + priv = gsd_device_get_instance_private (device); + + return priv->device_file; +} + +gboolean +gsd_device_get_dimensions (GsdDevice *device, + guint *width, + guint *height) +{ + GsdDevicePrivate *priv; + + g_return_val_if_fail (GSD_IS_DEVICE (device), FALSE); + + priv = gsd_device_get_instance_private (device); + + if (width) + *width = priv->width; + if (height) + *height = priv->height; + + return priv->width > 0 && priv->height > 0; +} + +GsdDevice * +gsd_device_manager_lookup_gdk_device (GsdDeviceManager *manager, + GdkDevice *gdk_device) +{ + GsdDeviceManagerClass *klass; + + g_return_val_if_fail (GSD_IS_DEVICE_MANAGER (manager), NULL); + g_return_val_if_fail (GDK_IS_DEVICE (gdk_device), NULL); + + klass = GSD_DEVICE_MANAGER_GET_CLASS (manager); + if (!klass->lookup_device) + return NULL; + + return klass->lookup_device (manager, gdk_device); +} + +gboolean +gsd_device_shares_group (GsdDevice *device1, + GsdDevice *device2) +{ + GsdDevicePrivate *priv1, *priv2; + + priv1 = gsd_device_get_instance_private (GSD_DEVICE (device1)); + priv2 = gsd_device_get_instance_private (GSD_DEVICE (device2)); + + /* Don't group NULLs together */ + if (!priv1->group && !priv2->group) + return FALSE; + + return g_strcmp0 (priv1->group, priv2->group) == 0; +} diff --git a/panels/common/gsd-device-manager.h b/panels/common/gsd-device-manager.h new file mode 100644 index 0000000..f48b5ad --- /dev/null +++ b/panels/common/gsd-device-manager.h @@ -0,0 +1,86 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2014 Carlos Garnacho <carlosg@gnome.org> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#pragma once + +#include <gdk/gdk.h> +#include <glib-object.h> +#include <gio/gio.h> + +G_BEGIN_DECLS + +#define GSD_TYPE_DEVICE (gsd_device_get_type ()) +G_DECLARE_DERIVABLE_TYPE (GsdDevice, gsd_device, GSD, DEVICE, GObject) + +#define GSD_TYPE_DEVICE_MANAGER (gsd_device_manager_get_type ()) +G_DECLARE_DERIVABLE_TYPE (GsdDeviceManager, gsd_device_manager, GSD, DEVICE_MANAGER, GObject) + +typedef enum { + GSD_DEVICE_TYPE_MOUSE = 1 << 0, + GSD_DEVICE_TYPE_KEYBOARD = 1 << 1, + GSD_DEVICE_TYPE_TOUCHPAD = 1 << 2, + GSD_DEVICE_TYPE_TABLET = 1 << 3, + GSD_DEVICE_TYPE_TOUCHSCREEN = 1 << 4, + GSD_DEVICE_TYPE_PAD = 1 << 5 +} GsdDeviceType; + +struct _GsdDeviceClass { + GObjectClass parent_class; +}; + +struct _GsdDeviceManagerClass +{ + GObjectClass parent_class; + + GList * (* list_devices) (GsdDeviceManager *manager, + GsdDeviceType type); + + void (* device_added) (GsdDeviceManager *manager, + GsdDevice *device); + void (* device_removed) (GsdDeviceManager *manager, + GsdDevice *device); + void (* device_changed) (GsdDeviceManager *manager, + GsdDevice *device); + + GsdDevice * (* lookup_device) (GsdDeviceManager *manager, + GdkDevice *gdk_device); +}; + +GsdDeviceManager * gsd_device_manager_get (void); +GList * gsd_device_manager_list_devices (GsdDeviceManager *manager, + GsdDeviceType type); + +const gchar * gsd_device_get_name (GsdDevice *device); +GsdDeviceType gsd_device_get_device_type (GsdDevice *device); +void gsd_device_get_device_ids (GsdDevice *device, + const gchar **vendor, + const gchar **product); +GSettings * gsd_device_get_settings (GsdDevice *device); + +const gchar * gsd_device_get_device_file (GsdDevice *device); +gboolean gsd_device_get_dimensions (GsdDevice *device, + guint *width, + guint *height); + +GsdDevice * gsd_device_manager_lookup_gdk_device (GsdDeviceManager *manager, + GdkDevice *gdk_device); +gboolean gsd_device_shares_group (GsdDevice *device1, + GsdDevice *device2); + +G_END_DECLS diff --git a/panels/common/gsd-input-helper.c b/panels/common/gsd-input-helper.c new file mode 100644 index 0000000..6ffc18b --- /dev/null +++ b/panels/common/gsd-input-helper.c @@ -0,0 +1,108 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2010 Bastien Nocera <hadess@hadess.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <http://www.gnu.org/licenses/>. + * + */ + +#include "config.h" + +#include <string.h> + +#include <gdk/gdk.h> +#include <gdk/gdkx.h> + +#include <sys/types.h> +#include <X11/Xatom.h> +#include <X11/extensions/XInput2.h> + +#include "gsd-input-helper.h" +#include "gsd-device-manager.h" + +static gboolean +device_type_is_present (GsdDeviceType type) +{ + g_autoptr(GList) l = gsd_device_manager_list_devices (gsd_device_manager_get (), + type); + return l != NULL; +} + +gboolean +touchscreen_is_present (void) +{ + return device_type_is_present (GSD_DEVICE_TYPE_TOUCHSCREEN); +} + +gboolean +touchpad_is_present (void) +{ + return device_type_is_present (GSD_DEVICE_TYPE_TOUCHPAD); +} + +gboolean +mouse_is_present (void) +{ + return device_type_is_present (GSD_DEVICE_TYPE_MOUSE); +} + +char * +xdevice_get_device_node (int deviceid) +{ + GdkDisplay *display; + Atom prop; + Atom act_type; + int act_format; + unsigned long nitems, bytes_after; + unsigned char *data; + char *ret; + + display = gdk_display_get_default (); + gdk_display_sync (display); + + prop = XInternAtom (GDK_DISPLAY_XDISPLAY (display), "Device Node", False); + if (!prop) + return NULL; + + gdk_x11_display_error_trap_push (display); + + if (!XIGetProperty (GDK_DISPLAY_XDISPLAY (display), + deviceid, prop, 0, 1000, False, + AnyPropertyType, &act_type, &act_format, + &nitems, &bytes_after, &data) == Success) { + gdk_x11_display_error_trap_pop_ignored (display); + return NULL; + } + if (gdk_x11_display_error_trap_pop (display)) + goto out; + + if (nitems == 0) + goto out; + + if (act_type != XA_STRING) + goto out; + + /* Unknown string format */ + if (act_format != 8) + goto out; + + ret = g_strdup ((char *) data); + + XFree (data); + return ret; + +out: + XFree (data); + return NULL; +} diff --git a/panels/common/gsd-input-helper.h b/panels/common/gsd-input-helper.h new file mode 100644 index 0000000..8fda1e6 --- /dev/null +++ b/panels/common/gsd-input-helper.h @@ -0,0 +1,31 @@ +/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 8 -*- + * + * Copyright (C) 2010 Bastien Nocera <hadess@hadess.net> + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <http://www.gnu.org/licenses/>. + */ + +#pragma once + +G_BEGIN_DECLS + +#include <glib.h> + +gboolean touchpad_is_present (void); +gboolean touchscreen_is_present (void); +gboolean mouse_is_present (void); + +char * xdevice_get_device_node (int deviceid); + +G_END_DECLS diff --git a/panels/common/hostname-helper.c b/panels/common/hostname-helper.c new file mode 100644 index 0000000..a8f7c41 --- /dev/null +++ b/panels/common/hostname-helper.c @@ -0,0 +1,204 @@ +/* + * Copyright (C) 2011 Red Hat, Inc + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <http://www.gnu.org/licenses/>. + * + */ + +#include <glib.h> +#include <glib/gi18n.h> +#include <string.h> + +#include "hostname-helper.h" + +static char * +allowed_chars (void) +{ + GString *s; + char i; + + s = g_string_new (NULL); + for (i = 'a'; i <= 'z'; i++) + g_string_append_c (s, i); + for (i = 'A'; i <= 'Z'; i++) + g_string_append_c (s, i); + for (i = '0'; i <= '9'; i++) + g_string_append_c (s, i); + g_string_append_c (s, '-'); + + return g_string_free (s, FALSE); +} + +static char * +remove_leading_dashes (char *input) +{ + char *start; + + for (start = input; *start && (*start == '-'); start++) + ; + + memmove (input, start, strlen (start) + 1); + + return input; +} + +static gboolean +is_empty (const char *input) +{ + if (input == NULL || + *input == '\0') + return TRUE; + return FALSE; +} + +static char * +remove_trailing_dashes (char *input) +{ + int len; + + len = strlen (input); + while (len--) { + if (input[len] == '-') + input[len] = '\0'; + else + break; + } + return input; +} + +static char * +remove_apostrophes (char *input) +{ + char *apo; + + while ((apo = strchr (input, '\'')) != NULL) + memmove (apo, apo + 1, strlen (apo)); + return input; +} + +static char * +remove_duplicate_dashes (char *input) +{ + char *dashes; + + while ((dashes = strstr (input, "--")) != NULL) + memmove (dashes, dashes + 1, strlen (dashes)); + return input; +} + +#define CHECK if (is_empty (result)) return g_strdup ("localhost") + +char * +pretty_hostname_to_static (const char *pretty, + gboolean for_display) +{ + g_autofree gchar *result = NULL; + g_autofree gchar *valid_chars = NULL; + g_autofree gchar *composed = NULL; + + g_return_val_if_fail (pretty != NULL, NULL); + g_return_val_if_fail (g_utf8_validate (pretty, -1, NULL), NULL); + + g_debug ("Input: '%s'", pretty); + + composed = g_utf8_normalize (pretty, -1, G_NORMALIZE_ALL_COMPOSE); + g_debug ("\tcomposed: '%s'", composed); + /* Transform the pretty hostname to ASCII */ + result = g_str_to_ascii (composed, NULL); + g_debug ("\ttranslit: '%s'", result); + + CHECK; + + /* Remove apostrophes */ + remove_apostrophes (result); + g_debug ("\tapostrophes: '%s'", result); + + CHECK; + + /* Remove all the not-allowed chars */ + valid_chars = allowed_chars (); + g_strcanon (result, valid_chars, '-'); + g_debug ("\tcanon: '%s'", result); + + CHECK; + + /* Remove the leading dashes */ + remove_leading_dashes (result); + g_debug ("\tleading: '%s'", result); + + CHECK; + + /* Remove trailing dashes */ + remove_trailing_dashes (result); + g_debug ("\ttrailing: '%s'", result); + + CHECK; + + /* Remove duplicate dashes */ + remove_duplicate_dashes (result); + g_debug ("\tduplicate: '%s'", result); + + CHECK; + + /* Lower case */ + if (!for_display) + return g_ascii_strdown (result, -1); + + return g_steal_pointer (&result); +} +#undef CHECK + +/* Max length of an SSID in bytes */ +#define SSID_MAX_LEN 32 +char * +pretty_hostname_to_ssid (const char *pretty) +{ + const char *p, *prev; + + if (pretty == NULL || *pretty == '\0') { + pretty = g_get_host_name (); + if (g_strcmp0 (pretty, "localhost") == 0) + pretty = NULL; + } + + if (pretty == NULL) { + /* translators: This is the default hotspot name, need to be less than 32-bytes */ + gchar *ret = g_strdup (C_("hotspot", "Hotspot")); + g_assert (strlen (ret) <= SSID_MAX_LEN); + return ret; + } + + g_return_val_if_fail (g_utf8_validate (pretty, -1, NULL), NULL); + + p = pretty; + prev = NULL; + while ((p = g_utf8_find_next_char (p, NULL)) != NULL) { + if (p == prev) + break; + + if (p - pretty > SSID_MAX_LEN) { + return g_strndup (pretty, prev - pretty); + } + if (p - pretty == SSID_MAX_LEN) { + return g_strndup (pretty, p - pretty); + } + + if (*p == '\0') + break; + + prev = p; + } + + return g_strdup (pretty); +} diff --git a/panels/common/hostname-helper.h b/panels/common/hostname-helper.h new file mode 100644 index 0000000..3d2a143 --- /dev/null +++ b/panels/common/hostname-helper.h @@ -0,0 +1,23 @@ +/* + * Copyright (C) 2011 Red Hat, Inc + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <http://www.gnu.org/licenses/>. + * + */ + +#pragma once + +char *pretty_hostname_to_static (const char *pretty, + gboolean for_display); +char *pretty_hostname_to_ssid (const char *pretty); diff --git a/panels/common/list-box-helper.c b/panels/common/list-box-helper.c new file mode 100644 index 0000000..77b1f65 --- /dev/null +++ b/panels/common/list-box-helper.c @@ -0,0 +1,151 @@ +/* + * Copyright (C) 2014 Red Hat, Inc + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <http://www.gnu.org/licenses/>. + * + */ + +#include "list-box-helper.h" + +#define MAX_ROWS_VISIBLE 5 + +struct _CcListBoxRow +{ + GtkListBoxRow parent_instance; +}; +G_DEFINE_TYPE (CcListBoxRow, cc_list_box_row, GTK_TYPE_LIST_BOX_ROW) +enum +{ + BOX_ROW_ACTIVATED, + LAST_BOX_ROW_SIGNAL +}; +static guint cc_list_box_row_signals[LAST_BOX_ROW_SIGNAL] = { 0 }; +static void +cc_list_box_row_class_init (CcListBoxRowClass *klass) +{ + cc_list_box_row_signals[BOX_ROW_ACTIVATED] = + g_signal_new ("activated", + CC_TYPE_LIST_BOX_ROW, + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, 0); +} +static void cc_list_box_row_init (CcListBoxRow *self) {} + +struct _CcListBox +{ + GtkListBox parent_instance; +}; +G_DEFINE_TYPE (CcListBox, cc_list_box, GTK_TYPE_LIST_BOX) +static void +cc_list_box_row_activated (GtkListBox *box, GtkListBoxRow *row) +{ + if (CC_IS_LIST_BOX_ROW (row)) + g_signal_emit (row, cc_list_box_row_signals[BOX_ROW_ACTIVATED], 0); +} +static void +cc_list_box_class_init (CcListBoxClass *klass) +{ + GtkListBoxClass *parent_class = GTK_LIST_BOX_CLASS (klass); + parent_class->row_activated = cc_list_box_row_activated; +} +static void cc_list_box_init (CcListBox *self) {} + + +void +cc_list_box_update_header_func (GtkListBoxRow *row, + GtkListBoxRow *before, + gpointer user_data) +{ + GtkWidget *current; + + if (before == NULL) + { + gtk_list_box_row_set_header (row, NULL); + return; + } + + current = gtk_list_box_row_get_header (row); + if (current == NULL) + { + current = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL); + gtk_widget_show (current); + gtk_list_box_row_set_header (row, current); + } +} + +void +cc_list_box_adjust_scrolling (GtkListBox *listbox) +{ + GtkWidget *scrolled_window; + g_autoptr(GList) children = NULL; + guint n_rows, num_max_rows; + + scrolled_window = g_object_get_data (G_OBJECT (listbox), "cc-scrolling-scrolled-window"); + if (!scrolled_window) + return; + + children = gtk_container_get_children (GTK_CONTAINER (listbox)); + n_rows = g_list_length (children); + + num_max_rows = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (listbox), "cc-max-rows-visible")); + + if (n_rows >= num_max_rows) + { + gint total_row_height = 0; + GList *l; + guint i; + + for (l = children, i = 0; l != NULL && i < num_max_rows; l = l->next, i++) { + gint row_height; + gtk_widget_get_preferred_height (GTK_WIDGET (l->data), &row_height, NULL); + total_row_height += row_height; + } + + gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (scrolled_window), total_row_height); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), + GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); + } + else + { + gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (scrolled_window), -1); + gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), + GTK_POLICY_NEVER, GTK_POLICY_NEVER); + } +} + +void +cc_list_box_setup_scrolling (GtkListBox *listbox, + guint num_max_rows) +{ + GtkWidget *parent; + GtkWidget *scrolled_window; + + parent = gtk_widget_get_parent (GTK_WIDGET (listbox)); + scrolled_window = gtk_scrolled_window_new (NULL, NULL); + gtk_widget_show (scrolled_window); + + g_object_ref (listbox); + gtk_container_remove (GTK_CONTAINER (parent), GTK_WIDGET (listbox)); + gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (listbox)); + g_object_unref (listbox); + + gtk_container_add (GTK_CONTAINER (parent), scrolled_window); + + if (num_max_rows == 0) + num_max_rows = MAX_ROWS_VISIBLE; + + g_object_set_data (G_OBJECT (listbox), "cc-scrolling-scrolled-window", scrolled_window); + g_object_set_data (G_OBJECT (listbox), "cc-max-rows-visible", GUINT_TO_POINTER (num_max_rows)); +} diff --git a/panels/common/list-box-helper.h b/panels/common/list-box-helper.h new file mode 100644 index 0000000..f3c2553 --- /dev/null +++ b/panels/common/list-box-helper.h @@ -0,0 +1,39 @@ +/* + * Copyright (C) 2014 Red Hat, Inc + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see <http://www.gnu.org/licenses/>. + * + */ + +#pragma once + +#include <gtk/gtk.h> + +#define CC_TYPE_LIST_BOX_ROW (cc_list_box_row_get_type ()) +G_DECLARE_FINAL_TYPE (CcListBoxRow, cc_list_box_row, CC, LIST_BOX_ROW, GtkListBoxRow) + +#define CC_TYPE_LIST_BOX (cc_list_box_get_type ()) +G_DECLARE_FINAL_TYPE (CcListBox, cc_list_box, CC, LIST_BOX, GtkListBox) + +void +cc_list_box_update_header_func (GtkListBoxRow *row, + GtkListBoxRow *before, + gpointer user_data); + +void +cc_list_box_adjust_scrolling (GtkListBox *listbox); + +void +cc_list_box_setup_scrolling (GtkListBox *listbox, + guint num_rows); diff --git a/panels/common/meson.build b/panels/common/meson.build new file mode 100644 index 0000000..85fabf2 --- /dev/null +++ b/panels/common/meson.build @@ -0,0 +1,121 @@ +common_inc = include_directories('.') + +common_sources = [] + +enums = 'gsd-common-enums' +enums_header = files('gsd-device-manager.h') + +common_sources += gnome.mkenums( + enums + '.h', + sources: enums_header, + fhead: '#pragma once\n\n#include <glib-object.h>\n\nG_BEGIN_DECLS\n', + fprod: '/* enumerations from "@filename@" */\n', + vhead: 'GType @enum_name@_get_type (void) G_GNUC_CONST;\n#define GSD_TYPE_@ENUMSHORT@ (@enum_name@_get_type())\n', + ftail: 'G_END_DECLS\n' +) + +common_sources += gnome.mkenums( + enums + '.c', + sources: enums_header, + fhead: '#include "gsd-device-manager.h"\n#include "gsd-common-enums.h"\n', + fprod: '\n/* enumerations from "@filename@" */', + vhead: 'GType\n@enum_name@_get_type (void)\n{\n static GType etype = 0;\n if (etype == 0) {\n static const G@Type@Value values[] = {', + vprod: ' { @VALUENAME@, "@VALUENAME@", "@valuenick@" },', + vtail: ' { 0, NULL, NULL }\n };\n etype = g_@type@_register_static ("@EnumName@", values);\n }\n return etype;\n}\n' +) + +sources = files( + 'cc-hostname-entry.c', + 'cc-time-entry.c', + 'cc-os-release.c', + 'hostname-helper.c', + 'list-box-helper.c', +) + +libwidgets = static_library( + 'widgets', + sources: sources, + include_directories: top_inc, + dependencies: common_deps + [ polkit_gobject_dep ] +) +libwidgets_dep = declare_dependency( + include_directories: common_inc, + link_with: libwidgets +) + +sources = common_sources + files( + 'cc-common-language.c', + 'cc-language-chooser.c', + 'cc-list-row.c', + 'cc-time-editor.c', + 'cc-permission-infobar.c', + 'cc-util.c' +) + +resource_data = files( + 'cc-language-chooser.ui', + 'cc-list-row.ui', + 'cc-time-editor.ui', + 'cc-permission-infobar.ui', +) + +sources += gnome.compile_resources( + 'cc-common-resources', + 'common.gresource.xml', + c_name: 'cc_common', + dependencies: resource_data, + export: true +) + +deps = common_deps + [ + gnome_desktop_dep, + dependency('fontconfig') +] + +liblanguage = static_library( + 'language', + sources: sources, + include_directories: top_inc, + dependencies: deps +) + +liblanguage_dep = declare_dependency( + include_directories: common_inc, + link_with: liblanguage +) + +gsd_headers = [ + 'gsd-device-manager.h', + 'gsd-input-helper.h' +] + +gsd_sources = [ + 'gsd-device-manager.c', + 'gsd-input-helper.c' +] + +sources = common_sources + files(gsd_sources) + +deps = common_deps + [ gudev_dep ] + +libdevice = static_library( + 'device', + sources: sources, + include_directories: top_inc, + dependencies: deps +) + +libdevice_dep = declare_dependency( + include_directories: common_inc, + link_with: libdevice +) + +polkit_conf = configuration_data() +polkit_conf.set('PRIVILEGED_GROUP', get_option('privileged_group')) +configure_file( + input: 'gnome-control-center.rules.in', + output: 'gnome-control-center.rules', + configuration: polkit_conf, + install_dir: join_paths(control_center_datadir, 'polkit-1', 'rules.d') +) + |