Beispiel #1
0
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
}
Beispiel #2
0
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);
}
Beispiel #3
0
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);
	}
}
Beispiel #4
0
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)));
}
Beispiel #5
0
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);
}
Beispiel #7
0
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);
}
Beispiel #8
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);
}
Beispiel #9
0
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;
}
Beispiel #10
0
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;
}
Beispiel #11
0
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);
}
Beispiel #12
0
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;
		}

	}
}
Beispiel #13
0
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);
}
Beispiel #14
0
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);
}
Beispiel #15
0
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);	
}
Beispiel #16
0
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);

}
Beispiel #17
0
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() */
Beispiel #18
0
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);
}
Beispiel #21
0
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);
    }
}
Beispiel #22
0
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);
    }
}
Beispiel #27
0
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);
}
Beispiel #28
0
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);
}
Beispiel #29
0
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);
}
Beispiel #30
0
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);
}