static void
gis_finished_page_init (GisFinishedPage *self)
{
g_resources_register (finished_get_resource ());
gtk_widget_init_template (GTK_WIDGET (self));
}
static void
gis_password_page_init (GisPasswordPage *page)
{
g_resources_register (password_get_resource ());
gtk_widget_init_template (GTK_WIDGET (page));
}
int main (int argc, char **argv)
{
GtkBuilder *builder;
GtkWidget *window;
GError *error = NULL;
gtk_init (&argc, &argv);
g_resources_register (cc_mouse_get_resource ());
builder = gtk_builder_new ();
gtk_builder_add_from_resource (builder, "/org/gnome/control-center/mouse/gnome-mouse-test.ui", &error);
if (error != NULL)
{
g_warning ("Error loading UI file: %s", error->message);
return 1;
}
window = gnome_mouse_test_init (builder);
gtk_widget_show_all (window);
g_signal_connect (G_OBJECT (window), "delete-event",
G_CALLBACK (delete_event_cb), window);
gtk_main ();
return 0;
}
static void
gis_goa_page_init (GisGoaPage *page)
{
g_resources_register (goa_get_resource ());
gtk_widget_init_template (GTK_WIDGET (page));
}
static void
gis_summary_page_init (GisSummaryPage *page)
{
g_resources_register (summary_get_resource ());
gtk_widget_init_template (GTK_WIDGET (page));
}
static void
gis_network_page_init (GisNetworkPage *page)
{
g_resources_register (network_get_resource ());
gtk_widget_init_template (GTK_WIDGET (page));
}
static void
irc_application_startup (GApplication *self)
{
g_resources_register (irc_get_resource ());
g_application_set_resource_base_path (self, "/se/tingping/IrcClient");
G_APPLICATION_CLASS (irc_application_parent_class)->startup (self);
}
static void registerGResource(void)
{
GOwnPtr<char> resourcesPath(g_build_filename(WEBKIT_EXEC_PATH, "TestWebKitAPI", "WebKit2Gtk", "resources", "webkit2gtk-tests-resources.gresource", NULL));
GResource* resource = g_resource_load(resourcesPath.get(), 0);
g_assert(resource);
g_resources_register(resource);
g_resource_unref(resource);
}
GtkWidget *
cc_language_chooser_new (GtkWidget *parent)
{
GtkBuilder *builder;
GtkWidget *chooser;
CcLanguageChooserPrivate *priv;
GError *error = NULL;
g_resources_register (cc_common_get_resource ());
builder = gtk_builder_new ();
if (gtk_builder_add_from_resource (builder, "/org/gnome/control-center/common/language-chooser.ui", &error) == 0) {
g_object_unref (builder);
g_warning ("failed to load language chooser: %s", error->message);
g_error_free (error);
return NULL;
}
chooser = WID ("language-dialog");
priv = g_new0 (CcLanguageChooserPrivate, 1);
g_object_set_data_full (G_OBJECT (chooser), "private", priv, cc_language_chooser_private_free);
g_object_set_data_full (G_OBJECT (chooser), "builder", builder, g_object_unref);
priv->done_button = WID ("ok-button");
priv->filter_entry = WID ("language-filter-entry");
priv->language_list = WID ("language-list");
priv->scrolledwindow = WID ("language-scrolledwindow");
priv->more_item = more_widget_new ();
/* We ref-sink here so we can reuse this widget multiple times */
priv->no_results = g_object_ref_sink (no_results_widget_new ());
gtk_widget_show_all (priv->no_results);
gtk_list_box_set_sort_func (GTK_LIST_BOX (priv->language_list),
sort_languages, chooser, NULL);
gtk_list_box_set_filter_func (GTK_LIST_BOX (priv->language_list),
language_visible, chooser, NULL);
gtk_list_box_set_selection_mode (GTK_LIST_BOX (priv->language_list),
GTK_SELECTION_NONE);
gtk_list_box_set_header_func (GTK_LIST_BOX (priv->language_list),
cc_list_box_update_header_func, NULL, NULL);
add_all_languages (GTK_DIALOG (chooser));
g_signal_connect_swapped (priv->filter_entry, "search-changed",
G_CALLBACK (filter_changed), chooser);
g_signal_connect (priv->language_list, "row-activated",
G_CALLBACK (row_activated), chooser);
gtk_list_box_invalidate_filter (GTK_LIST_BOX (priv->language_list));
gtk_window_set_transient_for (GTK_WINDOW (chooser), GTK_WINDOW (parent));
g_signal_connect (chooser, "activate-default",
G_CALLBACK (activate_default), chooser);
return chooser;
}
static void
gis_account_page_init (GisAccountPage *page)
{
g_resources_register (account_get_resource ());
g_type_ensure (GIS_TYPE_ACCOUNT_PAGE_LOCAL);
g_type_ensure (GIS_TYPE_ACCOUNT_PAGE_ENTERPRISE);
gtk_widget_init_template (GTK_WIDGET (page));
}
static void
gis_language_page_init (GisLanguagePage *page)
{
g_resources_register (language_get_resource ());
g_type_ensure (GIS_TYPE_WELCOME_WIDGET);
g_type_ensure (CC_TYPE_LANGUAGE_CHOOSER);
gtk_widget_init_template (GTK_WIDGET (page));
}
int
main (int argc,
char *argv[])
{
struct desktop *desktop;
gdk_set_allowed_backends ("wayland");
gtk_init (&argc, &argv);
g_resources_register (maynard_get_resource ());
desktop = malloc (sizeof *desktop);
desktop->output = NULL;
desktop->shell = NULL;
desktop->helper = NULL;
desktop->gdk_display = gdk_display_get_default ();
desktop->display =
gdk_wayland_display_get_wl_display (desktop->gdk_display);
if (desktop->display == NULL)
{
fprintf (stderr, "failed to get display: %m\n");
return -1;
}
desktop->registry = wl_display_get_registry (desktop->display);
wl_registry_add_listener (desktop->registry,
®istry_listener, desktop);
/* Wait until we have been notified about the compositor,
* shell, and shell helper objects */
while (!desktop->output || !desktop->shell || !desktop->helper)
wl_display_roundtrip (desktop->display);
desktop->grid_visible = FALSE;
desktop->system_visible = FALSE;
desktop->volume_visible = FALSE;
css_setup (desktop);
background_create (desktop);
/* panel needs to be first so the clock and launcher grid can
* be added to its layer */
panel_create (desktop);
clock_create (desktop);
launcher_grid_create (desktop);
gtk_main ();
/* TODO cleanup */
return EXIT_SUCCESS;
}
static void
cc_notifications_panel_init (CcNotificationsPanel *panel)
{
GtkWidget *w;
GError *error = NULL;
g_resources_register (cc_notifications_get_resource ());
panel->known_applications = g_hash_table_new_full (g_str_hash, g_str_equal,
NULL, g_free);
panel->builder = gtk_builder_new ();
if (gtk_builder_add_from_resource (panel->builder,
"/org/gnome/control-center/notifications/notifications.ui",
&error) == 0)
{
g_error ("Error loading UI file: %s", error->message);
g_error_free (error);
return;
}
panel->master_settings = g_settings_new (MASTER_SCHEMA);
g_settings_bind (panel->master_settings, "show-banners",
gtk_builder_get_object (panel->builder, "ccnotify-switch-banners"),
"active", G_SETTINGS_BIND_DEFAULT);
g_settings_bind (panel->master_settings, "show-in-lock-screen",
gtk_builder_get_object (panel->builder, "ccnotify-switch-lock-screen"),
"active", G_SETTINGS_BIND_DEFAULT);
panel->list_box = egg_list_box_new ();
w = GTK_WIDGET (gtk_builder_get_object (panel->builder,
"ccnotify-app-scrolledwindow"));
egg_list_box_add_to_scrolled (panel->list_box, GTK_SCROLLED_WINDOW (w));
egg_list_box_set_selection_mode (panel->list_box, GTK_SELECTION_NONE);
egg_list_box_set_sort_func (panel->list_box, sort_apps, NULL, NULL);
egg_list_box_set_separator_funcs (panel->list_box,
update_separator_func,
NULL, NULL);
g_signal_connect (panel->list_box, "child-activated",
G_CALLBACK (select_app), panel);
gtk_widget_set_visible (GTK_WIDGET (panel->list_box), TRUE);
build_app_store (panel);
w = GTK_WIDGET (gtk_builder_get_object (panel->builder,
"ccnotify-main-grid"));
gtk_widget_reparent (w, GTK_WIDGET (panel));
gtk_widget_show (w);
}
GType
wireless_security_get_g_type (void)
{
static GType type_id = 0;
if (!type_id) {
g_resources_register (wireless_security_get_resource ());
type_id = g_boxed_type_register_static ("CcWirelessSecurity",
(GBoxedCopyFunc) wireless_security_ref,
(GBoxedFreeFunc) wireless_security_unref);
}
return type_id;
}
static void
gis_password_page_init (GisPasswordPage *page)
{
GtkCssProvider *provider;
g_resources_register (password_get_resource ());
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_resource (provider, "/org/gnome/initial-setup/gis-password-page.css");
gtk_style_context_add_provider_for_screen (gdk_screen_get_default (),
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
g_object_unref (provider);
gtk_widget_init_template (GTK_WIDGET (page));
}
/** \brief Intialize the GResource binary blob handling
*
* First tries to load from src/arch/gtk3/data and then from VICEDIR/data.
* Loading from VICEDIR/data will fail, the vice.gresource file doesn't get
* copied there yet with a make install, nor does the VICEDIR/data dir exist.
*
* \return bool
*/
int uidata_init(void)
{
GError *err = NULL;
#ifdef HAVE_DEBUG_GTK3UI
char **files;
int i;
#endif
char *path;
char *dir;
/* try directory with VICE's data files */
dir = archdep_get_vice_datadir();
debug_gtk3("trying archdep_get_vice_datadir() (%s).", dir);
path = archdep_join_paths(dir, "vice.gresource", NULL);
lib_free(dir);
gresource = g_resource_load(path, &err);
if (gresource == NULL && err != NULL) {
debug_gtk3("failed to load resource data '%s': %s.",
path, err->message);
g_clear_error(&err);
lib_free(path);
return 0;
}
lib_free(path);
g_resources_register(gresource);
/* debugging: show files in the resource blob */
#ifdef HAVE_DEBUG_GTK3UI
files = g_resource_enumerate_children(
gresource,
UIDATA_ROOT_PATH,
G_RESOURCE_LOOKUP_FLAGS_NONE,
&err);
if (files == NULL && err != NULL) {
debug_gtk3("couldn't enumerate children: %s.", err->message);
g_clear_error(&err);
return 0;
}
debug_gtk3("Listing files in the GResource file:");
for (i = 0; files[i] != NULL; i++) {
debug_gtk3("%d: %s.", i, files[i]);
}
#endif
return 1;
}
static void
cc_ua_panel_init (CcUaPanel *self)
{
CcUaPanelPrivate *priv;
GtkWidget *panel;
GtkWidget *content;
priv = self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
CC_TYPE_UA_PANEL,
CcUaPanelPrivate);
g_resources_register (cc_universal_access_get_resource ());
priv->interface_settings = g_settings_new (INTERFACE_SETTINGS);
priv->a11y_settings = g_settings_new (A11Y_SETTINGS);
priv->wm_settings = g_settings_new (WM_SETTINGS);
priv->kb_settings = g_settings_new (KEYBOARD_SETTINGS);
priv->mouse_settings = g_settings_new (MOUSE_SETTINGS);
priv->application_settings = g_settings_new (APPLICATION_SETTINGS);
priv->builder = gtk_builder_new ();
gtk_builder_add_from_resource (priv->builder,
"/org/gnome/control-center/universal-access/uap.ui",
NULL);
cc_ua_panel_init_status (self);
cc_ua_panel_init_seeing (self);
cc_ua_panel_init_hearing (self);
cc_ua_panel_init_keyboard (self);
cc_ua_panel_init_mouse (self);
panel = WID ("universal_access_panel");
content = WID ("universal_access_content");
g_signal_connect (content, "size-allocate",
G_CALLBACK (on_content_size_changed), panel);
priv->focus_adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (panel));
gtk_container_set_focus_vadjustment (GTK_CONTAINER (content), priv->focus_adjustment);
gtk_widget_reparent (panel, GTK_WIDGET (self));
}
static void
cc_mouse_panel_init (CcMousePanel *self)
{
CcMousePanelPrivate *priv;
priv = self->priv = MOUSE_PANEL_PRIVATE (self);
g_resources_register (cc_mouse_get_resource ());
priv->prefs_widget = cc_mouse_properties_new ();
priv->test_widget = cc_mouse_test_new ();
gtk_widget_set_margin_start (priv->prefs_widget, 6);
gtk_widget_set_margin_end (priv->prefs_widget, 6);
gtk_widget_set_margin_top (priv->prefs_widget, 6);
gtk_widget_set_margin_bottom (priv->prefs_widget, 6);
gtk_container_add (GTK_CONTAINER (self), priv->prefs_widget);
gtk_widget_show (priv->prefs_widget);
gtk_widget_show (priv->test_widget);
}
static void
cc_keyboard_panel_init (CcKeyboardPanel *self)
{
CcKeyboardPanelPrivate *priv;
GError *error = NULL;
priv = self->priv = KEYBOARD_PANEL_PRIVATE (self);
g_resources_register (cc_keyboard_get_resource ());
priv->builder = gtk_builder_new ();
if (gtk_builder_add_from_resource (priv->builder,
"/org/gnome/control-center/keyboard/gnome-keyboard-panel.ui",
&error) == 0)
{
g_warning ("Could not load UI: %s", error->message);
g_clear_error (&error);
g_object_unref (priv->builder);
priv->builder = NULL;
}
}
int
main (int argc,
char *argv[])
{
GApplication *app;
int ret;
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
g_set_prgname (PACKAGE_TARNAME);
g_set_application_name (_("Builder"));
ide_set_program_name ("gnome-builder");
ide_log_init (TRUE, NULL);
g_message ("Initializing with Gtk+ version %d.%d.%d.",
gtk_get_major_version (),
gtk_get_minor_version (),
gtk_get_micro_version ());
g_resources_register (gb_icons_get_resource ());
app = g_object_new (GB_TYPE_APPLICATION,
"application-id", "org.gnome.Builder",
"flags", G_APPLICATION_HANDLES_OPEN,
NULL);
ret = g_application_run (app, argc, argv);
g_clear_object (&app);
ide_log_shutdown ();
return ret;
}
static void
ide_application_plugins_load_plugin_gresources (IdeApplication *self,
PeasPluginInfo *plugin_info,
PeasEngine *engine)
{
g_autofree gchar *gresources_path = NULL;
g_autofree gchar *gresources_basename = NULL;
const gchar *module_dir;
const gchar *module_name;
g_assert (IDE_IS_APPLICATION (self));
g_assert (plugin_info != NULL);
g_assert (PEAS_IS_ENGINE (engine));
module_dir = peas_plugin_info_get_module_dir (plugin_info);
module_name = peas_plugin_info_get_module_name (plugin_info);
gresources_basename = g_strdup_printf ("%s.gresource", module_name);
gresources_path = g_build_filename (module_dir, gresources_basename, NULL);
if (g_file_test (gresources_path, G_FILE_TEST_IS_REGULAR))
{
g_autoptr(GError) error = NULL;
GResource *resource;
resource = g_resource_load (gresources_path, &error);
if (resource == NULL)
{
g_warning ("Failed to load gresources: %s", error->message);
return;
}
g_hash_table_insert (self->plugin_gresources, g_strdup (module_name), resource);
g_resources_register (resource);
}
}
static int
run_bridge (const gchar *interactive)
{
CockpitTransport *transport;
CockpitBridge *bridge;
gboolean terminated = FALSE;
gboolean interupted = FALSE;
gboolean closed = FALSE;
gboolean init_received = FALSE;
guint sig_term;
guint sig_int;
int outfd;
cockpit_set_journal_logging (G_LOG_DOMAIN, !isatty (2));
/*
* This process talks on stdin/stdout. However lots of stuff wants to write
* to stdout, such as g_debug, and uses fd 1 to do that. Reroute fd 1 so that
* it goes to stderr, and use another fd for stdout.
*/
outfd = dup (1);
if (outfd < 0 || dup2 (2, 1) < 1)
{
g_warning ("bridge couldn't redirect stdout to stderr");
outfd = 1;
}
sig_term = g_unix_signal_add (SIGTERM, on_signal_done, &terminated);
sig_int = g_unix_signal_add (SIGINT, on_signal_done, &interupted);
g_type_init ();
cockpit_dbus_json_allow_external = FALSE;
packages = cockpit_packages_new ();
cockpit_dbus_internal_startup (interactive != NULL);
if (interactive)
{
/* Allow skipping the init message when interactive */
init_received = TRUE;
transport = cockpit_interact_transport_new (0, outfd, interactive);
}
else
{
transport = cockpit_pipe_transport_new_fds ("stdio", 0, outfd);
}
g_resources_register (cockpitassets_get_resource ());
cockpit_web_failure_resource = "/org/cockpit-project/Cockpit/fail.html";
bridge = cockpit_bridge_new (transport, payload_types, init_received);
cockpit_dbus_environment_startup ();
g_signal_connect (transport, "closed", G_CALLBACK (on_closed_set_flag), &closed);
send_init_command (transport);
while (!terminated && !closed && !interupted)
g_main_context_iteration (NULL, TRUE);
g_object_unref (bridge);
g_object_unref (transport);
cockpit_packages_free (packages);
packages = NULL;
g_source_remove (sig_term);
g_source_remove (sig_int);
/* So the caller gets the right signal */
if (terminated)
raise (SIGTERM);
return 0;
}
static void
cc_background_panel_init (CcBackgroundPanel *self)
{
CcBackgroundPanelPrivate *priv;
gchar *objects[] = {"background-panel", NULL };
GError *err = NULL;
GtkWidget *widget;
priv = self->priv = BACKGROUND_PANEL_PRIVATE (self);
priv->connection = g_application_get_dbus_connection (g_application_get_default ());
g_resources_register (cc_background_get_resource ());
priv->builder = gtk_builder_new ();
gtk_builder_add_objects_from_resource (priv->builder,
"/org/gnome/control-center/background/background.ui",
objects, &err);
if (err)
{
g_warning ("Could not load ui: %s", err->message);
g_error_free (err);
return;
}
priv->settings = g_settings_new (WP_PATH_ID);
g_settings_delay (priv->settings);
priv->lock_settings = g_settings_new (WP_LOCK_PATH_ID);
g_settings_delay (priv->lock_settings);
/* add the top level widget */
widget = WID ("background-panel");
gtk_container_add (GTK_CONTAINER (self), widget);
gtk_widget_show_all (GTK_WIDGET (self));
/* setup preview area */
widget = WID ("background-desktop-drawingarea");
g_signal_connect (widget, "draw", G_CALLBACK (on_preview_draw), self);
widget = WID ("background-lock-drawingarea");
g_signal_connect (widget, "draw", G_CALLBACK (on_lock_preview_draw), self);
priv->copy_cancellable = g_cancellable_new ();
priv->capture_cancellable = g_cancellable_new ();
priv->thumb_factory = gnome_desktop_thumbnail_factory_new (GNOME_DESKTOP_THUMBNAIL_SIZE_LARGE);
/* Load the backgrounds */
reload_current_bg (self, priv->settings);
update_preview (priv, priv->settings, NULL);
reload_current_bg (self, priv->lock_settings);
update_preview (priv, priv->lock_settings, NULL);
/* Background settings */
g_signal_connect (priv->settings, "changed", G_CALLBACK (on_settings_changed), self);
g_signal_connect (priv->lock_settings, "changed", G_CALLBACK (on_settings_changed), self);
/* Background buttons */
widget = WID ("background-set-button");
g_signal_connect (widget, "clicked", G_CALLBACK (on_background_button_clicked), self);
widget = WID ("background-lock-set-button");
g_signal_connect (widget, "clicked", G_CALLBACK (on_lock_button_clicked), self);
}
DB_plugin_t *
ddb_misc_headerbar_GTK3_load (DB_functions_t *api) {
g_resources_register(headerbarui_get_resource());
deadbeef = api;
return DB_PLUGIN(&plugin);
}
static int
run_bridge (const gchar *interactive,
gboolean privileged_slave)
{
CockpitTransport *transport;
gboolean terminated = FALSE;
gboolean interupted = FALSE;
gboolean closed = FALSE;
CockpitPortal *super = NULL;
CockpitPortal *pcp = NULL;
gpointer polkit_agent = NULL;
const gchar *directory;
struct passwd *pwd;
GPid daemon_pid = 0;
GPid agent_pid = 0;
guint sig_term;
guint sig_int;
int outfd;
uid_t uid;
cockpit_set_journal_logging (G_LOG_DOMAIN, !isatty (2));
/*
* The bridge always runs from within $XDG_RUNTIME_DIR
* This makes it easy to create user sockets and/or files.
*/
if (!privileged_slave)
{
directory = g_get_user_runtime_dir ();
if (g_mkdir_with_parents (directory, 0700) < 0)
g_warning ("couldn't create runtime dir: %s: %s", directory, g_strerror (errno));
else if (g_chdir (directory) < 0)
g_warning ("couldn't change to runtime dir: %s: %s", directory, g_strerror (errno));
}
/* Always set environment variables early */
uid = geteuid();
pwd = getpwuid_a (uid);
if (pwd == NULL)
{
g_message ("couldn't get user info: %s", g_strerror (errno));
}
else
{
g_setenv ("USER", pwd->pw_name, TRUE);
g_setenv ("HOME", pwd->pw_dir, TRUE);
g_setenv ("SHELL", pwd->pw_shell, TRUE);
}
/* Reset the umask, typically this is done in .bashrc for a login shell */
umask (022);
/*
* This process talks on stdin/stdout. However lots of stuff wants to write
* to stdout, such as g_debug, and uses fd 1 to do that. Reroute fd 1 so that
* it goes to stderr, and use another fd for stdout.
*/
outfd = dup (1);
if (outfd < 0 || dup2 (2, 1) < 1)
{
g_warning ("bridge couldn't redirect stdout to stderr");
outfd = 1;
}
sig_term = g_unix_signal_add (SIGTERM, on_signal_done, &terminated);
sig_int = g_unix_signal_add (SIGINT, on_signal_done, &interupted);
g_type_init ();
/* Start daemons if necessary */
if (!interactive && !privileged_slave)
{
if (!have_env ("DBUS_SESSION_BUS_ADDRESS"))
daemon_pid = start_dbus_daemon ();
if (!have_env ("SSH_AUTH_SOCK"))
agent_pid = start_ssh_agent ();
}
packages = cockpit_packages_new ();
cockpit_dbus_internal_startup (interactive != NULL);
if (interactive)
{
/* Allow skipping the init message when interactive */
init_received = TRUE;
transport = cockpit_interact_transport_new (0, outfd, interactive);
}
else
{
transport = cockpit_pipe_transport_new_fds ("stdio", 0, outfd);
}
if (uid != 0)
{
if (!interactive)
polkit_agent = cockpit_polkit_agent_register (transport, NULL);
super = cockpit_portal_new_superuser (transport);
}
g_resources_register (cockpitassets_get_resource ());
cockpit_web_failure_resource = "/org/cockpit-project/Cockpit/fail.html";
pcp = cockpit_portal_new_pcp (transport);
cockpit_dbus_time_startup ();
cockpit_dbus_user_startup (pwd);
cockpit_dbus_setup_startup ();
g_free (pwd);
pwd = NULL;
g_signal_connect (transport, "control", G_CALLBACK (on_transport_control), NULL);
g_signal_connect (transport, "closed", G_CALLBACK (on_closed_set_flag), &closed);
send_init_command (transport);
/* Owns the channels */
channels = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
while (!terminated && !closed && !interupted)
g_main_context_iteration (NULL, TRUE);
if (polkit_agent)
cockpit_polkit_agent_unregister (polkit_agent);
if (super)
g_object_unref (super);
g_object_unref (pcp);
g_object_unref (transport);
g_hash_table_destroy (channels);
cockpit_dbus_internal_cleanup ();
cockpit_packages_free (packages);
packages = NULL;
if (daemon_pid)
kill (daemon_pid, SIGTERM);
if (agent_pid)
kill (agent_pid, SIGTERM);
g_source_remove (sig_term);
g_source_remove (sig_int);
/* So the caller gets the right signal */
if (terminated)
raise (SIGTERM);
return 0;
}
static void
cc_search_panel_init (CcSearchPanel *self)
{
GError *error;
GtkWidget *widget;
GtkWidget *scrolled_window;
guint res;
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, CC_TYPE_SEARCH_PANEL, CcSearchPanelPrivate);
g_resources_register (cc_search_get_resource ());
self->priv->builder = gtk_builder_new ();
error = NULL;
res = gtk_builder_add_from_resource (self->priv->builder,
"/org/gnome/control-center/search/search.ui",
&error);
if (res == 0)
{
g_warning ("Could not load interface file: %s",
(error != NULL) ? error->message : "unknown error");
g_clear_error (&error);
return;
}
scrolled_window = WID ("scrolled_window");
widget = GTK_WIDGET (gtk_list_box_new ());
gtk_list_box_set_sort_func (GTK_LIST_BOX (widget),
(GtkListBoxSortFunc)list_sort_func, self, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), widget);
self->priv->list_box = widget;
gtk_widget_show (widget);
g_signal_connect_swapped (widget, "row-selected",
G_CALLBACK (search_panel_invalidate_button_state), self);
self->priv->up_button = WID ("up_button");
g_signal_connect (self->priv->up_button, "clicked",
G_CALLBACK (up_button_clicked), self);
gtk_widget_set_sensitive (self->priv->up_button, FALSE);
self->priv->down_button = WID ("down_button");
g_signal_connect (self->priv->down_button, "clicked",
G_CALLBACK (down_button_clicked), self);
gtk_widget_set_sensitive (self->priv->down_button, FALSE);
widget = WID ("settings_button");
g_signal_connect (widget, "clicked",
G_CALLBACK (settings_button_clicked), self);
gtk_widget_set_sensitive (widget, cc_search_locations_dialog_is_available ());
self->priv->search_settings = g_settings_new ("org.gnome.desktop.search-providers");
self->priv->sort_order = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, NULL);
g_signal_connect_swapped (self->priv->search_settings, "changed::sort-order",
G_CALLBACK (search_panel_invalidate_sort_order), self);
search_panel_invalidate_sort_order (self);
populate_search_providers (self);
widget = WID ("search_vbox");
gtk_container_add (GTK_CONTAINER (self), widget);
}
static void
cc_privacy_panel_init (CcPrivacyPanel *self)
{
GError *error;
GtkWidget *widget;
GtkWidget *frame;
guint res;
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, CC_TYPE_PRIVACY_PANEL, CcPrivacyPanelPrivate);
g_resources_register (cc_privacy_get_resource ());
self->priv->builder = gtk_builder_new ();
error = NULL;
res = gtk_builder_add_from_resource (self->priv->builder,
"/org/gnome/control-center/privacy/privacy.ui",
&error);
if (res == 0)
{
g_warning ("Could not load interface file: %s",
(error != NULL) ? error->message : "unknown error");
g_clear_error (&error);
return;
}
self->priv->recent_dialog = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "recent_dialog"));
self->priv->screen_lock_dialog = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "screen_lock_dialog"));
self->priv->trash_dialog = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "trash_dialog"));
self->priv->software_dialog = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "software_dialog"));
self->priv->abrt_dialog = GTK_WIDGET (gtk_builder_get_object (self->priv->builder, "abrt_dialog"));
frame = WID ("frame");
widget = gtk_list_box_new ();
gtk_list_box_set_selection_mode (GTK_LIST_BOX (widget), GTK_SELECTION_NONE);
gtk_container_add (GTK_CONTAINER (frame), widget);
self->priv->list_box = widget;
gtk_widget_show (widget);
g_signal_connect_swapped (widget, "row-activated",
G_CALLBACK (activate_row), self);
gtk_list_box_set_header_func (GTK_LIST_BOX (widget),
cc_list_box_update_header_func,
NULL, NULL);
self->priv->lockdown_settings = g_settings_new ("org.gnome.desktop.lockdown");
self->priv->lock_settings = g_settings_new ("org.gnome.desktop.screensaver");
self->priv->privacy_settings = g_settings_new ("org.gnome.desktop.privacy");
self->priv->notification_settings = g_settings_new ("org.gnome.desktop.notifications");
self->priv->location_settings = g_settings_new ("org.gnome.system.location");
add_screen_lock (self);
add_usage_history (self);
add_trash_temp (self);
add_software (self);
add_abrt (self);
g_signal_connect (self->priv->lockdown_settings, "changed",
G_CALLBACK (on_lockdown_settings_changed), self);
update_lock_screen_sensitivity (self);
widget = WID ("location_services_switch");
gtk_switch_set_active (GTK_SWITCH (widget),
g_settings_get_boolean (self->priv->location_settings,
LOCATION_ENABLED));
g_settings_bind (self->priv->location_settings,
LOCATION_ENABLED,
widget, "active",
G_SETTINGS_BIND_DEFAULT);
widget = WID ("privacy_vbox");
gtk_container_add (GTK_CONTAINER (self), widget);
}
static void
cc_sharing_panel_init (CcSharingPanel *self)
{
CcSharingPanelPrivate *priv = self->priv = PANEL_PRIVATE (self);
GtkWidget *box;
GError *err = NULL;
gchar *objects[] = {
"sharing-panel",
"bluetooth-sharing-dialog",
"media-sharing-dialog",
"personal-file-sharing-dialog",
"remote-login-dialog",
"screen-sharing-dialog",
NULL };
GError *error = NULL;
g_resources_register (cc_sharing_get_resource ());
priv->builder = gtk_builder_new ();
gtk_builder_add_objects_from_resource (priv->builder,
"/org/gnome/control-center/sharing/sharing.ui",
objects, &err);
if (err)
g_error ("Error loading CcSharingPanel user interface: %s", err->message);
priv->hostname_entry = WID ("hostname-entry");
gtk_container_add (GTK_CONTAINER (self), WID ("sharing-panel"));
g_signal_connect (WID ("main-list-box"), "row-activated",
G_CALLBACK (cc_sharing_panel_main_list_box_row_activated), self);
priv->hostname_cancellable = g_cancellable_new ();
priv->bluetooth_sharing_dialog = WID ("bluetooth-sharing-dialog");
priv->media_sharing_dialog = WID ("media-sharing-dialog");
priv->personal_file_sharing_dialog = WID ("personal-file-sharing-dialog");
priv->remote_login_dialog = WID ("remote-login-dialog");
priv->remote_login_cancellable = g_cancellable_new ();
priv->screen_sharing_dialog = WID ("screen-sharing-dialog");
g_signal_connect (priv->bluetooth_sharing_dialog, "response",
G_CALLBACK (gtk_widget_hide), NULL);
g_signal_connect (priv->media_sharing_dialog, "response",
G_CALLBACK (gtk_widget_hide), NULL);
g_signal_connect (priv->personal_file_sharing_dialog, "response",
G_CALLBACK (gtk_widget_hide), NULL);
g_signal_connect (priv->remote_login_dialog, "response",
G_CALLBACK (gtk_widget_hide), NULL);
g_signal_connect (priv->screen_sharing_dialog, "response",
G_CALLBACK (gtk_widget_hide), NULL);
gtk_list_box_set_activate_on_single_click (GTK_LIST_BOX (WID ("main-list-box")),
TRUE);
gtk_list_box_set_header_func (GTK_LIST_BOX (WID ("main-list-box")),
cc_list_box_update_header_func,
NULL, NULL);
/* create the master switch */
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
priv->master_switch = gtk_switch_new ();
gtk_widget_set_valign (priv->master_switch, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (box), priv->master_switch, FALSE, FALSE, 4);
gtk_widget_show_all (box);
/* start the panel in the disabled state */
gtk_switch_set_active (GTK_SWITCH (priv->master_switch), FALSE);
gtk_widget_set_sensitive (WID ("main-list-box"), FALSE);
g_signal_connect (priv->master_switch, "notify::active",
G_CALLBACK (cc_sharing_panel_master_switch_notify), self);
self->priv->sharing_proxy = G_DBUS_PROXY (gsd_sharing_proxy_new_for_bus_sync (G_BUS_TYPE_SESSION,
G_DBUS_PROXY_FLAGS_NONE,
"org.gnome.SettingsDaemon.Sharing",
"/org/gnome/SettingsDaemon/Sharing",
NULL,
&error));
if (!self->priv->sharing_proxy) {
g_warning ("Failed to get sharing proxy: %s", error->message);
g_error_free (error);
}
/* bluetooth */
if (cc_sharing_panel_check_schema_available (self, FILE_SHARING_SCHEMA_ID))
cc_sharing_panel_setup_bluetooth_sharing_dialog (self);
else
gtk_widget_hide (WID ("bluetooth-sharing-button"));
/* media sharing */
cc_sharing_panel_setup_media_sharing_dialog (self);
/* personal file sharing */
if (cc_sharing_panel_check_schema_available (self, FILE_SHARING_SCHEMA_ID))
cc_sharing_panel_setup_personal_file_sharing_dialog (self);
else
gtk_widget_hide (WID ("personal-file-sharing-button"));
/* remote login */
cc_sharing_panel_setup_remote_login_dialog (self);
/* screen sharing */
if (cc_sharing_panel_check_schema_available (self, VINO_SCHEMA_ID))
cc_sharing_panel_setup_screen_sharing_dialog (self);
else
gtk_widget_hide (WID ("screen-sharing-button"));
/* make sure the hostname entry isn't focused by default */
g_signal_connect_swapped (self, "map", G_CALLBACK (gtk_widget_grab_focus),
WID ("main-list-box"));
}
static void
gis_privacy_page_init (GisPrivacyPage *page)
{
g_resources_register (privacy_get_resource ());
gtk_widget_init_template (GTK_WIDGET (page));
}
static void
fcitx_config_app_init (FcitxConfigApp *app)
{
fcitx_config_gtk3_register_resource();
g_resources_register (fcitx_config_gtk3_get_resource ());
}
