void dialogs_init(GtkBuilder *builder)
{
GtkWidget *tmp, *tmp2;
dialogs.about = GTK_WIDGET(gtk_builder_get_object(builder, "About_dialog"));
dialogs.saveas = GTK_WIDGET(gtk_builder_get_object(builder, "saveas_dialog"));
dialogs.connect = GTK_WIDGET(gtk_builder_get_object(builder, "connect_dialog"));
dialogs.connect_fru = GTK_WIDGET(gtk_builder_get_object(builder, "fru_info"));
dialogs.serial_num = GTK_WIDGET(gtk_builder_get_object(builder, "serial_number_popup"));
dialogs.connect_iio = GTK_WIDGET(gtk_builder_get_object(builder, "connect_iio_devices"));
dialogs.load_save_profile = GTK_WIDGET(gtk_builder_get_object(builder, "load_save_profile"));
gtk_builder_connect_signals(builder, &dialogs);
save_csv = GTK_WIDGET(gtk_builder_get_object(builder, "save_csv"));
save_vsa = GTK_WIDGET(gtk_builder_get_object(builder, "save_vsa"));
save_mat = GTK_WIDGET(gtk_builder_get_object(builder, "save_MATLAB"));
save_mat_scale = GTK_WIDGET(gtk_builder_get_object(builder, "save_mat_scale"));
/* Bind some dialogs radio buttons to text/labels */
tmp2 = GTK_WIDGET(gtk_builder_get_object(builder, "connect_net"));
tmp = GTK_WIDGET(gtk_builder_get_object(builder, "connect_net_label"));
serial_num = GTK_WIDGET(gtk_builder_get_object(builder, "serial_number"));
fru_date = GTK_WIDGET(gtk_builder_get_object(builder, "fru_date"));
fru_file_list = GTK_WIDGET(gtk_builder_get_object(builder, "FRU_files"));
g_object_bind_property(tmp2, "active", tmp, "sensitive", 0);
tmp = GTK_WIDGET(gtk_builder_get_object(builder, "connect_net_IP"));
g_object_bind_property(tmp2, "active", tmp, "sensitive", 0);
}
GstElement * _owr_payload_create_payload_packetizer(OwrPayload *payload)
{
GstElement * pay = NULL;
gchar *element_name = NULL;
OwrMediaType media_type;
g_return_val_if_fail(payload, NULL);
element_name = g_strdup_printf("pay_%s_%u", OwrCodecTypePayElementName[payload->priv->codec_type], get_unique_id());
pay = gst_element_factory_make(OwrCodecTypePayElementName[payload->priv->codec_type], element_name);
g_free(element_name);
g_object_bind_property(payload, "mtu", pay, "mtu", G_BINDING_SYNC_CREATE);
g_object_get(payload, "media-type", &media_type, NULL);
switch (media_type) {
case OWR_MEDIA_TYPE_AUDIO:
if (OWR_IS_AUDIO_PAYLOAD(payload)) {
g_object_bind_property(OWR_AUDIO_PAYLOAD(payload), "ptime", pay, "min-ptime", G_BINDING_SYNC_CREATE);
g_object_bind_property(OWR_AUDIO_PAYLOAD(payload), "ptime", pay, "max-ptime", G_BINDING_SYNC_CREATE);
}
break;
case OWR_MEDIA_TYPE_VIDEO:
if (payload->priv->codec_type == OWR_CODEC_TYPE_H264)
g_object_set(pay, "config-interval", 1, NULL);
break;
default:
g_warn_if_reached();
}
return pay;
}
static GtkWidget *
build_tab_label (EphyNotebook *nb, EphyEmbed *embed)
{
GtkWidget *tab_label;
EphyWebView *view;
tab_label = ephy_tab_label_new ();
g_signal_connect (tab_label, "close-clicked", G_CALLBACK (close_button_clicked_cb), embed);
/* Set up drag-and-drop target */
g_signal_connect (tab_label, "drag-data-received",
G_CALLBACK (notebook_drag_data_received_cb), embed);
gtk_drag_dest_set (tab_label, GTK_DEST_DEFAULT_ALL,
url_drag_types, G_N_ELEMENTS (url_drag_types),
GDK_ACTION_MOVE | GDK_ACTION_COPY);
gtk_drag_dest_add_text_targets (tab_label);
/* Hook the label up to the tab properties */
view = ephy_embed_get_web_view (embed);
g_signal_connect_object (embed, "notify::title",
G_CALLBACK (rebuild_tab_menu_cb), nb, 0);
g_object_bind_property (view, "title", tab_label, "label-text", G_BINDING_DEFAULT);
g_object_bind_property (view, "display-address", tab_label, "label-uri", G_BINDING_DEFAULT);
g_object_bind_property (view, "icon", tab_label, "icon-buf", G_BINDING_DEFAULT);
g_object_bind_property (view, "is-loading", tab_label, "spinning", G_BINDING_DEFAULT);
g_object_bind_property (view, "is-playing-audio", tab_label, "audio", G_BINDING_DEFAULT);
return tab_label;
}
static void
gis_account_page_constructed (GObject *object)
{
GisAccountPage *page = GIS_ACCOUNT_PAGE (object);
GisAccountPagePrivate *priv = gis_account_page_get_instance_private (page);
G_OBJECT_CLASS (gis_account_page_parent_class)->constructed (object);
g_signal_connect (priv->page_local, "validation-changed",
G_CALLBACK (on_validation_changed), page);
g_signal_connect (priv->page_local, "user-created",
G_CALLBACK (on_local_user_created), page);
g_signal_connect (priv->page_local, "confirm",
G_CALLBACK (on_local_page_confirmed), page);
g_signal_connect (priv->page_enterprise, "validation-changed",
G_CALLBACK (on_validation_changed), page);
g_signal_connect (priv->page_enterprise, "user-cached",
G_CALLBACK (on_local_user_cached), page);
update_page_validation (page);
g_signal_connect (priv->page_toggle, "toggled", G_CALLBACK (toggle_mode), page);
g_object_bind_property (page, "applying", priv->page_toggle, "sensitive", G_BINDING_INVERT_BOOLEAN);
g_object_bind_property (priv->page_enterprise, "visible", priv->page_toggle, "visible", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
/* force a refresh by setting to an invalid value */
priv->mode = NUM_MODES;
set_mode (page, UM_LOCAL);
gtk_widget_show (GTK_WIDGET (page));
}
static void
update_bindings (AthenaNavigationState *self)
{
gint length, idx;
GBinding *binding;
GtkAction *master_action, *slave_action;
length = g_strv_length (self->priv->action_names);
for (idx = 0; idx < length; idx++) {
master_action = gtk_action_group_get_action (self->priv->master,
self->priv->action_names[idx]);
slave_action = gtk_action_group_get_action (self->priv->slave,
self->priv->action_names[idx]);
binding = g_object_bind_property (master_action, "sensitive",
slave_action, "sensitive",
G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
/* bind "active" too for toggle actions */
if (GTK_IS_TOGGLE_ACTION (master_action)) {
binding = g_object_bind_property (master_action, "active",
slave_action, "active",
G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
}
self->priv->active_bindings = g_list_prepend (self->priv->active_bindings, binding);
}
}
static void
setup_search (GtkAppChooserDialog *self)
{
gboolean use_header;
g_object_get (self, "use-header-bar", &use_header, NULL);
if (use_header)
{
GtkWidget *button;
GtkWidget *image;
GtkWidget *header;
button = gtk_toggle_button_new ();
gtk_widget_set_valign (button, GTK_ALIGN_CENTER);
image = gtk_image_new_from_icon_name ("edit-find-symbolic", GTK_ICON_SIZE_MENU);
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (button), image);
gtk_style_context_add_class (gtk_widget_get_style_context (button), "image-button");
gtk_style_context_remove_class (gtk_widget_get_style_context (button), "text-button");
gtk_widget_show (button);
header = gtk_dialog_get_header_bar (GTK_DIALOG (self));
gtk_header_bar_pack_end (GTK_HEADER_BAR (header), button);
g_object_bind_property (button, "active",
self->priv->search_bar, "search-mode-enabled",
G_BINDING_BIDIRECTIONAL);
g_object_bind_property (self->priv->search_entry, "sensitive",
button, "sensitive",
G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
}
}
static void
mex_content_tile_set_content (MexContentView *view,
MexContent *content)
{
MexContentTile *tile = MEX_CONTENT_TILE (view);
MexContentTilePrivate *priv = tile->priv;
const gchar *label_prop_name, *secondary_label_prop_name;
if (priv->content == content)
return;
if (priv->changed_id)
{
g_signal_handler_disconnect (priv->content, priv->changed_id);
priv->changed_id = 0;
}
if (priv->content)
{
g_object_unref (priv->content);
priv->content = NULL;
}
if (!content)
return;
priv->content = g_object_ref_sink (content);
/* Update title/thumbnail display */
label_prop_name = mex_content_get_property_name (priv->content,
MEX_CONTENT_METADATA_TITLE);
secondary_label_prop_name =
mex_content_get_property_name (priv->content,
MEX_CONTENT_METADATA_ARTIST);
g_object_bind_property (content, label_prop_name,
tile, "label",
G_BINDING_SYNC_CREATE);
if (secondary_label_prop_name)
{
g_object_bind_property (content, secondary_label_prop_name,
tile, "secondary-label",
G_BINDING_SYNC_CREATE);
}
_update_logo (tile);
_reset_thumbnail (tile);
/* TODO: use g_object_bind_property */
priv->changed_id = g_signal_connect (priv->content,
"notify",
G_CALLBACK (_content_notify),
view);
}
static void
gtk_menu_section_box_insert_func (GtkMenuTrackerItem *item,
gint position,
gpointer user_data)
{
GtkMenuSectionBox *box = user_data;
GtkWidget *widget;
if (gtk_menu_tracker_item_get_is_separator (item))
{
widget = gtk_menu_section_box_new_section (item, box);
}
else if (gtk_menu_tracker_item_get_has_link (item, G_MENU_LINK_SUBMENU))
{
widget = g_object_new (GTK_TYPE_MODEL_BUTTON, "has-submenu", TRUE, NULL);
g_object_bind_property (item, "label", widget, "text", G_BINDING_SYNC_CREATE);
g_object_bind_property (item, "icon", widget, "icon", G_BINDING_SYNC_CREATE);
g_object_bind_property (item, "sensitive", widget, "sensitive", G_BINDING_SYNC_CREATE);
gtk_menu_section_box_new_submenu (item, box->toplevel, widget);
gtk_widget_show (widget);
}
else
{
widget = gtk_model_button_new ();
g_object_bind_property (item, "label", widget, "text", G_BINDING_SYNC_CREATE);
if (box->iconic)
{
g_object_bind_property (item, "verb-icon", widget, "icon", G_BINDING_SYNC_CREATE);
g_object_set (widget, "iconic", TRUE, "centered", TRUE, NULL);
}
else
g_object_bind_property (item, "icon", widget, "icon", G_BINDING_SYNC_CREATE);
g_object_bind_property (item, "sensitive", widget, "sensitive", G_BINDING_SYNC_CREATE);
g_object_bind_property (item, "role", widget, "action-role", G_BINDING_SYNC_CREATE);
g_object_bind_property (item, "toggled", widget, "toggled", G_BINDING_SYNC_CREATE);
g_object_bind_property (item, "accel", widget, "accel", G_BINDING_SYNC_CREATE);
g_signal_connect (widget, "clicked", G_CALLBACK (gtk_popover_item_activate), item);
}
gtk_widget_show (widget);
g_object_set_data_full (G_OBJECT (widget), "GtkMenuTrackerItem", g_object_ref (item), g_object_unref);
gtk_widget_set_halign (widget, GTK_ALIGN_FILL);
if (box->iconic)
gtk_box_pack_start (GTK_BOX (box->item_box), widget, TRUE, TRUE, 0);
else
gtk_container_add (GTK_CONTAINER (box->item_box), widget);
gtk_box_reorder_child (GTK_BOX (box->item_box), widget, position);
gtk_menu_section_box_schedule_separator_sync (box);
}
static void
cc_ua_panel_init_hearing (CcUaPanel *self)
{
CcUaPanelPrivate *priv = self->priv;
GtkWidget *list;
GtkWidget *dialog;
list = WID ("list_hearing");
add_section (list, self);
add_separators (GTK_LIST_BOX (list));
g_signal_connect_swapped (list, "row-activated",
G_CALLBACK (activate_row), self);
/* set the initial visual bell values */
visual_bell_type_notify_cb (NULL, NULL, self);
/* and listen */
g_settings_bind (priv->wm_settings, KEY_VISUAL_BELL_ENABLED,
WID ("visual_alerts_switch"), "active",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind_with_mapping (priv->wm_settings, KEY_VISUAL_BELL_ENABLED,
WID ("value_visual_alerts"),
"label", G_SETTINGS_BIND_GET,
on_off_label_mapping_get,
NULL, NULL, NULL);
g_object_bind_property (WID ("visual_alerts_switch"), "active",
WID ("visual_alerts_window_radio"), "sensitive",
G_BINDING_SYNC_CREATE);
g_object_bind_property (WID ("visual_alerts_switch"), "active",
WID ("visual_alerts_screen_radio"), "sensitive",
G_BINDING_SYNC_CREATE);
g_signal_connect (priv->wm_settings, "changed::" KEY_VISUAL_BELL_TYPE,
G_CALLBACK (visual_bell_type_notify_cb), self);
g_signal_connect (WID ("visual_alerts_window_radio"),
"toggled", G_CALLBACK (visual_bell_type_toggle_cb), self);
dialog = WID ("visual_alerts_dialog");
g_object_set_data (G_OBJECT (WID ("row_visual_alerts")), "dialog", dialog);
g_signal_connect_swapped (WID ("visual_alerts_done"), "clicked",
G_CALLBACK (gtk_widget_hide), dialog);
g_signal_connect (dialog, "delete-event",
G_CALLBACK (gtk_widget_hide_on_delete), NULL);
g_signal_connect (WID ("visual_alerts_test_button"),
"clicked", G_CALLBACK (gdk_beep), NULL);
g_signal_connect (WID ("heading_visual_alerts"), "mnemonic-activate",
G_CALLBACK (mnemonic_activate), self);
}
static void
example_app_window_init (ExampleAppWindow *win)
{
ExampleAppWindowPrivate *priv;
GtkBuilder *builder;
GMenuModel *menu;
GAction *action;
priv = example_app_window_get_instance_private (win);
gtk_widget_init_template (GTK_WIDGET (win));
priv->settings = g_settings_new ("com.lonelycactus.exampleapp");
g_settings_bind (priv->settings, "transition",
priv->stack, "transition-type",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (priv->settings, "show-words",
priv->sidebar, "reveal-child",
G_SETTINGS_BIND_DEFAULT);
g_object_bind_property (priv->search, "active",
priv->searchbar, "search-mode-enabled",
G_BINDING_BIDIRECTIONAL);
g_signal_connect (priv->connect, "toggled",
G_CALLBACK (toggle_server), win);
g_signal_connect (priv->sidebar, "notify::reveal-child",
G_CALLBACK (words_changed), win);
builder = gtk_builder_new_from_resource ("/com/lonelycactus/exampleapp/gears-menu.ui");
menu = G_MENU_MODEL (gtk_builder_get_object (builder, "menu"));
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (priv->gears), menu);
g_object_unref (builder);
action = g_settings_create_action (priv->settings, "show-words");
g_action_map_add_action (G_ACTION_MAP (win), action);
g_object_unref (action);
action = (GAction*) g_property_action_new ("show-lines", priv->lines, "visible");
g_action_map_add_action (G_ACTION_MAP (win), action);
g_object_unref (action);
g_object_bind_property (priv->lines, "visible",
priv->lines_label, "visible",
G_BINDING_DEFAULT);
service_init();
service_start_accepting_new_connections();
g_object_set (gtk_settings_get_default (), "gtk-shell-shows-app-menu", FALSE, NULL);
gtk_application_window_set_show_menubar (GTK_APPLICATION_WINDOW (win), TRUE);
}
static void
transport_stream_constructed (GObject * object)
{
TransportStream *stream = TRANSPORT_STREAM (object);
GstWebRTCBin *webrtc;
GstWebRTCICETransport *ice_trans;
stream->transport = gst_webrtc_dtls_transport_new (stream->session_id, FALSE);
stream->rtcp_transport =
gst_webrtc_dtls_transport_new (stream->session_id, TRUE);
webrtc = GST_WEBRTC_BIN (gst_object_get_parent (GST_OBJECT (object)));
g_object_bind_property (stream->transport, "client", stream, "dtls-client",
G_BINDING_BIDIRECTIONAL);
g_object_bind_property (stream->rtcp_transport, "client", stream,
"dtls-client", G_BINDING_BIDIRECTIONAL);
g_object_bind_property (stream->transport, "certificate",
stream->rtcp_transport, "certificate", G_BINDING_BIDIRECTIONAL);
/* Need to go full Java and have a transport manager?
* Or make the caller set the ICE transport up? */
stream->stream = _find_ice_stream_for_session (webrtc, stream->session_id);
if (stream->stream == NULL) {
stream->stream = gst_webrtc_ice_add_stream (webrtc->priv->ice,
stream->session_id);
_add_ice_stream_item (webrtc, stream->session_id, stream->stream);
}
ice_trans =
gst_webrtc_ice_find_transport (webrtc->priv->ice, stream->stream,
GST_WEBRTC_ICE_COMPONENT_RTP);
gst_webrtc_dtls_transport_set_transport (stream->transport, ice_trans);
gst_object_unref (ice_trans);
ice_trans =
gst_webrtc_ice_find_transport (webrtc->priv->ice, stream->stream,
GST_WEBRTC_ICE_COMPONENT_RTCP);
gst_webrtc_dtls_transport_set_transport (stream->rtcp_transport, ice_trans);
gst_object_unref (ice_trans);
stream->send_bin = g_object_new (transport_send_bin_get_type (), "stream",
stream, NULL);
gst_object_ref_sink (stream->send_bin);
stream->receive_bin = g_object_new (transport_receive_bin_get_type (),
"stream", stream, NULL);
gst_object_ref_sink (stream->receive_bin);
gst_object_unref (webrtc);
G_OBJECT_CLASS (parent_class)->constructed (object);
}
GstElement * _owr_payload_create_encoder(OwrPayload *payload)
{
GstElement *encoder = NULL;
gchar *element_name = NULL;
GstElementFactory *factory;
const gchar *factory_name;
g_return_val_if_fail(payload, NULL);
switch (payload->priv->codec_type) {
case OWR_CODEC_TYPE_H264:
encoder = try_codecs(h264_encoders, "encoder");
g_return_val_if_fail(encoder, NULL);
factory = gst_element_get_factory(encoder);
factory_name = gst_plugin_feature_get_name(factory);
if (!strcmp(factory_name, "openh264enc")) {
g_object_set(encoder, "gop-size", 0, NULL);
gst_util_set_object_arg(G_OBJECT(encoder), "rate-control", "bitrate");
g_object_bind_property(payload, "bitrate", encoder, "bitrate", G_BINDING_SYNC_CREATE);
} else if (!strcmp(factory_name, "x264enc")) {
g_object_bind_property_full(payload, "bitrate", encoder, "bitrate", G_BINDING_SYNC_CREATE,
binding_transform_to_kbps, NULL, NULL, NULL);
g_object_set(encoder, "tune", 0x04 /* zero-latency */, NULL);
} else if (!strcmp(factory_name, "vtenc_h264")) {
g_object_bind_property_full(payload, "bitrate", encoder, "bitrate", G_BINDING_SYNC_CREATE,
binding_transform_to_kbps, NULL, NULL, NULL);
} else {
/* Assume bits/s instead of kbit/s */
g_object_bind_property(payload, "bitrate", encoder, "bitrate", G_BINDING_SYNC_CREATE);
}
g_object_set(payload, "bitrate", evaluate_bitrate_from_payload(payload), NULL);
break;
case OWR_CODEC_TYPE_VP8:
encoder = try_codecs(vp8_encoders, "encoder");
g_return_val_if_fail(encoder, NULL);
g_object_set(encoder, "end-usage", 1, "deadline", G_GINT64_CONSTANT(1), "lag-in-frames", 0,
"error-resilient", 1, "keyframe-mode", 0, NULL);
g_object_bind_property(payload, "bitrate", encoder, "target-bitrate", G_BINDING_SYNC_CREATE);
g_object_set(payload, "bitrate", evaluate_bitrate_from_payload(payload), NULL);
break;
default:
element_name = g_strdup_printf("encoder_%s_%u", OwrCodecTypeEncoderElementName[payload->priv->codec_type], get_unique_id());
encoder = gst_element_factory_make(OwrCodecTypeEncoderElementName[payload->priv->codec_type], element_name);
g_free(element_name);
g_return_val_if_fail(encoder, NULL);
break;
}
return encoder;
}
GtkWidget *
cc_input_options_new (GtkWidget *parent)
{
GtkBuilder *builder;
GtkWidget *options;
CcInputOptionsPrivate *priv;
GError *error = NULL;
builder = gtk_builder_new ();
if (gtk_builder_add_from_resource (builder, "/org/gnome/control-center/region/input-options.ui", &error) == 0) {
g_object_unref (builder);
g_warning ("failed to load input options: %s", error->message);
g_error_free (error);
return NULL;
}
options = WID ("dialog");
priv = g_new0 (CcInputOptionsPrivate, 1);
g_object_set_data_full (G_OBJECT (options), "private", priv, cc_input_options_private_free);
g_object_set_data_full (G_OBJECT (options), "builder", builder, g_object_unref);
priv->same_source = WID ("same-source");
priv->per_window_source = WID ("per-window-source");
priv->previous_source = WID ("previous-source");
priv->next_source = WID ("next-source");
priv->alt_next_source = WID ("alt-next-source");
g_object_bind_property (priv->previous_source, "visible",
WID ("previous-source-label"), "visible",
G_BINDING_DEFAULT);
g_object_bind_property (priv->next_source, "visible",
WID ("next-source-label"), "visible",
G_BINDING_DEFAULT);
g_object_bind_property (priv->alt_next_source, "visible",
WID ("alt-next-source-label"), "visible",
G_BINDING_DEFAULT);
priv->settings = g_settings_new ("org.gnome.desktop.input-sources");
g_settings_bind (priv->settings, "per-window",
priv->per_window_source, "active",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (priv->settings, "per-window",
priv->same_source, "active",
G_SETTINGS_BIND_DEFAULT | G_SETTINGS_BIND_INVERT_BOOLEAN);
update_shortcuts (options);
update_modifiers_shortcut (options);
gtk_window_set_transient_for (GTK_WINDOW (options), GTK_WINDOW (parent));
return options;
}
static void
setup_header_bar (GtkWidget *window,
VteTerminal *vtterm,
gboolean show_maximized_title)
{
/*
* Using the default GtkHeaderBar title/subtitle widget makes the bar
* too thick to look nice for a terminal, so set a custom widget.
*/
GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
const gchar *title = gtk_window_get_title (GTK_WINDOW (window));
GtkWidget *label = gtk_label_new (title ? title : "dwt");
g_object_bind_property (G_OBJECT (vtterm), "window-title",
G_OBJECT (label), "label",
G_BINDING_DEFAULT);
GtkWidget *header = gtk_header_bar_new ();
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (header), TRUE);
gtk_header_bar_set_has_subtitle (GTK_HEADER_BAR (header), FALSE);
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (header), label);
GtkWidget *button = gtk_button_new_from_icon_name ("tab-new-symbolic",
GTK_ICON_SIZE_BUTTON);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_actionable_set_action_name (GTK_ACTIONABLE (button), "app.new-terminal");
gtk_header_bar_pack_start (GTK_HEADER_BAR (header), button);
GtkWidget *revealer = gtk_revealer_new ();
gtk_container_add (GTK_CONTAINER (revealer),
gtk_image_new_from_icon_name ("software-update-urgent-symbolic",
GTK_ICON_SIZE_BUTTON));
gtk_revealer_set_transition_duration (GTK_REVEALER (revealer), 500);
gtk_revealer_set_transition_type (GTK_REVEALER (revealer),
GTK_REVEALER_TRANSITION_TYPE_CROSSFADE);
gtk_header_bar_pack_end (GTK_HEADER_BAR (header), revealer);
g_signal_connect (G_OBJECT (vtterm), "bell",
G_CALLBACK (header_bar_term_beeped), revealer);
g_object_bind_property (G_OBJECT (window), "urgency-hint",
G_OBJECT (revealer), "reveal-child",
G_BINDING_DEFAULT);
gtk_window_set_titlebar (GTK_WINDOW (window), header);
/* Hide the header bar when the window is maximized. */
if (!show_maximized_title) {
g_object_bind_property (G_OBJECT (window), "is-maximized",
G_OBJECT (header), "visible",
G_BINDING_INVERT_BOOLEAN);
}
}
static void
eee_backend_child_added (ECollectionBackend *backend,
ESource *child_source)
{
ESource *collection_source;
const gchar *extension_name;
gboolean is_mail = FALSE;
collection_source = e_backend_get_source (E_BACKEND (backend));
extension_name = E_SOURCE_EXTENSION_MAIL_ACCOUNT;
is_mail |= e_source_has_extension (child_source, extension_name);
extension_name = E_SOURCE_EXTENSION_MAIL_IDENTITY;
is_mail |= e_source_has_extension (child_source, extension_name);
extension_name = E_SOURCE_EXTENSION_MAIL_TRANSPORT;
is_mail |= e_source_has_extension (child_source, extension_name);
/* Synchronize mail-related display names with the collection. */
if (is_mail)
g_object_bind_property (
collection_source, "display-name",
child_source, "display-name",
G_BINDING_SYNC_CREATE);
/* Synchronize mail-related user with the collection identity. */
extension_name = E_SOURCE_EXTENSION_AUTHENTICATION;
if (is_mail && e_source_has_extension (child_source, extension_name)) {
ESourceAuthentication *auth_child_extension;
ESourceCollection *collection_extension;
extension_name = E_SOURCE_EXTENSION_COLLECTION;
collection_extension = e_source_get_extension (
collection_source, extension_name);
extension_name = E_SOURCE_EXTENSION_AUTHENTICATION;
auth_child_extension = e_source_get_extension (
child_source, extension_name);
g_object_bind_property (
collection_extension, "identity",
auth_child_extension, "user",
G_BINDING_SYNC_CREATE);
}
/* Chain up to parent's child_added() method. */
E_COLLECTION_BACKEND_CLASS (e_eee_backend_parent_class)->
child_added (backend, child_source);
}
void
libre_impuesto_window_actions_init (LibreImpuestoWindow *impuesto_window)
{
GtkActionGroup *action_group;
GtkUIManager *ui_manager;
gchar *filename;
GError *error;
gboolean ret_val;
g_return_if_fail (IS_LIBRE_IMPUESTO_WINDOW (impuesto_window));
ui_manager = libre_impuesto_window_get_ui_manager (impuesto_window);
action_group = libre_impuesto_add_action_group(ui_manager, "impuesto");
gtk_action_group_add_actions ( action_group, impuesto_entries,
G_N_ELEMENTS (impuesto_entries),
impuesto_window);
gtk_action_group_add_toggle_actions ( action_group, impuesto_toggle_entries,
G_N_ELEMENTS (impuesto_toggle_entries),
impuesto_window);
error = NULL;
filename = g_build_filename (LIBRE_IMPUESTO_UIDIR,
"libre-impuestos-menu.ui", NULL);
ret_val = gtk_ui_manager_add_ui_from_file (ui_manager, filename, &error);
g_free (filename);
if (!ret_val) {
g_critical("%s", error->message);
}
g_object_bind_property (impuesto_window, "headerbar-visible",
libre_impuesto_window_get_action (impuesto_window,
"show-headerbar"),
"active", G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
g_object_bind_property (impuesto_window, "sidebar-visible",
libre_impuesto_window_get_action( impuesto_window,
"show-sidebar"),
"active", G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
g_object_bind_property (impuesto_window, "statusbar-visible",
libre_impuesto_window_get_action (impuesto_window,
"show-statusbar"),
"active", G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
}
void dialogs_init(GtkBuilder *builder)
{
const char *name = NULL;
struct iio_context *ctx;
GtkWidget *tmp;
dialogs.builder = builder;
dialogs.about = GTK_WIDGET(gtk_builder_get_object(builder, "About_dialog"));
dialogs.connect = GTK_WIDGET(gtk_builder_get_object(builder, "connect_dialog"));
dialogs.connect_fru = GTK_WIDGET(gtk_builder_get_object(builder, "fru_info"));
dialogs.serial_num = GTK_WIDGET(gtk_builder_get_object(builder, "serial_number_popup"));
dialogs.connect_iio = GTK_WIDGET(gtk_builder_get_object(builder, "connect_iio_devices"));
dialogs.ctx_info = GTK_WIDGET(gtk_builder_get_object(builder, "connect_iio_ctx_info"));
dialogs.load_save_profile = GTK_WIDGET(gtk_builder_get_object(builder, "load_save_profile"));
dialogs.connect_net = GTK_WIDGET(gtk_builder_get_object(builder, "connect_net"));
dialogs.net_ip = GTK_WIDGET(gtk_builder_get_object(builder, "connect_net_IP"));
dialogs.ok_btn = GTK_WIDGET(gtk_builder_get_object(builder, "button3"));
dialogs.latest_version = GTK_WIDGET(gtk_builder_get_object(builder, "latest_version_popup"));
dialogs.ver_progress_window = GTK_WIDGET(gtk_builder_get_object(builder, "progress_window"));
dialogs.ver_progress_bar = GTK_WIDGET(gtk_builder_get_object(builder, "progressbar"));
gtk_builder_connect_signals(builder, &dialogs);
/* Bind some dialogs radio buttons to text/labels */
tmp = GTK_WIDGET(gtk_builder_get_object(builder, "connect_net_label"));
serial_num = GTK_WIDGET(gtk_builder_get_object(builder, "serial_number"));
fru_date = GTK_WIDGET(gtk_builder_get_object(builder, "fru_date"));
fru_file_list = GTK_WIDGET(gtk_builder_get_object(builder, "FRU_files"));
g_object_bind_property(dialogs.connect_net, "active", tmp, "sensitive", 0);
g_object_bind_property(dialogs.connect_net, "active", dialogs.net_ip, "sensitive", 0);
/* Grey out the "local context" option if it is not available */
ctx = get_context_from_osc();
if (ctx)
name = iio_context_get_name(ctx);
if (!name || strcmp(name, "local")) {
ctx = iio_create_local_context();
if (ctx) {
iio_context_destroy(ctx);
} else {
GtkWidget *local = GTK_WIDGET(gtk_builder_get_object(
builder, "connect_local"));
gtk_widget_set_sensitive(local, false);
gtk_toggle_button_set_active(
GTK_TOGGLE_BUTTON(dialogs.connect_net), true);
}
}
}
static GtkWidget *
test_stacking (void)
{
GtkWidget *win;
GtkWidget *overlay;
GtkWidget *main_child;
GtkWidget *label;
GtkWidget *child;
GtkWidget *grid;
GtkWidget *check1;
GtkWidget *check2;
GdkRGBA color;
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (win), "Stacking");
grid = gtk_grid_new ();
overlay = gtk_overlay_new ();
main_child = gtk_event_box_new ();
gdk_rgba_parse (&color, "green");
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gtk_widget_override_background_color (main_child, 0, &color);
G_GNUC_END_IGNORE_DEPRECATIONS
gtk_widget_set_hexpand (main_child, TRUE);
gtk_widget_set_vexpand (main_child, TRUE);
label = gtk_label_new ("Main child");
child = gtk_label_new ("Overlay");
gtk_widget_set_halign (child, GTK_ALIGN_END);
gtk_widget_set_valign (child, GTK_ALIGN_END);
check1 = gtk_check_button_new_with_label ("Show main");
g_object_bind_property (main_child, "visible", check1, "active", G_BINDING_BIDIRECTIONAL);
check2 = gtk_check_button_new_with_label ("Show overlay");
g_object_bind_property (child, "visible", check2, "active", G_BINDING_BIDIRECTIONAL);
gtk_container_add (GTK_CONTAINER (main_child), label);
gtk_container_add (GTK_CONTAINER (overlay), main_child);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child);
gtk_grid_attach (GTK_GRID (grid), overlay, 1, 0, 1, 3);
gtk_container_add (GTK_CONTAINER (win), grid);
gtk_grid_attach (GTK_GRID (grid), check1, 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), check2, 0, 1, 1, 1);
child = gtk_label_new ("");
gtk_widget_set_vexpand (child, TRUE);
gtk_grid_attach (GTK_GRID (grid), child, 0, 2, 1, 1);
return win;
}
static void
constructed(GObject* obj)
{
GtGamesViewChild* self = GT_GAMES_VIEW_CHILD(obj);
GtGamesViewChildPrivate* priv = gt_games_view_child_get_instance_private(self);
g_object_bind_property(priv->game, "name",
priv->name_label, "label",
G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
g_object_bind_property(priv->game, "preview",
priv->preview_image, "pixbuf",
G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
G_OBJECT_CLASS(gt_games_view_child_parent_class)->constructed(obj);
}
static gboolean
gdm_display_real_set_slave_bus_name (GdmDisplay *display,
const char *name,
GError **error)
{
g_free (display->priv->slave_bus_name);
display->priv->slave_bus_name = g_strdup (name);
if (display->priv->slave_name_id > 0) {
g_bus_unwatch_name (display->priv->slave_name_id);
}
display->priv->slave_name_id = g_bus_watch_name_on_connection (display->priv->connection,
name,
G_BUS_NAME_WATCHER_FLAGS_NONE,
NULL, /* name appeared */
on_name_vanished,
g_object_ref (display),
NULL);
g_clear_object (&display->priv->slave_bus_proxy);
display->priv->slave_bus_proxy = GDM_DBUS_SLAVE (gdm_dbus_slave_proxy_new_sync (display->priv->connection,
G_DBUS_PROXY_FLAGS_NONE,
name,
GDM_SLAVE_PATH,
NULL, NULL));
g_object_bind_property (G_OBJECT (display->priv->slave_bus_proxy),
"session-id",
G_OBJECT (display),
"session-id",
G_BINDING_DEFAULT);
return TRUE;
}
int
main (int argc, char *argv[])
{
GtkWidget *window, *list, *sw, *row;
GtkWidget *hbox, *vbox, *combo, *button;
gint i;
gchar *text;
gtk_init (NULL, NULL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), -1, 300);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_container_add (GTK_CONTAINER (window), hbox);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
g_object_set (vbox, "margin", 12, NULL);
gtk_container_add (GTK_CONTAINER (hbox), vbox);
list = gtk_list_box_new ();
gtk_list_box_set_selection_mode (GTK_LIST_BOX (list), GTK_SELECTION_NONE);
g_signal_connect (list, "row-activated", G_CALLBACK (on_row_activated), NULL);
g_signal_connect (list, "selected-rows-changed", G_CALLBACK (on_selected_children_changed), NULL);
g_signal_connect (gtk_widget_get_accessible (list), "selection-changed", G_CALLBACK (a11y_selection_changed), NULL);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_set_hexpand (sw, TRUE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_container_add (GTK_CONTAINER (hbox), sw);
gtk_container_add (GTK_CONTAINER (sw), list);
button = gtk_check_button_new_with_label ("Activate on single click");
g_object_bind_property (list, "activate-on-single-click",
button, "active",
G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
gtk_container_add (GTK_CONTAINER (vbox), button);
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "None");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "Single");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "Browse");
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (combo), "Multiple");
g_signal_connect (combo, "changed", G_CALLBACK (selection_mode_changed), list);
gtk_container_add (GTK_CONTAINER (vbox), combo);
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), gtk_list_box_get_selection_mode (GTK_LIST_BOX (list)));
for (i = 0; i < 20; i++)
{
text = g_strdup_printf ("Row %d", i);
row = create_row (text);
gtk_list_box_insert (GTK_LIST_BOX (list), row, -1);
}
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
static void
gimp_prop_table_chain_toggled (GimpChainButton *chain,
GtkAdjustment *x_adj)
{
GtkAdjustment *y_adj;
y_adj = g_object_get_data (G_OBJECT (x_adj), "y-adjustment");
if (gimp_chain_button_get_active (chain))
{
GBinding *binding;
binding = g_object_bind_property (x_adj, "value",
y_adj, "value",
G_BINDING_BIDIRECTIONAL);
g_object_set_data (G_OBJECT (chain), "binding", binding);
}
else
{
GBinding *binding;
binding = g_object_get_data (G_OBJECT (chain), "binding");
g_object_unref (binding);
g_object_set_data (G_OBJECT (chain), "binding", NULL);
}
}
static void
cc_search_panel_constructed (GObject *object)
{
CcSearchPanel *self = CC_SEARCH_PANEL (object);
GtkWidget *box, *widget, *search_box;
G_OBJECT_CLASS (cc_search_panel_parent_class)->constructed (object);
/* add the disable all switch */
search_box = WID ("search_vbox");
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
widget = gtk_switch_new ();
gtk_widget_set_valign (widget, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (box), widget, FALSE, FALSE, 4);
g_settings_bind (self->priv->search_settings, "disable-external",
widget, "active",
G_SETTINGS_BIND_DEFAULT |
G_SETTINGS_BIND_INVERT_BOOLEAN);
g_object_bind_property (widget, "active",
search_box, "sensitive",
G_BINDING_DEFAULT |
G_BINDING_SYNC_CREATE);
gtk_widget_show_all (box);
cc_shell_embed_widget_in_header (cc_panel_get_shell (CC_PANEL (self)), box);
}
GtkWidget *
gimp_color_options_gui (GimpToolOptions *tool_options)
{
GObject *config = G_OBJECT (tool_options);
GtkWidget *vbox = gimp_tool_options_gui (tool_options);
GtkWidget *frame;
GtkWidget *scale;
GtkWidget *button;
/* the sample average options */
frame = gimp_frame_new (NULL);
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
scale = gimp_prop_spin_scale_new (config, "average-radius", NULL,
1.0, 10.0, 0);
gtk_container_add (GTK_CONTAINER (frame), scale);
gtk_widget_show (scale);
button = gimp_prop_check_button_new (config, "sample-average", NULL);
gtk_frame_set_label_widget (GTK_FRAME (frame), button);
gtk_widget_show (button);
g_object_bind_property (config, "sample-average",
scale, "sensitive",
G_BINDING_SYNC_CREATE);
return vbox;
}
static gboolean
geyes_applet_fill (PanelApplet *applet)
{
EyesApplet *eyes_applet;
GSimpleActionGroup *action_group;
GAction *action;
gchar *ui_path;
panel_applet_set_flags (applet, PANEL_APPLET_EXPAND_MINOR);
eyes_applet = create_eyes (applet);
eyes_applet->settings = panel_applet_settings_new (applet, GEYES_PREFS_SCHEMA);
eyes_applet->timeout_id = g_timeout_add (
UPDATE_TIMEOUT, (GSourceFunc) timer_cb, eyes_applet);
action_group = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (action_group),
geyes_applet_menu_actions,
G_N_ELEMENTS (geyes_applet_menu_actions),
eyes_applet);
ui_path = g_build_filename (GEYES_MENU_UI_DIR, "geyes-applet-menu.xml", NULL);
panel_applet_setup_menu_from_file (eyes_applet->applet,
ui_path, action_group,
GETTEXT_PACKAGE);
g_free (ui_path);
gtk_widget_insert_action_group (GTK_WIDGET (applet), "geyes",
G_ACTION_GROUP (action_group));
action = g_action_map_lookup_action (G_ACTION_MAP (action_group), "preferences");
g_object_bind_property (applet, "locked-down",
action, "enabled",
G_BINDING_DEFAULT|G_BINDING_INVERT_BOOLEAN|G_BINDING_SYNC_CREATE);
g_object_unref (action_group);
gtk_widget_set_tooltip_text (GTK_WIDGET (eyes_applet->applet), _("Eyes"));
set_atk_name_description (GTK_WIDGET (eyes_applet->applet), _("Eyes"),
_("The eyes look in the direction of the mouse pointer"));
g_signal_connect (eyes_applet->vbox,
"destroy",
G_CALLBACK (destroy_cb),
eyes_applet);
gtk_widget_show_all (GTK_WIDGET (eyes_applet->applet));
/* setup here and not in create eyes so the destroy signal is set so
* that when there is an error within loading the theme
* we can emit this signal */
if (properties_load (eyes_applet) == FALSE)
return FALSE;
setup_eyes (eyes_applet);
return TRUE;
}
int main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *box;
GtkWidget *bu;
GtkWidget *w, *c;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add (GTK_CONTAINER (window), box);
w = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 15);
gtk_box_pack_start (GTK_BOX (box), w, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (w), gtk_entry_new (), TRUE, TRUE, 0);
bu = gtk_button_new_with_label ("Bu");
gtk_box_pack_start (GTK_BOX (w), bu, TRUE, TRUE, 0);
c = gtk_switch_new ();
gtk_switch_set_active (GTK_SWITCH (c), TRUE);
gtk_widget_set_halign (c, GTK_ALIGN_CENTER);
gtk_widget_set_valign (c, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (box), c, TRUE, TRUE, 0);
g_signal_connect (bu, "clicked", G_CALLBACK (set_insensitive), w);
g_signal_connect (bu, "state-changed", G_CALLBACK (state_changed), NULL);
g_object_bind_property (c, "active", w, "sensitive", G_BINDING_BIDIRECTIONAL);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
static void
nmt_editor_constructed (GObject *object)
{
NmtEditor *editor = NMT_EDITOR (object);
NmtEditorPrivate *priv = NMT_EDITOR_GET_PRIVATE (editor);
NmtNewtWidget *vbox, *buttons, *page;
if (G_OBJECT_CLASS (nmt_editor_parent_class)->constructed)
G_OBJECT_CLASS (nmt_editor_parent_class)->constructed (object);
priv->edit_connection = build_edit_connection (priv->orig_connection);
vbox = nmt_newt_grid_new ();
page = nmt_page_main_new (priv->edit_connection, priv->type_data);
nmt_newt_grid_add (NMT_NEWT_GRID (vbox), page, 0, 0);
buttons = nmt_newt_button_box_new (NMT_NEWT_BUTTON_BOX_HORIZONTAL);
nmt_newt_grid_add (NMT_NEWT_GRID (vbox), buttons, 0, 1);
nmt_newt_widget_set_padding (buttons, 0, 1, 0, 0);
priv->cancel = nmt_newt_button_box_add_end (NMT_NEWT_BUTTON_BOX (buttons), _("Cancel"));
nmt_newt_widget_set_exit_on_activate (priv->cancel, TRUE);
priv->ok = nmt_newt_button_box_add_end (NMT_NEWT_BUTTON_BOX (buttons), _("OK"));
g_signal_connect (priv->ok, "clicked", G_CALLBACK (save_connection_and_exit), editor);
g_object_bind_property (page, "valid",
priv->ok, "sensitive",
G_BINDING_SYNC_CREATE);
nmt_newt_form_set_content (NMT_NEWT_FORM (editor), vbox);
}
static void
pt_window_init (PtWindow *win)
{
win->priv = pt_window_get_instance_private (win);
gtk_widget_init_template (GTK_WIDGET (win));
setup_settings (win);
setup_player (win);
setup_accels_actions_headerbar (win);
setup_mediakeys (win); /* this is in pt_mediakeys.c */
pt_window_setup_dnd (win); /* this is in pt_window_dnd.c */
setup_dbus_service (win); /* this is in pt_dbus_service.c */
win->priv->recent = gtk_recent_manager_get_default ();
win->priv->timer = 0;
win->priv->progress_dlg = NULL;
win->priv->progress_handler_id = 0;
win->priv->wavedata = NULL;
pos_label_set_pango_attrs (GTK_LABEL (win->priv->pos_label));
g_object_bind_property (win->priv->waveslider, "follow-cursor",
win->priv->pos_label, "has_tooltip",
G_BINDING_INVERT_BOOLEAN | G_BINDING_SYNC_CREATE);
pt_window_ready_to_play (win, FALSE);
}
EinaMuine*
eina_muine_new (void)
{
gchar *xml_string = NULL;
gel_io_resources_load_file_contents_or_error(EINA_APP_PATH_DOMAIN "/muine/main.ui", &xml_string, NULL);
EinaMuine *self = g_object_new (EINA_TYPE_MUINE, "xml-string", xml_string , NULL);
EinaMuinePrivate *priv = self->priv;
g_free(xml_string);
GelUIGeneric *ui_generic = GEL_UI_GENERIC(self);
priv->listview = gel_ui_generic_get_typed(ui_generic, GTK_TREE_VIEW, "list-view");
priv->filter = gel_ui_generic_get_typed(ui_generic, GTK_TREE_MODEL_FILTER, "model-filter");
priv->model = gel_ui_generic_get_typed(ui_generic, GTK_LIST_STORE, "model");
priv->search = gel_ui_generic_get_typed(ui_generic, GTK_ENTRY, "search-entry");
g_object_set(gel_ui_generic_get_object(ui_generic, "markup-renderer"),
"yalign", 0.0f,
NULL);
gtk_tree_model_filter_set_visible_func(priv->filter, (GtkTreeModelFilterVisibleFunc) muine_filter_func, self, NULL);
g_object_bind_property(self, "mode", gel_ui_generic_get_object(ui_generic, "mode-view"), "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
gchar *actions[] = { "play-action", "queue-action" };
for (guint i = 0; i < G_N_ELEMENTS(actions); i++)
{
GObject *a = gel_ui_generic_get_object(ui_generic, actions[i]);
g_signal_connect(a, "activate", (GCallback) action_activate_cb, self);
}
g_signal_connect(priv->listview, "row-activated", (GCallback) row_activated_cb, self);
g_signal_connect(priv->search, "changed", (GCallback) search_changed_cb, self);
g_signal_connect(priv->search, "icon-press", (GCallback) search_icon_press_cb, self);
return self;
}
static void
nmt_password_fields_constructed (GObject *object)
{
NmtPasswordFieldsPrivate *priv = NMT_PASSWORD_FIELDS_GET_PRIVATE (object);
NmtNewtGrid *grid = NMT_NEWT_GRID (object);
nmt_newt_grid_add (grid, NMT_NEWT_WIDGET (priv->entry), 0, 0);
if (priv->extras & NMT_PASSWORD_FIELDS_ALWAYS_ASK) {
nmt_newt_grid_add (grid, NMT_NEWT_WIDGET (priv->always_ask), 0, 1);
g_signal_connect (priv->always_ask, "notify::active",
G_CALLBACK (always_ask_changed), object);
} else
g_clear_object (&priv->always_ask);
if (priv->extras & NMT_PASSWORD_FIELDS_SHOW_PASSWORD) {
nmt_newt_grid_add (grid, NMT_NEWT_WIDGET (priv->show_password), 0, 2);
g_signal_connect (priv->show_password, "notify::active",
G_CALLBACK (show_password_changed), object);
g_object_bind_property (priv->show_password, "active",
priv->entry, "password",
G_BINDING_INVERT_BOOLEAN | G_BINDING_SYNC_CREATE);
} else
g_clear_object (&priv->show_password);
G_OBJECT_CLASS (nmt_password_fields_parent_class)->constructed (object);
}
