/* Functions for creating and updating GTK widgets.
-Copyright (C) 2003-2012 Free Software Foundation, Inc.
+Copyright (C) 2003-2013 Free Software Foundation, Inc.
This file is part of GNU Emacs.
#ifdef USE_GTK
#include <float.h>
-#include <signal.h>
#include <stdio.h>
-#include <setjmp.h>
#include <c-ctype.h>
free_widget_value (widget_value *wv)
{
if (wv->free_list)
- abort ();
+ emacs_abort ();
if (malloc_cpt > 25)
{
/* Check for special colors used in face spec for region face.
The colors are fetched from the Gtk+ theme.
- Return 1 if color was found, 0 if not. */
+ Return true if color was found, false if not. */
-int
+bool
xg_check_special_colors (struct frame *f,
const char *color_name,
XColor *color)
{
- int success_p = 0;
- int get_bg = strcmp ("gtk_selection_bg_color", color_name) == 0;
- int get_fg = !get_bg && strcmp ("gtk_selection_fg_color", color_name) == 0;
+ bool success_p = 0;
+ bool get_bg = strcmp ("gtk_selection_bg_color", color_name) == 0;
+ bool get_fg = !get_bg && strcmp ("gtk_selection_fg_color", color_name) == 0;
if (! FRAME_GTK_WIDGET (f) || ! (get_bg || get_fg))
return success_p;
- BLOCK_INPUT;
+ block_input ();
{
#ifdef HAVE_GTK3
GtkStyleContext *gsty
gtk_style_context_get_background_color (gsty, state, &col);
sprintf (buf, "rgbi:%lf/%lf/%lf", col.red, col.green, col.blue);
- success_p = XParseColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
- buf, color);
+ success_p = (XParseColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f),
+ buf, color)
+ != 0);
#else
GtkStyle *gsty = gtk_widget_get_style (FRAME_GTK_WIDGET (f));
GdkColor *grgb = get_bg
#endif
}
- UNBLOCK_INPUT;
+ unblock_input ();
return success_p;
}
#endif /* USE_GTK_TOOLTIP */
/* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
- Return zero if no system tooltip available, non-zero otherwise. */
+ Return true if a system tooltip is available. */
-int
+bool
xg_prepare_tooltip (FRAME_PTR f,
Lisp_Object string,
int *width,
if (!x->ttip_lbl) return 0;
- BLOCK_INPUT;
+ block_input ();
encoded_string = ENCODE_UTF_8 (string);
widget = GTK_WIDGET (x->ttip_lbl);
gwin = gtk_widget_get_window (GTK_WIDGET (x->ttip_window));
if (width) *width = req.width;
if (height) *height = req.height;
- UNBLOCK_INPUT;
+ unblock_input ();
return 1;
#endif /* USE_GTK_TOOLTIP */
struct x_output *x = f->output_data.x;
if (x->ttip_window)
{
- BLOCK_INPUT;
+ block_input ();
gtk_window_move (x->ttip_window, root_x, root_y);
gtk_widget_show_all (GTK_WIDGET (x->ttip_window));
- UNBLOCK_INPUT;
+ unblock_input ();
}
#endif
}
/* Hide tooltip if shown. Do nothing if not shown.
- Return non-zero if tip was hidden, non-zero if not (i.e. not using
+ Return true if tip was hidden, false if not (i.e. not using
system tooltips). */
-int
+bool
xg_hide_tooltip (FRAME_PTR f)
{
- int ret = 0;
+ bool ret = 0;
#ifdef USE_GTK_TOOLTIP
if (f->output_data.x->ttip_window)
{
GtkWindow *win = f->output_data.x->ttip_window;
- BLOCK_INPUT;
+ block_input ();
gtk_widget_hide (GTK_WIDGET (win));
if (g_object_get_data (G_OBJECT (win), "restore-tt"))
GtkSettings *settings = gtk_settings_get_for_screen (screen);
g_object_set (settings, "gtk-enable-tooltips", TRUE, NULL);
}
- UNBLOCK_INPUT;
+ unblock_input ();
ret = 1;
}
gpointer gdkwin;
GtkWidget *gwdesc = 0;
- BLOCK_INPUT;
+ block_input ();
gdkwin = gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy),
wdesc);
gwdesc = gtk_get_event_widget (&event);
}
- UNBLOCK_INPUT;
+ unblock_input ();
return gwdesc;
}
xbg.pixel = pixel;
if (XQueryColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), &xbg))
{
- bg.red = (double)xbg.red/65536.0;
- bg.green = (double)xbg.green/65536.0;
- bg.blue = (double)xbg.blue/65536.0;
+ bg.red = (double)xbg.red/65535.0;
+ bg.green = (double)xbg.green/65535.0;
+ bg.blue = (double)xbg.blue/65535.0;
bg.alpha = 1.0;
gtk_widget_override_background_color (w, GTK_STATE_FLAG_NORMAL, &bg);
}
}
/* Create and set up the GTK widgets for frame F.
- Return 0 if creation failed, non-zero otherwise. */
+ Return true if creation succeeded. */
-int
+bool
xg_create_frame_widgets (FRAME_PTR f)
{
GtkWidget *wtop;
#endif
char *title = 0;
- BLOCK_INPUT;
+ block_input ();
if (FRAME_X_EMBEDDED_P (f))
{
if (whbox) gtk_widget_destroy (whbox);
if (wfixed) gtk_widget_destroy (wfixed);
- UNBLOCK_INPUT;
+ unblock_input ();
return 0;
}
}
}
- UNBLOCK_INPUT;
+ unblock_input ();
return 1;
}
/* Set the normal size hints for the window manager, for frame F.
FLAGS is the flags word to use--or 0 meaning preserve the flags
that the window now has.
- If USER_POSITION is nonzero, we set the User Position
+ If USER_POSITION, set the User Position
flag (this is useful when FLAGS is 0). */
void
-x_wm_set_size_hint (FRAME_PTR f, long int flags, int user_position)
+x_wm_set_size_hint (FRAME_PTR f, long int flags, bool user_position)
{
/* Must use GTK routines here, otherwise GTK resets the size hints
to its own defaults. */
size_hints.height_inc = FRAME_LINE_HEIGHT (f);
hint_flags |= GDK_HINT_BASE_SIZE;
- base_width = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, 0) + FRAME_TOOLBAR_WIDTH (f);
- /* Use one row here so base_height does not become zero.
+ /* Use one row/col here so base_height/width does not become zero.
Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
+ base_width = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, 1) + FRAME_TOOLBAR_WIDTH (f);
base_height = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, 1)
+ FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f);
check_frame_size (f, &min_rows, &min_cols);
+ if (min_cols > 0) --min_cols; /* We used one col in base_width = ... 1); */
if (min_rows > 0) --min_rows; /* We used one row in base_height = ... 1); */
size_hints.base_width = base_width;
&f->output_data.x->size_hints,
sizeof (size_hints)) != 0)
{
- BLOCK_INPUT;
+ block_input ();
gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
NULL, &size_hints, hint_flags);
f->output_data.x->size_hints = size_hints;
f->output_data.x->hint_flags = hint_flags;
- UNBLOCK_INPUT;
+ unblock_input ();
}
}
{
if (FRAME_GTK_WIDGET (f))
{
- BLOCK_INPUT;
+ block_input ();
xg_set_widget_bg (f, FRAME_GTK_WIDGET (f), FRAME_BACKGROUND_PIXEL (f));
- UNBLOCK_INPUT;
+ unblock_input ();
}
}
/* If the number of buttons is greater than 4, make two rows of buttons
instead. This looks better. */
- int make_two_rows = total_buttons > 4;
+ bool make_two_rows = total_buttons > 4;
if (right_buttons == 0) right_buttons = total_buttons/2;
left_buttons = total_buttons - right_buttons;
struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
struct xg_dialog_data *dd = (struct xg_dialog_data *) p->pointer;
- BLOCK_INPUT;
+ block_input ();
if (dd->w) gtk_widget_destroy (dd->w);
if (dd->timerid != 0) g_source_remove (dd->timerid);
g_main_loop_quit (dd->loop);
g_main_loop_unref (dd->loop);
- UNBLOCK_INPUT;
+ unblock_input ();
return Qnil;
}
/***********************************************************************
File dialog functions
***********************************************************************/
-/* Return non-zero if the old file selection dialog is being used.
- Return zero if not. */
+/* Return true if the old file selection dialog is being used. */
-int
+bool
xg_uses_old_file_dialog (void)
{
#ifdef HAVE_GTK_FILE_SELECTION_NEW
F is the current frame.
PROMPT is a prompt to show to the user. May not be NULL.
DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
- If MUSTMATCH_P is non-zero, the returned file name must be an existing
+ If MUSTMATCH_P, the returned file name must be an existing
file. (Actually, this only has cosmetic effects, the user can
still enter a non-existing file.) *FUNC is set to a function that
can be used to retrieve the selected file name from the returned widget.
xg_get_file_with_chooser (FRAME_PTR f,
char *prompt,
char *default_filename,
- int mustmatch_p, int only_dir_p,
+ bool mustmatch_p, bool only_dir_p,
xg_get_file_func *func)
{
char msgbuf[1024];
F is the current frame.
PROMPT is a prompt to show to the user. May not be NULL.
DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
- If MUSTMATCH_P is non-zero, the returned file name must be an existing
+ If MUSTMATCH_P, the returned file name must be an existing
file. *FUNC is set to a function that can be used to retrieve the
selected file name from the returned widget.
xg_get_file_with_selection (FRAME_PTR f,
char *prompt,
char *default_filename,
- int mustmatch_p, int only_dir_p,
+ bool mustmatch_p, bool only_dir_p,
xg_get_file_func *func)
{
GtkWidget *filewin;
F is the current frame.
PROMPT is a prompt to show to the user. May not be NULL.
DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
- If MUSTMATCH_P is non-zero, the returned file name must be an existing
+ If MUSTMATCH_P, the returned file name must be an existing
file.
Returns a file name or NULL if no file was selected.
xg_get_file_name (FRAME_PTR f,
char *prompt,
char *default_filename,
- int mustmatch_p,
- int only_dir_p)
+ bool mustmatch_p,
+ bool only_dir_p)
{
GtkWidget *w = 0;
char *fn = 0;
int filesel_done = 0;
xg_get_file_func func;
-#if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
- /* I really don't know why this is needed, but without this the GLIBC add on
- library linuxthreads hangs when the Gnome file chooser backend creates
- threads. */
- sigblock (sigmask (__SIGRTMIN));
-#endif /* HAVE_PTHREAD */
-
#ifdef HAVE_GTK_FILE_SELECTION_NEW
if (xg_uses_old_file_dialog ())
gtk_widget_set_name (w, "emacs-filedialog");
filesel_done = xg_dialog_run (f, w);
-
-#if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
- sigunblock (sigmask (__SIGRTMIN));
-#endif
-
if (filesel_done == GTK_RESPONSE_OK)
fn = (*func) (w);
#if USE_NEW_GTK_FONT_CHOOSER
-extern Lisp_Object Qxft, Qnormal;
-extern Lisp_Object Qextra_light, Qlight, Qsemi_light, Qsemi_bold;
-extern Lisp_Object Qbold, Qextra_bold, Qultra_bold;
-extern Lisp_Object Qoblique, Qitalic;
-
#define XG_WEIGHT_TO_SYMBOL(w) \
(w <= PANGO_WEIGHT_THIN ? Qextra_light \
: w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
static char *x_last_font_name;
+extern Lisp_Object Qxft;
/* Pop up a GTK font selector and return the name of the font the user
selects, as a C string. The returned font name follows GTK's own
int done = 0;
Lisp_Object font = Qnil;
-#if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
- sigblock (sigmask (__SIGRTMIN));
-#endif /* HAVE_PTHREAD */
-
w = gtk_font_chooser_dialog_new
("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
gtk_widget_set_name (w, "emacs-fontdialog");
done = xg_dialog_run (f, w);
-
-#if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
- sigunblock (sigmask (__SIGRTMIN));
-#endif
-
if (done == GTK_RESPONSE_OK)
{
#if USE_NEW_GTK_FONT_CHOOSER
static int xg_detached_menus;
-/* Returns non-zero if there are detached menus. */
+/* Return true if there are detached menus. */
-int
+bool
xg_have_tear_offs (void)
{
return xg_detached_menus > 0;
SELECT_CB is the callback to use when a menu item is selected.
DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
- POP_UP_P is non-zero if we shall create a popup menu.
- MENU_BAR_P is non-zero if we shall create a menu bar.
- ADD_TEAROFF_P is non-zero if we shall add a tearoff menu item. Ignored
- if MENU_BAR_P is non-zero.
+ If POP_UP_P, create a popup menu.
+ If MENU_BAR_P, create a menu bar.
+ If ADD_TEAROFF_P, add a tearoff menu item. Ignored if MENU_BAR_P.
TOPMENU is the topmost GtkWidget that others shall be placed under.
It may be NULL, in that case we create the appropriate widget
(menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
GCallback select_cb,
GCallback deactivate_cb,
GCallback highlight_cb,
- int pop_up_p,
- int menu_bar_p,
- int add_tearoff_p,
+ bool pop_up_p,
+ bool menu_bar_p,
+ bool add_tearoff_p,
GtkWidget *topmenu,
xg_menu_cb_data *cl_data,
const char *name)
GCallback highlight_cb)
{
GtkWidget *w = 0;
- int menu_bar_p = strcmp (type, "menubar") == 0;
- int pop_up_p = strcmp (type, "popup") == 0;
+ bool menu_bar_p = strcmp (type, "menubar") == 0;
+ bool pop_up_p = strcmp (type, "popup") == 0;
if (strcmp (type, "dialog") == 0)
{
return gtk_label_get_label (wlabel);
}
-/* Return non-zero if the menu item WITEM has the text LABEL. */
+/* Return true if the menu item WITEM has the text LABEL. */
-static int
+static bool
xg_item_label_same_p (GtkMenuItem *witem, const char *label)
{
- int is_same = 0;
+ bool is_same = 0;
char *utf8_label = get_utf8_string (label);
const char *old_label = witem ? xg_get_menu_item_label (witem) : 0;
{
GtkMenuItem *witem = GTK_MENU_ITEM (iter->data);
GtkMenuItem *witem2 = 0;
- int val_in_menubar = 0;
- int iter_in_new_menubar = 0;
+ bool val_in_menubar = 0;
+ bool iter_in_new_menubar = 0;
GList *iter2;
widget_value *cur;
GList *list = 0;
GList *iter;
widget_value *cur;
- int has_tearoff_p = 0;
+ bool has_tearoff_p = 0;
GList *first_radio = 0;
if (submenu)
/* Update the MENUBAR.
F is the frame the menu bar belongs to.
VAL describes the contents of the menu bar.
- If DEEP_P is non-zero, rebuild all but the top level menu names in
+ If DEEP_P, rebuild all but the top level menu names in
the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
SELECT_CB is the callback to use when a menu item is selected.
DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
void
xg_modify_menubar_widgets (GtkWidget *menubar, FRAME_PTR f, widget_value *val,
- int deep_p,
+ bool deep_p,
GCallback select_cb, GCallback deactivate_cb,
GCallback highlight_cb)
{
}
/* Recompute all the widgets of frame F, when the menu bar has been
- changed. Value is non-zero if widgets were updated. */
+ changed. */
-int
+void
xg_update_frame_menubar (FRAME_PTR f)
{
struct x_output *x = f->output_data.x;
GtkRequisition req;
if (!x->menubar_widget || gtk_widget_get_mapped (x->menubar_widget))
- return 0;
+ return;
if (x->menubar_widget && gtk_widget_get_parent (x->menubar_widget))
- return 0; /* Already done this, happens for frames created invisible. */
+ return; /* Already done this, happens for frames created invisible. */
- BLOCK_INPUT;
+ block_input ();
gtk_box_pack_start (GTK_BOX (x->vbox_widget), x->menubar_widget,
FALSE, FALSE, 0);
FRAME_MENUBAR_HEIGHT (f) = req.height;
xg_height_or_width_changed (f);
}
- UNBLOCK_INPUT;
-
- return 1;
+ unblock_input ();
}
/* Get rid of the menu bar of frame F, and free its storage.
if (x->menubar_widget)
{
- BLOCK_INPUT;
+ block_input ();
gtk_container_remove (GTK_CONTAINER (x->vbox_widget), x->menubar_widget);
/* The menubar and its children shall be deleted when removed from
x->menubar_widget = 0;
FRAME_MENUBAR_HEIGHT (f) = 0;
xg_height_or_width_changed (f);
- UNBLOCK_INPUT;
+ unblock_input ();
}
}
-int
+bool
xg_event_is_for_menubar (FRAME_PTR f, XEvent *event)
{
struct x_output *x = f->output_data.x;
break;
}
g_list_free (list);
- return iter == 0 ? 0 : 1;
+ return iter != 0;
}
/* Setting scroll bar values invokes the callback. Use this variable
to indicate that callback should do nothing. */
-int xg_ignore_gtk_scrollbar;
+bool xg_ignore_gtk_scrollbar;
/* The width of the scroll bar for the current theme. */
}
/* Should never end up here */
- abort ();
+ emacs_abort ();
}
/* Remove pointer at IDX from id_to_widget.
int size, value;
int old_size;
int new_step;
- int changed = 0;
+ bool changed = 0;
adj = gtk_range_get_adjustment (GTK_RANGE (wscroll));
if (changed || int_gtk_range_get_value (GTK_RANGE (wscroll)) != value)
{
- BLOCK_INPUT;
+ block_input ();
/* gtk_range_set_value invokes the callback. Set
ignore_gtk_scrollbar to make the callback do nothing */
xg_ignore_gtk_scrollbar = 0;
- UNBLOCK_INPUT;
+ unblock_input ();
}
}
}
-/* Return non-zero if EVENT is for a scroll bar in frame F.
+/* Return true if EVENT is for a scroll bar in frame F.
When the same X window is used for several Gtk+ widgets, we cannot
say for sure based on the X window alone if an event is for the
- frame. This function does additional checks.
+ frame. This function does additional checks. */
- Return non-zero if the event is for a scroll bar, zero otherwise. */
-
-int
+bool
xg_event_is_for_scrollbar (FRAME_PTR f, XEvent *event)
{
- int retval = 0;
+ bool retval = 0;
if (f && event->type == ButtonPress && event->xbutton.button < 4)
{
else
{
fprintf (stderr, "internal error: GTK_IMAGE_PIXBUF failed\n");
- abort ();
+ emacs_abort ();
}
}
else if (store_type == GTK_IMAGE_ICON_NAME)
else
{
fprintf (stderr, "internal error: store_type is %d\n", store_type);
- abort ();
+ emacs_abort ();
}
}
if (wmenuimage)
xg_pack_tool_bar (FRAME_PTR f, Lisp_Object pos)
{
struct x_output *x = f->output_data.x;
- int into_hbox = EQ (pos, Qleft) || EQ (pos, Qright);
+ bool into_hbox = EQ (pos, Qleft) || EQ (pos, Qright);
toolbar_set_orientation (x->toolbar_widget,
into_hbox
}
else
{
- int vbox_pos = x->menubar_widget ? 1 : 0;
+ bool vbox_pos = x->menubar_widget != 0;
gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x->handlebox_widget),
GTK_POS_LEFT);
gtk_box_pack_start (GTK_BOX (x->vbox_widget), x->handlebox_widget,
GtkWidget *wimage,
GtkWidget **wbutton,
const char *label,
- int i, int horiz, int text_image)
+ int i, bool horiz, bool text_image)
{
GtkToolItem *ti = gtk_tool_item_new ();
GtkWidget *vb = gtk_box_new (horiz
return ti;
}
-static int
-is_box_type (GtkWidget *vb, int is_horizontal)
+static bool
+is_box_type (GtkWidget *vb, bool is_horizontal)
{
#ifdef HAVE_GTK3
- int ret = 0;
+ bool ret = 0;
if (GTK_IS_BOX (vb))
{
GtkOrientation ori = gtk_orientable_get_orientation (GTK_ORIENTABLE (vb));
}
-static int
+static bool
xg_tool_item_stale_p (GtkWidget *wbutton, const char *stock_name,
const char *icon_name, const struct image *img,
- const char *label, int horiz)
+ const char *label, bool horiz)
{
gpointer old;
GtkWidget *wimage;
return 0;
}
-static int
+static bool
xg_update_tool_bar_sizes (FRAME_PTR f)
{
struct x_output *x = f->output_data.x;
GtkToolbar *wtoolbar;
GtkToolItem *ti;
GtkTextDirection dir;
- int pack_tool_bar = x->handlebox_widget == NULL;
+ bool pack_tool_bar = x->handlebox_widget == NULL;
Lisp_Object style;
- int text_image, horiz;
+ bool text_image, horiz;
struct xg_frame_tb_info *tbinfo;
if (! FRAME_GTK_WIDGET (f))
return;
- BLOCK_INPUT;
+ block_input ();
if (RANGED_INTEGERP (1, Vtool_bar_button_margin, INT_MAX))
{
&& ! NILP (Fequal (tbinfo->style, style))
&& ! NILP (Fequal (tbinfo->last_tool_bar, f->tool_bar_items)))
{
- UNBLOCK_INPUT;
+ unblock_input ();
return;
}
for (i = j = 0; i < f->n_tool_bar_items; ++i)
{
- int enabled_p = !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P));
- int selected_p = !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P));
+ bool enabled_p = !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P));
+ bool selected_p = !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P));
int idx;
ptrdiff_t img_id;
int icon_size = 0;
Lisp_Object rtl;
GtkWidget *wbutton = NULL;
Lisp_Object specified_file;
- int vert_only = ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY));
+ bool vert_only = ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY));
const char *label
= (EQ (style, Qimage) || (vert_only && horiz)) ? NULL
: STRINGP (PROP (TOOL_BAR_ITEM_LABEL))
xg_height_or_width_changed (f);
}
- UNBLOCK_INPUT;
+ unblock_input ();
}
/* Deallocate all resources for the tool bar on frame F.
if (x->toolbar_widget)
{
struct xg_frame_tb_info *tbinfo;
- int is_packed = x->handlebox_widget != 0;
- BLOCK_INPUT;
+ bool is_packed = x->handlebox_widget != 0;
+ block_input ();
/* We may have created the toolbar_widget in xg_create_tool_bar, but
not the x->handlebox_widget which is created in xg_pack_tool_bar. */
if (is_packed)
xg_height_or_width_changed (f);
- UNBLOCK_INPUT;
+ unblock_input ();
}
}
-int
+void
xg_change_toolbar_position (FRAME_PTR f, Lisp_Object pos)
{
struct x_output *x = f->output_data.x;
if (! x->toolbar_widget || ! x->handlebox_widget)
- return 1;
+ return;
- BLOCK_INPUT;
+ block_input ();
g_object_ref (x->handlebox_widget);
if (x->toolbar_in_hbox)
gtk_container_remove (GTK_CONTAINER (x->hbox_widget),
if (xg_update_tool_bar_sizes (f))
xg_height_or_width_changed (f);
- UNBLOCK_INPUT;
- return 1;
+ unblock_input ();
}
"cancel", 0);
update_theme_scrollbar_width ();
+#ifdef HAVE_FREETYPE
x_last_font_name = NULL;
+#endif
}
#endif /* USE_GTK */