/****************************************************************************
Temporarily disable signal invocation of the given callback for the given
GObject. Re-enable the signal with enable_gobject_callback.
****************************************************************************/
void disable_gobject_callback(GObject *obj, GCallback cb)
{
gulong hid;
if (!obj || !cb) {
return;
}
hid = g_signal_handler_find(obj, G_SIGNAL_MATCH_FUNC,
0, 0, NULL, cb, NULL);
g_signal_handler_block(obj, hid);
}
static void add_button_clicked(GtkButton *button, XmiMsimGuiLayerDialog *dialog) {
//make entries empty and disable OK button
GtkWidget *compound_dialog = xmi_msim_gui_compound_dialog_new(GTK_WINDOW(dialog), XMI_MSIM_GUI_COMPOUND_DIALOG_TYPE_ADD);
int rv = gtk_dialog_run(GTK_DIALOG(compound_dialog));
if (rv == GTK_RESPONSE_ACCEPT) {
//something was changed
gchar *compound = xmi_msim_gui_compound_dialog_get_compound(XMI_MSIM_GUI_COMPOUND_DIALOG(compound_dialog));
gdouble compound_weight = xmi_msim_gui_compound_dialog_get_weight(XMI_MSIM_GUI_COMPOUND_DIALOG(compound_dialog));
struct compoundData *cd, *cd2, *cdsum;
cd2 = CompoundParser(compound);
//get current composition
int n_elements, *Z;
double *weight;
xmi_msim_gui_layer_dialog_get_composition(dialog, &n_elements, &Z, &weight);
if (n_elements > 0) {
xmi_layer layer = {n_elements, Z, weight, 0.0, 0.0};
//copy xmi_layer to compoundData and add current contents
cd = xmi_layer2compoundData(&layer);
//calculate sum
cdsum = add_compound_data(*cd, 1.0, *cd2, compound_weight/100.0);
xmi_msim_gui_layer_dialog_set_composition(dialog, cdsum->nElements, cdsum->Elements, cdsum->massFractions);
g_free(Z);
g_free(weight);
FreeCompoundData(cdsum);
FreeCompoundData(cd);
}
else {
//list is empty!
xmi_scale_double(cd2->massFractions, cd2->nElements, compound_weight/100.0);
if (cd2->nElements == 1) {
// if compound
double density = ElementDensity(cd2->Elements[0]);
gchar *buffer = g_strdup_printf("%f", density);
g_signal_handler_block(G_OBJECT(dialog->densityEntry), dialog->density_changed);
gtk_entry_set_text(GTK_ENTRY(dialog->densityEntry), buffer);
g_signal_handler_unblock(G_OBJECT(dialog->densityEntry), dialog->density_changed);
g_free(buffer);
}
xmi_msim_gui_layer_dialog_set_composition(dialog, cd2->nElements, cd2->Elements, cd2->massFractions);
}
FreeCompoundData(cd2);
}
gtk_widget_destroy(compound_dialog);
return;
}
gint keypress (GtkWidget *widget, GdkEventKey *key)
{
int game_area;
if (widget == app)
{
int cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook));
int pfields_page = gtk_notebook_page_num(GTK_NOTEBOOK(notebook),
pfields);
/* Main window - check the notebook */
game_area = (cur_page == pfields_page);
}
else
{
/* Sub-window - find out which */
char *title = NULL;
title = g_object_get_data(G_OBJECT(widget), "title");
game_area = title && !strcmp( title, _("Playing Fields"));
}
if (game_area)
{ /* keys for the playing field - key releases needed - install timeout */
if (keytimeoutid && key->time == k.time)
g_source_remove (keytimeoutid);
}
/* Check if it's a GTetrinet key */
if (gtetrinet_key (key->keyval, key->state & (GDK_MOD1_MASK)))
{
g_signal_stop_emission_by_name (G_OBJECT(widget), "key-press-event");
return TRUE;
}
/* if ((key->state & (GDK_MOD1_MASK | GDK_CONTROL_MASK)) > 0)
return FALSE;*/
if (game_area && ingame && (gdk_keyval_to_lower (key->keyval) == keys[K_GAMEMSG]))
{
g_signal_handler_block (app, keypress_signal);
fields_gmsginputactivate (TRUE);
g_signal_stop_emission_by_name (G_OBJECT(widget), "key-press-event");
}
if (game_area && tetrinet_key (key->keyval))
{
g_signal_stop_emission_by_name (G_OBJECT(widget), "key-press-event");
return TRUE;
}
return FALSE;
}
static void
on_selection_changed (GtkTreeSelection *treeselection,
gpointer user_data)
{
NautilusBookmark *selected;
char *name = NULL, *uri = NULL;
g_assert (GTK_IS_ENTRY (name_field));
g_assert (GTK_IS_ENTRY (uri_field));
selected = get_selected_bookmark ();
if (selected) {
name = nautilus_bookmark_get_name (selected);
uri = nautilus_bookmark_get_uri (selected);
}
/* Set the sensitivity of widgets that require a selection */
gtk_widget_set_sensitive (remove_button, selected != NULL);
gtk_widget_set_sensitive (jump_button, selected != NULL);
gtk_widget_set_sensitive (name_field, selected != NULL);
gtk_widget_set_sensitive (uri_field, selected != NULL);
g_signal_handler_block (name_field, name_field_changed_signal_id);
nautilus_entry_set_text (NAUTILUS_ENTRY (name_field),
name ? name : "");
g_signal_handler_unblock (name_field, name_field_changed_signal_id);
g_signal_handler_block (uri_field, uri_field_changed_signal_id);
nautilus_entry_set_text (NAUTILUS_ENTRY (uri_field),
uri ? uri : "");
g_signal_handler_unblock (uri_field, uri_field_changed_signal_id);
text_changed = FALSE;
name_text_changed = FALSE;
g_free (name);
g_free (uri);
}
static void
toggle_state_changed (GActionGroup *group,
const gchar *name,
GVariant *state,
GtkCheckMenuItem *w)
{
ActionData *a;
a = g_object_get_data (G_OBJECT (w), "action");
g_signal_handler_block (w, a->activate_handler);
gtk_check_menu_item_set_active (w, g_variant_get_boolean (state));
g_signal_handler_unblock (w, a->activate_handler);
}
static void update(RyostklconfigProDimnessSelector *dimness_selector) {
RyostklconfigProDimnessSelectorPrivate *priv = dimness_selector->priv;
gchar *text;
text = get_text_for_data(dimness_selector);
g_signal_handler_block(G_OBJECT(dimness_selector), priv->changed_handler_id);
set_text(dimness_selector, text);
g_signal_handler_unblock(G_OBJECT(dimness_selector), priv->changed_handler_id);
g_free(text);
}
static void
time_adj_on_changed(GtkAdjustment *adj, gpointer user_data)
{
GtkVlcPlayer *player = GTK_VLC_PLAYER(user_data);
/* avoid signal handler recursion */
g_signal_handler_block(G_OBJECT(adj),
player->priv->time_adj_on_changed_id);
gtk_adjustment_set_upper(adj, (gdouble)gtk_vlc_player_get_length(player) +
gtk_adjustment_get_page_size(adj));
g_signal_handler_unblock(G_OBJECT(adj),
player->priv->time_adj_on_changed_id);
}
static void block_changed_signal(GObject *instance)
{
GList *list;
GList *cur;
list = g_object_get_data(G_OBJECT(instance), "selection_list");
for (cur = g_list_first(list); cur != NULL; cur = g_list_next(cur)) {
GtkTreeSelection *selection = cur->data;
gulong handler_id;
handler_id = GPOINTER_TO_UINT(g_object_get_data(G_OBJECT(selection), "changed_handler_id"));
g_signal_handler_block(G_OBJECT(selection), handler_id);
}
}
static void
prop_binding_block_cb (gpointer hkey,
PropBinding *binding,
const gchar *key)
{
g_return_if_fail (binding != NULL);
g_return_if_fail (key != NULL);
if (binding->type == BINDING_PROP && binding->key &&
g_ascii_strcasecmp (binding->key, key) == 0)
g_signal_handler_block (
binding->object, binding->prop_notify_id);
}
int
clip_GTK_SIGNALHANDLERBLOCK(ClipMachine *cm)
{
C_widget *cwid = _fetch_cw_arg(cm);
int conn_id = _clip_parni(cm,2);
CHECKCWID(cwid,GTK_IS_OBJECT);
CHECKARG(2,NUMERIC_t);
//gtk_signal_handler_block(GTK_OBJECT(cwid->widget),conn_id);
g_signal_handler_block(GTK_OBJECT(cwid->widget),conn_id);
return 0;
err:
return 1;
}
static void
knot_moved_handler (SPKnot *knot, NRPointF *p, guint state, gpointer data)
{
SPKnotHolder *knot_holder;
SPItem *item;
SPObject *object;
NRMatrixF i2d;
GSList *el;
knot_holder = (SPKnotHolder *) data;
item = SP_ITEM (knot_holder->item);
object = SP_OBJECT (item);
for (el = knot_holder->entity; el; el = el->next) {
SPKnotHolderEntity *e = (SPKnotHolderEntity *)el->data;
if (e->knot == knot) {
NRMatrixF d2i;
NRPointF q;
sp_item_i2d_affine(item, &i2d);
nr_matrix_f_invert (&d2i, &i2d);
q.x = NR_MATRIX_DF_TRANSFORM_X (&d2i, p->x, p->y);
q.y = NR_MATRIX_DF_TRANSFORM_Y (&d2i, p->x, p->y);
e->knot_set (item, &q, state);
break;
}
}
sp_shape_set_shape (SP_SHAPE (item));
sp_item_i2d_affine(item, &i2d);
for (el = knot_holder->entity; el; el = el->next) {
SPKnotHolderEntity *e = (SPKnotHolderEntity *)el->data;
NRPointF sp, dp;
GObject *kob;
kob = G_OBJECT (e->knot);
e->knot_get (item, &sp);
dp.x = NR_MATRIX_DF_TRANSFORM_X (&i2d, sp.x, sp.y);
dp.y = NR_MATRIX_DF_TRANSFORM_Y (&i2d, sp.x, sp.y);
g_signal_handler_block (kob, e->handler_id);
sp_knot_set_position (e->knot, &dp, SP_KNOT_STATE_NORMAL);
g_signal_handler_unblock (kob, e->handler_id);
}
}
static void
cb_plot_area_changed (GtkWidget *spin, PlotAreaPrefState *state)
{
GogViewAllocation pos;
double value;
double max;
value = gtk_spin_button_get_value (GTK_SPIN_BUTTON (spin)) / 100.0;
gog_chart_get_plot_area (state->chart, &pos);
if (spin == state->x_spin) {
pos.x = value;
max = 1.0 - pos.x;
g_signal_handler_block (state->w_spin, state->w_spin_signal);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (state->w_spin), 0.0, max * 100.0);
if (pos.w > max) pos.w = max;
gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->w_spin), pos.w * 100.0);
g_signal_handler_unblock (state->w_spin, state->w_spin_signal);
}
else if (spin == state->y_spin) {
pos.y = value;
max = 1.0 - pos.y;
g_signal_handler_block (state->h_spin, state->h_spin_signal);
gtk_spin_button_set_range (GTK_SPIN_BUTTON (state->h_spin), 0.0, max * 100.0);
if (pos.h > max) pos.h = max;
gtk_spin_button_set_value (GTK_SPIN_BUTTON (state->h_spin), pos.w * 100.0);
g_signal_handler_unblock (state->h_spin, state->h_spin_signal);
}
else if (spin == state->w_spin) {
pos.w = value;
}
else if (spin == state->h_spin) {
pos.h = value;
}
gog_chart_set_plot_area (state->chart, &pos);
gtk_combo_box_set_active (GTK_COMBO_BOX (state->position_select_combo), 1);
gtk_widget_show (state->manual_setting_grid);
}
static void
exit_activated_cb (TrayProvider *tray)
{
GdkEventAny ev;
menu_selection_done_cb (tray);
ev.type = GDK_DELETE;
ev.window = tray->window->window;
ev.send_event = TRUE;
g_signal_handler_block (tray->window, tray->sig);
gtk_main_do_event ((GdkEvent *) &ev);
}
bool wxSlider::Create(wxWindow *parent, wxWindowID id,
int value, int minValue, int maxValue,
const wxPoint& pos, const wxSize& size,
long style, const wxValidator& validator, const wxString& name )
{
m_acceptsFocus = true;
m_needParent = true;
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, validator, name ))
{
wxFAIL_MSG( wxT("wxSlider creation failed") );
return false;
}
m_pos = 0;
m_scrollEventType = 0;
m_needThumbRelease = false;
if (style & wxSL_VERTICAL)
m_widget = gtk_vscale_new( (GtkAdjustment *) NULL );
else
m_widget = gtk_hscale_new( (GtkAdjustment *) NULL );
gtk_scale_set_draw_value(GTK_SCALE (m_widget), (style & wxSL_LABELS) != 0);
// Keep full precision in position value
gtk_scale_set_digits(GTK_SCALE (m_widget), -1);
if (style & wxSL_INVERSE)
gtk_range_set_inverted( GTK_RANGE(m_widget), TRUE );
g_signal_connect(m_widget, "button_press_event", G_CALLBACK(gtk_button_press_event), this);
g_signal_connect(m_widget, "button_release_event", G_CALLBACK(gtk_button_release_event), this);
g_signal_connect(m_widget, "move_slider", G_CALLBACK(gtk_move_slider), this);
g_signal_connect(m_widget, "format_value", G_CALLBACK(gtk_format_value), NULL);
g_signal_connect(m_widget, "value_changed", G_CALLBACK(gtk_value_changed), this);
gulong handler_id;
handler_id = g_signal_connect(
m_widget, "event_after", G_CALLBACK(gtk_event_after), this);
g_signal_handler_block(m_widget, handler_id);
SetRange( minValue, maxValue );
SetValue( value );
m_parent->DoAddChild( this );
PostCreation(size);
return true;
}
/* Only-second-level changed in check-box or manager */
static void _nojs_preferences_on_check_second_level_only_changed(NoJSPreferences *self,
gpointer *inUserData)
{
NoJSPreferencesPrivate *priv=self->priv;
gboolean state;
/* Get toggle state of widget (but block signal for manager) and set in manager */
g_signal_handler_block(priv->manager, priv->signalManagerChangedCheckSecondLevelID);
state=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->checkSecondLevelOnlyCheckbox));
nojs_set_only_second_level_domain(priv->manager, state);
g_signal_handler_unblock(priv->manager, priv->signalManagerChangedCheckSecondLevelID);
}
/* Allow-all-sites changed in check-box or manager */
static void _nojs_preferences_on_allow_all_sites_changed(NoJSPreferences *self,
gpointer *inUserData)
{
NoJSPreferencesPrivate *priv=self->priv;
gboolean state;
/* Get toggle state of widget (but block signal for manager) and set in manager */
g_signal_handler_block(priv->manager, priv->signalManagerChangedAllowAllSitesID);
state=gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->allowAllSitesCheckbox));
nojs_set_allow_all_sites(priv->manager, state);
g_signal_handler_unblock(priv->manager, priv->signalManagerChangedAllowAllSitesID);
}
void update_item_active(MITEM *mitems)
{
int i;
for(i=0; mitems[i].name; i++)
if (mitems[i].check_dat) {
GtkWidget *item = mitems[i].item;
if (!item)
continue;
g_signal_handler_block(item, mitems[i].handler);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), *mitems[i].check_dat);
g_signal_handler_unblock(item, mitems[i].handler);
}
}
static void
notify_fontname (XpadPreferences *pref)
{
const gchar *fontname = xpad_settings_get_fontname (xpad_settings ());
g_signal_handler_block (pref->priv->fontbutton, pref->priv->font_handler);
g_signal_handler_block (pref->priv->fontcheck, pref->priv->fontcheck_handler);
if (fontname)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->fontcheck), TRUE);
gtk_widget_set_sensitive (pref->priv->fontbutton, TRUE);
gtk_font_button_set_font_name (GTK_FONT_BUTTON (pref->priv->fontbutton), fontname);
}
else
{
gtk_widget_set_sensitive (pref->priv->fontbutton, FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->antifontcheck), TRUE);
}
g_signal_handler_unblock (pref->priv->fontcheck, pref->priv->fontcheck_handler);
g_signal_handler_unblock (pref->priv->fontbutton, pref->priv->font_handler);
}
static void
change_font_check (GtkToggleButton *button, XpadPreferences *pref)
{
g_signal_handler_block (xpad_settings (), pref->priv->notify_font_handler);
if (!gtk_toggle_button_get_active (button))
xpad_settings_set_fontname (xpad_settings (), NULL);
else
xpad_settings_set_fontname (xpad_settings (), gtk_font_button_get_font_name (GTK_FONT_BUTTON (pref->priv->fontbutton)));
gtk_widget_set_sensitive (pref->priv->fontbutton, gtk_toggle_button_get_active (button));
g_signal_handler_unblock (xpad_settings (), pref->priv->notify_font_handler);
}
static void
notify_text_color (XpadPreferences *pref)
{
const GdkColor *color = xpad_settings_get_text_color (xpad_settings ());
g_signal_handler_block (pref->priv->textbutton, pref->priv->text_handler);
g_signal_handler_block (pref->priv->colorcheck, pref->priv->colorcheck_handler);
if (color)
{
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->colorcheck), TRUE);
gtk_widget_set_sensitive (pref->priv->colorbox, TRUE);
gtk_color_button_set_color (GTK_COLOR_BUTTON (pref->priv->textbutton), color);
}
else
{
gtk_widget_set_sensitive (pref->priv->colorbox, FALSE);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (pref->priv->anticolorcheck), TRUE);
}
g_signal_handler_unblock (pref->priv->colorcheck, pref->priv->colorcheck_handler);
g_signal_handler_unblock (pref->priv->textbutton, pref->priv->text_handler);
}
void lamixer_volbox_changed(GtkObject *adjustment, VolBox *volumebox)
{
long rangevalue_left,rangevalue_right,increment;
rangevalue_left = gtk_range_get_value(GTK_RANGE(adjustment));
if (volumebox->type == 1) {
snd_mixer_selem_set_playback_volume (volumebox->volelem, SND_MIXER_SCHN_FRONT_LEFT, rangevalue_left);
}
else if (volumebox->type == 2) {
snd_mixer_selem_set_capture_volume (volumebox->volelem, SND_MIXER_SCHN_FRONT_LEFT, rangevalue_left);
}
if ((volumebox->lockswitch != NULL) && (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(volumebox->lockswitch)))) {
if (volumebox->type == 1) {
snd_mixer_selem_get_playback_volume (volumebox->volelem, SND_MIXER_SCHN_FRONT_RIGHT, &rangevalue_right);
}
else if (volumebox->type == 2) {
snd_mixer_selem_get_capture_volume (volumebox->volelem, SND_MIXER_SCHN_FRONT_RIGHT, &rangevalue_right);
}
//TODO: Percent increment will be better?
increment = rangevalue_left-volumebox->curval;
if ( ((rangevalue_right<volumebox->maxrange) && (rangevalue_right>volumebox->minrange)) || \
((rangevalue_right==volumebox->maxrange) && (increment<0)) || ((rangevalue_right==volumebox->minrange) && (increment>0)) ) {
if (((rangevalue_right+increment)<=(long)volumebox->maxrange) && ((rangevalue_right+increment)>=(long)volumebox->minrange)) {
rangevalue_right = rangevalue_right+increment;
}
else {
if ((rangevalue_right+increment) < ((long)volumebox->minrange))
rangevalue_right = volumebox->minrange;
else
rangevalue_right = volumebox->maxrange;
}
g_signal_handler_block(G_OBJECT(volumebox->rvolbar), volumebox->hsignalidr);
gtk_range_set_value(GTK_RANGE(volumebox->rvolbar), rangevalue_right);
if (volumebox->type == 1) {
snd_mixer_selem_set_playback_volume (volumebox->volelem, SND_MIXER_SCHN_FRONT_RIGHT, rangevalue_right);
}
else if (volumebox->type == 2) {
snd_mixer_selem_set_capture_volume (volumebox->volelem, SND_MIXER_SCHN_FRONT_RIGHT, rangevalue_right);
}
volumebox->rcurval = rangevalue_right;
g_signal_handler_unblock(G_OBJECT(volumebox->rvolbar), volumebox->hsignalidr);
}
}
volumebox->curval = rangevalue_left;
}
void update_icon(void){
E_RETURN is_wall_active;
is_wall_active = torwall_client_status();
if (is_wall_active == STATUS_RUNNING) {
gtk_status_icon_set_from_icon_name(tray_icon, "torwallActive");
update_notify(TOOL_ACTIVE, "torwallActive");
gtk_status_icon_set_tooltip(tray_icon,
TOOL_ACTIVE);
g_signal_handler_block(ch_toggle, ch_toggle_handler_id);
gtk_check_menu_item_set_active(ch_toggle, 1);
gtk_widget_set_sensitive((GtkWidget*)i_currentnode, 1);
g_signal_handler_unblock(ch_toggle, ch_toggle_handler_id);
} else {
gtk_status_icon_set_from_icon_name(tray_icon, "torwallInactive");
update_notify(TOOL_INACTIVE, "torwallInactive");
gtk_status_icon_set_tooltip(tray_icon,
TOOL_INACTIVE);
g_signal_handler_block(ch_toggle, ch_toggle_handler_id);
gtk_check_menu_item_set_active(ch_toggle, 0);
gtk_widget_set_sensitive((GtkWidget*)i_currentnode, 0);
g_signal_handler_unblock(ch_toggle, ch_toggle_handler_id);
}
}
static void
on_row_deleted (GtkListStore *store,
GtkTreePath *path,
gpointer user_data)
{
gint *indices, row;
indices = gtk_tree_path_get_indices (path);
row = indices[0];
g_signal_handler_block (bookmarks, bookmark_list_changed_signal_id);
nautilus_bookmark_list_delete_item_at (bookmarks, row);
g_signal_handler_unblock (bookmarks, bookmark_list_changed_signal_id);
}
/**
* Handle toggle events on "Default" check box
* @param cell The item that received the signal.
* @param path_str Path string.
* @param data Pointer to user data (list store).
*
* This function is called when the user clicks on "Default" check box
* indicating that a new default location has been selected. If the
* clicked check box has been un-checked the action is ignored, because
* we need a default location. If the clicked check box has been checked,
* the default flag of the checked QTH is set to TRUE, while the flag is
* cleared for all the other QTH's.
*/
static void default_toggled(GtkCellRendererToggle * cell, gchar * path_str,
gpointer data)
{
GtkTreeModel *model = (GtkTreeModel *) data;
GtkTreeIter iter;
GtkTreePath *path = gtk_tree_path_new_from_string(path_str);
gboolean fixed;
gchar *defqth;
/* block toggle signals while we mess with the check boxes */
g_signal_handler_block(cell, handler_id);
/* get toggled iter */
gtk_tree_model_get_iter(model, &iter, path);
gtk_tree_model_get(model, &iter, QTH_LIST_COL_DEF, &fixed, -1);
if (fixed)
{
/* do nothing except sending a message */
sat_log_log(SAT_LOG_LEVEL_INFO,
_("%s:%d: Default QTH can not be cleared! "
"Select another QTH to change default."),
__FILE__, __LINE__);
}
else
{
/* make this qth new default */
gtk_list_store_set(GTK_LIST_STORE(model), &iter,
QTH_LIST_COL_DEF, TRUE, -1);
/* copy file name of new default QTH to a string buffer */
gtk_tree_model_get(model, &iter, QTH_LIST_COL_NAME, &defqth, -1);
sat_log_log(SAT_LOG_LEVEL_INFO,
_("%s:%d: New default QTH is %s.qth."),
__FILE__, __LINE__, defqth);
/* clear the default flag for the other qth */
gtk_tree_model_foreach(model, clear_default_flags, defqth);
g_free(defqth);
}
/* clean up */
gtk_tree_path_free(path);
/* unblock toggle signals */
g_signal_handler_unblock(cell, handler_id);
}
static void
on_selection_changed (GtkTreeSelection *treeselection,
gpointer user_data)
{
NautilusBookmarksWindow *self = user_data;
NautilusBookmark *selected;
const char *name = NULL;
char *entry_text = NULL;
GFile *location;
selected = get_selected_bookmark (self);
if (selected) {
name = nautilus_bookmark_get_name (selected);
location = nautilus_bookmark_get_location (selected);
entry_text = g_file_get_parse_name (location);
g_object_unref (location);
}
update_widgets_sensitivity (self);
g_signal_handler_block (self->priv->name_field, self->priv->name_changed_id);
nautilus_entry_set_text (NAUTILUS_ENTRY (self->priv->name_field),
name ? name : "");
g_signal_handler_unblock (self->priv->name_field, self->priv->name_changed_id);
g_signal_handler_block (self->priv->uri_field, self->priv->uri_changed_id);
nautilus_entry_set_text (NAUTILUS_ENTRY (self->priv->uri_field),
entry_text ? entry_text : "");
g_signal_handler_unblock (self->priv->uri_field, self->priv->uri_changed_id);
self->priv->text_changed = FALSE;
self->priv->name_text_changed = FALSE;
g_free (entry_text);
}
static void
on_row_deleted (GtkListStore *store,
GtkTreePath *path,
gpointer user_data)
{
NautilusBookmarksWindow *self = user_data;
gint *indices, row;
indices = gtk_tree_path_get_indices (path);
row = indices[0];
g_signal_handler_block (self->priv->bookmarks, self->priv->bookmarks_changed_id);
nautilus_bookmark_list_delete_item_at (self->priv->bookmarks, row);
g_signal_handler_unblock (self->priv->bookmarks, self->priv->bookmarks_changed_id);
}
void gglk_text_auto_scroll(GglkText *tb)
{
if(!tb->should_scroll)
return;
tb->should_scroll = FALSE;
if(tb->vadjust)
g_signal_handler_block(tb->vadjust, tb->scroll_handler);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(tb),
tb->scrollmark, 0.1,
TRUE, 0.0, 0.0);
if(tb->vadjust)
g_signal_handler_unblock(tb->vadjust, tb->scroll_handler);
}
static void
calendar_update_details (CalendarData *data)
{
guint year, month, day;
gchar *detail;
gtk_calendar_get_date (GTK_CALENDAR (data->calendar_widget), &year, &month, &day);
detail = calendar_get_detail (data, year, month, day);
g_signal_handler_block (data->details_buffer, data->details_changed);
gtk_text_buffer_set_text (data->details_buffer, detail ? detail : "", -1);
g_signal_handler_unblock (data->details_buffer, data->details_changed);
g_free (detail);
}
void radio_button_set_active_no_signal( GtkRadioButton* radio, int index ){
{
for ( GSList* l = gtk_radio_button_get_group( radio ); l != 0; l = g_slist_next( l ) )
{
g_signal_handler_block( G_OBJECT( l->data ), gpointer_to_int( g_object_get_data( G_OBJECT( l->data ), "handler" ) ) );
}
}
radio_button_set_active( radio, index );
{
for ( GSList* l = gtk_radio_button_get_group( radio ); l != 0; l = g_slist_next( l ) )
{
g_signal_handler_unblock( G_OBJECT( l->data ), gpointer_to_int( g_object_get_data( G_OBJECT( l->data ), "handler" ) ) );
}
}
}
static void
radio_state_changed (GActionGroup *group,
const gchar *name,
GVariant *state,
GtkCheckMenuItem *w)
{
ActionData *a;
gboolean b;
a = g_object_get_data (G_OBJECT (w), "action");
g_signal_handler_block (w, a->activate_handler);
b = g_strcmp0 (a->target, g_variant_get_string (state, NULL)) == 0;
gtk_check_menu_item_set_active (w, b);
g_signal_handler_unblock (w, a->activate_handler);
}