diff options
Diffstat (limited to '')
34 files changed, 5821 insertions, 0 deletions
diff --git a/shell/appdata/gnome-control-center.appdata.xml.in b/shell/appdata/gnome-control-center.appdata.xml.in new file mode 100644 index 0000000..bbed55c --- /dev/null +++ b/shell/appdata/gnome-control-center.appdata.xml.in @@ -0,0 +1,30 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!-- Copyright 2015 Richard Hughes <richard@hughsie.com> --> +<component type="desktop"> + <id>gnome-control-center.desktop</id> + <metadata_license>CC0-1.0</metadata_license> + <project_license>GPL-2.0+</project_license> + <name>GNOME Settings</name> + <summary>Utility to configure the GNOME desktop</summary> + <description> + <p> + Settings is the primary interface for configuring your system. + </p> + </description> + <url type="bugtracker">https://gitlab.gnome.org/GNOME/gnome-control-center/issues/</url> + <url type="donation">https://www.gnome.org/friends/</url> + <url type="translate">https://wiki.gnome.org/TranslationProject</url> + <update_contact>gnomecc-list_at_gnome.org</update_contact> + <project_group>GNOME</project_group> + <launchable type="desktop-id">gnome-control-center.desktop</launchable> + <developer_name>The GNOME Project</developer_name> + <compulsory_for_desktop>GNOME</compulsory_for_desktop> + <kudos> + <kudo>HiDpiIcon</kudo> + <kudo>HighContrast</kudo> + <kudo>ModernToolkit</kudo> + <kudo>SearchProvider</kudo> + <kudo>UserDocs</kudo> + </kudos> + <translation type="gettext">gnome-control-center-2.0</translation> +</component> diff --git a/shell/appdata/meson.build b/shell/appdata/meson.build new file mode 100644 index 0000000..3b36171 --- /dev/null +++ b/shell/appdata/meson.build @@ -0,0 +1,10 @@ +appdata = 'gnome-control-center.appdata.xml' + +i18n.merge_file( + appdata, + input: appdata + '.in', + output: appdata, + po_dir: po_dir, + install: true, + install_dir: join_paths(control_center_datadir, 'metainfo') +) diff --git a/shell/cc-application.c b/shell/cc-application.c new file mode 100644 index 0000000..4a90157 --- /dev/null +++ b/shell/cc-application.c @@ -0,0 +1,310 @@ +/* + * Copyright © 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, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#include "config.h" + +#include <stdlib.h> + +#include <glib.h> +#include <glib/gi18n.h> +#include <gio/gio.h> +#include <handy.h> + +#include "cc-application.h" +#include "cc-log.h" +#include "cc-object-storage.h" +#include "cc-panel-loader.h" +#include "cc-window.h" + +struct _CcApplication +{ + GtkApplication parent; + + CcShellModel *model; + + CcWindow *window; +}; + +static void cc_application_quit (GSimpleAction *simple, + GVariant *parameter, + gpointer user_data); + +static void launch_panel_activated (GSimpleAction *action, + GVariant *parameter, + gpointer user_data); + +static void help_activated (GSimpleAction *action, + GVariant *parameter, + gpointer user_data); + +G_DEFINE_TYPE (CcApplication, cc_application, GTK_TYPE_APPLICATION) + +const GOptionEntry all_options[] = { + { "version", 0, 0, G_OPTION_ARG_NONE, NULL, N_("Display version number"), NULL }, + { "verbose", 'v', 0, G_OPTION_ARG_NONE, NULL, N_("Enable verbose mode"), NULL }, + { "search", 's', 0, G_OPTION_ARG_STRING, NULL, N_("Search for the string"), "SEARCH" }, + { "list", 'l', 0, G_OPTION_ARG_NONE, NULL, N_("List possible panel names and exit"), NULL }, + { G_OPTION_REMAINING, '\0', 0, G_OPTION_ARG_FILENAME_ARRAY, NULL, N_("Panel to display"), N_("[PANEL] [ARGUMENT…]") }, + { NULL, 0, 0, 0, NULL, NULL, NULL } /* end the list */ +}; + +static const GActionEntry cc_app_actions[] = { + { "launch-panel", launch_panel_activated, "(sav)", NULL, NULL, { 0 } }, + { "help", help_activated, NULL, NULL, NULL, { 0 } }, + { "quit", cc_application_quit, NULL, NULL, NULL, { 0 } } +}; + +static void +help_activated (GSimpleAction *action, + GVariant *parameter, + gpointer user_data) +{ + CcApplication *self = CC_APPLICATION (user_data); + CcPanel *panel; + GtkWidget *window; + const char *uri = NULL; + + panel = cc_shell_get_active_panel (CC_SHELL (self->window)); + if (panel) + uri = cc_panel_get_help_uri (panel); + + window = cc_shell_get_toplevel (CC_SHELL (self->window)); + gtk_show_uri_on_window (GTK_WINDOW (window), + uri ? uri : "help:gnome-help/prefs", + GDK_CURRENT_TIME, + NULL); +} + +static void +launch_panel_activated (GSimpleAction *action, + GVariant *parameter, + gpointer user_data) +{ + CcApplication *self = CC_APPLICATION (user_data); + g_autoptr(GVariant) parameters = NULL; + g_autoptr(GError) error = NULL; + gchar *panel_id; + + g_variant_get (parameter, "(&s@av)", &panel_id, ¶meters); + + g_debug ("gnome-control-center: 'launch-panel' activated for panel '%s' with %"G_GSIZE_FORMAT" arguments", + panel_id, + g_variant_n_children (parameters)); + + if (!cc_shell_set_active_panel_from_id (CC_SHELL (self->window), panel_id, parameters, &error)) + g_warning ("Failed to activate the '%s' panel: %s", panel_id, error->message); + + /* Now present the window */ + g_application_activate (G_APPLICATION (self)); +} + +static gint +cc_application_handle_local_options (GApplication *application, + GVariantDict *options) +{ + if (g_variant_dict_contains (options, "version")) + { + g_print ("%s %s\n", PACKAGE, VERSION); + return 0; + } + + if (g_variant_dict_contains (options, "list")) + { + cc_panel_loader_list_panels (); + return 0; + } + + return -1; +} + +static int +cc_application_command_line (GApplication *application, + GApplicationCommandLine *command_line) +{ + CcApplication *self; + g_autofree GStrv start_panels = NULL; + GVariantDict *options; + int retval = 0; + char *search_str; + gboolean debug; + + self = CC_APPLICATION (application); + options = g_application_command_line_get_options_dict (command_line); + + debug = g_variant_dict_contains (options, "verbose"); + + if (debug) + cc_log_init (); + + gtk_window_present (GTK_WINDOW (self->window)); + + if (g_variant_dict_lookup (options, "search", "&s", &search_str)) + { + cc_window_set_search_item (self->window, search_str); + } + else if (g_variant_dict_lookup (options, G_OPTION_REMAINING, "^a&ay", &start_panels)) + { + const char *start_id; + GError *err = NULL; + GVariant *parameters; + GVariantBuilder builder; + int i; + + g_return_val_if_fail (start_panels[0] != NULL, 1); + start_id = start_panels[0]; + + if (start_panels[1]) + g_debug ("Extra argument: %s", start_panels[1]); + else + g_debug ("No extra argument"); + + g_variant_builder_init (&builder, G_VARIANT_TYPE ("av")); + + for (i = 1; start_panels[i] != NULL; i++) + g_variant_builder_add (&builder, "v", g_variant_new_string (start_panels[i])); + parameters = g_variant_builder_end (&builder); + if (!cc_shell_set_active_panel_from_id (CC_SHELL (self->window), start_id, parameters, &err)) + { + g_warning ("Could not load setting panel \"%s\": %s", start_id, + (err) ? err->message : "Unknown error"); + retval = 1; + + if (err) + g_clear_error (&err); + } + } + + return retval; +} + +static void +cc_application_quit (GSimpleAction *simple, + GVariant *parameter, + gpointer user_data) +{ + CcApplication *self = CC_APPLICATION (user_data); + + gtk_widget_destroy (GTK_WIDGET (self->window)); +} + + +static void +cc_application_activate (GApplication *application) +{ + CcApplication *self = CC_APPLICATION (application); + + gtk_window_present (GTK_WINDOW (self->window)); +} + +static void +cc_application_startup (GApplication *application) +{ + CcApplication *self = CC_APPLICATION (application); + const gchar *help_accels[] = { "F1", NULL }; + + g_action_map_add_action_entries (G_ACTION_MAP (self), + cc_app_actions, + G_N_ELEMENTS (cc_app_actions), + self); + + G_APPLICATION_CLASS (cc_application_parent_class)->startup (application); + + hdy_init (); + + gtk_application_set_accels_for_action (GTK_APPLICATION (application), + "app.help", help_accels); + + self->model = cc_shell_model_new (); + self->window = cc_window_new (GTK_APPLICATION (application), self->model); +} + +static void +cc_application_finalize (GObject *object) +{ + /* Destroy the object storage cache when finalizing */ + cc_object_storage_destroy (); + + G_OBJECT_CLASS (cc_application_parent_class)->finalize (object); +} + +static GObject * +cc_application_constructor (GType type, + guint n_construct_params, + GObjectConstructParam *construct_params) +{ + static GObject *self = NULL; + + if (self == NULL) + { + self = G_OBJECT_CLASS (cc_application_parent_class)->constructor (type, + n_construct_params, + construct_params); + g_object_add_weak_pointer (self, (gpointer) &self); + return self; + } + + return g_object_ref (self); +} + +static void +cc_application_class_init (CcApplicationClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GApplicationClass *application_class = G_APPLICATION_CLASS (klass); + + object_class->finalize = cc_application_finalize; + object_class->constructor = cc_application_constructor; + application_class->activate = cc_application_activate; + application_class->startup = cc_application_startup; + application_class->command_line = cc_application_command_line; + application_class->handle_local_options = cc_application_handle_local_options; +} + +static void +cc_application_init (CcApplication *self) +{ + g_autoptr(GtkCssProvider) provider = NULL; + + cc_object_storage_initialize (); + + g_application_add_main_option_entries (G_APPLICATION (self), all_options); + + provider = gtk_css_provider_new (); + gtk_css_provider_load_from_resource (provider, "/org/gnome/ControlCenter/gtk/style.css"); + gtk_style_context_add_provider_for_screen (gdk_screen_get_default (), + GTK_STYLE_PROVIDER (provider), + GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); +} + +GtkApplication * +cc_application_new (void) +{ + return g_object_new (CC_TYPE_APPLICATION, + "application-id", "org.gnome.ControlCenter", + "flags", G_APPLICATION_HANDLES_COMMAND_LINE, + NULL); +} + +CcShellModel * +cc_application_get_model (CcApplication *self) +{ + g_return_val_if_fail (CC_IS_APPLICATION (self), NULL); + + return self->model; +} diff --git a/shell/cc-application.h b/shell/cc-application.h new file mode 100644 index 0000000..e9c8b60 --- /dev/null +++ b/shell/cc-application.h @@ -0,0 +1,36 @@ +/* + * Copyright © 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, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + * 02110-1301, USA. + */ + +#pragma once + +#include "cc-shell-model.h" + +#include <gtk/gtk.h> + +G_BEGIN_DECLS + +#define CC_TYPE_APPLICATION (cc_application_get_type()) + +G_DECLARE_FINAL_TYPE (CcApplication, cc_application, CC, APPLICATION, GtkApplication) + +GtkApplication *cc_application_new (void); + +CcShellModel *cc_application_get_model (CcApplication *self); + +G_END_DECLS diff --git a/shell/cc-debug.h.in b/shell/cc-debug.h.in new file mode 100644 index 0000000..226f82e --- /dev/null +++ b/shell/cc-debug.h.in @@ -0,0 +1,229 @@ +/* cc-debug.h.in + * + * Copyright © 2018 Georges Basile Stavracas Neto <georges.stavracas@gmail.com> + * + * 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> + +/** + * SECTION:cc-debug + * @short_description: Debugging macros + * @title:Debugging + * @stability:stable + * + * Macros used for tracing and debugging code. These + * are only valid when Settings is compiled with tracing + * suppoer (pass `--enable-tracing` to the configure + * script to do that). + */ + +G_BEGIN_DECLS + +#ifndef CC_ENABLE_TRACE +# define CC_ENABLE_TRACE @ENABLE_TRACING@ +#endif +#if CC_ENABLE_TRACE != 1 +# undef CC_ENABLE_TRACE +#endif + +/** + * CC_LOG_LEVEL_TRACE: (skip) + */ +#ifndef CC_LOG_LEVEL_TRACE +# define CC_LOG_LEVEL_TRACE ((GLogLevelFlags)(1 << G_LOG_LEVEL_USER_SHIFT)) +#endif + +#ifdef CC_ENABLE_TRACE + +/** + * CC_TRACE_MSG: + * @fmt: printf-like format of the message + * @...: arguments for @fmt + * + * Prints a trace message. + */ +# define CC_TRACE_MSG(fmt, ...) \ + g_log(G_LOG_DOMAIN, CC_LOG_LEVEL_TRACE, " MSG: %s():%d: " fmt, \ + G_STRFUNC, __LINE__, ##__VA_ARGS__) + +/** + * CC_PROBE: + * + * Prints a probing message. Put this macro in the code when + * you want to check the program reaches a certain section + * of code. + */ +# define CC_PROBE \ + g_log(G_LOG_DOMAIN, CC_LOG_LEVEL_TRACE, "PROBE: %s():%d", \ + G_STRFUNC, __LINE__) + +/** + * CC_TODO: + * @_msg: the message to print + * + * Prints a TODO message. + */ +# define CC_TODO(_msg) \ + g_log(G_LOG_DOMAIN, CC_LOG_LEVEL_TRACE, " TODO: %s():%d: %s", \ + G_STRFUNC, __LINE__, _msg) + +/** + * CC_ENTRY: + * + * Prints an entry message. This shouldn't be used in + * critical functions. Place this at the beggining of + * the function, before any assertion. + */ +# define CC_ENTRY \ + g_log(G_LOG_DOMAIN, CC_LOG_LEVEL_TRACE, "ENTRY: %s():%d", \ + G_STRFUNC, __LINE__) + +/** + * CC_EXIT: + * + * Prints an exit message. This shouldn't be used in + * critical functions. Place this at the end of + * the function, after any relevant code. If the + * function returns something, use CC_RETURN() + * instead. + */ +# define CC_EXIT \ + G_STMT_START { \ + g_log(G_LOG_DOMAIN, CC_LOG_LEVEL_TRACE, " EXIT: %s():%d", \ + G_STRFUNC, __LINE__); \ + return; \ + } G_STMT_END + +/** + * CC_GOTO: + * @_l: goto tag + * + * Logs a goto jump. + */ +# define CC_GOTO(_l) \ + G_STMT_START { \ + g_log(G_LOG_DOMAIN, CC_LOG_LEVEL_TRACE, " GOTO: %s():%d ("#_l")",\ + G_STRFUNC, __LINE__); \ + goto _l; \ + } G_STMT_END + +/** + * CC_RETURN: + * @_r: the return value. + * + * Prints an exit message, and returns @_r. See #CC_EXIT. + */ +# define CC_RETURN(_r) \ + G_STMT_START { \ + g_log(G_LOG_DOMAIN, CC_LOG_LEVEL_TRACE, " EXIT: %s():%d ", \ + G_STRFUNC, __LINE__); \ + return _r; \ + } G_STMT_END + +#else + +/** + * CC_TODO: + * @_msg: the message to print + * + * Prints a TODO message. + */ +# define CC_TODO(_msg) + +/** + * CC_PROBE: + * + * Prints a probing message. + */ +# define CC_PROBE + +/** + * CC_TRACE_MSG: + * @fmt: printf-like format of the message + * @...: arguments for @fmt + * + * Prints a trace message. + */ +# define CC_TRACE_MSG(fmt, ...) + +/** + * CC_ENTRY: + * + * Prints a probing message. This shouldn't be used in + * critical functions. Place this at the beggining of + * the function, before any assertion. + */ +# define CC_ENTRY + +/** + * CC_GOTO: + * @_l: goto tag + * + * Logs a goto jump. + */ +# define CC_GOTO(_l) goto _l + +/** + * CC_EXIT: + * + * Prints an exit message. This shouldn't be used in + * critical functions. Place this at the end of + * the function, after any relevant code. If the + * function returns somethin, use CC_RETURN() + * instead. + */ +# define CC_EXIT return + +/** + * CC_RETURN: + * @_r: the return value. + * + * Prints an exit message, and returns @_r. See #CC_EXIT. + */ +# define CC_RETURN(_r) return _r +#endif + +/** + * _CC_BUG: (skip) + */ +#define _CC_BUG(Component, Description, File, Line, Func, ...) \ + G_STMT_START { \ + g_printerr ("-----------------------------------------------------------------\n"); \ + g_printerr ("You've found a bug in Settings or one of its dependent libraries.\n"); \ + g_printerr ("Please help us help you by filing a bug report at:\n"); \ + g_printerr ("\n"); \ + g_printerr ("@BUGREPORT_URL@&component=%s\n", Component); \ + g_printerr ("\n"); \ + g_printerr ("%s:%d in function %s()\n", File, Line, Func); \ + g_printerr ("\n"); \ + g_printerr (Description"\n", ##__VA_ARGS__); \ + g_printerr ("-----------------------------------------------------------------\n"); \ + } G_STMT_END + +/** + * CC_BUG: + * @Component: the component + * @Description: the description + * @...: extra arguments + * + * Logs a bug-friendly message. + */ +#define CC_BUG(Component, Description, ...) \ + _CC_BUG(Component, Description, __FILE__, __LINE__, G_STRFUNC, ##__VA_ARGS__) + +G_END_DECLS diff --git a/shell/cc-log.c b/shell/cc-log.c new file mode 100644 index 0000000..dba4f5a --- /dev/null +++ b/shell/cc-log.c @@ -0,0 +1,101 @@ +/* cc-shell-log.c + * + * Copyright © 2018 Georges Basile Stavracas Neto <georges.stavracas@gmail.com> + * + * 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-debug.h" +#include "cc-log.h" + +#include <unistd.h> +#include <glib.h> + +G_LOCK_DEFINE_STATIC (channel_lock); + +GIOChannel *standard_channel = NULL; + +static const gchar* ignored_domains[] = +{ + "GdkPixbuf", + NULL +}; + +static const gchar * +log_level_str (GLogLevelFlags log_level) +{ + switch (((gulong)log_level & G_LOG_LEVEL_MASK)) + { + case G_LOG_LEVEL_ERROR: return " \033[1;31mERROR\033[0m"; + case G_LOG_LEVEL_CRITICAL: return "\033[1;35mCRITICAL\033[0m"; + case G_LOG_LEVEL_WARNING: return " \033[1;33mWARNING\033[0m"; + case G_LOG_LEVEL_MESSAGE: return " \033[1;34mMESSAGE\033[0m"; + case G_LOG_LEVEL_INFO: return " \033[1;32mINFO\033[0m"; + case G_LOG_LEVEL_DEBUG: return " \033[1;32mDEBUG\033[0m"; + case CC_LOG_LEVEL_TRACE: return " \033[1;36mTRACE\033[0m"; + default: return " UNKNOWN"; + } +} + +static void +log_handler (const gchar *domain, + GLogLevelFlags log_level, + const gchar *message, + gpointer user_data) +{ + g_autoptr(GDateTime) now = NULL; + const gchar *level; + g_autofree gchar *ftime = NULL; + g_autofree gchar *buffer = NULL; + + /* Skip ignored log domains */ + if (domain && g_strv_contains (ignored_domains, domain)) + return; + + level = log_level_str (log_level); + now = g_date_time_new_now_local (); + ftime = g_date_time_format (now, "%H:%M:%S"); + buffer = g_strdup_printf ("%s.%04d %24s: %s: %s\n", + ftime, + g_date_time_get_microsecond (now) / 1000, + domain, + level, + message); + + /* Safely write to the channel */ + G_LOCK (channel_lock); + + g_io_channel_write_chars (standard_channel, buffer, -1, NULL, NULL); + g_io_channel_flush (standard_channel, NULL); + + G_UNLOCK (channel_lock); +} + +void +cc_log_init (void) +{ + static gsize initialized = FALSE; + + if (g_once_init_enter (&initialized)) + { + standard_channel = g_io_channel_unix_new (STDOUT_FILENO); + + g_setenv ("G_MESSAGES_DEBUG", "all", TRUE); + + g_log_set_default_handler (log_handler, NULL); + + g_once_init_leave (&initialized, TRUE); + } +} + diff --git a/shell/cc-log.h b/shell/cc-log.h new file mode 100644 index 0000000..2d04c0b --- /dev/null +++ b/shell/cc-log.h @@ -0,0 +1,25 @@ +/* cc-log.h + * + * Copyright © 2018 Georges Basile Stavracas Neto <georges.stavracas@gmail.com> + * + * 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 + +void cc_log_init (void); + +G_END_DECLS diff --git a/shell/cc-object-storage.c b/shell/cc-object-storage.c new file mode 100644 index 0000000..f52ba59 --- /dev/null +++ b/shell/cc-object-storage.c @@ -0,0 +1,444 @@ +/* cc-object-storage.h + * + * Copyright 2018 Georges Basile Stavracas Neto <georges.stavracas@gmail.com> + * + * 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/>. + */ + +#define G_LOG_DOMAIN "cc-object-storage" + +#include "cc-object-storage.h" + +struct _CcObjectStorage +{ + GObject parent_instance; + + GHashTable *id_to_object; +}; + +G_DEFINE_TYPE (CcObjectStorage, cc_object_storage, G_TYPE_OBJECT) + +/* Singleton instance */ +static CcObjectStorage *_instance = NULL; + +/* GTask API to create a new D-Bus proxy */ +typedef struct +{ + GBusType bus_type; + GDBusProxyFlags flags; + gchar *name; + gchar *path; + gchar *interface; + gboolean cached; +} TaskData; + +static TaskData* +task_data_new (GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *path, + const gchar *interface) +{ + TaskData *data = g_slice_new (TaskData); + data->bus_type = bus_type; + data->flags =flags; + data->name = g_strdup (name); + data->path = g_strdup (path); + data->interface = g_strdup (interface); + data->cached = FALSE; + + return data; +} + +static void +task_data_free (TaskData *data) +{ + g_free (data->name); + g_free (data->path); + g_free (data->interface); + g_slice_free (TaskData, data); +} + +static void +create_dbus_proxy_in_thread_cb (GTask *task, + gpointer source_object, + gpointer task_data, + GCancellable *cancellable) +{ + g_autoptr(GDBusProxy) proxy = NULL; + g_autoptr(GError) local_error = NULL; + TaskData *data = task_data; + + proxy = g_dbus_proxy_new_for_bus_sync (data->bus_type, + data->flags, + NULL, + data->name, + data->path, + data->interface, + cancellable, + &local_error); + + if (local_error) + { + g_task_return_error (task, local_error); + return; + } + + g_task_return_pointer (task, g_object_ref (g_steal_pointer (&proxy)), g_object_unref); +} + +static void +cc_object_storage_finalize (GObject *object) +{ + CcObjectStorage *self = (CcObjectStorage *)object; + + g_debug ("Destroying cached objects"); + + g_clear_pointer (&self->id_to_object, g_hash_table_destroy); + + G_OBJECT_CLASS (cc_object_storage_parent_class)->finalize (object); +} + +static void +cc_object_storage_class_init (CcObjectStorageClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->finalize = cc_object_storage_finalize; +} + +static void +cc_object_storage_init (CcObjectStorage *self) +{ + self->id_to_object = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref); +} + +/** + * cc_object_storage_has_object: + * @key: the unique string identifier of the object + * + * Checks whether there is an object associated with @key. + * + * Returns: %TRUE if the object is stored, %FALSE otherwise. + */ +gboolean +cc_object_storage_has_object (const gchar *key) +{ + g_assert (CC_IS_OBJECT_STORAGE (_instance)); + g_assert (key != NULL); + + return g_hash_table_contains (_instance->id_to_object, key); +} + +/** + * cc_object_storage_add_object: + * @key: the unique string identifier of the object + * @object: (type GObject): the object to be stored + * + * Adds @object to the object storage. It is a programming error to try to + * add an object that was already added. + * + * @object must be a GObject. + * + * Always check if the object is stored with cc_object_storage_has_object() + * before calling this function. + */ +void +cc_object_storage_add_object (const gchar *key, + gpointer object) +{ + /* Trying to add an object that was already added is a hard error. Each + * object must be added once, and only once, over the entire lifetime + * of the application. + */ + g_assert (CC_IS_OBJECT_STORAGE (_instance)); + g_assert (key != NULL); + g_assert (G_IS_OBJECT (object)); + g_assert (!g_hash_table_contains (_instance->id_to_object, key)); + + g_debug ("Adding object %s (%s → %p) to the storage", + g_type_name (G_OBJECT_TYPE (object)), + key, + object); + + g_hash_table_insert (_instance->id_to_object, g_strdup (key), g_object_ref (object)); +} + +/** + * cc_object_storage_get_object: + * @key: the unique string identifier of the object + * + * Retrieves the object associated with @key. It is a programming error to + * try to retrieve an object before adding it. + * + * Always check if the object is stored with cc_object_storage_has_object() + * before calling this function. + * + * Returns: (transfer full): the GObject associated with @key. + */ +gpointer +cc_object_storage_get_object (const gchar *key) +{ + /* Trying to peek an object that was not yet added is a hard error. Users + * of this API need to first check if the object is available with + * cc_object_storage_has_object(). + */ + g_assert (CC_IS_OBJECT_STORAGE (_instance)); + g_assert (key != NULL); + g_assert (g_hash_table_contains (_instance->id_to_object, key)); + + return g_object_ref (g_hash_table_lookup (_instance->id_to_object, key)); +} + +/** + * cc_object_storage_create_dbus_proxy_sync: + * @name: the D-Bus name + * @flags: the D-Bus proxy flags + * @path: the D-Bus object path + * @interface: the D-Bus interface name + * @cancellable: (nullable): #GCancellable to cancel the operation + * @error: (nullable): return location for a #GError + * + * Synchronously create a #GDBusProxy with @name, @path and @interface, + * stores it in the cache, and returns the newly created proxy. + * + * If a proxy with that signature is already created, it will be used + * instead of creating a new one. + * + * Returns: (transfer full)(nullable): the new #GDBusProxy. + */ +gpointer +cc_object_storage_create_dbus_proxy_sync (GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *path, + const gchar *interface, + GCancellable *cancellable, + GError **error) +{ + g_autoptr(GDBusProxy) proxy = NULL; + g_autoptr(GError) local_error = NULL; + g_autofree gchar *key = NULL; + + g_assert (CC_IS_OBJECT_STORAGE (_instance)); + g_assert (name && *name); + g_assert (path && *path); + g_assert (interface && *interface); + g_assert (!error || !*error); + + key = g_strdup_printf ("CcObjectStorage::dbus-proxy(%s,%s,%s)", name, path, interface); + + g_debug ("Creating D-Bus proxy for %s", key); + + /* Check if a DBus proxy with that signature is already available; if it is, + * return that instead of a new one. + */ + if (g_hash_table_contains (_instance->id_to_object, key)) + return cc_object_storage_get_object (key); + + proxy = g_dbus_proxy_new_for_bus_sync (bus_type, + flags, + NULL, + name, + path, + interface, + cancellable, + &local_error); + + if (local_error) + { + g_propagate_error (error, g_steal_pointer (&local_error)); + return NULL; + } + + /* Store the newly created D-Bus proxy */ + cc_object_storage_add_object (key, proxy); + + return g_steal_pointer (&proxy); +} + + +/** + * cc_object_storage_create_dbus_proxy: + * @name: the D-Bus name + * @flags: the D-Bus proxy flags + * @path: the D-Bus object path + * @interface: the D-Bus interface name + * @cancellable: (nullable): #GCancellable to cancel the operation + * @callback: callback for when the async operation is finished + * @user_data: user data for @callback + * + * Asynchronously create a #GDBusProxy with @name, @path and @interface. + * + * If a proxy with that signature is already created, it will be used instead of + * creating a new one. + * + * It is a programming error to create the an identical proxy while asynchronously + * creating one. Not cancelling this operation will result in an assertion failure + * when calling cc_object_storage_create_dbus_proxy_finish(). + */ +void +cc_object_storage_create_dbus_proxy (GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *path, + const gchar *interface, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + g_autoptr(GTask) task = NULL; + g_autofree gchar *key = NULL; + TaskData *data = NULL; + + g_assert (CC_IS_OBJECT_STORAGE (_instance)); + g_assert (name && *name); + g_assert (path && *path); + g_assert (interface && *interface); + g_assert (!cancellable || G_IS_CANCELLABLE (cancellable)); + + data = task_data_new (bus_type, flags, name, path, interface); + + task = g_task_new (_instance, cancellable, callback, user_data); + g_task_set_source_tag (task, cc_object_storage_create_dbus_proxy); + g_task_set_task_data (task, data, (GDestroyNotify) task_data_free); + + /* Check if the D-Bus proxy is already created */ + key = g_strdup_printf ("CcObjectStorage::dbus-proxy(%s,%s,%s)", name, path, interface); + + g_debug ("Asynchronously creating D-Bus proxy for %s", key); + + if (g_hash_table_contains (_instance->id_to_object, key)) + { + /* Mark this GTask as already cached, so we can call the right assertions + * on the callback + * */ + data->cached = TRUE; + + g_debug ("Found in cache the D-Bus proxy %s", key); + + g_task_return_pointer (task, cc_object_storage_get_object (key), g_object_unref); + return; + } + + g_task_run_in_thread (task, create_dbus_proxy_in_thread_cb); +} + +/** + * cc_object_storage_create_dbus_proxy_finish: + * @result: + * @error: (nullable): return location for a #GError + * + * Finishes a D-Bus proxy creation started by cc_object_storage_create_dbus_proxy(). + * + * Synchronously create a #GDBusProxy with @name, @path and @interface, + * stores it in the cache, and returns the newly created proxy. + * + * If a proxy with that signature is already created, it will be used + * instead of creating a new one. + * + * Returns: (transfer full)(nullable): the new #GDBusProxy. + */ +gpointer +cc_object_storage_create_dbus_proxy_finish (GAsyncResult *result, + GError **error) +{ + g_autoptr(GDBusProxy) proxy = NULL; + g_autoptr(GError) local_error = NULL; + g_autofree gchar *key = NULL; + TaskData *task_data; + GTask *task; + + task = G_TASK (result); + + g_assert (task && G_TASK (result)); + g_assert (!error || !*error); + + task_data = g_task_get_task_data (task); + g_assert (task_data != NULL); + + key = g_strdup_printf ("CcObjectStorage::dbus-proxy(%s,%s,%s)", + task_data->name, + task_data->path, + task_data->interface); + + g_debug ("Finished creating D-Bus proxy for %s", key); + + /* Retrieve the newly created proxy */ + proxy = g_task_propagate_pointer (task, &local_error); + + /* If the proxy is not cached, do the normal caching routine */ + if (local_error) + { + g_propagate_error (error, g_steal_pointer (&local_error)); + return NULL; + } + + /* Either we have the object stored right when trying to create it - in which case, + * task_data->cached == TRUE and cc_object_storage_has_object (key) == TRUE - or we + * didn't have a cached proxy before, and we shouldn't have it now. + * + * This is to force consumers of this code to *never* try to create the same D-Bus + * proxy asynchronously multiple times. Trying to do so is considered a programming + * error. + */ + g_assert (task_data->cached == cc_object_storage_has_object (key)); + + /* If the proxy is already cached, destroy the newly created and used the cached proxy + * instead. + */ + if (cc_object_storage_has_object (key)) + return cc_object_storage_get_object (key); + + /* Store the newly created D-Bus proxy */ + cc_object_storage_add_object (key, proxy); + + return g_steal_pointer (&proxy); +} + +/** + * cc_object_storage_initialize: + * + * Initializes the single CcObjectStorage. This must be called only once, + * and before every other method of this object. + */ +void +cc_object_storage_initialize (void) +{ + g_assert (_instance == NULL); + + if (g_once_init_enter (&_instance)) + { + CcObjectStorage *instance = g_object_new (CC_TYPE_OBJECT_STORAGE, NULL); + + g_debug ("Initializing object storage"); + + g_once_init_leave (&_instance, instance); + } +} + +/** + * cc_object_storage_destroy: + * + * Destroys the instance of #CcObjectStorage. This must be called only + * once during the application lifetime. It is a programming error to + * call this function multiple times + */ +void +cc_object_storage_destroy (void) +{ + g_assert (_instance != NULL); + + g_clear_object (&_instance); +} diff --git a/shell/cc-object-storage.h b/shell/cc-object-storage.h new file mode 100644 index 0000000..efea0e2 --- /dev/null +++ b/shell/cc-object-storage.h @@ -0,0 +1,65 @@ +/* cc-object-storage.h + * + * Copyright 2018 Georges Basile Stavracas Neto <georges.stavracas@gmail.com> + * + * 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-object.h> +#include <gio/gio.h> + +G_BEGIN_DECLS + +/* Default storage keys */ +#define CC_OBJECT_NMCLIENT "CcObjectStorage::nm-client" + + +#define CC_TYPE_OBJECT_STORAGE (cc_object_storage_get_type()) + +G_DECLARE_FINAL_TYPE (CcObjectStorage, cc_object_storage, CC, OBJECT_STORAGE, GObject) + +gboolean cc_object_storage_has_object (const gchar *key); + +void cc_object_storage_add_object (const gchar *key, + gpointer object); + +gpointer cc_object_storage_get_object (const gchar *key); + +gpointer cc_object_storage_create_dbus_proxy_sync (GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *path, + const gchar *interface, + GCancellable *cancellable, + GError **error); + +void cc_object_storage_create_dbus_proxy (GBusType bus_type, + GDBusProxyFlags flags, + const gchar *name, + const gchar *path, + const gchar *interface, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); + +gpointer cc_object_storage_create_dbus_proxy_finish (GAsyncResult *result, + GError **error); + +void cc_object_storage_initialize (void); + +void cc_object_storage_destroy (void); + +G_END_DECLS diff --git a/shell/cc-panel-list.c b/shell/cc-panel-list.c new file mode 100644 index 0000000..d425067 --- /dev/null +++ b/shell/cc-panel-list.c @@ -0,0 +1,1112 @@ +/* cc-panel-list.c + * + * Copyright (C) 2016 Endless, 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/>. + * + * Author: Georges Basile Stavracas Neto <gbsneto@gnome.org> + */ + +#define G_LOG_DOMAIN "cc-panel-list" + +#include <string.h> + +#include "cc-debug.h" +#include "cc-panel-list.h" +#include "cc-util.h" + +typedef struct +{ + GtkWidget *row; + GtkWidget *description_label; + CcPanelCategory category; + gchar *id; + gchar *name; + gchar *description; + gchar **keywords; + CcPanelVisibility visibility; +} RowData; + +struct _CcPanelList +{ + GtkStack parent; + + GtkWidget *privacy_listbox; + GtkWidget *main_listbox; + GtkWidget *search_listbox; + + /* When clicking on Details or Devices row, show it + * automatically select the first panel of the list. + */ + gboolean autoselect_panel : 1; + + GtkListBoxRow *privacy_row; + + gchar *current_panel_id; + gchar *search_query; + + CcPanelListView previous_view; + CcPanelListView view; + GHashTable *id_to_data; + GHashTable *id_to_search_data; +}; + +G_DEFINE_TYPE (CcPanelList, cc_panel_list, GTK_TYPE_STACK) + +enum +{ + PROP_0, + PROP_SEARCH_MODE, + PROP_SEARCH_QUERY, + PROP_VIEW, + N_PROPS +}; + +enum +{ + SHOW_PANEL, + LAST_SIGNAL +}; + +static GParamSpec *properties [N_PROPS] = { NULL, }; +static gint signals [LAST_SIGNAL] = { 0, }; + +/* + * Auxiliary methods + */ +static GtkWidget* +get_widget_from_view (CcPanelList *self, + CcPanelListView view) +{ + switch (view) + { + case CC_PANEL_LIST_MAIN: + return self->main_listbox; + + case CC_PANEL_LIST_PRIVACY: + return self->privacy_listbox; + + case CC_PANEL_LIST_SEARCH: + return self->search_listbox; + + case CC_PANEL_LIST_WIDGET: + return gtk_stack_get_child_by_name (GTK_STACK (self), "custom-widget"); + + default: + return NULL; + } +} + +static GtkWidget * +get_listbox_from_category (CcPanelList *self, + CcPanelCategory category) +{ + + switch (category) + { + case CC_CATEGORY_PRIVACY: + return self->privacy_listbox; + break; + + default: + return self->main_listbox; + break; + } + + return NULL; +} + +static void +activate_row_below (CcPanelList *self, + RowData *data) +{ + GtkListBoxRow *next_row; + GtkListBox *listbox; + guint row_index; + + row_index = gtk_list_box_row_get_index (GTK_LIST_BOX_ROW (data->row)); + listbox = GTK_LIST_BOX (get_listbox_from_category (self, data->category)); + next_row = gtk_list_box_get_row_at_index (listbox, row_index + 1); + + /* Try the previous one if the current is invalid */ + if (!next_row) + next_row = gtk_list_box_get_row_at_index (listbox, row_index - 1); + + if (next_row) + g_signal_emit_by_name (next_row, "activate"); +} + +static CcPanelListView +get_view_from_listbox (CcPanelList *self, + GtkWidget *listbox) +{ + if (listbox == self->main_listbox) + return CC_PANEL_LIST_MAIN; + + if (listbox == self->privacy_listbox) + return CC_PANEL_LIST_PRIVACY; + + return CC_PANEL_LIST_SEARCH; +} + +static void +switch_to_view (CcPanelList *self, + CcPanelListView view) +{ + GtkWidget *visible_child; + gboolean should_crossfade; + + CC_ENTRY; + + if (self->view == view) + CC_RETURN (); + + CC_TRACE_MSG ("Switching to view: %d", view); + + self->previous_view = self->view; + self->view = view; + + /* + * When changing to or from the search view, the animation should + * be crossfade. Otherwise, it's the previous-forward movement. + */ + should_crossfade = view == CC_PANEL_LIST_SEARCH || + self->previous_view == CC_PANEL_LIST_SEARCH; + + gtk_stack_set_transition_type (GTK_STACK (self), + should_crossfade ? GTK_STACK_TRANSITION_TYPE_CROSSFADE : + GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT); + + visible_child = get_widget_from_view (self, view); + + gtk_stack_set_visible_child (GTK_STACK (self), visible_child); + + /* For non-search views, make sure the displayed panel matches the + * newly selected row + */ + if (self->autoselect_panel && + view != CC_PANEL_LIST_SEARCH && + self->previous_view != CC_PANEL_LIST_WIDGET) + { + cc_panel_list_activate (self); + } + + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_VIEW]); + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SEARCH_MODE]); + + CC_EXIT; +} + +static void +update_search (CcPanelList *self) +{ + /* + * Only change to the search view is there's a + * search query available. + */ + if (self->search_query && + g_utf8_strlen (self->search_query, -1) > 0) + { + if (self->view == CC_PANEL_LIST_MAIN) + switch_to_view (self, CC_PANEL_LIST_SEARCH); + } + else + { + if (self->view == CC_PANEL_LIST_SEARCH) + switch_to_view (self, self->previous_view); + } + + gtk_list_box_invalidate_filter (GTK_LIST_BOX (self->search_listbox)); + gtk_list_box_unselect_all (GTK_LIST_BOX (self->search_listbox)); +} + +static const gchar* +get_panel_id_from_row (CcPanelList *self, + GtkListBoxRow *row) +{ + + RowData *row_data; + + if (row == self->privacy_row) + return "privacy"; + + row_data = g_object_get_data (G_OBJECT (row), "data"); + + g_assert (row_data != NULL); + return row_data->id; +} + +/* + * RowData functions + */ +static void +row_data_free (RowData *data) +{ + g_strfreev (data->keywords); + g_free (data->description); + g_free (data->name); + g_free (data->id); + g_free (data); +} + +static RowData* +row_data_new (CcPanelCategory category, + const gchar *id, + const gchar *name, + const gchar *description, + const GStrv keywords, + const gchar *icon, + CcPanelVisibility visibility, + gboolean has_sidebar) +{ + GtkWidget *label, *grid, *image; + RowData *data; + + data = g_new0 (RowData, 1); + data->category = category; + data->row = gtk_list_box_row_new (); + data->id = g_strdup (id); + data->name = g_strdup (name); + data->description = g_strdup (description); + data->keywords = g_strdupv (keywords); + + /* Setup the row */ + grid = g_object_new (GTK_TYPE_GRID, + "visible", TRUE, + "hexpand", TRUE, + "border-width", 12, + "column-spacing", 12, + NULL); + + /* Icon */ + image = gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_BUTTON); + gtk_style_context_add_class (gtk_widget_get_style_context (image), "sidebar-icon"); + + gtk_grid_attach (GTK_GRID (grid), image, 0, 0, 1, 1); + + gtk_widget_show (image); + + /* Name label */ + label = g_object_new (GTK_TYPE_LABEL, + "label", name, + "visible", TRUE, + "xalign", 0.0, + "hexpand", TRUE, + NULL); + gtk_grid_attach (GTK_GRID (grid), label, 1, 0, 1, 1); + + /* Description label */ + label = g_object_new (GTK_TYPE_LABEL, + "label", description, + "visible", FALSE, + "xalign", 0.0, + "hexpand", TRUE, + NULL); + gtk_label_set_max_width_chars (GTK_LABEL (label), 25); + gtk_label_set_line_wrap (GTK_LABEL (label), TRUE); + + if (has_sidebar) + { + image = gtk_image_new_from_icon_name ("go-next-symbolic", GTK_ICON_SIZE_BUTTON); + gtk_style_context_add_class (gtk_widget_get_style_context (image), "sidebar-icon"); + gtk_grid_attach (GTK_GRID (grid), image, 2, 0, 1, 1); + gtk_widget_show (image); + } + + gtk_style_context_add_class (gtk_widget_get_style_context (label), "dim-label"); + gtk_grid_attach (GTK_GRID (grid), label, 1, 1, 1, 1); + + data->description_label = label; + + gtk_container_add (GTK_CONTAINER (data->row), grid); + gtk_widget_show (data->row); + + g_object_set_data_full (G_OBJECT (data->row), "data", data, (GDestroyNotify) row_data_free); + + data->visibility = visibility; + + return data; +} + +/* + * GtkListBox functions + */ +static gboolean +filter_func (GtkListBoxRow *row, + gpointer user_data) +{ + CcPanelList *self; + RowData *data; + g_autofree gchar *search_text = NULL; + g_autofree gchar *panel_text = NULL; + g_autofree gchar *panel_description = NULL; + gboolean retval = FALSE; + gint i; + + self = CC_PANEL_LIST (user_data); + data = g_object_get_data (G_OBJECT (row), "data"); + + if (!self->search_query) + return TRUE; + + panel_text = cc_util_normalize_casefold_and_unaccent (data->name); + search_text = cc_util_normalize_casefold_and_unaccent (self->search_query); + panel_description = cc_util_normalize_casefold_and_unaccent (data->description); + + g_strstrip (panel_text); + g_strstrip (search_text); + g_strstrip (panel_description); + + /* + * The description label is only visible when the search is + * happening. + */ + gtk_widget_set_visible (data->description_label, self->view == CC_PANEL_LIST_SEARCH); + + for (i = 0; !retval && data->keywords[i] != NULL; i++) + retval = (strstr (data->keywords[i], search_text) == data->keywords[i]); + + retval = retval || g_strstr_len (panel_text, -1, search_text) != NULL || + g_strstr_len (panel_description, -1, search_text) != NULL; + + return retval; +} + +static const gchar * const panel_order[] = { + /* Main page */ + "wifi", + "network", + "mobile-broadband", + "bluetooth", + "background", + "notifications", + "search", + "applications", + "privacy", + "online-accounts", + "sharing", + + /* Privacy page */ + "location", + "camera", + "microphone", + "thunderbolt", + "usage", + "lock", + "diagnostics", + + /* Devices page */ + "sound", + "power", + "display", + "mouse", + "keyboard", + "printers", + "removable-media", + "wacom", + "color", + + /* Details page */ + "region", + "universal-access", + "user-accounts", + "default-apps", + "reset-settings", + "datetime", + "info-overview", +}; + +static guint +get_panel_id_index (const gchar *panel_id) +{ + guint i; + + for (i = 0; i < G_N_ELEMENTS (panel_order); i++) + { + if (g_str_equal (panel_order[i], panel_id)) + return i; + } + + return 0; +} + +static gint +sort_function (GtkListBoxRow *a, + GtkListBoxRow *b, + gpointer user_data) +{ + CcPanelList *self = CC_PANEL_LIST (user_data); + const gchar *a_id, *b_id; + + a_id = get_panel_id_from_row (self, a); + b_id = get_panel_id_from_row (self, b); + + return get_panel_id_index (a_id) - get_panel_id_index (b_id); +} + +static gint +search_sort_function (GtkListBoxRow *a, + GtkListBoxRow *b, + gpointer user_data) +{ + CcPanelList *self; + RowData *a_data, *b_data; + g_autofree gchar *a_name = NULL; + g_autofree gchar *b_name = NULL; + g_autofree gchar *search = NULL; + gchar *a_strstr, *b_strstr; + gint a_distance, b_distance; + + self = CC_PANEL_LIST (user_data); + search = NULL; + a_data = g_object_get_data (G_OBJECT (a), "data"); + b_data = g_object_get_data (G_OBJECT (b), "data"); + + a_distance = b_distance = G_MAXINT; + + a_name = cc_util_normalize_casefold_and_unaccent (a_data->name); + b_name = cc_util_normalize_casefold_and_unaccent (b_data->name); + g_strstrip (a_name); + g_strstrip (b_name); + + if (self->search_query) + { + search = cc_util_normalize_casefold_and_unaccent (self->search_query); + g_strstrip (search); + } + + /* Default result for empty search */ + if (!search || g_utf8_strlen (search, -1) == 0) + return g_strcmp0 (a_name, b_name); + + a_strstr = g_strstr_len (a_name, -1, search); + b_strstr = g_strstr_len (b_name, -1, search); + + if (a_strstr) + a_distance = g_strstr_len (a_name, -1, search) - a_name; + + if (b_strstr) + b_distance = g_strstr_len (b_name, -1, search) - b_name; + + return a_distance - b_distance; +} + +static void +header_func (GtkListBoxRow *row, + GtkListBoxRow *before, + gpointer user_data) +{ + CcPanelList *self = CC_PANEL_LIST (user_data); + RowData *row_data, *before_data; + + if (!before) + return; + + if (row == self->privacy_row || before == self->privacy_row) + return; + + /* + * We can only retrieve the data after assuring that none + * of the rows are the Privacy row. + */ + row_data = g_object_get_data (G_OBJECT (row), "data"); + before_data = g_object_get_data (G_OBJECT (before), "data"); + + if (row_data->category != before_data->category) + { + GtkWidget *separator; + + separator = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL); + gtk_widget_set_hexpand (separator, TRUE); + gtk_widget_show (separator); + + gtk_list_box_row_set_header (row, separator); + } + else + { + gtk_list_box_row_set_header (row, NULL); + } +} + +/* + * Callbacks + */ +static void +row_activated_cb (GtkWidget *listbox, + GtkListBoxRow *row, + CcPanelList *self) +{ + RowData *data; + + if (row == self->privacy_row) + { + switch_to_view (self, CC_PANEL_LIST_PRIVACY); + goto out; + } + + /* + * When a panel is selected, the previous one should be + * unselected, except when it's search. + */ + if (listbox != self->search_listbox) + { + if (listbox != self->main_listbox) + gtk_list_box_unselect_all (GTK_LIST_BOX (self->main_listbox)); + + if (listbox != self->privacy_listbox) + gtk_list_box_unselect_all (GTK_LIST_BOX (self->privacy_listbox)); + } + + /* + * Since we're not sure that the activated row is in the + * current view, set the view here. + */ + switch_to_view (self, get_view_from_listbox (self, listbox)); + + data = g_object_get_data (G_OBJECT (row), "data"); + + /* If the activated row is relative to the current panel, and it has + * a custom widget, show the custom widget again. + */ + if (g_strcmp0 (data->id, self->current_panel_id) == 0 && + self->previous_view != CC_PANEL_LIST_SEARCH && + gtk_stack_get_child_by_name (GTK_STACK (self), "custom-widget") != NULL) + { + CC_TRACE_MSG ("Switching to panel widget"); + + switch_to_view (self, CC_PANEL_LIST_WIDGET); + } + + g_signal_emit (self, signals[SHOW_PANEL], 0, data->id); + +out: + /* After selecting the panel and eventually changing the view, reset the + * autoselect flag. If necessary, cc_panel_list_set_active_panel() will + * set it to FALSE again. + */ + self->autoselect_panel = TRUE; +} + +static void +search_row_activated_cb (GtkWidget *listbox, + GtkListBoxRow *row, + CcPanelList *self) +{ + GtkWidget *real_listbox; + RowData *data; + GList *children, *l; + + CC_ENTRY; + + data = g_object_get_data (G_OBJECT (row), "data"); + + if (data->category == CC_CATEGORY_PRIVACY) + real_listbox = self->privacy_listbox; + else + real_listbox = self->main_listbox; + + /* Select the correct row */ + children = gtk_container_get_children (GTK_CONTAINER (real_listbox)); + + for (l = children; l != NULL; l = l->next) + { + RowData *real_row_data; + + real_row_data = g_object_get_data (l->data, "data"); + + /* + * The main listbox has the Details & Devices rows, and neither + * of them contains "data", so we have to ensure we have valid + * data before going on. + */ + if (!real_row_data) + continue; + + if (g_strcmp0 (real_row_data->id, data->id) == 0) + { + GtkListBoxRow *real_row; + + real_row = GTK_LIST_BOX_ROW (real_row_data->row); + + gtk_list_box_select_row (GTK_LIST_BOX (real_listbox), real_row); + gtk_widget_grab_focus (GTK_WIDGET (real_row)); + + g_signal_emit_by_name (real_row, "activate"); + break; + } + } + + g_list_free (children); + + CC_EXIT; +} + +static void +cc_panel_list_finalize (GObject *object) +{ + CcPanelList *self = (CcPanelList *)object; + + g_clear_pointer (&self->search_query, g_free); + g_clear_pointer (&self->current_panel_id, g_free); + g_clear_pointer (&self->id_to_data, g_hash_table_destroy); + g_clear_pointer (&self->id_to_search_data, g_hash_table_destroy); + + G_OBJECT_CLASS (cc_panel_list_parent_class)->finalize (object); +} + +static void +cc_panel_list_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + CcPanelList *self = CC_PANEL_LIST (object); + + switch (prop_id) + { + case PROP_SEARCH_MODE: + g_value_set_boolean (value, self->view == CC_PANEL_LIST_SEARCH); + break; + + case PROP_SEARCH_QUERY: + g_value_set_string (value, self->search_query); + break; + + case PROP_VIEW: + g_value_set_int (value, self->view); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +cc_panel_list_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + CcPanelList *self = CC_PANEL_LIST (object); + + switch (prop_id) + { + case PROP_SEARCH_MODE: + update_search (self); + break; + + case PROP_SEARCH_QUERY: + cc_panel_list_set_search_query (self, g_value_get_string (value)); + break; + + case PROP_VIEW: + switch_to_view (self, g_value_get_int (value)); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + } +} + +static void +cc_panel_list_class_init (CcPanelListClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + + object_class->finalize = cc_panel_list_finalize; + object_class->get_property = cc_panel_list_get_property; + object_class->set_property = cc_panel_list_set_property; + + /** + * CcPanelList:show-panel: + * + * Emitted when a panel is selected. + */ + signals[SHOW_PANEL] = g_signal_new ("show-panel", + CC_TYPE_PANEL_LIST, + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, NULL, + G_TYPE_NONE, + 1, + G_TYPE_STRING); + + /** + * CcPanelList:search-mode: + * + * Whether the search is visible or not. + */ + properties[PROP_SEARCH_MODE] = g_param_spec_boolean ("search-mode", + "Search mode", + "Whether it's in search mode or not", + FALSE, + G_PARAM_READWRITE); + + /** + * CcPanelList:search-query: + * + * The search that is being applied to sidelist. + */ + properties[PROP_SEARCH_QUERY] = g_param_spec_string ("search-query", + "Search query", + "The current search query", + NULL, + G_PARAM_READWRITE); + + /** + * CcPanelList:view: + * + * The current view of the sidelist. + */ + properties[PROP_VIEW] = g_param_spec_int ("view", + "View", + "The current view of the sidelist", + CC_PANEL_LIST_MAIN, + CC_PANEL_LIST_SEARCH, + CC_PANEL_LIST_MAIN, + G_PARAM_READWRITE); + + g_object_class_install_properties (object_class, N_PROPS, properties); + + gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/ControlCenter/gtk/cc-panel-list.ui"); + + gtk_widget_class_bind_template_child (widget_class, CcPanelList, privacy_listbox); + gtk_widget_class_bind_template_child (widget_class, CcPanelList, privacy_row); + gtk_widget_class_bind_template_child (widget_class, CcPanelList, main_listbox); + gtk_widget_class_bind_template_child (widget_class, CcPanelList, search_listbox); + + gtk_widget_class_bind_template_callback (widget_class, row_activated_cb); + gtk_widget_class_bind_template_callback (widget_class, search_row_activated_cb); +} + +static void +cc_panel_list_init (CcPanelList *self) +{ + gtk_widget_init_template (GTK_WIDGET (self)); + + self->id_to_data = g_hash_table_new (g_str_hash, g_str_equal); + self->id_to_search_data = g_hash_table_new (g_str_hash, g_str_equal); + self->view = CC_PANEL_LIST_MAIN; + + gtk_list_box_set_sort_func (GTK_LIST_BOX (self->main_listbox), + sort_function, + self, + NULL); + + gtk_list_box_set_sort_func (GTK_LIST_BOX (self->privacy_listbox), + sort_function, + self, + NULL); + + gtk_list_box_set_header_func (GTK_LIST_BOX (self->main_listbox), + header_func, + self, + NULL); + + /* Search listbox */ + gtk_list_box_set_sort_func (GTK_LIST_BOX (self->search_listbox), + search_sort_function, + self, + NULL); + + gtk_list_box_set_filter_func (GTK_LIST_BOX (self->search_listbox), + filter_func, + self, + NULL); +} + +GtkWidget* +cc_panel_list_new (void) +{ + return g_object_new (CC_TYPE_PANEL_LIST, NULL); +} + +gboolean +cc_panel_list_activate (CcPanelList *self) +{ + GtkListBoxRow *row; + GtkWidget *listbox; + guint i = 0; + + CC_ENTRY; + + g_return_val_if_fail (CC_IS_PANEL_LIST (self), FALSE); + + listbox = get_widget_from_view (self, self->view); + if (!GTK_IS_LIST_BOX (listbox)) + CC_RETURN (FALSE); + + /* Select the first visible row */ + do + row = gtk_list_box_get_row_at_index (GTK_LIST_BOX (listbox), i++); + while (row && !gtk_widget_get_visible (GTK_WIDGET (row))); + + /* If the row is valid, activate it */ + if (row) + { + gtk_list_box_select_row (GTK_LIST_BOX (listbox), row); + gtk_widget_grab_focus (GTK_WIDGET (row)); + + g_signal_emit_by_name (row, "activate"); + } + + CC_RETURN (row != NULL); +} + +const gchar* +cc_panel_list_get_search_query (CcPanelList *self) +{ + g_return_val_if_fail (CC_IS_PANEL_LIST (self), NULL); + + return self->search_query; +} + +void +cc_panel_list_set_search_query (CcPanelList *self, + const gchar *search) +{ + g_return_if_fail (CC_IS_PANEL_LIST (self)); + + if (g_strcmp0 (self->search_query, search) != 0) + { + g_clear_pointer (&self->search_query, g_free); + self->search_query = g_strdup (search); + + update_search (self); + + g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SEARCH_QUERY]); + + gtk_list_box_invalidate_filter (GTK_LIST_BOX (self->search_listbox)); + gtk_list_box_invalidate_sort (GTK_LIST_BOX (self->search_listbox)); + } +} + +CcPanelListView +cc_panel_list_get_view (CcPanelList *self) +{ + g_return_val_if_fail (CC_IS_PANEL_LIST (self), -1); + + return self->view; +} + +void +cc_panel_list_go_previous (CcPanelList *self) +{ + CcPanelListView previous_view; + + g_return_if_fail (CC_IS_PANEL_LIST (self)); + + previous_view = self->previous_view; + + /* The back button is only visible and clickable outside the main view. If + * the previous view is the widget view itself, it means we went from: + * + * Main → Details or Devices → Widget + * + * to + * + * Main → Details or Devices + * + * A similar situation may happen with search. + * + * To avoid a loop (Details or Devices → Widget → Details or Devices → ...), + * make sure to go back to the main view when the current view is details or + * devices. + */ + if (previous_view == CC_PANEL_LIST_WIDGET || previous_view == CC_PANEL_LIST_SEARCH) + previous_view = CC_PANEL_LIST_MAIN; + + switch_to_view (self, previous_view); +} + +void +cc_panel_list_add_panel (CcPanelList *self, + CcPanelCategory category, + const gchar *id, + const gchar *title, + const gchar *description, + const GStrv keywords, + const gchar *icon, + CcPanelVisibility visibility, + gboolean has_sidebar) +{ + GtkWidget *listbox; + RowData *data, *search_data; + + g_return_if_fail (CC_IS_PANEL_LIST (self)); + + /* Add the panel to the proper listbox */ + data = row_data_new (category, id, title, description, keywords, icon, visibility, has_sidebar); + gtk_widget_set_visible (data->row, visibility == CC_PANEL_VISIBLE); + + listbox = get_listbox_from_category (self, category); + gtk_container_add (GTK_CONTAINER (listbox), data->row); + + /* And add to the search listbox too */ + search_data = row_data_new (category, id, title, description, keywords, icon, visibility, has_sidebar); + gtk_widget_set_visible (search_data->row, visibility != CC_PANEL_HIDDEN); + + gtk_container_add (GTK_CONTAINER (self->search_listbox), search_data->row); + + g_hash_table_insert (self->id_to_data, data->id, data); + g_hash_table_insert (self->id_to_search_data, search_data->id, search_data); + + /* Only show the Devices/Details rows when there's at least one panel */ + if (category == CC_CATEGORY_PRIVACY) + gtk_widget_show (GTK_WIDGET (self->privacy_row)); +} + +/** + * cc_panel_list_set_active_panel: + * @self: a #CcPanelList + * @id: the id of the panel to be activated + * + * Sets the current active panel. + */ +void +cc_panel_list_set_active_panel (CcPanelList *self, + const gchar *id) +{ + GtkWidget *listbox; + RowData *data; + + g_return_if_fail (CC_IS_PANEL_LIST (self)); + + data = g_hash_table_lookup (self->id_to_data, id); + + g_assert (data != NULL); + + /* Stop if row is supposed to be always hidden */ + if (data->visibility == CC_PANEL_HIDDEN) + { + g_debug ("Panel '%s' is always hidden, stopping.", id); + cc_panel_list_activate (self); + return; + } + + /* If the currently selected panel is not always visible, for example when + * the panel is only visible on search and we're temporarily seeing it, make + * sure to hide it after the user moves out. + */ + if (self->current_panel_id != NULL && g_strcmp0 (self->current_panel_id, id) != 0) + { + RowData *current_row_data; + + current_row_data = g_hash_table_lookup (self->id_to_data, self->current_panel_id); + + /* We cannot be showing a non-existent panel */ + g_assert (current_row_data != NULL); + + gtk_widget_set_visible (current_row_data->row, current_row_data->visibility == CC_PANEL_VISIBLE); + } + + listbox = gtk_widget_get_parent (data->row); + + /* The row might be hidden now, so make sure it's visible */ + gtk_widget_show (data->row); + + gtk_list_box_select_row (GTK_LIST_BOX (listbox), GTK_LIST_BOX_ROW (data->row)); + gtk_widget_grab_focus (data->row); + + /* When setting the active panel programatically, prevent from + * autoselecting the first panel of the new view. + */ + self->autoselect_panel = FALSE; + + if (self->view != CC_PANEL_LIST_WIDGET) + g_signal_emit_by_name (data->row, "activate"); + + /* Store the current panel id */ + g_clear_pointer (&self->current_panel_id, g_free); + self->current_panel_id = g_strdup (id); +} + +/** + * cc_panel_list_set_panel_visibility: + * @self: a #CcPanelList + * @id: the id of the panel + * @visibility: visibility of panel with @id + * + * Sets the visibility of panel with @id. @id must be a valid + * id with a corresponding panel. + */ +void +cc_panel_list_set_panel_visibility (CcPanelList *self, + const gchar *id, + CcPanelVisibility visibility) +{ + RowData *data, *search_data; + + g_return_if_fail (CC_IS_PANEL_LIST (self)); + + data = g_hash_table_lookup (self->id_to_data, id); + search_data = g_hash_table_lookup (self->id_to_search_data, id); + + g_assert (data != NULL); + g_assert (search_data != NULL); + + data->visibility = visibility; + + /* If this is the currently selected row, and the panel can't be displayed + * (i.e. visibility != VISIBLE), then select the next possible row */ + if (gtk_list_box_row_is_selected (GTK_LIST_BOX_ROW (data->row)) && + visibility != CC_PANEL_VISIBLE) + { + activate_row_below (self, data); + } + + gtk_widget_set_visible (data->row, visibility == CC_PANEL_VISIBLE); + gtk_widget_set_visible (search_data->row, visibility =! CC_PANEL_HIDDEN); +} + +void +cc_panel_list_add_sidebar_widget (CcPanelList *self, + GtkWidget *widget) +{ + g_return_if_fail (CC_IS_PANEL_LIST (self)); + + if (widget) + { + gtk_stack_add_named (GTK_STACK (self), widget, "custom-widget"); + switch_to_view (self, CC_PANEL_LIST_WIDGET); + } + else + { + widget = get_widget_from_view (self, CC_PANEL_LIST_WIDGET); + + if (widget) + gtk_container_remove (GTK_CONTAINER (self), widget); + } +} + +void +cc_panel_list_set_selection_mode (CcPanelList *self, + GtkSelectionMode selection_mode) +{ + g_return_if_fail (CC_IS_PANEL_LIST (self)); + + gtk_list_box_set_selection_mode (GTK_LIST_BOX (self->main_listbox), selection_mode); + + /* When selection mode changed, selection will be lost. So reselect */ + if (selection_mode == GTK_SELECTION_SINGLE && self->current_panel_id) + { + GtkWidget *listbox; + RowData *data; + + data = g_hash_table_lookup (self->id_to_data, self->current_panel_id); + listbox = gtk_widget_get_parent (data->row); + gtk_list_box_select_row (GTK_LIST_BOX (listbox), GTK_LIST_BOX_ROW (data->row)); + } +} + diff --git a/shell/cc-panel-list.h b/shell/cc-panel-list.h new file mode 100644 index 0000000..8d7324d --- /dev/null +++ b/shell/cc-panel-list.h @@ -0,0 +1,78 @@ +/* cc-panel-list.c + * + * Copyright (C) 2016 Endless, 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/>. + * + * Author: Georges Basile Stavracas Neto <gbsneto@gnome.org> + */ + +#pragma once + +#include <glib-object.h> + +#include "cc-panel.h" +#include "cc-shell-model.h" + +G_BEGIN_DECLS + +typedef enum +{ + CC_PANEL_LIST_MAIN, + CC_PANEL_LIST_PRIVACY, + CC_PANEL_LIST_WIDGET, + CC_PANEL_LIST_SEARCH +} CcPanelListView; + +#define CC_TYPE_PANEL_LIST (cc_panel_list_get_type()) + +G_DECLARE_FINAL_TYPE (CcPanelList, cc_panel_list, CC, PANEL_LIST, GtkStack) + +GtkWidget* cc_panel_list_new (void); + +gboolean cc_panel_list_activate (CcPanelList *self); + +const gchar* cc_panel_list_get_search_query (CcPanelList *self); + +void cc_panel_list_set_search_query (CcPanelList *self, + const gchar *search); + +CcPanelListView cc_panel_list_get_view (CcPanelList *self); + +void cc_panel_list_go_previous (CcPanelList *self); + +void cc_panel_list_add_panel (CcPanelList *self, + CcPanelCategory category, + const gchar *id, + const gchar *title, + const gchar *description, + const GStrv keywords, + const gchar *icon, + CcPanelVisibility visibility, + gboolean has_sidebar); + +void cc_panel_list_set_active_panel (CcPanelList *self, + const gchar *id); + +void cc_panel_list_set_panel_visibility (CcPanelList *self, + const gchar *id, + CcPanelVisibility visibility); + +void cc_panel_list_add_sidebar_widget (CcPanelList *self, + GtkWidget *widget); + +void cc_panel_list_set_selection_mode (CcPanelList *self, + GtkSelectionMode selection_mode); + +G_END_DECLS diff --git a/shell/cc-panel-list.ui b/shell/cc-panel-list.ui new file mode 100644 index 0000000..06ef5a4 --- /dev/null +++ b/shell/cc-panel-list.ui @@ -0,0 +1,147 @@ +<?xml version="1.0" encoding="UTF-8"?> +<interface> + <requires lib="gtk+" version="3.20"/> + <template class="CcPanelList" parent="GtkStack"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="vhomogeneous">False</property> + <property name="hhomogeneous">True</property> + <property name="transition_type">slide-left-right</property> + <child> + <object class="GtkListBox" id="main_listbox"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <signal name="row-activated" handler="row_activated_cb" object="CcPanelList" swapped="no" /> + <child> + <object class="GtkListBoxRow" id="privacy_row"> + <property name="visible">False</property> + <property name="can_focus">True</property> + <child> + <object class="GtkBox"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="border_width">12</property> + <property name="spacing">12</property> + <child> + <object class="GtkImage"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="icon_name">preferences-system-privacy-symbolic</property> + <style> + <class name="sidebar-icon" /> + </style> + </object> + <packing> + <property name="expand">False</property> + <property name="fill">True</property> + <property name="position">0</property> + </packing> + </child> + <child> + <object class="GtkLabel"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="hexpand">True</property> + <property name="label" translatable="yes">Privacy</property> + <property name="xalign">0</property> + </object> + <packing> + <property name="expand">False</property> + <property name="fill">True</property> + <property name="position">1</property> + </packing> + </child> + <child> + <object class="GtkImage"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="icon_name">go-next-symbolic</property> + <style> + <class name="sidebar-icon" /> + </style> + </object> + <packing> + <property name="expand">False</property> + <property name="fill">True</property> + <property name="position">2</property> + </packing> + </child> + </object> + </child> + </object> + </child> + </object> + <packing> + <property name="name">main</property> + </packing> + </child> + <child> + <object class="GtkListBox" id="privacy_listbox"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <signal name="row-activated" handler="row_activated_cb" object="CcPanelList" swapped="no" /> + </object> + <packing> + <property name="name">privacy</property> + <property name="position">1</property> + </packing> + </child> + <child> + <object class="GtkListBox" id="search_listbox"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <signal name="row-activated" handler="search_row_activated_cb" object="CcPanelList" swapped="no" /> + + <!-- Placeholder --> + <child type="placeholder"> + <object class="GtkBox" id="empty_search_placeholder"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="halign">center</property> + <property name="valign">center</property> + <property name="expand">True</property> + <property name="border_width">18</property> + <property name="orientation">vertical</property> + <property name="spacing">6</property> + <child> + <object class="GtkImage"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="pixel_size">64</property> + <property name="icon_name">edit-find-symbolic</property> + <style> + <class name="dim-label"/> + </style> + </object> + </child> + <child> + <object class="GtkLabel"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="label" translatable="yes">No results found</property> + <attributes> + <attribute name="weight" value="bold"/> + <attribute name="scale" value="1.44"/> + </attributes> + </object> + </child> + <child> + <object class="GtkLabel"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="label" translatable="yes">Try a different search</property> + <style> + <class name="dim-label"/> + </style> + </object> + </child> + </object> + </child> + </object> + <packing> + <property name="name">search</property> + <property name="position">3</property> + </packing> + </child> + </template> +</interface> diff --git a/shell/cc-panel-loader.c b/shell/cc-panel-loader.c new file mode 100644 index 0000000..f203843 --- /dev/null +++ b/shell/cc-panel-loader.c @@ -0,0 +1,316 @@ +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ +/* + * 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 + * + * Author: Thomas Wood <thos@gnome.org> + */ + +#include <config.h> + +#include <string.h> +#include <gio/gdesktopappinfo.h> +#include <glib/gi18n.h> + +#include "cc-panel.h" +#include "cc-panel-loader.h" + +#ifndef CC_PANEL_LOADER_NO_GTYPES + +/* Extension points */ +extern GType cc_applications_panel_get_type (void); +extern GType cc_background_panel_get_type (void); +#ifdef BUILD_BLUETOOTH +extern GType cc_bluetooth_panel_get_type (void); +#endif /* BUILD_BLUETOOTH */ +extern GType cc_color_panel_get_type (void); +extern GType cc_date_time_panel_get_type (void); +extern GType cc_default_apps_panel_get_type (void); +extern GType cc_display_panel_get_type (void); +extern GType cc_info_overview_panel_get_type (void); +extern GType cc_keyboard_panel_get_type (void); +extern GType cc_mouse_panel_get_type (void); +#ifdef BUILD_NETWORK +extern GType cc_network_panel_get_type (void); +extern GType cc_wifi_panel_get_type (void); +#endif /* BUILD_NETWORK */ +extern GType cc_notifications_panel_get_type (void); +extern GType cc_goa_panel_get_type (void); +extern GType cc_power_panel_get_type (void); +extern GType cc_printers_panel_get_type (void); +extern GType cc_region_panel_get_type (void); +extern GType cc_removable_media_panel_get_type (void); +extern GType cc_search_panel_get_type (void); +extern GType cc_sharing_panel_get_type (void); +extern GType cc_sound_panel_get_type (void); +#ifdef BUILD_THUNDERBOLT +extern GType cc_bolt_panel_get_type (void); +#endif /* BUILD_THUNDERBOLT */ +extern GType cc_ua_panel_get_type (void); +extern GType cc_user_panel_get_type (void); +#ifdef BUILD_WACOM +extern GType cc_wacom_panel_get_type (void); +#endif /* BUILD_WACOM */ +extern GType cc_location_panel_get_type (void); +extern GType cc_camera_panel_get_type (void); +extern GType cc_microphone_panel_get_type (void); +extern GType cc_usage_panel_get_type (void); +extern GType cc_lock_panel_get_type (void); +extern GType cc_diagnostics_panel_get_type (void); + +/* Static init functions */ +extern void cc_diagnostics_panel_static_init_func (void); +#ifdef BUILD_NETWORK +extern void cc_wifi_panel_static_init_func (void); +#endif /* BUILD_NETWORK */ +#ifdef BUILD_WACOM +extern void cc_wacom_panel_static_init_func (void); +#endif /* BUILD_WACOM */ + +#define PANEL_TYPE(name, get_type, init_func) { name, get_type, init_func } + +#else /* CC_PANEL_LOADER_NO_GTYPES */ + +#define PANEL_TYPE(name, get_type, init_func) { name } + +#endif + +static CcPanelLoaderVtable default_panels[] = +{ + PANEL_TYPE("applications", cc_applications_panel_get_type, NULL), + PANEL_TYPE("background", cc_background_panel_get_type, NULL), +#ifdef BUILD_BLUETOOTH + PANEL_TYPE("bluetooth", cc_bluetooth_panel_get_type, NULL), +#endif + PANEL_TYPE("camera", cc_camera_panel_get_type, NULL), + PANEL_TYPE("color", cc_color_panel_get_type, NULL), + PANEL_TYPE("datetime", cc_date_time_panel_get_type, NULL), + PANEL_TYPE("default-apps", cc_default_apps_panel_get_type, NULL), + PANEL_TYPE("diagnostics", cc_diagnostics_panel_get_type, cc_diagnostics_panel_static_init_func), + PANEL_TYPE("display", cc_display_panel_get_type, NULL), + PANEL_TYPE("info-overview", cc_info_overview_panel_get_type, NULL), + PANEL_TYPE("keyboard", cc_keyboard_panel_get_type, NULL), + PANEL_TYPE("location", cc_location_panel_get_type, NULL), + PANEL_TYPE("lock", cc_lock_panel_get_type, NULL), + PANEL_TYPE("microphone", cc_microphone_panel_get_type, NULL), + PANEL_TYPE("mouse", cc_mouse_panel_get_type, NULL), +#ifdef BUILD_NETWORK + PANEL_TYPE("network", cc_network_panel_get_type, NULL), + PANEL_TYPE("wifi", cc_wifi_panel_get_type, cc_wifi_panel_static_init_func), +#endif + PANEL_TYPE("notifications", cc_notifications_panel_get_type, NULL), + PANEL_TYPE("online-accounts", cc_goa_panel_get_type, NULL), + PANEL_TYPE("power", cc_power_panel_get_type, NULL), + PANEL_TYPE("printers", cc_printers_panel_get_type, NULL), + PANEL_TYPE("region", cc_region_panel_get_type, NULL), + PANEL_TYPE("removable-media", cc_removable_media_panel_get_type, NULL), + PANEL_TYPE("search", cc_search_panel_get_type, NULL), + PANEL_TYPE("sharing", cc_sharing_panel_get_type, NULL), + PANEL_TYPE("sound", cc_sound_panel_get_type, NULL), +#ifdef BUILD_THUNDERBOLT + PANEL_TYPE("thunderbolt", cc_bolt_panel_get_type, NULL), +#endif + PANEL_TYPE("universal-access", cc_ua_panel_get_type, NULL), + PANEL_TYPE("usage", cc_usage_panel_get_type, NULL), + PANEL_TYPE("user-accounts", cc_user_panel_get_type, NULL), +#ifdef BUILD_WACOM + PANEL_TYPE("wacom", cc_wacom_panel_get_type, cc_wacom_panel_static_init_func), +#endif +}; + +/* Override for the panel vtable. When NULL, the default_panels will + * be used. + */ +static CcPanelLoaderVtable *panels_vtable = default_panels; +static gsize panels_vtable_len = G_N_ELEMENTS (default_panels); + + +static int +parse_categories (GDesktopAppInfo *app) +{ + g_auto(GStrv) split = NULL; + const gchar *categories; + gint retval; + + categories = g_desktop_app_info_get_categories (app); + split = g_strsplit (categories, ";", -1); + + retval = -1; + +#define const_strv(s) ((const gchar* const*) s) + + if (g_strv_contains (const_strv (split), "X-GNOME-ConnectivitySettings")) + retval = CC_CATEGORY_CONNECTIVITY; + else if (g_strv_contains (const_strv (split), "X-GNOME-PersonalizationSettings")) + retval = CC_CATEGORY_PERSONALIZATION; + else if (g_strv_contains (const_strv (split), "X-GNOME-AccountSettings")) + retval = CC_CATEGORY_ACCOUNT; + else if (g_strv_contains (const_strv (split), "X-GNOME-DevicesSettings")) + retval = CC_CATEGORY_DEVICES; + else if (g_strv_contains (const_strv (split), "X-GNOME-DetailsSettings")) + retval = CC_CATEGORY_DETAILS; + else if (g_strv_contains (const_strv (split), "X-GNOME-PrivacySettings")) + retval = CC_CATEGORY_PRIVACY; + else if (g_strv_contains (const_strv (split), "HardwareSettings")) + retval = CC_CATEGORY_HARDWARE; + +#undef const_strv + + if (retval < 0) + { + g_warning ("Invalid categories %s for panel %s", + categories, g_app_info_get_id (G_APP_INFO (app))); + } + + return retval; +} + +#ifndef CC_PANEL_LOADER_NO_GTYPES + +static GHashTable *panel_types; + +static void +ensure_panel_types (void) +{ + int i; + + if (G_LIKELY (panel_types != NULL)) + return; + + panel_types = g_hash_table_new (g_str_hash, g_str_equal); + for (i = 0; i < panels_vtable_len; i++) + g_hash_table_insert (panel_types, (char*)panels_vtable[i].name, panels_vtable[i].get_type); +} + +/** + * cc_panel_loader_load_by_name: + * @shell: a #CcShell implementation + * @name: name of the panel + * @parameters: parameters passed to the new panel + * + * Creates a new instance of a #CcPanel from @name, and sets the + * @shell and @parameters properties at construction time. + */ +CcPanel * +cc_panel_loader_load_by_name (CcShell *shell, + const gchar *name, + GVariant *parameters) +{ + GType (*get_type) (void); + + ensure_panel_types (); + + get_type = g_hash_table_lookup (panel_types, name); + g_assert (get_type != NULL); + + return g_object_new (get_type (), + "shell", shell, + "parameters", parameters, + NULL); +} + +#endif /* CC_PANEL_LOADER_NO_GTYPES */ + +/** + * cc_panel_loader_fill_model: + * @model: a #CcShellModel + * + * Fills @model with information from the available panels. It + * iterates over the panel vtable, gathering the panel names, + * build the desktop filename from it, and retrieves additional + * information from it. + */ +void +cc_panel_loader_fill_model (CcShellModel *model) +{ + guint i; + + for (i = 0; i < panels_vtable_len; i++) + { + g_autoptr(GDesktopAppInfo) app = NULL; + g_autofree gchar *desktop_name = NULL; + gint category; + + desktop_name = g_strconcat ("gnome-", panels_vtable[i].name, "-panel.desktop", NULL); + app = g_desktop_app_info_new (desktop_name); + + if (!app) + { + g_warning ("Ignoring broken panel %s (missing desktop file)", panels_vtable[i].name); + continue; + } + + category = parse_categories (app); + if (G_UNLIKELY (category < 0)) + continue; + + cc_shell_model_add_item (model, category, G_APP_INFO (app), panels_vtable[i].name); + } + + /* If there's an static init function, execute it after adding all panels to + * the model. This will allow the panels to show or hide themselves without + * having an instance running. + */ +#ifndef CC_PANEL_LOADER_NO_GTYPES + for (i = 0; i < panels_vtable_len; i++) + { + if (panels_vtable[i].static_init_func) + panels_vtable[i].static_init_func (); + } +#endif +} + +/** + * cc_panel_loader_list_panels: + * + * Prints the list of panels from the current panel vtable, + * usually as response to running GNOME Settings with the + * '--list' command line argument. + */ +void +cc_panel_loader_list_panels (void) +{ + guint i; + + g_print ("%s\n", _("Available panels:")); + + for (i = 0; i < panels_vtable_len; i++) + g_print ("\t%s\n", panels_vtable[i].name); + +} + +/** + * cc_panel_loader_override_vtable: + * @override_vtable: the new panel vtable + * @n_elements: number of items of @override_vtable + * + * Override the default panel vtable so that GNOME Settings loads + * a custom set of panels. Intended to be used by tests to inject + * panels that exercise specific interactions with CcWindow (e.g. + * header widgets, permissions, etc). + */ +void +cc_panel_loader_override_vtable (CcPanelLoaderVtable *override_vtable, + gsize n_elements) +{ + g_assert (override_vtable != NULL); + g_assert (n_elements > 0); + + g_debug ("Overriding default panel vtable"); + + panels_vtable = override_vtable; + panels_vtable_len = n_elements; +} diff --git a/shell/cc-panel-loader.h b/shell/cc-panel-loader.h new file mode 100644 index 0000000..1b91832 --- /dev/null +++ b/shell/cc-panel-loader.h @@ -0,0 +1,52 @@ +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ +/* + * 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 "config.h" + +#include <glib.h> +#include <glib-object.h> +#include <shell/cc-panel.h> +#include <shell/cc-shell-model.h> + +G_BEGIN_DECLS + +typedef struct +{ + const gchar *name; + +#ifndef CC_PANEL_LOADER_NO_GTYPES + GType (*get_type)(void); + CcPanelStaticInitFunc static_init_func; +#endif +} CcPanelLoaderVtable; + +void cc_panel_loader_fill_model (CcShellModel *model); +void cc_panel_loader_list_panels (void); +CcPanel *cc_panel_loader_load_by_name (CcShell *shell, + const char *name, + GVariant *parameters); + +void cc_panel_loader_override_vtable (CcPanelLoaderVtable *override_vtable, + gsize n_elements); + +G_END_DECLS + diff --git a/shell/cc-panel.c b/shell/cc-panel.c new file mode 100644 index 0000000..df9a7f3 --- /dev/null +++ b/shell/cc-panel.c @@ -0,0 +1,257 @@ +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- + * + * Copyright (C) 2010 Red Hat, Inc. + * Copyright (C) 2010 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/>. + * + * Authors: William Jon McCann <jmccann@redhat.com> + * Thomas Wood <thomas.wood@intel.com> + * + */ + +/** + * SECTION:cc-panel + * @short_description: An abstract class for Control Center panels + * + * CcPanel is an abstract class used to implement panels for the shell. A + * panel contains a collection of related settings that are displayed within + * the shell window. + */ + +#include "config.h" + +#include "cc-panel.h" + +#include <stdlib.h> +#include <stdio.h> + +#include <gtk/gtk.h> +#include <gio/gio.h> + +typedef struct +{ + CcShell *shell; + GCancellable *cancellable; +} CcPanelPrivate; + +G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (CcPanel, cc_panel, GTK_TYPE_BIN) + +enum +{ + SIDEBAR_ACTIVATED, + LAST_SIGNAL +}; + +enum +{ + PROP_0, + PROP_SHELL, + PROP_PARAMETERS, + N_PROPS +}; + +static GParamSpec *properties [N_PROPS]; + +static guint signals [LAST_SIGNAL] = { 0 }; + +static void +cc_panel_set_property (GObject *object, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + CcPanelPrivate *priv = cc_panel_get_instance_private (CC_PANEL (object)); + + switch (prop_id) + { + case PROP_SHELL: + /* construct only property */ + priv->shell = g_value_get_object (value); + break; + + case PROP_PARAMETERS: + { + g_autoptr(GVariant) v = NULL; + GVariant *parameters; + gsize n_parameters; + + parameters = g_value_get_variant (value); + + if (parameters == NULL) + return; + + n_parameters = g_variant_n_children (parameters); + if (n_parameters == 0) + return; + + g_variant_get_child (parameters, 0, "v", &v); + + if (!g_variant_is_of_type (v, G_VARIANT_TYPE_DICTIONARY)) + g_warning ("Wrong type for the first argument GVariant, expected 'a{sv}' but got '%s'", + (gchar *)g_variant_get_type (v)); + else if (g_variant_n_children (v) > 0) + g_warning ("Ignoring additional flags"); + + if (n_parameters > 1) + g_warning ("Ignoring additional parameters"); + + break; + } + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +cc_panel_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + CcPanelPrivate *priv = cc_panel_get_instance_private (CC_PANEL (object)); + + switch (prop_id) + { + case PROP_SHELL: + g_value_set_object (value, priv->shell); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); + break; + } +} + +static void +cc_panel_finalize (GObject *object) +{ + CcPanelPrivate *priv = cc_panel_get_instance_private (CC_PANEL (object)); + + g_cancellable_cancel (priv->cancellable); + g_clear_object (&priv->cancellable); + + G_OBJECT_CLASS (cc_panel_parent_class)->finalize (object); +} + +static void +cc_panel_class_init (CcPanelClass *klass) +{ + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->get_property = cc_panel_get_property; + object_class->set_property = cc_panel_set_property; + object_class->finalize = cc_panel_finalize; + + signals[SIDEBAR_ACTIVATED] = g_signal_new ("sidebar-activated", + G_TYPE_FROM_CLASS (object_class), + G_SIGNAL_RUN_LAST, + 0, NULL, NULL, + g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + properties[PROP_SHELL] = g_param_spec_object ("shell", + "Shell", + "Shell the Panel resides in", + CC_TYPE_SHELL, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS); + + properties[PROP_PARAMETERS] = g_param_spec_variant ("parameters", + "Structured parameters", + "Additional parameters passed externally (ie. command line, D-Bus activation)", + G_VARIANT_TYPE ("av"), + NULL, + G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS); + + g_object_class_install_properties (object_class, N_PROPS, properties); +} + +static void +cc_panel_init (CcPanel *panel) +{ +} + +/** + * cc_panel_get_shell: + * @panel: A #CcPanel + * + * Get the shell that the panel resides in + * + * Returns: a #CcShell + */ +CcShell * +cc_panel_get_shell (CcPanel *panel) +{ + CcPanelPrivate *priv; + + g_return_val_if_fail (CC_IS_PANEL (panel), NULL); + + priv = cc_panel_get_instance_private (panel); + + return priv->shell; +} + +const gchar* +cc_panel_get_help_uri (CcPanel *panel) +{ + CcPanelClass *class = CC_PANEL_GET_CLASS (panel); + + if (class->get_help_uri) + return class->get_help_uri (panel); + + return NULL; +} + +GtkWidget * +cc_panel_get_title_widget (CcPanel *panel) +{ + CcPanelClass *class = CC_PANEL_GET_CLASS (panel); + + if (class->get_title_widget) + return class->get_title_widget (panel); + + return NULL; +} + +GtkWidget* +cc_panel_get_sidebar_widget (CcPanel *panel) +{ + CcPanelClass *class = CC_PANEL_GET_CLASS (panel); + + if (class->get_sidebar_widget) + { + GtkWidget *sidebar_widget; + + sidebar_widget = class->get_sidebar_widget (panel); + g_assert (sidebar_widget != NULL); + + return sidebar_widget; + } + + return NULL; +} + +GCancellable * +cc_panel_get_cancellable (CcPanel *panel) +{ + CcPanelPrivate *priv = cc_panel_get_instance_private (panel); + + g_return_val_if_fail (CC_IS_PANEL (panel), NULL); + + if (priv->cancellable == NULL) + priv->cancellable = g_cancellable_new (); + + return priv->cancellable; +} diff --git a/shell/cc-panel.h b/shell/cc-panel.h new file mode 100644 index 0000000..35cb9c4 --- /dev/null +++ b/shell/cc-panel.h @@ -0,0 +1,100 @@ +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- + * + * Copyright (C) 2010 Red Hat, Inc. + * Copyright (C) 2010 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/>. + * + * Authors: William Jon McCann <jmccann@redhat.com> + * Thomas Wood <thomas.wood@intel.com> + */ + +#pragma once + +#include <glib-object.h> +#include <gtk/gtk.h> + +/** + * Utility macro used to register panels + * + * use: CC_PANEL_REGISTER (PluginName, plugin_name) + */ +#define CC_PANEL_REGISTER(PluginName, plugin_name) G_DEFINE_TYPE (PluginName, plugin_name, CC_TYPE_PANEL) + +/** + * CcPanelStaticInitFunc: + * + * Function that statically allocates resources and initializes + * any data that the panel will make use of during runtime. + * + * If panels represent hardware that can potentially not exist, + * e.g. the Wi-Fi panel, these panels can use this function to + * show or hide themselves without needing to have an instance + * created and running. + */ +typedef void (*CcPanelStaticInitFunc) (void); + + +#define CC_TYPE_PANEL (cc_panel_get_type()) +G_DECLARE_DERIVABLE_TYPE (CcPanel, cc_panel, CC, PANEL, GtkBin) + +/** + * CcPanelVisibility: + * + * @CC_PANEL_HIDDEN: Panel is hidden from search and sidebar, and not reachable. + * @CC_PANEL_VISIBLE_IN_SEARCH: Panel is hidden from main view, but can be accessed from search. + * @CC_PANEL_VISIBLE: Panel is visible everywhere. + */ +typedef enum +{ + CC_PANEL_HIDDEN, + CC_PANEL_VISIBLE_IN_SEARCH, + CC_PANEL_VISIBLE, +} CcPanelVisibility; + +/* cc-shell.h requires CcPanel, so make sure it is defined first */ +#include "cc-shell.h" + +G_BEGIN_DECLS + +/** + * CcPanelClass: + * + * The contents of this struct are private and should not be accessed directly. + */ +struct _CcPanelClass +{ + /*< private >*/ + GtkBinClass parent_class; + + const gchar* (*get_help_uri) (CcPanel *panel); + + GtkWidget* (*get_title_widget) (CcPanel *panel); + GtkWidget* (*get_sidebar_widget) (CcPanel *panel); +}; + +CcShell* cc_panel_get_shell (CcPanel *panel); + +GPermission* cc_panel_get_permission (CcPanel *panel); + +const gchar* cc_panel_get_help_uri (CcPanel *panel); + +GtkWidget* cc_panel_get_title_widget (CcPanel *panel); + +GtkWidget* cc_panel_get_sidebar_widget (CcPanel *panel); + +GCancellable *cc_panel_get_cancellable (CcPanel *panel); + +G_END_DECLS + diff --git a/shell/cc-shell-model.c b/shell/cc-shell-model.c new file mode 100644 index 0000000..19fc9c6 --- /dev/null +++ b/shell/cc-shell-model.c @@ -0,0 +1,422 @@ +/* + * Copyright (c) 2009, 2010 Intel, Inc. + * Copyright (c) 2010 Red Hat, Inc. + * + * 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 + * + * Author: Thomas Wood <thos@gnome.org> + */ + +#include "cc-shell-model.h" +#include "cc-util.h" + +#include <string.h> + +#include <gio/gdesktopappinfo.h> + +#define GNOME_SETTINGS_PANEL_ID_KEY "X-GNOME-Settings-Panel" +#define GNOME_SETTINGS_PANEL_CATEGORY GNOME_SETTINGS_PANEL_ID_KEY +#define GNOME_SETTINGS_PANEL_ID_KEYWORDS "Keywords" + +struct _CcShellModel +{ + GtkListStore parent; + + GStrv sort_terms; +}; + +G_DEFINE_TYPE (CcShellModel, cc_shell_model, GTK_TYPE_LIST_STORE) + +static gint +sort_by_name (GtkTreeModel *model, + GtkTreeIter *a, + GtkTreeIter *b) +{ + g_autofree gchar *a_name = NULL; + g_autofree gchar *b_name = NULL; + + gtk_tree_model_get (model, a, COL_CASEFOLDED_NAME, &a_name, -1); + gtk_tree_model_get (model, b, COL_CASEFOLDED_NAME, &b_name, -1); + + return g_strcmp0 (a_name, b_name); +} + +static gint +sort_by_name_with_terms (GtkTreeModel *model, + GtkTreeIter *a, + GtkTreeIter *b, + gchar **terms) +{ + gboolean a_match, b_match; + g_autofree gchar *a_name = NULL; + g_autofree gchar *b_name = NULL; + gint i; + + gtk_tree_model_get (model, a, COL_CASEFOLDED_NAME, &a_name, -1); + gtk_tree_model_get (model, b, COL_CASEFOLDED_NAME, &b_name, -1); + + for (i = 0; terms[i]; ++i) + { + a_match = strstr (a_name, terms[i]) != NULL; + b_match = strstr (b_name, terms[i]) != NULL; + + if (a_match && !b_match) + return -1; + else if (!a_match && b_match) + return 1; + } + + return 0; +} + +static gint +count_matches (gchar **keywords, + gchar **terms) +{ + gint i, j, c; + + if (!keywords || !terms) + return 0; + + c = 0; + + for (i = 0; terms[i]; ++i) + for (j = 0; keywords[j]; ++j) + if (strstr (keywords[j], terms[i])) + c += 1; + + return c; +} + +static gint +sort_by_keywords_with_terms (GtkTreeModel *model, + GtkTreeIter *a, + GtkTreeIter *b, + gchar **terms) +{ + gint a_matches, b_matches; + g_auto(GStrv) a_keywords = NULL; + g_auto(GStrv) b_keywords = NULL; + + gtk_tree_model_get (model, a, COL_KEYWORDS, &a_keywords, -1); + gtk_tree_model_get (model, b, COL_KEYWORDS, &b_keywords, -1); + + a_matches = count_matches (a_keywords, terms); + b_matches = count_matches (b_keywords, terms); + + if (a_matches > b_matches) + return -1; + else if (a_matches < b_matches) + return 1; + + return 0; +} + +static gint +sort_by_description_with_terms (GtkTreeModel *model, + GtkTreeIter *a, + GtkTreeIter *b, + gchar **terms) +{ + gint a_matches, b_matches; + g_autofree gchar *a_description = NULL; + g_autofree gchar *b_description = NULL; + g_auto(GStrv) a_description_split = NULL; + g_auto(GStrv) b_description_split = NULL; + + gtk_tree_model_get (model, a, COL_DESCRIPTION, &a_description, -1); + gtk_tree_model_get (model, b, COL_DESCRIPTION, &b_description, -1); + + if (a_description && !b_description) + return -1; + else if (!a_description && b_description) + return 1; + else if (!a_description && !b_description) + return 0; + + a_description_split = g_strsplit (a_description, " ", -1); + b_description_split = g_strsplit (b_description, " ", -1); + + a_matches = count_matches (a_description_split, terms); + b_matches = count_matches (b_description_split, terms); + + if (a_matches > b_matches) + return -1; + else if (a_matches < b_matches) + return 1; + + return 0; +} + +static gint +sort_with_terms (GtkTreeModel *model, + GtkTreeIter *a, + GtkTreeIter *b, + gchar **terms) +{ + gint rval; + + rval = sort_by_name_with_terms (model, a, b, terms); + if (rval) + return rval; + + rval = sort_by_keywords_with_terms (model, a, b, terms); + if (rval) + return rval; + + rval = sort_by_description_with_terms (model, a, b, terms); + if (rval) + return rval; + + return sort_by_name (model, a, b); +} + +static gint +cc_shell_model_sort_func (GtkTreeModel *model, + GtkTreeIter *a, + GtkTreeIter *b, + gpointer data) +{ + CcShellModel *self = data; + + if (!self->sort_terms || !self->sort_terms[0]) + return sort_by_name (model, a, b); + else + return sort_with_terms (model, a, b, self->sort_terms); +} + +static void +cc_shell_model_finalize (GObject *object) +{ + CcShellModel *self = CC_SHELL_MODEL (object); + + g_clear_pointer (&self->sort_terms, g_strfreev); + + G_OBJECT_CLASS (cc_shell_model_parent_class)->finalize (object); +} + +static void +cc_shell_model_class_init (CcShellModelClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + gobject_class->finalize = cc_shell_model_finalize; +} + +static void +cc_shell_model_init (CcShellModel *self) +{ + GType types[] = {G_TYPE_STRING, G_TYPE_STRING, G_TYPE_APP_INFO, G_TYPE_STRING, G_TYPE_UINT, + G_TYPE_STRING, G_TYPE_STRING, G_TYPE_ICON, G_TYPE_STRV, G_TYPE_UINT, G_TYPE_BOOLEAN }; + + gtk_list_store_set_column_types (GTK_LIST_STORE (self), + N_COLS, types); + + gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (self), + cc_shell_model_sort_func, + self, NULL); + gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (self), + GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, + GTK_SORT_ASCENDING); +} + +CcShellModel * +cc_shell_model_new (void) +{ + return g_object_new (CC_TYPE_SHELL_MODEL, NULL); +} + +static char ** +get_casefolded_keywords (GAppInfo *appinfo) +{ + const char * const * keywords; + char **casefolded_keywords; + int i, n; + + keywords = g_desktop_app_info_get_keywords (G_DESKTOP_APP_INFO (appinfo)); + n = keywords ? g_strv_length ((char**) keywords) : 0; + casefolded_keywords = g_new (char*, n+1); + + for (i = 0; i < n; i++) + casefolded_keywords[i] = cc_util_normalize_casefold_and_unaccent (keywords[i]); + casefolded_keywords[n] = NULL; + + return casefolded_keywords; +} + +static GIcon * +symbolicize_g_icon (GIcon *gicon) +{ + const gchar * const *names; + g_autofree gchar *new_name = NULL; + + if (!G_IS_THEMED_ICON (gicon)) + return g_object_ref (gicon); + + names = g_themed_icon_get_names (G_THEMED_ICON (gicon)); + + if (g_str_has_suffix (names[0], "-symbolic")) + return g_object_ref (gicon); + + new_name = g_strdup_printf ("%s-symbolic", names[0]); + return g_themed_icon_new_with_default_fallbacks (new_name); +} + +void +cc_shell_model_add_item (CcShellModel *model, + CcPanelCategory category, + GAppInfo *appinfo, + const char *id) +{ + g_autoptr(GIcon) icon = NULL; + const gchar *name = g_app_info_get_name (appinfo); + const gchar *comment = g_app_info_get_description (appinfo); + g_auto(GStrv) keywords = NULL; + g_autofree gchar *casefolded_name = NULL; + g_autofree gchar *casefolded_description = NULL; + gboolean has_sidebar; + + casefolded_name = cc_util_normalize_casefold_and_unaccent (name); + casefolded_description = cc_util_normalize_casefold_and_unaccent (comment); + keywords = get_casefolded_keywords (appinfo); + icon = symbolicize_g_icon (g_app_info_get_icon (appinfo)); + has_sidebar = g_desktop_app_info_get_boolean (G_DESKTOP_APP_INFO (appinfo), "X-GNOME-ControlCenter-HasSidebar"); + + gtk_list_store_insert_with_values (GTK_LIST_STORE (model), NULL, 0, + COL_NAME, name, + COL_CASEFOLDED_NAME, casefolded_name, + COL_APP, appinfo, + COL_ID, id, + COL_CATEGORY, category, + COL_DESCRIPTION, comment, + COL_CASEFOLDED_DESCRIPTION, casefolded_description, + COL_GICON, icon, + COL_KEYWORDS, keywords, + COL_VISIBILITY, CC_PANEL_VISIBLE, + COL_HAS_SIDEBAR, has_sidebar, + -1); +} + +gboolean +cc_shell_model_has_panel (CcShellModel *model, + const char *id) +{ + GtkTreeIter iter; + gboolean valid; + + g_assert (id); + + valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter); + while (valid) + { + g_autofree gchar *panel_id = NULL; + + gtk_tree_model_get (GTK_TREE_MODEL (model), &iter, COL_ID, &panel_id, -1); + if (g_str_equal (id, panel_id)) + return TRUE; + + valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (model), &iter); + } + + return FALSE; +} + +gboolean +cc_shell_model_iter_matches_search (CcShellModel *model, + GtkTreeIter *iter, + const char *term) +{ + g_autofree gchar *name = NULL; + g_autofree gchar *description = NULL; + gboolean result; + g_auto(GStrv) keywords = NULL; + + gtk_tree_model_get (GTK_TREE_MODEL (model), iter, + COL_CASEFOLDED_NAME, &name, + COL_CASEFOLDED_DESCRIPTION, &description, + COL_KEYWORDS, &keywords, + -1); + + result = (strstr (name, term) != NULL); + + if (!result && description) + result = (strstr (description, term) != NULL); + + if (!result && keywords) + { + gint i; + + for (i = 0; !result && keywords[i]; i++) + result = (strstr (keywords[i], term) == keywords[i]); + } + + return result; +} + +void +cc_shell_model_set_sort_terms (CcShellModel *self, + gchar **terms) +{ + g_return_if_fail (CC_IS_SHELL_MODEL (self)); + + g_clear_pointer (&self->sort_terms, g_strfreev); + self->sort_terms = g_strdupv (terms); + + /* trigger a re-sort */ + gtk_tree_sortable_set_default_sort_func (GTK_TREE_SORTABLE (self), + cc_shell_model_sort_func, + self, + NULL); +} + +void +cc_shell_model_set_panel_visibility (CcShellModel *self, + const gchar *id, + CcPanelVisibility visibility) +{ + GtkTreeModel *model; + GtkTreeIter iter; + gboolean valid; + + g_return_if_fail (CC_IS_SHELL_MODEL (self)); + + model = GTK_TREE_MODEL (self); + + /* Find the iter for the panel with the given id */ + valid = gtk_tree_model_get_iter_first (model, &iter); + + while (valid) + { + g_autofree gchar *item_id = NULL; + + gtk_tree_model_get (model, &iter, COL_ID, &item_id, -1); + + /* Found the iter */ + if (g_str_equal (id, item_id)) + break; + + /* If not found, continue */ + valid = gtk_tree_model_iter_next (model, &iter); + } + + /* If we don't find any panel with the given id, we'll iterate until + * valid == FALSE, so we can use this variable to determine if the + * panel was found or not. It is a programming error to try to set + * the visibility of a non-existent panel. + */ + g_assert (valid); + + gtk_list_store_set (GTK_LIST_STORE (self), &iter, COL_VISIBILITY, visibility, -1); +} diff --git a/shell/cc-shell-model.h b/shell/cc-shell-model.h new file mode 100644 index 0000000..763803e --- /dev/null +++ b/shell/cc-shell-model.h @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2010 Intel, Inc. + * + * 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 + * + * Author: Thomas Wood <thos@gnome.org> + */ + +#pragma once + +#include "cc-panel.h" + +#include <gtk/gtk.h> + +G_BEGIN_DECLS + +#define CC_TYPE_SHELL_MODEL cc_shell_model_get_type() + +G_DECLARE_FINAL_TYPE (CcShellModel, cc_shell_model, CC, SHELL_MODEL, GtkListStore) + +typedef enum +{ + CC_CATEGORY_CONNECTIVITY, + CC_CATEGORY_PERSONALIZATION, + CC_CATEGORY_ACCOUNT, + CC_CATEGORY_HARDWARE, + CC_CATEGORY_PRIVACY, + CC_CATEGORY_DEVICES, + CC_CATEGORY_DETAILS, + CC_CATEGORY_LAST +} CcPanelCategory; + +enum +{ + COL_NAME, + COL_CASEFOLDED_NAME, + COL_APP, + COL_ID, + COL_CATEGORY, + COL_DESCRIPTION, + COL_CASEFOLDED_DESCRIPTION, + COL_GICON, + COL_KEYWORDS, + COL_VISIBILITY, + COL_HAS_SIDEBAR, + + N_COLS +}; + + +CcShellModel* cc_shell_model_new (void); + +void cc_shell_model_add_item (CcShellModel *model, + CcPanelCategory category, + GAppInfo *appinfo, + const char *id); + +gboolean cc_shell_model_has_panel (CcShellModel *model, + const char *id); + +gboolean cc_shell_model_iter_matches_search (CcShellModel *model, + GtkTreeIter *iter, + const char *term); + +void cc_shell_model_set_sort_terms (CcShellModel *model, + GStrv terms); + +void cc_shell_model_set_panel_visibility (CcShellModel *self, + const gchar *id, + CcPanelVisibility visible); + +G_END_DECLS diff --git a/shell/cc-shell.c b/shell/cc-shell.c new file mode 100644 index 0000000..ffab0a6 --- /dev/null +++ b/shell/cc-shell.c @@ -0,0 +1,175 @@ +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- + * + * Copyright (c) 2010 Intel, Inc. + * + * 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 + * + * Author: Thomas Wood <thos@gnome.org> + */ + +/** + * SECTION:cc-shell + * @short_description: Interface representing the Control Center shell + * + * CcShell is an interface that represents an instance of a control + * center shell. It provides access to some of the properties of the shell + * that panels will need to read or change. When a panel is created it has an + * instance of CcShell available that represents the current shell. + */ + + +#include "cc-shell.h" +#include "cc-panel.h" + +G_DEFINE_INTERFACE (CcShell, cc_shell, GTK_TYPE_WIDGET) + +static void +cc_shell_default_init (CcShellInterface *iface) +{ + g_object_interface_install_property (iface, + g_param_spec_object ("active-panel", + "active panel", + "The currently active Panel", + CC_TYPE_PANEL, + G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); +} + +/** + * cc_shell_get_active_panel: + * @shell: A #CcShell + * + * Get the current active panel + * + * Returns: a #CcPanel or NULL if no panel is active + */ +CcPanel * +cc_shell_get_active_panel (CcShell *shell) +{ + CcPanel *panel = NULL; + + g_return_val_if_fail (CC_IS_SHELL (shell), NULL); + + g_object_get (shell, "active-panel", &panel, NULL); + + return panel; +} + +/** + * cc_shell_set_active_panel: + * @shell: A #CcShell + * @panel: A #CcPanel + * + * Set the current active panel. If @panel is NULL, then the shell is returned + * to a state where no panel is being displayed (for example, the list of panels + * may be shown instead). + * + */ +void +cc_shell_set_active_panel (CcShell *shell, + CcPanel *panel) +{ + g_return_if_fail (CC_IS_SHELL (shell)); + g_return_if_fail (panel == NULL || CC_IS_PANEL (panel)); + + g_object_set (shell, "active-panel", panel, NULL); +} + +/** + * cc_shell_set_active_panel_from_id: + * @shell: A #CcShell + * @id: The ID of the panel to set as active + * @parameters: A #GVariant with additional parameters + * @error: A #GError + * + * Find a panel corresponding to the specified id and set it as active. + * + * Returns: #TRUE if the panel was found and set as the active panel + */ +gboolean +cc_shell_set_active_panel_from_id (CcShell *shell, + const gchar *id, + GVariant *parameters, + GError **error) +{ + CcShellInterface *iface; + + g_return_val_if_fail (CC_IS_SHELL (shell), FALSE); + + iface = CC_SHELL_GET_IFACE (shell); + + if (!iface->set_active_panel_from_id) + { + g_warning ("Object of type \"%s\" does not implement required interface" + " method \"set_active_panel_from_id\",", + G_OBJECT_TYPE_NAME (shell)); + return FALSE; + } + else + { + return iface->set_active_panel_from_id (shell, id, parameters, error); + } +} + +/** + * cc_shell_get_toplevel: + * @shell: A #CcShell + * + * Gets the toplevel window of the shell. + * + * Returns: The #GtkWidget of the shell window, or #NULL on error. + */ +GtkWidget * +cc_shell_get_toplevel (CcShell *shell) +{ + CcShellInterface *iface; + + g_return_val_if_fail (CC_IS_SHELL (shell), NULL); + + iface = CC_SHELL_GET_IFACE (shell); + + if (iface->get_toplevel) + { + return iface->get_toplevel (shell); + } + + g_warning ("Object of type \"%s\" does not implement required interface" + " method \"get_toplevel\",", + G_OBJECT_TYPE_NAME (shell)); + + return NULL; +} + +void +cc_shell_embed_widget_in_header (CcShell *shell, + GtkWidget *widget, + GtkPositionType position) +{ + CcShellInterface *iface; + + g_return_if_fail (CC_IS_SHELL (shell)); + + iface = CC_SHELL_GET_IFACE (shell); + + if (!iface->embed_widget_in_header) + { + g_warning ("Object of type \"%s\" does not implement required interface" + " method \"embed_widget_in_header\",", + G_OBJECT_TYPE_NAME (shell)); + } + else + { + iface->embed_widget_in_header (shell, widget, position); + } +} diff --git a/shell/cc-shell.h b/shell/cc-shell.h new file mode 100644 index 0000000..f5d35db --- /dev/null +++ b/shell/cc-shell.h @@ -0,0 +1,77 @@ +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- + * + * Copyright (c) 2010 Intel, Inc. + * + * 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 + * + * Author: Thomas Wood <thos@gnome.org> + */ + +#pragma once + +#include <gtk/gtk.h> + +G_BEGIN_DECLS + +#define CC_TYPE_SHELL (cc_shell_get_type()) +#define CC_SHELL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CC_TYPE_SHELL, CcShell)) +#define CC_IS_SHELL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CC_TYPE_SHELL)) +#define CC_SHELL_GET_IFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), CC_TYPE_SHELL, CcShellInterface)) + +#define CC_SHELL_PANEL_EXTENSION_POINT "control-center-1" + +typedef struct _CcShell CcShell; +typedef struct _CcShellInterface CcShellInterface; + +/* cc-panel.h requires CcShell, so make sure they are defined first */ +#include "cc-panel.h" + +/** + * CcShellInterface: + * @set_active_panel_from_id: virtual function to set the active panel from an + * id string + * + */ +struct _CcShellInterface +{ + GTypeInterface g_iface; + + /* methods */ + gboolean (*set_active_panel_from_id) (CcShell *shell, + const gchar *id, + GVariant *parameters, + GError **error); + GtkWidget * (*get_toplevel) (CcShell *shell); + void (*embed_widget_in_header) (CcShell *shell, + GtkWidget *widget, + GtkPositionType position); +}; + +GType cc_shell_get_type (void) G_GNUC_CONST; + +CcPanel * cc_shell_get_active_panel (CcShell *shell); +void cc_shell_set_active_panel (CcShell *shell, + CcPanel *panel); +gboolean cc_shell_set_active_panel_from_id (CcShell *shell, + const gchar *id, + GVariant *parameters, + GError **error); +GtkWidget * cc_shell_get_toplevel (CcShell *shell); + +void cc_shell_embed_widget_in_header (CcShell *shell, + GtkWidget *widget, + GtkPositionType position); + +G_END_DECLS diff --git a/shell/cc-window.c b/shell/cc-window.c new file mode 100644 index 0000000..400c391 --- /dev/null +++ b/shell/cc-window.c @@ -0,0 +1,948 @@ +/* + * Copyright (c) 2009, 2010 Intel, Inc. + * Copyright (c) 2010 Red Hat, Inc. + * Copyright (c) 2016 Endless, Inc. + * + * 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 + * + * Author: Thomas Wood <thos@gnome.org> + */ + +#define G_LOG_DOMAIN "cc-window" + +#include <config.h> + +#include "cc-debug.h" +#include "cc-window.h" + +#include <glib/gi18n.h> +#include <gio/gio.h> +#include <gio/gdesktopappinfo.h> +#include <gtk/gtk.h> +#include <gdk/gdkkeysyms.h> +#include <gdk/gdkx.h> +#include <handy.h> +#include <string.h> +#include <time.h> + +#include "cc-application.h" +#include "cc-panel.h" +#include "cc-shell.h" +#include "cc-shell-model.h" +#include "cc-panel-list.h" +#include "cc-panel-loader.h" +#include "cc-util.h" + +#define MOUSE_BACK_BUTTON 8 + +#define DEFAULT_WINDOW_ICON_NAME "gnome-control-center" + +struct _CcWindow +{ + GtkApplicationWindow parent; + + GtkRevealer *back_revealer; + GtkMessageDialog *development_warning_dialog; + GtkHeaderBar *header; + HdyLeaflet *header_box; + GtkSizeGroup *header_sizegroup; + HdyLeaflet *main_leaflet; + GtkHeaderBar *panel_headerbar; + CcPanelList *panel_list; + GtkButton *previous_button; + GtkSearchBar *search_bar; + GtkToggleButton *search_button; + GtkSearchEntry *search_entry; + GtkBox *sidebar_box; + GtkStack *stack; + GtkBox *top_left_box; + GtkBox *top_right_box; + + GtkWidget *current_panel; + char *current_panel_id; + GQueue *previous_panels; + + GPtrArray *custom_widgets; + + CcShellModel *store; + + CcPanel *active_panel; + GSettings *settings; + + CcPanelListView previous_list_view; +}; + +static void cc_shell_iface_init (CcShellInterface *iface); + +G_DEFINE_TYPE_WITH_CODE (CcWindow, cc_window, GTK_TYPE_APPLICATION_WINDOW, + G_IMPLEMENT_INTERFACE (CC_TYPE_SHELL, cc_shell_iface_init)) + +enum +{ + PROP_0, + PROP_ACTIVE_PANEL, + PROP_MODEL +}; + +/* Auxiliary methods */ +static gboolean +in_flatpak_sandbox (void) +{ + return g_strcmp0 (PROFILE, "development") == 0; +} + +static void +remove_all_custom_widgets (CcWindow *self) +{ + GtkWidget *parent; + GtkWidget *widget; + guint i; + + CC_ENTRY; + + /* remove from the header */ + for (i = 0; i < self->custom_widgets->len; i++) + { + widget = g_ptr_array_index (self->custom_widgets, i); + parent = gtk_widget_get_parent (widget); + + g_assert (parent == GTK_WIDGET (self->top_right_box) || parent == GTK_WIDGET (self->top_left_box)); + gtk_container_remove (GTK_CONTAINER (parent), widget); + } + g_ptr_array_set_size (self->custom_widgets, 0); + + CC_EXIT; +} + +static void +show_panel (CcWindow *self) +{ + hdy_leaflet_set_visible_child (self->main_leaflet, GTK_WIDGET (self->stack)); + hdy_leaflet_set_visible_child (self->header_box, GTK_WIDGET (self->panel_headerbar)); +} + +static void +show_sidebar (CcWindow *self) +{ + hdy_leaflet_set_visible_child (self->main_leaflet, GTK_WIDGET (self->sidebar_box)); + hdy_leaflet_set_visible_child (self->header_box, GTK_WIDGET (self->header)); +} + +static void +on_sidebar_activated_cb (CcWindow *self) +{ + show_panel (self); +} + +static gboolean +activate_panel (CcWindow *self, + const gchar *id, + GVariant *parameters, + const gchar *name, + GIcon *gicon, + CcPanelVisibility visibility) +{ + g_autoptr(GTimer) timer = NULL; + GtkWidget *sidebar_widget; + GtkWidget *title_widget; + gdouble ellapsed_time; + + CC_ENTRY; + + if (!id) + CC_RETURN (FALSE); + + if (visibility == CC_PANEL_HIDDEN) + CC_RETURN (FALSE); + + /* clear any custom widgets */ + remove_all_custom_widgets (self); + + timer = g_timer_new (); + + g_settings_set_string (self->settings, "last-panel", id); + + /* Begin the profile */ + g_timer_start (timer); + + if (self->current_panel) + g_signal_handlers_disconnect_by_data (self->current_panel, self); + self->current_panel = GTK_WIDGET (cc_panel_loader_load_by_name (CC_SHELL (self), id, parameters)); + cc_shell_set_active_panel (CC_SHELL (self), CC_PANEL (self->current_panel)); + gtk_widget_show (self->current_panel); + + gtk_stack_add_named (self->stack, self->current_panel, id); + + /* switch to the new panel */ + gtk_widget_show (self->current_panel); + gtk_stack_set_visible_child_name (self->stack, id); + + /* set the title of the window */ + gtk_window_set_role (GTK_WINDOW (self), id); + gtk_header_bar_set_title (self->panel_headerbar, name); + + title_widget = cc_panel_get_title_widget (CC_PANEL (self->current_panel)); + gtk_header_bar_set_custom_title (self->panel_headerbar, title_widget); + + sidebar_widget = cc_panel_get_sidebar_widget (CC_PANEL (self->current_panel)); + cc_panel_list_add_sidebar_widget (self->panel_list, sidebar_widget); + /* Ensure we show the panel when the leaflet is folded and a sidebar widget's + * row is activated. + */ + g_signal_connect_object (self->current_panel, "sidebar-activated", G_CALLBACK (on_sidebar_activated_cb), self, G_CONNECT_SWAPPED); + + /* Finish profiling */ + g_timer_stop (timer); + + ellapsed_time = g_timer_elapsed (timer, NULL); + + g_debug ("Time to open panel '%s': %lfs", name, ellapsed_time); + + CC_RETURN (TRUE); +} + +static void +add_current_panel_to_history (CcWindow *self, + const char *start_id) +{ + g_return_if_fail (start_id != NULL); + + if (!self->current_panel_id || g_strcmp0 (self->current_panel_id, start_id) == 0) + return; + + g_queue_push_head (self->previous_panels, g_strdup (self->current_panel_id)); + g_debug ("Added '%s' to the previous panels", self->current_panel_id); +} + +static gboolean +find_iter_for_panel_id (CcWindow *self, + const gchar *panel_id, + GtkTreeIter *out_iter) +{ + GtkTreeIter iter; + gboolean valid; + + valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL (self->store), &iter); + + while (valid) + { + g_autofree gchar *id = NULL; + + gtk_tree_model_get (GTK_TREE_MODEL (self->store), + &iter, + COL_ID, &id, + -1); + + if (g_strcmp0 (id, panel_id) == 0) + break; + + valid = gtk_tree_model_iter_next (GTK_TREE_MODEL (self->store), &iter); + } + + g_assert (out_iter != NULL); + *out_iter = iter; + + return valid; +} + +static void +update_list_title (CcWindow *self) +{ + CcPanelListView view; + GtkTreeIter iter; + g_autofree gchar *title = NULL; + + CC_ENTRY; + + view = cc_panel_list_get_view (self->panel_list); + title = NULL; + + switch (view) + { + case CC_PANEL_LIST_PRIVACY: + title = g_strdup (_("Privacy")); + break; + + case CC_PANEL_LIST_MAIN: + title = g_strdup (_("Settings")); + break; + + case CC_PANEL_LIST_WIDGET: + find_iter_for_panel_id (self, self->current_panel_id, &iter); + gtk_tree_model_get (GTK_TREE_MODEL (self->store), + &iter, + COL_NAME, &title, + -1); + break; + + case CC_PANEL_LIST_SEARCH: + title = NULL; + break; + } + + if (title) + gtk_header_bar_set_title (self->header, title); + + CC_EXIT; +} + +static void +on_row_changed_cb (CcWindow *self, + GtkTreePath *path, + GtkTreeIter *iter, + GtkTreeModel *model) +{ + g_autofree gchar *id = NULL; + CcPanelVisibility visibility; + + gtk_tree_model_get (model, iter, + COL_ID, &id, + COL_VISIBILITY, &visibility, + -1); + + cc_panel_list_set_panel_visibility (self->panel_list, id, visibility); +} + +static void +setup_model (CcWindow *self) +{ + GtkTreeModel *model; + GtkTreeIter iter; + gboolean valid; + + /* CcApplication must have a valid model at this point */ + g_assert (self->store != NULL); + + model = GTK_TREE_MODEL (self->store); + + cc_panel_loader_fill_model (self->store); + + /* Create a row for each panel */ + valid = gtk_tree_model_get_iter_first (model, &iter); + + while (valid) + { + CcPanelCategory category; + g_autoptr(GIcon) icon = NULL; + g_autofree gchar *name = NULL; + g_autofree gchar *description = NULL; + g_autofree gchar *id = NULL; + g_auto(GStrv) keywords = NULL; + CcPanelVisibility visibility; + gboolean has_sidebar; + const gchar *icon_name = NULL; + + gtk_tree_model_get (model, &iter, + COL_CATEGORY, &category, + COL_DESCRIPTION, &description, + COL_GICON, &icon, + COL_ID, &id, + COL_NAME, &name, + COL_KEYWORDS, &keywords, + COL_VISIBILITY, &visibility, + COL_HAS_SIDEBAR, &has_sidebar, + -1); + + if (G_IS_THEMED_ICON (icon)) + icon_name = g_themed_icon_get_names (G_THEMED_ICON (icon))[0]; + + cc_panel_list_add_panel (self->panel_list, + category, + id, + name, + description, + keywords, + icon_name, + visibility, + has_sidebar); + + valid = gtk_tree_model_iter_next (model, &iter); + } + + /* React to visibility changes */ + g_signal_connect_object (model, "row-changed", G_CALLBACK (on_row_changed_cb), self, G_CONNECT_SWAPPED); +} + +static void +update_headerbar_buttons (CcWindow *self) +{ + gboolean is_main_view; + + CC_ENTRY; + + is_main_view = cc_panel_list_get_view (self->panel_list) == CC_PANEL_LIST_MAIN; + + gtk_widget_set_visible (GTK_WIDGET (self->previous_button), !is_main_view); + gtk_widget_set_visible (GTK_WIDGET (self->search_button), is_main_view); + + update_list_title (self); + + CC_EXIT; +} + +static gboolean +set_active_panel_from_id (CcWindow *self, + const gchar *start_id, + GVariant *parameters, + gboolean add_to_history, + gboolean force_moving_to_the_panel, + GError **error) +{ + g_autoptr(GIcon) gicon = NULL; + g_autofree gchar *name = NULL; + CcPanelVisibility visibility; + GtkTreeIter iter; + GtkWidget *old_panel; + CcPanelListView view; + gboolean activated; + gboolean found; + + CC_ENTRY; + + view = cc_panel_list_get_view (self->panel_list); + + /* When loading the same panel again, just set its parameters */ + if (g_strcmp0 (self->current_panel_id, start_id) == 0) + { + g_object_set (G_OBJECT (self->current_panel), "parameters", parameters, NULL); + if (force_moving_to_the_panel || self->previous_list_view == view) + show_panel (self); + self->previous_list_view = view; + CC_RETURN (TRUE); + } + + found = find_iter_for_panel_id (self, start_id, &iter); + if (!found) + { + g_warning ("Could not find settings panel \"%s\"", start_id); + CC_RETURN (TRUE); + } + + old_panel = self->current_panel; + + gtk_tree_model_get (GTK_TREE_MODEL (self->store), + &iter, + COL_NAME, &name, + COL_GICON, &gicon, + COL_VISIBILITY, &visibility, + -1); + + /* Activate the panel */ + activated = activate_panel (self, start_id, parameters, name, gicon, visibility); + + /* Failed to activate the panel for some reason, let's keep the old + * panel around instead */ + if (!activated) + { + g_debug ("Failed to activate panel"); + CC_RETURN (TRUE); + } + + if (add_to_history) + add_current_panel_to_history (self, start_id); + + if (force_moving_to_the_panel) + show_panel (self); + + g_free (self->current_panel_id); + self->current_panel_id = g_strdup (start_id); + + CC_TRACE_MSG ("Current panel id: %s", start_id); + + if (old_panel) + gtk_container_remove (GTK_CONTAINER (self->stack), old_panel); + + cc_panel_list_set_active_panel (self->panel_list, start_id); + + update_headerbar_buttons (self); + + CC_RETURN (TRUE); +} + +static void +set_active_panel (CcWindow *self, + CcPanel *panel) +{ + g_return_if_fail (CC_IS_SHELL (self)); + g_return_if_fail (panel == NULL || CC_IS_PANEL (panel)); + + if (panel != self->active_panel) + { + /* remove the old panel */ + g_clear_object (&self->active_panel); + + /* set the new panel */ + if (panel) + self->active_panel = g_object_ref (panel); + + g_object_notify (G_OBJECT (self), "active-panel"); + } +} + +static void +switch_to_previous_panel (CcWindow *self) +{ + g_autofree gchar *previous_panel_id = NULL; + + CC_ENTRY; + + if (g_queue_get_length (self->previous_panels) == 0) + CC_RETURN (); + + previous_panel_id = g_queue_pop_head (self->previous_panels); + + g_debug ("Going to previous panel (%s)", previous_panel_id); + + set_active_panel_from_id (self, previous_panel_id, NULL, FALSE, FALSE, NULL); + + CC_EXIT; +} + +/* Callbacks */ +static void +on_main_leaflet_folded_changed_cb (CcWindow *self) +{ + GtkSelectionMode selection_mode; + + g_assert (CC_IS_WINDOW (self)); + + selection_mode = GTK_SELECTION_SINGLE; + + if (hdy_leaflet_get_folded (self->main_leaflet)) + selection_mode = GTK_SELECTION_NONE; + + cc_panel_list_set_selection_mode (self->panel_list, selection_mode); +} + +static void +show_panel_cb (CcWindow *self, + const gchar *panel_id) +{ + if (!panel_id) + return; + + set_active_panel_from_id (self, panel_id, NULL, TRUE, FALSE, NULL); +} + +static void +search_entry_activate_cb (CcWindow *self) +{ + gboolean changed; + + changed = cc_panel_list_activate (self->panel_list); + + gtk_search_bar_set_search_mode (self->search_bar, !changed); +} + +static void +back_button_clicked_cb (CcWindow *self) +{ + show_sidebar (self); +} + +static void +previous_button_clicked_cb (CcWindow *self) +{ + g_debug ("Num previous panels? %d", g_queue_get_length (self->previous_panels)); + + /* When in search, simply unsed the search mode */ + if (gtk_search_bar_get_search_mode (self->search_bar)) + gtk_search_bar_set_search_mode (self->search_bar, FALSE); + else + cc_panel_list_go_previous (self->panel_list); + + update_headerbar_buttons (self); +} + +static void +gdk_window_set_cb (CcWindow *self) +{ + GdkWindow *window; + g_autofree gchar *str = NULL; + + if (!GDK_IS_X11_DISPLAY (gdk_display_get_default ())) + return; + + window = gtk_widget_get_window (GTK_WIDGET (self)); + + if (!window) + return; + + str = g_strdup_printf ("%u", (guint) GDK_WINDOW_XID (window)); + g_setenv ("GNOME_CONTROL_CENTER_XID", str, TRUE); +} + +static gboolean +window_map_event_cb (CcWindow *self) +{ + /* If focus ends up in a category icon view one of the items is + * immediately selected which looks odd when we are starting up, so + * we explicitly unset the focus here. */ + gtk_window_set_focus (GTK_WINDOW (self), NULL); + return GDK_EVENT_PROPAGATE; +} + +static gboolean +window_key_press_event_cb (CcWindow *self, + GdkEventKey *event) +{ + GdkModifierType state; + CcPanelListView view; + GdkKeymap *keymap; + gboolean retval; + gboolean is_rtl; + + retval = GDK_EVENT_PROPAGATE; + state = event->state; + keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (self))); + gdk_keymap_add_virtual_modifiers (keymap, &state); + + state = state & gtk_accelerator_get_default_mod_mask (); + is_rtl = gtk_widget_get_direction (GTK_WIDGET (self)) == GTK_TEXT_DIR_RTL; + view = cc_panel_list_get_view (self->panel_list); + + /* The search only happens when we're in the MAIN view */ + if (view == CC_PANEL_LIST_MAIN && + gtk_search_bar_handle_event (self->search_bar, (GdkEvent*) event) == GDK_EVENT_STOP) + { + return GDK_EVENT_STOP; + } + + if (state == GDK_CONTROL_MASK) + { + switch (event->keyval) + { + case GDK_KEY_s: + case GDK_KEY_S: + case GDK_KEY_f: + case GDK_KEY_F: + /* The search only happens when we're in the MAIN view */ + if (view != CC_PANEL_LIST_MAIN && + view != CC_PANEL_LIST_SEARCH) + { + break; + } + + retval = !gtk_search_bar_get_search_mode (self->search_bar); + gtk_search_bar_set_search_mode (self->search_bar, retval); + if (retval) + gtk_widget_grab_focus (GTK_WIDGET (self->search_entry)); + retval = GDK_EVENT_STOP; + break; + case GDK_KEY_Q: + case GDK_KEY_q: + case GDK_KEY_W: + case GDK_KEY_w: + gtk_widget_destroy (GTK_WIDGET (self)); + retval = GDK_EVENT_STOP; + break; + } + } + else if ((!is_rtl && state == GDK_MOD1_MASK && event->keyval == GDK_KEY_Left) || + (is_rtl && state == GDK_MOD1_MASK && event->keyval == GDK_KEY_Right) || + event->keyval == GDK_KEY_Back) + { + g_debug ("Going to previous panel"); + switch_to_previous_panel (self); + retval = GDK_EVENT_STOP; + } + + return retval; +} + +static void +on_development_warning_dialog_responded_cb (CcWindow *self) +{ + g_debug ("Disabling development build warning dialog"); + g_settings_set_boolean (self->settings, "show-development-warning", FALSE); + + gtk_widget_hide (GTK_WIDGET (self->development_warning_dialog)); +} + +/* CcShell implementation */ +static gboolean +cc_window_set_active_panel_from_id (CcShell *shell, + const gchar *start_id, + GVariant *parameters, + GError **error) +{ + return set_active_panel_from_id (CC_WINDOW (shell), start_id, parameters, TRUE, TRUE, error); +} + +static void +cc_window_embed_widget_in_header (CcShell *shell, + GtkWidget *widget, + GtkPositionType position) +{ + CcWindow *self = CC_WINDOW (shell); + + CC_ENTRY; + + /* add to header */ + switch (position) + { + case GTK_POS_RIGHT: + gtk_container_add (GTK_CONTAINER (self->top_right_box), widget); + break; + + case GTK_POS_LEFT: + gtk_container_add (GTK_CONTAINER (self->top_left_box), widget); + break; + + case GTK_POS_TOP: + case GTK_POS_BOTTOM: + default: + g_warning ("Invalid position passed"); + return; + } + + g_ptr_array_add (self->custom_widgets, g_object_ref (widget)); + + gtk_size_group_add_widget (self->header_sizegroup, widget); + + CC_EXIT; +} + +static GtkWidget * +cc_window_get_toplevel (CcShell *self) +{ + return GTK_WIDGET (self); +} + +static void +cc_shell_iface_init (CcShellInterface *iface) +{ + iface->set_active_panel_from_id = cc_window_set_active_panel_from_id; + iface->embed_widget_in_header = cc_window_embed_widget_in_header; + iface->get_toplevel = cc_window_get_toplevel; +} + +/* GtkWidget overrides */ +static void +cc_window_map (GtkWidget *widget) +{ + CcWindow *self = (CcWindow *) widget; + + GTK_WIDGET_CLASS (cc_window_parent_class)->map (widget); + + /* Show a warning for Flatpak builds */ + if (in_flatpak_sandbox () && g_settings_get_boolean (self->settings, "show-development-warning")) + gtk_window_present (GTK_WINDOW (self->development_warning_dialog)); +} + +/* GObject Implementation */ +static void +cc_window_get_property (GObject *object, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + CcWindow *self = CC_WINDOW (object); + + switch (property_id) + { + case PROP_ACTIVE_PANEL: + g_value_set_object (value, self->active_panel); + break; + + case PROP_MODEL: + g_value_set_object (value, self->store); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +static void +cc_window_set_property (GObject *object, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + CcWindow *self = CC_WINDOW (object); + + switch (property_id) + { + case PROP_ACTIVE_PANEL: + set_active_panel (self, g_value_get_object (value)); + break; + + case PROP_MODEL: + g_assert (self->store == NULL); + self->store = g_value_dup_object (value); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec); + } +} + +static void +cc_window_constructed (GObject *object) +{ + CcWindow *self = CC_WINDOW (object); + g_autofree char *id = NULL; + + /* Add the panels */ + setup_model (self); + + /* After everything is loaded, select the last used panel, if any, + * or the first visible panel */ + id = g_settings_get_string (self->settings, "last-panel"); + if (id != NULL && cc_shell_model_has_panel (self->store, id)) + cc_panel_list_set_active_panel (self->panel_list, id); + else + cc_panel_list_activate (self->panel_list); + + g_signal_connect_swapped (self->panel_list, + "notify::view", + G_CALLBACK (update_headerbar_buttons), + self); + + update_headerbar_buttons (self); + show_sidebar (self); + + G_OBJECT_CLASS (cc_window_parent_class)->constructed (object); +} + +static void +cc_window_dispose (GObject *object) +{ + CcWindow *self = CC_WINDOW (object); + + g_clear_pointer (&self->current_panel_id, g_free); + g_clear_pointer (&self->custom_widgets, g_ptr_array_unref); + g_clear_object (&self->store); + g_clear_object (&self->active_panel); + + G_OBJECT_CLASS (cc_window_parent_class)->dispose (object); +} + +static void +cc_window_finalize (GObject *object) +{ + CcWindow *self = CC_WINDOW (object); + + if (self->previous_panels) + { + g_queue_free_full (self->previous_panels, g_free); + self->previous_panels = NULL; + } + + g_clear_object (&self->settings); + + G_OBJECT_CLASS (cc_window_parent_class)->finalize (object); +} + +static void +cc_window_class_init (CcWindowClass *klass) +{ + GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass); + GObjectClass *object_class = G_OBJECT_CLASS (klass); + + object_class->get_property = cc_window_get_property; + object_class->set_property = cc_window_set_property; + object_class->constructed = cc_window_constructed; + object_class->dispose = cc_window_dispose; + object_class->finalize = cc_window_finalize; + + widget_class->map = cc_window_map; + + g_object_class_override_property (object_class, PROP_ACTIVE_PANEL, "active-panel"); + + g_object_class_install_property (object_class, + PROP_MODEL, + g_param_spec_object ("model", + "Model", + "The CcShellModel of this application", + CC_TYPE_SHELL_MODEL, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS)); + + gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/ControlCenter/gtk/cc-window.ui"); + + gtk_widget_class_bind_template_child (widget_class, CcWindow, back_revealer); + gtk_widget_class_bind_template_child (widget_class, CcWindow, development_warning_dialog); + gtk_widget_class_bind_template_child (widget_class, CcWindow, header); + gtk_widget_class_bind_template_child (widget_class, CcWindow, header_box); + gtk_widget_class_bind_template_child (widget_class, CcWindow, header_sizegroup); + gtk_widget_class_bind_template_child (widget_class, CcWindow, main_leaflet); + gtk_widget_class_bind_template_child (widget_class, CcWindow, panel_headerbar); + gtk_widget_class_bind_template_child (widget_class, CcWindow, panel_list); + gtk_widget_class_bind_template_child (widget_class, CcWindow, previous_button); + gtk_widget_class_bind_template_child (widget_class, CcWindow, search_bar); + gtk_widget_class_bind_template_child (widget_class, CcWindow, search_button); + gtk_widget_class_bind_template_child (widget_class, CcWindow, search_entry); + gtk_widget_class_bind_template_child (widget_class, CcWindow, sidebar_box); + gtk_widget_class_bind_template_child (widget_class, CcWindow, stack); + gtk_widget_class_bind_template_child (widget_class, CcWindow, top_left_box); + gtk_widget_class_bind_template_child (widget_class, CcWindow, top_right_box); + + gtk_widget_class_bind_template_callback (widget_class, back_button_clicked_cb); + gtk_widget_class_bind_template_callback (widget_class, gdk_window_set_cb); + gtk_widget_class_bind_template_callback (widget_class, on_main_leaflet_folded_changed_cb); + gtk_widget_class_bind_template_callback (widget_class, on_development_warning_dialog_responded_cb); + gtk_widget_class_bind_template_callback (widget_class, previous_button_clicked_cb); + gtk_widget_class_bind_template_callback (widget_class, search_entry_activate_cb); + gtk_widget_class_bind_template_callback (widget_class, show_panel_cb); + gtk_widget_class_bind_template_callback (widget_class, update_list_title); + gtk_widget_class_bind_template_callback (widget_class, window_key_press_event_cb); + gtk_widget_class_bind_template_callback (widget_class, window_map_event_cb); + + g_type_ensure (CC_TYPE_PANEL_LIST); +} + +static void +cc_window_init (CcWindow *self) +{ + gtk_widget_init_template (GTK_WIDGET (self)); + + gtk_widget_add_events (GTK_WIDGET (self), GDK_BUTTON_RELEASE_MASK); + + self->settings = g_settings_new ("org.gnome.ControlCenter"); + self->custom_widgets = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); + self->previous_panels = g_queue_new (); + self->previous_list_view = cc_panel_list_get_view (self->panel_list); + + /* Add a custom CSS class on development builds */ + if (in_flatpak_sandbox ()) + gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (self)), "devel"); +} + +CcWindow * +cc_window_new (GtkApplication *application, + CcShellModel *model) +{ + g_return_val_if_fail (GTK_IS_APPLICATION (application), NULL); + + return g_object_new (CC_TYPE_WINDOW, + "application", application, + "resizable", TRUE, + "title", _("Settings"), + "icon-name", DEFAULT_WINDOW_ICON_NAME, + "window-position", GTK_WIN_POS_CENTER, + "show-menubar", FALSE, + "model", model, + NULL); +} + +void +cc_window_set_search_item (CcWindow *center, + const char *search) +{ + gtk_search_bar_set_search_mode (center->search_bar, TRUE); + gtk_entry_set_text (GTK_ENTRY (center->search_entry), search); + gtk_editable_set_position (GTK_EDITABLE (center->search_entry), -1); +} diff --git a/shell/cc-window.h b/shell/cc-window.h new file mode 100644 index 0000000..5f74c36 --- /dev/null +++ b/shell/cc-window.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2010 Intel, Inc. + * + * 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 + * + * Author: Thomas Wood <thos@gnome.org> + */ + +#pragma once + +#include <glib-object.h> +#include "cc-shell.h" +#include "cc-shell-model.h" + +G_BEGIN_DECLS + +#define CC_TYPE_WINDOW (cc_window_get_type ()) + +G_DECLARE_FINAL_TYPE (CcWindow, cc_window, CC, WINDOW, GtkApplicationWindow) + +CcWindow *cc_window_new (GtkApplication *application, + CcShellModel *model); + +void cc_window_set_search_item (CcWindow *center, + const char *search); + +G_END_DECLS diff --git a/shell/cc-window.ui b/shell/cc-window.ui new file mode 100644 index 0000000..24f37de --- /dev/null +++ b/shell/cc-window.ui @@ -0,0 +1,336 @@ +<?xml version="1.0" encoding="UTF-8"?> +<interface> + <requires lib="gtk+" version="3.20"/> + <template class="CcWindow" parent="GtkApplicationWindow"> + <property name="can_focus">False</property> + <property name="window_position">center</property> + <property name="default-width">980</property> + <property name="default-height">640</property> + <signal name="notify::window" handler="gdk_window_set_cb" object="CcWindow" swapped="yes" /> + <signal name="map-event" handler="window_map_event_cb" object="CcWindow" swapped="yes" /> + <signal name="key-press-event" handler="window_key_press_event_cb" object="CcWindow" swapped="yes" after="yes" /> + <child> + <object class="HdyLeaflet" id="main_leaflet"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="transition-type">slide</property> + <signal name="notify::folded" handler="on_main_leaflet_folded_changed_cb" object="CcWindow" swapped="yes" /> + <child> + <object class="GtkBox" id="sidebar_box"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="hexpand">False</property> + <property name="orientation">vertical</property> + <child> + <object class="GtkSearchBar" id="search_bar"> + <property name="visible">True</property> + <property name="search_mode_enabled" bind-source="search_button" bind-property="active" bind-flags="sync-create|bidirectional" /> + <property name="app_paintable">True</property> + <property name="can_focus">False</property> + <child> + <object class="GtkSearchEntry" id="search_entry"> + <property name="visible">True</property> + <property name="can_focus">True</property> + <property name="width_chars">25</property> + <property name="input_hints">no-emoji</property> + <property name="max_width_chars">25</property> + <property name="primary_icon_name">edit-find-symbolic</property> + <property name="primary_icon_activatable">False</property> + <property name="primary_icon_sensitive">False</property> + <signal name="activate" handler="search_entry_activate_cb" object="CcWindow" swapped="yes" /> + <signal name="notify::text" handler="update_list_title" object="CcWindow" swapped="yes" /> + </object> + </child> + </object> + <packing> + <property name="expand">False</property> + <property name="fill">True</property> + <property name="position">0</property> + </packing> + </child> + <child> + <object class="GtkScrolledWindow"> + <property name="visible">True</property> + <property name="can_focus">True</property> + <property name="vexpand">True</property> + <property name="width-request">200</property> + <property name="hscrollbar_policy">never</property> + <style> + <class name="view"/> + </style> + <child> + <object class="CcPanelList" id="panel_list"> + <property name="visible">True</property> + <property name="can_focus">True</property> + <property name="search-mode" bind-source="search_bar" bind-property="search-mode-enabled" bind-flags="bidirectional" /> + <property name="search-query" bind-source="search_entry" bind-property="text" bind-flags="default" /> + <signal name="show-panel" handler="show_panel_cb" object="CcWindow" swapped="yes" /> + </object> + </child> + </object> + <packing> + <property name="expand">False</property> + <property name="fill">True</property> + <property name="position">1</property> + </packing> + </child> + </object> + </child> + <child> + <object class="GtkSeparator" id="panel_separator"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="orientation">vertical</property> + <style> + <class name="sidebar"/> + </style> + </object> + </child> + <child> + <object class="GtkStack" id="stack"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="hexpand">True</property> + <property name="vexpand">True</property> + <property name="transition_type">crossfade</property> + <property name="width_request">360</property> + <style> + <class name="background"/> + </style> + </object> + </child> + </object> + </child> + <child type="titlebar"> + <object class="HdyTitleBar"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <child> + <object class="HdyLeaflet" id="header_box"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="orientation">horizontal</property> + <property name="mode-transition-duration" bind-source="main_leaflet" bind-property="mode-transition-duration" bind-flags="bidirectional|sync-create"/> + <property name="child-transition-duration" bind-source="main_leaflet" bind-property="child-transition-duration" bind-flags="bidirectional|sync-create"/> + <property name="transition-type" bind-source="main_leaflet" bind-property="transition-type" bind-flags="bidirectional|sync-create"/> + <child> + <object class="GtkHeaderBar" id="header"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="show-close-button">True</property> + <property name="title" translatable="yes">Settings</property> + <child> + <object class="GtkButton" id="previous_button"> + <property name="can_focus">True</property> + <property name="receives_default">True</property> + <signal name="clicked" handler="previous_button_clicked_cb" object="CcWindow" swapped="yes" /> + <child> + <object class="GtkImage"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="icon_name">go-previous-symbolic</property> + </object> + </child> + <child internal-child="accessible"> + <object class="AtkObject" id="a11y-button1"> + <property name="accessible-name" translatable="yes">All Settings</property> + </object> + </child> + <style> + <class name="image-button"/> + </style> + </object> + </child> + <child> + <object class="GtkToggleButton" id="search_button"> + <property name="visible">True</property> + <property name="can_focus">True</property> + <property name="receives_default">True</property> + <child internal-child="accessible"> + <object class="AtkObject"> + <property name="accessible-name" translatable="yes">Search</property> + </object> + </child> + <child> + <object class="GtkImage"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="icon_name">edit-find-symbolic</property> + </object> + </child> + <style> + <class name="image-button"/> + </style> + </object> + </child> + <child> + <object class="GtkMenuButton"> + <property name="visible">True</property> + <property name="can_focus">True</property> + <property name="receives_default">True</property> + <property name="menu_model">primary_menu</property> + <child internal-child="accessible"> + <object class="AtkObject"> + <property name="accessible-name" translatable="yes">Primary Menu</property> + </object> + </child> + <child> + <object class="GtkImage"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="icon_name">open-menu-symbolic</property> + </object> + </child> + <style> + <class name="image-button"/> + </style> + </object> + <packing> + <property name="pack_type">end</property> + </packing> + </child> + </object> + </child> + <child> + <object class="GtkSeparator" id="header_separator"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="orientation">vertical</property> + <style> + <class name="sidebar"/> + </style> + </object> + </child> + <child> + <object class="GtkHeaderBar" id="panel_headerbar"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="hexpand">True</property> + <property name="show_close_button">True</property> + <child> + <object class="GtkRevealer" id="back_revealer"> + <property name="can_focus">False</property> + <property name="transition-type">crossfade</property> + <property name="transition-duration" bind-source="main_leaflet" bind-property="mode-transition-duration" bind-flags="bidirectional|sync-create"/> + <property name="visible" bind-source="header_box" bind-property="folded" bind-flags="sync-create"/> + <property name="reveal-child" bind-source="header_box" bind-property="folded" bind-flags="sync-create"/> + <child> + <object class="GtkButton" id="back"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="receives_default">False</property> + <property name="valign">center</property> + <property name="use-underline">True</property> + <signal name="clicked" handler="back_button_clicked_cb" object="CcWindow" swapped="yes" /> + <style> + <class name="image-button"/> + </style> + <child internal-child="accessible"> + <object class="AtkObject" id="a11y-back"> + <property name="accessible-name" translatable="yes">Back</property> + </object> + </child> + <child> + <object class="GtkImage" id="back_image"> + <property name="visible">True</property> + <property name="can_focus">False</property> + <property name="icon_name">go-previous-symbolic</property> + <property name="icon_size">1</property> + </object> + </child> + </object> + </child> + </object> + </child> + <child> + <object class="GtkBox" id="top_left_box"> + <property name="visible">True</property> + <property name="can_focus">True</property> + </object> + </child> + <child> + <object class="GtkBox" id="top_right_box"> + <property name="visible">True</property> + <property name="can_focus">True</property> + </object> + <packing> + <property name="pack_type">end</property> + </packing> + </child> + </object> + </child> + </object> + </child> + </object> + </child> + </template> + + <object class="HdyHeaderGroup"> + <property name="decorate-all" bind-source="main_leaflet" bind-property="folded" bind-flags="sync-create"/> + <headerbars> + <headerbar name="header"/> + <headerbar name="panel_headerbar"/> + </headerbars> + </object> + + <object class="GtkSizeGroup" id="header_sizegroup"> + <property name="mode">vertical</property> + <widgets> + <widget name="search_button"/> + <widget name="previous_button"/> + </widgets> + </object> + + <!-- Synchronize left header and sidebar --> + <object class="GtkSizeGroup"> + <property name="mode">horizontal</property> + <widgets> + <widget name="header"/> + <widget name="sidebar_box"/> + </widgets> + </object> + + <!-- Synchronize separators --> + <object class="GtkSizeGroup"> + <property name="mode">horizontal</property> + <widgets> + <widget name="header_separator"/> + <widget name="panel_separator"/> + </widgets> + </object> + + <!-- Synchronize right header and panel --> + <object class="GtkSizeGroup"> + <property name="mode">horizontal</property> + <widgets> + <widget name="panel_headerbar"/> + <widget name="stack"/> + </widgets> + </object> + + <!-- Warning dialog for development builds --> + <object class="GtkMessageDialog" id="development_warning_dialog"> + <property name="message-type">warning</property> + <property name="transient-for">CcWindow</property> + <property name="resizable">false</property> + <property name="modal">true</property> + <property name="buttons">ok</property> + <property name="text" translatable="yes">Warning: Development Version</property> + <property name="secondary-text" translatable="yes">This version of Settings should only be used for development purposes. You may experience incorrect system behavior, data loss, and other unexpected issues. </property> + <signal name="response" handler="on_development_warning_dialog_responded_cb" object="CcWindow" swapped="yes" /> + </object> + + <menu id="primary_menu"> + <section> + <item> + <attribute name="label" translatable="yes">Keyboard Shortcuts</attribute> + <attribute name="action">win.show-help-overlay</attribute> + </item> + <item> + <attribute name="label" translatable="yes">Help</attribute> + <attribute name="action">app.help</attribute> + </item> + </section> + </menu> + +</interface> diff --git a/shell/completions/gnome-control-center.in b/shell/completions/gnome-control-center.in new file mode 100644 index 0000000..51ce4fd --- /dev/null +++ b/shell/completions/gnome-control-center.in @@ -0,0 +1,51 @@ +# gnome-control-center tab completion for bash. + +_gnome_control_center() +{ + local cur prev command_list i v + + cur=${COMP_WORDS[COMP_CWORD]} + prev=${COMP_WORDS[COMP_CWORD-1]} + + case "$prev" in + *) + if [ $prev = "gnome-control-center" ] ; then + command_list="--verbose --version" + command_list="$command_list @PANELS@" + elif [ $prev = "--verbose" ]; then + command_list="@PANELS@" + fi + + for i in --version @PANELS@; do + if [ $i = $prev ]; then + case $i in + keyboard) + command_list="shortcuts typing" + ;; + network) + # FIXME + # The first 3 commands need an object path like + # /org/freedesktop/NetworkManager/Devices/1 + command_list="connect-3g connect-8021x-wifi show-device connect-hidden-wifi create-wifi" + ;; + sound) + command_list="applications effects hardware input outputs" + ;; + *) + command_list="" + ;; + esac + fi + done + ;; + esac + + for i in $command_list; do + if [ -z "${i/$cur*}" ]; then + COMPREPLY=( ${COMPREPLY[@]} $i ) + fi + done +} + +# load the completion +complete -F _gnome_control_center gnome-control-center diff --git a/shell/completions/meson.build b/shell/completions/meson.build new file mode 100644 index 0000000..951d060 --- /dev/null +++ b/shell/completions/meson.build @@ -0,0 +1,12 @@ +completion_conf = configuration_data() +completion_conf.set('PANELS', ' '.join(panels_list)) + +desktop = 'gnome-control-center' + +desktop_in = configure_file( + input: desktop + '.in', + output: desktop, + configuration: completion_conf, + install: true, + install_dir: join_paths(control_center_datadir, 'bash-completion', 'completions') +) diff --git a/shell/gnome-control-center.desktop.in.in b/shell/gnome-control-center.desktop.in.in new file mode 100644 index 0000000..e876299 --- /dev/null +++ b/shell/gnome-control-center.desktop.in.in @@ -0,0 +1,16 @@ +[Desktop Entry] +Name=Settings +# Translators: Do NOT translate or transliterate this text (this is an icon file name)! +Icon=org.gnome.Settings +Exec=gnome-control-center +Terminal=false +Type=Application +StartupNotify=true +Categories=GNOME;GTK;Settings; +OnlyShowIn=GNOME;Unity; +X-GNOME-Bugzilla-Bugzilla=GNOME +X-GNOME-Bugzilla-Product=gnome-control-center +X-GNOME-Bugzilla-Component=shell +X-GNOME-Bugzilla-Version=@VERSION@ +# Translators: Search terms to find this application. Do NOT translate or localize the semicolons! The list MUST also end with a semicolon! +Keywords=Preferences;Settings; diff --git a/shell/gnome-control-center.gresource.xml b/shell/gnome-control-center.gresource.xml new file mode 100644 index 0000000..9be077e --- /dev/null +++ b/shell/gnome-control-center.gresource.xml @@ -0,0 +1,9 @@ +<?xml version="1.0" encoding="UTF-8"?> +<gresources> + <gresource prefix="/org/gnome/ControlCenter/gtk"> + <file preprocess="xml-stripblanks">cc-panel-list.ui</file> + <file preprocess="xml-stripblanks">cc-window.ui</file> + <file preprocess="xml-stripblanks">help-overlay.ui</file> + <file>style.css</file> + </gresource> +</gresources> diff --git a/shell/help-overlay.ui b/shell/help-overlay.ui new file mode 100644 index 0000000..02cb679 --- /dev/null +++ b/shell/help-overlay.ui @@ -0,0 +1,61 @@ +<?xml version="1.0" encoding="UTF-8"?> +<interface> + <!-- interface-requires gtk+ 3.17 --> + + <object class="GtkShortcutsWindow" id="help_overlay"> + <property name="modal">1</property> + <child> + <object class="GtkShortcutsSection"> + <property name="visible">1</property> + <property name="section-name">shortcuts</property> + <property name="max-height">10</property> + <child> + <object class="GtkShortcutsGroup"> + <property name="visible">1</property> + <property name="title" translatable="yes" context="shortcut window">General</property> + <child> + <object class="GtkShortcutsShortcut"> + <property name="visible">1</property> + <property name="accelerator"><ctrl>Q</property> + <property name="title" translatable="yes" context="shortcut window">Quit</property> + </object> + </child> + <child> + <object class="GtkShortcutsShortcut"> + <property name="visible">1</property> + <property name="accelerator"><ctrl>S</property> + <property name="title" translatable="yes" context="shortcut window">Search</property> + </object> + </child> + </object> + </child> + <child> + <object class="GtkShortcutsGroup"> + <property name="visible">1</property> + <property name="title" translatable="yes" context="shortcut window">Panels</property> + <child> + <object class="GtkShortcutsShortcut"> + <property name="visible">1</property> + <property name="accelerator"><Alt>Left</property> + <property name="title" translatable="yes" context="shortcut window">Go back to previous panel</property> + </object> + </child> + </object> + </child> + <child> + <object class="GtkShortcutsGroup"> + <property name="visible">1</property> + <property name="title" translatable="yes" context="shortcut window">Search</property> + <child> + <object class="GtkShortcutsShortcut"> + <property name="visible">1</property> + <property name="accelerator">Escape</property> + <property name="title" translatable="yes" context="shortcut window">Cancel search</property> + </object> + </child> + </object> + </child> + </object> + </child> + </object> +</interface> diff --git a/shell/list-panel.sh b/shell/list-panel.sh new file mode 100755 index 0000000..cf31eae --- /dev/null +++ b/shell/list-panel.sh @@ -0,0 +1,8 @@ +#!/bin/sh + +LIST="" +for i in $1/panels/*/gnome-*panel.desktop.in.in $1/panels/*/data/gnome-*panel.desktop.in.in; do + basename=`basename $i` + LIST="$LIST `echo $basename | sed 's/gnome-//' | sed 's/-panel.desktop.in.in/ /'`" +done +echo -n $LIST | tr " " "\n" | sort | tr "\n" " " diff --git a/shell/main.c b/shell/main.c new file mode 100644 index 0000000..14c81c5 --- /dev/null +++ b/shell/main.c @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2009, 2010 Intel, Inc. + * Copyright (c) 2010 Red Hat, Inc. + * + * 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 + * + * Author: Thomas Wood <thos@gnome.org> + */ + +#include "config.h" + +#include <stdlib.h> +#include <glib/gi18n.h> +#include <gtk/gtk.h> + +#ifdef GDK_WINDOWING_X11 +#include <X11/Xlib.h> +#endif + +#ifdef HAVE_CHEESE +#include <cheese-gtk.h> +#endif /* HAVE_CHEESE */ + +#include "cc-application.h" + +static void +initialize_dependencies (gint *argc, + gchar ***argv) +{ + #ifdef GDK_WINDOWING_X11 + XInitThreads (); + #endif + + #ifdef HAVE_CHEESE + cheese_gtk_init (argc, argv); + #endif /* HAVE_CHEESE */ +} + +int +main (gint argc, + gchar **argv) +{ + g_autoptr(GtkApplication) application = NULL; + + bindtextdomain (GETTEXT_PACKAGE, GNOMELOCALEDIR); + bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); + textdomain (GETTEXT_PACKAGE); + + initialize_dependencies (&argc, &argv); + + application = cc_application_new (); + + return g_application_run (G_APPLICATION (application), argc, argv); +} diff --git a/shell/meson.build b/shell/meson.build new file mode 100644 index 0000000..89b9659 --- /dev/null +++ b/shell/meson.build @@ -0,0 +1,176 @@ +subdir('appdata') +subdir('completions') + +service_conf = configuration_data() +service_conf.set('bindir', control_center_bindir) + +service = 'org.gnome.ControlCenter.service' + +configure_file( + input : service + '.in', + output : service, + install : true, + install_dir : join_paths(control_center_datadir, 'dbus-1', 'services'), + configuration : service_conf +) + +desktop = 'gnome-control-center.desktop' + +desktop_in = configure_file( + input : desktop + '.in.in', + output : desktop + '.in', + configuration : desktop_conf +) + +i18n.merge_file( + desktop, + type : 'desktop', + input : desktop_in, + output : desktop, + po_dir : po_dir, + install : true, + install_dir : control_center_desktopdir +) + +cflags = ['-DGNOMELOCALEDIR="@0@"'.format(control_center_localedir)] + + +# Common sources between gnome-control-center and +# libtestshell. +common_sources = files( + 'cc-application.c', + 'cc-log.c', + 'cc-object-storage.c', + 'cc-panel-loader.c', + 'cc-panel.c', + 'cc-shell.c', + 'cc-panel-list.c', + 'cc-window.c', +) + + +################### +# Generated files # +################### + +generated_sources = files() + +# Debug +debug_conf = configuration_data() +debug_conf.set('BUGREPORT_URL', 'https://gitlab.gnome.org/GNOME/' + meson.project_name() + '/issues/new') +debug_conf.set10('ENABLE_TRACING', enable_tracing) + +generated_sources += configure_file( + input : 'cc-debug.h.in', + output : 'cc-debug.h', + configuration : debug_conf +) + +#Resources +resource_data = files( + 'cc-panel-list.ui', + 'cc-window.ui', + 'help-overlay.ui', +) + +generated_sources += gnome.compile_resources( + 'resources', + meson.project_name() + '.gresource.xml', + dependencies : resource_data, + export : true +) + +common_sources += generated_sources + +############ +# libshell # +############ + +libshell = static_library( + 'shell', + sources : 'cc-shell-model.c', + include_directories : [top_inc, common_inc], + dependencies : common_deps, + c_args : cflags +) + +libshell_dep = declare_dependency( + sources : generated_sources, + include_directories : top_inc, + link_with : libshell +) + + +######################## +# gnome-control-center # +######################## + +shell_sources = common_sources + files('main.c') + +shell_deps = common_deps + [ + libdevice_dep, + liblanguage_dep, + libwidgets_dep, + x11_dep, + libshell_dep, +] + +if enable_cheese + shell_deps += cheese_deps +endif + +if host_is_linux_not_s390 + shell_deps += wacom_deps +endif + +executable( + meson.project_name(), + shell_sources, + include_directories : top_inc, + dependencies : shell_deps, + c_args : cflags, + link_with : panels_libs, + install : true +) + + +################## +# lipanel_loader # +################## + +# Because it is confusing and somewhat problematic to directly add and compile +# cc-panel-loader.o by another directory (i.e. the shell search provider), we +# have to create a library and link it there, just like libshell.la. +libpanel_loader = static_library( + 'panel_loader', + sources : 'cc-panel-loader.c', + include_directories : top_inc, + dependencies : common_deps, + c_args : cflags + ['-DCC_PANEL_LOADER_NO_GTYPES'] +) + + +################ +# libtestshell # +################ + +libtestshell = static_library( + 'testshell', + common_sources, + include_directories : top_inc, + dependencies : shell_deps, + c_args : cflags, + link_with : panels_libs, +) +libtestshell_dep = declare_dependency( + sources : generated_sources, + include_directories : top_inc, + link_with : libtestshell +) +libtestshell_deps = common_deps + [ libwidgets_dep, libtestshell_dep ] + + +install_data ( + 'org.gnome.ControlCenter.gschema.xml', + install_dir : control_center_schemadir +) diff --git a/shell/org.gnome.ControlCenter.gschema.xml b/shell/org.gnome.ControlCenter.gschema.xml new file mode 100644 index 0000000..40350bc --- /dev/null +++ b/shell/org.gnome.ControlCenter.gschema.xml @@ -0,0 +1,19 @@ +<schemalist> + <schema gettext-domain="gnome-control-center-2.0" id="org.gnome.ControlCenter" path="/org/gnome/control-center/"> + <key name="last-panel" type="s"> + <default>''</default> + <summary>The identifier for the last Settings panel to be opened</summary> + <description> + The identifier for the last Settings panel to be opened. Unrecognised values + will be ignored and the first panel in the list selected. + </description> + </key> + <key name="show-development-warning" type="b"> + <default>true</default> + <summary>Show warning when running a development build of Settings</summary> + <description> + Whether Settings should show a warning when running a development build. + </description> + </key> + </schema> +</schemalist> diff --git a/shell/org.gnome.ControlCenter.service.in b/shell/org.gnome.ControlCenter.service.in new file mode 100644 index 0000000..a515129 --- /dev/null +++ b/shell/org.gnome.ControlCenter.service.in @@ -0,0 +1,3 @@ +[D-BUS Service] +Name=org.gnome.ControlCenter +Exec=@bindir@/gnome-control-center diff --git a/shell/style.css b/shell/style.css new file mode 100644 index 0000000..7ffc6ab --- /dev/null +++ b/shell/style.css @@ -0,0 +1,7 @@ +.drag-handle { + color: alpha(@theme_fg_color, 0.4); +} + +.drag-handle:backdrop { + color: alpha(@theme_unfocused_fg_color, 0.4); +} |