1 /* Functions for creating and updating GTK widgets.
3 Copyright (C) 2003-2013 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
30 #include "blockinput.h"
31 #include "syssignal.h"
34 #include "termhooks.h"
38 #include <gdk/gdkkeysyms.h>
39 #include "xsettings.h"
42 #include <X11/Xft/Xft.h>
47 #include "emacsgtkfixed.h"
50 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
51 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
53 #define FRAME_TOTAL_PIXEL_WIDTH(f) \
54 (FRAME_PIXEL_WIDTH (f) + FRAME_TOOLBAR_WIDTH (f))
56 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
57 #define gtk_widget_set_has_window(w, b) \
58 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
60 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
61 #define gtk_dialog_get_action_area(w) ((w)->action_area)
62 #define gtk_dialog_get_content_area(w) ((w)->vbox)
64 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
65 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
67 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
68 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
69 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
70 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
71 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
73 #if GTK_CHECK_VERSION (2, 12, 0)
74 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
76 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
79 #if GTK_CHECK_VERSION (3, 2, 0)
80 #define USE_NEW_GTK_FONT_CHOOSER 1
82 #define USE_NEW_GTK_FONT_CHOOSER 0
83 #define gtk_font_chooser_dialog_new(x, y) \
84 gtk_font_selection_dialog_new (x)
85 #undef GTK_FONT_CHOOSER
86 #define GTK_FONT_CHOOSER(x) GTK_FONT_SELECTION_DIALOG (x)
87 #define gtk_font_chooser_set_font(x, y) \
88 gtk_font_selection_dialog_set_font_name (x, y)
92 #ifdef USE_GTK_TOOLTIP
93 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
95 #define gdk_window_get_geometry(w, a, b, c, d) \
96 gdk_window_get_geometry (w, a, b, c, d, 0)
97 #define gdk_x11_window_lookup_for_display(d, w) \
98 gdk_xid_table_lookup_for_display (d, w)
99 #define gtk_box_new(ori, spacing) \
100 ((ori) == GTK_ORIENTATION_HORIZONTAL \
101 ? gtk_hbox_new (FALSE, (spacing)) : gtk_vbox_new (FALSE, (spacing)))
102 #define gtk_scrollbar_new(ori, spacing) \
103 ((ori) == GTK_ORIENTATION_HORIZONTAL \
104 ? gtk_hscrollbar_new ((spacing)) : gtk_vscrollbar_new ((spacing)))
106 #define GDK_KEY_g GDK_g
108 #endif /* HAVE_GTK3 */
110 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
112 static void update_theme_scrollbar_width (void);
114 #define TB_INFO_KEY "xg_frame_tb_info"
115 struct xg_frame_tb_info
117 Lisp_Object last_tool_bar
;
120 int hmargin
, vmargin
;
121 GtkTextDirection dir
;
125 /***********************************************************************
126 Display handling functions
127 ***********************************************************************/
129 /* Keep track of the default display, or NULL if there is none. Emacs
130 may close all its displays. */
132 static GdkDisplay
*gdpy_def
;
134 /* When the GTK widget W is to be created on a display for F that
135 is not the default display, set the display for W.
136 W can be a GtkMenu or a GtkWindow widget. */
139 xg_set_screen (GtkWidget
*w
, struct frame
*f
)
141 if (FRAME_X_DISPLAY (f
) != DEFAULT_GDK_DISPLAY ())
143 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
144 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
147 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
149 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
154 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
155 *DPY is set to NULL if the display can't be opened.
157 Returns non-zero if display could be opened, zero if display could not
158 be opened, and less than zero if the GTK version doesn't support
159 multiple displays. */
162 xg_display_open (char *display_name
, Display
**dpy
)
166 gdpy
= gdk_display_open (display_name
);
167 if (!gdpy_def
&& gdpy
)
170 gdk_display_manager_set_default_display (gdk_display_manager_get (),
174 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
178 /* Close display DPY. */
181 xg_display_close (Display
*dpy
)
183 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
185 /* If this is the default display, try to change it before closing.
186 If there is no other display to use, gdpy_def is set to NULL, and
187 the next call to xg_display_open resets the default display. */
188 if (gdk_display_get_default () == gdpy
)
190 struct x_display_info
*dpyinfo
;
191 GdkDisplay
*gdpy_new
= NULL
;
193 /* Find another display. */
194 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
195 if (dpyinfo
->display
!= dpy
)
197 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
198 gdk_display_manager_set_default_display (gdk_display_manager_get (),
205 #if GTK_CHECK_VERSION (2, 0, 0) && ! GTK_CHECK_VERSION (2, 10, 0)
206 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
207 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
208 can continue running, but there will be memory leaks. */
209 g_object_run_dispose (G_OBJECT (gdpy
));
211 /* This seems to be fixed in GTK 2.10. */
212 gdk_display_close (gdpy
);
217 /***********************************************************************
219 ***********************************************************************/
220 /* The next two variables and functions are taken from lwlib. */
221 static widget_value
*widget_value_free_list
;
222 static int malloc_cpt
;
224 /* Allocate a widget_value structure, either by taking one from the
225 widget_value_free_list or by malloc:ing a new one.
227 Return a pointer to the allocated structure. */
230 malloc_widget_value (void)
233 if (widget_value_free_list
)
235 wv
= widget_value_free_list
;
236 widget_value_free_list
= wv
->free_list
;
241 wv
= xmalloc (sizeof *wv
);
244 memset (wv
, 0, sizeof (widget_value
));
248 /* This is analogous to free. It frees only what was allocated
249 by malloc_widget_value, and no substructures. */
252 free_widget_value (widget_value
*wv
)
259 /* When the number of already allocated cells is too big,
266 wv
->free_list
= widget_value_free_list
;
267 widget_value_free_list
= wv
;
272 /* Create and return the cursor to be used for popup menus and
273 scroll bars on display DPY. */
276 xg_create_default_cursor (Display
*dpy
)
278 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
279 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
283 xg_get_pixbuf_from_pixmap (struct frame
*f
, Pixmap pix
)
288 unsigned int width
, height
, uunused
;
291 XGetGeometry (FRAME_X_DISPLAY (f
), pix
, &wunused
, &iunused
, &iunused
,
292 &width
, &height
, &uunused
, &uunused
);
294 xim
= XGetImage (FRAME_X_DISPLAY (f
), pix
, 0, 0, width
, height
,
298 tmp_buf
= gdk_pixbuf_new_from_data ((guchar
*) xim
->data
,
311 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
314 xg_get_pixbuf_from_pix_and_mask (struct frame
*f
,
319 GdkPixbuf
*icon_buf
, *tmp_buf
;
321 tmp_buf
= xg_get_pixbuf_from_pixmap (f
, pix
);
322 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
323 g_object_unref (G_OBJECT (tmp_buf
));
325 width
= gdk_pixbuf_get_width (icon_buf
);
326 height
= gdk_pixbuf_get_height (icon_buf
);
330 GdkPixbuf
*mask_buf
= xg_get_pixbuf_from_pixmap (f
, mask
);
331 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
332 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
333 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
334 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
337 for (y
= 0; y
< height
; ++y
)
339 guchar
*iconptr
, *maskptr
;
342 iconptr
= pixels
+ y
* rowstride
;
343 maskptr
= mask_pixels
+ y
* mask_rowstride
;
345 for (x
= 0; x
< width
; ++x
)
347 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
348 just R is sufficient. */
350 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
352 iconptr
+= rowstride
/width
;
353 maskptr
+= mask_rowstride
/width
;
357 g_object_unref (G_OBJECT (mask_buf
));
364 file_for_image (Lisp_Object image
)
366 Lisp_Object specified_file
= Qnil
;
369 for (tail
= XCDR (image
);
370 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
371 tail
= XCDR (XCDR (tail
)))
372 if (EQ (XCAR (tail
), QCfile
))
373 specified_file
= XCAR (XCDR (tail
));
375 return specified_file
;
378 /* For the image defined in IMG, make and return a GtkImage. For displays with
379 8 planes or less we must make a GdkPixbuf and apply the mask manually.
380 Otherwise the highlighting and dimming the tool bar code in GTK does
381 will look bad. For display with more than 8 planes we just use the
382 pixmap and mask directly. For monochrome displays, GTK doesn't seem
383 able to use external pixmaps, it looks bad whatever we do.
384 The image is defined on the display where frame F is.
385 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
386 If OLD_WIDGET is NULL, a new widget is constructed and returned.
387 If OLD_WIDGET is not NULL, that widget is modified. */
390 xg_get_image_for_pixmap (struct frame
*f
,
393 GtkImage
*old_widget
)
397 /* If we have a file, let GTK do all the image handling.
398 This seems to be the only way to make insensitive and activated icons
399 look good in all cases. */
400 Lisp_Object specified_file
= file_for_image (img
->spec
);
403 /* We already loaded the image once before calling this
404 function, so this only fails if the image file has been removed.
405 In that case, use the pixmap already loaded. */
407 if (STRINGP (specified_file
)
408 && STRINGP (file
= x_find_image_file (specified_file
)))
411 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
413 gtk_image_set_from_file (old_widget
, SSDATA (file
));
415 return GTK_WIDGET (old_widget
);
418 /* No file, do the image handling ourselves. This will look very bad
419 on a monochrome display, and sometimes bad on all displays with
422 /* This is a workaround to make icons look good on pseudo color
423 displays. Apparently GTK expects the images to have an alpha
424 channel. If they don't, insensitive and activated icons will
425 look bad. This workaround does not work on monochrome displays,
426 and is strictly not needed on true color/static color displays (i.e.
427 16 bits and higher). But we do it anyway so we get a pixbuf that is
428 not associated with the img->pixmap. The img->pixmap may be removed
429 by clearing the image cache and then the tool bar redraw fails, since
430 Gtk+ assumes the pixmap is always there. */
431 icon_buf
= xg_get_pixbuf_from_pix_and_mask (f
, img
->pixmap
, img
->mask
);
436 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
438 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
440 g_object_unref (G_OBJECT (icon_buf
));
443 return GTK_WIDGET (old_widget
);
447 /* Set CURSOR on W and all widgets W contain. We must do like this
448 for scroll bars and menu because they create widgets internally,
449 and it is those widgets that are visible. */
452 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
454 GdkWindow
*window
= gtk_widget_get_window (w
);
455 GList
*children
= gdk_window_peek_children (window
);
457 gdk_window_set_cursor (window
, cursor
);
459 /* The scroll bar widget has more than one GDK window (had to look at
460 the source to figure this out), and there is no way to set cursor
461 on widgets in GTK. So we must set the cursor for all GDK windows.
464 for ( ; children
; children
= g_list_next (children
))
465 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
468 /* Insert NODE into linked LIST. */
471 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
473 xg_list_node
*list_start
= list
->next
;
475 if (list_start
) list_start
->prev
= node
;
476 node
->next
= list_start
;
481 /* Remove NODE from linked LIST. */
484 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
486 xg_list_node
*list_start
= list
->next
;
487 if (node
== list_start
)
489 list
->next
= node
->next
;
490 if (list
->next
) list
->next
->prev
= 0;
494 node
->prev
->next
= node
->next
;
495 if (node
->next
) node
->next
->prev
= node
->prev
;
499 /* Allocate and return a utf8 version of STR. If STR is already
500 utf8 or NULL, just return a copy of STR.
501 A new string is allocated and the caller must free the result
505 get_utf8_string (const char *str
)
509 if (!str
) return NULL
;
511 /* If not UTF-8, try current locale. */
512 if (!g_utf8_validate (str
, -1, NULL
))
513 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
515 return g_strdup (str
);
519 /* Probably some control characters in str. Escape them. */
521 ptrdiff_t nr_bad
= 0;
524 unsigned char *p
= (unsigned char *)str
;
528 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
529 &bytes_written
, &err
))
530 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
533 p
+= bytes_written
+1;
546 if ((min (PTRDIFF_MAX
, SIZE_MAX
) - len
- 1) / 4 < nr_bad
)
547 memory_full (SIZE_MAX
);
548 up
= utf8_str
= xmalloc (len
+ nr_bad
* 4 + 1);
549 p
= (unsigned char *)str
;
551 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
552 &bytes_written
, &err
))
553 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
555 memcpy (up
, p
, bytes_written
);
556 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
557 up
+= bytes_written
+4;
558 p
+= bytes_written
+1;
565 strcat (utf8_str
, cp
);
577 /* Check for special colors used in face spec for region face.
578 The colors are fetched from the Gtk+ theme.
579 Return true if color was found, false if not. */
582 xg_check_special_colors (struct frame
*f
,
583 const char *color_name
,
587 bool get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
588 bool get_fg
= !get_bg
&& strcmp ("gtk_selection_fg_color", color_name
) == 0;
590 if (! FRAME_GTK_WIDGET (f
) || ! (get_bg
|| get_fg
))
596 GtkStyleContext
*gsty
597 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f
));
599 char buf
[sizeof "rgbi://" + 3 * (DBL_MAX_10_EXP
+ sizeof "-1.000000" - 1)];
600 int state
= GTK_STATE_FLAG_SELECTED
|GTK_STATE_FLAG_FOCUSED
;
602 gtk_style_context_get_color (gsty
, state
, &col
);
604 gtk_style_context_get_background_color (gsty
, state
, &col
);
606 sprintf (buf
, "rgbi:%lf/%lf/%lf", col
.red
, col
.green
, col
.blue
);
607 success_p
= (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
611 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
612 GdkColor
*grgb
= get_bg
613 ? &gsty
->bg
[GTK_STATE_SELECTED
]
614 : &gsty
->fg
[GTK_STATE_SELECTED
];
616 color
->red
= grgb
->red
;
617 color
->green
= grgb
->green
;
618 color
->blue
= grgb
->blue
;
619 color
->pixel
= grgb
->pixel
;
630 /***********************************************************************
632 ***********************************************************************/
633 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
634 We use that to pop down the tooltip. This happens if Gtk+ for some
635 reason wants to change or hide the tooltip. */
637 #ifdef USE_GTK_TOOLTIP
640 hierarchy_ch_cb (GtkWidget
*widget
,
641 GtkWidget
*previous_toplevel
,
644 struct frame
*f
= user_data
;
645 struct x_output
*x
= f
->output_data
.x
;
646 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
648 if (! top
|| ! GTK_IS_WINDOW (top
))
649 gtk_widget_hide (previous_toplevel
);
652 /* Callback called when Gtk+ thinks a tooltip should be displayed.
653 We use it to get the tooltip window and the tooltip widget so
654 we can manipulate the ourselves.
656 Return FALSE ensures that the tooltip is not shown. */
659 qttip_cb (GtkWidget
*widget
,
662 gboolean keyboard_mode
,
666 struct frame
*f
= user_data
;
667 struct x_output
*x
= f
->output_data
.x
;
668 if (x
->ttip_widget
== NULL
)
673 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
674 x
->ttip_widget
= tooltip
;
675 g_object_ref (G_OBJECT (tooltip
));
676 x
->ttip_lbl
= gtk_label_new ("");
677 g_object_ref (G_OBJECT (x
->ttip_lbl
));
678 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
679 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
681 /* Change stupid Gtk+ default line wrapping. */
682 p
= gtk_widget_get_parent (x
->ttip_lbl
);
683 list
= gtk_container_get_children (GTK_CONTAINER (p
));
684 for (iter
= list
; iter
; iter
= g_list_next (iter
))
686 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
687 if (GTK_IS_LABEL (w
))
688 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
692 /* ATK needs an empty title for some reason. */
693 gtk_window_set_title (x
->ttip_window
, "");
694 /* Realize so we can safely get screen later on. */
695 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
696 gtk_widget_realize (x
->ttip_lbl
);
698 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
699 G_CALLBACK (hierarchy_ch_cb
), f
);
704 #endif /* USE_GTK_TOOLTIP */
706 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
707 Return true if a system tooltip is available. */
710 xg_prepare_tooltip (struct frame
*f
,
715 #ifndef USE_GTK_TOOLTIP
718 struct x_output
*x
= f
->output_data
.x
;
722 GtkSettings
*settings
;
723 gboolean tt_enabled
= TRUE
;
725 Lisp_Object encoded_string
;
727 if (!x
->ttip_lbl
) return 0;
730 encoded_string
= ENCODE_UTF_8 (string
);
731 widget
= GTK_WIDGET (x
->ttip_lbl
);
732 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
733 screen
= gdk_window_get_screen (gwin
);
734 settings
= gtk_settings_get_for_screen (screen
);
735 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
738 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
739 /* Record that we disabled it so it can be enabled again. */
740 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
744 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
745 g_object_set_data (G_OBJECT
746 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
747 "gdk-display-current-tooltip", NULL
);
749 /* Put our dummy widget in so we can get callbacks for unrealize and
750 hierarchy-changed. */
751 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
752 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
753 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
754 if (width
) *width
= req
.width
;
755 if (height
) *height
= req
.height
;
760 #endif /* USE_GTK_TOOLTIP */
763 /* Show the tooltip at ROOT_X and ROOT_Y.
764 xg_prepare_tooltip must have been called before this function. */
767 xg_show_tooltip (struct frame
*f
, int root_x
, int root_y
)
769 #ifdef USE_GTK_TOOLTIP
770 struct x_output
*x
= f
->output_data
.x
;
774 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
775 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
781 /* Hide tooltip if shown. Do nothing if not shown.
782 Return true if tip was hidden, false if not (i.e. not using
786 xg_hide_tooltip (struct frame
*f
)
789 #ifdef USE_GTK_TOOLTIP
790 if (f
->output_data
.x
->ttip_window
)
792 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
794 gtk_widget_hide (GTK_WIDGET (win
));
796 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
798 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
799 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
800 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
801 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
812 /***********************************************************************
813 General functions for creating widgets, resizing, events, e.t.c.
814 ***********************************************************************/
817 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
818 const gchar
*msg
, gpointer user_data
)
820 if (!strstr (msg
, "visible children"))
821 fprintf (stderr
, "XX %s-WARNING **: %s\n", log_domain
, msg
);
824 /* Make a geometry string and pass that to GTK. It seems this is the
825 only way to get geometry position right if the user explicitly
826 asked for a position when starting Emacs.
827 F is the frame we shall set geometry for. */
830 xg_set_geometry (struct frame
*f
)
832 if (f
->size_hint_flags
& (USPosition
| PPosition
))
834 int left
= f
->left_pos
;
835 int xneg
= f
->size_hint_flags
& XNegative
;
836 int top
= f
->top_pos
;
837 int yneg
= f
->size_hint_flags
& YNegative
;
838 char geom_str
[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
846 sprintf (geom_str
, "=%dx%d%c%d%c%d",
847 FRAME_PIXEL_WIDTH (f
),
848 FRAME_PIXEL_HEIGHT (f
),
849 (xneg
? '-' : '+'), left
,
850 (yneg
? '-' : '+'), top
);
852 /* Silence warning about visible children. */
853 id
= g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
854 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
856 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
858 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
860 g_log_remove_handler ("Gtk", id
);
864 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
865 and use a GtkFixed widget, this doesn't happen automatically. */
868 xg_clear_under_internal_border (struct frame
*f
)
870 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
872 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
873 gtk_widget_queue_draw (wfixed
);
874 gdk_window_process_all_updates ();
875 x_clear_area (FRAME_X_DISPLAY (f
),
878 FRAME_PIXEL_WIDTH (f
),
879 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
880 x_clear_area (FRAME_X_DISPLAY (f
),
883 FRAME_INTERNAL_BORDER_WIDTH (f
),
884 FRAME_PIXEL_HEIGHT (f
), 0);
885 x_clear_area (FRAME_X_DISPLAY (f
),
887 0, FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
888 FRAME_PIXEL_WIDTH (f
),
889 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
890 x_clear_area (FRAME_X_DISPLAY (f
),
892 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
894 FRAME_INTERNAL_BORDER_WIDTH (f
),
895 FRAME_PIXEL_HEIGHT (f
), 0);
899 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
900 and a Gtk+ menu bar, we get resize events for the edit part of the
901 frame only. We let Gtk+ deal with the Gtk+ parts.
902 F is the frame to resize.
903 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
906 xg_frame_resized (struct frame
*f
, int pixelwidth
, int pixelheight
)
910 if (pixelwidth
== -1 && pixelheight
== -1)
912 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
913 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
915 &pixelwidth
, &pixelheight
);
920 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
921 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
923 if (columns
!= FRAME_COLS (f
)
924 || rows
!= FRAME_LINES (f
)
925 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
926 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
928 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
929 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
931 xg_clear_under_internal_border (f
);
932 change_frame_size (f
, rows
, columns
, 0, 1, 0);
933 SET_FRAME_GARBAGED (f
);
934 cancel_mouse_face (f
);
938 /* Resize the outer window of frame F after changing the height.
939 COLUMNS/ROWS is the size the edit area shall have after the resize. */
942 xg_frame_set_char_size (struct frame
*f
, int cols
, int rows
)
944 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
945 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
948 if (FRAME_PIXEL_HEIGHT (f
) == 0)
951 /* Take into account the size of the scroll bar. Always use the
952 number of columns occupied by the scroll bar here otherwise we
953 might end up with a frame width that is not a multiple of the
954 frame's character width which is bad for vertically split
956 f
->scroll_bar_actual_width
957 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
959 compute_fringe_widths (f
, 0);
961 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
962 after calculating that value. */
963 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
)
964 + FRAME_TOOLBAR_WIDTH (f
);
967 /* Do this before resize, as we don't know yet if we will be resized. */
968 xg_clear_under_internal_border (f
);
970 /* Must resize our top level widget. Font size may have changed,
971 but not rows/cols. */
972 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
973 pixelwidth
, pixelheight
);
974 x_wm_set_size_hint (f
, 0, 0);
976 SET_FRAME_GARBAGED (f
);
977 cancel_mouse_face (f
);
979 /* We can not call change_frame_size for a mapped frame,
980 we can not set pixel width/height either. The window manager may
981 override our resize request, XMonad does this all the time.
982 The best we can do is try to sync, so lisp code sees the updated
983 size as fast as possible.
984 For unmapped windows, we can set rows/cols. When
985 the frame is mapped again we will (hopefully) get the correct size. */
986 if (FRAME_VISIBLE_P (f
))
988 /* Must call this to flush out events */
989 (void)gtk_events_pending ();
991 x_wait_for_event (f
, ConfigureNotify
);
995 change_frame_size (f
, rows
, cols
, 0, 1, 0);
996 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
997 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
1001 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
1002 The policy is to keep the number of editable lines. */
1005 xg_height_or_width_changed (struct frame
*f
)
1007 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1008 FRAME_TOTAL_PIXEL_WIDTH (f
),
1009 FRAME_TOTAL_PIXEL_HEIGHT (f
));
1010 f
->output_data
.x
->hint_flags
= 0;
1011 x_wm_set_size_hint (f
, 0, 0);
1014 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
1015 Must be done like this, because GtkWidget:s can have "hidden"
1016 X Window that aren't accessible.
1018 Return 0 if no widget match WDESC. */
1021 xg_win_to_widget (Display
*dpy
, Window wdesc
)
1024 GtkWidget
*gwdesc
= 0;
1028 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
1033 event
.any
.window
= gdkwin
;
1034 event
.any
.type
= GDK_NOTHING
;
1035 gwdesc
= gtk_get_event_widget (&event
);
1042 /* Set the background of widget W to PIXEL. */
1045 xg_set_widget_bg (struct frame
*f
, GtkWidget
*w
, long unsigned int pixel
)
1051 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
1053 bg
.red
= (double)xbg
.red
/65535.0;
1054 bg
.green
= (double)xbg
.green
/65535.0;
1055 bg
.blue
= (double)xbg
.blue
/65535.0;
1057 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
1061 GdkColormap
*map
= gtk_widget_get_colormap (w
);
1062 gdk_colormap_query_color (map
, pixel
, &bg
);
1063 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
1067 /* Callback called when the gtk theme changes.
1068 We notify lisp code so it can fix faces used for region for example. */
1071 style_changed_cb (GObject
*go
,
1075 struct input_event event
;
1076 GdkDisplay
*gdpy
= user_data
;
1077 const char *display_name
= gdk_display_get_name (gdpy
);
1078 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1081 event
.kind
= CONFIG_CHANGED_EVENT
;
1082 event
.frame_or_window
= build_string (display_name
);
1083 /* Theme doesn't change often, so intern is called seldom. */
1084 event
.arg
= intern ("theme-name");
1085 kbd_buffer_store_event (&event
);
1087 update_theme_scrollbar_width ();
1089 /* If scroll bar width changed, we need set the new size on all frames
1093 Lisp_Object rest
, frame
;
1094 FOR_EACH_FRAME (rest
, frame
)
1096 struct frame
*f
= XFRAME (frame
);
1097 if (FRAME_LIVE_P (f
)
1099 && FRAME_X_DISPLAY (f
) == dpy
)
1101 x_set_scroll_bar_default_width (f
);
1102 xg_frame_set_char_size (f
, FRAME_COLS (f
), FRAME_LINES (f
));
1108 /* Called when a delete-event occurs on WIDGET. */
1111 delete_cb (GtkWidget
*widget
,
1116 /* The event doesn't arrive in the normal event loop. Send event
1118 struct frame
*f
= user_data
;
1119 struct input_event ie
;
1122 ie
.kind
= DELETE_WINDOW_EVENT
;
1123 XSETFRAME (ie
.frame_or_window
, f
);
1124 kbd_buffer_store_event (&ie
);
1130 /* Create and set up the GTK widgets for frame F.
1131 Return true if creation succeeded. */
1134 xg_create_frame_widgets (struct frame
*f
)
1137 GtkWidget
*wvbox
, *whbox
;
1146 if (FRAME_X_EMBEDDED_P (f
))
1148 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1149 wtop
= gtk_plug_new_for_display (gdpy
, f
->output_data
.x
->parent_desc
);
1152 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1154 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1155 has backported it to Gtk+ 2.0 and they add the resize grip for
1156 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1157 forever, so disable the grip. */
1158 #if (! GTK_CHECK_VERSION (3, 0, 0) \
1159 && defined HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1160 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop
), FALSE
);
1163 xg_set_screen (wtop
, f
);
1165 wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1166 whbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1167 gtk_box_set_homogeneous (GTK_BOX (wvbox
), FALSE
);
1168 gtk_box_set_homogeneous (GTK_BOX (whbox
), FALSE
);
1171 wfixed
= emacs_fixed_new (f
);
1173 wfixed
= gtk_fixed_new ();
1176 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1178 if (wtop
) gtk_widget_destroy (wtop
);
1179 if (wvbox
) gtk_widget_destroy (wvbox
);
1180 if (whbox
) gtk_widget_destroy (whbox
);
1181 if (wfixed
) gtk_widget_destroy (wfixed
);
1187 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1188 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1189 gtk_widget_set_name (wvbox
, "pane");
1190 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1192 /* If this frame has a title or name, set it in the title bar. */
1193 if (! NILP (f
->title
))
1194 title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1195 else if (! NILP (f
->name
))
1196 title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1198 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1200 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1201 FRAME_GTK_WIDGET (f
) = wfixed
;
1202 f
->output_data
.x
->vbox_widget
= wvbox
;
1203 f
->output_data
.x
->hbox_widget
= whbox
;
1205 gtk_widget_set_has_window (wfixed
, TRUE
);
1207 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1208 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1209 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1211 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1212 update_frame_tool_bar (f
);
1214 /* We don't want this widget double buffered, because we draw on it
1215 with regular X drawing primitives, so from a GTK/GDK point of
1216 view, the widget is totally blank. When an expose comes, this
1217 will make the widget blank, and then Emacs redraws it. This flickers
1218 a lot, so we turn off double buffering. */
1219 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1221 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1222 SSDATA (Vx_resource_name
),
1223 SSDATA (Vx_resource_class
));
1225 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1226 GTK is to destroy the widget. We want Emacs to do that instead. */
1227 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1228 G_CALLBACK (delete_cb
), f
);
1230 /* Convert our geometry parameters into a geometry string
1232 GTK will itself handle calculating the real position this way. */
1233 xg_set_geometry (f
);
1235 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1237 gtk_widget_add_events (wfixed
,
1238 GDK_POINTER_MOTION_MASK
1240 | GDK_BUTTON_PRESS_MASK
1241 | GDK_BUTTON_RELEASE_MASK
1242 | GDK_KEY_PRESS_MASK
1243 | GDK_ENTER_NOTIFY_MASK
1244 | GDK_LEAVE_NOTIFY_MASK
1245 | GDK_FOCUS_CHANGE_MASK
1246 | GDK_STRUCTURE_MASK
1247 | GDK_VISIBILITY_NOTIFY_MASK
);
1249 /* Must realize the windows so the X window gets created. It is used
1250 by callers of this function. */
1251 gtk_widget_realize (wfixed
);
1252 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1254 /* Since GTK clears its window by filling with the background color,
1255 we must keep X and GTK background in sync. */
1256 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1259 /* Also, do not let any background pixmap to be set, this looks very
1260 bad as Emacs overwrites the background pixmap with its own idea
1261 of background color. */
1262 style
= gtk_widget_get_modifier_style (wfixed
);
1264 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1265 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1266 gtk_widget_modify_style (wfixed
, style
);
1268 gtk_widget_set_can_focus (wfixed
, TRUE
);
1269 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1272 #ifdef USE_GTK_TOOLTIP
1273 /* Steal a tool tip window we can move ourselves. */
1274 f
->output_data
.x
->ttip_widget
= 0;
1275 f
->output_data
.x
->ttip_lbl
= 0;
1276 f
->output_data
.x
->ttip_window
= 0;
1277 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1278 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1282 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1283 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1284 /* Only connect this signal once per screen. */
1285 if (! g_signal_handler_find (G_OBJECT (gs
),
1286 G_SIGNAL_MATCH_FUNC
,
1288 G_CALLBACK (style_changed_cb
),
1291 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1292 G_CALLBACK (style_changed_cb
),
1293 gdk_screen_get_display (screen
));
1303 xg_free_frame_widgets (struct frame
*f
)
1305 if (FRAME_GTK_OUTER_WIDGET (f
))
1307 #ifdef USE_GTK_TOOLTIP
1308 struct x_output
*x
= f
->output_data
.x
;
1310 struct xg_frame_tb_info
*tbinfo
1311 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
1316 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1317 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1318 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1319 #ifdef USE_GTK_TOOLTIP
1321 gtk_widget_destroy (x
->ttip_lbl
);
1323 g_object_unref (G_OBJECT (x
->ttip_widget
));
1328 /* Set the normal size hints for the window manager, for frame F.
1329 FLAGS is the flags word to use--or 0 meaning preserve the flags
1330 that the window now has.
1331 If USER_POSITION, set the User Position
1332 flag (this is useful when FLAGS is 0). */
1335 x_wm_set_size_hint (struct frame
*f
, long int flags
, bool user_position
)
1337 /* Must use GTK routines here, otherwise GTK resets the size hints
1338 to its own defaults. */
1339 GdkGeometry size_hints
;
1340 gint hint_flags
= 0;
1341 int base_width
, base_height
;
1342 int min_rows
= 0, min_cols
= 0;
1343 int win_gravity
= f
->win_gravity
;
1345 /* Don't set size hints during initialization; that apparently leads
1346 to a race condition. See the thread at
1347 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1348 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1353 memset (&size_hints
, 0, sizeof (size_hints
));
1354 f
->output_data
.x
->size_hints
= size_hints
;
1355 f
->output_data
.x
->hint_flags
= hint_flags
;
1358 flags
= f
->size_hint_flags
;
1360 size_hints
= f
->output_data
.x
->size_hints
;
1361 hint_flags
= f
->output_data
.x
->hint_flags
;
1363 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1364 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
1365 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
1367 hint_flags
|= GDK_HINT_BASE_SIZE
;
1368 /* Use one row/col here so base_height/width does not become zero.
1369 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1370 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 1) + FRAME_TOOLBAR_WIDTH (f
);
1371 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 1)
1372 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1374 check_frame_size (f
, &min_rows
, &min_cols
);
1375 if (min_cols
> 0) --min_cols
; /* We used one col in base_width = ... 1); */
1376 if (min_rows
> 0) --min_rows
; /* We used one row in base_height = ... 1); */
1378 size_hints
.base_width
= base_width
;
1379 size_hints
.base_height
= base_height
;
1380 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
1381 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
1383 /* These currently have a one to one mapping with the X values, but I
1384 don't think we should rely on that. */
1385 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1386 size_hints
.win_gravity
= 0;
1387 if (win_gravity
== NorthWestGravity
)
1388 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1389 else if (win_gravity
== NorthGravity
)
1390 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1391 else if (win_gravity
== NorthEastGravity
)
1392 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1393 else if (win_gravity
== WestGravity
)
1394 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1395 else if (win_gravity
== CenterGravity
)
1396 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1397 else if (win_gravity
== EastGravity
)
1398 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1399 else if (win_gravity
== SouthWestGravity
)
1400 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1401 else if (win_gravity
== SouthGravity
)
1402 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1403 else if (win_gravity
== SouthEastGravity
)
1404 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1405 else if (win_gravity
== StaticGravity
)
1406 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1410 hint_flags
&= ~GDK_HINT_POS
;
1411 hint_flags
|= GDK_HINT_USER_POS
;
1414 if (hint_flags
!= f
->output_data
.x
->hint_flags
1415 || memcmp (&size_hints
,
1416 &f
->output_data
.x
->size_hints
,
1417 sizeof (size_hints
)) != 0)
1420 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1421 NULL
, &size_hints
, hint_flags
);
1422 f
->output_data
.x
->size_hints
= size_hints
;
1423 f
->output_data
.x
->hint_flags
= hint_flags
;
1428 /* Change background color of a frame.
1429 Since GTK uses the background color to clear the window, we must
1430 keep the GTK and X colors in sync.
1431 F is the frame to change,
1432 BG is the pixel value to change to. */
1435 xg_set_background_color (struct frame
*f
, long unsigned int bg
)
1437 if (FRAME_GTK_WIDGET (f
))
1440 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1446 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1447 functions so GTK does not overwrite the icon. */
1450 xg_set_frame_icon (struct frame
*f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1452 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1456 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1461 /***********************************************************************
1463 ***********************************************************************/
1464 /* Return the dialog title to use for a dialog of type KEY.
1465 This is the encoding used by lwlib. We use the same for GTK. */
1468 get_dialog_title (char key
)
1470 const char *title
= "";
1478 title
= "Information";
1497 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1498 the dialog, but return TRUE so the event does not propagate further
1499 in GTK. This prevents GTK from destroying the dialog widget automatically
1500 and we can always destroy the widget manually, regardless of how
1501 it was popped down (button press or WM_DELETE_WINDOW).
1502 W is the dialog widget.
1503 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1504 user_data is NULL (not used).
1506 Returns TRUE to end propagation of event. */
1509 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1511 gtk_widget_unmap (w
);
1515 /* Create a popup dialog window. See also xg_create_widget below.
1516 WV is a widget_value describing the dialog.
1517 SELECT_CB is the callback to use when a button has been pressed.
1518 DEACTIVATE_CB is the callback to use when the dialog pops down.
1520 Returns the GTK dialog widget. */
1523 create_dialog (widget_value
*wv
,
1524 GCallback select_cb
,
1525 GCallback deactivate_cb
)
1527 const char *title
= get_dialog_title (wv
->name
[0]);
1528 int total_buttons
= wv
->name
[1] - '0';
1529 int right_buttons
= wv
->name
[4] - '0';
1532 int button_spacing
= 10;
1533 GtkWidget
*wdialog
= gtk_dialog_new ();
1534 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1535 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1537 GtkWidget
*whbox_down
;
1539 /* If the number of buttons is greater than 4, make two rows of buttons
1540 instead. This looks better. */
1541 bool make_two_rows
= total_buttons
> 4;
1543 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1544 left_buttons
= total_buttons
- right_buttons
;
1546 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1547 gtk_widget_set_name (wdialog
, "emacs-dialog");
1552 GtkWidget
*wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, button_spacing
);
1553 GtkWidget
*whbox_up
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1554 gtk_box_set_homogeneous (GTK_BOX (wvbox
), TRUE
);
1555 gtk_box_set_homogeneous (GTK_BOX (whbox_up
), FALSE
);
1556 whbox_down
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1557 gtk_box_set_homogeneous (GTK_BOX (whbox_down
), FALSE
);
1559 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1560 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1561 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1563 cur_box
= GTK_BOX (whbox_up
);
1566 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1567 G_CALLBACK (dialog_delete_callback
), 0);
1571 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1572 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1575 for (item
= wv
->contents
; item
; item
= item
->next
)
1577 char *utf8_label
= get_utf8_string (item
->value
);
1581 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1583 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1584 /* This is the text part of the dialog. */
1585 w
= gtk_label_new (utf8_label
);
1586 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1587 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1588 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1590 /* Try to make dialog look better. Must realize first so
1591 the widget can calculate the size it needs. */
1592 gtk_widget_realize (w
);
1593 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1594 gtk_box_set_spacing (wvbox
, req
.height
);
1595 if (item
->value
&& strlen (item
->value
) > 0)
1596 button_spacing
= 2*req
.width
/strlen (item
->value
);
1600 /* This is one button to add to the dialog. */
1601 w
= gtk_button_new_with_label (utf8_label
);
1602 if (! item
->enabled
)
1603 gtk_widget_set_sensitive (w
, FALSE
);
1605 g_signal_connect (G_OBJECT (w
), "clicked",
1606 select_cb
, item
->call_data
);
1608 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1609 if (++button_nr
== left_buttons
)
1612 cur_box
= GTK_BOX (whbox_down
);
1614 gtk_box_pack_start (cur_box
,
1622 g_free (utf8_label
);
1628 struct xg_dialog_data
1636 /* Function that is called when the file or font dialogs pop down.
1637 W is the dialog widget, RESPONSE is the response code.
1638 USER_DATA is what we passed in to g_signal_connect. */
1641 xg_dialog_response_cb (GtkDialog
*w
,
1645 struct xg_dialog_data
*dd
= user_data
;
1646 dd
->response
= response
;
1647 g_main_loop_quit (dd
->loop
);
1651 /* Destroy the dialog. This makes it pop down. */
1654 pop_down_dialog (void *arg
)
1656 struct xg_dialog_data
*dd
= arg
;
1659 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1660 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1662 g_main_loop_quit (dd
->loop
);
1663 g_main_loop_unref (dd
->loop
);
1668 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1669 We pass in DATA as gpointer* so we can use this as a callback. */
1672 xg_maybe_add_timer (gpointer data
)
1674 struct xg_dialog_data
*dd
= data
;
1675 EMACS_TIME next_time
= timer_check ();
1679 if (EMACS_TIME_VALID_P (next_time
))
1681 time_t s
= EMACS_SECS (next_time
);
1682 int per_ms
= EMACS_TIME_RESOLUTION
/ 1000;
1683 int ms
= (EMACS_NSECS (next_time
) + per_ms
- 1) / per_ms
;
1684 if (s
<= ((guint
) -1 - ms
) / 1000)
1685 dd
->timerid
= g_timeout_add (s
* 1000 + ms
, xg_maybe_add_timer
, dd
);
1691 /* Pops up a modal dialog W and waits for response.
1692 We don't use gtk_dialog_run because we want to process emacs timers.
1693 The dialog W is not destroyed when this function returns. */
1696 xg_dialog_run (struct frame
*f
, GtkWidget
*w
)
1698 ptrdiff_t count
= SPECPDL_INDEX ();
1699 struct xg_dialog_data dd
;
1701 xg_set_screen (w
, f
);
1702 gtk_window_set_transient_for (GTK_WINDOW (w
),
1703 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1704 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1705 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1707 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1708 dd
.response
= GTK_RESPONSE_CANCEL
;
1712 g_signal_connect (G_OBJECT (w
),
1714 G_CALLBACK (xg_dialog_response_cb
),
1716 /* Don't destroy the widget if closed by the window manager close button. */
1717 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1718 gtk_widget_show (w
);
1720 record_unwind_protect_ptr (pop_down_dialog
, &dd
);
1722 (void) xg_maybe_add_timer (&dd
);
1723 g_main_loop_run (dd
.loop
);
1726 unbind_to (count
, Qnil
);
1732 /***********************************************************************
1733 File dialog functions
1734 ***********************************************************************/
1735 /* Return true if the old file selection dialog is being used. */
1738 xg_uses_old_file_dialog (void)
1740 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1741 return x_gtk_use_old_file_dialog
;
1748 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1750 /* Return the selected file for file chooser dialog W.
1751 The returned string must be free:d. */
1754 xg_get_file_name_from_chooser (GtkWidget
*w
)
1756 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1759 /* Callback called when the "Show hidden files" toggle is pressed.
1760 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1763 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1765 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1767 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1768 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1772 /* Callback called when a property changes in a file chooser.
1773 GOBJECT is the file chooser dialog, ARG1 describes the property.
1774 USER_DATA is the toggle widget in the file chooser dialog.
1775 We use this to update the "Show hidden files" toggle when the user
1776 changes that property by right clicking in the file list. */
1779 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1781 if (strcmp (arg1
->name
, "show-hidden") == 0)
1783 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1784 gboolean visible
, toggle_on
;
1786 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1787 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1789 if (!!visible
!= !!toggle_on
)
1791 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1792 G_CALLBACK (xg_toggle_visibility_cb
),
1794 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1795 g_signal_handlers_unblock_by_func
1796 (G_OBJECT (wtoggle
),
1797 G_CALLBACK (xg_toggle_visibility_cb
),
1800 x_gtk_show_hidden_files
= visible
;
1804 /* Read a file name from the user using a file chooser dialog.
1805 F is the current frame.
1806 PROMPT is a prompt to show to the user. May not be NULL.
1807 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1808 If MUSTMATCH_P, the returned file name must be an existing
1809 file. (Actually, this only has cosmetic effects, the user can
1810 still enter a non-existing file.) *FUNC is set to a function that
1811 can be used to retrieve the selected file name from the returned widget.
1813 Returns the created widget. */
1816 xg_get_file_with_chooser (struct frame
*f
,
1818 char *default_filename
,
1819 bool mustmatch_p
, bool only_dir_p
,
1820 xg_get_file_func
*func
)
1824 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1825 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1826 GtkFileChooserAction action
= (mustmatch_p
?
1827 GTK_FILE_CHOOSER_ACTION_OPEN
:
1828 GTK_FILE_CHOOSER_ACTION_SAVE
);
1831 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1833 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1834 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1835 (mustmatch_p
|| only_dir_p
?
1836 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1839 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1841 wbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1842 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
1843 gtk_widget_show (wbox
);
1844 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1846 if (x_gtk_show_hidden_files
)
1848 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1849 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1851 gtk_widget_show (wtoggle
);
1852 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1853 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1854 g_signal_connect (G_OBJECT (filewin
), "notify",
1855 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1857 if (x_gtk_file_dialog_help_text
)
1860 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1861 Show the C-l help text only for versions < 2.10. */
1862 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1863 strcat (msgbuf
, "\nType C-l to display a file name text entry box.\n");
1864 strcat (msgbuf
, "\nIf you don't like this file selector, use the "
1865 "corresponding\nkey binding or customize "
1866 "use-file-dialog to turn it off.");
1868 wmessage
= gtk_label_new (msgbuf
);
1869 gtk_widget_show (wmessage
);
1872 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1873 if (x_gtk_file_dialog_help_text
)
1874 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1875 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1877 if (default_filename
)
1880 struct gcpro gcpro1
;
1881 char *utf8_filename
;
1884 file
= build_string (default_filename
);
1886 /* File chooser does not understand ~/... in the file name. It must be
1887 an absolute name starting with /. */
1888 if (default_filename
[0] != '/')
1889 file
= Fexpand_file_name (file
, Qnil
);
1891 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1892 if (! NILP (Ffile_directory_p (file
)))
1893 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1897 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1899 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1901 char *cp
= strrchr (utf8_filename
, '/');
1903 else cp
= utf8_filename
;
1904 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1911 *func
= xg_get_file_name_from_chooser
;
1915 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1917 /* Return the selected file for file selector dialog W.
1918 The returned string must be free:d. */
1921 xg_get_file_name_from_selector (GtkWidget
*w
)
1923 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1924 return xstrdup (gtk_file_selection_get_filename (filesel
));
1927 /* Create a file selection dialog.
1928 F is the current frame.
1929 PROMPT is a prompt to show to the user. May not be NULL.
1930 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1931 If MUSTMATCH_P, the returned file name must be an existing
1932 file. *FUNC is set to a function that can be used to retrieve the
1933 selected file name from the returned widget.
1935 Returns the created widget. */
1938 xg_get_file_with_selection (struct frame
*f
,
1940 char *default_filename
,
1941 bool mustmatch_p
, bool only_dir_p
,
1942 xg_get_file_func
*func
)
1945 GtkFileSelection
*filesel
;
1947 filewin
= gtk_file_selection_new (prompt
);
1948 filesel
= GTK_FILE_SELECTION (filewin
);
1950 if (default_filename
)
1951 gtk_file_selection_set_filename (filesel
, default_filename
);
1955 /* The selection_entry part of filesel is not documented. */
1956 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1957 gtk_file_selection_hide_fileop_buttons (filesel
);
1960 *func
= xg_get_file_name_from_selector
;
1964 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1966 /* Read a file name from the user using a file dialog, either the old
1967 file selection dialog, or the new file chooser dialog. Which to use
1968 depends on what the GTK version used has, and what the value of
1969 gtk-use-old-file-dialog.
1970 F is the current frame.
1971 PROMPT is a prompt to show to the user. May not be NULL.
1972 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1973 If MUSTMATCH_P, the returned file name must be an existing
1976 Returns a file name or NULL if no file was selected.
1977 The returned string must be freed by the caller. */
1980 xg_get_file_name (struct frame
*f
,
1982 char *default_filename
,
1988 int filesel_done
= 0;
1989 xg_get_file_func func
;
1991 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1993 if (xg_uses_old_file_dialog ())
1994 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1995 mustmatch_p
, only_dir_p
, &func
);
1997 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1998 mustmatch_p
, only_dir_p
, &func
);
2000 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
2001 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
2002 mustmatch_p
, only_dir_p
, &func
);
2003 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
2005 gtk_widget_set_name (w
, "emacs-filedialog");
2007 filesel_done
= xg_dialog_run (f
, w
);
2008 if (filesel_done
== GTK_RESPONSE_OK
)
2011 gtk_widget_destroy (w
);
2015 /***********************************************************************
2017 ***********************************************************************/
2019 #ifdef HAVE_FREETYPE
2021 #if USE_NEW_GTK_FONT_CHOOSER
2023 #define XG_WEIGHT_TO_SYMBOL(w) \
2024 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
2025 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
2026 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
2027 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
2028 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
2029 : w <= PANGO_WEIGHT_BOLD ? Qbold \
2030 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
2033 #define XG_STYLE_TO_SYMBOL(s) \
2034 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
2035 : s == PANGO_STYLE_ITALIC ? Qitalic \
2038 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2041 static char *x_last_font_name
;
2042 extern Lisp_Object Qxft
;
2044 /* Pop up a GTK font selector and return the name of the font the user
2045 selects, as a C string. The returned font name follows GTK's own
2048 `FAMILY [VALUE1 VALUE2] SIZE'
2050 This can be parsed using font_parse_fcname in font.c.
2051 DEFAULT_NAME, if non-zero, is the default font name. */
2054 xg_get_font (struct frame
*f
, const char *default_name
)
2058 Lisp_Object font
= Qnil
;
2060 w
= gtk_font_chooser_dialog_new
2061 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2065 /* Convert fontconfig names to Gtk names, i.e. remove - before
2067 char *p
= strrchr (default_name
, '-');
2071 while (c_isdigit (*ep
))
2073 if (*ep
== '\0') *p
= ' ';
2076 else if (x_last_font_name
)
2077 default_name
= x_last_font_name
;
2080 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w
), default_name
);
2082 gtk_widget_set_name (w
, "emacs-fontdialog");
2083 done
= xg_dialog_run (f
, w
);
2084 if (done
== GTK_RESPONSE_OK
)
2086 #if USE_NEW_GTK_FONT_CHOOSER
2087 /* Use the GTK3 font chooser. */
2088 PangoFontDescription
*desc
2089 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w
));
2093 Lisp_Object args
[10];
2094 const char *name
= pango_font_description_get_family (desc
);
2095 gint size
= pango_font_description_get_size (desc
);
2096 PangoWeight weight
= pango_font_description_get_weight (desc
);
2097 PangoStyle style
= pango_font_description_get_style (desc
);
2100 args
[1] = build_string (name
);
2103 args
[3] = make_float (pango_units_to_double (size
));
2106 args
[5] = XG_WEIGHT_TO_SYMBOL (weight
);
2109 args
[7] = XG_STYLE_TO_SYMBOL (style
);
2114 font
= Ffont_spec (8, args
);
2116 pango_font_description_free (desc
);
2117 xfree (x_last_font_name
);
2118 x_last_font_name
= xstrdup (name
);
2121 #else /* Use old font selector, which just returns the font name. */
2124 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w
));
2128 font
= build_string (font_name
);
2129 g_free (x_last_font_name
);
2130 x_last_font_name
= font_name
;
2132 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2135 gtk_widget_destroy (w
);
2138 #endif /* HAVE_FREETYPE */
2142 /***********************************************************************
2144 ***********************************************************************/
2146 /* The name of menu items that can be used for customization. Since GTK
2147 RC files are very crude and primitive, we have to set this on all
2148 menu item names so a user can easily customize menu items. */
2150 #define MENU_ITEM_NAME "emacs-menuitem"
2153 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2154 during GC. The next member points to the items. */
2155 static xg_list_node xg_menu_cb_list
;
2157 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2158 during GC. The next member points to the items. */
2159 static xg_list_node xg_menu_item_cb_list
;
2161 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2162 F is the frame CL_DATA will be initialized for.
2163 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2165 The menu bar and all sub menus under the menu bar in a frame
2166 share the same structure, hence the reference count.
2168 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2169 allocated xg_menu_cb_data if CL_DATA is NULL. */
2171 static xg_menu_cb_data
*
2172 make_cl_data (xg_menu_cb_data
*cl_data
, struct frame
*f
, GCallback highlight_cb
)
2176 cl_data
= xmalloc (sizeof *cl_data
);
2178 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2179 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2180 cl_data
->highlight_cb
= highlight_cb
;
2181 cl_data
->ref_count
= 0;
2183 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2186 cl_data
->ref_count
++;
2191 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2192 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2194 When the menu bar is updated, menu items may have been added and/or
2195 removed, so menu_bar_vector and menu_bar_items_used change. We must
2196 then update CL_DATA since it is used to determine which menu
2197 item that is invoked in the menu.
2198 HIGHLIGHT_CB could change, there is no check that the same
2199 function is given when modifying a menu bar as was given when
2200 creating the menu bar. */
2203 update_cl_data (xg_menu_cb_data
*cl_data
,
2205 GCallback highlight_cb
)
2210 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2211 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2212 cl_data
->highlight_cb
= highlight_cb
;
2216 /* Decrease reference count for CL_DATA.
2217 If reference count is zero, free CL_DATA. */
2220 unref_cl_data (xg_menu_cb_data
*cl_data
)
2222 if (cl_data
&& cl_data
->ref_count
> 0)
2224 cl_data
->ref_count
--;
2225 if (cl_data
->ref_count
== 0)
2227 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2233 /* Function that marks all lisp data during GC. */
2239 Lisp_Object rest
, frame
;
2241 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2242 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2244 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2246 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2248 if (! NILP (cb_data
->help
))
2249 mark_object (cb_data
->help
);
2252 FOR_EACH_FRAME (rest
, frame
)
2254 struct frame
*f
= XFRAME (frame
);
2256 if (FRAME_X_P (f
) && FRAME_GTK_OUTER_WIDGET (f
))
2258 struct xg_frame_tb_info
*tbinfo
2259 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
2263 mark_object (tbinfo
->last_tool_bar
);
2264 mark_object (tbinfo
->style
);
2271 /* Callback called when a menu item is destroyed. Used to free data.
2272 W is the widget that is being destroyed (not used).
2273 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2276 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2280 xg_menu_item_cb_data
*data
= client_data
;
2281 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2286 /* Callback called when the pointer enters/leaves a menu item.
2287 W is the parent of the menu item.
2288 EVENT is either an enter event or leave event.
2289 CLIENT_DATA is not used.
2291 Returns FALSE to tell GTK to keep processing this event. */
2294 menuitem_highlight_callback (GtkWidget
*w
,
2295 GdkEventCrossing
*event
,
2296 gpointer client_data
)
2299 GtkWidget
*subwidget
;
2300 xg_menu_item_cb_data
*data
;
2302 ev
.crossing
= *event
;
2303 subwidget
= gtk_get_event_widget (&ev
);
2304 data
= g_object_get_data (G_OBJECT (subwidget
), XG_ITEM_DATA
);
2307 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2309 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2310 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2311 (*func
) (subwidget
, call_data
);
2318 /* Callback called when a menu is destroyed. Used to free data.
2319 W is the widget that is being destroyed (not used).
2320 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2323 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2325 unref_cl_data (client_data
);
2328 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2329 must be non-NULL) and can be inserted into a menu item.
2331 Returns the GtkHBox. */
2334 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2340 wbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
2341 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
2342 wlbl
= gtk_label_new (utf8_label
);
2343 wkey
= gtk_label_new (utf8_key
);
2345 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2346 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2348 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2349 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2351 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2352 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2353 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2358 /* Make and return a menu item widget with the key to the right.
2359 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2360 UTF8_KEY is the text representing the key binding.
2361 ITEM is the widget_value describing the menu item.
2363 GROUP is an in/out parameter. If the menu item to be created is not
2364 part of any radio menu group, *GROUP contains NULL on entry and exit.
2365 If the menu item to be created is part of a radio menu group, on entry
2366 *GROUP contains the group to use, or NULL if this is the first item
2367 in the group. On exit, *GROUP contains the radio item group.
2369 Unfortunately, keys don't line up as nicely as in Motif,
2370 but the MacOS X version doesn't either, so I guess that is OK. */
2373 make_menu_item (const char *utf8_label
,
2374 const char *utf8_key
,
2379 GtkWidget
*wtoadd
= 0;
2381 /* It has been observed that some menu items have a NULL name field.
2382 This will lead to this function being called with a NULL utf8_label.
2383 GTK crashes on that so we set a blank label. Why there is a NULL
2384 name remains to be investigated. */
2385 if (! utf8_label
) utf8_label
= " ";
2388 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2390 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2393 if (utf8_key
) w
= gtk_check_menu_item_new ();
2394 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2395 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2397 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2399 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2400 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2401 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2403 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2408 if (utf8_key
) w
= gtk_menu_item_new ();
2409 else w
= gtk_menu_item_new_with_label (utf8_label
);
2412 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2413 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2418 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2420 static int xg_detached_menus
;
2422 /* Return true if there are detached menus. */
2425 xg_have_tear_offs (void)
2427 return xg_detached_menus
> 0;
2430 /* Callback invoked when a detached menu window is removed. Here we
2431 decrease the xg_detached_menus count.
2432 WIDGET is the top level window that is removed (the parent of the menu).
2433 CLIENT_DATA is not used. */
2436 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2438 if (xg_detached_menus
> 0) --xg_detached_menus
;
2441 /* Callback invoked when a menu is detached. It increases the
2442 xg_detached_menus count.
2443 WIDGET is the GtkTearoffMenuItem.
2444 CLIENT_DATA is not used. */
2447 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2449 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2450 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2452 ++xg_detached_menus
;
2453 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2455 G_CALLBACK (tearoff_remove
), 0);
2458 #else /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2460 xg_have_tear_offs (void)
2464 #endif /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2466 /* Create a menu item widget, and connect the callbacks.
2467 ITEM describes the menu item.
2468 F is the frame the created menu belongs to.
2469 SELECT_CB is the callback to use when a menu item is selected.
2470 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2471 CL_DATA points to the callback data to be used for this menu.
2472 GROUP is an in/out parameter. If the menu item to be created is not
2473 part of any radio menu group, *GROUP contains NULL on entry and exit.
2474 If the menu item to be created is part of a radio menu group, on entry
2475 *GROUP contains the group to use, or NULL if this is the first item
2476 in the group. On exit, *GROUP contains the radio item group.
2478 Returns the created GtkWidget. */
2481 xg_create_one_menuitem (widget_value
*item
,
2483 GCallback select_cb
,
2484 GCallback highlight_cb
,
2485 xg_menu_cb_data
*cl_data
,
2491 xg_menu_item_cb_data
*cb_data
;
2493 utf8_label
= get_utf8_string (item
->name
);
2494 utf8_key
= get_utf8_string (item
->key
);
2496 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2498 if (utf8_label
) g_free (utf8_label
);
2499 if (utf8_key
) g_free (utf8_key
);
2501 cb_data
= xmalloc (sizeof *cb_data
);
2503 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2505 cb_data
->select_id
= 0;
2506 cb_data
->help
= item
->help
;
2507 cb_data
->cl_data
= cl_data
;
2508 cb_data
->call_data
= item
->call_data
;
2510 g_signal_connect (G_OBJECT (w
),
2512 G_CALLBACK (menuitem_destroy_callback
),
2515 /* Put cb_data in widget, so we can get at it when modifying menubar */
2516 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2518 /* final item, not a submenu */
2519 if (item
->call_data
&& ! item
->contents
)
2523 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2529 /* Create a full menu tree specified by DATA.
2530 F is the frame the created menu belongs to.
2531 SELECT_CB is the callback to use when a menu item is selected.
2532 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2533 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2534 If POP_UP_P, create a popup menu.
2535 If MENU_BAR_P, create a menu bar.
2536 If ADD_TEAROFF_P, add a tearoff menu item. Ignored if MENU_BAR_P or
2537 the Gtk+ version used does not have tearoffs.
2538 TOPMENU is the topmost GtkWidget that others shall be placed under.
2539 It may be NULL, in that case we create the appropriate widget
2540 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2541 CL_DATA is the callback data we shall use for this menu, or NULL
2542 if we haven't set the first callback yet.
2543 NAME is the name to give to the top level menu if this function
2544 creates it. May be NULL to not set any name.
2546 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2549 This function calls itself to create submenus. */
2552 create_menus (widget_value
*data
,
2554 GCallback select_cb
,
2555 GCallback deactivate_cb
,
2556 GCallback highlight_cb
,
2561 xg_menu_cb_data
*cl_data
,
2565 GtkWidget
*wmenu
= topmenu
;
2566 GSList
*group
= NULL
;
2572 wmenu
= gtk_menu_new ();
2573 xg_set_screen (wmenu
, f
);
2574 /* Connect this to the menu instead of items so we get enter/leave for
2575 disabled items also. TODO: Still does not get enter/leave for
2576 disabled items in detached menus. */
2577 g_signal_connect (G_OBJECT (wmenu
),
2578 "enter-notify-event",
2579 G_CALLBACK (menuitem_highlight_callback
),
2581 g_signal_connect (G_OBJECT (wmenu
),
2582 "leave-notify-event",
2583 G_CALLBACK (menuitem_highlight_callback
),
2588 wmenu
= gtk_menu_bar_new ();
2589 /* Set width of menu bar to a small value so it doesn't enlarge
2590 a small initial frame size. The width will be set to the
2591 width of the frame later on when it is added to a container.
2592 height -1: Natural height. */
2593 gtk_widget_set_size_request (wmenu
, 1, -1);
2596 /* Put cl_data on the top menu for easier access. */
2597 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2598 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2599 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2600 G_CALLBACK (menu_destroy_callback
), cl_data
);
2603 gtk_widget_set_name (wmenu
, name
);
2606 g_signal_connect (G_OBJECT (wmenu
),
2607 "selection-done", deactivate_cb
, 0);
2610 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2611 if (! menu_bar_p
&& add_tearoff_p
)
2613 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2614 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2616 g_signal_connect (G_OBJECT (tearoff
), "activate",
2617 G_CALLBACK (tearoff_activate
), 0);
2621 for (item
= data
; item
; item
= item
->next
)
2625 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2626 && !menu_separator_name_p (item
->name
))
2629 /* A title for a popup. We do the same as GTK does when
2630 creating titles, but it does not look good. */
2632 utf8_label
= get_utf8_string (item
->name
);
2634 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2635 w
= gtk_menu_item_new_with_label (utf8_label
);
2636 gtk_widget_set_sensitive (w
, FALSE
);
2637 if (utf8_label
) g_free (utf8_label
);
2639 else if (menu_separator_name_p (item
->name
))
2642 /* GTK only have one separator type. */
2643 w
= gtk_separator_menu_item_new ();
2647 w
= xg_create_one_menuitem (item
,
2649 item
->contents
? 0 : select_cb
,
2654 /* Create a possibly empty submenu for menu bar items, since some
2655 themes don't highlight items correctly without it. */
2656 if (item
->contents
|| menu_bar_p
)
2658 GtkWidget
*submenu
= create_menus (item
->contents
,
2669 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2673 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2674 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2680 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2681 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2682 with some text and buttons.
2683 F is the frame the created item belongs to.
2684 NAME is the name to use for the top widget.
2685 VAL is a widget_value structure describing items to be created.
2686 SELECT_CB is the callback to use when a menu item is selected or
2687 a dialog button is pressed.
2688 DEACTIVATE_CB is the callback to use when an item is deactivated.
2689 For a menu, when a sub menu is not shown anymore, for a dialog it is
2690 called when the dialog is popped down.
2691 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2693 Returns the widget created. */
2696 xg_create_widget (const char *type
, const char *name
, struct frame
*f
,
2697 widget_value
*val
, GCallback select_cb
,
2698 GCallback deactivate_cb
, GCallback highlight_cb
)
2701 bool menu_bar_p
= strcmp (type
, "menubar") == 0;
2702 bool pop_up_p
= strcmp (type
, "popup") == 0;
2704 if (strcmp (type
, "dialog") == 0)
2706 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2707 xg_set_screen (w
, f
);
2708 gtk_window_set_transient_for (GTK_WINDOW (w
),
2709 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2710 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2711 gtk_widget_set_name (w
, "emacs-dialog");
2712 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2714 else if (menu_bar_p
|| pop_up_p
)
2716 w
= create_menus (val
->contents
,
2728 /* Set the cursor to an arrow for popup menus when they are mapped.
2729 This is done by default for menu bar menus. */
2732 /* Must realize so the GdkWindow inside the widget is created. */
2733 gtk_widget_realize (w
);
2734 xg_set_cursor (w
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
2739 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2746 /* Return the label for menu item WITEM. */
2749 xg_get_menu_item_label (GtkMenuItem
*witem
)
2751 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2752 return gtk_label_get_label (wlabel
);
2755 /* Return true if the menu item WITEM has the text LABEL. */
2758 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2761 char *utf8_label
= get_utf8_string (label
);
2762 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2764 if (! old_label
&& ! utf8_label
)
2766 else if (old_label
&& utf8_label
)
2767 is_same
= strcmp (utf8_label
, old_label
) == 0;
2769 if (utf8_label
) g_free (utf8_label
);
2774 /* Destroy widgets in LIST. */
2777 xg_destroy_widgets (GList
*list
)
2781 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2783 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2785 /* Destroying the widget will remove it from the container it is in. */
2786 gtk_widget_destroy (w
);
2790 /* Update the top level names in MENUBAR (i.e. not submenus).
2791 F is the frame the menu bar belongs to.
2792 *LIST is a list with the current menu bar names (menu item widgets).
2793 ITER is the item within *LIST that shall be updated.
2794 POS is the numerical position, starting at 0, of ITER in *LIST.
2795 VAL describes what the menu bar shall look like after the update.
2796 SELECT_CB is the callback to use when a menu item is selected.
2797 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2798 CL_DATA points to the callback data to be used for this menu bar.
2800 This function calls itself to walk through the menu bar names. */
2803 xg_update_menubar (GtkWidget
*menubar
,
2809 GCallback select_cb
,
2810 GCallback deactivate_cb
,
2811 GCallback highlight_cb
,
2812 xg_menu_cb_data
*cl_data
)
2814 if (! iter
&& ! val
)
2816 else if (iter
&& ! val
)
2818 /* Item(s) have been removed. Remove all remaining items. */
2819 xg_destroy_widgets (iter
);
2821 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2822 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2823 gtk_menu_item_new_with_label (""),
2829 else if (! iter
&& val
)
2831 /* Item(s) added. Add all new items in one call. */
2832 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2833 0, 1, 0, menubar
, cl_data
, 0);
2839 /* Below this neither iter or val is NULL */
2840 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2842 /* This item is still the same, check next item. */
2844 iter
= g_list_next (iter
);
2847 else /* This item is changed. */
2849 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2850 GtkMenuItem
*witem2
= 0;
2851 bool val_in_menubar
= 0;
2852 bool iter_in_new_menubar
= 0;
2856 /* See if the changed entry (val) is present later in the menu bar */
2858 iter2
&& ! val_in_menubar
;
2859 iter2
= g_list_next (iter2
))
2861 witem2
= GTK_MENU_ITEM (iter2
->data
);
2862 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2865 /* See if the current entry (iter) is present later in the
2866 specification for the new menu bar. */
2867 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2868 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2870 if (val_in_menubar
&& ! iter_in_new_menubar
)
2874 /* This corresponds to:
2879 g_object_ref (G_OBJECT (witem
));
2880 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2881 gtk_widget_destroy (GTK_WIDGET (witem
));
2883 /* Must get new list since the old changed. */
2884 g_list_free (*list
);
2885 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2886 while (nr
-- > 0) iter
= g_list_next (iter
);
2888 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2890 /* This corresponds to:
2893 Rename B to X. This might seem to be a strange thing to do,
2894 since if there is a menu under B it will be totally wrong for X.
2895 But consider editing a C file. Then there is a C-mode menu
2896 (corresponds to B above).
2897 If then doing C-x C-f the minibuf menu (X above) replaces the
2898 C-mode menu. When returning from the minibuffer, we get
2899 back the C-mode menu. Thus we do:
2900 Rename B to X (C-mode to minibuf menu)
2901 Rename X to B (minibuf to C-mode menu).
2902 If the X menu hasn't been invoked, the menu under B
2903 is up to date when leaving the minibuffer. */
2904 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2905 char *utf8_label
= get_utf8_string (val
->name
);
2906 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2908 gtk_label_set_text (wlabel
, utf8_label
);
2910 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2911 /* If this item has a submenu that has been detached, change
2912 the title in the WM decorations also. */
2913 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2914 /* Set the title of the detached window. */
2915 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2918 if (utf8_label
) g_free (utf8_label
);
2919 iter
= g_list_next (iter
);
2923 else if (! val_in_menubar
&& iter_in_new_menubar
)
2925 /* This corresponds to:
2932 GtkWidget
*w
= xg_create_one_menuitem (val
,
2939 /* Create a possibly empty submenu for menu bar items, since some
2940 themes don't highlight items correctly without it. */
2941 GtkWidget
*submenu
= create_menus (NULL
, f
,
2942 select_cb
, deactivate_cb
,
2944 0, 0, 0, 0, cl_data
, 0);
2945 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2946 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2947 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2949 g_list_free (*list
);
2950 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2951 while (nr
-- > 0) iter
= g_list_next (iter
);
2952 iter
= g_list_next (iter
);
2956 else /* if (val_in_menubar && iter_in_new_menubar) */
2959 /* This corresponds to:
2964 g_object_ref (G_OBJECT (witem2
));
2965 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2966 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2967 GTK_WIDGET (witem2
), pos
);
2968 g_object_unref (G_OBJECT (witem2
));
2970 g_list_free (*list
);
2971 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2972 while (nr
-- > 0) iter
= g_list_next (iter
);
2973 if (iter
) iter
= g_list_next (iter
);
2979 /* Update the rest of the menu bar. */
2980 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2981 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2984 /* Update the menu item W so it corresponds to VAL.
2985 SELECT_CB is the callback to use when a menu item is selected.
2986 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2987 CL_DATA is the data to set in the widget for menu invocation. */
2990 xg_update_menu_item (widget_value
*val
,
2992 GCallback select_cb
,
2993 GCallback highlight_cb
,
2994 xg_menu_cb_data
*cl_data
)
3001 const char *old_label
= 0;
3002 const char *old_key
= 0;
3003 xg_menu_item_cb_data
*cb_data
;
3005 wchild
= XG_BIN_CHILD (w
);
3006 utf8_label
= get_utf8_string (val
->name
);
3007 utf8_key
= get_utf8_string (val
->key
);
3009 /* See if W is a menu item with a key. See make_menu_item above. */
3010 if (GTK_IS_BOX (wchild
))
3012 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
3014 wlbl
= GTK_LABEL (list
->data
);
3015 wkey
= GTK_LABEL (list
->next
->data
);
3020 /* Remove the key and keep just the label. */
3021 g_object_ref (G_OBJECT (wlbl
));
3022 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3023 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
3024 g_object_unref (G_OBJECT (wlbl
));
3029 else /* Just a label. */
3031 wlbl
= GTK_LABEL (wchild
);
3033 /* Check if there is now a key. */
3036 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
3037 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
3039 wlbl
= GTK_LABEL (list
->data
);
3040 wkey
= GTK_LABEL (list
->next
->data
);
3043 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3044 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
3049 if (wkey
) old_key
= gtk_label_get_label (wkey
);
3050 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
3052 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
3053 gtk_label_set_text (wkey
, utf8_key
);
3055 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
3056 gtk_label_set_text (wlbl
, utf8_label
);
3058 if (utf8_key
) g_free (utf8_key
);
3059 if (utf8_label
) g_free (utf8_label
);
3061 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
3062 gtk_widget_set_sensitive (w
, FALSE
);
3063 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
3064 gtk_widget_set_sensitive (w
, TRUE
);
3066 cb_data
= g_object_get_data (G_OBJECT (w
), XG_ITEM_DATA
);
3069 cb_data
->call_data
= val
->call_data
;
3070 cb_data
->help
= val
->help
;
3071 cb_data
->cl_data
= cl_data
;
3073 /* We assume the callback functions don't change. */
3074 if (val
->call_data
&& ! val
->contents
)
3076 /* This item shall have a select callback. */
3077 if (! cb_data
->select_id
)
3079 = g_signal_connect (G_OBJECT (w
), "activate",
3080 select_cb
, cb_data
);
3082 else if (cb_data
->select_id
)
3084 g_signal_handler_disconnect (w
, cb_data
->select_id
);
3085 cb_data
->select_id
= 0;
3090 /* Update the toggle menu item W so it corresponds to VAL. */
3093 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
3095 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3098 /* Update the radio menu item W so it corresponds to VAL. */
3101 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
3103 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3106 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3107 SUBMENU may be NULL, in that case a new menu is created.
3108 F is the frame the menu bar belongs to.
3109 VAL describes the contents of the menu bar.
3110 SELECT_CB is the callback to use when a menu item is selected.
3111 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3112 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3113 CL_DATA is the call back data to use for any newly created items.
3115 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3119 xg_update_submenu (GtkWidget
*submenu
,
3122 GCallback select_cb
,
3123 GCallback deactivate_cb
,
3124 GCallback highlight_cb
,
3125 xg_menu_cb_data
*cl_data
)
3127 GtkWidget
*newsub
= submenu
;
3131 bool has_tearoff_p
= 0;
3132 GList
*first_radio
= 0;
3135 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3137 for (cur
= val
, iter
= list
;
3139 iter
= g_list_next (iter
), cur
= cur
->next
)
3141 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3143 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
3144 /* Skip tearoff items, they have no counterpart in val. */
3145 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
3148 iter
= g_list_next (iter
);
3149 if (iter
) w
= GTK_WIDGET (iter
->data
);
3154 /* Remember first radio button in a group. If we get a mismatch in
3155 a radio group we must rebuild the whole group so that the connections
3156 in GTK becomes correct. */
3157 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3159 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3160 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3163 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3165 if (! menu_separator_name_p (cur
->name
))
3168 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3170 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3172 xg_update_toggle_item (cur
, w
);
3173 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3175 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3177 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3179 xg_update_radio_item (cur
, w
);
3180 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3182 else if (GTK_IS_MENU_ITEM (w
))
3184 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3187 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3188 menu_separator_name_p (cur
->name
))
3191 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3193 sub
= gtk_menu_item_get_submenu (witem
);
3194 if (sub
&& ! cur
->contents
)
3196 /* Not a submenu anymore. */
3197 g_object_ref (G_OBJECT (sub
));
3198 remove_submenu (witem
);
3199 gtk_widget_destroy (sub
);
3201 else if (cur
->contents
)
3205 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3206 select_cb
, deactivate_cb
,
3207 highlight_cb
, cl_data
);
3209 /* If this item just became a submenu, we must set it. */
3211 gtk_menu_item_set_submenu (witem
, nsub
);
3216 /* Structural difference. Remove everything from here and down
3222 /* Remove widgets from first structural change. */
3225 /* If we are adding new menu items below, we must remove from
3226 first radio button so that radio groups become correct. */
3227 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3228 else xg_destroy_widgets (iter
);
3233 /* More items added. Create them. */
3234 newsub
= create_menus (cur
,
3247 if (list
) g_list_free (list
);
3252 /* Update the MENUBAR.
3253 F is the frame the menu bar belongs to.
3254 VAL describes the contents of the menu bar.
3255 If DEEP_P, rebuild all but the top level menu names in
3256 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3257 SELECT_CB is the callback to use when a menu item is selected.
3258 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3259 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3262 xg_modify_menubar_widgets (GtkWidget
*menubar
, struct frame
*f
,
3263 widget_value
*val
, bool deep_p
,
3264 GCallback select_cb
, GCallback deactivate_cb
,
3265 GCallback highlight_cb
)
3267 xg_menu_cb_data
*cl_data
;
3268 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3272 cl_data
= g_object_get_data (G_OBJECT (menubar
), XG_FRAME_DATA
);
3274 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3275 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3281 /* Update all sub menus.
3282 We must keep the submenus (GTK menu item widgets) since the
3283 X Window in the XEvent that activates the menu are those widgets. */
3285 /* Update cl_data, menu_item things in F may have changed. */
3286 update_cl_data (cl_data
, f
, highlight_cb
);
3288 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3293 GtkMenuItem
*witem
= 0;
3295 /* Find sub menu that corresponds to val and update it. */
3296 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3298 witem
= GTK_MENU_ITEM (iter
->data
);
3299 if (xg_item_label_same_p (witem
, cur
->name
))
3301 sub
= gtk_menu_item_get_submenu (witem
);
3306 newsub
= xg_update_submenu (sub
,
3313 /* sub may still be NULL. If we just updated non deep and added
3314 a new menu bar item, it has no sub menu yet. So we set the
3315 newly created sub menu under witem. */
3316 if (newsub
!= sub
&& witem
!= 0)
3318 xg_set_screen (newsub
, f
);
3319 gtk_menu_item_set_submenu (witem
, newsub
);
3325 gtk_widget_show_all (menubar
);
3328 /* Callback called when the menu bar W is mapped.
3329 Used to find the height of the menu bar if we didn't get it
3330 after showing the widget. */
3333 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3336 struct frame
*f
= user_data
;
3337 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3338 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3340 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3341 xg_height_or_width_changed (f
);
3345 /* Recompute all the widgets of frame F, when the menu bar has been
3349 xg_update_frame_menubar (struct frame
*f
)
3351 struct x_output
*x
= f
->output_data
.x
;
3354 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3357 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3358 return; /* Already done this, happens for frames created invisible. */
3362 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3364 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3366 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3367 gtk_widget_show_all (x
->menubar_widget
);
3368 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3370 /* If menu bar doesn't know its height yet, cheat a little so the frame
3371 doesn't jump so much when resized later in menubar_map_cb. */
3372 if (req
.height
== 0)
3375 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3377 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3378 xg_height_or_width_changed (f
);
3383 /* Get rid of the menu bar of frame F, and free its storage.
3384 This is used when deleting a frame, and when turning off the menu bar. */
3387 free_frame_menubar (struct frame
*f
)
3389 struct x_output
*x
= f
->output_data
.x
;
3391 if (x
->menubar_widget
)
3395 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3396 /* The menubar and its children shall be deleted when removed from
3398 x
->menubar_widget
= 0;
3399 FRAME_MENUBAR_HEIGHT (f
) = 0;
3400 xg_height_or_width_changed (f
);
3406 xg_event_is_for_menubar (struct frame
*f
, XEvent
*event
)
3408 struct x_output
*x
= f
->output_data
.x
;
3417 if (! x
->menubar_widget
) return 0;
3419 if (! (event
->xbutton
.x
>= 0
3420 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3421 && event
->xbutton
.y
>= 0
3422 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
3423 && event
->xbutton
.same_screen
))
3426 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3427 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3429 gevent
.any
.window
= gw
;
3430 gevent
.any
.type
= GDK_NOTHING
;
3431 gwdesc
= gtk_get_event_widget (&gevent
);
3432 if (! gwdesc
) return 0;
3433 if (! GTK_IS_MENU_BAR (gwdesc
)
3434 && ! GTK_IS_MENU_ITEM (gwdesc
)
3435 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3438 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3439 if (! list
) return 0;
3440 rec
.x
= event
->xbutton
.x
;
3441 rec
.y
= event
->xbutton
.y
;
3445 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3447 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3448 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3457 /***********************************************************************
3458 Scroll bar functions
3459 ***********************************************************************/
3462 /* Setting scroll bar values invokes the callback. Use this variable
3463 to indicate that callback should do nothing. */
3465 bool xg_ignore_gtk_scrollbar
;
3467 /* The width of the scroll bar for the current theme. */
3469 static int scroll_bar_width_for_theme
;
3471 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3472 may be larger than 32 bits. Keep a mapping from integer index to widget
3473 pointers to get around the 32 bit limitation. */
3477 GtkWidget
**widgets
;
3482 /* Grow this much every time we need to allocate more */
3484 #define ID_TO_WIDGET_INCR 32
3486 /* Store the widget pointer W in id_to_widget and return the integer index. */
3489 xg_store_widget_in_map (GtkWidget
*w
)
3493 if (id_to_widget
.max_size
== id_to_widget
.used
)
3496 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3497 memory_full (SIZE_MAX
);
3499 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3500 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3501 new_size
, sizeof (GtkWidget
*));
3503 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3504 id_to_widget
.widgets
[i
] = 0;
3505 id_to_widget
.max_size
= new_size
;
3508 /* Just loop over the array and find a free place. After all,
3509 how many scroll bars are we creating? Should be a small number.
3510 The check above guarantees we will find a free place. */
3511 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3513 if (! id_to_widget
.widgets
[i
])
3515 id_to_widget
.widgets
[i
] = w
;
3516 ++id_to_widget
.used
;
3522 /* Should never end up here */
3526 /* Remove pointer at IDX from id_to_widget.
3527 Called when scroll bar is destroyed. */
3530 xg_remove_widget_from_map (ptrdiff_t idx
)
3532 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3534 id_to_widget
.widgets
[idx
] = 0;
3535 --id_to_widget
.used
;
3539 /* Get the widget pointer at IDX from id_to_widget. */
3542 xg_get_widget_from_map (ptrdiff_t idx
)
3544 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3545 return id_to_widget
.widgets
[idx
];
3551 update_theme_scrollbar_width (void)
3554 GtkAdjustment
*vadj
;
3561 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3562 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3563 g_object_ref_sink (G_OBJECT (wscroll
));
3564 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3565 gtk_widget_destroy (wscroll
);
3566 g_object_unref (G_OBJECT (wscroll
));
3569 scroll_bar_width_for_theme
= w
;
3573 xg_get_default_scrollbar_width (void)
3575 return scroll_bar_width_for_theme
;
3578 /* Return the scrollbar id for X Window WID on display DPY.
3579 Return -1 if WID not in id_to_widget. */
3582 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3587 w
= xg_win_to_widget (dpy
, wid
);
3591 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3592 if (id_to_widget
.widgets
[idx
] == w
)
3599 /* Callback invoked when scroll bar WIDGET is destroyed.
3600 DATA is the index into id_to_widget for WIDGET.
3601 We free pointer to last scroll bar values here and remove the index. */
3604 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3606 intptr_t id
= (intptr_t) data
;
3607 xg_remove_widget_from_map (id
);
3610 /* Create a scroll bar widget for frame F. Store the scroll bar
3612 SCROLL_CALLBACK is the callback to invoke when the value of the
3614 END_CALLBACK is the callback to invoke when scrolling ends.
3615 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3616 to set resources for the widget. */
3619 xg_create_scroll_bar (struct frame
*f
,
3620 struct scroll_bar
*bar
,
3621 GCallback scroll_callback
,
3622 GCallback end_callback
,
3623 const char *scroll_bar_name
)
3629 GtkAdjustment
*vadj
;
3634 /* Page, step increment values are not so important here, they
3635 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3636 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3639 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3640 webox
= gtk_event_box_new ();
3641 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3643 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3645 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3647 scroll_id
= xg_store_widget_in_map (wscroll
);
3649 g_signal_connect (G_OBJECT (wscroll
),
3651 G_CALLBACK (xg_gtk_scroll_destroy
),
3652 (gpointer
) scroll_id
);
3653 g_signal_connect (G_OBJECT (wscroll
),
3657 g_signal_connect (G_OBJECT (wscroll
),
3658 "button-release-event",
3662 /* The scroll bar widget does not draw on a window of its own. Instead
3663 it draws on the parent window, in this case the edit widget. So
3664 whenever the edit widget is cleared, the scroll bar needs to redraw
3665 also, which causes flicker. Put an event box between the edit widget
3666 and the scroll bar, so the scroll bar instead draws itself on the
3667 event box window. */
3668 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3669 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3672 /* Set the cursor to an arrow. */
3673 xg_set_cursor (webox
, FRAME_X_DISPLAY_INFO (f
)->xg_cursor
);
3675 bar
->x_window
= scroll_id
;
3678 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3681 xg_remove_scroll_bar (struct frame
*f
, ptrdiff_t scrollbar_id
)
3683 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3686 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3687 gtk_widget_destroy (w
);
3688 gtk_widget_destroy (wparent
);
3689 SET_FRAME_GARBAGED (f
);
3693 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3695 TOP/LEFT are the new pixel positions where the bar shall appear.
3696 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3699 xg_update_scrollbar_pos (struct frame
*f
,
3700 ptrdiff_t scrollbar_id
,
3707 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3711 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3712 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3715 /* Clear out old position. */
3716 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3717 if (gtk_widget_get_parent (wparent
) == wfixed
)
3719 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3720 "x", &oldx
, "y", &oldy
, NULL
);
3721 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3724 /* Move and resize to new values. */
3725 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3726 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3729 /* No room. Hide scroll bar as some themes output a warning if
3730 the height is less than the min size. */
3731 gtk_widget_hide (wparent
);
3732 gtk_widget_hide (wscroll
);
3736 gtk_widget_show_all (wparent
);
3737 gtk_widget_set_size_request (wscroll
, width
, height
);
3739 gtk_widget_queue_draw (wfixed
);
3740 gdk_window_process_all_updates ();
3741 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3743 /* Clear under old scroll bar position. This must be done after
3744 the gtk_widget_queue_draw and gdk_window_process_all_updates
3746 x_clear_area (FRAME_X_DISPLAY (f
),
3748 oldx
, oldy
, oldw
, oldh
, 0);
3751 /* GTK does not redraw until the main loop is entered again, but
3752 if there are no X events pending we will not enter it. So we sync
3753 here to get some events. */
3756 SET_FRAME_GARBAGED (f
);
3757 cancel_mouse_face (f
);
3761 /* Get the current value of the range, truncated to an integer. */
3764 int_gtk_range_get_value (GtkRange
*range
)
3766 return gtk_range_get_value (range
);
3770 /* Set the thumb size and position of scroll bar BAR. We are currently
3771 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3774 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3779 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3781 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3783 if (wscroll
&& NILP (bar
->dragging
))
3793 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3795 if (scroll_bar_adjust_thumb_portion_p
)
3797 /* We do the same as for MOTIF in xterm.c, use 30 chars per
3798 line rather than the real portion value. This makes the
3799 thumb less likely to resize and that looks better. */
3800 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3802 /* When the thumb is at the bottom, position == whole.
3803 So we need to increase `whole' to make space for the thumb. */
3811 top
= (gdouble
) position
/ whole
;
3812 shown
= (gdouble
) portion
/ whole
;
3815 size
= clip_to_bounds (1, shown
* XG_SB_RANGE
, XG_SB_RANGE
);
3816 value
= clip_to_bounds (XG_SB_MIN
, top
* XG_SB_RANGE
, XG_SB_MAX
- size
);
3818 /* Assume all lines are of equal size. */
3819 new_step
= size
/ max (1, FRAME_LINES (f
));
3821 old_size
= gtk_adjustment_get_page_size (adj
);
3822 if (old_size
!= size
)
3824 int old_step
= gtk_adjustment_get_step_increment (adj
);
3825 if (old_step
!= new_step
)
3827 gtk_adjustment_set_page_size (adj
, size
);
3828 gtk_adjustment_set_step_increment (adj
, new_step
);
3829 /* Assume a page increment is about 95% of the page size */
3830 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3835 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3839 /* gtk_range_set_value invokes the callback. Set
3840 ignore_gtk_scrollbar to make the callback do nothing */
3841 xg_ignore_gtk_scrollbar
= 1;
3843 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3844 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3846 gtk_adjustment_changed (adj
);
3848 xg_ignore_gtk_scrollbar
= 0;
3855 /* Return true if EVENT is for a scroll bar in frame F.
3856 When the same X window is used for several Gtk+ widgets, we cannot
3857 say for sure based on the X window alone if an event is for the
3858 frame. This function does additional checks. */
3861 xg_event_is_for_scrollbar (struct frame
*f
, XEvent
*event
)
3865 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3867 /* Check if press occurred outside the edit widget. */
3868 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3871 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
3872 (gdk_display_get_device_manager (gdpy
));
3873 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
3875 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
3877 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3880 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3881 || event
->type
== MotionNotify
))
3883 /* If we are releasing or moving the scroll bar, it has the grab. */
3884 GtkWidget
*w
= gtk_grab_get_current ();
3885 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3893 /***********************************************************************
3895 ***********************************************************************/
3896 /* The key for the data we put in the GtkImage widgets. The data is
3897 the image used by Emacs. We use this to see if we need to update
3898 the GtkImage with a new image. */
3899 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3901 /* The key for storing the latest modifiers so the activate callback can
3903 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3905 /* The key for storing the button widget in its proxy menu item. */
3906 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3908 /* The key for the data we put in the GtkImage widgets. The data is
3909 the stock name used by Emacs. We use this to see if we need to update
3910 the GtkImage with a new image. */
3911 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3913 /* As above, but this is used for named theme widgets, as opposed to
3915 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3917 /* Callback function invoked when a tool bar item is pressed.
3918 W is the button widget in the tool bar that got pressed,
3919 CLIENT_DATA is an integer that is the index of the button in the
3920 tool bar. 0 is the first button. */
3923 xg_tool_bar_button_cb (GtkWidget
*widget
,
3924 GdkEventButton
*event
,
3927 intptr_t state
= event
->state
;
3928 gpointer ptr
= (gpointer
) state
;
3929 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3934 /* Callback function invoked when a tool bar item is pressed.
3935 W is the button widget in the tool bar 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_callback (GtkWidget
*w
, gpointer client_data
)
3942 intptr_t idx
= (intptr_t) client_data
;
3943 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
3944 intptr_t mod
= (intptr_t) gmod
;
3946 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3947 Lisp_Object key
, frame
;
3948 struct input_event event
;
3951 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3954 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3956 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3957 XSETFRAME (frame
, f
);
3959 /* We generate two events here. The first one is to set the prefix
3960 to `(tool_bar)', see keyboard.c. */
3961 event
.kind
= TOOL_BAR_EVENT
;
3962 event
.frame_or_window
= frame
;
3964 kbd_buffer_store_event (&event
);
3966 event
.kind
= TOOL_BAR_EVENT
;
3967 event
.frame_or_window
= frame
;
3969 /* Convert between the modifier bits GDK uses and the modifier bits
3970 Emacs uses. This assumes GDK and X masks are the same, which they are when
3972 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3973 kbd_buffer_store_event (&event
);
3975 /* Return focus to the frame after we have clicked on a detached
3977 Fx_focus_frame (frame
);
3980 /* Callback function invoked when a tool bar item is pressed in a detached
3981 tool bar or the overflow drop down menu.
3982 We just call xg_tool_bar_callback.
3983 W is the menu item widget that got pressed,
3984 CLIENT_DATA is an integer that is the index of the button in the
3985 tool bar. 0 is the first button. */
3988 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3990 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3991 XG_TOOL_BAR_PROXY_BUTTON
));
3992 xg_tool_bar_callback (wbutton
, client_data
);
3997 xg_tool_bar_help_callback (GtkWidget
*w
,
3998 GdkEventCrossing
*event
,
3999 gpointer client_data
);
4001 /* This callback is called when a help is to be shown for an item in
4002 the detached tool bar when the detached tool bar it is not expanded. */
4005 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
4006 GdkEventCrossing
*event
,
4007 gpointer client_data
)
4009 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
4010 XG_TOOL_BAR_PROXY_BUTTON
));
4012 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
4016 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
4018 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
4019 GtkWidget
*c1
= clist
->data
;
4020 GtkWidget
*c2
= clist
->next
? clist
->next
->data
: NULL
;
4022 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
4023 g_list_free (clist
);
4024 return GTK_IS_LABEL (c1
) ? c1
: c2
;
4028 /* This callback is called when a tool item should create a proxy item,
4029 such as for the overflow menu. Also called when the tool bar is detached.
4030 If we don't create a proxy menu item, the detached tool bar will be
4034 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
4036 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
4037 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4039 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
4040 GtkImage
*wimage
= GTK_IMAGE (c1
);
4041 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
4042 (wlbl
? gtk_label_get_text (wlbl
) : "");
4043 GtkWidget
*wmenuimage
;
4046 if (gtk_button_get_use_stock (wbutton
))
4047 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
4048 GTK_ICON_SIZE_MENU
);
4051 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
4052 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
4054 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
4056 if (store_type
== GTK_IMAGE_STOCK
)
4059 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
4060 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
4062 else if (store_type
== GTK_IMAGE_ICON_SET
)
4064 GtkIconSet
*icon_set
;
4065 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
4066 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
4067 GTK_ICON_SIZE_MENU
);
4069 else if (store_type
== GTK_IMAGE_PIXBUF
)
4074 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
4077 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
4079 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
4080 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
4081 GDK_INTERP_BILINEAR
);
4083 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
4087 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
4091 else if (store_type
== GTK_IMAGE_ICON_NAME
)
4093 const gchar
*icon_name
;
4094 GtkIconSize icon_size
;
4096 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
4097 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
4098 GTK_ICON_SIZE_MENU
);
4102 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
4107 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
4109 g_signal_connect (G_OBJECT (wmenuitem
),
4111 G_CALLBACK (xg_tool_bar_proxy_callback
),
4115 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
4116 (gpointer
) wbutton
);
4117 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
4118 gtk_widget_set_sensitive (wmenuitem
,
4119 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
4121 /* Use enter/leave notify to show help. We use the events
4122 rather than the GtkButton specific signals "enter" and
4123 "leave", so we can have only one callback. The event
4124 will tell us what kind of event it is. */
4125 g_signal_connect (G_OBJECT (wmenuitem
),
4126 "enter-notify-event",
4127 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4129 g_signal_connect (G_OBJECT (wmenuitem
),
4130 "leave-notify-event",
4131 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4137 /* This callback is called when a tool bar is detached. We must set
4138 the height of the tool bar to zero when this happens so frame sizes
4139 are correctly calculated.
4140 WBOX is the handle box widget that enables detach/attach of the tool bar.
4141 W is the tool bar widget.
4142 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4145 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
4147 gpointer client_data
)
4149 struct frame
*f
= client_data
;
4151 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
4156 GtkRequisition req
, req2
;
4158 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4159 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4160 req
.width
-= req2
.width
;
4161 req
.height
-= req2
.height
;
4162 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4163 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4164 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4165 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4166 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4167 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4168 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4169 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4170 xg_height_or_width_changed (f
);
4174 /* This callback is called when a tool bar is reattached. We must set
4175 the height of the tool bar when this happens so frame sizes
4176 are correctly calculated.
4177 WBOX is the handle box widget that enables detach/attach of the tool bar.
4178 W is the tool bar widget.
4179 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4182 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
4184 gpointer client_data
)
4186 struct frame
*f
= client_data
;
4187 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
4191 GtkRequisition req
, req2
;
4193 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4194 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4195 req
.width
+= req2
.width
;
4196 req
.height
+= req2
.height
;
4197 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4198 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4199 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4200 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4201 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4202 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4203 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4204 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4205 xg_height_or_width_changed (f
);
4209 /* This callback is called when the mouse enters or leaves a tool bar item.
4210 It is used for displaying and hiding the help text.
4211 W is the tool bar item, a button.
4212 EVENT is either an enter event or leave event.
4213 CLIENT_DATA is an integer that is the index of the button in the
4214 tool bar. 0 is the first button.
4216 Returns FALSE to tell GTK to keep processing this event. */
4219 xg_tool_bar_help_callback (GtkWidget
*w
,
4220 GdkEventCrossing
*event
,
4221 gpointer client_data
)
4223 intptr_t idx
= (intptr_t) client_data
;
4224 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4225 Lisp_Object help
, frame
;
4227 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4230 if (event
->type
== GDK_ENTER_NOTIFY
)
4232 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4233 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4236 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4241 XSETFRAME (frame
, f
);
4242 kbd_buffer_store_help_event (frame
, help
);
4248 /* This callback is called when a tool bar item shall be redrawn.
4249 It modifies the expose event so that the GtkImage widget redraws the
4250 whole image. This to overcome a bug that makes GtkImage draw the image
4251 in the wrong place when it tries to redraw just a part of the image.
4252 W is the GtkImage to be redrawn.
4253 EVENT is the expose event for W.
4254 CLIENT_DATA is unused.
4256 Returns FALSE to tell GTK to keep processing this event. */
4260 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4261 GdkEventExpose
*event
,
4262 gpointer client_data
)
4266 gdk_drawable_get_size (event
->window
, &width
, &height
);
4267 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4268 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4270 event
->area
.x
= max (0, event
->area
.x
);
4271 event
->area
.y
= max (0, event
->area
.y
);
4273 event
->area
.width
= max (width
, event
->area
.width
);
4274 event
->area
.height
= max (height
, event
->area
.height
);
4280 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4281 #define toolbar_set_orientation(w, o) \
4282 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4284 #define toolbar_set_orientation(w, o) \
4285 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4288 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4289 #define TOOLBAR_TOP_WIDGET(x) ((x)->handlebox_widget)
4291 #define TOOLBAR_TOP_WIDGET(x) ((x)->toolbar_widget)
4294 /* Attach a tool bar to frame F. */
4297 xg_pack_tool_bar (struct frame
*f
, Lisp_Object pos
)
4299 struct x_output
*x
= f
->output_data
.x
;
4300 bool into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4301 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4303 toolbar_set_orientation (x
->toolbar_widget
,
4305 ? GTK_ORIENTATION_VERTICAL
4306 : GTK_ORIENTATION_HORIZONTAL
);
4307 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4308 if (!x
->handlebox_widget
)
4310 top_widget
= x
->handlebox_widget
= gtk_handle_box_new ();
4311 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
4312 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
4313 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
4314 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
4315 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
4322 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4323 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4326 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), top_widget
,
4329 if (EQ (pos
, Qleft
))
4330 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4333 x
->toolbar_in_hbox
= true;
4337 bool vbox_pos
= x
->menubar_widget
!= 0;
4338 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4339 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4342 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), top_widget
,
4346 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4349 x
->toolbar_in_hbox
= false;
4351 x
->toolbar_is_packed
= true;
4354 static bool xg_update_tool_bar_sizes (struct frame
*f
);
4357 tb_size_cb (GtkWidget
*widget
,
4358 GdkRectangle
*allocation
,
4361 /* When tool bar is created it has one preferred size. But when size is
4362 allocated between widgets, it may get another. So we must update
4363 size hints if tool bar size changes. Seen on Fedora 18 at least. */
4364 struct frame
*f
= user_data
;
4365 if (xg_update_tool_bar_sizes (f
))
4366 x_wm_set_size_hint (f
, 0, 0);
4369 /* Create a tool bar for frame F. */
4372 xg_create_tool_bar (struct frame
*f
)
4374 struct x_output
*x
= f
->output_data
.x
;
4375 #if GTK_CHECK_VERSION (3, 3, 6)
4376 GtkStyleContext
*gsty
;
4378 struct xg_frame_tb_info
*tbinfo
4379 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4383 tbinfo
= xmalloc (sizeof (*tbinfo
));
4384 tbinfo
->last_tool_bar
= Qnil
;
4385 tbinfo
->style
= Qnil
;
4386 tbinfo
->hmargin
= tbinfo
->vmargin
= 0;
4387 tbinfo
->dir
= GTK_TEXT_DIR_NONE
;
4388 tbinfo
->n_last_items
= 0;
4389 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4394 x
->toolbar_widget
= gtk_toolbar_new ();
4396 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4398 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4399 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4400 g_signal_connect (x
->toolbar_widget
, "size-allocate",
4401 G_CALLBACK (tb_size_cb
), f
);
4402 #if GTK_CHECK_VERSION (3, 3, 6)
4403 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4404 gtk_style_context_add_class (gsty
, "primary-toolbar");
4409 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4411 /* Find the right-to-left image named by RTL in the tool bar images for F.
4412 Returns IMAGE if RTL is not found. */
4415 find_rtl_image (struct frame
*f
, Lisp_Object image
, Lisp_Object rtl
)
4418 Lisp_Object file
, rtl_name
;
4419 struct gcpro gcpro1
, gcpro2
;
4420 GCPRO2 (file
, rtl_name
);
4422 rtl_name
= Ffile_name_nondirectory (rtl
);
4424 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4426 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4427 if (!NILP (file
= file_for_image (rtl_image
)))
4429 file
= call1 (intern ("file-name-sans-extension"),
4430 Ffile_name_nondirectory (file
));
4431 if (! NILP (Fequal (file
, rtl_name
)))
4442 static GtkToolItem
*
4443 xg_make_tool_item (struct frame
*f
,
4445 GtkWidget
**wbutton
,
4447 int i
, bool horiz
, bool text_image
)
4449 GtkToolItem
*ti
= gtk_tool_item_new ();
4450 GtkWidget
*vb
= gtk_box_new (horiz
4451 ? GTK_ORIENTATION_HORIZONTAL
4452 : GTK_ORIENTATION_VERTICAL
,
4454 GtkWidget
*wb
= gtk_button_new ();
4455 /* The eventbox is here so we can have tooltips on disabled items. */
4456 GtkWidget
*weventbox
= gtk_event_box_new ();
4457 #if GTK_CHECK_VERSION (3, 3, 6)
4458 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4459 GtkStyleContext
*gsty
;
4461 gtk_css_provider_load_from_data (css_prov
,
4463 " background-color: transparent;"
4467 gsty
= gtk_widget_get_style_context (weventbox
);
4468 gtk_style_context_add_provider (gsty
,
4469 GTK_STYLE_PROVIDER (css_prov
),
4470 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4471 g_object_unref (css_prov
);
4474 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4476 if (wimage
&& !text_image
)
4477 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4479 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4480 if (wimage
&& text_image
)
4481 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4483 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4484 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4485 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4486 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4487 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4489 if (wimage
|| label
)
4492 gpointer gi
= (gpointer
) ii
;
4494 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4495 G_CALLBACK (xg_tool_bar_menu_proxy
),
4498 g_signal_connect (G_OBJECT (wb
), "clicked",
4499 G_CALLBACK (xg_tool_bar_callback
),
4502 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4505 /* Catch expose events to overcome an annoying redraw bug, see
4506 comment for xg_tool_bar_item_expose_callback. */
4507 g_signal_connect (G_OBJECT (ti
),
4509 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4512 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4514 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4515 no distinction based on modifiers in the activate callback,
4516 so we have to do it ourselves. */
4517 g_signal_connect (wb
, "button-release-event",
4518 G_CALLBACK (xg_tool_bar_button_cb
),
4521 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4523 /* Use enter/leave notify to show help. We use the events
4524 rather than the GtkButton specific signals "enter" and
4525 "leave", so we can have only one callback. The event
4526 will tell us what kind of event it is. */
4527 g_signal_connect (G_OBJECT (weventbox
),
4528 "enter-notify-event",
4529 G_CALLBACK (xg_tool_bar_help_callback
),
4531 g_signal_connect (G_OBJECT (weventbox
),
4532 "leave-notify-event",
4533 G_CALLBACK (xg_tool_bar_help_callback
),
4537 if (wbutton
) *wbutton
= wb
;
4543 is_box_type (GtkWidget
*vb
, bool is_horizontal
)
4547 if (GTK_IS_BOX (vb
))
4549 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4550 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4551 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4555 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4561 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4562 const char *icon_name
, const struct image
*img
,
4563 const char *label
, bool horiz
)
4567 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4568 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4570 /* Check if the tool icon matches. */
4571 if (stock_name
&& wimage
)
4573 old
= g_object_get_data (G_OBJECT (wimage
),
4574 XG_TOOL_BAR_STOCK_NAME
);
4575 if (!old
|| strcmp (old
, stock_name
))
4578 else if (icon_name
&& wimage
)
4580 old
= g_object_get_data (G_OBJECT (wimage
),
4581 XG_TOOL_BAR_ICON_NAME
);
4582 if (!old
|| strcmp (old
, icon_name
))
4587 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4588 XG_TOOL_BAR_IMAGE_DATA
);
4589 Pixmap old_img
= (Pixmap
) gold_img
;
4590 if (old_img
!= img
->pixmap
)
4594 /* Check button configuration and label. */
4595 if (is_box_type (vb
, horiz
)
4596 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4599 /* Ensure label is correct. */
4601 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4606 xg_update_tool_bar_sizes (struct frame
*f
)
4608 struct x_output
*x
= f
->output_data
.x
;
4610 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4611 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4613 gtk_widget_get_preferred_size (GTK_WIDGET (top_widget
), NULL
, &req
);
4614 if (x
->toolbar_in_hbox
)
4617 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4619 "position", &pos
, NULL
);
4620 if (pos
== 0) nl
= req
.width
;
4621 else nr
= req
.width
;
4626 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4628 "position", &pos
, NULL
);
4629 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4630 else nb
= req
.height
;
4633 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4634 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4635 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4636 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4638 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4639 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4640 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4641 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4642 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4643 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4651 /* Update the tool bar for frame F. Add new buttons and remove old. */
4654 update_frame_tool_bar (struct frame
*f
)
4657 struct x_output
*x
= f
->output_data
.x
;
4658 int hmargin
= 0, vmargin
= 0;
4659 GtkToolbar
*wtoolbar
;
4661 GtkTextDirection dir
;
4663 bool text_image
, horiz
;
4664 struct xg_frame_tb_info
*tbinfo
;
4666 if (! FRAME_GTK_WIDGET (f
))
4671 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4673 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4674 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4676 else if (CONSP (Vtool_bar_button_margin
))
4678 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4679 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4681 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4682 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4685 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4686 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4687 i.e. zero. This means that margins less than
4688 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4689 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4690 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4692 if (! x
->toolbar_widget
)
4693 xg_create_tool_bar (f
);
4695 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4696 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4698 style
= Ftool_bar_get_system_style ();
4700 /* Are we up to date? */
4701 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4704 if (! NILP (tbinfo
->last_tool_bar
) && ! NILP (f
->tool_bar_items
)
4705 && tbinfo
->n_last_items
== f
->n_tool_bar_items
4706 && tbinfo
->hmargin
== hmargin
&& tbinfo
->vmargin
== vmargin
4707 && tbinfo
->dir
== dir
4708 && ! NILP (Fequal (tbinfo
->style
, style
))
4709 && ! NILP (Fequal (tbinfo
->last_tool_bar
, f
->tool_bar_items
)))
4715 tbinfo
->last_tool_bar
= f
->tool_bar_items
;
4716 tbinfo
->n_last_items
= f
->n_tool_bar_items
;
4717 tbinfo
->style
= style
;
4718 tbinfo
->hmargin
= hmargin
;
4719 tbinfo
->vmargin
= vmargin
;
4722 text_image
= EQ (style
, Qtext_image_horiz
);
4723 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4725 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4727 bool enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4728 bool selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4732 struct image
*img
= NULL
;
4734 Lisp_Object stock
= Qnil
;
4735 GtkStockItem stock_item
;
4736 char *stock_name
= NULL
;
4737 char *icon_name
= NULL
;
4739 GtkWidget
*wbutton
= NULL
;
4740 Lisp_Object specified_file
;
4741 bool vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4743 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4744 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4745 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4748 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4750 /* If this is a separator, use a gtk separator item. */
4751 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4753 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4756 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4758 ti
= gtk_separator_tool_item_new ();
4759 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4765 /* Otherwise, the tool-bar item is an ordinary button. */
4767 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4769 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4773 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4775 /* Ignore invalid image specifications. */
4776 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4777 if (!valid_image_p (image
))
4780 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4785 specified_file
= file_for_image (image
);
4786 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4787 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4789 if (STRINGP (stock
))
4791 stock_name
= SSDATA (stock
);
4792 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4794 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4795 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4797 icon_name
= stock_name
+ 2;
4801 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4804 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4806 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4807 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4815 if (stock_name
== NULL
&& icon_name
== NULL
)
4817 /* No stock image, or stock item not known. Try regular
4818 image. If image is a vector, choose it according to the
4820 if (dir
== GTK_TEXT_DIR_RTL
4821 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4823 image
= find_rtl_image (f
, image
, rtl
);
4825 if (VECTORP (image
))
4829 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4830 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4833 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4834 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4836 eassert (ASIZE (image
) >= idx
);
4837 image
= AREF (image
, idx
);
4842 img_id
= lookup_image (f
, image
);
4843 img
= IMAGE_FROM_ID (f
, img_id
);
4844 prepare_image_for_display (f
, img
);
4846 if (img
->load_failed_p
|| img
->pixmap
== None
)
4849 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4855 /* If there is an existing widget, check if it's stale; if so,
4856 remove it and make a new tool item from scratch. */
4857 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4860 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4869 /* Save the image so we can see if an update is needed the
4870 next time we call xg_tool_item_match_p. */
4871 if (EQ (style
, Qtext
))
4873 else if (stock_name
)
4875 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4876 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4877 (gpointer
) xstrdup (stock_name
),
4878 (GDestroyNotify
) xfree
);
4882 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4883 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4884 (gpointer
) xstrdup (icon_name
),
4885 (GDestroyNotify
) xfree
);
4889 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4890 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4891 (gpointer
)img
->pixmap
);
4894 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4895 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4896 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4901 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4905 /* Remove buttons not longer needed. */
4908 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4910 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4911 } while (ti
!= NULL
);
4913 if (f
->n_tool_bar_items
!= 0)
4915 if (! x
->toolbar_is_packed
)
4916 xg_pack_tool_bar (f
, f
->tool_bar_position
);
4917 gtk_widget_show_all (TOOLBAR_TOP_WIDGET (x
));
4918 if (xg_update_tool_bar_sizes (f
))
4919 xg_height_or_width_changed (f
);
4925 /* Deallocate all resources for the tool bar on frame F.
4926 Remove the tool bar. */
4929 free_frame_tool_bar (struct frame
*f
)
4931 struct x_output
*x
= f
->output_data
.x
;
4933 if (x
->toolbar_widget
)
4935 struct xg_frame_tb_info
*tbinfo
;
4936 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4939 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4940 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4941 if (x
->toolbar_is_packed
)
4943 if (x
->toolbar_in_hbox
)
4944 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4947 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4951 gtk_widget_destroy (x
->toolbar_widget
);
4953 x
->toolbar_widget
= 0;
4954 TOOLBAR_TOP_WIDGET (x
) = 0;
4955 x
->toolbar_is_packed
= false;
4956 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4957 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4959 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4964 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4969 xg_height_or_width_changed (f
);
4976 xg_change_toolbar_position (struct frame
*f
, Lisp_Object pos
)
4978 struct x_output
*x
= f
->output_data
.x
;
4979 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4981 if (! x
->toolbar_widget
|| ! top_widget
)
4985 g_object_ref (top_widget
);
4986 if (x
->toolbar_is_packed
)
4988 if (x
->toolbar_in_hbox
)
4989 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4992 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4996 xg_pack_tool_bar (f
, pos
);
4997 g_object_unref (top_widget
);
4998 if (xg_update_tool_bar_sizes (f
))
4999 xg_height_or_width_changed (f
);
5006 /***********************************************************************
5008 ***********************************************************************/
5010 xg_initialize (void)
5012 GtkBindingSet
*binding_set
;
5013 GtkSettings
*settings
;
5016 /* Work around a bug with corrupted data if libXft gets unloaded. This way
5017 we keep it permanently linked in. */
5022 xg_ignore_gtk_scrollbar
= 0;
5023 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
5024 xg_detached_menus
= 0;
5026 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
5027 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
5029 id_to_widget
.max_size
= id_to_widget
.used
= 0;
5030 id_to_widget
.widgets
= 0;
5032 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
5033 (gdk_display_get_default ()));
5034 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
5035 bindings. It doesn't seem to be any way to remove properties,
5036 so we set it to VoidSymbol which in X means "no key". */
5037 gtk_settings_set_string_property (settings
,
5038 "gtk-menu-bar-accel",
5042 /* Make GTK text input widgets use Emacs style keybindings. This is
5044 gtk_settings_set_string_property (settings
,
5045 "gtk-key-theme-name",
5049 /* Make dialogs close on C-g. Since file dialog inherits from
5050 dialog, this works for them also. */
5051 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
5052 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5055 /* Make menus close on C-g. */
5056 binding_set
= gtk_binding_set_by_class (g_type_class_ref
5057 (GTK_TYPE_MENU_SHELL
));
5058 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5060 update_theme_scrollbar_width ();
5062 #ifdef HAVE_FREETYPE
5063 x_last_font_name
= NULL
;
5067 #endif /* USE_GTK */