1 /* Functions for creating and updating GTK widgets.
3 Copyright (C) 2003-2014 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
30 #include "blockinput.h"
31 #include "syssignal.h"
35 #include "termhooks.h"
41 #include <gdk/gdkkeysyms.h>
42 #include "xsettings.h"
45 #include <X11/Xft/Xft.h>
50 #include "emacsgtkfixed.h"
53 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
54 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
56 #define FRAME_TOTAL_PIXEL_WIDTH(f) \
57 (FRAME_PIXEL_WIDTH (f) + FRAME_TOOLBAR_WIDTH (f))
59 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
60 #define gtk_widget_set_has_window(w, b) \
61 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
63 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
64 #define gtk_dialog_get_action_area(w) ((w)->action_area)
65 #define gtk_dialog_get_content_area(w) ((w)->vbox)
67 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
68 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
70 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
71 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
72 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
73 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
74 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
76 #if GTK_CHECK_VERSION (2, 12, 0)
77 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
79 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
83 #if GTK_CHECK_VERSION (3, 2, 0)
84 #define USE_NEW_GTK_FONT_CHOOSER 1
86 #define USE_NEW_GTK_FONT_CHOOSER 0
87 #define gtk_font_chooser_dialog_new(x, y) \
88 gtk_font_selection_dialog_new (x)
89 #undef GTK_FONT_CHOOSER
90 #define GTK_FONT_CHOOSER(x) GTK_FONT_SELECTION_DIALOG (x)
91 #define gtk_font_chooser_set_font(x, y) \
92 gtk_font_selection_dialog_set_font_name (x, y)
94 #endif /* HAVE_FREETYPE */
97 #ifdef USE_GTK_TOOLTIP
98 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
100 #define gdk_window_get_geometry(w, a, b, c, d) \
101 gdk_window_get_geometry (w, a, b, c, d, 0)
102 #define gdk_x11_window_lookup_for_display(d, w) \
103 gdk_xid_table_lookup_for_display (d, w)
104 #define gtk_box_new(ori, spacing) \
105 ((ori) == GTK_ORIENTATION_HORIZONTAL \
106 ? gtk_hbox_new (FALSE, (spacing)) : gtk_vbox_new (FALSE, (spacing)))
107 #define gtk_scrollbar_new(ori, spacing) \
108 ((ori) == GTK_ORIENTATION_HORIZONTAL \
109 ? gtk_hscrollbar_new ((spacing)) : gtk_vscrollbar_new ((spacing)))
111 #define GDK_KEY_g GDK_g
113 #endif /* HAVE_GTK3 */
115 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
117 static void update_theme_scrollbar_width (void);
119 #define TB_INFO_KEY "xg_frame_tb_info"
120 struct xg_frame_tb_info
122 Lisp_Object last_tool_bar
;
125 int hmargin
, vmargin
;
126 GtkTextDirection dir
;
130 /***********************************************************************
131 Display handling functions
132 ***********************************************************************/
134 /* Keep track of the default display, or NULL if there is none. Emacs
135 may close all its displays. */
137 static GdkDisplay
*gdpy_def
;
139 /* When the GTK widget W is to be created on a display for F that
140 is not the default display, set the display for W.
141 W can be a GtkMenu or a GtkWindow widget. */
144 xg_set_screen (GtkWidget
*w
, struct frame
*f
)
146 if (FRAME_X_DISPLAY (f
) != DEFAULT_GDK_DISPLAY ())
148 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
149 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
152 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
154 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
159 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
160 *DPY is set to NULL if the display can't be opened.
162 Returns non-zero if display could be opened, zero if display could not
163 be opened, and less than zero if the GTK version doesn't support
164 multiple displays. */
167 xg_display_open (char *display_name
, Display
**dpy
)
171 gdpy
= gdk_display_open (display_name
);
172 if (!gdpy_def
&& gdpy
)
175 gdk_display_manager_set_default_display (gdk_display_manager_get (),
179 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
183 /* Close display DPY. */
186 xg_display_close (Display
*dpy
)
188 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
190 /* If this is the default display, try to change it before closing.
191 If there is no other display to use, gdpy_def is set to NULL, and
192 the next call to xg_display_open resets the default display. */
193 if (gdk_display_get_default () == gdpy
)
195 struct x_display_info
*dpyinfo
;
196 GdkDisplay
*gdpy_new
= NULL
;
198 /* Find another display. */
199 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
200 if (dpyinfo
->display
!= dpy
)
202 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
203 gdk_display_manager_set_default_display (gdk_display_manager_get (),
210 #if GTK_CHECK_VERSION (2, 0, 0) && ! GTK_CHECK_VERSION (2, 10, 0)
211 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
212 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
213 can continue running, but there will be memory leaks. */
214 g_object_run_dispose (G_OBJECT (gdpy
));
216 /* This seems to be fixed in GTK 2.10. */
217 gdk_display_close (gdpy
);
222 /***********************************************************************
224 ***********************************************************************/
226 /* Create and return the cursor to be used for popup menus and
227 scroll bars on display DPY. */
230 xg_create_default_cursor (Display
*dpy
)
232 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
233 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
237 xg_get_pixbuf_from_pixmap (struct frame
*f
, Pixmap pix
)
242 unsigned int width
, height
, uunused
;
245 XGetGeometry (FRAME_X_DISPLAY (f
), pix
, &wunused
, &iunused
, &iunused
,
246 &width
, &height
, &uunused
, &uunused
);
248 xim
= XGetImage (FRAME_X_DISPLAY (f
), pix
, 0, 0, width
, height
,
252 tmp_buf
= gdk_pixbuf_new_from_data ((guchar
*) xim
->data
,
265 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
268 xg_get_pixbuf_from_pix_and_mask (struct frame
*f
,
273 GdkPixbuf
*icon_buf
, *tmp_buf
;
275 tmp_buf
= xg_get_pixbuf_from_pixmap (f
, pix
);
276 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
277 g_object_unref (G_OBJECT (tmp_buf
));
279 width
= gdk_pixbuf_get_width (icon_buf
);
280 height
= gdk_pixbuf_get_height (icon_buf
);
284 GdkPixbuf
*mask_buf
= xg_get_pixbuf_from_pixmap (f
, mask
);
285 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
286 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
287 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
288 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
291 for (y
= 0; y
< height
; ++y
)
293 guchar
*iconptr
, *maskptr
;
296 iconptr
= pixels
+ y
* rowstride
;
297 maskptr
= mask_pixels
+ y
* mask_rowstride
;
299 for (x
= 0; x
< width
; ++x
)
301 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
302 just R is sufficient. */
304 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
306 iconptr
+= rowstride
/width
;
307 maskptr
+= mask_rowstride
/width
;
311 g_object_unref (G_OBJECT (mask_buf
));
318 file_for_image (Lisp_Object image
)
320 Lisp_Object specified_file
= Qnil
;
323 for (tail
= XCDR (image
);
324 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
325 tail
= XCDR (XCDR (tail
)))
326 if (EQ (XCAR (tail
), QCfile
))
327 specified_file
= XCAR (XCDR (tail
));
329 return specified_file
;
332 /* For the image defined in IMG, make and return a GtkImage. For displays with
333 8 planes or less we must make a GdkPixbuf and apply the mask manually.
334 Otherwise the highlighting and dimming the tool bar code in GTK does
335 will look bad. For display with more than 8 planes we just use the
336 pixmap and mask directly. For monochrome displays, GTK doesn't seem
337 able to use external pixmaps, it looks bad whatever we do.
338 The image is defined on the display where frame F is.
339 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
340 If OLD_WIDGET is NULL, a new widget is constructed and returned.
341 If OLD_WIDGET is not NULL, that widget is modified. */
344 xg_get_image_for_pixmap (struct frame
*f
,
347 GtkImage
*old_widget
)
351 /* If we have a file, let GTK do all the image handling.
352 This seems to be the only way to make insensitive and activated icons
353 look good in all cases. */
354 Lisp_Object specified_file
= file_for_image (img
->spec
);
357 /* We already loaded the image once before calling this
358 function, so this only fails if the image file has been removed.
359 In that case, use the pixmap already loaded. */
361 if (STRINGP (specified_file
)
362 && STRINGP (file
= x_find_image_file (specified_file
)))
365 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
367 gtk_image_set_from_file (old_widget
, SSDATA (file
));
369 return GTK_WIDGET (old_widget
);
372 /* No file, do the image handling ourselves. This will look very bad
373 on a monochrome display, and sometimes bad on all displays with
376 /* This is a workaround to make icons look good on pseudo color
377 displays. Apparently GTK expects the images to have an alpha
378 channel. If they don't, insensitive and activated icons will
379 look bad. This workaround does not work on monochrome displays,
380 and is strictly not needed on true color/static color displays (i.e.
381 16 bits and higher). But we do it anyway so we get a pixbuf that is
382 not associated with the img->pixmap. The img->pixmap may be removed
383 by clearing the image cache and then the tool bar redraw fails, since
384 Gtk+ assumes the pixmap is always there. */
385 icon_buf
= xg_get_pixbuf_from_pix_and_mask (f
, img
->pixmap
, img
->mask
);
390 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
392 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
394 g_object_unref (G_OBJECT (icon_buf
));
397 return GTK_WIDGET (old_widget
);
401 /* Set CURSOR on W and all widgets W contain. We must do like this
402 for scroll bars and menu because they create widgets internally,
403 and it is those widgets that are visible. */
406 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
408 GdkWindow
*window
= gtk_widget_get_window (w
);
409 GList
*children
= gdk_window_peek_children (window
);
411 gdk_window_set_cursor (window
, cursor
);
413 /* The scroll bar widget has more than one GDK window (had to look at
414 the source to figure this out), and there is no way to set cursor
415 on widgets in GTK. So we must set the cursor for all GDK windows.
418 for ( ; children
; children
= g_list_next (children
))
419 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
422 /* Insert NODE into linked LIST. */
425 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
427 xg_list_node
*list_start
= list
->next
;
429 if (list_start
) list_start
->prev
= node
;
430 node
->next
= list_start
;
435 /* Remove NODE from linked LIST. */
438 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
440 xg_list_node
*list_start
= list
->next
;
441 if (node
== list_start
)
443 list
->next
= node
->next
;
444 if (list
->next
) list
->next
->prev
= 0;
448 node
->prev
->next
= node
->next
;
449 if (node
->next
) node
->next
->prev
= node
->prev
;
453 /* Allocate and return a utf8 version of STR. If STR is already
454 utf8 or NULL, just return a copy of STR.
455 A new string is allocated and the caller must free the result
459 get_utf8_string (const char *str
)
463 if (!str
) return NULL
;
465 /* If not UTF-8, try current locale. */
466 if (!g_utf8_validate (str
, -1, NULL
))
467 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
469 return g_strdup (str
);
473 /* Probably some control characters in str. Escape them. */
475 ptrdiff_t nr_bad
= 0;
478 unsigned char *p
= (unsigned char *)str
;
482 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
483 &bytes_written
, &err
))
484 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
487 p
+= bytes_written
+1;
500 if ((min (PTRDIFF_MAX
, SIZE_MAX
) - len
- 1) / 4 < nr_bad
)
501 memory_full (SIZE_MAX
);
502 up
= utf8_str
= xmalloc (len
+ nr_bad
* 4 + 1);
503 p
= (unsigned char *)str
;
505 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
506 &bytes_written
, &err
))
507 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
509 memcpy (up
, p
, bytes_written
);
510 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
511 up
+= bytes_written
+4;
512 p
+= bytes_written
+1;
519 strcat (utf8_str
, cp
);
531 /* Check for special colors used in face spec for region face.
532 The colors are fetched from the Gtk+ theme.
533 Return true if color was found, false if not. */
536 xg_check_special_colors (struct frame
*f
,
537 const char *color_name
,
541 bool get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
542 bool get_fg
= !get_bg
&& strcmp ("gtk_selection_fg_color", color_name
) == 0;
544 if (! FRAME_GTK_WIDGET (f
) || ! (get_bg
|| get_fg
))
550 GtkStyleContext
*gsty
551 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f
));
553 char buf
[sizeof "rgb://rrrr/gggg/bbbb"];
554 int state
= GTK_STATE_FLAG_SELECTED
|GTK_STATE_FLAG_FOCUSED
;
556 gtk_style_context_get_color (gsty
, state
, &col
);
558 gtk_style_context_get_background_color (gsty
, state
, &col
);
560 sprintf (buf
, "rgb:%04x/%04x/%04x",
561 (int)(col
.red
* 65535),
562 (int)(col
.green
* 65535),
563 (int)(col
.blue
* 65535));
564 success_p
= (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
568 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
569 GdkColor
*grgb
= get_bg
570 ? &gsty
->bg
[GTK_STATE_SELECTED
]
571 : &gsty
->fg
[GTK_STATE_SELECTED
];
573 color
->red
= grgb
->red
;
574 color
->green
= grgb
->green
;
575 color
->blue
= grgb
->blue
;
576 color
->pixel
= grgb
->pixel
;
587 /***********************************************************************
589 ***********************************************************************/
590 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
591 We use that to pop down the tooltip. This happens if Gtk+ for some
592 reason wants to change or hide the tooltip. */
594 #ifdef USE_GTK_TOOLTIP
597 hierarchy_ch_cb (GtkWidget
*widget
,
598 GtkWidget
*previous_toplevel
,
601 struct frame
*f
= user_data
;
602 struct x_output
*x
= f
->output_data
.x
;
603 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
605 if (! top
|| ! GTK_IS_WINDOW (top
))
606 gtk_widget_hide (previous_toplevel
);
609 /* Callback called when Gtk+ thinks a tooltip should be displayed.
610 We use it to get the tooltip window and the tooltip widget so
611 we can manipulate the ourselves.
613 Return FALSE ensures that the tooltip is not shown. */
616 qttip_cb (GtkWidget
*widget
,
619 gboolean keyboard_mode
,
623 struct frame
*f
= user_data
;
624 struct x_output
*x
= f
->output_data
.x
;
625 if (x
->ttip_widget
== NULL
)
630 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
631 x
->ttip_widget
= tooltip
;
632 g_object_ref (G_OBJECT (tooltip
));
633 x
->ttip_lbl
= gtk_label_new ("");
634 g_object_ref (G_OBJECT (x
->ttip_lbl
));
635 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
636 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
638 /* Change stupid Gtk+ default line wrapping. */
639 p
= gtk_widget_get_parent (x
->ttip_lbl
);
640 list
= gtk_container_get_children (GTK_CONTAINER (p
));
641 for (iter
= list
; iter
; iter
= g_list_next (iter
))
643 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
644 if (GTK_IS_LABEL (w
))
645 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
649 /* ATK needs an empty title for some reason. */
650 gtk_window_set_title (x
->ttip_window
, "");
651 /* Realize so we can safely get screen later on. */
652 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
653 gtk_widget_realize (x
->ttip_lbl
);
655 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
656 G_CALLBACK (hierarchy_ch_cb
), f
);
661 #endif /* USE_GTK_TOOLTIP */
663 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
664 Return true if a system tooltip is available. */
667 xg_prepare_tooltip (struct frame
*f
,
672 #ifndef USE_GTK_TOOLTIP
675 struct x_output
*x
= f
->output_data
.x
;
679 GtkSettings
*settings
;
680 gboolean tt_enabled
= TRUE
;
682 Lisp_Object encoded_string
;
684 if (!x
->ttip_lbl
) return 0;
687 encoded_string
= ENCODE_UTF_8 (string
);
688 widget
= GTK_WIDGET (x
->ttip_lbl
);
689 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
690 screen
= gdk_window_get_screen (gwin
);
691 settings
= gtk_settings_get_for_screen (screen
);
692 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
695 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
696 /* Record that we disabled it so it can be enabled again. */
697 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
701 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
702 g_object_set_data (G_OBJECT
703 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
704 "gdk-display-current-tooltip", NULL
);
706 /* Put our dummy widget in so we can get callbacks for unrealize and
707 hierarchy-changed. */
708 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
709 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
710 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
711 if (width
) *width
= req
.width
;
712 if (height
) *height
= req
.height
;
717 #endif /* USE_GTK_TOOLTIP */
720 /* Show the tooltip at ROOT_X and ROOT_Y.
721 xg_prepare_tooltip must have been called before this function. */
724 xg_show_tooltip (struct frame
*f
, int root_x
, int root_y
)
726 #ifdef USE_GTK_TOOLTIP
727 struct x_output
*x
= f
->output_data
.x
;
731 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
732 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
738 /* Hide tooltip if shown. Do nothing if not shown.
739 Return true if tip was hidden, false if not (i.e. not using
743 xg_hide_tooltip (struct frame
*f
)
746 #ifdef USE_GTK_TOOLTIP
747 if (f
->output_data
.x
->ttip_window
)
749 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
751 gtk_widget_hide (GTK_WIDGET (win
));
753 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
755 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
756 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
757 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
758 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
769 /***********************************************************************
770 General functions for creating widgets, resizing, events, e.t.c.
771 ***********************************************************************/
774 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
775 const gchar
*msg
, gpointer user_data
)
777 if (!strstr (msg
, "visible children"))
778 fprintf (stderr
, "XX %s-WARNING **: %s\n", log_domain
, msg
);
781 /* Make a geometry string and pass that to GTK. It seems this is the
782 only way to get geometry position right if the user explicitly
783 asked for a position when starting Emacs.
784 F is the frame we shall set geometry for. */
787 xg_set_geometry (struct frame
*f
)
789 if (f
->size_hint_flags
& (USPosition
| PPosition
))
791 int left
= f
->left_pos
;
792 int xneg
= f
->size_hint_flags
& XNegative
;
793 int top
= f
->top_pos
;
794 int yneg
= f
->size_hint_flags
& YNegative
;
795 char geom_str
[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
803 sprintf (geom_str
, "=%dx%d%c%d%c%d",
804 FRAME_PIXEL_WIDTH (f
),
805 FRAME_PIXEL_HEIGHT (f
),
806 (xneg
? '-' : '+'), left
,
807 (yneg
? '-' : '+'), top
);
809 /* Silence warning about visible children. */
810 id
= g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
811 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
813 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
815 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
817 g_log_remove_handler ("Gtk", id
);
821 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
822 and use a GtkFixed widget, this doesn't happen automatically. */
825 xg_clear_under_internal_border (struct frame
*f
)
827 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
829 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
831 gtk_widget_queue_draw (wfixed
);
832 gdk_window_process_all_updates ();
834 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), 0, 0,
835 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
837 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), 0, 0,
838 FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
840 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), 0,
841 FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
842 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
844 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
845 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
846 0, FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
850 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
851 and a Gtk+ menu bar, we get resize events for the edit part of the
852 frame only. We let Gtk+ deal with the Gtk+ parts.
853 F is the frame to resize.
854 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
857 xg_frame_resized (struct frame
*f
, int pixelwidth
, int pixelheight
)
861 if (pixelwidth
== -1 && pixelheight
== -1)
863 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
864 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
866 &pixelwidth
, &pixelheight
);
871 width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, pixelwidth
);
872 height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelheight
);
874 if (width
!= FRAME_TEXT_WIDTH (f
)
875 || height
!= FRAME_TEXT_HEIGHT (f
)
876 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
877 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
879 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
880 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
882 xg_clear_under_internal_border (f
);
883 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
884 SET_FRAME_GARBAGED (f
);
885 cancel_mouse_face (f
);
889 /* Resize the outer window of frame F after changing the height.
890 COLUMNS/ROWS is the size the edit area shall have after the resize. */
893 xg_frame_set_char_size (struct frame
*f
, int width
, int height
)
895 int pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
896 int pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
898 if (FRAME_PIXEL_HEIGHT (f
) == 0)
901 /* Do this before resize, as we don't know yet if we will be resized. */
902 xg_clear_under_internal_border (f
);
904 /* Must resize our top level widget. Font size may have changed,
905 but not rows/cols. */
906 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
907 pixelwidth
+ FRAME_TOOLBAR_WIDTH (f
),
908 pixelheight
+ FRAME_TOOLBAR_HEIGHT (f
)
909 + FRAME_MENUBAR_HEIGHT (f
));
910 x_wm_set_size_hint (f
, 0, 0);
912 SET_FRAME_GARBAGED (f
);
913 cancel_mouse_face (f
);
915 /* We can not call change_frame_size for a mapped frame,
916 we can not set pixel width/height either. The window manager may
917 override our resize request, XMonad does this all the time.
918 The best we can do is try to sync, so lisp code sees the updated
919 size as fast as possible.
920 For unmapped windows, we can set rows/cols. When
921 the frame is mapped again we will (hopefully) get the correct size. */
922 if (FRAME_VISIBLE_P (f
))
924 /* Must call this to flush out events */
925 (void)gtk_events_pending ();
927 x_wait_for_event (f
, ConfigureNotify
);
930 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
933 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
934 The policy is to keep the number of editable lines. */
937 xg_height_or_width_changed (struct frame
*f
)
939 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
940 FRAME_TOTAL_PIXEL_WIDTH (f
),
941 FRAME_TOTAL_PIXEL_HEIGHT (f
));
942 f
->output_data
.x
->hint_flags
= 0;
943 x_wm_set_size_hint (f
, 0, 0);
946 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
947 Must be done like this, because GtkWidget:s can have "hidden"
948 X Window that aren't accessible.
950 Return 0 if no widget match WDESC. */
953 xg_win_to_widget (Display
*dpy
, Window wdesc
)
956 GtkWidget
*gwdesc
= 0;
960 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
965 event
.any
.window
= gdkwin
;
966 event
.any
.type
= GDK_NOTHING
;
967 gwdesc
= gtk_get_event_widget (&event
);
974 /* Set the background of widget W to PIXEL. */
977 xg_set_widget_bg (struct frame
*f
, GtkWidget
*w
, unsigned long pixel
)
983 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
985 bg
.red
= (double)xbg
.red
/65535.0;
986 bg
.green
= (double)xbg
.green
/65535.0;
987 bg
.blue
= (double)xbg
.blue
/65535.0;
989 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
993 GdkColormap
*map
= gtk_widget_get_colormap (w
);
994 gdk_colormap_query_color (map
, pixel
, &bg
);
995 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
999 /* Callback called when the gtk theme changes.
1000 We notify lisp code so it can fix faces used for region for example. */
1003 style_changed_cb (GObject
*go
,
1007 struct input_event event
;
1008 GdkDisplay
*gdpy
= user_data
;
1009 const char *display_name
= gdk_display_get_name (gdpy
);
1010 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1013 event
.kind
= CONFIG_CHANGED_EVENT
;
1014 event
.frame_or_window
= build_string (display_name
);
1015 /* Theme doesn't change often, so intern is called seldom. */
1016 event
.arg
= intern ("theme-name");
1017 kbd_buffer_store_event (&event
);
1019 update_theme_scrollbar_width ();
1021 /* If scroll bar width changed, we need set the new size on all frames
1025 Lisp_Object rest
, frame
;
1026 FOR_EACH_FRAME (rest
, frame
)
1028 struct frame
*f
= XFRAME (frame
);
1029 if (FRAME_LIVE_P (f
)
1031 && FRAME_X_DISPLAY (f
) == dpy
)
1033 x_set_scroll_bar_default_width (f
);
1034 xg_frame_set_char_size (f
, FRAME_TEXT_WIDTH (f
), FRAME_TEXT_HEIGHT (f
));
1040 /* Called when a delete-event occurs on WIDGET. */
1043 delete_cb (GtkWidget
*widget
,
1048 /* The event doesn't arrive in the normal event loop. Send event
1050 struct frame
*f
= user_data
;
1051 struct input_event ie
;
1054 ie
.kind
= DELETE_WINDOW_EVENT
;
1055 XSETFRAME (ie
.frame_or_window
, f
);
1056 kbd_buffer_store_event (&ie
);
1062 /* Create and set up the GTK widgets for frame F.
1063 Return true if creation succeeded. */
1066 xg_create_frame_widgets (struct frame
*f
)
1069 GtkWidget
*wvbox
, *whbox
;
1078 if (FRAME_X_EMBEDDED_P (f
))
1080 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1081 wtop
= gtk_plug_new_for_display (gdpy
, f
->output_data
.x
->parent_desc
);
1084 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1086 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1087 has backported it to Gtk+ 2.0 and they add the resize grip for
1088 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1089 forever, so disable the grip. */
1090 #if (! GTK_CHECK_VERSION (3, 0, 0) \
1091 && defined HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1092 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop
), FALSE
);
1095 xg_set_screen (wtop
, f
);
1097 wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1098 whbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1099 gtk_box_set_homogeneous (GTK_BOX (wvbox
), FALSE
);
1100 gtk_box_set_homogeneous (GTK_BOX (whbox
), FALSE
);
1103 wfixed
= emacs_fixed_new (f
);
1105 wfixed
= gtk_fixed_new ();
1108 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1110 if (wtop
) gtk_widget_destroy (wtop
);
1111 if (wvbox
) gtk_widget_destroy (wvbox
);
1112 if (whbox
) gtk_widget_destroy (whbox
);
1113 if (wfixed
) gtk_widget_destroy (wfixed
);
1119 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1120 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1121 gtk_widget_set_name (wvbox
, "pane");
1122 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1124 /* If this frame has a title or name, set it in the title bar. */
1125 if (! NILP (f
->title
))
1126 title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1127 else if (! NILP (f
->name
))
1128 title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1130 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1132 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1133 FRAME_GTK_WIDGET (f
) = wfixed
;
1134 f
->output_data
.x
->vbox_widget
= wvbox
;
1135 f
->output_data
.x
->hbox_widget
= whbox
;
1137 gtk_widget_set_has_window (wfixed
, TRUE
);
1139 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1140 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1141 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1143 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1144 update_frame_tool_bar (f
);
1146 /* We don't want this widget double buffered, because we draw on it
1147 with regular X drawing primitives, so from a GTK/GDK point of
1148 view, the widget is totally blank. When an expose comes, this
1149 will make the widget blank, and then Emacs redraws it. This flickers
1150 a lot, so we turn off double buffering. */
1151 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1153 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1154 SSDATA (Vx_resource_name
),
1155 SSDATA (Vx_resource_class
));
1157 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1158 GTK is to destroy the widget. We want Emacs to do that instead. */
1159 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1160 G_CALLBACK (delete_cb
), f
);
1162 /* Convert our geometry parameters into a geometry string
1164 GTK will itself handle calculating the real position this way. */
1165 xg_set_geometry (f
);
1167 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1169 gtk_widget_add_events (wfixed
,
1170 GDK_POINTER_MOTION_MASK
1172 | GDK_BUTTON_PRESS_MASK
1173 | GDK_BUTTON_RELEASE_MASK
1174 | GDK_KEY_PRESS_MASK
1175 | GDK_ENTER_NOTIFY_MASK
1176 | GDK_LEAVE_NOTIFY_MASK
1177 | GDK_FOCUS_CHANGE_MASK
1178 | GDK_STRUCTURE_MASK
1179 | GDK_VISIBILITY_NOTIFY_MASK
);
1181 /* Must realize the windows so the X window gets created. It is used
1182 by callers of this function. */
1183 gtk_widget_realize (wfixed
);
1184 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1186 /* Since GTK clears its window by filling with the background color,
1187 we must keep X and GTK background in sync. */
1188 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1191 /* Also, do not let any background pixmap to be set, this looks very
1192 bad as Emacs overwrites the background pixmap with its own idea
1193 of background color. */
1194 style
= gtk_widget_get_modifier_style (wfixed
);
1196 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1197 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1198 gtk_widget_modify_style (wfixed
, style
);
1200 gtk_widget_set_can_focus (wfixed
, TRUE
);
1201 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1204 #ifdef USE_GTK_TOOLTIP
1205 /* Steal a tool tip window we can move ourselves. */
1206 f
->output_data
.x
->ttip_widget
= 0;
1207 f
->output_data
.x
->ttip_lbl
= 0;
1208 f
->output_data
.x
->ttip_window
= 0;
1209 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1210 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1214 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1215 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1216 /* Only connect this signal once per screen. */
1217 if (! g_signal_handler_find (G_OBJECT (gs
),
1218 G_SIGNAL_MATCH_FUNC
,
1220 G_CALLBACK (style_changed_cb
),
1223 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1224 G_CALLBACK (style_changed_cb
),
1225 gdk_screen_get_display (screen
));
1235 xg_free_frame_widgets (struct frame
*f
)
1237 if (FRAME_GTK_OUTER_WIDGET (f
))
1239 #ifdef USE_GTK_TOOLTIP
1240 struct x_output
*x
= f
->output_data
.x
;
1242 struct xg_frame_tb_info
*tbinfo
1243 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
1248 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1249 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1250 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1251 #ifdef USE_GTK_TOOLTIP
1253 gtk_widget_destroy (x
->ttip_lbl
);
1255 g_object_unref (G_OBJECT (x
->ttip_widget
));
1260 /* Set the normal size hints for the window manager, for frame F.
1261 FLAGS is the flags word to use--or 0 meaning preserve the flags
1262 that the window now has.
1263 If USER_POSITION, set the User Position
1264 flag (this is useful when FLAGS is 0). */
1267 x_wm_set_size_hint (struct frame
*f
, long int flags
, bool user_position
)
1269 /* Must use GTK routines here, otherwise GTK resets the size hints
1270 to its own defaults. */
1271 GdkGeometry size_hints
;
1272 gint hint_flags
= 0;
1273 int base_width
, base_height
;
1274 int min_rows
= 0, min_cols
= 0;
1275 int win_gravity
= f
->win_gravity
;
1276 Lisp_Object fs_state
, frame
;
1278 /* Don't set size hints during initialization; that apparently leads
1279 to a race condition. See the thread at
1280 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1281 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1284 XSETFRAME (frame
, f
);
1285 fs_state
= Fframe_parameter (frame
, Qfullscreen
);
1286 if (EQ (fs_state
, Qmaximized
) || EQ (fs_state
, Qfullboth
))
1288 /* Don't set hints when maximized or fullscreen. Apparently KWin and
1289 Gtk3 don't get along and the frame shrinks (!).
1296 memset (&size_hints
, 0, sizeof (size_hints
));
1297 f
->output_data
.x
->size_hints
= size_hints
;
1298 f
->output_data
.x
->hint_flags
= hint_flags
;
1301 flags
= f
->size_hint_flags
;
1303 size_hints
= f
->output_data
.x
->size_hints
;
1304 hint_flags
= f
->output_data
.x
->hint_flags
;
1306 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1307 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
1308 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
1310 hint_flags
|= GDK_HINT_BASE_SIZE
;
1311 /* Use one row/col here so base_height/width does not become zero.
1312 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1313 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 1) + FRAME_TOOLBAR_WIDTH (f
);
1314 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 1)
1315 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1317 check_frame_size (f
, &min_cols
, &min_rows
, 0);
1318 if (min_cols
> 0) --min_cols
; /* We used one col in base_width = ... 1); */
1319 if (min_rows
> 0) --min_rows
; /* We used one row in base_height = ... 1); */
1321 size_hints
.base_width
= base_width
;
1322 size_hints
.base_height
= base_height
;
1323 size_hints
.min_width
= base_width
+ min_cols
* FRAME_COLUMN_WIDTH (f
);;
1324 size_hints
.min_height
= base_height
+ min_rows
* FRAME_LINE_HEIGHT (f
);
1326 /* These currently have a one to one mapping with the X values, but I
1327 don't think we should rely on that. */
1328 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1329 size_hints
.win_gravity
= 0;
1330 if (win_gravity
== NorthWestGravity
)
1331 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1332 else if (win_gravity
== NorthGravity
)
1333 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1334 else if (win_gravity
== NorthEastGravity
)
1335 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1336 else if (win_gravity
== WestGravity
)
1337 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1338 else if (win_gravity
== CenterGravity
)
1339 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1340 else if (win_gravity
== EastGravity
)
1341 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1342 else if (win_gravity
== SouthWestGravity
)
1343 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1344 else if (win_gravity
== SouthGravity
)
1345 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1346 else if (win_gravity
== SouthEastGravity
)
1347 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1348 else if (win_gravity
== StaticGravity
)
1349 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1353 hint_flags
&= ~GDK_HINT_POS
;
1354 hint_flags
|= GDK_HINT_USER_POS
;
1357 if (hint_flags
!= f
->output_data
.x
->hint_flags
1358 || memcmp (&size_hints
,
1359 &f
->output_data
.x
->size_hints
,
1360 sizeof (size_hints
)) != 0)
1363 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1364 NULL
, &size_hints
, hint_flags
);
1365 f
->output_data
.x
->size_hints
= size_hints
;
1366 f
->output_data
.x
->hint_flags
= hint_flags
;
1371 /* Change background color of a frame.
1372 Since GTK uses the background color to clear the window, we must
1373 keep the GTK and X colors in sync.
1374 F is the frame to change,
1375 BG is the pixel value to change to. */
1378 xg_set_background_color (struct frame
*f
, unsigned long bg
)
1380 if (FRAME_GTK_WIDGET (f
))
1383 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1389 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1390 functions so GTK does not overwrite the icon. */
1393 xg_set_frame_icon (struct frame
*f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1395 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1399 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1404 /***********************************************************************
1406 ***********************************************************************/
1407 /* Return the dialog title to use for a dialog of type KEY.
1408 This is the encoding used by lwlib. We use the same for GTK. */
1411 get_dialog_title (char key
)
1413 const char *title
= "";
1421 title
= "Information";
1440 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1441 the dialog, but return TRUE so the event does not propagate further
1442 in GTK. This prevents GTK from destroying the dialog widget automatically
1443 and we can always destroy the widget manually, regardless of how
1444 it was popped down (button press or WM_DELETE_WINDOW).
1445 W is the dialog widget.
1446 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1447 user_data is NULL (not used).
1449 Returns TRUE to end propagation of event. */
1452 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1454 gtk_widget_unmap (w
);
1458 /* Create a popup dialog window. See also xg_create_widget below.
1459 WV is a widget_value describing the dialog.
1460 SELECT_CB is the callback to use when a button has been pressed.
1461 DEACTIVATE_CB is the callback to use when the dialog pops down.
1463 Returns the GTK dialog widget. */
1466 create_dialog (widget_value
*wv
,
1467 GCallback select_cb
,
1468 GCallback deactivate_cb
)
1470 const char *title
= get_dialog_title (wv
->name
[0]);
1471 int total_buttons
= wv
->name
[1] - '0';
1472 int right_buttons
= wv
->name
[4] - '0';
1475 int button_spacing
= 10;
1476 GtkWidget
*wdialog
= gtk_dialog_new ();
1477 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1478 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1480 GtkWidget
*whbox_down
;
1482 /* If the number of buttons is greater than 4, make two rows of buttons
1483 instead. This looks better. */
1484 bool make_two_rows
= total_buttons
> 4;
1486 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1487 left_buttons
= total_buttons
- right_buttons
;
1489 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1490 gtk_widget_set_name (wdialog
, "emacs-dialog");
1495 GtkWidget
*wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, button_spacing
);
1496 GtkWidget
*whbox_up
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1497 gtk_box_set_homogeneous (GTK_BOX (wvbox
), TRUE
);
1498 gtk_box_set_homogeneous (GTK_BOX (whbox_up
), FALSE
);
1499 whbox_down
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1500 gtk_box_set_homogeneous (GTK_BOX (whbox_down
), FALSE
);
1502 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1503 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1504 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1506 cur_box
= GTK_BOX (whbox_up
);
1509 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1510 G_CALLBACK (dialog_delete_callback
), 0);
1514 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1515 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1518 for (item
= wv
->contents
; item
; item
= item
->next
)
1520 char *utf8_label
= get_utf8_string (item
->value
);
1524 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1526 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1527 /* This is the text part of the dialog. */
1528 w
= gtk_label_new (utf8_label
);
1529 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1530 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1531 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1533 /* Try to make dialog look better. Must realize first so
1534 the widget can calculate the size it needs. */
1535 gtk_widget_realize (w
);
1536 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1537 gtk_box_set_spacing (wvbox
, req
.height
);
1538 if (item
->value
&& strlen (item
->value
) > 0)
1539 button_spacing
= 2*req
.width
/strlen (item
->value
);
1543 /* This is one button to add to the dialog. */
1544 w
= gtk_button_new_with_label (utf8_label
);
1545 if (! item
->enabled
)
1546 gtk_widget_set_sensitive (w
, FALSE
);
1548 g_signal_connect (G_OBJECT (w
), "clicked",
1549 select_cb
, item
->call_data
);
1551 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1552 if (++button_nr
== left_buttons
)
1555 cur_box
= GTK_BOX (whbox_down
);
1557 gtk_box_pack_start (cur_box
,
1565 g_free (utf8_label
);
1571 struct xg_dialog_data
1579 /* Function that is called when the file or font dialogs pop down.
1580 W is the dialog widget, RESPONSE is the response code.
1581 USER_DATA is what we passed in to g_signal_connect. */
1584 xg_dialog_response_cb (GtkDialog
*w
,
1588 struct xg_dialog_data
*dd
= user_data
;
1589 dd
->response
= response
;
1590 g_main_loop_quit (dd
->loop
);
1594 /* Destroy the dialog. This makes it pop down. */
1597 pop_down_dialog (void *arg
)
1599 struct xg_dialog_data
*dd
= arg
;
1602 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1603 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1605 g_main_loop_quit (dd
->loop
);
1606 g_main_loop_unref (dd
->loop
);
1611 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1612 We pass in DATA as gpointer* so we can use this as a callback. */
1615 xg_maybe_add_timer (gpointer data
)
1617 struct xg_dialog_data
*dd
= data
;
1618 struct timespec next_time
= timer_check ();
1622 if (timespec_valid_p (next_time
))
1624 time_t s
= next_time
.tv_sec
;
1625 int per_ms
= TIMESPEC_RESOLUTION
/ 1000;
1626 int ms
= (next_time
.tv_nsec
+ per_ms
- 1) / per_ms
;
1627 if (s
<= ((guint
) -1 - ms
) / 1000)
1628 dd
->timerid
= g_timeout_add (s
* 1000 + ms
, xg_maybe_add_timer
, dd
);
1634 /* Pops up a modal dialog W and waits for response.
1635 We don't use gtk_dialog_run because we want to process emacs timers.
1636 The dialog W is not destroyed when this function returns. */
1639 xg_dialog_run (struct frame
*f
, GtkWidget
*w
)
1641 ptrdiff_t count
= SPECPDL_INDEX ();
1642 struct xg_dialog_data dd
;
1644 xg_set_screen (w
, f
);
1645 gtk_window_set_transient_for (GTK_WINDOW (w
),
1646 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1647 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1648 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1650 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1651 dd
.response
= GTK_RESPONSE_CANCEL
;
1655 g_signal_connect (G_OBJECT (w
),
1657 G_CALLBACK (xg_dialog_response_cb
),
1659 /* Don't destroy the widget if closed by the window manager close button. */
1660 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1661 gtk_widget_show (w
);
1663 record_unwind_protect_ptr (pop_down_dialog
, &dd
);
1665 (void) xg_maybe_add_timer (&dd
);
1666 g_main_loop_run (dd
.loop
);
1669 unbind_to (count
, Qnil
);
1675 /***********************************************************************
1676 File dialog functions
1677 ***********************************************************************/
1678 /* Return true if the old file selection dialog is being used. */
1681 xg_uses_old_file_dialog (void)
1683 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1684 return x_gtk_use_old_file_dialog
;
1691 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1693 /* Return the selected file for file chooser dialog W.
1694 The returned string must be free:d. */
1697 xg_get_file_name_from_chooser (GtkWidget
*w
)
1699 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1702 /* Callback called when the "Show hidden files" toggle is pressed.
1703 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1706 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1708 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1710 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1711 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1715 /* Callback called when a property changes in a file chooser.
1716 GOBJECT is the file chooser dialog, ARG1 describes the property.
1717 USER_DATA is the toggle widget in the file chooser dialog.
1718 We use this to update the "Show hidden files" toggle when the user
1719 changes that property by right clicking in the file list. */
1722 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1724 if (strcmp (arg1
->name
, "show-hidden") == 0)
1726 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1727 gboolean visible
, toggle_on
;
1729 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1730 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1732 if (!!visible
!= !!toggle_on
)
1734 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1735 G_CALLBACK (xg_toggle_visibility_cb
),
1737 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1738 g_signal_handlers_unblock_by_func
1739 (G_OBJECT (wtoggle
),
1740 G_CALLBACK (xg_toggle_visibility_cb
),
1743 x_gtk_show_hidden_files
= visible
;
1747 /* Read a file name from the user using a file chooser dialog.
1748 F is the current frame.
1749 PROMPT is a prompt to show to the user. May not be NULL.
1750 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1751 If MUSTMATCH_P, the returned file name must be an existing
1752 file. (Actually, this only has cosmetic effects, the user can
1753 still enter a non-existing file.) *FUNC is set to a function that
1754 can be used to retrieve the selected file name from the returned widget.
1756 Returns the created widget. */
1759 xg_get_file_with_chooser (struct frame
*f
,
1761 char *default_filename
,
1762 bool mustmatch_p
, bool only_dir_p
,
1763 xg_get_file_func
*func
)
1767 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1768 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1769 GtkFileChooserAction action
= (mustmatch_p
?
1770 GTK_FILE_CHOOSER_ACTION_OPEN
:
1771 GTK_FILE_CHOOSER_ACTION_SAVE
);
1774 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1776 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1777 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1778 (mustmatch_p
|| only_dir_p
?
1779 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1782 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1784 wbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1785 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
1786 gtk_widget_show (wbox
);
1787 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1789 if (x_gtk_show_hidden_files
)
1791 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1792 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1794 gtk_widget_show (wtoggle
);
1795 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1796 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1797 g_signal_connect (G_OBJECT (filewin
), "notify",
1798 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1800 if (x_gtk_file_dialog_help_text
)
1803 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1804 Show the C-l help text only for versions < 2.10. */
1805 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1806 strcat (msgbuf
, "\nType C-l to display a file name text entry box.\n");
1807 strcat (msgbuf
, "\nIf you don't like this file selector, use the "
1808 "corresponding\nkey binding or customize "
1809 "use-file-dialog to turn it off.");
1811 wmessage
= gtk_label_new (msgbuf
);
1812 gtk_widget_show (wmessage
);
1815 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1816 if (x_gtk_file_dialog_help_text
)
1817 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1818 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1820 if (default_filename
)
1823 struct gcpro gcpro1
;
1824 char *utf8_filename
;
1827 file
= build_string (default_filename
);
1829 /* File chooser does not understand ~/... in the file name. It must be
1830 an absolute name starting with /. */
1831 if (default_filename
[0] != '/')
1832 file
= Fexpand_file_name (file
, Qnil
);
1834 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1835 if (! NILP (Ffile_directory_p (file
)))
1836 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1840 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1842 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1844 char *cp
= strrchr (utf8_filename
, '/');
1846 else cp
= utf8_filename
;
1847 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1854 *func
= xg_get_file_name_from_chooser
;
1858 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1860 /* Return the selected file for file selector dialog W.
1861 The returned string must be free:d. */
1864 xg_get_file_name_from_selector (GtkWidget
*w
)
1866 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1867 return xstrdup (gtk_file_selection_get_filename (filesel
));
1870 /* Create a file selection dialog.
1871 F is the current frame.
1872 PROMPT is a prompt to show to the user. May not be NULL.
1873 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1874 If MUSTMATCH_P, the returned file name must be an existing
1875 file. *FUNC is set to a function that can be used to retrieve the
1876 selected file name from the returned widget.
1878 Returns the created widget. */
1881 xg_get_file_with_selection (struct frame
*f
,
1883 char *default_filename
,
1884 bool mustmatch_p
, bool only_dir_p
,
1885 xg_get_file_func
*func
)
1888 GtkFileSelection
*filesel
;
1890 filewin
= gtk_file_selection_new (prompt
);
1891 filesel
= GTK_FILE_SELECTION (filewin
);
1893 if (default_filename
)
1894 gtk_file_selection_set_filename (filesel
, default_filename
);
1898 /* The selection_entry part of filesel is not documented. */
1899 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1900 gtk_file_selection_hide_fileop_buttons (filesel
);
1903 *func
= xg_get_file_name_from_selector
;
1907 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1909 /* Read a file name from the user using a file dialog, either the old
1910 file selection dialog, or the new file chooser dialog. Which to use
1911 depends on what the GTK version used has, and what the value of
1912 gtk-use-old-file-dialog.
1913 F is the current frame.
1914 PROMPT is a prompt to show to the user. May not be NULL.
1915 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1916 If MUSTMATCH_P, the returned file name must be an existing
1919 Returns a file name or NULL if no file was selected.
1920 The returned string must be freed by the caller. */
1923 xg_get_file_name (struct frame
*f
,
1925 char *default_filename
,
1931 int filesel_done
= 0;
1932 xg_get_file_func func
;
1934 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1936 if (xg_uses_old_file_dialog ())
1937 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1938 mustmatch_p
, only_dir_p
, &func
);
1940 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1941 mustmatch_p
, only_dir_p
, &func
);
1943 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1944 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1945 mustmatch_p
, only_dir_p
, &func
);
1946 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1948 gtk_widget_set_name (w
, "emacs-filedialog");
1950 filesel_done
= xg_dialog_run (f
, w
);
1951 if (filesel_done
== GTK_RESPONSE_OK
)
1954 gtk_widget_destroy (w
);
1958 /***********************************************************************
1960 ***********************************************************************/
1962 #ifdef HAVE_FREETYPE
1964 #if USE_NEW_GTK_FONT_CHOOSER
1966 #define XG_WEIGHT_TO_SYMBOL(w) \
1967 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
1968 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
1969 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
1970 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
1971 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
1972 : w <= PANGO_WEIGHT_BOLD ? Qbold \
1973 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
1976 #define XG_STYLE_TO_SYMBOL(s) \
1977 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
1978 : s == PANGO_STYLE_ITALIC ? Qitalic \
1981 #endif /* USE_NEW_GTK_FONT_CHOOSER */
1984 static char *x_last_font_name
;
1986 /* Pop up a GTK font selector and return the name of the font the user
1987 selects, as a C string. The returned font name follows GTK's own
1990 `FAMILY [VALUE1 VALUE2] SIZE'
1992 This can be parsed using font_parse_fcname in font.c.
1993 DEFAULT_NAME, if non-zero, is the default font name. */
1996 xg_get_font (struct frame
*f
, const char *default_name
)
2000 Lisp_Object font
= Qnil
;
2002 w
= gtk_font_chooser_dialog_new
2003 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2007 /* Convert fontconfig names to Gtk names, i.e. remove - before
2009 char *p
= strrchr (default_name
, '-');
2013 while (c_isdigit (*ep
))
2015 if (*ep
== '\0') *p
= ' ';
2018 else if (x_last_font_name
)
2019 default_name
= x_last_font_name
;
2022 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w
), default_name
);
2024 gtk_widget_set_name (w
, "emacs-fontdialog");
2025 done
= xg_dialog_run (f
, w
);
2026 if (done
== GTK_RESPONSE_OK
)
2028 #if USE_NEW_GTK_FONT_CHOOSER
2029 /* Use the GTK3 font chooser. */
2030 PangoFontDescription
*desc
2031 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w
));
2035 Lisp_Object args
[10];
2036 const char *name
= pango_font_description_get_family (desc
);
2037 gint size
= pango_font_description_get_size (desc
);
2038 PangoWeight weight
= pango_font_description_get_weight (desc
);
2039 PangoStyle style
= pango_font_description_get_style (desc
);
2042 args
[1] = build_string (name
);
2045 args
[3] = make_float (pango_units_to_double (size
));
2048 args
[5] = XG_WEIGHT_TO_SYMBOL (weight
);
2051 args
[7] = XG_STYLE_TO_SYMBOL (style
);
2056 font
= Ffont_spec (8, args
);
2058 pango_font_description_free (desc
);
2059 dupstring (&x_last_font_name
, name
);
2062 #else /* Use old font selector, which just returns the font name. */
2065 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w
));
2069 font
= build_string (font_name
);
2070 g_free (x_last_font_name
);
2071 x_last_font_name
= font_name
;
2073 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2076 gtk_widget_destroy (w
);
2079 #endif /* HAVE_FREETYPE */
2083 /***********************************************************************
2085 ***********************************************************************/
2087 /* The name of menu items that can be used for customization. Since GTK
2088 RC files are very crude and primitive, we have to set this on all
2089 menu item names so a user can easily customize menu items. */
2091 #define MENU_ITEM_NAME "emacs-menuitem"
2094 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2095 during GC. The next member points to the items. */
2096 static xg_list_node xg_menu_cb_list
;
2098 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2099 during GC. The next member points to the items. */
2100 static xg_list_node xg_menu_item_cb_list
;
2102 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2103 F is the frame CL_DATA will be initialized for.
2104 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2106 The menu bar and all sub menus under the menu bar in a frame
2107 share the same structure, hence the reference count.
2109 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2110 allocated xg_menu_cb_data if CL_DATA is NULL. */
2112 static xg_menu_cb_data
*
2113 make_cl_data (xg_menu_cb_data
*cl_data
, struct frame
*f
, GCallback highlight_cb
)
2117 cl_data
= xmalloc (sizeof *cl_data
);
2119 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2120 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2121 cl_data
->highlight_cb
= highlight_cb
;
2122 cl_data
->ref_count
= 0;
2124 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2127 cl_data
->ref_count
++;
2132 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2133 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2135 When the menu bar is updated, menu items may have been added and/or
2136 removed, so menu_bar_vector and menu_bar_items_used change. We must
2137 then update CL_DATA since it is used to determine which menu
2138 item that is invoked in the menu.
2139 HIGHLIGHT_CB could change, there is no check that the same
2140 function is given when modifying a menu bar as was given when
2141 creating the menu bar. */
2144 update_cl_data (xg_menu_cb_data
*cl_data
,
2146 GCallback highlight_cb
)
2151 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2152 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2153 cl_data
->highlight_cb
= highlight_cb
;
2157 /* Decrease reference count for CL_DATA.
2158 If reference count is zero, free CL_DATA. */
2161 unref_cl_data (xg_menu_cb_data
*cl_data
)
2163 if (cl_data
&& cl_data
->ref_count
> 0)
2165 cl_data
->ref_count
--;
2166 if (cl_data
->ref_count
== 0)
2168 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2174 /* Function that marks all lisp data during GC. */
2180 Lisp_Object rest
, frame
;
2182 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2183 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2185 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2187 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2189 if (! NILP (cb_data
->help
))
2190 mark_object (cb_data
->help
);
2193 FOR_EACH_FRAME (rest
, frame
)
2195 struct frame
*f
= XFRAME (frame
);
2197 if (FRAME_X_P (f
) && FRAME_GTK_OUTER_WIDGET (f
))
2199 struct xg_frame_tb_info
*tbinfo
2200 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
2204 mark_object (tbinfo
->last_tool_bar
);
2205 mark_object (tbinfo
->style
);
2212 /* Callback called when a menu item is destroyed. Used to free data.
2213 W is the widget that is being destroyed (not used).
2214 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2217 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2221 xg_menu_item_cb_data
*data
= client_data
;
2222 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2227 /* Callback called when the pointer enters/leaves a menu item.
2228 W is the parent of the menu item.
2229 EVENT is either an enter event or leave event.
2230 CLIENT_DATA is not used.
2232 Returns FALSE to tell GTK to keep processing this event. */
2235 menuitem_highlight_callback (GtkWidget
*w
,
2236 GdkEventCrossing
*event
,
2237 gpointer client_data
)
2240 GtkWidget
*subwidget
;
2241 xg_menu_item_cb_data
*data
;
2243 ev
.crossing
= *event
;
2244 subwidget
= gtk_get_event_widget (&ev
);
2245 data
= g_object_get_data (G_OBJECT (subwidget
), XG_ITEM_DATA
);
2248 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2250 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2251 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2252 (*func
) (subwidget
, call_data
);
2259 /* Callback called when a menu is destroyed. Used to free data.
2260 W is the widget that is being destroyed (not used).
2261 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2264 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2266 unref_cl_data (client_data
);
2269 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2270 must be non-NULL) and can be inserted into a menu item.
2272 Returns the GtkHBox. */
2275 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2281 wbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
2282 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
2283 wlbl
= gtk_label_new (utf8_label
);
2284 wkey
= gtk_label_new (utf8_key
);
2286 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2287 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2289 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2290 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2292 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2293 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2294 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2299 /* Make and return a menu item widget with the key to the right.
2300 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2301 UTF8_KEY is the text representing the key binding.
2302 ITEM is the widget_value describing the menu item.
2304 GROUP is an in/out parameter. If the menu item to be created is not
2305 part of any radio menu group, *GROUP contains NULL on entry and exit.
2306 If the menu item to be created is part of a radio menu group, on entry
2307 *GROUP contains the group to use, or NULL if this is the first item
2308 in the group. On exit, *GROUP contains the radio item group.
2310 Unfortunately, keys don't line up as nicely as in Motif,
2311 but the MacOS X version doesn't either, so I guess that is OK. */
2314 make_menu_item (const char *utf8_label
,
2315 const char *utf8_key
,
2320 GtkWidget
*wtoadd
= 0;
2322 /* It has been observed that some menu items have a NULL name field.
2323 This will lead to this function being called with a NULL utf8_label.
2324 GTK crashes on that so we set a blank label. Why there is a NULL
2325 name remains to be investigated. */
2326 if (! utf8_label
) utf8_label
= " ";
2329 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2331 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2334 if (utf8_key
) w
= gtk_check_menu_item_new ();
2335 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2336 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2338 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2340 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2341 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2342 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2344 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2349 if (utf8_key
) w
= gtk_menu_item_new ();
2350 else w
= gtk_menu_item_new_with_label (utf8_label
);
2353 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2354 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2359 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2361 static int xg_detached_menus
;
2363 /* Return true if there are detached menus. */
2366 xg_have_tear_offs (struct frame
*f
)
2368 /* If the frame's menubar height is zero, the menu bar is probably
2369 being redirected outside the window to some kind of global menu;
2370 this situation is the moral equivalent of a tear-off. */
2371 return FRAME_MENUBAR_HEIGHT (f
) == 0 || xg_detached_menus
> 0;
2374 /* Callback invoked when a detached menu window is removed. Here we
2375 decrease the xg_detached_menus count.
2376 WIDGET is the top level window that is removed (the parent of the menu).
2377 CLIENT_DATA is not used. */
2380 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2382 if (xg_detached_menus
> 0) --xg_detached_menus
;
2385 /* Callback invoked when a menu is detached. It increases the
2386 xg_detached_menus count.
2387 WIDGET is the GtkTearoffMenuItem.
2388 CLIENT_DATA is not used. */
2391 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2393 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2394 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2396 ++xg_detached_menus
;
2397 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2399 G_CALLBACK (tearoff_remove
), 0);
2402 #else /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2404 xg_have_tear_offs (struct frame
*f
)
2406 return FRAME_MENUBAR_HEIGHT (f
) == 0;
2408 #endif /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2410 /* Create a menu item widget, and connect the callbacks.
2411 ITEM describes the menu item.
2412 F is the frame the created menu belongs to.
2413 SELECT_CB is the callback to use when a menu item is selected.
2414 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2415 CL_DATA points to the callback data to be used for this menu.
2416 GROUP is an in/out parameter. If the menu item to be created is not
2417 part of any radio menu group, *GROUP contains NULL on entry and exit.
2418 If the menu item to be created is part of a radio menu group, on entry
2419 *GROUP contains the group to use, or NULL if this is the first item
2420 in the group. On exit, *GROUP contains the radio item group.
2422 Returns the created GtkWidget. */
2425 xg_create_one_menuitem (widget_value
*item
,
2427 GCallback select_cb
,
2428 GCallback highlight_cb
,
2429 xg_menu_cb_data
*cl_data
,
2435 xg_menu_item_cb_data
*cb_data
;
2437 utf8_label
= get_utf8_string (item
->name
);
2438 utf8_key
= get_utf8_string (item
->key
);
2440 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2442 if (utf8_label
) g_free (utf8_label
);
2443 if (utf8_key
) g_free (utf8_key
);
2445 cb_data
= xmalloc (sizeof *cb_data
);
2447 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2449 cb_data
->select_id
= 0;
2450 cb_data
->help
= item
->help
;
2451 cb_data
->cl_data
= cl_data
;
2452 cb_data
->call_data
= item
->call_data
;
2454 g_signal_connect (G_OBJECT (w
),
2456 G_CALLBACK (menuitem_destroy_callback
),
2459 /* Put cb_data in widget, so we can get at it when modifying menubar */
2460 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2462 /* final item, not a submenu */
2463 if (item
->call_data
&& ! item
->contents
)
2467 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2473 /* Create a full menu tree specified by DATA.
2474 F is the frame the created menu belongs to.
2475 SELECT_CB is the callback to use when a menu item is selected.
2476 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2477 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2478 If POP_UP_P, create a popup menu.
2479 If MENU_BAR_P, create a menu bar.
2480 If ADD_TEAROFF_P, add a tearoff menu item. Ignored if MENU_BAR_P or
2481 the Gtk+ version used does not have tearoffs.
2482 TOPMENU is the topmost GtkWidget that others shall be placed under.
2483 It may be NULL, in that case we create the appropriate widget
2484 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2485 CL_DATA is the callback data we shall use for this menu, or NULL
2486 if we haven't set the first callback yet.
2487 NAME is the name to give to the top level menu if this function
2488 creates it. May be NULL to not set any name.
2490 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2493 This function calls itself to create submenus. */
2496 create_menus (widget_value
*data
,
2498 GCallback select_cb
,
2499 GCallback deactivate_cb
,
2500 GCallback highlight_cb
,
2505 xg_menu_cb_data
*cl_data
,
2509 GtkWidget
*wmenu
= topmenu
;
2510 GSList
*group
= NULL
;
2516 wmenu
= gtk_menu_new ();
2517 xg_set_screen (wmenu
, f
);
2518 /* Connect this to the menu instead of items so we get enter/leave for
2519 disabled items also. TODO: Still does not get enter/leave for
2520 disabled items in detached menus. */
2521 g_signal_connect (G_OBJECT (wmenu
),
2522 "enter-notify-event",
2523 G_CALLBACK (menuitem_highlight_callback
),
2525 g_signal_connect (G_OBJECT (wmenu
),
2526 "leave-notify-event",
2527 G_CALLBACK (menuitem_highlight_callback
),
2532 wmenu
= gtk_menu_bar_new ();
2533 /* Set width of menu bar to a small value so it doesn't enlarge
2534 a small initial frame size. The width will be set to the
2535 width of the frame later on when it is added to a container.
2536 height -1: Natural height. */
2537 gtk_widget_set_size_request (wmenu
, 1, -1);
2540 /* Put cl_data on the top menu for easier access. */
2541 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2542 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2543 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2544 G_CALLBACK (menu_destroy_callback
), cl_data
);
2547 gtk_widget_set_name (wmenu
, name
);
2550 g_signal_connect (G_OBJECT (wmenu
),
2551 "selection-done", deactivate_cb
, 0);
2554 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2555 if (! menu_bar_p
&& add_tearoff_p
)
2557 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2558 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2560 g_signal_connect (G_OBJECT (tearoff
), "activate",
2561 G_CALLBACK (tearoff_activate
), 0);
2565 for (item
= data
; item
; item
= item
->next
)
2569 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2570 && !menu_separator_name_p (item
->name
))
2573 /* A title for a popup. We do the same as GTK does when
2574 creating titles, but it does not look good. */
2576 utf8_label
= get_utf8_string (item
->name
);
2578 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2579 w
= gtk_menu_item_new_with_label (utf8_label
);
2580 gtk_widget_set_sensitive (w
, FALSE
);
2581 if (utf8_label
) g_free (utf8_label
);
2583 else if (menu_separator_name_p (item
->name
))
2586 /* GTK only have one separator type. */
2587 w
= gtk_separator_menu_item_new ();
2591 w
= xg_create_one_menuitem (item
,
2593 item
->contents
? 0 : select_cb
,
2598 /* Create a possibly empty submenu for menu bar items, since some
2599 themes don't highlight items correctly without it. */
2600 if (item
->contents
|| menu_bar_p
)
2602 GtkWidget
*submenu
= create_menus (item
->contents
,
2613 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2617 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2618 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2624 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2625 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2626 with some text and buttons.
2627 F is the frame the created item belongs to.
2628 NAME is the name to use for the top widget.
2629 VAL is a widget_value structure describing items to be created.
2630 SELECT_CB is the callback to use when a menu item is selected or
2631 a dialog button is pressed.
2632 DEACTIVATE_CB is the callback to use when an item is deactivated.
2633 For a menu, when a sub menu is not shown anymore, for a dialog it is
2634 called when the dialog is popped down.
2635 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2637 Returns the widget created. */
2640 xg_create_widget (const char *type
, const char *name
, struct frame
*f
,
2641 widget_value
*val
, GCallback select_cb
,
2642 GCallback deactivate_cb
, GCallback highlight_cb
)
2645 bool menu_bar_p
= strcmp (type
, "menubar") == 0;
2646 bool pop_up_p
= strcmp (type
, "popup") == 0;
2648 if (strcmp (type
, "dialog") == 0)
2650 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2651 xg_set_screen (w
, f
);
2652 gtk_window_set_transient_for (GTK_WINDOW (w
),
2653 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2654 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2655 gtk_widget_set_name (w
, "emacs-dialog");
2656 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2658 else if (menu_bar_p
|| pop_up_p
)
2660 w
= create_menus (val
->contents
,
2672 /* Set the cursor to an arrow for popup menus when they are mapped.
2673 This is done by default for menu bar menus. */
2676 /* Must realize so the GdkWindow inside the widget is created. */
2677 gtk_widget_realize (w
);
2678 xg_set_cursor (w
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
2683 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2690 /* Return the label for menu item WITEM. */
2693 xg_get_menu_item_label (GtkMenuItem
*witem
)
2695 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2696 return gtk_label_get_label (wlabel
);
2699 /* Return true if the menu item WITEM has the text LABEL. */
2702 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2705 char *utf8_label
= get_utf8_string (label
);
2706 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2708 if (! old_label
&& ! utf8_label
)
2710 else if (old_label
&& utf8_label
)
2711 is_same
= strcmp (utf8_label
, old_label
) == 0;
2713 if (utf8_label
) g_free (utf8_label
);
2718 /* Destroy widgets in LIST. */
2721 xg_destroy_widgets (GList
*list
)
2725 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2727 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2729 /* Destroying the widget will remove it from the container it is in. */
2730 gtk_widget_destroy (w
);
2734 /* Update the top level names in MENUBAR (i.e. not submenus).
2735 F is the frame the menu bar belongs to.
2736 *LIST is a list with the current menu bar names (menu item widgets).
2737 ITER is the item within *LIST that shall be updated.
2738 POS is the numerical position, starting at 0, of ITER in *LIST.
2739 VAL describes what the menu bar shall look like after the update.
2740 SELECT_CB is the callback to use when a menu item is selected.
2741 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2742 CL_DATA points to the callback data to be used for this menu bar.
2744 This function calls itself to walk through the menu bar names. */
2747 xg_update_menubar (GtkWidget
*menubar
,
2753 GCallback select_cb
,
2754 GCallback deactivate_cb
,
2755 GCallback highlight_cb
,
2756 xg_menu_cb_data
*cl_data
)
2758 if (! iter
&& ! val
)
2760 else if (iter
&& ! val
)
2762 /* Item(s) have been removed. Remove all remaining items. */
2763 xg_destroy_widgets (iter
);
2765 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2766 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2767 gtk_menu_item_new_with_label (""),
2773 else if (! iter
&& val
)
2775 /* Item(s) added. Add all new items in one call. */
2776 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2777 0, 1, 0, menubar
, cl_data
, 0);
2783 /* Below this neither iter or val is NULL */
2784 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2786 /* This item is still the same, check next item. */
2788 iter
= g_list_next (iter
);
2791 else /* This item is changed. */
2793 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2794 GtkMenuItem
*witem2
= 0;
2795 bool val_in_menubar
= 0;
2796 bool iter_in_new_menubar
= 0;
2800 /* See if the changed entry (val) is present later in the menu bar */
2802 iter2
&& ! val_in_menubar
;
2803 iter2
= g_list_next (iter2
))
2805 witem2
= GTK_MENU_ITEM (iter2
->data
);
2806 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2809 /* See if the current entry (iter) is present later in the
2810 specification for the new menu bar. */
2811 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2812 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2814 if (val_in_menubar
&& ! iter_in_new_menubar
)
2818 /* This corresponds to:
2823 g_object_ref (G_OBJECT (witem
));
2824 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2825 gtk_widget_destroy (GTK_WIDGET (witem
));
2827 /* Must get new list since the old changed. */
2828 g_list_free (*list
);
2829 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2830 while (nr
-- > 0) iter
= g_list_next (iter
);
2832 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2834 /* This corresponds to:
2837 Rename B to X. This might seem to be a strange thing to do,
2838 since if there is a menu under B it will be totally wrong for X.
2839 But consider editing a C file. Then there is a C-mode menu
2840 (corresponds to B above).
2841 If then doing C-x C-f the minibuf menu (X above) replaces the
2842 C-mode menu. When returning from the minibuffer, we get
2843 back the C-mode menu. Thus we do:
2844 Rename B to X (C-mode to minibuf menu)
2845 Rename X to B (minibuf to C-mode menu).
2846 If the X menu hasn't been invoked, the menu under B
2847 is up to date when leaving the minibuffer. */
2848 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2849 char *utf8_label
= get_utf8_string (val
->name
);
2850 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2852 /* GTK menu items don't notice when their labels have been
2853 changed from underneath them, so we have to explicitly
2854 use g_object_notify to tell listeners (e.g., a GMenuModel
2855 bridge that might be loaded) that the item's label has
2857 gtk_label_set_text (wlabel
, utf8_label
);
2858 g_object_notify (G_OBJECT (witem
), "label");
2860 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2861 /* If this item has a submenu that has been detached, change
2862 the title in the WM decorations also. */
2863 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2864 /* Set the title of the detached window. */
2865 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2868 if (utf8_label
) g_free (utf8_label
);
2869 iter
= g_list_next (iter
);
2873 else if (! val_in_menubar
&& iter_in_new_menubar
)
2875 /* This corresponds to:
2882 GtkWidget
*w
= xg_create_one_menuitem (val
,
2889 /* Create a possibly empty submenu for menu bar items, since some
2890 themes don't highlight items correctly without it. */
2891 GtkWidget
*submenu
= create_menus (NULL
, f
,
2892 select_cb
, deactivate_cb
,
2894 0, 0, 0, 0, cl_data
, 0);
2896 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2897 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2898 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2900 g_list_free (*list
);
2901 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2902 while (nr
-- > 0) iter
= g_list_next (iter
);
2903 iter
= g_list_next (iter
);
2907 else /* if (val_in_menubar && iter_in_new_menubar) */
2910 /* This corresponds to:
2915 g_object_ref (G_OBJECT (witem2
));
2916 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2917 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2918 GTK_WIDGET (witem2
), pos
);
2919 g_object_unref (G_OBJECT (witem2
));
2921 g_list_free (*list
);
2922 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2923 while (nr
-- > 0) iter
= g_list_next (iter
);
2924 if (iter
) iter
= g_list_next (iter
);
2930 /* Update the rest of the menu bar. */
2931 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2932 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2935 /* Update the menu item W so it corresponds to VAL.
2936 SELECT_CB is the callback to use when a menu item is selected.
2937 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2938 CL_DATA is the data to set in the widget for menu invocation. */
2941 xg_update_menu_item (widget_value
*val
,
2943 GCallback select_cb
,
2944 GCallback highlight_cb
,
2945 xg_menu_cb_data
*cl_data
)
2952 const char *old_label
= 0;
2953 const char *old_key
= 0;
2954 xg_menu_item_cb_data
*cb_data
;
2955 bool label_changed
= false;
2957 wchild
= XG_BIN_CHILD (w
);
2958 utf8_label
= get_utf8_string (val
->name
);
2959 utf8_key
= get_utf8_string (val
->key
);
2961 /* See if W is a menu item with a key. See make_menu_item above. */
2962 if (GTK_IS_BOX (wchild
))
2964 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2966 wlbl
= GTK_LABEL (list
->data
);
2967 wkey
= GTK_LABEL (list
->next
->data
);
2972 /* Remove the key and keep just the label. */
2973 g_object_ref (G_OBJECT (wlbl
));
2974 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2975 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2976 g_object_unref (G_OBJECT (wlbl
));
2981 else /* Just a label. */
2983 wlbl
= GTK_LABEL (wchild
);
2985 /* Check if there is now a key. */
2988 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2989 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2991 wlbl
= GTK_LABEL (list
->data
);
2992 wkey
= GTK_LABEL (list
->next
->data
);
2995 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2996 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
3000 if (wkey
) old_key
= gtk_label_get_label (wkey
);
3001 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
3003 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
3005 label_changed
= true;
3006 gtk_label_set_text (wkey
, utf8_key
);
3009 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
3011 label_changed
= true;
3012 gtk_label_set_text (wlbl
, utf8_label
);
3015 if (utf8_key
) g_free (utf8_key
);
3016 if (utf8_label
) g_free (utf8_label
);
3018 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
3019 gtk_widget_set_sensitive (w
, FALSE
);
3020 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
3021 gtk_widget_set_sensitive (w
, TRUE
);
3023 cb_data
= g_object_get_data (G_OBJECT (w
), XG_ITEM_DATA
);
3026 cb_data
->call_data
= val
->call_data
;
3027 cb_data
->help
= val
->help
;
3028 cb_data
->cl_data
= cl_data
;
3030 /* We assume the callback functions don't change. */
3031 if (val
->call_data
&& ! val
->contents
)
3033 /* This item shall have a select callback. */
3034 if (! cb_data
->select_id
)
3036 = g_signal_connect (G_OBJECT (w
), "activate",
3037 select_cb
, cb_data
);
3039 else if (cb_data
->select_id
)
3041 g_signal_handler_disconnect (w
, cb_data
->select_id
);
3042 cb_data
->select_id
= 0;
3046 if (label_changed
) /* See comment in xg_update_menubar. */
3047 g_object_notify (G_OBJECT (w
), "label");
3050 /* Update the toggle menu item W so it corresponds to VAL. */
3053 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
3055 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3058 /* Update the radio menu item W so it corresponds to VAL. */
3061 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
3063 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3066 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3067 SUBMENU may be NULL, in that case a new menu is created.
3068 F is the frame the menu bar belongs to.
3069 VAL describes the contents of the menu bar.
3070 SELECT_CB is the callback to use when a menu item is selected.
3071 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3072 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3073 CL_DATA is the call back data to use for any newly created items.
3075 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3079 xg_update_submenu (GtkWidget
*submenu
,
3082 GCallback select_cb
,
3083 GCallback deactivate_cb
,
3084 GCallback highlight_cb
,
3085 xg_menu_cb_data
*cl_data
)
3087 GtkWidget
*newsub
= submenu
;
3091 bool has_tearoff_p
= 0;
3092 GList
*first_radio
= 0;
3095 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3097 for (cur
= val
, iter
= list
;
3099 iter
= g_list_next (iter
), cur
= cur
->next
)
3101 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3103 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
3104 /* Skip tearoff items, they have no counterpart in val. */
3105 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
3108 iter
= g_list_next (iter
);
3109 if (iter
) w
= GTK_WIDGET (iter
->data
);
3114 /* Remember first radio button in a group. If we get a mismatch in
3115 a radio group we must rebuild the whole group so that the connections
3116 in GTK becomes correct. */
3117 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3119 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3120 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3123 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3125 if (! menu_separator_name_p (cur
->name
))
3128 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3130 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3132 xg_update_toggle_item (cur
, w
);
3133 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3135 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3137 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3139 xg_update_radio_item (cur
, w
);
3140 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3142 else if (GTK_IS_MENU_ITEM (w
))
3144 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3147 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3148 menu_separator_name_p (cur
->name
))
3151 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3153 sub
= gtk_menu_item_get_submenu (witem
);
3154 if (sub
&& ! cur
->contents
)
3156 /* Not a submenu anymore. */
3157 g_object_ref (G_OBJECT (sub
));
3158 remove_submenu (witem
);
3159 gtk_widget_destroy (sub
);
3161 else if (cur
->contents
)
3165 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3166 select_cb
, deactivate_cb
,
3167 highlight_cb
, cl_data
);
3169 /* If this item just became a submenu, we must set it. */
3171 gtk_menu_item_set_submenu (witem
, nsub
);
3176 /* Structural difference. Remove everything from here and down
3182 /* Remove widgets from first structural change. */
3185 /* If we are adding new menu items below, we must remove from
3186 first radio button so that radio groups become correct. */
3187 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3188 else xg_destroy_widgets (iter
);
3193 /* More items added. Create them. */
3194 newsub
= create_menus (cur
,
3207 if (list
) g_list_free (list
);
3212 /* Update the MENUBAR.
3213 F is the frame the menu bar belongs to.
3214 VAL describes the contents of the menu bar.
3215 If DEEP_P, rebuild all but the top level menu names in
3216 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3217 SELECT_CB is the callback to use when a menu item is selected.
3218 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3219 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3222 xg_modify_menubar_widgets (GtkWidget
*menubar
, struct frame
*f
,
3223 widget_value
*val
, bool deep_p
,
3224 GCallback select_cb
, GCallback deactivate_cb
,
3225 GCallback highlight_cb
)
3227 xg_menu_cb_data
*cl_data
;
3228 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3232 cl_data
= g_object_get_data (G_OBJECT (menubar
), XG_FRAME_DATA
);
3234 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3235 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3241 /* Update all sub menus.
3242 We must keep the submenus (GTK menu item widgets) since the
3243 X Window in the XEvent that activates the menu are those widgets. */
3245 /* Update cl_data, menu_item things in F may have changed. */
3246 update_cl_data (cl_data
, f
, highlight_cb
);
3248 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3253 GtkMenuItem
*witem
= 0;
3255 /* Find sub menu that corresponds to val and update it. */
3256 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3258 witem
= GTK_MENU_ITEM (iter
->data
);
3259 if (xg_item_label_same_p (witem
, cur
->name
))
3261 sub
= gtk_menu_item_get_submenu (witem
);
3266 newsub
= xg_update_submenu (sub
,
3273 /* sub may still be NULL. If we just updated non deep and added
3274 a new menu bar item, it has no sub menu yet. So we set the
3275 newly created sub menu under witem. */
3276 if (newsub
!= sub
&& witem
!= 0)
3278 xg_set_screen (newsub
, f
);
3279 gtk_menu_item_set_submenu (witem
, newsub
);
3285 gtk_widget_show_all (menubar
);
3288 /* Callback called when the menu bar W is mapped.
3289 Used to find the height of the menu bar if we didn't get it
3290 after showing the widget. */
3293 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3296 struct frame
*f
= user_data
;
3297 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3298 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3300 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3301 xg_height_or_width_changed (f
);
3305 /* Recompute all the widgets of frame F, when the menu bar has been
3309 xg_update_frame_menubar (struct frame
*f
)
3311 struct x_output
*x
= f
->output_data
.x
;
3314 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3317 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3318 return; /* Already done this, happens for frames created invisible. */
3322 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3324 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3326 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3327 gtk_widget_show_all (x
->menubar_widget
);
3328 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3330 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3332 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3333 xg_height_or_width_changed (f
);
3338 /* Get rid of the menu bar of frame F, and free its storage.
3339 This is used when deleting a frame, and when turning off the menu bar. */
3342 free_frame_menubar (struct frame
*f
)
3344 struct x_output
*x
= f
->output_data
.x
;
3346 if (x
->menubar_widget
)
3350 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3351 /* The menubar and its children shall be deleted when removed from
3353 x
->menubar_widget
= 0;
3354 FRAME_MENUBAR_HEIGHT (f
) = 0;
3355 xg_height_or_width_changed (f
);
3361 xg_event_is_for_menubar (struct frame
*f
, const XEvent
*event
)
3363 struct x_output
*x
= f
->output_data
.x
;
3372 if (! x
->menubar_widget
) return 0;
3374 if (! (event
->xbutton
.x
>= 0
3375 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3376 && event
->xbutton
.y
>= 0
3377 && event
->xbutton
.y
< FRAME_MENUBAR_HEIGHT (f
)
3378 && event
->xbutton
.same_screen
))
3381 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3382 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3384 gevent
.any
.window
= gw
;
3385 gevent
.any
.type
= GDK_NOTHING
;
3386 gwdesc
= gtk_get_event_widget (&gevent
);
3387 if (! gwdesc
) return 0;
3388 if (! GTK_IS_MENU_BAR (gwdesc
)
3389 && ! GTK_IS_MENU_ITEM (gwdesc
)
3390 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3393 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3394 if (! list
) return 0;
3395 rec
.x
= event
->xbutton
.x
;
3396 rec
.y
= event
->xbutton
.y
;
3400 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3402 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3403 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3412 /***********************************************************************
3413 Scroll bar functions
3414 ***********************************************************************/
3417 /* Setting scroll bar values invokes the callback. Use this variable
3418 to indicate that callback should do nothing. */
3420 bool xg_ignore_gtk_scrollbar
;
3422 /* The width of the scroll bar for the current theme. */
3424 static int scroll_bar_width_for_theme
;
3426 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3427 may be larger than 32 bits. Keep a mapping from integer index to widget
3428 pointers to get around the 32 bit limitation. */
3432 GtkWidget
**widgets
;
3437 /* Grow this much every time we need to allocate more */
3439 #define ID_TO_WIDGET_INCR 32
3441 /* Store the widget pointer W in id_to_widget and return the integer index. */
3444 xg_store_widget_in_map (GtkWidget
*w
)
3448 if (id_to_widget
.max_size
== id_to_widget
.used
)
3451 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3452 memory_full (SIZE_MAX
);
3454 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3455 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3456 new_size
, sizeof (GtkWidget
*));
3458 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3459 id_to_widget
.widgets
[i
] = 0;
3460 id_to_widget
.max_size
= new_size
;
3463 /* Just loop over the array and find a free place. After all,
3464 how many scroll bars are we creating? Should be a small number.
3465 The check above guarantees we will find a free place. */
3466 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3468 if (! id_to_widget
.widgets
[i
])
3470 id_to_widget
.widgets
[i
] = w
;
3471 ++id_to_widget
.used
;
3477 /* Should never end up here */
3481 /* Remove pointer at IDX from id_to_widget.
3482 Called when scroll bar is destroyed. */
3485 xg_remove_widget_from_map (ptrdiff_t idx
)
3487 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3489 id_to_widget
.widgets
[idx
] = 0;
3490 --id_to_widget
.used
;
3494 /* Get the widget pointer at IDX from id_to_widget. */
3497 xg_get_widget_from_map (ptrdiff_t idx
)
3499 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3500 return id_to_widget
.widgets
[idx
];
3506 update_theme_scrollbar_width (void)
3509 GtkAdjustment
*vadj
;
3516 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3517 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3518 g_object_ref_sink (G_OBJECT (wscroll
));
3519 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3520 gtk_widget_destroy (wscroll
);
3521 g_object_unref (G_OBJECT (wscroll
));
3524 scroll_bar_width_for_theme
= w
;
3528 xg_get_default_scrollbar_width (void)
3530 return scroll_bar_width_for_theme
;
3533 /* Return the scrollbar id for X Window WID on display DPY.
3534 Return -1 if WID not in id_to_widget. */
3537 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3542 w
= xg_win_to_widget (dpy
, wid
);
3546 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3547 if (id_to_widget
.widgets
[idx
] == w
)
3554 /* Callback invoked when scroll bar WIDGET is destroyed.
3555 DATA is the index into id_to_widget for WIDGET.
3556 We free pointer to last scroll bar values here and remove the index. */
3559 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3561 intptr_t id
= (intptr_t) data
;
3562 xg_remove_widget_from_map (id
);
3565 /* Create a scroll bar widget for frame F. Store the scroll bar
3567 SCROLL_CALLBACK is the callback to invoke when the value of the
3569 END_CALLBACK is the callback to invoke when scrolling ends.
3570 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3571 to set resources for the widget. */
3574 xg_create_scroll_bar (struct frame
*f
,
3575 struct scroll_bar
*bar
,
3576 GCallback scroll_callback
,
3577 GCallback end_callback
,
3578 const char *scroll_bar_name
)
3584 GtkAdjustment
*vadj
;
3589 /* Page, step increment values are not so important here, they
3590 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3591 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3594 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3595 webox
= gtk_event_box_new ();
3596 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3598 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3600 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3602 scroll_id
= xg_store_widget_in_map (wscroll
);
3604 g_signal_connect (G_OBJECT (wscroll
),
3606 G_CALLBACK (xg_gtk_scroll_destroy
),
3607 (gpointer
) scroll_id
);
3608 g_signal_connect (G_OBJECT (wscroll
),
3612 g_signal_connect (G_OBJECT (wscroll
),
3613 "button-release-event",
3617 /* The scroll bar widget does not draw on a window of its own. Instead
3618 it draws on the parent window, in this case the edit widget. So
3619 whenever the edit widget is cleared, the scroll bar needs to redraw
3620 also, which causes flicker. Put an event box between the edit widget
3621 and the scroll bar, so the scroll bar instead draws itself on the
3622 event box window. */
3623 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3624 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3627 /* Set the cursor to an arrow. */
3628 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3630 bar
->x_window
= scroll_id
;
3633 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3636 xg_remove_scroll_bar (struct frame
*f
, ptrdiff_t scrollbar_id
)
3638 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3641 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3642 gtk_widget_destroy (w
);
3643 gtk_widget_destroy (wparent
);
3644 SET_FRAME_GARBAGED (f
);
3648 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3650 TOP/LEFT are the new pixel positions where the bar shall appear.
3651 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3654 xg_update_scrollbar_pos (struct frame
*f
,
3655 ptrdiff_t scrollbar_id
,
3662 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3666 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3667 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3670 /* Clear out old position. */
3671 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3672 if (gtk_widget_get_parent (wparent
) == wfixed
)
3674 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3675 "x", &oldx
, "y", &oldy
, NULL
);
3676 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3679 /* Move and resize to new values. */
3680 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3681 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3684 /* No room. Hide scroll bar as some themes output a warning if
3685 the height is less than the min size. */
3686 gtk_widget_hide (wparent
);
3687 gtk_widget_hide (wscroll
);
3691 gtk_widget_show_all (wparent
);
3692 gtk_widget_set_size_request (wscroll
, width
, height
);
3694 gtk_widget_queue_draw (wfixed
);
3695 gdk_window_process_all_updates ();
3696 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3697 /* Clear under old scroll bar position. This must be done after
3698 the gtk_widget_queue_draw and gdk_window_process_all_updates
3700 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3701 oldx
, oldy
, oldw
, oldh
);
3703 /* GTK does not redraw until the main loop is entered again, but
3704 if there are no X events pending we will not enter it. So we sync
3705 here to get some events. */
3708 SET_FRAME_GARBAGED (f
);
3709 cancel_mouse_face (f
);
3713 /* Get the current value of the range, truncated to an integer. */
3716 int_gtk_range_get_value (GtkRange
*range
)
3718 return gtk_range_get_value (range
);
3722 /* Set the thumb size and position of scroll bar BAR. We are currently
3723 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3726 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3731 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3733 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3735 if (wscroll
&& bar
->dragging
== -1)
3745 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3747 if (scroll_bar_adjust_thumb_portion_p
)
3749 /* We do the same as for MOTIF in xterm.c, use 30 chars per
3750 line rather than the real portion value. This makes the
3751 thumb less likely to resize and that looks better. */
3752 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3754 /* When the thumb is at the bottom, position == whole.
3755 So we need to increase `whole' to make space for the thumb. */
3763 top
= (gdouble
) position
/ whole
;
3764 shown
= (gdouble
) portion
/ whole
;
3767 size
= clip_to_bounds (1, shown
* XG_SB_RANGE
, XG_SB_RANGE
);
3768 value
= clip_to_bounds (XG_SB_MIN
, top
* XG_SB_RANGE
, XG_SB_MAX
- size
);
3770 /* Assume all lines are of equal size. */
3771 new_step
= size
/ max (1, FRAME_LINES (f
));
3773 old_size
= gtk_adjustment_get_page_size (adj
);
3774 if (old_size
!= size
)
3776 int old_step
= gtk_adjustment_get_step_increment (adj
);
3777 if (old_step
!= new_step
)
3779 gtk_adjustment_set_page_size (adj
, size
);
3780 gtk_adjustment_set_step_increment (adj
, new_step
);
3781 /* Assume a page increment is about 95% of the page size */
3782 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3787 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3791 /* gtk_range_set_value invokes the callback. Set
3792 ignore_gtk_scrollbar to make the callback do nothing */
3793 xg_ignore_gtk_scrollbar
= 1;
3795 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3796 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3798 gtk_adjustment_changed (adj
);
3800 xg_ignore_gtk_scrollbar
= 0;
3807 /* Return true if EVENT is for a scroll bar in frame F.
3808 When the same X window is used for several Gtk+ widgets, we cannot
3809 say for sure based on the X window alone if an event is for the
3810 frame. This function does additional checks. */
3813 xg_event_is_for_scrollbar (struct frame
*f
, const XEvent
*event
)
3817 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3819 /* Check if press occurred outside the edit widget. */
3820 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3823 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
3824 (gdk_display_get_device_manager (gdpy
));
3825 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
3827 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
3829 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3832 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3833 || event
->type
== MotionNotify
))
3835 /* If we are releasing or moving the scroll bar, it has the grab. */
3836 GtkWidget
*w
= gtk_grab_get_current ();
3837 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3845 /***********************************************************************
3847 ***********************************************************************/
3848 /* The key for the data we put in the GtkImage widgets. The data is
3849 the image used by Emacs. We use this to see if we need to update
3850 the GtkImage with a new image. */
3851 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3853 /* The key for storing the latest modifiers so the activate callback can
3855 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3857 /* The key for storing the button widget in its proxy menu item. */
3858 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3860 /* The key for the data we put in the GtkImage widgets. The data is
3861 the stock name used by Emacs. We use this to see if we need to update
3862 the GtkImage with a new image. */
3863 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3865 /* As above, but this is used for named theme widgets, as opposed to
3867 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3869 /* Callback function invoked when a tool bar item is pressed.
3870 W is the button widget in the tool bar that got pressed,
3871 CLIENT_DATA is an integer that is the index of the button in the
3872 tool bar. 0 is the first button. */
3875 xg_tool_bar_button_cb (GtkWidget
*widget
,
3876 GdkEventButton
*event
,
3879 intptr_t state
= event
->state
;
3880 gpointer ptr
= (gpointer
) state
;
3881 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3886 /* Callback function invoked when a tool bar item is pressed.
3887 W is the button widget in the tool bar that got pressed,
3888 CLIENT_DATA is an integer that is the index of the button in the
3889 tool bar. 0 is the first button. */
3892 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3894 intptr_t idx
= (intptr_t) client_data
;
3895 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
3896 intptr_t mod
= (intptr_t) gmod
;
3898 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3899 Lisp_Object key
, frame
;
3900 struct input_event event
;
3903 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3906 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3908 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3909 XSETFRAME (frame
, f
);
3911 /* We generate two events here. The first one is to set the prefix
3912 to `(tool_bar)', see keyboard.c. */
3913 event
.kind
= TOOL_BAR_EVENT
;
3914 event
.frame_or_window
= frame
;
3916 kbd_buffer_store_event (&event
);
3918 event
.kind
= TOOL_BAR_EVENT
;
3919 event
.frame_or_window
= frame
;
3921 /* Convert between the modifier bits GDK uses and the modifier bits
3922 Emacs uses. This assumes GDK and X masks are the same, which they are when
3924 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), mod
);
3925 kbd_buffer_store_event (&event
);
3927 /* Return focus to the frame after we have clicked on a detached
3932 /* Callback function invoked when a tool bar item is pressed in a detached
3933 tool bar or the overflow drop down menu.
3934 We just call xg_tool_bar_callback.
3935 W is the menu item widget that got pressed,
3936 CLIENT_DATA is an integer that is the index of the button in the
3937 tool bar. 0 is the first button. */
3940 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3942 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3943 XG_TOOL_BAR_PROXY_BUTTON
));
3944 xg_tool_bar_callback (wbutton
, client_data
);
3949 xg_tool_bar_help_callback (GtkWidget
*w
,
3950 GdkEventCrossing
*event
,
3951 gpointer client_data
);
3953 /* This callback is called when a help is to be shown for an item in
3954 the detached tool bar when the detached tool bar it is not expanded. */
3957 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
3958 GdkEventCrossing
*event
,
3959 gpointer client_data
)
3961 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3962 XG_TOOL_BAR_PROXY_BUTTON
));
3964 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3968 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
3970 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
3971 GtkWidget
*c1
= clist
->data
;
3972 GtkWidget
*c2
= clist
->next
? clist
->next
->data
: NULL
;
3974 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
3975 g_list_free (clist
);
3976 return GTK_IS_LABEL (c1
) ? c1
: c2
;
3980 /* This callback is called when a tool item should create a proxy item,
3981 such as for the overflow menu. Also called when the tool bar is detached.
3982 If we don't create a proxy menu item, the detached tool bar will be
3986 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
3988 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
3989 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
3991 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
3992 GtkImage
*wimage
= GTK_IMAGE (c1
);
3993 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
3994 (wlbl
? gtk_label_get_text (wlbl
) : "");
3995 GtkWidget
*wmenuimage
;
3998 if (gtk_button_get_use_stock (wbutton
))
3999 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
4000 GTK_ICON_SIZE_MENU
);
4003 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
4004 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
4006 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
4008 if (store_type
== GTK_IMAGE_STOCK
)
4011 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
4012 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
4014 else if (store_type
== GTK_IMAGE_ICON_SET
)
4016 GtkIconSet
*icon_set
;
4017 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
4018 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
4019 GTK_ICON_SIZE_MENU
);
4021 else if (store_type
== GTK_IMAGE_PIXBUF
)
4026 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
4029 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
4031 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
4032 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
4033 GDK_INTERP_BILINEAR
);
4035 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
4039 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
4043 else if (store_type
== GTK_IMAGE_ICON_NAME
)
4045 const gchar
*icon_name
;
4046 GtkIconSize icon_size
;
4048 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
4049 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
4050 GTK_ICON_SIZE_MENU
);
4054 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
4059 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
4061 g_signal_connect (G_OBJECT (wmenuitem
),
4063 G_CALLBACK (xg_tool_bar_proxy_callback
),
4067 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
4068 (gpointer
) wbutton
);
4069 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
4070 gtk_widget_set_sensitive (wmenuitem
,
4071 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
4073 /* Use enter/leave notify to show help. We use the events
4074 rather than the GtkButton specific signals "enter" and
4075 "leave", so we can have only one callback. The event
4076 will tell us what kind of event it is. */
4077 g_signal_connect (G_OBJECT (wmenuitem
),
4078 "enter-notify-event",
4079 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4081 g_signal_connect (G_OBJECT (wmenuitem
),
4082 "leave-notify-event",
4083 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4089 /* This callback is called when a tool bar is detached. We must set
4090 the height of the tool bar to zero when this happens so frame sizes
4091 are correctly calculated.
4092 WBOX is the handle box widget that enables detach/attach of the tool bar.
4093 W is the tool bar widget.
4094 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4097 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
4099 gpointer client_data
)
4101 struct frame
*f
= client_data
;
4103 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
4108 GtkRequisition req
, req2
;
4110 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4111 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4112 req
.width
-= req2
.width
;
4113 req
.height
-= req2
.height
;
4114 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4115 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4116 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4117 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4118 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4119 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4120 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4121 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4122 xg_height_or_width_changed (f
);
4126 /* This callback is called when a tool bar is reattached. We must set
4127 the height of the tool bar when this happens so frame sizes
4128 are correctly calculated.
4129 WBOX is the handle box widget that enables detach/attach of the tool bar.
4130 W is the tool bar widget.
4131 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4134 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
4136 gpointer client_data
)
4138 struct frame
*f
= client_data
;
4139 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
4143 GtkRequisition req
, req2
;
4145 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4146 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4147 req
.width
+= req2
.width
;
4148 req
.height
+= req2
.height
;
4149 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4150 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4151 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4152 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4153 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4154 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4155 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4156 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4157 xg_height_or_width_changed (f
);
4161 /* This callback is called when the mouse enters or leaves a tool bar item.
4162 It is used for displaying and hiding the help text.
4163 W is the tool bar item, a button.
4164 EVENT is either an enter event or leave event.
4165 CLIENT_DATA is an integer that is the index of the button in the
4166 tool bar. 0 is the first button.
4168 Returns FALSE to tell GTK to keep processing this event. */
4171 xg_tool_bar_help_callback (GtkWidget
*w
,
4172 GdkEventCrossing
*event
,
4173 gpointer client_data
)
4175 intptr_t idx
= (intptr_t) client_data
;
4176 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4177 Lisp_Object help
, frame
;
4179 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4182 if (event
->type
== GDK_ENTER_NOTIFY
)
4184 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4185 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4188 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4193 XSETFRAME (frame
, f
);
4194 kbd_buffer_store_help_event (frame
, help
);
4200 /* This callback is called when a tool bar item shall be redrawn.
4201 It modifies the expose event so that the GtkImage widget redraws the
4202 whole image. This to overcome a bug that makes GtkImage draw the image
4203 in the wrong place when it tries to redraw just a part of the image.
4204 W is the GtkImage to be redrawn.
4205 EVENT is the expose event for W.
4206 CLIENT_DATA is unused.
4208 Returns FALSE to tell GTK to keep processing this event. */
4212 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4213 GdkEventExpose
*event
,
4214 gpointer client_data
)
4218 gdk_drawable_get_size (event
->window
, &width
, &height
);
4219 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4220 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4222 event
->area
.x
= max (0, event
->area
.x
);
4223 event
->area
.y
= max (0, event
->area
.y
);
4225 event
->area
.width
= max (width
, event
->area
.width
);
4226 event
->area
.height
= max (height
, event
->area
.height
);
4232 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4233 #define toolbar_set_orientation(w, o) \
4234 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4236 #define toolbar_set_orientation(w, o) \
4237 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4240 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4241 #define TOOLBAR_TOP_WIDGET(x) ((x)->handlebox_widget)
4243 #define TOOLBAR_TOP_WIDGET(x) ((x)->toolbar_widget)
4246 /* Attach a tool bar to frame F. */
4249 xg_pack_tool_bar (struct frame
*f
, Lisp_Object pos
)
4251 struct x_output
*x
= f
->output_data
.x
;
4252 bool into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4253 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4255 toolbar_set_orientation (x
->toolbar_widget
,
4257 ? GTK_ORIENTATION_VERTICAL
4258 : GTK_ORIENTATION_HORIZONTAL
);
4259 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4260 if (!x
->handlebox_widget
)
4262 top_widget
= x
->handlebox_widget
= gtk_handle_box_new ();
4263 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
4264 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
4265 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
4266 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
4267 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
4274 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4275 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4278 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), top_widget
,
4281 if (EQ (pos
, Qleft
))
4282 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4285 x
->toolbar_in_hbox
= true;
4289 bool vbox_pos
= x
->menubar_widget
!= 0;
4290 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4291 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4294 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), top_widget
,
4298 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4301 x
->toolbar_in_hbox
= false;
4303 x
->toolbar_is_packed
= true;
4306 static bool xg_update_tool_bar_sizes (struct frame
*f
);
4309 tb_size_cb (GtkWidget
*widget
,
4310 GdkRectangle
*allocation
,
4313 /* When tool bar is created it has one preferred size. But when size is
4314 allocated between widgets, it may get another. So we must update
4315 size hints if tool bar size changes. Seen on Fedora 18 at least. */
4316 struct frame
*f
= user_data
;
4317 if (xg_update_tool_bar_sizes (f
))
4318 xg_height_or_width_changed (f
);
4321 /* Create a tool bar for frame F. */
4324 xg_create_tool_bar (struct frame
*f
)
4326 struct x_output
*x
= f
->output_data
.x
;
4327 #if GTK_CHECK_VERSION (3, 3, 6)
4328 GtkStyleContext
*gsty
;
4330 struct xg_frame_tb_info
*tbinfo
4331 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4335 tbinfo
= xmalloc (sizeof (*tbinfo
));
4336 tbinfo
->last_tool_bar
= Qnil
;
4337 tbinfo
->style
= Qnil
;
4338 tbinfo
->hmargin
= tbinfo
->vmargin
= 0;
4339 tbinfo
->dir
= GTK_TEXT_DIR_NONE
;
4340 tbinfo
->n_last_items
= 0;
4341 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4346 x
->toolbar_widget
= gtk_toolbar_new ();
4348 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4350 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4351 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4352 g_signal_connect (x
->toolbar_widget
, "size-allocate",
4353 G_CALLBACK (tb_size_cb
), f
);
4354 #if GTK_CHECK_VERSION (3, 3, 6)
4355 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4356 gtk_style_context_add_class (gsty
, "primary-toolbar");
4361 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4363 /* Find the right-to-left image named by RTL in the tool bar images for F.
4364 Returns IMAGE if RTL is not found. */
4367 find_rtl_image (struct frame
*f
, Lisp_Object image
, Lisp_Object rtl
)
4370 Lisp_Object file
, rtl_name
;
4371 struct gcpro gcpro1
, gcpro2
;
4372 GCPRO2 (file
, rtl_name
);
4374 rtl_name
= Ffile_name_nondirectory (rtl
);
4376 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4378 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4379 if (!NILP (file
= file_for_image (rtl_image
)))
4381 file
= call1 (intern ("file-name-sans-extension"),
4382 Ffile_name_nondirectory (file
));
4383 if (! NILP (Fequal (file
, rtl_name
)))
4394 static GtkToolItem
*
4395 xg_make_tool_item (struct frame
*f
,
4397 GtkWidget
**wbutton
,
4399 int i
, bool horiz
, bool text_image
)
4401 GtkToolItem
*ti
= gtk_tool_item_new ();
4402 GtkWidget
*vb
= gtk_box_new (horiz
4403 ? GTK_ORIENTATION_HORIZONTAL
4404 : GTK_ORIENTATION_VERTICAL
,
4406 GtkWidget
*wb
= gtk_button_new ();
4407 /* The eventbox is here so we can have tooltips on disabled items. */
4408 GtkWidget
*weventbox
= gtk_event_box_new ();
4409 #if GTK_CHECK_VERSION (3, 3, 6)
4410 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4411 GtkStyleContext
*gsty
;
4413 gtk_css_provider_load_from_data (css_prov
,
4415 " background-color: transparent;"
4419 gsty
= gtk_widget_get_style_context (weventbox
);
4420 gtk_style_context_add_provider (gsty
,
4421 GTK_STYLE_PROVIDER (css_prov
),
4422 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4423 g_object_unref (css_prov
);
4426 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4428 if (wimage
&& !text_image
)
4429 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4431 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4432 if (wimage
&& text_image
)
4433 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4435 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4436 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4437 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4438 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4439 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4441 if (wimage
|| label
)
4444 gpointer gi
= (gpointer
) ii
;
4446 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4447 G_CALLBACK (xg_tool_bar_menu_proxy
),
4450 g_signal_connect (G_OBJECT (wb
), "clicked",
4451 G_CALLBACK (xg_tool_bar_callback
),
4454 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4457 /* Catch expose events to overcome an annoying redraw bug, see
4458 comment for xg_tool_bar_item_expose_callback. */
4459 g_signal_connect (G_OBJECT (ti
),
4461 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4464 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4466 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4467 no distinction based on modifiers in the activate callback,
4468 so we have to do it ourselves. */
4469 g_signal_connect (wb
, "button-release-event",
4470 G_CALLBACK (xg_tool_bar_button_cb
),
4473 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4475 /* Use enter/leave notify to show help. We use the events
4476 rather than the GtkButton specific signals "enter" and
4477 "leave", so we can have only one callback. The event
4478 will tell us what kind of event it is. */
4479 g_signal_connect (G_OBJECT (weventbox
),
4480 "enter-notify-event",
4481 G_CALLBACK (xg_tool_bar_help_callback
),
4483 g_signal_connect (G_OBJECT (weventbox
),
4484 "leave-notify-event",
4485 G_CALLBACK (xg_tool_bar_help_callback
),
4489 if (wbutton
) *wbutton
= wb
;
4495 is_box_type (GtkWidget
*vb
, bool is_horizontal
)
4499 if (GTK_IS_BOX (vb
))
4501 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4502 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4503 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4507 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4513 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4514 const char *icon_name
, const struct image
*img
,
4515 const char *label
, bool horiz
)
4519 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4520 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4522 /* Check if the tool icon matches. */
4523 if (stock_name
&& wimage
)
4525 old
= g_object_get_data (G_OBJECT (wimage
),
4526 XG_TOOL_BAR_STOCK_NAME
);
4527 if (!old
|| strcmp (old
, stock_name
))
4530 else if (icon_name
&& wimage
)
4532 old
= g_object_get_data (G_OBJECT (wimage
),
4533 XG_TOOL_BAR_ICON_NAME
);
4534 if (!old
|| strcmp (old
, icon_name
))
4539 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4540 XG_TOOL_BAR_IMAGE_DATA
);
4541 Pixmap old_img
= (Pixmap
) gold_img
;
4542 if (old_img
!= img
->pixmap
)
4546 /* Check button configuration and label. */
4547 if (is_box_type (vb
, horiz
)
4548 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4551 /* Ensure label is correct. */
4553 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4558 xg_update_tool_bar_sizes (struct frame
*f
)
4560 struct x_output
*x
= f
->output_data
.x
;
4562 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4563 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4565 gtk_widget_get_preferred_size (GTK_WIDGET (top_widget
), NULL
, &req
);
4566 if (x
->toolbar_in_hbox
)
4569 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4571 "position", &pos
, NULL
);
4572 if (pos
== 0) nl
= req
.width
;
4573 else nr
= req
.width
;
4578 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4580 "position", &pos
, NULL
);
4581 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4582 else nb
= req
.height
;
4585 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4586 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4587 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4588 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4590 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4591 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4592 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4593 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4594 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4595 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4603 /* Update the tool bar for frame F. Add new buttons and remove old. */
4606 update_frame_tool_bar (struct frame
*f
)
4609 struct x_output
*x
= f
->output_data
.x
;
4610 int hmargin
= 0, vmargin
= 0;
4611 GtkToolbar
*wtoolbar
;
4613 GtkTextDirection dir
;
4615 bool text_image
, horiz
;
4616 struct xg_frame_tb_info
*tbinfo
;
4618 if (! FRAME_GTK_WIDGET (f
))
4623 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4625 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4626 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4628 else if (CONSP (Vtool_bar_button_margin
))
4630 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4631 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4633 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4634 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4637 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4638 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4639 i.e. zero. This means that margins less than
4640 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4641 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4642 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4644 if (! x
->toolbar_widget
)
4645 xg_create_tool_bar (f
);
4647 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4648 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4650 style
= Ftool_bar_get_system_style ();
4652 /* Are we up to date? */
4653 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4656 if (! NILP (tbinfo
->last_tool_bar
) && ! NILP (f
->tool_bar_items
)
4657 && tbinfo
->n_last_items
== f
->n_tool_bar_items
4658 && tbinfo
->hmargin
== hmargin
&& tbinfo
->vmargin
== vmargin
4659 && tbinfo
->dir
== dir
4660 && ! NILP (Fequal (tbinfo
->style
, style
))
4661 && ! NILP (Fequal (tbinfo
->last_tool_bar
, f
->tool_bar_items
)))
4667 tbinfo
->last_tool_bar
= f
->tool_bar_items
;
4668 tbinfo
->n_last_items
= f
->n_tool_bar_items
;
4669 tbinfo
->style
= style
;
4670 tbinfo
->hmargin
= hmargin
;
4671 tbinfo
->vmargin
= vmargin
;
4674 text_image
= EQ (style
, Qtext_image_horiz
);
4675 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4677 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4679 bool enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4680 bool selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4684 struct image
*img
= NULL
;
4686 Lisp_Object stock
= Qnil
;
4687 GtkStockItem stock_item
;
4688 char *stock_name
= NULL
;
4689 char *icon_name
= NULL
;
4691 GtkWidget
*wbutton
= NULL
;
4692 Lisp_Object specified_file
;
4693 bool vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4695 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4696 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4697 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4700 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4702 /* If this is a separator, use a gtk separator item. */
4703 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4705 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4708 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4710 ti
= gtk_separator_tool_item_new ();
4711 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4717 /* Otherwise, the tool-bar item is an ordinary button. */
4719 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4721 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4725 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4727 /* Ignore invalid image specifications. */
4728 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4729 if (!valid_image_p (image
))
4732 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4737 specified_file
= file_for_image (image
);
4738 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4739 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4741 if (STRINGP (stock
))
4743 stock_name
= SSDATA (stock
);
4744 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4746 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4747 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4749 icon_name
= stock_name
+ 2;
4753 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4756 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4758 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4759 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4767 if (stock_name
== NULL
&& icon_name
== NULL
)
4769 /* No stock image, or stock item not known. Try regular
4770 image. If image is a vector, choose it according to the
4772 if (dir
== GTK_TEXT_DIR_RTL
4773 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4775 image
= find_rtl_image (f
, image
, rtl
);
4777 if (VECTORP (image
))
4781 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4782 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4785 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4786 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4788 eassert (ASIZE (image
) >= idx
);
4789 image
= AREF (image
, idx
);
4794 img_id
= lookup_image (f
, image
);
4795 img
= IMAGE_FROM_ID (f
, img_id
);
4796 prepare_image_for_display (f
, img
);
4798 if (img
->load_failed_p
|| img
->pixmap
== None
)
4801 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4807 /* If there is an existing widget, check if it's stale; if so,
4808 remove it and make a new tool item from scratch. */
4809 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4812 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4821 /* Save the image so we can see if an update is needed the
4822 next time we call xg_tool_item_match_p. */
4823 if (EQ (style
, Qtext
))
4825 else if (stock_name
)
4827 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4828 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4829 (gpointer
) xstrdup (stock_name
),
4830 (GDestroyNotify
) xfree
);
4834 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4835 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4836 (gpointer
) xstrdup (icon_name
),
4837 (GDestroyNotify
) xfree
);
4841 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4842 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4843 (gpointer
)img
->pixmap
);
4846 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4847 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4848 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4853 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4857 /* Remove buttons not longer needed. */
4860 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4862 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4863 } while (ti
!= NULL
);
4865 if (f
->n_tool_bar_items
!= 0)
4867 if (! x
->toolbar_is_packed
)
4868 xg_pack_tool_bar (f
, FRAME_TOOL_BAR_POSITION (f
));
4869 gtk_widget_show_all (TOOLBAR_TOP_WIDGET (x
));
4870 if (xg_update_tool_bar_sizes (f
))
4871 xg_height_or_width_changed (f
);
4877 /* Deallocate all resources for the tool bar on frame F.
4878 Remove the tool bar. */
4881 free_frame_tool_bar (struct frame
*f
)
4883 struct x_output
*x
= f
->output_data
.x
;
4885 if (x
->toolbar_widget
)
4887 struct xg_frame_tb_info
*tbinfo
;
4888 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4891 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4892 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4893 if (x
->toolbar_is_packed
)
4895 if (x
->toolbar_in_hbox
)
4896 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4899 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4903 gtk_widget_destroy (x
->toolbar_widget
);
4905 x
->toolbar_widget
= 0;
4906 TOOLBAR_TOP_WIDGET (x
) = 0;
4907 x
->toolbar_is_packed
= false;
4908 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4909 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4911 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4916 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4921 xg_height_or_width_changed (f
);
4928 xg_change_toolbar_position (struct frame
*f
, Lisp_Object pos
)
4930 struct x_output
*x
= f
->output_data
.x
;
4931 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4933 if (! x
->toolbar_widget
|| ! top_widget
)
4937 g_object_ref (top_widget
);
4938 if (x
->toolbar_is_packed
)
4940 if (x
->toolbar_in_hbox
)
4941 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4944 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4948 xg_pack_tool_bar (f
, pos
);
4949 g_object_unref (top_widget
);
4950 if (xg_update_tool_bar_sizes (f
))
4951 xg_height_or_width_changed (f
);
4958 /***********************************************************************
4960 ***********************************************************************/
4962 xg_initialize (void)
4964 GtkBindingSet
*binding_set
;
4965 GtkSettings
*settings
;
4968 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4969 we keep it permanently linked in. */
4974 xg_ignore_gtk_scrollbar
= 0;
4975 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
4976 xg_detached_menus
= 0;
4978 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4979 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4981 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4982 id_to_widget
.widgets
= 0;
4984 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
4985 (gdk_display_get_default ()));
4986 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4987 bindings. It doesn't seem to be any way to remove properties,
4988 so we set it to "" which in means "no key". */
4989 gtk_settings_set_string_property (settings
,
4990 "gtk-menu-bar-accel",
4994 /* Make GTK text input widgets use Emacs style keybindings. This is
4996 gtk_settings_set_string_property (settings
,
4997 "gtk-key-theme-name",
5001 /* Make dialogs close on C-g. Since file dialog inherits from
5002 dialog, this works for them also. */
5003 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
5004 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5007 /* Make menus close on C-g. */
5008 binding_set
= gtk_binding_set_by_class (g_type_class_ref
5009 (GTK_TYPE_MENU_SHELL
));
5010 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5012 update_theme_scrollbar_width ();
5014 #ifdef HAVE_FREETYPE
5015 x_last_font_name
= NULL
;
5019 #endif /* USE_GTK */