static void case_sensitive_toggled_cb (GtkWidget *check, EphyFindToolbar *toolbar) { gboolean case_sensitive; GtkWidget *proxy; case_sensitive = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (check)); proxy = gtk_tool_item_get_proxy_menu_item (GTK_TOOL_ITEM (gtk_widget_get_parent (check)), "menu-proxy"); if (proxy != NULL) { g_signal_handlers_block_by_func (proxy, G_CALLBACK (case_sensitive_menu_toggled_cb), toolbar); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (proxy), case_sensitive); g_signal_handlers_unblock_by_func (proxy, G_CALLBACK (case_sensitive_menu_toggled_cb), toolbar); } #ifdef HAVE_WEBKIT2 do_search (toolbar); #else ephy_find_toolbar_mark_matches (toolbar); /* * If we now use the stricter method (and are case sensitive), * check that the current selection still matches. If not, find the * next one. * This currently requires going back and then forward, because * there's no function in WebKit that would verify the current selection. */ if (case_sensitive) { EphyFindResult result; result = real_find (toolbar->priv, EPHY_FIND_DIRECTION_PREV); if (result != EPHY_FIND_RESULT_NOTFOUND) result = real_find (toolbar->priv, EPHY_FIND_DIRECTION_NEXT); set_status (toolbar, result); } #endif }
static void gimp_rotate_tool_prepare (GimpTransformTool *tr_tool) { GimpRotateTool *rotate = GIMP_ROTATE_TOOL (tr_tool); GimpDisplay *display = GIMP_TOOL (tr_tool)->display; GimpImage *image = gimp_display_get_image (display); gdouble xres; gdouble yres; tr_tool->px = (gdouble) (tr_tool->x1 + tr_tool->x2) / 2.0; tr_tool->py = (gdouble) (tr_tool->y1 + tr_tool->y2) / 2.0; tr_tool->trans_info[ANGLE] = 0.0; tr_tool->trans_info[REAL_ANGLE] = 0.0; tr_tool->trans_info[PIVOT_X] = tr_tool->px; tr_tool->trans_info[PIVOT_Y] = tr_tool->py; gimp_image_get_resolution (image, &xres, &yres); g_signal_handlers_block_by_func (rotate->sizeentry, rotate_center_changed, tr_tool); gimp_size_entry_set_unit (GIMP_SIZE_ENTRY (rotate->sizeentry), gimp_display_get_shell (display)->unit); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (rotate->sizeentry), 0, xres, FALSE); gimp_size_entry_set_resolution (GIMP_SIZE_ENTRY (rotate->sizeentry), 1, yres, FALSE); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (rotate->sizeentry), 0, -65536, 65536 + gimp_image_get_width (image)); gimp_size_entry_set_refval_boundaries (GIMP_SIZE_ENTRY (rotate->sizeentry), 1, -65536, 65536 + gimp_image_get_height (image)); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (rotate->sizeentry), 0, tr_tool->x1, tr_tool->x2); gimp_size_entry_set_size (GIMP_SIZE_ENTRY (rotate->sizeentry), 1, tr_tool->y1, tr_tool->y2); g_signal_handlers_unblock_by_func (rotate->sizeentry, rotate_center_changed, tr_tool); }
static void panel_desktop_menu_item_on_presence_changed (PanelSessionManager *manager, PanelSessionManagerPresenceType presence_type, PanelDesktopMenuItem *desktop_item) { const char *icon; GtkWidget *image; GList *l; switch (presence_type) { case PANEL_SESSION_MANAGER_PRESENCE_AVAILABLE: icon = PANEL_ICON_USER_AVAILABLE; break; case PANEL_SESSION_MANAGER_PRESENCE_INVISIBLE: icon = PANEL_ICON_USER_INVISIBLE; break; case PANEL_SESSION_MANAGER_PRESENCE_BUSY: icon = PANEL_ICON_USER_BUSY; break; case PANEL_SESSION_MANAGER_PRESENCE_IDLE: default: icon = PANEL_ICON_USER_IDLE; break; } image = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (desktop_item)); /* we only have an image if we are specifically using an icon for this * menu */ if (image) { gtk_image_set_from_icon_name (GTK_IMAGE (image), icon, panel_menu_icon_get_size ()); } for (l = desktop_item->priv->presence_items; l != NULL; l = l->next) { PanelSessionManagerPresenceType for_presence; GObject *object = l->data; for_presence = GPOINTER_TO_INT (g_object_get_data (object, "panel-menu-presence")); g_signal_handlers_block_by_func (object, panel_menu_item_activate_presence, desktop_item->priv->account_manager); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (object), for_presence == presence_type); g_signal_handlers_unblock_by_func (object, panel_menu_item_activate_presence, desktop_item->priv->account_manager); } }
static void update_ui (PlumaSpellPlugin *plugin) { PlumaSpellPluginPrivate *data; PlumaWindow *window; PlumaDocument *doc; PlumaView *view; gboolean autospell; GtkAction *action; pluma_debug (DEBUG_PLUGINS); data = plugin->priv; window = PLUMA_WINDOW (data->window); doc = pluma_window_get_active_document (window); view = pluma_window_get_active_view (window); autospell = (doc != NULL && pluma_automatic_spell_checker_get_from_document (doc) != NULL); if (doc != NULL) { PlumaTab *tab; PlumaTabState state; tab = pluma_window_get_active_tab (window); state = pluma_tab_get_state (tab); /* If the document is loading we can't get the metadata so we endup with an useless speller */ if (state == PLUMA_TAB_STATE_NORMAL) { action = gtk_action_group_get_action (data->action_group, "AutoSpell"); g_signal_handlers_block_by_func (action, auto_spell_cb, plugin); set_auto_spell (window, doc, autospell); gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), autospell); g_signal_handlers_unblock_by_func (action, auto_spell_cb, plugin); } } gtk_action_group_set_sensitive (data->action_group, (view != NULL) && gtk_text_view_get_editable (GTK_TEXT_VIEW (view))); }
static void gimp_text_style_editor_set_toggle (GimpTextStyleEditor *editor, GtkToggleButton *toggle, gboolean active) { g_signal_handlers_block_by_func (toggle, gimp_text_style_editor_tag_toggled, editor); gtk_toggle_button_set_active (toggle, active); g_signal_handlers_unblock_by_func (toggle, gimp_text_style_editor_tag_toggled, editor); }
/************************************************************************ * Utilities * ************************************************************************/ static void cursor_example_load_alphabet (CursorExample *example) { CursorExamplePrivate *priv = example->priv; const gchar *const *alphabet; /* Update the alphabet on the navigator */ alphabet = e_book_client_cursor_get_alphabet (priv->cursor, NULL, NULL, NULL, NULL); cursor_navigator_set_alphabet (priv->navigator, alphabet); /* Reset navigator to the beginning */ g_signal_handlers_block_by_func (priv->navigator, cursor_example_navigator_changed, example); cursor_navigator_set_index (priv->navigator, 0); g_signal_handlers_unblock_by_func (priv->navigator, cursor_example_navigator_changed, example); }
static void update_fade_spins(void) { int fade = patch_get_fade_samples(se->patch); int max_fade = patch_get_max_fade_samples(se->patch); int xfade = patch_get_xfade_samples(se->patch); int max_xfade = patch_get_max_xfade_samples(se->patch); g_signal_handlers_block_by_func(se->fade_spin, cb_fade_spin_changed, 0); gtk_spin_button_set_range(GTK_SPIN_BUTTON(se->fade_spin), 0, max_fade); gtk_spin_button_set_value(GTK_SPIN_BUTTON(se->fade_spin), fade); g_signal_handlers_unblock_by_func( se->fade_spin, cb_fade_spin_changed, 0); g_signal_handlers_block_by_func(se->xfade_spin, cb_xfade_spin_changed, 0); gtk_spin_button_set_range(GTK_SPIN_BUTTON(se->xfade_spin), 0, max_xfade); gtk_spin_button_set_value(GTK_SPIN_BUTTON(se->xfade_spin), xfade); g_signal_handlers_unblock_by_func(se->xfade_spin, cb_xfade_spin_changed, 0); }
/* Update the mute checkbox according to the current audio state. */ static void update_mute_check(GtkToggleButton *mute_check, GCallback handler_func, gpointer handler_data, gboolean muted) { gint n_blocked; n_blocked = g_signal_handlers_block_by_func (G_OBJECT(mute_check), DATA_PTR(handler_func), handler_data); g_assert(n_blocked == 1); gtk_toggle_button_set_active(mute_check, muted); g_signal_handlers_unblock_by_func (G_OBJECT(mute_check), DATA_PTR(handler_func), handler_data); }
static bool_t update (GObject * object) { int64_t pos = 0; int vol = 0; if (aud_drct_get_playing () && aud_drct_get_ready ()) pos = (int64_t) aud_drct_get_time () * 1000; aud_drct_get_volume_main (& vol); g_signal_handlers_block_by_func (object, (void *) volume_changed, NULL); g_object_set (object, "position", pos, "volume", (double) vol / 100, NULL); g_signal_handlers_unblock_by_func (object, (void *) volume_changed, NULL); return TRUE; }
bool wxGtkCalendarCtrl::SetDate(const wxDateTime& date) { if ( date.IsValid() && !IsInValidRange(date) ) return false; g_signal_handlers_block_by_func(m_widget, (gpointer) gtk_day_selected_callback, this); g_signal_handlers_block_by_func(m_widget, (gpointer) gtk_month_changed_callback, this); m_selectedDate = date; int year = date.GetYear(); int month = date.GetMonth(); int day = date.GetDay(); gtk_calendar_select_month(GTK_CALENDAR(m_widget), month, year); gtk_calendar_select_day(GTK_CALENDAR(m_widget), day); g_signal_handlers_unblock_by_func( m_widget, (gpointer) gtk_month_changed_callback, this); g_signal_handlers_unblock_by_func( m_widget, (gpointer) gtk_day_selected_callback, this); return true; }
static void _lib_filter_compare_button_changed(GtkDarktableToggleButton *widget, gpointer user_data) { g_signal_handlers_block_by_func(widget, _lib_filter_compare_button_changed, user_data); dt_collection_rating_comperator_t comparator = dt_collection_get_rating_comparator(darktable.collection); comparator = (comparator + 1) % DT_COLLECTION_RATING_N_COMPS; dt_collection_set_rating_comparator(darktable.collection, comparator); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), FALSE); gtk_button_set_label(GTK_BUTTON(widget), comparators[comparator]); g_signal_handlers_unblock_by_func(widget, _lib_filter_compare_button_changed, user_data); _lib_filter_update_query(user_data); }
void nyth_dcu_frame_set_value_blocked(NythDcuFrame *frame, guint new_value) { GSList *child; guint value; for (child = frame->priv->radios; child; child = g_slist_next(child)) { value = GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(child->data), state_key)); if (value == new_value) { g_signal_handlers_block_by_func(G_OBJECT(child->data), radio_toggled_cb, frame); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(child->data), TRUE); g_signal_handlers_unblock_by_func(G_OBJECT(child->data), radio_toggled_cb, frame); break; } } }
static void gimp_text_options_notify_font (GimpContext *context, GParamSpec *pspec, GimpText *text) { g_signal_handlers_block_by_func (text, gimp_text_options_notify_text_font, context); g_object_set (text, "font", gimp_context_get_font_name (context), NULL); g_signal_handlers_unblock_by_func (text, gimp_text_options_notify_text_font, context); }
static void gnc_currency_edit_active_changed (GtkComboBox *gobject, gpointer user_data) { GNCCurrencyEdit *self = GNC_CURRENCY_EDIT (gobject); GNCCurrencyEditPrivate *priv = GET_PRIVATE (self); gnc_commodity *currency = gnc_currency_edit_get_currency (self); const gchar *mnemonic = gnc_commodity_get_mnemonic (currency); g_signal_handlers_block_by_func(G_OBJECT(self), G_CALLBACK(gnc_currency_edit_active_changed), user_data); g_object_set (G_OBJECT (self), "mnemonic", mnemonic, NULL); g_signal_handlers_unblock_by_func(G_OBJECT(self), G_CALLBACK(gnc_currency_edit_active_changed), user_data); }
static void toggle_toolbar_search_button (NemoWindowPane *pane) { GtkActionGroup *group; GtkAction *action; group = pane->action_group; action = gtk_action_group_get_action (group, NEMO_ACTION_SEARCH); g_signal_handlers_block_by_func (action, action_show_hide_search_callback, pane); gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), TRUE); g_signal_handlers_unblock_by_func (action, action_show_hide_search_callback, pane); }
static void bar_pane_keywords_update(PaneKeywordsData *pkd) { GList *keywords = NULL; GtkTextBuffer *keyword_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(pkd->keyword_view)); g_signal_handlers_block_by_func(keyword_buffer, bar_pane_keywords_changed, pkd); keywords = metadata_read_list(pkd->fd, KEYWORD_KEY, METADATA_PLAIN); keyword_list_push(pkd->keyword_view, keywords); bar_keyword_tree_sync(pkd); string_list_free(keywords); g_signal_handlers_unblock_by_func(keyword_buffer, bar_pane_keywords_changed, pkd); }
static void scale_value_received(GtkObject *object, gpointer arg1, gpointer user_data) { CtkEventStruct *event_struct; CtkImageSliders *ctk_image_sliders = CTK_IMAGE_SLIDERS(user_data); GtkAdjustment *adj; GtkWidget *scale; gint val; event_struct = (CtkEventStruct *) arg1; switch (event_struct->attribute) { case NV_CTRL_DIGITAL_VIBRANCE: scale = ctk_image_sliders->digital_vibrance; break; case NV_CTRL_IMAGE_SHARPENING: scale = ctk_image_sliders->image_sharpening; break; default: return; } if (event_struct->is_availability_changed) { setup_scale(ctk_image_sliders, event_struct->attribute, scale); } adj = CTK_SCALE(scale)->gtk_adjustment; val = gtk_adjustment_get_value(GTK_ADJUSTMENT(adj)); if (val != event_struct->value) { val = event_struct->value; g_signal_handlers_block_by_func(adj, scale_value_changed, ctk_image_sliders); gtk_adjustment_set_value(GTK_ADJUSTMENT(adj), val); post_scale_value_changed(GTK_ADJUSTMENT(adj), ctk_image_sliders, val); g_signal_handlers_unblock_by_func(adj, scale_value_changed, ctk_image_sliders); } } /* scale_value_received() */
static void colorsel_cmyk_set_color (GimpColorSelector *selector, const GimpRGB *rgb, const GimpHSV *hsv) { ColorselCmyk *module = COLORSEL_CMYK (selector); gdouble values[4]; gint i; if (module->rgb2cmyk) { gdouble rgb_values[3]; gdouble cmyk_values[4]; rgb_values[0] = rgb->r; rgb_values[1] = rgb->g; rgb_values[2] = rgb->b; cmsDoTransform (module->rgb2cmyk, rgb_values, cmyk_values, 1); module->cmyk.c = cmyk_values[0] / 100.0; module->cmyk.m = cmyk_values[1] / 100.0; module->cmyk.y = cmyk_values[2] / 100.0; module->cmyk.k = cmyk_values[3] / 100.0; } else { gimp_rgb_to_cmyk (rgb, 1.0, &module->cmyk); } values[0] = module->cmyk.c * 100.0; values[1] = module->cmyk.m * 100.0; values[2] = module->cmyk.y * 100.0; values[3] = module->cmyk.k * 100.0; for (i = 0; i < 4; i++) { g_signal_handlers_block_by_func (module->adj[i], colorsel_cmyk_adj_update, module); gtk_adjustment_set_value (module->adj[i], values[i]); g_signal_handlers_unblock_by_func (module->adj[i], colorsel_cmyk_adj_update, module); } }
static void gimp_color_notebook_set_channel (GimpColorSelector *selector, GimpColorSelectorChannel channel) { GimpColorNotebook *notebook = GIMP_COLOR_NOTEBOOK (selector); g_signal_handlers_block_by_func (notebook->cur_page, gimp_color_notebook_channel_changed, notebook); gimp_color_selector_set_channel (notebook->cur_page, channel); g_signal_handlers_unblock_by_func (notebook->cur_page, gimp_color_notebook_channel_changed, notebook); }
static void check_rotation_menu_item(struct screen_info *info, xcb_randr_rotation_t rotation, gboolean is_active) { GtkWidget *item = info->rotation_menu_items[rotation]; if (!item) { g_warning("Unknown rotation item\n"); return; } g_signal_handlers_block_by_func(G_OBJECT(item), G_CALLBACK(menu_on_item), (gpointer)info); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), is_active); g_signal_handlers_unblock_by_func(G_OBJECT(item), G_CALLBACK(menu_on_item), (gpointer)info); }
void wxComboBox::EnableTextChangedEvents(bool enable) { if ( !GetEntry() ) return; if ( enable ) { g_signal_handlers_unblock_by_func(gtk_bin_get_child(GTK_BIN(m_widget)), (gpointer)gtkcombobox_text_changed_callback, this); } else // disable { g_signal_handlers_block_by_func(gtk_bin_get_child(GTK_BIN(m_widget)), (gpointer)gtkcombobox_text_changed_callback, this); } }
static void update_script_list (DialogData *data) { GthScriptFile *script_file; GList *script_list; g_signal_handlers_block_by_func (data->list_store, row_deleted_cb, data); gtk_list_store_clear (data->list_store); g_signal_handlers_unblock_by_func (data->list_store, row_deleted_cb, data); script_file = gth_script_file_get (); script_list = gth_script_file_get_scripts (script_file); set_script_list (data, script_list); _g_object_list_unref (script_list); }
static void rotate_adjustment_changed (GtkAdjustment *adj, RotateDialogData *dialog) { gdouble angle = gtk_adjustment_get_value (dialog->rotate_adj); g_signal_handlers_block_by_func (dialog->shell, display_shell_rotated, dialog); gimp_display_shell_rotate_to (dialog->shell, angle); g_signal_handlers_unblock_by_func (dialog->shell, display_shell_rotated, dialog); }
static void populate_regions (GtkBuilder *builder, const gchar *current_lang) { gchar *current_region; GSettings *locale_settings; GHashTable *ht; GHashTableIter htiter; GtkTreeModel *model; gchar *name, *language; GtkWidget *treeview; GtkTreeIter iter; GtkTreeSelection *selection; treeview = GTK_WIDGET (gtk_builder_get_object (builder, "region_selector")); /* don't update the setting just because the list is repopulated */ selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview)); g_signal_handlers_block_by_func (selection, update_settings_cb, builder); model = gtk_tree_view_get_model (GTK_TREE_VIEW (treeview)); locale_settings = g_object_get_data (G_OBJECT (treeview), "settings"); ht = cc_common_language_get_initial_regions (current_lang); current_region = g_settings_get_string (locale_settings, "region"); if (!current_region || !current_region[0]) { current_region = g_strdup (current_lang); } else if (!g_hash_table_lookup (ht, current_region)) { name = gdm_get_region_from_name (current_region, NULL); g_hash_table_insert (ht, g_strdup (current_region), name); } gtk_list_store_clear (GTK_LIST_STORE (model)); g_hash_table_iter_init (&htiter, ht); while (g_hash_table_iter_next (&htiter, (gpointer *)&name, (gpointer *)&language)) { gtk_list_store_append (GTK_LIST_STORE (model), &iter); gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, name, 1, language, -1); } g_hash_table_unref (ht); select_region (GTK_TREE_VIEW (treeview), current_region); g_free (current_region); g_signal_handlers_unblock_by_func (selection, update_settings_cb, builder); }
/* A tab of a browser was reordered */ static void _interface_tweaks_on_tab_reordered(InterfaceTweaks *self, GtkWidget *inChild, guint inPageNumber, gpointer inUserData) { g_return_if_fail(IS_INTERFACE_TWEAKS(self)); g_return_if_fail(MIDORI_IS_VIEW(inChild)); g_return_if_fail(GTK_IS_NOTEBOOK(inUserData)); InterfaceTweaksPrivate *priv=self->priv; MidoriView *view=MIDORI_VIEW(inChild); GtkNotebook *notebook=GTK_NOTEBOOK(inUserData); MidoriBrowser *browser; gboolean minimized; gint firstMaximizedPosition; /* Check if tab we should group minimized tabs to front */ if(!priv->groupMinimizedTabs) return; /* Check if tab was minimized */ minimized=FALSE; g_object_get(view, "minimized", &minimized, NULL); /* Get browser of tab */ browser=midori_browser_get_for_widget(GTK_WIDGET(view)); if(!browser) return; /* Find position of first maximized tab */ firstMaximizedPosition=_interface_tweak_get_browser_first_maximized_tab_position(browser, view); /* If tab is maximized then it moves away from front and * the position must be decreased by one to get the first maximized tab */ if(!minimized) firstMaximizedPosition--; /* Reorder tab now */ if(firstMaximizedPosition<0) firstMaximizedPosition=0; if((minimized==TRUE && inPageNumber>=firstMaximizedPosition) || (minimized==FALSE && inPageNumber<firstMaximizedPosition)) { g_signal_handlers_block_by_func(view, G_CALLBACK(_interface_tweaks_on_notify_minimized_tab_for_group_tabs), self); gtk_notebook_reorder_child(GTK_NOTEBOOK(notebook), GTK_WIDGET(view), firstMaximizedPosition); g_signal_handlers_unblock_by_func(view, G_CALLBACK(_interface_tweaks_on_notify_minimized_tab_for_group_tabs), self); } }
static void gimp_tool_preset_editor_set_data (GimpDataEditor *editor, GimpData *data) { GimpToolPresetEditor *preset_editor = GIMP_TOOL_PRESET_EDITOR (editor); if (editor->data) g_signal_handlers_disconnect_by_func (editor->data, gimp_tool_preset_editor_notify_data, editor); GIMP_DATA_EDITOR_CLASS (parent_class)->set_data (editor, data); if (editor->data) { GimpToolInfo *tool_info; const gchar *stock_id; gchar *label; g_signal_handlers_block_by_func (preset_editor->tool_preset_model, gimp_tool_preset_editor_notify_model, editor); gimp_config_copy (GIMP_CONFIG (editor->data), GIMP_CONFIG (preset_editor->tool_preset_model), GIMP_CONFIG_PARAM_SERIALIZE); g_signal_handlers_unblock_by_func (preset_editor->tool_preset_model, gimp_tool_preset_editor_notify_model, editor); g_signal_connect (editor->data, "notify", G_CALLBACK (gimp_tool_preset_editor_notify_data), editor); tool_info = preset_editor->tool_preset_model->tool_options->tool_info; stock_id = gimp_viewable_get_stock_id (GIMP_VIEWABLE (tool_info)); label = g_strdup_printf (_("%s Preset"), tool_info->blurb); gtk_image_set_from_stock (GTK_IMAGE (preset_editor->tool_icon), stock_id, GTK_ICON_SIZE_MENU); gtk_label_set_text (GTK_LABEL (preset_editor->tool_label), label); g_free (label); } }
static void set_column_order (CajaColumnChooser *chooser, char **column_order) { GList *columns; GList *l; GtkTreePath *path; columns = caja_get_columns_for_file (chooser->details->file); columns = caja_sort_columns (columns, column_order); g_signal_handlers_block_by_func (chooser->details->store, G_CALLBACK (row_deleted_callback), chooser); path = gtk_tree_path_new_first (); for (l = columns; l != NULL; l = l->next) { GtkTreeIter iter; if (get_column_iter (chooser, CAJA_COLUMN (l->data), &iter)) { GtkTreeIter before; if (path) { gtk_tree_model_get_iter (GTK_TREE_MODEL (chooser->details->store), &before, path); gtk_list_store_move_after (chooser->details->store, &iter, &before); gtk_tree_path_next (path); } else { gtk_list_store_move_after (chooser->details->store, &iter, NULL); } } } gtk_tree_path_free (path); g_signal_handlers_unblock_by_func (chooser->details->store, G_CALLBACK (row_deleted_callback), chooser); caja_column_list_free (columns); }
static void palette_color_notify_cb (GtkColorButton *button, GParamSpec *pspec, TerminalProfile *profile) { GtkWidget *editor; GdkColor color; guint i; gtk_color_button_get_color (button, &color); i = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (button), "palette-entry-index")); editor = gtk_widget_get_toplevel (GTK_WIDGET (button)); g_signal_handlers_block_by_func (profile, G_CALLBACK (profile_palette_notify_colorpickers_cb), editor); terminal_profile_modify_palette_entry (profile, i, &color); g_signal_handlers_unblock_by_func (profile, G_CALLBACK (profile_palette_notify_colorpickers_cb), editor); }
static void profile_palette_notify_scheme_combo_cb (TerminalProfile *profile, GParamSpec *pspec, GtkComboBox *combo) { guint i; if (!terminal_profile_get_palette_is_builtin (profile, &i)) /* If we didn't find a match, then we want the last combo * box item which is "custom" */ i = TERMINAL_PALETTE_N_BUILTINS; g_signal_handlers_block_by_func (combo, G_CALLBACK (palette_scheme_combo_changed_cb), profile); gtk_combo_box_set_active (combo, i); g_signal_handlers_unblock_by_func (combo, G_CALLBACK (palette_scheme_combo_changed_cb), profile); }
static void gimp_text_style_editor_set_default_size (GimpTextStyleEditor *editor) { gdouble pixels = gimp_units_to_pixels (editor->text->font_size, editor->text->unit, editor->resolution_y); g_signal_handlers_block_by_func (editor->size_entry, gimp_text_style_editor_size_changed, editor); gimp_size_entry_set_refval (GIMP_SIZE_ENTRY (editor->size_entry), 0, pixels); g_signal_handlers_unblock_by_func (editor->size_entry, gimp_text_style_editor_size_changed, editor); }