1 /* Functions for creating and updating GTK widgets.
3 Copyright (C) 2003-2012 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_MAJOR_VERSION > 2 || GTK_MINOR_VERSION > 11
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_MAJOR_VERSION > 3 || (GTK_MAJOR_VERSION == 3 && GTK_MINOR_VERSION >= 2)
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
, FRAME_PTR 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_MAJOR_VERSION == 2 && GTK_MINOR_VERSION < 10
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 (FRAME_PTR 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 (FRAME_PTR 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 (FRAME_PTR 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 1 if color was found, 0 if not. */
582 xg_check_special_colors (struct frame
*f
,
583 const char *color_name
,
587 int get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
588 int 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
),
610 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
611 GdkColor
*grgb
= get_bg
612 ? &gsty
->bg
[GTK_STATE_SELECTED
]
613 : &gsty
->fg
[GTK_STATE_SELECTED
];
615 color
->red
= grgb
->red
;
616 color
->green
= grgb
->green
;
617 color
->blue
= grgb
->blue
;
618 color
->pixel
= grgb
->pixel
;
629 /***********************************************************************
631 ***********************************************************************/
632 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
633 We use that to pop down the tooltip. This happens if Gtk+ for some
634 reason wants to change or hide the tooltip. */
636 #ifdef USE_GTK_TOOLTIP
639 hierarchy_ch_cb (GtkWidget
*widget
,
640 GtkWidget
*previous_toplevel
,
643 FRAME_PTR f
= (FRAME_PTR
) user_data
;
644 struct x_output
*x
= f
->output_data
.x
;
645 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
647 if (! top
|| ! GTK_IS_WINDOW (top
))
648 gtk_widget_hide (previous_toplevel
);
651 /* Callback called when Gtk+ thinks a tooltip should be displayed.
652 We use it to get the tooltip window and the tooltip widget so
653 we can manipulate the ourselves.
655 Return FALSE ensures that the tooltip is not shown. */
658 qttip_cb (GtkWidget
*widget
,
661 gboolean keyboard_mode
,
665 FRAME_PTR f
= (FRAME_PTR
) user_data
;
666 struct x_output
*x
= f
->output_data
.x
;
667 if (x
->ttip_widget
== NULL
)
672 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
673 x
->ttip_widget
= tooltip
;
674 g_object_ref (G_OBJECT (tooltip
));
675 x
->ttip_lbl
= gtk_label_new ("");
676 g_object_ref (G_OBJECT (x
->ttip_lbl
));
677 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
678 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
680 /* Change stupid Gtk+ default line wrapping. */
681 p
= gtk_widget_get_parent (x
->ttip_lbl
);
682 list
= gtk_container_get_children (GTK_CONTAINER (p
));
683 for (iter
= list
; iter
; iter
= g_list_next (iter
))
685 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
686 if (GTK_IS_LABEL (w
))
687 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
691 /* ATK needs an empty title for some reason. */
692 gtk_window_set_title (x
->ttip_window
, "");
693 /* Realize so we can safely get screen later on. */
694 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
695 gtk_widget_realize (x
->ttip_lbl
);
697 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
698 G_CALLBACK (hierarchy_ch_cb
), f
);
703 #endif /* USE_GTK_TOOLTIP */
705 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
706 Return zero if no system tooltip available, non-zero otherwise. */
709 xg_prepare_tooltip (FRAME_PTR f
,
714 #ifndef USE_GTK_TOOLTIP
717 struct x_output
*x
= f
->output_data
.x
;
721 GtkSettings
*settings
;
722 gboolean tt_enabled
= TRUE
;
724 Lisp_Object encoded_string
;
726 if (!x
->ttip_lbl
) return 0;
729 encoded_string
= ENCODE_UTF_8 (string
);
730 widget
= GTK_WIDGET (x
->ttip_lbl
);
731 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
732 screen
= gdk_window_get_screen (gwin
);
733 settings
= gtk_settings_get_for_screen (screen
);
734 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
737 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
738 /* Record that we disabled it so it can be enabled again. */
739 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
743 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
744 g_object_set_data (G_OBJECT
745 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
746 "gdk-display-current-tooltip", NULL
);
748 /* Put our dummy widget in so we can get callbacks for unrealize and
749 hierarchy-changed. */
750 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
751 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
752 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
753 if (width
) *width
= req
.width
;
754 if (height
) *height
= req
.height
;
759 #endif /* USE_GTK_TOOLTIP */
762 /* Show the tooltip at ROOT_X and ROOT_Y.
763 xg_prepare_tooltip must have been called before this function. */
766 xg_show_tooltip (FRAME_PTR f
, int root_x
, int root_y
)
768 #ifdef USE_GTK_TOOLTIP
769 struct x_output
*x
= f
->output_data
.x
;
773 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
774 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
780 /* Hide tooltip if shown. Do nothing if not shown.
781 Return non-zero if tip was hidden, non-zero if not (i.e. not using
785 xg_hide_tooltip (FRAME_PTR f
)
788 #ifdef USE_GTK_TOOLTIP
789 if (f
->output_data
.x
->ttip_window
)
791 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
793 gtk_widget_hide (GTK_WIDGET (win
));
795 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
797 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
798 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
799 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
800 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
811 /***********************************************************************
812 General functions for creating widgets, resizing, events, e.t.c.
813 ***********************************************************************/
815 /* Make a geometry string and pass that to GTK. It seems this is the
816 only way to get geometry position right if the user explicitly
817 asked for a position when starting Emacs.
818 F is the frame we shall set geometry for. */
821 xg_set_geometry (FRAME_PTR f
)
823 if (f
->size_hint_flags
& (USPosition
| PPosition
))
825 int left
= f
->left_pos
;
826 int xneg
= f
->size_hint_flags
& XNegative
;
827 int top
= f
->top_pos
;
828 int yneg
= f
->size_hint_flags
& YNegative
;
829 char geom_str
[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
836 sprintf (geom_str
, "=%dx%d%c%d%c%d",
837 FRAME_PIXEL_WIDTH (f
),
838 FRAME_PIXEL_HEIGHT (f
),
839 (xneg
? '-' : '+'), left
,
840 (yneg
? '-' : '+'), top
);
842 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
844 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
848 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
849 and use a GtkFixed widget, this doesn't happen automatically. */
852 xg_clear_under_internal_border (FRAME_PTR f
)
854 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
856 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
857 gtk_widget_queue_draw (wfixed
);
858 gdk_window_process_all_updates ();
859 x_clear_area (FRAME_X_DISPLAY (f
),
862 FRAME_PIXEL_WIDTH (f
),
863 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
864 x_clear_area (FRAME_X_DISPLAY (f
),
867 FRAME_INTERNAL_BORDER_WIDTH (f
),
868 FRAME_PIXEL_HEIGHT (f
), 0);
869 x_clear_area (FRAME_X_DISPLAY (f
),
871 0, FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
872 FRAME_PIXEL_WIDTH (f
),
873 FRAME_INTERNAL_BORDER_WIDTH (f
), 0);
874 x_clear_area (FRAME_X_DISPLAY (f
),
876 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
878 FRAME_INTERNAL_BORDER_WIDTH (f
),
879 FRAME_PIXEL_HEIGHT (f
), 0);
883 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
884 and a Gtk+ menu bar, we get resize events for the edit part of the
885 frame only. We let Gtk+ deal with the Gtk+ parts.
886 F is the frame to resize.
887 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
890 xg_frame_resized (FRAME_PTR f
, int pixelwidth
, int pixelheight
)
894 if (pixelwidth
== -1 && pixelheight
== -1)
896 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
897 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
899 &pixelwidth
, &pixelheight
);
904 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
905 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
907 if (columns
!= FRAME_COLS (f
)
908 || rows
!= FRAME_LINES (f
)
909 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
910 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
912 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
913 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
915 xg_clear_under_internal_border (f
);
916 change_frame_size (f
, rows
, columns
, 0, 1, 0);
917 SET_FRAME_GARBAGED (f
);
918 cancel_mouse_face (f
);
922 /* Resize the outer window of frame F after changing the height.
923 COLUMNS/ROWS is the size the edit area shall have after the resize. */
926 xg_frame_set_char_size (FRAME_PTR f
, int cols
, int rows
)
928 int pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
929 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
932 if (FRAME_PIXEL_HEIGHT (f
) == 0)
935 /* Take into account the size of the scroll bar. Always use the
936 number of columns occupied by the scroll bar here otherwise we
937 might end up with a frame width that is not a multiple of the
938 frame's character width which is bad for vertically split
940 f
->scroll_bar_actual_width
941 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
943 compute_fringe_widths (f
, 0);
945 /* FRAME_TEXT_COLS_TO_PIXEL_WIDTH uses scroll_bar_actual_width, so call it
946 after calculating that value. */
947 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
)
948 + FRAME_TOOLBAR_WIDTH (f
);
951 /* Do this before resize, as we don't know yet if we will be resized. */
952 xg_clear_under_internal_border (f
);
954 /* Must resize our top level widget. Font size may have changed,
955 but not rows/cols. */
956 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
957 pixelwidth
, pixelheight
);
958 x_wm_set_size_hint (f
, 0, 0);
960 SET_FRAME_GARBAGED (f
);
961 cancel_mouse_face (f
);
963 /* We can not call change_frame_size for a mapped frame,
964 we can not set pixel width/height either. The window manager may
965 override our resize request, XMonad does this all the time.
966 The best we can do is try to sync, so lisp code sees the updated
967 size as fast as possible.
968 For unmapped windows, we can set rows/cols. When
969 the frame is mapped again we will (hopefully) get the correct size. */
970 if (f
->async_visible
)
972 /* Must call this to flush out events */
973 (void)gtk_events_pending ();
975 x_wait_for_event (f
, ConfigureNotify
);
979 change_frame_size (f
, rows
, cols
, 0, 1, 0);
980 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
981 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
985 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
986 The policy is to keep the number of editable lines. */
989 xg_height_or_width_changed (FRAME_PTR f
)
991 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
992 FRAME_TOTAL_PIXEL_WIDTH (f
),
993 FRAME_TOTAL_PIXEL_HEIGHT (f
));
994 f
->output_data
.x
->hint_flags
= 0;
995 x_wm_set_size_hint (f
, 0, 0);
998 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
999 Must be done like this, because GtkWidget:s can have "hidden"
1000 X Window that aren't accessible.
1002 Return 0 if no widget match WDESC. */
1005 xg_win_to_widget (Display
*dpy
, Window wdesc
)
1008 GtkWidget
*gwdesc
= 0;
1012 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
1017 event
.any
.window
= gdkwin
;
1018 event
.any
.type
= GDK_NOTHING
;
1019 gwdesc
= gtk_get_event_widget (&event
);
1026 /* Set the background of widget W to PIXEL. */
1029 xg_set_widget_bg (FRAME_PTR f
, GtkWidget
*w
, long unsigned int pixel
)
1035 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
1037 bg
.red
= (double)xbg
.red
/65536.0;
1038 bg
.green
= (double)xbg
.green
/65536.0;
1039 bg
.blue
= (double)xbg
.blue
/65536.0;
1041 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
1045 GdkColormap
*map
= gtk_widget_get_colormap (w
);
1046 gdk_colormap_query_color (map
, pixel
, &bg
);
1047 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
1051 /* Callback called when the gtk theme changes.
1052 We notify lisp code so it can fix faces used for region for example. */
1055 style_changed_cb (GObject
*go
,
1059 struct input_event event
;
1060 GdkDisplay
*gdpy
= (GdkDisplay
*) user_data
;
1061 const char *display_name
= gdk_display_get_name (gdpy
);
1062 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1065 event
.kind
= CONFIG_CHANGED_EVENT
;
1066 event
.frame_or_window
= build_string (display_name
);
1067 /* Theme doesn't change often, so intern is called seldom. */
1068 event
.arg
= intern ("theme-name");
1069 kbd_buffer_store_event (&event
);
1071 update_theme_scrollbar_width ();
1073 /* If scroll bar width changed, we need set the new size on all frames
1077 Lisp_Object rest
, frame
;
1078 FOR_EACH_FRAME (rest
, frame
)
1080 FRAME_PTR f
= XFRAME (frame
);
1081 if (FRAME_X_DISPLAY (f
) == dpy
)
1083 x_set_scroll_bar_default_width (f
);
1084 xg_frame_set_char_size (f
, FRAME_COLS (f
), FRAME_LINES (f
));
1090 /* Called when a delete-event occurs on WIDGET. */
1093 delete_cb (GtkWidget
*widget
,
1098 /* The event doesn't arrive in the normal event loop. Send event
1100 FRAME_PTR f
= (FRAME_PTR
) user_data
;
1101 struct input_event ie
;
1104 ie
.kind
= DELETE_WINDOW_EVENT
;
1105 XSETFRAME (ie
.frame_or_window
, f
);
1106 kbd_buffer_store_event (&ie
);
1112 /* Create and set up the GTK widgets for frame F.
1113 Return 0 if creation failed, non-zero otherwise. */
1116 xg_create_frame_widgets (FRAME_PTR f
)
1119 GtkWidget
*wvbox
, *whbox
;
1128 if (FRAME_X_EMBEDDED_P (f
))
1130 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1131 wtop
= gtk_plug_new_for_display (gdpy
, f
->output_data
.x
->parent_desc
);
1134 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1136 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1137 has backported it to Gtk+ 2.0 and they add the resize grip for
1138 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1139 forever, so disable the grip. */
1140 #if GTK_MAJOR_VERSION < 3 && defined (HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1141 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop
), FALSE
);
1144 xg_set_screen (wtop
, f
);
1146 wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1147 whbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1148 gtk_box_set_homogeneous (GTK_BOX (wvbox
), FALSE
);
1149 gtk_box_set_homogeneous (GTK_BOX (whbox
), FALSE
);
1152 wfixed
= emacs_fixed_new (f
);
1154 wfixed
= gtk_fixed_new ();
1157 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1159 if (wtop
) gtk_widget_destroy (wtop
);
1160 if (wvbox
) gtk_widget_destroy (wvbox
);
1161 if (whbox
) gtk_widget_destroy (whbox
);
1162 if (wfixed
) gtk_widget_destroy (wfixed
);
1168 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1169 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1170 gtk_widget_set_name (wvbox
, "pane");
1171 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1173 /* If this frame has a title or name, set it in the title bar. */
1174 if (! NILP (f
->title
))
1175 title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1176 else if (! NILP (f
->name
))
1177 title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1179 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1181 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1182 FRAME_GTK_WIDGET (f
) = wfixed
;
1183 f
->output_data
.x
->vbox_widget
= wvbox
;
1184 f
->output_data
.x
->hbox_widget
= whbox
;
1186 gtk_widget_set_has_window (wfixed
, TRUE
);
1188 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1189 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1190 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1192 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1193 update_frame_tool_bar (f
);
1195 /* We don't want this widget double buffered, because we draw on it
1196 with regular X drawing primitives, so from a GTK/GDK point of
1197 view, the widget is totally blank. When an expose comes, this
1198 will make the widget blank, and then Emacs redraws it. This flickers
1199 a lot, so we turn off double buffering. */
1200 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1202 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1203 SSDATA (Vx_resource_name
),
1204 SSDATA (Vx_resource_class
));
1206 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1207 GTK is to destroy the widget. We want Emacs to do that instead. */
1208 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1209 G_CALLBACK (delete_cb
), f
);
1211 /* Convert our geometry parameters into a geometry string
1213 GTK will itself handle calculating the real position this way. */
1214 xg_set_geometry (f
);
1216 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1218 gtk_widget_add_events (wfixed
,
1219 GDK_POINTER_MOTION_MASK
1221 | GDK_BUTTON_PRESS_MASK
1222 | GDK_BUTTON_RELEASE_MASK
1223 | GDK_KEY_PRESS_MASK
1224 | GDK_ENTER_NOTIFY_MASK
1225 | GDK_LEAVE_NOTIFY_MASK
1226 | GDK_FOCUS_CHANGE_MASK
1227 | GDK_STRUCTURE_MASK
1228 | GDK_VISIBILITY_NOTIFY_MASK
);
1230 /* Must realize the windows so the X window gets created. It is used
1231 by callers of this function. */
1232 gtk_widget_realize (wfixed
);
1233 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1235 /* Since GTK clears its window by filling with the background color,
1236 we must keep X and GTK background in sync. */
1237 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1240 /* Also, do not let any background pixmap to be set, this looks very
1241 bad as Emacs overwrites the background pixmap with its own idea
1242 of background color. */
1243 style
= gtk_widget_get_modifier_style (wfixed
);
1245 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1246 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1247 gtk_widget_modify_style (wfixed
, style
);
1249 gtk_widget_set_can_focus (wfixed
, TRUE
);
1250 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1253 #ifdef USE_GTK_TOOLTIP
1254 /* Steal a tool tip window we can move ourselves. */
1255 f
->output_data
.x
->ttip_widget
= 0;
1256 f
->output_data
.x
->ttip_lbl
= 0;
1257 f
->output_data
.x
->ttip_window
= 0;
1258 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1259 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1263 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1264 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1265 /* Only connect this signal once per screen. */
1266 if (! g_signal_handler_find (G_OBJECT (gs
),
1267 G_SIGNAL_MATCH_FUNC
,
1269 G_CALLBACK (style_changed_cb
),
1272 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1273 G_CALLBACK (style_changed_cb
),
1274 gdk_screen_get_display (screen
));
1284 xg_free_frame_widgets (FRAME_PTR f
)
1286 if (FRAME_GTK_OUTER_WIDGET (f
))
1288 #ifdef USE_GTK_TOOLTIP
1289 struct x_output
*x
= f
->output_data
.x
;
1291 struct xg_frame_tb_info
*tbinfo
1292 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
1297 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1298 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1299 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1300 #ifdef USE_GTK_TOOLTIP
1302 gtk_widget_destroy (x
->ttip_lbl
);
1304 g_object_unref (G_OBJECT (x
->ttip_widget
));
1309 /* Set the normal size hints for the window manager, for frame F.
1310 FLAGS is the flags word to use--or 0 meaning preserve the flags
1311 that the window now has.
1312 If USER_POSITION is nonzero, we set the User Position
1313 flag (this is useful when FLAGS is 0). */
1316 x_wm_set_size_hint (FRAME_PTR f
, long int flags
, int user_position
)
1318 /* Must use GTK routines here, otherwise GTK resets the size hints
1319 to its own defaults. */
1320 GdkGeometry size_hints
;
1321 gint hint_flags
= 0;
1322 int base_width
, base_height
;
1323 int min_rows
= 0, min_cols
= 0;
1324 int win_gravity
= f
->win_gravity
;
1326 /* Don't set size hints during initialization; that apparently leads
1327 to a race condition. See the thread at
1328 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1329 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1334 memset (&size_hints
, 0, sizeof (size_hints
));
1335 f
->output_data
.x
->size_hints
= size_hints
;
1336 f
->output_data
.x
->hint_flags
= hint_flags
;
1339 flags
= f
->size_hint_flags
;
1341 size_hints
= f
->output_data
.x
->size_hints
;
1342 hint_flags
= f
->output_data
.x
->hint_flags
;
1344 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1345 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
1346 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
1348 hint_flags
|= GDK_HINT_BASE_SIZE
;
1349 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0) + FRAME_TOOLBAR_WIDTH (f
);
1350 /* Use one row here so base_height does not become zero.
1351 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1352 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 1)
1353 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1355 check_frame_size (f
, &min_rows
, &min_cols
);
1356 if (min_rows
> 0) --min_rows
; /* We used one row in base_height = ... 1); */
1358 size_hints
.base_width
= base_width
;
1359 size_hints
.base_height
= base_height
;
1360 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
1361 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
1363 /* These currently have a one to one mapping with the X values, but I
1364 don't think we should rely on that. */
1365 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1366 size_hints
.win_gravity
= 0;
1367 if (win_gravity
== NorthWestGravity
)
1368 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1369 else if (win_gravity
== NorthGravity
)
1370 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1371 else if (win_gravity
== NorthEastGravity
)
1372 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1373 else if (win_gravity
== WestGravity
)
1374 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1375 else if (win_gravity
== CenterGravity
)
1376 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1377 else if (win_gravity
== EastGravity
)
1378 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1379 else if (win_gravity
== SouthWestGravity
)
1380 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1381 else if (win_gravity
== SouthGravity
)
1382 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1383 else if (win_gravity
== SouthEastGravity
)
1384 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1385 else if (win_gravity
== StaticGravity
)
1386 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1390 hint_flags
&= ~GDK_HINT_POS
;
1391 hint_flags
|= GDK_HINT_USER_POS
;
1394 if (hint_flags
!= f
->output_data
.x
->hint_flags
1395 || memcmp (&size_hints
,
1396 &f
->output_data
.x
->size_hints
,
1397 sizeof (size_hints
)) != 0)
1400 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1401 NULL
, &size_hints
, hint_flags
);
1402 f
->output_data
.x
->size_hints
= size_hints
;
1403 f
->output_data
.x
->hint_flags
= hint_flags
;
1408 /* Change background color of a frame.
1409 Since GTK uses the background color to clear the window, we must
1410 keep the GTK and X colors in sync.
1411 F is the frame to change,
1412 BG is the pixel value to change to. */
1415 xg_set_background_color (FRAME_PTR f
, long unsigned int bg
)
1417 if (FRAME_GTK_WIDGET (f
))
1420 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1426 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1427 functions so GTK does not overwrite the icon. */
1430 xg_set_frame_icon (FRAME_PTR f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1432 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1436 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1441 /***********************************************************************
1443 ***********************************************************************/
1444 /* Return the dialog title to use for a dialog of type KEY.
1445 This is the encoding used by lwlib. We use the same for GTK. */
1448 get_dialog_title (char key
)
1450 const char *title
= "";
1458 title
= "Information";
1477 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1478 the dialog, but return TRUE so the event does not propagate further
1479 in GTK. This prevents GTK from destroying the dialog widget automatically
1480 and we can always destroy the widget manually, regardless of how
1481 it was popped down (button press or WM_DELETE_WINDOW).
1482 W is the dialog widget.
1483 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1484 user_data is NULL (not used).
1486 Returns TRUE to end propagation of event. */
1489 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1491 gtk_widget_unmap (w
);
1495 /* Create a popup dialog window. See also xg_create_widget below.
1496 WV is a widget_value describing the dialog.
1497 SELECT_CB is the callback to use when a button has been pressed.
1498 DEACTIVATE_CB is the callback to use when the dialog pops down.
1500 Returns the GTK dialog widget. */
1503 create_dialog (widget_value
*wv
,
1504 GCallback select_cb
,
1505 GCallback deactivate_cb
)
1507 const char *title
= get_dialog_title (wv
->name
[0]);
1508 int total_buttons
= wv
->name
[1] - '0';
1509 int right_buttons
= wv
->name
[4] - '0';
1512 int button_spacing
= 10;
1513 GtkWidget
*wdialog
= gtk_dialog_new ();
1514 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1515 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1517 GtkWidget
*whbox_down
;
1519 /* If the number of buttons is greater than 4, make two rows of buttons
1520 instead. This looks better. */
1521 int make_two_rows
= total_buttons
> 4;
1523 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1524 left_buttons
= total_buttons
- right_buttons
;
1526 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1527 gtk_widget_set_name (wdialog
, "emacs-dialog");
1532 GtkWidget
*wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, button_spacing
);
1533 GtkWidget
*whbox_up
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1534 gtk_box_set_homogeneous (GTK_BOX (wvbox
), TRUE
);
1535 gtk_box_set_homogeneous (GTK_BOX (whbox_up
), FALSE
);
1536 whbox_down
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1537 gtk_box_set_homogeneous (GTK_BOX (whbox_down
), FALSE
);
1539 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1540 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1541 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1543 cur_box
= GTK_BOX (whbox_up
);
1546 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1547 G_CALLBACK (dialog_delete_callback
), 0);
1551 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1552 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1555 for (item
= wv
->contents
; item
; item
= item
->next
)
1557 char *utf8_label
= get_utf8_string (item
->value
);
1561 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1563 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1564 /* This is the text part of the dialog. */
1565 w
= gtk_label_new (utf8_label
);
1566 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1567 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1568 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1570 /* Try to make dialog look better. Must realize first so
1571 the widget can calculate the size it needs. */
1572 gtk_widget_realize (w
);
1573 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1574 gtk_box_set_spacing (wvbox
, req
.height
);
1575 if (item
->value
&& strlen (item
->value
) > 0)
1576 button_spacing
= 2*req
.width
/strlen (item
->value
);
1580 /* This is one button to add to the dialog. */
1581 w
= gtk_button_new_with_label (utf8_label
);
1582 if (! item
->enabled
)
1583 gtk_widget_set_sensitive (w
, FALSE
);
1585 g_signal_connect (G_OBJECT (w
), "clicked",
1586 select_cb
, item
->call_data
);
1588 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1589 if (++button_nr
== left_buttons
)
1592 cur_box
= GTK_BOX (whbox_down
);
1594 gtk_box_pack_start (cur_box
,
1602 g_free (utf8_label
);
1608 struct xg_dialog_data
1616 /* Function that is called when the file or font dialogs pop down.
1617 W is the dialog widget, RESPONSE is the response code.
1618 USER_DATA is what we passed in to g_signal_connect. */
1621 xg_dialog_response_cb (GtkDialog
*w
,
1625 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*)user_data
;
1626 dd
->response
= response
;
1627 g_main_loop_quit (dd
->loop
);
1631 /* Destroy the dialog. This makes it pop down. */
1634 pop_down_dialog (Lisp_Object arg
)
1636 struct Lisp_Save_Value
*p
= XSAVE_VALUE (arg
);
1637 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) p
->pointer
;
1640 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1641 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1643 g_main_loop_quit (dd
->loop
);
1644 g_main_loop_unref (dd
->loop
);
1651 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1652 We pass in DATA as gpointer* so we can use this as a callback. */
1655 xg_maybe_add_timer (gpointer data
)
1657 struct xg_dialog_data
*dd
= (struct xg_dialog_data
*) data
;
1658 EMACS_TIME next_time
= timer_check ();
1662 if (EMACS_TIME_VALID_P (next_time
))
1664 time_t s
= EMACS_SECS (next_time
);
1665 int per_ms
= EMACS_TIME_RESOLUTION
/ 1000;
1666 int ms
= (EMACS_NSECS (next_time
) + per_ms
- 1) / per_ms
;
1667 if (s
<= ((guint
) -1 - ms
) / 1000)
1668 dd
->timerid
= g_timeout_add (s
* 1000 + ms
, xg_maybe_add_timer
, dd
);
1674 /* Pops up a modal dialog W and waits for response.
1675 We don't use gtk_dialog_run because we want to process emacs timers.
1676 The dialog W is not destroyed when this function returns. */
1679 xg_dialog_run (FRAME_PTR f
, GtkWidget
*w
)
1681 ptrdiff_t count
= SPECPDL_INDEX ();
1682 struct xg_dialog_data dd
;
1684 xg_set_screen (w
, f
);
1685 gtk_window_set_transient_for (GTK_WINDOW (w
),
1686 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1687 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1688 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1690 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1691 dd
.response
= GTK_RESPONSE_CANCEL
;
1695 g_signal_connect (G_OBJECT (w
),
1697 G_CALLBACK (xg_dialog_response_cb
),
1699 /* Don't destroy the widget if closed by the window manager close button. */
1700 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1701 gtk_widget_show (w
);
1703 record_unwind_protect (pop_down_dialog
, make_save_value (&dd
, 0));
1705 (void) xg_maybe_add_timer (&dd
);
1706 g_main_loop_run (dd
.loop
);
1709 unbind_to (count
, Qnil
);
1715 /***********************************************************************
1716 File dialog functions
1717 ***********************************************************************/
1718 /* Return non-zero if the old file selection dialog is being used.
1719 Return zero if not. */
1722 xg_uses_old_file_dialog (void)
1724 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1725 return x_gtk_use_old_file_dialog
;
1732 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1734 /* Return the selected file for file chooser dialog W.
1735 The returned string must be free:d. */
1738 xg_get_file_name_from_chooser (GtkWidget
*w
)
1740 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1743 /* Callback called when the "Show hidden files" toggle is pressed.
1744 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1747 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1749 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1751 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1752 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1756 /* Callback called when a property changes in a file chooser.
1757 GOBJECT is the file chooser dialog, ARG1 describes the property.
1758 USER_DATA is the toggle widget in the file chooser dialog.
1759 We use this to update the "Show hidden files" toggle when the user
1760 changes that property by right clicking in the file list. */
1763 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1765 if (strcmp (arg1
->name
, "show-hidden") == 0)
1767 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1768 gboolean visible
, toggle_on
;
1770 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1771 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1773 if (!!visible
!= !!toggle_on
)
1775 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1776 G_CALLBACK (xg_toggle_visibility_cb
),
1778 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1779 g_signal_handlers_unblock_by_func
1780 (G_OBJECT (wtoggle
),
1781 G_CALLBACK (xg_toggle_visibility_cb
),
1784 x_gtk_show_hidden_files
= visible
;
1788 /* Read a file name from the user using a file chooser dialog.
1789 F is the current frame.
1790 PROMPT is a prompt to show to the user. May not be NULL.
1791 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1792 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1793 file. (Actually, this only has cosmetic effects, the user can
1794 still enter a non-existing file.) *FUNC is set to a function that
1795 can be used to retrieve the selected file name from the returned widget.
1797 Returns the created widget. */
1800 xg_get_file_with_chooser (FRAME_PTR f
,
1802 char *default_filename
,
1803 int mustmatch_p
, int only_dir_p
,
1804 xg_get_file_func
*func
)
1808 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1809 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1810 GtkFileChooserAction action
= (mustmatch_p
?
1811 GTK_FILE_CHOOSER_ACTION_OPEN
:
1812 GTK_FILE_CHOOSER_ACTION_SAVE
);
1815 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1817 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1818 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1819 (mustmatch_p
|| only_dir_p
?
1820 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1823 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1825 wbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1826 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
1827 gtk_widget_show (wbox
);
1828 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1830 if (x_gtk_show_hidden_files
)
1832 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1833 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1835 gtk_widget_show (wtoggle
);
1836 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1837 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1838 g_signal_connect (G_OBJECT (filewin
), "notify",
1839 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1841 if (x_gtk_file_dialog_help_text
)
1844 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1845 Show the C-l help text only for versions < 2.10. */
1846 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1847 strcat (msgbuf
, "\nType C-l to display a file name text entry box.\n");
1848 strcat (msgbuf
, "\nIf you don't like this file selector, use the "
1849 "corresponding\nkey binding or customize "
1850 "use-file-dialog to turn it off.");
1852 wmessage
= gtk_label_new (msgbuf
);
1853 gtk_widget_show (wmessage
);
1856 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1857 if (x_gtk_file_dialog_help_text
)
1858 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1859 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1861 if (default_filename
)
1864 struct gcpro gcpro1
;
1865 char *utf8_filename
;
1868 file
= build_string (default_filename
);
1870 /* File chooser does not understand ~/... in the file name. It must be
1871 an absolute name starting with /. */
1872 if (default_filename
[0] != '/')
1873 file
= Fexpand_file_name (file
, Qnil
);
1875 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1876 if (! NILP (Ffile_directory_p (file
)))
1877 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1881 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1883 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1885 char *cp
= strrchr (utf8_filename
, '/');
1887 else cp
= utf8_filename
;
1888 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1895 *func
= xg_get_file_name_from_chooser
;
1899 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1901 /* Return the selected file for file selector dialog W.
1902 The returned string must be free:d. */
1905 xg_get_file_name_from_selector (GtkWidget
*w
)
1907 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1908 return xstrdup ((char*) gtk_file_selection_get_filename (filesel
));
1911 /* Create a file selection dialog.
1912 F is the current frame.
1913 PROMPT is a prompt to show to the user. May not be NULL.
1914 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1915 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1916 file. *FUNC is set to a function that can be used to retrieve the
1917 selected file name from the returned widget.
1919 Returns the created widget. */
1922 xg_get_file_with_selection (FRAME_PTR f
,
1924 char *default_filename
,
1925 int mustmatch_p
, int only_dir_p
,
1926 xg_get_file_func
*func
)
1929 GtkFileSelection
*filesel
;
1931 filewin
= gtk_file_selection_new (prompt
);
1932 filesel
= GTK_FILE_SELECTION (filewin
);
1934 if (default_filename
)
1935 gtk_file_selection_set_filename (filesel
, default_filename
);
1939 /* The selection_entry part of filesel is not documented. */
1940 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1941 gtk_file_selection_hide_fileop_buttons (filesel
);
1944 *func
= xg_get_file_name_from_selector
;
1948 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1950 /* Read a file name from the user using a file dialog, either the old
1951 file selection dialog, or the new file chooser dialog. Which to use
1952 depends on what the GTK version used has, and what the value of
1953 gtk-use-old-file-dialog.
1954 F is the current frame.
1955 PROMPT is a prompt to show to the user. May not be NULL.
1956 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1957 If MUSTMATCH_P is non-zero, the returned file name must be an existing
1960 Returns a file name or NULL if no file was selected.
1961 The returned string must be freed by the caller. */
1964 xg_get_file_name (FRAME_PTR f
,
1966 char *default_filename
,
1972 int filesel_done
= 0;
1973 xg_get_file_func func
;
1975 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
1976 /* I really don't know why this is needed, but without this the GLIBC add on
1977 library linuxthreads hangs when the Gnome file chooser backend creates
1979 sigblock (sigmask (__SIGRTMIN
));
1980 #endif /* HAVE_PTHREAD */
1982 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1984 if (xg_uses_old_file_dialog ())
1985 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1986 mustmatch_p
, only_dir_p
, &func
);
1988 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1989 mustmatch_p
, only_dir_p
, &func
);
1991 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1992 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1993 mustmatch_p
, only_dir_p
, &func
);
1994 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1996 gtk_widget_set_name (w
, "emacs-filedialog");
1998 filesel_done
= xg_dialog_run (f
, w
);
2000 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
2001 sigunblock (sigmask (__SIGRTMIN
));
2004 if (filesel_done
== GTK_RESPONSE_OK
)
2007 gtk_widget_destroy (w
);
2011 /***********************************************************************
2013 ***********************************************************************/
2015 #ifdef HAVE_FREETYPE
2017 #if USE_NEW_GTK_FONT_CHOOSER
2019 extern Lisp_Object Qxft
, Qnormal
;
2020 extern Lisp_Object Qextra_light
, Qlight
, Qsemi_light
, Qsemi_bold
;
2021 extern Lisp_Object Qbold
, Qextra_bold
, Qultra_bold
;
2022 extern Lisp_Object Qoblique
, Qitalic
;
2024 #define XG_WEIGHT_TO_SYMBOL(w) \
2025 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
2026 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
2027 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
2028 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
2029 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
2030 : w <= PANGO_WEIGHT_BOLD ? Qbold \
2031 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
2034 #define XG_STYLE_TO_SYMBOL(s) \
2035 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
2036 : s == PANGO_STYLE_ITALIC ? Qitalic \
2039 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2042 static char *x_last_font_name
;
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 (FRAME_PTR f
, const char *default_name
)
2058 Lisp_Object font
= Qnil
;
2060 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
2061 sigblock (sigmask (__SIGRTMIN
));
2062 #endif /* HAVE_PTHREAD */
2064 w
= gtk_font_chooser_dialog_new
2065 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2069 /* Convert fontconfig names to Gtk names, i.e. remove - before
2071 char *p
= strrchr (default_name
, '-');
2075 while (isdigit (*ep
))
2077 if (*ep
== '\0') *p
= ' ';
2080 else if (x_last_font_name
)
2081 default_name
= x_last_font_name
;
2084 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w
), default_name
);
2086 gtk_widget_set_name (w
, "emacs-fontdialog");
2087 done
= xg_dialog_run (f
, w
);
2089 #if defined (HAVE_PTHREAD) && defined (__SIGRTMIN)
2090 sigunblock (sigmask (__SIGRTMIN
));
2093 if (done
== GTK_RESPONSE_OK
)
2095 #if USE_NEW_GTK_FONT_CHOOSER
2096 /* Use the GTK3 font chooser. */
2097 PangoFontDescription
*desc
2098 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w
));
2102 Lisp_Object args
[10];
2103 const char *name
= pango_font_description_get_family (desc
);
2104 gint size
= pango_font_description_get_size (desc
);
2105 PangoWeight weight
= pango_font_description_get_weight (desc
);
2106 PangoStyle style
= pango_font_description_get_style (desc
);
2109 args
[1] = build_string (name
);
2112 args
[3] = make_float (pango_units_to_double (size
));
2115 args
[5] = XG_WEIGHT_TO_SYMBOL (weight
);
2118 args
[7] = XG_STYLE_TO_SYMBOL (style
);
2123 font
= Ffont_spec (8, args
);
2125 pango_font_description_free (desc
);
2126 xfree (x_last_font_name
);
2127 x_last_font_name
= xstrdup (name
);
2130 #else /* Use old font selector, which just returns the font name. */
2133 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w
));
2137 font
= build_string (font_name
);
2138 g_free (x_last_font_name
);
2139 x_last_font_name
= font_name
;
2141 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2144 gtk_widget_destroy (w
);
2147 #endif /* HAVE_FREETYPE */
2151 /***********************************************************************
2153 ***********************************************************************/
2155 /* The name of menu items that can be used for customization. Since GTK
2156 RC files are very crude and primitive, we have to set this on all
2157 menu item names so a user can easily customize menu items. */
2159 #define MENU_ITEM_NAME "emacs-menuitem"
2162 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2163 during GC. The next member points to the items. */
2164 static xg_list_node xg_menu_cb_list
;
2166 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2167 during GC. The next member points to the items. */
2168 static xg_list_node xg_menu_item_cb_list
;
2170 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2171 F is the frame CL_DATA will be initialized for.
2172 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2174 The menu bar and all sub menus under the menu bar in a frame
2175 share the same structure, hence the reference count.
2177 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2178 allocated xg_menu_cb_data if CL_DATA is NULL. */
2180 static xg_menu_cb_data
*
2181 make_cl_data (xg_menu_cb_data
*cl_data
, FRAME_PTR f
, GCallback highlight_cb
)
2185 cl_data
= xmalloc (sizeof *cl_data
);
2187 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2188 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2189 cl_data
->highlight_cb
= highlight_cb
;
2190 cl_data
->ref_count
= 0;
2192 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2195 cl_data
->ref_count
++;
2200 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2201 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2203 When the menu bar is updated, menu items may have been added and/or
2204 removed, so menu_bar_vector and menu_bar_items_used change. We must
2205 then update CL_DATA since it is used to determine which menu
2206 item that is invoked in the menu.
2207 HIGHLIGHT_CB could change, there is no check that the same
2208 function is given when modifying a menu bar as was given when
2209 creating the menu bar. */
2212 update_cl_data (xg_menu_cb_data
*cl_data
,
2214 GCallback highlight_cb
)
2219 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2220 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2221 cl_data
->highlight_cb
= highlight_cb
;
2225 /* Decrease reference count for CL_DATA.
2226 If reference count is zero, free CL_DATA. */
2229 unref_cl_data (xg_menu_cb_data
*cl_data
)
2231 if (cl_data
&& cl_data
->ref_count
> 0)
2233 cl_data
->ref_count
--;
2234 if (cl_data
->ref_count
== 0)
2236 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2242 /* Function that marks all lisp data during GC. */
2248 Lisp_Object rest
, frame
;
2250 for (iter
= xg_menu_cb_list
.next
; iter
; iter
= iter
->next
)
2251 mark_object (((xg_menu_cb_data
*) iter
)->menu_bar_vector
);
2253 for (iter
= xg_menu_item_cb_list
.next
; iter
; iter
= iter
->next
)
2255 xg_menu_item_cb_data
*cb_data
= (xg_menu_item_cb_data
*) iter
;
2257 if (! NILP (cb_data
->help
))
2258 mark_object (cb_data
->help
);
2261 FOR_EACH_FRAME (rest
, frame
)
2263 FRAME_PTR f
= XFRAME (frame
);
2265 if (FRAME_X_P (f
) && FRAME_GTK_OUTER_WIDGET (f
))
2267 struct xg_frame_tb_info
*tbinfo
2268 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
2272 mark_object (tbinfo
->last_tool_bar
);
2273 mark_object (tbinfo
->style
);
2280 /* Callback called when a menu item is destroyed. Used to free data.
2281 W is the widget that is being destroyed (not used).
2282 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2285 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2289 xg_menu_item_cb_data
*data
= (xg_menu_item_cb_data
*) client_data
;
2290 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2295 /* Callback called when the pointer enters/leaves a menu item.
2296 W is the parent of the menu item.
2297 EVENT is either an enter event or leave event.
2298 CLIENT_DATA is not used.
2300 Returns FALSE to tell GTK to keep processing this event. */
2303 menuitem_highlight_callback (GtkWidget
*w
,
2304 GdkEventCrossing
*event
,
2305 gpointer client_data
)
2308 GtkWidget
*subwidget
;
2309 xg_menu_item_cb_data
*data
;
2311 ev
.crossing
= *event
;
2312 subwidget
= gtk_get_event_widget (&ev
);
2313 data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (subwidget
),
2317 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2319 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2320 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2321 (*func
) (subwidget
, call_data
);
2328 /* Callback called when a menu is destroyed. Used to free data.
2329 W is the widget that is being destroyed (not used).
2330 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2333 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2335 unref_cl_data ((xg_menu_cb_data
*) client_data
);
2338 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2339 must be non-NULL) and can be inserted into a menu item.
2341 Returns the GtkHBox. */
2344 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2350 wbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
2351 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
2352 wlbl
= gtk_label_new (utf8_label
);
2353 wkey
= gtk_label_new (utf8_key
);
2355 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2356 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2358 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2359 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2361 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2362 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2363 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2368 /* Make and return a menu item widget with the key to the right.
2369 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2370 UTF8_KEY is the text representing the key binding.
2371 ITEM is the widget_value describing the menu item.
2373 GROUP is an in/out parameter. If the menu item to be created is not
2374 part of any radio menu group, *GROUP contains NULL on entry and exit.
2375 If the menu item to be created is part of a radio menu group, on entry
2376 *GROUP contains the group to use, or NULL if this is the first item
2377 in the group. On exit, *GROUP contains the radio item group.
2379 Unfortunately, keys don't line up as nicely as in Motif,
2380 but the MacOS X version doesn't either, so I guess that is OK. */
2383 make_menu_item (const char *utf8_label
,
2384 const char *utf8_key
,
2389 GtkWidget
*wtoadd
= 0;
2391 /* It has been observed that some menu items have a NULL name field.
2392 This will lead to this function being called with a NULL utf8_label.
2393 GTK crashes on that so we set a blank label. Why there is a NULL
2394 name remains to be investigated. */
2395 if (! utf8_label
) utf8_label
= " ";
2398 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2400 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2403 if (utf8_key
) w
= gtk_check_menu_item_new ();
2404 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2405 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2407 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2409 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2410 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2411 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2413 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2418 if (utf8_key
) w
= gtk_menu_item_new ();
2419 else w
= gtk_menu_item_new_with_label (utf8_label
);
2422 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2423 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2428 static int xg_detached_menus
;
2430 /* Returns non-zero if there are detached menus. */
2433 xg_have_tear_offs (void)
2435 return xg_detached_menus
> 0;
2438 /* Callback invoked when a detached menu window is removed. Here we
2439 decrease the xg_detached_menus count.
2440 WIDGET is the top level window that is removed (the parent of the menu).
2441 CLIENT_DATA is not used. */
2444 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2446 if (xg_detached_menus
> 0) --xg_detached_menus
;
2449 /* Callback invoked when a menu is detached. It increases the
2450 xg_detached_menus count.
2451 WIDGET is the GtkTearoffMenuItem.
2452 CLIENT_DATA is not used. */
2455 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2457 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2458 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2460 ++xg_detached_menus
;
2461 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2463 G_CALLBACK (tearoff_remove
), 0);
2468 /* Create a menu item widget, and connect the callbacks.
2469 ITEM describes the menu item.
2470 F is the frame the created menu belongs to.
2471 SELECT_CB is the callback to use when a menu item is selected.
2472 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2473 CL_DATA points to the callback data to be used for this menu.
2474 GROUP is an in/out parameter. If the menu item to be created is not
2475 part of any radio menu group, *GROUP contains NULL on entry and exit.
2476 If the menu item to be created is part of a radio menu group, on entry
2477 *GROUP contains the group to use, or NULL if this is the first item
2478 in the group. On exit, *GROUP contains the radio item group.
2480 Returns the created GtkWidget. */
2483 xg_create_one_menuitem (widget_value
*item
,
2485 GCallback select_cb
,
2486 GCallback highlight_cb
,
2487 xg_menu_cb_data
*cl_data
,
2493 xg_menu_item_cb_data
*cb_data
;
2495 utf8_label
= get_utf8_string (item
->name
);
2496 utf8_key
= get_utf8_string (item
->key
);
2498 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2500 if (utf8_label
) g_free (utf8_label
);
2501 if (utf8_key
) g_free (utf8_key
);
2503 cb_data
= xmalloc (sizeof *cb_data
);
2505 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2507 cb_data
->select_id
= 0;
2508 cb_data
->help
= item
->help
;
2509 cb_data
->cl_data
= cl_data
;
2510 cb_data
->call_data
= item
->call_data
;
2512 g_signal_connect (G_OBJECT (w
),
2514 G_CALLBACK (menuitem_destroy_callback
),
2517 /* Put cb_data in widget, so we can get at it when modifying menubar */
2518 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2520 /* final item, not a submenu */
2521 if (item
->call_data
&& ! item
->contents
)
2525 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2531 /* Create a full menu tree specified by DATA.
2532 F is the frame the created menu belongs to.
2533 SELECT_CB is the callback to use when a menu item is selected.
2534 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2535 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2536 POP_UP_P is non-zero if we shall create a popup menu.
2537 MENU_BAR_P is non-zero if we shall create a menu bar.
2538 ADD_TEAROFF_P is non-zero if we shall add a tearoff menu item. Ignored
2539 if MENU_BAR_P is non-zero.
2540 TOPMENU is the topmost GtkWidget that others shall be placed under.
2541 It may be NULL, in that case we create the appropriate widget
2542 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2543 CL_DATA is the callback data we shall use for this menu, or NULL
2544 if we haven't set the first callback yet.
2545 NAME is the name to give to the top level menu if this function
2546 creates it. May be NULL to not set any name.
2548 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2551 This function calls itself to create submenus. */
2554 create_menus (widget_value
*data
,
2556 GCallback select_cb
,
2557 GCallback deactivate_cb
,
2558 GCallback highlight_cb
,
2563 xg_menu_cb_data
*cl_data
,
2567 GtkWidget
*wmenu
= topmenu
;
2568 GSList
*group
= NULL
;
2574 wmenu
= gtk_menu_new ();
2575 xg_set_screen (wmenu
, f
);
2576 /* Connect this to the menu instead of items so we get enter/leave for
2577 disabled items also. TODO: Still does not get enter/leave for
2578 disabled items in detached menus. */
2579 g_signal_connect (G_OBJECT (wmenu
),
2580 "enter-notify-event",
2581 G_CALLBACK (menuitem_highlight_callback
),
2583 g_signal_connect (G_OBJECT (wmenu
),
2584 "leave-notify-event",
2585 G_CALLBACK (menuitem_highlight_callback
),
2590 wmenu
= gtk_menu_bar_new ();
2591 /* Set width of menu bar to a small value so it doesn't enlarge
2592 a small initial frame size. The width will be set to the
2593 width of the frame later on when it is added to a container.
2594 height -1: Natural height. */
2595 gtk_widget_set_size_request (wmenu
, 1, -1);
2598 /* Put cl_data on the top menu for easier access. */
2599 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2600 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2601 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2602 G_CALLBACK (menu_destroy_callback
), cl_data
);
2605 gtk_widget_set_name (wmenu
, name
);
2608 g_signal_connect (G_OBJECT (wmenu
),
2609 "selection-done", deactivate_cb
, 0);
2612 if (! menu_bar_p
&& add_tearoff_p
)
2614 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2615 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2617 g_signal_connect (G_OBJECT (tearoff
), "activate",
2618 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
, FRAME_PTR f
, widget_value
*val
,
2697 GCallback select_cb
, GCallback deactivate_cb
,
2698 GCallback highlight_cb
)
2701 int menu_bar_p
= strcmp (type
, "menubar") == 0;
2702 int 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 non-zero 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 int val_in_menubar
= 0;
2852 int 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 /* If this item has a submenu that has been detached, change
2911 the title in the WM decorations also. */
2912 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2913 /* Set the title of the detached window. */
2914 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2916 if (utf8_label
) g_free (utf8_label
);
2917 iter
= g_list_next (iter
);
2921 else if (! val_in_menubar
&& iter_in_new_menubar
)
2923 /* This corresponds to:
2930 GtkWidget
*w
= xg_create_one_menuitem (val
,
2937 /* Create a possibly empty submenu for menu bar items, since some
2938 themes don't highlight items correctly without it. */
2939 GtkWidget
*submenu
= create_menus (NULL
, f
,
2940 select_cb
, deactivate_cb
,
2942 0, 0, 0, 0, cl_data
, 0);
2943 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2944 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2945 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2947 g_list_free (*list
);
2948 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2949 while (nr
-- > 0) iter
= g_list_next (iter
);
2950 iter
= g_list_next (iter
);
2954 else /* if (val_in_menubar && iter_in_new_menubar) */
2957 /* This corresponds to:
2962 g_object_ref (G_OBJECT (witem2
));
2963 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2964 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2965 GTK_WIDGET (witem2
), pos
);
2966 g_object_unref (G_OBJECT (witem2
));
2968 g_list_free (*list
);
2969 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2970 while (nr
-- > 0) iter
= g_list_next (iter
);
2971 if (iter
) iter
= g_list_next (iter
);
2977 /* Update the rest of the menu bar. */
2978 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2979 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2982 /* Update the menu item W so it corresponds to VAL.
2983 SELECT_CB is the callback to use when a menu item is selected.
2984 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2985 CL_DATA is the data to set in the widget for menu invocation. */
2988 xg_update_menu_item (widget_value
*val
,
2990 GCallback select_cb
,
2991 GCallback highlight_cb
,
2992 xg_menu_cb_data
*cl_data
)
2999 const char *old_label
= 0;
3000 const char *old_key
= 0;
3001 xg_menu_item_cb_data
*cb_data
;
3003 wchild
= XG_BIN_CHILD (w
);
3004 utf8_label
= get_utf8_string (val
->name
);
3005 utf8_key
= get_utf8_string (val
->key
);
3007 /* See if W is a menu item with a key. See make_menu_item above. */
3008 if (GTK_IS_BOX (wchild
))
3010 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
3012 wlbl
= GTK_LABEL (list
->data
);
3013 wkey
= GTK_LABEL (list
->next
->data
);
3018 /* Remove the key and keep just the label. */
3019 g_object_ref (G_OBJECT (wlbl
));
3020 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3021 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
3022 g_object_unref (G_OBJECT (wlbl
));
3027 else /* Just a label. */
3029 wlbl
= GTK_LABEL (wchild
);
3031 /* Check if there is now a key. */
3034 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
3035 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
3037 wlbl
= GTK_LABEL (list
->data
);
3038 wkey
= GTK_LABEL (list
->next
->data
);
3041 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
3042 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
3047 if (wkey
) old_key
= gtk_label_get_label (wkey
);
3048 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
3050 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
3051 gtk_label_set_text (wkey
, utf8_key
);
3053 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
3054 gtk_label_set_text (wlbl
, utf8_label
);
3056 if (utf8_key
) g_free (utf8_key
);
3057 if (utf8_label
) g_free (utf8_label
);
3059 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
3060 gtk_widget_set_sensitive (w
, FALSE
);
3061 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
3062 gtk_widget_set_sensitive (w
, TRUE
);
3064 cb_data
= (xg_menu_item_cb_data
*) g_object_get_data (G_OBJECT (w
),
3068 cb_data
->call_data
= val
->call_data
;
3069 cb_data
->help
= val
->help
;
3070 cb_data
->cl_data
= cl_data
;
3072 /* We assume the callback functions don't change. */
3073 if (val
->call_data
&& ! val
->contents
)
3075 /* This item shall have a select callback. */
3076 if (! cb_data
->select_id
)
3078 = g_signal_connect (G_OBJECT (w
), "activate",
3079 select_cb
, cb_data
);
3081 else if (cb_data
->select_id
)
3083 g_signal_handler_disconnect (w
, cb_data
->select_id
);
3084 cb_data
->select_id
= 0;
3089 /* Update the toggle menu item W so it corresponds to VAL. */
3092 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
3094 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3097 /* Update the radio menu item W so it corresponds to VAL. */
3100 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
3102 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3105 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3106 SUBMENU may be NULL, in that case a new menu is created.
3107 F is the frame the menu bar belongs to.
3108 VAL describes the contents of the menu bar.
3109 SELECT_CB is the callback to use when a menu item is selected.
3110 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3111 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3112 CL_DATA is the call back data to use for any newly created items.
3114 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3118 xg_update_submenu (GtkWidget
*submenu
,
3121 GCallback select_cb
,
3122 GCallback deactivate_cb
,
3123 GCallback highlight_cb
,
3124 xg_menu_cb_data
*cl_data
)
3126 GtkWidget
*newsub
= submenu
;
3130 int has_tearoff_p
= 0;
3131 GList
*first_radio
= 0;
3134 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3136 for (cur
= val
, iter
= list
;
3138 iter
= g_list_next (iter
), cur
= cur
->next
)
3140 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3142 /* Skip tearoff items, they have no counterpart in val. */
3143 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
3146 iter
= g_list_next (iter
);
3147 if (iter
) w
= GTK_WIDGET (iter
->data
);
3151 /* Remember first radio button in a group. If we get a mismatch in
3152 a radio group we must rebuild the whole group so that the connections
3153 in GTK becomes correct. */
3154 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3156 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3157 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3160 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3162 if (! menu_separator_name_p (cur
->name
))
3165 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3167 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3169 xg_update_toggle_item (cur
, w
);
3170 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3172 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3174 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3176 xg_update_radio_item (cur
, w
);
3177 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3179 else if (GTK_IS_MENU_ITEM (w
))
3181 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3184 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3185 menu_separator_name_p (cur
->name
))
3188 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3190 sub
= gtk_menu_item_get_submenu (witem
);
3191 if (sub
&& ! cur
->contents
)
3193 /* Not a submenu anymore. */
3194 g_object_ref (G_OBJECT (sub
));
3195 remove_submenu (witem
);
3196 gtk_widget_destroy (sub
);
3198 else if (cur
->contents
)
3202 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3203 select_cb
, deactivate_cb
,
3204 highlight_cb
, cl_data
);
3206 /* If this item just became a submenu, we must set it. */
3208 gtk_menu_item_set_submenu (witem
, nsub
);
3213 /* Structural difference. Remove everything from here and down
3219 /* Remove widgets from first structural change. */
3222 /* If we are adding new menu items below, we must remove from
3223 first radio button so that radio groups become correct. */
3224 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3225 else xg_destroy_widgets (iter
);
3230 /* More items added. Create them. */
3231 newsub
= create_menus (cur
,
3244 if (list
) g_list_free (list
);
3249 /* Update the MENUBAR.
3250 F is the frame the menu bar belongs to.
3251 VAL describes the contents of the menu bar.
3252 If DEEP_P is non-zero, rebuild all but the top level menu names in
3253 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3254 SELECT_CB is the callback to use when a menu item is selected.
3255 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3256 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3259 xg_modify_menubar_widgets (GtkWidget
*menubar
, FRAME_PTR f
, widget_value
*val
,
3261 GCallback select_cb
, GCallback deactivate_cb
,
3262 GCallback highlight_cb
)
3264 xg_menu_cb_data
*cl_data
;
3265 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3269 cl_data
= (xg_menu_cb_data
*) g_object_get_data (G_OBJECT (menubar
),
3272 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3273 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3279 /* Update all sub menus.
3280 We must keep the submenus (GTK menu item widgets) since the
3281 X Window in the XEvent that activates the menu are those widgets. */
3283 /* Update cl_data, menu_item things in F may have changed. */
3284 update_cl_data (cl_data
, f
, highlight_cb
);
3286 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3291 GtkMenuItem
*witem
= 0;
3293 /* Find sub menu that corresponds to val and update it. */
3294 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3296 witem
= GTK_MENU_ITEM (iter
->data
);
3297 if (xg_item_label_same_p (witem
, cur
->name
))
3299 sub
= gtk_menu_item_get_submenu (witem
);
3304 newsub
= xg_update_submenu (sub
,
3311 /* sub may still be NULL. If we just updated non deep and added
3312 a new menu bar item, it has no sub menu yet. So we set the
3313 newly created sub menu under witem. */
3314 if (newsub
!= sub
&& witem
!= 0)
3316 xg_set_screen (newsub
, f
);
3317 gtk_menu_item_set_submenu (witem
, newsub
);
3323 gtk_widget_show_all (menubar
);
3326 /* Callback called when the menu bar W is mapped.
3327 Used to find the height of the menu bar if we didn't get it
3328 after showing the widget. */
3331 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3334 FRAME_PTR f
= (FRAME_PTR
) user_data
;
3335 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3336 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3338 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3339 xg_height_or_width_changed (f
);
3343 /* Recompute all the widgets of frame F, when the menu bar has been
3344 changed. Value is non-zero if widgets were updated. */
3347 xg_update_frame_menubar (FRAME_PTR f
)
3349 struct x_output
*x
= f
->output_data
.x
;
3352 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3355 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3356 return 0; /* Already done this, happens for frames created invisible. */
3360 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3362 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3364 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3365 gtk_widget_show_all (x
->menubar_widget
);
3366 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3368 /* If menu bar doesn't know its height yet, cheat a little so the frame
3369 doesn't jump so much when resized later in menubar_map_cb. */
3370 if (req
.height
== 0)
3373 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3375 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3376 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 (FRAME_PTR 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 (FRAME_PTR 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
))
3452 return iter
== 0 ? 0 : 1;
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 int 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 (FRAME_PTR 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 (FRAME_PTR 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 (FRAME_PTR 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 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3783 if (wscroll
&& NILP (bar
->dragging
))
3793 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3795 /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
3796 rather than the real portion value. This makes the thumb less likely
3797 to resize and that looks better. */
3798 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3799 /* When the thumb is at the bottom, position == whole.
3800 So we need to increase `whole' to make space for the thumb. */
3807 top
= (gdouble
) position
/ whole
;
3808 shown
= (gdouble
) portion
/ whole
;
3811 size
= shown
* XG_SB_RANGE
;
3812 size
= min (size
, XG_SB_RANGE
);
3813 size
= max (size
, 1);
3815 value
= top
* XG_SB_RANGE
;
3816 value
= min (value
, XG_SB_MAX
- size
);
3817 value
= max (value
, XG_SB_MIN
);
3819 /* Assume all lines are of equal size. */
3820 new_step
= size
/ max (1, FRAME_LINES (f
));
3822 old_size
= gtk_adjustment_get_page_size (adj
);
3823 if (old_size
!= size
)
3825 int old_step
= gtk_adjustment_get_step_increment (adj
);
3826 if (old_step
!= new_step
)
3828 gtk_adjustment_set_page_size (adj
, size
);
3829 gtk_adjustment_set_step_increment (adj
, new_step
);
3830 /* Assume a page increment is about 95% of the page size */
3831 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3836 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3840 /* gtk_range_set_value invokes the callback. Set
3841 ignore_gtk_scrollbar to make the callback do nothing */
3842 xg_ignore_gtk_scrollbar
= 1;
3844 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3845 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3847 gtk_adjustment_changed (adj
);
3849 xg_ignore_gtk_scrollbar
= 0;
3856 /* Return non-zero if EVENT is for a scroll bar in frame F.
3857 When the same X window is used for several Gtk+ widgets, we cannot
3858 say for sure based on the X window alone if an event is for the
3859 frame. This function does additional checks.
3861 Return non-zero if the event is for a scroll bar, zero otherwise. */
3864 xg_event_is_for_scrollbar (FRAME_PTR f
, XEvent
*event
)
3868 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3870 /* Check if press occurred outside the edit widget. */
3871 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3874 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
3875 (gdk_display_get_device_manager (gdpy
));
3876 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
3878 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
3880 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3883 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3884 || event
->type
== MotionNotify
))
3886 /* If we are releasing or moving the scroll bar, it has the grab. */
3887 GtkWidget
*w
= gtk_grab_get_current ();
3888 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3896 /***********************************************************************
3898 ***********************************************************************/
3899 /* The key for the data we put in the GtkImage widgets. The data is
3900 the image used by Emacs. We use this to see if we need to update
3901 the GtkImage with a new image. */
3902 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3904 /* The key for storing the latest modifiers so the activate callback can
3906 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3908 /* The key for storing the button widget in its proxy menu item. */
3909 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3911 /* The key for the data we put in the GtkImage widgets. The data is
3912 the stock name used by Emacs. We use this to see if we need to update
3913 the GtkImage with a new image. */
3914 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3916 /* As above, but this is used for named theme widgets, as opposed to
3918 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3920 /* Callback function invoked when a tool bar item is pressed.
3921 W is the button widget in the tool bar that got pressed,
3922 CLIENT_DATA is an integer that is the index of the button in the
3923 tool bar. 0 is the first button. */
3926 xg_tool_bar_button_cb (GtkWidget
*widget
,
3927 GdkEventButton
*event
,
3930 intptr_t state
= event
->state
;
3931 gpointer ptr
= (gpointer
) state
;
3932 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3937 /* Callback function invoked when a tool bar item is pressed.
3938 W is the button widget in the tool bar that got pressed,
3939 CLIENT_DATA is an integer that is the index of the button in the
3940 tool bar. 0 is the first button. */
3943 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3945 intptr_t idx
= (intptr_t) client_data
;
3946 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
3947 intptr_t mod
= (intptr_t) gmod
;
3949 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3950 Lisp_Object key
, frame
;
3951 struct input_event event
;
3954 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3957 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3959 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3960 XSETFRAME (frame
, f
);
3962 /* We generate two events here. The first one is to set the prefix
3963 to `(tool_bar)', see keyboard.c. */
3964 event
.kind
= TOOL_BAR_EVENT
;
3965 event
.frame_or_window
= frame
;
3967 kbd_buffer_store_event (&event
);
3969 event
.kind
= TOOL_BAR_EVENT
;
3970 event
.frame_or_window
= frame
;
3972 /* Convert between the modifier bits GDK uses and the modifier bits
3973 Emacs uses. This assumes GDK and X masks are the same, which they are when
3975 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), mod
);
3976 kbd_buffer_store_event (&event
);
3978 /* Return focus to the frame after we have clicked on a detached
3980 Fx_focus_frame (frame
);
3983 /* Callback function invoked when a tool bar item is pressed in a detached
3984 tool bar or the overflow drop down menu.
3985 We just call xg_tool_bar_callback.
3986 W is the menu item widget that got pressed,
3987 CLIENT_DATA is an integer that is the index of the button in the
3988 tool bar. 0 is the first button. */
3991 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3993 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3994 XG_TOOL_BAR_PROXY_BUTTON
));
3995 xg_tool_bar_callback (wbutton
, client_data
);
4000 xg_tool_bar_help_callback (GtkWidget
*w
,
4001 GdkEventCrossing
*event
,
4002 gpointer client_data
);
4004 /* This callback is called when a help is to be shown for an item in
4005 the detached tool bar when the detached tool bar it is not expanded. */
4008 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
4009 GdkEventCrossing
*event
,
4010 gpointer client_data
)
4012 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
4013 XG_TOOL_BAR_PROXY_BUTTON
));
4015 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
4019 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
4021 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
4022 GtkWidget
*c1
= (GtkWidget
*) clist
->data
;
4023 GtkWidget
*c2
= clist
->next
? (GtkWidget
*) clist
->next
->data
: NULL
;
4025 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
4026 g_list_free (clist
);
4027 return GTK_IS_LABEL (c1
) ? c1
: c2
;
4031 /* This callback is called when a tool item should create a proxy item,
4032 such as for the overflow menu. Also called when the tool bar is detached.
4033 If we don't create a proxy menu item, the detached tool bar will be
4037 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
4039 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
4040 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4042 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
4043 GtkImage
*wimage
= GTK_IMAGE (c1
);
4044 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
4045 (wlbl
? gtk_label_get_text (wlbl
) : "");
4046 GtkWidget
*wmenuimage
;
4049 if (gtk_button_get_use_stock (wbutton
))
4050 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
4051 GTK_ICON_SIZE_MENU
);
4054 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
4055 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
4057 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
4059 if (store_type
== GTK_IMAGE_STOCK
)
4062 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
4063 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
4065 else if (store_type
== GTK_IMAGE_ICON_SET
)
4067 GtkIconSet
*icon_set
;
4068 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
4069 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
4070 GTK_ICON_SIZE_MENU
);
4072 else if (store_type
== GTK_IMAGE_PIXBUF
)
4077 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
4080 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
4082 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
4083 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
4084 GDK_INTERP_BILINEAR
);
4086 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
4090 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
4094 else if (store_type
== GTK_IMAGE_ICON_NAME
)
4096 const gchar
*icon_name
;
4097 GtkIconSize icon_size
;
4099 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
4100 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
4101 GTK_ICON_SIZE_MENU
);
4105 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
4110 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
4112 g_signal_connect (G_OBJECT (wmenuitem
),
4114 G_CALLBACK (xg_tool_bar_proxy_callback
),
4118 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
4119 (gpointer
) wbutton
);
4120 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
4121 gtk_widget_set_sensitive (wmenuitem
,
4122 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
4124 /* Use enter/leave notify to show help. We use the events
4125 rather than the GtkButton specific signals "enter" and
4126 "leave", so we can have only one callback. The event
4127 will tell us what kind of event it is. */
4128 g_signal_connect (G_OBJECT (wmenuitem
),
4129 "enter-notify-event",
4130 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4132 g_signal_connect (G_OBJECT (wmenuitem
),
4133 "leave-notify-event",
4134 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4140 /* This callback is called when a tool bar is detached. We must set
4141 the height of the tool bar to zero when this happens so frame sizes
4142 are correctly calculated.
4143 WBOX is the handle box widget that enables detach/attach of the tool bar.
4144 W is the tool bar widget.
4145 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4148 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
4150 gpointer client_data
)
4152 FRAME_PTR f
= (FRAME_PTR
) client_data
;
4154 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
4159 GtkRequisition req
, req2
;
4160 FRAME_X_OUTPUT (f
)->toolbar_detached
= 1;
4161 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4162 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4163 req
.width
-= req2
.width
;
4164 req
.height
-= req2
.height
;
4165 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4166 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4167 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4168 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4169 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4170 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4171 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4172 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4173 xg_height_or_width_changed (f
);
4177 /* This callback is called when a tool bar is reattached. We must set
4178 the height of the tool bar when this happens so frame sizes
4179 are correctly calculated.
4180 WBOX is the handle box widget that enables detach/attach of the tool bar.
4181 W is the tool bar widget.
4182 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4185 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
4187 gpointer client_data
)
4189 FRAME_PTR f
= (FRAME_PTR
) client_data
;
4190 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
4194 GtkRequisition req
, req2
;
4195 FRAME_X_OUTPUT (f
)->toolbar_detached
= 0;
4196 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4197 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4198 req
.width
+= req2
.width
;
4199 req
.height
+= req2
.height
;
4200 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4201 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4202 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4203 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4204 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4205 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4206 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4207 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4208 xg_height_or_width_changed (f
);
4212 /* This callback is called when the mouse enters or leaves a tool bar item.
4213 It is used for displaying and hiding the help text.
4214 W is the tool bar item, a button.
4215 EVENT is either an enter event or leave event.
4216 CLIENT_DATA is an integer that is the index of the button in the
4217 tool bar. 0 is the first button.
4219 Returns FALSE to tell GTK to keep processing this event. */
4222 xg_tool_bar_help_callback (GtkWidget
*w
,
4223 GdkEventCrossing
*event
,
4224 gpointer client_data
)
4226 intptr_t idx
= (intptr_t) client_data
;
4227 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4228 Lisp_Object help
, frame
;
4230 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4233 if (event
->type
== GDK_ENTER_NOTIFY
)
4235 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4236 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4239 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4244 XSETFRAME (frame
, f
);
4245 kbd_buffer_store_help_event (frame
, help
);
4251 /* This callback is called when a tool bar item shall be redrawn.
4252 It modifies the expose event so that the GtkImage widget redraws the
4253 whole image. This to overcome a bug that makes GtkImage draw the image
4254 in the wrong place when it tries to redraw just a part of the image.
4255 W is the GtkImage to be redrawn.
4256 EVENT is the expose event for W.
4257 CLIENT_DATA is unused.
4259 Returns FALSE to tell GTK to keep processing this event. */
4263 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4264 GdkEventExpose
*event
,
4265 gpointer client_data
)
4269 gdk_drawable_get_size (event
->window
, &width
, &height
);
4270 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4271 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4273 event
->area
.x
= max (0, event
->area
.x
);
4274 event
->area
.y
= max (0, event
->area
.y
);
4276 event
->area
.width
= max (width
, event
->area
.width
);
4277 event
->area
.height
= max (height
, event
->area
.height
);
4283 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4284 #define toolbar_set_orientation(w, o) \
4285 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4287 #define toolbar_set_orientation(w, o) \
4288 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4291 /* Attach a tool bar to frame F. */
4294 xg_pack_tool_bar (FRAME_PTR f
, Lisp_Object pos
)
4296 struct x_output
*x
= f
->output_data
.x
;
4297 int into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4299 toolbar_set_orientation (x
->toolbar_widget
,
4301 ? GTK_ORIENTATION_VERTICAL
4302 : GTK_ORIENTATION_HORIZONTAL
);
4303 if (!x
->handlebox_widget
)
4305 x
->handlebox_widget
= gtk_handle_box_new ();
4306 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
4307 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
4308 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
4309 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
4310 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
4316 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4318 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), x
->handlebox_widget
,
4321 if (EQ (pos
, Qleft
))
4322 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4323 x
->handlebox_widget
,
4325 x
->toolbar_in_hbox
= 1;
4329 int vbox_pos
= x
->menubar_widget
? 1 : 0;
4330 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4332 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->handlebox_widget
,
4336 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4337 x
->handlebox_widget
,
4339 x
->toolbar_in_hbox
= 0;
4343 /* Create a tool bar for frame F. */
4346 xg_create_tool_bar (FRAME_PTR f
)
4348 struct x_output
*x
= f
->output_data
.x
;
4349 #if GTK_CHECK_VERSION (3, 3, 6)
4350 GtkStyleContext
*gsty
;
4352 struct xg_frame_tb_info
*tbinfo
4353 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4357 tbinfo
= xmalloc (sizeof (*tbinfo
));
4358 tbinfo
->last_tool_bar
= Qnil
;
4359 tbinfo
->style
= Qnil
;
4360 tbinfo
->hmargin
= tbinfo
->vmargin
= 0;
4361 tbinfo
->dir
= GTK_TEXT_DIR_NONE
;
4362 tbinfo
->n_last_items
= 0;
4363 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4368 x
->toolbar_widget
= gtk_toolbar_new ();
4369 x
->toolbar_detached
= 0;
4371 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4373 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4374 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4375 #if GTK_CHECK_VERSION (3, 3, 6)
4376 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4377 gtk_style_context_add_class (gsty
, "primary-toolbar");
4382 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4384 /* Find the right-to-left image named by RTL in the tool bar images for F.
4385 Returns IMAGE if RTL is not found. */
4388 find_rtl_image (FRAME_PTR f
, Lisp_Object image
, Lisp_Object rtl
)
4391 Lisp_Object file
, rtl_name
;
4392 struct gcpro gcpro1
, gcpro2
;
4393 GCPRO2 (file
, rtl_name
);
4395 rtl_name
= Ffile_name_nondirectory (rtl
);
4397 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4399 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4400 if (!NILP (file
= file_for_image (rtl_image
)))
4402 file
= call1 (intern ("file-name-sans-extension"),
4403 Ffile_name_nondirectory (file
));
4404 if (! NILP (Fequal (file
, rtl_name
)))
4415 static GtkToolItem
*
4416 xg_make_tool_item (FRAME_PTR f
,
4418 GtkWidget
**wbutton
,
4420 int i
, int horiz
, int text_image
)
4422 GtkToolItem
*ti
= gtk_tool_item_new ();
4423 GtkWidget
*vb
= gtk_box_new (horiz
4424 ? GTK_ORIENTATION_HORIZONTAL
4425 : GTK_ORIENTATION_VERTICAL
,
4427 GtkWidget
*wb
= gtk_button_new ();
4428 /* The eventbox is here so we can have tooltips on disabled items. */
4429 GtkWidget
*weventbox
= gtk_event_box_new ();
4430 #if GTK_CHECK_VERSION (3, 3, 6)
4431 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4432 GtkStyleContext
*gsty
;
4434 gtk_css_provider_load_from_data (css_prov
,
4436 " background-color: transparent;"
4440 gsty
= gtk_widget_get_style_context (weventbox
);
4441 gtk_style_context_add_provider (gsty
,
4442 GTK_STYLE_PROVIDER (css_prov
),
4443 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4444 g_object_unref (css_prov
);
4447 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4449 if (wimage
&& !text_image
)
4450 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4452 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4453 if (wimage
&& text_image
)
4454 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4456 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4457 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4458 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4459 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4460 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4462 if (wimage
|| label
)
4465 gpointer gi
= (gpointer
) ii
;
4467 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4468 G_CALLBACK (xg_tool_bar_menu_proxy
),
4471 g_signal_connect (G_OBJECT (wb
), "clicked",
4472 G_CALLBACK (xg_tool_bar_callback
),
4475 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4478 /* Catch expose events to overcome an annoying redraw bug, see
4479 comment for xg_tool_bar_item_expose_callback. */
4480 g_signal_connect (G_OBJECT (ti
),
4482 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4485 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4487 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4488 no distinction based on modifiers in the activate callback,
4489 so we have to do it ourselves. */
4490 g_signal_connect (wb
, "button-release-event",
4491 G_CALLBACK (xg_tool_bar_button_cb
),
4494 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4496 /* Use enter/leave notify to show help. We use the events
4497 rather than the GtkButton specific signals "enter" and
4498 "leave", so we can have only one callback. The event
4499 will tell us what kind of event it is. */
4500 g_signal_connect (G_OBJECT (weventbox
),
4501 "enter-notify-event",
4502 G_CALLBACK (xg_tool_bar_help_callback
),
4504 g_signal_connect (G_OBJECT (weventbox
),
4505 "leave-notify-event",
4506 G_CALLBACK (xg_tool_bar_help_callback
),
4510 if (wbutton
) *wbutton
= wb
;
4516 is_box_type (GtkWidget
*vb
, int is_horizontal
)
4520 if (GTK_IS_BOX (vb
))
4522 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4523 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4524 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4528 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4534 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4535 const char *icon_name
, const struct image
*img
,
4536 const char *label
, int horiz
)
4540 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4541 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4543 /* Check if the tool icon matches. */
4544 if (stock_name
&& wimage
)
4546 old
= g_object_get_data (G_OBJECT (wimage
),
4547 XG_TOOL_BAR_STOCK_NAME
);
4548 if (!old
|| strcmp (old
, stock_name
))
4551 else if (icon_name
&& wimage
)
4553 old
= g_object_get_data (G_OBJECT (wimage
),
4554 XG_TOOL_BAR_ICON_NAME
);
4555 if (!old
|| strcmp (old
, icon_name
))
4560 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4561 XG_TOOL_BAR_IMAGE_DATA
);
4562 Pixmap old_img
= (Pixmap
) gold_img
;
4563 if (old_img
!= img
->pixmap
)
4567 /* Check button configuration and label. */
4568 if (is_box_type (vb
, horiz
)
4569 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4572 /* Ensure label is correct. */
4574 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4579 xg_update_tool_bar_sizes (FRAME_PTR f
)
4581 struct x_output
*x
= f
->output_data
.x
;
4583 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4585 gtk_widget_get_preferred_size (GTK_WIDGET (x
->handlebox_widget
), NULL
, &req
);
4586 if (x
->toolbar_in_hbox
)
4589 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4590 x
->handlebox_widget
,
4591 "position", &pos
, NULL
);
4592 if (pos
== 0) nl
= req
.width
;
4593 else nr
= req
.width
;
4598 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4599 x
->handlebox_widget
,
4600 "position", &pos
, NULL
);
4601 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4602 else nb
= req
.height
;
4605 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4606 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4607 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4608 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4610 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4611 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4612 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4613 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4614 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4615 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4623 /* Update the tool bar for frame F. Add new buttons and remove old. */
4626 update_frame_tool_bar (FRAME_PTR f
)
4629 struct x_output
*x
= f
->output_data
.x
;
4630 int hmargin
= 0, vmargin
= 0;
4631 GtkToolbar
*wtoolbar
;
4633 GtkTextDirection dir
;
4634 int pack_tool_bar
= x
->handlebox_widget
== NULL
;
4636 int text_image
, horiz
;
4637 struct xg_frame_tb_info
*tbinfo
;
4639 if (! FRAME_GTK_WIDGET (f
))
4644 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4646 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4647 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4649 else if (CONSP (Vtool_bar_button_margin
))
4651 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4652 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4654 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4655 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4658 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4659 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4660 i.e. zero. This means that margins less than
4661 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4662 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4663 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4665 if (! x
->toolbar_widget
)
4666 xg_create_tool_bar (f
);
4668 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4669 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4671 style
= Ftool_bar_get_system_style ();
4673 /* Are we up to date? */
4674 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4677 if (! NILP (tbinfo
->last_tool_bar
) && ! NILP (f
->tool_bar_items
)
4678 && tbinfo
->n_last_items
== f
->n_tool_bar_items
4679 && tbinfo
->hmargin
== hmargin
&& tbinfo
->vmargin
== vmargin
4680 && tbinfo
->dir
== dir
4681 && ! NILP (Fequal (tbinfo
->style
, style
))
4682 && ! NILP (Fequal (tbinfo
->last_tool_bar
, f
->tool_bar_items
)))
4688 tbinfo
->last_tool_bar
= f
->tool_bar_items
;
4689 tbinfo
->n_last_items
= f
->n_tool_bar_items
;
4690 tbinfo
->style
= style
;
4691 tbinfo
->hmargin
= hmargin
;
4692 tbinfo
->vmargin
= vmargin
;
4695 text_image
= EQ (style
, Qtext_image_horiz
);
4696 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4698 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4700 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4701 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4705 struct image
*img
= NULL
;
4707 Lisp_Object stock
= Qnil
;
4708 GtkStockItem stock_item
;
4709 char *stock_name
= NULL
;
4710 char *icon_name
= NULL
;
4712 GtkWidget
*wbutton
= NULL
;
4713 Lisp_Object specified_file
;
4714 int vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4716 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4717 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4718 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4721 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4723 /* If this is a separator, use a gtk separator item. */
4724 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4726 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4729 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4731 ti
= gtk_separator_tool_item_new ();
4732 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4738 /* Otherwise, the tool-bar item is an ordinary button. */
4740 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4742 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4746 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4748 /* Ignore invalid image specifications. */
4749 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4750 if (!valid_image_p (image
))
4753 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4758 specified_file
= file_for_image (image
);
4759 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4760 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4762 if (STRINGP (stock
))
4764 stock_name
= SSDATA (stock
);
4765 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4767 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4768 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4770 icon_name
= stock_name
+ 2;
4774 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4777 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4779 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4780 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4788 if (stock_name
== NULL
&& icon_name
== NULL
)
4790 /* No stock image, or stock item not known. Try regular
4791 image. If image is a vector, choose it according to the
4793 if (dir
== GTK_TEXT_DIR_RTL
4794 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4796 image
= find_rtl_image (f
, image
, rtl
);
4798 if (VECTORP (image
))
4802 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4803 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4806 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4807 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4809 eassert (ASIZE (image
) >= idx
);
4810 image
= AREF (image
, idx
);
4815 img_id
= lookup_image (f
, image
);
4816 img
= IMAGE_FROM_ID (f
, img_id
);
4817 prepare_image_for_display (f
, img
);
4819 if (img
->load_failed_p
|| img
->pixmap
== None
)
4822 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4828 /* If there is an existing widget, check if it's stale; if so,
4829 remove it and make a new tool item from scratch. */
4830 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4833 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4842 /* Save the image so we can see if an update is needed the
4843 next time we call xg_tool_item_match_p. */
4844 if (EQ (style
, Qtext
))
4846 else if (stock_name
)
4848 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4849 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4850 (gpointer
) xstrdup (stock_name
),
4851 (GDestroyNotify
) xfree
);
4855 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4856 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4857 (gpointer
) xstrdup (icon_name
),
4858 (GDestroyNotify
) xfree
);
4862 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4863 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4864 (gpointer
)img
->pixmap
);
4867 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4868 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4869 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4874 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4878 /* Remove buttons not longer needed. */
4881 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4883 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4884 } while (ti
!= NULL
);
4886 if (f
->n_tool_bar_items
!= 0)
4889 xg_pack_tool_bar (f
, f
->tool_bar_position
);
4890 gtk_widget_show_all (GTK_WIDGET (x
->handlebox_widget
));
4891 if (xg_update_tool_bar_sizes (f
))
4892 xg_height_or_width_changed (f
);
4898 /* Deallocate all resources for the tool bar on frame F.
4899 Remove the tool bar. */
4902 free_frame_tool_bar (FRAME_PTR f
)
4904 struct x_output
*x
= f
->output_data
.x
;
4906 if (x
->toolbar_widget
)
4908 struct xg_frame_tb_info
*tbinfo
;
4909 int is_packed
= x
->handlebox_widget
!= 0;
4911 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4912 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4915 if (x
->toolbar_in_hbox
)
4916 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4917 x
->handlebox_widget
);
4919 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4920 x
->handlebox_widget
);
4923 gtk_widget_destroy (x
->toolbar_widget
);
4925 x
->toolbar_widget
= 0;
4926 x
->handlebox_widget
= 0;
4927 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4928 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4930 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4935 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4940 xg_height_or_width_changed (f
);
4947 xg_change_toolbar_position (FRAME_PTR f
, Lisp_Object pos
)
4949 struct x_output
*x
= f
->output_data
.x
;
4951 if (! x
->toolbar_widget
|| ! x
->handlebox_widget
)
4955 g_object_ref (x
->handlebox_widget
);
4956 if (x
->toolbar_in_hbox
)
4957 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4958 x
->handlebox_widget
);
4960 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4961 x
->handlebox_widget
);
4962 xg_pack_tool_bar (f
, pos
);
4963 g_object_unref (x
->handlebox_widget
);
4964 if (xg_update_tool_bar_sizes (f
))
4965 xg_height_or_width_changed (f
);
4973 /***********************************************************************
4975 ***********************************************************************/
4977 xg_initialize (void)
4979 GtkBindingSet
*binding_set
;
4980 GtkSettings
*settings
;
4983 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4984 we keep it permanently linked in. */
4989 xg_ignore_gtk_scrollbar
= 0;
4990 xg_detached_menus
= 0;
4991 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4992 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4994 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4995 id_to_widget
.widgets
= 0;
4997 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
4998 (gdk_display_get_default ()));
4999 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
5000 bindings. It doesn't seem to be any way to remove properties,
5001 so we set it to VoidSymbol which in X means "no key". */
5002 gtk_settings_set_string_property (settings
,
5003 "gtk-menu-bar-accel",
5007 /* Make GTK text input widgets use Emacs style keybindings. This is
5009 gtk_settings_set_string_property (settings
,
5010 "gtk-key-theme-name",
5014 /* Make dialogs close on C-g. Since file dialog inherits from
5015 dialog, this works for them also. */
5016 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
5017 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5020 /* Make menus close on C-g. */
5021 binding_set
= gtk_binding_set_by_class (g_type_class_ref
5022 (GTK_TYPE_MENU_SHELL
));
5023 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
5025 update_theme_scrollbar_width ();
5027 x_last_font_name
= NULL
;
5030 #endif /* USE_GTK */