static void action_stop_enabled_changed (GActionGroup *action_group, gchar *action_name, gboolean enabled, gpointer user_data) { NautilusToolbar *self = user_data; gtk_widget_set_visible (self->priv->stop, enabled); }
void inSiteSearchToggle(RuskWindow *rusk) { if(!gtk_widget_is_visible(GTK_WIDGET(rusk->insiteSearch))) { gtk_widget_set_visible(GTK_WIDGET(rusk->insiteSearch), TRUE); gtk_window_set_focus(rusk->window, GTK_WIDGET(rusk->insiteSearch)); WebKitFindController *finder = webkit_web_view_get_find_controller(rusk->webview); runInSiteSearch(rusk, webkit_find_controller_get_search_text(finder), TRUE); webkit_find_controller_search_previous(finder); }else { webkit_find_controller_search_finish(webkit_web_view_get_find_controller(rusk->webview)); gtk_widget_set_visible(GTK_WIDGET(rusk->insiteSearch), FALSE); gtk_window_set_focus(rusk->window, GTK_WIDGET(rusk->webview)); } }
/* Steals permissions and permissions_data references */ static void update_perm_store (CcPrivacyPanel *self, GVariant *permissions, GVariant *permissions_data) { CcPrivacyPanelPrivate *priv; GVariantIter iter; gchar *key; gchar **value; GList *children; priv = self->priv; g_clear_pointer (&priv->location_apps_perms, g_variant_unref); priv->location_apps_perms = permissions; g_clear_pointer (&priv->location_apps_data, g_variant_unref); priv->location_apps_data = permissions_data; g_variant_iter_init (&iter, permissions); while (g_variant_iter_loop (&iter, "{s^as}", &key, &value)) { gboolean enabled; gint64 last_used; if (g_strv_length (value) < 2) { g_debug ("Permissions for %s in incorrect format, ignoring..", key); continue; } enabled = (g_strcmp0 (value[0], "NONE") != 0); last_used = g_ascii_strtoll (value[1], NULL, 10); add_location_app (self, key, enabled, last_used); } children = gtk_container_get_children (GTK_CONTAINER (priv->location_apps_list_box)); if (g_list_length (children) > 0) { gtk_widget_set_visible (priv->location_apps_label, TRUE); gtk_widget_set_visible (priv->location_apps_frame, TRUE); } g_list_free (children); }
static void gtk_message_row_update (GtkMessageRow *row) { GtkMessageRowPrivate *priv = row->priv; GDateTime *t; char *s; gtk_label_set_text (priv->source_name, priv->message->sender_name); gtk_label_set_text (priv->source_nick, priv->message->sender_nick); gtk_label_set_text (priv->content_label, priv->message->message); t = g_date_time_new_from_unix_utc (priv->message->time); s = g_date_time_format (t, "%e %b %y"); gtk_label_set_text (priv->short_time_label, s); g_free (s); s = g_date_time_format (t, "%X - %e %b %Y"); gtk_label_set_text (priv->detailed_time_label, s); g_free (s); g_date_time_unref (t); gtk_widget_set_visible (GTK_WIDGET(priv->n_favorites_label), priv->message->n_favorites != 0); s = g_strdup_printf ("<b>%d</b>\nFavorites", priv->message->n_favorites); gtk_label_set_markup (priv->n_favorites_label, s); g_free (s); gtk_widget_set_visible (GTK_WIDGET(priv->n_reshares_label), priv->message->n_reshares != 0); s = g_strdup_printf ("<b>%d</b>\nReshares", priv->message->n_reshares); gtk_label_set_markup (priv->n_reshares_label, s); g_free (s); gtk_widget_set_visible (GTK_WIDGET (priv->resent_box), priv->message->resent_by != NULL); if (priv->message->resent_by) gtk_button_set_label (GTK_BUTTON (priv->resent_by_button), priv->message->resent_by); if (strcmp (priv->message->sender_nick, "@GTKtoolkit") == 0) { gtk_image_set_from_icon_name (priv->avatar_image, "gtk3-demo"); gtk_image_set_icon_size (priv->avatar_image, GTK_ICON_SIZE_LARGE); } else gtk_image_set_from_pixbuf (priv->avatar_image, avatar_pixbuf_other); }
void um_password_dialog_set_user (UmPasswordDialog *um, ActUser *user) { gboolean visible; if (um->user) { g_object_unref (um->user); um->user = NULL; } if (user) { um->user = g_object_ref (user); gtk_entry_set_text (GTK_ENTRY (um->password_entry), ""); gtk_entry_set_text (GTK_ENTRY (um->verify_entry), ""); gtk_entry_set_text (GTK_ENTRY (um->old_password_entry), ""); gtk_entry_set_visibility (GTK_ENTRY (um->password_entry), FALSE); gtk_entry_set_visibility (GTK_ENTRY (um->verify_entry), FALSE); if (act_user_get_uid (um->user) == getuid ()) { mode_change (um, ACT_USER_PASSWORD_MODE_REGULAR); gtk_widget_hide (um->action_radio_box); visible = (act_user_get_password_mode (user) != ACT_USER_PASSWORD_MODE_NONE); gtk_widget_set_visible (um->old_password_label, visible); gtk_widget_set_visible (um->old_password_entry, visible); um->old_password_ok = !visible; } else { mode_change (um, ACT_USER_PASSWORD_MODE_SET_AT_LOGIN); gtk_widget_show (um->action_radio_box); gtk_widget_hide (um->old_password_label); gtk_widget_hide (um->old_password_entry); um->old_password_ok = TRUE; } if (act_user_get_uid (um->user) == getuid()) { if (um->passwd_handler != NULL) passwd_destroy (um->passwd_handler); um->passwd_handler = passwd_init (); } } }
static void gcm_picker_sensor_client_setup_ui (GcmPickerPrivate *priv) { gboolean ret = FALSE; GtkWidget *widget; g_autoptr(GError) error = NULL; g_autoptr(GPtrArray) sensors; /* no present */ sensors = cd_client_get_sensors_sync (priv->client, NULL, &error); if (sensors == NULL) { g_warning ("%s", error->message); goto out; } if (sensors->len == 0) { gtk_label_set_label (GTK_LABEL (priv->info_bar_hardware_label), /* TRANSLATORS: this is displayed the user has not got suitable hardware */ _("No colorimeter is attached.")); goto out; } priv->sensor = g_object_ref (g_ptr_array_index (sensors, 0)); /* connect to the profile */ ret = cd_sensor_connect_sync (priv->sensor, NULL, &error); if (!ret) { g_warning ("failed to connect to sensor: %s", error->message); goto out; } if (!cd_sensor_get_native (priv->sensor)) { gtk_label_set_label (GTK_LABEL (priv->info_bar_hardware_label), /* TRANSLATORS: this is displayed if VTE support is not enabled */ _("The sensor has no native driver.")); goto out; } #if 0 /* no support */ ret = cd_sensor_supports_spot (priv->sensor); if (!ret) { /* TRANSLATORS: this is displayed the user has not got suitable hardware */ gtk_label_set_label (GTK_LABEL (priv->info_bar_hardware_label), _("The attached colorimeter is not capable of reading a spot color.")); goto out; } #else ret = TRUE; #endif out: widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "button_measure")); gtk_widget_set_sensitive (widget, ret); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "expander_results")); gtk_widget_set_sensitive (widget, ret && priv->done_measure); gtk_widget_set_visible (priv->info_bar_hardware, !ret); }
static void ch_assemble_set_color (ChAssemblePrivate *priv, gdouble red, gdouble green, gdouble blue) { CdColorRGB color; /* set color */ color.R = red; color.G = green; color.B = blue; cd_sample_widget_set_color (priv->sample_widget, &color); /* force redraw */ gtk_widget_set_visible (GTK_WIDGET (priv->sample_widget), FALSE); gtk_widget_set_visible (GTK_WIDGET (priv->sample_widget), TRUE); }
/** * gtk_search_bar_set_show_close_button: * @bar: a #GtkSearchBar * @visible: whether the close button will be shown or not * * Shows or hides the close button. Applications that * already have a "search" toggle button should not show a close * button in their search bar, as it duplicates the role of the * toggle button. * * Since: 3.10 */ void gtk_search_bar_set_show_close_button (GtkSearchBar *bar, gboolean visible) { GtkSearchBarPrivate *priv = gtk_search_bar_get_instance_private (bar); g_return_if_fail (GTK_IS_SEARCH_BAR (bar)); gtk_widget_set_visible (priv->close_button, visible); }
static void toolbar_update_appearance (NautilusToolbar *self) { gboolean show_location_entry; show_location_entry = self->priv->show_location_entry || g_settings_get_boolean (nautilus_preferences, NAUTILUS_PREFERENCES_ALWAYS_USE_LOCATION_ENTRY); gtk_widget_set_visible (self->priv->toolbar, self->priv->show_main_bar); gtk_widget_set_visible (self->priv->location_bar, show_location_entry); gtk_widget_set_visible (self->priv->path_bar, !show_location_entry); gtk_widget_set_visible (self->priv->search_bar, self->priv->show_search_bar); }
static void _list_preferences_dialog_hide_failure(GtkWidget *dialog) { _ListPreferencesWindowData *windata; g_assert(GTK_IS_DELETABLE_DIALOG(dialog)); windata = (_ListPreferencesWindowData *)g_object_get_data(G_OBJECT(dialog), "windata"); gtk_widget_set_visible(windata->label_failure, FALSE); }
void linphone_gtk_enable_hold_button(LinphoneCall *call, gboolean sensitive, gboolean holdon) { GtkWidget *callview=(GtkWidget*)linphone_call_get_user_pointer (call); GtkWidget *button; g_return_if_fail(callview!=NULL); linphone_gtk_call_update_tab_header(call,!holdon); button=linphone_gtk_get_widget(callview,"hold_call"); gtk_widget_set_sensitive(GTK_WIDGET(button),sensitive); gtk_widget_set_visible(GTK_WIDGET(button),sensitive); linphone_gtk_draw_hold_button(GTK_BUTTON(button),!holdon); }
void MainWindow::setSidebarVisible(bool visible) { XOJ_CHECK_TYPE(MainWindow); GtkWidget * sidebar = get("sidebarContents"); gtk_widget_set_visible(sidebar, visible); control->getSettings()->setSidebarVisible(visible); GtkWidget * w = get("menuViewSidebarVisible"); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(w), visible); }
void gimp_toggle_button_set_visible (GtkToggleButton *toggle, GtkWidget *widget) { g_return_if_fail (GTK_IS_TOGGLE_BUTTON (toggle)); g_return_if_fail (GTK_IS_WIDGET (widget)); gtk_widget_set_visible (widget, gtk_toggle_button_get_active (toggle)); }
static void update_preview (CcBackgroundPanelPrivate *priv, GSettings *settings, CcBackgroundItem *item) { gboolean changes_with_time; CcBackgroundItem *current_background; current_background = CURRENT_BG; if (item && current_background) { g_object_unref (current_background); current_background = cc_background_item_copy (item); if (settings == priv->settings) priv->current_background = current_background; else priv->current_lock_background = current_background; cc_background_item_load (current_background, NULL); } changes_with_time = FALSE; if (current_background) { changes_with_time = cc_background_item_changes_with_time (current_background); } if (settings == priv->settings) { gtk_widget_set_visible (WID ("slide_image"), changes_with_time); gtk_widget_set_visible (WID ("slide-label"), changes_with_time); gtk_widget_queue_draw (WID ("background-desktop-drawingarea")); } else { gtk_widget_set_visible (WID ("slide_image1"), changes_with_time); gtk_widget_set_visible (WID ("slide-label1"), changes_with_time); gtk_widget_queue_draw (WID ("background-lock-drawingarea")); } }
static void operator_callback(GtkWidget *combobox, gpointer user_data) { dt_iop_module_t *self = (dt_iop_module_t *)user_data; dt_iop_global_tonemap_gui_data_t *g = (dt_iop_global_tonemap_gui_data_t *)self->gui_data; if(self->dt->gui->reset) return; dt_iop_global_tonemap_params_t *p = (dt_iop_global_tonemap_params_t *)self->params; p->operator= dt_bauhaus_combobox_get(combobox); gtk_widget_set_visible(g->drago.bias, FALSE); gtk_widget_set_visible(g->drago.max_light, FALSE); /* show ui for selected operator */ if(p->operator== OPERATOR_DRAGO) { gtk_widget_set_visible(g->drago.bias, TRUE); gtk_widget_set_visible(g->drago.max_light, TRUE); } dt_dev_add_history_item(darktable.develop, self, TRUE); }
void on_selection_toggle_button_toggled (GtkToggleButton *togglebutton, gpointer user_data) { return; FsearchApplicationWindow *self = (FsearchApplicationWindow *)user_data; g_assert (FSEARCH_WINDOW_IS_WINDOW (self)); gtk_widget_set_visible (self->selection_popover, gtk_toggle_button_get_active (togglebutton)); }
static void gtk_color_editor_set_use_alpha (GtkColorEditor *editor, gboolean use_alpha) { if (editor->priv->use_alpha != use_alpha) { editor->priv->use_alpha = use_alpha; gtk_widget_set_visible (editor->priv->a_slider, use_alpha); gtk_color_swatch_set_use_alpha (GTK_COLOR_SWATCH (editor->priv->swatch), use_alpha); } }
void egg_search_bar_set_show_close_button (EggSearchBar *self, gboolean show_close_button) { EggSearchBarPrivate *priv = egg_search_bar_get_instance_private (self); g_return_if_fail (EGG_IS_SEARCH_BAR (self)); gtk_widget_set_visible (GTK_WIDGET (priv->close_button), show_close_button); g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_SHOW_CLOSE_BUTTON]); }
/* * helpers: */ static void _list_preferences_dialog_show_failure(GtkWidget *dialog, const gchar *message) { _ListPreferencesWindowData *windata; g_assert(GTK_IS_DELETABLE_DIALOG(dialog)); windata = (_ListPreferencesWindowData *)g_object_get_data(G_OBJECT(dialog), "windata"); gtk_widget_set_visible(windata->label_failure, TRUE); gtk_label_set_text(GTK_LABEL(windata->label_failure), message); }
static void glade_recent_chooser_editor_load (GladeEditable *editable, GladeWidget *gwidget) { GladeRecentChooserEditor *recent_editor = GLADE_RECENT_CHOOSER_EDITOR (editable); GladeRecentChooserEditorPrivate *priv = recent_editor->priv; /* Chain up to default implementation */ parent_editable_iface->load (editable, gwidget); if (gwidget) { GObject *object = glade_widget_get_object (gwidget); gboolean has_show_numbers = (GTK_IS_RECENT_ACTION (object) || GTK_IS_RECENT_CHOOSER_MENU (object)); /* Update subclass specific editor visibility */ gtk_widget_set_visible (priv->select_multiple_editor, !has_show_numbers); gtk_widget_set_visible (priv->show_numbers_editor, has_show_numbers); } }
void ghb_show_hide_advanced_video( signal_user_data_t *ud ) { gboolean hide; hide = ghb_settings_get_boolean(ud->prefs, "HideAdvancedVideoSettings"); if (hide) { ghb_ui_update(ud, "x264UseAdvancedOptions", ghb_boolean_value(FALSE)); } GtkWidget *widget; GtkWidget *nb = GHB_WIDGET(ud->builder, "SettingsNotebook"); GtkWidget *at = GHB_WIDGET(ud->builder, "advanced_tab"); int pgn = gtk_notebook_page_num(GTK_NOTEBOOK(nb), at); widget = gtk_notebook_get_nth_page(GTK_NOTEBOOK(nb), pgn); gtk_widget_set_visible(widget, !hide); widget = GHB_WIDGET(ud->builder, "x264UseAdvancedOptions"); gtk_widget_set_visible(widget, !hide); }
void gui_update(dt_iop_module_t *self) { self->request_color_pick = DT_REQUEST_COLORPICK_OFF; dt_iop_invert_gui_data_t *g = (dt_iop_invert_gui_data_t *)self->gui_data; gtk_widget_set_visible(GTK_WIDGET(g->pickerbuttons), TRUE); dtgtk_reset_label_set_text(g->label, _("color of film material")); gui_update_from_coeffs(self); }
static void gcal_event_widget_set_event_internal (GcalEventWidget *self, GcalEvent *event) { g_autofree gchar *hour_str = NULL; /* * This function is called only once, since the property is * set as CONSTRUCT_ONLY. Any other attempt to set an event * will be ignored. * * Because of that condition, we don't really have to care about * disconnecting functions or cleaning up the previous event. */ /* The event spawns with a floating reference, and we take it's ownership */ g_set_object (&self->event, event); /* * Initially, the widget's start and end dates are the same * of the event's ones. We may change it afterwards. */ gcal_event_widget_set_date_start (self, gcal_event_get_date_start (event)); gcal_event_widget_set_date_end (self, gcal_event_get_date_end (event)); /* Update color */ update_color (self); g_signal_connect_swapped (event, "notify::color", G_CALLBACK (update_color), self); g_signal_connect_swapped (event, "notify::summary", G_CALLBACK (gtk_widget_queue_draw), self); /* Tooltip */ gcal_event_widget_set_event_tooltip (self, event); /* Hour label */ hour_str = get_hour_label (self); gtk_widget_set_visible (self->hour_label, !gcal_event_get_all_day (event)); gtk_label_set_label (GTK_LABEL (self->hour_label), hour_str); /* Summary label */ g_object_bind_property (event, "summary", self->summary_label, "label", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE); }
static void device_changed (GsdDeviceManager *device_manager, GsdDevice *device, CcMousePropertiesPrivate *d) { d->have_touchpad = have_device_type (d->device_manager, GSD_DEVICE_TYPE_TOUCHPAD); gtk_widget_set_visible (WID ("touchpad_vbox"), d->have_touchpad); if (d->have_touchpad) { d->changing_scroll = TRUE; synaptics_check_capabilities (d); setup_scrollmethod_radios (d); d->changing_scroll = FALSE; } d->have_mouse = have_device_type (d->device_manager, GSD_DEVICE_TYPE_MOUSE); gtk_widget_set_visible (WID ("mouse_vbox"), d->have_mouse); gtk_widget_set_visible (WID ("touchpad_enabled_switch"), show_touchpad_enabling_switch (d)); }
static void device_changed (GdkDeviceManager *device_manager, GdkDevice *device, GtkBuilder *dialog) { gboolean present; present = touchpad_is_present (); gtk_widget_set_visible (WID ("touchpad_vbox"), present); if (present) { changing_scroll = TRUE; synaptics_check_capabilities (dialog); setup_scrollmethod_radios (dialog); changing_scroll = FALSE; } present = mouse_is_present (); gtk_widget_set_visible (WID ("mouse_vbox"), present); }
void infoscreengui_set_message (GuInfoscreenGui *is, const gchar *msg) { gtk_widget_set_visible (GTK_WIDGET(is->image), TRUE); if (STR_EQU (msg, "compile_error")) { gtk_label_set_text (is->header, get_infoheader(1)); gtk_label_set_text (is->details, get_infodetails(1)); } else if (STR_EQU (msg, "document_error")) { gtk_label_set_text (is->header, get_infoheader(2)); gtk_label_set_text (is->details, get_infodetails(2)); } else if (STR_EQU (msg, "program_error")) { gtk_label_set_text (is->header, get_infoheader(3)); gtk_label_set_text (is->details, get_infodetails(3)); } else { gtk_label_set_text (is->header, get_infoheader(4)); gtk_label_set_text (is->details, get_infodetails(4)); gtk_widget_set_visible (GTK_WIDGET(is->image), FALSE); } }
void gd_notification_set_show_close_button (GdNotification *notification, gboolean show_close_button) { GdNotificationPrivate *priv = notification->priv; priv->show_close_button = show_close_button; gtk_widget_set_visible (priv->close_button, show_close_button); gtk_widget_queue_resize (GTK_WIDGET (notification)); }
/** * mcm_calibrate_dialog_pop: **/ void mcm_calibrate_dialog_pop (McmCalibrateDialog *calibrate_dialog) { McmCalibrateDialogPrivate *priv = calibrate_dialog->priv; GtkWidget *widget; gchar *text; guint len; McmCalibrateDialogItem *dialog; /* save in case we need to reuse */ len = priv->cached_dialogs->len; if (len < 2) { egg_warning ("cannot pop dialog as nothing to recover"); return; } dialog = g_ptr_array_index (priv->cached_dialogs, len-2); /* set the text */ text = g_strdup_printf ("<big><b>%s</b></big>", dialog->title); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "label_title")); gtk_label_set_markup (GTK_LABEL(widget), text); g_free (text); /* set the text */ widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "label_message")); gtk_label_set_markup (GTK_LABEL(widget), dialog->message); /* show the okay button */ widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "button_ok")); gtk_widget_set_visible (widget, dialog->show_okay); /* show the expander */ widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "expander_details")); gtk_widget_set_visible (widget, dialog->show_expander); /* show the correct image */ mcm_calibrate_dialog_set_image_filename_private (calibrate_dialog, dialog->image_filename); /* remove from the stack */ g_ptr_array_remove_index (priv->cached_dialogs, len-1); }
static void subtitle_update_pref_lang(signal_user_data_t *ud, const iso639_lang_t *lang) { GtkLabel *label; GtkButton *button; gchar *str; const char * name = _("None"); const char * code = "und"; label = GTK_LABEL(GHB_WIDGET(ud->builder, "subtitle_preferred_language")); if (lang != NULL) { code = lang->iso639_2; if (strncmp(code, "und", 4)) { name = lang->native_name && lang->native_name[0] ? lang->native_name : lang->eng_name; } } str = g_strdup_printf(_("Preferred Language: %s"), name); gtk_label_set_text(label, str); g_free(str); ghb_settings_set_string(ud->settings, "PreferredLanguage", code); button = GTK_BUTTON(GHB_WIDGET(ud->builder, "SubtitleAddForeignAudioSubtitle")); str = g_strdup_printf(_("Add %s subtitle track if default audio is not %s"), name, name); gtk_button_set_label(button, str); g_free(str); // If there is no preferred language, hide options that require // a preferred language to be set. gboolean visible = !(lang == NULL || !strncmp(code, "und", 4)); gtk_widget_set_visible(GTK_WIDGET(button), visible); button = GTK_BUTTON(GHB_WIDGET(ud->builder, "SubtitleAddForeignAudioSearch")); gtk_widget_set_visible(GTK_WIDGET(button), visible); }
/** * show alert/error message * * @param message printable text that will be presented to the user */ void ui_log_alert_show( char *message, ...) { /* just hide when message is NULL */ if(!message) { gtk_widget_set_visible(GTK_WIDGET(UI("alert_dialog")), FALSE); return; } /* allocate mem to build message */ char *tmp; if(!(tmp = alloca(MAX_MSG_SIZE))) { NFT_LOG_PERROR("alloca"); return; } /* build message */ va_list ap; va_start(ap, message); /* print log-string */ if(vsnprintf((char *) tmp, MAX_MSG_SIZE, message, ap) < 0) { NFT_LOG_PERROR("vsnprintf"); return; } va_end(ap); /* putout message through niftyled log mechanism also */ NFT_LOG(L_ERROR, "%s", tmp); /* set message */ gtk_label_set_text(GTK_LABEL(UI("alert_label")), tmp); /* show dialog */ gtk_widget_set_visible(GTK_WIDGET(UI("alert_dialog")), TRUE); }