1 /* Functions for creating and updating GTK widgets.
3 Copyright (C) 2003-2015 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
30 #include "blockinput.h"
31 #include "syssignal.h"
35 #include "termhooks.h"
41 #include <gdk/gdkkeysyms.h>
42 #include "xsettings.h"
45 #include <X11/Xft/Xft.h>
50 #include "emacsgtkfixed.h"
53 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
54 #define gtk_widget_set_has_window(w, b) \
55 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
57 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
58 #define gtk_dialog_get_action_area(w) ((w)->action_area)
59 #define gtk_dialog_get_content_area(w) ((w)->vbox)
61 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
62 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
64 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
65 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
66 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
67 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
68 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
70 #if GTK_CHECK_VERSION (2, 12, 0)
71 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
73 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
76 #if ! GTK_CHECK_VERSION (2, 14, 0)
77 #define gtk_adjustment_configure(adj, xvalue, xlower, \
78 xupper, xstep_increment, \
79 xpage_increment, xpagesize) \
81 adj->lower = xlower; \
82 adj->upper = xupper; \
83 adj->page_size = xpagesize; \
84 gtk_adjustment_set_value (adj, xvalue); \
85 adj->page_increment = xpage_increment; \
86 adj->step_increment = xstep_increment; \
88 #endif /* < Gtk+ 2.14 */
91 #if GTK_CHECK_VERSION (3, 2, 0)
92 #define USE_NEW_GTK_FONT_CHOOSER 1
94 #define USE_NEW_GTK_FONT_CHOOSER 0
95 #define gtk_font_chooser_dialog_new(x, y) \
96 gtk_font_selection_dialog_new (x)
97 #undef GTK_FONT_CHOOSER
98 #define GTK_FONT_CHOOSER(x) GTK_FONT_SELECTION_DIALOG (x)
99 #define gtk_font_chooser_set_font(x, y) \
100 gtk_font_selection_dialog_set_font_name (x, y)
102 #endif /* HAVE_FREETYPE */
104 #if GTK_CHECK_VERSION (3, 10, 0)
105 #define XG_TEXT_CANCEL "Cancel"
106 #define XG_TEXT_OK "OK"
107 #define XG_TEXT_OPEN "Open"
109 #define XG_TEXT_CANCEL GTK_STOCK_CANCEL
110 #define XG_TEXT_OK GTK_STOCK_OK
111 #define XG_TEXT_OPEN GTK_STOCK_OPEN
115 #ifdef USE_GTK_TOOLTIP
116 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
118 #define gdk_window_get_geometry(w, a, b, c, d) \
119 gdk_window_get_geometry (w, a, b, c, d, 0)
120 #define gdk_x11_window_lookup_for_display(d, w) \
121 gdk_xid_table_lookup_for_display (d, w)
122 #define gtk_box_new(ori, spacing) \
123 ((ori) == GTK_ORIENTATION_HORIZONTAL \
124 ? gtk_hbox_new (FALSE, (spacing)) : gtk_vbox_new (FALSE, (spacing)))
125 #define gtk_scrollbar_new(ori, spacing) \
126 ((ori) == GTK_ORIENTATION_HORIZONTAL \
127 ? gtk_hscrollbar_new ((spacing)) : gtk_vscrollbar_new ((spacing)))
129 #define GDK_KEY_g GDK_g
131 #endif /* HAVE_GTK3 */
133 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
135 static void update_theme_scrollbar_width (void);
136 static void update_theme_scrollbar_height (void);
138 #define TB_INFO_KEY "xg_frame_tb_info"
139 struct xg_frame_tb_info
141 Lisp_Object last_tool_bar
;
144 int hmargin
, vmargin
;
145 GtkTextDirection dir
;
149 /***********************************************************************
150 Display handling functions
151 ***********************************************************************/
153 /* Keep track of the default display, or NULL if there is none. Emacs
154 may close all its displays. */
156 static GdkDisplay
*gdpy_def
;
158 /* When the GTK widget W is to be created on a display for F that
159 is not the default display, set the display for W.
160 W can be a GtkMenu or a GtkWindow widget. */
163 xg_set_screen (GtkWidget
*w
, struct frame
*f
)
165 if (FRAME_X_DISPLAY (f
) != DEFAULT_GDK_DISPLAY ())
167 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
168 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
171 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
173 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
178 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
179 *DPY is set to NULL if the display can't be opened.
181 Returns non-zero if display could be opened, zero if display could not
182 be opened, and less than zero if the GTK version doesn't support
183 multiple displays. */
186 xg_display_open (char *display_name
, Display
**dpy
)
190 unrequest_sigio (); // See comment in x_display_ok, xterm.c.
191 gdpy
= gdk_display_open (display_name
);
193 if (!gdpy_def
&& gdpy
)
196 gdk_display_manager_set_default_display (gdk_display_manager_get (),
200 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
204 /* Close display DPY. */
207 xg_display_close (Display
*dpy
)
209 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
211 /* If this is the default display, try to change it before closing.
212 If there is no other display to use, gdpy_def is set to NULL, and
213 the next call to xg_display_open resets the default display. */
214 if (gdk_display_get_default () == gdpy
)
216 struct x_display_info
*dpyinfo
;
217 GdkDisplay
*gdpy_new
= NULL
;
219 /* Find another display. */
220 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
221 if (dpyinfo
->display
!= dpy
)
223 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
224 gdk_display_manager_set_default_display (gdk_display_manager_get (),
231 #if GTK_CHECK_VERSION (2, 0, 0) && ! GTK_CHECK_VERSION (2, 10, 0)
232 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
233 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
234 can continue running, but there will be memory leaks. */
235 g_object_run_dispose (G_OBJECT (gdpy
));
237 /* This seems to be fixed in GTK 2.10. */
238 gdk_display_close (gdpy
);
243 /***********************************************************************
245 ***********************************************************************/
247 /* Create and return the cursor to be used for popup menus and
248 scroll bars on display DPY. */
251 xg_create_default_cursor (Display
*dpy
)
253 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
254 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
258 xg_get_pixbuf_from_pixmap (struct frame
*f
, Pixmap pix
)
263 unsigned int width
, height
, uunused
;
266 XGetGeometry (FRAME_X_DISPLAY (f
), pix
, &wunused
, &iunused
, &iunused
,
267 &width
, &height
, &uunused
, &uunused
);
269 xim
= XGetImage (FRAME_X_DISPLAY (f
), pix
, 0, 0, width
, height
,
273 tmp_buf
= gdk_pixbuf_new_from_data ((guchar
*) xim
->data
,
286 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
289 xg_get_pixbuf_from_pix_and_mask (struct frame
*f
,
294 GdkPixbuf
*icon_buf
, *tmp_buf
;
296 tmp_buf
= xg_get_pixbuf_from_pixmap (f
, pix
);
297 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
298 g_object_unref (G_OBJECT (tmp_buf
));
300 width
= gdk_pixbuf_get_width (icon_buf
);
301 height
= gdk_pixbuf_get_height (icon_buf
);
305 GdkPixbuf
*mask_buf
= xg_get_pixbuf_from_pixmap (f
, mask
);
306 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
307 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
308 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
309 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
312 for (y
= 0; y
< height
; ++y
)
314 guchar
*iconptr
, *maskptr
;
317 iconptr
= pixels
+ y
* rowstride
;
318 maskptr
= mask_pixels
+ y
* mask_rowstride
;
320 for (x
= 0; x
< width
; ++x
)
322 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
323 just R is sufficient. */
325 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
327 iconptr
+= rowstride
/width
;
328 maskptr
+= mask_rowstride
/width
;
332 g_object_unref (G_OBJECT (mask_buf
));
339 file_for_image (Lisp_Object image
)
341 Lisp_Object specified_file
= Qnil
;
344 for (tail
= XCDR (image
);
345 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
346 tail
= XCDR (XCDR (tail
)))
347 if (EQ (XCAR (tail
), QCfile
))
348 specified_file
= XCAR (XCDR (tail
));
350 return specified_file
;
353 /* For the image defined in IMG, make and return a GtkImage. For displays with
354 8 planes or less we must make a GdkPixbuf and apply the mask manually.
355 Otherwise the highlighting and dimming the tool bar code in GTK does
356 will look bad. For display with more than 8 planes we just use the
357 pixmap and mask directly. For monochrome displays, GTK doesn't seem
358 able to use external pixmaps, it looks bad whatever we do.
359 The image is defined on the display where frame F is.
360 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
361 If OLD_WIDGET is NULL, a new widget is constructed and returned.
362 If OLD_WIDGET is not NULL, that widget is modified. */
365 xg_get_image_for_pixmap (struct frame
*f
,
368 GtkImage
*old_widget
)
372 /* If we have a file, let GTK do all the image handling.
373 This seems to be the only way to make insensitive and activated icons
374 look good in all cases. */
375 Lisp_Object specified_file
= file_for_image (img
->spec
);
378 /* We already loaded the image once before calling this
379 function, so this only fails if the image file has been removed.
380 In that case, use the pixmap already loaded. */
382 if (STRINGP (specified_file
)
383 && STRINGP (file
= x_find_image_file (specified_file
)))
386 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
388 gtk_image_set_from_file (old_widget
, SSDATA (file
));
390 return GTK_WIDGET (old_widget
);
393 /* No file, do the image handling ourselves. This will look very bad
394 on a monochrome display, and sometimes bad on all displays with
397 /* This is a workaround to make icons look good on pseudo color
398 displays. Apparently GTK expects the images to have an alpha
399 channel. If they don't, insensitive and activated icons will
400 look bad. This workaround does not work on monochrome displays,
401 and is strictly not needed on true color/static color displays (i.e.
402 16 bits and higher). But we do it anyway so we get a pixbuf that is
403 not associated with the img->pixmap. The img->pixmap may be removed
404 by clearing the image cache and then the tool bar redraw fails, since
405 Gtk+ assumes the pixmap is always there. */
406 icon_buf
= xg_get_pixbuf_from_pix_and_mask (f
, img
->pixmap
, img
->mask
);
411 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
413 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
415 g_object_unref (G_OBJECT (icon_buf
));
418 return GTK_WIDGET (old_widget
);
422 /* Set CURSOR on W and all widgets W contain. We must do like this
423 for scroll bars and menu because they create widgets internally,
424 and it is those widgets that are visible. */
427 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
429 GdkWindow
*window
= gtk_widget_get_window (w
);
430 GList
*children
= gdk_window_peek_children (window
);
432 gdk_window_set_cursor (window
, cursor
);
434 /* The scroll bar widget has more than one GDK window (had to look at
435 the source to figure this out), and there is no way to set cursor
436 on widgets in GTK. So we must set the cursor for all GDK windows.
439 for ( ; children
; children
= g_list_next (children
))
440 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
443 /* Insert NODE into linked LIST. */
446 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
448 xg_list_node
*list_start
= list
->next
;
450 if (list_start
) list_start
->prev
= node
;
451 node
->next
= list_start
;
456 /* Remove NODE from linked LIST. */
459 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
461 xg_list_node
*list_start
= list
->next
;
462 if (node
== list_start
)
464 list
->next
= node
->next
;
465 if (list
->next
) list
->next
->prev
= 0;
469 node
->prev
->next
= node
->next
;
470 if (node
->next
) node
->next
->prev
= node
->prev
;
474 /* Allocate and return a utf8 version of STR. If STR is already
475 utf8 or NULL, just return a copy of STR.
476 A new string is allocated and the caller must free the result
480 get_utf8_string (const char *str
)
484 if (!str
) return NULL
;
486 /* If not UTF-8, try current locale. */
487 if (!g_utf8_validate (str
, -1, NULL
))
488 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
490 return g_strdup (str
);
494 /* Probably some control characters in str. Escape them. */
496 ptrdiff_t nr_bad
= 0;
499 unsigned char *p
= (unsigned char *)str
;
503 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
504 &bytes_written
, &err
))
505 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
508 p
+= bytes_written
+1;
521 if ((min (PTRDIFF_MAX
, SIZE_MAX
) - len
- 1) / 4 < nr_bad
)
522 memory_full (SIZE_MAX
);
523 up
= utf8_str
= xmalloc (len
+ nr_bad
* 4 + 1);
524 p
= (unsigned char *)str
;
526 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
527 &bytes_written
, &err
))
528 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
530 memcpy (up
, p
, bytes_written
);
532 up
+= sprintf (up
, "\\%03o", p
[bytes_written
]);
533 p
+= bytes_written
+ 1;
552 /* Check for special colors used in face spec for region face.
553 The colors are fetched from the Gtk+ theme.
554 Return true if color was found, false if not. */
557 xg_check_special_colors (struct frame
*f
,
558 const char *color_name
,
562 bool get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
563 bool get_fg
= !get_bg
&& strcmp ("gtk_selection_fg_color", color_name
) == 0;
565 if (! FRAME_GTK_WIDGET (f
) || ! (get_bg
|| get_fg
))
571 GtkStyleContext
*gsty
572 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f
));
574 char buf
[sizeof "rgb://rrrr/gggg/bbbb"];
575 int state
= GTK_STATE_FLAG_SELECTED
|GTK_STATE_FLAG_FOCUSED
;
577 gtk_style_context_get_color (gsty
, state
, &col
);
579 gtk_style_context_get_background_color (gsty
, state
, &col
);
581 sprintf (buf
, "rgb:%04x/%04x/%04x",
582 (int)(col
.red
* 65535),
583 (int)(col
.green
* 65535),
584 (int)(col
.blue
* 65535));
585 success_p
= (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
589 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
590 GdkColor
*grgb
= get_bg
591 ? &gsty
->bg
[GTK_STATE_SELECTED
]
592 : &gsty
->fg
[GTK_STATE_SELECTED
];
594 color
->red
= grgb
->red
;
595 color
->green
= grgb
->green
;
596 color
->blue
= grgb
->blue
;
597 color
->pixel
= grgb
->pixel
;
608 /***********************************************************************
610 ***********************************************************************/
611 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
612 We use that to pop down the tooltip. This happens if Gtk+ for some
613 reason wants to change or hide the tooltip. */
615 #ifdef USE_GTK_TOOLTIP
618 hierarchy_ch_cb (GtkWidget
*widget
,
619 GtkWidget
*previous_toplevel
,
622 struct frame
*f
= user_data
;
623 struct x_output
*x
= f
->output_data
.x
;
624 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
626 if (! top
|| ! GTK_IS_WINDOW (top
))
627 gtk_widget_hide (previous_toplevel
);
630 /* Callback called when Gtk+ thinks a tooltip should be displayed.
631 We use it to get the tooltip window and the tooltip widget so
632 we can manipulate the ourselves.
634 Return FALSE ensures that the tooltip is not shown. */
637 qttip_cb (GtkWidget
*widget
,
640 gboolean keyboard_mode
,
644 struct frame
*f
= user_data
;
645 struct x_output
*x
= f
->output_data
.x
;
646 if (x
->ttip_widget
== NULL
)
651 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
652 x
->ttip_widget
= tooltip
;
653 g_object_ref (G_OBJECT (tooltip
));
654 x
->ttip_lbl
= gtk_label_new ("");
655 g_object_ref (G_OBJECT (x
->ttip_lbl
));
656 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
657 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
659 /* Change stupid Gtk+ default line wrapping. */
660 p
= gtk_widget_get_parent (x
->ttip_lbl
);
661 list
= gtk_container_get_children (GTK_CONTAINER (p
));
662 for (iter
= list
; iter
; iter
= g_list_next (iter
))
664 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
665 if (GTK_IS_LABEL (w
))
666 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
670 /* ATK needs an empty title for some reason. */
671 gtk_window_set_title (x
->ttip_window
, "");
672 /* Realize so we can safely get screen later on. */
673 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
674 gtk_widget_realize (x
->ttip_lbl
);
676 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
677 G_CALLBACK (hierarchy_ch_cb
), f
);
682 #endif /* USE_GTK_TOOLTIP */
684 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
685 Return true if a system tooltip is available. */
688 xg_prepare_tooltip (struct frame
*f
,
693 #ifndef USE_GTK_TOOLTIP
696 struct x_output
*x
= f
->output_data
.x
;
700 GtkSettings
*settings
;
701 gboolean tt_enabled
= TRUE
;
703 Lisp_Object encoded_string
;
705 if (!x
->ttip_lbl
) return 0;
708 encoded_string
= ENCODE_UTF_8 (string
);
709 widget
= GTK_WIDGET (x
->ttip_lbl
);
710 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
711 screen
= gdk_window_get_screen (gwin
);
712 settings
= gtk_settings_get_for_screen (screen
);
713 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
716 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
717 /* Record that we disabled it so it can be enabled again. */
718 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
722 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
723 g_object_set_data (G_OBJECT
724 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
725 "gdk-display-current-tooltip", NULL
);
727 /* Put our dummy widget in so we can get callbacks for unrealize and
728 hierarchy-changed. */
729 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
730 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
731 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
732 if (width
) *width
= req
.width
;
733 if (height
) *height
= req
.height
;
738 #endif /* USE_GTK_TOOLTIP */
741 /* Show the tooltip at ROOT_X and ROOT_Y.
742 xg_prepare_tooltip must have been called before this function. */
745 xg_show_tooltip (struct frame
*f
, int root_x
, int root_y
)
747 #ifdef USE_GTK_TOOLTIP
748 struct x_output
*x
= f
->output_data
.x
;
752 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
753 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
759 /* Hide tooltip if shown. Do nothing if not shown.
760 Return true if tip was hidden, false if not (i.e. not using
764 xg_hide_tooltip (struct frame
*f
)
767 #ifdef USE_GTK_TOOLTIP
768 if (f
->output_data
.x
->ttip_window
)
770 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
772 gtk_widget_hide (GTK_WIDGET (win
));
774 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
776 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
777 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
778 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
779 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
790 /***********************************************************************
791 General functions for creating widgets, resizing, events, e.t.c.
792 ***********************************************************************/
795 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
796 const gchar
*msg
, gpointer user_data
)
798 if (!strstr (msg
, "visible children"))
799 fprintf (stderr
, "XX %s-WARNING **: %s\n", log_domain
, msg
);
802 /* Make a geometry string and pass that to GTK. It seems this is the
803 only way to get geometry position right if the user explicitly
804 asked for a position when starting Emacs.
805 F is the frame we shall set geometry for. */
808 xg_set_geometry (struct frame
*f
)
810 if (f
->size_hint_flags
& (USPosition
| PPosition
))
812 int left
= f
->left_pos
;
813 int xneg
= f
->size_hint_flags
& XNegative
;
814 int top
= f
->top_pos
;
815 int yneg
= f
->size_hint_flags
& YNegative
;
816 char geom_str
[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
824 sprintf (geom_str
, "=%dx%d%c%d%c%d",
825 FRAME_PIXEL_WIDTH (f
),
826 FRAME_PIXEL_HEIGHT (f
),
827 (xneg
? '-' : '+'), left
,
828 (yneg
? '-' : '+'), top
);
830 /* Silence warning about visible children. */
831 id
= g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
832 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
834 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
836 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
838 g_log_remove_handler ("Gtk", id
);
842 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
843 and use a GtkFixed widget, this doesn't happen automatically. */
846 xg_clear_under_internal_border (struct frame
*f
)
848 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
851 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
853 gtk_widget_queue_draw (wfixed
);
854 gdk_window_process_all_updates ();
856 x_clear_area (f
, 0, 0,
857 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
859 x_clear_area (f
, 0, 0,
860 FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
863 FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
864 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
867 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
868 0, FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
872 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
873 and a Gtk+ menu bar, we get resize events for the edit part of the
874 frame only. We let Gtk+ deal with the Gtk+ parts.
875 F is the frame to resize.
876 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
879 xg_frame_resized (struct frame
*f
, int pixelwidth
, int pixelheight
)
883 if (pixelwidth
== -1 && pixelheight
== -1)
885 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
886 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
887 0, 0, &pixelwidth
, &pixelheight
);
892 width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, pixelwidth
);
893 height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelheight
);
895 frame_size_history_add
896 (f
, Qxg_frame_resized
, width
, height
, Qnil
);
898 if (width
!= FRAME_TEXT_WIDTH (f
)
899 || height
!= FRAME_TEXT_HEIGHT (f
)
900 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
901 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
903 xg_clear_under_internal_border (f
);
904 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
905 SET_FRAME_GARBAGED (f
);
906 cancel_mouse_face (f
);
908 do_pending_window_change (0);
912 /* Resize the outer window of frame F after changing the height.
913 COLUMNS/ROWS is the size the edit area shall have after the resize. */
916 xg_frame_set_char_size (struct frame
*f
, int width
, int height
)
918 int pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
919 int pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
920 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
921 gint gwidth
, gheight
;
923 if (FRAME_PIXEL_HEIGHT (f
) == 0)
926 gtk_window_get_size (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
929 /* Do this before resize, as we don't know yet if we will be resized. */
930 xg_clear_under_internal_border (f
);
932 /* Resize the top level widget so rows and columns remain constant.
934 When the frame is fullheight and we only want to change the width
935 or it is fullwidth and we only want to change the height we should
936 be able to preserve the fullscreen property. However, due to the
937 fact that we have to send a resize request anyway, the window
938 manager will abolish it. At least the respective size should
939 remain unchanged but giving the frame back its normal size will
941 if (EQ (fullscreen
, Qfullwidth
) && width
== FRAME_TEXT_WIDTH (f
))
943 frame_size_history_add
944 (f
, Qxg_frame_set_char_size_1
, width
, height
,
945 list2 (make_number (gheight
),
946 make_number (pixelheight
+ FRAME_TOOLBAR_HEIGHT (f
)
947 + FRAME_MENUBAR_HEIGHT (f
))));
949 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
951 pixelheight
+ FRAME_TOOLBAR_HEIGHT (f
)
952 + FRAME_MENUBAR_HEIGHT (f
));
954 else if (EQ (fullscreen
, Qfullheight
) && height
== FRAME_TEXT_HEIGHT (f
))
956 frame_size_history_add
957 (f
, Qxg_frame_set_char_size_2
, width
, height
,
958 list2 (make_number (gwidth
),
959 make_number (pixelwidth
+ FRAME_TOOLBAR_WIDTH (f
))));
961 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
962 pixelwidth
+ FRAME_TOOLBAR_WIDTH (f
),
968 frame_size_history_add
969 (f
, Qxg_frame_set_char_size_3
, width
, height
,
970 list2 (make_number (pixelwidth
+ FRAME_TOOLBAR_WIDTH (f
)),
971 make_number (pixelheight
+ FRAME_TOOLBAR_HEIGHT (f
)
972 + FRAME_MENUBAR_HEIGHT (f
))));
974 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
975 pixelwidth
+ FRAME_TOOLBAR_WIDTH (f
),
976 pixelheight
+ FRAME_TOOLBAR_HEIGHT (f
)
977 + FRAME_MENUBAR_HEIGHT (f
));
981 SET_FRAME_GARBAGED (f
);
982 cancel_mouse_face (f
);
984 x_wm_set_size_hint (f
, 0, 0);
985 /* We can not call change_frame_size for a mapped frame,
986 we can not set pixel width/height either. The window manager may
987 override our resize request, XMonad does this all the time.
988 The best we can do is try to sync, so lisp code sees the updated
989 size as fast as possible.
990 For unmapped windows, we can set rows/cols. When
991 the frame is mapped again we will (hopefully) get the correct size. */
992 if (FRAME_VISIBLE_P (f
))
994 /* Must call this to flush out events */
995 (void)gtk_events_pending ();
997 x_wait_for_event (f
, ConfigureNotify
);
999 if (!NILP (fullscreen
))
1000 /* Try to restore fullscreen state. */
1002 store_frame_param (f
, Qfullscreen
, fullscreen
);
1003 x_set_fullscreen (f
, fullscreen
, fullscreen
);
1007 adjust_frame_size (f
, width
, height
, 5, 0, Qxg_frame_set_char_size
);
1011 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
1012 The policy is to keep the number of editable lines. */
1016 xg_height_or_width_changed (struct frame
*f
)
1018 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1019 FRAME_TOTAL_PIXEL_WIDTH (f
),
1020 FRAME_TOTAL_PIXEL_HEIGHT (f
));
1021 f
->output_data
.x
->hint_flags
= 0;
1022 x_wm_set_size_hint (f
, 0, 0);
1026 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
1027 Must be done like this, because GtkWidget:s can have "hidden"
1028 X Window that aren't accessible.
1030 Return 0 if no widget match WDESC. */
1033 xg_win_to_widget (Display
*dpy
, Window wdesc
)
1036 GtkWidget
*gwdesc
= 0;
1040 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
1045 event
.any
.window
= gdkwin
;
1046 event
.any
.type
= GDK_NOTHING
;
1047 gwdesc
= gtk_get_event_widget (&event
);
1054 /* Set the background of widget W to PIXEL. */
1057 xg_set_widget_bg (struct frame
*f
, GtkWidget
*w
, unsigned long pixel
)
1063 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
1065 bg
.red
= (double)xbg
.red
/65535.0;
1066 bg
.green
= (double)xbg
.green
/65535.0;
1067 bg
.blue
= (double)xbg
.blue
/65535.0;
1069 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
1073 GdkColormap
*map
= gtk_widget_get_colormap (w
);
1074 gdk_colormap_query_color (map
, pixel
, &bg
);
1075 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
1079 /* Callback called when the gtk theme changes.
1080 We notify lisp code so it can fix faces used for region for example. */
1083 style_changed_cb (GObject
*go
,
1087 struct input_event event
;
1088 GdkDisplay
*gdpy
= user_data
;
1089 const char *display_name
= gdk_display_get_name (gdpy
);
1090 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1093 event
.kind
= CONFIG_CHANGED_EVENT
;
1094 event
.frame_or_window
= build_string (display_name
);
1095 /* Theme doesn't change often, so intern is called seldom. */
1096 event
.arg
= intern ("theme-name");
1097 kbd_buffer_store_event (&event
);
1099 update_theme_scrollbar_width ();
1100 update_theme_scrollbar_height ();
1102 /* If scroll bar width changed, we need set the new size on all frames
1106 Lisp_Object rest
, frame
;
1107 FOR_EACH_FRAME (rest
, frame
)
1109 struct frame
*f
= XFRAME (frame
);
1110 if (FRAME_LIVE_P (f
)
1112 && FRAME_X_DISPLAY (f
) == dpy
)
1114 x_set_scroll_bar_default_width (f
);
1115 x_set_scroll_bar_default_height (f
);
1116 xg_frame_set_char_size (f
, FRAME_TEXT_WIDTH (f
), FRAME_TEXT_HEIGHT (f
));
1122 /* Called when a delete-event occurs on WIDGET. */
1125 delete_cb (GtkWidget
*widget
,
1130 /* The event doesn't arrive in the normal event loop. Send event
1132 struct frame
*f
= user_data
;
1133 struct input_event ie
;
1136 ie
.kind
= DELETE_WINDOW_EVENT
;
1137 XSETFRAME (ie
.frame_or_window
, f
);
1138 kbd_buffer_store_event (&ie
);
1144 /* Create and set up the GTK widgets for frame F.
1145 Return true if creation succeeded. */
1148 xg_create_frame_widgets (struct frame
*f
)
1151 GtkWidget
*wvbox
, *whbox
;
1160 if (FRAME_X_EMBEDDED_P (f
))
1162 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1163 wtop
= gtk_plug_new_for_display (gdpy
, f
->output_data
.x
->parent_desc
);
1166 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1168 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1169 has backported it to Gtk+ 2.0 and they add the resize grip for
1170 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1171 forever, so disable the grip. */
1172 #if (! GTK_CHECK_VERSION (3, 0, 0) \
1173 && defined HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1174 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop
), FALSE
);
1177 xg_set_screen (wtop
, f
);
1179 wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1180 whbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1181 gtk_box_set_homogeneous (GTK_BOX (wvbox
), FALSE
);
1182 gtk_box_set_homogeneous (GTK_BOX (whbox
), FALSE
);
1185 wfixed
= emacs_fixed_new (f
);
1187 wfixed
= gtk_fixed_new ();
1190 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1192 if (wtop
) gtk_widget_destroy (wtop
);
1193 if (wvbox
) gtk_widget_destroy (wvbox
);
1194 if (whbox
) gtk_widget_destroy (whbox
);
1195 if (wfixed
) gtk_widget_destroy (wfixed
);
1201 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1202 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1203 gtk_widget_set_name (wvbox
, "pane");
1204 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1206 /* If this frame has a title or name, set it in the title bar. */
1207 if (! NILP (f
->title
))
1208 title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1209 else if (! NILP (f
->name
))
1210 title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1212 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1214 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1215 FRAME_GTK_WIDGET (f
) = wfixed
;
1216 f
->output_data
.x
->vbox_widget
= wvbox
;
1217 f
->output_data
.x
->hbox_widget
= whbox
;
1219 gtk_widget_set_has_window (wfixed
, TRUE
);
1221 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1222 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1223 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1225 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1226 update_frame_tool_bar (f
);
1228 /* We don't want this widget double buffered, because we draw on it
1229 with regular X drawing primitives, so from a GTK/GDK point of
1230 view, the widget is totally blank. When an expose comes, this
1231 will make the widget blank, and then Emacs redraws it. This flickers
1232 a lot, so we turn off double buffering. */
1233 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1235 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1236 SSDATA (Vx_resource_name
),
1237 SSDATA (Vx_resource_class
));
1239 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1240 GTK is to destroy the widget. We want Emacs to do that instead. */
1241 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1242 G_CALLBACK (delete_cb
), f
);
1244 /* Convert our geometry parameters into a geometry string
1246 GTK will itself handle calculating the real position this way. */
1247 xg_set_geometry (f
);
1249 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1251 gtk_widget_add_events (wfixed
,
1252 GDK_POINTER_MOTION_MASK
1254 | GDK_BUTTON_PRESS_MASK
1255 | GDK_BUTTON_RELEASE_MASK
1256 | GDK_KEY_PRESS_MASK
1257 | GDK_ENTER_NOTIFY_MASK
1258 | GDK_LEAVE_NOTIFY_MASK
1259 | GDK_FOCUS_CHANGE_MASK
1260 | GDK_STRUCTURE_MASK
1261 | GDK_VISIBILITY_NOTIFY_MASK
);
1263 /* Must realize the windows so the X window gets created. It is used
1264 by callers of this function. */
1265 gtk_widget_realize (wfixed
);
1266 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1268 /* Since GTK clears its window by filling with the background color,
1269 we must keep X and GTK background in sync. */
1270 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1273 /* Also, do not let any background pixmap to be set, this looks very
1274 bad as Emacs overwrites the background pixmap with its own idea
1275 of background color. */
1276 style
= gtk_widget_get_modifier_style (wfixed
);
1278 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1279 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1280 gtk_widget_modify_style (wfixed
, style
);
1282 gtk_widget_set_can_focus (wfixed
, TRUE
);
1283 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1286 #ifdef USE_GTK_TOOLTIP
1287 /* Steal a tool tip window we can move ourselves. */
1288 f
->output_data
.x
->ttip_widget
= 0;
1289 f
->output_data
.x
->ttip_lbl
= 0;
1290 f
->output_data
.x
->ttip_window
= 0;
1291 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1292 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1296 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1297 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1298 /* Only connect this signal once per screen. */
1299 if (! g_signal_handler_find (G_OBJECT (gs
),
1300 G_SIGNAL_MATCH_FUNC
,
1302 G_CALLBACK (style_changed_cb
),
1305 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1306 G_CALLBACK (style_changed_cb
),
1307 gdk_screen_get_display (screen
));
1317 xg_free_frame_widgets (struct frame
*f
)
1319 if (FRAME_GTK_OUTER_WIDGET (f
))
1321 #ifdef USE_GTK_TOOLTIP
1322 struct x_output
*x
= f
->output_data
.x
;
1324 struct xg_frame_tb_info
*tbinfo
1325 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
1330 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1331 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1332 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1333 #ifdef USE_GTK_TOOLTIP
1335 gtk_widget_destroy (x
->ttip_lbl
);
1337 g_object_unref (G_OBJECT (x
->ttip_widget
));
1342 /* Set the normal size hints for the window manager, for frame F.
1343 FLAGS is the flags word to use--or 0 meaning preserve the flags
1344 that the window now has.
1345 If USER_POSITION, set the User Position
1346 flag (this is useful when FLAGS is 0). */
1349 x_wm_set_size_hint (struct frame
*f
, long int flags
, bool user_position
)
1351 /* Must use GTK routines here, otherwise GTK resets the size hints
1352 to its own defaults. */
1353 GdkGeometry size_hints
;
1354 gint hint_flags
= 0;
1355 int base_width
, base_height
;
1356 int min_rows
= 0, min_cols
= 0;
1357 int win_gravity
= f
->win_gravity
;
1358 Lisp_Object fs_state
, frame
;
1360 /* Don't set size hints during initialization; that apparently leads
1361 to a race condition. See the thread at
1362 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1363 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1366 XSETFRAME (frame
, f
);
1367 fs_state
= Fframe_parameter (frame
, Qfullscreen
);
1368 if (EQ (fs_state
, Qmaximized
) || EQ (fs_state
, Qfullboth
))
1370 /* Don't set hints when maximized or fullscreen. Apparently KWin and
1371 Gtk3 don't get along and the frame shrinks (!).
1378 memset (&size_hints
, 0, sizeof (size_hints
));
1379 f
->output_data
.x
->size_hints
= size_hints
;
1380 f
->output_data
.x
->hint_flags
= hint_flags
;
1383 flags
= f
->size_hint_flags
;
1385 size_hints
= f
->output_data
.x
->size_hints
;
1386 hint_flags
= f
->output_data
.x
->hint_flags
;
1388 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1389 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
1390 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
1392 hint_flags
|= GDK_HINT_BASE_SIZE
;
1393 /* Use one row/col here so base_height/width does not become zero.
1394 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1395 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 1) + FRAME_TOOLBAR_WIDTH (f
);
1396 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 1)
1397 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1399 if (min_cols
> 0) --min_cols
; /* We used one col in base_width = ... 1); */
1400 if (min_rows
> 0) --min_rows
; /* We used one row in base_height = ... 1); */
1402 size_hints
.base_width
= base_width
;
1403 size_hints
.base_height
= base_height
;
1404 size_hints
.min_width
= base_width
+ min_cols
* FRAME_COLUMN_WIDTH (f
);
1405 size_hints
.min_height
= base_height
+ min_rows
* FRAME_LINE_HEIGHT (f
);
1407 /* These currently have a one to one mapping with the X values, but I
1408 don't think we should rely on that. */
1409 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1410 size_hints
.win_gravity
= 0;
1411 if (win_gravity
== NorthWestGravity
)
1412 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1413 else if (win_gravity
== NorthGravity
)
1414 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1415 else if (win_gravity
== NorthEastGravity
)
1416 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1417 else if (win_gravity
== WestGravity
)
1418 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1419 else if (win_gravity
== CenterGravity
)
1420 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1421 else if (win_gravity
== EastGravity
)
1422 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1423 else if (win_gravity
== SouthWestGravity
)
1424 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1425 else if (win_gravity
== SouthGravity
)
1426 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1427 else if (win_gravity
== SouthEastGravity
)
1428 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1429 else if (win_gravity
== StaticGravity
)
1430 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1434 hint_flags
&= ~GDK_HINT_POS
;
1435 hint_flags
|= GDK_HINT_USER_POS
;
1438 if (hint_flags
!= f
->output_data
.x
->hint_flags
1439 || memcmp (&size_hints
,
1440 &f
->output_data
.x
->size_hints
,
1441 sizeof (size_hints
)) != 0)
1444 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1445 NULL
, &size_hints
, hint_flags
);
1446 f
->output_data
.x
->size_hints
= size_hints
;
1447 f
->output_data
.x
->hint_flags
= hint_flags
;
1452 /* Change background color of a frame.
1453 Since GTK uses the background color to clear the window, we must
1454 keep the GTK and X colors in sync.
1455 F is the frame to change,
1456 BG is the pixel value to change to. */
1459 xg_set_background_color (struct frame
*f
, unsigned long bg
)
1461 if (FRAME_GTK_WIDGET (f
))
1464 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1470 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1471 functions so GTK does not overwrite the icon. */
1474 xg_set_frame_icon (struct frame
*f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1476 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1480 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1485 /***********************************************************************
1487 ***********************************************************************/
1488 /* Return the dialog title to use for a dialog of type KEY.
1489 This is the encoding used by lwlib. We use the same for GTK. */
1492 get_dialog_title (char key
)
1494 const char *title
= "";
1502 title
= "Information";
1521 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1522 the dialog, but return TRUE so the event does not propagate further
1523 in GTK. This prevents GTK from destroying the dialog widget automatically
1524 and we can always destroy the widget manually, regardless of how
1525 it was popped down (button press or WM_DELETE_WINDOW).
1526 W is the dialog widget.
1527 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1528 user_data is NULL (not used).
1530 Returns TRUE to end propagation of event. */
1533 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1535 gtk_widget_unmap (w
);
1539 /* Create a popup dialog window. See also xg_create_widget below.
1540 WV is a widget_value describing the dialog.
1541 SELECT_CB is the callback to use when a button has been pressed.
1542 DEACTIVATE_CB is the callback to use when the dialog pops down.
1544 Returns the GTK dialog widget. */
1547 create_dialog (widget_value
*wv
,
1548 GCallback select_cb
,
1549 GCallback deactivate_cb
)
1551 const char *title
= get_dialog_title (wv
->name
[0]);
1552 int total_buttons
= wv
->name
[1] - '0';
1553 int right_buttons
= wv
->name
[4] - '0';
1556 int button_spacing
= 10;
1557 GtkWidget
*wdialog
= gtk_dialog_new ();
1558 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1560 GtkWidget
*whbox_down
;
1562 /* If the number of buttons is greater than 4, make two rows of buttons
1563 instead. This looks better. */
1564 bool make_two_rows
= total_buttons
> 4;
1566 #if GTK_CHECK_VERSION (3, 12, 0)
1567 GtkBuilder
*gbld
= gtk_builder_new ();
1568 GObject
*go
= gtk_buildable_get_internal_child (GTK_BUILDABLE (wd
),
1571 GtkBox
*cur_box
= GTK_BOX (go
);
1572 g_object_unref (G_OBJECT (gbld
));
1574 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1577 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1578 left_buttons
= total_buttons
- right_buttons
;
1580 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1581 gtk_widget_set_name (wdialog
, "emacs-dialog");
1586 GtkWidget
*wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, button_spacing
);
1587 GtkWidget
*whbox_up
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1588 gtk_box_set_homogeneous (GTK_BOX (wvbox
), TRUE
);
1589 gtk_box_set_homogeneous (GTK_BOX (whbox_up
), FALSE
);
1590 whbox_down
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1591 gtk_box_set_homogeneous (GTK_BOX (whbox_down
), FALSE
);
1593 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1594 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1595 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1597 cur_box
= GTK_BOX (whbox_up
);
1600 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1601 G_CALLBACK (dialog_delete_callback
), 0);
1605 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1606 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1609 for (item
= wv
->contents
; item
; item
= item
->next
)
1611 char *utf8_label
= get_utf8_string (item
->value
);
1615 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1617 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1618 /* This is the text part of the dialog. */
1619 w
= gtk_label_new (utf8_label
);
1620 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1621 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1622 #if GTK_CHECK_VERSION (3, 14, 0)
1623 gtk_widget_set_halign (w
, GTK_ALIGN_START
);
1624 gtk_widget_set_valign (w
, GTK_ALIGN_CENTER
);
1626 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1628 /* Try to make dialog look better. Must realize first so
1629 the widget can calculate the size it needs. */
1630 gtk_widget_realize (w
);
1631 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1632 gtk_box_set_spacing (wvbox
, req
.height
);
1633 if (item
->value
&& strlen (item
->value
) > 0)
1634 button_spacing
= 2*req
.width
/strlen (item
->value
);
1635 if (button_spacing
< 10) button_spacing
= 10;
1639 /* This is one button to add to the dialog. */
1640 w
= gtk_button_new_with_label (utf8_label
);
1641 if (! item
->enabled
)
1642 gtk_widget_set_sensitive (w
, FALSE
);
1644 g_signal_connect (G_OBJECT (w
), "clicked",
1645 select_cb
, item
->call_data
);
1647 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1648 if (++button_nr
== left_buttons
)
1651 cur_box
= GTK_BOX (whbox_down
);
1656 g_free (utf8_label
);
1662 struct xg_dialog_data
1670 /* Function that is called when the file or font dialogs pop down.
1671 W is the dialog widget, RESPONSE is the response code.
1672 USER_DATA is what we passed in to g_signal_connect. */
1675 xg_dialog_response_cb (GtkDialog
*w
,
1679 struct xg_dialog_data
*dd
= user_data
;
1680 dd
->response
= response
;
1681 g_main_loop_quit (dd
->loop
);
1685 /* Destroy the dialog. This makes it pop down. */
1688 pop_down_dialog (void *arg
)
1690 struct xg_dialog_data
*dd
= arg
;
1693 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1694 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1696 g_main_loop_quit (dd
->loop
);
1697 g_main_loop_unref (dd
->loop
);
1702 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1703 We pass in DATA as gpointer* so we can use this as a callback. */
1706 xg_maybe_add_timer (gpointer data
)
1708 struct xg_dialog_data
*dd
= data
;
1709 struct timespec next_time
= timer_check ();
1713 if (timespec_valid_p (next_time
))
1715 time_t s
= next_time
.tv_sec
;
1716 int per_ms
= TIMESPEC_RESOLUTION
/ 1000;
1717 int ms
= (next_time
.tv_nsec
+ per_ms
- 1) / per_ms
;
1718 if (s
<= ((guint
) -1 - ms
) / 1000)
1719 dd
->timerid
= g_timeout_add (s
* 1000 + ms
, xg_maybe_add_timer
, dd
);
1725 /* Pops up a modal dialog W and waits for response.
1726 We don't use gtk_dialog_run because we want to process emacs timers.
1727 The dialog W is not destroyed when this function returns. */
1730 xg_dialog_run (struct frame
*f
, GtkWidget
*w
)
1732 ptrdiff_t count
= SPECPDL_INDEX ();
1733 struct xg_dialog_data dd
;
1735 xg_set_screen (w
, f
);
1736 gtk_window_set_transient_for (GTK_WINDOW (w
),
1737 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1738 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1739 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1741 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1742 dd
.response
= GTK_RESPONSE_CANCEL
;
1746 g_signal_connect (G_OBJECT (w
),
1748 G_CALLBACK (xg_dialog_response_cb
),
1750 /* Don't destroy the widget if closed by the window manager close button. */
1751 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1752 gtk_widget_show (w
);
1754 record_unwind_protect_ptr (pop_down_dialog
, &dd
);
1756 (void) xg_maybe_add_timer (&dd
);
1757 g_main_loop_run (dd
.loop
);
1760 unbind_to (count
, Qnil
);
1766 /***********************************************************************
1767 File dialog functions
1768 ***********************************************************************/
1769 /* Return true if the old file selection dialog is being used. */
1772 xg_uses_old_file_dialog (void)
1774 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1775 return x_gtk_use_old_file_dialog
;
1782 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1784 /* Return the selected file for file chooser dialog W.
1785 The returned string must be free:d. */
1788 xg_get_file_name_from_chooser (GtkWidget
*w
)
1790 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1793 /* Callback called when the "Show hidden files" toggle is pressed.
1794 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1797 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1799 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1801 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1802 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1806 /* Callback called when a property changes in a file chooser.
1807 GOBJECT is the file chooser dialog, ARG1 describes the property.
1808 USER_DATA is the toggle widget in the file chooser dialog.
1809 We use this to update the "Show hidden files" toggle when the user
1810 changes that property by right clicking in the file list. */
1813 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1815 if (strcmp (arg1
->name
, "show-hidden") == 0)
1817 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1818 gboolean visible
, toggle_on
;
1820 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1821 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1823 if (!!visible
!= !!toggle_on
)
1825 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1826 G_CALLBACK (xg_toggle_visibility_cb
),
1828 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1829 g_signal_handlers_unblock_by_func
1830 (G_OBJECT (wtoggle
),
1831 G_CALLBACK (xg_toggle_visibility_cb
),
1834 x_gtk_show_hidden_files
= visible
;
1838 /* Read a file name from the user using a file chooser dialog.
1839 F is the current frame.
1840 PROMPT is a prompt to show to the user. May not be NULL.
1841 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1842 If MUSTMATCH_P, the returned file name must be an existing
1843 file. (Actually, this only has cosmetic effects, the user can
1844 still enter a non-existing file.) *FUNC is set to a function that
1845 can be used to retrieve the selected file name from the returned widget.
1847 Returns the created widget. */
1850 xg_get_file_with_chooser (struct frame
*f
,
1852 char *default_filename
,
1853 bool mustmatch_p
, bool only_dir_p
,
1854 xg_get_file_func
*func
)
1858 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1859 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1860 GtkFileChooserAction action
= (mustmatch_p
?
1861 GTK_FILE_CHOOSER_ACTION_OPEN
:
1862 GTK_FILE_CHOOSER_ACTION_SAVE
);
1865 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1867 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1868 XG_TEXT_CANCEL
, GTK_RESPONSE_CANCEL
,
1869 (mustmatch_p
|| only_dir_p
?
1870 XG_TEXT_OPEN
: XG_TEXT_OK
),
1873 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1875 wbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1876 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
1877 gtk_widget_show (wbox
);
1878 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1880 if (x_gtk_show_hidden_files
)
1882 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1883 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1885 gtk_widget_show (wtoggle
);
1886 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1887 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1888 g_signal_connect (G_OBJECT (filewin
), "notify",
1889 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1891 if (x_gtk_file_dialog_help_text
)
1894 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1895 Show the C-l help text only for versions < 2.10. */
1896 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1897 z
= stpcpy (z
, "\nType C-l to display a file name text entry box.\n");
1898 strcpy (z
, "\nIf you don't like this file selector, use the "
1899 "corresponding\nkey binding or customize "
1900 "use-file-dialog to turn it off.");
1902 wmessage
= gtk_label_new (msgbuf
);
1903 gtk_widget_show (wmessage
);
1906 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1907 if (x_gtk_file_dialog_help_text
)
1908 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1909 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1911 if (default_filename
)
1914 struct gcpro gcpro1
;
1915 char *utf8_filename
;
1918 file
= build_string (default_filename
);
1920 /* File chooser does not understand ~/... in the file name. It must be
1921 an absolute name starting with /. */
1922 if (default_filename
[0] != '/')
1923 file
= Fexpand_file_name (file
, Qnil
);
1925 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1926 if (! NILP (Ffile_directory_p (file
)))
1927 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1931 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1933 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1935 char *cp
= strrchr (utf8_filename
, '/');
1937 else cp
= utf8_filename
;
1938 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1945 *func
= xg_get_file_name_from_chooser
;
1949 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1951 /* Return the selected file for file selector dialog W.
1952 The returned string must be free:d. */
1955 xg_get_file_name_from_selector (GtkWidget
*w
)
1957 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1958 return xstrdup (gtk_file_selection_get_filename (filesel
));
1961 /* Create a file selection dialog.
1962 F is the current frame.
1963 PROMPT is a prompt to show to the user. May not be NULL.
1964 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1965 If MUSTMATCH_P, the returned file name must be an existing
1966 file. *FUNC is set to a function that can be used to retrieve the
1967 selected file name from the returned widget.
1969 Returns the created widget. */
1972 xg_get_file_with_selection (struct frame
*f
,
1974 char *default_filename
,
1975 bool mustmatch_p
, bool only_dir_p
,
1976 xg_get_file_func
*func
)
1979 GtkFileSelection
*filesel
;
1981 filewin
= gtk_file_selection_new (prompt
);
1982 filesel
= GTK_FILE_SELECTION (filewin
);
1984 if (default_filename
)
1985 gtk_file_selection_set_filename (filesel
, default_filename
);
1989 /* The selection_entry part of filesel is not documented. */
1990 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1991 gtk_file_selection_hide_fileop_buttons (filesel
);
1994 *func
= xg_get_file_name_from_selector
;
1998 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
2000 /* Read a file name from the user using a file dialog, either the old
2001 file selection dialog, or the new file chooser dialog. Which to use
2002 depends on what the GTK version used has, and what the value of
2003 gtk-use-old-file-dialog.
2004 F is the current frame.
2005 PROMPT is a prompt to show to the user. May not be NULL.
2006 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
2007 If MUSTMATCH_P, the returned file name must be an existing
2010 Returns a file name or NULL if no file was selected.
2011 The returned string must be freed by the caller. */
2014 xg_get_file_name (struct frame
*f
,
2016 char *default_filename
,
2022 int filesel_done
= 0;
2023 xg_get_file_func func
;
2025 #ifdef HAVE_GTK_FILE_SELECTION_NEW
2027 if (xg_uses_old_file_dialog ())
2028 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
2029 mustmatch_p
, only_dir_p
, &func
);
2031 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
2032 mustmatch_p
, only_dir_p
, &func
);
2034 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
2035 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
2036 mustmatch_p
, only_dir_p
, &func
);
2037 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
2039 gtk_widget_set_name (w
, "emacs-filedialog");
2041 filesel_done
= xg_dialog_run (f
, w
);
2042 if (filesel_done
== GTK_RESPONSE_OK
)
2045 gtk_widget_destroy (w
);
2049 /***********************************************************************
2051 ***********************************************************************/
2053 #ifdef HAVE_FREETYPE
2055 #if USE_NEW_GTK_FONT_CHOOSER
2057 #define XG_WEIGHT_TO_SYMBOL(w) \
2058 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
2059 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
2060 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
2061 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
2062 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
2063 : w <= PANGO_WEIGHT_BOLD ? Qbold \
2064 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
2067 #define XG_STYLE_TO_SYMBOL(s) \
2068 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
2069 : s == PANGO_STYLE_ITALIC ? Qitalic \
2072 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2075 static char *x_last_font_name
;
2077 /* Pop up a GTK font selector and return the name of the font the user
2078 selects, as a C string. The returned font name follows GTK's own
2081 `FAMILY [VALUE1 VALUE2] SIZE'
2083 This can be parsed using font_parse_fcname in font.c.
2084 DEFAULT_NAME, if non-zero, is the default font name. */
2087 xg_get_font (struct frame
*f
, const char *default_name
)
2091 Lisp_Object font
= Qnil
;
2093 w
= gtk_font_chooser_dialog_new
2094 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2098 /* Convert fontconfig names to Gtk names, i.e. remove - before
2100 char *p
= strrchr (default_name
, '-');
2104 while (c_isdigit (*ep
))
2106 if (*ep
== '\0') *p
= ' ';
2109 else if (x_last_font_name
)
2110 default_name
= x_last_font_name
;
2113 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w
), default_name
);
2115 gtk_widget_set_name (w
, "emacs-fontdialog");
2116 done
= xg_dialog_run (f
, w
);
2117 if (done
== GTK_RESPONSE_OK
)
2119 #if USE_NEW_GTK_FONT_CHOOSER
2120 /* Use the GTK3 font chooser. */
2121 PangoFontDescription
*desc
2122 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w
));
2126 const char *name
= pango_font_description_get_family (desc
);
2127 gint size
= pango_font_description_get_size (desc
);
2128 PangoWeight weight
= pango_font_description_get_weight (desc
);
2129 PangoStyle style
= pango_font_description_get_style (desc
);
2132 #define FONT_TYPE_WANTED (Qftcr)
2134 #define FONT_TYPE_WANTED (Qxft)
2136 font
= CALLN (Ffont_spec
,
2137 QCname
, build_string (name
),
2138 QCsize
, make_float (pango_units_to_double (size
)),
2139 QCweight
, XG_WEIGHT_TO_SYMBOL (weight
),
2140 QCslant
, XG_STYLE_TO_SYMBOL (style
),
2144 pango_font_description_free (desc
);
2145 dupstring (&x_last_font_name
, name
);
2148 #else /* Use old font selector, which just returns the font name. */
2151 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w
));
2155 font
= build_string (font_name
);
2156 g_free (x_last_font_name
);
2157 x_last_font_name
= font_name
;
2159 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2162 gtk_widget_destroy (w
);
2165 #endif /* HAVE_FREETYPE */
2169 /***********************************************************************
2171 ***********************************************************************/
2173 /* The name of menu items that can be used for customization. Since GTK
2174 RC files are very crude and primitive, we have to set this on all
2175 menu item names so a user can easily customize menu items. */
2177 #define MENU_ITEM_NAME "emacs-menuitem"
2180 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2181 during GC. The next member points to the items. */
2182 static xg_list_node xg_menu_cb_list
;
2184 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2185 during GC. The next member points to the items. */
2186 static xg_list_node xg_menu_item_cb_list
;
2188 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2189 F is the frame CL_DATA will be initialized for.
2190 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2192 The menu bar and all sub menus under the menu bar in a frame
2193 share the same structure, hence the reference count.
2195 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2196 allocated xg_menu_cb_data if CL_DATA is NULL. */
2198 static xg_menu_cb_data
*
2199 make_cl_data (xg_menu_cb_data
*cl_data
, struct frame
*f
, GCallback highlight_cb
)
2203 cl_data
= xmalloc (sizeof *cl_data
);
2205 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2206 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2207 cl_data
->highlight_cb
= highlight_cb
;
2208 cl_data
->ref_count
= 0;
2210 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2213 cl_data
->ref_count
++;
2218 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2219 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2221 When the menu bar is updated, menu items may have been added and/or
2222 removed, so menu_bar_vector and menu_bar_items_used change. We must
2223 then update CL_DATA since it is used to determine which menu
2224 item that is invoked in the menu.
2225 HIGHLIGHT_CB could change, there is no check that the same
2226 function is given when modifying a menu bar as was given when
2227 creating the menu bar. */
2230 update_cl_data (xg_menu_cb_data
*cl_data
,
2232 GCallback highlight_cb
)
2237 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2238 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2239 cl_data
->highlight_cb
= highlight_cb
;
2243 /* Decrease reference count for CL_DATA.
2244 If reference count is zero, free CL_DATA. */
2247 unref_cl_data (xg_menu_cb_data
*cl_data
)
2249 if (cl_data
&& cl_data
->ref_count
> 0)
2251 cl_data
->ref_count
--;
2252 if (cl_data
->ref_count
== 0)
2254 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2260 /* Function that marks all lisp data during GC. */
2266 Lisp_Object rest
, frame
;
2268 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2269 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2271 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2273 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2275 if (! NILP (cb_data
->help
))
2276 mark_object (cb_data
->help
);
2279 FOR_EACH_FRAME (rest
, frame
)
2281 struct frame
*f
= XFRAME (frame
);
2283 if (FRAME_X_P (f
) && FRAME_GTK_OUTER_WIDGET (f
))
2285 struct xg_frame_tb_info
*tbinfo
2286 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
2290 mark_object (tbinfo
->last_tool_bar
);
2291 mark_object (tbinfo
->style
);
2298 /* Callback called when a menu item is destroyed. Used to free data.
2299 W is the widget that is being destroyed (not used).
2300 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2303 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2307 xg_menu_item_cb_data
*data
= client_data
;
2308 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2313 /* Callback called when the pointer enters/leaves a menu item.
2314 W is the parent of the menu item.
2315 EVENT is either an enter event or leave event.
2316 CLIENT_DATA is not used.
2318 Returns FALSE to tell GTK to keep processing this event. */
2321 menuitem_highlight_callback (GtkWidget
*w
,
2322 GdkEventCrossing
*event
,
2323 gpointer client_data
)
2326 GtkWidget
*subwidget
;
2327 xg_menu_item_cb_data
*data
;
2329 ev
.crossing
= *event
;
2330 subwidget
= gtk_get_event_widget (&ev
);
2331 data
= g_object_get_data (G_OBJECT (subwidget
), XG_ITEM_DATA
);
2334 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2336 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2337 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2338 (*func
) (subwidget
, call_data
);
2345 /* Callback called when a menu is destroyed. Used to free data.
2346 W is the widget that is being destroyed (not used).
2347 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2350 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2352 unref_cl_data (client_data
);
2355 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2356 must be non-NULL) and can be inserted into a menu item.
2358 Returns the GtkHBox. */
2361 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2367 wbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
2368 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
2369 wlbl
= gtk_label_new (utf8_label
);
2370 wkey
= gtk_label_new (utf8_key
);
2372 #if GTK_CHECK_VERSION (3, 14, 0)
2373 gtk_widget_set_halign (wlbl
, GTK_ALIGN_START
);
2374 gtk_widget_set_valign (wlbl
, GTK_ALIGN_CENTER
);
2375 gtk_widget_set_halign (wkey
, GTK_ALIGN_START
);
2376 gtk_widget_set_valign (wkey
, GTK_ALIGN_CENTER
);
2378 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2379 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2381 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2382 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2384 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2385 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2386 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2391 /* Make and return a menu item widget with the key to the right.
2392 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2393 UTF8_KEY is the text representing the key binding.
2394 ITEM is the widget_value describing the menu item.
2396 GROUP is an in/out parameter. If the menu item to be created is not
2397 part of any radio menu group, *GROUP contains NULL on entry and exit.
2398 If the menu item to be created is part of a radio menu group, on entry
2399 *GROUP contains the group to use, or NULL if this is the first item
2400 in the group. On exit, *GROUP contains the radio item group.
2402 Unfortunately, keys don't line up as nicely as in Motif,
2403 but the MacOS X version doesn't either, so I guess that is OK. */
2406 make_menu_item (const char *utf8_label
,
2407 const char *utf8_key
,
2412 GtkWidget
*wtoadd
= 0;
2414 /* It has been observed that some menu items have a NULL name field.
2415 This will lead to this function being called with a NULL utf8_label.
2416 GTK crashes on that so we set a blank label. Why there is a NULL
2417 name remains to be investigated. */
2418 if (! utf8_label
) utf8_label
= " ";
2421 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2423 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2426 if (utf8_key
) w
= gtk_check_menu_item_new ();
2427 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2428 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2430 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2432 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2433 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2434 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2436 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2441 if (utf8_key
) w
= gtk_menu_item_new ();
2442 else w
= gtk_menu_item_new_with_label (utf8_label
);
2445 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2446 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2451 /* Create a menu item widget, and connect the callbacks.
2452 ITEM describes the menu item.
2453 F is the frame the created menu belongs to.
2454 SELECT_CB is the callback to use when a menu item is selected.
2455 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2456 CL_DATA points to the callback data to be used for this menu.
2457 GROUP is an in/out parameter. If the menu item to be created is not
2458 part of any radio menu group, *GROUP contains NULL on entry and exit.
2459 If the menu item to be created is part of a radio menu group, on entry
2460 *GROUP contains the group to use, or NULL if this is the first item
2461 in the group. On exit, *GROUP contains the radio item group.
2463 Returns the created GtkWidget. */
2466 xg_create_one_menuitem (widget_value
*item
,
2468 GCallback select_cb
,
2469 GCallback highlight_cb
,
2470 xg_menu_cb_data
*cl_data
,
2476 xg_menu_item_cb_data
*cb_data
;
2478 utf8_label
= get_utf8_string (item
->name
);
2479 utf8_key
= get_utf8_string (item
->key
);
2481 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2483 if (utf8_label
) g_free (utf8_label
);
2484 if (utf8_key
) g_free (utf8_key
);
2486 cb_data
= xmalloc (sizeof *cb_data
);
2488 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2490 cb_data
->select_id
= 0;
2491 cb_data
->help
= item
->help
;
2492 cb_data
->cl_data
= cl_data
;
2493 cb_data
->call_data
= item
->call_data
;
2495 g_signal_connect (G_OBJECT (w
),
2497 G_CALLBACK (menuitem_destroy_callback
),
2500 /* Put cb_data in widget, so we can get at it when modifying menubar */
2501 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2503 /* final item, not a submenu */
2504 if (item
->call_data
&& ! item
->contents
)
2508 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2514 /* Create a full menu tree specified by DATA.
2515 F is the frame the created menu belongs to.
2516 SELECT_CB is the callback to use when a menu item is selected.
2517 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2518 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2519 If POP_UP_P, create a popup menu.
2520 If MENU_BAR_P, create a menu bar.
2521 TOPMENU is the topmost GtkWidget that others shall be placed under.
2522 It may be NULL, in that case we create the appropriate widget
2523 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2524 CL_DATA is the callback data we shall use for this menu, or NULL
2525 if we haven't set the first callback yet.
2526 NAME is the name to give to the top level menu if this function
2527 creates it. May be NULL to not set any name.
2529 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2532 This function calls itself to create submenus. */
2535 create_menus (widget_value
*data
,
2537 GCallback select_cb
,
2538 GCallback deactivate_cb
,
2539 GCallback highlight_cb
,
2543 xg_menu_cb_data
*cl_data
,
2547 GtkWidget
*wmenu
= topmenu
;
2548 GSList
*group
= NULL
;
2554 wmenu
= gtk_menu_new ();
2555 xg_set_screen (wmenu
, f
);
2556 /* Connect this to the menu instead of items so we get enter/leave for
2557 disabled items also. TODO: Still does not get enter/leave for
2558 disabled items in detached menus. */
2559 g_signal_connect (G_OBJECT (wmenu
),
2560 "enter-notify-event",
2561 G_CALLBACK (menuitem_highlight_callback
),
2563 g_signal_connect (G_OBJECT (wmenu
),
2564 "leave-notify-event",
2565 G_CALLBACK (menuitem_highlight_callback
),
2570 wmenu
= gtk_menu_bar_new ();
2571 /* Set width of menu bar to a small value so it doesn't enlarge
2572 a small initial frame size. The width will be set to the
2573 width of the frame later on when it is added to a container.
2574 height -1: Natural height. */
2575 gtk_widget_set_size_request (wmenu
, 1, -1);
2578 /* Put cl_data on the top menu for easier access. */
2579 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2580 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2581 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2582 G_CALLBACK (menu_destroy_callback
), cl_data
);
2585 gtk_widget_set_name (wmenu
, name
);
2588 g_signal_connect (G_OBJECT (wmenu
),
2589 "selection-done", deactivate_cb
, 0);
2592 for (item
= data
; item
; item
= item
->next
)
2596 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2597 && !menu_separator_name_p (item
->name
))
2600 /* A title for a popup. We do the same as GTK does when
2601 creating titles, but it does not look good. */
2603 utf8_label
= get_utf8_string (item
->name
);
2605 w
= gtk_menu_item_new_with_label (utf8_label
);
2606 gtk_widget_set_sensitive (w
, FALSE
);
2607 if (utf8_label
) g_free (utf8_label
);
2609 else if (menu_separator_name_p (item
->name
))
2612 /* GTK only have one separator type. */
2613 w
= gtk_separator_menu_item_new ();
2617 w
= xg_create_one_menuitem (item
,
2619 item
->contents
? 0 : select_cb
,
2624 /* Create a possibly empty submenu for menu bar items, since some
2625 themes don't highlight items correctly without it. */
2626 if (item
->contents
|| menu_bar_p
)
2628 GtkWidget
*submenu
= create_menus (item
->contents
,
2638 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2642 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2643 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2649 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2650 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2651 with some text and buttons.
2652 F is the frame the created item belongs to.
2653 NAME is the name to use for the top widget.
2654 VAL is a widget_value structure describing items to be created.
2655 SELECT_CB is the callback to use when a menu item is selected or
2656 a dialog button is pressed.
2657 DEACTIVATE_CB is the callback to use when an item is deactivated.
2658 For a menu, when a sub menu is not shown anymore, for a dialog it is
2659 called when the dialog is popped down.
2660 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2662 Returns the widget created. */
2665 xg_create_widget (const char *type
, const char *name
, struct frame
*f
,
2666 widget_value
*val
, GCallback select_cb
,
2667 GCallback deactivate_cb
, GCallback highlight_cb
)
2670 bool menu_bar_p
= strcmp (type
, "menubar") == 0;
2671 bool pop_up_p
= strcmp (type
, "popup") == 0;
2673 if (strcmp (type
, "dialog") == 0)
2675 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2676 xg_set_screen (w
, f
);
2677 gtk_window_set_transient_for (GTK_WINDOW (w
),
2678 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2679 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2680 gtk_widget_set_name (w
, "emacs-dialog");
2681 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2683 else if (menu_bar_p
|| pop_up_p
)
2685 w
= create_menus (val
->contents
,
2696 /* Set the cursor to an arrow for popup menus when they are mapped.
2697 This is done by default for menu bar menus. */
2700 /* Must realize so the GdkWindow inside the widget is created. */
2701 gtk_widget_realize (w
);
2702 xg_set_cursor (w
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
2707 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2714 /* Return the label for menu item WITEM. */
2717 xg_get_menu_item_label (GtkMenuItem
*witem
)
2719 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2720 return gtk_label_get_label (wlabel
);
2723 /* Return true if the menu item WITEM has the text LABEL. */
2726 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2729 char *utf8_label
= get_utf8_string (label
);
2730 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2732 if (! old_label
&& ! utf8_label
)
2734 else if (old_label
&& utf8_label
)
2735 is_same
= strcmp (utf8_label
, old_label
) == 0;
2737 if (utf8_label
) g_free (utf8_label
);
2742 /* Destroy widgets in LIST. */
2745 xg_destroy_widgets (GList
*list
)
2749 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2751 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2753 /* Destroying the widget will remove it from the container it is in. */
2754 gtk_widget_destroy (w
);
2758 /* Update the top level names in MENUBAR (i.e. not submenus).
2759 F is the frame the menu bar belongs to.
2760 *LIST is a list with the current menu bar names (menu item widgets).
2761 ITER is the item within *LIST that shall be updated.
2762 POS is the numerical position, starting at 0, of ITER in *LIST.
2763 VAL describes what the menu bar shall look like after the update.
2764 SELECT_CB is the callback to use when a menu item is selected.
2765 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2766 CL_DATA points to the callback data to be used for this menu bar.
2768 This function calls itself to walk through the menu bar names. */
2771 xg_update_menubar (GtkWidget
*menubar
,
2777 GCallback select_cb
,
2778 GCallback deactivate_cb
,
2779 GCallback highlight_cb
,
2780 xg_menu_cb_data
*cl_data
)
2782 if (! iter
&& ! val
)
2784 else if (iter
&& ! val
)
2786 /* Item(s) have been removed. Remove all remaining items. */
2787 xg_destroy_widgets (iter
);
2789 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2790 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2791 gtk_menu_item_new_with_label (""),
2797 else if (! iter
&& val
)
2799 /* Item(s) added. Add all new items in one call. */
2800 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2801 0, 1, menubar
, cl_data
, 0);
2807 /* Below this neither iter or val is NULL */
2808 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2810 /* This item is still the same, check next item. */
2812 iter
= g_list_next (iter
);
2815 else /* This item is changed. */
2817 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2818 GtkMenuItem
*witem2
= 0;
2819 bool val_in_menubar
= 0;
2820 bool iter_in_new_menubar
= 0;
2824 /* See if the changed entry (val) is present later in the menu bar */
2826 iter2
&& ! val_in_menubar
;
2827 iter2
= g_list_next (iter2
))
2829 witem2
= GTK_MENU_ITEM (iter2
->data
);
2830 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2833 /* See if the current entry (iter) is present later in the
2834 specification for the new menu bar. */
2835 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2836 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2838 if (val_in_menubar
&& ! iter_in_new_menubar
)
2842 /* This corresponds to:
2847 g_object_ref (G_OBJECT (witem
));
2848 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2849 gtk_widget_destroy (GTK_WIDGET (witem
));
2851 /* Must get new list since the old changed. */
2852 g_list_free (*list
);
2853 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2854 while (nr
-- > 0) iter
= g_list_next (iter
);
2856 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2858 /* This corresponds to:
2861 Rename B to X. This might seem to be a strange thing to do,
2862 since if there is a menu under B it will be totally wrong for X.
2863 But consider editing a C file. Then there is a C-mode menu
2864 (corresponds to B above).
2865 If then doing C-x C-f the minibuf menu (X above) replaces the
2866 C-mode menu. When returning from the minibuffer, we get
2867 back the C-mode menu. Thus we do:
2868 Rename B to X (C-mode to minibuf menu)
2869 Rename X to B (minibuf to C-mode menu).
2870 If the X menu hasn't been invoked, the menu under B
2871 is up to date when leaving the minibuffer. */
2872 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2873 char *utf8_label
= get_utf8_string (val
->name
);
2875 /* GTK menu items don't notice when their labels have been
2876 changed from underneath them, so we have to explicitly
2877 use g_object_notify to tell listeners (e.g., a GMenuModel
2878 bridge that might be loaded) that the item's label has
2880 gtk_label_set_text (wlabel
, utf8_label
);
2881 #if GTK_CHECK_VERSION (2, 16, 0)
2882 g_object_notify (G_OBJECT (witem
), "label");
2884 if (utf8_label
) g_free (utf8_label
);
2885 iter
= g_list_next (iter
);
2889 else if (! val_in_menubar
&& iter_in_new_menubar
)
2891 /* This corresponds to:
2898 GtkWidget
*w
= xg_create_one_menuitem (val
,
2905 /* Create a possibly empty submenu for menu bar items, since some
2906 themes don't highlight items correctly without it. */
2907 GtkWidget
*submenu
= create_menus (NULL
, f
,
2908 select_cb
, deactivate_cb
,
2910 0, 0, 0, cl_data
, 0);
2912 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2913 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2914 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2916 g_list_free (*list
);
2917 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2918 while (nr
-- > 0) iter
= g_list_next (iter
);
2919 iter
= g_list_next (iter
);
2923 else /* if (val_in_menubar && iter_in_new_menubar) */
2926 /* This corresponds to:
2931 g_object_ref (G_OBJECT (witem2
));
2932 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2933 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2934 GTK_WIDGET (witem2
), pos
);
2935 g_object_unref (G_OBJECT (witem2
));
2937 g_list_free (*list
);
2938 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2939 while (nr
-- > 0) iter
= g_list_next (iter
);
2940 if (iter
) iter
= g_list_next (iter
);
2946 /* Update the rest of the menu bar. */
2947 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2948 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2951 /* Update the menu item W so it corresponds to VAL.
2952 SELECT_CB is the callback to use when a menu item is selected.
2953 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2954 CL_DATA is the data to set in the widget for menu invocation. */
2957 xg_update_menu_item (widget_value
*val
,
2959 GCallback select_cb
,
2960 GCallback highlight_cb
,
2961 xg_menu_cb_data
*cl_data
)
2968 const char *old_label
= 0;
2969 const char *old_key
= 0;
2970 xg_menu_item_cb_data
*cb_data
;
2971 bool label_changed
= false;
2973 wchild
= XG_BIN_CHILD (w
);
2974 utf8_label
= get_utf8_string (val
->name
);
2975 utf8_key
= get_utf8_string (val
->key
);
2977 /* See if W is a menu item with a key. See make_menu_item above. */
2978 if (GTK_IS_BOX (wchild
))
2980 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2982 wlbl
= GTK_LABEL (list
->data
);
2983 wkey
= GTK_LABEL (list
->next
->data
);
2988 /* Remove the key and keep just the label. */
2989 g_object_ref (G_OBJECT (wlbl
));
2990 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2991 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2992 g_object_unref (G_OBJECT (wlbl
));
2997 else /* Just a label. */
2999 wlbl
= GTK_LABEL (wchild
);
3001 /* Check if there is now a key. */
3004 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
3005 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
3007 wlbl
= GTK_LABEL (list
->data
);
3008 wkey
= GTK_LABEL (list
->next
->data
);
3011 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3012 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
3016 if (wkey
) old_key
= gtk_label_get_label (wkey
);
3017 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
3019 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
3021 label_changed
= true;
3022 gtk_label_set_text (wkey
, utf8_key
);
3025 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
3027 label_changed
= true;
3028 gtk_label_set_text (wlbl
, utf8_label
);
3031 if (utf8_key
) g_free (utf8_key
);
3032 if (utf8_label
) g_free (utf8_label
);
3034 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
3035 gtk_widget_set_sensitive (w
, FALSE
);
3036 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
3037 gtk_widget_set_sensitive (w
, TRUE
);
3039 cb_data
= g_object_get_data (G_OBJECT (w
), XG_ITEM_DATA
);
3042 cb_data
->call_data
= val
->call_data
;
3043 cb_data
->help
= val
->help
;
3044 cb_data
->cl_data
= cl_data
;
3046 /* We assume the callback functions don't change. */
3047 if (val
->call_data
&& ! val
->contents
)
3049 /* This item shall have a select callback. */
3050 if (! cb_data
->select_id
)
3052 = g_signal_connect (G_OBJECT (w
), "activate",
3053 select_cb
, cb_data
);
3055 else if (cb_data
->select_id
)
3057 g_signal_handler_disconnect (w
, cb_data
->select_id
);
3058 cb_data
->select_id
= 0;
3062 #if GTK_CHECK_VERSION (2, 16, 0)
3063 if (label_changed
) /* See comment in xg_update_menubar. */
3064 g_object_notify (G_OBJECT (w
), "label");
3068 /* Update the toggle menu item W so it corresponds to VAL. */
3071 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
3073 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3076 /* Update the radio menu item W so it corresponds to VAL. */
3079 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
3081 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3084 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3085 SUBMENU may be NULL, in that case a new menu is created.
3086 F is the frame the menu bar belongs to.
3087 VAL describes the contents of the menu bar.
3088 SELECT_CB is the callback to use when a menu item is selected.
3089 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3090 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3091 CL_DATA is the call back data to use for any newly created items.
3093 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3097 xg_update_submenu (GtkWidget
*submenu
,
3100 GCallback select_cb
,
3101 GCallback deactivate_cb
,
3102 GCallback highlight_cb
,
3103 xg_menu_cb_data
*cl_data
)
3105 GtkWidget
*newsub
= submenu
;
3109 GList
*first_radio
= 0;
3112 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3114 for (cur
= val
, iter
= list
;
3116 iter
= g_list_next (iter
), cur
= cur
->next
)
3118 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3120 /* Remember first radio button in a group. If we get a mismatch in
3121 a radio group we must rebuild the whole group so that the connections
3122 in GTK becomes correct. */
3123 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3125 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3126 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3129 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3131 if (! menu_separator_name_p (cur
->name
))
3134 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3136 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3138 xg_update_toggle_item (cur
, w
);
3139 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3141 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3143 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3145 xg_update_radio_item (cur
, w
);
3146 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3148 else if (GTK_IS_MENU_ITEM (w
))
3150 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3153 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3154 menu_separator_name_p (cur
->name
))
3157 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3159 sub
= gtk_menu_item_get_submenu (witem
);
3160 if (sub
&& ! cur
->contents
)
3162 /* Not a submenu anymore. */
3163 g_object_ref (G_OBJECT (sub
));
3164 remove_submenu (witem
);
3165 gtk_widget_destroy (sub
);
3167 else if (cur
->contents
)
3171 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3172 select_cb
, deactivate_cb
,
3173 highlight_cb
, cl_data
);
3175 /* If this item just became a submenu, we must set it. */
3177 gtk_menu_item_set_submenu (witem
, nsub
);
3182 /* Structural difference. Remove everything from here and down
3188 /* Remove widgets from first structural change. */
3191 /* If we are adding new menu items below, we must remove from
3192 first radio button so that radio groups become correct. */
3193 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3194 else xg_destroy_widgets (iter
);
3199 /* More items added. Create them. */
3200 newsub
= create_menus (cur
,
3212 if (list
) g_list_free (list
);
3217 /* Update the MENUBAR.
3218 F is the frame the menu bar belongs to.
3219 VAL describes the contents of the menu bar.
3220 If DEEP_P, rebuild all but the top level menu names in
3221 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3222 SELECT_CB is the callback to use when a menu item is selected.
3223 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3224 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3227 xg_modify_menubar_widgets (GtkWidget
*menubar
, struct frame
*f
,
3228 widget_value
*val
, bool deep_p
,
3229 GCallback select_cb
, GCallback deactivate_cb
,
3230 GCallback highlight_cb
)
3232 xg_menu_cb_data
*cl_data
;
3233 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3237 cl_data
= g_object_get_data (G_OBJECT (menubar
), XG_FRAME_DATA
);
3239 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3240 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3246 /* Update all sub menus.
3247 We must keep the submenus (GTK menu item widgets) since the
3248 X Window in the XEvent that activates the menu are those widgets. */
3250 /* Update cl_data, menu_item things in F may have changed. */
3251 update_cl_data (cl_data
, f
, highlight_cb
);
3253 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3258 GtkMenuItem
*witem
= 0;
3260 /* Find sub menu that corresponds to val and update it. */
3261 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3263 witem
= GTK_MENU_ITEM (iter
->data
);
3264 if (xg_item_label_same_p (witem
, cur
->name
))
3266 sub
= gtk_menu_item_get_submenu (witem
);
3271 newsub
= xg_update_submenu (sub
,
3278 /* sub may still be NULL. If we just updated non deep and added
3279 a new menu bar item, it has no sub menu yet. So we set the
3280 newly created sub menu under witem. */
3281 if (newsub
!= sub
&& witem
!= 0)
3283 xg_set_screen (newsub
, f
);
3284 gtk_menu_item_set_submenu (witem
, newsub
);
3290 gtk_widget_show_all (menubar
);
3293 /* Callback called when the menu bar W is mapped.
3294 Used to find the height of the menu bar if we didn't get it
3295 after showing the widget. */
3298 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3301 struct frame
*f
= user_data
;
3302 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3303 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3305 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3306 adjust_frame_size (f
, -1, -1, 2, 0, Qmenu_bar_lines
);
3310 /* Recompute all the widgets of frame F, when the menu bar has been
3314 xg_update_frame_menubar (struct frame
*f
)
3316 struct x_output
*x
= f
->output_data
.x
;
3319 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3322 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3323 return; /* Already done this, happens for frames created invisible. */
3327 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3329 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3331 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3332 gtk_widget_show_all (x
->menubar_widget
);
3333 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3335 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3337 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3338 adjust_frame_size (f
, -1, -1, 2, 0, Qmenu_bar_lines
);
3343 /* Get rid of the menu bar of frame F, and free its storage.
3344 This is used when deleting a frame, and when turning off the menu bar. */
3347 free_frame_menubar (struct frame
*f
)
3349 struct x_output
*x
= f
->output_data
.x
;
3351 if (x
->menubar_widget
)
3355 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3356 /* The menubar and its children shall be deleted when removed from
3358 x
->menubar_widget
= 0;
3359 FRAME_MENUBAR_HEIGHT (f
) = 0;
3360 adjust_frame_size (f
, -1, -1, 2, 0, Qmenu_bar_lines
);
3366 xg_event_is_for_menubar (struct frame
*f
, const XEvent
*event
)
3368 struct x_output
*x
= f
->output_data
.x
;
3377 if (! x
->menubar_widget
) return 0;
3379 if (! (event
->xbutton
.x
>= 0
3380 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3381 && event
->xbutton
.y
>= 0
3382 && event
->xbutton
.y
< FRAME_MENUBAR_HEIGHT (f
)
3383 && event
->xbutton
.same_screen
))
3386 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3387 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3389 gevent
.any
.window
= gw
;
3390 gevent
.any
.type
= GDK_NOTHING
;
3391 gwdesc
= gtk_get_event_widget (&gevent
);
3392 if (! gwdesc
) return 0;
3393 if (! GTK_IS_MENU_BAR (gwdesc
)
3394 && ! GTK_IS_MENU_ITEM (gwdesc
)
3395 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3398 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3399 if (! list
) return 0;
3400 rec
.x
= event
->xbutton
.x
;
3401 rec
.y
= event
->xbutton
.y
;
3405 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3407 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3408 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3417 /***********************************************************************
3418 Scroll bar functions
3419 ***********************************************************************/
3422 /* Setting scroll bar values invokes the callback. Use this variable
3423 to indicate that callback should do nothing. */
3425 bool xg_ignore_gtk_scrollbar
;
3427 /* Width and height of scroll bars for the current theme. */
3428 static int scroll_bar_width_for_theme
;
3429 static int scroll_bar_height_for_theme
;
3431 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3432 may be larger than 32 bits. Keep a mapping from integer index to widget
3433 pointers to get around the 32 bit limitation. */
3437 GtkWidget
**widgets
;
3442 /* Grow this much every time we need to allocate more */
3444 #define ID_TO_WIDGET_INCR 32
3446 /* Store the widget pointer W in id_to_widget and return the integer index. */
3449 xg_store_widget_in_map (GtkWidget
*w
)
3453 if (id_to_widget
.max_size
== id_to_widget
.used
)
3456 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3457 memory_full (SIZE_MAX
);
3459 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3460 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3461 new_size
, sizeof (GtkWidget
*));
3463 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3464 id_to_widget
.widgets
[i
] = 0;
3465 id_to_widget
.max_size
= new_size
;
3468 /* Just loop over the array and find a free place. After all,
3469 how many scroll bars are we creating? Should be a small number.
3470 The check above guarantees we will find a free place. */
3471 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3473 if (! id_to_widget
.widgets
[i
])
3475 id_to_widget
.widgets
[i
] = w
;
3476 ++id_to_widget
.used
;
3482 /* Should never end up here */
3486 /* Remove pointer at IDX from id_to_widget.
3487 Called when scroll bar is destroyed. */
3490 xg_remove_widget_from_map (ptrdiff_t idx
)
3492 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3494 id_to_widget
.widgets
[idx
] = 0;
3495 --id_to_widget
.used
;
3499 /* Get the widget pointer at IDX from id_to_widget. */
3502 xg_get_widget_from_map (ptrdiff_t idx
)
3504 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3505 return id_to_widget
.widgets
[idx
];
3511 update_theme_scrollbar_width (void)
3514 GtkAdjustment
*vadj
;
3521 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3522 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3523 g_object_ref_sink (G_OBJECT (wscroll
));
3524 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3525 gtk_widget_destroy (wscroll
);
3526 g_object_unref (G_OBJECT (wscroll
));
3531 scroll_bar_width_for_theme
= w
;
3535 update_theme_scrollbar_height (void)
3538 GtkAdjustment
*hadj
;
3545 hadj
= gtk_adjustment_new (YG_SB_MIN
, YG_SB_MIN
, YG_SB_MAX
, 0.1, 0.1, 0.1);
3546 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL
, GTK_ADJUSTMENT (hadj
));
3547 g_object_ref_sink (G_OBJECT (wscroll
));
3548 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3549 gtk_widget_destroy (wscroll
);
3550 g_object_unref (G_OBJECT (wscroll
));
3553 scroll_bar_height_for_theme
= w
;
3557 xg_get_default_scrollbar_width (void)
3559 return scroll_bar_width_for_theme
;
3563 xg_get_default_scrollbar_height (void)
3565 /* Apparently there's no default height for themes. */
3566 return scroll_bar_width_for_theme
;
3569 /* Return the scrollbar id for X Window WID on display DPY.
3570 Return -1 if WID not in id_to_widget. */
3573 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3578 w
= xg_win_to_widget (dpy
, wid
);
3582 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3583 if (id_to_widget
.widgets
[idx
] == w
)
3590 /* Callback invoked when scroll bar WIDGET is destroyed.
3591 DATA is the index into id_to_widget for WIDGET.
3592 We free pointer to last scroll bar values here and remove the index. */
3595 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3597 intptr_t id
= (intptr_t) data
;
3598 xg_remove_widget_from_map (id
);
3601 /* Create a scroll bar widget for frame F. Store the scroll bar
3603 SCROLL_CALLBACK is the callback to invoke when the value of the
3605 END_CALLBACK is the callback to invoke when scrolling ends.
3606 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3607 to set resources for the widget. */
3610 xg_create_scroll_bar (struct frame
*f
,
3611 struct scroll_bar
*bar
,
3612 GCallback scroll_callback
,
3613 GCallback end_callback
,
3614 const char *scroll_bar_name
)
3620 GtkAdjustment
*vadj
;
3625 /* Page, step increment values are not so important here, they
3626 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3627 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3630 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3631 webox
= gtk_event_box_new ();
3632 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3634 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3636 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3638 scroll_id
= xg_store_widget_in_map (wscroll
);
3640 g_signal_connect (G_OBJECT (wscroll
),
3642 G_CALLBACK (xg_gtk_scroll_destroy
),
3643 (gpointer
) scroll_id
);
3644 g_signal_connect (G_OBJECT (wscroll
),
3648 g_signal_connect (G_OBJECT (wscroll
),
3649 "button-release-event",
3653 /* The scroll bar widget does not draw on a window of its own. Instead
3654 it draws on the parent window, in this case the edit widget. So
3655 whenever the edit widget is cleared, the scroll bar needs to redraw
3656 also, which causes flicker. Put an event box between the edit widget
3657 and the scroll bar, so the scroll bar instead draws itself on the
3658 event box window. */
3659 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3660 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3663 /* Set the cursor to an arrow. */
3664 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3666 bar
->x_window
= scroll_id
;
3667 bar
->horizontal
= 0;
3670 /* Create a horizontal scroll bar widget for frame F. Store the scroll
3671 bar in BAR. SCROLL_CALLBACK is the callback to invoke when the value
3672 of the bar changes. END_CALLBACK is the callback to invoke when
3673 scrolling ends. SCROLL_BAR_NAME is the name we use for the scroll
3674 bar. Can be used to set resources for the widget. */
3677 xg_create_horizontal_scroll_bar (struct frame
*f
,
3678 struct scroll_bar
*bar
,
3679 GCallback scroll_callback
,
3680 GCallback end_callback
,
3681 const char *scroll_bar_name
)
3687 GtkAdjustment
*hadj
;
3692 /* Page, step increment values are not so important here, they
3693 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3694 hadj
= gtk_adjustment_new (YG_SB_MIN
, YG_SB_MIN
, YG_SB_MAX
,
3697 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL
, GTK_ADJUSTMENT (hadj
));
3698 webox
= gtk_event_box_new ();
3699 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3701 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3703 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3705 scroll_id
= xg_store_widget_in_map (wscroll
);
3707 g_signal_connect (G_OBJECT (wscroll
),
3709 G_CALLBACK (xg_gtk_scroll_destroy
),
3710 (gpointer
) scroll_id
);
3711 g_signal_connect (G_OBJECT (wscroll
),
3715 g_signal_connect (G_OBJECT (wscroll
),
3716 "button-release-event",
3720 /* The scroll bar widget does not draw on a window of its own. Instead
3721 it draws on the parent window, in this case the edit widget. So
3722 whenever the edit widget is cleared, the scroll bar needs to redraw
3723 also, which causes flicker. Put an event box between the edit widget
3724 and the scroll bar, so the scroll bar instead draws itself on the
3725 event box window. */
3726 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3727 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3730 /* Set the cursor to an arrow. */
3731 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3733 bar
->x_window
= scroll_id
;
3734 bar
->horizontal
= 1;
3737 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3740 xg_remove_scroll_bar (struct frame
*f
, ptrdiff_t scrollbar_id
)
3742 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3745 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3746 gtk_widget_destroy (w
);
3747 gtk_widget_destroy (wparent
);
3748 SET_FRAME_GARBAGED (f
);
3752 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3754 TOP/LEFT are the new pixel positions where the bar shall appear.
3755 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3758 xg_update_scrollbar_pos (struct frame
*f
,
3759 ptrdiff_t scrollbar_id
,
3766 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3770 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3771 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3774 /* Clear out old position. */
3775 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3776 if (gtk_widget_get_parent (wparent
) == wfixed
)
3778 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3779 "x", &oldx
, "y", &oldy
, NULL
);
3780 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3783 /* Move and resize to new values. */
3784 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3785 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3788 /* No room. Hide scroll bar as some themes output a warning if
3789 the height is less than the min size. */
3790 gtk_widget_hide (wparent
);
3791 gtk_widget_hide (wscroll
);
3795 gtk_widget_show_all (wparent
);
3796 gtk_widget_set_size_request (wscroll
, width
, height
);
3799 gtk_widget_queue_draw (wfixed
);
3800 gdk_window_process_all_updates ();
3802 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3803 /* Clear under old scroll bar position. This must be done after
3804 the gtk_widget_queue_draw and gdk_window_process_all_updates
3807 oldx
, oldy
, oldw
, oldh
);
3809 /* GTK does not redraw until the main loop is entered again, but
3810 if there are no X events pending we will not enter it. So we sync
3811 here to get some events. */
3814 SET_FRAME_GARBAGED (f
);
3815 cancel_mouse_face (f
);
3820 /* Update the position of the horizontal scroll bar represented by SCROLLBAR_ID
3822 TOP/LEFT are the new pixel positions where the bar shall appear.
3823 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3826 xg_update_horizontal_scrollbar_pos (struct frame
*f
,
3827 ptrdiff_t scrollbar_id
,
3834 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3838 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3839 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3842 /* Clear out old position. */
3843 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3844 if (gtk_widget_get_parent (wparent
) == wfixed
)
3846 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3847 "x", &oldx
, "y", &oldy
, NULL
);
3848 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3851 /* Move and resize to new values. */
3852 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3853 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3856 /* No room. Hide scroll bar as some themes output a warning if
3857 the width is less than the min size. */
3858 gtk_widget_hide (wparent
);
3859 gtk_widget_hide (wscroll
);
3863 gtk_widget_show_all (wparent
);
3864 gtk_widget_set_size_request (wscroll
, width
, height
);
3866 gtk_widget_queue_draw (wfixed
);
3867 gdk_window_process_all_updates ();
3868 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3869 /* Clear under old scroll bar position. This must be done after
3870 the gtk_widget_queue_draw and gdk_window_process_all_updates
3873 oldx
, oldy
, oldw
, oldh
);
3875 /* GTK does not redraw until the main loop is entered again, but
3876 if there are no X events pending we will not enter it. So we sync
3877 here to get some events. */
3880 SET_FRAME_GARBAGED (f
);
3881 cancel_mouse_face (f
);
3886 /* Get the current value of the range, truncated to an integer. */
3889 int_gtk_range_get_value (GtkRange
*range
)
3891 return gtk_range_get_value (range
);
3895 /* Set the thumb size and position of scroll bar BAR. We are currently
3896 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3899 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3904 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3906 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3908 if (wscroll
&& bar
->dragging
== -1)
3918 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3920 if (scroll_bar_adjust_thumb_portion_p
)
3922 /* We do the same as for MOTIF in xterm.c, use 30 chars per
3923 line rather than the real portion value. This makes the
3924 thumb less likely to resize and that looks better. */
3925 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3927 /* When the thumb is at the bottom, position == whole.
3928 So we need to increase `whole' to make space for the thumb. */
3936 top
= (gdouble
) position
/ whole
;
3937 shown
= (gdouble
) portion
/ whole
;
3940 size
= clip_to_bounds (1, shown
* XG_SB_RANGE
, XG_SB_RANGE
);
3941 value
= clip_to_bounds (XG_SB_MIN
, top
* XG_SB_RANGE
, XG_SB_MAX
- size
);
3943 /* Assume all lines are of equal size. */
3944 new_step
= size
/ max (1, FRAME_LINES (f
));
3946 old_size
= gtk_adjustment_get_page_size (adj
);
3947 if (old_size
!= size
)
3949 int old_step
= gtk_adjustment_get_step_increment (adj
);
3950 if (old_step
!= new_step
)
3952 gtk_adjustment_set_page_size (adj
, size
);
3953 gtk_adjustment_set_step_increment (adj
, new_step
);
3954 /* Assume a page increment is about 95% of the page size */
3955 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3960 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3964 /* gtk_range_set_value invokes the callback. Set
3965 ignore_gtk_scrollbar to make the callback do nothing */
3966 xg_ignore_gtk_scrollbar
= 1;
3968 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3969 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3971 gtk_adjustment_changed (adj
);
3973 xg_ignore_gtk_scrollbar
= 0;
3980 /* Set the thumb size and position of horizontal scroll bar BAR. We are
3981 currently displaying PORTION out of a whole WHOLE, and our position
3984 xg_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
,
3989 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3991 if (wscroll
&& bar
->dragging
== -1)
3995 int upper
= max (whole
- 1, 0);
3996 int pagesize
= min (upper
, max (portion
, 0));
3997 int value
= max (0, min (position
, upper
- pagesize
));
3998 /* These should be set to something more <portion, whole>
4000 int page_increment
= 4;
4001 int step_increment
= 1;
4004 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
4005 gtk_adjustment_configure (adj
, (gdouble
) value
, (gdouble
) lower
,
4006 (gdouble
) upper
, (gdouble
) step_increment
,
4007 (gdouble
) page_increment
, (gdouble
) pagesize
);
4008 gtk_adjustment_changed (adj
);
4013 /* Return true if EVENT is for a scroll bar in frame F.
4014 When the same X window is used for several Gtk+ widgets, we cannot
4015 say for sure based on the X window alone if an event is for the
4016 frame. This function does additional checks. */
4019 xg_event_is_for_scrollbar (struct frame
*f
, const XEvent
*event
)
4023 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
4025 /* Check if press occurred outside the edit widget. */
4026 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
4029 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
4030 (gdk_display_get_device_manager (gdpy
));
4031 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
4033 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
4035 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
4038 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
4039 || event
->type
== MotionNotify
))
4041 /* If we are releasing or moving the scroll bar, it has the grab. */
4042 GtkWidget
*w
= gtk_grab_get_current ();
4043 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
4050 /***********************************************************************
4052 ***********************************************************************/
4054 static GtkPrintSettings
*print_settings
= NULL
;
4055 static GtkPageSetup
*page_setup
= NULL
;
4058 xg_page_setup_dialog (void)
4060 GtkPageSetup
*new_page_setup
= NULL
;
4062 if (print_settings
== NULL
)
4063 print_settings
= gtk_print_settings_new ();
4064 new_page_setup
= gtk_print_run_page_setup_dialog (NULL
, page_setup
,
4067 g_object_unref (page_setup
);
4068 page_setup
= new_page_setup
;
4072 xg_get_page_setup (void)
4074 Lisp_Object result
, orientation_symbol
;
4075 GtkPageOrientation orientation
;
4077 if (page_setup
== NULL
)
4078 page_setup
= gtk_page_setup_new ();
4079 result
= list4 (Fcons (Qleft_margin
,
4080 make_float (gtk_page_setup_get_left_margin (page_setup
,
4082 Fcons (Qright_margin
,
4083 make_float (gtk_page_setup_get_right_margin (page_setup
,
4086 make_float (gtk_page_setup_get_top_margin (page_setup
,
4088 Fcons (Qbottom_margin
,
4089 make_float (gtk_page_setup_get_bottom_margin (page_setup
,
4090 GTK_UNIT_POINTS
))));
4091 result
= Fcons (Fcons (Qheight
,
4092 make_float (gtk_page_setup_get_page_height (page_setup
,
4095 result
= Fcons (Fcons (Qwidth
,
4096 make_float (gtk_page_setup_get_page_width (page_setup
,
4099 orientation
= gtk_page_setup_get_orientation (page_setup
);
4100 if (orientation
== GTK_PAGE_ORIENTATION_PORTRAIT
)
4101 orientation_symbol
= Qportrait
;
4102 else if (orientation
== GTK_PAGE_ORIENTATION_LANDSCAPE
)
4103 orientation_symbol
= Qlandscape
;
4104 else if (orientation
== GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT
)
4105 orientation_symbol
= Qreverse_portrait
;
4106 else if (orientation
== GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE
)
4107 orientation_symbol
= Qreverse_landscape
;
4108 result
= Fcons (Fcons (Qorientation
, orientation_symbol
), result
);
4114 draw_page (GtkPrintOperation
*operation
, GtkPrintContext
*context
,
4115 gint page_nr
, gpointer user_data
)
4117 Lisp_Object frames
= *((Lisp_Object
*) user_data
);
4118 struct frame
*f
= XFRAME (Fnth (make_number (page_nr
), frames
));
4119 cairo_t
*cr
= gtk_print_context_get_cairo_context (context
);
4121 x_cr_draw_frame (cr
, f
);
4125 xg_print_frames_dialog (Lisp_Object frames
)
4127 GtkPrintOperation
*print
;
4128 GtkPrintOperationResult res
;
4130 print
= gtk_print_operation_new ();
4131 if (print_settings
!= NULL
)
4132 gtk_print_operation_set_print_settings (print
, print_settings
);
4133 if (page_setup
!= NULL
)
4134 gtk_print_operation_set_default_page_setup (print
, page_setup
);
4135 gtk_print_operation_set_n_pages (print
, XINT (Flength (frames
)));
4136 g_signal_connect (print
, "draw-page", G_CALLBACK (draw_page
), &frames
);
4137 res
= gtk_print_operation_run (print
, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG
,
4139 if (res
== GTK_PRINT_OPERATION_RESULT_APPLY
)
4141 if (print_settings
!= NULL
)
4142 g_object_unref (print_settings
);
4144 g_object_ref (gtk_print_operation_get_print_settings (print
));
4146 g_object_unref (print
);
4149 #endif /* USE_CAIRO */
4153 /***********************************************************************
4155 ***********************************************************************/
4156 /* The key for the data we put in the GtkImage widgets. The data is
4157 the image used by Emacs. We use this to see if we need to update
4158 the GtkImage with a new image. */
4159 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
4161 /* The key for storing the latest modifiers so the activate callback can
4163 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
4165 /* The key for the data we put in the GtkImage widgets. The data is
4166 the stock name used by Emacs. We use this to see if we need to update
4167 the GtkImage with a new image. */
4168 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
4170 /* As above, but this is used for named theme widgets, as opposed to
4172 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
4174 /* Callback function invoked when a tool bar item is pressed.
4175 W is the button widget in the tool bar that got pressed,
4176 CLIENT_DATA is an integer that is the index of the button in the
4177 tool bar. 0 is the first button. */
4180 xg_tool_bar_button_cb (GtkWidget
*widget
,
4181 GdkEventButton
*event
,
4184 intptr_t state
= event
->state
;
4185 gpointer ptr
= (gpointer
) state
;
4186 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
4191 /* Callback function invoked when a tool bar item is pressed.
4192 W is the button widget in the tool bar that got pressed,
4193 CLIENT_DATA is an integer that is the index of the button in the
4194 tool bar. 0 is the first button. */
4197 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
4199 intptr_t idx
= (intptr_t) client_data
;
4200 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
4201 intptr_t mod
= (intptr_t) gmod
;
4203 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4204 Lisp_Object key
, frame
;
4205 struct input_event event
;
4208 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4211 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4213 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
4214 XSETFRAME (frame
, f
);
4216 /* We generate two events here. The first one is to set the prefix
4217 to `(tool_bar)', see keyboard.c. */
4218 event
.kind
= TOOL_BAR_EVENT
;
4219 event
.frame_or_window
= frame
;
4221 kbd_buffer_store_event (&event
);
4223 event
.kind
= TOOL_BAR_EVENT
;
4224 event
.frame_or_window
= frame
;
4226 /* Convert between the modifier bits GDK uses and the modifier bits
4227 Emacs uses. This assumes GDK and X masks are the same, which they are when
4229 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), mod
);
4230 kbd_buffer_store_event (&event
);
4232 /* Return focus to the frame after we have clicked on a detached
4238 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
4240 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
4241 GtkWidget
*c1
= clist
->data
;
4242 GtkWidget
*c2
= clist
->next
? clist
->next
->data
: NULL
;
4244 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
4245 g_list_free (clist
);
4246 return GTK_IS_LABEL (c1
) ? c1
: c2
;
4250 /* This callback is called when the mouse enters or leaves a tool bar item.
4251 It is used for displaying and hiding the help text.
4252 W is the tool bar item, a button.
4253 EVENT is either an enter event or leave event.
4254 CLIENT_DATA is an integer that is the index of the button in the
4255 tool bar. 0 is the first button.
4257 Returns FALSE to tell GTK to keep processing this event. */
4260 xg_tool_bar_help_callback (GtkWidget
*w
,
4261 GdkEventCrossing
*event
,
4262 gpointer client_data
)
4264 intptr_t idx
= (intptr_t) client_data
;
4265 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4266 Lisp_Object help
, frame
;
4268 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4271 if (event
->type
== GDK_ENTER_NOTIFY
)
4273 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4274 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4277 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4282 XSETFRAME (frame
, f
);
4283 kbd_buffer_store_help_event (frame
, help
);
4289 /* This callback is called when a tool bar item shall be redrawn.
4290 It modifies the expose event so that the GtkImage widget redraws the
4291 whole image. This to overcome a bug that makes GtkImage draw the image
4292 in the wrong place when it tries to redraw just a part of the image.
4293 W is the GtkImage to be redrawn.
4294 EVENT is the expose event for W.
4295 CLIENT_DATA is unused.
4297 Returns FALSE to tell GTK to keep processing this event. */
4301 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4302 GdkEventExpose
*event
,
4303 gpointer client_data
)
4307 gdk_drawable_get_size (event
->window
, &width
, &height
);
4308 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4309 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4311 event
->area
.x
= max (0, event
->area
.x
);
4312 event
->area
.y
= max (0, event
->area
.y
);
4314 event
->area
.width
= max (width
, event
->area
.width
);
4315 event
->area
.height
= max (height
, event
->area
.height
);
4321 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4322 #define toolbar_set_orientation(w, o) \
4323 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4325 #define toolbar_set_orientation(w, o) \
4326 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4329 /* Attach a tool bar to frame F. */
4332 xg_pack_tool_bar (struct frame
*f
, Lisp_Object pos
)
4334 struct x_output
*x
= f
->output_data
.x
;
4335 bool into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4336 GtkWidget
*top_widget
= x
->toolbar_widget
;
4338 toolbar_set_orientation (x
->toolbar_widget
,
4340 ? GTK_ORIENTATION_VERTICAL
4341 : GTK_ORIENTATION_HORIZONTAL
);
4345 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), top_widget
,
4348 if (EQ (pos
, Qleft
))
4349 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4352 x
->toolbar_in_hbox
= true;
4356 bool vbox_pos
= x
->menubar_widget
!= 0;
4357 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), top_widget
,
4361 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4364 x
->toolbar_in_hbox
= false;
4366 x
->toolbar_is_packed
= true;
4369 static bool xg_update_tool_bar_sizes (struct frame
*f
);
4372 tb_size_cb (GtkWidget
*widget
,
4373 GdkRectangle
*allocation
,
4376 /* When tool bar is created it has one preferred size. But when size is
4377 allocated between widgets, it may get another. So we must update
4378 size hints if tool bar size changes. Seen on Fedora 18 at least. */
4379 struct frame
*f
= user_data
;
4381 if (xg_update_tool_bar_sizes (f
))
4383 frame_size_history_add (f
, Qtb_size_cb
, 0, 0, Qnil
);
4384 adjust_frame_size (f
, -1, -1, 5, 0, Qtool_bar_lines
);
4388 /* Create a tool bar for frame F. */
4391 xg_create_tool_bar (struct frame
*f
)
4393 struct x_output
*x
= f
->output_data
.x
;
4394 #if GTK_CHECK_VERSION (3, 3, 6)
4395 GtkStyleContext
*gsty
;
4397 struct xg_frame_tb_info
*tbinfo
4398 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4402 tbinfo
= xmalloc (sizeof (*tbinfo
));
4403 tbinfo
->last_tool_bar
= Qnil
;
4404 tbinfo
->style
= Qnil
;
4405 tbinfo
->hmargin
= tbinfo
->vmargin
= 0;
4406 tbinfo
->dir
= GTK_TEXT_DIR_NONE
;
4407 tbinfo
->n_last_items
= 0;
4408 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4413 x
->toolbar_widget
= gtk_toolbar_new ();
4415 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4417 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4418 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4419 g_signal_connect (x
->toolbar_widget
, "size-allocate",
4420 G_CALLBACK (tb_size_cb
), f
);
4421 #if GTK_CHECK_VERSION (3, 3, 6)
4422 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4423 gtk_style_context_add_class (gsty
, "primary-toolbar");
4428 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4430 /* Find the right-to-left image named by RTL in the tool bar images for F.
4431 Returns IMAGE if RTL is not found. */
4434 find_rtl_image (struct frame
*f
, Lisp_Object image
, Lisp_Object rtl
)
4437 Lisp_Object file
, rtl_name
;
4438 struct gcpro gcpro1
, gcpro2
;
4439 GCPRO2 (file
, rtl_name
);
4441 rtl_name
= Ffile_name_nondirectory (rtl
);
4443 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4445 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4446 if (!NILP (file
= file_for_image (rtl_image
)))
4448 file
= call1 (intern ("file-name-sans-extension"),
4449 Ffile_name_nondirectory (file
));
4450 if (! NILP (Fequal (file
, rtl_name
)))
4461 static GtkToolItem
*
4462 xg_make_tool_item (struct frame
*f
,
4464 GtkWidget
**wbutton
,
4466 int i
, bool horiz
, bool text_image
)
4468 GtkToolItem
*ti
= gtk_tool_item_new ();
4469 GtkWidget
*vb
= gtk_box_new (horiz
4470 ? GTK_ORIENTATION_HORIZONTAL
4471 : GTK_ORIENTATION_VERTICAL
,
4473 GtkWidget
*wb
= gtk_button_new ();
4474 /* The eventbox is here so we can have tooltips on disabled items. */
4475 GtkWidget
*weventbox
= gtk_event_box_new ();
4476 #if GTK_CHECK_VERSION (3, 3, 6)
4477 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4478 GtkStyleContext
*gsty
;
4480 gtk_css_provider_load_from_data (css_prov
,
4482 " background-color: transparent;"
4486 gsty
= gtk_widget_get_style_context (weventbox
);
4487 gtk_style_context_add_provider (gsty
,
4488 GTK_STYLE_PROVIDER (css_prov
),
4489 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4490 g_object_unref (css_prov
);
4493 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4495 if (wimage
&& !text_image
)
4496 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4498 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4499 if (wimage
&& text_image
)
4500 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4502 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4503 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4504 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4505 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4506 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4508 if (wimage
|| label
)
4511 gpointer gi
= (gpointer
) ii
;
4513 g_signal_connect (G_OBJECT (wb
), "clicked",
4514 G_CALLBACK (xg_tool_bar_callback
),
4517 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4520 /* Catch expose events to overcome an annoying redraw bug, see
4521 comment for xg_tool_bar_item_expose_callback. */
4522 g_signal_connect (G_OBJECT (ti
),
4524 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4527 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4529 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4530 no distinction based on modifiers in the activate callback,
4531 so we have to do it ourselves. */
4532 g_signal_connect (wb
, "button-release-event",
4533 G_CALLBACK (xg_tool_bar_button_cb
),
4536 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4538 /* Use enter/leave notify to show help. We use the events
4539 rather than the GtkButton specific signals "enter" and
4540 "leave", so we can have only one callback. The event
4541 will tell us what kind of event it is. */
4542 g_signal_connect (G_OBJECT (weventbox
),
4543 "enter-notify-event",
4544 G_CALLBACK (xg_tool_bar_help_callback
),
4546 g_signal_connect (G_OBJECT (weventbox
),
4547 "leave-notify-event",
4548 G_CALLBACK (xg_tool_bar_help_callback
),
4552 if (wbutton
) *wbutton
= wb
;
4558 is_box_type (GtkWidget
*vb
, bool is_horizontal
)
4562 if (GTK_IS_BOX (vb
))
4564 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4565 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4566 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4570 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4576 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4577 const char *icon_name
, const struct image
*img
,
4578 const char *label
, bool horiz
)
4582 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4583 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4585 /* Check if the tool icon matches. */
4586 if (stock_name
&& wimage
)
4588 old
= g_object_get_data (G_OBJECT (wimage
),
4589 XG_TOOL_BAR_STOCK_NAME
);
4590 if (!old
|| strcmp (old
, stock_name
))
4593 else if (icon_name
&& wimage
)
4595 old
= g_object_get_data (G_OBJECT (wimage
),
4596 XG_TOOL_BAR_ICON_NAME
);
4597 if (!old
|| strcmp (old
, icon_name
))
4602 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4603 XG_TOOL_BAR_IMAGE_DATA
);
4604 Pixmap old_img
= (Pixmap
) gold_img
;
4605 if (old_img
!= img
->pixmap
)
4609 /* Check button configuration and label. */
4610 if (is_box_type (vb
, horiz
)
4611 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4614 /* Ensure label is correct. */
4616 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4621 xg_update_tool_bar_sizes (struct frame
*f
)
4623 struct x_output
*x
= f
->output_data
.x
;
4625 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4626 GtkWidget
*top_widget
= x
->toolbar_widget
;
4628 gtk_widget_get_preferred_size (GTK_WIDGET (top_widget
), NULL
, &req
);
4629 if (x
->toolbar_in_hbox
)
4632 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4634 "position", &pos
, NULL
);
4635 if (pos
== 0) nl
= req
.width
;
4636 else nr
= req
.width
;
4641 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4643 "position", &pos
, NULL
);
4644 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4645 else nb
= req
.height
;
4648 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4649 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4650 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4651 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4653 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4654 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4655 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4656 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4657 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4658 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4667 find_icon_from_name (char *name
,
4668 GtkIconTheme
*icon_theme
,
4671 #if ! GTK_CHECK_VERSION (3, 10, 0)
4672 GtkStockItem stock_item
;
4675 if (name
[0] == 'n' && name
[1] == ':')
4677 *icon_name
= name
+ 2;
4680 if (! gtk_icon_theme_has_icon (icon_theme
, *icon_name
))
4684 #if ! GTK_CHECK_VERSION (3, 10, 0)
4685 else if (gtk_stock_lookup (name
, &stock_item
))
4688 else if (gtk_icon_theme_has_icon (icon_theme
, name
))
4703 /* Update the tool bar for frame F. Add new buttons and remove old. */
4706 update_frame_tool_bar (struct frame
*f
)
4709 struct x_output
*x
= f
->output_data
.x
;
4710 int hmargin
= 0, vmargin
= 0;
4711 GtkToolbar
*wtoolbar
;
4713 GtkTextDirection dir
;
4715 bool text_image
, horiz
;
4716 struct xg_frame_tb_info
*tbinfo
;
4718 GtkIconTheme
*icon_theme
;
4721 if (! FRAME_GTK_WIDGET (f
))
4726 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4728 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4729 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4731 else if (CONSP (Vtool_bar_button_margin
))
4733 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4734 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4736 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4737 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4740 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4741 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4742 i.e. zero. This means that margins less than
4743 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4744 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4745 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4747 if (! x
->toolbar_widget
)
4748 xg_create_tool_bar (f
);
4750 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4751 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4753 style
= Ftool_bar_get_system_style ();
4754 screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4755 icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4757 /* Are we up to date? */
4758 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4761 if (! NILP (tbinfo
->last_tool_bar
) && ! NILP (f
->tool_bar_items
)
4762 && tbinfo
->n_last_items
== f
->n_tool_bar_items
4763 && tbinfo
->hmargin
== hmargin
&& tbinfo
->vmargin
== vmargin
4764 && tbinfo
->dir
== dir
4765 && ! NILP (Fequal (tbinfo
->style
, style
))
4766 && ! NILP (Fequal (tbinfo
->last_tool_bar
, f
->tool_bar_items
)))
4772 tbinfo
->last_tool_bar
= f
->tool_bar_items
;
4773 tbinfo
->n_last_items
= f
->n_tool_bar_items
;
4774 tbinfo
->style
= style
;
4775 tbinfo
->hmargin
= hmargin
;
4776 tbinfo
->vmargin
= vmargin
;
4779 text_image
= EQ (style
, Qtext_image_horiz
);
4780 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4782 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4784 bool enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4785 bool selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4789 struct image
*img
= NULL
;
4791 Lisp_Object stock
= Qnil
;
4792 char *stock_name
= NULL
;
4793 char *icon_name
= NULL
;
4795 GtkWidget
*wbutton
= NULL
;
4796 Lisp_Object specified_file
;
4797 bool vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4799 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4800 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4801 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4804 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4806 /* If this is a separator, use a gtk separator item. */
4807 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4809 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4812 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4814 ti
= gtk_separator_tool_item_new ();
4815 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4821 /* Otherwise, the tool-bar item is an ordinary button. */
4823 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4825 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4829 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4831 /* Ignore invalid image specifications. */
4832 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4833 if (!valid_image_p (image
))
4836 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4841 specified_file
= file_for_image (image
);
4842 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4843 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4848 for (tem
= stock
; CONSP (tem
); tem
= XCDR (tem
))
4849 if (! NILP (tem
) && STRINGP (XCAR (tem
)))
4851 stock_name
= find_icon_from_name (SSDATA (XCAR (tem
)),
4854 if (stock_name
|| icon_name
) break;
4857 else if (STRINGP (stock
))
4859 stock_name
= find_icon_from_name (SSDATA (stock
),
4864 if (stock_name
|| icon_name
)
4865 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4867 if (stock_name
== NULL
&& icon_name
== NULL
)
4869 /* No stock image, or stock item not known. Try regular
4870 image. If image is a vector, choose it according to the
4872 if (dir
== GTK_TEXT_DIR_RTL
4873 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4875 image
= find_rtl_image (f
, image
, rtl
);
4877 if (VECTORP (image
))
4881 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4882 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4885 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4886 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4888 eassert (ASIZE (image
) >= idx
);
4889 image
= AREF (image
, idx
);
4894 img_id
= lookup_image (f
, image
);
4895 img
= IMAGE_FROM_ID (f
, img_id
);
4896 prepare_image_for_display (f
, img
);
4898 if (img
->load_failed_p
|| img
->pixmap
== None
)
4901 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4907 /* If there is an existing widget, check if it's stale; if so,
4908 remove it and make a new tool item from scratch. */
4909 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4912 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4921 /* Save the image so we can see if an update is needed the
4922 next time we call xg_tool_item_match_p. */
4923 if (EQ (style
, Qtext
))
4925 else if (stock_name
)
4928 #if GTK_CHECK_VERSION (3, 10, 0)
4929 w
= gtk_image_new_from_icon_name (stock_name
, icon_size
);
4931 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4933 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4934 (gpointer
) xstrdup (stock_name
),
4935 (GDestroyNotify
) xfree
);
4939 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4940 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4941 (gpointer
) xstrdup (icon_name
),
4942 (GDestroyNotify
) xfree
);
4946 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4947 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4948 (gpointer
)img
->pixmap
);
4951 #if GTK_CHECK_VERSION (3, 14, 0)
4954 gtk_widget_set_margin_start (w
, hmargin
);
4955 gtk_widget_set_margin_end (w
, hmargin
);
4956 gtk_widget_set_margin_top (w
, vmargin
);
4957 gtk_widget_set_margin_bottom (w
, vmargin
);
4960 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4962 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4963 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4968 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4972 /* Remove buttons not longer needed. */
4975 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4977 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4978 } while (ti
!= NULL
);
4980 if (f
->n_tool_bar_items
!= 0)
4982 if (! x
->toolbar_is_packed
)
4983 xg_pack_tool_bar (f
, FRAME_TOOL_BAR_POSITION (f
));
4984 gtk_widget_show_all (x
->toolbar_widget
);
4985 if (xg_update_tool_bar_sizes (f
))
4987 frame_size_history_add (f
, Qupdate_frame_tool_bar
, 0, 0, Qnil
);
4988 adjust_frame_size (f
, -1, -1, 2, 0, Qtool_bar_lines
);
4995 /* Deallocate all resources for the tool bar on frame F.
4996 Remove the tool bar. */
4999 free_frame_tool_bar (struct frame
*f
)
5001 struct x_output
*x
= f
->output_data
.x
;
5003 if (x
->toolbar_widget
)
5005 struct xg_frame_tb_info
*tbinfo
;
5006 GtkWidget
*top_widget
= x
->toolbar_widget
;
5009 if (x
->toolbar_is_packed
)
5011 if (x
->toolbar_in_hbox
)
5012 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
5015 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
5019 gtk_widget_destroy (x
->toolbar_widget
);
5021 x
->toolbar_widget
= 0;
5022 x
->toolbar_widget
= 0;
5023 x
->toolbar_is_packed
= false;
5024 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
5025 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
5027 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
5032 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
5037 frame_size_history_add (f
, Qfree_frame_tool_bar
, 0, 0, Qnil
);
5038 adjust_frame_size (f
, -1, -1, 2, 0, Qtool_bar_lines
);
5045 xg_change_toolbar_position (struct frame
*f
, Lisp_Object pos
)
5047 struct x_output
*x
= f
->output_data
.x
;
5048 GtkWidget
*top_widget
= x
->toolbar_widget
;
5050 if (! x
->toolbar_widget
|| ! top_widget
)
5054 g_object_ref (top_widget
);
5055 if (x
->toolbar_is_packed
)
5057 if (x
->toolbar_in_hbox
)
5058 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
5061 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
5065 xg_pack_tool_bar (f
, pos
);
5066 g_object_unref (top_widget
);
5068 if (xg_update_tool_bar_sizes (f
))
5070 frame_size_history_add (f
, Qxg_change_toolbar_position
, 0, 0, Qnil
);
5071 adjust_frame_size (f
, -1, -1, 2, 0, Qtool_bar_lines
);
5080 /***********************************************************************
5082 ***********************************************************************/
5084 xg_initialize (void)
5086 GtkBindingSet
*binding_set
;
5087 GtkSettings
*settings
;
5090 /* Work around a bug with corrupted data if libXft gets unloaded. This way
5091 we keep it permanently linked in. */
5096 xg_ignore_gtk_scrollbar
= 0;
5097 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
5098 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
5100 id_to_widget
.max_size
= id_to_widget
.used
= 0;
5101 id_to_widget
.widgets
= 0;
5103 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
5104 (gdk_display_get_default ()));
5105 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
5106 bindings. It doesn't seem to be any way to remove properties,
5107 so we set it to "" which in means "no key". */
5108 gtk_settings_set_string_property (settings
,
5109 "gtk-menu-bar-accel",
5113 /* Make GTK text input widgets use Emacs style keybindings. This is
5115 gtk_settings_set_string_property (settings
,
5116 "gtk-key-theme-name",
5120 /* Make dialogs close on C-g. Since file dialog inherits from
5121 dialog, this works for them also. */
5122 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
5123 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5126 /* Make menus close on C-g. */
5127 binding_set
= gtk_binding_set_by_class (g_type_class_ref
5128 (GTK_TYPE_MENU_SHELL
));
5129 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5131 update_theme_scrollbar_width ();
5132 update_theme_scrollbar_height ();
5134 #ifdef HAVE_FREETYPE
5135 x_last_font_name
= NULL
;
5139 #endif /* USE_GTK */