static void
photos_dlna_renderers_dialog_init (PhotosDlnaRenderersDialog *self)
{
PhotosDlnaRenderersDialogPrivate *priv;
GList *renderers;
self->priv = photos_dlna_renderers_dialog_get_instance_private (self);
priv = self->priv;
priv->item_mngr = photos_item_manager_dup_singleton ();
priv->renderers_mngr = photos_dlna_renderers_manager_dup_singleton ();
priv->remote_mngr = photos_remote_display_manager_dup_singleton ();
priv->mode_cntrlr = photos_mode_controller_dup_singleton ();
gtk_widget_init_template (GTK_WIDGET (self));
gtk_list_box_set_header_func (priv->listbox, photos_dlna_renderers_separator_cb, NULL, NULL);
renderers = photos_dlna_renderers_manager_dup_renderers (priv->renderers_mngr);
while (renderers != NULL)
{
PhotosDlnaRenderer *renderer = PHOTOS_DLNA_RENDERER (renderers->data);
photos_dlna_renderers_dialog_add_renderer (self, renderer);
renderers = g_list_delete_link (renderers, renderers);
}
g_signal_connect (self, "response", G_CALLBACK (gtk_widget_destroy), NULL);
}
static void
show_input_sources_for_locale (GtkWidget *chooser,
LocaleInfo *info)
{
CcInputChooserPrivate *priv = GET_PRIVATE (chooser);
set_fixed_size (chooser);
remove_all_children (GTK_CONTAINER (priv->list));
if (!info->back_row)
{
info->back_row = g_object_ref_sink (back_row_new (info->name));
g_object_set_data (G_OBJECT (info->back_row), "back", GINT_TO_POINTER (TRUE));
g_object_set_data (G_OBJECT (info->back_row), "locale-info", info);
}
gtk_container_add (GTK_CONTAINER (priv->list), GTK_WIDGET (info->back_row));
add_input_source_rows_for_locale (chooser, info);
gtk_widget_show_all (priv->list);
gtk_adjustment_set_value (priv->adjustment,
gtk_adjustment_get_lower (priv->adjustment));
gtk_list_box_set_header_func (GTK_LIST_BOX (priv->list), cc_list_box_update_header_func, NULL, NULL);
gtk_list_box_invalidate_filter (GTK_LIST_BOX (priv->list));
gtk_list_box_set_selection_mode (GTK_LIST_BOX (priv->list), GTK_SELECTION_SINGLE);
gtk_list_box_set_activate_on_single_click (GTK_LIST_BOX (priv->list), FALSE);
gtk_list_box_unselect_all (GTK_LIST_BOX (priv->list));
if (gtk_widget_is_visible (priv->filter_entry) &&
!gtk_widget_is_focus (priv->filter_entry))
gtk_widget_grab_focus (priv->filter_entry);
}
static void
empathy_roster_view_constructed (GObject *object)
{
EmpathyRosterView *self = EMPATHY_ROSTER_VIEW (object);
void (*chain_up) (GObject *) =
((GObjectClass *) empathy_roster_view_parent_class)->constructed;
if (chain_up != NULL)
chain_up (object);
g_assert (EMPATHY_IS_ROSTER_MODEL (self->priv->model));
/* Get saved group states. */
empathy_contact_groups_get_all ();
populate_view (self);
tp_g_signal_connect_object (self->priv->model, "individual-added",
G_CALLBACK (individual_added_cb), self, 0);
tp_g_signal_connect_object (self->priv->model, "individual-removed",
G_CALLBACK (individual_removed_cb), self, 0);
tp_g_signal_connect_object (self->priv->model, "groups-changed",
G_CALLBACK (groups_changed_cb), self, 0);
gtk_list_box_set_sort_func (GTK_LIST_BOX (self),
roster_view_sort, self, NULL);
gtk_list_box_set_header_func (GTK_LIST_BOX (self), update_header, self, NULL);
gtk_list_box_set_filter_func (GTK_LIST_BOX (self), filter_list, self, NULL);
gtk_list_box_set_activate_on_single_click (GTK_LIST_BOX (self), FALSE);
}
static void
show_filter_widgets (GtkWidget *chooser)
{
CcInputChooserPrivate *priv = GET_PRIVATE (chooser);
LocaleInfo *info;
GHashTableIter iter;
remove_all_children (GTK_CONTAINER (priv->list));
g_hash_table_iter_init (&iter, priv->locales);
while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &info))
add_input_source_widgets_for_locale (chooser, info);
gtk_widget_show_all (priv->list);
gtk_adjustment_set_value (priv->adjustment,
gtk_adjustment_get_lower (priv->adjustment));
gtk_list_box_set_header_func (GTK_LIST_BOX (priv->list),
update_header_func_filter, NULL, NULL);
gtk_list_box_set_selection_mode (GTK_LIST_BOX (priv->list), GTK_SELECTION_SINGLE);
gtk_list_box_set_placeholder (GTK_LIST_BOX (priv->list), priv->no_results);
if (gtk_widget_is_visible (priv->filter_entry))
gtk_widget_grab_focus (priv->filter_entry);
}
static void
photos_dlna_renderers_dialog_init (PhotosDlnaRenderersDialog *self)
{
GApplication *app;
GList *renderers;
PhotosSearchContextState *state;
app = g_application_get_default ();
state = photos_search_context_get_state (PHOTOS_SEARCH_CONTEXT (app));
self->item_mngr = g_object_ref (state->item_mngr);
self->renderers_mngr = photos_dlna_renderers_manager_dup_singleton ();
self->remote_mngr = photos_remote_display_manager_dup_singleton ();
self->mode_cntrlr = g_object_ref (state->mode_cntrlr);
gtk_widget_init_template (GTK_WIDGET (self));
gtk_list_box_set_header_func (self->listbox, photos_utils_list_box_header_func, NULL, NULL);
renderers = photos_dlna_renderers_manager_dup_renderers (self->renderers_mngr);
while (renderers != NULL)
{
PhotosDlnaRenderer *renderer = PHOTOS_DLNA_RENDERER (renderers->data);
photos_dlna_renderers_dialog_add_renderer (self, renderer);
renderers = g_list_delete_link (renderers, renderers);
g_object_unref (renderer);
}
g_signal_connect (self, "response", G_CALLBACK (gtk_widget_destroy), NULL);
}
gint
main (gint argc,
gchar *argv[])
{
g_autoptr (DummyProvider) dummy_provider = NULL;
GtdTaskModel *model = NULL;
GtkWidget *scrolledwindow = NULL;
GtkWindow *window = NULL;
GtkWidget *listbox = NULL;
g_set_prgname ("test-task-model");
g_set_application_name ("GNOME To Do | Task Model Test");
gtk_init ();
gtd_log_init ();
/* Create a DumbProvider and pre-populate it */
dummy_provider = dummy_provider_new ();
dummy_provider_generate_task_lists (dummy_provider);
/* Inject a dumb fake provider */
_gtd_manager_inject_provider (gtd_manager_get_default (), GTD_PROVIDER (dummy_provider));
/* Now create the model - the initial providers must be there already */
model = _gtd_task_model_new (gtd_manager_get_default ());
/* Listbox */
listbox = gtk_list_box_new ();
gtk_list_box_bind_model (GTK_LIST_BOX (listbox),
G_LIST_MODEL (model),
create_task_cb,
NULL,
NULL);
gtk_list_box_set_header_func (GTK_LIST_BOX (listbox), header_func, NULL, NULL);
/* Scrolled window */
scrolledwindow = g_object_new (GTK_TYPE_SCROLLED_WINDOW,
"propagate-natural-height", TRUE,
"max-content-height", 600,
"hscrollbar-policy", GTK_POLICY_NEVER,
NULL);
gtk_container_add (GTK_CONTAINER (scrolledwindow), listbox);
/* Window */
window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_TOPLEVEL));
gtk_window_set_default_size (window, 800, 600);
gtk_container_add (GTK_CONTAINER (window), scrolledwindow);
gtk_window_present (window);
/* Now, generate more tasks and lists after injecting to the manager */
dummy_provider_generate_task_lists (dummy_provider);
/* Schedule a live removal of tasks */
dummy_provider_schedule_remove_task (dummy_provider);
gtk_main ();
return 0;
}
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;
}
GtkWidget *
cc_search_locations_dialog_new (CcSearchPanel *self)
{
GtkWidget *locations_dialog, *widget, *list_box;
GtkBuilder *dialog_builder;
GError *error = NULL;
dialog_builder = gtk_builder_new ();
gtk_builder_add_from_resource (dialog_builder,
"/org/gnome/control-center/search/search-locations-dialog.ui",
&error);
if (error != NULL)
{
g_warning ("Could not load interface file: %s", error->message);
g_error_free (error);
return NULL;
}
tracker_preferences = g_settings_new (TRACKER_SCHEMA);
locations_dialog = GTK_WIDGET (gtk_builder_get_object (dialog_builder, "locations_dialog"));
widget = GTK_WIDGET (gtk_builder_get_object (dialog_builder, "locations_scrolledwindow"));
list_box = GTK_WIDGET (gtk_list_box_new ());
gtk_container_add (GTK_CONTAINER (widget), list_box);
gtk_list_box_set_sort_func (GTK_LIST_BOX (list_box),
(GtkListBoxSortFunc)place_compare_func, NULL, NULL);
gtk_list_box_set_header_func (GTK_LIST_BOX (list_box),
place_header_func, NULL, NULL);
gtk_widget_show (list_box);
widget = GTK_WIDGET (gtk_builder_get_object (dialog_builder, "locations_remove"));
gtk_widget_set_sensitive (widget, FALSE);
g_signal_connect (list_box, "row-selected",
G_CALLBACK (list_box_row_selected), widget);
g_signal_connect (widget, "clicked",
G_CALLBACK (remove_button_clicked), list_box);
g_signal_connect_swapped (tracker_preferences, "changed::" TRACKER_KEY_RECURSIVE_DIRECTORIES,
G_CALLBACK (locations_dialog_refresh), list_box);
widget = GTK_WIDGET (gtk_builder_get_object (dialog_builder, "locations_add"));
g_signal_connect (widget, "clicked",
G_CALLBACK (add_button_clicked), list_box);
gtk_window_set_transient_for (GTK_WINDOW (locations_dialog),
GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (self))));
g_signal_connect (locations_dialog, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (locations_dialog, "destroy",
G_CALLBACK (locations_dialog_destroy), NULL);
populate_list_box (list_box);
g_object_unref (dialog_builder);
return locations_dialog;
}
static void
show_locale_rows (GtkWidget *chooser)
{
CcInputChooserPrivate *priv = GET_PRIVATE (chooser);
GHashTable *initial = NULL;
LocaleInfo *info;
GHashTableIter iter;
remove_all_children (GTK_CONTAINER (priv->list));
if (!priv->showing_extra)
initial = cc_common_language_get_initial_languages ();
g_hash_table_iter_init (&iter, priv->locales);
while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &info))
{
if (!info->default_input_source_row &&
!g_hash_table_size (info->layout_rows_by_id) &&
!g_hash_table_size (info->engine_rows_by_id))
continue;
if (!info->locale_row)
{
info->locale_row = g_object_ref_sink (locale_row_new (info->name));
g_object_set_data (G_OBJECT (info->locale_row), "locale-info", info);
if (!priv->showing_extra &&
!g_hash_table_contains (initial, info->id) &&
!is_current_locale (info->id))
g_object_set_data (G_OBJECT (info->locale_row), "is-extra", GINT_TO_POINTER (TRUE));
}
gtk_container_add (GTK_CONTAINER (priv->list), GTK_WIDGET (info->locale_row));
}
gtk_container_add (GTK_CONTAINER (priv->list), GTK_WIDGET (priv->more_row));
gtk_widget_show_all (priv->list);
gtk_adjustment_set_value (priv->adjustment,
gtk_adjustment_get_lower (priv->adjustment));
gtk_list_box_set_header_func (GTK_LIST_BOX (priv->list), cc_list_box_update_header_func, NULL, NULL);
gtk_list_box_invalidate_filter (GTK_LIST_BOX (priv->list));
gtk_list_box_set_selection_mode (GTK_LIST_BOX (priv->list), GTK_SELECTION_NONE);
gtk_list_box_set_activate_on_single_click (GTK_LIST_BOX (priv->list), TRUE);
if (gtk_widget_is_visible (priv->filter_entry) &&
!gtk_widget_is_focus (priv->filter_entry))
gtk_widget_grab_focus (priv->filter_entry);
if (!priv->showing_extra)
g_hash_table_destroy (initial);
}
static void
add_routes_section (CEPageIP4 *page)
{
GtkWidget *widget;
GtkWidget *frame;
GtkWidget *list;
gint i;
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder, "routes_section"));
frame = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (widget), frame);
page->routes_list = list = gtk_list_box_new ();
gtk_list_box_set_selection_mode (GTK_LIST_BOX (list), GTK_SELECTION_NONE);
gtk_list_box_set_header_func (GTK_LIST_BOX (list), cc_list_box_update_header_func, NULL, NULL);
gtk_list_box_set_sort_func (GTK_LIST_BOX (list), (GtkListBoxSortFunc)sort_first_last, NULL, NULL);
gtk_container_add (GTK_CONTAINER (frame), list);
page->auto_routes = GTK_SWITCH (gtk_builder_get_object (CE_PAGE (page)->builder, "auto_routes_switch"));
gtk_switch_set_active (page->auto_routes, !nm_setting_ip4_config_get_ignore_auto_routes (page->setting));
g_signal_connect (page->auto_routes, "notify::active", G_CALLBACK (switch_toggled), page);
add_section_toolbar (page, widget, G_CALLBACK (add_empty_route_row));
for (i = 0; i < nm_setting_ip4_config_get_num_routes (page->setting); i++) {
NMIP4Route *route;
struct in_addr tmp_addr;
gchar address[INET_ADDRSTRLEN + 1];
gchar netmask[INET_ADDRSTRLEN + 1];
gchar gateway[INET_ADDRSTRLEN + 1];
gint metric;
route = nm_setting_ip4_config_get_route (page->setting, i);
if (!route)
continue;
tmp_addr.s_addr = nm_ip4_route_get_dest (route);
(void) inet_ntop (AF_INET, &tmp_addr, &address[0], sizeof (address));
tmp_addr.s_addr = nm_utils_ip4_prefix_to_netmask (nm_ip4_route_get_prefix (route));
(void) inet_ntop (AF_INET, &tmp_addr, &netmask[0], sizeof (netmask));
tmp_addr.s_addr = nm_ip4_route_get_next_hop (route);
(void) inet_ntop (AF_INET, &tmp_addr, &gateway[0], sizeof (gateway));
metric = nm_ip4_route_get_metric (route);
add_route_row (page, address, netmask, gateway, metric);
}
if (nm_setting_ip4_config_get_num_routes (page->setting) == 0)
add_empty_route_row (page);
gtk_widget_show_all (widget);
}
static void
gs_update_list_init (GsUpdateList *update_list)
{
GsUpdateListPrivate *priv = GET_PRIV (update_list);
priv->sizegroup_image = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->sizegroup_name = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
gtk_list_box_set_header_func (GTK_LIST_BOX (update_list),
list_header_func,
update_list, NULL);
gtk_list_box_set_sort_func (GTK_LIST_BOX (update_list),
list_sort_func,
update_list, NULL);
}
static void
cc_language_chooser_constructed (GObject *object)
{
GtkBuilder *builder;
CcLanguageChooser *chooser = CC_LANGUAGE_CHOOSER (object);
CcLanguageChooserPrivate *priv = chooser->priv;
GError *error = NULL;
G_OBJECT_CLASS (cc_language_chooser_parent_class)->constructed (object);
builder = gtk_builder_new ();
if (gtk_builder_add_from_resource (builder, "/org/gnome/control-center/language-chooser.ui", &error) == 0) {
g_object_unref (builder);
g_warning ("failed to load language chooser: %s", error->message);
g_error_free (error);
return;
}
gtk_container_add (GTK_CONTAINER (chooser), WID ("language-chooser"));
priv->filter_entry = WID ("language-filter-entry");
priv->language_list = WID ("language-list");
priv->more_item = more_widget_new ();
priv->no_results = no_results_widget_new ();
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_header_func (GTK_LIST_BOX (priv->language_list),
update_header_func, chooser, NULL);
gtk_list_box_set_selection_mode (GTK_LIST_BOX (priv->language_list),
GTK_SELECTION_NONE);
add_all_languages (chooser);
g_signal_connect (priv->filter_entry, "changed",
G_CALLBACK (filter_changed),
chooser);
g_signal_connect (priv->language_list, "row-activated",
G_CALLBACK (row_activated), chooser);
if (priv->language == NULL)
priv->language = cc_common_language_get_current_language ();
sync_all_checkmarks (chooser);
g_object_unref (builder);
}
static void
add_address_section (CEPageIP6 *page)
{
GtkWidget *widget;
GtkWidget *frame;
GtkWidget *list;
gint i;
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder, "address_section"));
frame = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (widget), frame);
page->address_list = list = gtk_list_box_new ();
gtk_list_box_set_selection_mode (GTK_LIST_BOX (list), GTK_SELECTION_NONE);
gtk_list_box_set_header_func (GTK_LIST_BOX (list), update_header, NULL, NULL);
gtk_list_box_set_sort_func (GTK_LIST_BOX (list), (GtkListBoxSortFunc)sort_first_last, NULL, NULL);
gtk_container_add (GTK_CONTAINER (frame), list);
add_section_toolbar (page, widget, G_CALLBACK (add_empty_address_row));
for (i = 0; i < nm_setting_ip6_config_get_num_addresses (page->setting); i++) {
NMIP6Address *addr;
const struct in6_addr *tmp_addr;
gchar address[INET6_ADDRSTRLEN + 1];
gchar network[INET6_ADDRSTRLEN + 1];
gchar gateway[INET6_ADDRSTRLEN + 1];
addr = nm_setting_ip6_config_get_address (page->setting, i);
if (!addr)
continue;
tmp_addr = nm_ip6_address_get_address (addr);
(void) inet_ntop (AF_INET6, tmp_addr, &address[0], sizeof (address));
snprintf (network, sizeof (network), "%u", nm_ip6_address_get_prefix (addr));
tmp_addr = nm_ip6_address_get_gateway (addr);
if (tmp_addr && !IN6_IS_ADDR_UNSPECIFIED (tmp_addr))
(void) inet_ntop (AF_INET6, tmp_addr, &gateway[0], sizeof (gateway));
else
gateway[0] = '\0';
add_address_row (page, address, network, gateway);
}
if (nm_setting_ip6_config_get_num_addresses (page->setting) == 0)
add_empty_address_row (page);
gtk_widget_show_all (widget);
}
static void
setup_listbox (CcDateTimePanel *self,
GtkWidget *listbox)
{
CcDateTimePanelPrivate *priv = self->priv;
gtk_list_box_set_header_func (GTK_LIST_BOX (listbox), cc_list_box_update_header_func, NULL, NULL);
g_signal_connect (listbox, "row-activated",
G_CALLBACK (list_box_row_activated), self);
g_signal_connect (listbox, "keynav-failed",
G_CALLBACK (keynav_failed), self);
priv->listboxes = g_list_append (priv->listboxes, listbox);
priv->listboxes_reverse = g_list_prepend (priv->listboxes_reverse, listbox);
}
static void
add_address_section (CEPageIP4 *page)
{
GtkWidget *widget;
GtkWidget *frame;
GtkWidget *list;
gint i;
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder, "address_section"));
frame = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (widget), frame);
page->address_list = list = gtk_list_box_new ();
gtk_list_box_set_selection_mode (GTK_LIST_BOX (list), GTK_SELECTION_NONE);
gtk_list_box_set_header_func (GTK_LIST_BOX (list), cc_list_box_update_header_func, NULL, NULL);
gtk_list_box_set_sort_func (GTK_LIST_BOX (list), (GtkListBoxSortFunc)sort_first_last, NULL, NULL);
gtk_container_add (GTK_CONTAINER (frame), list);
add_section_toolbar (page, widget, G_CALLBACK (add_empty_address_row));
for (i = 0; i < nm_setting_ip4_config_get_num_addresses (page->setting); i++) {
NMIP4Address *addr;
struct in_addr tmp_addr;
gchar address[INET_ADDRSTRLEN + 1];
gchar network[INET_ADDRSTRLEN + 1];
gchar gateway[INET_ADDRSTRLEN + 1];
addr = nm_setting_ip4_config_get_address (page->setting, i);
if (!addr)
continue;
tmp_addr.s_addr = nm_ip4_address_get_address (addr);
(void) inet_ntop (AF_INET, &tmp_addr, &address[0], sizeof (address));
tmp_addr.s_addr = nm_utils_ip4_prefix_to_netmask (nm_ip4_address_get_prefix (addr));
(void) inet_ntop (AF_INET, &tmp_addr, &network[0], sizeof (network));
tmp_addr.s_addr = nm_ip4_address_get_gateway (addr);
(void) inet_ntop (AF_INET, &tmp_addr, &gateway[0], sizeof (gateway));
add_address_row (page, address, network, gateway);
}
if (nm_setting_ip4_config_get_num_addresses (page->setting) == 0)
add_empty_address_row (page);
gtk_widget_show_all (widget);
}
static void
gs_update_list_init (GsUpdateList *update_list)
{
GsUpdateListPrivate *priv = gs_update_list_get_instance_private (update_list);
priv->sizegroup_image = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->sizegroup_name = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->sizegroup_button = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->sizegroup_header = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);
gtk_list_box_set_header_func (GTK_LIST_BOX (update_list),
list_header_func,
update_list, NULL);
gtk_list_box_set_sort_func (GTK_LIST_BOX (update_list),
list_sort_func,
update_list, NULL);
/* set each section count to zero */
for (guint i = 0; i < GS_UPDATE_LIST_SECTION_LAST; i++)
priv->sections_cnt[i] = 0;
}
static void
device_ethernet_constructed (GObject *object)
{
NetDeviceEthernet *device = NET_DEVICE_ETHERNET (object);
NMClient *client;
GtkWidget *list;
GtkWidget *swin;
GtkWidget *widget;
widget = GTK_WIDGET (gtk_builder_get_object (device->builder,
"device_off_switch"));
g_signal_connect (widget, "notify::active",
G_CALLBACK (device_off_toggled), device);
device->scrolled_window = swin = GTK_WIDGET (gtk_builder_get_object (device->builder, "list"));
device->list = list = GTK_WIDGET (gtk_list_box_new ());
gtk_list_box_set_selection_mode (GTK_LIST_BOX (list), GTK_SELECTION_NONE);
gtk_list_box_set_header_func (GTK_LIST_BOX (list), cc_list_box_update_header_func, NULL, NULL);
gtk_container_add (GTK_CONTAINER (swin), list);
g_signal_connect (list, "row-activated",
G_CALLBACK (connection_activated), device);
gtk_widget_show (list);
device->details = GTK_WIDGET (gtk_builder_get_object (device->builder, "details"));
device->details_button = GTK_WIDGET (gtk_builder_get_object (device->builder, "details_button"));
g_signal_connect (device->details_button, "clicked",
G_CALLBACK (show_details_for_wired), device);
device->add_profile_button = GTK_WIDGET (gtk_builder_get_object (device->builder, "add_profile_button"));
g_signal_connect (device->add_profile_button, "clicked",
G_CALLBACK (add_profile), device);
client = net_object_get_client (NET_OBJECT (object));
g_signal_connect (client, NM_CLIENT_CONNECTION_ADDED,
G_CALLBACK (client_connection_added_cb), object);
g_signal_connect_object (client, NM_CLIENT_CONNECTION_REMOVED,
G_CALLBACK (connection_removed), device, 0);
device_ethernet_refresh_ui (device);
}
static void
seahorse_keyserver_results_constructed (GObject *obj)
{
SeahorseKeyserverResults *self = SEAHORSE_KEYSERVER_RESULTS (obj);
GtkWindow *window = GTK_WINDOW (self);
g_autofree gchar* title = NULL;
G_OBJECT_CLASS (seahorse_keyserver_results_parent_class)->constructed (obj);
if (g_utf8_strlen (self->search_string, -1) == 0) {
title = g_strdup (_("Remote keys"));
} else {
title = g_strdup_printf (_("Remote keys containing “%s”"), self->search_string);
}
gtk_window_set_default_size (window, 640, 476);
gtk_window_set_title (window, title);
gtk_widget_set_visible (GTK_WIDGET (window), TRUE);
g_signal_connect (window, "delete-event",
G_CALLBACK (on_delete_event), self);
self->builder = gtk_builder_new_from_resource ("/org/gnome/Seahorse/seahorse-keyserver-results.ui");
gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (self))),
GTK_WIDGET (gtk_builder_get_object (self->builder, "keyserver-results")));
/* init key list */
self->key_list = GTK_LIST_BOX (gtk_builder_get_object (self->builder, "key_list"));
gtk_list_box_set_header_func (self->key_list, key_list_header_func, NULL, NULL);
g_signal_connect_object (self->key_list, "row-activated",
G_CALLBACK (on_row_activated), self, 0);
gtk_widget_show (GTK_WIDGET (self->key_list));
/* Make sure the listbox gets updated with the collection */
g_signal_connect_object (self->collection, "added",
G_CALLBACK (on_item_added), self, 0);
/* Set focus to the current key list */
gtk_widget_grab_focus (GTK_WIDGET (self->key_list));
}
static void
gis_goa_page_constructed (GObject *object)
{
GisGoaPage *page = GIS_GOA_PAGE (object);
GisGoaPagePrivate *priv = gis_goa_page_get_instance_private (page);
GError *error = NULL;
GNetworkMonitor *network_monitor = g_network_monitor_get_default ();
G_OBJECT_CLASS (gis_goa_page_parent_class)->constructed (object);
gis_page_set_skippable (GIS_PAGE (page), TRUE);
priv->providers = g_hash_table_new (g_str_hash, g_str_equal);
priv->goa_client = goa_client_new_sync (NULL, &error);
if (priv->goa_client == NULL) {
g_warning ("Failed to get a GoaClient: %s", error->message);
g_error_free (error);
return;
}
g_signal_connect (priv->goa_client, "account-added",
G_CALLBACK (accounts_changed), page);
g_signal_connect (priv->goa_client, "account-removed",
G_CALLBACK (accounts_changed), page);
g_signal_connect (network_monitor, "network-changed",
G_CALLBACK (network_status_changed), page);
gtk_list_box_set_header_func (GTK_LIST_BOX (priv->accounts_list),
update_header_func,
NULL, NULL);
g_signal_connect (priv->accounts_list, "row-activated",
G_CALLBACK (row_activated), page);
populate_provider_list (page);
sync_accounts (page);
}
static void
add_dns_section (CEPageIP6 *page)
{
GtkWidget *widget;
GtkWidget *frame;
GtkWidget *list;
gint i;
widget = GTK_WIDGET (gtk_builder_get_object (CE_PAGE (page)->builder, "dns_section"));
frame = gtk_frame_new (NULL);
gtk_container_add (GTK_CONTAINER (widget), frame);
page->dns_list = list = gtk_list_box_new ();
gtk_list_box_set_selection_mode (GTK_LIST_BOX (list), GTK_SELECTION_NONE);
gtk_list_box_set_header_func (GTK_LIST_BOX (list), update_header, NULL, NULL);
gtk_list_box_set_sort_func (GTK_LIST_BOX (list), (GtkListBoxSortFunc)sort_first_last, NULL, NULL);
gtk_container_add (GTK_CONTAINER (frame), list);
page->auto_dns = GTK_SWITCH (gtk_builder_get_object (CE_PAGE (page)->builder, "auto_dns_switch"));
gtk_switch_set_active (page->auto_dns, !nm_setting_ip6_config_get_ignore_auto_dns (page->setting));
g_signal_connect (page->auto_dns, "notify::active", G_CALLBACK (switch_toggled), page);
add_section_toolbar (page, widget, G_CALLBACK (add_empty_dns_row));
for (i = 0; i < nm_setting_ip6_config_get_num_dns (page->setting); i++) {
const struct in6_addr *tmp_addr;
gchar address[INET6_ADDRSTRLEN + 1];
tmp_addr = nm_setting_ip6_config_get_dns (page->setting, i);
(void) inet_ntop (AF_INET, tmp_addr, &address[0], sizeof (address));
add_dns_row (page, address);
}
if (nm_setting_ip6_config_get_num_dns (page->setting) == 0)
add_empty_dns_row (page);
gtk_widget_show_all (widget);
}
static void
gcal_year_view_init (GcalYearView *self)
{
self->priv = gcal_year_view_get_instance_private (self);
gtk_widget_init_template (GTK_WIDGET (self));
gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (self)), "calendar-view");
if (gtk_widget_get_direction (GTK_WIDGET (self)) == GTK_TEXT_DIR_LTR)
self->priv->k = 0;
else if (gtk_widget_get_direction (GTK_WIDGET (self)) == GTK_TEXT_DIR_RTL)
self->priv->k = 1;
self->priv->navigator_grid = g_new0 (GridData, 1);
self->priv->selected_data = g_new0 (ButtonData, 1);
self->priv->start_selected_date = g_new0 (icaltimetype, 1);
self->priv->start_selected_date->zone = e_cal_util_get_system_timezone ();
self->priv->end_selected_date = g_new0 (icaltimetype, 1);
self->priv->end_selected_date->zone = e_cal_util_get_system_timezone ();
gtk_list_box_set_header_func (GTK_LIST_BOX (self->priv->events_sidebar), update_sidebar_headers, self, NULL);
gtk_list_box_set_sort_func (GTK_LIST_BOX (self->priv->events_sidebar), sidebar_sort_func, NULL, NULL);
}
static void
gis_network_page_constructed (GObject *object)
{
GisNetworkPage *page = GIS_NETWORK_PAGE (object);
GisNetworkPagePrivate *priv = gis_network_page_get_instance_private (page);
const GPtrArray *devices;
NMDevice *device;
guint i;
gboolean visible = FALSE;
G_OBJECT_CLASS (gis_network_page_parent_class)->constructed (object);
priv->icons = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->nm_client = nm_client_new ();
g_object_bind_property (priv->nm_client, "wireless-enabled",
priv->turn_on_switch, "active",
G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
devices = nm_client_get_devices (priv->nm_client);
if (devices) {
for (i = 0; i < devices->len; i++) {
device = g_ptr_array_index (devices, i);
if (!nm_device_get_managed (device))
continue;
if (nm_device_get_device_type (device) == NM_DEVICE_TYPE_WIFI) {
/* FIXME deal with multiple, dynamic devices */
priv->nm_device = g_object_ref (device);
break;
}
}
}
if (priv->nm_device == NULL) {
g_debug ("No network device found, hiding network page");
goto out;
}
if (nm_device_get_state (priv->nm_device) == NM_DEVICE_STATE_ACTIVATED) {
g_debug ("Activated network device found, hiding network page");
goto out;
}
visible = TRUE;
priv->nm_settings = nm_remote_settings_new (NULL);
g_signal_connect (priv->nm_device, "notify::state",
G_CALLBACK (device_state_changed), page);
g_signal_connect (priv->nm_client, "notify::active-connections",
G_CALLBACK (active_connections_changed), page);
gtk_list_box_set_selection_mode (GTK_LIST_BOX (priv->network_list), GTK_SELECTION_NONE);
gtk_list_box_set_header_func (GTK_LIST_BOX (priv->network_list), update_header_func, NULL, NULL);
gtk_list_box_set_sort_func (GTK_LIST_BOX (priv->network_list), ap_sort, NULL, NULL);
g_signal_connect (priv->network_list, "row-activated",
G_CALLBACK (row_activated), page);
refresh_wireless_list (page);
sync_complete (page);
gis_page_set_skippable (GIS_PAGE (page), TRUE);
out:
gtk_widget_set_visible (GTK_WIDGET (page), visible);
}
static GtkWidget*
create_starter_widget (StarterPlugin* plugin)
{
GError *error;
GtkWidget *stack;
GtkWidget *switcher;
GtkWidget *starter_box;
GtkWidget *switcher_box;
GtkWidget *actions_frame;
GtkWidget *actions_listbox;
GtkWidget *recent_projects_box;
GtkWidget *recent_listbox;
GtkBuilder *builder;
GtkWidget *button;
error = NULL;
builder = gtk_builder_new ();
if (!gtk_builder_add_from_resource (builder, "/org/gnome/anjuta/ui/starter.ui", &error))
{
DEBUG_PRINT ("Could not load starter.ui! %s", error->message);
g_error_free (error);
}
else
{
/* Manually assembling stack and switcher because they are not available in glade yet */
switcher = gtk_stack_switcher_new ();
stack = gtk_stack_new ();
gtk_stack_switcher_set_stack (switcher, stack);
gtk_stack_set_transition_type (stack, GTK_STACK_TRANSITION_TYPE_CROSSFADE);
gtk_stack_set_transition_duration (stack, TRANSITION_TIME);
starter_box = GTK_WIDGET (gtk_builder_get_object (builder, STARTER_BOX));
switcher_box = GTK_WIDGET (gtk_builder_get_object (builder, SWITCHER_BOX));
gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (starter_box)), starter_box);
g_object_ref (starter_box);
gtk_box_pack_start (switcher_box, switcher, FALSE, FALSE, 0);
gtk_box_pack_start (starter_box, stack, FALSE, FALSE, 0);
gtk_widget_show_all (starter_box);
actions_listbox = GTK_WIDGET (gtk_builder_get_object (builder, ACTIONS_LISTBOX));
gtk_list_box_set_header_func (GTK_LIST_BOX (actions_listbox), add_action_separators, NULL, NULL);
actions_frame = GTK_WIDGET (gtk_builder_get_object (builder, ACTIONS_FRAME));
gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (actions_frame)), actions_frame);
g_object_ref (actions_frame);
gtk_stack_add_titled (stack, actions_frame, ACTIONS_ID, "Actions");
recent_projects_box = GTK_WIDGET (gtk_builder_get_object (builder, RECENT_PROJECTS_BOX));
gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (recent_projects_box)), recent_projects_box);
g_object_ref (recent_projects_box);
recent_listbox = GTK_WIDGET (gtk_builder_get_object (builder, RECENT_LISTBOX));
refresh_recent_project_view (GTK_LIST_BOX (recent_listbox));
gtk_stack_add_titled (stack, recent_projects_box, RECENT_PROJECTS_ID, "Recent Projects");
button = GTK_WIDGET (gtk_builder_get_object (builder, REMOVE_PROJECT_BUTTON));
g_signal_connect_object (G_OBJECT (button), "clicked",
G_CALLBACK (on_remove_project_clicked), recent_listbox, G_CONNECT_AFTER);
gtk_builder_connect_signals (builder, plugin);
}
g_object_unref (builder);
return starter_box;
}
/* Set up the property editors in the dialog. */
static void
setup_dialog (CcMousePropertiesPrivate *d)
{
GtkWidget *button;
d->left_handed = g_settings_get_boolean (d->mouse_settings, "left-handed");
button = WID (d->left_handed ? "primary-button-right" : "primary-button-left");
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
g_settings_bind (d->mouse_settings, "left-handed",
WID ("primary-button-left"), "active",
G_SETTINGS_BIND_DEFAULT | G_SETTINGS_BIND_INVERT_BOOLEAN);
g_settings_bind (d->mouse_settings, "left-handed",
WID ("primary-button-right"), "active",
G_SETTINGS_BIND_DEFAULT);
/* Allow changing orientation with either button */
button = WID ("primary-button-right");
d->right_gesture = gtk_gesture_multi_press_new (button);
handle_secondary_button (d, button, d->right_gesture);
button = WID ("primary-button-left");
d->left_gesture = gtk_gesture_multi_press_new (button);
handle_secondary_button (d, button, d->left_gesture);
g_settings_bind (d->mouse_settings, "natural-scroll",
WID ("mouse-natural-scrolling-switch"), "active",
G_SETTINGS_BIND_DEFAULT);
gtk_list_box_set_header_func (GTK_LIST_BOX (WID ("general-listbox")), cc_list_box_update_header_func, NULL, NULL);
gtk_list_box_set_header_func (GTK_LIST_BOX (WID ("touchpad-listbox")), cc_list_box_update_header_func, NULL, NULL);
/* Mouse section */
gtk_widget_set_visible (WID ("mouse-frame"), d->have_mouse);
g_settings_bind (d->mouse_settings, "speed",
gtk_range_get_adjustment (GTK_RANGE (WID ("mouse-speed-scale"))), "value",
G_SETTINGS_BIND_DEFAULT);
gtk_list_box_set_header_func (GTK_LIST_BOX (WID ("mouse-listbox")), cc_list_box_update_header_func, NULL, NULL);
/* Touchpad section */
gtk_widget_set_visible (WID ("touchpad-toggle-switch"),
show_touchpad_enabling_switch (d));
g_settings_bind_with_mapping (d->touchpad_settings, "send-events",
WID ("touchpad-toggle-switch"), "active",
G_SETTINGS_BIND_DEFAULT,
touchpad_enabled_get_mapping,
touchpad_enabled_set_mapping,
NULL, NULL);
g_settings_bind_with_mapping (d->touchpad_settings, "send-events",
WID ("touchpad-options-listbox"), "sensitive",
G_SETTINGS_BIND_GET,
touchpad_enabled_get_mapping,
touchpad_enabled_set_mapping,
NULL, NULL);
g_settings_bind (d->touchpad_settings, "natural-scroll",
WID ("touchpad-natural-scrolling-switch"), "active",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (d->touchpad_settings, "speed",
gtk_range_get_adjustment (GTK_RANGE (WID ("touchpad-speed-scale"))), "value",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (d->touchpad_settings, "tap-to-click",
WID ("tap-to-click-switch"), "active",
G_SETTINGS_BIND_DEFAULT);
setup_touchpad_options (d);
g_signal_connect (WID ("edge-scrolling-switch"), "state-set",
G_CALLBACK (edge_scrolling_changed_event), d);
g_signal_connect (WID ("two-finger-scrolling-switch"), "state-set",
G_CALLBACK (two_finger_scrolling_changed_event), d);
gtk_list_box_set_header_func (GTK_LIST_BOX (WID ("touchpad-options-listbox")), cc_list_box_update_header_func, NULL, NULL);
}
static void
populate_colors (GtkWidget *widget)
{
struct { const gchar *name; const gchar *color; const gchar *title; } colors[] = {
{ "2.5", "#C8828C", "Red" },
{ "5", "#C98286", NULL },
{ "7.5", "#C9827F", NULL },
{ "10", "#C98376", NULL },
{ "2.5", "#C8856D", "Red/Yellow" },
{ "5", "#C58764", NULL },
{ "7.5", "#C1895E", NULL },
{ "10", "#BB8C56", NULL },
{ "2.5", "#B58F4F", "Yellow" },
{ "5", "#AD924B", NULL },
{ "7.5", "#A79548", NULL },
{ "10", "#A09749", NULL },
{ "2.5", "#979A4E", "Yellow/Green" },
{ "5", "#8D9C55", NULL },
{ "7.5", "#7F9F62", NULL },
{ "10", "#73A06E", NULL },
{ "2.5", "#65A27C", "Green" },
{ "5", "#5CA386", NULL },
{ "7.5", "#57A38D", NULL },
{ "10", "#52A394", NULL },
{ "2.5", "#4EA39A", "Green/Blue" },
{ "5", "#49A3A2", NULL },
{ "7.5", "#46A2AA", NULL },
{ "10", "#46A1B1", NULL },
{ "2.5", "#49A0B8", "Blue" },
{ "5", "#529EBD", NULL },
{ "7.5", "#5D9CC1", NULL },
{ "10", "#689AC3", NULL },
{ "2.5", "#7597C5", "Blue/Purple" },
{ "5", "#8095C6", NULL },
{ "7.5", "#8D91C6", NULL },
{ "10", "#988EC4", NULL },
{ "2.5", "#A08CC1", "Purple" },
{ "5", "#A88ABD", NULL },
{ "7.5", "#B187B6", NULL },
{ "10", "#B786B0", NULL },
{ "2.5", "#BC84A9", "Purple/Red" },
{ "5", "#C183A0", NULL },
{ "7.5", "#C48299", NULL },
{ "10", "#C68292", NULL }
};
gint i;
GtkWidget *row, *box, *label, *swatch;
GtkWidget *sw;
GdkRGBA rgba;
gtk_list_box_set_header_func (GTK_LIST_BOX (widget), update_title_header, NULL, NULL);
for (i = 0; i < G_N_ELEMENTS (colors); i++)
{
row = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 20);
label = gtk_label_new (colors[i].name);
g_object_set (label,
"halign", GTK_ALIGN_START,
"valign", GTK_ALIGN_CENTER,
"margin", 6,
"xalign", 0.0,
NULL);
gtk_box_pack_start (GTK_BOX (row), label, TRUE, TRUE, 0);
gdk_rgba_parse (&rgba, colors[i].color);
swatch = g_object_new (g_type_from_name ("GtkColorSwatch"),
"rgba", &rgba,
"selectable", FALSE,
"halign", GTK_ALIGN_END,
"valign", GTK_ALIGN_CENTER,
"margin", 6,
"height-request", 24,
NULL);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add (GTK_CONTAINER (box), swatch);
gtk_box_pack_start (GTK_BOX (row), box, FALSE, FALSE, 0);
gtk_widget_show_all (row);
gtk_list_box_insert (GTK_LIST_BOX (widget), row, -1);
row = gtk_widget_get_parent (row);
gtk_list_box_row_set_activatable (GTK_LIST_BOX_ROW (row), FALSE);
if (colors[i].title)
g_object_set_data (G_OBJECT (row), "title", (gpointer)colors[i].title);
}
gtk_list_box_invalidate_headers (GTK_LIST_BOX (widget));
sw = gtk_widget_get_ancestor (widget, GTK_TYPE_SCROLLED_WINDOW);
g_signal_connect (sw, "edge-overshot", G_CALLBACK (overshot), widget);
}
GtkWidget *
cc_format_chooser_new (GtkWidget *parent)
{
GtkBuilder *builder;
GtkWidget *chooser;
CcFormatChooserPrivate *priv;
GError *error = NULL;
builder = gtk_builder_new ();
if (gtk_builder_add_from_resource (builder, "/org/gnome/control-center/region/format-chooser.ui", &error) == 0) {
g_object_unref (builder);
g_warning ("failed to load format chooser: %s", error->message);
g_error_free (error);
return NULL;
}
chooser = WID ("dialog");
priv = g_new0 (CcFormatChooserPrivate, 1);
g_object_set_data_full (G_OBJECT (chooser), "private", priv, cc_format_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 ("region-filter-entry");
priv->list = WID ("region-list");
priv->scrolledwindow = WID ("region-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);
priv->full_date = WID ("full-date-format");
priv->medium_date = WID ("medium-date-format");
priv->short_date = WID ("short-date-format");
priv->time = WID ("time-format");
priv->number = WID ("number-format");
priv->measurement = WID ("measurement-format");
priv->paper = WID ("paper-format");
gtk_list_box_set_adjustment (GTK_LIST_BOX (priv->list),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (priv->scrolledwindow)));
gtk_list_box_set_sort_func (GTK_LIST_BOX (priv->list),
(GtkListBoxSortFunc)sort_regions, chooser, NULL);
gtk_list_box_set_filter_func (GTK_LIST_BOX (priv->list),
region_visible, chooser, NULL);
gtk_list_box_set_selection_mode (GTK_LIST_BOX (priv->list),
GTK_SELECTION_NONE);
gtk_list_box_set_header_func (GTK_LIST_BOX (priv->list),
cc_list_box_update_header_func, NULL, NULL);
add_all_regions (GTK_DIALOG (chooser));
g_signal_connect_swapped (priv->filter_entry, "search-changed",
G_CALLBACK (filter_changed), chooser);
g_signal_connect (priv->list, "row-activated",
G_CALLBACK (row_activated), chooser);
gtk_list_box_invalidate_filter (GTK_LIST_BOX (priv->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;
}
PpJobsDialog *
pp_jobs_dialog_new (GtkWindow *parent,
UserResponseCallback user_callback,
gpointer user_data,
gchar *printer_name)
{
PpJobsDialog *dialog;
GtkButton *clear_all_button;
GError *error = NULL;
gchar *objects[] = { "jobs-dialog", NULL };
guint builder_result;
gchar *title;
dialog = g_new0 (PpJobsDialog, 1);
dialog->builder = gtk_builder_new ();
dialog->parent = GTK_WIDGET (parent);
builder_result = gtk_builder_add_objects_from_resource (dialog->builder,
"/org/gnome/control-center/printers/jobs-dialog.ui",
objects, &error);
if (builder_result == 0)
{
g_warning ("Could not load ui: %s", error->message);
g_error_free (error);
return NULL;
}
dialog->dialog = (GtkWidget *) gtk_builder_get_object (dialog->builder, "jobs-dialog");
dialog->user_callback = user_callback;
dialog->user_data = user_data;
dialog->printer_name = g_strdup (printer_name);
dialog->ref_count = 0;
/* connect signals */
g_signal_connect (dialog->dialog, "delete-event", G_CALLBACK (gtk_widget_hide_on_delete), NULL);
g_signal_connect (dialog->dialog, "response", G_CALLBACK (jobs_dialog_response_cb), dialog);
clear_all_button = GTK_BUTTON (gtk_builder_get_object (dialog->builder, "jobs-clear-all-button"));
g_signal_connect (clear_all_button, "clicked", G_CALLBACK (on_clear_all_button_clicked), dialog);
/* Translators: This is the printer name for which we are showing the active jobs */
title = g_strdup_printf (C_("Printer jobs dialog title", "%s — Active Jobs"), printer_name);
gtk_window_set_title (GTK_WINDOW (dialog->dialog), title);
g_free (title);
dialog->listbox = GTK_LIST_BOX (gtk_builder_get_object (dialog->builder, "jobs-listbox"));
gtk_list_box_set_header_func (dialog->listbox,
cc_list_box_update_header_func, NULL, NULL);
dialog->store = g_list_store_new (pp_job_get_type ());
gtk_list_box_bind_model (dialog->listbox, G_LIST_MODEL (dialog->store),
create_listbox_row, NULL, NULL);
update_jobs_list (dialog);
gtk_window_set_transient_for (GTK_WINDOW (dialog->dialog), GTK_WINDOW (parent));
gtk_window_present (GTK_WINDOW (dialog->dialog));
gtk_widget_show_all (GTK_WIDGET (dialog->dialog));
return dialog;
}
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_setup_media_sharing_dialog (CcSharingPanel *self)
{
CcSharingPanelPrivate *priv = self->priv;
gchar **folders, **list;
GtkWidget *box, *networks, *grid, *w;
char *path;
path = g_find_program_in_path ("rygel");
if (path == NULL)
{
gtk_widget_hide (WID ("media-sharing-button"));
return;
}
g_free (path);
g_signal_connect (WID ("media-sharing-dialog"), "response",
G_CALLBACK (cc_sharing_panel_media_sharing_dialog_response),
self);
cc_media_sharing_get_preferences (&folders);
box = WID ("shared-folders-listbox");
gtk_list_box_set_header_func (GTK_LIST_BOX (box),
cc_list_box_update_header_func, NULL,
NULL);
cc_list_box_setup_scrolling (GTK_LIST_BOX (box), 3);
list = folders;
while (list && *list)
{
GtkWidget *row;
row = cc_sharing_panel_new_media_sharing_row (*list, self);
gtk_list_box_insert (GTK_LIST_BOX (box), row, -1);
list++;
}
gtk_list_box_insert (GTK_LIST_BOX (box),
cc_sharing_panel_new_add_media_sharing_row (self), -1);
cc_list_box_adjust_scrolling (GTK_LIST_BOX (box));
g_signal_connect (G_OBJECT (box), "row-activated",
G_CALLBACK (cc_sharing_panel_add_folder), self);
g_strfreev (folders);
networks = cc_sharing_networks_new (self->priv->sharing_proxy, "rygel");
grid = WID ("grid4");
gtk_grid_attach (GTK_GRID (grid), networks, 0, 4, 2, 1);
gtk_widget_show (networks);
w = cc_sharing_switch_new (networks);
gtk_header_bar_pack_start (GTK_HEADER_BAR (WID ("media-sharing-headerbar")), w);
self->priv->media_sharing_switch = w;
cc_sharing_panel_bind_networks_to_label (self, networks,
WID ("media-sharing-status-label"));
}
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"));
}
