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
)))
385 char *encoded_file
= SSDATA (ENCODE_FILE (file
));
387 old_widget
= GTK_IMAGE (gtk_image_new_from_file (encoded_file
));
389 gtk_image_set_from_file (old_widget
, encoded_file
);
391 return GTK_WIDGET (old_widget
);
394 /* No file, do the image handling ourselves. This will look very bad
395 on a monochrome display, and sometimes bad on all displays with
398 /* This is a workaround to make icons look good on pseudo color
399 displays. Apparently GTK expects the images to have an alpha
400 channel. If they don't, insensitive and activated icons will
401 look bad. This workaround does not work on monochrome displays,
402 and is strictly not needed on true color/static color displays (i.e.
403 16 bits and higher). But we do it anyway so we get a pixbuf that is
404 not associated with the img->pixmap. The img->pixmap may be removed
405 by clearing the image cache and then the tool bar redraw fails, since
406 Gtk+ assumes the pixmap is always there. */
407 icon_buf
= xg_get_pixbuf_from_pix_and_mask (f
, img
->pixmap
, img
->mask
);
412 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
414 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
416 g_object_unref (G_OBJECT (icon_buf
));
419 return GTK_WIDGET (old_widget
);
423 /* Set CURSOR on W and all widgets W contain. We must do like this
424 for scroll bars and menu because they create widgets internally,
425 and it is those widgets that are visible. */
428 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
430 GdkWindow
*window
= gtk_widget_get_window (w
);
431 GList
*children
= gdk_window_peek_children (window
);
433 gdk_window_set_cursor (window
, cursor
);
435 /* The scroll bar widget has more than one GDK window (had to look at
436 the source to figure this out), and there is no way to set cursor
437 on widgets in GTK. So we must set the cursor for all GDK windows.
440 for ( ; children
; children
= g_list_next (children
))
441 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
444 /* Insert NODE into linked LIST. */
447 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
449 xg_list_node
*list_start
= list
->next
;
451 if (list_start
) list_start
->prev
= node
;
452 node
->next
= list_start
;
457 /* Remove NODE from linked LIST. */
460 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
462 xg_list_node
*list_start
= list
->next
;
463 if (node
== list_start
)
465 list
->next
= node
->next
;
466 if (list
->next
) list
->next
->prev
= 0;
470 node
->prev
->next
= node
->next
;
471 if (node
->next
) node
->next
->prev
= node
->prev
;
475 /* Allocate and return a utf8 version of STR. If STR is already
476 utf8 or NULL, just return a copy of STR.
477 A new string is allocated and the caller must free the result
481 get_utf8_string (const char *str
)
485 if (!str
) return NULL
;
487 /* If not UTF-8, try current locale. */
488 if (!g_utf8_validate (str
, -1, NULL
))
489 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
491 return g_strdup (str
);
495 /* Probably some control characters in str. Escape them. */
497 ptrdiff_t nr_bad
= 0;
500 unsigned char *p
= (unsigned char *)str
;
504 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
505 &bytes_written
, &err
))
506 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
509 p
+= bytes_written
+1;
522 if ((min (PTRDIFF_MAX
, SIZE_MAX
) - len
- 1) / 4 < nr_bad
)
523 memory_full (SIZE_MAX
);
524 up
= utf8_str
= xmalloc (len
+ nr_bad
* 4 + 1);
525 p
= (unsigned char *)str
;
527 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
528 &bytes_written
, &err
))
529 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
531 memcpy (up
, p
, bytes_written
);
533 up
+= sprintf (up
, "\\%03o", p
[bytes_written
]);
534 p
+= bytes_written
+ 1;
553 /* Check for special colors used in face spec for region face.
554 The colors are fetched from the Gtk+ theme.
555 Return true if color was found, false if not. */
558 xg_check_special_colors (struct frame
*f
,
559 const char *color_name
,
563 bool get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
564 bool get_fg
= !get_bg
&& strcmp ("gtk_selection_fg_color", color_name
) == 0;
566 if (! FRAME_GTK_WIDGET (f
) || ! (get_bg
|| get_fg
))
572 GtkStyleContext
*gsty
573 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f
));
575 char buf
[sizeof "rgb://rrrr/gggg/bbbb"];
576 int state
= GTK_STATE_FLAG_SELECTED
|GTK_STATE_FLAG_FOCUSED
;
578 gtk_style_context_get_color (gsty
, state
, &col
);
580 gtk_style_context_get_background_color (gsty
, state
, &col
);
582 sprintf (buf
, "rgb:%04x/%04x/%04x",
583 (unsigned) (col
.red
* 65535),
584 (unsigned) (col
.green
* 65535),
585 (unsigned) (col
.blue
* 65535));
586 success_p
= x_parse_color (f
, buf
, color
) != 0;
588 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
589 GdkColor
*grgb
= get_bg
590 ? &gsty
->bg
[GTK_STATE_SELECTED
]
591 : &gsty
->fg
[GTK_STATE_SELECTED
];
593 color
->red
= grgb
->red
;
594 color
->green
= grgb
->green
;
595 color
->blue
= grgb
->blue
;
596 color
->pixel
= grgb
->pixel
;
607 /***********************************************************************
609 ***********************************************************************/
610 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
611 We use that to pop down the tooltip. This happens if Gtk+ for some
612 reason wants to change or hide the tooltip. */
614 #ifdef USE_GTK_TOOLTIP
617 hierarchy_ch_cb (GtkWidget
*widget
,
618 GtkWidget
*previous_toplevel
,
621 struct frame
*f
= user_data
;
622 struct x_output
*x
= f
->output_data
.x
;
623 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
625 if (! top
|| ! GTK_IS_WINDOW (top
))
626 gtk_widget_hide (previous_toplevel
);
629 /* Callback called when Gtk+ thinks a tooltip should be displayed.
630 We use it to get the tooltip window and the tooltip widget so
631 we can manipulate the ourselves.
633 Return FALSE ensures that the tooltip is not shown. */
636 qttip_cb (GtkWidget
*widget
,
639 gboolean keyboard_mode
,
643 struct frame
*f
= user_data
;
644 struct x_output
*x
= f
->output_data
.x
;
645 if (x
->ttip_widget
== NULL
)
650 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
651 x
->ttip_widget
= tooltip
;
652 g_object_ref (G_OBJECT (tooltip
));
653 x
->ttip_lbl
= gtk_label_new ("");
654 g_object_ref (G_OBJECT (x
->ttip_lbl
));
655 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
656 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
658 /* Change stupid Gtk+ default line wrapping. */
659 p
= gtk_widget_get_parent (x
->ttip_lbl
);
660 list
= gtk_container_get_children (GTK_CONTAINER (p
));
661 for (iter
= list
; iter
; iter
= g_list_next (iter
))
663 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
664 if (GTK_IS_LABEL (w
))
665 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
669 /* ATK needs an empty title for some reason. */
670 gtk_window_set_title (x
->ttip_window
, "");
671 /* Realize so we can safely get screen later on. */
672 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
673 gtk_widget_realize (x
->ttip_lbl
);
675 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
676 G_CALLBACK (hierarchy_ch_cb
), f
);
681 #endif /* USE_GTK_TOOLTIP */
683 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
684 Return true if a system tooltip is available. */
687 xg_prepare_tooltip (struct frame
*f
,
692 #ifndef USE_GTK_TOOLTIP
695 struct x_output
*x
= f
->output_data
.x
;
699 GtkSettings
*settings
;
700 gboolean tt_enabled
= TRUE
;
702 Lisp_Object encoded_string
;
704 if (!x
->ttip_lbl
) return 0;
707 encoded_string
= ENCODE_UTF_8 (string
);
708 widget
= GTK_WIDGET (x
->ttip_lbl
);
709 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
710 screen
= gdk_window_get_screen (gwin
);
711 settings
= gtk_settings_get_for_screen (screen
);
712 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
715 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
716 /* Record that we disabled it so it can be enabled again. */
717 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
721 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
722 g_object_set_data (G_OBJECT
723 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
724 "gdk-display-current-tooltip", NULL
);
726 /* Put our dummy widget in so we can get callbacks for unrealize and
727 hierarchy-changed. */
728 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
729 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
730 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
731 if (width
) *width
= req
.width
;
732 if (height
) *height
= req
.height
;
737 #endif /* USE_GTK_TOOLTIP */
740 /* Show the tooltip at ROOT_X and ROOT_Y.
741 xg_prepare_tooltip must have been called before this function. */
744 xg_show_tooltip (struct frame
*f
, int root_x
, int root_y
)
746 #ifdef USE_GTK_TOOLTIP
747 struct x_output
*x
= f
->output_data
.x
;
751 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
752 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
758 /* Hide tooltip if shown. Do nothing if not shown.
759 Return true if tip was hidden, false if not (i.e. not using
763 xg_hide_tooltip (struct frame
*f
)
766 #ifdef USE_GTK_TOOLTIP
767 if (f
->output_data
.x
->ttip_window
)
769 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
771 gtk_widget_hide (GTK_WIDGET (win
));
773 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
775 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
776 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
777 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
778 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
789 /***********************************************************************
790 General functions for creating widgets, resizing, events, e.t.c.
791 ***********************************************************************/
794 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
795 const gchar
*msg
, gpointer user_data
)
797 if (!strstr (msg
, "visible children"))
798 fprintf (stderr
, "XX %s-WARNING **: %s\n", log_domain
, msg
);
801 /* Make a geometry string and pass that to GTK. It seems this is the
802 only way to get geometry position right if the user explicitly
803 asked for a position when starting Emacs.
804 F is the frame we shall set geometry for. */
807 xg_set_geometry (struct frame
*f
)
809 if (f
->size_hint_flags
& (USPosition
| PPosition
))
811 int left
= f
->left_pos
;
812 int xneg
= f
->size_hint_flags
& XNegative
;
813 int top
= f
->top_pos
;
814 int yneg
= f
->size_hint_flags
& YNegative
;
815 char geom_str
[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
823 sprintf (geom_str
, "=%dx%d%c%d%c%d",
824 FRAME_PIXEL_WIDTH (f
),
825 FRAME_PIXEL_HEIGHT (f
),
826 (xneg
? '-' : '+'), left
,
827 (yneg
? '-' : '+'), top
);
829 /* Silence warning about visible children. */
830 id
= g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
831 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
833 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
835 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
837 g_log_remove_handler ("Gtk", id
);
841 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
842 and use a GtkFixed widget, this doesn't happen automatically. */
845 xg_clear_under_internal_border (struct frame
*f
)
847 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
850 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
852 gtk_widget_queue_draw (wfixed
);
853 gdk_window_process_all_updates ();
855 x_clear_area (f
, 0, 0,
856 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
858 x_clear_area (f
, 0, 0,
859 FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
862 FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
863 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
866 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
867 0, FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
872 xg_get_gdk_scale (void)
874 const char *sscale
= getenv ("GDK_SCALE");
878 long scale
= atol (sscale
);
880 return min (scale
, INT_MAX
);
886 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
887 and a Gtk+ menu bar, we get resize events for the edit part of the
888 frame only. We let Gtk+ deal with the Gtk+ parts.
889 F is the frame to resize.
890 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
893 xg_frame_resized (struct frame
*f
, int pixelwidth
, int pixelheight
)
897 if (pixelwidth
== -1 && pixelheight
== -1)
899 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
900 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
901 0, 0, &pixelwidth
, &pixelheight
);
906 width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, pixelwidth
);
907 height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelheight
);
909 frame_size_history_add
910 (f
, Qxg_frame_resized
, width
, height
, Qnil
);
912 if (width
!= FRAME_TEXT_WIDTH (f
)
913 || height
!= FRAME_TEXT_HEIGHT (f
)
914 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
915 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
917 xg_clear_under_internal_border (f
);
918 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
919 SET_FRAME_GARBAGED (f
);
920 cancel_mouse_face (f
);
924 /* Resize the outer window of frame F after changing the height.
925 COLUMNS/ROWS is the size the edit area shall have after the resize. */
928 xg_frame_set_char_size (struct frame
*f
, int width
, int height
)
930 int pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
931 int pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
932 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
933 gint gwidth
, gheight
;
935 = pixelheight
+ FRAME_TOOLBAR_HEIGHT (f
) + FRAME_MENUBAR_HEIGHT (f
);
936 int totalwidth
= pixelwidth
+ FRAME_TOOLBAR_WIDTH (f
);
938 if (FRAME_PIXEL_HEIGHT (f
) == 0)
941 gtk_window_get_size (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
944 /* Do this before resize, as we don't know yet if we will be resized. */
945 xg_clear_under_internal_border (f
);
947 if (FRAME_VISIBLE_P (f
))
949 int scale
= xg_get_gdk_scale ();
950 totalheight
/= scale
;
954 /* Resize the top level widget so rows and columns remain constant.
956 When the frame is fullheight and we only want to change the width
957 or it is fullwidth and we only want to change the height we should
958 be able to preserve the fullscreen property. However, due to the
959 fact that we have to send a resize request anyway, the window
960 manager will abolish it. At least the respective size should
961 remain unchanged but giving the frame back its normal size will
963 if (EQ (fullscreen
, Qfullwidth
) && width
== FRAME_TEXT_WIDTH (f
))
965 frame_size_history_add
966 (f
, Qxg_frame_set_char_size_1
, width
, height
,
967 list2 (make_number (gheight
),
968 make_number (totalheight
)));
970 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
974 else if (EQ (fullscreen
, Qfullheight
) && height
== FRAME_TEXT_HEIGHT (f
))
976 frame_size_history_add
977 (f
, Qxg_frame_set_char_size_2
, width
, height
,
978 list2 (make_number (gwidth
),
979 make_number (totalwidth
)));
981 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
987 frame_size_history_add
988 (f
, Qxg_frame_set_char_size_3
, width
, height
,
989 list2 (make_number (totalwidth
),
990 make_number (totalheight
)));
992 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
998 SET_FRAME_GARBAGED (f
);
999 cancel_mouse_face (f
);
1001 x_wm_set_size_hint (f
, 0, 0);
1002 /* We can not call change_frame_size for a mapped frame,
1003 we can not set pixel width/height either. The window manager may
1004 override our resize request, XMonad does this all the time.
1005 The best we can do is try to sync, so lisp code sees the updated
1006 size as fast as possible.
1007 For unmapped windows, we can set rows/cols. When
1008 the frame is mapped again we will (hopefully) get the correct size. */
1009 if (FRAME_VISIBLE_P (f
))
1011 /* Must call this to flush out events */
1012 (void)gtk_events_pending ();
1014 x_wait_for_event (f
, ConfigureNotify
);
1016 if (!NILP (fullscreen
))
1017 /* Try to restore fullscreen state. */
1019 store_frame_param (f
, Qfullscreen
, fullscreen
);
1020 x_set_fullscreen (f
, fullscreen
, fullscreen
);
1024 adjust_frame_size (f
, width
, height
, 5, 0, Qxg_frame_set_char_size
);
1028 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
1029 The policy is to keep the number of editable lines. */
1033 xg_height_or_width_changed (struct frame
*f
)
1035 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1036 FRAME_TOTAL_PIXEL_WIDTH (f
),
1037 FRAME_TOTAL_PIXEL_HEIGHT (f
));
1038 f
->output_data
.x
->hint_flags
= 0;
1039 x_wm_set_size_hint (f
, 0, 0);
1043 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
1044 Must be done like this, because GtkWidget:s can have "hidden"
1045 X Window that aren't accessible.
1047 Return 0 if no widget match WDESC. */
1050 xg_win_to_widget (Display
*dpy
, Window wdesc
)
1053 GtkWidget
*gwdesc
= 0;
1057 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
1062 event
.any
.window
= gdkwin
;
1063 event
.any
.type
= GDK_NOTHING
;
1064 gwdesc
= gtk_get_event_widget (&event
);
1071 /* Set the background of widget W to PIXEL. */
1074 xg_set_widget_bg (struct frame
*f
, GtkWidget
*w
, unsigned long pixel
)
1080 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
1082 bg
.red
= (double)xbg
.red
/65535.0;
1083 bg
.green
= (double)xbg
.green
/65535.0;
1084 bg
.blue
= (double)xbg
.blue
/65535.0;
1086 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
1090 GdkColormap
*map
= gtk_widget_get_colormap (w
);
1091 gdk_colormap_query_color (map
, pixel
, &bg
);
1092 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
1096 /* Callback called when the gtk theme changes.
1097 We notify lisp code so it can fix faces used for region for example. */
1100 style_changed_cb (GObject
*go
,
1104 struct input_event event
;
1105 GdkDisplay
*gdpy
= user_data
;
1106 const char *display_name
= gdk_display_get_name (gdpy
);
1107 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1110 event
.kind
= CONFIG_CHANGED_EVENT
;
1111 event
.frame_or_window
= build_string (display_name
);
1112 /* Theme doesn't change often, so intern is called seldom. */
1113 event
.arg
= intern ("theme-name");
1114 kbd_buffer_store_event (&event
);
1116 update_theme_scrollbar_width ();
1117 update_theme_scrollbar_height ();
1119 /* If scroll bar width changed, we need set the new size on all frames
1123 Lisp_Object rest
, frame
;
1124 FOR_EACH_FRAME (rest
, frame
)
1126 struct frame
*f
= XFRAME (frame
);
1127 if (FRAME_LIVE_P (f
)
1129 && FRAME_X_DISPLAY (f
) == dpy
)
1131 x_set_scroll_bar_default_width (f
);
1132 x_set_scroll_bar_default_height (f
);
1133 xg_frame_set_char_size (f
, FRAME_TEXT_WIDTH (f
), FRAME_TEXT_HEIGHT (f
));
1139 /* Called when a delete-event occurs on WIDGET. */
1142 delete_cb (GtkWidget
*widget
,
1149 /* Create and set up the GTK widgets for frame F.
1150 Return true if creation succeeded. */
1153 xg_create_frame_widgets (struct frame
*f
)
1156 GtkWidget
*wvbox
, *whbox
;
1165 if (FRAME_X_EMBEDDED_P (f
))
1167 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1168 wtop
= gtk_plug_new_for_display (gdpy
, f
->output_data
.x
->parent_desc
);
1171 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1173 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1174 has backported it to Gtk+ 2.0 and they add the resize grip for
1175 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1176 forever, so disable the grip. */
1177 #if (! GTK_CHECK_VERSION (3, 0, 0) \
1178 && defined HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1179 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop
), FALSE
);
1182 xg_set_screen (wtop
, f
);
1184 wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1185 whbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1186 gtk_box_set_homogeneous (GTK_BOX (wvbox
), FALSE
);
1187 gtk_box_set_homogeneous (GTK_BOX (whbox
), FALSE
);
1190 wfixed
= emacs_fixed_new (f
);
1192 wfixed
= gtk_fixed_new ();
1195 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1197 if (wtop
) gtk_widget_destroy (wtop
);
1198 if (wvbox
) gtk_widget_destroy (wvbox
);
1199 if (whbox
) gtk_widget_destroy (whbox
);
1200 if (wfixed
) gtk_widget_destroy (wfixed
);
1206 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1207 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1208 gtk_widget_set_name (wvbox
, "pane");
1209 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1211 /* If this frame has a title or name, set it in the title bar. */
1212 if (! NILP (f
->title
))
1213 title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1214 else if (! NILP (f
->name
))
1215 title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1217 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1219 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1220 FRAME_GTK_WIDGET (f
) = wfixed
;
1221 f
->output_data
.x
->vbox_widget
= wvbox
;
1222 f
->output_data
.x
->hbox_widget
= whbox
;
1224 gtk_widget_set_has_window (wfixed
, TRUE
);
1226 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1227 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1228 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1230 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1231 update_frame_tool_bar (f
);
1233 /* We don't want this widget double buffered, because we draw on it
1234 with regular X drawing primitives, so from a GTK/GDK point of
1235 view, the widget is totally blank. When an expose comes, this
1236 will make the widget blank, and then Emacs redraws it. This flickers
1237 a lot, so we turn off double buffering. */
1238 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1240 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1241 SSDATA (Vx_resource_name
),
1242 SSDATA (Vx_resource_class
));
1244 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1245 GTK is to destroy the widget. We want Emacs to do that instead. */
1246 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1247 G_CALLBACK (delete_cb
), f
);
1249 /* Convert our geometry parameters into a geometry string
1251 GTK will itself handle calculating the real position this way. */
1252 xg_set_geometry (f
);
1254 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1256 gtk_widget_add_events (wfixed
,
1257 GDK_POINTER_MOTION_MASK
1259 | GDK_BUTTON_PRESS_MASK
1260 | GDK_BUTTON_RELEASE_MASK
1261 | GDK_KEY_PRESS_MASK
1262 | GDK_ENTER_NOTIFY_MASK
1263 | GDK_LEAVE_NOTIFY_MASK
1264 | GDK_FOCUS_CHANGE_MASK
1265 | GDK_STRUCTURE_MASK
1266 | GDK_VISIBILITY_NOTIFY_MASK
);
1268 /* Must realize the windows so the X window gets created. It is used
1269 by callers of this function. */
1270 gtk_widget_realize (wfixed
);
1271 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1273 /* Since GTK clears its window by filling with the background color,
1274 we must keep X and GTK background in sync. */
1275 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1278 /* Also, do not let any background pixmap to be set, this looks very
1279 bad as Emacs overwrites the background pixmap with its own idea
1280 of background color. */
1281 style
= gtk_widget_get_modifier_style (wfixed
);
1283 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1284 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1285 gtk_widget_modify_style (wfixed
, style
);
1287 gtk_widget_set_can_focus (wfixed
, TRUE
);
1288 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1291 #ifdef USE_GTK_TOOLTIP
1292 /* Steal a tool tip window we can move ourselves. */
1293 f
->output_data
.x
->ttip_widget
= 0;
1294 f
->output_data
.x
->ttip_lbl
= 0;
1295 f
->output_data
.x
->ttip_window
= 0;
1296 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1297 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1301 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1302 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1303 /* Only connect this signal once per screen. */
1304 if (! g_signal_handler_find (G_OBJECT (gs
),
1305 G_SIGNAL_MATCH_FUNC
,
1307 G_CALLBACK (style_changed_cb
),
1310 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1311 G_CALLBACK (style_changed_cb
),
1312 gdk_screen_get_display (screen
));
1322 xg_free_frame_widgets (struct frame
*f
)
1324 if (FRAME_GTK_OUTER_WIDGET (f
))
1326 #ifdef USE_GTK_TOOLTIP
1327 struct x_output
*x
= f
->output_data
.x
;
1329 struct xg_frame_tb_info
*tbinfo
1330 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
1335 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1336 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1337 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1338 #ifdef USE_GTK_TOOLTIP
1340 gtk_widget_destroy (x
->ttip_lbl
);
1342 g_object_unref (G_OBJECT (x
->ttip_widget
));
1347 /* Set the normal size hints for the window manager, for frame F.
1348 FLAGS is the flags word to use--or 0 meaning preserve the flags
1349 that the window now has.
1350 If USER_POSITION, set the User Position
1351 flag (this is useful when FLAGS is 0). */
1354 x_wm_set_size_hint (struct frame
*f
, long int flags
, bool user_position
)
1356 /* Must use GTK routines here, otherwise GTK resets the size hints
1357 to its own defaults. */
1358 GdkGeometry size_hints
;
1359 gint hint_flags
= 0;
1360 int base_width
, base_height
;
1361 int min_rows
= 0, min_cols
= 0;
1362 int win_gravity
= f
->win_gravity
;
1363 Lisp_Object fs_state
, frame
;
1364 int scale
= xg_get_gdk_scale ();
1366 /* Don't set size hints during initialization; that apparently leads
1367 to a race condition. See the thread at
1368 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1369 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1372 XSETFRAME (frame
, f
);
1373 fs_state
= Fframe_parameter (frame
, Qfullscreen
);
1374 if ((EQ (fs_state
, Qmaximized
) || EQ (fs_state
, Qfullboth
)) &&
1375 (x_wm_supports (f
, FRAME_DISPLAY_INFO (f
)->Xatom_net_wm_state
) ||
1376 x_wm_supports (f
, FRAME_DISPLAY_INFO (f
)->Xatom_net_wm_state_fullscreen
)))
1378 /* Don't set hints when maximized or fullscreen. Apparently KWin and
1379 Gtk3 don't get along and the frame shrinks (!).
1386 memset (&size_hints
, 0, sizeof (size_hints
));
1387 f
->output_data
.x
->size_hints
= size_hints
;
1388 f
->output_data
.x
->hint_flags
= hint_flags
;
1391 flags
= f
->size_hint_flags
;
1393 size_hints
= f
->output_data
.x
->size_hints
;
1394 hint_flags
= f
->output_data
.x
->hint_flags
;
1396 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1397 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
1398 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
1400 hint_flags
|= GDK_HINT_BASE_SIZE
;
1401 /* Use one row/col here so base_height/width does not become zero.
1402 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1403 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 1) + FRAME_TOOLBAR_WIDTH (f
);
1404 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 1)
1405 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1407 if (min_cols
> 0) --min_cols
; /* We used one col in base_width = ... 1); */
1408 if (min_rows
> 0) --min_rows
; /* We used one row in base_height = ... 1); */
1410 size_hints
.base_width
= base_width
;
1411 size_hints
.base_height
= base_height
;
1412 size_hints
.min_width
= base_width
+ min_cols
* FRAME_COLUMN_WIDTH (f
);
1413 size_hints
.min_height
= base_height
+ min_rows
* FRAME_LINE_HEIGHT (f
);
1415 /* These currently have a one to one mapping with the X values, but I
1416 don't think we should rely on that. */
1417 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1418 size_hints
.win_gravity
= 0;
1419 if (win_gravity
== NorthWestGravity
)
1420 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1421 else if (win_gravity
== NorthGravity
)
1422 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1423 else if (win_gravity
== NorthEastGravity
)
1424 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1425 else if (win_gravity
== WestGravity
)
1426 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1427 else if (win_gravity
== CenterGravity
)
1428 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1429 else if (win_gravity
== EastGravity
)
1430 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1431 else if (win_gravity
== SouthWestGravity
)
1432 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1433 else if (win_gravity
== SouthGravity
)
1434 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1435 else if (win_gravity
== SouthEastGravity
)
1436 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1437 else if (win_gravity
== StaticGravity
)
1438 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1442 hint_flags
&= ~GDK_HINT_POS
;
1443 hint_flags
|= GDK_HINT_USER_POS
;
1446 size_hints
.base_width
/= scale
;
1447 size_hints
.base_height
/= scale
;
1448 size_hints
.width_inc
/= scale
;
1449 size_hints
.height_inc
/= scale
;
1451 if (hint_flags
!= f
->output_data
.x
->hint_flags
1452 || memcmp (&size_hints
,
1453 &f
->output_data
.x
->size_hints
,
1454 sizeof (size_hints
)) != 0)
1457 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1458 NULL
, &size_hints
, hint_flags
);
1459 f
->output_data
.x
->size_hints
= size_hints
;
1460 f
->output_data
.x
->hint_flags
= hint_flags
;
1465 /* Change background color of a frame.
1466 Since GTK uses the background color to clear the window, we must
1467 keep the GTK and X colors in sync.
1468 F is the frame to change,
1469 BG is the pixel value to change to. */
1472 xg_set_background_color (struct frame
*f
, unsigned long bg
)
1474 if (FRAME_GTK_WIDGET (f
))
1477 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1483 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1484 functions so GTK does not overwrite the icon. */
1487 xg_set_frame_icon (struct frame
*f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1489 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1493 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1498 /***********************************************************************
1500 ***********************************************************************/
1501 /* Return the dialog title to use for a dialog of type KEY.
1502 This is the encoding used by lwlib. We use the same for GTK. */
1505 get_dialog_title (char key
)
1507 const char *title
= "";
1515 title
= "Information";
1534 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1535 the dialog, but return TRUE so the event does not propagate further
1536 in GTK. This prevents GTK from destroying the dialog widget automatically
1537 and we can always destroy the widget manually, regardless of how
1538 it was popped down (button press or WM_DELETE_WINDOW).
1539 W is the dialog widget.
1540 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1541 user_data is NULL (not used).
1543 Returns TRUE to end propagation of event. */
1546 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1548 gtk_widget_unmap (w
);
1552 /* Create a popup dialog window. See also xg_create_widget below.
1553 WV is a widget_value describing the dialog.
1554 SELECT_CB is the callback to use when a button has been pressed.
1555 DEACTIVATE_CB is the callback to use when the dialog pops down.
1557 Returns the GTK dialog widget. */
1560 create_dialog (widget_value
*wv
,
1561 GCallback select_cb
,
1562 GCallback deactivate_cb
)
1564 const char *title
= get_dialog_title (wv
->name
[0]);
1565 int total_buttons
= wv
->name
[1] - '0';
1566 int right_buttons
= wv
->name
[4] - '0';
1569 int button_spacing
= 10;
1570 GtkWidget
*wdialog
= gtk_dialog_new ();
1571 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1573 GtkWidget
*whbox_down
;
1575 /* If the number of buttons is greater than 4, make two rows of buttons
1576 instead. This looks better. */
1577 bool make_two_rows
= total_buttons
> 4;
1579 #if GTK_CHECK_VERSION (3, 12, 0)
1580 GtkBuilder
*gbld
= gtk_builder_new ();
1581 GObject
*go
= gtk_buildable_get_internal_child (GTK_BUILDABLE (wd
),
1584 GtkBox
*cur_box
= GTK_BOX (go
);
1585 g_object_unref (G_OBJECT (gbld
));
1587 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1590 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1591 left_buttons
= total_buttons
- right_buttons
;
1593 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1594 gtk_widget_set_name (wdialog
, "emacs-dialog");
1599 GtkWidget
*wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, button_spacing
);
1600 GtkWidget
*whbox_up
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1601 gtk_box_set_homogeneous (GTK_BOX (wvbox
), TRUE
);
1602 gtk_box_set_homogeneous (GTK_BOX (whbox_up
), FALSE
);
1603 whbox_down
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1604 gtk_box_set_homogeneous (GTK_BOX (whbox_down
), FALSE
);
1606 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1607 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1608 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1610 cur_box
= GTK_BOX (whbox_up
);
1613 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1614 G_CALLBACK (dialog_delete_callback
), 0);
1618 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1619 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1622 for (item
= wv
->contents
; item
; item
= item
->next
)
1624 char *utf8_label
= get_utf8_string (item
->value
);
1628 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1630 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1631 /* This is the text part of the dialog. */
1632 w
= gtk_label_new (utf8_label
);
1633 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1634 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1635 #if GTK_CHECK_VERSION (3, 14, 0)
1636 gtk_widget_set_halign (w
, GTK_ALIGN_START
);
1637 gtk_widget_set_valign (w
, GTK_ALIGN_CENTER
);
1639 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1641 /* Try to make dialog look better. Must realize first so
1642 the widget can calculate the size it needs. */
1643 gtk_widget_realize (w
);
1644 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1645 gtk_box_set_spacing (wvbox
, req
.height
);
1646 if (item
->value
&& strlen (item
->value
) > 0)
1647 button_spacing
= 2*req
.width
/strlen (item
->value
);
1648 if (button_spacing
< 10) button_spacing
= 10;
1652 /* This is one button to add to the dialog. */
1653 w
= gtk_button_new_with_label (utf8_label
);
1654 if (! item
->enabled
)
1655 gtk_widget_set_sensitive (w
, FALSE
);
1657 g_signal_connect (G_OBJECT (w
), "clicked",
1658 select_cb
, item
->call_data
);
1660 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1661 if (++button_nr
== left_buttons
)
1664 cur_box
= GTK_BOX (whbox_down
);
1669 g_free (utf8_label
);
1675 struct xg_dialog_data
1683 /* Function that is called when the file or font dialogs pop down.
1684 W is the dialog widget, RESPONSE is the response code.
1685 USER_DATA is what we passed in to g_signal_connect. */
1688 xg_dialog_response_cb (GtkDialog
*w
,
1692 struct xg_dialog_data
*dd
= user_data
;
1693 dd
->response
= response
;
1694 g_main_loop_quit (dd
->loop
);
1698 /* Destroy the dialog. This makes it pop down. */
1701 pop_down_dialog (void *arg
)
1703 struct xg_dialog_data
*dd
= arg
;
1706 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1707 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1709 g_main_loop_quit (dd
->loop
);
1710 g_main_loop_unref (dd
->loop
);
1715 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1716 We pass in DATA as gpointer* so we can use this as a callback. */
1719 xg_maybe_add_timer (gpointer data
)
1721 struct xg_dialog_data
*dd
= data
;
1722 struct timespec next_time
= timer_check ();
1726 if (timespec_valid_p (next_time
))
1728 time_t s
= next_time
.tv_sec
;
1729 int per_ms
= TIMESPEC_RESOLUTION
/ 1000;
1730 int ms
= (next_time
.tv_nsec
+ per_ms
- 1) / per_ms
;
1731 if (s
<= ((guint
) -1 - ms
) / 1000)
1732 dd
->timerid
= g_timeout_add (s
* 1000 + ms
, xg_maybe_add_timer
, dd
);
1738 /* Pops up a modal dialog W and waits for response.
1739 We don't use gtk_dialog_run because we want to process emacs timers.
1740 The dialog W is not destroyed when this function returns. */
1743 xg_dialog_run (struct frame
*f
, GtkWidget
*w
)
1745 ptrdiff_t count
= SPECPDL_INDEX ();
1746 struct xg_dialog_data dd
;
1748 xg_set_screen (w
, f
);
1749 gtk_window_set_transient_for (GTK_WINDOW (w
),
1750 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1751 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1752 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1754 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1755 dd
.response
= GTK_RESPONSE_CANCEL
;
1759 g_signal_connect (G_OBJECT (w
),
1761 G_CALLBACK (xg_dialog_response_cb
),
1763 /* Don't destroy the widget if closed by the window manager close button. */
1764 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1765 gtk_widget_show (w
);
1767 record_unwind_protect_ptr (pop_down_dialog
, &dd
);
1769 (void) xg_maybe_add_timer (&dd
);
1770 g_main_loop_run (dd
.loop
);
1773 unbind_to (count
, Qnil
);
1779 /***********************************************************************
1780 File dialog functions
1781 ***********************************************************************/
1782 /* Return true if the old file selection dialog is being used. */
1785 xg_uses_old_file_dialog (void)
1787 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1788 return x_gtk_use_old_file_dialog
;
1795 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1797 /* Return the selected file for file chooser dialog W.
1798 The returned string must be free:d. */
1801 xg_get_file_name_from_chooser (GtkWidget
*w
)
1803 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1806 /* Callback called when the "Show hidden files" toggle is pressed.
1807 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1810 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1812 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1814 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1815 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1819 /* Callback called when a property changes in a file chooser.
1820 GOBJECT is the file chooser dialog, ARG1 describes the property.
1821 USER_DATA is the toggle widget in the file chooser dialog.
1822 We use this to update the "Show hidden files" toggle when the user
1823 changes that property by right clicking in the file list. */
1826 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1828 if (strcmp (arg1
->name
, "show-hidden") == 0)
1830 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1831 gboolean visible
, toggle_on
;
1833 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1834 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1836 if (!!visible
!= !!toggle_on
)
1838 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1839 G_CALLBACK (xg_toggle_visibility_cb
),
1841 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1842 g_signal_handlers_unblock_by_func
1843 (G_OBJECT (wtoggle
),
1844 G_CALLBACK (xg_toggle_visibility_cb
),
1847 x_gtk_show_hidden_files
= visible
;
1851 /* Read a file name from the user using a file chooser dialog.
1852 F is the current frame.
1853 PROMPT is a prompt to show to the user. May not be NULL.
1854 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1855 If MUSTMATCH_P, the returned file name must be an existing
1856 file. (Actually, this only has cosmetic effects, the user can
1857 still enter a non-existing file.) *FUNC is set to a function that
1858 can be used to retrieve the selected file name from the returned widget.
1860 Returns the created widget. */
1863 xg_get_file_with_chooser (struct frame
*f
,
1865 char *default_filename
,
1866 bool mustmatch_p
, bool only_dir_p
,
1867 xg_get_file_func
*func
)
1871 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1872 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1873 GtkFileChooserAction action
= (mustmatch_p
?
1874 GTK_FILE_CHOOSER_ACTION_OPEN
:
1875 GTK_FILE_CHOOSER_ACTION_SAVE
);
1878 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1880 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1881 XG_TEXT_CANCEL
, GTK_RESPONSE_CANCEL
,
1882 (mustmatch_p
|| only_dir_p
?
1883 XG_TEXT_OPEN
: XG_TEXT_OK
),
1886 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1888 wbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1889 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
1890 gtk_widget_show (wbox
);
1891 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1893 if (x_gtk_show_hidden_files
)
1895 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1896 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1898 gtk_widget_show (wtoggle
);
1899 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1900 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1901 g_signal_connect (G_OBJECT (filewin
), "notify",
1902 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1904 if (x_gtk_file_dialog_help_text
)
1907 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1908 Show the C-l help text only for versions < 2.10. */
1909 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1910 z
= stpcpy (z
, "\nType C-l to display a file name text entry box.\n");
1911 strcpy (z
, "\nIf you don't like this file selector, use the "
1912 "corresponding\nkey binding or customize "
1913 "use-file-dialog to turn it off.");
1915 wmessage
= gtk_label_new (msgbuf
);
1916 gtk_widget_show (wmessage
);
1919 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1920 if (x_gtk_file_dialog_help_text
)
1921 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1922 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1924 if (default_filename
)
1927 char *utf8_filename
;
1929 file
= build_string (default_filename
);
1931 /* File chooser does not understand ~/... in the file name. It must be
1932 an absolute name starting with /. */
1933 if (default_filename
[0] != '/')
1934 file
= Fexpand_file_name (file
, Qnil
);
1936 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1937 if (! NILP (Ffile_directory_p (file
)))
1938 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1942 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1944 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1946 char *cp
= strrchr (utf8_filename
, '/');
1948 else cp
= utf8_filename
;
1949 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1954 *func
= xg_get_file_name_from_chooser
;
1958 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1960 /* Return the selected file for file selector dialog W.
1961 The returned string must be free:d. */
1964 xg_get_file_name_from_selector (GtkWidget
*w
)
1966 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1967 return xstrdup (gtk_file_selection_get_filename (filesel
));
1970 /* Create a file selection dialog.
1971 F is the current frame.
1972 PROMPT is a prompt to show to the user. May not be NULL.
1973 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1974 If MUSTMATCH_P, the returned file name must be an existing
1975 file. *FUNC is set to a function that can be used to retrieve the
1976 selected file name from the returned widget.
1978 Returns the created widget. */
1981 xg_get_file_with_selection (struct frame
*f
,
1983 char *default_filename
,
1984 bool mustmatch_p
, bool only_dir_p
,
1985 xg_get_file_func
*func
)
1988 GtkFileSelection
*filesel
;
1990 filewin
= gtk_file_selection_new (prompt
);
1991 filesel
= GTK_FILE_SELECTION (filewin
);
1993 if (default_filename
)
1994 gtk_file_selection_set_filename (filesel
, default_filename
);
1998 /* The selection_entry part of filesel is not documented. */
1999 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
2000 gtk_file_selection_hide_fileop_buttons (filesel
);
2003 *func
= xg_get_file_name_from_selector
;
2007 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
2009 /* Read a file name from the user using a file dialog, either the old
2010 file selection dialog, or the new file chooser dialog. Which to use
2011 depends on what the GTK version used has, and what the value of
2012 gtk-use-old-file-dialog.
2013 F is the current frame.
2014 PROMPT is a prompt to show to the user. May not be NULL.
2015 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
2016 If MUSTMATCH_P, the returned file name must be an existing
2019 Returns a file name or NULL if no file was selected.
2020 The returned string must be freed by the caller. */
2023 xg_get_file_name (struct frame
*f
,
2025 char *default_filename
,
2031 int filesel_done
= 0;
2032 xg_get_file_func func
;
2034 #ifdef HAVE_GTK_FILE_SELECTION_NEW
2036 if (xg_uses_old_file_dialog ())
2037 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
2038 mustmatch_p
, only_dir_p
, &func
);
2040 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
2041 mustmatch_p
, only_dir_p
, &func
);
2043 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
2044 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
2045 mustmatch_p
, only_dir_p
, &func
);
2046 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
2048 gtk_widget_set_name (w
, "emacs-filedialog");
2050 filesel_done
= xg_dialog_run (f
, w
);
2051 if (filesel_done
== GTK_RESPONSE_OK
)
2054 gtk_widget_destroy (w
);
2058 /***********************************************************************
2060 ***********************************************************************/
2062 #ifdef HAVE_FREETYPE
2064 #if USE_NEW_GTK_FONT_CHOOSER
2066 #define XG_WEIGHT_TO_SYMBOL(w) \
2067 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
2068 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
2069 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
2070 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
2071 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
2072 : w <= PANGO_WEIGHT_BOLD ? Qbold \
2073 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
2076 #define XG_STYLE_TO_SYMBOL(s) \
2077 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
2078 : s == PANGO_STYLE_ITALIC ? Qitalic \
2081 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2084 static char *x_last_font_name
;
2086 /* Pop up a GTK font selector and return the name of the font the user
2087 selects, as a C string. The returned font name follows GTK's own
2090 `FAMILY [VALUE1 VALUE2] SIZE'
2092 This can be parsed using font_parse_fcname in font.c.
2093 DEFAULT_NAME, if non-zero, is the default font name. */
2096 xg_get_font (struct frame
*f
, const char *default_name
)
2100 Lisp_Object font
= Qnil
;
2102 w
= gtk_font_chooser_dialog_new
2103 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2107 /* Convert fontconfig names to Gtk names, i.e. remove - before
2109 char *p
= strrchr (default_name
, '-');
2113 while (c_isdigit (*ep
))
2115 if (*ep
== '\0') *p
= ' ';
2118 else if (x_last_font_name
)
2119 default_name
= x_last_font_name
;
2122 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w
), default_name
);
2124 gtk_widget_set_name (w
, "emacs-fontdialog");
2125 done
= xg_dialog_run (f
, w
);
2126 if (done
== GTK_RESPONSE_OK
)
2128 #if USE_NEW_GTK_FONT_CHOOSER
2129 /* Use the GTK3 font chooser. */
2130 PangoFontDescription
*desc
2131 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w
));
2135 const char *name
= pango_font_description_get_family (desc
);
2136 gint size
= pango_font_description_get_size (desc
);
2137 PangoWeight weight
= pango_font_description_get_weight (desc
);
2138 PangoStyle style
= pango_font_description_get_style (desc
);
2141 #define FONT_TYPE_WANTED (Qftcr)
2143 #define FONT_TYPE_WANTED (Qxft)
2145 font
= CALLN (Ffont_spec
,
2146 QCname
, build_string (name
),
2147 QCsize
, make_float (pango_units_to_double (size
)),
2148 QCweight
, XG_WEIGHT_TO_SYMBOL (weight
),
2149 QCslant
, XG_STYLE_TO_SYMBOL (style
),
2153 pango_font_description_free (desc
);
2154 dupstring (&x_last_font_name
, name
);
2157 #else /* Use old font selector, which just returns the font name. */
2160 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w
));
2164 font
= build_string (font_name
);
2165 g_free (x_last_font_name
);
2166 x_last_font_name
= font_name
;
2168 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2171 gtk_widget_destroy (w
);
2174 #endif /* HAVE_FREETYPE */
2178 /***********************************************************************
2180 ***********************************************************************/
2182 /* The name of menu items that can be used for customization. Since GTK
2183 RC files are very crude and primitive, we have to set this on all
2184 menu item names so a user can easily customize menu items. */
2186 #define MENU_ITEM_NAME "emacs-menuitem"
2189 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2190 during GC. The next member points to the items. */
2191 static xg_list_node xg_menu_cb_list
;
2193 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2194 during GC. The next member points to the items. */
2195 static xg_list_node xg_menu_item_cb_list
;
2197 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2198 F is the frame CL_DATA will be initialized for.
2199 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2201 The menu bar and all sub menus under the menu bar in a frame
2202 share the same structure, hence the reference count.
2204 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2205 allocated xg_menu_cb_data if CL_DATA is NULL. */
2207 static xg_menu_cb_data
*
2208 make_cl_data (xg_menu_cb_data
*cl_data
, struct frame
*f
, GCallback highlight_cb
)
2212 cl_data
= xmalloc (sizeof *cl_data
);
2214 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2215 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2216 cl_data
->highlight_cb
= highlight_cb
;
2217 cl_data
->ref_count
= 0;
2219 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2222 cl_data
->ref_count
++;
2227 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2228 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2230 When the menu bar is updated, menu items may have been added and/or
2231 removed, so menu_bar_vector and menu_bar_items_used change. We must
2232 then update CL_DATA since it is used to determine which menu
2233 item that is invoked in the menu.
2234 HIGHLIGHT_CB could change, there is no check that the same
2235 function is given when modifying a menu bar as was given when
2236 creating the menu bar. */
2239 update_cl_data (xg_menu_cb_data
*cl_data
,
2241 GCallback highlight_cb
)
2246 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2247 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2248 cl_data
->highlight_cb
= highlight_cb
;
2252 /* Decrease reference count for CL_DATA.
2253 If reference count is zero, free CL_DATA. */
2256 unref_cl_data (xg_menu_cb_data
*cl_data
)
2258 if (cl_data
&& cl_data
->ref_count
> 0)
2260 cl_data
->ref_count
--;
2261 if (cl_data
->ref_count
== 0)
2263 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2269 /* Function that marks all lisp data during GC. */
2275 Lisp_Object rest
, frame
;
2277 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2278 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2280 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2282 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2284 if (! NILP (cb_data
->help
))
2285 mark_object (cb_data
->help
);
2288 FOR_EACH_FRAME (rest
, frame
)
2290 struct frame
*f
= XFRAME (frame
);
2292 if (FRAME_X_P (f
) && FRAME_GTK_OUTER_WIDGET (f
))
2294 struct xg_frame_tb_info
*tbinfo
2295 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
2299 mark_object (tbinfo
->last_tool_bar
);
2300 mark_object (tbinfo
->style
);
2307 /* Callback called when a menu item is destroyed. Used to free data.
2308 W is the widget that is being destroyed (not used).
2309 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2312 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2316 xg_menu_item_cb_data
*data
= client_data
;
2317 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2322 /* Callback called when the pointer enters/leaves a menu item.
2323 W is the parent of the menu item.
2324 EVENT is either an enter event or leave event.
2325 CLIENT_DATA is not used.
2327 Returns FALSE to tell GTK to keep processing this event. */
2330 menuitem_highlight_callback (GtkWidget
*w
,
2331 GdkEventCrossing
*event
,
2332 gpointer client_data
)
2335 GtkWidget
*subwidget
;
2336 xg_menu_item_cb_data
*data
;
2338 ev
.crossing
= *event
;
2339 subwidget
= gtk_get_event_widget (&ev
);
2340 data
= g_object_get_data (G_OBJECT (subwidget
), XG_ITEM_DATA
);
2343 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2345 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2346 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2347 (*func
) (subwidget
, call_data
);
2354 /* Callback called when a menu is destroyed. Used to free data.
2355 W is the widget that is being destroyed (not used).
2356 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2359 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2361 unref_cl_data (client_data
);
2364 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2365 must be non-NULL) and can be inserted into a menu item.
2367 Returns the GtkHBox. */
2370 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2376 wbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
2377 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
2378 wlbl
= gtk_label_new (utf8_label
);
2379 wkey
= gtk_label_new (utf8_key
);
2381 #if GTK_CHECK_VERSION (3, 14, 0)
2382 gtk_widget_set_halign (wlbl
, GTK_ALIGN_START
);
2383 gtk_widget_set_valign (wlbl
, GTK_ALIGN_CENTER
);
2384 gtk_widget_set_halign (wkey
, GTK_ALIGN_START
);
2385 gtk_widget_set_valign (wkey
, GTK_ALIGN_CENTER
);
2387 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2388 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2390 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2391 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2393 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2394 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2395 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2400 /* Make and return a menu item widget with the key to the right.
2401 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2402 UTF8_KEY is the text representing the key binding.
2403 ITEM is the widget_value describing the menu item.
2405 GROUP is an in/out parameter. If the menu item to be created is not
2406 part of any radio menu group, *GROUP contains NULL on entry and exit.
2407 If the menu item to be created is part of a radio menu group, on entry
2408 *GROUP contains the group to use, or NULL if this is the first item
2409 in the group. On exit, *GROUP contains the radio item group.
2411 Unfortunately, keys don't line up as nicely as in Motif,
2412 but the MacOS X version doesn't either, so I guess that is OK. */
2415 make_menu_item (const char *utf8_label
,
2416 const char *utf8_key
,
2421 GtkWidget
*wtoadd
= 0;
2423 /* It has been observed that some menu items have a NULL name field.
2424 This will lead to this function being called with a NULL utf8_label.
2425 GTK crashes on that so we set a blank label. Why there is a NULL
2426 name remains to be investigated. */
2427 if (! utf8_label
) utf8_label
= " ";
2430 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2432 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2435 if (utf8_key
) w
= gtk_check_menu_item_new ();
2436 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2437 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2439 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2441 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2442 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2443 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2445 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2450 if (utf8_key
) w
= gtk_menu_item_new ();
2451 else w
= gtk_menu_item_new_with_label (utf8_label
);
2454 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2455 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2460 /* Create a menu item widget, and connect the callbacks.
2461 ITEM describes the menu item.
2462 F is the frame the created menu belongs to.
2463 SELECT_CB is the callback to use when a menu item is selected.
2464 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2465 CL_DATA points to the callback data to be used for this menu.
2466 GROUP is an in/out parameter. If the menu item to be created is not
2467 part of any radio menu group, *GROUP contains NULL on entry and exit.
2468 If the menu item to be created is part of a radio menu group, on entry
2469 *GROUP contains the group to use, or NULL if this is the first item
2470 in the group. On exit, *GROUP contains the radio item group.
2472 Returns the created GtkWidget. */
2475 xg_create_one_menuitem (widget_value
*item
,
2477 GCallback select_cb
,
2478 GCallback highlight_cb
,
2479 xg_menu_cb_data
*cl_data
,
2485 xg_menu_item_cb_data
*cb_data
;
2487 utf8_label
= get_utf8_string (item
->name
);
2488 utf8_key
= get_utf8_string (item
->key
);
2490 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2492 if (utf8_label
) g_free (utf8_label
);
2493 if (utf8_key
) g_free (utf8_key
);
2495 cb_data
= xmalloc (sizeof *cb_data
);
2497 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2499 cb_data
->select_id
= 0;
2500 cb_data
->help
= item
->help
;
2501 cb_data
->cl_data
= cl_data
;
2502 cb_data
->call_data
= item
->call_data
;
2504 g_signal_connect (G_OBJECT (w
),
2506 G_CALLBACK (menuitem_destroy_callback
),
2509 /* Put cb_data in widget, so we can get at it when modifying menubar */
2510 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2512 /* final item, not a submenu */
2513 if (item
->call_data
&& ! item
->contents
)
2517 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2523 /* Create a full menu tree specified by DATA.
2524 F is the frame the created menu belongs to.
2525 SELECT_CB is the callback to use when a menu item is selected.
2526 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2527 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2528 If POP_UP_P, create a popup menu.
2529 If MENU_BAR_P, create a menu bar.
2530 TOPMENU is the topmost GtkWidget that others shall be placed under.
2531 It may be NULL, in that case we create the appropriate widget
2532 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2533 CL_DATA is the callback data we shall use for this menu, or NULL
2534 if we haven't set the first callback yet.
2535 NAME is the name to give to the top level menu if this function
2536 creates it. May be NULL to not set any name.
2538 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2541 This function calls itself to create submenus. */
2544 create_menus (widget_value
*data
,
2546 GCallback select_cb
,
2547 GCallback deactivate_cb
,
2548 GCallback highlight_cb
,
2552 xg_menu_cb_data
*cl_data
,
2556 GtkWidget
*wmenu
= topmenu
;
2557 GSList
*group
= NULL
;
2563 wmenu
= gtk_menu_new ();
2564 xg_set_screen (wmenu
, f
);
2565 /* Connect this to the menu instead of items so we get enter/leave for
2566 disabled items also. TODO: Still does not get enter/leave for
2567 disabled items in detached menus. */
2568 g_signal_connect (G_OBJECT (wmenu
),
2569 "enter-notify-event",
2570 G_CALLBACK (menuitem_highlight_callback
),
2572 g_signal_connect (G_OBJECT (wmenu
),
2573 "leave-notify-event",
2574 G_CALLBACK (menuitem_highlight_callback
),
2579 wmenu
= gtk_menu_bar_new ();
2580 /* Set width of menu bar to a small value so it doesn't enlarge
2581 a small initial frame size. The width will be set to the
2582 width of the frame later on when it is added to a container.
2583 height -1: Natural height. */
2584 gtk_widget_set_size_request (wmenu
, 1, -1);
2587 /* Put cl_data on the top menu for easier access. */
2588 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2589 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2590 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2591 G_CALLBACK (menu_destroy_callback
), cl_data
);
2594 gtk_widget_set_name (wmenu
, name
);
2597 g_signal_connect (G_OBJECT (wmenu
),
2598 "selection-done", deactivate_cb
, 0);
2601 for (item
= data
; item
; item
= item
->next
)
2605 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2606 && !menu_separator_name_p (item
->name
))
2609 /* A title for a popup. We do the same as GTK does when
2610 creating titles, but it does not look good. */
2612 utf8_label
= get_utf8_string (item
->name
);
2614 w
= gtk_menu_item_new_with_label (utf8_label
);
2615 gtk_widget_set_sensitive (w
, FALSE
);
2616 if (utf8_label
) g_free (utf8_label
);
2618 else if (menu_separator_name_p (item
->name
))
2621 /* GTK only have one separator type. */
2622 w
= gtk_separator_menu_item_new ();
2626 w
= xg_create_one_menuitem (item
,
2628 item
->contents
? 0 : select_cb
,
2633 /* Create a possibly empty submenu for menu bar items, since some
2634 themes don't highlight items correctly without it. */
2635 if (item
->contents
|| menu_bar_p
)
2637 GtkWidget
*submenu
= create_menus (item
->contents
,
2647 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2651 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2652 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2658 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2659 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2660 with some text and buttons.
2661 F is the frame the created item belongs to.
2662 NAME is the name to use for the top widget.
2663 VAL is a widget_value structure describing items to be created.
2664 SELECT_CB is the callback to use when a menu item is selected or
2665 a dialog button is pressed.
2666 DEACTIVATE_CB is the callback to use when an item is deactivated.
2667 For a menu, when a sub menu is not shown anymore, for a dialog it is
2668 called when the dialog is popped down.
2669 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2671 Returns the widget created. */
2674 xg_create_widget (const char *type
, const char *name
, struct frame
*f
,
2675 widget_value
*val
, GCallback select_cb
,
2676 GCallback deactivate_cb
, GCallback highlight_cb
)
2679 bool menu_bar_p
= strcmp (type
, "menubar") == 0;
2680 bool pop_up_p
= strcmp (type
, "popup") == 0;
2682 if (strcmp (type
, "dialog") == 0)
2684 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2685 xg_set_screen (w
, f
);
2686 gtk_window_set_transient_for (GTK_WINDOW (w
),
2687 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2688 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2689 gtk_widget_set_name (w
, "emacs-dialog");
2690 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2692 else if (menu_bar_p
|| pop_up_p
)
2694 w
= create_menus (val
->contents
,
2705 /* Set the cursor to an arrow for popup menus when they are mapped.
2706 This is done by default for menu bar menus. */
2709 /* Must realize so the GdkWindow inside the widget is created. */
2710 gtk_widget_realize (w
);
2711 xg_set_cursor (w
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
2716 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2723 /* Return the label for menu item WITEM. */
2726 xg_get_menu_item_label (GtkMenuItem
*witem
)
2728 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2729 return gtk_label_get_label (wlabel
);
2732 /* Return true if the menu item WITEM has the text LABEL. */
2735 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2738 char *utf8_label
= get_utf8_string (label
);
2739 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2741 if (! old_label
&& ! utf8_label
)
2743 else if (old_label
&& utf8_label
)
2744 is_same
= strcmp (utf8_label
, old_label
) == 0;
2746 if (utf8_label
) g_free (utf8_label
);
2751 /* Destroy widgets in LIST. */
2754 xg_destroy_widgets (GList
*list
)
2758 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2760 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2762 /* Destroying the widget will remove it from the container it is in. */
2763 gtk_widget_destroy (w
);
2767 /* Update the top level names in MENUBAR (i.e. not submenus).
2768 F is the frame the menu bar belongs to.
2769 *LIST is a list with the current menu bar names (menu item widgets).
2770 ITER is the item within *LIST that shall be updated.
2771 POS is the numerical position, starting at 0, of ITER in *LIST.
2772 VAL describes what the menu bar shall look like after the update.
2773 SELECT_CB is the callback to use when a menu item is selected.
2774 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2775 CL_DATA points to the callback data to be used for this menu bar.
2777 This function calls itself to walk through the menu bar names. */
2780 xg_update_menubar (GtkWidget
*menubar
,
2786 GCallback select_cb
,
2787 GCallback deactivate_cb
,
2788 GCallback highlight_cb
,
2789 xg_menu_cb_data
*cl_data
)
2791 if (! iter
&& ! val
)
2793 else if (iter
&& ! val
)
2795 /* Item(s) have been removed. Remove all remaining items. */
2796 xg_destroy_widgets (iter
);
2798 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2799 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2800 gtk_menu_item_new_with_label (""),
2806 else if (! iter
&& val
)
2808 /* Item(s) added. Add all new items in one call. */
2809 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2810 0, 1, menubar
, cl_data
, 0);
2816 /* Below this neither iter or val is NULL */
2817 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2819 /* This item is still the same, check next item. */
2821 iter
= g_list_next (iter
);
2824 else /* This item is changed. */
2826 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2827 GtkMenuItem
*witem2
= 0;
2828 bool val_in_menubar
= 0;
2829 bool iter_in_new_menubar
= 0;
2833 /* See if the changed entry (val) is present later in the menu bar */
2835 iter2
&& ! val_in_menubar
;
2836 iter2
= g_list_next (iter2
))
2838 witem2
= GTK_MENU_ITEM (iter2
->data
);
2839 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2842 /* See if the current entry (iter) is present later in the
2843 specification for the new menu bar. */
2844 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2845 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2847 if (val_in_menubar
&& ! iter_in_new_menubar
)
2851 /* This corresponds to:
2856 g_object_ref (G_OBJECT (witem
));
2857 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2858 gtk_widget_destroy (GTK_WIDGET (witem
));
2860 /* Must get new list since the old changed. */
2861 g_list_free (*list
);
2862 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2863 while (nr
-- > 0) iter
= g_list_next (iter
);
2865 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2867 /* This corresponds to:
2870 Rename B to X. This might seem to be a strange thing to do,
2871 since if there is a menu under B it will be totally wrong for X.
2872 But consider editing a C file. Then there is a C-mode menu
2873 (corresponds to B above).
2874 If then doing C-x C-f the minibuf menu (X above) replaces the
2875 C-mode menu. When returning from the minibuffer, we get
2876 back the C-mode menu. Thus we do:
2877 Rename B to X (C-mode to minibuf menu)
2878 Rename X to B (minibuf to C-mode menu).
2879 If the X menu hasn't been invoked, the menu under B
2880 is up to date when leaving the minibuffer. */
2881 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2882 char *utf8_label
= get_utf8_string (val
->name
);
2884 /* GTK menu items don't notice when their labels have been
2885 changed from underneath them, so we have to explicitly
2886 use g_object_notify to tell listeners (e.g., a GMenuModel
2887 bridge that might be loaded) that the item's label has
2889 gtk_label_set_text (wlabel
, utf8_label
);
2890 #if GTK_CHECK_VERSION (2, 16, 0)
2891 g_object_notify (G_OBJECT (witem
), "label");
2893 if (utf8_label
) g_free (utf8_label
);
2894 iter
= g_list_next (iter
);
2898 else if (! val_in_menubar
&& iter_in_new_menubar
)
2900 /* This corresponds to:
2907 GtkWidget
*w
= xg_create_one_menuitem (val
,
2914 /* Create a possibly empty submenu for menu bar items, since some
2915 themes don't highlight items correctly without it. */
2916 GtkWidget
*submenu
= create_menus (NULL
, f
,
2917 select_cb
, deactivate_cb
,
2919 0, 0, 0, cl_data
, 0);
2921 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2922 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2923 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2925 g_list_free (*list
);
2926 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2927 while (nr
-- > 0) iter
= g_list_next (iter
);
2928 iter
= g_list_next (iter
);
2932 else /* if (val_in_menubar && iter_in_new_menubar) */
2935 /* This corresponds to:
2940 g_object_ref (G_OBJECT (witem2
));
2941 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2942 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2943 GTK_WIDGET (witem2
), pos
);
2944 g_object_unref (G_OBJECT (witem2
));
2946 g_list_free (*list
);
2947 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2948 while (nr
-- > 0) iter
= g_list_next (iter
);
2949 if (iter
) iter
= g_list_next (iter
);
2955 /* Update the rest of the menu bar. */
2956 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2957 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2960 /* Update the menu item W so it corresponds to VAL.
2961 SELECT_CB is the callback to use when a menu item is selected.
2962 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2963 CL_DATA is the data to set in the widget for menu invocation. */
2966 xg_update_menu_item (widget_value
*val
,
2968 GCallback select_cb
,
2969 GCallback highlight_cb
,
2970 xg_menu_cb_data
*cl_data
)
2977 const char *old_label
= 0;
2978 const char *old_key
= 0;
2979 xg_menu_item_cb_data
*cb_data
;
2980 bool label_changed
= false;
2982 wchild
= XG_BIN_CHILD (w
);
2983 utf8_label
= get_utf8_string (val
->name
);
2984 utf8_key
= get_utf8_string (val
->key
);
2986 /* See if W is a menu item with a key. See make_menu_item above. */
2987 if (GTK_IS_BOX (wchild
))
2989 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2991 wlbl
= GTK_LABEL (list
->data
);
2992 wkey
= GTK_LABEL (list
->next
->data
);
2997 /* Remove the key and keep just the label. */
2998 g_object_ref (G_OBJECT (wlbl
));
2999 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3000 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
3001 g_object_unref (G_OBJECT (wlbl
));
3006 else /* Just a label. */
3008 wlbl
= GTK_LABEL (wchild
);
3010 /* Check if there is now a key. */
3013 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
3014 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
3016 wlbl
= GTK_LABEL (list
->data
);
3017 wkey
= GTK_LABEL (list
->next
->data
);
3020 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3021 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
3025 if (wkey
) old_key
= gtk_label_get_label (wkey
);
3026 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
3028 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
3030 label_changed
= true;
3031 gtk_label_set_text (wkey
, utf8_key
);
3034 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
3036 label_changed
= true;
3037 gtk_label_set_text (wlbl
, utf8_label
);
3040 if (utf8_key
) g_free (utf8_key
);
3041 if (utf8_label
) g_free (utf8_label
);
3043 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
3044 gtk_widget_set_sensitive (w
, FALSE
);
3045 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
3046 gtk_widget_set_sensitive (w
, TRUE
);
3048 cb_data
= g_object_get_data (G_OBJECT (w
), XG_ITEM_DATA
);
3051 cb_data
->call_data
= val
->call_data
;
3052 cb_data
->help
= val
->help
;
3053 cb_data
->cl_data
= cl_data
;
3055 /* We assume the callback functions don't change. */
3056 if (val
->call_data
&& ! val
->contents
)
3058 /* This item shall have a select callback. */
3059 if (! cb_data
->select_id
)
3061 = g_signal_connect (G_OBJECT (w
), "activate",
3062 select_cb
, cb_data
);
3064 else if (cb_data
->select_id
)
3066 g_signal_handler_disconnect (w
, cb_data
->select_id
);
3067 cb_data
->select_id
= 0;
3071 #if GTK_CHECK_VERSION (2, 16, 0)
3072 if (label_changed
) /* See comment in xg_update_menubar. */
3073 g_object_notify (G_OBJECT (w
), "label");
3077 /* Update the toggle menu item W so it corresponds to VAL. */
3080 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
3082 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3085 /* Update the radio menu item W so it corresponds to VAL. */
3088 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
3090 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3093 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3094 SUBMENU may be NULL, in that case a new menu is created.
3095 F is the frame the menu bar belongs to.
3096 VAL describes the contents of the menu bar.
3097 SELECT_CB is the callback to use when a menu item is selected.
3098 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3099 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3100 CL_DATA is the call back data to use for any newly created items.
3102 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3106 xg_update_submenu (GtkWidget
*submenu
,
3109 GCallback select_cb
,
3110 GCallback deactivate_cb
,
3111 GCallback highlight_cb
,
3112 xg_menu_cb_data
*cl_data
)
3114 GtkWidget
*newsub
= submenu
;
3118 GList
*first_radio
= 0;
3121 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3123 for (cur
= val
, iter
= list
;
3125 iter
= g_list_next (iter
), cur
= cur
->next
)
3127 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3129 /* Remember first radio button in a group. If we get a mismatch in
3130 a radio group we must rebuild the whole group so that the connections
3131 in GTK becomes correct. */
3132 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3134 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3135 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3138 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3140 if (! menu_separator_name_p (cur
->name
))
3143 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3145 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3147 xg_update_toggle_item (cur
, w
);
3148 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3150 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3152 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3154 xg_update_radio_item (cur
, w
);
3155 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3157 else if (GTK_IS_MENU_ITEM (w
))
3159 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3162 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3163 menu_separator_name_p (cur
->name
))
3166 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3168 sub
= gtk_menu_item_get_submenu (witem
);
3169 if (sub
&& ! cur
->contents
)
3171 /* Not a submenu anymore. */
3172 g_object_ref (G_OBJECT (sub
));
3173 remove_submenu (witem
);
3174 gtk_widget_destroy (sub
);
3176 else if (cur
->contents
)
3180 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3181 select_cb
, deactivate_cb
,
3182 highlight_cb
, cl_data
);
3184 /* If this item just became a submenu, we must set it. */
3186 gtk_menu_item_set_submenu (witem
, nsub
);
3191 /* Structural difference. Remove everything from here and down
3197 /* Remove widgets from first structural change. */
3200 /* If we are adding new menu items below, we must remove from
3201 first radio button so that radio groups become correct. */
3202 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3203 else xg_destroy_widgets (iter
);
3208 /* More items added. Create them. */
3209 newsub
= create_menus (cur
,
3221 if (list
) g_list_free (list
);
3226 /* Update the MENUBAR.
3227 F is the frame the menu bar belongs to.
3228 VAL describes the contents of the menu bar.
3229 If DEEP_P, rebuild all but the top level menu names in
3230 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3231 SELECT_CB is the callback to use when a menu item is selected.
3232 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3233 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3236 xg_modify_menubar_widgets (GtkWidget
*menubar
, struct frame
*f
,
3237 widget_value
*val
, bool deep_p
,
3238 GCallback select_cb
, GCallback deactivate_cb
,
3239 GCallback highlight_cb
)
3241 xg_menu_cb_data
*cl_data
;
3242 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3246 cl_data
= g_object_get_data (G_OBJECT (menubar
), XG_FRAME_DATA
);
3248 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3249 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3255 /* Update all sub menus.
3256 We must keep the submenus (GTK menu item widgets) since the
3257 X Window in the XEvent that activates the menu are those widgets. */
3259 /* Update cl_data, menu_item things in F may have changed. */
3260 update_cl_data (cl_data
, f
, highlight_cb
);
3262 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3267 GtkMenuItem
*witem
= 0;
3269 /* Find sub menu that corresponds to val and update it. */
3270 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3272 witem
= GTK_MENU_ITEM (iter
->data
);
3273 if (xg_item_label_same_p (witem
, cur
->name
))
3275 sub
= gtk_menu_item_get_submenu (witem
);
3280 newsub
= xg_update_submenu (sub
,
3287 /* sub may still be NULL. If we just updated non deep and added
3288 a new menu bar item, it has no sub menu yet. So we set the
3289 newly created sub menu under witem. */
3290 if (newsub
!= sub
&& witem
!= 0)
3292 xg_set_screen (newsub
, f
);
3293 gtk_menu_item_set_submenu (witem
, newsub
);
3299 gtk_widget_show_all (menubar
);
3302 /* Callback called when the menu bar W is mapped.
3303 Used to find the height of the menu bar if we didn't get it
3304 after showing the widget. */
3307 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3310 struct frame
*f
= user_data
;
3311 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3312 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3314 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3315 adjust_frame_size (f
, -1, -1, 2, 0, Qmenu_bar_lines
);
3319 /* Recompute all the widgets of frame F, when the menu bar has been
3323 xg_update_frame_menubar (struct frame
*f
)
3325 struct x_output
*x
= f
->output_data
.x
;
3328 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3331 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3332 return; /* Already done this, happens for frames created invisible. */
3336 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3338 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3340 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3341 gtk_widget_show_all (x
->menubar_widget
);
3342 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3344 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3346 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3347 adjust_frame_size (f
, -1, -1, 2, 0, Qmenu_bar_lines
);
3352 /* Get rid of the menu bar of frame F, and free its storage.
3353 This is used when deleting a frame, and when turning off the menu bar. */
3356 free_frame_menubar (struct frame
*f
)
3358 struct x_output
*x
= f
->output_data
.x
;
3360 if (x
->menubar_widget
)
3364 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3365 /* The menubar and its children shall be deleted when removed from
3367 x
->menubar_widget
= 0;
3368 FRAME_MENUBAR_HEIGHT (f
) = 0;
3369 adjust_frame_size (f
, -1, -1, 2, 0, Qmenu_bar_lines
);
3375 xg_event_is_for_menubar (struct frame
*f
, const XEvent
*event
)
3377 struct x_output
*x
= f
->output_data
.x
;
3386 if (! x
->menubar_widget
) return 0;
3388 if (! (event
->xbutton
.x
>= 0
3389 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3390 && event
->xbutton
.y
>= 0
3391 && event
->xbutton
.y
< FRAME_MENUBAR_HEIGHT (f
)
3392 && event
->xbutton
.same_screen
))
3395 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3396 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3398 gevent
.any
.window
= gw
;
3399 gevent
.any
.type
= GDK_NOTHING
;
3400 gwdesc
= gtk_get_event_widget (&gevent
);
3401 if (! gwdesc
) return 0;
3402 if (! GTK_IS_MENU_BAR (gwdesc
)
3403 && ! GTK_IS_MENU_ITEM (gwdesc
)
3404 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3407 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3408 if (! list
) return 0;
3409 rec
.x
= event
->xbutton
.x
;
3410 rec
.y
= event
->xbutton
.y
;
3414 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3416 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3417 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3426 /***********************************************************************
3427 Scroll bar functions
3428 ***********************************************************************/
3431 /* Setting scroll bar values invokes the callback. Use this variable
3432 to indicate that callback should do nothing. */
3434 bool xg_ignore_gtk_scrollbar
;
3436 /* Width and height of scroll bars for the current theme. */
3437 static int scroll_bar_width_for_theme
;
3438 static int scroll_bar_height_for_theme
;
3440 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3441 may be larger than 32 bits. Keep a mapping from integer index to widget
3442 pointers to get around the 32 bit limitation. */
3446 GtkWidget
**widgets
;
3451 /* Grow this much every time we need to allocate more */
3453 #define ID_TO_WIDGET_INCR 32
3455 /* Store the widget pointer W in id_to_widget and return the integer index. */
3458 xg_store_widget_in_map (GtkWidget
*w
)
3462 if (id_to_widget
.max_size
== id_to_widget
.used
)
3465 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3466 memory_full (SIZE_MAX
);
3468 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3469 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3470 new_size
, sizeof (GtkWidget
*));
3472 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3473 id_to_widget
.widgets
[i
] = 0;
3474 id_to_widget
.max_size
= new_size
;
3477 /* Just loop over the array and find a free place. After all,
3478 how many scroll bars are we creating? Should be a small number.
3479 The check above guarantees we will find a free place. */
3480 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3482 if (! id_to_widget
.widgets
[i
])
3484 id_to_widget
.widgets
[i
] = w
;
3485 ++id_to_widget
.used
;
3491 /* Should never end up here */
3495 /* Remove pointer at IDX from id_to_widget.
3496 Called when scroll bar is destroyed. */
3499 xg_remove_widget_from_map (ptrdiff_t idx
)
3501 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3503 id_to_widget
.widgets
[idx
] = 0;
3504 --id_to_widget
.used
;
3508 /* Get the widget pointer at IDX from id_to_widget. */
3511 xg_get_widget_from_map (ptrdiff_t idx
)
3513 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3514 return id_to_widget
.widgets
[idx
];
3520 update_theme_scrollbar_width (void)
3523 GtkAdjustment
*vadj
;
3530 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3531 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3532 g_object_ref_sink (G_OBJECT (wscroll
));
3533 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3534 gtk_widget_destroy (wscroll
);
3535 g_object_unref (G_OBJECT (wscroll
));
3540 scroll_bar_width_for_theme
= w
;
3544 update_theme_scrollbar_height (void)
3547 GtkAdjustment
*hadj
;
3554 hadj
= gtk_adjustment_new (YG_SB_MIN
, YG_SB_MIN
, YG_SB_MAX
, 0.1, 0.1, 0.1);
3555 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL
, GTK_ADJUSTMENT (hadj
));
3556 g_object_ref_sink (G_OBJECT (wscroll
));
3557 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3558 gtk_widget_destroy (wscroll
);
3559 g_object_unref (G_OBJECT (wscroll
));
3562 scroll_bar_height_for_theme
= w
;
3566 xg_get_default_scrollbar_width (void)
3568 return scroll_bar_width_for_theme
* xg_get_gdk_scale ();
3572 xg_get_default_scrollbar_height (void)
3574 /* Apparently there's no default height for themes. */
3575 return scroll_bar_width_for_theme
* xg_get_gdk_scale ();
3578 /* Return the scrollbar id for X Window WID on display DPY.
3579 Return -1 if WID not in id_to_widget. */
3582 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3587 w
= xg_win_to_widget (dpy
, wid
);
3591 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3592 if (id_to_widget
.widgets
[idx
] == w
)
3599 /* Callback invoked when scroll bar WIDGET is destroyed.
3600 DATA is the index into id_to_widget for WIDGET.
3601 We free pointer to last scroll bar values here and remove the index. */
3604 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3606 intptr_t id
= (intptr_t) data
;
3607 xg_remove_widget_from_map (id
);
3610 /* Create a scroll bar widget for frame F. Store the scroll bar
3612 SCROLL_CALLBACK is the callback to invoke when the value of the
3614 END_CALLBACK is the callback to invoke when scrolling ends.
3615 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3616 to set resources for the widget. */
3619 xg_create_scroll_bar (struct frame
*f
,
3620 struct scroll_bar
*bar
,
3621 GCallback scroll_callback
,
3622 GCallback end_callback
,
3623 const char *scroll_bar_name
)
3629 GtkAdjustment
*vadj
;
3634 /* Page, step increment values are not so important here, they
3635 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3636 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3639 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3640 webox
= gtk_event_box_new ();
3641 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3643 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3645 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3647 scroll_id
= xg_store_widget_in_map (wscroll
);
3649 g_signal_connect (G_OBJECT (wscroll
),
3651 G_CALLBACK (xg_gtk_scroll_destroy
),
3652 (gpointer
) scroll_id
);
3653 g_signal_connect (G_OBJECT (wscroll
),
3657 g_signal_connect (G_OBJECT (wscroll
),
3658 "button-release-event",
3662 /* The scroll bar widget does not draw on a window of its own. Instead
3663 it draws on the parent window, in this case the edit widget. So
3664 whenever the edit widget is cleared, the scroll bar needs to redraw
3665 also, which causes flicker. Put an event box between the edit widget
3666 and the scroll bar, so the scroll bar instead draws itself on the
3667 event box window. */
3668 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3669 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3672 /* Set the cursor to an arrow. */
3673 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3675 bar
->x_window
= scroll_id
;
3676 bar
->horizontal
= 0;
3679 /* Create a horizontal scroll bar widget for frame F. Store the scroll
3680 bar in BAR. SCROLL_CALLBACK is the callback to invoke when the value
3681 of the bar changes. END_CALLBACK is the callback to invoke when
3682 scrolling ends. SCROLL_BAR_NAME is the name we use for the scroll
3683 bar. Can be used to set resources for the widget. */
3686 xg_create_horizontal_scroll_bar (struct frame
*f
,
3687 struct scroll_bar
*bar
,
3688 GCallback scroll_callback
,
3689 GCallback end_callback
,
3690 const char *scroll_bar_name
)
3696 GtkAdjustment
*hadj
;
3701 /* Page, step increment values are not so important here, they
3702 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3703 hadj
= gtk_adjustment_new (YG_SB_MIN
, YG_SB_MIN
, YG_SB_MAX
,
3706 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL
, GTK_ADJUSTMENT (hadj
));
3707 webox
= gtk_event_box_new ();
3708 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3710 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3712 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3714 scroll_id
= xg_store_widget_in_map (wscroll
);
3716 g_signal_connect (G_OBJECT (wscroll
),
3718 G_CALLBACK (xg_gtk_scroll_destroy
),
3719 (gpointer
) scroll_id
);
3720 g_signal_connect (G_OBJECT (wscroll
),
3724 g_signal_connect (G_OBJECT (wscroll
),
3725 "button-release-event",
3729 /* The scroll bar widget does not draw on a window of its own. Instead
3730 it draws on the parent window, in this case the edit widget. So
3731 whenever the edit widget is cleared, the scroll bar needs to redraw
3732 also, which causes flicker. Put an event box between the edit widget
3733 and the scroll bar, so the scroll bar instead draws itself on the
3734 event box window. */
3735 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3736 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3739 /* Set the cursor to an arrow. */
3740 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3742 bar
->x_window
= scroll_id
;
3743 bar
->horizontal
= 1;
3746 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3749 xg_remove_scroll_bar (struct frame
*f
, ptrdiff_t scrollbar_id
)
3751 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3754 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3755 gtk_widget_destroy (w
);
3756 gtk_widget_destroy (wparent
);
3757 SET_FRAME_GARBAGED (f
);
3761 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3763 TOP/LEFT are the new pixel positions where the bar shall appear.
3764 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3767 xg_update_scrollbar_pos (struct frame
*f
,
3768 ptrdiff_t scrollbar_id
,
3774 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3777 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3778 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3780 int scale
= xg_get_gdk_scale ();
3785 left
-= (scale
- 1) * ((width
/ scale
) >> 1);
3787 /* Clear out old position. */
3788 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3789 if (gtk_widget_get_parent (wparent
) == wfixed
)
3791 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3792 "x", &oldx
, "y", &oldy
, NULL
);
3793 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3796 /* Move and resize to new values. */
3797 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3798 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3801 /* No room. Hide scroll bar as some themes output a warning if
3802 the height is less than the min size. */
3803 gtk_widget_hide (wparent
);
3804 gtk_widget_hide (wscroll
);
3808 gtk_widget_show_all (wparent
);
3809 gtk_widget_set_size_request (wscroll
, width
, height
);
3812 gtk_widget_queue_draw (wfixed
);
3813 gdk_window_process_all_updates ();
3815 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3817 /* Clear under old scroll bar position. This must be done after
3818 the gtk_widget_queue_draw and gdk_window_process_all_updates
3820 oldw
+= (scale
- 1) * oldw
;
3821 oldx
-= (scale
- 1) * oldw
;
3822 x_clear_area (f
, oldx
, oldy
, oldw
, oldh
);
3825 /* GTK does not redraw until the main loop is entered again, but
3826 if there are no X events pending we will not enter it. So we sync
3827 here to get some events. */
3830 SET_FRAME_GARBAGED (f
);
3831 cancel_mouse_face (f
);
3836 /* Update the position of the horizontal scroll bar represented by SCROLLBAR_ID
3838 TOP/LEFT are the new pixel positions where the bar shall appear.
3839 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3842 xg_update_horizontal_scrollbar_pos (struct frame
*f
,
3843 ptrdiff_t scrollbar_id
,
3850 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3854 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3855 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3858 /* Clear out old position. */
3859 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3860 if (gtk_widget_get_parent (wparent
) == wfixed
)
3862 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3863 "x", &oldx
, "y", &oldy
, NULL
);
3864 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3867 /* Move and resize to new values. */
3868 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3869 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3872 /* No room. Hide scroll bar as some themes output a warning if
3873 the width is less than the min size. */
3874 gtk_widget_hide (wparent
);
3875 gtk_widget_hide (wscroll
);
3879 gtk_widget_show_all (wparent
);
3880 gtk_widget_set_size_request (wscroll
, width
, height
);
3882 gtk_widget_queue_draw (wfixed
);
3883 gdk_window_process_all_updates ();
3884 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3885 /* Clear under old scroll bar position. This must be done after
3886 the gtk_widget_queue_draw and gdk_window_process_all_updates
3889 oldx
, oldy
, oldw
, oldh
);
3891 /* GTK does not redraw until the main loop is entered again, but
3892 if there are no X events pending we will not enter it. So we sync
3893 here to get some events. */
3896 SET_FRAME_GARBAGED (f
);
3897 cancel_mouse_face (f
);
3902 /* Get the current value of the range, truncated to an integer. */
3905 int_gtk_range_get_value (GtkRange
*range
)
3907 return gtk_range_get_value (range
);
3911 /* Set the thumb size and position of scroll bar BAR. We are currently
3912 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3915 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3920 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3922 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3924 if (wscroll
&& bar
->dragging
== -1)
3934 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3936 if (scroll_bar_adjust_thumb_portion_p
)
3938 /* We do the same as for MOTIF in xterm.c, use 30 chars per
3939 line rather than the real portion value. This makes the
3940 thumb less likely to resize and that looks better. */
3941 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3943 /* When the thumb is at the bottom, position == whole.
3944 So we need to increase `whole' to make space for the thumb. */
3952 top
= (gdouble
) position
/ whole
;
3953 shown
= (gdouble
) portion
/ whole
;
3956 size
= clip_to_bounds (1, shown
* XG_SB_RANGE
, XG_SB_RANGE
);
3957 value
= clip_to_bounds (XG_SB_MIN
, top
* XG_SB_RANGE
, XG_SB_MAX
- size
);
3959 /* Assume all lines are of equal size. */
3960 new_step
= size
/ max (1, FRAME_LINES (f
));
3962 old_size
= gtk_adjustment_get_page_size (adj
);
3963 if (old_size
!= size
)
3965 int old_step
= gtk_adjustment_get_step_increment (adj
);
3966 if (old_step
!= new_step
)
3968 gtk_adjustment_set_page_size (adj
, size
);
3969 gtk_adjustment_set_step_increment (adj
, new_step
);
3970 /* Assume a page increment is about 95% of the page size */
3971 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3976 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3980 /* gtk_range_set_value invokes the callback. Set
3981 ignore_gtk_scrollbar to make the callback do nothing */
3982 xg_ignore_gtk_scrollbar
= 1;
3984 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3985 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3987 gtk_adjustment_changed (adj
);
3989 xg_ignore_gtk_scrollbar
= 0;
3996 /* Set the thumb size and position of horizontal scroll bar BAR. We are
3997 currently displaying PORTION out of a whole WHOLE, and our position
4000 xg_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
,
4005 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
4007 if (wscroll
&& bar
->dragging
== -1)
4011 int upper
= max (whole
- 1, 0);
4012 int pagesize
= min (upper
, max (portion
, 0));
4013 int value
= max (0, min (position
, upper
- pagesize
));
4014 /* These should be set to something more <portion, whole>
4016 int page_increment
= 4;
4017 int step_increment
= 1;
4020 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
4021 gtk_adjustment_configure (adj
, (gdouble
) value
, (gdouble
) lower
,
4022 (gdouble
) upper
, (gdouble
) step_increment
,
4023 (gdouble
) page_increment
, (gdouble
) pagesize
);
4024 gtk_adjustment_changed (adj
);
4029 /* Return true if EVENT is for a scroll bar in frame F.
4030 When the same X window is used for several Gtk+ widgets, we cannot
4031 say for sure based on the X window alone if an event is for the
4032 frame. This function does additional checks. */
4035 xg_event_is_for_scrollbar (struct frame
*f
, const XEvent
*event
)
4039 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
4041 /* Check if press occurred outside the edit widget. */
4042 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
4045 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
4046 (gdk_display_get_device_manager (gdpy
));
4047 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
4049 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
4051 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
4054 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
4055 || event
->type
== MotionNotify
))
4057 /* If we are releasing or moving the scroll bar, it has the grab. */
4058 GtkWidget
*w
= gtk_grab_get_current ();
4059 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
4066 /***********************************************************************
4068 ***********************************************************************/
4070 static GtkPrintSettings
*print_settings
= NULL
;
4071 static GtkPageSetup
*page_setup
= NULL
;
4074 xg_page_setup_dialog (void)
4076 GtkPageSetup
*new_page_setup
= NULL
;
4078 if (print_settings
== NULL
)
4079 print_settings
= gtk_print_settings_new ();
4080 new_page_setup
= gtk_print_run_page_setup_dialog (NULL
, page_setup
,
4083 g_object_unref (page_setup
);
4084 page_setup
= new_page_setup
;
4088 xg_get_page_setup (void)
4090 Lisp_Object result
, orientation_symbol
;
4091 GtkPageOrientation orientation
;
4093 if (page_setup
== NULL
)
4094 page_setup
= gtk_page_setup_new ();
4095 result
= list4 (Fcons (Qleft_margin
,
4096 make_float (gtk_page_setup_get_left_margin (page_setup
,
4098 Fcons (Qright_margin
,
4099 make_float (gtk_page_setup_get_right_margin (page_setup
,
4102 make_float (gtk_page_setup_get_top_margin (page_setup
,
4104 Fcons (Qbottom_margin
,
4105 make_float (gtk_page_setup_get_bottom_margin (page_setup
,
4106 GTK_UNIT_POINTS
))));
4107 result
= Fcons (Fcons (Qheight
,
4108 make_float (gtk_page_setup_get_page_height (page_setup
,
4111 result
= Fcons (Fcons (Qwidth
,
4112 make_float (gtk_page_setup_get_page_width (page_setup
,
4115 orientation
= gtk_page_setup_get_orientation (page_setup
);
4116 if (orientation
== GTK_PAGE_ORIENTATION_PORTRAIT
)
4117 orientation_symbol
= Qportrait
;
4118 else if (orientation
== GTK_PAGE_ORIENTATION_LANDSCAPE
)
4119 orientation_symbol
= Qlandscape
;
4120 else if (orientation
== GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT
)
4121 orientation_symbol
= Qreverse_portrait
;
4122 else if (orientation
== GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE
)
4123 orientation_symbol
= Qreverse_landscape
;
4124 result
= Fcons (Fcons (Qorientation
, orientation_symbol
), result
);
4130 draw_page (GtkPrintOperation
*operation
, GtkPrintContext
*context
,
4131 gint page_nr
, gpointer user_data
)
4133 Lisp_Object frames
= *((Lisp_Object
*) user_data
);
4134 struct frame
*f
= XFRAME (Fnth (make_number (page_nr
), frames
));
4135 cairo_t
*cr
= gtk_print_context_get_cairo_context (context
);
4137 x_cr_draw_frame (cr
, f
);
4141 xg_print_frames_dialog (Lisp_Object frames
)
4143 GtkPrintOperation
*print
;
4144 GtkPrintOperationResult res
;
4146 print
= gtk_print_operation_new ();
4147 if (print_settings
!= NULL
)
4148 gtk_print_operation_set_print_settings (print
, print_settings
);
4149 if (page_setup
!= NULL
)
4150 gtk_print_operation_set_default_page_setup (print
, page_setup
);
4151 gtk_print_operation_set_n_pages (print
, XINT (Flength (frames
)));
4152 g_signal_connect (print
, "draw-page", G_CALLBACK (draw_page
), &frames
);
4153 res
= gtk_print_operation_run (print
, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG
,
4155 if (res
== GTK_PRINT_OPERATION_RESULT_APPLY
)
4157 if (print_settings
!= NULL
)
4158 g_object_unref (print_settings
);
4160 g_object_ref (gtk_print_operation_get_print_settings (print
));
4162 g_object_unref (print
);
4165 #endif /* USE_CAIRO */
4169 /***********************************************************************
4171 ***********************************************************************/
4172 /* The key for the data we put in the GtkImage widgets. The data is
4173 the image used by Emacs. We use this to see if we need to update
4174 the GtkImage with a new image. */
4175 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
4177 /* The key for storing the latest modifiers so the activate callback can
4179 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
4181 /* The key for the data we put in the GtkImage widgets. The data is
4182 the stock name used by Emacs. We use this to see if we need to update
4183 the GtkImage with a new image. */
4184 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
4186 /* As above, but this is used for named theme widgets, as opposed to
4188 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
4190 /* Callback function invoked when a tool bar item is pressed.
4191 W is the button widget in the tool bar that got pressed,
4192 CLIENT_DATA is an integer that is the index of the button in the
4193 tool bar. 0 is the first button. */
4196 xg_tool_bar_button_cb (GtkWidget
*widget
,
4197 GdkEventButton
*event
,
4200 intptr_t state
= event
->state
;
4201 gpointer ptr
= (gpointer
) state
;
4202 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
4207 /* Callback function invoked when a tool bar item is pressed.
4208 W is the button widget in the tool bar that got pressed,
4209 CLIENT_DATA is an integer that is the index of the button in the
4210 tool bar. 0 is the first button. */
4213 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
4215 intptr_t idx
= (intptr_t) client_data
;
4216 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
4217 intptr_t mod
= (intptr_t) gmod
;
4219 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4220 Lisp_Object key
, frame
;
4221 struct input_event event
;
4224 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4227 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4229 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
4230 XSETFRAME (frame
, f
);
4232 /* We generate two events here. The first one is to set the prefix
4233 to `(tool_bar)', see keyboard.c. */
4234 event
.kind
= TOOL_BAR_EVENT
;
4235 event
.frame_or_window
= frame
;
4237 kbd_buffer_store_event (&event
);
4239 event
.kind
= TOOL_BAR_EVENT
;
4240 event
.frame_or_window
= frame
;
4242 /* Convert between the modifier bits GDK uses and the modifier bits
4243 Emacs uses. This assumes GDK and X masks are the same, which they are when
4245 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), mod
);
4246 kbd_buffer_store_event (&event
);
4248 /* Return focus to the frame after we have clicked on a detached
4254 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
4256 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
4257 GtkWidget
*c1
= clist
->data
;
4258 GtkWidget
*c2
= clist
->next
? clist
->next
->data
: NULL
;
4260 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
4261 g_list_free (clist
);
4262 return GTK_IS_LABEL (c1
) ? c1
: c2
;
4266 /* This callback is called when the mouse enters or leaves a tool bar item.
4267 It is used for displaying and hiding the help text.
4268 W is the tool bar item, a button.
4269 EVENT is either an enter event or leave event.
4270 CLIENT_DATA is an integer that is the index of the button in the
4271 tool bar. 0 is the first button.
4273 Returns FALSE to tell GTK to keep processing this event. */
4276 xg_tool_bar_help_callback (GtkWidget
*w
,
4277 GdkEventCrossing
*event
,
4278 gpointer client_data
)
4280 intptr_t idx
= (intptr_t) client_data
;
4281 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4282 Lisp_Object help
, frame
;
4284 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4287 if (event
->type
== GDK_ENTER_NOTIFY
)
4289 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4290 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4293 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4298 XSETFRAME (frame
, f
);
4299 kbd_buffer_store_help_event (frame
, help
);
4305 /* This callback is called when a tool bar item shall be redrawn.
4306 It modifies the expose event so that the GtkImage widget redraws the
4307 whole image. This to overcome a bug that makes GtkImage draw the image
4308 in the wrong place when it tries to redraw just a part of the image.
4309 W is the GtkImage to be redrawn.
4310 EVENT is the expose event for W.
4311 CLIENT_DATA is unused.
4313 Returns FALSE to tell GTK to keep processing this event. */
4317 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4318 GdkEventExpose
*event
,
4319 gpointer client_data
)
4323 gdk_drawable_get_size (event
->window
, &width
, &height
);
4324 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4325 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4327 event
->area
.x
= max (0, event
->area
.x
);
4328 event
->area
.y
= max (0, event
->area
.y
);
4330 event
->area
.width
= max (width
, event
->area
.width
);
4331 event
->area
.height
= max (height
, event
->area
.height
);
4337 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4338 #define toolbar_set_orientation(w, o) \
4339 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4341 #define toolbar_set_orientation(w, o) \
4342 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4345 /* Attach a tool bar to frame F. */
4348 xg_pack_tool_bar (struct frame
*f
, Lisp_Object pos
)
4350 struct x_output
*x
= f
->output_data
.x
;
4351 bool into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4352 GtkWidget
*top_widget
= x
->toolbar_widget
;
4354 toolbar_set_orientation (x
->toolbar_widget
,
4356 ? GTK_ORIENTATION_VERTICAL
4357 : GTK_ORIENTATION_HORIZONTAL
);
4361 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), top_widget
,
4364 if (EQ (pos
, Qleft
))
4365 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4368 x
->toolbar_in_hbox
= true;
4372 bool vbox_pos
= x
->menubar_widget
!= 0;
4373 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), top_widget
,
4377 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4380 x
->toolbar_in_hbox
= false;
4382 x
->toolbar_is_packed
= true;
4385 static bool xg_update_tool_bar_sizes (struct frame
*f
);
4388 tb_size_cb (GtkWidget
*widget
,
4389 GdkRectangle
*allocation
,
4392 /* When tool bar is created it has one preferred size. But when size is
4393 allocated between widgets, it may get another. So we must update
4394 size hints if tool bar size changes. Seen on Fedora 18 at least. */
4395 struct frame
*f
= user_data
;
4397 if (xg_update_tool_bar_sizes (f
))
4399 frame_size_history_add (f
, Qtb_size_cb
, 0, 0, Qnil
);
4400 adjust_frame_size (f
, -1, -1, 5, 0, Qtool_bar_lines
);
4404 /* Create a tool bar for frame F. */
4407 xg_create_tool_bar (struct frame
*f
)
4409 struct x_output
*x
= f
->output_data
.x
;
4410 #if GTK_CHECK_VERSION (3, 3, 6)
4411 GtkStyleContext
*gsty
;
4413 struct xg_frame_tb_info
*tbinfo
4414 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4418 tbinfo
= xmalloc (sizeof (*tbinfo
));
4419 tbinfo
->last_tool_bar
= Qnil
;
4420 tbinfo
->style
= Qnil
;
4421 tbinfo
->hmargin
= tbinfo
->vmargin
= 0;
4422 tbinfo
->dir
= GTK_TEXT_DIR_NONE
;
4423 tbinfo
->n_last_items
= 0;
4424 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4429 x
->toolbar_widget
= gtk_toolbar_new ();
4431 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4433 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4434 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4435 g_signal_connect (x
->toolbar_widget
, "size-allocate",
4436 G_CALLBACK (tb_size_cb
), f
);
4437 #if GTK_CHECK_VERSION (3, 3, 6)
4438 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4439 gtk_style_context_add_class (gsty
, "primary-toolbar");
4444 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4446 /* Find the right-to-left image named by RTL in the tool bar images for F.
4447 Returns IMAGE if RTL is not found. */
4450 find_rtl_image (struct frame
*f
, Lisp_Object image
, Lisp_Object rtl
)
4453 Lisp_Object file
, rtl_name
;
4455 rtl_name
= Ffile_name_nondirectory (rtl
);
4457 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4459 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4460 if (!NILP (file
= file_for_image (rtl_image
)))
4462 file
= call1 (intern ("file-name-sans-extension"),
4463 Ffile_name_nondirectory (file
));
4464 if (! NILP (Fequal (file
, rtl_name
)))
4475 static GtkToolItem
*
4476 xg_make_tool_item (struct frame
*f
,
4478 GtkWidget
**wbutton
,
4480 int i
, bool horiz
, bool text_image
)
4482 GtkToolItem
*ti
= gtk_tool_item_new ();
4483 GtkWidget
*vb
= gtk_box_new (horiz
4484 ? GTK_ORIENTATION_HORIZONTAL
4485 : GTK_ORIENTATION_VERTICAL
,
4487 GtkWidget
*wb
= gtk_button_new ();
4488 /* The eventbox is here so we can have tooltips on disabled items. */
4489 GtkWidget
*weventbox
= gtk_event_box_new ();
4490 #if GTK_CHECK_VERSION (3, 3, 6)
4491 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4492 GtkStyleContext
*gsty
;
4494 gtk_css_provider_load_from_data (css_prov
,
4496 " background-color: transparent;"
4500 gsty
= gtk_widget_get_style_context (weventbox
);
4501 gtk_style_context_add_provider (gsty
,
4502 GTK_STYLE_PROVIDER (css_prov
),
4503 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4504 g_object_unref (css_prov
);
4507 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4509 if (wimage
&& !text_image
)
4510 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4512 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4513 if (wimage
&& text_image
)
4514 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4516 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4517 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4518 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4519 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4520 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4522 if (wimage
|| label
)
4525 gpointer gi
= (gpointer
) ii
;
4527 g_signal_connect (G_OBJECT (wb
), "clicked",
4528 G_CALLBACK (xg_tool_bar_callback
),
4531 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4534 /* Catch expose events to overcome an annoying redraw bug, see
4535 comment for xg_tool_bar_item_expose_callback. */
4536 g_signal_connect (G_OBJECT (ti
),
4538 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4541 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4543 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4544 no distinction based on modifiers in the activate callback,
4545 so we have to do it ourselves. */
4546 g_signal_connect (wb
, "button-release-event",
4547 G_CALLBACK (xg_tool_bar_button_cb
),
4550 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4552 /* Use enter/leave notify to show help. We use the events
4553 rather than the GtkButton specific signals "enter" and
4554 "leave", so we can have only one callback. The event
4555 will tell us what kind of event it is. */
4556 g_signal_connect (G_OBJECT (weventbox
),
4557 "enter-notify-event",
4558 G_CALLBACK (xg_tool_bar_help_callback
),
4560 g_signal_connect (G_OBJECT (weventbox
),
4561 "leave-notify-event",
4562 G_CALLBACK (xg_tool_bar_help_callback
),
4566 if (wbutton
) *wbutton
= wb
;
4572 is_box_type (GtkWidget
*vb
, bool is_horizontal
)
4576 if (GTK_IS_BOX (vb
))
4578 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4579 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4580 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4584 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4590 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4591 const char *icon_name
, const struct image
*img
,
4592 const char *label
, bool horiz
)
4596 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4597 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4599 /* Check if the tool icon matches. */
4600 if (stock_name
&& wimage
)
4602 old
= g_object_get_data (G_OBJECT (wimage
),
4603 XG_TOOL_BAR_STOCK_NAME
);
4604 if (!old
|| strcmp (old
, stock_name
))
4607 else if (icon_name
&& wimage
)
4609 old
= g_object_get_data (G_OBJECT (wimage
),
4610 XG_TOOL_BAR_ICON_NAME
);
4611 if (!old
|| strcmp (old
, icon_name
))
4616 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4617 XG_TOOL_BAR_IMAGE_DATA
);
4618 Pixmap old_img
= (Pixmap
) gold_img
;
4619 if (old_img
!= img
->pixmap
)
4623 /* Check button configuration and label. */
4624 if (is_box_type (vb
, horiz
)
4625 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4628 /* Ensure label is correct. */
4630 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4635 xg_update_tool_bar_sizes (struct frame
*f
)
4637 struct x_output
*x
= f
->output_data
.x
;
4639 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4640 GtkWidget
*top_widget
= x
->toolbar_widget
;
4642 gtk_widget_get_preferred_size (GTK_WIDGET (top_widget
), NULL
, &req
);
4643 if (x
->toolbar_in_hbox
)
4646 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4648 "position", &pos
, NULL
);
4649 if (pos
== 0) nl
= req
.width
;
4650 else nr
= req
.width
;
4655 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4657 "position", &pos
, NULL
);
4658 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4659 else nb
= req
.height
;
4662 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4663 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4664 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4665 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4667 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4668 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4669 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4670 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4671 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4672 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4681 find_icon_from_name (char *name
,
4682 GtkIconTheme
*icon_theme
,
4685 #if ! GTK_CHECK_VERSION (3, 10, 0)
4686 GtkStockItem stock_item
;
4689 if (name
[0] == 'n' && name
[1] == ':')
4691 *icon_name
= name
+ 2;
4694 if (! gtk_icon_theme_has_icon (icon_theme
, *icon_name
))
4698 #if ! GTK_CHECK_VERSION (3, 10, 0)
4699 else if (gtk_stock_lookup (name
, &stock_item
))
4702 else if (gtk_icon_theme_has_icon (icon_theme
, name
))
4717 /* Update the tool bar for frame F. Add new buttons and remove old. */
4720 update_frame_tool_bar (struct frame
*f
)
4723 struct x_output
*x
= f
->output_data
.x
;
4724 int hmargin
= 0, vmargin
= 0;
4725 GtkToolbar
*wtoolbar
;
4727 GtkTextDirection dir
;
4729 bool text_image
, horiz
;
4730 struct xg_frame_tb_info
*tbinfo
;
4732 GtkIconTheme
*icon_theme
;
4735 if (! FRAME_GTK_WIDGET (f
))
4740 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4742 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4743 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4745 else if (CONSP (Vtool_bar_button_margin
))
4747 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4748 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4750 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4751 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4754 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4755 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4756 i.e. zero. This means that margins less than
4757 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4758 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4759 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4761 if (! x
->toolbar_widget
)
4762 xg_create_tool_bar (f
);
4764 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4765 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4767 style
= Ftool_bar_get_system_style ();
4768 screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4769 icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4771 /* Are we up to date? */
4772 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4775 if (! NILP (tbinfo
->last_tool_bar
) && ! NILP (f
->tool_bar_items
)
4776 && tbinfo
->n_last_items
== f
->n_tool_bar_items
4777 && tbinfo
->hmargin
== hmargin
&& tbinfo
->vmargin
== vmargin
4778 && tbinfo
->dir
== dir
4779 && ! NILP (Fequal (tbinfo
->style
, style
))
4780 && ! NILP (Fequal (tbinfo
->last_tool_bar
, f
->tool_bar_items
)))
4786 tbinfo
->last_tool_bar
= f
->tool_bar_items
;
4787 tbinfo
->n_last_items
= f
->n_tool_bar_items
;
4788 tbinfo
->style
= style
;
4789 tbinfo
->hmargin
= hmargin
;
4790 tbinfo
->vmargin
= vmargin
;
4793 text_image
= EQ (style
, Qtext_image_horiz
);
4794 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4796 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4798 bool enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4799 bool selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4803 struct image
*img
= NULL
;
4805 Lisp_Object stock
= Qnil
;
4806 char *stock_name
= NULL
;
4807 char *icon_name
= NULL
;
4809 GtkWidget
*wbutton
= NULL
;
4810 Lisp_Object specified_file
;
4811 bool vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4813 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4814 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4815 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4818 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4820 /* If this is a separator, use a gtk separator item. */
4821 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4823 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4826 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4828 ti
= gtk_separator_tool_item_new ();
4829 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4835 /* Otherwise, the tool-bar item is an ordinary button. */
4837 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4839 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4843 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4845 /* Ignore invalid image specifications. */
4846 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4847 if (!valid_image_p (image
))
4850 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4855 specified_file
= file_for_image (image
);
4856 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4857 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4862 for (tem
= stock
; CONSP (tem
); tem
= XCDR (tem
))
4863 if (! NILP (tem
) && STRINGP (XCAR (tem
)))
4865 stock_name
= find_icon_from_name (SSDATA (XCAR (tem
)),
4868 if (stock_name
|| icon_name
) break;
4871 else if (STRINGP (stock
))
4873 stock_name
= find_icon_from_name (SSDATA (stock
),
4878 if (stock_name
|| icon_name
)
4879 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4881 if (stock_name
== NULL
&& icon_name
== NULL
)
4883 /* No stock image, or stock item not known. Try regular
4884 image. If image is a vector, choose it according to the
4886 if (dir
== GTK_TEXT_DIR_RTL
4887 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4889 image
= find_rtl_image (f
, image
, rtl
);
4891 if (VECTORP (image
))
4895 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4896 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4899 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4900 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4902 eassert (ASIZE (image
) >= idx
);
4903 image
= AREF (image
, idx
);
4908 img_id
= lookup_image (f
, image
);
4909 img
= IMAGE_FROM_ID (f
, img_id
);
4910 prepare_image_for_display (f
, img
);
4912 if (img
->load_failed_p
|| img
->pixmap
== None
)
4915 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4921 /* If there is an existing widget, check if it's stale; if so,
4922 remove it and make a new tool item from scratch. */
4923 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4926 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4935 /* Save the image so we can see if an update is needed the
4936 next time we call xg_tool_item_match_p. */
4937 if (EQ (style
, Qtext
))
4939 else if (stock_name
)
4942 #if GTK_CHECK_VERSION (3, 10, 0)
4943 w
= gtk_image_new_from_icon_name (stock_name
, icon_size
);
4945 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4947 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4948 (gpointer
) xstrdup (stock_name
),
4949 (GDestroyNotify
) xfree
);
4953 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4954 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4955 (gpointer
) xstrdup (icon_name
),
4956 (GDestroyNotify
) xfree
);
4960 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4961 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4962 (gpointer
)img
->pixmap
);
4965 #if GTK_CHECK_VERSION (3, 14, 0)
4968 gtk_widget_set_margin_start (w
, hmargin
);
4969 gtk_widget_set_margin_end (w
, hmargin
);
4970 gtk_widget_set_margin_top (w
, vmargin
);
4971 gtk_widget_set_margin_bottom (w
, vmargin
);
4974 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4976 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4977 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4982 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4986 /* Remove buttons not longer needed. */
4989 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4991 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4992 } while (ti
!= NULL
);
4994 if (f
->n_tool_bar_items
!= 0)
4996 if (! x
->toolbar_is_packed
)
4997 xg_pack_tool_bar (f
, FRAME_TOOL_BAR_POSITION (f
));
4998 gtk_widget_show_all (x
->toolbar_widget
);
4999 if (xg_update_tool_bar_sizes (f
))
5001 frame_size_history_add (f
, Qupdate_frame_tool_bar
, 0, 0, Qnil
);
5002 adjust_frame_size (f
, -1, -1, 2, 0, Qtool_bar_lines
);
5009 /* Deallocate all resources for the tool bar on frame F.
5010 Remove the tool bar. */
5013 free_frame_tool_bar (struct frame
*f
)
5015 struct x_output
*x
= f
->output_data
.x
;
5017 if (x
->toolbar_widget
)
5019 struct xg_frame_tb_info
*tbinfo
;
5020 GtkWidget
*top_widget
= x
->toolbar_widget
;
5023 if (x
->toolbar_is_packed
)
5025 if (x
->toolbar_in_hbox
)
5026 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
5029 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
5033 gtk_widget_destroy (x
->toolbar_widget
);
5035 x
->toolbar_widget
= 0;
5036 x
->toolbar_widget
= 0;
5037 x
->toolbar_is_packed
= false;
5038 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
5039 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
5041 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
5046 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
5051 frame_size_history_add (f
, Qfree_frame_tool_bar
, 0, 0, Qnil
);
5052 adjust_frame_size (f
, -1, -1, 2, 0, Qtool_bar_lines
);
5059 xg_change_toolbar_position (struct frame
*f
, Lisp_Object pos
)
5061 struct x_output
*x
= f
->output_data
.x
;
5062 GtkWidget
*top_widget
= x
->toolbar_widget
;
5064 if (! x
->toolbar_widget
|| ! top_widget
)
5068 g_object_ref (top_widget
);
5069 if (x
->toolbar_is_packed
)
5071 if (x
->toolbar_in_hbox
)
5072 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
5075 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
5079 xg_pack_tool_bar (f
, pos
);
5080 g_object_unref (top_widget
);
5082 if (xg_update_tool_bar_sizes (f
))
5084 frame_size_history_add (f
, Qxg_change_toolbar_position
, 0, 0, Qnil
);
5085 adjust_frame_size (f
, -1, -1, 2, 0, Qtool_bar_lines
);
5094 /***********************************************************************
5096 ***********************************************************************/
5098 xg_initialize (void)
5100 GtkBindingSet
*binding_set
;
5101 GtkSettings
*settings
;
5104 /* Work around a bug with corrupted data if libXft gets unloaded. This way
5105 we keep it permanently linked in. */
5110 xg_ignore_gtk_scrollbar
= 0;
5111 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
5112 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
5114 id_to_widget
.max_size
= id_to_widget
.used
= 0;
5115 id_to_widget
.widgets
= 0;
5117 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
5118 (gdk_display_get_default ()));
5119 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
5120 bindings. It doesn't seem to be any way to remove properties,
5121 so we set it to "" which in means "no key". */
5122 gtk_settings_set_string_property (settings
,
5123 "gtk-menu-bar-accel",
5127 /* Make GTK text input widgets use Emacs style keybindings. This is
5129 gtk_settings_set_string_property (settings
,
5130 "gtk-key-theme-name",
5134 /* Make dialogs close on C-g. Since file dialog inherits from
5135 dialog, this works for them also. */
5136 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
5137 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5140 /* Make menus close on C-g. */
5141 binding_set
= gtk_binding_set_by_class (g_type_class_ref
5142 (GTK_TYPE_MENU_SHELL
));
5143 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5145 update_theme_scrollbar_width ();
5146 update_theme_scrollbar_height ();
5148 #ifdef HAVE_FREETYPE
5149 x_last_font_name
= NULL
;
5153 #endif /* USE_GTK */