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
= (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
590 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
591 GdkColor
*grgb
= get_bg
592 ? &gsty
->bg
[GTK_STATE_SELECTED
]
593 : &gsty
->fg
[GTK_STATE_SELECTED
];
595 color
->red
= grgb
->red
;
596 color
->green
= grgb
->green
;
597 color
->blue
= grgb
->blue
;
598 color
->pixel
= grgb
->pixel
;
609 /***********************************************************************
611 ***********************************************************************/
612 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
613 We use that to pop down the tooltip. This happens if Gtk+ for some
614 reason wants to change or hide the tooltip. */
616 #ifdef USE_GTK_TOOLTIP
619 hierarchy_ch_cb (GtkWidget
*widget
,
620 GtkWidget
*previous_toplevel
,
623 struct frame
*f
= user_data
;
624 struct x_output
*x
= f
->output_data
.x
;
625 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
627 if (! top
|| ! GTK_IS_WINDOW (top
))
628 gtk_widget_hide (previous_toplevel
);
631 /* Callback called when Gtk+ thinks a tooltip should be displayed.
632 We use it to get the tooltip window and the tooltip widget so
633 we can manipulate the ourselves.
635 Return FALSE ensures that the tooltip is not shown. */
638 qttip_cb (GtkWidget
*widget
,
641 gboolean keyboard_mode
,
645 struct frame
*f
= user_data
;
646 struct x_output
*x
= f
->output_data
.x
;
647 if (x
->ttip_widget
== NULL
)
652 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
653 x
->ttip_widget
= tooltip
;
654 g_object_ref (G_OBJECT (tooltip
));
655 x
->ttip_lbl
= gtk_label_new ("");
656 g_object_ref (G_OBJECT (x
->ttip_lbl
));
657 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
658 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
660 /* Change stupid Gtk+ default line wrapping. */
661 p
= gtk_widget_get_parent (x
->ttip_lbl
);
662 list
= gtk_container_get_children (GTK_CONTAINER (p
));
663 for (iter
= list
; iter
; iter
= g_list_next (iter
))
665 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
666 if (GTK_IS_LABEL (w
))
667 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
671 /* ATK needs an empty title for some reason. */
672 gtk_window_set_title (x
->ttip_window
, "");
673 /* Realize so we can safely get screen later on. */
674 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
675 gtk_widget_realize (x
->ttip_lbl
);
677 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
678 G_CALLBACK (hierarchy_ch_cb
), f
);
683 #endif /* USE_GTK_TOOLTIP */
685 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
686 Return true if a system tooltip is available. */
689 xg_prepare_tooltip (struct frame
*f
,
694 #ifndef USE_GTK_TOOLTIP
697 struct x_output
*x
= f
->output_data
.x
;
701 GtkSettings
*settings
;
702 gboolean tt_enabled
= TRUE
;
704 Lisp_Object encoded_string
;
706 if (!x
->ttip_lbl
) return 0;
709 encoded_string
= ENCODE_UTF_8 (string
);
710 widget
= GTK_WIDGET (x
->ttip_lbl
);
711 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
712 screen
= gdk_window_get_screen (gwin
);
713 settings
= gtk_settings_get_for_screen (screen
);
714 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
717 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
718 /* Record that we disabled it so it can be enabled again. */
719 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
723 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
724 g_object_set_data (G_OBJECT
725 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
726 "gdk-display-current-tooltip", NULL
);
728 /* Put our dummy widget in so we can get callbacks for unrealize and
729 hierarchy-changed. */
730 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
731 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
732 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
733 if (width
) *width
= req
.width
;
734 if (height
) *height
= req
.height
;
739 #endif /* USE_GTK_TOOLTIP */
742 /* Show the tooltip at ROOT_X and ROOT_Y.
743 xg_prepare_tooltip must have been called before this function. */
746 xg_show_tooltip (struct frame
*f
, int root_x
, int root_y
)
748 #ifdef USE_GTK_TOOLTIP
749 struct x_output
*x
= f
->output_data
.x
;
753 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
754 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
760 /* Hide tooltip if shown. Do nothing if not shown.
761 Return true if tip was hidden, false if not (i.e. not using
765 xg_hide_tooltip (struct frame
*f
)
768 #ifdef USE_GTK_TOOLTIP
769 if (f
->output_data
.x
->ttip_window
)
771 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
773 gtk_widget_hide (GTK_WIDGET (win
));
775 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
777 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
778 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
779 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
780 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
791 /***********************************************************************
792 General functions for creating widgets, resizing, events, e.t.c.
793 ***********************************************************************/
796 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
797 const gchar
*msg
, gpointer user_data
)
799 if (!strstr (msg
, "visible children"))
800 fprintf (stderr
, "XX %s-WARNING **: %s\n", log_domain
, msg
);
803 /* Make a geometry string and pass that to GTK. It seems this is the
804 only way to get geometry position right if the user explicitly
805 asked for a position when starting Emacs.
806 F is the frame we shall set geometry for. */
809 xg_set_geometry (struct frame
*f
)
811 if (f
->size_hint_flags
& (USPosition
| PPosition
))
813 int left
= f
->left_pos
;
814 int xneg
= f
->size_hint_flags
& XNegative
;
815 int top
= f
->top_pos
;
816 int yneg
= f
->size_hint_flags
& YNegative
;
817 char geom_str
[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
825 sprintf (geom_str
, "=%dx%d%c%d%c%d",
826 FRAME_PIXEL_WIDTH (f
),
827 FRAME_PIXEL_HEIGHT (f
),
828 (xneg
? '-' : '+'), left
,
829 (yneg
? '-' : '+'), top
);
831 /* Silence warning about visible children. */
832 id
= g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
833 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
835 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
837 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
839 g_log_remove_handler ("Gtk", id
);
843 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
844 and use a GtkFixed widget, this doesn't happen automatically. */
847 xg_clear_under_internal_border (struct frame
*f
)
849 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
852 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
854 gtk_widget_queue_draw (wfixed
);
855 gdk_window_process_all_updates ();
857 x_clear_area (f
, 0, 0,
858 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
860 x_clear_area (f
, 0, 0,
861 FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
864 FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
865 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
868 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
869 0, FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
874 xg_get_gdk_scale (void)
876 const char *sscale
= getenv ("GDK_SCALE");
880 long scale
= atol (sscale
);
882 return min (scale
, INT_MAX
);
888 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
889 and a Gtk+ menu bar, we get resize events for the edit part of the
890 frame only. We let Gtk+ deal with the Gtk+ parts.
891 F is the frame to resize.
892 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
895 xg_frame_resized (struct frame
*f
, int pixelwidth
, int pixelheight
)
899 if (pixelwidth
== -1 && pixelheight
== -1)
901 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
902 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
903 0, 0, &pixelwidth
, &pixelheight
);
908 width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, pixelwidth
);
909 height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelheight
);
911 frame_size_history_add
912 (f
, Qxg_frame_resized
, width
, height
, Qnil
);
914 if (width
!= FRAME_TEXT_WIDTH (f
)
915 || height
!= FRAME_TEXT_HEIGHT (f
)
916 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
917 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
919 xg_clear_under_internal_border (f
);
920 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
921 SET_FRAME_GARBAGED (f
);
922 cancel_mouse_face (f
);
924 do_pending_window_change (0);
928 /* Resize the outer window of frame F after changing the height.
929 COLUMNS/ROWS is the size the edit area shall have after the resize. */
932 xg_frame_set_char_size (struct frame
*f
, int width
, int height
)
934 int pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
935 int pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
936 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
937 gint gwidth
, gheight
;
939 = pixelheight
+ FRAME_TOOLBAR_HEIGHT (f
) + FRAME_MENUBAR_HEIGHT (f
);
940 int totalwidth
= pixelwidth
+ FRAME_TOOLBAR_WIDTH (f
);
942 if (FRAME_PIXEL_HEIGHT (f
) == 0)
945 gtk_window_get_size (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
948 /* Do this before resize, as we don't know yet if we will be resized. */
949 xg_clear_under_internal_border (f
);
951 if (FRAME_VISIBLE_P (f
))
953 int scale
= xg_get_gdk_scale ();
954 totalheight
/= scale
;
958 /* Resize the top level widget so rows and columns remain constant.
960 When the frame is fullheight and we only want to change the width
961 or it is fullwidth and we only want to change the height we should
962 be able to preserve the fullscreen property. However, due to the
963 fact that we have to send a resize request anyway, the window
964 manager will abolish it. At least the respective size should
965 remain unchanged but giving the frame back its normal size will
967 if (EQ (fullscreen
, Qfullwidth
) && width
== FRAME_TEXT_WIDTH (f
))
969 frame_size_history_add
970 (f
, Qxg_frame_set_char_size_1
, width
, height
,
971 list2 (make_number (gheight
),
972 make_number (totalheight
)));
974 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
978 else if (EQ (fullscreen
, Qfullheight
) && height
== FRAME_TEXT_HEIGHT (f
))
980 frame_size_history_add
981 (f
, Qxg_frame_set_char_size_2
, width
, height
,
982 list2 (make_number (gwidth
),
983 make_number (totalwidth
)));
985 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
991 frame_size_history_add
992 (f
, Qxg_frame_set_char_size_3
, width
, height
,
993 list2 (make_number (totalwidth
),
994 make_number (totalheight
)));
996 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1002 SET_FRAME_GARBAGED (f
);
1003 cancel_mouse_face (f
);
1005 x_wm_set_size_hint (f
, 0, 0);
1006 /* We can not call change_frame_size for a mapped frame,
1007 we can not set pixel width/height either. The window manager may
1008 override our resize request, XMonad does this all the time.
1009 The best we can do is try to sync, so lisp code sees the updated
1010 size as fast as possible.
1011 For unmapped windows, we can set rows/cols. When
1012 the frame is mapped again we will (hopefully) get the correct size. */
1013 if (FRAME_VISIBLE_P (f
))
1015 /* Must call this to flush out events */
1016 (void)gtk_events_pending ();
1018 x_wait_for_event (f
, ConfigureNotify
);
1020 if (!NILP (fullscreen
))
1021 /* Try to restore fullscreen state. */
1023 store_frame_param (f
, Qfullscreen
, fullscreen
);
1024 x_set_fullscreen (f
, fullscreen
, fullscreen
);
1028 adjust_frame_size (f
, width
, height
, 5, 0, Qxg_frame_set_char_size
);
1032 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
1033 The policy is to keep the number of editable lines. */
1037 xg_height_or_width_changed (struct frame
*f
)
1039 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1040 FRAME_TOTAL_PIXEL_WIDTH (f
),
1041 FRAME_TOTAL_PIXEL_HEIGHT (f
));
1042 f
->output_data
.x
->hint_flags
= 0;
1043 x_wm_set_size_hint (f
, 0, 0);
1047 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
1048 Must be done like this, because GtkWidget:s can have "hidden"
1049 X Window that aren't accessible.
1051 Return 0 if no widget match WDESC. */
1054 xg_win_to_widget (Display
*dpy
, Window wdesc
)
1057 GtkWidget
*gwdesc
= 0;
1061 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
1066 event
.any
.window
= gdkwin
;
1067 event
.any
.type
= GDK_NOTHING
;
1068 gwdesc
= gtk_get_event_widget (&event
);
1075 /* Set the background of widget W to PIXEL. */
1078 xg_set_widget_bg (struct frame
*f
, GtkWidget
*w
, unsigned long pixel
)
1084 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
1086 bg
.red
= (double)xbg
.red
/65535.0;
1087 bg
.green
= (double)xbg
.green
/65535.0;
1088 bg
.blue
= (double)xbg
.blue
/65535.0;
1090 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
1094 GdkColormap
*map
= gtk_widget_get_colormap (w
);
1095 gdk_colormap_query_color (map
, pixel
, &bg
);
1096 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
1100 /* Callback called when the gtk theme changes.
1101 We notify lisp code so it can fix faces used for region for example. */
1104 style_changed_cb (GObject
*go
,
1108 struct input_event event
;
1109 GdkDisplay
*gdpy
= user_data
;
1110 const char *display_name
= gdk_display_get_name (gdpy
);
1111 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1114 event
.kind
= CONFIG_CHANGED_EVENT
;
1115 event
.frame_or_window
= build_string (display_name
);
1116 /* Theme doesn't change often, so intern is called seldom. */
1117 event
.arg
= intern ("theme-name");
1118 kbd_buffer_store_event (&event
);
1120 update_theme_scrollbar_width ();
1121 update_theme_scrollbar_height ();
1123 /* If scroll bar width changed, we need set the new size on all frames
1127 Lisp_Object rest
, frame
;
1128 FOR_EACH_FRAME (rest
, frame
)
1130 struct frame
*f
= XFRAME (frame
);
1131 if (FRAME_LIVE_P (f
)
1133 && FRAME_X_DISPLAY (f
) == dpy
)
1135 x_set_scroll_bar_default_width (f
);
1136 x_set_scroll_bar_default_height (f
);
1137 xg_frame_set_char_size (f
, FRAME_TEXT_WIDTH (f
), FRAME_TEXT_HEIGHT (f
));
1143 /* Called when a delete-event occurs on WIDGET. */
1146 delete_cb (GtkWidget
*widget
,
1153 /* Create and set up the GTK widgets for frame F.
1154 Return true if creation succeeded. */
1157 xg_create_frame_widgets (struct frame
*f
)
1160 GtkWidget
*wvbox
, *whbox
;
1169 if (FRAME_X_EMBEDDED_P (f
))
1171 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1172 wtop
= gtk_plug_new_for_display (gdpy
, f
->output_data
.x
->parent_desc
);
1175 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1177 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1178 has backported it to Gtk+ 2.0 and they add the resize grip for
1179 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1180 forever, so disable the grip. */
1181 #if (! GTK_CHECK_VERSION (3, 0, 0) \
1182 && defined HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1183 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop
), FALSE
);
1186 xg_set_screen (wtop
, f
);
1188 wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1189 whbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1190 gtk_box_set_homogeneous (GTK_BOX (wvbox
), FALSE
);
1191 gtk_box_set_homogeneous (GTK_BOX (whbox
), FALSE
);
1194 wfixed
= emacs_fixed_new (f
);
1196 wfixed
= gtk_fixed_new ();
1199 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1201 if (wtop
) gtk_widget_destroy (wtop
);
1202 if (wvbox
) gtk_widget_destroy (wvbox
);
1203 if (whbox
) gtk_widget_destroy (whbox
);
1204 if (wfixed
) gtk_widget_destroy (wfixed
);
1210 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1211 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1212 gtk_widget_set_name (wvbox
, "pane");
1213 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1215 /* If this frame has a title or name, set it in the title bar. */
1216 if (! NILP (f
->title
))
1217 title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1218 else if (! NILP (f
->name
))
1219 title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1221 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1223 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1224 FRAME_GTK_WIDGET (f
) = wfixed
;
1225 f
->output_data
.x
->vbox_widget
= wvbox
;
1226 f
->output_data
.x
->hbox_widget
= whbox
;
1228 gtk_widget_set_has_window (wfixed
, TRUE
);
1230 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1231 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1232 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1234 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1235 update_frame_tool_bar (f
);
1237 /* We don't want this widget double buffered, because we draw on it
1238 with regular X drawing primitives, so from a GTK/GDK point of
1239 view, the widget is totally blank. When an expose comes, this
1240 will make the widget blank, and then Emacs redraws it. This flickers
1241 a lot, so we turn off double buffering. */
1242 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1244 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1245 SSDATA (Vx_resource_name
),
1246 SSDATA (Vx_resource_class
));
1248 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1249 GTK is to destroy the widget. We want Emacs to do that instead. */
1250 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1251 G_CALLBACK (delete_cb
), f
);
1253 /* Convert our geometry parameters into a geometry string
1255 GTK will itself handle calculating the real position this way. */
1256 xg_set_geometry (f
);
1258 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1260 gtk_widget_add_events (wfixed
,
1261 GDK_POINTER_MOTION_MASK
1263 | GDK_BUTTON_PRESS_MASK
1264 | GDK_BUTTON_RELEASE_MASK
1265 | GDK_KEY_PRESS_MASK
1266 | GDK_ENTER_NOTIFY_MASK
1267 | GDK_LEAVE_NOTIFY_MASK
1268 | GDK_FOCUS_CHANGE_MASK
1269 | GDK_STRUCTURE_MASK
1270 | GDK_VISIBILITY_NOTIFY_MASK
);
1272 /* Must realize the windows so the X window gets created. It is used
1273 by callers of this function. */
1274 gtk_widget_realize (wfixed
);
1275 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1277 /* Since GTK clears its window by filling with the background color,
1278 we must keep X and GTK background in sync. */
1279 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1282 /* Also, do not let any background pixmap to be set, this looks very
1283 bad as Emacs overwrites the background pixmap with its own idea
1284 of background color. */
1285 style
= gtk_widget_get_modifier_style (wfixed
);
1287 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1288 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1289 gtk_widget_modify_style (wfixed
, style
);
1291 gtk_widget_set_can_focus (wfixed
, TRUE
);
1292 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1295 #ifdef USE_GTK_TOOLTIP
1296 /* Steal a tool tip window we can move ourselves. */
1297 f
->output_data
.x
->ttip_widget
= 0;
1298 f
->output_data
.x
->ttip_lbl
= 0;
1299 f
->output_data
.x
->ttip_window
= 0;
1300 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1301 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1305 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1306 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1307 /* Only connect this signal once per screen. */
1308 if (! g_signal_handler_find (G_OBJECT (gs
),
1309 G_SIGNAL_MATCH_FUNC
,
1311 G_CALLBACK (style_changed_cb
),
1314 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1315 G_CALLBACK (style_changed_cb
),
1316 gdk_screen_get_display (screen
));
1326 xg_free_frame_widgets (struct frame
*f
)
1328 if (FRAME_GTK_OUTER_WIDGET (f
))
1330 #ifdef USE_GTK_TOOLTIP
1331 struct x_output
*x
= f
->output_data
.x
;
1333 struct xg_frame_tb_info
*tbinfo
1334 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
1339 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1340 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1341 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1342 #ifdef USE_GTK_TOOLTIP
1344 gtk_widget_destroy (x
->ttip_lbl
);
1346 g_object_unref (G_OBJECT (x
->ttip_widget
));
1351 /* Set the normal size hints for the window manager, for frame F.
1352 FLAGS is the flags word to use--or 0 meaning preserve the flags
1353 that the window now has.
1354 If USER_POSITION, set the User Position
1355 flag (this is useful when FLAGS is 0). */
1358 x_wm_set_size_hint (struct frame
*f
, long int flags
, bool user_position
)
1360 /* Must use GTK routines here, otherwise GTK resets the size hints
1361 to its own defaults. */
1362 GdkGeometry size_hints
;
1363 gint hint_flags
= 0;
1364 int base_width
, base_height
;
1365 int min_rows
= 0, min_cols
= 0;
1366 int win_gravity
= f
->win_gravity
;
1367 Lisp_Object fs_state
, frame
;
1368 int scale
= xg_get_gdk_scale ();
1370 /* Don't set size hints during initialization; that apparently leads
1371 to a race condition. See the thread at
1372 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1373 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1376 XSETFRAME (frame
, f
);
1377 fs_state
= Fframe_parameter (frame
, Qfullscreen
);
1378 if ((EQ (fs_state
, Qmaximized
) || EQ (fs_state
, Qfullboth
)) &&
1379 (x_wm_supports (f
, FRAME_DISPLAY_INFO (f
)->Xatom_net_wm_state
) ||
1380 x_wm_supports (f
, FRAME_DISPLAY_INFO (f
)->Xatom_net_wm_state_fullscreen
)))
1382 /* Don't set hints when maximized or fullscreen. Apparently KWin and
1383 Gtk3 don't get along and the frame shrinks (!).
1390 memset (&size_hints
, 0, sizeof (size_hints
));
1391 f
->output_data
.x
->size_hints
= size_hints
;
1392 f
->output_data
.x
->hint_flags
= hint_flags
;
1395 flags
= f
->size_hint_flags
;
1397 size_hints
= f
->output_data
.x
->size_hints
;
1398 hint_flags
= f
->output_data
.x
->hint_flags
;
1400 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1401 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
1402 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
1404 hint_flags
|= GDK_HINT_BASE_SIZE
;
1405 /* Use one row/col here so base_height/width does not become zero.
1406 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1407 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 1) + FRAME_TOOLBAR_WIDTH (f
);
1408 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 1)
1409 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1411 if (min_cols
> 0) --min_cols
; /* We used one col in base_width = ... 1); */
1412 if (min_rows
> 0) --min_rows
; /* We used one row in base_height = ... 1); */
1414 size_hints
.base_width
= base_width
;
1415 size_hints
.base_height
= base_height
;
1416 size_hints
.min_width
= base_width
+ min_cols
* FRAME_COLUMN_WIDTH (f
);
1417 size_hints
.min_height
= base_height
+ min_rows
* FRAME_LINE_HEIGHT (f
);
1419 /* These currently have a one to one mapping with the X values, but I
1420 don't think we should rely on that. */
1421 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1422 size_hints
.win_gravity
= 0;
1423 if (win_gravity
== NorthWestGravity
)
1424 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1425 else if (win_gravity
== NorthGravity
)
1426 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1427 else if (win_gravity
== NorthEastGravity
)
1428 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1429 else if (win_gravity
== WestGravity
)
1430 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1431 else if (win_gravity
== CenterGravity
)
1432 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1433 else if (win_gravity
== EastGravity
)
1434 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1435 else if (win_gravity
== SouthWestGravity
)
1436 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1437 else if (win_gravity
== SouthGravity
)
1438 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1439 else if (win_gravity
== SouthEastGravity
)
1440 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1441 else if (win_gravity
== StaticGravity
)
1442 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1446 hint_flags
&= ~GDK_HINT_POS
;
1447 hint_flags
|= GDK_HINT_USER_POS
;
1450 size_hints
.base_width
/= scale
;
1451 size_hints
.base_height
/= scale
;
1452 size_hints
.width_inc
/= scale
;
1453 size_hints
.height_inc
/= scale
;
1455 if (hint_flags
!= f
->output_data
.x
->hint_flags
1456 || memcmp (&size_hints
,
1457 &f
->output_data
.x
->size_hints
,
1458 sizeof (size_hints
)) != 0)
1461 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1462 NULL
, &size_hints
, hint_flags
);
1463 f
->output_data
.x
->size_hints
= size_hints
;
1464 f
->output_data
.x
->hint_flags
= hint_flags
;
1469 /* Change background color of a frame.
1470 Since GTK uses the background color to clear the window, we must
1471 keep the GTK and X colors in sync.
1472 F is the frame to change,
1473 BG is the pixel value to change to. */
1476 xg_set_background_color (struct frame
*f
, unsigned long bg
)
1478 if (FRAME_GTK_WIDGET (f
))
1481 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1487 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1488 functions so GTK does not overwrite the icon. */
1491 xg_set_frame_icon (struct frame
*f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1493 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1497 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1502 /***********************************************************************
1504 ***********************************************************************/
1505 /* Return the dialog title to use for a dialog of type KEY.
1506 This is the encoding used by lwlib. We use the same for GTK. */
1509 get_dialog_title (char key
)
1511 const char *title
= "";
1519 title
= "Information";
1538 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1539 the dialog, but return TRUE so the event does not propagate further
1540 in GTK. This prevents GTK from destroying the dialog widget automatically
1541 and we can always destroy the widget manually, regardless of how
1542 it was popped down (button press or WM_DELETE_WINDOW).
1543 W is the dialog widget.
1544 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1545 user_data is NULL (not used).
1547 Returns TRUE to end propagation of event. */
1550 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1552 gtk_widget_unmap (w
);
1556 /* Create a popup dialog window. See also xg_create_widget below.
1557 WV is a widget_value describing the dialog.
1558 SELECT_CB is the callback to use when a button has been pressed.
1559 DEACTIVATE_CB is the callback to use when the dialog pops down.
1561 Returns the GTK dialog widget. */
1564 create_dialog (widget_value
*wv
,
1565 GCallback select_cb
,
1566 GCallback deactivate_cb
)
1568 const char *title
= get_dialog_title (wv
->name
[0]);
1569 int total_buttons
= wv
->name
[1] - '0';
1570 int right_buttons
= wv
->name
[4] - '0';
1573 int button_spacing
= 10;
1574 GtkWidget
*wdialog
= gtk_dialog_new ();
1575 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1577 GtkWidget
*whbox_down
;
1579 /* If the number of buttons is greater than 4, make two rows of buttons
1580 instead. This looks better. */
1581 bool make_two_rows
= total_buttons
> 4;
1583 #if GTK_CHECK_VERSION (3, 12, 0)
1584 GtkBuilder
*gbld
= gtk_builder_new ();
1585 GObject
*go
= gtk_buildable_get_internal_child (GTK_BUILDABLE (wd
),
1588 GtkBox
*cur_box
= GTK_BOX (go
);
1589 g_object_unref (G_OBJECT (gbld
));
1591 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1594 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1595 left_buttons
= total_buttons
- right_buttons
;
1597 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1598 gtk_widget_set_name (wdialog
, "emacs-dialog");
1603 GtkWidget
*wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, button_spacing
);
1604 GtkWidget
*whbox_up
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1605 gtk_box_set_homogeneous (GTK_BOX (wvbox
), TRUE
);
1606 gtk_box_set_homogeneous (GTK_BOX (whbox_up
), FALSE
);
1607 whbox_down
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1608 gtk_box_set_homogeneous (GTK_BOX (whbox_down
), FALSE
);
1610 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1611 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1612 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1614 cur_box
= GTK_BOX (whbox_up
);
1617 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1618 G_CALLBACK (dialog_delete_callback
), 0);
1622 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1623 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1626 for (item
= wv
->contents
; item
; item
= item
->next
)
1628 char *utf8_label
= get_utf8_string (item
->value
);
1632 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1634 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1635 /* This is the text part of the dialog. */
1636 w
= gtk_label_new (utf8_label
);
1637 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1638 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1639 #if GTK_CHECK_VERSION (3, 14, 0)
1640 gtk_widget_set_halign (w
, GTK_ALIGN_START
);
1641 gtk_widget_set_valign (w
, GTK_ALIGN_CENTER
);
1643 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1645 /* Try to make dialog look better. Must realize first so
1646 the widget can calculate the size it needs. */
1647 gtk_widget_realize (w
);
1648 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1649 gtk_box_set_spacing (wvbox
, req
.height
);
1650 if (item
->value
&& strlen (item
->value
) > 0)
1651 button_spacing
= 2*req
.width
/strlen (item
->value
);
1652 if (button_spacing
< 10) button_spacing
= 10;
1656 /* This is one button to add to the dialog. */
1657 w
= gtk_button_new_with_label (utf8_label
);
1658 if (! item
->enabled
)
1659 gtk_widget_set_sensitive (w
, FALSE
);
1661 g_signal_connect (G_OBJECT (w
), "clicked",
1662 select_cb
, item
->call_data
);
1664 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1665 if (++button_nr
== left_buttons
)
1668 cur_box
= GTK_BOX (whbox_down
);
1673 g_free (utf8_label
);
1679 struct xg_dialog_data
1687 /* Function that is called when the file or font dialogs pop down.
1688 W is the dialog widget, RESPONSE is the response code.
1689 USER_DATA is what we passed in to g_signal_connect. */
1692 xg_dialog_response_cb (GtkDialog
*w
,
1696 struct xg_dialog_data
*dd
= user_data
;
1697 dd
->response
= response
;
1698 g_main_loop_quit (dd
->loop
);
1702 /* Destroy the dialog. This makes it pop down. */
1705 pop_down_dialog (void *arg
)
1707 struct xg_dialog_data
*dd
= arg
;
1710 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1711 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1713 g_main_loop_quit (dd
->loop
);
1714 g_main_loop_unref (dd
->loop
);
1719 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1720 We pass in DATA as gpointer* so we can use this as a callback. */
1723 xg_maybe_add_timer (gpointer data
)
1725 struct xg_dialog_data
*dd
= data
;
1726 struct timespec next_time
= timer_check ();
1730 if (timespec_valid_p (next_time
))
1732 time_t s
= next_time
.tv_sec
;
1733 int per_ms
= TIMESPEC_RESOLUTION
/ 1000;
1734 int ms
= (next_time
.tv_nsec
+ per_ms
- 1) / per_ms
;
1735 if (s
<= ((guint
) -1 - ms
) / 1000)
1736 dd
->timerid
= g_timeout_add (s
* 1000 + ms
, xg_maybe_add_timer
, dd
);
1742 /* Pops up a modal dialog W and waits for response.
1743 We don't use gtk_dialog_run because we want to process emacs timers.
1744 The dialog W is not destroyed when this function returns. */
1747 xg_dialog_run (struct frame
*f
, GtkWidget
*w
)
1749 ptrdiff_t count
= SPECPDL_INDEX ();
1750 struct xg_dialog_data dd
;
1752 xg_set_screen (w
, f
);
1753 gtk_window_set_transient_for (GTK_WINDOW (w
),
1754 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1755 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1756 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1758 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1759 dd
.response
= GTK_RESPONSE_CANCEL
;
1763 g_signal_connect (G_OBJECT (w
),
1765 G_CALLBACK (xg_dialog_response_cb
),
1767 /* Don't destroy the widget if closed by the window manager close button. */
1768 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1769 gtk_widget_show (w
);
1771 record_unwind_protect_ptr (pop_down_dialog
, &dd
);
1773 (void) xg_maybe_add_timer (&dd
);
1774 g_main_loop_run (dd
.loop
);
1777 unbind_to (count
, Qnil
);
1783 /***********************************************************************
1784 File dialog functions
1785 ***********************************************************************/
1786 /* Return true if the old file selection dialog is being used. */
1789 xg_uses_old_file_dialog (void)
1791 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1792 return x_gtk_use_old_file_dialog
;
1799 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1801 /* Return the selected file for file chooser dialog W.
1802 The returned string must be free:d. */
1805 xg_get_file_name_from_chooser (GtkWidget
*w
)
1807 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1810 /* Callback called when the "Show hidden files" toggle is pressed.
1811 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1814 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1816 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1818 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1819 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1823 /* Callback called when a property changes in a file chooser.
1824 GOBJECT is the file chooser dialog, ARG1 describes the property.
1825 USER_DATA is the toggle widget in the file chooser dialog.
1826 We use this to update the "Show hidden files" toggle when the user
1827 changes that property by right clicking in the file list. */
1830 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1832 if (strcmp (arg1
->name
, "show-hidden") == 0)
1834 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1835 gboolean visible
, toggle_on
;
1837 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1838 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1840 if (!!visible
!= !!toggle_on
)
1842 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1843 G_CALLBACK (xg_toggle_visibility_cb
),
1845 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1846 g_signal_handlers_unblock_by_func
1847 (G_OBJECT (wtoggle
),
1848 G_CALLBACK (xg_toggle_visibility_cb
),
1851 x_gtk_show_hidden_files
= visible
;
1855 /* Read a file name from the user using a file chooser dialog.
1856 F is the current frame.
1857 PROMPT is a prompt to show to the user. May not be NULL.
1858 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1859 If MUSTMATCH_P, the returned file name must be an existing
1860 file. (Actually, this only has cosmetic effects, the user can
1861 still enter a non-existing file.) *FUNC is set to a function that
1862 can be used to retrieve the selected file name from the returned widget.
1864 Returns the created widget. */
1867 xg_get_file_with_chooser (struct frame
*f
,
1869 char *default_filename
,
1870 bool mustmatch_p
, bool only_dir_p
,
1871 xg_get_file_func
*func
)
1875 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1876 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1877 GtkFileChooserAction action
= (mustmatch_p
?
1878 GTK_FILE_CHOOSER_ACTION_OPEN
:
1879 GTK_FILE_CHOOSER_ACTION_SAVE
);
1882 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1884 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1885 XG_TEXT_CANCEL
, GTK_RESPONSE_CANCEL
,
1886 (mustmatch_p
|| only_dir_p
?
1887 XG_TEXT_OPEN
: XG_TEXT_OK
),
1890 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1892 wbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1893 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
1894 gtk_widget_show (wbox
);
1895 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1897 if (x_gtk_show_hidden_files
)
1899 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1900 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1902 gtk_widget_show (wtoggle
);
1903 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1904 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1905 g_signal_connect (G_OBJECT (filewin
), "notify",
1906 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1908 if (x_gtk_file_dialog_help_text
)
1911 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1912 Show the C-l help text only for versions < 2.10. */
1913 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1914 z
= stpcpy (z
, "\nType C-l to display a file name text entry box.\n");
1915 strcpy (z
, "\nIf you don't like this file selector, use the "
1916 "corresponding\nkey binding or customize "
1917 "use-file-dialog to turn it off.");
1919 wmessage
= gtk_label_new (msgbuf
);
1920 gtk_widget_show (wmessage
);
1923 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1924 if (x_gtk_file_dialog_help_text
)
1925 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1926 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1928 if (default_filename
)
1931 char *utf8_filename
;
1933 file
= build_string (default_filename
);
1935 /* File chooser does not understand ~/... in the file name. It must be
1936 an absolute name starting with /. */
1937 if (default_filename
[0] != '/')
1938 file
= Fexpand_file_name (file
, Qnil
);
1940 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1941 if (! NILP (Ffile_directory_p (file
)))
1942 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1946 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1948 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1950 char *cp
= strrchr (utf8_filename
, '/');
1952 else cp
= utf8_filename
;
1953 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1958 *func
= xg_get_file_name_from_chooser
;
1962 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1964 /* Return the selected file for file selector dialog W.
1965 The returned string must be free:d. */
1968 xg_get_file_name_from_selector (GtkWidget
*w
)
1970 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1971 return xstrdup (gtk_file_selection_get_filename (filesel
));
1974 /* Create a file selection dialog.
1975 F is the current frame.
1976 PROMPT is a prompt to show to the user. May not be NULL.
1977 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1978 If MUSTMATCH_P, the returned file name must be an existing
1979 file. *FUNC is set to a function that can be used to retrieve the
1980 selected file name from the returned widget.
1982 Returns the created widget. */
1985 xg_get_file_with_selection (struct frame
*f
,
1987 char *default_filename
,
1988 bool mustmatch_p
, bool only_dir_p
,
1989 xg_get_file_func
*func
)
1992 GtkFileSelection
*filesel
;
1994 filewin
= gtk_file_selection_new (prompt
);
1995 filesel
= GTK_FILE_SELECTION (filewin
);
1997 if (default_filename
)
1998 gtk_file_selection_set_filename (filesel
, default_filename
);
2002 /* The selection_entry part of filesel is not documented. */
2003 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
2004 gtk_file_selection_hide_fileop_buttons (filesel
);
2007 *func
= xg_get_file_name_from_selector
;
2011 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
2013 /* Read a file name from the user using a file dialog, either the old
2014 file selection dialog, or the new file chooser dialog. Which to use
2015 depends on what the GTK version used has, and what the value of
2016 gtk-use-old-file-dialog.
2017 F is the current frame.
2018 PROMPT is a prompt to show to the user. May not be NULL.
2019 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
2020 If MUSTMATCH_P, the returned file name must be an existing
2023 Returns a file name or NULL if no file was selected.
2024 The returned string must be freed by the caller. */
2027 xg_get_file_name (struct frame
*f
,
2029 char *default_filename
,
2035 int filesel_done
= 0;
2036 xg_get_file_func func
;
2038 #ifdef HAVE_GTK_FILE_SELECTION_NEW
2040 if (xg_uses_old_file_dialog ())
2041 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
2042 mustmatch_p
, only_dir_p
, &func
);
2044 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
2045 mustmatch_p
, only_dir_p
, &func
);
2047 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
2048 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
2049 mustmatch_p
, only_dir_p
, &func
);
2050 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
2052 gtk_widget_set_name (w
, "emacs-filedialog");
2054 filesel_done
= xg_dialog_run (f
, w
);
2055 if (filesel_done
== GTK_RESPONSE_OK
)
2058 gtk_widget_destroy (w
);
2062 /***********************************************************************
2064 ***********************************************************************/
2066 #ifdef HAVE_FREETYPE
2068 #if USE_NEW_GTK_FONT_CHOOSER
2070 #define XG_WEIGHT_TO_SYMBOL(w) \
2071 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
2072 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
2073 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
2074 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
2075 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
2076 : w <= PANGO_WEIGHT_BOLD ? Qbold \
2077 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
2080 #define XG_STYLE_TO_SYMBOL(s) \
2081 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
2082 : s == PANGO_STYLE_ITALIC ? Qitalic \
2085 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2088 static char *x_last_font_name
;
2090 /* Pop up a GTK font selector and return the name of the font the user
2091 selects, as a C string. The returned font name follows GTK's own
2094 `FAMILY [VALUE1 VALUE2] SIZE'
2096 This can be parsed using font_parse_fcname in font.c.
2097 DEFAULT_NAME, if non-zero, is the default font name. */
2100 xg_get_font (struct frame
*f
, const char *default_name
)
2104 Lisp_Object font
= Qnil
;
2106 w
= gtk_font_chooser_dialog_new
2107 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2111 /* Convert fontconfig names to Gtk names, i.e. remove - before
2113 char *p
= strrchr (default_name
, '-');
2117 while (c_isdigit (*ep
))
2119 if (*ep
== '\0') *p
= ' ';
2122 else if (x_last_font_name
)
2123 default_name
= x_last_font_name
;
2126 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w
), default_name
);
2128 gtk_widget_set_name (w
, "emacs-fontdialog");
2129 done
= xg_dialog_run (f
, w
);
2130 if (done
== GTK_RESPONSE_OK
)
2132 #if USE_NEW_GTK_FONT_CHOOSER
2133 /* Use the GTK3 font chooser. */
2134 PangoFontDescription
*desc
2135 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w
));
2139 const char *name
= pango_font_description_get_family (desc
);
2140 gint size
= pango_font_description_get_size (desc
);
2141 PangoWeight weight
= pango_font_description_get_weight (desc
);
2142 PangoStyle style
= pango_font_description_get_style (desc
);
2145 #define FONT_TYPE_WANTED (Qftcr)
2147 #define FONT_TYPE_WANTED (Qxft)
2149 font
= CALLN (Ffont_spec
,
2150 QCname
, build_string (name
),
2151 QCsize
, make_float (pango_units_to_double (size
)),
2152 QCweight
, XG_WEIGHT_TO_SYMBOL (weight
),
2153 QCslant
, XG_STYLE_TO_SYMBOL (style
),
2157 pango_font_description_free (desc
);
2158 dupstring (&x_last_font_name
, name
);
2161 #else /* Use old font selector, which just returns the font name. */
2164 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w
));
2168 font
= build_string (font_name
);
2169 g_free (x_last_font_name
);
2170 x_last_font_name
= font_name
;
2172 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2175 gtk_widget_destroy (w
);
2178 #endif /* HAVE_FREETYPE */
2182 /***********************************************************************
2184 ***********************************************************************/
2186 /* The name of menu items that can be used for customization. Since GTK
2187 RC files are very crude and primitive, we have to set this on all
2188 menu item names so a user can easily customize menu items. */
2190 #define MENU_ITEM_NAME "emacs-menuitem"
2193 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2194 during GC. The next member points to the items. */
2195 static xg_list_node xg_menu_cb_list
;
2197 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2198 during GC. The next member points to the items. */
2199 static xg_list_node xg_menu_item_cb_list
;
2201 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2202 F is the frame CL_DATA will be initialized for.
2203 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2205 The menu bar and all sub menus under the menu bar in a frame
2206 share the same structure, hence the reference count.
2208 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2209 allocated xg_menu_cb_data if CL_DATA is NULL. */
2211 static xg_menu_cb_data
*
2212 make_cl_data (xg_menu_cb_data
*cl_data
, struct frame
*f
, GCallback highlight_cb
)
2216 cl_data
= xmalloc (sizeof *cl_data
);
2218 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2219 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2220 cl_data
->highlight_cb
= highlight_cb
;
2221 cl_data
->ref_count
= 0;
2223 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2226 cl_data
->ref_count
++;
2231 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2232 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2234 When the menu bar is updated, menu items may have been added and/or
2235 removed, so menu_bar_vector and menu_bar_items_used change. We must
2236 then update CL_DATA since it is used to determine which menu
2237 item that is invoked in the menu.
2238 HIGHLIGHT_CB could change, there is no check that the same
2239 function is given when modifying a menu bar as was given when
2240 creating the menu bar. */
2243 update_cl_data (xg_menu_cb_data
*cl_data
,
2245 GCallback highlight_cb
)
2250 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2251 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2252 cl_data
->highlight_cb
= highlight_cb
;
2256 /* Decrease reference count for CL_DATA.
2257 If reference count is zero, free CL_DATA. */
2260 unref_cl_data (xg_menu_cb_data
*cl_data
)
2262 if (cl_data
&& cl_data
->ref_count
> 0)
2264 cl_data
->ref_count
--;
2265 if (cl_data
->ref_count
== 0)
2267 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2273 /* Function that marks all lisp data during GC. */
2279 Lisp_Object rest
, frame
;
2281 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2282 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2284 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2286 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2288 if (! NILP (cb_data
->help
))
2289 mark_object (cb_data
->help
);
2292 FOR_EACH_FRAME (rest
, frame
)
2294 struct frame
*f
= XFRAME (frame
);
2296 if (FRAME_X_P (f
) && FRAME_GTK_OUTER_WIDGET (f
))
2298 struct xg_frame_tb_info
*tbinfo
2299 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
2303 mark_object (tbinfo
->last_tool_bar
);
2304 mark_object (tbinfo
->style
);
2311 /* Callback called when a menu item is destroyed. Used to free data.
2312 W is the widget that is being destroyed (not used).
2313 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2316 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2320 xg_menu_item_cb_data
*data
= client_data
;
2321 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2326 /* Callback called when the pointer enters/leaves a menu item.
2327 W is the parent of the menu item.
2328 EVENT is either an enter event or leave event.
2329 CLIENT_DATA is not used.
2331 Returns FALSE to tell GTK to keep processing this event. */
2334 menuitem_highlight_callback (GtkWidget
*w
,
2335 GdkEventCrossing
*event
,
2336 gpointer client_data
)
2339 GtkWidget
*subwidget
;
2340 xg_menu_item_cb_data
*data
;
2342 ev
.crossing
= *event
;
2343 subwidget
= gtk_get_event_widget (&ev
);
2344 data
= g_object_get_data (G_OBJECT (subwidget
), XG_ITEM_DATA
);
2347 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2349 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2350 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2351 (*func
) (subwidget
, call_data
);
2358 /* Callback called when a menu is destroyed. Used to free data.
2359 W is the widget that is being destroyed (not used).
2360 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2363 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2365 unref_cl_data (client_data
);
2368 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2369 must be non-NULL) and can be inserted into a menu item.
2371 Returns the GtkHBox. */
2374 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2380 wbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
2381 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
2382 wlbl
= gtk_label_new (utf8_label
);
2383 wkey
= gtk_label_new (utf8_key
);
2385 #if GTK_CHECK_VERSION (3, 14, 0)
2386 gtk_widget_set_halign (wlbl
, GTK_ALIGN_START
);
2387 gtk_widget_set_valign (wlbl
, GTK_ALIGN_CENTER
);
2388 gtk_widget_set_halign (wkey
, GTK_ALIGN_START
);
2389 gtk_widget_set_valign (wkey
, GTK_ALIGN_CENTER
);
2391 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2392 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2394 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2395 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2397 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2398 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2399 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2404 /* Make and return a menu item widget with the key to the right.
2405 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2406 UTF8_KEY is the text representing the key binding.
2407 ITEM is the widget_value describing the menu item.
2409 GROUP is an in/out parameter. If the menu item to be created is not
2410 part of any radio menu group, *GROUP contains NULL on entry and exit.
2411 If the menu item to be created is part of a radio menu group, on entry
2412 *GROUP contains the group to use, or NULL if this is the first item
2413 in the group. On exit, *GROUP contains the radio item group.
2415 Unfortunately, keys don't line up as nicely as in Motif,
2416 but the MacOS X version doesn't either, so I guess that is OK. */
2419 make_menu_item (const char *utf8_label
,
2420 const char *utf8_key
,
2425 GtkWidget
*wtoadd
= 0;
2427 /* It has been observed that some menu items have a NULL name field.
2428 This will lead to this function being called with a NULL utf8_label.
2429 GTK crashes on that so we set a blank label. Why there is a NULL
2430 name remains to be investigated. */
2431 if (! utf8_label
) utf8_label
= " ";
2434 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2436 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2439 if (utf8_key
) w
= gtk_check_menu_item_new ();
2440 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2441 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2443 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2445 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2446 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2447 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2449 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2454 if (utf8_key
) w
= gtk_menu_item_new ();
2455 else w
= gtk_menu_item_new_with_label (utf8_label
);
2458 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2459 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2464 /* Create a menu item widget, and connect the callbacks.
2465 ITEM describes the menu item.
2466 F is the frame the created menu belongs to.
2467 SELECT_CB is the callback to use when a menu item is selected.
2468 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2469 CL_DATA points to the callback data to be used for this menu.
2470 GROUP is an in/out parameter. If the menu item to be created is not
2471 part of any radio menu group, *GROUP contains NULL on entry and exit.
2472 If the menu item to be created is part of a radio menu group, on entry
2473 *GROUP contains the group to use, or NULL if this is the first item
2474 in the group. On exit, *GROUP contains the radio item group.
2476 Returns the created GtkWidget. */
2479 xg_create_one_menuitem (widget_value
*item
,
2481 GCallback select_cb
,
2482 GCallback highlight_cb
,
2483 xg_menu_cb_data
*cl_data
,
2489 xg_menu_item_cb_data
*cb_data
;
2491 utf8_label
= get_utf8_string (item
->name
);
2492 utf8_key
= get_utf8_string (item
->key
);
2494 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2496 if (utf8_label
) g_free (utf8_label
);
2497 if (utf8_key
) g_free (utf8_key
);
2499 cb_data
= xmalloc (sizeof *cb_data
);
2501 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2503 cb_data
->select_id
= 0;
2504 cb_data
->help
= item
->help
;
2505 cb_data
->cl_data
= cl_data
;
2506 cb_data
->call_data
= item
->call_data
;
2508 g_signal_connect (G_OBJECT (w
),
2510 G_CALLBACK (menuitem_destroy_callback
),
2513 /* Put cb_data in widget, so we can get at it when modifying menubar */
2514 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2516 /* final item, not a submenu */
2517 if (item
->call_data
&& ! item
->contents
)
2521 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2527 /* Create a full menu tree specified by DATA.
2528 F is the frame the created menu belongs to.
2529 SELECT_CB is the callback to use when a menu item is selected.
2530 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2531 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2532 If POP_UP_P, create a popup menu.
2533 If MENU_BAR_P, create a menu bar.
2534 TOPMENU is the topmost GtkWidget that others shall be placed under.
2535 It may be NULL, in that case we create the appropriate widget
2536 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2537 CL_DATA is the callback data we shall use for this menu, or NULL
2538 if we haven't set the first callback yet.
2539 NAME is the name to give to the top level menu if this function
2540 creates it. May be NULL to not set any name.
2542 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2545 This function calls itself to create submenus. */
2548 create_menus (widget_value
*data
,
2550 GCallback select_cb
,
2551 GCallback deactivate_cb
,
2552 GCallback highlight_cb
,
2556 xg_menu_cb_data
*cl_data
,
2560 GtkWidget
*wmenu
= topmenu
;
2561 GSList
*group
= NULL
;
2567 wmenu
= gtk_menu_new ();
2568 xg_set_screen (wmenu
, f
);
2569 /* Connect this to the menu instead of items so we get enter/leave for
2570 disabled items also. TODO: Still does not get enter/leave for
2571 disabled items in detached menus. */
2572 g_signal_connect (G_OBJECT (wmenu
),
2573 "enter-notify-event",
2574 G_CALLBACK (menuitem_highlight_callback
),
2576 g_signal_connect (G_OBJECT (wmenu
),
2577 "leave-notify-event",
2578 G_CALLBACK (menuitem_highlight_callback
),
2583 wmenu
= gtk_menu_bar_new ();
2584 /* Set width of menu bar to a small value so it doesn't enlarge
2585 a small initial frame size. The width will be set to the
2586 width of the frame later on when it is added to a container.
2587 height -1: Natural height. */
2588 gtk_widget_set_size_request (wmenu
, 1, -1);
2591 /* Put cl_data on the top menu for easier access. */
2592 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2593 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2594 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2595 G_CALLBACK (menu_destroy_callback
), cl_data
);
2598 gtk_widget_set_name (wmenu
, name
);
2601 g_signal_connect (G_OBJECT (wmenu
),
2602 "selection-done", deactivate_cb
, 0);
2605 for (item
= data
; item
; item
= item
->next
)
2609 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2610 && !menu_separator_name_p (item
->name
))
2613 /* A title for a popup. We do the same as GTK does when
2614 creating titles, but it does not look good. */
2616 utf8_label
= get_utf8_string (item
->name
);
2618 w
= gtk_menu_item_new_with_label (utf8_label
);
2619 gtk_widget_set_sensitive (w
, FALSE
);
2620 if (utf8_label
) g_free (utf8_label
);
2622 else if (menu_separator_name_p (item
->name
))
2625 /* GTK only have one separator type. */
2626 w
= gtk_separator_menu_item_new ();
2630 w
= xg_create_one_menuitem (item
,
2632 item
->contents
? 0 : select_cb
,
2637 /* Create a possibly empty submenu for menu bar items, since some
2638 themes don't highlight items correctly without it. */
2639 if (item
->contents
|| menu_bar_p
)
2641 GtkWidget
*submenu
= create_menus (item
->contents
,
2651 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2655 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2656 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2662 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2663 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2664 with some text and buttons.
2665 F is the frame the created item belongs to.
2666 NAME is the name to use for the top widget.
2667 VAL is a widget_value structure describing items to be created.
2668 SELECT_CB is the callback to use when a menu item is selected or
2669 a dialog button is pressed.
2670 DEACTIVATE_CB is the callback to use when an item is deactivated.
2671 For a menu, when a sub menu is not shown anymore, for a dialog it is
2672 called when the dialog is popped down.
2673 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2675 Returns the widget created. */
2678 xg_create_widget (const char *type
, const char *name
, struct frame
*f
,
2679 widget_value
*val
, GCallback select_cb
,
2680 GCallback deactivate_cb
, GCallback highlight_cb
)
2683 bool menu_bar_p
= strcmp (type
, "menubar") == 0;
2684 bool pop_up_p
= strcmp (type
, "popup") == 0;
2686 if (strcmp (type
, "dialog") == 0)
2688 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2689 xg_set_screen (w
, f
);
2690 gtk_window_set_transient_for (GTK_WINDOW (w
),
2691 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2692 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2693 gtk_widget_set_name (w
, "emacs-dialog");
2694 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2696 else if (menu_bar_p
|| pop_up_p
)
2698 w
= create_menus (val
->contents
,
2709 /* Set the cursor to an arrow for popup menus when they are mapped.
2710 This is done by default for menu bar menus. */
2713 /* Must realize so the GdkWindow inside the widget is created. */
2714 gtk_widget_realize (w
);
2715 xg_set_cursor (w
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
2720 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2727 /* Return the label for menu item WITEM. */
2730 xg_get_menu_item_label (GtkMenuItem
*witem
)
2732 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2733 return gtk_label_get_label (wlabel
);
2736 /* Return true if the menu item WITEM has the text LABEL. */
2739 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2742 char *utf8_label
= get_utf8_string (label
);
2743 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2745 if (! old_label
&& ! utf8_label
)
2747 else if (old_label
&& utf8_label
)
2748 is_same
= strcmp (utf8_label
, old_label
) == 0;
2750 if (utf8_label
) g_free (utf8_label
);
2755 /* Destroy widgets in LIST. */
2758 xg_destroy_widgets (GList
*list
)
2762 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2764 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2766 /* Destroying the widget will remove it from the container it is in. */
2767 gtk_widget_destroy (w
);
2771 /* Update the top level names in MENUBAR (i.e. not submenus).
2772 F is the frame the menu bar belongs to.
2773 *LIST is a list with the current menu bar names (menu item widgets).
2774 ITER is the item within *LIST that shall be updated.
2775 POS is the numerical position, starting at 0, of ITER in *LIST.
2776 VAL describes what the menu bar shall look like after the update.
2777 SELECT_CB is the callback to use when a menu item is selected.
2778 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2779 CL_DATA points to the callback data to be used for this menu bar.
2781 This function calls itself to walk through the menu bar names. */
2784 xg_update_menubar (GtkWidget
*menubar
,
2790 GCallback select_cb
,
2791 GCallback deactivate_cb
,
2792 GCallback highlight_cb
,
2793 xg_menu_cb_data
*cl_data
)
2795 if (! iter
&& ! val
)
2797 else if (iter
&& ! val
)
2799 /* Item(s) have been removed. Remove all remaining items. */
2800 xg_destroy_widgets (iter
);
2802 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2803 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2804 gtk_menu_item_new_with_label (""),
2810 else if (! iter
&& val
)
2812 /* Item(s) added. Add all new items in one call. */
2813 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2814 0, 1, menubar
, cl_data
, 0);
2820 /* Below this neither iter or val is NULL */
2821 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2823 /* This item is still the same, check next item. */
2825 iter
= g_list_next (iter
);
2828 else /* This item is changed. */
2830 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2831 GtkMenuItem
*witem2
= 0;
2832 bool val_in_menubar
= 0;
2833 bool iter_in_new_menubar
= 0;
2837 /* See if the changed entry (val) is present later in the menu bar */
2839 iter2
&& ! val_in_menubar
;
2840 iter2
= g_list_next (iter2
))
2842 witem2
= GTK_MENU_ITEM (iter2
->data
);
2843 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2846 /* See if the current entry (iter) is present later in the
2847 specification for the new menu bar. */
2848 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2849 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2851 if (val_in_menubar
&& ! iter_in_new_menubar
)
2855 /* This corresponds to:
2860 g_object_ref (G_OBJECT (witem
));
2861 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2862 gtk_widget_destroy (GTK_WIDGET (witem
));
2864 /* Must get new list since the old changed. */
2865 g_list_free (*list
);
2866 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2867 while (nr
-- > 0) iter
= g_list_next (iter
);
2869 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2871 /* This corresponds to:
2874 Rename B to X. This might seem to be a strange thing to do,
2875 since if there is a menu under B it will be totally wrong for X.
2876 But consider editing a C file. Then there is a C-mode menu
2877 (corresponds to B above).
2878 If then doing C-x C-f the minibuf menu (X above) replaces the
2879 C-mode menu. When returning from the minibuffer, we get
2880 back the C-mode menu. Thus we do:
2881 Rename B to X (C-mode to minibuf menu)
2882 Rename X to B (minibuf to C-mode menu).
2883 If the X menu hasn't been invoked, the menu under B
2884 is up to date when leaving the minibuffer. */
2885 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2886 char *utf8_label
= get_utf8_string (val
->name
);
2888 /* GTK menu items don't notice when their labels have been
2889 changed from underneath them, so we have to explicitly
2890 use g_object_notify to tell listeners (e.g., a GMenuModel
2891 bridge that might be loaded) that the item's label has
2893 gtk_label_set_text (wlabel
, utf8_label
);
2894 #if GTK_CHECK_VERSION (2, 16, 0)
2895 g_object_notify (G_OBJECT (witem
), "label");
2897 if (utf8_label
) g_free (utf8_label
);
2898 iter
= g_list_next (iter
);
2902 else if (! val_in_menubar
&& iter_in_new_menubar
)
2904 /* This corresponds to:
2911 GtkWidget
*w
= xg_create_one_menuitem (val
,
2918 /* Create a possibly empty submenu for menu bar items, since some
2919 themes don't highlight items correctly without it. */
2920 GtkWidget
*submenu
= create_menus (NULL
, f
,
2921 select_cb
, deactivate_cb
,
2923 0, 0, 0, cl_data
, 0);
2925 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2926 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2927 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2929 g_list_free (*list
);
2930 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2931 while (nr
-- > 0) iter
= g_list_next (iter
);
2932 iter
= g_list_next (iter
);
2936 else /* if (val_in_menubar && iter_in_new_menubar) */
2939 /* This corresponds to:
2944 g_object_ref (G_OBJECT (witem2
));
2945 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2946 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2947 GTK_WIDGET (witem2
), pos
);
2948 g_object_unref (G_OBJECT (witem2
));
2950 g_list_free (*list
);
2951 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2952 while (nr
-- > 0) iter
= g_list_next (iter
);
2953 if (iter
) iter
= g_list_next (iter
);
2959 /* Update the rest of the menu bar. */
2960 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2961 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2964 /* Update the menu item W so it corresponds to VAL.
2965 SELECT_CB is the callback to use when a menu item is selected.
2966 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2967 CL_DATA is the data to set in the widget for menu invocation. */
2970 xg_update_menu_item (widget_value
*val
,
2972 GCallback select_cb
,
2973 GCallback highlight_cb
,
2974 xg_menu_cb_data
*cl_data
)
2981 const char *old_label
= 0;
2982 const char *old_key
= 0;
2983 xg_menu_item_cb_data
*cb_data
;
2984 bool label_changed
= false;
2986 wchild
= XG_BIN_CHILD (w
);
2987 utf8_label
= get_utf8_string (val
->name
);
2988 utf8_key
= get_utf8_string (val
->key
);
2990 /* See if W is a menu item with a key. See make_menu_item above. */
2991 if (GTK_IS_BOX (wchild
))
2993 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2995 wlbl
= GTK_LABEL (list
->data
);
2996 wkey
= GTK_LABEL (list
->next
->data
);
3001 /* Remove the key and keep just the label. */
3002 g_object_ref (G_OBJECT (wlbl
));
3003 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3004 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
3005 g_object_unref (G_OBJECT (wlbl
));
3010 else /* Just a label. */
3012 wlbl
= GTK_LABEL (wchild
);
3014 /* Check if there is now a key. */
3017 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
3018 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
3020 wlbl
= GTK_LABEL (list
->data
);
3021 wkey
= GTK_LABEL (list
->next
->data
);
3024 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3025 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
3029 if (wkey
) old_key
= gtk_label_get_label (wkey
);
3030 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
3032 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
3034 label_changed
= true;
3035 gtk_label_set_text (wkey
, utf8_key
);
3038 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
3040 label_changed
= true;
3041 gtk_label_set_text (wlbl
, utf8_label
);
3044 if (utf8_key
) g_free (utf8_key
);
3045 if (utf8_label
) g_free (utf8_label
);
3047 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
3048 gtk_widget_set_sensitive (w
, FALSE
);
3049 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
3050 gtk_widget_set_sensitive (w
, TRUE
);
3052 cb_data
= g_object_get_data (G_OBJECT (w
), XG_ITEM_DATA
);
3055 cb_data
->call_data
= val
->call_data
;
3056 cb_data
->help
= val
->help
;
3057 cb_data
->cl_data
= cl_data
;
3059 /* We assume the callback functions don't change. */
3060 if (val
->call_data
&& ! val
->contents
)
3062 /* This item shall have a select callback. */
3063 if (! cb_data
->select_id
)
3065 = g_signal_connect (G_OBJECT (w
), "activate",
3066 select_cb
, cb_data
);
3068 else if (cb_data
->select_id
)
3070 g_signal_handler_disconnect (w
, cb_data
->select_id
);
3071 cb_data
->select_id
= 0;
3075 #if GTK_CHECK_VERSION (2, 16, 0)
3076 if (label_changed
) /* See comment in xg_update_menubar. */
3077 g_object_notify (G_OBJECT (w
), "label");
3081 /* Update the toggle menu item W so it corresponds to VAL. */
3084 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
3086 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3089 /* Update the radio menu item W so it corresponds to VAL. */
3092 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
3094 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3097 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3098 SUBMENU may be NULL, in that case a new menu is created.
3099 F is the frame the menu bar belongs to.
3100 VAL describes the contents of the menu bar.
3101 SELECT_CB is the callback to use when a menu item is selected.
3102 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3103 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3104 CL_DATA is the call back data to use for any newly created items.
3106 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3110 xg_update_submenu (GtkWidget
*submenu
,
3113 GCallback select_cb
,
3114 GCallback deactivate_cb
,
3115 GCallback highlight_cb
,
3116 xg_menu_cb_data
*cl_data
)
3118 GtkWidget
*newsub
= submenu
;
3122 GList
*first_radio
= 0;
3125 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3127 for (cur
= val
, iter
= list
;
3129 iter
= g_list_next (iter
), cur
= cur
->next
)
3131 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3133 /* Remember first radio button in a group. If we get a mismatch in
3134 a radio group we must rebuild the whole group so that the connections
3135 in GTK becomes correct. */
3136 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3138 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3139 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3142 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3144 if (! menu_separator_name_p (cur
->name
))
3147 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3149 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3151 xg_update_toggle_item (cur
, w
);
3152 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3154 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3156 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3158 xg_update_radio_item (cur
, w
);
3159 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3161 else if (GTK_IS_MENU_ITEM (w
))
3163 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3166 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3167 menu_separator_name_p (cur
->name
))
3170 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3172 sub
= gtk_menu_item_get_submenu (witem
);
3173 if (sub
&& ! cur
->contents
)
3175 /* Not a submenu anymore. */
3176 g_object_ref (G_OBJECT (sub
));
3177 remove_submenu (witem
);
3178 gtk_widget_destroy (sub
);
3180 else if (cur
->contents
)
3184 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3185 select_cb
, deactivate_cb
,
3186 highlight_cb
, cl_data
);
3188 /* If this item just became a submenu, we must set it. */
3190 gtk_menu_item_set_submenu (witem
, nsub
);
3195 /* Structural difference. Remove everything from here and down
3201 /* Remove widgets from first structural change. */
3204 /* If we are adding new menu items below, we must remove from
3205 first radio button so that radio groups become correct. */
3206 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3207 else xg_destroy_widgets (iter
);
3212 /* More items added. Create them. */
3213 newsub
= create_menus (cur
,
3225 if (list
) g_list_free (list
);
3230 /* Update the MENUBAR.
3231 F is the frame the menu bar belongs to.
3232 VAL describes the contents of the menu bar.
3233 If DEEP_P, rebuild all but the top level menu names in
3234 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3235 SELECT_CB is the callback to use when a menu item is selected.
3236 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3237 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3240 xg_modify_menubar_widgets (GtkWidget
*menubar
, struct frame
*f
,
3241 widget_value
*val
, bool deep_p
,
3242 GCallback select_cb
, GCallback deactivate_cb
,
3243 GCallback highlight_cb
)
3245 xg_menu_cb_data
*cl_data
;
3246 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3250 cl_data
= g_object_get_data (G_OBJECT (menubar
), XG_FRAME_DATA
);
3252 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3253 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3259 /* Update all sub menus.
3260 We must keep the submenus (GTK menu item widgets) since the
3261 X Window in the XEvent that activates the menu are those widgets. */
3263 /* Update cl_data, menu_item things in F may have changed. */
3264 update_cl_data (cl_data
, f
, highlight_cb
);
3266 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3271 GtkMenuItem
*witem
= 0;
3273 /* Find sub menu that corresponds to val and update it. */
3274 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3276 witem
= GTK_MENU_ITEM (iter
->data
);
3277 if (xg_item_label_same_p (witem
, cur
->name
))
3279 sub
= gtk_menu_item_get_submenu (witem
);
3284 newsub
= xg_update_submenu (sub
,
3291 /* sub may still be NULL. If we just updated non deep and added
3292 a new menu bar item, it has no sub menu yet. So we set the
3293 newly created sub menu under witem. */
3294 if (newsub
!= sub
&& witem
!= 0)
3296 xg_set_screen (newsub
, f
);
3297 gtk_menu_item_set_submenu (witem
, newsub
);
3303 gtk_widget_show_all (menubar
);
3306 /* Callback called when the menu bar W is mapped.
3307 Used to find the height of the menu bar if we didn't get it
3308 after showing the widget. */
3311 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3314 struct frame
*f
= user_data
;
3315 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3316 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3318 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3319 adjust_frame_size (f
, -1, -1, 2, 0, Qmenu_bar_lines
);
3323 /* Recompute all the widgets of frame F, when the menu bar has been
3327 xg_update_frame_menubar (struct frame
*f
)
3329 struct x_output
*x
= f
->output_data
.x
;
3332 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3335 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3336 return; /* Already done this, happens for frames created invisible. */
3340 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3342 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3344 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3345 gtk_widget_show_all (x
->menubar_widget
);
3346 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3348 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3350 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3351 adjust_frame_size (f
, -1, -1, 2, 0, Qmenu_bar_lines
);
3356 /* Get rid of the menu bar of frame F, and free its storage.
3357 This is used when deleting a frame, and when turning off the menu bar. */
3360 free_frame_menubar (struct frame
*f
)
3362 struct x_output
*x
= f
->output_data
.x
;
3364 if (x
->menubar_widget
)
3368 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3369 /* The menubar and its children shall be deleted when removed from
3371 x
->menubar_widget
= 0;
3372 FRAME_MENUBAR_HEIGHT (f
) = 0;
3373 adjust_frame_size (f
, -1, -1, 2, 0, Qmenu_bar_lines
);
3379 xg_event_is_for_menubar (struct frame
*f
, const XEvent
*event
)
3381 struct x_output
*x
= f
->output_data
.x
;
3390 if (! x
->menubar_widget
) return 0;
3392 if (! (event
->xbutton
.x
>= 0
3393 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3394 && event
->xbutton
.y
>= 0
3395 && event
->xbutton
.y
< FRAME_MENUBAR_HEIGHT (f
)
3396 && event
->xbutton
.same_screen
))
3399 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3400 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3402 gevent
.any
.window
= gw
;
3403 gevent
.any
.type
= GDK_NOTHING
;
3404 gwdesc
= gtk_get_event_widget (&gevent
);
3405 if (! gwdesc
) return 0;
3406 if (! GTK_IS_MENU_BAR (gwdesc
)
3407 && ! GTK_IS_MENU_ITEM (gwdesc
)
3408 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3411 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3412 if (! list
) return 0;
3413 rec
.x
= event
->xbutton
.x
;
3414 rec
.y
= event
->xbutton
.y
;
3418 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3420 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3421 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3430 /***********************************************************************
3431 Scroll bar functions
3432 ***********************************************************************/
3435 /* Setting scroll bar values invokes the callback. Use this variable
3436 to indicate that callback should do nothing. */
3438 bool xg_ignore_gtk_scrollbar
;
3440 /* Width and height of scroll bars for the current theme. */
3441 static int scroll_bar_width_for_theme
;
3442 static int scroll_bar_height_for_theme
;
3444 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3445 may be larger than 32 bits. Keep a mapping from integer index to widget
3446 pointers to get around the 32 bit limitation. */
3450 GtkWidget
**widgets
;
3455 /* Grow this much every time we need to allocate more */
3457 #define ID_TO_WIDGET_INCR 32
3459 /* Store the widget pointer W in id_to_widget and return the integer index. */
3462 xg_store_widget_in_map (GtkWidget
*w
)
3466 if (id_to_widget
.max_size
== id_to_widget
.used
)
3469 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3470 memory_full (SIZE_MAX
);
3472 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3473 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3474 new_size
, sizeof (GtkWidget
*));
3476 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3477 id_to_widget
.widgets
[i
] = 0;
3478 id_to_widget
.max_size
= new_size
;
3481 /* Just loop over the array and find a free place. After all,
3482 how many scroll bars are we creating? Should be a small number.
3483 The check above guarantees we will find a free place. */
3484 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3486 if (! id_to_widget
.widgets
[i
])
3488 id_to_widget
.widgets
[i
] = w
;
3489 ++id_to_widget
.used
;
3495 /* Should never end up here */
3499 /* Remove pointer at IDX from id_to_widget.
3500 Called when scroll bar is destroyed. */
3503 xg_remove_widget_from_map (ptrdiff_t idx
)
3505 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3507 id_to_widget
.widgets
[idx
] = 0;
3508 --id_to_widget
.used
;
3512 /* Get the widget pointer at IDX from id_to_widget. */
3515 xg_get_widget_from_map (ptrdiff_t idx
)
3517 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3518 return id_to_widget
.widgets
[idx
];
3524 update_theme_scrollbar_width (void)
3527 GtkAdjustment
*vadj
;
3534 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3535 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3536 g_object_ref_sink (G_OBJECT (wscroll
));
3537 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3538 gtk_widget_destroy (wscroll
);
3539 g_object_unref (G_OBJECT (wscroll
));
3544 scroll_bar_width_for_theme
= w
;
3548 update_theme_scrollbar_height (void)
3551 GtkAdjustment
*hadj
;
3558 hadj
= gtk_adjustment_new (YG_SB_MIN
, YG_SB_MIN
, YG_SB_MAX
, 0.1, 0.1, 0.1);
3559 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL
, GTK_ADJUSTMENT (hadj
));
3560 g_object_ref_sink (G_OBJECT (wscroll
));
3561 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3562 gtk_widget_destroy (wscroll
);
3563 g_object_unref (G_OBJECT (wscroll
));
3566 scroll_bar_height_for_theme
= w
;
3570 xg_get_default_scrollbar_width (void)
3572 return scroll_bar_width_for_theme
* xg_get_gdk_scale ();
3576 xg_get_default_scrollbar_height (void)
3578 /* Apparently there's no default height for themes. */
3579 return scroll_bar_width_for_theme
* xg_get_gdk_scale ();
3582 /* Return the scrollbar id for X Window WID on display DPY.
3583 Return -1 if WID not in id_to_widget. */
3586 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3591 w
= xg_win_to_widget (dpy
, wid
);
3595 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3596 if (id_to_widget
.widgets
[idx
] == w
)
3603 /* Callback invoked when scroll bar WIDGET is destroyed.
3604 DATA is the index into id_to_widget for WIDGET.
3605 We free pointer to last scroll bar values here and remove the index. */
3608 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3610 intptr_t id
= (intptr_t) data
;
3611 xg_remove_widget_from_map (id
);
3614 /* Create a scroll bar widget for frame F. Store the scroll bar
3616 SCROLL_CALLBACK is the callback to invoke when the value of the
3618 END_CALLBACK is the callback to invoke when scrolling ends.
3619 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3620 to set resources for the widget. */
3623 xg_create_scroll_bar (struct frame
*f
,
3624 struct scroll_bar
*bar
,
3625 GCallback scroll_callback
,
3626 GCallback end_callback
,
3627 const char *scroll_bar_name
)
3633 GtkAdjustment
*vadj
;
3638 /* Page, step increment values are not so important here, they
3639 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3640 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3643 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3644 webox
= gtk_event_box_new ();
3645 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3647 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3649 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3651 scroll_id
= xg_store_widget_in_map (wscroll
);
3653 g_signal_connect (G_OBJECT (wscroll
),
3655 G_CALLBACK (xg_gtk_scroll_destroy
),
3656 (gpointer
) scroll_id
);
3657 g_signal_connect (G_OBJECT (wscroll
),
3661 g_signal_connect (G_OBJECT (wscroll
),
3662 "button-release-event",
3666 /* The scroll bar widget does not draw on a window of its own. Instead
3667 it draws on the parent window, in this case the edit widget. So
3668 whenever the edit widget is cleared, the scroll bar needs to redraw
3669 also, which causes flicker. Put an event box between the edit widget
3670 and the scroll bar, so the scroll bar instead draws itself on the
3671 event box window. */
3672 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3673 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3676 /* Set the cursor to an arrow. */
3677 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3679 bar
->x_window
= scroll_id
;
3680 bar
->horizontal
= 0;
3683 /* Create a horizontal scroll bar widget for frame F. Store the scroll
3684 bar in BAR. SCROLL_CALLBACK is the callback to invoke when the value
3685 of the bar changes. END_CALLBACK is the callback to invoke when
3686 scrolling ends. SCROLL_BAR_NAME is the name we use for the scroll
3687 bar. Can be used to set resources for the widget. */
3690 xg_create_horizontal_scroll_bar (struct frame
*f
,
3691 struct scroll_bar
*bar
,
3692 GCallback scroll_callback
,
3693 GCallback end_callback
,
3694 const char *scroll_bar_name
)
3700 GtkAdjustment
*hadj
;
3705 /* Page, step increment values are not so important here, they
3706 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3707 hadj
= gtk_adjustment_new (YG_SB_MIN
, YG_SB_MIN
, YG_SB_MAX
,
3710 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL
, GTK_ADJUSTMENT (hadj
));
3711 webox
= gtk_event_box_new ();
3712 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3714 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3716 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3718 scroll_id
= xg_store_widget_in_map (wscroll
);
3720 g_signal_connect (G_OBJECT (wscroll
),
3722 G_CALLBACK (xg_gtk_scroll_destroy
),
3723 (gpointer
) scroll_id
);
3724 g_signal_connect (G_OBJECT (wscroll
),
3728 g_signal_connect (G_OBJECT (wscroll
),
3729 "button-release-event",
3733 /* The scroll bar widget does not draw on a window of its own. Instead
3734 it draws on the parent window, in this case the edit widget. So
3735 whenever the edit widget is cleared, the scroll bar needs to redraw
3736 also, which causes flicker. Put an event box between the edit widget
3737 and the scroll bar, so the scroll bar instead draws itself on the
3738 event box window. */
3739 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3740 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3743 /* Set the cursor to an arrow. */
3744 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3746 bar
->x_window
= scroll_id
;
3747 bar
->horizontal
= 1;
3750 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3753 xg_remove_scroll_bar (struct frame
*f
, ptrdiff_t scrollbar_id
)
3755 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3758 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3759 gtk_widget_destroy (w
);
3760 gtk_widget_destroy (wparent
);
3761 SET_FRAME_GARBAGED (f
);
3765 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3767 TOP/LEFT are the new pixel positions where the bar shall appear.
3768 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3771 xg_update_scrollbar_pos (struct frame
*f
,
3772 ptrdiff_t scrollbar_id
,
3778 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3781 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3782 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3784 int scale
= xg_get_gdk_scale ();
3789 left
-= (scale
- 1) * ((width
/ scale
) >> 1);
3791 /* Clear out old position. */
3792 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3793 if (gtk_widget_get_parent (wparent
) == wfixed
)
3795 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3796 "x", &oldx
, "y", &oldy
, NULL
);
3797 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3800 /* Move and resize to new values. */
3801 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3802 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3805 /* No room. Hide scroll bar as some themes output a warning if
3806 the height is less than the min size. */
3807 gtk_widget_hide (wparent
);
3808 gtk_widget_hide (wscroll
);
3812 gtk_widget_show_all (wparent
);
3813 gtk_widget_set_size_request (wscroll
, width
, height
);
3816 gtk_widget_queue_draw (wfixed
);
3817 gdk_window_process_all_updates ();
3819 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3821 /* Clear under old scroll bar position. This must be done after
3822 the gtk_widget_queue_draw and gdk_window_process_all_updates
3824 oldw
+= (scale
- 1) * oldw
;
3825 oldx
-= (scale
- 1) * oldw
;
3826 x_clear_area (f
, oldx
, oldy
, oldw
, oldh
);
3829 /* GTK does not redraw until the main loop is entered again, but
3830 if there are no X events pending we will not enter it. So we sync
3831 here to get some events. */
3834 SET_FRAME_GARBAGED (f
);
3835 cancel_mouse_face (f
);
3840 /* Update the position of the horizontal scroll bar represented by SCROLLBAR_ID
3842 TOP/LEFT are the new pixel positions where the bar shall appear.
3843 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3846 xg_update_horizontal_scrollbar_pos (struct frame
*f
,
3847 ptrdiff_t scrollbar_id
,
3854 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3858 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3859 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3862 /* Clear out old position. */
3863 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3864 if (gtk_widget_get_parent (wparent
) == wfixed
)
3866 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3867 "x", &oldx
, "y", &oldy
, NULL
);
3868 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3871 /* Move and resize to new values. */
3872 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3873 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3876 /* No room. Hide scroll bar as some themes output a warning if
3877 the width is less than the min size. */
3878 gtk_widget_hide (wparent
);
3879 gtk_widget_hide (wscroll
);
3883 gtk_widget_show_all (wparent
);
3884 gtk_widget_set_size_request (wscroll
, width
, height
);
3886 gtk_widget_queue_draw (wfixed
);
3887 gdk_window_process_all_updates ();
3888 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3889 /* Clear under old scroll bar position. This must be done after
3890 the gtk_widget_queue_draw and gdk_window_process_all_updates
3893 oldx
, oldy
, oldw
, oldh
);
3895 /* GTK does not redraw until the main loop is entered again, but
3896 if there are no X events pending we will not enter it. So we sync
3897 here to get some events. */
3900 SET_FRAME_GARBAGED (f
);
3901 cancel_mouse_face (f
);
3906 /* Get the current value of the range, truncated to an integer. */
3909 int_gtk_range_get_value (GtkRange
*range
)
3911 return gtk_range_get_value (range
);
3915 /* Set the thumb size and position of scroll bar BAR. We are currently
3916 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3919 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3924 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3926 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3928 if (wscroll
&& bar
->dragging
== -1)
3938 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3940 if (scroll_bar_adjust_thumb_portion_p
)
3942 /* We do the same as for MOTIF in xterm.c, use 30 chars per
3943 line rather than the real portion value. This makes the
3944 thumb less likely to resize and that looks better. */
3945 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3947 /* When the thumb is at the bottom, position == whole.
3948 So we need to increase `whole' to make space for the thumb. */
3956 top
= (gdouble
) position
/ whole
;
3957 shown
= (gdouble
) portion
/ whole
;
3960 size
= clip_to_bounds (1, shown
* XG_SB_RANGE
, XG_SB_RANGE
);
3961 value
= clip_to_bounds (XG_SB_MIN
, top
* XG_SB_RANGE
, XG_SB_MAX
- size
);
3963 /* Assume all lines are of equal size. */
3964 new_step
= size
/ max (1, FRAME_LINES (f
));
3966 old_size
= gtk_adjustment_get_page_size (adj
);
3967 if (old_size
!= size
)
3969 int old_step
= gtk_adjustment_get_step_increment (adj
);
3970 if (old_step
!= new_step
)
3972 gtk_adjustment_set_page_size (adj
, size
);
3973 gtk_adjustment_set_step_increment (adj
, new_step
);
3974 /* Assume a page increment is about 95% of the page size */
3975 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3980 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3984 /* gtk_range_set_value invokes the callback. Set
3985 ignore_gtk_scrollbar to make the callback do nothing */
3986 xg_ignore_gtk_scrollbar
= 1;
3988 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3989 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3991 gtk_adjustment_changed (adj
);
3993 xg_ignore_gtk_scrollbar
= 0;
4000 /* Set the thumb size and position of horizontal scroll bar BAR. We are
4001 currently displaying PORTION out of a whole WHOLE, and our position
4004 xg_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
,
4009 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
4011 if (wscroll
&& bar
->dragging
== -1)
4015 int upper
= max (whole
- 1, 0);
4016 int pagesize
= min (upper
, max (portion
, 0));
4017 int value
= max (0, min (position
, upper
- pagesize
));
4018 /* These should be set to something more <portion, whole>
4020 int page_increment
= 4;
4021 int step_increment
= 1;
4024 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
4025 gtk_adjustment_configure (adj
, (gdouble
) value
, (gdouble
) lower
,
4026 (gdouble
) upper
, (gdouble
) step_increment
,
4027 (gdouble
) page_increment
, (gdouble
) pagesize
);
4028 gtk_adjustment_changed (adj
);
4033 /* Return true if EVENT is for a scroll bar in frame F.
4034 When the same X window is used for several Gtk+ widgets, we cannot
4035 say for sure based on the X window alone if an event is for the
4036 frame. This function does additional checks. */
4039 xg_event_is_for_scrollbar (struct frame
*f
, const XEvent
*event
)
4043 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
4045 /* Check if press occurred outside the edit widget. */
4046 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
4049 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
4050 (gdk_display_get_device_manager (gdpy
));
4051 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
4053 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
4055 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
4058 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
4059 || event
->type
== MotionNotify
))
4061 /* If we are releasing or moving the scroll bar, it has the grab. */
4062 GtkWidget
*w
= gtk_grab_get_current ();
4063 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
4070 /***********************************************************************
4072 ***********************************************************************/
4074 static GtkPrintSettings
*print_settings
= NULL
;
4075 static GtkPageSetup
*page_setup
= NULL
;
4078 xg_page_setup_dialog (void)
4080 GtkPageSetup
*new_page_setup
= NULL
;
4082 if (print_settings
== NULL
)
4083 print_settings
= gtk_print_settings_new ();
4084 new_page_setup
= gtk_print_run_page_setup_dialog (NULL
, page_setup
,
4087 g_object_unref (page_setup
);
4088 page_setup
= new_page_setup
;
4092 xg_get_page_setup (void)
4094 Lisp_Object result
, orientation_symbol
;
4095 GtkPageOrientation orientation
;
4097 if (page_setup
== NULL
)
4098 page_setup
= gtk_page_setup_new ();
4099 result
= list4 (Fcons (Qleft_margin
,
4100 make_float (gtk_page_setup_get_left_margin (page_setup
,
4102 Fcons (Qright_margin
,
4103 make_float (gtk_page_setup_get_right_margin (page_setup
,
4106 make_float (gtk_page_setup_get_top_margin (page_setup
,
4108 Fcons (Qbottom_margin
,
4109 make_float (gtk_page_setup_get_bottom_margin (page_setup
,
4110 GTK_UNIT_POINTS
))));
4111 result
= Fcons (Fcons (Qheight
,
4112 make_float (gtk_page_setup_get_page_height (page_setup
,
4115 result
= Fcons (Fcons (Qwidth
,
4116 make_float (gtk_page_setup_get_page_width (page_setup
,
4119 orientation
= gtk_page_setup_get_orientation (page_setup
);
4120 if (orientation
== GTK_PAGE_ORIENTATION_PORTRAIT
)
4121 orientation_symbol
= Qportrait
;
4122 else if (orientation
== GTK_PAGE_ORIENTATION_LANDSCAPE
)
4123 orientation_symbol
= Qlandscape
;
4124 else if (orientation
== GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT
)
4125 orientation_symbol
= Qreverse_portrait
;
4126 else if (orientation
== GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE
)
4127 orientation_symbol
= Qreverse_landscape
;
4128 result
= Fcons (Fcons (Qorientation
, orientation_symbol
), result
);
4134 draw_page (GtkPrintOperation
*operation
, GtkPrintContext
*context
,
4135 gint page_nr
, gpointer user_data
)
4137 Lisp_Object frames
= *((Lisp_Object
*) user_data
);
4138 struct frame
*f
= XFRAME (Fnth (make_number (page_nr
), frames
));
4139 cairo_t
*cr
= gtk_print_context_get_cairo_context (context
);
4141 x_cr_draw_frame (cr
, f
);
4145 xg_print_frames_dialog (Lisp_Object frames
)
4147 GtkPrintOperation
*print
;
4148 GtkPrintOperationResult res
;
4150 print
= gtk_print_operation_new ();
4151 if (print_settings
!= NULL
)
4152 gtk_print_operation_set_print_settings (print
, print_settings
);
4153 if (page_setup
!= NULL
)
4154 gtk_print_operation_set_default_page_setup (print
, page_setup
);
4155 gtk_print_operation_set_n_pages (print
, XINT (Flength (frames
)));
4156 g_signal_connect (print
, "draw-page", G_CALLBACK (draw_page
), &frames
);
4157 res
= gtk_print_operation_run (print
, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG
,
4159 if (res
== GTK_PRINT_OPERATION_RESULT_APPLY
)
4161 if (print_settings
!= NULL
)
4162 g_object_unref (print_settings
);
4164 g_object_ref (gtk_print_operation_get_print_settings (print
));
4166 g_object_unref (print
);
4169 #endif /* USE_CAIRO */
4173 /***********************************************************************
4175 ***********************************************************************/
4176 /* The key for the data we put in the GtkImage widgets. The data is
4177 the image used by Emacs. We use this to see if we need to update
4178 the GtkImage with a new image. */
4179 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
4181 /* The key for storing the latest modifiers so the activate callback can
4183 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
4185 /* The key for the data we put in the GtkImage widgets. The data is
4186 the stock name used by Emacs. We use this to see if we need to update
4187 the GtkImage with a new image. */
4188 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
4190 /* As above, but this is used for named theme widgets, as opposed to
4192 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
4194 /* Callback function invoked when a tool bar item is pressed.
4195 W is the button widget in the tool bar that got pressed,
4196 CLIENT_DATA is an integer that is the index of the button in the
4197 tool bar. 0 is the first button. */
4200 xg_tool_bar_button_cb (GtkWidget
*widget
,
4201 GdkEventButton
*event
,
4204 intptr_t state
= event
->state
;
4205 gpointer ptr
= (gpointer
) state
;
4206 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
4211 /* Callback function invoked when a tool bar item is pressed.
4212 W is the button widget in the tool bar that got pressed,
4213 CLIENT_DATA is an integer that is the index of the button in the
4214 tool bar. 0 is the first button. */
4217 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
4219 intptr_t idx
= (intptr_t) client_data
;
4220 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
4221 intptr_t mod
= (intptr_t) gmod
;
4223 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4224 Lisp_Object key
, frame
;
4225 struct input_event event
;
4228 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4231 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4233 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
4234 XSETFRAME (frame
, f
);
4236 /* We generate two events here. The first one is to set the prefix
4237 to `(tool_bar)', see keyboard.c. */
4238 event
.kind
= TOOL_BAR_EVENT
;
4239 event
.frame_or_window
= frame
;
4241 kbd_buffer_store_event (&event
);
4243 event
.kind
= TOOL_BAR_EVENT
;
4244 event
.frame_or_window
= frame
;
4246 /* Convert between the modifier bits GDK uses and the modifier bits
4247 Emacs uses. This assumes GDK and X masks are the same, which they are when
4249 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), mod
);
4250 kbd_buffer_store_event (&event
);
4252 /* Return focus to the frame after we have clicked on a detached
4258 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
4260 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
4261 GtkWidget
*c1
= clist
->data
;
4262 GtkWidget
*c2
= clist
->next
? clist
->next
->data
: NULL
;
4264 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
4265 g_list_free (clist
);
4266 return GTK_IS_LABEL (c1
) ? c1
: c2
;
4270 /* This callback is called when the mouse enters or leaves a tool bar item.
4271 It is used for displaying and hiding the help text.
4272 W is the tool bar item, a button.
4273 EVENT is either an enter event or leave event.
4274 CLIENT_DATA is an integer that is the index of the button in the
4275 tool bar. 0 is the first button.
4277 Returns FALSE to tell GTK to keep processing this event. */
4280 xg_tool_bar_help_callback (GtkWidget
*w
,
4281 GdkEventCrossing
*event
,
4282 gpointer client_data
)
4284 intptr_t idx
= (intptr_t) client_data
;
4285 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4286 Lisp_Object help
, frame
;
4288 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4291 if (event
->type
== GDK_ENTER_NOTIFY
)
4293 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4294 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4297 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4302 XSETFRAME (frame
, f
);
4303 kbd_buffer_store_help_event (frame
, help
);
4309 /* This callback is called when a tool bar item shall be redrawn.
4310 It modifies the expose event so that the GtkImage widget redraws the
4311 whole image. This to overcome a bug that makes GtkImage draw the image
4312 in the wrong place when it tries to redraw just a part of the image.
4313 W is the GtkImage to be redrawn.
4314 EVENT is the expose event for W.
4315 CLIENT_DATA is unused.
4317 Returns FALSE to tell GTK to keep processing this event. */
4321 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4322 GdkEventExpose
*event
,
4323 gpointer client_data
)
4327 gdk_drawable_get_size (event
->window
, &width
, &height
);
4328 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4329 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4331 event
->area
.x
= max (0, event
->area
.x
);
4332 event
->area
.y
= max (0, event
->area
.y
);
4334 event
->area
.width
= max (width
, event
->area
.width
);
4335 event
->area
.height
= max (height
, event
->area
.height
);
4341 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4342 #define toolbar_set_orientation(w, o) \
4343 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4345 #define toolbar_set_orientation(w, o) \
4346 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4349 /* Attach a tool bar to frame F. */
4352 xg_pack_tool_bar (struct frame
*f
, Lisp_Object pos
)
4354 struct x_output
*x
= f
->output_data
.x
;
4355 bool into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4356 GtkWidget
*top_widget
= x
->toolbar_widget
;
4358 toolbar_set_orientation (x
->toolbar_widget
,
4360 ? GTK_ORIENTATION_VERTICAL
4361 : GTK_ORIENTATION_HORIZONTAL
);
4365 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), top_widget
,
4368 if (EQ (pos
, Qleft
))
4369 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4372 x
->toolbar_in_hbox
= true;
4376 bool vbox_pos
= x
->menubar_widget
!= 0;
4377 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), top_widget
,
4381 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4384 x
->toolbar_in_hbox
= false;
4386 x
->toolbar_is_packed
= true;
4389 static bool xg_update_tool_bar_sizes (struct frame
*f
);
4392 tb_size_cb (GtkWidget
*widget
,
4393 GdkRectangle
*allocation
,
4396 /* When tool bar is created it has one preferred size. But when size is
4397 allocated between widgets, it may get another. So we must update
4398 size hints if tool bar size changes. Seen on Fedora 18 at least. */
4399 struct frame
*f
= user_data
;
4401 if (xg_update_tool_bar_sizes (f
))
4403 frame_size_history_add (f
, Qtb_size_cb
, 0, 0, Qnil
);
4404 adjust_frame_size (f
, -1, -1, 5, 0, Qtool_bar_lines
);
4408 /* Create a tool bar for frame F. */
4411 xg_create_tool_bar (struct frame
*f
)
4413 struct x_output
*x
= f
->output_data
.x
;
4414 #if GTK_CHECK_VERSION (3, 3, 6)
4415 GtkStyleContext
*gsty
;
4417 struct xg_frame_tb_info
*tbinfo
4418 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4422 tbinfo
= xmalloc (sizeof (*tbinfo
));
4423 tbinfo
->last_tool_bar
= Qnil
;
4424 tbinfo
->style
= Qnil
;
4425 tbinfo
->hmargin
= tbinfo
->vmargin
= 0;
4426 tbinfo
->dir
= GTK_TEXT_DIR_NONE
;
4427 tbinfo
->n_last_items
= 0;
4428 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4433 x
->toolbar_widget
= gtk_toolbar_new ();
4435 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4437 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4438 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4439 g_signal_connect (x
->toolbar_widget
, "size-allocate",
4440 G_CALLBACK (tb_size_cb
), f
);
4441 #if GTK_CHECK_VERSION (3, 3, 6)
4442 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4443 gtk_style_context_add_class (gsty
, "primary-toolbar");
4448 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4450 /* Find the right-to-left image named by RTL in the tool bar images for F.
4451 Returns IMAGE if RTL is not found. */
4454 find_rtl_image (struct frame
*f
, Lisp_Object image
, Lisp_Object rtl
)
4457 Lisp_Object file
, rtl_name
;
4459 rtl_name
= Ffile_name_nondirectory (rtl
);
4461 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4463 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4464 if (!NILP (file
= file_for_image (rtl_image
)))
4466 file
= call1 (intern ("file-name-sans-extension"),
4467 Ffile_name_nondirectory (file
));
4468 if (! NILP (Fequal (file
, rtl_name
)))
4479 static GtkToolItem
*
4480 xg_make_tool_item (struct frame
*f
,
4482 GtkWidget
**wbutton
,
4484 int i
, bool horiz
, bool text_image
)
4486 GtkToolItem
*ti
= gtk_tool_item_new ();
4487 GtkWidget
*vb
= gtk_box_new (horiz
4488 ? GTK_ORIENTATION_HORIZONTAL
4489 : GTK_ORIENTATION_VERTICAL
,
4491 GtkWidget
*wb
= gtk_button_new ();
4492 /* The eventbox is here so we can have tooltips on disabled items. */
4493 GtkWidget
*weventbox
= gtk_event_box_new ();
4494 #if GTK_CHECK_VERSION (3, 3, 6)
4495 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4496 GtkStyleContext
*gsty
;
4498 gtk_css_provider_load_from_data (css_prov
,
4500 " background-color: transparent;"
4504 gsty
= gtk_widget_get_style_context (weventbox
);
4505 gtk_style_context_add_provider (gsty
,
4506 GTK_STYLE_PROVIDER (css_prov
),
4507 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4508 g_object_unref (css_prov
);
4511 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4513 if (wimage
&& !text_image
)
4514 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4516 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4517 if (wimage
&& text_image
)
4518 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4520 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4521 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4522 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4523 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4524 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4526 if (wimage
|| label
)
4529 gpointer gi
= (gpointer
) ii
;
4531 g_signal_connect (G_OBJECT (wb
), "clicked",
4532 G_CALLBACK (xg_tool_bar_callback
),
4535 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4538 /* Catch expose events to overcome an annoying redraw bug, see
4539 comment for xg_tool_bar_item_expose_callback. */
4540 g_signal_connect (G_OBJECT (ti
),
4542 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4545 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4547 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4548 no distinction based on modifiers in the activate callback,
4549 so we have to do it ourselves. */
4550 g_signal_connect (wb
, "button-release-event",
4551 G_CALLBACK (xg_tool_bar_button_cb
),
4554 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4556 /* Use enter/leave notify to show help. We use the events
4557 rather than the GtkButton specific signals "enter" and
4558 "leave", so we can have only one callback. The event
4559 will tell us what kind of event it is. */
4560 g_signal_connect (G_OBJECT (weventbox
),
4561 "enter-notify-event",
4562 G_CALLBACK (xg_tool_bar_help_callback
),
4564 g_signal_connect (G_OBJECT (weventbox
),
4565 "leave-notify-event",
4566 G_CALLBACK (xg_tool_bar_help_callback
),
4570 if (wbutton
) *wbutton
= wb
;
4576 is_box_type (GtkWidget
*vb
, bool is_horizontal
)
4580 if (GTK_IS_BOX (vb
))
4582 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4583 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4584 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4588 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4594 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4595 const char *icon_name
, const struct image
*img
,
4596 const char *label
, bool horiz
)
4600 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4601 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4603 /* Check if the tool icon matches. */
4604 if (stock_name
&& wimage
)
4606 old
= g_object_get_data (G_OBJECT (wimage
),
4607 XG_TOOL_BAR_STOCK_NAME
);
4608 if (!old
|| strcmp (old
, stock_name
))
4611 else if (icon_name
&& wimage
)
4613 old
= g_object_get_data (G_OBJECT (wimage
),
4614 XG_TOOL_BAR_ICON_NAME
);
4615 if (!old
|| strcmp (old
, icon_name
))
4620 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4621 XG_TOOL_BAR_IMAGE_DATA
);
4622 Pixmap old_img
= (Pixmap
) gold_img
;
4623 if (old_img
!= img
->pixmap
)
4627 /* Check button configuration and label. */
4628 if (is_box_type (vb
, horiz
)
4629 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4632 /* Ensure label is correct. */
4634 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4639 xg_update_tool_bar_sizes (struct frame
*f
)
4641 struct x_output
*x
= f
->output_data
.x
;
4643 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4644 GtkWidget
*top_widget
= x
->toolbar_widget
;
4646 gtk_widget_get_preferred_size (GTK_WIDGET (top_widget
), NULL
, &req
);
4647 if (x
->toolbar_in_hbox
)
4650 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4652 "position", &pos
, NULL
);
4653 if (pos
== 0) nl
= req
.width
;
4654 else nr
= req
.width
;
4659 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4661 "position", &pos
, NULL
);
4662 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4663 else nb
= req
.height
;
4666 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4667 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4668 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4669 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4671 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4672 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4673 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4674 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4675 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4676 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4685 find_icon_from_name (char *name
,
4686 GtkIconTheme
*icon_theme
,
4689 #if ! GTK_CHECK_VERSION (3, 10, 0)
4690 GtkStockItem stock_item
;
4693 if (name
[0] == 'n' && name
[1] == ':')
4695 *icon_name
= name
+ 2;
4698 if (! gtk_icon_theme_has_icon (icon_theme
, *icon_name
))
4702 #if ! GTK_CHECK_VERSION (3, 10, 0)
4703 else if (gtk_stock_lookup (name
, &stock_item
))
4706 else if (gtk_icon_theme_has_icon (icon_theme
, name
))
4721 /* Update the tool bar for frame F. Add new buttons and remove old. */
4724 update_frame_tool_bar (struct frame
*f
)
4727 struct x_output
*x
= f
->output_data
.x
;
4728 int hmargin
= 0, vmargin
= 0;
4729 GtkToolbar
*wtoolbar
;
4731 GtkTextDirection dir
;
4733 bool text_image
, horiz
;
4734 struct xg_frame_tb_info
*tbinfo
;
4736 GtkIconTheme
*icon_theme
;
4739 if (! FRAME_GTK_WIDGET (f
))
4744 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4746 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4747 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4749 else if (CONSP (Vtool_bar_button_margin
))
4751 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4752 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4754 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4755 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4758 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4759 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4760 i.e. zero. This means that margins less than
4761 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4762 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4763 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4765 if (! x
->toolbar_widget
)
4766 xg_create_tool_bar (f
);
4768 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4769 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4771 style
= Ftool_bar_get_system_style ();
4772 screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4773 icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4775 /* Are we up to date? */
4776 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4779 if (! NILP (tbinfo
->last_tool_bar
) && ! NILP (f
->tool_bar_items
)
4780 && tbinfo
->n_last_items
== f
->n_tool_bar_items
4781 && tbinfo
->hmargin
== hmargin
&& tbinfo
->vmargin
== vmargin
4782 && tbinfo
->dir
== dir
4783 && ! NILP (Fequal (tbinfo
->style
, style
))
4784 && ! NILP (Fequal (tbinfo
->last_tool_bar
, f
->tool_bar_items
)))
4790 tbinfo
->last_tool_bar
= f
->tool_bar_items
;
4791 tbinfo
->n_last_items
= f
->n_tool_bar_items
;
4792 tbinfo
->style
= style
;
4793 tbinfo
->hmargin
= hmargin
;
4794 tbinfo
->vmargin
= vmargin
;
4797 text_image
= EQ (style
, Qtext_image_horiz
);
4798 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4800 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4802 bool enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4803 bool selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4807 struct image
*img
= NULL
;
4809 Lisp_Object stock
= Qnil
;
4810 char *stock_name
= NULL
;
4811 char *icon_name
= NULL
;
4813 GtkWidget
*wbutton
= NULL
;
4814 Lisp_Object specified_file
;
4815 bool vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4817 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4818 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4819 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4822 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4824 /* If this is a separator, use a gtk separator item. */
4825 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4827 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4830 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4832 ti
= gtk_separator_tool_item_new ();
4833 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4839 /* Otherwise, the tool-bar item is an ordinary button. */
4841 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4843 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4847 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4849 /* Ignore invalid image specifications. */
4850 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4851 if (!valid_image_p (image
))
4854 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4859 specified_file
= file_for_image (image
);
4860 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4861 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4866 for (tem
= stock
; CONSP (tem
); tem
= XCDR (tem
))
4867 if (! NILP (tem
) && STRINGP (XCAR (tem
)))
4869 stock_name
= find_icon_from_name (SSDATA (XCAR (tem
)),
4872 if (stock_name
|| icon_name
) break;
4875 else if (STRINGP (stock
))
4877 stock_name
= find_icon_from_name (SSDATA (stock
),
4882 if (stock_name
|| icon_name
)
4883 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4885 if (stock_name
== NULL
&& icon_name
== NULL
)
4887 /* No stock image, or stock item not known. Try regular
4888 image. If image is a vector, choose it according to the
4890 if (dir
== GTK_TEXT_DIR_RTL
4891 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4893 image
= find_rtl_image (f
, image
, rtl
);
4895 if (VECTORP (image
))
4899 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4900 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4903 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4904 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4906 eassert (ASIZE (image
) >= idx
);
4907 image
= AREF (image
, idx
);
4912 img_id
= lookup_image (f
, image
);
4913 img
= IMAGE_FROM_ID (f
, img_id
);
4914 prepare_image_for_display (f
, img
);
4916 if (img
->load_failed_p
|| img
->pixmap
== None
)
4919 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4925 /* If there is an existing widget, check if it's stale; if so,
4926 remove it and make a new tool item from scratch. */
4927 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4930 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4939 /* Save the image so we can see if an update is needed the
4940 next time we call xg_tool_item_match_p. */
4941 if (EQ (style
, Qtext
))
4943 else if (stock_name
)
4946 #if GTK_CHECK_VERSION (3, 10, 0)
4947 w
= gtk_image_new_from_icon_name (stock_name
, icon_size
);
4949 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4951 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4952 (gpointer
) xstrdup (stock_name
),
4953 (GDestroyNotify
) xfree
);
4957 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4958 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4959 (gpointer
) xstrdup (icon_name
),
4960 (GDestroyNotify
) xfree
);
4964 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4965 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4966 (gpointer
)img
->pixmap
);
4969 #if GTK_CHECK_VERSION (3, 14, 0)
4972 gtk_widget_set_margin_start (w
, hmargin
);
4973 gtk_widget_set_margin_end (w
, hmargin
);
4974 gtk_widget_set_margin_top (w
, vmargin
);
4975 gtk_widget_set_margin_bottom (w
, vmargin
);
4978 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4980 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4981 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4986 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4990 /* Remove buttons not longer needed. */
4993 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4995 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4996 } while (ti
!= NULL
);
4998 if (f
->n_tool_bar_items
!= 0)
5000 if (! x
->toolbar_is_packed
)
5001 xg_pack_tool_bar (f
, FRAME_TOOL_BAR_POSITION (f
));
5002 gtk_widget_show_all (x
->toolbar_widget
);
5003 if (xg_update_tool_bar_sizes (f
))
5005 frame_size_history_add (f
, Qupdate_frame_tool_bar
, 0, 0, Qnil
);
5006 adjust_frame_size (f
, -1, -1, 2, 0, Qtool_bar_lines
);
5013 /* Deallocate all resources for the tool bar on frame F.
5014 Remove the tool bar. */
5017 free_frame_tool_bar (struct frame
*f
)
5019 struct x_output
*x
= f
->output_data
.x
;
5021 if (x
->toolbar_widget
)
5023 struct xg_frame_tb_info
*tbinfo
;
5024 GtkWidget
*top_widget
= x
->toolbar_widget
;
5027 if (x
->toolbar_is_packed
)
5029 if (x
->toolbar_in_hbox
)
5030 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
5033 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
5037 gtk_widget_destroy (x
->toolbar_widget
);
5039 x
->toolbar_widget
= 0;
5040 x
->toolbar_widget
= 0;
5041 x
->toolbar_is_packed
= false;
5042 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
5043 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
5045 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
5050 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
5055 frame_size_history_add (f
, Qfree_frame_tool_bar
, 0, 0, Qnil
);
5056 adjust_frame_size (f
, -1, -1, 2, 0, Qtool_bar_lines
);
5063 xg_change_toolbar_position (struct frame
*f
, Lisp_Object pos
)
5065 struct x_output
*x
= f
->output_data
.x
;
5066 GtkWidget
*top_widget
= x
->toolbar_widget
;
5068 if (! x
->toolbar_widget
|| ! top_widget
)
5072 g_object_ref (top_widget
);
5073 if (x
->toolbar_is_packed
)
5075 if (x
->toolbar_in_hbox
)
5076 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
5079 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
5083 xg_pack_tool_bar (f
, pos
);
5084 g_object_unref (top_widget
);
5086 if (xg_update_tool_bar_sizes (f
))
5088 frame_size_history_add (f
, Qxg_change_toolbar_position
, 0, 0, Qnil
);
5089 adjust_frame_size (f
, -1, -1, 2, 0, Qtool_bar_lines
);
5098 /***********************************************************************
5100 ***********************************************************************/
5102 xg_initialize (void)
5104 GtkBindingSet
*binding_set
;
5105 GtkSettings
*settings
;
5108 /* Work around a bug with corrupted data if libXft gets unloaded. This way
5109 we keep it permanently linked in. */
5114 xg_ignore_gtk_scrollbar
= 0;
5115 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
5116 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
5118 id_to_widget
.max_size
= id_to_widget
.used
= 0;
5119 id_to_widget
.widgets
= 0;
5121 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
5122 (gdk_display_get_default ()));
5123 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
5124 bindings. It doesn't seem to be any way to remove properties,
5125 so we set it to "" which in means "no key". */
5126 gtk_settings_set_string_property (settings
,
5127 "gtk-menu-bar-accel",
5131 /* Make GTK text input widgets use Emacs style keybindings. This is
5133 gtk_settings_set_string_property (settings
,
5134 "gtk-key-theme-name",
5138 /* Make dialogs close on C-g. Since file dialog inherits from
5139 dialog, this works for them also. */
5140 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
5141 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5144 /* Make menus close on C-g. */
5145 binding_set
= gtk_binding_set_by_class (g_type_class_ref
5146 (GTK_TYPE_MENU_SHELL
));
5147 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5149 update_theme_scrollbar_width ();
5150 update_theme_scrollbar_height ();
5152 #ifdef HAVE_FREETYPE
5153 x_last_font_name
= NULL
;
5157 #endif /* USE_GTK */