1 /* Functions for creating and updating GTK widgets.
3 Copyright (C) 2003-2015 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
30 #include "blockinput.h"
31 #include "syssignal.h"
35 #include "termhooks.h"
41 #include <gdk/gdkkeysyms.h>
42 #include "xsettings.h"
45 #include <X11/Xft/Xft.h>
50 #include "emacsgtkfixed.h"
53 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
54 #define gtk_widget_set_has_window(w, b) \
55 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
57 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
58 #define gtk_dialog_get_action_area(w) ((w)->action_area)
59 #define gtk_dialog_get_content_area(w) ((w)->vbox)
61 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
62 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
64 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
65 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
66 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
67 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
68 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
70 #if GTK_CHECK_VERSION (2, 12, 0)
71 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
73 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
76 #if ! GTK_CHECK_VERSION (2, 14, 0)
77 #define gtk_adjustment_configure(adj, xvalue, xlower, \
78 xupper, xstep_increment, \
79 xpage_increment, xpagesize) \
81 adj->lower = xlower; \
82 adj->upper = xupper; \
83 adj->page_size = xpagesize; \
84 gtk_adjustment_set_value (adj, xvalue); \
85 adj->page_increment = xpage_increment; \
86 adj->step_increment = xstep_increment; \
88 #endif /* < Gtk+ 2.14 */
91 #if GTK_CHECK_VERSION (3, 2, 0)
92 #define USE_NEW_GTK_FONT_CHOOSER 1
94 #define USE_NEW_GTK_FONT_CHOOSER 0
95 #define gtk_font_chooser_dialog_new(x, y) \
96 gtk_font_selection_dialog_new (x)
97 #undef GTK_FONT_CHOOSER
98 #define GTK_FONT_CHOOSER(x) GTK_FONT_SELECTION_DIALOG (x)
99 #define gtk_font_chooser_set_font(x, y) \
100 gtk_font_selection_dialog_set_font_name (x, y)
102 #endif /* HAVE_FREETYPE */
104 #if GTK_CHECK_VERSION (3, 10, 0)
105 #define XG_TEXT_CANCEL "Cancel"
106 #define XG_TEXT_OK "OK"
107 #define XG_TEXT_OPEN "Open"
109 #define XG_TEXT_CANCEL GTK_STOCK_CANCEL
110 #define XG_TEXT_OK GTK_STOCK_OK
111 #define XG_TEXT_OPEN GTK_STOCK_OPEN
115 #ifdef USE_GTK_TOOLTIP
116 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
118 #define gdk_window_get_geometry(w, a, b, c, d) \
119 gdk_window_get_geometry (w, a, b, c, d, 0)
120 #define gdk_x11_window_lookup_for_display(d, w) \
121 gdk_xid_table_lookup_for_display (d, w)
122 #define gtk_box_new(ori, spacing) \
123 ((ori) == GTK_ORIENTATION_HORIZONTAL \
124 ? gtk_hbox_new (FALSE, (spacing)) : gtk_vbox_new (FALSE, (spacing)))
125 #define gtk_scrollbar_new(ori, spacing) \
126 ((ori) == GTK_ORIENTATION_HORIZONTAL \
127 ? gtk_hscrollbar_new ((spacing)) : gtk_vscrollbar_new ((spacing)))
129 #define GDK_KEY_g GDK_g
131 #endif /* HAVE_GTK3 */
133 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
135 static void update_theme_scrollbar_width (void);
136 static void update_theme_scrollbar_height (void);
138 #define TB_INFO_KEY "xg_frame_tb_info"
139 struct xg_frame_tb_info
141 Lisp_Object last_tool_bar
;
144 int hmargin
, vmargin
;
145 GtkTextDirection dir
;
149 /***********************************************************************
150 Display handling functions
151 ***********************************************************************/
153 /* Keep track of the default display, or NULL if there is none. Emacs
154 may close all its displays. */
156 static GdkDisplay
*gdpy_def
;
158 /* When the GTK widget W is to be created on a display for F that
159 is not the default display, set the display for W.
160 W can be a GtkMenu or a GtkWindow widget. */
163 xg_set_screen (GtkWidget
*w
, struct frame
*f
)
165 if (FRAME_X_DISPLAY (f
) != DEFAULT_GDK_DISPLAY ())
167 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
168 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
171 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
173 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
178 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
179 *DPY is set to NULL if the display can't be opened.
181 Returns non-zero if display could be opened, zero if display could not
182 be opened, and less than zero if the GTK version doesn't support
183 multiple displays. */
186 xg_display_open (char *display_name
, Display
**dpy
)
190 unrequest_sigio (); // See comment in x_display_ok, xterm.c.
191 gdpy
= gdk_display_open (display_name
);
193 if (!gdpy_def
&& gdpy
)
196 gdk_display_manager_set_default_display (gdk_display_manager_get (),
200 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
204 /* Close display DPY. */
207 xg_display_close (Display
*dpy
)
209 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
211 /* If this is the default display, try to change it before closing.
212 If there is no other display to use, gdpy_def is set to NULL, and
213 the next call to xg_display_open resets the default display. */
214 if (gdk_display_get_default () == gdpy
)
216 struct x_display_info
*dpyinfo
;
217 GdkDisplay
*gdpy_new
= NULL
;
219 /* Find another display. */
220 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
221 if (dpyinfo
->display
!= dpy
)
223 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
224 gdk_display_manager_set_default_display (gdk_display_manager_get (),
231 #if GTK_CHECK_VERSION (2, 0, 0) && ! GTK_CHECK_VERSION (2, 10, 0)
232 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
233 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
234 can continue running, but there will be memory leaks. */
235 g_object_run_dispose (G_OBJECT (gdpy
));
237 /* This seems to be fixed in GTK 2.10. */
238 gdk_display_close (gdpy
);
243 /***********************************************************************
245 ***********************************************************************/
247 /* Create and return the cursor to be used for popup menus and
248 scroll bars on display DPY. */
251 xg_create_default_cursor (Display
*dpy
)
253 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
254 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
258 xg_get_pixbuf_from_pixmap (struct frame
*f
, Pixmap pix
)
263 unsigned int width
, height
, uunused
;
266 XGetGeometry (FRAME_X_DISPLAY (f
), pix
, &wunused
, &iunused
, &iunused
,
267 &width
, &height
, &uunused
, &uunused
);
269 xim
= XGetImage (FRAME_X_DISPLAY (f
), pix
, 0, 0, width
, height
,
273 tmp_buf
= gdk_pixbuf_new_from_data ((guchar
*) xim
->data
,
286 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
289 xg_get_pixbuf_from_pix_and_mask (struct frame
*f
,
294 GdkPixbuf
*icon_buf
, *tmp_buf
;
296 tmp_buf
= xg_get_pixbuf_from_pixmap (f
, pix
);
297 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
298 g_object_unref (G_OBJECT (tmp_buf
));
300 width
= gdk_pixbuf_get_width (icon_buf
);
301 height
= gdk_pixbuf_get_height (icon_buf
);
305 GdkPixbuf
*mask_buf
= xg_get_pixbuf_from_pixmap (f
, mask
);
306 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
307 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
308 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
309 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
312 for (y
= 0; y
< height
; ++y
)
314 guchar
*iconptr
, *maskptr
;
317 iconptr
= pixels
+ y
* rowstride
;
318 maskptr
= mask_pixels
+ y
* mask_rowstride
;
320 for (x
= 0; x
< width
; ++x
)
322 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
323 just R is sufficient. */
325 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
327 iconptr
+= rowstride
/width
;
328 maskptr
+= mask_rowstride
/width
;
332 g_object_unref (G_OBJECT (mask_buf
));
339 file_for_image (Lisp_Object image
)
341 Lisp_Object specified_file
= Qnil
;
344 for (tail
= XCDR (image
);
345 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
346 tail
= XCDR (XCDR (tail
)))
347 if (EQ (XCAR (tail
), QCfile
))
348 specified_file
= XCAR (XCDR (tail
));
350 return specified_file
;
353 /* For the image defined in IMG, make and return a GtkImage. For displays with
354 8 planes or less we must make a GdkPixbuf and apply the mask manually.
355 Otherwise the highlighting and dimming the tool bar code in GTK does
356 will look bad. For display with more than 8 planes we just use the
357 pixmap and mask directly. For monochrome displays, GTK doesn't seem
358 able to use external pixmaps, it looks bad whatever we do.
359 The image is defined on the display where frame F is.
360 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
361 If OLD_WIDGET is NULL, a new widget is constructed and returned.
362 If OLD_WIDGET is not NULL, that widget is modified. */
365 xg_get_image_for_pixmap (struct frame
*f
,
368 GtkImage
*old_widget
)
372 /* If we have a file, let GTK do all the image handling.
373 This seems to be the only way to make insensitive and activated icons
374 look good in all cases. */
375 Lisp_Object specified_file
= file_for_image (img
->spec
);
378 /* We already loaded the image once before calling this
379 function, so this only fails if the image file has been removed.
380 In that case, use the pixmap already loaded. */
382 if (STRINGP (specified_file
)
383 && STRINGP (file
= x_find_image_file (specified_file
)))
385 char *encoded_file
= SSDATA (ENCODE_FILE (file
));
387 old_widget
= GTK_IMAGE (gtk_image_new_from_file (encoded_file
));
389 gtk_image_set_from_file (old_widget
, encoded_file
);
391 return GTK_WIDGET (old_widget
);
394 /* No file, do the image handling ourselves. This will look very bad
395 on a monochrome display, and sometimes bad on all displays with
398 /* This is a workaround to make icons look good on pseudo color
399 displays. Apparently GTK expects the images to have an alpha
400 channel. If they don't, insensitive and activated icons will
401 look bad. This workaround does not work on monochrome displays,
402 and is strictly not needed on true color/static color displays (i.e.
403 16 bits and higher). But we do it anyway so we get a pixbuf that is
404 not associated with the img->pixmap. The img->pixmap may be removed
405 by clearing the image cache and then the tool bar redraw fails, since
406 Gtk+ assumes the pixmap is always there. */
407 icon_buf
= xg_get_pixbuf_from_pix_and_mask (f
, img
->pixmap
, img
->mask
);
412 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
414 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
416 g_object_unref (G_OBJECT (icon_buf
));
419 return GTK_WIDGET (old_widget
);
423 /* Set CURSOR on W and all widgets W contain. We must do like this
424 for scroll bars and menu because they create widgets internally,
425 and it is those widgets that are visible. */
428 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
430 GdkWindow
*window
= gtk_widget_get_window (w
);
431 GList
*children
= gdk_window_peek_children (window
);
433 gdk_window_set_cursor (window
, cursor
);
435 /* The scroll bar widget has more than one GDK window (had to look at
436 the source to figure this out), and there is no way to set cursor
437 on widgets in GTK. So we must set the cursor for all GDK windows.
440 for ( ; children
; children
= g_list_next (children
))
441 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
444 /* Insert NODE into linked LIST. */
447 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
449 xg_list_node
*list_start
= list
->next
;
451 if (list_start
) list_start
->prev
= node
;
452 node
->next
= list_start
;
457 /* Remove NODE from linked LIST. */
460 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
462 xg_list_node
*list_start
= list
->next
;
463 if (node
== list_start
)
465 list
->next
= node
->next
;
466 if (list
->next
) list
->next
->prev
= 0;
470 node
->prev
->next
= node
->next
;
471 if (node
->next
) node
->next
->prev
= node
->prev
;
475 /* Allocate and return a utf8 version of STR. If STR is already
476 utf8 or NULL, just return a copy of STR.
477 A new string is allocated and the caller must free the result
481 get_utf8_string (const char *str
)
485 if (!str
) return NULL
;
487 /* If not UTF-8, try current locale. */
488 if (!g_utf8_validate (str
, -1, NULL
))
489 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
491 return g_strdup (str
);
495 /* Probably some control characters in str. Escape them. */
497 ptrdiff_t nr_bad
= 0;
500 unsigned char *p
= (unsigned char *)str
;
504 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
505 &bytes_written
, &err
))
506 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
509 p
+= bytes_written
+1;
522 if ((min (PTRDIFF_MAX
, SIZE_MAX
) - len
- 1) / 4 < nr_bad
)
523 memory_full (SIZE_MAX
);
524 up
= utf8_str
= xmalloc (len
+ nr_bad
* 4 + 1);
525 p
= (unsigned char *)str
;
527 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
528 &bytes_written
, &err
))
529 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
531 memcpy (up
, p
, bytes_written
);
533 up
+= sprintf (up
, "\\%03o", p
[bytes_written
]);
534 p
+= bytes_written
+ 1;
553 /* Check for special colors used in face spec for region face.
554 The colors are fetched from the Gtk+ theme.
555 Return true if color was found, false if not. */
558 xg_check_special_colors (struct frame
*f
,
559 const char *color_name
,
563 bool get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
564 bool get_fg
= !get_bg
&& strcmp ("gtk_selection_fg_color", color_name
) == 0;
566 if (! FRAME_GTK_WIDGET (f
) || ! (get_bg
|| get_fg
))
572 GtkStyleContext
*gsty
573 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f
));
575 char buf
[sizeof "rgb://rrrr/gggg/bbbb"];
576 int state
= GTK_STATE_FLAG_SELECTED
|GTK_STATE_FLAG_FOCUSED
;
578 gtk_style_context_get_color (gsty
, state
, &col
);
580 gtk_style_context_get_background_color (gsty
, state
, &col
);
582 sprintf (buf
, "rgb:%04x/%04x/%04x",
583 (unsigned) (col
.red
* 65535),
584 (unsigned) (col
.green
* 65535),
585 (unsigned) (col
.blue
* 65535));
586 success_p
= (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
590 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
591 GdkColor
*grgb
= get_bg
592 ? &gsty
->bg
[GTK_STATE_SELECTED
]
593 : &gsty
->fg
[GTK_STATE_SELECTED
];
595 color
->red
= grgb
->red
;
596 color
->green
= grgb
->green
;
597 color
->blue
= grgb
->blue
;
598 color
->pixel
= grgb
->pixel
;
609 /***********************************************************************
611 ***********************************************************************/
612 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
613 We use that to pop down the tooltip. This happens if Gtk+ for some
614 reason wants to change or hide the tooltip. */
616 #ifdef USE_GTK_TOOLTIP
619 hierarchy_ch_cb (GtkWidget
*widget
,
620 GtkWidget
*previous_toplevel
,
623 struct frame
*f
= user_data
;
624 struct x_output
*x
= f
->output_data
.x
;
625 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
627 if (! top
|| ! GTK_IS_WINDOW (top
))
628 gtk_widget_hide (previous_toplevel
);
631 /* Callback called when Gtk+ thinks a tooltip should be displayed.
632 We use it to get the tooltip window and the tooltip widget so
633 we can manipulate the ourselves.
635 Return FALSE ensures that the tooltip is not shown. */
638 qttip_cb (GtkWidget
*widget
,
641 gboolean keyboard_mode
,
645 struct frame
*f
= user_data
;
646 struct x_output
*x
= f
->output_data
.x
;
647 if (x
->ttip_widget
== NULL
)
652 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
653 x
->ttip_widget
= tooltip
;
654 g_object_ref (G_OBJECT (tooltip
));
655 x
->ttip_lbl
= gtk_label_new ("");
656 g_object_ref (G_OBJECT (x
->ttip_lbl
));
657 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
658 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
660 /* Change stupid Gtk+ default line wrapping. */
661 p
= gtk_widget_get_parent (x
->ttip_lbl
);
662 list
= gtk_container_get_children (GTK_CONTAINER (p
));
663 for (iter
= list
; iter
; iter
= g_list_next (iter
))
665 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
666 if (GTK_IS_LABEL (w
))
667 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
671 /* ATK needs an empty title for some reason. */
672 gtk_window_set_title (x
->ttip_window
, "");
673 /* Realize so we can safely get screen later on. */
674 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
675 gtk_widget_realize (x
->ttip_lbl
);
677 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
678 G_CALLBACK (hierarchy_ch_cb
), f
);
683 #endif /* USE_GTK_TOOLTIP */
685 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
686 Return true if a system tooltip is available. */
689 xg_prepare_tooltip (struct frame
*f
,
694 #ifndef USE_GTK_TOOLTIP
697 struct x_output
*x
= f
->output_data
.x
;
701 GtkSettings
*settings
;
702 gboolean tt_enabled
= TRUE
;
704 Lisp_Object encoded_string
;
706 if (!x
->ttip_lbl
) return 0;
709 encoded_string
= ENCODE_UTF_8 (string
);
710 widget
= GTK_WIDGET (x
->ttip_lbl
);
711 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
712 screen
= gdk_window_get_screen (gwin
);
713 settings
= gtk_settings_get_for_screen (screen
);
714 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
717 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
718 /* Record that we disabled it so it can be enabled again. */
719 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
723 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
724 g_object_set_data (G_OBJECT
725 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
726 "gdk-display-current-tooltip", NULL
);
728 /* Put our dummy widget in so we can get callbacks for unrealize and
729 hierarchy-changed. */
730 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
731 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
732 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
733 if (width
) *width
= req
.width
;
734 if (height
) *height
= req
.height
;
739 #endif /* USE_GTK_TOOLTIP */
742 /* Show the tooltip at ROOT_X and ROOT_Y.
743 xg_prepare_tooltip must have been called before this function. */
746 xg_show_tooltip (struct frame
*f
, int root_x
, int root_y
)
748 #ifdef USE_GTK_TOOLTIP
749 struct x_output
*x
= f
->output_data
.x
;
753 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
754 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
760 /* Hide tooltip if shown. Do nothing if not shown.
761 Return true if tip was hidden, false if not (i.e. not using
765 xg_hide_tooltip (struct frame
*f
)
768 #ifdef USE_GTK_TOOLTIP
769 if (f
->output_data
.x
->ttip_window
)
771 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
773 gtk_widget_hide (GTK_WIDGET (win
));
775 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
777 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
778 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
779 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
780 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
791 /***********************************************************************
792 General functions for creating widgets, resizing, events, e.t.c.
793 ***********************************************************************/
796 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
797 const gchar
*msg
, gpointer user_data
)
799 if (!strstr (msg
, "visible children"))
800 fprintf (stderr
, "XX %s-WARNING **: %s\n", log_domain
, msg
);
803 /* Make a geometry string and pass that to GTK. It seems this is the
804 only way to get geometry position right if the user explicitly
805 asked for a position when starting Emacs.
806 F is the frame we shall set geometry for. */
809 xg_set_geometry (struct frame
*f
)
811 if (f
->size_hint_flags
& (USPosition
| PPosition
))
813 int left
= f
->left_pos
;
814 int xneg
= f
->size_hint_flags
& XNegative
;
815 int top
= f
->top_pos
;
816 int yneg
= f
->size_hint_flags
& YNegative
;
817 char geom_str
[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
825 sprintf (geom_str
, "=%dx%d%c%d%c%d",
826 FRAME_PIXEL_WIDTH (f
),
827 FRAME_PIXEL_HEIGHT (f
),
828 (xneg
? '-' : '+'), left
,
829 (yneg
? '-' : '+'), top
);
831 /* Silence warning about visible children. */
832 id
= g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
833 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
835 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
837 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
839 g_log_remove_handler ("Gtk", id
);
843 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
844 and use a GtkFixed widget, this doesn't happen automatically. */
847 xg_clear_under_internal_border (struct frame
*f
)
849 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
852 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
854 gtk_widget_queue_draw (wfixed
);
855 gdk_window_process_all_updates ();
857 x_clear_area (f
, 0, 0,
858 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
860 x_clear_area (f
, 0, 0,
861 FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
864 FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
865 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
868 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
869 0, FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
874 xg_get_gdk_scale (void)
876 const char *sscale
= getenv ("GDK_SCALE");
880 long scale
= atol (sscale
);
882 return min (scale
, INT_MAX
);
888 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
889 and a Gtk+ menu bar, we get resize events for the edit part of the
890 frame only. We let Gtk+ deal with the Gtk+ parts.
891 F is the frame to resize.
892 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
895 xg_frame_resized (struct frame
*f
, int pixelwidth
, int pixelheight
)
899 if (pixelwidth
== -1 && pixelheight
== -1)
901 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
902 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
903 0, 0, &pixelwidth
, &pixelheight
);
908 width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, pixelwidth
);
909 height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelheight
);
911 frame_size_history_add
912 (f
, Qxg_frame_resized
, width
, height
, Qnil
);
914 if (width
!= FRAME_TEXT_WIDTH (f
)
915 || height
!= FRAME_TEXT_HEIGHT (f
)
916 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
917 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
919 xg_clear_under_internal_border (f
);
920 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
921 SET_FRAME_GARBAGED (f
);
922 cancel_mouse_face (f
);
924 do_pending_window_change (0);
928 /* Resize the outer window of frame F after changing the height.
929 COLUMNS/ROWS is the size the edit area shall have after the resize. */
932 xg_frame_set_char_size (struct frame
*f
, int width
, int height
)
934 int pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
935 int pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
936 Lisp_Object fullscreen
= get_frame_param (f
, Qfullscreen
);
937 gint gwidth
, gheight
;
939 = pixelheight
+ FRAME_TOOLBAR_HEIGHT (f
) + FRAME_MENUBAR_HEIGHT (f
);
940 int totalwidth
= pixelwidth
+ FRAME_TOOLBAR_WIDTH (f
);
942 if (FRAME_PIXEL_HEIGHT (f
) == 0)
945 gtk_window_get_size (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
948 /* Do this before resize, as we don't know yet if we will be resized. */
949 xg_clear_under_internal_border (f
);
951 if (FRAME_VISIBLE_P (f
))
953 int scale
= xg_get_gdk_scale ();
954 totalheight
/= scale
;
958 /* Resize the top level widget so rows and columns remain constant.
960 When the frame is fullheight and we only want to change the width
961 or it is fullwidth and we only want to change the height we should
962 be able to preserve the fullscreen property. However, due to the
963 fact that we have to send a resize request anyway, the window
964 manager will abolish it. At least the respective size should
965 remain unchanged but giving the frame back its normal size will
967 if (EQ (fullscreen
, Qfullwidth
) && width
== FRAME_TEXT_WIDTH (f
))
969 frame_size_history_add
970 (f
, Qxg_frame_set_char_size_1
, width
, height
,
971 list2 (make_number (gheight
),
972 make_number (totalheight
)));
974 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
978 else if (EQ (fullscreen
, Qfullheight
) && height
== FRAME_TEXT_HEIGHT (f
))
980 frame_size_history_add
981 (f
, Qxg_frame_set_char_size_2
, width
, height
,
982 list2 (make_number (gwidth
),
983 make_number (totalwidth
)));
985 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
991 frame_size_history_add
992 (f
, Qxg_frame_set_char_size_3
, width
, height
,
993 list2 (make_number (totalwidth
),
994 make_number (totalheight
)));
996 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1002 SET_FRAME_GARBAGED (f
);
1003 cancel_mouse_face (f
);
1005 x_wm_set_size_hint (f
, 0, 0);
1006 /* We can not call change_frame_size for a mapped frame,
1007 we can not set pixel width/height either. The window manager may
1008 override our resize request, XMonad does this all the time.
1009 The best we can do is try to sync, so lisp code sees the updated
1010 size as fast as possible.
1011 For unmapped windows, we can set rows/cols. When
1012 the frame is mapped again we will (hopefully) get the correct size. */
1013 if (FRAME_VISIBLE_P (f
))
1015 /* Must call this to flush out events */
1016 (void)gtk_events_pending ();
1018 x_wait_for_event (f
, ConfigureNotify
);
1020 if (!NILP (fullscreen
))
1021 /* Try to restore fullscreen state. */
1023 store_frame_param (f
, Qfullscreen
, fullscreen
);
1024 x_set_fullscreen (f
, fullscreen
, fullscreen
);
1028 adjust_frame_size (f
, width
, height
, 5, 0, Qxg_frame_set_char_size
);
1032 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
1033 The policy is to keep the number of editable lines. */
1037 xg_height_or_width_changed (struct frame
*f
)
1039 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1040 FRAME_TOTAL_PIXEL_WIDTH (f
),
1041 FRAME_TOTAL_PIXEL_HEIGHT (f
));
1042 f
->output_data
.x
->hint_flags
= 0;
1043 x_wm_set_size_hint (f
, 0, 0);
1047 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
1048 Must be done like this, because GtkWidget:s can have "hidden"
1049 X Window that aren't accessible.
1051 Return 0 if no widget match WDESC. */
1054 xg_win_to_widget (Display
*dpy
, Window wdesc
)
1057 GtkWidget
*gwdesc
= 0;
1061 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
1066 event
.any
.window
= gdkwin
;
1067 event
.any
.type
= GDK_NOTHING
;
1068 gwdesc
= gtk_get_event_widget (&event
);
1075 /* Set the background of widget W to PIXEL. */
1078 xg_set_widget_bg (struct frame
*f
, GtkWidget
*w
, unsigned long pixel
)
1084 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
1086 bg
.red
= (double)xbg
.red
/65535.0;
1087 bg
.green
= (double)xbg
.green
/65535.0;
1088 bg
.blue
= (double)xbg
.blue
/65535.0;
1090 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
1094 GdkColormap
*map
= gtk_widget_get_colormap (w
);
1095 gdk_colormap_query_color (map
, pixel
, &bg
);
1096 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
1100 /* Callback called when the gtk theme changes.
1101 We notify lisp code so it can fix faces used for region for example. */
1104 style_changed_cb (GObject
*go
,
1108 struct input_event event
;
1109 GdkDisplay
*gdpy
= user_data
;
1110 const char *display_name
= gdk_display_get_name (gdpy
);
1111 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1114 event
.kind
= CONFIG_CHANGED_EVENT
;
1115 event
.frame_or_window
= build_string (display_name
);
1116 /* Theme doesn't change often, so intern is called seldom. */
1117 event
.arg
= intern ("theme-name");
1118 kbd_buffer_store_event (&event
);
1120 update_theme_scrollbar_width ();
1121 update_theme_scrollbar_height ();
1123 /* If scroll bar width changed, we need set the new size on all frames
1127 Lisp_Object rest
, frame
;
1128 FOR_EACH_FRAME (rest
, frame
)
1130 struct frame
*f
= XFRAME (frame
);
1131 if (FRAME_LIVE_P (f
)
1133 && FRAME_X_DISPLAY (f
) == dpy
)
1135 x_set_scroll_bar_default_width (f
);
1136 x_set_scroll_bar_default_height (f
);
1137 xg_frame_set_char_size (f
, FRAME_TEXT_WIDTH (f
), FRAME_TEXT_HEIGHT (f
));
1143 /* Called when a delete-event occurs on WIDGET. */
1146 delete_cb (GtkWidget
*widget
,
1153 /* Create and set up the GTK widgets for frame F.
1154 Return true if creation succeeded. */
1157 xg_create_frame_widgets (struct frame
*f
)
1160 GtkWidget
*wvbox
, *whbox
;
1169 if (FRAME_X_EMBEDDED_P (f
))
1171 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1172 wtop
= gtk_plug_new_for_display (gdpy
, f
->output_data
.x
->parent_desc
);
1175 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1177 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1178 has backported it to Gtk+ 2.0 and they add the resize grip for
1179 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1180 forever, so disable the grip. */
1181 #if (! GTK_CHECK_VERSION (3, 0, 0) \
1182 && defined HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1183 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop
), FALSE
);
1186 xg_set_screen (wtop
, f
);
1188 wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1189 whbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1190 gtk_box_set_homogeneous (GTK_BOX (wvbox
), FALSE
);
1191 gtk_box_set_homogeneous (GTK_BOX (whbox
), FALSE
);
1194 wfixed
= emacs_fixed_new (f
);
1196 wfixed
= gtk_fixed_new ();
1199 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1201 if (wtop
) gtk_widget_destroy (wtop
);
1202 if (wvbox
) gtk_widget_destroy (wvbox
);
1203 if (whbox
) gtk_widget_destroy (whbox
);
1204 if (wfixed
) gtk_widget_destroy (wfixed
);
1210 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1211 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1212 gtk_widget_set_name (wvbox
, "pane");
1213 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1215 /* If this frame has a title or name, set it in the title bar. */
1216 if (! NILP (f
->title
))
1217 title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1218 else if (! NILP (f
->name
))
1219 title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1221 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1223 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1224 FRAME_GTK_WIDGET (f
) = wfixed
;
1225 f
->output_data
.x
->vbox_widget
= wvbox
;
1226 f
->output_data
.x
->hbox_widget
= whbox
;
1228 gtk_widget_set_has_window (wfixed
, TRUE
);
1230 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1231 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1232 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1234 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1235 update_frame_tool_bar (f
);
1237 /* We don't want this widget double buffered, because we draw on it
1238 with regular X drawing primitives, so from a GTK/GDK point of
1239 view, the widget is totally blank. When an expose comes, this
1240 will make the widget blank, and then Emacs redraws it. This flickers
1241 a lot, so we turn off double buffering. */
1242 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1244 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1245 SSDATA (Vx_resource_name
),
1246 SSDATA (Vx_resource_class
));
1248 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1249 GTK is to destroy the widget. We want Emacs to do that instead. */
1250 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1251 G_CALLBACK (delete_cb
), f
);
1253 /* Convert our geometry parameters into a geometry string
1255 GTK will itself handle calculating the real position this way. */
1256 xg_set_geometry (f
);
1258 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1260 gtk_widget_add_events (wfixed
,
1261 GDK_POINTER_MOTION_MASK
1263 | GDK_BUTTON_PRESS_MASK
1264 | GDK_BUTTON_RELEASE_MASK
1265 | GDK_KEY_PRESS_MASK
1266 | GDK_ENTER_NOTIFY_MASK
1267 | GDK_LEAVE_NOTIFY_MASK
1268 | GDK_FOCUS_CHANGE_MASK
1269 | GDK_STRUCTURE_MASK
1270 | GDK_VISIBILITY_NOTIFY_MASK
);
1272 /* Must realize the windows so the X window gets created. It is used
1273 by callers of this function. */
1274 gtk_widget_realize (wfixed
);
1275 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1277 /* Since GTK clears its window by filling with the background color,
1278 we must keep X and GTK background in sync. */
1279 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1282 /* Also, do not let any background pixmap to be set, this looks very
1283 bad as Emacs overwrites the background pixmap with its own idea
1284 of background color. */
1285 style
= gtk_widget_get_modifier_style (wfixed
);
1287 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1288 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1289 gtk_widget_modify_style (wfixed
, style
);
1291 gtk_widget_set_can_focus (wfixed
, TRUE
);
1292 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1295 #ifdef USE_GTK_TOOLTIP
1296 /* Steal a tool tip window we can move ourselves. */
1297 f
->output_data
.x
->ttip_widget
= 0;
1298 f
->output_data
.x
->ttip_lbl
= 0;
1299 f
->output_data
.x
->ttip_window
= 0;
1300 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1301 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1305 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1306 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1307 /* Only connect this signal once per screen. */
1308 if (! g_signal_handler_find (G_OBJECT (gs
),
1309 G_SIGNAL_MATCH_FUNC
,
1311 G_CALLBACK (style_changed_cb
),
1314 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1315 G_CALLBACK (style_changed_cb
),
1316 gdk_screen_get_display (screen
));
1326 xg_free_frame_widgets (struct frame
*f
)
1328 if (FRAME_GTK_OUTER_WIDGET (f
))
1330 #ifdef USE_GTK_TOOLTIP
1331 struct x_output
*x
= f
->output_data
.x
;
1333 struct xg_frame_tb_info
*tbinfo
1334 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
1339 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1340 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1341 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1342 #ifdef USE_GTK_TOOLTIP
1344 gtk_widget_destroy (x
->ttip_lbl
);
1346 g_object_unref (G_OBJECT (x
->ttip_widget
));
1351 /* Set the normal size hints for the window manager, for frame F.
1352 FLAGS is the flags word to use--or 0 meaning preserve the flags
1353 that the window now has.
1354 If USER_POSITION, set the User Position
1355 flag (this is useful when FLAGS is 0). */
1358 x_wm_set_size_hint (struct frame
*f
, long int flags
, bool user_position
)
1360 /* Must use GTK routines here, otherwise GTK resets the size hints
1361 to its own defaults. */
1362 GdkGeometry size_hints
;
1363 gint hint_flags
= 0;
1364 int base_width
, base_height
;
1365 int min_rows
= 0, min_cols
= 0;
1366 int win_gravity
= f
->win_gravity
;
1367 Lisp_Object fs_state
, frame
;
1368 int scale
= xg_get_gdk_scale ();
1370 /* Don't set size hints during initialization; that apparently leads
1371 to a race condition. See the thread at
1372 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1373 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1376 XSETFRAME (frame
, f
);
1377 fs_state
= Fframe_parameter (frame
, Qfullscreen
);
1378 if (EQ (fs_state
, Qmaximized
) || EQ (fs_state
, Qfullboth
))
1380 /* Don't set hints when maximized or fullscreen. Apparently KWin and
1381 Gtk3 don't get along and the frame shrinks (!).
1388 memset (&size_hints
, 0, sizeof (size_hints
));
1389 f
->output_data
.x
->size_hints
= size_hints
;
1390 f
->output_data
.x
->hint_flags
= hint_flags
;
1393 flags
= f
->size_hint_flags
;
1395 size_hints
= f
->output_data
.x
->size_hints
;
1396 hint_flags
= f
->output_data
.x
->hint_flags
;
1398 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1399 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
1400 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
1402 hint_flags
|= GDK_HINT_BASE_SIZE
;
1403 /* Use one row/col here so base_height/width does not become zero.
1404 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1405 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 1) + FRAME_TOOLBAR_WIDTH (f
);
1406 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 1)
1407 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1409 if (min_cols
> 0) --min_cols
; /* We used one col in base_width = ... 1); */
1410 if (min_rows
> 0) --min_rows
; /* We used one row in base_height = ... 1); */
1412 size_hints
.base_width
= base_width
;
1413 size_hints
.base_height
= base_height
;
1414 size_hints
.min_width
= base_width
+ min_cols
* FRAME_COLUMN_WIDTH (f
);
1415 size_hints
.min_height
= base_height
+ min_rows
* FRAME_LINE_HEIGHT (f
);
1417 /* These currently have a one to one mapping with the X values, but I
1418 don't think we should rely on that. */
1419 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1420 size_hints
.win_gravity
= 0;
1421 if (win_gravity
== NorthWestGravity
)
1422 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1423 else if (win_gravity
== NorthGravity
)
1424 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1425 else if (win_gravity
== NorthEastGravity
)
1426 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1427 else if (win_gravity
== WestGravity
)
1428 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1429 else if (win_gravity
== CenterGravity
)
1430 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1431 else if (win_gravity
== EastGravity
)
1432 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1433 else if (win_gravity
== SouthWestGravity
)
1434 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1435 else if (win_gravity
== SouthGravity
)
1436 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1437 else if (win_gravity
== SouthEastGravity
)
1438 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1439 else if (win_gravity
== StaticGravity
)
1440 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1444 hint_flags
&= ~GDK_HINT_POS
;
1445 hint_flags
|= GDK_HINT_USER_POS
;
1448 size_hints
.base_width
/= scale
;
1449 size_hints
.base_height
/= scale
;
1450 size_hints
.width_inc
/= scale
;
1451 size_hints
.height_inc
/= scale
;
1453 if (hint_flags
!= f
->output_data
.x
->hint_flags
1454 || memcmp (&size_hints
,
1455 &f
->output_data
.x
->size_hints
,
1456 sizeof (size_hints
)) != 0)
1459 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1460 NULL
, &size_hints
, hint_flags
);
1461 f
->output_data
.x
->size_hints
= size_hints
;
1462 f
->output_data
.x
->hint_flags
= hint_flags
;
1467 /* Change background color of a frame.
1468 Since GTK uses the background color to clear the window, we must
1469 keep the GTK and X colors in sync.
1470 F is the frame to change,
1471 BG is the pixel value to change to. */
1474 xg_set_background_color (struct frame
*f
, unsigned long bg
)
1476 if (FRAME_GTK_WIDGET (f
))
1479 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1485 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1486 functions so GTK does not overwrite the icon. */
1489 xg_set_frame_icon (struct frame
*f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1491 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1495 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1500 /***********************************************************************
1502 ***********************************************************************/
1503 /* Return the dialog title to use for a dialog of type KEY.
1504 This is the encoding used by lwlib. We use the same for GTK. */
1507 get_dialog_title (char key
)
1509 const char *title
= "";
1517 title
= "Information";
1536 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1537 the dialog, but return TRUE so the event does not propagate further
1538 in GTK. This prevents GTK from destroying the dialog widget automatically
1539 and we can always destroy the widget manually, regardless of how
1540 it was popped down (button press or WM_DELETE_WINDOW).
1541 W is the dialog widget.
1542 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1543 user_data is NULL (not used).
1545 Returns TRUE to end propagation of event. */
1548 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1550 gtk_widget_unmap (w
);
1554 /* Create a popup dialog window. See also xg_create_widget below.
1555 WV is a widget_value describing the dialog.
1556 SELECT_CB is the callback to use when a button has been pressed.
1557 DEACTIVATE_CB is the callback to use when the dialog pops down.
1559 Returns the GTK dialog widget. */
1562 create_dialog (widget_value
*wv
,
1563 GCallback select_cb
,
1564 GCallback deactivate_cb
)
1566 const char *title
= get_dialog_title (wv
->name
[0]);
1567 int total_buttons
= wv
->name
[1] - '0';
1568 int right_buttons
= wv
->name
[4] - '0';
1571 int button_spacing
= 10;
1572 GtkWidget
*wdialog
= gtk_dialog_new ();
1573 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1575 GtkWidget
*whbox_down
;
1577 /* If the number of buttons is greater than 4, make two rows of buttons
1578 instead. This looks better. */
1579 bool make_two_rows
= total_buttons
> 4;
1581 #if GTK_CHECK_VERSION (3, 12, 0)
1582 GtkBuilder
*gbld
= gtk_builder_new ();
1583 GObject
*go
= gtk_buildable_get_internal_child (GTK_BUILDABLE (wd
),
1586 GtkBox
*cur_box
= GTK_BOX (go
);
1587 g_object_unref (G_OBJECT (gbld
));
1589 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1592 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1593 left_buttons
= total_buttons
- right_buttons
;
1595 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1596 gtk_widget_set_name (wdialog
, "emacs-dialog");
1601 GtkWidget
*wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, button_spacing
);
1602 GtkWidget
*whbox_up
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1603 gtk_box_set_homogeneous (GTK_BOX (wvbox
), TRUE
);
1604 gtk_box_set_homogeneous (GTK_BOX (whbox_up
), FALSE
);
1605 whbox_down
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1606 gtk_box_set_homogeneous (GTK_BOX (whbox_down
), FALSE
);
1608 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1609 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1610 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1612 cur_box
= GTK_BOX (whbox_up
);
1615 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1616 G_CALLBACK (dialog_delete_callback
), 0);
1620 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1621 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1624 for (item
= wv
->contents
; item
; item
= item
->next
)
1626 char *utf8_label
= get_utf8_string (item
->value
);
1630 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1632 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1633 /* This is the text part of the dialog. */
1634 w
= gtk_label_new (utf8_label
);
1635 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1636 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1637 #if GTK_CHECK_VERSION (3, 14, 0)
1638 gtk_widget_set_halign (w
, GTK_ALIGN_START
);
1639 gtk_widget_set_valign (w
, GTK_ALIGN_CENTER
);
1641 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1643 /* Try to make dialog look better. Must realize first so
1644 the widget can calculate the size it needs. */
1645 gtk_widget_realize (w
);
1646 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1647 gtk_box_set_spacing (wvbox
, req
.height
);
1648 if (item
->value
&& strlen (item
->value
) > 0)
1649 button_spacing
= 2*req
.width
/strlen (item
->value
);
1650 if (button_spacing
< 10) button_spacing
= 10;
1654 /* This is one button to add to the dialog. */
1655 w
= gtk_button_new_with_label (utf8_label
);
1656 if (! item
->enabled
)
1657 gtk_widget_set_sensitive (w
, FALSE
);
1659 g_signal_connect (G_OBJECT (w
), "clicked",
1660 select_cb
, item
->call_data
);
1662 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1663 if (++button_nr
== left_buttons
)
1666 cur_box
= GTK_BOX (whbox_down
);
1671 g_free (utf8_label
);
1677 struct xg_dialog_data
1685 /* Function that is called when the file or font dialogs pop down.
1686 W is the dialog widget, RESPONSE is the response code.
1687 USER_DATA is what we passed in to g_signal_connect. */
1690 xg_dialog_response_cb (GtkDialog
*w
,
1694 struct xg_dialog_data
*dd
= user_data
;
1695 dd
->response
= response
;
1696 g_main_loop_quit (dd
->loop
);
1700 /* Destroy the dialog. This makes it pop down. */
1703 pop_down_dialog (void *arg
)
1705 struct xg_dialog_data
*dd
= arg
;
1708 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1709 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1711 g_main_loop_quit (dd
->loop
);
1712 g_main_loop_unref (dd
->loop
);
1717 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1718 We pass in DATA as gpointer* so we can use this as a callback. */
1721 xg_maybe_add_timer (gpointer data
)
1723 struct xg_dialog_data
*dd
= data
;
1724 struct timespec next_time
= timer_check ();
1728 if (timespec_valid_p (next_time
))
1730 time_t s
= next_time
.tv_sec
;
1731 int per_ms
= TIMESPEC_RESOLUTION
/ 1000;
1732 int ms
= (next_time
.tv_nsec
+ per_ms
- 1) / per_ms
;
1733 if (s
<= ((guint
) -1 - ms
) / 1000)
1734 dd
->timerid
= g_timeout_add (s
* 1000 + ms
, xg_maybe_add_timer
, dd
);
1740 /* Pops up a modal dialog W and waits for response.
1741 We don't use gtk_dialog_run because we want to process emacs timers.
1742 The dialog W is not destroyed when this function returns. */
1745 xg_dialog_run (struct frame
*f
, GtkWidget
*w
)
1747 ptrdiff_t count
= SPECPDL_INDEX ();
1748 struct xg_dialog_data dd
;
1750 xg_set_screen (w
, f
);
1751 gtk_window_set_transient_for (GTK_WINDOW (w
),
1752 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1753 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1754 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1756 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1757 dd
.response
= GTK_RESPONSE_CANCEL
;
1761 g_signal_connect (G_OBJECT (w
),
1763 G_CALLBACK (xg_dialog_response_cb
),
1765 /* Don't destroy the widget if closed by the window manager close button. */
1766 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1767 gtk_widget_show (w
);
1769 record_unwind_protect_ptr (pop_down_dialog
, &dd
);
1771 (void) xg_maybe_add_timer (&dd
);
1772 g_main_loop_run (dd
.loop
);
1775 unbind_to (count
, Qnil
);
1781 /***********************************************************************
1782 File dialog functions
1783 ***********************************************************************/
1784 /* Return true if the old file selection dialog is being used. */
1787 xg_uses_old_file_dialog (void)
1789 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1790 return x_gtk_use_old_file_dialog
;
1797 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1799 /* Return the selected file for file chooser dialog W.
1800 The returned string must be free:d. */
1803 xg_get_file_name_from_chooser (GtkWidget
*w
)
1805 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1808 /* Callback called when the "Show hidden files" toggle is pressed.
1809 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1812 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1814 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1816 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1817 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1821 /* Callback called when a property changes in a file chooser.
1822 GOBJECT is the file chooser dialog, ARG1 describes the property.
1823 USER_DATA is the toggle widget in the file chooser dialog.
1824 We use this to update the "Show hidden files" toggle when the user
1825 changes that property by right clicking in the file list. */
1828 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1830 if (strcmp (arg1
->name
, "show-hidden") == 0)
1832 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1833 gboolean visible
, toggle_on
;
1835 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1836 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1838 if (!!visible
!= !!toggle_on
)
1840 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1841 G_CALLBACK (xg_toggle_visibility_cb
),
1843 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1844 g_signal_handlers_unblock_by_func
1845 (G_OBJECT (wtoggle
),
1846 G_CALLBACK (xg_toggle_visibility_cb
),
1849 x_gtk_show_hidden_files
= visible
;
1853 /* Read a file name from the user using a file chooser dialog.
1854 F is the current frame.
1855 PROMPT is a prompt to show to the user. May not be NULL.
1856 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1857 If MUSTMATCH_P, the returned file name must be an existing
1858 file. (Actually, this only has cosmetic effects, the user can
1859 still enter a non-existing file.) *FUNC is set to a function that
1860 can be used to retrieve the selected file name from the returned widget.
1862 Returns the created widget. */
1865 xg_get_file_with_chooser (struct frame
*f
,
1867 char *default_filename
,
1868 bool mustmatch_p
, bool only_dir_p
,
1869 xg_get_file_func
*func
)
1873 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1874 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1875 GtkFileChooserAction action
= (mustmatch_p
?
1876 GTK_FILE_CHOOSER_ACTION_OPEN
:
1877 GTK_FILE_CHOOSER_ACTION_SAVE
);
1880 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1882 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1883 XG_TEXT_CANCEL
, GTK_RESPONSE_CANCEL
,
1884 (mustmatch_p
|| only_dir_p
?
1885 XG_TEXT_OPEN
: XG_TEXT_OK
),
1888 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1890 wbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1891 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
1892 gtk_widget_show (wbox
);
1893 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1895 if (x_gtk_show_hidden_files
)
1897 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1898 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1900 gtk_widget_show (wtoggle
);
1901 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1902 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1903 g_signal_connect (G_OBJECT (filewin
), "notify",
1904 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1906 if (x_gtk_file_dialog_help_text
)
1909 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1910 Show the C-l help text only for versions < 2.10. */
1911 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1912 z
= stpcpy (z
, "\nType C-l to display a file name text entry box.\n");
1913 strcpy (z
, "\nIf you don't like this file selector, use the "
1914 "corresponding\nkey binding or customize "
1915 "use-file-dialog to turn it off.");
1917 wmessage
= gtk_label_new (msgbuf
);
1918 gtk_widget_show (wmessage
);
1921 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1922 if (x_gtk_file_dialog_help_text
)
1923 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1924 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1926 if (default_filename
)
1929 struct gcpro gcpro1
;
1930 char *utf8_filename
;
1933 file
= build_string (default_filename
);
1935 /* File chooser does not understand ~/... in the file name. It must be
1936 an absolute name starting with /. */
1937 if (default_filename
[0] != '/')
1938 file
= Fexpand_file_name (file
, Qnil
);
1940 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1941 if (! NILP (Ffile_directory_p (file
)))
1942 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1946 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1948 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1950 char *cp
= strrchr (utf8_filename
, '/');
1952 else cp
= utf8_filename
;
1953 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1960 *func
= xg_get_file_name_from_chooser
;
1964 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1966 /* Return the selected file for file selector dialog W.
1967 The returned string must be free:d. */
1970 xg_get_file_name_from_selector (GtkWidget
*w
)
1972 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1973 return xstrdup (gtk_file_selection_get_filename (filesel
));
1976 /* Create a file selection dialog.
1977 F is the current frame.
1978 PROMPT is a prompt to show to the user. May not be NULL.
1979 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1980 If MUSTMATCH_P, the returned file name must be an existing
1981 file. *FUNC is set to a function that can be used to retrieve the
1982 selected file name from the returned widget.
1984 Returns the created widget. */
1987 xg_get_file_with_selection (struct frame
*f
,
1989 char *default_filename
,
1990 bool mustmatch_p
, bool only_dir_p
,
1991 xg_get_file_func
*func
)
1994 GtkFileSelection
*filesel
;
1996 filewin
= gtk_file_selection_new (prompt
);
1997 filesel
= GTK_FILE_SELECTION (filewin
);
1999 if (default_filename
)
2000 gtk_file_selection_set_filename (filesel
, default_filename
);
2004 /* The selection_entry part of filesel is not documented. */
2005 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
2006 gtk_file_selection_hide_fileop_buttons (filesel
);
2009 *func
= xg_get_file_name_from_selector
;
2013 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
2015 /* Read a file name from the user using a file dialog, either the old
2016 file selection dialog, or the new file chooser dialog. Which to use
2017 depends on what the GTK version used has, and what the value of
2018 gtk-use-old-file-dialog.
2019 F is the current frame.
2020 PROMPT is a prompt to show to the user. May not be NULL.
2021 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
2022 If MUSTMATCH_P, the returned file name must be an existing
2025 Returns a file name or NULL if no file was selected.
2026 The returned string must be freed by the caller. */
2029 xg_get_file_name (struct frame
*f
,
2031 char *default_filename
,
2037 int filesel_done
= 0;
2038 xg_get_file_func func
;
2040 #ifdef HAVE_GTK_FILE_SELECTION_NEW
2042 if (xg_uses_old_file_dialog ())
2043 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
2044 mustmatch_p
, only_dir_p
, &func
);
2046 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
2047 mustmatch_p
, only_dir_p
, &func
);
2049 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
2050 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
2051 mustmatch_p
, only_dir_p
, &func
);
2052 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
2054 gtk_widget_set_name (w
, "emacs-filedialog");
2056 filesel_done
= xg_dialog_run (f
, w
);
2057 if (filesel_done
== GTK_RESPONSE_OK
)
2060 gtk_widget_destroy (w
);
2064 /***********************************************************************
2066 ***********************************************************************/
2068 #ifdef HAVE_FREETYPE
2070 #if USE_NEW_GTK_FONT_CHOOSER
2072 #define XG_WEIGHT_TO_SYMBOL(w) \
2073 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
2074 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
2075 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
2076 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
2077 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
2078 : w <= PANGO_WEIGHT_BOLD ? Qbold \
2079 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
2082 #define XG_STYLE_TO_SYMBOL(s) \
2083 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
2084 : s == PANGO_STYLE_ITALIC ? Qitalic \
2087 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2090 static char *x_last_font_name
;
2092 /* Pop up a GTK font selector and return the name of the font the user
2093 selects, as a C string. The returned font name follows GTK's own
2096 `FAMILY [VALUE1 VALUE2] SIZE'
2098 This can be parsed using font_parse_fcname in font.c.
2099 DEFAULT_NAME, if non-zero, is the default font name. */
2102 xg_get_font (struct frame
*f
, const char *default_name
)
2106 Lisp_Object font
= Qnil
;
2108 w
= gtk_font_chooser_dialog_new
2109 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2113 /* Convert fontconfig names to Gtk names, i.e. remove - before
2115 char *p
= strrchr (default_name
, '-');
2119 while (c_isdigit (*ep
))
2121 if (*ep
== '\0') *p
= ' ';
2124 else if (x_last_font_name
)
2125 default_name
= x_last_font_name
;
2128 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w
), default_name
);
2130 gtk_widget_set_name (w
, "emacs-fontdialog");
2131 done
= xg_dialog_run (f
, w
);
2132 if (done
== GTK_RESPONSE_OK
)
2134 #if USE_NEW_GTK_FONT_CHOOSER
2135 /* Use the GTK3 font chooser. */
2136 PangoFontDescription
*desc
2137 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w
));
2141 const char *name
= pango_font_description_get_family (desc
);
2142 gint size
= pango_font_description_get_size (desc
);
2143 PangoWeight weight
= pango_font_description_get_weight (desc
);
2144 PangoStyle style
= pango_font_description_get_style (desc
);
2147 #define FONT_TYPE_WANTED (Qftcr)
2149 #define FONT_TYPE_WANTED (Qxft)
2151 font
= CALLN (Ffont_spec
,
2152 QCname
, build_string (name
),
2153 QCsize
, make_float (pango_units_to_double (size
)),
2154 QCweight
, XG_WEIGHT_TO_SYMBOL (weight
),
2155 QCslant
, XG_STYLE_TO_SYMBOL (style
),
2159 pango_font_description_free (desc
);
2160 dupstring (&x_last_font_name
, name
);
2163 #else /* Use old font selector, which just returns the font name. */
2166 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w
));
2170 font
= build_string (font_name
);
2171 g_free (x_last_font_name
);
2172 x_last_font_name
= font_name
;
2174 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2177 gtk_widget_destroy (w
);
2180 #endif /* HAVE_FREETYPE */
2184 /***********************************************************************
2186 ***********************************************************************/
2188 /* The name of menu items that can be used for customization. Since GTK
2189 RC files are very crude and primitive, we have to set this on all
2190 menu item names so a user can easily customize menu items. */
2192 #define MENU_ITEM_NAME "emacs-menuitem"
2195 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2196 during GC. The next member points to the items. */
2197 static xg_list_node xg_menu_cb_list
;
2199 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2200 during GC. The next member points to the items. */
2201 static xg_list_node xg_menu_item_cb_list
;
2203 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2204 F is the frame CL_DATA will be initialized for.
2205 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2207 The menu bar and all sub menus under the menu bar in a frame
2208 share the same structure, hence the reference count.
2210 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2211 allocated xg_menu_cb_data if CL_DATA is NULL. */
2213 static xg_menu_cb_data
*
2214 make_cl_data (xg_menu_cb_data
*cl_data
, struct frame
*f
, GCallback highlight_cb
)
2218 cl_data
= xmalloc (sizeof *cl_data
);
2220 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2221 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2222 cl_data
->highlight_cb
= highlight_cb
;
2223 cl_data
->ref_count
= 0;
2225 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2228 cl_data
->ref_count
++;
2233 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2234 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2236 When the menu bar is updated, menu items may have been added and/or
2237 removed, so menu_bar_vector and menu_bar_items_used change. We must
2238 then update CL_DATA since it is used to determine which menu
2239 item that is invoked in the menu.
2240 HIGHLIGHT_CB could change, there is no check that the same
2241 function is given when modifying a menu bar as was given when
2242 creating the menu bar. */
2245 update_cl_data (xg_menu_cb_data
*cl_data
,
2247 GCallback highlight_cb
)
2252 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2253 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2254 cl_data
->highlight_cb
= highlight_cb
;
2258 /* Decrease reference count for CL_DATA.
2259 If reference count is zero, free CL_DATA. */
2262 unref_cl_data (xg_menu_cb_data
*cl_data
)
2264 if (cl_data
&& cl_data
->ref_count
> 0)
2266 cl_data
->ref_count
--;
2267 if (cl_data
->ref_count
== 0)
2269 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2275 /* Function that marks all lisp data during GC. */
2281 Lisp_Object rest
, frame
;
2283 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2284 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2286 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2288 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2290 if (! NILP (cb_data
->help
))
2291 mark_object (cb_data
->help
);
2294 FOR_EACH_FRAME (rest
, frame
)
2296 struct frame
*f
= XFRAME (frame
);
2298 if (FRAME_X_P (f
) && FRAME_GTK_OUTER_WIDGET (f
))
2300 struct xg_frame_tb_info
*tbinfo
2301 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
2305 mark_object (tbinfo
->last_tool_bar
);
2306 mark_object (tbinfo
->style
);
2313 /* Callback called when a menu item is destroyed. Used to free data.
2314 W is the widget that is being destroyed (not used).
2315 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2318 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2322 xg_menu_item_cb_data
*data
= client_data
;
2323 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2328 /* Callback called when the pointer enters/leaves a menu item.
2329 W is the parent of the menu item.
2330 EVENT is either an enter event or leave event.
2331 CLIENT_DATA is not used.
2333 Returns FALSE to tell GTK to keep processing this event. */
2336 menuitem_highlight_callback (GtkWidget
*w
,
2337 GdkEventCrossing
*event
,
2338 gpointer client_data
)
2341 GtkWidget
*subwidget
;
2342 xg_menu_item_cb_data
*data
;
2344 ev
.crossing
= *event
;
2345 subwidget
= gtk_get_event_widget (&ev
);
2346 data
= g_object_get_data (G_OBJECT (subwidget
), XG_ITEM_DATA
);
2349 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2351 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2352 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2353 (*func
) (subwidget
, call_data
);
2360 /* Callback called when a menu is destroyed. Used to free data.
2361 W is the widget that is being destroyed (not used).
2362 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2365 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2367 unref_cl_data (client_data
);
2370 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2371 must be non-NULL) and can be inserted into a menu item.
2373 Returns the GtkHBox. */
2376 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2382 wbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
2383 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
2384 wlbl
= gtk_label_new (utf8_label
);
2385 wkey
= gtk_label_new (utf8_key
);
2387 #if GTK_CHECK_VERSION (3, 14, 0)
2388 gtk_widget_set_halign (wlbl
, GTK_ALIGN_START
);
2389 gtk_widget_set_valign (wlbl
, GTK_ALIGN_CENTER
);
2390 gtk_widget_set_halign (wkey
, GTK_ALIGN_START
);
2391 gtk_widget_set_valign (wkey
, GTK_ALIGN_CENTER
);
2393 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2394 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2396 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2397 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2399 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2400 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2401 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2406 /* Make and return a menu item widget with the key to the right.
2407 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2408 UTF8_KEY is the text representing the key binding.
2409 ITEM is the widget_value describing the menu item.
2411 GROUP is an in/out parameter. If the menu item to be created is not
2412 part of any radio menu group, *GROUP contains NULL on entry and exit.
2413 If the menu item to be created is part of a radio menu group, on entry
2414 *GROUP contains the group to use, or NULL if this is the first item
2415 in the group. On exit, *GROUP contains the radio item group.
2417 Unfortunately, keys don't line up as nicely as in Motif,
2418 but the MacOS X version doesn't either, so I guess that is OK. */
2421 make_menu_item (const char *utf8_label
,
2422 const char *utf8_key
,
2427 GtkWidget
*wtoadd
= 0;
2429 /* It has been observed that some menu items have a NULL name field.
2430 This will lead to this function being called with a NULL utf8_label.
2431 GTK crashes on that so we set a blank label. Why there is a NULL
2432 name remains to be investigated. */
2433 if (! utf8_label
) utf8_label
= " ";
2436 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2438 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2441 if (utf8_key
) w
= gtk_check_menu_item_new ();
2442 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2443 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2445 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2447 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2448 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2449 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2451 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2456 if (utf8_key
) w
= gtk_menu_item_new ();
2457 else w
= gtk_menu_item_new_with_label (utf8_label
);
2460 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2461 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2466 /* Create a menu item widget, and connect the callbacks.
2467 ITEM describes the menu item.
2468 F is the frame the created menu belongs to.
2469 SELECT_CB is the callback to use when a menu item is selected.
2470 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2471 CL_DATA points to the callback data to be used for this menu.
2472 GROUP is an in/out parameter. If the menu item to be created is not
2473 part of any radio menu group, *GROUP contains NULL on entry and exit.
2474 If the menu item to be created is part of a radio menu group, on entry
2475 *GROUP contains the group to use, or NULL if this is the first item
2476 in the group. On exit, *GROUP contains the radio item group.
2478 Returns the created GtkWidget. */
2481 xg_create_one_menuitem (widget_value
*item
,
2483 GCallback select_cb
,
2484 GCallback highlight_cb
,
2485 xg_menu_cb_data
*cl_data
,
2491 xg_menu_item_cb_data
*cb_data
;
2493 utf8_label
= get_utf8_string (item
->name
);
2494 utf8_key
= get_utf8_string (item
->key
);
2496 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2498 if (utf8_label
) g_free (utf8_label
);
2499 if (utf8_key
) g_free (utf8_key
);
2501 cb_data
= xmalloc (sizeof *cb_data
);
2503 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2505 cb_data
->select_id
= 0;
2506 cb_data
->help
= item
->help
;
2507 cb_data
->cl_data
= cl_data
;
2508 cb_data
->call_data
= item
->call_data
;
2510 g_signal_connect (G_OBJECT (w
),
2512 G_CALLBACK (menuitem_destroy_callback
),
2515 /* Put cb_data in widget, so we can get at it when modifying menubar */
2516 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2518 /* final item, not a submenu */
2519 if (item
->call_data
&& ! item
->contents
)
2523 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2529 /* Create a full menu tree specified by DATA.
2530 F is the frame the created menu belongs to.
2531 SELECT_CB is the callback to use when a menu item is selected.
2532 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2533 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2534 If POP_UP_P, create a popup menu.
2535 If MENU_BAR_P, create a menu bar.
2536 TOPMENU is the topmost GtkWidget that others shall be placed under.
2537 It may be NULL, in that case we create the appropriate widget
2538 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2539 CL_DATA is the callback data we shall use for this menu, or NULL
2540 if we haven't set the first callback yet.
2541 NAME is the name to give to the top level menu if this function
2542 creates it. May be NULL to not set any name.
2544 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2547 This function calls itself to create submenus. */
2550 create_menus (widget_value
*data
,
2552 GCallback select_cb
,
2553 GCallback deactivate_cb
,
2554 GCallback highlight_cb
,
2558 xg_menu_cb_data
*cl_data
,
2562 GtkWidget
*wmenu
= topmenu
;
2563 GSList
*group
= NULL
;
2569 wmenu
= gtk_menu_new ();
2570 xg_set_screen (wmenu
, f
);
2571 /* Connect this to the menu instead of items so we get enter/leave for
2572 disabled items also. TODO: Still does not get enter/leave for
2573 disabled items in detached menus. */
2574 g_signal_connect (G_OBJECT (wmenu
),
2575 "enter-notify-event",
2576 G_CALLBACK (menuitem_highlight_callback
),
2578 g_signal_connect (G_OBJECT (wmenu
),
2579 "leave-notify-event",
2580 G_CALLBACK (menuitem_highlight_callback
),
2585 wmenu
= gtk_menu_bar_new ();
2586 /* Set width of menu bar to a small value so it doesn't enlarge
2587 a small initial frame size. The width will be set to the
2588 width of the frame later on when it is added to a container.
2589 height -1: Natural height. */
2590 gtk_widget_set_size_request (wmenu
, 1, -1);
2593 /* Put cl_data on the top menu for easier access. */
2594 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2595 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2596 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2597 G_CALLBACK (menu_destroy_callback
), cl_data
);
2600 gtk_widget_set_name (wmenu
, name
);
2603 g_signal_connect (G_OBJECT (wmenu
),
2604 "selection-done", deactivate_cb
, 0);
2607 for (item
= data
; item
; item
= item
->next
)
2611 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2612 && !menu_separator_name_p (item
->name
))
2615 /* A title for a popup. We do the same as GTK does when
2616 creating titles, but it does not look good. */
2618 utf8_label
= get_utf8_string (item
->name
);
2620 w
= gtk_menu_item_new_with_label (utf8_label
);
2621 gtk_widget_set_sensitive (w
, FALSE
);
2622 if (utf8_label
) g_free (utf8_label
);
2624 else if (menu_separator_name_p (item
->name
))
2627 /* GTK only have one separator type. */
2628 w
= gtk_separator_menu_item_new ();
2632 w
= xg_create_one_menuitem (item
,
2634 item
->contents
? 0 : select_cb
,
2639 /* Create a possibly empty submenu for menu bar items, since some
2640 themes don't highlight items correctly without it. */
2641 if (item
->contents
|| menu_bar_p
)
2643 GtkWidget
*submenu
= create_menus (item
->contents
,
2653 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2657 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2658 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2664 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2665 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2666 with some text and buttons.
2667 F is the frame the created item belongs to.
2668 NAME is the name to use for the top widget.
2669 VAL is a widget_value structure describing items to be created.
2670 SELECT_CB is the callback to use when a menu item is selected or
2671 a dialog button is pressed.
2672 DEACTIVATE_CB is the callback to use when an item is deactivated.
2673 For a menu, when a sub menu is not shown anymore, for a dialog it is
2674 called when the dialog is popped down.
2675 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2677 Returns the widget created. */
2680 xg_create_widget (const char *type
, const char *name
, struct frame
*f
,
2681 widget_value
*val
, GCallback select_cb
,
2682 GCallback deactivate_cb
, GCallback highlight_cb
)
2685 bool menu_bar_p
= strcmp (type
, "menubar") == 0;
2686 bool pop_up_p
= strcmp (type
, "popup") == 0;
2688 if (strcmp (type
, "dialog") == 0)
2690 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2691 xg_set_screen (w
, f
);
2692 gtk_window_set_transient_for (GTK_WINDOW (w
),
2693 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2694 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2695 gtk_widget_set_name (w
, "emacs-dialog");
2696 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2698 else if (menu_bar_p
|| pop_up_p
)
2700 w
= create_menus (val
->contents
,
2711 /* Set the cursor to an arrow for popup menus when they are mapped.
2712 This is done by default for menu bar menus. */
2715 /* Must realize so the GdkWindow inside the widget is created. */
2716 gtk_widget_realize (w
);
2717 xg_set_cursor (w
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
2722 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2729 /* Return the label for menu item WITEM. */
2732 xg_get_menu_item_label (GtkMenuItem
*witem
)
2734 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2735 return gtk_label_get_label (wlabel
);
2738 /* Return true if the menu item WITEM has the text LABEL. */
2741 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2744 char *utf8_label
= get_utf8_string (label
);
2745 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2747 if (! old_label
&& ! utf8_label
)
2749 else if (old_label
&& utf8_label
)
2750 is_same
= strcmp (utf8_label
, old_label
) == 0;
2752 if (utf8_label
) g_free (utf8_label
);
2757 /* Destroy widgets in LIST. */
2760 xg_destroy_widgets (GList
*list
)
2764 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2766 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2768 /* Destroying the widget will remove it from the container it is in. */
2769 gtk_widget_destroy (w
);
2773 /* Update the top level names in MENUBAR (i.e. not submenus).
2774 F is the frame the menu bar belongs to.
2775 *LIST is a list with the current menu bar names (menu item widgets).
2776 ITER is the item within *LIST that shall be updated.
2777 POS is the numerical position, starting at 0, of ITER in *LIST.
2778 VAL describes what the menu bar shall look like after the update.
2779 SELECT_CB is the callback to use when a menu item is selected.
2780 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2781 CL_DATA points to the callback data to be used for this menu bar.
2783 This function calls itself to walk through the menu bar names. */
2786 xg_update_menubar (GtkWidget
*menubar
,
2792 GCallback select_cb
,
2793 GCallback deactivate_cb
,
2794 GCallback highlight_cb
,
2795 xg_menu_cb_data
*cl_data
)
2797 if (! iter
&& ! val
)
2799 else if (iter
&& ! val
)
2801 /* Item(s) have been removed. Remove all remaining items. */
2802 xg_destroy_widgets (iter
);
2804 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2805 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2806 gtk_menu_item_new_with_label (""),
2812 else if (! iter
&& val
)
2814 /* Item(s) added. Add all new items in one call. */
2815 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2816 0, 1, menubar
, cl_data
, 0);
2822 /* Below this neither iter or val is NULL */
2823 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2825 /* This item is still the same, check next item. */
2827 iter
= g_list_next (iter
);
2830 else /* This item is changed. */
2832 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2833 GtkMenuItem
*witem2
= 0;
2834 bool val_in_menubar
= 0;
2835 bool iter_in_new_menubar
= 0;
2839 /* See if the changed entry (val) is present later in the menu bar */
2841 iter2
&& ! val_in_menubar
;
2842 iter2
= g_list_next (iter2
))
2844 witem2
= GTK_MENU_ITEM (iter2
->data
);
2845 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2848 /* See if the current entry (iter) is present later in the
2849 specification for the new menu bar. */
2850 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2851 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2853 if (val_in_menubar
&& ! iter_in_new_menubar
)
2857 /* This corresponds to:
2862 g_object_ref (G_OBJECT (witem
));
2863 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2864 gtk_widget_destroy (GTK_WIDGET (witem
));
2866 /* Must get new list since the old changed. */
2867 g_list_free (*list
);
2868 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2869 while (nr
-- > 0) iter
= g_list_next (iter
);
2871 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2873 /* This corresponds to:
2876 Rename B to X. This might seem to be a strange thing to do,
2877 since if there is a menu under B it will be totally wrong for X.
2878 But consider editing a C file. Then there is a C-mode menu
2879 (corresponds to B above).
2880 If then doing C-x C-f the minibuf menu (X above) replaces the
2881 C-mode menu. When returning from the minibuffer, we get
2882 back the C-mode menu. Thus we do:
2883 Rename B to X (C-mode to minibuf menu)
2884 Rename X to B (minibuf to C-mode menu).
2885 If the X menu hasn't been invoked, the menu under B
2886 is up to date when leaving the minibuffer. */
2887 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2888 char *utf8_label
= get_utf8_string (val
->name
);
2890 /* GTK menu items don't notice when their labels have been
2891 changed from underneath them, so we have to explicitly
2892 use g_object_notify to tell listeners (e.g., a GMenuModel
2893 bridge that might be loaded) that the item's label has
2895 gtk_label_set_text (wlabel
, utf8_label
);
2896 #if GTK_CHECK_VERSION (2, 16, 0)
2897 g_object_notify (G_OBJECT (witem
), "label");
2899 if (utf8_label
) g_free (utf8_label
);
2900 iter
= g_list_next (iter
);
2904 else if (! val_in_menubar
&& iter_in_new_menubar
)
2906 /* This corresponds to:
2913 GtkWidget
*w
= xg_create_one_menuitem (val
,
2920 /* Create a possibly empty submenu for menu bar items, since some
2921 themes don't highlight items correctly without it. */
2922 GtkWidget
*submenu
= create_menus (NULL
, f
,
2923 select_cb
, deactivate_cb
,
2925 0, 0, 0, cl_data
, 0);
2927 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2928 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2929 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2931 g_list_free (*list
);
2932 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2933 while (nr
-- > 0) iter
= g_list_next (iter
);
2934 iter
= g_list_next (iter
);
2938 else /* if (val_in_menubar && iter_in_new_menubar) */
2941 /* This corresponds to:
2946 g_object_ref (G_OBJECT (witem2
));
2947 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2948 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2949 GTK_WIDGET (witem2
), pos
);
2950 g_object_unref (G_OBJECT (witem2
));
2952 g_list_free (*list
);
2953 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2954 while (nr
-- > 0) iter
= g_list_next (iter
);
2955 if (iter
) iter
= g_list_next (iter
);
2961 /* Update the rest of the menu bar. */
2962 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2963 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2966 /* Update the menu item W so it corresponds to VAL.
2967 SELECT_CB is the callback to use when a menu item is selected.
2968 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2969 CL_DATA is the data to set in the widget for menu invocation. */
2972 xg_update_menu_item (widget_value
*val
,
2974 GCallback select_cb
,
2975 GCallback highlight_cb
,
2976 xg_menu_cb_data
*cl_data
)
2983 const char *old_label
= 0;
2984 const char *old_key
= 0;
2985 xg_menu_item_cb_data
*cb_data
;
2986 bool label_changed
= false;
2988 wchild
= XG_BIN_CHILD (w
);
2989 utf8_label
= get_utf8_string (val
->name
);
2990 utf8_key
= get_utf8_string (val
->key
);
2992 /* See if W is a menu item with a key. See make_menu_item above. */
2993 if (GTK_IS_BOX (wchild
))
2995 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2997 wlbl
= GTK_LABEL (list
->data
);
2998 wkey
= GTK_LABEL (list
->next
->data
);
3003 /* Remove the key and keep just the label. */
3004 g_object_ref (G_OBJECT (wlbl
));
3005 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3006 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
3007 g_object_unref (G_OBJECT (wlbl
));
3012 else /* Just a label. */
3014 wlbl
= GTK_LABEL (wchild
);
3016 /* Check if there is now a key. */
3019 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
3020 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
3022 wlbl
= GTK_LABEL (list
->data
);
3023 wkey
= GTK_LABEL (list
->next
->data
);
3026 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3027 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
3031 if (wkey
) old_key
= gtk_label_get_label (wkey
);
3032 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
3034 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
3036 label_changed
= true;
3037 gtk_label_set_text (wkey
, utf8_key
);
3040 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
3042 label_changed
= true;
3043 gtk_label_set_text (wlbl
, utf8_label
);
3046 if (utf8_key
) g_free (utf8_key
);
3047 if (utf8_label
) g_free (utf8_label
);
3049 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
3050 gtk_widget_set_sensitive (w
, FALSE
);
3051 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
3052 gtk_widget_set_sensitive (w
, TRUE
);
3054 cb_data
= g_object_get_data (G_OBJECT (w
), XG_ITEM_DATA
);
3057 cb_data
->call_data
= val
->call_data
;
3058 cb_data
->help
= val
->help
;
3059 cb_data
->cl_data
= cl_data
;
3061 /* We assume the callback functions don't change. */
3062 if (val
->call_data
&& ! val
->contents
)
3064 /* This item shall have a select callback. */
3065 if (! cb_data
->select_id
)
3067 = g_signal_connect (G_OBJECT (w
), "activate",
3068 select_cb
, cb_data
);
3070 else if (cb_data
->select_id
)
3072 g_signal_handler_disconnect (w
, cb_data
->select_id
);
3073 cb_data
->select_id
= 0;
3077 #if GTK_CHECK_VERSION (2, 16, 0)
3078 if (label_changed
) /* See comment in xg_update_menubar. */
3079 g_object_notify (G_OBJECT (w
), "label");
3083 /* Update the toggle menu item W so it corresponds to VAL. */
3086 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
3088 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3091 /* Update the radio menu item W so it corresponds to VAL. */
3094 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
3096 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3099 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3100 SUBMENU may be NULL, in that case a new menu is created.
3101 F is the frame the menu bar belongs to.
3102 VAL describes the contents of the menu bar.
3103 SELECT_CB is the callback to use when a menu item is selected.
3104 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3105 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3106 CL_DATA is the call back data to use for any newly created items.
3108 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3112 xg_update_submenu (GtkWidget
*submenu
,
3115 GCallback select_cb
,
3116 GCallback deactivate_cb
,
3117 GCallback highlight_cb
,
3118 xg_menu_cb_data
*cl_data
)
3120 GtkWidget
*newsub
= submenu
;
3124 GList
*first_radio
= 0;
3127 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3129 for (cur
= val
, iter
= list
;
3131 iter
= g_list_next (iter
), cur
= cur
->next
)
3133 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3135 /* Remember first radio button in a group. If we get a mismatch in
3136 a radio group we must rebuild the whole group so that the connections
3137 in GTK becomes correct. */
3138 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3140 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3141 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3144 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3146 if (! menu_separator_name_p (cur
->name
))
3149 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3151 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3153 xg_update_toggle_item (cur
, w
);
3154 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3156 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3158 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3160 xg_update_radio_item (cur
, w
);
3161 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3163 else if (GTK_IS_MENU_ITEM (w
))
3165 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3168 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3169 menu_separator_name_p (cur
->name
))
3172 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3174 sub
= gtk_menu_item_get_submenu (witem
);
3175 if (sub
&& ! cur
->contents
)
3177 /* Not a submenu anymore. */
3178 g_object_ref (G_OBJECT (sub
));
3179 remove_submenu (witem
);
3180 gtk_widget_destroy (sub
);
3182 else if (cur
->contents
)
3186 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3187 select_cb
, deactivate_cb
,
3188 highlight_cb
, cl_data
);
3190 /* If this item just became a submenu, we must set it. */
3192 gtk_menu_item_set_submenu (witem
, nsub
);
3197 /* Structural difference. Remove everything from here and down
3203 /* Remove widgets from first structural change. */
3206 /* If we are adding new menu items below, we must remove from
3207 first radio button so that radio groups become correct. */
3208 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3209 else xg_destroy_widgets (iter
);
3214 /* More items added. Create them. */
3215 newsub
= create_menus (cur
,
3227 if (list
) g_list_free (list
);
3232 /* Update the MENUBAR.
3233 F is the frame the menu bar belongs to.
3234 VAL describes the contents of the menu bar.
3235 If DEEP_P, rebuild all but the top level menu names in
3236 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3237 SELECT_CB is the callback to use when a menu item is selected.
3238 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3239 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3242 xg_modify_menubar_widgets (GtkWidget
*menubar
, struct frame
*f
,
3243 widget_value
*val
, bool deep_p
,
3244 GCallback select_cb
, GCallback deactivate_cb
,
3245 GCallback highlight_cb
)
3247 xg_menu_cb_data
*cl_data
;
3248 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3252 cl_data
= g_object_get_data (G_OBJECT (menubar
), XG_FRAME_DATA
);
3254 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3255 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3261 /* Update all sub menus.
3262 We must keep the submenus (GTK menu item widgets) since the
3263 X Window in the XEvent that activates the menu are those widgets. */
3265 /* Update cl_data, menu_item things in F may have changed. */
3266 update_cl_data (cl_data
, f
, highlight_cb
);
3268 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3273 GtkMenuItem
*witem
= 0;
3275 /* Find sub menu that corresponds to val and update it. */
3276 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3278 witem
= GTK_MENU_ITEM (iter
->data
);
3279 if (xg_item_label_same_p (witem
, cur
->name
))
3281 sub
= gtk_menu_item_get_submenu (witem
);
3286 newsub
= xg_update_submenu (sub
,
3293 /* sub may still be NULL. If we just updated non deep and added
3294 a new menu bar item, it has no sub menu yet. So we set the
3295 newly created sub menu under witem. */
3296 if (newsub
!= sub
&& witem
!= 0)
3298 xg_set_screen (newsub
, f
);
3299 gtk_menu_item_set_submenu (witem
, newsub
);
3305 gtk_widget_show_all (menubar
);
3308 /* Callback called when the menu bar W is mapped.
3309 Used to find the height of the menu bar if we didn't get it
3310 after showing the widget. */
3313 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3316 struct frame
*f
= user_data
;
3317 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3318 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3320 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3321 adjust_frame_size (f
, -1, -1, 2, 0, Qmenu_bar_lines
);
3325 /* Recompute all the widgets of frame F, when the menu bar has been
3329 xg_update_frame_menubar (struct frame
*f
)
3331 struct x_output
*x
= f
->output_data
.x
;
3334 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3337 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3338 return; /* Already done this, happens for frames created invisible. */
3342 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3344 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3346 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3347 gtk_widget_show_all (x
->menubar_widget
);
3348 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3350 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3352 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3353 adjust_frame_size (f
, -1, -1, 2, 0, Qmenu_bar_lines
);
3358 /* Get rid of the menu bar of frame F, and free its storage.
3359 This is used when deleting a frame, and when turning off the menu bar. */
3362 free_frame_menubar (struct frame
*f
)
3364 struct x_output
*x
= f
->output_data
.x
;
3366 if (x
->menubar_widget
)
3370 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3371 /* The menubar and its children shall be deleted when removed from
3373 x
->menubar_widget
= 0;
3374 FRAME_MENUBAR_HEIGHT (f
) = 0;
3375 adjust_frame_size (f
, -1, -1, 2, 0, Qmenu_bar_lines
);
3381 xg_event_is_for_menubar (struct frame
*f
, const XEvent
*event
)
3383 struct x_output
*x
= f
->output_data
.x
;
3392 if (! x
->menubar_widget
) return 0;
3394 if (! (event
->xbutton
.x
>= 0
3395 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3396 && event
->xbutton
.y
>= 0
3397 && event
->xbutton
.y
< FRAME_MENUBAR_HEIGHT (f
)
3398 && event
->xbutton
.same_screen
))
3401 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3402 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3404 gevent
.any
.window
= gw
;
3405 gevent
.any
.type
= GDK_NOTHING
;
3406 gwdesc
= gtk_get_event_widget (&gevent
);
3407 if (! gwdesc
) return 0;
3408 if (! GTK_IS_MENU_BAR (gwdesc
)
3409 && ! GTK_IS_MENU_ITEM (gwdesc
)
3410 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3413 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3414 if (! list
) return 0;
3415 rec
.x
= event
->xbutton
.x
;
3416 rec
.y
= event
->xbutton
.y
;
3420 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3422 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3423 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3432 /***********************************************************************
3433 Scroll bar functions
3434 ***********************************************************************/
3437 /* Setting scroll bar values invokes the callback. Use this variable
3438 to indicate that callback should do nothing. */
3440 bool xg_ignore_gtk_scrollbar
;
3442 /* Width and height of scroll bars for the current theme. */
3443 static int scroll_bar_width_for_theme
;
3444 static int scroll_bar_height_for_theme
;
3446 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3447 may be larger than 32 bits. Keep a mapping from integer index to widget
3448 pointers to get around the 32 bit limitation. */
3452 GtkWidget
**widgets
;
3457 /* Grow this much every time we need to allocate more */
3459 #define ID_TO_WIDGET_INCR 32
3461 /* Store the widget pointer W in id_to_widget and return the integer index. */
3464 xg_store_widget_in_map (GtkWidget
*w
)
3468 if (id_to_widget
.max_size
== id_to_widget
.used
)
3471 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3472 memory_full (SIZE_MAX
);
3474 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3475 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3476 new_size
, sizeof (GtkWidget
*));
3478 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3479 id_to_widget
.widgets
[i
] = 0;
3480 id_to_widget
.max_size
= new_size
;
3483 /* Just loop over the array and find a free place. After all,
3484 how many scroll bars are we creating? Should be a small number.
3485 The check above guarantees we will find a free place. */
3486 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3488 if (! id_to_widget
.widgets
[i
])
3490 id_to_widget
.widgets
[i
] = w
;
3491 ++id_to_widget
.used
;
3497 /* Should never end up here */
3501 /* Remove pointer at IDX from id_to_widget.
3502 Called when scroll bar is destroyed. */
3505 xg_remove_widget_from_map (ptrdiff_t idx
)
3507 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3509 id_to_widget
.widgets
[idx
] = 0;
3510 --id_to_widget
.used
;
3514 /* Get the widget pointer at IDX from id_to_widget. */
3517 xg_get_widget_from_map (ptrdiff_t idx
)
3519 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3520 return id_to_widget
.widgets
[idx
];
3526 update_theme_scrollbar_width (void)
3529 GtkAdjustment
*vadj
;
3536 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3537 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3538 g_object_ref_sink (G_OBJECT (wscroll
));
3539 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3540 gtk_widget_destroy (wscroll
);
3541 g_object_unref (G_OBJECT (wscroll
));
3546 scroll_bar_width_for_theme
= w
;
3550 update_theme_scrollbar_height (void)
3553 GtkAdjustment
*hadj
;
3560 hadj
= gtk_adjustment_new (YG_SB_MIN
, YG_SB_MIN
, YG_SB_MAX
, 0.1, 0.1, 0.1);
3561 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL
, GTK_ADJUSTMENT (hadj
));
3562 g_object_ref_sink (G_OBJECT (wscroll
));
3563 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3564 gtk_widget_destroy (wscroll
);
3565 g_object_unref (G_OBJECT (wscroll
));
3568 scroll_bar_height_for_theme
= w
;
3572 xg_get_default_scrollbar_width (void)
3574 return scroll_bar_width_for_theme
* xg_get_gdk_scale ();
3578 xg_get_default_scrollbar_height (void)
3580 /* Apparently there's no default height for themes. */
3581 return scroll_bar_width_for_theme
* xg_get_gdk_scale ();
3584 /* Return the scrollbar id for X Window WID on display DPY.
3585 Return -1 if WID not in id_to_widget. */
3588 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3593 w
= xg_win_to_widget (dpy
, wid
);
3597 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3598 if (id_to_widget
.widgets
[idx
] == w
)
3605 /* Callback invoked when scroll bar WIDGET is destroyed.
3606 DATA is the index into id_to_widget for WIDGET.
3607 We free pointer to last scroll bar values here and remove the index. */
3610 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3612 intptr_t id
= (intptr_t) data
;
3613 xg_remove_widget_from_map (id
);
3616 /* Create a scroll bar widget for frame F. Store the scroll bar
3618 SCROLL_CALLBACK is the callback to invoke when the value of the
3620 END_CALLBACK is the callback to invoke when scrolling ends.
3621 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3622 to set resources for the widget. */
3625 xg_create_scroll_bar (struct frame
*f
,
3626 struct scroll_bar
*bar
,
3627 GCallback scroll_callback
,
3628 GCallback end_callback
,
3629 const char *scroll_bar_name
)
3635 GtkAdjustment
*vadj
;
3640 /* Page, step increment values are not so important here, they
3641 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3642 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3645 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3646 webox
= gtk_event_box_new ();
3647 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3649 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3651 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3653 scroll_id
= xg_store_widget_in_map (wscroll
);
3655 g_signal_connect (G_OBJECT (wscroll
),
3657 G_CALLBACK (xg_gtk_scroll_destroy
),
3658 (gpointer
) scroll_id
);
3659 g_signal_connect (G_OBJECT (wscroll
),
3663 g_signal_connect (G_OBJECT (wscroll
),
3664 "button-release-event",
3668 /* The scroll bar widget does not draw on a window of its own. Instead
3669 it draws on the parent window, in this case the edit widget. So
3670 whenever the edit widget is cleared, the scroll bar needs to redraw
3671 also, which causes flicker. Put an event box between the edit widget
3672 and the scroll bar, so the scroll bar instead draws itself on the
3673 event box window. */
3674 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3675 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3678 /* Set the cursor to an arrow. */
3679 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3681 bar
->x_window
= scroll_id
;
3682 bar
->horizontal
= 0;
3685 /* Create a horizontal scroll bar widget for frame F. Store the scroll
3686 bar in BAR. SCROLL_CALLBACK is the callback to invoke when the value
3687 of the bar changes. END_CALLBACK is the callback to invoke when
3688 scrolling ends. SCROLL_BAR_NAME is the name we use for the scroll
3689 bar. Can be used to set resources for the widget. */
3692 xg_create_horizontal_scroll_bar (struct frame
*f
,
3693 struct scroll_bar
*bar
,
3694 GCallback scroll_callback
,
3695 GCallback end_callback
,
3696 const char *scroll_bar_name
)
3702 GtkAdjustment
*hadj
;
3707 /* Page, step increment values are not so important here, they
3708 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3709 hadj
= gtk_adjustment_new (YG_SB_MIN
, YG_SB_MIN
, YG_SB_MAX
,
3712 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_HORIZONTAL
, GTK_ADJUSTMENT (hadj
));
3713 webox
= gtk_event_box_new ();
3714 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3716 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3718 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3720 scroll_id
= xg_store_widget_in_map (wscroll
);
3722 g_signal_connect (G_OBJECT (wscroll
),
3724 G_CALLBACK (xg_gtk_scroll_destroy
),
3725 (gpointer
) scroll_id
);
3726 g_signal_connect (G_OBJECT (wscroll
),
3730 g_signal_connect (G_OBJECT (wscroll
),
3731 "button-release-event",
3735 /* The scroll bar widget does not draw on a window of its own. Instead
3736 it draws on the parent window, in this case the edit widget. So
3737 whenever the edit widget is cleared, the scroll bar needs to redraw
3738 also, which causes flicker. Put an event box between the edit widget
3739 and the scroll bar, so the scroll bar instead draws itself on the
3740 event box window. */
3741 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3742 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3745 /* Set the cursor to an arrow. */
3746 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3748 bar
->x_window
= scroll_id
;
3749 bar
->horizontal
= 1;
3752 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3755 xg_remove_scroll_bar (struct frame
*f
, ptrdiff_t scrollbar_id
)
3757 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3760 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3761 gtk_widget_destroy (w
);
3762 gtk_widget_destroy (wparent
);
3763 SET_FRAME_GARBAGED (f
);
3767 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3769 TOP/LEFT are the new pixel positions where the bar shall appear.
3770 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3773 xg_update_scrollbar_pos (struct frame
*f
,
3774 ptrdiff_t scrollbar_id
,
3780 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3783 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3784 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3786 int scale
= xg_get_gdk_scale ();
3791 left
-= (scale
- 1) * ((width
/ scale
) >> 1);
3793 /* Clear out old position. */
3794 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3795 if (gtk_widget_get_parent (wparent
) == wfixed
)
3797 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3798 "x", &oldx
, "y", &oldy
, NULL
);
3799 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3802 /* Move and resize to new values. */
3803 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3804 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3807 /* No room. Hide scroll bar as some themes output a warning if
3808 the height is less than the min size. */
3809 gtk_widget_hide (wparent
);
3810 gtk_widget_hide (wscroll
);
3814 gtk_widget_show_all (wparent
);
3815 gtk_widget_set_size_request (wscroll
, width
, height
);
3818 gtk_widget_queue_draw (wfixed
);
3819 gdk_window_process_all_updates ();
3821 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3823 /* Clear under old scroll bar position. This must be done after
3824 the gtk_widget_queue_draw and gdk_window_process_all_updates
3826 oldw
+= (scale
- 1) * oldw
;
3827 oldx
-= (scale
- 1) * oldw
;
3828 x_clear_area (f
, oldx
, oldy
, oldw
, oldh
);
3831 /* GTK does not redraw until the main loop is entered again, but
3832 if there are no X events pending we will not enter it. So we sync
3833 here to get some events. */
3836 SET_FRAME_GARBAGED (f
);
3837 cancel_mouse_face (f
);
3842 /* Update the position of the horizontal scroll bar represented by SCROLLBAR_ID
3844 TOP/LEFT are the new pixel positions where the bar shall appear.
3845 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3848 xg_update_horizontal_scrollbar_pos (struct frame
*f
,
3849 ptrdiff_t scrollbar_id
,
3856 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3860 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3861 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3864 /* Clear out old position. */
3865 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3866 if (gtk_widget_get_parent (wparent
) == wfixed
)
3868 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3869 "x", &oldx
, "y", &oldy
, NULL
);
3870 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3873 /* Move and resize to new values. */
3874 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3875 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3878 /* No room. Hide scroll bar as some themes output a warning if
3879 the width is less than the min size. */
3880 gtk_widget_hide (wparent
);
3881 gtk_widget_hide (wscroll
);
3885 gtk_widget_show_all (wparent
);
3886 gtk_widget_set_size_request (wscroll
, width
, height
);
3888 gtk_widget_queue_draw (wfixed
);
3889 gdk_window_process_all_updates ();
3890 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3891 /* Clear under old scroll bar position. This must be done after
3892 the gtk_widget_queue_draw and gdk_window_process_all_updates
3895 oldx
, oldy
, oldw
, oldh
);
3897 /* GTK does not redraw until the main loop is entered again, but
3898 if there are no X events pending we will not enter it. So we sync
3899 here to get some events. */
3902 SET_FRAME_GARBAGED (f
);
3903 cancel_mouse_face (f
);
3908 /* Get the current value of the range, truncated to an integer. */
3911 int_gtk_range_get_value (GtkRange
*range
)
3913 return gtk_range_get_value (range
);
3917 /* Set the thumb size and position of scroll bar BAR. We are currently
3918 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3921 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3926 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3928 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3930 if (wscroll
&& bar
->dragging
== -1)
3940 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3942 if (scroll_bar_adjust_thumb_portion_p
)
3944 /* We do the same as for MOTIF in xterm.c, use 30 chars per
3945 line rather than the real portion value. This makes the
3946 thumb less likely to resize and that looks better. */
3947 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3949 /* When the thumb is at the bottom, position == whole.
3950 So we need to increase `whole' to make space for the thumb. */
3958 top
= (gdouble
) position
/ whole
;
3959 shown
= (gdouble
) portion
/ whole
;
3962 size
= clip_to_bounds (1, shown
* XG_SB_RANGE
, XG_SB_RANGE
);
3963 value
= clip_to_bounds (XG_SB_MIN
, top
* XG_SB_RANGE
, XG_SB_MAX
- size
);
3965 /* Assume all lines are of equal size. */
3966 new_step
= size
/ max (1, FRAME_LINES (f
));
3968 old_size
= gtk_adjustment_get_page_size (adj
);
3969 if (old_size
!= size
)
3971 int old_step
= gtk_adjustment_get_step_increment (adj
);
3972 if (old_step
!= new_step
)
3974 gtk_adjustment_set_page_size (adj
, size
);
3975 gtk_adjustment_set_step_increment (adj
, new_step
);
3976 /* Assume a page increment is about 95% of the page size */
3977 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3982 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3986 /* gtk_range_set_value invokes the callback. Set
3987 ignore_gtk_scrollbar to make the callback do nothing */
3988 xg_ignore_gtk_scrollbar
= 1;
3990 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3991 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3993 gtk_adjustment_changed (adj
);
3995 xg_ignore_gtk_scrollbar
= 0;
4002 /* Set the thumb size and position of horizontal scroll bar BAR. We are
4003 currently displaying PORTION out of a whole WHOLE, and our position
4006 xg_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
,
4011 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
4013 if (wscroll
&& bar
->dragging
== -1)
4017 int upper
= max (whole
- 1, 0);
4018 int pagesize
= min (upper
, max (portion
, 0));
4019 int value
= max (0, min (position
, upper
- pagesize
));
4020 /* These should be set to something more <portion, whole>
4022 int page_increment
= 4;
4023 int step_increment
= 1;
4026 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
4027 gtk_adjustment_configure (adj
, (gdouble
) value
, (gdouble
) lower
,
4028 (gdouble
) upper
, (gdouble
) step_increment
,
4029 (gdouble
) page_increment
, (gdouble
) pagesize
);
4030 gtk_adjustment_changed (adj
);
4035 /* Return true if EVENT is for a scroll bar in frame F.
4036 When the same X window is used for several Gtk+ widgets, we cannot
4037 say for sure based on the X window alone if an event is for the
4038 frame. This function does additional checks. */
4041 xg_event_is_for_scrollbar (struct frame
*f
, const XEvent
*event
)
4045 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
4047 /* Check if press occurred outside the edit widget. */
4048 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
4051 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
4052 (gdk_display_get_device_manager (gdpy
));
4053 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
4055 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
4057 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
4060 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
4061 || event
->type
== MotionNotify
))
4063 /* If we are releasing or moving the scroll bar, it has the grab. */
4064 GtkWidget
*w
= gtk_grab_get_current ();
4065 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
4072 /***********************************************************************
4074 ***********************************************************************/
4076 static GtkPrintSettings
*print_settings
= NULL
;
4077 static GtkPageSetup
*page_setup
= NULL
;
4080 xg_page_setup_dialog (void)
4082 GtkPageSetup
*new_page_setup
= NULL
;
4084 if (print_settings
== NULL
)
4085 print_settings
= gtk_print_settings_new ();
4086 new_page_setup
= gtk_print_run_page_setup_dialog (NULL
, page_setup
,
4089 g_object_unref (page_setup
);
4090 page_setup
= new_page_setup
;
4094 xg_get_page_setup (void)
4096 Lisp_Object result
, orientation_symbol
;
4097 GtkPageOrientation orientation
;
4099 if (page_setup
== NULL
)
4100 page_setup
= gtk_page_setup_new ();
4101 result
= list4 (Fcons (Qleft_margin
,
4102 make_float (gtk_page_setup_get_left_margin (page_setup
,
4104 Fcons (Qright_margin
,
4105 make_float (gtk_page_setup_get_right_margin (page_setup
,
4108 make_float (gtk_page_setup_get_top_margin (page_setup
,
4110 Fcons (Qbottom_margin
,
4111 make_float (gtk_page_setup_get_bottom_margin (page_setup
,
4112 GTK_UNIT_POINTS
))));
4113 result
= Fcons (Fcons (Qheight
,
4114 make_float (gtk_page_setup_get_page_height (page_setup
,
4117 result
= Fcons (Fcons (Qwidth
,
4118 make_float (gtk_page_setup_get_page_width (page_setup
,
4121 orientation
= gtk_page_setup_get_orientation (page_setup
);
4122 if (orientation
== GTK_PAGE_ORIENTATION_PORTRAIT
)
4123 orientation_symbol
= Qportrait
;
4124 else if (orientation
== GTK_PAGE_ORIENTATION_LANDSCAPE
)
4125 orientation_symbol
= Qlandscape
;
4126 else if (orientation
== GTK_PAGE_ORIENTATION_REVERSE_PORTRAIT
)
4127 orientation_symbol
= Qreverse_portrait
;
4128 else if (orientation
== GTK_PAGE_ORIENTATION_REVERSE_LANDSCAPE
)
4129 orientation_symbol
= Qreverse_landscape
;
4130 result
= Fcons (Fcons (Qorientation
, orientation_symbol
), result
);
4136 draw_page (GtkPrintOperation
*operation
, GtkPrintContext
*context
,
4137 gint page_nr
, gpointer user_data
)
4139 Lisp_Object frames
= *((Lisp_Object
*) user_data
);
4140 struct frame
*f
= XFRAME (Fnth (make_number (page_nr
), frames
));
4141 cairo_t
*cr
= gtk_print_context_get_cairo_context (context
);
4143 x_cr_draw_frame (cr
, f
);
4147 xg_print_frames_dialog (Lisp_Object frames
)
4149 GtkPrintOperation
*print
;
4150 GtkPrintOperationResult res
;
4152 print
= gtk_print_operation_new ();
4153 if (print_settings
!= NULL
)
4154 gtk_print_operation_set_print_settings (print
, print_settings
);
4155 if (page_setup
!= NULL
)
4156 gtk_print_operation_set_default_page_setup (print
, page_setup
);
4157 gtk_print_operation_set_n_pages (print
, XINT (Flength (frames
)));
4158 g_signal_connect (print
, "draw-page", G_CALLBACK (draw_page
), &frames
);
4159 res
= gtk_print_operation_run (print
, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG
,
4161 if (res
== GTK_PRINT_OPERATION_RESULT_APPLY
)
4163 if (print_settings
!= NULL
)
4164 g_object_unref (print_settings
);
4166 g_object_ref (gtk_print_operation_get_print_settings (print
));
4168 g_object_unref (print
);
4171 #endif /* USE_CAIRO */
4175 /***********************************************************************
4177 ***********************************************************************/
4178 /* The key for the data we put in the GtkImage widgets. The data is
4179 the image used by Emacs. We use this to see if we need to update
4180 the GtkImage with a new image. */
4181 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
4183 /* The key for storing the latest modifiers so the activate callback can
4185 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
4187 /* The key for the data we put in the GtkImage widgets. The data is
4188 the stock name used by Emacs. We use this to see if we need to update
4189 the GtkImage with a new image. */
4190 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
4192 /* As above, but this is used for named theme widgets, as opposed to
4194 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
4196 /* Callback function invoked when a tool bar item is pressed.
4197 W is the button widget in the tool bar that got pressed,
4198 CLIENT_DATA is an integer that is the index of the button in the
4199 tool bar. 0 is the first button. */
4202 xg_tool_bar_button_cb (GtkWidget
*widget
,
4203 GdkEventButton
*event
,
4206 intptr_t state
= event
->state
;
4207 gpointer ptr
= (gpointer
) state
;
4208 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
4213 /* Callback function invoked when a tool bar item is pressed.
4214 W is the button widget in the tool bar that got pressed,
4215 CLIENT_DATA is an integer that is the index of the button in the
4216 tool bar. 0 is the first button. */
4219 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
4221 intptr_t idx
= (intptr_t) client_data
;
4222 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
4223 intptr_t mod
= (intptr_t) gmod
;
4225 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4226 Lisp_Object key
, frame
;
4227 struct input_event event
;
4230 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4233 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4235 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
4236 XSETFRAME (frame
, f
);
4238 /* We generate two events here. The first one is to set the prefix
4239 to `(tool_bar)', see keyboard.c. */
4240 event
.kind
= TOOL_BAR_EVENT
;
4241 event
.frame_or_window
= frame
;
4243 kbd_buffer_store_event (&event
);
4245 event
.kind
= TOOL_BAR_EVENT
;
4246 event
.frame_or_window
= frame
;
4248 /* Convert between the modifier bits GDK uses and the modifier bits
4249 Emacs uses. This assumes GDK and X masks are the same, which they are when
4251 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), mod
);
4252 kbd_buffer_store_event (&event
);
4254 /* Return focus to the frame after we have clicked on a detached
4260 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
4262 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
4263 GtkWidget
*c1
= clist
->data
;
4264 GtkWidget
*c2
= clist
->next
? clist
->next
->data
: NULL
;
4266 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
4267 g_list_free (clist
);
4268 return GTK_IS_LABEL (c1
) ? c1
: c2
;
4272 /* This callback is called when the mouse enters or leaves a tool bar item.
4273 It is used for displaying and hiding the help text.
4274 W is the tool bar item, a button.
4275 EVENT is either an enter event or leave event.
4276 CLIENT_DATA is an integer that is the index of the button in the
4277 tool bar. 0 is the first button.
4279 Returns FALSE to tell GTK to keep processing this event. */
4282 xg_tool_bar_help_callback (GtkWidget
*w
,
4283 GdkEventCrossing
*event
,
4284 gpointer client_data
)
4286 intptr_t idx
= (intptr_t) client_data
;
4287 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4288 Lisp_Object help
, frame
;
4290 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4293 if (event
->type
== GDK_ENTER_NOTIFY
)
4295 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4296 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4299 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4304 XSETFRAME (frame
, f
);
4305 kbd_buffer_store_help_event (frame
, help
);
4311 /* This callback is called when a tool bar item shall be redrawn.
4312 It modifies the expose event so that the GtkImage widget redraws the
4313 whole image. This to overcome a bug that makes GtkImage draw the image
4314 in the wrong place when it tries to redraw just a part of the image.
4315 W is the GtkImage to be redrawn.
4316 EVENT is the expose event for W.
4317 CLIENT_DATA is unused.
4319 Returns FALSE to tell GTK to keep processing this event. */
4323 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4324 GdkEventExpose
*event
,
4325 gpointer client_data
)
4329 gdk_drawable_get_size (event
->window
, &width
, &height
);
4330 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4331 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4333 event
->area
.x
= max (0, event
->area
.x
);
4334 event
->area
.y
= max (0, event
->area
.y
);
4336 event
->area
.width
= max (width
, event
->area
.width
);
4337 event
->area
.height
= max (height
, event
->area
.height
);
4343 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4344 #define toolbar_set_orientation(w, o) \
4345 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4347 #define toolbar_set_orientation(w, o) \
4348 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4351 /* Attach a tool bar to frame F. */
4354 xg_pack_tool_bar (struct frame
*f
, Lisp_Object pos
)
4356 struct x_output
*x
= f
->output_data
.x
;
4357 bool into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4358 GtkWidget
*top_widget
= x
->toolbar_widget
;
4360 toolbar_set_orientation (x
->toolbar_widget
,
4362 ? GTK_ORIENTATION_VERTICAL
4363 : GTK_ORIENTATION_HORIZONTAL
);
4367 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), top_widget
,
4370 if (EQ (pos
, Qleft
))
4371 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4374 x
->toolbar_in_hbox
= true;
4378 bool vbox_pos
= x
->menubar_widget
!= 0;
4379 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), top_widget
,
4383 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4386 x
->toolbar_in_hbox
= false;
4388 x
->toolbar_is_packed
= true;
4391 static bool xg_update_tool_bar_sizes (struct frame
*f
);
4394 tb_size_cb (GtkWidget
*widget
,
4395 GdkRectangle
*allocation
,
4398 /* When tool bar is created it has one preferred size. But when size is
4399 allocated between widgets, it may get another. So we must update
4400 size hints if tool bar size changes. Seen on Fedora 18 at least. */
4401 struct frame
*f
= user_data
;
4403 if (xg_update_tool_bar_sizes (f
))
4405 frame_size_history_add (f
, Qtb_size_cb
, 0, 0, Qnil
);
4406 adjust_frame_size (f
, -1, -1, 5, 0, Qtool_bar_lines
);
4410 /* Create a tool bar for frame F. */
4413 xg_create_tool_bar (struct frame
*f
)
4415 struct x_output
*x
= f
->output_data
.x
;
4416 #if GTK_CHECK_VERSION (3, 3, 6)
4417 GtkStyleContext
*gsty
;
4419 struct xg_frame_tb_info
*tbinfo
4420 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4424 tbinfo
= xmalloc (sizeof (*tbinfo
));
4425 tbinfo
->last_tool_bar
= Qnil
;
4426 tbinfo
->style
= Qnil
;
4427 tbinfo
->hmargin
= tbinfo
->vmargin
= 0;
4428 tbinfo
->dir
= GTK_TEXT_DIR_NONE
;
4429 tbinfo
->n_last_items
= 0;
4430 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4435 x
->toolbar_widget
= gtk_toolbar_new ();
4437 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4439 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4440 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4441 g_signal_connect (x
->toolbar_widget
, "size-allocate",
4442 G_CALLBACK (tb_size_cb
), f
);
4443 #if GTK_CHECK_VERSION (3, 3, 6)
4444 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4445 gtk_style_context_add_class (gsty
, "primary-toolbar");
4450 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4452 /* Find the right-to-left image named by RTL in the tool bar images for F.
4453 Returns IMAGE if RTL is not found. */
4456 find_rtl_image (struct frame
*f
, Lisp_Object image
, Lisp_Object rtl
)
4459 Lisp_Object file
, rtl_name
;
4460 struct gcpro gcpro1
, gcpro2
;
4461 GCPRO2 (file
, rtl_name
);
4463 rtl_name
= Ffile_name_nondirectory (rtl
);
4465 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4467 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4468 if (!NILP (file
= file_for_image (rtl_image
)))
4470 file
= call1 (intern ("file-name-sans-extension"),
4471 Ffile_name_nondirectory (file
));
4472 if (! NILP (Fequal (file
, rtl_name
)))
4483 static GtkToolItem
*
4484 xg_make_tool_item (struct frame
*f
,
4486 GtkWidget
**wbutton
,
4488 int i
, bool horiz
, bool text_image
)
4490 GtkToolItem
*ti
= gtk_tool_item_new ();
4491 GtkWidget
*vb
= gtk_box_new (horiz
4492 ? GTK_ORIENTATION_HORIZONTAL
4493 : GTK_ORIENTATION_VERTICAL
,
4495 GtkWidget
*wb
= gtk_button_new ();
4496 /* The eventbox is here so we can have tooltips on disabled items. */
4497 GtkWidget
*weventbox
= gtk_event_box_new ();
4498 #if GTK_CHECK_VERSION (3, 3, 6)
4499 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4500 GtkStyleContext
*gsty
;
4502 gtk_css_provider_load_from_data (css_prov
,
4504 " background-color: transparent;"
4508 gsty
= gtk_widget_get_style_context (weventbox
);
4509 gtk_style_context_add_provider (gsty
,
4510 GTK_STYLE_PROVIDER (css_prov
),
4511 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4512 g_object_unref (css_prov
);
4515 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4517 if (wimage
&& !text_image
)
4518 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4520 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4521 if (wimage
&& text_image
)
4522 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4524 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4525 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4526 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4527 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4528 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4530 if (wimage
|| label
)
4533 gpointer gi
= (gpointer
) ii
;
4535 g_signal_connect (G_OBJECT (wb
), "clicked",
4536 G_CALLBACK (xg_tool_bar_callback
),
4539 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4542 /* Catch expose events to overcome an annoying redraw bug, see
4543 comment for xg_tool_bar_item_expose_callback. */
4544 g_signal_connect (G_OBJECT (ti
),
4546 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4549 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4551 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4552 no distinction based on modifiers in the activate callback,
4553 so we have to do it ourselves. */
4554 g_signal_connect (wb
, "button-release-event",
4555 G_CALLBACK (xg_tool_bar_button_cb
),
4558 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4560 /* Use enter/leave notify to show help. We use the events
4561 rather than the GtkButton specific signals "enter" and
4562 "leave", so we can have only one callback. The event
4563 will tell us what kind of event it is. */
4564 g_signal_connect (G_OBJECT (weventbox
),
4565 "enter-notify-event",
4566 G_CALLBACK (xg_tool_bar_help_callback
),
4568 g_signal_connect (G_OBJECT (weventbox
),
4569 "leave-notify-event",
4570 G_CALLBACK (xg_tool_bar_help_callback
),
4574 if (wbutton
) *wbutton
= wb
;
4580 is_box_type (GtkWidget
*vb
, bool is_horizontal
)
4584 if (GTK_IS_BOX (vb
))
4586 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4587 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4588 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4592 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4598 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4599 const char *icon_name
, const struct image
*img
,
4600 const char *label
, bool horiz
)
4604 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4605 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4607 /* Check if the tool icon matches. */
4608 if (stock_name
&& wimage
)
4610 old
= g_object_get_data (G_OBJECT (wimage
),
4611 XG_TOOL_BAR_STOCK_NAME
);
4612 if (!old
|| strcmp (old
, stock_name
))
4615 else if (icon_name
&& wimage
)
4617 old
= g_object_get_data (G_OBJECT (wimage
),
4618 XG_TOOL_BAR_ICON_NAME
);
4619 if (!old
|| strcmp (old
, icon_name
))
4624 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4625 XG_TOOL_BAR_IMAGE_DATA
);
4626 Pixmap old_img
= (Pixmap
) gold_img
;
4627 if (old_img
!= img
->pixmap
)
4631 /* Check button configuration and label. */
4632 if (is_box_type (vb
, horiz
)
4633 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4636 /* Ensure label is correct. */
4638 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4643 xg_update_tool_bar_sizes (struct frame
*f
)
4645 struct x_output
*x
= f
->output_data
.x
;
4647 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4648 GtkWidget
*top_widget
= x
->toolbar_widget
;
4650 gtk_widget_get_preferred_size (GTK_WIDGET (top_widget
), NULL
, &req
);
4651 if (x
->toolbar_in_hbox
)
4654 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4656 "position", &pos
, NULL
);
4657 if (pos
== 0) nl
= req
.width
;
4658 else nr
= req
.width
;
4663 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4665 "position", &pos
, NULL
);
4666 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4667 else nb
= req
.height
;
4670 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4671 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4672 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4673 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4675 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4676 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4677 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4678 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4679 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4680 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4689 find_icon_from_name (char *name
,
4690 GtkIconTheme
*icon_theme
,
4693 #if ! GTK_CHECK_VERSION (3, 10, 0)
4694 GtkStockItem stock_item
;
4697 if (name
[0] == 'n' && name
[1] == ':')
4699 *icon_name
= name
+ 2;
4702 if (! gtk_icon_theme_has_icon (icon_theme
, *icon_name
))
4706 #if ! GTK_CHECK_VERSION (3, 10, 0)
4707 else if (gtk_stock_lookup (name
, &stock_item
))
4710 else if (gtk_icon_theme_has_icon (icon_theme
, name
))
4725 /* Update the tool bar for frame F. Add new buttons and remove old. */
4728 update_frame_tool_bar (struct frame
*f
)
4731 struct x_output
*x
= f
->output_data
.x
;
4732 int hmargin
= 0, vmargin
= 0;
4733 GtkToolbar
*wtoolbar
;
4735 GtkTextDirection dir
;
4737 bool text_image
, horiz
;
4738 struct xg_frame_tb_info
*tbinfo
;
4740 GtkIconTheme
*icon_theme
;
4743 if (! FRAME_GTK_WIDGET (f
))
4748 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4750 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4751 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4753 else if (CONSP (Vtool_bar_button_margin
))
4755 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4756 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4758 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4759 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4762 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4763 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4764 i.e. zero. This means that margins less than
4765 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4766 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4767 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4769 if (! x
->toolbar_widget
)
4770 xg_create_tool_bar (f
);
4772 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4773 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4775 style
= Ftool_bar_get_system_style ();
4776 screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4777 icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4779 /* Are we up to date? */
4780 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4783 if (! NILP (tbinfo
->last_tool_bar
) && ! NILP (f
->tool_bar_items
)
4784 && tbinfo
->n_last_items
== f
->n_tool_bar_items
4785 && tbinfo
->hmargin
== hmargin
&& tbinfo
->vmargin
== vmargin
4786 && tbinfo
->dir
== dir
4787 && ! NILP (Fequal (tbinfo
->style
, style
))
4788 && ! NILP (Fequal (tbinfo
->last_tool_bar
, f
->tool_bar_items
)))
4794 tbinfo
->last_tool_bar
= f
->tool_bar_items
;
4795 tbinfo
->n_last_items
= f
->n_tool_bar_items
;
4796 tbinfo
->style
= style
;
4797 tbinfo
->hmargin
= hmargin
;
4798 tbinfo
->vmargin
= vmargin
;
4801 text_image
= EQ (style
, Qtext_image_horiz
);
4802 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4804 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4806 bool enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4807 bool selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4811 struct image
*img
= NULL
;
4813 Lisp_Object stock
= Qnil
;
4814 char *stock_name
= NULL
;
4815 char *icon_name
= NULL
;
4817 GtkWidget
*wbutton
= NULL
;
4818 Lisp_Object specified_file
;
4819 bool vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4821 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4822 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4823 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4826 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4828 /* If this is a separator, use a gtk separator item. */
4829 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4831 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4834 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4836 ti
= gtk_separator_tool_item_new ();
4837 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4843 /* Otherwise, the tool-bar item is an ordinary button. */
4845 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4847 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4851 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4853 /* Ignore invalid image specifications. */
4854 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4855 if (!valid_image_p (image
))
4858 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4863 specified_file
= file_for_image (image
);
4864 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4865 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4870 for (tem
= stock
; CONSP (tem
); tem
= XCDR (tem
))
4871 if (! NILP (tem
) && STRINGP (XCAR (tem
)))
4873 stock_name
= find_icon_from_name (SSDATA (XCAR (tem
)),
4876 if (stock_name
|| icon_name
) break;
4879 else if (STRINGP (stock
))
4881 stock_name
= find_icon_from_name (SSDATA (stock
),
4886 if (stock_name
|| icon_name
)
4887 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4889 if (stock_name
== NULL
&& icon_name
== NULL
)
4891 /* No stock image, or stock item not known. Try regular
4892 image. If image is a vector, choose it according to the
4894 if (dir
== GTK_TEXT_DIR_RTL
4895 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4897 image
= find_rtl_image (f
, image
, rtl
);
4899 if (VECTORP (image
))
4903 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4904 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4907 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4908 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4910 eassert (ASIZE (image
) >= idx
);
4911 image
= AREF (image
, idx
);
4916 img_id
= lookup_image (f
, image
);
4917 img
= IMAGE_FROM_ID (f
, img_id
);
4918 prepare_image_for_display (f
, img
);
4920 if (img
->load_failed_p
|| img
->pixmap
== None
)
4923 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4929 /* If there is an existing widget, check if it's stale; if so,
4930 remove it and make a new tool item from scratch. */
4931 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4934 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4943 /* Save the image so we can see if an update is needed the
4944 next time we call xg_tool_item_match_p. */
4945 if (EQ (style
, Qtext
))
4947 else if (stock_name
)
4950 #if GTK_CHECK_VERSION (3, 10, 0)
4951 w
= gtk_image_new_from_icon_name (stock_name
, icon_size
);
4953 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4955 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4956 (gpointer
) xstrdup (stock_name
),
4957 (GDestroyNotify
) xfree
);
4961 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4962 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4963 (gpointer
) xstrdup (icon_name
),
4964 (GDestroyNotify
) xfree
);
4968 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4969 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4970 (gpointer
)img
->pixmap
);
4973 #if GTK_CHECK_VERSION (3, 14, 0)
4976 gtk_widget_set_margin_start (w
, hmargin
);
4977 gtk_widget_set_margin_end (w
, hmargin
);
4978 gtk_widget_set_margin_top (w
, vmargin
);
4979 gtk_widget_set_margin_bottom (w
, vmargin
);
4982 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4984 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4985 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4990 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4994 /* Remove buttons not longer needed. */
4997 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4999 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
5000 } while (ti
!= NULL
);
5002 if (f
->n_tool_bar_items
!= 0)
5004 if (! x
->toolbar_is_packed
)
5005 xg_pack_tool_bar (f
, FRAME_TOOL_BAR_POSITION (f
));
5006 gtk_widget_show_all (x
->toolbar_widget
);
5007 if (xg_update_tool_bar_sizes (f
))
5009 frame_size_history_add (f
, Qupdate_frame_tool_bar
, 0, 0, Qnil
);
5010 adjust_frame_size (f
, -1, -1, 2, 0, Qtool_bar_lines
);
5017 /* Deallocate all resources for the tool bar on frame F.
5018 Remove the tool bar. */
5021 free_frame_tool_bar (struct frame
*f
)
5023 struct x_output
*x
= f
->output_data
.x
;
5025 if (x
->toolbar_widget
)
5027 struct xg_frame_tb_info
*tbinfo
;
5028 GtkWidget
*top_widget
= x
->toolbar_widget
;
5031 if (x
->toolbar_is_packed
)
5033 if (x
->toolbar_in_hbox
)
5034 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
5037 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
5041 gtk_widget_destroy (x
->toolbar_widget
);
5043 x
->toolbar_widget
= 0;
5044 x
->toolbar_widget
= 0;
5045 x
->toolbar_is_packed
= false;
5046 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
5047 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
5049 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
5054 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
5059 frame_size_history_add (f
, Qfree_frame_tool_bar
, 0, 0, Qnil
);
5060 adjust_frame_size (f
, -1, -1, 2, 0, Qtool_bar_lines
);
5067 xg_change_toolbar_position (struct frame
*f
, Lisp_Object pos
)
5069 struct x_output
*x
= f
->output_data
.x
;
5070 GtkWidget
*top_widget
= x
->toolbar_widget
;
5072 if (! x
->toolbar_widget
|| ! top_widget
)
5076 g_object_ref (top_widget
);
5077 if (x
->toolbar_is_packed
)
5079 if (x
->toolbar_in_hbox
)
5080 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
5083 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
5087 xg_pack_tool_bar (f
, pos
);
5088 g_object_unref (top_widget
);
5090 if (xg_update_tool_bar_sizes (f
))
5092 frame_size_history_add (f
, Qxg_change_toolbar_position
, 0, 0, Qnil
);
5093 adjust_frame_size (f
, -1, -1, 2, 0, Qtool_bar_lines
);
5102 /***********************************************************************
5104 ***********************************************************************/
5106 xg_initialize (void)
5108 GtkBindingSet
*binding_set
;
5109 GtkSettings
*settings
;
5112 /* Work around a bug with corrupted data if libXft gets unloaded. This way
5113 we keep it permanently linked in. */
5118 xg_ignore_gtk_scrollbar
= 0;
5119 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
5120 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
5122 id_to_widget
.max_size
= id_to_widget
.used
= 0;
5123 id_to_widget
.widgets
= 0;
5125 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
5126 (gdk_display_get_default ()));
5127 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
5128 bindings. It doesn't seem to be any way to remove properties,
5129 so we set it to "" which in means "no key". */
5130 gtk_settings_set_string_property (settings
,
5131 "gtk-menu-bar-accel",
5135 /* Make GTK text input widgets use Emacs style keybindings. This is
5137 gtk_settings_set_string_property (settings
,
5138 "gtk-key-theme-name",
5142 /* Make dialogs close on C-g. Since file dialog inherits from
5143 dialog, this works for them also. */
5144 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
5145 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5148 /* Make menus close on C-g. */
5149 binding_set
= gtk_binding_set_by_class (g_type_class_ref
5150 (GTK_TYPE_MENU_SHELL
));
5151 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5153 update_theme_scrollbar_width ();
5154 update_theme_scrollbar_height ();
5156 #ifdef HAVE_FREETYPE
5157 x_last_font_name
= NULL
;
5161 #endif /* USE_GTK */