1 /* Functions for creating and updating GTK widgets.
3 Copyright (C) 2003-2013 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"
34 #include "termhooks.h"
40 #include <gdk/gdkkeysyms.h>
41 #include "xsettings.h"
44 #include <X11/Xft/Xft.h>
49 #include "emacsgtkfixed.h"
52 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
53 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
55 #define FRAME_TOTAL_PIXEL_WIDTH(f) \
56 (FRAME_PIXEL_WIDTH (f) + FRAME_TOOLBAR_WIDTH (f))
58 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
59 #define gtk_widget_set_has_window(w, b) \
60 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
62 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
63 #define gtk_dialog_get_action_area(w) ((w)->action_area)
64 #define gtk_dialog_get_content_area(w) ((w)->vbox)
66 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
67 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
69 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
70 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
71 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
72 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
73 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
75 #if GTK_CHECK_VERSION (2, 12, 0)
76 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
78 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
81 #if GTK_CHECK_VERSION (3, 2, 0)
82 #define USE_NEW_GTK_FONT_CHOOSER 1
84 #define USE_NEW_GTK_FONT_CHOOSER 0
85 #define gtk_font_chooser_dialog_new(x, y) \
86 gtk_font_selection_dialog_new (x)
87 #undef GTK_FONT_CHOOSER
88 #define GTK_FONT_CHOOSER(x) GTK_FONT_SELECTION_DIALOG (x)
89 #define gtk_font_chooser_set_font(x, y) \
90 gtk_font_selection_dialog_set_font_name (x, y)
94 #ifdef USE_GTK_TOOLTIP
95 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
97 #define gdk_window_get_geometry(w, a, b, c, d) \
98 gdk_window_get_geometry (w, a, b, c, d, 0)
99 #define gdk_x11_window_lookup_for_display(d, w) \
100 gdk_xid_table_lookup_for_display (d, w)
101 #define gtk_box_new(ori, spacing) \
102 ((ori) == GTK_ORIENTATION_HORIZONTAL \
103 ? gtk_hbox_new (FALSE, (spacing)) : gtk_vbox_new (FALSE, (spacing)))
104 #define gtk_scrollbar_new(ori, spacing) \
105 ((ori) == GTK_ORIENTATION_HORIZONTAL \
106 ? gtk_hscrollbar_new ((spacing)) : gtk_vscrollbar_new ((spacing)))
108 #define GDK_KEY_g GDK_g
110 #endif /* HAVE_GTK3 */
112 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
114 static void update_theme_scrollbar_width (void);
116 #define TB_INFO_KEY "xg_frame_tb_info"
117 struct xg_frame_tb_info
119 Lisp_Object last_tool_bar
;
122 int hmargin
, vmargin
;
123 GtkTextDirection dir
;
127 /***********************************************************************
128 Display handling functions
129 ***********************************************************************/
131 /* Keep track of the default display, or NULL if there is none. Emacs
132 may close all its displays. */
134 static GdkDisplay
*gdpy_def
;
136 /* When the GTK widget W is to be created on a display for F that
137 is not the default display, set the display for W.
138 W can be a GtkMenu or a GtkWindow widget. */
141 xg_set_screen (GtkWidget
*w
, struct frame
*f
)
143 if (FRAME_X_DISPLAY (f
) != DEFAULT_GDK_DISPLAY ())
145 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
146 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
149 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
151 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
156 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
157 *DPY is set to NULL if the display can't be opened.
159 Returns non-zero if display could be opened, zero if display could not
160 be opened, and less than zero if the GTK version doesn't support
161 multiple displays. */
164 xg_display_open (char *display_name
, Display
**dpy
)
168 gdpy
= gdk_display_open (display_name
);
169 if (!gdpy_def
&& gdpy
)
172 gdk_display_manager_set_default_display (gdk_display_manager_get (),
176 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
180 /* Close display DPY. */
183 xg_display_close (Display
*dpy
)
185 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
187 /* If this is the default display, try to change it before closing.
188 If there is no other display to use, gdpy_def is set to NULL, and
189 the next call to xg_display_open resets the default display. */
190 if (gdk_display_get_default () == gdpy
)
192 struct x_display_info
*dpyinfo
;
193 GdkDisplay
*gdpy_new
= NULL
;
195 /* Find another display. */
196 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
197 if (dpyinfo
->display
!= dpy
)
199 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
200 gdk_display_manager_set_default_display (gdk_display_manager_get (),
207 #if GTK_CHECK_VERSION (2, 0, 0) && ! GTK_CHECK_VERSION (2, 10, 0)
208 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
209 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
210 can continue running, but there will be memory leaks. */
211 g_object_run_dispose (G_OBJECT (gdpy
));
213 /* This seems to be fixed in GTK 2.10. */
214 gdk_display_close (gdpy
);
219 /***********************************************************************
221 ***********************************************************************/
222 /* The next two variables and functions are taken from lwlib. */
223 static widget_value
*widget_value_free_list
;
224 static int malloc_cpt
;
226 /* Allocate a widget_value structure, either by taking one from the
227 widget_value_free_list or by malloc:ing a new one.
229 Return a pointer to the allocated structure. */
232 malloc_widget_value (void)
235 if (widget_value_free_list
)
237 wv
= widget_value_free_list
;
238 widget_value_free_list
= wv
->free_list
;
243 wv
= xmalloc (sizeof *wv
);
246 memset (wv
, 0, sizeof (widget_value
));
250 /* This is analogous to free. It frees only what was allocated
251 by malloc_widget_value, and no substructures. */
254 free_widget_value (widget_value
*wv
)
261 /* When the number of already allocated cells is too big,
268 wv
->free_list
= widget_value_free_list
;
269 widget_value_free_list
= wv
;
274 /* Create and return the cursor to be used for popup menus and
275 scroll bars on display DPY. */
278 xg_create_default_cursor (Display
*dpy
)
280 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
281 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
285 xg_get_pixbuf_from_pixmap (struct frame
*f
, Pixmap pix
)
290 unsigned int width
, height
, uunused
;
293 XGetGeometry (FRAME_X_DISPLAY (f
), pix
, &wunused
, &iunused
, &iunused
,
294 &width
, &height
, &uunused
, &uunused
);
296 xim
= XGetImage (FRAME_X_DISPLAY (f
), pix
, 0, 0, width
, height
,
300 tmp_buf
= gdk_pixbuf_new_from_data ((guchar
*) xim
->data
,
313 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
316 xg_get_pixbuf_from_pix_and_mask (struct frame
*f
,
321 GdkPixbuf
*icon_buf
, *tmp_buf
;
323 tmp_buf
= xg_get_pixbuf_from_pixmap (f
, pix
);
324 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
325 g_object_unref (G_OBJECT (tmp_buf
));
327 width
= gdk_pixbuf_get_width (icon_buf
);
328 height
= gdk_pixbuf_get_height (icon_buf
);
332 GdkPixbuf
*mask_buf
= xg_get_pixbuf_from_pixmap (f
, mask
);
333 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
334 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
335 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
336 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
339 for (y
= 0; y
< height
; ++y
)
341 guchar
*iconptr
, *maskptr
;
344 iconptr
= pixels
+ y
* rowstride
;
345 maskptr
= mask_pixels
+ y
* mask_rowstride
;
347 for (x
= 0; x
< width
; ++x
)
349 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
350 just R is sufficient. */
352 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
354 iconptr
+= rowstride
/width
;
355 maskptr
+= mask_rowstride
/width
;
359 g_object_unref (G_OBJECT (mask_buf
));
366 file_for_image (Lisp_Object image
)
368 Lisp_Object specified_file
= Qnil
;
371 for (tail
= XCDR (image
);
372 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
373 tail
= XCDR (XCDR (tail
)))
374 if (EQ (XCAR (tail
), QCfile
))
375 specified_file
= XCAR (XCDR (tail
));
377 return specified_file
;
380 /* For the image defined in IMG, make and return a GtkImage. For displays with
381 8 planes or less we must make a GdkPixbuf and apply the mask manually.
382 Otherwise the highlighting and dimming the tool bar code in GTK does
383 will look bad. For display with more than 8 planes we just use the
384 pixmap and mask directly. For monochrome displays, GTK doesn't seem
385 able to use external pixmaps, it looks bad whatever we do.
386 The image is defined on the display where frame F is.
387 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
388 If OLD_WIDGET is NULL, a new widget is constructed and returned.
389 If OLD_WIDGET is not NULL, that widget is modified. */
392 xg_get_image_for_pixmap (struct frame
*f
,
395 GtkImage
*old_widget
)
399 /* If we have a file, let GTK do all the image handling.
400 This seems to be the only way to make insensitive and activated icons
401 look good in all cases. */
402 Lisp_Object specified_file
= file_for_image (img
->spec
);
405 /* We already loaded the image once before calling this
406 function, so this only fails if the image file has been removed.
407 In that case, use the pixmap already loaded. */
409 if (STRINGP (specified_file
)
410 && STRINGP (file
= x_find_image_file (specified_file
)))
413 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
415 gtk_image_set_from_file (old_widget
, SSDATA (file
));
417 return GTK_WIDGET (old_widget
);
420 /* No file, do the image handling ourselves. This will look very bad
421 on a monochrome display, and sometimes bad on all displays with
424 /* This is a workaround to make icons look good on pseudo color
425 displays. Apparently GTK expects the images to have an alpha
426 channel. If they don't, insensitive and activated icons will
427 look bad. This workaround does not work on monochrome displays,
428 and is strictly not needed on true color/static color displays (i.e.
429 16 bits and higher). But we do it anyway so we get a pixbuf that is
430 not associated with the img->pixmap. The img->pixmap may be removed
431 by clearing the image cache and then the tool bar redraw fails, since
432 Gtk+ assumes the pixmap is always there. */
433 icon_buf
= xg_get_pixbuf_from_pix_and_mask (f
, img
->pixmap
, img
->mask
);
438 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
440 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
442 g_object_unref (G_OBJECT (icon_buf
));
445 return GTK_WIDGET (old_widget
);
449 /* Set CURSOR on W and all widgets W contain. We must do like this
450 for scroll bars and menu because they create widgets internally,
451 and it is those widgets that are visible. */
454 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
456 GdkWindow
*window
= gtk_widget_get_window (w
);
457 GList
*children
= gdk_window_peek_children (window
);
459 gdk_window_set_cursor (window
, cursor
);
461 /* The scroll bar widget has more than one GDK window (had to look at
462 the source to figure this out), and there is no way to set cursor
463 on widgets in GTK. So we must set the cursor for all GDK windows.
466 for ( ; children
; children
= g_list_next (children
))
467 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
470 /* Insert NODE into linked LIST. */
473 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
475 xg_list_node
*list_start
= list
->next
;
477 if (list_start
) list_start
->prev
= node
;
478 node
->next
= list_start
;
483 /* Remove NODE from linked LIST. */
486 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
488 xg_list_node
*list_start
= list
->next
;
489 if (node
== list_start
)
491 list
->next
= node
->next
;
492 if (list
->next
) list
->next
->prev
= 0;
496 node
->prev
->next
= node
->next
;
497 if (node
->next
) node
->next
->prev
= node
->prev
;
501 /* Allocate and return a utf8 version of STR. If STR is already
502 utf8 or NULL, just return a copy of STR.
503 A new string is allocated and the caller must free the result
507 get_utf8_string (const char *str
)
511 if (!str
) return NULL
;
513 /* If not UTF-8, try current locale. */
514 if (!g_utf8_validate (str
, -1, NULL
))
515 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
517 return g_strdup (str
);
521 /* Probably some control characters in str. Escape them. */
523 ptrdiff_t nr_bad
= 0;
526 unsigned char *p
= (unsigned char *)str
;
530 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
531 &bytes_written
, &err
))
532 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
535 p
+= bytes_written
+1;
548 if ((min (PTRDIFF_MAX
, SIZE_MAX
) - len
- 1) / 4 < nr_bad
)
549 memory_full (SIZE_MAX
);
550 up
= utf8_str
= xmalloc (len
+ nr_bad
* 4 + 1);
551 p
= (unsigned char *)str
;
553 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
554 &bytes_written
, &err
))
555 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
557 memcpy (up
, p
, bytes_written
);
558 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
559 up
+= bytes_written
+4;
560 p
+= bytes_written
+1;
567 strcat (utf8_str
, cp
);
579 /* Check for special colors used in face spec for region face.
580 The colors are fetched from the Gtk+ theme.
581 Return true if color was found, false if not. */
584 xg_check_special_colors (struct frame
*f
,
585 const char *color_name
,
589 bool get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
590 bool get_fg
= !get_bg
&& strcmp ("gtk_selection_fg_color", color_name
) == 0;
592 if (! FRAME_GTK_WIDGET (f
) || ! (get_bg
|| get_fg
))
598 GtkStyleContext
*gsty
599 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f
));
601 char buf
[sizeof "rgbi://" + 3 * (DBL_MAX_10_EXP
+ sizeof "-1.000000" - 1)];
602 int state
= GTK_STATE_FLAG_SELECTED
|GTK_STATE_FLAG_FOCUSED
;
604 gtk_style_context_get_color (gsty
, state
, &col
);
606 gtk_style_context_get_background_color (gsty
, state
, &col
);
608 sprintf (buf
, "rgbi:%lf/%lf/%lf", col
.red
, col
.green
, col
.blue
);
609 success_p
= (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
613 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
614 GdkColor
*grgb
= get_bg
615 ? &gsty
->bg
[GTK_STATE_SELECTED
]
616 : &gsty
->fg
[GTK_STATE_SELECTED
];
618 color
->red
= grgb
->red
;
619 color
->green
= grgb
->green
;
620 color
->blue
= grgb
->blue
;
621 color
->pixel
= grgb
->pixel
;
632 /***********************************************************************
634 ***********************************************************************/
635 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
636 We use that to pop down the tooltip. This happens if Gtk+ for some
637 reason wants to change or hide the tooltip. */
639 #ifdef USE_GTK_TOOLTIP
642 hierarchy_ch_cb (GtkWidget
*widget
,
643 GtkWidget
*previous_toplevel
,
646 struct frame
*f
= user_data
;
647 struct x_output
*x
= f
->output_data
.x
;
648 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
650 if (! top
|| ! GTK_IS_WINDOW (top
))
651 gtk_widget_hide (previous_toplevel
);
654 /* Callback called when Gtk+ thinks a tooltip should be displayed.
655 We use it to get the tooltip window and the tooltip widget so
656 we can manipulate the ourselves.
658 Return FALSE ensures that the tooltip is not shown. */
661 qttip_cb (GtkWidget
*widget
,
664 gboolean keyboard_mode
,
668 struct frame
*f
= user_data
;
669 struct x_output
*x
= f
->output_data
.x
;
670 if (x
->ttip_widget
== NULL
)
675 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
676 x
->ttip_widget
= tooltip
;
677 g_object_ref (G_OBJECT (tooltip
));
678 x
->ttip_lbl
= gtk_label_new ("");
679 g_object_ref (G_OBJECT (x
->ttip_lbl
));
680 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
681 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
683 /* Change stupid Gtk+ default line wrapping. */
684 p
= gtk_widget_get_parent (x
->ttip_lbl
);
685 list
= gtk_container_get_children (GTK_CONTAINER (p
));
686 for (iter
= list
; iter
; iter
= g_list_next (iter
))
688 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
689 if (GTK_IS_LABEL (w
))
690 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
694 /* ATK needs an empty title for some reason. */
695 gtk_window_set_title (x
->ttip_window
, "");
696 /* Realize so we can safely get screen later on. */
697 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
698 gtk_widget_realize (x
->ttip_lbl
);
700 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
701 G_CALLBACK (hierarchy_ch_cb
), f
);
706 #endif /* USE_GTK_TOOLTIP */
708 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
709 Return true if a system tooltip is available. */
712 xg_prepare_tooltip (struct frame
*f
,
717 #ifndef USE_GTK_TOOLTIP
720 struct x_output
*x
= f
->output_data
.x
;
724 GtkSettings
*settings
;
725 gboolean tt_enabled
= TRUE
;
727 Lisp_Object encoded_string
;
729 if (!x
->ttip_lbl
) return 0;
732 encoded_string
= ENCODE_UTF_8 (string
);
733 widget
= GTK_WIDGET (x
->ttip_lbl
);
734 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
735 screen
= gdk_window_get_screen (gwin
);
736 settings
= gtk_settings_get_for_screen (screen
);
737 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
740 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
741 /* Record that we disabled it so it can be enabled again. */
742 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
746 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
747 g_object_set_data (G_OBJECT
748 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
749 "gdk-display-current-tooltip", NULL
);
751 /* Put our dummy widget in so we can get callbacks for unrealize and
752 hierarchy-changed. */
753 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
754 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
755 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
756 if (width
) *width
= req
.width
;
757 if (height
) *height
= req
.height
;
762 #endif /* USE_GTK_TOOLTIP */
765 /* Show the tooltip at ROOT_X and ROOT_Y.
766 xg_prepare_tooltip must have been called before this function. */
769 xg_show_tooltip (struct frame
*f
, int root_x
, int root_y
)
771 #ifdef USE_GTK_TOOLTIP
772 struct x_output
*x
= f
->output_data
.x
;
776 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
777 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
783 /* Hide tooltip if shown. Do nothing if not shown.
784 Return true if tip was hidden, false if not (i.e. not using
788 xg_hide_tooltip (struct frame
*f
)
791 #ifdef USE_GTK_TOOLTIP
792 if (f
->output_data
.x
->ttip_window
)
794 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
796 gtk_widget_hide (GTK_WIDGET (win
));
798 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
800 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
801 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
802 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
803 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
814 /***********************************************************************
815 General functions for creating widgets, resizing, events, e.t.c.
816 ***********************************************************************/
819 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
820 const gchar
*msg
, gpointer user_data
)
822 if (!strstr (msg
, "visible children"))
823 fprintf (stderr
, "XX %s-WARNING **: %s\n", log_domain
, msg
);
826 /* Make a geometry string and pass that to GTK. It seems this is the
827 only way to get geometry position right if the user explicitly
828 asked for a position when starting Emacs.
829 F is the frame we shall set geometry for. */
832 xg_set_geometry (struct frame
*f
)
834 if (f
->size_hint_flags
& (USPosition
| PPosition
))
836 int left
= f
->left_pos
;
837 int xneg
= f
->size_hint_flags
& XNegative
;
838 int top
= f
->top_pos
;
839 int yneg
= f
->size_hint_flags
& YNegative
;
840 char geom_str
[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
848 sprintf (geom_str
, "=%dx%d%c%d%c%d",
849 FRAME_PIXEL_WIDTH (f
),
850 FRAME_PIXEL_HEIGHT (f
),
851 (xneg
? '-' : '+'), left
,
852 (yneg
? '-' : '+'), top
);
854 /* Silence warning about visible children. */
855 id
= g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
856 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
858 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
860 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
862 g_log_remove_handler ("Gtk", id
);
866 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
867 and use a GtkFixed widget, this doesn't happen automatically. */
870 xg_clear_under_internal_border (struct frame
*f
)
872 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
874 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
875 gtk_widget_queue_draw (wfixed
);
876 gdk_window_process_all_updates ();
877 x_clear_area (FRAME_X_DISPLAY (f
),
880 FRAME_PIXEL_WIDTH (f
),
881 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
882 x_clear_area (FRAME_X_DISPLAY (f
),
885 FRAME_INTERNAL_BORDER_WIDTH (f
),
886 FRAME_PIXEL_HEIGHT (f
), 0);
887 x_clear_area (FRAME_X_DISPLAY (f
),
889 0, FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
890 FRAME_PIXEL_WIDTH (f
),
891 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
892 x_clear_area (FRAME_X_DISPLAY (f
),
894 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
896 FRAME_INTERNAL_BORDER_WIDTH (f
),
897 FRAME_PIXEL_HEIGHT (f
), 0);
901 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
902 and a Gtk+ menu bar, we get resize events for the edit part of the
903 frame only. We let Gtk+ deal with the Gtk+ parts.
904 F is the frame to resize.
905 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
908 xg_frame_resized (struct frame
*f
, int pixelwidth
, int pixelheight
)
912 if (pixelwidth
== -1 && pixelheight
== -1)
914 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
915 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
917 &pixelwidth
, &pixelheight
);
922 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
923 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
925 if (columns
!= FRAME_COLS (f
)
926 || rows
!= FRAME_LINES (f
)
927 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
928 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
930 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
931 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
933 xg_clear_under_internal_border (f
);
934 change_frame_size (f
, rows
, columns
, 0, 1, 0);
935 SET_FRAME_GARBAGED (f
);
936 cancel_mouse_face (f
);
940 /* Resize the outer window of frame F after changing the height.
941 COLUMNS/ROWS is the size the edit area shall have after the resize. */
944 xg_frame_set_char_size (struct frame
*f
, int cols
, int rows
)
946 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
947 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
950 if (FRAME_PIXEL_HEIGHT (f
) == 0)
953 /* Take into account the size of the scroll bar. Always use the
954 number of columns occupied by the scroll bar here otherwise we
955 might end up with a frame width that is not a multiple of the
956 frame's character width which is bad for vertically split
958 f
->scroll_bar_actual_width
959 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
961 compute_fringe_widths (f
, 0);
963 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
964 after calculating that value. */
965 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
)
966 + FRAME_TOOLBAR_WIDTH (f
);
969 /* Do this before resize, as we don't know yet if we will be resized. */
970 xg_clear_under_internal_border (f
);
972 /* Must resize our top level widget. Font size may have changed,
973 but not rows/cols. */
974 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
975 pixelwidth
, pixelheight
);
976 x_wm_set_size_hint (f
, 0, 0);
978 SET_FRAME_GARBAGED (f
);
979 cancel_mouse_face (f
);
981 /* We can not call change_frame_size for a mapped frame,
982 we can not set pixel width/height either. The window manager may
983 override our resize request, XMonad does this all the time.
984 The best we can do is try to sync, so lisp code sees the updated
985 size as fast as possible.
986 For unmapped windows, we can set rows/cols. When
987 the frame is mapped again we will (hopefully) get the correct size. */
988 if (FRAME_VISIBLE_P (f
))
990 /* Must call this to flush out events */
991 (void)gtk_events_pending ();
993 x_wait_for_event (f
, ConfigureNotify
);
997 change_frame_size (f
, rows
, cols
, 0, 1, 0);
998 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
999 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
1003 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
1004 The policy is to keep the number of editable lines. */
1007 xg_height_or_width_changed (struct frame
*f
)
1009 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1010 FRAME_TOTAL_PIXEL_WIDTH (f
),
1011 FRAME_TOTAL_PIXEL_HEIGHT (f
));
1012 f
->output_data
.x
->hint_flags
= 0;
1013 x_wm_set_size_hint (f
, 0, 0);
1016 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
1017 Must be done like this, because GtkWidget:s can have "hidden"
1018 X Window that aren't accessible.
1020 Return 0 if no widget match WDESC. */
1023 xg_win_to_widget (Display
*dpy
, Window wdesc
)
1026 GtkWidget
*gwdesc
= 0;
1030 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
1035 event
.any
.window
= gdkwin
;
1036 event
.any
.type
= GDK_NOTHING
;
1037 gwdesc
= gtk_get_event_widget (&event
);
1044 /* Set the background of widget W to PIXEL. */
1047 xg_set_widget_bg (struct frame
*f
, GtkWidget
*w
, long unsigned int pixel
)
1053 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
1055 bg
.red
= (double)xbg
.red
/65535.0;
1056 bg
.green
= (double)xbg
.green
/65535.0;
1057 bg
.blue
= (double)xbg
.blue
/65535.0;
1059 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
1063 GdkColormap
*map
= gtk_widget_get_colormap (w
);
1064 gdk_colormap_query_color (map
, pixel
, &bg
);
1065 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
1069 /* Callback called when the gtk theme changes.
1070 We notify lisp code so it can fix faces used for region for example. */
1073 style_changed_cb (GObject
*go
,
1077 struct input_event event
;
1078 GdkDisplay
*gdpy
= user_data
;
1079 const char *display_name
= gdk_display_get_name (gdpy
);
1080 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1083 event
.kind
= CONFIG_CHANGED_EVENT
;
1084 event
.frame_or_window
= build_string (display_name
);
1085 /* Theme doesn't change often, so intern is called seldom. */
1086 event
.arg
= intern ("theme-name");
1087 kbd_buffer_store_event (&event
);
1089 update_theme_scrollbar_width ();
1091 /* If scroll bar width changed, we need set the new size on all frames
1095 Lisp_Object rest
, frame
;
1096 FOR_EACH_FRAME (rest
, frame
)
1098 struct frame
*f
= XFRAME (frame
);
1099 if (FRAME_LIVE_P (f
)
1101 && FRAME_X_DISPLAY (f
) == dpy
)
1103 x_set_scroll_bar_default_width (f
);
1104 xg_frame_set_char_size (f
, FRAME_COLS (f
), FRAME_LINES (f
));
1110 /* Called when a delete-event occurs on WIDGET. */
1113 delete_cb (GtkWidget
*widget
,
1118 /* The event doesn't arrive in the normal event loop. Send event
1120 struct frame
*f
= user_data
;
1121 struct input_event ie
;
1124 ie
.kind
= DELETE_WINDOW_EVENT
;
1125 XSETFRAME (ie
.frame_or_window
, f
);
1126 kbd_buffer_store_event (&ie
);
1132 /* Create and set up the GTK widgets for frame F.
1133 Return true if creation succeeded. */
1136 xg_create_frame_widgets (struct frame
*f
)
1139 GtkWidget
*wvbox
, *whbox
;
1148 if (FRAME_X_EMBEDDED_P (f
))
1150 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1151 wtop
= gtk_plug_new_for_display (gdpy
, f
->output_data
.x
->parent_desc
);
1154 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1156 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1157 has backported it to Gtk+ 2.0 and they add the resize grip for
1158 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1159 forever, so disable the grip. */
1160 #if (! GTK_CHECK_VERSION (3, 0, 0) \
1161 && defined HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1162 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop
), FALSE
);
1165 xg_set_screen (wtop
, f
);
1167 wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1168 whbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1169 gtk_box_set_homogeneous (GTK_BOX (wvbox
), FALSE
);
1170 gtk_box_set_homogeneous (GTK_BOX (whbox
), FALSE
);
1173 wfixed
= emacs_fixed_new (f
);
1175 wfixed
= gtk_fixed_new ();
1178 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1180 if (wtop
) gtk_widget_destroy (wtop
);
1181 if (wvbox
) gtk_widget_destroy (wvbox
);
1182 if (whbox
) gtk_widget_destroy (whbox
);
1183 if (wfixed
) gtk_widget_destroy (wfixed
);
1189 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1190 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1191 gtk_widget_set_name (wvbox
, "pane");
1192 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1194 /* If this frame has a title or name, set it in the title bar. */
1195 if (! NILP (f
->title
))
1196 title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1197 else if (! NILP (f
->name
))
1198 title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1200 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1202 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1203 FRAME_GTK_WIDGET (f
) = wfixed
;
1204 f
->output_data
.x
->vbox_widget
= wvbox
;
1205 f
->output_data
.x
->hbox_widget
= whbox
;
1207 gtk_widget_set_has_window (wfixed
, TRUE
);
1209 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1210 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1211 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1213 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1214 update_frame_tool_bar (f
);
1216 /* We don't want this widget double buffered, because we draw on it
1217 with regular X drawing primitives, so from a GTK/GDK point of
1218 view, the widget is totally blank. When an expose comes, this
1219 will make the widget blank, and then Emacs redraws it. This flickers
1220 a lot, so we turn off double buffering. */
1221 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1223 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1224 SSDATA (Vx_resource_name
),
1225 SSDATA (Vx_resource_class
));
1227 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1228 GTK is to destroy the widget. We want Emacs to do that instead. */
1229 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1230 G_CALLBACK (delete_cb
), f
);
1232 /* Convert our geometry parameters into a geometry string
1234 GTK will itself handle calculating the real position this way. */
1235 xg_set_geometry (f
);
1237 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1239 gtk_widget_add_events (wfixed
,
1240 GDK_POINTER_MOTION_MASK
1242 | GDK_BUTTON_PRESS_MASK
1243 | GDK_BUTTON_RELEASE_MASK
1244 | GDK_KEY_PRESS_MASK
1245 | GDK_ENTER_NOTIFY_MASK
1246 | GDK_LEAVE_NOTIFY_MASK
1247 | GDK_FOCUS_CHANGE_MASK
1248 | GDK_STRUCTURE_MASK
1249 | GDK_VISIBILITY_NOTIFY_MASK
);
1251 /* Must realize the windows so the X window gets created. It is used
1252 by callers of this function. */
1253 gtk_widget_realize (wfixed
);
1254 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1256 /* Since GTK clears its window by filling with the background color,
1257 we must keep X and GTK background in sync. */
1258 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1261 /* Also, do not let any background pixmap to be set, this looks very
1262 bad as Emacs overwrites the background pixmap with its own idea
1263 of background color. */
1264 style
= gtk_widget_get_modifier_style (wfixed
);
1266 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1267 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1268 gtk_widget_modify_style (wfixed
, style
);
1270 gtk_widget_set_can_focus (wfixed
, TRUE
);
1271 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1274 #ifdef USE_GTK_TOOLTIP
1275 /* Steal a tool tip window we can move ourselves. */
1276 f
->output_data
.x
->ttip_widget
= 0;
1277 f
->output_data
.x
->ttip_lbl
= 0;
1278 f
->output_data
.x
->ttip_window
= 0;
1279 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1280 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1284 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1285 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1286 /* Only connect this signal once per screen. */
1287 if (! g_signal_handler_find (G_OBJECT (gs
),
1288 G_SIGNAL_MATCH_FUNC
,
1290 G_CALLBACK (style_changed_cb
),
1293 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1294 G_CALLBACK (style_changed_cb
),
1295 gdk_screen_get_display (screen
));
1305 xg_free_frame_widgets (struct frame
*f
)
1307 if (FRAME_GTK_OUTER_WIDGET (f
))
1309 #ifdef USE_GTK_TOOLTIP
1310 struct x_output
*x
= f
->output_data
.x
;
1312 struct xg_frame_tb_info
*tbinfo
1313 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
1318 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1319 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1320 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1321 #ifdef USE_GTK_TOOLTIP
1323 gtk_widget_destroy (x
->ttip_lbl
);
1325 g_object_unref (G_OBJECT (x
->ttip_widget
));
1330 /* Set the normal size hints for the window manager, for frame F.
1331 FLAGS is the flags word to use--or 0 meaning preserve the flags
1332 that the window now has.
1333 If USER_POSITION, set the User Position
1334 flag (this is useful when FLAGS is 0). */
1337 x_wm_set_size_hint (struct frame
*f
, long int flags
, bool user_position
)
1339 /* Must use GTK routines here, otherwise GTK resets the size hints
1340 to its own defaults. */
1341 GdkGeometry size_hints
;
1342 gint hint_flags
= 0;
1343 int base_width
, base_height
;
1344 int min_rows
= 0, min_cols
= 0;
1345 int win_gravity
= f
->win_gravity
;
1346 Lisp_Object fs_state
, frame
;
1348 /* Don't set size hints during initialization; that apparently leads
1349 to a race condition. See the thread at
1350 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1351 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1354 XSETFRAME (frame
, f
);
1355 fs_state
= Fframe_parameter (frame
, Qfullscreen
);
1356 if (EQ (fs_state
, Qmaximized
) || EQ (fs_state
, Qfullboth
))
1358 /* Don't set hints when maximized or fullscreen. Apparently KWin and
1359 Gtk3 don't get along and the frame shrinks (!).
1366 memset (&size_hints
, 0, sizeof (size_hints
));
1367 f
->output_data
.x
->size_hints
= size_hints
;
1368 f
->output_data
.x
->hint_flags
= hint_flags
;
1371 flags
= f
->size_hint_flags
;
1373 size_hints
= f
->output_data
.x
->size_hints
;
1374 hint_flags
= f
->output_data
.x
->hint_flags
;
1376 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1377 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
1378 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
1380 hint_flags
|= GDK_HINT_BASE_SIZE
;
1381 /* Use one row/col here so base_height/width does not become zero.
1382 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1383 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 1) + FRAME_TOOLBAR_WIDTH (f
);
1384 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 1)
1385 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1387 check_frame_size (f
, &min_rows
, &min_cols
);
1388 if (min_cols
> 0) --min_cols
; /* We used one col in base_width = ... 1); */
1389 if (min_rows
> 0) --min_rows
; /* We used one row in base_height = ... 1); */
1391 size_hints
.base_width
= base_width
;
1392 size_hints
.base_height
= base_height
;
1393 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
1394 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
1396 /* These currently have a one to one mapping with the X values, but I
1397 don't think we should rely on that. */
1398 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1399 size_hints
.win_gravity
= 0;
1400 if (win_gravity
== NorthWestGravity
)
1401 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1402 else if (win_gravity
== NorthGravity
)
1403 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1404 else if (win_gravity
== NorthEastGravity
)
1405 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1406 else if (win_gravity
== WestGravity
)
1407 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1408 else if (win_gravity
== CenterGravity
)
1409 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1410 else if (win_gravity
== EastGravity
)
1411 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1412 else if (win_gravity
== SouthWestGravity
)
1413 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1414 else if (win_gravity
== SouthGravity
)
1415 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1416 else if (win_gravity
== SouthEastGravity
)
1417 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1418 else if (win_gravity
== StaticGravity
)
1419 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1423 hint_flags
&= ~GDK_HINT_POS
;
1424 hint_flags
|= GDK_HINT_USER_POS
;
1427 if (hint_flags
!= f
->output_data
.x
->hint_flags
1428 || memcmp (&size_hints
,
1429 &f
->output_data
.x
->size_hints
,
1430 sizeof (size_hints
)) != 0)
1433 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1434 NULL
, &size_hints
, hint_flags
);
1435 f
->output_data
.x
->size_hints
= size_hints
;
1436 f
->output_data
.x
->hint_flags
= hint_flags
;
1441 /* Change background color of a frame.
1442 Since GTK uses the background color to clear the window, we must
1443 keep the GTK and X colors in sync.
1444 F is the frame to change,
1445 BG is the pixel value to change to. */
1448 xg_set_background_color (struct frame
*f
, long unsigned int bg
)
1450 if (FRAME_GTK_WIDGET (f
))
1453 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1459 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1460 functions so GTK does not overwrite the icon. */
1463 xg_set_frame_icon (struct frame
*f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1465 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1469 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1474 /***********************************************************************
1476 ***********************************************************************/
1477 /* Return the dialog title to use for a dialog of type KEY.
1478 This is the encoding used by lwlib. We use the same for GTK. */
1481 get_dialog_title (char key
)
1483 const char *title
= "";
1491 title
= "Information";
1510 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1511 the dialog, but return TRUE so the event does not propagate further
1512 in GTK. This prevents GTK from destroying the dialog widget automatically
1513 and we can always destroy the widget manually, regardless of how
1514 it was popped down (button press or WM_DELETE_WINDOW).
1515 W is the dialog widget.
1516 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1517 user_data is NULL (not used).
1519 Returns TRUE to end propagation of event. */
1522 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1524 gtk_widget_unmap (w
);
1528 /* Create a popup dialog window. See also xg_create_widget below.
1529 WV is a widget_value describing the dialog.
1530 SELECT_CB is the callback to use when a button has been pressed.
1531 DEACTIVATE_CB is the callback to use when the dialog pops down.
1533 Returns the GTK dialog widget. */
1536 create_dialog (widget_value
*wv
,
1537 GCallback select_cb
,
1538 GCallback deactivate_cb
)
1540 const char *title
= get_dialog_title (wv
->name
[0]);
1541 int total_buttons
= wv
->name
[1] - '0';
1542 int right_buttons
= wv
->name
[4] - '0';
1545 int button_spacing
= 10;
1546 GtkWidget
*wdialog
= gtk_dialog_new ();
1547 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1548 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1550 GtkWidget
*whbox_down
;
1552 /* If the number of buttons is greater than 4, make two rows of buttons
1553 instead. This looks better. */
1554 bool make_two_rows
= total_buttons
> 4;
1556 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1557 left_buttons
= total_buttons
- right_buttons
;
1559 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1560 gtk_widget_set_name (wdialog
, "emacs-dialog");
1565 GtkWidget
*wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, button_spacing
);
1566 GtkWidget
*whbox_up
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1567 gtk_box_set_homogeneous (GTK_BOX (wvbox
), TRUE
);
1568 gtk_box_set_homogeneous (GTK_BOX (whbox_up
), FALSE
);
1569 whbox_down
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1570 gtk_box_set_homogeneous (GTK_BOX (whbox_down
), FALSE
);
1572 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1573 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1574 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1576 cur_box
= GTK_BOX (whbox_up
);
1579 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1580 G_CALLBACK (dialog_delete_callback
), 0);
1584 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1585 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1588 for (item
= wv
->contents
; item
; item
= item
->next
)
1590 char *utf8_label
= get_utf8_string (item
->value
);
1594 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1596 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1597 /* This is the text part of the dialog. */
1598 w
= gtk_label_new (utf8_label
);
1599 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1600 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1601 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1603 /* Try to make dialog look better. Must realize first so
1604 the widget can calculate the size it needs. */
1605 gtk_widget_realize (w
);
1606 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1607 gtk_box_set_spacing (wvbox
, req
.height
);
1608 if (item
->value
&& strlen (item
->value
) > 0)
1609 button_spacing
= 2*req
.width
/strlen (item
->value
);
1613 /* This is one button to add to the dialog. */
1614 w
= gtk_button_new_with_label (utf8_label
);
1615 if (! item
->enabled
)
1616 gtk_widget_set_sensitive (w
, FALSE
);
1618 g_signal_connect (G_OBJECT (w
), "clicked",
1619 select_cb
, item
->call_data
);
1621 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1622 if (++button_nr
== left_buttons
)
1625 cur_box
= GTK_BOX (whbox_down
);
1627 gtk_box_pack_start (cur_box
,
1635 g_free (utf8_label
);
1641 struct xg_dialog_data
1649 /* Function that is called when the file or font dialogs pop down.
1650 W is the dialog widget, RESPONSE is the response code.
1651 USER_DATA is what we passed in to g_signal_connect. */
1654 xg_dialog_response_cb (GtkDialog
*w
,
1658 struct xg_dialog_data
*dd
= user_data
;
1659 dd
->response
= response
;
1660 g_main_loop_quit (dd
->loop
);
1664 /* Destroy the dialog. This makes it pop down. */
1667 pop_down_dialog (void *arg
)
1669 struct xg_dialog_data
*dd
= arg
;
1672 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1673 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1675 g_main_loop_quit (dd
->loop
);
1676 g_main_loop_unref (dd
->loop
);
1681 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1682 We pass in DATA as gpointer* so we can use this as a callback. */
1685 xg_maybe_add_timer (gpointer data
)
1687 struct xg_dialog_data
*dd
= data
;
1688 EMACS_TIME next_time
= timer_check ();
1692 if (EMACS_TIME_VALID_P (next_time
))
1694 time_t s
= EMACS_SECS (next_time
);
1695 int per_ms
= EMACS_TIME_RESOLUTION
/ 1000;
1696 int ms
= (EMACS_NSECS (next_time
) + per_ms
- 1) / per_ms
;
1697 if (s
<= ((guint
) -1 - ms
) / 1000)
1698 dd
->timerid
= g_timeout_add (s
* 1000 + ms
, xg_maybe_add_timer
, dd
);
1704 /* Pops up a modal dialog W and waits for response.
1705 We don't use gtk_dialog_run because we want to process emacs timers.
1706 The dialog W is not destroyed when this function returns. */
1709 xg_dialog_run (struct frame
*f
, GtkWidget
*w
)
1711 ptrdiff_t count
= SPECPDL_INDEX ();
1712 struct xg_dialog_data dd
;
1714 xg_set_screen (w
, f
);
1715 gtk_window_set_transient_for (GTK_WINDOW (w
),
1716 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1717 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1718 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1720 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1721 dd
.response
= GTK_RESPONSE_CANCEL
;
1725 g_signal_connect (G_OBJECT (w
),
1727 G_CALLBACK (xg_dialog_response_cb
),
1729 /* Don't destroy the widget if closed by the window manager close button. */
1730 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1731 gtk_widget_show (w
);
1733 record_unwind_protect_ptr (pop_down_dialog
, &dd
);
1735 (void) xg_maybe_add_timer (&dd
);
1736 g_main_loop_run (dd
.loop
);
1739 unbind_to (count
, Qnil
);
1745 /***********************************************************************
1746 File dialog functions
1747 ***********************************************************************/
1748 /* Return true if the old file selection dialog is being used. */
1751 xg_uses_old_file_dialog (void)
1753 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1754 return x_gtk_use_old_file_dialog
;
1761 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1763 /* Return the selected file for file chooser dialog W.
1764 The returned string must be free:d. */
1767 xg_get_file_name_from_chooser (GtkWidget
*w
)
1769 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1772 /* Callback called when the "Show hidden files" toggle is pressed.
1773 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1776 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1778 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1780 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1781 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1785 /* Callback called when a property changes in a file chooser.
1786 GOBJECT is the file chooser dialog, ARG1 describes the property.
1787 USER_DATA is the toggle widget in the file chooser dialog.
1788 We use this to update the "Show hidden files" toggle when the user
1789 changes that property by right clicking in the file list. */
1792 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1794 if (strcmp (arg1
->name
, "show-hidden") == 0)
1796 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1797 gboolean visible
, toggle_on
;
1799 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1800 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1802 if (!!visible
!= !!toggle_on
)
1804 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1805 G_CALLBACK (xg_toggle_visibility_cb
),
1807 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1808 g_signal_handlers_unblock_by_func
1809 (G_OBJECT (wtoggle
),
1810 G_CALLBACK (xg_toggle_visibility_cb
),
1813 x_gtk_show_hidden_files
= visible
;
1817 /* Read a file name from the user using a file chooser dialog.
1818 F is the current frame.
1819 PROMPT is a prompt to show to the user. May not be NULL.
1820 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1821 If MUSTMATCH_P, the returned file name must be an existing
1822 file. (Actually, this only has cosmetic effects, the user can
1823 still enter a non-existing file.) *FUNC is set to a function that
1824 can be used to retrieve the selected file name from the returned widget.
1826 Returns the created widget. */
1829 xg_get_file_with_chooser (struct frame
*f
,
1831 char *default_filename
,
1832 bool mustmatch_p
, bool only_dir_p
,
1833 xg_get_file_func
*func
)
1837 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1838 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1839 GtkFileChooserAction action
= (mustmatch_p
?
1840 GTK_FILE_CHOOSER_ACTION_OPEN
:
1841 GTK_FILE_CHOOSER_ACTION_SAVE
);
1844 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1846 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1847 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1848 (mustmatch_p
|| only_dir_p
?
1849 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1852 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1854 wbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1855 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
1856 gtk_widget_show (wbox
);
1857 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1859 if (x_gtk_show_hidden_files
)
1861 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1862 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1864 gtk_widget_show (wtoggle
);
1865 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1866 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1867 g_signal_connect (G_OBJECT (filewin
), "notify",
1868 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1870 if (x_gtk_file_dialog_help_text
)
1873 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1874 Show the C-l help text only for versions < 2.10. */
1875 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1876 strcat (msgbuf
, "\nType C-l to display a file name text entry box.\n");
1877 strcat (msgbuf
, "\nIf you don't like this file selector, use the "
1878 "corresponding\nkey binding or customize "
1879 "use-file-dialog to turn it off.");
1881 wmessage
= gtk_label_new (msgbuf
);
1882 gtk_widget_show (wmessage
);
1885 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1886 if (x_gtk_file_dialog_help_text
)
1887 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1888 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1890 if (default_filename
)
1893 struct gcpro gcpro1
;
1894 char *utf8_filename
;
1897 file
= build_string (default_filename
);
1899 /* File chooser does not understand ~/... in the file name. It must be
1900 an absolute name starting with /. */
1901 if (default_filename
[0] != '/')
1902 file
= Fexpand_file_name (file
, Qnil
);
1904 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1905 if (! NILP (Ffile_directory_p (file
)))
1906 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1910 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1912 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1914 char *cp
= strrchr (utf8_filename
, '/');
1916 else cp
= utf8_filename
;
1917 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1924 *func
= xg_get_file_name_from_chooser
;
1928 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1930 /* Return the selected file for file selector dialog W.
1931 The returned string must be free:d. */
1934 xg_get_file_name_from_selector (GtkWidget
*w
)
1936 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1937 return xstrdup (gtk_file_selection_get_filename (filesel
));
1940 /* Create a file selection dialog.
1941 F is the current frame.
1942 PROMPT is a prompt to show to the user. May not be NULL.
1943 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1944 If MUSTMATCH_P, the returned file name must be an existing
1945 file. *FUNC is set to a function that can be used to retrieve the
1946 selected file name from the returned widget.
1948 Returns the created widget. */
1951 xg_get_file_with_selection (struct frame
*f
,
1953 char *default_filename
,
1954 bool mustmatch_p
, bool only_dir_p
,
1955 xg_get_file_func
*func
)
1958 GtkFileSelection
*filesel
;
1960 filewin
= gtk_file_selection_new (prompt
);
1961 filesel
= GTK_FILE_SELECTION (filewin
);
1963 if (default_filename
)
1964 gtk_file_selection_set_filename (filesel
, default_filename
);
1968 /* The selection_entry part of filesel is not documented. */
1969 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1970 gtk_file_selection_hide_fileop_buttons (filesel
);
1973 *func
= xg_get_file_name_from_selector
;
1977 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1979 /* Read a file name from the user using a file dialog, either the old
1980 file selection dialog, or the new file chooser dialog. Which to use
1981 depends on what the GTK version used has, and what the value of
1982 gtk-use-old-file-dialog.
1983 F is the current frame.
1984 PROMPT is a prompt to show to the user. May not be NULL.
1985 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1986 If MUSTMATCH_P, the returned file name must be an existing
1989 Returns a file name or NULL if no file was selected.
1990 The returned string must be freed by the caller. */
1993 xg_get_file_name (struct frame
*f
,
1995 char *default_filename
,
2001 int filesel_done
= 0;
2002 xg_get_file_func func
;
2004 #ifdef HAVE_GTK_FILE_SELECTION_NEW
2006 if (xg_uses_old_file_dialog ())
2007 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
2008 mustmatch_p
, only_dir_p
, &func
);
2010 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
2011 mustmatch_p
, only_dir_p
, &func
);
2013 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
2014 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
2015 mustmatch_p
, only_dir_p
, &func
);
2016 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
2018 gtk_widget_set_name (w
, "emacs-filedialog");
2020 filesel_done
= xg_dialog_run (f
, w
);
2021 if (filesel_done
== GTK_RESPONSE_OK
)
2024 gtk_widget_destroy (w
);
2028 /***********************************************************************
2030 ***********************************************************************/
2032 #ifdef HAVE_FREETYPE
2034 #if USE_NEW_GTK_FONT_CHOOSER
2036 #define XG_WEIGHT_TO_SYMBOL(w) \
2037 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
2038 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
2039 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
2040 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
2041 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
2042 : w <= PANGO_WEIGHT_BOLD ? Qbold \
2043 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
2046 #define XG_STYLE_TO_SYMBOL(s) \
2047 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
2048 : s == PANGO_STYLE_ITALIC ? Qitalic \
2051 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2054 static char *x_last_font_name
;
2056 /* Pop up a GTK font selector and return the name of the font the user
2057 selects, as a C string. The returned font name follows GTK's own
2060 `FAMILY [VALUE1 VALUE2] SIZE'
2062 This can be parsed using font_parse_fcname in font.c.
2063 DEFAULT_NAME, if non-zero, is the default font name. */
2066 xg_get_font (struct frame
*f
, const char *default_name
)
2070 Lisp_Object font
= Qnil
;
2072 w
= gtk_font_chooser_dialog_new
2073 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2077 /* Convert fontconfig names to Gtk names, i.e. remove - before
2079 char *p
= strrchr (default_name
, '-');
2083 while (c_isdigit (*ep
))
2085 if (*ep
== '\0') *p
= ' ';
2088 else if (x_last_font_name
)
2089 default_name
= x_last_font_name
;
2092 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w
), default_name
);
2094 gtk_widget_set_name (w
, "emacs-fontdialog");
2095 done
= xg_dialog_run (f
, w
);
2096 if (done
== GTK_RESPONSE_OK
)
2098 #if USE_NEW_GTK_FONT_CHOOSER
2099 /* Use the GTK3 font chooser. */
2100 PangoFontDescription
*desc
2101 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w
));
2105 Lisp_Object args
[10];
2106 const char *name
= pango_font_description_get_family (desc
);
2107 gint size
= pango_font_description_get_size (desc
);
2108 PangoWeight weight
= pango_font_description_get_weight (desc
);
2109 PangoStyle style
= pango_font_description_get_style (desc
);
2112 args
[1] = build_string (name
);
2115 args
[3] = make_float (pango_units_to_double (size
));
2118 args
[5] = XG_WEIGHT_TO_SYMBOL (weight
);
2121 args
[7] = XG_STYLE_TO_SYMBOL (style
);
2126 font
= Ffont_spec (8, args
);
2128 pango_font_description_free (desc
);
2129 xfree (x_last_font_name
);
2130 x_last_font_name
= xstrdup (name
);
2133 #else /* Use old font selector, which just returns the font name. */
2136 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w
));
2140 font
= build_string (font_name
);
2141 g_free (x_last_font_name
);
2142 x_last_font_name
= font_name
;
2144 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2147 gtk_widget_destroy (w
);
2150 #endif /* HAVE_FREETYPE */
2154 /***********************************************************************
2156 ***********************************************************************/
2158 /* The name of menu items that can be used for customization. Since GTK
2159 RC files are very crude and primitive, we have to set this on all
2160 menu item names so a user can easily customize menu items. */
2162 #define MENU_ITEM_NAME "emacs-menuitem"
2165 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2166 during GC. The next member points to the items. */
2167 static xg_list_node xg_menu_cb_list
;
2169 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2170 during GC. The next member points to the items. */
2171 static xg_list_node xg_menu_item_cb_list
;
2173 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2174 F is the frame CL_DATA will be initialized for.
2175 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2177 The menu bar and all sub menus under the menu bar in a frame
2178 share the same structure, hence the reference count.
2180 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2181 allocated xg_menu_cb_data if CL_DATA is NULL. */
2183 static xg_menu_cb_data
*
2184 make_cl_data (xg_menu_cb_data
*cl_data
, struct frame
*f
, GCallback highlight_cb
)
2188 cl_data
= xmalloc (sizeof *cl_data
);
2190 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2191 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2192 cl_data
->highlight_cb
= highlight_cb
;
2193 cl_data
->ref_count
= 0;
2195 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2198 cl_data
->ref_count
++;
2203 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2204 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2206 When the menu bar is updated, menu items may have been added and/or
2207 removed, so menu_bar_vector and menu_bar_items_used change. We must
2208 then update CL_DATA since it is used to determine which menu
2209 item that is invoked in the menu.
2210 HIGHLIGHT_CB could change, there is no check that the same
2211 function is given when modifying a menu bar as was given when
2212 creating the menu bar. */
2215 update_cl_data (xg_menu_cb_data
*cl_data
,
2217 GCallback highlight_cb
)
2222 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2223 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2224 cl_data
->highlight_cb
= highlight_cb
;
2228 /* Decrease reference count for CL_DATA.
2229 If reference count is zero, free CL_DATA. */
2232 unref_cl_data (xg_menu_cb_data
*cl_data
)
2234 if (cl_data
&& cl_data
->ref_count
> 0)
2236 cl_data
->ref_count
--;
2237 if (cl_data
->ref_count
== 0)
2239 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2245 /* Function that marks all lisp data during GC. */
2251 Lisp_Object rest
, frame
;
2253 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2254 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2256 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2258 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2260 if (! NILP (cb_data
->help
))
2261 mark_object (cb_data
->help
);
2264 FOR_EACH_FRAME (rest
, frame
)
2266 struct frame
*f
= XFRAME (frame
);
2268 if (FRAME_X_P (f
) && FRAME_GTK_OUTER_WIDGET (f
))
2270 struct xg_frame_tb_info
*tbinfo
2271 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
2275 mark_object (tbinfo
->last_tool_bar
);
2276 mark_object (tbinfo
->style
);
2283 /* Callback called when a menu item is destroyed. Used to free data.
2284 W is the widget that is being destroyed (not used).
2285 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2288 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2292 xg_menu_item_cb_data
*data
= client_data
;
2293 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2298 /* Callback called when the pointer enters/leaves a menu item.
2299 W is the parent of the menu item.
2300 EVENT is either an enter event or leave event.
2301 CLIENT_DATA is not used.
2303 Returns FALSE to tell GTK to keep processing this event. */
2306 menuitem_highlight_callback (GtkWidget
*w
,
2307 GdkEventCrossing
*event
,
2308 gpointer client_data
)
2311 GtkWidget
*subwidget
;
2312 xg_menu_item_cb_data
*data
;
2314 ev
.crossing
= *event
;
2315 subwidget
= gtk_get_event_widget (&ev
);
2316 data
= g_object_get_data (G_OBJECT (subwidget
), XG_ITEM_DATA
);
2319 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2321 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2322 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2323 (*func
) (subwidget
, call_data
);
2330 /* Callback called when a menu is destroyed. Used to free data.
2331 W is the widget that is being destroyed (not used).
2332 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2335 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2337 unref_cl_data (client_data
);
2340 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2341 must be non-NULL) and can be inserted into a menu item.
2343 Returns the GtkHBox. */
2346 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2352 wbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
2353 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
2354 wlbl
= gtk_label_new (utf8_label
);
2355 wkey
= gtk_label_new (utf8_key
);
2357 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2358 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2360 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2361 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2363 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2364 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2365 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2370 /* Make and return a menu item widget with the key to the right.
2371 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2372 UTF8_KEY is the text representing the key binding.
2373 ITEM is the widget_value describing the menu item.
2375 GROUP is an in/out parameter. If the menu item to be created is not
2376 part of any radio menu group, *GROUP contains NULL on entry and exit.
2377 If the menu item to be created is part of a radio menu group, on entry
2378 *GROUP contains the group to use, or NULL if this is the first item
2379 in the group. On exit, *GROUP contains the radio item group.
2381 Unfortunately, keys don't line up as nicely as in Motif,
2382 but the MacOS X version doesn't either, so I guess that is OK. */
2385 make_menu_item (const char *utf8_label
,
2386 const char *utf8_key
,
2391 GtkWidget
*wtoadd
= 0;
2393 /* It has been observed that some menu items have a NULL name field.
2394 This will lead to this function being called with a NULL utf8_label.
2395 GTK crashes on that so we set a blank label. Why there is a NULL
2396 name remains to be investigated. */
2397 if (! utf8_label
) utf8_label
= " ";
2400 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2402 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2405 if (utf8_key
) w
= gtk_check_menu_item_new ();
2406 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2407 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2409 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2411 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2412 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2413 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2415 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2420 if (utf8_key
) w
= gtk_menu_item_new ();
2421 else w
= gtk_menu_item_new_with_label (utf8_label
);
2424 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2425 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2430 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2432 static int xg_detached_menus
;
2434 /* Return true if there are detached menus. */
2437 xg_have_tear_offs (void)
2439 return xg_detached_menus
> 0;
2442 /* Callback invoked when a detached menu window is removed. Here we
2443 decrease the xg_detached_menus count.
2444 WIDGET is the top level window that is removed (the parent of the menu).
2445 CLIENT_DATA is not used. */
2448 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2450 if (xg_detached_menus
> 0) --xg_detached_menus
;
2453 /* Callback invoked when a menu is detached. It increases the
2454 xg_detached_menus count.
2455 WIDGET is the GtkTearoffMenuItem.
2456 CLIENT_DATA is not used. */
2459 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2461 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2462 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2464 ++xg_detached_menus
;
2465 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2467 G_CALLBACK (tearoff_remove
), 0);
2470 #else /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2472 xg_have_tear_offs (void)
2476 #endif /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2478 /* Create a menu item widget, and connect the callbacks.
2479 ITEM describes the menu item.
2480 F is the frame the created menu belongs to.
2481 SELECT_CB is the callback to use when a menu item is selected.
2482 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2483 CL_DATA points to the callback data to be used for this menu.
2484 GROUP is an in/out parameter. If the menu item to be created is not
2485 part of any radio menu group, *GROUP contains NULL on entry and exit.
2486 If the menu item to be created is part of a radio menu group, on entry
2487 *GROUP contains the group to use, or NULL if this is the first item
2488 in the group. On exit, *GROUP contains the radio item group.
2490 Returns the created GtkWidget. */
2493 xg_create_one_menuitem (widget_value
*item
,
2495 GCallback select_cb
,
2496 GCallback highlight_cb
,
2497 xg_menu_cb_data
*cl_data
,
2503 xg_menu_item_cb_data
*cb_data
;
2505 utf8_label
= get_utf8_string (item
->name
);
2506 utf8_key
= get_utf8_string (item
->key
);
2508 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2510 if (utf8_label
) g_free (utf8_label
);
2511 if (utf8_key
) g_free (utf8_key
);
2513 cb_data
= xmalloc (sizeof *cb_data
);
2515 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2517 cb_data
->select_id
= 0;
2518 cb_data
->help
= item
->help
;
2519 cb_data
->cl_data
= cl_data
;
2520 cb_data
->call_data
= item
->call_data
;
2522 g_signal_connect (G_OBJECT (w
),
2524 G_CALLBACK (menuitem_destroy_callback
),
2527 /* Put cb_data in widget, so we can get at it when modifying menubar */
2528 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2530 /* final item, not a submenu */
2531 if (item
->call_data
&& ! item
->contents
)
2535 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2541 /* Create a full menu tree specified by DATA.
2542 F is the frame the created menu belongs to.
2543 SELECT_CB is the callback to use when a menu item is selected.
2544 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2545 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2546 If POP_UP_P, create a popup menu.
2547 If MENU_BAR_P, create a menu bar.
2548 If ADD_TEAROFF_P, add a tearoff menu item. Ignored if MENU_BAR_P or
2549 the Gtk+ version used does not have tearoffs.
2550 TOPMENU is the topmost GtkWidget that others shall be placed under.
2551 It may be NULL, in that case we create the appropriate widget
2552 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2553 CL_DATA is the callback data we shall use for this menu, or NULL
2554 if we haven't set the first callback yet.
2555 NAME is the name to give to the top level menu if this function
2556 creates it. May be NULL to not set any name.
2558 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2561 This function calls itself to create submenus. */
2564 create_menus (widget_value
*data
,
2566 GCallback select_cb
,
2567 GCallback deactivate_cb
,
2568 GCallback highlight_cb
,
2573 xg_menu_cb_data
*cl_data
,
2577 GtkWidget
*wmenu
= topmenu
;
2578 GSList
*group
= NULL
;
2584 wmenu
= gtk_menu_new ();
2585 xg_set_screen (wmenu
, f
);
2586 /* Connect this to the menu instead of items so we get enter/leave for
2587 disabled items also. TODO: Still does not get enter/leave for
2588 disabled items in detached menus. */
2589 g_signal_connect (G_OBJECT (wmenu
),
2590 "enter-notify-event",
2591 G_CALLBACK (menuitem_highlight_callback
),
2593 g_signal_connect (G_OBJECT (wmenu
),
2594 "leave-notify-event",
2595 G_CALLBACK (menuitem_highlight_callback
),
2600 wmenu
= gtk_menu_bar_new ();
2601 /* Set width of menu bar to a small value so it doesn't enlarge
2602 a small initial frame size. The width will be set to the
2603 width of the frame later on when it is added to a container.
2604 height -1: Natural height. */
2605 gtk_widget_set_size_request (wmenu
, 1, -1);
2608 /* Put cl_data on the top menu for easier access. */
2609 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2610 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2611 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2612 G_CALLBACK (menu_destroy_callback
), cl_data
);
2615 gtk_widget_set_name (wmenu
, name
);
2618 g_signal_connect (G_OBJECT (wmenu
),
2619 "selection-done", deactivate_cb
, 0);
2622 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2623 if (! menu_bar_p
&& add_tearoff_p
)
2625 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2626 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2628 g_signal_connect (G_OBJECT (tearoff
), "activate",
2629 G_CALLBACK (tearoff_activate
), 0);
2633 for (item
= data
; item
; item
= item
->next
)
2637 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2638 && !menu_separator_name_p (item
->name
))
2641 /* A title for a popup. We do the same as GTK does when
2642 creating titles, but it does not look good. */
2644 utf8_label
= get_utf8_string (item
->name
);
2646 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2647 w
= gtk_menu_item_new_with_label (utf8_label
);
2648 gtk_widget_set_sensitive (w
, FALSE
);
2649 if (utf8_label
) g_free (utf8_label
);
2651 else if (menu_separator_name_p (item
->name
))
2654 /* GTK only have one separator type. */
2655 w
= gtk_separator_menu_item_new ();
2659 w
= xg_create_one_menuitem (item
,
2661 item
->contents
? 0 : select_cb
,
2666 /* Create a possibly empty submenu for menu bar items, since some
2667 themes don't highlight items correctly without it. */
2668 if (item
->contents
|| menu_bar_p
)
2670 GtkWidget
*submenu
= create_menus (item
->contents
,
2681 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2685 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2686 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2692 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2693 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2694 with some text and buttons.
2695 F is the frame the created item belongs to.
2696 NAME is the name to use for the top widget.
2697 VAL is a widget_value structure describing items to be created.
2698 SELECT_CB is the callback to use when a menu item is selected or
2699 a dialog button is pressed.
2700 DEACTIVATE_CB is the callback to use when an item is deactivated.
2701 For a menu, when a sub menu is not shown anymore, for a dialog it is
2702 called when the dialog is popped down.
2703 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2705 Returns the widget created. */
2708 xg_create_widget (const char *type
, const char *name
, struct frame
*f
,
2709 widget_value
*val
, GCallback select_cb
,
2710 GCallback deactivate_cb
, GCallback highlight_cb
)
2713 bool menu_bar_p
= strcmp (type
, "menubar") == 0;
2714 bool pop_up_p
= strcmp (type
, "popup") == 0;
2716 if (strcmp (type
, "dialog") == 0)
2718 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2719 xg_set_screen (w
, f
);
2720 gtk_window_set_transient_for (GTK_WINDOW (w
),
2721 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2722 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2723 gtk_widget_set_name (w
, "emacs-dialog");
2724 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2726 else if (menu_bar_p
|| pop_up_p
)
2728 w
= create_menus (val
->contents
,
2740 /* Set the cursor to an arrow for popup menus when they are mapped.
2741 This is done by default for menu bar menus. */
2744 /* Must realize so the GdkWindow inside the widget is created. */
2745 gtk_widget_realize (w
);
2746 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2751 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2758 /* Return the label for menu item WITEM. */
2761 xg_get_menu_item_label (GtkMenuItem
*witem
)
2763 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2764 return gtk_label_get_label (wlabel
);
2767 /* Return true if the menu item WITEM has the text LABEL. */
2770 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2773 char *utf8_label
= get_utf8_string (label
);
2774 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2776 if (! old_label
&& ! utf8_label
)
2778 else if (old_label
&& utf8_label
)
2779 is_same
= strcmp (utf8_label
, old_label
) == 0;
2781 if (utf8_label
) g_free (utf8_label
);
2786 /* Destroy widgets in LIST. */
2789 xg_destroy_widgets (GList
*list
)
2793 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2795 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2797 /* Destroying the widget will remove it from the container it is in. */
2798 gtk_widget_destroy (w
);
2802 /* Update the top level names in MENUBAR (i.e. not submenus).
2803 F is the frame the menu bar belongs to.
2804 *LIST is a list with the current menu bar names (menu item widgets).
2805 ITER is the item within *LIST that shall be updated.
2806 POS is the numerical position, starting at 0, of ITER in *LIST.
2807 VAL describes what the menu bar shall look like after the update.
2808 SELECT_CB is the callback to use when a menu item is selected.
2809 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2810 CL_DATA points to the callback data to be used for this menu bar.
2812 This function calls itself to walk through the menu bar names. */
2815 xg_update_menubar (GtkWidget
*menubar
,
2821 GCallback select_cb
,
2822 GCallback deactivate_cb
,
2823 GCallback highlight_cb
,
2824 xg_menu_cb_data
*cl_data
)
2826 if (! iter
&& ! val
)
2828 else if (iter
&& ! val
)
2830 /* Item(s) have been removed. Remove all remaining items. */
2831 xg_destroy_widgets (iter
);
2833 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2834 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2835 gtk_menu_item_new_with_label (""),
2841 else if (! iter
&& val
)
2843 /* Item(s) added. Add all new items in one call. */
2844 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2845 0, 1, 0, menubar
, cl_data
, 0);
2851 /* Below this neither iter or val is NULL */
2852 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2854 /* This item is still the same, check next item. */
2856 iter
= g_list_next (iter
);
2859 else /* This item is changed. */
2861 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2862 GtkMenuItem
*witem2
= 0;
2863 bool val_in_menubar
= 0;
2864 bool iter_in_new_menubar
= 0;
2868 /* See if the changed entry (val) is present later in the menu bar */
2870 iter2
&& ! val_in_menubar
;
2871 iter2
= g_list_next (iter2
))
2873 witem2
= GTK_MENU_ITEM (iter2
->data
);
2874 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2877 /* See if the current entry (iter) is present later in the
2878 specification for the new menu bar. */
2879 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2880 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2882 if (val_in_menubar
&& ! iter_in_new_menubar
)
2886 /* This corresponds to:
2891 g_object_ref (G_OBJECT (witem
));
2892 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2893 gtk_widget_destroy (GTK_WIDGET (witem
));
2895 /* Must get new list since the old changed. */
2896 g_list_free (*list
);
2897 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2898 while (nr
-- > 0) iter
= g_list_next (iter
);
2900 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2902 /* This corresponds to:
2905 Rename B to X. This might seem to be a strange thing to do,
2906 since if there is a menu under B it will be totally wrong for X.
2907 But consider editing a C file. Then there is a C-mode menu
2908 (corresponds to B above).
2909 If then doing C-x C-f the minibuf menu (X above) replaces the
2910 C-mode menu. When returning from the minibuffer, we get
2911 back the C-mode menu. Thus we do:
2912 Rename B to X (C-mode to minibuf menu)
2913 Rename X to B (minibuf to C-mode menu).
2914 If the X menu hasn't been invoked, the menu under B
2915 is up to date when leaving the minibuffer. */
2916 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2917 char *utf8_label
= get_utf8_string (val
->name
);
2918 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2920 gtk_label_set_text (wlabel
, utf8_label
);
2922 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2923 /* If this item has a submenu that has been detached, change
2924 the title in the WM decorations also. */
2925 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2926 /* Set the title of the detached window. */
2927 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2930 if (utf8_label
) g_free (utf8_label
);
2931 iter
= g_list_next (iter
);
2935 else if (! val_in_menubar
&& iter_in_new_menubar
)
2937 /* This corresponds to:
2944 GtkWidget
*w
= xg_create_one_menuitem (val
,
2951 /* Create a possibly empty submenu for menu bar items, since some
2952 themes don't highlight items correctly without it. */
2953 GtkWidget
*submenu
= create_menus (NULL
, f
,
2954 select_cb
, deactivate_cb
,
2956 0, 0, 0, 0, cl_data
, 0);
2957 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2958 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2959 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2961 g_list_free (*list
);
2962 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2963 while (nr
-- > 0) iter
= g_list_next (iter
);
2964 iter
= g_list_next (iter
);
2968 else /* if (val_in_menubar && iter_in_new_menubar) */
2971 /* This corresponds to:
2976 g_object_ref (G_OBJECT (witem2
));
2977 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2978 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2979 GTK_WIDGET (witem2
), pos
);
2980 g_object_unref (G_OBJECT (witem2
));
2982 g_list_free (*list
);
2983 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2984 while (nr
-- > 0) iter
= g_list_next (iter
);
2985 if (iter
) iter
= g_list_next (iter
);
2991 /* Update the rest of the menu bar. */
2992 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2993 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2996 /* Update the menu item W so it corresponds to VAL.
2997 SELECT_CB is the callback to use when a menu item is selected.
2998 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2999 CL_DATA is the data to set in the widget for menu invocation. */
3002 xg_update_menu_item (widget_value
*val
,
3004 GCallback select_cb
,
3005 GCallback highlight_cb
,
3006 xg_menu_cb_data
*cl_data
)
3013 const char *old_label
= 0;
3014 const char *old_key
= 0;
3015 xg_menu_item_cb_data
*cb_data
;
3017 wchild
= XG_BIN_CHILD (w
);
3018 utf8_label
= get_utf8_string (val
->name
);
3019 utf8_key
= get_utf8_string (val
->key
);
3021 /* See if W is a menu item with a key. See make_menu_item above. */
3022 if (GTK_IS_BOX (wchild
))
3024 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
3026 wlbl
= GTK_LABEL (list
->data
);
3027 wkey
= GTK_LABEL (list
->next
->data
);
3032 /* Remove the key and keep just the label. */
3033 g_object_ref (G_OBJECT (wlbl
));
3034 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3035 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
3036 g_object_unref (G_OBJECT (wlbl
));
3041 else /* Just a label. */
3043 wlbl
= GTK_LABEL (wchild
);
3045 /* Check if there is now a key. */
3048 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
3049 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
3051 wlbl
= GTK_LABEL (list
->data
);
3052 wkey
= GTK_LABEL (list
->next
->data
);
3055 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3056 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
3061 if (wkey
) old_key
= gtk_label_get_label (wkey
);
3062 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
3064 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
3065 gtk_label_set_text (wkey
, utf8_key
);
3067 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
3068 gtk_label_set_text (wlbl
, utf8_label
);
3070 if (utf8_key
) g_free (utf8_key
);
3071 if (utf8_label
) g_free (utf8_label
);
3073 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
3074 gtk_widget_set_sensitive (w
, FALSE
);
3075 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
3076 gtk_widget_set_sensitive (w
, TRUE
);
3078 cb_data
= g_object_get_data (G_OBJECT (w
), XG_ITEM_DATA
);
3081 cb_data
->call_data
= val
->call_data
;
3082 cb_data
->help
= val
->help
;
3083 cb_data
->cl_data
= cl_data
;
3085 /* We assume the callback functions don't change. */
3086 if (val
->call_data
&& ! val
->contents
)
3088 /* This item shall have a select callback. */
3089 if (! cb_data
->select_id
)
3091 = g_signal_connect (G_OBJECT (w
), "activate",
3092 select_cb
, cb_data
);
3094 else if (cb_data
->select_id
)
3096 g_signal_handler_disconnect (w
, cb_data
->select_id
);
3097 cb_data
->select_id
= 0;
3102 /* Update the toggle menu item W so it corresponds to VAL. */
3105 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
3107 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3110 /* Update the radio menu item W so it corresponds to VAL. */
3113 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
3115 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3118 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3119 SUBMENU may be NULL, in that case a new menu is created.
3120 F is the frame the menu bar belongs to.
3121 VAL describes the contents of the menu bar.
3122 SELECT_CB is the callback to use when a menu item is selected.
3123 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3124 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3125 CL_DATA is the call back data to use for any newly created items.
3127 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3131 xg_update_submenu (GtkWidget
*submenu
,
3134 GCallback select_cb
,
3135 GCallback deactivate_cb
,
3136 GCallback highlight_cb
,
3137 xg_menu_cb_data
*cl_data
)
3139 GtkWidget
*newsub
= submenu
;
3143 bool has_tearoff_p
= 0;
3144 GList
*first_radio
= 0;
3147 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3149 for (cur
= val
, iter
= list
;
3151 iter
= g_list_next (iter
), cur
= cur
->next
)
3153 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3155 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
3156 /* Skip tearoff items, they have no counterpart in val. */
3157 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
3160 iter
= g_list_next (iter
);
3161 if (iter
) w
= GTK_WIDGET (iter
->data
);
3166 /* Remember first radio button in a group. If we get a mismatch in
3167 a radio group we must rebuild the whole group so that the connections
3168 in GTK becomes correct. */
3169 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3171 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3172 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3175 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3177 if (! menu_separator_name_p (cur
->name
))
3180 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3182 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3184 xg_update_toggle_item (cur
, w
);
3185 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3187 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3189 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3191 xg_update_radio_item (cur
, w
);
3192 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3194 else if (GTK_IS_MENU_ITEM (w
))
3196 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3199 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3200 menu_separator_name_p (cur
->name
))
3203 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3205 sub
= gtk_menu_item_get_submenu (witem
);
3206 if (sub
&& ! cur
->contents
)
3208 /* Not a submenu anymore. */
3209 g_object_ref (G_OBJECT (sub
));
3210 remove_submenu (witem
);
3211 gtk_widget_destroy (sub
);
3213 else if (cur
->contents
)
3217 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3218 select_cb
, deactivate_cb
,
3219 highlight_cb
, cl_data
);
3221 /* If this item just became a submenu, we must set it. */
3223 gtk_menu_item_set_submenu (witem
, nsub
);
3228 /* Structural difference. Remove everything from here and down
3234 /* Remove widgets from first structural change. */
3237 /* If we are adding new menu items below, we must remove from
3238 first radio button so that radio groups become correct. */
3239 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3240 else xg_destroy_widgets (iter
);
3245 /* More items added. Create them. */
3246 newsub
= create_menus (cur
,
3259 if (list
) g_list_free (list
);
3264 /* Update the MENUBAR.
3265 F is the frame the menu bar belongs to.
3266 VAL describes the contents of the menu bar.
3267 If DEEP_P, rebuild all but the top level menu names in
3268 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3269 SELECT_CB is the callback to use when a menu item is selected.
3270 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3271 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3274 xg_modify_menubar_widgets (GtkWidget
*menubar
, struct frame
*f
,
3275 widget_value
*val
, bool deep_p
,
3276 GCallback select_cb
, GCallback deactivate_cb
,
3277 GCallback highlight_cb
)
3279 xg_menu_cb_data
*cl_data
;
3280 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3284 cl_data
= g_object_get_data (G_OBJECT (menubar
), XG_FRAME_DATA
);
3286 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3287 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3293 /* Update all sub menus.
3294 We must keep the submenus (GTK menu item widgets) since the
3295 X Window in the XEvent that activates the menu are those widgets. */
3297 /* Update cl_data, menu_item things in F may have changed. */
3298 update_cl_data (cl_data
, f
, highlight_cb
);
3300 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3305 GtkMenuItem
*witem
= 0;
3307 /* Find sub menu that corresponds to val and update it. */
3308 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3310 witem
= GTK_MENU_ITEM (iter
->data
);
3311 if (xg_item_label_same_p (witem
, cur
->name
))
3313 sub
= gtk_menu_item_get_submenu (witem
);
3318 newsub
= xg_update_submenu (sub
,
3325 /* sub may still be NULL. If we just updated non deep and added
3326 a new menu bar item, it has no sub menu yet. So we set the
3327 newly created sub menu under witem. */
3328 if (newsub
!= sub
&& witem
!= 0)
3330 xg_set_screen (newsub
, f
);
3331 gtk_menu_item_set_submenu (witem
, newsub
);
3337 gtk_widget_show_all (menubar
);
3340 /* Callback called when the menu bar W is mapped.
3341 Used to find the height of the menu bar if we didn't get it
3342 after showing the widget. */
3345 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3348 struct frame
*f
= user_data
;
3349 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3350 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3352 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3353 xg_height_or_width_changed (f
);
3357 /* Recompute all the widgets of frame F, when the menu bar has been
3361 xg_update_frame_menubar (struct frame
*f
)
3363 struct x_output
*x
= f
->output_data
.x
;
3366 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3369 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3370 return; /* Already done this, happens for frames created invisible. */
3374 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3376 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3378 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3379 gtk_widget_show_all (x
->menubar_widget
);
3380 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3382 /* If menu bar doesn't know its height yet, cheat a little so the frame
3383 doesn't jump so much when resized later in menubar_map_cb. */
3384 if (req
.height
== 0)
3387 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3389 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3390 xg_height_or_width_changed (f
);
3395 /* Get rid of the menu bar of frame F, and free its storage.
3396 This is used when deleting a frame, and when turning off the menu bar. */
3399 free_frame_menubar (struct frame
*f
)
3401 struct x_output
*x
= f
->output_data
.x
;
3403 if (x
->menubar_widget
)
3407 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3408 /* The menubar and its children shall be deleted when removed from
3410 x
->menubar_widget
= 0;
3411 FRAME_MENUBAR_HEIGHT (f
) = 0;
3412 xg_height_or_width_changed (f
);
3418 xg_event_is_for_menubar (struct frame
*f
, XEvent
*event
)
3420 struct x_output
*x
= f
->output_data
.x
;
3429 if (! x
->menubar_widget
) return 0;
3431 if (! (event
->xbutton
.x
>= 0
3432 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3433 && event
->xbutton
.y
>= 0
3434 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
3435 && event
->xbutton
.same_screen
))
3438 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3439 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3441 gevent
.any
.window
= gw
;
3442 gevent
.any
.type
= GDK_NOTHING
;
3443 gwdesc
= gtk_get_event_widget (&gevent
);
3444 if (! gwdesc
) return 0;
3445 if (! GTK_IS_MENU_BAR (gwdesc
)
3446 && ! GTK_IS_MENU_ITEM (gwdesc
)
3447 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3450 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3451 if (! list
) return 0;
3452 rec
.x
= event
->xbutton
.x
;
3453 rec
.y
= event
->xbutton
.y
;
3457 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3459 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3460 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3469 /***********************************************************************
3470 Scroll bar functions
3471 ***********************************************************************/
3474 /* Setting scroll bar values invokes the callback. Use this variable
3475 to indicate that callback should do nothing. */
3477 bool xg_ignore_gtk_scrollbar
;
3479 /* The width of the scroll bar for the current theme. */
3481 static int scroll_bar_width_for_theme
;
3483 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3484 may be larger than 32 bits. Keep a mapping from integer index to widget
3485 pointers to get around the 32 bit limitation. */
3489 GtkWidget
**widgets
;
3494 /* Grow this much every time we need to allocate more */
3496 #define ID_TO_WIDGET_INCR 32
3498 /* Store the widget pointer W in id_to_widget and return the integer index. */
3501 xg_store_widget_in_map (GtkWidget
*w
)
3505 if (id_to_widget
.max_size
== id_to_widget
.used
)
3508 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3509 memory_full (SIZE_MAX
);
3511 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3512 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3513 new_size
, sizeof (GtkWidget
*));
3515 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3516 id_to_widget
.widgets
[i
] = 0;
3517 id_to_widget
.max_size
= new_size
;
3520 /* Just loop over the array and find a free place. After all,
3521 how many scroll bars are we creating? Should be a small number.
3522 The check above guarantees we will find a free place. */
3523 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3525 if (! id_to_widget
.widgets
[i
])
3527 id_to_widget
.widgets
[i
] = w
;
3528 ++id_to_widget
.used
;
3534 /* Should never end up here */
3538 /* Remove pointer at IDX from id_to_widget.
3539 Called when scroll bar is destroyed. */
3542 xg_remove_widget_from_map (ptrdiff_t idx
)
3544 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3546 id_to_widget
.widgets
[idx
] = 0;
3547 --id_to_widget
.used
;
3551 /* Get the widget pointer at IDX from id_to_widget. */
3554 xg_get_widget_from_map (ptrdiff_t idx
)
3556 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3557 return id_to_widget
.widgets
[idx
];
3563 update_theme_scrollbar_width (void)
3566 GtkAdjustment
*vadj
;
3573 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3574 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3575 g_object_ref_sink (G_OBJECT (wscroll
));
3576 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3577 gtk_widget_destroy (wscroll
);
3578 g_object_unref (G_OBJECT (wscroll
));
3581 scroll_bar_width_for_theme
= w
;
3585 xg_get_default_scrollbar_width (void)
3587 return scroll_bar_width_for_theme
;
3590 /* Return the scrollbar id for X Window WID on display DPY.
3591 Return -1 if WID not in id_to_widget. */
3594 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3599 w
= xg_win_to_widget (dpy
, wid
);
3603 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3604 if (id_to_widget
.widgets
[idx
] == w
)
3611 /* Callback invoked when scroll bar WIDGET is destroyed.
3612 DATA is the index into id_to_widget for WIDGET.
3613 We free pointer to last scroll bar values here and remove the index. */
3616 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3618 intptr_t id
= (intptr_t) data
;
3619 xg_remove_widget_from_map (id
);
3622 /* Create a scroll bar widget for frame F. Store the scroll bar
3624 SCROLL_CALLBACK is the callback to invoke when the value of the
3626 END_CALLBACK is the callback to invoke when scrolling ends.
3627 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3628 to set resources for the widget. */
3631 xg_create_scroll_bar (struct frame
*f
,
3632 struct scroll_bar
*bar
,
3633 GCallback scroll_callback
,
3634 GCallback end_callback
,
3635 const char *scroll_bar_name
)
3641 GtkAdjustment
*vadj
;
3646 /* Page, step increment values are not so important here, they
3647 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3648 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3651 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3652 webox
= gtk_event_box_new ();
3653 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3655 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3657 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3659 scroll_id
= xg_store_widget_in_map (wscroll
);
3661 g_signal_connect (G_OBJECT (wscroll
),
3663 G_CALLBACK (xg_gtk_scroll_destroy
),
3664 (gpointer
) scroll_id
);
3665 g_signal_connect (G_OBJECT (wscroll
),
3669 g_signal_connect (G_OBJECT (wscroll
),
3670 "button-release-event",
3674 /* The scroll bar widget does not draw on a window of its own. Instead
3675 it draws on the parent window, in this case the edit widget. So
3676 whenever the edit widget is cleared, the scroll bar needs to redraw
3677 also, which causes flicker. Put an event box between the edit widget
3678 and the scroll bar, so the scroll bar instead draws itself on the
3679 event box window. */
3680 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3681 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3684 /* Set the cursor to an arrow. */
3685 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3687 bar
->x_window
= scroll_id
;
3690 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3693 xg_remove_scroll_bar (struct frame
*f
, ptrdiff_t scrollbar_id
)
3695 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3698 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3699 gtk_widget_destroy (w
);
3700 gtk_widget_destroy (wparent
);
3701 SET_FRAME_GARBAGED (f
);
3705 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3707 TOP/LEFT are the new pixel positions where the bar shall appear.
3708 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3711 xg_update_scrollbar_pos (struct frame
*f
,
3712 ptrdiff_t scrollbar_id
,
3719 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3723 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3724 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3727 /* Clear out old position. */
3728 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3729 if (gtk_widget_get_parent (wparent
) == wfixed
)
3731 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3732 "x", &oldx
, "y", &oldy
, NULL
);
3733 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3736 /* Move and resize to new values. */
3737 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3738 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3741 /* No room. Hide scroll bar as some themes output a warning if
3742 the height is less than the min size. */
3743 gtk_widget_hide (wparent
);
3744 gtk_widget_hide (wscroll
);
3748 gtk_widget_show_all (wparent
);
3749 gtk_widget_set_size_request (wscroll
, width
, height
);
3751 gtk_widget_queue_draw (wfixed
);
3752 gdk_window_process_all_updates ();
3753 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3755 /* Clear under old scroll bar position. This must be done after
3756 the gtk_widget_queue_draw and gdk_window_process_all_updates
3758 x_clear_area (FRAME_X_DISPLAY (f
),
3760 oldx
, oldy
, oldw
, oldh
, 0);
3763 /* GTK does not redraw until the main loop is entered again, but
3764 if there are no X events pending we will not enter it. So we sync
3765 here to get some events. */
3768 SET_FRAME_GARBAGED (f
);
3769 cancel_mouse_face (f
);
3773 /* Get the current value of the range, truncated to an integer. */
3776 int_gtk_range_get_value (GtkRange
*range
)
3778 return gtk_range_get_value (range
);
3782 /* Set the thumb size and position of scroll bar BAR. We are currently
3783 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3786 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3791 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3793 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3795 if (wscroll
&& NILP (bar
->dragging
))
3805 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3807 if (scroll_bar_adjust_thumb_portion_p
)
3809 /* We do the same as for MOTIF in xterm.c, use 30 chars per
3810 line rather than the real portion value. This makes the
3811 thumb less likely to resize and that looks better. */
3812 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3814 /* When the thumb is at the bottom, position == whole.
3815 So we need to increase `whole' to make space for the thumb. */
3823 top
= (gdouble
) position
/ whole
;
3824 shown
= (gdouble
) portion
/ whole
;
3827 size
= clip_to_bounds (1, shown
* XG_SB_RANGE
, XG_SB_RANGE
);
3828 value
= clip_to_bounds (XG_SB_MIN
, top
* XG_SB_RANGE
, XG_SB_MAX
- size
);
3830 /* Assume all lines are of equal size. */
3831 new_step
= size
/ max (1, FRAME_LINES (f
));
3833 old_size
= gtk_adjustment_get_page_size (adj
);
3834 if (old_size
!= size
)
3836 int old_step
= gtk_adjustment_get_step_increment (adj
);
3837 if (old_step
!= new_step
)
3839 gtk_adjustment_set_page_size (adj
, size
);
3840 gtk_adjustment_set_step_increment (adj
, new_step
);
3841 /* Assume a page increment is about 95% of the page size */
3842 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3847 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3851 /* gtk_range_set_value invokes the callback. Set
3852 ignore_gtk_scrollbar to make the callback do nothing */
3853 xg_ignore_gtk_scrollbar
= 1;
3855 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3856 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3858 gtk_adjustment_changed (adj
);
3860 xg_ignore_gtk_scrollbar
= 0;
3867 /* Return true if EVENT is for a scroll bar in frame F.
3868 When the same X window is used for several Gtk+ widgets, we cannot
3869 say for sure based on the X window alone if an event is for the
3870 frame. This function does additional checks. */
3873 xg_event_is_for_scrollbar (struct frame
*f
, XEvent
*event
)
3877 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3879 /* Check if press occurred outside the edit widget. */
3880 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3883 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
3884 (gdk_display_get_device_manager (gdpy
));
3885 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
3887 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
3889 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3892 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3893 || event
->type
== MotionNotify
))
3895 /* If we are releasing or moving the scroll bar, it has the grab. */
3896 GtkWidget
*w
= gtk_grab_get_current ();
3897 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3905 /***********************************************************************
3907 ***********************************************************************/
3908 /* The key for the data we put in the GtkImage widgets. The data is
3909 the image used by Emacs. We use this to see if we need to update
3910 the GtkImage with a new image. */
3911 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3913 /* The key for storing the latest modifiers so the activate callback can
3915 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3917 /* The key for storing the button widget in its proxy menu item. */
3918 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3920 /* The key for the data we put in the GtkImage widgets. The data is
3921 the stock name used by Emacs. We use this to see if we need to update
3922 the GtkImage with a new image. */
3923 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3925 /* As above, but this is used for named theme widgets, as opposed to
3927 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3929 /* Callback function invoked when a tool bar item is pressed.
3930 W is the button widget in the tool bar that got pressed,
3931 CLIENT_DATA is an integer that is the index of the button in the
3932 tool bar. 0 is the first button. */
3935 xg_tool_bar_button_cb (GtkWidget
*widget
,
3936 GdkEventButton
*event
,
3939 intptr_t state
= event
->state
;
3940 gpointer ptr
= (gpointer
) state
;
3941 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3946 /* Callback function invoked when a tool bar item is pressed.
3947 W is the button widget in the tool bar that got pressed,
3948 CLIENT_DATA is an integer that is the index of the button in the
3949 tool bar. 0 is the first button. */
3952 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3954 intptr_t idx
= (intptr_t) client_data
;
3955 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
3956 intptr_t mod
= (intptr_t) gmod
;
3958 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3959 Lisp_Object key
, frame
;
3960 struct input_event event
;
3963 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3966 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3968 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3969 XSETFRAME (frame
, f
);
3971 /* We generate two events here. The first one is to set the prefix
3972 to `(tool_bar)', see keyboard.c. */
3973 event
.kind
= TOOL_BAR_EVENT
;
3974 event
.frame_or_window
= frame
;
3976 kbd_buffer_store_event (&event
);
3978 event
.kind
= TOOL_BAR_EVENT
;
3979 event
.frame_or_window
= frame
;
3981 /* Convert between the modifier bits GDK uses and the modifier bits
3982 Emacs uses. This assumes GDK and X masks are the same, which they are when
3984 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3985 kbd_buffer_store_event (&event
);
3987 /* Return focus to the frame after we have clicked on a detached
3989 Fx_focus_frame (frame
);
3992 /* Callback function invoked when a tool bar item is pressed in a detached
3993 tool bar or the overflow drop down menu.
3994 We just call xg_tool_bar_callback.
3995 W is the menu item widget that got pressed,
3996 CLIENT_DATA is an integer that is the index of the button in the
3997 tool bar. 0 is the first button. */
4000 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
4002 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
4003 XG_TOOL_BAR_PROXY_BUTTON
));
4004 xg_tool_bar_callback (wbutton
, client_data
);
4009 xg_tool_bar_help_callback (GtkWidget
*w
,
4010 GdkEventCrossing
*event
,
4011 gpointer client_data
);
4013 /* This callback is called when a help is to be shown for an item in
4014 the detached tool bar when the detached tool bar it is not expanded. */
4017 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
4018 GdkEventCrossing
*event
,
4019 gpointer client_data
)
4021 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
4022 XG_TOOL_BAR_PROXY_BUTTON
));
4024 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
4028 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
4030 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
4031 GtkWidget
*c1
= clist
->data
;
4032 GtkWidget
*c2
= clist
->next
? clist
->next
->data
: NULL
;
4034 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
4035 g_list_free (clist
);
4036 return GTK_IS_LABEL (c1
) ? c1
: c2
;
4040 /* This callback is called when a tool item should create a proxy item,
4041 such as for the overflow menu. Also called when the tool bar is detached.
4042 If we don't create a proxy menu item, the detached tool bar will be
4046 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
4048 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
4049 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4051 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
4052 GtkImage
*wimage
= GTK_IMAGE (c1
);
4053 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
4054 (wlbl
? gtk_label_get_text (wlbl
) : "");
4055 GtkWidget
*wmenuimage
;
4058 if (gtk_button_get_use_stock (wbutton
))
4059 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
4060 GTK_ICON_SIZE_MENU
);
4063 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
4064 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
4066 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
4068 if (store_type
== GTK_IMAGE_STOCK
)
4071 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
4072 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
4074 else if (store_type
== GTK_IMAGE_ICON_SET
)
4076 GtkIconSet
*icon_set
;
4077 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
4078 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
4079 GTK_ICON_SIZE_MENU
);
4081 else if (store_type
== GTK_IMAGE_PIXBUF
)
4086 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
4089 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
4091 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
4092 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
4093 GDK_INTERP_BILINEAR
);
4095 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
4099 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
4103 else if (store_type
== GTK_IMAGE_ICON_NAME
)
4105 const gchar
*icon_name
;
4106 GtkIconSize icon_size
;
4108 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
4109 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
4110 GTK_ICON_SIZE_MENU
);
4114 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
4119 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
4121 g_signal_connect (G_OBJECT (wmenuitem
),
4123 G_CALLBACK (xg_tool_bar_proxy_callback
),
4127 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
4128 (gpointer
) wbutton
);
4129 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
4130 gtk_widget_set_sensitive (wmenuitem
,
4131 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
4133 /* Use enter/leave notify to show help. We use the events
4134 rather than the GtkButton specific signals "enter" and
4135 "leave", so we can have only one callback. The event
4136 will tell us what kind of event it is. */
4137 g_signal_connect (G_OBJECT (wmenuitem
),
4138 "enter-notify-event",
4139 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4141 g_signal_connect (G_OBJECT (wmenuitem
),
4142 "leave-notify-event",
4143 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4149 /* This callback is called when a tool bar is detached. We must set
4150 the height of the tool bar to zero when this happens so frame sizes
4151 are correctly calculated.
4152 WBOX is the handle box widget that enables detach/attach of the tool bar.
4153 W is the tool bar widget.
4154 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4157 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
4159 gpointer client_data
)
4161 struct frame
*f
= client_data
;
4163 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
4168 GtkRequisition req
, req2
;
4170 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4171 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4172 req
.width
-= req2
.width
;
4173 req
.height
-= req2
.height
;
4174 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4175 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4176 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4177 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4178 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4179 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4180 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4181 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4182 xg_height_or_width_changed (f
);
4186 /* This callback is called when a tool bar is reattached. We must set
4187 the height of the tool bar when this happens so frame sizes
4188 are correctly calculated.
4189 WBOX is the handle box widget that enables detach/attach of the tool bar.
4190 W is the tool bar widget.
4191 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4194 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
4196 gpointer client_data
)
4198 struct frame
*f
= client_data
;
4199 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
4203 GtkRequisition req
, req2
;
4205 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4206 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4207 req
.width
+= req2
.width
;
4208 req
.height
+= req2
.height
;
4209 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4210 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4211 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4212 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4213 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4214 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4215 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4216 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4217 xg_height_or_width_changed (f
);
4221 /* This callback is called when the mouse enters or leaves a tool bar item.
4222 It is used for displaying and hiding the help text.
4223 W is the tool bar item, a button.
4224 EVENT is either an enter event or leave event.
4225 CLIENT_DATA is an integer that is the index of the button in the
4226 tool bar. 0 is the first button.
4228 Returns FALSE to tell GTK to keep processing this event. */
4231 xg_tool_bar_help_callback (GtkWidget
*w
,
4232 GdkEventCrossing
*event
,
4233 gpointer client_data
)
4235 intptr_t idx
= (intptr_t) client_data
;
4236 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4237 Lisp_Object help
, frame
;
4239 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4242 if (event
->type
== GDK_ENTER_NOTIFY
)
4244 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4245 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4248 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4253 XSETFRAME (frame
, f
);
4254 kbd_buffer_store_help_event (frame
, help
);
4260 /* This callback is called when a tool bar item shall be redrawn.
4261 It modifies the expose event so that the GtkImage widget redraws the
4262 whole image. This to overcome a bug that makes GtkImage draw the image
4263 in the wrong place when it tries to redraw just a part of the image.
4264 W is the GtkImage to be redrawn.
4265 EVENT is the expose event for W.
4266 CLIENT_DATA is unused.
4268 Returns FALSE to tell GTK to keep processing this event. */
4272 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4273 GdkEventExpose
*event
,
4274 gpointer client_data
)
4278 gdk_drawable_get_size (event
->window
, &width
, &height
);
4279 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4280 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4282 event
->area
.x
= max (0, event
->area
.x
);
4283 event
->area
.y
= max (0, event
->area
.y
);
4285 event
->area
.width
= max (width
, event
->area
.width
);
4286 event
->area
.height
= max (height
, event
->area
.height
);
4292 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4293 #define toolbar_set_orientation(w, o) \
4294 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4296 #define toolbar_set_orientation(w, o) \
4297 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4300 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4301 #define TOOLBAR_TOP_WIDGET(x) ((x)->handlebox_widget)
4303 #define TOOLBAR_TOP_WIDGET(x) ((x)->toolbar_widget)
4306 /* Attach a tool bar to frame F. */
4309 xg_pack_tool_bar (struct frame
*f
, Lisp_Object pos
)
4311 struct x_output
*x
= f
->output_data
.x
;
4312 bool into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4313 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4315 toolbar_set_orientation (x
->toolbar_widget
,
4317 ? GTK_ORIENTATION_VERTICAL
4318 : GTK_ORIENTATION_HORIZONTAL
);
4319 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4320 if (!x
->handlebox_widget
)
4322 top_widget
= x
->handlebox_widget
= gtk_handle_box_new ();
4323 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
4324 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
4325 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
4326 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
4327 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
4334 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4335 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4338 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), top_widget
,
4341 if (EQ (pos
, Qleft
))
4342 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4345 x
->toolbar_in_hbox
= true;
4349 bool vbox_pos
= x
->menubar_widget
!= 0;
4350 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4351 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4354 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), top_widget
,
4358 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4361 x
->toolbar_in_hbox
= false;
4363 x
->toolbar_is_packed
= true;
4366 static bool xg_update_tool_bar_sizes (struct frame
*f
);
4369 tb_size_cb (GtkWidget
*widget
,
4370 GdkRectangle
*allocation
,
4373 /* When tool bar is created it has one preferred size. But when size is
4374 allocated between widgets, it may get another. So we must update
4375 size hints if tool bar size changes. Seen on Fedora 18 at least. */
4376 struct frame
*f
= user_data
;
4377 if (xg_update_tool_bar_sizes (f
))
4378 x_wm_set_size_hint (f
, 0, 0);
4381 /* Create a tool bar for frame F. */
4384 xg_create_tool_bar (struct frame
*f
)
4386 struct x_output
*x
= f
->output_data
.x
;
4387 #if GTK_CHECK_VERSION (3, 3, 6)
4388 GtkStyleContext
*gsty
;
4390 struct xg_frame_tb_info
*tbinfo
4391 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4395 tbinfo
= xmalloc (sizeof (*tbinfo
));
4396 tbinfo
->last_tool_bar
= Qnil
;
4397 tbinfo
->style
= Qnil
;
4398 tbinfo
->hmargin
= tbinfo
->vmargin
= 0;
4399 tbinfo
->dir
= GTK_TEXT_DIR_NONE
;
4400 tbinfo
->n_last_items
= 0;
4401 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4406 x
->toolbar_widget
= gtk_toolbar_new ();
4408 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4410 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4411 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4412 g_signal_connect (x
->toolbar_widget
, "size-allocate",
4413 G_CALLBACK (tb_size_cb
), f
);
4414 #if GTK_CHECK_VERSION (3, 3, 6)
4415 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4416 gtk_style_context_add_class (gsty
, "primary-toolbar");
4421 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4423 /* Find the right-to-left image named by RTL in the tool bar images for F.
4424 Returns IMAGE if RTL is not found. */
4427 find_rtl_image (struct frame
*f
, Lisp_Object image
, Lisp_Object rtl
)
4430 Lisp_Object file
, rtl_name
;
4431 struct gcpro gcpro1
, gcpro2
;
4432 GCPRO2 (file
, rtl_name
);
4434 rtl_name
= Ffile_name_nondirectory (rtl
);
4436 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4438 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4439 if (!NILP (file
= file_for_image (rtl_image
)))
4441 file
= call1 (intern ("file-name-sans-extension"),
4442 Ffile_name_nondirectory (file
));
4443 if (! NILP (Fequal (file
, rtl_name
)))
4454 static GtkToolItem
*
4455 xg_make_tool_item (struct frame
*f
,
4457 GtkWidget
**wbutton
,
4459 int i
, bool horiz
, bool text_image
)
4461 GtkToolItem
*ti
= gtk_tool_item_new ();
4462 GtkWidget
*vb
= gtk_box_new (horiz
4463 ? GTK_ORIENTATION_HORIZONTAL
4464 : GTK_ORIENTATION_VERTICAL
,
4466 GtkWidget
*wb
= gtk_button_new ();
4467 /* The eventbox is here so we can have tooltips on disabled items. */
4468 GtkWidget
*weventbox
= gtk_event_box_new ();
4469 #if GTK_CHECK_VERSION (3, 3, 6)
4470 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4471 GtkStyleContext
*gsty
;
4473 gtk_css_provider_load_from_data (css_prov
,
4475 " background-color: transparent;"
4479 gsty
= gtk_widget_get_style_context (weventbox
);
4480 gtk_style_context_add_provider (gsty
,
4481 GTK_STYLE_PROVIDER (css_prov
),
4482 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4483 g_object_unref (css_prov
);
4486 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4488 if (wimage
&& !text_image
)
4489 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4491 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4492 if (wimage
&& text_image
)
4493 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4495 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4496 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4497 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4498 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4499 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4501 if (wimage
|| label
)
4504 gpointer gi
= (gpointer
) ii
;
4506 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4507 G_CALLBACK (xg_tool_bar_menu_proxy
),
4510 g_signal_connect (G_OBJECT (wb
), "clicked",
4511 G_CALLBACK (xg_tool_bar_callback
),
4514 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4517 /* Catch expose events to overcome an annoying redraw bug, see
4518 comment for xg_tool_bar_item_expose_callback. */
4519 g_signal_connect (G_OBJECT (ti
),
4521 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4524 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4526 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4527 no distinction based on modifiers in the activate callback,
4528 so we have to do it ourselves. */
4529 g_signal_connect (wb
, "button-release-event",
4530 G_CALLBACK (xg_tool_bar_button_cb
),
4533 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4535 /* Use enter/leave notify to show help. We use the events
4536 rather than the GtkButton specific signals "enter" and
4537 "leave", so we can have only one callback. The event
4538 will tell us what kind of event it is. */
4539 g_signal_connect (G_OBJECT (weventbox
),
4540 "enter-notify-event",
4541 G_CALLBACK (xg_tool_bar_help_callback
),
4543 g_signal_connect (G_OBJECT (weventbox
),
4544 "leave-notify-event",
4545 G_CALLBACK (xg_tool_bar_help_callback
),
4549 if (wbutton
) *wbutton
= wb
;
4555 is_box_type (GtkWidget
*vb
, bool is_horizontal
)
4559 if (GTK_IS_BOX (vb
))
4561 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4562 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4563 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4567 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4573 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4574 const char *icon_name
, const struct image
*img
,
4575 const char *label
, bool horiz
)
4579 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4580 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4582 /* Check if the tool icon matches. */
4583 if (stock_name
&& wimage
)
4585 old
= g_object_get_data (G_OBJECT (wimage
),
4586 XG_TOOL_BAR_STOCK_NAME
);
4587 if (!old
|| strcmp (old
, stock_name
))
4590 else if (icon_name
&& wimage
)
4592 old
= g_object_get_data (G_OBJECT (wimage
),
4593 XG_TOOL_BAR_ICON_NAME
);
4594 if (!old
|| strcmp (old
, icon_name
))
4599 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4600 XG_TOOL_BAR_IMAGE_DATA
);
4601 Pixmap old_img
= (Pixmap
) gold_img
;
4602 if (old_img
!= img
->pixmap
)
4606 /* Check button configuration and label. */
4607 if (is_box_type (vb
, horiz
)
4608 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4611 /* Ensure label is correct. */
4613 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4618 xg_update_tool_bar_sizes (struct frame
*f
)
4620 struct x_output
*x
= f
->output_data
.x
;
4622 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4623 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4625 gtk_widget_get_preferred_size (GTK_WIDGET (top_widget
), NULL
, &req
);
4626 if (x
->toolbar_in_hbox
)
4629 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4631 "position", &pos
, NULL
);
4632 if (pos
== 0) nl
= req
.width
;
4633 else nr
= req
.width
;
4638 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4640 "position", &pos
, NULL
);
4641 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4642 else nb
= req
.height
;
4645 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4646 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4647 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4648 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4650 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4651 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4652 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4653 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4654 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4655 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4663 /* Update the tool bar for frame F. Add new buttons and remove old. */
4666 update_frame_tool_bar (struct frame
*f
)
4669 struct x_output
*x
= f
->output_data
.x
;
4670 int hmargin
= 0, vmargin
= 0;
4671 GtkToolbar
*wtoolbar
;
4673 GtkTextDirection dir
;
4675 bool text_image
, horiz
;
4676 struct xg_frame_tb_info
*tbinfo
;
4678 if (! FRAME_GTK_WIDGET (f
))
4683 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4685 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4686 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4688 else if (CONSP (Vtool_bar_button_margin
))
4690 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4691 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4693 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4694 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4697 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4698 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4699 i.e. zero. This means that margins less than
4700 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4701 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4702 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4704 if (! x
->toolbar_widget
)
4705 xg_create_tool_bar (f
);
4707 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4708 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4710 style
= Ftool_bar_get_system_style ();
4712 /* Are we up to date? */
4713 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4716 if (! NILP (tbinfo
->last_tool_bar
) && ! NILP (f
->tool_bar_items
)
4717 && tbinfo
->n_last_items
== f
->n_tool_bar_items
4718 && tbinfo
->hmargin
== hmargin
&& tbinfo
->vmargin
== vmargin
4719 && tbinfo
->dir
== dir
4720 && ! NILP (Fequal (tbinfo
->style
, style
))
4721 && ! NILP (Fequal (tbinfo
->last_tool_bar
, f
->tool_bar_items
)))
4727 tbinfo
->last_tool_bar
= f
->tool_bar_items
;
4728 tbinfo
->n_last_items
= f
->n_tool_bar_items
;
4729 tbinfo
->style
= style
;
4730 tbinfo
->hmargin
= hmargin
;
4731 tbinfo
->vmargin
= vmargin
;
4734 text_image
= EQ (style
, Qtext_image_horiz
);
4735 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4737 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4739 bool enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4740 bool selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4744 struct image
*img
= NULL
;
4746 Lisp_Object stock
= Qnil
;
4747 GtkStockItem stock_item
;
4748 char *stock_name
= NULL
;
4749 char *icon_name
= NULL
;
4751 GtkWidget
*wbutton
= NULL
;
4752 Lisp_Object specified_file
;
4753 bool vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4755 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4756 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4757 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4760 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4762 /* If this is a separator, use a gtk separator item. */
4763 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4765 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4768 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4770 ti
= gtk_separator_tool_item_new ();
4771 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4777 /* Otherwise, the tool-bar item is an ordinary button. */
4779 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4781 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4785 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4787 /* Ignore invalid image specifications. */
4788 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4789 if (!valid_image_p (image
))
4792 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4797 specified_file
= file_for_image (image
);
4798 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4799 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4801 if (STRINGP (stock
))
4803 stock_name
= SSDATA (stock
);
4804 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4806 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4807 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4809 icon_name
= stock_name
+ 2;
4813 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4816 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4818 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4819 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4827 if (stock_name
== NULL
&& icon_name
== NULL
)
4829 /* No stock image, or stock item not known. Try regular
4830 image. If image is a vector, choose it according to the
4832 if (dir
== GTK_TEXT_DIR_RTL
4833 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4835 image
= find_rtl_image (f
, image
, rtl
);
4837 if (VECTORP (image
))
4841 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4842 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4845 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4846 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4848 eassert (ASIZE (image
) >= idx
);
4849 image
= AREF (image
, idx
);
4854 img_id
= lookup_image (f
, image
);
4855 img
= IMAGE_FROM_ID (f
, img_id
);
4856 prepare_image_for_display (f
, img
);
4858 if (img
->load_failed_p
|| img
->pixmap
== None
)
4861 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4867 /* If there is an existing widget, check if it's stale; if so,
4868 remove it and make a new tool item from scratch. */
4869 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4872 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4881 /* Save the image so we can see if an update is needed the
4882 next time we call xg_tool_item_match_p. */
4883 if (EQ (style
, Qtext
))
4885 else if (stock_name
)
4887 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4888 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4889 (gpointer
) xstrdup (stock_name
),
4890 (GDestroyNotify
) xfree
);
4894 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4895 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4896 (gpointer
) xstrdup (icon_name
),
4897 (GDestroyNotify
) xfree
);
4901 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4902 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4903 (gpointer
)img
->pixmap
);
4906 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4907 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4908 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4913 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4917 /* Remove buttons not longer needed. */
4920 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4922 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4923 } while (ti
!= NULL
);
4925 if (f
->n_tool_bar_items
!= 0)
4927 if (! x
->toolbar_is_packed
)
4928 xg_pack_tool_bar (f
, f
->tool_bar_position
);
4929 gtk_widget_show_all (TOOLBAR_TOP_WIDGET (x
));
4930 if (xg_update_tool_bar_sizes (f
))
4931 xg_height_or_width_changed (f
);
4937 /* Deallocate all resources for the tool bar on frame F.
4938 Remove the tool bar. */
4941 free_frame_tool_bar (struct frame
*f
)
4943 struct x_output
*x
= f
->output_data
.x
;
4945 if (x
->toolbar_widget
)
4947 struct xg_frame_tb_info
*tbinfo
;
4948 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4951 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4952 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4953 if (x
->toolbar_is_packed
)
4955 if (x
->toolbar_in_hbox
)
4956 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4959 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4963 gtk_widget_destroy (x
->toolbar_widget
);
4965 x
->toolbar_widget
= 0;
4966 TOOLBAR_TOP_WIDGET (x
) = 0;
4967 x
->toolbar_is_packed
= false;
4968 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4969 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4971 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4976 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4981 xg_height_or_width_changed (f
);
4988 xg_change_toolbar_position (struct frame
*f
, Lisp_Object pos
)
4990 struct x_output
*x
= f
->output_data
.x
;
4991 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4993 if (! x
->toolbar_widget
|| ! top_widget
)
4997 g_object_ref (top_widget
);
4998 if (x
->toolbar_is_packed
)
5000 if (x
->toolbar_in_hbox
)
5001 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
5004 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
5008 xg_pack_tool_bar (f
, pos
);
5009 g_object_unref (top_widget
);
5010 if (xg_update_tool_bar_sizes (f
))
5011 xg_height_or_width_changed (f
);
5018 /***********************************************************************
5020 ***********************************************************************/
5022 xg_initialize (void)
5024 GtkBindingSet
*binding_set
;
5025 GtkSettings
*settings
;
5028 /* Work around a bug with corrupted data if libXft gets unloaded. This way
5029 we keep it permanently linked in. */
5034 xg_ignore_gtk_scrollbar
= 0;
5035 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
5036 xg_detached_menus
= 0;
5038 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
5039 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
5041 id_to_widget
.max_size
= id_to_widget
.used
= 0;
5042 id_to_widget
.widgets
= 0;
5044 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
5045 (gdk_display_get_default ()));
5046 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
5047 bindings. It doesn't seem to be any way to remove properties,
5048 so we set it to "" which in means "no key". */
5049 gtk_settings_set_string_property (settings
,
5050 "gtk-menu-bar-accel",
5054 /* Make GTK text input widgets use Emacs style keybindings. This is
5056 gtk_settings_set_string_property (settings
,
5057 "gtk-key-theme-name",
5061 /* Make dialogs close on C-g. Since file dialog inherits from
5062 dialog, this works for them also. */
5063 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
5064 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5067 /* Make menus close on C-g. */
5068 binding_set
= gtk_binding_set_by_class (g_type_class_ref
5069 (GTK_TYPE_MENU_SHELL
));
5070 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5072 update_theme_scrollbar_width ();
5074 #ifdef HAVE_FREETYPE
5075 x_last_font_name
= NULL
;
5079 #endif /* USE_GTK */