1 /* Functions for creating and updating GTK widgets.
3 Copyright (C) 2003-2015 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
30 #include "blockinput.h"
31 #include "syssignal.h"
35 #include "termhooks.h"
41 #include <gdk/gdkkeysyms.h>
42 #include "xsettings.h"
45 #include <X11/Xft/Xft.h>
50 #include "emacsgtkfixed.h"
53 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
54 #define gtk_widget_set_has_window(w, b) \
55 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
57 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
58 #define gtk_dialog_get_action_area(w) ((w)->action_area)
59 #define gtk_dialog_get_content_area(w) ((w)->vbox)
61 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
62 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
64 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
65 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
66 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
67 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
68 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
70 #if GTK_CHECK_VERSION (2, 12, 0)
71 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
73 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
76 #if ! GTK_CHECK_VERSION (2, 14, 0)
77 #define gtk_adjustment_configure(adj, xvalue, xlower, \
78 xupper, xstep_increment, \
79 xpage_increment, xpagesize) \
81 adj->lower = xlower; \
82 adj->upper = xupper; \
83 adj->page_size = xpagesize; \
84 gtk_adjustment_set_value (adj, xvalue); \
85 adj->page_increment = xpage_increment; \
86 adj->step_increment = xstep_increment; \
88 #endif /* < Gtk+ 2.14 */
91 #if GTK_CHECK_VERSION (3, 2, 0)
92 #define USE_NEW_GTK_FONT_CHOOSER 1
94 #define USE_NEW_GTK_FONT_CHOOSER 0
95 #define gtk_font_chooser_dialog_new(x, y) \
96 gtk_font_selection_dialog_new (x)
97 #undef GTK_FONT_CHOOSER
98 #define GTK_FONT_CHOOSER(x) GTK_FONT_SELECTION_DIALOG (x)
99 #define gtk_font_chooser_set_font(x, y) \
100 gtk_font_selection_dialog_set_font_name (x, y)
102 #endif /* HAVE_FREETYPE */
104 #if GTK_CHECK_VERSION (3, 10, 0)
105 #define XG_TEXT_CANCEL "Cancel"
106 #define XG_TEXT_OK "OK"
107 #define XG_TEXT_OPEN "Open"
109 #define XG_TEXT_CANCEL GTK_STOCK_CANCEL
110 #define XG_TEXT_OK GTK_STOCK_OK
111 #define XG_TEXT_OPEN GTK_STOCK_OPEN
115 #ifdef USE_GTK_TOOLTIP
116 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
118 #define gdk_window_get_geometry(w, a, b, c, d) \
119 gdk_window_get_geometry (w, a, b, c, d, 0)
120 #define gdk_x11_window_lookup_for_display(d, w) \
121 gdk_xid_table_lookup_for_display (d, w)
122 #define gtk_box_new(ori, spacing) \
123 ((ori) == GTK_ORIENTATION_HORIZONTAL \
124 ? gtk_hbox_new (FALSE, (spacing)) : gtk_vbox_new (FALSE, (spacing)))
125 #define gtk_scrollbar_new(ori, spacing) \
126 ((ori) == GTK_ORIENTATION_HORIZONTAL \
127 ? gtk_hscrollbar_new ((spacing)) : gtk_vscrollbar_new ((spacing)))
129 #define GDK_KEY_g GDK_g
131 #endif /* HAVE_GTK3 */
133 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
135 static void update_theme_scrollbar_width (void);
136 static void update_theme_scrollbar_height (void);
138 #define TB_INFO_KEY "xg_frame_tb_info"
139 struct xg_frame_tb_info
141 Lisp_Object last_tool_bar
;
144 int hmargin
, vmargin
;
145 GtkTextDirection dir
;
149 /***********************************************************************
150 Display handling functions
151 ***********************************************************************/
153 /* Keep track of the default display, or NULL if there is none. Emacs
154 may close all its displays. */
156 static GdkDisplay
*gdpy_def
;
158 /* When the GTK widget W is to be created on a display for F that
159 is not the default display, set the display for W.
160 W can be a GtkMenu or a GtkWindow widget. */
163 xg_set_screen (GtkWidget
*w
, struct frame
*f
)
165 if (FRAME_X_DISPLAY (f
) != DEFAULT_GDK_DISPLAY ())
167 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
168 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
171 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
173 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
178 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
179 *DPY is set to NULL if the display can't be opened.
181 Returns non-zero if display could be opened, zero if display could not
182 be opened, and less than zero if the GTK version doesn't support
183 multiple displays. */
186 xg_display_open (char *display_name
, Display
**dpy
)
190 unrequest_sigio (); // See comment in x_display_ok, xterm.c.
191 gdpy
= gdk_display_open (display_name
);
193 if (!gdpy_def
&& gdpy
)
196 gdk_display_manager_set_default_display (gdk_display_manager_get (),
200 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
204 /* Close display DPY. */
207 xg_display_close (Display
*dpy
)
209 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
211 /* If this is the default display, try to change it before closing.
212 If there is no other display to use, gdpy_def is set to NULL, and
213 the next call to xg_display_open resets the default display. */
214 if (gdk_display_get_default () == gdpy
)
216 struct x_display_info
*dpyinfo
;
217 GdkDisplay
*gdpy_new
= NULL
;
219 /* Find another display. */
220 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
221 if (dpyinfo
->display
!= dpy
)
223 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
224 gdk_display_manager_set_default_display (gdk_display_manager_get (),
231 #if GTK_CHECK_VERSION (2, 0, 0) && ! GTK_CHECK_VERSION (2, 10, 0)
232 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
233 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
234 can continue running, but there will be memory leaks. */
235 g_object_run_dispose (G_OBJECT (gdpy
));
237 /* This seems to be fixed in GTK 2.10. */
238 gdk_display_close (gdpy
);
243 /***********************************************************************
245 ***********************************************************************/
247 /* Create and return the cursor to be used for popup menus and
248 scroll bars on display DPY. */
251 xg_create_default_cursor (Display
*dpy
)
253 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
254 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
258 xg_get_pixbuf_from_pixmap (struct frame
*f
, Pixmap pix
)
263 unsigned int width
, height
, uunused
;
266 XGetGeometry (FRAME_X_DISPLAY (f
), pix
, &wunused
, &iunused
, &iunused
,
267 &width
, &height
, &uunused
, &uunused
);
269 xim
= XGetImage (FRAME_X_DISPLAY (f
), pix
, 0, 0, width
, height
,
273 tmp_buf
= gdk_pixbuf_new_from_data ((guchar
*) xim
->data
,
286 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
289 xg_get_pixbuf_from_pix_and_mask (struct frame
*f
,
294 GdkPixbuf
*icon_buf
, *tmp_buf
;
296 tmp_buf
= xg_get_pixbuf_from_pixmap (f
, pix
);
297 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
298 g_object_unref (G_OBJECT (tmp_buf
));
300 width
= gdk_pixbuf_get_width (icon_buf
);
301 height
= gdk_pixbuf_get_height (icon_buf
);
305 GdkPixbuf
*mask_buf
= xg_get_pixbuf_from_pixmap (f
, mask
);
306 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
307 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
308 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
309 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
312 for (y
= 0; y
< height
; ++y
)
314 guchar
*iconptr
, *maskptr
;
317 iconptr
= pixels
+ y
* rowstride
;
318 maskptr
= mask_pixels
+ y
* mask_rowstride
;
320 for (x
= 0; x
< width
; ++x
)
322 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
323 just R is sufficient. */
325 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
327 iconptr
+= rowstride
/width
;
328 maskptr
+= mask_rowstride
/width
;
332 g_object_unref (G_OBJECT (mask_buf
));
339 file_for_image (Lisp_Object image
)
341 Lisp_Object specified_file
= Qnil
;
344 for (tail
= XCDR (image
);
345 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
346 tail
= XCDR (XCDR (tail
)))
347 if (EQ (XCAR (tail
), QCfile
))
348 specified_file
= XCAR (XCDR (tail
));
350 return specified_file
;
353 /* For the image defined in IMG, make and return a GtkImage. For displays with
354 8 planes or less we must make a GdkPixbuf and apply the mask manually.
355 Otherwise the highlighting and dimming the tool bar code in GTK does
356 will look bad. For display with more than 8 planes we just use the
357 pixmap and mask directly. For monochrome displays, GTK doesn't seem
358 able to use external pixmaps, it looks bad whatever we do.
359 The image is defined on the display where frame F is.
360 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
361 If OLD_WIDGET is NULL, a new widget is constructed and returned.
362 If OLD_WIDGET is not NULL, that widget is modified. */
365 xg_get_image_for_pixmap (struct frame
*f
,
368 GtkImage
*old_widget
)
372 /* If we have a file, let GTK do all the image handling.
373 This seems to be the only way to make insensitive and activated icons
374 look good in all cases. */
375 Lisp_Object specified_file
= file_for_image (img
->spec
);
378 /* We already loaded the image once before calling this
379 function, so this only fails if the image file has been removed.
380 In that case, use the pixmap already loaded. */
382 if (STRINGP (specified_file
)
383 && STRINGP (file
= x_find_image_file (specified_file
)))
385 char *encoded_file
= SSDATA (ENCODE_FILE (file
));
387 old_widget
= GTK_IMAGE (gtk_image_new_from_file (encoded_file
));
389 gtk_image_set_from_file (old_widget
, encoded_file
);
391 return GTK_WIDGET (old_widget
);
394 /* No file, do the image handling ourselves. This will look very bad
395 on a monochrome display, and sometimes bad on all displays with
398 /* This is a workaround to make icons look good on pseudo color
399 displays. Apparently GTK expects the images to have an alpha
400 channel. If they don't, insensitive and activated icons will
401 look bad. This workaround does not work on monochrome displays,
402 and is strictly not needed on true color/static color displays (i.e.
403 16 bits and higher). But we do it anyway so we get a pixbuf that is
404 not associated with the img->pixmap. The img->pixmap may be removed
405 by clearing the image cache and then the tool bar redraw fails, since
406 Gtk+ assumes the pixmap is always there. */
407 icon_buf
= xg_get_pixbuf_from_pix_and_mask (f
, img
->pixmap
, img
->mask
);
412 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
414 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
416 g_object_unref (G_OBJECT (icon_buf
));
419 return GTK_WIDGET (old_widget
);
423 /* Set CURSOR on W and all widgets W contain. We must do like this
424 for scroll bars and menu because they create widgets internally,
425 and it is those widgets that are visible. */
428 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
430 GdkWindow
*window
= gtk_widget_get_window (w
);
431 GList
*children
= gdk_window_peek_children (window
);
433 gdk_window_set_cursor (window
, cursor
);
435 /* The scroll bar widget has more than one GDK window (had to look at
436 the source to figure this out), and there is no way to set cursor
437 on widgets in GTK. So we must set the cursor for all GDK windows.
440 for ( ; children
; children
= g_list_next (children
))
441 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
444 /* Insert NODE into linked LIST. */
447 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
449 xg_list_node
*list_start
= list
->next
;
451 if (list_start
) list_start
->prev
= node
;
452 node
->next
= list_start
;
457 /* Remove NODE from linked LIST. */
460 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
462 xg_list_node
*list_start
= list
->next
;
463 if (node
== list_start
)
465 list
->next
= node
->next
;
466 if (list
->next
) list
->next
->prev
= 0;
470 node
->prev
->next
= node
->next
;
471 if (node
->next
) node
->next
->prev
= node
->prev
;
475 /* Allocate and return a utf8 version of STR. If STR is already
476 utf8 or NULL, just return a copy of STR.
477 A new string is allocated and the caller must free the result
481 get_utf8_string (const char *str
)
485 if (!str
) return NULL
;
487 /* If not UTF-8, try current locale. */
488 if (!g_utf8_validate (str
, -1, NULL
))
489 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
491 return g_strdup (str
);
495 /* Probably some control characters in str. Escape them. */
497 ptrdiff_t nr_bad
= 0;
500 unsigned char *p
= (unsigned char *)str
;
504 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
505 &bytes_written
, &err
))
506 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
509 p
+= bytes_written
+1;
522 if ((min (PTRDIFF_MAX
, SIZE_MAX
) - len
- 1) / 4 < nr_bad
)
523 memory_full (SIZE_MAX
);
524 up
= utf8_str
= xmalloc (len
+ nr_bad
* 4 + 1);
525 p
= (unsigned char *)str
;
527 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
528 &bytes_written
, &err
))
529 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
531 memcpy (up
, p
, bytes_written
);
533 up
+= sprintf (up
, "\\%03o", p
[bytes_written
]);
534 p
+= bytes_written
+ 1;
553 /* Check for special colors used in face spec for region face.
554 The colors are fetched from the Gtk+ theme.
555 Return true if color was found, false if not. */
558 xg_check_special_colors (struct frame
*f
,
559 const char *color_name
,
563 bool get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
564 bool get_fg
= !get_bg
&& strcmp ("gtk_selection_fg_color", color_name
) == 0;
566 if (! FRAME_GTK_WIDGET (f
) || ! (get_bg
|| get_fg
))
572 GtkStyleContext
*gsty
573 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f
));
575 char buf
[sizeof "rgb://rrrr/gggg/bbbb"];
576 int state
= GTK_STATE_FLAG_SELECTED
|GTK_STATE_FLAG_FOCUSED
;
578 gtk_style_context_get_color (gsty
, state
, &col
);
580 gtk_style_context_get_background_color (gsty
, state
, &col
);
582 sprintf (buf
, "rgb:%04x/%04x/%04x",
583 (unsigned) (col
.red
* 65535),
584 (unsigned) (col
.green
* 65535),
585 (unsigned) (col
.blue
* 65535));
586 success_p
= x_parse_color (f
, buf
, color
) != 0;
588 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
589 GdkColor
*grgb
= get_bg
590 ? &gsty
->bg
[GTK_STATE_SELECTED
]
591 : &gsty
->fg
[GTK_STATE_SELECTED
];
593 color
->red
= grgb
->red
;
594 color
->green
= grgb
->green
;
595 color
->blue
= grgb
->blue
;
596 color
->pixel
= grgb
->pixel
;
607 /***********************************************************************
609 ***********************************************************************/
610 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
611 We use that to pop down the tooltip. This happens if Gtk+ for some
612 reason wants to change or hide the tooltip. */
614 #ifdef USE_GTK_TOOLTIP
617 hierarchy_ch_cb (GtkWidget
*widget
,
618 GtkWidget
*previous_toplevel
,
621 struct frame
*f
= user_data
;
622 struct x_output
*x
= f
->output_data
.x
;
623 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
625 if (! top
|| ! GTK_IS_WINDOW (top
))
626 gtk_widget_hide (previous_toplevel
);
629 /* Callback called when Gtk+ thinks a tooltip should be displayed.
630 We use it to get the tooltip window and the tooltip widget so
631 we can manipulate the ourselves.
633 Return FALSE ensures that the tooltip is not shown. */
636 qttip_cb (GtkWidget
*widget
,
639 gboolean keyboard_mode
,
643 struct frame
*f
= user_data
;
644 struct x_output
*x
= f
->output_data
.x
;
645 if (x
->ttip_widget
== NULL
)
650 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
651 x
->ttip_widget
= tooltip
;
652 g_object_ref (G_OBJECT (tooltip
));
653 x
->ttip_lbl
= gtk_label_new ("");
654 g_object_ref (G_OBJECT (x
->ttip_lbl
));
655 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
656 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
658 /* Change stupid Gtk+ default line wrapping. */
659 p
= gtk_widget_get_parent (x
->ttip_lbl
);
660 list
= gtk_container_get_children (GTK_CONTAINER (p
));
661 for (iter
= list
; iter
; iter
= g_list_next (iter
))
663 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
664 if (GTK_IS_LABEL (w
))
665 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
669 /* ATK needs an empty title for some reason. */
670 gtk_window_set_title (x
->ttip_window
, "");
671 /* Realize so we can safely get screen later on. */
672 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
673 gtk_widget_realize (x
->ttip_lbl
);
675 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
676 G_CALLBACK (hierarchy_ch_cb
), f
);
681 #endif /* USE_GTK_TOOLTIP */
683 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
684 Return true if a system tooltip is available. */
687 xg_prepare_tooltip (struct frame
*f
,
692 #ifndef USE_GTK_TOOLTIP
695 struct x_output
*x
= f
->output_data
.x
;
699 GtkSettings
*settings
;
700 gboolean tt_enabled
= TRUE
;
702 Lisp_Object encoded_string
;
704 if (!x
->ttip_lbl
) return 0;
707 encoded_string
= ENCODE_UTF_8 (string
);
708 widget
= GTK_WIDGET (x
->ttip_lbl
);
709 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
710 screen
= gdk_window_get_screen (gwin
);
711 settings
= gtk_settings_get_for_screen (screen
);
712 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
715 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
716 /* Record that we disabled it so it can be enabled again. */
717 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
721 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
722 g_object_set_data (G_OBJECT
723 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
724 "gdk-display-current-tooltip", NULL
);
726 /* Put our dummy widget in so we can get callbacks for unrealize and
727 hierarchy-changed. */
728 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
729 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
730 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
731 if (width
) *width
= req
.width
;
732 if (height
) *height
= req
.height
;
737 #endif /* USE_GTK_TOOLTIP */
740 /* Show the tooltip at ROOT_X and ROOT_Y.
741 xg_prepare_tooltip must have been called before this function. */
744 xg_show_tooltip (struct frame
*f
, int root_x
, int root_y
)
746 #ifdef USE_GTK_TOOLTIP
747 struct x_output
*x
= f
->output_data
.x
;
751 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
752 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
758 /* Hide tooltip if shown. Do nothing if not shown.
759 Return true if tip was hidden, false if not (i.e. not using
763 xg_hide_tooltip (struct frame
*f
)
766 #ifdef USE_GTK_TOOLTIP
767 if (f
->output_data
.x
->ttip_window
)
769 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
771 gtk_widget_hide (GTK_WIDGET (win
));
773 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
775 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
776 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
777 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
778 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
789 /***********************************************************************
790 General functions for creating widgets, resizing, events, e.t.c.
791 ***********************************************************************/
794 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
795 const gchar
*msg
, gpointer user_data
)
797 if (!strstr (msg
, "visible children"))
798 fprintf (stderr
, "XX %s-WARNING **: %s\n", log_domain
, msg
);
801 /* Make a geometry string and pass that to GTK. It seems this is the
802 only way to get geometry position right if the user explicitly
803 asked for a position when starting Emacs.
804 F is the frame we shall set geometry for. */
807 xg_set_geometry (struct frame
*f
)
809 if (f
->size_hint_flags
& (USPosition
| PPosition
))
811 int left
= f
->left_pos
;
812 int xneg
= f
->size_hint_flags
& XNegative
;
813 int top
= f
->top_pos
;
814 int yneg
= f
->size_hint_flags
& YNegative
;
815 char geom_str
[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
823 sprintf (geom_str
, "=%dx%d%c%d%c%d",
824 FRAME_PIXEL_WIDTH (f
),
825 FRAME_PIXEL_HEIGHT (f
),
826 (xneg
? '-' : '+'), left
,
827 (yneg
? '-' : '+'), top
);
829 /* Silence warning about visible children. */
830 id
= g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
831 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
833 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
835 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
837 g_log_remove_handler ("Gtk", id
);
841 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
842 and use a GtkFixed widget, this doesn't happen automatically. */
845 xg_clear_under_internal_border (struct frame
*f
)
847 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
850 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
852 gtk_widget_queue_draw (wfixed
);
853 gdk_window_process_all_updates ();
855 x_clear_area (f
, 0, 0,
856 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
858 x_clear_area (f
, 0, 0,
859 FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
862 FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
863 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
866 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
867 0, FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
872 xg_get_gdk_scale (void)
874 const char *sscale
= getenv ("GDK_SCALE");
878 long scale
= atol (sscale
);
880 return min (scale
, INT_MAX
);
886 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
887 and a Gtk+ menu bar, we get resize events for the edit part of the
888 frame only. We let Gtk+ deal with the Gtk+ parts.
889 F is the frame to resize.
890 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
893 xg_frame_resized (struct frame
*f
, int pixelwidth
, int pixelheight
)
897 if (pixelwidth
== -1 && pixelheight
== -1)
899 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
900 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
901 0, 0, &pixelwidth
, &pixelheight
);
906 width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, pixelwidth
);
907 height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelheight
);
909 frame_size_history_add
910 (f
, Qxg_frame_resized
, width
, height
, Qnil
);
912 if (width
!= FRAME_TEXT_WIDTH (f
)
913 || height
!= FRAME_TEXT_HEIGHT (f
)
914 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
915 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
917 xg_clear_under_internal_border (f
);
918 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
919 SET_FRAME_GARBAGED (f
);
920 cancel_mouse_face (f
);
924 /* Resize the outer window of frame F after changing the height.
925 COLUMNS/ROWS is the size the edit area shall have after the resize. */
928 xg_frame_set_char_size (struct frame
*f
, int width
, int height
)
930 int pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
931 int pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
932 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
933 gint gwidth
, gheight
;
935 = pixelheight
+ FRAME_TOOLBAR_HEIGHT (f
) + FRAME_MENUBAR_HEIGHT (f
);
936 int totalwidth
= pixelwidth
+ FRAME_TOOLBAR_WIDTH (f
);
938 if (FRAME_PIXEL_HEIGHT (f
) == 0)
941 gtk_window_get_size (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
944 /* Do this before resize, as we don't know yet if we will be resized. */
945 xg_clear_under_internal_border (f
);
947 if (FRAME_VISIBLE_P (f
))
949 int scale
= xg_get_gdk_scale ();
950 totalheight
/= scale
;
954 x_wm_set_size_hint (f
, 0, 0);
956 /* Resize the top level widget so rows and columns remain constant.
958 When the frame is fullheight and we only want to change the width
959 or it is fullwidth and we only want to change the height we should
960 be able to preserve the fullscreen property. However, due to the
961 fact that we have to send a resize request anyway, the window
962 manager will abolish it. At least the respective size should
963 remain unchanged but giving the frame back its normal size will
965 if (EQ (fullscreen
, Qfullwidth
) && width
== FRAME_TEXT_WIDTH (f
))
967 frame_size_history_add
968 (f
, Qxg_frame_set_char_size_1
, width
, height
,
969 list2 (make_number (gheight
), make_number (totalheight
)));
971 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
972 gwidth
, totalheight
);
974 else if (EQ (fullscreen
, Qfullheight
) && height
== FRAME_TEXT_HEIGHT (f
))
976 frame_size_history_add
977 (f
, Qxg_frame_set_char_size_2
, width
, height
,
978 list2 (make_number (gwidth
), make_number (totalwidth
)));
980 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
981 totalwidth
, gheight
);
985 frame_size_history_add
986 (f
, Qxg_frame_set_char_size_3
, width
, height
,
987 list2 (make_number (totalwidth
), make_number (totalheight
)));
989 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
990 totalwidth
, totalheight
);
994 SET_FRAME_GARBAGED (f
);
995 cancel_mouse_face (f
);
997 /* We can not call change_frame_size for a mapped frame,
998 we can not set pixel width/height either. The window manager may
999 override our resize request, XMonad does this all the time.
1000 The best we can do is try to sync, so lisp code sees the updated
1001 size as fast as possible.
1002 For unmapped windows, we can set rows/cols. When
1003 the frame is mapped again we will (hopefully) get the correct size. */
1004 if (FRAME_VISIBLE_P (f
))
1006 /* Must call this to flush out events */
1007 (void)gtk_events_pending ();
1009 x_wait_for_event (f
, ConfigureNotify
);
1011 if (!NILP (fullscreen
))
1012 /* Try to restore fullscreen state. */
1014 store_frame_param (f
, Qfullscreen
, fullscreen
);
1015 x_set_fullscreen (f
, fullscreen
, fullscreen
);
1019 adjust_frame_size (f
, width
, height
, 5, 0, Qxg_frame_set_char_size
);
1023 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
1024 The policy is to keep the number of editable lines. */
1028 xg_height_or_width_changed (struct frame
*f
)
1030 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1031 FRAME_TOTAL_PIXEL_WIDTH (f
),
1032 FRAME_TOTAL_PIXEL_HEIGHT (f
));
1033 f
->output_data
.x
->hint_flags
= 0;
1034 x_wm_set_size_hint (f
, 0, 0);
1038 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
1039 Must be done like this, because GtkWidget:s can have "hidden"
1040 X Window that aren't accessible.
1042 Return 0 if no widget match WDESC. */
1045 xg_win_to_widget (Display
*dpy
, Window wdesc
)
1048 GtkWidget
*gwdesc
= 0;
1052 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
1057 event
.any
.window
= gdkwin
;
1058 event
.any
.type
= GDK_NOTHING
;
1059 gwdesc
= gtk_get_event_widget (&event
);
1066 /* Set the background of widget W to PIXEL. */
1069 xg_set_widget_bg (struct frame
*f
, GtkWidget
*w
, unsigned long pixel
)
1075 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
1077 bg
.red
= (double)xbg
.red
/65535.0;
1078 bg
.green
= (double)xbg
.green
/65535.0;
1079 bg
.blue
= (double)xbg
.blue
/65535.0;
1081 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
1085 GdkColormap
*map
= gtk_widget_get_colormap (w
);
1086 gdk_colormap_query_color (map
, pixel
, &bg
);
1087 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
1091 /* Callback called when the gtk theme changes.
1092 We notify lisp code so it can fix faces used for region for example. */
1095 style_changed_cb (GObject
*go
,
1099 struct input_event event
;
1100 GdkDisplay
*gdpy
= user_data
;
1101 const char *display_name
= gdk_display_get_name (gdpy
);
1102 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1105 event
.kind
= CONFIG_CHANGED_EVENT
;
1106 event
.frame_or_window
= build_string (display_name
);
1107 /* Theme doesn't change often, so intern is called seldom. */
1108 event
.arg
= intern ("theme-name");
1109 kbd_buffer_store_event (&event
);
1111 update_theme_scrollbar_width ();
1112 update_theme_scrollbar_height ();
1114 /* If scroll bar width changed, we need set the new size on all frames
1118 Lisp_Object rest
, frame
;
1119 FOR_EACH_FRAME (rest
, frame
)
1121 struct frame
*f
= XFRAME (frame
);
1122 if (FRAME_LIVE_P (f
)
1124 && FRAME_X_DISPLAY (f
) == dpy
)
1126 x_set_scroll_bar_default_width (f
);
1127 x_set_scroll_bar_default_height (f
);
1128 xg_frame_set_char_size (f
, FRAME_TEXT_WIDTH (f
), FRAME_TEXT_HEIGHT (f
));
1134 /* Called when a delete-event occurs on WIDGET. */
1137 delete_cb (GtkWidget
*widget
,
1144 /* Create and set up the GTK widgets for frame F.
1145 Return true if creation succeeded. */
1148 xg_create_frame_widgets (struct frame
*f
)
1151 GtkWidget
*wvbox
, *whbox
;
1160 if (FRAME_X_EMBEDDED_P (f
))
1162 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1163 wtop
= gtk_plug_new_for_display (gdpy
, f
->output_data
.x
->parent_desc
);
1166 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1168 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1169 has backported it to Gtk+ 2.0 and they add the resize grip for
1170 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1171 forever, so disable the grip. */
1172 #if (! GTK_CHECK_VERSION (3, 0, 0) \
1173 && defined HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1174 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop
), FALSE
);
1177 xg_set_screen (wtop
, f
);
1179 wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1180 whbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1181 gtk_box_set_homogeneous (GTK_BOX (wvbox
), FALSE
);
1182 gtk_box_set_homogeneous (GTK_BOX (whbox
), FALSE
);
1185 wfixed
= emacs_fixed_new (f
);
1187 wfixed
= gtk_fixed_new ();
1190 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1192 if (wtop
) gtk_widget_destroy (wtop
);
1193 if (wvbox
) gtk_widget_destroy (wvbox
);
1194 if (whbox
) gtk_widget_destroy (whbox
);
1195 if (wfixed
) gtk_widget_destroy (wfixed
);
1201 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1202 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1203 gtk_widget_set_name (wvbox
, "pane");
1204 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1206 /* If this frame has a title or name, set it in the title bar. */
1207 if (! NILP (f
->title
))
1208 title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1209 else if (! NILP (f
->name
))
1210 title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1212 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1214 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1215 FRAME_GTK_WIDGET (f
) = wfixed
;
1216 f
->output_data
.x
->vbox_widget
= wvbox
;
1217 f
->output_data
.x
->hbox_widget
= whbox
;
1219 gtk_widget_set_has_window (wfixed
, TRUE
);
1221 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1222 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1223 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1225 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1226 update_frame_tool_bar (f
);
1228 /* We don't want this widget double buffered, because we draw on it
1229 with regular X drawing primitives, so from a GTK/GDK point of
1230 view, the widget is totally blank. When an expose comes, this
1231 will make the widget blank, and then Emacs redraws it. This flickers
1232 a lot, so we turn off double buffering. */
1233 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1235 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1236 SSDATA (Vx_resource_name
),
1237 SSDATA (Vx_resource_class
));
1239 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1240 GTK is to destroy the widget. We want Emacs to do that instead. */
1241 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1242 G_CALLBACK (delete_cb
), f
);
1244 /* Convert our geometry parameters into a geometry string
1246 GTK will itself handle calculating the real position this way. */
1247 xg_set_geometry (f
);
1249 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1251 gtk_widget_add_events (wfixed
,
1252 GDK_POINTER_MOTION_MASK
1254 | GDK_BUTTON_PRESS_MASK
1255 | GDK_BUTTON_RELEASE_MASK
1256 | GDK_KEY_PRESS_MASK
1257 | GDK_ENTER_NOTIFY_MASK
1258 | GDK_LEAVE_NOTIFY_MASK
1259 | GDK_FOCUS_CHANGE_MASK
1260 | GDK_STRUCTURE_MASK
1261 | GDK_VISIBILITY_NOTIFY_MASK
);
1263 /* Must realize the windows so the X window gets created. It is used
1264 by callers of this function. */
1265 gtk_widget_realize (wfixed
);
1266 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1268 /* Since GTK clears its window by filling with the background color,
1269 we must keep X and GTK background in sync. */
1270 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1273 /* Also, do not let any background pixmap to be set, this looks very
1274 bad as Emacs overwrites the background pixmap with its own idea
1275 of background color. */
1276 style
= gtk_widget_get_modifier_style (wfixed
);
1278 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1279 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1280 gtk_widget_modify_style (wfixed
, style
);
1282 gtk_widget_set_can_focus (wfixed
, TRUE
);
1283 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1286 #ifdef USE_GTK_TOOLTIP
1287 /* Steal a tool tip window we can move ourselves. */
1288 f
->output_data
.x
->ttip_widget
= 0;
1289 f
->output_data
.x
->ttip_lbl
= 0;
1290 f
->output_data
.x
->ttip_window
= 0;
1291 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1292 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1296 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1297 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1298 /* Only connect this signal once per screen. */
1299 if (! g_signal_handler_find (G_OBJECT (gs
),
1300 G_SIGNAL_MATCH_FUNC
,
1302 G_CALLBACK (style_changed_cb
),
1305 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1306 G_CALLBACK (style_changed_cb
),
1307 gdk_screen_get_display (screen
));
1317 xg_free_frame_widgets (struct frame
*f
)
1319 if (FRAME_GTK_OUTER_WIDGET (f
))
1321 #ifdef USE_GTK_TOOLTIP
1322 struct x_output
*x
= f
->output_data
.x
;
1324 struct xg_frame_tb_info
*tbinfo
1325 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
1330 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1331 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1332 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1333 #ifdef USE_GTK_TOOLTIP
1335 gtk_widget_destroy (x
->ttip_lbl
);
1337 g_object_unref (G_OBJECT (x
->ttip_widget
));
1342 /* Set the normal size hints for the window manager, for frame F.
1343 FLAGS is the flags word to use--or 0 meaning preserve the flags
1344 that the window now has.
1345 If USER_POSITION, set the User Position
1346 flag (this is useful when FLAGS is 0). */
1349 x_wm_set_size_hint (struct frame
*f
, long int flags
, bool user_position
)
1351 /* Must use GTK routines here, otherwise GTK resets the size hints
1352 to its own defaults. */
1353 GdkGeometry size_hints
;
1354 gint hint_flags
= 0;
1355 int base_width
, base_height
;
1356 int min_rows
= 0, min_cols
= 0;
1357 int win_gravity
= f
->win_gravity
;
1358 Lisp_Object fs_state
, frame
;
1359 int scale
= xg_get_gdk_scale ();
1361 /* Don't set size hints during initialization; that apparently leads
1362 to a race condition. See the thread at
1363 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1364 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1367 XSETFRAME (frame
, f
);
1368 fs_state
= Fframe_parameter (frame
, Qfullscreen
);
1369 if ((EQ (fs_state
, Qmaximized
) || EQ (fs_state
, Qfullboth
)) &&
1370 (x_wm_supports (f
, FRAME_DISPLAY_INFO (f
)->Xatom_net_wm_state
) ||
1371 x_wm_supports (f
, FRAME_DISPLAY_INFO (f
)->Xatom_net_wm_state_fullscreen
)))
1373 /* Don't set hints when maximized or fullscreen. Apparently KWin and
1374 Gtk3 don't get along and the frame shrinks (!).
1381 memset (&size_hints
, 0, sizeof (size_hints
));
1382 f
->output_data
.x
->size_hints
= size_hints
;
1383 f
->output_data
.x
->hint_flags
= hint_flags
;
1386 flags
= f
->size_hint_flags
;
1388 size_hints
= f
->output_data
.x
->size_hints
;
1389 hint_flags
= f
->output_data
.x
->hint_flags
;
1391 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1392 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
1393 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
1395 hint_flags
|= GDK_HINT_BASE_SIZE
;
1396 /* Use one row/col here so base_height/width does not become zero.
1397 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it.
1398 Obviously this makes the row/col value displayed off by 1. */
1399 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 1) + FRAME_TOOLBAR_WIDTH (f
);
1400 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 1)
1401 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1403 if (min_cols
> 0) --min_cols
; /* We used one col in base_width = ... 1); */
1404 if (min_rows
> 0) --min_rows
; /* We used one row in base_height = ... 1); */
1406 size_hints
.base_width
= base_width
;
1407 size_hints
.base_height
= base_height
;
1408 size_hints
.min_width
= base_width
+ min_cols
* FRAME_COLUMN_WIDTH (f
);
1409 size_hints
.min_height
= base_height
+ min_rows
* FRAME_LINE_HEIGHT (f
);
1411 /* These currently have a one to one mapping with the X values, but I
1412 don't think we should rely on that. */
1413 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1414 size_hints
.win_gravity
= 0;
1415 if (win_gravity
== NorthWestGravity
)
1416 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1417 else if (win_gravity
== NorthGravity
)
1418 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1419 else if (win_gravity
== NorthEastGravity
)
1420 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1421 else if (win_gravity
== WestGravity
)
1422 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1423 else if (win_gravity
== CenterGravity
)
1424 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1425 else if (win_gravity
== EastGravity
)
1426 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1427 else if (win_gravity
== SouthWestGravity
)
1428 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1429 else if (win_gravity
== SouthGravity
)
1430 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1431 else if (win_gravity
== SouthEastGravity
)
1432 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1433 else if (win_gravity
== StaticGravity
)
1434 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1438 hint_flags
&= ~GDK_HINT_POS
;
1439 hint_flags
|= GDK_HINT_USER_POS
;
1442 size_hints
.base_width
/= scale
;
1443 size_hints
.base_height
/= scale
;
1444 size_hints
.width_inc
/= scale
;
1445 size_hints
.height_inc
/= scale
;
1447 if (hint_flags
!= f
->output_data
.x
->hint_flags
1448 || memcmp (&size_hints
,
1449 &f
->output_data
.x
->size_hints
,
1450 sizeof (size_hints
)) != 0)
1453 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1454 NULL
, &size_hints
, hint_flags
);
1455 f
->output_data
.x
->size_hints
= size_hints
;
1456 f
->output_data
.x
->hint_flags
= hint_flags
;
1461 /* Change background color of a frame.
1462 Since GTK uses the background color to clear the window, we must
1463 keep the GTK and X colors in sync.
1464 F is the frame to change,
1465 BG is the pixel value to change to. */
1468 xg_set_background_color (struct frame
*f
, unsigned long bg
)
1470 if (FRAME_GTK_WIDGET (f
))
1473 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1479 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1480 functions so GTK does not overwrite the icon. */
1483 xg_set_frame_icon (struct frame
*f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1485 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1489 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1494 /***********************************************************************
1496 ***********************************************************************/
1497 /* Return the dialog title to use for a dialog of type KEY.
1498 This is the encoding used by lwlib. We use the same for GTK. */
1501 get_dialog_title (char key
)
1503 const char *title
= "";
1511 title
= "Information";
1530 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1531 the dialog, but return TRUE so the event does not propagate further
1532 in GTK. This prevents GTK from destroying the dialog widget automatically
1533 and we can always destroy the widget manually, regardless of how
1534 it was popped down (button press or WM_DELETE_WINDOW).
1535 W is the dialog widget.
1536 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1537 user_data is NULL (not used).
1539 Returns TRUE to end propagation of event. */
1542 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1544 gtk_widget_unmap (w
);
1548 /* Create a popup dialog window. See also xg_create_widget below.
1549 WV is a widget_value describing the dialog.
1550 SELECT_CB is the callback to use when a button has been pressed.
1551 DEACTIVATE_CB is the callback to use when the dialog pops down.
1553 Returns the GTK dialog widget. */
1556 create_dialog (widget_value
*wv
,
1557 GCallback select_cb
,
1558 GCallback deactivate_cb
)
1560 const char *title
= get_dialog_title (wv
->name
[0]);
1561 int total_buttons
= wv
->name
[1] - '0';
1562 int right_buttons
= wv
->name
[4] - '0';
1565 int button_spacing
= 10;
1566 GtkWidget
*wdialog
= gtk_dialog_new ();
1567 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1569 GtkWidget
*whbox_down
;
1571 /* If the number of buttons is greater than 4, make two rows of buttons
1572 instead. This looks better. */
1573 bool make_two_rows
= total_buttons
> 4;
1575 #if GTK_CHECK_VERSION (3, 12, 0)
1576 GtkBuilder
*gbld
= gtk_builder_new ();
1577 GObject
*go
= gtk_buildable_get_internal_child (GTK_BUILDABLE (wd
),
1580 GtkBox
*cur_box
= GTK_BOX (go
);
1581 g_object_unref (G_OBJECT (gbld
));
1583 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1586 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1587 left_buttons
= total_buttons
- right_buttons
;
1589 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1590 gtk_widget_set_name (wdialog
, "emacs-dialog");
1595 GtkWidget
*wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, button_spacing
);
1596 GtkWidget
*whbox_up
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1597 gtk_box_set_homogeneous (GTK_BOX (wvbox
), TRUE
);
1598 gtk_box_set_homogeneous (GTK_BOX (whbox_up
), FALSE
);
1599 whbox_down
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1600 gtk_box_set_homogeneous (GTK_BOX (whbox_down
), FALSE
);
1602 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1603 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1604 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1606 cur_box
= GTK_BOX (whbox_up
);
1609 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1610 G_CALLBACK (dialog_delete_callback
), 0);
1614 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1615 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1618 for (item
= wv
->contents
; item
; item
= item
->next
)
1620 char *utf8_label
= get_utf8_string (item
->value
);
1624 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1626 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1627 /* This is the text part of the dialog. */
1628 w
= gtk_label_new (utf8_label
);
1629 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1630 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1631 #if GTK_CHECK_VERSION (3, 14, 0)
1632 gtk_widget_set_halign (w
, GTK_ALIGN_START
);
1633 gtk_widget_set_valign (w
, GTK_ALIGN_CENTER
);
1635 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1637 /* Try to make dialog look better. Must realize first so
1638 the widget can calculate the size it needs. */
1639 gtk_widget_realize (w
);
1640 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1641 gtk_box_set_spacing (wvbox
, req
.height
);
1642 if (item
->value
&& strlen (item
->value
) > 0)
1643 button_spacing
= 2*req
.width
/strlen (item
->value
);
1644 if (button_spacing
< 10) button_spacing
= 10;
1648 /* This is one button to add to the dialog. */
1649 w
= gtk_button_new_with_label (utf8_label
);
1650 if (! item
->enabled
)
1651 gtk_widget_set_sensitive (w
, FALSE
);
1653 g_signal_connect (G_OBJECT (w
), "clicked",
1654 select_cb
, item
->call_data
);
1656 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1657 if (++button_nr
== left_buttons
)
1660 cur_box
= GTK_BOX (whbox_down
);
1665 g_free (utf8_label
);
1671 struct xg_dialog_data
1679 /* Function that is called when the file or font dialogs pop down.
1680 W is the dialog widget, RESPONSE is the response code.
1681 USER_DATA is what we passed in to g_signal_connect. */
1684 xg_dialog_response_cb (GtkDialog
*w
,
1688 struct xg_dialog_data
*dd
= user_data
;
1689 dd
->response
= response
;
1690 g_main_loop_quit (dd
->loop
);
1694 /* Destroy the dialog. This makes it pop down. */
1697 pop_down_dialog (void *arg
)
1699 struct xg_dialog_data
*dd
= arg
;
1702 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1703 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1705 g_main_loop_quit (dd
->loop
);
1706 g_main_loop_unref (dd
->loop
);
1711 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1712 We pass in DATA as gpointer* so we can use this as a callback. */
1715 xg_maybe_add_timer (gpointer data
)
1717 struct xg_dialog_data
*dd
= data
;
1718 struct timespec next_time
= timer_check ();
1722 if (timespec_valid_p (next_time
))
1724 time_t s
= next_time
.tv_sec
;
1725 int per_ms
= TIMESPEC_RESOLUTION
/ 1000;
1726 int ms
= (next_time
.tv_nsec
+ per_ms
- 1) / per_ms
;
1727 if (s
<= ((guint
) -1 - ms
) / 1000)
1728 dd
->timerid
= g_timeout_add (s
* 1000 + ms
, xg_maybe_add_timer
, dd
);
1734 /* Pops up a modal dialog W and waits for response.
1735 We don't use gtk_dialog_run because we want to process emacs timers.
1736 The dialog W is not destroyed when this function returns. */
1739 xg_dialog_run (struct frame
*f
, GtkWidget
*w
)
1741 ptrdiff_t count
= SPECPDL_INDEX ();
1742 struct xg_dialog_data dd
;
1744 xg_set_screen (w
, f
);
1745 gtk_window_set_transient_for (GTK_WINDOW (w
),
1746 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1747 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1748 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1750 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1751 dd
.response
= GTK_RESPONSE_CANCEL
;
1755 g_signal_connect (G_OBJECT (w
),
1757 G_CALLBACK (xg_dialog_response_cb
),
1759 /* Don't destroy the widget if closed by the window manager close button. */
1760 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1761 gtk_widget_show (w
);
1763 record_unwind_protect_ptr (pop_down_dialog
, &dd
);
1765 (void) xg_maybe_add_timer (&dd
);
1766 g_main_loop_run (dd
.loop
);
1769 unbind_to (count
, Qnil
);
1775 /***********************************************************************
1776 File dialog functions
1777 ***********************************************************************/
1778 /* Return true if the old file selection dialog is being used. */
1781 xg_uses_old_file_dialog (void)
1783 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1784 return x_gtk_use_old_file_dialog
;
1791 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1793 /* Return the selected file for file chooser dialog W.
1794 The returned string must be free:d. */
1797 xg_get_file_name_from_chooser (GtkWidget
*w
)
1799 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1802 /* Callback called when the "Show hidden files" toggle is pressed.
1803 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1806 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1808 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1810 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1811 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1815 /* Callback called when a property changes in a file chooser.
1816 GOBJECT is the file chooser dialog, ARG1 describes the property.
1817 USER_DATA is the toggle widget in the file chooser dialog.
1818 We use this to update the "Show hidden files" toggle when the user
1819 changes that property by right clicking in the file list. */
1822 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1824 if (strcmp (arg1
->name
, "show-hidden") == 0)
1826 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1827 gboolean visible
, toggle_on
;
1829 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1830 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1832 if (!!visible
!= !!toggle_on
)
1834 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1835 G_CALLBACK (xg_toggle_visibility_cb
),
1837 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1838 g_signal_handlers_unblock_by_func
1839 (G_OBJECT (wtoggle
),
1840 G_CALLBACK (xg_toggle_visibility_cb
),
1843 x_gtk_show_hidden_files
= visible
;
1847 /* Read a file name from the user using a file chooser dialog.
1848 F is the current frame.
1849 PROMPT is a prompt to show to the user. May not be NULL.
1850 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1851 If MUSTMATCH_P, the returned file name must be an existing
1852 file. (Actually, this only has cosmetic effects, the user can
1853 still enter a non-existing file.) *FUNC is set to a function that
1854 can be used to retrieve the selected file name from the returned widget.
1856 Returns the created widget. */
1859 xg_get_file_with_chooser (struct frame
*f
,
1861 char *default_filename
,
1862 bool mustmatch_p
, bool only_dir_p
,
1863 xg_get_file_func
*func
)
1867 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1868 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1869 GtkFileChooserAction action
= (mustmatch_p
?
1870 GTK_FILE_CHOOSER_ACTION_OPEN
:
1871 GTK_FILE_CHOOSER_ACTION_SAVE
);
1874 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1876 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1877 XG_TEXT_CANCEL
, GTK_RESPONSE_CANCEL
,
1878 (mustmatch_p
|| only_dir_p
?
1879 XG_TEXT_OPEN
: XG_TEXT_OK
),
1882 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1884 wbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1885 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
1886 gtk_widget_show (wbox
);
1887 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1889 if (x_gtk_show_hidden_files
)
1891 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1892 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1894 gtk_widget_show (wtoggle
);
1895 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1896 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1897 g_signal_connect (G_OBJECT (filewin
), "notify",
1898 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1900 if (x_gtk_file_dialog_help_text
)
1903 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1904 Show the C-l help text only for versions < 2.10. */
1905 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1906 z
= stpcpy (z
, "\nType C-l to display a file name text entry box.\n");
1907 strcpy (z
, "\nIf you don't like this file selector, use the "
1908 "corresponding\nkey binding or customize "
1909 "use-file-dialog to turn it off.");
1911 wmessage
= gtk_label_new (msgbuf
);
1912 gtk_widget_show (wmessage
);
1915 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1916 if (x_gtk_file_dialog_help_text
)
1917 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1918 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1920 if (default_filename
)
1923 char *utf8_filename
;
1925 file
= build_string (default_filename
);
1927 /* File chooser does not understand ~/... in the file name. It must be
1928 an absolute name starting with /. */
1929 if (default_filename
[0] != '/')
1930 file
= Fexpand_file_name (file
, Qnil
);
1932 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1933 if (! NILP (Ffile_directory_p (file
)))
1934 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1938 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1940 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1942 char *cp
= strrchr (utf8_filename
, '/');
1944 else cp
= utf8_filename
;
1945 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1950 *func
= xg_get_file_name_from_chooser
;
1954 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1956 /* Return the selected file for file selector dialog W.
1957 The returned string must be free:d. */
1960 xg_get_file_name_from_selector (GtkWidget
*w
)
1962 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1963 return xstrdup (gtk_file_selection_get_filename (filesel
));
1966 /* Create a file selection dialog.
1967 F is the current frame.
1968 PROMPT is a prompt to show to the user. May not be NULL.
1969 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1970 If MUSTMATCH_P, the returned file name must be an existing
1971 file. *FUNC is set to a function that can be used to retrieve the
1972 selected file name from the returned widget.
1974 Returns the created widget. */
1977 xg_get_file_with_selection (struct frame
*f
,
1979 char *default_filename
,
1980 bool mustmatch_p
, bool only_dir_p
,
1981 xg_get_file_func
*func
)
1984 GtkFileSelection
*filesel
;
1986 filewin
= gtk_file_selection_new (prompt
);
1987 filesel
= GTK_FILE_SELECTION (filewin
);
1989 if (default_filename
)
1990 gtk_file_selection_set_filename (filesel
, default_filename
);
1994 /* The selection_entry part of filesel is not documented. */
1995 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1996 gtk_file_selection_hide_fileop_buttons (filesel
);
1999 *func
= xg_get_file_name_from_selector
;
2003 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
2005 /* Read a file name from the user using a file dialog, either the old
2006 file selection dialog, or the new file chooser dialog. Which to use
2007 depends on what the GTK version used has, and what the value of
2008 gtk-use-old-file-dialog.
2009 F is the current frame.
2010 PROMPT is a prompt to show to the user. May not be NULL.
2011 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
2012 If MUSTMATCH_P, the returned file name must be an existing
2015 Returns a file name or NULL if no file was selected.
2016 The returned string must be freed by the caller. */
2019 xg_get_file_name (struct frame
*f
,
2021 char *default_filename
,
2027 int filesel_done
= 0;
2028 xg_get_file_func func
;
2030 #ifdef HAVE_GTK_FILE_SELECTION_NEW
2032 if (xg_uses_old_file_dialog ())
2033 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
2034 mustmatch_p
, only_dir_p
, &func
);
2036 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
2037 mustmatch_p
, only_dir_p
, &func
);
2039 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
2040 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
2041 mustmatch_p
, only_dir_p
, &func
);
2042 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
2044 gtk_widget_set_name (w
, "emacs-filedialog");
2046 filesel_done
= xg_dialog_run (f
, w
);
2047 if (filesel_done
== GTK_RESPONSE_OK
)
2050 gtk_widget_destroy (w
);
2054 /***********************************************************************
2056 ***********************************************************************/
2058 #ifdef HAVE_FREETYPE
2060 #if USE_NEW_GTK_FONT_CHOOSER
2062 #define XG_WEIGHT_TO_SYMBOL(w) \
2063 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
2064 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
2065 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
2066 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
2067 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
2068 : w <= PANGO_WEIGHT_BOLD ? Qbold \
2069 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
2072 #define XG_STYLE_TO_SYMBOL(s) \
2073 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
2074 : s == PANGO_STYLE_ITALIC ? Qitalic \
2077 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2080 static char *x_last_font_name
;
2082 /* Pop up a GTK font selector and return the name of the font the user
2083 selects, as a C string. The returned font name follows GTK's own
2086 `FAMILY [VALUE1 VALUE2] SIZE'
2088 This can be parsed using font_parse_fcname in font.c.
2089 DEFAULT_NAME, if non-zero, is the default font name. */
2092 xg_get_font (struct frame
*f
, const char *default_name
)
2096 Lisp_Object font
= Qnil
;
2098 w
= gtk_font_chooser_dialog_new
2099 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2103 /* Convert fontconfig names to Gtk names, i.e. remove - before
2105 char *p
= strrchr (default_name
, '-');
2109 while (c_isdigit (*ep
))
2111 if (*ep
== '\0') *p
= ' ';
2114 else if (x_last_font_name
)
2115 default_name
= x_last_font_name
;
2118 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w
), default_name
);
2120 gtk_widget_set_name (w
, "emacs-fontdialog");
2121 done
= xg_dialog_run (f
, w
);
2122 if (done
== GTK_RESPONSE_OK
)
2124 #if USE_NEW_GTK_FONT_CHOOSER
2125 /* Use the GTK3 font chooser. */
2126 PangoFontDescription
*desc
2127 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w
));
2131 const char *name
= pango_font_description_get_family (desc
);
2132 gint size
= pango_font_description_get_size (desc
);
2133 PangoWeight weight
= pango_font_description_get_weight (desc
);
2134 PangoStyle style
= pango_font_description_get_style (desc
);
2137 #define FONT_TYPE_WANTED (Qftcr)
2139 #define FONT_TYPE_WANTED (Qxft)
2141 font
= CALLN (Ffont_spec
,
2142 QCname
, build_string (name
),
2143 QCsize
, make_float (pango_units_to_double (size
)),
2144 QCweight
, XG_WEIGHT_TO_SYMBOL (weight
),
2145 QCslant
, XG_STYLE_TO_SYMBOL (style
),
2149 pango_font_description_free (desc
);
2150 dupstring (&x_last_font_name
, name
);
2153 #else /* Use old font selector, which just returns the font name. */
2156 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w
));
2160 font
= build_string (font_name
);
2161 g_free (x_last_font_name
);
2162 x_last_font_name
= font_name
;
2164 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2167 gtk_widget_destroy (w
);
2170 #endif /* HAVE_FREETYPE */
2174 /***********************************************************************
2176 ***********************************************************************/
2178 /* The name of menu items that can be used for customization. Since GTK
2179 RC files are very crude and primitive, we have to set this on all
2180 menu item names so a user can easily customize menu items. */
2182 #define MENU_ITEM_NAME "emacs-menuitem"
2185 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2186 during GC. The next member points to the items. */
2187 static xg_list_node xg_menu_cb_list
;
2189 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2190 during GC. The next member points to the items. */
2191 static xg_list_node xg_menu_item_cb_list
;
2193 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2194 F is the frame CL_DATA will be initialized for.
2195 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2197 The menu bar and all sub menus under the menu bar in a frame
2198 share the same structure, hence the reference count.
2200 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2201 allocated xg_menu_cb_data if CL_DATA is NULL. */
2203 static xg_menu_cb_data
*
2204 make_cl_data (xg_menu_cb_data
*cl_data
, struct frame
*f
, GCallback highlight_cb
)
2208 cl_data
= xmalloc (sizeof *cl_data
);
2210 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2211 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2212 cl_data
->highlight_cb
= highlight_cb
;
2213 cl_data
->ref_count
= 0;
2215 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2218 cl_data
->ref_count
++;
2223 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2224 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2226 When the menu bar is updated, menu items may have been added and/or
2227 removed, so menu_bar_vector and menu_bar_items_used change. We must
2228 then update CL_DATA since it is used to determine which menu
2229 item that is invoked in the menu.
2230 HIGHLIGHT_CB could change, there is no check that the same
2231 function is given when modifying a menu bar as was given when
2232 creating the menu bar. */
2235 update_cl_data (xg_menu_cb_data
*cl_data
,
2237 GCallback highlight_cb
)
2242 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2243 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2244 cl_data
->highlight_cb
= highlight_cb
;
2248 /* Decrease reference count for CL_DATA.
2249 If reference count is zero, free CL_DATA. */
2252 unref_cl_data (xg_menu_cb_data
*cl_data
)
2254 if (cl_data
&& cl_data
->ref_count
> 0)
2256 cl_data
->ref_count
--;
2257 if (cl_data
->ref_count
== 0)
2259 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2265 /* Function that marks all lisp data during GC. */
2271 Lisp_Object rest
, frame
;
2273 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2274 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2276 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2278 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2280 if (! NILP (cb_data
->help
))
2281 mark_object (cb_data
->help
);
2284 FOR_EACH_FRAME (rest
, frame
)
2286 struct frame
*f
= XFRAME (frame
);
2288 if (FRAME_X_P (f
) && FRAME_GTK_OUTER_WIDGET (f
))
2290 struct xg_frame_tb_info
*tbinfo
2291 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
2295 mark_object (tbinfo
->last_tool_bar
);
2296 mark_object (tbinfo
->style
);
2303 /* Callback called when a menu item is destroyed. Used to free data.
2304 W is the widget that is being destroyed (not used).
2305 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2308 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2312 xg_menu_item_cb_data
*data
= client_data
;
2313 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2318 /* Callback called when the pointer enters/leaves a menu item.
2319 W is the parent of the menu item.
2320 EVENT is either an enter event or leave event.
2321 CLIENT_DATA is not used.
2323 Returns FALSE to tell GTK to keep processing this event. */
2326 menuitem_highlight_callback (GtkWidget
*w
,
2327 GdkEventCrossing
*event
,
2328 gpointer client_data
)
2331 GtkWidget
*subwidget
;
2332 xg_menu_item_cb_data
*data
;
2334 ev
.crossing
= *event
;
2335 subwidget
= gtk_get_event_widget (&ev
);
2336 data
= g_object_get_data (G_OBJECT (subwidget
), XG_ITEM_DATA
);
2339 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2341 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2342 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2343 (*func
) (subwidget
, call_data
);
2350 /* Callback called when a menu is destroyed. Used to free data.
2351 W is the widget that is being destroyed (not used).
2352 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2355 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2357 unref_cl_data (client_data
);
2360 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2361 must be non-NULL) and can be inserted into a menu item.
2363 Returns the GtkHBox. */
2366 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2372 wbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
2373 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
2374 wlbl
= gtk_label_new (utf8_label
);
2375 wkey
= gtk_label_new (utf8_key
);
2377 #if GTK_CHECK_VERSION (3, 14, 0)
2378 gtk_widget_set_halign (wlbl
, GTK_ALIGN_START
);
2379 gtk_widget_set_valign (wlbl
, GTK_ALIGN_CENTER
);
2380 gtk_widget_set_halign (wkey
, GTK_ALIGN_START
);
2381 gtk_widget_set_valign (wkey
, GTK_ALIGN_CENTER
);
2383 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2384 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2386 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2387 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2389 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2390 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2391 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2396 /* Make and return a menu item widget with the key to the right.
2397 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2398 UTF8_KEY is the text representing the key binding.
2399 ITEM is the widget_value describing the menu item.
2401 GROUP is an in/out parameter. If the menu item to be created is not
2402 part of any radio menu group, *GROUP contains NULL on entry and exit.
2403 If the menu item to be created is part of a radio menu group, on entry
2404 *GROUP contains the group to use, or NULL if this is the first item
2405 in the group. On exit, *GROUP contains the radio item group.
2407 Unfortunately, keys don't line up as nicely as in Motif,
2408 but the MacOS X version doesn't either, so I guess that is OK. */
2411 make_menu_item (const char *utf8_label
,
2412 const char *utf8_key
,
2417 GtkWidget
*wtoadd
= 0;
2419 /* It has been observed that some menu items have a NULL name field.
2420 This will lead to this function being called with a NULL utf8_label.
2421 GTK crashes on that so we set a blank label. Why there is a NULL
2422 name remains to be investigated. */
2423 if (! utf8_label
) utf8_label
= " ";
2426 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2428 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2431 if (utf8_key
) w
= gtk_check_menu_item_new ();
2432 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2433 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2435 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2437 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2438 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2439 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2441 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2446 if (utf8_key
) w
= gtk_menu_item_new ();
2447 else w
= gtk_menu_item_new_with_label (utf8_label
);
2450 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2451 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2456 /* Create a menu item widget, and connect the callbacks.
2457 ITEM describes the menu item.
2458 F is the frame the created menu belongs to.
2459 SELECT_CB is the callback to use when a menu item is selected.
2460 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2461 CL_DATA points to the callback data to be used for this menu.
2462 GROUP is an in/out parameter. If the menu item to be created is not
2463 part of any radio menu group, *GROUP contains NULL on entry and exit.
2464 If the menu item to be created is part of a radio menu group, on entry
2465 *GROUP contains the group to use, or NULL if this is the first item
2466 in the group. On exit, *GROUP contains the radio item group.
2468 Returns the created GtkWidget. */
2471 xg_create_one_menuitem (widget_value
*item
,
2473 GCallback select_cb
,
2474 GCallback highlight_cb
,
2475 xg_menu_cb_data
*cl_data
,
2481 xg_menu_item_cb_data
*cb_data
;
2483 utf8_label
= get_utf8_string (item
->name
);
2484 utf8_key
= get_utf8_string (item
->key
);
2486 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2488 if (utf8_label
) g_free (utf8_label
);
2489 if (utf8_key
) g_free (utf8_key
);
2491 cb_data
= xmalloc (sizeof *cb_data
);
2493 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2495 cb_data
->select_id
= 0;
2496 cb_data
->help
= item
->help
;
2497 cb_data
->cl_data
= cl_data
;
2498 cb_data
->call_data
= item
->call_data
;
2500 g_signal_connect (G_OBJECT (w
),
2502 G_CALLBACK (menuitem_destroy_callback
),
2505 /* Put cb_data in widget, so we can get at it when modifying menubar */
2506 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2508 /* final item, not a submenu */
2509 if (item
->call_data
&& ! item
->contents
)
2513 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2519 /* Create a full menu tree specified by DATA.
2520 F is the frame the created menu belongs to.
2521 SELECT_CB is the callback to use when a menu item is selected.
2522 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2523 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2524 If POP_UP_P, create a popup menu.
2525 If MENU_BAR_P, create a menu bar.
2526 TOPMENU is the topmost GtkWidget that others shall be placed under.
2527 It may be NULL, in that case we create the appropriate widget
2528 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2529 CL_DATA is the callback data we shall use for this menu, or NULL
2530 if we haven't set the first callback yet.
2531 NAME is the name to give to the top level menu if this function
2532 creates it. May be NULL to not set any name.
2534 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2537 This function calls itself to create submenus. */
2540 create_menus (widget_value
*data
,
2542 GCallback select_cb
,
2543 GCallback deactivate_cb
,
2544 GCallback highlight_cb
,
2548 xg_menu_cb_data
*cl_data
,
2552 GtkWidget
*wmenu
= topmenu
;
2553 GSList
*group
= NULL
;
2559 wmenu
= gtk_menu_new ();
2560 xg_set_screen (wmenu
, f
);
2561 /* Connect this to the menu instead of items so we get enter/leave for
2562 disabled items also. TODO: Still does not get enter/leave for
2563 disabled items in detached menus. */
2564 g_signal_connect (G_OBJECT (wmenu
),
2565 "enter-notify-event",
2566 G_CALLBACK (menuitem_highlight_callback
),
2568 g_signal_connect (G_OBJECT (wmenu
),
2569 "leave-notify-event",
2570 G_CALLBACK (menuitem_highlight_callback
),
2575 wmenu
= gtk_menu_bar_new ();
2576 /* Set width of menu bar to a small value so it doesn't enlarge
2577 a small initial frame size. The width will be set to the
2578 width of the frame later on when it is added to a container.
2579 height -1: Natural height. */
2580 gtk_widget_set_size_request (wmenu
, 1, -1);
2583 /* Put cl_data on the top menu for easier access. */
2584 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2585 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2586 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2587 G_CALLBACK (menu_destroy_callback
), cl_data
);
2590 gtk_widget_set_name (wmenu
, name
);
2593 g_signal_connect (G_OBJECT (wmenu
),
2594 "selection-done", deactivate_cb
, 0);
2597 for (item
= data
; item
; item
= item
->next
)
2601 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2602 && !menu_separator_name_p (item
->name
))
2605 /* A title for a popup. We do the same as GTK does when
2606 creating titles, but it does not look good. */
2608 utf8_label
= get_utf8_string (item
->name
);
2610 w
= gtk_menu_item_new_with_label (utf8_label
);
2611 gtk_widget_set_sensitive (w
, FALSE
);
2612 if (utf8_label
) g_free (utf8_label
);
2614 else if (menu_separator_name_p (item
->name
))
2617 /* GTK only have one separator type. */
2618 w
= gtk_separator_menu_item_new ();
2622 w
= xg_create_one_menuitem (item
,
2624 item
->contents
? 0 : select_cb
,
2629 /* Create a possibly empty submenu for menu bar items, since some
2630 themes don't highlight items correctly without it. */
2631 if (item
->contents
|| menu_bar_p
)
2633 GtkWidget
*submenu
= create_menus (item
->contents
,
2643 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2647 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2648 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2654 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2655 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2656 with some text and buttons.
2657 F is the frame the created item belongs to.
2658 NAME is the name to use for the top widget.
2659 VAL is a widget_value structure describing items to be created.
2660 SELECT_CB is the callback to use when a menu item is selected or
2661 a dialog button is pressed.
2662 DEACTIVATE_CB is the callback to use when an item is deactivated.
2663 For a menu, when a sub menu is not shown anymore, for a dialog it is
2664 called when the dialog is popped down.
2665 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2667 Returns the widget created. */
2670 xg_create_widget (const char *type
, const char *name
, struct frame
*f
,
2671 widget_value
*val
, GCallback select_cb
,
2672 GCallback deactivate_cb
, GCallback highlight_cb
)
2675 bool menu_bar_p
= strcmp (type
, "menubar") == 0;
2676 bool pop_up_p
= strcmp (type
, "popup") == 0;
2678 if (strcmp (type
, "dialog") == 0)
2680 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2681 xg_set_screen (w
, f
);
2682 gtk_window_set_transient_for (GTK_WINDOW (w
),
2683 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2684 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2685 gtk_widget_set_name (w
, "emacs-dialog");
2686 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2688 else if (menu_bar_p
|| pop_up_p
)
2690 w
= create_menus (val
->contents
,
2701 /* Set the cursor to an arrow for popup menus when they are mapped.
2702 This is done by default for menu bar menus. */
2705 /* Must realize so the GdkWindow inside the widget is created. */
2706 gtk_widget_realize (w
);
2707 xg_set_cursor (w
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
2712 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2719 /* Return the label for menu item WITEM. */
2722 xg_get_menu_item_label (GtkMenuItem
*witem
)
2724 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2725 return gtk_label_get_label (wlabel
);
2728 /* Return true if the menu item WITEM has the text LABEL. */
2731 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2734 char *utf8_label
= get_utf8_string (label
);
2735 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2737 if (! old_label
&& ! utf8_label
)
2739 else if (old_label
&& utf8_label
)
2740 is_same
= strcmp (utf8_label
, old_label
) == 0;
2742 if (utf8_label
) g_free (utf8_label
);
2747 /* Destroy widgets in LIST. */
2750 xg_destroy_widgets (GList
*list
)
2754 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2756 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2758 /* Destroying the widget will remove it from the container it is in. */
2759 gtk_widget_destroy (w
);
2763 /* Update the top level names in MENUBAR (i.e. not submenus).
2764 F is the frame the menu bar belongs to.
2765 *LIST is a list with the current menu bar names (menu item widgets).
2766 ITER is the item within *LIST that shall be updated.
2767 POS is the numerical position, starting at 0, of ITER in *LIST.
2768 VAL describes what the menu bar shall look like after the update.
2769 SELECT_CB is the callback to use when a menu item is selected.
2770 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2771 CL_DATA points to the callback data to be used for this menu bar.
2773 This function calls itself to walk through the menu bar names. */
2776 xg_update_menubar (GtkWidget
*menubar
,
2782 GCallback select_cb
,
2783 GCallback deactivate_cb
,
2784 GCallback highlight_cb
,
2785 xg_menu_cb_data
*cl_data
)
2787 if (! iter
&& ! val
)
2789 else if (iter
&& ! val
)
2791 /* Item(s) have been removed. Remove all remaining items. */
2792 xg_destroy_widgets (iter
);
2794 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2795 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2796 gtk_menu_item_new_with_label (""),
2802 else if (! iter
&& val
)
2804 /* Item(s) added. Add all new items in one call. */
2805 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2806 0, 1, menubar
, cl_data
, 0);
2812 /* Below this neither iter or val is NULL */
2813 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2815 /* This item is still the same, check next item. */
2817 iter
= g_list_next (iter
);
2820 else /* This item is changed. */
2822 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2823 GtkMenuItem
*witem2
= 0;
2824 bool val_in_menubar
= 0;
2825 bool iter_in_new_menubar
= 0;
2829 /* See if the changed entry (val) is present later in the menu bar */
2831 iter2
&& ! val_in_menubar
;
2832 iter2
= g_list_next (iter2
))
2834 witem2
= GTK_MENU_ITEM (iter2
->data
);
2835 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2838 /* See if the current entry (iter) is present later in the
2839 specification for the new menu bar. */
2840 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2841 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2843 if (val_in_menubar
&& ! iter_in_new_menubar
)
2847 /* This corresponds to:
2852 g_object_ref (G_OBJECT (witem
));
2853 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2854 gtk_widget_destroy (GTK_WIDGET (witem
));
2856 /* Must get new list since the old changed. */
2857 g_list_free (*list
);
2858 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2859 while (nr
-- > 0) iter
= g_list_next (iter
);
2861 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2863 /* This corresponds to:
2866 Rename B to X. This might seem to be a strange thing to do,
2867 since if there is a menu under B it will be totally wrong for X.
2868 But consider editing a C file. Then there is a C-mode menu
2869 (corresponds to B above).
2870 If then doing C-x C-f the minibuf menu (X above) replaces the
2871 C-mode menu. When returning from the minibuffer, we get
2872 back the C-mode menu. Thus we do:
2873 Rename B to X (C-mode to minibuf menu)
2874 Rename X to B (minibuf to C-mode menu).
2875 If the X menu hasn't been invoked, the menu under B
2876 is up to date when leaving the minibuffer. */
2877 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2878 char *utf8_label
= get_utf8_string (val
->name
);
2880 /* GTK menu items don't notice when their labels have been
2881 changed from underneath them, so we have to explicitly
2882 use g_object_notify to tell listeners (e.g., a GMenuModel
2883 bridge that might be loaded) that the item's label has
2885 gtk_label_set_text (wlabel
, utf8_label
);
2886 #if GTK_CHECK_VERSION (2, 16, 0)
2887 g_object_notify (G_OBJECT (witem
), "label");
2889 if (utf8_label
) g_free (utf8_label
);
2890 iter
= g_list_next (iter
);
2894 else if (! val_in_menubar
&& iter_in_new_menubar
)
2896 /* This corresponds to:
2903 GtkWidget
*w
= xg_create_one_menuitem (val
,
2910 /* Create a possibly empty submenu for menu bar items, since some
2911 themes don't highlight items correctly without it. */
2912 GtkWidget
*submenu
= create_menus (NULL
, f
,
2913 select_cb
, deactivate_cb
,
2915 0, 0, 0, cl_data
, 0);
2917 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2918 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2919 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2921 g_list_free (*list
);
2922 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2923 while (nr
-- > 0) iter
= g_list_next (iter
);
2924 iter
= g_list_next (iter
);
2928 else /* if (val_in_menubar && iter_in_new_menubar) */
2931 /* This corresponds to:
2936 g_object_ref (G_OBJECT (witem2
));
2937 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2938 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2939 GTK_WIDGET (witem2
), pos
);
2940 g_object_unref (G_OBJECT (witem2
));
2942 g_list_free (*list
);
2943 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2944 while (nr
-- > 0) iter
= g_list_next (iter
);
2945 if (iter
) iter
= g_list_next (iter
);
2951 /* Update the rest of the menu bar. */
2952 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2953 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2956 /* Update the menu item W so it corresponds to VAL.
2957 SELECT_CB is the callback to use when a menu item is selected.
2958 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2959 CL_DATA is the data to set in the widget for menu invocation. */
2962 xg_update_menu_item (widget_value
*val
,
2964 GCallback select_cb
,
2965 GCallback highlight_cb
,
2966 xg_menu_cb_data
*cl_data
)
2973 const char *old_label
= 0;
2974 const char *old_key
= 0;
2975 xg_menu_item_cb_data
*cb_data
;
2976 bool label_changed
= false;
2978 wchild
= XG_BIN_CHILD (w
);
2979 utf8_label
= get_utf8_string (val
->name
);
2980 utf8_key
= get_utf8_string (val
->key
);
2982 /* See if W is a menu item with a key. See make_menu_item above. */
2983 if (GTK_IS_BOX (wchild
))
2985 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2987 wlbl
= GTK_LABEL (list
->data
);
2988 wkey
= GTK_LABEL (list
->next
->data
);
2993 /* Remove the key and keep just the label. */
2994 g_object_ref (G_OBJECT (wlbl
));
2995 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2996 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2997 g_object_unref (G_OBJECT (wlbl
));
3002 else /* Just a label. */
3004 wlbl
= GTK_LABEL (wchild
);
3006 /* Check if there is now a key. */
3009 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
3010 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
3012 wlbl
= GTK_LABEL (list
->data
);
3013 wkey
= GTK_LABEL (list
->next
->data
);
3016 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3017 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
3021 if (wkey
) old_key
= gtk_label_get_label (wkey
);
3022 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
3024 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
3026 label_changed
= true;
3027 gtk_label_set_text (wkey
, utf8_key
);
3030 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
3032 label_changed
= true;
3033 gtk_label_set_text (wlbl
, utf8_label
);
3036 if (utf8_key
) g_free (utf8_key
);
3037 if (utf8_label
) g_free (utf8_label
);
3039 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
3040 gtk_widget_set_sensitive (w
, FALSE
);
3041 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
3042 gtk_widget_set_sensitive (w
, TRUE
);
3044 cb_data
= g_object_get_data (G_OBJECT (w
), XG_ITEM_DATA
);
3047 cb_data
->call_data
= val
->call_data
;
3048 cb_data
->help
= val
->help
;
3049 cb_data
->cl_data
= cl_data
;
3051 /* We assume the callback functions don't change. */
3052 if (val
->call_data
&& ! val
->contents
)
3054 /* This item shall have a select callback. */
3055 if (! cb_data
->select_id
)
3057 = g_signal_connect (G_OBJECT (w
), "activate",
3058 select_cb
, cb_data
);
3060 else if (cb_data
->select_id
)
3062 g_signal_handler_disconnect (w
, cb_data
->select_id
);
3063 cb_data
->select_id
= 0;
3067 #if GTK_CHECK_VERSION (2, 16, 0)
3068 if (label_changed
) /* See comment in xg_update_menubar. */
3069 g_object_notify (G_OBJECT (w
), "label");
3073 /* Update the toggle menu item W so it corresponds to VAL. */
3076 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
3078 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3081 /* Update the radio menu item W so it corresponds to VAL. */
3084 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
3086 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3089 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3090 SUBMENU may be NULL, in that case a new menu is created.
3091 F is the frame the menu bar belongs to.
3092 VAL describes the contents of the menu bar.
3093 SELECT_CB is the callback to use when a menu item is selected.
3094 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3095 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3096 CL_DATA is the call back data to use for any newly created items.
3098 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3102 xg_update_submenu (GtkWidget
*submenu
,
3105 GCallback select_cb
,
3106 GCallback deactivate_cb
,
3107 GCallback highlight_cb
,
3108 xg_menu_cb_data
*cl_data
)
3110 GtkWidget
*newsub
= submenu
;
3114 GList
*first_radio
= 0;
3117 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3119 for (cur
= val
, iter
= list
;
3121 iter
= g_list_next (iter
), cur
= cur
->next
)
3123 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3125 /* Remember first radio button in a group. If we get a mismatch in
3126 a radio group we must rebuild the whole group so that the connections
3127 in GTK becomes correct. */
3128 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3130 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3131 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3134 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3136 if (! menu_separator_name_p (cur
->name
))
3139 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3141 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3143 xg_update_toggle_item (cur
, w
);
3144 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3146 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3148 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3150 xg_update_radio_item (cur
, w
);
3151 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3153 else if (GTK_IS_MENU_ITEM (w
))
3155 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3158 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3159 menu_separator_name_p (cur
->name
))
3162 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3164 sub
= gtk_menu_item_get_submenu (witem
);
3165 if (sub
&& ! cur
->contents
)
3167 /* Not a submenu anymore. */
3168 g_object_ref (G_OBJECT (sub
));
3169 remove_submenu (witem
);
3170 gtk_widget_destroy (sub
);
3172 else if (cur
->contents
)
3176 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3177 select_cb
, deactivate_cb
,
3178 highlight_cb
, cl_data
);
3180 /* If this item just became a submenu, we must set it. */
3182 gtk_menu_item_set_submenu (witem
, nsub
);
3187 /* Structural difference. Remove everything from here and down
3193 /* Remove widgets from first structural change. */
3196 /* If we are adding new menu items below, we must remove from
3197 first radio button so that radio groups become correct. */
3198 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3199 else xg_destroy_widgets (iter
);
3204 /* More items added. Create them. */
3205 newsub
= create_menus (cur
,
3217 if (list
) g_list_free (list
);
3222 /* Update the MENUBAR.
3223 F is the frame the menu bar belongs to.
3224 VAL describes the contents of the menu bar.
3225 If DEEP_P, rebuild all but the top level menu names in
3226 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3227 SELECT_CB is the callback to use when a menu item is selected.
3228 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3229 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3232 xg_modify_menubar_widgets (GtkWidget
*menubar
, struct frame
*f
,
3233 widget_value
*val
, bool deep_p
,
3234 GCallback select_cb
, GCallback deactivate_cb
,
3235 GCallback highlight_cb
)
3237 xg_menu_cb_data
*cl_data
;
3238 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3242 cl_data
= g_object_get_data (G_OBJECT (menubar
), XG_FRAME_DATA
);
3244 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3245 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3251 /* Update all sub menus.
3252 We must keep the submenus (GTK menu item widgets) since the
3253 X Window in the XEvent that activates the menu are those widgets. */
3255 /* Update cl_data, menu_item things in F may have changed. */
3256 update_cl_data (cl_data
, f
, highlight_cb
);
3258 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3263 GtkMenuItem
*witem
= 0;
3265 /* Find sub menu that corresponds to val and update it. */
3266 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3268 witem
= GTK_MENU_ITEM (iter
->data
);
3269 if (xg_item_label_same_p (witem
, cur
->name
))
3271 sub
= gtk_menu_item_get_submenu (witem
);
3276 newsub
= xg_update_submenu (sub
,
3283 /* sub may still be NULL. If we just updated non deep and added
3284 a new menu bar item, it has no sub menu yet. So we set the
3285 newly created sub menu under witem. */
3286 if (newsub
!= sub
&& witem
!= 0)
3288 xg_set_screen (newsub
, f
);
3289 gtk_menu_item_set_submenu (witem
, newsub
);
3295 gtk_widget_show_all (menubar
);
3298 /* Callback called when the menu bar W is mapped.
3299 Used to find the height of the menu bar if we didn't get it
3300 after showing the widget. */
3303 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3306 struct frame
*f
= user_data
;
3307 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3308 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3310 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3311 adjust_frame_size (f
, -1, -1, 2, 0, Qmenu_bar_lines
);
3315 /* Recompute all the widgets of frame F, when the menu bar has been
3319 xg_update_frame_menubar (struct frame
*f
)
3321 struct x_output
*x
= f
->output_data
.x
;
3324 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3327 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3328 return; /* Already done this, happens for frames created invisible. */
3332 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3334 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3336 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3337 gtk_widget_show_all (x
->menubar_widget
);
3338 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3340 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3342 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3343 adjust_frame_size (f
, -1, -1, 2, 0, Qmenu_bar_lines
);
3348 /* Get rid of the menu bar of frame F, and free its storage.
3349 This is used when deleting a frame, and when turning off the menu bar. */
3352 free_frame_menubar (struct frame
*f
)
3354 struct x_output
*x
= f
->output_data
.x
;
3356 if (x
->menubar_widget
)
3360 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3361 /* The menubar and its children shall be deleted when removed from
3363 x
->menubar_widget
= 0;
3364 FRAME_MENUBAR_HEIGHT (f
) = 0;
3365 adjust_frame_size (f
, -1, -1, 2, 0, Qmenu_bar_lines
);
3371 xg_event_is_for_menubar (struct frame
*f
, const XEvent
*event
)
3373 struct x_output
*x
= f
->output_data
.x
;
3382 if (! x
->menubar_widget
) return 0;
3384 if (! (event
->xbutton
.x
>= 0
3385 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3386 && event
->xbutton
.y
>= 0
3387 && event
->xbutton
.y
< FRAME_MENUBAR_HEIGHT (f
)
3388 && event
->xbutton
.same_screen
))
3391 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3392 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3394 gevent
.any
.window
= gw
;
3395 gevent
.any
.type
= GDK_NOTHING
;
3396 gwdesc
= gtk_get_event_widget (&gevent
);
3397 if (! gwdesc
) return 0;
3398 if (! GTK_IS_MENU_BAR (gwdesc
)
3399 && ! GTK_IS_MENU_ITEM (gwdesc
)
3400 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3403 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3404 if (! list
) return 0;
3405 rec
.x
= event
->xbutton
.x
;
3406 rec
.y
= event
->xbutton
.y
;
3410 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3412 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3413 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3422 /***********************************************************************
3423 Scroll bar functions
3424 ***********************************************************************/
3427 /* Setting scroll bar values invokes the callback. Use this variable
3428 to indicate that callback should do nothing. */
3430 bool xg_ignore_gtk_scrollbar
;
3432 /* Width and height of scroll bars for the current theme. */
3433 static int scroll_bar_width_for_theme
;
3434 static int scroll_bar_height_for_theme
;
3436 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3437 may be larger than 32 bits. Keep a mapping from integer index to widget
3438 pointers to get around the 32 bit limitation. */
3442 GtkWidget
**widgets
;
3447 /* Grow this much every time we need to allocate more */
3449 #define ID_TO_WIDGET_INCR 32
3451 /* Store the widget pointer W in id_to_widget and return the integer index. */
3454 xg_store_widget_in_map (GtkWidget
*w
)
3458 if (id_to_widget
.max_size
== id_to_widget
.used
)
3461 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3462 memory_full (SIZE_MAX
);
3464 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3465 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3466 new_size
, sizeof (GtkWidget
*));
3468 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3469 id_to_widget
.widgets
[i
] = 0;
3470 id_to_widget
.max_size
= new_size
;
3473 /* Just loop over the array and find a free place. After all,
3474 how many scroll bars are we creating? Should be a small number.
3475 The check above guarantees we will find a free place. */
3476 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3478 if (! id_to_widget
.widgets
[i
])
3480 id_to_widget
.widgets
[i
] = w
;
3481 ++id_to_widget
.used
;
3487 /* Should never end up here */
3491 /* Remove pointer at IDX from id_to_widget.
3492 Called when scroll bar is destroyed. */
3495 xg_remove_widget_from_map (ptrdiff_t idx
)
3497 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3499 id_to_widget
.widgets
[idx
] = 0;
3500 --id_to_widget
.used
;
3504 /* Get the widget pointer at IDX from id_to_widget. */
3507 xg_get_widget_from_map (ptrdiff_t idx
)
3509 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3510 return id_to_widget
.widgets
[idx
];
3516 update_theme_scrollbar_width (void)
3519 GtkAdjustment
*vadj
;
3526 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3527 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3528 g_object_ref_sink (G_OBJECT (wscroll
));
3529 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3530 gtk_widget_destroy (wscroll
);
3531 g_object_unref (G_OBJECT (wscroll
));
3536 scroll_bar_width_for_theme
= w
;
3540 update_theme_scrollbar_height (void)
3543 GtkAdjustment
*hadj
;
3550 hadj
= gtk_adjustment_new (YG_SB_MIN
, YG_SB_MIN
, YG_SB_MAX
, 0.1, 0.1, 0.1);
3551 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL
, GTK_ADJUSTMENT (hadj
));
3552 g_object_ref_sink (G_OBJECT (wscroll
));
3553 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3554 gtk_widget_destroy (wscroll
);
3555 g_object_unref (G_OBJECT (wscroll
));
3558 scroll_bar_height_for_theme
= w
;
3562 xg_get_default_scrollbar_width (void)
3564 return scroll_bar_width_for_theme
* xg_get_gdk_scale ();
3568 xg_get_default_scrollbar_height (void)
3570 /* Apparently there's no default height for themes. */
3571 return scroll_bar_width_for_theme
* xg_get_gdk_scale ();
3574 /* Return the scrollbar id for X Window WID on display DPY.
3575 Return -1 if WID not in id_to_widget. */
3578 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3583 w
= xg_win_to_widget (dpy
, wid
);
3587 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3588 if (id_to_widget
.widgets
[idx
] == w
)
3595 /* Callback invoked when scroll bar WIDGET is destroyed.
3596 DATA is the index into id_to_widget for WIDGET.
3597 We free pointer to last scroll bar values here and remove the index. */
3600 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3602 intptr_t id
= (intptr_t) data
;
3603 xg_remove_widget_from_map (id
);
3606 /* Create a scroll bar widget for frame F. Store the scroll bar
3608 SCROLL_CALLBACK is the callback to invoke when the value of the
3610 END_CALLBACK is the callback to invoke when scrolling ends.
3611 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3612 to set resources for the widget. */
3615 xg_create_scroll_bar (struct frame
*f
,
3616 struct scroll_bar
*bar
,
3617 GCallback scroll_callback
,
3618 GCallback end_callback
,
3619 const char *scroll_bar_name
)
3625 GtkAdjustment
*vadj
;
3630 /* Page, step increment values are not so important here, they
3631 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3632 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3635 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3636 webox
= gtk_event_box_new ();
3637 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3639 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3641 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3643 scroll_id
= xg_store_widget_in_map (wscroll
);
3645 g_signal_connect (G_OBJECT (wscroll
),
3647 G_CALLBACK (xg_gtk_scroll_destroy
),
3648 (gpointer
) scroll_id
);
3649 g_signal_connect (G_OBJECT (wscroll
),
3653 g_signal_connect (G_OBJECT (wscroll
),
3654 "button-release-event",
3658 /* The scroll bar widget does not draw on a window of its own. Instead
3659 it draws on the parent window, in this case the edit widget. So
3660 whenever the edit widget is cleared, the scroll bar needs to redraw
3661 also, which causes flicker. Put an event box between the edit widget
3662 and the scroll bar, so the scroll bar instead draws itself on the
3663 event box window. */
3664 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3665 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3668 /* Set the cursor to an arrow. */
3669 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3671 bar
->x_window
= scroll_id
;
3672 bar
->horizontal
= 0;
3675 /* Create a horizontal scroll bar widget for frame F. Store the scroll
3676 bar in BAR. SCROLL_CALLBACK is the callback to invoke when the value
3677 of the bar changes. END_CALLBACK is the callback to invoke when
3678 scrolling ends. SCROLL_BAR_NAME is the name we use for the scroll
3679 bar. Can be used to set resources for the widget. */
3682 xg_create_horizontal_scroll_bar (struct frame
*f
,
3683 struct scroll_bar
*bar
,
3684 GCallback scroll_callback
,
3685 GCallback end_callback
,
3686 const char *scroll_bar_name
)
3692 GtkAdjustment
*hadj
;
3697 /* Page, step increment values are not so important here, they
3698 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3699 hadj
= gtk_adjustment_new (YG_SB_MIN
, YG_SB_MIN
, YG_SB_MAX
,
3702 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL
, GTK_ADJUSTMENT (hadj
));
3703 webox
= gtk_event_box_new ();
3704 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3706 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3708 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3710 scroll_id
= xg_store_widget_in_map (wscroll
);
3712 g_signal_connect (G_OBJECT (wscroll
),
3714 G_CALLBACK (xg_gtk_scroll_destroy
),
3715 (gpointer
) scroll_id
);
3716 g_signal_connect (G_OBJECT (wscroll
),
3720 g_signal_connect (G_OBJECT (wscroll
),
3721 "button-release-event",
3725 /* The scroll bar widget does not draw on a window of its own. Instead
3726 it draws on the parent window, in this case the edit widget. So
3727 whenever the edit widget is cleared, the scroll bar needs to redraw
3728 also, which causes flicker. Put an event box between the edit widget
3729 and the scroll bar, so the scroll bar instead draws itself on the
3730 event box window. */
3731 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3732 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3735 /* Set the cursor to an arrow. */
3736 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3738 bar
->x_window
= scroll_id
;
3739 bar
->horizontal
= 1;
3742 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3745 xg_remove_scroll_bar (struct frame
*f
, ptrdiff_t scrollbar_id
)
3747 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3750 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3751 gtk_widget_destroy (w
);
3752 gtk_widget_destroy (wparent
);
3753 SET_FRAME_GARBAGED (f
);
3757 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3759 TOP/LEFT are the new pixel positions where the bar shall appear.
3760 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3763 xg_update_scrollbar_pos (struct frame
*f
,
3764 ptrdiff_t scrollbar_id
,
3770 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3773 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3774 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3776 int scale
= xg_get_gdk_scale ();
3781 left
-= (scale
- 1) * ((width
/ scale
) >> 1);
3783 /* Clear out old position. */
3784 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3785 if (gtk_widget_get_parent (wparent
) == wfixed
)
3787 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3788 "x", &oldx
, "y", &oldy
, NULL
);
3789 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3792 /* Move and resize to new values. */
3793 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3794 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3797 /* No room. Hide scroll bar as some themes output a warning if
3798 the height is less than the min size. */
3799 gtk_widget_hide (wparent
);
3800 gtk_widget_hide (wscroll
);
3804 gtk_widget_show_all (wparent
);
3805 gtk_widget_set_size_request (wscroll
, width
, height
);
3808 gtk_widget_queue_draw (wfixed
);
3809 gdk_window_process_all_updates ();
3811 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3813 /* Clear under old scroll bar position. This must be done after
3814 the gtk_widget_queue_draw and gdk_window_process_all_updates
3816 oldw
+= (scale
- 1) * oldw
;
3817 oldx
-= (scale
- 1) * oldw
;
3818 x_clear_area (f
, oldx
, oldy
, oldw
, oldh
);
3821 /* GTK does not redraw until the main loop is entered again, but
3822 if there are no X events pending we will not enter it. So we sync
3823 here to get some events. */
3826 SET_FRAME_GARBAGED (f
);
3827 cancel_mouse_face (f
);
3832 /* Update the position of the horizontal scroll bar represented by SCROLLBAR_ID
3834 TOP/LEFT are the new pixel positions where the bar shall appear.
3835 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3838 xg_update_horizontal_scrollbar_pos (struct frame
*f
,
3839 ptrdiff_t scrollbar_id
,
3846 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3850 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3851 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3854 /* Clear out old position. */
3855 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3856 if (gtk_widget_get_parent (wparent
) == wfixed
)
3858 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3859 "x", &oldx
, "y", &oldy
, NULL
);
3860 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3863 /* Move and resize to new values. */
3864 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3865 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3868 /* No room. Hide scroll bar as some themes output a warning if
3869 the width is less than the min size. */
3870 gtk_widget_hide (wparent
);
3871 gtk_widget_hide (wscroll
);
3875 gtk_widget_show_all (wparent
);
3876 gtk_widget_set_size_request (wscroll
, width
, height
);
3878 gtk_widget_queue_draw (wfixed
);
3879 gdk_window_process_all_updates ();
3880 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3881 /* Clear under old scroll bar position. This must be done after
3882 the gtk_widget_queue_draw and gdk_window_process_all_updates
3885 oldx
, oldy
, oldw
, oldh
);
3887 /* GTK does not redraw until the main loop is entered again, but
3888 if there are no X events pending we will not enter it. So we sync
3889 here to get some events. */
3892 SET_FRAME_GARBAGED (f
);
3893 cancel_mouse_face (f
);
3898 /* Get the current value of the range, truncated to an integer. */
3901 int_gtk_range_get_value (GtkRange
*range
)
3903 return gtk_range_get_value (range
);
3907 /* Set the thumb size and position of scroll bar BAR. We are currently
3908 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3911 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3916 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3918 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3920 if (wscroll
&& bar
->dragging
== -1)
3930 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3932 if (scroll_bar_adjust_thumb_portion_p
)
3934 /* We do the same as for MOTIF in xterm.c, use 30 chars per
3935 line rather than the real portion value. This makes the
3936 thumb less likely to resize and that looks better. */
3937 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3939 /* When the thumb is at the bottom, position == whole.
3940 So we need to increase `whole' to make space for the thumb. */
3948 top
= (gdouble
) position
/ whole
;
3949 shown
= (gdouble
) portion
/ whole
;
3952 size
= clip_to_bounds (1, shown
* XG_SB_RANGE
, XG_SB_RANGE
);
3953 value
= clip_to_bounds (XG_SB_MIN
, top
* XG_SB_RANGE
, XG_SB_MAX
- size
);
3955 /* Assume all lines are of equal size. */
3956 new_step
= size
/ max (1, FRAME_LINES (f
));
3958 old_size
= gtk_adjustment_get_page_size (adj
);
3959 if (old_size
!= size
)
3961 int old_step
= gtk_adjustment_get_step_increment (adj
);
3962 if (old_step
!= new_step
)
3964 gtk_adjustment_set_page_size (adj
, size
);
3965 gtk_adjustment_set_step_increment (adj
, new_step
);
3966 /* Assume a page increment is about 95% of the page size */
3967 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3972 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3976 /* gtk_range_set_value invokes the callback. Set
3977 ignore_gtk_scrollbar to make the callback do nothing */
3978 xg_ignore_gtk_scrollbar
= 1;
3980 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3981 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3983 gtk_adjustment_changed (adj
);
3985 xg_ignore_gtk_scrollbar
= 0;
3992 /* Set the thumb size and position of horizontal scroll bar BAR. We are
3993 currently displaying PORTION out of a whole WHOLE, and our position
3996 xg_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
,
4001 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
4003 if (wscroll
&& bar
->dragging
== -1)
4007 int upper
= max (whole
- 1, 0);
4008 int pagesize
= min (upper
, max (portion
, 0));
4009 int value
= max (0, min (position
, upper
- pagesize
));
4010 /* These should be set to something more <portion, whole>
4012 int page_increment
= 4;
4013 int step_increment
= 1;
4016 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
4017 gtk_adjustment_configure (adj
, (gdouble
) value
, (gdouble
) lower
,
4018 (gdouble
) upper
, (gdouble
) step_increment
,
4019 (gdouble
) page_increment
, (gdouble
) pagesize
);
4020 gtk_adjustment_changed (adj
);
4025 /* Return true if EVENT is for a scroll bar in frame F.
4026 When the same X window is used for several Gtk+ widgets, we cannot
4027 say for sure based on the X window alone if an event is for the
4028 frame. This function does additional checks. */
4031 xg_event_is_for_scrollbar (struct frame
*f
, const XEvent
*event
)
4035 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
4037 /* Check if press occurred outside the edit widget. */
4038 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
4041 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
4042 (gdk_display_get_device_manager (gdpy
));
4043 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
4045 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
4047 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
4050 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
4051 || event
->type
== MotionNotify
))
4053 /* If we are releasing or moving the scroll bar, it has the grab. */
4054 GtkWidget
*w
= gtk_grab_get_current ();
4055 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
4062 /***********************************************************************
4064 ***********************************************************************/
4066 static GtkPrintSettings
*print_settings
= NULL
;
4067 static GtkPageSetup
*page_setup
= NULL
;
4070 xg_page_setup_dialog (void)
4072 GtkPageSetup
*new_page_setup
= NULL
;
4074 if (print_settings
== NULL
)
4075 print_settings
= gtk_print_settings_new ();
4076 new_page_setup
= gtk_print_run_page_setup_dialog (NULL
, page_setup
,
4079 g_object_unref (page_setup
);
4080 page_setup
= new_page_setup
;
4084 xg_get_page_setup (void)
4086 Lisp_Object result
, orientation_symbol
;
4087 GtkPageOrientation orientation
;
4089 if (page_setup
== NULL
)
4090 page_setup
= gtk_page_setup_new ();
4091 result
= list4 (Fcons (Qleft_margin
,
4092 make_float (gtk_page_setup_get_left_margin (page_setup
,
4094 Fcons (Qright_margin
,
4095 make_float (gtk_page_setup_get_right_margin (page_setup
,
4098 make_float (gtk_page_setup_get_top_margin (page_setup
,
4100 Fcons (Qbottom_margin
,
4101 make_float (gtk_page_setup_get_bottom_margin (page_setup
,
4102 GTK_UNIT_POINTS
))));
4103 result
= Fcons (Fcons (Qheight
,
4104 make_float (gtk_page_setup_get_page_height (page_setup
,
4107 result
= Fcons (Fcons (Qwidth
,
4108 make_float (gtk_page_setup_get_page_width (page_setup
,
4111 orientation
= gtk_page_setup_get_orientation (page_setup
);
4112 if (orientation
== GTK_PAGE_ORIENTATION_PORTRAIT
)
4113 orientation_symbol
= Qportrait
;
4114 else if (orientation
== GTK_PAGE_ORIENTATION_LANDSCAPE
)
4115 orientation_symbol
= Qlandscape
;
4116 else if (orientation
== GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT
)
4117 orientation_symbol
= Qreverse_portrait
;
4118 else if (orientation
== GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE
)
4119 orientation_symbol
= Qreverse_landscape
;
4120 result
= Fcons (Fcons (Qorientation
, orientation_symbol
), result
);
4126 draw_page (GtkPrintOperation
*operation
, GtkPrintContext
*context
,
4127 gint page_nr
, gpointer user_data
)
4129 Lisp_Object frames
= *((Lisp_Object
*) user_data
);
4130 struct frame
*f
= XFRAME (Fnth (make_number (page_nr
), frames
));
4131 cairo_t
*cr
= gtk_print_context_get_cairo_context (context
);
4133 x_cr_draw_frame (cr
, f
);
4137 xg_print_frames_dialog (Lisp_Object frames
)
4139 GtkPrintOperation
*print
;
4140 GtkPrintOperationResult res
;
4142 print
= gtk_print_operation_new ();
4143 if (print_settings
!= NULL
)
4144 gtk_print_operation_set_print_settings (print
, print_settings
);
4145 if (page_setup
!= NULL
)
4146 gtk_print_operation_set_default_page_setup (print
, page_setup
);
4147 gtk_print_operation_set_n_pages (print
, XINT (Flength (frames
)));
4148 g_signal_connect (print
, "draw-page", G_CALLBACK (draw_page
), &frames
);
4149 res
= gtk_print_operation_run (print
, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG
,
4151 if (res
== GTK_PRINT_OPERATION_RESULT_APPLY
)
4153 if (print_settings
!= NULL
)
4154 g_object_unref (print_settings
);
4156 g_object_ref (gtk_print_operation_get_print_settings (print
));
4158 g_object_unref (print
);
4161 #endif /* USE_CAIRO */
4165 /***********************************************************************
4167 ***********************************************************************/
4168 /* The key for the data we put in the GtkImage widgets. The data is
4169 the image used by Emacs. We use this to see if we need to update
4170 the GtkImage with a new image. */
4171 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
4173 /* The key for storing the latest modifiers so the activate callback can
4175 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
4177 /* The key for the data we put in the GtkImage widgets. The data is
4178 the stock name used by Emacs. We use this to see if we need to update
4179 the GtkImage with a new image. */
4180 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
4182 /* As above, but this is used for named theme widgets, as opposed to
4184 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
4186 /* Callback function invoked when a tool bar item is pressed.
4187 W is the button widget in the tool bar that got pressed,
4188 CLIENT_DATA is an integer that is the index of the button in the
4189 tool bar. 0 is the first button. */
4192 xg_tool_bar_button_cb (GtkWidget
*widget
,
4193 GdkEventButton
*event
,
4196 intptr_t state
= event
->state
;
4197 gpointer ptr
= (gpointer
) state
;
4198 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
4203 /* Callback function invoked when a tool bar item is pressed.
4204 W is the button widget in the tool bar that got pressed,
4205 CLIENT_DATA is an integer that is the index of the button in the
4206 tool bar. 0 is the first button. */
4209 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
4211 intptr_t idx
= (intptr_t) client_data
;
4212 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
4213 intptr_t mod
= (intptr_t) gmod
;
4215 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4216 Lisp_Object key
, frame
;
4217 struct input_event event
;
4220 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4223 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4225 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
4226 XSETFRAME (frame
, f
);
4228 /* We generate two events here. The first one is to set the prefix
4229 to `(tool_bar)', see keyboard.c. */
4230 event
.kind
= TOOL_BAR_EVENT
;
4231 event
.frame_or_window
= frame
;
4233 kbd_buffer_store_event (&event
);
4235 event
.kind
= TOOL_BAR_EVENT
;
4236 event
.frame_or_window
= frame
;
4238 /* Convert between the modifier bits GDK uses and the modifier bits
4239 Emacs uses. This assumes GDK and X masks are the same, which they are when
4241 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), mod
);
4242 kbd_buffer_store_event (&event
);
4244 /* Return focus to the frame after we have clicked on a detached
4250 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
4252 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
4253 GtkWidget
*c1
= clist
->data
;
4254 GtkWidget
*c2
= clist
->next
? clist
->next
->data
: NULL
;
4256 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
4257 g_list_free (clist
);
4258 return GTK_IS_LABEL (c1
) ? c1
: c2
;
4262 /* This callback is called when the mouse enters or leaves a tool bar item.
4263 It is used for displaying and hiding the help text.
4264 W is the tool bar item, a button.
4265 EVENT is either an enter event or leave event.
4266 CLIENT_DATA is an integer that is the index of the button in the
4267 tool bar. 0 is the first button.
4269 Returns FALSE to tell GTK to keep processing this event. */
4272 xg_tool_bar_help_callback (GtkWidget
*w
,
4273 GdkEventCrossing
*event
,
4274 gpointer client_data
)
4276 intptr_t idx
= (intptr_t) client_data
;
4277 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4278 Lisp_Object help
, frame
;
4280 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4283 if (event
->type
== GDK_ENTER_NOTIFY
)
4285 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4286 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4289 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4294 XSETFRAME (frame
, f
);
4295 kbd_buffer_store_help_event (frame
, help
);
4301 /* This callback is called when a tool bar item shall be redrawn.
4302 It modifies the expose event so that the GtkImage widget redraws the
4303 whole image. This to overcome a bug that makes GtkImage draw the image
4304 in the wrong place when it tries to redraw just a part of the image.
4305 W is the GtkImage to be redrawn.
4306 EVENT is the expose event for W.
4307 CLIENT_DATA is unused.
4309 Returns FALSE to tell GTK to keep processing this event. */
4313 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4314 GdkEventExpose
*event
,
4315 gpointer client_data
)
4319 gdk_drawable_get_size (event
->window
, &width
, &height
);
4320 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4321 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4323 event
->area
.x
= max (0, event
->area
.x
);
4324 event
->area
.y
= max (0, event
->area
.y
);
4326 event
->area
.width
= max (width
, event
->area
.width
);
4327 event
->area
.height
= max (height
, event
->area
.height
);
4333 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4334 #define toolbar_set_orientation(w, o) \
4335 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4337 #define toolbar_set_orientation(w, o) \
4338 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4341 /* Attach a tool bar to frame F. */
4344 xg_pack_tool_bar (struct frame
*f
, Lisp_Object pos
)
4346 struct x_output
*x
= f
->output_data
.x
;
4347 bool into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4348 GtkWidget
*top_widget
= x
->toolbar_widget
;
4350 toolbar_set_orientation (x
->toolbar_widget
,
4352 ? GTK_ORIENTATION_VERTICAL
4353 : GTK_ORIENTATION_HORIZONTAL
);
4357 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), top_widget
,
4360 if (EQ (pos
, Qleft
))
4361 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4364 x
->toolbar_in_hbox
= true;
4368 bool vbox_pos
= x
->menubar_widget
!= 0;
4369 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), top_widget
,
4373 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4376 x
->toolbar_in_hbox
= false;
4378 x
->toolbar_is_packed
= true;
4381 static bool xg_update_tool_bar_sizes (struct frame
*f
);
4384 tb_size_cb (GtkWidget
*widget
,
4385 GdkRectangle
*allocation
,
4388 /* When tool bar is created it has one preferred size. But when size is
4389 allocated between widgets, it may get another. So we must update
4390 size hints if tool bar size changes. Seen on Fedora 18 at least. */
4391 struct frame
*f
= user_data
;
4393 if (xg_update_tool_bar_sizes (f
))
4395 frame_size_history_add (f
, Qtb_size_cb
, 0, 0, Qnil
);
4396 adjust_frame_size (f
, -1, -1, 5, 0, Qtool_bar_lines
);
4400 /* Create a tool bar for frame F. */
4403 xg_create_tool_bar (struct frame
*f
)
4405 struct x_output
*x
= f
->output_data
.x
;
4406 #if GTK_CHECK_VERSION (3, 3, 6)
4407 GtkStyleContext
*gsty
;
4409 struct xg_frame_tb_info
*tbinfo
4410 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4414 tbinfo
= xmalloc (sizeof (*tbinfo
));
4415 tbinfo
->last_tool_bar
= Qnil
;
4416 tbinfo
->style
= Qnil
;
4417 tbinfo
->hmargin
= tbinfo
->vmargin
= 0;
4418 tbinfo
->dir
= GTK_TEXT_DIR_NONE
;
4419 tbinfo
->n_last_items
= 0;
4420 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4425 x
->toolbar_widget
= gtk_toolbar_new ();
4427 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4429 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4430 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4431 g_signal_connect (x
->toolbar_widget
, "size-allocate",
4432 G_CALLBACK (tb_size_cb
), f
);
4433 #if GTK_CHECK_VERSION (3, 3, 6)
4434 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4435 gtk_style_context_add_class (gsty
, "primary-toolbar");
4440 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4442 /* Find the right-to-left image named by RTL in the tool bar images for F.
4443 Returns IMAGE if RTL is not found. */
4446 find_rtl_image (struct frame
*f
, Lisp_Object image
, Lisp_Object rtl
)
4449 Lisp_Object file
, rtl_name
;
4451 rtl_name
= Ffile_name_nondirectory (rtl
);
4453 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4455 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4456 if (!NILP (file
= file_for_image (rtl_image
)))
4458 file
= call1 (intern ("file-name-sans-extension"),
4459 Ffile_name_nondirectory (file
));
4460 if (! NILP (Fequal (file
, rtl_name
)))
4471 static GtkToolItem
*
4472 xg_make_tool_item (struct frame
*f
,
4474 GtkWidget
**wbutton
,
4476 int i
, bool horiz
, bool text_image
)
4478 GtkToolItem
*ti
= gtk_tool_item_new ();
4479 GtkWidget
*vb
= gtk_box_new (horiz
4480 ? GTK_ORIENTATION_HORIZONTAL
4481 : GTK_ORIENTATION_VERTICAL
,
4483 GtkWidget
*wb
= gtk_button_new ();
4484 /* The eventbox is here so we can have tooltips on disabled items. */
4485 GtkWidget
*weventbox
= gtk_event_box_new ();
4486 #if GTK_CHECK_VERSION (3, 3, 6)
4487 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4488 GtkStyleContext
*gsty
;
4490 gtk_css_provider_load_from_data (css_prov
,
4492 " background-color: transparent;"
4496 gsty
= gtk_widget_get_style_context (weventbox
);
4497 gtk_style_context_add_provider (gsty
,
4498 GTK_STYLE_PROVIDER (css_prov
),
4499 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4500 g_object_unref (css_prov
);
4503 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4505 if (wimage
&& !text_image
)
4506 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4508 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4509 if (wimage
&& text_image
)
4510 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4512 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4513 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4514 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4515 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4516 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4518 if (wimage
|| label
)
4521 gpointer gi
= (gpointer
) ii
;
4523 g_signal_connect (G_OBJECT (wb
), "clicked",
4524 G_CALLBACK (xg_tool_bar_callback
),
4527 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4530 /* Catch expose events to overcome an annoying redraw bug, see
4531 comment for xg_tool_bar_item_expose_callback. */
4532 g_signal_connect (G_OBJECT (ti
),
4534 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4537 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4539 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4540 no distinction based on modifiers in the activate callback,
4541 so we have to do it ourselves. */
4542 g_signal_connect (wb
, "button-release-event",
4543 G_CALLBACK (xg_tool_bar_button_cb
),
4546 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4548 /* Use enter/leave notify to show help. We use the events
4549 rather than the GtkButton specific signals "enter" and
4550 "leave", so we can have only one callback. The event
4551 will tell us what kind of event it is. */
4552 g_signal_connect (G_OBJECT (weventbox
),
4553 "enter-notify-event",
4554 G_CALLBACK (xg_tool_bar_help_callback
),
4556 g_signal_connect (G_OBJECT (weventbox
),
4557 "leave-notify-event",
4558 G_CALLBACK (xg_tool_bar_help_callback
),
4562 if (wbutton
) *wbutton
= wb
;
4568 is_box_type (GtkWidget
*vb
, bool is_horizontal
)
4572 if (GTK_IS_BOX (vb
))
4574 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4575 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4576 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4580 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4586 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4587 const char *icon_name
, const struct image
*img
,
4588 const char *label
, bool horiz
)
4592 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4593 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4595 /* Check if the tool icon matches. */
4596 if (stock_name
&& wimage
)
4598 old
= g_object_get_data (G_OBJECT (wimage
),
4599 XG_TOOL_BAR_STOCK_NAME
);
4600 if (!old
|| strcmp (old
, stock_name
))
4603 else if (icon_name
&& wimage
)
4605 old
= g_object_get_data (G_OBJECT (wimage
),
4606 XG_TOOL_BAR_ICON_NAME
);
4607 if (!old
|| strcmp (old
, icon_name
))
4612 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4613 XG_TOOL_BAR_IMAGE_DATA
);
4614 Pixmap old_img
= (Pixmap
) gold_img
;
4615 if (old_img
!= img
->pixmap
)
4619 /* Check button configuration and label. */
4620 if (is_box_type (vb
, horiz
)
4621 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4624 /* Ensure label is correct. */
4626 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4631 xg_update_tool_bar_sizes (struct frame
*f
)
4633 struct x_output
*x
= f
->output_data
.x
;
4635 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4636 GtkWidget
*top_widget
= x
->toolbar_widget
;
4638 gtk_widget_get_preferred_size (GTK_WIDGET (top_widget
), NULL
, &req
);
4639 if (x
->toolbar_in_hbox
)
4642 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4644 "position", &pos
, NULL
);
4645 if (pos
== 0) nl
= req
.width
;
4646 else nr
= req
.width
;
4651 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4653 "position", &pos
, NULL
);
4654 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4655 else nb
= req
.height
;
4658 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4659 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4660 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4661 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4663 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4664 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4665 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4666 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4667 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4668 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4677 find_icon_from_name (char *name
,
4678 GtkIconTheme
*icon_theme
,
4681 #if ! GTK_CHECK_VERSION (3, 10, 0)
4682 GtkStockItem stock_item
;
4685 if (name
[0] == 'n' && name
[1] == ':')
4687 *icon_name
= name
+ 2;
4690 if (! gtk_icon_theme_has_icon (icon_theme
, *icon_name
))
4694 #if ! GTK_CHECK_VERSION (3, 10, 0)
4695 else if (gtk_stock_lookup (name
, &stock_item
))
4698 else if (gtk_icon_theme_has_icon (icon_theme
, name
))
4713 /* Update the tool bar for frame F. Add new buttons and remove old. */
4716 update_frame_tool_bar (struct frame
*f
)
4719 struct x_output
*x
= f
->output_data
.x
;
4720 int hmargin
= 0, vmargin
= 0;
4721 GtkToolbar
*wtoolbar
;
4723 GtkTextDirection dir
;
4725 bool text_image
, horiz
;
4726 struct xg_frame_tb_info
*tbinfo
;
4728 GtkIconTheme
*icon_theme
;
4731 if (! FRAME_GTK_WIDGET (f
))
4736 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4738 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4739 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4741 else if (CONSP (Vtool_bar_button_margin
))
4743 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4744 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4746 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4747 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4750 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4751 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4752 i.e. zero. This means that margins less than
4753 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4754 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4755 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4757 if (! x
->toolbar_widget
)
4758 xg_create_tool_bar (f
);
4760 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4761 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4763 style
= Ftool_bar_get_system_style ();
4764 screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4765 icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4767 /* Are we up to date? */
4768 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4771 if (! NILP (tbinfo
->last_tool_bar
) && ! NILP (f
->tool_bar_items
)
4772 && tbinfo
->n_last_items
== f
->n_tool_bar_items
4773 && tbinfo
->hmargin
== hmargin
&& tbinfo
->vmargin
== vmargin
4774 && tbinfo
->dir
== dir
4775 && ! NILP (Fequal (tbinfo
->style
, style
))
4776 && ! NILP (Fequal (tbinfo
->last_tool_bar
, f
->tool_bar_items
)))
4782 tbinfo
->last_tool_bar
= f
->tool_bar_items
;
4783 tbinfo
->n_last_items
= f
->n_tool_bar_items
;
4784 tbinfo
->style
= style
;
4785 tbinfo
->hmargin
= hmargin
;
4786 tbinfo
->vmargin
= vmargin
;
4789 text_image
= EQ (style
, Qtext_image_horiz
);
4790 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4792 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4794 bool enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4795 bool selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4799 struct image
*img
= NULL
;
4801 Lisp_Object stock
= Qnil
;
4802 char *stock_name
= NULL
;
4803 char *icon_name
= NULL
;
4805 GtkWidget
*wbutton
= NULL
;
4806 Lisp_Object specified_file
;
4807 bool vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4809 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4810 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4811 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4814 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4816 /* If this is a separator, use a gtk separator item. */
4817 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4819 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4822 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4824 ti
= gtk_separator_tool_item_new ();
4825 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4831 /* Otherwise, the tool-bar item is an ordinary button. */
4833 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4835 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4839 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4841 /* Ignore invalid image specifications. */
4842 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4843 if (!valid_image_p (image
))
4846 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4851 specified_file
= file_for_image (image
);
4852 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4853 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4858 for (tem
= stock
; CONSP (tem
); tem
= XCDR (tem
))
4859 if (! NILP (tem
) && STRINGP (XCAR (tem
)))
4861 stock_name
= find_icon_from_name (SSDATA (XCAR (tem
)),
4864 if (stock_name
|| icon_name
) break;
4867 else if (STRINGP (stock
))
4869 stock_name
= find_icon_from_name (SSDATA (stock
),
4874 if (stock_name
|| icon_name
)
4875 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4877 if (stock_name
== NULL
&& icon_name
== NULL
)
4879 /* No stock image, or stock item not known. Try regular
4880 image. If image is a vector, choose it according to the
4882 if (dir
== GTK_TEXT_DIR_RTL
4883 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4885 image
= find_rtl_image (f
, image
, rtl
);
4887 if (VECTORP (image
))
4891 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4892 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4895 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4896 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4898 eassert (ASIZE (image
) >= idx
);
4899 image
= AREF (image
, idx
);
4904 img_id
= lookup_image (f
, image
);
4905 img
= IMAGE_FROM_ID (f
, img_id
);
4906 prepare_image_for_display (f
, img
);
4908 if (img
->load_failed_p
|| img
->pixmap
== None
)
4911 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4917 /* If there is an existing widget, check if it's stale; if so,
4918 remove it and make a new tool item from scratch. */
4919 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4922 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4931 /* Save the image so we can see if an update is needed the
4932 next time we call xg_tool_item_match_p. */
4933 if (EQ (style
, Qtext
))
4935 else if (stock_name
)
4938 #if GTK_CHECK_VERSION (3, 10, 0)
4939 w
= gtk_image_new_from_icon_name (stock_name
, icon_size
);
4941 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4943 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4944 (gpointer
) xstrdup (stock_name
),
4945 (GDestroyNotify
) xfree
);
4949 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4950 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4951 (gpointer
) xstrdup (icon_name
),
4952 (GDestroyNotify
) xfree
);
4956 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4957 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4958 (gpointer
)img
->pixmap
);
4961 #if GTK_CHECK_VERSION (3, 14, 0)
4964 gtk_widget_set_margin_start (w
, hmargin
);
4965 gtk_widget_set_margin_end (w
, hmargin
);
4966 gtk_widget_set_margin_top (w
, vmargin
);
4967 gtk_widget_set_margin_bottom (w
, vmargin
);
4970 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4972 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4973 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4978 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4982 /* Remove buttons not longer needed. */
4985 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4987 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4988 } while (ti
!= NULL
);
4990 if (f
->n_tool_bar_items
!= 0)
4992 if (! x
->toolbar_is_packed
)
4993 xg_pack_tool_bar (f
, FRAME_TOOL_BAR_POSITION (f
));
4994 gtk_widget_show_all (x
->toolbar_widget
);
4995 if (xg_update_tool_bar_sizes (f
))
4998 = ((f
->after_make_frame
4999 && !f
->tool_bar_resized
5000 && (EQ (frame_inhibit_implied_resize
, Qt
)
5001 || (CONSP (frame_inhibit_implied_resize
)
5002 && !NILP (Fmemq (Qtool_bar_lines
,
5003 frame_inhibit_implied_resize
))))
5004 /* This will probably fail to DTRT in the
5005 fullheight/-width cases. */
5006 && NILP (get_frame_param (f
, Qfullscreen
)))
5010 frame_size_history_add (f
, Qupdate_frame_tool_bar
, 0, 0, Qnil
);
5011 adjust_frame_size (f
, -1, -1, inhibit
, 0, Qtool_bar_lines
);
5013 f
->tool_bar_resized
= f
->tool_bar_redisplayed
;
5019 /* Deallocate all resources for the tool bar on frame F.
5020 Remove the tool bar. */
5023 free_frame_tool_bar (struct frame
*f
)
5025 struct x_output
*x
= f
->output_data
.x
;
5027 if (x
->toolbar_widget
)
5029 struct xg_frame_tb_info
*tbinfo
;
5030 GtkWidget
*top_widget
= x
->toolbar_widget
;
5033 if (x
->toolbar_is_packed
)
5035 if (x
->toolbar_in_hbox
)
5036 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
5039 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
5043 gtk_widget_destroy (x
->toolbar_widget
);
5045 x
->toolbar_widget
= 0;
5046 x
->toolbar_widget
= 0;
5047 x
->toolbar_is_packed
= false;
5048 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
5049 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
5051 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
5056 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
5061 frame_size_history_add (f
, Qfree_frame_tool_bar
, 0, 0, Qnil
);
5062 adjust_frame_size (f
, -1, -1, 2, 0, Qtool_bar_lines
);
5069 xg_change_toolbar_position (struct frame
*f
, Lisp_Object pos
)
5071 struct x_output
*x
= f
->output_data
.x
;
5072 GtkWidget
*top_widget
= x
->toolbar_widget
;
5074 if (! x
->toolbar_widget
|| ! top_widget
)
5078 g_object_ref (top_widget
);
5079 if (x
->toolbar_is_packed
)
5081 if (x
->toolbar_in_hbox
)
5082 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
5085 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
5089 xg_pack_tool_bar (f
, pos
);
5090 g_object_unref (top_widget
);
5092 if (xg_update_tool_bar_sizes (f
))
5094 frame_size_history_add (f
, Qxg_change_toolbar_position
, 0, 0, Qnil
);
5095 adjust_frame_size (f
, -1, -1, 2, 0, Qtool_bar_lines
);
5104 /***********************************************************************
5106 ***********************************************************************/
5108 xg_initialize (void)
5110 GtkBindingSet
*binding_set
;
5111 GtkSettings
*settings
;
5114 /* Work around a bug with corrupted data if libXft gets unloaded. This way
5115 we keep it permanently linked in. */
5120 xg_ignore_gtk_scrollbar
= 0;
5121 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
5122 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
5124 id_to_widget
.max_size
= id_to_widget
.used
= 0;
5125 id_to_widget
.widgets
= 0;
5127 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
5128 (gdk_display_get_default ()));
5129 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
5130 bindings. It doesn't seem to be any way to remove properties,
5131 so we set it to "" which in means "no key". */
5132 gtk_settings_set_string_property (settings
,
5133 "gtk-menu-bar-accel",
5137 /* Make GTK text input widgets use Emacs style keybindings. This is
5139 gtk_settings_set_string_property (settings
,
5140 "gtk-key-theme-name",
5144 /* Make dialogs close on C-g. Since file dialog inherits from
5145 dialog, this works for them also. */
5146 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
5147 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5150 /* Make menus close on C-g. */
5151 binding_set
= gtk_binding_set_by_class (g_type_class_ref
5152 (GTK_TYPE_MENU_SHELL
));
5153 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5155 update_theme_scrollbar_width ();
5156 update_theme_scrollbar_height ();
5158 #ifdef HAVE_FREETYPE
5159 x_last_font_name
= NULL
;
5163 #endif /* USE_GTK */