1 /* Functions for creating and updating GTK widgets.
3 Copyright (C) 2003-2014 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
30 #include "blockinput.h"
31 #include "syssignal.h"
34 #include "termhooks.h"
40 #include <gdk/gdkkeysyms.h>
41 #include "xsettings.h"
44 #include <X11/Xft/Xft.h>
49 #include "emacsgtkfixed.h"
52 #define FRAME_TOTAL_PIXEL_HEIGHT(f) \
53 (FRAME_PIXEL_HEIGHT (f) + FRAME_MENUBAR_HEIGHT (f) + FRAME_TOOLBAR_HEIGHT (f))
55 #define FRAME_TOTAL_PIXEL_WIDTH(f) \
56 (FRAME_PIXEL_WIDTH (f) + FRAME_TOOLBAR_WIDTH (f))
58 #ifndef HAVE_GTK_WIDGET_SET_HAS_WINDOW
59 #define gtk_widget_set_has_window(w, b) \
60 (gtk_fixed_set_has_window (GTK_FIXED (w), b))
62 #ifndef HAVE_GTK_DIALOG_GET_ACTION_AREA
63 #define gtk_dialog_get_action_area(w) ((w)->action_area)
64 #define gtk_dialog_get_content_area(w) ((w)->vbox)
66 #ifndef HAVE_GTK_WIDGET_GET_SENSITIVE
67 #define gtk_widget_get_sensitive(w) (GTK_WIDGET_SENSITIVE (w))
69 #ifndef HAVE_GTK_ADJUSTMENT_GET_PAGE_SIZE
70 #define gtk_adjustment_set_page_size(w, s) ((w)->page_size = (s))
71 #define gtk_adjustment_set_page_increment(w, s) ((w)->page_increment = (s))
72 #define gtk_adjustment_get_step_increment(w) ((w)->step_increment)
73 #define gtk_adjustment_set_step_increment(w, s) ((w)->step_increment = (s))
75 #if GTK_CHECK_VERSION (2, 12, 0)
76 #define remove_submenu(w) gtk_menu_item_set_submenu ((w), NULL)
78 #define remove_submenu(w) gtk_menu_item_remove_submenu ((w))
82 #if GTK_CHECK_VERSION (3, 2, 0)
83 #define USE_NEW_GTK_FONT_CHOOSER 1
85 #define USE_NEW_GTK_FONT_CHOOSER 0
86 #define gtk_font_chooser_dialog_new(x, y) \
87 gtk_font_selection_dialog_new (x)
88 #undef GTK_FONT_CHOOSER
89 #define GTK_FONT_CHOOSER(x) GTK_FONT_SELECTION_DIALOG (x)
90 #define gtk_font_chooser_set_font(x, y) \
91 gtk_font_selection_dialog_set_font_name (x, y)
93 #endif /* HAVE_FREETYPE */
96 #ifdef USE_GTK_TOOLTIP
97 #define gdk_window_get_screen(w) gdk_drawable_get_screen (w)
99 #define gdk_window_get_geometry(w, a, b, c, d) \
100 gdk_window_get_geometry (w, a, b, c, d, 0)
101 #define gdk_x11_window_lookup_for_display(d, w) \
102 gdk_xid_table_lookup_for_display (d, w)
103 #define gtk_box_new(ori, spacing) \
104 ((ori) == GTK_ORIENTATION_HORIZONTAL \
105 ? gtk_hbox_new (FALSE, (spacing)) : gtk_vbox_new (FALSE, (spacing)))
106 #define gtk_scrollbar_new(ori, spacing) \
107 ((ori) == GTK_ORIENTATION_HORIZONTAL \
108 ? gtk_hscrollbar_new ((spacing)) : gtk_vscrollbar_new ((spacing)))
110 #define GDK_KEY_g GDK_g
112 #endif /* HAVE_GTK3 */
114 #define XG_BIN_CHILD(x) gtk_bin_get_child (GTK_BIN (x))
116 static void update_theme_scrollbar_width (void);
118 #define TB_INFO_KEY "xg_frame_tb_info"
119 struct xg_frame_tb_info
121 Lisp_Object last_tool_bar
;
124 int hmargin
, vmargin
;
125 GtkTextDirection dir
;
129 /***********************************************************************
130 Display handling functions
131 ***********************************************************************/
133 /* Keep track of the default display, or NULL if there is none. Emacs
134 may close all its displays. */
136 static GdkDisplay
*gdpy_def
;
138 /* When the GTK widget W is to be created on a display for F that
139 is not the default display, set the display for W.
140 W can be a GtkMenu or a GtkWindow widget. */
143 xg_set_screen (GtkWidget
*w
, struct frame
*f
)
145 if (FRAME_X_DISPLAY (f
) != DEFAULT_GDK_DISPLAY ())
147 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
148 GdkScreen
*gscreen
= gdk_display_get_default_screen (gdpy
);
151 gtk_menu_set_screen (GTK_MENU (w
), gscreen
);
153 gtk_window_set_screen (GTK_WINDOW (w
), gscreen
);
158 /* Open a display named by DISPLAY_NAME. The display is returned in *DPY.
159 *DPY is set to NULL if the display can't be opened.
161 Returns non-zero if display could be opened, zero if display could not
162 be opened, and less than zero if the GTK version doesn't support
163 multiple displays. */
166 xg_display_open (char *display_name
, Display
**dpy
)
170 gdpy
= gdk_display_open (display_name
);
171 if (!gdpy_def
&& gdpy
)
174 gdk_display_manager_set_default_display (gdk_display_manager_get (),
178 *dpy
= gdpy
? GDK_DISPLAY_XDISPLAY (gdpy
) : NULL
;
182 /* Close display DPY. */
185 xg_display_close (Display
*dpy
)
187 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
189 /* If this is the default display, try to change it before closing.
190 If there is no other display to use, gdpy_def is set to NULL, and
191 the next call to xg_display_open resets the default display. */
192 if (gdk_display_get_default () == gdpy
)
194 struct x_display_info
*dpyinfo
;
195 GdkDisplay
*gdpy_new
= NULL
;
197 /* Find another display. */
198 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
199 if (dpyinfo
->display
!= dpy
)
201 gdpy_new
= gdk_x11_lookup_xdisplay (dpyinfo
->display
);
202 gdk_display_manager_set_default_display (gdk_display_manager_get (),
209 #if GTK_CHECK_VERSION (2, 0, 0) && ! GTK_CHECK_VERSION (2, 10, 0)
210 /* GTK 2.2-2.8 has a bug that makes gdk_display_close crash (bug
211 http://bugzilla.gnome.org/show_bug.cgi?id=85715). This way we
212 can continue running, but there will be memory leaks. */
213 g_object_run_dispose (G_OBJECT (gdpy
));
215 /* This seems to be fixed in GTK 2.10. */
216 gdk_display_close (gdpy
);
221 /***********************************************************************
223 ***********************************************************************/
225 /* Create and return the cursor to be used for popup menus and
226 scroll bars on display DPY. */
229 xg_create_default_cursor (Display
*dpy
)
231 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (dpy
);
232 return gdk_cursor_new_for_display (gdpy
, GDK_LEFT_PTR
);
236 xg_get_pixbuf_from_pixmap (struct frame
*f
, Pixmap pix
)
241 unsigned int width
, height
, uunused
;
244 XGetGeometry (FRAME_X_DISPLAY (f
), pix
, &wunused
, &iunused
, &iunused
,
245 &width
, &height
, &uunused
, &uunused
);
247 xim
= XGetImage (FRAME_X_DISPLAY (f
), pix
, 0, 0, width
, height
,
251 tmp_buf
= gdk_pixbuf_new_from_data ((guchar
*) xim
->data
,
264 /* Apply GMASK to GPIX and return a GdkPixbuf with an alpha channel. */
267 xg_get_pixbuf_from_pix_and_mask (struct frame
*f
,
272 GdkPixbuf
*icon_buf
, *tmp_buf
;
274 tmp_buf
= xg_get_pixbuf_from_pixmap (f
, pix
);
275 icon_buf
= gdk_pixbuf_add_alpha (tmp_buf
, FALSE
, 0, 0, 0);
276 g_object_unref (G_OBJECT (tmp_buf
));
278 width
= gdk_pixbuf_get_width (icon_buf
);
279 height
= gdk_pixbuf_get_height (icon_buf
);
283 GdkPixbuf
*mask_buf
= xg_get_pixbuf_from_pixmap (f
, mask
);
284 guchar
*pixels
= gdk_pixbuf_get_pixels (icon_buf
);
285 guchar
*mask_pixels
= gdk_pixbuf_get_pixels (mask_buf
);
286 int rowstride
= gdk_pixbuf_get_rowstride (icon_buf
);
287 int mask_rowstride
= gdk_pixbuf_get_rowstride (mask_buf
);
290 for (y
= 0; y
< height
; ++y
)
292 guchar
*iconptr
, *maskptr
;
295 iconptr
= pixels
+ y
* rowstride
;
296 maskptr
= mask_pixels
+ y
* mask_rowstride
;
298 for (x
= 0; x
< width
; ++x
)
300 /* In a bitmap, RGB is either 255/255/255 or 0/0/0. Checking
301 just R is sufficient. */
303 iconptr
[3] = 0; /* 0, 1, 2 is R, G, B. 3 is alpha. */
305 iconptr
+= rowstride
/width
;
306 maskptr
+= mask_rowstride
/width
;
310 g_object_unref (G_OBJECT (mask_buf
));
317 file_for_image (Lisp_Object image
)
319 Lisp_Object specified_file
= Qnil
;
322 for (tail
= XCDR (image
);
323 NILP (specified_file
) && CONSP (tail
) && CONSP (XCDR (tail
));
324 tail
= XCDR (XCDR (tail
)))
325 if (EQ (XCAR (tail
), QCfile
))
326 specified_file
= XCAR (XCDR (tail
));
328 return specified_file
;
331 /* For the image defined in IMG, make and return a GtkImage. For displays with
332 8 planes or less we must make a GdkPixbuf and apply the mask manually.
333 Otherwise the highlighting and dimming the tool bar code in GTK does
334 will look bad. For display with more than 8 planes we just use the
335 pixmap and mask directly. For monochrome displays, GTK doesn't seem
336 able to use external pixmaps, it looks bad whatever we do.
337 The image is defined on the display where frame F is.
338 WIDGET is used to find the GdkColormap to use for the GdkPixbuf.
339 If OLD_WIDGET is NULL, a new widget is constructed and returned.
340 If OLD_WIDGET is not NULL, that widget is modified. */
343 xg_get_image_for_pixmap (struct frame
*f
,
346 GtkImage
*old_widget
)
350 /* If we have a file, let GTK do all the image handling.
351 This seems to be the only way to make insensitive and activated icons
352 look good in all cases. */
353 Lisp_Object specified_file
= file_for_image (img
->spec
);
356 /* We already loaded the image once before calling this
357 function, so this only fails if the image file has been removed.
358 In that case, use the pixmap already loaded. */
360 if (STRINGP (specified_file
)
361 && STRINGP (file
= x_find_image_file (specified_file
)))
364 old_widget
= GTK_IMAGE (gtk_image_new_from_file (SSDATA (file
)));
366 gtk_image_set_from_file (old_widget
, SSDATA (file
));
368 return GTK_WIDGET (old_widget
);
371 /* No file, do the image handling ourselves. This will look very bad
372 on a monochrome display, and sometimes bad on all displays with
375 /* This is a workaround to make icons look good on pseudo color
376 displays. Apparently GTK expects the images to have an alpha
377 channel. If they don't, insensitive and activated icons will
378 look bad. This workaround does not work on monochrome displays,
379 and is strictly not needed on true color/static color displays (i.e.
380 16 bits and higher). But we do it anyway so we get a pixbuf that is
381 not associated with the img->pixmap. The img->pixmap may be removed
382 by clearing the image cache and then the tool bar redraw fails, since
383 Gtk+ assumes the pixmap is always there. */
384 icon_buf
= xg_get_pixbuf_from_pix_and_mask (f
, img
->pixmap
, img
->mask
);
389 old_widget
= GTK_IMAGE (gtk_image_new_from_pixbuf (icon_buf
));
391 gtk_image_set_from_pixbuf (old_widget
, icon_buf
);
393 g_object_unref (G_OBJECT (icon_buf
));
396 return GTK_WIDGET (old_widget
);
400 /* Set CURSOR on W and all widgets W contain. We must do like this
401 for scroll bars and menu because they create widgets internally,
402 and it is those widgets that are visible. */
405 xg_set_cursor (GtkWidget
*w
, GdkCursor
*cursor
)
407 GdkWindow
*window
= gtk_widget_get_window (w
);
408 GList
*children
= gdk_window_peek_children (window
);
410 gdk_window_set_cursor (window
, cursor
);
412 /* The scroll bar widget has more than one GDK window (had to look at
413 the source to figure this out), and there is no way to set cursor
414 on widgets in GTK. So we must set the cursor for all GDK windows.
417 for ( ; children
; children
= g_list_next (children
))
418 gdk_window_set_cursor (GDK_WINDOW (children
->data
), cursor
);
421 /* Insert NODE into linked LIST. */
424 xg_list_insert (xg_list_node
*list
, xg_list_node
*node
)
426 xg_list_node
*list_start
= list
->next
;
428 if (list_start
) list_start
->prev
= node
;
429 node
->next
= list_start
;
434 /* Remove NODE from linked LIST. */
437 xg_list_remove (xg_list_node
*list
, xg_list_node
*node
)
439 xg_list_node
*list_start
= list
->next
;
440 if (node
== list_start
)
442 list
->next
= node
->next
;
443 if (list
->next
) list
->next
->prev
= 0;
447 node
->prev
->next
= node
->next
;
448 if (node
->next
) node
->next
->prev
= node
->prev
;
452 /* Allocate and return a utf8 version of STR. If STR is already
453 utf8 or NULL, just return a copy of STR.
454 A new string is allocated and the caller must free the result
458 get_utf8_string (const char *str
)
462 if (!str
) return NULL
;
464 /* If not UTF-8, try current locale. */
465 if (!g_utf8_validate (str
, -1, NULL
))
466 utf8_str
= g_locale_to_utf8 (str
, -1, 0, 0, 0);
468 return g_strdup (str
);
472 /* Probably some control characters in str. Escape them. */
474 ptrdiff_t nr_bad
= 0;
477 unsigned char *p
= (unsigned char *)str
;
481 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
482 &bytes_written
, &err
))
483 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
486 p
+= bytes_written
+1;
499 if ((min (PTRDIFF_MAX
, SIZE_MAX
) - len
- 1) / 4 < nr_bad
)
500 memory_full (SIZE_MAX
);
501 up
= utf8_str
= xmalloc (len
+ nr_bad
* 4 + 1);
502 p
= (unsigned char *)str
;
504 while (! (cp
= g_locale_to_utf8 ((char *)p
, -1, &bytes_read
,
505 &bytes_written
, &err
))
506 && err
->code
== G_CONVERT_ERROR_ILLEGAL_SEQUENCE
)
508 memcpy (up
, p
, bytes_written
);
509 sprintf (up
+ bytes_written
, "\\%03o", p
[bytes_written
]);
510 up
+= bytes_written
+4;
511 p
+= bytes_written
+1;
518 strcat (utf8_str
, cp
);
530 /* Check for special colors used in face spec for region face.
531 The colors are fetched from the Gtk+ theme.
532 Return true if color was found, false if not. */
535 xg_check_special_colors (struct frame
*f
,
536 const char *color_name
,
540 bool get_bg
= strcmp ("gtk_selection_bg_color", color_name
) == 0;
541 bool get_fg
= !get_bg
&& strcmp ("gtk_selection_fg_color", color_name
) == 0;
543 if (! FRAME_GTK_WIDGET (f
) || ! (get_bg
|| get_fg
))
549 GtkStyleContext
*gsty
550 = gtk_widget_get_style_context (FRAME_GTK_OUTER_WIDGET (f
));
552 char buf
[sizeof "rgb://rrrr/gggg/bbbb"];
553 int state
= GTK_STATE_FLAG_SELECTED
|GTK_STATE_FLAG_FOCUSED
;
555 gtk_style_context_get_color (gsty
, state
, &col
);
557 gtk_style_context_get_background_color (gsty
, state
, &col
);
559 sprintf (buf
, "rgb:%04x/%04x/%04x",
560 (int)(col
.red
* 65535),
561 (int)(col
.green
* 65535),
562 (int)(col
.blue
* 65535));
563 success_p
= (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
567 GtkStyle
*gsty
= gtk_widget_get_style (FRAME_GTK_WIDGET (f
));
568 GdkColor
*grgb
= get_bg
569 ? &gsty
->bg
[GTK_STATE_SELECTED
]
570 : &gsty
->fg
[GTK_STATE_SELECTED
];
572 color
->red
= grgb
->red
;
573 color
->green
= grgb
->green
;
574 color
->blue
= grgb
->blue
;
575 color
->pixel
= grgb
->pixel
;
586 /***********************************************************************
588 ***********************************************************************/
589 /* Gtk+ calls this callback when the parent of our tooltip dummy changes.
590 We use that to pop down the tooltip. This happens if Gtk+ for some
591 reason wants to change or hide the tooltip. */
593 #ifdef USE_GTK_TOOLTIP
596 hierarchy_ch_cb (GtkWidget
*widget
,
597 GtkWidget
*previous_toplevel
,
600 struct frame
*f
= user_data
;
601 struct x_output
*x
= f
->output_data
.x
;
602 GtkWidget
*top
= gtk_widget_get_toplevel (x
->ttip_lbl
);
604 if (! top
|| ! GTK_IS_WINDOW (top
))
605 gtk_widget_hide (previous_toplevel
);
608 /* Callback called when Gtk+ thinks a tooltip should be displayed.
609 We use it to get the tooltip window and the tooltip widget so
610 we can manipulate the ourselves.
612 Return FALSE ensures that the tooltip is not shown. */
615 qttip_cb (GtkWidget
*widget
,
618 gboolean keyboard_mode
,
622 struct frame
*f
= user_data
;
623 struct x_output
*x
= f
->output_data
.x
;
624 if (x
->ttip_widget
== NULL
)
629 g_object_set (G_OBJECT (widget
), "has-tooltip", FALSE
, NULL
);
630 x
->ttip_widget
= tooltip
;
631 g_object_ref (G_OBJECT (tooltip
));
632 x
->ttip_lbl
= gtk_label_new ("");
633 g_object_ref (G_OBJECT (x
->ttip_lbl
));
634 gtk_tooltip_set_custom (tooltip
, x
->ttip_lbl
);
635 x
->ttip_window
= GTK_WINDOW (gtk_widget_get_toplevel (x
->ttip_lbl
));
637 /* Change stupid Gtk+ default line wrapping. */
638 p
= gtk_widget_get_parent (x
->ttip_lbl
);
639 list
= gtk_container_get_children (GTK_CONTAINER (p
));
640 for (iter
= list
; iter
; iter
= g_list_next (iter
))
642 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
643 if (GTK_IS_LABEL (w
))
644 gtk_label_set_line_wrap (GTK_LABEL (w
), FALSE
);
648 /* ATK needs an empty title for some reason. */
649 gtk_window_set_title (x
->ttip_window
, "");
650 /* Realize so we can safely get screen later on. */
651 gtk_widget_realize (GTK_WIDGET (x
->ttip_window
));
652 gtk_widget_realize (x
->ttip_lbl
);
654 g_signal_connect (x
->ttip_lbl
, "hierarchy-changed",
655 G_CALLBACK (hierarchy_ch_cb
), f
);
660 #endif /* USE_GTK_TOOLTIP */
662 /* Prepare a tooltip to be shown, i.e. calculate WIDTH and HEIGHT.
663 Return true if a system tooltip is available. */
666 xg_prepare_tooltip (struct frame
*f
,
671 #ifndef USE_GTK_TOOLTIP
674 struct x_output
*x
= f
->output_data
.x
;
678 GtkSettings
*settings
;
679 gboolean tt_enabled
= TRUE
;
681 Lisp_Object encoded_string
;
683 if (!x
->ttip_lbl
) return 0;
686 encoded_string
= ENCODE_UTF_8 (string
);
687 widget
= GTK_WIDGET (x
->ttip_lbl
);
688 gwin
= gtk_widget_get_window (GTK_WIDGET (x
->ttip_window
));
689 screen
= gdk_window_get_screen (gwin
);
690 settings
= gtk_settings_get_for_screen (screen
);
691 g_object_get (settings
, "gtk-enable-tooltips", &tt_enabled
, NULL
);
694 g_object_set (settings
, "gtk-enable-tooltips", FALSE
, NULL
);
695 /* Record that we disabled it so it can be enabled again. */
696 g_object_set_data (G_OBJECT (x
->ttip_window
), "restore-tt",
700 /* Prevent Gtk+ from hiding tooltip on mouse move and such. */
701 g_object_set_data (G_OBJECT
702 (gtk_widget_get_display (GTK_WIDGET (x
->ttip_window
))),
703 "gdk-display-current-tooltip", NULL
);
705 /* Put our dummy widget in so we can get callbacks for unrealize and
706 hierarchy-changed. */
707 gtk_tooltip_set_custom (x
->ttip_widget
, widget
);
708 gtk_tooltip_set_text (x
->ttip_widget
, SSDATA (encoded_string
));
709 gtk_widget_get_preferred_size (GTK_WIDGET (x
->ttip_window
), NULL
, &req
);
710 if (width
) *width
= req
.width
;
711 if (height
) *height
= req
.height
;
716 #endif /* USE_GTK_TOOLTIP */
719 /* Show the tooltip at ROOT_X and ROOT_Y.
720 xg_prepare_tooltip must have been called before this function. */
723 xg_show_tooltip (struct frame
*f
, int root_x
, int root_y
)
725 #ifdef USE_GTK_TOOLTIP
726 struct x_output
*x
= f
->output_data
.x
;
730 gtk_window_move (x
->ttip_window
, root_x
, root_y
);
731 gtk_widget_show_all (GTK_WIDGET (x
->ttip_window
));
737 /* Hide tooltip if shown. Do nothing if not shown.
738 Return true if tip was hidden, false if not (i.e. not using
742 xg_hide_tooltip (struct frame
*f
)
745 #ifdef USE_GTK_TOOLTIP
746 if (f
->output_data
.x
->ttip_window
)
748 GtkWindow
*win
= f
->output_data
.x
->ttip_window
;
750 gtk_widget_hide (GTK_WIDGET (win
));
752 if (g_object_get_data (G_OBJECT (win
), "restore-tt"))
754 GdkWindow
*gwin
= gtk_widget_get_window (GTK_WIDGET (win
));
755 GdkScreen
*screen
= gdk_window_get_screen (gwin
);
756 GtkSettings
*settings
= gtk_settings_get_for_screen (screen
);
757 g_object_set (settings
, "gtk-enable-tooltips", TRUE
, NULL
);
768 /***********************************************************************
769 General functions for creating widgets, resizing, events, e.t.c.
770 ***********************************************************************/
773 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
774 const gchar
*msg
, gpointer user_data
)
776 if (!strstr (msg
, "visible children"))
777 fprintf (stderr
, "XX %s-WARNING **: %s\n", log_domain
, msg
);
780 /* Make a geometry string and pass that to GTK. It seems this is the
781 only way to get geometry position right if the user explicitly
782 asked for a position when starting Emacs.
783 F is the frame we shall set geometry for. */
786 xg_set_geometry (struct frame
*f
)
788 if (f
->size_hint_flags
& (USPosition
| PPosition
))
790 int left
= f
->left_pos
;
791 int xneg
= f
->size_hint_flags
& XNegative
;
792 int top
= f
->top_pos
;
793 int yneg
= f
->size_hint_flags
& YNegative
;
794 char geom_str
[sizeof "=x--" + 4 * INT_STRLEN_BOUND (int)];
802 sprintf (geom_str
, "=%dx%d%c%d%c%d",
803 FRAME_PIXEL_WIDTH (f
),
804 FRAME_PIXEL_HEIGHT (f
),
805 (xneg
? '-' : '+'), left
,
806 (yneg
? '-' : '+'), top
);
808 /* Silence warning about visible children. */
809 id
= g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
810 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
812 if (!gtk_window_parse_geometry (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
814 fprintf (stderr
, "Failed to parse: '%s'\n", geom_str
);
816 g_log_remove_handler ("Gtk", id
);
820 /* Clear under internal border if any. As we use a mix of Gtk+ and X calls
821 and use a GtkFixed widget, this doesn't happen automatically. */
824 xg_clear_under_internal_border (struct frame
*f
)
826 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
828 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
830 gtk_widget_queue_draw (wfixed
);
831 gdk_window_process_all_updates ();
833 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), 0, 0,
834 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
836 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), 0, 0,
837 FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
839 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), 0,
840 FRAME_PIXEL_HEIGHT (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
841 FRAME_PIXEL_WIDTH (f
), FRAME_INTERNAL_BORDER_WIDTH (f
));
843 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
844 FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
),
845 0, FRAME_INTERNAL_BORDER_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
));
849 /* Function to handle resize of our frame. As we have a Gtk+ tool bar
850 and a Gtk+ menu bar, we get resize events for the edit part of the
851 frame only. We let Gtk+ deal with the Gtk+ parts.
852 F is the frame to resize.
853 PIXELWIDTH, PIXELHEIGHT is the new size in pixels. */
856 xg_frame_resized (struct frame
*f
, int pixelwidth
, int pixelheight
)
860 if (pixelwidth
== -1 && pixelheight
== -1)
862 if (FRAME_GTK_WIDGET (f
) && gtk_widget_get_mapped (FRAME_GTK_WIDGET (f
)))
863 gdk_window_get_geometry (gtk_widget_get_window (FRAME_GTK_WIDGET (f
)),
865 &pixelwidth
, &pixelheight
);
870 width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, pixelwidth
);
871 height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelheight
);
873 if (width
!= FRAME_TEXT_WIDTH (f
)
874 || height
!= FRAME_TEXT_HEIGHT (f
)
875 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
876 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
878 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
879 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
881 xg_clear_under_internal_border (f
);
882 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
883 SET_FRAME_GARBAGED (f
);
884 cancel_mouse_face (f
);
888 /* Resize the outer window of frame F after changing the height.
889 COLUMNS/ROWS is the size the edit area shall have after the resize. */
892 xg_frame_set_char_size (struct frame
*f
, int width
, int height
)
894 int pixelwidth
= FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
);
895 int pixelheight
= FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
);
897 if (FRAME_PIXEL_HEIGHT (f
) == 0)
900 /* Do this before resize, as we don't know yet if we will be resized. */
901 xg_clear_under_internal_border (f
);
903 /* Must resize our top level widget. Font size may have changed,
904 but not rows/cols. */
905 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
906 pixelwidth
+ FRAME_TOOLBAR_WIDTH (f
),
907 pixelheight
+ FRAME_TOOLBAR_HEIGHT (f
)
908 + FRAME_MENUBAR_HEIGHT (f
));
909 x_wm_set_size_hint (f
, 0, 0);
911 SET_FRAME_GARBAGED (f
);
912 cancel_mouse_face (f
);
914 /* We can not call change_frame_size for a mapped frame,
915 we can not set pixel width/height either. The window manager may
916 override our resize request, XMonad does this all the time.
917 The best we can do is try to sync, so lisp code sees the updated
918 size as fast as possible.
919 For unmapped windows, we can set rows/cols. When
920 the frame is mapped again we will (hopefully) get the correct size. */
921 if (FRAME_VISIBLE_P (f
))
923 /* Must call this to flush out events */
924 (void)gtk_events_pending ();
926 x_wait_for_event (f
, ConfigureNotify
);
929 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
932 /* Handle height/width changes (i.e. add/remove/move menu/toolbar).
933 The policy is to keep the number of editable lines. */
936 xg_height_or_width_changed (struct frame
*f
)
938 gtk_window_resize (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
939 FRAME_TOTAL_PIXEL_WIDTH (f
),
940 FRAME_TOTAL_PIXEL_HEIGHT (f
));
941 f
->output_data
.x
->hint_flags
= 0;
942 x_wm_set_size_hint (f
, 0, 0);
945 /* Convert an X Window WSESC on display DPY to its corresponding GtkWidget.
946 Must be done like this, because GtkWidget:s can have "hidden"
947 X Window that aren't accessible.
949 Return 0 if no widget match WDESC. */
952 xg_win_to_widget (Display
*dpy
, Window wdesc
)
955 GtkWidget
*gwdesc
= 0;
959 gdkwin
= gdk_x11_window_lookup_for_display (gdk_x11_lookup_xdisplay (dpy
),
964 event
.any
.window
= gdkwin
;
965 event
.any
.type
= GDK_NOTHING
;
966 gwdesc
= gtk_get_event_widget (&event
);
973 /* Set the background of widget W to PIXEL. */
976 xg_set_widget_bg (struct frame
*f
, GtkWidget
*w
, unsigned long pixel
)
982 if (XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &xbg
))
984 bg
.red
= (double)xbg
.red
/65535.0;
985 bg
.green
= (double)xbg
.green
/65535.0;
986 bg
.blue
= (double)xbg
.blue
/65535.0;
988 gtk_widget_override_background_color (w
, GTK_STATE_FLAG_NORMAL
, &bg
);
992 GdkColormap
*map
= gtk_widget_get_colormap (w
);
993 gdk_colormap_query_color (map
, pixel
, &bg
);
994 gtk_widget_modify_bg (FRAME_GTK_WIDGET (f
), GTK_STATE_NORMAL
, &bg
);
998 /* Callback called when the gtk theme changes.
999 We notify lisp code so it can fix faces used for region for example. */
1002 style_changed_cb (GObject
*go
,
1006 struct input_event event
;
1007 GdkDisplay
*gdpy
= user_data
;
1008 const char *display_name
= gdk_display_get_name (gdpy
);
1009 Display
*dpy
= GDK_DISPLAY_XDISPLAY (gdpy
);
1012 event
.kind
= CONFIG_CHANGED_EVENT
;
1013 event
.frame_or_window
= build_string (display_name
);
1014 /* Theme doesn't change often, so intern is called seldom. */
1015 event
.arg
= intern ("theme-name");
1016 kbd_buffer_store_event (&event
);
1018 update_theme_scrollbar_width ();
1020 /* If scroll bar width changed, we need set the new size on all frames
1024 Lisp_Object rest
, frame
;
1025 FOR_EACH_FRAME (rest
, frame
)
1027 struct frame
*f
= XFRAME (frame
);
1028 if (FRAME_LIVE_P (f
)
1030 && FRAME_X_DISPLAY (f
) == dpy
)
1032 x_set_scroll_bar_default_width (f
);
1033 xg_frame_set_char_size (f
, FRAME_TEXT_WIDTH (f
), FRAME_TEXT_HEIGHT (f
));
1039 /* Called when a delete-event occurs on WIDGET. */
1042 delete_cb (GtkWidget
*widget
,
1047 /* The event doesn't arrive in the normal event loop. Send event
1049 struct frame
*f
= user_data
;
1050 struct input_event ie
;
1053 ie
.kind
= DELETE_WINDOW_EVENT
;
1054 XSETFRAME (ie
.frame_or_window
, f
);
1055 kbd_buffer_store_event (&ie
);
1061 /* Create and set up the GTK widgets for frame F.
1062 Return true if creation succeeded. */
1065 xg_create_frame_widgets (struct frame
*f
)
1068 GtkWidget
*wvbox
, *whbox
;
1077 if (FRAME_X_EMBEDDED_P (f
))
1079 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
1080 wtop
= gtk_plug_new_for_display (gdpy
, f
->output_data
.x
->parent_desc
);
1083 wtop
= gtk_window_new (GTK_WINDOW_TOPLEVEL
);
1085 /* gtk_window_set_has_resize_grip is a Gtk+ 3.0 function but Ubuntu
1086 has backported it to Gtk+ 2.0 and they add the resize grip for
1087 Gtk+ 2.0 applications also. But it has a bug that makes Emacs loop
1088 forever, so disable the grip. */
1089 #if (! GTK_CHECK_VERSION (3, 0, 0) \
1090 && defined HAVE_GTK_WINDOW_SET_HAS_RESIZE_GRIP)
1091 gtk_window_set_has_resize_grip (GTK_WINDOW (wtop
), FALSE
);
1094 xg_set_screen (wtop
, f
);
1096 wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1097 whbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1098 gtk_box_set_homogeneous (GTK_BOX (wvbox
), FALSE
);
1099 gtk_box_set_homogeneous (GTK_BOX (whbox
), FALSE
);
1102 wfixed
= emacs_fixed_new (f
);
1104 wfixed
= gtk_fixed_new ();
1107 if (! wtop
|| ! wvbox
|| ! whbox
|| ! wfixed
)
1109 if (wtop
) gtk_widget_destroy (wtop
);
1110 if (wvbox
) gtk_widget_destroy (wvbox
);
1111 if (whbox
) gtk_widget_destroy (whbox
);
1112 if (wfixed
) gtk_widget_destroy (wfixed
);
1118 /* Use same names as the Xt port does. I.e. Emacs.pane.emacs by default */
1119 gtk_widget_set_name (wtop
, EMACS_CLASS
);
1120 gtk_widget_set_name (wvbox
, "pane");
1121 gtk_widget_set_name (wfixed
, SSDATA (Vx_resource_name
));
1123 /* If this frame has a title or name, set it in the title bar. */
1124 if (! NILP (f
->title
))
1125 title
= SSDATA (ENCODE_UTF_8 (f
->title
));
1126 else if (! NILP (f
->name
))
1127 title
= SSDATA (ENCODE_UTF_8 (f
->name
));
1129 if (title
) gtk_window_set_title (GTK_WINDOW (wtop
), title
);
1131 FRAME_GTK_OUTER_WIDGET (f
) = wtop
;
1132 FRAME_GTK_WIDGET (f
) = wfixed
;
1133 f
->output_data
.x
->vbox_widget
= wvbox
;
1134 f
->output_data
.x
->hbox_widget
= whbox
;
1136 gtk_widget_set_has_window (wfixed
, TRUE
);
1138 gtk_container_add (GTK_CONTAINER (wtop
), wvbox
);
1139 gtk_box_pack_start (GTK_BOX (wvbox
), whbox
, TRUE
, TRUE
, 0);
1140 gtk_box_pack_start (GTK_BOX (whbox
), wfixed
, TRUE
, TRUE
, 0);
1142 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1143 update_frame_tool_bar (f
);
1145 /* We don't want this widget double buffered, because we draw on it
1146 with regular X drawing primitives, so from a GTK/GDK point of
1147 view, the widget is totally blank. When an expose comes, this
1148 will make the widget blank, and then Emacs redraws it. This flickers
1149 a lot, so we turn off double buffering. */
1150 gtk_widget_set_double_buffered (wfixed
, FALSE
);
1152 gtk_window_set_wmclass (GTK_WINDOW (wtop
),
1153 SSDATA (Vx_resource_name
),
1154 SSDATA (Vx_resource_class
));
1156 /* Add callback to do nothing on WM_DELETE_WINDOW. The default in
1157 GTK is to destroy the widget. We want Emacs to do that instead. */
1158 g_signal_connect (G_OBJECT (wtop
), "delete-event",
1159 G_CALLBACK (delete_cb
), f
);
1161 /* Convert our geometry parameters into a geometry string
1163 GTK will itself handle calculating the real position this way. */
1164 xg_set_geometry (f
);
1166 = gtk_window_get_gravity (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1168 gtk_widget_add_events (wfixed
,
1169 GDK_POINTER_MOTION_MASK
1171 | GDK_BUTTON_PRESS_MASK
1172 | GDK_BUTTON_RELEASE_MASK
1173 | GDK_KEY_PRESS_MASK
1174 | GDK_ENTER_NOTIFY_MASK
1175 | GDK_LEAVE_NOTIFY_MASK
1176 | GDK_FOCUS_CHANGE_MASK
1177 | GDK_STRUCTURE_MASK
1178 | GDK_VISIBILITY_NOTIFY_MASK
);
1180 /* Must realize the windows so the X window gets created. It is used
1181 by callers of this function. */
1182 gtk_widget_realize (wfixed
);
1183 FRAME_X_WINDOW (f
) = GTK_WIDGET_TO_X_WIN (wfixed
);
1185 /* Since GTK clears its window by filling with the background color,
1186 we must keep X and GTK background in sync. */
1187 xg_set_widget_bg (f
, wfixed
, FRAME_BACKGROUND_PIXEL (f
));
1190 /* Also, do not let any background pixmap to be set, this looks very
1191 bad as Emacs overwrites the background pixmap with its own idea
1192 of background color. */
1193 style
= gtk_widget_get_modifier_style (wfixed
);
1195 /* Must use g_strdup because gtk_widget_modify_style does g_free. */
1196 style
->bg_pixmap_name
[GTK_STATE_NORMAL
] = g_strdup ("<none>");
1197 gtk_widget_modify_style (wfixed
, style
);
1199 gtk_widget_set_can_focus (wfixed
, TRUE
);
1200 gtk_window_set_resizable (GTK_WINDOW (wtop
), TRUE
);
1203 #ifdef USE_GTK_TOOLTIP
1204 /* Steal a tool tip window we can move ourselves. */
1205 f
->output_data
.x
->ttip_widget
= 0;
1206 f
->output_data
.x
->ttip_lbl
= 0;
1207 f
->output_data
.x
->ttip_window
= 0;
1208 gtk_widget_set_tooltip_text (wtop
, "Dummy text");
1209 g_signal_connect (wtop
, "query-tooltip", G_CALLBACK (qttip_cb
), f
);
1213 GdkScreen
*screen
= gtk_widget_get_screen (wtop
);
1214 GtkSettings
*gs
= gtk_settings_get_for_screen (screen
);
1215 /* Only connect this signal once per screen. */
1216 if (! g_signal_handler_find (G_OBJECT (gs
),
1217 G_SIGNAL_MATCH_FUNC
,
1219 G_CALLBACK (style_changed_cb
),
1222 g_signal_connect (G_OBJECT (gs
), "notify::gtk-theme-name",
1223 G_CALLBACK (style_changed_cb
),
1224 gdk_screen_get_display (screen
));
1234 xg_free_frame_widgets (struct frame
*f
)
1236 if (FRAME_GTK_OUTER_WIDGET (f
))
1238 #ifdef USE_GTK_TOOLTIP
1239 struct x_output
*x
= f
->output_data
.x
;
1241 struct xg_frame_tb_info
*tbinfo
1242 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
1247 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
1248 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow in xterm.c */
1249 FRAME_GTK_OUTER_WIDGET (f
) = 0;
1250 #ifdef USE_GTK_TOOLTIP
1252 gtk_widget_destroy (x
->ttip_lbl
);
1254 g_object_unref (G_OBJECT (x
->ttip_widget
));
1259 /* Set the normal size hints for the window manager, for frame F.
1260 FLAGS is the flags word to use--or 0 meaning preserve the flags
1261 that the window now has.
1262 If USER_POSITION, set the User Position
1263 flag (this is useful when FLAGS is 0). */
1266 x_wm_set_size_hint (struct frame
*f
, long int flags
, bool user_position
)
1268 /* Must use GTK routines here, otherwise GTK resets the size hints
1269 to its own defaults. */
1270 GdkGeometry size_hints
;
1271 gint hint_flags
= 0;
1272 int base_width
, base_height
;
1273 int min_rows
= 0, min_cols
= 0;
1274 int win_gravity
= f
->win_gravity
;
1275 Lisp_Object fs_state
, frame
;
1277 /* Don't set size hints during initialization; that apparently leads
1278 to a race condition. See the thread at
1279 http://lists.gnu.org/archive/html/emacs-devel/2008-10/msg00033.html */
1280 if (NILP (Vafter_init_time
) || !FRAME_GTK_OUTER_WIDGET (f
))
1283 XSETFRAME (frame
, f
);
1284 fs_state
= Fframe_parameter (frame
, Qfullscreen
);
1285 if (EQ (fs_state
, Qmaximized
) || EQ (fs_state
, Qfullboth
))
1287 /* Don't set hints when maximized or fullscreen. Apparently KWin and
1288 Gtk3 don't get along and the frame shrinks (!).
1295 memset (&size_hints
, 0, sizeof (size_hints
));
1296 f
->output_data
.x
->size_hints
= size_hints
;
1297 f
->output_data
.x
->hint_flags
= hint_flags
;
1300 flags
= f
->size_hint_flags
;
1302 size_hints
= f
->output_data
.x
->size_hints
;
1303 hint_flags
= f
->output_data
.x
->hint_flags
;
1305 hint_flags
|= GDK_HINT_RESIZE_INC
| GDK_HINT_MIN_SIZE
;
1306 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
1307 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
1309 hint_flags
|= GDK_HINT_BASE_SIZE
;
1310 /* Use one row/col here so base_height/width does not become zero.
1311 Gtk+ and/or Unity on Ubuntu 12.04 can't handle it. */
1312 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 1) + FRAME_TOOLBAR_WIDTH (f
);
1313 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 1)
1314 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
1316 check_frame_size (f
, &min_cols
, &min_rows
, 0);
1317 if (min_cols
> 0) --min_cols
; /* We used one col in base_width = ... 1); */
1318 if (min_rows
> 0) --min_rows
; /* We used one row in base_height = ... 1); */
1320 size_hints
.base_width
= base_width
;
1321 size_hints
.base_height
= base_height
;
1322 size_hints
.min_width
= base_width
+ min_cols
* FRAME_COLUMN_WIDTH (f
);;
1323 size_hints
.min_height
= base_height
+ min_rows
* FRAME_LINE_HEIGHT (f
);
1325 /* These currently have a one to one mapping with the X values, but I
1326 don't think we should rely on that. */
1327 hint_flags
|= GDK_HINT_WIN_GRAVITY
;
1328 size_hints
.win_gravity
= 0;
1329 if (win_gravity
== NorthWestGravity
)
1330 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_WEST
;
1331 else if (win_gravity
== NorthGravity
)
1332 size_hints
.win_gravity
= GDK_GRAVITY_NORTH
;
1333 else if (win_gravity
== NorthEastGravity
)
1334 size_hints
.win_gravity
= GDK_GRAVITY_NORTH_EAST
;
1335 else if (win_gravity
== WestGravity
)
1336 size_hints
.win_gravity
= GDK_GRAVITY_WEST
;
1337 else if (win_gravity
== CenterGravity
)
1338 size_hints
.win_gravity
= GDK_GRAVITY_CENTER
;
1339 else if (win_gravity
== EastGravity
)
1340 size_hints
.win_gravity
= GDK_GRAVITY_EAST
;
1341 else if (win_gravity
== SouthWestGravity
)
1342 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_WEST
;
1343 else if (win_gravity
== SouthGravity
)
1344 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH
;
1345 else if (win_gravity
== SouthEastGravity
)
1346 size_hints
.win_gravity
= GDK_GRAVITY_SOUTH_EAST
;
1347 else if (win_gravity
== StaticGravity
)
1348 size_hints
.win_gravity
= GDK_GRAVITY_STATIC
;
1352 hint_flags
&= ~GDK_HINT_POS
;
1353 hint_flags
|= GDK_HINT_USER_POS
;
1356 if (hint_flags
!= f
->output_data
.x
->hint_flags
1357 || memcmp (&size_hints
,
1358 &f
->output_data
.x
->size_hints
,
1359 sizeof (size_hints
)) != 0)
1362 gtk_window_set_geometry_hints (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1363 NULL
, &size_hints
, hint_flags
);
1364 f
->output_data
.x
->size_hints
= size_hints
;
1365 f
->output_data
.x
->hint_flags
= hint_flags
;
1370 /* Change background color of a frame.
1371 Since GTK uses the background color to clear the window, we must
1372 keep the GTK and X colors in sync.
1373 F is the frame to change,
1374 BG is the pixel value to change to. */
1377 xg_set_background_color (struct frame
*f
, unsigned long bg
)
1379 if (FRAME_GTK_WIDGET (f
))
1382 xg_set_widget_bg (f
, FRAME_GTK_WIDGET (f
), FRAME_BACKGROUND_PIXEL (f
));
1388 /* Set the frame icon to ICON_PIXMAP/MASK. This must be done with GTK
1389 functions so GTK does not overwrite the icon. */
1392 xg_set_frame_icon (struct frame
*f
, Pixmap icon_pixmap
, Pixmap icon_mask
)
1394 GdkPixbuf
*gp
= xg_get_pixbuf_from_pix_and_mask (f
,
1398 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)), gp
);
1403 /***********************************************************************
1405 ***********************************************************************/
1406 /* Return the dialog title to use for a dialog of type KEY.
1407 This is the encoding used by lwlib. We use the same for GTK. */
1410 get_dialog_title (char key
)
1412 const char *title
= "";
1420 title
= "Information";
1439 /* Callback for dialogs that get WM_DELETE_WINDOW. We pop down
1440 the dialog, but return TRUE so the event does not propagate further
1441 in GTK. This prevents GTK from destroying the dialog widget automatically
1442 and we can always destroy the widget manually, regardless of how
1443 it was popped down (button press or WM_DELETE_WINDOW).
1444 W is the dialog widget.
1445 EVENT is the GdkEvent that represents WM_DELETE_WINDOW (not used).
1446 user_data is NULL (not used).
1448 Returns TRUE to end propagation of event. */
1451 dialog_delete_callback (GtkWidget
*w
, GdkEvent
*event
, gpointer user_data
)
1453 gtk_widget_unmap (w
);
1457 /* Create a popup dialog window. See also xg_create_widget below.
1458 WV is a widget_value describing the dialog.
1459 SELECT_CB is the callback to use when a button has been pressed.
1460 DEACTIVATE_CB is the callback to use when the dialog pops down.
1462 Returns the GTK dialog widget. */
1465 create_dialog (widget_value
*wv
,
1466 GCallback select_cb
,
1467 GCallback deactivate_cb
)
1469 const char *title
= get_dialog_title (wv
->name
[0]);
1470 int total_buttons
= wv
->name
[1] - '0';
1471 int right_buttons
= wv
->name
[4] - '0';
1474 int button_spacing
= 10;
1475 GtkWidget
*wdialog
= gtk_dialog_new ();
1476 GtkDialog
*wd
= GTK_DIALOG (wdialog
);
1477 GtkBox
*cur_box
= GTK_BOX (gtk_dialog_get_action_area (wd
));
1479 GtkWidget
*whbox_down
;
1481 /* If the number of buttons is greater than 4, make two rows of buttons
1482 instead. This looks better. */
1483 bool make_two_rows
= total_buttons
> 4;
1485 if (right_buttons
== 0) right_buttons
= total_buttons
/2;
1486 left_buttons
= total_buttons
- right_buttons
;
1488 gtk_window_set_title (GTK_WINDOW (wdialog
), title
);
1489 gtk_widget_set_name (wdialog
, "emacs-dialog");
1494 GtkWidget
*wvbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, button_spacing
);
1495 GtkWidget
*whbox_up
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1496 gtk_box_set_homogeneous (GTK_BOX (wvbox
), TRUE
);
1497 gtk_box_set_homogeneous (GTK_BOX (whbox_up
), FALSE
);
1498 whbox_down
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
1499 gtk_box_set_homogeneous (GTK_BOX (whbox_down
), FALSE
);
1501 gtk_box_pack_start (cur_box
, wvbox
, FALSE
, FALSE
, 0);
1502 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_up
, FALSE
, FALSE
, 0);
1503 gtk_box_pack_start (GTK_BOX (wvbox
), whbox_down
, FALSE
, FALSE
, 0);
1505 cur_box
= GTK_BOX (whbox_up
);
1508 g_signal_connect (G_OBJECT (wdialog
), "delete-event",
1509 G_CALLBACK (dialog_delete_callback
), 0);
1513 g_signal_connect (G_OBJECT (wdialog
), "close", deactivate_cb
, 0);
1514 g_signal_connect (G_OBJECT (wdialog
), "response", deactivate_cb
, 0);
1517 for (item
= wv
->contents
; item
; item
= item
->next
)
1519 char *utf8_label
= get_utf8_string (item
->value
);
1523 if (item
->name
&& strcmp (item
->name
, "message") == 0)
1525 GtkBox
*wvbox
= GTK_BOX (gtk_dialog_get_content_area (wd
));
1526 /* This is the text part of the dialog. */
1527 w
= gtk_label_new (utf8_label
);
1528 gtk_box_pack_start (wvbox
, gtk_label_new (""), FALSE
, FALSE
, 0);
1529 gtk_box_pack_start (wvbox
, w
, TRUE
, TRUE
, 0);
1530 gtk_misc_set_alignment (GTK_MISC (w
), 0.1, 0.5);
1532 /* Try to make dialog look better. Must realize first so
1533 the widget can calculate the size it needs. */
1534 gtk_widget_realize (w
);
1535 gtk_widget_get_preferred_size (w
, NULL
, &req
);
1536 gtk_box_set_spacing (wvbox
, req
.height
);
1537 if (item
->value
&& strlen (item
->value
) > 0)
1538 button_spacing
= 2*req
.width
/strlen (item
->value
);
1542 /* This is one button to add to the dialog. */
1543 w
= gtk_button_new_with_label (utf8_label
);
1544 if (! item
->enabled
)
1545 gtk_widget_set_sensitive (w
, FALSE
);
1547 g_signal_connect (G_OBJECT (w
), "clicked",
1548 select_cb
, item
->call_data
);
1550 gtk_box_pack_start (cur_box
, w
, TRUE
, TRUE
, button_spacing
);
1551 if (++button_nr
== left_buttons
)
1554 cur_box
= GTK_BOX (whbox_down
);
1556 gtk_box_pack_start (cur_box
,
1564 g_free (utf8_label
);
1570 struct xg_dialog_data
1578 /* Function that is called when the file or font dialogs pop down.
1579 W is the dialog widget, RESPONSE is the response code.
1580 USER_DATA is what we passed in to g_signal_connect. */
1583 xg_dialog_response_cb (GtkDialog
*w
,
1587 struct xg_dialog_data
*dd
= user_data
;
1588 dd
->response
= response
;
1589 g_main_loop_quit (dd
->loop
);
1593 /* Destroy the dialog. This makes it pop down. */
1596 pop_down_dialog (void *arg
)
1598 struct xg_dialog_data
*dd
= arg
;
1601 if (dd
->w
) gtk_widget_destroy (dd
->w
);
1602 if (dd
->timerid
!= 0) g_source_remove (dd
->timerid
);
1604 g_main_loop_quit (dd
->loop
);
1605 g_main_loop_unref (dd
->loop
);
1610 /* If there are any emacs timers pending, add a timeout to main loop in DATA.
1611 We pass in DATA as gpointer* so we can use this as a callback. */
1614 xg_maybe_add_timer (gpointer data
)
1616 struct xg_dialog_data
*dd
= data
;
1617 struct timespec next_time
= timer_check ();
1621 if (timespec_valid_p (next_time
))
1623 time_t s
= next_time
.tv_sec
;
1624 int per_ms
= TIMESPEC_RESOLUTION
/ 1000;
1625 int ms
= (next_time
.tv_nsec
+ per_ms
- 1) / per_ms
;
1626 if (s
<= ((guint
) -1 - ms
) / 1000)
1627 dd
->timerid
= g_timeout_add (s
* 1000 + ms
, xg_maybe_add_timer
, dd
);
1633 /* Pops up a modal dialog W and waits for response.
1634 We don't use gtk_dialog_run because we want to process emacs timers.
1635 The dialog W is not destroyed when this function returns. */
1638 xg_dialog_run (struct frame
*f
, GtkWidget
*w
)
1640 ptrdiff_t count
= SPECPDL_INDEX ();
1641 struct xg_dialog_data dd
;
1643 xg_set_screen (w
, f
);
1644 gtk_window_set_transient_for (GTK_WINDOW (w
),
1645 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
1646 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
1647 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
1649 dd
.loop
= g_main_loop_new (NULL
, FALSE
);
1650 dd
.response
= GTK_RESPONSE_CANCEL
;
1654 g_signal_connect (G_OBJECT (w
),
1656 G_CALLBACK (xg_dialog_response_cb
),
1658 /* Don't destroy the widget if closed by the window manager close button. */
1659 g_signal_connect (G_OBJECT (w
), "delete-event", G_CALLBACK (gtk_true
), NULL
);
1660 gtk_widget_show (w
);
1662 record_unwind_protect_ptr (pop_down_dialog
, &dd
);
1664 (void) xg_maybe_add_timer (&dd
);
1665 g_main_loop_run (dd
.loop
);
1668 unbind_to (count
, Qnil
);
1674 /***********************************************************************
1675 File dialog functions
1676 ***********************************************************************/
1677 /* Return true if the old file selection dialog is being used. */
1680 xg_uses_old_file_dialog (void)
1682 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1683 return x_gtk_use_old_file_dialog
;
1690 typedef char * (*xg_get_file_func
) (GtkWidget
*);
1692 /* Return the selected file for file chooser dialog W.
1693 The returned string must be free:d. */
1696 xg_get_file_name_from_chooser (GtkWidget
*w
)
1698 return gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (w
));
1701 /* Callback called when the "Show hidden files" toggle is pressed.
1702 WIDGET is the toggle widget, DATA is the file chooser dialog. */
1705 xg_toggle_visibility_cb (GtkWidget
*widget
, gpointer data
)
1707 GtkFileChooser
*dialog
= GTK_FILE_CHOOSER (data
);
1709 g_object_get (G_OBJECT (dialog
), "show-hidden", &visible
, NULL
);
1710 g_object_set (G_OBJECT (dialog
), "show-hidden", !visible
, NULL
);
1714 /* Callback called when a property changes in a file chooser.
1715 GOBJECT is the file chooser dialog, ARG1 describes the property.
1716 USER_DATA is the toggle widget in the file chooser dialog.
1717 We use this to update the "Show hidden files" toggle when the user
1718 changes that property by right clicking in the file list. */
1721 xg_toggle_notify_cb (GObject
*gobject
, GParamSpec
*arg1
, gpointer user_data
)
1723 if (strcmp (arg1
->name
, "show-hidden") == 0)
1725 GtkWidget
*wtoggle
= GTK_WIDGET (user_data
);
1726 gboolean visible
, toggle_on
;
1728 g_object_get (G_OBJECT (gobject
), "show-hidden", &visible
, NULL
);
1729 toggle_on
= gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (wtoggle
));
1731 if (!!visible
!= !!toggle_on
)
1733 g_signal_handlers_block_by_func (G_OBJECT (wtoggle
),
1734 G_CALLBACK (xg_toggle_visibility_cb
),
1736 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), visible
);
1737 g_signal_handlers_unblock_by_func
1738 (G_OBJECT (wtoggle
),
1739 G_CALLBACK (xg_toggle_visibility_cb
),
1742 x_gtk_show_hidden_files
= visible
;
1746 /* Read a file name from the user using a file chooser dialog.
1747 F is the current frame.
1748 PROMPT is a prompt to show to the user. May not be NULL.
1749 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1750 If MUSTMATCH_P, the returned file name must be an existing
1751 file. (Actually, this only has cosmetic effects, the user can
1752 still enter a non-existing file.) *FUNC is set to a function that
1753 can be used to retrieve the selected file name from the returned widget.
1755 Returns the created widget. */
1758 xg_get_file_with_chooser (struct frame
*f
,
1760 char *default_filename
,
1761 bool mustmatch_p
, bool only_dir_p
,
1762 xg_get_file_func
*func
)
1766 GtkWidget
*filewin
, *wtoggle
, *wbox
, *wmessage
IF_LINT (= NULL
);
1767 GtkWindow
*gwin
= GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
));
1768 GtkFileChooserAction action
= (mustmatch_p
?
1769 GTK_FILE_CHOOSER_ACTION_OPEN
:
1770 GTK_FILE_CHOOSER_ACTION_SAVE
);
1773 action
= GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER
;
1775 filewin
= gtk_file_chooser_dialog_new (prompt
, gwin
, action
,
1776 GTK_STOCK_CANCEL
, GTK_RESPONSE_CANCEL
,
1777 (mustmatch_p
|| only_dir_p
?
1778 GTK_STOCK_OPEN
: GTK_STOCK_OK
),
1781 gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin
), TRUE
);
1783 wbox
= gtk_box_new (GTK_ORIENTATION_VERTICAL
, 0);
1784 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
1785 gtk_widget_show (wbox
);
1786 wtoggle
= gtk_check_button_new_with_label ("Show hidden files.");
1788 if (x_gtk_show_hidden_files
)
1790 g_object_set (G_OBJECT (filewin
), "show-hidden", TRUE
, NULL
);
1791 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (wtoggle
), TRUE
);
1793 gtk_widget_show (wtoggle
);
1794 g_signal_connect (G_OBJECT (wtoggle
), "clicked",
1795 G_CALLBACK (xg_toggle_visibility_cb
), filewin
);
1796 g_signal_connect (G_OBJECT (filewin
), "notify",
1797 G_CALLBACK (xg_toggle_notify_cb
), wtoggle
);
1799 if (x_gtk_file_dialog_help_text
)
1802 /* Gtk+ 2.10 has the file name text entry box integrated in the dialog.
1803 Show the C-l help text only for versions < 2.10. */
1804 if (gtk_check_version (2, 10, 0) && action
!= GTK_FILE_CHOOSER_ACTION_SAVE
)
1805 strcat (msgbuf
, "\nType C-l to display a file name text entry box.\n");
1806 strcat (msgbuf
, "\nIf you don't like this file selector, use the "
1807 "corresponding\nkey binding or customize "
1808 "use-file-dialog to turn it off.");
1810 wmessage
= gtk_label_new (msgbuf
);
1811 gtk_widget_show (wmessage
);
1814 gtk_box_pack_start (GTK_BOX (wbox
), wtoggle
, FALSE
, FALSE
, 0);
1815 if (x_gtk_file_dialog_help_text
)
1816 gtk_box_pack_start (GTK_BOX (wbox
), wmessage
, FALSE
, FALSE
, 0);
1817 gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filewin
), wbox
);
1819 if (default_filename
)
1822 struct gcpro gcpro1
;
1823 char *utf8_filename
;
1826 file
= build_string (default_filename
);
1828 /* File chooser does not understand ~/... in the file name. It must be
1829 an absolute name starting with /. */
1830 if (default_filename
[0] != '/')
1831 file
= Fexpand_file_name (file
, Qnil
);
1833 utf8_filename
= SSDATA (ENCODE_UTF_8 (file
));
1834 if (! NILP (Ffile_directory_p (file
)))
1835 gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin
),
1839 gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin
),
1841 if (action
== GTK_FILE_CHOOSER_ACTION_SAVE
)
1843 char *cp
= strrchr (utf8_filename
, '/');
1845 else cp
= utf8_filename
;
1846 gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (filewin
), cp
);
1853 *func
= xg_get_file_name_from_chooser
;
1857 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1859 /* Return the selected file for file selector dialog W.
1860 The returned string must be free:d. */
1863 xg_get_file_name_from_selector (GtkWidget
*w
)
1865 GtkFileSelection
*filesel
= GTK_FILE_SELECTION (w
);
1866 return xstrdup (gtk_file_selection_get_filename (filesel
));
1869 /* Create a file selection dialog.
1870 F is the current frame.
1871 PROMPT is a prompt to show to the user. May not be NULL.
1872 DEFAULT_FILENAME is a default selection to be displayed. May be NULL.
1873 If MUSTMATCH_P, the returned file name must be an existing
1874 file. *FUNC is set to a function that can be used to retrieve the
1875 selected file name from the returned widget.
1877 Returns the created widget. */
1880 xg_get_file_with_selection (struct frame
*f
,
1882 char *default_filename
,
1883 bool mustmatch_p
, bool only_dir_p
,
1884 xg_get_file_func
*func
)
1887 GtkFileSelection
*filesel
;
1889 filewin
= gtk_file_selection_new (prompt
);
1890 filesel
= GTK_FILE_SELECTION (filewin
);
1892 if (default_filename
)
1893 gtk_file_selection_set_filename (filesel
, default_filename
);
1897 /* The selection_entry part of filesel is not documented. */
1898 gtk_widget_set_sensitive (filesel
->selection_entry
, FALSE
);
1899 gtk_file_selection_hide_fileop_buttons (filesel
);
1902 *func
= xg_get_file_name_from_selector
;
1906 #endif /* HAVE_GTK_FILE_SELECTION_NEW */
1908 /* Read a file name from the user using a file dialog, either the old
1909 file selection dialog, or the new file chooser dialog. Which to use
1910 depends on what the GTK version used has, and what the value of
1911 gtk-use-old-file-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, the returned file name must be an existing
1918 Returns a file name or NULL if no file was selected.
1919 The returned string must be freed by the caller. */
1922 xg_get_file_name (struct frame
*f
,
1924 char *default_filename
,
1930 int filesel_done
= 0;
1931 xg_get_file_func func
;
1933 #ifdef HAVE_GTK_FILE_SELECTION_NEW
1935 if (xg_uses_old_file_dialog ())
1936 w
= xg_get_file_with_selection (f
, prompt
, default_filename
,
1937 mustmatch_p
, only_dir_p
, &func
);
1939 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1940 mustmatch_p
, only_dir_p
, &func
);
1942 #else /* not HAVE_GTK_FILE_SELECTION_NEW */
1943 w
= xg_get_file_with_chooser (f
, prompt
, default_filename
,
1944 mustmatch_p
, only_dir_p
, &func
);
1945 #endif /* not HAVE_GTK_FILE_SELECTION_NEW */
1947 gtk_widget_set_name (w
, "emacs-filedialog");
1949 filesel_done
= xg_dialog_run (f
, w
);
1950 if (filesel_done
== GTK_RESPONSE_OK
)
1953 gtk_widget_destroy (w
);
1957 /***********************************************************************
1959 ***********************************************************************/
1961 #ifdef HAVE_FREETYPE
1963 #if USE_NEW_GTK_FONT_CHOOSER
1965 #define XG_WEIGHT_TO_SYMBOL(w) \
1966 (w <= PANGO_WEIGHT_THIN ? Qextra_light \
1967 : w <= PANGO_WEIGHT_ULTRALIGHT ? Qlight \
1968 : w <= PANGO_WEIGHT_LIGHT ? Qsemi_light \
1969 : w < PANGO_WEIGHT_MEDIUM ? Qnormal \
1970 : w <= PANGO_WEIGHT_SEMIBOLD ? Qsemi_bold \
1971 : w <= PANGO_WEIGHT_BOLD ? Qbold \
1972 : w <= PANGO_WEIGHT_HEAVY ? Qextra_bold \
1975 #define XG_STYLE_TO_SYMBOL(s) \
1976 (s == PANGO_STYLE_OBLIQUE ? Qoblique \
1977 : s == PANGO_STYLE_ITALIC ? Qitalic \
1980 #endif /* USE_NEW_GTK_FONT_CHOOSER */
1983 static char *x_last_font_name
;
1985 /* Pop up a GTK font selector and return the name of the font the user
1986 selects, as a C string. The returned font name follows GTK's own
1989 `FAMILY [VALUE1 VALUE2] SIZE'
1991 This can be parsed using font_parse_fcname in font.c.
1992 DEFAULT_NAME, if non-zero, is the default font name. */
1995 xg_get_font (struct frame
*f
, const char *default_name
)
1999 Lisp_Object font
= Qnil
;
2001 w
= gtk_font_chooser_dialog_new
2002 ("Pick a font", GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2006 /* Convert fontconfig names to Gtk names, i.e. remove - before
2008 char *p
= strrchr (default_name
, '-');
2012 while (c_isdigit (*ep
))
2014 if (*ep
== '\0') *p
= ' ';
2017 else if (x_last_font_name
)
2018 default_name
= x_last_font_name
;
2021 gtk_font_chooser_set_font (GTK_FONT_CHOOSER (w
), default_name
);
2023 gtk_widget_set_name (w
, "emacs-fontdialog");
2024 done
= xg_dialog_run (f
, w
);
2025 if (done
== GTK_RESPONSE_OK
)
2027 #if USE_NEW_GTK_FONT_CHOOSER
2028 /* Use the GTK3 font chooser. */
2029 PangoFontDescription
*desc
2030 = gtk_font_chooser_get_font_desc (GTK_FONT_CHOOSER (w
));
2034 Lisp_Object args
[10];
2035 const char *name
= pango_font_description_get_family (desc
);
2036 gint size
= pango_font_description_get_size (desc
);
2037 PangoWeight weight
= pango_font_description_get_weight (desc
);
2038 PangoStyle style
= pango_font_description_get_style (desc
);
2041 args
[1] = build_string (name
);
2044 args
[3] = make_float (pango_units_to_double (size
));
2047 args
[5] = XG_WEIGHT_TO_SYMBOL (weight
);
2050 args
[7] = XG_STYLE_TO_SYMBOL (style
);
2055 font
= Ffont_spec (8, args
);
2057 pango_font_description_free (desc
);
2058 dupstring (&x_last_font_name
, name
);
2061 #else /* Use old font selector, which just returns the font name. */
2064 = gtk_font_selection_dialog_get_font_name (GTK_FONT_CHOOSER (w
));
2068 font
= build_string (font_name
);
2069 g_free (x_last_font_name
);
2070 x_last_font_name
= font_name
;
2072 #endif /* USE_NEW_GTK_FONT_CHOOSER */
2075 gtk_widget_destroy (w
);
2078 #endif /* HAVE_FREETYPE */
2082 /***********************************************************************
2084 ***********************************************************************/
2086 /* The name of menu items that can be used for customization. Since GTK
2087 RC files are very crude and primitive, we have to set this on all
2088 menu item names so a user can easily customize menu items. */
2090 #define MENU_ITEM_NAME "emacs-menuitem"
2093 /* Linked list of all allocated struct xg_menu_cb_data. Used for marking
2094 during GC. The next member points to the items. */
2095 static xg_list_node xg_menu_cb_list
;
2097 /* Linked list of all allocated struct xg_menu_item_cb_data. Used for marking
2098 during GC. The next member points to the items. */
2099 static xg_list_node xg_menu_item_cb_list
;
2101 /* Allocate and initialize CL_DATA if NULL, otherwise increase ref_count.
2102 F is the frame CL_DATA will be initialized for.
2103 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2105 The menu bar and all sub menus under the menu bar in a frame
2106 share the same structure, hence the reference count.
2108 Returns CL_DATA if CL_DATA is not NULL, or a pointer to a newly
2109 allocated xg_menu_cb_data if CL_DATA is NULL. */
2111 static xg_menu_cb_data
*
2112 make_cl_data (xg_menu_cb_data
*cl_data
, struct frame
*f
, GCallback highlight_cb
)
2116 cl_data
= xmalloc (sizeof *cl_data
);
2118 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2119 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2120 cl_data
->highlight_cb
= highlight_cb
;
2121 cl_data
->ref_count
= 0;
2123 xg_list_insert (&xg_menu_cb_list
, &cl_data
->ptrs
);
2126 cl_data
->ref_count
++;
2131 /* Update CL_DATA with values from frame F and with HIGHLIGHT_CB.
2132 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2134 When the menu bar is updated, menu items may have been added and/or
2135 removed, so menu_bar_vector and menu_bar_items_used change. We must
2136 then update CL_DATA since it is used to determine which menu
2137 item that is invoked in the menu.
2138 HIGHLIGHT_CB could change, there is no check that the same
2139 function is given when modifying a menu bar as was given when
2140 creating the menu bar. */
2143 update_cl_data (xg_menu_cb_data
*cl_data
,
2145 GCallback highlight_cb
)
2150 cl_data
->menu_bar_vector
= f
->menu_bar_vector
;
2151 cl_data
->menu_bar_items_used
= f
->menu_bar_items_used
;
2152 cl_data
->highlight_cb
= highlight_cb
;
2156 /* Decrease reference count for CL_DATA.
2157 If reference count is zero, free CL_DATA. */
2160 unref_cl_data (xg_menu_cb_data
*cl_data
)
2162 if (cl_data
&& cl_data
->ref_count
> 0)
2164 cl_data
->ref_count
--;
2165 if (cl_data
->ref_count
== 0)
2167 xg_list_remove (&xg_menu_cb_list
, &cl_data
->ptrs
);
2173 /* Callback called when a menu item is destroyed. Used to free data.
2174 W is the widget that is being destroyed (not used).
2175 CLIENT_DATA points to the xg_menu_item_cb_data associated with the W. */
2178 menuitem_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2182 xg_menu_item_cb_data
*data
= client_data
;
2183 xg_list_remove (&xg_menu_item_cb_list
, &data
->ptrs
);
2188 /* Callback called when the pointer enters/leaves a menu item.
2189 W is the parent of the menu item.
2190 EVENT is either an enter event or leave event.
2191 CLIENT_DATA is not used.
2193 Returns FALSE to tell GTK to keep processing this event. */
2196 menuitem_highlight_callback (GtkWidget
*w
,
2197 GdkEventCrossing
*event
,
2198 gpointer client_data
)
2201 GtkWidget
*subwidget
;
2202 xg_menu_item_cb_data
*data
;
2204 ev
.crossing
= *event
;
2205 subwidget
= gtk_get_event_widget (&ev
);
2206 data
= g_object_get_data (G_OBJECT (subwidget
), XG_ITEM_DATA
);
2209 if (! NILP (data
->help
) && data
->cl_data
->highlight_cb
)
2211 gpointer call_data
= event
->type
== GDK_LEAVE_NOTIFY
? 0 : data
;
2212 GtkCallback func
= (GtkCallback
) data
->cl_data
->highlight_cb
;
2213 (*func
) (subwidget
, call_data
);
2220 /* Callback called when a menu is destroyed. Used to free data.
2221 W is the widget that is being destroyed (not used).
2222 CLIENT_DATA points to the xg_menu_cb_data associated with W. */
2225 menu_destroy_callback (GtkWidget
*w
, gpointer client_data
)
2227 unref_cl_data (client_data
);
2230 /* Make a GTK widget that contains both UTF8_LABEL and UTF8_KEY (both
2231 must be non-NULL) and can be inserted into a menu item.
2233 Returns the GtkHBox. */
2236 make_widget_for_menu_item (const char *utf8_label
, const char *utf8_key
)
2242 wbox
= gtk_box_new (GTK_ORIENTATION_HORIZONTAL
, 0);
2243 gtk_box_set_homogeneous (GTK_BOX (wbox
), FALSE
);
2244 wlbl
= gtk_label_new (utf8_label
);
2245 wkey
= gtk_label_new (utf8_key
);
2247 gtk_misc_set_alignment (GTK_MISC (wlbl
), 0.0, 0.5);
2248 gtk_misc_set_alignment (GTK_MISC (wkey
), 0.0, 0.5);
2250 gtk_box_pack_start (GTK_BOX (wbox
), wlbl
, TRUE
, TRUE
, 0);
2251 gtk_box_pack_start (GTK_BOX (wbox
), wkey
, FALSE
, FALSE
, 0);
2253 gtk_widget_set_name (wlbl
, MENU_ITEM_NAME
);
2254 gtk_widget_set_name (wkey
, MENU_ITEM_NAME
);
2255 gtk_widget_set_name (wbox
, MENU_ITEM_NAME
);
2260 /* Make and return a menu item widget with the key to the right.
2261 UTF8_LABEL is the text for the menu item (GTK uses UTF8 internally).
2262 UTF8_KEY is the text representing the key binding.
2263 ITEM is the widget_value describing the menu item.
2265 GROUP is an in/out parameter. If the menu item to be created is not
2266 part of any radio menu group, *GROUP contains NULL on entry and exit.
2267 If the menu item to be created is part of a radio menu group, on entry
2268 *GROUP contains the group to use, or NULL if this is the first item
2269 in the group. On exit, *GROUP contains the radio item group.
2271 Unfortunately, keys don't line up as nicely as in Motif,
2272 but the MacOS X version doesn't either, so I guess that is OK. */
2275 make_menu_item (const char *utf8_label
,
2276 const char *utf8_key
,
2281 GtkWidget
*wtoadd
= 0;
2283 /* It has been observed that some menu items have a NULL name field.
2284 This will lead to this function being called with a NULL utf8_label.
2285 GTK crashes on that so we set a blank label. Why there is a NULL
2286 name remains to be investigated. */
2287 if (! utf8_label
) utf8_label
= " ";
2290 wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2292 if (item
->button_type
== BUTTON_TYPE_TOGGLE
)
2295 if (utf8_key
) w
= gtk_check_menu_item_new ();
2296 else w
= gtk_check_menu_item_new_with_label (utf8_label
);
2297 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), item
->selected
);
2299 else if (item
->button_type
== BUTTON_TYPE_RADIO
)
2301 if (utf8_key
) w
= gtk_radio_menu_item_new (*group
);
2302 else w
= gtk_radio_menu_item_new_with_label (*group
, utf8_label
);
2303 *group
= gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (w
));
2305 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), TRUE
);
2310 if (utf8_key
) w
= gtk_menu_item_new ();
2311 else w
= gtk_menu_item_new_with_label (utf8_label
);
2314 if (wtoadd
) gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2315 if (! item
->enabled
) gtk_widget_set_sensitive (w
, FALSE
);
2320 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2322 static int xg_detached_menus
;
2324 /* Return true if there are detached menus. */
2327 xg_have_tear_offs (struct frame
*f
)
2329 /* If the frame's menubar height is zero, the menu bar is probably
2330 being redirected outside the window to some kind of global menu;
2331 this situation is the moral equivalent of a tear-off. */
2332 return FRAME_MENUBAR_HEIGHT (f
) == 0 || xg_detached_menus
> 0;
2335 /* Callback invoked when a detached menu window is removed. Here we
2336 decrease the xg_detached_menus count.
2337 WIDGET is the top level window that is removed (the parent of the menu).
2338 CLIENT_DATA is not used. */
2341 tearoff_remove (GtkWidget
*widget
, gpointer client_data
)
2343 if (xg_detached_menus
> 0) --xg_detached_menus
;
2346 /* Callback invoked when a menu is detached. It increases the
2347 xg_detached_menus count.
2348 WIDGET is the GtkTearoffMenuItem.
2349 CLIENT_DATA is not used. */
2352 tearoff_activate (GtkWidget
*widget
, gpointer client_data
)
2354 GtkWidget
*menu
= gtk_widget_get_parent (widget
);
2355 if (gtk_menu_get_tearoff_state (GTK_MENU (menu
)))
2357 ++xg_detached_menus
;
2358 g_signal_connect (G_OBJECT (gtk_widget_get_toplevel (widget
)),
2360 G_CALLBACK (tearoff_remove
), 0);
2363 #else /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2365 xg_have_tear_offs (struct frame
*f
)
2367 return FRAME_MENUBAR_HEIGHT (f
) == 0;
2369 #endif /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
2371 /* Create a menu item widget, and connect the callbacks.
2372 ITEM describes the menu item.
2373 F is the frame the created menu belongs to.
2374 SELECT_CB is the callback to use when a menu item is selected.
2375 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2376 CL_DATA points to the callback data to be used for this menu.
2377 GROUP is an in/out parameter. If the menu item to be created is not
2378 part of any radio menu group, *GROUP contains NULL on entry and exit.
2379 If the menu item to be created is part of a radio menu group, on entry
2380 *GROUP contains the group to use, or NULL if this is the first item
2381 in the group. On exit, *GROUP contains the radio item group.
2383 Returns the created GtkWidget. */
2386 xg_create_one_menuitem (widget_value
*item
,
2388 GCallback select_cb
,
2389 GCallback highlight_cb
,
2390 xg_menu_cb_data
*cl_data
,
2396 xg_menu_item_cb_data
*cb_data
;
2398 utf8_label
= get_utf8_string (item
->name
);
2399 utf8_key
= get_utf8_string (item
->key
);
2401 w
= make_menu_item (utf8_label
, utf8_key
, item
, group
);
2403 if (utf8_label
) g_free (utf8_label
);
2404 if (utf8_key
) g_free (utf8_key
);
2406 cb_data
= xmalloc (sizeof *cb_data
);
2408 xg_list_insert (&xg_menu_item_cb_list
, &cb_data
->ptrs
);
2410 cb_data
->select_id
= 0;
2411 cb_data
->help
= item
->help
;
2412 cb_data
->cl_data
= cl_data
;
2413 cb_data
->call_data
= item
->call_data
;
2415 g_signal_connect (G_OBJECT (w
),
2417 G_CALLBACK (menuitem_destroy_callback
),
2420 /* Put cb_data in widget, so we can get at it when modifying menubar */
2421 g_object_set_data (G_OBJECT (w
), XG_ITEM_DATA
, cb_data
);
2423 /* final item, not a submenu */
2424 if (item
->call_data
&& ! item
->contents
)
2428 = g_signal_connect (G_OBJECT (w
), "activate", select_cb
, cb_data
);
2434 /* Create a full menu tree specified by DATA.
2435 F is the frame the created menu belongs to.
2436 SELECT_CB is the callback to use when a menu item is selected.
2437 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
2438 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2439 If POP_UP_P, create a popup menu.
2440 If MENU_BAR_P, create a menu bar.
2441 If ADD_TEAROFF_P, add a tearoff menu item. Ignored if MENU_BAR_P or
2442 the Gtk+ version used does not have tearoffs.
2443 TOPMENU is the topmost GtkWidget that others shall be placed under.
2444 It may be NULL, in that case we create the appropriate widget
2445 (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
2446 CL_DATA is the callback data we shall use for this menu, or NULL
2447 if we haven't set the first callback yet.
2448 NAME is the name to give to the top level menu if this function
2449 creates it. May be NULL to not set any name.
2451 Returns the top level GtkWidget. This is TOPLEVEL if TOPLEVEL is
2454 This function calls itself to create submenus. */
2457 create_menus (widget_value
*data
,
2459 GCallback select_cb
,
2460 GCallback deactivate_cb
,
2461 GCallback highlight_cb
,
2466 xg_menu_cb_data
*cl_data
,
2470 GtkWidget
*wmenu
= topmenu
;
2471 GSList
*group
= NULL
;
2477 wmenu
= gtk_menu_new ();
2478 xg_set_screen (wmenu
, f
);
2479 /* Connect this to the menu instead of items so we get enter/leave for
2480 disabled items also. TODO: Still does not get enter/leave for
2481 disabled items in detached menus. */
2482 g_signal_connect (G_OBJECT (wmenu
),
2483 "enter-notify-event",
2484 G_CALLBACK (menuitem_highlight_callback
),
2486 g_signal_connect (G_OBJECT (wmenu
),
2487 "leave-notify-event",
2488 G_CALLBACK (menuitem_highlight_callback
),
2493 wmenu
= gtk_menu_bar_new ();
2494 /* Set width of menu bar to a small value so it doesn't enlarge
2495 a small initial frame size. The width will be set to the
2496 width of the frame later on when it is added to a container.
2497 height -1: Natural height. */
2498 gtk_widget_set_size_request (wmenu
, 1, -1);
2501 /* Put cl_data on the top menu for easier access. */
2502 cl_data
= make_cl_data (cl_data
, f
, highlight_cb
);
2503 g_object_set_data (G_OBJECT (wmenu
), XG_FRAME_DATA
, (gpointer
)cl_data
);
2504 g_signal_connect (G_OBJECT (wmenu
), "destroy",
2505 G_CALLBACK (menu_destroy_callback
), cl_data
);
2508 gtk_widget_set_name (wmenu
, name
);
2511 g_signal_connect (G_OBJECT (wmenu
),
2512 "selection-done", deactivate_cb
, 0);
2515 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2516 if (! menu_bar_p
&& add_tearoff_p
)
2518 GtkWidget
*tearoff
= gtk_tearoff_menu_item_new ();
2519 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), tearoff
);
2521 g_signal_connect (G_OBJECT (tearoff
), "activate",
2522 G_CALLBACK (tearoff_activate
), 0);
2526 for (item
= data
; item
; item
= item
->next
)
2530 if (pop_up_p
&& !item
->contents
&& !item
->call_data
2531 && !menu_separator_name_p (item
->name
))
2534 /* A title for a popup. We do the same as GTK does when
2535 creating titles, but it does not look good. */
2537 utf8_label
= get_utf8_string (item
->name
);
2539 gtk_menu_set_title (GTK_MENU (wmenu
), utf8_label
);
2540 w
= gtk_menu_item_new_with_label (utf8_label
);
2541 gtk_widget_set_sensitive (w
, FALSE
);
2542 if (utf8_label
) g_free (utf8_label
);
2544 else if (menu_separator_name_p (item
->name
))
2547 /* GTK only have one separator type. */
2548 w
= gtk_separator_menu_item_new ();
2552 w
= xg_create_one_menuitem (item
,
2554 item
->contents
? 0 : select_cb
,
2559 /* Create a possibly empty submenu for menu bar items, since some
2560 themes don't highlight items correctly without it. */
2561 if (item
->contents
|| menu_bar_p
)
2563 GtkWidget
*submenu
= create_menus (item
->contents
,
2574 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2578 gtk_menu_shell_append (GTK_MENU_SHELL (wmenu
), w
);
2579 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2585 /* Create a menubar, popup menu or dialog, depending on the TYPE argument.
2586 TYPE can be "menubar", "popup" for popup menu, or "dialog" for a dialog
2587 with some text and buttons.
2588 F is the frame the created item belongs to.
2589 NAME is the name to use for the top widget.
2590 VAL is a widget_value structure describing items to be created.
2591 SELECT_CB is the callback to use when a menu item is selected or
2592 a dialog button is pressed.
2593 DEACTIVATE_CB is the callback to use when an item is deactivated.
2594 For a menu, when a sub menu is not shown anymore, for a dialog it is
2595 called when the dialog is popped down.
2596 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2598 Returns the widget created. */
2601 xg_create_widget (const char *type
, const char *name
, struct frame
*f
,
2602 widget_value
*val
, GCallback select_cb
,
2603 GCallback deactivate_cb
, GCallback highlight_cb
)
2606 bool menu_bar_p
= strcmp (type
, "menubar") == 0;
2607 bool pop_up_p
= strcmp (type
, "popup") == 0;
2609 if (strcmp (type
, "dialog") == 0)
2611 w
= create_dialog (val
, select_cb
, deactivate_cb
);
2612 xg_set_screen (w
, f
);
2613 gtk_window_set_transient_for (GTK_WINDOW (w
),
2614 GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
2615 gtk_window_set_destroy_with_parent (GTK_WINDOW (w
), TRUE
);
2616 gtk_widget_set_name (w
, "emacs-dialog");
2617 gtk_window_set_modal (GTK_WINDOW (w
), TRUE
);
2619 else if (menu_bar_p
|| pop_up_p
)
2621 w
= create_menus (val
->contents
,
2633 /* Set the cursor to an arrow for popup menus when they are mapped.
2634 This is done by default for menu bar menus. */
2637 /* Must realize so the GdkWindow inside the widget is created. */
2638 gtk_widget_realize (w
);
2639 xg_set_cursor (w
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
2644 fprintf (stderr
, "bad type in xg_create_widget: %s, doing nothing\n",
2651 /* Return the label for menu item WITEM. */
2654 xg_get_menu_item_label (GtkMenuItem
*witem
)
2656 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2657 return gtk_label_get_label (wlabel
);
2660 /* Return true if the menu item WITEM has the text LABEL. */
2663 xg_item_label_same_p (GtkMenuItem
*witem
, const char *label
)
2666 char *utf8_label
= get_utf8_string (label
);
2667 const char *old_label
= witem
? xg_get_menu_item_label (witem
) : 0;
2669 if (! old_label
&& ! utf8_label
)
2671 else if (old_label
&& utf8_label
)
2672 is_same
= strcmp (utf8_label
, old_label
) == 0;
2674 if (utf8_label
) g_free (utf8_label
);
2679 /* Destroy widgets in LIST. */
2682 xg_destroy_widgets (GList
*list
)
2686 for (iter
= list
; iter
; iter
= g_list_next (iter
))
2688 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
2690 /* Destroying the widget will remove it from the container it is in. */
2691 gtk_widget_destroy (w
);
2695 /* Update the top level names in MENUBAR (i.e. not submenus).
2696 F is the frame the menu bar belongs to.
2697 *LIST is a list with the current menu bar names (menu item widgets).
2698 ITER is the item within *LIST that shall be updated.
2699 POS is the numerical position, starting at 0, of ITER in *LIST.
2700 VAL describes what the menu bar shall look like after the update.
2701 SELECT_CB is the callback to use when a menu item is selected.
2702 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2703 CL_DATA points to the callback data to be used for this menu bar.
2705 This function calls itself to walk through the menu bar names. */
2708 xg_update_menubar (GtkWidget
*menubar
,
2714 GCallback select_cb
,
2715 GCallback deactivate_cb
,
2716 GCallback highlight_cb
,
2717 xg_menu_cb_data
*cl_data
)
2719 if (! iter
&& ! val
)
2721 else if (iter
&& ! val
)
2723 /* Item(s) have been removed. Remove all remaining items. */
2724 xg_destroy_widgets (iter
);
2726 /* Add a blank entry so the menubar doesn't collapse to nothing. */
2727 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2728 gtk_menu_item_new_with_label (""),
2734 else if (! iter
&& val
)
2736 /* Item(s) added. Add all new items in one call. */
2737 create_menus (val
, f
, select_cb
, deactivate_cb
, highlight_cb
,
2738 0, 1, 0, menubar
, cl_data
, 0);
2744 /* Below this neither iter or val is NULL */
2745 else if (xg_item_label_same_p (GTK_MENU_ITEM (iter
->data
), val
->name
))
2747 /* This item is still the same, check next item. */
2749 iter
= g_list_next (iter
);
2752 else /* This item is changed. */
2754 GtkMenuItem
*witem
= GTK_MENU_ITEM (iter
->data
);
2755 GtkMenuItem
*witem2
= 0;
2756 bool val_in_menubar
= 0;
2757 bool iter_in_new_menubar
= 0;
2761 /* See if the changed entry (val) is present later in the menu bar */
2763 iter2
&& ! val_in_menubar
;
2764 iter2
= g_list_next (iter2
))
2766 witem2
= GTK_MENU_ITEM (iter2
->data
);
2767 val_in_menubar
= xg_item_label_same_p (witem2
, val
->name
);
2770 /* See if the current entry (iter) is present later in the
2771 specification for the new menu bar. */
2772 for (cur
= val
; cur
&& ! iter_in_new_menubar
; cur
= cur
->next
)
2773 iter_in_new_menubar
= xg_item_label_same_p (witem
, cur
->name
);
2775 if (val_in_menubar
&& ! iter_in_new_menubar
)
2779 /* This corresponds to:
2784 g_object_ref (G_OBJECT (witem
));
2785 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem
));
2786 gtk_widget_destroy (GTK_WIDGET (witem
));
2788 /* Must get new list since the old changed. */
2789 g_list_free (*list
);
2790 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2791 while (nr
-- > 0) iter
= g_list_next (iter
);
2793 else if (! val_in_menubar
&& ! iter_in_new_menubar
)
2795 /* This corresponds to:
2798 Rename B to X. This might seem to be a strange thing to do,
2799 since if there is a menu under B it will be totally wrong for X.
2800 But consider editing a C file. Then there is a C-mode menu
2801 (corresponds to B above).
2802 If then doing C-x C-f the minibuf menu (X above) replaces the
2803 C-mode menu. When returning from the minibuffer, we get
2804 back the C-mode menu. Thus we do:
2805 Rename B to X (C-mode to minibuf menu)
2806 Rename X to B (minibuf to C-mode menu).
2807 If the X menu hasn't been invoked, the menu under B
2808 is up to date when leaving the minibuffer. */
2809 GtkLabel
*wlabel
= GTK_LABEL (XG_BIN_CHILD (witem
));
2810 char *utf8_label
= get_utf8_string (val
->name
);
2811 GtkWidget
*submenu
= gtk_menu_item_get_submenu (witem
);
2813 /* GTK menu items don't notice when their labels have been
2814 changed from underneath them, so we have to explicitly
2815 use g_object_notify to tell listeners (e.g., a GMenuModel
2816 bridge that might be loaded) that the item's label has
2818 gtk_label_set_text (wlabel
, utf8_label
);
2819 g_object_notify (G_OBJECT (witem
), "label");
2821 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
2822 /* If this item has a submenu that has been detached, change
2823 the title in the WM decorations also. */
2824 if (submenu
&& gtk_menu_get_tearoff_state (GTK_MENU (submenu
)))
2825 /* Set the title of the detached window. */
2826 gtk_menu_set_title (GTK_MENU (submenu
), utf8_label
);
2829 if (utf8_label
) g_free (utf8_label
);
2830 iter
= g_list_next (iter
);
2834 else if (! val_in_menubar
&& iter_in_new_menubar
)
2836 /* This corresponds to:
2843 GtkWidget
*w
= xg_create_one_menuitem (val
,
2850 /* Create a possibly empty submenu for menu bar items, since some
2851 themes don't highlight items correctly without it. */
2852 GtkWidget
*submenu
= create_menus (NULL
, f
,
2853 select_cb
, deactivate_cb
,
2855 0, 0, 0, 0, cl_data
, 0);
2857 gtk_widget_set_name (w
, MENU_ITEM_NAME
);
2858 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
), w
, pos
);
2859 gtk_menu_item_set_submenu (GTK_MENU_ITEM (w
), submenu
);
2861 g_list_free (*list
);
2862 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2863 while (nr
-- > 0) iter
= g_list_next (iter
);
2864 iter
= g_list_next (iter
);
2868 else /* if (val_in_menubar && iter_in_new_menubar) */
2871 /* This corresponds to:
2876 g_object_ref (G_OBJECT (witem2
));
2877 gtk_container_remove (GTK_CONTAINER (menubar
), GTK_WIDGET (witem2
));
2878 gtk_menu_shell_insert (GTK_MENU_SHELL (menubar
),
2879 GTK_WIDGET (witem2
), pos
);
2880 g_object_unref (G_OBJECT (witem2
));
2882 g_list_free (*list
);
2883 *list
= iter
= gtk_container_get_children (GTK_CONTAINER (menubar
));
2884 while (nr
-- > 0) iter
= g_list_next (iter
);
2885 if (iter
) iter
= g_list_next (iter
);
2891 /* Update the rest of the menu bar. */
2892 xg_update_menubar (menubar
, f
, list
, iter
, pos
, val
,
2893 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
2896 /* Update the menu item W so it corresponds to VAL.
2897 SELECT_CB is the callback to use when a menu item is selected.
2898 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
2899 CL_DATA is the data to set in the widget for menu invocation. */
2902 xg_update_menu_item (widget_value
*val
,
2904 GCallback select_cb
,
2905 GCallback highlight_cb
,
2906 xg_menu_cb_data
*cl_data
)
2913 const char *old_label
= 0;
2914 const char *old_key
= 0;
2915 xg_menu_item_cb_data
*cb_data
;
2916 bool label_changed
= false;
2918 wchild
= XG_BIN_CHILD (w
);
2919 utf8_label
= get_utf8_string (val
->name
);
2920 utf8_key
= get_utf8_string (val
->key
);
2922 /* See if W is a menu item with a key. See make_menu_item above. */
2923 if (GTK_IS_BOX (wchild
))
2925 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wchild
));
2927 wlbl
= GTK_LABEL (list
->data
);
2928 wkey
= GTK_LABEL (list
->next
->data
);
2933 /* Remove the key and keep just the label. */
2934 g_object_ref (G_OBJECT (wlbl
));
2935 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2936 gtk_container_add (GTK_CONTAINER (w
), GTK_WIDGET (wlbl
));
2937 g_object_unref (G_OBJECT (wlbl
));
2942 else /* Just a label. */
2944 wlbl
= GTK_LABEL (wchild
);
2946 /* Check if there is now a key. */
2949 GtkWidget
*wtoadd
= make_widget_for_menu_item (utf8_label
, utf8_key
);
2950 GList
*list
= gtk_container_get_children (GTK_CONTAINER (wtoadd
));
2952 wlbl
= GTK_LABEL (list
->data
);
2953 wkey
= GTK_LABEL (list
->next
->data
);
2956 gtk_container_remove (GTK_CONTAINER (w
), wchild
);
2957 gtk_container_add (GTK_CONTAINER (w
), wtoadd
);
2961 if (wkey
) old_key
= gtk_label_get_label (wkey
);
2962 if (wlbl
) old_label
= gtk_label_get_label (wlbl
);
2964 if (wkey
&& utf8_key
&& (! old_key
|| strcmp (utf8_key
, old_key
) != 0))
2966 label_changed
= true;
2967 gtk_label_set_text (wkey
, utf8_key
);
2970 if (! old_label
|| strcmp (utf8_label
, old_label
) != 0)
2972 label_changed
= true;
2973 gtk_label_set_text (wlbl
, utf8_label
);
2976 if (utf8_key
) g_free (utf8_key
);
2977 if (utf8_label
) g_free (utf8_label
);
2979 if (! val
->enabled
&& gtk_widget_get_sensitive (w
))
2980 gtk_widget_set_sensitive (w
, FALSE
);
2981 else if (val
->enabled
&& ! gtk_widget_get_sensitive (w
))
2982 gtk_widget_set_sensitive (w
, TRUE
);
2984 cb_data
= g_object_get_data (G_OBJECT (w
), XG_ITEM_DATA
);
2987 cb_data
->call_data
= val
->call_data
;
2988 cb_data
->help
= val
->help
;
2989 cb_data
->cl_data
= cl_data
;
2991 /* We assume the callback functions don't change. */
2992 if (val
->call_data
&& ! val
->contents
)
2994 /* This item shall have a select callback. */
2995 if (! cb_data
->select_id
)
2997 = g_signal_connect (G_OBJECT (w
), "activate",
2998 select_cb
, cb_data
);
3000 else if (cb_data
->select_id
)
3002 g_signal_handler_disconnect (w
, cb_data
->select_id
);
3003 cb_data
->select_id
= 0;
3007 if (label_changed
) /* See comment in xg_update_menubar. */
3008 g_object_notify (G_OBJECT (w
), "label");
3011 /* Update the toggle menu item W so it corresponds to VAL. */
3014 xg_update_toggle_item (widget_value
*val
, GtkWidget
*w
)
3016 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3019 /* Update the radio menu item W so it corresponds to VAL. */
3022 xg_update_radio_item (widget_value
*val
, GtkWidget
*w
)
3024 gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (w
), val
->selected
);
3027 /* Update the sub menu SUBMENU and all its children so it corresponds to VAL.
3028 SUBMENU may be NULL, in that case a new menu is created.
3029 F is the frame the menu bar belongs to.
3030 VAL describes the contents of the menu bar.
3031 SELECT_CB is the callback to use when a menu item is selected.
3032 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3033 HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
3034 CL_DATA is the call back data to use for any newly created items.
3036 Returns the updated submenu widget, that is SUBMENU unless SUBMENU
3040 xg_update_submenu (GtkWidget
*submenu
,
3043 GCallback select_cb
,
3044 GCallback deactivate_cb
,
3045 GCallback highlight_cb
,
3046 xg_menu_cb_data
*cl_data
)
3048 GtkWidget
*newsub
= submenu
;
3052 bool has_tearoff_p
= 0;
3053 GList
*first_radio
= 0;
3056 list
= gtk_container_get_children (GTK_CONTAINER (submenu
));
3058 for (cur
= val
, iter
= list
;
3060 iter
= g_list_next (iter
), cur
= cur
->next
)
3062 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3064 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
3065 /* Skip tearoff items, they have no counterpart in val. */
3066 if (GTK_IS_TEAROFF_MENU_ITEM (w
))
3069 iter
= g_list_next (iter
);
3070 if (iter
) w
= GTK_WIDGET (iter
->data
);
3075 /* Remember first radio button in a group. If we get a mismatch in
3076 a radio group we must rebuild the whole group so that the connections
3077 in GTK becomes correct. */
3078 if (cur
->button_type
== BUTTON_TYPE_RADIO
&& ! first_radio
)
3080 else if (cur
->button_type
!= BUTTON_TYPE_RADIO
3081 && ! GTK_IS_RADIO_MENU_ITEM (w
))
3084 if (GTK_IS_SEPARATOR_MENU_ITEM (w
))
3086 if (! menu_separator_name_p (cur
->name
))
3089 else if (GTK_IS_CHECK_MENU_ITEM (w
))
3091 if (cur
->button_type
!= BUTTON_TYPE_TOGGLE
)
3093 xg_update_toggle_item (cur
, w
);
3094 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3096 else if (GTK_IS_RADIO_MENU_ITEM (w
))
3098 if (cur
->button_type
!= BUTTON_TYPE_RADIO
)
3100 xg_update_radio_item (cur
, w
);
3101 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3103 else if (GTK_IS_MENU_ITEM (w
))
3105 GtkMenuItem
*witem
= GTK_MENU_ITEM (w
);
3108 if (cur
->button_type
!= BUTTON_TYPE_NONE
||
3109 menu_separator_name_p (cur
->name
))
3112 xg_update_menu_item (cur
, w
, select_cb
, highlight_cb
, cl_data
);
3114 sub
= gtk_menu_item_get_submenu (witem
);
3115 if (sub
&& ! cur
->contents
)
3117 /* Not a submenu anymore. */
3118 g_object_ref (G_OBJECT (sub
));
3119 remove_submenu (witem
);
3120 gtk_widget_destroy (sub
);
3122 else if (cur
->contents
)
3126 nsub
= xg_update_submenu (sub
, f
, cur
->contents
,
3127 select_cb
, deactivate_cb
,
3128 highlight_cb
, cl_data
);
3130 /* If this item just became a submenu, we must set it. */
3132 gtk_menu_item_set_submenu (witem
, nsub
);
3137 /* Structural difference. Remove everything from here and down
3143 /* Remove widgets from first structural change. */
3146 /* If we are adding new menu items below, we must remove from
3147 first radio button so that radio groups become correct. */
3148 if (cur
&& first_radio
) xg_destroy_widgets (first_radio
);
3149 else xg_destroy_widgets (iter
);
3154 /* More items added. Create them. */
3155 newsub
= create_menus (cur
,
3168 if (list
) g_list_free (list
);
3173 /* Update the MENUBAR.
3174 F is the frame the menu bar belongs to.
3175 VAL describes the contents of the menu bar.
3176 If DEEP_P, rebuild all but the top level menu names in
3177 the MENUBAR. If DEEP_P is zero, just rebuild the names in the menubar.
3178 SELECT_CB is the callback to use when a menu item is selected.
3179 DEACTIVATE_CB is the callback to use when a sub menu is not shown anymore.
3180 HIGHLIGHT_CB is the callback to call when entering/leaving menu items. */
3183 xg_modify_menubar_widgets (GtkWidget
*menubar
, struct frame
*f
,
3184 widget_value
*val
, bool deep_p
,
3185 GCallback select_cb
, GCallback deactivate_cb
,
3186 GCallback highlight_cb
)
3188 xg_menu_cb_data
*cl_data
;
3189 GList
*list
= gtk_container_get_children (GTK_CONTAINER (menubar
));
3193 cl_data
= g_object_get_data (G_OBJECT (menubar
), XG_FRAME_DATA
);
3195 xg_update_menubar (menubar
, f
, &list
, list
, 0, val
->contents
,
3196 select_cb
, deactivate_cb
, highlight_cb
, cl_data
);
3202 /* Update all sub menus.
3203 We must keep the submenus (GTK menu item widgets) since the
3204 X Window in the XEvent that activates the menu are those widgets. */
3206 /* Update cl_data, menu_item things in F may have changed. */
3207 update_cl_data (cl_data
, f
, highlight_cb
);
3209 for (cur
= val
->contents
; cur
; cur
= cur
->next
)
3214 GtkMenuItem
*witem
= 0;
3216 /* Find sub menu that corresponds to val and update it. */
3217 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3219 witem
= GTK_MENU_ITEM (iter
->data
);
3220 if (xg_item_label_same_p (witem
, cur
->name
))
3222 sub
= gtk_menu_item_get_submenu (witem
);
3227 newsub
= xg_update_submenu (sub
,
3234 /* sub may still be NULL. If we just updated non deep and added
3235 a new menu bar item, it has no sub menu yet. So we set the
3236 newly created sub menu under witem. */
3237 if (newsub
!= sub
&& witem
!= 0)
3239 xg_set_screen (newsub
, f
);
3240 gtk_menu_item_set_submenu (witem
, newsub
);
3246 gtk_widget_show_all (menubar
);
3249 /* Callback called when the menu bar W is mapped.
3250 Used to find the height of the menu bar if we didn't get it
3251 after showing the widget. */
3254 menubar_map_cb (GtkWidget
*w
, gpointer user_data
)
3257 struct frame
*f
= user_data
;
3258 gtk_widget_get_preferred_size (w
, NULL
, &req
);
3259 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3261 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3262 xg_height_or_width_changed (f
);
3266 /* Recompute all the widgets of frame F, when the menu bar has been
3270 xg_update_frame_menubar (struct frame
*f
)
3272 struct x_output
*x
= f
->output_data
.x
;
3275 if (!x
->menubar_widget
|| gtk_widget_get_mapped (x
->menubar_widget
))
3278 if (x
->menubar_widget
&& gtk_widget_get_parent (x
->menubar_widget
))
3279 return; /* Already done this, happens for frames created invisible. */
3283 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
,
3285 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
), x
->menubar_widget
, 0);
3287 g_signal_connect (x
->menubar_widget
, "map", G_CALLBACK (menubar_map_cb
), f
);
3288 gtk_widget_show_all (x
->menubar_widget
);
3289 gtk_widget_get_preferred_size (x
->menubar_widget
, NULL
, &req
);
3291 if (FRAME_MENUBAR_HEIGHT (f
) != req
.height
)
3293 FRAME_MENUBAR_HEIGHT (f
) = req
.height
;
3294 xg_height_or_width_changed (f
);
3299 /* Get rid of the menu bar of frame F, and free its storage.
3300 This is used when deleting a frame, and when turning off the menu bar. */
3303 free_frame_menubar (struct frame
*f
)
3305 struct x_output
*x
= f
->output_data
.x
;
3307 if (x
->menubar_widget
)
3311 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
), x
->menubar_widget
);
3312 /* The menubar and its children shall be deleted when removed from
3314 x
->menubar_widget
= 0;
3315 FRAME_MENUBAR_HEIGHT (f
) = 0;
3316 xg_height_or_width_changed (f
);
3322 xg_event_is_for_menubar (struct frame
*f
, const XEvent
*event
)
3324 struct x_output
*x
= f
->output_data
.x
;
3333 if (! x
->menubar_widget
) return 0;
3335 if (! (event
->xbutton
.x
>= 0
3336 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
3337 && event
->xbutton
.y
>= 0
3338 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
3339 && event
->xbutton
.same_screen
))
3342 gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3343 gw
= gdk_x11_window_lookup_for_display (gdpy
, event
->xbutton
.window
);
3345 gevent
.any
.window
= gw
;
3346 gevent
.any
.type
= GDK_NOTHING
;
3347 gwdesc
= gtk_get_event_widget (&gevent
);
3348 if (! gwdesc
) return 0;
3349 if (! GTK_IS_MENU_BAR (gwdesc
)
3350 && ! GTK_IS_MENU_ITEM (gwdesc
)
3351 && ! gtk_widget_is_ancestor (x
->menubar_widget
, gwdesc
))
3354 list
= gtk_container_get_children (GTK_CONTAINER (x
->menubar_widget
));
3355 if (! list
) return 0;
3356 rec
.x
= event
->xbutton
.x
;
3357 rec
.y
= event
->xbutton
.y
;
3361 for (iter
= list
; iter
; iter
= g_list_next (iter
))
3363 GtkWidget
*w
= GTK_WIDGET (iter
->data
);
3364 if (gtk_widget_get_mapped (w
) && gtk_widget_intersect (w
, &rec
, NULL
))
3373 /***********************************************************************
3374 Scroll bar functions
3375 ***********************************************************************/
3378 /* Setting scroll bar values invokes the callback. Use this variable
3379 to indicate that callback should do nothing. */
3381 bool xg_ignore_gtk_scrollbar
;
3383 /* The width of the scroll bar for the current theme. */
3385 static int scroll_bar_width_for_theme
;
3387 /* Xlib's `Window' fits in 32 bits. But we want to store pointers, and they
3388 may be larger than 32 bits. Keep a mapping from integer index to widget
3389 pointers to get around the 32 bit limitation. */
3393 GtkWidget
**widgets
;
3398 /* Grow this much every time we need to allocate more */
3400 #define ID_TO_WIDGET_INCR 32
3402 /* Store the widget pointer W in id_to_widget and return the integer index. */
3405 xg_store_widget_in_map (GtkWidget
*w
)
3409 if (id_to_widget
.max_size
== id_to_widget
.used
)
3412 if (TYPE_MAXIMUM (Window
) - ID_TO_WIDGET_INCR
< id_to_widget
.max_size
)
3413 memory_full (SIZE_MAX
);
3415 new_size
= id_to_widget
.max_size
+ ID_TO_WIDGET_INCR
;
3416 id_to_widget
.widgets
= xnrealloc (id_to_widget
.widgets
,
3417 new_size
, sizeof (GtkWidget
*));
3419 for (i
= id_to_widget
.max_size
; i
< new_size
; ++i
)
3420 id_to_widget
.widgets
[i
] = 0;
3421 id_to_widget
.max_size
= new_size
;
3424 /* Just loop over the array and find a free place. After all,
3425 how many scroll bars are we creating? Should be a small number.
3426 The check above guarantees we will find a free place. */
3427 for (i
= 0; i
< id_to_widget
.max_size
; ++i
)
3429 if (! id_to_widget
.widgets
[i
])
3431 id_to_widget
.widgets
[i
] = w
;
3432 ++id_to_widget
.used
;
3438 /* Should never end up here */
3442 /* Remove pointer at IDX from id_to_widget.
3443 Called when scroll bar is destroyed. */
3446 xg_remove_widget_from_map (ptrdiff_t idx
)
3448 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3450 id_to_widget
.widgets
[idx
] = 0;
3451 --id_to_widget
.used
;
3455 /* Get the widget pointer at IDX from id_to_widget. */
3458 xg_get_widget_from_map (ptrdiff_t idx
)
3460 if (idx
< id_to_widget
.max_size
&& id_to_widget
.widgets
[idx
] != 0)
3461 return id_to_widget
.widgets
[idx
];
3467 update_theme_scrollbar_width (void)
3470 GtkAdjustment
*vadj
;
3477 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
, 0.1, 0.1, 0.1);
3478 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3479 g_object_ref_sink (G_OBJECT (wscroll
));
3480 gtk_widget_style_get (wscroll
, "slider-width", &w
, "trough-border", &b
, NULL
);
3481 gtk_widget_destroy (wscroll
);
3482 g_object_unref (G_OBJECT (wscroll
));
3485 scroll_bar_width_for_theme
= w
;
3489 xg_get_default_scrollbar_width (void)
3491 return scroll_bar_width_for_theme
;
3494 /* Return the scrollbar id for X Window WID on display DPY.
3495 Return -1 if WID not in id_to_widget. */
3498 xg_get_scroll_id_for_window (Display
*dpy
, Window wid
)
3503 w
= xg_win_to_widget (dpy
, wid
);
3507 for (idx
= 0; idx
< id_to_widget
.max_size
; ++idx
)
3508 if (id_to_widget
.widgets
[idx
] == w
)
3515 /* Callback invoked when scroll bar WIDGET is destroyed.
3516 DATA is the index into id_to_widget for WIDGET.
3517 We free pointer to last scroll bar values here and remove the index. */
3520 xg_gtk_scroll_destroy (GtkWidget
*widget
, gpointer data
)
3522 intptr_t id
= (intptr_t) data
;
3523 xg_remove_widget_from_map (id
);
3526 /* Create a scroll bar widget for frame F. Store the scroll bar
3528 SCROLL_CALLBACK is the callback to invoke when the value of the
3530 END_CALLBACK is the callback to invoke when scrolling ends.
3531 SCROLL_BAR_NAME is the name we use for the scroll bar. Can be used
3532 to set resources for the widget. */
3535 xg_create_scroll_bar (struct frame
*f
,
3536 struct scroll_bar
*bar
,
3537 GCallback scroll_callback
,
3538 GCallback end_callback
,
3539 const char *scroll_bar_name
)
3545 GtkAdjustment
*vadj
;
3550 /* Page, step increment values are not so important here, they
3551 will be corrected in x_set_toolkit_scroll_bar_thumb. */
3552 vadj
= gtk_adjustment_new (XG_SB_MIN
, XG_SB_MIN
, XG_SB_MAX
,
3555 wscroll
= gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL
, GTK_ADJUSTMENT (vadj
));
3556 webox
= gtk_event_box_new ();
3557 gtk_widget_set_name (wscroll
, scroll_bar_name
);
3559 gtk_range_set_update_policy (GTK_RANGE (wscroll
), GTK_UPDATE_CONTINUOUS
);
3561 g_object_set_data (G_OBJECT (wscroll
), XG_FRAME_DATA
, (gpointer
)f
);
3563 scroll_id
= xg_store_widget_in_map (wscroll
);
3565 g_signal_connect (G_OBJECT (wscroll
),
3567 G_CALLBACK (xg_gtk_scroll_destroy
),
3568 (gpointer
) scroll_id
);
3569 g_signal_connect (G_OBJECT (wscroll
),
3573 g_signal_connect (G_OBJECT (wscroll
),
3574 "button-release-event",
3578 /* The scroll bar widget does not draw on a window of its own. Instead
3579 it draws on the parent window, in this case the edit widget. So
3580 whenever the edit widget is cleared, the scroll bar needs to redraw
3581 also, which causes flicker. Put an event box between the edit widget
3582 and the scroll bar, so the scroll bar instead draws itself on the
3583 event box window. */
3584 gtk_fixed_put (GTK_FIXED (f
->output_data
.x
->edit_widget
), webox
, -1, -1);
3585 gtk_container_add (GTK_CONTAINER (webox
), wscroll
);
3588 /* Set the cursor to an arrow. */
3589 xg_set_cursor (webox
, FRAME_DISPLAY_INFO (f
)->xg_cursor
);
3591 bar
->x_window
= scroll_id
;
3594 /* Remove the scroll bar represented by SCROLLBAR_ID from the frame F. */
3597 xg_remove_scroll_bar (struct frame
*f
, ptrdiff_t scrollbar_id
)
3599 GtkWidget
*w
= xg_get_widget_from_map (scrollbar_id
);
3602 GtkWidget
*wparent
= gtk_widget_get_parent (w
);
3603 gtk_widget_destroy (w
);
3604 gtk_widget_destroy (wparent
);
3605 SET_FRAME_GARBAGED (f
);
3609 /* Update the position of the vertical scroll bar represented by SCROLLBAR_ID
3611 TOP/LEFT are the new pixel positions where the bar shall appear.
3612 WIDTH, HEIGHT is the size in pixels the bar shall have. */
3615 xg_update_scrollbar_pos (struct frame
*f
,
3616 ptrdiff_t scrollbar_id
,
3623 GtkWidget
*wscroll
= xg_get_widget_from_map (scrollbar_id
);
3627 GtkWidget
*wfixed
= f
->output_data
.x
->edit_widget
;
3628 GtkWidget
*wparent
= gtk_widget_get_parent (wscroll
);
3631 /* Clear out old position. */
3632 int oldx
= -1, oldy
= -1, oldw
, oldh
;
3633 if (gtk_widget_get_parent (wparent
) == wfixed
)
3635 gtk_container_child_get (GTK_CONTAINER (wfixed
), wparent
,
3636 "x", &oldx
, "y", &oldy
, NULL
);
3637 gtk_widget_get_size_request (wscroll
, &oldw
, &oldh
);
3640 /* Move and resize to new values. */
3641 gtk_fixed_move (GTK_FIXED (wfixed
), wparent
, left
, top
);
3642 gtk_widget_style_get (wscroll
, "min-slider-length", &msl
, NULL
);
3645 /* No room. Hide scroll bar as some themes output a warning if
3646 the height is less than the min size. */
3647 gtk_widget_hide (wparent
);
3648 gtk_widget_hide (wscroll
);
3652 gtk_widget_show_all (wparent
);
3653 gtk_widget_set_size_request (wscroll
, width
, height
);
3655 gtk_widget_queue_draw (wfixed
);
3656 gdk_window_process_all_updates ();
3657 if (oldx
!= -1 && oldw
> 0 && oldh
> 0)
3658 /* Clear under old scroll bar position. This must be done after
3659 the gtk_widget_queue_draw and gdk_window_process_all_updates
3661 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3662 oldx
, oldy
, oldw
, oldh
);
3664 /* GTK does not redraw until the main loop is entered again, but
3665 if there are no X events pending we will not enter it. So we sync
3666 here to get some events. */
3669 SET_FRAME_GARBAGED (f
);
3670 cancel_mouse_face (f
);
3674 /* Get the current value of the range, truncated to an integer. */
3677 int_gtk_range_get_value (GtkRange
*range
)
3679 return gtk_range_get_value (range
);
3683 /* Set the thumb size and position of scroll bar BAR. We are currently
3684 displaying PORTION out of a whole WHOLE, and our position POSITION. */
3687 xg_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
,
3692 GtkWidget
*wscroll
= xg_get_widget_from_map (bar
->x_window
);
3694 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3696 if (wscroll
&& bar
->dragging
== -1)
3706 adj
= gtk_range_get_adjustment (GTK_RANGE (wscroll
));
3708 if (scroll_bar_adjust_thumb_portion_p
)
3710 /* We do the same as for MOTIF in xterm.c, use 30 chars per
3711 line rather than the real portion value. This makes the
3712 thumb less likely to resize and that looks better. */
3713 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
3715 /* When the thumb is at the bottom, position == whole.
3716 So we need to increase `whole' to make space for the thumb. */
3724 top
= (gdouble
) position
/ whole
;
3725 shown
= (gdouble
) portion
/ whole
;
3728 size
= clip_to_bounds (1, shown
* XG_SB_RANGE
, XG_SB_RANGE
);
3729 value
= clip_to_bounds (XG_SB_MIN
, top
* XG_SB_RANGE
, XG_SB_MAX
- size
);
3731 /* Assume all lines are of equal size. */
3732 new_step
= size
/ max (1, FRAME_LINES (f
));
3734 old_size
= gtk_adjustment_get_page_size (adj
);
3735 if (old_size
!= size
)
3737 int old_step
= gtk_adjustment_get_step_increment (adj
);
3738 if (old_step
!= new_step
)
3740 gtk_adjustment_set_page_size (adj
, size
);
3741 gtk_adjustment_set_step_increment (adj
, new_step
);
3742 /* Assume a page increment is about 95% of the page size */
3743 gtk_adjustment_set_page_increment (adj
, size
- size
/ 20);
3748 if (changed
|| int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3752 /* gtk_range_set_value invokes the callback. Set
3753 ignore_gtk_scrollbar to make the callback do nothing */
3754 xg_ignore_gtk_scrollbar
= 1;
3756 if (int_gtk_range_get_value (GTK_RANGE (wscroll
)) != value
)
3757 gtk_range_set_value (GTK_RANGE (wscroll
), (gdouble
)value
);
3759 gtk_adjustment_changed (adj
);
3761 xg_ignore_gtk_scrollbar
= 0;
3768 /* Return true if EVENT is for a scroll bar in frame F.
3769 When the same X window is used for several Gtk+ widgets, we cannot
3770 say for sure based on the X window alone if an event is for the
3771 frame. This function does additional checks. */
3774 xg_event_is_for_scrollbar (struct frame
*f
, const XEvent
*event
)
3778 if (f
&& event
->type
== ButtonPress
&& event
->xbutton
.button
< 4)
3780 /* Check if press occurred outside the edit widget. */
3781 GdkDisplay
*gdpy
= gdk_x11_lookup_xdisplay (FRAME_X_DISPLAY (f
));
3784 GdkDevice
*gdev
= gdk_device_manager_get_client_pointer
3785 (gdk_display_get_device_manager (gdpy
));
3786 gwin
= gdk_device_get_window_at_position (gdev
, NULL
, NULL
);
3788 gwin
= gdk_display_get_window_at_pointer (gdpy
, NULL
, NULL
);
3790 retval
= gwin
!= gtk_widget_get_window (f
->output_data
.x
->edit_widget
);
3793 && ((event
->type
== ButtonRelease
&& event
->xbutton
.button
< 4)
3794 || event
->type
== MotionNotify
))
3796 /* If we are releasing or moving the scroll bar, it has the grab. */
3797 GtkWidget
*w
= gtk_grab_get_current ();
3798 retval
= w
!= 0 && GTK_IS_SCROLLBAR (w
);
3806 /***********************************************************************
3808 ***********************************************************************/
3809 /* The key for the data we put in the GtkImage widgets. The data is
3810 the image used by Emacs. We use this to see if we need to update
3811 the GtkImage with a new image. */
3812 #define XG_TOOL_BAR_IMAGE_DATA "emacs-tool-bar-image"
3814 /* The key for storing the latest modifiers so the activate callback can
3816 #define XG_TOOL_BAR_LAST_MODIFIER "emacs-tool-bar-modifier"
3818 /* The key for storing the button widget in its proxy menu item. */
3819 #define XG_TOOL_BAR_PROXY_BUTTON "emacs-tool-bar-proxy-button"
3821 /* The key for the data we put in the GtkImage widgets. The data is
3822 the stock name used by Emacs. We use this to see if we need to update
3823 the GtkImage with a new image. */
3824 #define XG_TOOL_BAR_STOCK_NAME "emacs-tool-bar-stock-name"
3826 /* As above, but this is used for named theme widgets, as opposed to
3828 #define XG_TOOL_BAR_ICON_NAME "emacs-tool-bar-icon-name"
3830 /* Callback function invoked when a tool bar item is pressed.
3831 W is the button widget in the tool bar that got pressed,
3832 CLIENT_DATA is an integer that is the index of the button in the
3833 tool bar. 0 is the first button. */
3836 xg_tool_bar_button_cb (GtkWidget
*widget
,
3837 GdkEventButton
*event
,
3840 intptr_t state
= event
->state
;
3841 gpointer ptr
= (gpointer
) state
;
3842 g_object_set_data (G_OBJECT (widget
), XG_TOOL_BAR_LAST_MODIFIER
, ptr
);
3847 /* Callback function invoked when a tool bar item is pressed.
3848 W is the button widget in the tool bar that got pressed,
3849 CLIENT_DATA is an integer that is the index of the button in the
3850 tool bar. 0 is the first button. */
3853 xg_tool_bar_callback (GtkWidget
*w
, gpointer client_data
)
3855 intptr_t idx
= (intptr_t) client_data
;
3856 gpointer gmod
= g_object_get_data (G_OBJECT (w
), XG_TOOL_BAR_LAST_MODIFIER
);
3857 intptr_t mod
= (intptr_t) gmod
;
3859 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
3860 Lisp_Object key
, frame
;
3861 struct input_event event
;
3864 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
3867 idx
*= TOOL_BAR_ITEM_NSLOTS
;
3869 key
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_KEY
);
3870 XSETFRAME (frame
, f
);
3872 /* We generate two events here. The first one is to set the prefix
3873 to `(tool_bar)', see keyboard.c. */
3874 event
.kind
= TOOL_BAR_EVENT
;
3875 event
.frame_or_window
= frame
;
3877 kbd_buffer_store_event (&event
);
3879 event
.kind
= TOOL_BAR_EVENT
;
3880 event
.frame_or_window
= frame
;
3882 /* Convert between the modifier bits GDK uses and the modifier bits
3883 Emacs uses. This assumes GDK and X masks are the same, which they are when
3885 event
.modifiers
= x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), mod
);
3886 kbd_buffer_store_event (&event
);
3888 /* Return focus to the frame after we have clicked on a detached
3893 /* Callback function invoked when a tool bar item is pressed in a detached
3894 tool bar or the overflow drop down menu.
3895 We just call xg_tool_bar_callback.
3896 W is the menu item widget that got pressed,
3897 CLIENT_DATA is an integer that is the index of the button in the
3898 tool bar. 0 is the first button. */
3901 xg_tool_bar_proxy_callback (GtkWidget
*w
, gpointer client_data
)
3903 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3904 XG_TOOL_BAR_PROXY_BUTTON
));
3905 xg_tool_bar_callback (wbutton
, client_data
);
3910 xg_tool_bar_help_callback (GtkWidget
*w
,
3911 GdkEventCrossing
*event
,
3912 gpointer client_data
);
3914 /* This callback is called when a help is to be shown for an item in
3915 the detached tool bar when the detached tool bar it is not expanded. */
3918 xg_tool_bar_proxy_help_callback (GtkWidget
*w
,
3919 GdkEventCrossing
*event
,
3920 gpointer client_data
)
3922 GtkWidget
*wbutton
= GTK_WIDGET (g_object_get_data (G_OBJECT (w
),
3923 XG_TOOL_BAR_PROXY_BUTTON
));
3925 return xg_tool_bar_help_callback (wbutton
, event
, client_data
);
3929 xg_get_tool_bar_widgets (GtkWidget
*vb
, GtkWidget
**wimage
)
3931 GList
*clist
= gtk_container_get_children (GTK_CONTAINER (vb
));
3932 GtkWidget
*c1
= clist
->data
;
3933 GtkWidget
*c2
= clist
->next
? clist
->next
->data
: NULL
;
3935 *wimage
= GTK_IS_IMAGE (c1
) ? c1
: c2
;
3936 g_list_free (clist
);
3937 return GTK_IS_LABEL (c1
) ? c1
: c2
;
3941 /* This callback is called when a tool item should create a proxy item,
3942 such as for the overflow menu. Also called when the tool bar is detached.
3943 If we don't create a proxy menu item, the detached tool bar will be
3947 xg_tool_bar_menu_proxy (GtkToolItem
*toolitem
, gpointer user_data
)
3949 GtkButton
*wbutton
= GTK_BUTTON (XG_BIN_CHILD (XG_BIN_CHILD (toolitem
)));
3950 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
3952 GtkLabel
*wlbl
= GTK_LABEL (xg_get_tool_bar_widgets (vb
, &c1
));
3953 GtkImage
*wimage
= GTK_IMAGE (c1
);
3954 GtkWidget
*wmenuitem
= gtk_image_menu_item_new_with_label
3955 (wlbl
? gtk_label_get_text (wlbl
) : "");
3956 GtkWidget
*wmenuimage
;
3959 if (gtk_button_get_use_stock (wbutton
))
3960 wmenuimage
= gtk_image_new_from_stock (gtk_button_get_label (wbutton
),
3961 GTK_ICON_SIZE_MENU
);
3964 GtkSettings
*settings
= gtk_widget_get_settings (GTK_WIDGET (wbutton
));
3965 GtkImageType store_type
= gtk_image_get_storage_type (wimage
);
3967 g_object_set (G_OBJECT (settings
), "gtk-menu-images", TRUE
, NULL
);
3969 if (store_type
== GTK_IMAGE_STOCK
)
3972 gtk_image_get_stock (wimage
, &stock_id
, NULL
);
3973 wmenuimage
= gtk_image_new_from_stock (stock_id
, GTK_ICON_SIZE_MENU
);
3975 else if (store_type
== GTK_IMAGE_ICON_SET
)
3977 GtkIconSet
*icon_set
;
3978 gtk_image_get_icon_set (wimage
, &icon_set
, NULL
);
3979 wmenuimage
= gtk_image_new_from_icon_set (icon_set
,
3980 GTK_ICON_SIZE_MENU
);
3982 else if (store_type
== GTK_IMAGE_PIXBUF
)
3987 gtk_icon_size_lookup_for_settings (settings
, GTK_ICON_SIZE_MENU
,
3990 GdkPixbuf
*src_pixbuf
, *dest_pixbuf
;
3992 src_pixbuf
= gtk_image_get_pixbuf (wimage
);
3993 dest_pixbuf
= gdk_pixbuf_scale_simple (src_pixbuf
, width
, height
,
3994 GDK_INTERP_BILINEAR
);
3996 wmenuimage
= gtk_image_new_from_pixbuf (dest_pixbuf
);
4000 fprintf (stderr
, "internal error: GTK_IMAGE_PIXBUF failed\n");
4004 else if (store_type
== GTK_IMAGE_ICON_NAME
)
4006 const gchar
*icon_name
;
4007 GtkIconSize icon_size
;
4009 gtk_image_get_icon_name (wimage
, &icon_name
, &icon_size
);
4010 wmenuimage
= gtk_image_new_from_icon_name (icon_name
,
4011 GTK_ICON_SIZE_MENU
);
4015 fprintf (stderr
, "internal error: store_type is %d\n", store_type
);
4020 gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (wmenuitem
), wmenuimage
);
4022 g_signal_connect (G_OBJECT (wmenuitem
),
4024 G_CALLBACK (xg_tool_bar_proxy_callback
),
4028 g_object_set_data (G_OBJECT (wmenuitem
), XG_TOOL_BAR_PROXY_BUTTON
,
4029 (gpointer
) wbutton
);
4030 gtk_tool_item_set_proxy_menu_item (toolitem
, "Emacs toolbar item", wmenuitem
);
4031 gtk_widget_set_sensitive (wmenuitem
,
4032 gtk_widget_get_sensitive (GTK_WIDGET (wbutton
)));
4034 /* Use enter/leave notify to show help. We use the events
4035 rather than the GtkButton specific signals "enter" and
4036 "leave", so we can have only one callback. The event
4037 will tell us what kind of event it is. */
4038 g_signal_connect (G_OBJECT (wmenuitem
),
4039 "enter-notify-event",
4040 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4042 g_signal_connect (G_OBJECT (wmenuitem
),
4043 "leave-notify-event",
4044 G_CALLBACK (xg_tool_bar_proxy_help_callback
),
4050 /* This callback is called when a tool bar is detached. We must set
4051 the height of the tool bar to zero when this happens so frame sizes
4052 are correctly calculated.
4053 WBOX is the handle box widget that enables detach/attach of the tool bar.
4054 W is the tool bar widget.
4055 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4058 xg_tool_bar_detach_callback (GtkHandleBox
*wbox
,
4060 gpointer client_data
)
4062 struct frame
*f
= client_data
;
4064 g_object_set (G_OBJECT (w
), "show-arrow", !x_gtk_whole_detached_tool_bar
,
4069 GtkRequisition req
, req2
;
4071 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4072 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4073 req
.width
-= req2
.width
;
4074 req
.height
-= req2
.height
;
4075 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4076 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4077 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4078 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4079 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4080 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4081 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4082 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4083 xg_height_or_width_changed (f
);
4087 /* This callback is called when a tool bar is reattached. We must set
4088 the height of the tool bar when this happens so frame sizes
4089 are correctly calculated.
4090 WBOX is the handle box widget that enables detach/attach of the tool bar.
4091 W is the tool bar widget.
4092 CLIENT_DATA is a pointer to the frame the tool bar belongs to. */
4095 xg_tool_bar_attach_callback (GtkHandleBox
*wbox
,
4097 gpointer client_data
)
4099 struct frame
*f
= client_data
;
4100 g_object_set (G_OBJECT (w
), "show-arrow", TRUE
, NULL
);
4104 GtkRequisition req
, req2
;
4106 gtk_widget_get_preferred_size (GTK_WIDGET (wbox
), NULL
, &req
);
4107 gtk_widget_get_preferred_size (w
, NULL
, &req2
);
4108 req
.width
+= req2
.width
;
4109 req
.height
+= req2
.height
;
4110 if (FRAME_TOOLBAR_TOP_HEIGHT (f
) != 0)
4111 FRAME_TOOLBAR_TOP_HEIGHT (f
) = req
.height
;
4112 else if (FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) != 0)
4113 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = req
.height
;
4114 else if (FRAME_TOOLBAR_RIGHT_WIDTH (f
) != 0)
4115 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = req
.width
;
4116 else if (FRAME_TOOLBAR_LEFT_WIDTH (f
) != 0)
4117 FRAME_TOOLBAR_LEFT_WIDTH (f
) = req
.width
;
4118 xg_height_or_width_changed (f
);
4122 /* This callback is called when the mouse enters or leaves a tool bar item.
4123 It is used for displaying and hiding the help text.
4124 W is the tool bar item, a button.
4125 EVENT is either an enter event or leave event.
4126 CLIENT_DATA is an integer that is the index of the button in the
4127 tool bar. 0 is the first button.
4129 Returns FALSE to tell GTK to keep processing this event. */
4132 xg_tool_bar_help_callback (GtkWidget
*w
,
4133 GdkEventCrossing
*event
,
4134 gpointer client_data
)
4136 intptr_t idx
= (intptr_t) client_data
;
4137 struct frame
*f
= g_object_get_data (G_OBJECT (w
), XG_FRAME_DATA
);
4138 Lisp_Object help
, frame
;
4140 if (! f
|| ! f
->n_tool_bar_items
|| NILP (f
->tool_bar_items
))
4143 if (event
->type
== GDK_ENTER_NOTIFY
)
4145 idx
*= TOOL_BAR_ITEM_NSLOTS
;
4146 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_HELP
);
4149 help
= AREF (f
->tool_bar_items
, idx
+ TOOL_BAR_ITEM_CAPTION
);
4154 XSETFRAME (frame
, f
);
4155 kbd_buffer_store_help_event (frame
, help
);
4161 /* This callback is called when a tool bar item shall be redrawn.
4162 It modifies the expose event so that the GtkImage widget redraws the
4163 whole image. This to overcome a bug that makes GtkImage draw the image
4164 in the wrong place when it tries to redraw just a part of the image.
4165 W is the GtkImage to be redrawn.
4166 EVENT is the expose event for W.
4167 CLIENT_DATA is unused.
4169 Returns FALSE to tell GTK to keep processing this event. */
4173 xg_tool_bar_item_expose_callback (GtkWidget
*w
,
4174 GdkEventExpose
*event
,
4175 gpointer client_data
)
4179 gdk_drawable_get_size (event
->window
, &width
, &height
);
4180 event
->area
.x
-= width
> event
->area
.width
? width
-event
->area
.width
: 0;
4181 event
->area
.y
-= height
> event
->area
.height
? height
-event
->area
.height
: 0;
4183 event
->area
.x
= max (0, event
->area
.x
);
4184 event
->area
.y
= max (0, event
->area
.y
);
4186 event
->area
.width
= max (width
, event
->area
.width
);
4187 event
->area
.height
= max (height
, event
->area
.height
);
4193 #ifdef HAVE_GTK_ORIENTABLE_SET_ORIENTATION
4194 #define toolbar_set_orientation(w, o) \
4195 gtk_orientable_set_orientation (GTK_ORIENTABLE (w), o)
4197 #define toolbar_set_orientation(w, o) \
4198 gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
4201 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4202 #define TOOLBAR_TOP_WIDGET(x) ((x)->handlebox_widget)
4204 #define TOOLBAR_TOP_WIDGET(x) ((x)->toolbar_widget)
4207 /* Attach a tool bar to frame F. */
4210 xg_pack_tool_bar (struct frame
*f
, Lisp_Object pos
)
4212 struct x_output
*x
= f
->output_data
.x
;
4213 bool into_hbox
= EQ (pos
, Qleft
) || EQ (pos
, Qright
);
4214 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4216 toolbar_set_orientation (x
->toolbar_widget
,
4218 ? GTK_ORIENTATION_VERTICAL
4219 : GTK_ORIENTATION_HORIZONTAL
);
4220 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4221 if (!x
->handlebox_widget
)
4223 top_widget
= x
->handlebox_widget
= gtk_handle_box_new ();
4224 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-detached",
4225 G_CALLBACK (xg_tool_bar_detach_callback
), f
);
4226 g_signal_connect (G_OBJECT (x
->handlebox_widget
), "child-attached",
4227 G_CALLBACK (xg_tool_bar_attach_callback
), f
);
4228 gtk_container_add (GTK_CONTAINER (x
->handlebox_widget
),
4235 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4236 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4239 gtk_box_pack_start (GTK_BOX (x
->hbox_widget
), top_widget
,
4242 if (EQ (pos
, Qleft
))
4243 gtk_box_reorder_child (GTK_BOX (x
->hbox_widget
),
4246 x
->toolbar_in_hbox
= true;
4250 bool vbox_pos
= x
->menubar_widget
!= 0;
4251 #ifdef HAVE_GTK_HANDLE_BOX_NEW
4252 gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x
->handlebox_widget
),
4255 gtk_box_pack_start (GTK_BOX (x
->vbox_widget
), top_widget
,
4259 gtk_box_reorder_child (GTK_BOX (x
->vbox_widget
),
4262 x
->toolbar_in_hbox
= false;
4264 x
->toolbar_is_packed
= true;
4267 static bool xg_update_tool_bar_sizes (struct frame
*f
);
4270 tb_size_cb (GtkWidget
*widget
,
4271 GdkRectangle
*allocation
,
4274 /* When tool bar is created it has one preferred size. But when size is
4275 allocated between widgets, it may get another. So we must update
4276 size hints if tool bar size changes. Seen on Fedora 18 at least. */
4277 struct frame
*f
= user_data
;
4278 if (xg_update_tool_bar_sizes (f
))
4279 xg_height_or_width_changed (f
);
4282 /* Create a tool bar for frame F. */
4285 xg_create_tool_bar (struct frame
*f
)
4287 struct x_output
*x
= f
->output_data
.x
;
4288 #if GTK_CHECK_VERSION (3, 3, 6)
4289 GtkStyleContext
*gsty
;
4291 struct xg_frame_tb_info
*tbinfo
4292 = g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4296 tbinfo
= xmalloc (sizeof (*tbinfo
));
4297 tbinfo
->last_tool_bar
= Qnil
;
4298 tbinfo
->style
= Qnil
;
4299 tbinfo
->hmargin
= tbinfo
->vmargin
= 0;
4300 tbinfo
->dir
= GTK_TEXT_DIR_NONE
;
4301 tbinfo
->n_last_items
= 0;
4302 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4307 x
->toolbar_widget
= gtk_toolbar_new ();
4309 gtk_widget_set_name (x
->toolbar_widget
, "emacs-toolbar");
4311 gtk_toolbar_set_style (GTK_TOOLBAR (x
->toolbar_widget
), GTK_TOOLBAR_ICONS
);
4312 toolbar_set_orientation (x
->toolbar_widget
, GTK_ORIENTATION_HORIZONTAL
);
4313 g_signal_connect (x
->toolbar_widget
, "size-allocate",
4314 G_CALLBACK (tb_size_cb
), f
);
4315 #if GTK_CHECK_VERSION (3, 3, 6)
4316 gsty
= gtk_widget_get_style_context (x
->toolbar_widget
);
4317 gtk_style_context_add_class (gsty
, "primary-toolbar");
4322 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
4324 /* Find the right-to-left image named by RTL in the tool bar images for F.
4325 Returns IMAGE if RTL is not found. */
4328 find_rtl_image (struct frame
*f
, Lisp_Object image
, Lisp_Object rtl
)
4331 Lisp_Object file
, rtl_name
;
4332 struct gcpro gcpro1
, gcpro2
;
4333 GCPRO2 (file
, rtl_name
);
4335 rtl_name
= Ffile_name_nondirectory (rtl
);
4337 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
4339 Lisp_Object rtl_image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4340 if (!NILP (file
= file_for_image (rtl_image
)))
4342 file
= call1 (intern ("file-name-sans-extension"),
4343 Ffile_name_nondirectory (file
));
4344 if (! NILP (Fequal (file
, rtl_name
)))
4355 static GtkToolItem
*
4356 xg_make_tool_item (struct frame
*f
,
4358 GtkWidget
**wbutton
,
4360 int i
, bool horiz
, bool text_image
)
4362 GtkToolItem
*ti
= gtk_tool_item_new ();
4363 GtkWidget
*vb
= gtk_box_new (horiz
4364 ? GTK_ORIENTATION_HORIZONTAL
4365 : GTK_ORIENTATION_VERTICAL
,
4367 GtkWidget
*wb
= gtk_button_new ();
4368 /* The eventbox is here so we can have tooltips on disabled items. */
4369 GtkWidget
*weventbox
= gtk_event_box_new ();
4370 #if GTK_CHECK_VERSION (3, 3, 6)
4371 GtkCssProvider
*css_prov
= gtk_css_provider_new ();
4372 GtkStyleContext
*gsty
;
4374 gtk_css_provider_load_from_data (css_prov
,
4376 " background-color: transparent;"
4380 gsty
= gtk_widget_get_style_context (weventbox
);
4381 gtk_style_context_add_provider (gsty
,
4382 GTK_STYLE_PROVIDER (css_prov
),
4383 GTK_STYLE_PROVIDER_PRIORITY_USER
);
4384 g_object_unref (css_prov
);
4387 gtk_box_set_homogeneous (GTK_BOX (vb
), FALSE
);
4389 if (wimage
&& !text_image
)
4390 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4392 gtk_box_pack_start (GTK_BOX (vb
), gtk_label_new (label
), TRUE
, TRUE
, 0);
4393 if (wimage
&& text_image
)
4394 gtk_box_pack_start (GTK_BOX (vb
), wimage
, TRUE
, TRUE
, 0);
4396 gtk_button_set_focus_on_click (GTK_BUTTON (wb
), FALSE
);
4397 gtk_button_set_relief (GTK_BUTTON (wb
), GTK_RELIEF_NONE
);
4398 gtk_container_add (GTK_CONTAINER (wb
), vb
);
4399 gtk_container_add (GTK_CONTAINER (weventbox
), wb
);
4400 gtk_container_add (GTK_CONTAINER (ti
), weventbox
);
4402 if (wimage
|| label
)
4405 gpointer gi
= (gpointer
) ii
;
4407 g_signal_connect (G_OBJECT (ti
), "create-menu-proxy",
4408 G_CALLBACK (xg_tool_bar_menu_proxy
),
4411 g_signal_connect (G_OBJECT (wb
), "clicked",
4412 G_CALLBACK (xg_tool_bar_callback
),
4415 g_object_set_data (G_OBJECT (weventbox
), XG_FRAME_DATA
, (gpointer
)f
);
4418 /* Catch expose events to overcome an annoying redraw bug, see
4419 comment for xg_tool_bar_item_expose_callback. */
4420 g_signal_connect (G_OBJECT (ti
),
4422 G_CALLBACK (xg_tool_bar_item_expose_callback
),
4425 gtk_tool_item_set_homogeneous (ti
, FALSE
);
4427 /* Callback to save modifier mask (Shift/Control, etc). GTK makes
4428 no distinction based on modifiers in the activate callback,
4429 so we have to do it ourselves. */
4430 g_signal_connect (wb
, "button-release-event",
4431 G_CALLBACK (xg_tool_bar_button_cb
),
4434 g_object_set_data (G_OBJECT (wb
), XG_FRAME_DATA
, (gpointer
)f
);
4436 /* Use enter/leave notify to show help. We use the events
4437 rather than the GtkButton specific signals "enter" and
4438 "leave", so we can have only one callback. The event
4439 will tell us what kind of event it is. */
4440 g_signal_connect (G_OBJECT (weventbox
),
4441 "enter-notify-event",
4442 G_CALLBACK (xg_tool_bar_help_callback
),
4444 g_signal_connect (G_OBJECT (weventbox
),
4445 "leave-notify-event",
4446 G_CALLBACK (xg_tool_bar_help_callback
),
4450 if (wbutton
) *wbutton
= wb
;
4456 is_box_type (GtkWidget
*vb
, bool is_horizontal
)
4460 if (GTK_IS_BOX (vb
))
4462 GtkOrientation ori
= gtk_orientable_get_orientation (GTK_ORIENTABLE (vb
));
4463 ret
= (ori
== GTK_ORIENTATION_HORIZONTAL
&& is_horizontal
)
4464 || (ori
== GTK_ORIENTATION_VERTICAL
&& ! is_horizontal
);
4468 return is_horizontal
? GTK_IS_VBOX (vb
) : GTK_IS_HBOX (vb
);
4474 xg_tool_item_stale_p (GtkWidget
*wbutton
, const char *stock_name
,
4475 const char *icon_name
, const struct image
*img
,
4476 const char *label
, bool horiz
)
4480 GtkWidget
*vb
= XG_BIN_CHILD (wbutton
);
4481 GtkWidget
*wlbl
= xg_get_tool_bar_widgets (vb
, &wimage
);
4483 /* Check if the tool icon matches. */
4484 if (stock_name
&& wimage
)
4486 old
= g_object_get_data (G_OBJECT (wimage
),
4487 XG_TOOL_BAR_STOCK_NAME
);
4488 if (!old
|| strcmp (old
, stock_name
))
4491 else if (icon_name
&& wimage
)
4493 old
= g_object_get_data (G_OBJECT (wimage
),
4494 XG_TOOL_BAR_ICON_NAME
);
4495 if (!old
|| strcmp (old
, icon_name
))
4500 gpointer gold_img
= g_object_get_data (G_OBJECT (wimage
),
4501 XG_TOOL_BAR_IMAGE_DATA
);
4502 Pixmap old_img
= (Pixmap
) gold_img
;
4503 if (old_img
!= img
->pixmap
)
4507 /* Check button configuration and label. */
4508 if (is_box_type (vb
, horiz
)
4509 || (label
? (wlbl
== NULL
) : (wlbl
!= NULL
)))
4512 /* Ensure label is correct. */
4514 gtk_label_set_text (GTK_LABEL (wlbl
), label
);
4519 xg_update_tool_bar_sizes (struct frame
*f
)
4521 struct x_output
*x
= f
->output_data
.x
;
4523 int nl
= 0, nr
= 0, nt
= 0, nb
= 0;
4524 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4526 gtk_widget_get_preferred_size (GTK_WIDGET (top_widget
), NULL
, &req
);
4527 if (x
->toolbar_in_hbox
)
4530 gtk_container_child_get (GTK_CONTAINER (x
->hbox_widget
),
4532 "position", &pos
, NULL
);
4533 if (pos
== 0) nl
= req
.width
;
4534 else nr
= req
.width
;
4539 gtk_container_child_get (GTK_CONTAINER (x
->vbox_widget
),
4541 "position", &pos
, NULL
);
4542 if (pos
== 0 || (pos
== 1 && x
->menubar_widget
)) nt
= req
.height
;
4543 else nb
= req
.height
;
4546 if (nl
!= FRAME_TOOLBAR_LEFT_WIDTH (f
)
4547 || nr
!= FRAME_TOOLBAR_RIGHT_WIDTH (f
)
4548 || nt
!= FRAME_TOOLBAR_TOP_HEIGHT (f
)
4549 || nb
!= FRAME_TOOLBAR_BOTTOM_HEIGHT (f
))
4551 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = FRAME_TOOLBAR_LEFT_WIDTH (f
)
4552 = FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4553 FRAME_TOOLBAR_LEFT_WIDTH (f
) = nl
;
4554 FRAME_TOOLBAR_RIGHT_WIDTH (f
) = nr
;
4555 FRAME_TOOLBAR_TOP_HEIGHT (f
) = nt
;
4556 FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = nb
;
4564 /* Update the tool bar for frame F. Add new buttons and remove old. */
4567 update_frame_tool_bar (struct frame
*f
)
4570 struct x_output
*x
= f
->output_data
.x
;
4571 int hmargin
= 0, vmargin
= 0;
4572 GtkToolbar
*wtoolbar
;
4574 GtkTextDirection dir
;
4576 bool text_image
, horiz
;
4577 struct xg_frame_tb_info
*tbinfo
;
4579 if (! FRAME_GTK_WIDGET (f
))
4584 if (RANGED_INTEGERP (1, Vtool_bar_button_margin
, INT_MAX
))
4586 hmargin
= XFASTINT (Vtool_bar_button_margin
);
4587 vmargin
= XFASTINT (Vtool_bar_button_margin
);
4589 else if (CONSP (Vtool_bar_button_margin
))
4591 if (RANGED_INTEGERP (1, XCAR (Vtool_bar_button_margin
), INT_MAX
))
4592 hmargin
= XFASTINT (XCAR (Vtool_bar_button_margin
));
4594 if (RANGED_INTEGERP (1, XCDR (Vtool_bar_button_margin
), INT_MAX
))
4595 vmargin
= XFASTINT (XCDR (Vtool_bar_button_margin
));
4598 /* The natural size (i.e. when GTK uses 0 as margin) looks best,
4599 so take DEFAULT_TOOL_BAR_BUTTON_MARGIN to mean "default for GTK",
4600 i.e. zero. This means that margins less than
4601 DEFAULT_TOOL_BAR_BUTTON_MARGIN has no effect. */
4602 hmargin
= max (0, hmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4603 vmargin
= max (0, vmargin
- DEFAULT_TOOL_BAR_BUTTON_MARGIN
);
4605 if (! x
->toolbar_widget
)
4606 xg_create_tool_bar (f
);
4608 wtoolbar
= GTK_TOOLBAR (x
->toolbar_widget
);
4609 dir
= gtk_widget_get_direction (GTK_WIDGET (wtoolbar
));
4611 style
= Ftool_bar_get_system_style ();
4613 /* Are we up to date? */
4614 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4617 if (! NILP (tbinfo
->last_tool_bar
) && ! NILP (f
->tool_bar_items
)
4618 && tbinfo
->n_last_items
== f
->n_tool_bar_items
4619 && tbinfo
->hmargin
== hmargin
&& tbinfo
->vmargin
== vmargin
4620 && tbinfo
->dir
== dir
4621 && ! NILP (Fequal (tbinfo
->style
, style
))
4622 && ! NILP (Fequal (tbinfo
->last_tool_bar
, f
->tool_bar_items
)))
4628 tbinfo
->last_tool_bar
= f
->tool_bar_items
;
4629 tbinfo
->n_last_items
= f
->n_tool_bar_items
;
4630 tbinfo
->style
= style
;
4631 tbinfo
->hmargin
= hmargin
;
4632 tbinfo
->vmargin
= vmargin
;
4635 text_image
= EQ (style
, Qtext_image_horiz
);
4636 horiz
= EQ (style
, Qboth_horiz
) || text_image
;
4638 for (i
= j
= 0; i
< f
->n_tool_bar_items
; ++i
)
4640 bool enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
4641 bool selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
4645 struct image
*img
= NULL
;
4647 Lisp_Object stock
= Qnil
;
4648 GtkStockItem stock_item
;
4649 char *stock_name
= NULL
;
4650 char *icon_name
= NULL
;
4652 GtkWidget
*wbutton
= NULL
;
4653 Lisp_Object specified_file
;
4654 bool vert_only
= ! NILP (PROP (TOOL_BAR_ITEM_VERT_ONLY
));
4656 = (EQ (style
, Qimage
) || (vert_only
&& horiz
)) ? NULL
4657 : STRINGP (PROP (TOOL_BAR_ITEM_LABEL
))
4658 ? SSDATA (PROP (TOOL_BAR_ITEM_LABEL
))
4661 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4663 /* If this is a separator, use a gtk separator item. */
4664 if (EQ (PROP (TOOL_BAR_ITEM_TYPE
), Qt
))
4666 if (ti
== NULL
|| !GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4669 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4671 ti
= gtk_separator_tool_item_new ();
4672 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4678 /* Otherwise, the tool-bar item is an ordinary button. */
4680 if (ti
&& GTK_IS_SEPARATOR_TOOL_ITEM (ti
))
4682 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4686 if (ti
) wbutton
= XG_BIN_CHILD (XG_BIN_CHILD (ti
));
4688 /* Ignore invalid image specifications. */
4689 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
4690 if (!valid_image_p (image
))
4693 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4698 specified_file
= file_for_image (image
);
4699 if (!NILP (specified_file
) && !NILP (Ffboundp (Qx_gtk_map_stock
)))
4700 stock
= call1 (Qx_gtk_map_stock
, specified_file
);
4702 if (STRINGP (stock
))
4704 stock_name
= SSDATA (stock
);
4705 if (stock_name
[0] == 'n' && stock_name
[1] == ':')
4707 GdkScreen
*screen
= gtk_widget_get_screen (GTK_WIDGET (wtoolbar
));
4708 GtkIconTheme
*icon_theme
= gtk_icon_theme_get_for_screen (screen
);
4710 icon_name
= stock_name
+ 2;
4714 if (! gtk_icon_theme_has_icon (icon_theme
, icon_name
))
4717 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4719 else if (gtk_stock_lookup (SSDATA (stock
), &stock_item
))
4720 icon_size
= gtk_toolbar_get_icon_size (wtoolbar
);
4728 if (stock_name
== NULL
&& icon_name
== NULL
)
4730 /* No stock image, or stock item not known. Try regular
4731 image. If image is a vector, choose it according to the
4733 if (dir
== GTK_TEXT_DIR_RTL
4734 && !NILP (rtl
= PROP (TOOL_BAR_ITEM_RTL_IMAGE
))
4736 image
= find_rtl_image (f
, image
, rtl
);
4738 if (VECTORP (image
))
4742 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
4743 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
4746 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
4747 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
4749 eassert (ASIZE (image
) >= idx
);
4750 image
= AREF (image
, idx
);
4755 img_id
= lookup_image (f
, image
);
4756 img
= IMAGE_FROM_ID (f
, img_id
);
4757 prepare_image_for_display (f
, img
);
4759 if (img
->load_failed_p
|| img
->pixmap
== None
)
4762 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4768 /* If there is an existing widget, check if it's stale; if so,
4769 remove it and make a new tool item from scratch. */
4770 if (ti
&& xg_tool_item_stale_p (wbutton
, stock_name
, icon_name
,
4773 gtk_container_remove (GTK_CONTAINER (wtoolbar
),
4782 /* Save the image so we can see if an update is needed the
4783 next time we call xg_tool_item_match_p. */
4784 if (EQ (style
, Qtext
))
4786 else if (stock_name
)
4788 w
= gtk_image_new_from_stock (stock_name
, icon_size
);
4789 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_STOCK_NAME
,
4790 (gpointer
) xstrdup (stock_name
),
4791 (GDestroyNotify
) xfree
);
4795 w
= gtk_image_new_from_icon_name (icon_name
, icon_size
);
4796 g_object_set_data_full (G_OBJECT (w
), XG_TOOL_BAR_ICON_NAME
,
4797 (gpointer
) xstrdup (icon_name
),
4798 (GDestroyNotify
) xfree
);
4802 w
= xg_get_image_for_pixmap (f
, img
, x
->widget
, NULL
);
4803 g_object_set_data (G_OBJECT (w
), XG_TOOL_BAR_IMAGE_DATA
,
4804 (gpointer
)img
->pixmap
);
4807 if (w
) gtk_misc_set_padding (GTK_MISC (w
), hmargin
, vmargin
);
4808 ti
= xg_make_tool_item (f
, w
, &wbutton
, label
, i
, horiz
, text_image
);
4809 gtk_toolbar_insert (GTK_TOOLBAR (wtoolbar
), ti
, j
);
4814 gtk_widget_set_sensitive (wbutton
, enabled_p
);
4818 /* Remove buttons not longer needed. */
4821 ti
= gtk_toolbar_get_nth_item (GTK_TOOLBAR (wtoolbar
), j
);
4823 gtk_container_remove (GTK_CONTAINER (wtoolbar
), GTK_WIDGET (ti
));
4824 } while (ti
!= NULL
);
4826 if (f
->n_tool_bar_items
!= 0)
4828 if (! x
->toolbar_is_packed
)
4829 xg_pack_tool_bar (f
, f
->tool_bar_position
);
4830 gtk_widget_show_all (TOOLBAR_TOP_WIDGET (x
));
4831 if (xg_update_tool_bar_sizes (f
))
4832 xg_height_or_width_changed (f
);
4838 /* Deallocate all resources for the tool bar on frame F.
4839 Remove the tool bar. */
4842 free_frame_tool_bar (struct frame
*f
)
4844 struct x_output
*x
= f
->output_data
.x
;
4846 if (x
->toolbar_widget
)
4848 struct xg_frame_tb_info
*tbinfo
;
4849 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4852 /* We may have created the toolbar_widget in xg_create_tool_bar, but
4853 not the x->handlebox_widget which is created in xg_pack_tool_bar. */
4854 if (x
->toolbar_is_packed
)
4856 if (x
->toolbar_in_hbox
)
4857 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4860 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4864 gtk_widget_destroy (x
->toolbar_widget
);
4866 x
->toolbar_widget
= 0;
4867 TOOLBAR_TOP_WIDGET (x
) = 0;
4868 x
->toolbar_is_packed
= false;
4869 FRAME_TOOLBAR_TOP_HEIGHT (f
) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f
) = 0;
4870 FRAME_TOOLBAR_LEFT_WIDTH (f
) = FRAME_TOOLBAR_RIGHT_WIDTH (f
) = 0;
4872 tbinfo
= g_object_get_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4877 g_object_set_data (G_OBJECT (FRAME_GTK_OUTER_WIDGET (f
)),
4882 xg_height_or_width_changed (f
);
4889 xg_change_toolbar_position (struct frame
*f
, Lisp_Object pos
)
4891 struct x_output
*x
= f
->output_data
.x
;
4892 GtkWidget
*top_widget
= TOOLBAR_TOP_WIDGET (x
);
4894 if (! x
->toolbar_widget
|| ! top_widget
)
4898 g_object_ref (top_widget
);
4899 if (x
->toolbar_is_packed
)
4901 if (x
->toolbar_in_hbox
)
4902 gtk_container_remove (GTK_CONTAINER (x
->hbox_widget
),
4905 gtk_container_remove (GTK_CONTAINER (x
->vbox_widget
),
4909 xg_pack_tool_bar (f
, pos
);
4910 g_object_unref (top_widget
);
4911 if (xg_update_tool_bar_sizes (f
))
4912 xg_height_or_width_changed (f
);
4919 /***********************************************************************
4921 ***********************************************************************/
4923 xg_initialize (void)
4925 GtkBindingSet
*binding_set
;
4926 GtkSettings
*settings
;
4929 /* Work around a bug with corrupted data if libXft gets unloaded. This way
4930 we keep it permanently linked in. */
4935 xg_ignore_gtk_scrollbar
= 0;
4936 #ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
4937 xg_detached_menus
= 0;
4939 xg_menu_cb_list
.prev
= xg_menu_cb_list
.next
=
4940 xg_menu_item_cb_list
.prev
= xg_menu_item_cb_list
.next
= 0;
4942 id_to_widget
.max_size
= id_to_widget
.used
= 0;
4943 id_to_widget
.widgets
= 0;
4945 settings
= gtk_settings_get_for_screen (gdk_display_get_default_screen
4946 (gdk_display_get_default ()));
4947 /* Remove F10 as a menu accelerator, it does not mix well with Emacs key
4948 bindings. It doesn't seem to be any way to remove properties,
4949 so we set it to "" which in means "no key". */
4950 gtk_settings_set_string_property (settings
,
4951 "gtk-menu-bar-accel",
4955 /* Make GTK text input widgets use Emacs style keybindings. This is
4957 gtk_settings_set_string_property (settings
,
4958 "gtk-key-theme-name",
4962 /* Make dialogs close on C-g. Since file dialog inherits from
4963 dialog, this works for them also. */
4964 binding_set
= gtk_binding_set_by_class (g_type_class_ref (GTK_TYPE_DIALOG
));
4965 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4968 /* Make menus close on C-g. */
4969 binding_set
= gtk_binding_set_by_class (g_type_class_ref
4970 (GTK_TYPE_MENU_SHELL
));
4971 gtk_binding_entry_add_signal (binding_set
, GDK_KEY_g
, GDK_CONTROL_MASK
,
4973 update_theme_scrollbar_width ();
4975 #ifdef HAVE_FREETYPE
4976 x_last_font_name
= NULL
;
4980 #endif /* USE_GTK */